From 742c4385220e510a108b776d36af3c8570fdbc1d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 22 Feb 2023 23:56:44 +0100
Subject: [PATCH 001/506] Fix builtins checks for nil args

---
 builtin/builtin.go      | 15 +++++++++++----
 checker/checker_test.go | 18 ++++++++++++++++++
 2 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 4ea819a7f..ad9376962 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -34,7 +34,7 @@ var Builtins = map[int]*Function{
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for len (expected 1, got %d)", len(args))
 			}
-			switch args[0].Kind() {
+			switch kind(args[0]) {
 			case reflect.Array, reflect.Map, reflect.Slice, reflect.String, reflect.Interface:
 				return integerType, nil
 			}
@@ -48,7 +48,7 @@ var Builtins = map[int]*Function{
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for abs (expected 1, got %d)", len(args))
 			}
-			switch args[0].Kind() {
+			switch kind(args[0]) {
 			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
 				return args[0], nil
 			}
@@ -62,7 +62,7 @@ var Builtins = map[int]*Function{
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for int (expected 1, got %d)", len(args))
 			}
-			switch args[0].Kind() {
+			switch kind(args[0]) {
 			case reflect.Interface:
 				return integerType, nil
 			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
@@ -80,7 +80,7 @@ var Builtins = map[int]*Function{
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for float (expected 1, got %d)", len(args))
 			}
-			switch args[0].Kind() {
+			switch kind(args[0]) {
 			case reflect.Interface:
 				return floatType, nil
 			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
@@ -92,3 +92,10 @@ var Builtins = map[int]*Function{
 		},
 	},
 }
+
+func kind(t reflect.Type) reflect.Kind {
+	if t == nil {
+		return reflect.Invalid
+	}
+	return t.Kind()
+}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index ba612a4c4..eba6a1f81 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -875,3 +875,21 @@ func TestCheck_Function_without_types(t *testing.T) {
 	require.NotNil(t, tree.Node.(*ast.CallNode).Func)
 	require.Equal(t, "add", tree.Node.(*ast.CallNode).Func.Name)
 }
+
+func TestCheck_dont_panic_on_nil_arguments_for_builtins(t *testing.T) {
+	tests := []string{
+		"len(nil)",
+		"abs(nil)",
+		"int(nil)",
+		"float(nil)",
+	}
+	for _, test := range tests {
+		t.Run(test, func(t *testing.T) {
+			tree, err := parser.Parse(test)
+			require.NoError(t, err)
+
+			_, err = checker.Check(tree, conf.New(nil))
+			require.Error(t, err)
+		})
+	}
+}

From 5613693f083dab319c8a98b62d7d35acd6880c94 Mon Sep 17 00:00:00 2001
From: blotus <sebastien@blot.me>
Date: Thu, 9 Mar 2023 13:48:26 +0100
Subject: [PATCH 002/506] runtime.Fetch: add string type assertion check before
 trying to check if the value is a method (#349)

---
 expr_test.go          | 26 ++++++++++++++++++++++++++
 vm/runtime/runtime.go |  8 +++++---
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index b80010fd5..a62e330e3 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1613,6 +1613,32 @@ func TestIssue271(t *testing.T) {
 	require.Equal(t, 1.0, output)
 }
 
+type Issue346Array []Issue346Type
+
+type Issue346Type struct {
+	Bar string
+}
+
+func (i Issue346Array) Len() int {
+	return len(i)
+}
+
+func TestIssue346(t *testing.T) {
+	code := `Foo[0].Bar`
+
+	env := map[string]interface{}{
+		"Foo": Issue346Array{
+			{Bar: "bar"},
+		},
+	}
+	program, err := expr.Compile(code, expr.Env(env))
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, "bar", output)
+}
+
 func TestCompile_allow_to_use_interface_to_get_an_element_from_map(t *testing.T) {
 	code := `{"value": "ok"}[vars.key]`
 	env := map[string]interface{}{
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 154a319fb..93ead17bf 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -18,9 +18,11 @@ func Fetch(from, i interface{}) interface{} {
 
 	// Methods can be defined on any type.
 	if v.NumMethod() > 0 {
-		method := v.MethodByName(i.(string))
-		if method.IsValid() {
-			return method.Interface()
+		if methodName, ok := i.(string); ok {
+			method := v.MethodByName(methodName)
+			if method.IsValid() {
+				return method.Interface()
+			}
 		}
 	}
 

From df2cccd267636baa18c7e19468ffa59c61222c9f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 9 Mar 2023 23:49:13 +0100
Subject: [PATCH 003/506] Fix nil key check in map (#351)

---
 checker/checker.go    |  2 +-
 expr_test.go          | 39 +++++++++++++++++++++++++++++++++++++++
 vm/runtime/runtime.go | 20 +++++++++++++++-----
 3 files changed, 55 insertions(+), 6 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 76e3d0be8..5ce9b31fa 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -417,7 +417,7 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 		return anyType, info{}
 
 	case reflect.Map:
-		if !prop.AssignableTo(base.Key()) && !isAny(prop) {
+		if prop != nil && !prop.AssignableTo(base.Key()) && !isAny(prop) {
 			return v.error(node.Property, "cannot use %v to get an element from %v", prop, base)
 		}
 		t, c := deref(base.Elem())
diff --git a/expr_test.go b/expr_test.go
index a62e330e3..0549dfe72 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1772,6 +1772,45 @@ func TestRun_NilCoalescingOperator(t *testing.T) {
 	})
 }
 
+func TestEval_nil_in_maps(t *testing.T) {
+	env := map[string]interface{}{
+		"m":     map[interface{}]interface{}{nil: "bar"},
+		"empty": map[interface{}]interface{}{},
+	}
+	t.Run("nil key exists", func(t *testing.T) {
+		p, err := expr.Compile(`m[nil]`, expr.Env(env))
+		assert.NoError(t, err)
+
+		out, err := expr.Run(p, env)
+		assert.NoError(t, err)
+		assert.Equal(t, "bar", out)
+	})
+	t.Run("no nil key", func(t *testing.T) {
+		p, err := expr.Compile(`empty[nil]`, expr.Env(env))
+		assert.NoError(t, err)
+
+		out, err := expr.Run(p, env)
+		assert.NoError(t, err)
+		assert.Equal(t, nil, out)
+	})
+	t.Run("nil in m", func(t *testing.T) {
+		p, err := expr.Compile(`nil in m`, expr.Env(env))
+		assert.NoError(t, err)
+
+		out, err := expr.Run(p, env)
+		assert.NoError(t, err)
+		assert.Equal(t, true, out)
+	})
+	t.Run("nil in empty", func(t *testing.T) {
+		p, err := expr.Compile(`nil in empty`, expr.Env(env))
+		assert.NoError(t, err)
+
+		out, err := expr.Run(p, env)
+		assert.NoError(t, err)
+		assert.Equal(t, false, out)
+	})
+}
+
 // Mock types
 
 type mockEnv struct {
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 93ead17bf..b2eeb65d8 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -48,7 +48,12 @@ func Fetch(from, i interface{}) interface{} {
 		}
 
 	case reflect.Map:
-		value := v.MapIndex(reflect.ValueOf(i))
+		var value reflect.Value
+		if i == nil {
+			value = v.MapIndex(reflect.Zero(v.Type().Key()))
+		} else {
+			value = v.MapIndex(reflect.ValueOf(i))
+		}
 		if value.IsValid() {
 			return value.Interface()
 		} else {
@@ -221,11 +226,16 @@ func In(needle interface{}, array interface{}) bool {
 		return false
 
 	case reflect.Map:
-		n := reflect.ValueOf(needle)
-		if !n.IsValid() {
-			panic(fmt.Sprintf("cannot use %T as index to %T", needle, array))
+		var value reflect.Value
+		if needle == nil {
+			value = v.MapIndex(reflect.Zero(v.Type().Key()))
+		} else {
+			n := reflect.ValueOf(needle)
+			if !n.IsValid() {
+				panic(fmt.Sprintf("cannot use %T as index to %T", needle, array))
+			}
+			value = v.MapIndex(n)
 		}
-		value := v.MapIndex(n)
 		if value.IsValid() {
 			return true
 		}

From e10a35d3dffdbd6ec83ca65b2f76d6a12ab373b8 Mon Sep 17 00:00:00 2001
From: hesining <37295940+hesining@users.noreply.github.com>
Date: Sat, 11 Mar 2023 04:08:40 +0800
Subject: [PATCH 004/506] Add Wrap and Unwrap method to hold self error (#352)

---
 expr_test.go  |  2 +-
 file/error.go | 11 +++++++++++
 vm/vm.go      |  3 +++
 vm/vm_test.go |  4 ++++
 4 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/expr_test.go b/expr_test.go
index 0549dfe72..cfe594a71 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1348,7 +1348,7 @@ func TestCompile_exposed_error(t *testing.T) {
 
 	b, err := json.Marshal(err)
 	require.NoError(t, err)
-	require.Equal(t, `{"Line":1,"Column":2,"Message":"invalid operation: == (mismatched types int and bool)","Snippet":"\n | 1 == true\n | ..^"}`, string(b))
+	require.Equal(t, `{"Line":1,"Column":2,"Message":"invalid operation: == (mismatched types int and bool)","Snippet":"\n | 1 == true\n | ..^","Prev":null}`, string(b))
 }
 
 func TestCompile_deref(t *testing.T) {
diff --git a/file/error.go b/file/error.go
index b7af3e6e2..1e7e81b94 100644
--- a/file/error.go
+++ b/file/error.go
@@ -10,6 +10,7 @@ type Error struct {
 	Location
 	Message string
 	Snippet string
+	Prev error
 }
 
 func (e *Error) Error() string {
@@ -44,6 +45,16 @@ func (e *Error) Bind(source *Source) *Error {
 	return e
 }
 
+
+func (e *Error) Unwrap() error {
+	return e.Prev
+}
+
+func (e *Error) Wrap(err error) {
+	e.Prev = err
+}
+
+
 func (e *Error) format() string {
 	if e.Location.Empty() {
 		return e.Message
diff --git a/vm/vm.go b/vm/vm.go
index 46f7628f2..af4fc5bf7 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -61,6 +61,9 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 				Location: program.Locations[vm.ip-1],
 				Message:  fmt.Sprintf("%v", r),
 			}
+			if err, ok := r.(error); ok {
+				f.Wrap(err)
+			}
 			err = f.Bind(program.Source)
 		}
 	}()
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 0fc291bc2..6e32d4713 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -274,6 +274,10 @@ func TestRun_MethodWithError(t *testing.T) {
 	out, err := vm.Run(program, env)
 	require.EqualError(t, err, "error (1:1)\n | WillError(\"yes\")\n | ^")
 	require.Equal(t, nil, out)
+
+	selfErr := errors.Unwrap(err)
+	require.NotNil(t, err)
+	require.Equal(t, "error", selfErr.Error())
 }
 
 func TestRun_FastMethods(t *testing.T) {

From cf1f46a3959954f3d6c80161b2584ebbb5216b42 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 20 Mar 2023 21:13:35 +0100
Subject: [PATCH 005/506] Add todo

---
 ast/node.go | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index 018c95658..adb5ddee0 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -102,12 +102,14 @@ type ChainNode struct {
 
 type MemberNode struct {
 	base
-	Node        Node
-	Property    Node
-	Name        string
-	Optional    bool
-	Deref       bool
-	FieldIndex  []int
+	Node       Node
+	Property   Node
+	Name       string
+	Optional   bool
+	Deref      bool
+	FieldIndex []int
+
+	// TODO: Replace with a single MethodIndex field of &int type.
 	Method      bool
 	MethodIndex int
 }

From 68aa5698b7c1a5b61990bf3ee49c3e58363a3a3e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 20 Mar 2023 21:15:52 +0100
Subject: [PATCH 006/506] Add comment

---
 ast/node.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ast/node.go b/ast/node.go
index adb5ddee0..e85f853e9 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -104,7 +104,7 @@ type MemberNode struct {
 	base
 	Node       Node
 	Property   Node
-	Name       string
+	Name       string // Name of the filed or method. Used for error reporting.
 	Optional   bool
 	Deref      bool
 	FieldIndex []int

From 1a1138d22ab8eca39eb0286dd63299d0ce57a4c6 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 20 Mar 2023 21:20:13 +0100
Subject: [PATCH 007/506] Fix method calls for interfaces

---
 checker/checker.go | 10 +++++++---
 expr_test.go       | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+), 3 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 5ce9b31fa..06371c62e 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -393,15 +393,19 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 		// First, check methods defined on base type itself,
 		// independent of which type it is. Without dereferencing.
 		if m, ok := base.MethodByName(name.Value); ok {
-			node.Method = true
-			node.MethodIndex = m.Index
-			node.Name = name.Value
 			if base.Kind() == reflect.Interface {
 				// In case of interface type method will not have a receiver,
 				// and to prevent checker decreasing numbers of in arguments
 				// return method type as not method (second argument is false).
+
+				// Also, we can not use m.Index here, because it will be
+				// different indexes for different types which implement
+				// the same interface.
 				return m.Type, info{}
 			} else {
+				node.Method = true
+				node.MethodIndex = m.Index
+				node.Name = name.Value
 				return m.Type, info{method: true}
 			}
 		}
diff --git a/expr_test.go b/expr_test.go
index cfe594a71..6246c844b 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1811,6 +1811,48 @@ func TestEval_nil_in_maps(t *testing.T) {
 	})
 }
 
+type Bar interface {
+	Bar() int
+}
+type Foo interface {
+	Foo() Bar
+}
+
+type FooImpl struct{}
+
+func (f FooImpl) Foo() Bar {
+	return BarImpl{}
+}
+
+type BarImpl struct{}
+
+// Aba is a special method that is not part of the Bar interface,
+// but is used to test that the correct method is called. "Aba" name
+// is chosen to be before "Bar" in the alphabet.
+func (b BarImpl) Aba() bool {
+	return true
+}
+
+func (b BarImpl) Bar() int {
+	return 42
+}
+
+func TestEval_interface_method(t *testing.T) {
+	require.True(t, BarImpl{}.Aba())
+	require.True(t, BarImpl{}.Bar() == 42)
+
+	env := map[string]interface{}{
+		"var": FooImpl{},
+	}
+	p, err := expr.Compile(`var.Foo().Bar()`, expr.Env(env))
+
+	assert.NoError(t, err)
+
+	out, err := expr.Run(p, env)
+	assert.NoError(t, err)
+	assert.Equal(t, 42, out)
+}
+
 // Mock types
 
 type mockEnv struct {

From b3fb3b93ee204bf4df5e8c7abe9dcedfd3a157a8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 21 Mar 2023 11:43:04 +0100
Subject: [PATCH 008/506] Beautify program disassemble

---
 vm/program.go | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/vm/program.go b/vm/program.go
index 7a417903c..d424df14f 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -1,9 +1,12 @@
 package vm
 
 import (
+	"bytes"
 	"fmt"
+	"reflect"
 	"regexp"
 	"strings"
+	"text/tabwriter"
 
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/builtin"
@@ -22,7 +25,8 @@ type Program struct {
 }
 
 func (program *Program) Disassemble() string {
-	out := ""
+	var buf bytes.Buffer
+	w := tabwriter.NewWriter(&buf, 0, 0, 2, ' ', 0)
 	ip := 0
 	for ip < len(program.Bytecode) {
 		pp := ip
@@ -31,16 +35,16 @@ func (program *Program) Disassemble() string {
 		ip += 1
 
 		code := func(label string) {
-			out += fmt.Sprintf("%v\t%v\n", pp, label)
+			_, _ = fmt.Fprintf(w, "%v\t%v\n", pp, label)
 		}
 		jump := func(label string) {
-			out += fmt.Sprintf("%v\t%v\t%v\t(%v)\n", pp, label, arg, ip+arg)
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t(%v)\n", pp, label, arg, ip+arg)
 		}
 		jumpBack := func(label string) {
-			out += fmt.Sprintf("%v\t%v\t%v\t(%v)\n", pp, label, arg, ip-arg)
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t(%v)\n", pp, label, arg, ip-arg)
 		}
 		argument := func(label string) {
-			out += fmt.Sprintf("%v\t%v\t%v\n", pp, label, arg)
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\n", pp, label, arg)
 		}
 		constant := func(label string) {
 			var c interface{}
@@ -58,14 +62,14 @@ func (program *Program) Disassemble() string {
 			if method, ok := c.(*runtime.Method); ok {
 				c = fmt.Sprintf("{%v %v}", method.Name, method.Index)
 			}
-			out += fmt.Sprintf("%v\t%v\t%v\t%v\n", pp, label, arg, c)
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, c)
 		}
 		builtIn := func(label string) {
 			f, ok := builtin.Builtins[arg]
 			if !ok {
 				panic(fmt.Sprintf("unknown builtin %v", arg))
 			}
-			out += fmt.Sprintf("%v\t%v\t%v\n", pp, "OpBuiltin", f.Name)
+			_, _ = fmt.Fprintf(w, "%v\t%v\t%v\n", pp, "OpBuiltin", f.Name)
 		}
 
 		switch op {
@@ -223,7 +227,8 @@ func (program *Program) Disassemble() string {
 			argument("OpCallFast")
 
 		case OpCallTyped:
-			argument("OpCallTyped")
+			signature := reflect.TypeOf(FuncTypes[arg]).Elem().String()
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, "OpCallTyped", arg, signature)
 
 		case OpBuiltin:
 			builtIn("OpBuiltin")
@@ -265,8 +270,9 @@ func (program *Program) Disassemble() string {
 			code("OpEnd")
 
 		default:
-			out += fmt.Sprintf("%v\t%#x\n", ip, op)
+			_, _ = fmt.Fprintf(w, "%v\t%#x\n", ip, op)
 		}
 	}
-	return out
+	_ = w.Flush()
+	return buf.String()
 }

From fb81647d3bd538f924726bbf48e339d68e4599dd Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 21 Mar 2023 12:03:36 +0100
Subject: [PATCH 009/506] Fix param type overwriting in type propagation logic

---
 checker/checker.go      |  2 +-
 checker/checker_test.go | 40 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/checker/checker.go b/checker/checker.go
index 06371c62e..00025a33c 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -639,7 +639,7 @@ func (v *visitor) checkFunc(name string, fn reflect.Type, method bool, node *ast
 			in = fn.In(i + fnInOffset)
 		}
 
-		if isIntegerOrArithmeticOperation(arg) {
+		if isIntegerOrArithmeticOperation(arg) && (isInteger(in) || isFloat(in)) {
 			t = in
 			setTypeForIntegers(arg, t)
 		}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index eba6a1f81..f62b6d580 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -484,6 +484,11 @@ cannot use int to get an element from map[string]interface {} (1:10)
 invalid operation: + (mismatched types int and string) (1:13)
  | 1 /* one */ + "2"
  | ............^
+
+FuncTyped(42)
+cannot use int as argument (type string) to call FuncTyped  (1:11)
+ | FuncTyped(42)
+ | ..........^
 `
 
 func TestCheck_error(t *testing.T) {
@@ -893,3 +898,38 @@ func TestCheck_dont_panic_on_nil_arguments_for_builtins(t *testing.T) {
 		})
 	}
 }
+
+func TestCheck_do_not_override_params_for_functions(t *testing.T) {
+	env := map[string]interface{}{
+		"foo": func(p string) string {
+			return "foo"
+		},
+	}
+	config := conf.New(env)
+	expr.Function(
+		"bar",
+		func(p ...interface{}) (interface{}, error) {
+			return p[0].(string), nil
+		},
+		new(func(string) string),
+	)(config)
+	config.Check()
+
+	t.Run("func from env", func(t *testing.T) {
+		tree, err := parser.Parse("foo(1)")
+		require.NoError(t, err)
+
+		_, err = checker.Check(tree, config)
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "cannot use int as argument")
+	})
+
+	t.Run("func from function", func(t *testing.T) {
+		tree, err := parser.Parse("bar(1)")
+		require.NoError(t, err)
+
+		_, err = checker.Check(tree, config)
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "cannot use int as argument")
+	})
+}

From 0886a6af70395e70d8c11dcfc66f73fa489c2f51 Mon Sep 17 00:00:00 2001
From: Schneizel <744587537@qq.com>
Date: Tue, 18 Apr 2023 20:09:01 +0800
Subject: [PATCH 010/506] remove duplicate codes (#356)

---
 expr.go | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/expr.go b/expr.go
index 14f6af285..6aa674fb5 100644
--- a/expr.go
+++ b/expr.go
@@ -151,15 +151,10 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 			_, _ = checker.Check(tree, config)
 			ast.Walk(&tree.Node, v)
 		}
-		_, err = checker.Check(tree, config)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		_, err = checker.Check(tree, config)
-		if err != nil {
-			return nil, err
-		}
+	}
+	_, err = checker.Check(tree, config)
+	if err != nil {
+		return nil, err
 	}
 
 	if config.Optimize {

From c71396e70b9454b6cfcc958ed0f374aed2856fb4 Mon Sep 17 00:00:00 2001
From: Pranav Peshwe <pranavpeshwe@Gmail.com>
Date: Wed, 19 Apr 2023 16:27:56 +0530
Subject: [PATCH 011/506] Fixed a compilation error - there is not member named
 timestamp. Added some formatting for better looks. (#355)

---
 docs/Getting-Started.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/Getting-Started.md b/docs/Getting-Started.md
index de42cdb4c..04dd015a5 100644
--- a/docs/Getting-Started.md
+++ b/docs/Getting-Started.md
@@ -82,7 +82,7 @@ type Message struct {
 }
 
 func main() {
-	code := `map(filter(messages, len(.Text) > 0), .Text + Format(.timestamp))`
+	code := `map(filter(messages, len(.Text) > 0), Format(.Date) + '\t' + .Text + '\n')`
 
 	// We can use an empty instance of the struct as an environment.
 	program, err := expr.Compile(code, expr.Env(Env{}))

From cb1f3459dd4705b6cbaf43069925d5e2c782fd6b Mon Sep 17 00:00:00 2001
From: mdmcconnell <113192632+mdmcconnell@users.noreply.github.com>
Date: Tue, 9 May 2023 19:32:42 +0100
Subject: [PATCH 012/506] Update Visitor-and-Patch.md (#369)

Stringer example fixed.
---
 docs/Visitor-and-Patch.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/docs/Visitor-and-Patch.md b/docs/Visitor-and-Patch.md
index 419a60eee..f98418b05 100644
--- a/docs/Visitor-and-Patch.md
+++ b/docs/Visitor-and-Patch.md
@@ -91,8 +91,8 @@ func (p *patcher) Visit(node *ast.Node) {
 }
 ```
 
-Type information is also available. Here is an example, there all `fmt.Stringer` 
-interface automatically converted to `string` type.
+Type information is also available. In the following example, any struct
+implementing the `fmt.Stringer` interface is automatically converted to `string` type.
 
 ```go
 func main() {
@@ -136,6 +136,7 @@ func (p *stringerPatcher) Visit(node *ast.Node) {
 			Callee: &ast.MemberNode{
 				Node:  *node,
 				Field: "String",
+				Property: &ast.StringNode{Value: "String"},
 			},
 		})
 	}

From d41c4943fb39a2d9a0b2e532895251af0e2bc179 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 6 Jul 2023 12:11:39 +0200
Subject: [PATCH 013/506] Update README.md

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 242431f2c..705fa21cb 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,5 @@
+<a href="https://webpod.dev/?from=expr"><img src="https://webpod.dev/img/banner.png" alt="Webpod - deploy JavaScript apps" width="190" align="right"></a>
+
 # Expr 
 [![test](https://github.com/antonmedv/expr/actions/workflows/test.yml/badge.svg)](https://github.com/antonmedv/expr/actions/workflows/test.yml) 
 [![Go Report Card](https://goreportcard.com/badge/github.com/antonmedv/expr)](https://goreportcard.com/report/github.com/antonmedv/expr) 

From 3c23d10fd78b0cfb86f8bcf66bd2ad9485d2074f Mon Sep 17 00:00:00 2001
From: mdmcconnell <113192632+mdmcconnell@users.noreply.github.com>
Date: Wed, 12 Jul 2023 10:01:19 +0100
Subject: [PATCH 014/506] env[] keyword implemented in parser (#382)

---
 checker/checker.go   | 12 +++++-
 compiler/compiler.go |  4 ++
 conf/types_table.go  | 14 +++++--
 expr_test.go         | 97 ++++++++++++++++++++++++++++++++++++++++++++
 vm/opcodes.go        |  1 +
 vm/vm.go             |  2 +
 6 files changed, 125 insertions(+), 5 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 00025a33c..a4e5e6d45 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -383,8 +383,18 @@ func (v *visitor) ChainNode(node *ast.ChainNode) (reflect.Type, info) {
 }
 
 func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
-	base, _ := v.visit(node.Node)
 	prop, _ := v.visit(node.Property)
+	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "env" {
+		// If the index is a constant string, can save some
+		// cycles later by finding the type of its referent
+		if name, ok := node.Property.(*ast.StringNode); ok {
+			if t, ok := v.config.Types[name.Value]; ok {
+				return t.Type, info{method: t.Method}
+			} // No error if no type found; it may be added to env between compile and run
+		}
+		return anyType, info{}
+	}
+	base, _ := v.visit(node.Node)
 
 	if name, ok := node.Property.(*ast.StringNode); ok {
 		if base == nil {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 3cd32af0f..423dd6217 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -205,6 +205,10 @@ func (c *compiler) NilNode(_ *ast.NilNode) {
 }
 
 func (c *compiler) IdentifierNode(node *ast.IdentifierNode) {
+	if node.Value == "env" {
+		c.emit(OpLoadEnv)
+		return
+	}
 	if c.mapEnv {
 		c.emit(OpLoadFast, c.addConstant(node.Value))
 	} else if len(node.FieldIndex) > 0 {
diff --git a/conf/types_table.go b/conf/types_table.go
index e917f5fa8..f4d401c9c 100644
--- a/conf/types_table.go
+++ b/conf/types_table.go
@@ -54,6 +54,9 @@ func CreateTypesTable(i interface{}) TypesTable {
 		for _, key := range v.MapKeys() {
 			value := v.MapIndex(key)
 			if key.Kind() == reflect.String && value.IsValid() && value.CanInterface() {
+				if key.String() == "env" { // Could check for all keywords here
+					panic("attempt to misuse env keyword as env map key")
+				}
 				types[key.String()] = Tag{Type: reflect.TypeOf(value.Interface())}
 			}
 		}
@@ -94,10 +97,13 @@ func FieldsFromStruct(t reflect.Type) TypesTable {
 					}
 				}
 			}
-
-			types[FieldName(f)] = Tag{
-				Type:       f.Type,
-				FieldIndex: f.Index,
+			if fn := FieldName(f); fn == "env" { // Could check for all keywords here
+				panic("attempt to misuse env keyword as env struct field tag")
+			} else {
+				types[FieldName(f)] = Tag{
+					Type:       f.Type,
+					FieldIndex: f.Index,
+				}
 			}
 		}
 	}
diff --git a/expr_test.go b/expr_test.go
index 6246c844b..14cbf7415 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1811,6 +1811,103 @@ func TestEval_nil_in_maps(t *testing.T) {
 	})
 }
 
+// Test the use of env keyword.  Forms env[] and env[”] are valid.
+// The enclosed identifier must be in the expression env.
+func TestEnv_keyword(t *testing.T) {
+	env := map[string]interface{}{
+		"space test":                       "ok",
+		"space_test":                       "not ok", // Seems to be some underscore substituting happening, check that.
+		"Section 1-2a":                     "ok",
+		`c:\ndrive\2015 Information Table`: "ok",
+		"%*worst function name ever!!": func() string {
+			return "ok"
+		}(),
+		"1":      "o",
+		"2":      "k",
+		"num":    10,
+		"mylist": []int{1, 2, 3, 4, 5},
+		"MIN": func(a, b int) int {
+			if a < b {
+				return a
+			} else {
+				return b
+			}
+		},
+		"red":   "n",
+		"irect": "um",
+		"String Map": map[string]string{
+			"one":   "two",
+			"three": "four",
+		},
+		"OtherMap": map[string]string{
+			"a": "b",
+			"c": "d",
+		},
+	}
+
+	// No error cases
+	var tests = []struct {
+		code string
+		want interface{}
+	}{
+		{"env['space test']", "ok"},
+		{"env['Section 1-2a']", "ok"},
+		{`env["c:\\ndrive\\2015 Information Table"]`, "ok"},
+		{"env['%*worst function name ever!!']", "ok"},
+		{"env['String Map'].one", "two"},
+		{"env['1'] + env['2']", "ok"},
+		{"1 + env['num'] + env['num']", 21},
+		{"MIN(env['num'],0)", 0},
+		{"env['nu' + 'm']", 10},
+		{"env[red + irect]", 10},
+		{"env['String Map']?.five", ""},
+		{"env.red", "n"},
+		{"env?.blue", nil},
+		{"env.mylist[1]", 2},
+		{"env?.OtherMap?.a", "b"},
+		{"env?.OtherMap?.d", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+
+			program, err := expr.Compile(tt.code, expr.Env(env))
+			require.NoError(t, err, "compile error")
+
+			got, err := expr.Run(program, env)
+			require.NoError(t, err, "execution error")
+
+			assert.Equal(t, tt.want, got, tt.code)
+		})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			got, err := expr.Eval(tt.code, env)
+			require.NoError(t, err, "eval error: "+tt.code)
+
+			assert.Equal(t, tt.want, got, "eval: "+tt.code)
+		})
+	}
+
+	// error cases
+	tests = []struct {
+		code string
+		want interface{}
+	}{
+		{"env()", "bad"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			_, err := expr.Eval(tt.code, expr.Env(env))
+			require.Error(t, err, "compile error")
+
+		})
+	}
+
+}
+
 type Bar interface {
 	Bar() int
 }
diff --git a/vm/opcodes.go b/vm/opcodes.go
index b3117e73c..63b9f8a30 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -11,6 +11,7 @@ const (
 	OpLoadFast
 	OpLoadMethod
 	OpLoadFunc
+	OpLoadEnv
 	OpFetch
 	OpFetchField
 	OpMethod
diff --git a/vm/vm.go b/vm/vm.go
index af4fc5bf7..3e5411b1f 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -123,6 +123,8 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			a := vm.pop()
 			vm.push(runtime.FetchField(a, program.Constants[arg].(*runtime.Field)))
 
+		case OpLoadEnv:
+			vm.push(env)
 		case OpMethod:
 			a := vm.pop()
 			vm.push(runtime.FetchMethod(a, program.Constants[arg].(*runtime.Method)))

From d3fee6e695813fc1f82b55eb7922a9dfcecd36cc Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 19 Jul 2023 17:09:45 +0400
Subject: [PATCH 015/506] Fix OpLoadEnv disassemble

---
 vm/program.go      | 5 ++++-
 vm/program_test.go | 2 +-
 vm/vm.go           | 1 +
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/vm/program.go b/vm/program.go
index d424df14f..57d7140eb 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -97,6 +97,9 @@ func (program *Program) Disassemble() string {
 		case OpLoadFunc:
 			argument("OpLoadFunc")
 
+		case OpLoadEnv:
+			code("OpLoadEnv")
+
 		case OpFetch:
 			code("OpFetch")
 
@@ -270,7 +273,7 @@ func (program *Program) Disassemble() string {
 			code("OpEnd")
 
 		default:
-			_, _ = fmt.Fprintf(w, "%v\t%#x\n", ip, op)
+			_, _ = fmt.Fprintf(w, "%v\t%#x (unknown)\n", ip, op)
 		}
 	}
 	_ = w.Flush()
diff --git a/vm/program_test.go b/vm/program_test.go
index b7bb4f226..06e83b18c 100644
--- a/vm/program_test.go
+++ b/vm/program_test.go
@@ -15,7 +15,7 @@ func TestProgram_Disassemble(t *testing.T) {
 			Arguments: []int{1},
 		}
 		d := program.Disassemble()
-		if strings.Contains(d, "\t0x") {
+		if strings.Contains(d, "(unknown)") {
 			t.Errorf("cannot disassemble all opcodes")
 		}
 	}
diff --git a/vm/vm.go b/vm/vm.go
index 3e5411b1f..b2b2e619e 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -125,6 +125,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 
 		case OpLoadEnv:
 			vm.push(env)
+
 		case OpMethod:
 			a := vm.pop()
 			vm.push(runtime.FetchMethod(a, program.Constants[arg].(*runtime.Method)))

From 38b27f3162bd7c083dd59d5f563f87805ed7dabb Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 19 Jul 2023 17:16:46 +0400
Subject: [PATCH 016/506] Code style

---
 file/error.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/file/error.go b/file/error.go
index 1e7e81b94..edf202b04 100644
--- a/file/error.go
+++ b/file/error.go
@@ -10,7 +10,7 @@ type Error struct {
 	Location
 	Message string
 	Snippet string
-	Prev error
+	Prev    error
 }
 
 func (e *Error) Error() string {
@@ -45,7 +45,6 @@ func (e *Error) Bind(source *Source) *Error {
 	return e
 }
 
-
 func (e *Error) Unwrap() error {
 	return e.Prev
 }
@@ -54,7 +53,6 @@ func (e *Error) Wrap(err error) {
 	e.Prev = err
 }
 
-
 func (e *Error) format() string {
 	if e.Location.Empty() {
 		return e.Message

From d2100ece96affe6766d97e2cf0e4ca4d145f0d30 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 19 Jul 2023 17:19:59 +0400
Subject: [PATCH 017/506] Add OpInvalid

---
 vm/opcodes.go |  3 ++-
 vm/program.go |  3 +++
 vm/vm.go      |  3 +++
 vm/vm_test.go | 12 ++++++++++++
 4 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/vm/opcodes.go b/vm/opcodes.go
index 63b9f8a30..4bc9abf4d 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -3,7 +3,8 @@ package vm
 type Opcode byte
 
 const (
-	OpPush Opcode = iota
+	OpInvalid Opcode = iota
+	OpPush
 	OpPushInt
 	OpPop
 	OpLoadConst
diff --git a/vm/program.go b/vm/program.go
index 57d7140eb..936eca9a2 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -73,6 +73,9 @@ func (program *Program) Disassemble() string {
 		}
 
 		switch op {
+		case OpInvalid:
+			code("OpInvalid")
+
 		case OpPush:
 			constant("OpPush")
 
diff --git a/vm/vm.go b/vm/vm.go
index b2b2e619e..ec22c251d 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -93,6 +93,9 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 
 		switch op {
 
+		case OpInvalid:
+			panic("invalid opcode")
+
 		case OpPush:
 			vm.push(program.Constants[arg])
 
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 6e32d4713..a5f24c29a 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -11,6 +11,7 @@ import (
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/compiler"
 	"github.com/antonmedv/expr/conf"
+	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/parser"
 	"github.com/antonmedv/expr/vm"
 	"github.com/stretchr/testify/require"
@@ -380,3 +381,14 @@ func TestRun_TaggedFieldName(t *testing.T) {
 
 	require.Equal(t, "hello world", out)
 }
+
+func TestRun_OpInvalid(t *testing.T) {
+	program := &vm.Program{
+		Locations: []file.Location{{0, 0}},
+		Bytecode:  []vm.Opcode{vm.OpInvalid},
+		Arguments: []int{0},
+	}
+
+	_, err := vm.Run(program, nil)
+	require.EqualError(t, err, "invalid opcode")
+}

From 0dd3702b814ce12b5bd15f0bedba78dcba7d6080 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 10 Aug 2023 22:09:32 +0200
Subject: [PATCH 018/506] Refactor deref (#398)

* Refactor deref types

* Refactor deref opcode inserts

* Add multiple pointers deref
---
 ast/node.go               |   4 +-
 checker/checker.go        |  26 +++----
 checker/types.go          |  12 ++--
 compiler/compiler.go      |  72 ++++++++++++++------
 compiler/compiler_test.go |  20 ++++++
 expr_test.go              |  48 +------------
 test/deref/deref_test.go  | 139 ++++++++++++++++++++++++++++++++++++++
 vm/runtime/runtime.go     |   4 +-
 8 files changed, 232 insertions(+), 93 deletions(-)
 create mode 100644 test/deref/deref_test.go

diff --git a/ast/node.go b/ast/node.go
index e85f853e9..5bdcb75ed 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -50,7 +50,6 @@ type NilNode struct {
 type IdentifierNode struct {
 	base
 	Value       string
-	Deref       bool
 	FieldIndex  []int
 	Method      bool // true if method, false if field
 	MethodIndex int  // index of method, set only if Method is true
@@ -106,10 +105,9 @@ type MemberNode struct {
 	Property   Node
 	Name       string // Name of the filed or method. Used for error reporting.
 	Optional   bool
-	Deref      bool
 	FieldIndex []int
 
-	// TODO: Replace with a single MethodIndex field of &int type.
+	// TODO: Combine Method and MethodIndex into a single MethodIndex field of &int type.
 	Method      bool
 	MethodIndex int
 }
diff --git a/checker/checker.go b/checker/checker.go
index a4e5e6d45..86d6d6c6a 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -135,18 +135,14 @@ func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 		// when the arguments are known in CallNode.
 		return anyType, info{fn: fn}
 	}
-	if v.config.Types == nil {
-		node.Deref = true
-	} else if t, ok := v.config.Types[node.Value]; ok {
+	if t, ok := v.config.Types[node.Value]; ok {
 		if t.Ambiguous {
 			return v.error(node, "ambiguous identifier %v", node.Value)
 		}
-		d, c := deref(t.Type)
-		node.Deref = c
 		node.Method = t.Method
 		node.MethodIndex = t.MethodIndex
 		node.FieldIndex = t.FieldIndex
-		return d, info{method: t.Method}
+		return t.Type, info{method: t.Method}
 	}
 	if v.config.Strict {
 		return v.error(node, "unknown name %v", node.Value)
@@ -180,6 +176,8 @@ func (v *visitor) ConstantNode(node *ast.ConstantNode) (reflect.Type, info) {
 func (v *visitor) UnaryNode(node *ast.UnaryNode) (reflect.Type, info) {
 	t, _ := v.visit(node.Node)
 
+	t = deref(t)
+
 	switch node.Operator {
 
 	case "!", "not":
@@ -209,6 +207,9 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 	l, _ := v.visit(node.Left)
 	r, _ := v.visit(node.Right)
 
+	l = deref(l)
+	r = deref(r)
+
 	// check operator overloading
 	if fns, ok := v.config.Operators[node.Operator]; ok {
 		t, _, ok := conf.FindSuitableOperatorOverload(fns, v.config.Types, l, r)
@@ -427,34 +428,27 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 
 	switch base.Kind() {
 	case reflect.Interface:
-		node.Deref = true
 		return anyType, info{}
 
 	case reflect.Map:
 		if prop != nil && !prop.AssignableTo(base.Key()) && !isAny(prop) {
 			return v.error(node.Property, "cannot use %v to get an element from %v", prop, base)
 		}
-		t, c := deref(base.Elem())
-		node.Deref = c
-		return t, info{}
+		return base.Elem(), info{}
 
 	case reflect.Array, reflect.Slice:
 		if !isInteger(prop) && !isAny(prop) {
 			return v.error(node.Property, "array elements can only be selected using an integer (got %v)", prop)
 		}
-		t, c := deref(base.Elem())
-		node.Deref = c
-		return t, info{}
+		return base.Elem(), info{}
 
 	case reflect.Struct:
 		if name, ok := node.Property.(*ast.StringNode); ok {
 			propertyName := name.Value
 			if field, ok := fetchField(base, propertyName); ok {
-				t, c := deref(field.Type)
-				node.Deref = c
 				node.FieldIndex = field.Index
 				node.Name = propertyName
-				return t, info{}
+				return field.Type, info{}
 			}
 			if len(v.parents) > 1 {
 				if _, ok := v.parents[len(v.parents)-2].(*ast.CallNode); ok {
diff --git a/checker/types.go b/checker/types.go
index 7ccd89480..e8f53372c 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -204,25 +204,23 @@ func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
 	return reflect.StructField{}, false
 }
 
-func deref(t reflect.Type) (reflect.Type, bool) {
+func deref(t reflect.Type) reflect.Type {
 	if t == nil {
-		return nil, false
+		return nil
 	}
 	if t.Kind() == reflect.Interface {
-		return t, true
+		return t
 	}
-	found := false
 	for t != nil && t.Kind() == reflect.Ptr {
 		e := t.Elem()
 		switch e.Kind() {
 		case reflect.Struct, reflect.Map, reflect.Array, reflect.Slice:
-			return t, false
+			return t
 		default:
-			found = true
 			t = e
 		}
 	}
-	return t, found
+	return t
 }
 
 func isIntegerOrArithmeticOperation(node ast.Node) bool {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 423dd6217..4b2f94603 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -224,11 +224,6 @@ func (c *compiler) IdentifierNode(node *ast.IdentifierNode) {
 	} else {
 		c.emit(OpLoadConst, c.addConstant(node.Value))
 	}
-	if node.Deref {
-		c.emit(OpDeref)
-	} else if node.Type() == nil {
-		c.emit(OpDeref)
-	}
 }
 
 func (c *compiler) IntegerNode(node *ast.IntegerNode) {
@@ -289,6 +284,7 @@ func (c *compiler) ConstantNode(node *ast.ConstantNode) {
 
 func (c *compiler) UnaryNode(node *ast.UnaryNode) {
 	c.compile(node.Node)
+	c.derefInNeeded(node.Node)
 
 	switch node.Operator {
 
@@ -313,7 +309,9 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 	switch node.Operator {
 	case "==":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Left)
 
 		if l == r && l == reflect.Int {
 			c.emit(OpEqualInt)
@@ -325,114 +323,155 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 
 	case "!=":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Left)
 		c.emit(OpEqual)
 		c.emit(OpNot)
 
 	case "or", "||":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		end := c.emit(OpJumpIfTrue, placeholder)
 		c.emit(OpPop)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.patchJump(end)
 
 	case "and", "&&":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		end := c.emit(OpJumpIfFalse, placeholder)
 		c.emit(OpPop)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.patchJump(end)
 
 	case "<":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpLess)
 
 	case ">":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpMore)
 
 	case "<=":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpLessOrEqual)
 
 	case ">=":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpMoreOrEqual)
 
 	case "+":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpAdd)
 
 	case "-":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpSubtract)
 
 	case "*":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpMultiply)
 
 	case "/":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpDivide)
 
 	case "%":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpModulo)
 
 	case "**", "^":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpExponent)
 
 	case "in":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpIn)
 
 	case "matches":
 		if node.Regexp != nil {
 			c.compile(node.Left)
+			c.derefInNeeded(node.Left)
 			c.emit(OpMatchesConst, c.addConstant(node.Regexp))
 		} else {
 			c.compile(node.Left)
+			c.derefInNeeded(node.Left)
 			c.compile(node.Right)
+			c.derefInNeeded(node.Right)
 			c.emit(OpMatches)
 		}
 
 	case "contains":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpContains)
 
 	case "startsWith":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpStartsWith)
 
 	case "endsWith":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpEndsWith)
 
 	case "..":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.emit(OpRange)
 
 	case "??":
 		c.compile(node.Left)
+		c.derefInNeeded(node.Left)
 		end := c.emit(OpJumpIfNotNil, placeholder)
 		c.emit(OpPop)
 		c.compile(node.Right)
+		c.derefInNeeded(node.Right)
 		c.patchJump(end)
 
 	default:
@@ -461,7 +500,6 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 		return
 	}
 	op := OpFetch
-	original := node
 	index := node.FieldIndex
 	path := []string{node.Name}
 	base := node.Node
@@ -470,21 +508,15 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 		for !node.Optional {
 			ident, ok := base.(*ast.IdentifierNode)
 			if ok && len(ident.FieldIndex) > 0 {
-				if ident.Deref {
-					panic("IdentifierNode should not be dereferenced")
-				}
 				index = append(ident.FieldIndex, index...)
 				path = append([]string{ident.Value}, path...)
 				c.emitLocation(ident.Location(), OpLoadField, c.addConstant(
 					&runtime.Field{Index: index, Path: path},
 				))
-				goto deref
+				return
 			}
 			member, ok := base.(*ast.MemberNode)
 			if ok && len(member.FieldIndex) > 0 {
-				if member.Deref {
-					panic("MemberNode should not be dereferenced")
-				}
 				index = append(member.FieldIndex, index...)
 				path = append([]string{member.Name}, path...)
 				node = member
@@ -509,13 +541,6 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 			&runtime.Field{Index: index, Path: path},
 		))
 	}
-
-deref:
-	if original.Deref {
-		c.emit(OpDeref)
-	} else if original.Type() == nil {
-		c.emit(OpDeref)
-	}
 }
 
 func (c *compiler) SliceNode(node *ast.SliceNode) {
@@ -734,6 +759,13 @@ func (c *compiler) PairNode(node *ast.PairNode) {
 	c.compile(node.Value)
 }
 
+func (c *compiler) derefInNeeded(node ast.Node) {
+	switch kind(node) {
+	case reflect.Ptr, reflect.Interface:
+		c.emit(OpDeref)
+	}
+}
+
 func kind(node ast.Node) reflect.Kind {
 	t := node.Type()
 	if t == nil {
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index 81da17316..d5293913c 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -27,6 +27,7 @@ type Env struct {
 		_   byte
 		B   B
 		Map map[string]B
+		Ptr *int
 	}
 }
 
@@ -249,6 +250,25 @@ func TestCompile(t *testing.T) {
 				Arguments: []int{0, 2, 0, 1},
 			},
 		},
+		{
+			`A.Ptr + 1`,
+			vm.Program{
+				Constants: []interface{}{
+					&runtime.Field{
+						Index: []int{0, 3},
+						Path:  []string{"A", "Ptr"},
+					},
+					1,
+				},
+				Bytecode: []vm.Opcode{
+					vm.OpLoadField,
+					vm.OpDeref,
+					vm.OpPush,
+					vm.OpAdd,
+				},
+				Arguments: []int{0, 0, 1, 0},
+			},
+		},
 	}
 
 	for _, test := range tests {
diff --git a/expr_test.go b/expr_test.go
index 14cbf7415..3cda97fef 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1351,50 +1351,6 @@ func TestCompile_exposed_error(t *testing.T) {
 	require.Equal(t, `{"Line":1,"Column":2,"Message":"invalid operation: == (mismatched types int and bool)","Snippet":"\n | 1 == true\n | ..^","Prev":null}`, string(b))
 }
 
-func TestCompile_deref(t *testing.T) {
-	i := 1
-	env := map[string]interface{}{
-		"i": &i,
-		"map": map[string]interface{}{
-			"i": &i,
-		},
-	}
-	{
-		// With specified env, OpDeref added and == works as expected.
-		program, err := expr.Compile(`i == 1 && map.i == 1`, expr.Env(env))
-		require.NoError(t, err)
-
-		env["any"] = &i
-		out, err := expr.Run(program, env)
-		require.NoError(t, err)
-		require.Equal(t, true, out)
-	}
-	{
-		// Compile without expr.Env() also works as expected,
-		// and should add OpDeref automatically.
-		program, err := expr.Compile(`i == 1 && map.i == 1`)
-		require.NoError(t, err)
-
-		out, err := expr.Run(program, env)
-		require.NoError(t, err)
-		require.Equal(t, true, out)
-	}
-}
-
-func TestEval_deref(t *testing.T) {
-	i := 1
-	env := map[string]interface{}{
-		"i": &i,
-		"map": map[string]interface{}{
-			"i": &i,
-		},
-	}
-
-	out, err := expr.Eval(`i == 1 && map.i == 1`, env)
-	require.NoError(t, err)
-	require.Equal(t, true, out)
-}
-
 func TestAsBool_exposed_error(t *testing.T) {
 	_, err := expr.Compile(`42`, expr.AsBool())
 	require.Error(t, err)
@@ -1519,10 +1475,10 @@ func TestIssue154(t *testing.T) {
 
 	for _, input := range tests {
 		program, err := expr.Compile(input, expr.Env(env))
-		assert.NoError(t, err, input)
+		require.NoError(t, err, input)
 
 		output, err := expr.Run(program, env)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.True(t, output.(bool), input)
 	}
 }
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
new file mode 100644
index 000000000..761e779f2
--- /dev/null
+++ b/test/deref/deref_test.go
@@ -0,0 +1,139 @@
+package deref_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/antonmedv/expr"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDeref_binary(t *testing.T) {
+	i := 1
+	env := map[string]interface{}{
+		"i": &i,
+		"map": map[string]interface{}{
+			"i": &i,
+		},
+	}
+	t.Run("==", func(t *testing.T) {
+		program, err := expr.Compile(`i == 1 && map.i == 1`, expr.Env(env))
+		require.NoError(t, err)
+
+		out, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, true, out)
+	})
+	t.Run("><", func(t *testing.T) {
+		program, err := expr.Compile(`i > 0 && map.i < 99`, expr.Env(env))
+		require.NoError(t, err)
+
+		out, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, true, out)
+	})
+	t.Run("??+", func(t *testing.T) {
+		program, err := expr.Compile(`(i ?? map.i) + 1`, expr.Env(env))
+		require.NoError(t, err)
+
+		out, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, 2, out)
+	})
+}
+
+func TestDeref_unary(t *testing.T) {
+	i := 1
+	ok := true
+	env := map[string]interface{}{
+		"i": &i,
+		"map": map[string]interface{}{
+			"ok": &ok,
+		},
+	}
+
+	program, err := expr.Compile(`-i < 0 && !!map.ok`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, true, out)
+}
+
+func TestDeref_eval(t *testing.T) {
+	i := 1
+	env := map[string]interface{}{
+		"i": &i,
+		"map": map[string]interface{}{
+			"i": &i,
+		},
+	}
+	out, err := expr.Eval(`i == 1 && map.i == 1`, env)
+	require.NoError(t, err)
+	require.Equal(t, true, out)
+}
+
+func TestDeref_emptyCtx(t *testing.T) {
+	program, err := expr.Compile(`ctx`)
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, map[string]interface{}{
+		"ctx": context.Background(),
+	})
+	require.NoError(t, err)
+	require.Implements(t, new(context.Context), output)
+}
+
+func TestDeref_emptyCtx_Eval(t *testing.T) {
+	output, err := expr.Eval(`ctx`, map[string]interface{}{
+		"ctx": context.Background(),
+	})
+	require.NoError(t, err)
+	require.Implements(t, new(context.Context), output)
+}
+
+func TestDeref_context_WithValue(t *testing.T) {
+	program, err := expr.Compile(`ctxWithValue`)
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, map[string]interface{}{
+		"ctxWithValue": context.WithValue(context.Background(), "value", "test"),
+	})
+	require.NoError(t, err)
+	require.Implements(t, new(context.Context), output)
+}
+
+func TestDeref_method_on_int_pointer(t *testing.T) {
+	output, err := expr.Eval(`foo.Bar()`, map[string]interface{}{
+		"foo": new(foo),
+	})
+	require.NoError(t, err)
+	require.Equal(t, 42, output)
+}
+
+type foo int
+
+func (f *foo) Bar() int {
+	return 42
+}
+
+func TestDeref_multiple_pointers(t *testing.T) {
+	a := 42
+	b := &a
+	c := &b
+	t.Run("returned as is", func(t *testing.T) {
+		output, err := expr.Eval(`c`, map[string]interface{}{
+			"c": c,
+		})
+		require.NoError(t, err)
+		require.Equal(t, c, output)
+		require.IsType(t, (**int)(nil), output)
+	})
+	t.Run("+ works", func(t *testing.T) {
+		output, err := expr.Eval(`c+2`, map[string]interface{}{
+			"c": c,
+		})
+		require.NoError(t, err)
+		require.Equal(t, 44, output)
+	})
+}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index b2eeb65d8..75ac94bf8 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -153,13 +153,15 @@ func Deref(i interface{}) interface{} {
 		v = v.Elem()
 	}
 
-	if v.Kind() == reflect.Ptr {
+loop:
+	for v.Kind() == reflect.Ptr {
 		if v.IsNil() {
 			return i
 		}
 		indirect := reflect.Indirect(v)
 		switch indirect.Kind() {
 		case reflect.Struct, reflect.Map, reflect.Array, reflect.Slice:
+			break loop
 		default:
 			v = v.Elem()
 		}

From 6f8e24d3edb1f56ef3f9970f7c3b47fb6d89b6e0 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 10 Aug 2023 22:11:05 +0200
Subject: [PATCH 019/506] Add go 1.20 & 1.21

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 7352f0d64..0d781a35b 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.13', '1.14', '1.15', '1.16' , '1.17', '1.18', '1.19' ]
+        go-versions: [ '1.13', '1.14', '1.15', '1.16' , '1.17', '1.18', '1.19', '1.20', '1.21' ]
     steps:
       - uses: actions/checkout@v2
       - name: Setup Go ${{ matrix.go-version }}

From edcab828e4a953553500ca5a662791f9cfc3dd4f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 10 Aug 2023 22:41:20 +0200
Subject: [PATCH 020/506] Add repl

---
 repl/go.mod  | 10 ++++++++++
 repl/go.sum  | 24 ++++++++++++++++++++++++
 repl/repl.go | 38 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 72 insertions(+)
 create mode 100644 repl/go.mod
 create mode 100644 repl/go.sum
 create mode 100644 repl/repl.go

diff --git a/repl/go.mod b/repl/go.mod
new file mode 100644
index 000000000..6b0cd27e6
--- /dev/null
+++ b/repl/go.mod
@@ -0,0 +1,10 @@
+module github.com/antonmedv/expr/repl
+
+go 1.20
+
+require (
+	github.com/antonmedv/expr v1.12.7
+	github.com/chzyer/readline v1.5.1
+)
+
+require golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5 // indirect
diff --git a/repl/go.sum b/repl/go.sum
new file mode 100644
index 000000000..03c9b71af
--- /dev/null
+++ b/repl/go.sum
@@ -0,0 +1,24 @@
+github.com/antonmedv/expr v1.12.7 h1:jfV/l/+dHWAadLwAtESXNxXdfbK9bE4+FNMHYCMntwk=
+github.com/antonmedv/expr v1.12.7/go.mod h1:FPC8iWArxls7axbVLsW+kpg1mz29A1b2M6jt+hZfDkU=
+github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
+github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
+github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
+github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk=
+github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=
+github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5 h1:y/woIyUBFbpQGKS0u1aHF/40WUDnek3fPOyD08H5Vng=
+golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/repl/repl.go b/repl/repl.go
new file mode 100644
index 000000000..280df9108
--- /dev/null
+++ b/repl/repl.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/antonmedv/expr"
+	"github.com/chzyer/readline"
+)
+
+func main() {
+	rl, err := readline.New("> ")
+	if err != nil {
+		panic(err)
+	}
+	defer rl.Close()
+
+	for {
+		line, err := rl.Readline()
+		if err != nil { // io.EOF when Ctrl-D is pressed
+			break
+		}
+
+		if line == "exit" {
+			break
+		}
+
+		result := evaluate(line)
+		fmt.Println(result)
+	}
+}
+
+func evaluate(input string) string {
+	result, err := expr.Eval(input, nil)
+	if err != nil {
+		return err.Error()
+	}
+	return fmt.Sprintf("%v", result)
+}

From c31c46786baee7f897ef985a735045e3b75ff329 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 11 Aug 2023 00:24:23 +0200
Subject: [PATCH 021/506] Upgrade deps

---
 repl/go.mod | 2 +-
 repl/go.sum | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/repl/go.mod b/repl/go.mod
index 6b0cd27e6..544f97299 100644
--- a/repl/go.mod
+++ b/repl/go.mod
@@ -7,4 +7,4 @@ require (
 	github.com/chzyer/readline v1.5.1
 )
 
-require golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5 // indirect
+require golang.org/x/sys v0.11.0 // indirect
diff --git a/repl/go.sum b/repl/go.sum
index 03c9b71af..12275609b 100644
--- a/repl/go.sum
+++ b/repl/go.sum
@@ -18,6 +18,8 @@ github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PK
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5 h1:y/woIyUBFbpQGKS0u1aHF/40WUDnek3fPOyD08H5Vng=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

From c83a35c94a7f352e9689f30e0f3c75ce5ce0d134 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 11 Aug 2023 00:25:05 +0200
Subject: [PATCH 022/506] Update README.md

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index 705fa21cb..242431f2c 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,3 @@
-<a href="https://webpod.dev/?from=expr"><img src="https://webpod.dev/img/banner.png" alt="Webpod - deploy JavaScript apps" width="190" align="right"></a>
-
 # Expr 
 [![test](https://github.com/antonmedv/expr/actions/workflows/test.yml/badge.svg)](https://github.com/antonmedv/expr/actions/workflows/test.yml) 
 [![Go Report Card](https://goreportcard.com/badge/github.com/antonmedv/expr)](https://goreportcard.com/report/github.com/antonmedv/expr) 

From e646a93d2c6bb3c777fc62bd52ded0c66cfaa911 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 11 Aug 2023 00:29:59 +0200
Subject: [PATCH 023/506] Add env info

---
 docs/Language-Definition.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 3dc947e0b..45514cc54 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -259,3 +259,11 @@ Braces `{` `}` can be omitted:
 ```expr
 filter(Tweets, len(.Value) > 280)
 ```
+
+## `env` variable
+
+The `env` variable is a map of all variables passed to the expression.
+
+```expr
+Foo.Name == env['Foo'].Name
+```

From b32455f84c56fe5823b7e0f8e247ba492e021159 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 11 Aug 2023 08:49:26 +0200
Subject: [PATCH 024/506] gofmt

---
 parser/lexer/utils.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/parser/lexer/utils.go b/parser/lexer/utils.go
index 72e3cf20c..a0ea87e28 100644
--- a/parser/lexer/utils.go
+++ b/parser/lexer/utils.go
@@ -63,10 +63,10 @@ func unescape(value string) (string, error) {
 
 // unescapeChar takes a string input and returns the following info:
 //
-//   value - the escaped unicode rune at the front of the string.
-//   multibyte - whether the rune value might require multiple bytes to represent.
-//   tail - the remainder of the input string.
-//   err - error value, if the character could not be unescaped.
+//	value - the escaped unicode rune at the front of the string.
+//	multibyte - whether the rune value might require multiple bytes to represent.
+//	tail - the remainder of the input string.
+//	err - error value, if the character could not be unescaped.
 //
 // When multibyte is true the return value may still fit within a single byte,
 // but a multibyte conversion is attempted which is more expensive than when the

From 8404831a352e677125f2f96d088c810281a19a48 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 11 Aug 2023 13:47:04 +0200
Subject: [PATCH 025/506] Update docs

---
 docs/Configuration.md   |  67 ++++++++++++
 docs/Getting-Started.md | 218 ++++++++++++++++++++--------------------
 2 files changed, 174 insertions(+), 111 deletions(-)
 create mode 100644 docs/Configuration.md

diff --git a/docs/Configuration.md b/docs/Configuration.md
new file mode 100644
index 000000000..153fc0df0
--- /dev/null
+++ b/docs/Configuration.md
@@ -0,0 +1,67 @@
+# Configuration
+
+Expr can be configured to do more things. For example, with [AllowUndefinedVariables](https://pkg.go.dev/github.com/antonmedv/expr#AllowUndefinedVariables) or [AsBool](https://pkg.go.dev/github.com/antonmedv/expr#AsBool) to expect the boolean result from the expression.
+
+```go
+program, err := expr.Compile(code, expr.Env(Env{}), expr.AllowUndefinedVariables(), expr.AsBool())
+```
+
+## Functions
+
+Expr supports any Go functions. For example, you can use `fmt.Sprintf` or methods of your structs.
+Also, Expr supports functions configured via [`expr.Function(name, fn[, ...types])`](https://pkg.go.dev/github.com/antonmedv/expr#Function) option.
+
+```go
+	atoi := expr.Function(
+		"atoi",
+		func(params ...any) (any, error) {
+			return strconv.Atoi(params[0].(string))
+		},
+	)
+
+	program, err := expr.Compile(`atoi("42")`, atoi)
+```
+
+Expr sees the `atoi` function as a function with a variadic number of arguments of type `any` and returns a value of type `any`. But, we can specify the types of arguments and the return value by adding the correct function
+signature or multiple signatures.
+
+```go
+	atoi := expr.Function(
+		"atoi",
+		func(params ...any) (any, error) {
+			return strconv.Atoi(params[0].(string))
+		},
+		new(func(string) int),
+	)
+```
+
+Or we can simply reuse the `strconv.Atoi` function.
+
+```go
+	atoi := expr.Function(
+		"atoi",
+		func(params ...any) (any, error) {
+			return strconv.Atoi(params[0].(string))
+		},
+		strconv.Atoi,
+	)
+```
+
+Here is another example with a few function signatures:
+
+```go
+	toInt := expr.Function(
+		"toInt",
+		func(params ...any) (any, error) {
+			switch params[0].(type) {
+			case float64:
+				return int(params[0].(float64)), nil
+			case string:
+				return strconv.Atoi(params[0].(string))
+			}
+			return nil, fmt.Errorf("invalid type")
+		},
+		new(func(float64) int),
+		new(func(string) int),
+	)
+```
diff --git a/docs/Getting-Started.md b/docs/Getting-Started.md
index 04dd015a5..87653946a 100644
--- a/docs/Getting-Started.md
+++ b/docs/Getting-Started.md
@@ -1,97 +1,126 @@
 # Getting Started
 
 **Expr** is a simple, fast and extensible expression language for Go. It is
-designed to be easy to use and integrate into your application.
+designed to be easy to use and integrate into your Go application. Let's delve
+deeper into its core features:
 
+- **Memory safe** - Designed to prevent vulnerabilities like buffer overflows and memory leaks.
+- **Type safe** - Enforces strict type rules, aligning with Go's type system.
+- **Terminating** - Ensures every expression evaluation cannot loop indefinitely.
+- **Side effects free** - Evaluations won't modify global states or variables.
 
-## Evaluate
-
-For simple use cases with one execution of an expression, you can use the 
-`expr.Eval` function. It takes an expression and a map of variables and returns
-the result of the expression.
+Let's start with a simple example:
 
 ```go
-package main
+program, err := expr.Compile(`2 + 2`)
+if err != nil {
+    panic(err)
+}
 
-import (
-	"fmt"
-	"github.com/antonmedv/expr"
-)
+output, err := expr.Run(program, nil)
+if err != nil {
+    panic(err)
+}
 
-func main() {
-	env := map[string]interface{}{
-		"foo": 1,
-		"bar": 2,
-	}
+fmt.Print(output) // 4
+```
 
-	out, err := expr.Eval("foo + bar", env)
+Expr compiles the expression `2 + 2` into a bytecode program. Then we run
+the program and get the output. The output is `4` as expected.
 
-	if err != nil {
-		panic(err)
-	}
-	fmt.Print(out)
+The `expr.Compile` function returns a `*vm.Program` and an error. The program
+can be reused between runs. The `expr.Run` function takes a program and an
+environment. The environment is a map of variables that can be used in the
+expression. In this example, we use `nil` as an environment because we don't
+need any variables.
+
+Now let's pass some variables to the expression:
+
+```go
+env := map[string]any{
+    "foo": 100,
+	"bar": 200,
 }
+
+program, err := expr.Compile(`foo + bar`, expr.Env(env))
+if err != nil {
+    panic(err)
+}
+
+output, err := expr.Run(program, env)
+if err != nil {
+    panic(err)
+}
+
+fmt.Print(output) // 300
 ```
 
-## Compile
+Why do we need to pass the environment to the `expr.Compile` function? Expr can be used as a type-safe language. 
+Expr can infer the type of the expression and check it against the environment. Here is an example:
+
+```go
+env := map[string]any{
+    "name": "Anton",
+    "age": 35,
+}
+
+program, err := expr.Compile(`name + age`, expr.Env(env))
+if err != nil {
+    panic(err) // Will panic with "invalid operation: string + int"
+}
+```
 
-Usually, we want to compile, type check and verify that the expression returns a 
-boolean (or another type). For example, if a user saves an expression from a
-[web UI](https://antonmedv.github.io/expr/).
+Expr can work with any Go types. Here is an example:
 
 ```go
-	env := map[string]interface{}{
-		"greet":   "Hello, %v!",
-		"names":   []string{"world", "you"},
-		"sprintf": fmt.Sprintf, // Use any functions.
-	}
+env := map[string]interface{}{
+	"greet":   "Hello, %v!",
+	"names":   []string{"world", "you"},
+	"sprintf": fmt.Sprintf,
+}
 
-	code := `sprintf(greet, names[0])`
+code := `sprintf(greet, names[0])`
 
-	// Compile the code into a bytecode. This step can be done only once and
-	// the program may be reused. Specify an environment for the type check.
-	program, err := expr.Compile(code, expr.Env(env))
-	if err != nil {
-		panic(err)
-	}
+program, err := expr.Compile(code, expr.Env(env))
+if err != nil {
+	panic(err)
+}
 
-	output, err := expr.Run(program, env)
-	if err != nil {
-		panic(err)
-	}
+output, err := expr.Run(program, env)
+if err != nil {
+	panic(err)
+}
 
-	fmt.Print(output)
+fmt.Print(output) // Hello, world!
 ```
 
-An environment can be a struct and structs methods can be used as
-functions. Expr supports embedded structs and methods defined on them too.
-
-The struct fields can be renamed by adding struct tags such as `expr:"name"`.
+Also, Expr can use a struct as an environment. Methods defined on the struct become functions.
+The struct fields can be renamed with the `expr` tag. Here is an example:
 
 ```go
 type Env struct {
-	Messages []Message `expr:"messages"`
+	Posts []Post `expr:"posts"`
 }
 
-// Methods defined on the struct become functions.
-func (Env) Format(t time.Time) string { return t.Format(time.RFC822) }
+func (Env) Format(t time.Time) string { 
+	return t.Format(time.RFC822) 
+}
 
-type Message struct {
-	Text string
+type Post struct {
+	Body string
 	Date time.Time
 }
 
 func main() {
-	code := `map(filter(messages, len(.Text) > 0), Format(.Date) + '\t' + .Text + '\n')`
-
-	// We can use an empty instance of the struct as an environment.
+	code := `map(posts, Format(.Date) + ": " + .Body)`
+	
 	program, err := expr.Compile(code, expr.Env(Env{}))
 	if err != nil {
 		panic(err)
 	}
 
 	env := Env{
-		Messages: []Message{
+		Posts: []Post{
 			{"Oh My God!", time.Now()}, 
 			{"How you doin?", time.Now()}, 
 			{"Could I be wearing any more clothes?", time.Now()},
@@ -107,70 +136,37 @@ func main() {
 }
 ```
 
-## Configuration
-
-Expr can be configured to do more things. For example, with [AllowUndefinedVariables](https://pkg.go.dev/github.com/antonmedv/expr#AllowUndefinedVariables) or [AsBool](https://pkg.go.dev/github.com/antonmedv/expr#AsBool) to expect the boolean result from the expression.
-
-```go
-program, err := expr.Compile(code, expr.Env(Env{}), expr.AllowUndefinedVariables(), expr.AsBool())
-```
-
-## Functions
-
-Expr supports any Go functions. For example, you can use `fmt.Sprintf` or methods of your structs. 
-Also, Expr supports functions configured via [`expr.Function(name, fn[, ...types])`](https://pkg.go.dev/github.com/antonmedv/expr#Function) option.
+The compiled program can be reused between runs. Here is an example:
 
 ```go
-	atoi := expr.Function(
-		"atoi",
-		func(params ...any) (any, error) {
-			return strconv.Atoi(params[0].(string))
-		},
-	)
+type Env struct {
+    X int
+    Y int
+}
 
-	program, err := expr.Compile(`atoi("42")`, atoi)
-```
+program, err := expr.Compile(`X + Y`, expr.Env(Env{}))
+if err != nil {
+    panic(err)
+}
 
-Expr sees the `atoi` function as a function with a variadic number of arguments of type `any` and returns a value of type `any`. But, we can specify the types of arguments and the return value by adding the correct function
-signature or multiple signatures.
+output, err := expr.Run(program, Env{1, 2})
+if err != nil {
+    panic(err)
+}
 
-```go
-	atoi := expr.Function(
-		"atoi",
-		func(params ...any) (any, error) {
-			return strconv.Atoi(params[0].(string))
-		},
-		new(func(string) int),
-	)
-```
+fmt.Print(output) // 3
 
-Or we can simply reuse the `strconv.Atoi` function.
+output, err = expr.Run(program, Env{3, 4})
+if err != nil {
+    panic(err)
+}
 
-```go
-	atoi := expr.Function(
-		"atoi",
-		func(params ...any) (any, error) {
-			return strconv.Atoi(params[0].(string))
-		},
-		strconv.Atoi,
-	)
+fmt.Print(output) // 7
 ```
 
-Here is another example with a few function signatures:
-
+:::tip
+For one-off expressions, you can use the `expr.Eval` function. It compiles and runs the expression in one step.
 ```go
-	toInt := expr.Function(
-		"toInt",
-		func(params ...any) (any, error) {
-			switch params[0].(type) {
-			case float64:
-				return int(params[0].(float64)), nil
-			case string:
-				return strconv.Atoi(params[0].(string))
-			}
-			return nil, fmt.Errorf("invalid type")
-		},
-		new(func(float64) int),
-		new(func(string) int),
-	)
+output, err := expr.Eval(`2 + 2`, env)
 ```
+:::

From d625ef35e41a6b363a713d100151fe1edffec2cf Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 11 Aug 2023 14:06:17 +0200
Subject: [PATCH 026/506] Add config docs

---
 docs/Configuration.md | 99 ++++++++++++++++++++++++++++++++++++++++---
 docs/Internals.md     | 17 --------
 2 files changed, 94 insertions(+), 22 deletions(-)

diff --git a/docs/Configuration.md b/docs/Configuration.md
index 153fc0df0..5423bc663 100644
--- a/docs/Configuration.md
+++ b/docs/Configuration.md
@@ -1,15 +1,91 @@
 # Configuration
 
-Expr can be configured to do more things. For example, with [AllowUndefinedVariables](https://pkg.go.dev/github.com/antonmedv/expr#AllowUndefinedVariables) or [AsBool](https://pkg.go.dev/github.com/antonmedv/expr#AsBool) to expect the boolean result from the expression.
+Expr can be configured with options. For example, you can pass the environment with variables and functions.
+
+## AllowUndefinedVariables()
+
+This option allows undefined variables in the expression. By default, Expr will return an error 
+if the expression contains undefined variables.
+
+```go
+program, err := expr.Compile(`foo + bar`, expr.AllowUndefinedVariables())
+```
+
+## AsBool()
+
+This option forces the expression to return a boolean value. If the expression returns a non-boolean value,
+Expr will return an error.
+
+```go
+program, err := expr.Compile(`Title contains "Hello"`, expr.AsBool())
+```
+
+## AsFloat64()
+
+This option forces the expression to return a float64 value. If the expression returns a non-float64 value,
+Expr will return an error.
+
+```go
+program, err := expr.Compile(`42`, expr.AsFloat64())
+```
+
+:::note
+If the expression returns integer value, Expr will convert it to float64.
+:::
+
+## AsInt()
+
+This option forces the expression to return an int value. If the expression returns a non-int value,
+Expr will return an error.
+
+```go
+program, err := expr.Compile(`42`, expr.AsInt())
+```
+
+:::note
+If the expression returns a float value, Expr truncates it to int.
+:::
+
+## AsInt64()
+
+Same as `AsInt()` but returns an int64 value.
 
 ```go
-program, err := expr.Compile(code, expr.Env(Env{}), expr.AllowUndefinedVariables(), expr.AsBool())
+program, err := expr.Compile(`42`, expr.AsInt64())
 ```
 
-## Functions
+## AsKind()
 
-Expr supports any Go functions. For example, you can use `fmt.Sprintf` or methods of your structs.
-Also, Expr supports functions configured via [`expr.Function(name, fn[, ...types])`](https://pkg.go.dev/github.com/antonmedv/expr#Function) option.
+This option forces the expression to return a value of the specified kind. 
+If the expression returns a value of a different kind, Expr will return an error.
+
+```go
+program, err := expr.Compile(`42`, expr.AsKind(reflect.String))
+```
+
+## ConstExpr()
+
+This option tells Expr to treat specified functions as constant expressions. 
+If all arguments of the function are constants, Expr will replace the function call with the result 
+during the compile step.
+
+```go
+program, err := expr.Compile(`fib(42)`, expr.ConstExpr("fib"))
+```
+
+[ConstExpr Example](https://pkg.go.dev/github.com/antonmedv/expr?tab=doc#ConstExpr)
+
+## Env()
+
+This option passes the environment with variables and functions to the expression.
+
+```go
+program, err := expr.Compile(`foo + bar`, expr.Env(Env{}))
+```
+
+## Function()
+
+This option adds a function to the expression.
 
 ```go
 	atoi := expr.Function(
@@ -65,3 +141,16 @@ Here is another example with a few function signatures:
 		new(func(string) int),
 	)
 ```
+
+
+## Operator()
+
+This options defines an [operator overloading](Operator-Overloading.md).
+
+## Optimize()
+
+This option enables [optimizations](Optimizations.md). By default, Expr will optimize the expression.
+
+## Patch()
+
+This option allows you to [patch the expression](Visitor-and-Patch.md) before compilation.
diff --git a/docs/Internals.md b/docs/Internals.md
index 593af1321..beb28f17a 100644
--- a/docs/Internals.md
+++ b/docs/Internals.md
@@ -59,20 +59,3 @@ Will be replaced with a binary operator:
 ```
 
 Ranges computed on the compile stage, are replaced with pre-created slices.
-
-## Const expr
-
-If some function is marked as a constant expression with `expr.ConstExpr`. It will be
-replaced with the result of the call if all arguments are constants.
-
-```go
-expr.ConstExpt("fib")
-```
-
-```
-fib(42)
-``` 
-
-Will be replaced with the result of `fib`(42)` on the compile step.
-
-[ConstExpr Example](https://pkg.go.dev/github.com/antonmedv/expr?tab=doc#ConstExpr)

From 6feb409a961d08d250eafa49294343ed18c958ae Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 11 Aug 2023 14:12:15 +0200
Subject: [PATCH 027/506] Fix link in docs

---
 docs/Configuration.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/Configuration.md b/docs/Configuration.md
index 5423bc663..7dd9d5a18 100644
--- a/docs/Configuration.md
+++ b/docs/Configuration.md
@@ -149,7 +149,7 @@ This options defines an [operator overloading](Operator-Overloading.md).
 
 ## Optimize()
 
-This option enables [optimizations](Optimizations.md). By default, Expr will optimize the expression.
+This option enables [optimizations](Internals.md). By default, Expr will optimize the expression.
 
 ## Patch()
 

From 4ba47d93aade9d759142165a65f3b9ae74728e25 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 11 Aug 2023 21:43:17 +0200
Subject: [PATCH 028/506] Update env

---
 test/playground/env.go | 89 +++++++++++++++---------------------------
 1 file changed, 32 insertions(+), 57 deletions(-)

diff --git a/test/playground/env.go b/test/playground/env.go
index 9b35c69b9..06224c60d 100644
--- a/test/playground/env.go
+++ b/test/playground/env.go
@@ -1,71 +1,46 @@
 package playground
 
-import "time"
+import (
+	"time"
+)
 
-type Env struct {
-	Products  []Product  `expr:"products"`
-	Customers []Customer `expr:"customers"`
-	Discounts []Discount `expr:"discounts"`
-	Orders    []Order    `expr:"orders"`
+type UserProfile struct {
+	Birthday  time.Time
+	Biography string
+	Website   string
 }
 
-type Product struct {
-	Name        string
-	Description string
-	Price       float64
-	Stock       int
-	AddOn       *AddOn
-	Metadata    map[string]interface{}
-	Tags        []string
-	Rating      float64
-	Reviews     []Review
-}
-
-type Feature struct {
-	Id          string
-	Description string
-}
-
-type Discount struct {
-	Name    string
-	Percent int
-}
-
-type Customer struct {
+type Author struct {
+	ID        int
 	FirstName string
 	LastName  string
-	Age       int
-	Addresses []Address
-}
-
-type Address struct {
-	Country    string
-	City       string
-	Street     string
-	PostalCode string
+	Email     string
+	Profile   UserProfile
 }
 
-type Order struct {
-	Number    int
-	Customer  Customer
-	Items     []*OrderItem
-	Discounts []*Discount
-	CreatedAt time.Time
-}
-
-type OrderItem struct {
-	Product  Product
-	Quantity int
+type Post struct {
+	ID          int
+	Title       string
+	Content     string
+	PublishDate time.Time
+	Author      Author
+	Comments    []Comment
+	Tags        []string
+	Likes       int
 }
 
-type Review struct {
-	Product  *Product
-	Customer *Customer
-	Comment  string
-	Rating   float64
+type Comment struct {
+	ID          int
+	AuthorName  string
+	Content     string
+	CommentDate time.Time
+	Upvotes     int
 }
 
-type AddOn struct {
-	Name  string
-	Price float64
+type Blog struct {
+	Posts      []Post
+	Authors    map[int]Author
+	TotalViews int
+	TotalPosts int
+	TotalLikes int
 }

From 9da6e0fb2961833a846da3ac71d25d0d90c80373 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 12 Aug 2023 13:22:27 +0200
Subject: [PATCH 029/506] Update README.md

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 242431f2c..1aab8b685 100644
--- a/README.md
+++ b/README.md
@@ -13,14 +13,14 @@ The purpose of the package is to allow users to use expressions inside configura
 It is a perfect candidate for the foundation of a _business rule engine_. 
 The idea is to let configure things in a dynamic way without recompile of a program:
 
-```coffeescript
-# Get the special price if
+```js
+// Get the special price if
 user.Group in ["good_customers", "collaborator"]
 
-# Promote article to the homepage when
+// Promote article to the homepage when
 len(article.Comments) > 100 and article.Category not in ["misc"]
 
-# Send an alert when
+// Send an alert when
 product.Stock < 15
 ```
 

From 9ca99f0c4830bb0f0c3765cd0648eeb7c2344c9d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 13 Aug 2023 01:17:49 +0200
Subject: [PATCH 030/506] Add pipe operator (#400)

---
 debug/go.mod             |   4 +-
 debug/go.sum             |   2 -
 parser/lexer/state.go    |   7 +-
 parser/parser.go         | 135 ++++++++++++++++++++++++++-------------
 parser/parser_test.go    |  30 +++++++++
 repl/go.mod              |   4 +-
 repl/go.sum              |   3 -
 test/pipes/pipes_test.go |  31 +++++++++
 8 files changed, 161 insertions(+), 55 deletions(-)
 create mode 100644 test/pipes/pipes_test.go

diff --git a/debug/go.mod b/debug/go.mod
index dd9b17c57..5dbf3d776 100644
--- a/debug/go.mod
+++ b/debug/go.mod
@@ -3,7 +3,9 @@ module github.com/antonmedv/expr/debug
 go 1.13
 
 require (
-	github.com/antonmedv/expr v1.9.1-0.20221030193158-2213166cdca2
+	github.com/antonmedv/expr v0.0.0
 	github.com/gdamore/tcell v1.3.0
 	github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498
 )
+
+replace github.com/antonmedv/expr => ../
diff --git a/debug/go.sum b/debug/go.sum
index dd620f7dc..3eaa3b26f 100644
--- a/debug/go.sum
+++ b/debug/go.sum
@@ -1,6 +1,4 @@
 github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
-github.com/antonmedv/expr v1.9.1-0.20221030193158-2213166cdca2 h1:/lRT2yHd7/W9hW2ZvpNKyoop5YBjJ+wa6p6Vxg1m9Hg=
-github.com/antonmedv/expr v1.9.1-0.20221030193158-2213166cdca2/go.mod h1:FPC8iWArxls7axbVLsW+kpg1mz29A1b2M6jt+hZfDkU=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index 1212aa321..5b4b5839e 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -28,14 +28,17 @@ func root(l *lexer) stateFn {
 		return questionMark
 	case r == '/':
 		return slash
+	case r == '|':
+		l.accept("|")
+		l.emit(Operator)
 	case strings.ContainsRune("([{", r):
 		l.emit(Bracket)
 	case strings.ContainsRune(")]}", r):
 		l.emit(Bracket)
 	case strings.ContainsRune("#,:%+-^", r): // single rune operator
 		l.emit(Operator)
-	case strings.ContainsRune("&|!=*<>", r): // possible double rune operator
-		l.accept("&|=*")
+	case strings.ContainsRune("&!=*<>", r): // possible double rune operator
+		l.accept("&=*")
 		l.emit(Operator)
 	case r == '.':
 		l.backup()
diff --git a/parser/parser.go b/parser/parser.go
index fd26fe18b..ac54e29b3 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -23,10 +23,6 @@ type operator struct {
 	associativity associativity
 }
 
-type builtin struct {
-	arity int
-}
-
 var unaryOperators = map[string]operator{
 	"not": {50, left},
 	"!":   {50, left},
@@ -61,6 +57,10 @@ var binaryOperators = map[string]operator{
 	"??":         {500, left},
 }
 
+type builtin struct {
+	arity int
+}
+
 var builtins = map[string]builtin{
 	"all":    {2},
 	"none":   {2},
@@ -201,12 +201,41 @@ func (p *parser) parseExpression(precedence int) Node {
 	}
 
 	if precedence == 0 {
-		nodeLeft = p.parseConditionalExpression(nodeLeft)
+		nodeLeft = p.parseConditional(nodeLeft)
+
+		if p.current.Is(Operator, "|") {
+			p.next()
+			return p.parsePipe(nodeLeft)
+		}
 	}
 
 	return nodeLeft
 }
 
+func (p *parser) parseConditional(node Node) Node {
+	var expr1, expr2 Node
+	for p.current.Is(Operator, "?") && p.err == nil {
+		p.next()
+
+		if !p.current.Is(Operator, ":") {
+			expr1 = p.parseExpression(0)
+			p.expect(Operator, ":")
+			expr2 = p.parseExpression(0)
+		} else {
+			p.next()
+			expr1 = node
+			expr2 = p.parseExpression(0)
+		}
+
+		node = &ConditionalNode{
+			Cond: node,
+			Exp1: expr1,
+			Exp2: expr2,
+		}
+	}
+	return node
+}
+
 func (p *parser) parsePrimary() Node {
 	token := p.current
 
@@ -245,34 +274,10 @@ func (p *parser) parsePrimary() Node {
 		}
 	}
 
-	return p.parsePrimaryExpression()
-}
-
-func (p *parser) parseConditionalExpression(node Node) Node {
-	var expr1, expr2 Node
-	for p.current.Is(Operator, "?") && p.err == nil {
-		p.next()
-
-		if !p.current.Is(Operator, ":") {
-			expr1 = p.parseExpression(0)
-			p.expect(Operator, ":")
-			expr2 = p.parseExpression(0)
-		} else {
-			p.next()
-			expr1 = node
-			expr2 = p.parseExpression(0)
-		}
-
-		node = &ConditionalNode{
-			Cond: node,
-			Exp1: expr1,
-			Exp2: expr2,
-		}
-	}
-	return node
+	return p.parseSecondary()
 }
 
-func (p *parser) parsePrimaryExpression() Node {
+func (p *parser) parseSecondary() Node {
 	var node Node
 	token := p.current
 
@@ -294,7 +299,7 @@ func (p *parser) parsePrimaryExpression() Node {
 			node.SetLocation(token.Location)
 			return node
 		default:
-			node = p.parseIdentifierExpression(token)
+			node = p.parseCall(token)
 		}
 
 	case Number:
@@ -345,14 +350,13 @@ func (p *parser) parsePrimaryExpression() Node {
 	return p.parsePostfixExpression(node)
 }
 
-func (p *parser) parseIdentifierExpression(token Token) Node {
+func (p *parser) parseCall(token Token) Node {
 	var node Node
 	if p.current.Is(Bracket, "(") {
 		var arguments []Node
 
 		if b, ok := builtins[token.Value]; ok {
 			p.expect(Bracket, "(")
-			// TODO: Add builtins signatures.
 			if b.arity == 1 {
 				arguments = make([]Node, 1)
 				arguments[0] = p.parseExpression(0)
@@ -578,20 +582,43 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 	return node
 }
 
-func isValidIdentifier(str string) bool {
-	if len(str) == 0 {
-		return false
-	}
-	h, w := utf8.DecodeRuneInString(str)
-	if !IsAlphabetic(h) {
-		return false
-	}
-	for _, r := range str[w:] {
-		if !IsAlphaNumeric(r) {
-			return false
+func (p *parser) parsePipe(node Node) Node {
+	identifier := p.current
+	p.expect(Identifier)
+
+	arguments := []Node{node}
+
+	if b, ok := builtins[identifier.Value]; ok {
+		p.expect(Bracket, "(")
+		if b.arity == 2 {
+			arguments = append(arguments, p.parseClosure())
+		}
+		p.expect(Bracket, ")")
+
+		node = &BuiltinNode{
+			Name:      identifier.Value,
+			Arguments: arguments,
 		}
+		node.SetLocation(identifier.Location)
+	} else {
+		callee := &IdentifierNode{Value: identifier.Value}
+		callee.SetLocation(identifier.Location)
+
+		arguments = append(arguments, p.parseArguments()...)
+
+		node = &CallNode{
+			Callee:    callee,
+			Arguments: arguments,
+		}
+		node.SetLocation(identifier.Location)
 	}
-	return true
+
+	if p.current.Is(Operator, "|") {
+		p.next()
+		return p.parsePipe(node)
+	}
+
+	return node
 }
 
 func (p *parser) parseArguments() []Node {
@@ -608,3 +635,19 @@ func (p *parser) parseArguments() []Node {
 
 	return nodes
 }
+
+func isValidIdentifier(str string) bool {
+	if len(str) == 0 {
+		return false
+	}
+	h, w := utf8.DecodeRuneInString(str)
+	if !IsAlphabetic(h) {
+		return false
+	}
+	for _, r := range str[w:] {
+		if !IsAlphaNumeric(r) {
+			return false
+		}
+	}
+	return true
+}
diff --git a/parser/parser_test.go b/parser/parser_test.go
index a93ecdc2f..4c162224c 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -8,6 +8,7 @@ import (
 	. "github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/parser"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParse(t *testing.T) {
@@ -444,6 +445,12 @@ func TestParse(t *testing.T) {
 				Left:  &IdentifierNode{Value: "foo"},
 				Right: &CallNode{Callee: &IdentifierNode{Value: "bar"}}},
 		},
+		{
+			"true | ok()",
+			&CallNode{
+				Callee: &IdentifierNode{Value: "ok"},
+				Arguments: []Node{
+					&BoolNode{Value: true}}}},
 	}
 	for _, test := range parseTests {
 		actual, err := parser.Parse(test.input)
@@ -631,3 +638,26 @@ func TestParse_optional_chaining(t *testing.T) {
 		assert.Equal(t, Dump(test.expected), Dump(actual.Node), test.input)
 	}
 }
+
+func TestParse_pipe_operator(t *testing.T) {
+	input := "arr | map(.foo) | len() | Foo()"
+	expect := &CallNode{
+		Callee: &IdentifierNode{Value: "Foo"},
+		Arguments: []Node{
+			&CallNode{
+				Callee: &IdentifierNode{Value: "len"},
+				Arguments: []Node{
+					&BuiltinNode{
+						Name: "map",
+						Arguments: []Node{
+							&IdentifierNode{Value: "arr"},
+							&ClosureNode{
+								Node: &MemberNode{
+									Node:     &PointerNode{},
+									Property: &StringNode{Value: "foo"},
+								}}}}}}}}
+
+	actual, err := parser.Parse(input)
+	require.NoError(t, err)
+	assert.Equal(t, Dump(expect), Dump(actual.Node))
+}
diff --git a/repl/go.mod b/repl/go.mod
index 544f97299..4e15b13bb 100644
--- a/repl/go.mod
+++ b/repl/go.mod
@@ -3,8 +3,10 @@ module github.com/antonmedv/expr/repl
 go 1.20
 
 require (
-	github.com/antonmedv/expr v1.12.7
+	github.com/antonmedv/expr v0.0.0
 	github.com/chzyer/readline v1.5.1
 )
 
 require golang.org/x/sys v0.11.0 // indirect
+
+replace github.com/antonmedv/expr => ../
diff --git a/repl/go.sum b/repl/go.sum
index 12275609b..e5a857a0c 100644
--- a/repl/go.sum
+++ b/repl/go.sum
@@ -1,5 +1,3 @@
-github.com/antonmedv/expr v1.12.7 h1:jfV/l/+dHWAadLwAtESXNxXdfbK9bE4+FNMHYCMntwk=
-github.com/antonmedv/expr v1.12.7/go.mod h1:FPC8iWArxls7axbVLsW+kpg1mz29A1b2M6jt+hZfDkU=
 github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
 github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
 github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
@@ -16,7 +14,6 @@ github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSS
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5 h1:y/woIyUBFbpQGKS0u1aHF/40WUDnek3fPOyD08H5Vng=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
diff --git a/test/pipes/pipes_test.go b/test/pipes/pipes_test.go
new file mode 100644
index 000000000..47f440681
--- /dev/null
+++ b/test/pipes/pipes_test.go
@@ -0,0 +1,31 @@
+package pipes_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/antonmedv/expr"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPipes(t *testing.T) {
+	env := map[string]interface{}{
+		"sprintf": fmt.Sprintf,
+	}
+
+	program, err := expr.Compile(`"%s bar %d" | sprintf("foo", -42 | abs())`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, "foo bar 42", out)
+}
+
+func TestPipes_map_filter(t *testing.T) {
+	program, err := expr.Compile(`1..9 | map(# + 1) | filter(# % 2 == 0)`)
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, nil)
+	require.NoError(t, err)
+	require.Equal(t, []interface{}{2, 4, 6, 8, 10}, out)
+}

From 2eb6a03aacf9ca8a87685a6f3b1adc3e8473b295 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 13 Aug 2023 12:33:34 +0200
Subject: [PATCH 031/506] Refactor builtin funcs

---
 builtin/builtin.go   | 31 +++++++++----------------------
 builtin/utils.go     | 16 ++++++++++++++++
 compiler/compiler.go |  4 ++--
 3 files changed, 27 insertions(+), 24 deletions(-)
 create mode 100644 builtin/utils.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index ad9376962..f0b2fe887 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -5,16 +5,10 @@ import (
 	"reflect"
 )
 
-var (
-	anyType     = reflect.TypeOf(new(interface{})).Elem()
-	integerType = reflect.TypeOf(0)
-	floatType   = reflect.TypeOf(float64(0))
-)
-
 type Function struct {
 	Name     string
+	Id       int
 	Func     func(args ...interface{}) (interface{}, error)
-	Opcode   int
 	Types    []reflect.Type
 	Validate func(args []reflect.Type) (reflect.Type, error)
 }
@@ -28,8 +22,8 @@ const (
 
 var Builtins = map[int]*Function{
 	Len: {
-		Name:   "len",
-		Opcode: Len,
+		Name: "len",
+		Id:   Len,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for len (expected 1, got %d)", len(args))
@@ -42,8 +36,8 @@ var Builtins = map[int]*Function{
 		},
 	},
 	Abs: {
-		Name:   "abs",
-		Opcode: Abs,
+		Name: "abs",
+		Id:   Abs,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for abs (expected 1, got %d)", len(args))
@@ -56,8 +50,8 @@ var Builtins = map[int]*Function{
 		},
 	},
 	Int: {
-		Name:   "int",
-		Opcode: Int,
+		Name: "int",
+		Id:   Int,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for int (expected 1, got %d)", len(args))
@@ -74,8 +68,8 @@ var Builtins = map[int]*Function{
 		},
 	},
 	Float: {
-		Name:   "float",
-		Opcode: Float,
+		Name: "float",
+		Id:   Float,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for float (expected 1, got %d)", len(args))
@@ -92,10 +86,3 @@ var Builtins = map[int]*Function{
 		},
 	},
 }
-
-func kind(t reflect.Type) reflect.Kind {
-	if t == nil {
-		return reflect.Invalid
-	}
-	return t.Kind()
-}
diff --git a/builtin/utils.go b/builtin/utils.go
new file mode 100644
index 000000000..64a84b747
--- /dev/null
+++ b/builtin/utils.go
@@ -0,0 +1,16 @@
+package builtin
+
+import "reflect"
+
+var (
+	anyType     = reflect.TypeOf(new(interface{})).Elem()
+	integerType = reflect.TypeOf(0)
+	floatType   = reflect.TypeOf(float64(0))
+)
+
+func kind(t reflect.Type) reflect.Kind {
+	if t == nil {
+		return reflect.Invalid
+	}
+	return t.Kind()
+}
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 4b2f94603..11f3865e6 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -563,8 +563,8 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 		c.compile(arg)
 	}
 	if node.Func != nil {
-		if node.Func.Opcode > 0 {
-			c.emit(OpBuiltin, node.Func.Opcode)
+		if node.Func.Id > 0 {
+			c.emit(OpBuiltin, node.Func.Id)
 			return
 		}
 		switch len(node.Arguments) {

From 078f2e8de33c12531d44ba0fcbcb6ce99e80f0b8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 13 Aug 2023 21:43:47 +0200
Subject: [PATCH 032/506] Refactor builtin.Function and move builtin funcs to
 builtin package

---
 builtin/builtin.go    |  26 +++----
 builtin/func.go       | 173 ++++++++++++++++++++++++++++++++++++++++++
 compiler/compiler.go  |   4 -
 vm/opcodes.go         |   1 -
 vm/program.go         |  11 ---
 vm/runtime/runtime.go |  91 ----------------------
 vm/vm.go              |  22 +-----
 7 files changed, 183 insertions(+), 145 deletions(-)
 create mode 100644 builtin/func.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index f0b2fe887..4d600e5d5 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -7,23 +7,15 @@ import (
 
 type Function struct {
 	Name     string
-	Id       int
 	Func     func(args ...interface{}) (interface{}, error)
 	Types    []reflect.Type
 	Validate func(args []reflect.Type) (reflect.Type, error)
 }
 
-const (
-	Len = iota + 1
-	Abs
-	Int
-	Float
-)
-
-var Builtins = map[int]*Function{
-	Len: {
+var Builtins = []*Function{
+	{
 		Name: "len",
-		Id:   Len,
+		Func: Len,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for len (expected 1, got %d)", len(args))
@@ -35,9 +27,9 @@ var Builtins = map[int]*Function{
 			return anyType, fmt.Errorf("invalid argument for len (type %s)", args[0])
 		},
 	},
-	Abs: {
+	{
 		Name: "abs",
-		Id:   Abs,
+		Func: Abs,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for abs (expected 1, got %d)", len(args))
@@ -49,9 +41,9 @@ var Builtins = map[int]*Function{
 			return anyType, fmt.Errorf("invalid argument for abs (type %s)", args[0])
 		},
 	},
-	Int: {
+	{
 		Name: "int",
-		Id:   Int,
+		Func: Int,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for int (expected 1, got %d)", len(args))
@@ -67,9 +59,9 @@ var Builtins = map[int]*Function{
 			return anyType, fmt.Errorf("invalid argument for int (type %s)", args[0])
 		},
 	},
-	Float: {
+	{
 		Name: "float",
-		Id:   Float,
+		Func: Float,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for float (expected 1, got %d)", len(args))
diff --git a/builtin/func.go b/builtin/func.go
new file mode 100644
index 000000000..d120ede59
--- /dev/null
+++ b/builtin/func.go
@@ -0,0 +1,173 @@
+package builtin
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+func Len(xs ...interface{}) (interface{}, error) {
+	x := xs[0]
+	v := reflect.ValueOf(x)
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
+		return v.Len(), nil
+	default:
+		return nil, fmt.Errorf("invalid argument for len (type %T)", x)
+	}
+}
+
+func Abs(xs ...interface{}) (interface{}, error) {
+	x := xs[0]
+	switch x.(type) {
+	case float32:
+		if x.(float32) < 0 {
+			return -x.(float32), nil
+		} else {
+			return x, nil
+		}
+	case float64:
+		if x.(float64) < 0 {
+			return -x.(float64), nil
+		} else {
+			return x, nil
+		}
+	case int:
+		if x.(int) < 0 {
+			return -x.(int), nil
+		} else {
+			return x, nil
+		}
+	case int8:
+		if x.(int8) < 0 {
+			return -x.(int8), nil
+		} else {
+			return x, nil
+		}
+	case int16:
+		if x.(int16) < 0 {
+			return -x.(int16), nil
+		} else {
+			return x, nil
+		}
+	case int32:
+		if x.(int32) < 0 {
+			return -x.(int32), nil
+		} else {
+			return x, nil
+		}
+	case int64:
+		if x.(int64) < 0 {
+			return -x.(int64), nil
+		} else {
+			return x, nil
+		}
+	case uint:
+		if x.(uint) < 0 {
+			return -x.(uint), nil
+		} else {
+			return x, nil
+		}
+	case uint8:
+		if x.(uint8) < 0 {
+			return -x.(uint8), nil
+		} else {
+			return x, nil
+		}
+	case uint16:
+		if x.(uint16) < 0 {
+			return -x.(uint16), nil
+		} else {
+			return x, nil
+		}
+	case uint32:
+		if x.(uint32) < 0 {
+			return -x.(uint32), nil
+		} else {
+			return x, nil
+		}
+	case uint64:
+		if x.(uint64) < 0 {
+			return -x.(uint64), nil
+		} else {
+			return x, nil
+		}
+	}
+	return nil, fmt.Errorf("invalid argument for abs (type %T)", x)
+}
+
+func Int(xs ...interface{}) (interface{}, error) {
+	x := xs[0]
+	switch x := x.(type) {
+	case float32:
+		return int(x), nil
+	case float64:
+		return int(x), nil
+	case int:
+		return x, nil
+	case int8:
+		return int(x), nil
+	case int16:
+		return int(x), nil
+	case int32:
+		return int(x), nil
+	case int64:
+		return int(x), nil
+	case uint:
+		return int(x), nil
+	case uint8:
+		return int(x), nil
+	case uint16:
+		return int(x), nil
+	case uint32:
+		return int(x), nil
+	case uint64:
+		return int(x), nil
+	case string:
+		i, err := strconv.Atoi(x)
+		if err != nil {
+			return nil, fmt.Errorf("invalid operation: int(%s)", x)
+		}
+		return i, nil
+	default:
+		return nil, fmt.Errorf("invalid operation: int(%T)", x)
+	}
+}
+
+func Float(xs ...interface{}) (interface{}, error) {
+	x := xs[0]
+	switch x := x.(type) {
+	case float32:
+		return float64(x), nil
+	case float64:
+		return x, nil
+	case int:
+		return float64(x), nil
+	case int8:
+		return float64(x), nil
+	case int16:
+		return float64(x), nil
+	case int32:
+		return float64(x), nil
+	case int64:
+		return float64(x), nil
+	case uint:
+		return float64(x), nil
+	case uint8:
+		return float64(x), nil
+	case uint16:
+		return float64(x), nil
+	case uint32:
+		return float64(x), nil
+	case uint64:
+		return float64(x), nil
+	case string:
+		f, err := strconv.ParseFloat(x, 64)
+		if err != nil {
+			return nil, fmt.Errorf("invalid operation: float(%s)", x)
+		}
+		return f, nil
+	default:
+		return nil, fmt.Errorf("invalid operation: float(%T)", x)
+	}
+}
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 11f3865e6..917860b09 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -563,10 +563,6 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 		c.compile(arg)
 	}
 	if node.Func != nil {
-		if node.Func.Id > 0 {
-			c.emit(OpBuiltin, node.Func.Id)
-			return
-		}
 		switch len(node.Arguments) {
 		case 0:
 			c.emit(OpCall0, c.addFunction(node))
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 4bc9abf4d..70c788b42 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -57,7 +57,6 @@ const (
 	OpCallN
 	OpCallFast
 	OpCallTyped
-	OpBuiltin
 	OpArray
 	OpMap
 	OpLen
diff --git a/vm/program.go b/vm/program.go
index 936eca9a2..3212449c8 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -9,7 +9,6 @@ import (
 	"text/tabwriter"
 
 	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/vm/runtime"
 )
@@ -64,13 +63,6 @@ func (program *Program) Disassemble() string {
 			}
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, c)
 		}
-		builtIn := func(label string) {
-			f, ok := builtin.Builtins[arg]
-			if !ok {
-				panic(fmt.Sprintf("unknown builtin %v", arg))
-			}
-			_, _ = fmt.Fprintf(w, "%v\t%v\t%v\n", pp, "OpBuiltin", f.Name)
-		}
 
 		switch op {
 		case OpInvalid:
@@ -236,9 +228,6 @@ func (program *Program) Disassemble() string {
 			signature := reflect.TypeOf(FuncTypes[arg]).Elem().String()
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, "OpCallTyped", arg, signature)
 
-		case OpBuiltin:
-			builtIn("OpBuiltin")
-
 		case OpArray:
 			code("OpArray")
 
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 75ac94bf8..92abf16c6 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"math"
 	"reflect"
-	"strconv"
 )
 
 func Fetch(from, i interface{}) interface{} {
@@ -348,12 +347,6 @@ func ToInt(a interface{}) int {
 		return int(x)
 	case uint64:
 		return int(x)
-	case string:
-		i, err := strconv.Atoi(x)
-		if err != nil {
-			panic(fmt.Sprintf("invalid operation: int(%s)", x))
-		}
-		return i
 	default:
 		panic(fmt.Sprintf("invalid operation: int(%T)", x))
 	}
@@ -416,12 +409,6 @@ func ToFloat64(a interface{}) float64 {
 		return float64(x)
 	case uint64:
 		return float64(x)
-	case string:
-		f, err := strconv.ParseFloat(x, 64)
-		if err != nil {
-			panic(fmt.Sprintf("invalid operation: float(%s)", x))
-		}
-		return f
 	default:
 		panic(fmt.Sprintf("invalid operation: float(%T)", x))
 	}
@@ -439,81 +426,3 @@ func IsNil(v interface{}) bool {
 		return false
 	}
 }
-
-func Abs(x interface{}) interface{} {
-	switch x.(type) {
-	case float32:
-		if x.(float32) < 0 {
-			return -x.(float32)
-		} else {
-			return x
-		}
-	case float64:
-		if x.(float64) < 0 {
-			return -x.(float64)
-		} else {
-			return x
-		}
-	case int:
-		if x.(int) < 0 {
-			return -x.(int)
-		} else {
-			return x
-		}
-	case int8:
-		if x.(int8) < 0 {
-			return -x.(int8)
-		} else {
-			return x
-		}
-	case int16:
-		if x.(int16) < 0 {
-			return -x.(int16)
-		} else {
-			return x
-		}
-	case int32:
-		if x.(int32) < 0 {
-			return -x.(int32)
-		} else {
-			return x
-		}
-	case int64:
-		if x.(int64) < 0 {
-			return -x.(int64)
-		} else {
-			return x
-		}
-	case uint:
-		if x.(uint) < 0 {
-			return -x.(uint)
-		} else {
-			return x
-		}
-	case uint8:
-		if x.(uint8) < 0 {
-			return -x.(uint8)
-		} else {
-			return x
-		}
-	case uint16:
-		if x.(uint16) < 0 {
-			return -x.(uint16)
-		} else {
-			return x
-		}
-	case uint32:
-		if x.(uint32) < 0 {
-			return -x.(uint32)
-		} else {
-			return x
-		}
-	case uint64:
-		if x.(uint64) < 0 {
-			return -x.(uint64)
-		} else {
-			return x
-		}
-	}
-	panic(fmt.Sprintf("invalid argument for abs (type %T)", x))
-}
diff --git a/vm/vm.go b/vm/vm.go
index ec22c251d..4509a1f3f 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -8,7 +8,6 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/vm/runtime"
 )
@@ -411,8 +410,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			vm.push(runtime.Len(vm.current()))
 
 		case OpCast:
-			t := arg
-			switch t {
+			switch arg {
 			case 0:
 				vm.push(runtime.ToInt(vm.pop()))
 			case 1:
@@ -456,24 +454,6 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 		case OpEnd:
 			vm.scopes = vm.scopes[:len(vm.scopes)-1]
 
-		case OpBuiltin:
-			switch arg {
-			case builtin.Len:
-				vm.push(runtime.Len(vm.pop()))
-
-			case builtin.Abs:
-				vm.push(runtime.Abs(vm.pop()))
-
-			case builtin.Int:
-				vm.push(runtime.ToInt(vm.pop()))
-
-			case builtin.Float:
-				vm.push(runtime.ToFloat64(vm.pop()))
-
-			default:
-				panic(fmt.Sprintf("unknown builtin %v", arg))
-			}
-
 		default:
 			panic(fmt.Sprintf("unknown bytecode %#x", op))
 		}

From 65bd6736f33db2fd4e916aadbb025540252f8faf Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 10:29:38 +0200
Subject: [PATCH 033/506] Add OpCallBuiltin opcode to avoid an extra allocation

---
 builtin/builtin.go                            |  26 +-
 builtin/func.go                               | 126 ++++-----
 checker/checker.go                            | 260 +++++++++---------
 compiler/compiler.go                          |  19 +-
 expr_test.go                                  |  70 -----
 parser/parser.go                              |  25 +-
 parser/parser_test.go                         |   8 +-
 repl/repl.go                                  |  54 +++-
 .../interface_method/interface_method_test.go |  48 ++++
 test/patch/patch_test.go                      |  38 +++
 vm/opcodes.go                                 |   1 +
 vm/program.go                                 |   7 +
 vm/vm.go                                      |   4 +
 13 files changed, 393 insertions(+), 293 deletions(-)
 create mode 100644 test/interface_method/interface_method_test.go
 create mode 100644 test/patch/patch_test.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 4d600e5d5..32ef76302 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -8,14 +8,24 @@ import (
 type Function struct {
 	Name     string
 	Func     func(args ...interface{}) (interface{}, error)
+	Builtin1 func(arg interface{}) interface{}
 	Types    []reflect.Type
 	Validate func(args []reflect.Type) (reflect.Type, error)
 }
 
+var Index map[string]int
+
+func init() {
+	Index = make(map[string]int)
+	for i, fn := range Builtins {
+		Index[fn.Name] = i
+	}
+}
+
 var Builtins = []*Function{
 	{
-		Name: "len",
-		Func: Len,
+		Name:     "len",
+		Builtin1: Len,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for len (expected 1, got %d)", len(args))
@@ -28,8 +38,8 @@ var Builtins = []*Function{
 		},
 	},
 	{
-		Name: "abs",
-		Func: Abs,
+		Name:     "abs",
+		Builtin1: Abs,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for abs (expected 1, got %d)", len(args))
@@ -42,8 +52,8 @@ var Builtins = []*Function{
 		},
 	},
 	{
-		Name: "int",
-		Func: Int,
+		Name:     "int",
+		Builtin1: Int,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for int (expected 1, got %d)", len(args))
@@ -60,8 +70,8 @@ var Builtins = []*Function{
 		},
 	},
 	{
-		Name: "float",
-		Func: Float,
+		Name:     "float",
+		Builtin1: Float,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments for float (expected 1, got %d)", len(args))
diff --git a/builtin/func.go b/builtin/func.go
index d120ede59..f3f5c1208 100644
--- a/builtin/func.go
+++ b/builtin/func.go
@@ -6,168 +6,164 @@ import (
 	"strconv"
 )
 
-func Len(xs ...interface{}) (interface{}, error) {
-	x := xs[0]
+func Len(x interface{}) interface{} {
 	v := reflect.ValueOf(x)
 	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
-		return v.Len(), nil
+		return v.Len()
 	default:
-		return nil, fmt.Errorf("invalid argument for len (type %T)", x)
+		panic(fmt.Sprintf("invalid argument for len (type %T)", x))
 	}
 }
 
-func Abs(xs ...interface{}) (interface{}, error) {
-	x := xs[0]
+func Abs(x interface{}) interface{} {
 	switch x.(type) {
 	case float32:
 		if x.(float32) < 0 {
-			return -x.(float32), nil
+			return -x.(float32)
 		} else {
-			return x, nil
+			return x
 		}
 	case float64:
 		if x.(float64) < 0 {
-			return -x.(float64), nil
+			return -x.(float64)
 		} else {
-			return x, nil
+			return x
 		}
 	case int:
 		if x.(int) < 0 {
-			return -x.(int), nil
+			return -x.(int)
 		} else {
-			return x, nil
+			return x
 		}
 	case int8:
 		if x.(int8) < 0 {
-			return -x.(int8), nil
+			return -x.(int8)
 		} else {
-			return x, nil
+			return x
 		}
 	case int16:
 		if x.(int16) < 0 {
-			return -x.(int16), nil
+			return -x.(int16)
 		} else {
-			return x, nil
+			return x
 		}
 	case int32:
 		if x.(int32) < 0 {
-			return -x.(int32), nil
+			return -x.(int32)
 		} else {
-			return x, nil
+			return x
 		}
 	case int64:
 		if x.(int64) < 0 {
-			return -x.(int64), nil
+			return -x.(int64)
 		} else {
-			return x, nil
+			return x
 		}
 	case uint:
 		if x.(uint) < 0 {
-			return -x.(uint), nil
+			return -x.(uint)
 		} else {
-			return x, nil
+			return x
 		}
 	case uint8:
 		if x.(uint8) < 0 {
-			return -x.(uint8), nil
+			return -x.(uint8)
 		} else {
-			return x, nil
+			return x
 		}
 	case uint16:
 		if x.(uint16) < 0 {
-			return -x.(uint16), nil
+			return -x.(uint16)
 		} else {
-			return x, nil
+			return x
 		}
 	case uint32:
 		if x.(uint32) < 0 {
-			return -x.(uint32), nil
+			return -x.(uint32)
 		} else {
-			return x, nil
+			return x
 		}
 	case uint64:
 		if x.(uint64) < 0 {
-			return -x.(uint64), nil
+			return -x.(uint64)
 		} else {
-			return x, nil
+			return x
 		}
 	}
-	return nil, fmt.Errorf("invalid argument for abs (type %T)", x)
+	panic(fmt.Sprintf("invalid argument for abs (type %T)", x))
 }
 
-func Int(xs ...interface{}) (interface{}, error) {
-	x := xs[0]
+func Int(x interface{}) interface{} {
 	switch x := x.(type) {
 	case float32:
-		return int(x), nil
+		return int(x)
 	case float64:
-		return int(x), nil
+		return int(x)
 	case int:
-		return x, nil
+		return x
 	case int8:
-		return int(x), nil
+		return int(x)
 	case int16:
-		return int(x), nil
+		return int(x)
 	case int32:
-		return int(x), nil
+		return int(x)
 	case int64:
-		return int(x), nil
+		return int(x)
 	case uint:
-		return int(x), nil
+		return int(x)
 	case uint8:
-		return int(x), nil
+		return int(x)
 	case uint16:
-		return int(x), nil
+		return int(x)
 	case uint32:
-		return int(x), nil
+		return int(x)
 	case uint64:
-		return int(x), nil
+		return int(x)
 	case string:
 		i, err := strconv.Atoi(x)
 		if err != nil {
-			return nil, fmt.Errorf("invalid operation: int(%s)", x)
+			panic(fmt.Sprintf("invalid operation: int(%s)", x))
 		}
-		return i, nil
+		return i
 	default:
-		return nil, fmt.Errorf("invalid operation: int(%T)", x)
+		panic(fmt.Sprintf("invalid operation: int(%T)", x))
 	}
 }
 
-func Float(xs ...interface{}) (interface{}, error) {
-	x := xs[0]
+func Float(x interface{}) interface{} {
 	switch x := x.(type) {
 	case float32:
-		return float64(x), nil
+		return float64(x)
 	case float64:
-		return x, nil
+		return x
 	case int:
-		return float64(x), nil
+		return float64(x)
 	case int8:
-		return float64(x), nil
+		return float64(x)
 	case int16:
-		return float64(x), nil
+		return float64(x)
 	case int32:
-		return float64(x), nil
+		return float64(x)
 	case int64:
-		return float64(x), nil
+		return float64(x)
 	case uint:
-		return float64(x), nil
+		return float64(x)
 	case uint8:
-		return float64(x), nil
+		return float64(x)
 	case uint16:
-		return float64(x), nil
+		return float64(x)
 	case uint32:
-		return float64(x), nil
+		return float64(x)
 	case uint64:
-		return float64(x), nil
+		return float64(x)
 	case string:
 		f, err := strconv.ParseFloat(x, 64)
 		if err != nil {
-			return nil, fmt.Errorf("invalid operation: float(%s)", x)
+			panic(fmt.Sprintf("invalid operation: float(%s)", x))
 		}
-		return f, nil
+		return f
 	default:
-		return nil, fmt.Errorf("invalid operation: float(%T)", x)
+		panic(fmt.Sprintf("invalid operation: float(%T)", x))
 	}
 }
diff --git a/checker/checker.go b/checker/checker.go
index 86d6d6c6a..bd2557507 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -493,45 +493,8 @@ func (v *visitor) CallNode(node *ast.CallNode) (reflect.Type, info) {
 	fn, fnInfo := v.visit(node.Callee)
 
 	if fnInfo.fn != nil {
-		f := fnInfo.fn
-		node.Func = f
-		if f.Validate != nil {
-			args := make([]reflect.Type, len(node.Arguments))
-			for i, arg := range node.Arguments {
-				args[i], _ = v.visit(arg)
-			}
-			t, err := f.Validate(args)
-			if err != nil {
-				return v.error(node, "%v", err)
-			}
-			return t, info{}
-		}
-		if len(f.Types) == 0 {
-			t, err := v.checkFunc(f.Name, functionType, false, node)
-			if err != nil {
-				if v.err == nil {
-					v.err = err
-				}
-				return anyType, info{}
-			}
-			// No type was specified, so we assume the function returns any.
-			return t, info{}
-		}
-		var lastErr *file.Error
-		for _, t := range f.Types {
-			outType, err := v.checkFunc(f.Name, t, false, node)
-			if err != nil {
-				lastErr = err
-				continue
-			}
-			return outType, info{}
-		}
-		if lastErr != nil {
-			if v.err == nil {
-				v.err = lastErr
-			}
-			return anyType, info{}
-		}
+		node.Func = fnInfo.fn
+		return v.checkFunction(fnInfo.fn, node.Arguments, node)
 	}
 
 	fnName := "function"
@@ -564,7 +527,7 @@ func (v *visitor) CallNode(node *ast.CallNode) (reflect.Type, info) {
 			}
 		}
 
-		outType, err := v.checkFunc(fnName, fn, fnInfo.method, node)
+		outType, err := v.checkArguments(fnName, fn, fnInfo.method, node.Arguments, node)
 		if err != nil {
 			if v.err == nil {
 				v.err = err
@@ -579,90 +542,6 @@ func (v *visitor) CallNode(node *ast.CallNode) (reflect.Type, info) {
 	return v.error(node, "%v is not callable", fn)
 }
 
-func (v *visitor) checkFunc(name string, fn reflect.Type, method bool, node *ast.CallNode) (reflect.Type, *file.Error) {
-	if isAny(fn) {
-		return anyType, nil
-	}
-
-	if fn.NumOut() == 0 {
-		return anyType, &file.Error{
-			Location: node.Location(),
-			Message:  fmt.Sprintf("func %v doesn't return value", name),
-		}
-	}
-	if numOut := fn.NumOut(); numOut > 2 {
-		return anyType, &file.Error{
-			Location: node.Location(),
-			Message:  fmt.Sprintf("func %v returns more then two values", name),
-		}
-	}
-
-	// If func is method on an env, first argument should be a receiver,
-	// and actual arguments less than fnNumIn by one.
-	fnNumIn := fn.NumIn()
-	if method {
-		fnNumIn--
-	}
-	// Skip first argument in case of the receiver.
-	fnInOffset := 0
-	if method {
-		fnInOffset = 1
-	}
-
-	if fn.IsVariadic() {
-		if len(node.Arguments) < fnNumIn-1 {
-			return anyType, &file.Error{
-				Location: node.Location(),
-				Message:  fmt.Sprintf("not enough arguments to call %v", name),
-			}
-		}
-	} else {
-		if len(node.Arguments) > fnNumIn {
-			return anyType, &file.Error{
-				Location: node.Location(),
-				Message:  fmt.Sprintf("too many arguments to call %v", name),
-			}
-		}
-		if len(node.Arguments) < fnNumIn {
-			return anyType, &file.Error{
-				Location: node.Location(),
-				Message:  fmt.Sprintf("not enough arguments to call %v", name),
-			}
-		}
-	}
-
-	for i, arg := range node.Arguments {
-		t, _ := v.visit(arg)
-
-		var in reflect.Type
-		if fn.IsVariadic() && i >= fnNumIn-1 {
-			// For variadic arguments fn(xs ...int), go replaces type of xs (int) with ([]int).
-			// As we compare arguments one by one, we need underling type.
-			in = fn.In(fn.NumIn() - 1).Elem()
-		} else {
-			in = fn.In(i + fnInOffset)
-		}
-
-		if isIntegerOrArithmeticOperation(arg) && (isInteger(in) || isFloat(in)) {
-			t = in
-			setTypeForIntegers(arg, t)
-		}
-
-		if t == nil {
-			continue
-		}
-
-		if !t.AssignableTo(in) && t.Kind() != reflect.Interface {
-			return anyType, &file.Error{
-				Location: arg.Location(),
-				Message:  fmt.Sprintf("cannot use %v as argument (type %v) to call %v ", t, in, name),
-			}
-		}
-	}
-
-	return fn.Out(0), nil
-}
-
 func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 	switch node.Name {
 	case "all", "none", "any", "one":
@@ -748,10 +627,139 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return integerType, info{}
 		}
 		return v.error(node.Arguments[1], "closure should has one input and one output param")
+	}
 
-	default:
-		return v.error(node, "unknown builtin %v", node.Name)
+	if id, ok := builtin.Index[node.Name]; ok {
+		return v.checkFunction(builtin.Builtins[id], node.Arguments, node)
 	}
+
+	return v.error(node, "unknown builtin %v", node.Name)
+}
+
+func (v *visitor) checkFunction(f *builtin.Function, arguments []ast.Node, node ast.Node) (reflect.Type, info) {
+	if f.Validate != nil {
+		args := make([]reflect.Type, len(arguments))
+		for i, arg := range arguments {
+			args[i], _ = v.visit(arg)
+		}
+		t, err := f.Validate(args)
+		if err != nil {
+			return v.error(node, "%v", err)
+		}
+		return t, info{}
+	}
+	if len(f.Types) == 0 {
+		t, err := v.checkArguments(f.Name, functionType, false, arguments, node)
+		if err != nil {
+			if v.err == nil {
+				v.err = err
+			}
+			return anyType, info{}
+		}
+		// No type was specified, so we assume the function returns any.
+		return t, info{}
+	}
+	var lastErr *file.Error
+	for _, t := range f.Types {
+		outType, err := v.checkArguments(f.Name, t, false, arguments, node)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		return outType, info{}
+	}
+	if lastErr != nil {
+		if v.err == nil {
+			v.err = lastErr
+		}
+		return anyType, info{}
+	}
+
+	return v.error(node, "no matching overload for %v", f.Name)
+}
+
+func (v *visitor) checkArguments(name string, fn reflect.Type, method bool, arguments []ast.Node, node ast.Node) (reflect.Type, *file.Error) {
+	if isAny(fn) {
+		return anyType, nil
+	}
+
+	if fn.NumOut() == 0 {
+		return anyType, &file.Error{
+			Location: node.Location(),
+			Message:  fmt.Sprintf("func %v doesn't return value", name),
+		}
+	}
+	if numOut := fn.NumOut(); numOut > 2 {
+		return anyType, &file.Error{
+			Location: node.Location(),
+			Message:  fmt.Sprintf("func %v returns more then two values", name),
+		}
+	}
+
+	// If func is method on an env, first argument should be a receiver,
+	// and actual arguments less than fnNumIn by one.
+	fnNumIn := fn.NumIn()
+	if method {
+		fnNumIn--
+	}
+	// Skip first argument in case of the receiver.
+	fnInOffset := 0
+	if method {
+		fnInOffset = 1
+	}
+
+	if fn.IsVariadic() {
+		if len(arguments) < fnNumIn-1 {
+			return anyType, &file.Error{
+				Location: node.Location(),
+				Message:  fmt.Sprintf("not enough arguments to call %v", name),
+			}
+		}
+	} else {
+		if len(arguments) > fnNumIn {
+			return anyType, &file.Error{
+				Location: node.Location(),
+				Message:  fmt.Sprintf("too many arguments to call %v", name),
+			}
+		}
+		if len(arguments) < fnNumIn {
+			return anyType, &file.Error{
+				Location: node.Location(),
+				Message:  fmt.Sprintf("not enough arguments to call %v", name),
+			}
+		}
+	}
+
+	for i, arg := range arguments {
+		t, _ := v.visit(arg)
+
+		var in reflect.Type
+		if fn.IsVariadic() && i >= fnNumIn-1 {
+			// For variadic arguments fn(xs ...int), go replaces type of xs (int) with ([]int).
+			// As we compare arguments one by one, we need underling type.
+			in = fn.In(fn.NumIn() - 1).Elem()
+		} else {
+			in = fn.In(i + fnInOffset)
+		}
+
+		if isIntegerOrArithmeticOperation(arg) && (isInteger(in) || isFloat(in)) {
+			t = in
+			setTypeForIntegers(arg, t)
+		}
+
+		if t == nil {
+			continue
+		}
+
+		if !t.AssignableTo(in) && t.Kind() != reflect.Interface {
+			return anyType, &file.Error{
+				Location: arg.Location(),
+				Message:  fmt.Sprintf("cannot use %v as argument (type %v) to call %v ", t, in, name),
+			}
+		}
+	}
+
+	return fn.Out(0), nil
 }
 
 func (v *visitor) ClosureNode(node *ast.ClosureNode) (reflect.Type, info) {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 917860b09..119ec48f6 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -5,6 +5,7 @@ import (
 	"reflect"
 
 	"github.com/antonmedv/expr/ast"
+	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/conf"
 	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/parser"
@@ -603,6 +604,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpTrue)
 		c.patchJump(loopBreak)
 		c.emit(OpEnd)
+		return
 
 	case "none":
 		c.compile(node.Arguments[0])
@@ -617,6 +619,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpTrue)
 		c.patchJump(loopBreak)
 		c.emit(OpEnd)
+		return
 
 	case "any":
 		c.compile(node.Arguments[0])
@@ -630,6 +633,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpFalse)
 		c.patchJump(loopBreak)
 		c.emit(OpEnd)
+		return
 
 	case "one":
 		c.compile(node.Arguments[0])
@@ -644,6 +648,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emitPush(1)
 		c.emit(OpEqual)
 		c.emit(OpEnd)
+		return
 
 	case "filter":
 		c.compile(node.Arguments[0])
@@ -658,6 +663,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpGetCount)
 		c.emit(OpEnd)
 		c.emit(OpArray)
+		return
 
 	case "map":
 		c.compile(node.Arguments[0])
@@ -668,6 +674,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpGetLen)
 		c.emit(OpEnd)
 		c.emit(OpArray)
+		return
 
 	case "count":
 		c.compile(node.Arguments[0])
@@ -680,10 +687,18 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		})
 		c.emit(OpGetCount)
 		c.emit(OpEnd)
+		return
+	}
 
-	default:
-		panic(fmt.Sprintf("unknown builtin %v", node.Name))
+	if id, ok := builtin.Index[node.Name]; ok {
+		for _, arg := range node.Arguments {
+			c.compile(arg)
+		}
+		c.emit(OpCallBuiltin, id)
+		return
 	}
+
+	panic(fmt.Sprintf("unknown builtin %v", node.Name))
 }
 
 func (c *compiler) emitCond(body func()) {
diff --git a/expr_test.go b/expr_test.go
index 3cda97fef..e7e432cd8 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1308,34 +1308,6 @@ func TestPatch(t *testing.T) {
 	require.Equal(t, true, output)
 }
 
-type lengthPatcher struct{}
-
-func (p *lengthPatcher) Visit(node *ast.Node) {
-	switch n := (*node).(type) {
-	case *ast.MemberNode:
-		if prop, ok := n.Property.(*ast.StringNode); ok && prop.Value == "length" {
-			ast.Patch(node, &ast.CallNode{
-				Callee:    &ast.IdentifierNode{Value: "len"},
-				Arguments: []ast.Node{n.Node},
-			})
-		}
-	}
-}
-
-func TestPatch_length(t *testing.T) {
-	program, err := expr.Compile(
-		`String.length == 5`,
-		expr.Env(mockEnv{}),
-		expr.Patch(&lengthPatcher{}),
-	)
-	require.NoError(t, err)
-
-	env := mockEnv{String: "hello"}
-	output, err := expr.Run(program, env)
-	require.NoError(t, err)
-	require.Equal(t, true, output)
-}
-
 func TestCompile_exposed_error(t *testing.T) {
 	_, err := expr.Compile(`1 == true`)
 	require.Error(t, err)
@@ -1864,48 +1836,6 @@ func TestEnv_keyword(t *testing.T) {
 
 }
 
-type Bar interface {
-	Bar() int
-}
-type Foo interface {
-	Foo() Bar
-}
-
-type FooImpl struct{}
-
-func (f FooImpl) Foo() Bar {
-	return BarImpl{}
-}
-
-type BarImpl struct{}
-
-// Aba is a special method that is not part of the Bar interface,
-// but is used to test that the correct method is called. "Aba" name
-// is chosen to be before "Bar" in the alphabet.
-func (b BarImpl) Aba() bool {
-	return true
-}
-
-func (b BarImpl) Bar() int {
-	return 42
-}
-
-func TestEval_interface_method(t *testing.T) {
-	require.True(t, BarImpl{}.Aba())
-	require.True(t, BarImpl{}.Bar() == 42)
-
-	env := map[string]interface{}{
-		"var": FooImpl{},
-	}
-	p, err := expr.Compile(`var.Foo().Bar()`, expr.Env(env))
-
-	assert.NoError(t, err)
-
-	out, err := expr.Run(p, env)
-	assert.NoError(t, err)
-	assert.Equal(t, 42, out)
-}
-
 // Mock types
 
 type mockEnv struct {
diff --git a/parser/parser.go b/parser/parser.go
index ac54e29b3..0792ead1c 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -7,6 +7,7 @@ import (
 	"unicode/utf8"
 
 	. "github.com/antonmedv/expr/ast"
+	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/file"
 	. "github.com/antonmedv/expr/parser/lexer"
 )
@@ -57,11 +58,9 @@ var binaryOperators = map[string]operator{
 	"??":         {500, left},
 }
 
-type builtin struct {
+var predicates = map[string]struct {
 	arity int
-}
-
-var builtins = map[string]builtin{
+}{
 	"all":    {2},
 	"none":   {2},
 	"any":    {2},
@@ -355,7 +354,7 @@ func (p *parser) parseCall(token Token) Node {
 	if p.current.Is(Bracket, "(") {
 		var arguments []Node
 
-		if b, ok := builtins[token.Value]; ok {
+		if b, ok := predicates[token.Value]; ok {
 			p.expect(Bracket, "(")
 			if b.arity == 1 {
 				arguments = make([]Node, 1)
@@ -373,6 +372,12 @@ func (p *parser) parseCall(token Token) Node {
 				Arguments: arguments,
 			}
 			node.SetLocation(token.Location)
+		} else if _, ok := builtin.Index[token.Value]; ok {
+			node = &BuiltinNode{
+				Name:      token.Value,
+				Arguments: p.parseArguments(),
+			}
+			node.SetLocation(token.Location)
 		} else {
 			callee := &IdentifierNode{Value: token.Value}
 			callee.SetLocation(token.Location)
@@ -588,13 +593,21 @@ func (p *parser) parsePipe(node Node) Node {
 
 	arguments := []Node{node}
 
-	if b, ok := builtins[identifier.Value]; ok {
+	if b, ok := predicates[identifier.Value]; ok {
 		p.expect(Bracket, "(")
 		if b.arity == 2 {
 			arguments = append(arguments, p.parseClosure())
 		}
 		p.expect(Bracket, ")")
 
+		node = &BuiltinNode{
+			Name:      identifier.Value,
+			Arguments: arguments,
+		}
+		node.SetLocation(identifier.Location)
+	} else if _, ok := builtin.Index[identifier.Value]; ok {
+		arguments = append(arguments, p.parseArguments()...)
+
 		node = &BuiltinNode{
 			Name:      identifier.Value,
 			Arguments: arguments,
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 4c162224c..256024e0d 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -265,8 +265,8 @@ func TestParse(t *testing.T) {
 		},
 		{
 			"len(foo)",
-			&CallNode{
-				Callee: &IdentifierNode{Value: "len"},
+			&BuiltinNode{
+				Name: "len",
 				Arguments: []Node{
 					&IdentifierNode{Value: "foo"},
 				},
@@ -644,8 +644,8 @@ func TestParse_pipe_operator(t *testing.T) {
 	expect := &CallNode{
 		Callee: &IdentifierNode{Value: "Foo"},
 		Arguments: []Node{
-			&CallNode{
-				Callee: &IdentifierNode{Value: "len"},
+			&BuiltinNode{
+				Name: "len",
 				Arguments: []Node{
 					&BuiltinNode{
 						Name: "map",
diff --git a/repl/repl.go b/repl/repl.go
index 280df9108..9072555a5 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -2,37 +2,67 @@ package main
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/vm"
 	"github.com/chzyer/readline"
 )
 
 func main() {
-	rl, err := readline.New("> ")
+	rl, err := readline.NewEx(&readline.Config{
+		Prompt: "> ",
+		AutoComplete: readline.NewPrefixCompleter(
+			readline.PcItem("exit"),
+			readline.PcItem("opcodes"),
+			readline.PcItem("len"),
+			readline.PcItem("abs"),
+			readline.PcItem("int"),
+			readline.PcItem("float"),
+			readline.PcItem("map"),
+			readline.PcItem("filter"),
+			readline.PcItem("all"),
+			readline.PcItem("any"),
+			readline.PcItem("none"),
+			readline.PcItem("one"),
+			readline.PcItem("count"),
+			readline.PcItem("sum"),
+		),
+	})
 	if err != nil {
 		panic(err)
 	}
 	defer rl.Close()
 
+	var program *vm.Program
 	for {
 		line, err := rl.Readline()
 		if err != nil { // io.EOF when Ctrl-D is pressed
 			break
 		}
-
+		line = strings.TrimSpace(line)
 		if line == "exit" {
 			break
 		}
+		if line == "opcodes" {
+			if program == nil {
+				fmt.Println("no program")
+				continue
+			}
+			fmt.Println(program.Disassemble())
+			continue
+		}
 
-		result := evaluate(line)
-		fmt.Println(result)
-	}
-}
-
-func evaluate(input string) string {
-	result, err := expr.Eval(input, nil)
-	if err != nil {
-		return err.Error()
+		program, err = expr.Compile(line, expr.Env(nil))
+		if err != nil {
+			fmt.Printf("compile error: %s\n", err)
+			continue
+		}
+		output, err := expr.Run(program, nil)
+		if err != nil {
+			fmt.Printf("runtime error: %s\n", err)
+			continue
+		}
+		fmt.Println(output)
 	}
-	return fmt.Sprintf("%v", result)
 }
diff --git a/test/interface_method/interface_method_test.go b/test/interface_method/interface_method_test.go
new file mode 100644
index 000000000..44d765f04
--- /dev/null
+++ b/test/interface_method/interface_method_test.go
@@ -0,0 +1,48 @@
+package interface_method_test
+
+import (
+	"testing"
+
+	"github.com/antonmedv/expr"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type Bar interface {
+	Bar() int
+}
+
+type FooImpl struct{}
+
+func (f FooImpl) Foo() Bar {
+	return BarImpl{}
+}
+
+type BarImpl struct{}
+
+// Aba is a special method that is not part of the Bar interface,
+// but is used to test that the correct method is called. "Aba" name
+// is chosen to be before "Bar" in the alphabet.
+func (b BarImpl) Aba() bool {
+	return true
+}
+
+func (b BarImpl) Bar() int {
+	return 42
+}
+
+func TestInterfaceMethod(t *testing.T) {
+	require.True(t, BarImpl{}.Aba())
+	require.True(t, BarImpl{}.Bar() == 42)
+
+	env := map[string]interface{}{
+		"var": FooImpl{},
+	}
+	p, err := expr.Compile(`var.Foo().Bar()`, expr.Env(env))
+
+	assert.NoError(t, err)
+
+	out, err := expr.Run(p, env)
+	assert.NoError(t, err)
+	assert.Equal(t, 42, out)
+}
diff --git a/test/patch/patch_test.go b/test/patch/patch_test.go
new file mode 100644
index 000000000..cc7b3fd5d
--- /dev/null
+++ b/test/patch/patch_test.go
@@ -0,0 +1,38 @@
+package patch_test
+
+import (
+	"testing"
+
+	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/ast"
+	"github.com/antonmedv/expr/test/mock"
+	"github.com/stretchr/testify/require"
+)
+
+type lengthPatcher struct{}
+
+func (p *lengthPatcher) Visit(node *ast.Node) {
+	switch n := (*node).(type) {
+	case *ast.MemberNode:
+		if prop, ok := n.Property.(*ast.StringNode); ok && prop.Value == "length" {
+			ast.Patch(node, &ast.BuiltinNode{
+				Name:      "len",
+				Arguments: []ast.Node{n.Node},
+			})
+		}
+	}
+}
+
+func TestPatch_length(t *testing.T) {
+	program, err := expr.Compile(
+		`String.length == 5`,
+		expr.Env(mock.Env{}),
+		expr.Patch(&lengthPatcher{}),
+	)
+	require.NoError(t, err)
+
+	env := mock.Env{String: "hello"}
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, true, output)
+}
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 70c788b42..985af1df7 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -57,6 +57,7 @@ const (
 	OpCallN
 	OpCallFast
 	OpCallTyped
+	OpCallBuiltin
 	OpArray
 	OpMap
 	OpLen
diff --git a/vm/program.go b/vm/program.go
index 3212449c8..be0fd59b7 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -9,6 +9,7 @@ import (
 	"text/tabwriter"
 
 	"github.com/antonmedv/expr/ast"
+	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/vm/runtime"
 )
@@ -63,6 +64,9 @@ func (program *Program) Disassemble() string {
 			}
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, c)
 		}
+		builtin := func(label string) {
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, builtin.Builtins[arg].Name)
+		}
 
 		switch op {
 		case OpInvalid:
@@ -228,6 +232,9 @@ func (program *Program) Disassemble() string {
 			signature := reflect.TypeOf(FuncTypes[arg]).Elem().String()
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, "OpCallTyped", arg, signature)
 
+		case OpCallBuiltin:
+			builtin("OpCallBuiltin")
+
 		case OpArray:
 			code("OpArray")
 
diff --git a/vm/vm.go b/vm/vm.go
index 4509a1f3f..70f0ddca5 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/vm/runtime"
 )
@@ -380,6 +381,9 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			out := vm.call(fn, arg)
 			vm.push(out)
 
+		case OpCallBuiltin:
+			vm.push(builtin.Builtins[arg].Builtin1(vm.pop()))
+
 		case OpArray:
 			size := vm.pop().(int)
 			array := make([]interface{}, size)

From 47093a6b75cc27f00d1074794597f16ac2a3130d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 11:35:59 +0200
Subject: [PATCH 034/506] Refactor expr_test.go

---
 checker/checker.go      |   3 +
 expr_test.go            | 480 ++++++++++++----------------------------
 test/mock/mock.go       | 105 ++++++++-
 test/time/time_test.go  | 102 +++++++++
 vm/runtime/generated.go |   2 +
 vm/vm_test.go           |  89 --------
 6 files changed, 345 insertions(+), 436 deletions(-)
 create mode 100644 test/time/time_test.go

diff --git a/checker/checker.go b/checker/checker.go
index bd2557507..8cd2f2b93 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -262,6 +262,9 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 		if isTime(l) && isTime(r) {
 			return durationType, info{}
 		}
+		if isTime(l) && isDuration(r) {
+			return timeType, info{}
+		}
 		if or(l, r, isNumber, isTime) {
 			return anyType, info{}
 		}
diff --git a/expr_test.go b/expr_test.go
index e7e432cd8..481cda37d 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -4,13 +4,13 @@ import (
 	"encoding/json"
 	"fmt"
 	"reflect"
-	"strings"
 	"testing"
 	"time"
 
 	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/file"
+	"github.com/antonmedv/expr/test/mock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -411,7 +411,7 @@ func ExampleAllowUndefinedVariables_zero_value_functions() {
 	code := `words == "" ? Split("foo,bar", ",") : Split(words, ",")`
 
 	// Env is map[string]string type on which methods are defined.
-	env := mockMapStringStringEnv{}
+	env := mock.MapStringStringEnv{}
 
 	options := []expr.Option{
 		expr.Env(env),
@@ -434,6 +434,18 @@ func ExampleAllowUndefinedVariables_zero_value_functions() {
 	// Output: [foo bar]
 }
 
+type patcher struct{}
+
+func (p *patcher) Visit(node *ast.Node) {
+	switch n := (*node).(type) {
+	case *ast.MemberNode:
+		ast.Patch(node, &ast.CallNode{
+			Callee:    &ast.IdentifierNode{Value: "get"},
+			Arguments: []ast.Node{n.Node, n.Property},
+		})
+	}
+}
+
 func ExamplePatch() {
 	/*
 		type patcher struct{}
@@ -476,13 +488,13 @@ func ExamplePatch() {
 }
 
 func TestOperator_struct(t *testing.T) {
-	env := &mockEnv{
-		BirthDay: time.Date(2017, time.October, 23, 18, 30, 0, 0, time.UTC),
+	env := mock.Env{
+		Time: time.Date(2017, time.October, 23, 18, 30, 0, 0, time.UTC),
 	}
 
-	code := `BirthDay == "2017-10-23"`
+	code := `Time == "2017-10-23"`
 
-	program, err := expr.Compile(code, expr.Env(&mockEnv{}), expr.Operator("==", "DateEqual"))
+	program, err := expr.Compile(code, expr.Env(mock.Env{}), expr.Operator("==", "TimeEqualString"))
 	require.NoError(t, err)
 
 	output, err := expr.Run(program, env)
@@ -491,28 +503,26 @@ func TestOperator_struct(t *testing.T) {
 }
 
 func TestOperator_options_another_order(t *testing.T) {
-	code := `BirthDay == "2017-10-23"`
-	_, err := expr.Compile(code, expr.Operator("==", "DateEqual"), expr.Env(&mockEnv{}))
+	code := `Time == "2017-10-23"`
+	_, err := expr.Compile(code, expr.Operator("==", "TimeEqualString"), expr.Env(&mock.Env{}))
 	require.NoError(t, err)
 }
 
 func TestOperator_no_env(t *testing.T) {
 	code := `BirthDay == "2017-10-23"`
 	require.Panics(t, func() {
-		_, _ = expr.Compile(code, expr.Operator("==", "DateEqual"))
+		_, _ = expr.Compile(code, expr.Operator("==", "TimeEqualString"))
 	})
 }
 
 func TestOperator_interface(t *testing.T) {
-	env := &mockEnv{
-		Ticket: &ticket{Price: 100},
-	}
+	env := mock.Env{}
 
-	code := `Ticket == "$100" && "$100" == Ticket && Now != Ticket && Now == Now`
+	code := `Foo == "Foo.String" && "Foo.String" == Foo && Time != Foo && Time == Time`
 
 	program, err := expr.Compile(
 		code,
-		expr.Env(&mockEnv{}),
+		expr.Env(&mock.Env{}),
 		expr.Operator("==", "StringerStringEqual", "StringStringerEqual", "StringerStringerEqual"),
 		expr.Operator("!=", "NotStringerStringEqual", "NotStringStringerEqual", "NotStringerStringerEqual"),
 	)
@@ -543,49 +553,57 @@ func TestExpr_readme_example(t *testing.T) {
 
 func TestExpr(t *testing.T) {
 	date := time.Date(2017, time.October, 23, 18, 30, 0, 0, time.UTC)
-	timeNow := time.Now()
 	oneDay, _ := time.ParseDuration("24h")
-	timeNowPlusOneDay := timeNow.Add(oneDay)
-
-	env := &mockEnv{
-		Any:     "any",
-		Int:     0,
-		Int32:   0,
-		Int64:   0,
-		Uint64:  0,
-		Float64: 0,
-		Bool:    true,
-		String:  "string",
-		Array:   []int{1, 2, 3, 4, 5},
-		Ticket: &ticket{
-			Price: 100,
-		},
-		Passengers: &passengers{
-			Adults: 1,
-		},
-		Segments: []*segment{
-			{Origin: "MOW", Destination: "LED"},
-			{Origin: "LED", Destination: "MOW"},
-		},
-		BirthDay:       date,
-		Now:            timeNow,
-		NowPlusOne:     timeNowPlusOneDay,
-		OneDayDuration: oneDay,
-		One:            1,
-		Two:            2,
-		Three:          3,
-		MultiDimArray:  [][]int{{1, 2, 3}, {1, 2, 3}},
-		Sum: func(list []int) int {
-			var ret int
-			for _, el := range list {
-				ret += el
+	timeNowPlusOneDay := date.Add(oneDay)
+
+	env := mock.Env{
+		Embed:     mock.Embed{},
+		Ambiguous: "",
+		Any:       nil,
+		Bool:      true,
+		Float:     0,
+		Int64:     0,
+		Int32:     0,
+		Int:       0,
+		One:       1,
+		Two:       2,
+		Uint32:    0,
+		String:    "string",
+		BoolPtr:   nil,
+		FloatPtr:  nil,
+		IntPtr:    nil,
+		IntPtrPtr: nil,
+		StringPtr: nil,
+		Foo: mock.Foo{
+			Value: "foo",
+			Bar: mock.Bar{
+				Baz: "baz",
+			},
+		},
+		Abstract:           nil,
+		ArrayOfAny:         nil,
+		ArrayOfInt:         []int{1, 2, 3, 4, 5},
+		ArrayOfFoo:         nil,
+		MapOfFoo:           nil,
+		MapOfAny:           nil,
+		FuncParam:          nil,
+		FuncParamAny:       nil,
+		FuncTooManyReturns: nil,
+		FuncNamed:          nil,
+		NilAny:             nil,
+		NilFn:              nil,
+		NilStruct:          nil,
+		Variadic: func(head int, xs ...int) bool {
+			sum := 0
+			for _, x := range xs {
+				sum += x
 			}
-			return ret
+			return head == sum
 		},
-		Inc:       func(a int) int { return a + 1 },
-		Nil:       nil,
-		Tweets:    []tweet{{"Oh My God!", date}, {"How you doin?", date}, {"Could I be wearing any more clothes?", date}},
-		Lowercase: "lowercase",
+		Fast:        nil,
+		Time:        date,
+		TimePlusDay: timeNowPlusOneDay,
+		Duration:    oneDay,
 	}
 
 	tests := []struct {
@@ -697,7 +715,7 @@ func TestExpr(t *testing.T) {
 			true,
 		},
 		{
-			`1 in [1, 2, 3] && "foo" in {foo: 0, bar: 1} && "Price" in Ticket`,
+			`1 in [1, 2, 3] && "foo" in {foo: 0, bar: 1} && "Bar" in Foo`,
 			true,
 		},
 		{
@@ -745,20 +763,20 @@ func TestExpr(t *testing.T) {
 			5,
 		},
 		{
-			`Ticket.Price`,
-			100,
+			`Foo.Bar.Baz`,
+			"baz",
 		},
 		{
 			`Add(10, 5) + GetInt()`,
 			15,
 		},
 		{
-			`Ticket.String()`,
-			`$100`,
+			`Foo.Method().Baz`,
+			`baz (from Foo.Method)`,
 		},
 		{
-			`Ticket.PriceDiv(25)`,
-			4,
+			`Foo.MethodWithArgs("prefix ")`,
+			"prefix foo",
 		},
 		{
 			`len([1, 2, 3])`,
@@ -777,7 +795,7 @@ func TestExpr(t *testing.T) {
 			12,
 		},
 		{
-			`len(Array)`,
+			`len(ArrayOfInt)`,
 			5,
 		},
 		{
@@ -824,102 +842,70 @@ func TestExpr(t *testing.T) {
 			`count(1..30, {# % 3 == 0})`,
 			10,
 		},
-		{
-			`Now.After(BirthDay)`,
-			true,
-		},
 		{
 			`"a" < "b"`,
 			true,
 		},
 		{
-			`Now.Sub(Now).String() == Duration("0s").String()`,
+			`Time.Sub(Time).String() == "0s"`,
 			true,
 		},
-		{
-			`8.5 * Passengers.Adults * len(Segments)`,
-			float64(17),
-		},
 		{
 			`1 + 1`,
 			2,
 		},
 		{
-			`(One * Two) * Three == One * (Two * Three)`,
+			`(One * Two) * 3 == One * (Two * 3)`,
 			true,
 		},
 		{
-			`Array[0]`,
-			1,
-		},
-		{
-			`Sum(Array)`,
-			15,
+			`ArrayOfInt[1]`,
+			2,
 		},
 		{
-			`Array[0] < Array[1]`,
+			`ArrayOfInt[0] < ArrayOfInt[1]`,
 			true,
 		},
 		{
-			`Sum(MultiDimArray[0])`,
-			6,
-		},
-		{
-			`Sum(MultiDimArray[0]) + Sum(MultiDimArray[1])`,
-			12,
-		},
-		{
-			`Inc(Array[0] + Array[1])`,
-			4,
-		},
-		{
-			`Array[0] + Array[1]`,
-			3,
-		},
-		{
-			`Array[-1]`,
+			`ArrayOfInt[-1]`,
 			5,
 		},
 		{
-			`Array[1:2]`,
+			`ArrayOfInt[1:2]`,
 			[]int{2},
 		},
 		{
-			`Array[1:4]`,
+			`ArrayOfInt[1:4]`,
 			[]int{2, 3, 4},
 		},
 		{
-			`Array[-4:-1]`,
+			`ArrayOfInt[-4:-1]`,
 			[]int{2, 3, 4},
 		},
 		{
-			`Array[:3]`,
+			`ArrayOfInt[:3]`,
 			[]int{1, 2, 3},
 		},
 		{
-			`Array[3:]`,
+			`ArrayOfInt[3:]`,
 			[]int{4, 5},
 		},
 		{
-			`Array[0:5] == Array`,
+			`ArrayOfInt[0:5] == ArrayOfInt`,
 			true,
 		},
 		{
-			`Array[0:] == Array`,
+			`ArrayOfInt[0:] == ArrayOfInt`,
 			true,
 		},
 		{
-			`Array[:5] == Array`,
+			`ArrayOfInt[:5] == ArrayOfInt`,
 			true,
 		},
 		{
-			`Array[:] == Array`,
+			`ArrayOfInt[:] == ArrayOfInt`,
 			true,
 		},
-		{
-			`1 + 2 + Three`,
-			6,
-		},
 		{
 			`4 in 5..1`,
 			false,
@@ -928,16 +914,12 @@ func TestExpr(t *testing.T) {
 			`4..0`,
 			[]int{},
 		},
-		{
-			`MapArg({foo: "bar"})`,
-			"bar",
-		},
 		{
 			`NilStruct`,
-			(*time.Time)(nil),
+			(*mock.Foo)(nil),
 		},
 		{
-			`Nil == nil && nil == Nil && nil == nil && Nil == Nil && NilInt == nil && NilSlice == nil && NilStruct == nil`,
+			`NilAny == nil && nil == NilAny && nil == nil && NilAny == NilAny && NilInt == nil && NilSlice == nil && NilStruct == nil`,
 			true,
 		},
 		{
@@ -945,12 +927,12 @@ func TestExpr(t *testing.T) {
 			false,
 		},
 		{
-			`Variadic("head", 1, 2, 3)`,
-			[]int{1, 2, 3},
+			`Variadic(6, 1, 2, 3)`,
+			true,
 		},
 		{
-			`Variadic("empty")`,
-			[]int{},
+			`Variadic(0)`,
+			true,
 		},
 		{
 			`String[:]`,
@@ -973,98 +955,75 @@ func TestExpr(t *testing.T) {
 			"",
 		},
 		{
-			`Float(0)`,
-			float64(0),
-		},
-		{
-			`map(filter(Tweets, {len(.Text) > 10}), {Format(.Date)})`,
-			[]interface{}{"23 Oct 17 18:30 UTC", "23 Oct 17 18:30 UTC"},
-		},
-		{
-			`Concat("a", 1, [])`,
-			`a1[]`,
+			`map(filter(ArrayOfInt, # >= 3), # + 1)`,
+			[]interface{}{4, 5, 6},
 		},
 		{
-			`Tweets[0].Date < Now`,
+			`Time < Time + Duration`,
 			true,
 		},
 		{
-			`Now > Tweets[0].Date`,
+			`Time + Duration > Time`,
 			true,
 		},
 		{
-			`Now == Now`,
+			`Time == Time`,
 			true,
 		},
 		{
-			`Now >= Now`,
+			`Time >= Time`,
 			true,
 		},
 		{
-			`Now <= Now`,
+			`Time <= Time`,
 			true,
 		},
 		{
-			`Now == NowPlusOne`,
+			`Time == Time + Duration`,
 			false,
 		},
 		{
-			`Now != Now`,
+			`Time != Time`,
 			false,
 		},
 		{
-			`Now != NowPlusOne`,
-			true,
-		},
-		{
-			`NowPlusOne - Now`,
-			oneDay,
-		},
-		{
-			`Now + OneDayDuration`,
-			timeNowPlusOneDay,
-		},
-		{
-			`OneDayDuration + Now`,
-			timeNowPlusOneDay,
-		},
-		{
-			`lowercase`,
-			"lowercase",
+			`TimePlusDay - Duration`,
+			date,
 		},
 		{
-			`1 /* one*/ + 2 /* two */`,
+			`1 /* one */ + 2 // two`,
 			3,
 		},
 	}
 
 	for _, tt := range tests {
-		program, err := expr.Compile(tt.code, expr.Env(&mockEnv{}))
-		require.NoError(t, err, "compile error")
-
-		got, err := expr.Run(program, env)
-		require.NoError(t, err, "execution error")
+		t.Run(tt.code, func(t *testing.T) {
+			tt := tt
+			program, err := expr.Compile(tt.code, expr.Env(mock.Env{}))
+			require.NoError(t, err, "compile error")
 
-		assert.Equal(t, tt.want, got, tt.code)
+			got, err := expr.Run(program, env)
+			require.NoError(t, err, "run error")
+			assert.Equal(t, tt.want, got)
+		})
 	}
-
 	for _, tt := range tests {
-		if tt.code == `-Int64 == 0` {
+		t.Run(tt.code, func(t *testing.T) {
+			tt := tt
 			program, err := expr.Compile(tt.code, expr.Optimize(false))
-			require.NoError(t, err, "compile error")
+			require.NoError(t, err, "unoptimized")
 
 			got, err := expr.Run(program, env)
-			require.NoError(t, err, "run error")
-			assert.Equal(t, tt.want, got, "unoptimized: "+tt.code)
-		}
+			require.NoError(t, err, "unoptimized")
+			assert.Equal(t, tt.want, got, "unoptimized")
+		})
 	}
-
 	for _, tt := range tests {
 		t.Run(tt.code, func(t *testing.T) {
+			tt := tt
 			got, err := expr.Eval(tt.code, env)
-			require.NoError(t, err, "eval error: "+tt.code)
-
-			assert.Equal(t, tt.want, got, "eval: "+tt.code)
+			require.NoError(t, err, "eval")
+			assert.Equal(t, tt.want, got, "eval")
 		})
 	}
 }
@@ -1146,11 +1105,11 @@ func TestExpr_map_default_values_compile_check(t *testing.T) {
 		input string
 	}{
 		{
-			mockMapStringStringEnv{"foo": "bar"},
+			mock.MapStringStringEnv{"foo": "bar"},
 			`Split(foo, sep)`,
 		},
 		{
-			mockMapStringIntEnv{"foo": 1},
+			mock.MapStringIntEnv{"foo": 1},
 			`foo / bar`,
 		},
 	}
@@ -1167,7 +1126,7 @@ func TestExpr_calls_with_nil(t *testing.T) {
 			assert.Nil(t, b, "b is not nil")
 			return a == b
 		},
-		"is": is{},
+		"is": mock.Is{},
 	}
 
 	p, err := expr.Compile(
@@ -1294,16 +1253,13 @@ func (p *stringerPatcher) Visit(node *ast.Node) {
 
 func TestPatch(t *testing.T) {
 	program, err := expr.Compile(
-		`Ticket == "$100" and "$90" != Ticket + "0"`,
-		expr.Env(mockEnv{}),
-		expr.Patch(&stringerPatcher{}),
+		`Foo == "Foo.String"`,
+		expr.Env(mock.Env{}),
+		expr.Patch(&mock.StringerPatcher{}),
 	)
 	require.NoError(t, err)
 
-	env := mockEnv{
-		Ticket: &ticket{Price: 100},
-	}
-	output, err := expr.Run(program, env)
+	output, err := expr.Run(program, mock.Env{})
 	require.NoError(t, err)
 	require.Equal(t, true, output)
 }
@@ -1584,7 +1540,7 @@ func TestCompile_allow_to_use_interface_to_get_an_element_from_map(t *testing.T)
 
 	t.Run("with allow undefined variables", func(t *testing.T) {
 		code := `{'key': 'value'}[Key]`
-		env := mockMapStringStringEnv{}
+		env := mock.MapStringStringEnv{}
 		options := []expr.Option{
 			expr.AllowUndefinedVariables(),
 		}
@@ -1835,163 +1791,3 @@ func TestEnv_keyword(t *testing.T) {
 	}
 
 }
-
-// Mock types
-
-type mockEnv struct {
-	Any                  interface{}
-	Int, One, Two, Three int
-	Int32                int32
-	Int64                int64
-	Uint64               uint64
-	Float64              float64
-	Bool                 bool
-	String               string
-	Array                []int
-	MultiDimArray        [][]int
-	Sum                  func(list []int) int
-	Inc                  func(int) int
-	Ticket               *ticket
-	Passengers           *passengers
-	Segments             []*segment
-	BirthDay             time.Time
-	Now                  time.Time
-	NowPlusOne           time.Time
-	OneDayDuration       time.Duration
-	Nil                  interface{}
-	NilStruct            *time.Time
-	NilInt               *int
-	NilSlice             []ticket
-	Tweets               []tweet
-	Lowercase            string `expr:"lowercase"`
-}
-
-func (e *mockEnv) GetInt() int {
-	return e.Int
-}
-
-func (*mockEnv) Add(a, b int) int {
-	return a + b
-}
-
-func (*mockEnv) Duration(s string) time.Duration {
-	d, err := time.ParseDuration(s)
-	if err != nil {
-		panic(err)
-	}
-	return d
-}
-
-func (*mockEnv) MapArg(m map[string]interface{}) string {
-	return m["foo"].(string)
-}
-
-func (*mockEnv) DateEqual(date time.Time, s string) bool {
-	return date.Format("2006-01-02") == s
-}
-
-func (*mockEnv) StringerStringEqual(f fmt.Stringer, s string) bool {
-	return f.String() == s
-}
-
-func (*mockEnv) StringStringerEqual(s string, f fmt.Stringer) bool {
-	return s == f.String()
-}
-
-func (*mockEnv) StringerStringerEqual(f fmt.Stringer, g fmt.Stringer) bool {
-	return f.String() == g.String()
-}
-
-func (*mockEnv) NotStringerStringEqual(f fmt.Stringer, s string) bool {
-	return f.String() != s
-}
-
-func (*mockEnv) NotStringStringerEqual(s string, f fmt.Stringer) bool {
-	return s != f.String()
-}
-
-func (*mockEnv) NotStringerStringerEqual(f fmt.Stringer, g fmt.Stringer) bool {
-	return f.String() != g.String()
-}
-
-func (*mockEnv) Variadic(x string, xs ...int) []int {
-	return xs
-}
-
-func (*mockEnv) Concat(list ...interface{}) string {
-	out := ""
-	for _, e := range list {
-		out += fmt.Sprintf("%v", e)
-	}
-	return out
-}
-
-func (*mockEnv) Float(i interface{}) float64 {
-	switch t := i.(type) {
-	case int:
-		return float64(t)
-	case float64:
-		return t
-	default:
-		panic("unexpected type")
-	}
-}
-
-func (*mockEnv) Format(t time.Time) string {
-	return t.Format(time.RFC822)
-}
-
-type ticket struct {
-	Price int
-}
-
-func (t *ticket) PriceDiv(p int) int {
-	return t.Price / p
-}
-
-func (t *ticket) String() string {
-	return fmt.Sprintf("$%v", t.Price)
-}
-
-type passengers struct {
-	Adults   uint32
-	Children uint32
-	Infants  uint32
-}
-
-type segment struct {
-	Origin      string
-	Destination string
-	Date        time.Time
-}
-
-type tweet struct {
-	Text string
-	Date time.Time
-}
-
-type mockMapStringStringEnv map[string]string
-
-func (m mockMapStringStringEnv) Split(s, sep string) []string {
-	return strings.Split(s, sep)
-}
-
-type mockMapStringIntEnv map[string]int
-
-type is struct{}
-
-func (is) Nil(a interface{}) bool {
-	return a == nil
-}
-
-type patcher struct{}
-
-func (p *patcher) Visit(node *ast.Node) {
-	switch n := (*node).(type) {
-	case *ast.MemberNode:
-		ast.Patch(node, &ast.CallNode{
-			Callee:    &ast.IdentifierNode{Value: "get"},
-			Arguments: []ast.Node{n.Node, n.Property},
-		})
-	}
-}
diff --git a/test/mock/mock.go b/test/mock/mock.go
index f5474eda3..b59293cdd 100644
--- a/test/mock/mock.go
+++ b/test/mock/mock.go
@@ -1,6 +1,13 @@
 package mock
 
-import "time"
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"time"
+
+	"github.com/antonmedv/expr/ast"
+)
 
 type Env struct {
 	Embed
@@ -10,8 +17,11 @@ type Env struct {
 	Float              float64
 	Int64              int64
 	Int32              int32
-	Int                int
+	Int, One, Two      int
 	Uint32             uint32
+	Uint64             uint64
+	Float32            float32
+	Float64            float64
 	String             string
 	BoolPtr            *bool
 	FloatPtr           *float64
@@ -22,17 +32,22 @@ type Env struct {
 	Abstract           Abstract
 	ArrayOfAny         []interface{}
 	ArrayOfInt         []int
-	ArrayOfFoo         []Foo
+	ArrayOfFoo         []*Foo
 	MapOfFoo           map[string]Foo
 	MapOfAny           map[string]interface{}
 	FuncParam          func(_ bool, _ int, _ string) bool
 	FuncParamAny       func(_ interface{}) bool
 	FuncTooManyReturns func() (int, int, error)
 	FuncNamed          MyFunc
+	NilAny             interface{}
+	NilInt             *int
 	NilFn              func()
+	NilStruct          *Foo
+	NilSlice           []interface{}
 	Variadic           func(_ int, _ ...int) bool
 	Fast               func(...interface{}) interface{}
 	Time               time.Time
+	TimePlusDay        time.Time
 	Duration           time.Duration
 }
 
@@ -48,6 +63,42 @@ func (p Env) FuncTyped(_ string) int {
 	return 2023
 }
 
+func (p Env) TimeEqualString(a time.Time, s string) bool {
+	return a.Format("2006-01-02") == s
+}
+
+func (p Env) GetInt() int {
+	return p.Int
+}
+
+func (Env) Add(a, b int) int {
+	return a + b
+}
+
+func (Env) StringerStringEqual(f fmt.Stringer, s string) bool {
+	return f.String() == s
+}
+
+func (Env) StringStringerEqual(s string, f fmt.Stringer) bool {
+	return s == f.String()
+}
+
+func (Env) StringerStringerEqual(f fmt.Stringer, g fmt.Stringer) bool {
+	return f.String() == g.String()
+}
+
+func (Env) NotStringerStringEqual(f fmt.Stringer, s string) bool {
+	return f.String() != s
+}
+
+func (Env) NotStringStringerEqual(s string, f fmt.Stringer) bool {
+	return s != f.String()
+}
+
+func (Env) NotStringerStringerEqual(f fmt.Stringer, g fmt.Stringer) bool {
+	return f.String() != g.String()
+}
+
 type Embed struct {
 	EmbedEmbed
 	EmbedString string
@@ -62,11 +113,22 @@ type EmbedEmbed struct {
 }
 
 type Foo struct {
-	Bar Bar
+	Value string
+	Bar   Bar
 }
 
 func (Foo) Method() Bar {
-	return Bar{}
+	return Bar{
+		Baz: "baz (from Foo.Method)",
+	}
+}
+
+func (f Foo) MethodWithArgs(prefix string) string {
+	return prefix + f.Value
+}
+
+func (Foo) String() string {
+	return "Foo.String"
 }
 
 type Bar struct {
@@ -78,3 +140,36 @@ type Abstract interface {
 }
 
 type MyFunc func(string) int
+
+var stringer = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
+
+type StringerPatcher struct{}
+
+func (*StringerPatcher) Visit(node *ast.Node) {
+	t := (*node).Type()
+	if t == nil {
+		return
+	}
+	if t.Implements(stringer) {
+		ast.Patch(node, &ast.CallNode{
+			Callee: &ast.MemberNode{
+				Node:     *node,
+				Property: &ast.StringNode{Value: "String"},
+			},
+		})
+	}
+}
+
+type MapStringStringEnv map[string]string
+
+func (m MapStringStringEnv) Split(s, sep string) []string {
+	return strings.Split(s, sep)
+}
+
+type MapStringIntEnv map[string]int
+
+type Is struct{}
+
+func (Is) Nil(a interface{}) bool {
+	return a == nil
+}
diff --git a/test/time/time_test.go b/test/time/time_test.go
new file mode 100644
index 000000000..f6318426f
--- /dev/null
+++ b/test/time/time_test.go
@@ -0,0 +1,102 @@
+package time_test
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/antonmedv/expr/checker"
+	"github.com/antonmedv/expr/compiler"
+	"github.com/antonmedv/expr/conf"
+	"github.com/antonmedv/expr/parser"
+	"github.com/antonmedv/expr/vm"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTime(t *testing.T) {
+	testTime := time.Date(2000, time.Month(1), 1, 0, 0, 0, 0, time.UTC)
+	testDuration := time.Duration(1)
+
+	tests := []struct {
+		a       interface{}
+		b       interface{}
+		op      string
+		want    interface{}
+		wantErr bool
+	}{
+		{a: testTime, b: testTime, op: "<", wantErr: false, want: false},
+		{a: testTime, b: testTime, op: ">", wantErr: false, want: false},
+		{a: testTime, b: testTime, op: "<=", wantErr: false, want: true},
+		{a: testTime, b: testTime, op: ">=", wantErr: false, want: true},
+		{a: testTime, b: testTime, op: "==", wantErr: false, want: true},
+		{a: testTime, b: testTime, op: "!=", wantErr: false, want: false},
+		{a: testTime, b: testTime, op: "-", wantErr: false},
+		{a: testTime, b: testDuration, op: "+", wantErr: false},
+		{a: testTime, b: testDuration, op: "-", wantErr: false},
+
+		// error cases
+		{a: testTime, b: int64(1), op: "<", wantErr: true},
+		{a: testTime, b: float64(1), op: "<", wantErr: true},
+		{a: testTime, b: testDuration, op: "<", wantErr: true},
+
+		{a: testTime, b: int64(1), op: ">", wantErr: true},
+		{a: testTime, b: float64(1), op: ">", wantErr: true},
+		{a: testTime, b: testDuration, op: ">", wantErr: true},
+
+		{a: testTime, b: int64(1), op: "<=", wantErr: true},
+		{a: testTime, b: float64(1), op: "<=", wantErr: true},
+		{a: testTime, b: testDuration, op: "<=", wantErr: true},
+
+		{a: testTime, b: int64(1), op: ">=", wantErr: true},
+		{a: testTime, b: float64(1), op: ">=", wantErr: true},
+		{a: testTime, b: testDuration, op: ">=", wantErr: true},
+
+		{a: testTime, b: int64(1), op: "==", wantErr: false, want: false},
+		{a: testTime, b: float64(1), op: "==", wantErr: false, want: false},
+		{a: testTime, b: testDuration, op: "==", wantErr: false, want: false},
+
+		{a: testTime, b: int64(1), op: "!=", wantErr: false, want: true},
+		{a: testTime, b: float64(1), op: "!=", wantErr: false, want: true},
+		{a: testTime, b: testDuration, op: "!=", wantErr: false, want: true},
+
+		{a: testTime, b: int64(1), op: "-", wantErr: true},
+		{a: testTime, b: float64(1), op: "-", wantErr: true},
+
+		{a: testTime, b: testTime, op: "+", wantErr: true},
+		{a: testTime, b: int64(1), op: "+", wantErr: true},
+		{a: testTime, b: float64(1), op: "+", wantErr: true},
+		{a: testDuration, b: testTime, op: "+", wantErr: false},
+	}
+
+	for _, tt := range tests {
+		t.Run(fmt.Sprintf("time helper test `%T %s %T`", tt.a, tt.op, tt.b), func(t *testing.T) {
+			input := fmt.Sprintf("a %v b", tt.op)
+			env := map[string]interface{}{
+				"a": tt.a,
+				"b": tt.b,
+			}
+
+			config := conf.CreateNew()
+
+			tree, err := parser.Parse(input)
+			require.NoError(t, err)
+
+			_, err = checker.Check(tree, config)
+			require.NoError(t, err)
+
+			program, err := compiler.Compile(tree, config)
+			require.NoError(t, err)
+
+			got, err := vm.Run(program, env)
+			if tt.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+
+				if tt.want != nil {
+					require.Equal(t, tt.want, got)
+				}
+			}
+		})
+	}
+}
diff --git a/vm/runtime/generated.go b/vm/runtime/generated.go
index 09a4a200e..011a03325 100644
--- a/vm/runtime/generated.go
+++ b/vm/runtime/generated.go
@@ -2386,6 +2386,8 @@ func Subtract(a, b interface{}) interface{} {
 		switch y := b.(type) {
 		case time.Time:
 			return x.Sub(y)
+		case time.Duration:
+			return x.Add(-y)
 		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T - %T", a, b))
diff --git a/vm/vm_test.go b/vm/vm_test.go
index a5f24c29a..499020692 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
-	"time"
 
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/checker"
@@ -134,94 +133,6 @@ func TestRun_Helpers(t *testing.T) {
 	}
 }
 
-func TestRun_Helpers_Time(t *testing.T) {
-	testTime := time.Date(2000, time.Month(1), 1, 0, 0, 0, 0, time.UTC)
-	testDuration := time.Duration(1)
-
-	tests := []struct {
-		a       interface{}
-		b       interface{}
-		op      string
-		want    interface{}
-		wantErr bool
-	}{
-		{a: testTime, b: testTime, op: "<", wantErr: false, want: false},
-		{a: testTime, b: testTime, op: ">", wantErr: false, want: false},
-		{a: testTime, b: testTime, op: "<=", wantErr: false, want: true},
-		{a: testTime, b: testTime, op: ">=", wantErr: false, want: true},
-		{a: testTime, b: testTime, op: "==", wantErr: false, want: true},
-		{a: testTime, b: testTime, op: "!=", wantErr: false, want: false},
-		{a: testTime, b: testTime, op: "-", wantErr: false},
-		{a: testTime, b: testDuration, op: "+", wantErr: false},
-
-		// error cases
-		{a: testTime, b: int64(1), op: "<", wantErr: true},
-		{a: testTime, b: float64(1), op: "<", wantErr: true},
-		{a: testTime, b: testDuration, op: "<", wantErr: true},
-
-		{a: testTime, b: int64(1), op: ">", wantErr: true},
-		{a: testTime, b: float64(1), op: ">", wantErr: true},
-		{a: testTime, b: testDuration, op: ">", wantErr: true},
-
-		{a: testTime, b: int64(1), op: "<=", wantErr: true},
-		{a: testTime, b: float64(1), op: "<=", wantErr: true},
-		{a: testTime, b: testDuration, op: "<=", wantErr: true},
-
-		{a: testTime, b: int64(1), op: ">=", wantErr: true},
-		{a: testTime, b: float64(1), op: ">=", wantErr: true},
-		{a: testTime, b: testDuration, op: ">=", wantErr: true},
-
-		{a: testTime, b: int64(1), op: "==", wantErr: false, want: false},
-		{a: testTime, b: float64(1), op: "==", wantErr: false, want: false},
-		{a: testTime, b: testDuration, op: "==", wantErr: false, want: false},
-
-		{a: testTime, b: int64(1), op: "!=", wantErr: false, want: true},
-		{a: testTime, b: float64(1), op: "!=", wantErr: false, want: true},
-		{a: testTime, b: testDuration, op: "!=", wantErr: false, want: true},
-
-		{a: testTime, b: int64(1), op: "-", wantErr: true},
-		{a: testTime, b: float64(1), op: "-", wantErr: true},
-		{a: testTime, b: testDuration, op: "-", wantErr: true},
-
-		{a: testTime, b: testTime, op: "+", wantErr: true},
-		{a: testTime, b: int64(1), op: "+", wantErr: true},
-		{a: testTime, b: float64(1), op: "+", wantErr: true},
-		{a: testDuration, b: testTime, op: "+", wantErr: false},
-	}
-
-	for _, tt := range tests {
-		t.Run(fmt.Sprintf("time helper test `%T %s %T`", tt.a, tt.op, tt.b), func(t *testing.T) {
-			input := fmt.Sprintf("a %v b", tt.op)
-			env := map[string]interface{}{
-				"a": tt.a,
-				"b": tt.b,
-			}
-
-			config := conf.CreateNew()
-
-			tree, err := parser.Parse(input)
-			require.NoError(t, err)
-
-			_, err = checker.Check(tree, config)
-			require.NoError(t, err)
-
-			program, err := compiler.Compile(tree, config)
-			require.NoError(t, err)
-
-			got, err := vm.Run(program, env)
-			if tt.wantErr {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-
-				if tt.want != nil {
-					require.Equal(t, tt.want, got)
-				}
-			}
-		})
-	}
-}
-
 func TestRun_MemoryBudget(t *testing.T) {
 	input := `map(1..100, {map(1..100, {map(1..100, {0})})})`
 

From dfad27f50781d49a0d06d7bed6f07e0c5bd1801e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 11:40:14 +0200
Subject: [PATCH 035/506] Test fixes

---
 expr_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index 481cda37d..0f9f27f98 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -504,12 +504,12 @@ func TestOperator_struct(t *testing.T) {
 
 func TestOperator_options_another_order(t *testing.T) {
 	code := `Time == "2017-10-23"`
-	_, err := expr.Compile(code, expr.Operator("==", "TimeEqualString"), expr.Env(&mock.Env{}))
+	_, err := expr.Compile(code, expr.Operator("==", "TimeEqualString"), expr.Env(mock.Env{}))
 	require.NoError(t, err)
 }
 
 func TestOperator_no_env(t *testing.T) {
-	code := `BirthDay == "2017-10-23"`
+	code := `Time == "2017-10-23"`
 	require.Panics(t, func() {
 		_, _ = expr.Compile(code, expr.Operator("==", "TimeEqualString"))
 	})
@@ -522,7 +522,7 @@ func TestOperator_interface(t *testing.T) {
 
 	program, err := expr.Compile(
 		code,
-		expr.Env(&mock.Env{}),
+		expr.Env(mock.Env{}),
 		expr.Operator("==", "StringerStringEqual", "StringStringerEqual", "StringerStringerEqual"),
 		expr.Operator("!=", "NotStringerStringEqual", "NotStringStringerEqual", "NotStringerStringerEqual"),
 	)

From 57248060718ebcc46ebefbe4525ea6b57b5d7a78 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 11:48:20 +0200
Subject: [PATCH 036/506] Update patcher documentation

---
 docs/Visitor-and-Patch.md | 93 ++++++++++-----------------------------
 1 file changed, 23 insertions(+), 70 deletions(-)

diff --git a/docs/Visitor-and-Patch.md b/docs/Visitor-and-Patch.md
index f98418b05..05838dab1 100644
--- a/docs/Visitor-and-Patch.md
+++ b/docs/Visitor-and-Patch.md
@@ -47,17 +47,31 @@ Specify a visitor to modify the AST with `expr.Patch` function.
 program, err := expr.Compile(code, expr.Patch(&visitor{}))
 ```
  
-For example, we are going to replace the expression `list[-1]` with the `list[len(list)-1]`.
+For example, let's pass a context to every function call:
 
 ```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+
+	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/ast"
+)
+
 func main() {
 	env := map[string]interface{}{
-		"list": []int{1, 2, 3},
+		"foo": func(ctx context.Context, arg int) any {
+			// ...
+		},
+		"ctx": context.Background(),
 	}
 
-	code := `list[-1]` // will output 3
+	code := `foo(42)` // will be converted to foo(ctx, 42)
 
-	program, err := expr.Compile(code, expr.Env(env), expr.Patch(&patcher{}))
+	program, err := expr.Compile(code, expr.Env(env), expr.Patch(patcher{}))
 	if err != nil {
 		panic(err)
 	}
@@ -71,75 +85,14 @@ func main() {
 
 type patcher struct{}
 
-func (p *patcher) Visit(node *ast.Node) {
-	n, ok := (*node).(*ast.IndexNode)
-	if !ok {
-		return
-	}
-	unary, ok := n.Index.(*ast.UnaryNode)
+var contextType = reflect.TypeOf((*context.Context)(nil)).Elem()
+
+func (patcher) Visit(node *ast.Node) {
+	callNode, ok := (*node).(*ast.CallNode)
 	if !ok {
 		return
 	}
-	if unary.Operator == "-" {
-		ast.Patch(&n.Index, &ast.BinaryNode{
-			Operator: "-",
-			Left:     &ast.BuiltinNode{Name: "len", Arguments: []ast.Node{n.Node}},
-			Right:    unary.Node,
-		})
-	}
-
+	callNode.Arguments = append([]ast.Node{&ast.IdentifierNode{Value: "ctx"}}, callNode.Arguments...)
 }
-```
-
-Type information is also available. In the following example, any struct
-implementing the `fmt.Stringer` interface is automatically converted to `string` type.
 
-```go
-func main() {
-	code := `Price == "$100"`
-
-	program, err := expr.Compile(code, expr.Env(Env{}), expr.Patch(&stringerPatcher{}))
-	if err != nil {
-		panic(err)
-	}
-
-	env := Env{100_00}
-
-	output, err := expr.Run(program, env)
-	if err != nil {
-		panic(err)
-	}
-	fmt.Print(output)
-}
-
-type Env struct {
-	Price Price
-}
-
-type Price int
-
-func (p Price) String() string {
-	return fmt.Sprintf("$%v", int(p)/100)
-}
-
-var stringer = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
-
-type stringerPatcher struct{}
-
-func (p *stringerPatcher) Visit(node *ast.Node) {
-	t := (*node).Type()
-	if t == nil {
-		return
-	}
-	if t.Implements(stringer) {
-		ast.Patch(node, &ast.CallNode{
-			Callee: &ast.MemberNode{
-				Node:  *node,
-				Field: "String",
-				Property: &ast.StringNode{Value: "String"},
-			},
-		})
-	}
-
-}
 ```

From 23efe7b36c3e627d35e6afaec0d6f45f1ed69601 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 12:05:07 +0200
Subject: [PATCH 037/506] Fix isTime() func

---
 checker/types.go |  2 +-
 expr_test.go     | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/checker/types.go b/checker/types.go
index e8f53372c..da8acf41d 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -98,7 +98,7 @@ func isTime(t reflect.Type) bool {
 			return true
 		}
 	}
-	return isAny(t)
+	return false
 }
 
 func isDuration(t reflect.Type) bool {
diff --git a/expr_test.go b/expr_test.go
index 0f9f27f98..5e0ec5c8f 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1791,3 +1791,17 @@ func TestEnv_keyword(t *testing.T) {
 	}
 
 }
+
+func TestIssue401(t *testing.T) {
+	program, err := expr.Compile("(a - b + c) / d", expr.AllowUndefinedVariables())
+	require.NoError(t, err, "compile error")
+
+	output, err := expr.Run(program, map[string]interface{}{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+	})
+	require.NoError(t, err, "run error")
+	require.Equal(t, 0.5, output)
+}

From a4557ba5f3c08f8f2bbace02a866296bde20431e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 12:20:37 +0200
Subject: [PATCH 038/506] Move operator tests

---
 expr_test.go                   | 46 ----------------------------
 test/operator/operator_test.go | 56 ++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+), 46 deletions(-)
 create mode 100644 test/operator/operator_test.go

diff --git a/expr_test.go b/expr_test.go
index 5e0ec5c8f..16464383f 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -487,52 +487,6 @@ func ExamplePatch() {
 	// Output : Hello, you, world!
 }
 
-func TestOperator_struct(t *testing.T) {
-	env := mock.Env{
-		Time: time.Date(2017, time.October, 23, 18, 30, 0, 0, time.UTC),
-	}
-
-	code := `Time == "2017-10-23"`
-
-	program, err := expr.Compile(code, expr.Env(mock.Env{}), expr.Operator("==", "TimeEqualString"))
-	require.NoError(t, err)
-
-	output, err := expr.Run(program, env)
-	require.NoError(t, err)
-	require.Equal(t, true, output)
-}
-
-func TestOperator_options_another_order(t *testing.T) {
-	code := `Time == "2017-10-23"`
-	_, err := expr.Compile(code, expr.Operator("==", "TimeEqualString"), expr.Env(mock.Env{}))
-	require.NoError(t, err)
-}
-
-func TestOperator_no_env(t *testing.T) {
-	code := `Time == "2017-10-23"`
-	require.Panics(t, func() {
-		_, _ = expr.Compile(code, expr.Operator("==", "TimeEqualString"))
-	})
-}
-
-func TestOperator_interface(t *testing.T) {
-	env := mock.Env{}
-
-	code := `Foo == "Foo.String" && "Foo.String" == Foo && Time != Foo && Time == Time`
-
-	program, err := expr.Compile(
-		code,
-		expr.Env(mock.Env{}),
-		expr.Operator("==", "StringerStringEqual", "StringStringerEqual", "StringerStringerEqual"),
-		expr.Operator("!=", "NotStringerStringEqual", "NotStringStringerEqual", "NotStringerStringerEqual"),
-	)
-	require.NoError(t, err)
-
-	output, err := expr.Run(program, env)
-	require.NoError(t, err)
-	require.Equal(t, true, output)
-}
-
 func TestExpr_readme_example(t *testing.T) {
 	env := map[string]interface{}{
 		"greet":   "Hello, %v!",
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
new file mode 100644
index 000000000..13ef19128
--- /dev/null
+++ b/test/operator/operator_test.go
@@ -0,0 +1,56 @@
+package operator_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/test/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOperator_struct(t *testing.T) {
+	env := mock.Env{
+		Time: time.Date(2017, time.October, 23, 18, 30, 0, 0, time.UTC),
+	}
+
+	code := `Time == "2017-10-23"`
+
+	program, err := expr.Compile(code, expr.Env(mock.Env{}), expr.Operator("==", "TimeEqualString"))
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, true, output)
+}
+
+func TestOperator_options_another_order(t *testing.T) {
+	code := `Time == "2017-10-23"`
+	_, err := expr.Compile(code, expr.Operator("==", "TimeEqualString"), expr.Env(mock.Env{}))
+	require.NoError(t, err)
+}
+
+func TestOperator_no_env(t *testing.T) {
+	code := `Time == "2017-10-23"`
+	require.Panics(t, func() {
+		_, _ = expr.Compile(code, expr.Operator("==", "TimeEqualString"))
+	})
+}
+
+func TestOperator_interface(t *testing.T) {
+	env := mock.Env{}
+
+	code := `Foo == "Foo.String" && "Foo.String" == Foo && Time != Foo && Time == Time`
+
+	program, err := expr.Compile(
+		code,
+		expr.Env(mock.Env{}),
+		expr.Operator("==", "StringerStringEqual", "StringStringerEqual", "StringerStringerEqual"),
+		expr.Operator("!=", "NotStringerStringEqual", "NotStringStringerEqual", "NotStringerStringerEqual"),
+	)
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, true, output)
+}

From ae70b655e969cb5daf5a02fec4e79fa01e70a528 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 12:46:08 +0200
Subject: [PATCH 039/506] Add AsAny()

---
 checker/checker.go      | 8 +++++++-
 checker/checker_test.go | 1 +
 conf/config.go          | 1 +
 expr.go                 | 7 +++++++
 4 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/checker/checker.go b/checker/checker.go
index 8cd2f2b93..a5864cb33 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -31,9 +31,15 @@ func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
 	}
 
 	if v.config.Expect != reflect.Invalid {
+		if v.config.ExpectAny {
+			if isAny(t) {
+				return t, nil
+			}
+		}
+
 		switch v.config.Expect {
 		case reflect.Int, reflect.Int64, reflect.Float64:
-			if !isNumber(t) && !isAny(t) {
+			if !isNumber(t) {
 				return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, t)
 			}
 		default:
diff --git a/checker/checker_test.go b/checker/checker_test.go
index f62b6d580..70d7b4bc9 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -778,6 +778,7 @@ func TestCheck_cast_to_expected_works_with_interface(t *testing.T) {
 
 		config := conf.New(Env{})
 		expr.AsFloat64()(config)
+		expr.AsAny()(config)
 
 		_, err = checker.Check(tree, config)
 		require.NoError(t, err)
diff --git a/conf/config.go b/conf/config.go
index 1ac0fa7d2..33b91372d 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -16,6 +16,7 @@ type Config struct {
 	DefaultType reflect.Type
 	Operators   OperatorsTable
 	Expect      reflect.Kind
+	ExpectAny   bool
 	Optimize    bool
 	Strict      bool
 	ConstFns    map[string]reflect.Value
diff --git a/expr.go b/expr.go
index 6aa674fb5..1d81226ca 100644
--- a/expr.go
+++ b/expr.go
@@ -52,6 +52,13 @@ func ConstExpr(fn string) Option {
 	}
 }
 
+// AsAny tells the compiler to expect any result.
+func AsAny() Option {
+	return func(c *conf.Config) {
+		c.ExpectAny = true
+	}
+}
+
 // AsKind tells the compiler to expect kind of the result.
 func AsKind(kind reflect.Kind) Option {
 	return func(c *conf.Config) {

From a2a2ff441197b77f06db1766ce4e95466c431988 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 13:06:29 +0200
Subject: [PATCH 040/506] Add string() builtin

---
 builtin/builtin.go      | 16 +++++++++++++---
 builtin/builtin_test.go |  4 ++++
 builtin/func.go         |  4 ++++
 builtin/utils.go        | 19 ++++++++++++++++++-
 checker/checker.go      |  2 +-
 conf/config.go          |  2 +-
 repl/repl.go            | 26 +++++++++-----------------
 vm/program.go           |  2 +-
 vm/vm.go                |  2 +-
 9 files changed, 52 insertions(+), 25 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 32ef76302..8b9019451 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -13,16 +13,21 @@ type Function struct {
 	Validate func(args []reflect.Type) (reflect.Type, error)
 }
 
-var Index map[string]int
+var (
+	Index map[string]int
+	Names []string
+)
 
 func init() {
 	Index = make(map[string]int)
-	for i, fn := range Builtins {
+	Names = make([]string, len(Functions))
+	for i, fn := range Functions {
 		Index[fn.Name] = i
+		Names[i] = fn.Name
 	}
 }
 
-var Builtins = []*Function{
+var Functions = []*Function{
 	{
 		Name:     "len",
 		Builtin1: Len,
@@ -87,4 +92,9 @@ var Builtins = []*Function{
 			return anyType, fmt.Errorf("invalid argument for float (type %s)", args[0])
 		},
 	},
+	{
+		Name:     "string",
+		Builtin1: String,
+		Types:    types(new(func(any interface{}) string)),
+	},
 }
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index dd1907d08..24cfa36c5 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -23,6 +23,9 @@ var tests = []struct {
 	{`float(5)`, 5.0},
 	{`float(5.5)`, 5.5},
 	{`float("5.5")`, 5.5},
+	{`string(5)`, "5"},
+	{`string(5.5)`, "5.5"},
+	{`string("5.5")`, "5.5"},
 }
 
 func TestBuiltin(t *testing.T) {
@@ -48,6 +51,7 @@ var errorTests = []struct {
 	{`int(1, 2)`, `invalid number of arguments for int (expected 1, got 2)`},
 	{`float()`, `invalid number of arguments for float (expected 1, got 0)`},
 	{`float(1, 2)`, `invalid number of arguments for float (expected 1, got 2)`},
+	{`string(1, 2)`, `too many arguments to call string`},
 }
 
 func TestBuiltinErrors(t *testing.T) {
diff --git a/builtin/func.go b/builtin/func.go
index f3f5c1208..d9885ef4c 100644
--- a/builtin/func.go
+++ b/builtin/func.go
@@ -167,3 +167,7 @@ func Float(x interface{}) interface{} {
 		panic(fmt.Sprintf("invalid operation: float(%T)", x))
 	}
 }
+
+func String(arg interface{}) interface{} {
+	return fmt.Sprintf("%v", arg)
+}
diff --git a/builtin/utils.go b/builtin/utils.go
index 64a84b747..be258657f 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -1,6 +1,8 @@
 package builtin
 
-import "reflect"
+import (
+	"reflect"
+)
 
 var (
 	anyType     = reflect.TypeOf(new(interface{})).Elem()
@@ -14,3 +16,18 @@ func kind(t reflect.Type) reflect.Kind {
 	}
 	return t.Kind()
 }
+
+func types(types ...interface{}) []reflect.Type {
+	ts := make([]reflect.Type, len(types))
+	for i, t := range types {
+		t := reflect.TypeOf(t)
+		if t.Kind() == reflect.Ptr {
+			t = t.Elem()
+		}
+		if t.Kind() != reflect.Func {
+			panic("not a function")
+		}
+		ts[i] = t
+	}
+	return ts
+}
diff --git a/checker/checker.go b/checker/checker.go
index a5864cb33..c67850d7d 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -639,7 +639,7 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
-		return v.checkFunction(builtin.Builtins[id], node.Arguments, node)
+		return v.checkFunction(builtin.Functions[id], node.Arguments, node)
 	}
 
 	return v.error(node, "unknown builtin %v", node.Name)
diff --git a/conf/config.go b/conf/config.go
index 33b91372d..ad7f36c1c 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -32,7 +32,7 @@ func CreateNew() *Config {
 		Functions: make(map[string]*builtin.Function),
 		Optimize:  true,
 	}
-	for _, f := range builtin.Builtins {
+	for _, f := range builtin.Functions {
 		c.Functions[f.Name] = f
 	}
 	return c
diff --git a/repl/repl.go b/repl/repl.go
index 9072555a5..eca5f3987 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -5,29 +5,21 @@ import (
 	"strings"
 
 	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/vm"
 	"github.com/chzyer/readline"
 )
 
 func main() {
+	items := []readline.PrefixCompleterInterface{}
+	for _, name := range builtin.Names {
+		items = append(items, readline.PcItem(name))
+	}
+	items = append(items, readline.PcItem("exit"))
+	items = append(items, readline.PcItem("opcodes"))
 	rl, err := readline.NewEx(&readline.Config{
-		Prompt: "> ",
-		AutoComplete: readline.NewPrefixCompleter(
-			readline.PcItem("exit"),
-			readline.PcItem("opcodes"),
-			readline.PcItem("len"),
-			readline.PcItem("abs"),
-			readline.PcItem("int"),
-			readline.PcItem("float"),
-			readline.PcItem("map"),
-			readline.PcItem("filter"),
-			readline.PcItem("all"),
-			readline.PcItem("any"),
-			readline.PcItem("none"),
-			readline.PcItem("one"),
-			readline.PcItem("count"),
-			readline.PcItem("sum"),
-		),
+		Prompt:       "> ",
+		AutoComplete: readline.NewPrefixCompleter(items...),
 	})
 	if err != nil {
 		panic(err)
diff --git a/vm/program.go b/vm/program.go
index be0fd59b7..dd3c0fae5 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -65,7 +65,7 @@ func (program *Program) Disassemble() string {
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, c)
 		}
 		builtin := func(label string) {
-			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, builtin.Builtins[arg].Name)
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, builtin.Functions[arg].Name)
 		}
 
 		switch op {
diff --git a/vm/vm.go b/vm/vm.go
index 70f0ddca5..aa6191859 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -382,7 +382,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			vm.push(out)
 
 		case OpCallBuiltin:
-			vm.push(builtin.Builtins[arg].Builtin1(vm.pop()))
+			vm.push(builtin.Functions[arg].Builtin1(vm.pop()))
 
 		case OpArray:
 			size := vm.pop().(int)

From 0c26c2694154ef2cc0af2dbc951cac912c8ef58d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 13:28:27 +0200
Subject: [PATCH 041/506] Better autocomplete to repl

---
 repl/repl.go | 39 +++++++++++++++++++++++++++++++++------
 1 file changed, 33 insertions(+), 6 deletions(-)

diff --git a/repl/repl.go b/repl/repl.go
index eca5f3987..453c70531 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -11,15 +11,19 @@ import (
 )
 
 func main() {
-	items := []readline.PrefixCompleterInterface{}
-	for _, name := range builtin.Names {
-		items = append(items, readline.PcItem(name))
+	extra := []string{
+		"exit",
+		"opcodes",
+		"map",
+		"filter",
+		"all",
+		"any",
+		"none",
+		"one",
 	}
-	items = append(items, readline.PcItem("exit"))
-	items = append(items, readline.PcItem("opcodes"))
 	rl, err := readline.NewEx(&readline.Config{
 		Prompt:       "> ",
-		AutoComplete: readline.NewPrefixCompleter(items...),
+		AutoComplete: completer{append(builtin.Names, extra...)},
 	})
 	if err != nil {
 		panic(err)
@@ -58,3 +62,26 @@ func main() {
 		fmt.Println(output)
 	}
 }
+
+type completer struct {
+	words []string
+}
+
+func (c completer) Do(line []rune, pos int) ([][]rune, int) {
+	var lastWord string
+	for i := pos - 1; i >= 0; i-- {
+		if line[i] == ' ' {
+			break
+		}
+		lastWord = string(line[i]) + lastWord
+	}
+
+	var words [][]rune
+	for _, word := range c.words {
+		if strings.HasPrefix(word, lastWord) {
+			words = append(words, []rune(strings.TrimPrefix(word, lastWord)))
+		}
+	}
+
+	return words, len(lastWord)
+}

From 18e429023d33ff7c1110e1e0d570586a6cd09ffc Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 15:37:06 +0200
Subject: [PATCH 042/506] Add builtin functions

---
 builtin/builtin.go          | 323 ++++++++++++++++++++++++++++++++++++
 builtin/builtin_test.go     |  63 ++++++-
 builtin/func.go             |  22 +++
 compiler/compiler.go        |  49 +++---
 optimizer/optimizer_test.go |   6 +-
 test/time/time_test.go      |  43 +++++
 vm/opcodes.go               |   2 +-
 vm/program.go               |   4 +-
 vm/runtime/runtime.go       |   2 +-
 vm/vm.go                    |   2 +-
 10 files changed, 488 insertions(+), 28 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 8b9019451..c0e3582ec 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -1,8 +1,14 @@
 package builtin
 
 import (
+	"encoding/base64"
+	"encoding/json"
 	"fmt"
 	"reflect"
+	"strings"
+	"time"
+
+	"github.com/antonmedv/expr/vm/runtime"
 )
 
 type Function struct {
@@ -97,4 +103,321 @@ var Functions = []*Function{
 		Builtin1: String,
 		Types:    types(new(func(any interface{}) string)),
 	},
+	{
+		Name: "trim",
+		Func: func(args ...interface{}) (interface{}, error) {
+			if len(args) == 1 {
+				return strings.TrimSpace(args[0].(string)), nil
+			} else if len(args) == 2 {
+				return strings.Trim(args[0].(string), args[1].(string)), nil
+			} else {
+				return nil, fmt.Errorf("invalid number of arguments for trim (expected 1 or 2, got %d)", len(args))
+			}
+		},
+		Types: types(
+			strings.TrimSpace,
+			strings.Trim,
+		),
+	},
+	{
+		Name: "trimPrefix",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.TrimPrefix(args[0].(string), args[1].(string)), nil
+		},
+		Types: types(strings.TrimPrefix),
+	},
+	{
+		Name: "trimSuffix",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.TrimSuffix(args[0].(string), args[1].(string)), nil
+		},
+		Types: types(strings.TrimSuffix),
+	},
+	{
+		Name: "upper",
+		Builtin1: func(arg interface{}) interface{} {
+			return strings.ToUpper(arg.(string))
+		},
+		Types: types(strings.ToUpper),
+	},
+	{
+		Name: "lower",
+		Builtin1: func(arg interface{}) interface{} {
+			return strings.ToLower(arg.(string))
+		},
+		Types: types(strings.ToLower),
+	},
+	{
+		Name: "split",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.Split(args[0].(string), args[1].(string)), nil
+		},
+		Types: types(strings.Split),
+	},
+	{
+		Name: "splitN",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.SplitN(args[0].(string), args[1].(string), runtime.ToInt(args[2])), nil
+		},
+		Types: types(strings.SplitN),
+	},
+	{
+		Name: "splitAfter",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.SplitAfter(args[0].(string), args[1].(string)), nil
+		},
+		Types: types(strings.SplitAfter),
+	},
+	{
+		Name: "splitAfterN",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.SplitAfterN(args[0].(string), args[1].(string), runtime.ToInt(args[2])), nil
+		},
+		Types: types(strings.SplitAfterN),
+	},
+	{
+		Name: "replace",
+		Func: func(args ...interface{}) (interface{}, error) {
+			if len(args) == 4 {
+				return strings.Replace(args[0].(string), args[1].(string), args[2].(string), runtime.ToInt(args[3])), nil
+			} else if len(args) == 3 {
+				return strings.ReplaceAll(args[0].(string), args[1].(string), args[2].(string)), nil
+			} else {
+				return nil, fmt.Errorf("invalid number of arguments for replace (expected 3 or 4, got %d)", len(args))
+			}
+		},
+		Types: types(
+			strings.Replace,
+			strings.ReplaceAll,
+		),
+	},
+	{
+		Name: "repeat",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.Repeat(args[0].(string), runtime.ToInt(args[1])), nil
+		},
+		Types: types(strings.Repeat),
+	},
+	{
+		Name: "join",
+		Func: func(args ...interface{}) (interface{}, error) {
+			glue := ""
+			if len(args) == 2 {
+				glue = args[1].(string)
+			}
+			switch args[0].(type) {
+			case []string:
+				return strings.Join(args[0].([]string), glue), nil
+			case []interface{}:
+				var s []string
+				for _, arg := range args[0].([]interface{}) {
+					s = append(s, arg.(string))
+				}
+				return strings.Join(s, glue), nil
+			}
+			return nil, fmt.Errorf("invalid argument for join (type %s)", reflect.TypeOf(args[0]))
+		},
+		Types: types(
+			strings.Join,
+			new(func([]interface{}, string) string),
+			new(func([]string) string),
+			new(func([]interface{}) string),
+		),
+	},
+	{
+		Name: "indexOf",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.Index(args[0].(string), args[1].(string)), nil
+		},
+		Types: types(strings.Index),
+	},
+	{
+		Name: "lastIndexOf",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.LastIndex(args[0].(string), args[1].(string)), nil
+		},
+		Types: types(strings.LastIndex),
+	},
+	{
+		Name: "hasPrefix",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.HasPrefix(args[0].(string), args[1].(string)), nil
+		},
+		Types: types(strings.HasPrefix),
+	},
+	{
+		Name: "hasSuffix",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return strings.HasSuffix(args[0].(string), args[1].(string)), nil
+		},
+		Types: types(strings.HasSuffix),
+	},
+	{
+		Name: "max",
+		Func: Max,
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) == 0 {
+				return anyType, fmt.Errorf("not enough arguments to call max")
+			}
+			for _, arg := range args {
+				switch kind(arg) {
+				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
+				default:
+					return anyType, fmt.Errorf("invalid argument for max (type %s)", arg)
+				}
+			}
+			return args[0], nil
+		},
+	},
+	{
+		Name: "min",
+		Func: Min,
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) == 0 {
+				return anyType, fmt.Errorf("not enough arguments to call min")
+			}
+			for _, arg := range args {
+				switch kind(arg) {
+				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
+				default:
+					return anyType, fmt.Errorf("invalid argument for min (type %s)", arg)
+				}
+			}
+			return args[0], nil
+		},
+	},
+	{
+		Name: "toJSON",
+		Func: func(args ...interface{}) (interface{}, error) {
+			b, err := json.MarshalIndent(args[0], "", "  ")
+			if err != nil {
+				return nil, err
+			}
+			return string(b), nil
+		},
+		Types: types(new(func(interface{}) string)),
+	},
+	{
+		Name: "fromJSON",
+		Func: func(args ...interface{}) (interface{}, error) {
+			var v interface{}
+			err := json.Unmarshal([]byte(args[0].(string)), &v)
+			if err != nil {
+				return nil, err
+			}
+			return v, nil
+		},
+		Types: types(new(func(string) interface{})),
+	},
+	{
+		Name: "toBase64",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return base64.StdEncoding.EncodeToString([]byte(args[0].(string))), nil
+		},
+		Types: types(new(func(string) string)),
+	},
+	{
+		Name: "fromBase64",
+		Func: func(args ...interface{}) (interface{}, error) {
+			b, err := base64.StdEncoding.DecodeString(args[0].(string))
+			if err != nil {
+				return nil, err
+			}
+			return string(b), nil
+		},
+		Types: types(new(func(string) string)),
+	},
+	{
+		Name: "now",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return time.Now(), nil
+		},
+		Types: types(new(func() time.Time)),
+	},
+	{
+		Name: "duration",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return time.ParseDuration(args[0].(string))
+		},
+		Types: types(time.ParseDuration),
+	},
+	{
+		Name: "date",
+		Func: func(args ...interface{}) (interface{}, error) {
+			date := args[0].(string)
+			if len(args) == 2 {
+				layout := args[1].(string)
+				return time.Parse(layout, date)
+			}
+			if len(args) == 3 {
+				layout := args[1].(string)
+				timeZone := args[2].(string)
+				tz, err := time.LoadLocation(timeZone)
+				if err != nil {
+					return nil, err
+				}
+				t, err := time.ParseInLocation(layout, date, tz)
+				if err != nil {
+					return nil, err
+				}
+				return t, nil
+			}
+
+			layouts := []string{
+				time.DateOnly,
+				time.TimeOnly,
+				time.DateTime,
+				time.RFC3339,
+				time.RFC822,
+				time.RFC850,
+				time.RFC1123,
+			}
+			for _, layout := range layouts {
+				t, err := time.Parse(layout, date)
+				if err == nil {
+					return t, nil
+				}
+			}
+			return nil, fmt.Errorf("invalid date %s", date)
+		},
+		Types: types(
+			new(func(string) time.Time),
+			new(func(string, string) time.Time),
+			new(func(string, string, string) time.Time),
+		),
+	},
+	{
+		Name: "first",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return runtime.Fetch(args[0], 0), nil
+		},
+		Types: types(new(func([]interface{}) interface{})),
+	},
+	{
+		Name: "last",
+		Func: func(args ...interface{}) (interface{}, error) {
+			return runtime.Fetch(args[0], -1), nil
+		},
+	},
+	{
+		Name: "get",
+		Func: func(args ...interface{}) (out interface{}, err error) {
+			defer func() {
+				if r := recover(); r != nil {
+					return
+				}
+			}()
+			return runtime.Fetch(args[0], args[1]), nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 2 {
+				return anyType, fmt.Errorf("invalid number of arguments for get (expected 2, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Map, reflect.Struct, reflect.Slice, reflect.Array, reflect.Interface:
+				return anyType, nil
+			}
+			return anyType, fmt.Errorf("cannot get %s from %s", args[1], args[0])
+		},
+	},
 }
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 24cfa36c5..9b36dbe40 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -2,6 +2,7 @@ package builtin_test
 
 import (
 	"testing"
+	"time"
 
 	"github.com/antonmedv/expr"
 	"github.com/stretchr/testify/assert"
@@ -26,12 +27,63 @@ var tests = []struct {
 	{`string(5)`, "5"},
 	{`string(5.5)`, "5.5"},
 	{`string("5.5")`, "5.5"},
+	{`trim("  foo  ")`, "foo"},
+	{`trim("__foo___", "_")`, "foo"},
+	{`trimPrefix("prefix_foo", "prefix_")`, "foo"},
+	{`trimSuffix("foo_suffix", "_suffix")`, "foo"},
+	{`upper("foo")`, "FOO"},
+	{`lower("FOO")`, "foo"},
+	{`split("foo,bar,baz", ",")`, []string{"foo", "bar", "baz"}},
+	{`splitN("foo,bar,baz", ",", 2)`, []string{"foo", "bar,baz"}},
+	{`splitAfter("foo,bar,baz", ",")`, []string{"foo,", "bar,", "baz"}},
+	{`splitAfterN("foo,bar,baz", ",", 2)`, []string{"foo,", "bar,baz"}},
+	{`replace("foo,bar,baz", ",", ";")`, "foo;bar;baz"},
+	{`replace("foo,bar,baz,goo", ",", ";", 2)`, "foo;bar;baz,goo"},
+	{`repeat("foo", 3)`, "foofoofoo"},
+	{`join(ArrayOfString, ",")`, "foo,bar,baz"},
+	{`join(ArrayOfString)`, "foobarbaz"},
+	{`join(["foo", "bar", "baz"], ",")`, "foo,bar,baz"},
+	{`join(["foo", "bar", "baz"])`, "foobarbaz"},
+	{`indexOf("foo,bar,baz", ",")`, 3},
+	{`lastIndexOf("foo,bar,baz", ",")`, 7},
+	{`hasPrefix("foo,bar,baz", "foo")`, true},
+	{`hasSuffix("foo,bar,baz", "baz")`, true},
+	{`max(1, 2, 3)`, 3},
+	{`max(1.5, 2.5, 3.5)`, 3.5},
+	{`min(1, 2, 3)`, 1},
+	{`min(1.5, 2.5, 3.5)`, 1.5},
+	{`toJSON({foo: 1, bar: 2})`, "{\n  \"bar\": 2,\n  \"foo\": 1\n}"},
+	{`fromJSON("[1, 2, 3]")`, []interface{}{1.0, 2.0, 3.0}},
+	{`toBase64("hello")`, "aGVsbG8="},
+	{`fromBase64("aGVsbG8=")`, "hello"},
+	{`now().Format("2006-01-02T15:04:05Z")`, time.Now().Format("2006-01-02T15:04:05Z")},
+	{`duration("1h")`, time.Hour},
+	{`date("2006-01-02T15:04:05Z")`, time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
+	{`date("2006.01.02", "2006.01.02")`, time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC)},
+	{`first(ArrayOfString)`, "foo"},
+	{`first(ArrayOfInt)`, 1},
+	{`first(ArrayOfAny)`, 1},
+	{`last(ArrayOfString)`, "baz"},
+	{`last(ArrayOfInt)`, 3},
+	{`last(ArrayOfAny)`, true},
+	{`get(ArrayOfString, 1)`, "bar"},
+	{`get(ArrayOfString, 99)`, nil},
+	{`get(ArrayOfInt, 1)`, 2},
+	{`get(ArrayOfInt, -1)`, 3},
+	{`get(ArrayOfAny, 1)`, "2"},
+	{`get({foo: 1, bar: 2}, "foo")`, 1},
+	{`get({foo: 1, bar: 2}, "unknown")`, nil},
 }
 
 func TestBuiltin(t *testing.T) {
+	env := map[string]interface{}{
+		"ArrayOfString": []string{"foo", "bar", "baz"},
+		"ArrayOfInt":    []int{1, 2, 3},
+		"ArrayOfAny":    []interface{}{1, "2", true},
+	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
-			out, err := expr.Eval(test.input, nil)
+			out, err := expr.Eval(test.input, env)
 			assert.NoError(t, err)
 			assert.Equal(t, test.want, out)
 		})
@@ -52,6 +104,15 @@ var errorTests = []struct {
 	{`float()`, `invalid number of arguments for float (expected 1, got 0)`},
 	{`float(1, 2)`, `invalid number of arguments for float (expected 1, got 2)`},
 	{`string(1, 2)`, `too many arguments to call string`},
+	{`trim()`, `not enough arguments to call trim`},
+	{`max()`, `not enough arguments to call max`},
+	{`max(1, "2")`, `invalid argument for max (type string)`},
+	{`min()`, `not enough arguments to call min`},
+	{`min(1, "2")`, `invalid argument for min (type string)`},
+	{`duration("error")`, `invalid duration`},
+	{`date("error")`, `invalid date`},
+	{`get()`, `invalid number of arguments for get (expected 2, got 0)`},
+	{`get(1, 2)`, `cannot get int from int`},
 }
 
 func TestBuiltinErrors(t *testing.T) {
diff --git a/builtin/func.go b/builtin/func.go
index d9885ef4c..54fd383a0 100644
--- a/builtin/func.go
+++ b/builtin/func.go
@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"reflect"
 	"strconv"
+
+	"github.com/antonmedv/expr/vm/runtime"
 )
 
 func Len(x interface{}) interface{} {
@@ -171,3 +173,23 @@ func Float(x interface{}) interface{} {
 func String(arg interface{}) interface{} {
 	return fmt.Sprintf("%v", arg)
 }
+
+func Max(args ...interface{}) (interface{}, error) {
+	var max interface{}
+	for _, arg := range args {
+		if max == nil || runtime.Less(max, arg) {
+			max = arg
+		}
+	}
+	return max, nil
+}
+
+func Min(args ...interface{}) (interface{}, error) {
+	var min interface{}
+	for _, arg := range args {
+		if min == nil || runtime.More(min, arg) {
+			min = arg
+		}
+	}
+	return min, nil
+}
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 119ec48f6..0679edcc7 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -127,16 +127,34 @@ func (c *compiler) addConstant(constant interface{}) int {
 	return p
 }
 
-func (c *compiler) addFunction(node *ast.CallNode) int {
-	if node.Func == nil {
+// emitFunction adds builtin.Function.Func to the program.Functions and emits call opcode.
+func (c *compiler) emitFunction(fn *builtin.Function, argsLen int) {
+	switch argsLen {
+	case 0:
+		c.emit(OpCall0, c.addFunction(fn))
+	case 1:
+		c.emit(OpCall1, c.addFunction(fn))
+	case 2:
+		c.emit(OpCall2, c.addFunction(fn))
+	case 3:
+		c.emit(OpCall3, c.addFunction(fn))
+	default:
+		c.emit(OpLoadFunc, c.addFunction(fn))
+		c.emit(OpCallN, argsLen)
+	}
+}
+
+// addFunction adds builtin.Function.Func to the program.Functions and returns its index.
+func (c *compiler) addFunction(fn *builtin.Function) int {
+	if fn == nil {
 		panic("function is nil")
 	}
-	if p, ok := c.functionsIndex[node.Func.Name]; ok {
+	if p, ok := c.functionsIndex[fn.Name]; ok {
 		return p
 	}
 	p := len(c.functions)
-	c.functions = append(c.functions, node.Func.Func)
-	c.functionsIndex[node.Func.Name] = p
+	c.functions = append(c.functions, fn.Func)
+	c.functionsIndex[fn.Name] = p
 	return p
 }
 
@@ -564,19 +582,7 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 		c.compile(arg)
 	}
 	if node.Func != nil {
-		switch len(node.Arguments) {
-		case 0:
-			c.emit(OpCall0, c.addFunction(node))
-		case 1:
-			c.emit(OpCall1, c.addFunction(node))
-		case 2:
-			c.emit(OpCall2, c.addFunction(node))
-		case 3:
-			c.emit(OpCall3, c.addFunction(node))
-		default:
-			c.emit(OpLoadFunc, c.addFunction(node))
-			c.emit(OpCallN, len(node.Arguments))
-		}
+		c.emitFunction(node.Func, len(node.Arguments))
 		return
 	}
 	c.compile(node.Callee)
@@ -691,10 +697,15 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
+		f := builtin.Functions[id]
 		for _, arg := range node.Arguments {
 			c.compile(arg)
 		}
-		c.emit(OpCallBuiltin, id)
+		if f.Builtin1 != nil {
+			c.emit(OpCallBuiltin1, id)
+		} else if f.Func != nil {
+			c.emitFunction(f, len(node.Arguments))
+		}
 		return
 	}
 
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index ba31af56a..0fc9f55bd 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -119,15 +119,15 @@ func TestOptimize_const_range(t *testing.T) {
 }
 
 func TestOptimize_const_expr(t *testing.T) {
-	tree, err := parser.Parse(`upper("hello")`)
+	tree, err := parser.Parse(`toUpper("hello")`)
 	require.NoError(t, err)
 
 	env := map[string]interface{}{
-		"upper": strings.ToUpper,
+		"toUpper": strings.ToUpper,
 	}
 
 	config := conf.New(env)
-	config.ConstExpr("upper")
+	config.ConstExpr("toUpper")
 
 	err = optimizer.Optimize(&tree.Node, config)
 	require.NoError(t, err)
diff --git a/test/time/time_test.go b/test/time/time_test.go
index f6318426f..200c821ee 100644
--- a/test/time/time_test.go
+++ b/test/time/time_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/compiler"
 	"github.com/antonmedv/expr/conf"
@@ -100,3 +101,45 @@ func TestTime(t *testing.T) {
 		})
 	}
 }
+
+func TestTime_duration(t *testing.T) {
+	env := map[string]interface{}{
+		"date": time.Date(2000, time.Month(1), 1, 0, 0, 0, 0, time.UTC),
+	}
+	program, err := expr.Compile(`now() - duration("1h") < now() && date + duration("24h") < now()`, expr.Env(env))
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, true, output)
+}
+
+func TestTime_date(t *testing.T) {
+	var tests = []struct {
+		input string
+		want  time.Time
+	}{
+		{
+			`'2017-10-23' | date()`,
+			time.Date(2017, 10, 23, 0, 0, 0, 0, time.UTC),
+		},
+		{
+			`'24.11.1987 20:30' | date("02.01.2006 15:04", "Europe/Zurich")`,
+			time.Date(1987, 11, 24, 20, 30, 0, 0, time.FixedZone("Europe/Zurich", 3600)),
+		},
+		{
+			`'24.11.1987 20:30 MSK' | date("02.01.2006 15:04 MST", "Europe/Zurich")`,
+			time.Date(1987, 11, 24, 20, 30, 0, 0, time.FixedZone("MSK", 0)),
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			program, err := expr.Compile(test.input)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			require.Truef(t, test.want.Equal(output.(time.Time)), "want %v, got %v", test.want, output)
+		})
+	}
+}
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 985af1df7..1720fd4c2 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -57,7 +57,7 @@ const (
 	OpCallN
 	OpCallFast
 	OpCallTyped
-	OpCallBuiltin
+	OpCallBuiltin1
 	OpArray
 	OpMap
 	OpLen
diff --git a/vm/program.go b/vm/program.go
index dd3c0fae5..d6018139d 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -232,8 +232,8 @@ func (program *Program) Disassemble() string {
 			signature := reflect.TypeOf(FuncTypes[arg]).Elem().String()
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, "OpCallTyped", arg, signature)
 
-		case OpCallBuiltin:
-			builtin("OpCallBuiltin")
+		case OpCallBuiltin1:
+			builtin("OpCallBuiltin1")
 
 		case OpArray:
 			code("OpArray")
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 92abf16c6..97f61843f 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -264,7 +264,7 @@ func In(needle interface{}, array interface{}) bool {
 	panic(fmt.Sprintf(`operator "in"" not defined on %T`, array))
 }
 
-func Len(a interface{}) interface{} {
+func Len(a interface{}) int {
 	v := reflect.ValueOf(a)
 	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
diff --git a/vm/vm.go b/vm/vm.go
index aa6191859..0437a4c40 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -381,7 +381,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			out := vm.call(fn, arg)
 			vm.push(out)
 
-		case OpCallBuiltin:
+		case OpCallBuiltin1:
 			vm.push(builtin.Functions[arg].Builtin1(vm.pop()))
 
 		case OpArray:

From 24e1757b1d91d15882ef7965c195f3b0903b61d8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 15:54:34 +0200
Subject: [PATCH 043/506] Fix time constants

---
 builtin/builtin.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index c0e3582ec..19195f183 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -364,9 +364,9 @@ var Functions = []*Function{
 			}
 
 			layouts := []string{
-				time.DateOnly,
-				time.TimeOnly,
-				time.DateTime,
+				"2006-01-02",
+				"15:04:05",
+				"2006-01-02 15:04:05",
 				time.RFC3339,
 				time.RFC822,
 				time.RFC850,

From 592dd5f9275276b888afb855efa1f58ea0c87301 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 15:41:10 +0200
Subject: [PATCH 044/506] Improve OpCallTyped performance

---
 vm/vm.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/vm/vm.go b/vm/vm.go
index 0437a4c40..51e8bf1c0 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -377,9 +377,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			vm.push(fn(in...))
 
 		case OpCallTyped:
-			fn := vm.pop()
-			out := vm.call(fn, arg)
-			vm.push(out)
+			vm.push(vm.call(vm.pop(), arg))
 
 		case OpCallBuiltin1:
 			vm.push(builtin.Functions[arg].Builtin1(vm.pop()))

From 9f2ffce00e62a89de30a361aeb98e714138b986d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 22:13:55 +0200
Subject: [PATCH 045/506] Update docs

---
 docs/Language-Definition.md | 117 ++++++++++++++++++++++++++++++++++++
 1 file changed, 117 insertions(+)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 45514cc54..d6da203ca 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -238,6 +238,123 @@ int("123") == 123
 
 Returns the float value of a number or a string.
 
+### string()
+
+todo
+
+### trim()
+
+todo
+
+### trimPrefix()
+
+todo
+
+### trimSuffix()
+
+todo
+
+### upper()
+
+todo
+
+### lower()
+
+todo
+
+### split()
+
+todo
+
+### splitN()
+
+todo
+
+### splitAfter()
+
+todo
+
+### splitAfterN()
+
+todo
+
+### replace()
+
+todo
+
+### repeat()
+
+todo
+
+### join()
+
+todo
+
+### indexOf()
+
+todo
+
+### lastIndexOf()
+
+todo
+
+### hasPrefix()
+
+todo
+
+### hasSuffix()
+
+todo
+
+### max()
+
+todo
+
+### min()
+
+todo
+
+### toJSON()
+
+todo
+
+### fromJSON()
+
+todo
+
+### toBase64()
+
+todo
+
+### fromBase64()
+
+todo
+
+### now()
+
+todo
+
+### duration()
+
+todo
+
+### date()
+
+todo
+
+### first()
+
+todo
+
+### last()
+
+todo
+
+### get()
+
+todo
+
+
 ## Predicate
 
 The predicate is an expression that accepts a single argument. To access

From 5002d98ec24b365dc289a18889e95e156e9bc77b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 22:44:00 +0200
Subject: [PATCH 046/506] Fix get/first/last

---
 builtin/builtin.go      |  41 +++++++++++-
 builtin/builtin_test.go | 144 +++++++++++++++++++++-------------------
 2 files changed, 114 insertions(+), 71 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 19195f183..cb9399fd5 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -389,15 +389,48 @@ var Functions = []*Function{
 	{
 		Name: "first",
 		Func: func(args ...interface{}) (interface{}, error) {
+			defer func() {
+				if r := recover(); r != nil {
+					return
+				}
+			}()
 			return runtime.Fetch(args[0], 0), nil
 		},
-		Types: types(new(func([]interface{}) interface{})),
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments for first (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface:
+				return anyType, nil
+			case reflect.Slice, reflect.Array:
+				return args[0].Elem(), nil
+			}
+			return anyType, fmt.Errorf("cannot get first element from %s", args[0])
+		},
 	},
 	{
 		Name: "last",
 		Func: func(args ...interface{}) (interface{}, error) {
+			defer func() {
+				if r := recover(); r != nil {
+					return
+				}
+			}()
 			return runtime.Fetch(args[0], -1), nil
 		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments for last (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface:
+				return anyType, nil
+			case reflect.Slice, reflect.Array:
+				return args[0].Elem(), nil
+			}
+			return anyType, fmt.Errorf("cannot get last element from %s", args[0])
+		},
 	},
 	{
 		Name: "get",
@@ -414,8 +447,12 @@ var Functions = []*Function{
 				return anyType, fmt.Errorf("invalid number of arguments for get (expected 2, got %d)", len(args))
 			}
 			switch kind(args[0]) {
-			case reflect.Map, reflect.Struct, reflect.Slice, reflect.Array, reflect.Interface:
+			case reflect.Interface:
 				return anyType, nil
+			case reflect.Slice, reflect.Array:
+				return args[0].Elem(), nil
+			case reflect.Map:
+				return args[0].Elem(), nil
 			}
 			return anyType, fmt.Errorf("cannot get %s from %s", args[1], args[0])
 		},
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 9b36dbe40..a18c903ef 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -6,76 +6,79 @@ import (
 
 	"github.com/antonmedv/expr"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-var tests = []struct {
-	input string
-	want  interface{}
-}{
-	{`len(1..10)`, 10},
-	{`len({foo: 1, bar: 2})`, 2},
-	{`len("hello")`, 5},
-	{`abs(-5)`, 5},
-	{`abs(.5)`, .5},
-	{`abs(-.5)`, .5},
-	{`int(5.5)`, 5},
-	{`int(5)`, 5},
-	{`int("5")`, 5},
-	{`float(5)`, 5.0},
-	{`float(5.5)`, 5.5},
-	{`float("5.5")`, 5.5},
-	{`string(5)`, "5"},
-	{`string(5.5)`, "5.5"},
-	{`string("5.5")`, "5.5"},
-	{`trim("  foo  ")`, "foo"},
-	{`trim("__foo___", "_")`, "foo"},
-	{`trimPrefix("prefix_foo", "prefix_")`, "foo"},
-	{`trimSuffix("foo_suffix", "_suffix")`, "foo"},
-	{`upper("foo")`, "FOO"},
-	{`lower("FOO")`, "foo"},
-	{`split("foo,bar,baz", ",")`, []string{"foo", "bar", "baz"}},
-	{`splitN("foo,bar,baz", ",", 2)`, []string{"foo", "bar,baz"}},
-	{`splitAfter("foo,bar,baz", ",")`, []string{"foo,", "bar,", "baz"}},
-	{`splitAfterN("foo,bar,baz", ",", 2)`, []string{"foo,", "bar,baz"}},
-	{`replace("foo,bar,baz", ",", ";")`, "foo;bar;baz"},
-	{`replace("foo,bar,baz,goo", ",", ";", 2)`, "foo;bar;baz,goo"},
-	{`repeat("foo", 3)`, "foofoofoo"},
-	{`join(ArrayOfString, ",")`, "foo,bar,baz"},
-	{`join(ArrayOfString)`, "foobarbaz"},
-	{`join(["foo", "bar", "baz"], ",")`, "foo,bar,baz"},
-	{`join(["foo", "bar", "baz"])`, "foobarbaz"},
-	{`indexOf("foo,bar,baz", ",")`, 3},
-	{`lastIndexOf("foo,bar,baz", ",")`, 7},
-	{`hasPrefix("foo,bar,baz", "foo")`, true},
-	{`hasSuffix("foo,bar,baz", "baz")`, true},
-	{`max(1, 2, 3)`, 3},
-	{`max(1.5, 2.5, 3.5)`, 3.5},
-	{`min(1, 2, 3)`, 1},
-	{`min(1.5, 2.5, 3.5)`, 1.5},
-	{`toJSON({foo: 1, bar: 2})`, "{\n  \"bar\": 2,\n  \"foo\": 1\n}"},
-	{`fromJSON("[1, 2, 3]")`, []interface{}{1.0, 2.0, 3.0}},
-	{`toBase64("hello")`, "aGVsbG8="},
-	{`fromBase64("aGVsbG8=")`, "hello"},
-	{`now().Format("2006-01-02T15:04:05Z")`, time.Now().Format("2006-01-02T15:04:05Z")},
-	{`duration("1h")`, time.Hour},
-	{`date("2006-01-02T15:04:05Z")`, time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
-	{`date("2006.01.02", "2006.01.02")`, time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC)},
-	{`first(ArrayOfString)`, "foo"},
-	{`first(ArrayOfInt)`, 1},
-	{`first(ArrayOfAny)`, 1},
-	{`last(ArrayOfString)`, "baz"},
-	{`last(ArrayOfInt)`, 3},
-	{`last(ArrayOfAny)`, true},
-	{`get(ArrayOfString, 1)`, "bar"},
-	{`get(ArrayOfString, 99)`, nil},
-	{`get(ArrayOfInt, 1)`, 2},
-	{`get(ArrayOfInt, -1)`, 3},
-	{`get(ArrayOfAny, 1)`, "2"},
-	{`get({foo: 1, bar: 2}, "foo")`, 1},
-	{`get({foo: 1, bar: 2}, "unknown")`, nil},
-}
-
 func TestBuiltin(t *testing.T) {
+	var tests = []struct {
+		input string
+		want  interface{}
+	}{
+		{`len(1..10)`, 10},
+		{`len({foo: 1, bar: 2})`, 2},
+		{`len("hello")`, 5},
+		{`abs(-5)`, 5},
+		{`abs(.5)`, .5},
+		{`abs(-.5)`, .5},
+		{`int(5.5)`, 5},
+		{`int(5)`, 5},
+		{`int("5")`, 5},
+		{`float(5)`, 5.0},
+		{`float(5.5)`, 5.5},
+		{`float("5.5")`, 5.5},
+		{`string(5)`, "5"},
+		{`string(5.5)`, "5.5"},
+		{`string("5.5")`, "5.5"},
+		{`trim("  foo  ")`, "foo"},
+		{`trim("__foo___", "_")`, "foo"},
+		{`trimPrefix("prefix_foo", "prefix_")`, "foo"},
+		{`trimSuffix("foo_suffix", "_suffix")`, "foo"},
+		{`upper("foo")`, "FOO"},
+		{`lower("FOO")`, "foo"},
+		{`split("foo,bar,baz", ",")`, []string{"foo", "bar", "baz"}},
+		{`splitN("foo,bar,baz", ",", 2)`, []string{"foo", "bar,baz"}},
+		{`splitAfter("foo,bar,baz", ",")`, []string{"foo,", "bar,", "baz"}},
+		{`splitAfterN("foo,bar,baz", ",", 2)`, []string{"foo,", "bar,baz"}},
+		{`replace("foo,bar,baz", ",", ";")`, "foo;bar;baz"},
+		{`replace("foo,bar,baz,goo", ",", ";", 2)`, "foo;bar;baz,goo"},
+		{`repeat("foo", 3)`, "foofoofoo"},
+		{`join(ArrayOfString, ",")`, "foo,bar,baz"},
+		{`join(ArrayOfString)`, "foobarbaz"},
+		{`join(["foo", "bar", "baz"], ",")`, "foo,bar,baz"},
+		{`join(["foo", "bar", "baz"])`, "foobarbaz"},
+		{`indexOf("foo,bar,baz", ",")`, 3},
+		{`lastIndexOf("foo,bar,baz", ",")`, 7},
+		{`hasPrefix("foo,bar,baz", "foo")`, true},
+		{`hasSuffix("foo,bar,baz", "baz")`, true},
+		{`max(1, 2, 3)`, 3},
+		{`max(1.5, 2.5, 3.5)`, 3.5},
+		{`min(1, 2, 3)`, 1},
+		{`min(1.5, 2.5, 3.5)`, 1.5},
+		{`toJSON({foo: 1, bar: 2})`, "{\n  \"bar\": 2,\n  \"foo\": 1\n}"},
+		{`fromJSON("[1, 2, 3]")`, []interface{}{1.0, 2.0, 3.0}},
+		{`toBase64("hello")`, "aGVsbG8="},
+		{`fromBase64("aGVsbG8=")`, "hello"},
+		{`now().Format("2006-01-02T15:04:05Z")`, time.Now().Format("2006-01-02T15:04:05Z")},
+		{`duration("1h")`, time.Hour},
+		{`date("2006-01-02T15:04:05Z")`, time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
+		{`date("2006.01.02", "2006.01.02")`, time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC)},
+		{`first(ArrayOfString)`, "foo"},
+		{`first(ArrayOfInt)`, 1},
+		{`first(ArrayOfAny)`, 1},
+		{`first([])`, nil},
+		{`last(ArrayOfString)`, "baz"},
+		{`last(ArrayOfInt)`, 3},
+		{`last(ArrayOfAny)`, true},
+		{`last([])`, nil},
+		{`get(ArrayOfString, 1)`, "bar"},
+		{`get(ArrayOfString, 99)`, nil},
+		{`get(ArrayOfInt, 1)`, 2},
+		{`get(ArrayOfInt, -1)`, 3},
+		{`get(ArrayOfAny, 1)`, "2"},
+		{`get({foo: 1, bar: 2}, "foo")`, 1},
+		{`get({foo: 1, bar: 2}, "unknown")`, nil},
+	}
+
 	env := map[string]interface{}{
 		"ArrayOfString": []string{"foo", "bar", "baz"},
 		"ArrayOfInt":    []int{1, 2, 3},
@@ -83,8 +86,11 @@ func TestBuiltin(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
-			out, err := expr.Eval(test.input, env)
-			assert.NoError(t, err)
+			program, err := expr.Compile(test.input, expr.Env(env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, env)
+			require.NoError(t, err)
 			assert.Equal(t, test.want, out)
 		})
 	}

From be61690d48c2d1738c2b4b7c46700ecf3ed87894 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 14 Aug 2023 22:44:08 +0200
Subject: [PATCH 047/506] Update documentation

---
 docs/Language-Definition.md | 260 +++++++++++++++++++++++++++---------
 1 file changed, 199 insertions(+), 61 deletions(-)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index d6da203ca..7a7ba6f7d 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -53,7 +53,6 @@
     </tr>
 </table>
 
-
 ## Operators
 
 <table>
@@ -126,8 +125,8 @@ foo matches "^[A-Z].*"
 ### Membership Operator
 
 Fields of structs and items of maps can be accessed with `.` operator
-or `[]` operator. Elements of arrays and slices can be accessed with 
-`[]` operator. Negative indices are supported with `-1` being 
+or `[]` operator. Elements of arrays and slices can be accessed with
+`[]` operator. Negative indices are supported with `-1` being
 the last element.
 
 The `in` operator can be used to check if an item is in an array or a map.
@@ -169,7 +168,6 @@ array[3:] == [4, 5]
 array[:] == array
 ```
 
-
 ## Built-in Functions
 
 ### all(array, predicate)
@@ -238,122 +236,262 @@ int("123") == 123
 
 Returns the float value of a number or a string.
 
-### string()
+### string(v)
 
-todo
+Converts the given value `v` into a string representation.
 
-### trim()
+```expr
+string(123) == "123"
+```
 
-todo
+### trim(v[, chars])
 
-### trimPrefix()
+Removes white spaces from both ends of a string `v`.
+If the optional `chars` argument is given, it is a string specifying the set of characters to be removed.
 
-todo
+```expr
+trim("  Hello  ") == "Hello"
+trim("__Hello__", "_") == "Hello"
+```
 
-### trimSuffix()
+### trimPrefix(v, prefix)
 
-todo
+Removes the specified prefix from the string `v` if it starts with that prefix.
 
-### upper()
+```expr
+trimPrefix("HelloWorld", "Hello") == "World"
+```
 
-todo
+### trimSuffix(v, suffix)
 
-### lower()
+Removes the specified suffix from the string `v` if it ends with that suffix.
 
-todo
+```expr
+trimSuffix("HelloWorld", "World") == "Hello"
+```
 
-### split()
+### upper(v)
 
-todo
+Converts all the characters in string `v` to uppercase.
 
-### splitN()
+```expr
+upper("hello") == "HELLO"
+```
 
-todo
+### lower(v)
 
-### splitAfter()
+Converts all the characters in string `v` to lowercase.
 
-todo
+```expr
+lower("HELLO") == "hello"
+```
 
-### splitAfterN()
+### split(v, delimiter)
 
-todo
+Splits the string `v` at each instance of the delimiter and returns an array of substrings.
 
-### replace()
+```expr
+split("apple,orange,grape", ",") == ["apple", "orange", "grape"]
+```
 
-todo
+### splitN(v, delimiter, n)
 
-### repeat()
+Splits the string `v` at each instance of the delimiter but limits the result to `n` substrings.
 
-todo
+```expr
+splitN("apple,orange,grape", ",", 2) == ["apple", "orange,grape"]
+```
 
-### join()
+### splitAfter(v, delimiter)
 
-todo
+Splits the string `v` after each instance of the delimiter.
 
-### indexOf()
+```expr
+splitAfter("apple,orange,grape", ",") == ["apple,", "orange,", "grape"]
+```
 
-todo
+### splitAfterN(v, delimiter, n)
 
-### lastIndexOf()
+Splits the string `v` after each instance of the delimiter but limits the result to `n` substrings.
 
-todo
+```expr
+splitAfterN("apple,orange,grape", ",", 2) == ["apple,", "orange,grape"]
+```
 
-### hasPrefix()
+### replace(v, old, new)
 
-todo
+Replaces all occurrences of `old` in string `v` with `new`.
 
-### hasSuffix()
+```expr
+replace("Hello World", "World", "Universe") == "Hello Universe"
+```
 
-todo
+### repeat(v, n)
 
-### max()
+Repeats the string `v` `n` times.
 
-todo
+```expr
+repeat("Hi", 3) == "HiHiHi"
+```
+
+### join(v, delimiter)
+
+Joins an array of strings `v` into a single string with the given delimiter.
+
+```expr
+join(["apple", "orange", "grape"], ",") == "apple,orange,grape"
+```
 
-### min()
+### indexOf(v, substring)
 
-todo
+Returns the index of the first occurrence of the substring in string `v` or -1 if not found.
 
-### toJSON()
+```expr
+indexOf("apple pie", "pie") == 6
+```
 
-todo
+### lastIndexOf(v, substring)
 
-### fromJSON()
+Returns the index of the last occurrence of the substring in string `v` or -1 if not found.
 
-todo
+```expr
+lastIndexOf("apple pie apple", "apple") == 10
+```
 
-### toBase64()
+### hasPrefix(v, prefix)
 
-todo
+Returns `true` if string `v` starts with the given prefix.
 
-### fromBase64()
+```expr
+hasPrefix("HelloWorld", "Hello") == true
+```
+
+### hasSuffix(v, suffix)
+
+Returns `true` if string `v` ends with the given suffix.
+
+```expr
+hasSuffix("HelloWorld", "World") == true
+```
+
+### max(v1, v2)
+
+Returns the maximum of the two values `v1` and `v2`.
+
+```expr
+max(5, 7) == 7
+```
 
-todo
+### min(v1, v2)
+
+Returns the minimum of the two values `v1` and `v2`.
+
+```expr
+min(5, 7) == 5
+```
+
+### toJSON(v)
+
+Converts the given value `v` to its JSON string representation.
+
+```expr
+toJSON({"name": "John", "age": 30})
+```
+
+### fromJSON(v)
+
+Parses the given JSON string `v` and returns the corresponding value.
+
+```expr
+fromJSON('{"name": "John", "age": 30}')
+```
+
+### toBase64(v)
+
+Encodes the string `v` into Base64 format.
+
+```expr
+toBase64("Hello World") == "SGVsbG8gV29ybGQ="
+```
+
+### fromBase64(v)
+
+Decodes the Base64 encoded string `v` back to its original form.
+
+```expr
+fromBase64("SGVsbG8gV29ybGQ=") == "Hello World"
+```
 
 ### now()
 
-todo
+Returns the current date and time.
+
+```expr
+createdAt > now() - duration(1h)
+```
+
+### duration(v)
+
+Returns [time.Duration](https://pkg.go.dev/time#Duration) value of the given string `v`.
 
-### duration()
+Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
 
-todo
+```expr
+duration("1h").Seconds() == 3600
+```
+
+### date(v[, format, timezone])
 
-### date()
+Converts the given value `v` into a date representation.
 
-todo
+If the optional `format` argument is given, it is a string specifying the format of the date.
+The format string uses the same formatting rules as the standard
+Go [time package](https://pkg.go.dev/time#pkg-constants).
 
-### first()
+If the optional `timezone` argument is given, it is a string specifying the timezone of the date.
 
-todo
+If the `format` argument is not given, the `v` argument must be in one of the following formats:
 
-### last()
+- 2006-01-02
+- 15:04:05
+- 2006-01-02 15:04:05
+- RFC3339
+- RFC822,
+- RFC850,
+- RFC1123,
 
-todo
+```expr
+date("2023-08-14")
+date("15:04:05")
+date("2023-08-14T00:00:00Z")
+date("2023-08-14 00:00:00", "2006-01-02 15:04:05", "Europe/Zurich")
+```
 
-### get()
+### first(v)
 
-todo
+Returns the first element from an array `v`. If the array is empty, returns `nil`.
 
+```expr
+first([1, 2, 3]) == 1
+```
+
+### last(v)
+
+Returns the last element from an array `v`. If the array is empty, returns `nil`.
+
+```expr
+last([1, 2, 3]) == 3
+```
+
+### get(v, index)
+
+Retrieves the element at the specified index from an array or map `v`. If the index is out of range, returns `nil`.
+Or the key does not exist, returns `nil`.
+
+```expr
+get([1, 2, 3], 1) == 2
+get({"name": "John", "age": 30}, "name") == "John"
+```
 
 ## Predicate
 

From 677dfb506e15dfcb1623ca0e9b5808118212ee79 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 12:54:09 +0200
Subject: [PATCH 048/506] Better type checks for env in get()

---
 builtin/builtin.go      | 26 +++---------
 builtin/builtin_test.go | 91 +++++++++++++++++++++++++++++------------
 checker/checker.go      | 46 ++++++++++++++++++---
 checker/checker_test.go | 28 +++++++++++++
 expr_test.go            |  2 +
 5 files changed, 141 insertions(+), 52 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index cb9399fd5..556223420 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -39,7 +39,7 @@ var Functions = []*Function{
 		Builtin1: Len,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments for len (expected 1, got %d)", len(args))
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 			switch kind(args[0]) {
 			case reflect.Array, reflect.Map, reflect.Slice, reflect.String, reflect.Interface:
@@ -53,7 +53,7 @@ var Functions = []*Function{
 		Builtin1: Abs,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments for abs (expected 1, got %d)", len(args))
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 			switch kind(args[0]) {
 			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
@@ -67,7 +67,7 @@ var Functions = []*Function{
 		Builtin1: Int,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments for int (expected 1, got %d)", len(args))
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 			switch kind(args[0]) {
 			case reflect.Interface:
@@ -85,7 +85,7 @@ var Functions = []*Function{
 		Builtin1: Float,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments for float (expected 1, got %d)", len(args))
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 			switch kind(args[0]) {
 			case reflect.Interface:
@@ -398,7 +398,7 @@ var Functions = []*Function{
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments for first (expected 1, got %d)", len(args))
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 			switch kind(args[0]) {
 			case reflect.Interface:
@@ -421,7 +421,7 @@ var Functions = []*Function{
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments for last (expected 1, got %d)", len(args))
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 			switch kind(args[0]) {
 			case reflect.Interface:
@@ -442,19 +442,5 @@ var Functions = []*Function{
 			}()
 			return runtime.Fetch(args[0], args[1]), nil
 		},
-		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 2 {
-				return anyType, fmt.Errorf("invalid number of arguments for get (expected 2, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Interface:
-				return anyType, nil
-			case reflect.Slice, reflect.Array:
-				return args[0].Elem(), nil
-			case reflect.Map:
-				return args[0].Elem(), nil
-			}
-			return anyType, fmt.Errorf("cannot get %s from %s", args[1], args[0])
-		},
 	},
 }
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index a18c903ef..94a146b8a 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -1,10 +1,15 @@
 package builtin_test
 
 import (
+	"fmt"
+	"reflect"
 	"testing"
 	"time"
 
 	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/checker"
+	"github.com/antonmedv/expr/conf"
+	"github.com/antonmedv/expr/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -96,32 +101,31 @@ func TestBuiltin(t *testing.T) {
 	}
 }
 
-var errorTests = []struct {
-	input string
-	err   string
-}{
-	{`len()`, `invalid number of arguments for len (expected 1, got 0)`},
-	{`len(1)`, `invalid argument for len (type int)`},
-	{`abs()`, `invalid number of arguments for abs (expected 1, got 0)`},
-	{`abs(1, 2)`, `invalid number of arguments for abs (expected 1, got 2)`},
-	{`abs("foo")`, `invalid argument for abs (type string)`},
-	{`int()`, `invalid number of arguments for int (expected 1, got 0)`},
-	{`int(1, 2)`, `invalid number of arguments for int (expected 1, got 2)`},
-	{`float()`, `invalid number of arguments for float (expected 1, got 0)`},
-	{`float(1, 2)`, `invalid number of arguments for float (expected 1, got 2)`},
-	{`string(1, 2)`, `too many arguments to call string`},
-	{`trim()`, `not enough arguments to call trim`},
-	{`max()`, `not enough arguments to call max`},
-	{`max(1, "2")`, `invalid argument for max (type string)`},
-	{`min()`, `not enough arguments to call min`},
-	{`min(1, "2")`, `invalid argument for min (type string)`},
-	{`duration("error")`, `invalid duration`},
-	{`date("error")`, `invalid date`},
-	{`get()`, `invalid number of arguments for get (expected 2, got 0)`},
-	{`get(1, 2)`, `cannot get int from int`},
-}
-
-func TestBuiltinErrors(t *testing.T) {
+func TestBuiltin_errors(t *testing.T) {
+	var errorTests = []struct {
+		input string
+		err   string
+	}{
+		{`len()`, `invalid number of arguments (expected 1, got 0)`},
+		{`len(1)`, `invalid argument for len (type int)`},
+		{`abs()`, `invalid number of arguments (expected 1, got 0)`},
+		{`abs(1, 2)`, `invalid number of arguments (expected 1, got 2)`},
+		{`abs("foo")`, `invalid argument for abs (type string)`},
+		{`int()`, `invalid number of arguments (expected 1, got 0)`},
+		{`int(1, 2)`, `invalid number of arguments (expected 1, got 2)`},
+		{`float()`, `invalid number of arguments (expected 1, got 0)`},
+		{`float(1, 2)`, `invalid number of arguments (expected 1, got 2)`},
+		{`string(1, 2)`, `too many arguments to call string`},
+		{`trim()`, `not enough arguments to call trim`},
+		{`max()`, `not enough arguments to call max`},
+		{`max(1, "2")`, `invalid argument for max (type string)`},
+		{`min()`, `not enough arguments to call min`},
+		{`min(1, "2")`, `invalid argument for min (type string)`},
+		{`duration("error")`, `invalid duration`},
+		{`date("error")`, `invalid date`},
+		{`get()`, `invalid number of arguments (expected 2, got 0)`},
+		{`get(1, 2)`, `type int does not support indexing`},
+	}
 	for _, test := range errorTests {
 		t.Run(test.input, func(t *testing.T) {
 			_, err := expr.Eval(test.input, nil)
@@ -130,3 +134,38 @@ func TestBuiltinErrors(t *testing.T) {
 		})
 	}
 }
+
+func TestBuiltin_types(t *testing.T) {
+	env := map[string]interface{}{
+		"num":           42,
+		"str":           "foo",
+		"ArrayOfString": []string{"foo", "bar", "baz"},
+		"ArrayOfInt":    []int{1, 2, 3},
+	}
+
+	tests := []struct {
+		input string
+		want  reflect.Kind
+	}{
+		{`get(ArrayOfString, 0)`, reflect.String},
+		{`get(ArrayOfInt, 0)`, reflect.Int},
+		{`first(ArrayOfString)`, reflect.String},
+		{`first(ArrayOfInt)`, reflect.Int},
+		{`last(ArrayOfString)`, reflect.String},
+		{`last(ArrayOfInt)`, reflect.Int},
+		{`get(env, 'str')`, reflect.String},
+		{`get(env, 'num')`, reflect.Int},
+		{`get(env, 'ArrayOfString')`, reflect.Slice},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			tree, err := parser.Parse(test.input)
+			require.NoError(t, err)
+
+			rtype, err := checker.Check(tree, conf.New(env))
+			require.NoError(t, err)
+			require.True(t, rtype.Kind() == test.want, fmt.Sprintf("expected %s, got %s", test.want, rtype.Kind()))
+		})
+	}
+}
diff --git a/checker/checker.go b/checker/checker.go
index c67850d7d..973786bd1 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -135,6 +135,9 @@ func (v *visitor) NilNode(*ast.NilNode) (reflect.Type, info) {
 }
 
 func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info) {
+	if node.Value == "env" {
+		return mapType, info{}
+	}
 	if fn, ok := v.config.Functions[node.Value]; ok {
 		// Return anyType instead of func type as we don't know the arguments yet.
 		// The func type can be one of the fn.Types. The type will be resolved
@@ -393,7 +396,9 @@ func (v *visitor) ChainNode(node *ast.ChainNode) (reflect.Type, info) {
 }
 
 func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
+	base, _ := v.visit(node.Node)
 	prop, _ := v.visit(node.Property)
+
 	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "env" {
 		// If the index is a constant string, can save some
 		// cycles later by finding the type of its referent
@@ -404,7 +409,6 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 		}
 		return anyType, info{}
 	}
-	base, _ := v.visit(node.Node)
 
 	if name, ok := node.Property.(*ast.StringNode); ok {
 		if base == nil {
@@ -503,7 +507,7 @@ func (v *visitor) CallNode(node *ast.CallNode) (reflect.Type, info) {
 
 	if fnInfo.fn != nil {
 		node.Func = fnInfo.fn
-		return v.checkFunction(fnInfo.fn, node.Arguments, node)
+		return v.checkFunction(fnInfo.fn, node, node.Arguments)
 	}
 
 	fnName := "function"
@@ -639,13 +643,44 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
-		return v.checkFunction(builtin.Functions[id], node.Arguments, node)
+		switch node.Name {
+		case "get":
+			return v.checkBuiltinGet(node)
+		}
+		return v.checkFunction(builtin.Functions[id], node, node.Arguments)
 	}
 
 	return v.error(node, "unknown builtin %v", node.Name)
 }
 
-func (v *visitor) checkFunction(f *builtin.Function, arguments []ast.Node, node ast.Node) (reflect.Type, info) {
+func (v *visitor) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
+	if len(node.Arguments) != 2 {
+		return v.error(node, "invalid number of arguments (expected 2, got %d)", len(node.Arguments))
+	}
+
+	val := node.Arguments[0]
+	prop := node.Arguments[1]
+	if id, ok := val.(*ast.IdentifierNode); ok && id.Value == "env" {
+		if s, ok := prop.(*ast.StringNode); ok {
+			return v.config.Types[s.Value].Type, info{}
+		}
+		return anyType, info{}
+	}
+
+	t, _ := v.visit(val)
+
+	switch t.Kind() {
+	case reflect.Interface:
+		return anyType, info{}
+	case reflect.Slice, reflect.Array:
+		return t.Elem(), info{}
+	case reflect.Map:
+		return t.Elem(), info{}
+	}
+	return v.error(val, "type %v does not support indexing", t)
+}
+
+func (v *visitor) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) (reflect.Type, info) {
 	if f.Validate != nil {
 		args := make([]reflect.Type, len(arguments))
 		for i, arg := range arguments {
@@ -656,8 +691,7 @@ func (v *visitor) checkFunction(f *builtin.Function, arguments []ast.Node, node
 			return v.error(node, "%v", err)
 		}
 		return t, info{}
-	}
-	if len(f.Types) == 0 {
+	} else if len(f.Types) == 0 {
 		t, err := v.checkArguments(f.Name, functionType, false, arguments, node)
 		if err != nil {
 			if v.err == nil {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 70d7b4bc9..127c7dd57 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -934,3 +934,31 @@ func TestCheck_do_not_override_params_for_functions(t *testing.T) {
 		require.Contains(t, err.Error(), "cannot use int as argument")
 	})
 }
+
+func TestCheck_env_keyword(t *testing.T) {
+	env := map[string]interface{}{
+		"num":  42,
+		"str":  "foo",
+		"name": "str",
+	}
+
+	tests := []struct {
+		input string
+		want  reflect.Kind
+	}{
+		{`env['str']`, reflect.String},
+		{`env['num']`, reflect.Int},
+		{`env[name]`, reflect.Interface},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			tree, err := parser.Parse(test.input)
+			require.NoError(t, err)
+
+			rtype, err := checker.Check(tree, conf.New(env))
+			require.NoError(t, err)
+			require.True(t, rtype.Kind() == test.want, fmt.Sprintf("expected %s, got %s", test.want, rtype.Kind()))
+		})
+	}
+}
diff --git a/expr_test.go b/expr_test.go
index 16464383f..7a7aea97c 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1704,6 +1704,8 @@ func TestEnv_keyword(t *testing.T) {
 		{"env.mylist[1]", 2},
 		{"env?.OtherMap?.a", "b"},
 		{"env?.OtherMap?.d", ""},
+		{"'num' in env", true},
+		{"get(env, 'num')", 10},
 	}
 
 	for _, tt := range tests {

From a9c94aa45744d91f4e5fc02a5d5ce5198353fcec Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 14:38:48 +0200
Subject: [PATCH 049/506] Fix pipe operator parsing

---
 parser/parser.go         | 29 ++++++++++++++---------------
 test/pipes/pipes_test.go | 36 +++++++++++++++++++++++++++++++-----
 2 files changed, 45 insertions(+), 20 deletions(-)

diff --git a/parser/parser.go b/parser/parser.go
index 0792ead1c..5f070b91c 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -32,6 +32,7 @@ var unaryOperators = map[string]operator{
 }
 
 var binaryOperators = map[string]operator{
+	"|":          {0, left},
 	"or":         {10, left},
 	"||":         {10, left},
 	"and":        {15, left},
@@ -147,12 +148,13 @@ func (p *parser) expect(kind Kind, values ...string) {
 func (p *parser) parseExpression(precedence int) Node {
 	nodeLeft := p.parsePrimary()
 
-	lastOperator := ""
+	prevOperator := ""
 	opToken := p.current
 	for opToken.Is(Operator) && p.err == nil {
 		negate := false
 		var notToken Token
 
+		// Handle "not *" operator, like "not in" or "not contains".
 		if opToken.Is(Operator, "not") {
 			p.next()
 			notToken = p.current
@@ -164,7 +166,12 @@ func (p *parser) parseExpression(precedence int) Node {
 			if op.precedence >= precedence {
 				p.next()
 
-				if lastOperator == "??" && opToken.Value != "??" && !opToken.Is(Bracket, "(") {
+				if opToken.Value == "|" {
+					nodeLeft = p.parsePipe(nodeLeft)
+					goto next
+				}
+
+				if prevOperator == "??" && opToken.Value != "??" && !opToken.Is(Bracket, "(") {
 					p.errorAt(opToken, "Operator (%v) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses.", opToken.Value)
 					break
 				}
@@ -191,21 +198,18 @@ func (p *parser) parseExpression(precedence int) Node {
 					nodeLeft.SetLocation(notToken.Location)
 				}
 
-				lastOperator = opToken.Value
-				opToken = p.current
-				continue
+				goto next
 			}
 		}
 		break
+
+	next:
+		prevOperator = opToken.Value
+		opToken = p.current
 	}
 
 	if precedence == 0 {
 		nodeLeft = p.parseConditional(nodeLeft)
-
-		if p.current.Is(Operator, "|") {
-			p.next()
-			return p.parsePipe(nodeLeft)
-		}
 	}
 
 	return nodeLeft
@@ -626,11 +630,6 @@ func (p *parser) parsePipe(node Node) Node {
 		node.SetLocation(identifier.Location)
 	}
 
-	if p.current.Is(Operator, "|") {
-		p.next()
-		return p.parsePipe(node)
-	}
-
 	return node
 }
 
diff --git a/test/pipes/pipes_test.go b/test/pipes/pipes_test.go
index 47f440681..f2c0a93b3 100644
--- a/test/pipes/pipes_test.go
+++ b/test/pipes/pipes_test.go
@@ -13,12 +13,38 @@ func TestPipes(t *testing.T) {
 		"sprintf": fmt.Sprintf,
 	}
 
-	program, err := expr.Compile(`"%s bar %d" | sprintf("foo", -42 | abs())`, expr.Env(env))
-	require.NoError(t, err)
+	tests := []struct {
+		input string
+		want  interface{}
+	}{
+		{
+			`-1 | abs()`,
+			1,
+		},
+		{
+			`"%s bar %d" | sprintf("foo", -42 | abs())`,
+			"foo bar 42",
+		},
+		{
+			`[] | first() ?? "foo"`,
+			"foo",
+		},
+		{
+			`['a'] | first() + "b" | upper()`,
+			"AB",
+		},
+	}
 
-	out, err := expr.Run(program, env)
-	require.NoError(t, err)
-	require.Equal(t, "foo bar 42", out)
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			program, err := expr.Compile(test.input, expr.Env(env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, env)
+			require.NoError(t, err)
+			require.Equal(t, test.want, out)
+		})
+	}
 }
 
 func TestPipes_map_filter(t *testing.T) {

From cee681e6165f9cea28bd83921cec0c72e0abce54 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 15:17:36 +0200
Subject: [PATCH 050/506] Add more pipe tests

---
 test/pipes/pipes_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/pipes/pipes_test.go b/test/pipes/pipes_test.go
index f2c0a93b3..6a0e2950b 100644
--- a/test/pipes/pipes_test.go
+++ b/test/pipes/pipes_test.go
@@ -30,8 +30,8 @@ func TestPipes(t *testing.T) {
 			"foo",
 		},
 		{
-			`['a'] | first() + "b" | upper()`,
-			"AB",
+			`"a" | upper() + "B" | lower()`,
+			"ab",
 		},
 	}
 

From 24608fb366f02185607f57caae80987947ac8b5b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 15:39:59 +0200
Subject: [PATCH 051/506] Add expr.ExperimentalPipes() config

---
 conf/config.go           |  1 +
 expr.go                  | 13 ++++++++++++-
 parser/parser.go         | 15 +++++++++++++++
 parser/parser_test.go    |  4 ++--
 test/pipes/pipes_test.go |  4 ++--
 test/time/time_test.go   |  6 +++---
 6 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/conf/config.go b/conf/config.go
index ad7f36c1c..849cdce14 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -22,6 +22,7 @@ type Config struct {
 	ConstFns    map[string]reflect.Value
 	Visitors    []ast.Visitor
 	Functions   map[string]*builtin.Function
+	Pipes       bool
 }
 
 // CreateNew creates new config with default values.
diff --git a/expr.go b/expr.go
index 1d81226ca..6314314b1 100644
--- a/expr.go
+++ b/expr.go
@@ -130,6 +130,13 @@ func Function(name string, fn func(params ...interface{}) (interface{}, error),
 	}
 }
 
+// ExperimentalPipes enables pipes syntax.
+func ExperimentalPipes() Option {
+	return func(c *conf.Config) {
+		c.Pipes = true
+	}
+}
+
 // Compile parses and compiles given input expression to bytecode program.
 func Compile(input string, ops ...Option) (*vm.Program, error) {
 	config := conf.CreateNew()
@@ -146,7 +153,11 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 		})
 	}
 
-	tree, err := parser.Parse(input)
+	parseConfig := parser.Config{
+		Pipes: config.Pipes,
+	}
+
+	tree, err := parser.ParseWithConfig(input, parseConfig)
 	if err != nil {
 		return nil, err
 	}
diff --git a/parser/parser.go b/parser/parser.go
index 5f070b91c..3288662b5 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -77,6 +77,7 @@ type parser struct {
 	pos     int
 	err     *file.Error
 	depth   int // closure call depth
+	pipes   bool
 }
 
 type Tree struct {
@@ -84,7 +85,15 @@ type Tree struct {
 	Source *file.Source
 }
 
+type Config struct {
+	Pipes bool
+}
+
 func Parse(input string) (*Tree, error) {
+	return ParseWithConfig(input, Config{})
+}
+
+func ParseWithConfig(input string, config Config) (*Tree, error) {
 	source := file.NewSource(input)
 
 	tokens, err := Lex(source)
@@ -95,6 +104,7 @@ func Parse(input string) (*Tree, error) {
 	p := &parser{
 		tokens:  tokens,
 		current: tokens[0],
+		pipes:   config.Pipes,
 	}
 
 	node := p.parseExpression(0)
@@ -592,6 +602,11 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 }
 
 func (p *parser) parsePipe(node Node) Node {
+	if !p.pipes {
+		p.error("enable Pipes via expr.ExperimentalPipes()")
+		return &NilNode{}
+	}
+
 	identifier := p.current
 	p.expect(Identifier)
 
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 256024e0d..0d5d62d47 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -453,7 +453,7 @@ func TestParse(t *testing.T) {
 					&BoolNode{Value: true}}}},
 	}
 	for _, test := range parseTests {
-		actual, err := parser.Parse(test.input)
+		actual, err := parser.ParseWithConfig(test.input, parser.Config{Pipes: true})
 		if err != nil {
 			t.Errorf("%s:\n%v", test.input, err)
 			continue
@@ -657,7 +657,7 @@ func TestParse_pipe_operator(t *testing.T) {
 									Property: &StringNode{Value: "foo"},
 								}}}}}}}}
 
-	actual, err := parser.Parse(input)
+	actual, err := parser.ParseWithConfig(input, parser.Config{Pipes: true})
 	require.NoError(t, err)
 	assert.Equal(t, Dump(expect), Dump(actual.Node))
 }
diff --git a/test/pipes/pipes_test.go b/test/pipes/pipes_test.go
index 6a0e2950b..1658dd6aa 100644
--- a/test/pipes/pipes_test.go
+++ b/test/pipes/pipes_test.go
@@ -37,7 +37,7 @@ func TestPipes(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
-			program, err := expr.Compile(test.input, expr.Env(env))
+			program, err := expr.Compile(test.input, expr.Env(env), expr.ExperimentalPipes())
 			require.NoError(t, err)
 
 			out, err := expr.Run(program, env)
@@ -48,7 +48,7 @@ func TestPipes(t *testing.T) {
 }
 
 func TestPipes_map_filter(t *testing.T) {
-	program, err := expr.Compile(`1..9 | map(# + 1) | filter(# % 2 == 0)`)
+	program, err := expr.Compile(`1..9 | map(# + 1) | filter(# % 2 == 0)`, expr.ExperimentalPipes())
 	require.NoError(t, err)
 
 	out, err := expr.Run(program, nil)
diff --git a/test/time/time_test.go b/test/time/time_test.go
index 200c821ee..eb8d478dc 100644
--- a/test/time/time_test.go
+++ b/test/time/time_test.go
@@ -120,15 +120,15 @@ func TestTime_date(t *testing.T) {
 		want  time.Time
 	}{
 		{
-			`'2017-10-23' | date()`,
+			`date('2017-10-23')`,
 			time.Date(2017, 10, 23, 0, 0, 0, 0, time.UTC),
 		},
 		{
-			`'24.11.1987 20:30' | date("02.01.2006 15:04", "Europe/Zurich")`,
+			`date('24.11.1987 20:30', "02.01.2006 15:04", "Europe/Zurich")`,
 			time.Date(1987, 11, 24, 20, 30, 0, 0, time.FixedZone("Europe/Zurich", 3600)),
 		},
 		{
-			`'24.11.1987 20:30 MSK' | date("02.01.2006 15:04 MST", "Europe/Zurich")`,
+			`date('24.11.1987 20:30 MSK', "02.01.2006 15:04 MST", "Europe/Zurich")`,
 			time.Date(1987, 11, 24, 20, 30, 0, 0, time.FixedZone("MSK", 0)),
 		},
 	}

From 8e6e992bcba45cac82067dbd8bdc2095dc8cd0ac Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 16:40:36 +0200
Subject: [PATCH 052/506] Integrate repl with debugger

---
 debug/debugger.go |  5 ++++-
 repl/go.mod       | 14 +++++++++++++-
 repl/go.sum       | 21 +++++++++++++++++++++
 repl/repl.go      | 45 ++++++++++++++++++++++++++++++++-------------
 vm/program.go     |  9 +++++++--
 5 files changed, 77 insertions(+), 17 deletions(-)

diff --git a/debug/debugger.go b/debug/debugger.go
index b7af11230..6f71c322f 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -58,7 +58,10 @@ func StartDebugger(program *Program, env interface{}) {
 	}()
 
 	index := make(map[int]int)
-	for row, line := range strings.Split(program.Disassemble(), "\n") {
+	var buf strings.Builder
+	program.Opcodes(&buf)
+
+	for row, line := range strings.Split(buf.String(), "\n") {
 		if line == "" {
 			continue
 		}
diff --git a/repl/go.mod b/repl/go.mod
index 4e15b13bb..7bda6fbff 100644
--- a/repl/go.mod
+++ b/repl/go.mod
@@ -4,9 +4,21 @@ go 1.20
 
 require (
 	github.com/antonmedv/expr v0.0.0
+	github.com/antonmedv/expr/debug v0.0.0
 	github.com/chzyer/readline v1.5.1
 )
 
-require golang.org/x/sys v0.11.0 // indirect
+require (
+	github.com/gdamore/encoding v1.0.0 // indirect
+	github.com/gdamore/tcell v1.3.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.0.3 // indirect
+	github.com/mattn/go-runewidth v0.0.8 // indirect
+	github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498 // indirect
+	github.com/rivo/uniseg v0.1.0 // indirect
+	golang.org/x/sys v0.11.0 // indirect
+	golang.org/x/text v0.3.2 // indirect
+)
 
 replace github.com/antonmedv/expr => ../
+
+replace github.com/antonmedv/expr/debug => ../debug
diff --git a/repl/go.sum b/repl/go.sum
index e5a857a0c..438d30deb 100644
--- a/repl/go.sum
+++ b/repl/go.sum
@@ -1,3 +1,4 @@
+github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
 github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
 github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
@@ -7,16 +8,36 @@ github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
+github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
+github.com/gdamore/tcell v1.3.0 h1:r35w0JBADPZCVQijYebl6YMWWtHRqVEGt7kL2eBADRM=
+github.com/gdamore/tcell v1.3.0/go.mod h1:Hjvr+Ofd+gLglo7RYKxxnzCBmev3BzsS67MebKS4zMM=
+github.com/lucasb-eyer/go-colorful v1.0.2/go.mod h1:0MS4r+7BZKSJ5mw4/S5MPN+qHFF1fYclkSPilDOKW0s=
+github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tWFlaaUAac=
+github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0=
+github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498 h1:4CFNy7/q7P06AsIONZzuWy7jcdqEmYQvOZ9FAFZdbls=
+github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498/go.mod h1:6lkG1x+13OShEf0EaOCaTQYyB7d5nSbb181KtjlS+84=
+github.com/rivo/uniseg v0.1.0 h1:+2KBaVoUmb9XzDsrx/Ct0W/EYOSFf/nWTauy++DprtY=
+github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/repl/repl.go b/repl/repl.go
index 453c70531..78ba1bd66 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -2,44 +2,54 @@ package main
 
 import (
 	"fmt"
+	"os"
 	"strings"
 
 	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/builtin"
+	"github.com/antonmedv/expr/debug"
 	"github.com/antonmedv/expr/vm"
 	"github.com/chzyer/readline"
 )
 
+var keywords = []string{
+	"exit", "opcodes", "debug",
+
+	// Predicate functions:
+	"map", "filter", "all",
+	"any", "none", "one",
+
+	// Operators:
+	"and", "or", "in", "not", "not in",
+	"contains", "matches", "startsWith", "endsWith",
+}
+
 func main() {
-	extra := []string{
-		"exit",
-		"opcodes",
-		"map",
-		"filter",
-		"all",
-		"any",
-		"none",
-		"one",
-	}
 	rl, err := readline.NewEx(&readline.Config{
 		Prompt:       "> ",
-		AutoComplete: completer{append(builtin.Names, extra...)},
+		AutoComplete: completer{append(builtin.Names, keywords...)},
 	})
 	if err != nil {
 		panic(err)
 	}
 	defer rl.Close()
 
+	env := map[string]interface{}{
+		"ENV": os.Environ(),
+	}
 	var program *vm.Program
+
 	for {
 		line, err := rl.Readline()
 		if err != nil { // io.EOF when Ctrl-D is pressed
 			break
 		}
 		line = strings.TrimSpace(line)
+
 		if line == "exit" {
 			break
 		}
+
 		if line == "opcodes" {
 			if program == nil {
 				fmt.Println("no program")
@@ -49,12 +59,21 @@ func main() {
 			continue
 		}
 
-		program, err = expr.Compile(line, expr.Env(nil))
+		if line == "debug" {
+			if program == nil {
+				fmt.Println("no program")
+				continue
+			}
+			debug.StartDebugger(program, env)
+			continue
+		}
+
+		program, err = expr.Compile(line, expr.Env(env), expr.ExperimentalPipes())
 		if err != nil {
 			fmt.Printf("compile error: %s\n", err)
 			continue
 		}
-		output, err := expr.Run(program, nil)
+		output, err := expr.Run(program, env)
 		if err != nil {
 			fmt.Printf("runtime error: %s\n", err)
 			continue
diff --git a/vm/program.go b/vm/program.go
index d6018139d..24747df90 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -3,6 +3,7 @@ package vm
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"reflect"
 	"regexp"
 	"strings"
@@ -27,6 +28,12 @@ type Program struct {
 func (program *Program) Disassemble() string {
 	var buf bytes.Buffer
 	w := tabwriter.NewWriter(&buf, 0, 0, 2, ' ', 0)
+	program.Opcodes(w)
+	_ = w.Flush()
+	return buf.String()
+}
+
+func (program *Program) Opcodes(w io.Writer) {
 	ip := 0
 	for ip < len(program.Bytecode) {
 		pp := ip
@@ -275,6 +282,4 @@ func (program *Program) Disassemble() string {
 			_, _ = fmt.Fprintf(w, "%v\t%#x (unknown)\n", ip, op)
 		}
 	}
-	_ = w.Flush()
-	return buf.String()
 }

From a21a00d0d06faa7f91457648330197a4fd599f59 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 17:02:33 +0200
Subject: [PATCH 053/506] Update debugger deps

---
 debug/debugger.go |  4 +--
 debug/go.mod      | 10 +++++---
 debug/go.sum      | 65 ++++++++++++++++++++++++++++++++++-------------
 repl/go.mod       | 15 ++++++-----
 repl/go.sum       | 62 +++++++++++++++++++++++++++++++-------------
 5 files changed, 109 insertions(+), 47 deletions(-)

diff --git a/debug/debugger.go b/debug/debugger.go
index 6f71c322f..7de851769 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -8,7 +8,7 @@ import (
 	"time"
 
 	. "github.com/antonmedv/expr/vm"
-	"github.com/gdamore/tcell"
+	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
 )
 
@@ -85,7 +85,7 @@ func StartDebugger(program *Program, env interface{}) {
 		app.QueueUpdateDraw(func() {
 			for row := 0; row < table.GetRowCount(); row++ {
 				for col := 0; col < table.GetColumnCount(); col++ {
-					table.GetCell(row, col).SetBackgroundColor(tcell.ColorDefault)
+					table.GetCell(row, col).SetBackgroundColor(tcell.ColorBlack)
 				}
 			}
 
diff --git a/debug/go.mod b/debug/go.mod
index 5dbf3d776..831ec776e 100644
--- a/debug/go.mod
+++ b/debug/go.mod
@@ -3,9 +3,13 @@ module github.com/antonmedv/expr/debug
 go 1.13
 
 require (
-	github.com/antonmedv/expr v0.0.0
-	github.com/gdamore/tcell v1.3.0
-	github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498
+	github.com/antonmedv/expr v1.13.0
+	github.com/gdamore/tcell/v2 v2.6.0
+	github.com/mattn/go-runewidth v0.0.15 // indirect
+	github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703
+	github.com/rivo/uniseg v0.4.4 // indirect
+	golang.org/x/term v0.11.0 // indirect
+	golang.org/x/text v0.12.0 // indirect
 )
 
 replace github.com/antonmedv/expr => ../
diff --git a/debug/go.sum b/debug/go.sum
index 3eaa3b26f..879eeb41d 100644
--- a/debug/go.sum
+++ b/debug/go.sum
@@ -1,35 +1,64 @@
-github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
-github.com/gdamore/tcell v1.3.0 h1:r35w0JBADPZCVQijYebl6YMWWtHRqVEGt7kL2eBADRM=
-github.com/gdamore/tcell v1.3.0/go.mod h1:Hjvr+Ofd+gLglo7RYKxxnzCBmev3BzsS67MebKS4zMM=
-github.com/lucasb-eyer/go-colorful v1.0.2/go.mod h1:0MS4r+7BZKSJ5mw4/S5MPN+qHFF1fYclkSPilDOKW0s=
-github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tWFlaaUAac=
-github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
-github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0=
-github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/gdamore/tcell/v2 v2.6.0 h1:OKbluoP9VYmJwZwq/iLb4BxwKcwGthaa1YNBJIyCySg=
+github.com/gdamore/tcell/v2 v2.6.0/go.mod h1:be9omFATkdr0D9qewWW3d+MEvl5dha+Etb5y65J2H8Y=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498 h1:4CFNy7/q7P06AsIONZzuWy7jcdqEmYQvOZ9FAFZdbls=
-github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498/go.mod h1:6lkG1x+13OShEf0EaOCaTQYyB7d5nSbb181KtjlS+84=
-github.com/rivo/uniseg v0.1.0 h1:+2KBaVoUmb9XzDsrx/Ct0W/EYOSFf/nWTauy++DprtY=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703 h1:ZyM/+FYnpbZsFWuCohniM56kRoHRB4r5EuIzXEYkpxo=
+github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703/go.mod h1:nVwGv4MP47T0jvlk7KuTTjjuSmrGO4JF0iaiNt4bufE=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4 h1:sfkvUWPNGwSV+8/fNqctR5lS2AqCSqYwXdrjCxp/dXo=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.11.0 h1:F9tnn/DA/Im8nCwm+fX+1/eBwi4qFjRT++MhtVC4ZX0=
+golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
+golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/repl/go.mod b/repl/go.mod
index 7bda6fbff..c099d3b85 100644
--- a/repl/go.mod
+++ b/repl/go.mod
@@ -3,20 +3,21 @@ module github.com/antonmedv/expr/repl
 go 1.20
 
 require (
-	github.com/antonmedv/expr v0.0.0
+	github.com/antonmedv/expr v1.13.0
 	github.com/antonmedv/expr/debug v0.0.0
 	github.com/chzyer/readline v1.5.1
 )
 
 require (
 	github.com/gdamore/encoding v1.0.0 // indirect
-	github.com/gdamore/tcell v1.3.0 // indirect
-	github.com/lucasb-eyer/go-colorful v1.0.3 // indirect
-	github.com/mattn/go-runewidth v0.0.8 // indirect
-	github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498 // indirect
-	github.com/rivo/uniseg v0.1.0 // indirect
+	github.com/gdamore/tcell/v2 v2.6.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // indirect
+	github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703 // indirect
+	github.com/rivo/uniseg v0.4.4 // indirect
 	golang.org/x/sys v0.11.0 // indirect
-	golang.org/x/text v0.3.2 // indirect
+	golang.org/x/term v0.11.0 // indirect
+	golang.org/x/text v0.12.0 // indirect
 )
 
 replace github.com/antonmedv/expr => ../
diff --git a/repl/go.sum b/repl/go.sum
index 438d30deb..ba8ef9af6 100644
--- a/repl/go.sum
+++ b/repl/go.sum
@@ -1,4 +1,3 @@
-github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
 github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
 github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
@@ -10,34 +9,63 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
-github.com/gdamore/tcell v1.3.0 h1:r35w0JBADPZCVQijYebl6YMWWtHRqVEGt7kL2eBADRM=
-github.com/gdamore/tcell v1.3.0/go.mod h1:Hjvr+Ofd+gLglo7RYKxxnzCBmev3BzsS67MebKS4zMM=
-github.com/lucasb-eyer/go-colorful v1.0.2/go.mod h1:0MS4r+7BZKSJ5mw4/S5MPN+qHFF1fYclkSPilDOKW0s=
-github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tWFlaaUAac=
-github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
-github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0=
-github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/gdamore/tcell/v2 v2.6.0 h1:OKbluoP9VYmJwZwq/iLb4BxwKcwGthaa1YNBJIyCySg=
+github.com/gdamore/tcell/v2 v2.6.0/go.mod h1:be9omFATkdr0D9qewWW3d+MEvl5dha+Etb5y65J2H8Y=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498 h1:4CFNy7/q7P06AsIONZzuWy7jcdqEmYQvOZ9FAFZdbls=
-github.com/rivo/tview v0.0.0-20200219210816-cd38d7432498/go.mod h1:6lkG1x+13OShEf0EaOCaTQYyB7d5nSbb181KtjlS+84=
-github.com/rivo/uniseg v0.1.0 h1:+2KBaVoUmb9XzDsrx/Ct0W/EYOSFf/nWTauy++DprtY=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703 h1:ZyM/+FYnpbZsFWuCohniM56kRoHRB4r5EuIzXEYkpxo=
+github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703/go.mod h1:nVwGv4MP47T0jvlk7KuTTjjuSmrGO4JF0iaiNt4bufE=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.11.0 h1:F9tnn/DA/Im8nCwm+fX+1/eBwi4qFjRT++MhtVC4ZX0=
+golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
+golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

From 54fb84bf4fbfee4a20cbd27dbdc851bc85ce758b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 17:11:34 +0200
Subject: [PATCH 054/506] Update README.md

---
 README.md | 29 +++++++++++++++++++++++------
 1 file changed, 23 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 1aab8b685..b223940f4 100644
--- a/README.md
+++ b/README.md
@@ -26,21 +26,38 @@ product.Stock < 15
 
 ## Features
 
-* Seamless integration with Go (no need to redefine types)
-* Static typing ([example](https://godoc.org/github.com/antonmedv/expr#example-Env)).
+**Expr** is a safe, fast, and intuitive expression evaluator optimized for the Go language. 
+Here are its standout features:
+
+### Safety and Isolation
+* **Memory-Safe**: Expr is designed with a focus on safety, ensuring that programs do not access unrelated memory or introduce memory vulnerabilities.
+* **Side-Effect-Free**: Expressions evaluated in Expr only compute outputs from their inputs, ensuring no side-effects that can change state or produce unintended results.
+* **Always Terminating**: Expr is designed to prevent infinite loops, ensuring that every program will conclude in a reasonable amount of time.
+
+### Go Integration
+* **Seamless with Go**: Integrate Expr into your Go projects without the need to redefine types.
+
+### Static Typing
+* Ensures type correctness and prevents runtime type errors.
   ```go
   out, err := expr.Compile(`name + age`)
   // err: invalid operation + (mismatched types string and int)
   // | name + age
   // | .....^
   ```
-* User-friendly error messages.
-* Reasonable set of basic operators.
-* Builtins `all`, `none`, `any`, `one`, `filter`, `map`.
+
+### User-Friendly
+* Provides user-friendly error messages to assist with debugging and development.
+
+### Flexibility and Utility
+* **Rich Operators**: Offers a reasonable set of basic operators for a variety of applications.
+* **Built-in Functions**: Functions like `all`, `none`, `any`, `one`, `filter`, and `map` are provided out-of-the-box.
   ```coffeescript
   all(Tweets, {.Size <= 280})
   ```
-* Fast ([benchmarks](https://github.com/antonmedv/golang-expression-evaluation-comparison#readme)): uses bytecode virtual machine and optimizing compiler.
+
+### Performance
+* **Optimized for Speed**: Expr stands out in its performance, utilizing an optimizing compiler and a bytecode virtual machine. Check out these [benchmarks](https://github.com/antonmedv/golang-expression-evaluation-comparison#readme) for more details.
 
 ## Install
 

From b132d24022c7ed1fef1bbf97161bf90369c104ea Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 22:47:38 +0200
Subject: [PATCH 055/506] Update README.md

---
 README.md | 23 ++++++++---------------
 1 file changed, 8 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index b223940f4..8f2234d2b 100644
--- a/README.md
+++ b/README.md
@@ -3,25 +3,18 @@
 [![Go Report Card](https://goreportcard.com/badge/github.com/antonmedv/expr)](https://goreportcard.com/report/github.com/antonmedv/expr) 
 [![GoDoc](https://godoc.org/github.com/antonmedv/expr?status.svg)](https://godoc.org/github.com/antonmedv/expr)
 
-<img src="https://expr.medv.io/img/logo-small.png" width="150" alt="expr logo" align="right"/>
-
-**Expr** package provides an engine that can compile and evaluate expressions. 
-An expression is a one-liner that returns a value (mostly, but not limited to, booleans).
-It is designed for simplicity, speed and safety.
+**Expr** is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed.
 
-The purpose of the package is to allow users to use expressions inside configuration for more complex logic. 
-It is a perfect candidate for the foundation of a _business rule engine_. 
-The idea is to let configure things in a dynamic way without recompile of a program:
+<img src="https://expr.medv.io/img/logo-small.png" width="150" alt="expr logo" align="right"/>
 
 ```js
-// Get the special price if
-user.Group in ["good_customers", "collaborator"]
-
-// Promote article to the homepage when
-len(article.Comments) > 100 and article.Category not in ["misc"]
+// Allow only admins and moderators to moderate comments.
+user.Group in ["admin", "moderator"] || user.Id == comment.UserId
+```
 
-// Send an alert when
-product.Stock < 15
+```js
+// Ensure all tweets are less than 240 characters.
+all(Tweets, .Size <= 240)
 ```
 
 ## Features

From ba04206a438caf6cf03456ef223912d90e08efb7 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 22:50:15 +0200
Subject: [PATCH 056/506] Update README.md

---
 README.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/README.md b/README.md
index 8f2234d2b..5c0a1e027 100644
--- a/README.md
+++ b/README.md
@@ -45,9 +45,6 @@ Here are its standout features:
 ### Flexibility and Utility
 * **Rich Operators**: Offers a reasonable set of basic operators for a variety of applications.
 * **Built-in Functions**: Functions like `all`, `none`, `any`, `one`, `filter`, and `map` are provided out-of-the-box.
-  ```coffeescript
-  all(Tweets, {.Size <= 280})
-  ```
 
 ### Performance
 * **Optimized for Speed**: Expr stands out in its performance, utilizing an optimizing compiler and a bytecode virtual machine. Check out these [benchmarks](https://github.com/antonmedv/golang-expression-evaluation-comparison#readme) for more details.

From 10694bade7b71c18c0c9daf6bd249081491765d2 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 23:05:53 +0200
Subject: [PATCH 057/506] Add func names in disassemble

---
 compiler/compiler.go |  3 +++
 vm/program.go        | 12 ++++++++----
 vm/program_test.go   |  1 +
 3 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 0679edcc7..2b3bfa70f 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -54,6 +54,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		Bytecode:  c.bytecode,
 		Arguments: c.arguments,
 		Functions: c.functions,
+		FuncNames: c.functionNames,
 	}
 	return
 }
@@ -64,6 +65,7 @@ type compiler struct {
 	constants      []interface{}
 	constantsIndex map[interface{}]int
 	functions      []Function
+	functionNames  []string
 	functionsIndex map[string]int
 	mapEnv         bool
 	cast           reflect.Kind
@@ -154,6 +156,7 @@ func (c *compiler) addFunction(fn *builtin.Function) int {
 	}
 	p := len(c.functions)
 	c.functions = append(c.functions, fn.Func)
+	c.functionNames = append(c.functionNames, fn.Name)
 	c.functionsIndex[fn.Name] = p
 	return p
 }
diff --git a/vm/program.go b/vm/program.go
index 24747df90..ea954cc7c 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -23,6 +23,7 @@ type Program struct {
 	Bytecode  []Opcode
 	Arguments []int
 	Functions []Function
+	FuncNames []string
 }
 
 func (program *Program) Disassemble() string {
@@ -74,6 +75,9 @@ func (program *Program) Opcodes(w io.Writer) {
 		builtin := func(label string) {
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, builtin.Functions[arg].Name)
 		}
+		funcName := func(label string) {
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v()\n", pp, label, arg, program.FuncNames[arg])
+		}
 
 		switch op {
 		case OpInvalid:
@@ -218,16 +222,16 @@ func (program *Program) Opcodes(w io.Writer) {
 			argument("OpCall")
 
 		case OpCall0:
-			argument("OpCall0")
+			funcName("OpCall0")
 
 		case OpCall1:
-			argument("OpCall1")
+			funcName("OpCall1")
 
 		case OpCall2:
-			argument("OpCall2")
+			funcName("OpCall2")
 
 		case OpCall3:
-			argument("OpCall3")
+			funcName("OpCall3")
 
 		case OpCallN:
 			argument("OpCallN")
diff --git a/vm/program_test.go b/vm/program_test.go
index 06e83b18c..c1cdf4f4c 100644
--- a/vm/program_test.go
+++ b/vm/program_test.go
@@ -13,6 +13,7 @@ func TestProgram_Disassemble(t *testing.T) {
 			Constants: []interface{}{1, 2},
 			Bytecode:  []vm.Opcode{op},
 			Arguments: []int{1},
+			FuncNames: []string{"foo", "bar"},
 		}
 		d := program.Disassemble()
 		if strings.Contains(d, "(unknown)") {

From 4810a4735ac20476292226266c8d3abd75aa662b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 15 Aug 2023 23:34:16 +0200
Subject: [PATCH 058/506] Rename env to $env

---
 builtin/builtin_test.go |  6 +++---
 checker/checker.go      |  6 +++---
 checker/checker_test.go |  6 +++---
 compiler/compiler.go    |  2 +-
 conf/types_table.go     |  4 ++--
 expr_test.go            | 36 ++++++++++++++++++------------------
 6 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 94a146b8a..4c8f61fbb 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -153,9 +153,9 @@ func TestBuiltin_types(t *testing.T) {
 		{`first(ArrayOfInt)`, reflect.Int},
 		{`last(ArrayOfString)`, reflect.String},
 		{`last(ArrayOfInt)`, reflect.Int},
-		{`get(env, 'str')`, reflect.String},
-		{`get(env, 'num')`, reflect.Int},
-		{`get(env, 'ArrayOfString')`, reflect.Slice},
+		{`get($env, 'str')`, reflect.String},
+		{`get($env, 'num')`, reflect.Int},
+		{`get($env, 'ArrayOfString')`, reflect.Slice},
 	}
 
 	for _, test := range tests {
diff --git a/checker/checker.go b/checker/checker.go
index 973786bd1..f4d84d078 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -135,7 +135,7 @@ func (v *visitor) NilNode(*ast.NilNode) (reflect.Type, info) {
 }
 
 func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info) {
-	if node.Value == "env" {
+	if node.Value == "$env" {
 		return mapType, info{}
 	}
 	if fn, ok := v.config.Functions[node.Value]; ok {
@@ -399,7 +399,7 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 	base, _ := v.visit(node.Node)
 	prop, _ := v.visit(node.Property)
 
-	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "env" {
+	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "$env" {
 		// If the index is a constant string, can save some
 		// cycles later by finding the type of its referent
 		if name, ok := node.Property.(*ast.StringNode); ok {
@@ -660,7 +660,7 @@ func (v *visitor) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
 
 	val := node.Arguments[0]
 	prop := node.Arguments[1]
-	if id, ok := val.(*ast.IdentifierNode); ok && id.Value == "env" {
+	if id, ok := val.(*ast.IdentifierNode); ok && id.Value == "$env" {
 		if s, ok := prop.(*ast.StringNode); ok {
 			return v.config.Types[s.Value].Type, info{}
 		}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 127c7dd57..56bc7546a 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -946,9 +946,9 @@ func TestCheck_env_keyword(t *testing.T) {
 		input string
 		want  reflect.Kind
 	}{
-		{`env['str']`, reflect.String},
-		{`env['num']`, reflect.Int},
-		{`env[name]`, reflect.Interface},
+		{`$env['str']`, reflect.String},
+		{`$env['num']`, reflect.Int},
+		{`$env[name]`, reflect.Interface},
 	}
 
 	for _, test := range tests {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 2b3bfa70f..d32ba55e4 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -227,7 +227,7 @@ func (c *compiler) NilNode(_ *ast.NilNode) {
 }
 
 func (c *compiler) IdentifierNode(node *ast.IdentifierNode) {
-	if node.Value == "env" {
+	if node.Value == "$env" {
 		c.emit(OpLoadEnv)
 		return
 	}
diff --git a/conf/types_table.go b/conf/types_table.go
index f4d401c9c..7d486480c 100644
--- a/conf/types_table.go
+++ b/conf/types_table.go
@@ -54,7 +54,7 @@ func CreateTypesTable(i interface{}) TypesTable {
 		for _, key := range v.MapKeys() {
 			value := v.MapIndex(key)
 			if key.Kind() == reflect.String && value.IsValid() && value.CanInterface() {
-				if key.String() == "env" { // Could check for all keywords here
+				if key.String() == "$env" { // Could check for all keywords here
 					panic("attempt to misuse env keyword as env map key")
 				}
 				types[key.String()] = Tag{Type: reflect.TypeOf(value.Interface())}
@@ -97,7 +97,7 @@ func FieldsFromStruct(t reflect.Type) TypesTable {
 					}
 				}
 			}
-			if fn := FieldName(f); fn == "env" { // Could check for all keywords here
+			if fn := FieldName(f); fn == "$env" { // Could check for all keywords here
 				panic("attempt to misuse env keyword as env struct field tag")
 			} else {
 				types[FieldName(f)] = Tag{
diff --git a/expr_test.go b/expr_test.go
index 7a7aea97c..31de39c71 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1688,24 +1688,24 @@ func TestEnv_keyword(t *testing.T) {
 		code string
 		want interface{}
 	}{
-		{"env['space test']", "ok"},
-		{"env['Section 1-2a']", "ok"},
-		{`env["c:\\ndrive\\2015 Information Table"]`, "ok"},
-		{"env['%*worst function name ever!!']", "ok"},
-		{"env['String Map'].one", "two"},
-		{"env['1'] + env['2']", "ok"},
-		{"1 + env['num'] + env['num']", 21},
-		{"MIN(env['num'],0)", 0},
-		{"env['nu' + 'm']", 10},
-		{"env[red + irect]", 10},
-		{"env['String Map']?.five", ""},
-		{"env.red", "n"},
-		{"env?.blue", nil},
-		{"env.mylist[1]", 2},
-		{"env?.OtherMap?.a", "b"},
-		{"env?.OtherMap?.d", ""},
-		{"'num' in env", true},
-		{"get(env, 'num')", 10},
+		{"$env['space test']", "ok"},
+		{"$env['Section 1-2a']", "ok"},
+		{`$env["c:\\ndrive\\2015 Information Table"]`, "ok"},
+		{"$env['%*worst function name ever!!']", "ok"},
+		{"$env['String Map'].one", "two"},
+		{"$env['1'] + $env['2']", "ok"},
+		{"1 + $env['num'] + $env['num']", 21},
+		{"MIN($env['num'],0)", 0},
+		{"$env['nu' + 'm']", 10},
+		{"$env[red + irect]", 10},
+		{"$env['String Map']?.five", ""},
+		{"$env.red", "n"},
+		{"$env?.blue", nil},
+		{"$env.mylist[1]", 2},
+		{"$env?.OtherMap?.a", "b"},
+		{"$env?.OtherMap?.d", ""},
+		{"'num' in $env", true},
+		{"get($env, 'num')", 10},
 	}
 
 	for _, tt := range tests {

From aa3560bd7d08aaf70f9d33e70f0c8c0697d20115 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 16 Aug 2023 11:29:09 +0200
Subject: [PATCH 059/506] Fix slice out of bound errors

---
 expr_test.go          | 20 ++++++++++++++++++++
 vm/runtime/runtime.go |  6 ++++++
 2 files changed, 26 insertions(+)

diff --git a/expr_test.go b/expr_test.go
index 31de39c71..7ea3700d0 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1761,3 +1761,23 @@ func TestIssue401(t *testing.T) {
 	require.NoError(t, err, "run error")
 	require.Equal(t, 0.5, output)
 }
+
+func TestEval_slices_out_of_bound(t *testing.T) {
+	tests := []struct {
+		code string
+		want interface{}
+	}{
+		{"[1, 2, 3][:99]", []interface{}{1, 2, 3}},
+		{"[1, 2, 3][99:]", []interface{}{}},
+		{"[1, 2, 3][:-99]", []interface{}{}},
+		{"[1, 2, 3][-99:]", []interface{}{1, 2, 3}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			got, err := expr.Eval(tt.code, nil)
+			require.NoError(t, err, "eval error: "+tt.code)
+			assert.Equal(t, tt.want, got, "eval: "+tt.code)
+		})
+	}
+}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 97f61843f..3960b073c 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -183,9 +183,15 @@ func Slice(array, from, to interface{}) interface{} {
 		if a < 0 {
 			a = length + a
 		}
+		if a < 0 {
+			a = 0
+		}
 		if b < 0 {
 			b = length + b
 		}
+		if b < 0 {
+			b = 0
+		}
 		if b > length {
 			b = length
 		}

From beb738ba38d47bce3dfa13332b64342d61221bd1 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 16 Aug 2023 11:30:50 +0200
Subject: [PATCH 060/506] Update Language-Definition.md

---
 docs/Language-Definition.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 7a7ba6f7d..312946425 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -515,10 +515,10 @@ Braces `{` `}` can be omitted:
 filter(Tweets, len(.Value) > 280)
 ```
 
-## `env` variable
+## `$env` variable
 
-The `env` variable is a map of all variables passed to the expression.
+The `$env` variable is a map of all variables passed to the expression.
 
 ```expr
-Foo.Name == env['Foo'].Name
+Foo.Name == $env["Foo"].Name
 ```

From 8f2cfbf673cdec4322f88126ed3ac8ece98bf921 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 16 Aug 2023 11:40:49 +0200
Subject: [PATCH 061/506] Add demo

---
 .github/images/demo.tape |  83 +++++++++++++++++++++++++++++++++++++++
 .github/images/out.gif   | Bin 0 -> 1087311 bytes
 2 files changed, 83 insertions(+)
 create mode 100644 .github/images/demo.tape
 create mode 100644 .github/images/out.gif

diff --git a/.github/images/demo.tape b/.github/images/demo.tape
new file mode 100644
index 000000000..e7e2f15c3
--- /dev/null
+++ b/.github/images/demo.tape
@@ -0,0 +1,83 @@
+Set Shell zsh
+Sleep 500ms
+Type "repl"
+Enter
+Sleep 500ms
+Type "1..9 | filter("
+Sleep 500ms
+Type "# "
+Sleep 500ms
+Type "% 2 == 0) | map("
+Sleep 500ms
+Type "# ^ 2"
+Sleep 500ms
+Type ")"
+Enter
+Sleep 1s
+Type "de"
+Sleep 500ms
+Type "bug"
+Enter
+Sleep 1.5s
+Enter 50
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Enter
+Sleep 1.5s
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Escape
+Type "OB"
+Enter
+Sleep 2s
+Escape
+Type "OB"
+Escape
+Type "OB"
+Ctrl+C
+Sleep 1s
+Ctrl+D
+Ctrl+D
+
diff --git a/.github/images/out.gif b/.github/images/out.gif
new file mode 100644
index 0000000000000000000000000000000000000000..501706bb550ab2c80eba18301e929fd7cfc4de64
GIT binary patch
literal 1087311
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%0AK+`sUS1{s~XF}QA<fx
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%0AccL95w-LddOfPjZo7hW}lL8G2E`)AFbj&to
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%0Dj6299?)T#W{#N`e}AEcv=oWY
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%0DN?lJf>uQuJj;<s
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%0DVk`56$!VPU!?nn}@V+@w|#tWV%>
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
JJG5{a{x7GLc-#O0

literal 0
HcmV?d00001


From 47eae7e6e89768c43449376cca0503e672d4a30d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 12:50:04 +0200
Subject: [PATCH 062/506] Add pipe docs

---
 docs/Language-Definition.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 312946425..d99f55cd3 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -110,6 +110,12 @@
             <code>[:]</code>
         </td>
     </tr>
+    <tr>
+        <td>Pipe</td>
+        <td>
+            <code>|</code>
+        </td>
+    </tr>
 </table>
 
 Examples:
@@ -168,6 +174,17 @@ array[3:] == [4, 5]
 array[:] == array
 ```
 
+### Pipe Operator
+
+The pipe operator `|` can be used to pass the result of the left-hand side
+expression as the first argument of the right-hand side expression.
+
+For example, expression `split(lower(user.Name), " ")` can be written as:
+
+```expr
+user.Name | lower() | split(" ")
+```
+
 ## Built-in Functions
 
 ### all(array, predicate)

From 879a428e42546c3bb3bd3abfa309c5d333a157a4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 17:22:22 +0200
Subject: [PATCH 063/506] Update prompt

---
 repl/repl.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/repl/repl.go b/repl/repl.go
index 78ba1bd66..c249af0d9 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -26,7 +26,7 @@ var keywords = []string{
 
 func main() {
 	rl, err := readline.NewEx(&readline.Config{
-		Prompt:       "> ",
+		Prompt:       "❯ ",
 		AutoComplete: completer{append(builtin.Names, keywords...)},
 	})
 	if err != nil {

From 189e576d9b2d677e4e9e0e3a30f32f00b236eee5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 17:10:28 +0200
Subject: [PATCH 064/506] Add String() to nodes

---
 ast/dump.go                 |  59 ++++++++++++
 ast/node.go                 |   1 +
 ast/print.go                | 185 ++++++++++++++++++++++++++++--------
 ast/print_test.go           | 112 ++++++++++++++++++++++
 parser/lexer/state.go       |  12 ++-
 parser/lexer/utils.go       |  13 ---
 parser/operator/operator.go |  52 ++++++++++
 parser/parser.go            |  82 ++--------------
 parser/utils/utils.go       |  34 +++++++
 9 files changed, 419 insertions(+), 131 deletions(-)
 create mode 100644 ast/dump.go
 create mode 100644 ast/print_test.go
 create mode 100644 parser/operator/operator.go
 create mode 100644 parser/utils/utils.go

diff --git a/ast/dump.go b/ast/dump.go
new file mode 100644
index 000000000..56bc7dbe2
--- /dev/null
+++ b/ast/dump.go
@@ -0,0 +1,59 @@
+package ast
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+)
+
+func Dump(node Node) string {
+	return dump(reflect.ValueOf(node), "")
+}
+
+func dump(v reflect.Value, ident string) string {
+	if !v.IsValid() {
+		return "nil"
+	}
+	t := v.Type()
+	switch t.Kind() {
+	case reflect.Struct:
+		out := t.Name() + "{\n"
+		for i := 0; i < t.NumField(); i++ {
+			f := t.Field(i)
+			if isPrivate(f.Name) {
+				continue
+			}
+			s := v.Field(i)
+			out += fmt.Sprintf("%v%v: %v,\n", ident+"\t", f.Name, dump(s, ident+"\t"))
+		}
+		return out + ident + "}"
+	case reflect.Slice:
+		if v.Len() == 0 {
+			return t.String() + "{}"
+		}
+		out := t.String() + "{\n"
+		for i := 0; i < v.Len(); i++ {
+			s := v.Index(i)
+			out += fmt.Sprintf("%v%v,", ident+"\t", dump(s, ident+"\t"))
+			if i+1 < v.Len() {
+				out += "\n"
+			}
+		}
+		return out + "\n" + ident + "}"
+	case reflect.Ptr:
+		return dump(v.Elem(), ident)
+	case reflect.Interface:
+		return dump(reflect.ValueOf(v.Interface()), ident)
+
+	case reflect.String:
+		return fmt.Sprintf("%q", v)
+	default:
+		return fmt.Sprintf("%v", v)
+	}
+}
+
+var isCapital = regexp.MustCompile("^[A-Z]")
+
+func isPrivate(s string) bool {
+	return !isCapital.Match([]byte(s))
+}
diff --git a/ast/node.go b/ast/node.go
index 5bdcb75ed..ba6545871 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -14,6 +14,7 @@ type Node interface {
 	SetLocation(file.Location)
 	Type() reflect.Type
 	SetType(reflect.Type)
+	String() string
 }
 
 func Patch(node *Node, newNode Node) {
diff --git a/ast/print.go b/ast/print.go
index 56bc7dbe2..e95e88796 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -1,59 +1,162 @@
 package ast
 
 import (
+	"encoding/json"
 	"fmt"
-	"reflect"
-	"regexp"
+	"strings"
+
+	"github.com/antonmedv/expr/parser/operator"
+	"github.com/antonmedv/expr/parser/utils"
 )
 
-func Dump(node Node) string {
-	return dump(reflect.ValueOf(node), "")
+func (n *NilNode) String() string {
+	return "nil"
+}
+
+func (n *IdentifierNode) String() string {
+	return n.Value
+}
+
+func (n *IntegerNode) String() string {
+	return fmt.Sprintf("%d", n.Value)
+}
+
+func (n *FloatNode) String() string {
+	return fmt.Sprintf("%v", n.Value)
+}
+
+func (n *BoolNode) String() string {
+	return fmt.Sprintf("%t", n.Value)
 }
 
-func dump(v reflect.Value, ident string) string {
-	if !v.IsValid() {
+func (n *StringNode) String() string {
+	return fmt.Sprintf("%q", n.Value)
+}
+
+func (n *ConstantNode) String() string {
+	if n.Value == nil {
 		return "nil"
 	}
-	t := v.Type()
-	switch t.Kind() {
-	case reflect.Struct:
-		out := t.Name() + "{\n"
-		for i := 0; i < t.NumField(); i++ {
-			f := t.Field(i)
-			if isPrivate(f.Name) {
-				continue
-			}
-			s := v.Field(i)
-			out += fmt.Sprintf("%v%v: %v,\n", ident+"\t", f.Name, dump(s, ident+"\t"))
-		}
-		return out + ident + "}"
-	case reflect.Slice:
-		if v.Len() == 0 {
-			return t.String() + "{}"
+	b, err := json.Marshal(n.Value)
+	if err != nil {
+		panic(err)
+	}
+	return string(b)
+}
+
+func (n *UnaryNode) String() string {
+	op := ""
+	if n.Operator == "not" {
+		op = fmt.Sprintf("%s ", n.Operator)
+	} else {
+		op = fmt.Sprintf("%s", n.Operator)
+	}
+	if _, ok := n.Node.(*BinaryNode); ok {
+		return fmt.Sprintf("%s(%s)", op, n.Node.String())
+	}
+	return fmt.Sprintf("%s%s", op, n.Node.String())
+}
+
+func (n *BinaryNode) String() string {
+	var left, right string
+	if b, ok := n.Left.(*BinaryNode); ok && operator.Less(b.Operator, n.Operator) {
+		left = fmt.Sprintf("(%s)", n.Left.String())
+	} else {
+		left = n.Left.String()
+	}
+	if b, ok := n.Right.(*BinaryNode); ok && operator.Less(b.Operator, n.Operator) {
+		right = fmt.Sprintf("(%s)", n.Right.String())
+	} else {
+		right = n.Right.String()
+	}
+	return fmt.Sprintf("%s %s %s", left, n.Operator, right)
+}
+
+func (n *ChainNode) String() string {
+	return n.Node.String()
+}
+
+func (n *MemberNode) String() string {
+	if n.Optional {
+		if str, ok := n.Property.(*StringNode); ok && utils.IsValidIdentifier(str.Value) {
+			return fmt.Sprintf("%s?.%s", n.Node.String(), str.Value)
+		} else {
+			return fmt.Sprintf("get(%s, %s)", n.Node.String(), n.Property.String())
 		}
-		out := t.String() + "{\n"
-		for i := 0; i < v.Len(); i++ {
-			s := v.Index(i)
-			out += fmt.Sprintf("%v%v,", ident+"\t", dump(s, ident+"\t"))
-			if i+1 < v.Len() {
-				out += "\n"
-			}
+	}
+	if str, ok := n.Property.(*StringNode); ok && utils.IsValidIdentifier(str.Value) {
+		if _, ok := n.Node.(*PointerNode); ok {
+			return fmt.Sprintf(".%s", str.Value)
 		}
-		return out + "\n" + ident + "}"
-	case reflect.Ptr:
-		return dump(v.Elem(), ident)
-	case reflect.Interface:
-		return dump(reflect.ValueOf(v.Interface()), ident)
+		return fmt.Sprintf("%s.%s", n.Node.String(), str.Value)
+	}
+	return fmt.Sprintf("%s[%s]", n.Node.String(), n.Property.String())
+}
+
+func (n *SliceNode) String() string {
+	return fmt.Sprintf("%s[%s:%s]", n.Node.String(), n.From.String(), n.To.String())
+}
 
-	case reflect.String:
-		return fmt.Sprintf("%q", v)
-	default:
-		return fmt.Sprintf("%v", v)
+func (n *CallNode) String() string {
+	arguments := make([]string, len(n.Arguments))
+	for i, arg := range n.Arguments {
+		arguments[i] = arg.String()
 	}
+	return fmt.Sprintf("%s(%s)", n.Callee.String(), strings.Join(arguments, ", "))
 }
 
-var isCapital = regexp.MustCompile("^[A-Z]")
+func (n *BuiltinNode) String() string {
+	arguments := make([]string, len(n.Arguments))
+	for i, arg := range n.Arguments {
+		arguments[i] = arg.String()
+	}
+	return fmt.Sprintf("%s(%s)", n.Name, strings.Join(arguments, ", "))
+}
+
+func (n *ClosureNode) String() string {
+	return n.Node.String()
+}
+
+func (n *PointerNode) String() string {
+	return "#"
+}
+
+func (n *ConditionalNode) String() string {
+	var cond, exp1, exp2 string
+	if _, ok := n.Cond.(*ConditionalNode); ok {
+		cond = fmt.Sprintf("(%s)", n.Cond.String())
+	} else {
+		cond = n.Cond.String()
+	}
+	if _, ok := n.Exp1.(*ConditionalNode); ok {
+		exp1 = fmt.Sprintf("(%s)", n.Exp1.String())
+	} else {
+		exp1 = n.Exp1.String()
+	}
+	if _, ok := n.Exp2.(*ConditionalNode); ok {
+		exp2 = fmt.Sprintf("(%s)", n.Exp2.String())
+	} else {
+		exp2 = n.Exp2.String()
+	}
+	return fmt.Sprintf("%s ? %s : %s", cond, exp1, exp2)
+}
+
+func (n *ArrayNode) String() string {
+	nodes := make([]string, len(n.Nodes))
+	for i, node := range n.Nodes {
+		nodes[i] = node.String()
+	}
+	return fmt.Sprintf("[%s]", strings.Join(nodes, ", "))
+}
+
+func (n *MapNode) String() string {
+	pairs := make([]string, len(n.Pairs))
+	for i, pair := range n.Pairs {
+		pairs[i] = pair.String()
+	}
+	return fmt.Sprintf("{%s}", strings.Join(pairs, ", "))
+}
 
-func isPrivate(s string) bool {
-	return !isCapital.Match([]byte(s))
+func (n *PairNode) String() string {
+	return fmt.Sprintf("%s: %s", n.Key.String(), n.Value.String())
 }
diff --git a/ast/print_test.go b/ast/print_test.go
new file mode 100644
index 000000000..9517a0820
--- /dev/null
+++ b/ast/print_test.go
@@ -0,0 +1,112 @@
+package ast_test
+
+import (
+	"testing"
+
+	"github.com/antonmedv/expr/ast"
+	"github.com/antonmedv/expr/parser"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPrint(t *testing.T) {
+	tests := []struct {
+		input string
+		want  string
+	}{
+		{`nil`, `nil`},
+		{`true`, `true`},
+		{`false`, `false`},
+		{`1`, `1`},
+		{`1.1`, `1.1`},
+		{`"a"`, `"a"`},
+		{`'a'`, `"a"`},
+		{`a`, `a`},
+		{`a.b`, `a.b`},
+		{`a[0]`, `a[0]`},
+		{`a["the b"]`, `a["the b"]`},
+		{`a.b[0]`, `a.b[0]`},
+		{`a?.b`, `a?.b`},
+		{`-a`, `-a`},
+		{`!a`, `!a`},
+		{`not a`, `not a`},
+		{`a + b`, `a + b`},
+		{`a + b * c`, `a + b * c`},
+		{`(a + b) * c`, `(a + b) * c`},
+		{`a * (b + c)`, `a * (b + c)`},
+		{`-(a + b) * c`, `-(a + b) * c`},
+		{`a == b`, `a == b`},
+		{`a matches b`, `a matches b`},
+		{`a in b`, `a in b`},
+		{`a not in b`, `not (a in b)`},
+		{`a and b`, `a and b`},
+		{`a or b`, `a or b`},
+		{`a or b and c`, `a or b and c`},
+		{`a or (b and c)`, `a or b and c`},
+		{`(a or b) and c`, `(a or b) and c`},
+		{`a ? b : c`, `a ? b : c`},
+		{`a ? b : c ? d : e`, `a ? b : (c ? d : e)`},
+		{`(a ? b : c) ? d : e`, `(a ? b : c) ? d : e`},
+		{`a ? (b ? c : d) : e`, `a ? (b ? c : d) : e`},
+		{`func()`, `func()`},
+		{`func(a)`, `func(a)`},
+		{`func(a, b)`, `func(a, b)`},
+		{`{}`, `{}`},
+		{`{a: b}`, `{"a": b}`},
+		{`{a: b, c: d}`, `{"a": b, "c": d}`},
+		{`[]`, `[]`},
+		{`[a]`, `[a]`},
+		{`[a, b]`, `[a, b]`},
+		{`len(a)`, `len(a)`},
+		{`map(a, # > 0)`, `map(a, # > 0)`},
+		{`map(a, {# > 0})`, `map(a, # > 0)`},
+		{`map(a, .b)`, `map(a, .b)`},
+		{`a.b()`, `a.b()`},
+		{`a.b(c)`, `a.b(c)`},
+		{`a[1:-1]`, `a[1:-1]`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			tree, err := parser.Parse(tt.input)
+			require.NoError(t, err)
+
+			require.Equal(t, tt.want, tree.Node.String())
+		})
+	}
+}
+
+func TestPrint_MemberNode(t *testing.T) {
+	node := &ast.MemberNode{
+		Node: &ast.IdentifierNode{
+			Value: "a",
+		},
+		Property: &ast.StringNode{Value: "b c"},
+		Optional: true,
+	}
+	require.Equal(t, `get(a, "b c")`, node.String())
+}
+
+func TestPrint_ConstantNode(t *testing.T) {
+	tests := []struct {
+		input interface{}
+		want  string
+	}{
+		{nil, `nil`},
+		{true, `true`},
+		{false, `false`},
+		{1, `1`},
+		{1.1, `1.1`},
+		{"a", `"a"`},
+		{[]int{1, 2, 3}, `[1,2,3]`},
+		{map[string]int{"a": 1}, `{"a":1}`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.want, func(t *testing.T) {
+			node := &ast.ConstantNode{
+				Value: tt.input,
+			}
+			require.Equal(t, tt.want, node.String())
+		})
+	}
+}
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index 5b4b5839e..c8f0d1725 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -2,6 +2,8 @@ package lexer
 
 import (
 	"strings"
+
+	"github.com/antonmedv/expr/parser/utils"
 )
 
 type stateFn func(*lexer) stateFn
@@ -11,7 +13,7 @@ func root(l *lexer) stateFn {
 	case r == eof:
 		l.emitEOF()
 		return nil
-	case IsSpace(r):
+	case utils.IsSpace(r):
 		l.ignore()
 		return root
 	case r == '\'' || r == '"':
@@ -43,7 +45,7 @@ func root(l *lexer) stateFn {
 	case r == '.':
 		l.backup()
 		return dot
-	case IsAlphaNumeric(r):
+	case utils.IsAlphaNumeric(r):
 		l.backup()
 		return identifier
 	default:
@@ -91,7 +93,7 @@ func (l *lexer) scanNumber() bool {
 		l.acceptRun(digits)
 	}
 	// Next thing mustn't be alphanumeric.
-	if IsAlphaNumeric(l.peek()) {
+	if utils.IsAlphaNumeric(l.peek()) {
 		l.next()
 		return false
 	}
@@ -113,7 +115,7 @@ func identifier(l *lexer) stateFn {
 loop:
 	for {
 		switch r := l.next(); {
-		case IsAlphaNumeric(r):
+		case utils.IsAlphaNumeric(r):
 			// absorb
 		default:
 			l.backup()
@@ -141,7 +143,7 @@ func not(l *lexer) stateFn {
 	// Get the next word.
 	for {
 		r := l.next()
-		if IsAlphaNumeric(r) {
+		if utils.IsAlphaNumeric(r) {
 			// absorb
 		} else {
 			l.backup()
diff --git a/parser/lexer/utils.go b/parser/lexer/utils.go
index a0ea87e28..83d96f49c 100644
--- a/parser/lexer/utils.go
+++ b/parser/lexer/utils.go
@@ -3,22 +3,9 @@ package lexer
 import (
 	"fmt"
 	"strings"
-	"unicode"
 	"unicode/utf8"
 )
 
-func IsSpace(r rune) bool {
-	return unicode.IsSpace(r)
-}
-
-func IsAlphaNumeric(r rune) bool {
-	return IsAlphabetic(r) || unicode.IsDigit(r)
-}
-
-func IsAlphabetic(r rune) bool {
-	return r == '_' || r == '$' || unicode.IsLetter(r)
-}
-
 var (
 	newlineNormalizer = strings.NewReplacer("\r\n", "\n", "\r", "\n")
 )
diff --git a/parser/operator/operator.go b/parser/operator/operator.go
new file mode 100644
index 000000000..455c06f17
--- /dev/null
+++ b/parser/operator/operator.go
@@ -0,0 +1,52 @@
+package operator
+
+type Associativity int
+
+const (
+	Left Associativity = iota + 1
+	Right
+)
+
+type Operator struct {
+	Precedence    int
+	Associativity Associativity
+}
+
+func Less(a, b string) bool {
+	return Binary[a].Precedence < Binary[b].Precedence
+}
+
+var Unary = map[string]Operator{
+	"not": {50, Left},
+	"!":   {50, Left},
+	"-":   {90, Left},
+	"+":   {90, Left},
+}
+
+var Binary = map[string]Operator{
+	"|":          {0, Left},
+	"or":         {10, Left},
+	"||":         {10, Left},
+	"and":        {15, Left},
+	"&&":         {15, Left},
+	"==":         {20, Left},
+	"!=":         {20, Left},
+	"<":          {20, Left},
+	">":          {20, Left},
+	">=":         {20, Left},
+	"<=":         {20, Left},
+	"in":         {20, Left},
+	"matches":    {20, Left},
+	"contains":   {20, Left},
+	"startsWith": {20, Left},
+	"endsWith":   {20, Left},
+	"..":         {25, Left},
+	"+":          {30, Left},
+	"-":          {30, Left},
+	"*":          {60, Left},
+	"/":          {60, Left},
+	"%":          {60, Left},
+	"**":         {100, Right},
+	"^":          {100, Right},
+	"??":         {500, Left},
+}
diff --git a/parser/parser.go b/parser/parser.go
index 3288662b5..b1de4c9c0 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -4,61 +4,15 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
-	"unicode/utf8"
 
 	. "github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/file"
 	. "github.com/antonmedv/expr/parser/lexer"
+	"github.com/antonmedv/expr/parser/operator"
+	"github.com/antonmedv/expr/parser/utils"
 )
 
-type associativity int
-
-const (
-	left associativity = iota + 1
-	right
-)
-
-type operator struct {
-	precedence    int
-	associativity associativity
-}
-
-var unaryOperators = map[string]operator{
-	"not": {50, left},
-	"!":   {50, left},
-	"-":   {90, left},
-	"+":   {90, left},
-}
-
-var binaryOperators = map[string]operator{
-	"|":          {0, left},
-	"or":         {10, left},
-	"||":         {10, left},
-	"and":        {15, left},
-	"&&":         {15, left},
-	"==":         {20, left},
-	"!=":         {20, left},
-	"<":          {20, left},
-	">":          {20, left},
-	">=":         {20, left},
-	"<=":         {20, left},
-	"in":         {20, left},
-	"matches":    {20, left},
-	"contains":   {20, left},
-	"startsWith": {20, left},
-	"endsWith":   {20, left},
-	"..":         {25, left},
-	"+":          {30, left},
-	"-":          {30, left},
-	"*":          {60, left},
-	"/":          {60, left},
-	"%":          {60, left},
-	"**":         {100, right},
-	"^":          {100, right},
-	"??":         {500, left},
-}
-
 var predicates = map[string]struct {
 	arity int
 }{
@@ -172,8 +126,8 @@ func (p *parser) parseExpression(precedence int) Node {
 			opToken = p.current
 		}
 
-		if op, ok := binaryOperators[opToken.Value]; ok {
-			if op.precedence >= precedence {
+		if op, ok := operator.Binary[opToken.Value]; ok {
+			if op.Precedence >= precedence {
 				p.next()
 
 				if opToken.Value == "|" {
@@ -187,10 +141,10 @@ func (p *parser) parseExpression(precedence int) Node {
 				}
 
 				var nodeRight Node
-				if op.associativity == left {
-					nodeRight = p.parseExpression(op.precedence + 1)
+				if op.Associativity == operator.Left {
+					nodeRight = p.parseExpression(op.Precedence + 1)
 				} else {
-					nodeRight = p.parseExpression(op.precedence)
+					nodeRight = p.parseExpression(op.Precedence)
 				}
 
 				nodeLeft = &BinaryNode{
@@ -253,9 +207,9 @@ func (p *parser) parsePrimary() Node {
 	token := p.current
 
 	if token.Is(Operator) {
-		if op, ok := unaryOperators[token.Value]; ok {
+		if op, ok := operator.Unary[token.Value]; ok {
 			p.next()
-			expr := p.parseExpression(op.precedence)
+			expr := p.parseExpression(op.Precedence)
 			node := &UnaryNode{
 				Operator: token.Value,
 				Node:     expr,
@@ -510,7 +464,7 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 
 			if propertyToken.Kind != Identifier &&
 				// Operators like "not" and "matches" are valid methods or property names.
-				(propertyToken.Kind != Operator || !isValidIdentifier(propertyToken.Value)) {
+				(propertyToken.Kind != Operator || !utils.IsValidIdentifier(propertyToken.Value)) {
 				p.error("expected name")
 			}
 
@@ -662,19 +616,3 @@ func (p *parser) parseArguments() []Node {
 
 	return nodes
 }
-
-func isValidIdentifier(str string) bool {
-	if len(str) == 0 {
-		return false
-	}
-	h, w := utf8.DecodeRuneInString(str)
-	if !IsAlphabetic(h) {
-		return false
-	}
-	for _, r := range str[w:] {
-		if !IsAlphaNumeric(r) {
-			return false
-		}
-	}
-	return true
-}
diff --git a/parser/utils/utils.go b/parser/utils/utils.go
new file mode 100644
index 000000000..947f9a400
--- /dev/null
+++ b/parser/utils/utils.go
@@ -0,0 +1,34 @@
+package utils
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+func IsValidIdentifier(str string) bool {
+	if len(str) == 0 {
+		return false
+	}
+	h, w := utf8.DecodeRuneInString(str)
+	if !IsAlphabetic(h) {
+		return false
+	}
+	for _, r := range str[w:] {
+		if !IsAlphaNumeric(r) {
+			return false
+		}
+	}
+	return true
+}
+
+func IsSpace(r rune) bool {
+	return unicode.IsSpace(r)
+}
+
+func IsAlphaNumeric(r rune) bool {
+	return IsAlphabetic(r) || unicode.IsDigit(r)
+}
+
+func IsAlphabetic(r rune) bool {
+	return r == '_' || r == '$' || unicode.IsLetter(r)
+}

From cb6c8ca40f4c31b5c4131ec832bff70be2294134 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 18:00:31 +0200
Subject: [PATCH 065/506] Return correct type for builtin functions

---
 checker/checker.go      |  5 +----
 checker/checker_test.go | 21 +++++++++++++++++++++
 2 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index f4d84d078..89c0d4d84 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -139,10 +139,7 @@ func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 		return mapType, info{}
 	}
 	if fn, ok := v.config.Functions[node.Value]; ok {
-		// Return anyType instead of func type as we don't know the arguments yet.
-		// The func type can be one of the fn.Types. The type will be resolved
-		// when the arguments are known in CallNode.
-		return anyType, info{fn: fn}
+		return functionType, info{fn: fn}
 	}
 	if t, ok := v.config.Types[node.Value]; ok {
 		if t.Ambiguous {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 56bc7546a..dbd13765f 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -962,3 +962,24 @@ func TestCheck_env_keyword(t *testing.T) {
 		})
 	}
 }
+
+func TestCheck_builtin_without_call(t *testing.T) {
+	tests := []struct {
+		input string
+		err   string
+	}{
+		{`len + 1`, "invalid operation: + (mismatched types func(...interface {}) (interface {}, error) and int) (1:5)\n | len + 1\n | ....^"},
+		{`string.A`, "type func(...interface {}) (interface {}, error)[string] is undefined (1:8)\n | string.A\n | .......^"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			tree, err := parser.Parse(test.input)
+			require.NoError(t, err)
+
+			_, err = checker.Check(tree, conf.New(nil))
+			require.Error(t, err)
+			require.Equal(t, test.err, err.Error())
+		})
+	}
+}

From 931dbf3ecd990b36ec980b97df4a522d65b1c021 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 21:05:34 +0200
Subject: [PATCH 066/506] Fix date test

---
 test/time/time_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/time/time_test.go b/test/time/time_test.go
index eb8d478dc..4b659367c 100644
--- a/test/time/time_test.go
+++ b/test/time/time_test.go
@@ -104,9 +104,9 @@ func TestTime(t *testing.T) {
 
 func TestTime_duration(t *testing.T) {
 	env := map[string]interface{}{
-		"date": time.Date(2000, time.Month(1), 1, 0, 0, 0, 0, time.UTC),
+		"foo": time.Date(2000, time.Month(1), 1, 0, 0, 0, 0, time.UTC),
 	}
-	program, err := expr.Compile(`now() - duration("1h") < now() && date + duration("24h") < now()`, expr.Env(env))
+	program, err := expr.Compile(`now() - duration("1h") < now() && foo + duration("24h") < now()`, expr.Env(env))
 	require.NoError(t, err)
 
 	output, err := expr.Run(program, env)

From 39c9df602b5b19499994b6a2568d3a171d897ac8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 23:03:13 +0200
Subject: [PATCH 067/506] Fix panic in checker

---
 checker/checker.go        |  8 ++++----
 checker/types.go          |  7 +++++++
 compiler/compiler_test.go | 13 +++++++++++++
 3 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 89c0d4d84..5088fa5f9 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -475,7 +475,7 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 func (v *visitor) SliceNode(node *ast.SliceNode) (reflect.Type, info) {
 	t, _ := v.visit(node.Node)
 
-	switch t.Kind() {
+	switch kind(t) {
 	case reflect.Interface:
 		// ok
 	case reflect.String, reflect.Array, reflect.Slice:
@@ -532,7 +532,7 @@ func (v *visitor) CallNode(node *ast.CallNode) (reflect.Type, info) {
 			fn.NumOut() == 1 &&
 			fn.Out(0).Kind() == reflect.Interface {
 			rest := fn.In(fn.NumIn() - 1) // function has only one param for functions and two for methods
-			if rest.Kind() == reflect.Slice && rest.Elem().Kind() == reflect.Interface {
+			if kind(rest) == reflect.Slice && rest.Elem().Kind() == reflect.Interface {
 				node.Fast = true
 			}
 		}
@@ -666,7 +666,7 @@ func (v *visitor) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
 
 	t, _ := v.visit(val)
 
-	switch t.Kind() {
+	switch kind(t) {
 	case reflect.Interface:
 		return anyType, info{}
 	case reflect.Slice, reflect.Array:
@@ -791,7 +791,7 @@ func (v *visitor) checkArguments(name string, fn reflect.Type, method bool, argu
 			continue
 		}
 
-		if !t.AssignableTo(in) && t.Kind() != reflect.Interface {
+		if !t.AssignableTo(in) && kind(t) != reflect.Interface {
 			return anyType, &file.Error{
 				Location: arg.Location(),
 				Message:  fmt.Sprintf("cannot use %v as argument (type %v) to call %v ", t, in, name),
diff --git a/checker/types.go b/checker/types.go
index da8acf41d..bb23aa190 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -223,6 +223,13 @@ func deref(t reflect.Type) reflect.Type {
 	return t
 }
 
+func kind(t reflect.Type) reflect.Kind {
+	if t == nil {
+		return reflect.Invalid
+	}
+	return t.Kind()
+}
+
 func isIntegerOrArithmeticOperation(node ast.Node) bool {
 	switch n := node.(type) {
 	case *ast.IntegerNode:
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index d5293913c..c5575ebfd 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/test/playground"
 	"github.com/antonmedv/expr/vm"
 	"github.com/antonmedv/expr/vm/runtime"
 	"github.com/stretchr/testify/assert"
@@ -278,3 +279,15 @@ func TestCompile(t *testing.T) {
 		assert.Equal(t, test.program.Disassemble(), program.Disassemble(), test.input)
 	}
 }
+
+func TestCompile_panic(t *testing.T) {
+	tests := []string{
+		`(TotalPosts.Profile[Authors > TotalPosts == get(nil, TotalLikes)] > Authors) ^ (TotalLikes / (Posts?.PublishDate[TotalPosts] < Posts))`,
+	}
+	for _, test := range tests {
+		t.Run(test, func(t *testing.T) {
+			_, err := expr.Compile(test, expr.Env(playground.Blog{}))
+			require.Error(t, err)
+		})
+	}
+}

From 87e38b17441fba0c5691cccf545ef835c74224c3 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 23:16:33 +0200
Subject: [PATCH 068/506] Fix panic in checker

---
 checker/checker.go        | 3 +++
 compiler/compiler_test.go | 1 +
 2 files changed, 4 insertions(+)

diff --git a/checker/checker.go b/checker/checker.go
index 5088fa5f9..0091544fe 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -804,6 +804,9 @@ func (v *visitor) checkArguments(name string, fn reflect.Type, method bool, argu
 
 func (v *visitor) ClosureNode(node *ast.ClosureNode) (reflect.Type, info) {
 	t, _ := v.visit(node.Node)
+	if t == nil {
+		return v.error(node.Node, "closure cannot be nil")
+	}
 	return reflect.FuncOf([]reflect.Type{anyType}, []reflect.Type{t}, false), info{}
 }
 
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index c5575ebfd..b405d3df7 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -283,6 +283,7 @@ func TestCompile(t *testing.T) {
 func TestCompile_panic(t *testing.T) {
 	tests := []string{
 		`(TotalPosts.Profile[Authors > TotalPosts == get(nil, TotalLikes)] > Authors) ^ (TotalLikes / (Posts?.PublishDate[TotalPosts] < Posts))`,
+		`one(Posts, nil)`,
 	}
 	for _, test := range tests {
 		t.Run(test, func(t *testing.T) {

From f383e06071d372e613aaa9b7329019c37b12159b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 23:19:58 +0200
Subject: [PATCH 069/506] Fix panic in checker

---
 checker/checker.go        | 14 ++++++++++++++
 compiler/compiler_test.go |  1 +
 2 files changed, 15 insertions(+)

diff --git a/checker/checker.go b/checker/checker.go
index 0091544fe..9cfb0f9f3 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -670,8 +670,22 @@ func (v *visitor) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
 	case reflect.Interface:
 		return anyType, info{}
 	case reflect.Slice, reflect.Array:
+		p, _ := v.visit(prop)
+		if p == nil {
+			return v.error(prop, "cannot use nil as slice index")
+		}
+		if !isInteger(p) && !isAny(p) {
+			return v.error(prop, "non-integer slice index %v", p)
+		}
 		return t.Elem(), info{}
 	case reflect.Map:
+		p, _ := v.visit(prop)
+		if p == nil {
+			return v.error(prop, "cannot use nil as map index")
+		}
+		if !p.AssignableTo(t.Key()) && !isAny(p) {
+			return v.error(prop, "cannot use %v to get an element from %v", p, t)
+		}
 		return t.Elem(), info{}
 	}
 	return v.error(val, "type %v does not support indexing", t)
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index b405d3df7..fd3f663ee 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -284,6 +284,7 @@ func TestCompile_panic(t *testing.T) {
 	tests := []string{
 		`(TotalPosts.Profile[Authors > TotalPosts == get(nil, TotalLikes)] > Authors) ^ (TotalLikes / (Posts?.PublishDate[TotalPosts] < Posts))`,
 		`one(Posts, nil)`,
+		`trim(TotalViews, Posts) <= get(Authors, nil)`,
 	}
 	for _, test := range tests {
 		t.Run(test, func(t *testing.T) {

From 87534e6eca73f8a940557068e972c1897efafd3b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 23:39:35 +0200
Subject: [PATCH 070/506] Improve type checker

---
 checker/checker.go      | 8 +++++++-
 checker/checker_test.go | 5 +++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/checker/checker.go b/checker/checker.go
index 9cfb0f9f3..43c80b35f 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -321,9 +321,15 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 			return boolType, info{}
 		}
 		if isMap(r) {
+			if l == nil {
+				return v.error(node, "cannot use nil as map key")
+			}
+			if !isAny(l) && !l.AssignableTo(r.Key()) {
+				return v.error(node, "cannot use %v (type %v) as type %v in map key", l, l, r.Key())
+			}
 			return boolType, info{}
 		}
-		if isArray(r) {
+		if isInteger(l) && isArray(r) {
 			return boolType, info{}
 		}
 		if isAny(l) && anyOf(r, isString, isArray, isMap) {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index dbd13765f..e2d955e94 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -489,6 +489,11 @@ FuncTyped(42)
 cannot use int as argument (type string) to call FuncTyped  (1:11)
  | FuncTyped(42)
  | ..........^
+
+.0 in MapOfFoo
+cannot use float64 (type float64) as type string in map key (1:4)
+ | .0 in MapOfFoo
+ | ...^
 `
 
 func TestCheck_error(t *testing.T) {

From 282244db28b8efe3a5a0e3b2a25537ce95b67cb3 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 17 Aug 2023 23:59:56 +0200
Subject: [PATCH 071/506] Improve type checker

---
 checker/checker.go      | 24 +++++++++++++++++++-----
 checker/checker_test.go | 11 ++++++++---
 2 files changed, 27 insertions(+), 8 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 43c80b35f..82aa5b74e 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -275,7 +275,7 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 			return anyType, info{}
 		}
 
-	case "/", "*":
+	case "*":
 		if isNumber(l) && isNumber(r) {
 			return combined(l, r), info{}
 		}
@@ -283,6 +283,14 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 			return anyType, info{}
 		}
 
+	case "/":
+		if isNumber(l) && isNumber(r) {
+			return floatType, info{}
+		}
+		if or(l, r, isNumber) {
+			return floatType, info{}
+		}
+
 	case "**", "^":
 		if isNumber(l) && isNumber(r) {
 			return floatType, info{}
@@ -321,15 +329,21 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 			return boolType, info{}
 		}
 		if isMap(r) {
-			if l == nil {
-				return v.error(node, "cannot use nil as map key")
+			if l == nil { // It is possible to compare with nil.
+				return boolType, info{}
 			}
 			if !isAny(l) && !l.AssignableTo(r.Key()) {
-				return v.error(node, "cannot use %v (type %v) as type %v in map key", l, l, r.Key())
+				return v.error(node, "cannot use %v as type %v in map key", l, r.Key())
 			}
 			return boolType, info{}
 		}
-		if isInteger(l) && isArray(r) {
+		if isArray(r) {
+			if l == nil { // It is possible to compare with nil.
+				return boolType, info{}
+			}
+			if !isAny(l) && !isInteger(l) {
+				return v.error(node, "cannot use %v as type %v in array", l, r.Elem())
+			}
 			return boolType, info{}
 		}
 		if isAny(l) && anyOf(r, isString, isArray, isMap) {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index e2d955e94..5b6a31365 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -55,13 +55,13 @@ var successTests = []string{
 	"(Any ? 0 : nil) == 0",
 	"(Any ? nil : nil) == nil",
 	"!(Any ? Foo : Foo.Bar).Anything",
-	"String in ArrayOfFoo",
+	"Int in ArrayOfFoo",
+	"Int not in ArrayOfFoo",
 	"String in Foo",
 	"String in MapOfFoo",
 	"String matches 'ok'",
 	"String matches Any",
 	"String not matches Any",
-	"String not in ArrayOfFoo",
 	"StringPtr == nil",
 	"[1, 2, 3] == []",
 	"len([]) > 0",
@@ -491,9 +491,14 @@ cannot use int as argument (type string) to call FuncTyped  (1:11)
  | ..........^
 
 .0 in MapOfFoo
-cannot use float64 (type float64) as type string in map key (1:4)
+cannot use float64 as type string in map key (1:4)
  | .0 in MapOfFoo
  | ...^
+
+1/2 in MapIntAny
+cannot use float64 as type int in map key (1:5)
+ | 1/2 in MapIntAny
+ | ....^
 `
 
 func TestCheck_error(t *testing.T) {

From 76664a6b6001432253f2c36f57372398992d8290 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 00:06:51 +0200
Subject: [PATCH 072/506] Fix errors in checker

---
 checker/checker.go        | 6 +++---
 compiler/compiler_test.go | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 82aa5b74e..8204aa7d0 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -434,7 +434,7 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 		// First, check methods defined on base type itself,
 		// independent of which type it is. Without dereferencing.
 		if m, ok := base.MethodByName(name.Value); ok {
-			if base.Kind() == reflect.Interface {
+			if kind(base) == reflect.Interface {
 				// In case of interface type method will not have a receiver,
 				// and to prevent checker decreasing numbers of in arguments
 				// return method type as not method (second argument is false).
@@ -452,11 +452,11 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 		}
 	}
 
-	if base.Kind() == reflect.Ptr {
+	if kind(base) == reflect.Ptr {
 		base = base.Elem()
 	}
 
-	switch base.Kind() {
+	switch kind(base) {
 	case reflect.Interface:
 		return anyType, info{}
 
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index fd3f663ee..9a21979d8 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -285,6 +285,7 @@ func TestCompile_panic(t *testing.T) {
 		`(TotalPosts.Profile[Authors > TotalPosts == get(nil, TotalLikes)] > Authors) ^ (TotalLikes / (Posts?.PublishDate[TotalPosts] < Posts))`,
 		`one(Posts, nil)`,
 		`trim(TotalViews, Posts) <= get(Authors, nil)`,
+		`Authors.IsZero(nil * Authors) - (TotalViews && Posts ? nil : nil)[TotalViews.IsZero(false, " ").IsZero(Authors)]`,
 	}
 	for _, test := range tests {
 		t.Run(test, func(t *testing.T) {

From a03c2c3700dbc67f8384a18d7bee3222878147df Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 00:15:32 +0200
Subject: [PATCH 073/506] Add test data generator

---
 test/mock/mock.go            |   1 +
 test/playground/data.go      | 119 ++++++++++++
 test/playground/env.go       | 125 ++++++++++++
 test/playground/gen/gen.go   | 358 +++++++++++++++++++++++++++++++++++
 test/playground/gen/utils.go |  53 ++++++
 5 files changed, 656 insertions(+)
 create mode 100644 test/playground/data.go
 create mode 100644 test/playground/gen/gen.go
 create mode 100644 test/playground/gen/utils.go

diff --git a/test/mock/mock.go b/test/mock/mock.go
index b59293cdd..2ded8e555 100644
--- a/test/mock/mock.go
+++ b/test/mock/mock.go
@@ -35,6 +35,7 @@ type Env struct {
 	ArrayOfFoo         []*Foo
 	MapOfFoo           map[string]Foo
 	MapOfAny           map[string]interface{}
+	MapIntAny          map[int]string
 	FuncParam          func(_ bool, _ int, _ string) bool
 	FuncParamAny       func(_ interface{}) bool
 	FuncTooManyReturns func() (int, int, error)
diff --git a/test/playground/data.go b/test/playground/data.go
new file mode 100644
index 000000000..70d12e916
--- /dev/null
+++ b/test/playground/data.go
@@ -0,0 +1,119 @@
+package playground
+
+import (
+	"fmt"
+	"time"
+)
+
+func ExampleData() interface{} {
+	profileJohn := UserProfile{
+		Birthday:  time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC),
+		Biography: "A passionate writer about Go.",
+		Website:   "https://johndoe.com",
+	}
+
+	profileJane := UserProfile{
+		Birthday:  time.Date(1985, 2, 15, 0, 0, 0, 0, time.UTC),
+		Biography: "A web developer and writer.",
+		Website:   "https://jane.com",
+	}
+
+	authorJohn := Author{
+		ID:        1,
+		FirstName: "John",
+		LastName:  "Doe",
+		Email:     "john.doe@example.com",
+		Profile:   profileJohn,
+	}
+
+	authorJane := Author{
+		ID:        2,
+		FirstName: "Jane",
+		LastName:  "Smith",
+		Email:     "jane.smith@example.com",
+		Profile:   profileJane,
+	}
+
+	posts := []Post{
+		{
+			ID:          1,
+			Title:       "Understanding Golang",
+			Content:     "Go is an open-source programming language...",
+			PublishDate: time.Now().AddDate(0, -1, 0),
+			Author:      authorJohn,
+			Comments:    generateComments(3),
+			Tags:        []string{"Go", "Programming"},
+			Likes:       100,
+		},
+		{
+			ID:          2,
+			Title:       "Exploring Python",
+			Content:     "Python is versatile...",
+			PublishDate: time.Now().AddDate(0, -2, 0),
+			Author:      authorJane,
+			Comments:    generateComments(4),
+			Tags:        []string{"Python", "Development"},
+			Likes:       150,
+		},
+		{
+			ID:          3,
+			Title:       "Web Development Basics",
+			Content:     "The world of web development...",
+			PublishDate: time.Now().AddDate(0, -3, 0),
+			Author:      authorJane,
+			Comments:    generateComments(5),
+			Tags:        []string{"Web", "HTML", "CSS"},
+			Likes:       125,
+		},
+		{
+			ID:          4,
+			Title:       "Machine Learning in a Nutshell",
+			Content:     "ML is revolutionizing industries...",
+			PublishDate: time.Now().AddDate(0, -5, 0),
+			Author:      authorJohn,
+			Comments:    generateComments(6),
+			Tags:        []string{"ML", "AI"},
+			Likes:       200,
+		},
+		{
+			ID:          5,
+			Title:       "JavaScript: The Good Parts",
+			Content:     "JavaScript powers the web...",
+			PublishDate: time.Now().AddDate(0, -4, 0),
+			Author:      authorJane,
+			Comments:    generateComments(3),
+			Tags:        []string{"JavaScript", "Web"},
+			Likes:       170,
+		},
+	}
+
+	blog := Blog{
+		Posts:      make([]Post, len(posts)),
+		Authors:    map[int]Author{authorJohn.ID: authorJohn, authorJane.ID: authorJane},
+		TotalViews: 10000,
+		TotalPosts: len(posts),
+		TotalLikes: 0,
+	}
+
+	for i, post := range posts {
+		blog.Posts[i] = post
+		blog.TotalLikes += post.Likes
+	}
+
+	return blog
+}
+
+func generateComments(count int) []Comment {
+	var comments []Comment
+	for i := 1; i <= count; i++ {
+		comment := Comment{
+			ID:          i,
+			AuthorName:  fmt.Sprintf("Commenter %d", i),
+			Content:     fmt.Sprintf("This is comment %d!", i),
+			CommentDate: time.Now().AddDate(0, 0, -i),
+			Upvotes:     i * 5,
+		}
+		comments = append(comments, comment)
+	}
+	return comments
+}
diff --git a/test/playground/env.go b/test/playground/env.go
index 06224c60d..691aae624 100644
--- a/test/playground/env.go
+++ b/test/playground/env.go
@@ -10,6 +10,10 @@ type UserProfile struct {
 	Website   string
 }
 
+func (u UserProfile) Age() int {
+	return time.Now().Year() - u.Birthday.Year()
+}
+
 type Author struct {
 	ID        int
 	FirstName string
@@ -18,6 +22,14 @@ type Author struct {
 	Profile   UserProfile
 }
 
+func (a Author) FullName() string {
+	return a.FirstName + " " + a.LastName
+}
+
+func (a Author) IsAdmin() bool {
+	return a.ID == 1
+}
+
 type Post struct {
 	ID          int
 	Title       string
@@ -29,6 +41,35 @@ type Post struct {
 	Likes       int
 }
 
+func (p Post) Published() bool {
+	return !p.PublishDate.IsZero()
+}
+
+func (p Post) After(date time.Time) bool {
+	return p.PublishDate.After(date)
+}
+
+func (p Post) Before(date time.Time) bool {
+	return p.PublishDate.Before(date)
+}
+
+func (p Post) Compare(other Post) int {
+	if p.PublishDate.Before(other.PublishDate) {
+		return -1
+	} else if p.PublishDate.After(other.PublishDate) {
+		return 1
+	}
+	return 0
+}
+
+func (p Post) Equal(other Post) bool {
+	return p.Compare(other) == 0
+}
+
+func (p Post) IsZero() bool {
+	return p.ID == 0 && p.Title == "" && p.Content == "" && p.PublishDate.IsZero()
+}
+
 type Comment struct {
 	ID          int
 	AuthorName  string
@@ -37,6 +78,14 @@ type Comment struct {
 	Upvotes     int
 }
 
+func (c Comment) Upvoted() bool {
+	return c.Upvotes > 0
+}
+
+func (c Comment) AuthorEmail() string {
+	return c.AuthorName + "@example.com"
+}
+
 type Blog struct {
 	Posts      []Post
 	Authors    map[int]Author
@@ -44,3 +93,79 @@ type Blog struct {
 	TotalPosts int
 	TotalLikes int
 }
+
+func (b Blog) RecentPosts() []Post {
+	var posts []Post
+	for _, post := range b.Posts {
+		if post.Published() {
+			posts = append(posts, post)
+		}
+	}
+	return posts
+}
+
+func (b Blog) PopularPosts() []Post {
+	var posts []Post
+	for _, post := range b.Posts {
+		if post.Likes > 150 {
+			posts = append(posts, post)
+		}
+	}
+	return posts
+}
+
+func (b Blog) TotalUpvotes() int {
+	var upvotes int
+	for _, post := range b.Posts {
+		for _, comment := range post.Comments {
+			upvotes += comment.Upvotes
+		}
+	}
+	return upvotes
+}
+
+func (b Blog) TotalComments() int {
+	var comments int
+	for _, post := range b.Posts {
+		comments += len(post.Comments)
+	}
+	return comments
+}
+
+func (Blog) Add(a, b float64) float64 {
+	return a + b
+}
+
+func (Blog) Sub(a, b float64) float64 {
+	return a - b
+}
+
+func (Blog) Title(post Post) string {
+	return post.Title
+}
+
+func (Blog) HasTag(post Post, tag string) bool {
+	for _, t := range post.Tags {
+		if t == tag {
+			return true
+		}
+	}
+	return false
+}
+
+func (Blog) IsAdmin(author Author) bool {
+	return author.IsAdmin()
+}
+
+func (Blog) IsZero(post Post) bool {
+	return post.IsZero()
+}
+
+func (Blog) WithID(posts []Post, id int) Post {
+	for _, post := range posts {
+		if post.ID == id {
+			return post
+		}
+	}
+	return Post{}
+}
diff --git a/test/playground/gen/gen.go b/test/playground/gen/gen.go
new file mode 100644
index 000000000..8e0bb17f2
--- /dev/null
+++ b/test/playground/gen/gen.go
@@ -0,0 +1,358 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+
+	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/ast"
+	"github.com/antonmedv/expr/builtin"
+	"github.com/antonmedv/expr/test/playground"
+)
+
+func main() {
+	var code string
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Printf("==========================\n%s\n==========================\n", code)
+			panic(r)
+		}
+	}()
+
+	corpus := map[string]struct{}{}
+	for {
+		code = node(weightedRandomInt([]intWeight{
+			{3, 100},
+			{4, 40},
+			{5, 50},
+			{6, 30},
+			{7, 20},
+			{8, 10},
+			{9, 5},
+			{10, 5},
+		})).String()
+
+		program, err := expr.Compile(code, expr.Env(playground.Blog{}))
+		if err != nil {
+			continue
+		}
+		_, err = expr.Run(program, playground.ExampleData())
+		if err != nil {
+			continue
+		}
+
+		if _, ok := corpus[code]; ok {
+			continue
+		}
+		corpus[code] = struct{}{}
+		fmt.Println(code)
+	}
+}
+
+func node(depth int) ast.Node {
+	if depth <= 0 {
+		return weightedRandom([]fnWeight{
+			{nilNode, 1},
+			{floatNode, 1},
+			{integerNode, 1},
+			{stringNode, 1},
+			{booleanNode, 1},
+			{identifierNode, 10},
+		})(depth - 1)
+	}
+	return weightedRandom([]fnWeight{
+		{arrayNode, 1},
+		{mapNode, 1},
+		{identifierNode, 1000},
+		{memberNode, 1500},
+		{unaryNode, 100},
+		{binaryNode, 2000},
+		{callNode, 2000},
+		{builtinNode, 500},
+		{predicateNode, 1000},
+		{pointerNode, 500},
+		{sliceNode, 100},
+		{conditionalNode, 100},
+	})(depth - 1)
+}
+
+func nilNode(depth int) ast.Node {
+	return &ast.NilNode{}
+}
+
+func floatNode(depth int) ast.Node {
+	cases := []float64{
+		0.0,
+		0.5,
+	}
+	return &ast.FloatNode{
+		Value: cases[rand.Intn(len(cases))],
+	}
+}
+
+func integerNode(depth int) ast.Node {
+	return &ast.IntegerNode{
+		Value: rand.Intn(3),
+	}
+}
+
+func stringNode(depth int) ast.Node {
+	corpus := []string{
+		"Go", "JavaScript", " ",
+	}
+	return &ast.StringNode{
+		Value: corpus[rand.Intn(len(corpus))],
+	}
+}
+
+func booleanNode(depth int) ast.Node {
+	return &ast.BoolNode{
+		Value: maybe(),
+	}
+}
+
+func identifierNode(depth int) ast.Node {
+	cases := []string{
+		"Posts",
+		"Authors",
+		"TotalViews",
+	}
+
+	return &ast.IdentifierNode{
+		Value: cases[rand.Intn(len(cases))],
+	}
+}
+
+func memberNode(depth int) ast.Node {
+	cases := []string{
+		"Birthday",
+		"Biography",
+		"Website",
+		"ID",
+		"FirstName",
+		"LastName",
+		"Email",
+		"Profile",
+		"ID",
+		"Title",
+		"Content",
+		"PublishDate",
+		"Author",
+		"Comments",
+		"Tags",
+		"Likes",
+		"ID",
+		"AuthorName",
+		"Content",
+		"CommentDate",
+		"Upvotes",
+	}
+
+	return &ast.MemberNode{
+		Node: node(depth - 1),
+		Property: weightedRandom([]fnWeight{
+			{func(_ int) ast.Node { return &ast.StringNode{Value: cases[rand.Intn(len(cases))]} }, 5},
+			{node, 1},
+		})(depth - 1),
+		Optional: maybe(),
+	}
+}
+
+func unaryNode(depth int) ast.Node {
+	cases := []string{
+		"-",
+		"!",
+		"not",
+	}
+	return &ast.UnaryNode{
+		Operator: cases[rand.Intn(len(cases))],
+		Node:     node(depth - 1),
+	}
+}
+
+func binaryNode(depth int) ast.Node {
+	cases := []string{
+		"or",
+		"||",
+		"and",
+		"&&",
+		"==",
+		"!=",
+		"<",
+		">",
+		">=",
+		"<=",
+		"in",
+		"matches",
+		"contains",
+		"startsWith",
+		"endsWith",
+		"..",
+		"+",
+		"-",
+		"*",
+		"/",
+		"%",
+		"**",
+		"^",
+	}
+	return &ast.BinaryNode{
+		Operator: cases[rand.Intn(len(cases))],
+		Left:     node(depth - 1),
+		Right:    node(depth - 1),
+	}
+}
+
+func methodNode(depth int) ast.Node {
+	cases := []string{
+		"Age",
+		"FullName",
+		"IsAdmin",
+		"Published",
+		"After",
+		"Before",
+		"Compare",
+		"Equal",
+		"IsZero",
+		"Upvoted",
+		"AuthorEmail",
+	}
+
+	return &ast.MemberNode{
+		Node:     node(depth - 1),
+		Property: &ast.StringNode{Value: cases[rand.Intn(len(cases))]},
+		Optional: maybe(),
+	}
+}
+
+func funcNode(depth int) ast.Node {
+	cases := []string{
+		"RecentPosts",
+		"PopularPosts",
+		"TotalUpvotes",
+		"TotalComments",
+		"Add",
+		"Sub",
+		"Title",
+		"HasTag",
+		"IsAdmin",
+		"IsZero",
+		"WithID",
+	}
+
+	return &ast.IdentifierNode{
+		Value: cases[rand.Intn(len(cases))],
+	}
+}
+
+func callNode(depth int) ast.Node {
+	var args []ast.Node
+	max := weightedRandomInt([]intWeight{
+		{1, 100},
+		{2, 50},
+		{3, 25},
+		{4, 10},
+		{5, 5},
+	})
+	for i := 0; i < max; i++ {
+		args = append(args, node(depth-1))
+	}
+	return &ast.CallNode{
+		Callee: weightedRandom([]fnWeight{
+			{methodNode, 2},
+			{funcNode, 2},
+		})(depth - 1),
+		Arguments: args,
+	}
+}
+
+func builtinNode(depth int) ast.Node {
+	var args []ast.Node
+	max := weightedRandomInt([]intWeight{
+		{1, 100},
+		{2, 50},
+		{3, 25},
+		{4, 10},
+		{5, 5},
+	})
+	for i := 0; i < max; i++ {
+		args = append(args, node(depth-1))
+	}
+	return &ast.BuiltinNode{
+		Name:      builtin.Names[rand.Intn(len(builtin.Names))],
+		Arguments: args,
+	}
+}
+
+func predicateNode(depth int) ast.Node {
+	cases := []string{
+		"all",
+		"none",
+		"any",
+		"one",
+		"filter",
+		"map",
+		"count",
+	}
+	return &ast.BuiltinNode{
+		Name:      cases[rand.Intn(len(cases))],
+		Arguments: []ast.Node{node(depth - 1), node(depth - 1)},
+	}
+}
+
+func pointerNode(depth int) ast.Node {
+	return &ast.PointerNode{}
+}
+
+func arrayNode(depth int) ast.Node {
+	var items []ast.Node
+	max := weightedRandomInt([]intWeight{
+		{1, 100},
+		{2, 50},
+		{3, 25},
+		{4, 10},
+		{5, 5},
+	})
+	for i := 0; i < max; i++ {
+		items = append(items, node(depth-1))
+	}
+	return &ast.ArrayNode{
+		Nodes: items,
+	}
+}
+
+func mapNode(depth int) ast.Node {
+	var items []ast.Node
+	max := weightedRandomInt([]intWeight{
+		{1, 100},
+		{2, 50},
+		{3, 25},
+		{4, 10},
+		{5, 5},
+	})
+	for i := 0; i < max; i++ {
+		items = append(items, &ast.PairNode{
+			Key:   stringNode(depth - 1),
+			Value: node(depth - 1),
+		})
+	}
+	return &ast.MapNode{
+		Pairs: items,
+	}
+}
+
+func sliceNode(depth int) ast.Node {
+	return &ast.SliceNode{
+		Node: node(depth - 1),
+		From: node(depth - 1),
+		To:   node(depth - 1),
+	}
+}
+
+func conditionalNode(depth int) ast.Node {
+	return &ast.ConditionalNode{
+		Cond: node(depth - 1),
+		Exp1: node(depth - 1),
+		Exp2: node(depth - 1),
+	}
+}
diff --git a/test/playground/gen/utils.go b/test/playground/gen/utils.go
new file mode 100644
index 000000000..0a1b5cc9c
--- /dev/null
+++ b/test/playground/gen/utils.go
@@ -0,0 +1,53 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/antonmedv/expr/ast"
+)
+
+func maybe() bool {
+	return rand.Intn(2) == 0
+}
+
+type fn func(int) ast.Node
+
+type fnWeight struct {
+	value  fn
+	weight int
+}
+
+func weightedRandom(cases []fnWeight) fn {
+	totalWeight := 0
+	for _, c := range cases {
+		totalWeight += c.weight
+	}
+	r := rand.Intn(totalWeight)
+	for _, c := range cases {
+		if r < c.weight {
+			return c.value
+		}
+		r -= c.weight
+	}
+	return cases[0].value
+}
+
+type intWeight struct {
+	value  int
+	weight int
+}
+
+func weightedRandomInt(cases []intWeight) int {
+	totalWeight := 0
+	for _, c := range cases {
+		totalWeight += c.weight
+	}
+	r := rand.Intn(totalWeight)
+	for _, c := range cases {
+		if r < c.weight {
+			return c.value
+		}
+		r -= c.weight
+	}
+	return cases[0].value
+}

From dbd9af5b1cfd1a38b8034b26d0af4ca261b027b4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 00:21:18 +0200
Subject: [PATCH 074/506] Exclude test folder from coverage

---
 .github/scripts/coverage.mjs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs
index 2df642b22..1fb96c498 100755
--- a/.github/scripts/coverage.mjs
+++ b/.github/scripts/coverage.mjs
@@ -2,7 +2,7 @@
 
 const expected = 90
 const exclude = [
-  'cmd',
+  'expr/test',
   'checker/mock',
   'vm/func_types',
   'vm/runtime/helpers',

From d0d972b171eccff9066ed405a5637d3e6d16372f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 01:34:16 +0200
Subject: [PATCH 075/506] Add fuzz testing

---
 fuzz_test.go                            |   81 +
 test/playground/data.go                 |    2 +-
 testdata/corpus.txt                     | 3446 +++++++++++++++++++++++
 testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e |    2 +
 testdata/fuzz/FuzzExpr/87861ab0b9f0abbe |    2 +
 testdata/fuzz/FuzzExpr/b65163ca9e44703c |    2 +
 6 files changed, 3534 insertions(+), 1 deletion(-)
 create mode 100644 fuzz_test.go
 create mode 100644 testdata/corpus.txt
 create mode 100644 testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e
 create mode 100644 testdata/fuzz/FuzzExpr/87861ab0b9f0abbe
 create mode 100644 testdata/fuzz/FuzzExpr/b65163ca9e44703c

diff --git a/fuzz_test.go b/fuzz_test.go
new file mode 100644
index 000000000..be395e47b
--- /dev/null
+++ b/fuzz_test.go
@@ -0,0 +1,81 @@
+package expr_test
+
+import (
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/test/playground"
+)
+
+func FuzzExpr(f *testing.F) {
+	env := playground.ExampleData()
+
+	b, err := os.ReadFile("testdata/corpus.txt")
+	if err != nil {
+		f.Fatal(err)
+	}
+	for _, testcase := range strings.Split(string(b), "\n") {
+		f.Add(testcase)
+	}
+
+	f.Add(`Posts[0].Comments[0].AuthorEmail()`)
+	f.Add(`Posts[0].Comments[0].Upvoted()`)
+	f.Add(`Posts[0].Comments[0].CommentDate.Add(now())`)
+	f.Add(`Posts[0].Comments[0].CommentDate.AddDate(0, 0, 1)`)
+	f.Add(`Authors[Posts[0].Author.ID].Profile.Biography`)
+	f.Add(`Authors[2].Profile.Age()`)
+	f.Add(`Authors[2].Profile.Website`)
+
+	okCases := []*regexp.Regexp{
+		regexp.MustCompile(`cannot slice`),
+		regexp.MustCompile(`integer divide by zero`),
+		regexp.MustCompile(`invalid operation`),
+		regexp.MustCompile(`interface conversion`),
+		regexp.MustCompile(`memory budget exceeded`),
+		regexp.MustCompile(`slice index out of range`),
+		regexp.MustCompile(`cannot fetch .* from .*`),
+		regexp.MustCompile(`cannot get .* from .*`),
+		regexp.MustCompile(`invalid argument for .*`),
+		regexp.MustCompile(`json: unsupported value`),
+		regexp.MustCompile(`error parsing regexp`),
+		regexp.MustCompile(`time: missing unit in duration`),
+		regexp.MustCompile(`using interface \{} as type .*`),
+		regexp.MustCompile(`reflect.Value.MapIndex: value of type .* is not assignable to type .*`),
+		regexp.MustCompile(`reflect: call of reflect.Value.Call on zero Value`),
+		regexp.MustCompile(`reflect: call of reflect.Value.Len on bool Value`),
+		regexp.MustCompile(`reflect: Call using .* as type .*`),
+		regexp.MustCompile(`reflect: call of reflect.Value.Index on map Value`),
+	}
+
+	skipCode := []string{
+		`??`,
+	}
+
+	f.Fuzz(func(t *testing.T, code string) {
+		for _, skipCase := range skipCode {
+			if strings.Contains(code, skipCase) {
+				t.Skip()
+				return
+			}
+		}
+
+		program, err := expr.Compile(code, expr.Env(playground.Blog{}))
+		if err != nil {
+			t.Skip()
+		}
+
+		_, err = expr.Run(program, env)
+		if err != nil {
+			for _, okCase := range okCases {
+				if okCase.MatchString(err.Error()) {
+					t.Skip()
+					return
+				}
+			}
+			t.Errorf("code: %s, err: %s", code, err)
+		}
+	})
+}
diff --git a/test/playground/data.go b/test/playground/data.go
index 70d12e916..534af0523 100644
--- a/test/playground/data.go
+++ b/test/playground/data.go
@@ -5,7 +5,7 @@ import (
 	"time"
 )
 
-func ExampleData() interface{} {
+func ExampleData() Blog {
 	profileJohn := UserProfile{
 		Birthday:  time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC),
 		Biography: "A passionate writer about Go.",
diff --git a/testdata/corpus.txt b/testdata/corpus.txt
new file mode 100644
index 000000000..420ef66ad
--- /dev/null
+++ b/testdata/corpus.txt
@@ -0,0 +1,3446 @@
+TotalViews
+Authors
+len(Authors)
+Posts
+map(Posts, float(TotalViews))
+all(map(Posts, 0.5), TotalViews < TotalViews)
+Authors == Authors
+-TotalViews
+map(Posts, TotalViews)
+len(Posts)
+TotalViews .. TotalViews
+first(Posts)
+min(TotalViews)
+Authors[0]?.ID
+int(TotalViews)
+string(Authors)
+toJSON(Posts)
+map(Posts, int(TotalViews))
+Authors[TotalViews]?.FirstName
+TotalViews >= TotalViews
+abs(TotalViews)
+Authors[TotalViews]?.LastName
+string(TotalViews)
+TotalViews <= TotalViews
+string(get(Posts, TotalViews))
+TotalViews + -TotalViews
+one(Posts, TotalViews > TotalViews)
+get(Posts, TotalViews)
+TotalViews <= 0.5 * TotalViews
+toJSON(TotalViews)
+float(TotalViews)
+map(Posts, 0 / TotalViews)
+all(Posts, 0 in Authors)
+last(Posts)
+TotalViews * TotalViews == TotalViews
+Authors[TotalViews]
+TotalViews ** TotalViews
+map(Posts, Authors)
+one(Posts, 1 != TotalViews)
+TotalViews * TotalViews == 0 ^ TotalViews
+string(map(Posts, TotalViews))
+get(Posts, 0)?.PublishDate
+TotalViews == len(Authors)
+[Authors]
+TotalViews - TotalViews
+filter(Posts, nil == TotalViews)
+IsAdmin(Authors[0])
+string(Posts)
+get(Posts, TotalViews)?.PublishDate
+Authors[TotalViews]?.ID
+Authors[TotalViews]?.Profile
+TotalViews < TotalViews
+max(TotalViews)
+Authors != Authors
+map(Posts, #)
+len(map(Posts, 0))
+string(TotalViews .. TotalViews)
+TotalViews > TotalViews
+last(0 .. TotalViews)
+toJSON(Authors)
+{" ": TotalViews}?.Content
+last(map(Posts, Posts))
+TotalViews == TotalViews
+-(TotalViews / 0.5)
+Posts != Posts
+TotalViews ** 0 < TotalViews
+!("JavaScript" <= "Go")
+Authors[TotalViews].ID
+int(min(1, 0))
+Authors[TotalViews % TotalViews]
+map(map(Posts, Authors), nil == Posts)
+-max(2)
+-(TotalViews + TotalViews)
+{"Go": nil, "Go": 0.5}?.Content?.AuthorName
+get(Posts, 2).Title
+!(TotalViews == nil)
+first(Posts).Title
+not none(Posts, true)
+not (nil in Posts)
+TotalViews ^ TotalViews
+map(Posts, Posts)
+-(TotalViews % TotalViews)
+get(Posts, 0).Content
+last(Posts)?.Likes
+TotalViews in Posts
+Authors[TotalViews].LastName
+get(Posts, 0).Title
+filter(Posts, TotalViews > TotalViews)
+{"JavaScript": Posts}
+--TotalViews
+TotalViews + TotalViews
+TotalViews .. abs(TotalViews)
+TotalViews != TotalViews
+!(1 != TotalViews)
+WithID(Posts, TotalViews)?.ID
+TotalViews < -TotalViews
+get(map(Posts, TotalViews), TotalViews)
+TotalViews / TotalViews
+TotalViews < TotalViews ? Authors : Authors == Authors
+[get(Posts, TotalViews), Authors]
+map(Posts, float(1))
+Authors[2].ID
+TotalViews >= TotalViews ? TotalViews : Posts
+TotalViews % TotalViews
+max(0 ** 0.5)
+TotalViews > TotalViews ? Authors : 0.5
+TotalViews + TotalViews - TotalViews
+Posts == Posts
+TotalViews ** 0 - TotalViews
+not none(Posts, false)
+any(Posts, TotalViews <= 2)
+IsAdmin(get(Authors, TotalViews))
+!(Authors != nil)
+TotalViews in Posts ? TotalViews : 2
+[TotalViews]
+TotalViews <= TotalViews + TotalViews
+float(TotalViews) >= TotalViews
+0 % TotalViews .. TotalViews + TotalViews
+0 ** TotalViews >= float(0)
+first(Posts)?.ID
+not (Authors != nil)
+TotalViews in Authors
+Posts[0].Content
+not (TotalViews == 0)
+!any(Posts, false)
+!(TotalViews == 0)
+TotalViews - TotalViews <= float(0)
+TotalViews ^ 1 ^ 1
+-(TotalViews - 0)
+first(Posts).Likes
+!(Authors == Authors)
+float(TotalViews) > count(Posts, true)
+false ? Authors : TotalViews + TotalViews
+all(Posts, TotalViews < TotalViews)
+toJSON(" " startsWith " ")
+string(filter(Posts, true))
+int(TotalViews / TotalViews)
+float(0 ^ TotalViews)
+get(Posts, 0)?.Likes
+all(Posts, TotalViews > TotalViews)
+not (1 in Posts)
+WithID(Posts, 1).PublishDate
+TotalViews >= TotalViews ** TotalViews
+get(Authors, 1)?.FirstName
+-(0 - TotalViews)
+(0.5 / TotalViews) ^ TotalViews
+--0
+trim(upper("Go"))
+int(int(TotalViews))
+TotalViews <= TotalViews ** TotalViews
+-(0 + TotalViews)
+none(Posts, "Go" contains "JavaScript")
+toJSON(0.5 == 2)
+-int(TotalViews)
+!(TotalViews in Authors)
+Posts[2].PublishDate
+-2 in Authors
+map(Posts, #?.Likes)
+(2 + TotalViews) ^ TotalViews
+(TotalViews + TotalViews) / TotalViews
+Authors[TotalViews].FirstName
+none(Posts, Posts == Posts)
+toJSON(TotalViews > TotalViews)
+(TotalViews * 0.5) ** TotalViews
+Posts[2]?.Author
+Authors[nil].FirstName
+!(TotalViews == TotalViews)
+-(TotalViews ** TotalViews)
+toJSON(TotalViews ** 2)
+first(Posts).Tags
+not (Authors == Authors)
+min(2 ** TotalViews)
+-(0 - 0)
+1 < TotalViews ? Posts : Authors
+all(Posts, one(Posts, true))
+map(Posts, TotalViews <= 2)
+[Posts]
+TotalViews * TotalViews
+TotalViews <= -(0.5 - TotalViews)
+WithID(Posts, TotalViews)
+Posts != map(Posts, Posts)
+!(2 == TotalViews)
+!(nil == Authors)
+get(Authors, TotalViews)
+-(TotalViews ** 0)
+Authors[1].FirstName
+TotalViews - 0 != -0
+-(TotalViews * 0)
+string(TotalViews > TotalViews)
+map(map(Posts, Authors), #)
+{" ": TotalViews, " ": Posts}.PublishDate
+get(Authors, 0)?.Profile
+get(Authors, TotalViews).LastName
+first(Posts).Author
+{"Go": Authors}
+TotalViews > int(2)
+map(Posts, min(0.5))
+map(false ? 1 : Authors, Authors)
+!(TotalViews == 0.5)
+get(Posts, TotalViews)?.Tags
+!(nil != Posts)
+toJSON(TotalViews < TotalViews)
+0.5 * TotalViews * TotalViews
+TotalViews == TotalViews != nil
+string(!true)
+-TotalViews ^ min(0)
+get(Posts, TotalViews)?.ID
+toJSON(max(0.5))
+TotalViews * 0 / TotalViews
+not not false
+{" ": Posts}?.Author
+any(Posts, Authors != Authors)
+get(Authors, 0)?.Email
+string(Posts[TotalViews:TotalViews])
+get(Posts, TotalViews)?.Likes
+first(map(Posts, true))
+abs(TotalViews / 0.5)
+Posts[2].Tags
+toJSON(upper("JavaScript"))
+-0 + TotalViews
+toJSON(float(TotalViews))
+get(Authors, TotalViews)?.Email
+2 / TotalViews >= TotalViews
+TotalViews ^ TotalViews > TotalViews
+TotalViews < TotalViews - 0
+TotalViews > TotalViews * TotalViews
+TotalViews % TotalViews / TotalViews
+any(Posts, nil != Authors)
+-TotalViews > TotalViews
+string(map(Posts, Authors))
+get(Authors, TotalViews)?.FirstName
+Authors[2]?.LastName
+any(Posts, TotalViews == 2)
+string(0 <= TotalViews)
+!(TotalViews > TotalViews)
+not (TotalViews == TotalViews)
+!(TotalViews >= TotalViews)
+map(Posts, TotalViews in Posts)
+count(Posts, TotalViews <= TotalViews)
+len(map(Posts, TotalViews))
+Title(WithID(Posts, TotalViews))
+TotalViews < 0 ? Authors : "Go"
+!(" " == nil)
+count(Posts, 0 >= TotalViews)
+not (TotalViews in Posts)
+-(2 - TotalViews)
+get(Posts, -0)
+get(Posts, TotalViews)?.Content
+abs(len(Authors))
+TotalViews / (1 - 2)
+IsZero(WithID(Posts, 0))
+Posts[0].PublishDate
+TotalViews in Posts ? TotalViews : Authors
+get(Posts, 2)?.Likes
+toJSON(toJSON(Posts))
+map(Posts, get(Posts, TotalViews))
+get(Posts, TotalViews)?.Comments
+Posts[0]?.Tags
+TotalViews % TotalViews != TotalViews
+!(Authors != Authors)
+Authors[TotalViews].Profile
+!(0.5 == 0.5)
+not (TotalViews >= TotalViews)
+0.5 / 0 <= TotalViews
+abs(TotalViews ** TotalViews)
+TotalViews > TotalViews ? Posts : TotalViews
+!(TotalViews < TotalViews)
+not (0 == TotalViews)
+TotalViews + 0.5 ** TotalViews
+{" ": Authors}
+TotalViews == 1 / TotalViews
+TotalViews < TotalViews ? Authors : 1
+len(Posts) >= TotalViews ^ 0
+(0 % TotalViews) ^ 1 ^ 0
+last(Posts)?.Author
+map(Posts, not false)
+get(Authors, TotalViews).ID
+get(Posts, TotalViews)?.Author
+all(Posts, TotalViews > 0.5)
+Authors[TotalViews + TotalViews]
+TotalViews - TotalViews > TotalViews ^ TotalViews
+-count(Posts, true)
+map(Posts, 0.5) != Posts
+!(TotalViews > 0)
+TotalViews + 1 .. TotalViews
+Posts == Posts ? TotalViews : 0
+toJSON(TotalViews / TotalViews)
+len(TotalViews .. TotalViews)
+toJSON(max(TotalViews))
+get(Authors, TotalViews)?.LastName
+TotalViews ** 2 + TotalViews
+WithID(Posts, 0)?.Content
+abs(TotalViews - TotalViews)
+last(Posts).Content
+Posts[2]?.Title
+-abs(TotalViews)
+Authors[-1]
+max(TotalViews) < TotalViews
+abs(len(Posts))
+TotalViews / 0.5 / TotalViews
+toJSON(TotalViews == nil)
+toJSON(toJSON(nil))
+Posts[0].Likes
+not (TotalViews > TotalViews)
+first(Posts)?.Content
+-(TotalViews * 0.5)
+toJSON(nil == Authors)
+true ? "JavaScript" : TotalViews in map(Posts, Posts)
+string(map(Posts, true))
+{"JavaScript": Authors}
+[Posts, Posts]
+toJSON(TotalViews <= TotalViews)
+get(Authors, 1 - TotalViews)
+get(map(Posts, Posts), TotalViews)
+string(TotalViews / 0)
+not (Posts == Posts)
+TotalViews > 0.5 * TotalViews
+TotalViews .. TotalViews % TotalViews
+get(Authors, TotalViews).Email
+string(none(Posts, false))
+toJSON(-0.5)
+TotalViews .. 1 == map(Posts, Authors)
+{"Go": Posts}
+not (0 != 0.5)
+get(Authors, TotalViews).Profile
+!(TotalViews != 0)
+WithID(Posts, TotalViews).Tags
+TotalViews > TotalViews + TotalViews
+none(Posts, TotalViews != TotalViews)
+map(map(Posts, 1), #)
+IsAdmin(Authors[TotalViews])
+!(0.5 < TotalViews)
+get(Authors, TotalViews).FirstName
+Posts[1]?.Comments
+all(Posts, TotalViews == TotalViews)
+TotalViews - TotalViews - 1
+{"Go": TotalViews}
+get(Posts, 1)?.Likes
+Authors[TotalViews].Email
+IsAdmin(get(Authors, 1))
+TotalViews ** 2 > TotalViews
+not (Posts != nil)
+string(-0.5)
+TotalViews % min(TotalViews)
+TotalViews > len(Authors)
+get(Posts, 0).Comments
+{"JavaScript": Authors}?.Website
+TotalViews ** 0 + TotalViews
+TotalViews <= -0
+{" ": nil}?.Comments
+!(false != nil)
+!(nil == Posts)
+Posts[1].Content
+lower(string(Authors))
+nil != Authors || true != false
+(TotalViews - TotalViews) % TotalViews
+Posts == Posts ? Authors : 0 * TotalViews
+0.5 != 2 ? Posts : Posts
+Authors[0].LastName
+{" ": Authors, " ": Authors, " ": Posts, "Go": false}.Birthday
+max(TotalViews - TotalViews)
+toJSON(Authors[TotalViews])
+none(map(Posts, false), #)
+not (Posts != Posts)
+get(Posts, 0).ID
+!(TotalViews != TotalViews)
+len(toJSON(Posts))
+TotalViews >= TotalViews % TotalViews
+!(TotalViews != 1)
+Title(Posts[1])
+none(Posts, "Go" > "Go")
+TotalViews * (TotalViews - TotalViews)
+toJSON(TotalViews <= 2)
+one(Posts, 0.5 == 1)
+get(map(Posts, 0), TotalViews)
+Authors[nil]?.ID
+string(nil in Posts)
+count(Posts, false) .. TotalViews
+TotalViews ** (TotalViews + 0)
+map(false ? Authors : Posts, Authors)
+last(Posts)?.Content
+2 - TotalViews == TotalViews
+TotalViews == TotalViews - 0
+none(Posts, TotalViews == 2)
+len(Authors) + TotalViews
+string(0 .. TotalViews)
+min(TotalViews + 0)
+!(TotalViews <= TotalViews)
+-TotalViews >= TotalViews
+Title(last(Posts))
+toJSON(TotalViews <= 0.5)
+int(TotalViews ^ TotalViews)
+map(Posts, TotalViews == TotalViews)
+not (Posts == nil)
+TotalViews + 0 <= TotalViews
+len(string(Authors))
+get(Posts, 2)?.Content
+min(2 - TotalViews)
+Authors[0].ID
+string(int(TotalViews))
+Posts[TotalViews:TotalViews]
+0 - TotalViews - TotalViews
+not all(Posts, true)
+-(TotalViews * TotalViews)
+-TotalViews / TotalViews
+!(nil == TotalViews)
+not (nil != Authors)
+!(TotalViews < 0.5)
+map(map(Posts, TotalViews), 0 % TotalViews)
+0 - 0.5 >= TotalViews
+filter(Posts, 0 <= 0)
+map(Posts, get(Authors, 0))
+nil == Authors[TotalViews % TotalViews]
+Authors != nil ? nil : TotalViews
+float(min(TotalViews, 0))
+count(Posts, 1 >= TotalViews)
+last(Posts).Tags
+0.5 / TotalViews > TotalViews
+get(Authors, TotalViews)?.ID
+!(0.5 >= TotalViews)
+nil == 2 ? Posts : TotalViews
+max(TotalViews * 1)
+TotalViews / TotalViews - TotalViews
+map(Posts, Posts) == Posts
+0 == TotalViews or 0 > TotalViews
+all(Posts, Posts == Posts)
+get(Posts, 2).Comments
+get(Posts, max(TotalViews))
+not (TotalViews in Authors)
+first(map(Posts, Authors))
+get(Posts, 0).PublishDate
+!(2 < 1)
+min(TotalViews, TotalViews)
+(0.5 - TotalViews) / 0 ** 0
+none(Posts, 1 == TotalViews)
+get(Authors, 0)?.ID
+float(TotalViews) - TotalViews
+toJSON(not true)
+map(Posts, nil == TotalViews)
+get(Posts, 2).Content
+any(Posts, IsZero(#))
+last(Posts).Comments
+Posts[1].Likes
+string(TotalViews * 0)
+TotalViews * TotalViews * TotalViews
+false ? true : TotalViews * TotalViews
+not ("JavaScript" matches "JavaScript")
+0 % TotalViews .. TotalViews
+!(Posts == Posts)
+TotalViews == TotalViews ? TotalViews : TotalViews
+string(TotalViews + 2)
+{"JavaScript": Posts, " ": 0.5, "JavaScript": TotalViews}.Content
+map(Posts, toJSON(Posts))
+TotalViews in 0 .. TotalViews
+!false ? Authors : Authors
+toJSON(0 * TotalViews)
+Authors[2]?.FirstName
+not (0.5 <= TotalViews)
+!(0 <= 0)
+get(Posts, TotalViews)?.Title
+false ? Authors : TotalViews in Authors ? TotalViews : 0.5
+string(max(TotalViews))
+max(0 + TotalViews, TotalViews - 2)
+map(Posts, TotalViews ** 0)
+max(1 * TotalViews)
+max(max(0))
+0 >= TotalViews ? Posts : TotalViews
+TotalViews * 0.5 * 0.5 ^ 0
+-0 ^ TotalViews
+{"Go": Posts, "JavaScript": true, "JavaScript": Authors}.Birthday
+!!true
+Authors[1 % 2]
+(0 - 0) ^ TotalViews
+TotalViews / TotalViews != TotalViews
+string(Posts == Posts)
+toJSON(TotalViews in Authors)
+get(Posts, 1)?.Content
+TotalViews - 0 % TotalViews
+!(nil != "Go")
+TotalViews * 2 % TotalViews
+map(map(Posts, Posts), TotalViews)
+2 * 2 > TotalViews
+WithID(Posts, TotalViews).Author
+int(len(Posts))
+map(Posts, TotalViews < TotalViews)
+Authors[TotalViews]?.Email
+map(Posts, 0.5 / 0)
+0.5 + 1 + TotalViews
+float(TotalViews % TotalViews)
+!(Posts != nil)
+string(!false)
+TotalViews ** 2 == TotalViews
+IsZero(WithID(Posts, TotalViews))
+int(toJSON(0))
+last(Posts).Title
+filter(Posts, Posts == nil)
+-TotalViews % TotalViews
+TotalViews + TotalViews .. TotalViews
+string(-TotalViews)
+!(2 in Posts)
+TotalViews < TotalViews ? Posts : 0.5
+-TotalViews <= TotalViews
+get(Posts, 1)?.Comments
+toJSON(0 * 0.5)
+Authors[nil].ID
+get(Authors, int(TotalViews))
+abs(abs(2))
+Posts != filter(Posts, false)
+one(map(Posts, true), #)
+map(map(Posts, TotalViews), #)
+{"Go": Authors}?.Content
+not (nil != 0.5)
+Posts == map(Posts, 0.5)
+last(map(Posts, Authors))
+Posts[1]?.ID
+IsZero(last(Posts))
+TotalViews - TotalViews ** 0
+map(Posts, string(TotalViews))
+not (TotalViews != TotalViews)
+!none(Posts, true)
+string(toJSON(Posts))
+{" ": TotalViews}
+get(Authors, 0).FirstName
+not (0 != TotalViews)
+!(2 <= TotalViews)
+0 - 0 in Authors
+get(TotalViews .. TotalViews, TotalViews)
+not ("Go" != nil)
+string(TotalViews % TotalViews)
+Title(Posts[2])
+not (0 >= TotalViews)
+TotalViews / -TotalViews
+{"JavaScript": TotalViews}
+fromJSON(toJSON(TotalViews))
+-len(Posts)
+-(TotalViews ^ 0.5)
+TotalViews <= TotalViews == false
+" " in Authors[TotalViews]
+map(map(Posts, #), Authors)
+abs(TotalViews * TotalViews)
+get(Authors, 2)?.Email
+map(map(Posts, Posts), toJSON(Posts))
+TotalViews * 0 <= 2 - TotalViews
+TotalViews in Authors == nil
+map(map(Posts, TotalViews), get(Posts, 0))
+map(Posts, first(Posts))
+TotalViews + 0 == TotalViews
+-TotalViews == TotalViews
+filter(Posts, TotalViews != TotalViews)
+TotalViews != 1 / TotalViews
+TotalViews + 0.5 <= TotalViews
+toJSON(TotalViews != 0)
+Authors[nil]?.Email
+Posts[1].Tags
+string(true == nil)
+none(Posts, nil != TotalViews)
+get(Authors, 1).ID
+get(Posts, 1).ID
+!(nil != TotalViews)
+float(TotalViews * TotalViews)
+get(Posts, TotalViews % TotalViews)
+one(map(Posts, Posts), 0 in Posts)
+Posts[1]?.Content
+TotalViews * int(0.5)
+string(toJSON(TotalViews))
+get(Posts, 1)?.Tags
+0 ** TotalViews / TotalViews
+all(Posts, false && false)
+map(map(Posts, 0), TotalViews)
+TotalViews <= 1 ^ TotalViews
+Authors[0 * 0]
+TotalViews <= TotalViews / 0.5
+string(TotalViews / TotalViews)
+TotalViews != 0 + 1
+{"Go": TotalViews, "Go": Authors, "Go": TotalViews}.Content
+TotalViews ^ TotalViews ** TotalViews
+first(map(Posts, Posts))
+!(Posts != Posts)
+WithID(Posts, 0)?.Comments
+map(map(Posts, "Go"), TotalViews)
+TotalViews > 0.5 ^ TotalViews
+count(Posts, TotalViews == 0.5)
+TotalViews ^ (0 / 0)
+map(Posts, last(Posts))
+WithID(Posts, TotalViews)?.Tags
+get(Posts, -1)
+min(0 + 0)
+TotalViews * TotalViews <= TotalViews
+len(Authors) in Authors
+Authors == nil ? Posts : TotalViews
+Posts != nil ? Authors : TotalViews
+one(Posts, TotalViews < TotalViews)
+!none(Posts, false)
+Posts[0].Author
+TotalViews != 0 ? TotalViews < TotalViews : Posts
+Authors[nil].Email
+get(Authors, 2)?.Profile
+{"JavaScript": Posts}?.ID
+first(Posts)?.Author
+not (0 < 0.5)
+first(filter(Posts, false))
+Posts[2]?.Tags
+TotalViews * TotalViews != TotalViews
+not (TotalViews < 0.5)
+filter(Posts, 0 == TotalViews)
+TotalViews ** 1 == TotalViews
+-(0 / TotalViews)
+abs(-TotalViews)
+TotalViews == nil == nil
+map(map(Posts, 0.5), Posts)
+not (1 < TotalViews)
+TotalViews ^ -TotalViews
+Posts == Posts[TotalViews:TotalViews]
+Authors == Authors ? "Go" : Posts
+all(Posts, 2 >= TotalViews)
+TotalViews - TotalViews >= Authors[TotalViews].ID
+not (0 < TotalViews)
+map(Posts, TotalViews .. 0)
+max(TotalViews % TotalViews)
+toJSON(!false)
+map(Posts, TotalViews / 1)
+all(Posts, TotalViews in Posts)
+max(TotalViews + TotalViews)
+not (true or false)
+float(TotalViews) * TotalViews
+get(Authors, TotalViews)?.Profile
+TotalViews <= 0 % TotalViews
+TotalViews > TotalViews ? Posts : Authors[TotalViews]
+any(Posts, TotalViews in Posts)
+filter(Posts, none(Posts, false))
+IsZero(first(Posts))
+map(Posts, TotalViews >= TotalViews)
+nil != TotalViews ? TotalViews : map(Posts, TotalViews)
+abs(-0.5)
+TotalViews == TotalViews % TotalViews
+first(Posts)?.Comments
+WithID(Posts, TotalViews)?.Author
+one(Posts, nil != 1)
+first(Posts)?.Tags
+map(Posts, #?.Tags)
+Posts[1]?.Likes
+TotalViews >= TotalViews ? TotalViews : " "
+all(Posts, false) ? last(Posts) : TotalViews
+TotalViews ** (TotalViews * 1)
+TotalViews != -TotalViews
+-(0 + 0)
+Posts[0]?.Comments
+count(Posts, nil != Posts)
+(0.5 + TotalViews) ** TotalViews
+TotalViews - TotalViews in Authors
+IsAdmin(Authors[nil])
+one(Posts, 0 <= 1)
+2 ** 0.5 > TotalViews ** 1
+any(Posts, nil in Posts)
+!(2 < 0)
+TotalViews < TotalViews != false
+{"JavaScript": Posts, "Go": "JavaScript"}.Birthday
+abs(TotalViews) >= TotalViews
+count(Posts, true) % TotalViews
+!(TotalViews < 1)
+filter(map(Posts, 0.5), TotalViews >= TotalViews)
+toJSON(0 ^ 2)
+TotalViews / (2 - 1)
+toJSON(first(Posts))
+TotalViews ^ 0 != TotalViews
+string(-(TotalViews * TotalViews))
+TotalViews != 0 / TotalViews
+toJSON(get(Authors, TotalViews))
+float(float(0))
+get(Posts, 1).Likes
+count(Posts, Posts != Posts)
+first(true ? Posts : Authors)
+-min(TotalViews)
+--0.5
+max(TotalViews ^ TotalViews)
+0.5 >= TotalViews ? Authors : TotalViews * TotalViews
+first(Posts[TotalViews:TotalViews])
+(TotalViews * TotalViews) ^ TotalViews
+map(Posts, abs(TotalViews))
+TotalViews == int(TotalViews)
+Authors[0]?.LastName
+not (0.5 < 1)
+TotalViews != 0.5 + TotalViews
+toJSON(TotalViews % TotalViews)
+true ? Authors : TotalViews % TotalViews
+one(Posts, Authors != Authors)
+[get(Authors, TotalViews)]
+not (0.5 != TotalViews)
+get(Posts, 1).Comments
+TotalViews + 0 in Posts
+0.5 ^ 1 <= TotalViews
+Posts[0]?.Likes
+first(Posts)?.PublishDate
+string(true ? TotalViews : TotalViews)
+int(1 / 0)
+0 * 1 * TotalViews
+-(TotalViews / TotalViews)
+Authors[0]?.Profile
+max(TotalViews ^ 0)
+not false ? nil : Posts
+count(Posts, true) * TotalViews
+filter(Posts, 0 >= 0.5)
+all(Posts, Authors == Authors)
+TotalViews >= 0.5 ^ TotalViews
+get(Posts, 2).ID
+{"Go": TotalViews, "Go": TotalViews, "JavaScript": Authors, " ": Authors, "JavaScript": TotalViews}?.Title
+last(Posts)?.Tags
+TotalViews <= TotalViews / 0
+Authors != Authors == one(Posts, false)
+TotalViews in Posts ? "Go" : Authors
+TotalViews + 0 ^ TotalViews
+first(TotalViews .. TotalViews)
+get(Posts, TotalViews - TotalViews)
+string(TotalViews + TotalViews)
+none(Posts, TotalViews == TotalViews)
+min(-TotalViews)
+last(Posts).ID
+Posts[0].ID
+none(Posts, TotalViews <= TotalViews)
+string(map(Posts, Posts))
+get(TotalViews .. 0, TotalViews)
+one(Posts, TotalViews in Posts)
+get(Authors, 1)?.ID
+none(map(Posts, Posts), Posts == Posts)
+toJSON(TotalViews > 0)
+Posts[0]?.ID
+TotalViews / (TotalViews - 0)
+TotalViews / (TotalViews + TotalViews)
+TotalViews in Authors and TotalViews <= TotalViews
+map(Posts, Authors[TotalViews])
+int(1 * TotalViews)
+all(Posts, 2 == TotalViews)
+max(TotalViews, TotalViews)
+toJSON(get(Posts, TotalViews))
+{"JavaScript": TotalViews == TotalViews}
+min(0, TotalViews) ** TotalViews
+toBase64(string(Posts))
+TotalViews != 0 ** TotalViews
+count(Posts, TotalViews >= TotalViews)
+first(Posts).ID
+{"JavaScript": Authors, "Go": Authors}?.Likes?.ID
+TotalViews - TotalViews * TotalViews
+toJSON(map(Posts, Authors))
+{" ": Posts}
+float(TotalViews / 0)
+!(TotalViews == 1)
+TotalViews != TotalViews - TotalViews
+last(Posts)?.ID
+TotalViews == float(0.5)
+TotalViews ** (0 / TotalViews)
+count(Posts, !(TotalViews <= TotalViews))
+get(Authors, -0)
+Authors[nil]?.LastName
+toJSON(Authors == Authors)
+IsAdmin(get(Authors, 0))
+abs(TotalViews) <= TotalViews
+TotalViews == -TotalViews
+int(0 + 0)
+all(Posts, "JavaScript" < "Go")
+TotalViews >= 0 - TotalViews
+map(filter(Posts, false), TotalViews)
+string(TotalViews - TotalViews)
+!all(Posts, false)
+TotalViews == 1 ? 1 : Authors
+map(Posts, TotalViews ** 2)
+Posts[2]?.Likes
+-(0 ^ 0)
+TotalViews ** (1 - TotalViews)
+TotalViews > 0 ^ 0.5
+last(map(Posts, "JavaScript"))
+not (2 != 0.5)
+!(TotalViews > 1)
+get(Authors, 0).ID
+max(TotalViews * 0)
+Authors[nil].LastName
+string(map(Posts, 0.5))
+map(map(Posts, TotalViews), TotalViews)
+Authors[0 + TotalViews]
+1 % TotalViews / TotalViews
+len(string(Posts))
+string(0 >= 0.5)
+(1 * TotalViews) ^ TotalViews
+!(1 > 0.5)
+not (1 in Authors)
+-0 <= TotalViews / 0.5
+{" ": false, "Go": TotalViews}.FirstName
+TotalViews ** 0 ^ TotalViews
+toJSON(-TotalViews)
+string(TotalViews >= 2)
+int(TotalViews * TotalViews)
+TotalViews % TotalViews >= TotalViews
+get(map(Posts, Authors), TotalViews)
+TotalViews > TotalViews ** TotalViews
+WithID(Posts, TotalViews).ID
+TotalViews + 0.5 ^ TotalViews
+map(Posts, int(0))
+toJSON(1 > TotalViews)
+WithID(Posts, TotalViews).Comments
+len("JavaScript") > TotalViews
+Title(WithID(Posts, 0))
+string(Authors == nil)
+WithID(Posts, TotalViews).PublishDate
+-(2 ** 0)
+string(false ? Posts : false)
+string(2 == 0.5)
+count(TotalViews .. TotalViews, TotalViews != TotalViews)
+!(true != true)
+get(Posts, 0)?.Content
+one(Posts, Posts != Posts)
+map(TotalViews .. TotalViews, TotalViews)
+count(Posts, TotalViews != 0)
+string(Authors[TotalViews])
+len(toJSON(2))
+upper(string(" "))
+map(Posts, Authors) != Posts
+not (nil != Posts)
+Title(get(Posts, 2))
+WithID(Posts, 0).Author.FirstName
+Authors[0]?.FirstName
+not (true || false)
+int(string(TotalViews))
+-(0.5 ^ TotalViews)
+TotalViews > TotalViews ? Authors : TotalViews
+IsZero(get(Posts, 2))
+map(Posts, count(Posts, true))
+toJSON(0.5 < TotalViews)
+string(2 < TotalViews)
+not (TotalViews > 0.5)
+not (" " > "JavaScript")
+any(Posts, Authors == Authors)
+TotalViews in TotalViews .. 0
+-(0.5 / TotalViews)
+-(TotalViews ^ TotalViews)
+0 ** 0.5 + abs(TotalViews)
+-1 in Posts
+one(Posts, 0 < TotalViews)
+TotalViews * TotalViews ** TotalViews
+!(0 in Authors)
+map(filter(Posts, true), #)
+get(map(Posts, "Go"), TotalViews)
+string(TotalViews % 1)
+!(TotalViews in Posts)
+toJSON(TotalViews ** 1)
+count(Posts, TotalViews in Authors)
+float(toJSON(TotalViews))
+-float(TotalViews)
+Title(first(Posts))
+int(TotalViews) > TotalViews
+map(filter(Posts, false), 0 < 2)
+TotalViews <= TotalViews * 2
+map(map(Posts, "JavaScript"), Posts)
+any(Posts, TotalViews <= TotalViews)
+count(Posts, nil == nil)
+WithID(Posts, 0).Content
+TotalViews - min(0.5)
+map(Posts, Posts[0])
+map(map(Posts, Posts), #)
+0.5 + 0 + min(TotalViews)
+TotalViews in map(Posts, Authors)
+TotalViews != TotalViews ? TotalViews : nil
+Authors[1].LastName
+not (TotalViews == nil)
+0 - TotalViews in Posts
+get(Posts, 2 - TotalViews)
+none(Posts, TotalViews in Posts)
+TotalViews * abs(TotalViews)
+0.5 <= TotalViews or TotalViews > TotalViews
+get(false ? Authors : Authors, TotalViews % TotalViews)
+{" ": Posts}?.ID
+map(Posts, TotalViews in Authors)
+abs(TotalViews) != TotalViews
+min(TotalViews * TotalViews)
+first(Posts).PublishDate
+false ? true : TotalViews in Posts
+not all(Posts, false)
+count(Posts, 0 == 2)
+true ? Authors : TotalViews == TotalViews
+!(TotalViews != nil)
+{" ": TotalViews - 2}
+string(Authors[0])
+max(abs(0))
+TotalViews / TotalViews / TotalViews ^ TotalViews
+!(TotalViews <= 0)
+TotalViews ** (TotalViews - TotalViews)
+WithID(Posts, TotalViews).Content
+TotalViews ** TotalViews ** TotalViews
+TotalViews in Authors ? Posts : Posts
+{" ": false}?.Profile
+TotalViews ** (TotalViews * 2)
+TotalViews ^ 0 + TotalViews ^ TotalViews
+map(map(Posts, TotalViews), Posts)
+TotalViews + TotalViews / 0.5
+get(Posts, 2)?.Title
+0.5 ^ TotalViews ^ TotalViews
+TotalViews > -TotalViews
+string(0 > TotalViews)
+map(Posts, .ID)
+{"JavaScript": 1, " ": Authors}?.Biography
+not (TotalViews == 1)
+string(string(" "))
+map(Posts, 1 ^ TotalViews)
+toJSON("Go" matches "Go")
+filter(Posts, TotalViews in Posts)
+TotalViews in map(Posts, Posts)
+one(map(Posts, false), #)
+map(Posts, -TotalViews)
+{" ": Posts, "Go": Authors}.Author
+TotalViews * TotalViews / TotalViews
+IsZero(get(Posts, 0))
+one(Posts, TotalViews <= TotalViews)
+last(Posts).Likes
+!!false
+map(map(Posts, Authors), TotalViews > TotalViews)
+float(len(Authors))
+float(float(TotalViews))
+Authors[2]?.ID
+get(Posts, 2)?.Author
+min(len(Posts))
+!one(Posts, true)
+2 - TotalViews != TotalViews
+false ? Authors : TotalViews / int(TotalViews)
+map(false ? false : Posts, Posts)
+toJSON(one(Posts, false))
+WithID(Posts, TotalViews)?.Content
+!(0 >= 0)
+max(count(Posts, true))
+TotalViews <= len(Posts)
+TotalViews == TotalViews or 0 == TotalViews
+count(Posts, TotalViews == 2)
+Authors != Authors ? TotalViews : 0
+int(TotalViews) ^ TotalViews
+not (1 > 0)
+-(TotalViews - TotalViews)
+{"JavaScript": Posts}.PublishDate
+float(TotalViews / TotalViews)
+map(TotalViews .. 0, Posts)
+last(map(Posts, TotalViews))
+{"JavaScript": Add(0, 0)}
+abs(TotalViews + 1)
+not (Authors != Authors)
+Authors[0].FirstName
+toJSON(TotalViews + 0)
+--max(2)
+{"JavaScript": Authors, " ": Posts, " ": TotalViews}.Author
+not (TotalViews < 1)
+0 ^ 2 > count(Posts, false)
+not ("Go" contains "JavaScript")
+len(Posts) ** TotalViews
+abs(TotalViews ** 0)
+map(Posts, .Author)
+get(Posts, len(Posts))
+toJSON(min(2))
+-(0.5 - TotalViews)
+count(Posts, Authors == Authors)
+{"JavaScript": TotalViews}.Website
+TotalViews <= TotalViews && TotalViews > TotalViews
+count(map(Posts, TotalViews), TotalViews < TotalViews)
+!(TotalViews >= 0)
+string(Authors) matches string(false)
+TotalViews ^ TotalViews * TotalViews
+one(Posts, Authors == nil)
+string(len(Posts))
+float(2 / TotalViews)
+(0 % 2) ** TotalViews
+get(Posts, 2).Author
+Posts[0]?.Author
+get(Authors, 2).LastName
+not (1 == TotalViews)
+"JavaScript" < "JavaScript" == nil ? TotalViews : Posts
+-TotalViews in Authors
+abs(1 ** 0)
+get(Posts, 0)?.ID
+get(Posts, 0 * 2)
+min(TotalViews % TotalViews)
+nil != Authors || nil == 0.5
+{"Go": "JavaScript"}.ID
+none(Posts, 0 != TotalViews)
+Authors[abs(0)]
+map(Posts, Authors == Authors)
+map(Posts, TotalViews > TotalViews)
+map(Posts, 2 ** 2)
+string(2 > TotalViews)
+Posts[2].Title
+none(Posts, Authors != Authors)
+not (TotalViews > 0)
+TotalViews > TotalViews != nil
+toJSON(toJSON(TotalViews))
+toJSON({"JavaScript": TotalViews})
+Authors[0].Profile
+map(Posts, Authors != Authors)
+TotalViews / (TotalViews + 0.5)
+-TotalViews ^ TotalViews
+last(Posts).PublishDate
+one(map(Posts, TotalViews), 1 != TotalViews)
+not (TotalViews <= 0.5)
+TotalViews <= TotalViews * TotalViews
+min(len("Go"))
+!(nil == 1)
+TotalViews ** TotalViews == TotalViews
+TotalViews .. 2 % TotalViews
+lower(toJSON(Posts))
+any(Posts, Posts != Posts)
+toJSON(TotalViews - 0)
+TotalViews * 2 ** TotalViews
+0.5 / 0 - TotalViews - 1
+int(0 + 2)
+Posts[TotalViews % TotalViews]
+max(0.5 + TotalViews)
+0 + TotalViews in Posts
+[0 in Authors]
+IsZero(Posts[0])
+[map(Posts, TotalViews)]
+one(Posts, 0 != nil)
+TotalViews ^ 0.5 ** (0 / 0)
+TotalViews >= abs(TotalViews)
+filter(Posts, 0 in Posts)
+TotalViews > TotalViews and TotalViews in Authors
+last(map(Posts, 0.5))
+TotalViews != TotalViews ? Authors : 0
+string(2 > 0)
+2 ^ TotalViews ** TotalViews
+TotalViews .. 0 + 2
+{"JavaScript": TotalViews, " ": Posts}.FirstName
+toJSON(Posts == Posts)
+not one(Posts, true)
+Authors[2]?.Profile
+min(TotalViews) - TotalViews
+map(Posts, 0 .. TotalViews)
+map(map(Posts, " "), TotalViews)
+TotalViews in map(Posts, TotalViews)
+TotalViews % TotalViews <= TotalViews
+map(Posts, len(Authors))
+-min(2)
+filter(Posts, !false)
+string(TotalViews ^ TotalViews)
+int(TotalViews) > TotalViews ? Authors : Posts
+TotalViews ^ 0 != TotalViews / TotalViews
+float(TotalViews / 2)
+none(Posts, Authors == Authors)
+-max(TotalViews)
+map(Posts, Authors) == map(Posts, Authors)
+TotalViews == TotalViews ? "Go" : TotalViews
+!(0 > TotalViews)
+TotalViews ** TotalViews - TotalViews
+2 - 0.5 <= TotalViews ? nil : nil
+filter(Posts, TotalViews <= 1)
+not (0.5 == 2)
+map(Posts, 0.5 ** 2)
+toJSON(2 >= 0)
+count(Posts, 0.5 >= TotalViews)
+all(Posts, TotalViews < 0)
+toJSON(1 > 0.5)
+filter(Posts, TotalViews == TotalViews)
+first(Posts)?.Likes
+get(Posts, 2).PublishDate
+Posts != nil ? Posts : true
+abs(TotalViews / 0)
+int(TotalViews ** TotalViews)
+string(none(Posts, true))
+{"JavaScript": Authors, " ": Authors}.ID
+min(TotalViews ^ 0.5)
+{"JavaScript": 0.5}.Comments
+get(Authors, 0).LastName
+{"JavaScript": TotalViews}?.PublishDate
+TotalViews - TotalViews + 0.5
+float(abs(TotalViews))
+map(Posts, 2 .. TotalViews)
+any(Posts, TotalViews in Authors)
+map(map(Posts, Posts), map(Posts, false))
+one(Posts, 0 < 1)
+map(Posts, map(Posts, false))
+Posts[-1]
+float(string(TotalViews))
+TotalViews % (0 + 1)
+TotalViews ^ (TotalViews + 2)
+any(Posts, 0 < 0)
+any(Posts, TotalViews > 1)
+abs(TotalViews) in map(Posts, Authors)
+float(TotalViews ^ TotalViews)
+all(Posts, nil == TotalViews)
+all(Posts, TotalViews in Authors)
+max(min(TotalViews))
+TotalViews < 2 / TotalViews
+max(len(Posts), TotalViews)
+min(-(TotalViews % TotalViews))
+count(Posts, true) / TotalViews
+fromJSON(toJSON(0.5))
+TotalViews >= 0 ^ TotalViews
+int(2 ^ TotalViews)
+not (0 <= 1)
+!(TotalViews >= 0.5)
+min(TotalViews ** TotalViews)
+TotalViews ** TotalViews != TotalViews / 0
+map(Posts, map(Posts, TotalViews))
+!(0 < TotalViews)
+0 in Posts ? TotalViews : Authors
+abs(2 - TotalViews)
+TotalViews .. TotalViews - 0
+not (" " matches " ")
+any(Posts, TotalViews < TotalViews)
+Authors[1]?.Email
+TotalViews < 0.5 * TotalViews
+map(Posts, #?.ID)
+get(Authors, -(TotalViews + TotalViews))
+not (TotalViews < 2)
+get(Posts, abs(TotalViews))
+TotalViews * 0 == TotalViews
+TotalViews / TotalViews < TotalViews
+get(Posts, 2)?.Comments
+filter(Posts, true != nil)
+[1 ** 0]
+max(abs(TotalViews))
+string(max(1))
+(2 - TotalViews) / TotalViews
+TotalViews != TotalViews ^ TotalViews
+TotalViews != 0.5 ? Posts : Posts
+min(1 ** 0.5, min(TotalViews))
+-max(0.5, TotalViews)
+string(get(Posts, 1))
+none(Posts, 0 >= TotalViews)
+TotalViews > count(Posts, true)
+none(Posts, nil == TotalViews)
+any(Posts, 0 >= TotalViews)
+{"Go": TotalViews}.Content?.Likes
+map(Posts, TotalViews % TotalViews)
+float(1) ** TotalViews
+int(TotalViews ** 1)
+TotalViews >= TotalViews + 1
+TotalViews * TotalViews / 1
+len(Authors) ^ TotalViews
+any(Posts, !false)
+Authors[1]?.ID
+Posts[0].Comments
+Authors != Authors && TotalViews <= TotalViews
+max(-0.5)
+all(Posts, nil != 1)
+last(filter(Posts, true))
+min(int(TotalViews))
+Posts[2]?.ID
+map(0 .. 0, TotalViews)
+last(Posts[TotalViews:TotalViews])
+abs(2 ^ 0.5)
+WithID(Posts, 1).Likes
+int(min(1))
+int(false ? TotalViews : TotalViews)
+TotalViews + 0 ** TotalViews
+float(0 % TotalViews)
+map(Posts, .Title)
+Authors != Authors && TotalViews > TotalViews
+not true ? 0 : 0.5
+(TotalViews % TotalViews) ** TotalViews
+0 + TotalViews - TotalViews
+TotalViews * 1 .. TotalViews
+string(Authors != Authors)
+int(TotalViews - 0)
+map(Posts, !true)
+string(max(max(TotalViews)))
+min(TotalViews) ^ TotalViews
+!(1 != nil)
+!("Go" != " ")
+map(TotalViews .. TotalViews, Posts)
+-(0 / 0.5)
+string(map(Posts, 1))
+{"JavaScript": Posts, "Go": " "}?.PublishDate
+not (nil != nil)
+-(TotalViews % 2)
+one(Posts, 1 in Posts)
+TotalViews < TotalViews ** TotalViews
+len(true ? Posts : TotalViews)
+map(Posts, count(Posts, false))
+toJSON(2 ^ 1)
+{"JavaScript": Authors}?.AuthorName
+get(Authors, 0).Profile
+TotalViews / 0 > max(0)
+TotalViews - TotalViews * 2
+-(TotalViews % 1)
+{"JavaScript": 0 == TotalViews}
+TotalViews * TotalViews ^ TotalViews
+max(0.5) != 0 ? TotalViews : true
+TotalViews + TotalViews ** 0.5
+Title(get(Posts, 1))
+min(TotalViews) in filter(Posts, false)
+string(not true)
+len(toJSON(TotalViews))
+TotalViews * TotalViews == TotalViews * TotalViews
+-(0.5 ** 0)
+TotalViews <= abs(TotalViews)
+min(TotalViews + TotalViews)
+all(map(Posts, 0.5), TotalViews < 2)
+string(TotalViews - 1)
+(TotalViews + 0) % TotalViews
+{" ": Authors}?.Content
+len(string(TotalViews))
+not (nil == TotalViews)
+map(map(Posts, TotalViews), Authors)
+toJSON(TotalViews / 2)
+one(map(Posts, Posts), none(Posts, false))
+max(max(0.5))
+toJSON(false ? Authors : Posts)
+Title(get(Posts, 0))
+min(min(TotalViews))
+trim(toJSON(" "))
+max(TotalViews / TotalViews)
+map(Posts, # != WithID(Posts, TotalViews))
+min(max(0))
+map(Posts, true and false)
+(TotalViews / 0) ^ TotalViews
+{" ": TotalViews, " ": TotalViews}?.Comments
+float(count(Posts, false))
+string(WithID(Posts, TotalViews))
+TotalViews >= -0
+all([true, Posts], TotalViews <= TotalViews)
+Posts == Posts ? Authors : 0.5
+!true ? true : TotalViews
+not any(Posts, true)
+2 + 0 .. TotalViews
+!(0.5 == nil)
+{"JavaScript": Posts, " ": Posts}.Biography
+TotalViews >= 0.5 - TotalViews
+first(map(Posts, TotalViews))
+TotalViews ^ (1 / TotalViews)
+count(Posts, 0.5 >= 1)
+{"JavaScript": TotalViews}.ID
+all(Posts, any(Posts, false))
+TotalViews != 0 == false
+map(Posts, get(Posts, 0))
+count(Posts, nil in Authors)
+int(-TotalViews)
+none(Posts, 0 < TotalViews)
+toJSON(0 in Authors)
+toJSON(trim("Go"))
+toJSON(int(2))
+-len("JavaScript")
+!(nil != Authors)
+get(Posts, 0).Tags
+string(get(Authors, TotalViews))
+Posts[0]?.Content
+TotalViews / 0 / TotalViews
+not (1 > TotalViews)
+first(Posts)?.Title
+!not false
+get(Posts, 1)?.Title
+all(Posts, one(Posts, false))
+Posts[0].Tags
+toJSON(Posts[0])
+Posts[2].Likes
+TotalViews - min(TotalViews)
+-(0.5 - 0)
+toJSON(TotalViews - TotalViews)
+WithID(Posts, 0 - TotalViews)
+false ? TotalViews : TotalViews > TotalViews
+filter(Posts, nil == Authors)
+!true and Authors == Authors
+-0.5 ^ TotalViews ** TotalViews
+TotalViews - 1 ** TotalViews
+not (2 > TotalViews)
+TotalViews >= -TotalViews
+TotalViews ^ TotalViews > TotalViews ? TotalViews : Posts
+0 * 0 * TotalViews
+not (nil in Authors)
+Posts[0]?.PublishDate
+TotalViews ** 0.5 / TotalViews
+not (0.5 > 0.5)
+{"Go": TotalViews < 0}?.Author
+-len(Authors)
+0.5 ^ TotalViews - TotalViews
+!not true
+TotalViews == TotalViews + 0
+Authors[nil]?.Profile
+TotalViews != 0 ^ TotalViews
+-1 in Authors
+TotalViews <= 1 ? Authors : Authors
+2 + TotalViews + TotalViews
+string({" ": Authors})
+map(Posts, trim(string(nil)))
+int(TotalViews - TotalViews)
+toBase64(string(Authors))
+max(TotalViews * TotalViews)
+not ("JavaScript" != nil)
+float(0 + 2)
+IsZero(get(Posts, 1))
+TotalViews * len(Posts)
+string(true ? TotalViews : Posts)
+float(-TotalViews)
+0 ^ 0 - TotalViews
+TotalViews != 1 ? false : 0
+toJSON(map(Posts, Posts))
+min(abs(0))
+len(map(Posts, Authors))
+get(false ? Authors : 0, TotalViews)
+last(Posts[1:TotalViews])
+none(Posts, TotalViews != nil)
+filter(Posts, 0 in Authors)
+map(Posts, 0 + TotalViews)
+map(Posts, Posts[1])
+TotalViews - TotalViews >= -TotalViews
+0.5 ** TotalViews <= TotalViews
+Authors == nil ? "Go" : true
+int(TotalViews) < TotalViews
+max(min(0.5, 0))
+any(Posts, none(Posts, TotalViews != nil))
+one(Posts, nil != Authors)
+string(nil == "JavaScript")
+none(Posts, nil != Posts)
+!(0 != nil)
+TotalViews == 1 ^ TotalViews
+TotalViews * (TotalViews - 0)
+not true ? Authors : TotalViews
+TotalViews != TotalViews ? -TotalViews : Authors
+TotalViews + TotalViews / 2
+map(0 .. TotalViews, #)
+TotalViews ** (TotalViews / TotalViews)
+any(Posts, TotalViews > TotalViews)
+abs(min(TotalViews))
+TotalViews >= int(TotalViews)
+lower(true ? "Go" : Posts)
+max(1 / TotalViews) > TotalViews
+map(Posts, TotalViews % 2)
+int(toJSON(TotalViews))
+string(toJSON(false))
+!(0.5 <= 2)
+upper(string(false))
+first(Posts).Comments
+Posts[0]?.Title
+len(0 .. TotalViews)
+WithID(Posts, 1).ID
+Authors == Authors && nil in Posts
+{"Go": Authors, " ": Posts}?.Birthday
+any(Posts, 1 > 0)
+!(TotalViews != 0.5)
+last(Posts)?.Author.FirstName
+{"JavaScript": 0.5, " ": 0}.Tags
+get(Authors, 1).Email
+max(int(TotalViews))
+TotalViews ** 0 != TotalViews
+all(Posts, 0 == TotalViews)
+int(TotalViews / 0)
+not (TotalViews <= TotalViews)
+map(Posts, int(1))
+toJSON(0 in Posts)
+count(Posts, true) != TotalViews
+map(Posts, .Likes)
+get(Posts, 1).Content
+TotalViews / TotalViews / (0 - 0)
+[false ? Posts : Posts]
+get(Posts, 1).Author
+TotalViews + 0.5 >= -2
+Authors == Authors ? TotalViews : Posts
+one(Posts, TotalViews == TotalViews)
+toJSON(TotalViews != TotalViews)
+toJSON(TotalViews >= TotalViews)
+TotalViews + TotalViews ^ 0
+not (TotalViews != 0.5)
+TotalViews < TotalViews ^ TotalViews
+map(Posts[0:TotalViews], TotalViews)
+IsZero(Posts[1])
+!(0 <= TotalViews)
+TotalViews / TotalViews >= TotalViews + TotalViews
+none(TotalViews .. 0, Posts == Posts)
+toJSON(float(0))
+!(TotalViews <= 0.5)
+count(Posts, 2 >= 0.5)
+Authors[-TotalViews]
+{"Go": Authors, "Go": false}?.ID
+count(Posts, true) <= TotalViews ? TotalViews : Posts
+string(0 % TotalViews)
+{"Go": 2, " ": nil, "JavaScript": TotalViews, "JavaScript": "JavaScript"}.Birthday
+toJSON(filter(Posts, true))
+[Posts != Posts]
+Posts[2].Author
+get(Posts[TotalViews:TotalViews], TotalViews)
+TotalViews + TotalViews != TotalViews
+toBase64(string("Go"))
+one(Posts, 0 == 2)
+max(0 ** 1)
+int(TotalViews ** 0)
+map(map(Posts, true), TotalViews / TotalViews)
+filter(Posts, 1 >= TotalViews)
+TotalViews % TotalViews % TotalViews
+float(int(TotalViews))
+TotalViews * 0 ^ 0.5
+none(map(Posts, Authors), TotalViews == 0.5)
+TotalViews * TotalViews in map(Posts, 0)
+abs(0.5 + 2)
+filter(Posts, TotalViews < TotalViews)
+get(Posts, TotalViews + 0)
+{"JavaScript": true}?.Content
+TotalViews == nil ? TotalViews : Authors
+!(false and true)
+not ("JavaScript" == nil)
+last(TotalViews .. TotalViews)
+TotalViews < TotalViews % TotalViews
+TotalViews in Posts ? Posts : " "
+max(TotalViews + 1)
+string(2 in Posts)
+one(Posts, Authors == Authors)
+Posts != Posts ? TotalViews : TotalViews
+TotalViews - 0 + TotalViews
+map(Posts, TotalViews ** TotalViews)
+TotalViews ^ TotalViews / 0 ** TotalViews
+not (nil != TotalViews)
+TotalViews - TotalViews .. TotalViews
+!(nil == 0)
+!(1 <= TotalViews)
+int(TotalViews) + TotalViews
+get(Authors, 2)?.ID
+TotalViews <= 0 != false
+map(map(Posts, 0.5), #)
+get(Posts, 2)?.PublishDate
+abs(TotalViews) + TotalViews
+float(TotalViews) <= TotalViews
+IsAdmin(Authors[2])
+Authors[-2]
+map(Posts, 0 > 0.5)
+string(true ? " " : "JavaScript")
+!IsZero(Posts[1])
+-0 > TotalViews
+abs(TotalViews + TotalViews)
+Posts == map(Posts, Posts)
+abs(-0)
+0 - TotalViews < TotalViews
+Authors != nil ? Authors : splitAfter("Go", nil)
+one(map(Posts, Posts), 0 > 0.5)
+not true ? Posts : "Go"
+-0.5 ^ TotalViews
+(TotalViews - TotalViews) ** TotalViews
+float(int(0))
+!("JavaScript" matches "JavaScript")
+not (Authors == nil)
+-0.5 > TotalViews
+get(map(Posts, 1), TotalViews)
+TotalViews == TotalViews + TotalViews
+filter(Posts, TotalViews <= 0)
+TotalViews % (TotalViews + 1)
+{" ": Posts}.CommentDate
+2 + 0 - TotalViews
+Posts[2].Comments
+any(Posts, 0 in Posts)
+count(Posts, TotalViews == 0)
+{"JavaScript": TotalViews}?.FirstName
+min(0.5 + TotalViews)
+max(-TotalViews)
+map(filter(Posts, true), TotalViews)
+TotalViews / 0 - TotalViews
+max(TotalViews - 0)
+get(Posts, 1)?.ID
+false ? TotalViews : 0 >= TotalViews
+-int(1)
+one(map(Posts, TotalViews), TotalViews >= TotalViews)
+last(true ? Posts : 0)
+not any(Posts, false)
+{" ": " ", "Go": 1}?.Upvotes
+get(Authors, 0)?.LastName
+TotalViews ^ 2 ** 0
+string(nil == TotalViews)
+not (0 > 2)
+not true ? map(Posts, Posts) : Posts
+TotalViews >= min(TotalViews)
+Posts != Posts || TotalViews <= TotalViews
+get(Posts, 2 % TotalViews)
+map(TotalViews .. TotalViews, Authors)
+int(2) > len(" ")
+TotalViews <= TotalViews - TotalViews
+TotalViews - TotalViews - TotalViews
+last(TotalViews .. 1)
+string(TotalViews) in first(Posts)
+TotalViews <= 0.5 + TotalViews
+Authors[nil]?.FirstName
+TotalViews - int(0)
+get(Posts, 0).Author
+all(Posts, Authors != Authors)
+get(false ? 2 : Posts, TotalViews)
+not (0.5 <= 0)
+max(TotalViews) == TotalViews
+TotalViews ^ max(0)
+toJSON(get(Posts, 0))
+map(Posts, 2 ** TotalViews)
+float(TotalViews) / TotalViews ** 1
+!(0.5 < 0)
+get(Authors, 2).ID
+TotalViews / 1 ** 1
+last(Authors == Authors ? true : "Go")
+count(map(Posts, false), #)
+all(Posts, TotalViews < 1)
+TotalViews % TotalViews == max(TotalViews)
+all(Posts, !false)
+{"JavaScript": 0}.CommentDate
+{"Go": true, "Go": nil}?.Email
+float(get(Authors, TotalViews).ID)
+TotalViews ^ (0 + TotalViews)
+Authors[1].ID
+count(Posts, TotalViews < TotalViews)
+!(0 == 0)
+float(max(TotalViews))
+-TotalViews - TotalViews
+TotalViews == 2 + TotalViews
+float(TotalViews) / TotalViews
+TotalViews / count(Posts, true)
+min(TotalViews / TotalViews)
+count(Posts, TotalViews > 0)
+map(Posts[TotalViews:TotalViews], Authors)
+toJSON(TotalViews <= 0)
+get(Authors, 0).Email
+string(0 != nil)
+string(Posts != Posts)
+Posts != Posts ? false : 0
+-(0 * TotalViews)
+-float(0.5)
+Posts != map(Posts, "JavaScript")
+TotalViews <= 0.5 / 0.5
+-(1 + TotalViews)
+TotalViews != nil ? Posts : "Go"
+max(0) * TotalViews
+TotalViews / min(TotalViews)
+count(Posts, true == false)
+TotalViews != TotalViews ? 0 : Authors
+WithID(Posts, TotalViews).Likes
+TotalViews % TotalViews in map(Posts, Posts)
+{"Go": TotalViews}.Likes
+one(Posts, 0.5 <= 0.5)
+TotalViews >= 0.5 + 1
+TotalViews > TotalViews ? nil : nil
+abs(TotalViews - 0)
+TotalViews > TotalViews - 0
+toJSON(TotalViews * 0)
+get(Authors, 0 + 2)
+max(TotalViews) ^ TotalViews
+Posts[2 + 0]
+(0 - TotalViews) / TotalViews * TotalViews
+len(map(Posts, Posts))
+all(Posts, 0 == 0.5)
+toJSON(!(nil == Posts))
+!("JavaScript" != nil)
+get(Authors, 0 * TotalViews)
+Authors[TotalViews - TotalViews]
+{"Go": Authors}?.ID
+{"JavaScript": TotalViews}.Biography?.Age(TotalViews)
+TotalViews * 0 < TotalViews
+(TotalViews + TotalViews) ** TotalViews
+TotalViews + TotalViews > TotalViews
+map(map(Posts, Posts), Authors)
+IsZero(Posts[2])
+TotalViews >= 0 ** 0
+!(2 > TotalViews)
+TotalViews - TotalViews < TotalViews
+get(Posts, 0)?.Tags
+min(1 - 0)
+min(count(Posts, false))
+1 * TotalViews - TotalViews
+Authors == Authors != nil ? Posts : Authors
+!(TotalViews < 0)
+Posts != Posts ? Posts : -TotalViews
+TotalViews == abs(TotalViews)
+string([Posts])
+TotalViews ** -0
+TotalViews != 2 * TotalViews
+-2 == TotalViews
+first(Posts).Content
+any(Posts, TotalViews > 0)
+TotalViews ^ (0 / TotalViews)
+Authors == nil ? "JavaScript" : TotalViews
+toJSON(1 < 1)
+-(0.5 + 0)
+none(Posts, TotalViews < TotalViews)
+Posts == nil ? Authors : TotalViews
+get(true ? "Go" : Authors, 0.5 <= TotalViews)
+TotalViews ^ TotalViews <= TotalViews
+any(Posts, 2 < TotalViews)
+{" ": Authors}.ID
+map(Posts[TotalViews:TotalViews], #)
+string(all(Posts, true))
+count(Posts, TotalViews > TotalViews)
+one(Posts, nil in Posts)
+not (0.5 < TotalViews)
+string(nil == Authors)
+all(map(Posts, Posts), TotalViews != TotalViews)
+map(map(Posts, TotalViews), toJSON(0.5))
+Add(1, 2) / (TotalViews + TotalViews)
+false ? nil : TotalViews >= 0.5 ** TotalViews
+all(Posts, all(Posts, true))
+{" ": Authors}?.Email
+{"Go": 0.5, "Go": Authors}.Tags
+filter(Posts, Posts != nil)
+filter(Posts, all(Posts, false))
+min(TotalViews) ** TotalViews
+all(map(Posts, Authors), 1 >= 0.5)
+none(Posts, "Go" == "Go")
+{" ": Authors, " ": nil != 1}
+string(last(Posts))
+string(2 == 1)
+IsAdmin(Authors[1])
+0 .. 0 != Posts
+--(0.5 / TotalViews)
+TotalViews - TotalViews + TotalViews
+any(Posts, TotalViews == 0)
+map(Posts, -0.5)
+-(0.5 + TotalViews)
+string({"JavaScript": Posts, " ": Authors}.Title)
+any(Posts, nil == TotalViews)
+toJSON(int(TotalViews))
+1 * TotalViews - TotalViews % TotalViews
+TotalViews == TotalViews == nil
+len(Authors) * 0.5 ** TotalViews
+int(len(Authors))
+count(Posts, true) > TotalViews
+len(map(Posts, 2))
+not true ? TotalViews : false
+filter(Posts, IsZero(#))
+one(Posts, TotalViews in Authors)
+-(2 + 0)
+float(TotalViews + TotalViews)
+{" ": Posts, "Go": Posts}
+none(Posts, any(Posts, false))
+!(1 in Authors)
+get(true ? Posts : Authors, string(Authors, Posts, TotalViews))
+TotalViews / TotalViews >= 0 / TotalViews
+TotalViews <= TotalViews ? Authors : Posts
+0 ** 1 < TotalViews
+not !false
+float(-2)
+TotalViews - 0 .. TotalViews + 1
+toJSON(nil != Posts)
+map(Posts, 0 in Posts)
+true ? Posts : TotalViews > TotalViews
+map(Posts, .PublishDate)
+any(Posts, TotalViews <= 0)
+map(TotalViews .. TotalViews, #)
+Authors[0]?.Email
+{"JavaScript": true, " ": TotalViews}.Comments
+{" ": Authors}.Website
+-count(Posts, false)
+toJSON(1 < TotalViews)
+Title(WithID(Posts, 1))
+map(Posts, 0) != Posts
+int(TotalViews + TotalViews)
+float(-0)
+--2
+get(Authors, 1 * TotalViews)
+-max(0)
+0 * TotalViews - TotalViews
+TotalViews > 0 ? nil : 0
+int(0.5 / TotalViews)
+WithID(Posts, 0).Tags
+all(Posts, 0 >= TotalViews)
+min(TotalViews - TotalViews)
+get(Posts, 0)?.Comments
+string(TotalViews in Authors)
+TotalViews ^ (0.5 * TotalViews)
+one(Posts, nil == nil)
+string(TotalViews == 0.5)
+TotalViews ^ min(TotalViews)
+toJSON(Posts[TotalViews:1])
+abs(1 ** TotalViews)
+min(2 + TotalViews)
+TotalViews < len(Posts)
+not (nil == Authors)
+{"Go": Authors, "JavaScript": TotalViews}.ID
+map(Posts, TotalViews != TotalViews)
+toJSON(Posts != Posts)
+map(2 .. TotalViews, TotalViews)
+get(Authors, len(Authors))
+get(Authors, count(Posts, true))
+map(Posts, 0 - TotalViews)
+TotalViews ^ TotalViews - TotalViews
+TotalViews ^ (TotalViews - TotalViews)
+int(TotalViews % TotalViews)
+{"Go": Posts, " ": Posts}
+min(abs(2))
+string(0 * 0.5)
+TotalViews >= TotalViews || TotalViews == nil
+get(Posts, 2)?.ID
+get(Authors, 1).FirstName
+abs(0 - 0)
+TotalViews * 1 != TotalViews
+float(TotalViews * 0.5)
+any(Posts, 1 in Authors)
+map(Posts, 2) != Posts
+get(true ? Authors : nil, TotalViews)
+not (TotalViews > 1)
+none(map(Posts, TotalViews), true == false)
+TotalViews / abs(TotalViews)
+TotalViews == TotalViews ? 2 : Posts
+TotalViews <= 0.5 ? Authors : TotalViews
+toJSON(nil == 0)
+string(TotalViews != nil)
+any(Posts, TotalViews > 2)
+all(map(Posts, Authors), nil in Posts)
+abs(Sub(0, 0))
+Posts == TotalViews .. 0
+WithID(Posts, 1)?.ID
+not (0 > TotalViews)
+one(Posts, nil == TotalViews)
+map(true ? Posts : TotalViews, TotalViews)
+Authors[int(TotalViews)]
+TotalViews < TotalViews + TotalViews
+toJSON("JavaScript" > "JavaScript")
+TotalViews - TotalViews > TotalViews
+{"Go": TotalViews != TotalViews}
+int(-0)
+toJSON(TotalViews ^ 0)
+TotalViews != TotalViews ? Posts : (false ? TotalViews : 1)
+map(Posts, Authors[nil])
+map(Posts[0:TotalViews], "JavaScript" == "JavaScript")
+TotalViews * TotalViews .. TotalViews
+TotalViews ^ (TotalViews - 0.5)
+abs(1 + TotalViews)
+TotalViews <= count(Posts, false)
+nil == Posts && TotalViews > TotalViews
+toJSON(false ? 2 : nil)
+toJSON(max(1))
+min(TotalViews * 1)
+TotalViews != TotalViews ? Posts : 1
+-(TotalViews ^ 0)
+int(2) <= TotalViews
+-TotalViews == 0 - TotalViews
+WithID(Posts, 1).Tags
+get(Authors, 2)?.LastName
+TotalViews ^ 0.5 + TotalViews
+toJSON(TotalViews + TotalViews)
+any(Posts, 2 in Posts)
+get(Authors, 2).Profile
+Authors[1].Profile
+TotalViews != 0.5 && nil == 0
+{" ": "JavaScript" <= "JavaScript"}
+one(Posts, TotalViews == nil)
+WithID(Posts, 1).Content
+none(Posts, true or false)
+max(TotalViews, TotalViews) - TotalViews
+TotalViews - -1
+count(Posts, TotalViews in Posts)
+Posts != Posts ? true : 0
+map(Posts, one(Posts, true))
+TotalViews .. TotalViews + TotalViews
+string(nil == 2)
+none(Posts, TotalViews < 0.5)
+max(2 + TotalViews)
+{"Go": false, "Go": 2}.ID
+TotalViews ** Sub(0.5, 0)
+!(nil != nil and Authors == Authors)
+get(Authors, 0)?.FirstName
+map(Posts, map(Posts, Posts))
+map(Posts, 0 ^ 2)
+{"Go": TotalViews, " ": Authors}.CommentDate
+{" ": Posts}.Content
+one(Posts, not false)
+abs(TotalViews) in Authors
+max(0, TotalViews) >= TotalViews - TotalViews
+TotalViews + abs(0)
+min(len(" "))
+max(count(Posts, false))
+Posts == TotalViews .. TotalViews
+0.5 + TotalViews == TotalViews
+TotalViews % TotalViews * 1
+Posts[1].Author
+Posts == map(Posts, Authors)
+string(TotalViews * TotalViews)
+not true ? Posts : Authors
+min(TotalViews) * 0 * 2
+float(TotalViews) > TotalViews
+abs(0.5 / TotalViews)
+not (TotalViews < 0)
+Authors[1]?.Profile
+map(map(Posts, Authors), toJSON(Authors))
+first(1 .. TotalViews)
+last(Posts)?.Comments
+!("Go" == nil)
+abs(0) / TotalViews * TotalViews
+toJSON(Posts != nil)
+min(-0.5)
+TotalViews > 0 / TotalViews
+0.5 ** 0 - TotalViews
+filter(Posts, 2 == 0)
+int(TotalViews) <= TotalViews
+get(Authors, -TotalViews)
+map(Posts, nil != Authors)
+one(Posts, 0.5 == TotalViews)
+map(map(Posts, Authors), map(Posts, Posts))
+toJSON(Authors[nil])
+Posts[1].PublishDate
+map(Posts, get(Authors, TotalViews))
+-(1 - TotalViews)
+{"JavaScript": Posts}.Profile
+map(Posts, TotalViews ^ TotalViews)
+TotalViews >= 0.5 ? TotalViews : TotalViews
+0 - TotalViews + TotalViews
+TotalViews != nil ? TotalViews : 0 > TotalViews
+2 >= TotalViews || TotalViews <= 2
+TotalViews != TotalViews ? Authors : TotalViews
+all([Posts, 0, TotalViews], 2 in Posts)
+min(1 ** 0)
+{"Go": true}.CommentDate?.Email
+abs(TotalViews) < TotalViews
+TotalViews ^ (0.5 + TotalViews)
+map(Posts, TotalViews - TotalViews)
+any(Posts, 1 <= TotalViews)
+not false ? Authors : Posts
+abs(0 ** TotalViews)
+false ? nil : TotalViews == TotalViews
+int(1) + TotalViews
+[map(Posts, Authors)]
+TotalViews * 2 + TotalViews
+toJSON(0.5 > 0)
+TotalViews * TotalViews == nil ? 0 : TotalViews
+WithID(Posts, TotalViews)?.Likes
+TotalViews * TotalViews >= TotalViews ? nil : Authors
+!(2 == nil)
+1 ** 1 <= TotalViews
+string(TotalViews <= TotalViews)
+TotalViews ** get(Authors, 1).ID
+(TotalViews / TotalViews) ** TotalViews
+toJSON(TotalViews - 0.5)
+float(0.5 / TotalViews)
+{"JavaScript": nil, " ": TotalViews, "JavaScript": true, "Go": TotalViews, "Go": TotalViews}?.PublishDate?.ID?.Profile
+-(2 + TotalViews)
+any(Posts, 0 > TotalViews)
+TotalViews + TotalViews / TotalViews
+TotalViews != nil ? Authors : " "
+not (nil == Posts)
+get(Posts, 1)?.PublishDate
+TotalViews - TotalViews ** TotalViews
+{"JavaScript": Authors}?.ID?.Biography
+map(Posts, TotalViews - 1)
+{" ": 0.5}.ID
+Authors == Authors and TotalViews in Posts
+min(TotalViews) >= TotalViews
+-(2 ** 1)
+TotalViews ^ TotalViews < TotalViews
+!all(Posts, true)
+any(Posts, nil == true)
+{" ": 0.5}?.ID
+TotalViews <= TotalViews ^ TotalViews
+none(map(Posts, TotalViews), Authors == nil)
+!(0 == 0.5)
+TotalViews + abs(TotalViews)
+{"Go": TotalViews, "Go": nil, " ": Authors}?.Profile?.Upvotes
+string(get(Posts, 0))
+get(Posts, false ? Authors : Posts)
+TotalViews == TotalViews ^ TotalViews
+none(Posts, nil in Authors)
+!(0 != TotalViews)
+map(Posts, #) != Posts
+{"JavaScript": TotalViews}.Biography
+toJSON(TotalViews >= 0)
+-get(Authors, 0)?.ID
+TotalViews > TotalViews / 0
+all(Posts, 0 <= 0)
+get(Posts, -TotalViews)
+not true ? nil : nil
+int(TotalViews) ** TotalViews
+map(Posts, TotalViews < 0)
+trim(false ? Posts : " ")
+TotalViews in 1 .. TotalViews
+TotalViews == Authors[TotalViews].ID
+string(1 * TotalViews)
+TotalViews + TotalViews in Authors
+TotalViews ** 0 ** TotalViews
+float(max(0.5))
+!(nil in Posts)
+{" ": Authors}?.Upvotes
+one([" "], 1 != 0.5)
+string(not (0.5 >= TotalViews))
+get(true ? Authors : false, "Go" matches "JavaScript")
+TotalViews % TotalViews > TotalViews
+string(Posts == nil)
+{" ": TotalViews}?.Upvotes
+Posts[1].Comments
+0.5 ** 0 != TotalViews
+any(Posts, Posts == Posts)
+any(filter(Posts, true), 0 != TotalViews)
+2 / TotalViews < TotalViews
+TotalViews / 1 == TotalViews
+TotalViews ^ (TotalViews + 0.5)
+filter(Posts, any(Posts, false))
+not ("JavaScript" startsWith "Go")
+min(TotalViews) % TotalViews
+0 ^ 1 / TotalViews
+TotalViews > TotalViews ? true : 0
+one(map(Posts, Authors), Authors == Authors)
+toJSON(!true)
+TotalViews >= TotalViews == nil
+toJSON(all(Posts, true))
+toJSON(0 == TotalViews)
+TotalViews - TotalViews != TotalViews
+TotalViews > TotalViews / TotalViews
+TotalViews + 0 / TotalViews
+[len(Authors)]
+fromJSON(string(TotalViews))
+toJSON(2 / TotalViews)
+TotalViews .. TotalViews == Posts
+TotalViews ^ 0 == TotalViews
+TotalViews > TotalViews && Posts == Posts
+-TotalViews + TotalViews
+abs(2) < TotalViews ? TotalViews : Authors
+int(TotalViews + 0)
+TotalViews >= TotalViews ? Posts : Authors
+Posts[min(1)]
+toJSON(nil == 1)
+0.5 ** TotalViews < 0.5 ^ TotalViews
+(TotalViews + TotalViews) ^ max(1)
+string(upper("Go"))
+-TotalViews + 0 * TotalViews
+{"Go": Posts}.Website
+TotalViews in Posts ? nil : 0
+TotalViews >= TotalViews / 2
+-(TotalViews - 0.5)
+map(Posts, true ? TotalViews : Authors)
+map(Posts, Posts == Posts)
+string(TotalViews != 0.5)
+max(TotalViews) != TotalViews % 2
+max(TotalViews + 2)
+map(Posts, TotalViews * TotalViews)
+all(Posts, TotalViews != TotalViews)
+Posts[2].Content
+map(Posts, TotalViews / 0)
+one(map(Posts, TotalViews), !false)
+map([Posts, false, Authors], #)
+-(0 % TotalViews)
+count(Posts, TotalViews == TotalViews)
+{"JavaScript": Posts, "Go": "Go"}.Likes
+TotalViews - max(0)
+WithID(Posts, 2).ID
+toJSON(0 >= TotalViews)
+-(1 % TotalViews)
+Add(0, 1) ** TotalViews
+string("Go" != "JavaScript")
+one(false ? Posts : Authors, nil != Authors)
+(TotalViews + TotalViews) % TotalViews
+!(0 > 2)
+min(TotalViews) .. TotalViews
+TotalViews < len(Authors)
+toJSON(nil != TotalViews)
+none(Posts, !false)
+[Posts, Authors]
+last(Posts)?.PublishDate
+0 != nil or TotalViews != nil
+get(Authors, min(2))
+toJSON(2 == nil)
+{"Go": TotalViews}.Upvotes
+get(Authors, TotalViews - TotalViews)
+last(filter(Posts, false))
+TotalViews ^ TotalViews >= 1 * TotalViews
+one(Posts, TotalViews == 0)
+trim(string(TotalViews))
+-TotalViews < TotalViews
+not false ? 1 : Posts
+TotalViews ^ TotalViews ** (TotalViews - 0.5)
+any(Posts, 0.5 != 2)
+-0 in Posts
+nil != Posts ? TotalViews : abs(TotalViews)
+{"JavaScript": Authors}.ID
+map(Posts, 0.5 + TotalViews)
+2 / TotalViews != TotalViews
+filter(Posts, 0 <= TotalViews)
+map(Posts, Authors) == Posts
+map(Posts, nil == " ")
+string(TotalViews > 0.5)
+string(TotalViews != 0)
+toJSON(len(Posts))
+get(Posts, 0).Likes
+Authors[len(Authors)]
+{"Go": TotalViews, "Go": TotalViews}?.Biography
+TotalViews != count(Posts, true)
+[Authors, TotalViews, TotalViews] == Posts
+len(Authors) != max(TotalViews)
+!(TotalViews + 0.5 >= TotalViews)
+int(1 ** TotalViews)
+{" ": TotalViews, "Go": nil}?.PublishDate
+TotalViews == 0 ? 0.5 : Posts
+not (TotalViews < TotalViews)
+TotalViews == 0 and TotalViews >= TotalViews
+!(" " endsWith " ")
+none(Posts, TotalViews < 0)
+TotalViews == TotalViews ? TotalViews : 0
+0 ^ 0 >= TotalViews
+max(float(0.5))
+filter(Posts, Posts != Posts)
+-(1 % 1)
+one(Posts, one(Posts, true))
+TotalViews ** float(1)
+max(int(2))
+{"JavaScript": Authors, "Go": TotalViews, "Go": Authors, "Go": TotalViews}.Birthday
+map(map(Posts, Posts), Posts)
+get(false ? false : TotalViews, TotalViews)
+one(Posts, TotalViews != TotalViews)
+TotalViews >= len("JavaScript")
+string(TotalViews <= 0)
+true ? TotalViews : Posts != map(Posts, 0)
+TotalViews ** (0 + TotalViews)
+TotalViews == TotalViews / TotalViews
+trim("JavaScript" + "Go")
+{"JavaScript": TotalViews <= TotalViews}
+string(TotalViews != TotalViews)
+{" ": nil, "Go": TotalViews, "Go": TotalViews, " ": Posts, " ": Posts}?.Author
+TotalViews % 2 <= TotalViews
+TotalViews - 1 % TotalViews
+Posts != Posts[TotalViews:TotalViews]
+TotalViews != nil or Posts == nil
+TotalViews + Add(0.5, 0)
+TotalViews != TotalViews && TotalViews <= TotalViews
+{"Go": Authors, "Go": Posts, "JavaScript": Authors}.Profile
+TotalViews - -TotalViews
+map(Posts, -0)
+2 ^ TotalViews * TotalViews
+-(TotalViews ^ 2)
+TotalViews * 0 in Posts
+TotalViews < TotalViews ? Authors : map(Posts, true)
+-(TotalViews / 0.5 ** TotalViews)
+TotalViews % 1 <= TotalViews
+-TotalViews != TotalViews
+!(TotalViews <= 1)
+[Authors, Authors]
+!(0 >= TotalViews)
+0 * TotalViews + TotalViews
+last(false ? TotalViews : Posts)
+int(-2)
+Add(1, 0.5) >= TotalViews
+TotalViews <= TotalViews ? Authors : Authors
+TotalViews != TotalViews % TotalViews
+trim(string(Authors))
+none(TotalViews .. TotalViews, TotalViews >= TotalViews)
+string(TotalViews - 2)
+(TotalViews * TotalViews) ** (TotalViews - TotalViews)
+abs(0.5) ** TotalViews
+-1 + TotalViews
+int(TotalViews ^ 0)
+TotalViews > 0.5 ? Posts : nil
+string(TotalViews in Posts)
+string(1 in Authors)
+TotalViews == TotalViews ? Authors : TotalViews
+0.5 * TotalViews + max(0)
+TotalViews * 2 * TotalViews
+map(map(Posts, TotalViews), TotalViews - 0)
+any(Posts, 0.5 < TotalViews)
+TotalViews ** TotalViews <= TotalViews
+Authors[2].Profile
+none(map(Posts, Authors), 2 == 2)
+count(Posts, false) - TotalViews
+min(TotalViews) <= TotalViews
+!(0.5 > 1)
+not !true
+TotalViews ** TotalViews / TotalViews
+len(Authors) != TotalViews
+int(0 ^ 2)
+TotalViews <= TotalViews == nil
+float(1 ** TotalViews)
+TotalViews > 0.5 - TotalViews
+TotalViews + min(TotalViews, TotalViews)
+1 / TotalViews + TotalViews
+filter(map(Posts, 0), nil != nil)
+0.5 <= TotalViews or Posts == Posts
+toJSON(any(Posts, true))
+string(true ? Posts : Authors)
+string(count(Posts, true))
+none([Posts, Posts, 0.5, nil], 0 == TotalViews)
+WithID(Posts, 0)?.ID
+max(1 ^ TotalViews)
+string(nil != 0.5)
+not (TotalViews >= 1)
+count(Posts, nil in Posts)
+TotalViews > 1 % 2
+not (2 == TotalViews)
+lower(string(TotalViews))
+toJSON(Authors) startsWith " " ? 0 : TotalViews
+TotalViews ** TotalViews / int(TotalViews)
+any(map(Posts, 0), 0 in Posts)
+filter(Posts, 0.5 == 2)
+not (2 != TotalViews)
+string(false ? Authors : 0)
+string(true ? Posts : TotalViews)
+map(Posts, 1 ** 0)
+fromJSON(string(false))
+TotalViews * Authors[TotalViews].ID
+!(false or true)
+one(Posts, nil != TotalViews)
+last(TotalViews .. 0)
+string(0.5 == nil)
+TotalViews == TotalViews - TotalViews
+TotalViews <= 0.5 ? nil : nil
+float(TotalViews ** TotalViews)
+toJSON(any(Posts, false))
+TotalViews / TotalViews == TotalViews
+one([0.5], TotalViews in Posts)
+toBase64(string(0))
+-(0.5 / 1)
+filter(Posts, 0.5 != nil)
+not (TotalViews <= 0)
+(TotalViews - TotalViews) * TotalViews
+map(true ? Authors : TotalViews, Posts)
+not ("Go" < "Go")
+max(float(TotalViews))
+!IsAdmin(Authors[nil])
+toJSON(map(Posts, TotalViews))
+0 * 0.5 / (TotalViews - TotalViews)
+filter(Posts, not (nil != Posts))
+Posts[0 + 0]
+TotalViews ^ (TotalViews / 1)
+map(Posts, #?.Content)
+{"Go": Authors}?.Author
+not (0 != 1)
+0 + TotalViews <= TotalViews
+one(Posts, Authors != nil)
+float(TotalViews) ^ TotalViews
+TotalViews - TotalViews ^ TotalViews
+!false ? Authors : 1
+WithID(Posts, TotalViews)?.PublishDate
+max(TotalViews * 2)
+get(Authors, 2)?.FirstName
+get(Posts, 0 % TotalViews)
+len(Posts) == TotalViews
+get(Posts, 1 - 0)
+{" ": Posts, " ": Authors}?.Biography
+count(Posts, 0 <= TotalViews)
+nil != Posts or TotalViews > TotalViews
+toJSON(TotalViews == 0)
+0 != TotalViews && TotalViews == nil
+Title(Posts[0])
+TotalViews % TotalViews * TotalViews
+min(TotalViews) > min(TotalViews)
+none(Posts, TotalViews in Authors)
+TotalViews != float(TotalViews)
+map(map(Posts, 0), string(Posts))
+TotalViews ^ TotalViews ^ TotalViews
+lower(string(nil))
+TotalViews <= 0.5 - 1
+string(2 % TotalViews)
+WithID(Posts, TotalViews).Author.LastName
+last(get(Posts, 2)?.Tags)
+{" ": 0 != TotalViews}
+max(TotalViews / 0)
+int(2 / TotalViews)
+none(Posts, nil in Posts)
+abs(TotalViews ^ 0)
+nil != Authors && false ? Posts : TotalViews
+TotalViews ^ (TotalViews - 1)
+IsAdmin(nil) || true ? TotalViews : Authors
+TotalViews % TotalViews .. TotalViews
+map(Posts, false or true)
+int(max(TotalViews))
+TotalViews <= TotalViews != false
+0 % TotalViews / TotalViews
+not ("JavaScript" <= "JavaScript")
+abs(TotalViews) != 0 ? TotalViews : TotalViews
+TotalViews + TotalViews == TotalViews / TotalViews
+not (nil != "Go")
+TotalViews .. len(Authors)
+get(Posts, 0)?.Author
+TotalViews * TotalViews >= 0 + TotalViews
+abs(float(TotalViews))
+string(2 - TotalViews)
+TotalViews - TotalViews % TotalViews
+-(2 % TotalViews)
+[Authors[TotalViews]]
+get(map(Posts, 0), -TotalViews)
+max(len("JavaScript"))
+map(Posts, .Tags)
+-(2 ^ TotalViews)
+-(TotalViews / 2)
+string(2 + 0)
+int(0.5) > TotalViews
+all(Posts, TotalViews >= TotalViews)
+len(toJSON(Authors))
+toJSON(TotalViews .. TotalViews)
+abs(int(TotalViews))
+{"Go": true}.Tags
+TotalViews ** 2 == TotalViews ? 0 : 2
+toJSON(TotalViews != nil)
+count(Posts, 0 != 0)
+TotalViews in Authors && TotalViews != TotalViews
+toJSON(get(Authors, 0))
+TotalViews <= TotalViews ? 0 : nil
+get(Authors, TotalViews + TotalViews)
+0 * TotalViews > TotalViews
+TotalViews > TotalViews ^ 0.5
+TotalViews ** -TotalViews
+map(map(Posts, 0), get(Posts, TotalViews))
+map(Posts, max(TotalViews))
+max(TotalViews / 0.5)
+(TotalViews - 1) ^ TotalViews
+map(map(Posts, 0), Authors)
+{"Go": get(Posts, TotalViews)}
+TotalViews / TotalViews > 0.5 ? Posts : 0.5
+toJSON(count(Posts, false))
+not (2 <= 0)
+len(Posts) % TotalViews
+filter(Posts, 0 >= TotalViews)
+1 / 2 + TotalViews
+Posts[2].ID
+{"JavaScript": " "}?.ID
+fromJSON(toJSON(Posts))
+not (-TotalViews in Authors)
+TotalViews + len(Posts)
+TotalViews ** (TotalViews + TotalViews)
+-1 .. -TotalViews
+-0 == TotalViews
+not not (Authors == Authors)
+map(Posts, nil in Posts)
+toJSON(TotalViews in Posts)
+one(Posts, 0.5 < 0.5)
+-(1 / 1)
+2 in Authors || 1 > TotalViews
+len(string(0))
+!true ? true : " "
+nil != 0 and Posts == Posts
+not true ? 0 : Authors
+map(Posts, lower("Go"))
+toJSON(nil in Authors)
+Authors[2].Email
+one(map(Posts, Posts), !true)
+get(Authors, 1).Profile
+TotalViews < abs(TotalViews)
+toJSON(toJSON(Authors))
+toJSON(last(Posts))
+not (TotalViews != 2)
+len(Posts) in Posts
+-min(0)
+" " >= "Go" && Authors != nil
+{"Go": Authors, " ": 0.5, "JavaScript": nil, " ": 0, "JavaScript": Posts}?.PublishDate
+TotalViews * 0.5 <= TotalViews * TotalViews
+len(Authors) * TotalViews
+Posts == map(Posts, 1)
+TotalViews / 0.5 >= 0.5 ? " " : true
+!(0 >= 0.5)
+TotalViews < TotalViews * TotalViews
+TotalViews ^ TotalViews <= max(0)
+not (0 <= 2)
+abs(TotalViews) > 2 == true
+-int(2)
+get(true ? Authors : 0, TotalViews)
+string(0 == nil)
+Posts != Posts ? 2 : Authors
+string(2 / TotalViews)
+count(Posts, Posts == nil)
+!(nil in Authors)
+{"JavaScript": false, "JavaScript": Posts, " ": TotalViews}.Title
+2 % TotalViews >= TotalViews
+toJSON(2 < 2)
+TotalViews % TotalViews >= TotalViews ** TotalViews
+int(0.5 ^ TotalViews)
+TotalViews / 0.5 ** 1
+{"Go": Posts, " ": Posts, "Go": nil}.Author
+TotalViews ^ 0.5 == 0.5 ? Posts : "JavaScript"
+0 ** 0 ^ (TotalViews - 2)
+first(false ? TotalViews : Posts)
+int(0) in Posts
+!one(Posts, false)
+toJSON(abs(TotalViews))
+get(Posts, 2)?.Tags
+Authors[TotalViews % 1]
+min(0 % TotalViews)
+string(Authors == Authors)
+min(-0)
+min(0) ^ -2
+count(Posts, "Go" != nil)
+one(Posts, 0.5 < 0)
+0 / TotalViews > TotalViews ? " " : 1
+first(false ? Posts : TotalViews)
+Authors == Authors ? Authors : Authors
+map(Posts, Posts) != Posts
+map(Posts, false == false)
+any(Posts, true) && TotalViews == TotalViews
+get(Authors, TotalViews * TotalViews)
+TotalViews * 0 / float(TotalViews)
+Posts == map(Posts, "Go")
+TotalViews < TotalViews - 0.5
+not (TotalViews >= 2)
+0 ** TotalViews + TotalViews / TotalViews
+TotalViews * 0 + 1 / TotalViews
+string(!(nil in Posts))
+none(map(Posts, 1), TotalViews != TotalViews)
+!(0.5 <= 0)
+TotalViews + 0 != TotalViews
+int(float(2))
+not (true and true)
+max(0.5 + TotalViews, TotalViews % TotalViews)
+one(Posts, nil == Posts)
+TotalViews / 0 < TotalViews ? TotalViews : 0.5
+TotalViews >= 0 - 0.5
+count(Posts, 0.5 > TotalViews)
+float(TotalViews ^ 0.5)
+get(Posts, 0)?.Title
+abs(TotalViews ** 1)
+true ? " " : TotalViews < TotalViews
+not (0.5 > 0)
+!(0.5 == TotalViews)
+map(map(Posts, Authors), Posts)
+TotalViews != TotalViews ** TotalViews
+not all(map(Posts, "Go"), TotalViews != TotalViews)
+int(0 * TotalViews)
+max(TotalViews ^ 0.5)
+TotalViews / TotalViews / TotalViews
+Posts != map(Posts, TotalViews)
+TotalViews / 2 ^ 0
+TotalViews > 1 ? TotalViews : TotalViews
+-TotalViews < -TotalViews
+{"Go": TotalViews}?.LastName
+all(Posts, any(Posts, true))
+max(1 ** TotalViews)
+max(TotalViews, TotalViews % TotalViews)
+max(-(TotalViews * TotalViews))
+float(TotalViews + 1)
+Posts[len(Authors)]
+map(Posts, 0 != nil)
+not (0.5 >= 0.5)
+Authors[2 + TotalViews]
+map(map(Posts, Posts), TotalViews != nil)
+{"Go": "Go", "JavaScript": Posts}.Title
+not (true == nil)
+string(0 != 0)
+TotalViews * 0.5 / TotalViews
+int(TotalViews) / TotalViews
+get(Posts, 1).Title
+Posts != Posts == nil
+TotalViews < 0 == nil
+(TotalViews % 1) ** TotalViews
+float(float(0.5))
+not (0 < 1)
+!(0 < 1)
+{" ": Posts, "Go": Posts, " ": TotalViews, "JavaScript": 0.5, " ": Posts}.ID
+-(0 / 1)
+{"JavaScript": Authors}?.Email
+map(filter(Posts, true), Authors)
+not true ? TotalViews : Posts
+filter(Posts, nil != 2)
+{" ": Posts, " ": TotalViews}.Comments
+string(true && true)
+Authors == Authors == nil
+string(TotalViews >= TotalViews)
+map(Posts, 0 == TotalViews)
+last(filter(Posts, true)).Content
+string(1 ^ 0)
+TotalViews + TotalViews * 0
+len(map(Posts, true))
+not (1 < 2)
+count(Posts, 0 != TotalViews)
+TotalViews * TotalViews in Posts ? 2 : Authors
+TotalViews != TotalViews ^ 1
+count(map(Posts, Authors), !false)
+filter(Posts, TotalViews >= TotalViews)
+filter(Posts, TotalViews >= 0)
+max(0) ^ TotalViews
+none(Posts, false) != false ? Authors : " "
+TotalViews / (0.5 + TotalViews)
+all(Posts, !true)
+{"Go": Authors}.Author
+none(Posts, 0.5 >= 0)
+Posts == Posts != false
+not (0.5 < 2)
+min(1 ^ TotalViews)
+any(Posts, # != #)
+TotalViews ^ TotalViews > -TotalViews
+-(0 ^ TotalViews)
+TotalViews != TotalViews / TotalViews
+abs(TotalViews / TotalViews)
+WithID(Posts, 1 * 0)
+TotalViews * TotalViews % TotalViews
+len(Authors) < -TotalViews
+Authors != Authors and Posts != nil
+filter(Posts, nil == 1)
+not (TotalViews != nil)
+TotalViews >= 0.5 || Posts != nil
+string(string(nil))
+Authors == Authors ? TotalViews : 0
+{"JavaScript": 0.5 > TotalViews, "JavaScript": Authors}
+0.5 ^ TotalViews + TotalViews
+one(Posts, Posts == Posts)
+Posts == 1 .. TotalViews
+[-2, Authors]
+one(Posts, 1 == TotalViews)
+abs(TotalViews) > min(0, 0.5)
+0 ^ TotalViews - 0 % TotalViews
+TotalViews ** 2 - TotalViews
+TotalViews < TotalViews ** 2
+len(Authors) == TotalViews ** TotalViews
+{"Go": TotalViews, "Go": TotalViews, " ": Posts, "JavaScript": Posts, "JavaScript": nil}.ID
+min(1) != TotalViews
+TotalViews - Sub(2, 0.5)
+float(len(Posts))
+0 - TotalViews != float(TotalViews)
+map(Posts[0:0], !false)
+Posts[2]?.Comments
+map(Posts, float(TotalViews % TotalViews))
+string(false ? false : nil)
+min(TotalViews / 0)
+all(Posts, 0.5 < TotalViews)
+count(Posts, TotalViews > 1)
+{" ": min(0), " ": -TotalViews}
+max(TotalViews % 1)
+TotalViews > abs(TotalViews)
+TotalViews < 0.5 ? Authors : Posts
+not (" " < " ")
+TotalViews ^ float(0)
+toJSON({" ": Authors})
+TotalViews * TotalViews * 0.5
+float(1 % TotalViews)
+-0 % TotalViews
+any(Posts, 2 != nil)
+(0 / 0) ^ TotalViews ^ 0.5
+trim(toJSON(TotalViews))
+TotalViews / TotalViews + TotalViews
+TotalViews / int(0.5)
+{"JavaScript": map(Posts, Authors)}.Profile
+duration(toJSON(0))
+upper(toJSON(TotalViews))
+toJSON(nil == nil)
+Add(0, 0) > TotalViews ? Posts : 0.5
+max(1 / 0)
+filter(Posts, nil == Posts)
+2 ^ TotalViews > TotalViews
+!true ? "Go" : Posts
+map(true ? Authors : Posts, TotalViews)
+min(0.5 * TotalViews)
+" " contains "Go" or nil in Authors
+one(Posts, 1 != 0)
+-TotalViews < TotalViews == false
+map(Posts, "Go" == "Go")
+count(Posts, not false)
+TotalViews >= 0.5 / 0
+len(Authors) / TotalViews / TotalViews
+one(Posts, 2 == TotalViews)
+TotalViews + 2 ^ 1
+-(0.5 * TotalViews)
+[map(Posts, "JavaScript")]
+none(Posts, 0 > TotalViews)
+map(Posts, TotalViews == 0.5)
+one(Posts, Posts != nil)
+-max(0, TotalViews)
+not (0 == 0.5)
+map(Posts, map(Posts, Authors))
+0.5 ^ 0 ^ TotalViews ^ TotalViews
+(TotalViews - 0.5) / TotalViews
+min(count(Posts, true))
+TotalViews < TotalViews ** TotalViews - -TotalViews
+last(map(Posts, false))
+map(map(Posts, Authors), Authors)
+TotalViews ^ 0 >= TotalViews
+len(true ? Posts : Posts)
+Posts != Posts ? Posts : Posts
+TotalViews == 0 / TotalViews
+0 ** 0 >= TotalViews
+TotalViews != 0 ? 0.5 : "Go"
+len(trim(" "))
+{" ": nil}.Tags
+TotalViews in Authors ? 0 : 2
+TotalViews ^ TotalViews != TotalViews
+one(Posts, TotalViews >= TotalViews)
+toJSON(true != true)
+1 / TotalViews > TotalViews
+TotalViews + TotalViews - max(TotalViews)
+all(Posts, 1 <= TotalViews)
+none(Posts, TotalViews >= 1)
+max(0.5 / TotalViews)
+TotalViews .. -TotalViews
+Posts == Posts ? TotalViews : TotalViews
+TotalViews ^ (Posts != nil ? TotalViews : Posts)
+TotalViews == count(Posts, false)
+0 % TotalViews + TotalViews
+string(0.5 + 0)
+all(map(Posts, Authors), Posts != Posts)
+string(false ? " " : TotalViews)
+toJSON(TotalViews * TotalViews)
+0 / TotalViews - TotalViews
+none(Posts, TotalViews != 2)
+count(Posts, Authors != Authors)
+0 + TotalViews < TotalViews
+toJSON(upper("Go"))
+TotalViews ** (0 - 2)
+all(Posts, # == #)
+{" ": true}?.Biography
+nil != Posts and TotalViews < 0
+TotalViews in Authors ? Posts : nil
+one(Posts, Posts == nil)
+nil == TotalViews and 0.5 <= TotalViews
+TotalViews != min(TotalViews)
+TotalViews <= TotalViews ? "JavaScript" : Authors
+min(TotalViews) * TotalViews
+TotalViews ** 2 == TotalViews % TotalViews
+string(1 ^ 0.5)
+max(min(0, 2))
+TotalViews / Add(0, 2)
+count(Posts, false) > TotalViews
+Authors == Authors != true
+TotalViews >= TotalViews + 0.5
+abs(2) in Authors ? nil : false
+string(filter(Posts, false))
+upper(string(float(TotalViews)))
+abs(0.5 / 0.5)
+Authors != Authors ? Authors : Authors
+toJSON(TotalViews == TotalViews)
+-0 - TotalViews
+1 .. TotalViews == Posts
+-TotalViews >= 1 ? 0.5 : 1
+0 ^ TotalViews / TotalViews
+-(0.5 ^ 0)
+max(TotalViews ** TotalViews)
+2 ** 0.5 / count(Posts, false)
+string(map(Posts, 0))
+map(map(Posts, TotalViews), abs(TotalViews))
+max(TotalViews) ** TotalViews
+string(-0)
+TotalViews ** TotalViews >= TotalViews
+TotalViews != 0 ? Posts : nil
+filter(Posts, 1 == 0)
+TotalViews ^ 0 ** TotalViews
+count(Posts, Authors == nil)
+TotalViews ** (TotalViews * TotalViews)
+string("Go" <= " ")
+get(Authors, TotalViews - 0)
+0.5 + 0 < 0.5 ? nil : TotalViews
+toJSON(nil in Posts)
+min(TotalViews * 0.5)
+!(TotalViews > 0.5)
+{" ": -TotalViews}
+Authors[min(TotalViews)]
+[2 ^ 2]
+max(int(0))
+{"Go": "Go"}.Tags
+string(TotalViews * 0.5)
+all(Posts, TotalViews != nil)
+map(Posts, Posts[0:TotalViews])
+TotalViews * 2 > TotalViews
+TotalViews - TotalViews + TotalViews - TotalViews
+lower(string(false))
+all(Posts, Posts == nil)
+all(Posts, 2 >= 2)
+len(filter(Posts, true))
+filter(Posts, Authors != Authors)
+!(0 == TotalViews)
+map(true ? Posts : Posts, Authors)
+len(Authors) ** TotalViews
+not true and TotalViews == 0
+all(Posts, nil == nil)
+TotalViews <= 1 or nil in Authors
+TotalViews / 2 == TotalViews ? false : Authors
+TotalViews / max(2)
+TotalViews + 2 ^ TotalViews
+TotalViews in map(Posts, 0)
+int(0.5 * TotalViews)
+(TotalViews + TotalViews) * TotalViews % 2
+Authors == Authors ? 1 : nil
+TotalViews / 0.5 * TotalViews
+true ? Authors : 2 >= TotalViews
+len(Authors) in Posts == nil
+filter(1 .. TotalViews, TotalViews >= TotalViews)
+TotalViews ^ 2 != TotalViews
+all(Posts, nil == Authors)
+string(any(Posts, false))
+TotalViews <= -TotalViews
+float(TotalViews) - 0.5 - TotalViews
+nil in Posts or true == nil
+map(Posts, TotalViews .. TotalViews)
+toJSON(TotalViews == 1)
+Posts != Posts == false
+{" ": Posts, " ": 0.5}?.Author
+-(2 + 1)
+-(1 * TotalViews)
+get(Posts, TotalViews - TotalViews)?.ID
+string(0 == TotalViews)
+min(TotalViews, TotalViews) > TotalViews
+TotalViews != len(Authors)
+string(int(0))
+not (nil != true)
+0 ^ TotalViews - TotalViews
+all(Posts, 0.5 != TotalViews)
+Posts != Posts ? Posts : Authors
+!(nil != true)
+{"JavaScript": nil}?.PublishDate
+int(TotalViews - 2)
+min(TotalViews) / 0 ** TotalViews
+-TotalViews * TotalViews ** TotalViews
+min(2 % TotalViews)
+0 .. TotalViews != Posts ? TotalViews : 0.5
+int(TotalViews * 2)
+0.5 - TotalViews != TotalViews
+get(Posts, 1).Tags
+TotalViews % TotalViews < TotalViews
+get(Posts, false ? Posts : TotalViews)
+TotalViews - float(TotalViews) <= TotalViews
+{" ": Posts, " ": Posts}.Content != Authors
+not (0.5 != 0)
+not ("JavaScript" == " ")
+(0.5 + TotalViews) / TotalViews
+TotalViews / 0.5 < TotalViews
+not (0 == 1)
+TotalViews != TotalViews ? TotalViews : Posts
+upper(toJSON(" "))
+float(2) >= TotalViews ** TotalViews
+-(TotalViews / 0)
+not (TotalViews != 1)
+int(0 ^ 0)
+TotalViews ^ 0 ^ (TotalViews + TotalViews)
+TotalViews * 0.5 > TotalViews
+map(Posts, 0.5 / TotalViews)
+-(TotalViews ** 2)
+int(2) - TotalViews
+toJSON(nil != 1)
+TotalViews > 0 ** TotalViews
+TotalViews >= TotalViews ^ 1
+filter(Posts, TotalViews < 0.5)
+abs(0.5 ^ TotalViews)
+int(0 % TotalViews)
+0.5 * TotalViews > TotalViews / TotalViews
+int(TotalViews + 0.5)
+map(Posts, 0 != TotalViews)
+Posts[1].Title
+TotalViews * -TotalViews
+!(1 == TotalViews)
+TotalViews - TotalViews >= TotalViews
+max(Add(2, 0))
+1 + 0 < 1 ** 0
+nil != Posts ? TotalViews : Posts == Posts
+one(Posts, true != nil)
+filter(Posts, 0.5 == nil)
+not (0 in Authors)
+map(map(Posts, true), Authors)
+not ("Go" > "Go")
+string(0.5 + TotalViews)
+true ? Authors : Posts[TotalViews]
+not (false and true)
+min(0 + 1)
+{"Go": Authors}?.LastName
+0.5 * TotalViews / int(TotalViews)
+Posts == map(Posts, TotalViews)
+count(Posts, nil == Posts)
+-(TotalViews * 1)
+TotalViews * TotalViews in Posts
+string(not false)
+2 ^ 0 / int(TotalViews)
+TotalViews ** -0.5
+!(0.5 >= 0)
+string(nil == nil)
+!(1 > TotalViews)
+abs(TotalViews ^ (TotalViews / TotalViews))
+TotalViews .. 1 - 0
+!(" " <= "Go")
+abs(TotalViews + 2)
+abs(len("Go"))
+string(string(Posts))
+map(Posts, min(TotalViews))
+{"Go": nil}.ID
+!(" " > " ")
+{" ": TotalViews, "Go": Posts}
+last(map(Posts, 0))
+-abs(0)
+toJSON(true ? 0.5 : 0.5)
+float(1 / TotalViews)
+not (1 != 0)
+max(0 / TotalViews)
+int(0) - TotalViews
+!not (TotalViews != 0)
+string(!(TotalViews < TotalViews))
+int(0.5) == TotalViews
+Authors == Authors ? Posts : 1
+WithID(Posts, 1)?.PublishDate
+-(TotalViews + 0)
+Authors[min(0)]
+filter(Posts, true) != map(Posts, TotalViews)
+trim("Go") > toJSON(TotalViews)
+WithID(Posts, 2).Title
+int(TotalViews) % TotalViews
+max(0.5 - 0)
+last(Posts).Author
+map(Posts, TotalViews > 0.5)
+!true ? 2 : 2
+count(Posts, TotalViews != TotalViews)
+string(0 ^ 0)
+min(TotalViews) + TotalViews
+false ? Posts : TotalViews .. TotalViews
+one(Posts, !false)
+fromJSON(toJSON(Authors))
+TotalViews - 1 + TotalViews
+true ? Posts : TotalViews ^ TotalViews
+Authors != nil ? TotalViews : TotalViews
+TotalViews ** (TotalViews + 0.5)
+get(Authors, abs(TotalViews))
+len(Posts) > TotalViews * TotalViews
+TotalViews <= TotalViews ? Authors : TotalViews
+one(Posts, true && true)
+min(TotalViews * 2)
+Posts[1]?.Tags
+min(1) != 2 ^ TotalViews
+map(Posts, string(Posts))
+-(2 ^ 1)
+not (TotalViews == 0.5)
+count(Posts, nil == 0)
+0.5 * 0 != TotalViews
+(TotalViews + 0) ^ TotalViews
+TotalViews + count(Posts, false)
+TotalViews == 0.5 ? TotalViews : TotalViews
+map(Posts, true) == Posts
+{"JavaScript": 0.5 ** TotalViews}
+{"Go": nil, "JavaScript": Posts, " ": Authors}?.Upvotes
+one(Posts, IsZero(#))
+!any(Posts, true)
+last([TotalViews])
+string(TotalViews <= 0.5)
+-TotalViews - TotalViews / TotalViews
+any(false ? " " : Authors, 0 == 0.5)
+one(Posts, !true)
+WithID(Posts, false ? TotalViews : TotalViews)
+trim(true ? " " : TotalViews)
+TotalViews ^ TotalViews != abs(TotalViews)
+count(Posts, TotalViews != nil)
+{" ": Posts}?.Content
+{"JavaScript": TotalViews, "Go": Posts}.Title
+none(Posts, !true)
+trim(toJSON(1))
+0 .. TotalViews != filter(Posts, true)
+count(Posts, true) == TotalViews
+filter(TotalViews .. TotalViews, 0 == nil)
+WithID(Posts, 2)?.ID
+string(TotalViews / 1)
+toJSON(len(Authors))
+float(TotalViews ^ 1)
+min(TotalViews, TotalViews) % TotalViews
+filter(Posts, 0 != TotalViews)
+{"JavaScript": nil}?.Tags
+-(TotalViews + 1)
+TotalViews - TotalViews == TotalViews
+(0.5 * TotalViews) ** TotalViews
+one(Posts, 0 > TotalViews)
+TotalViews .. 0 - TotalViews
+filter(true ? Posts : Posts, TotalViews <= 0)
+len(filter(Posts, false))
+TotalViews - 0.5 * TotalViews
+TotalViews * TotalViews >= TotalViews ? "JavaScript" : 1
+-float(0)
+TotalViews * max(0)
+any(Posts, TotalViews != nil)
+{"Go": Authors}?.FirstName
+int(min(TotalViews))
+TotalViews != nil == nil
+{" ": 0.5 != TotalViews}
+TotalViews ** -2
+toJSON(map(Posts, "JavaScript"))
+map(map(Posts, Authors), TotalViews)
+TotalViews / TotalViews ^ 0
+TotalViews != TotalViews ^ 0
+map(Posts, Authors != nil)
+-TotalViews > count(Posts, false)
+2 ^ TotalViews >= TotalViews ? true : 0
+map(Posts, TotalViews / TotalViews)
+map(Posts, TotalViews + 0)
+one(Posts, TotalViews != 1)
+(0 + TotalViews) ** TotalViews
+TotalViews .. -1
+{"JavaScript": 0, "JavaScript": Posts, "Go": TotalViews}.FirstName
+TotalViews ^ 0.5 / TotalViews
+abs(TotalViews % TotalViews)
+one(map(Posts, Authors), TotalViews > 0.5)
+TotalViews == nil ? Posts : "JavaScript"
+toJSON(one(Posts, true))
+toJSON(0.5 ^ TotalViews)
+len(true ? Authors : TotalViews)
+0 / TotalViews <= TotalViews
+Posts != nil ? 2 : nil
+2 - 0 >= TotalViews
+map(Posts, true ? false : 2)
+filter(Posts, !true)
+string(TotalViews ^ 0.5)
+TotalViews in Posts ? Posts : Authors
+int(0) == TotalViews
+max(0.5 ^ 0)
+filter(Posts, nil in Posts)
+toJSON(1 .. TotalViews)
+TotalViews != 0 and not true
+Posts[TotalViews:TotalViews] == 1 .. TotalViews
+!(TotalViews <= 2)
+any(Posts, 2 < 1)
+TotalViews / (TotalViews - 0.5)
+int(1 / 0.5)
+!("JavaScript" <= " ")
+int(abs(TotalViews))
+map(Posts, TotalViews + TotalViews)
+map(Posts, len(Posts))
+lastIndexOf(" ", "Go") ** TotalViews
+toJSON(get(Authors, TotalViews).Profile)
+min(TotalViews) != TotalViews
+any(Posts, 0 != TotalViews)
+{" ": Authors, "Go": 0, "Go": Authors, "JavaScript": Authors, "Go": 2}.Content != Posts
+filter(map(Posts, Authors), Posts == Posts)
+TotalViews > 0.5 ? Posts : Posts
+one(Posts, 0.5 >= TotalViews)
+none(Posts, IsZero(#))
+Sub(1, 0.5) ** TotalViews
+TotalViews >= 0 ** 1
+TotalViews in Posts != false
+get(Posts, int(TotalViews))
+!(0.5 != TotalViews)
+(1 - TotalViews) ** TotalViews
+[TotalViews, TotalViews]
+Posts != map(Posts, 0.5)
+get(map(Posts, false), TotalViews)
+TotalViews ** TotalViews + TotalViews
+string(map(Posts, " "))
+any(Posts, TotalViews == TotalViews)
+TotalViews * (0 + TotalViews)
+[nil != false]
+TotalViews <= 0.5 ^ 2
+-(0 - 1)
+min(TotalViews / 0.5)
+TotalViews != TotalViews ** 0.5
+Authors != Authors != nil
+TotalViews / TotalViews ** 0
+one(Posts, 1 > TotalViews)
+!(nil != 0.5)
+get(Authors, 1 + TotalViews)
+{"JavaScript": "JavaScript"}.ID
+abs(TotalViews + 0)
+map(Posts, TotalViews != 0.5)
+abs(TotalViews ** 0.5)
+[TotalViews .. TotalViews]
+0.5 - 0 >= TotalViews
+-abs(2)
+{"JavaScript": Posts, "JavaScript": Authors}.Title
+map(Posts, 2 ** 0.5)
+string(0 == 2)
+map(Posts, nil in Authors)
+-min(0.5 ^ 0)
+min(TotalViews + TotalViews, TotalViews)
+Authors[nil].Profile
+2 % TotalViews == TotalViews
+TotalViews * int(TotalViews)
+!(0 in Posts)
+string(hasPrefix("JavaScript", " "))
+map(Posts, TotalViews < 0.5)
+any(Posts, 0 == TotalViews)
+0 >= TotalViews or TotalViews < TotalViews
+all(map(Posts, Posts), TotalViews in Authors)
+none([TotalViews <= TotalViews], #)
+get(Posts, TotalViews)?.Author?.ID
+not (0 <= TotalViews)
+!(0 > 0.5)
+TotalViews in Posts or TotalViews > TotalViews
+TotalViews <= TotalViews ? nil : Authors
+string(map(Posts, "Go"))
+string({" ": false})
+toJSON(Authors != Authors)
+!(0.5 > 0.5)
+toJSON(get(Posts, 1))
+TotalViews - 2 * TotalViews
+TotalViews >= TotalViews ? nil : false
+map([Authors], Posts)
+TotalViews * 0 % 1
+2 ** TotalViews < TotalViews
+float(TotalViews ** 0)
+!("JavaScript" >= " ")
+-TotalViews ** -TotalViews
+TotalViews - 2 == TotalViews
+last(map(Posts, 2))
+TotalViews / TotalViews > TotalViews
+toJSON(TotalViews < 2)
+max(2) ^ len(Posts)
+!false ? Authors : "JavaScript"
+string(all(Posts, false))
+!("Go" > "Go")
+TotalViews >= 0 == nil
+toJSON(TotalViews != 1)
+(TotalViews + TotalViews) ^ TotalViews
+TotalViews + TotalViews + TotalViews
+last(Posts)?.Title
+Add(1, 2) + TotalViews ^ 0
+not (1 == nil)
+string(1 / 0)
+filter(Posts, Authors == Authors)
+get(false ? Posts : TotalViews, TotalViews != Posts)
+0 ** TotalViews * TotalViews
+{" ": nil, "Go": "JavaScript", "JavaScript": Authors}?.Tags
+all(Posts, nil != TotalViews)
+abs(0.5 ** TotalViews)
+TotalViews <= 2 ** TotalViews
+TotalViews ^ (TotalViews / TotalViews)
+string(0 / TotalViews)
+max(0 + 0)
+any([0, TotalViews], TotalViews in Authors)
+map(map(Posts, 0), TotalViews - TotalViews)
+min(TotalViews) > TotalViews
+TotalViews < count(Posts, true)
+false ? 1 : TotalViews > TotalViews
+TotalViews ** (TotalViews % TotalViews)
+Posts == Posts == one(Posts, true)
+get(true ? 0.5 : Posts, Posts)
+last(map(Posts, #))
+not (TotalViews != 0)
+TotalViews ** (0 % TotalViews)
+any(Posts, true == nil)
+string(0.5 > 2)
+Posts != Posts != true
+max(TotalViews + 0.5, TotalViews)
+Authors != Authors ? 1 : 0
+abs(TotalViews) / TotalViews
+TotalViews != len(Posts)
+{"JavaScript": Posts, " ": Posts, "Go": nil}.Author
+TotalViews == nil ? Authors : TotalViews
+{" ": TotalViews, "JavaScript": Authors}
+min(1 / TotalViews)
+string(1 <= TotalViews)
+int(1) >= TotalViews
+filter(Posts, not false)
+first(Posts[0:2])
+-max(TotalViews, TotalViews)
+all(Posts, 0.5 > TotalViews)
+none(Posts, TotalViews <= 1)
+Posts == Posts ? Authors : Authors
+0.5 ** TotalViews == TotalViews
+get(Posts, TotalViews * 0)
+abs(TotalViews * 0.5)
+TotalViews / 0 * TotalViews
+-(1 ** TotalViews)
+Posts == Posts and TotalViews in Authors
+count(map(Posts, TotalViews), TotalViews == 0.5)
+get(Posts, true ? false : TotalViews)
+TotalViews >= 2 * 0
+{" ": Authors, "JavaScript": Posts}
+toJSON(0 != TotalViews)
+2 ** TotalViews == TotalViews
+max(TotalViews, TotalViews, TotalViews)
+Posts == Posts || TotalViews < 1
+WithID(Posts, 0)?.PublishDate
+[TotalViews == 1]
+1 .. 1 == Posts
+abs(0 % 1)
+none(2 .. TotalViews, "Go" >= "JavaScript")
+any(Posts, none(Posts, false))
+string(nil != TotalViews)
+!(0.5 != nil)
+toJSON(string(1))
+WithID(Posts, TotalViews).Title
+one(Posts, TotalViews != 0.5)
+0 ^ 0 < TotalViews
+{"Go": TotalViews}?.CommentDate?.Content
+TotalViews + TotalViews < TotalViews
+TotalViews / TotalViews * TotalViews
+!(false != false)
+float(0) < TotalViews
+string(-1)
+-(0 * 1)
+-(TotalViews > TotalViews ? Posts : TotalViews)
+TotalViews != TotalViews == true
+1 % TotalViews % TotalViews
+TotalViews < float(TotalViews)
+string(TotalViews ** 1)
+{"JavaScript": Authors != Authors}
+Posts != 0 .. TotalViews
+count(Posts, any(Posts, false))
+map(map(Posts, true), count(Posts, false))
+TotalViews != 0 ? TotalViews : " "
+TotalViews == nil ? TotalViews : Posts
+{" ": TotalViews > TotalViews, "Go": Posts}
+float(TotalViews) * -0.5
+TotalViews / TotalViews >= TotalViews
+Posts != Posts ? 2 : "JavaScript"
+!true ? Posts : Posts
+-(TotalViews ** 1)
+string(Posts != nil)
+toJSON(Posts == nil)
+TotalViews != TotalViews ? 0.5 : nil
+lower(toJSON(TotalViews))
+!(nil == false)
+all(Posts, 0 >= 0.5)
+TotalViews != 0.5 == nil
+any(Posts, TotalViews >= TotalViews)
+map(map(Posts, true), #)
+{"JavaScript": 0}.LastName
+abs(0 - TotalViews)
+0 <= TotalViews || TotalViews == 2
+(TotalViews / TotalViews) ^ TotalViews
+TotalViews != 0 * TotalViews
+count(Posts, false) < TotalViews ? Authors : TotalViews
+TotalViews > 0.5 + TotalViews
+TotalViews % TotalViews in Posts
+max(0 % 2)
+string(len(Authors))
+-(TotalViews + 0.5)
+float(min(0.5))
+!("JavaScript" == "Go")
+len(map(Posts, false))
+map(Posts, TotalViews == 2)
+!true ? TotalViews : 0
+{" ": 0, " ": TotalViews, "JavaScript": 0.5}.Title
+toJSON(Authors != nil)
+true ? Posts : Authors[TotalViews]
+TotalViews * TotalViews ^ 1
+{"Go": Authors, "Go": 0.5}?.Email
+filter(Posts, nil != TotalViews)
+TotalViews in Authors ? true : false
+toJSON(string(Authors))
+first(map(Posts, "Go"))
+Posts[1]?.Author
+max(TotalViews % 2)
+!(nil == 2)
+TotalViews != 2 ? true : TotalViews
+TotalViews in Posts ? TotalViews : Posts
+len(Authors) > 0 * TotalViews
+TotalViews .. min(TotalViews)
+TotalViews == TotalViews + 2
+string(1 / 0.5)
+false ? Authors : 1 in Authors
+map(Posts, Posts != Posts)
+!(2 != TotalViews)
+all(Posts, TotalViews <= TotalViews * TotalViews)
+string(2 < 0)
+string(0.5 != TotalViews)
+map(Posts, # == #)
+Authors != Authors ? get(Authors, 2) : Authors
+TotalViews ^ (TotalViews * 2)
+TotalViews < TotalViews * 0
+TotalViews > 0 * 0
+TotalViews <= 1 ? Posts : true
+TotalViews <= TotalViews ? TotalViews : Posts
+not (" " > "Go")
+TotalViews / -0
+string(float(TotalViews))
+not (0 in Posts)
+not false ? " " : 2
+TotalViews ^ int(0)
+any(Posts, TotalViews != TotalViews)
+map(Posts, IsZero(#))
+get(Authors, 1)?.LastName
+toJSON(map(Posts, 1))
+{" ": nil, "JavaScript": 2}?.Upvotes
+len(0 .. 1)
+TotalViews <= TotalViews / TotalViews
+max(0 - TotalViews)
+Authors == Authors || 0.5 >= 1
+get(true ? Posts : Posts, TotalViews)
+float(1) + TotalViews
+{"JavaScript": TotalViews}?.ID
+count(Posts, 2 < 0)
+map(Posts, 0.5 != 0.5)
+{"Go": Authors}.Likes
+Posts != Posts ? TotalViews : 0.5
+map(Posts, Posts[TotalViews:TotalViews])
+any(map(Posts, 0), not true)
+nil == " " && 0 == TotalViews
+string(0 <= 0)
+map(Posts, nil != Posts)
+-TotalViews in 0 .. TotalViews
+filter(Posts, TotalViews < 0)
+TotalViews ^ TotalViews * min(0) + TotalViews
+count(Posts, IsZero(#))
+map(0 .. TotalViews, TotalViews)
+!(0 > 0)
+1 >= TotalViews ? IsAdmin(nil) : TotalViews
+TotalViews <= TotalViews % 1
+first(map(Posts, " "))
+len(Authors) == 0 % TotalViews
+max(2 - TotalViews)
+{"JavaScript": "Go", " ": " "}?.Title
+{"JavaScript": Authors}?.PublishDate
+TotalViews * 0.5 >= TotalViews
+one(Posts, TotalViews != 0)
+none(Posts, one(Posts, false))
+Posts != nil ? Posts : false
+Posts[TotalViews:TotalViews + TotalViews]
+abs(0.5 + TotalViews)
+!(true == nil)
+int(TotalViews / 1)
+float(Add(0, 0))
+1 - TotalViews == TotalViews ** 0
+TotalViews ** (1 * TotalViews)
+string(Title(Posts[0]))
+map(Posts, toBase64(" "))
+{"JavaScript": TotalViews, "JavaScript": Authors}
+(TotalViews - TotalViews) * -0
+map(Posts, TotalViews * 0)
+toJSON(false ? Authors : Authors)
+!false != none(Posts, true)
+map(Posts, 0.5 < TotalViews)
+string(1 ** TotalViews)
+min(float(TotalViews))
+TotalViews == 1 ? nil : Authors
+Posts == Posts != true
+0.5 * TotalViews - TotalViews
+TotalViews in TotalViews .. 2
+filter(Posts, "JavaScript" endsWith "Go")
+-min(1)
+TotalViews + 1 in Posts
+not (" " != nil)
+[0.5 + 0]
+max(TotalViews, TotalViews) > TotalViews
+string(Add(2, 0))
+all(Posts, nil != Authors)
+TotalViews == abs(0)
+TotalViews ** 0 != -0
+any(Posts, 0.5 != nil)
+not (nil != "JavaScript")
+1 + 0 >= TotalViews
+TotalViews * 0 ** TotalViews
+toJSON(string(TotalViews))
+TotalViews ^ count(Posts, Authors == nil)
+0 * 0 in Authors
+[TotalViews % 2]
+min(float(TotalViews), 0 / TotalViews)
+any(map(Posts, 2), TotalViews <= 0.5)
+0.5 - TotalViews > TotalViews
+string(nil != nil)
+(TotalViews - TotalViews) * (2 + 0.5)
+int(count(Posts, true))
+0 > TotalViews || 1 >= TotalViews
+count(Posts, 0.5 < 0.5)
+any(Posts, 2 >= TotalViews)
+0.5 + TotalViews + TotalViews
+min(TotalViews) in Authors ? nil : nil
+not (2 >= TotalViews)
+get(Posts, TotalViews - 1)
+abs(false ? 0.5 : TotalViews)
+TotalViews ** abs(TotalViews)
+float(TotalViews * 0)
+TotalViews < 0.5 - TotalViews
+TotalViews ^ -0
+-(TotalViews / 1)
+map(Posts, toJSON("JavaScript"))
+map(Posts, filter(Posts, false))
+none(Posts, 2 < TotalViews)
+2 > TotalViews and nil == Posts
+TotalViews in Authors ? nil : Posts
+--1
+min(TotalViews ^ TotalViews)
+max(TotalViews + 0)
+TotalViews * TotalViews >= TotalViews
+map(map(Posts, false), Posts)
+Add(0, 0.5) + TotalViews
+all(Posts, 1 > 2)
+TotalViews != TotalViews * TotalViews
+{"Go": Posts}?.FirstName
+map(map(Posts, 2), Posts)
+upper(string(2))
+2 * 0 .. TotalViews
+Posts == [TotalViews, Authors]
+get(Posts, TotalViews) != get(Posts, TotalViews)
+{"Go": 1, " ": Posts}.ID
+toJSON(TotalViews ^ 1)
+none(Posts, 1 <= 0.5)
+0 - TotalViews > TotalViews ? false : nil
+TotalViews == 0 ? Authors : Posts
+{"JavaScript": " " != nil}
+[Authors, Posts]
+0.5 - 2 <= TotalViews
+len(Posts) <= TotalViews
+len(Authors) <= TotalViews
+-float(2)
+0.5 ** TotalViews != TotalViews
+-TotalViews in filter(Posts, true)
+2 ** 0 ^ (TotalViews / TotalViews)
+TotalViews ** TotalViews != TotalViews ** TotalViews
+float(2 - TotalViews)
+map(Posts, nil == Posts)
+TotalViews * 1 % TotalViews
+toJSON(true ? TotalViews : Posts)
+TotalViews % TotalViews == TotalViews
+-0 != TotalViews
+TotalViews ** TotalViews ^ TotalViews
+trim(toJSON(nil))
+any(Posts, TotalViews == nil)
+string(TotalViews < TotalViews)
+int(0.5 ^ 2)
+!(TotalViews < 2)
+first([" ", TotalViews, TotalViews, Authors, Authors])
+WithID(Posts, 0).ID + TotalViews
+none(Posts, 0 in Posts)
+first(Posts[0:TotalViews])
+get(Posts, 2).Likes
+TotalViews >= 2 - TotalViews
+count(map(Posts, Posts), TotalViews in Authors)
+TotalViews != TotalViews ? Posts : Posts
+TotalViews + TotalViews != count(Posts, true)
+TotalViews ** 0 >= TotalViews
+Authors[1].Email
+min(min(0))
+float(0 * 2)
+TotalViews + abs(TotalViews % 1)
+0.5 != TotalViews or 0 != nil
+abs(1) < TotalViews
+{"Go": nil, "JavaScript": "Go"}?.CommentDate
+one(Posts, " " != nil)
+int(TotalViews) in map(Posts, Posts)
+TotalViews + 0 .. TotalViews
+TotalViews - TotalViews / 0
+0.5 / TotalViews < TotalViews ** 2
+none(Posts, TotalViews <= 0)
+Authors[len(Posts)]
+lower(toJSON(Authors))
+!(0.5 != 2)
+TotalViews != TotalViews ? nil : TotalViews
+int(TotalViews * 0.5)
+len(Posts) <= -TotalViews
+!(0 < 0)
+Posts == nil ? Authors : nil
+-(TotalViews + 2)
+TotalViews * TotalViews - TotalViews
+1 < TotalViews || 0 == 0
+not (nil != 0)
+TotalViews >= 0.5 != nil
+none(Posts, TotalViews < 1)
+map(Posts, 0 in Authors)
+not true ? Posts : Posts
+string(0.5 < TotalViews)
+int(TotalViews) != TotalViews
+map(Posts[TotalViews:TotalViews], Posts)
+(TotalViews - 0) ^ TotalViews
+len(Posts) + TotalViews
+{"JavaScript": " ", "Go": TotalViews, "Go": 2}?.Tags
+!(1 < 0)
+one(filter(Posts, false), 0 == nil)
+abs(TotalViews) .. TotalViews
+TotalViews % 1 < TotalViews ? 0.5 : Authors
+map(Posts, 1 + TotalViews)
+string(true == true)
+TotalViews ** (0.5 * TotalViews)
+none(Posts, false == true)
+int(0.5 ** TotalViews)
+TotalViews .. max(TotalViews)
+TotalViews <= count(Posts, true)
+!(Posts == nil)
+{"JavaScript": Authors, "Go": "Go"}.Upvotes
+float(0.5 + TotalViews)
+TotalViews % 1 + TotalViews / 0
+"JavaScript" in Authors[TotalViews]
+TotalViews + TotalViews + 0.5
+all(Posts, false == false)
+TotalViews < 0 / TotalViews
+map(Posts, 0.5 * 2)
+[-TotalViews]
+get(Posts, false ? 0 : Authors)
+get(Posts, true ? TotalViews : true)
+max(max(TotalViews))
+!(TotalViews >= 1)
+Posts == Posts or 2 <= 0
+-0.5 == TotalViews
+map(TotalViews .. 1, Title(nil))
+not !(TotalViews > TotalViews)
+(0.5 + 2) ** len(Posts)
+!true ? Posts : Authors
+abs(0.5 ** 0)
+all(Posts, TotalViews == 1)
+string(0 in Posts)
+TotalViews + max(0)
+get(Authors, int(0))
+get(Posts, true ? 0 : Authors)
+TotalViews > TotalViews % TotalViews
+len(Posts) != TotalViews
+float(TotalViews * 2)
+0 % TotalViews / 0.5 / 1
+toJSON(min(TotalViews))
+string(any(Posts, true))
+not !(Authors != Authors)
+-0.5 ** TotalViews
+Authors != Authors && one(Posts, true)
+TotalViews * 2 == TotalViews
+int(0.5) <= TotalViews ? Posts : 0
+one(Posts, true) && TotalViews in Posts
+TotalViews + 0 > 0 ^ 0
+any(Posts, .Equal(#))
+TotalViews ^ TotalViews / TotalViews
+0 / 0 != TotalViews / TotalViews
+2 ^ TotalViews - TotalViews
+map(map(Posts, 0), Posts)
+-(1 * 0)
+map(Posts, 1 != TotalViews)
+min(TotalViews ^ 0)
+map(false ? " " : Posts, Authors)
+{"JavaScript": Authors, "Go": TotalViews}?.Profile
+upper(false ? TotalViews : "Go")
+min(1 % 1)
+max(0.5 - 2)
+-(TotalViews - 2)
+all(Posts, nil in Posts)
+TotalViews + 0 + TotalViews
+Posts != map(Posts, Authors)
+TotalViews * TotalViews < TotalViews
+{" ": TotalViews, "JavaScript": TotalViews}?.Content
+0 != TotalViews ? TotalViews : TotalViews
+{" ": "JavaScript", " ": TotalViews}.ID
+min(0 - TotalViews)
+TotalViews + 0 in Authors
+TotalViews - TotalViews / 0.5
+TotalViews != max(TotalViews, TotalViews)
+0.5 ** 1 == TotalViews
+len(Authors) in Posts
+filter(Posts, Posts == Posts)
+TotalViews ^ 0.5 ^ TotalViews
+all(map(Posts, 0.5), TotalViews in Authors)
+TotalViews + TotalViews >= TotalViews
+(0 % TotalViews) ** TotalViews
+filter(map(Posts, " "), TotalViews >= 0)
+TotalViews in Authors or TotalViews in Posts
+-max(0.5)
+all(Posts, 0 < TotalViews)
+WithID(Posts, 1)?.Content
+!false ? nil : 1
+-0 ** TotalViews
+{" ": TotalViews, "JavaScript": nil}?.CommentDate
+int(TotalViews ^ 1)
+map(Posts, .Content)
+string(false != false)
+filter(Posts, any(Posts, true))
+abs(true ? TotalViews : Posts)
+map(Posts, # != #)
+toJSON(0 ^ TotalViews)
+not false ? 0.5 : Authors
+TotalViews - 0 <= TotalViews
+TotalViews ^ TotalViews + TotalViews
+TotalViews * TotalViews / 0
+float(0 + 0.5)
+abs(count(Posts, true))
+max(0) ** TotalViews
+not (1 >= TotalViews)
+filter(Posts, false != true)
+string(toJSON(true))
+0 % TotalViews < TotalViews
+map(map(Posts, TotalViews), 2 != TotalViews)
+-(2 ** TotalViews)
+none(Posts, TotalViews > TotalViews)
+get(Authors, 2 * TotalViews)
+[Authors] != Posts
+Posts[0 % TotalViews]
+(0 + TotalViews) / TotalViews
+true ? TotalViews : 1 .. TotalViews
+float(0.5) ** TotalViews
+TotalViews * 1 <= abs(TotalViews)
+TotalViews + 1 >= TotalViews
+0 * 0.5 - TotalViews
+filter(Posts, 0 < 0)
+TotalViews == min(TotalViews)
+{"JavaScript": " ", "JavaScript": TotalViews}.Comments
+TotalViews == TotalViews ** 0
+-TotalViews > 0.5 ? "JavaScript" : 2
+TotalViews / (0.5 + 0.5)
+TotalViews ^ min(0)
+TotalViews * 1 ^ TotalViews
+map(map(Posts, TotalViews), -0)
+string(0.5 ** 0)
+count(Posts, false) > TotalViews ? 1 : Posts
+min(TotalViews % 2)
+0.5 / TotalViews < TotalViews
+!(0 != 0)
+!true ? TotalViews : Posts
+last(map(Posts, " "))
+TotalViews * 0 % TotalViews
+float(TotalViews - 1)
+string(TotalViews ** 0.5)
+map(Posts, TotalViews <= 0)
+TotalViews ** 0 * TotalViews
+abs(TotalViews ^ TotalViews)
+TotalViews in Posts and nil in Authors
+TotalViews / 1 / TotalViews
+TotalViews % TotalViews - TotalViews
+len(TotalViews .. 0)
+Posts[count(Posts, false)]
+toJSON(0 <= TotalViews)
+any(Posts, nil != 1)
+not (2 >= 0)
+0.5 > TotalViews and TotalViews <= TotalViews
+-(TotalViews ** 0.5)
+not (false != nil)
+TotalViews == TotalViews * TotalViews
+not (1 <= TotalViews)
+not (0 != 0)
+0.5 + TotalViews <= TotalViews
+string(1 - 0.5)
+TotalViews <= max(TotalViews)
+-TotalViews in Posts
+any(Posts, 0 in Authors)
+any(Posts, TotalViews == 1)
+abs(0 + TotalViews)
+TotalViews / 1 - TotalViews
+one(Posts, 2 <= 1)
+TotalViews / 1 * 0
+TotalViews == TotalViews ? Authors : Posts
+not !(TotalViews in Authors)
+(2 - TotalViews) * TotalViews ^ TotalViews
+not (1 != TotalViews)
+int(0.5 + 0.5)
+map(false ? 2 : Posts, #)
+count(Posts, 0 < TotalViews)
+map(Posts, 0.5 != TotalViews)
+TotalViews ** TotalViews ^ 0.5
+abs(0 / TotalViews)
+TotalViews <= TotalViews ? TotalViews : 1
+all(Posts, 0 <= 1)
+Authors[max(TotalViews)]
+0.5 != TotalViews || Posts != Posts
+any(map(Posts, true), 1 < TotalViews)
+lower(upper(" "))
+TotalViews >= 2 ? TotalViews : true
+string(0 / 0.5)
+none(Posts, false ? Posts : true)
+TotalViews ^ (TotalViews * 0.5)
+0 % 1 != 0 ^ TotalViews
+Authors[2].LastName
+TotalViews in Posts == nil
+Posts == Posts ? true : Authors
+all(Posts, TotalViews != 0.5)
+upper(toBase64("JavaScript"))
+int(1) .. TotalViews
+TotalViews ^ (TotalViews * TotalViews)
+TotalViews / max(TotalViews)
+string(nil in Authors)
+min(0.5 ^ 0)
+2 % TotalViews + TotalViews
+not (1 == 0)
+max(-0)
+(TotalViews + TotalViews) / (TotalViews + 1)
+not not true
+TotalViews ^ (TotalViews * 0)
+not false ? nil : TotalViews
+Authors[1 + TotalViews]
+toJSON(false ? Posts : Posts)
+map(Posts, TotalViews == 0)
+(0 + 0) / 1 ** 2
+true ? 1 : 0 / TotalViews
+none(Posts, nil != Authors)
+nil != Posts or 2 > TotalViews
+toJSON(min(TotalViews, 0.5))
+all(Posts, TotalViews <= TotalViews)
+any(Posts, 1 > TotalViews)
+TotalViews > 1 ^ 2
+one(Posts, not true)
+one(Posts, TotalViews > 0)
+none(Posts, 2 <= TotalViews)
+none(map(Posts, Posts), nil == Posts)
+0.5 ** TotalViews ** TotalViews
+0 + 1 <= TotalViews
+!false ? false : true
+abs(true ? TotalViews : TotalViews)
+-(0 ** 0)
+TotalViews * (TotalViews + 0)
+TotalViews % (TotalViews + TotalViews)
+toJSON(map(Posts, 0.5))
+float(TotalViews) != TotalViews
+{"JavaScript": 1, "Go": Posts}?.PublishDate
+min(1 % TotalViews)
+TotalViews != 0.5 && TotalViews in Posts
+TotalViews != 0 % TotalViews
+min(0 ^ TotalViews)
+WithID(Posts, 0).ID
+toJSON(0.5 + 0.5)
+TotalViews + 0 / 0
+TotalViews >= 0 ? Authors : Authors
+toBase64(string(TotalViews))
+{"JavaScript": "JavaScript"}.Content
+any(Posts, 2 != 0.5)
+TotalViews + -0
+TotalViews >= TotalViews and 2 in Authors
+Posts != Posts == false ? false : TotalViews
+[Posts, TotalViews] != Posts
diff --git a/testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e b/testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e
new file mode 100644
index 000000000..751f951d4
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("duration(toJSON(1))")
diff --git a/testdata/fuzz/FuzzExpr/87861ab0b9f0abbe b/testdata/fuzz/FuzzExpr/87861ab0b9f0abbe
new file mode 100644
index 000000000..58c76a3b0
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/87861ab0b9f0abbe
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("[[0][0]][0][:0]")
diff --git a/testdata/fuzz/FuzzExpr/b65163ca9e44703c b/testdata/fuzz/FuzzExpr/b65163ca9e44703c
new file mode 100644
index 000000000..e24cea08f
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/b65163ca9e44703c
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("map(false?:Authors,.A)")

From a3bd3a14a3fb350daf28266e8484288dd85f02e9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 12:41:06 +0200
Subject: [PATCH 076/506] Do not set int type for 1/0 expression

---
 checker/checker_test.go | 5 +++++
 checker/types.go        | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/checker/checker_test.go b/checker/checker_test.go
index 5b6a31365..74f02ef37 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -499,6 +499,11 @@ cannot use float64 as type string in map key (1:4)
 cannot use float64 as type int in map key (1:5)
  | 1/2 in MapIntAny
  | ....^
+
+repeat("0", 1/0)
+cannot use float64 as argument (type int) to call repeat  (1:14)
+ | repeat("0", 1/0)
+ | .............^
 `
 
 func TestCheck_error(t *testing.T) {
diff --git a/checker/types.go b/checker/types.go
index bb23aa190..f5fcbdab3 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -241,7 +241,7 @@ func isIntegerOrArithmeticOperation(node ast.Node) bool {
 		}
 	case *ast.BinaryNode:
 		switch n.Operator {
-		case "+", "/", "-", "*":
+		case "+", "-", "*":
 			return true
 		}
 	}

From 692a25396290abbc035f5dc26ce91782b238a2bb Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 12:43:27 +0200
Subject: [PATCH 077/506] Update fuzz_test.go

---
 fuzz_test.go                            |  120 +-
 testdata/corpus.txt                     | 3446 -----------------------
 testdata/fuzz/FuzzExpr/1fedafb72e35699d |    2 +
 testdata/fuzz/FuzzExpr/37464e3dcb75a05c |    2 +
 testdata/fuzz/FuzzExpr/42564f0e9eda1ad1 |    2 +
 testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e |    2 -
 testdata/fuzz/FuzzExpr/87861ab0b9f0abbe |    2 -
 testdata/fuzz/FuzzExpr/b1aef962e961045a |    2 +
 testdata/fuzz/FuzzExpr/b65163ca9e44703c |    2 -
 testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c |    2 +
 testdata/fuzz/FuzzExpr/c6717d9f77902b9c |    2 +
 testdata/fuzz/FuzzExpr/cd662894c578ed90 |    2 +
 testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd |    2 +
 13 files changed, 110 insertions(+), 3478 deletions(-)
 delete mode 100644 testdata/corpus.txt
 create mode 100644 testdata/fuzz/FuzzExpr/1fedafb72e35699d
 create mode 100644 testdata/fuzz/FuzzExpr/37464e3dcb75a05c
 create mode 100644 testdata/fuzz/FuzzExpr/42564f0e9eda1ad1
 delete mode 100644 testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e
 delete mode 100644 testdata/fuzz/FuzzExpr/87861ab0b9f0abbe
 create mode 100644 testdata/fuzz/FuzzExpr/b1aef962e961045a
 delete mode 100644 testdata/fuzz/FuzzExpr/b65163ca9e44703c
 create mode 100644 testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c
 create mode 100644 testdata/fuzz/FuzzExpr/c6717d9f77902b9c
 create mode 100644 testdata/fuzz/FuzzExpr/cd662894c578ed90
 create mode 100644 testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd

diff --git a/fuzz_test.go b/fuzz_test.go
index be395e47b..b9af4ec21 100644
--- a/fuzz_test.go
+++ b/fuzz_test.go
@@ -1,53 +1,121 @@
 package expr_test
 
 import (
-	"os"
 	"regexp"
 	"strings"
 	"testing"
 
 	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/test/playground"
 )
 
 func FuzzExpr(f *testing.F) {
-	env := playground.ExampleData()
-
-	b, err := os.ReadFile("testdata/corpus.txt")
-	if err != nil {
-		f.Fatal(err)
+	env := map[string]interface{}{
+		"i": 1,
+		"j": 2,
+		"a": []int{1, 2, 3},
+		"m": map[string]interface{}{"a": 1, "b": 2, "m": map[string]int{"a": 1}},
+		"s": "abc",
 	}
-	for _, testcase := range strings.Split(string(b), "\n") {
-		f.Add(testcase)
+
+	fn := expr.Function(
+		"fn",
+		func(params ...interface{}) (interface{}, error) {
+			return params[0], nil
+		},
+		new(func(int) int),
+	)
+
+	corpus := []string{
+		`.5 + .5`,
+		`i + j`,
+		`i - j`,
+		`i * j`,
+		`i / j`,
+		`i % j`,
+		`true || false`,
+		`true && false`,
+		`i == j`,
+		`i != j`,
+		`i > j`,
+		`i >= j`,
+		`i < j`,
+		`i <= j`,
+		`i in a`,
+		`i not in a`,
+		`i in m`,
+		`m.a`,
+		`m.m.a`,
+		`a[0]`,
+		`a[i]`,
+		`a[i:j]`,
+		`a[i:]`,
+		`a[:j]`,
+		`a[:]`,
+		`a[1:-1]`,
+		`len(a)`,
+		`abs(-1)`,
+		`int(0.5)`,
+		`float(42)`,
+		`string(i)`,
+		`trim(" a ")`,
+		`trim("_a_", "_")`,
+		`trimPrefix("  a")`,
+		`trimSuffix("a  ")`,
+		`upper("a")`,
+		`lower("A")`,
+		`split("a,b,c", ",")`,
+		`replace("a,b,c", ",", "_")`,
+		`repeat("a", 3)`,
+		`join(["a", "b", "c"], ",")`,
+		`indexOf("abc", "b")`,
+		`max(1,2,3)`,
+		`min(1,2,3)`,
+		`toJSON(a)`,
+		`fromJSON("[1,2,3]")`,
+		`now()`,
+		`duration("1s")`,
+		`first(a)`,
+		`last(a)`,
+		`get(m, "a")`,
+		`1..9 | filter(i > 5) | map(i * 2)`,
+		`s startsWith "a"`,
+		`s endsWith "c"`,
+		`s contains "a"`,
+		`s matches "a"`,
+		`s matches "a+"`,
+		`true ? 1 : 2`,
+		`fn(1)`,
+		`{a: 1, b: 2}`,
+		`[1, 2, 3]`,
 	}
 
-	f.Add(`Posts[0].Comments[0].AuthorEmail()`)
-	f.Add(`Posts[0].Comments[0].Upvoted()`)
-	f.Add(`Posts[0].Comments[0].CommentDate.Add(now())`)
-	f.Add(`Posts[0].Comments[0].CommentDate.AddDate(0, 0, 1)`)
-	f.Add(`Authors[Posts[0].Author.ID].Profile.Biography`)
-	f.Add(`Authors[2].Profile.Age()`)
-	f.Add(`Authors[2].Profile.Website`)
+	for _, s := range corpus {
+		f.Add(s)
+	}
 
 	okCases := []*regexp.Regexp{
+		regexp.MustCompile(`cannot fetch .* from .*`),
+		regexp.MustCompile(`cannot get .* from .*`),
 		regexp.MustCompile(`cannot slice`),
+		regexp.MustCompile(`slice index out of range`),
+		regexp.MustCompile(`error parsing regexp`),
 		regexp.MustCompile(`integer divide by zero`),
-		regexp.MustCompile(`invalid operation`),
 		regexp.MustCompile(`interface conversion`),
-		regexp.MustCompile(`memory budget exceeded`),
-		regexp.MustCompile(`slice index out of range`),
-		regexp.MustCompile(`cannot fetch .* from .*`),
-		regexp.MustCompile(`cannot get .* from .*`),
 		regexp.MustCompile(`invalid argument for .*`),
-		regexp.MustCompile(`json: unsupported value`),
-		regexp.MustCompile(`error parsing regexp`),
+		regexp.MustCompile(`invalid character`),
+		regexp.MustCompile(`invalid operation`),
+		regexp.MustCompile(`invalid duration`),
 		regexp.MustCompile(`time: missing unit in duration`),
+		regexp.MustCompile(`time: unknown unit .* in duration`),
+		regexp.MustCompile(`json: unsupported value`),
+		regexp.MustCompile(`unexpected end of JSON input`),
+		regexp.MustCompile(`memory budget exceeded`),
 		regexp.MustCompile(`using interface \{} as type .*`),
 		regexp.MustCompile(`reflect.Value.MapIndex: value of type .* is not assignable to type .*`),
-		regexp.MustCompile(`reflect: call of reflect.Value.Call on zero Value`),
-		regexp.MustCompile(`reflect: call of reflect.Value.Len on bool Value`),
 		regexp.MustCompile(`reflect: Call using .* as type .*`),
+		regexp.MustCompile(`reflect: call of reflect.Value.Call on .* Value`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Index on map Value`),
+		regexp.MustCompile(`reflect: call of reflect.Value.Len on .* Value`),
 	}
 
 	skipCode := []string{
@@ -62,7 +130,7 @@ func FuzzExpr(f *testing.F) {
 			}
 		}
 
-		program, err := expr.Compile(code, expr.Env(playground.Blog{}))
+		program, err := expr.Compile(code, expr.Env(env), fn)
 		if err != nil {
 			t.Skip()
 		}
diff --git a/testdata/corpus.txt b/testdata/corpus.txt
deleted file mode 100644
index 420ef66ad..000000000
--- a/testdata/corpus.txt
+++ /dev/null
@@ -1,3446 +0,0 @@
-TotalViews
-Authors
-len(Authors)
-Posts
-map(Posts, float(TotalViews))
-all(map(Posts, 0.5), TotalViews < TotalViews)
-Authors == Authors
--TotalViews
-map(Posts, TotalViews)
-len(Posts)
-TotalViews .. TotalViews
-first(Posts)
-min(TotalViews)
-Authors[0]?.ID
-int(TotalViews)
-string(Authors)
-toJSON(Posts)
-map(Posts, int(TotalViews))
-Authors[TotalViews]?.FirstName
-TotalViews >= TotalViews
-abs(TotalViews)
-Authors[TotalViews]?.LastName
-string(TotalViews)
-TotalViews <= TotalViews
-string(get(Posts, TotalViews))
-TotalViews + -TotalViews
-one(Posts, TotalViews > TotalViews)
-get(Posts, TotalViews)
-TotalViews <= 0.5 * TotalViews
-toJSON(TotalViews)
-float(TotalViews)
-map(Posts, 0 / TotalViews)
-all(Posts, 0 in Authors)
-last(Posts)
-TotalViews * TotalViews == TotalViews
-Authors[TotalViews]
-TotalViews ** TotalViews
-map(Posts, Authors)
-one(Posts, 1 != TotalViews)
-TotalViews * TotalViews == 0 ^ TotalViews
-string(map(Posts, TotalViews))
-get(Posts, 0)?.PublishDate
-TotalViews == len(Authors)
-[Authors]
-TotalViews - TotalViews
-filter(Posts, nil == TotalViews)
-IsAdmin(Authors[0])
-string(Posts)
-get(Posts, TotalViews)?.PublishDate
-Authors[TotalViews]?.ID
-Authors[TotalViews]?.Profile
-TotalViews < TotalViews
-max(TotalViews)
-Authors != Authors
-map(Posts, #)
-len(map(Posts, 0))
-string(TotalViews .. TotalViews)
-TotalViews > TotalViews
-last(0 .. TotalViews)
-toJSON(Authors)
-{" ": TotalViews}?.Content
-last(map(Posts, Posts))
-TotalViews == TotalViews
--(TotalViews / 0.5)
-Posts != Posts
-TotalViews ** 0 < TotalViews
-!("JavaScript" <= "Go")
-Authors[TotalViews].ID
-int(min(1, 0))
-Authors[TotalViews % TotalViews]
-map(map(Posts, Authors), nil == Posts)
--max(2)
--(TotalViews + TotalViews)
-{"Go": nil, "Go": 0.5}?.Content?.AuthorName
-get(Posts, 2).Title
-!(TotalViews == nil)
-first(Posts).Title
-not none(Posts, true)
-not (nil in Posts)
-TotalViews ^ TotalViews
-map(Posts, Posts)
--(TotalViews % TotalViews)
-get(Posts, 0).Content
-last(Posts)?.Likes
-TotalViews in Posts
-Authors[TotalViews].LastName
-get(Posts, 0).Title
-filter(Posts, TotalViews > TotalViews)
-{"JavaScript": Posts}
---TotalViews
-TotalViews + TotalViews
-TotalViews .. abs(TotalViews)
-TotalViews != TotalViews
-!(1 != TotalViews)
-WithID(Posts, TotalViews)?.ID
-TotalViews < -TotalViews
-get(map(Posts, TotalViews), TotalViews)
-TotalViews / TotalViews
-TotalViews < TotalViews ? Authors : Authors == Authors
-[get(Posts, TotalViews), Authors]
-map(Posts, float(1))
-Authors[2].ID
-TotalViews >= TotalViews ? TotalViews : Posts
-TotalViews % TotalViews
-max(0 ** 0.5)
-TotalViews > TotalViews ? Authors : 0.5
-TotalViews + TotalViews - TotalViews
-Posts == Posts
-TotalViews ** 0 - TotalViews
-not none(Posts, false)
-any(Posts, TotalViews <= 2)
-IsAdmin(get(Authors, TotalViews))
-!(Authors != nil)
-TotalViews in Posts ? TotalViews : 2
-[TotalViews]
-TotalViews <= TotalViews + TotalViews
-float(TotalViews) >= TotalViews
-0 % TotalViews .. TotalViews + TotalViews
-0 ** TotalViews >= float(0)
-first(Posts)?.ID
-not (Authors != nil)
-TotalViews in Authors
-Posts[0].Content
-not (TotalViews == 0)
-!any(Posts, false)
-!(TotalViews == 0)
-TotalViews - TotalViews <= float(0)
-TotalViews ^ 1 ^ 1
--(TotalViews - 0)
-first(Posts).Likes
-!(Authors == Authors)
-float(TotalViews) > count(Posts, true)
-false ? Authors : TotalViews + TotalViews
-all(Posts, TotalViews < TotalViews)
-toJSON(" " startsWith " ")
-string(filter(Posts, true))
-int(TotalViews / TotalViews)
-float(0 ^ TotalViews)
-get(Posts, 0)?.Likes
-all(Posts, TotalViews > TotalViews)
-not (1 in Posts)
-WithID(Posts, 1).PublishDate
-TotalViews >= TotalViews ** TotalViews
-get(Authors, 1)?.FirstName
--(0 - TotalViews)
-(0.5 / TotalViews) ^ TotalViews
---0
-trim(upper("Go"))
-int(int(TotalViews))
-TotalViews <= TotalViews ** TotalViews
--(0 + TotalViews)
-none(Posts, "Go" contains "JavaScript")
-toJSON(0.5 == 2)
--int(TotalViews)
-!(TotalViews in Authors)
-Posts[2].PublishDate
--2 in Authors
-map(Posts, #?.Likes)
-(2 + TotalViews) ^ TotalViews
-(TotalViews + TotalViews) / TotalViews
-Authors[TotalViews].FirstName
-none(Posts, Posts == Posts)
-toJSON(TotalViews > TotalViews)
-(TotalViews * 0.5) ** TotalViews
-Posts[2]?.Author
-Authors[nil].FirstName
-!(TotalViews == TotalViews)
--(TotalViews ** TotalViews)
-toJSON(TotalViews ** 2)
-first(Posts).Tags
-not (Authors == Authors)
-min(2 ** TotalViews)
--(0 - 0)
-1 < TotalViews ? Posts : Authors
-all(Posts, one(Posts, true))
-map(Posts, TotalViews <= 2)
-[Posts]
-TotalViews * TotalViews
-TotalViews <= -(0.5 - TotalViews)
-WithID(Posts, TotalViews)
-Posts != map(Posts, Posts)
-!(2 == TotalViews)
-!(nil == Authors)
-get(Authors, TotalViews)
--(TotalViews ** 0)
-Authors[1].FirstName
-TotalViews - 0 != -0
--(TotalViews * 0)
-string(TotalViews > TotalViews)
-map(map(Posts, Authors), #)
-{" ": TotalViews, " ": Posts}.PublishDate
-get(Authors, 0)?.Profile
-get(Authors, TotalViews).LastName
-first(Posts).Author
-{"Go": Authors}
-TotalViews > int(2)
-map(Posts, min(0.5))
-map(false ? 1 : Authors, Authors)
-!(TotalViews == 0.5)
-get(Posts, TotalViews)?.Tags
-!(nil != Posts)
-toJSON(TotalViews < TotalViews)
-0.5 * TotalViews * TotalViews
-TotalViews == TotalViews != nil
-string(!true)
--TotalViews ^ min(0)
-get(Posts, TotalViews)?.ID
-toJSON(max(0.5))
-TotalViews * 0 / TotalViews
-not not false
-{" ": Posts}?.Author
-any(Posts, Authors != Authors)
-get(Authors, 0)?.Email
-string(Posts[TotalViews:TotalViews])
-get(Posts, TotalViews)?.Likes
-first(map(Posts, true))
-abs(TotalViews / 0.5)
-Posts[2].Tags
-toJSON(upper("JavaScript"))
--0 + TotalViews
-toJSON(float(TotalViews))
-get(Authors, TotalViews)?.Email
-2 / TotalViews >= TotalViews
-TotalViews ^ TotalViews > TotalViews
-TotalViews < TotalViews - 0
-TotalViews > TotalViews * TotalViews
-TotalViews % TotalViews / TotalViews
-any(Posts, nil != Authors)
--TotalViews > TotalViews
-string(map(Posts, Authors))
-get(Authors, TotalViews)?.FirstName
-Authors[2]?.LastName
-any(Posts, TotalViews == 2)
-string(0 <= TotalViews)
-!(TotalViews > TotalViews)
-not (TotalViews == TotalViews)
-!(TotalViews >= TotalViews)
-map(Posts, TotalViews in Posts)
-count(Posts, TotalViews <= TotalViews)
-len(map(Posts, TotalViews))
-Title(WithID(Posts, TotalViews))
-TotalViews < 0 ? Authors : "Go"
-!(" " == nil)
-count(Posts, 0 >= TotalViews)
-not (TotalViews in Posts)
--(2 - TotalViews)
-get(Posts, -0)
-get(Posts, TotalViews)?.Content
-abs(len(Authors))
-TotalViews / (1 - 2)
-IsZero(WithID(Posts, 0))
-Posts[0].PublishDate
-TotalViews in Posts ? TotalViews : Authors
-get(Posts, 2)?.Likes
-toJSON(toJSON(Posts))
-map(Posts, get(Posts, TotalViews))
-get(Posts, TotalViews)?.Comments
-Posts[0]?.Tags
-TotalViews % TotalViews != TotalViews
-!(Authors != Authors)
-Authors[TotalViews].Profile
-!(0.5 == 0.5)
-not (TotalViews >= TotalViews)
-0.5 / 0 <= TotalViews
-abs(TotalViews ** TotalViews)
-TotalViews > TotalViews ? Posts : TotalViews
-!(TotalViews < TotalViews)
-not (0 == TotalViews)
-TotalViews + 0.5 ** TotalViews
-{" ": Authors}
-TotalViews == 1 / TotalViews
-TotalViews < TotalViews ? Authors : 1
-len(Posts) >= TotalViews ^ 0
-(0 % TotalViews) ^ 1 ^ 0
-last(Posts)?.Author
-map(Posts, not false)
-get(Authors, TotalViews).ID
-get(Posts, TotalViews)?.Author
-all(Posts, TotalViews > 0.5)
-Authors[TotalViews + TotalViews]
-TotalViews - TotalViews > TotalViews ^ TotalViews
--count(Posts, true)
-map(Posts, 0.5) != Posts
-!(TotalViews > 0)
-TotalViews + 1 .. TotalViews
-Posts == Posts ? TotalViews : 0
-toJSON(TotalViews / TotalViews)
-len(TotalViews .. TotalViews)
-toJSON(max(TotalViews))
-get(Authors, TotalViews)?.LastName
-TotalViews ** 2 + TotalViews
-WithID(Posts, 0)?.Content
-abs(TotalViews - TotalViews)
-last(Posts).Content
-Posts[2]?.Title
--abs(TotalViews)
-Authors[-1]
-max(TotalViews) < TotalViews
-abs(len(Posts))
-TotalViews / 0.5 / TotalViews
-toJSON(TotalViews == nil)
-toJSON(toJSON(nil))
-Posts[0].Likes
-not (TotalViews > TotalViews)
-first(Posts)?.Content
--(TotalViews * 0.5)
-toJSON(nil == Authors)
-true ? "JavaScript" : TotalViews in map(Posts, Posts)
-string(map(Posts, true))
-{"JavaScript": Authors}
-[Posts, Posts]
-toJSON(TotalViews <= TotalViews)
-get(Authors, 1 - TotalViews)
-get(map(Posts, Posts), TotalViews)
-string(TotalViews / 0)
-not (Posts == Posts)
-TotalViews > 0.5 * TotalViews
-TotalViews .. TotalViews % TotalViews
-get(Authors, TotalViews).Email
-string(none(Posts, false))
-toJSON(-0.5)
-TotalViews .. 1 == map(Posts, Authors)
-{"Go": Posts}
-not (0 != 0.5)
-get(Authors, TotalViews).Profile
-!(TotalViews != 0)
-WithID(Posts, TotalViews).Tags
-TotalViews > TotalViews + TotalViews
-none(Posts, TotalViews != TotalViews)
-map(map(Posts, 1), #)
-IsAdmin(Authors[TotalViews])
-!(0.5 < TotalViews)
-get(Authors, TotalViews).FirstName
-Posts[1]?.Comments
-all(Posts, TotalViews == TotalViews)
-TotalViews - TotalViews - 1
-{"Go": TotalViews}
-get(Posts, 1)?.Likes
-Authors[TotalViews].Email
-IsAdmin(get(Authors, 1))
-TotalViews ** 2 > TotalViews
-not (Posts != nil)
-string(-0.5)
-TotalViews % min(TotalViews)
-TotalViews > len(Authors)
-get(Posts, 0).Comments
-{"JavaScript": Authors}?.Website
-TotalViews ** 0 + TotalViews
-TotalViews <= -0
-{" ": nil}?.Comments
-!(false != nil)
-!(nil == Posts)
-Posts[1].Content
-lower(string(Authors))
-nil != Authors || true != false
-(TotalViews - TotalViews) % TotalViews
-Posts == Posts ? Authors : 0 * TotalViews
-0.5 != 2 ? Posts : Posts
-Authors[0].LastName
-{" ": Authors, " ": Authors, " ": Posts, "Go": false}.Birthday
-max(TotalViews - TotalViews)
-toJSON(Authors[TotalViews])
-none(map(Posts, false), #)
-not (Posts != Posts)
-get(Posts, 0).ID
-!(TotalViews != TotalViews)
-len(toJSON(Posts))
-TotalViews >= TotalViews % TotalViews
-!(TotalViews != 1)
-Title(Posts[1])
-none(Posts, "Go" > "Go")
-TotalViews * (TotalViews - TotalViews)
-toJSON(TotalViews <= 2)
-one(Posts, 0.5 == 1)
-get(map(Posts, 0), TotalViews)
-Authors[nil]?.ID
-string(nil in Posts)
-count(Posts, false) .. TotalViews
-TotalViews ** (TotalViews + 0)
-map(false ? Authors : Posts, Authors)
-last(Posts)?.Content
-2 - TotalViews == TotalViews
-TotalViews == TotalViews - 0
-none(Posts, TotalViews == 2)
-len(Authors) + TotalViews
-string(0 .. TotalViews)
-min(TotalViews + 0)
-!(TotalViews <= TotalViews)
--TotalViews >= TotalViews
-Title(last(Posts))
-toJSON(TotalViews <= 0.5)
-int(TotalViews ^ TotalViews)
-map(Posts, TotalViews == TotalViews)
-not (Posts == nil)
-TotalViews + 0 <= TotalViews
-len(string(Authors))
-get(Posts, 2)?.Content
-min(2 - TotalViews)
-Authors[0].ID
-string(int(TotalViews))
-Posts[TotalViews:TotalViews]
-0 - TotalViews - TotalViews
-not all(Posts, true)
--(TotalViews * TotalViews)
--TotalViews / TotalViews
-!(nil == TotalViews)
-not (nil != Authors)
-!(TotalViews < 0.5)
-map(map(Posts, TotalViews), 0 % TotalViews)
-0 - 0.5 >= TotalViews
-filter(Posts, 0 <= 0)
-map(Posts, get(Authors, 0))
-nil == Authors[TotalViews % TotalViews]
-Authors != nil ? nil : TotalViews
-float(min(TotalViews, 0))
-count(Posts, 1 >= TotalViews)
-last(Posts).Tags
-0.5 / TotalViews > TotalViews
-get(Authors, TotalViews)?.ID
-!(0.5 >= TotalViews)
-nil == 2 ? Posts : TotalViews
-max(TotalViews * 1)
-TotalViews / TotalViews - TotalViews
-map(Posts, Posts) == Posts
-0 == TotalViews or 0 > TotalViews
-all(Posts, Posts == Posts)
-get(Posts, 2).Comments
-get(Posts, max(TotalViews))
-not (TotalViews in Authors)
-first(map(Posts, Authors))
-get(Posts, 0).PublishDate
-!(2 < 1)
-min(TotalViews, TotalViews)
-(0.5 - TotalViews) / 0 ** 0
-none(Posts, 1 == TotalViews)
-get(Authors, 0)?.ID
-float(TotalViews) - TotalViews
-toJSON(not true)
-map(Posts, nil == TotalViews)
-get(Posts, 2).Content
-any(Posts, IsZero(#))
-last(Posts).Comments
-Posts[1].Likes
-string(TotalViews * 0)
-TotalViews * TotalViews * TotalViews
-false ? true : TotalViews * TotalViews
-not ("JavaScript" matches "JavaScript")
-0 % TotalViews .. TotalViews
-!(Posts == Posts)
-TotalViews == TotalViews ? TotalViews : TotalViews
-string(TotalViews + 2)
-{"JavaScript": Posts, " ": 0.5, "JavaScript": TotalViews}.Content
-map(Posts, toJSON(Posts))
-TotalViews in 0 .. TotalViews
-!false ? Authors : Authors
-toJSON(0 * TotalViews)
-Authors[2]?.FirstName
-not (0.5 <= TotalViews)
-!(0 <= 0)
-get(Posts, TotalViews)?.Title
-false ? Authors : TotalViews in Authors ? TotalViews : 0.5
-string(max(TotalViews))
-max(0 + TotalViews, TotalViews - 2)
-map(Posts, TotalViews ** 0)
-max(1 * TotalViews)
-max(max(0))
-0 >= TotalViews ? Posts : TotalViews
-TotalViews * 0.5 * 0.5 ^ 0
--0 ^ TotalViews
-{"Go": Posts, "JavaScript": true, "JavaScript": Authors}.Birthday
-!!true
-Authors[1 % 2]
-(0 - 0) ^ TotalViews
-TotalViews / TotalViews != TotalViews
-string(Posts == Posts)
-toJSON(TotalViews in Authors)
-get(Posts, 1)?.Content
-TotalViews - 0 % TotalViews
-!(nil != "Go")
-TotalViews * 2 % TotalViews
-map(map(Posts, Posts), TotalViews)
-2 * 2 > TotalViews
-WithID(Posts, TotalViews).Author
-int(len(Posts))
-map(Posts, TotalViews < TotalViews)
-Authors[TotalViews]?.Email
-map(Posts, 0.5 / 0)
-0.5 + 1 + TotalViews
-float(TotalViews % TotalViews)
-!(Posts != nil)
-string(!false)
-TotalViews ** 2 == TotalViews
-IsZero(WithID(Posts, TotalViews))
-int(toJSON(0))
-last(Posts).Title
-filter(Posts, Posts == nil)
--TotalViews % TotalViews
-TotalViews + TotalViews .. TotalViews
-string(-TotalViews)
-!(2 in Posts)
-TotalViews < TotalViews ? Posts : 0.5
--TotalViews <= TotalViews
-get(Posts, 1)?.Comments
-toJSON(0 * 0.5)
-Authors[nil].ID
-get(Authors, int(TotalViews))
-abs(abs(2))
-Posts != filter(Posts, false)
-one(map(Posts, true), #)
-map(map(Posts, TotalViews), #)
-{"Go": Authors}?.Content
-not (nil != 0.5)
-Posts == map(Posts, 0.5)
-last(map(Posts, Authors))
-Posts[1]?.ID
-IsZero(last(Posts))
-TotalViews - TotalViews ** 0
-map(Posts, string(TotalViews))
-not (TotalViews != TotalViews)
-!none(Posts, true)
-string(toJSON(Posts))
-{" ": TotalViews}
-get(Authors, 0).FirstName
-not (0 != TotalViews)
-!(2 <= TotalViews)
-0 - 0 in Authors
-get(TotalViews .. TotalViews, TotalViews)
-not ("Go" != nil)
-string(TotalViews % TotalViews)
-Title(Posts[2])
-not (0 >= TotalViews)
-TotalViews / -TotalViews
-{"JavaScript": TotalViews}
-fromJSON(toJSON(TotalViews))
--len(Posts)
--(TotalViews ^ 0.5)
-TotalViews <= TotalViews == false
-" " in Authors[TotalViews]
-map(map(Posts, #), Authors)
-abs(TotalViews * TotalViews)
-get(Authors, 2)?.Email
-map(map(Posts, Posts), toJSON(Posts))
-TotalViews * 0 <= 2 - TotalViews
-TotalViews in Authors == nil
-map(map(Posts, TotalViews), get(Posts, 0))
-map(Posts, first(Posts))
-TotalViews + 0 == TotalViews
--TotalViews == TotalViews
-filter(Posts, TotalViews != TotalViews)
-TotalViews != 1 / TotalViews
-TotalViews + 0.5 <= TotalViews
-toJSON(TotalViews != 0)
-Authors[nil]?.Email
-Posts[1].Tags
-string(true == nil)
-none(Posts, nil != TotalViews)
-get(Authors, 1).ID
-get(Posts, 1).ID
-!(nil != TotalViews)
-float(TotalViews * TotalViews)
-get(Posts, TotalViews % TotalViews)
-one(map(Posts, Posts), 0 in Posts)
-Posts[1]?.Content
-TotalViews * int(0.5)
-string(toJSON(TotalViews))
-get(Posts, 1)?.Tags
-0 ** TotalViews / TotalViews
-all(Posts, false && false)
-map(map(Posts, 0), TotalViews)
-TotalViews <= 1 ^ TotalViews
-Authors[0 * 0]
-TotalViews <= TotalViews / 0.5
-string(TotalViews / TotalViews)
-TotalViews != 0 + 1
-{"Go": TotalViews, "Go": Authors, "Go": TotalViews}.Content
-TotalViews ^ TotalViews ** TotalViews
-first(map(Posts, Posts))
-!(Posts != Posts)
-WithID(Posts, 0)?.Comments
-map(map(Posts, "Go"), TotalViews)
-TotalViews > 0.5 ^ TotalViews
-count(Posts, TotalViews == 0.5)
-TotalViews ^ (0 / 0)
-map(Posts, last(Posts))
-WithID(Posts, TotalViews)?.Tags
-get(Posts, -1)
-min(0 + 0)
-TotalViews * TotalViews <= TotalViews
-len(Authors) in Authors
-Authors == nil ? Posts : TotalViews
-Posts != nil ? Authors : TotalViews
-one(Posts, TotalViews < TotalViews)
-!none(Posts, false)
-Posts[0].Author
-TotalViews != 0 ? TotalViews < TotalViews : Posts
-Authors[nil].Email
-get(Authors, 2)?.Profile
-{"JavaScript": Posts}?.ID
-first(Posts)?.Author
-not (0 < 0.5)
-first(filter(Posts, false))
-Posts[2]?.Tags
-TotalViews * TotalViews != TotalViews
-not (TotalViews < 0.5)
-filter(Posts, 0 == TotalViews)
-TotalViews ** 1 == TotalViews
--(0 / TotalViews)
-abs(-TotalViews)
-TotalViews == nil == nil
-map(map(Posts, 0.5), Posts)
-not (1 < TotalViews)
-TotalViews ^ -TotalViews
-Posts == Posts[TotalViews:TotalViews]
-Authors == Authors ? "Go" : Posts
-all(Posts, 2 >= TotalViews)
-TotalViews - TotalViews >= Authors[TotalViews].ID
-not (0 < TotalViews)
-map(Posts, TotalViews .. 0)
-max(TotalViews % TotalViews)
-toJSON(!false)
-map(Posts, TotalViews / 1)
-all(Posts, TotalViews in Posts)
-max(TotalViews + TotalViews)
-not (true or false)
-float(TotalViews) * TotalViews
-get(Authors, TotalViews)?.Profile
-TotalViews <= 0 % TotalViews
-TotalViews > TotalViews ? Posts : Authors[TotalViews]
-any(Posts, TotalViews in Posts)
-filter(Posts, none(Posts, false))
-IsZero(first(Posts))
-map(Posts, TotalViews >= TotalViews)
-nil != TotalViews ? TotalViews : map(Posts, TotalViews)
-abs(-0.5)
-TotalViews == TotalViews % TotalViews
-first(Posts)?.Comments
-WithID(Posts, TotalViews)?.Author
-one(Posts, nil != 1)
-first(Posts)?.Tags
-map(Posts, #?.Tags)
-Posts[1]?.Likes
-TotalViews >= TotalViews ? TotalViews : " "
-all(Posts, false) ? last(Posts) : TotalViews
-TotalViews ** (TotalViews * 1)
-TotalViews != -TotalViews
--(0 + 0)
-Posts[0]?.Comments
-count(Posts, nil != Posts)
-(0.5 + TotalViews) ** TotalViews
-TotalViews - TotalViews in Authors
-IsAdmin(Authors[nil])
-one(Posts, 0 <= 1)
-2 ** 0.5 > TotalViews ** 1
-any(Posts, nil in Posts)
-!(2 < 0)
-TotalViews < TotalViews != false
-{"JavaScript": Posts, "Go": "JavaScript"}.Birthday
-abs(TotalViews) >= TotalViews
-count(Posts, true) % TotalViews
-!(TotalViews < 1)
-filter(map(Posts, 0.5), TotalViews >= TotalViews)
-toJSON(0 ^ 2)
-TotalViews / (2 - 1)
-toJSON(first(Posts))
-TotalViews ^ 0 != TotalViews
-string(-(TotalViews * TotalViews))
-TotalViews != 0 / TotalViews
-toJSON(get(Authors, TotalViews))
-float(float(0))
-get(Posts, 1).Likes
-count(Posts, Posts != Posts)
-first(true ? Posts : Authors)
--min(TotalViews)
---0.5
-max(TotalViews ^ TotalViews)
-0.5 >= TotalViews ? Authors : TotalViews * TotalViews
-first(Posts[TotalViews:TotalViews])
-(TotalViews * TotalViews) ^ TotalViews
-map(Posts, abs(TotalViews))
-TotalViews == int(TotalViews)
-Authors[0]?.LastName
-not (0.5 < 1)
-TotalViews != 0.5 + TotalViews
-toJSON(TotalViews % TotalViews)
-true ? Authors : TotalViews % TotalViews
-one(Posts, Authors != Authors)
-[get(Authors, TotalViews)]
-not (0.5 != TotalViews)
-get(Posts, 1).Comments
-TotalViews + 0 in Posts
-0.5 ^ 1 <= TotalViews
-Posts[0]?.Likes
-first(Posts)?.PublishDate
-string(true ? TotalViews : TotalViews)
-int(1 / 0)
-0 * 1 * TotalViews
--(TotalViews / TotalViews)
-Authors[0]?.Profile
-max(TotalViews ^ 0)
-not false ? nil : Posts
-count(Posts, true) * TotalViews
-filter(Posts, 0 >= 0.5)
-all(Posts, Authors == Authors)
-TotalViews >= 0.5 ^ TotalViews
-get(Posts, 2).ID
-{"Go": TotalViews, "Go": TotalViews, "JavaScript": Authors, " ": Authors, "JavaScript": TotalViews}?.Title
-last(Posts)?.Tags
-TotalViews <= TotalViews / 0
-Authors != Authors == one(Posts, false)
-TotalViews in Posts ? "Go" : Authors
-TotalViews + 0 ^ TotalViews
-first(TotalViews .. TotalViews)
-get(Posts, TotalViews - TotalViews)
-string(TotalViews + TotalViews)
-none(Posts, TotalViews == TotalViews)
-min(-TotalViews)
-last(Posts).ID
-Posts[0].ID
-none(Posts, TotalViews <= TotalViews)
-string(map(Posts, Posts))
-get(TotalViews .. 0, TotalViews)
-one(Posts, TotalViews in Posts)
-get(Authors, 1)?.ID
-none(map(Posts, Posts), Posts == Posts)
-toJSON(TotalViews > 0)
-Posts[0]?.ID
-TotalViews / (TotalViews - 0)
-TotalViews / (TotalViews + TotalViews)
-TotalViews in Authors and TotalViews <= TotalViews
-map(Posts, Authors[TotalViews])
-int(1 * TotalViews)
-all(Posts, 2 == TotalViews)
-max(TotalViews, TotalViews)
-toJSON(get(Posts, TotalViews))
-{"JavaScript": TotalViews == TotalViews}
-min(0, TotalViews) ** TotalViews
-toBase64(string(Posts))
-TotalViews != 0 ** TotalViews
-count(Posts, TotalViews >= TotalViews)
-first(Posts).ID
-{"JavaScript": Authors, "Go": Authors}?.Likes?.ID
-TotalViews - TotalViews * TotalViews
-toJSON(map(Posts, Authors))
-{" ": Posts}
-float(TotalViews / 0)
-!(TotalViews == 1)
-TotalViews != TotalViews - TotalViews
-last(Posts)?.ID
-TotalViews == float(0.5)
-TotalViews ** (0 / TotalViews)
-count(Posts, !(TotalViews <= TotalViews))
-get(Authors, -0)
-Authors[nil]?.LastName
-toJSON(Authors == Authors)
-IsAdmin(get(Authors, 0))
-abs(TotalViews) <= TotalViews
-TotalViews == -TotalViews
-int(0 + 0)
-all(Posts, "JavaScript" < "Go")
-TotalViews >= 0 - TotalViews
-map(filter(Posts, false), TotalViews)
-string(TotalViews - TotalViews)
-!all(Posts, false)
-TotalViews == 1 ? 1 : Authors
-map(Posts, TotalViews ** 2)
-Posts[2]?.Likes
--(0 ^ 0)
-TotalViews ** (1 - TotalViews)
-TotalViews > 0 ^ 0.5
-last(map(Posts, "JavaScript"))
-not (2 != 0.5)
-!(TotalViews > 1)
-get(Authors, 0).ID
-max(TotalViews * 0)
-Authors[nil].LastName
-string(map(Posts, 0.5))
-map(map(Posts, TotalViews), TotalViews)
-Authors[0 + TotalViews]
-1 % TotalViews / TotalViews
-len(string(Posts))
-string(0 >= 0.5)
-(1 * TotalViews) ^ TotalViews
-!(1 > 0.5)
-not (1 in Authors)
--0 <= TotalViews / 0.5
-{" ": false, "Go": TotalViews}.FirstName
-TotalViews ** 0 ^ TotalViews
-toJSON(-TotalViews)
-string(TotalViews >= 2)
-int(TotalViews * TotalViews)
-TotalViews % TotalViews >= TotalViews
-get(map(Posts, Authors), TotalViews)
-TotalViews > TotalViews ** TotalViews
-WithID(Posts, TotalViews).ID
-TotalViews + 0.5 ^ TotalViews
-map(Posts, int(0))
-toJSON(1 > TotalViews)
-WithID(Posts, TotalViews).Comments
-len("JavaScript") > TotalViews
-Title(WithID(Posts, 0))
-string(Authors == nil)
-WithID(Posts, TotalViews).PublishDate
--(2 ** 0)
-string(false ? Posts : false)
-string(2 == 0.5)
-count(TotalViews .. TotalViews, TotalViews != TotalViews)
-!(true != true)
-get(Posts, 0)?.Content
-one(Posts, Posts != Posts)
-map(TotalViews .. TotalViews, TotalViews)
-count(Posts, TotalViews != 0)
-string(Authors[TotalViews])
-len(toJSON(2))
-upper(string(" "))
-map(Posts, Authors) != Posts
-not (nil != Posts)
-Title(get(Posts, 2))
-WithID(Posts, 0).Author.FirstName
-Authors[0]?.FirstName
-not (true || false)
-int(string(TotalViews))
--(0.5 ^ TotalViews)
-TotalViews > TotalViews ? Authors : TotalViews
-IsZero(get(Posts, 2))
-map(Posts, count(Posts, true))
-toJSON(0.5 < TotalViews)
-string(2 < TotalViews)
-not (TotalViews > 0.5)
-not (" " > "JavaScript")
-any(Posts, Authors == Authors)
-TotalViews in TotalViews .. 0
--(0.5 / TotalViews)
--(TotalViews ^ TotalViews)
-0 ** 0.5 + abs(TotalViews)
--1 in Posts
-one(Posts, 0 < TotalViews)
-TotalViews * TotalViews ** TotalViews
-!(0 in Authors)
-map(filter(Posts, true), #)
-get(map(Posts, "Go"), TotalViews)
-string(TotalViews % 1)
-!(TotalViews in Posts)
-toJSON(TotalViews ** 1)
-count(Posts, TotalViews in Authors)
-float(toJSON(TotalViews))
--float(TotalViews)
-Title(first(Posts))
-int(TotalViews) > TotalViews
-map(filter(Posts, false), 0 < 2)
-TotalViews <= TotalViews * 2
-map(map(Posts, "JavaScript"), Posts)
-any(Posts, TotalViews <= TotalViews)
-count(Posts, nil == nil)
-WithID(Posts, 0).Content
-TotalViews - min(0.5)
-map(Posts, Posts[0])
-map(map(Posts, Posts), #)
-0.5 + 0 + min(TotalViews)
-TotalViews in map(Posts, Authors)
-TotalViews != TotalViews ? TotalViews : nil
-Authors[1].LastName
-not (TotalViews == nil)
-0 - TotalViews in Posts
-get(Posts, 2 - TotalViews)
-none(Posts, TotalViews in Posts)
-TotalViews * abs(TotalViews)
-0.5 <= TotalViews or TotalViews > TotalViews
-get(false ? Authors : Authors, TotalViews % TotalViews)
-{" ": Posts}?.ID
-map(Posts, TotalViews in Authors)
-abs(TotalViews) != TotalViews
-min(TotalViews * TotalViews)
-first(Posts).PublishDate
-false ? true : TotalViews in Posts
-not all(Posts, false)
-count(Posts, 0 == 2)
-true ? Authors : TotalViews == TotalViews
-!(TotalViews != nil)
-{" ": TotalViews - 2}
-string(Authors[0])
-max(abs(0))
-TotalViews / TotalViews / TotalViews ^ TotalViews
-!(TotalViews <= 0)
-TotalViews ** (TotalViews - TotalViews)
-WithID(Posts, TotalViews).Content
-TotalViews ** TotalViews ** TotalViews
-TotalViews in Authors ? Posts : Posts
-{" ": false}?.Profile
-TotalViews ** (TotalViews * 2)
-TotalViews ^ 0 + TotalViews ^ TotalViews
-map(map(Posts, TotalViews), Posts)
-TotalViews + TotalViews / 0.5
-get(Posts, 2)?.Title
-0.5 ^ TotalViews ^ TotalViews
-TotalViews > -TotalViews
-string(0 > TotalViews)
-map(Posts, .ID)
-{"JavaScript": 1, " ": Authors}?.Biography
-not (TotalViews == 1)
-string(string(" "))
-map(Posts, 1 ^ TotalViews)
-toJSON("Go" matches "Go")
-filter(Posts, TotalViews in Posts)
-TotalViews in map(Posts, Posts)
-one(map(Posts, false), #)
-map(Posts, -TotalViews)
-{" ": Posts, "Go": Authors}.Author
-TotalViews * TotalViews / TotalViews
-IsZero(get(Posts, 0))
-one(Posts, TotalViews <= TotalViews)
-last(Posts).Likes
-!!false
-map(map(Posts, Authors), TotalViews > TotalViews)
-float(len(Authors))
-float(float(TotalViews))
-Authors[2]?.ID
-get(Posts, 2)?.Author
-min(len(Posts))
-!one(Posts, true)
-2 - TotalViews != TotalViews
-false ? Authors : TotalViews / int(TotalViews)
-map(false ? false : Posts, Posts)
-toJSON(one(Posts, false))
-WithID(Posts, TotalViews)?.Content
-!(0 >= 0)
-max(count(Posts, true))
-TotalViews <= len(Posts)
-TotalViews == TotalViews or 0 == TotalViews
-count(Posts, TotalViews == 2)
-Authors != Authors ? TotalViews : 0
-int(TotalViews) ^ TotalViews
-not (1 > 0)
--(TotalViews - TotalViews)
-{"JavaScript": Posts}.PublishDate
-float(TotalViews / TotalViews)
-map(TotalViews .. 0, Posts)
-last(map(Posts, TotalViews))
-{"JavaScript": Add(0, 0)}
-abs(TotalViews + 1)
-not (Authors != Authors)
-Authors[0].FirstName
-toJSON(TotalViews + 0)
---max(2)
-{"JavaScript": Authors, " ": Posts, " ": TotalViews}.Author
-not (TotalViews < 1)
-0 ^ 2 > count(Posts, false)
-not ("Go" contains "JavaScript")
-len(Posts) ** TotalViews
-abs(TotalViews ** 0)
-map(Posts, .Author)
-get(Posts, len(Posts))
-toJSON(min(2))
--(0.5 - TotalViews)
-count(Posts, Authors == Authors)
-{"JavaScript": TotalViews}.Website
-TotalViews <= TotalViews && TotalViews > TotalViews
-count(map(Posts, TotalViews), TotalViews < TotalViews)
-!(TotalViews >= 0)
-string(Authors) matches string(false)
-TotalViews ^ TotalViews * TotalViews
-one(Posts, Authors == nil)
-string(len(Posts))
-float(2 / TotalViews)
-(0 % 2) ** TotalViews
-get(Posts, 2).Author
-Posts[0]?.Author
-get(Authors, 2).LastName
-not (1 == TotalViews)
-"JavaScript" < "JavaScript" == nil ? TotalViews : Posts
--TotalViews in Authors
-abs(1 ** 0)
-get(Posts, 0)?.ID
-get(Posts, 0 * 2)
-min(TotalViews % TotalViews)
-nil != Authors || nil == 0.5
-{"Go": "JavaScript"}.ID
-none(Posts, 0 != TotalViews)
-Authors[abs(0)]
-map(Posts, Authors == Authors)
-map(Posts, TotalViews > TotalViews)
-map(Posts, 2 ** 2)
-string(2 > TotalViews)
-Posts[2].Title
-none(Posts, Authors != Authors)
-not (TotalViews > 0)
-TotalViews > TotalViews != nil
-toJSON(toJSON(TotalViews))
-toJSON({"JavaScript": TotalViews})
-Authors[0].Profile
-map(Posts, Authors != Authors)
-TotalViews / (TotalViews + 0.5)
--TotalViews ^ TotalViews
-last(Posts).PublishDate
-one(map(Posts, TotalViews), 1 != TotalViews)
-not (TotalViews <= 0.5)
-TotalViews <= TotalViews * TotalViews
-min(len("Go"))
-!(nil == 1)
-TotalViews ** TotalViews == TotalViews
-TotalViews .. 2 % TotalViews
-lower(toJSON(Posts))
-any(Posts, Posts != Posts)
-toJSON(TotalViews - 0)
-TotalViews * 2 ** TotalViews
-0.5 / 0 - TotalViews - 1
-int(0 + 2)
-Posts[TotalViews % TotalViews]
-max(0.5 + TotalViews)
-0 + TotalViews in Posts
-[0 in Authors]
-IsZero(Posts[0])
-[map(Posts, TotalViews)]
-one(Posts, 0 != nil)
-TotalViews ^ 0.5 ** (0 / 0)
-TotalViews >= abs(TotalViews)
-filter(Posts, 0 in Posts)
-TotalViews > TotalViews and TotalViews in Authors
-last(map(Posts, 0.5))
-TotalViews != TotalViews ? Authors : 0
-string(2 > 0)
-2 ^ TotalViews ** TotalViews
-TotalViews .. 0 + 2
-{"JavaScript": TotalViews, " ": Posts}.FirstName
-toJSON(Posts == Posts)
-not one(Posts, true)
-Authors[2]?.Profile
-min(TotalViews) - TotalViews
-map(Posts, 0 .. TotalViews)
-map(map(Posts, " "), TotalViews)
-TotalViews in map(Posts, TotalViews)
-TotalViews % TotalViews <= TotalViews
-map(Posts, len(Authors))
--min(2)
-filter(Posts, !false)
-string(TotalViews ^ TotalViews)
-int(TotalViews) > TotalViews ? Authors : Posts
-TotalViews ^ 0 != TotalViews / TotalViews
-float(TotalViews / 2)
-none(Posts, Authors == Authors)
--max(TotalViews)
-map(Posts, Authors) == map(Posts, Authors)
-TotalViews == TotalViews ? "Go" : TotalViews
-!(0 > TotalViews)
-TotalViews ** TotalViews - TotalViews
-2 - 0.5 <= TotalViews ? nil : nil
-filter(Posts, TotalViews <= 1)
-not (0.5 == 2)
-map(Posts, 0.5 ** 2)
-toJSON(2 >= 0)
-count(Posts, 0.5 >= TotalViews)
-all(Posts, TotalViews < 0)
-toJSON(1 > 0.5)
-filter(Posts, TotalViews == TotalViews)
-first(Posts)?.Likes
-get(Posts, 2).PublishDate
-Posts != nil ? Posts : true
-abs(TotalViews / 0)
-int(TotalViews ** TotalViews)
-string(none(Posts, true))
-{"JavaScript": Authors, " ": Authors}.ID
-min(TotalViews ^ 0.5)
-{"JavaScript": 0.5}.Comments
-get(Authors, 0).LastName
-{"JavaScript": TotalViews}?.PublishDate
-TotalViews - TotalViews + 0.5
-float(abs(TotalViews))
-map(Posts, 2 .. TotalViews)
-any(Posts, TotalViews in Authors)
-map(map(Posts, Posts), map(Posts, false))
-one(Posts, 0 < 1)
-map(Posts, map(Posts, false))
-Posts[-1]
-float(string(TotalViews))
-TotalViews % (0 + 1)
-TotalViews ^ (TotalViews + 2)
-any(Posts, 0 < 0)
-any(Posts, TotalViews > 1)
-abs(TotalViews) in map(Posts, Authors)
-float(TotalViews ^ TotalViews)
-all(Posts, nil == TotalViews)
-all(Posts, TotalViews in Authors)
-max(min(TotalViews))
-TotalViews < 2 / TotalViews
-max(len(Posts), TotalViews)
-min(-(TotalViews % TotalViews))
-count(Posts, true) / TotalViews
-fromJSON(toJSON(0.5))
-TotalViews >= 0 ^ TotalViews
-int(2 ^ TotalViews)
-not (0 <= 1)
-!(TotalViews >= 0.5)
-min(TotalViews ** TotalViews)
-TotalViews ** TotalViews != TotalViews / 0
-map(Posts, map(Posts, TotalViews))
-!(0 < TotalViews)
-0 in Posts ? TotalViews : Authors
-abs(2 - TotalViews)
-TotalViews .. TotalViews - 0
-not (" " matches " ")
-any(Posts, TotalViews < TotalViews)
-Authors[1]?.Email
-TotalViews < 0.5 * TotalViews
-map(Posts, #?.ID)
-get(Authors, -(TotalViews + TotalViews))
-not (TotalViews < 2)
-get(Posts, abs(TotalViews))
-TotalViews * 0 == TotalViews
-TotalViews / TotalViews < TotalViews
-get(Posts, 2)?.Comments
-filter(Posts, true != nil)
-[1 ** 0]
-max(abs(TotalViews))
-string(max(1))
-(2 - TotalViews) / TotalViews
-TotalViews != TotalViews ^ TotalViews
-TotalViews != 0.5 ? Posts : Posts
-min(1 ** 0.5, min(TotalViews))
--max(0.5, TotalViews)
-string(get(Posts, 1))
-none(Posts, 0 >= TotalViews)
-TotalViews > count(Posts, true)
-none(Posts, nil == TotalViews)
-any(Posts, 0 >= TotalViews)
-{"Go": TotalViews}.Content?.Likes
-map(Posts, TotalViews % TotalViews)
-float(1) ** TotalViews
-int(TotalViews ** 1)
-TotalViews >= TotalViews + 1
-TotalViews * TotalViews / 1
-len(Authors) ^ TotalViews
-any(Posts, !false)
-Authors[1]?.ID
-Posts[0].Comments
-Authors != Authors && TotalViews <= TotalViews
-max(-0.5)
-all(Posts, nil != 1)
-last(filter(Posts, true))
-min(int(TotalViews))
-Posts[2]?.ID
-map(0 .. 0, TotalViews)
-last(Posts[TotalViews:TotalViews])
-abs(2 ^ 0.5)
-WithID(Posts, 1).Likes
-int(min(1))
-int(false ? TotalViews : TotalViews)
-TotalViews + 0 ** TotalViews
-float(0 % TotalViews)
-map(Posts, .Title)
-Authors != Authors && TotalViews > TotalViews
-not true ? 0 : 0.5
-(TotalViews % TotalViews) ** TotalViews
-0 + TotalViews - TotalViews
-TotalViews * 1 .. TotalViews
-string(Authors != Authors)
-int(TotalViews - 0)
-map(Posts, !true)
-string(max(max(TotalViews)))
-min(TotalViews) ^ TotalViews
-!(1 != nil)
-!("Go" != " ")
-map(TotalViews .. TotalViews, Posts)
--(0 / 0.5)
-string(map(Posts, 1))
-{"JavaScript": Posts, "Go": " "}?.PublishDate
-not (nil != nil)
--(TotalViews % 2)
-one(Posts, 1 in Posts)
-TotalViews < TotalViews ** TotalViews
-len(true ? Posts : TotalViews)
-map(Posts, count(Posts, false))
-toJSON(2 ^ 1)
-{"JavaScript": Authors}?.AuthorName
-get(Authors, 0).Profile
-TotalViews / 0 > max(0)
-TotalViews - TotalViews * 2
--(TotalViews % 1)
-{"JavaScript": 0 == TotalViews}
-TotalViews * TotalViews ^ TotalViews
-max(0.5) != 0 ? TotalViews : true
-TotalViews + TotalViews ** 0.5
-Title(get(Posts, 1))
-min(TotalViews) in filter(Posts, false)
-string(not true)
-len(toJSON(TotalViews))
-TotalViews * TotalViews == TotalViews * TotalViews
--(0.5 ** 0)
-TotalViews <= abs(TotalViews)
-min(TotalViews + TotalViews)
-all(map(Posts, 0.5), TotalViews < 2)
-string(TotalViews - 1)
-(TotalViews + 0) % TotalViews
-{" ": Authors}?.Content
-len(string(TotalViews))
-not (nil == TotalViews)
-map(map(Posts, TotalViews), Authors)
-toJSON(TotalViews / 2)
-one(map(Posts, Posts), none(Posts, false))
-max(max(0.5))
-toJSON(false ? Authors : Posts)
-Title(get(Posts, 0))
-min(min(TotalViews))
-trim(toJSON(" "))
-max(TotalViews / TotalViews)
-map(Posts, # != WithID(Posts, TotalViews))
-min(max(0))
-map(Posts, true and false)
-(TotalViews / 0) ^ TotalViews
-{" ": TotalViews, " ": TotalViews}?.Comments
-float(count(Posts, false))
-string(WithID(Posts, TotalViews))
-TotalViews >= -0
-all([true, Posts], TotalViews <= TotalViews)
-Posts == Posts ? Authors : 0.5
-!true ? true : TotalViews
-not any(Posts, true)
-2 + 0 .. TotalViews
-!(0.5 == nil)
-{"JavaScript": Posts, " ": Posts}.Biography
-TotalViews >= 0.5 - TotalViews
-first(map(Posts, TotalViews))
-TotalViews ^ (1 / TotalViews)
-count(Posts, 0.5 >= 1)
-{"JavaScript": TotalViews}.ID
-all(Posts, any(Posts, false))
-TotalViews != 0 == false
-map(Posts, get(Posts, 0))
-count(Posts, nil in Authors)
-int(-TotalViews)
-none(Posts, 0 < TotalViews)
-toJSON(0 in Authors)
-toJSON(trim("Go"))
-toJSON(int(2))
--len("JavaScript")
-!(nil != Authors)
-get(Posts, 0).Tags
-string(get(Authors, TotalViews))
-Posts[0]?.Content
-TotalViews / 0 / TotalViews
-not (1 > TotalViews)
-first(Posts)?.Title
-!not false
-get(Posts, 1)?.Title
-all(Posts, one(Posts, false))
-Posts[0].Tags
-toJSON(Posts[0])
-Posts[2].Likes
-TotalViews - min(TotalViews)
--(0.5 - 0)
-toJSON(TotalViews - TotalViews)
-WithID(Posts, 0 - TotalViews)
-false ? TotalViews : TotalViews > TotalViews
-filter(Posts, nil == Authors)
-!true and Authors == Authors
--0.5 ^ TotalViews ** TotalViews
-TotalViews - 1 ** TotalViews
-not (2 > TotalViews)
-TotalViews >= -TotalViews
-TotalViews ^ TotalViews > TotalViews ? TotalViews : Posts
-0 * 0 * TotalViews
-not (nil in Authors)
-Posts[0]?.PublishDate
-TotalViews ** 0.5 / TotalViews
-not (0.5 > 0.5)
-{"Go": TotalViews < 0}?.Author
--len(Authors)
-0.5 ^ TotalViews - TotalViews
-!not true
-TotalViews == TotalViews + 0
-Authors[nil]?.Profile
-TotalViews != 0 ^ TotalViews
--1 in Authors
-TotalViews <= 1 ? Authors : Authors
-2 + TotalViews + TotalViews
-string({" ": Authors})
-map(Posts, trim(string(nil)))
-int(TotalViews - TotalViews)
-toBase64(string(Authors))
-max(TotalViews * TotalViews)
-not ("JavaScript" != nil)
-float(0 + 2)
-IsZero(get(Posts, 1))
-TotalViews * len(Posts)
-string(true ? TotalViews : Posts)
-float(-TotalViews)
-0 ^ 0 - TotalViews
-TotalViews != 1 ? false : 0
-toJSON(map(Posts, Posts))
-min(abs(0))
-len(map(Posts, Authors))
-get(false ? Authors : 0, TotalViews)
-last(Posts[1:TotalViews])
-none(Posts, TotalViews != nil)
-filter(Posts, 0 in Authors)
-map(Posts, 0 + TotalViews)
-map(Posts, Posts[1])
-TotalViews - TotalViews >= -TotalViews
-0.5 ** TotalViews <= TotalViews
-Authors == nil ? "Go" : true
-int(TotalViews) < TotalViews
-max(min(0.5, 0))
-any(Posts, none(Posts, TotalViews != nil))
-one(Posts, nil != Authors)
-string(nil == "JavaScript")
-none(Posts, nil != Posts)
-!(0 != nil)
-TotalViews == 1 ^ TotalViews
-TotalViews * (TotalViews - 0)
-not true ? Authors : TotalViews
-TotalViews != TotalViews ? -TotalViews : Authors
-TotalViews + TotalViews / 2
-map(0 .. TotalViews, #)
-TotalViews ** (TotalViews / TotalViews)
-any(Posts, TotalViews > TotalViews)
-abs(min(TotalViews))
-TotalViews >= int(TotalViews)
-lower(true ? "Go" : Posts)
-max(1 / TotalViews) > TotalViews
-map(Posts, TotalViews % 2)
-int(toJSON(TotalViews))
-string(toJSON(false))
-!(0.5 <= 2)
-upper(string(false))
-first(Posts).Comments
-Posts[0]?.Title
-len(0 .. TotalViews)
-WithID(Posts, 1).ID
-Authors == Authors && nil in Posts
-{"Go": Authors, " ": Posts}?.Birthday
-any(Posts, 1 > 0)
-!(TotalViews != 0.5)
-last(Posts)?.Author.FirstName
-{"JavaScript": 0.5, " ": 0}.Tags
-get(Authors, 1).Email
-max(int(TotalViews))
-TotalViews ** 0 != TotalViews
-all(Posts, 0 == TotalViews)
-int(TotalViews / 0)
-not (TotalViews <= TotalViews)
-map(Posts, int(1))
-toJSON(0 in Posts)
-count(Posts, true) != TotalViews
-map(Posts, .Likes)
-get(Posts, 1).Content
-TotalViews / TotalViews / (0 - 0)
-[false ? Posts : Posts]
-get(Posts, 1).Author
-TotalViews + 0.5 >= -2
-Authors == Authors ? TotalViews : Posts
-one(Posts, TotalViews == TotalViews)
-toJSON(TotalViews != TotalViews)
-toJSON(TotalViews >= TotalViews)
-TotalViews + TotalViews ^ 0
-not (TotalViews != 0.5)
-TotalViews < TotalViews ^ TotalViews
-map(Posts[0:TotalViews], TotalViews)
-IsZero(Posts[1])
-!(0 <= TotalViews)
-TotalViews / TotalViews >= TotalViews + TotalViews
-none(TotalViews .. 0, Posts == Posts)
-toJSON(float(0))
-!(TotalViews <= 0.5)
-count(Posts, 2 >= 0.5)
-Authors[-TotalViews]
-{"Go": Authors, "Go": false}?.ID
-count(Posts, true) <= TotalViews ? TotalViews : Posts
-string(0 % TotalViews)
-{"Go": 2, " ": nil, "JavaScript": TotalViews, "JavaScript": "JavaScript"}.Birthday
-toJSON(filter(Posts, true))
-[Posts != Posts]
-Posts[2].Author
-get(Posts[TotalViews:TotalViews], TotalViews)
-TotalViews + TotalViews != TotalViews
-toBase64(string("Go"))
-one(Posts, 0 == 2)
-max(0 ** 1)
-int(TotalViews ** 0)
-map(map(Posts, true), TotalViews / TotalViews)
-filter(Posts, 1 >= TotalViews)
-TotalViews % TotalViews % TotalViews
-float(int(TotalViews))
-TotalViews * 0 ^ 0.5
-none(map(Posts, Authors), TotalViews == 0.5)
-TotalViews * TotalViews in map(Posts, 0)
-abs(0.5 + 2)
-filter(Posts, TotalViews < TotalViews)
-get(Posts, TotalViews + 0)
-{"JavaScript": true}?.Content
-TotalViews == nil ? TotalViews : Authors
-!(false and true)
-not ("JavaScript" == nil)
-last(TotalViews .. TotalViews)
-TotalViews < TotalViews % TotalViews
-TotalViews in Posts ? Posts : " "
-max(TotalViews + 1)
-string(2 in Posts)
-one(Posts, Authors == Authors)
-Posts != Posts ? TotalViews : TotalViews
-TotalViews - 0 + TotalViews
-map(Posts, TotalViews ** TotalViews)
-TotalViews ^ TotalViews / 0 ** TotalViews
-not (nil != TotalViews)
-TotalViews - TotalViews .. TotalViews
-!(nil == 0)
-!(1 <= TotalViews)
-int(TotalViews) + TotalViews
-get(Authors, 2)?.ID
-TotalViews <= 0 != false
-map(map(Posts, 0.5), #)
-get(Posts, 2)?.PublishDate
-abs(TotalViews) + TotalViews
-float(TotalViews) <= TotalViews
-IsAdmin(Authors[2])
-Authors[-2]
-map(Posts, 0 > 0.5)
-string(true ? " " : "JavaScript")
-!IsZero(Posts[1])
--0 > TotalViews
-abs(TotalViews + TotalViews)
-Posts == map(Posts, Posts)
-abs(-0)
-0 - TotalViews < TotalViews
-Authors != nil ? Authors : splitAfter("Go", nil)
-one(map(Posts, Posts), 0 > 0.5)
-not true ? Posts : "Go"
--0.5 ^ TotalViews
-(TotalViews - TotalViews) ** TotalViews
-float(int(0))
-!("JavaScript" matches "JavaScript")
-not (Authors == nil)
--0.5 > TotalViews
-get(map(Posts, 1), TotalViews)
-TotalViews == TotalViews + TotalViews
-filter(Posts, TotalViews <= 0)
-TotalViews % (TotalViews + 1)
-{" ": Posts}.CommentDate
-2 + 0 - TotalViews
-Posts[2].Comments
-any(Posts, 0 in Posts)
-count(Posts, TotalViews == 0)
-{"JavaScript": TotalViews}?.FirstName
-min(0.5 + TotalViews)
-max(-TotalViews)
-map(filter(Posts, true), TotalViews)
-TotalViews / 0 - TotalViews
-max(TotalViews - 0)
-get(Posts, 1)?.ID
-false ? TotalViews : 0 >= TotalViews
--int(1)
-one(map(Posts, TotalViews), TotalViews >= TotalViews)
-last(true ? Posts : 0)
-not any(Posts, false)
-{" ": " ", "Go": 1}?.Upvotes
-get(Authors, 0)?.LastName
-TotalViews ^ 2 ** 0
-string(nil == TotalViews)
-not (0 > 2)
-not true ? map(Posts, Posts) : Posts
-TotalViews >= min(TotalViews)
-Posts != Posts || TotalViews <= TotalViews
-get(Posts, 2 % TotalViews)
-map(TotalViews .. TotalViews, Authors)
-int(2) > len(" ")
-TotalViews <= TotalViews - TotalViews
-TotalViews - TotalViews - TotalViews
-last(TotalViews .. 1)
-string(TotalViews) in first(Posts)
-TotalViews <= 0.5 + TotalViews
-Authors[nil]?.FirstName
-TotalViews - int(0)
-get(Posts, 0).Author
-all(Posts, Authors != Authors)
-get(false ? 2 : Posts, TotalViews)
-not (0.5 <= 0)
-max(TotalViews) == TotalViews
-TotalViews ^ max(0)
-toJSON(get(Posts, 0))
-map(Posts, 2 ** TotalViews)
-float(TotalViews) / TotalViews ** 1
-!(0.5 < 0)
-get(Authors, 2).ID
-TotalViews / 1 ** 1
-last(Authors == Authors ? true : "Go")
-count(map(Posts, false), #)
-all(Posts, TotalViews < 1)
-TotalViews % TotalViews == max(TotalViews)
-all(Posts, !false)
-{"JavaScript": 0}.CommentDate
-{"Go": true, "Go": nil}?.Email
-float(get(Authors, TotalViews).ID)
-TotalViews ^ (0 + TotalViews)
-Authors[1].ID
-count(Posts, TotalViews < TotalViews)
-!(0 == 0)
-float(max(TotalViews))
--TotalViews - TotalViews
-TotalViews == 2 + TotalViews
-float(TotalViews) / TotalViews
-TotalViews / count(Posts, true)
-min(TotalViews / TotalViews)
-count(Posts, TotalViews > 0)
-map(Posts[TotalViews:TotalViews], Authors)
-toJSON(TotalViews <= 0)
-get(Authors, 0).Email
-string(0 != nil)
-string(Posts != Posts)
-Posts != Posts ? false : 0
--(0 * TotalViews)
--float(0.5)
-Posts != map(Posts, "JavaScript")
-TotalViews <= 0.5 / 0.5
--(1 + TotalViews)
-TotalViews != nil ? Posts : "Go"
-max(0) * TotalViews
-TotalViews / min(TotalViews)
-count(Posts, true == false)
-TotalViews != TotalViews ? 0 : Authors
-WithID(Posts, TotalViews).Likes
-TotalViews % TotalViews in map(Posts, Posts)
-{"Go": TotalViews}.Likes
-one(Posts, 0.5 <= 0.5)
-TotalViews >= 0.5 + 1
-TotalViews > TotalViews ? nil : nil
-abs(TotalViews - 0)
-TotalViews > TotalViews - 0
-toJSON(TotalViews * 0)
-get(Authors, 0 + 2)
-max(TotalViews) ^ TotalViews
-Posts[2 + 0]
-(0 - TotalViews) / TotalViews * TotalViews
-len(map(Posts, Posts))
-all(Posts, 0 == 0.5)
-toJSON(!(nil == Posts))
-!("JavaScript" != nil)
-get(Authors, 0 * TotalViews)
-Authors[TotalViews - TotalViews]
-{"Go": Authors}?.ID
-{"JavaScript": TotalViews}.Biography?.Age(TotalViews)
-TotalViews * 0 < TotalViews
-(TotalViews + TotalViews) ** TotalViews
-TotalViews + TotalViews > TotalViews
-map(map(Posts, Posts), Authors)
-IsZero(Posts[2])
-TotalViews >= 0 ** 0
-!(2 > TotalViews)
-TotalViews - TotalViews < TotalViews
-get(Posts, 0)?.Tags
-min(1 - 0)
-min(count(Posts, false))
-1 * TotalViews - TotalViews
-Authors == Authors != nil ? Posts : Authors
-!(TotalViews < 0)
-Posts != Posts ? Posts : -TotalViews
-TotalViews == abs(TotalViews)
-string([Posts])
-TotalViews ** -0
-TotalViews != 2 * TotalViews
--2 == TotalViews
-first(Posts).Content
-any(Posts, TotalViews > 0)
-TotalViews ^ (0 / TotalViews)
-Authors == nil ? "JavaScript" : TotalViews
-toJSON(1 < 1)
--(0.5 + 0)
-none(Posts, TotalViews < TotalViews)
-Posts == nil ? Authors : TotalViews
-get(true ? "Go" : Authors, 0.5 <= TotalViews)
-TotalViews ^ TotalViews <= TotalViews
-any(Posts, 2 < TotalViews)
-{" ": Authors}.ID
-map(Posts[TotalViews:TotalViews], #)
-string(all(Posts, true))
-count(Posts, TotalViews > TotalViews)
-one(Posts, nil in Posts)
-not (0.5 < TotalViews)
-string(nil == Authors)
-all(map(Posts, Posts), TotalViews != TotalViews)
-map(map(Posts, TotalViews), toJSON(0.5))
-Add(1, 2) / (TotalViews + TotalViews)
-false ? nil : TotalViews >= 0.5 ** TotalViews
-all(Posts, all(Posts, true))
-{" ": Authors}?.Email
-{"Go": 0.5, "Go": Authors}.Tags
-filter(Posts, Posts != nil)
-filter(Posts, all(Posts, false))
-min(TotalViews) ** TotalViews
-all(map(Posts, Authors), 1 >= 0.5)
-none(Posts, "Go" == "Go")
-{" ": Authors, " ": nil != 1}
-string(last(Posts))
-string(2 == 1)
-IsAdmin(Authors[1])
-0 .. 0 != Posts
---(0.5 / TotalViews)
-TotalViews - TotalViews + TotalViews
-any(Posts, TotalViews == 0)
-map(Posts, -0.5)
--(0.5 + TotalViews)
-string({"JavaScript": Posts, " ": Authors}.Title)
-any(Posts, nil == TotalViews)
-toJSON(int(TotalViews))
-1 * TotalViews - TotalViews % TotalViews
-TotalViews == TotalViews == nil
-len(Authors) * 0.5 ** TotalViews
-int(len(Authors))
-count(Posts, true) > TotalViews
-len(map(Posts, 2))
-not true ? TotalViews : false
-filter(Posts, IsZero(#))
-one(Posts, TotalViews in Authors)
--(2 + 0)
-float(TotalViews + TotalViews)
-{" ": Posts, "Go": Posts}
-none(Posts, any(Posts, false))
-!(1 in Authors)
-get(true ? Posts : Authors, string(Authors, Posts, TotalViews))
-TotalViews / TotalViews >= 0 / TotalViews
-TotalViews <= TotalViews ? Authors : Posts
-0 ** 1 < TotalViews
-not !false
-float(-2)
-TotalViews - 0 .. TotalViews + 1
-toJSON(nil != Posts)
-map(Posts, 0 in Posts)
-true ? Posts : TotalViews > TotalViews
-map(Posts, .PublishDate)
-any(Posts, TotalViews <= 0)
-map(TotalViews .. TotalViews, #)
-Authors[0]?.Email
-{"JavaScript": true, " ": TotalViews}.Comments
-{" ": Authors}.Website
--count(Posts, false)
-toJSON(1 < TotalViews)
-Title(WithID(Posts, 1))
-map(Posts, 0) != Posts
-int(TotalViews + TotalViews)
-float(-0)
---2
-get(Authors, 1 * TotalViews)
--max(0)
-0 * TotalViews - TotalViews
-TotalViews > 0 ? nil : 0
-int(0.5 / TotalViews)
-WithID(Posts, 0).Tags
-all(Posts, 0 >= TotalViews)
-min(TotalViews - TotalViews)
-get(Posts, 0)?.Comments
-string(TotalViews in Authors)
-TotalViews ^ (0.5 * TotalViews)
-one(Posts, nil == nil)
-string(TotalViews == 0.5)
-TotalViews ^ min(TotalViews)
-toJSON(Posts[TotalViews:1])
-abs(1 ** TotalViews)
-min(2 + TotalViews)
-TotalViews < len(Posts)
-not (nil == Authors)
-{"Go": Authors, "JavaScript": TotalViews}.ID
-map(Posts, TotalViews != TotalViews)
-toJSON(Posts != Posts)
-map(2 .. TotalViews, TotalViews)
-get(Authors, len(Authors))
-get(Authors, count(Posts, true))
-map(Posts, 0 - TotalViews)
-TotalViews ^ TotalViews - TotalViews
-TotalViews ^ (TotalViews - TotalViews)
-int(TotalViews % TotalViews)
-{"Go": Posts, " ": Posts}
-min(abs(2))
-string(0 * 0.5)
-TotalViews >= TotalViews || TotalViews == nil
-get(Posts, 2)?.ID
-get(Authors, 1).FirstName
-abs(0 - 0)
-TotalViews * 1 != TotalViews
-float(TotalViews * 0.5)
-any(Posts, 1 in Authors)
-map(Posts, 2) != Posts
-get(true ? Authors : nil, TotalViews)
-not (TotalViews > 1)
-none(map(Posts, TotalViews), true == false)
-TotalViews / abs(TotalViews)
-TotalViews == TotalViews ? 2 : Posts
-TotalViews <= 0.5 ? Authors : TotalViews
-toJSON(nil == 0)
-string(TotalViews != nil)
-any(Posts, TotalViews > 2)
-all(map(Posts, Authors), nil in Posts)
-abs(Sub(0, 0))
-Posts == TotalViews .. 0
-WithID(Posts, 1)?.ID
-not (0 > TotalViews)
-one(Posts, nil == TotalViews)
-map(true ? Posts : TotalViews, TotalViews)
-Authors[int(TotalViews)]
-TotalViews < TotalViews + TotalViews
-toJSON("JavaScript" > "JavaScript")
-TotalViews - TotalViews > TotalViews
-{"Go": TotalViews != TotalViews}
-int(-0)
-toJSON(TotalViews ^ 0)
-TotalViews != TotalViews ? Posts : (false ? TotalViews : 1)
-map(Posts, Authors[nil])
-map(Posts[0:TotalViews], "JavaScript" == "JavaScript")
-TotalViews * TotalViews .. TotalViews
-TotalViews ^ (TotalViews - 0.5)
-abs(1 + TotalViews)
-TotalViews <= count(Posts, false)
-nil == Posts && TotalViews > TotalViews
-toJSON(false ? 2 : nil)
-toJSON(max(1))
-min(TotalViews * 1)
-TotalViews != TotalViews ? Posts : 1
--(TotalViews ^ 0)
-int(2) <= TotalViews
--TotalViews == 0 - TotalViews
-WithID(Posts, 1).Tags
-get(Authors, 2)?.LastName
-TotalViews ^ 0.5 + TotalViews
-toJSON(TotalViews + TotalViews)
-any(Posts, 2 in Posts)
-get(Authors, 2).Profile
-Authors[1].Profile
-TotalViews != 0.5 && nil == 0
-{" ": "JavaScript" <= "JavaScript"}
-one(Posts, TotalViews == nil)
-WithID(Posts, 1).Content
-none(Posts, true or false)
-max(TotalViews, TotalViews) - TotalViews
-TotalViews - -1
-count(Posts, TotalViews in Posts)
-Posts != Posts ? true : 0
-map(Posts, one(Posts, true))
-TotalViews .. TotalViews + TotalViews
-string(nil == 2)
-none(Posts, TotalViews < 0.5)
-max(2 + TotalViews)
-{"Go": false, "Go": 2}.ID
-TotalViews ** Sub(0.5, 0)
-!(nil != nil and Authors == Authors)
-get(Authors, 0)?.FirstName
-map(Posts, map(Posts, Posts))
-map(Posts, 0 ^ 2)
-{"Go": TotalViews, " ": Authors}.CommentDate
-{" ": Posts}.Content
-one(Posts, not false)
-abs(TotalViews) in Authors
-max(0, TotalViews) >= TotalViews - TotalViews
-TotalViews + abs(0)
-min(len(" "))
-max(count(Posts, false))
-Posts == TotalViews .. TotalViews
-0.5 + TotalViews == TotalViews
-TotalViews % TotalViews * 1
-Posts[1].Author
-Posts == map(Posts, Authors)
-string(TotalViews * TotalViews)
-not true ? Posts : Authors
-min(TotalViews) * 0 * 2
-float(TotalViews) > TotalViews
-abs(0.5 / TotalViews)
-not (TotalViews < 0)
-Authors[1]?.Profile
-map(map(Posts, Authors), toJSON(Authors))
-first(1 .. TotalViews)
-last(Posts)?.Comments
-!("Go" == nil)
-abs(0) / TotalViews * TotalViews
-toJSON(Posts != nil)
-min(-0.5)
-TotalViews > 0 / TotalViews
-0.5 ** 0 - TotalViews
-filter(Posts, 2 == 0)
-int(TotalViews) <= TotalViews
-get(Authors, -TotalViews)
-map(Posts, nil != Authors)
-one(Posts, 0.5 == TotalViews)
-map(map(Posts, Authors), map(Posts, Posts))
-toJSON(Authors[nil])
-Posts[1].PublishDate
-map(Posts, get(Authors, TotalViews))
--(1 - TotalViews)
-{"JavaScript": Posts}.Profile
-map(Posts, TotalViews ^ TotalViews)
-TotalViews >= 0.5 ? TotalViews : TotalViews
-0 - TotalViews + TotalViews
-TotalViews != nil ? TotalViews : 0 > TotalViews
-2 >= TotalViews || TotalViews <= 2
-TotalViews != TotalViews ? Authors : TotalViews
-all([Posts, 0, TotalViews], 2 in Posts)
-min(1 ** 0)
-{"Go": true}.CommentDate?.Email
-abs(TotalViews) < TotalViews
-TotalViews ^ (0.5 + TotalViews)
-map(Posts, TotalViews - TotalViews)
-any(Posts, 1 <= TotalViews)
-not false ? Authors : Posts
-abs(0 ** TotalViews)
-false ? nil : TotalViews == TotalViews
-int(1) + TotalViews
-[map(Posts, Authors)]
-TotalViews * 2 + TotalViews
-toJSON(0.5 > 0)
-TotalViews * TotalViews == nil ? 0 : TotalViews
-WithID(Posts, TotalViews)?.Likes
-TotalViews * TotalViews >= TotalViews ? nil : Authors
-!(2 == nil)
-1 ** 1 <= TotalViews
-string(TotalViews <= TotalViews)
-TotalViews ** get(Authors, 1).ID
-(TotalViews / TotalViews) ** TotalViews
-toJSON(TotalViews - 0.5)
-float(0.5 / TotalViews)
-{"JavaScript": nil, " ": TotalViews, "JavaScript": true, "Go": TotalViews, "Go": TotalViews}?.PublishDate?.ID?.Profile
--(2 + TotalViews)
-any(Posts, 0 > TotalViews)
-TotalViews + TotalViews / TotalViews
-TotalViews != nil ? Authors : " "
-not (nil == Posts)
-get(Posts, 1)?.PublishDate
-TotalViews - TotalViews ** TotalViews
-{"JavaScript": Authors}?.ID?.Biography
-map(Posts, TotalViews - 1)
-{" ": 0.5}.ID
-Authors == Authors and TotalViews in Posts
-min(TotalViews) >= TotalViews
--(2 ** 1)
-TotalViews ^ TotalViews < TotalViews
-!all(Posts, true)
-any(Posts, nil == true)
-{" ": 0.5}?.ID
-TotalViews <= TotalViews ^ TotalViews
-none(map(Posts, TotalViews), Authors == nil)
-!(0 == 0.5)
-TotalViews + abs(TotalViews)
-{"Go": TotalViews, "Go": nil, " ": Authors}?.Profile?.Upvotes
-string(get(Posts, 0))
-get(Posts, false ? Authors : Posts)
-TotalViews == TotalViews ^ TotalViews
-none(Posts, nil in Authors)
-!(0 != TotalViews)
-map(Posts, #) != Posts
-{"JavaScript": TotalViews}.Biography
-toJSON(TotalViews >= 0)
--get(Authors, 0)?.ID
-TotalViews > TotalViews / 0
-all(Posts, 0 <= 0)
-get(Posts, -TotalViews)
-not true ? nil : nil
-int(TotalViews) ** TotalViews
-map(Posts, TotalViews < 0)
-trim(false ? Posts : " ")
-TotalViews in 1 .. TotalViews
-TotalViews == Authors[TotalViews].ID
-string(1 * TotalViews)
-TotalViews + TotalViews in Authors
-TotalViews ** 0 ** TotalViews
-float(max(0.5))
-!(nil in Posts)
-{" ": Authors}?.Upvotes
-one([" "], 1 != 0.5)
-string(not (0.5 >= TotalViews))
-get(true ? Authors : false, "Go" matches "JavaScript")
-TotalViews % TotalViews > TotalViews
-string(Posts == nil)
-{" ": TotalViews}?.Upvotes
-Posts[1].Comments
-0.5 ** 0 != TotalViews
-any(Posts, Posts == Posts)
-any(filter(Posts, true), 0 != TotalViews)
-2 / TotalViews < TotalViews
-TotalViews / 1 == TotalViews
-TotalViews ^ (TotalViews + 0.5)
-filter(Posts, any(Posts, false))
-not ("JavaScript" startsWith "Go")
-min(TotalViews) % TotalViews
-0 ^ 1 / TotalViews
-TotalViews > TotalViews ? true : 0
-one(map(Posts, Authors), Authors == Authors)
-toJSON(!true)
-TotalViews >= TotalViews == nil
-toJSON(all(Posts, true))
-toJSON(0 == TotalViews)
-TotalViews - TotalViews != TotalViews
-TotalViews > TotalViews / TotalViews
-TotalViews + 0 / TotalViews
-[len(Authors)]
-fromJSON(string(TotalViews))
-toJSON(2 / TotalViews)
-TotalViews .. TotalViews == Posts
-TotalViews ^ 0 == TotalViews
-TotalViews > TotalViews && Posts == Posts
--TotalViews + TotalViews
-abs(2) < TotalViews ? TotalViews : Authors
-int(TotalViews + 0)
-TotalViews >= TotalViews ? Posts : Authors
-Posts[min(1)]
-toJSON(nil == 1)
-0.5 ** TotalViews < 0.5 ^ TotalViews
-(TotalViews + TotalViews) ^ max(1)
-string(upper("Go"))
--TotalViews + 0 * TotalViews
-{"Go": Posts}.Website
-TotalViews in Posts ? nil : 0
-TotalViews >= TotalViews / 2
--(TotalViews - 0.5)
-map(Posts, true ? TotalViews : Authors)
-map(Posts, Posts == Posts)
-string(TotalViews != 0.5)
-max(TotalViews) != TotalViews % 2
-max(TotalViews + 2)
-map(Posts, TotalViews * TotalViews)
-all(Posts, TotalViews != TotalViews)
-Posts[2].Content
-map(Posts, TotalViews / 0)
-one(map(Posts, TotalViews), !false)
-map([Posts, false, Authors], #)
--(0 % TotalViews)
-count(Posts, TotalViews == TotalViews)
-{"JavaScript": Posts, "Go": "Go"}.Likes
-TotalViews - max(0)
-WithID(Posts, 2).ID
-toJSON(0 >= TotalViews)
--(1 % TotalViews)
-Add(0, 1) ** TotalViews
-string("Go" != "JavaScript")
-one(false ? Posts : Authors, nil != Authors)
-(TotalViews + TotalViews) % TotalViews
-!(0 > 2)
-min(TotalViews) .. TotalViews
-TotalViews < len(Authors)
-toJSON(nil != TotalViews)
-none(Posts, !false)
-[Posts, Authors]
-last(Posts)?.PublishDate
-0 != nil or TotalViews != nil
-get(Authors, min(2))
-toJSON(2 == nil)
-{"Go": TotalViews}.Upvotes
-get(Authors, TotalViews - TotalViews)
-last(filter(Posts, false))
-TotalViews ^ TotalViews >= 1 * TotalViews
-one(Posts, TotalViews == 0)
-trim(string(TotalViews))
--TotalViews < TotalViews
-not false ? 1 : Posts
-TotalViews ^ TotalViews ** (TotalViews - 0.5)
-any(Posts, 0.5 != 2)
--0 in Posts
-nil != Posts ? TotalViews : abs(TotalViews)
-{"JavaScript": Authors}.ID
-map(Posts, 0.5 + TotalViews)
-2 / TotalViews != TotalViews
-filter(Posts, 0 <= TotalViews)
-map(Posts, Authors) == Posts
-map(Posts, nil == " ")
-string(TotalViews > 0.5)
-string(TotalViews != 0)
-toJSON(len(Posts))
-get(Posts, 0).Likes
-Authors[len(Authors)]
-{"Go": TotalViews, "Go": TotalViews}?.Biography
-TotalViews != count(Posts, true)
-[Authors, TotalViews, TotalViews] == Posts
-len(Authors) != max(TotalViews)
-!(TotalViews + 0.5 >= TotalViews)
-int(1 ** TotalViews)
-{" ": TotalViews, "Go": nil}?.PublishDate
-TotalViews == 0 ? 0.5 : Posts
-not (TotalViews < TotalViews)
-TotalViews == 0 and TotalViews >= TotalViews
-!(" " endsWith " ")
-none(Posts, TotalViews < 0)
-TotalViews == TotalViews ? TotalViews : 0
-0 ^ 0 >= TotalViews
-max(float(0.5))
-filter(Posts, Posts != Posts)
--(1 % 1)
-one(Posts, one(Posts, true))
-TotalViews ** float(1)
-max(int(2))
-{"JavaScript": Authors, "Go": TotalViews, "Go": Authors, "Go": TotalViews}.Birthday
-map(map(Posts, Posts), Posts)
-get(false ? false : TotalViews, TotalViews)
-one(Posts, TotalViews != TotalViews)
-TotalViews >= len("JavaScript")
-string(TotalViews <= 0)
-true ? TotalViews : Posts != map(Posts, 0)
-TotalViews ** (0 + TotalViews)
-TotalViews == TotalViews / TotalViews
-trim("JavaScript" + "Go")
-{"JavaScript": TotalViews <= TotalViews}
-string(TotalViews != TotalViews)
-{" ": nil, "Go": TotalViews, "Go": TotalViews, " ": Posts, " ": Posts}?.Author
-TotalViews % 2 <= TotalViews
-TotalViews - 1 % TotalViews
-Posts != Posts[TotalViews:TotalViews]
-TotalViews != nil or Posts == nil
-TotalViews + Add(0.5, 0)
-TotalViews != TotalViews && TotalViews <= TotalViews
-{"Go": Authors, "Go": Posts, "JavaScript": Authors}.Profile
-TotalViews - -TotalViews
-map(Posts, -0)
-2 ^ TotalViews * TotalViews
--(TotalViews ^ 2)
-TotalViews * 0 in Posts
-TotalViews < TotalViews ? Authors : map(Posts, true)
--(TotalViews / 0.5 ** TotalViews)
-TotalViews % 1 <= TotalViews
--TotalViews != TotalViews
-!(TotalViews <= 1)
-[Authors, Authors]
-!(0 >= TotalViews)
-0 * TotalViews + TotalViews
-last(false ? TotalViews : Posts)
-int(-2)
-Add(1, 0.5) >= TotalViews
-TotalViews <= TotalViews ? Authors : Authors
-TotalViews != TotalViews % TotalViews
-trim(string(Authors))
-none(TotalViews .. TotalViews, TotalViews >= TotalViews)
-string(TotalViews - 2)
-(TotalViews * TotalViews) ** (TotalViews - TotalViews)
-abs(0.5) ** TotalViews
--1 + TotalViews
-int(TotalViews ^ 0)
-TotalViews > 0.5 ? Posts : nil
-string(TotalViews in Posts)
-string(1 in Authors)
-TotalViews == TotalViews ? Authors : TotalViews
-0.5 * TotalViews + max(0)
-TotalViews * 2 * TotalViews
-map(map(Posts, TotalViews), TotalViews - 0)
-any(Posts, 0.5 < TotalViews)
-TotalViews ** TotalViews <= TotalViews
-Authors[2].Profile
-none(map(Posts, Authors), 2 == 2)
-count(Posts, false) - TotalViews
-min(TotalViews) <= TotalViews
-!(0.5 > 1)
-not !true
-TotalViews ** TotalViews / TotalViews
-len(Authors) != TotalViews
-int(0 ^ 2)
-TotalViews <= TotalViews == nil
-float(1 ** TotalViews)
-TotalViews > 0.5 - TotalViews
-TotalViews + min(TotalViews, TotalViews)
-1 / TotalViews + TotalViews
-filter(map(Posts, 0), nil != nil)
-0.5 <= TotalViews or Posts == Posts
-toJSON(any(Posts, true))
-string(true ? Posts : Authors)
-string(count(Posts, true))
-none([Posts, Posts, 0.5, nil], 0 == TotalViews)
-WithID(Posts, 0)?.ID
-max(1 ^ TotalViews)
-string(nil != 0.5)
-not (TotalViews >= 1)
-count(Posts, nil in Posts)
-TotalViews > 1 % 2
-not (2 == TotalViews)
-lower(string(TotalViews))
-toJSON(Authors) startsWith " " ? 0 : TotalViews
-TotalViews ** TotalViews / int(TotalViews)
-any(map(Posts, 0), 0 in Posts)
-filter(Posts, 0.5 == 2)
-not (2 != TotalViews)
-string(false ? Authors : 0)
-string(true ? Posts : TotalViews)
-map(Posts, 1 ** 0)
-fromJSON(string(false))
-TotalViews * Authors[TotalViews].ID
-!(false or true)
-one(Posts, nil != TotalViews)
-last(TotalViews .. 0)
-string(0.5 == nil)
-TotalViews == TotalViews - TotalViews
-TotalViews <= 0.5 ? nil : nil
-float(TotalViews ** TotalViews)
-toJSON(any(Posts, false))
-TotalViews / TotalViews == TotalViews
-one([0.5], TotalViews in Posts)
-toBase64(string(0))
--(0.5 / 1)
-filter(Posts, 0.5 != nil)
-not (TotalViews <= 0)
-(TotalViews - TotalViews) * TotalViews
-map(true ? Authors : TotalViews, Posts)
-not ("Go" < "Go")
-max(float(TotalViews))
-!IsAdmin(Authors[nil])
-toJSON(map(Posts, TotalViews))
-0 * 0.5 / (TotalViews - TotalViews)
-filter(Posts, not (nil != Posts))
-Posts[0 + 0]
-TotalViews ^ (TotalViews / 1)
-map(Posts, #?.Content)
-{"Go": Authors}?.Author
-not (0 != 1)
-0 + TotalViews <= TotalViews
-one(Posts, Authors != nil)
-float(TotalViews) ^ TotalViews
-TotalViews - TotalViews ^ TotalViews
-!false ? Authors : 1
-WithID(Posts, TotalViews)?.PublishDate
-max(TotalViews * 2)
-get(Authors, 2)?.FirstName
-get(Posts, 0 % TotalViews)
-len(Posts) == TotalViews
-get(Posts, 1 - 0)
-{" ": Posts, " ": Authors}?.Biography
-count(Posts, 0 <= TotalViews)
-nil != Posts or TotalViews > TotalViews
-toJSON(TotalViews == 0)
-0 != TotalViews && TotalViews == nil
-Title(Posts[0])
-TotalViews % TotalViews * TotalViews
-min(TotalViews) > min(TotalViews)
-none(Posts, TotalViews in Authors)
-TotalViews != float(TotalViews)
-map(map(Posts, 0), string(Posts))
-TotalViews ^ TotalViews ^ TotalViews
-lower(string(nil))
-TotalViews <= 0.5 - 1
-string(2 % TotalViews)
-WithID(Posts, TotalViews).Author.LastName
-last(get(Posts, 2)?.Tags)
-{" ": 0 != TotalViews}
-max(TotalViews / 0)
-int(2 / TotalViews)
-none(Posts, nil in Posts)
-abs(TotalViews ^ 0)
-nil != Authors && false ? Posts : TotalViews
-TotalViews ^ (TotalViews - 1)
-IsAdmin(nil) || true ? TotalViews : Authors
-TotalViews % TotalViews .. TotalViews
-map(Posts, false or true)
-int(max(TotalViews))
-TotalViews <= TotalViews != false
-0 % TotalViews / TotalViews
-not ("JavaScript" <= "JavaScript")
-abs(TotalViews) != 0 ? TotalViews : TotalViews
-TotalViews + TotalViews == TotalViews / TotalViews
-not (nil != "Go")
-TotalViews .. len(Authors)
-get(Posts, 0)?.Author
-TotalViews * TotalViews >= 0 + TotalViews
-abs(float(TotalViews))
-string(2 - TotalViews)
-TotalViews - TotalViews % TotalViews
--(2 % TotalViews)
-[Authors[TotalViews]]
-get(map(Posts, 0), -TotalViews)
-max(len("JavaScript"))
-map(Posts, .Tags)
--(2 ^ TotalViews)
--(TotalViews / 2)
-string(2 + 0)
-int(0.5) > TotalViews
-all(Posts, TotalViews >= TotalViews)
-len(toJSON(Authors))
-toJSON(TotalViews .. TotalViews)
-abs(int(TotalViews))
-{"Go": true}.Tags
-TotalViews ** 2 == TotalViews ? 0 : 2
-toJSON(TotalViews != nil)
-count(Posts, 0 != 0)
-TotalViews in Authors && TotalViews != TotalViews
-toJSON(get(Authors, 0))
-TotalViews <= TotalViews ? 0 : nil
-get(Authors, TotalViews + TotalViews)
-0 * TotalViews > TotalViews
-TotalViews > TotalViews ^ 0.5
-TotalViews ** -TotalViews
-map(map(Posts, 0), get(Posts, TotalViews))
-map(Posts, max(TotalViews))
-max(TotalViews / 0.5)
-(TotalViews - 1) ^ TotalViews
-map(map(Posts, 0), Authors)
-{"Go": get(Posts, TotalViews)}
-TotalViews / TotalViews > 0.5 ? Posts : 0.5
-toJSON(count(Posts, false))
-not (2 <= 0)
-len(Posts) % TotalViews
-filter(Posts, 0 >= TotalViews)
-1 / 2 + TotalViews
-Posts[2].ID
-{"JavaScript": " "}?.ID
-fromJSON(toJSON(Posts))
-not (-TotalViews in Authors)
-TotalViews + len(Posts)
-TotalViews ** (TotalViews + TotalViews)
--1 .. -TotalViews
--0 == TotalViews
-not not (Authors == Authors)
-map(Posts, nil in Posts)
-toJSON(TotalViews in Posts)
-one(Posts, 0.5 < 0.5)
--(1 / 1)
-2 in Authors || 1 > TotalViews
-len(string(0))
-!true ? true : " "
-nil != 0 and Posts == Posts
-not true ? 0 : Authors
-map(Posts, lower("Go"))
-toJSON(nil in Authors)
-Authors[2].Email
-one(map(Posts, Posts), !true)
-get(Authors, 1).Profile
-TotalViews < abs(TotalViews)
-toJSON(toJSON(Authors))
-toJSON(last(Posts))
-not (TotalViews != 2)
-len(Posts) in Posts
--min(0)
-" " >= "Go" && Authors != nil
-{"Go": Authors, " ": 0.5, "JavaScript": nil, " ": 0, "JavaScript": Posts}?.PublishDate
-TotalViews * 0.5 <= TotalViews * TotalViews
-len(Authors) * TotalViews
-Posts == map(Posts, 1)
-TotalViews / 0.5 >= 0.5 ? " " : true
-!(0 >= 0.5)
-TotalViews < TotalViews * TotalViews
-TotalViews ^ TotalViews <= max(0)
-not (0 <= 2)
-abs(TotalViews) > 2 == true
--int(2)
-get(true ? Authors : 0, TotalViews)
-string(0 == nil)
-Posts != Posts ? 2 : Authors
-string(2 / TotalViews)
-count(Posts, Posts == nil)
-!(nil in Authors)
-{"JavaScript": false, "JavaScript": Posts, " ": TotalViews}.Title
-2 % TotalViews >= TotalViews
-toJSON(2 < 2)
-TotalViews % TotalViews >= TotalViews ** TotalViews
-int(0.5 ^ TotalViews)
-TotalViews / 0.5 ** 1
-{"Go": Posts, " ": Posts, "Go": nil}.Author
-TotalViews ^ 0.5 == 0.5 ? Posts : "JavaScript"
-0 ** 0 ^ (TotalViews - 2)
-first(false ? TotalViews : Posts)
-int(0) in Posts
-!one(Posts, false)
-toJSON(abs(TotalViews))
-get(Posts, 2)?.Tags
-Authors[TotalViews % 1]
-min(0 % TotalViews)
-string(Authors == Authors)
-min(-0)
-min(0) ^ -2
-count(Posts, "Go" != nil)
-one(Posts, 0.5 < 0)
-0 / TotalViews > TotalViews ? " " : 1
-first(false ? Posts : TotalViews)
-Authors == Authors ? Authors : Authors
-map(Posts, Posts) != Posts
-map(Posts, false == false)
-any(Posts, true) && TotalViews == TotalViews
-get(Authors, TotalViews * TotalViews)
-TotalViews * 0 / float(TotalViews)
-Posts == map(Posts, "Go")
-TotalViews < TotalViews - 0.5
-not (TotalViews >= 2)
-0 ** TotalViews + TotalViews / TotalViews
-TotalViews * 0 + 1 / TotalViews
-string(!(nil in Posts))
-none(map(Posts, 1), TotalViews != TotalViews)
-!(0.5 <= 0)
-TotalViews + 0 != TotalViews
-int(float(2))
-not (true and true)
-max(0.5 + TotalViews, TotalViews % TotalViews)
-one(Posts, nil == Posts)
-TotalViews / 0 < TotalViews ? TotalViews : 0.5
-TotalViews >= 0 - 0.5
-count(Posts, 0.5 > TotalViews)
-float(TotalViews ^ 0.5)
-get(Posts, 0)?.Title
-abs(TotalViews ** 1)
-true ? " " : TotalViews < TotalViews
-not (0.5 > 0)
-!(0.5 == TotalViews)
-map(map(Posts, Authors), Posts)
-TotalViews != TotalViews ** TotalViews
-not all(map(Posts, "Go"), TotalViews != TotalViews)
-int(0 * TotalViews)
-max(TotalViews ^ 0.5)
-TotalViews / TotalViews / TotalViews
-Posts != map(Posts, TotalViews)
-TotalViews / 2 ^ 0
-TotalViews > 1 ? TotalViews : TotalViews
--TotalViews < -TotalViews
-{"Go": TotalViews}?.LastName
-all(Posts, any(Posts, true))
-max(1 ** TotalViews)
-max(TotalViews, TotalViews % TotalViews)
-max(-(TotalViews * TotalViews))
-float(TotalViews + 1)
-Posts[len(Authors)]
-map(Posts, 0 != nil)
-not (0.5 >= 0.5)
-Authors[2 + TotalViews]
-map(map(Posts, Posts), TotalViews != nil)
-{"Go": "Go", "JavaScript": Posts}.Title
-not (true == nil)
-string(0 != 0)
-TotalViews * 0.5 / TotalViews
-int(TotalViews) / TotalViews
-get(Posts, 1).Title
-Posts != Posts == nil
-TotalViews < 0 == nil
-(TotalViews % 1) ** TotalViews
-float(float(0.5))
-not (0 < 1)
-!(0 < 1)
-{" ": Posts, "Go": Posts, " ": TotalViews, "JavaScript": 0.5, " ": Posts}.ID
--(0 / 1)
-{"JavaScript": Authors}?.Email
-map(filter(Posts, true), Authors)
-not true ? TotalViews : Posts
-filter(Posts, nil != 2)
-{" ": Posts, " ": TotalViews}.Comments
-string(true && true)
-Authors == Authors == nil
-string(TotalViews >= TotalViews)
-map(Posts, 0 == TotalViews)
-last(filter(Posts, true)).Content
-string(1 ^ 0)
-TotalViews + TotalViews * 0
-len(map(Posts, true))
-not (1 < 2)
-count(Posts, 0 != TotalViews)
-TotalViews * TotalViews in Posts ? 2 : Authors
-TotalViews != TotalViews ^ 1
-count(map(Posts, Authors), !false)
-filter(Posts, TotalViews >= TotalViews)
-filter(Posts, TotalViews >= 0)
-max(0) ^ TotalViews
-none(Posts, false) != false ? Authors : " "
-TotalViews / (0.5 + TotalViews)
-all(Posts, !true)
-{"Go": Authors}.Author
-none(Posts, 0.5 >= 0)
-Posts == Posts != false
-not (0.5 < 2)
-min(1 ^ TotalViews)
-any(Posts, # != #)
-TotalViews ^ TotalViews > -TotalViews
--(0 ^ TotalViews)
-TotalViews != TotalViews / TotalViews
-abs(TotalViews / TotalViews)
-WithID(Posts, 1 * 0)
-TotalViews * TotalViews % TotalViews
-len(Authors) < -TotalViews
-Authors != Authors and Posts != nil
-filter(Posts, nil == 1)
-not (TotalViews != nil)
-TotalViews >= 0.5 || Posts != nil
-string(string(nil))
-Authors == Authors ? TotalViews : 0
-{"JavaScript": 0.5 > TotalViews, "JavaScript": Authors}
-0.5 ^ TotalViews + TotalViews
-one(Posts, Posts == Posts)
-Posts == 1 .. TotalViews
-[-2, Authors]
-one(Posts, 1 == TotalViews)
-abs(TotalViews) > min(0, 0.5)
-0 ^ TotalViews - 0 % TotalViews
-TotalViews ** 2 - TotalViews
-TotalViews < TotalViews ** 2
-len(Authors) == TotalViews ** TotalViews
-{"Go": TotalViews, "Go": TotalViews, " ": Posts, "JavaScript": Posts, "JavaScript": nil}.ID
-min(1) != TotalViews
-TotalViews - Sub(2, 0.5)
-float(len(Posts))
-0 - TotalViews != float(TotalViews)
-map(Posts[0:0], !false)
-Posts[2]?.Comments
-map(Posts, float(TotalViews % TotalViews))
-string(false ? false : nil)
-min(TotalViews / 0)
-all(Posts, 0.5 < TotalViews)
-count(Posts, TotalViews > 1)
-{" ": min(0), " ": -TotalViews}
-max(TotalViews % 1)
-TotalViews > abs(TotalViews)
-TotalViews < 0.5 ? Authors : Posts
-not (" " < " ")
-TotalViews ^ float(0)
-toJSON({" ": Authors})
-TotalViews * TotalViews * 0.5
-float(1 % TotalViews)
--0 % TotalViews
-any(Posts, 2 != nil)
-(0 / 0) ^ TotalViews ^ 0.5
-trim(toJSON(TotalViews))
-TotalViews / TotalViews + TotalViews
-TotalViews / int(0.5)
-{"JavaScript": map(Posts, Authors)}.Profile
-duration(toJSON(0))
-upper(toJSON(TotalViews))
-toJSON(nil == nil)
-Add(0, 0) > TotalViews ? Posts : 0.5
-max(1 / 0)
-filter(Posts, nil == Posts)
-2 ^ TotalViews > TotalViews
-!true ? "Go" : Posts
-map(true ? Authors : Posts, TotalViews)
-min(0.5 * TotalViews)
-" " contains "Go" or nil in Authors
-one(Posts, 1 != 0)
--TotalViews < TotalViews == false
-map(Posts, "Go" == "Go")
-count(Posts, not false)
-TotalViews >= 0.5 / 0
-len(Authors) / TotalViews / TotalViews
-one(Posts, 2 == TotalViews)
-TotalViews + 2 ^ 1
--(0.5 * TotalViews)
-[map(Posts, "JavaScript")]
-none(Posts, 0 > TotalViews)
-map(Posts, TotalViews == 0.5)
-one(Posts, Posts != nil)
--max(0, TotalViews)
-not (0 == 0.5)
-map(Posts, map(Posts, Authors))
-0.5 ^ 0 ^ TotalViews ^ TotalViews
-(TotalViews - 0.5) / TotalViews
-min(count(Posts, true))
-TotalViews < TotalViews ** TotalViews - -TotalViews
-last(map(Posts, false))
-map(map(Posts, Authors), Authors)
-TotalViews ^ 0 >= TotalViews
-len(true ? Posts : Posts)
-Posts != Posts ? Posts : Posts
-TotalViews == 0 / TotalViews
-0 ** 0 >= TotalViews
-TotalViews != 0 ? 0.5 : "Go"
-len(trim(" "))
-{" ": nil}.Tags
-TotalViews in Authors ? 0 : 2
-TotalViews ^ TotalViews != TotalViews
-one(Posts, TotalViews >= TotalViews)
-toJSON(true != true)
-1 / TotalViews > TotalViews
-TotalViews + TotalViews - max(TotalViews)
-all(Posts, 1 <= TotalViews)
-none(Posts, TotalViews >= 1)
-max(0.5 / TotalViews)
-TotalViews .. -TotalViews
-Posts == Posts ? TotalViews : TotalViews
-TotalViews ^ (Posts != nil ? TotalViews : Posts)
-TotalViews == count(Posts, false)
-0 % TotalViews + TotalViews
-string(0.5 + 0)
-all(map(Posts, Authors), Posts != Posts)
-string(false ? " " : TotalViews)
-toJSON(TotalViews * TotalViews)
-0 / TotalViews - TotalViews
-none(Posts, TotalViews != 2)
-count(Posts, Authors != Authors)
-0 + TotalViews < TotalViews
-toJSON(upper("Go"))
-TotalViews ** (0 - 2)
-all(Posts, # == #)
-{" ": true}?.Biography
-nil != Posts and TotalViews < 0
-TotalViews in Authors ? Posts : nil
-one(Posts, Posts == nil)
-nil == TotalViews and 0.5 <= TotalViews
-TotalViews != min(TotalViews)
-TotalViews <= TotalViews ? "JavaScript" : Authors
-min(TotalViews) * TotalViews
-TotalViews ** 2 == TotalViews % TotalViews
-string(1 ^ 0.5)
-max(min(0, 2))
-TotalViews / Add(0, 2)
-count(Posts, false) > TotalViews
-Authors == Authors != true
-TotalViews >= TotalViews + 0.5
-abs(2) in Authors ? nil : false
-string(filter(Posts, false))
-upper(string(float(TotalViews)))
-abs(0.5 / 0.5)
-Authors != Authors ? Authors : Authors
-toJSON(TotalViews == TotalViews)
--0 - TotalViews
-1 .. TotalViews == Posts
--TotalViews >= 1 ? 0.5 : 1
-0 ^ TotalViews / TotalViews
--(0.5 ^ 0)
-max(TotalViews ** TotalViews)
-2 ** 0.5 / count(Posts, false)
-string(map(Posts, 0))
-map(map(Posts, TotalViews), abs(TotalViews))
-max(TotalViews) ** TotalViews
-string(-0)
-TotalViews ** TotalViews >= TotalViews
-TotalViews != 0 ? Posts : nil
-filter(Posts, 1 == 0)
-TotalViews ^ 0 ** TotalViews
-count(Posts, Authors == nil)
-TotalViews ** (TotalViews * TotalViews)
-string("Go" <= " ")
-get(Authors, TotalViews - 0)
-0.5 + 0 < 0.5 ? nil : TotalViews
-toJSON(nil in Posts)
-min(TotalViews * 0.5)
-!(TotalViews > 0.5)
-{" ": -TotalViews}
-Authors[min(TotalViews)]
-[2 ^ 2]
-max(int(0))
-{"Go": "Go"}.Tags
-string(TotalViews * 0.5)
-all(Posts, TotalViews != nil)
-map(Posts, Posts[0:TotalViews])
-TotalViews * 2 > TotalViews
-TotalViews - TotalViews + TotalViews - TotalViews
-lower(string(false))
-all(Posts, Posts == nil)
-all(Posts, 2 >= 2)
-len(filter(Posts, true))
-filter(Posts, Authors != Authors)
-!(0 == TotalViews)
-map(true ? Posts : Posts, Authors)
-len(Authors) ** TotalViews
-not true and TotalViews == 0
-all(Posts, nil == nil)
-TotalViews <= 1 or nil in Authors
-TotalViews / 2 == TotalViews ? false : Authors
-TotalViews / max(2)
-TotalViews + 2 ^ TotalViews
-TotalViews in map(Posts, 0)
-int(0.5 * TotalViews)
-(TotalViews + TotalViews) * TotalViews % 2
-Authors == Authors ? 1 : nil
-TotalViews / 0.5 * TotalViews
-true ? Authors : 2 >= TotalViews
-len(Authors) in Posts == nil
-filter(1 .. TotalViews, TotalViews >= TotalViews)
-TotalViews ^ 2 != TotalViews
-all(Posts, nil == Authors)
-string(any(Posts, false))
-TotalViews <= -TotalViews
-float(TotalViews) - 0.5 - TotalViews
-nil in Posts or true == nil
-map(Posts, TotalViews .. TotalViews)
-toJSON(TotalViews == 1)
-Posts != Posts == false
-{" ": Posts, " ": 0.5}?.Author
--(2 + 1)
--(1 * TotalViews)
-get(Posts, TotalViews - TotalViews)?.ID
-string(0 == TotalViews)
-min(TotalViews, TotalViews) > TotalViews
-TotalViews != len(Authors)
-string(int(0))
-not (nil != true)
-0 ^ TotalViews - TotalViews
-all(Posts, 0.5 != TotalViews)
-Posts != Posts ? Posts : Authors
-!(nil != true)
-{"JavaScript": nil}?.PublishDate
-int(TotalViews - 2)
-min(TotalViews) / 0 ** TotalViews
--TotalViews * TotalViews ** TotalViews
-min(2 % TotalViews)
-0 .. TotalViews != Posts ? TotalViews : 0.5
-int(TotalViews * 2)
-0.5 - TotalViews != TotalViews
-get(Posts, 1).Tags
-TotalViews % TotalViews < TotalViews
-get(Posts, false ? Posts : TotalViews)
-TotalViews - float(TotalViews) <= TotalViews
-{" ": Posts, " ": Posts}.Content != Authors
-not (0.5 != 0)
-not ("JavaScript" == " ")
-(0.5 + TotalViews) / TotalViews
-TotalViews / 0.5 < TotalViews
-not (0 == 1)
-TotalViews != TotalViews ? TotalViews : Posts
-upper(toJSON(" "))
-float(2) >= TotalViews ** TotalViews
--(TotalViews / 0)
-not (TotalViews != 1)
-int(0 ^ 0)
-TotalViews ^ 0 ^ (TotalViews + TotalViews)
-TotalViews * 0.5 > TotalViews
-map(Posts, 0.5 / TotalViews)
--(TotalViews ** 2)
-int(2) - TotalViews
-toJSON(nil != 1)
-TotalViews > 0 ** TotalViews
-TotalViews >= TotalViews ^ 1
-filter(Posts, TotalViews < 0.5)
-abs(0.5 ^ TotalViews)
-int(0 % TotalViews)
-0.5 * TotalViews > TotalViews / TotalViews
-int(TotalViews + 0.5)
-map(Posts, 0 != TotalViews)
-Posts[1].Title
-TotalViews * -TotalViews
-!(1 == TotalViews)
-TotalViews - TotalViews >= TotalViews
-max(Add(2, 0))
-1 + 0 < 1 ** 0
-nil != Posts ? TotalViews : Posts == Posts
-one(Posts, true != nil)
-filter(Posts, 0.5 == nil)
-not (0 in Authors)
-map(map(Posts, true), Authors)
-not ("Go" > "Go")
-string(0.5 + TotalViews)
-true ? Authors : Posts[TotalViews]
-not (false and true)
-min(0 + 1)
-{"Go": Authors}?.LastName
-0.5 * TotalViews / int(TotalViews)
-Posts == map(Posts, TotalViews)
-count(Posts, nil == Posts)
--(TotalViews * 1)
-TotalViews * TotalViews in Posts
-string(not false)
-2 ^ 0 / int(TotalViews)
-TotalViews ** -0.5
-!(0.5 >= 0)
-string(nil == nil)
-!(1 > TotalViews)
-abs(TotalViews ^ (TotalViews / TotalViews))
-TotalViews .. 1 - 0
-!(" " <= "Go")
-abs(TotalViews + 2)
-abs(len("Go"))
-string(string(Posts))
-map(Posts, min(TotalViews))
-{"Go": nil}.ID
-!(" " > " ")
-{" ": TotalViews, "Go": Posts}
-last(map(Posts, 0))
--abs(0)
-toJSON(true ? 0.5 : 0.5)
-float(1 / TotalViews)
-not (1 != 0)
-max(0 / TotalViews)
-int(0) - TotalViews
-!not (TotalViews != 0)
-string(!(TotalViews < TotalViews))
-int(0.5) == TotalViews
-Authors == Authors ? Posts : 1
-WithID(Posts, 1)?.PublishDate
--(TotalViews + 0)
-Authors[min(0)]
-filter(Posts, true) != map(Posts, TotalViews)
-trim("Go") > toJSON(TotalViews)
-WithID(Posts, 2).Title
-int(TotalViews) % TotalViews
-max(0.5 - 0)
-last(Posts).Author
-map(Posts, TotalViews > 0.5)
-!true ? 2 : 2
-count(Posts, TotalViews != TotalViews)
-string(0 ^ 0)
-min(TotalViews) + TotalViews
-false ? Posts : TotalViews .. TotalViews
-one(Posts, !false)
-fromJSON(toJSON(Authors))
-TotalViews - 1 + TotalViews
-true ? Posts : TotalViews ^ TotalViews
-Authors != nil ? TotalViews : TotalViews
-TotalViews ** (TotalViews + 0.5)
-get(Authors, abs(TotalViews))
-len(Posts) > TotalViews * TotalViews
-TotalViews <= TotalViews ? Authors : TotalViews
-one(Posts, true && true)
-min(TotalViews * 2)
-Posts[1]?.Tags
-min(1) != 2 ^ TotalViews
-map(Posts, string(Posts))
--(2 ^ 1)
-not (TotalViews == 0.5)
-count(Posts, nil == 0)
-0.5 * 0 != TotalViews
-(TotalViews + 0) ^ TotalViews
-TotalViews + count(Posts, false)
-TotalViews == 0.5 ? TotalViews : TotalViews
-map(Posts, true) == Posts
-{"JavaScript": 0.5 ** TotalViews}
-{"Go": nil, "JavaScript": Posts, " ": Authors}?.Upvotes
-one(Posts, IsZero(#))
-!any(Posts, true)
-last([TotalViews])
-string(TotalViews <= 0.5)
--TotalViews - TotalViews / TotalViews
-any(false ? " " : Authors, 0 == 0.5)
-one(Posts, !true)
-WithID(Posts, false ? TotalViews : TotalViews)
-trim(true ? " " : TotalViews)
-TotalViews ^ TotalViews != abs(TotalViews)
-count(Posts, TotalViews != nil)
-{" ": Posts}?.Content
-{"JavaScript": TotalViews, "Go": Posts}.Title
-none(Posts, !true)
-trim(toJSON(1))
-0 .. TotalViews != filter(Posts, true)
-count(Posts, true) == TotalViews
-filter(TotalViews .. TotalViews, 0 == nil)
-WithID(Posts, 2)?.ID
-string(TotalViews / 1)
-toJSON(len(Authors))
-float(TotalViews ^ 1)
-min(TotalViews, TotalViews) % TotalViews
-filter(Posts, 0 != TotalViews)
-{"JavaScript": nil}?.Tags
--(TotalViews + 1)
-TotalViews - TotalViews == TotalViews
-(0.5 * TotalViews) ** TotalViews
-one(Posts, 0 > TotalViews)
-TotalViews .. 0 - TotalViews
-filter(true ? Posts : Posts, TotalViews <= 0)
-len(filter(Posts, false))
-TotalViews - 0.5 * TotalViews
-TotalViews * TotalViews >= TotalViews ? "JavaScript" : 1
--float(0)
-TotalViews * max(0)
-any(Posts, TotalViews != nil)
-{"Go": Authors}?.FirstName
-int(min(TotalViews))
-TotalViews != nil == nil
-{" ": 0.5 != TotalViews}
-TotalViews ** -2
-toJSON(map(Posts, "JavaScript"))
-map(map(Posts, Authors), TotalViews)
-TotalViews / TotalViews ^ 0
-TotalViews != TotalViews ^ 0
-map(Posts, Authors != nil)
--TotalViews > count(Posts, false)
-2 ^ TotalViews >= TotalViews ? true : 0
-map(Posts, TotalViews / TotalViews)
-map(Posts, TotalViews + 0)
-one(Posts, TotalViews != 1)
-(0 + TotalViews) ** TotalViews
-TotalViews .. -1
-{"JavaScript": 0, "JavaScript": Posts, "Go": TotalViews}.FirstName
-TotalViews ^ 0.5 / TotalViews
-abs(TotalViews % TotalViews)
-one(map(Posts, Authors), TotalViews > 0.5)
-TotalViews == nil ? Posts : "JavaScript"
-toJSON(one(Posts, true))
-toJSON(0.5 ^ TotalViews)
-len(true ? Authors : TotalViews)
-0 / TotalViews <= TotalViews
-Posts != nil ? 2 : nil
-2 - 0 >= TotalViews
-map(Posts, true ? false : 2)
-filter(Posts, !true)
-string(TotalViews ^ 0.5)
-TotalViews in Posts ? Posts : Authors
-int(0) == TotalViews
-max(0.5 ^ 0)
-filter(Posts, nil in Posts)
-toJSON(1 .. TotalViews)
-TotalViews != 0 and not true
-Posts[TotalViews:TotalViews] == 1 .. TotalViews
-!(TotalViews <= 2)
-any(Posts, 2 < 1)
-TotalViews / (TotalViews - 0.5)
-int(1 / 0.5)
-!("JavaScript" <= " ")
-int(abs(TotalViews))
-map(Posts, TotalViews + TotalViews)
-map(Posts, len(Posts))
-lastIndexOf(" ", "Go") ** TotalViews
-toJSON(get(Authors, TotalViews).Profile)
-min(TotalViews) != TotalViews
-any(Posts, 0 != TotalViews)
-{" ": Authors, "Go": 0, "Go": Authors, "JavaScript": Authors, "Go": 2}.Content != Posts
-filter(map(Posts, Authors), Posts == Posts)
-TotalViews > 0.5 ? Posts : Posts
-one(Posts, 0.5 >= TotalViews)
-none(Posts, IsZero(#))
-Sub(1, 0.5) ** TotalViews
-TotalViews >= 0 ** 1
-TotalViews in Posts != false
-get(Posts, int(TotalViews))
-!(0.5 != TotalViews)
-(1 - TotalViews) ** TotalViews
-[TotalViews, TotalViews]
-Posts != map(Posts, 0.5)
-get(map(Posts, false), TotalViews)
-TotalViews ** TotalViews + TotalViews
-string(map(Posts, " "))
-any(Posts, TotalViews == TotalViews)
-TotalViews * (0 + TotalViews)
-[nil != false]
-TotalViews <= 0.5 ^ 2
--(0 - 1)
-min(TotalViews / 0.5)
-TotalViews != TotalViews ** 0.5
-Authors != Authors != nil
-TotalViews / TotalViews ** 0
-one(Posts, 1 > TotalViews)
-!(nil != 0.5)
-get(Authors, 1 + TotalViews)
-{"JavaScript": "JavaScript"}.ID
-abs(TotalViews + 0)
-map(Posts, TotalViews != 0.5)
-abs(TotalViews ** 0.5)
-[TotalViews .. TotalViews]
-0.5 - 0 >= TotalViews
--abs(2)
-{"JavaScript": Posts, "JavaScript": Authors}.Title
-map(Posts, 2 ** 0.5)
-string(0 == 2)
-map(Posts, nil in Authors)
--min(0.5 ^ 0)
-min(TotalViews + TotalViews, TotalViews)
-Authors[nil].Profile
-2 % TotalViews == TotalViews
-TotalViews * int(TotalViews)
-!(0 in Posts)
-string(hasPrefix("JavaScript", " "))
-map(Posts, TotalViews < 0.5)
-any(Posts, 0 == TotalViews)
-0 >= TotalViews or TotalViews < TotalViews
-all(map(Posts, Posts), TotalViews in Authors)
-none([TotalViews <= TotalViews], #)
-get(Posts, TotalViews)?.Author?.ID
-not (0 <= TotalViews)
-!(0 > 0.5)
-TotalViews in Posts or TotalViews > TotalViews
-TotalViews <= TotalViews ? nil : Authors
-string(map(Posts, "Go"))
-string({" ": false})
-toJSON(Authors != Authors)
-!(0.5 > 0.5)
-toJSON(get(Posts, 1))
-TotalViews - 2 * TotalViews
-TotalViews >= TotalViews ? nil : false
-map([Authors], Posts)
-TotalViews * 0 % 1
-2 ** TotalViews < TotalViews
-float(TotalViews ** 0)
-!("JavaScript" >= " ")
--TotalViews ** -TotalViews
-TotalViews - 2 == TotalViews
-last(map(Posts, 2))
-TotalViews / TotalViews > TotalViews
-toJSON(TotalViews < 2)
-max(2) ^ len(Posts)
-!false ? Authors : "JavaScript"
-string(all(Posts, false))
-!("Go" > "Go")
-TotalViews >= 0 == nil
-toJSON(TotalViews != 1)
-(TotalViews + TotalViews) ^ TotalViews
-TotalViews + TotalViews + TotalViews
-last(Posts)?.Title
-Add(1, 2) + TotalViews ^ 0
-not (1 == nil)
-string(1 / 0)
-filter(Posts, Authors == Authors)
-get(false ? Posts : TotalViews, TotalViews != Posts)
-0 ** TotalViews * TotalViews
-{" ": nil, "Go": "JavaScript", "JavaScript": Authors}?.Tags
-all(Posts, nil != TotalViews)
-abs(0.5 ** TotalViews)
-TotalViews <= 2 ** TotalViews
-TotalViews ^ (TotalViews / TotalViews)
-string(0 / TotalViews)
-max(0 + 0)
-any([0, TotalViews], TotalViews in Authors)
-map(map(Posts, 0), TotalViews - TotalViews)
-min(TotalViews) > TotalViews
-TotalViews < count(Posts, true)
-false ? 1 : TotalViews > TotalViews
-TotalViews ** (TotalViews % TotalViews)
-Posts == Posts == one(Posts, true)
-get(true ? 0.5 : Posts, Posts)
-last(map(Posts, #))
-not (TotalViews != 0)
-TotalViews ** (0 % TotalViews)
-any(Posts, true == nil)
-string(0.5 > 2)
-Posts != Posts != true
-max(TotalViews + 0.5, TotalViews)
-Authors != Authors ? 1 : 0
-abs(TotalViews) / TotalViews
-TotalViews != len(Posts)
-{"JavaScript": Posts, " ": Posts, "Go": nil}.Author
-TotalViews == nil ? Authors : TotalViews
-{" ": TotalViews, "JavaScript": Authors}
-min(1 / TotalViews)
-string(1 <= TotalViews)
-int(1) >= TotalViews
-filter(Posts, not false)
-first(Posts[0:2])
--max(TotalViews, TotalViews)
-all(Posts, 0.5 > TotalViews)
-none(Posts, TotalViews <= 1)
-Posts == Posts ? Authors : Authors
-0.5 ** TotalViews == TotalViews
-get(Posts, TotalViews * 0)
-abs(TotalViews * 0.5)
-TotalViews / 0 * TotalViews
--(1 ** TotalViews)
-Posts == Posts and TotalViews in Authors
-count(map(Posts, TotalViews), TotalViews == 0.5)
-get(Posts, true ? false : TotalViews)
-TotalViews >= 2 * 0
-{" ": Authors, "JavaScript": Posts}
-toJSON(0 != TotalViews)
-2 ** TotalViews == TotalViews
-max(TotalViews, TotalViews, TotalViews)
-Posts == Posts || TotalViews < 1
-WithID(Posts, 0)?.PublishDate
-[TotalViews == 1]
-1 .. 1 == Posts
-abs(0 % 1)
-none(2 .. TotalViews, "Go" >= "JavaScript")
-any(Posts, none(Posts, false))
-string(nil != TotalViews)
-!(0.5 != nil)
-toJSON(string(1))
-WithID(Posts, TotalViews).Title
-one(Posts, TotalViews != 0.5)
-0 ^ 0 < TotalViews
-{"Go": TotalViews}?.CommentDate?.Content
-TotalViews + TotalViews < TotalViews
-TotalViews / TotalViews * TotalViews
-!(false != false)
-float(0) < TotalViews
-string(-1)
--(0 * 1)
--(TotalViews > TotalViews ? Posts : TotalViews)
-TotalViews != TotalViews == true
-1 % TotalViews % TotalViews
-TotalViews < float(TotalViews)
-string(TotalViews ** 1)
-{"JavaScript": Authors != Authors}
-Posts != 0 .. TotalViews
-count(Posts, any(Posts, false))
-map(map(Posts, true), count(Posts, false))
-TotalViews != 0 ? TotalViews : " "
-TotalViews == nil ? TotalViews : Posts
-{" ": TotalViews > TotalViews, "Go": Posts}
-float(TotalViews) * -0.5
-TotalViews / TotalViews >= TotalViews
-Posts != Posts ? 2 : "JavaScript"
-!true ? Posts : Posts
--(TotalViews ** 1)
-string(Posts != nil)
-toJSON(Posts == nil)
-TotalViews != TotalViews ? 0.5 : nil
-lower(toJSON(TotalViews))
-!(nil == false)
-all(Posts, 0 >= 0.5)
-TotalViews != 0.5 == nil
-any(Posts, TotalViews >= TotalViews)
-map(map(Posts, true), #)
-{"JavaScript": 0}.LastName
-abs(0 - TotalViews)
-0 <= TotalViews || TotalViews == 2
-(TotalViews / TotalViews) ^ TotalViews
-TotalViews != 0 * TotalViews
-count(Posts, false) < TotalViews ? Authors : TotalViews
-TotalViews > 0.5 + TotalViews
-TotalViews % TotalViews in Posts
-max(0 % 2)
-string(len(Authors))
--(TotalViews + 0.5)
-float(min(0.5))
-!("JavaScript" == "Go")
-len(map(Posts, false))
-map(Posts, TotalViews == 2)
-!true ? TotalViews : 0
-{" ": 0, " ": TotalViews, "JavaScript": 0.5}.Title
-toJSON(Authors != nil)
-true ? Posts : Authors[TotalViews]
-TotalViews * TotalViews ^ 1
-{"Go": Authors, "Go": 0.5}?.Email
-filter(Posts, nil != TotalViews)
-TotalViews in Authors ? true : false
-toJSON(string(Authors))
-first(map(Posts, "Go"))
-Posts[1]?.Author
-max(TotalViews % 2)
-!(nil == 2)
-TotalViews != 2 ? true : TotalViews
-TotalViews in Posts ? TotalViews : Posts
-len(Authors) > 0 * TotalViews
-TotalViews .. min(TotalViews)
-TotalViews == TotalViews + 2
-string(1 / 0.5)
-false ? Authors : 1 in Authors
-map(Posts, Posts != Posts)
-!(2 != TotalViews)
-all(Posts, TotalViews <= TotalViews * TotalViews)
-string(2 < 0)
-string(0.5 != TotalViews)
-map(Posts, # == #)
-Authors != Authors ? get(Authors, 2) : Authors
-TotalViews ^ (TotalViews * 2)
-TotalViews < TotalViews * 0
-TotalViews > 0 * 0
-TotalViews <= 1 ? Posts : true
-TotalViews <= TotalViews ? TotalViews : Posts
-not (" " > "Go")
-TotalViews / -0
-string(float(TotalViews))
-not (0 in Posts)
-not false ? " " : 2
-TotalViews ^ int(0)
-any(Posts, TotalViews != TotalViews)
-map(Posts, IsZero(#))
-get(Authors, 1)?.LastName
-toJSON(map(Posts, 1))
-{" ": nil, "JavaScript": 2}?.Upvotes
-len(0 .. 1)
-TotalViews <= TotalViews / TotalViews
-max(0 - TotalViews)
-Authors == Authors || 0.5 >= 1
-get(true ? Posts : Posts, TotalViews)
-float(1) + TotalViews
-{"JavaScript": TotalViews}?.ID
-count(Posts, 2 < 0)
-map(Posts, 0.5 != 0.5)
-{"Go": Authors}.Likes
-Posts != Posts ? TotalViews : 0.5
-map(Posts, Posts[TotalViews:TotalViews])
-any(map(Posts, 0), not true)
-nil == " " && 0 == TotalViews
-string(0 <= 0)
-map(Posts, nil != Posts)
--TotalViews in 0 .. TotalViews
-filter(Posts, TotalViews < 0)
-TotalViews ^ TotalViews * min(0) + TotalViews
-count(Posts, IsZero(#))
-map(0 .. TotalViews, TotalViews)
-!(0 > 0)
-1 >= TotalViews ? IsAdmin(nil) : TotalViews
-TotalViews <= TotalViews % 1
-first(map(Posts, " "))
-len(Authors) == 0 % TotalViews
-max(2 - TotalViews)
-{"JavaScript": "Go", " ": " "}?.Title
-{"JavaScript": Authors}?.PublishDate
-TotalViews * 0.5 >= TotalViews
-one(Posts, TotalViews != 0)
-none(Posts, one(Posts, false))
-Posts != nil ? Posts : false
-Posts[TotalViews:TotalViews + TotalViews]
-abs(0.5 + TotalViews)
-!(true == nil)
-int(TotalViews / 1)
-float(Add(0, 0))
-1 - TotalViews == TotalViews ** 0
-TotalViews ** (1 * TotalViews)
-string(Title(Posts[0]))
-map(Posts, toBase64(" "))
-{"JavaScript": TotalViews, "JavaScript": Authors}
-(TotalViews - TotalViews) * -0
-map(Posts, TotalViews * 0)
-toJSON(false ? Authors : Authors)
-!false != none(Posts, true)
-map(Posts, 0.5 < TotalViews)
-string(1 ** TotalViews)
-min(float(TotalViews))
-TotalViews == 1 ? nil : Authors
-Posts == Posts != true
-0.5 * TotalViews - TotalViews
-TotalViews in TotalViews .. 2
-filter(Posts, "JavaScript" endsWith "Go")
--min(1)
-TotalViews + 1 in Posts
-not (" " != nil)
-[0.5 + 0]
-max(TotalViews, TotalViews) > TotalViews
-string(Add(2, 0))
-all(Posts, nil != Authors)
-TotalViews == abs(0)
-TotalViews ** 0 != -0
-any(Posts, 0.5 != nil)
-not (nil != "JavaScript")
-1 + 0 >= TotalViews
-TotalViews * 0 ** TotalViews
-toJSON(string(TotalViews))
-TotalViews ^ count(Posts, Authors == nil)
-0 * 0 in Authors
-[TotalViews % 2]
-min(float(TotalViews), 0 / TotalViews)
-any(map(Posts, 2), TotalViews <= 0.5)
-0.5 - TotalViews > TotalViews
-string(nil != nil)
-(TotalViews - TotalViews) * (2 + 0.5)
-int(count(Posts, true))
-0 > TotalViews || 1 >= TotalViews
-count(Posts, 0.5 < 0.5)
-any(Posts, 2 >= TotalViews)
-0.5 + TotalViews + TotalViews
-min(TotalViews) in Authors ? nil : nil
-not (2 >= TotalViews)
-get(Posts, TotalViews - 1)
-abs(false ? 0.5 : TotalViews)
-TotalViews ** abs(TotalViews)
-float(TotalViews * 0)
-TotalViews < 0.5 - TotalViews
-TotalViews ^ -0
--(TotalViews / 1)
-map(Posts, toJSON("JavaScript"))
-map(Posts, filter(Posts, false))
-none(Posts, 2 < TotalViews)
-2 > TotalViews and nil == Posts
-TotalViews in Authors ? nil : Posts
---1
-min(TotalViews ^ TotalViews)
-max(TotalViews + 0)
-TotalViews * TotalViews >= TotalViews
-map(map(Posts, false), Posts)
-Add(0, 0.5) + TotalViews
-all(Posts, 1 > 2)
-TotalViews != TotalViews * TotalViews
-{"Go": Posts}?.FirstName
-map(map(Posts, 2), Posts)
-upper(string(2))
-2 * 0 .. TotalViews
-Posts == [TotalViews, Authors]
-get(Posts, TotalViews) != get(Posts, TotalViews)
-{"Go": 1, " ": Posts}.ID
-toJSON(TotalViews ^ 1)
-none(Posts, 1 <= 0.5)
-0 - TotalViews > TotalViews ? false : nil
-TotalViews == 0 ? Authors : Posts
-{"JavaScript": " " != nil}
-[Authors, Posts]
-0.5 - 2 <= TotalViews
-len(Posts) <= TotalViews
-len(Authors) <= TotalViews
--float(2)
-0.5 ** TotalViews != TotalViews
--TotalViews in filter(Posts, true)
-2 ** 0 ^ (TotalViews / TotalViews)
-TotalViews ** TotalViews != TotalViews ** TotalViews
-float(2 - TotalViews)
-map(Posts, nil == Posts)
-TotalViews * 1 % TotalViews
-toJSON(true ? TotalViews : Posts)
-TotalViews % TotalViews == TotalViews
--0 != TotalViews
-TotalViews ** TotalViews ^ TotalViews
-trim(toJSON(nil))
-any(Posts, TotalViews == nil)
-string(TotalViews < TotalViews)
-int(0.5 ^ 2)
-!(TotalViews < 2)
-first([" ", TotalViews, TotalViews, Authors, Authors])
-WithID(Posts, 0).ID + TotalViews
-none(Posts, 0 in Posts)
-first(Posts[0:TotalViews])
-get(Posts, 2).Likes
-TotalViews >= 2 - TotalViews
-count(map(Posts, Posts), TotalViews in Authors)
-TotalViews != TotalViews ? Posts : Posts
-TotalViews + TotalViews != count(Posts, true)
-TotalViews ** 0 >= TotalViews
-Authors[1].Email
-min(min(0))
-float(0 * 2)
-TotalViews + abs(TotalViews % 1)
-0.5 != TotalViews or 0 != nil
-abs(1) < TotalViews
-{"Go": nil, "JavaScript": "Go"}?.CommentDate
-one(Posts, " " != nil)
-int(TotalViews) in map(Posts, Posts)
-TotalViews + 0 .. TotalViews
-TotalViews - TotalViews / 0
-0.5 / TotalViews < TotalViews ** 2
-none(Posts, TotalViews <= 0)
-Authors[len(Posts)]
-lower(toJSON(Authors))
-!(0.5 != 2)
-TotalViews != TotalViews ? nil : TotalViews
-int(TotalViews * 0.5)
-len(Posts) <= -TotalViews
-!(0 < 0)
-Posts == nil ? Authors : nil
--(TotalViews + 2)
-TotalViews * TotalViews - TotalViews
-1 < TotalViews || 0 == 0
-not (nil != 0)
-TotalViews >= 0.5 != nil
-none(Posts, TotalViews < 1)
-map(Posts, 0 in Authors)
-not true ? Posts : Posts
-string(0.5 < TotalViews)
-int(TotalViews) != TotalViews
-map(Posts[TotalViews:TotalViews], Posts)
-(TotalViews - 0) ^ TotalViews
-len(Posts) + TotalViews
-{"JavaScript": " ", "Go": TotalViews, "Go": 2}?.Tags
-!(1 < 0)
-one(filter(Posts, false), 0 == nil)
-abs(TotalViews) .. TotalViews
-TotalViews % 1 < TotalViews ? 0.5 : Authors
-map(Posts, 1 + TotalViews)
-string(true == true)
-TotalViews ** (0.5 * TotalViews)
-none(Posts, false == true)
-int(0.5 ** TotalViews)
-TotalViews .. max(TotalViews)
-TotalViews <= count(Posts, true)
-!(Posts == nil)
-{"JavaScript": Authors, "Go": "Go"}.Upvotes
-float(0.5 + TotalViews)
-TotalViews % 1 + TotalViews / 0
-"JavaScript" in Authors[TotalViews]
-TotalViews + TotalViews + 0.5
-all(Posts, false == false)
-TotalViews < 0 / TotalViews
-map(Posts, 0.5 * 2)
-[-TotalViews]
-get(Posts, false ? 0 : Authors)
-get(Posts, true ? TotalViews : true)
-max(max(TotalViews))
-!(TotalViews >= 1)
-Posts == Posts or 2 <= 0
--0.5 == TotalViews
-map(TotalViews .. 1, Title(nil))
-not !(TotalViews > TotalViews)
-(0.5 + 2) ** len(Posts)
-!true ? Posts : Authors
-abs(0.5 ** 0)
-all(Posts, TotalViews == 1)
-string(0 in Posts)
-TotalViews + max(0)
-get(Authors, int(0))
-get(Posts, true ? 0 : Authors)
-TotalViews > TotalViews % TotalViews
-len(Posts) != TotalViews
-float(TotalViews * 2)
-0 % TotalViews / 0.5 / 1
-toJSON(min(TotalViews))
-string(any(Posts, true))
-not !(Authors != Authors)
--0.5 ** TotalViews
-Authors != Authors && one(Posts, true)
-TotalViews * 2 == TotalViews
-int(0.5) <= TotalViews ? Posts : 0
-one(Posts, true) && TotalViews in Posts
-TotalViews + 0 > 0 ^ 0
-any(Posts, .Equal(#))
-TotalViews ^ TotalViews / TotalViews
-0 / 0 != TotalViews / TotalViews
-2 ^ TotalViews - TotalViews
-map(map(Posts, 0), Posts)
--(1 * 0)
-map(Posts, 1 != TotalViews)
-min(TotalViews ^ 0)
-map(false ? " " : Posts, Authors)
-{"JavaScript": Authors, "Go": TotalViews}?.Profile
-upper(false ? TotalViews : "Go")
-min(1 % 1)
-max(0.5 - 2)
--(TotalViews - 2)
-all(Posts, nil in Posts)
-TotalViews + 0 + TotalViews
-Posts != map(Posts, Authors)
-TotalViews * TotalViews < TotalViews
-{" ": TotalViews, "JavaScript": TotalViews}?.Content
-0 != TotalViews ? TotalViews : TotalViews
-{" ": "JavaScript", " ": TotalViews}.ID
-min(0 - TotalViews)
-TotalViews + 0 in Authors
-TotalViews - TotalViews / 0.5
-TotalViews != max(TotalViews, TotalViews)
-0.5 ** 1 == TotalViews
-len(Authors) in Posts
-filter(Posts, Posts == Posts)
-TotalViews ^ 0.5 ^ TotalViews
-all(map(Posts, 0.5), TotalViews in Authors)
-TotalViews + TotalViews >= TotalViews
-(0 % TotalViews) ** TotalViews
-filter(map(Posts, " "), TotalViews >= 0)
-TotalViews in Authors or TotalViews in Posts
--max(0.5)
-all(Posts, 0 < TotalViews)
-WithID(Posts, 1)?.Content
-!false ? nil : 1
--0 ** TotalViews
-{" ": TotalViews, "JavaScript": nil}?.CommentDate
-int(TotalViews ^ 1)
-map(Posts, .Content)
-string(false != false)
-filter(Posts, any(Posts, true))
-abs(true ? TotalViews : Posts)
-map(Posts, # != #)
-toJSON(0 ^ TotalViews)
-not false ? 0.5 : Authors
-TotalViews - 0 <= TotalViews
-TotalViews ^ TotalViews + TotalViews
-TotalViews * TotalViews / 0
-float(0 + 0.5)
-abs(count(Posts, true))
-max(0) ** TotalViews
-not (1 >= TotalViews)
-filter(Posts, false != true)
-string(toJSON(true))
-0 % TotalViews < TotalViews
-map(map(Posts, TotalViews), 2 != TotalViews)
--(2 ** TotalViews)
-none(Posts, TotalViews > TotalViews)
-get(Authors, 2 * TotalViews)
-[Authors] != Posts
-Posts[0 % TotalViews]
-(0 + TotalViews) / TotalViews
-true ? TotalViews : 1 .. TotalViews
-float(0.5) ** TotalViews
-TotalViews * 1 <= abs(TotalViews)
-TotalViews + 1 >= TotalViews
-0 * 0.5 - TotalViews
-filter(Posts, 0 < 0)
-TotalViews == min(TotalViews)
-{"JavaScript": " ", "JavaScript": TotalViews}.Comments
-TotalViews == TotalViews ** 0
--TotalViews > 0.5 ? "JavaScript" : 2
-TotalViews / (0.5 + 0.5)
-TotalViews ^ min(0)
-TotalViews * 1 ^ TotalViews
-map(map(Posts, TotalViews), -0)
-string(0.5 ** 0)
-count(Posts, false) > TotalViews ? 1 : Posts
-min(TotalViews % 2)
-0.5 / TotalViews < TotalViews
-!(0 != 0)
-!true ? TotalViews : Posts
-last(map(Posts, " "))
-TotalViews * 0 % TotalViews
-float(TotalViews - 1)
-string(TotalViews ** 0.5)
-map(Posts, TotalViews <= 0)
-TotalViews ** 0 * TotalViews
-abs(TotalViews ^ TotalViews)
-TotalViews in Posts and nil in Authors
-TotalViews / 1 / TotalViews
-TotalViews % TotalViews - TotalViews
-len(TotalViews .. 0)
-Posts[count(Posts, false)]
-toJSON(0 <= TotalViews)
-any(Posts, nil != 1)
-not (2 >= 0)
-0.5 > TotalViews and TotalViews <= TotalViews
--(TotalViews ** 0.5)
-not (false != nil)
-TotalViews == TotalViews * TotalViews
-not (1 <= TotalViews)
-not (0 != 0)
-0.5 + TotalViews <= TotalViews
-string(1 - 0.5)
-TotalViews <= max(TotalViews)
--TotalViews in Posts
-any(Posts, 0 in Authors)
-any(Posts, TotalViews == 1)
-abs(0 + TotalViews)
-TotalViews / 1 - TotalViews
-one(Posts, 2 <= 1)
-TotalViews / 1 * 0
-TotalViews == TotalViews ? Authors : Posts
-not !(TotalViews in Authors)
-(2 - TotalViews) * TotalViews ^ TotalViews
-not (1 != TotalViews)
-int(0.5 + 0.5)
-map(false ? 2 : Posts, #)
-count(Posts, 0 < TotalViews)
-map(Posts, 0.5 != TotalViews)
-TotalViews ** TotalViews ^ 0.5
-abs(0 / TotalViews)
-TotalViews <= TotalViews ? TotalViews : 1
-all(Posts, 0 <= 1)
-Authors[max(TotalViews)]
-0.5 != TotalViews || Posts != Posts
-any(map(Posts, true), 1 < TotalViews)
-lower(upper(" "))
-TotalViews >= 2 ? TotalViews : true
-string(0 / 0.5)
-none(Posts, false ? Posts : true)
-TotalViews ^ (TotalViews * 0.5)
-0 % 1 != 0 ^ TotalViews
-Authors[2].LastName
-TotalViews in Posts == nil
-Posts == Posts ? true : Authors
-all(Posts, TotalViews != 0.5)
-upper(toBase64("JavaScript"))
-int(1) .. TotalViews
-TotalViews ^ (TotalViews * TotalViews)
-TotalViews / max(TotalViews)
-string(nil in Authors)
-min(0.5 ^ 0)
-2 % TotalViews + TotalViews
-not (1 == 0)
-max(-0)
-(TotalViews + TotalViews) / (TotalViews + 1)
-not not true
-TotalViews ^ (TotalViews * 0)
-not false ? nil : TotalViews
-Authors[1 + TotalViews]
-toJSON(false ? Posts : Posts)
-map(Posts, TotalViews == 0)
-(0 + 0) / 1 ** 2
-true ? 1 : 0 / TotalViews
-none(Posts, nil != Authors)
-nil != Posts or 2 > TotalViews
-toJSON(min(TotalViews, 0.5))
-all(Posts, TotalViews <= TotalViews)
-any(Posts, 1 > TotalViews)
-TotalViews > 1 ^ 2
-one(Posts, not true)
-one(Posts, TotalViews > 0)
-none(Posts, 2 <= TotalViews)
-none(map(Posts, Posts), nil == Posts)
-0.5 ** TotalViews ** TotalViews
-0 + 1 <= TotalViews
-!false ? false : true
-abs(true ? TotalViews : TotalViews)
--(0 ** 0)
-TotalViews * (TotalViews + 0)
-TotalViews % (TotalViews + TotalViews)
-toJSON(map(Posts, 0.5))
-float(TotalViews) != TotalViews
-{"JavaScript": 1, "Go": Posts}?.PublishDate
-min(1 % TotalViews)
-TotalViews != 0.5 && TotalViews in Posts
-TotalViews != 0 % TotalViews
-min(0 ^ TotalViews)
-WithID(Posts, 0).ID
-toJSON(0.5 + 0.5)
-TotalViews + 0 / 0
-TotalViews >= 0 ? Authors : Authors
-toBase64(string(TotalViews))
-{"JavaScript": "JavaScript"}.Content
-any(Posts, 2 != 0.5)
-TotalViews + -0
-TotalViews >= TotalViews and 2 in Authors
-Posts != Posts == false ? false : TotalViews
-[Posts, TotalViews] != Posts
diff --git a/testdata/fuzz/FuzzExpr/1fedafb72e35699d b/testdata/fuzz/FuzzExpr/1fedafb72e35699d
new file mode 100644
index 000000000..fb2cb204e
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/1fedafb72e35699d
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("one(m[\"\"],#)")
diff --git a/testdata/fuzz/FuzzExpr/37464e3dcb75a05c b/testdata/fuzz/FuzzExpr/37464e3dcb75a05c
new file mode 100644
index 000000000..992d44c28
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/37464e3dcb75a05c
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("repeat(\"0\",1/0)")
diff --git a/testdata/fuzz/FuzzExpr/42564f0e9eda1ad1 b/testdata/fuzz/FuzzExpr/42564f0e9eda1ad1
new file mode 100644
index 000000000..7c21a804e
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/42564f0e9eda1ad1
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("duration(\"0A\")")
diff --git a/testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e b/testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e
deleted file mode 100644
index 751f951d4..000000000
--- a/testdata/fuzz/FuzzExpr/75dd7c6d4ff6ea8e
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("duration(toJSON(1))")
diff --git a/testdata/fuzz/FuzzExpr/87861ab0b9f0abbe b/testdata/fuzz/FuzzExpr/87861ab0b9f0abbe
deleted file mode 100644
index 58c76a3b0..000000000
--- a/testdata/fuzz/FuzzExpr/87861ab0b9f0abbe
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("[[0][0]][0][:0]")
diff --git a/testdata/fuzz/FuzzExpr/b1aef962e961045a b/testdata/fuzz/FuzzExpr/b1aef962e961045a
new file mode 100644
index 000000000..c5c870587
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/b1aef962e961045a
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("fn()")
diff --git a/testdata/fuzz/FuzzExpr/b65163ca9e44703c b/testdata/fuzz/FuzzExpr/b65163ca9e44703c
deleted file mode 100644
index e24cea08f..000000000
--- a/testdata/fuzz/FuzzExpr/b65163ca9e44703c
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("map(false?:Authors,.A)")
diff --git a/testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c b/testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c
new file mode 100644
index 000000000..fb870a2c8
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("fromJSON(\"A\")")
diff --git a/testdata/fuzz/FuzzExpr/c6717d9f77902b9c b/testdata/fuzz/FuzzExpr/c6717d9f77902b9c
new file mode 100644
index 000000000..0f3984207
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/c6717d9f77902b9c
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("toJSON(2^1070)")
diff --git a/testdata/fuzz/FuzzExpr/cd662894c578ed90 b/testdata/fuzz/FuzzExpr/cd662894c578ed90
new file mode 100644
index 000000000..d6b71bb6f
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/cd662894c578ed90
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("duration(\"\")")
diff --git a/testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd b/testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd
new file mode 100644
index 000000000..7790bd025
--- /dev/null
+++ b/testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd
@@ -0,0 +1,2 @@
+go test fuzz v1
+string("fromJSON(\"\")")

From d6e36f69fc216947d285bcbec983fa8f4867e71b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 13:46:11 +0200
Subject: [PATCH 078/506] Move memory budget test

---
 expr_test.go  | 19 +++++++++++++++++++
 vm/vm_test.go | 13 -------------
 2 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index 7ea3700d0..ac8d0f548 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1781,3 +1781,22 @@ func TestEval_slices_out_of_bound(t *testing.T) {
 		})
 	}
 }
+
+func TestMemoryBudget(t *testing.T) {
+	tests := []struct {
+		code string
+	}{
+		{`map(1..100, {map(1..100, {map(1..100, {0})})})`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			program, err := expr.Compile(tt.code)
+			require.NoError(t, err, "compile error")
+
+			_, err = expr.Run(program, nil)
+			assert.Error(t, err, "run error")
+			assert.Contains(t, err.Error(), "memory budget exceeded")
+		})
+	}
+}
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 499020692..202dd3357 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -133,19 +133,6 @@ func TestRun_Helpers(t *testing.T) {
 	}
 }
 
-func TestRun_MemoryBudget(t *testing.T) {
-	input := `map(1..100, {map(1..100, {map(1..100, {0})})})`
-
-	tree, err := parser.Parse(input)
-	require.NoError(t, err)
-
-	program, err := compiler.Compile(tree, nil)
-	require.NoError(t, err)
-
-	_, err = vm.Run(program, nil)
-	require.Error(t, err)
-}
-
 type ErrorEnv struct {
 	InnerEnv InnerEnv
 }

From ec7d61521e788de934bebae4ee73f93511acbccf Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 14:21:10 +0200
Subject: [PATCH 079/506] Fix in op checker

---
 checker/checker.go      | 2 +-
 checker/checker_test.go | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 8204aa7d0..c04c09f31 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -341,7 +341,7 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 			if l == nil { // It is possible to compare with nil.
 				return boolType, info{}
 			}
-			if !isAny(l) && !isInteger(l) {
+			if !isAny(l) && !l.AssignableTo(r.Elem()) && !(isInteger(l) && isInteger(r.Elem())) {
 				return v.error(node, "cannot use %v as type %v in array", l, r.Elem())
 			}
 			return boolType, info{}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 74f02ef37..4b4f77c46 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -55,8 +55,10 @@ var successTests = []string{
 	"(Any ? 0 : nil) == 0",
 	"(Any ? nil : nil) == nil",
 	"!(Any ? Foo : Foo.Bar).Anything",
-	"Int in ArrayOfFoo",
-	"Int not in ArrayOfFoo",
+	"Int in ArrayOfInt",
+	"Int not in ArrayOfAny",
+	"String in ArrayOfAny",
+	"String in ArrayOfString",
 	"String in Foo",
 	"String in MapOfFoo",
 	"String matches 'ok'",

From e9b1e312eab9a9f95ba117e71da8dd0fe5dd85af Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 14:21:25 +0200
Subject: [PATCH 080/506] Add memory budget test

---
 expr_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/expr_test.go b/expr_test.go
index ac8d0f548..3e959bb19 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1787,6 +1787,7 @@ func TestMemoryBudget(t *testing.T) {
 		code string
 	}{
 		{`map(1..100, {map(1..100, {map(1..100, {0})})})`},
+		{`len(1..10000000)`},
 	}
 
 	for _, tt := range tests {

From 72749ef809321ec5a2fb45c255613444aa00a33d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 14:21:36 +0200
Subject: [PATCH 081/506] Update fuzz_test.go

---
 fuzz_test.go | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/fuzz_test.go b/fuzz_test.go
index b9af4ec21..3bbc789d8 100644
--- a/fuzz_test.go
+++ b/fuzz_test.go
@@ -42,7 +42,7 @@ func FuzzExpr(f *testing.F) {
 		`i <= j`,
 		`i in a`,
 		`i not in a`,
-		`i in m`,
+		`s in m`,
 		`m.a`,
 		`m.m.a`,
 		`a[0]`,
@@ -59,7 +59,7 @@ func FuzzExpr(f *testing.F) {
 		`string(i)`,
 		`trim(" a ")`,
 		`trim("_a_", "_")`,
-		`trimPrefix("  a")`,
+		`trimPrefix("  a", " ")`,
 		`trimSuffix("a  ")`,
 		`upper("a")`,
 		`lower("A")`,
@@ -116,6 +116,9 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`reflect: call of reflect.Value.Call on .* Value`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Index on map Value`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Len on .* Value`),
+		regexp.MustCompile(`strings: negative Repeat count`),
+		regexp.MustCompile(`strings: illegal bytes to escape`),
+		regexp.MustCompile(`operator "in" not defined on int`),
 	}
 
 	skipCode := []string{
@@ -125,25 +128,25 @@ func FuzzExpr(f *testing.F) {
 	f.Fuzz(func(t *testing.T, code string) {
 		for _, skipCase := range skipCode {
 			if strings.Contains(code, skipCase) {
-				t.Skip()
+				t.Skipf("skip code: %s", skipCase)
 				return
 			}
 		}
 
-		program, err := expr.Compile(code, expr.Env(env), fn)
+		program, err := expr.Compile(code, expr.Env(env), fn, expr.ExperimentalPipes())
 		if err != nil {
-			t.Skip()
+			t.Skipf("compile error: %s", err)
 		}
 
 		_, err = expr.Run(program, env)
 		if err != nil {
 			for _, okCase := range okCases {
 				if okCase.MatchString(err.Error()) {
-					t.Skip()
+					t.Skipf("skip error: %s", err)
 					return
 				}
 			}
-			t.Errorf("code: %s, err: %s", code, err)
+			t.Errorf("code: %s\nerr: %s", code, err)
 		}
 	})
 }

From 7a494d20df535c38980f94c85ecda8c650a404d6 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 14:21:59 +0200
Subject: [PATCH 082/506] Small fixes

---
 builtin/utils.go      | 1 +
 checker/types.go      | 1 -
 test/mock/mock.go     | 1 +
 vm/runtime/runtime.go | 2 +-
 4 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/builtin/utils.go b/builtin/utils.go
index be258657f..1699c5ddd 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -8,6 +8,7 @@ var (
 	anyType     = reflect.TypeOf(new(interface{})).Elem()
 	integerType = reflect.TypeOf(0)
 	floatType   = reflect.TypeOf(float64(0))
+	arrayType   = reflect.TypeOf([]interface{}{})
 )
 
 func kind(t reflect.Type) reflect.Kind {
diff --git a/checker/types.go b/checker/types.go
index f5fcbdab3..d1a5e85e6 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -20,7 +20,6 @@ var (
 	timeType     = reflect.TypeOf(time.Time{})
 	durationType = reflect.TypeOf(time.Duration(0))
 	functionType = reflect.TypeOf(new(func(...interface{}) (interface{}, error))).Elem()
-	errorType    = reflect.TypeOf((*error)(nil)).Elem()
 )
 
 func combined(a, b reflect.Type) reflect.Type {
diff --git a/test/mock/mock.go b/test/mock/mock.go
index 2ded8e555..b2798a045 100644
--- a/test/mock/mock.go
+++ b/test/mock/mock.go
@@ -32,6 +32,7 @@ type Env struct {
 	Abstract           Abstract
 	ArrayOfAny         []interface{}
 	ArrayOfInt         []int
+	ArrayOfString      []string
 	ArrayOfFoo         []*Foo
 	MapOfFoo           map[string]Foo
 	MapOfAny           map[string]interface{}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 3960b073c..7075c7014 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -267,7 +267,7 @@ func In(needle interface{}, array interface{}) bool {
 		return false
 	}
 
-	panic(fmt.Sprintf(`operator "in"" not defined on %T`, array))
+	panic(fmt.Sprintf(`operator "in" not defined on %T`, array))
 }
 
 func Len(a interface{}) int {

From d90488d31c9984c60775c5940eab8343658c60e8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 14:22:21 +0200
Subject: [PATCH 083/506] Add repeat() memory boundary

---
 builtin/builtin_test.go | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 4c8f61fbb..417af5a8c 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -169,3 +169,19 @@ func TestBuiltin_types(t *testing.T) {
 		})
 	}
 }
+
+func TestBuiltin_memory_limits(t *testing.T) {
+	tests := []struct {
+		input string
+	}{
+		{`repeat("\xc4<\xc4\xc4\xc4",10009999990)`},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			_, err := expr.Eval(test.input, nil)
+			assert.Error(t, err)
+			assert.Contains(t, err.Error(), "memory budget exceeded")
+		})
+	}
+}

From 31a57fa969fdd9c15e0b214cb789a760025d0389 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 14:22:31 +0200
Subject: [PATCH 084/506] Add repeat() memory boundary

---
 builtin/builtin.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 556223420..52738e4cd 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -194,7 +194,11 @@ var Functions = []*Function{
 	{
 		Name: "repeat",
 		Func: func(args ...interface{}) (interface{}, error) {
-			return strings.Repeat(args[0].(string), runtime.ToInt(args[1])), nil
+			n := runtime.ToInt(args[1])
+			if n > 1e6 {
+				panic("memory budget exceeded")
+			}
+			return strings.Repeat(args[0].(string), n), nil
 		},
 		Types: types(strings.Repeat),
 	},

From 386ff5ca38ff27eebd2845c6778218fc7a9fc095 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 14:22:53 +0200
Subject: [PATCH 085/506] Allow trim* func to take only one arg

---
 builtin/builtin.go | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 52738e4cd..34019535f 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -122,16 +122,30 @@ var Functions = []*Function{
 	{
 		Name: "trimPrefix",
 		Func: func(args ...interface{}) (interface{}, error) {
-			return strings.TrimPrefix(args[0].(string), args[1].(string)), nil
+			s := " "
+			if len(args) == 2 {
+				s = args[1].(string)
+			}
+			return strings.TrimPrefix(args[0].(string), s), nil
 		},
-		Types: types(strings.TrimPrefix),
+		Types: types(
+			strings.TrimPrefix,
+			new(func(string) string),
+		),
 	},
 	{
 		Name: "trimSuffix",
 		Func: func(args ...interface{}) (interface{}, error) {
-			return strings.TrimSuffix(args[0].(string), args[1].(string)), nil
+			s := " "
+			if len(args) == 2 {
+				s = args[1].(string)
+			}
+			return strings.TrimSuffix(args[0].(string), s), nil
 		},
-		Types: types(strings.TrimSuffix),
+		Types: types(
+			strings.TrimSuffix,
+			new(func(string) string),
+		),
 	},
 	{
 		Name: "upper",

From d6ddf088650f71a4557eef90c4a8f6be611d8486 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 14:23:07 +0200
Subject: [PATCH 086/506] Add keys() and values() builtins

---
 builtin/builtin.go      | 56 +++++++++++++++++++++++++++++++++++++++++
 builtin/builtin_test.go |  2 ++
 2 files changed, 58 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 34019535f..a8ced5cf1 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -461,4 +461,60 @@ var Functions = []*Function{
 			return runtime.Fetch(args[0], args[1]), nil
 		},
 	},
+	{
+		Name: "keys",
+		Func: func(args ...interface{}) (interface{}, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Map {
+				return nil, fmt.Errorf("cannot get keys from %s", v.Kind())
+			}
+			keys := v.MapKeys()
+			out := make([]interface{}, len(keys))
+			for i, key := range keys {
+				out[i] = key.Interface()
+			}
+			return out, nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Map:
+				return arrayType, nil
+			}
+			return anyType, fmt.Errorf("cannot get keys from %s", args[0])
+		},
+	},
+	{
+		Name: "values",
+		Func: func(args ...interface{}) (interface{}, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Map {
+				return nil, fmt.Errorf("cannot get values from %s", v.Kind())
+			}
+			keys := v.MapKeys()
+			out := make([]interface{}, len(keys))
+			for i, key := range keys {
+				out[i] = v.MapIndex(key).Interface()
+			}
+			return out, nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Map:
+				return arrayType, nil
+			}
+			return anyType, fmt.Errorf("cannot get values from %s", args[0])
+		},
+	},
 }
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 417af5a8c..03bee3afd 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -82,6 +82,8 @@ func TestBuiltin(t *testing.T) {
 		{`get(ArrayOfAny, 1)`, "2"},
 		{`get({foo: 1, bar: 2}, "foo")`, 1},
 		{`get({foo: 1, bar: 2}, "unknown")`, nil},
+		{`"foo" in keys({foo: 1, bar: 2})`, true},
+		{`1 in values({foo: 1, bar: 2})`, true},
 	}
 
 	env := map[string]interface{}{

From f9413ab10e33d39aa9706b090d304a77a540507a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 14:43:24 +0200
Subject: [PATCH 087/506] Do not allow to override builtin function

---
 builtin/builtin.go      | 13 ++++++++++---
 builtin/builtin_test.go | 31 +++++++++++++++++++++++++++++++
 conf/config.go          | 20 ++++++++++++++++++++
 conf/types_table.go     |  7 +++++++
 4 files changed, 68 insertions(+), 3 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index a8ced5cf1..5a0136175 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -12,13 +12,19 @@ import (
 )
 
 type Function struct {
-	Name     string
-	Func     func(args ...interface{}) (interface{}, error)
+	Name  string
+	Func  func(args ...interface{}) (interface{}, error)
+	Types []reflect.Type
+
+	builtin  bool // true if function is builtin
 	Builtin1 func(arg interface{}) interface{}
-	Types    []reflect.Type
 	Validate func(args []reflect.Type) (reflect.Type, error)
 }
 
+func (f Function) Builtin() bool {
+	return f.builtin
+}
+
 var (
 	Index map[string]int
 	Names []string
@@ -28,6 +34,7 @@ func init() {
 	Index = make(map[string]int)
 	Names = make([]string, len(Functions))
 	for i, fn := range Functions {
+		fn.builtin = true
 		Index[fn.Name] = i
 		Names[i] = fn.Name
 	}
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 03bee3afd..4cde5ab48 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -187,3 +187,34 @@ func TestBuiltin_memory_limits(t *testing.T) {
 		})
 	}
 }
+
+func TestBuiltin_disallow_builtins_override(t *testing.T) {
+	t.Run("via env", func(t *testing.T) {
+		env := map[string]interface{}{
+			"len": func() int { return 42 },
+			"repeat": func(a string) string {
+				return a
+			},
+		}
+		assert.Panics(t, func() {
+			_, _ = expr.Compile(`string(len("foo")) + repeat("0", 2)`, expr.Env(env))
+		})
+	})
+	t.Run("via expr.Function", func(t *testing.T) {
+		length := expr.Function("len",
+			func(params ...interface{}) (interface{}, error) {
+				return 42, nil
+			},
+			new(func() int),
+		)
+		repeat := expr.Function("repeat",
+			func(params ...interface{}) (interface{}, error) {
+				return params[0], nil
+			},
+			new(func(string) string),
+		)
+		assert.Panics(t, func() {
+			_, _ = expr.Compile(`string(len("foo")) + repeat("0", 2)`, length, repeat)
+		})
+	})
+}
diff --git a/conf/config.go b/conf/config.go
index 849cdce14..2989eab81 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -95,4 +95,24 @@ func (c *Config) Check() {
 			}
 		}
 	}
+	for name, t := range c.Types {
+		if kind(t.Type) != reflect.Func {
+			continue
+		}
+		for _, b := range builtin.Names {
+			if b == name {
+				panic(fmt.Errorf(`cannot override builtin %s(); it is already defined in expr`, name))
+			}
+		}
+	}
+	for _, f := range c.Functions {
+		if f.Builtin() {
+			continue
+		}
+		for _, b := range builtin.Names {
+			if b == f.Name {
+				panic(fmt.Errorf(`cannot override builtin %s(); it is already defined in expr`, f.Name))
+			}
+		}
+	}
 }
diff --git a/conf/types_table.go b/conf/types_table.go
index 7d486480c..592340069 100644
--- a/conf/types_table.go
+++ b/conf/types_table.go
@@ -121,6 +121,13 @@ func dereference(t reflect.Type) reflect.Type {
 	return t
 }
 
+func kind(t reflect.Type) reflect.Kind {
+	if t == nil {
+		return reflect.Invalid
+	}
+	return t.Kind()
+}
+
 func FieldName(field reflect.StructField) string {
 	if taggedName := field.Tag.Get("expr"); taggedName != "" {
 		return taggedName

From 3475f60925a1753a6413ed3d13a921bf9b759ffc Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 15:17:20 +0200
Subject: [PATCH 088/506] Add gen test

---
 test/{playground => }/gen/gen.go        |   101 +-
 test/gen/gen_test.go                    |    26 +
 test/{playground => }/gen/utils.go      |     0
 testdata/examples.txt                   | 20343 ++++++++++++++++++++++
 testdata/fuzz/FuzzExpr/1fedafb72e35699d |     2 -
 testdata/fuzz/FuzzExpr/37464e3dcb75a05c |     2 -
 testdata/fuzz/FuzzExpr/42564f0e9eda1ad1 |     2 -
 testdata/fuzz/FuzzExpr/b1aef962e961045a |     2 -
 testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c |     2 -
 testdata/fuzz/FuzzExpr/c6717d9f77902b9c |     2 -
 testdata/fuzz/FuzzExpr/cd662894c578ed90 |     2 -
 testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd |     2 -
 12 files changed, 20415 insertions(+), 71 deletions(-)
 rename test/{playground => }/gen/gen.go (85%)
 create mode 100644 test/gen/gen_test.go
 rename test/{playground => }/gen/utils.go (100%)
 create mode 100644 testdata/examples.txt
 delete mode 100644 testdata/fuzz/FuzzExpr/1fedafb72e35699d
 delete mode 100644 testdata/fuzz/FuzzExpr/37464e3dcb75a05c
 delete mode 100644 testdata/fuzz/FuzzExpr/42564f0e9eda1ad1
 delete mode 100644 testdata/fuzz/FuzzExpr/b1aef962e961045a
 delete mode 100644 testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c
 delete mode 100644 testdata/fuzz/FuzzExpr/c6717d9f77902b9c
 delete mode 100644 testdata/fuzz/FuzzExpr/cd662894c578ed90
 delete mode 100644 testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd

diff --git a/test/playground/gen/gen.go b/test/gen/gen.go
similarity index 85%
rename from test/playground/gen/gen.go
rename to test/gen/gen.go
index 8e0bb17f2..7e1f433ed 100644
--- a/test/playground/gen/gen.go
+++ b/test/gen/gen.go
@@ -3,19 +3,52 @@ package main
 import (
 	"fmt"
 	"math/rand"
+	"runtime/debug"
 
 	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/builtin"
-	"github.com/antonmedv/expr/test/playground"
 )
 
+var env = map[string]interface{}{
+	"a":   1,
+	"b":   2,
+	"f":   0.5,
+	"ok":  true,
+	"s":   "abc",
+	"arr": []int{1, 2, 3},
+	"obj": map[string]interface{}{
+		"a": 1,
+		"b": 2,
+		"obj": map[string]interface{}{
+			"a": 1,
+			"b": 2,
+			"obj": map[string]int{
+				"a": 1,
+				"b": 2,
+			},
+		},
+		"fn":   func(a int) int { return a + 1 },
+		"head": func(xs ...interface{}) interface{} { return xs[0] },
+	},
+	"add": func(a, b int) int { return a + b },
+	"div": func(a, b int) int { return a / b },
+}
+
+var names []string
+
+func init() {
+	for name := range env {
+		names = append(names, name)
+	}
+}
+
 func main() {
 	var code string
 	defer func() {
 		if r := recover(); r != nil {
 			fmt.Printf("==========================\n%s\n==========================\n", code)
-			panic(r)
+			debug.PrintStack()
 		}
 	}()
 
@@ -32,11 +65,11 @@ func main() {
 			{10, 5},
 		})).String()
 
-		program, err := expr.Compile(code, expr.Env(playground.Blog{}))
+		program, err := expr.Compile(code, expr.Env(env))
 		if err != nil {
 			continue
 		}
-		_, err = expr.Run(program, playground.ExampleData())
+		_, err = expr.Run(program, env)
 		if err != nil {
 			continue
 		}
@@ -98,7 +131,7 @@ func integerNode(depth int) ast.Node {
 
 func stringNode(depth int) ast.Node {
 	corpus := []string{
-		"Go", "JavaScript", " ",
+		"a", "b", "c",
 	}
 	return &ast.StringNode{
 		Value: corpus[rand.Intn(len(corpus))],
@@ -112,40 +145,16 @@ func booleanNode(depth int) ast.Node {
 }
 
 func identifierNode(depth int) ast.Node {
-	cases := []string{
-		"Posts",
-		"Authors",
-		"TotalViews",
-	}
-
 	return &ast.IdentifierNode{
-		Value: cases[rand.Intn(len(cases))],
+		Value: names[rand.Intn(len(names))],
 	}
 }
 
 func memberNode(depth int) ast.Node {
 	cases := []string{
-		"Birthday",
-		"Biography",
-		"Website",
-		"ID",
-		"FirstName",
-		"LastName",
-		"Email",
-		"Profile",
-		"ID",
-		"Title",
-		"Content",
-		"PublishDate",
-		"Author",
-		"Comments",
-		"Tags",
-		"Likes",
-		"ID",
-		"AuthorName",
-		"Content",
-		"CommentDate",
-		"Upvotes",
+		"a",
+		"b",
+		"obj",
 	}
 
 	return &ast.MemberNode{
@@ -205,17 +214,8 @@ func binaryNode(depth int) ast.Node {
 
 func methodNode(depth int) ast.Node {
 	cases := []string{
-		"Age",
-		"FullName",
-		"IsAdmin",
-		"Published",
-		"After",
-		"Before",
-		"Compare",
-		"Equal",
-		"IsZero",
-		"Upvoted",
-		"AuthorEmail",
+		"fn",
+		"head",
 	}
 
 	return &ast.MemberNode{
@@ -227,17 +227,8 @@ func methodNode(depth int) ast.Node {
 
 func funcNode(depth int) ast.Node {
 	cases := []string{
-		"RecentPosts",
-		"PopularPosts",
-		"TotalUpvotes",
-		"TotalComments",
-		"Add",
-		"Sub",
-		"Title",
-		"HasTag",
-		"IsAdmin",
-		"IsZero",
-		"WithID",
+		"add",
+		"div",
 	}
 
 	return &ast.IdentifierNode{
diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go
new file mode 100644
index 000000000..fdb061dc8
--- /dev/null
+++ b/test/gen/gen_test.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/antonmedv/expr"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGenerated(t *testing.T) {
+	b, err := os.ReadFile("../../testdata/examples.txt")
+	require.NoError(t, err)
+
+	examples := strings.TrimSpace(string(b))
+	for _, line := range strings.Split(examples, "\n") {
+		t.Run(line, func(t *testing.T) {
+			program, err := expr.Compile(line, expr.Env(env))
+			require.NoError(t, err)
+
+			_, err = expr.Run(program, env)
+			require.NoError(t, err)
+		})
+	}
+}
diff --git a/test/playground/gen/utils.go b/test/gen/utils.go
similarity index 100%
rename from test/playground/gen/utils.go
rename to test/gen/utils.go
diff --git a/testdata/examples.txt b/testdata/examples.txt
new file mode 100644
index 000000000..46e90f47f
--- /dev/null
+++ b/testdata/examples.txt
@@ -0,0 +1,20343 @@
+!!(obj?.head(obj, div) == obj.obj)
+!!false
+!!ok
+!!true
+!("a" != nil)
+!("a" != s)
+!("a" < "b")
+!("a" < s)
+!("a" <= "a")
+!("a" == nil)
+!("a" == s)
+!("a" > s)
+!("a" endsWith "a")
+!("a" endsWith s)
+!("a" in obj)
+!("a" matches s)
+!("a" startsWith "a")
+!("a" startsWith "c")
+!("a" startsWith s)
+!("b" != "b")
+!("b" != s)
+!("b" < "c")
+!("b" < s)
+!("b" <= "c")
+!("b" <= s)
+!("b" > "b")
+!("b" > "c")
+!("b" > s)
+!("b" >= "c")
+!("b" >= s)
+!("b" contains "a")
+!("b" contains "c")
+!("b" contains s)
+!("b" endsWith "a")
+!("b" endsWith "b")
+!("b" in obj)
+!("b" startsWith "c")
+!("c" != "c")
+!("c" != nil)
+!("c" < "b")
+!("c" < s)
+!("c" <= s)
+!("c" == "c")
+!("c" == nil)
+!("c" == s)
+!("c" > s)
+!("c" >= "b")
+!("c" >= s)
+!("c" endsWith "b")
+!("c" endsWith "c")
+!("c" endsWith s)
+!("c" in obj)
+!("c" matches "c")
+!("c" matches s)
+!("c" startsWith "a")
+!("c" startsWith s)
+!(0 != 0)
+!(0 != 1)
+!(0 != a)
+!(0 != f)
+!(0 != nil)
+!(0 < 0)
+!(0 < 0.5)
+!(0 < 2)
+!(0 < a)
+!(0 < b)
+!(0 < f)
+!(0 <= 0)
+!(0 <= 0.5)
+!(0 <= 1)
+!(0 <= a)
+!(0 <= b)
+!(0 <= f)
+!(0 == 0)
+!(0 == 0.5)
+!(0 == 1)
+!(0 == 2)
+!(0 == a)
+!(0 == b)
+!(0 == f)
+!(0 == nil)
+!(0 > 0)
+!(0 > 2)
+!(0 > b)
+!(0 > f)
+!(0 >= 0)
+!(0 >= 0.5)
+!(0 >= 1)
+!(0 >= 2)
+!(0 >= a)
+!(0 >= b)
+!(0 >= f)
+!(0 in arr)
+!(0.5 != 0)
+!(0.5 != 0.5)
+!(0.5 != 2)
+!(0.5 != a)
+!(0.5 != b)
+!(0.5 != f)
+!(0.5 != nil)
+!(0.5 < 0)
+!(0.5 < 2)
+!(0.5 < a)
+!(0.5 < b)
+!(0.5 < f)
+!(0.5 <= 0)
+!(0.5 <= a)
+!(0.5 <= b)
+!(0.5 <= f)
+!(0.5 == 2)
+!(0.5 == a)
+!(0.5 == b)
+!(0.5 == f)
+!(0.5 == nil)
+!(0.5 > 0)
+!(0.5 > 1)
+!(0.5 > 2)
+!(0.5 > a)
+!(0.5 > b)
+!(0.5 > f)
+!(0.5 >= 0)
+!(0.5 >= 0.5)
+!(0.5 >= 1)
+!(0.5 >= a)
+!(0.5 >= b)
+!(0.5 >= f)
+!(1 < 0)
+!(1 < 1)
+!(1 < a)
+!(1 < b)
+!(1 <= 0)
+!(1 <= a)
+!(1 <= b)
+!(1 <= f)
+!(1 == 0)
+!(1 == a)
+!(1 == f)
+!(1 == nil)
+!(1 > a)
+!(1 > b)
+!(1 > f)
+!(1 >= 0)
+!(1 >= 0.5)
+!(1 >= b)
+!(1 in arr)
+!(2 != 0.5)
+!(2 != 2)
+!(2 != a)
+!(2 != b)
+!(2 != f)
+!(2 / a < f)
+!(2 < 0)
+!(2 < 1)
+!(2 < 2)
+!(2 < a)
+!(2 < f)
+!(2 <= 2)
+!(2 <= b)
+!(2 <= f)
+!(2 == 0)
+!(2 == 0.5)
+!(2 == 1)
+!(2 == 2)
+!(2 == a)
+!(2 == b)
+!(2 == f)
+!(2 > 0)
+!(2 > a)
+!(2 > f)
+!(2 >= a)
+!(2 >= b)
+!(2 >= f)
+!(2 in arr)
+!(a != 0.5)
+!(a != 1)
+!(a != 2)
+!(a != a)
+!(a != b)
+!(a != f)
+!(a != nil)
+!(a + 0.5 >= a)
+!(a < 0)
+!(a < 0.5)
+!(a < 2)
+!(a < a)
+!(a < b)
+!(a < div(0, a))
+!(a < f)
+!(a <= 0)
+!(a <= 0.5)
+!(a <= 2)
+!(a <= a)
+!(a <= b)
+!(a <= f)
+!(a == 0)
+!(a == 0.5)
+!(a == 1)
+!(a == 2)
+!(a == a)
+!(a == b)
+!(a == f)
+!(a == nil)
+!(a > 0)
+!(a > 0.5)
+!(a > 1)
+!(a > 2 && div == add)
+!(a > 2)
+!(a > a)
+!(a > b)
+!(a > f)
+!(a >= 0)
+!(a >= 0.5)
+!(a >= 1)
+!(a >= 2)
+!(a >= a)
+!(a >= b)
+!(a >= f)
+!(a in arr)
+!(add != add)
+!(add != div)
+!(add != nil)
+!(add == add)
+!(add == div)
+!(add == nil)
+!(arr != nil)
+!(arr == arr)
+!(arr == nil)
+!(b != 0)
+!(b != 0.5)
+!(b != a)
+!(b != b)
+!(b != f)
+!(b != nil)
+!(b < 0)
+!(b < 0.5 * 0.5)
+!(b < 0.5)
+!(b < 1)
+!(b < a)
+!(b < b)
+!(b < f)
+!(b <= 0)
+!(b <= 1)
+!(b <= a)
+!(b <= b)
+!(b <= f)
+!(b == 0)
+!(b == 0.5)
+!(b == a)
+!(b == b)
+!(b == f)
+!(b == nil)
+!(b == obj.a)
+!(b > 0)
+!(b > 0.5)
+!(b > 1)
+!(b > 2)
+!(b > a)
+!(b > b)
+!(b > f)
+!(b >= 0)
+!(b >= 0.5)
+!(b >= 1)
+!(b >= 2)
+!(b >= a)
+!(b >= b)
+!(b >= f)
+!(b in arr)
+!(div != add)
+!(div != div)
+!(div != nil)
+!(div == add)
+!(div == div)
+!(f != 0)
+!(f != 0.5)
+!(f != 1)
+!(f != 2)
+!(f != a)
+!(f != b)
+!(f != f)
+!(f != nil)
+!(f < 0)
+!(f < 0.5)
+!(f < 1)
+!(f < a)
+!(f < b)
+!(f < f)
+!(f < obj.b)
+!(f <= 0)
+!(f <= 0.5)
+!(f <= 2)
+!(f <= a)
+!(f <= b)
+!(f <= f)
+!(f <= obj.b)
+!(f == 0)
+!(f == 0.5)
+!(f == 1)
+!(f == 2)
+!(f == a)
+!(f == b)
+!(f == f)
+!(f == nil)
+!(f > 0)
+!(f > 0.5)
+!(f > 1)
+!(f > a)
+!(f > b)
+!(f > div(b, a))
+!(f > f)
+!(f >= 0)
+!(f >= 0.5)
+!(f >= 1)
+!(f >= 2)
+!(f >= a)
+!(f >= b)
+!(f >= f)
+!(false != nil)
+!(false != ok)
+!(false != true)
+!(false && false)
+!(false && ok)
+!(false && true)
+!(false == nil)
+!(false and ok)
+!(false or ok)
+!(false || ok)
+!(nil != "a")
+!(nil != "c")
+!(nil != 0)
+!(nil != 0.5)
+!(nil != 2)
+!(nil != a)
+!(nil != add)
+!(nil != arr)
+!(nil != b)
+!(nil != div)
+!(nil != f)
+!(nil != false)
+!(nil != nil)
+!(nil != obj)
+!(nil != ok)
+!(nil != s)
+!(nil != true)
+!(nil == "b")
+!(nil == 0)
+!(nil == 0.5)
+!(nil == 1)
+!(nil == a)
+!(nil == add)
+!(nil == arr)
+!(nil == b)
+!(nil == div)
+!(nil == false)
+!(nil == nil)
+!(nil == obj)
+!(nil == ok)
+!(nil == s)
+!(nil in arr)
+!(nil in obj)
+!(obj != nil)
+!(obj != obj)
+!(obj == nil)
+!(obj == obj)
+!(obj.b == a ** a)
+!(ok != false)
+!(ok != nil)
+!(ok != ok)
+!(ok != true)
+!(ok && false)
+!(ok && ok)
+!(ok && true)
+!(ok == false)
+!(ok == nil)
+!(ok == ok)
+!(ok == true)
+!(ok and false)
+!(ok and ok)
+!(ok and true)
+!(ok or ok)
+!(ok or true)
+!(ok || false)
+!(ok || ok)
+!(ok || true)
+!(s != "b")
+!(s != "c")
+!(s != nil)
+!(s != s)
+!(s < "a")
+!(s < "b")
+!(s < "c")
+!(s < s)
+!(s <= "c")
+!(s <= s)
+!(s == "a")
+!(s == "b")
+!(s == "c")
+!(s == nil)
+!(s == s)
+!(s > "b")
+!(s > s)
+!(s >= "a")
+!(s >= s)
+!(s contains "c")
+!(s contains s)
+!(s endsWith "a")
+!(s endsWith "c")
+!(s endsWith s)
+!(s in obj)
+!(s matches "a")
+!(s matches "b")
+!(s matches s || ok)
+!(s matches s)
+!(s startsWith "a")
+!(s startsWith "b")
+!(s startsWith s)
+!(string(s) startsWith "b" != false)
+!(true != ok)
+!(true != true)
+!(true && false)
+!(true && ok)
+!(true == ok)
+!(true == true)
+!(true and true)
+!(true or ok)
+!(true || false)
+!(true || ok)
+!(true || true)
+!all(arr, 2 != a)
+!all(arr, false)
+!all(arr, ok)
+!all(arr, true)
+!any(arr, false)
+!any(arr, ok)
+!any(arr, true)
+!false && obj != obj.obj
+!false && obj.b
+!false == obj.head(ok)
+!false ? "a" : s
+!false ? "b" : add
+!false ? "b" : f
+!false ? "c" : f
+!false ? 0 : "b"
+!false ? 0 : false
+!false ? 0 : s
+!false ? 2 : false
+!false ? a : add
+!false ? a : false
+!false ? a : s
+!false ? add : ok
+!false ? add : s
+!false ? b : s
+!false ? div : s
+!false ? f : f
+!false ? f : obj.head(obj)
+!false ? false : b
+!false ? nil : "a"
+!false ? nil : f
+!false ? nil : true
+!false ? obj : nil
+!false ? obj : obj
+!false ? ok : obj
+!false ? ok : ok
+!false ? s : add
+!false ? s : nil
+!false ? s : obj?.head(a.head("a"))
+!false ? true : arr
+!false ? true : div
+!false or obj.a
+!false or obj?.fn(obj, div)
+!false or ok
+!fromJSON(string(false))
+!hasSuffix("a", s)
+!none(arr, false)
+!none(arr, ok)
+!none(arr, true)
+!not (a < 0)
+!not (f != 1)
+!not (f == 0)
+!not (s != s)
+!not (s contains s)
+!not false
+!not ok
+!not true
+!obj.head(2 == s)
+!obj.head(add != nil)
+!obj.head(arr != s)
+!obj.head(false == add)
+!obj.head(false)
+!obj.head(ok)
+!obj.head(ok, 1, obj)
+!obj.head(ok, add)
+!obj.head(ok, map("a", 2))
+!obj.head(ok, nil)
+!obj.head(ok, s)
+!obj.head(ok, s, obj, div, s)
+!obj.head(true, 0, arr)
+!obj.head(true, a)
+!obj.head(true, b, nil, f)
+!obj.head(true, s)
+!obj?.head(any(s, true))
+!obj?.head(false)
+!obj?.head(false, "b")
+!obj?.head(false, div, 2, obj)
+!obj?.head(false, true)
+!obj?.head(ok)
+!obj?.head(ok, arr)
+!obj?.head(ok, div, ok)
+!obj?.head(ok, false)
+!obj?.head(ok, nil, "c")
+!obj?.head(ok, ok)
+!obj?.head(ok, s)
+!obj?.head(ok, true, b)
+!obj?.head(true)
+!obj?.head(true, 0)
+!ok
+!ok != (ok or false)
+!ok != ok
+!ok && a == 1
+!ok && obj.b
+!ok && ok
+!ok == ok
+!ok ? "a" : 0.5
+!ok ? "a" : div
+!ok ? "b" : 0
+!ok ? "b" : obj.b
+!ok ? "b" : ok
+!ok ? "c" : 0.5
+!ok ? 0 : add
+!ok ? 0.5 : 0
+!ok ? 0.5 : 0.5
+!ok ? 0.5 : div
+!ok ? 1 : nil
+!ok ? 2 : "b"
+!ok ? a : arr
+!ok ? a : b
+!ok ? a : div
+!ok ? a : s
+!ok ? a : true
+!ok ? add : 1
+!ok ? add : a
+!ok ? add : add
+!ok ? add : f
+!ok ? add : false
+!ok ? add : obj
+!ok ? add : ok
+!ok ? add : s
+!ok ? arr : b
+!ok ? arr == arr : div
+!ok ? b : "a"
+!ok ? b : "b"
+!ok ? b : 1
+!ok ? b : a
+!ok ? b : f
+!ok ? div : a
+!ok ? div : b
+!ok ? div : obj
+!ok ? div : s
+!ok ? f : a
+!ok ? f : div
+!ok ? f : s
+!ok ? false : 0
+!ok ? false : f
+!ok ? nil : div
+!ok ? obj : 1
+!ok ? obj : ok
+!ok ? ok : a
+!ok ? ok : arr
+!ok ? ok : false
+!ok ? ok : nil
+!ok ? ok : ok
+!ok ? s : 0.5
+!ok ? s : obj
+!ok ? true : s
+!ok and a <= b
+!ok and arr == nil
+!ok and obj.a
+!ok and obj.a?.obj
+!ok and obj?.a
+!ok and obj[nil]
+!ok and ok
+!ok or nil != a
+!ok or obj?.a
+!ok or obj?.b
+!ok or ok
+!ok or ok || false
+!ok || nil == s
+!ok || obj.a
+!ok || obj.fn(2)
+!ok || ok
+!one(arr, false)
+!one(arr, ok)
+!true != obj.a
+!true && obj?.obj
+!true && ok == nil
+!true == obj.obj
+!true == obj?.obj
+!true == ok
+!true ? "a" : a
+!true ? "a" : ok
+!true ? 0 : true
+!true ? 0.5 : b
+!true ? 1 : add
+!true ? a : add
+!true ? a : arr
+!true ? add : ok
+!true ? arr : 0.5
+!true ? div : ok
+!true ? div : true
+!true ? f : 0
+!true ? f : f
+!true ? false : b
+!true ? nil : "b"
+!true ? nil : "c"
+!true ? nil : div
+!true ? nil : ok
+!true ? obj : add
+!true ? ok : add
+!true ? ok : obj
+!true ? s : "a"
+!true ? s : false
+!true ? true : a
+!true ? true : f
+!true and f != b
+!true and nil != "a"
+!true and obj.a
+!true and ok
+!true or obj?.head(1, nil, ok, div, arr)
+!true || !true
+"a" != nil or a <= 0
+"a" != obj.a
+"a" != obj.b
+"a" != obj.obj
+"a" != obj.obj.b
+"a" != obj?.a
+"a" != obj?.b
+"a" != obj?.fn(b)
+"a" != obj?.head(add)
+"a" != obj?.head(f == ok)
+"a" != obj?.head(ok and nil)
+"a" != obj?.obj
+"a" < "a" ? obj.fn(true, 2, div, arr) : ok
+"a" < "c" && obj.head(ok)
+"a" < s || ok && false
+"a" <= s && ok
+"a" == "a" || ok
+"a" == nil != ok
+"a" == nil == obj?.head(obj, "c", b, 0, true)
+"a" == obj.a
+"a" == obj.b
+"a" == obj.obj
+"a" == obj?.a
+"a" == obj?.b
+"a" == obj?.head(-0.5)
+"a" == obj?.head(filter("a", false))
+"a" == obj?.obj
+"a" == s && ok
+"a" == s == ok
+"a" == s ? s : f
+"a" > s or obj.fn(b)
+"a" >= "a" && 0 == a
+"a" >= "b" || obj?.head(div, 2, div)
+"a" >= "b" || obj?.obj
+"a" >= obj.head(string(s contains "b"))
+"a" >= obj?.head(s)
+"a" >= s ? s : string(s)
+"a" contains "c" && any(arr, true)
+"a" contains "c" == obj?.a
+"a" contains s and obj?.obj
+"a" contains s and ok
+"a" endsWith s != ok
+"a" endsWith s || obj?.head(div)
+"a" in obj && obj.head(1)
+"a" in obj.obj
+"a" in obj?.obj
+"a" matches "b" || obj?.b
+"a" matches s and obj?.b
+"b" != "b" == true ? b : nil
+"b" != obj.a
+"b" != obj.b
+"b" != obj.head(f)
+"b" != obj.obj
+"b" != obj.obj.a
+"b" != obj.obj?.a
+"b" != obj?.a
+"b" != obj?.b
+"b" != obj?.fn(a)
+"b" != obj?.obj
+"b" != obj?.obj.obj
+"b" != s or ok
+"b" + "a" contains s + s
+"b" + s == obj.a
+"b" + s in obj ? div : f
+"b" < "c" != ok
+"b" < "c" && obj.head(div, b, b)
+"b" < s and obj?.head(div, ok)
+"b" <= "a" and ok
+"b" <= "a" or obj?.a
+"b" <= "b" and nil == ok
+"b" <= obj.head(s)
+"b" == obj.a
+"b" == obj.b
+"b" == obj.obj
+"b" == obj.obj?.obj
+"b" == obj?.a
+"b" == obj?.b
+"b" == obj?.head(div)
+"b" == obj?.obj
+"b" == obj[string(add)]
+"b" == s != obj.b
+"b" == s == obj.obj
+"b" > "b" ? f : obj
+"b" > "b" and !true
+"b" > s && arr != arr
+"b" contains "b" || obj.a
+"b" endsWith "b" || add != obj.a
+"b" in obj.obj
+"b" in obj?.head(obj?.obj)
+"b" in obj?.obj
+"b" matches obj?.head(s)
+"b" startsWith s ? a : s
+"b" startsWith s or ok
+"b" startsWith s || true && false
+"c" != "a" || ok
+"c" != "a" || ok ? add : add
+"c" != "b" && a > a
+"c" != "c" == ok
+"c" != nil || false or ok
+"c" != obj.a
+"c" != obj.b
+"c" != obj.fn(b)
+"c" != obj.obj
+"c" != obj.obj?.b
+"c" != obj?.a
+"c" != obj?.b
+"c" != obj?.head(obj?.obj)
+"c" != obj?.obj
+"c" != obj?.obj.a
+"c" != obj?.obj?.b
+"c" != s != ok
+"c" + s matches s
+"c" < "b" != ok
+"c" < s == obj.obj
+"c" < s ? add : min(0.5)
+"c" < s || obj?.fn(b)
+"c" == obj.a
+"c" == obj.b
+"c" == obj.head(0 ^ b)
+"c" == obj.obj
+"c" == obj.obj?.b
+"c" == obj?.a
+"c" == obj?.b
+"c" == obj?.obj
+"c" == s and "c" < "b"
+"c" == s || false != nil
+"c" > "a" && obj.b
+"c" > "c" and obj?.b
+"c" > s ? obj : s
+"c" >= "b" or obj.fn("c")
+"c" >= s ? arr : obj.b
+"c" contains "c" || 1 >= a
+"c" contains s && obj?.obj.a
+"c" endsWith s == obj?.obj
+"c" endsWith s or s < s
+"c" endsWith s || ok
+"c" in obj or obj?.obj
+"c" in obj || true ? b : div
+"c" in obj.head(arr)
+"c" in obj.obj
+"c" in obj?.obj
+"c" matches s && obj?.obj
+"c" matches s ? div : add
+"c" startsWith "c" && ok
+"c" startsWith "c" ? s : ok
+"c" startsWith s and nil != 1
+(0 % a) ^ (a * f)
+(0 * 0) ^ f
+(0 * 2) ^ obj?.head(1, "b", s, a, s)
+(0 * f) ^ f
+(0 + 0) ^ obj?.a
+(0 + 0.5) ^ (a - b)
+(0 + 1) ^ a ^ f
+(0 + 2) ^ (a - f)
+(0 + a) % a
+(0 + a) ^ a
+(0 + b) ** b
+(0 + f) * f
+(0 + f) / b
+(0 + f) / obj.b
+(0 + f) ^ f
+(0 - 0) * f
+(0 - 0) ^ (f * b)
+(0 - a) * a
+(0 - a) ^ a
+(0 - b) / 0.5 ** f
+(0 - b) / a
+(0 - b) ^ f
+(0 - f) * max(0)
+(0 / 0) ^ f
+(0 / 2) ^ obj?.b
+(0.5 * 0) ** (0 * 2)
+(0.5 * a) ** a
+(0.5 * b) ^ obj.a
+(0.5 * f) ** f
+(0.5 + a) / f
+(0.5 + b) ** b
+(0.5 + b) ^ obj.b
+(0.5 - f) / b
+(0.5 / a) ^ a
+(0.5 / f) ** max(0.5)
+(0.5 / f) ^ obj?.a
+(1 % a) ^ obj.head(2)
+(1 * a) ^ a
+(1 - 0) / f
+(1 - 2) ** (a * a)
+(1 - b) ^ min(0)
+(1 - f) / a
+(1 - f) ^ b
+(1 / 0) ** obj?.a
+(1 / 0) ^ f
+(1 / 0.5 + f) * f
+(1 / b) ^ f
+(1 / f) ** a
+(1 / f) ** b
+(2 % a) ** f
+(2 % a) ^ -b
+(2 % b) ** b
+(2 % b) ** f
+(2 % b) ** obj?.head(f, add, ok, false)
+(2 * a) ^ b
+(2 + 0) ** a
+(2 + 0.5) / min(f)
+(2 + 2) ^ len(s) * f
+(2 + f) * a ** 0
+(2 + f) ** b
+(2 - 2) ** -0
+(2 - 2) ** b
+(2 - 2) / f
+(2 - a) ^ a
+(2 - a) ^ add(0, a)
+(2 - f) / obj.a
+(2 / f) ** (a - f)
+(2 / f) ^ f == b
+(2 / f) ^ obj.a
+(a % 2) ^ b
+(a % a) ** obj.head(b, b)
+(a * a) ** f
+(a * a) ** obj.b
+(a * f) ^ a
+(a * f) ^ f ** a
+(a + 0) % a
+(a + 0) / obj.b
+(a + a) % obj?.a
+(a + a) / b
+(a + b) % a
+(a + b) % add(a, b)
+(a - 0) / a
+(a - 0) / b
+(a - 0) ^ int(b)
+(a - 0.5) / (0.5 + 0)
+(a - 0.5) / obj.head(a)
+(a - 0.5) / obj?.b
+(a - 0.5) ^ b
+(a - 1) ^ f
+(a - 2) % a
+(a - a) % b
+(a - b) * b
+(a - b) ** a ** 0
+(a - b) ^ f
+(a - f) * b
+(a - f) * f
+(a - f) * obj.head(f)
+(a - f) ^ a
+(a / 1) ** f
+(a / b) ^ f
+(a / f) ** a
+(a / f) ^ b
+(a / f) ^ min(0)
+(b % 2) ** b
+(b % 2) ^ add(b, b)
+(b % a) ^ b
+(b * 0) ** a
+(b * 0) ** f
+(b * a) ** a
+(b * b) ^ a ** 0
+(b * f) ^ float(a)
+(b + 0) * div(b, b)
+(b + 0) / b
+(b + 0.5) ** f
+(b + 2) % b
+(b + 2) ** f
+(b + a) ** f
+(b + b) * a
+(b + b) ^ b
+(b + b) ^ obj?.b
+(b + f) / b
+(b + f) ^ a
+(b - 0) * b
+(b - 0) / b != f
+(b - 1) * obj?.b
+(b - 1) / a
+(b - a) ** obj.a
+(b - a) / a
+(b - b) * b
+(b - f) * f
+(b - f) ** b
+(b - f) ^ (a - 1)
+(b / 0) ^ f
+(b / 1) ** b
+(b / a) ^ (b / 1)
+(b / a) ^ obj?.obj.obj?.b
+(b / b) ** f
+(f * 0.5) ** obj?.a
+(f * a) ** obj.fn(1)
+(f * b) ** f
+(f * b) ^ f
+(f * f) ** a ** a
+(f * f) ** b
+(f * f) ** f
+(f * f) ^ b
+(f + 0) * b ^ b
+(f + 0) ** f
+(f + 0.5) ^ f
+(f + a) * a
+(f + a) ** f
+(f + a) ** obj?.a
+(f + b) * f
+(f + b) ** add(2, b)
+(f + b) ** obj.b
+(f + f) * b
+(f + f) ** arr[2]
+(f + f) / b
+(f + f) ^ (1 / 2)
+(f + f) ^ arr[a]
+(f + f) ^ b
+(f + f) ^ f
+(f - 0) ** obj?.fn(b)
+(f - 0) / a
+(f - 0) ^ (f / 0.5)
+(f - 0) ^ a
+(f - 0.5) * f
+(f - 0.5) / f
+(f - 0.5) ^ a
+(f - 2) * a
+(f - a) * -a
+(f - a) ** b ^ f
+(f - a) / add(a, b)
+(f - b) ** b
+(f / a) ^ f
+(f / a) ^ obj.b
+(f / b) ** b
+(false or false) != obj?.b
+(false or false) and s >= "b"
+(false or true) != obj.head(add)
+(false || true) == obj?.b
+(min(f, f) / b) ** (b % obj?.b)
+(ok ? true : 0) ? div : arr
+(ok ? true : 0) ? obj?.b : (true ? false : true)
+(ok and ok) != ok
+(ok or false) and false ? 2 : div
+(ok or ok) == obj?.a
+(ok or ok) == ok
+(ok or ok) and obj.obj?.a
+(ok or true) and ok
+(ok || ok) == ok
+(ok || ok) and obj.obj
+(ok || ok) and ok
+(true and true) != obj.a
+(true or ok) != ok
+(true || false) and a == 0.5
+(true || ok) == obj.a
+(true || true) != a + obj?.b
+-((f - 1) ** len(s))
+-(0 % 1)
+-(0 % 2)
+-(0 % a)
+-(0 % b)
+-(0 * 0)
+-(0 * b)
+-(0 * f * obj?.b)
+-(0 * f)
+-(0 ** 0)
+-(0 ** a)
+-(0 ** b)
+-(0 ** f)
+-(0 + 0)
+-(0 + 0.5)
+-(0 + 1)
+-(0 + 2)
+-(0 + a)
+-(0 + f)
+-(0 - 0)
+-(0 - 0.5)
+-(0 - 1)
+-(0 - 2)
+-(0 - a)
+-(0 - b)
+-(0 - f)
+-(0 / 0)
+-(0 / 0.5)
+-(0 / 2)
+-(0 / a)
+-(0 / b)
+-(0 / f)
+-(0 ^ 0)
+-(0 ^ 0.5)
+-(0 ^ 2)
+-(0 ^ a)
+-(0 ^ b)
+-(0 ^ f)
+-(0.5 * 0.5)
+-(0.5 * 2)
+-(0.5 * a)
+-(0.5 * b)
+-(0.5 * f)
+-(0.5 ** 0)
+-(0.5 ** 0.5)
+-(0.5 ** a)
+-(0.5 ** b)
+-(0.5 ** f)
+-(0.5 + 0)
+-(0.5 + 1)
+-(0.5 + 2)
+-(0.5 + a)
+-(0.5 + b)
+-(0.5 + f)
+-(0.5 - 0)
+-(0.5 - 0.5)
+-(0.5 - 1)
+-(0.5 - 2)
+-(0.5 - a)
+-(0.5 - b)
+-(0.5 - f)
+-(0.5 / 0)
+-(0.5 / 2)
+-(0.5 / a)
+-(0.5 / b)
+-(0.5 / f)
+-(0.5 ^ 0.5)
+-(0.5 ^ 2)
+-(0.5 ^ a)
+-(0.5 ^ b)
+-(1 % 2)
+-(1 % a)
+-(1 % b)
+-(1 * 0)
+-(1 * 1)
+-(1 * a)
+-(1 ** a)
+-(1 ** f)
+-(1 + 1)
+-(1 + a)
+-(1 + b)
+-(1 - 0)
+-(1 - 0.5) / a
+-(1 - a)
+-(1 - b)
+-(1 - f)
+-(1 / 0)
+-(1 / 0.5)
+-(1 / 2)
+-(1 / f)
+-(1 ^ 0.5)
+-(1 ^ b)
+-(1 ^ f)
+-(2 % a)
+-(2 % b)
+-(2 * 0)
+-(2 * 2)
+-(2 * b)
+-(2 * f)
+-(2 ** b)
+-(2 + 0.5)
+-(2 + a)
+-(2 + b)
+-(2 + f)
+-(2 - 0.5)
+-(2 - 2)
+-(2 - b)
+-(2 / 0)
+-(2 / 0.5)
+-(2 / a)
+-(2 ^ 1)
+-(2 ^ 2)
+-(2 ^ a)
+-(a % 1)
+-(a % 2)
+-(a % a)
+-(a % b)
+-(a * 0)
+-(a * 1)
+-(a * 2)
+-(a * a)
+-(a * b)
+-(a * f)
+-(a ** 0)
+-(a ** 0.5)
+-(a ** a)
+-(a ** b)
+-(a ** f)
+-(a + 0)
+-(a + 1)
+-(a + 2)
+-(a + a)
+-(a + b)
+-(a + f)
+-(a - 0)
+-(a - 1)
+-(a - 2)
+-(a - a)
+-(a - b)
+-(a - f)
+-(a / 0)
+-(a / 0.5)
+-(a / 1)
+-(a / 2)
+-(a / a)
+-(a / b)
+-(a ^ 0)
+-(a ^ 0.5)
+-(a ^ 2)
+-(a ^ a)
+-(a ^ b)
+-(a ^ f)
+-(b % 1)
+-(b % a)
+-(b % b)
+-(b % obj.a)
+-(b * 0)
+-(b * 0.5)
+-(b * 1)
+-(b * 2)
+-(b * a)
+-(b * b)
+-(b * f)
+-(b ** 0)
+-(b ** 0.5)
+-(b ** 1)
+-(b ** a)
+-(b ** b)
+-(b ** f)
+-(b + 0)
+-(b + 1)
+-(b + 2)
+-(b + a)
+-(b + b)
+-(b + f)
+-(b - 0.5)
+-(b - 1)
+-(b - 2)
+-(b - 2) - b
+-(b - a)
+-(b - b)
+-(b - f)
+-(b / 0)
+-(b / 0.5)
+-(b / 1)
+-(b / 2)
+-(b / a)
+-(b / b)
+-(b / f)
+-(b ^ 0)
+-(b ^ 0.5)
+-(b ^ 1)
+-(b ^ 2)
+-(b ^ a)
+-(b ^ b)
+-(b ^ f)
+-(f * 0)
+-(f * 0.5)
+-(f * 1)
+-(f * 2)
+-(f * a)
+-(f * b)
+-(f * f)
+-(f * int(a))
+-(f ** 0)
+-(f ** 0.5)
+-(f ** 1)
+-(f ** a)
+-(f ** b)
+-(f ** f)
+-(f + 2)
+-(f + a)
+-(f + b)
+-(f + f)
+-(f + f) - b
+-(f - 0)
+-(f - 1)
+-(f - 2)
+-(f - a)
+-(f - b)
+-(f - f)
+-(f - obj.a)
+-(f / 0)
+-(f / 0.5)
+-(f / a)
+-(f / b)
+-(f / f)
+-(f ^ 0)
+-(f ^ 0.5)
+-(f ^ 1)
+-(f ^ 2)
+-(f ^ a)
+-(f ^ b)
+-(f ^ f)
+-(obj.fn(b) + b)
+-(obj.head(1) - a)
+-(obj.head(b, 2, f, nil) / obj.a)
+--(a % b)
+--(f ** a)
+--0
+--0.5
+--1
+--2
+--a
+--abs(b)
+--b
+--f
+--int(0.5)
+--obj.a
+--obj.b
+--obj.b % b
+-0 != a ? ok : 0
+-0 != b
+-0 != f
+-0 != obj.b
+-0 % a
+-0 * obj.fn(2)
+-0 ** a
+-0 ** b
+-0 - a
+-0 - abs(2)
+-0 - div(a, a)
+-0 - obj.a
+-0 - obj.b
+-0 .. 1 * a
+-0 .. obj.b
+-0 / b
+-0 / obj.a
+-0 / obj.head(1, a)
+-0 / obj?.a
+-0 < a
+-0 < b
+-0 < f
+-0 <= a
+-0 <= f
+-0 == a
+-0 == b / 0
+-0 == nil ? b : obj
+-0 > b * f
+-0 > f
+-0 >= -0
+-0 >= a
+-0 >= obj?.b
+-0 ^ -0
+-0 ^ a
+-0 ^ b
+-0 ^ f
+-0 in arr
+-0.5 != 0.5 ? s : b
+-0.5 != a
+-0.5 != nil ? false : nil
+-0.5 * obj?.b
+-0.5 + b
+-0.5 - add(0, a)
+-0.5 - f
+-0.5 / a
+-0.5 / obj?.fn(a)
+-0.5 < f
+-0.5 <= f ? f : add
+-0.5 == 0 % b
+-0.5 >= 0 == ok
+-0.5 >= obj.b
+-0.5 ^ (a / b)
+-1 % a
+-1 * -b
+-1 ** b
+-1 ** obj.b
+-1 + b
+-1 - b
+-1 - f
+-1 .. obj?.a
+-1 / b
+-1 > 2 != nil
+-1 > a
+-1 > b
+-1 > obj?.b
+-1 >= f ? arr : div
+-1 ^ (f / a)
+-1 ^ b
+-1 ^ obj.head(a)
+-2 != b
+-2 != f
+-2 * f
+-2 ** f
+-2 ** min(0, f)
+-2 - 0.5 ^ 0
+-2 .. -b
+-2 .. a
+-2 < abs(1)
+-2 < f ** a
+-2 < obj.b
+-2 == obj?.b
+-2 ^ a
+-2 ^ b
+-2 ^ f
+-a
+-a != f
+-a != obj.fn(a)
+-a != obj.obj?.a
+-a % int(a)
+-a * b
+-a * obj.a
+-a ** a
+-a ** f
+-a ** float(2)
+-a ** max(a)
+-a + b
+-a + obj.b
+-a - f
+-a .. a
+-a .. obj.a
+-a / f
+-a / max(0.5)
+-a < f
+-a < obj?.a
+-a <= a ** b
+-a == 0 + b
+-a == a
+-a > add(a, a)
+-a > b
+-a > get(arr, 1)
+-a > obj.b
+-a >= a - 0
+-a >= obj?.b
+-a ^ a
+-a ^ f
+-abs(0)
+-abs(0.5)
+-abs(1)
+-abs(2 / f)
+-abs(2)
+-abs(a)
+-abs(b)
+-abs(f)
+-add(0, 0)
+-add(0, 2)
+-add(0, a)
+-add(0, b)
+-add(1, 0)
+-add(1, 1)
+-add(1, 2)
+-add(1, a)
+-add(1, b)
+-add(2, 0)
+-add(a, 0)
+-add(a, 2)
+-add(a, a)
+-add(a, b)
+-add(b, 0)
+-add(b, 1)
+-add(b, 2)
+-add(b, a)
+-add(b, b)
+-add(b, ok ? a : "b")
+-arr[0]
+-arr[1]
+-arr[2]
+-arr[a]
+-arr[b]
+-b
+-b != a
+-b != b
+-b != f
+-b != obj.a
+-b % b
+-b % b % obj.b
+-b % obj.b
+-b % obj.fn(a)
+-b * a
+-b * b
+-b ** a
+-b + a
+-b + obj?.b
+-b - a
+-b - b
+-b - f
+-b - obj.a
+-b .. b
+-b / a ^ 0.5
+-b / b
+-b / obj?.a
+-b < 2 / 0
+-b < b
+-b < f
+-b <= f
+-b <= obj?.a
+-b <= obj?.b
+-b == int(0)
+-b == len("b")
+-b == max(0)
+-b > a
+-b > a * 0.5
+-b > b
+-b > b ? b : 1
+-b > div(2, b)
+-b > obj.b
+-b >= a
+-b >= b
+-b >= f
+-b >= f ? b : true
+-b >= obj.head(a)
+-b ^ (b - 0.5)
+-b ^ a
+-count(arr, false)
+-count(arr, ok)
+-count(arr, true)
+-div(0, 2)
+-div(0, a)
+-div(0, b)
+-div(1, 1)
+-div(1, 2)
+-div(1, b)
+-div(2, 1)
+-div(2, 1) / a
+-div(2, a)
+-div(2, b)
+-div(a, 1)
+-div(a, 2)
+-div(a, a)
+-div(a, b)
+-div(a, obj.a)
+-div(b, 1)
+-div(b, a)
+-div(b, b)
+-f
+-f != a
+-f != f
+-f != f != true
+-f != len(s)
+-f != obj.b
+-f != obj.fn(b)
+-f * a
+-f * b ^ a
+-f ** -a
+-f ** b
+-f + a
+-f + b
+-f + f
+-f + int(b)
+-f + obj.a
+-f - a * 1
+-f - arr[b]
+-f - b
+-f - f
+-f / add(a, b)
+-f / b
+-f / f
+-f / f ^ b
+-f < a
+-f < f ? ok : b
+-f < f ^ b
+-f < obj.a
+-f <= a
+-f <= f
+-f == add(0, b)
+-f == f
+-f == obj.obj
+-f == obj?.obj
+-f > a
+-f > f / a
+-f > len(s)
+-f > obj.a
+-f >= 0 / b
+-f >= a
+-f >= a * a
+-f >= b
+-f >= obj.a
+-f ^ a
+-f ^ a ** f
+-f ^ f
+-first(arr)
+-first(arr) < f
+-first(arr) ^ a
+-float(0)
+-float(0.5)
+-float(2)
+-float(a)
+-float(b)
+-float(f)
+-get(arr, 0)
+-get(arr, 1)
+-get(arr, 2)
+-get(arr, a)
+-get(arr, b)
+-indexOf(s, "c")
+-indexOf(s, s)
+-int(0)
+-int(0.5)
+-int(1)
+-int(2)
+-int(a)
+-int(b)
+-int(f)
+-int(obj?.a)
+-last(arr)
+-len("b")
+-len(arr)
+-len(map(arr, obj))
+-len(obj)
+-len(s)
+-max(0)
+-max(0.5)
+-max(0.5, f)
+-max(1)
+-max(1, 2)
+-max(1, a)
+-max(2)
+-max(a)
+-max(a, f)
+-max(b)
+-max(b, 0, f)
+-max(f)
+-max(f, b)
+-min(0)
+-min(0, b)
+-min(0.5, b)
+-min(1)
+-min(2)
+-min(a)
+-min(a, b)
+-min(b)
+-min(b, 1)
+-min(f)
+-min(f, 0)
+-obj.a
+-obj.a > f
+-obj.a ^ b
+-obj.b
+-obj.fn(0)
+-obj.fn(1)
+-obj.fn(2)
+-obj.fn(a - b)
+-obj.fn(a)
+-obj.fn(b)
+-obj.fn(count("c", true))
+-obj.head(0)
+-obj.head(0, arr)
+-obj.head(0, obj)
+-obj.head(0, s)
+-obj.head(0.5)
+-obj.head(0.5, add)
+-obj.head(0.5, b, add)
+-obj.head(0.5, div, ok)
+-obj.head(0.5, f)
+-obj.head(0.5, true)
+-obj.head(1)
+-obj.head(1, "a", nil)
+-obj.head(1, f)
+-obj.head(1, ok, arr)
+-obj.head(2)
+-obj.head(2, 1, b)
+-obj.head(2, arr)
+-obj.head(2, ok, 2)
+-obj.head(a)
+-obj.head(a, div, "a", b)
+-obj.head(a, f, add, "a")
+-obj.head(a, nil)
+-obj.head(a, true, obj)
+-obj.head(b)
+-obj.head(b, "b", s, ok)
+-obj.head(b, add)
+-obj.head(b, b, ok, obj)
+-obj.head(b, f)
+-obj.head(b, nil, add, ok)
+-obj.head(b, nil, f)
+-obj.head(b, nil, true)
+-obj.head(f)
+-obj.head(f, 0, add)
+-obj.head(f, b)
+-obj.head(f, ok)
+-obj.head(first("a"))
+-obj.head(obj, 0.5)?.b
+-obj.obj.a
+-obj.obj.b
+-obj.obj.obj?.a
+-obj.obj.obj?.b
+-obj.obj?.a
+-obj.obj?.b
+-obj.obj?.obj?.obj
+-obj?.a
+-obj?.a != a
+-obj?.a > b
+-obj?.b
+-obj?.fn(0)
+-obj?.fn(1)
+-obj?.fn(2)
+-obj?.fn(a)
+-obj?.fn(b)
+-obj?.head(0)
+-obj?.head(0, 0.5, s)
+-obj?.head(0, 2)
+-obj?.head(0, add)
+-obj?.head(0, b)
+-obj?.head(0, nil)
+-obj?.head(0, nil, obj, obj, 2)
+-obj?.head(0, obj, ok, nil)
+-obj?.head(0, s)
+-obj?.head(0.5)
+-obj?.head(0.5, a)
+-obj?.head(0.5, add)
+-obj?.head(0.5, f, arr)
+-obj?.head(0.5, obj)
+-obj?.head(1)
+-obj?.head(2)
+-obj?.head(a)
+-obj?.head(a, "c", "a")
+-obj?.head(a, 0, f, b, a)
+-obj?.head(a, 1, a)
+-obj?.head(a, a)
+-obj?.head(a, obj, obj)
+-obj?.head(a, ok, b)
+-obj?.head(a, s)
+-obj?.head(b)
+-obj?.head(b, 0)
+-obj?.head(b, 0, obj)
+-obj?.head(b, 0.5, arr)
+-obj?.head(b, 1)
+-obj?.head(b, false, add)
+-obj?.head(b, nil)
+-obj?.head(b, ok)
+-obj?.head(f)
+-obj?.head(f, add, ok)
+-obj?.head(f, obj)
+-obj?.head(f, obj, 0)
+-obj?.head(f, ok)
+-obj?.head(f, true, nil)
+-obj?.head(min(nil, 2, a), a)
+-obj?.obj.a
+-obj?.obj.b
+-obj?.obj?.a
+-obj?.obj?.b
+-obj?.obj?.obj.b
+-obj?.obj?.obj?.obj
+0 != 0.5 == obj?.head(a)
+0 != 0.5 ? s <= s : obj?.head(false)
+0 != 2 && s != "c"
+0 != a || a != f
+0 != arr[b]
+0 != arr[obj.a]
+0 != b and f != 0
+0 != b and obj.head(b, "b", div)
+0 != b || obj.b
+0 != b || obj.obj
+0 != f or 0.5 == 1
+0 != nil and obj?.b
+0 != obj.a
+0 != obj.a % a
+0 != obj.b
+0 != obj.head(arr)
+0 != obj.head(obj)
+0 != obj.obj
+0 != obj.obj?.a
+0 != obj.obj?.obj
+0 != obj.obj?.obj?.b
+0 != obj?.a
+0 != obj?.b
+0 != obj?.b ^ b
+0 != obj?.head(b)
+0 != obj?.head(ok, a)
+0 != obj?.obj
+0 != obj?.obj.a
+0 % 1 - obj.b
+0 % 1 < b ^ 0
+0 % 1 == f
+0 % 1 >= obj.a
+0 % a - b
+0 % a < a
+0 % a <= a * f
+0 % arr[b]
+0 % b != f
+0 % b % div(b, b)
+0 % b * a
+0 % b * f
+0 % b + add(a, a)
+0 % b + b
+0 % b + obj?.a
+0 % b / b / 0.5
+0 % b == obj.head(s, 0)
+0 % b >= a
+0 % obj.a
+0 % obj.b
+0 % obj?.a
+0 % obj?.b
+0 % obj?.fn(b)
+0 % obj?.head(b)
+0 % obj?.obj.b
+0 * 0 / b
+0 * 0 < f
+0 * 0 <= a
+0 * 0 <= obj.a
+0 * 0 == a
+0 * 0 >= a
+0 * 0.5 + a
+0 * 0.5 / b
+0 * 0.5 < b
+0 * 0.5 <= int(a)
+0 * 0.5 >= max(0)
+0 * 1 < 0 - a
+0 * 1 == a
+0 * 1 > f
+0 * a + obj?.b
+0 * a / f
+0 * a == f ** 0
+0 * a == obj[s]
+0 * a > f
+0 * a in arr
+0 * arr[0 - 0]
+0 * arr[b]
+0 * b != f
+0 * b * f
+0 * b + f
+0 * b + obj?.a
+0 * b < obj.b
+0 * b == b
+0 * f != a
+0 * f != a % 1
+0 * f != f
+0 * f * b
+0 * f + b
+0 * f - b
+0 * f < obj?.b
+0 * f < obj?.head(f, obj)
+0 * f <= b + 0
+0 * f <= obj.a
+0 * f >= b ^ 2
+0 * obj.a
+0 * obj.b
+0 * obj.head(b + f)
+0 * obj?.a
+0 * obj?.b
+0 * obj?.fn(abs(obj.b))
+0 ** 0 - f
+0 ** 0 <= f != ok
+0 ** 0 ^ a
+0 ** 0.5 + a
+0 ** 0.5 - b
+0 ** 0.5 <= a
+0 ** 0.5 <= f
+0 ** 0.5 <= obj.fn(a)
+0 ** 0.5 ^ (b - 0)
+0 ** 1 * add(0, a)
+0 ** 1 > b
+0 ** 2 * f
+0 ** 2 * obj?.b
+0 ** 2 <= a ? true : div
+0 ** 2 > b
+0 ** a * -2
+0 ** a == b
+0 ** a ^ (0 % 2)
+0 ** b != f
+0 ** b - b ^ 2
+0 ** b > f ? s : add
+0 ** f * obj?.b
+0 ** f + b
+0 ** f > f
+0 ** f >= f
+0 ** obj.a
+0 ** obj.b
+0 ** obj?.a
+0 ** obj?.b
+0 ** obj?.head(b)
+0 + 0 == obj?.a
+0 + 0.5 == obj?.head(nil, true, b, arr)
+0 + 2 < f
+0 + a != f
+0 + a + b
+0 + a .. a
+0 + a .. get(arr, 0)
+0 + a > b
+0 + b + a
+0 + b < a
+0 + b == f * f
+0 + f - b
+0 + f < obj.a
+0 + f < obj.b
+0 + f > b
+0 + f >= a
+0 + obj.a
+0 + obj.a != div
+0 + obj.b
+0 + obj.b == s
+0 + obj.obj?.b
+0 + obj?.a
+0 + obj?.b
+0 - 0 .. obj?.a
+0 - 0 in arr
+0 - 0.5 != obj.b
+0 - 0.5 >= obj.a
+0 - 1 + a
+0 - 1 + b
+0 - 1 > obj.head(f, a)
+0 - a - a
+0 - a .. a
+0 - a < a
+0 - a <= a
+0 - a > a
+0 - a >= a
+0 - b .. obj?.b
+0 - b < 0 / 2
+0 - b < a
+0 - b < obj.a
+0 - b <= a
+0 - b >= b
+0 - b in arr
+0 - f != 0.5 == false
+0 - f + div(b, a)
+0 - f < a
+0 - f <= b
+0 - obj.a
+0 - obj.b
+0 - obj.obj.b
+0 - obj?.a
+0 - obj?.b
+0 .. b != arr
+0 .. obj.a
+0 .. obj.b
+0 .. obj.fn(a)
+0 .. obj.obj.a
+0 .. obj?.a
+0 .. obj?.b
+0 .. obj?.obj.a
+0 / 0 - f
+0 / 0 > f ? arr : b
+0 / 0.5 - a
+0 / 1 / abs(0)
+0 / 1 > b
+0 / 2 <= b
+0 / a != f / f
+0 / arr[a]
+0 / arr[b]
+0 / b != f + 2
+0 / b * obj.b
+0 / b / a
+0 / b == obj?.a
+0 / b >= f
+0 / f / f
+0 / f == b
+0 / obj.a
+0 / obj.b
+0 / obj.head(min(a), arr in arr)
+0 / obj?.a
+0 / obj?.b
+0 / obj?.fn(true and 2)
+0 / obj?.obj?.a
+0 < 0 && obj?.obj
+0 < 0 and obj?.fn(s, arr).b
+0 < 0.5 == ok
+0 < 1 || !ok
+0 < a && "c" in obj
+0 < arr[a]
+0 < b != obj?.b
+0 < b && 2 <= b
+0 < f && ok
+0 < f && true ? nil : 1
+0 < f or a in arr
+0 < obj.a
+0 < obj.b
+0 < obj.obj?.a
+0 < obj?.a
+0 < obj?.b
+0 <= 0 and obj.a
+0 <= 0 or obj?.b
+0 <= 0.5 != obj?.obj
+0 <= 0.5 and one(arr, true)
+0 <= 1 and 0 >= f
+0 <= a == none(arr, false)
+0 <= a || ok ? f : obj
+0 <= b ? a <= a : f
+0 <= obj.a
+0 <= obj.b
+0 <= obj?.a
+0 <= obj?.b
+0 <= obj?.obj.b
+0 <= obj?.obj?.b
+0 == 0 and div == nil
+0 == 2 or ok
+0 == a != ok
+0 == b or ok
+0 == b || ok
+0 == f == !true
+0 == f and obj?.a
+0 == nil or one(arr, true)
+0 == nil || obj.b
+0 == obj.a
+0 == obj.b
+0 == obj.obj
+0 == obj.obj.a
+0 == obj?.a
+0 == obj?.b
+0 == obj?.head(!(obj != div))
+0 == obj?.head(arr)
+0 == obj?.head(obj)
+0 == obj?.obj
+0 == obj?.obj.b
+0 == obj[toJSON(nil)]
+0 > 0 != nil == ok
+0 > 0.5 ? add : ok
+0 > 1 ? s : s
+0 > 2 && ok
+0 > a || 0 != 2
+0 > b != obj.a
+0 > b && "b" == s
+0 > b == ok
+0 > b or 0 == nil
+0 > f && 0 != b
+0 > f && obj.head(s)
+0 > obj.a
+0 > obj.b
+0 > obj.fn(obj?.b)
+0 > obj?.a
+0 > obj?.b
+0 > obj?.fn(a)
+0 > obj?.head(b)
+0 > obj?.obj.a
+0 >= 0.5 and ok ? arr : s
+0 >= 2 && obj?.a
+0 >= b != ok ? b : nil
+0 >= b && obj?.fn(true)
+0 >= b == obj?.head(b, s)
+0 >= b and b in obj?.obj
+0 >= f && obj.head(obj)
+0 >= f or ok
+0 >= obj.a
+0 >= obj.b
+0 >= obj.head(obj?.fn(b))
+0 >= obj?.a
+0 >= obj?.b
+0 >= obj?.obj.b
+0 >= obj?.obj?.a
+0 ^ 0 / f
+0 ^ 0 == f
+0 ^ 0.5 ** obj?.a
+0 ^ 0.5 - b
+0 ^ 0.5 <= f
+0 ^ 1 * a
+0 ^ 2 < a / b
+0 ^ 2 < f
+0 ^ 2 ^ f
+0 ^ a != a / a
+0 ^ a + b
+0 ^ a - obj.a
+0 ^ a - obj?.b
+0 ^ a < a
+0 ^ a <= b
+0 ^ b != b
+0 ^ b - -b
+0 ^ b / b
+0 ^ b >= b
+0 ^ b ^ f
+0 ^ f < obj.b
+0 ^ f <= obj?.a
+0 ^ f > f
+0 ^ obj.a
+0 ^ obj.b
+0 ^ obj.obj.b
+0 ^ obj.obj?.a
+0 ^ obj?.a
+0 ^ obj?.b
+0 in arr or s != nil
+0 in arr || ok
+0.5 != 0 == ok
+0.5 != 0 and ok
+0.5 != 0 || obj?.a
+0.5 != 0.5 == true ? a : arr
+0.5 != 0.5 || nil != s
+0.5 != 1 && s <= "b"
+0.5 != a || obj?.obj
+0.5 != b and false ? nil : add
+0.5 != b or ok
+0.5 != f and ok
+0.5 != nil && s >= s
+0.5 != obj.a
+0.5 != obj.b
+0.5 != obj.obj
+0.5 != obj.obj.obj
+0.5 != obj?.a
+0.5 != obj?.b
+0.5 != obj?.head(arr, obj)
+0.5 != obj?.obj
+0.5 != obj?.obj.b
+0.5 * 0 >= obj.head(a)
+0.5 * 0.5 * f
+0.5 * 0.5 / add(b, 0)
+0.5 * 0.5 < f ? obj : obj
+0.5 * 1 < f
+0.5 * a < f
+0.5 * a == f
+0.5 * a >= 0.5 ? "b" : b
+0.5 * arr[a]
+0.5 * b <= f
+0.5 * f < div(b, b)
+0.5 * f > div(a, b)
+0.5 * f > f
+0.5 * obj.a
+0.5 * obj.b
+0.5 * obj.fn(b)
+0.5 * obj.obj?.a
+0.5 * obj?.a
+0.5 * obj?.b
+0.5 * obj?.head(obj.a)
+0.5 * obj?.obj?.b
+0.5 ** 0 / a
+0.5 ** 0 <= b
+0.5 ** 0 ^ a
+0.5 ** 0.5 > f
+0.5 ** 0.5 >= f
+0.5 ** 1 != b
+0.5 ** 1 > b
+0.5 ** a + b
+0.5 ** a > b
+0.5 ** a > b ** 0
+0.5 ** a >= b
+0.5 ** a ^ obj?.b
+0.5 ** arr[b]
+0.5 ** arr[obj.a]
+0.5 ** b < a + b
+0.5 ** b > a
+0.5 ** b ^ obj?.a
+0.5 ** f * f
+0.5 ** f ** (a - 0)
+0.5 ** f <= -a
+0.5 ** f <= a
+0.5 ** f >= b
+0.5 ** obj.a
+0.5 ** obj.b
+0.5 ** obj.obj?.a
+0.5 ** obj?.a
+0.5 ** obj?.b
+0.5 ** obj?.obj?.b
+0.5 + 0 >= b ? f : s
+0.5 + 2 + a
+0.5 + 2 + b ^ a
+0.5 + a - -0
+0.5 + a - f
+0.5 + f != obj?.b
+0.5 + f == b / f
+0.5 + obj.a
+0.5 + obj.b
+0.5 + obj?.a
+0.5 + obj?.b
+0.5 - 0.5 > 0.5 - b
+0.5 - 1 + b
+0.5 - a != f + b
+0.5 - f != obj.head(s)
+0.5 - f - div(b, a)
+0.5 - f < f * a
+0.5 - f == obj.a
+0.5 - obj.a
+0.5 - obj.b
+0.5 - obj.head(f)
+0.5 - obj.head(min(0, b))
+0.5 - obj.obj.a
+0.5 - obj?.a
+0.5 - obj?.a * b > obj?.a
+0.5 - obj?.b
+0.5 - obj?.obj.a
+0.5 - obj?.obj.b
+0.5 - obj?.obj?.b
+0.5 / 0 * b
+0.5 / 0.5 * div(0, b)
+0.5 / 0.5 - b
+0.5 / 1 < b
+0.5 / 1 == obj.a
+0.5 / a * a
+0.5 / a <= b ? f : div
+0.5 / a > obj.head(b, s)
+0.5 / arr[a % 1]
+0.5 / b != f
+0.5 / b / f
+0.5 / b == get(arr, b)
+0.5 / b > a
+0.5 / b >= a
+0.5 / obj.a
+0.5 / obj.b
+0.5 / obj.obj.a
+0.5 / obj?.a
+0.5 / obj?.b
+0.5 / obj?.obj.a
+0.5 / obj?.obj.b
+0.5 < 0 && true ? ok : obj
+0.5 < 0 or obj?.b
+0.5 < 0 or obj?.obj
+0.5 < 0 || obj?.obj
+0.5 < 0 || ok
+0.5 < 0.5 && !false
+0.5 < 0.5 ? b - a : s
+0.5 < 0.5 in obj.head(arr, ok)
+0.5 < f != ok
+0.5 < obj.a
+0.5 < obj.b
+0.5 < obj.fn(a)
+0.5 < obj?.a
+0.5 < obj?.b
+0.5 <= 0 || arr != arr
+0.5 <= a != ok
+0.5 <= arr[b]
+0.5 <= b || obj.fn(true).a.obj
+0.5 <= f && ok
+0.5 <= f == obj.b
+0.5 <= obj.a
+0.5 <= obj.b
+0.5 <= obj?.a
+0.5 <= obj?.b
+0.5 <= obj?.b * b
+0.5 == 1 and obj.head(obj, f, true)
+0.5 == 2 || 0.5 < 0
+0.5 == a && obj?.b
+0.5 == b && ok
+0.5 == f != obj.a
+0.5 == f ? 0.5 ** 0 : div
+0.5 == f ? ok : obj
+0.5 == f or ok
+0.5 == nil != obj.obj
+0.5 == nil == obj.fn(b)
+0.5 == nil == obj.obj
+0.5 == obj.a
+0.5 == obj.a + b
+0.5 == obj.b
+0.5 == obj.fn(a)
+0.5 == obj.fn(b)
+0.5 == obj.head(s == add, arr)
+0.5 == obj.obj
+0.5 == obj?.a
+0.5 == obj?.b
+0.5 == obj?.fn(a)
+0.5 == obj?.obj
+0.5 > 0 == obj?.b
+0.5 > 0 ? b : b
+0.5 > 0.5 ? a ** 1 : add
+0.5 > 0.5 and obj?.a
+0.5 > 1 == true ? add : nil
+0.5 > a != not false
+0.5 > a == ok
+0.5 > b ? a : obj
+0.5 > f ? (false ? arr : ok) : obj.head(0.5, s, arr)
+0.5 > f and div == add
+0.5 > obj.a
+0.5 > obj.b
+0.5 > obj.head(a ** a)
+0.5 > obj.head(f)
+0.5 > obj?.a
+0.5 > obj?.b
+0.5 > obj?.head(obj.head(obj?.b))
+0.5 > obj?.obj?.b
+0.5 >= 0.5 && obj.head(add, 0, arr, 0.5, s)
+0.5 >= a and ok
+0.5 >= b == true ? nil : div
+0.5 >= b ? div : string(0.5)
+0.5 >= obj.a
+0.5 >= obj.b
+0.5 >= obj.obj?.a
+0.5 >= obj.obj?.b
+0.5 >= obj?.a
+0.5 >= obj?.b
+0.5 ^ 0 - 0 * 1
+0.5 ^ 0 - a
+0.5 ^ 0 <= a * a
+0.5 ^ 0 > f
+0.5 ^ 0.5 + a
+0.5 ^ 0.5 ^ f
+0.5 ^ 1 >= a
+0.5 ^ 2 == f
+0.5 ^ a + obj?.b
+0.5 ^ a ^ (b * 0)
+0.5 ^ arr[a]
+0.5 ^ b > a
+0.5 ^ b > f
+0.5 ^ b >= obj.a
+0.5 ^ f * b
+0.5 ^ f > add(2, b)
+0.5 ^ f > f
+0.5 ^ f >= f
+0.5 ^ obj.a
+0.5 ^ obj.b
+0.5 ^ obj?.a
+0.5 ^ obj?.b
+0.5 ^ obj?.obj?.b
+1 != 0 != obj.a
+1 != 0 or obj?.head(false, div, div)
+1 != 0.5 || b < a
+1 != b != ok
+1 != f == ok
+1 != obj.a
+1 != obj.b
+1 != obj.fn(b)
+1 != obj.obj
+1 != obj?.a
+1 != obj?.b
+1 != obj?.obj
+1 != obj?.obj?.b
+1 % 1 .. 2 - a
+1 % 1 > f
+1 % a * add(1, b)
+1 % a - b
+1 % a / f
+1 % a > b + f
+1 % b / b
+1 % b == b
+1 % b >= b
+1 % obj.a
+1 % obj.b
+1 % obj?.a
+1 % obj?.b
+1 % obj?.obj.b
+1 * 0 .. obj?.head(b)
+1 * 2 == f
+1 * b != 0 ^ a
+1 * b < a
+1 * f < a / b
+1 * f > b
+1 * obj.a
+1 * obj.b
+1 * obj.obj.b
+1 * obj?.a
+1 * obj?.b
+1 ** 0 != obj.obj
+1 ** 0 ** float(2)
+1 ** 0 ^ a
+1 ** 0 ^ b
+1 ** 0.5 / obj?.a
+1 ** 2 ** count(arr, false)
+1 ** 2 < b
+1 ** a >= b
+1 ** b != b
+1 ** b + f
+1 ** b <= -b
+1 ** b >= 1 ** f
+1 ** obj.a
+1 ** obj.b
+1 ** obj.fn(b)
+1 ** obj?.a
+1 ** obj?.b
+1 + 0 == len(arr)
+1 + 0 == obj?.fn(b)
+1 + a > 0 != false
+1 + a > f
+1 + b - a
+1 + f != a
+1 + f >= 0 == false
+1 + f >= add(b, 0)
+1 + obj.a
+1 + obj.b
+1 + obj?.a
+1 + obj?.b
+1 - 0 .. abs(1)
+1 - 1 != a
+1 - 1 < a
+1 - 2 <= f
+1 - a != b ? arr : f
+1 - a > f
+1 - b != f
+1 - b > f
+1 - b >= add(b, 2)
+1 - b in arr ? s : b
+1 - obj.a
+1 - obj.b
+1 - obj.fn(2 - b)
+1 - obj?.a
+1 - obj?.b
+1 - obj?.obj.a
+1 .. 0 == obj.a
+1 .. obj.a
+1 .. obj.b
+1 .. obj.obj.b
+1 .. obj?.a
+1 .. obj?.b
+1 / 0 < f
+1 / 0 in obj?.head(arr)
+1 / 2 * f
+1 / a < f
+1 / a <= abs(a)
+1 / f * b
+1 / f == b
+1 / obj.a
+1 / obj.b
+1 / obj.obj.a
+1 / obj?.a
+1 / obj?.b
+1 < a && obj?.head(ok).b
+1 < a ? a : a
+1 < a ? ok : b
+1 < a || nil != obj
+1 < b == obj.obj
+1 < obj.a
+1 < obj.b
+1 < obj.head(obj?.b)
+1 < obj?.a
+1 < obj?.b
+1 < obj?.fn(b)
+1 <= 0 ? ok : add
+1 <= 1 or obj.head(a)
+1 <= 2 != true == ok
+1 <= a == obj?.b
+1 <= a or obj.a
+1 <= f != obj?.a
+1 <= f == all(arr, ok)
+1 <= f == obj?.head(nil)
+1 <= obj.a
+1 <= obj.b
+1 <= obj?.a
+1 <= obj?.b
+1 <= obj?.head(a)
+1 <= obj?.head(b)
+1 <= obj?.obj.obj.a
+1 == a or obj.head(any(ok and ok, #), div.fn(b, arr, 0, a).a)
+1 == b || obj?.a
+1 == nil != true ? ok : f
+1 == obj.a
+1 == obj.b
+1 == obj.head(first(true, "b", add))
+1 == obj.obj
+1 == obj?.a
+1 == obj?.b
+1 == obj?.obj
+1 > 0.5 and obj?.obj
+1 > 0.5 || 0 == f
+1 > f and ok
+1 > obj.a
+1 > obj.b
+1 > obj?.a
+1 > obj?.b
+1 > obj?.obj?.b
+1 >= 0 || one(arr, ok)
+1 >= 2 ? arr : a
+1 >= f == not false
+1 >= f || obj?.obj
+1 >= obj.a
+1 >= obj.b
+1 >= obj.fn(b)
+1 >= obj?.a
+1 >= obj?.b
+1 >= obj?.fn(b)
+1 ^ 0 != a
+1 ^ 1 != f
+1 ^ 1 != obj?.obj
+1 ^ b ^ f
+1 ^ f - a
+1 ^ obj.a
+1 ^ obj.b
+1 ^ obj.head(b)
+1 ^ obj.obj.b
+1 ^ obj?.a
+1 ^ obj?.b
+2 != 0 != obj?.b
+2 != 0 != ok
+2 != b != ok
+2 != b && b != f
+2 != b or obj?.b
+2 != nil != ok
+2 != nil == ok ? nil : div
+2 != obj.a
+2 != obj.b
+2 != obj.head(add)
+2 != obj.obj
+2 != obj.obj?.a
+2 != obj?.a
+2 != obj?.b
+2 != obj?.fn(b)
+2 != obj?.obj
+2 % 2 == a
+2 % a % a
+2 % a .. a
+2 % a .. obj.b
+2 % a > 0.5 ? b : obj
+2 % b + arr[a]
+2 % b > b
+2 % obj.a
+2 % obj.b
+2 % obj?.a
+2 % obj?.b
+2 * 0 * b
+2 * 0 <= f
+2 * 0.5 - a - b
+2 * 0.5 < b
+2 * 0.5 >= f
+2 * a >= b
+2 * arr[b]
+2 * f != b
+2 * obj.a
+2 * obj.b
+2 * obj?.a
+2 * obj?.b
+2 ** 0 != 0 - f
+2 ** 0 / a
+2 ** 0 > a
+2 ** 0 > f
+2 ** 0.5 ** f
+2 ** 0.5 > a
+2 ** 2 * obj.b
+2 ** a * f
+2 ** a >= f
+2 ** b / a
+2 ** b ^ a
+2 ** obj.a
+2 ** obj.b
+2 ** obj?.a
+2 ** obj?.b
+2 ** obj?.obj.a
+2 + 0 > b
+2 + 0.5 <= f - f
+2 + 2 + obj.b
+2 + arr[b]
+2 + b >= 0 ? arr : true
+2 + f != obj?.b
+2 + f + add(a, b)
+2 + obj.a
+2 + obj.a > f
+2 + obj.b
+2 + obj?.a
+2 + obj?.b
+2 + obj?.obj?.a
+2 - 0 > a ? div : 0
+2 - a == f - f
+2 - a in arr
+2 - b + len("c")
+2 - f < obj?.a
+2 - f == a
+2 - obj.a
+2 - obj.b
+2 - obj?.a
+2 - obj?.b
+2 - obj?.obj?.a
+2 .. obj.a
+2 .. obj.b
+2 .. obj.obj?.a
+2 .. obj?.a
+2 .. obj?.b
+2 .. obj?.obj.a
+2 / 0.5 - a
+2 / 0.5 >= obj.a
+2 / 1 > a
+2 / 2 * a
+2 / a >= obj.head(0.5)
+2 / b * obj.b
+2 / b > a ? arr : f
+2 / f - obj?.b
+2 / obj.a
+2 / obj.b
+2 / obj?.a
+2 / obj?.b
+2 / obj?.fn(a)
+2 < a and obj.obj
+2 < arr[b]
+2 < b ? fromBase64(s) : ok
+2 < f and obj?.head(f, true, false)
+2 < f || none(arr, ok)
+2 < obj.a
+2 < obj.b
+2 < obj?.a
+2 < obj?.b
+2 < obj?.obj.a
+2 <= a == obj.b
+2 <= a ? ok : s
+2 <= a and one(arr, ok)
+2 <= obj.a
+2 <= obj.b
+2 <= obj?.a
+2 <= obj?.b
+2 <= obj?.fn(a)
+2 <= obj?.fn(b)
+2 == 0 || b > f
+2 == arr[b - a]
+2 == f && a in arr
+2 == f and nil != f
+2 == nil == obj?.a
+2 == obj.a
+2 == obj.b
+2 == obj.obj
+2 == obj.obj.a
+2 == obj?.a
+2 == obj?.b
+2 == obj?.fn(a)
+2 == obj?.obj
+2 == obj?.obj?.a
+2 == obj?.obj?.b
+2 > 1 and obj.b
+2 > a || obj.b
+2 > obj.a
+2 > obj.b
+2 > obj?.a
+2 > obj?.b
+2 > obj?.obj.a
+2 >= 1 or f <= a
+2 >= a == nil ? ok : a
+2 >= b and ok
+2 >= f or obj.fn("b", false)
+2 >= obj.a
+2 >= obj.b
+2 >= obj.fn(count(s, true))
+2 >= obj?.a
+2 >= obj?.b
+2 >= obj?.fn(obj?.head(0, 0.5))
+2 ^ 0 / -a
+2 ^ 0 < b
+2 ^ 0 < b ? 0.5 : a
+2 ^ 0 <= float(0)
+2 ^ 0 >= -0
+2 ^ 0.5 >= add(b, b)
+2 ^ 1 != 0 ? add : false
+2 ^ 1 * b
+2 ^ 1 > b
+2 ^ 2 > b
+2 ^ a <= a
+2 ^ b - a
+2 ^ b - b
+2 ^ b <= max(b)
+2 ^ b == b
+2 ^ f == f
+2 ^ f >= a
+2 ^ obj.a
+2 ^ obj.b
+2 ^ obj.obj.a
+2 ^ obj?.a
+2 ^ obj?.b
+2 ^ obj?.fn(obj.head(0))
+[!ok]
+["a"] != arr
+[-0.5]
+[-0]
+[-a]
+[0 ** 2]
+[0.5 + 1]
+[0.5 > 0]
+[0.5 > 2]
+[2 == a, a]
+[2] == obj.head(f, 2, "a", f)
+[a % a, a, add]
+[a % a]
+[a ** 0.5]
+[a ^ b]
+[a, "b" != s]
+[a]
+[abs(f)]
+[add(div(a, b), last(arr))]
+[add, add]
+[add]
+[arr, 2 == 0]
+[arr, add]
+[arr, div]
+[arr[b]]
+[arr]
+[b - f]
+[b / a]
+[b <= 0]
+[b <= 2]
+[b, arr]
+[b, obj]
+[b]
+[div, b]
+[div, f]
+[div]
+[f * f]
+[f + 0]
+[f / a]
+[f >= 0]
+[f, a]
+[f, f ** 0]
+[f]
+[false ? add : f]
+[len(obj)]
+[lower("a")]
+[map(arr, div), ok, a]
+[min(0.5)]
+[min(f)]
+[obj, div]
+[obj, obj]
+[obj.b]
+[obj.fn(a)]
+[obj.head(b, arr)]
+[obj.head(b, div)]
+[obj.head(f)]
+[obj.head(obj)]
+[obj.obj.obj]
+[obj.obj]
+[obj?.a]
+[obj?.b]
+[obj?.fn(a)]
+[obj?.fn(b)]
+[obj?.head("b")]
+[obj?.head("c")]
+[obj?.head(a, ok, nil, add, nil)]
+[obj?.head(div), f]
+[obj?.head(div, 0)]
+[obj?.head(s)]
+[obj?.obj]
+[obj]
+[ok, 0.5 / f]
+[ok, add]
+[ok, arr]
+[ok, obj?.obj.b]
+[ok, obj]
+[ok, s]
+[ok]
+[s != "a"]
+[s != nil]
+[s != s]
+[s + "a"]
+[s endsWith "c"]
+[s matches "a"]
+[s, b]
+[s]
+[string(f)]
+[true] != arr
+a
+a != -a
+a != 0 % 1
+a != 0 * b
+a != 0 + b
+a != 0 ? b : nil
+a != 0 ? div : obj
+a != 0 ? f : ok
+a != 0 ? s : arr
+a != 0 ^ 1
+a != 0 ^ b
+a != 0.5 * f
+a != 0.5 / b
+a != 0.5 ? false : ok
+a != 0.5 ? s : nil
+a != 1 != false
+a != 1 * b
+a != 1 ? 0 : obj
+a != 2 ** 0
+a != a
+a != a + 0.5
+a != a - 0
+a != a - a
+a != a / 0
+a != a == nil
+a != a == ok
+a != a ? "c" : 0.5
+a != a ? 0 : div
+a != a and ok != nil
+a != add(0, a)
+a != add(0, b)
+a != add(b, a)
+a != arr[1]
+a != arr[b]
+a != arr[obj?.a]
+a != b
+a != b != true
+a != b && b > f
+a != b && ok
+a != b ** 0.5
+a != b ** a
+a != b ** f
+a != b / a
+a != b == nil
+a != b == obj?.b
+a != b ? 0 : add
+a != b and obj.head(arr)
+a != b and obj.obj
+a != b and obj?.a
+a != div(b, a)
+a != f
+a != f ** f
+a != f == ok
+a != f ? 1 : obj
+a != f ^ a
+a != f || ok
+a != first(arr)
+a != float(a)
+a != min(0.5)
+a != min(a, 1, b)
+a != min(b)
+a != nil != obj.a
+a != nil != ok ? ok : a
+a != nil ? 0 : a
+a != nil or obj.head(obj)
+a != obj.a
+a != obj.b
+a != obj.head(add, ok)
+a != obj.head(arr, 2, add)
+a != obj.head(div)
+a != obj.head(ok)
+a != obj.head(true)
+a != obj.obj
+a != obj.obj?.b
+a != obj?.a
+a != obj?.b
+a != obj?.fn(a)
+a != obj?.head(0.5)
+a != obj?.head(a * a)
+a != obj?.head(obj, a)
+a != obj?.obj
+a != obj?.obj.a
+a != obj?.obj.obj
+a != obj?.obj?.b
+a != obj?.obj?.obj
+a % (b - a)
+a % -a
+a % -b
+a % 1 != -b
+a % 1 != b
+a % 1 / 0
+a % 1 / f
+a % 1 < a
+a % 1 >= f
+a % 2 != a + a
+a % 2 != b
+a % 2 * f
+a % a
+a % a % a
+a % a * add(2, 0)
+a % a * b
+a % a - obj?.b
+a % a / b
+a % a < b
+a % a <= f
+a % a > 0 ? add : obj?.obj.a
+a % a > a
+a % add(a, b)
+a % add(b, a)
+a % arr[b]
+a % arr[obj.head(f)]
+a % b
+a % b != b
+a % b % a
+a % b * f
+a % b * obj.b
+a % b - a
+a % b .. obj?.head(f)
+a % b / a
+a % b == -f
+a % b == f
+a % b > b
+a % b > f
+a % b >= a
+a % count(arr, ok)
+a % div(1, a)
+a % div(b, 1)
+a % int(max(a))
+a % len("b")
+a % len(obj)
+a % min(a)
+a % obj.a
+a % obj.b
+a % obj.b < a
+a % obj.head(a)
+a % obj.head(a, add(b, a))
+a % obj.head(b)
+a % obj.obj.a
+a % obj.obj?.a
+a % obj.obj?.b
+a % obj?.a
+a % obj?.b
+a % obj?.head(a)
+a % obj?.obj?.a
+a % obj?.obj?.b
+a * (0.5 + b)
+a * (1 - 1)
+a * (1 - f)
+a * (2 - 0)
+a * (2 - b)
+a * (a + 1)
+a * (b - f)
+a * -a
+a * -f
+a * 0 % a
+a * 0 * f
+a * 0 ** b
+a * 0 / a
+a * 0 > obj.head(b)
+a * 0 > obj?.head(b, add)
+a * 0.5 / b
+a * 0.5 < f
+a * 2 % b
+a * 2 % div(a, a)
+a * 2 == a != false
+a * a
+a * a != obj.b
+a * a % b
+a * a ** 0
+a * a - obj.a
+a * a .. a
+a * a .. b
+a * a / 2
+a * a / f
+a * a < f
+a * a >= f
+a * a >= f ? nil : a
+a * abs(a)
+a * abs(f)
+a * add(1, a)
+a * add(a, 0)
+a * add(b, 0)
+a * add(b, a)
+a * b
+a * b % a
+a * b * obj.b
+a * b ** f
+a * b + a
+a * b - a
+a * b - b
+a * b - f - 0
+a * b - obj.a
+a * b <= b
+a * b >= f
+a * div(0, 1)
+a * div(0, b)
+a * div(a, 1)
+a * div(a, a)
+a * f
+a * f != b * b
+a * f * f
+a * f ** 0.5
+a * f - a
+a * f / a
+a * f / b
+a * f < a
+a * f <= f
+a * f <= f ^ 0.5
+a * f == max(a)
+a * f >= f
+a * f ^ 0.5
+a * f ^ 1
+a * float(1)
+a * len("a")
+a * min(a)
+a * min(b)
+a * obj.a
+a * obj.b
+a * obj.head(0.5, a)
+a * obj.head(a)
+a * obj.head(obj).b
+a * obj?.a
+a * obj?.b
+a * obj?.fn(0)
+a * obj?.fn(b)
+a * obj?.fn(get(arr, b))
+a * obj?.head(b)
+a * obj?.head(obj).a
+a * obj?.obj.a
+a * obj?.obj?.a
+a ** (0 * f)
+a ** (0.5 - 2)
+a ** (0.5 - b)
+a ** (0.5 / a)
+a ** (2 * 0.5)
+a ** (2 * b)
+a ** (2 - f)
+a ** (a / b)
+a ** (b * a)
+a ** (b - 0.5)
+a ** (b / b)
+a ** (f * a)
+a ** (f * b)
+a ** (f - 0)
+a ** (f / 2)
+a ** -0
+a ** -0.5
+a ** -a
+a ** -b
+a ** 0 != a
+a ** 0 ** 0
+a ** 0 - b
+a ** 0 ^ add(b, a)
+a ** 0.5 ** 0.5
+a ** 0.5 / a
+a ** 0.5 <= b
+a ** 0.5 > b
+a ** 0.5 ^ a
+a ** 1 / a
+a ** 1 > f
+a ** 1 ^ f
+a ** 2 != 2 - f
+a ** 2 ** (f + 2)
+a ** 2 <= b
+a ** a
+a ** a ** (f / b)
+a ** a ** f
+a ** a - f
+a ** a / b
+a ** a / obj.head(f)
+a ** a <= a
+a ** a <= obj.head(0)
+a ** a == a
+a ** a == b * 0.5
+a ** a > a
+a ** a ^ 2 ** f
+a ** abs(-f)
+a ** abs(2)
+a ** add(1, 2)
+a ** add(b, a)
+a ** arr[-0]
+a ** arr[a]
+a ** arr[b]
+a ** b
+a ** b != b
+a ** b != f
+a ** b != min(1)
+a ** b ** a
+a ** b - a
+a ** b > f
+a ** b ^ f
+a ** div(2, b)
+a ** div(a, 2)
+a ** f
+a ** f != obj?.head(obj).b
+a ** f ** 0
+a ** f ** f
+a ** f ** obj?.a
+a ** f <= a
+a ** f ^ a
+a ** f ^ f
+a ** float(f)
+a ** int(f)
+a ** len(obj)
+a ** max(0)
+a ** max(a, f)
+a ** min(b)
+a ** obj.a
+a ** obj.b
+a ** obj.fn(a)
+a ** obj.fn(b)
+a ** obj.head(f)
+a ** obj.obj.a
+a ** obj?.a
+a ** obj?.b
+a ** obj?.b ^ b
+a ** obj?.head(1, ok)
+a ** obj?.head(a)
+a ** obj?.head(a, 0.5, add, "c")
+a ** obj?.head(f, ok)
+a ** obj?.obj?.a
+a + -0
+a + -2 * f
+a + -f
+a + 0 + a
+a + 0 + f
+a + 0 - f
+a + 0 <= b
+a + 0 <= f
+a + 0 == obj?.a
+a + 0 ^ b
+a + 0.5 != b
+a + 0.5 * 2
+a + 0.5 > f
+a + 0.5 ^ f
+a + a
+a + a % a
+a + a % b
+a + a * 1
+a + a * f
+a + a + a
+a + a + f
+a + a - a
+a + a - b
+a + a / 0
+a + a / b
+a + a < a + a
+a + a >= f
+a + a ^ b
+a + add(0, 2)
+a + add(b, b)
+a + b
+a + b % a
+a + b - 0
+a + b - f
+a + b .. a
+a + count(arr, a != a)
+a + div(0, 2)
+a + div(a, b)
+a + div(b, b)
+a + f
+a + f * 0.5
+a + f + b * 0
+a + f + f
+a + f - a - 2
+a + f - b
+a + f <= b
+a + f == f
+a + f == obj?.obj
+a + f > float(b)
+a + f >= obj.b
+a + f ^ b
+a + f ^ f
+a + get(arr, 1)
+a + int(f)
+a + last(arr)
+a + len(s)
+a + min(f, 2)
+a + obj.a
+a + obj.b
+a + obj.fn(2)
+a + obj.fn(a)
+a + obj.fn(b)
+a + obj.fn(obj.head(b))
+a + obj.head(1, ok)
+a + obj.head(a)
+a + obj.head(a, ok, arr, nil)
+a + obj.obj.a
+a + obj.obj.b
+a + obj?.a
+a + obj?.b
+a + obj?.head(f)
+a + obj?.head(f, "c" != f)
+a + obj?.head(obj?.a)
+a + obj?.obj.a
+a - -2
+a - -a
+a - -b
+a - 0 != a
+a - 0 != f
+a - 0 != obj?.obj?.a
+a - 0 ** f
+a - 0 - b
+a - 0 / 0
+a - 0 < obj.b
+a - 0 <= min(1)
+a - 0 == obj.b
+a - 0 > a
+a - 0 ^ f
+a - 0 in arr
+a - 0.5 != f
+a - 0.5 * 0.5
+a - 0.5 > b
+a - 0.5 >= a
+a - 1 .. obj.b
+a - 1 == obj?.head(div, div)
+a - 1 > b
+a - 2 * f
+a - 2 - 0.5
+a - 2 .. b
+a - a
+a - a != nil != false
+a - a * 0
+a - a * f
+a - a ** b
+a - a - f
+a - a .. -2
+a - a .. a
+a - a < b / 0
+a - a <= a
+a - a <= f ** 0.5
+a - a == a
+a - a == obj?.a
+a - a > 0 ? f : obj
+a - a in arr
+a - add(a, 0)
+a - add(b, 0)
+a - b
+a - b * f
+a - b + b - b
+a - b + float(0)
+a - b - a
+a - b / 0
+a - b / 0.5
+a - div(a, 1)
+a - f
+a - f != b
+a - f ** 1
+a - f + b
+a - float(f)
+a - get(arr, a)
+a - len("c")
+a - max(f)
+a - obj.a
+a - obj.b
+a - obj.fn(a)
+a - obj.head(0.5, b, b)
+a - obj.head(2, obj)
+a - obj.head(f)
+a - obj.head(f, "b")
+a - obj.obj?.b
+a - obj?.a
+a - obj?.b
+a - obj?.head(a)
+a - obj?.head(b, arr)
+a - obj?.obj.b
+a .. -2
+a .. 0 - 1
+a .. a
+a .. a + 2
+a .. a + b
+a .. a + obj.obj.a
+a .. a - 1
+a .. add(b, b)
+a .. arr[a]
+a .. arr[b]
+a .. b
+a .. b + obj?.b
+a .. b - a
+a .. b - b
+a .. b == arr
+a .. div(1, 2)
+a .. div(a, b)
+a .. len(arr)
+a .. len(s)
+a .. min(0, 2)
+a .. obj.a
+a .. obj.b
+a .. obj.head(a)
+a .. obj.head(b, "a")
+a .. obj.obj?.a
+a .. obj?.a
+a .. obj?.b
+a .. obj?.head(1, obj, ok, false)
+a .. obj?.head(2, s, nil)
+a .. obj?.head(a, true, nil)
+a .. obj?.obj.a
+a .. obj?.obj.b
+a .. obj?.obj.obj?.b
+a / (0 - 0)
+a / (1 + 0.5)
+a / (a - a)
+a / (f + 0)
+a / (f + f)
+a / -0
+a / -a
+a / -b
+a / -obj.obj.b
+a / 0 != obj?.obj
+a / 0 * 1
+a / 0 ** a
+a / 0 + obj.a
+a / 0 / obj.b
+a / 0 < obj.a
+a / 0 <= a
+a / 0 == f
+a / 0 >= a
+a / 0 >= b
+a / 0.5 < f
+a / 0.5 == obj?.a
+a / 1 - b
+a / 1 / a
+a / 1 < obj?.b
+a / a
+a / a != f
+a / a - a ^ 2
+a / a < b
+a / a <= add(1, 0)
+a / a == f
+a / a > float(f)
+a / add(0, b)
+a / add(a, b)
+a / add(b, 0)
+a / add(b, b)
+a / arr[a]
+a / b
+a / b * obj?.head(f, arr, 0.5)
+a / b ** b
+a / b / (b + 0)
+a / b / 2
+a / b < a
+a / b == a
+a / b > f
+a / b >= 1 * obj?.a
+a / b ^ b
+a / count(arr, false)
+a / div(0, a)
+a / div(a, a)
+a / div(b, b)
+a / f
+a / f * f
+a / f ** 0.5
+a / f + a
+a / f - f
+a / f / b
+a / f / f
+a / f < obj?.b
+a / f <= 0 % b
+a / int(0)
+a / max(0, 1, a)
+a / max(2, b)
+a / min(f)
+a / obj.a
+a / obj.b
+a / obj.fn(a)
+a / obj.fn(b)
+a / obj.head(0, a)
+a / obj.head(a, arr, 0.5)
+a / obj.head(f)
+a / obj.head(f, a)
+a / obj?.a
+a / obj?.b
+a / obj?.fn(obj?.a)
+a / obj?.head(0, obj, b, f, "b")
+a / obj?.head(2, add)
+a / obj?.head(a)
+a / obj?.head(b, div)
+a / obj?.head(f)
+a / obj?.obj?.a
+a < -0
+a < -a
+a < -obj.a
+a < 0 && obj.head(obj)
+a < 0 * 0.5
+a < 0 ** b
+a < 0 ** f
+a < 0 / a
+a < 0.5 != ok
+a < 0.5 + f
+a < 0.5 ? 0 : arr
+a < 0.5 ? a != nil : f
+a < 1 && obj.fn(ok, "a", obj)
+a < 1 * 2
+a < 1 ? obj : true
+a < 1 ^ b
+a < 2 && obj?.a
+a < 2 ** 2
+a < a
+a < a % b
+a < a * f
+a < a - f
+a < a / a
+a < a == false
+a < a ? 0 : ok
+a < a ? 0.5 : arr
+a < a ? a : add
+a < a ? div : add
+a < a ? f : add
+a < a ? nil : 2
+a < a ? s : a
+a < abs(a)
+a < abs(b)
+a < add(2, b)
+a < add(a, a)
+a < arr[a]
+a < b
+a < b != ok
+a < b + 0.5
+a < b + b
+a < b + f
+a < b - f
+a < b == obj?.head(ok)
+a < b ? "c" : ok
+a < b or obj.obj
+a < div(b, 1)
+a < f
+a < f && obj.b?.b
+a < f * b
+a < f * f
+a < f - 0
+a < f ? "b" : false
+a < f ? a : ok
+a < f ? add : b
+a < f ? s : arr
+a < f || ok
+a < get(arr, b)
+a < last(arr)
+a < min(a)
+a < min(f)
+a < obj.a
+a < obj.b
+a < obj.fn(a)
+a < obj.head(0)
+a < obj.head(0, a, a)
+a < obj.head(a, obj)
+a < obj.head(b)
+a < obj.obj.b
+a < obj.obj?.a
+a < obj?.a
+a < obj?.b
+a < obj?.obj.b
+a <= -0
+a <= -0.5
+a <= -1
+a <= -b
+a <= -f
+a <= 0 != nil
+a <= 0 && obj?.a
+a <= 0 && obj?.fn(add)
+a <= 0 * b
+a <= 0 + 0.5
+a <= 0 - 1
+a <= 0 ? obj : s startsWith "c"
+a <= 0 ^ 0.5
+a <= 0 || !ok
+a <= 0 || ok
+a <= 0.5 && obj?.head(true)
+a <= 0.5 == obj.b
+a <= 0.5 ? f != b : b
+a <= 0.5 ? false : ok
+a <= 0.5 ? obj : a
+a <= 1 + 0
+a <= 2 != ok
+a <= 2 ** a
+a <= a
+a <= a != true
+a <= a ** 0
+a <= a / 2
+a <= a ? arr : "c"
+a <= a || ok
+a <= add(b, 1)
+a <= arr[b]
+a <= b
+a <= b != nil ? 1 : s
+a <= b % a
+a <= b ** a
+a <= b + 2
+a <= b - a
+a <= b ? f : a
+a <= b ? f : nil
+a <= b ? f : obj.a
+a <= b ? false : b
+a <= b and obj.a
+a <= f
+a <= f ** a
+a <= f ? 2 : f
+a <= f ? obj?.head(b) : obj?.b
+a <= f ? true : ok
+a <= f and ok
+a <= float(a)
+a <= get(arr, b)
+a <= len(obj)
+a <= max(a)
+a <= obj.a
+a <= obj.b
+a <= obj.head(a, "a", b, b, a)
+a <= obj.head(b * 0.5)
+a <= obj.head(b)
+a <= obj.head(f)
+a <= obj.obj.b
+a <= obj?.a
+a <= obj?.b
+a <= obj?.fn(b)
+a <= obj?.obj.a
+a == -obj?.b
+a == 0 != nil
+a == 0 % a
+a == 0 && obj?.b
+a == 0 + 1
+a == 0 ? obj?.b : arr
+a == 0 ? s : b
+a == 0.5 != obj?.a
+a == 0.5 + b
+a == 0.5 ? b : b
+a == 0.5 and obj.fn("b", nil)
+a == 1 + b
+a == 1 - f
+a == 1 ? div : obj
+a == 1 ? s : f
+a == 1 ^ b
+a == 2 * f
+a == 2 or obj.a
+a == a
+a == a && obj.obj
+a == a * b
+a == a + a
+a == a ? 1 : a
+a == a ? 2 : f
+a == a ? f : obj
+a == a ? s : 0
+a == add(2, a)
+a == arr[b]
+a == b
+a == b != nil
+a == b % b
+a == b * 1
+a == b ? b : obj.b
+a == b ? s : add
+a == b ^ 0.5
+a == b and "a" endsWith s
+a == b or obj.b
+a == b or ok
+a == f
+a == f != nil
+a == f != nil ? s : obj
+a == f != ok
+a == f && obj == obj
+a == f * a
+a == f == obj?.a
+a == f ? f : "b"
+a == f ? ok : div
+a == f and obj?.obj
+a == f or obj.b
+a == f || obj.head(b)
+a == first(obj?.a)
+a == int(b)
+a == last(arr)
+a == len("b")
+a == len(obj)
+a == nil != true
+a == nil == ok
+a == nil ? 0 : b
+a == nil ? a : "b"
+a == nil ? s : div
+a == nil and obj.head(false)
+a == obj.a
+a == obj.b
+a == obj.head("c")
+a == obj.head(a, s)
+a == obj.head(add)
+a == obj.head(arr)
+a == obj.head(f)
+a == obj.head(obj, s, 0).obj
+a == obj.head(ok, nil, add, "c")
+a == obj.head(s, "a", ok, b)
+a == obj.obj
+a == obj.obj.b
+a == obj?.a
+a == obj?.b
+a == obj?.b / a
+a == obj?.b or ok
+a == obj?.c
+a == obj?.head(0.5)
+a == obj?.head(add)
+a == obj?.head(arr)
+a == obj?.head(b or true)
+a == obj?.head(b)
+a == obj?.head(b, obj, "c")
+a == obj?.head(s)
+a == obj?.head(s, map(s, obj), a)
+a == obj?.obj
+a == obj?.obj?.b
+a == obj?.obj?.obj
+a > -a
+a > -b
+a > -f
+a > 0 != obj?.b
+a > 0 != ok
+a > 0 && ok
+a > 0 * 0.5
+a > 0 + 1
+a > 0 ^ 0.5
+a > 0 or nil == add
+a > 1 != ok
+a > 1 * 0
+a > 1 - 0
+a > 1 || obj?.obj
+a > 2 * 0
+a > 2 ? add : div
+a > 2 and obj.obj
+a > a
+a > a != ok
+a > a != true
+a > a * a
+a > a ** f
+a > a - b
+a > a / f
+a > a ? add : 1
+a > a ? add : ok
+a > add(a, b)
+a > add(b, a)
+a > arr[a]
+a > b
+a > b != ok
+a > b && !true
+a > b * b
+a > b + b
+a > b ? "b" : 0 >= f
+a > b ^ 0
+a > div(1, b)
+a > f
+a > f != ok
+a > f ** b
+a > f ** f
+a > f / 0
+a > f ? f : add
+a > f ? s : div
+a > f ^ a
+a > f || obj.head(0, add)
+a > get(arr, b)
+a > int(f)
+a > len(obj)
+a > len(s)
+a > max(a)
+a > min(b, f)
+a > obj.a
+a > obj.a % a
+a > obj.a ? obj.head(f, obj) : add
+a > obj.b
+a > obj.fn(b)
+a > obj.head(0.5)
+a > obj.head(a)
+a > obj.head(b)
+a > obj.obj.a
+a > obj?.a
+a > obj?.b
+a > obj?.fn(0)
+a > obj?.fn(b)
+a > obj?.head(f)
+a > obj?.obj.a
+a > obj?.obj.b
+a > obj?.obj?.a
+a > obj?.obj?.b
+a >= -0
+a >= -a
+a >= -f
+a >= 0 != !ok
+a >= 0 != obj.head(a, nil)
+a >= 0 && ok
+a >= 0 ** 0
+a >= 0 ** 1
+a >= 0 ** a
+a >= 0 + b
+a >= 0 ? s : b
+a >= 0 ^ 0
+a >= 0 ^ a
+a >= 0 or ok
+a >= 0.5 && obj?.a
+a >= 0.5 ? div : f ** 1
+a >= 0.5 || !ok
+a >= 1 && f >= b
+a >= 1 + 1
+a >= 1 ? add : obj.obj
+a >= 1 ^ a
+a >= 1 ^ f
+a >= 1 || any(arr, true)
+a >= 2 ? s : -f
+a >= a
+a >= a != nil
+a >= a != ok
+a >= a != true
+a >= a * a
+a >= a ** 2
+a >= a ** a
+a >= a ** b
+a >= a - b
+a >= a ? arr : a
+a >= a ^ 0
+a >= a ^ 1 * b
+a >= a and obj?.b
+a >= a || obj.head("a", f).head(f.head(div ^ ok), add contains b.b)
+a >= add(a, 0)
+a >= add(a, a)
+a >= add(b, b)
+a >= arr[b]
+a >= b
+a >= b % 1
+a >= b && f < f
+a >= b - 0.5
+a >= b ? 1 : false
+a >= b ^ a
+a >= b and obj.obj
+a >= b or ok
+a >= b || b >= 0.5
+a >= f
+a >= f * 2
+a >= f ** 2
+a >= f ? arr : add
+a >= f ? b : ok
+a >= f and ok
+a >= f || obj.b.fn(add(f, any(obj, arr))?.b)
+a >= float(b)
+a >= get(arr, 0)
+a >= int(0)
+a >= int(f)
+a >= len("c")
+a >= min(f)
+a >= obj.a
+a >= obj.b
+a >= obj.b || 0.5 <= obj.a
+a >= obj.fn(1)
+a >= obj.fn(a * a)
+a >= obj.fn(div(a, b))
+a >= obj.head(1, nil, "a")
+a >= obj.head(a, nil)
+a >= obj.head(f)
+a >= obj.obj?.b
+a >= obj?.a
+a >= obj?.a / b
+a >= obj?.b
+a >= obj?.fn(0)
+a >= obj?.head(a)
+a >= obj?.obj.a
+a >= obj?.obj?.a
+a >= obj?.obj?.b
+a ^ (0 / b)
+a ^ (2 + 0.5)
+a ^ (a % 2)
+a ^ (a % b)
+a ^ (a * a)
+a ^ (a - a)
+a ^ (a - f)
+a ^ (b - 2)
+a ^ (b / 0)
+a ^ (f - f)
+a ^ (f / 2)
+a ^ -0
+a ^ -0.5
+a ^ -a
+a ^ -b
+a ^ -f
+a ^ 0 * b
+a ^ 0 + f
+a ^ 0 - a
+a ^ 0 >= a
+a ^ 0.5 ** b
+a ^ 0.5 + -1
+a ^ 0.5 < f
+a ^ 0.5 >= a
+a ^ 1 ** f
+a ^ 1 > obj?.b
+a ^ 1 ^ obj.a
+a ^ 2 * f
+a ^ 2 + b
+a ^ 2 == obj?.obj?.a
+a ^ 2 ^ a
+a ^ a
+a ^ a ** a
+a ^ a ** f
+a ^ a + a * f
+a ^ a / (b + f)
+a ^ a / a
+a ^ a / b
+a ^ a < obj.a
+a ^ a == 2 == nil
+a ^ a > f
+a ^ a ^ arr[a]
+a ^ a ^ obj?.head(0)
+a ^ abs(a)
+a ^ add(1, 1)
+a ^ add(a, b)
+a ^ add(b, 2)
+a ^ arr[0]
+a ^ arr[a]
+a ^ arr[b]
+a ^ b
+a ^ b != obj.obj?.a
+a ^ b ** f
+a ^ b ** obj?.b
+a ^ b + 2 ^ f
+a ^ b + a
+a ^ b - b - a
+a ^ b < 0 == ok
+a ^ b > a
+a ^ b ^ a
+a ^ div(a, 2)
+a ^ f
+a ^ f != a
+a ^ f ** 0.5
+a ^ f ** f
+a ^ f + a
+a ^ f + b
+a ^ f - a
+a ^ f / b
+a ^ f > 0 ? div : arr
+a ^ f ^ obj?.a
+a ^ first(arr)
+a ^ get(arr, 0)
+a ^ min(f)
+a ^ obj.a
+a ^ obj.b
+a ^ obj.fn(b)
+a ^ obj.fn(obj.a)
+a ^ obj.head(a)
+a ^ obj.head(f)
+a ^ obj.obj.b
+a ^ obj.obj?.b
+a ^ obj?.a
+a ^ obj?.b
+a ^ obj?.head(b)
+a ^ obj?.obj?.b
+a in a .. 0
+a in a .. 2
+a in arr
+a in arr && obj.a
+a in arr == true
+a in arr ? 0.5 : 0.5
+a in arr ? 1 : obj
+a in arr ? f : nil
+a in arr ? f : ok
+a in arr || 0.5 == f
+a in b .. 0
+a in filter(arr, false)
+a in filter(arr, ok)
+a in map(arr, #)
+a in obj?.head(nil)?.obj
+a in obj[nil]
+abs(-0.5)
+abs(-1)
+abs(-2)
+abs(-a)
+abs(-b)
+abs(-f)
+abs(0 % 2)
+abs(0 % a)
+abs(0 % b)
+abs(0 * 0.5)
+abs(0 * b)
+abs(0 + 0)
+abs(0 + a)
+abs(0 + b)
+abs(0 + f)
+abs(0 - a)
+abs(0 / a)
+abs(0 / b)
+abs(0 / f)
+abs(0 ^ 0.5)
+abs(0 ^ b)
+abs(0) ** lastIndexOf("b", "b")
+abs(0) ** obj?.b
+abs(0) / b
+abs(0) < b * 0
+abs(0) <= f
+abs(0) == obj.a
+abs(0) ^ obj?.a
+abs(0.5 * f)
+abs(0.5 ** 0.5)
+abs(0.5 ** b)
+abs(0.5 + 0.5)
+abs(0.5 + f)
+abs(0.5 - 1)
+abs(0.5 - b)
+abs(0.5 - f)
+abs(0.5 ^ b)
+abs(0.5) != obj.a
+abs(0.5) == a
+abs(0.5) == f != ok
+abs(1 % 1)
+abs(1 ** b)
+abs(1 - a)
+abs(1 / 0)
+abs(1 / a)
+abs(1 / f)
+abs(1 ^ a)
+abs(1) * 0 * a
+abs(1) - min(a, 0)
+abs(1) / f
+abs(1) == f
+abs(1) > obj?.b
+abs(2 - 0)
+abs(2 - 1)
+abs(2 - a)
+abs(2 ^ f)
+abs(a * 0)
+abs(a * a)
+abs(a ** 0.5)
+abs(a ** a)
+abs(a ** f)
+abs(a + 0)
+abs(a + b)
+abs(a - a)
+abs(a / 1)
+abs(a / b)
+abs(a / f)
+abs(a ^ 0.5)
+abs(a ^ 1)
+abs(a ^ f)
+abs(a)
+abs(a) * obj?.a
+abs(a) + b
+abs(a) + f
+abs(a) - a == a
+abs(a) <= b
+abs(a) <= b % 1
+abs(a) > f
+abs(a) >= add(0, b)
+abs(abs(0.5))
+abs(abs(a))
+abs(abs(f))
+abs(abs(obj.head(b)))
+abs(add(0, 0))
+abs(add(0, a))
+abs(add(0, b))
+abs(add(1, b))
+abs(add(2, b))
+abs(add(a, 0))
+abs(add(a, a))
+abs(add(a, b))
+abs(add(b, 1))
+abs(add(b, a))
+abs(add(b, b))
+abs(arr[a])
+abs(arr[a]) ** b
+abs(b % a)
+abs(b % b)
+abs(b * 1)
+abs(b * b)
+abs(b ** 0)
+abs(b ** 0.5)
+abs(b ** 2)
+abs(b ** b)
+abs(b ** f)
+abs(b + b)
+abs(b + f)
+abs(b - a)
+abs(b - f)
+abs(b / 0.5)
+abs(b / a)
+abs(b / f)
+abs(b ^ 0)
+abs(b ^ 2)
+abs(b ^ a)
+abs(b ^ f)
+abs(b ^ obj.b)
+abs(b)
+abs(b) % a
+abs(b) * a
+abs(b) * b
+abs(b) - f
+abs(b) .. a
+abs(b) < a
+abs(b) < b
+abs(b) <= f
+abs(b) <= obj?.b
+abs(b) >= b ? "c" : 0
+abs(div(0, 1))
+abs(div(0, a))
+abs(div(a, a))
+abs(div(a, b))
+abs(div(b, a))
+abs(div(b, b))
+abs(f * 1)
+abs(f ** 0)
+abs(f ** 2)
+abs(f ** a)
+abs(f ** b)
+abs(f ** f)
+abs(f + 0)
+abs(f + 2)
+abs(f + a)
+abs(f + b)
+abs(f - a)
+abs(f - f)
+abs(f / b)
+abs(f / f)
+abs(f ^ 0)
+abs(f ^ 1)
+abs(f ^ f)
+abs(f ^ obj.a)
+abs(f ^ obj?.b)
+abs(f)
+abs(f) != f
+abs(f) * obj.b
+abs(f) ** f
+abs(f) + b
+abs(f) < obj?.a
+abs(f) == a
+abs(false ? "b" : 2)
+abs(false ? s : 0)
+abs(float(0))
+abs(float(0.5))
+abs(float(add(b, b)))
+abs(float(b))
+abs(float(f ^ a))
+abs(get(arr, 2))
+abs(get(arr, b))
+abs(int(0))
+abs(int(1))
+abs(int(b))
+abs(int(f))
+abs(len("b"))
+abs(len(arr))
+abs(max(a))
+abs(max(f))
+abs(max(f, f))
+abs(min(0, f))
+abs(min(a))
+abs(min(b))
+abs(min(b, f))
+abs(min(f))
+abs(obj.a)
+abs(obj.a) != b
+abs(obj.b)
+abs(obj.fn(0))
+abs(obj.fn(a))
+abs(obj.fn(b))
+abs(obj.head(0.5, b))
+abs(obj.head(1))
+abs(obj.head(2))
+abs(obj.head(2, nil, obj))
+abs(obj.head(a))
+abs(obj.head(a, a))
+abs(obj.head(b))
+abs(obj.head(b, 0.5))
+abs(obj.head(f))
+abs(obj.obj.b)
+abs(obj?.a)
+abs(obj?.b ** (a / b))
+abs(obj?.b)
+abs(obj?.fn(0))
+abs(obj?.fn(1))
+abs(obj?.fn(a))
+abs(obj?.fn(b))
+abs(obj?.head(0))
+abs(obj?.head(2))
+abs(obj?.head(a))
+abs(obj?.head(a, 2))
+abs(obj?.head(a, b, add))
+abs(obj?.head(a, ok, b))
+abs(obj?.head(b))
+abs(obj?.head(b, a))
+abs(obj?.head(b, arr, div, f))
+abs(obj?.head(f, add, 0.5))
+abs(obj?.obj.a)
+abs(obj?.obj.b)
+abs(obj?.obj?.a)
+abs(ok ? 0.5 : 0.5)
+abs(ok ? 0.5 : nil)
+abs(ok ? a : b)
+abs(ok ? b : arr)
+abs(true ? b : b)
+abs(true ? f : ok)
+abs(true ? f : s)
+add
+add != add
+add != add != ok
+add != add && obj?.b
+add != add ? add : !ok
+add != add ? add(a, a) : add
+add != add ? arr : "b"
+add != add ? b : a
+add != add ? obj : obj
+add != add ? s : nil
+add != div
+add != div && obj.b
+add != div == ok
+add != div ? 0 : a
+add != div ? f : obj
+add != div ? nil : false
+add != div ? ok : ok
+add != div || obj?.head(0)
+add != nil ? 1 : 2
+add != nil ? div : s
+add != nil and obj?.obj
+add != nil || obj.a
+add != obj.a
+add != obj.a + a
+add != obj.b
+add != obj.head("a")
+add != obj.head(-a)
+add != obj.head(0 == obj)
+add != obj.head(0, s, ok)
+add != obj.head(add, "c")
+add != obj.head(arr)
+add != obj.head(arr, "a", f)
+add != obj.head(b)
+add != obj.head(f)
+add != obj.head(f, 0, a, 2, f)
+add != obj.head(ok, a, 0)
+add != obj.head(s)
+add != obj.obj
+add != obj.obj.a
+add != obj.obj.obj
+add != obj.obj?.a
+add != obj.obj?.b
+add != obj.obj?.obj
+add != obj?.a
+add != obj?.b
+add != obj?.head(0.5)
+add != obj?.head(a, div, add)
+add != obj?.head(add, 0.5)
+add != obj?.head(div, ok)
+add != obj?.head(f, nil, obj, true, nil)
+add != obj?.head(s, add, div)
+add != obj?.obj
+add != obj?.obj.obj?.a
+add != obj?.obj?.a
+add != obj[nil]
+add == add
+add == add != ok
+add == add == true
+add == add ? 1 : f
+add == add ? ok : a
+add == add ? ok : f
+add == add or obj.obj
+add == add or ok
+add == div
+add == div != nil
+add == div && obj.fn(nil, 0)
+add == div ? f : a
+add == div || s >= "b"
+add == get(obj, s)
+add == nil == nil
+add == nil or obj.obj
+add == nil or ok
+add == obj.a
+add == obj.b
+add == obj.head("c", s)
+add == obj.head(2, a)
+add == obj.head(add, add, obj)
+add == obj.head(f, "b", false, f)
+add == obj.head(f, arr)
+add == obj.head(obj)
+add == obj.obj
+add == obj.obj.b
+add == obj.obj?.a
+add == obj.obj?.b
+add == obj?.a
+add == obj?.b
+add == obj?.c?.b
+add == obj?.fn(b)
+add == obj?.head("c")
+add == obj?.head(add)
+add == obj?.head(add, f, nil)
+add == obj?.head(b, nil)
+add == obj?.head(div)
+add == obj?.head(obj)
+add == obj?.head(s)
+add == obj?.obj
+add == obj?.obj.a
+add == obj?.obj.obj
+add == obj?.obj?.a
+add in [b]
+add in obj.head(nil)
+add in obj?.head(arr)
+add in obj?.head(arr, ok)
+add in obj[toJSON(nil)]
+add(-0, a)
+add(-0, b)
+add(-0, obj?.b)
+add(-0, ok ? b : div)
+add(-1, a)
+add(-2, a)
+add(-2, b)
+add(-a, a)
+add(-a, obj.a)
+add(-b, b)
+add(0 * b, obj?.a)
+add(0 - a, a - a)
+add(0, 0) <= f
+add(0, 0) == obj.head(f)
+add(0, 0) > last(arr)
+add(0, 1) + f
+add(0, 1) .. obj.b
+add(0, 2) % (0 - b)
+add(0, 2) > b
+add(0, 2) > f
+add(0, 2) ^ obj.b
+add(0, a) != f
+add(0, a) % (0 + a)
+add(0, a) + a
+add(0, a) + f
+add(0, a) + obj.head(f)
+add(0, a) <= f
+add(0, a) > 0.5 ? obj : div
+add(0, b) ** (f * f)
+add(0, b) ** 0.5 ^ f
+add(0, b) ** b
+add(0, b) - max(f)
+add(0, b) - obj.b
+add(0, b) .. a
+add(0, b) .. b
+add(0, b) <= a + 0
+add(1 % b, b)
+add(1 + 0, b)
+add(1, 0) == f
+add(1, 0) ^ a
+add(1, 1) > f
+add(1, 2) ^ f
+add(1, a) * obj.b
+add(1, a) in arr
+add(1, b) % a
+add(1, b) + obj.head(a)
+add(1, b) == f
+add(2 - a, obj.fn(a))
+add(2 - b, min(0))
+add(2, 0) < a
+add(2, 0) <= div(b, 2)
+add(2, 2) + f
+add(2, 2) / obj.fn(b)
+add(2, 2) > b
+add(2, a) - a
+add(2, a) .. a
+add(2, a) ^ a
+add(2, b) != a
+add(2, b) / b
+add(2, b) > b
+add(2, b) >= a
+add(2, b) ^ obj.b
+add(a % 2, a)
+add(a % a, obj.b)
+add(a % b, b)
+add(a * 0, a)
+add(a * 0, b * b)
+add(a * a, a)
+add(a * a, get(arr, b))
+add(a * b, obj?.head(b))
+add(a - 0, obj.b)
+add(a - 1, a)
+add(a - 2, a)
+add(a - b, b)
+add(a, -0)
+add(a, -1)
+add(a, -a)
+add(a, -b)
+add(a, 0) ** f
+add(a, 0) - f ** 0.5
+add(a, 0) .. -b
+add(a, 0) .. obj?.a
+add(a, 0) < 2 ? f : 1
+add(a, 0) < b
+add(a, 0) > a
+add(a, 0) >= float(2)
+add(a, 0) ^ f
+add(a, 1) != 0.5 ? ok : add
+add(a, 1) ** a
+add(a, 1) - f
+add(a, 1) < b
+add(a, 1) > obj.a
+add(a, 1) >= a
+add(a, 1) in 1 .. a
+add(a, 2) ** f
+add(a, 2) / f
+add(a, a * 2)
+add(a, a - a)
+add(a, a)
+add(a, a) != 0.5 ? s : b
+add(a, a) != f
+add(a, a) != obj?.obj
+add(a, a) % obj?.a
+add(a, a) % obj?.fn(b)
+add(a, a) - f
+add(a, a) .. obj.a
+add(a, a) / a
+add(a, a) / b
+add(a, a) / f
+add(a, a) < b
+add(a, a) < f
+add(a, a) == a
+add(a, a) > 1 - a
+add(a, a) >= -b
+add(a, a) >= 0.5 * 0
+add(a, a) >= a
+add(a, a) ^ f
+add(a, abs(b))
+add(a, add(a, 2))
+add(a, add(a, b))
+add(a, add(b, a))
+add(a, add(b, b))
+add(a, arr[a])
+add(a, arr[b])
+add(a, b * a)
+add(a, b)
+add(a, b) ** obj.b
+add(a, b) ** obj.head(1, div)
+add(a, b) + f / a
+add(a, b) - b
+add(a, b) - obj.a
+add(a, b) / int(b)
+add(a, b) == a
+add(a, b) == b
+add(a, b) == obj.obj
+add(a, b) ^ b
+add(a, b) ^ obj.b
+add(a, count(arr, ok))
+add(a, div(1, 1))
+add(a, get(arr, a))
+add(a, int(a))
+add(a, int(f))
+add(a, len(obj))
+add(a, max(1))
+add(a, obj.a)
+add(a, obj.b)
+add(a, obj?.a)
+add(a, obj?.b)
+add(a, obj?.fn(a))
+add(a, obj?.head(0))
+add(a, obj?.head(0, div, nil))
+add(a, obj?.obj.b)
+add(abs(0), b)
+add(abs(a), obj?.a)
+add(add(0, a), b)
+add(add(2, a), b)
+add(add(a, 0), -2)
+add(add(a, 2), b)
+add(add(a, b), b)
+add(add(b, 0), a)
+add(add(b, 0), b)
+add(add(b, 2), a)
+add(add(b, 2), b)
+add(add(b, b), a)
+add(arr[b], b)
+add(b % 1, b + b)
+add(b % a, a)
+add(b * b, -a)
+add(b + 0, a)
+add(b + 0, len("b"))
+add(b + 1, obj?.b)
+add(b + 2, get(arr, 1))
+add(b - 0, b)
+add(b - 0, get(arr, 1))
+add(b - 1, a)
+add(b - a, obj.a)
+add(b, -1)
+add(b, -2)
+add(b, -a)
+add(b, -b)
+add(b, 0 * a)
+add(b, 0 + b)
+add(b, 0) != b ? arr : obj
+add(b, 0) != f
+add(b, 0) * obj.b
+add(b, 0) ** a
+add(b, 0) ** obj.a
+add(b, 0) + a
+add(b, 0) + f
+add(b, 0) == b + 0
+add(b, 0) > a - f
+add(b, 0) >= b
+add(b, 0) >= obj?.b
+add(b, 0) ^ (0 + 0.5)
+add(b, 1) ** -2
+add(b, 1) + a
+add(b, 1) <= a
+add(b, 1) == obj?.head(add, f)
+add(b, 1) ^ f
+add(b, 2 % a)
+add(b, 2) == obj.obj.a
+add(b, a * b)
+add(b, a)
+add(b, a) != a ? s : obj
+add(b, a) != f
+add(b, a) * obj.a
+add(b, a) + a
+add(b, a) - b
+add(b, a) .. obj?.head(0, nil, f)
+add(b, a) > a % b
+add(b, a) > b == true
+add(b, a) >= b
+add(b, a) ^ b
+add(b, a) ^ obj?.a
+add(b, add(0, b))
+add(b, add(1, b))
+add(b, add(2, b))
+add(b, add(b, 2))
+add(b, arr[0])
+add(b, b % a)
+add(b, b * a)
+add(b, b + a)
+add(b, b)
+add(b, b) % div(a, 1)
+add(b, b) + b
+add(b, b) - -b
+add(b, b) - a
+add(b, b) - f
+add(b, b) < a + 0
+add(b, b) >= a + 0.5
+add(b, b) ^ obj?.b
+add(b, div(0, a))
+add(b, div(1, b))
+add(b, div(a, a))
+add(b, div(b, a))
+add(b, div(b, b))
+add(b, first(arr))
+add(b, get(arr, b))
+add(b, int(a))
+add(b, len(arr))
+add(b, max(b))
+add(b, min(a))
+add(b, obj.a)
+add(b, obj.a) % a
+add(b, obj.b)
+add(b, obj.head(a))
+add(b, obj.obj.a)
+add(b, obj.obj?.b)
+add(b, obj?.a)
+add(b, obj?.b)
+add(b, obj?.head(a))
+add(b, obj?.obj.b)
+add(b, ok ? 1 : a)
+add(div(0, a), b)
+add(div(a, a), add(0, 0))
+add(div(a, b), b)
+add(div(b, 2), a)
+add(div(b, a), -a)
+add(div(b, a), obj?.head(a, div))
+add(div(b, b), b)
+add(div(b, b), obj?.a)
+add(false ? add : 0, 0 + a)
+add(get(arr, 0), last(arr))
+add(get(arr, a), a)
+add(get(arr, a), b)
+add(get(arr, b), b)
+add(indexOf("a", "b"), b)
+add(indexOf(s, s), a)
+add(int(0), 0 - a)
+add(int(0), b)
+add(int(2), div(b, b))
+add(int(a), b)
+add(int(b), a)
+add(int(f), 1 * b)
+add(last(arr), a)
+add(len(obj), b)
+add(len(s), a)
+add(max(0), a)
+add(max(2), int(a))
+add(min(0), len(arr))
+add(min(2), a)
+add(min(a), b)
+add(min(a), len(arr))
+add(min(a), obj.a)
+add(obj.a, a)
+add(obj.a, b)
+add(obj.a, obj.a)
+add(obj.a, obj.b)
+add(obj.b, a * a)
+add(obj.b, a)
+add(obj.b, arr[0])
+add(obj.b, b)
+add(obj.b, obj.a)
+add(obj.b, obj.b)
+add(obj.b, obj.fn(b))
+add(obj.b, obj?.a)
+add(obj.b, obj?.b)
+add(obj.b, obj?.head(0))
+add(obj.b, obj?.head(b))
+add(obj.fn(0), b)
+add(obj.fn(a), obj.a)
+add(obj.fn(b), a)
+add(obj.head(0), 2 * a)
+add(obj.head(0), obj?.head(b))
+add(obj.head(1, add), obj.a)
+add(obj.head(2, 0, "a"), b)
+add(obj.head(a), b)
+add(obj.head(b), a)
+add(obj.head(b), b)
+add(obj.head(b, obj), b)
+add(obj.obj?.b, a)
+add(obj?.a, -a)
+add(obj?.a, a + 0)
+add(obj?.a, a - b)
+add(obj?.a, a)
+add(obj?.a, b % 1)
+add(obj?.a, b)
+add(obj?.a, div(a, b))
+add(obj?.a, div(b, a))
+add(obj?.a, obj.a)
+add(obj?.a, obj.b)
+add(obj?.a, obj?.head(a, f, obj))
+add(obj?.b, -0)
+add(obj?.b, -1)
+add(obj?.b, 0 * a)
+add(obj?.b, 0 * b)
+add(obj?.b, 2 + a)
+add(obj?.b, a)
+add(obj?.b, add(0, a))
+add(obj?.b, b)
+add(obj?.b, min(0))
+add(obj?.b, obj.a)
+add(obj?.b, obj.b)
+add(obj?.b, obj?.a)
+add(obj?.b, obj?.b)
+add(obj?.b, obj?.head(0))
+add(obj?.fn(0), int(a))
+add(obj?.fn(0), obj.a)
+add(obj?.fn(b), obj.a)
+add(obj?.head(0, 0, false), arr[a])
+add(obj?.head(a), b)
+add(obj?.head(b), b)
+add(obj?.head(b, s), a)
+add(obj?.obj.a, b)
+add(ok ? 2 : f, obj.b)
+add(ok ? a : f, obj.b)
+add(ok ? a : s, b)
+all(0 .. 0, nil != 0)
+all(0 .. 2, "c" startsWith s)
+all(0 .. 2, ok)
+all(0 .. a, ok)
+all(0 .. b, ok)
+all(a .. 0, "a" matches s)
+all(a .. 0, a > b)
+all(a .. b, !ok)
+all(arr, "a" <= s)
+all(arr, "a" contains "b")
+all(arr, "a" in obj)
+all(arr, "b" matches "a")
+all(arr, "c" in obj)
+all(arr, "c" matches s)
+all(arr, # != f)
+all(arr, 0 == nil)
+all(arr, 0 > b)
+all(arr, 0.5 != b)
+all(arr, 0.5 <= a)
+all(arr, 0.5 >= a)
+all(arr, 2 != 1)
+all(arr, 2 < 0)
+all(arr, 2 < a)
+all(arr, 2 <= a)
+all(arr, 2 > f)
+all(arr, a != a)
+all(arr, a < 0)
+all(arr, a < 1)
+all(arr, a < b)
+all(arr, a < obj.b)
+all(arr, a <= f)
+all(arr, a == a)
+all(arr, a == f)
+all(arr, a > f)
+all(arr, a >= b)
+all(arr, add != add)
+all(arr, add == nil)
+all(arr, all(arr, ok))
+all(arr, all(arr, true))
+all(arr, any(arr, ok))
+all(arr, b < 0)
+all(arr, b <= b)
+all(arr, b == a)
+all(arr, f != a)
+all(arr, f < #)
+all(arr, f == b)
+all(arr, f == f)
+all(arr, f >= b)
+all(arr, f >= f)
+all(arr, false == ok)
+all(arr, false ? div : false)
+all(arr, false and ok)
+all(arr, false) and f <= b
+all(arr, nil != 2)
+all(arr, nil != nil)
+all(arr, nil == "b")
+all(arr, nil == add)
+all(arr, nil == arr)
+all(arr, none(arr, ok))
+all(arr, not true)
+all(arr, obj.head(false))
+all(arr, obj?.head(true))
+all(arr, ok != nil)
+all(arr, ok && ok)
+all(arr, ok == obj.b)
+all(arr, ok || false)
+all(arr, ok)
+all(arr, ok) != obj?.b
+all(arr, ok) != obj?.obj
+all(arr, ok) or obj.b
+all(arr, ok) or obj?.head(a)
+all(arr, one(arr, ok))
+all(arr, s != s)
+all(arr, s <= "b")
+all(arr, s > "a")
+all(arr, s contains s)
+all(arr, s matches s)
+all(arr, true or false)
+all(arr, true or true)
+all(arr, true) && a == nil
+all(b .. a, a > f)
+all(filter(arr, false), ok || ok)
+all(filter(arr, true), "a" >= "a")
+all(map(arr, "b"), ok)
+all(map(arr, 0), ok)
+all(map(arr, 0.5), 1 < 2)
+all(map(arr, 0.5), ok)
+all(map(arr, 2), b != b)
+all(map(arr, add), 2 < f)
+all(map(arr, arr), 2 == b)
+all(map(arr, b), b >= b)
+all(map(arr, b), not true)
+all(map(arr, b), ok)
+all(map(arr, f), a > f)
+all(map(arr, false), #)
+all(map(arr, obj), 0 <= f)
+all(map(arr, ok), #)
+all(map(arr, s), ok)
+all(obj.head("c"), ok)
+all(obj.head(arr, 0.5, div), true or false)
+all(obj.head(obj, a), ok)
+all(obj.head(obj, f, b), ok)
+all(obj.head(obj, s), 0 >= f)
+all(obj.head(s), b < 0)
+all(obj.obj, "a" == s)
+all(obj.obj, a >= a)
+all(obj.obj, add == add)
+all(obj.obj, all(arr, ok))
+all(obj.obj, div == nil)
+all(obj.obj, f <= a)
+all(obj.obj, obj.head(ok, div))
+all(obj.obj, ok || ok)
+all(obj.obj, ok)
+all(obj?.head("b", ok, add, 0), ok)
+all(obj?.head("c", b), 0 < a)
+all(obj?.head(arr), 0.5 > f)
+all(obj?.head(arr), b < f)
+all(obj?.head(arr), obj.head(ok))
+all(obj?.head(arr, 0.5, add, nil), f != 0.5)
+all(obj?.head(obj), a <= 0)
+all(obj?.head(obj, nil), ok)
+all(obj?.head(s), 1 == f)
+all(obj?.obj, 0 > 0)
+all(obj?.obj, b == 0.5)
+all(obj?.obj, b >= 1)
+all(obj?.obj, b >= a)
+all(obj?.obj, div != nil)
+all(obj?.obj, nil in arr)
+all(obj?.obj, obj.head(ok))
+all(obj?.obj, obj?.head(ok, ok))
+all(obj?.obj, ok && false)
+all(obj?.obj, ok)
+all(obj?.obj, s endsWith "c")
+all(obj?.obj, s matches s)
+all(ok ? arr : s, ok or true)
+all(ok ? obj : f, b > f)
+any(0 .. a, ok)
+any([false, "c"], ok)
+any([ok, false], #)
+any(a .. b, ok ? ok : obj)
+any(a .. b, ok)
+any(arr, !false)
+any(arr, !true)
+any(arr, "a" == obj.b)
+any(arr, "b" < s)
+any(arr, "c" != obj?.obj)
+any(arr, "c" startsWith "c")
+any(arr, # != a)
+any(arr, # != b)
+any(arr, 0 != 0.5)
+any(arr, 0.5 != b)
+any(arr, 0.5 >= f)
+any(arr, 1 != 0)
+any(arr, 2 < 0.5)
+any(arr, a != b)
+any(arr, a < b)
+any(arr, a == 0.5)
+any(arr, a == f)
+any(arr, a > 0.5)
+any(arr, a > b)
+any(arr, a in arr)
+any(arr, add != div)
+any(arr, any(arr, true))
+any(arr, b != f)
+any(arr, b < f)
+any(arr, b <= f)
+any(arr, b == 0)
+any(arr, b > 0)
+any(arr, b > f)
+any(arr, div == div)
+any(arr, f < a)
+any(arr, f < b)
+any(arr, f <= 0.5)
+any(arr, f > 0.5)
+any(arr, f >= a)
+any(arr, false and false)
+any(arr, false and ok)
+any(arr, false || false)
+any(arr, false) != ok
+any(arr, false) && ok
+any(arr, false) ? div(nil, a) : obj
+any(arr, false) || false ? div : 0
+any(arr, nil != add)
+any(arr, nil != f)
+any(arr, nil != s)
+any(arr, nil == "b")
+any(arr, nil == "c")
+any(arr, nil == 1)
+any(arr, nil == a)
+any(arr, nil == add)
+any(arr, nil == b)
+any(arr, nil == s)
+any(arr, not ok)
+any(arr, obj.head(false))
+any(arr, obj.head(false, div, 0, add))
+any(arr, obj.head(false, true))
+any(arr, obj.head(ok, add))
+any(arr, ok != nil)
+any(arr, ok ? ok : b)
+any(arr, ok)
+any(arr, ok) && obj.a
+any(arr, ok) && obj.obj
+any(arr, ok) && ok
+any(arr, ok) == ok
+any(arr, ok) ? s : keys(obj)
+any(arr, ok) and obj.a
+any(arr, ok) or obj.b
+any(arr, ok) or ok
+any(arr, one(arr, false))
+any(arr, s <= s)
+any(arr, s contains "c")
+any(arr, s endsWith "b")
+any(arr, string(2) != s)
+any(arr, true) != ok
+any(arr, true) && obj?.head(false)
+any(arr, true) and b != f
+any(arr, true) or obj?.a
+any(arr, true) || obj.obj
+any(arr[0:b], div != div)
+any(b .. 2, a == b)
+any(b .. a, obj?.a)
+any(false ? add : obj, nil == f)
+any(false ? div : "a", ok)
+any(false ? false : s, !true)
+any(filter(arr, ok), a != a)
+any(filter(arr, ok), ok ? ok : 0)
+any(filter(arr, ok), ok)
+any(filter(arr, true), "b" in obj)
+any(keys(obj), ok)
+any(map(arr, 0), a < a)
+any(map(arr, 0), b <= 0)
+any(map(arr, 0), nil != "b")
+any(map(arr, 0.5), a <= a)
+any(map(arr, a), false && ok)
+any(map(arr, add), ok)
+any(map(arr, arr), 2 == nil)
+any(map(arr, div), 0 > f)
+any(map(arr, div), ok)
+any(map(arr, f), b == 0)
+any(map(arr, f), nil != a)
+any(map(arr, f), ok)
+any(map(arr, ok), #)
+any(map(obj.head(s), a), ok)
+any(obj.head("b"), ok)
+any(obj.head("c", obj), 1 != nil)
+any(obj.head(arr), 0 < b)
+any(obj.head(obj), a < b)
+any(obj.head(s), 0 >= 0)
+any(obj.obj, 0.5 > b)
+any(obj.obj, 2 == 0.5)
+any(obj.obj, a < f)
+any(obj.obj, obj != obj)
+any(obj.obj, ok && false)
+any(obj.obj, ok and ok)
+any(obj.obj, ok)
+any(obj.obj, s <= s)
+any(obj.obj, s > "a")
+any(obj?.head(arr), ok)
+any(obj?.head(upper(a, 0, "c")), ok)
+any(obj?.obj, 0 >= 0.5)
+any(obj?.obj, a <= 0.5)
+any(obj?.obj, arr == arr)
+any(obj?.obj, b == b)
+any(obj?.obj, f == 1)
+any(obj?.obj, f == nil)
+any(obj?.obj, f > a)
+any(obj?.obj, not false)
+any(obj?.obj, not ok)
+any(obj?.obj, ok != nil)
+any(obj?.obj, ok)
+any(obj?.obj, s >= "c")
+any(obj?.obj?.obj, ok)
+any(ok ? "b" : ok, 2 != b)
+any(ok ? arr : ok, ok)
+any(ok ? obj : 0, b < b)
+any(ok ? obj : ok, 0 < 0.5)
+arr
+arr != arr
+arr != arr && ok ? arr : f
+arr != arr == obj.head(a)
+arr != b .. 0
+arr != filter(arr, true)
+arr != map(arr, 0)
+arr != map(arr, arr)
+arr != map(arr, obj)
+arr != nil ? ok : f
+arr != nil ? ok : ok
+arr != nil and f != b
+arr != nil or a == 0
+arr != nil || true && false
+arr != obj.a
+arr != obj.b
+arr != obj.head(0.5)
+arr != obj.head(add, add)
+arr != obj.head(all("c", ok))
+arr != obj.head(arr, add)
+arr != obj.head(arr, s)
+arr != obj.head(b)
+arr != obj.head(b, 0)
+arr != obj.head(b, b, b, true)
+arr != obj.head(nil)
+arr != obj.head(s)
+arr != obj.head(true, b, "a")
+arr != obj.obj
+arr != obj.obj.a
+arr != obj?.a
+arr != obj?.b
+arr != obj?.head("a" >= s)
+arr != obj?.head(0)
+arr != obj?.head(0.5)
+arr != obj?.head(div)
+arr != obj?.head(false)
+arr != obj?.head(nil)
+arr != obj?.head(obj, add)
+arr != obj?.head(obj, s, arr, add).a
+arr != obj?.head(s)
+arr != obj?.obj
+arr != obj?.obj.b
+arr != obj?.obj?.a
+arr == a .. a
+arr == arr
+arr == arr != ok
+arr == arr == ok
+arr == arr ? "b" : add
+arr == arr ? a : 0
+arr == arr ? add : obj
+arr == arr ? nil : "a"
+arr == arr ? obj : nil
+arr == arr ? obj?.head(div, "b") : s
+arr == arr ? ok : a
+arr == arr ? s : a
+arr == arr and obj?.fn(a)
+arr == arr and obj?.head(a, 0.5, arr, arr)
+arr == arr or obj.b != b
+arr == map(arr, true)
+arr == nil ? a : ok
+arr == nil ? ok : div
+arr == nil or add == div
+arr == nil or obj.fn(b)
+arr == nil || obj.b
+arr == obj.a
+arr == obj.b
+arr == obj.head(0, div)
+arr == obj.head(arr, f, ok)
+arr == obj.head(f, obj)
+arr == obj.head(s, 0)
+arr == obj.obj
+arr == obj.obj ? arr : obj
+arr == obj.obj.b
+arr == obj.obj.obj
+arr == obj?.a
+arr == obj?.b
+arr == obj?.head(a)
+arr == obj?.head(a, nil)
+arr == obj?.head(arr)
+arr == obj?.head(arr, "c")
+arr == obj?.head(b, ok)
+arr == obj?.head(div)
+arr == obj?.head(false)
+arr == obj?.head(nil, f, "b")
+arr == obj?.head(obj, arr)
+arr == obj?.head(s, 0.5)
+arr == obj?.head(s, a)
+arr == obj?.obj
+arr == obj?.obj.b
+arr == obj?.obj.obj
+arr == obj?.obj.obj?.a
+arr in keys(obj)
+arr in obj.head(arr)
+arr in obj?.head(get(0, b))
+arr[-a]
+arr[0 * 2]
+arr[0 * a]
+arr[0 + 0]
+arr[0 + 2:a]
+arr[0] % b
+arr[0] - a
+arr[0] / obj?.head(f, 0)
+arr[0] <= min(1)
+arr[0] >= f
+arr[1 % b]
+arr[1 * a]
+arr[1] < a
+arr[1] == b
+arr[2 % b]
+arr[2 * 0:b]
+arr[2] * obj.a
+arr[a + a]
+arr[a - b]
+arr[a]
+arr[a] != f
+arr[a] != f + 1
+arr[a] * a
+arr[a] ** a
+arr[a] + f
+arr[a] - 1 / 1
+arr[a] .. b
+arr[a] <= a
+arr[a] > -a
+arr[a] >= f
+arr[a] ^ f
+arr[add(a, 0)]
+arr[add(b, 0):b]
+arr[add(b, 0)]
+arr[b % b]
+arr[b - 0]
+arr[b - a]
+arr[b:a * b]
+arr[b:obj.b]
+arr[b]
+arr[b] % a
+arr[b] * (b + a)
+arr[b] ** a
+arr[b] - add(b, 1)
+arr[b] - arr[a]
+arr[b] - b
+arr[b] - f
+arr[b] - obj?.b
+arr[b] == obj.b
+arr[b] > -0
+arr[b] > a
+arr[b] > b
+arr[b] > get(arr, 0)
+arr[b] > last(arr)
+arr[div(a, 1)]
+arr[div(a, 2)]
+arr[div(a, b)]
+arr[len("a")]
+arr[max(0)]
+arr[max(b)]
+arr[obj.a]
+arr[obj.b:obj?.fn(2)]
+arr[obj.b]
+arr[obj.fn(a)]
+arr[obj.head(a)]
+arr[obj.head(a, obj)]
+arr[obj.head(f)]
+arr[obj?.a]
+arr[obj?.b]
+arr[obj?.fn(0)]
+arr[obj?.head(b)]
+arr[obj?.head(f)]
+arr[true ? b : obj]
+b
+b != -a
+b != -f
+b != 0 % b
+b != 0 && obj?.head("c", 0.5)
+b != 0 * a
+b != 0 ? false : 1
+b != 0 ? obj : arr
+b != 0 ? ok : nil
+b != 0 ? true : arr
+b != 0 or s <= "b"
+b != 0.5 * a
+b != 0.5 == ok != ok
+b != 0.5 ? ok : ok
+b != 0.5 ^ obj?.b
+b != 1 - b
+b != 1 - f
+b != 1 / a
+b != 1 == ok
+b != 2 || f > a
+b != a
+b != a % a
+b != a * a
+b != a - a
+b != a / 0.5
+b != a ? "b" : arr
+b != a ? "c" : obj
+b != a ? a : "a"
+b != a ? f : div
+b != a ? obj : add
+b != add(2, 0)
+b != add(2, a)
+b != add(a, a)
+b != b
+b != b != false
+b != b - a
+b != b - b
+b != b == nil
+b != b == ok
+b != b ? ok : div
+b != b ? s : obj.a
+b != div(2, b)
+b != f
+b != f != ok
+b != f / a
+b != f == true
+b != f ? 0.5 : arr
+b != f ? arr : ok
+b != f ? obj : add
+b != f or obj.b
+b != float(a)
+b != get(arr, 2)
+b != get(obj, s)
+b != nil ? nil : s
+b != nil ? obj : f
+b != nil || ok
+b != obj.a
+b != obj.b
+b != obj.c
+b != obj.head("b", obj)
+b != obj.head(add)
+b != obj.head(arr)
+b != obj.head(arr, f < b)
+b != obj.head(b, obj, false)
+b != obj.head(div, f)
+b != obj.head(nil, s)
+b != obj.head(obj)?.a
+b != obj.head(ok or not b)
+b != obj.head(ok)
+b != obj.obj
+b != obj.obj.obj
+b != obj?.a
+b != obj?.a ** b
+b != obj?.b
+b != obj?.head(div)
+b != obj?.head(false, ok)
+b != obj?.head(map(obj, add))
+b != obj?.head(not (0 == 0))
+b != obj?.head(obj)
+b != obj?.obj
+b != obj?.obj.obj
+b != obj?.obj?.a
+b % (0 + b)
+b % (0 - a)
+b % (b - a)
+b % -1
+b % -a
+b % -obj.b
+b % -obj?.b
+b % 1 - f - b
+b % 1 / 0.5
+b % 2 >= obj?.head(f)
+b % 2 in arr
+b % a
+b % a % a
+b % a % b
+b % a * a
+b % a * f
+b % a + 0.5 + b
+b % a - a
+b % a - f
+b % a .. b
+b % a / a
+b % a <= a
+b % a == b
+b % a > b
+b % a in arr
+b % add(0, b)
+b % add(1, 2)
+b % add(a, a)
+b % arr[a]
+b % arr[obj?.b]
+b % b
+b % b != a
+b % b % obj.a
+b % b * b
+b % b + -0.5
+b % b - b
+b % b - f
+b % b < a
+b % b < f
+b % b <= f ? s : s
+b % b == b
+b % get(arr, b)
+b % max(0, a)
+b % obj.a
+b % obj.b
+b % obj.fn(1)
+b % obj.head(a, div)
+b % obj.obj.a
+b % obj?.a
+b % obj?.b
+b % obj?.fn(b)
+b % obj?.head(a)
+b % obj?.head(a, obj)
+b % obj?.head(b)
+b % obj?.head(b, ok, div)
+b % obj?.head(obj, false).b
+b % obj?.obj?.a
+b % obj?.obj?.b
+b * (0 + f)
+b * (2 + 0.5)
+b * (a + f)
+b * (a - 1)
+b * -0
+b * -0.5
+b * -a
+b * -b
+b * -f
+b * 0 != a
+b * 0 * 0
+b * 0 ** 1
+b * 0 - get(arr, a)
+b * 0 .. a
+b * 0 / a
+b * 0 / f
+b * 0 < b
+b * 0 >= b
+b * 0 >= f
+b * 0.5 / (b - b)
+b * 0.5 / b
+b * 0.5 <= f
+b * 0.5 == b
+b * 1 * a
+b * 1 * min(b)
+b * 2 == f
+b * 2 > obj.b
+b * a
+b * a * a
+b * a ** f
+b * a + a
+b * a - a
+b * a .. b
+b * a / 0.5
+b * a <= f
+b * a == 0.5 - f
+b * a == obj?.a
+b * a > 2 ** f
+b * a > f
+b * a ^ 0
+b * abs(0)
+b * abs(a)
+b * abs(b)
+b * add(2, b)
+b * b
+b * b != 0 % a
+b * b != f
+b * b % a
+b * b * obj.a
+b * b + b
+b * b - obj.a
+b * b / a
+b * b / f
+b * b / obj?.a
+b * b == f
+b * b == len(s)
+b * b > f
+b * b ^ a
+b * b in arr
+b * f
+b * f * 0
+b * f * 2
+b * f * b
+b * f + b
+b * f + obj.a
+b * f / b
+b * f <= a == true
+b * f <= b
+b * f == b
+b * f ^ 0.5
+b * first(arr)
+b * float(0.5)
+b * float(f)
+b * get(arr, 0)
+b * get(arr, 1)
+b * int(a)
+b * max(2)
+b * obj.a
+b * obj.b
+b * obj.fn(b)
+b * obj.head(a)
+b * obj.head(b)
+b * obj.obj.a
+b * obj.obj.b
+b * obj.obj?.a
+b * obj.obj?.b
+b * obj?.a
+b * obj?.b
+b * obj?.fn(obj.b)
+b * obj?.fn(obj?.b)
+b * obj?.head(b, a) * obj.a
+b * obj?.head(f)
+b * obj?.head(f, f < 0)
+b * obj?.obj.b
+b ** (0 * 0.5)
+b ** (0 * f)
+b ** (0 - a)
+b ** (0 / b)
+b ** (1 % 1)
+b ** (2 * a)
+b ** (a % b)
+b ** (a - a)
+b ** (b + b)
+b ** (b / f)
+b ** (f * b)
+b ** (f + 0)
+b ** (f - 0)
+b ** (f - 2)
+b ** (f / f)
+b ** -a
+b ** -b
+b ** 0 * b * a
+b ** 0 - b
+b ** 0 < f
+b ** 0 < obj?.fn(2)
+b ** 0 == a
+b ** 0 ^ a ** f
+b ** 0 ^ obj.b
+b ** 0.5 ** a
+b ** 0.5 ** f
+b ** 0.5 + obj?.a
+b ** 0.5 >= b
+b ** 0.5 ^ (a * b)
+b ** 0.5 ^ b
+b ** 1 / a
+b ** 1 / f
+b ** 2 ** a
+b ** 2 ** b
+b ** 2 + 0.5 ^ f
+b ** 2 - a
+b ** a
+b ** a != obj?.a
+b ** a != obj?.b
+b ** a * b
+b ** a * obj.b
+b ** a ** b
+b ** a + obj?.head(0)
+b ** a - obj?.fn(b)
+b ** a / b
+b ** a / obj.fn(a)
+b ** a < a
+b ** a == obj?.fn(b)
+b ** a > b
+b ** a ^ 2
+b ** a ^ a
+b ** arr[0]
+b ** arr[a]
+b ** b
+b ** b * obj?.b
+b ** b ** 0
+b ** b ** 0.5
+b ** b + a
+b ** b < a % 2
+b ** b ^ f
+b ** div(a, a)
+b ** div(b, 2)
+b ** f
+b ** f != f
+b ** f != obj.a
+b ** f * a
+b ** f * f
+b ** f * obj.b
+b ** f ** f
+b ** f < 0 * 0.5
+b ** f < b
+b ** f ^ a
+b ** f ^ b
+b ** int(0.5)
+b ** int(a)
+b ** int(b)
+b ** max(1)
+b ** max(a, a, f)
+b ** min(1)
+b ** obj.a
+b ** obj.b
+b ** obj.fn(2)
+b ** obj.fn(b)
+b ** obj.head(a)
+b ** obj.head(b)
+b ** obj.obj?.a
+b ** obj.obj?.b
+b ** obj?.a
+b ** obj?.b
+b ** obj?.fn(b)
+b ** obj?.head(0.5)
+b ** obj?.head(0.5, arr, "c")
+b ** obj?.head(b, arr)
+b ** obj?.obj.b
+b ** obj?.obj?.a
+b + -2
+b + -b
+b + -f
+b + 0 % b
+b + 0 + a
+b + 0 + b
+b + 0 - b
+b + 0 - obj.head(0.5, obj, div, obj, a)
+b + 0 >= a
+b + 0 ^ 1
+b + 0.5 != b - 0
+b + 0.5 + -0
+b + 0.5 + a % a
+b + 0.5 / 2
+b + 0.5 / b
+b + 0.5 >= b ? "c" : arr
+b + 1 == obj.obj
+b + 2 < -b
+b + 2 < b
+b + 2 <= b
+b + 2 == obj.b
+b + 2 ^ 0
+b + a
+b + a != 1 * b
+b + a != obj.obj
+b + a % a
+b + a ** 0
+b + a .. a
+b + a .. b
+b + a < a == false
+b + a <= b
+b + a > a
+b + add(b, a)
+b + b
+b + b % b
+b + b - a
+b + b - obj?.head(0.5)
+b + b / 1
+b + b / b
+b + b <= a
+b + b == a
+b + b >= get(arr, 0)
+b + b ^ 1
+b + count(arr, true)
+b + div(0, 1)
+b + f
+b + f != b ? nil : f
+b + f ** a
+b + f + a
+b + f - b
+b + f - b - b
+b + f - obj.fn(a)
+b + f == f
+b + f == obj?.a
+b + f > b
+b + f > div(2, a)
+b + float(0.5)
+b + int(f)
+b + len("c")
+b + max(f)
+b + min(0.5)
+b + obj.a
+b + obj.a > f
+b + obj.b
+b + obj.head(b)
+b + obj.head(f, "c", 0)
+b + obj.head(f, 1, 0.5)
+b + obj.obj.a
+b + obj.obj.b
+b + obj.obj?.b
+b + obj?.a
+b + obj?.b
+b + obj?.head(0, 0.5, nil, b, obj)
+b + obj?.head(0, add)
+b + obj?.head(1, a, obj, obj)
+b + obj?.head(b)
+b + obj?.obj.b
+b + obj?.obj?.a
+b + obj?.obj?.b
+b - -2
+b - -b
+b - -f
+b - 0 - 0
+b - 0 == a ? obj : false
+b - 0 > b
+b - 0 > f
+b - 0 ^ 0
+b - 0.5 != f
+b - 0.5 / b
+b - 1 - b
+b - 1 .. b
+b - 1 / 0
+b - 1 / 2
+b - 1 / a
+b - 1 / f
+b - 1 < b
+b - 1 <= add(b, 0)
+b - 2 ** 2
+b - 2 - 2
+b - 2 / a
+b - 2 < b
+b - a
+b - a % b
+b - a * f
+b - a ** 1
+b - a + f
+b - a - 0.5
+b - a .. a
+b - a == a
+b - a == f
+b - a ^ 0
+b - a ^ b
+b - a in arr
+b - abs(0)
+b - add(2, b)
+b - add(a, 0)
+b - arr[0]
+b - arr[obj.b]
+b - b
+b - b + a
+b - b - b
+b - b - f
+b - b .. a
+b - b < a
+b - b < a ^ 0.5
+b - b ^ 0
+b - b ^ f
+b - div(2, 2)
+b - div(a, a)
+b - f
+b - f ** a
+b - f + 0
+b - f + 1
+b - f + obj?.b
+b - f - 0 ** a
+b - f - 0.5
+b - f - f
+b - f < f
+b - f == a
+b - f >= len(arr)
+b - get(arr, a)
+b - int(0.5)
+b - max(0, a)
+b - max(a)
+b - min(2)
+b - obj.a
+b - obj.a + a
+b - obj.a == b
+b - obj.b
+b - obj.fn(b)
+b - obj.fn(true && a)
+b - obj.head(0, obj)
+b - obj.head(f, 2, f)
+b - obj.obj.a
+b - obj.obj?.a
+b - obj?.a
+b - obj?.b
+b - obj?.fn(b)
+b - obj?.head(1)
+b - obj?.head(f)
+b - obj?.obj.b
+b - obj?.obj?.a
+b - obj?.obj?.b
+b .. -2
+b .. -a
+b .. -b
+b .. 0 * a
+b .. 0 + b
+b .. 0 == obj.b
+b .. 1 * 2
+b .. a
+b .. a % a
+b .. a + b
+b .. add(a, count(arr, false))
+b .. add(b, 0)
+b .. add(b, a)
+b .. add(b, b)
+b .. arr[b % 2]
+b .. b
+b .. b * a
+b .. b + b
+b .. count(arr, ok)
+b .. first(obj.head("b", obj))
+b .. get(arr, 0)
+b .. get(arr, b)
+b .. len(s)
+b .. min(b)
+b .. obj.a
+b .. obj.b
+b .. obj.head(b)
+b .. obj?.a
+b .. obj?.b
+b .. obj?.fn(a)
+b .. obj?.head(2)
+b .. obj?.head(a)
+b .. obj?.head(obj, s, div)?.b
+b .. obj?.obj.b
+b .. obj?.obj?.a
+b / (0 + 0)
+b / (1 + b)
+b / (a + f)
+b / (a - 0.5)
+b / (a - 2)
+b / (b - b)
+b / (f + b)
+b / (f - f)
+b / -0
+b / -0.5
+b / 0 * f
+b / 0 - b
+b / 0 / a
+b / 0 < a
+b / 0 > b
+b / 0 > b ? f : s
+b / 0 >= f
+b / 0.5 * a
+b / 0.5 * f
+b / 0.5 ** 2
+b / 0.5 + b
+b / 0.5 - b
+b / 0.5 <= a
+b / 0.5 <= obj?.a
+b / 0.5 >= 0.5 ? obj : arr
+b / 1 / b
+b / 2 != a
+b / 2 <= abs(1)
+b / 2 ^ 2
+b / a
+b / a != a
+b / a != obj.obj
+b / a ** f
+b / a + a
+b / a + b
+b / a / 0
+b / a / a
+b / a / b
+b / a == obj?.b
+b / a > 2 ? div : arr
+b / a > b
+b / add(1, a)
+b / add(a, a)
+b / add(b, 1)
+b / add(b, b)
+b / arr[a]
+b / b
+b / b * 0 ** b
+b / b ** f
+b / b < b
+b / b < obj.b
+b / b <= b
+b / b ^ 0
+b / f
+b / f != a
+b / f != abs(0.5)
+b / f * f
+b / f ** 0.5
+b / f + b
+b / f / f
+b / f < f
+b / f <= b
+b / f <= f
+b / f <= obj?.a
+b / f == a
+b / f >= a
+b / get(arr, 0)
+b / get(arr, b)
+b / int(a)
+b / min(1)
+b / min(b)
+b / obj.a
+b / obj.b
+b / obj.fn(2)
+b / obj.fn(a)
+b / obj.fn(b)
+b / obj.head(a, arr, add, a)
+b / obj.obj.a
+b / obj.obj.b
+b / obj.obj?.obj.a
+b / obj?.a
+b / obj?.b
+b / obj?.head(b, arr, f)
+b / obj?.obj.a
+b / obj?.obj.b
+b < -2
+b < 0 != obj.b
+b < 0 % b
+b < 0 + 1
+b < 0 - a
+b < 0 or ok
+b < 0 || ok
+b < 0.5 ? a : b
+b < 0.5 ? nil : div
+b < 1 == ok
+b < 1 ? b : 0
+b < 2 && obj.fn(b)
+b < 2 ** 1
+b < 2 / 1
+b < 2 / a
+b < 2 ^ a
+b < a
+b < a ** 0.5
+b < a + a
+b < a - 1
+b < a - f
+b < a / b
+b < a ? "a" : obj
+b < a ? 0 : nil
+b < a ? div : s
+b < a ? obj : f
+b < a ^ a and obj.head("c", 2)?.a
+b < a ^ f
+b < a and ok
+b < add(b, 1)
+b < add(b, a)
+b < b
+b < b && ok
+b < b - 1
+b < b == ok
+b < b ? b : true
+b < b ? f : arr
+b < b ? nil : ok
+b < b ? s : s
+b < b ^ b
+b < b and "b" in obj
+b < b and nil != 0
+b < b and obj.a
+b < b and ok
+b < b or obj?.a
+b < f
+b < f != ok
+b < f ** b
+b < f == ok
+b < f ? 1 : div
+b < f ? obj : b
+b < f ? obj.fn(arr, nil, nil, div) : obj
+b < f ? ok : s
+b < float(0)
+b < float(b)
+b < int(0)
+b < int(f)
+b < obj.a
+b < obj.a != obj?.obj
+b < obj.b
+b < obj.head(f)
+b < obj.obj.a
+b < obj?.a
+b < obj?.b
+b < obj?.b == true != obj.a
+b < obj?.fn(0)
+b < obj?.head(0)
+b < obj?.head(0, s, a)
+b < obj?.head(b)
+b < obj?.head(b, nil)
+b < obj?.obj?.a
+b < obj?.obj?.b
+b <= -0
+b <= -1
+b <= -a
+b <= 0 != ok
+b <= 0 % b
+b <= 0 && obj[s]
+b <= 0 * 0.5
+b <= 0 - 0.5
+b <= 0.5 + 0.5
+b <= 0.5 ? ok : b
+b <= 1 - f
+b <= 1 ? b : a
+b <= 1 || ok
+b <= 2 ? s : obj
+b <= 2 and ok
+b <= a
+b <= a * 1
+b <= a ** 0
+b <= a == nil
+b <= a ? 0 : div
+b <= a ? obj : arr
+b <= a ^ a
+b <= a || obj?.a
+b <= a || ok
+b <= abs(a)
+b <= abs(f)
+b <= add(b, 1)
+b <= arr[b]
+b <= b
+b <= b != nil
+b <= b % b
+b <= b * a
+b <= b + b
+b <= b / f
+b <= b ? add : ok
+b <= b ^ b
+b <= b or b < b
+b <= b or obj.b
+b <= b || ok
+b <= count(arr, ok)
+b <= div(b, b)
+b <= f
+b <= f != false
+b <= f != ok
+b <= f != ok ? arr : add
+b <= f * f
+b <= f ** f
+b <= f + b
+b <= f - obj?.b
+b <= float(b)
+b <= get(arr, 0)
+b <= int(a)
+b <= int(arr[0])
+b <= len(keys(obj))
+b <= max(0)
+b <= max(a)
+b <= max(f, f, a, f, f)
+b <= min(b, 0)
+b <= obj.a
+b <= obj.b
+b <= obj.head(1)
+b <= obj.head(a, 0)
+b <= obj.head(b)
+b <= obj.obj.b
+b <= obj?.a
+b <= obj?.b
+b <= obj?.fn(a)
+b <= obj?.fn(arr[0.5])
+b <= obj?.head(0, ok, false)
+b <= obj?.obj.a
+b == -0.5
+b == -b
+b == -f
+b == 0 != true ? b : arr
+b == 0 * 0
+b == 0 + 0
+b == 0 / a
+b == 0 == obj.b
+b == 0 ? arr : a
+b == 0 ? s : 0.5
+b == 0 and obj?.obj
+b == 0 or obj?.head(s)
+b == 0 || obj.obj
+b == 0.5 != obj.head(a, s, ok)
+b == 1 + obj.a
+b == 1 ? add : false
+b == 1 ^ b
+b == 2 ^ a
+b == a
+b == a != nil
+b == a / 1
+b == a == nil
+b == a ? a : b
+b == a ? div : ok
+b == a ? f : false
+b == a ? f : ok
+b == a or ok
+b == abs(f)
+b == add(0, b)
+b == add(a, 2)
+b == add(a, a)
+b == add(a, b)
+b == arr[a]
+b == arr[b]
+b == b
+b == b != obj?.obj
+b == b != ok
+b == b && 0 != 0
+b == b * 2
+b == b - a
+b == b - b
+b == b / 0.5
+b == b / b
+b == b == not false
+b == b or f < 0
+b == div(b, a)
+b == f
+b == f && ok
+b == f * 0
+b == f - b
+b == f == ok
+b == f ? add : div
+b == f or ok
+b == f || obj.b
+b == float(b)
+b == get(arr, 0)
+b == get(arr, 1)
+b == get(obj.head(nil, 0.5, div), a)
+b == int(0)
+b == len("a")
+b == max(f)
+b == min(0)
+b == nil != obj.a
+b == obj.a
+b == obj.b
+b == obj.b != obj.obj
+b == obj.fn(0)
+b == obj.fn(a)
+b == obj.fn(add(a, 1))
+b == obj.fn(b)
+b == obj.head(arr)
+b == obj.head(div)
+b == obj.head(f)
+b == obj.head(obj?.head(ok, 0, div))
+b == obj.head(ok, b, 2)
+b == obj.head(one(arr, ok))
+b == obj.head(true, add, div)
+b == obj.obj
+b == obj?.a
+b == obj?.b
+b == obj?.head("b")
+b == obj?.head(0)
+b == obj?.head(a)
+b == obj?.head(div)
+b == obj?.head(nil, add, ok)
+b == obj?.head(obj).a
+b == obj?.head(obj?.b)
+b == obj?.head(s)
+b == obj?.obj
+b == obj?.obj.b
+b == obj?.obj?.obj
+b == obj[s]
+b > 0 != true
+b > 0 - 2
+b > 0 / a
+b > 0 || ok
+b > 0 || ok ? 0 : a
+b > 0.5 ? arr : div
+b > 0.5 ^ 2
+b > 0.5 || nil == "a"
+b > 0.5 || obj.head(1 .. s.obj)
+b > 1 * f
+b > 1 ? 0 : 0
+b > 1 ? false : f
+b > 1 and 2 <= b
+b > 2 != ok
+b > 2 ? "a" : false
+b > a
+b > a != false
+b > a != nil
+b > a * a
+b > a * f
+b > a ** 0
+b > a ** b
+b > a ** f
+b > a / 2
+b > a / obj?.b
+b > a ^ b
+b > a or 0.5 > 2
+b > a or a != 0
+b > a || f != 0
+b > a || obj?.fn(div, arr).obj
+b > a || ok
+b > abs(0.5)
+b > arr[0]
+b > arr[a]
+b > b
+b > b % a
+b > b * 0.5
+b > b * f
+b > b ** a
+b > b + f
+b > b - 0.5
+b > b - f
+b > b ? ok : ok
+b > b ? ok : s
+b > b ^ a
+b > b or obj?.head(a, 1)
+b > b || ok
+b > div(a, -b)
+b > div(b, a)
+b > f
+b > f != obj?.b
+b > f * a
+b > f / b
+b > f == obj.b
+b > f ? arr : div
+b > f ? b : s
+b > f ? f : "c"
+b > f ^ b
+b > f and not ok
+b > f or obj.obj
+b > float(b)
+b > float(f)
+b > int(0)
+b > len(obj)
+b > obj.a
+b > obj.b
+b > obj.fn(a)
+b > obj.head(f)
+b > obj.obj.b
+b > obj?.a
+b > obj?.b
+b > obj?.head(0)
+b > obj?.head(0.5, 0)
+b > obj?.obj.a
+b > obj?.obj?.b
+b >= -a
+b >= -b
+b >= -f
+b >= 0 != ok
+b >= 0 - b
+b >= 0 ? 0.5 : true
+b >= 0 ? add : arr
+b >= 0 ? s : "c"
+b >= 0 ^ 0.5
+b >= 0 and obj.head(s, f, arr, 0)
+b >= 0.5 == ok
+b >= 0.5 ? f : 0
+b >= 0.5 and obj.a
+b >= a
+b >= a - 0.5
+b >= a == nil
+b >= a ? obj.obj : add
+b >= a ^ f
+b >= a and 0.5 >= b
+b >= abs(1)
+b >= b
+b >= b % a
+b >= b % b
+b >= b && nil != arr
+b >= b ** 0
+b >= b ** obj.b
+b >= b + 0.5
+b >= b and obj.b
+b >= b in obj?.head(nil, 0.5)?.obj
+b >= b or obj.fn(b)?.a
+b >= b || f - obj?.obj
+b >= div(a, b)
+b >= div(b, a)
+b >= div(b, b)
+b >= f
+b >= f != false
+b >= f ** b
+b >= f ? 0.5 : s
+b >= f ? nil : false
+b >= f ^ 0.5
+b >= f ^ b
+b >= f || a == f
+b >= f || obj?.head(nil, s)
+b >= int(0) != obj?.obj
+b >= int(a)
+b >= last(arr)
+b >= min(b)
+b >= obj.a
+b >= obj.b
+b >= obj.head(a)
+b >= obj.head(f, arr, add)
+b >= obj.obj?.a
+b >= obj?.a
+b >= obj?.a + a
+b >= obj?.b
+b >= obj?.b and ok
+b >= obj?.fn(0)
+b >= obj?.fn(a)
+b >= obj?.fn(b)
+b >= obj?.head(f)
+b >= obj?.obj.a
+b ^ (0 * 1)
+b ^ (0.5 + 0)
+b ^ (0.5 + b)
+b ^ (0.5 - a)
+b ^ (1 - 0.5)
+b ^ (1 / 0)
+b ^ (a * b)
+b ^ (a - a)
+b ^ (a / a)
+b ^ (b * a)
+b ^ (b + 0)
+b ^ (b + 0.5)
+b ^ (b / 0)
+b ^ (b / b)
+b ^ (f * 0)
+b ^ (f * 0.5)
+b ^ (f + b)
+b ^ (f - b)
+b ^ (f / 0.5)
+b ^ -a
+b ^ -b
+b ^ 0 != count(arr, ok)
+b ^ 0 != f ? arr : obj
+b ^ 0 + f
+b ^ 0 / f / f
+b ^ 0 ^ b
+b ^ 0.5 * f
+b ^ 0.5 < f
+b ^ 0.5 <= f
+b ^ 0.5 > obj?.a
+b ^ 0.5 >= b
+b ^ 1 - f
+b ^ 1 == obj?.obj
+b ^ 1 > f - f
+b ^ 1 ^ b
+b ^ 2 < obj.b
+b ^ 2 <= a
+b ^ 2 > a
+b ^ 2 ^ f
+b ^ 2 ^ obj?.fn(0)
+b ^ a
+b ^ a ** (f / a)
+b ^ a ** a
+b ^ a + f
+b ^ a - b + a
+b ^ a - max(a)
+b ^ a - min(b)
+b ^ a <= arr[a]
+b ^ a <= f ? add : true
+b ^ a == b
+b ^ a == obj.obj
+b ^ a ^ f
+b ^ add(0, a)
+b ^ add(2, a)
+b ^ add(a, b)
+b ^ add(b, 2)
+b ^ b
+b ^ b < -0.5
+b ^ b < f
+b ^ b == 0 / 1
+b ^ b == a
+b ^ b == a + 0
+b ^ b > f
+b ^ count(arr, true)
+b ^ div(0, b)
+b ^ div(1, a)
+b ^ div(b, a)
+b ^ f
+b ^ f >= 0 ? b : b
+b ^ f ^ 0.5
+b ^ f ^ a
+b ^ f ^ b
+b ^ get(arr, b)
+b ^ int(f)
+b ^ len(arr)
+b ^ min(f)
+b ^ obj.a
+b ^ obj.b
+b ^ obj.head(1)
+b ^ obj.head(b)
+b ^ obj.obj?.a
+b ^ obj?.a
+b ^ obj?.b
+b ^ obj?.fn(2)
+b ^ obj?.head(0.5, div, a)
+b ^ obj?.head(a, a)
+b ^ obj?.head(b)
+b ^ obj?.obj.a
+b ^ obj?.obj?.a
+b ^ obj?.obj?.b
+b in arr
+b in arr && true ? obj : div
+b in arr == not ok
+b in arr == true
+b in arr || nil == obj
+b in arr[2:1]
+b in filter(arr, ok)
+b in map(arr, 0)
+b in obj.head(arr)
+b in obj.head(nil, b, arr, 0, 0.5)?.a
+b in obj[s]
+count([f], ok)
+count([nil, arr, ok], ok)
+count(a .. 0, obj.a)
+count(a .. 0, ok || ok)
+count(arr, "b" < s)
+count(arr, "b" <= "a")
+count(arr, "c" > s)
+count(arr, # != #)
+count(arr, # == f)
+count(arr, # >= a)
+count(arr, # >= add(b, 0))
+count(arr, 0 != a)
+count(arr, 0 != f)
+count(arr, 0 <= 0)
+count(arr, 0 <= 0.5)
+count(arr, 0 == a)
+count(arr, 0 > 0.5)
+count(arr, 0 > a)
+count(arr, 0 > f)
+count(arr, 0.5 == 0.5)
+count(arr, 0.5 > 0.5)
+count(arr, 0.5 >= 0.5)
+count(arr, 1 < f)
+count(arr, 1 == b)
+count(arr, 2 < a)
+count(arr, 2 >= f)
+count(arr, a <= b)
+count(arr, a == nil)
+count(arr, a >= 0.5)
+count(arr, a >= a)
+count(arr, add != div)
+count(arr, add == add)
+count(arr, all(arr, false))
+count(arr, any(arr, ok))
+count(arr, any(arr, true))
+count(arr, arr == nil)
+count(arr, b != b)
+count(arr, b <= 1)
+count(arr, b == 0)
+count(arr, b == b)
+count(arr, b > 1)
+count(arr, b >= 1)
+count(arr, b >= a)
+count(arr, b in arr)
+count(arr, f != nil)
+count(arr, f < b)
+count(arr, f > a)
+count(arr, false or false)
+count(arr, false) % b
+count(arr, false) + abs(0.5)
+count(arr, false) == a
+count(arr, false) == f
+count(arr, false) > f
+count(arr, false) >= f + 0
+count(arr, false) >= obj?.a
+count(arr, false) ^ f
+count(arr, false) in arr
+count(arr, nil != 0)
+count(arr, nil != arr)
+count(arr, nil != div)
+count(arr, nil == 0.5)
+count(arr, nil == a)
+count(arr, nil == s)
+count(arr, not false)
+count(arr, obj != obj)
+count(arr, obj.head(ok))
+count(arr, obj?.a == arr)
+count(arr, ok != ok)
+count(arr, ok or 0 > 0.5)
+count(arr, ok)
+count(arr, ok) != b ? "b" : a
+count(arr, ok) % add(0, b)
+count(arr, ok) ** a
+count(arr, ok) + b
+count(arr, ok) - int(a)
+count(arr, ok) / a
+count(arr, ok) < a
+count(arr, ok) == b
+count(arr, ok) > a
+count(arr, ok) > b
+count(arr, ok) > obj.a
+count(arr, ok) in arr
+count(arr, one(arr, false))
+count(arr, s != s)
+count(arr, s contains "c")
+count(arr, s endsWith "a")
+count(arr, true) * obj?.a
+count(arr, true) - b
+count(arr, true) <= a
+count(arr, true) == b
+count(arr, true) > a
+count(arr, true) >= arr[b]
+count(b .. a, a == 0)
+count(b .. a, obj?.head(ok, obj, f, ok, arr))
+count(b .. a, ok)
+count(b .. b, not false)
+count(b .. b, ok == false)
+count(false ? f : obj, not true)
+count(false ? true : obj, 2 <= 1)
+count(filter(arr, false), obj?.obj)
+count(keys(obj), b >= f)
+count(keys(obj), ok)
+count(map(arr, "b"), ok)
+count(map(arr, 0.5), ok)
+count(map(arr, a), ok)
+count(map(arr, add), ok)
+count(map(arr, arr), f == b)
+count(map(arr, arr), ok)
+count(map(arr, f), ok)
+count(map(arr, obj), 0 != b)
+count(map(arr, obj), f == f)
+count(map(arr, true), #)
+count(map(obj.obj, arr), ok)
+count(obj.head("b", arr, add), 0.5 == 0.5)
+count(obj.head(obj), nil == nil)
+count(obj.head(obj, obj, s), ok)
+count(obj.head(s), any(arr, false))
+count(obj.head(s, s, arr, add, obj), ok)
+count(obj.obj, 0 < 0)
+count(obj.obj, all(arr, false))
+count(obj.obj, b > 0)
+count(obj.obj, f != 0)
+count(obj.obj, nil == s)
+count(obj.obj, obj != nil)
+count(obj.obj, obj != obj)
+count(obj.obj, obj?.head(ok))
+count(obj.obj, ok)
+count(obj?.head("a", a), ok) != f
+count(obj?.head("c", a, obj), f == 0)
+count(obj?.head(s), ok)
+count(obj?.head(s, s), f <= a)
+count(obj?.obj, "c" >= "c")
+count(obj?.obj, 0 == nil)
+count(obj?.obj, a != nil)
+count(obj?.obj, a == 1)
+count(obj?.obj, f >= f)
+count(obj?.obj, none(arr, false))
+count(obj?.obj, obj.head(true))
+count(obj?.obj, obj?.head(false))
+count(obj?.obj, ok != true)
+count(obj?.obj, ok)
+count(values(obj), ok)
+count(values(obj), true and ok)
+date(s, s)
+div
+div != add
+div != add != true
+div != add ? 0.5 : ok
+div != add and 1 == f
+div != add or ok
+div != div
+div != div ? arr : b
+div != div ? false : false
+div != div and 0 >= 2
+div != div or obj?.a
+div != nil && obj.b
+div != nil == ok ? s : 0
+div != nil == true
+div != nil ? s : obj
+div != nil ? s : ok
+div != nil || obj?.obj
+div != obj.a
+div != obj.b
+div != obj.fn(a)
+div != obj.fn(b)
+div != obj.head(a)
+div != obj.head(div)
+div != obj.head(div, "b")
+div != obj.head(f, arr)
+div != obj.head(obj)
+div != obj.head(ok)
+div != obj.obj
+div != obj.obj.obj
+div != obj.obj?.a
+div != obj.obj?.obj
+div != obj?.a
+div != obj?.b
+div != obj?.head(add)
+div != obj?.head(arr)
+div != obj?.head(b, "a")
+div != obj?.head(div)
+div != obj?.head(f)
+div != obj?.head(s)
+div != obj?.head(s, arr, 1, true)
+div != obj?.obj
+div != obj?.obj.obj
+div != obj?.obj?.obj
+div == add
+div == add != obj?.obj
+div == add != ok
+div == add ? 0 : ok
+div == add or ok
+div == div
+div == div != obj.b
+div == div != obj?.b
+div == div != ok
+div == div == ok
+div == div ? 1 / f : obj
+div == div ? obj : div
+div == get(obj, s)
+div == nil ? "a" : "c"
+div == nil ? 0 : b
+div == nil ? a : true
+div == nil ? ok : arr
+div == nil or obj.obj
+div == nil or obj?.a
+div == nil || ok ? obj : true
+div == obj.a
+div == obj.b
+div == obj.head(a, b)
+div == obj.head(arr, nil, false, obj)
+div == obj.head(f)
+div == obj.head(f, a, nil)
+div == obj.head(obj)
+div == obj.head(ok)
+div == obj.head(true, obj)
+div == obj.obj
+div == obj.obj?.b
+div == obj?.a
+div == obj?.b
+div == obj?.head(arr)
+div == obj?.head(b)
+div == obj?.head(obj)
+div == obj?.head(ok)
+div == obj?.head(s)
+div == obj?.obj
+div == obj?.obj.a
+div == obj?.obj?.b
+div in map(arr, add)
+div in obj?.head(nil)
+div in obj[s]?.b
+div(-1, b)
+div(-a, a)
+div(-a, get(arr, 2))
+div(-a, obj.b)
+div(-b, a + 2)
+div(-b, a)
+div(-b, b)
+div(-obj.head(a, s), b)
+div(0 * a, a)
+div(0 * obj.b, a)
+div(0 - a, a)
+div(0, 1) != count(arr, false)
+div(0, 1) % b
+div(0, 1) + b ^ f
+div(0, 1) - b
+div(0, 2) ** b
+div(0, 2) < b
+div(0, 2) > obj.a
+div(0, 2) >= abs(0.5)
+div(0, a) != f
+div(0, a) * b
+div(0, a) .. obj.fn(b)
+div(0, a) < b
+div(0, a) <= b
+div(0, a) ^ a
+div(0, a) ^ f
+div(0, a) in arr
+div(0, b) != b
+div(0, b) + b
+div(0, b) + obj.a
+div(0, b) + obj?.a
+div(0, b) < a
+div(0, b) > b
+div(0, b) >= b
+div(1 - b, a)
+div(1, 2) % a
+div(1, 2) * f ** b
+div(1, 2) / -2
+div(1, 2) >= f
+div(1, a) ** b
+div(1, a) - b
+div(1, a) / obj?.a
+div(1, a) < a ? s : ok
+div(1, b) - obj.a
+div(1, b) - obj?.a
+div(1, b) > b
+div(2 % 1, min(1))
+div(2 * 0, a)
+div(2 * 2, obj?.b)
+div(2 + b, b)
+div(2, 2) * a
+div(2, a) + 1 ** 1
+div(2, a) == b ? obj : 0
+div(2, a) > obj?.a
+div(2, b) != obj?.obj
+div(2, b) % a
+div(2, b) ** a
+div(2, b) - b
+div(2, b) / a
+div(a % a, a)
+div(a % a, obj.b)
+div(a * 0, b)
+div(a * 2, b)
+div(a * b, obj.b)
+div(a * b, obj?.b)
+div(a - 1, b)
+div(a - 2, b)
+div(a - b, get(arr, 0))
+div(a, -2)
+div(a, -a)
+div(a, 0 + a)
+div(a, 1) % a
+div(a, 1) ** obj.a
+div(a, 1) - a
+div(a, 1) < b
+div(a, 1) < obj?.a
+div(a, 1) <= obj.b
+div(a, 1) == a
+div(a, 1) >= a * b
+div(a, 2) ** a
+div(a, 2) + obj.b
+div(a, 2) < a
+div(a, 2) <= f ? s : s
+div(a, 2) <= obj.b
+div(a, 2) == b
+div(a, 2) > obj.b
+div(a, 2) ^ obj?.a
+div(a, a * a)
+div(a, a - 0)
+div(a, a)
+div(a, a) != 0 ? a : add
+div(a, a) != obj?.b
+div(a, a) % b
+div(a, a) * obj?.b
+div(a, a) ** b
+div(a, a) - f
+div(a, a) .. b
+div(a, a) / get(arr, 0)
+div(a, a) <= 2 ? b : "b"
+div(a, a) == b
+div(a, a) > 0 ? div : s
+div(a, a) > a
+div(a, a) > f
+div(a, a) >= a
+div(a, a) >= b
+div(a, a) ^ -f
+div(a, a) ^ f
+div(a, abs(b))
+div(a, add(0, b))
+div(a, add(2, 0))
+div(a, add(a, 0))
+div(a, add(a, b))
+div(a, add(b, 0))
+div(a, b + 0)
+div(a, b)
+div(a, b) % a
+div(a, b) % b
+div(a, b) ** (a % 1)
+div(a, b) ** a
+div(a, b) ** f
+div(a, b) + div(a, b)
+div(a, b) + f ^ a
+div(a, b) .. a
+div(a, b) / a
+div(a, b) < obj?.a
+div(a, b) <= b
+div(a, b) ^ get(arr, a)
+div(a, div(a, 1))
+div(a, div(a, a))
+div(a, div(b, 1))
+div(a, div(b, b))
+div(a, false ? b : a)
+div(a, get(arr, a))
+div(a, get(arr, b))
+div(a, int(1))
+div(a, int(a))
+div(a, last(arr))
+div(a, len(s))
+div(a, max(2))
+div(a, min(a))
+div(a, obj.a)
+div(a, obj.b)
+div(a, obj.fn(0))
+div(a, obj.fn(b))
+div(a, obj.head(1, obj))
+div(a, obj.obj?.a)
+div(a, obj.obj?.b)
+div(a, obj?.a)
+div(a, obj?.b)
+div(a, obj?.head(b))
+div(a, true ? 2 : div)
+div(abs(a), b)
+div(abs(b), a)
+div(add(0, a), b)
+div(add(2, a), a)
+div(add(2, a), b)
+div(add(a, 0), max(a)) == a
+div(add(a, a), obj.b)
+div(add(a, b), -2)
+div(add(b, 0), a)
+div(add(b, b), obj?.b)
+div(arr[1], a * b)
+div(arr[b], div(b, b))
+div(b % a, a)
+div(b % a, obj.a)
+div(b % b, a)
+div(b % b, b)
+div(b * 0, obj.a)
+div(b * a, a)
+div(b * a, obj?.b)
+div(b, -a)
+div(b, 1) % obj.b
+div(b, 1) * max(a)
+div(b, 1) / a
+div(b, 1) >= 0 ^ f
+div(b, 2 * b)
+div(b, 2) ** add(b, a)
+div(b, 2) ** f
+div(b, 2) ** f ** 1
+div(b, 2) + float(0)
+div(b, 2) > b
+div(b, 2) in arr
+div(b, a + 0)
+div(b, a)
+div(b, a) != a + 0.5
+div(b, a) != obj?.a
+div(b, a) % b
+div(b, a) * 0 / b
+div(b, a) + a
+div(b, a) - f
+div(b, a) < a ^ f
+div(b, a) < obj.obj.obj.b
+div(b, a) <= a
+div(b, a) == obj?.obj
+div(b, a) > a
+div(b, a) >= 0 ? add : "a"
+div(b, a) >= obj.b
+div(b, a) ^ a
+div(b, a) in arr
+div(b, add(0, a))
+div(b, add(b, 2))
+div(b, b * a)
+div(b, b * b)
+div(b, b)
+div(b, b) != b
+div(b, b) != obj?.obj
+div(b, b) * -b
+div(b, b) ** a
+div(b, b) ** obj?.a
+div(b, b) + obj.b
+div(b, b) / a
+div(b, b) / obj?.a
+div(b, b) < f
+div(b, b) <= b
+div(b, b) <= b != nil
+div(b, b) == a
+div(b, b) == f
+div(b, b) > obj.a
+div(b, b) ^ -f
+div(b, b) ^ a
+div(b, div(b, a))
+div(b, get(arr, 0))
+div(b, int(a))
+div(b, last(arr))
+div(b, obj.a)
+div(b, obj.b)
+div(b, obj.fn(a))
+div(b, obj.head(a))
+div(b, obj.head(a, nil))
+div(b, obj.head(b))
+div(b, obj?.a)
+div(b, obj?.b)
+div(b, obj?.head(a))
+div(b, obj?.head(get(arr, 0)))
+div(b, ok ? b : s)
+div(count(arr, false), b)
+div(count(arr, ok), a)
+div(count(arr, ok), b)
+div(div(2, a), a)
+div(div(a, 2), a)
+div(div(a, a), b)
+div(div(b, b), add(b, 2))
+div(false ? arr : a, a)
+div(first(arr), b)
+div(first(arr), obj.b)
+div(get(arr, 0), b)
+div(get(arr, 2), obj.a)
+div(get(arr, a), a)
+div(get(arr, b), b)
+div(int(1 - f), b)
+div(int(b), a)
+div(int(b), obj.b)
+div(int(obj.a), b)
+div(last(arr), a)
+div(last(arr), b)
+div(len(obj), a)
+div(len(obj), obj.a)
+div(len(obj), obj.fn(a))
+div(len(s), max(2, a))
+div(max(1), b)
+div(max(b), b)
+div(max(b), obj.b)
+div(min(1), b)
+div(min(2), a)
+div(min(a), b)
+div(obj.a, -2)
+div(obj.a, a)
+div(obj.a, add(b, 1))
+div(obj.a, b)
+div(obj.a, obj.b)
+div(obj.a, obj?.a)
+div(obj.a, obj?.b)
+div(obj.b, a + 0)
+div(obj.b, a)
+div(obj.b, add(b, b))
+div(obj.b, b)
+div(obj.b, len("c"))
+div(obj.b, obj.b)
+div(obj.b, obj.head(2))
+div(obj.b, obj?.a)
+div(obj.b, obj?.b)
+div(obj.fn(2), a)
+div(obj.fn(a), b)
+div(obj.fn(b), 0 - a)
+div(obj.fn(b), b)
+div(obj.head(0, nil), b)
+div(obj.head(1), b)
+div(obj.head(a, arr), b + b)
+div(obj?.a, 1 * a)
+div(obj?.a, a)
+div(obj?.a, add(a, b))
+div(obj?.a, b)
+div(obj?.a, div(b, a))
+div(obj?.a, int(2))
+div(obj?.a, obj.a)
+div(obj?.a, obj.fn(2))
+div(obj?.a, obj?.a)
+div(obj?.a, obj?.b)
+div(obj?.b, -b)
+div(obj?.b, a)
+div(obj?.b, add(b, 0))
+div(obj?.b, b * 2)
+div(obj?.b, b * a)
+div(obj?.b, b)
+div(obj?.b, div(b, 1))
+div(obj?.b, obj.a)
+div(obj?.b, obj.b)
+div(obj?.b, obj.head(a, div, nil, nil, nil))
+div(obj?.b, obj?.a)
+div(obj?.b, obj?.b)
+div(obj?.fn(0), obj.a)
+div(obj?.fn(a), int(1))
+div(obj?.head(0), obj?.a)
+div(obj?.head(0, 0), a)
+div(obj?.head(0, add), b * a)
+div(obj?.head(0, b, a, f), obj.head(a))
+div(obj?.head(2), b)
+div(obj?.head(a), a)
+div(obj?.head(a, a, f, b), b)
+div(obj?.head(b, 2), get(arr, b))
+div(obj?.head(b, add, "c", 0.5), len(arr))
+div(obj?.head(b, b), obj?.a)
+div(ok ? 1 : a, a)
+div(true ? a : f, 0 + b)
+div(true ? b : 0.5, b)
+duration(string(0))
+duration(toJSON(0))
+f
+f != -0.5
+f != 0 % b
+f != 0 ? 1 : b
+f != 0 || obj?.b
+f != 0.5 ? arr : a
+f != 0.5 ? obj.b : arr
+f != 0.5 ^ a
+f != 0.5 and obj.head(div(add)).fn(add(obj && b, div(f), none(0.5, f), div(true, obj, true))?.head(s, arr))
+f != 0.5 and obj?.obj
+f != 1 * b
+f != 1 / 1
+f != 1 == ok
+f != 1 ? 0.5 : a
+f != 1 ? arr : "b"
+f != 2 != true
+f != 2 % b
+f != 2 / 0
+f != 2 / a
+f != 2 ^ 0
+f != a
+f != a != not ok
+f != a && ok
+f != a ** 0
+f != a - 0.5
+f != a - 2
+f != a / f
+f != a == nil
+f != a ? add : 0
+f != a ? obj : arr
+f != a ? obj.head(0.5, b, 0, obj, 0) : arr
+f != a and obj?.a
+f != abs(b)
+f != add(2, b)
+f != arr[0]
+f != arr[b]
+f != b
+f != b != obj.head(div)
+f != b % 2
+f != b % a
+f != b && obj.b
+f != b && s != "b"
+f != b ** b
+f != b + 0
+f != b ? b : false
+f != b ^ 0
+f != b ^ f
+f != b and ok ? 0 : nil
+f != b or b >= f
+f != b or obj.b.head(get(nil, add).b)?.obj
+f != f
+f != f && obj.obj
+f != f - 0
+f != f / b
+f != f ? a : s
+f != f ? s : "c"
+f != f ^ 0.5
+f != f and f >= f
+f != f || b <= a
+f != f || obj?.head("b")
+f != f || ok ? arr : 0
+f != get(arr, 0)
+f != get(arr, b)
+f != indexOf("a", s)
+f != int(a)
+f != max(0, f)
+f != nil != obj.b
+f != nil != ok
+f != nil == ok
+f != nil ? div : s
+f != nil and obj.obj
+f != obj.a
+f != obj.b
+f != obj.fn(b)
+f != obj.head("a", false)
+f != obj.head(0.5)
+f != obj.head(0.5, div)
+f != obj.head(1)
+f != obj.head(b, ok, false)
+f != obj.head(div, false, f, b)
+f != obj.head(ok)
+f != obj.obj
+f != obj.obj || ok
+f != obj.obj.a
+f != obj?.a
+f != obj?.b
+f != obj?.fn(a)
+f != obj?.head(0)
+f != obj?.head(a, "b", 0)
+f != obj?.head(arr, div, 0, div, 0)
+f != obj?.head(b)
+f != obj?.head(div)
+f != obj?.head(f, nil, f)
+f != obj?.head(false)
+f != obj?.head(get(obj, ok))
+f != obj?.head(nil)
+f != obj?.head(nil, add, f)
+f != obj?.head(nil, s)?.b
+f != obj?.head(obj?.obj)
+f != obj?.head(s)
+f != obj?.obj
+f != obj?.obj.obj
+f != obj?.obj?.a
+f * (0.5 - a)
+f * (a + 0)
+f * (b + b)
+f * (b - f)
+f * -(a + b)
+f * -0.5
+f * -f
+f * -obj?.b
+f * 0 ** 0
+f * 0 ** 1
+f * 0 == b ? div : f
+f * 0 >= obj.head(0, add, div)
+f * 0.5 != a
+f * 0.5 != f
+f * 0.5 * 2
+f * 0.5 / 1
+f * 0.5 / b
+f * 0.5 >= f ^ 0
+f * 0.5 ^ 0.5
+f * 1 * a
+f * 1 == b
+f * 2 - f * 0.5
+f * 2 >= a + a
+f * a
+f * a != obj?.b
+f * a + f
+f * a / (0 + f)
+f * a / (f + b)
+f * a / b
+f * a / f
+f * a / obj.fn(b)
+f * a < a
+f * a <= -0
+f * a == obj?.b
+f * a > a
+f * a ^ b
+f * abs(b)
+f * add(a, 0)
+f * arr[0]
+f * arr[a]
+f * b
+f * b != 0 + a
+f * b * f
+f * b / -a
+f * b / 0.5
+f * b / b ** b
+f * b == f
+f * b ^ 0
+f * f
+f * f != a
+f * f != b
+f * f != obj.a
+f * f + 0 ^ 0
+f * f == b
+f * f ^ a
+f * get(arr, a)
+f * int(0)
+f * int(f)
+f * min(0)
+f * obj.a
+f * obj.a < b
+f * obj.b
+f * obj.fn(a)
+f * obj.head(f)
+f * obj.obj.b
+f * obj.obj?.b
+f * obj?.a
+f * obj?.a ^ f
+f * obj?.b
+f * obj?.fn(0)
+f * obj?.head(0, a)
+f * obj?.obj.b
+f * obj?.obj?.a
+f ** (0 % a)
+f ** (0 % b)
+f ** (0.5 + f)
+f ** (0.5 / b)
+f ** (2 + a)
+f ** (2 + f)
+f ** (2 - f)
+f ** (2 / 0)
+f ** (2 / f)
+f ** (a * 0)
+f ** (a * 2)
+f ** (a * b)
+f ** (a + a)
+f ** (a - a)
+f ** (a - f)
+f ** (a / b)
+f ** (b * a)
+f ** (b + 1)
+f ** (b + b)
+f ** (b - a)
+f ** (b / 0)
+f ** (f * 0)
+f ** (f * f)
+f ** -0.5
+f ** 0 != f
+f ** 0 * obj?.a
+f ** 0 + obj?.head(b, add)
+f ** 0 / obj?.b
+f ** 0 < 0 * 0
+f ** 0 < f
+f ** 0 >= b
+f ** 0.5 != f
+f ** 0.5 - b
+f ** 0.5 / obj.fn(b)
+f ** 0.5 >= b
+f ** 0.5 ^ a
+f ** 1 != a
+f ** 1 / min(f)
+f ** 1 <= b
+f ** 2 * a
+f ** 2 ** 0
+f ** 2 - b
+f ** 2 ^ obj?.a
+f ** a
+f ** a ** 0 ** f
+f ** a < a / f
+f ** a <= b
+f ** a <= max(f)
+f ** a > obj.b
+f ** a >= b
+f ** a ^ b
+f ** add(1, a)
+f ** arr[0]
+f ** arr[add(1, a)]
+f ** arr[obj.a]
+f ** arr[obj?.head(b)]
+f ** b
+f ** b != 1 ** 2
+f ** b ** a
+f ** b ** f
+f ** b ** obj?.fn(b)
+f ** b + a / f
+f ** b / f
+f ** b < float(f)
+f ** b <= b
+f ** b <= f
+f ** b > b
+f ** f
+f ** f != b / 0
+f ** f - f
+f ** f > b
+f ** f >= a
+f ** f ^ 1
+f ** get(arr, a)
+f ** int(f)
+f ** len(arr) <= a
+f ** max(b, 1)
+f ** min(a)
+f ** obj.a
+f ** obj.b
+f ** obj.head(0)
+f ** obj.head(add(0, b))
+f ** obj.obj.b
+f ** obj?.a
+f ** obj?.b
+f ** obj?.fn(a)
+f ** obj?.head(2, s)
+f ** obj?.head(a)
+f ** obj?.head(b, add, obj)
+f ** obj?.obj.a
+f + -0.5
+f + -f
+f + 0 + a
+f + 0 - b
+f + 0 < a
+f + 0 == a
+f + 0 == add(b, b)
+f + 0.5 * b
+f + 0.5 - b
+f + 0.5 <= a
+f + 0.5 ^ 1
+f + 1 ** b
+f + 1 - f
+f + 1 >= obj?.b
+f + 2 < obj.b
+f + 2 == b
+f + 2 >= max(b)
+f + a
+f + a != last(arr)
+f + a * 2
+f + a + 2
+f + a / 0
+f + a >= obj?.a
+f + a ^ a
+f + a ^ f
+f + add(b, 2)
+f + add(b, a)
+f + b
+f + b != a
+f + b ** 2
+f + b ** b
+f + b + 2
+f + b + b
+f + b - a
+f + b - f
+f + b ^ 2
+f + count(arr, false)
+f + div(2, 1)
+f + div(b, a)
+f + div(b, b)
+f + f
+f + f != f
+f + f + 1
+f + f + a
+f + f + a ** 0
+f + f - b
+f + f / 2
+f + f / a
+f + f < f
+f + f > b
+f + float(0)
+f + get(arr, a)
+f + int(b)
+f + len("a")
+f + min(0.5)
+f + obj.a
+f + obj.b
+f + obj.head(0.5)
+f + obj.head(f)
+f + obj.obj.obj.b
+f + obj.obj?.a
+f + obj?.a
+f + obj?.b
+f + obj?.b .. a
+f + obj?.fn(0)
+f + obj?.fn(b)
+f + obj?.obj.a
+f + obj?.obj?.a
+f - -f
+f - 0 != a
+f - 0 * a
+f - 0 ** a
+f - 0 + a
+f - 0 - 2
+f - 0 >= a % a
+f - 0.5 != b
+f - 0.5 ** b
+f - 1 - a
+f - 1 == 0 ? arr : f
+f - 1 > obj?.b
+f - 2 + 1
+f - 2 >= f
+f - a
+f - a % a
+f - a + 0
+f - a + b
+f - a - a
+f - a < b
+f - a < obj.fn(b)
+f - a < obj?.b
+f - a > b ** a
+f - a >= b
+f - add(b, b)
+f - arr[1]
+f - arr[b]
+f - arr[obj?.a]
+f - b
+f - b != b
+f - b * f
+f - b + f
+f - b + obj.head(b)
+f - b - b
+f - b / a
+f - b / b
+f - b < 0 ? 1 : 0
+f - b <= abs(a)
+f - b <= b - 0.5
+f - b == obj.obj
+f - b > f
+f - b >= a ? div : ok
+f - b >= f
+f - div(a, b)
+f - f
+f - f + a
+f - f - div(a, b)
+f - f / 2
+f - f / b
+f - f < a
+f - f <= obj.a
+f - f == b
+f - f == div(0, a)
+f - float(1)
+f - float(f)
+f - get(arr, b)
+f - int(0)
+f - int(2)
+f - obj.a
+f - obj.b
+f - obj.head(b)
+f - obj.obj.a
+f - obj.obj.obj.a
+f - obj.obj?.b
+f - obj?.a
+f - obj?.b
+f - obj?.head(f)
+f - obj?.head(f, a, add)
+f - obj?.obj.b
+f / (0 - f)
+f / (0.5 + b)
+f / (1 + 2)
+f / (2 + 0)
+f / (a + b)
+f / (a + f)
+f / (b + f)
+f / (b - f)
+f / (f - a)
+f / -a
+f / -b
+f / -f
+f / 0 * 0
+f / 0 * f
+f / 0 + obj?.b
+f / 0 / a
+f / 0.5 != b
+f / 0.5 * obj?.a
+f / 0.5 - a
+f / 0.5 - b
+f / 0.5 == obj?.b
+f / 1 != obj?.obj?.a
+f / 1 / b
+f / 2 != nil ? 0.5 : 0
+f / 2 / obj?.b
+f / 2 == obj?.b
+f / 2 >= f
+f / a
+f / a != a
+f / a != b - 1
+f / a != obj.b
+f / a != obj?.b
+f / a ** 0
+f / a - f
+f / a < 2 ** f
+f / a <= b
+f / a == a
+f / a == b
+f / a >= b ^ a
+f / a >= obj?.b
+f / add(a, 0)
+f / add(a, 2)
+f / add(a, b)
+f / add(b, a)
+f / b
+f / b != add(0, 1)
+f / b * 0
+f / b * b
+f / b ** 0.5
+f / b / a
+f / b <= b / a
+f / b <= f
+f / b == b
+f / b > a
+f / f
+f / f != obj.obj?.b
+f / f * 0
+f / f ** a
+f / f + add(2, b)
+f / f - -a
+f / f - a ^ a
+f / f - f
+f / f < a
+f / float(0)
+f / int(b)
+f / len(s)
+f / min(0)
+f / obj.a
+f / obj.b
+f / obj.fn(a)
+f / obj.head(b)
+f / obj.obj.a
+f / obj.obj?.a
+f / obj?.a
+f / obj?.b
+f / obj?.fn(0)
+f / obj?.fn(1)
+f / obj?.fn(2)
+f / obj?.fn(a)
+f / obj?.head(a, nil)
+f / obj?.head(f)
+f / obj?.head(f, nil)
+f / obj?.obj?.b
+f < -0
+f < -0.5
+f < 0 * b
+f < 0 - 0
+f < 0 == false
+f < 0 ? obj : add
+f < 0 ^ b
+f < 0 and obj.a
+f < 0 or 0.5 != b
+f < 0.5 == obj?.b
+f < 0.5 == obj?.head("a", div)
+f < 0.5 ? b : "b"
+f < 0.5 ? nil : add
+f < 0.5 ? obj : ok
+f < 1 != nil
+f < 1 * obj.a
+f < 2 - b
+f < 2 / 0.5
+f < a
+f < a && obj.b
+f < a && ok
+f < a ** b
+f < a + 1
+f < a / f
+f < a ? add : div
+f < a ? s : "c"
+f < a or obj?.a
+f < a or ok
+f < arr[0]
+f < b
+f < b != ok
+f < b - 0
+f < b ? a : a
+f < b ? a : f
+f < b ^ 0
+f < b ^ a
+f < b and f < 0.5
+f < b or nil == div
+f < div(a, a)
+f < div(a, b)
+f < f
+f < f != false
+f < f && obj.a
+f < f * 0
+f < f * 0.5
+f < f - 0
+f < f - b
+f < f == nil
+f < f == true
+f < f ? 0 : nil
+f < f ? 0.5 : a
+f < f ^ f
+f < f and obj.obj
+f < f or obj.b
+f < f or obj?.b
+f < float(0)
+f < float(b)
+f < float(f)
+f < get(arr, 0)
+f < get(arr, b)
+f < len(obj)
+f < min(0 % b)
+f < min(a)
+f < obj.a
+f < obj.b
+f < obj.fn(a)
+f < obj.head(0, arr, add, b)
+f < obj.head(b, b)
+f < obj.head(obj.b) and ok
+f < obj.obj?.a
+f < obj.obj?.b ^ f
+f < obj?.a
+f < obj?.b
+f < obj?.fn(b)
+f < obj?.head(0.5, true, add)
+f < obj?.head(a)
+f <= -a
+f <= -b
+f <= -f
+f <= 0 % b
+f <= 0 * 0
+f <= 0 ? "a" : "c"
+f <= 0 ? b : a
+f <= 0 ^ b
+f <= 0 and obj.obj
+f <= 0.5 ** b
+f <= 0.5 - b
+f <= 0.5 / a
+f <= 0.5 ? false : div
+f <= 0.5 ? obj : 0
+f <= 0.5 ^ 1
+f <= 0.5 and obj?.head(false)
+f <= 1 ** 0
+f <= 1 ** f
+f <= 1 - 2
+f <= 2 != false
+f <= 2 ? div : nil
+f <= 2 ? f : nil
+f <= a
+f <= a != ok
+f <= a % a
+f <= a && "c" <= s
+f <= a + 0
+f <= a / a
+f <= a / b
+f <= a ? 1 : 2
+f <= a and b == a
+f <= a or ok ? s : s
+f <= a || obj.fn(add)
+f <= add(2, b)
+f <= add(a, b)
+f <= arr[a]
+f <= arr[b]
+f <= arr[div(a, a)]
+f <= b
+f <= b != ok
+f <= b != true
+f <= b && ok
+f <= b * a
+f <= b == nil
+f <= b ? arr : add
+f <= b ? b : 2 != a
+f <= b ^ b
+f <= div(a, 1)
+f <= f
+f <= f - a
+f <= f - obj?.b
+f <= f / f
+f <= f ? a : div
+f <= f ? nil : true
+f <= f ^ a
+f <= f ^ b
+f <= f and obj.obj
+f <= f or false ? nil : s
+f <= f or ok
+f <= f || obj?.fn(s, 2)?.obj.fn(b)
+f <= float(f)
+f <= get(arr, b)
+f <= int(a)
+f <= last(arr)
+f <= obj.a
+f <= obj.a ** b
+f <= obj.b
+f <= obj.fn(0)
+f <= obj.head(0, nil)
+f <= obj?.a
+f <= obj?.b
+f <= obj?.head(a)
+f <= obj?.obj.a
+f <= obj?.obj?.b
+f == -0
+f == -b
+f == 0 ? b >= 1 : div
+f == 0 ? false : s
+f == 0.5 == ok
+f == 0.5 ? add : add
+f == 1 * 0
+f == 1 ** 0.5
+f == 1 ** b
+f == 1 / a
+f == 1 / f
+f == 1 ? true : "c"
+f == 2 ? ok : a
+f == a
+f == a != ok
+f == a * 0
+f == a * b
+f == a + a
+f == a and b < 2
+f == a and obj.head(obj, add)
+f == a || obj?.obj
+f == abs(b)
+f == add(b, 0)
+f == arr[b]
+f == b
+f == b != false
+f == b ** 0
+f == b + 0.5
+f == b + b
+f == b - 0
+f == b - 2
+f == b == nil
+f == b and obj?.b
+f == b or not ok
+f == div(a, b)
+f == div(b, b)
+f == f
+f == f != nil
+f == f ? arr : b
+f == f ^ 0
+f == f ^ a
+f == int(a)
+f == int(b)
+f == max(0)
+f == max(a)
+f == max(b)
+f == nil && obj?.fn(count(s == 0, "b" matches div))
+f == nil && ok ? f : obj
+f == nil == true ? obj : add
+f == nil ? arr : add
+f == nil ? nil == div : a
+f == nil and obj.fn(s)
+f == nil and ok
+f == nil || obj?.obj
+f == obj.a
+f == obj.b
+f == obj.b == ok
+f == obj.head(1)
+f == obj.head(2 != ok)
+f == obj.head(b)
+f == obj.head(f)
+f == obj.head(obj == div)
+f == obj.head(obj)
+f == obj.head(ok)
+f == obj.head(s)
+f == obj.obj
+f == obj.obj.obj
+f == obj.obj?.obj
+f == obj.obj?.obj?.b
+f == obj.obj?.obj?.obj
+f == obj?.a
+f == obj?.a % b
+f == obj?.b
+f == obj?.fn(0)
+f == obj?.head(b < 0)
+f == obj?.head(b, add)
+f == obj?.head(div)
+f == obj?.head(div, b, 2, b)
+f == obj?.obj
+f == obj?.obj.b
+f == {"a": b, "b": add, "a": arr}.obj
+f > -1
+f > -a
+f > -b
+f > -f
+f > 0 / f
+f > 0.5 ** 1
+f > 0.5 == ok
+f > 0.5 or not ok
+f > 0.5 or obj?.a
+f > 1 != ok
+f > 1 && s <= s
+f > 2 != false
+f > 2 - a
+f > 2 == obj.b
+f > a
+f > a != obj.b
+f > a * a
+f > a + 0
+f > a + f
+f > a / 0.5
+f > a ? arr : "c"
+f > a ? div : obj
+f > a ? f : obj?.obj
+f > a || div == nil
+f > a || true ? 1 : arr
+f > abs(a)
+f > add(b, 0)
+f > add(b, b)
+f > arr[a]
+f > arr[obj?.head(0.5)]
+f > b
+f > b && "a" <= "b"
+f > b ** 0
+f > b ** b
+f > b ** obj?.a
+f > b + 0
+f > b + 1
+f > b == ok
+f > b ? obj : f
+f > b || obj.head(0)
+f > count(arr, true)
+f > div(2, a)
+f > f
+f > f * b
+f > f ** 2
+f > f - a
+f > f / a
+f > f ? obj : nil
+f > f ^ b
+f > f in obj?.head(nil, "c")
+f > f or obj.head(nil)
+f > f or obj?.head(obj)
+f > int(0)
+f > len(obj)
+f > obj.a
+f > obj.b
+f > obj.fn(b)
+f > obj.obj.b
+f > obj.obj?.a
+f > obj.obj?.b
+f > obj?.a
+f > obj?.b
+f > obj?.fn(a)
+f > obj?.fn(b)
+f > obj?.head(a)
+f > obj?.obj.a
+f > obj?.obj?.obj?.b
+f >= -0
+f >= -1
+f >= -a
+f >= 0 != obj?.head(s, f)
+f >= 0 ** b
+f >= 0 + f
+f >= 0 - 0
+f >= 0 / b
+f >= 0 == ok
+f >= 0 ? nil : div
+f >= 0.5 != false
+f >= 0.5 ^ a
+f >= 1 * b
+f >= 1 ? a : add
+f >= 1 ? add : true
+f >= 1 ? obj : 1
+f >= 1 ^ a
+f >= 2 ^ a
+f >= a
+f >= a % b
+f >= a * a
+f >= a ? 0 : arr
+f >= a and obj?.head(a)
+f >= a in obj?.c
+f >= a or ok
+f >= add(a, a)
+f >= arr[b]
+f >= b
+f >= b != ok
+f >= b % 2
+f >= b && ok
+f >= b ** a
+f >= b + 2
+f >= b + a
+f >= b / a
+f >= b == false
+f >= b == obj.a
+f >= b ? s : div
+f >= b ^ a
+f >= b and obj?.b
+f >= count(arr, ok)
+f >= div(2, a)
+f >= div(b, b)
+f >= f
+f >= f && false ? f : a
+f >= f && ok
+f >= f * 0
+f >= f * 0.5
+f >= f ** 0
+f >= f ** a
+f >= f == ok
+f >= f == true
+f >= f ? "b" : 0
+f >= f ? b : f
+f >= first(arr)
+f >= float(b)
+f >= get(arr, a)
+f >= obj.a
+f >= obj.b
+f >= obj.fn(2)
+f >= obj.head(0.5, nil)
+f >= obj.head(a)
+f >= obj.head(b, add)
+f >= obj.obj.b
+f >= obj.obj?.b
+f >= obj?.a
+f >= obj?.b
+f >= obj?.b && ok
+f >= obj?.head(obj, b, 1)?.a
+f >= obj?.obj.b
+f >= obj?.obj?.a
+f ^ (0 + 1)
+f ^ (0 + a)
+f ^ (0 - b)
+f ^ (0.5 * a)
+f ^ (1 / a)
+f ^ (2 - b)
+f ^ (a * 0.5)
+f ^ (a * b)
+f ^ (a + a)
+f ^ (a + b)
+f ^ (a - f)
+f ^ (a / a)
+f ^ (b + 0)
+f ^ (f * f)
+f ^ (f / 0.5)
+f ^ -0
+f ^ -2
+f ^ -a
+f ^ 0 ** obj?.b
+f ^ 0 <= f
+f ^ 0 == a
+f ^ 0 >= obj.a
+f ^ 0 ^ 1
+f ^ 0.5 ** a
+f ^ 0.5 ** b
+f ^ 0.5 ** f
+f ^ 0.5 ** obj?.head(0, arr)
+f ^ 0.5 < a
+f ^ 0.5 ^ 0
+f ^ 0.5 ^ 0.5
+f ^ 0.5 ^ f
+f ^ 1 * a
+f ^ 1 ** 2
+f ^ 1 > a
+f ^ 1 > b ? nil : a
+f ^ 2 + div(a, 1)
+f ^ a
+f ^ a != obj.a
+f ^ a - a
+f ^ a <= b
+f ^ a == obj?.b
+f ^ a > a
+f ^ a > f
+f ^ a > obj.b
+f ^ a ^ obj?.b
+f ^ abs(b)
+f ^ abs(f)
+f ^ b
+f ^ b ** b ** obj?.b
+f ^ b + f
+f ^ b >= a + a
+f ^ div(b, 2)
+f ^ f
+f ^ f != b
+f ^ f * a
+f ^ f ** b
+f ^ f ** f
+f ^ f - b
+f ^ f / 0 ^ 2
+f ^ f / b
+f ^ f < b * b
+f ^ f <= 0.5 * b
+f ^ f >= f
+f ^ f ^ (b % a)
+f ^ f ^ abs(a)
+f ^ max(b)
+f ^ min(b, 2 * 2)
+f ^ obj.a
+f ^ obj.b
+f ^ obj.fn(0)
+f ^ obj.head(0.5, true)
+f ^ obj.head(f)
+f ^ obj.obj?.a
+f ^ obj?.a
+f ^ obj?.b
+f ^ obj?.obj.a
+f in get(obj.b, b)
+f in get(obj?.head(ok), s >= "c")
+f in map(arr, f)
+f in obj?.c
+f in obj?.head(get(f, obj))?.obj
+f in obj[nil]
+false != nil ? add : f
+false != nil ? f : ok
+false != obj.a
+false != obj.b
+false != obj.head(b)
+false != obj.head(ok)
+false != obj.obj
+false != obj.obj.b
+false != obj.obj?.a
+false != obj.obj?.obj
+false != obj?.a
+false != obj?.b
+false != obj?.head(add)
+false != obj?.obj
+false != obj?.obj.obj
+false != obj?.obj?.b
+false != ok or ok
+false != true or obj?.fn(0, nil)
+false && false && obj.b
+false && obj.a
+false && obj.b
+false && obj.fn(0 / div)
+false && obj.fn(add(f))
+false && obj.fn(filter(div .. obj, add.b), arr)
+false && obj.fn(obj)?.b
+false && obj.fn(ok?.b.a)
+false && obj.head(add?.b, add(b, f, s, add) contains add(arr, "a"))
+false && obj.head(any(ok, "c"))
+false && obj.head(div(0), duration(s, a, add))
+false && obj.head(div(filter(nil, arr), get(ok, nil)))
+false && obj.head(f?.obj, toBase64(nil, add, false))
+false && obj.head(none(arr, true), "a" / obj)
+false && obj.head(ok.fn(obj?.b, 0.5 endsWith obj))
+false && obj.obj
+false && obj?.a
+false && obj?.b
+false && obj?.b?.obj
+false && obj?.fn(add?.fn(map(b, 1)))
+false && obj?.fn(b - f <= div(0.5, "c"))
+false && obj?.fn(count(0, a)?.obj, arr?.head(nil) in div(true, 0, f), lastIndexOf(filter(nil, 0)), b?.head(none(0, obj), nil <= div, a .. s, "b" ** arr))
+false && obj?.fn(f * s ? nil : nil)
+false && obj?.head(a)
+false && obj?.head(a.obj)
+false && obj?.head(add(0, s)?.obj, arr startsWith div?.b)
+false && obj?.head(add(nil - b))
+false && obj?.head(add)
+false && obj?.head(all(0.5, ok), count(f, ok), f ? a : 0)
+false && obj?.head(all(f, add) && count("c", b), add.head(arr?.obj))
+false && obj?.obj
+false && obj[obj.fn(obj)]
+false && ok && obj.obj
+false && ok && obj[nil]
+false == nil == obj.a
+false == nil and obj.obj
+false == nil or ok
+false == obj.a
+false == obj.b
+false == obj.head(arr)
+false == obj.head(ok)
+false == obj.obj
+false == obj.obj?.a
+false == obj?.a
+false == obj?.b
+false == obj?.head(ok)
+false == obj?.obj
+false ? "b" : 0 >= obj.b
+false ? "c" : 0 / b
+false ? 0 : obj.a
+false ? 0 : obj.b
+false ? 0 : obj.obj
+false ? 0 : obj?.head(arr)
+false ? 0 : obj?.obj
+false ? 0.5 : a <= 0 + b
+false ? 0.5 : b / f
+false ? 0.5 : f * a
+false ? 0.5 : obj.obj
+false ? 0.5 : obj?.obj
+false ? 1 : obj.a
+false ? 1 : obj.b
+false ? 1 : obj?.obj
+false ? 2 : obj.obj
+false ? 2 : obj?.a
+false ? 2 : obj?.obj
+false ? a : 1 > min(f, f)
+false ? a : a != f
+false ? a : f + b
+false ? a : obj?.a
+false ? a : obj?.obj
+false ? a : true or obj?.b
+false ? add : a / a
+false ? add : f != a
+false ? add : obj.a
+false ? add : obj.b
+false ? add : obj?.a
+false ? add : obj?.b
+false ? add : obj?.obj
+false ? arr : 0 == a ^ 0.5
+false ? arr : obj.obj
+false ? arr : obj?.a
+false ? arr : obj?.b
+false ? b : 0 >= 0.5 - f
+false ? b : obj.b
+false ? b : obj.obj
+false ? b : obj.obj?.obj
+false ? b : obj?.a
+false ? b : obj?.obj
+false ? div : 1 - a
+false ? div : f * (2 - 2)
+false ? div : obj.a
+false ? div : obj.b
+false ? div : obj.obj
+false ? div : obj?.b
+false ? f : a ** f
+false ? f : obj.a
+false ? f : obj.obj
+false ? f : obj?.a
+false ? f : obj?.obj
+false ? false : obj.a
+false ? false : obj.obj
+false ? false : obj?.obj
+false ? nil : 0.5 ^ b
+false ? nil : 2 == a ? 0.5 : "b"
+false ? nil : obj.obj
+false ? nil : obj?.b
+false ? obj : 0.5 + b
+false ? obj : 2 != f ^ f
+false ? obj : a - b
+false ? obj : b <= add(0, b)
+false ? obj : obj?.a
+false ? obj : obj?.obj
+false ? ok : 0.5 > f ^ a
+false ? ok : b <= a
+false ? ok : b <= f
+false ? ok : b == a ? true : b
+false ? ok : obj?.a
+false ? s : 1 != obj.b
+false ? s : obj.b
+false ? s : obj?.a
+false ? true : obj.b
+false ? true : obj?.b
+false and false and obj.obj
+false and obj.a
+false and obj.a.obj
+false and obj.a?.b
+false and obj.b
+false and obj.b.a
+false and obj.fn((obj or b) + ok.fn(b, a))
+false and obj.fn(add?.a >= add(arr))
+false and obj.fn(any(obj, f startsWith obj))
+false and obj.fn(arr endsWith obj.obj)
+false and obj.fn(div(add?.obj), div.b != add)
+false and obj.fn(div, div(obj).a, a == div >= div(0.5, f))
+false and obj.fn(one(s, obj).b)
+false and obj.head("c" <= b, b, ok / obj)
+false and obj.head(any(arr, b))
+false and obj.head(div(nil, s)?.b)
+false and obj.head(div?.a)
+false and obj.head(get(false, obj))
+false and obj.head(s.head(arr), all(f, ok))?.b
+false and obj.obj
+false and obj?.a
+false and obj?.a?.a
+false and obj?.b
+false and obj?.b?.fn(all(map(a, get(add, 1)), !s[b]), lower(f) % f)
+false and obj?.b?.head(map(b, 0.5 - 1))
+false and obj?.b?.head(obj[ok].obj.b)
+false and obj?.b?.obj
+false and obj?.fn(a + a == div(0.5, obj, ok, div))
+false and obj?.fn(div or obj)
+false and obj?.head((ok or 0) in b.a, 0.5 / a.obj)
+false and obj?.head(1 != a)
+false and obj?.head(a && b)
+false and obj?.head(a)
+false and obj?.head(add && a, map(true, ok))
+false and obj?.head(add(1, false, 1, b))
+false and obj?.head(any(b, 0))
+false and obj?.head(arr <= f, ok.head(ok, "a", ok), arr, arr && ok)
+false and obj?.head(b <= add)
+false and obj?.head(f)
+false and obj?.head(ok.b or div endsWith div, div)
+false and obj?.head(s.head(b, false, s)?.a)
+false and obj?.head(toBase64(add))
+false and obj?.obj
+false and obj?.obj || obj?.b
+false and ok ? obj?.head(obj) : obj
+false and ok and obj.obj
+false or false or obj?.a
+false or obj.a
+false or obj.b
+false or obj.head(b)
+false or obj.obj
+false or obj.obj.a
+false or obj.obj.obj
+false or obj.obj?.obj
+false or obj?.a
+false or obj?.b
+false or obj?.fn(obj?.head(0, "b", b, 0))
+false or obj?.head(arr)
+false or obj?.head(s, arr)
+false or obj?.obj
+false or obj?.obj?.b
+false or ok ? f : div
+false or ok or obj?.obj
+false or true or obj.a
+false || false || true ? obj : 0
+false || obj.a
+false || obj.a == a
+false || obj.b
+false || obj.head(b)
+false || obj.obj
+false || obj?.a
+false || obj?.b
+false || obj?.fn(a)
+false || obj?.fn(b)
+false || obj?.obj
+false || true or obj?.obj
+filter(0 .. b, ok)
+filter(a .. a, 2 < f)
+filter(a .. b, ok)
+filter(arr, !false)
+filter(arr, !ok)
+filter(arr, "a" <= "c")
+filter(arr, "a" > "b")
+filter(arr, "a" endsWith s)
+filter(arr, "b" > "a")
+filter(arr, "c" > s)
+filter(arr, 0 == f)
+filter(arr, 0.5 != b)
+filter(arr, 0.5 < 0.5)
+filter(arr, 0.5 == 1)
+filter(arr, 1 == nil)
+filter(arr, 1 in arr)
+filter(arr, 2 < obj?.b)
+filter(arr, 2 > 2)
+filter(arr, 2 > a)
+filter(arr, a != nil)
+filter(arr, a < a)
+filter(arr, a <= 0)
+filter(arr, a > obj.b)
+filter(arr, a >= f)
+filter(arr, add == add)
+filter(arr, add == div)
+filter(arr, any(arr, ok))
+filter(arr, any(arr, true))
+filter(arr, arr == arr)
+filter(arr, b < 0)
+filter(arr, b < 0.5)
+filter(arr, b < b)
+filter(arr, b <= b)
+filter(arr, b > f)
+filter(arr, b >= a)
+filter(arr, f != nil)
+filter(arr, f != obj.obj)
+filter(arr, f < 0)
+filter(arr, f < f)
+filter(arr, f == b)
+filter(arr, f == nil)
+filter(arr, false) == arr
+filter(arr, false) == nil ? 2 : ok
+filter(arr, nil != add)
+filter(arr, nil != div)
+filter(arr, nil == "a")
+filter(arr, nil == a)
+filter(arr, nil == div)
+filter(arr, nil == false)
+filter(arr, nil == s)
+filter(arr, none(map(arr, 0), ok))
+filter(arr, not ok)
+filter(arr, obj.head(ok, "b"))
+filter(arr, obj?.head(false))
+filter(arr, obj?.head(ok))
+filter(arr, ok && ok)
+filter(arr, ok && true)
+filter(arr, ok == true)
+filter(arr, ok or ok)
+filter(arr, ok || ok)
+filter(arr, ok)
+filter(arr, ok) != b .. 1
+filter(arr, s == nil)
+filter(arr, s matches s)
+filter(arr, s startsWith "c")
+filter(arr[2:0], ok)
+filter(b .. 1, obj.obj)
+filter(b .. a, nil != a)
+filter(false ? a : arr, s != nil)
+filter(filter(arr, ok), 0.5 != nil)
+filter(filter(arr, ok), ok)
+filter(filter(arr, true), a <= 0)
+filter(keys(obj), ok)
+filter(map(arr, 0), s != s)
+filter(map(arr, 0.5), f != nil)
+filter(map(arr, 1), a != 2)
+filter(map(arr, add), ok)
+filter(map(arr, arr), ok)
+filter(map(arr, b), !ok)
+filter(map(arr, b), ok)
+filter(map(arr, div), add != add)
+filter(map(arr, div), ok)
+filter(map(arr, ok), #)
+filter(map(arr, ok), ok)
+filter(map(arr, s), ok)
+filter(map(obj?.obj, a == a), #)
+filter(obj.head(s), ok)
+filter(obj.obj, "b" endsWith s)
+filter(obj.obj, f < f)
+filter(obj.obj, s in obj)
+filter(obj?.head("b"), ok)
+filter(obj?.head("c"), ok)
+filter(obj?.head(s), ok)
+filter(obj?.head(s, s), ok)
+filter(ok ? "c" : true, ok)
+filter(ok ? arr : obj, a in arr)
+filter(ok ? s : arr, b in arr)
+filter(ok ? s : true, nil != f)
+filter(true ? arr : add, not true)
+filter(true ? arr : f, b == nil)
+first(0 .. 0)
+first(2 .. b)
+first([ok])
+first(a * obj?.b)
+first(a .. 0)
+first(a .. 1)
+first(a .. 2)
+first(a .. a)
+first(arr)
+first(arr) != a
+first(arr) != max(2, a)
+first(arr) != obj.b
+first(arr) % a
+first(arr) * f
+first(arr) ** -0.5
+first(arr) - 0 / a
+first(arr) - f ** a
+first(arr) .. obj.fn(b)
+first(arr) > f
+first(arr) ^ a
+first(arr[b:0])
+first(b * obj?.a)
+first(b .. 1)
+first(b .. b)
+first(false ? "a" : 0.5)
+first(false ? add : 1)
+first(false ? add : true)
+first(false ? b : arr)
+first(false ? false : "a")
+first(filter(arr, false))
+first(filter(arr, ok))
+first(filter(arr, true))
+first(get(obj, s))
+first(keys(obj))
+first(map(arr, "c"))
+first(map(arr, 0.5))
+first(map(arr, a))
+first(map(arr, add))
+first(map(arr, arr))
+first(map(arr, b))
+first(map(arr, div))
+first(map(arr, f))
+first(map(arr, false))
+first(map(arr, obj))
+first(map(arr, ok))
+first(map(arr, s))
+first(obj.a)
+first(obj.a)?.a
+first(obj.b)
+first(obj.b)?.a
+first(obj.fn(0))
+first(obj.fn(a))
+first(obj.fn(a))?.b
+first(obj.fn(b))
+first(obj.head("a"))
+first(obj.head("b"))
+first(obj.head(0.5))
+first(obj.head(0.5, add))
+first(obj.head(1))
+first(obj.head(1, 0, true))
+first(obj.head(1, add, add))
+first(obj.head(2, div))
+first(obj.head(a))
+first(obj.head(a, arr))
+first(obj.head(add, obj, div))
+first(obj.head(arr, "b")) == add
+first(obj.head(arr, 0, nil))
+first(obj.head(b))
+first(obj.head(b, "c"))
+first(obj.head(b, a))
+first(obj.head(b, a, 0))
+first(obj.head(b, s))
+first(obj.head(div))
+first(obj.head(f))
+first(obj.head(f, false, 0, a))
+first(obj.head(nil))
+first(obj.head(nil, 0))
+first(obj.head(obj, a)?.a)
+first(obj.head(ok))
+first(obj.head(ok, add, b))
+first(obj.head(s))
+first(obj.head(s, 0))
+first(obj.head(s, add))
+first(obj.head(s, div, f, add))
+first(obj.head(s, ok, add))
+first(obj.head(true))
+first(obj.obj)
+first(obj?.a)
+first(obj?.a)?.obj
+first(obj?.b)
+first(obj?.fn(0 + a))
+first(obj?.fn(0))
+first(obj?.fn(a))
+first(obj?.fn(b))
+first(obj?.head("a", false))
+first(obj?.head("b"))
+first(obj?.head("c", f))
+first(obj?.head(0))
+first(obj?.head(1))
+first(obj?.head(2))
+first(obj?.head(a))
+first(obj?.head(a, div))
+first(obj?.head(a, f))
+first(obj?.head(a, f, div, "b", a))
+first(obj?.head(a, f, nil))
+first(obj?.head(add))
+first(obj?.head(add, nil, f))?.obj
+first(obj?.head(arr))
+first(obj?.head(b))
+first(obj?.head(b, "b", false, add))
+first(obj?.head(b, s, div))
+first(obj?.head(div))
+first(obj?.head(f))
+first(obj?.head(false, nil, a, obj, f))
+first(obj?.head(get(s, obj)))
+first(obj?.head(nil))
+first(obj?.head(nil, f))
+first(obj?.head(obj))
+first(obj?.head(obj, f, 2).a)
+first(obj?.head(obj, nil, s))
+first(obj?.head(ok))
+first(obj?.head(ok, b))
+first(obj?.head(true))
+first(obj?.obj)
+first(obj?.obj.a)
+first(obj?.obj?.obj)
+first(obj[nil])
+first(obj[s])
+first(ok ? a : ok)
+first(ok ? obj : "b")
+first(ok ? obj : false)
+first(ok ? obj : ok)
+first(ok ? ok : s)
+first(ok ? s : ok)
+first(split(s, s))
+first(true ? arr : false)
+first(values(obj))
+float(-(f * 0))
+float(-0)
+float(-0.5)
+float(-1)
+float(-2)
+float(-a)
+float(-add(b, a))
+float(-b)
+float(-f)
+float(0 * a)
+float(0 * b)
+float(0 * f)
+float(0 ** 0)
+float(0 + 2)
+float(0 + b)
+float(0 - 0.5)
+float(0 - b)
+float(0 - f)
+float(0 / b)
+float(0 / f)
+float(0 ^ 0)
+float(0 ^ 0.5)
+float(0 ^ a)
+float(0 ^ f)
+float(0) != b ** a
+float(0) - f
+float(0) - obj.a
+float(0) == b
+float(0.5 * b)
+float(0.5 * f)
+float(0.5 - 0.5)
+float(0.5 - a)
+float(0.5 - b)
+float(0.5 ^ 1)
+float(0.5 ^ f)
+float(0.5) != a + a
+float(0.5) * obj?.head(0.5)
+float(0.5) ** (0 - 0)
+float(0.5) / b ** 0
+float(0.5) <= a
+float(0.5) >= b
+float(0.5) >= f / 0
+float(1 % a)
+float(1 - 1)
+float(1 - a)
+float(1 - b)
+float(1 - f)
+float(1) + a
+float(1) > a
+float(2 % a)
+float(2 ** b)
+float(2 + b)
+float(2 + f)
+float(2 / f)
+float(2 ^ 0)
+float(2 ^ 0.5)
+float(2) ** obj?.head(0, 0, "a", 0.5, obj)
+float(2) - obj?.a
+float(2) < float(b)
+float(2) <= a
+float(2) > b
+float(2) > f
+float(2) ^ b
+float(a % a)
+float(a % b)
+float(a * 0)
+float(a * 2)
+float(a * a)
+float(a * b)
+float(a ** 1)
+float(a ** f)
+float(a + 0)
+float(a + 2)
+float(a + a)
+float(a + b)
+float(a + f)
+float(a - 0)
+float(a - a)
+float(a - b)
+float(a - f)
+float(a / 0)
+float(a / a)
+float(a / b)
+float(a ^ 1)
+float(a ^ a)
+float(a ^ b)
+float(a ^ f)
+float(a)
+float(a) != add(a, a)
+float(a) ** f
+float(a) + a
+float(a) - a
+float(a) / obj?.head(f)
+float(a) < a
+float(a) < f
+float(a) <= obj.a
+float(a) > f
+float(a) >= -0
+float(abs(a))
+float(abs(b))
+float(abs(f))
+float(add(0, a))
+float(add(1, b))
+float(add(2, a))
+float(add(2, b))
+float(add(a, 0))
+float(add(a, 2))
+float(add(a, a))
+float(add(a, b))
+float(add(b, 0))
+float(add(b, a))
+float(add(b, b))
+float(arr[a])
+float(arr[b])
+float(b % b)
+float(b * 0)
+float(b * a)
+float(b * b)
+float(b ** a)
+float(b ** b)
+float(b + 0)
+float(b + f)
+float(b - 0)
+float(b - b)
+float(b / a)
+float(b ^ 0.5)
+float(b ^ a)
+float(b ^ b)
+float(b)
+float(b) * a
+float(b) * b
+float(b) ** (a / 0.5)
+float(b) + a
+float(b) + b
+float(b) + obj?.a
+float(b) - b
+float(b) - f
+float(b) / a - obj?.b
+float(b) == a
+float(count(arr, ok))
+float(div(0, a))
+float(div(0, b))
+float(div(1, a))
+float(div(2, a))
+float(div(a, a))
+float(div(b, 1))
+float(div(b, b))
+float(f * 0)
+float(f * a)
+float(f * b)
+float(f * f)
+float(f ** 0)
+float(f ** b)
+float(f ** f)
+float(f + 0)
+float(f + a)
+float(f + obj.a)
+float(f - 0)
+float(f - a)
+float(f - b)
+float(f - f)
+float(f / a)
+float(f / f)
+float(f ^ a)
+float(f)
+float(f) * a
+float(f) + f
+float(f) + obj.a
+float(f) / a
+float(f) < a ^ b
+float(f) > a
+float(f) >= b
+float(f) ^ obj.b
+float(false ? obj : b)
+float(false ? ok : b)
+float(first(arr))
+float(float(0.5))
+float(float(1))
+float(float(2))
+float(float(a))
+float(float(b))
+float(float(f))
+float(get(arr, 0))
+float(get(arr, a))
+float(get(arr, b))
+float(int(0.5))
+float(int(a))
+float(int(b))
+float(last(arr))
+float(len(arr))
+float(max(0.5))
+float(max(b))
+float(min(0))
+float(min(a ** a))
+float(min(a, 0))
+float(min(f))
+float(obj.a)
+float(obj.b)
+float(obj.fn(0))
+float(obj.fn(2))
+float(obj.fn(a))
+float(obj.fn(b))
+float(obj.head(0))
+float(obj.head(0.5, 1))
+float(obj.head(1))
+float(obj.head(2))
+float(obj.head(a))
+float(obj.head(a, obj))
+float(obj.head(b))
+float(obj.head(b, arr, obj, nil))
+float(obj.head(b, b, a))
+float(obj.head(b, nil))
+float(obj.head(f))
+float(obj.obj.b)
+float(obj.obj?.b)
+float(obj?.a)
+float(obj?.b)
+float(obj?.fn(0))
+float(obj?.fn(a))
+float(obj?.fn(b))
+float(obj?.head(0))
+float(obj?.head(0, arr, ok))
+float(obj?.head(0, false, false))
+float(obj?.head(0.5))
+float(obj?.head(a))
+float(obj?.head(a, s))
+float(obj?.head(b))
+float(obj?.head(b, div, div))
+float(obj?.head(b, nil))
+float(obj?.head(b, obj?.obj))
+float(obj?.head(f, s))
+float(obj?.obj?.a)
+float(ok ? 0 : arr)
+float(ok ? 0 : true)
+float(ok ? 2 : 2)
+float(ok ? b : b)
+float(ok ? f : s)
+float(string(0))
+float(string(f))
+float(toJSON(0))
+float(toJSON(1))
+float(toJSON(2))
+float(toJSON(b))
+float(toJSON(f))
+float(true ? a : a)
+float(true ? a : add)
+float(true ? b : f)
+float(true ? f : obj?.obj)
+fromBase64(s + "a")
+fromBase64(s[2:b])
+fromBase64(s[a:0])
+fromBase64(s[a:a])
+fromBase64(s[b:b])
+fromBase64(string(ok))
+fromBase64(toBase64(s))
+fromBase64(toJSON(nil))
+fromBase64(toJSON(ok))
+fromBase64(toJSON(true))
+fromJSON(string(b))
+fromJSON(string(ok))
+fromJSON(toJSON(b))
+fromJSON(toJSON(f))
+fromJSON(toJSON(nil))
+fromJSON(toJSON(s))
+fromJSON(toJSON(true))
+get(0 .. b, -b)
+get(0 .. b, a)
+get(0 .. b, obj.obj)
+get(1 .. 0, a)
+get(1 .. 1, get(arr, a))
+get(2 .. 2, b)
+get(2 .. a, a)
+get(2 .. b, true ? div : "c")
+get([1, arr], obj.a)
+get([a, "a", div, 0, a], obj?.b)
+get([b], obj.head(s))
+get([f], b)
+get(a .. 0, b)
+get(a .. b, b)
+get(arr, -a)
+get(arr, -b)
+get(arr, 0 % a)
+get(arr, 0 % b)
+get(arr, 0) != obj?.head(s)
+get(arr, 0) + a
+get(arr, 0) - a
+get(arr, 0) - b
+get(arr, 0) == f
+get(arr, 0) ^ 0 ** f
+get(arr, 1 + a)
+get(arr, 1) != b
+get(arr, 1) ** a
+get(arr, 1) - a
+get(arr, 1) >= get(arr, b)
+get(arr, 2) / obj?.b
+get(arr, 2) == obj.a
+get(arr, a)
+get(arr, a) != b
+get(arr, a) * a
+get(arr, a) * b
+get(arr, a) * obj.head(0, add)
+get(arr, a) ** f ^ f
+get(arr, a) .. b
+get(arr, a) < f
+get(arr, a) > f ** f
+get(arr, a) ^ min(f)
+get(arr, a) in arr
+get(arr, add(0, a))
+get(arr, add(a, 0))
+get(arr, b * 1)
+get(arr, b + 2)
+get(arr, b + a)
+get(arr, b - obj.a)
+get(arr, b)
+get(arr, b) != b
+get(arr, b) != obj.head("a")
+get(arr, b) % a * f
+get(arr, b) % b
+get(arr, b) * b
+get(arr, b) ** f
+get(arr, b) + b
+get(arr, b) - 0 * 1
+get(arr, b) - b
+get(arr, b) .. obj?.a
+get(arr, b) < a
+get(arr, b) <= obj?.b
+get(arr, b) == a ? f : 1
+get(arr, b) >= obj?.b
+get(arr, b) ^ f
+get(arr, b) ^ obj?.a
+get(arr, div(2, a))
+get(arr, div(a, b))
+get(arr, div(b, b))
+get(arr, int(0.5))
+get(arr, max(a, a, 0.5))
+get(arr, obj.a)
+get(arr, obj.b)
+get(arr, obj.fn(a))
+get(arr, obj.head(a, nil))
+get(arr, obj.head(add))
+get(arr, obj.head(add, 0, 0))
+get(arr, obj.head(arr))
+get(arr, obj.head(f))
+get(arr, obj.head(s, "c"))
+get(arr, obj.obj)
+get(arr, obj.obj?.obj)
+get(arr, obj?.a)
+get(arr, obj?.b)
+get(arr, obj?.head(0.5))
+get(arr, obj?.head(1))
+get(arr, obj?.head(1, ok, 0))
+get(arr, obj?.head(add, add))
+get(arr, obj?.head(arr))
+get(arr, obj?.head(arr, "c"))
+get(arr, obj?.head(false))
+get(arr, obj?.head(nil))
+get(arr, obj?.head(obj))
+get(arr, obj?.head(obj, f, div)?.b)
+get(arr, obj?.obj)
+get(arr, obj?.obj.a)
+get(arr, obj[nil])
+get(arr, ok ? "a" : add)
+get(arr, ok ? arr : div)
+get(arr, ok ? obj : 0)
+get(arr, ok ? obj : b)
+get(arr[0:1], b)
+get(arr[0:2], obj?.head(ok))
+get(arr[b:a], obj.b)
+get(b .. 2, obj.head(arr, ok))
+get(b .. a, a)
+get(b .. b, ok ? b : div)
+get(false ? "a" : ok, get(add, f))
+get(false ? "b" : b, f != b)
+get(false ? 0 : 0.5, s)
+get(false ? 0 : add, obj.head(add, div))
+get(false ? 0 : arr, arr)
+get(false ? 0 : ok, a)
+get(false ? 0.5 : arr, div)
+get(false ? 0.5 : s, f)
+get(false ? 2 : f, 0.5 .. 0.5)
+get(false ? arr : b, upper(0, true, "c"))
+get(false ? div : b, 0 / f)
+get(false ? div : b, s)
+get(false ? f : add, ok)
+get(false ? false : s, s)
+get(false ? obj : 0, s)
+get(false ? obj : ok, obj.head(s, div, "b"))
+get(false ? ok : arr, count(arr, ok))
+get(filter(arr, ok), a)
+get(get(obj, s), add)
+get(get(obj, s), int(1))
+get(get(obj, s), now(0))
+get(get(obj, s), obj.a)
+get(get(obj, s), s)
+get(map(arr, "b"), obj.head(b, s))
+get(map(arr, 0.5), obj.a)
+get(map(arr, add), a)
+get(map(arr, add), obj.head(b))
+get(map(arr, b), a - a)
+get(map(arr, b), add(b, 0))
+get(map(arr, div), b)
+get(map(arr, false), a)
+get(map(arr, obj), b)
+get(map(arr, s), min(b, b))
+get(map(arr, s), obj.a)
+get(map(arr, true), b)
+get(obj, get(obj, s))
+get(obj, lower("a"))
+get(obj, lower("c"))
+get(obj, obj.a)
+get(obj, obj.b)
+get(obj, obj.head("b", add, 0.5))
+get(obj, obj.head(0))
+get(obj, obj.head(b, a))
+get(obj, obj.head(div))
+get(obj, obj.head(div, add))
+get(obj, obj.head(f, add))
+get(obj, obj.head(obj))
+get(obj, obj.head(obj, "b", b))
+get(obj, obj.head(ok, add, 0, 2, obj))
+get(obj, obj.head(s))
+get(obj, obj.obj)
+get(obj, obj.obj.b)
+get(obj, obj.obj?.obj)
+get(obj, obj?.a)
+get(obj, obj?.b)
+get(obj, obj?.fn(0))
+get(obj, obj?.fn(1))
+get(obj, obj?.head("b", nil, a, f, f))
+get(obj, obj?.head(2))
+get(obj, obj?.head(a))
+get(obj, obj?.head(f, ok))
+get(obj, obj?.head(false, false, b))
+get(obj, obj?.head(s))
+get(obj, obj?.head(s))?.b
+get(obj, obj?.head(true))
+get(obj, obj?.obj)
+get(obj, ok ? "a" : a)
+get(obj, ok ? a : true)
+get(obj, ok ? obj : div)
+get(obj, ok ? s : obj)
+get(obj, s)
+get(obj, s) != f
+get(obj, s) != ok
+get(obj, s)?.a
+get(obj, s)?.a?.b
+get(obj, s)?.a?.head(f, div)
+get(obj, s)?.a?.obj
+get(obj, s)?.b
+get(obj, s)?.b?.b
+get(obj, s)?.fn(a)
+get(obj, s)?.fn(div)
+get(obj, s)?.fn(s)
+get(obj, s)?.head(add)
+get(obj, s)?.head(add, int(1))
+get(obj, s)?.head(s)
+get(obj, s)?.obj
+get(obj, s)?.obj.b
+get(obj, s)?.obj?.b
+get(obj, string(b))
+get(obj, string(div))
+get(obj, string(ok))
+get(obj, toBase64(s))
+get(obj, toJSON(b))
+get(obj, toJSON(f))
+get(obj, toJSON(false))
+get(obj, toJSON(nil == add))
+get(obj, toJSON(ok))?.a
+get(obj, trimPrefix("a"))
+get(obj, trimSuffix(s))
+get(obj.a, "a" matches s)
+get(obj.a, -f)
+get(obj.a, 0 != a)
+get(obj.a, 0 - 0)
+get(obj.a, 0 .. a)
+get(obj.a, 0 == arr)
+get(obj.a, 0.5 * b)
+get(obj.a, 0.5 >= f)
+get(obj.a, 1 <= b)
+get(obj.a, 1 > f)
+get(obj.a, 2 == add)
+get(obj.a, [s, a, obj])
+get(obj.a, a != nil)
+get(obj.a, a / a)
+get(obj.a, a)
+get(obj.a, a)?.a
+get(obj.a, abs(arr, false, 0))
+get(obj.a, add)
+get(obj.a, arr and false)
+get(obj.a, arr)
+get(obj.a, b + a)
+get(obj.a, b <= a)
+get(obj.a, b == a)
+get(obj.a, b)
+get(obj.a, div)
+get(obj.a, f * f)
+get(obj.a, f ** 2)
+get(obj.a, f <= 1)
+get(obj.a, f == add)
+get(obj.a, f == div)
+get(obj.a, f == s)
+get(obj.a, f)
+get(obj.a, false != "b")
+get(obj.a, float(nil, 2))
+get(obj.a, get("c", obj))
+get(obj.a, get(div, div))
+get(obj.a, get(div, obj))
+get(obj.a, get(f, 1))
+get(obj.a, get(false, b))
+get(obj.a, get(obj, true))
+get(obj.a, get(ok, true))
+get(obj.a, last(a, "a"))
+get(obj.a, len(true, s, ok, "c", s))
+get(obj.a, lower(add, "c"))?.b
+get(obj.a, map("c", 1))
+get(obj.a, map(arr, b))
+get(obj.a, map(obj, f))
+get(obj.a, map(s, s))
+get(obj.a, max(false))
+get(obj.a, obj != "c")
+get(obj.a, obj)
+get(obj.a, obj)?.b
+get(obj.a, obj.b)
+get(obj.a, obj.b)?.a
+get(obj.a, obj.head(div, nil))
+get(obj.a, obj?.head(ok))
+get(obj.a, ok == f)
+get(obj.a, ok || nil)
+get(obj.a, ok)
+get(obj.a, s != nil)
+get(obj.a, s)
+get(obj.a, s[f])
+get(obj.a, string(ok))
+get(obj.a, toJSON(0, b, 0, f))
+get(obj.a, toJSON(2))
+get(obj.a, true != s)
+get(obj.a, true and "c")
+get(obj.b, !true)
+get(obj.b, "a" startsWith "a")
+get(obj.b, "b" != add)
+get(obj.b, "c" in nil)
+get(obj.b, 0 + 0.5)
+get(obj.b, 0 < f)
+get(obj.b, 0.5 .. 0)
+get(obj.b, a == nil)
+get(obj.b, a == ok)
+get(obj.b, a >= a)
+get(obj.b, a and true)?.head(arr)
+get(obj.b, a)
+get(obj.b, a)?.head(s)
+get(obj.b, add)
+get(obj.b, arr == obj)?.a
+get(obj.b, arr)
+get(obj.b, b != f)
+get(obj.b, b .. a)
+get(obj.b, b >= b)
+get(obj.b, b)
+get(obj.b, div)
+get(obj.b, f != ok)
+get(obj.b, f)
+get(obj.b, false != "b")
+get(obj.b, filter(f .. 0.5, b or true))
+get(obj.b, get("b"))
+get(obj.b, get(2, false))
+get(obj.b, get(arr, a))
+get(obj.b, get(b, div))
+get(obj.b, get(div, 0))
+get(obj.b, get(ok))
+get(obj.b, last("b", 0))
+get(obj.b, lower("b"))
+get(obj.b, lower(f, s))
+get(obj.b, map(arr, arr))
+get(obj.b, map(obj, nil))
+get(obj.b, map(s, s))
+get(obj.b, max(nil, div))
+get(obj.b, not ok)
+get(obj.b, now(add, a, div))
+get(obj.b, obj == 0.5)
+get(obj.b, obj || true)
+get(obj.b, obj)
+get(obj.b, obj)?.b
+get(obj.b, obj)?.b?.b
+get(obj.b, obj.a)
+get(obj.b, obj.fn(1))
+get(obj.b, obj.head(f, obj, 0))
+get(obj.b, obj.obj)
+get(obj.b, obj?.a)
+get(obj.b, obj?.b)
+get(obj.b, obj?.head("b", nil, f))
+get(obj.b, obj?.head(div))
+get(obj.b, ok && s)
+get(obj.b, ok == a)
+get(obj.b, ok and arr)
+get(obj.b, ok)
+get(obj.b, one("b", true))
+get(obj.b, s == ok)
+get(obj.b, s)
+get(obj.b, s)?.a
+get(obj.b, toJSON(2))
+get(obj.b, upper(s))
+get(obj.c, a)
+get(obj.c, arr)
+get(obj.c, ok)
+get(obj.fn(0), a)
+get(obj.fn(0), add)
+get(obj.fn(0), arr)
+get(obj.fn(0), f in nil)
+get(obj.fn(0), int(b))
+get(obj.fn(0), ok)
+get(obj.fn(1) + obj?.fn(0), obj)
+get(obj.fn(1), div == a)
+get(obj.fn(1), div)
+get(obj.fn(1), f && false)
+get(obj.fn(1), now(arr))
+get(obj.fn(2), arr)
+get(obj.fn(a), f * f)
+get(obj.fn(a), get(nil))
+get(obj.fn(a), now(nil))
+get(obj.fn(b), 0 + a)
+get(obj.fn(b), 2 < 0.5)
+get(obj.fn(b), arr)
+get(obj.fn(b), div)
+get(obj.fn(b), ok)
+get(obj.fn(b), s)
+get(obj.head("a"), obj?.obj)
+get(obj.head("a", "a"), false ? obj : s)
+get(obj.head("a", nil), add != div)
+get(obj.head("b"), f)
+get(obj.head("b", f, add), div)
+get(obj.head("b", s, nil), a)
+get(obj.head(0), div)
+get(obj.head(0), f)
+get(obj.head(0, "c"), get("a", arr))
+get(obj.head(0, "c"), toJSON(a))
+get(obj.head(0, "c", b), add)
+get(obj.head(0, 0.5, div, s, a), b ** a)
+get(obj.head(0, add), a)
+get(obj.head(0, add, f), f)
+get(obj.head(0, nil), arr)
+get(obj.head(0.5), s)
+get(obj.head(0.5, 0, ok), obj)
+get(obj.head(0.5, false), add)
+get(obj.head(1, false, obj, f, arr), obj)
+get(obj.head(2, ok), get(obj, b))
+get(obj.head(a), a)
+get(obj.head(a), add)
+get(obj.head(a), obj == div)
+get(obj.head(a), obj?.a)
+get(obj.head(a), s)
+get(obj.head(a, 0, "a"), f)
+get(obj.head(a, 2, a, obj), div != ok)
+get(obj.head(a, a, arr), ok || f)
+get(obj.head(a, nil, a), arr)
+get(obj.head(a, s, add), obj.b)
+get(obj.head(add), add)
+get(obj.head(add), first(s))
+get(obj.head(add), float(s, 1))
+get(obj.head(add), ok && a)
+get(obj.head(add, 1), arr[0:a])
+get(obj.head(add, a, 2), b)
+get(obj.head(add, add, add), div)
+get(obj.head(arr), !ok)
+get(obj.head(arr), a)
+get(obj.head(arr), arr)
+get(obj.head(arr), f != arr)
+get(obj.head(arr), get(s, 2))
+get(obj.head(arr), ok)
+get(obj.head(arr, 0), f)
+get(obj.head(arr, 2), arr == nil)
+get(obj.head(arr, nil), -0.5)
+get(obj.head(arr, nil, nil), ok)
+get(obj.head(b), a)
+get(obj.head(b), arr)
+get(obj.head(b), f ** a)
+get(obj.head(b, 0), f != ok)
+get(obj.head(b, 1), div)
+get(obj.head(b, arr), "a" < s)
+get(obj.head(b, b), get(1, s))
+get(obj.head(b, div, f), a / b)
+get(obj.head(b, obj, s, true), 0 <= a)
+get(obj.head(div), add)
+get(obj.head(div), b - b)
+get(obj.head(div), b)
+get(obj.head(div), div != 1)?.b
+get(obj.head(div), obj)
+get(obj.head(div, "c", add), arr)
+get(obj.head(div, a), obj and false)
+get(obj.head(div, arr), a)?.b?.a
+get(obj.head(div, div), s matches s)
+get(obj.head(div, false), false != arr)
+get(obj.head(div, ok), !ok)
+get(obj.head(f), arr)
+get(obj.head(f), obj.a)?.obj
+get(obj.head(f), upper("c"))
+get(obj.head(f, add, f, ok), 0.5 and false)
+get(obj.head(f, b), obj.b)
+get(obj.head(f, false), arr)
+get(obj.head(f, nil), add)
+get(obj.head(f, s), arr[a])
+get(obj.head(false), add != s)
+get(obj.head(false), add)
+get(obj.head(false), div)
+get(obj.head(false), s)
+get(obj.head(false, add), s)
+get(obj.head(false, arr), div)
+get(obj.head(false, b, 0, obj), get(f, b))
+get(obj.head(false, div), s in obj)
+get(obj.head(get(s, 1)), div)
+get(obj.head(nil), add)
+get(obj.head(nil), obj?.head(true, "a"))
+get(obj.head(nil), obj?.obj)
+get(obj.head(nil), s)
+get(obj.head(nil), s[b])
+get(obj.head(nil, obj, arr, add, arr), b)
+get(obj.head(nil, true), string(b))
+get(obj.head(obj), div)
+get(obj.head(obj), get(add, s))
+get(obj.head(obj), get(div, ok, obj))
+get(obj.head(obj), ok)
+get(obj.head(obj), true || false)
+get(obj.head(obj, "a"), s)
+get(obj.head(obj, "c", nil), a)
+get(obj.head(obj, 0, "a"), obj.obj)?.b
+get(obj.head(obj, f), a)
+get(obj.head(obj, f, obj), toJSON(s))
+get(obj.head(obj, nil), nil != a)
+get(obj.head(obj, s, 0), arr)
+get(obj.head(ok), a != true)
+get(obj.head(ok), b ** 2)
+get(obj.head(ok), get(1, add))
+get(obj.head(ok), obj)
+get(obj.head(ok), obj?.a)
+get(obj.head(ok), s)
+get(obj.head(ok), toJSON(nil))
+get(obj.head(ok), true ? a : nil)
+get(obj.head(ok, "a"), add)
+get(obj.head(ok, 0.5, add, div), obj)
+get(obj.head(ok, 1), 0.5 != 0)
+get(obj.head(ok, a), "b" contains "b")
+get(obj.head(ok, arr, div, true, s), get(2, nil))
+get(obj.head(ok, s), map(obj, true))
+get(obj.head(s), add && true)
+get(obj.head(s), b)
+get(obj.head(s), div == "a")
+get(obj.head(s), get(obj, f))
+get(obj.head(s), map(s, f))
+get(obj.head(s), obj.head(0.5, true, ok))
+get(obj.head(s, a), get(div, nil))
+get(obj.head(s, arr, f), "a" in obj)
+get(obj.head(s, f), last(nil, arr))
+get(obj.head(true), ok != 0.5)
+get(obj.head(true, "c"), get(b, ok))
+get(obj.head(true, false, obj), true != f)
+get(obj.obj, !true)
+get(obj.obj, "a" == obj)
+get(obj.obj, "a" == ok)
+get(obj.obj, 0 <= 0)
+get(obj.obj, 0 == nil)
+get(obj.obj, 0 == s)
+get(obj.obj, 0 == true)
+get(obj.obj, 0 > a)
+get(obj.obj, 0.5 ^ b)
+get(obj.obj, a + f)
+get(obj.obj, a - 0)
+get(obj.obj, a)
+get(obj.obj, a)?.a
+get(obj.obj, abs(0))
+get(obj.obj, add(b, b))
+get(obj.obj, add)
+get(obj.obj, all("b", ok)) != b
+get(obj.obj, arr)
+get(obj.obj, b)
+get(obj.obj, count(s, false))
+get(obj.obj, div != "a")
+get(obj.obj, div != add)
+get(obj.obj, div)
+get(obj.obj, f != obj)
+get(obj.obj, f .. 0)
+get(obj.obj, f < a)
+get(obj.obj, f)
+get(obj.obj, false or false)
+get(obj.obj, false or s)
+get(obj.obj, filter(obj, false))
+get(obj.obj, get(arr))
+get(obj.obj, get(arr, obj))
+get(obj.obj, get(arr, s))
+get(obj.obj, get(b, a))
+get(obj.obj, get(f, false))
+get(obj.obj, get(nil, s))
+get(obj.obj, get(obj, true))
+get(obj.obj, int(b, 0.5))
+get(obj.obj, int(b, b))
+get(obj.obj, last("c"))
+get(obj.obj, map(arr, "a"))
+get(obj.obj, map(s, "a"))
+get(obj.obj, min(arr))
+get(obj.obj, nil != a)
+get(obj.obj, now(obj))
+get(obj.obj, obj)
+get(obj.obj, obj)?.obj
+get(obj.obj, obj?.a)
+get(obj.obj, obj?.b)
+get(obj.obj, obj?.obj)
+get(obj.obj, obj[s])
+get(obj.obj, ok != b)
+get(obj.obj, ok)
+get(obj.obj, one(obj, ok))
+get(obj.obj, one(s, ok))
+get(obj.obj, s)
+get(obj.obj, s)?.obj
+get(obj.obj, s[f])
+get(obj.obj, string(a, b))
+get(obj.obj, toBase64("a", 1))
+get(obj.obj, toJSON(arr))
+get(obj.obj, true or nil)
+get(obj.obj.a, obj)?.fn(a)
+get(obj.obj?.b, f)
+get(obj?.a, "b" in arr)
+get(obj?.a, -a)
+get(obj?.a, -f)
+get(obj?.a, 0 + a)
+get(obj?.a, 0 - a)
+get(obj?.a, 0 / a)
+get(obj?.a, 0 <= f)?.a
+get(obj?.a, 0.5 != 1)
+get(obj?.a, 0.5 > 0.5)
+get(obj?.a, 1 + f)
+get(obj?.a, 1 <= 1)
+get(obj?.a, a - a)
+get(obj?.a, a == nil)
+get(obj?.a, a)
+get(obj?.a, a)?.b
+get(obj?.a, add(a, a))?.obj
+get(obj?.a, add)
+get(obj?.a, all(s, false))
+get(obj?.a, arr)
+get(obj?.a, b ** a)
+get(obj?.a, b - a)
+get(obj?.a, b < b)
+get(obj?.a, b)
+get(obj?.a, div(0, b))
+get(obj?.a, div)
+get(obj?.a, f .. b)
+get(obj?.a, f ^ f)
+get(obj?.a, f)
+get(obj?.a, false != ok)
+get(obj?.a, false && s)
+get(obj?.a, false ? 0 : false)
+get(obj?.a, false || s)
+get(obj?.a, get("a", nil))
+get(obj?.a, get(0, ok))
+get(obj?.a, get(0.5, 2))
+get(obj?.a, get(2, true))
+get(obj?.a, get(s, f))
+get(obj?.a, get(s, s))
+get(obj?.a, get(true, nil))
+get(obj?.a, int(f))
+get(obj?.a, last(0.5, add, 0.5))
+get(obj?.a, last(add))
+get(obj?.a, map(arr, div))
+get(obj?.a, max(f))
+get(obj?.a, min(a, 0.5) <= 2 != ok)
+get(obj?.a, not ok)
+get(obj?.a, now(0.5, 1, s, 0, f))
+get(obj?.a, now(div))
+get(obj?.a, obj)
+get(obj?.a, obj.a)
+get(obj?.a, obj.b)
+get(obj?.a, obj.head(ok, 0))
+get(obj?.a, obj?.b)
+get(obj?.a, obj?.head(f))
+get(obj?.a, ok && "a")
+get(obj?.a, ok ? div : "a")
+get(obj?.a, ok || f)
+get(obj?.a, ok)
+get(obj?.a, s)
+get(obj?.a, string(div))
+get(obj?.a, toJSON(f, nil, s))
+get(obj?.a, true && false)
+get(obj?.a, true ? false : add)
+get(obj?.b, -f)
+get(obj?.b, 0 or true)
+get(obj?.b, 0 || false)?.fn(f)
+get(obj?.b, 1 - b)
+get(obj?.b, 2 % b)
+get(obj?.b, 2 == 0)
+get(obj?.b, a .. 0)
+get(obj?.b, a < b)
+get(obj?.b, a)
+get(obj?.b, a)?.obj
+get(obj?.b, add == s)
+get(obj?.b, add in arr)
+get(obj?.b, add)
+get(obj?.b, arr == 0.5)
+get(obj?.b, arr == a)
+get(obj?.b, arr)
+get(obj?.b, arr)?.b
+get(obj?.b, arr[b])
+get(obj?.b, b % a)
+get(obj?.b, b + 1)
+get(obj?.b, b)
+get(obj?.b, count(obj, true))
+get(obj?.b, div != "b")
+get(obj?.b, div)
+get(obj?.b, f != ok)
+get(obj?.b, f + 0)
+get(obj?.b, f / b)
+get(obj?.b, f == div)
+get(obj?.b, f)
+get(obj?.b, false == nil)
+get(obj?.b, false and f)
+get(obj?.b, float(a))
+get(obj?.b, get(0.5, ok))
+get(obj?.b, get(a, 2))
+get(obj?.b, get(a, a))
+get(obj?.b, get(add))
+get(obj?.b, get(add, arr))
+get(obj?.b, get(add, s))
+get(obj?.b, get(f, 0.5))
+get(obj?.b, get(f, arr))?.obj
+get(obj?.b, get(false, false))
+get(obj?.b, get(obj, div))
+get(obj?.b, get(obj, nil))
+get(obj?.b, get(ok, f))
+get(obj?.b, get(s))
+get(obj?.b, get(s, 0))
+get(obj?.b, int(2))
+get(obj?.b, last(ok, true, 0.5))
+get(obj?.b, map("a", s))
+get(obj?.b, map(obj, 0))
+get(obj?.b, map(obj, nil))
+get(obj?.b, map(s, 1))
+get(obj?.b, map(s, b))
+get(obj?.b, max(f))
+get(obj?.b, min(nil))
+get(obj?.b, nil or true)
+get(obj?.b, nil || false)
+get(obj?.b, now(s))
+get(obj?.b, now(true))
+get(obj?.b, obj == b)
+get(obj?.b, obj)
+get(obj?.b, obj.a)
+get(obj?.b, obj.b)
+get(obj?.b, obj.head(false))
+get(obj?.b, obj?.head(a, 0.5))
+get(obj?.b, obj?.head(obj, 0))
+get(obj?.b, obj?.head(ok))
+get(obj?.b, ok && arr)
+get(obj?.b, ok ? f : arr)
+get(obj?.b, ok and div)
+get(obj?.b, ok)
+get(obj?.b, s != obj)
+get(obj?.b, s == s)
+get(obj?.b, s > "a")
+get(obj?.b, s)
+get(obj?.b, s)?.obj
+get(obj?.b, toJSON(f))
+get(obj?.c?.a?.b, ok)
+get(obj?.fn(0), a)
+get(obj?.fn(0), ok)
+get(obj?.fn(0), s)
+get(obj?.fn(1 + 0), ok ? ok : s?.a)
+get(obj?.fn(1), obj)
+get(obj?.fn(2), a / 0)
+get(obj?.fn(2), a)
+get(obj?.fn(2), none(s, true))
+get(obj?.fn(a), add)
+get(obj?.fn(a), f)
+get(obj?.fn(a), get(arr, b))
+get(obj?.fn(a), get(nil, 0))
+get(obj?.fn(a), obj)
+get(obj?.fn(a), s)
+get(obj?.fn(b + b), a)
+get(obj?.fn(b), div)
+get(obj?.fn(b), f .. f)
+get(obj?.fn(b), obj)
+get(obj?.head("a"), arr)
+get(obj?.head("a"), map("a", a))
+get(obj?.head("a", f), obj?.b)?.b
+get(obj?.head("b"), add)
+get(obj?.head("b", 2, arr), ok)
+get(obj?.head("c"), s > "c")
+get(obj?.head("c"), s matches s)
+get(obj?.head("c", 0.5, a), "a" || false)
+get(obj?.head("c", b), nil == div)
+get(obj?.head("c", div, ok), count("b", true))
+get(obj?.head(0), b .. b)
+get(obj?.head(0), div)
+get(obj?.head(0), map(s, add))
+get(obj?.head(0), obj)
+get(obj?.head(0), obj?.b)
+get(obj?.head(0), ok)
+get(obj?.head(0), s)
+get(obj?.head(0, 0), b)
+get(obj?.head(0, 0, add, "b", 2), arr)
+get(obj?.head(0, a, 0.5, a), a - b)
+get(obj?.head(0, b, add, false, nil), b)
+get(obj?.head(0, nil, obj, 0, add), div)
+get(obj?.head(0.5), min(arr))
+get(obj?.head(0.5), s)
+get(obj?.head(0.5, b), ok or b)
+get(obj?.head(0.5, b), s)
+get(obj?.head(0.5, div), add)
+get(obj?.head(0.5, s, a, "c", b), obj?.head(add, 0))
+get(obj?.head(1), get(ok, 0))
+get(obj?.head(1, a), add)
+get(obj?.head(1, a, f), get(f, nil))
+get(obj?.head(2), a)
+get(obj?.head(2), max(0.5))
+get(obj?.head(2, true, a, ok), arr)
+get(obj?.head(a), add)
+get(obj?.head(a), arr)
+get(obj?.head(a), b)
+get(obj?.head(a), obj?.obj)
+get(obj?.head(a), s)
+get(obj?.head(a, "c", "c"), a)
+get(obj?.head(a, add, b), div)
+get(obj?.head(a, div), obj.head(b))
+get(obj?.head(a, s, s), map("a", a))
+get(obj?.head(add), b)
+get(obj?.head(add), none(obj, false))
+get(obj?.head(add), now(obj, 1, add))
+get(obj?.head(add), s)
+get(obj?.head(add, a, obj, "b", a), obj.obj)
+get(obj?.head(add, b), div)
+get(obj?.head(add, false), div != b)
+get(obj?.head(add, float(f)), s)
+get(obj?.head(add, obj, a), s)
+get(obj?.head(add, obj, a, 0.5), add)
+get(obj?.head(add, obj, obj), f)
+get(obj?.head(add, ok), a)
+get(obj?.head(arr), get(s, arr))
+get(obj?.head(arr), obj)
+get(obj?.head(arr), s)
+get(obj?.head(arr, 0.5, false), 0 > f)
+get(obj?.head(arr, a), obj.obj)
+get(obj?.head(arr, add), 0.5 / a)
+get(obj?.head(arr, add), b)
+get(obj?.head(arr, add), div)
+get(obj?.head(arr, nil), f)
+get(obj?.head(arr, nil, arr, ok), obj)
+get(obj?.head(arr, obj, "a"), false == div)
+get(obj?.head(arr, ok, arr), obj?.head(true, 0))
+get(obj?.head(arr, s), div)
+get(obj?.head(arr, s), obj.a)
+get(obj?.head(b), all(s, ok))
+get(obj?.head(b), b)
+get(obj?.head(b), f)?.obj
+get(obj?.head(b), false && 0)
+get(obj?.head(b), get(0.5, b))
+get(obj?.head(b), obj?.b)
+get(obj?.head(b, "b", nil), arr)
+get(obj?.head(b, 0), obj.b)
+get(obj?.head(b, div), add)
+get(obj?.head(b, nil, ok), nil == f)
+get(obj?.head(div), a)
+get(obj?.head(div), arr)
+get(obj?.head(div), div)
+get(obj?.head(div, 1, ok, a), div)
+get(obj?.head(div, a), obj && false)
+get(obj?.head(div, arr), nil == "c")
+get(obj?.head(div, false), f)
+get(obj?.head(div, false, arr), map(s, b))
+get(obj?.head(div, obj), f)
+get(obj?.head(f), arr)
+get(obj?.head(f), obj.obj)
+get(obj?.head(f), s)
+get(obj?.head(f, nil), ok ? f : div)
+get(obj?.head(f, ok, add), "a" == f)
+get(obj?.head(false), false and f)
+get(obj?.head(false), ok && obj)
+get(obj?.head(false), ok)
+get(obj?.head(false, b, ok, "a"), any(obj, ok))
+get(obj?.head(false, obj, 0, arr), div)
+get(obj?.head(false, s, 0, f), true or s)
+get(obj?.head(nil), a)
+get(obj?.head(nil), add)
+get(obj?.head(nil), f)
+get(obj?.head(nil), get(false, add))
+get(obj?.head(nil), ok)
+get(obj?.head(nil), s == arr)
+get(obj?.head(nil), s)
+get(obj?.head(nil, "c"), arr)
+get(obj?.head(nil, arr), ok or obj)
+get(obj?.head(nil, obj), first(f, nil))
+get(obj?.head(obj), add != true)
+get(obj?.head(obj), arr)
+get(obj?.head(obj), f)
+get(obj?.head(obj), obj)
+get(obj?.head(obj), ok)
+get(obj?.head(obj, "a", add), ok == ok)
+get(obj?.head(obj, arr), arr)
+get(obj?.head(obj, f), obj)
+get(obj?.head(obj, obj, ok), div)
+get(obj?.head(obj?.a), a)
+get(obj?.head(ok), a)
+get(obj?.head(ok), b)
+get(obj?.head(ok, 1), b == b)
+get(obj?.head(ok, 1), ok)
+get(obj?.head(ok, arr, div), get(add, s))
+get(obj?.head(ok, f, 0.5, b), 1 != true)
+get(obj?.head(s), b % 2)
+get(obj?.head(s), f)
+get(obj?.head(s), get(a, obj))
+get(obj?.head(s), obj)
+get(obj?.head(s), ok)
+get(obj?.head(s, 0, arr), false or s)
+get(obj?.head(s, 2, f, div), get(f, 0.5))
+get(obj?.head(s, add, s), hasPrefix("b", s))
+get(obj?.head(s, div, arr), s)
+get(obj?.head(s, false), obj == add)
+get(obj?.head(true), b)
+get(obj?.head(true), f != s)
+get(obj?.head(true), f)
+get(obj?.head(true), first(div, b))
+get(obj?.head(true, add), a)
+get(obj?.head(true, add, add), obj.head(ok, obj, 2, nil, 2))
+get(obj?.head(true, b), obj)
+get(obj?.head(true, div), a)
+get(obj?.head(true, f), filter(s, true))
+get(obj?.head(true, obj, 1, b), div)
+get(obj?.obj, "a" matches s)
+get(obj?.obj, -b)
+get(obj?.obj, 0 != f)
+get(obj?.obj, 0 != s)
+get(obj?.obj, 0 / a)
+get(obj?.obj, 0.5 + a)?.a
+get(obj?.obj, 1 .. a)
+get(obj?.obj, 2 + 2)
+get(obj?.obj, a != 2)
+get(obj?.obj, a * f)
+get(obj?.obj, a ** f)
+get(obj?.obj, a < b)
+get(obj?.obj, a or true)
+get(obj?.obj, a)
+get(obj?.obj, add and false)
+get(obj?.obj, add(a, b))
+get(obj?.obj, add)
+get(obj?.obj, arr)
+get(obj?.obj, b * b)
+get(obj?.obj, b ** 2)
+get(obj?.obj, b > a)
+get(obj?.obj, b)
+get(obj?.obj, div == 0)
+get(obj?.obj, div)
+get(obj?.obj, f < 0)
+get(obj?.obj, f)
+get(obj?.obj, false or "c")
+get(obj?.obj, filter("a", ok))
+get(obj?.obj, filter(s, ok))
+get(obj?.obj, get("b", arr))
+get(obj?.obj, get("c", arr))
+get(obj?.obj, get(0, a))
+get(obj?.obj, get(add, s))
+get(obj?.obj, get(arr, 0))
+get(obj?.obj, get(nil, a))
+get(obj?.obj, get(nil, b))
+get(obj?.obj, int(false, arr, b))
+get(obj?.obj, map(obj, "b"))
+get(obj?.obj, map(obj, div))
+get(obj?.obj, min(arr))
+get(obj?.obj, now("c", obj))
+get(obj?.obj, obj)
+get(obj?.obj, obj)?.a?.a
+get(obj?.obj, obj.a)
+get(obj?.obj, obj.b)
+get(obj?.obj, obj.head(nil))
+get(obj?.obj, obj.obj)
+get(obj?.obj, obj?.a)
+get(obj?.obj, obj?.head(add))
+get(obj?.obj, obj?.head(s, 0))
+get(obj?.obj, obj?.obj)
+get(obj?.obj, ok != a)
+get(obj?.obj, ok != false)
+get(obj?.obj, ok ? 2 : true)
+get(obj?.obj, ok and nil)
+get(obj?.obj, ok or ok)
+get(obj?.obj, ok)
+get(obj?.obj, ok)?.obj
+get(obj?.obj, one(obj, true))
+get(obj?.obj, s)
+get(obj?.obj, string(f))
+get(obj?.obj, string(f, 0))
+get(obj?.obj, string(ok, s, s))
+get(obj?.obj, toJSON(b, b, nil))
+get(obj?.obj, toJSON(f))
+get(obj?.obj, true || 1)
+get(obj?.obj.b, arr)
+get(obj?.obj?.a, div)
+get(obj?.obj?.b, obj)
+get(obj?.obj?.b, s)
+get(obj?.obj?.obj, f)
+get(obj[nil], add)
+get(obj[nil], arr)
+get(obj[nil], f)
+get(obj[nil], get(s, a))
+get(obj[nil], ok)
+get(obj[nil], s)
+get(obj[s], obj)
+get(obj[s], obj?.a)
+get(ok ? "a" : add, ok ? s : add)
+get(ok ? "a" : arr, arr)
+get(ok ? 0 : "c", obj)
+get(ok ? 0 : arr, arr)
+get(ok ? add : 0.5, b)
+get(ok ? add : obj, ok)
+get(ok ? arr : add, div)
+get(ok ? arr : b, f)
+get(ok ? arr : f, toJSON("c"))
+get(ok ? b : div, first(nil))
+get(ok ? div : 1, add)
+get(ok ? f : "a", f)
+get(ok ? f : div, arr)
+get(ok ? f : obj, div)
+get(ok ? f : ok, obj.obj)
+get(ok ? false : arr, s)
+get(ok ? obj : 0, arr)
+get(ok ? obj : a, a)
+get(ok ? obj : div, div)
+get(ok ? ok : b, ok and ok)
+get(ok ? ok : f, last(ok))
+get(ok ? ok : obj, a)
+get(ok ? ok : obj, arr)
+get(ok ? s : f, arr)
+get(ok ? s : false, 0 != f)
+get(ok ? s : obj, obj?.head(ok, add))?.b
+get(ok ? true : a, count(arr, ok))
+get(true ? "c" : 0, get("b", div))
+get(true ? 0.5 : 0, s)
+get(true ? 1 : arr, f)
+get(true ? 1 : ok, f == a)
+get(true ? 1 : ok, ok or add)
+get(true ? a : ok, f * 0.5)
+get(true ? a : ok, get(nil, "c"))
+get(true ? add : "a", a)
+get(true ? add : 0.5, s[0.5:b])
+get(true ? b : s, div)
+get(true ? div : 2, add)
+get(true ? f : "c", get(arr))
+get(true ? obj : add, arr)
+get(true ? ok : 0, 0 / a)
+get(true ? s : 0.5, get(obj, f))
+get(values(obj), obj.a)
+get({"b": b, "c": "c", "a": nil}?.b, obj.obj)
+indexOf("b", s) != a
+indexOf(s, s)
+indexOf(s, upper(s))
+int(-0)
+int(-0.5)
+int(-1)
+int(-a)
+int(-b)
+int(-f)
+int(0 % 1)
+int(0 % a)
+int(0 * 0)
+int(0 * 0.5)
+int(0 * f)
+int(0 ** 0.5)
+int(0 + 0)
+int(0 + a)
+int(0 + b)
+int(0 + f)
+int(0 - 0)
+int(0 - a)
+int(0 - b)
+int(0 - f)
+int(0 / a)
+int(0 / f)
+int(0 ^ a)
+int(0) != -f
+int(0) != a ? nil : a
+int(0) != obj.obj
+int(0) ** obj.b
+int(0) + get(arr, 0)
+int(0) .. b
+int(0) / f
+int(0) < min(1)
+int(0) <= obj.b
+int(0) > obj.head(b)
+int(0) ^ f
+int(0.5 * a)
+int(0.5 * f)
+int(0.5 ** 2)
+int(0.5 ** a)
+int(0.5 + f)
+int(0.5 - f)
+int(0.5 / 0.5)
+int(0.5 / a)
+int(0.5 / b)
+int(0.5 / f)
+int(0.5 ^ 0)
+int(0.5 ^ 0.5)
+int(0.5) != f ? 0.5 : arr
+int(0.5) < b
+int(0.5) > f
+int(1 % 1 % b)
+int(1 * f)
+int(1 ** 0)
+int(1 ** a)
+int(1 ** b)
+int(1 / b)
+int(1) != a
+int(1) * a
+int(1) ** a
+int(1) / 0 ^ f
+int(1) <= b
+int(2 % b)
+int(2 ** 1)
+int(2 ** f)
+int(2 + 0)
+int(2 - b)
+int(2 / a)
+int(2) != a
+int(2) ** a
+int(2) + int(b)
+int(2) .. b
+int(2) <= a * f
+int(2) > b
+int(a % 2)
+int(a % b)
+int(a * 0)
+int(a * 0.5)
+int(a * f)
+int(a ** 0)
+int(a ** b)
+int(a ** f)
+int(a + a)
+int(a + b)
+int(a - 0.5)
+int(a - a)
+int(a / 0)
+int(a / a)
+int(a / b)
+int(a / f)
+int(a ^ 0)
+int(a ^ 0.5)
+int(a ^ b)
+int(a)
+int(a) != b
+int(a) != f != true
+int(a) * a
+int(a) * f
+int(a) ** a
+int(a) + -f
+int(a) + a
+int(a) - b
+int(a) - f
+int(a) / a
+int(a) / obj.a
+int(a) < obj.head(obj).a
+int(a) <= b
+int(a) == b
+int(a) >= a
+int(a) >= obj.fn(a)
+int(a) ^ b
+int(abs(a))
+int(abs(b))
+int(abs(f))
+int(add(0, 0))
+int(add(0, 2))
+int(add(a, 0))
+int(add(a, 2))
+int(add(a, a))
+int(add(a, b))
+int(add(add(0, b), b))
+int(add(add(b, a), b))
+int(add(b, 0))
+int(add(b, b))
+int(arr[0])
+int(arr[a])
+int(arr[b])
+int(b % a)
+int(b * a)
+int(b * b)
+int(b ** a)
+int(b ** b)
+int(b ** f)
+int(b + 0.5)
+int(b + 2)
+int(b + a)
+int(b + b)
+int(b - 0)
+int(b - 2)
+int(b - b)
+int(b - f)
+int(b / 1)
+int(b / b)
+int(b ^ b)
+int(b ^ f)
+int(b)
+int(b) != 0 * 0
+int(b) != f
+int(b) % a
+int(b) * 0 % 2
+int(b) * a
+int(b) - a
+int(b) - b
+int(b) .. a
+int(b) / a
+int(b) ^ f
+int(count(arr, true))
+int(div(0, 2))
+int(div(0, a))
+int(div(1, a))
+int(div(1, b))
+int(div(2, a))
+int(div(2, b))
+int(div(a, 1))
+int(div(a, b))
+int(div(b, a))
+int(div(b, b))
+int(f * 0.5)
+int(f * a)
+int(f * b)
+int(f ** b)
+int(f + 0)
+int(f + 0.5)
+int(f + 2)
+int(f + a)
+int(f + b)
+int(f + f)
+int(f - 0)
+int(f - 1)
+int(f - a)
+int(f - b)
+int(f / 0)
+int(f / f)
+int(f ^ 0)
+int(f ^ a)
+int(f ^ b)
+int(f ^ obj?.a)
+int(f)
+int(f) != a
+int(f) * obj.a
+int(f) * obj.fn(b)
+int(f) ** b
+int(f) .. a
+int(f) < obj?.a
+int(f) == obj?.b
+int(f) >= 2 / a
+int(f) ^ b
+int(false ? "a" : a)
+int(false ? 0 : a)
+int(false ? add : 0)
+int(first(arr))
+int(float(0))
+int(float(2))
+int(float(a))
+int(float(f))
+int(get(arr, 0))
+int(get(arr, a))
+int(get(arr, b))
+int(int(1))
+int(int(a))
+int(int(f))
+int(last(arr))
+int(len(arr))
+int(len(obj))
+int(len(s))
+int(max(0.5))
+int(max(0.5, 0))
+int(max(1, b, f))
+int(max(b))
+int(max(b, f))
+int(max(f))
+int(min(0))
+int(min(0.5))
+int(min(2))
+int(min(a))
+int(min(b))
+int(min(f))
+int(obj.a + f)
+int(obj.a)
+int(obj.b / f)
+int(obj.b)
+int(obj.fn(0))
+int(obj.fn(1))
+int(obj.fn(a))
+int(obj.fn(b))
+int(obj.head(0))
+int(obj.head(0, obj))
+int(obj.head(a))
+int(obj.head(a, "a", div))
+int(obj.head(a, f))
+int(obj.head(a, nil, nil))
+int(obj.head(a, obj))
+int(obj.head(b))
+int(obj.head(b, s, nil, 0))
+int(obj.head(f))
+int(obj.head(f, s, "a"))
+int(obj.obj?.b)
+int(obj?.a)
+int(obj?.b)
+int(obj?.fn(0))
+int(obj?.fn(b))
+int(obj?.fn(obj.b))
+int(obj?.head(0.5, add))
+int(obj?.head(2, 1, obj))
+int(obj?.head(a))
+int(obj?.head(a, 0.5))
+int(obj?.head(a, a == b))
+int(obj?.head(b))
+int(obj?.head(b, add, 0))
+int(obj?.head(f))
+int(obj?.head(f, a, 1))
+int(obj?.obj.a)
+int(obj?.obj?.b)
+int(ok ? 0 : ok)
+int(ok ? 0.5 : add)
+int(ok ? 1 : 0.5)
+int(ok ? a : f)
+int(ok ? b : ok)
+int(ok ? f : s)
+int(string(a))
+int(string(b))
+int(toJSON(0))
+int(toJSON(a))
+int(toJSON(b))
+int(true ? 0 : nil)
+join(map(arr, s))
+keys(obj)
+keys(obj) == obj?.head(0, obj)
+keys(obj)[a]
+keys(ok ? obj : nil)
+keys({"b": 1, "c": obj})
+last(0 .. b)
+last(2 .. 1)
+last(["b"])
+last([nil, obj, b])
+last(a .. 0)
+last(a .. 2)
+last(a .. a)
+last(abs(obj?.head(a, add, div)))
+last(arr)
+last(arr) * 0 * 0
+last(arr) * abs(b)
+last(arr) * f * a
+last(arr) * obj.head(obj, arr).a
+last(arr) < b / 0.5
+last(arr) >= b
+last(arr[b:a])
+last(b + obj?.b)
+last(b - obj.b)
+last(b .. 2)
+last(b .. a)
+last(div(0, a) > a ? "c" : false)
+last(false ? f : a)
+last(false ? f : s)
+last(false ? obj : s)
+last(false ? s : 1)
+last(false ? s : obj)
+last(filter(arr, false))
+last(filter(arr, true))
+last(first(obj?.obj))
+last(get(obj.a, obj.b))
+last(get(obj.b, ok != 0.5))
+last(get(obj.obj, ok))
+last(last(obj?.b))
+last(map(arr, "a"))
+last(map(arr, 0))
+last(map(arr, 0.5))
+last(map(arr, a))
+last(map(arr, add))
+last(map(arr, arr))
+last(map(arr, b))
+last(map(arr, div))
+last(map(arr, false))
+last(map(arr, ok))
+last(map(arr, s))
+last(map(obj?.head("b"), b))
+last(obj.a)
+last(obj.b)
+last(obj.b)?.a
+last(obj.b)?.obj
+last(obj.fn(0))
+last(obj.fn(1))
+last(obj.fn(a))
+last(obj.fn(b))
+last(obj.head("a"))
+last(obj.head("c", 0, ok))
+last(obj.head(0))
+last(obj.head(0, nil))
+last(obj.head(0, ok, ok))
+last(obj.head(0.5))
+last(obj.head(2))
+last(obj.head(2, add, "a", "a", "a"))
+last(obj.head(a))
+last(obj.head(a, f))
+last(obj.head(a, true, f))
+last(obj.head(add, 2))
+last(obj.head(arr == div))
+last(obj.head(arr, s))
+last(obj.head(div))
+last(obj.head(div, 0.5, obj, s, 2))
+last(obj.head(f, a, s, a))
+last(obj.head(obj))
+last(obj.head(obj, b, add).a)
+last(obj.head(ok))
+last(obj.head(ok, false))
+last(obj.head(s))
+last(obj.head(s, a, ok))
+last(obj.head(true))
+last(obj.head(true, div))
+last(obj.obj)
+last(obj.obj)?.b
+last(obj.obj.a)
+last(obj.obj?.a)
+last(obj.obj?.obj.a)
+last(obj?.a)
+last(obj?.a)?.b
+last(obj?.b)
+last(obj?.b)?.obj
+last(obj?.fn(0))
+last(obj?.fn(a))
+last(obj?.fn(b))
+last(obj?.fn(b))?.b
+last(obj?.head("a", 0, 1))
+last(obj?.head(0, 0.5, a))
+last(obj?.head(1, s, "a", obj))
+last(obj?.head(2))
+last(obj?.head(a, b))
+last(obj?.head(a, obj))
+last(obj?.head(add))
+last(obj?.head(add, false, 0, div, f))
+last(obj?.head(arr))
+last(obj?.head(arr, 1))
+last(obj?.head(b))
+last(obj?.head(div, add, nil, ok))
+last(obj?.head(div, nil, ok))
+last(obj?.head(f))
+last(obj?.head(f, div, s))
+last(obj?.head(nil)?.obj)
+last(obj?.head(nil, div, ok))
+last(obj?.head(obj))
+last(obj?.head(obj))?.b
+last(obj?.head(obj, a))
+last(obj?.head(obj, false))
+last(obj?.head(ok, arr, div))
+last(obj?.head(ok, div))
+last(obj?.head(s))
+last(obj?.head(true))
+last(obj?.obj)
+last(obj?.obj)?.a
+last(obj?.obj)?.b
+last(obj?.obj.a)
+last(obj?.obj.b)
+last(obj?.obj?.obj)
+last(obj[nil])
+last(obj[obj[nil]])
+last(ok ? "a" : div)
+last(ok ? "c" : a)
+last(ok ? 0 : obj)
+last(ok ? a : s)
+last(ok ? add : arr)
+last(ok ? arr : false)
+last(ok ? div : 0.5)
+last(ok ? div : b)
+last(ok ? div : f)
+last(ok ? div : true)
+last(ok ? f : "c")
+last(ok ? f : b)
+last(ok ? f : ok)
+last(ok ? false : s)
+last(ok ? obj : div)
+last(ok ? obj : s)
+last(ok ? ok : 2)
+last(ok ? ok : f)?.obj
+last(ok ? true : "c")
+last(ok ? true : b)
+last(split(s, "c"))
+last(splitAfter("a", "a"))
+last(true ? a : ok)
+last(true ? add : f)
+last(true ? div : false)
+last(true ? div : ok)
+last(true ? obj : 0.5)
+last(true ? ok : b)
+last(true ? ok : div)
+lastIndexOf("a", "a") + f
+lastIndexOf("b", s) * a
+lastIndexOf(s, ok ? s : 0)
+lastIndexOf(s, s)
+len("a" + s)
+len("a") .. b
+len("a") == a
+len("a") >= 0 * b
+len("b" + "c")
+len("b") ** b
+len("b") >= f
+len("c" + "a")
+len(0 .. 0)
+len(0 .. a)
+len(2 .. 0)
+len([s])
+len(a .. 1)
+len(a .. a)
+len(a .. b)
+len(add != add or ok ? "c" : div)
+len(arr)
+len(arr) != f
+len(arr) != obj?.obj
+len(arr) - f
+len(arr) - int(a)
+len(arr) / a
+len(arr) > f
+len(arr) > last(arr)
+len(arr) ^ -f
+len(arr[a:2])
+len(filter(arr, false))
+len(filter(arr, ok))
+len(filter(arr, true))
+len(keys(obj))
+len(map(arr, "b"))
+len(map(arr, 0))
+len(map(arr, 1))
+len(map(arr, a))
+len(map(arr, arr))
+len(map(arr, b))
+len(map(arr, f))
+len(map(arr, ok))
+len(map(arr, s))
+len(obj)
+len(obj) % b
+len(obj) ** f
+len(obj) ** obj.b
+len(obj) + b
+len(obj) .. -b
+len(obj) / obj?.a
+len(obj) <= f
+len(obj) <= min(0)
+len(obj) == a
+len(obj) > get(arr, a)
+len(obj) > obj.a
+len(obj) >= a
+len(obj) >= count(arr, true)
+len(obj.head("a", 2, false))
+len(obj.head("b"))
+len(obj.head("c", ok))
+len(obj.head("c", true, obj, false, obj))
+len(obj.head(arr))
+len(obj.head(arr, div, b))
+len(obj.head(obj))
+len(obj.head(obj, 2))
+len(obj.head(s))
+len(obj.head(s, 0, div, s, add))
+len(obj.head(s, nil))
+len(obj.obj)
+len(obj.obj) > b
+len(obj?.head("c", b))
+len(obj?.head(arr, nil, f))
+len(obj?.head(arr, s, "c", div, "c"))
+len(obj?.head(obj))
+len(obj?.head(s))
+len(obj?.head(s, add))
+len(obj?.obj)
+len(obj?.obj.obj)
+len(obj?.obj?.obj)
+len(ok ? arr : a)
+len(ok ? arr : obj)
+len(s + "c")
+len(s + s)
+len(s)
+len(s) != a
+len(s) != obj.b
+len(s) ** obj?.a
+len(s) + a
+len(s) + f
+len(s) / f
+len(s) >= a
+len(s) >= b
+len(s) ^ f
+len(string(0))
+len(string(0.5))
+len(string(1))
+len(string(div == div))
+len(string(f))
+len(string(false))
+len(string(nil))
+len(string(obj))
+len(string(ok))
+len(string(s))
+len(toBase64("c"))
+len(toJSON("a"))
+len(toJSON("c"))
+len(toJSON(a))
+len(toJSON(b))
+len(toJSON(f))
+len(toJSON(nil == ok))
+len(toJSON(s))
+len(trim("b"))
+len(trim(s))
+len(trimPrefix("a"))
+len(trimPrefix(s))
+len(trimSuffix("a"))
+len(trimSuffix(s))
+len(true ? arr : add)
+len(true ? arr : obj)
+len(upper("b"))
+len(values(obj))
+len({"a": arr, "b": a})
+lower("b") != obj.head(f, ok)
+lower("b") contains s
+lower("b") matches "c" ? f : b
+lower("c" + s)
+lower(false ? 0 : "c")
+lower(obj.head(s))
+lower(obj.head(s, 2, s, "c"))
+lower(obj?.head(s))
+lower(s + "b")
+lower(s + "c")
+lower(s)
+lower(s) contains s
+lower(s) in obj?.obj
+lower(s[b:0])
+lower(string("a"))
+lower(string(0))
+lower(string(0.5))
+lower(string(2))
+lower(string(a))
+lower(string(b))
+lower(string(f))
+lower(string(false))
+lower(string(nil))
+lower(string(ok))
+lower(string(s))
+lower(string(true))
+lower(toBase64("b"))
+lower(toBase64("c"))
+lower(toBase64(s))
+lower(toJSON("b"))
+lower(toJSON("c"))
+lower(toJSON(a))
+lower(toJSON(f))
+lower(toJSON(ok))
+lower(toJSON(s))
+lower(trim("a"))
+lower(trim(s))
+lower(trimPrefix("a"))
+lower(trimPrefix("c"))
+lower(trimPrefix(s))
+lower(trimSuffix(s))
+lower(upper(s))
+map(0 .. 0, a)
+map(0 .. 0, b)
+map(0 .. 1, #)
+map(0 .. a, !ok)
+map(0 .. a, arr)
+map(0 .. a, ok)
+map(0 .. a, s)
+map(0 .. b, #)
+map(1 .. 0, count(arr, ok))
+map(1 .. 1, b)
+map(1 .. a, #)
+map(1 .. b, #)
+map(1 .. b, obj.head(div))
+map(2 .. 1, b)
+map(2 .. 2, map(arr, a))
+map(2 .. 2, true ? obj : a)
+map(2 .. b, arr)
+map([a], add)
+map([nil], div)
+map([obj, s], add)
+map([ok], #)
+map([s], arr)
+map([true, obj, s], not ok)
+map(a .. 0, #)
+map(a .. 0, arr)
+map(a .. 0, b)
+map(a .. 1, f)
+map(a .. a, #)
+map(a .. a, div(0, a))
+map(a .. a, s)
+map(a .. b, b)
+map(a .. b, f)
+map(a .. obj?.obj?.a, f != #)
+map(arr, !any(arr, ok))
+map(arr, "a" startsWith "b")
+map(arr, "b")[b]
+map(arr, # * #)
+map(arr, # + #)
+map(arr, # + b)
+map(arr, #)
+map(arr, -#)
+map(arr, -0)
+map(arr, -1)
+map(arr, -a)
+map(arr, -b)
+map(arr, -f)
+map(arr, 0 != nil)
+map(arr, 0 * 0)
+map(arr, 0 * 0.5 > b)
+map(arr, 0 + a)
+map(arr, 0 >= 0)
+map(arr, 0 ^ 0)
+map(arr, 0 in arr)
+map(arr, 0) != arr
+map(arr, 0.5 != nil)
+map(arr, 0.5 + 2)
+map(arr, 0.5 - b)
+map(arr, 0.5 <= b)
+map(arr, 0.5 > b)
+map(arr, 0.5 ^ a)
+map(arr, 0.5 ^ f)
+map(arr, 0.5) == arr
+map(arr, 0.5) == obj.head(1, a)
+map(arr, 1 + b)
+map(arr, 1 - 0)
+map(arr, 1 / a)
+map(arr, 1 == b)
+map(arr, 2 != nil)
+map(arr, 2 * a)
+map(arr, 2 ** 0.5)
+map(arr, 2 - f)
+map(arr, 2 ^ 2)
+map(arr, a != nil)
+map(arr, a % 2)
+map(arr, a % a <= #)
+map(arr, a * 0.5)
+map(arr, a ** a)
+map(arr, a + b)
+map(arr, a - f)
+map(arr, a / f)
+map(arr, a < 2)
+map(arr, a > 0)
+map(arr, a > a)
+map(arr, a > b)
+map(arr, a ^ b)
+map(arr, a)
+map(arr, abs(0))
+map(arr, add != add)
+map(arr, add != nil)
+map(arr, add == add)
+map(arr, add(#, #))
+map(arr, add(0, a))
+map(arr, add(0, b))
+map(arr, add(2, b))
+map(arr, add)
+map(arr, add)[a]
+map(arr, any(arr, ok))
+map(arr, arr)
+map(arr, b != 0.5)
+map(arr, b * 0.5)
+map(arr, b * b)
+map(arr, b + f)
+map(arr, b - 0.5)
+map(arr, b / f)
+map(arr, b <= 0.5)
+map(arr, b <= 2)
+map(arr, b <= a)
+map(arr, b > 1)
+map(arr, b > a)
+map(arr, b >= a)
+map(arr, b ^ f)
+map(arr, b)
+map(arr, b) != obj.b
+map(arr, b)[obj.b]
+map(arr, count(arr, ok))
+map(arr, count(arr, true))
+map(arr, div == add)
+map(arr, div(1, 1))
+map(arr, div(1, 2))
+map(arr, div(b, b))
+map(arr, div)
+map(arr, div) == arr
+map(arr, div)[obj.b]
+map(arr, div)[obj?.a]
+map(arr, f != b)
+map(arr, f != nil)
+map(arr, f ** 2)
+map(arr, f + a)
+map(arr, f + f)
+map(arr, f - 0.5)
+map(arr, f - f)
+map(arr, f / f)
+map(arr, f < b)
+map(arr, f <= 0)
+map(arr, f <= a)
+map(arr, f == a)
+map(arr, f == nil)
+map(arr, f > a)
+map(arr, f > f)
+map(arr, f >= a)
+map(arr, f ^ 0.5)
+map(arr, f ^ 1)
+map(arr, f)
+map(arr, false ? 0 : f)
+map(arr, false ? 0.5 : arr)
+map(arr, false ? div : a)
+map(arr, false) == obj.obj
+map(arr, filter(arr, ok))
+map(arr, float(1))
+map(arr, float(b))
+map(arr, get(arr, 0))
+map(arr, get(obj, s))
+map(arr, int(f))
+map(arr, len("b"))
+map(arr, lower(s))
+map(arr, map(arr, 0))
+map(arr, map(arr, 0.5))
+map(arr, map(arr, arr))
+map(arr, map(arr, true))
+map(arr, max(f))
+map(arr, min(0))
+map(arr, min(2))
+map(arr, min(b))
+map(arr, min(f))
+map(arr, nil != a)
+map(arr, nil != div)
+map(arr, nil == obj)
+map(arr, not ok)
+map(arr, not true)
+map(arr, obj != nil)
+map(arr, obj != obj?.b)
+map(arr, obj)
+map(arr, obj) != arr ? false : nil
+map(arr, obj) != obj.b
+map(arr, obj)[obj.a]
+map(arr, obj)[obj?.b]
+map(arr, obj.a)
+map(arr, obj.b)
+map(arr, obj.c)
+map(arr, obj.head(add, nil))
+map(arr, obj.head(arr))
+map(arr, obj.head(div))
+map(arr, obj.head(ok, f))
+map(arr, obj.obj)
+map(arr, obj.obj?.b)
+map(arr, obj?.a)
+map(arr, obj?.b)
+map(arr, obj?.fn(0))
+map(arr, obj?.fn(a))
+map(arr, obj?.head("a", b, obj))
+map(arr, obj?.head(0))
+map(arr, obj?.head(1))
+map(arr, obj?.head(add, ok, f))
+map(arr, obj?.head(arr))
+map(arr, obj?.head(b))
+map(arr, obj?.head(s))
+map(arr, obj?.obj)
+map(arr, obj?.obj.b)
+map(arr, obj?.obj?.a)
+map(arr, ok ? arr : s)
+map(arr, ok)
+map(arr, ok)[a]
+map(arr, ok)[b]
+map(arr, one(arr, ok))
+map(arr, repeat(s, a))
+map(arr, s + "a")
+map(arr, s < s)
+map(arr, s > s)
+map(arr, s endsWith s)
+map(arr, s in obj)
+map(arr, s)
+map(arr, s) != obj.a
+map(arr, s) != obj?.obj
+map(arr, s)[obj?.a]
+map(arr, s)[ok ? f : ok:a]
+map(arr, split(s, s))
+map(arr, string(arr))
+map(arr, toJSON(a))
+map(arr, trimPrefix(s))
+map(arr, true || ok)
+map(arr[b:a], ok)
+map(arr[b:b], b)
+map(arr[b:b], ok)
+map(b .. 0, b / b)
+map(b .. 1, #)
+map(b .. 1, s)
+map(b .. a, arr != arr)
+map(b .. a, b)
+map(b .. a, f > 0.5)
+map(b .. a, obj?.fn(ok, add))
+map(b .. a, s)
+map(b .. b, #)
+map(b .. b, ok)
+map(b .. b, string(arr))
+map(div(1, b) <= a ? arr : ok, #)
+map(false ? 0 : "a", obj?.obj)
+map(false ? 0 : obj, b)
+map(false ? 0.5 : arr, #)
+map(false ? a : arr, s)
+map(false ? b : "b", #)
+map(false ? div : arr, 2 * f)
+map(false ? obj : s, a)
+map(false ? s : arr, #)
+map(filter(arr, false), obj?.fn(nil))
+map(filter(arr, false), s)
+map(filter(arr, ok), 1 >= b)
+map(filter(arr, ok), 2 == nil)
+map(filter(arr, ok), a)
+map(filter(arr, ok), arr)
+map(filter(arr, ok), div)
+map(filter(arr, ok), obj)
+map(filter(arr, ok), s)
+map(filter(arr, true), #)
+map(keys(obj), #)
+map(keys(obj), b)
+map(map(arr, "a"), arr)
+map(map(arr, "a"), b)
+map(map(arr, "b"), f)
+map(map(arr, "b"), s)
+map(map(arr, "c"), #)
+map(map(arr, 0), #)
+map(map(arr, 0), obj.head(ok))
+map(map(arr, 0.5), #)
+map(map(arr, 0.5), a)
+map(map(arr, 0.5), arr)
+map(map(arr, 0.5), f)
+map(map(arr, 1), #)
+map(map(arr, 1), arr)
+map(map(arr, 1), b)
+map(map(arr, a), #)
+map(map(arr, a), arr)
+map(map(arr, add), "a" == nil)
+map(map(arr, add), #)
+map(map(arr, add), b)
+map(map(arr, add), obj)
+map(map(arr, arr), #)
+map(map(arr, arr), div)
+map(map(arr, arr), obj)
+map(map(arr, arr), obj?.b)
+map(map(arr, arr), ok)
+map(map(arr, b), #)
+map(map(arr, b), add)
+map(map(arr, b), f)
+map(map(arr, b), map(arr, ok))
+map(map(arr, b), obj)
+map(map(arr, b), ok)
+map(map(arr, b), s)
+map(map(arr, div), !true)
+map(map(arr, div), #)
+map(map(arr, div), add(b, 1))
+map(map(arr, div), add)
+map(map(arr, div), obj)
+map(map(arr, div), obj?.a)
+map(map(arr, div), split(s, s))
+map(map(arr, f), #)
+map(map(arr, f), s)
+map(map(arr, false), #)
+map(map(arr, false), add)
+map(map(arr, false), arr)
+map(map(arr, obj), 0 >= a)
+map(map(arr, obj), a in arr)
+map(map(arr, obj), a)
+map(map(arr, obj), add)
+map(map(arr, obj), b)
+map(map(arr, obj), ok)
+map(map(arr, ok), #)
+map(map(arr, s), #)
+map(map(arr, s), f)
+map(map(arr, s), obj)
+map(map(arr, true), #)
+map(map(arr, true), add)
+map(map(arr, true), f > f)
+map(map(arr, true), f ^ 1)
+map(map(arr, true), obj)
+map(obj.head("a"), #)
+map(obj.head("a", a, 0), #)
+map(obj.head("a", add, ok), b)
+map(obj.head("a", obj, "b", obj), #)
+map(obj.head("b"), a)
+map(obj.head("b"), ok)
+map(obj.head("b", nil, a, div, true), obj.a)
+map(obj.head("c"), b * 1)
+map(obj.head("c", 1, div, "a", f), #)
+map(obj.head("c", arr), #)
+map(obj.head("c", b), 0 * b)
+map(obj.head("c", b), arr)
+map(obj.head(arr), #)
+map(obj.head(arr), a)
+map(obj.head(arr), add)
+map(obj.head(arr), obj.obj)
+map(obj.head(arr), s)
+map(obj.head(arr, 0.5), a)
+map(obj.head(arr, arr, 0), a)
+map(obj.head(arr, false), arr)
+map(obj.head(arr, ok), #)
+map(obj.head(obj), a .. 0)
+map(obj.head(obj), a)
+map(obj.head(obj), arr)
+map(obj.head(obj), f)
+map(obj.head(obj), obj)
+map(obj.head(obj, a), 1 .. b)
+map(obj.head(obj, div), obj.obj)
+map(obj.head(s), #)
+map(obj.head(s), 0 + f)
+map(obj.head(s), a)
+map(obj.head(s), arr)
+map(obj.head(s), b % a)
+map(obj.head(s), b)
+map(obj.head(s), f)
+map(obj.head(s), ok)
+map(obj.head(s), s)
+map(obj.head(s, add, div), f)
+map(obj.head(s, b, f, ok, f), #)
+map(obj.head(s, ok, 0), a / 0.5)
+map(obj.obj, !false)
+map(obj.obj, "b" startsWith s)
+map(obj.obj, "c" > s)
+map(obj.obj, -0.5)
+map(obj.obj, -obj?.b)
+map(obj.obj, 0 == 1)
+map(obj.obj, 0.5 >= b)
+map(obj.obj, 2 + a)
+map(obj.obj, 2 .. b)
+map(obj.obj, a)
+map(obj.obj, add)
+map(obj.obj, arr)
+map(obj.obj, b ** b)
+map(obj.obj, b == 2)
+map(obj.obj, b)
+map(obj.obj, div(0, a))
+map(obj.obj, div)
+map(obj.obj, f)
+map(obj.obj, false || true)
+map(obj.obj, not false)
+map(obj.obj, obj)
+map(obj.obj, obj.a)
+map(obj.obj, obj.b)
+map(obj.obj, obj.fn(a))
+map(obj.obj, obj.head(a, obj, f, f))
+map(obj.obj, obj?.a)
+map(obj.obj, obj?.head(f, add, s))
+map(obj.obj, obj?.head(nil, true))
+map(obj.obj, obj?.head(obj, arr))
+map(obj.obj, ok)
+map(obj.obj, s > s)
+map(obj.obj, s matches s)
+map(obj.obj, s startsWith s)
+map(obj.obj, s)
+map(obj.obj, string(0.5))
+map(obj.obj, toBase64("c"))
+map(obj.obj, toJSON(ok))
+map(obj.obj.obj, a)
+map(obj.obj?.obj, b)
+map(obj?.head("a"), a)
+map(obj?.head("a"), add)
+map(obj?.head("a"), obj)
+map(obj?.head("b"), add)
+map(obj?.head("b", a, arr, ok, true), add)
+map(obj?.head("b", b), obj)
+map(obj?.head("c"), #)
+map(obj?.head("c"), ok && ok)
+map(obj?.head("c", add, f, "b"), #)
+map(obj?.head("c", arr, true), f ^ 0)
+map(obj?.head("c", false), #)
+map(obj?.head(arr), a)
+map(obj?.head(arr), s)
+map(obj?.head(arr, "b"), #)
+map(obj?.head(arr, 2), obj)
+map(obj?.head(arr, add), b)
+map(obj?.head(arr, b, nil, arr), toJSON(ok))
+map(obj?.head(arr, true, f), s)
+map(obj?.head(obj), -a)
+map(obj?.head(obj), b)
+map(obj?.head(obj), obj.b)
+map(obj?.head(obj), ok)
+map(obj?.head(obj, "c"), s)
+map(obj?.head(obj, 0.5), add)
+map(obj?.head(obj, a, false), arr)
+map(obj?.head(obj, f, add, s, true), s >= "b")
+map(obj?.head(obj, ok, b, a), div)
+map(obj?.head(s), b > 0.5)
+map(obj?.head(s), b)
+map(obj?.head(s), f)
+map(obj?.head(s), obj)
+map(obj?.head(s, "a", arr, obj), arr)
+map(obj?.head(s, b), obj?.a)
+map(obj?.head(s, obj), #)
+map(obj?.head(s, ok), a / 2)
+map(obj?.obj, -2)
+map(obj?.obj, 0 + a)
+map(obj?.obj, 0 == f)
+map(obj?.obj, 1 != 0)
+map(obj?.obj, 1 .. 0)
+map(obj?.obj, a != nil)
+map(obj?.obj, a + 0)
+map(obj?.obj, a)
+map(obj?.obj, abs(0))
+map(obj?.obj, add)
+map(obj?.obj, arr)
+map(obj?.obj, b > a)
+map(obj?.obj, b > f)
+map(obj?.obj, b)
+map(obj?.obj, count(arr, false))
+map(obj?.obj, count(arr, true))
+map(obj?.obj, div == add)
+map(obj?.obj, div)
+map(obj?.obj, f * a)
+map(obj?.obj, f)
+map(obj?.obj, first(arr))
+map(obj?.obj, len(s))
+map(obj?.obj, max(f, f * a))
+map(obj?.obj, nil != add)
+map(obj?.obj, nil == obj?.a)
+map(obj?.obj, obj)
+map(obj?.obj, obj.a)
+map(obj?.obj, obj.b)
+map(obj?.obj, obj.fn(0))
+map(obj?.obj, obj.head(b))
+map(obj?.obj, obj.obj)
+map(obj?.obj, obj?.a)
+map(obj?.obj, obj?.b)
+map(obj?.obj, obj?.fn(0))
+map(obj?.obj, obj?.head(ok, 0))
+map(obj?.obj, obj?.obj)
+map(obj?.obj, ok == true)
+map(obj?.obj, ok ? 0.5 : s)
+map(obj?.obj, ok ? false : ok)
+map(obj?.obj, ok)
+map(obj?.obj, s)
+map(obj?.obj, toBase64(s))
+map(obj?.obj, true ? 0 : arr)
+map(obj?.obj.obj, a)
+map(obj?.obj.obj, add)
+map(obj?.obj.obj, div)
+map(obj?.obj.obj, obj.a)
+map(obj?.obj.obj, ok)
+map(ok ? arr : "b", 1 + a)
+map(ok ? arr : nil, a)
+map(ok ? obj : "c", ok)
+map(ok ? obj : 0, arr)
+map(ok ? obj : add, div(b, a))
+map(ok ? obj : arr, arr)
+map(ok ? s : arr, b)
+map(ok ? s : div, #)
+map(ok ? s : div, add)
+map(split(s, "c"), #)
+map(true ? "a" : obj, #)
+map(true ? "b" : div, s)
+map(true ? arr : arr, #)
+map(true ? arr : f, abs(0.5))
+map(true ? arr : nil, arr)
+map(true ? obj : f, obj.head(0, true, 0.5, s))
+map(true ? s : 0, a)
+map(values(obj), f)
+map(values(obj), filter(arr, ok))
+max(-0)
+max(-0.5)
+max(-2)
+max(-a)
+max(-a, 0 + a)
+max(-b)
+max(-f)
+max(0 % 2, b)
+max(0 % a)
+max(0 ** 0.5)
+max(0 ** 2)
+max(0 ** b)
+max(0 ** f)
+max(0 + 0.5)
+max(0 + a)
+max(0 - 2)
+max(0 - a)
+max(0 / 0)
+max(0 / b)
+max(0 / f)
+max(0 ^ b)
+max(0 ^ f)
+max(0) != obj.head(false, f)
+max(0) + b
+max(0) .. a
+max(0) <= b
+max(0) == b
+max(0) > b != ok
+max(0, 0) != f
+max(0, a) < f
+max(0, b) * f
+max(0.5 * f)
+max(0.5 - a)
+max(0.5 - f)
+max(0.5 ^ 0)
+max(0.5) != obj?.a
+max(0.5) + f
+max(0.5) <= 0 * b
+max(0.5) ^ obj.head(b)
+max(0.5, 2) != obj?.b
+max(0.5, b) < b ? div : 2
+max(0.5, b, 0.5) < obj?.a
+max(1 % 1)
+max(1 * a)
+max(1 ** f)
+max(1 - a)
+max(1 / 2)
+max(1 / f)
+max(1 ^ f)
+max(1) .. b
+max(1) / int(f)
+max(1) / max(b, a, 0.5, 2)
+max(1) > 0.5 ? add : ok
+max(2 * 2)
+max(2 * f)
+max(2 + f)
+max(2 - 0.5)
+max(2 / a)
+max(2 / f)
+max(2 ^ 1)
+max(2 ^ f)
+max(2) * b
+max(2) - 0 % a
+max(2) ^ a ^ 0
+max(2, b) != b
+max(a % a)
+max(a % b)
+max(a * 0.5)
+max(a * f)
+max(a ** a)
+max(a ** f)
+max(a + 0.5)
+max(a + 1)
+max(a + 1, f)
+max(a + a)
+max(a - 0)
+max(a - 1)
+max(a - f)
+max(a / a, a)
+max(a / obj?.b)
+max(a / obj?.head(0.5, s, div))
+max(a ^ 0)
+max(a ^ f)
+max(a)
+max(a) - b
+max(a) - div(0, b)
+max(a) .. a
+max(a) < f
+max(a) <= b
+max(a) <= f
+max(a) == b ? 0 : nil
+max(a) > f
+max(a, -b)
+max(a, 0) - b
+max(a, 1) ^ b ** f
+max(a, a)
+max(a, a, b)
+max(a, b)
+max(a, f)
+max(abs(a))
+max(abs(arr[b]))
+max(abs(b))
+max(abs(f ^ 0.5))
+max(add(0, 0))
+max(add(0, b))
+max(add(1, 1))
+max(add(1, 2))
+max(add(2, a))
+max(add(a, 1))
+max(add(a, 2))
+max(add(a, a))
+max(add(b - a, obj.a))
+max(add(b, b))
+max(arr[0])
+max(arr[0], a)
+max(arr[1])
+max(arr[a])
+max(arr[b])
+max(b % b)
+max(b * 0)
+max(b * a)
+max(b * f)
+max(b ** 0)
+max(b ** 0.5)
+max(b ** 2)
+max(b ** a)
+max(b ** f)
+max(b + a)
+max(b - b)
+max(b - f)
+max(b / 0)
+max(b / 2)
+max(b / b)
+max(b / f)
+max(b ^ 0)
+max(b ^ 0.5)
+max(b ^ 1)
+max(b ^ b)
+max(b ^ f)
+max(b)
+max(b) != 0.5 ** 0
+max(b) * f
+max(b) ** a
+max(b) < b
+max(b) == div(b, b)
+max(b) == max(b)
+max(b, 2) ^ b
+max(b, a)
+max(b, a) >= float(f)
+max(b, b)
+max(b, f)
+max(b, float(a))
+max(count(arr, true))
+max(div(0, 2))
+max(div(0, a))
+max(div(1, 1))
+max(div(1, a))
+max(div(1, b))
+max(div(a, 2))
+max(div(a, b))
+max(div(b, 2))
+max(div(b, a))
+max(div(b, b))
+max(f * 0)
+max(f * a)
+max(f * b)
+max(f * b, a)
+max(f * f)
+max(f ** a)
+max(f ** obj.b)
+max(f + 0)
+max(f + a)
+max(f + b)
+max(f - 0)
+max(f - 1)
+max(f - 2)
+max(f - b)
+max(f - f)
+max(f / 0)
+max(f / 0.5)
+max(f / 1)
+max(f / a)
+max(f / b)
+max(f / f)
+max(f ^ a)
+max(f ^ b)
+max(f ^ f)
+max(f ^ f) ^ b
+max(f)
+max(f) != obj.a
+max(f) * a
+max(f) - int(0)
+max(f) / obj?.head(a, ok)
+max(f, 2 / f)
+max(f, a)
+max(f, b)
+max(f, f)
+max(false ? 0 : b)
+max(false ? b : b)
+max(float(0.5))
+max(float(2))
+max(float(b))
+max(float(f))
+max(get(arr, 0), a)
+max(get(arr, a))
+max(get(arr, b))
+max(int(0))
+max(int(0.5))
+max(int(a))
+max(int(b))
+max(last(arr))
+max(len("a"))
+max(len("c"), b)
+max(len(obj.head(s)))
+max(max(0, f, b, a))
+max(max(2))
+max(max(a, 0.5))
+max(max(b))
+max(max(b, 2, f))
+max(max(f))
+max(min(0.5))
+max(min(2))
+max(min(a))
+max(min(a, b))
+max(min(b, 0))
+max(min(f))
+max(true ? a : 0)
+min(-(0.5 ^ b))
+min(-0)
+min(-2)
+min(-a)
+min(-b)
+min(-f)
+min(-f, a)
+min(0 % 2)
+min(0 % b)
+min(0 * a)
+min(0 * b, b)
+min(0 ** a)
+min(0 ** b)
+min(0 ** f, f)
+min(0 + 0)
+min(0 - b)
+min(0 / 1)
+min(0 / 2)
+min(0 / f)
+min(0 ^ 0)
+min(0) % b
+min(0) % obj.b
+min(0) * obj?.b
+min(0) + b
+min(0) - b
+min(0) / a
+min(0) / obj?.head(a)
+min(0) > a / b
+min(0) ^ get(arr, a)
+min(0, 2) ^ f
+min(0.5 * 0)
+min(0.5 ** a)
+min(0.5 - f)
+min(0.5 / a)
+min(0.5 / b)
+min(0.5 / f)
+min(0.5 ^ 0)
+min(0.5 ^ 1)
+min(0.5 ^ a)
+min(0.5) != f
+min(0.5) * a
+min(0.5) ** a
+min(0.5) - f
+min(0.5) > a
+min(1 % b)
+min(1 * f)
+min(1 ** b)
+min(1 + 1)
+min(1 + a)
+min(1 - a)
+min(1 / a)
+min(1 / b)
+min(1 ^ 0)
+min(1) .. obj?.b
+min(1) == obj.obj
+min(1) >= f ? b : arr
+min(1) ^ b
+min(2 % b + a)
+min(2 % b)
+min(2 * b)
+min(2 ** 0)
+min(2 ** f)
+min(2 + 0.5)
+min(2 - b)
+min(2 ^ a)
+min(2) ** f
+min(a % 1)
+min(a % a)
+min(a % b)
+min(a * a)
+min(a * b, int(0))
+min(a * f)
+min(a ** 0)
+min(a ** a, b)
+min(a ** b)
+min(a ** f)
+min(a - 2)
+min(a - a)
+min(a - f)
+min(a / a)
+min(a / b)
+min(a ^ 0.5)
+min(a ^ b)
+min(a ^ obj.a)
+min(a)
+min(a) != f
+min(a) % a
+min(a) ** f
+min(a) - obj.b
+min(a) / b
+min(a) < a / 0
+min(a) == a
+min(a) > b
+min(a) > obj?.a
+min(a) >= a ^ b
+min(a) >= obj.head(f, nil)
+min(a) ^ a
+min(a) ^ f
+min(a, 0.5 / a)
+min(a, 2) ^ f
+min(a, a ** f)
+min(a, a)
+min(a, a) > f ** 0.5
+min(a, b)
+min(a, b) != f / a
+min(abs(0))
+min(abs(a))
+min(abs(b))
+min(add(0, 0))
+min(add(0, 1))
+min(add(0, 2))
+min(add(0, a))
+min(add(2, b))
+min(add(a, a))
+min(add(a, a), b)
+min(add(a, b))
+min(add(b, 0))
+min(add(b, 1))
+min(add(b, a))
+min(add(b, b))
+min(arr[0])
+min(arr[1])
+min(arr[a])
+min(arr[b])
+min(b % a)
+min(b * b)
+min(b * f)
+min(b ** 0)
+min(b ** 0.5)
+min(b ** a)
+min(b + 1)
+min(b + a)
+min(b + b)
+min(b + f)
+min(b - 0)
+min(b - 0.5)
+min(b - a)
+min(b / f)
+min(b / obj.a)
+min(b ^ a)
+min(b ^ f)
+min(b)
+min(b) * obj.a
+min(b) * obj.head(f, b)
+min(b) ** a
+min(b) + div(0, a)
+min(b) .. obj.a
+min(b) < -f
+min(b) <= a / f
+min(b) <= len(s)
+min(b) == obj.a
+min(b) ^ b
+min(b, 0) >= b
+min(b, 0, f) - b
+min(b, 1) != obj?.head(f)
+min(b, a - a)
+min(b, a)
+min(b, a) % obj.b
+min(b, a) ^ 0.5 ^ 0.5
+min(b, f)
+min(count(arr, ok))
+min(count(map(arr, add), f != nil))
+min(div(0, a) / f)
+min(div(0, b))
+min(div(1, a))
+min(div(2, a))
+min(div(2, b))
+min(div(a, 1))
+min(div(a, 2))
+min(div(a, b))
+min(div(a, b), a)
+min(div(b, 2))
+min(div(b, b))
+min(f * a, a)
+min(f ** 0.5)
+min(f ** a)
+min(f ** b)
+min(f ** f)
+min(f - 0.5)
+min(f - a)
+min(f / 0)
+min(f / a)
+min(f / b)
+min(f / f)
+min(f ^ 0)
+min(f ^ 0.5)
+min(f ^ b)
+min(f)
+min(f) * a ^ f
+min(f) ** obj?.head(b, nil, true, 2, add)
+min(f) / obj.a
+min(f) > f
+min(f, a)
+min(f, f)
+min(first(arr))
+min(float(0))
+min(float(b))
+min(get(arr, 0))
+min(get(arr, 1))
+min(get(arr, 2))
+min(get(arr, a))
+min(get(arr, b))
+min(indexOf(s, s))
+min(int(0))
+min(int(1))
+min(int(a))
+min(int(b))
+min(last(arr))
+min(len("c"))
+min(len(arr))
+min(len(obj))
+min(len(obj?.obj))
+min(len(s))
+min(len(s), a)
+min(max(a))
+min(max(b))
+min(max(b, 0.5))
+min(max(f))
+min(min(1))
+min(min(a))
+min(min(b, 0))
+min(min(f))
+min(min(int(f), b))
+min(ok ? b : 2)
+min(ok ? b : a)
+min(true ? 2 : 2)
+nil != "a" == ok
+nil != "a" || b <= 0
+nil != "c" or ok
+nil != 0 && obj.a
+nil != 0 || ok
+nil != 0.5 != ok
+nil != a and ok
+nil != a or ok
+nil != add && b > 0
+nil != add or obj.b
+nil != arr != obj.obj
+nil != arr or ok
+nil != b != obj.obj
+nil != b && obj.b
+nil != b and ok ? ok : add
+nil != b || obj.fn(s, ok).b
+nil != div != obj?.head(ok)
+nil != div != ok
+nil != div and ok
+nil != f and f < 2
+nil != f or obj?.obj
+nil != false or obj.obj
+nil != obj != (ok or ok)
+nil != obj && "c" > "b"
+nil != obj or ok
+nil != obj.a
+nil != obj.b
+nil != obj.obj
+nil != obj.obj.a
+nil != obj.obj.obj
+nil != obj?.a
+nil != obj?.b
+nil != obj?.b .. b
+nil != obj?.obj
+nil != obj?.obj?.b
+nil != obj?.obj?.obj
+nil != ok ? obj.a : add
+nil != s and 0.5 == 2
+nil != s or obj?.fn(1)
+nil != s or ok
+nil != true ? ok != ok : int("c")
+nil == "a" or nil != false
+nil == "c" and obj.fn("b", s, a)
+nil == a || 2 != b
+nil == a || ok
+nil == add != obj?.head(nil, add)
+nil == add != obj?.obj
+nil == add && obj.b
+nil == add and obj == nil
+nil == arr != true ? b : b
+nil == arr && obj.b
+nil == arr && obj?.head(obj, nil, a)
+nil == arr and obj.head(div(arr, a)?.head(add?.fn(nil), arr ? "c" : 0), 0 matches a.obj)
+nil == arr and ok
+nil == div || any(arr, true)
+nil == f != obj.a
+nil == f && obj.a
+nil == f and obj.obj
+nil == false and nil == arr
+nil == false and not false
+nil == nil || 0 >= 0
+nil == obj && obj?.obj
+nil == obj ? f / b : obj
+nil == obj and ok
+nil == obj || obj?.a
+nil == obj || ok
+nil == obj.a
+nil == obj.b
+nil == obj.head(add)
+nil == obj.obj
+nil == obj.obj.obj
+nil == obj?.a
+nil == obj?.b
+nil == obj?.obj
+nil == obj?.obj.a
+nil == obj?.obj.obj
+nil == obj[s]
+nil == ok && !true
+nil == ok && obj?.fn(b)
+nil == ok ? s : b
+nil == ok and obj.obj
+nil == ok and obj?.head("c")
+nil == ok or ok
+nil == ok || obj.a
+nil == ok || ok
+nil == s != ok
+nil == s and obj?.fn(true, 1)
+nil == s or ok
+nil == true and {"b": arr}.b
+nil in arr && obj.a
+nil in arr == ok
+nil in arr ? 2 .. 2 : obj
+nil in obj && ok
+nil in obj or 2 < 0
+nil in obj.obj
+nil in obj?.head(obj)
+nil in obj?.obj
+nil in obj?.obj?.obj
+none(0 .. a, ok)
+none(1 .. b, ok)
+none([true], ok)
+none(a .. 0, obj.a)
+none(a .. a, "b" > "b")
+none(a .. a, nil == obj)
+none(arr, "a" < s)
+none(arr, "a" contains s)
+none(arr, "a" startsWith s)
+none(arr, 0 < 1)
+none(arr, 0 <= b)
+none(arr, 0 == nil)
+none(arr, 0 > 0.5)
+none(arr, 0 >= 0)
+none(arr, 0 >= b)
+none(arr, 0.5 < b)
+none(arr, 0.5 == b)
+none(arr, 0.5 >= 0)
+none(arr, 1 != a)
+none(arr, 1 <= b)
+none(arr, 1 in arr)
+none(arr, 2 <= a)
+none(arr, a != 0)
+none(arr, a != 2)
+none(arr, a != a)
+none(arr, a != nil)
+none(arr, a < 0)
+none(arr, a < f)
+none(arr, a <= 0.5)
+none(arr, a == nil)
+none(arr, a in arr)
+none(arr, add != add)
+none(arr, add == nil)
+none(arr, all(arr, ok))
+none(arr, arr != arr)
+none(arr, b != get(arr, 0))
+none(arr, b < 0)
+none(arr, b < f)
+none(arr, b == a)
+none(arr, b >= a)
+none(arr, div != obj.obj)
+none(arr, div == div)
+none(arr, f != 0)
+none(arr, f != nil)
+none(arr, f == 0.5)
+none(arr, f > f)
+none(arr, false) and ok
+none(arr, nil != add)
+none(arr, nil != b)
+none(arr, nil != f)
+none(arr, nil == 0)
+none(arr, nil == arr)
+none(arr, nil == f)
+none(arr, nil == obj)
+none(arr, none(arr, false))
+none(arr, not ok)
+none(arr, obj.head(false, "b", nil))
+none(arr, obj?.head(false))
+none(arr, obj?.obj == (true and false))
+none(arr, ok ? true : b)
+none(arr, ok and false)
+none(arr, ok or ok)
+none(arr, ok || false)
+none(arr, ok)
+none(arr, ok) && obj.obj
+none(arr, ok) && obj?.obj
+none(arr, ok) == obj.b
+none(arr, ok) == obj?.obj
+none(arr, ok) == ok
+none(arr, s != "b")
+none(arr, s != "c")
+none(arr, s != s)
+none(arr, s endsWith "c")
+none(arr, s matches s)
+none(arr, s startsWith "c")
+none(arr, true) != obj.b
+none(arr, true) and obj.b
+none(arr, true) or obj.head(s, arr)
+none(b .. 0, obj.a)
+none(b .. 2, ok)
+none(false ? 0.5 : arr, s <= "b")
+none(filter(arr, ok), any(arr, ok))
+none(filter(arr, ok), ok and false)
+none(keys(obj), nil == obj)
+none(map(arr, "b"), f < b)
+none(map(arr, add), 0 == f)
+none(map(arr, add), b > a)
+none(map(arr, b), ok)
+none(map(arr, f), ok)
+none(map(arr, false), #)
+none(map(arr, false), ok)
+none(map(arr, obj), s > s)
+none(map(arr, ok), "b" <= "b")
+none(map(arr, ok), #)
+none(map(arr, s), b != nil)
+none(map(arr, s), ok && ok)
+none(map(arr, s), ok || ok)
+none(obj.head(arr), nil == s)
+none(obj.head(obj), s matches "b")
+none(obj.head(obj, true), ok)
+none(obj.head(s), !ok)
+none(obj.obj, 1 < f)
+none(obj.obj, b != a)
+none(obj.obj, b == b)
+none(obj.obj, nil != arr)
+none(obj.obj, ok and true)
+none(obj.obj, ok)
+none(obj.obj, s endsWith s)
+none(obj.obj, s matches s)
+none(obj.obj, true ? ok : "c")
+none(obj?.head("a"), 1 <= 0.5)
+none(obj?.head("b", nil), ok)
+none(obj?.head("b", true), f < f)
+none(obj?.head(obj, b, obj), ok)
+none(obj?.head(obj, nil), ok)
+none(obj?.obj, !ok)
+none(obj?.obj, 1 > b)
+none(obj?.obj, a != f)
+none(obj?.obj, a > f)
+none(obj?.obj, div != add)
+none(obj?.obj, f < 0.5)
+none(obj?.obj, f >= f)
+none(obj?.obj, ok != false)
+none(obj?.obj, ok)
+none(obj?.obj, s contains "b")
+none(obj?.obj, s startsWith s)
+none(obj?.obj, true == false)
+none(obj?.obj.obj, ok)
+none(ok ? "b" : false, ok == ok)
+not !!true
+not !(nil == 0.5)
+not !all(arr, true)
+not !false
+not !ok
+not !true
+not ("a" != "b")
+not ("a" != nil)
+not ("a" <= "c")
+not ("a" <= s)
+not ("a" == "a")
+not ("a" == "c")
+not ("a" == nil)
+not ("a" > s)
+not ("a" >= s)
+not ("a" contains "a")
+not ("a" contains "b")
+not ("a" contains s)
+not ("a" endsWith "b")
+not ("a" endsWith s)
+not ("a" in obj)
+not ("a" matches "c")
+not ("a" startsWith "a")
+not ("a" startsWith "b")
+not ("b" != "a")
+not ("b" != nil)
+not ("b" <= "a")
+not ("b" <= "c")
+not ("b" <= s)
+not ("b" == "a")
+not ("b" == "c")
+not ("b" == nil)
+not ("b" == s)
+not ("b" > s)
+not ("b" >= s)
+not ("b" contains "a")
+not ("b" contains "b")
+not ("b" contains s)
+not ("b" endsWith "a")
+not ("b" endsWith "b")
+not ("b" endsWith s)
+not ("b" in obj)
+not ("b" matches "b")
+not ("b" startsWith "b")
+not ("b" startsWith s)
+not ("c" != "a")
+not ("c" != s)
+not ("c" <= "c")
+not ("c" == "a")
+not ("c" > "b")
+not ("c" >= "a")
+not ("c" >= s)
+not ("c" contains "a")
+not ("c" contains "c")
+not ("c" contains s)
+not ("c" endsWith s)
+not ("c" in obj)
+not ("c" matches "a")
+not ("c" matches "b")
+not ("c" matches s)
+not ("c" startsWith s)
+not (-0.5 < a)
+not (0 != 0)
+not (0 != 2)
+not (0 != a)
+not (0 != b)
+not (0 != f)
+not (0 != nil)
+not (0 < 0.5)
+not (0 < 2)
+not (0 < a)
+not (0 < b)
+not (0 < f)
+not (0 <= 0)
+not (0 <= 0.5)
+not (0 <= 1)
+not (0 <= a)
+not (0 <= b)
+not (0 <= f)
+not (0 == 0.5)
+not (0 == 1)
+not (0 == 2)
+not (0 == a)
+not (0 == f)
+not (0 == nil)
+not (0 > 0)
+not (0 > 0.5)
+not (0 > 2)
+not (0 > a)
+not (0 > b)
+not (0 > f)
+not (0 >= 0)
+not (0 >= 0.5)
+not (0 >= 1)
+not (0 >= 2)
+not (0 >= a)
+not (0 >= b)
+not (0 >= f)
+not (0 in arr)
+not (0.5 != 0)
+not (0.5 != 0.5)
+not (0.5 != a)
+not (0.5 != b)
+not (0.5 != f)
+not (0.5 != nil)
+not (0.5 < 0.5)
+not (0.5 < a)
+not (0.5 < b)
+not (0.5 < f)
+not (0.5 <= 0)
+not (0.5 <= a)
+not (0.5 <= b)
+not (0.5 == 0)
+not (0.5 == 0.5)
+not (0.5 == 2)
+not (0.5 == a)
+not (0.5 == b)
+not (0.5 == f)
+not (0.5 == nil)
+not (0.5 > 0)
+not (0.5 > 1)
+not (0.5 > a)
+not (0.5 > b)
+not (0.5 > f)
+not (0.5 >= 0)
+not (0.5 >= 0.5)
+not (0.5 >= a)
+not (0.5 >= b)
+not (0.5 >= f)
+not (1 != 0)
+not (1 != b)
+not (1 != f)
+not (1 != nil)
+not (1 < 0)
+not (1 < a)
+not (1 < f)
+not (1 <= f)
+not (1 == 0.5)
+not (1 == b)
+not (1 == f)
+not (1 > 0.5)
+not (1 > b)
+not (1 > f)
+not (1 >= 0)
+not (1 >= 0.5)
+not (1 >= 2)
+not (1 >= a)
+not (1 >= f)
+not (1 in arr)
+not (2 != 0.5)
+not (2 != 2)
+not (2 != a)
+not (2 != f)
+not (2 != nil)
+not (2 < 0.5)
+not (2 < b)
+not (2 < f)
+not (2 <= 0.5)
+not (2 <= b)
+not (2 <= f)
+not (2 == a)
+not (2 > 0)
+not (2 > 1)
+not (2 > a)
+not (2 > b)
+not (2 > f)
+not (2 >= a)
+not (2 >= b)
+not (2 >= b) && ok
+not (2 in arr)
+not (a != 0)
+not (a != 0.5)
+not (a != 2)
+not (a != a)
+not (a != b)
+not (a != f)
+not (a < 0)
+not (a < 1)
+not (a < 2)
+not (a < a)
+not (a < b)
+not (a < f)
+not (a <= 0)
+not (a <= 0.5)
+not (a <= 1)
+not (a <= a)
+not (a <= b)
+not (a <= f)
+not (a == 0)
+not (a == 0.5)
+not (a == 1)
+not (a == 2)
+not (a == a)
+not (a == b)
+not (a == f)
+not (a == nil)
+not (a > 0)
+not (a > 1)
+not (a > a)
+not (a > b)
+not (a > f)
+not (a >= 0)
+not (a >= 0.5)
+not (a >= 1)
+not (a >= a)
+not (a >= b)
+not (a >= f)
+not (a in arr)
+not (add != add)
+not (add != div)
+not (add != nil)
+not (add == add)
+not (add == div)
+not (add == nil)
+not (arr != arr)
+not (arr != nil)
+not (arr == arr)
+not (arr == nil)
+not (b != 0)
+not (b != 0.5)
+not (b != 1)
+not (b != 2)
+not (b != a)
+not (b != b)
+not (b != f)
+not (b != nil)
+not (b ** 0 >= a)
+not (b < 0)
+not (b < 0.5)
+not (b < a)
+not (b < b)
+not (b < f)
+not (b <= 0.5)
+not (b <= 1)
+not (b <= 2)
+not (b <= a)
+not (b <= b)
+not (b <= f)
+not (b == 0)
+not (b == 0.5)
+not (b == 1)
+not (b == 2)
+not (b == a)
+not (b == b)
+not (b == f)
+not (b == nil)
+not (b > 0)
+not (b > 1)
+not (b > 2)
+not (b > a)
+not (b > b)
+not (b > f)
+not (b >= 0)
+not (b >= 0.5)
+not (b >= a)
+not (b >= b)
+not (b >= f)
+not (b in arr)
+not (div != add)
+not (div != div)
+not (div != nil)
+not (div == add)
+not (div == div)
+not (div == nil)
+not (f != 0)
+not (f != 0.5)
+not (f != a)
+not (f != b)
+not (f != f)
+not (f < 0)
+not (f < 1)
+not (f < 2)
+not (f < a)
+not (f < b)
+not (f < f)
+not (f <= 1)
+not (f <= a)
+not (f <= b)
+not (f <= f)
+not (f == 0)
+not (f == 0.5)
+not (f == 1)
+not (f == 2)
+not (f == a)
+not (f == b)
+not (f == f)
+not (f == nil)
+not (f > 0)
+not (f > 0.5)
+not (f > 1)
+not (f > 2)
+not (f > a)
+not (f > b)
+not (f > f)
+not (f > obj.b)
+not (f >= 0)
+not (f >= 1)
+not (f >= 2)
+not (f >= a)
+not (f >= b)
+not (f >= f)
+not (false != false)
+not (false != nil)
+not (false != ok)
+not (false && ok)
+not (false && true)
+not (false == nil)
+not (false == ok)
+not (false == true)
+not (false and true)
+not (false or false)
+not (false || false)
+not (false || ok)
+not (false || true)
+not (nil != "b")
+not (nil != "c")
+not (nil != 0)
+not (nil != 2)
+not (nil != a)
+not (nil != add)
+not (nil != arr)
+not (nil != b)
+not (nil != div)
+not (nil != f)
+not (nil != nil)
+not (nil != obj)
+not (nil != ok)
+not (nil != s)
+not (nil != true)
+not (nil == "b")
+not (nil == 0)
+not (nil == 0.5)
+not (nil == a)
+not (nil == add)
+not (nil == arr)
+not (nil == b)
+not (nil == div)
+not (nil == f)
+not (nil == false)
+not (nil == nil)
+not (nil == obj)
+not (nil == ok)
+not (nil == s)
+not (nil == true)
+not (nil in arr)
+not (nil in obj)
+not (obj != nil)
+not (obj != obj)
+not (obj == nil)
+not (obj == obj)
+not (obj.b != a ** a)
+not (obj.b == ok)
+not (obj.head(a) ** f <= f)
+not (obj.head(b, div) == s)
+not (obj.obj == f)
+not (obj?.a != f ** 1)
+not (obj?.b < b)
+not (obj?.b == ok)
+not (ok != false)
+not (ok != nil)
+not (ok != ok)
+not (ok != true)
+not (ok && false)
+not (ok && ok)
+not (ok && true)
+not (ok == false)
+not (ok == nil)
+not (ok == true)
+not (ok and false)
+not (ok and ok)
+not (ok and true)
+not (ok or false)
+not (ok or ok)
+not (ok || obj.b)
+not (ok || ok)
+not (ok || true)
+not (s != "a")
+not (s != "b")
+not (s != "c")
+not (s != nil)
+not (s != s)
+not (s < "a")
+not (s < "b")
+not (s < "c")
+not (s < s)
+not (s <= "a")
+not (s <= "b")
+not (s <= "c")
+not (s <= s)
+not (s == "a")
+not (s == "b")
+not (s == "c")
+not (s == nil)
+not (s == s)
+not (s > "c")
+not (s > s)
+not (s >= "a")
+not (s >= "b")
+not (s >= "c")
+not (s >= s)
+not (s contains "c")
+not (s contains s)
+not (s endsWith "a")
+not (s endsWith "b")
+not (s endsWith lower("b"))
+not (s endsWith s)
+not (s in obj)
+not (s matches "a")
+not (s matches "c")
+not (s matches s)
+not (s startsWith "a")
+not (s startsWith "b")
+not (s startsWith s)
+not (true != false)
+not (true != nil)
+not (true != ok)
+not (true != true)
+not (true && false)
+not (true && true)
+not (true == nil)
+not (true == ok)
+not (true == true)
+not (true and false)
+not (true and ok)
+not (true or false)
+not (true or ok)
+not (true or true)
+not (true || ok)
+not (true || true)
+not all(arr, false)
+not all(arr, ok)
+not all(arr, true)
+not any(arr, false)
+not any(arr, ok)
+not any(arr, true)
+not false ? "a" : obj
+not false ? "c" : 0.5
+not false ? 0 : obj.obj
+not false ? 0.5 : 0.5
+not false ? 0.5 : a
+not false ? 2 : 1
+not false ? a : div
+not false ? a : s
+not false ? add : 2
+not false ? add : obj
+not false ? arr : arr
+not false ? b : div
+not false ? b : ok
+not false ? b : s
+not false ? div : nil
+not false ? div : ok
+not false ? f : "a"
+not false ? f : 0
+not false ? f : 1
+not false ? false : s
+not false ? nil : "b"
+not false ? nil : f
+not false ? obj : "c"
+not false ? obj : add
+not false ? ok : nil
+not false ? ok : ok
+not false ? s : 0
+not false ? s : add
+not false ? s : b
+not false ? s : obj
+not false ? s : true
+not false ? true : false
+not false and obj.head(add)
+not false and obj?.obj.obj
+not false or b == nil
+not false or obj?.fn(false)
+not false or obj?.head(arr, obj)?.b
+not false or obj?.obj
+not false || a <= b
+not hasPrefix(s, "c")
+not hasSuffix("a", "a")
+not hasSuffix(s, "a")
+not none(arr, false)
+not none(arr, ok)
+not none(arr, true)
+not not (f > f)
+not not (nil == div)
+not not false
+not not obj.head(ok, ok)
+not not ok
+not not true
+not obj.head(f != true)
+not obj.head(false)
+not obj.head(false, add)
+not obj.head(false, div)
+not obj.head(obj, arr, b, nil).head(f <= 0)
+not obj.head(ok)
+not obj.head(ok, a)
+not obj.head(ok, add, a, s)
+not obj.head(ok, b, s)
+not obj.head(ok, div)
+not obj.head(true == "c")
+not obj.head(true)
+not obj?.head(0.5 <= a)
+not obj?.head(false)
+not obj?.head(false, 1)
+not obj?.head(false, b)
+not obj?.head(false, nil)
+not obj?.head(ok)
+not obj?.head(ok, "c")
+not obj?.head(ok, 0)
+not obj?.head(ok, a)
+not obj?.head(ok, div)
+not obj?.head(ok, div, a)
+not obj?.head(ok, f, true)
+not obj?.head(ok, s)
+not obj?.head(true)
+not ok
+not ok != obj.obj
+not ok != obj.obj?.obj
+not ok != ok
+not ok && obj.obj
+not ok && obj?.b
+not ok && obj?.head(b).a
+not ok && s > obj?.a
+not ok == obj?.a
+not ok == obj?.b
+not ok == ok
+not ok ? "a" : b
+not ok ? "a" : f
+not ok ? "b" : a
+not ok ? "b" : f
+not ok ? "b" : s
+not ok ? "c" : a
+not ok ? 0 : obj
+not ok ? 0 : true
+not ok ? 0.5 : false
+not ok ? 1 : b
+not ok ? 1 : f
+not ok ? 1 : true
+not ok ? 2 : div
+not ok ? 2 : true
+not ok ? a : 1
+not ok ? a : a
+not ok ? a : obj
+not ok ? a : s
+not ok ? add : 1
+not ok ? add : b
+not ok ? add : nil
+not ok ? add : s
+not ok ? arr : nil
+not ok ? arr : ok
+not ok ? arr : true
+not ok ? b : a
+not ok ? b : add
+not ok ? b : div
+not ok ? b : obj
+not ok ? div : 1
+not ok ? div : a
+not ok ? div : b
+not ok ? div : obj.b
+not ok ? f : "c"
+not ok ? f : false
+not ok ? f : obj?.obj
+not ok ? f : s
+not ok ? false : "c"
+not ok ? obj : arr
+not ok ? obj : b
+not ok ? obj : div
+not ok ? ok : "c"
+not ok ? ok : 0
+not ok ? ok : a
+not ok ? ok : add
+not ok ? ok : arr
+not ok ? ok : ok
+not ok ? s : a
+not ok ? true : add
+not ok ? true : false
+not ok and obj?.a.obj
+not ok or obj.a
+not ok or ok
+not ok || 0 <= f
+not ok || obj.head(0, nil)
+not ok || obj?.obj
+not ok || ok
+not one(arr, false)
+not one(arr, ok)
+not one(arr, true)
+not true != obj?.b
+not true ? "b" : b
+not true ? 0 : div
+not true ? 0.5 : ok
+not true ? 1 : obj
+not true ? a : a
+not true ? arr : 1
+not true ? arr : b
+not true ? b : "a"
+not true ? b : 2
+not true ? b : a
+not true ? b : div
+not true ? b : obj
+not true ? div : nil
+not true ? div : true
+not true ? f : false
+not true ? f : obj
+not true ? f : true
+not true ? nil : "c"
+not true ? nil : a
+not true ? obj : arr
+not true ? obj : f
+not true ? obj : ok
+not true ? s : ok
+not true and obj[s]
+not true and ok
+not true or obj.obj?.a
+not true || ok
+obj
+obj != get(obj, s)
+obj != nil == true
+obj != nil ? f : "b"
+obj != nil and obj?.fn(a)
+obj != nil and s <= "a"
+obj != nil || b <= obj.fn(fromJSON(a), trimSuffix(div(true), true % s, a startsWith obj, f ^ add), f)
+obj != obj
+obj != obj != ok
+obj != obj && obj?.head(0, true)
+obj != obj == ok
+obj != obj ? 0 : obj
+obj != obj ? 1 : 0.5
+obj != obj or obj.obj
+obj != obj || obj?.obj
+obj != obj.a
+obj != obj.b
+obj != obj.c
+obj != obj.fn(a)
+obj != obj.fn(b)
+obj != obj.head(b, f)
+obj != obj.head(f, s, s, ok)
+obj != obj.head(false)
+obj != obj.head(nil or false)
+obj != obj.head(ok)
+obj != obj.obj
+obj != obj.obj.b
+obj != obj.obj?.b
+obj != obj.obj?.obj
+obj != obj?.a
+obj != obj?.b
+obj != obj?.fn(b)
+obj != obj?.head(0, b)
+obj != obj?.head(a, 0)
+obj != obj?.head(obj)
+obj != obj?.obj
+obj != obj?.obj.b
+obj != obj?.obj.obj
+obj != obj?.obj?.b
+obj != obj?.obj?.obj
+obj != obj[s]
+obj != {"a": 2, "b": b}
+obj == nil && obj?.fn(nil)
+obj == nil == true ? 0.5 : obj
+obj == nil ? add : add
+obj == nil ? arr : arr
+obj == nil ? b : 1
+obj == nil ? obj : "c"
+obj == obj
+obj == obj != any(arr, true)
+obj == obj != ok
+obj == obj && ok
+obj == obj ? false : f
+obj == obj ? ok : s
+obj == obj or obj?.head(f, false, obj)
+obj == obj.a
+obj == obj.b
+obj == obj.head(0.5)
+obj == obj.head(2 == s)
+obj == obj.head(a)
+obj == obj.head(b)
+obj == obj.head(false)
+obj == obj.head(int(arr, ok, b, a), 2 * b)
+obj == obj.head(obj, s)
+obj == obj.head(s == div)
+obj == obj.obj
+obj == obj.obj.b
+obj == obj?.a
+obj == obj?.b
+obj == obj?.fn(0 + b)
+obj == obj?.fn(2)
+obj == obj?.head(0, f)
+obj == obj?.head(a)
+obj == obj?.head(add, "c", add, "a")
+obj == obj?.head(add, ok)
+obj == obj?.head(filter(arr, ok))
+obj == obj?.head(nil)
+obj == obj?.head(obj, 0)
+obj == obj?.obj
+obj == obj?.obj.a
+obj == obj?.obj?.a
+obj == obj?.obj?.b
+obj == obj[nil]
+obj in [0.5, a, true, obj]
+obj in [arr]
+obj in obj?.head(arr)
+obj in obj[s]
+obj.a
+obj.a != "c" ? obj : a
+obj.a != 0.5 - b
+obj.a != a
+obj.a != a * 0.5
+obj.a != add
+obj.a != add ? false : ok
+obj.a != arr
+obj.a != b
+obj.a != b / a && ok
+obj.a != div
+obj.a != div != false
+obj.a != div ? s : a
+obj.a != div or ok
+obj.a != f
+obj.a != last(arr)
+obj.a != obj
+obj.a != obj ? f : ok
+obj.a != obj.a
+obj.a != obj.head(add, obj)
+obj.a != obj.obj.obj
+obj.a != obj?.b
+obj.a != obj?.obj.a
+obj.a != ok
+obj.a != ok ? ok : 0.5
+obj.a != s
+obj.a != string(nil)
+obj.a != string(ok)
+obj.a != toJSON(0.5)
+obj.a % a
+obj.a % b
+obj.a % int(b)
+obj.a % obj.a
+obj.a % obj?.b
+obj.a * (0.5 + 0)
+obj.a * -a
+obj.a * 0 ^ f
+obj.a * a
+obj.a * b
+obj.a * count(arr, ok)
+obj.a * div(0, b)
+obj.a * f
+obj.a * len(arr)
+obj.a * obj.b
+obj.a * obj?.b
+obj.a ** (a % 2)
+obj.a ** (a + a)
+obj.a ** (b - f)
+obj.a ** 0 ** a
+obj.a ** 0.5 ^ 0.5
+obj.a ** a
+obj.a ** b
+obj.a ** div(a, 1)
+obj.a ** f
+obj.a + -b
+obj.a + a
+obj.a + b
+obj.a + f
+obj.a + int(b)
+obj.a + max(b, 2)
+obj.a + obj.a
+obj.a + obj.b
+obj.a + obj.head(a, true, nil)
+obj.a + obj?.a
+obj.a + obj?.b
+obj.a + obj?.fn(0)
+obj.a - 0 + f
+obj.a - a
+obj.a - a - 0.5
+obj.a - b
+obj.a - f
+obj.a - obj.a
+obj.a - obj.b
+obj.a - obj.head(obj).a
+obj.a - obj?.b
+obj.a .. a
+obj.a .. add(a, a)
+obj.a .. b
+obj.a .. div(0, a)
+obj.a .. max(a)
+obj.a / -f
+obj.a / 0 ^ b
+obj.a / a
+obj.a / b
+obj.a / f
+obj.a / f * b
+obj.a / obj.head(a, nil)
+obj.a / obj?.b
+obj.a < -2
+obj.a < 0 ? f : a
+obj.a < a
+obj.a < b
+obj.a < b ^ f
+obj.a < f
+obj.a < obj.b
+obj.a <= 0.5 / b
+obj.a <= 1 / a
+obj.a <= a
+obj.a <= a + f
+obj.a <= a ? 0 : nil
+obj.a <= a ? 2 : 0.5
+obj.a <= b
+obj.a <= b ** f
+obj.a <= count(arr, ok)
+obj.a <= f
+obj.a <= f ** a
+obj.a <= obj.a
+obj.a == (true && ok)
+obj.a == 2 / b
+obj.a == a
+obj.a == a * a
+obj.a == abs(0.5)
+obj.a == add
+obj.a == arr
+obj.a == arr != true
+obj.a == arr[0]
+obj.a == b
+obj.a == div
+obj.a == div == obj?.b
+obj.a == f
+obj.a == false ? div : add
+obj.a == filter(arr, ok)
+obj.a == map(arr, true)
+obj.a == not false
+obj.a == obj
+obj.a == obj ? 0 : a
+obj.a == obj ? arr : 0.5
+obj.a == obj.a
+obj.a == obj.b
+obj.a == obj.obj
+obj.a == obj?.b
+obj.a == obj?.obj
+obj.a == ok
+obj.a == s
+obj.a == string(false)
+obj.a > a
+obj.a > a ** f
+obj.a > a ? div : s
+obj.a > add(a, a)
+obj.a > add(b, 0)
+obj.a > b
+obj.a > f
+obj.a > f ? f : 0
+obj.a > max(f)
+obj.a > obj?.a
+obj.a > obj?.b
+obj.a >= 0 - 0
+obj.a >= a
+obj.a >= abs(0)
+obj.a >= add(b, 1)
+obj.a >= b
+obj.a >= f
+obj.a >= f ^ 0.5
+obj.a >= obj.a
+obj.a >= obj.b
+obj.a >= obj?.b
+obj.a ^ (a % a)
+obj.a ^ a
+obj.a ^ b
+obj.a ^ f
+obj.a ^ len(arr)
+obj.a ^ obj.a
+obj.a ^ obj.b
+obj.a ^ obj.fn(a)
+obj.a ^ obj?.a
+obj.a and !true
+obj.a in arr
+obj.a or not false
+obj.a or true || obj?.a
+obj.b
+obj.b != "c" ? s : ok
+obj.b != 0 / a
+obj.b != 1 / a
+obj.b != a
+obj.b != a ** f
+obj.b != add
+obj.b != arr
+obj.b != arr[1]
+obj.b != b
+obj.b != div
+obj.b != f
+obj.b != f - 0.5
+obj.b != f ? ok : add
+obj.b != int(f)
+obj.b != nil ? f : obj.b
+obj.b != obj
+obj.b != obj.a
+obj.b != obj.b
+obj.b != obj?.a
+obj.b != obj?.head(b, obj)
+obj.b != obj?.obj
+obj.b != ok
+obj.b != ok ? 0 : b
+obj.b != s
+obj.b != s ? nil : arr
+obj.b != trimSuffix("b")
+obj.b % 2 * f
+obj.b % a
+obj.b % abs(a)
+obj.b % b
+obj.b % len(arr)
+obj.b % len(obj)
+obj.b % obj.a
+obj.b % obj?.a
+obj.b && false ? 0.5 : f
+obj.b * (0.5 - b)
+obj.b * (a + 0.5)
+obj.b * 0.5 / a
+obj.b * a
+obj.b * add(0, a)
+obj.b * b
+obj.b * div(b, b)
+obj.b * f
+obj.b * f / f
+obj.b * get(arr, a)
+obj.b * obj.a
+obj.b * obj.b
+obj.b * obj.head(2, add, false, arr)
+obj.b ** a
+obj.b ** add(1, 2)
+obj.b ** add(b, a) != f
+obj.b ** b
+obj.b ** f
+obj.b ** f ^ 1
+obj.b ** obj.a
+obj.b ** obj.b
+obj.b ** obj?.b
+obj.b ** obj?.head(f, obj, 0.5, arr, ok)
+obj.b + -b
+obj.b + 0 / 2
+obj.b + a
+obj.b + a % 2
+obj.b + b
+obj.b + f
+obj.b + f / 2
+obj.b + len(s)
+obj.b + obj.b
+obj.b + obj?.a
+obj.b + obj?.b
+obj.b - 0 * f
+obj.b - 0 ^ a
+obj.b - a
+obj.b - b
+obj.b - div(a, a)
+obj.b - f
+obj.b - obj.b
+obj.b - obj?.a
+obj.b - obj?.b
+obj.b .. 0 - b
+obj.b .. 2 - a
+obj.b .. a
+obj.b .. b
+obj.b .. b * 0
+obj.b .. b - 0
+obj.b .. obj.a
+obj.b .. obj.b
+obj.b .. obj?.head(f, ok, obj, add, 0.5)
+obj.b / (0.5 + a)
+obj.b / -f
+obj.b / 0.5 ** a
+obj.b / 0.5 / a
+obj.b / a
+obj.b / b
+obj.b / f
+obj.b / obj?.a
+obj.b / obj?.head(a, div)
+obj.b < 0 - b
+obj.b < 1 / a
+obj.b < 2 * 0
+obj.b < 2 + b
+obj.b < a
+obj.b < b
+obj.b < f
+obj.b < get(obj, "b")
+obj.b < len("c")
+obj.b < min(f)
+obj.b < obj.a
+obj.b < obj.b
+obj.b <= 0.5 == nil
+obj.b <= 2 ? "a" : a
+obj.b <= a
+obj.b <= a * f
+obj.b <= a - f
+obj.b <= a ? a : 0
+obj.b <= arr[a]
+obj.b <= b
+obj.b <= f
+obj.b <= f != ok
+obj.b <= get(arr, a)
+obj.b <= min(b)
+obj.b <= obj.a
+obj.b <= obj.fn(0)
+obj.b <= obj?.a
+obj.b <= obj?.b
+obj.b <= obj?.head(b, 0)
+obj.b == !false
+obj.b == "c" ? a : nil
+obj.b == (ok && true)
+obj.b == (ok and true)
+obj.b == 0.5 ? arr : "c"
+obj.b == a
+obj.b == a .. a
+obj.b == a ? false : false
+obj.b == a ^ a
+obj.b == add
+obj.b == arr
+obj.b == b
+obj.b == b / 0
+obj.b == div
+obj.b == f
+obj.b == f ? 1 : "c"
+obj.b == f ? nil : b
+obj.b == f ? obj : ok
+obj.b == f ? s : arr
+obj.b == int(0.5)
+obj.b == map(arr, 0)
+obj.b == obj
+obj.b == obj.a
+obj.b == obj.b
+obj.b == obj.head(nil)
+obj.b == obj.obj
+obj.b == obj?.a
+obj.b == obj?.b
+obj.b == ok
+obj.b == s
+obj.b == toBase64(s)
+obj.b > -a
+obj.b > 0 ? b : f
+obj.b > a
+obj.b > a ** a
+obj.b > b
+obj.b > b + 0
+obj.b > f
+obj.b > int(1)
+obj.b > obj.a
+obj.b > obj.b
+obj.b > obj?.b
+obj.b > obj?.fn(0)
+obj.b >= 0 ** 1
+obj.b >= 0.5 / f
+obj.b >= 0.5 ^ 1
+obj.b >= 1 ? 2 : obj
+obj.b >= a
+obj.b >= a ? ok : b
+obj.b >= b
+obj.b >= b + b
+obj.b >= f
+obj.b >= max(b)
+obj.b >= obj.a
+obj.b >= obj.fn(b)
+obj.b >= obj?.a
+obj.b >= obj?.head(b)
+obj.b ^ a
+obj.b ^ b
+obj.b ^ f
+obj.b ^ obj.head(a, true, arr, s)
+obj.b ^ obj.obj.b
+obj.b ^ obj?.b
+obj.b and !false
+obj.b and !true
+obj.b and false == true
+obj.b in arr
+obj.b or false and true
+obj.c in obj
+obj.c?.a
+obj.c?.b
+obj.c?.b.b
+obj.c?.b?.b
+obj.c?.fn(b)
+obj.c?.head("a" != arr)
+obj.c?.head(a)
+obj.c?.head(b)
+obj.c?.obj
+obj.c?.obj?.head(div)
+obj.fn(-0)
+obj.fn(-1)
+obj.fn(-2)
+obj.fn(-a)
+obj.fn(-b)
+obj.fn(0 && true)
+obj.fn(0 * a)
+obj.fn(0 + 0)
+obj.fn(0 + b)
+obj.fn(0 - 0)
+obj.fn(0 and true)
+obj.fn(0 || false)
+obj.fn(0) != b
+obj.fn(0) * a
+obj.fn(0) ** f
+obj.fn(0) + f
+obj.fn(0) - b
+obj.fn(0) / a
+obj.fn(0) / b
+obj.fn(0) <= b + 0
+obj.fn(0) == a
+obj.fn(0) == b
+obj.fn(0) == s
+obj.fn(0) >= a
+obj.fn(0) ^ f
+obj.fn(1 % b)
+obj.fn(1 * b)
+obj.fn(1 + b)
+obj.fn(1 and true)
+obj.fn(1) ** obj?.b
+obj.fn(1) + b
+obj.fn(1) == add
+obj.fn(2 % 1)
+obj.fn(2 * 1)
+obj.fn(2 * a)
+obj.fn(2 + b)
+obj.fn(2) != add
+obj.fn(2) < f
+obj.fn(a % a)
+obj.fn(a * 0)
+obj.fn(a + 1)
+obj.fn(a + 2)
+obj.fn(a + a)
+obj.fn(a - 1)
+obj.fn(a - 2)
+obj.fn(a and true)
+obj.fn(a or false)
+obj.fn(a)
+obj.fn(a) != 2 - b
+obj.fn(a) != b
+obj.fn(a) != f
+obj.fn(a) != ok
+obj.fn(a) % a
+obj.fn(a) % b
+obj.fn(a) * a
+obj.fn(a) ** a
+obj.fn(a) ** b
+obj.fn(a) - a
+obj.fn(a) < a
+obj.fn(a) == add
+obj.fn(a) == arr
+obj.fn(a) == map(arr, arr)
+obj.fn(a) > b
+obj.fn(a) >= b
+obj.fn(a) ^ f
+obj.fn(a) and !true
+obj.fn(abs(1))
+obj.fn(abs(2))
+obj.fn(abs(f, s, b, b))
+obj.fn(add(0, 2))
+obj.fn(add(0, a))
+obj.fn(add(0, b))
+obj.fn(add(1, 1))
+obj.fn(add(1, b))
+obj.fn(add(2, a))
+obj.fn(add(a, 0))
+obj.fn(add(a, a))
+obj.fn(add(a, b))
+obj.fn(add(b, 2))
+obj.fn(add(b, b))
+obj.fn(arr[0])
+obj.fn(arr[a])
+obj.fn(arr[b])
+obj.fn(b % a)
+obj.fn(b % b)
+obj.fn(b && true)
+obj.fn(b * 0)
+obj.fn(b * 1)
+obj.fn(b * b)
+obj.fn(b + obj?.a)
+obj.fn(b - 1)
+obj.fn(b - 2)
+obj.fn(b - a)
+obj.fn(b or false)
+obj.fn(b || false)
+obj.fn(b)
+obj.fn(b) != a
+obj.fn(b) != div
+obj.fn(b) * b ^ f
+obj.fn(b) ** b
+obj.fn(b) + b
+obj.fn(b) .. a % 2
+obj.fn(b) .. b * b
+obj.fn(b) < b
+obj.fn(b) < f
+obj.fn(b) <= 0 % b
+obj.fn(b) <= b
+obj.fn(b) == a / 1
+obj.fn(b) == div ? obj : div
+obj.fn(b) == ok
+obj.fn(b) > f
+obj.fn(b) ^ obj?.a
+obj.fn(count("a", false))
+obj.fn(count("b", ok))
+obj.fn(count("b", true))
+obj.fn(count("c", ok))
+obj.fn(count("c", true))
+obj.fn(count(1 .. f, s))
+obj.fn(count(arr, false))
+obj.fn(count(arr, ok))
+obj.fn(count(obj, ok))
+obj.fn(count(s, ok))
+obj.fn(div(0, a))
+obj.fn(div(0, b))
+obj.fn(div(1, 1))
+obj.fn(div(1, b))
+obj.fn(div(a, a))
+obj.fn(div(a, b))
+obj.fn(div(b, a))
+obj.fn(div(b, b))
+obj.fn(f == obj or b)
+obj.fn(false ? 0 : b)
+obj.fn(false or 0)
+obj.fn(false or a)
+obj.fn(false || 0)
+obj.fn(false || 2)
+obj.fn(false || a)
+obj.fn(get(arr, 0))
+obj.fn(get(arr, 0.5))
+obj.fn(get(arr, b))
+obj.fn(int("b", a))
+obj.fn(int(0))
+obj.fn(int(1))
+obj.fn(int(a))
+obj.fn(int(a, 0))
+obj.fn(int(b))
+obj.fn(int(b, s, a, "a", f))
+obj.fn(int(obj, true, b))
+obj.fn(int(true, f))
+obj.fn(last(arr))
+obj.fn(last(arr, b))
+obj.fn(len("b"))
+obj.fn(len(0, obj))
+obj.fn(len(arr))
+obj.fn(len(arr, s))
+obj.fn(len(f, arr))
+obj.fn(len(false, 1, s, obj))
+obj.fn(len(nil, arr))
+obj.fn(len(s))
+obj.fn(max(0))
+obj.fn(max(0, b))
+obj.fn(max(1))
+obj.fn(max(1, 0.5))
+obj.fn(max(a))
+obj.fn(max(b))
+obj.fn(min(0))
+obj.fn(min(0, f, a))
+obj.fn(min(1))
+obj.fn(min(a))
+obj.fn(min(b))
+obj.fn(min(f, f, 0))
+obj.fn(obj.a)
+obj.fn(obj.a) < b
+obj.fn(obj.b)
+obj.fn(obj.fn(1))
+obj.fn(obj.fn(2))
+obj.fn(obj.fn(a))
+obj.fn(obj.head(0))
+obj.fn(obj.head(0, add))
+obj.fn(obj.head(2))
+obj.fn(obj.head(a))
+obj.fn(obj.head(a, s))
+obj.fn(obj.head(b))
+obj.fn(obj?.a)
+obj.fn(obj?.b)
+obj.fn(obj?.fn(0))
+obj.fn(obj?.fn(a))
+obj.fn(obj?.fn(b))
+obj.fn(obj?.head(0))
+obj.fn(obj?.head(0, div))
+obj.fn(obj?.head(1))
+obj.fn(obj?.head(a, arr))
+obj.fn(obj?.head(b))
+obj.fn(ok && 2)
+obj.fn(ok && a)
+obj.fn(ok && b)
+obj.fn(ok ? 1 : 0)
+obj.fn(ok ? a : s)
+obj.fn(ok ? b : "b" .. all(obj, ok))
+obj.fn(ok and 0)
+obj.fn(ok and a)
+obj.fn(ok and b)
+obj.fn(s, obj, nil) || true ? 0 : b
+obj.fn(true && 0)
+obj.fn(true && 2)
+obj.fn(true ? 0 : add)
+obj.fn(true and a)
+obj.head(!false)
+obj.head(!false, s, div)
+obj.head(!ok)
+obj.head(!true)
+obj.head(!true, div)
+obj.head(!true, ok ? true : add)
+obj.head("a" != "c")
+obj.head("a" != a)
+obj.head("a" != add)
+obj.head("a" != b)
+obj.head("a" != div)
+obj.head("a" != s)
+obj.head("a" < s)
+obj.head("a" == "c")
+obj.head("a" == 0)
+obj.head("a" == arr)
+obj.head("a" == b)
+obj.head("a" == f)
+obj.head("a" >= "c")
+obj.head("a" contains "a")
+obj.head("a" in arr, obj)
+obj.head("a" in nil)
+obj.head("a" or true)
+obj.head("a" || true)
+obj.head("a") == add
+obj.head("a", a) == b - 0.5
+obj.head("b" != "c", last(arr, ok, f), arr)
+obj.head("b" != 1)
+obj.head("b" != a)
+obj.head("b" != add)
+obj.head("b" != arr)
+obj.head("b" != b)
+obj.head("b" != s)
+obj.head("b" + "b")
+obj.head("b" <= "b")
+obj.head("b" == f)
+obj.head("b" == obj)
+obj.head("b" || false)
+obj.head("b") + s
+obj.head("b") startsWith s
+obj.head("b", ok) != add
+obj.head("c" != a)
+obj.head("c" != ok)
+obj.head("c" + "a")
+obj.head("c" + s)
+obj.head("c" == "c")
+obj.head("c" == add, ok)
+obj.head("c" == arr)
+obj.head("c" == div)
+obj.head("c" == false)
+obj.head("c" >= "b")
+obj.head("c" >= s, get(0, ok))
+obj.head("c" and false)
+obj.head("c" and true)
+obj.head("c" contains "b")
+obj.head("c" endsWith "c")
+obj.head("c" startsWith "c")
+obj.head("c" || false)
+obj.head("c") endsWith s
+obj.head("c", "c") > s
+obj.head((nil || true) == arr)
+obj.head(-0)
+obj.head(-0.5)
+obj.head(-0.5, add)
+obj.head(-2)
+obj.head(-a)
+obj.head(-b)
+obj.head(-f)
+obj.head(-f, obj?.head(obj, ok, arr))
+obj.head(0 != arr)
+obj.head(0 != b)
+obj.head(0 != div)
+obj.head(0 != nil)
+obj.head(0 != nil, b)
+obj.head(0 != ok)
+obj.head(0 && true)
+obj.head(0 * 0.5)
+obj.head(0 * a)
+obj.head(0 ** 0)
+obj.head(0 ** 1)
+obj.head(0 ** b)
+obj.head(0 ** f)
+obj.head(0 + 2)
+obj.head(0 + a)
+obj.head(0 + f)
+obj.head(0 - 0.5)
+obj.head(0 - 1)
+obj.head(0 - a)
+obj.head(0 - f)
+obj.head(0 .. 0)
+obj.head(0 .. 0.5)
+obj.head(0 .. b)
+obj.head(0 / b)
+obj.head(0 < 0)
+obj.head(0 < b, obj?.head(obj, obj, add, "a"))
+obj.head(0 <= 0.5)
+obj.head(0 <= 0.5, obj.a)
+obj.head(0 <= 1)
+obj.head(0 == "a")
+obj.head(0 == 0)
+obj.head(0 == 1)
+obj.head(0 == add, f)
+obj.head(0 == arr)
+obj.head(0 == div)
+obj.head(0 == f)
+obj.head(0 == false)
+obj.head(0 == ok)
+obj.head(0 == s, float(b))
+obj.head(0 == true)
+obj.head(0 > 0)
+obj.head(0 > b)
+obj.head(0 >= 0)
+obj.head(0 >= a, s)
+obj.head(0 ^ 0.5)
+obj.head(0 ^ 1)
+obj.head(0 ^ a)
+obj.head(0 ^ f)
+obj.head(0 in nil)
+obj.head(0 || true)
+obj.head(0) != s
+obj.head(0) - b
+obj.head(0) .. obj?.head(1)
+obj.head(0) / a
+obj.head(0) / b
+obj.head(0) < b ^ b
+obj.head(0) == b
+obj.head(0) > a - b
+obj.head(0) >= 0.5 ? 2 : obj
+obj.head(0) >= a
+obj.head(0) ^ (b % 1)
+obj.head(0) ^ b
+obj.head(0, "a") - f
+obj.head(0, "b") + f
+obj.head(0, "b") .. add(b, b)
+obj.head(0, 0) == "c" ? nil : a
+obj.head(0, 0, "c") == obj?.a
+obj.head(0, 0.5, "b", 0) <= 0.5 != true
+obj.head(0, 1, div) < a
+obj.head(0, add) / a
+obj.head(0, arr) > b
+obj.head(0, arr, add, nil) < a
+obj.head(0, b, s) .. a
+obj.head(0, div) + f
+obj.head(0, div, a) < obj?.a
+obj.head(0, f) <= b
+obj.head(0, f, arr) == ok
+obj.head(0, f, b) == s
+obj.head(0, f, obj, 0, "a") + a
+obj.head(0, ok) - a
+obj.head(0, ok) > -b
+obj.head(0, true, b) - a
+obj.head(0.5 != 1)
+obj.head(0.5 != a)
+obj.head(0.5 != add)
+obj.head(0.5 != arr)
+obj.head(0.5 != b)
+obj.head(0.5 != f)
+obj.head(0.5 != obj)
+obj.head(0.5 * 0)
+obj.head(0.5 * a, arr)
+obj.head(0.5 ** a)
+obj.head(0.5 + a)
+obj.head(0.5 + f)
+obj.head(0.5 - 1)
+obj.head(0.5 - a)
+obj.head(0.5 - f)
+obj.head(0.5 .. 0)
+obj.head(0.5 .. a, max(div))
+obj.head(0.5 / 0)
+obj.head(0.5 < 0.5)
+obj.head(0.5 <= 0)
+obj.head(0.5 <= b)
+obj.head(0.5 == a)
+obj.head(0.5 == add, div)
+obj.head(0.5 == obj)
+obj.head(0.5 >= a)
+obj.head(0.5 >= f)
+obj.head(0.5 ^ 1)
+obj.head(0.5 and true)
+obj.head(0.5 in nil)
+obj.head(0.5) - b / f
+obj.head(0.5) / obj.head(2, obj)
+obj.head(0.5, f) != a
+obj.head(0.5, false, b) + obj.a
+obj.head(0.5, nil) >= f
+obj.head(0.5, nil, s) > a
+obj.head(1 != add, obj.a)
+obj.head(1 != arr)
+obj.head(1 != nil)
+obj.head(1 != obj)
+obj.head(1 != s)
+obj.head(1 && true)
+obj.head(1 * 0)
+obj.head(1 ** 2)
+obj.head(1 - a)
+obj.head(1 .. b)
+obj.head(1 / 0.5)
+obj.head(1 / 1)
+obj.head(1 / a)
+obj.head(1 / f)
+obj.head(1 < 1)
+obj.head(1 < a)
+obj.head(1 == 0, get(div, b))
+obj.head(1 == b)
+obj.head(1 == div)
+obj.head(1 == div, get(div, false))
+obj.head(1 == s, 0 ** 0, ok)
+obj.head(1 >= 0)
+obj.head(1 >= a, ok)
+obj.head(1 >= f)
+obj.head(1 and false)
+obj.head(1) + a
+obj.head(1) + a + a
+obj.head(1) == f
+obj.head(1) ^ obj.b
+obj.head(1, a, ok) <= a
+obj.head(1, add, ok) > a
+obj.head(1, div) == b ? a : a
+obj.head(2 != "a")
+obj.head(2 != b)
+obj.head(2 != true)
+obj.head(2 % b)
+obj.head(2 * b)
+obj.head(2 ** b)
+obj.head(2 + 2)
+obj.head(2 + b)
+obj.head(2 - 1)
+obj.head(2 - f, obj, get(obj, a))
+obj.head(2 .. a)
+obj.head(2 / 0)
+obj.head(2 / a, add)
+obj.head(2 / f)
+obj.head(2 == ok)
+obj.head(2 >= 0.5)
+obj.head(2 >= b)
+obj.head(2 >= f)
+obj.head(2 ^ b, 0.5 && false)
+obj.head(2 ^ f)
+obj.head(2 in arr)
+obj.head(2 in nil, a)
+obj.head(2) != s
+obj.head(2) + f
+obj.head(2) == obj.a
+obj.head(2, 0.5) % obj?.b
+obj.head(2, 0.5) - obj.a
+obj.head(2, arr, 2, obj, div) > f
+obj.head(2, div, ok) in 2 .. 2
+obj.head(["c"])
+obj.head([arr, add])
+obj.head(a != 0)
+obj.head(a != a)
+obj.head(a != arr)
+obj.head(a != b)
+obj.head(a != f)
+obj.head(a != nil)
+obj.head(a != obj)
+obj.head(a != ok)
+obj.head(a != ok, obj.b)
+obj.head(a % 2)
+obj.head(a % b)
+obj.head(a * 0)
+obj.head(a * 0.5)
+obj.head(a * 1)
+obj.head(a * a)
+obj.head(a * b)
+obj.head(a * b, get(0.5, nil))
+obj.head(a * f)
+obj.head(a ** a)
+obj.head(a ** f)
+obj.head(a + 0)
+obj.head(a + 0.5, none(obj, true), a)
+obj.head(a - 0)
+obj.head(a - 0.5)
+obj.head(a - 1)
+obj.head(a - 2)
+obj.head(a - a)
+obj.head(a - b)
+obj.head(a - b, 0 && false, f)
+obj.head(a - f)
+obj.head(a .. f)
+obj.head(a / 0)
+obj.head(a / 1)
+obj.head(a < 0)
+obj.head(a < 1)
+obj.head(a < a)
+obj.head(a < b)
+obj.head(a <= a)
+obj.head(a <= b, false in arr)
+obj.head(a <= b, ok ? a : div)
+obj.head(a <= f)
+obj.head(a == "b")
+obj.head(a == 0)
+obj.head(a == 0, f == nil)
+obj.head(a == add)
+obj.head(a == b)
+obj.head(a == f)
+obj.head(a == f, ok ? obj : arr)
+obj.head(a == obj)
+obj.head(a > 1)
+obj.head(a >= a)
+obj.head(a >= f)
+obj.head(a ^ 0)
+obj.head(a ^ a)
+obj.head(a ^ a, add)
+obj.head(a ^ f)
+obj.head(a and true)
+obj.head(a in arr)
+obj.head(a or true)
+obj.head(a)
+obj.head(a) != div
+obj.head(a) * a
+obj.head(a) * b
+obj.head(a) ** f
+obj.head(a) + b
+obj.head(a) + f
+obj.head(a) < add(b, a)
+obj.head(a) < b ** 0
+obj.head(a) <= 0.5 - 0.5
+obj.head(a) >= 0.5 ^ f
+obj.head(a) >= int(a)
+obj.head(a) ^ a
+obj.head(a, "a", false, 0) % b
+obj.head(a, "b", "b") == obj ? "b" : arr
+obj.head(a, 1 != arr)
+obj.head(a, a)
+obj.head(a, add)
+obj.head(a, add) != div ? 0 : 0.5
+obj.head(a, arr)
+obj.head(a, arr) < obj.a
+obj.head(a, b)
+obj.head(a, b, f)
+obj.head(a, div)
+obj.head(a, f)
+obj.head(a, f) == f
+obj.head(a, f, div, "b") ^ b
+obj.head(a, f, f) * b ** a
+obj.head(a, f, obj.a)
+obj.head(a, false) ^ 0.5 ** a
+obj.head(a, nil) == f
+obj.head(a, nil) == obj
+obj.head(a, obj, ok, nil, ok) <= b
+obj.head(a, obj.a)
+obj.head(a, obj.b)
+obj.head(a, obj.obj)
+obj.head(a, obj?.head(s))
+obj.head(a, ok)
+obj.head(a, s)
+obj.head(a, s) - a
+obj.head(a, string(0.5, 1), f)
+obj.head(a, true || arr)
+obj.head(abs(0))
+obj.head(abs(1), ok && add)
+obj.head(abs(2))
+obj.head(abs(b))
+obj.head(abs(b, add, true, b))
+obj.head(abs(div, "b", b))
+obj.head(abs(div, arr, f))
+obj.head(abs(f))
+obj.head(abs(f, "b", a))
+obj.head(abs(obj, b), add != obj)
+obj.head(abs(obj, div, 1), a, get(0, f))
+obj.head(add != "a")
+obj.head(add != "c", ok)
+obj.head(add != 0)
+obj.head(add != 2)
+obj.head(add != add)
+obj.head(add != arr)
+obj.head(add != b)
+obj.head(add != f)
+obj.head(add != false, a)
+obj.head(add != nil, s)
+obj.head(add != obj)
+obj.head(add != ok)
+obj.head(add != true)
+obj.head(add && false, map(obj, obj))
+obj.head(add && true)
+obj.head(add == 0.5)
+obj.head(add == add)
+obj.head(add == arr)
+obj.head(add == f)
+obj.head(add == ok)
+obj.head(add == s)
+obj.head(add == true)
+obj.head(add in arr)
+obj.head(add in nil)
+obj.head(add or true)
+obj.head(add(0, 0))
+obj.head(add(0, 1), obj, s)
+obj.head(add(0, a))
+obj.head(add(1, a), int(0))
+obj.head(add(2, 0))
+obj.head(add(2, b))
+obj.head(add(a, 0))
+obj.head(add(a, 0), div)
+obj.head(add(a, a))
+obj.head(add(a, a), get(s, a))
+obj.head(add(b, 0))
+obj.head(add(b, a))
+obj.head(add(b, b))
+obj.head(add)
+obj.head(add) != div
+obj.head(add) != f
+obj.head(add) == f ** 1
+obj.head(add, a)
+obj.head(add, a, b, arr) == add
+obj.head(add, add)
+obj.head(add, b)
+obj.head(add, b, s) == ok
+obj.head(add, div)
+obj.head(add, f)
+obj.head(add, filter(arr, true))
+obj.head(add, obj)
+obj.head(add, s <= "b")
+obj.head(add, s)
+obj.head(add, s, arr) != add(a, 0)
+obj.head(add, string(b))
+obj.head(all("b", ok))
+obj.head(all("b", true))
+obj.head(all("c", false))
+obj.head(all("c", ok))
+obj.head(all(arr, false) == map(s, nil))
+obj.head(all(arr, ok))
+obj.head(all(arr, true))
+obj.head(all(arr, true), a)
+obj.head(all(obj, false))
+obj.head(all(obj, true))
+obj.head(all(s, ok))
+obj.head(any("a", false))
+obj.head(any("b", false))
+obj.head(any(arr, ok))
+obj.head(any(arr, true))
+obj.head(any(obj, false))
+obj.head(any(obj, true))
+obj.head(arr != 2)
+obj.head(arr != a)
+obj.head(arr != add)
+obj.head(arr != arr)
+obj.head(arr != b)
+obj.head(arr != div)
+obj.head(arr != f)
+obj.head(arr != false)
+obj.head(arr != s)
+obj.head(arr && false)
+obj.head(arr && true)
+obj.head(arr == "a")
+obj.head(arr == a)
+obj.head(arr == arr)
+obj.head(arr == b)
+obj.head(arr == f)
+obj.head(arr == nil)
+obj.head(arr == nil, all("b", ok), b)
+obj.head(arr == obj)
+obj.head(arr == s)
+obj.head(arr in nil)
+obj.head(arr || true)
+obj.head(arr)
+obj.head(arr) != a
+obj.head(arr) != a ** b
+obj.head(arr) != add
+obj.head(arr) != obj
+obj.head(arr) != obj.head(ok)
+obj.head(arr) in arr
+obj.head(arr)[obj?.a]
+obj.head(arr, 0) != obj?.head(obj)
+obj.head(arr, a) == 0.5 * f
+obj.head(arr, add)
+obj.head(arr, add)[obj.b]
+obj.head(arr, arr)
+obj.head(arr, b)
+obj.head(arr, b, arr)
+obj.head(arr, div)
+obj.head(arr, div, 0, "b", arr) != f
+obj.head(arr, div, arr)
+obj.head(arr, div, false, a, div) != arr
+obj.head(arr, f or true)
+obj.head(arr, f)
+obj.head(arr, f, arr, 0) != ok
+obj.head(arr, map(obj, false))
+obj.head(arr, obj)
+obj.head(arr, obj, add) == ok
+obj.head(arr, obj?.a)
+obj.head(arr, ok)
+obj.head(arr, ok, false) == add
+obj.head(arr[0:f])
+obj.head(arr[0], get(ok, f), arr)
+obj.head(arr[1])
+obj.head(arr[1], ok)
+obj.head(arr[a])
+obj.head(arr[b:f])
+obj.head(arr[b])
+obj.head(arr[b], s)
+obj.head(arr[f])
+obj.head(b != 0, ok, a)
+obj.head(b != a)
+obj.head(b != arr)
+obj.head(b != arr, s)
+obj.head(b != f)
+obj.head(b != false)
+obj.head(b != obj)
+obj.head(b != ok)
+obj.head(b != true)
+obj.head(b % 1, obj.b)
+obj.head(b % b, get(arr, arr))
+obj.head(b * 0.5)
+obj.head(b * 1)
+obj.head(b * a)
+obj.head(b * b, b)
+obj.head(b * f)
+obj.head(b ** 0)
+obj.head(b ** 0.5, add)
+obj.head(b ** b)
+obj.head(b ** f, div)
+obj.head(b + a)
+obj.head(b + b)
+obj.head(b + f)
+obj.head(b - 0)
+obj.head(b - 0, b ** b)
+obj.head(b - 0.5)
+obj.head(b - 1)
+obj.head(b - 2, obj.head(obj))
+obj.head(b - a)
+obj.head(b - f)
+obj.head(b .. a)
+obj.head(b .. a, 2 <= a)
+obj.head(b .. b)
+obj.head(b .. f, get(obj, a), map(arr, true))
+obj.head(b / 0)
+obj.head(b / b)
+obj.head(b / b, a)
+obj.head(b < a)
+obj.head(b < b)
+obj.head(b < f)
+obj.head(b <= a)
+obj.head(b <= f)
+obj.head(b == "a")
+obj.head(b == "b")
+obj.head(b == 0)
+obj.head(b == a)
+obj.head(b == add)
+obj.head(b == arr)
+obj.head(b == b)
+obj.head(b == div)
+obj.head(b == nil)
+obj.head(b == obj)
+obj.head(b == ok)
+obj.head(b == ok, div)
+obj.head(b == s)
+obj.head(b > 0)
+obj.head(b > 0.5)
+obj.head(b > 1)
+obj.head(b > a)
+obj.head(b >= a, arr)
+obj.head(b >= b, obj.a)
+obj.head(b >= f)
+obj.head(b ^ 0.5)
+obj.head(b ^ 1, not ok)
+obj.head(b ^ a)
+obj.head(b in arr)
+obj.head(b in nil)
+obj.head(b or false)
+obj.head(b || false)
+obj.head(b || true)
+obj.head(b)
+obj.head(b) != a
+obj.head(b) % a
+obj.head(b) % b
+obj.head(b) * b
+obj.head(b) ** div(1, 1)
+obj.head(b) ** obj?.a
+obj.head(b) - -0
+obj.head(b) - a
+obj.head(b) - b
+obj.head(b) .. div(a, a)
+obj.head(b) / (b + a)
+obj.head(b) / b
+obj.head(b) < -f
+obj.head(b) <= a + a
+obj.head(b) <= obj.b
+obj.head(b) == add
+obj.head(b) == map(arr, add)
+obj.head(b) == obj
+obj.head(b) > obj.b
+obj.head(b) >= a
+obj.head(b) ^ obj.a
+obj.head(b) in arr
+obj.head(b, 0 / 2, max(div))
+obj.head(b, 0.5, add, nil) == f
+obj.head(b, 2) != first(arr)
+obj.head(b, a + a)
+obj.head(b, a - a)
+obj.head(b, a)
+obj.head(b, a) ^ b
+obj.head(b, a, obj) <= b ? ok : "c"
+obj.head(b, a, obj) ^ f
+obj.head(b, a, s) >= obj?.a
+obj.head(b, add) - f
+obj.head(b, add, false, false, false) == s ? 1 : div
+obj.head(b, add, s, arr) < 0.5 + b
+obj.head(b, add, true) == f
+obj.head(b, arr)
+obj.head(b, arr) != add
+obj.head(b, arr) ** b
+obj.head(b, arr) >= b
+obj.head(b, b + f)
+obj.head(b, b)
+obj.head(b, b) != obj.obj
+obj.head(b, b, ok) / b
+obj.head(b, div)
+obj.head(b, f != "b")
+obj.head(b, f) != add
+obj.head(b, f, b, obj, a) ^ f ** f
+obj.head(b, f, false) + a
+obj.head(b, f, s, div, b) > b
+obj.head(b, false, b) - obj?.a
+obj.head(b, first(0.5))
+obj.head(b, get(b, arr))
+obj.head(b, get(div, true), "a" != 0)
+obj.head(b, get(s, 0))
+obj.head(b, get(true, obj))
+obj.head(b, last(nil))
+obj.head(b, nil != div)
+obj.head(b, nil or false)
+obj.head(b, obj)
+obj.head(b, obj) % b
+obj.head(b, obj.a)
+obj.head(b, obj.head(add))
+obj.head(b, ok or ok?.a)
+obj.head(b, ok)
+obj.head(b, s)
+obj.head(b, true) == div
+obj.head(count("a", true))
+obj.head(count("c", ok))
+obj.head(count(arr, false))
+obj.head(count(arr, ok))
+obj.head(count(arr, ok), 0 == arr)
+obj.head(count(arr, true))
+obj.head(count(obj, false))
+obj.head(count(obj, ok))
+obj.head(count(s, false))
+obj.head(count(s, ok))
+obj.head(count(s, ok), obj.b)
+obj.head(count(s, true))
+obj.head(date(s, s))
+obj.head(div != "a")
+obj.head(div != 1)
+obj.head(div != a)
+obj.head(div != add)
+obj.head(div != arr)
+obj.head(div != b, f)
+obj.head(div != f)
+obj.head(div != false)
+obj.head(div != obj, arr)
+obj.head(div != s)
+obj.head(div && true)
+obj.head(div == "b", div, b == nil)
+obj.head(div == 0)
+obj.head(div == 0.5)
+obj.head(div == 1)
+obj.head(div == 2)
+obj.head(div == a)
+obj.head(div == a, add)
+obj.head(div == div)
+obj.head(div == f)
+obj.head(div == f, add)
+obj.head(div == nil)
+obj.head(div == obj, b)
+obj.head(div == obj, toBase64(s))
+obj.head(div and true)
+obj.head(div in arr)
+obj.head(div in nil)
+obj.head(div || true)
+obj.head(div(0, a))
+obj.head(div(0, b), ok ? b : "a")
+obj.head(div(1, a))
+obj.head(div(1, a), obj, "b" in arr)
+obj.head(div(a, 2))
+obj.head(div(a, a))
+obj.head(div(a, b))
+obj.head(div(a, b), s)
+obj.head(div(b, 2))
+obj.head(div(b, a))
+obj.head(div(b, b))
+obj.head(div)
+obj.head(div) != ok
+obj.head(div) == a
+obj.head(div) == b
+obj.head(div) == div
+obj.head(div) == obj
+obj.head(div, 0 > f)
+obj.head(div, 0.5) != -0.5
+obj.head(div, a == f)
+obj.head(div, a)
+obj.head(div, add)
+obj.head(div, b ** a)
+obj.head(div, b + a, b, a)
+obj.head(div, b) == a
+obj.head(div, b, div)
+obj.head(div, b, obj, add) == b
+obj.head(div, div != obj)
+obj.head(div, div(0, 2))
+obj.head(div, div)
+obj.head(div, f != false)
+obj.head(div, f >= f)
+obj.head(div, f)
+obj.head(div, false, "c", s) != obj.head(add, "c")
+obj.head(div, get(a, 0))
+obj.head(div, get(false, f))
+obj.head(div, get(false, obj))
+obj.head(div, max(b))
+obj.head(div, not ok)
+obj.head(div, obj)
+obj.head(div, obj.a)
+obj.head(div, ok != arr)
+obj.head(div, ok and div)
+obj.head(div, ok)
+obj.head(div, s != div)
+obj.head(div, s < s, a)
+obj.head(div, s)
+obj.head(div, s[2])
+obj.head(f != "c")
+obj.head(f != "c", 0 * 0.5)
+obj.head(f != a)
+obj.head(f != a, ok, obj)
+obj.head(f != add)
+obj.head(f != b)
+obj.head(f != nil)
+obj.head(f != ok)
+obj.head(f != s)
+obj.head(f != s, upper(0.5, s))
+obj.head(f != true)
+obj.head(f * 0)
+obj.head(f * 0.5)
+obj.head(f * 2)
+obj.head(f * b)
+obj.head(f * f)
+obj.head(f ** 0)
+obj.head(f ** 2)
+obj.head(f ** b)
+obj.head(f ** obj.a)
+obj.head(f + 0)
+obj.head(f + a)
+obj.head(f + b)
+obj.head(f - 0)
+obj.head(f - 0.5)
+obj.head(f - 2)
+obj.head(f - a)
+obj.head(f - b, f ** f)
+obj.head(f - f)
+obj.head(f .. a)
+obj.head(f .. b, add == nil)
+obj.head(f .. f)
+obj.head(f .. f) != arr
+obj.head(f / 0.5)
+obj.head(f / 1)
+obj.head(f / a)
+obj.head(f / f)
+obj.head(f < b)
+obj.head(f <= 1, obj)
+obj.head(f <= b)
+obj.head(f == "b", now(ok, 2))
+obj.head(f == "c", one(arr, true))
+obj.head(f == 0)
+obj.head(f == add)
+obj.head(f == b)
+obj.head(f == f)
+obj.head(f == obj, div)
+obj.head(f == s)
+obj.head(f == s, ok)
+obj.head(f > 0)
+obj.head(f > 1)
+obj.head(f > f)
+obj.head(f > f, any(s, ok), f ^ 0)
+obj.head(f >= 0)
+obj.head(f >= 0.5)
+obj.head(f >= f)
+obj.head(f >= f, int(s, nil, f))
+obj.head(f ^ 2, a)
+obj.head(f ^ b)
+obj.head(f ^ f)
+obj.head(f ^ f, s < s)
+obj.head(f in arr)
+obj.head(f in arr, f == 0)
+obj.head(f in nil)
+obj.head(f or false)
+obj.head(f)
+obj.head(f) != abs(0.5)
+obj.head(f) != div
+obj.head(f) != ok
+obj.head(f) * b
+obj.head(f) .. int(0.5)
+obj.head(f) / a
+obj.head(f) < b
+obj.head(f) < f / 0
+obj.head(f) == f
+obj.head(f) == obj.a
+obj.head(f) == ok
+obj.head(f) == s
+obj.head(f) >= b
+obj.head(f) ^ f
+obj.head(f, 0 / f, a - a)
+obj.head(f, 0, 0.5) * a
+obj.head(f, 0, arr, a) >= f
+obj.head(f, a)
+obj.head(f, arr != div)
+obj.head(f, arr)
+obj.head(f, arr) == obj
+obj.head(f, b + f)
+obj.head(f, b and true, s)
+obj.head(f, b)
+obj.head(f, b, s) * f / 1
+obj.head(f, div != arr)
+obj.head(f, div) != ok
+obj.head(f, div, get(f, obj))
+obj.head(f, div, true, div) ** obj.a
+obj.head(f, f)
+obj.head(f, f) != obj.a
+obj.head(f, false ? true : 0)
+obj.head(f, float(b))
+obj.head(f, get(false, false))
+obj.head(f, last(obj))
+obj.head(f, nil != ok)
+obj.head(f, obj)
+obj.head(f, obj) != add
+obj.head(f, ok && f)
+obj.head(f, ok)
+obj.head(f, ok, f ** f)
+obj.head(f, s) && false ? add : ok
+obj.head(f, s) >= a / b
+obj.head(f, s, obj)
+obj.head(f, s[b])
+obj.head(false != 0)
+obj.head(false != add)
+obj.head(false != arr)
+obj.head(false != b)
+obj.head(false != div)
+obj.head(false != f)
+obj.head(false != obj)
+obj.head(false != s)
+obj.head(false && add)
+obj.head(false && b)
+obj.head(false && f)
+obj.head(false && obj)
+obj.head(false && s, obj?.head("a", nil, b))
+obj.head(false && s, s[2])
+obj.head(false == 0.5)
+obj.head(false == a)
+obj.head(false == add)
+obj.head(false == f, true != 2)
+obj.head(false == nil)
+obj.head(false == obj)
+obj.head(false ? add : add)
+obj.head(false ? arr : ok)
+obj.head(false ? obj : 0)
+obj.head(false ? obj : s)
+obj.head(false and "c")
+obj.head(false and add)
+obj.head(false and b)
+obj.head(false and div)
+obj.head(false and false)
+obj.head(false and obj)
+obj.head(false and s)
+obj.head(false in nil)
+obj.head(false or "b")
+obj.head(false or b)
+obj.head(false or f, get("a", arr))
+obj.head(false or ok)
+obj.head(false or s)
+obj.head(false or s, ok ? 0 : 0.5)
+obj.head(false || 0)
+obj.head(false || 1)
+obj.head(false || add)
+obj.head(false || arr)
+obj.head(false || b)
+obj.head(false || obj, get(arr, div))
+obj.head(false || s)
+obj.head(false || true)
+obj.head(false) && 2 == nil
+obj.head(false) && arr == nil
+obj.head(false) == a
+obj.head(false, "b") || "b" startsWith "a"
+obj.head(false, 0, nil, "c") == obj
+obj.head(false, a) != arr
+obj.head(false, arr, obj, 2, div) == arr
+obj.head(false, f) != div
+obj.head(false, obj) != a == ok
+obj.head(false, ok) == obj.b
+obj.head(filter("b", ok))
+obj.head(filter("c", ok), obj, get("c", add))
+obj.head(filter(arr, true))
+obj.head(filter(obj, false))
+obj.head(filter(s, ok))
+obj.head(first("a", 0.5, s))
+obj.head(first("b", add, nil, div))
+obj.head(first(0))
+obj.head(first(0.5))
+obj.head(first(0.5), obj?.a) == obj
+obj.head(first(0.5, ok))
+obj.head(first(2))
+obj.head(first(a))
+obj.head(first(a, 1, f))
+obj.head(first(add))
+obj.head(first(arr))
+obj.head(first(b, arr))
+obj.head(first(false, obj))
+obj.head(first(nil, "b", obj))
+obj.head(first(obj))
+obj.head(first(ok, b))
+obj.head(first(ok, ok))
+obj.head(first(s))
+obj.head(float("a", a))
+obj.head(float(0))
+obj.head(float(1))
+obj.head(float(2))
+obj.head(float(a))
+obj.head(float(a), ok and f)
+obj.head(float(a, 0, a))
+obj.head(float(a, b), add)
+obj.head(float(add, 2))
+obj.head(float(arr, b))
+obj.head(float(b))
+obj.head(float(div, obj, add, 0), false && obj)
+obj.head(float(f))
+obj.head(float(f), f)
+obj.head(float(f, 0))
+obj.head(float(ok, b))
+obj.head(get("a"))
+obj.head(get("a"))?.a
+obj.head(get("a"), b)
+obj.head(get("a", arr))
+obj.head(get("a", b))
+obj.head(get("a", div))
+obj.head(get("a", f))
+obj.head(get("a", obj))
+obj.head(get("a", ok))
+obj.head(get("b"))
+obj.head(get("b", 0))
+obj.head(get("b", a))
+obj.head(get("b", add))
+obj.head(get("b", arr))
+obj.head(get("b", nil))
+obj.head(get("b", obj, a))
+obj.head(get("b", ok))
+obj.head(get("b", s))
+obj.head(get("c", a))
+obj.head(get("c", arr))
+obj.head(get("c", arr)) == a
+obj.head(get("c", b))
+obj.head(get(0))
+obj.head(get(0, 0))
+obj.head(get(0, add))
+obj.head(get(0, arr))
+obj.head(get(0, arr), obj)
+obj.head(get(0, arr)?.b)
+obj.head(get(0, b))
+obj.head(get(0, div))
+obj.head(get(0, f), b)
+obj.head(get(0, ok))
+obj.head(get(0, s))
+obj.head(get(0, true))
+obj.head(get(0.5))
+obj.head(get(0.5, 0))
+obj.head(get(0.5, arr))
+obj.head(get(0.5, false))
+obj.head(get(0.5, nil, arr, 1, 2))
+obj.head(get(0.5, obj))
+obj.head(get(0.5, obj), ok)
+obj.head(get(1), map(arr, obj))?.b
+obj.head(get(1, a))
+obj.head(get(1, div))
+obj.head(get(1, f))
+obj.head(get(1, false))
+obj.head(get(1, s))
+obj.head(get(2, f))
+obj.head(get(a, 0))
+obj.head(get(a, 0.5))
+obj.head(get(a, add))
+obj.head(get(a, b))
+obj.head(get(a, b), min(false))
+obj.head(get(a, div))
+obj.head(get(a, nil))
+obj.head(get(a, nil), arr)
+obj.head(get(a, obj))
+obj.head(get(a, obj), div == nil)
+obj.head(get(a, s))
+obj.head(get(add, 0.5))
+obj.head(get(add, 0.5), ok)
+obj.head(get(add, 1))
+obj.head(get(add, 2))
+obj.head(get(add, a))
+obj.head(get(add, arr))
+obj.head(get(add, b))
+obj.head(get(add, div))
+obj.head(get(add, f))
+obj.head(get(add, f, a, s))
+obj.head(get(add, nil))
+obj.head(get(add, obj))
+obj.head(get(add, ok))
+obj.head(get(add, s))
+obj.head(get(arr))
+obj.head(get(arr, 0.5))
+obj.head(get(arr, 2))
+obj.head(get(arr, a))
+obj.head(get(arr, add))
+obj.head(get(arr, arr))
+obj.head(get(arr, f))
+obj.head(get(arr, f)) * f
+obj.head(get(arr, f), add)
+obj.head(get(arr, f, obj, a))
+obj.head(get(arr, nil))
+obj.head(get(arr, obj))?.a
+obj.head(get(arr, ok))
+obj.head(get(arr, s))
+obj.head(get(b))
+obj.head(get(b, 0.5))
+obj.head(get(b, 2))
+obj.head(get(b, a))
+obj.head(get(b, add))
+obj.head(get(b, b))
+obj.head(get(b, b), div, toJSON(arr))
+obj.head(get(b, b), ok)
+obj.head(get(b, div))
+obj.head(get(b, f))
+obj.head(get(b, nil))
+obj.head(get(b, obj))
+obj.head(get(b, ok))
+obj.head(get(b, s))
+obj.head(get(b, s))?.obj
+obj.head(get(b, true))
+obj.head(get(b, true), ok)?.a
+obj.head(get(div))
+obj.head(get(div, 0.5))
+obj.head(get(div, a))
+obj.head(get(div, add))
+obj.head(get(div, b))
+obj.head(get(div, b))?.obj
+obj.head(get(div, div))
+obj.head(get(div, nil))
+obj.head(get(div, obj.b))
+obj.head(get(div, ok))
+obj.head(get(div, s)?.obj)
+obj.head(get(div, true))
+obj.head(get(f, 0))
+obj.head(get(f, 0.5))
+obj.head(get(f, a))
+obj.head(get(f, add))
+obj.head(get(f, arr))
+obj.head(get(f, b))
+obj.head(get(f, div))
+obj.head(get(f, div, arr))
+obj.head(get(f, nil))
+obj.head(get(f, nil), add)
+obj.head(get(f, nil, a), a)
+obj.head(get(f, obj))
+obj.head(get(f, true))
+obj.head(get(false ? s : arr, obj?.head(a, add)))
+obj.head(get(false, arr))
+obj.head(get(false, div))
+obj.head(get(false, false))
+obj.head(get(false, ok))
+obj.head(get(nil))
+obj.head(get(nil, 0))
+obj.head(get(nil, 0.5))
+obj.head(get(nil, 1))
+obj.head(get(nil, a), arr)
+obj.head(get(nil, add))
+obj.head(get(nil, add))?.b
+obj.head(get(nil, div))
+obj.head(get(nil, div)) != float(a ** 0)
+obj.head(get(nil, f))
+obj.head(get(nil, nil))
+obj.head(get(nil, obj))
+obj.head(get(nil, ok))
+obj.head(get(nil, s))
+obj.head(get(nil, s), a)
+obj.head(get(nil, true))
+obj.head(get(obj))
+obj.head(get(obj), ok)
+obj.head(get(obj, 0))
+obj.head(get(obj, 1))
+obj.head(get(obj, 1))?.b
+obj.head(get(obj, a))
+obj.head(get(obj, arr) != a)
+obj.head(get(obj, arr))
+obj.head(get(obj, arr))?.obj
+obj.head(get(obj, b))
+obj.head(get(obj, div))
+obj.head(get(obj, f))
+obj.head(get(obj, false))
+obj.head(get(obj, nil))
+obj.head(get(obj, obj))
+obj.head(get(obj, ok))
+obj.head(get(obj, s))
+obj.head(get(obj, true))
+obj.head(get(ok))
+obj.head(get(ok, 0))
+obj.head(get(ok, 0.5))
+obj.head(get(ok, 1))
+obj.head(get(ok, a))?.b
+obj.head(get(ok, add))
+obj.head(get(ok, add), obj)
+obj.head(get(ok, arr))
+obj.head(get(ok, div))
+obj.head(get(ok, f))
+obj.head(get(ok, false), map(arr, "a"), toJSON(0.5))
+obj.head(get(ok, nil))
+obj.head(get(ok, ok))
+obj.head(get(ok, ok), 0 + 0.5)
+obj.head(get(ok, s), a > 0.5)
+obj.head(get(ok, s), arr[0:b])
+obj.head(get(s))
+obj.head(get(s, "a", ok))
+obj.head(get(s, 0.5))
+obj.head(get(s, 1))
+obj.head(get(s, 1), b)
+obj.head(get(s, a))
+obj.head(get(s, a), obj.head(0.5, div))
+obj.head(get(s, add))
+obj.head(get(s, arr))
+obj.head(get(s, div))
+obj.head(get(s, div))?.b
+obj.head(get(s, f))
+obj.head(get(s, nil))
+obj.head(get(s, obj))
+obj.head(get(s, obj), get(a, f))
+obj.head(get(s, ok), true ? b : "a")
+obj.head(get(s, true))
+obj.head(get(true && nil))
+obj.head(get(true))
+obj.head(get(true, 0))
+obj.head(get(true, 0), arr)
+obj.head(get(true, a))
+obj.head(get(true, add))
+obj.head(get(true, add), arr)
+obj.head(get(true, arr))
+obj.head(get(true, f), ok || 1)
+obj.head(get(true, nil))
+obj.head(int("b", arr, f))
+obj.head(int("b", nil, a))
+obj.head(int(a))
+obj.head(int(a), string(true))
+obj.head(int(arr, a, f))
+obj.head(int(s, 0))
+obj.head(keys(obj))
+obj.head(last(0.5))
+obj.head(last(0.5), arr)
+obj.head(last(0.5), get(nil, ok))
+obj.head(last(a))
+obj.head(last(a, "a"))
+obj.head(last(a, obj))
+obj.head(last(add))
+obj.head(last(add), ok)
+obj.head(last(add, obj, add))
+obj.head(last(arr))
+obj.head(last(arr, s), f)
+obj.head(last(b))
+obj.head(last(b, b))
+obj.head(last(div))
+obj.head(last(f))
+obj.head(last(f, b, b))
+obj.head(last(false))
+obj.head(last(obj))
+obj.head(last(obj, 2, obj))
+obj.head(last(obj, a, s))
+obj.head(last(ok, arr, nil, ok))
+obj.head(last(s))
+obj.head(last(s, ok, a), nil == arr)
+obj.head(len(add, add, s, obj))
+obj.head(len(add, obj))
+obj.head(len(arr))
+obj.head(len(b, s))
+obj.head(len(obj))
+obj.head(len(obj, "a"))
+obj.head(len(s) <= f)
+obj.head(len(s))
+obj.head(len(s, arr, "b"), obj?.b)
+obj.head(lower(a, "b"))
+obj.head(lower(a, div, "b"))
+obj.head(lower(s))
+obj.head(map("a", 0.5))
+obj.head(map("a", a))
+obj.head(map("a", nil))
+obj.head(map("a", s))
+obj.head(map("b", 0))
+obj.head(map("b", div))
+obj.head(map("b", f))
+obj.head(map("b", nil))
+obj.head(map("b", s))
+obj.head(map("b", true))
+obj.head(map("c", "b"))
+obj.head(map("c", a))
+obj.head(map("c", a), get(arr, div))
+obj.head(map("c", arr))
+obj.head(map("c", arr), ok)
+obj.head(map("c", b))
+obj.head(map("c", f))
+obj.head(map("c", s))
+obj.head(map(arr, "c"))
+obj.head(map(arr, 0))
+obj.head(map(arr, 1))
+obj.head(map(arr, a))
+obj.head(map(arr, arr))
+obj.head(map(arr, b))
+obj.head(map(arr, b), div != obj)
+obj.head(map(arr, div))
+obj.head(map(arr, f))
+obj.head(map(arr, false))
+obj.head(map(arr, nil))
+obj.head(map(arr, obj), toJSON(b))
+obj.head(map(arr, ok) == b)
+obj.head(map(arr, ok))
+obj.head(map(arr, s))
+obj.head(map(obj, "a"))
+obj.head(map(obj, "b"))
+obj.head(map(obj, "c"))
+obj.head(map(obj, 0))
+obj.head(map(obj, 0.5))
+obj.head(map(obj, a))
+obj.head(map(obj, add))
+obj.head(map(obj, div))
+obj.head(map(obj, f))
+obj.head(map(obj, false))
+obj.head(map(obj, nil))
+obj.head(map(obj, obj))
+obj.head(map(obj, ok))
+obj.head(map(obj, s))
+obj.head(map(s, "a"))
+obj.head(map(s, 0))
+obj.head(map(s, 0.5))
+obj.head(map(s, a))
+obj.head(map(s, add))
+obj.head(map(s, arr))
+obj.head(map(s, div))
+obj.head(map(s, f))
+obj.head(map(s, false))
+obj.head(map(s, get(f, f)))
+obj.head(map(s, nil))
+obj.head(map(s, nil), obj.a)
+obj.head(map(s, obj))
+obj.head(map(s, ok))
+obj.head(map(s, ok), int(b))
+obj.head(map(s, s))
+obj.head(map(s, true))
+obj.head(max("a"))
+obj.head(max("c"))
+obj.head(max(0.5))
+obj.head(max(1))
+obj.head(max(a))
+obj.head(max(add))
+obj.head(max(b))
+obj.head(max(f))
+obj.head(max(f), a)
+obj.head(max(nil, 0), div)
+obj.head(max(obj))
+obj.head(max(ok))
+obj.head(max(s))
+obj.head(min(0))
+obj.head(min(0, 0))
+obj.head(min(0, a, f, f))
+obj.head(min(a))
+obj.head(min(a, f), obj)
+obj.head(min(add))
+obj.head(min(arr))
+obj.head(min(div))
+obj.head(min(f))
+obj.head(min(nil))
+obj.head(min(ok))
+obj.head(min(s))
+obj.head(min(true))
+obj.head(nil != 0)
+obj.head(nil != 0, a)
+obj.head(nil != a)
+obj.head(nil != add)
+obj.head(nil != add, f)
+obj.head(nil != f)
+obj.head(nil != false)
+obj.head(nil != obj)
+obj.head(nil != true)
+obj.head(nil != true, obj?.b)
+obj.head(nil && true)
+obj.head(nil == "a")
+obj.head(nil == 0)
+obj.head(nil == 0.5)
+obj.head(nil == a)
+obj.head(nil == add)
+obj.head(nil == b, arr)
+obj.head(nil == f)
+obj.head(nil == nil, div, a)
+obj.head(nil == obj)
+obj.head(nil == s)
+obj.head(nil and false)
+obj.head(nil and true)
+obj.head(nil in arr, a)
+obj.head(nil in obj)
+obj.head(nil || true, b % a)
+obj.head(nil) != div
+obj.head(nil) != s
+obj.head(nil) == f / f
+obj.head(nil) in obj?.obj
+obj.head(nil)?.a
+obj.head(nil)?.a?.a
+obj.head(nil)?.b
+obj.head(nil)?.b.obj
+obj.head(nil)?.fn(div)
+obj.head(nil)?.fn(map(arr, arr))
+obj.head(nil)?.head(arr)
+obj.head(nil)?.head(f ^ b)
+obj.head(nil)?.obj
+obj.head(nil)?.obj.a
+obj.head(nil, "a", 0)?.obj
+obj.head(nil, "b")?.a
+obj.head(nil, "b")?.obj
+obj.head(nil, "c")?.head(arr)
+obj.head(nil, 0)?.b
+obj.head(nil, 0, nil)?.obj
+obj.head(nil, 0, obj, s)?.a
+obj.head(nil, 0, s)?.b
+obj.head(nil, 1)?.obj
+obj.head(nil, 1, arr)?.obj
+obj.head(nil, a)?.a.head(s, a)
+obj.head(nil, a)?.b
+obj.head(nil, a, 0)?.head(false or a)
+obj.head(nil, a, a, arr)?.b
+obj.head(nil, a, add)?.a
+obj.head(nil, a, arr)?.b
+obj.head(nil, a, b, true, a)?.b
+obj.head(nil, a, f)?.b
+obj.head(nil, add)?.b
+obj.head(nil, add)?.b?.a
+obj.head(nil, add, 2, ok) == ok
+obj.head(nil, add, a)?.obj
+obj.head(nil, add, b)?.a
+obj.head(nil, add, b)?.fn(a)
+obj.head(nil, add, b)?.obj
+obj.head(nil, arr) == arr
+obj.head(nil, arr)?.b
+obj.head(nil, arr)?.b.obj
+obj.head(nil, arr)?.obj
+obj.head(nil, arr, 0.5, obj, ok)?.b
+obj.head(nil, arr, arr)?.a
+obj.head(nil, arr, div)?.a
+obj.head(nil, arr, f)?.a
+obj.head(nil, b)?.a
+obj.head(nil, b)?.b?.obj
+obj.head(nil, b)?.obj
+obj.head(nil, b, 0, s, f)?.b
+obj.head(nil, b, div) in arr
+obj.head(nil, b, s)?.obj
+obj.head(nil, div) == f
+obj.head(nil, div)?.a
+obj.head(nil, div)?.b
+obj.head(nil, div, 0, b)?.b
+obj.head(nil, div, a)?.b
+obj.head(nil, div, nil, 1)?.obj
+obj.head(nil, f)?.a
+obj.head(nil, f)?.b.obj
+obj.head(nil, f)?.obj
+obj.head(nil, f, b, a)?.a?.b
+obj.head(nil, f, div)?.a
+obj.head(nil, f, div, arr)?.b
+obj.head(nil, f, f)?.a
+obj.head(nil, f, obj)?.a
+obj.head(nil, false)?.a
+obj.head(nil, false)?.b
+obj.head(nil, nil)?.b
+obj.head(nil, nil)?.obj
+obj.head(nil, nil, add)?.a
+obj.head(nil, nil, arr, nil, s)?.obj
+obj.head(nil, obj)?.a
+obj.head(nil, obj)?.b
+obj.head(nil, obj)?.obj
+obj.head(nil, obj, 1)?.b
+obj.head(nil, obj, f, div, a)?.b
+obj.head(nil, ok)?.a
+obj.head(nil, ok)?.b
+obj.head(nil, ok)?.obj
+obj.head(nil, ok, 0.5)?.a
+obj.head(nil, ok, f)?.head(ok)
+obj.head(nil, ok, ok)?.obj
+obj.head(nil, s)?.b
+obj.head(nil, s)?.obj
+obj.head(nil, s, a)?.b
+obj.head(nil, true)?.a
+obj.head(nil, true)?.b
+obj.head(nil, true, 0)?.a
+obj.head(nil, true, s)?.a
+obj.head(none("c", false))
+obj.head(none(arr, false))
+obj.head(none(arr, ok))
+obj.head(none(obj, false))
+obj.head(none(obj, ok))
+obj.head(none(s, false))
+obj.head(none(s, ok))
+obj.head(none(s, true))
+obj.head(none(s, true), a)
+obj.head(not (obj == obj))
+obj.head(not false)
+obj.head(not ok)
+obj.head(not true)
+obj.head(now("b"))
+obj.head(now("c"))
+obj.head(now(1, s, 0), add)
+obj.head(now(a))
+obj.head(now(add))
+obj.head(now(arr))
+obj.head(now(b))
+obj.head(now(b, nil))
+obj.head(now(div))
+obj.head(now(f))
+obj.head(now(f, a, s))
+obj.head(now(false, a, 0.5, arr))
+obj.head(now(nil))
+obj.head(now(nil, obj))
+obj.head(now(obj))
+obj.head(now(obj, div, ok, obj))
+obj.head(now(obj, ok))
+obj.head(now(ok))
+obj.head(now(ok, "b"))
+obj.head(obj != "a")
+obj.head(obj != 0)
+obj.head(obj != a)
+obj.head(obj != add)
+obj.head(obj != arr)
+obj.head(obj != b)
+obj.head(obj != div)
+obj.head(obj != f, filter("c", ok))
+obj.head(obj != obj)
+obj.head(obj != obj, b, true and 2)
+obj.head(obj != obj, get(add, a))
+obj.head(obj != ok)
+obj.head(obj != s)
+obj.head(obj && true)
+obj.head(obj == 0)
+obj.head(obj == 1)
+obj.head(obj == add)
+obj.head(obj == b)
+obj.head(obj == div)
+obj.head(obj == false)
+obj.head(obj == nil)
+obj.head(obj in nil)
+obj.head(obj or true)
+obj.head(obj)
+obj.head(obj) != a ? nil : 2
+obj.head(obj) != add
+obj.head(obj) == obj.a
+obj.head(obj) == s
+obj.head(obj).a
+obj.head(obj).b
+obj.head(obj).b * a
+obj.head(obj).fn(add(b, b))
+obj.head(obj).head(add)
+obj.head(obj).obj
+obj.head(obj).obj != obj
+obj.head(obj).obj.b
+obj.head(obj)?.a
+obj.head(obj)?.b
+obj.head(obj)?.fn(a)
+obj.head(obj)?.head(-0.5)
+obj.head(obj)?.head(arr)
+obj.head(obj)?.head(get(0.5 / f))
+obj.head(obj)?.head(last(ok, "b" contains "a"))
+obj.head(obj)?.head(s)
+obj.head(obj)?.obj
+obj.head(obj)?.obj == add
+obj.head(obj)?.obj.obj
+obj.head(obj)?.obj?.a
+obj.head(obj)?.obj?.obj
+obj.head(obj, "a").a
+obj.head(obj, "a")?.obj
+obj.head(obj, "a", add, arr, div)?.b
+obj.head(obj, "b" in arr)
+obj.head(obj, "b").b
+obj.head(obj, "b").obj
+obj.head(obj, "b")?.a
+obj.head(obj, "b", "b", arr)?.a
+obj.head(obj, "b", a).a
+obj.head(obj, "b", b)?.a
+obj.head(obj, "b", div, div, a).obj
+obj.head(obj, "c").obj
+obj.head(obj, "c")?.obj
+obj.head(obj, "c", obj)?.a
+obj.head(obj, 0 ** f)
+obj.head(obj, 0) == add
+obj.head(obj, 0).b
+obj.head(obj, 0).obj
+obj.head(obj, 0)?.a
+obj.head(obj, 0)?.b
+obj.head(obj, 0)?.obj
+obj.head(obj, 0, "b")?.a
+obj.head(obj, 0, "b")?.b
+obj.head(obj, 0, 0.5)?.obj?.obj?.b
+obj.head(obj, 0, 1, nil).obj
+obj.head(obj, 0, b).b
+obj.head(obj, 0, f, true).b
+obj.head(obj, 0, false)?.b
+obj.head(obj, 0, ok)?.obj
+obj.head(obj, 0, s)?.a
+obj.head(obj, 0.5 ^ b)
+obj.head(obj, 0.5).a
+obj.head(obj, 0.5).b
+obj.head(obj, 0.5).obj
+obj.head(obj, 0.5)?.a
+obj.head(obj, 0.5, "c")?.a
+obj.head(obj, 0.5, div)?.obj
+obj.head(obj, 0.5, obj).b
+obj.head(obj, 1).b
+obj.head(obj, 1).obj
+obj.head(obj, 1)?.a
+obj.head(obj, 1, a).obj?.obj?.a
+obj.head(obj, 1, false).obj
+obj.head(obj, 2, "a")?.b
+obj.head(obj, 2, true) != s
+obj.head(obj, a)
+obj.head(obj, a).a
+obj.head(obj, a).b
+obj.head(obj, a)?.b
+obj.head(obj, a)?.obj
+obj.head(obj, a, 0).a
+obj.head(obj, a, 1)?.b
+obj.head(obj, a, 2, a).b
+obj.head(obj, a, a).b
+obj.head(obj, a, a, false).b
+obj.head(obj, a, add, add, s).a
+obj.head(obj, a, add, s)?.obj
+obj.head(obj, a, arr).b
+obj.head(obj, a, ok, b)?.obj
+obj.head(obj, a, s, 2).obj
+obj.head(obj, add)
+obj.head(obj, add).a
+obj.head(obj, add).b
+obj.head(obj, add).obj
+obj.head(obj, add)?.a
+obj.head(obj, add)?.b
+obj.head(obj, add)?.head(div)
+obj.head(obj, add)?.obj
+obj.head(obj, add, "c", false, div).b
+obj.head(obj, add, 0, add).b
+obj.head(obj, add, obj)?.b
+obj.head(obj, add, ok, ok).a
+obj.head(obj, arr)
+obj.head(obj, arr).a
+obj.head(obj, arr).b
+obj.head(obj, arr)?.a
+obj.head(obj, arr)?.b
+obj.head(obj, arr, add)?.a
+obj.head(obj, arr, arr).obj
+obj.head(obj, arr, b).b
+obj.head(obj, arr, b)?.obj
+obj.head(obj, arr, b, obj, div)?.b
+obj.head(obj, arr, obj, add)?.b
+obj.head(obj, arr, ok).b
+obj.head(obj, arr, ok).obj
+obj.head(obj, arr, ok)?.obj
+obj.head(obj, arr, ok, 0).a
+obj.head(obj, arr, ok, arr).b
+obj.head(obj, arr, s, b, add)?.obj
+obj.head(obj, b)
+obj.head(obj, b).a
+obj.head(obj, b).b
+obj.head(obj, b).obj
+obj.head(obj, b)?.b
+obj.head(obj, b)?.obj
+obj.head(obj, b)?.obj?.obj
+obj.head(obj, b, add).obj
+obj.head(obj, b, b)?.a
+obj.head(obj, b, b, a).obj
+obj.head(obj, b, nil)?.obj
+obj.head(obj, b, true)?.b
+obj.head(obj, div)
+obj.head(obj, div).a
+obj.head(obj, div).obj
+obj.head(obj, div)?.a
+obj.head(obj, div)?.b
+obj.head(obj, div)?.head(div)
+obj.head(obj, div)?.obj
+obj.head(obj, div, "a", a).obj
+obj.head(obj, div, "b")?.a
+obj.head(obj, div, "b")?.b
+obj.head(obj, div, 0).a
+obj.head(obj, div, 0, ok).b
+obj.head(obj, div, arr, add)?.b
+obj.head(obj, div, f, div, add)?.obj
+obj.head(obj, div, f, obj, ok)?.obj
+obj.head(obj, div, obj)
+obj.head(obj, div, obj, a)?.obj
+obj.head(obj, div, s)
+obj.head(obj, f <= 0.5)?.a
+obj.head(obj, f)
+obj.head(obj, f).a
+obj.head(obj, f).b
+obj.head(obj, f).obj
+obj.head(obj, f)?.a
+obj.head(obj, f)?.b
+obj.head(obj, f, 2)?.head(arr)
+obj.head(obj, f, arr, a, "a").b
+obj.head(obj, f, f, true, s)?.obj
+obj.head(obj, f, obj).b
+obj.head(obj, f, obj)?.a
+obj.head(obj, false).a
+obj.head(obj, false).b
+obj.head(obj, false).obj
+obj.head(obj, false)?.a
+obj.head(obj, false, f).obj
+obj.head(obj, false, ok, f).obj
+obj.head(obj, false, s, ok).a
+obj.head(obj, get(arr, b), b < b).b
+obj.head(obj, get(ok, arr))
+obj.head(obj, last(add))
+obj.head(obj, map(obj, nil))
+obj.head(obj, nil).a
+obj.head(obj, nil).b
+obj.head(obj, nil)?.a
+obj.head(obj, nil)?.b
+obj.head(obj, nil)?.obj
+obj.head(obj, nil, 1)?.obj
+obj.head(obj, nil, a).b
+obj.head(obj, nil, arr)?.a
+obj.head(obj, nil, div).obj
+obj.head(obj, nil, obj).a
+obj.head(obj, not ok)
+obj.head(obj, obj)
+obj.head(obj, obj).b
+obj.head(obj, obj).obj
+obj.head(obj, obj)?.a
+obj.head(obj, obj)?.obj
+obj.head(obj, obj, arr).obj
+obj.head(obj, obj, b).a
+obj.head(obj, obj, b, ok, div).obj
+obj.head(obj, obj, div)
+obj.head(obj, obj, div)?.b
+obj.head(obj, obj, false)?.a
+obj.head(obj, obj, s)?.a
+obj.head(obj, obj.obj)
+obj.head(obj, ok in nil)
+obj.head(obj, ok or 0, s == "a", add, max("c"))
+obj.head(obj, ok)
+obj.head(obj, ok) and false ? 1 : arr
+obj.head(obj, ok).a
+obj.head(obj, ok).b
+obj.head(obj, ok)?.a
+obj.head(obj, ok)?.b
+obj.head(obj, ok)?.obj
+obj.head(obj, ok, "b")?.a
+obj.head(obj, ok, a)?.head(f)
+obj.head(obj, ok, add).obj
+obj.head(obj, ok, b).b
+obj.head(obj, ok, f)?.b
+obj.head(obj, ok, nil)?.a
+obj.head(obj, ok, obj)?.b
+obj.head(obj, ok, s)?.a
+obj.head(obj, ok, true, s)?.obj
+obj.head(obj, s)
+obj.head(obj, s).a
+obj.head(obj, s).b
+obj.head(obj, s)?.a
+obj.head(obj, s)?.b
+obj.head(obj, s)?.obj
+obj.head(obj, s, 0, nil).a
+obj.head(obj, s, 2, b)?.obj
+obj.head(obj, s, a)?.b
+obj.head(obj, s, b)?.a
+obj.head(obj, s, div, s)?.obj
+obj.head(obj, true != 0.5, add, abs(b))
+obj.head(obj, true) == obj?.b
+obj.head(obj, true).b
+obj.head(obj, true)?.obj
+obj.head(obj, true)[s]
+obj.head(obj, true, "a").b
+obj.head(obj, true, "a", div, true)?.a
+obj.head(obj.a)
+obj.head(obj.a, f && false)
+obj.head(obj.a, map(obj, "a"), obj)
+obj.head(obj.b)
+obj.head(obj.b, 0 == obj)
+obj.head(obj.b, 0.5 != nil)
+obj.head(obj.b, arr)
+obj.head(obj.b, false ? 0 : add)
+obj.head(obj.b, true ? arr : 0)
+obj.head(obj.fn(0))
+obj.head(obj.fn(a))
+obj.head(obj.fn(b))
+obj.head(obj.head(0))
+obj.head(obj.head(0, b, b, obj))
+obj.head(obj.head(0.5), string(f, a))
+obj.head(obj.head(1, ok, b, 0, div))
+obj.head(obj.head(a))
+obj.head(obj.head(a), arr)
+obj.head(obj.head(a, b))
+obj.head(obj.head(add))
+obj.head(obj.head(add, a, false))
+obj.head(obj.head(arr))
+obj.head(obj.head(arr), f)
+obj.head(obj.head(arr), ok)
+obj.head(obj.head(arr, 0.5))
+obj.head(obj.head(b, add))
+obj.head(obj.head(b, obj, ok))
+obj.head(obj.head(div))
+obj.head(obj.head(false))
+obj.head(obj.head(false, false, "a", "c", 2))
+obj.head(obj.head(nil))
+obj.head(obj.head(nil, b))
+obj.head(obj.head(nil, nil))
+obj.head(obj.head(obj))
+obj.head(obj.head(obj, s, a, s, add)).obj
+obj.head(obj.head(ok))
+obj.head(obj.head(ok, b))
+obj.head(obj.head(ok, s, 0))
+obj.head(obj.head(s))
+obj.head(obj.head(true))
+obj.head(obj.obj)
+obj.head(obj.obj)?.a
+obj.head(obj.obj)?.b
+obj.head(obj.obj, div, b)
+obj.head(obj.obj, f)
+obj.head(obj?.a)
+obj.head(obj?.a, first(div))
+obj.head(obj?.a, get(div, add))
+obj.head(obj?.a, ok)
+obj.head(obj?.b)
+obj.head(obj?.b, a)
+obj.head(obj?.b, div)
+obj.head(obj?.b, f)
+obj.head(obj?.b, get(0, div))
+obj.head(obj?.b, s)
+obj.head(obj?.c)
+obj.head(obj?.fn(1))
+obj.head(obj?.fn(a))
+obj.head(obj?.fn(b))
+obj.head(obj?.head("a", 1))
+obj.head(obj?.head("a", ok, 0.5, a))
+obj.head(obj?.head("b"))
+obj.head(obj?.head(0.5))
+obj.head(obj?.head(0.5), obj?.obj)
+obj.head(obj?.head(0.5, add))
+obj.head(obj?.head(1))
+obj.head(obj?.head(2))
+obj.head(obj?.head(2, f, 0.5, "b", b))
+obj.head(obj?.head(a))
+obj.head(obj?.head(a, f, obj, obj, nil))
+obj.head(obj?.head(add))
+obj.head(obj?.head(arr))
+obj.head(obj?.head(arr, true))
+obj.head(obj?.head(b))
+obj.head(obj?.head(b, a), a && true)
+obj.head(obj?.head(b, b))
+obj.head(obj?.head(div))
+obj.head(obj?.head(div), get(s, 1))
+obj.head(obj?.head(f), get(nil, a, "b"))
+obj.head(obj?.head(false))
+obj.head(obj?.head(false, arr))
+obj.head(obj?.head(false, false))
+obj.head(obj?.head(false, obj), b)
+obj.head(obj?.head(nil))
+obj.head(obj?.head(nil, a))
+obj.head(obj?.head(nil, true), a / f)
+obj.head(obj?.head(obj))
+obj.head(obj?.head(obj).head(arr))
+obj.head(obj?.head(obj, div, obj))
+obj.head(obj?.head(ok))
+obj.head(obj?.head(ok, "b", true, b, f))
+obj.head(obj?.head(ok, b, false))
+obj.head(obj?.head(ok, ok, ok))
+obj.head(obj?.head(s))
+obj.head(obj?.head(s, "b"), b, a)
+obj.head(obj?.head(true, ok))
+obj.head(obj?.obj)
+obj.head(obj?.obj).a
+obj.head(obj?.obj).obj
+obj.head(obj?.obj)?.obj
+obj.head(obj?.obj, add != nil)
+obj.head(obj?.obj, b)
+obj.head(obj?.obj, obj?.obj)
+obj.head(obj[s])?.obj
+obj.head(ok != "b", obj.a)
+obj.head(ok != 0)
+obj.head(ok != add)
+obj.head(ok != arr)
+obj.head(ok != f)
+obj.head(ok != nil)
+obj.head(ok != obj)
+obj.head(ok != ok)
+obj.head(ok != s)
+obj.head(ok != true)
+obj.head(ok && "c")
+obj.head(ok && "c", ok)
+obj.head(ok && 0)
+obj.head(ok && 0, s)
+obj.head(ok && 0.5)
+obj.head(ok && a)
+obj.head(ok && add)
+obj.head(ok && add, div)
+obj.head(ok && arr)
+obj.head(ok && arr, a ^ 0, add)
+obj.head(ok && b)
+obj.head(ok && div)
+obj.head(ok && f)
+obj.head(ok && false)
+obj.head(ok && nil)
+obj.head(ok && s)
+obj.head(ok && true)
+obj.head(ok == 0)
+obj.head(ok == 0.5)
+obj.head(ok == 2, a / 0.5)
+obj.head(ok == a)
+obj.head(ok == add)
+obj.head(ok == arr)
+obj.head(ok == b)
+obj.head(ok == f)
+obj.head(ok == false)
+obj.head(ok == ok)
+obj.head(ok == s)
+obj.head(ok ? 0 : add)
+obj.head(ok ? 2 : s)
+obj.head(ok ? add : 0)
+obj.head(ok ? arr : false)
+obj.head(ok ? arr : ok)
+obj.head(ok ? b : f)
+obj.head(ok ? b : nil)
+obj.head(ok ? div : 0)
+obj.head(ok ? obj : s)
+obj.head(ok ? ok : obj)
+obj.head(ok ? ok : s)
+obj.head(ok ? s : add)
+obj.head(ok and a) == obj
+obj.head(ok and add)
+obj.head(ok and arr)
+obj.head(ok and div)
+obj.head(ok and f)
+obj.head(ok and obj)
+obj.head(ok and true)
+obj.head(ok in map("b", nil))
+obj.head(ok or "a")
+obj.head(ok or "c")
+obj.head(ok or 0)
+obj.head(ok or 1)
+obj.head(ok or a)
+obj.head(ok or add)
+obj.head(ok or div)
+obj.head(ok or false)
+obj.head(ok or int(a)?.a?.b)
+obj.head(ok or obj)
+obj.head(ok or ok)
+obj.head(ok or s, get(0, nil))
+obj.head(ok || "a")
+obj.head(ok || a)
+obj.head(ok || add)
+obj.head(ok || arr)
+obj.head(ok || arr, any(obj, ok), b)
+obj.head(ok || div)
+obj.head(ok || f)
+obj.head(ok || nil)
+obj.head(ok || ok)
+obj.head(ok || s)
+obj.head(ok)
+obj.head(ok) != add
+obj.head(ok) != arr
+obj.head(ok) != f
+obj.head(ok) != obj.a
+obj.head(ok) && obj.a
+obj.head(ok) == add
+obj.head(ok) == string(a)
+obj.head(ok) ? arr : ok
+obj.head(ok) or !false
+obj.head(ok) or ok
+obj.head(ok, 1) == obj?.a
+obj.head(ok, 2, 0) != ok
+obj.head(ok, a + a)
+obj.head(ok, a <= a)
+obj.head(ok, a) == obj
+obj.head(ok, add)
+obj.head(ok, add) && obj.b
+obj.head(ok, arr, "a") or f != nil
+obj.head(ok, div)
+obj.head(ok, div) || obj.a.head(ok, a.head(nil, div) < false < "c", add)
+obj.head(ok, f != "a")
+obj.head(ok, f)
+obj.head(ok, false) == add(1, 1)
+obj.head(ok, get(a, obj))
+obj.head(ok, get(nil, a))
+obj.head(ok, map(obj, f))
+obj.head(ok, obj)
+obj.head(ok, obj.head(f))
+obj.head(ok, obj.obj)
+obj.head(ok, ok, div)
+obj.head(ok, s && false)
+obj.head(ok, s)
+obj.head(ok, s, add)
+obj.head(one("c", ok))
+obj.head(one(obj, ok))
+obj.head(one(s, false))
+obj.head(one(s, ok))
+obj.head(repeat("b", b))
+obj.head(repeat(s, 0))
+obj.head(s != "c")
+obj.head(s != 2, 0 .. b)
+obj.head(s != add, f ^ 0)
+obj.head(s != arr)
+obj.head(s != false)
+obj.head(s != obj)
+obj.head(s != ok)
+obj.head(s != s)
+obj.head(s + "a")
+obj.head(s + s)
+obj.head(s < "b")
+obj.head(s < s)
+obj.head(s <= "b", arr)
+obj.head(s <= s)
+obj.head(s == a)
+obj.head(s == arr)
+obj.head(s == b)
+obj.head(s == div)
+obj.head(s == f, a)
+obj.head(s == false)
+obj.head(s == ok)
+obj.head(s == true)
+obj.head(s > "b")
+obj.head(s >= "c")
+obj.head(s and false)
+obj.head(s contains s)
+obj.head(s contains s, obj.a)
+obj.head(s matches "b")
+obj.head(s matches "c")
+obj.head(s startsWith s)
+obj.head(s)
+obj.head(s) != "a" ? ok : s
+obj.head(s) != a
+obj.head(s) != obj?.obj
+obj.head(s) != string(b)
+obj.head(s) != true ? f : true
+obj.head(s) == 0 .. b
+obj.head(s) == div
+obj.head(s) == div != ok
+obj.head(s) == f
+obj.head(s) == nil ? arr : 0
+obj.head(s) == obj
+obj.head(s) in obj
+obj.head(s) in obj.obj
+obj.head(s) matches s ? obj : b
+obj.head(s) or false and ok
+obj.head(s)[a]
+obj.head(s)[obj?.b]
+obj.head(s, "a" == "a")
+obj.head(s, 0) <= s
+obj.head(s, 0, nil, a) <= s
+obj.head(s, 0.5 ** 1)
+obj.head(s, 0.5, 0.5) >= s
+obj.head(s, 2)[obj?.a]
+obj.head(s, a + f)
+obj.head(s, a)
+obj.head(s, all(arr, true), 0.5 * 0.5)
+obj.head(s, b ^ 0)
+obj.head(s, b)
+obj.head(s, b) == div
+obj.head(s, div)
+obj.head(s, f * b)
+obj.head(s, f == obj)
+obj.head(s, f)
+obj.head(s, f, obj)
+obj.head(s, false and nil)
+obj.head(s, false, true)[b]
+obj.head(s, get("a", obj), s != f)
+obj.head(s, nil != arr, ok)
+obj.head(s, now(add))
+obj.head(s, now(nil))
+obj.head(s, obj == arr)
+obj.head(s, obj)
+obj.head(s, ok, a)
+obj.head(s, s)
+obj.head(s, s) != obj.a
+obj.head(s[0])
+obj.head(s[a:1])
+obj.head(s[f])
+obj.head(splitAfter("c", "b", s, nil))
+obj.head(splitAfter("c", "c"))
+obj.head(string("a"), obj, a)
+obj.head(string("c", ok, ok))
+obj.head(string(0, ok))
+obj.head(string(0.5, "a", b))
+obj.head(string(1))
+obj.head(string(2, nil))
+obj.head(string(a))
+obj.head(string(a, nil))
+obj.head(string(add))
+obj.head(string(add, a, arr, f))
+obj.head(string(arr))
+obj.head(string(arr, b, f, s, f))
+obj.head(string(arr, obj, s, arr), all("c", ok))
+obj.head(string(b))
+obj.head(string(b, arr))
+obj.head(string(div))
+obj.head(string(div), ok == 1)
+obj.head(string(f, ok))
+obj.head(string(obj, false))
+obj.head(string(ok))
+obj.head(string(ok, true))
+obj.head(string(s))
+obj.head(string(s), div)
+obj.head(string(s, 0, obj))
+obj.head(string(true, div, obj, b))
+obj.head(toBase64("a", "b"))
+obj.head(toBase64("c"))
+obj.head(toBase64("c", b, a))
+obj.head(toBase64(s))
+obj.head(toJSON("a"))
+obj.head(toJSON("b"))
+obj.head(toJSON("b"), obj)
+obj.head(toJSON("c"))
+obj.head(toJSON("c", s))
+obj.head(toJSON(0))
+obj.head(toJSON(0, 0.5))
+obj.head(toJSON(0.5 < a))
+obj.head(toJSON(0.5))
+obj.head(toJSON(0.5, f, arr))
+obj.head(toJSON(1, ok, arr))
+obj.head(toJSON(2), f, 0.5 < f)
+obj.head(toJSON(a, f, 0, f))
+obj.head(toJSON(arr))
+obj.head(toJSON(b, add, ok))
+obj.head(toJSON(b, f, b))
+obj.head(toJSON(f))
+obj.head(toJSON(f, "b"))
+obj.head(toJSON(f, add, nil, obj))
+obj.head(toJSON(f, div))
+obj.head(toJSON(false), ok)
+obj.head(toJSON(false, f))
+obj.head(toJSON(nil))
+obj.head(toJSON(nil, div))
+obj.head(toJSON(ok))
+obj.head(toJSON(ok, obj, f))
+obj.head(toJSON(s, nil, ok))
+obj.head(toJSON(true), string(nil))
+obj.head(trim(s))
+obj.head(trimPrefix("c"))
+obj.head(trimPrefix(s), s)
+obj.head(trimSuffix("b"))
+obj.head(trimSuffix("c"))
+obj.head(trimSuffix(s))
+obj.head(true != 0)
+obj.head(true != add)
+obj.head(true != add, b == false)
+obj.head(true != div)
+obj.head(true != f, a)
+obj.head(true != obj)
+obj.head(true != ok, string(false, b, b, arr))
+obj.head(true && a) != f
+obj.head(true && add, get(nil, ok))
+obj.head(true && ok)
+obj.head(true && s)
+obj.head(true == "a")
+obj.head(true == 0.5)
+obj.head(true == a)
+obj.head(true == arr, ok)
+obj.head(true == f)
+obj.head(true == nil)
+obj.head(true ? add : false)
+obj.head(true ? arr : b)
+obj.head(true ? b : ok startsWith add.fn(true))
+obj.head(true ? div : arr, b)
+obj.head(true ? f : "b", s)
+obj.head(true ? obj : f)
+obj.head(true ? obj : nil)
+obj.head(true ? s : "a")
+obj.head(true and a)
+obj.head(true and arr)
+obj.head(true and b, s)
+obj.head(true and div)
+obj.head(true and nil)
+obj.head(true and obj)
+obj.head(true in arr)
+obj.head(true in nil)
+obj.head(true or 0)
+obj.head(true or 1, b)
+obj.head(true or a)
+obj.head(true or arr)
+obj.head(true or b)
+obj.head(true or obj)
+obj.head(true or ok)
+obj.head(true || arr)
+obj.head(true || obj)
+obj.head(true) != b
+obj.head(true) != obj
+obj.head(true) && obj?.obj?.b
+obj.head(true) == f
+obj.head(true, 0) or ok
+obj.head(true, add) or obj.b
+obj.head(true, add, b) && ok
+obj.head(true, div) || 0 == f
+obj.head(true, f) == s
+obj.head(upper("b"), b)
+obj.head(upper("c"))
+obj.head(upper("c"), b)
+obj.head(upper(a, "c"))
+obj.head(upper(s))
+obj.head(upper(s, a, 0.5, s))
+obj.head(upper(true, "a"))
+obj.head(values(obj))
+obj.head({"a": add})
+obj.head({"b": add, "b": b, "c": s})
+obj.obj
+obj.obj != 2 % 1
+obj.obj != a
+obj.obj != a / 1
+obj.obj != a == true
+obj.obj != a ? f : true
+obj.obj != add
+obj.obj != add(a, a)
+obj.obj != any(arr, true)
+obj.obj != arr
+obj.obj != arr ? false : b
+obj.obj != b
+obj.obj != b .. b
+obj.obj != b ? a : s
+obj.obj != div
+obj.obj != div(b, b)
+obj.obj != f
+obj.obj != f != nil
+obj.obj != f / f
+obj.obj != float(b)
+obj.obj != min(b)
+obj.obj != obj
+obj.obj != obj.a
+obj.obj != obj.head(0)
+obj.obj != obj?.a
+obj.obj != obj?.b
+obj.obj != ok
+obj.obj != s
+obj.obj != string(0.5)
+obj.obj != string(2)
+obj.obj && !false
+obj.obj == -b
+obj.obj == 0 == nil ? get(arr, a) : ok
+obj.obj == 2 ** f
+obj.obj == a
+obj.obj == a ** f
+obj.obj == add
+obj.obj == add ? arr : obj
+obj.obj == add ? div : "c"
+obj.obj == add(a, 0)
+obj.obj == any(arr, false)
+obj.obj == arr
+obj.obj == b
+obj.obj == div
+obj.obj == div != ok
+obj.obj == f
+obj.obj == f == ok
+obj.obj == f ? div : 0.5
+obj.obj == none(arr, ok)
+obj.obj == not true
+obj.obj == obj
+obj.obj == obj.obj
+obj.obj == obj.obj?.obj
+obj.obj == obj?.b
+obj.obj == obj?.head(0, ok)
+obj.obj == ok
+obj.obj == ok == ok
+obj.obj == s
+obj.obj == true ? 1 : a
+obj.obj == true ? nil : "a"
+obj.obj in arr
+obj.obj in map(arr, "a")
+obj.obj or "b" == "a"
+obj.obj or false and obj?.b?.b
+obj.obj.a
+obj.obj.a != b
+obj.obj.a ** a
+obj.obj.b
+obj.obj.b ** b
+obj.obj.b .. b
+obj.obj.b < b
+obj.obj.b ^ -f ^ -f
+obj.obj.obj
+obj.obj.obj.a
+obj.obj.obj.b
+obj.obj.obj.obj
+obj.obj.obj?.a
+obj.obj.obj?.b
+obj.obj.obj?.obj
+obj.obj?.a
+obj.obj?.a ** f
+obj.obj?.a == arr
+obj.obj?.b
+obj.obj?.b != add
+obj.obj?.b * f
+obj.obj?.obj
+obj.obj?.obj != b
+obj.obj?.obj.a
+obj.obj?.obj.b
+obj.obj?.obj.obj
+obj.obj?.obj?.a
+obj.obj?.obj?.b
+obj.obj?.obj?.obj
+obj.obj?.obj[s]
+obj.obj[obj.head(nil)]
+obj.obj[s]
+obj.obj[toJSON(s)]
+obj.obj[trimPrefix(s)]
+obj?.a
+obj?.a != (ok and ok)
+obj?.a != a
+obj?.a != add
+obj?.a != arr
+obj?.a != b
+obj?.a != div
+obj?.a != f
+obj?.a != f ** a
+obj?.a != obj
+obj?.a != obj.head(s, div, "b", 1)
+obj?.a != obj.obj
+obj?.a != obj?.a
+obj?.a != obj?.b
+obj?.a != ok
+obj?.a != ok ? b : arr
+obj?.a != s
+obj?.a != s != false
+obj?.a != toJSON(arr)
+obj?.a != trimPrefix("a")
+obj?.a % a
+obj?.a % b
+obj?.a % obj.a
+obj?.a % obj?.b
+obj?.a * -0.5
+obj?.a * a
+obj?.a * arr[a]
+obj?.a * b
+obj?.a * f
+obj?.a * min(f, f)
+obj?.a * obj.a
+obj?.a ** a
+obj?.a ** abs(0)
+obj?.a ** add(b, 0)
+obj?.a ** b
+obj?.a ** f
+obj?.a ** obj?.head(f, ok)
+obj?.a + a
+obj?.a + abs(a)
+obj?.a + add(0, 0)
+obj?.a + arr[b]
+obj?.a + b
+obj?.a + f
+obj?.a + f ** a
+obj?.a + obj.a
+obj?.a + obj?.a
+obj?.a + obj?.b
+obj?.a - 0 % 1
+obj?.a - 0 * 0
+obj?.a - 0 * 0.5
+obj?.a - 0 * 2
+obj?.a - a
+obj?.a - b
+obj?.a - f
+obj?.a - obj.b
+obj?.a - obj?.a
+obj?.a .. a
+obj?.a .. b
+obj?.a .. count(arr, true)
+obj?.a .. div(b, 2)
+obj?.a .. obj.b
+obj?.a .. obj?.a
+obj?.a / (b + f)
+obj?.a / a
+obj?.a / b
+obj?.a / b ** f
+obj?.a / f
+obj?.a / obj.head(b, a)
+obj?.a / obj?.b
+obj?.a < a
+obj?.a < a ? "c" : add
+obj?.a < a ? s : false
+obj?.a < b
+obj?.a < f
+obj?.a < float(b)
+obj?.a < obj.a
+obj?.a < obj?.a
+obj?.a <= 0 * 0.5
+obj?.a <= 0 == false
+obj?.a <= 2 ? b : ok
+obj?.a <= a
+obj?.a <= a + f
+obj?.a <= b
+obj?.a <= b + a
+obj?.a <= count(arr, ok)
+obj?.a <= div(b, a)
+obj?.a <= f
+obj?.a <= f ^ f
+obj?.a <= len(arr)
+obj?.a <= obj.head(0.5, add, false, nil)
+obj?.a <= obj?.b
+obj?.a == -1
+obj?.a == 0.5 ^ a
+obj?.a == a
+obj?.a == a ** f
+obj?.a == add
+obj?.a == arr
+obj?.a == b
+obj?.a == b ? ok : obj
+obj?.a == count(arr, ok)
+obj?.a == div
+obj?.a == div ? 2 : true
+obj?.a == div ? b : div
+obj?.a == div ? s : b
+obj?.a == f
+obj?.a == f != ok
+obj?.a == f ^ 0.5
+obj?.a == min(2, 0)
+obj?.a == nil ? 0 : a
+obj?.a == obj
+obj?.a == ok
+obj?.a == s
+obj?.a == toJSON(s)
+obj?.a > -1
+obj?.a > 1 ? 2 : 0.5
+obj?.a > a
+obj?.a > a ^ f
+obj?.a > b
+obj?.a > b + a
+obj?.a > b ? "b" : obj.a
+obj?.a > f
+obj?.a > f * b
+obj?.a > get(arr, 0)
+obj?.a > obj.a
+obj?.a > obj?.a
+obj?.a > obj?.b
+obj?.a >= 0 != nil
+obj?.a >= 0 * 0
+obj?.a >= 2 != nil
+obj?.a >= 2 / a
+obj?.a >= a
+obj?.a >= b
+obj?.a >= div(b, a)
+obj?.a >= f
+obj?.a >= f ? true : a == obj?.a?.a
+obj?.a >= obj.a
+obj?.a >= obj.b
+obj?.a >= obj.head(2, obj)
+obj?.a >= obj?.a
+obj?.a >= obj?.head(f, f)
+obj?.a ^ (b * 1)
+obj?.a ^ -b
+obj?.a ^ a
+obj?.a ^ arr[b]
+obj?.a ^ b
+obj?.a ^ f
+obj?.a ^ len(s)
+obj?.a ^ obj.a
+obj?.a ^ obj?.a
+obj?.a ^ obj?.b
+obj?.a ^ obj?.head(b, "c", 1)
+obj?.a in arr
+obj?.a in values(obj)
+obj?.a || !true
+obj?.a || not false
+obj?.b
+obj?.b != "a" ? f : false
+obj?.b != "a" ? nil : nil
+obj?.b != 0 ** f
+obj?.b != 0.5 + b
+obj?.b != 2 * b
+obj?.b != a
+obj?.b != a ? a : add
+obj?.b != a ? false : b
+obj?.b != add
+obj?.b != add == nil
+obj?.b != add ? 0 : "a"
+obj?.b != arr
+obj?.b != arr[a]
+obj?.b != b
+obj?.b != b ** 0
+obj?.b != div
+obj?.b != div ? div : 2
+obj?.b != f
+obj?.b != float(b)
+obj?.b != map(arr, a)
+obj?.b != map(arr, arr)
+obj?.b != max(0)
+obj?.b != min(a)
+obj?.b != obj
+obj?.b != obj.head(b, b)
+obj?.b != obj.obj
+obj?.b != obj?.a
+obj?.b != ok
+obj?.b != s
+obj?.b != toBase64(s)
+obj?.b % -a
+obj?.b % a
+obj?.b % b
+obj?.b % get(arr, 2)
+obj?.b % obj.a
+obj?.b % obj.head(a, f, arr)
+obj?.b % obj?.a
+obj?.b % obj?.head(1)
+obj?.b * (a + a)
+obj?.b * (f + b)
+obj?.b * 0 ^ f
+obj?.b * a
+obj?.b * a ** b
+obj?.b * a / f
+obj?.b * b
+obj?.b * div(b, a)
+obj?.b * f
+obj?.b * float(b)
+obj?.b * obj.a
+obj?.b * obj.head(2, add)
+obj?.b * obj.head(b, 0)
+obj?.b * obj?.b
+obj?.b ** (0 + b)
+obj?.b ** (b + b)
+obj?.b ** a
+obj?.b ** add(a, 0)
+obj?.b ** b
+obj?.b ** b ^ 0.5
+obj?.b ** f
+obj?.b ** max(0)
+obj?.b ** obj.a
+obj?.b ** obj.b
+obj?.b ** obj.head(a)
+obj?.b ** obj?.a
+obj?.b + a
+obj?.b + add(b, 2)
+obj?.b + b
+obj?.b + b * f
+obj?.b + div(a, 2)
+obj?.b + obj.a
+obj?.b + obj.b
+obj?.b + obj?.b
+obj?.b - -a
+obj?.b - 0 * 0
+obj?.b - 0 + a
+obj?.b - 0 ^ b
+obj?.b - a
+obj?.b - a + a
+obj?.b - b
+obj?.b - b - 1
+obj?.b - f
+obj?.b - f ** a
+obj?.b - obj.a
+obj?.b - obj.b
+obj?.b - obj?.a
+obj?.b .. 2 - 0
+obj?.b .. a
+obj?.b .. add(b, a)
+obj?.b .. b
+obj?.b .. obj.b
+obj?.b .. obj?.a
+obj?.b .. obj?.b
+obj?.b .. obj?.fn(a)
+obj?.b / (0 - b)
+obj?.b / 0 * f
+obj?.b / 0.5 ** b
+obj?.b / a
+obj?.b / b
+obj?.b / count(arr, ok)
+obj?.b / div(a, b)
+obj?.b / f
+obj?.b / get(arr, 0)
+obj?.b / obj.b
+obj?.b / obj?.a
+obj?.b / obj?.b
+obj?.b < 0 != ok
+obj?.b < 1 + 2
+obj?.b < 1 - a
+obj?.b < a
+obj?.b < add(b, 0)
+obj?.b < b
+obj?.b < b != ok
+obj?.b < f
+obj?.b < f * b
+obj?.b < obj?.b
+obj?.b <= -a
+obj?.b <= a
+obj?.b <= add(0, 1)
+obj?.b <= b
+obj?.b <= f
+obj?.b <= f + b
+obj?.b <= f / 2
+obj?.b <= f / b
+obj?.b <= obj?.b
+obj?.b == !false
+obj?.b == 0 * a
+obj?.b == 1 .. 0
+obj?.b == a
+obj?.b == a + f
+obj?.b == add
+obj?.b == arr
+obj?.b == arr ? add : s
+obj?.b == b
+obj?.b == b - a
+obj?.b == div
+obj?.b == f
+obj?.b == obj
+obj?.b == obj.obj
+obj?.b == obj?.b
+obj?.b == obj?.obj
+obj?.b == ok
+obj?.b == s
+obj?.b == s == nil
+obj?.b == s == ok
+obj?.b == s ? 0.5 : "a"
+obj?.b == s ? add : obj
+obj?.b == upper("c")
+obj?.b > 0 * a
+obj?.b > a
+obj?.b > b
+obj?.b > b ^ 0
+obj?.b > f
+obj?.b > max(1)
+obj?.b > min(0.5)
+obj?.b >= -a
+obj?.b >= 0 ** a
+obj?.b >= 0.5 != true
+obj?.b >= 0.5 ? div : arr
+obj?.b >= a
+obj?.b >= b
+obj?.b >= b + 0
+obj?.b >= b + b
+obj?.b >= div(b, 1)
+obj?.b >= f
+obj?.b >= max(f, f)
+obj?.b >= obj.a
+obj?.b >= obj.head(a, arr, add)
+obj?.b >= obj?.b
+obj?.b ^ (0 * f)
+obj?.b ^ -b
+obj?.b ^ a
+obj?.b ^ arr[2]
+obj?.b ^ b
+obj?.b ^ f
+obj?.b ^ int(f)
+obj?.b ^ obj.a
+obj?.b ^ obj.head(0)
+obj?.b ^ obj?.head(obj, obj, a).a
+obj?.b and (true || false)
+obj?.b in arr
+obj?.b in arr ? arr : a
+obj?.b in map(arr, true)
+obj?.c != div
+obj?.c != obj
+obj?.c?.a
+obj?.c?.a?.b
+obj?.c?.b
+obj?.c?.b.obj
+obj?.c?.fn(div)
+obj?.c?.obj
+obj?.c?.obj.b
+obj?.fn(-0)
+obj?.fn(-1)
+obj?.fn(-2)
+obj?.fn(-a)
+obj?.fn(-b)
+obj?.fn(0 % a)
+obj?.fn(0 * a)
+obj?.fn(0 + 0)
+obj?.fn(0 + a)
+obj?.fn(0 + b)
+obj?.fn(0 - 0)
+obj?.fn(0 - b)
+obj?.fn(0 or false)
+obj?.fn(0) != a
+obj?.fn(0) != ok
+obj?.fn(0) != {"b": 1, "a": div}
+obj?.fn(0) ** f
+obj?.fn(0) + b
+obj?.fn(0) / b
+obj?.fn(0) == a
+obj?.fn(0) == add
+obj?.fn(0) == obj
+obj?.fn(0) >= b
+obj?.fn(0) ^ b
+obj?.fn(0) ^ obj?.a
+obj?.fn(1 % a)
+obj?.fn(1 * b)
+obj?.fn(1 + 0)
+obj?.fn(1 + a)
+obj?.fn(1 - b)
+obj?.fn(1) != string(f)
+obj?.fn(1) * f / b
+obj?.fn(1) / b
+obj?.fn(1) < obj.head(0.5, s)
+obj?.fn(1) < obj?.head(a)
+obj?.fn(2 - 0)
+obj?.fn(2 - b)
+obj?.fn(2) % a
+obj?.fn(2) - obj.head(0.5, 0, b, 0.5)
+obj?.fn(2) <= a
+obj?.fn(2) == arr ? obj : b
+obj?.fn(a % 2)
+obj?.fn(a % a)
+obj?.fn(a % b)
+obj?.fn(a * 0)
+obj?.fn(a * 1)
+obj?.fn(a * 2)
+obj?.fn(a * a)
+obj?.fn(a + 2)
+obj?.fn(a + a)
+obj?.fn(a + b)
+obj?.fn(a - 1)
+obj?.fn(a - 2)
+obj?.fn(a - b)
+obj?.fn(a || false)
+obj?.fn(a)
+obj?.fn(a) != 0 .. b
+obj?.fn(a) != arr
+obj?.fn(a) != b
+obj?.fn(a) != div
+obj?.fn(a) != toBase64(s)
+obj?.fn(a) - 0.5 ** f
+obj?.fn(a) .. b
+obj?.fn(a) / a
+obj?.fn(a) == add
+obj?.fn(a) == s
+obj?.fn(a) > b
+obj?.fn(a) > obj.a
+obj?.fn(a) >= a
+obj?.fn(a) ^ a
+obj?.fn(a) || ok || true
+obj?.fn(abs(0.5, div, a))
+obj?.fn(abs(2))
+obj?.fn(abs(a))
+obj?.fn(abs(add, b, "b", a))
+obj?.fn(abs(arr, a))
+obj?.fn(abs(b))
+obj?.fn(abs(s, a))
+obj?.fn(add(0, 1))
+obj?.fn(add(0, b))
+obj?.fn(add(1, 0))
+obj?.fn(add(1, 2))
+obj?.fn(add(2, a))
+obj?.fn(add(2, b))
+obj?.fn(add(a, 0))
+obj?.fn(add(a, 2))
+obj?.fn(add(a, b))
+obj?.fn(add(b, a))
+obj?.fn(add(b, b))
+obj?.fn(arr[0.5])
+obj?.fn(arr[1])
+obj?.fn(arr[b])
+obj?.fn(arr[f])
+obj?.fn(b % 2)
+obj?.fn(b % a)
+obj?.fn(b && true)
+obj?.fn(b * b)
+obj?.fn(b + 0)
+obj?.fn(b + a)
+obj?.fn(b + b)
+obj?.fn(b - a)
+obj?.fn(b - b)
+obj?.fn(b)
+obj?.fn(b) != (false and ok)
+obj?.fn(b) != obj
+obj?.fn(b) != ok
+obj?.fn(b) != string("c")
+obj?.fn(b) * obj.obj?.a
+obj?.fn(b) - a
+obj?.fn(b) - f
+obj?.fn(b) - obj.b
+obj?.fn(b) .. b
+obj?.fn(b) < a
+obj?.fn(b) < b
+obj?.fn(b) == obj
+obj?.fn(b) > div(b, a)
+obj?.fn(b) ^ a
+obj?.fn(b) ^ b
+obj?.fn(b) in arr
+obj?.fn(count("a", false))
+obj?.fn(count("a", true))
+obj?.fn(count(arr, false))
+obj?.fn(count(arr, ok))
+obj?.fn(count(obj, false))
+obj?.fn(count(s, ok))
+obj?.fn(count(s, true))
+obj?.fn(div(0, 1))
+obj?.fn(div(0, b))
+obj?.fn(div(1, a))
+obj?.fn(div(2, 1))
+obj?.fn(div(2, a))
+obj?.fn(div(2, b))
+obj?.fn(div(a, 1))
+obj?.fn(div(a, a))
+obj?.fn(div(a, b))
+obj?.fn(div(b, 1))
+obj?.fn(div(b, 2))
+obj?.fn(div(b, a))
+obj?.fn(div(b, b))
+obj?.fn(false ? false : a)
+obj?.fn(false or 2)
+obj?.fn(false || 0)
+obj?.fn(get(arr, 0))
+obj?.fn(get(arr, 1))
+obj?.fn(get(arr, 2))
+obj?.fn(get(arr, a))
+obj?.fn(get(arr, b))
+obj?.fn(get(arr, f))
+obj?.fn(get(obj, "b"))
+obj?.fn(int(0))
+obj?.fn(int(0.5))
+obj?.fn(int(2))
+obj?.fn(int(a))
+obj?.fn(int(a, nil, 0))
+obj?.fn(int(add, b))
+obj?.fn(int(b))
+obj?.fn(int(b, 1))
+obj?.fn(int(f))
+obj?.fn(int(f, a, s, a))
+obj?.fn(int(ok, ok, 0))
+obj?.fn(int(s, "c", 0.5))
+obj?.fn(last(arr))
+obj?.fn(last(arr, 0.5))
+obj?.fn(len(0, f, obj, nil, "c"))
+obj?.fn(len(arr))
+obj?.fn(len(f, arr, obj))
+obj?.fn(len(obj))
+obj?.fn(len(ok, s))
+obj?.fn(max(0))
+obj?.fn(max(a))
+obj?.fn(max(b, a))
+obj?.fn(min(0))
+obj?.fn(min(2))
+obj?.fn(min(a))
+obj?.fn(obj.a)
+obj?.fn(obj.b)
+obj?.fn(obj.fn(1))
+obj?.fn(obj.head(0))
+obj?.fn(obj.head(0, nil))
+obj?.fn(obj.head(2, f, 0))
+obj?.fn(obj.head(a))
+obj?.fn(obj.head(a, arr))
+obj?.fn(obj.head(b))
+obj?.fn(obj.head(b, nil, 2))
+obj?.fn(obj.head(b, true))
+obj?.fn(obj.obj?.b)
+obj?.fn(obj?.a)
+obj?.fn(obj?.a) == b
+obj?.fn(obj?.b)
+obj?.fn(obj?.fn(0))
+obj?.fn(obj?.fn(1))
+obj?.fn(obj?.fn(2))
+obj?.fn(obj?.fn(a))
+obj?.fn(obj?.fn(b))
+obj?.fn(obj?.head(0))
+obj?.fn(obj?.head(0, arr))
+obj?.fn(obj?.head(0, s))
+obj?.fn(obj?.head(a))
+obj?.fn(obj?.head(a, 0, nil))
+obj?.fn(obj?.head(a, arr))
+obj?.fn(obj?.head(a, div, add))
+obj?.fn(obj?.head(b, 2))
+obj?.fn(obj?.head(b, add))
+obj?.fn(obj?.head(b, add, b))
+obj?.fn(obj?.head(b, add, nil))
+obj?.fn(obj?.obj.a)
+obj?.fn(ok ? 2 : 0)
+obj?.fn(ok ? b : obj)
+obj?.fn(ok and 1)
+obj?.fn(ok and a)
+obj?.fn(ok and b)
+obj?.fn(ok) and not true
+obj?.fn(true && 0)
+obj?.fn(true and 0)
+obj?.fn(true and a)
+obj?.head(!(add == arr))
+obj?.head(!false)
+obj?.head(!ok)
+obj?.head(!true)
+obj?.head("a" != 2)
+obj?.head("a" != arr)
+obj?.head("a" != b)
+obj?.head("a" != false)
+obj?.head("a" != true)
+obj?.head("a" < "b")
+obj?.head("a" == add)
+obj?.head("a" == arr, div)
+obj?.head("a" == false)
+obj?.head("a" > "b")
+obj?.head("a" > s)
+obj?.head("a" matches "c")
+obj?.head("a" startsWith "a")
+obj?.head("a" startsWith "b")
+obj?.head("a") <= s
+obj?.head("a") == arr
+obj?.head("a") > s
+obj?.head("a") contains s
+obj?.head("a") in 0 .. a
+obj?.head("a") in obj.obj
+obj?.head("a", 0) == b ** 0
+obj?.head("a", a) != arr ? s : false
+obj?.head("b" != "c")
+obj?.head("b" != 0)
+obj?.head("b" != 1)
+obj?.head("b" != 2)
+obj?.head("b" != arr)
+obj?.head("b" != nil)
+obj?.head("b" + "a")
+obj?.head("b" + s)
+obj?.head("b" == 0)
+obj?.head("b" == b, indexOf(s, s), a, b)
+obj?.head("b" == nil)
+obj?.head("b" > s)
+obj?.head("b" endsWith "a")
+obj?.head("b" in obj)
+obj?.head("b" matches s)
+obj?.head("b") == obj.a
+obj?.head("b", s, arr) == obj
+obj?.head("c" != "a")
+obj?.head("c" != arr)
+obj?.head("c" != div)
+obj?.head("c" + s)
+obj?.head("c" == arr)
+obj?.head("c" == div)
+obj?.head("c" == obj)
+obj?.head("c" == s)
+obj?.head("c" >= s)
+obj?.head("c" startsWith s)
+obj?.head("c") != ok
+obj?.head("c") == false == false
+obj?.head("c") == s
+obj?.head("c", 2, 0) + s
+obj?.head("c", add) contains s
+obj?.head("c", add) in obj
+obj?.head("c", b) != arr
+obj?.head("c", b) in arr
+obj?.head((b + 0) * a < b)
+obj?.head(-0)
+obj?.head(-0.5)
+obj?.head(-1)
+obj?.head(-a)
+obj?.head(-a, add)
+obj?.head(-b)
+obj?.head(-b, obj?.head("c", 0))
+obj?.head(-f)
+obj?.head(-f, add)
+obj?.head(0 != 0)
+obj?.head(0 != 1)
+obj?.head(0 != a)
+obj?.head(0 != arr)
+obj?.head(0 != b)
+obj?.head(0 != div)
+obj?.head(0 != f)
+obj?.head(0 != false)
+obj?.head(0 != nil)
+obj?.head(0 != obj)
+obj?.head(0 != obj, obj, -b)
+obj?.head(0 != obj?.obj)
+obj?.head(0 % 2)
+obj?.head(0 % a)
+obj?.head(0 % b)
+obj?.head(0 && false)
+obj?.head(0 * 0)
+obj?.head(0 * f)
+obj?.head(0 + 0)
+obj?.head(0 + 2)
+obj?.head(0 + a)
+obj?.head(0 + b)
+obj?.head(0 - 0)
+obj?.head(0 - 0.5)
+obj?.head(0 - 2)
+obj?.head(0 - a)
+obj?.head(0 - b)
+obj?.head(0 - f)
+obj?.head(0 .. 2)
+obj?.head(0 .. b)
+obj?.head(0 / 0)
+obj?.head(0 < 0.5)
+obj?.head(0 < a)
+obj?.head(0 <= 0)
+obj?.head(0 <= 0.5)
+obj?.head(0 <= a, get("a", b))
+obj?.head(0 <= b, obj)
+obj?.head(0 <= f)
+obj?.head(0 == "b")
+obj?.head(0 == 1)
+obj?.head(0 == add)
+obj?.head(0 == arr)
+obj?.head(0 == b)
+obj?.head(0 == div)
+obj?.head(0 == div, f != b)
+obj?.head(0 == nil)
+obj?.head(0 == obj)
+obj?.head(0 == s)
+obj?.head(0 > 0)
+obj?.head(0 > b)
+obj?.head(0 > f)
+obj?.head(0 > f, false or "b")
+obj?.head(0 >= 0)
+obj?.head(0 >= 2)
+obj?.head(0 >= a)
+obj?.head(0 >= f)
+obj?.head(0 ^ 0)
+obj?.head(0 ^ 0, f != obj)
+obj?.head(0 ^ 0, string(div, f, b, s))
+obj?.head(0 ^ b, obj, now(0.5))
+obj?.head(0 or true)
+obj?.head(0) != add
+obj?.head(0) != b
+obj?.head(0) != div
+obj?.head(0) != filter(arr, ok)
+obj?.head(0) % obj.a
+obj?.head(0) ** b
+obj?.head(0) - obj?.fn(b)
+obj?.head(0) .. a
+obj?.head(0) .. obj.b
+obj?.head(0) / obj?.a
+obj?.head(0) < div(b, b)
+obj?.head(0) in map(arr, false)
+obj?.head(0, 1) != f
+obj?.head(0, 1) != nil ? "a" : arr
+obj?.head(0, 2, ok) == f
+obj?.head(0, 2, s) * b
+obj?.head(0, arr) .. b
+obj?.head(0, arr, ok, ok) % b
+obj?.head(0, f, 0, ok) .. a
+obj?.head(0, ok) % a
+obj?.head(0, ok) % b
+obj?.head(0.5 != 0)
+obj?.head(0.5 != 1)
+obj?.head(0.5 != 2)
+obj?.head(0.5 != a, add, 0 == ok)
+obj?.head(0.5 != arr, obj)
+obj?.head(0.5 != false)
+obj?.head(0.5 != obj)
+obj?.head(0.5 && true)
+obj?.head(0.5 * 0.5)
+obj?.head(0.5 * b)
+obj?.head(0.5 * b, f <= a)
+obj?.head(0.5 ** 0)
+obj?.head(0.5 ** 0.5, a)
+obj?.head(0.5 ** a)
+obj?.head(0.5 + 2)
+obj?.head(0.5 + f)
+obj?.head(0.5 - f)
+obj?.head(0.5 - f, add, a)
+obj?.head(0.5 .. f)
+obj?.head(0.5 / 0.5)
+obj?.head(0.5 / 2)
+obj?.head(0.5 < 0)
+obj?.head(0.5 <= 0)
+obj?.head(0.5 <= f)
+obj?.head(0.5 == "c")
+obj?.head(0.5 == a)
+obj?.head(0.5 == arr)
+obj?.head(0.5 == ok)
+obj?.head(0.5 == true)
+obj?.head(0.5 > f)
+obj?.head(0.5) != a
+obj?.head(0.5) != arr
+obj?.head(0.5) != b
+obj?.head(0.5) - f
+obj?.head(0.5) <= f ? true : a
+obj?.head(0.5) == b
+obj?.head(0.5) == ok ? 0 : obj
+obj?.head(0.5) > f
+obj?.head(0.5) > f / f
+obj?.head(0.5, a) in arr ? add : f
+obj?.head(0.5, a, f) + 2 * f
+obj?.head(0.5, arr, div, f, "a") >= f
+obj?.head(0.5, arr, true) > obj?.b
+obj?.head(0.5, b) == obj
+obj?.head(0.5, nil) != b
+obj?.head(0.5, nil) ^ b
+obj?.head(0.5, nil, 0) / add(b, a)
+obj?.head(0.5, ok) <= a
+obj?.head(0.5, true) < obj?.a
+obj?.head(1 != 0)
+obj?.head(1 != ok)
+obj?.head(1 % b, ok, obj)
+obj?.head(1 * a)
+obj?.head(1 * b)
+obj?.head(1 + 0)
+obj?.head(1 + b, obj.head(add, ok))
+obj?.head(1 - b)
+obj?.head(1 - f, get(add, 1))
+obj?.head(1 .. b)
+obj?.head(1 < b)
+obj?.head(1 == add)
+obj?.head(1 == arr)
+obj?.head(1 == s)
+obj?.head(1 > b)
+obj?.head(1 >= f)
+obj?.head(1 ^ 1)
+obj?.head(1 ^ a)
+obj?.head(1 ^ f)
+obj?.head(1 and false)
+obj?.head(1 in nil)
+obj?.head(1 or true)
+obj?.head(1) != div
+obj?.head(1) * a
+obj?.head(1) >= f
+obj?.head(1, add) != obj.a
+obj?.head(1, add, s, ok) / obj.a
+obj?.head(1, s) + obj.head(0)
+obj?.head(2 != 0.5, filter(arr, false))
+obj?.head(2 != b)
+obj?.head(2 != div)
+obj?.head(2 != f)
+obj?.head(2 != nil)
+obj?.head(2 != nil, one("c", false))
+obj?.head(2 != s)
+obj?.head(2 != true)
+obj?.head(2 * f)
+obj?.head(2 ** b, upper(false, s))
+obj?.head(2 ** f)
+obj?.head(2 + 0.5)
+obj?.head(2 - b)
+obj?.head(2 .. 0)
+obj?.head(2 .. 0, f, s endsWith s)
+obj?.head(2 .. a)
+obj?.head(2 .. f)
+obj?.head(2 / a, arr, obj.obj)
+obj?.head(2 < 0.5)
+obj?.head(2 <= 0)
+obj?.head(2 <= a)
+obj?.head(2 <= f, f && false, add)
+obj?.head(2 == nil)
+obj?.head(2 == true)
+obj?.head(2 ^ b)
+obj?.head(2 in arr)
+obj?.head(2 || false)
+obj?.head(2) != a
+obj?.head(2) * a
+obj?.head(2) ** a
+obj?.head(2) - f
+obj?.head(2) == arr
+obj?.head(2) > a * f
+obj?.head(2) in obj?.head(nil)
+obj?.head(2, 1, arr, b, add) in arr
+obj?.head(2, arr, div) == a
+obj?.head(2, obj, "a", div) <= b % a
+obj?.head(2, obj, nil) .. b
+obj?.head(2, s, b) in arr
+obj?.head(["c", "a"])
+obj?.head(a != "a")
+obj?.head(a != "b")
+obj?.head(a != arr)
+obj?.head(a != div)
+obj?.head(a != false)
+obj?.head(a != nil)
+obj?.head(a != obj)
+obj?.head(a != obj, arr)
+obj?.head(a != ok)
+obj?.head(a % b)
+obj?.head(a * 0)
+obj?.head(a * a, obj)
+obj?.head(a ** 0)
+obj?.head(a ** 0.5)
+obj?.head(a ** a)
+obj?.head(a ** b)
+obj?.head(a ** f)
+obj?.head(a + 0)
+obj?.head(a + 0.5)
+obj?.head(a + 1)
+obj?.head(a + a)
+obj?.head(a + b)
+obj?.head(a - 0)
+obj?.head(a - 0.5)
+obj?.head(a - 1)
+obj?.head(a - b)
+obj?.head(a - f, ok)
+obj?.head(a .. 1)
+obj?.head(a .. a)
+obj?.head(a .. f)
+obj?.head(a / 0)
+obj?.head(a / a)
+obj?.head(a / b)
+obj?.head(a < 0)
+obj?.head(a < 0.5)
+obj?.head(a < a)
+obj?.head(a < a, a)
+obj?.head(a < b)
+obj?.head(a <= 0)
+obj?.head(a <= b)
+obj?.head(a == 0.5, string(2, true))
+obj?.head(a == add)
+obj?.head(a == arr)
+obj?.head(a == obj)
+obj?.head(a == obj, a, obj in nil, s)
+obj?.head(a == obj, obj.b)
+obj?.head(a == ok)
+obj?.head(a == s)
+obj?.head(a > 0)
+obj?.head(a > a)
+obj?.head(a >= 0)
+obj?.head(a >= 0, a)
+obj?.head(a ^ 0.5)
+obj?.head(a ^ 2, map(arr, obj))
+obj?.head(a ^ a)
+obj?.head(a ^ b)
+obj?.head(a ^ f)
+obj?.head(a and false)
+obj?.head(a in arr)
+obj?.head(a || false)
+obj?.head(a)
+obj?.head(a) != s
+obj?.head(a) * 2 ^ f
+obj?.head(a) ** (b * 0)
+obj?.head(a) ** b
+obj?.head(a) + obj?.a
+obj?.head(a) - 0.5 / f
+obj?.head(a) / b
+obj?.head(a) / obj?.head(2, s, arr)
+obj?.head(a) < -a
+obj?.head(a) <= a
+obj?.head(a) == nil ? nil : nil
+obj?.head(a) == one(arr, ok)
+obj?.head(a) > f
+obj?.head(a) > obj?.b
+obj?.head(a) >= b - b
+obj?.head(a) ^ a
+obj?.head(a, "c", 1, div, nil) != ok
+obj?.head(a, "c", arr) % a
+obj?.head(a, 0, ok, add) .. b
+obj?.head(a, 0.5, s, f) ^ a
+obj?.head(a, a)
+obj?.head(a, a, add)
+obj?.head(a, all(obj, true))
+obj?.head(a, arr)
+obj?.head(a, arr, obj)
+obj?.head(a, b > b)
+obj?.head(a, b) <= a
+obj?.head(a, b) == 0 + f
+obj?.head(a, div, div, ok)
+obj?.head(a, f ** f, a != 0.5)
+obj?.head(a, f, s) >= b
+obj?.head(a, false or f)
+obj?.head(a, false) != div
+obj?.head(a, max(a, f, f))
+obj?.head(a, obj)
+obj?.head(a, obj, f, 0) ^ obj?.a
+obj?.head(a, obj.head(b))
+obj?.head(a, obj?.a)
+obj?.head(a, ok, a)
+obj?.head(a, ok, b, s, add) in arr
+obj?.head(a, s)
+obj?.head(a, s, a)
+obj?.head(a, true, a) * b
+obj?.head(abs(0))
+obj?.head(abs(0, b))
+obj?.head(abs(0, b, s, obj, 0))
+obj?.head(abs(0.5))
+obj?.head(abs(2))
+obj?.head(abs(a, s, a))
+obj?.head(abs(b))
+obj?.head(abs(f))
+obj?.head(abs(obj, a))
+obj?.head(abs(obj, b))
+obj?.head(abs(obj, true, a))
+obj?.head(abs(s, a))
+obj?.head(abs(s, a), add, f)
+obj?.head(add != 0.5)
+obj?.head(add != a)
+obj?.head(add != add)
+obj?.head(add != div)
+obj?.head(add != false)
+obj?.head(add != nil)
+obj?.head(add != ok)
+obj?.head(add != s)
+obj?.head(add != true)
+obj?.head(add && false)
+obj?.head(add && true)
+obj?.head(add == "a")
+obj?.head(add == 0.5, b != nil)
+obj?.head(add == a, s != obj)
+obj?.head(add == arr)
+obj?.head(add == b)
+obj?.head(add == div)
+obj?.head(add == f)
+obj?.head(add == obj)
+obj?.head(add == ok)
+obj?.head(add == ok, obj)
+obj?.head(add == s)
+obj?.head(add and true)
+obj?.head(add in arr)
+obj?.head(add in arr, div)
+obj?.head(add in nil)
+obj?.head(add or false)
+obj?.head(add || false)
+obj?.head(add(0, 0))
+obj?.head(add(1, 0))
+obj?.head(add(1, 1))
+obj?.head(add(1, b))
+obj?.head(add(2, a))
+obj?.head(add(a, 0))
+obj?.head(add(b, 0))
+obj?.head(add(b, a))
+obj?.head(add(b, b))
+obj?.head(add)
+obj?.head(add) != arr
+obj?.head(add) != s
+obj?.head(add) == arr
+obj?.head(add) in arr
+obj?.head(add, "a") == div
+obj?.head(add, 0.5 ^ b)
+obj?.head(add, 2 / f)
+obj?.head(add, add)
+obj?.head(add, add, nil) == ok
+obj?.head(add, arr == add)
+obj?.head(add, arr) != s
+obj?.head(add, arr, s) != a
+obj?.head(add, b)
+obj?.head(add, div)
+obj?.head(add, f)
+obj?.head(add, f) != upper("c")
+obj?.head(add, get(b, s))
+obj?.head(add, get(false, obj))
+obj?.head(add, get(ok, b))
+obj?.head(add, obj)
+obj?.head(add, obj?.b)
+obj?.head(add, ok)
+obj?.head(add, s)
+obj?.head(add, string(s))
+obj?.head(all("a", ok))
+obj?.head(all("b", ok))
+obj?.head(all(arr, false))
+obj?.head(all(arr, ok))
+obj?.head(all(obj, false))
+obj?.head(all(s, ok))
+obj?.head(all(s, true))
+obj?.head(any("c", ok))
+obj?.head(any(obj, false))
+obj?.head(any(obj, ok))
+obj?.head(any(obj, ok), 1 == arr, b == 0.5)
+obj?.head(any(obj, true))
+obj?.head(any(s, ok), ok)
+obj?.head(arr != "b")
+obj?.head(arr != "c")
+obj?.head(arr != "c", arr)
+obj?.head(arr != 0.5)
+obj?.head(arr != div)
+obj?.head(arr != nil)
+obj?.head(arr != obj)
+obj?.head(arr != s)
+obj?.head(arr && true, ok and obj)
+obj?.head(arr == 0)
+obj?.head(arr == 0.5)
+obj?.head(arr == 1)
+obj?.head(arr == a)
+obj?.head(arr == add)
+obj?.head(arr == arr)
+obj?.head(arr == b)
+obj?.head(arr == div)
+obj?.head(arr == f)
+obj?.head(arr == nil)
+obj?.head(arr == obj)
+obj?.head(arr == ok)
+obj?.head(arr and false)
+obj?.head(arr)
+obj?.head(arr) != div(a, a)
+obj?.head(arr) != s
+obj?.head(arr) == a ? 1 : b
+obj?.head(arr) == arr
+obj?.head(arr) == obj.b
+obj?.head(arr) == obj?.obj
+obj?.head(arr) == ok
+obj?.head(arr)[-1]
+obj?.head(arr)[0.5 - a]
+obj?.head(arr)[b]
+obj?.head(arr, 0) == ok
+obj?.head(arr, 1 - f, ok)
+obj?.head(arr, a, a)
+obj?.head(arr, a, false) == 2 ? obj : "b"
+obj?.head(arr, add(0, 0), 0 - 0.5)
+obj?.head(arr, add)
+obj?.head(arr, all(obj, false), obj.a)
+obj?.head(arr, all(s, ok))
+obj?.head(arr, arr) in arr
+obj?.head(arr, b)
+obj?.head(arr, b) != a
+obj?.head(arr, b, div) != ok
+obj?.head(arr, div(a, b))
+obj?.head(arr, div)
+obj?.head(arr, filter(obj, false))
+obj?.head(arr, map(arr, obj))
+obj?.head(arr, max(ok))
+obj?.head(arr, none(obj, ok), any(arr, true))
+obj?.head(arr, obj)
+obj?.head(arr, obj?.head(a, 0))
+obj?.head(arr, obj?.head(add, add, 0))
+obj?.head(arr, obj?.obj)
+obj?.head(arr, ok)
+obj?.head(arr, ok)[b]
+obj?.head(arr, one(arr, ok))
+obj?.head(arr, s && true)
+obj?.head(arr, s)
+obj?.head(arr, string(div, 0))
+obj?.head(arr, true) == a
+obj?.head(arr[0.5:0])
+obj?.head(arr[0])
+obj?.head(arr[a])
+obj?.head(arr[a], s)
+obj?.head(arr[b])
+obj?.head(arr[f])
+obj?.head(b != "c")
+obj?.head(b != 0)
+obj?.head(b != 0.5)
+obj?.head(b != a)
+obj?.head(b != a, ok)
+obj?.head(b != add)
+obj?.head(b != arr)
+obj?.head(b != b)
+obj?.head(b != div)
+obj?.head(b != nil)
+obj?.head(b != obj)
+obj?.head(b != obj?.obj)
+obj?.head(b != ok)
+obj?.head(b != s)
+obj?.head(b != true)
+obj?.head(b % 2, f)
+obj?.head(b % a)
+obj?.head(b % a, s in nil)
+obj?.head(b && true)
+obj?.head(b * 0.5)
+obj?.head(b * a)
+obj?.head(b * b)
+obj?.head(b ** b)
+obj?.head(b + 0)
+obj?.head(b + 1)
+obj?.head(b + a)
+obj?.head(b + f)
+obj?.head(b - 0)
+obj?.head(b - 1)
+obj?.head(b - a)
+obj?.head(b - b)
+obj?.head(b - f)
+obj?.head(b .. 0.5)
+obj?.head(b .. 2)
+obj?.head(b .. a)
+obj?.head(b / 0)
+obj?.head(b / f)
+obj?.head(b < 0.5)
+obj?.head(b < 2)
+obj?.head(b < a)
+obj?.head(b < a, arr)
+obj?.head(b < f)
+obj?.head(b <= 0)
+obj?.head(b <= 1)
+obj?.head(b <= b)
+obj?.head(b == "b")
+obj?.head(b == "c")
+obj?.head(b == 0)
+obj?.head(b == 0.5)
+obj?.head(b == arr)
+obj?.head(b == div) != ok
+obj?.head(b == obj)
+obj?.head(b == ok)
+obj?.head(b > f)
+obj?.head(b >= 0)
+obj?.head(b >= 0.5)
+obj?.head(b >= 2)
+obj?.head(b >= b)
+obj?.head(b >= f)
+obj?.head(b ^ 0)
+obj?.head(b ^ b)
+obj?.head(b ^ f)
+obj?.head(b and false)
+obj?.head(b and true)
+obj?.head(b in nil)
+obj?.head(b or true)
+obj?.head(b || false)
+obj?.head(b)
+obj?.head(b) != 1 == ok
+obj?.head(b) % obj?.head(obj, div).a
+obj?.head(b) + 0.5 - b
+obj?.head(b) + b
+obj?.head(b) .. a
+obj?.head(b) / a
+obj?.head(b) <= a
+obj?.head(b) <= f
+obj?.head(b) == -f
+obj?.head(b) == b
+obj?.head(b) == f
+obj?.head(b) > 0 * 2
+obj?.head(b) >= a + b
+obj?.head(b, "a") .. b
+obj?.head(b, 0, b) > b
+obj?.head(b, 1 < f)
+obj?.head(b, 1 > b)
+obj?.head(b, add(b, 1))
+obj?.head(b, add)
+obj?.head(b, arr) - f
+obj?.head(b, arr) == div
+obj?.head(b, arr) == s
+obj?.head(b, arr) ^ b
+obj?.head(b, b > 1)
+obj?.head(b, b)
+obj?.head(b, b) ^ b
+obj?.head(b, b, b - a)
+obj?.head(b, div != ok)
+obj?.head(b, div) <= 0 ^ f
+obj?.head(b, f)
+obj?.head(b, f, a and false)
+obj?.head(b, f, div) <= f
+obj?.head(b, f, f) < obj?.b
+obj?.head(b, false, nil) / (0.5 - f)
+obj?.head(b, first(nil))
+obj?.head(b, get(nil, 0))
+obj?.head(b, get(s, a))
+obj?.head(b, max(arr))
+obj?.head(b, obj)
+obj?.head(b, obj) ** f
+obj?.head(b, obj, ok) .. 0 + a
+obj?.head(b, obj.a)
+obj?.head(b, obj.fn(b))
+obj?.head(b, obj?.obj)
+obj?.head(b, ok && add)
+obj?.head(b, ok ? b : 0)
+obj?.head(b, ok, 0.5) != b
+obj?.head(b, s)
+obj?.head(b, trim(s), b)
+obj?.head(count("a", ok))
+obj?.head(count("b", ok))
+obj?.head(count("c", ok))
+obj?.head(count(arr, ok))
+obj?.head(count(arr, true))
+obj?.head(count(obj, false))
+obj?.head(count(obj, ok))
+obj?.head(count(obj, true))
+obj?.head(count(s, false))
+obj?.head(count(s, ok))
+obj?.head(count(s, true), div, map("c", add))
+obj?.head(div != "c")
+obj?.head(div != 2, obj)
+obj?.head(div != a)
+obj?.head(div != f)
+obj?.head(div != f, div)
+obj?.head(div != s)
+obj?.head(div && false)
+obj?.head(div == "b", arr)
+obj?.head(div == 0)
+obj?.head(div == 2)
+obj?.head(div == a)
+obj?.head(div == arr)
+obj?.head(div == arr, arr)
+obj?.head(div == arr, ok)
+obj?.head(div == div)
+obj?.head(div == f)
+obj?.head(div == nil)
+obj?.head(div == obj)
+obj?.head(div == ok)
+obj?.head(div in arr)
+obj?.head(div or false)
+obj?.head(div || false)
+obj?.head(div(0, 1))
+obj?.head(div(0, 2))
+obj?.head(div(2, a))
+obj?.head(div(a, 1))
+obj?.head(div(a, 2), b)
+obj?.head(div(a, a))
+obj?.head(div(a, b))
+obj?.head(div(b, 1))
+obj?.head(div(b, a))
+obj?.head(div(b, b))
+obj?.head(div)
+obj?.head(div) != add
+obj?.head(div) != arr
+obj?.head(div) != f
+obj?.head(div) != s
+obj?.head(div) == obj
+obj?.head(div, 0, ok) != add
+obj?.head(div, 0.5 .. f)
+obj?.head(div, a == f)
+obj?.head(div, a)
+obj?.head(div, add == nil, get(0, arr))
+obj?.head(div, add)
+obj?.head(div, arr)
+obj?.head(div, arr, ok)
+obj?.head(div, b .. 0)
+obj?.head(div, b)
+obj?.head(div, b, arr) != arr
+obj?.head(div, div)
+obj?.head(div, f)
+obj?.head(div, f, ok) != f ** f
+obj?.head(div, false && "b")
+obj?.head(div, get(b, b))
+obj?.head(div, get(nil, div, nil, ok))
+obj?.head(div, nil) != s
+obj?.head(div, now(f, ok, ok, a), f)
+obj?.head(div, now(ok))
+obj?.head(div, obj)
+obj?.head(div, obj.a, s != 0.5)
+obj?.head(div, obj.head(f))
+obj?.head(div, obj?.a)
+obj?.head(div, ok)
+obj?.head(div, s)
+obj?.head(div, s) == ok ? f : a
+obj?.head(div, s, string(ok))
+obj?.head(f != "c")
+obj?.head(f != 0)
+obj?.head(f != 2)
+obj?.head(f != any(obj, ok))
+obj?.head(f != arr)
+obj?.head(f != b)
+obj?.head(f != div)
+obj?.head(f != f, ok)
+obj?.head(f != false)
+obj?.head(f != obj)
+obj?.head(f != s, b or true)
+obj?.head(f && false)
+obj?.head(f * 0)
+obj?.head(f * 0.5)
+obj?.head(f * 1)
+obj?.head(f * 2)
+obj?.head(f * a)
+obj?.head(f * f)
+obj?.head(f ** 0)
+obj?.head(f ** 2)
+obj?.head(f ** b)
+obj?.head(f ** f)
+obj?.head(f + 0.5)
+obj?.head(f + 1)
+obj?.head(f + f)
+obj?.head(f - 0)
+obj?.head(f - 0.5)
+obj?.head(f - 1)
+obj?.head(f - 2)
+obj?.head(f - b)
+obj?.head(f .. a)
+obj?.head(f .. b)
+obj?.head(f .. f)
+obj?.head(f / 0)
+obj?.head(f / 2)
+obj?.head(f / a)
+obj?.head(f / b)
+obj?.head(f < a)
+obj?.head(f < b)
+obj?.head(f < f)
+obj?.head(f <= 0)
+obj?.head(f <= a)
+obj?.head(f <= a, a)
+obj?.head(f <= f)
+obj?.head(f == add)
+obj?.head(f == arr)
+obj?.head(f == f)
+obj?.head(f == obj)
+obj?.head(f == ok)
+obj?.head(f == s)
+obj?.head(f == true, obj != false)
+obj?.head(f > b)
+obj?.head(f >= 0)
+obj?.head(f >= 0.5)
+obj?.head(f >= b)
+obj?.head(f >= f)
+obj?.head(f ^ 2)
+obj?.head(f ^ a)
+obj?.head(f in arr)
+obj?.head(f in nil)
+obj?.head(f or false)
+obj?.head(f or true)
+obj?.head(f)
+obj?.head(f) * b
+obj?.head(f) ** -f
+obj?.head(f) + obj?.a
+obj?.head(f) - b
+obj?.head(f) / a
+obj?.head(f) <= a
+obj?.head(f) == 0 ^ 0.5
+obj?.head(f) == b != true
+obj?.head(f) == f
+obj?.head(f) > 1 + 1
+obj?.head(f) > a
+obj?.head(f) >= b
+obj?.head(f) >= b ^ b
+obj?.head(f) in arr
+obj?.head(f, 0) <= a - f
+obj?.head(f, 2, arr, false, a) > a
+obj?.head(f, a)
+obj?.head(f, add)
+obj?.head(f, add, f) < add(a, a)
+obj?.head(f, add, obj) - a
+obj?.head(f, arr, 0.5, b) + f
+obj?.head(f, arr, f) + f
+obj?.head(f, b != "a")
+obj?.head(f, b, s, b) ^ obj.a
+obj?.head(f, div == arr)
+obj?.head(f, div)
+obj?.head(f, div, f) ** b
+obj?.head(f, f * b)
+obj?.head(f, f)
+obj?.head(f, f) + -b
+obj?.head(f, f, obj) != f
+obj?.head(f, f, ok, arr) <= f + 0
+obj?.head(f, get(0.5, arr), map(arr, nil))
+obj?.head(f, get(ok, add))
+obj?.head(f, nil) - a
+obj?.head(f, obj != arr)
+obj?.head(f, obj != b)
+obj?.head(f, obj)
+obj?.head(f, obj?.head(b, arr, "c"), b)
+obj?.head(f, ok ? add : b)
+obj?.head(f, ok ? s : 0)
+obj?.head(f, ok and add, string(add))
+obj?.head(f, ok)
+obj?.head(f, s)
+obj?.head(f, true and f)
+obj?.head(f, true || a)
+obj?.head(false != a)
+obj?.head(false != f)
+obj?.head(false != false)
+obj?.head(false != ok)
+obj?.head(false != s)
+obj?.head(false != s, upper(0, "b"), obj)
+obj?.head(false && a, a)
+obj?.head(false && add)
+obj?.head(false && b)
+obj?.head(false && obj)
+obj?.head(false == obj)
+obj?.head(false == s)
+obj?.head(false ? "c" : false)
+obj?.head(false ? a : 0, obj.fn(2))
+obj?.head(false ? a : add)
+obj?.head(false ? a : false)
+obj?.head(false ? add : ok, a ^ b)
+obj?.head(false ? arr : nil)
+obj?.head(false ? nil : 0.5)
+obj?.head(false ? obj : s, obj?.head("c"))
+obj?.head(false ? s : add)
+obj?.head(false ? s : f, div)
+obj?.head(false and "a", b)
+obj?.head(false and "b")
+obj?.head(false and 0.5)
+obj?.head(false and a)
+obj?.head(false and add)
+obj?.head(false and arr)
+obj?.head(false and obj)
+obj?.head(false or add)
+obj?.head(false or arr)
+obj?.head(false or b)
+obj?.head(false or f)
+obj?.head(false or true)
+obj?.head(false || add, arr != "a")
+obj?.head(false || arr)
+obj?.head(false || b)
+obj?.head(false || ok)
+obj?.head(false) == obj
+obj?.head(false) ? 0 % 1 : obj.obj
+obj?.head(false) in arr
+obj?.head(false, 0, b) == s + "a"
+obj?.head(false, 0.5, div) || obj.head(add, obj)
+obj?.head(false, 1) || b > 2
+obj?.head(false, b) == b
+obj?.head(false, b, "a") || obj?.a
+obj?.head(false, obj) in arr
+obj?.head(filter(arr, false))
+obj?.head(filter(arr, ok))
+obj?.head(filter(arr, true))
+obj?.head(filter(s, ok))
+obj?.head(filter(s, true))
+obj?.head(first(0))
+obj?.head(first(0.5, 1, arr, obj, arr))
+obj?.head(first(a), map(arr, add))
+obj?.head(first(a, 0.5))
+obj?.head(first(a, div))
+obj?.head(first(add))
+obj?.head(first(b, div))
+obj?.head(first(b, false, a))
+obj?.head(first(b, nil))
+obj?.head(first(div))
+obj?.head(first(f))
+obj?.head(first(f))?.b
+obj?.head(first(f), f)
+obj?.head(first(f, a), true != nil)
+obj?.head(first(false))
+obj?.head(first(false, nil), a != f)?.a
+obj?.head(first(false, ok))
+obj?.head(first(nil, nil))
+obj?.head(first(obj, 0), b * b)
+obj?.head(first(ok))
+obj?.head(first(ok, arr))
+obj?.head(first(s))
+obj?.head(first(s, b))
+obj?.head(first(s, s), abs(0.5))
+obj?.head(first(true, div, 0))
+obj?.head(float(0))
+obj?.head(float(0.5))
+obj?.head(float(2))
+obj?.head(float(b))
+obj?.head(float(b, 0.5))
+obj?.head(float(f))
+obj?.head(float(f, div, f))
+obj?.head(get("a", "b"))?.b
+obj?.head(get("a", nil))
+obj?.head(get("a", nil), f)
+obj?.head(get("a", ok))
+obj?.head(get("b", a))
+obj?.head(get("b", add))
+obj?.head(get("b", b))
+obj?.head(get("b", div))
+obj?.head(get("b", false))
+obj?.head(get("c", arr), a)
+obj?.head(get(0, 0))
+obj?.head(get(0, 0.5))
+obj?.head(get(0, a))
+obj?.head(get(0, add))
+obj?.head(get(0, arr))
+obj?.head(get(0, b))
+obj?.head(get(0, b), add)
+obj?.head(get(0, f))
+obj?.head(get(0, f), add)
+obj?.head(get(0, nil))
+obj?.head(get(0, obj))?.b
+obj?.head(get(0, ok))
+obj?.head(get(0, ok)?.b)
+obj?.head(get(0.5), get(ok, false))
+obj?.head(get(0.5, 0.5))
+obj?.head(get(0.5, b))
+obj?.head(get(0.5, false))
+obj?.head(get(0.5, nil))
+obj?.head(get(0.5, obj))
+obj?.head(get(0.5, ok))
+obj?.head(get(0.5, s))
+obj?.head(get(0.5, true))
+obj?.head(get(1, 0))
+obj?.head(get(1, a))
+obj?.head(get(1, add))
+obj?.head(get(1, b))
+obj?.head(get(1, nil))
+obj?.head(get(1, obj))
+obj?.head(get(1, ok))
+obj?.head(get(1, s))
+obj?.head(get(1, s), obj.head(nil), div)
+obj?.head(get(2))
+obj?.head(get(2, 0))
+obj?.head(get(2, a))
+obj?.head(get(2, add))
+obj?.head(get(2, div))
+obj?.head(get(a))
+obj?.head(get(a), ok)
+obj?.head(get(a, 0))
+obj?.head(get(a, 2))
+obj?.head(get(a, a))
+obj?.head(get(a, b))
+obj?.head(get(a, b))?.a
+obj?.head(get(a, div))
+obj?.head(get(a, f))
+obj?.head(get(a, false))
+obj?.head(get(a, obj))
+obj?.head(get(a, obj), b in nil)
+obj?.head(get(a, s))
+obj?.head(get(add, 0))
+obj?.head(get(add, 2))
+obj?.head(get(add, arr))
+obj?.head(get(add, b))
+obj?.head(get(add, div))
+obj?.head(get(add, f))
+obj?.head(get(add, false))
+obj?.head(get(add, nil))
+obj?.head(get(add, ok))
+obj?.head(get(add, s))
+obj?.head(get(add, true))
+obj?.head(get(arr))
+obj?.head(get(arr, 0.5))
+obj?.head(get(arr, a))
+obj?.head(get(arr, arr))
+obj?.head(get(arr, div))
+obj?.head(get(arr, false))
+obj?.head(get(arr, nil))
+obj?.head(get(arr, s))
+obj?.head(get(b))
+obj?.head(get(b, 0.5))
+obj?.head(get(b, 1), add)
+obj?.head(get(b, 2))
+obj?.head(get(b, a))
+obj?.head(get(b, arr))
+obj?.head(get(b, b))
+obj?.head(get(b, b), obj)
+obj?.head(get(b, div), obj.obj)
+obj?.head(get(b, nil))
+obj?.head(get(b, obj))
+obj?.head(get(b, ok))
+obj?.head(get(div, 0))
+obj?.head(get(div, 0.5))
+obj?.head(get(div, a))
+obj?.head(get(div, a, nil), ok || div)
+obj?.head(get(div, add))
+obj?.head(get(div, b))
+obj?.head(get(div, div))
+obj?.head(get(div, f))
+obj?.head(get(div, nil))
+obj?.head(get(div, obj))
+obj?.head(get(div, s))
+obj?.head(get(div, s), f == nil)
+obj?.head(get(div, true))
+obj?.head(get(f, 0))
+obj?.head(get(f, 0.5))
+obj?.head(get(f, 1))
+obj?.head(get(f, 2))
+obj?.head(get(f, a))?.a
+obj?.head(get(f, add))
+obj?.head(get(f, b), toBase64("c", ok, f))
+obj?.head(get(f, f))
+obj?.head(get(f, false))
+obj?.head(get(f, nil))
+obj?.head(get(f, ok))
+obj?.head(get(false, 0))
+obj?.head(get(false, 0)?.a)
+obj?.head(get(false, 0.5), s == div)
+obj?.head(get(false, div))
+obj?.head(get(false, nil))
+obj?.head(get(false, ok))
+obj?.head(get(false, s))
+obj?.head(get(nil))
+obj?.head(get(nil, add))
+obj?.head(get(nil, arr))
+obj?.head(get(nil, arr, s))
+obj?.head(get(nil, b), obj?.fn(b))
+obj?.head(get(nil, div))
+obj?.head(get(nil, nil))
+obj?.head(get(nil, nil), ok)
+obj?.head(get(nil, ok))
+obj?.head(get(nil, ok), map("c", add))
+obj?.head(get(nil, ok), ok)
+obj?.head(get(nil, s))
+obj?.head(get(obj)?.fn(ok))
+obj?.head(get(obj, 0))
+obj?.head(get(obj, 0.5))
+obj?.head(get(obj, 2))
+obj?.head(get(obj, a))
+obj?.head(get(obj, add))
+obj?.head(get(obj, arr))
+obj?.head(get(obj, b))
+obj?.head(get(obj, obj))
+obj?.head(get(obj, s))
+obj?.head(get(obj, s)?.obj?.obj)
+obj?.head(get(obj, s, arr))
+obj?.head(get(ok))
+obj?.head(get(ok, a))
+obj?.head(get(ok, add))
+obj?.head(get(ok, arr))
+obj?.head(get(ok, b))
+obj?.head(get(ok, div))
+obj?.head(get(ok, nil))
+obj?.head(get(ok, nil), false and add)
+obj?.head(get(ok, obj))
+obj?.head(get(ok, obj))?.b
+obj?.head(get(ok, obj), s)
+obj?.head(get(ok, s))
+obj?.head(get(ok, true))
+obj?.head(get(s))
+obj?.head(get(s), f == a)
+obj?.head(get(s)?.a)
+obj?.head(get(s, 1))
+obj?.head(get(s, 2), add)
+obj?.head(get(s, a))
+obj?.head(get(s, a, true))
+obj?.head(get(s, add))
+obj?.head(get(s, arr))
+obj?.head(get(s, arr), get(arr, arr))
+obj?.head(get(s, b))
+obj?.head(get(s, div))
+obj?.head(get(s, div), a, a)
+obj?.head(get(s, f))
+obj?.head(get(s, nil))
+obj?.head(get(s, obj))?.b
+obj?.head(get(s, ok))
+obj?.head(get(s, ok))?.a
+obj?.head(get(s, s))
+obj?.head(get(s, true))
+obj?.head(get(s, true), obj)
+obj?.head(get(true, 0.5), arr)
+obj?.head(get(true, a))
+obj?.head(get(true, add))
+obj?.head(get(true, div))
+obj?.head(get(true, div), any("b", false))
+obj?.head(get(true, f))
+obj?.head(get(true, false))
+obj?.head(get(true, s))
+obj?.head(int("b", a))
+obj?.head(int(2))
+obj?.head(int(a))
+obj?.head(int(b))
+obj?.head(int(f))
+obj?.head(int(false, s, false, a))
+obj?.head(last(0))
+obj?.head(last(0.5))
+obj?.head(last(0.5, add))
+obj?.head(last(0.5, b, f, "b"))
+obj?.head(last(1, true, a, s))
+obj?.head(last(a))
+obj?.head(last(a, false, f, "a"))
+obj?.head(last(add))
+obj?.head(last(arr, arr))
+obj?.head(last(b))
+obj?.head(last(b, add, ok, 2))
+obj?.head(last(div))
+obj?.head(last(div, b))
+obj?.head(last(f))
+obj?.head(last(f, arr, arr))
+obj?.head(last(obj))
+obj?.head(last(obj, "c", a, ok))
+obj?.head(last(ok))
+obj?.head(last(ok, ok))
+obj?.head(last(s))
+obj?.head(len("a"))
+obj?.head(len(add, "a"))
+obj?.head(len(arr))
+obj?.head(len(arr), arr)
+obj?.head(len(false, div, obj))
+obj?.head(len(obj, "c"))
+obj?.head(lower("a"))
+obj?.head(lower("b"))
+obj?.head(lower(arr, s))
+obj?.head(lower(false, true, s))
+obj?.head(lower(s))
+obj?.head(map("a", "a"))
+obj?.head(map("a", "b"))
+obj?.head(map("a", 0))
+obj?.head(map("a", 2))
+obj?.head(map("a", a), obj.head(a))
+obj?.head(map("a", add), s, get(arr, b))
+obj?.head(map("a", arr))
+obj?.head(map("a", div))
+obj?.head(map("a", f))
+obj?.head(map("b", add))
+obj?.head(map("b", f))
+obj?.head(map("b", nil))
+obj?.head(map("b", ok), add)
+obj?.head(map("c", 0.5))
+obj?.head(map("c", div), b)
+obj?.head(map("c", nil), get(s))
+obj?.head(map("c", obj))
+obj?.head(map("c", s))
+obj?.head(map(arr, "a"))
+obj?.head(map(arr, "b"))
+obj?.head(map(arr, 0))
+obj?.head(map(arr, 0.5))
+obj?.head(map(arr, arr))
+obj?.head(map(arr, b))
+obj?.head(map(arr, div))
+obj?.head(map(arr, f))
+obj?.head(map(arr, false))
+obj?.head(map(arr, false), f)
+obj?.head(map(arr, nil))
+obj?.head(map(arr, obj))
+obj?.head(map(arr, ok))
+obj?.head(map(arr, s))
+obj?.head(map(arr, true))
+obj?.head(map(obj, 0.5))
+obj?.head(map(obj, 1), add == f)
+obj?.head(map(obj, add))
+obj?.head(map(obj, arr))
+obj?.head(map(obj, b))
+obj?.head(map(obj, b), get(nil, ok), arr)
+obj?.head(map(obj, b), obj)
+obj?.head(map(obj, div))
+obj?.head(map(obj, f))
+obj?.head(map(obj, nil), ok || true)
+obj?.head(map(obj, obj))
+obj?.head(map(obj, obj), obj.b)
+obj?.head(map(obj, ok))
+obj?.head(map(obj, s))
+obj?.head(map(obj.obj, a or false))
+obj?.head(map(s, #))
+obj?.head(map(s, 0))
+obj?.head(map(s, 0.5))
+obj?.head(map(s, 1))
+obj?.head(map(s, 2), arr)
+obj?.head(map(s, a))
+obj?.head(map(s, add))
+obj?.head(map(s, arr))
+obj?.head(map(s, div))
+obj?.head(map(s, f))
+obj?.head(map(s, nil), add(a, a))
+obj?.head(map(s, obj), f, b + 2)
+obj?.head(map(s, ok))
+obj?.head(map(s, ok), 0 ** f)
+obj?.head(map(s, s))
+obj?.head(max("a"))
+obj?.head(max("b"))
+obj?.head(max("c"))
+obj?.head(max(1, b))
+obj?.head(max(b, b))
+obj?.head(max(div))
+obj?.head(max(f != 0))
+obj?.head(max(false))
+obj?.head(max(get(ok, b)))
+obj?.head(max(obj)?.obj)
+obj?.head(max(ok))
+obj?.head(max(s))
+obj?.head(min("a"))
+obj?.head(min("c"), arr)
+obj?.head(min(0))
+obj?.head(min(a))
+obj?.head(min(add))
+obj?.head(min(arr))
+obj?.head(min(b))
+obj?.head(min(f))
+obj?.head(min(nil))
+obj?.head(min(nil, 1), 0 / f)
+obj?.head(min(ok))
+obj?.head(min(ok), arr, f)
+obj?.head(min(s, s), f)
+obj?.head(nil != 0)
+obj?.head(nil != 0.5)
+obj?.head(nil != 1)
+obj?.head(nil != 2)
+obj?.head(nil != a)
+obj?.head(nil != add, obj.fn(b))
+obj?.head(nil != arr)
+obj?.head(nil != b, "b" != 0)
+obj?.head(nil != false)
+obj?.head(nil != nil)
+obj?.head(nil != obj)
+obj?.head(nil != ok)
+obj?.head(nil != true)
+obj?.head(nil == "b") or add(a, 0) - obj.b
+obj?.head(nil == "c" || add == f)
+obj?.head(nil == arr)
+obj?.head(nil == div)
+obj?.head(nil == nil)
+obj?.head(nil == obj)
+obj?.head(nil == ok)
+obj?.head(nil == s)
+obj?.head(nil in arr)
+obj?.head(nil || false)
+obj?.head(nil || true)
+obj?.head(nil) != add
+obj?.head(nil) != arr
+obj?.head(nil) != div
+obj?.head(nil) != f
+obj?.head(nil) == 2 + a
+obj?.head(nil) == add
+obj?.head(nil) == map(arr, "b")
+obj?.head(nil) == obj.obj
+obj?.head(nil) in obj
+obj?.head(nil) in obj?.obj
+obj?.head(nil)?.a
+obj?.head(nil)?.a.b
+obj?.head(nil)?.a?.b
+obj?.head(nil)?.b
+obj?.head(nil)?.b.a
+obj?.head(nil)?.b.obj
+obj?.head(nil)?.b?.obj
+obj?.head(nil)?.fn(obj.obj)
+obj?.head(nil)?.fn(s, "b" != f)
+obj?.head(nil)?.head(ok)
+obj?.head(nil)?.obj
+obj?.head(nil)?.obj?.a
+obj?.head(nil)?.obj?.b
+obj?.head(nil, "a")?.obj
+obj?.head(nil, "b")?.b
+obj?.head(nil, "b", obj)?.b
+obj?.head(nil, "b", s)?.b
+obj?.head(nil, "b", s, f)?.obj
+obj?.head(nil, "c")?.obj
+obj?.head(nil, "c", 0.5)?.obj
+obj?.head(nil, "c", f)?.a
+obj?.head(nil, 0)?.a
+obj?.head(nil, 0)?.b
+obj?.head(nil, 0)?.obj
+obj?.head(nil, 0, b, s)?.a
+obj?.head(nil, 0.5, 0, s)?.b
+obj?.head(nil, 1)?.b
+obj?.head(nil, 1)?.obj
+obj?.head(nil, 1, false)?.a
+obj?.head(nil, 1, nil)?.obj
+obj?.head(nil, 2)?.b
+obj?.head(nil, 2)?.obj
+obj?.head(nil, 2, 0, nil)?.a
+obj?.head(nil, a) != s ? add : obj?.b
+obj?.head(nil, a) == s
+obj?.head(nil, a)?.a
+obj?.head(nil, a)?.obj
+obj?.head(nil, a, 0.5, a)?.a
+obj?.head(nil, a, 0.5, add, false)?.b
+obj?.head(nil, a, add)?.a
+obj?.head(nil, a, ok, nil)?.obj
+obj?.head(nil, a, s)?.b
+obj?.head(nil, add)?.a
+obj?.head(nil, add)?.obj
+obj?.head(nil, add, "b")?.obj
+obj?.head(nil, add, b)?.obj.obj
+obj?.head(nil, add, false)?.a
+obj?.head(nil, add, false)?.b
+obj?.head(nil, add, nil, add)?.obj
+obj?.head(nil, arr)?.a
+obj?.head(nil, arr)?.b
+obj?.head(nil, arr)?.obj
+obj?.head(nil, arr, "a")?.obj
+obj?.head(nil, arr, "c")?.b
+obj?.head(nil, arr, 1)?.b
+obj?.head(nil, arr, s)?.a
+obj?.head(nil, b)?.a
+obj?.head(nil, b)?.b
+obj?.head(nil, b)?.obj
+obj?.head(nil, b, a, ok, ok)?.b
+obj?.head(nil, b, add)?.a
+obj?.head(nil, b, b)?.b
+obj?.head(nil, b, false)?.a
+obj?.head(nil, b, s)?.a
+obj?.head(nil, div)?.a
+obj?.head(nil, div)?.obj
+obj?.head(nil, div, arr)?.b
+obj?.head(nil, f)?.b
+obj?.head(nil, f)?.obj
+obj?.head(nil, f, add, add)?.b
+obj?.head(nil, f, nil)?.a
+obj?.head(nil, f, s)?.a
+obj?.head(nil, false)?.a
+obj?.head(nil, false)?.obj
+obj?.head(nil, false, s)?.a
+obj?.head(nil, nil)?.a
+obj?.head(nil, nil, 0.5)?.obj
+obj?.head(nil, nil, add)?.b
+obj?.head(nil, nil, add, arr)?.obj
+obj?.head(nil, nil, ok)?.obj
+obj?.head(nil, obj) in obj
+obj?.head(nil, obj)?.a
+obj?.head(nil, obj)?.b
+obj?.head(nil, obj)?.b.a
+obj?.head(nil, obj)?.obj
+obj?.head(nil, ok)?.a
+obj?.head(nil, ok)?.b
+obj?.head(nil, ok)?.obj
+obj?.head(nil, ok, "b")?.b
+obj?.head(nil, ok, 0.5)?.a
+obj?.head(nil, ok, arr)?.b
+obj?.head(nil, ok, div, arr, obj)?.obj
+obj?.head(nil, ok, nil, ok)?.obj
+obj?.head(nil, ok, s, 1, true)?.obj.a
+obj?.head(nil, s)?.a
+obj?.head(nil, s)?.obj
+obj?.head(nil, s, 0.5)?.obj
+obj?.head(nil, s, a)?.obj
+obj?.head(nil, s, false, s)?.a
+obj?.head(nil, s, s)?.b
+obj?.head(nil, true)?.a
+obj?.head(nil, true)?.head(f, arr)
+obj?.head(nil, true)?.obj
+obj?.head(none("b", true), s == f)
+obj?.head(none("c", false))
+obj?.head(none("c", ok))
+obj?.head(none("c", true))
+obj?.head(none(arr, ok), get(nil, 1), now(div, "a", s, div, f), a)
+obj?.head(none(obj, false))
+obj?.head(none(obj, ok))
+obj?.head(none(s, false))
+obj?.head(not false)
+obj?.head(not ok)
+obj?.head(not true)
+obj?.head(now(0, s))
+obj?.head(now(0, s), f + b)
+obj?.head(now(0.5), arr, obj.a)
+obj?.head(now(1))
+obj?.head(now(a))
+obj?.head(now(a, a, a))
+obj?.head(now(arr))
+obj?.head(now(b, b))
+obj?.head(now(b, div, f))
+obj?.head(now(b, s))
+obj?.head(now(div))
+obj?.head(now(div, div, "b", obj, 1))
+obj?.head(now(f, add))
+obj?.head(now(false))
+obj?.head(now(nil))
+obj?.head(now(nil, obj))
+obj?.head(now(obj), 0 == 1)
+obj?.head(now(obj, 0))
+obj?.head(now(ok))
+obj?.head(now(ok, arr))
+obj?.head(now(ok, b))
+obj?.head(now(ok, b, arr, nil))
+obj?.head(now(ok, f), true == 0.5)
+obj?.head(now(ok, true, a))
+obj?.head(now(s))
+obj?.head(now(s, b, s), "a" startsWith s)
+obj?.head(now(s, nil))
+obj?.head(now(true))
+obj?.head(now(true, "b", add))
+obj?.head(obj != "a")
+obj?.head(obj != 0)
+obj?.head(obj != 0.5)
+obj?.head(obj != add)
+obj?.head(obj != nil)
+obj?.head(obj != s)
+obj?.head(obj && true)
+obj?.head(obj == 0.5)
+obj?.head(obj == 1)
+obj?.head(obj == a)
+obj?.head(obj == div)
+obj?.head(obj == f, now(1))
+obj?.head(obj == false)
+obj?.head(obj == obj)
+obj?.head(obj == ok)
+obj?.head(obj and true, 2 .. b)
+obj?.head(obj in arr)
+obj?.head(obj in nil)
+obj?.head(obj or true)
+obj?.head(obj)
+obj?.head(obj) != a ** 0.5
+obj?.head(obj) != a ? obj : s
+obj?.head(obj) != div
+obj?.head(obj) != map(arr, s)
+obj?.head(obj) != ok
+obj?.head(obj) != s
+obj?.head(obj) == add
+obj?.head(obj) == div
+obj?.head(obj) == f
+obj?.head(obj) == s
+obj?.head(obj) in arr
+obj?.head(obj).a
+obj?.head(obj).b
+obj?.head(obj).head(b)
+obj?.head(obj).head(get(div, f))
+obj?.head(obj).obj
+obj?.head(obj).obj.obj
+obj?.head(obj).obj?.a
+obj?.head(obj).obj?.b
+obj?.head(obj)?.a
+obj?.head(obj)?.b
+obj?.head(obj)?.head(0 <= f)
+obj?.head(obj)?.head(a)
+obj?.head(obj)?.head(add)
+obj?.head(obj)?.obj
+obj?.head(obj)?.obj.obj
+obj?.head(obj)[s]
+obj?.head(obj, "a").b
+obj?.head(obj, "a").obj
+obj?.head(obj, "a")?.a
+obj?.head(obj, "a")?.obj
+obj?.head(obj, "a", arr, obj)?.head(obj == s)
+obj?.head(obj, "b").a
+obj?.head(obj, "b").b
+obj?.head(obj, "b", nil).b
+obj?.head(obj, "c").b
+obj?.head(obj, "c")?.a
+obj?.head(obj, "c")?.obj
+obj?.head(obj, 0 > a)
+obj?.head(obj, 0).a
+obj?.head(obj, 0).b
+obj?.head(obj, 0).obj
+obj?.head(obj, 0)?.a
+obj?.head(obj, 0)?.b
+obj?.head(obj, 0, add).b
+obj?.head(obj, 0.5).a
+obj?.head(obj, 0.5).obj
+obj?.head(obj, 0.5)[s]
+obj?.head(obj, 0.5, div)?.b
+obj?.head(obj, 0.5, nil).b
+obj?.head(obj, 1).b
+obj?.head(obj, 1, 0).obj
+obj?.head(obj, 1, 0)?.head(add)
+obj?.head(obj, 1, ok)?.b
+obj?.head(obj, 2).a
+obj?.head(obj, 2).obj
+obj?.head(obj, 2)?.obj
+obj?.head(obj, 2, true).a
+obj?.head(obj, a <= a)
+obj?.head(obj, a)
+obj?.head(obj, a).a
+obj?.head(obj, a).b
+obj?.head(obj, a).obj
+obj?.head(obj, a)?.a
+obj?.head(obj, a)?.b
+obj?.head(obj, a)?.obj
+obj?.head(obj, a, "c").a
+obj?.head(obj, a, 1, add, s)?.obj
+obj?.head(obj, a, 2, obj).obj
+obj?.head(obj, a, a).a
+obj?.head(obj, a, add, "b").b
+obj?.head(obj, a, b)?.b * b
+obj?.head(obj, a, f, b, a)?.b
+obj?.head(obj, a, obj, 0.5).obj?.b
+obj?.head(obj, a, ok, 1).obj?.a
+obj?.head(obj, a, ok, add).b
+obj?.head(obj, a, s)?.obj
+obj?.head(obj, a, s, ok).b
+obj?.head(obj, a, true)?.b
+obj?.head(obj, add == ok)
+obj?.head(obj, add)
+obj?.head(obj, add).b
+obj?.head(obj, add).obj
+obj?.head(obj, add)?.a
+obj?.head(obj, add)?.b
+obj?.head(obj, add)?.obj
+obj?.head(obj, add, nil).b
+obj?.head(obj, add, s).a
+obj?.head(obj, arr).a
+obj?.head(obj, arr).a == ok
+obj?.head(obj, arr).b
+obj?.head(obj, arr).obj
+obj?.head(obj, arr)?.b
+obj?.head(obj, arr)?.obj
+obj?.head(obj, arr, 0).b
+obj?.head(obj, arr, a, b, s)?.a
+obj?.head(obj, arr, f).b
+obj?.head(obj, arr, f)?.b
+obj?.head(obj, arr, nil).a
+obj?.head(obj, arr, nil).b
+obj?.head(obj, b)
+obj?.head(obj, b).obj
+obj?.head(obj, b)?.a
+obj?.head(obj, b)?.b
+obj?.head(obj, b)?.obj
+obj?.head(obj, b, "a")?.obj
+obj?.head(obj, b, 0.5).b
+obj?.head(obj, b, b).obj
+obj?.head(obj, b, div)?.b
+obj?.head(obj, b, f).obj
+obj?.head(obj, b, false, s)?.b
+obj?.head(obj, b, nil, arr, true).a
+obj?.head(obj, b, obj)?.b
+obj?.head(obj, b, obj)?.obj
+obj?.head(obj, b, ok).obj
+obj?.head(obj, b, s).obj
+obj?.head(obj, div != a)
+obj?.head(obj, div)
+obj?.head(obj, div).a
+obj?.head(obj, div).head(add)
+obj?.head(obj, div).obj
+obj?.head(obj, div)?.a
+obj?.head(obj, div)?.b
+obj?.head(obj, div)?.fn(-b)
+obj?.head(obj, div, "b")?.a
+obj?.head(obj, div, "b", 0, "b").obj
+obj?.head(obj, div, 0).b
+obj?.head(obj, div, 0)?.a
+obj?.head(obj, div, 1, false, b).a
+obj?.head(obj, div, f).obj
+obj?.head(obj, div, nil).a
+obj?.head(obj, div, nil).obj
+obj?.head(obj, div, obj.b)
+obj?.head(obj, div, ok).b
+obj?.head(obj, div, ok, nil).a
+obj?.head(obj, div, true, a)?.b
+obj?.head(obj, f * b)
+obj?.head(obj, f)
+obj?.head(obj, f) != obj?.head(arr, div)
+obj?.head(obj, f) == b
+obj?.head(obj, f).b
+obj?.head(obj, f).obj
+obj?.head(obj, f)?.b
+obj?.head(obj, f)?.obj
+obj?.head(obj, f, a).a
+obj?.head(obj, f, a, f).a
+obj?.head(obj, f, div).obj
+obj?.head(obj, f, f)?.b
+obj?.head(obj, f, false, b).b
+obj?.head(obj, f, obj).a
+obj?.head(obj, f, obj)?.obj?.b
+obj?.head(obj, f, ok, obj.a)
+obj?.head(obj, f, true).a
+obj?.head(obj, false).a
+obj?.head(obj, false).b
+obj?.head(obj, false)?.b
+obj?.head(obj, false, obj)?.obj
+obj?.head(obj, false, ok)?.obj
+obj?.head(obj, filter(arr, ok), arr)
+obj?.head(obj, first(0.5), f).obj
+obj?.head(obj, get(0.5), 0.5 ^ a)
+obj?.head(obj, get(a, obj))
+obj?.head(obj, get(add, add), add)
+obj?.head(obj, get(div, 0))
+obj?.head(obj, nil).a
+obj?.head(obj, nil).obj
+obj?.head(obj, nil)?.b
+obj?.head(obj, nil, 1, s, obj).b
+obj?.head(obj, nil, a).b
+obj?.head(obj, nil, add, obj).obj?.b
+obj?.head(obj, nil, b, a)?.obj
+obj?.head(obj, nil, f).obj
+obj?.head(obj, obj)
+obj?.head(obj, obj).a
+obj?.head(obj, obj).head(add)
+obj?.head(obj, obj)?.a
+obj?.head(obj, obj)?.b
+obj?.head(obj, obj)?.obj
+obj?.head(obj, obj, 0)?.b
+obj?.head(obj, obj, a, "a", a)?.b
+obj?.head(obj, obj, arr).a
+obj?.head(obj, obj, b)?.a
+obj?.head(obj, obj, false, f, 1).obj
+obj?.head(obj, obj, nil, true)?.obj
+obj?.head(obj, obj.b)
+obj?.head(obj, obj.fn(b))
+obj?.head(obj, obj?.head(f)).b
+obj?.head(obj, obj?.obj)
+obj?.head(obj, ok == arr)?.b
+obj?.head(obj, ok)
+obj?.head(obj, ok).obj
+obj?.head(obj, ok)?.a
+obj?.head(obj, ok)?.b
+obj?.head(obj, ok)?.obj
+obj?.head(obj, ok, 0.5).obj
+obj?.head(obj, ok, a).b
+obj?.head(obj, ok, a, "b")?.obj
+obj?.head(obj, ok, a, div, 0.5).a
+obj?.head(obj, ok, a, true)?.a
+obj?.head(obj, ok, b).obj
+obj?.head(obj, ok, f).obj
+obj?.head(obj, ok, false, f, div)?.obj
+obj?.head(obj, ok, nil)?.b
+obj?.head(obj, ok, obj).a
+obj?.head(obj, s)
+obj?.head(obj, s).a
+obj?.head(obj, s).obj
+obj?.head(obj, s).obj.a
+obj?.head(obj, s)?.head(get(b, a)?.obj)
+obj?.head(obj, s, 0, 0)?.obj
+obj?.head(obj, s, a, a, ok).b
+obj?.head(obj, s, add)
+obj?.head(obj, s, add, obj)?.a
+obj?.head(obj, s, f, a, b)?.b
+obj?.head(obj, s, nil, s)?.a
+obj?.head(obj, s, s, a, 2).b
+obj?.head(obj, s[2])
+obj?.head(obj, string(a))
+obj?.head(obj, true).a
+obj?.head(obj, true)?.a
+obj?.head(obj, true)?.b
+obj?.head(obj, true, 1, arr)?.b
+obj?.head(obj, true, div, obj)?.b
+obj?.head(obj, true, nil).obj
+obj?.head(obj.a)
+obj?.head(obj.a, add)
+obj?.head(obj.a, get(a, add))
+obj?.head(obj.b)
+obj?.head(obj.b, get(a, 2))
+obj?.head(obj.b, obj.head(ok, 0, add, 0.5, add))
+obj?.head(obj.b, string("a"))
+obj?.head(obj.fn(2))
+obj?.head(obj.fn(a))
+obj?.head(obj.head("c", "c"), map(obj, true))
+obj?.head(obj.head(0))
+obj?.head(obj.head(0, false, s))
+obj?.head(obj.head(0.5, true))
+obj?.head(obj.head(2))
+obj?.head(obj.head(add))
+obj?.head(obj.head(arr))
+obj?.head(obj.head(arr, add))
+obj?.head(obj.head(arr, div))
+obj?.head(obj.head(b))
+obj?.head(obj.head(b), b, 0 == add)
+obj?.head(obj.head(b, 0.5, a))
+obj?.head(obj.head(div))
+obj?.head(obj.head(div, div))
+obj?.head(obj.head(f))
+obj?.head(obj.head(false, b, f, b, a))
+obj?.head(obj.head(obj))
+obj?.head(obj.head(ok))
+obj?.head(obj.head(ok, nil, f))
+obj?.head(obj.head(s, a, add, add, add))
+obj?.head(obj.head(s, ok))
+obj?.head(obj.head(true))
+obj?.head(obj.obj)
+obj?.head(obj.obj).b
+obj?.head(obj.obj)?.b
+obj?.head(obj.obj, f)
+obj?.head(obj.obj, get(add, 0))
+obj?.head(obj.obj, obj)
+obj?.head(obj.obj, ok)
+obj?.head(obj?.a)
+obj?.head(obj?.a, div)
+obj?.head(obj?.a, obj)
+obj?.head(obj?.a, obj.a)
+obj?.head(obj?.a, ok or false)
+obj?.head(obj?.a, s)
+obj?.head(obj?.b)
+obj?.head(obj?.b, "c" <= s)
+obj?.head(obj?.b, f)
+obj?.head(obj?.b, filter(arr, ok))
+obj?.head(obj?.fn(a), b)
+obj?.head(obj?.fn(b))
+obj?.head(obj?.head("a"))
+obj?.head(obj?.head(0))
+obj?.head(obj?.head(0.5))
+obj?.head(obj?.head(1))
+obj?.head(obj?.head(a))
+obj?.head(obj?.head(a, arr))
+obj?.head(obj?.head(a, ok, obj, add))
+obj?.head(obj?.head(add))
+obj?.head(obj?.head(add, add))
+obj?.head(obj?.head(add, false))
+obj?.head(obj?.head(arr, nil))
+obj?.head(obj?.head(b))
+obj?.head(obj?.head(b, a))
+obj?.head(obj?.head(b, a, div))
+obj?.head(obj?.head(b, false))
+obj?.head(obj?.head(b, s))
+obj?.head(obj?.head(f, a, 1))
+obj?.head(obj?.head(false))
+obj?.head(obj?.head(false, "c"))
+obj?.head(obj?.head(obj))
+obj?.head(obj?.head(obj)).obj
+obj?.head(obj?.head(obj, 0))
+obj?.head(obj?.head(ok))
+obj?.head(obj?.head(ok), div)
+obj?.head(obj?.head(ok, 0))
+obj?.head(obj?.head(ok, 0, add), obj?.a)
+obj?.head(obj?.head(s))
+obj?.head(obj?.head(s, arr, 0.5))
+obj?.head(obj?.head(s, arr, true))
+obj?.head(obj?.head(s, nil, 0))
+obj?.head(obj?.head(s, true))
+obj?.head(obj?.obj)
+obj?.head(obj?.obj).obj
+obj?.head(obj?.obj)?.obj
+obj?.head(obj?.obj, a)
+obj?.head(obj?.obj, map(obj, ok))
+obj?.head(obj[nil])
+obj?.head(obj[s])
+obj?.head(ok != "c", b)
+obj?.head(ok != a)
+obj?.head(ok != arr)
+obj?.head(ok != b)
+obj?.head(ok != div)
+obj?.head(ok != f)
+obj?.head(ok != false)
+obj?.head(ok != obj)
+obj?.head(ok != s, get(s, 1), add)
+obj?.head(ok && "a")
+obj?.head(ok && 0)
+obj?.head(ok && 1 % b)
+obj?.head(ok && a)
+obj?.head(ok && a, obj != f)
+obj?.head(ok && arr)
+obj?.head(ok && f)
+obj?.head(ok && obj)
+obj?.head(ok && ok)
+obj?.head(ok == 0)
+obj?.head(ok == 0, f)
+obj?.head(ok == 1, add == obj)
+obj?.head(ok == 2)
+obj?.head(ok == a)
+obj?.head(ok == b)
+obj?.head(ok == div)
+obj?.head(ok == div, f)
+obj?.head(ok == obj)
+obj?.head(ok == ok)
+obj?.head(ok == s)
+obj?.head(ok == true)
+obj?.head(ok ? "b" : add)
+obj?.head(ok ? "c" : "b")
+obj?.head(ok ? 1 : arr)
+obj?.head(ok ? 1 : div.b)
+obj?.head(ok ? a : "c")
+obj?.head(ok ? a : f)
+obj?.head(ok ? a : obj, add)
+obj?.head(ok ? add : div)
+obj?.head(ok ? add : obj, s, obj.head(a, obj))
+obj?.head(ok ? arr : div)
+obj?.head(ok ? arr : nil)
+obj?.head(ok ? b : 0.5)
+obj?.head(ok ? b : b)
+obj?.head(ok ? b : nil && div)
+obj?.head(ok ? div : 0.5)
+obj?.head(ok ? div : arr)
+obj?.head(ok ? div : nil)
+obj?.head(ok ? f : 1)
+obj?.head(ok ? false : ok)
+obj?.head(ok ? nil : 0.5)
+obj?.head(ok ? nil : arr)
+obj?.head(ok ? nil : b, obj?.b)
+obj?.head(ok ? nil : f, arr)
+obj?.head(ok ? nil : ok)
+obj?.head(ok ? obj : add)
+obj?.head(ok ? obj : b)
+obj?.head(ok ? obj : s)
+obj?.head(ok ? ok : arr)
+obj?.head(ok ? true : add)
+obj?.head(ok and "a")
+obj?.head(ok and a, last(0.5))
+obj?.head(ok and add)
+obj?.head(ok and b)
+obj?.head(ok and div, get(0, arr))
+obj?.head(ok and f)
+obj?.head(ok and nil, f)?.obj
+obj?.head(ok and obj)
+obj?.head(ok and obj).obj
+obj?.head(ok and ok)
+obj?.head(ok and s)
+obj?.head(ok in arr)
+obj?.head(ok or "a")
+obj?.head(ok or "c")
+obj?.head(ok or 2)
+obj?.head(ok or a)
+obj?.head(ok or add)
+obj?.head(ok or arr)
+obj?.head(ok or div)
+obj?.head(ok or get(div >= b, arr?.head("b")))
+obj?.head(ok or nil)
+obj?.head(ok or obj)
+obj?.head(ok or true, a)
+obj?.head(ok || 0)
+obj?.head(ok || 0, f)
+obj?.head(ok || a)
+obj?.head(ok || add)
+obj?.head(ok || arr.obj in map("b" / a, min(f)).obj)
+obj?.head(ok || b || add.fn(0.5, obj))
+obj?.head(ok || div)
+obj?.head(ok || div, 1 != add)
+obj?.head(ok || s)
+obj?.head(ok)
+obj?.head(ok) != a
+obj?.head(ok) != f
+obj?.head(ok) != obj?.a
+obj?.head(ok) != obj?.b
+obj?.head(ok) && not ok
+obj?.head(ok) && ok
+obj?.head(ok) == a
+obj?.head(ok) == obj.obj
+obj?.head(ok) == ok
+obj?.head(ok) ? s : arr
+obj?.head(ok) and 0 == nil
+obj?.head(ok) and 0.5 != a
+obj?.head(ok) or ok
+obj?.head(ok) || obj?.a?.head(b <= a ? s : a / a || lastIndexOf(2) % (arr matches 0.5))
+obj?.head(ok, "a" contains "b")
+obj?.head(ok, 2) == keys(obj)
+obj?.head(ok, a)
+obj?.head(ok, add != a)
+obj?.head(ok, arr)
+obj?.head(ok, b)
+obj?.head(ok, div)
+obj?.head(ok, f)
+obj?.head(ok, f) == s
+obj?.head(ok, f, b)
+obj?.head(ok, false or ok)
+obj?.head(ok, false) or ok
+obj?.head(ok, map(arr, false))
+obj?.head(ok, none(s, false))
+obj?.head(ok, not ok)
+obj?.head(ok, obj)
+obj?.head(ok, obj) != add ? b : nil
+obj?.head(ok, obj.head(s), obj)
+obj?.head(ok, obj?.obj)
+obj?.head(ok, ok or 0.5)
+obj?.head(ok, s)
+obj?.head(ok, s, ok, 0.5) == obj
+obj?.head(ok, s, s) == a
+obj?.head(one("a", ok))
+obj?.head(one("b", true))
+obj?.head(one(arr, false))
+obj?.head(one(arr, ok))
+obj?.head(one(arr, ok), ok)
+obj?.head(one(arr, true))
+obj?.head(one(obj, false))
+obj?.head(one(obj, ok))
+obj?.head(one(obj, true))
+obj?.head(one(s, # < #))
+obj?.head(one(s, ok))
+obj?.head(one(s, true))
+obj?.head(s != "a", f)
+obj?.head(s != "b")
+obj?.head(s != 0)
+obj?.head(s != 1)
+obj?.head(s != 2)
+obj?.head(s != 2, obj)
+obj?.head(s != a)
+obj?.head(s != add)
+obj?.head(s != arr)
+obj?.head(s != b)
+obj?.head(s != div)
+obj?.head(s != f)
+obj?.head(s != nil)
+obj?.head(s != obj)
+obj?.head(s != ok)
+obj?.head(s + s)
+obj?.head(s <= "b")
+obj?.head(s <= s)
+obj?.head(s == "b")
+obj?.head(s == "c")
+obj?.head(s == 0)
+obj?.head(s == 2)
+obj?.head(s == a)
+obj?.head(s == add)
+obj?.head(s == arr)
+obj?.head(s == f)
+obj?.head(s == false)
+obj?.head(s == obj)
+obj?.head(s == ok)
+obj?.head(s == s)
+obj?.head(s == true)
+obj?.head(s > s)
+obj?.head(s >= s)
+obj?.head(s and false)
+obj?.head(s contains "a")
+obj?.head(s contains s, add != 0.5)
+obj?.head(s endsWith "a")
+obj?.head(s endsWith s)
+obj?.head(s in arr)
+obj?.head(s in obj)
+obj?.head(s matches s, ok or ok)
+obj?.head(s or false)
+obj?.head(s startsWith "b")
+obj?.head(s startsWith s)
+obj?.head(s)
+obj?.head(s) != div
+obj?.head(s) != obj.a
+obj?.head(s) == arr
+obj?.head(s) == ok
+obj?.head(s) endsWith string(0.5)
+obj?.head(s)[a]
+obj?.head(s, "a") != s
+obj?.head(s, "b" == a)
+obj?.head(s, "b", 0.5) == div
+obj?.head(s, a % a)
+obj?.head(s, a)
+obj?.head(s, add)
+obj?.head(s, add, nil, arr) != f
+obj?.head(s, arr)
+obj?.head(s, arr) == f
+obj?.head(s, arr) == ok
+obj?.head(s, arr, div)
+obj?.head(s, b == add)
+obj?.head(s, div)
+obj?.head(s, f)
+obj?.head(s, get(0, div))
+obj?.head(s, get(f, obj))
+obj?.head(s, nil) != ok
+obj?.head(s, nil, add)[2 + 0]
+obj?.head(s, nil, ok, f)[a]
+obj?.head(s, none(s, ok))
+obj?.head(s, now(0.5, f, ok))
+obj?.head(s, obj.obj)
+obj?.head(s, ok in nil)
+obj?.head(s, ok)
+obj?.head(s, ok) in obj
+obj?.head(s, ok, ok) != f == nil
+obj?.head(s, s)
+obj?.head(s[0.5])
+obj?.head(s[a])
+obj?.head(s[b])
+obj?.head(s[f])
+obj?.head(string("a"))
+obj?.head(string("a", b))
+obj?.head(string("c"))
+obj?.head(string(1, nil))
+obj?.head(string(2))
+obj?.head(string(a))
+obj?.head(string(a), 0 or false)
+obj?.head(string(arr))
+obj?.head(string(arr), arr)
+obj?.head(string(arr), b == 2)
+obj?.head(string(div))
+obj?.head(string(div, f))
+obj?.head(string(f))
+obj?.head(string(nil))
+obj?.head(string(nil, "c", s))
+obj?.head(string(nil, s))
+obj?.head(string(obj))
+obj?.head(string(obj, arr, ok, nil))
+obj?.head(string(s))
+obj?.head(string(s, "b"))
+obj?.head(string(s, 2))
+obj?.head(string(s, arr, ok, obj))
+obj?.head(toBase64("a"))
+obj?.head(toBase64("b"))
+obj?.head(toBase64(s))
+obj?.head(toBase64(s, 0.5))
+obj?.head(toBase64(s, 1))
+obj?.head(toJSON("a"))
+obj?.head(toJSON("c"))
+obj?.head(toJSON("c", nil))
+obj?.head(toJSON(0.5, nil))
+obj?.head(toJSON(2, "c"))
+obj?.head(toJSON(2, b))
+obj?.head(toJSON(a))
+obj?.head(toJSON(a, 0))
+obj?.head(toJSON(a, s))
+obj?.head(toJSON(arr))
+obj?.head(toJSON(arr), div)
+obj?.head(toJSON(b))
+obj?.head(toJSON(b, 0, s))
+obj?.head(toJSON(f))
+obj?.head(toJSON(f, "b"))
+obj?.head(toJSON(false), ok)
+obj?.head(toJSON(nil))
+obj?.head(toJSON(nil, nil, 2, div))
+obj?.head(toJSON(true, a))
+obj?.head(trim("c"))
+obj?.head(trimPrefix("a", ok, "c", s, 0.5))
+obj?.head(trimPrefix("c"))
+obj?.head(trimPrefix("c", s))
+obj?.head(trimSuffix("b"))
+obj?.head(true != 0.5)
+obj?.head(true != ok)
+obj?.head(true != s)
+obj?.head(true != true)
+obj?.head(true && a)
+obj?.head(true && arr)
+obj?.head(true && arr, any(arr, ok))
+obj?.head(true && b)
+obj?.head(true == add)
+obj?.head(true == div)
+obj?.head(true == obj, div(2, 1))
+obj?.head(true == ok)
+obj?.head(true ? "b" : obj)
+obj?.head(true ? a : obj)
+obj?.head(true ? add : div)
+obj?.head(true ? arr : add)
+obj?.head(true ? div : b)
+obj?.head(true ? nil : arr)
+obj?.head(true ? obj : arr)
+obj?.head(true ? obj : ok)
+obj?.head(true ? ok : b)
+obj?.head(true and "c")
+obj?.head(true and nil)
+obj?.head(true and obj)
+obj?.head(true and true, b)
+obj?.head(true in nil)
+obj?.head(true or b, string("c"))
+obj?.head(true or nil)
+obj?.head(true or obj)
+obj?.head(true or s)
+obj?.head(true || div)
+obj?.head(true || false, s contains s)
+obj?.head(true || nil, add)
+obj?.head(true) != div
+obj?.head(true) or f < 1
+obj?.head(true, div) or obj.b
+obj?.head(true, f, ok, obj) and add == add
+obj?.head(true, obj) == b ? 0 : obj.b
+obj?.head(true, ok, b, 0) or obj.a
+obj?.head(true, s, div, f) == obj.b
+obj?.head(upper("a"))
+obj?.head(upper("b"))
+obj?.head(upper(1, s))
+obj?.head(upper(s))
+obj?.head(upper(true, f, 1, s))
+obj?.head(values(obj))
+obj?.head({"a": 0, "b": div})
+obj?.head({"b": s})
+obj?.head({"c": f})
+obj?.obj
+obj?.obj != -a
+obj?.obj != -f
+obj?.obj != a
+obj?.obj != add
+obj?.obj != any(arr, false)
+obj?.obj != arr
+obj?.obj != arr ? ok : s
+obj?.obj != arr ? s : nil
+obj?.obj != b
+obj?.obj != div
+obj?.obj != div(b, a)
+obj?.obj != f
+obj?.obj != float(0.5)
+obj?.obj != map(arr, true)
+obj?.obj != max(0.5)
+obj?.obj != nil == nil
+obj?.obj != nil == ok
+obj?.obj != obj ? arr : ok
+obj?.obj != obj.obj
+obj?.obj != obj?.a
+obj?.obj != obj?.b
+obj?.obj != ok
+obj?.obj != s
+obj?.obj == -a
+obj?.obj == a
+obj?.obj == a ** a
+obj?.obj == a ** f
+obj?.obj == add
+obj?.obj == add(2, b)
+obj?.obj == add(a, b)
+obj?.obj == add(b, 0)
+obj?.obj == arr
+obj?.obj == b
+obj?.obj == b ? 2 : div
+obj?.obj == b ? add : a
+obj?.obj == div
+obj?.obj == div ? arr : a
+obj?.obj == f
+obj?.obj == map(arr, ok)
+obj?.obj == obj
+obj?.obj == obj ? b : false
+obj?.obj == obj.obj
+obj?.obj == obj.obj.a
+obj?.obj == obj?.b
+obj?.obj == ok
+obj?.obj == s
+obj?.obj == s + "a"
+obj?.obj in arr
+obj?.obj in obj.head(arr, obj)
+obj?.obj or 1 == 0
+obj?.obj.a
+obj?.obj.a != add
+obj?.obj.a != arr
+obj?.obj.a == arr
+obj?.obj.a == f
+obj?.obj.b
+obj?.obj.b > b
+obj?.obj.b >= a
+obj?.obj.obj
+obj?.obj.obj == arr
+obj?.obj.obj.a
+obj?.obj.obj.b
+obj?.obj.obj.b == add
+obj?.obj.obj.obj
+obj?.obj.obj?.a
+obj?.obj.obj?.b
+obj?.obj.obj?.obj
+obj?.obj?.a
+obj?.obj?.a <= b
+obj?.obj?.a == add
+obj?.obj?.b
+obj?.obj?.b == div
+obj?.obj?.b == obj
+obj?.obj?.obj
+obj?.obj?.obj != ok
+obj?.obj?.obj.a
+obj?.obj?.obj.b
+obj?.obj?.obj.obj
+obj?.obj?.obj?.a
+obj?.obj?.obj?.b
+obj?.obj?.obj?.obj
+obj?.obj[obj.head(s, 0)] == add
+obj?.obj[obj?.head(nil, "a")]
+obj?.obj[obj?.head(s)]
+obj?.obj[s]
+obj?.obj[string(0.5)]?.a
+obj[nil] != div
+obj[nil] != s
+obj[nil] == add
+obj[nil] == arr
+obj[nil] == f
+obj[nil]?.a
+obj[nil]?.a.a
+obj[nil]?.a.b
+obj[nil]?.a.obj
+obj[nil]?.a?.a
+obj[nil]?.b
+obj[nil]?.b?.b
+obj[nil]?.fn(b)
+obj[nil]?.fn(ok)
+obj[nil]?.head(arr)
+obj[nil]?.obj
+obj[nil]?.obj.obj
+obj[obj.head(s)]
+obj[ok ? "b" : add]
+obj[s[a:b]]
+obj[s]
+obj[s] != arr
+obj[s] != div
+obj[s] != f
+obj[s] != f ? add : div
+obj[s] != s
+obj[s] == !ok
+obj[s] == add
+obj[s] == obj.head(s)
+obj[s]?.a
+obj[s]?.a.b
+obj[s]?.a?.b
+obj[s]?.b
+obj[s]?.b.a
+obj[s]?.b.b
+obj[s]?.b?.obj
+obj[s]?.fn(a > 0).b
+obj[s]?.fn(f)
+obj[s]?.head(get(b == a))
+obj[s]?.head(obj.a)
+obj[s]?.head(ok || a)
+obj[s]?.obj
+obj[s]?.obj.b
+obj[s]?.obj.obj
+obj[s]?.obj?.a
+obj[s]?.obj?.b.obj
+obj[s]?.obj?.obj
+obj[string("a")]
+obj[string(2)]?.a
+obj[string(add)]
+obj[string(nil)]
+obj[string(obj)]
+obj[toJSON("b")]
+obj[toJSON(a)]
+obj[toJSON(f)]
+obj[toJSON(ok)]?.obj
+obj[trimPrefix("b")]
+obj[upper(s)]
+ok
+ok != !true
+ok != (arr != arr || a > a)
+ok != (ok or true)
+ok != (true || true)
+ok != false ? 1 : "b"
+ok != first(obj?.head(0.5))
+ok != nil != nil
+ok != nil != ok
+ok != nil != true
+ok != nil == ok
+ok != nil ? true : f
+ok != nil || one(arr, ok)
+ok != none(arr, false)
+ok != obj.a
+ok != obj.b
+ok != obj.head("a", true)
+ok != obj.head(add)
+ok != obj.head(arr)
+ok != obj.head(f, "c")
+ok != obj.head(ok, "c", nil, nil)
+ok != obj.obj
+ok != obj.obj.obj
+ok != obj?.a
+ok != obj?.b
+ok != obj?.fn(a)
+ok != obj?.fn(b)
+ok != obj?.head(1)
+ok != obj?.head(get(ok, obj))?.b
+ok != obj?.head(nil, add)
+ok != obj?.head(obj == obj)
+ok != obj?.head(ok)
+ok != obj?.obj
+ok != obj?.obj.a
+ok != obj?.obj.obj == nil ? s : obj.obj?.obj
+ok != obj?.obj?.a
+ok != obj?.obj?.b
+ok != ok
+ok != ok != ok
+ok != ok and obj.fn(f, nil)
+ok != ok or b >= a
+ok != one(arr, false)
+ok != true ? "b" : nil
+ok && !ok
+ok && "a" > "a"
+ok && "a" >= s
+ok && "c" < s
+ok && (true || ok)
+ok && 0 != f
+ok && 0 <= f
+ok && 0 == nil
+ok && 0.5 != b
+ok && 0.5 >= f
+ok && 1 != 2
+ok && 2 != f
+ok && 2 > f
+ok && a < 1
+ok && a < b
+ok && a <= 0
+ok && a <= a
+ok && a <= f
+ok && a == 0
+ok && a >= f
+ok && all(arr, ok)
+ok && all(arr, true)
+ok && arr != arr
+ok && arr == arr
+ok && b < 0.5
+ok && b == b
+ok && b >= f
+ok && b in arr
+ok && div == nil
+ok && f != 0
+ok && f != f
+ok && f < f
+ok && false && ok
+ok && false ? f : toJSON("c")
+ok && nil == "c"
+ok && nil == f
+ok && none(arr, ok)
+ok && not ok
+ok && obj.a
+ok && obj.b
+ok && obj.head(a)
+ok && obj.head(b)
+ok && obj.head(b, obj)
+ok && obj.head(false)
+ok && obj.obj
+ok && obj.obj?.a
+ok && obj.obj?.obj
+ok && obj?.a
+ok && obj?.b
+ok && obj?.head(a, b)
+ok && obj?.head(add, b, nil, obj)
+ok && obj?.head(arr)
+ok && obj?.head(false)
+ok && obj?.head(nil)
+ok && obj?.obj
+ok && obj?.obj != obj.b
+ok && obj?.obj?.a
+ok && obj?.obj?.b
+ok && ok
+ok && ok ? a : ok
+ok && ok ? add : s
+ok && ok ? b : a
+ok && ok ? f : obj
+ok && ok and obj?.obj
+ok && ok or nil == a
+ok && ok or obj?.head(div, f)
+ok && ok || ok
+ok && s != s
+ok && s contains "b"
+ok && true && obj.obj
+ok && true and ok
+ok && true or obj?.obj
+ok == !true
+ok == (false || ok)
+ok == (ok and true)
+ok == false == ok ? b : obj
+ok == false || 0.5 >= f
+ok == false || s != nil
+ok == nil ? 2 : arr
+ok == nil ? add : arr
+ok == nil ? div : "a"
+ok == nil ? div : obj.b
+ok == nil ? f : ok
+ok == nil ? nil : "c"
+ok == obj.a
+ok == obj.b
+ok == obj.head(a)
+ok == obj.head(add)
+ok == obj.head(b)
+ok == obj.head(div)
+ok == obj.head(f, s, 0, 2)
+ok == obj.head(ok)
+ok == obj.head(s)
+ok == obj.head(true)
+ok == obj.obj
+ok == obj?.a
+ok == obj?.b
+ok == obj?.head(0, s)
+ok == obj?.head(a != a)
+ok == obj?.head(a, 0, obj)
+ok == obj?.head(a, obj, 0, s, obj)
+ok == obj?.head(add)
+ok == obj?.head(add, add)
+ok == obj?.head(b, "a", add)
+ok == obj?.head(div, "b")
+ok == obj?.head(nil, false)
+ok == obj?.head(obj.head(arr, b))
+ok == obj?.head(ok)
+ok == obj?.head(ok, div, f, nil, 0.5)
+ok == obj?.obj
+ok == ok
+ok == ok != (ok or true)
+ok == ok == obj?.a
+ok == ok ? add : nil
+ok == ok ? b : s
+ok == ok and arr == arr
+ok == ok || obj.obj
+ok == one(arr, ok)
+ok == true != nil
+ok == true ? add : s
+ok == true and ok
+ok ? "a" : a != b / b
+ok ? "a" : f == obj.b
+ok ? "a" : obj.a
+ok ? "a" : obj.b
+ok ? "a" : obj?.a
+ok ? "b" : b % obj.head(ok)
+ok ? "b" : obj.b
+ok ? "b" : obj.obj
+ok ? "b" : obj?.b?.b
+ok ? "b" : obj?.obj
+ok ? "b" : s endsWith obj.head(add)
+ok ? "c" : 0 % a
+ok ? "c" : 0.5 * f
+ok ? "c" : obj?.b
+ok ? "c" : obj?.fn(add(arr, a) in none(0, b))
+ok ? "c" : obj?.head(arr?.head(a), arr.head(!arr, div?.head(obj, "c"), int(div, div)))
+ok ? 0 * b : obj?.obj
+ok ? 0 : 1 / obj.fn(add, false, add)
+ok ? 0 : a == b
+ok ? 0 : f * b
+ok ? 0 : obj != obj
+ok ? 0 : obj.a
+ok ? 0 : obj.obj
+ok ? 0 : obj?.a
+ok ? 0 : obj?.b
+ok ? 0 : obj?.b.head(add(map(f / b, add(0.5)), add(arr * s, upper(b))))
+ok ? 0 : obj?.fn(add?.obj).b
+ok ? 0 : obj?.fn(any(a, ok))
+ok ? 0 : obj?.fn(div(a.head("c", obj), div(div)))
+ok ? 0 : obj?.fn(div(false))?.a
+ok ? 0 : obj?.head(any(ok, div(obj)))
+ok ? 0 : obj?.head(hasPrefix(true, "c", add, f), div.a)
+ok ? 0 : obj?.obj
+ok ? 0 : s <= obj.b
+ok ? 0 == 0 : s
+ok ? 0.5 != 0 : trim(nil, s)
+ok ? 0.5 : add == obj.fn(s)
+ok ? 0.5 : b == obj?.a
+ok ? 0.5 : f ^ f
+ok ? 0.5 : obj.a
+ok ? 0.5 : obj.b
+ok ? 0.5 : obj.fn(obj)
+ok ? 0.5 : obj.head(add.a * div.fn(0, f))
+ok ? 0.5 : obj.obj
+ok ? 0.5 : obj?.a
+ok ? 0.5 : obj?.b
+ok ? 0.5 : obj?.head(nil - arr)
+ok ? 0.5 : obj?.obj
+ok ? 1 + b : a
+ok ? 1 : obj in obj.b
+ok ? 1 : obj.b
+ok ? 1 : obj?.head(arr[0:obj], a?.a)
+ok ? 1 : obj?.obj
+ok ? 2 : add == div
+ok ? 2 : obj.b
+ok ? 2 : obj.obj
+ok ? 2 : obj?.a
+ok ? a : "a" != s
+ok ? a : -0
+ok ? a : 0 < b
+ok ? a : 0 > a
+ok ? a : 0.5 / a
+ok ? a : 1 + f
+ok ? a : 2 / a
+ok ? a : a / obj.obj
+ok ? a : a >= a
+ok ? a : add
+ok ? a : obj.a
+ok ? a : obj.b
+ok ? a : obj.head(all(b, a))
+ok ? a : obj.obj
+ok ? a : obj.obj < a
+ok ? a : obj?.a
+ok ? a : obj?.b
+ok ? a : obj?.head(add).head(join(nil, ok) + f)
+ok ? a : obj?.head(div(add(arr, div, b, "a", b)))
+ok ? a : obj?.head(now(add(div, obj, add), add.obj, get(ok, b), div(arr)))
+ok ? a : obj?.obj
+ok ? a : s
+ok ? a < 1 : add
+ok ? a < a : obj
+ok ? abs(0) : f
+ok ? add : 0.5 * a
+ok ? add : 0.5 >= a
+ok ? add : a
+ok ? add : arr
+ok ? add : b .. a
+ok ? add : div
+ok ? add : f
+ok ? add : nil != obj.b
+ok ? add : nil == div
+ok ? add : obj
+ok ? add : obj in obj.b
+ok ? add : obj.a
+ok ? add : obj.b
+ok ? add : obj.b?.obj
+ok ? add : obj.fn("c", b).obj
+ok ? add : obj.fn(f.a < a?.head(1), f)
+ok ? add : obj.head(arr, s)
+ok ? add : obj.head(true)?.obj
+ok ? add : obj.obj
+ok ? add : obj.obj != obj.obj
+ok ? add : obj?.a
+ok ? add : obj?.b
+ok ? add : obj?.b.b
+ok ? add : obj?.fn(a?.fn(filter(0.5, "b"), add(a, arr)))
+ok ? add : obj?.fn(add(obj endsWith obj), obj)
+ok ? add : obj?.fn(none(arr, ok) > f - arr)
+ok ? add : obj?.obj
+ok ? add : ok
+ok ? add : s
+ok ? arr : "c" == obj?.obj
+ok ? arr : 0 ** a
+ok ? arr : a
+ok ? arr : a + add(b, nil)
+ok ? arr : a > b
+ok ? arr : add
+ok ? arr : arr
+ok ? arr : arr in fromJSON(s)
+ok ? arr : arr in obj?.fn(a)
+ok ? arr : b
+ok ? arr : b .. a
+ok ? arr : b > obj.head(0.5, 0, ok)
+ok ? arr : div == obj?.head(nil)
+ok ? arr : f
+ok ? arr : obj.b
+ok ? arr : obj.fn(arr)?.a
+ok ? arr : obj.head(all(f, a) matches div?.head("a", a), all(arr, b) / s?.fn(2), obj?.b?.a, count("b", add).b)
+ok ? arr : obj.head(div(add(a), arr?.fn(nil)), none(nil, ok) < hasSuffix(true, add), min(0.5, "c", true, div) ? div.obj : lower(false, a, 0))
+ok ? arr : obj.head(f.head(ok) + a)
+ok ? arr : obj.head(s, s)
+ok ? arr : obj.obj
+ok ? arr : obj?.b
+ok ? arr : obj?.b.b
+ok ? arr : obj?.fn(f startsWith len(true, obj, 0), arr matches b?.a).b
+ok ? arr : obj?.fn(obj in min(true, ok), all(a .. arr, f), ("c" == ok) * a)
+ok ? arr : obj?.obj
+ok ? arr : ok
+ok ? arr : s + s
+ok ? arr : s contains obj.a
+ok ? arr : s matches obj?.b
+ok ? arr[a:a] : nil != false
+ok ? b ** f : arr
+ok ? b + f : obj?.b
+ok ? b : (false ? b : nil)
+ok ? b : 0 + b
+ok ? b : add
+ok ? b : b
+ok ? b : div
+ok ? b : f >= f
+ok ? b : int(s)
+ok ? b : obj
+ok ? b : obj.a
+ok ? b : obj.obj
+ok ? b : obj?.a
+ok ? b : obj?.b
+ok ? b : obj?.fn("b" .. 0)
+ok ? b : obj?.fn(b?.obj, none(obj, ok))
+ok ? b : obj?.obj
+ok ? b : ok
+ok ? b : s < s
+ok ? b : s endsWith obj.b
+ok ? div : 1 * obj.a
+ok ? div : a
+ok ? div : a < f
+ok ? div : add
+ok ? div : b
+ok ? div : b - b ^ 0
+ok ? div : div
+ok ? div : f
+ok ? div : keys(obj)
+ok ? div : nil == ok
+ok ? div : obj.b
+ok ? div : obj.fn(ok != f, div?.obj)
+ok ? div : obj.obj
+ok ? div : obj?.a
+ok ? div : obj?.b
+ok ? div : obj?.fn(add)
+ok ? div : obj?.fn(obj.head(1))
+ok ? div : obj?.head(div, a.a)
+ok ? div : obj?.head(false ** true <= date(arr, s))
+ok ? div : obj?.head(obj?.head(s, 0, obj) .. add, none(div.a, false != 2))
+ok ? div : obj?.head(ok, add.fn(add)) * a
+ok ? div : obj?.obj
+ok ? div : obj[obj?.head(arr)]
+ok ? div : ok
+ok ? div : s <= s
+ok ? div : s contains s != true
+ok ? div : toJSON(0)
+ok ? div(a, b) : f
+ok ? f - 0 : a / a
+ok ? f : (true ? arr : "b")?.a
+ok ? f : 0 == obj.obj
+ok ? f : 0.5 ** b
+ok ? f : 0.5 - f
+ok ? f : 0.5 > f
+ok ? f : 2 % obj.fn(div)
+ok ? f : a * a
+ok ? f : a <= obj.head(true, ok)
+ok ? f : add
+ok ? f : b
+ok ? f : f
+ok ? f : f - obj.obj
+ok ? f : f >= f
+ok ? f : obj.a?.a
+ok ? f : obj.b
+ok ? f : obj.fn(any(div, f))
+ok ? f : obj.head(obj.head(1), all(s, b), add(true))
+ok ? f : obj.obj
+ok ? f : obj?.a
+ok ? f : obj?.b
+ok ? f : obj?.fn(div.obj, a, map(f, f), one(s, b))
+ok ? f : obj?.obj
+ok ? f : obj[obj.head("c")]?.b
+ok ? false : a / obj.a?.fn(div(arr, a, ok).b, add(obj[nil]))
+ok ? false : b - f
+ok ? false : obj.a
+ok ? false : obj.b
+ok ? false : obj.fn(div).a
+ok ? false : obj.head(ok)
+ok ? false : obj.head(s.fn(obj, add, obj))
+ok ? false : obj.obj
+ok ? false : obj?.a
+ok ? false : obj?.head(map(b, ok)).b
+ok ? false : obj?.obj
+ok ? map(arr, f) : arr
+ok ? map(arr, f) : obj?.b
+ok ? max(b) : s
+ok ? nil : 0 * get(arr, b)
+ok ? nil : a == f * b
+ok ? nil : arr[a:obj.obj]
+ok ? nil : b .. obj.b?.obj
+ok ? nil : f == a - a
+ok ? nil : obj.a
+ok ? nil : obj.b
+ok ? nil : obj.fn(0 % add.a)
+ok ? nil : obj.fn(div(s))
+ok ? nil : obj.obj
+ok ? nil : obj?.a
+ok ? nil : obj?.fn(add(arr, nil, b, obj))
+ok ? nil : obj?.fn(arr != ok, f.obj)
+ok ? nil : obj?.fn(filter(obj, b) and div(ok, b))?.head(b)
+ok ? nil : obj?.head(get("b" ** div, count(ok, add)))
+ok ? nil : obj?.obj
+ok ? nil == add : s
+ok ? not false : true || false
+ok ? obj : "b" startsWith obj.a
+ok ? obj : "c" < "a"
+ok ? obj : 0 - a ^ b
+ok ? obj : 0.5 * obj.b
+ok ? obj : 2 >= obj?.obj
+ok ? obj : a
+ok ? obj : a >= f
+ok ? obj : add
+ok ? obj : b ^ b
+ok ? obj : div
+ok ? obj : f
+ok ? obj : nil != s
+ok ? obj : obj
+ok ? obj : obj.a
+ok ? obj : obj.b
+ok ? obj : obj.fn(indexOf(map(add, div)))
+ok ? obj : obj.head(none(a, a / 0), nil .. f?.obj, div(0).a)
+ok ? obj : obj.obj
+ok ? obj : obj?.a
+ok ? obj : obj?.b
+ok ? obj : obj?.head(add.obj.a)
+ok ? obj : obj?.head(arr)
+ok ? obj : obj?.obj
+ok ? obj : ok
+ok ? obj : s
+ok ? obj : true != nil
+ok ? obj.a : 0.5 != 1
+ok ? obj.b : (ok ? 2 : add)
+ok ? obj.b : a
+ok ? obj.head(a) : a
+ok ? obj.head(nil, div, 0.5, add) : add
+ok ? obj.obj : s
+ok ? obj?.fn(0) : 1 * a
+ok ? obj?.obj : obj
+ok ? ok : a
+ok ? ok : a ^ obj.fn(a, 1)
+ok ? ok : add
+ok ? ok : arr
+ok ? ok : b > a - 0
+ok ? ok : div
+ok ? ok : obj.b
+ok ? ok : obj.b?.obj?.b
+ok ? ok : obj.fn(0.5 ^ f, none(arr, b), f?.obj, all(b, obj), splitN(true))
+ok ? ok : obj.fn(a || 0.5)
+ok ? ok : obj.fn(add.head(true && f, arr.head(f)))
+ok ? ok : obj.fn(arr.a, obj.head(a), any(f, obj), 0.5 - obj)
+ok ? ok : obj.fn(div, hasSuffix(f, 1)[ok], get(0 ? add : div, one(arr, s)))
+ok ? ok : obj.head(a)
+ok ? ok : obj.obj?.b
+ok ? ok : obj?.a
+ok ? ok : obj?.b
+ok ? ok : obj?.obj
+ok ? ok : obj?.obj.fn(arr)
+ok ? ok : s >= obj?.fn(false, "b")
+ok ? s : 0 - -0
+ok ? s : 0 - f
+ok ? s : 2 in arr ? a : a
+ok ? s : a % b
+ok ? s : add
+ok ? s : add in map(arr, add)
+ok ? s : add(b, a)
+ok ? s : arr
+ok ? s : arr == arr
+ok ? s : div
+ok ? s : f
+ok ? s : f + 2
+ok ? s : map(arr, #)
+ok ? s : nil == div
+ok ? s : obj
+ok ? s : obj.a
+ok ? s : obj.a.fn(add(s?.fn(a)).obj, get(arr.head("c"), 0 <= 0.5) > count(obj.a, s startsWith obj))
+ok ? s : obj.b
+ok ? s : obj.fn(a)
+ok ? s : obj.fn(div, a, false)
+ok ? s : obj.fn(filter(nil, arr) ^ div(ok, nil, f, s), arr?.head(not 0.5), div?.a)
+ok ? s : obj.fn(join(1))
+ok ? s : obj.fn(one(add, 1), div?.b)
+ok ? s : obj.head(div % f?.b)
+ok ? s : obj.obj
+ok ? s : obj?.a
+ok ? s : obj?.b
+ok ? s : obj?.obj
+ok ? s : obj?.obj.a
+ok ? s : s endsWith s
+ok ? trimSuffix("b") : obj
+ok ? true : false and 0 < a
+ok ? true : obj.a
+ok ? true : obj.fn((a startsWith add) - ok ? false : obj)
+ok ? true : obj.head(s <= div)
+ok ? true : obj?.a
+ok ? true : obj?.b
+ok ? true : obj?.obj
+ok ? true || obj?.a : obj
+ok and !ok
+ok and "a" == obj.a
+ok and "a" > "a"
+ok and 0 >= 0
+ok and 0.5 != b
+ok and 0.5 < f
+ok and 0.5 <= f
+ok and 0.5 > f
+ok and 1 >= 0
+ok and 2 >= 1
+ok and a < b
+ok and a == 0
+ok and a > b
+ok and b != 2
+ok and div != div
+ok and div == add
+ok and f <= a
+ok and f <= f
+ok and f == nil
+ok and f >= 0.5
+ok and f >= f
+ok and false && nil != obj
+ok and false && ok
+ok and false and ok
+ok and nil == "b"
+ok and nil == div
+ok and nil == obj
+ok and not ok
+ok and obj.a
+ok and obj.b
+ok and obj.fn(b)
+ok and obj.head(1, 0.5)
+ok and obj.head(f, "a", s)
+ok and obj.head(s)
+ok and obj.obj
+ok and obj.obj.b
+ok and obj.obj.obj
+ok and obj?.a
+ok and obj?.b
+ok and obj?.fn(not false ? 1 : arr)
+ok and obj?.head(add)
+ok and obj?.head(div)
+ok and obj?.head(obj?.head(arr))
+ok and obj?.head(one("c", ok))
+ok and obj?.obj
+ok and obj?.obj.obj
+ok and obj?.obj?.a
+ok and obj?.obj?.obj
+ok and obj[s]
+ok and ok
+ok and ok && ok
+ok and ok ? 1 > b : a ** 1
+ok and ok ? add : !ok
+ok and ok ? arr : "c"
+ok and ok ? div : s
+ok and ok ? nil : arr
+ok and ok ? s : f
+ok and ok and true == false
+ok and s contains s
+ok and true or arr == arr
+ok in obj.head(nil, div, s)
+ok in obj?.head(arr, ok, add)
+ok in values(obj)
+ok or !obj?.obj
+ok or !ok
+ok or "b" <= s
+ok or "b" == nil
+ok or "b" > s
+ok or 0 < f
+ok or 0 <= b
+ok or 0 == f
+ok or 0 >= b
+ok or 0.5 != 0
+ok or 0.5 >= 0
+ok or 2 <= 0
+ok or a < 0
+ok or a <= b
+ok or a == nil
+ok or add != nil
+ok or add == div
+ok or b > f
+ok or b in arr
+ok or div != div
+ok or div != nil
+ok or div == div
+ok or f != 0.5
+ok or f != b
+ok or f < 0
+ok or f == f
+ok or f > 0
+ok or f >= b
+ok or false && ok
+ok or false ? s : nil
+ok or false or 2 < a
+ok or fromJSON(nil)
+ok or nil != add
+ok or nil != arr
+ok or nil == ok
+ok or nil in obj?.fn(obj != splitN("c", true, "b"), count(nil * f, div), add(0.5)?.b)
+ok or not false
+ok or not ok
+ok or not true
+ok or obj.a
+ok or obj.a.b
+ok or obj.a.head(all(0 && nil, add(obj, false, "b")))
+ok or obj.a.obj
+ok or obj.a?.b
+ok or obj.a?.obj
+ok or obj.b
+ok or obj.b?.head(f)
+ok or obj.fn(-nil endsWith (nil || nil))
+ok or obj.fn(a, div)
+ok or obj.fn(a, s[div:arr]?.a)
+ok or obj.fn(add(arr)[arr:f], none(none(f, b), 0 .. 0))
+ok or obj.fn(arr .. a)?.b?.b
+ok or obj.fn(arr.b <= ok, b in add?.fn(obj))?.fn(add(arr, nil)?.head(b?.fn(nil, "b", false) .. none(add, b), filter(a.obj, div >= a), 0.5 ? div : arr matches date(nil), 0 ** nil * obj.head(ok), count(add(div), map(0, a))).a)
+ok or obj.fn(arr.fn(ok.head(0, add, a, a)))
+ok or obj.fn(b?.head(1, nil, 1, a, nil) matches add(s, a))
+ok or obj.fn(div(div .. 0, add(div)), indexOf(nil endsWith add))
+ok or obj.fn(div).head(filter(count(s, 0.5), add(obj)), arr startsWith obj || obj != div)
+ok or obj.fn(f, nil, arr)?.head(true contains b, ok.head(ok, arr)).b
+ok or obj.fn(fromBase64(any(b, true), s, add(div)), s)?.obj
+ok or obj.fn(map(2, b)?.obj, arr * 0.5 > filter(a, a))
+ok or obj.fn(obj ? div : div - add(add), b, none(div, a).obj)
+ok or obj.fn(ok, 0)
+ok or obj.head(0.5)
+ok or obj.head(0.5, obj)
+ok or obj.head(1, b, add, obj).b
+ok or obj.head(2 matches b, float(obj), none(b, div), add[add:1], 0.5 && s)
+ok or obj.head(a)
+ok or obj.head(add(div(0.5)), f)
+ok or obj.head(add.fn(2) matches obj?.head(nil, "c"))
+ok or obj.head(arr)
+ok or obj.head(arr?.obj, count(s, 0))
+ok or obj.head(b - nil)
+ok or obj.head(b ? s : "b" < div(arr), f.obj.fn(map(s, b)))
+ok or obj.head(b, b[nil] startsWith filter(false, b), s, div?.fn("a", obj, f) ? obj ** false : ok)
+ok or obj.head(div(count(2, obj), false || obj), filter(ok.fn(add), add?.head(ok)))
+ok or obj.head(div(count(nil, b), add("c")))
+ok or obj.head(div, a)
+ok or obj.head(div, ok)
+ok or obj.head(f)
+ok or obj.head(filter(add.head(s), one(a, 0.5)), add)
+ok or obj.head(obj)
+ok or obj.head(obj?.head(f))
+ok or obj.head(split(b))
+ok or obj.head(splitAfterN(a?.a) != (f && div(nil, 0)) != -min(div, 1), b)
+ok or obj.head(true)
+ok or obj.head(true, add)
+ok or obj.obj
+ok or obj.obj.a
+ok or obj.obj.obj
+ok or obj?.a
+ok or obj?.a.a
+ok or obj?.a.obj
+ok or obj?.a?.b
+ok or obj?.b
+ok or obj?.b.obj
+ok or obj?.fn("c" + 0)
+ok or obj?.fn("c", ok)
+ok or obj?.fn(a)
+ok or obj?.fn(a, div(filter(2, f)), add(first(a, true, s, "c")))
+ok or obj?.fn(add(a), b != b.b)
+ok or obj?.fn(add(s))
+ok or obj?.fn(add.b, ok endsWith arr)
+ok or obj?.fn(add?.b > s)
+ok or obj?.fn(arr, 1 ** nil)
+ok or obj?.fn(b)
+ok or obj?.fn(b?.head(s), arr)
+ok or obj?.fn(count(s?.head(0.5), add in f), join(add.a))
+ok or obj?.fn(div(s, obj, add))?.a.b
+ok or obj?.fn(f?.a)
+ok or obj?.fn(float(div))
+ok or obj?.fn(min(arr)[b:get(0.5, nil)])
+ok or obj?.fn(ok?.head(add(ok)), add(add?.obj))
+ok or obj?.fn(one(add(f, obj), a.fn(a)))
+ok or obj?.fn(one(arr, false) <= ok?.a)
+ok or obj?.fn(s)
+ok or obj?.fn(s?.b)
+ok or obj?.head(0)
+ok or obj?.head(2, a)
+ok or obj?.head(a in false matches add(nil), last(add(0), a.a), arr ^ obj == keys(nil, add), ok.obj)
+ok or obj?.head(add <= obj, "b" || a, a, get(a, div))
+ok or obj?.head(add == f, filter("a", ok))
+ok or obj?.head(add.obj, s)
+ok or obj?.head(all(div, add), max(s, ok))
+ok or obj?.head(arr).b
+ok or obj?.head(b)
+ok or obj?.head(f, a)
+ok or obj?.head(f, div)
+ok or obj?.head(fromJSON(b) endsWith b.a, none(map(b, b), s?.fn(arr, b)))
+ok or obj?.head(nil ? ok : f.a)
+ok or obj?.head(nil)
+ok or obj?.head(nil, ok, ok, a)
+ok or obj?.head(none(f.head(ok), f))
+ok or obj?.head(obj >= "c")
+ok or obj?.head(obj, f)
+ok or obj?.head(s)
+ok or obj?.head(s?.a)
+ok or obj?.obj
+ok or obj?.obj.b
+ok or obj?.obj?.b
+ok or obj[toJSON("b")]
+ok or ok
+ok or ok != false
+ok or ok == ok
+ok or ok ? 0 : a
+ok or ok ? false : a
+ok or ok ? obj : "b"
+ok or ok || !obj?.a
+ok or ok || nil != s
+ok or s != nil
+ok or s <= "b"
+ok or s == nil
+ok or s endsWith s
+ok or true ? 0 : true
+ok or true || ok
+ok || !ok
+ok || !true
+ok || "b" in obj
+ok || "c" != s
+ok || "c" > obj.obj
+ok || 0 in arr
+ok || 0.5 != 2
+ok || 0.5 <= f
+ok || 0.5 >= 0.5
+ok || 2 < f
+ok || 2 > f
+ok || a < f
+ok || a == 1
+ok || arr != arr
+ok || b != 2
+ok || b == a
+ok || b == f
+ok || b > 0
+ok || b > f
+ok || div == div
+ok || f == obj?.b
+ok || f > 0
+ok || f > b
+ok || f >= 0.5
+ok || f in obj.head(obj)
+ok || false ? obj : 0
+ok || false or obj.fn(div)
+ok || get(false ? b : 0.5, add.head(0.5, div))?.a
+ok || nil != b
+ok || nil == "b"
+ok || nil == f
+ok || nil == nil
+ok || nil == s
+ok || not obj?.head(b.head(div(ok)).a)
+ok || obj != obj
+ok || obj.a
+ok || obj.a startsWith toJSON(nil)
+ok || obj.a.b
+ok || obj.a?.a
+ok || obj.b
+ok || obj.b.b
+ok || obj.b.obj
+ok || obj.b?.b
+ok || obj.b?.obj
+ok || obj.fn(a.head(arr))
+ok || obj.fn(add(add.b, div?.a), s?.head(add.fn("b", b)), count(div, obj) % int(a, b, "c", false), obj)
+ok || obj.fn(add(f))
+ok || obj.fn(add, nil)?.head(arr contains a)
+ok || obj.fn(b)
+ok || obj.fn(div(obj), obj / obj, div(a, nil))
+ok || obj.fn(div).a
+ok || obj.fn(int(ok, nil, s, obj)[ok.a])
+ok || obj.fn(map("c", add), div(ok))
+ok || obj.fn(map(arr, div(f)))
+ok || obj.fn(nil, div)?.a
+ok || obj.fn(not 0 || nil - nil)
+ok || obj.fn(ok, obj)
+ok || obj.fn(ok.fn(nil))
+ok || obj.fn(s)
+ok || obj.fn(s[1], f < add)
+ok || obj.fn(true < arr matches div?.fn(a, s), div(add startsWith obj))
+ok || obj.fn(true <= a || f)
+ok || obj.head(0.5)
+ok || obj.head(2)
+ok || obj.head(a)
+ok || obj.head(add)
+ok || obj.head(arr)
+ok || obj.head(arr, filter(div(obj), -arr), fromBase64(1)?.obj, filter(f, 1) && b?.head(s, b))
+ok || obj.head(arr?.a?.obj)
+ok || obj.head(div.a)
+ok || obj.head(f, b)
+ok || obj.head(f, nil)?.obj.obj
+ok || obj.head(f.head(0 in arr, arr.head(s, s), div && a), s).b
+ok || obj.head(get(arr, false) && a ^ s)
+ok || obj.head(get(s?.b, f.a), s?.a ** ok)
+ok || obj.head(obj ? s : f, b * nil, one(false, nil))
+ok || obj.head(obj[add(b)], ok[add] in arr, arr)
+ok || obj.head(trim(false) matches filter(f, ok))
+ok || obj.obj
+ok || obj.obj.a
+ok || obj.obj?.a
+ok || obj.obj?.b
+ok || obj.obj?.fn(count(div(add || true, f, a?.fn(f, a, ok, nil)), add(a.b, add(nil))))
+ok || obj?.a
+ok || obj?.a?.b
+ok || obj?.a?.obj
+ok || obj?.b
+ok || obj?.b.b
+ok || obj?.b?.a
+ok || obj?.b?.head(f?.b ** arr.a)
+ok || obj?.b?.obj
+ok || obj?.fn("a", s)?.a
+ok || obj?.fn(-map(f, a), arr.fn(obj) == 0 .. arr)
+ok || obj?.fn(0, a)?.a
+ok || obj?.fn(0, nil, false)
+ok || obj?.fn(2, s)
+ok || obj?.fn(a)
+ok || obj?.fn(a.a)
+ok || obj?.fn(a.b, string(arr), ok).a
+ok || obj?.fn(a?.b >= hasSuffix(add))
+ok || obj?.fn(add("a"), arr matches nil, a?.obj)
+ok || obj?.fn(add(obj))
+ok || obj?.fn(add?.a)
+ok || obj?.fn(add[arr] in obj)
+ok || obj?.fn(any(a, arr), add(add, arr, f, 0.5, obj))
+ok || obj?.fn(arr)
+ok || obj?.fn(div >= true, a - arr, obj <= nil)
+ok || obj?.fn(div(0, arr, 0.5, b, div), ok ^ a)
+ok || obj?.fn(div, trimPrefix(add, arr, s, div))
+ok || obj?.fn(f?.a, b[0:false])
+ok || obj?.fn(f?.head(ok, div, add) < (arr or ok), div(0.5, s).b)
+ok || obj?.fn(get(f, ok) ^ div(2))
+ok || obj?.fn(get(get(ok, obj), div(b, 0.5, div)))
+ok || obj?.fn(hasPrefix(2), div.head(1))
+ok || obj?.fn(hasPrefix(b))
+ok || obj?.fn(map(none(add, 0), div))
+ok || obj?.fn(obj ** a, arr.fn("a", add, s)).head(ok)
+ok || obj?.fn(ok.fn(f, ok), get(nil, f))
+ok || obj?.fn(ok.head(arr), s)
+ok || obj?.fn(s[ok .. s])
+ok || obj?.head(-ok[ok], add(s < div))
+ok || obj?.head(0)?.a
+ok || obj?.head(0, "a", f, 0)
+ok || obj?.head(0.5, nil)
+ok || obj?.head(a in 2)
+ok || obj?.head(a)
+ok || obj?.head(add(b, add), div && nil)
+ok || obj?.head(add)
+ok || obj?.head(any(arr, true))
+ok || obj?.head(arr)
+ok || obj?.head(b)
+ok || obj?.head(b, ok, 2)
+ok || obj?.head(div || s)
+ok || obj?.head(div, div).a
+ok || obj?.head(f)
+ok || obj?.head(fromBase64(add(div)), b.b.obj)
+ok || obj?.head(ok && f)
+ok || obj?.head(ok)
+ok || obj?.head(ok, "c", 0, nil, s)
+ok || obj?.head(one(add, ok))
+ok || obj?.head(s)
+ok || obj?.head(s, f)
+ok || obj?.head(s.a)
+ok || obj?.head(true)
+ok || obj?.obj
+ok || obj?.obj.a
+ok || obj?.obj.b
+ok || obj?.obj.obj?.obj
+ok || obj?.obj?.b
+ok || obj[obj.b]
+ok || obj[s]?.b
+ok || ok
+ok || ok && true
+ok || ok == nil
+ok || ok ? false : arr
+ok || ok ? obj : s
+ok || ok or obj?.obj
+ok || s <= s
+ok || s >= s
+ok || s endsWith "b"
+ok || true ? f : ok
+ok || true or 1 != f
+ok || true or s matches s
+ok || true || obj?.c
+one(0 .. 2, ok)
+one(0 .. b, ok)
+one(2 .. 0, f > 0)
+one([add, false], ok)
+one(arr, !false)
+one(arr, !ok)
+one(arr, "b" contains "b")
+one(arr, "b" endsWith s)
+one(arr, "b" startsWith "c")
+one(arr, "c" contains "c")
+one(arr, # <= #)
+one(arr, 0 != 0.5)
+one(arr, 0 != nil)
+one(arr, 0 != obj?.obj)
+one(arr, 0 == 1)
+one(arr, 0 == nil)
+one(arr, 0 > b)
+one(arr, 0.5 <= b)
+one(arr, 0.5 == obj.obj)
+one(arr, 0.5 >= b)
+one(arr, 1 == 0)
+one(arr, a != 0.5)
+one(arr, a != a)
+one(arr, a < 0)
+one(arr, a <= b)
+one(arr, a == 0.5)
+one(arr, a == a)
+one(arr, a >= 0)
+one(arr, a >= a)
+one(arr, a >= b)
+one(arr, any(arr, ok))
+one(arr, arr != arr)
+one(arr, arr != nil)
+one(arr, arr == nil)
+one(arr, b != b)
+one(arr, b < #)
+one(arr, b < f)
+one(arr, b == f)
+one(arr, div != div)
+one(arr, div != nil)
+one(arr, div == div)
+one(arr, f != a)
+one(arr, f <= 0)
+one(arr, f <= a)
+one(arr, f == nil)
+one(arr, f >= 0)
+one(arr, false != obj.b)
+one(arr, false == obj.obj)
+one(arr, false) ? (true ? s : b) : 0 < 0
+one(arr, false) and ok
+one(arr, hasSuffix(s, "b"))
+one(arr, nil != 0)
+one(arr, nil != arr)
+one(arr, nil != f)
+one(arr, nil == add)
+one(arr, not ok)
+one(arr, obj.head(true, a))
+one(arr, ok != nil)
+one(arr, ok == ok)
+one(arr, ok)
+one(arr, ok) != obj.obj
+one(arr, ok) != ok
+one(arr, ok) && obj.obj
+one(arr, ok) && ok
+one(arr, ok) && ok ? a : div
+one(arr, ok) == obj.fn(0)
+one(arr, ok) and obj?.b
+one(arr, one(arr, ok))
+one(arr, s != "b")
+one(arr, s > s)
+one(arr, s endsWith s)
+one(arr, true && true)
+one(arr, true ? false : add)
+one(arr, true and true)
+one(arr, true) or obj?.head(0.5)
+one(b .. 0, obj.b)
+one(b .. 1, ok)
+one(b .. 2, any(arr, true))
+one(b .. a, ok)
+one(b .. b, "a" == nil)
+one(b .. b, f != nil)
+one(false ? 0 : arr, "a" < s)
+one(filter(arr, false), obj?.a)
+one(filter(arr, ok), nil == div)
+one(map(arr, "b"), div != add)
+one(map(arr, 0), f != f)
+one(map(arr, 0), ok == false)
+one(map(arr, 0), ok)
+one(map(arr, 0.5), ok)
+one(map(arr, 2), b <= 0.5)
+one(map(arr, a), ok)
+one(map(arr, add), ok)
+one(map(arr, arr), ok)
+one(map(arr, b), ok)
+one(map(arr, div), div != add)
+one(map(arr, div), ok)
+one(map(arr, f), s contains "b")
+one(map(arr, false), #)
+one(map(arr, ok), #)
+one(map(arr, ok), 0.5 < 0.5)
+one(map(arr, ok), ok)
+one(map(arr, true), #)
+one(obj.head("c"), obj == obj)
+one(obj.head("c", add), b == f)
+one(obj.head(arr), ok)
+one(obj.head(obj), ok)
+one(obj.head(s, obj), ok)
+one(obj.obj, b <= a)
+one(obj.obj, b > 1)
+one(obj.obj, f < 0.5)
+one(obj.obj, ok)
+one(obj?.head("c"), ok)
+one(obj?.head(arr), "a" matches "b")
+one(obj?.head(arr), "c" < s)
+one(obj?.head(s), b == nil)
+one(obj?.head(s), ok)
+one(obj?.head(s), s > s)
+one(obj?.obj, "b" != nil)
+one(obj?.obj, a == b)
+one(obj?.obj, b != 0)
+one(obj?.obj, false == true)
+one(obj?.obj, nil in obj)
+one(obj?.obj, obj.head(ok, 0, "b", 1, div))
+one(obj?.obj, ok)
+one(ok ? arr : f, ok)
+one(ok ? s : ok, ok)
+one(values(obj), nil == ok)
+repeat(s, a)
+repeat(s, b)
+repeat(toJSON(arr), obj?.a)
+s
+s != "b" ? add : add
+s != "b" ? obj : f
+s != "c" && nil != b
+s != nil != obj.a
+s != nil == ok
+s != nil ? arr : ok
+s != nil ? b : false
+s != nil and "b" < "c"
+s != nil || obj.b
+s != obj.a
+s != obj.b
+s != obj.head(0)
+s != obj.head(a)
+s != obj.head(arr)
+s != obj.head(div, arr)
+s != obj.head(f)
+s != obj.head(nil, add, f, s)
+s != obj.head(ok, "b", add)
+s != obj.head(s)
+s != obj.obj
+s != obj.obj.obj
+s != obj.obj?.a
+s != obj.obj?.b
+s != obj.obj?.obj
+s != obj?.a
+s != obj?.b
+s != obj?.b or add != obj.a
+s != obj?.fn(1)
+s != obj?.fn(int(b))
+s != obj?.head(add)
+s != obj?.head(add, 0.5, arr, add)
+s != obj?.obj
+s != obj?.obj.a
+s != obj?.obj?.obj
+s != s
+s != s != obj.head(obj)
+s != s != true
+s != s == ok
+s != s ? 1 : ok
+s != s ? b : s
+s != s || ok
+s != string(0.5)
+s != string(b)
+s != toJSON(1)
+s != toJSON(b)
+s != toJSON(true)
+s != trim("c")
+s + lower("a")
+s + repeat(s, 0)
+s + s
+s + s != s
+s + s + trimPrefix("a")
+s + s == obj?.obj
+s + s >= s
+s + s matches lower(s)
+s + string("c")
+s + string(f)
+s + toJSON("b")
+s + toJSON(ok)
+s + trim(s)
+s < "a" + s
+s < "a" ? 2 : ok
+s < "a" and obj?.obj
+s < "c" && s <= "b"
+s < "c" ? b : arr
+s < "c" and a > f
+s < "c" or obj.a
+s < "c" or obj?.head(s, obj)
+s < lower(s)
+s < obj.head(s)
+s < obj?.head("b", 0.5)
+s < s
+s < s != nil
+s < s || a == 1
+s < s || ok
+s < s[a:0]
+s < string(s)
+s < toJSON(0)
+s < trimPrefix("b")
+s <= "a" != nil
+s <= "a" ? nil : f
+s <= "b" ? "c" : nil
+s <= "c" ? "b" : a
+s <= "c" ? 1 : 2
+s <= "c" ? obj : add
+s <= "c" || obj.fn(b, b)
+s <= obj.head(s, b, "a", add)
+s <= s
+s <= s != ok
+s <= s == obj.b
+s <= s == ok
+s <= s ? 2 : 0.5
+s <= s ? b : ok
+s <= s || !ok
+s <= string(obj)
+s == "a" + "b"
+s == "b" ? obj : s
+s == -obj?.b
+s == f + obj.b
+s == get(obj, s)
+s == nil != nil
+s == nil != obj?.a
+s == nil == obj.obj
+s == nil ? obj : f
+s == nil ? obj : s
+s == nil or ok
+s == nil || obj?.b
+s == nil || true ? 2 : s
+s == obj.a
+s == obj.b
+s == obj.head(0.5)
+s == obj.head(0.5, b, true)
+s == obj.head(arr)
+s == obj.head(b)
+s == obj.head(nil, arr)?.fn(arr)?.obj
+s == obj.head(true or f)
+s == obj.obj
+s == obj.obj.b
+s == obj.obj?.b
+s == obj.obj?.obj?.b
+s == obj?.a
+s == obj?.b
+s == obj?.fn(a)
+s == obj?.head(arr)
+s == obj?.head(f, div)
+s == obj?.head(obj)
+s == obj?.head(obj).b
+s == obj?.head(obj, ok)
+s == obj?.head(ok)
+s == obj?.obj
+s == obj?.obj.obj
+s == obj?.obj?.a
+s == s
+s == s != ok
+s == s ? arr : "c"
+s == s || obj.b
+s == s[1:a]
+s == string("c")
+s == string(0)
+s == string(1)
+s == string(arr)
+s == string(div)
+s == toJSON(a)
+s == trimPrefix("b")
+s > "b" ? "c" : obj
+s > "b" ? b : 0.5
+s > "b" ? div : "b"
+s > "c" && obj.head(s, obj)
+s > obj.head(s)
+s > obj?.head(s)
+s > s
+s > s != true
+s > s && ok
+s > s + "c"
+s > s == obj?.a
+s > s ? add : ok
+s > s ? div : obj?.fn(2)
+s > s ? div : true
+s > s ? ok : obj.a
+s > s ? s : add
+s > s and b == 0
+s > s || obj.a
+s > string(2)
+s > string(arr)
+s > string(s)
+s > toBase64("c")
+s > toJSON(false)
+s > trimPrefix(s)
+s >= "a" + s
+s >= "a" == obj.a
+s >= "a" ? arr : b
+s >= "c" ? b : ok
+s >= "c" ? f : obj
+s >= "c" and obj.obj
+s >= "c" or obj?.head(add, 0, 2, add)
+s >= obj.head("c", s)
+s >= s
+s >= s != obj?.fn(b)
+s >= s && obj.b
+s >= s && obj?.a
+s >= s and obj?.a
+s >= s or obj.head(a)
+s >= string(0)
+s >= string(a)
+s >= string(nil)
+s >= string(s)
+s >= toJSON(arr)
+s >= toJSON(b)
+s >= trim(s)
+s contains "a" && a < f
+s contains "a" ? arr : true
+s contains "b" == ok
+s contains "b" ? a : f
+s contains "b" ? s : a
+s contains "c" ? "c" : b
+s contains "c" ? a : obj?.a
+s contains "c" ? b : obj.fn(obj)
+s contains "c" || obj?.obj
+s contains obj.head(s)
+s contains obj.head(s, div, add)
+s contains obj?.head("c")
+s contains obj?.head(s)
+s contains s
+s contains s == ok
+s contains s ? f : obj
+s contains s and !ok
+s contains s or obj?.head(b, b, obj)?.a in obj
+s contains s or ok
+s contains string(ok)
+s contains toBase64(s)
+s contains toJSON(nil)
+s contains toJSON(ok)
+s contains toJSON(s)
+s endsWith "a" && obj.head(0)
+s endsWith "a" == nil
+s endsWith "a" ? obj : 0
+s endsWith "b" and (ok || true)
+s endsWith "c" != ok ? arr : obj
+s endsWith "c" == ok
+s endsWith "c" ? b : arr
+s endsWith lower("c")
+s endsWith lower(s)
+s endsWith s
+s endsWith s != nil
+s endsWith s && ok
+s endsWith s + s
+s endsWith s == nil
+s endsWith s ? 0 : 0
+s endsWith s ? div : f
+s endsWith s ? div : obj?.b
+s endsWith s ? obj : arr
+s endsWith s ? ok : add
+s endsWith s and obj.head(arr, s)
+s endsWith s and ok
+s endsWith s or a < b
+s endsWith s || obj.fn(nil)
+s endsWith s || ok
+s endsWith string(add)
+s endsWith string(arr)
+s endsWith string(s)
+s endsWith toJSON(2)
+s in [0.5]
+s in map(arr, s)
+s in obj
+s in obj && s matches s
+s in obj == ok
+s in obj ? div : arr
+s in obj ? div : div
+s in obj or obj?.a
+s in obj.head(arr, div)
+s in obj.head(nil)
+s in obj.obj
+s in obj.obj.obj
+s in obj?.head(last(b))
+s in obj?.obj
+s in obj?.obj?.obj
+s matches "a" ? false : true
+s matches "b" != obj.b
+s matches "b" == ok
+s matches "b" ? arr : ok
+s matches "b" ? b : b < b
+s matches "b" ? nil : obj
+s matches "b" or "c" contains "b"
+s matches "b" or obj.head(add)?.obj
+s matches "c" && obj?.obj
+s matches "c" ? add : 1
+s matches "c" ? ok : nil
+s matches "c" ? s : add
+s matches obj?.head("a")
+s matches obj?.head(lower(s, s))
+s matches s
+s matches s == obj.b
+s matches s == obj?.head(a)
+s matches s == ok
+s matches s ? a : 2
+s matches s ? add : a
+s matches s ? nil : a >= a
+s matches s ? obj : arr
+s matches s and ok
+s matches toJSON(f)
+s matches toJSON(s)
+s matches trimSuffix(s, s)
+s startsWith "a" ? s : false
+s startsWith "c" || obj.b
+s startsWith s
+s startsWith s == false
+s startsWith s ? "a" : b
+s startsWith s ? arr : f
+s startsWith s ? obj : arr
+s startsWith s ? s : "a"
+s startsWith s || add == add
+s startsWith s || ok
+s startsWith string(arr)
+s startsWith toJSON(arr)
+s startsWith trimSuffix("b")
+s[0 + 2:min(0)]
+s[2:b] >= s
+s[a:a]
+s[a:a] == obj?.head(ok)
+s[a:b]
+s[a:obj?.a]
+s[add(a, a):obj.b]
+s[b:a]
+split(s, s)
+splitAfter(s, s)
+splitAfter(s[b:b], s)
+string(!false)
+string(!ok)
+string(!true)
+string("a" < s)
+string("a" == nil)
+string("a" == s)
+string("a" >= s)
+string("b" + "a")
+string("b" + s)
+string("b" <= "c")
+string("b" contains "c")
+string("b" matches "a")
+string("b" matches s)
+string("b") matches s
+string("c" != "b")
+string("c" != nil)
+string("c" <= "c")
+string("c" == "a")
+string("c" matches s)
+string("c") != string(s)
+string("c") <= string(s)
+string("c") in obj
+string(-(f >= 0 ? f : add))
+string(-0)
+string(-0.5)
+string(-2)
+string(-a)
+string(-b)
+string(-f)
+string(-obj.obj?.b)
+string(-obj?.b)
+string(0 != 0)
+string(0 != 1)
+string(0 != a)
+string(0 != nil)
+string(0 % 1)
+string(0 % 2)
+string(0 % a)
+string(0 % b)
+string(0 * 0)
+string(0 * a)
+string(0 * f)
+string(0 ** 1)
+string(0 ** 2)
+string(0 ** a)
+string(0 ** f)
+string(0 + 0)
+string(0 + 2)
+string(0 + b)
+string(0 - 1)
+string(0 - 2)
+string(0 - a)
+string(0 - b)
+string(0 / 2)
+string(0 / f)
+string(0 < a)
+string(0 < f)
+string(0 < obj.b)
+string(0 <= 0)
+string(0 <= 0.5)
+string(0 <= a)
+string(0 <= b)
+string(0 <= f)
+string(0 == a)
+string(0 == b)
+string(0 == f)
+string(0 > 2)
+string(0 > b)
+string(0 >= b)
+string(0 ^ 0)
+string(0 ^ 2)
+string(0) < s
+string(0) > s
+string(0) startsWith string(a)
+string(0.5 != a)
+string(0.5 != b)
+string(0.5 ** 1)
+string(0.5 ** b)
+string(0.5 ** f)
+string(0.5 + 1)
+string(0.5 + a)
+string(0.5 - b)
+string(0.5 / 0.5)
+string(0.5 / a)
+string(0.5 / f)
+string(0.5 < 2)
+string(0.5 < arr[-1])
+string(0.5 < b)
+string(0.5 < f)
+string(0.5 == 0)
+string(0.5 == b)
+string(0.5 == f)
+string(0.5 == nil)
+string(0.5 > a)
+string(0.5 > b)
+string(0.5 > f)
+string(0.5 ^ 0)
+string(0.5 ^ 0.5)
+string(1 != nil)
+string(1 % a)
+string(1 ** a)
+string(1 + b)
+string(1 + f)
+string(1 - 0)
+string(1 .. a)
+string(1 / 0.5)
+string(1 < 0)
+string(1 < b)
+string(1 <= 0)
+string(1 <= f)
+string(1 == 2)
+string(1 == b)
+string(1 == nil)
+string(1 > 1)
+string(1 > f)
+string(1 ^ 0)
+string(1 ^ f)
+string(1) != s
+string(1) == obj.b
+string(2 != 0)
+string(2 != nil)
+string(2 != obj.b)
+string(2 * f)
+string(2 + 0)
+string(2 + a)
+string(2 - a)
+string(2 .. a)
+string(2 / 0.5)
+string(2 < 0)
+string(2 <= 0)
+string(2 <= a)
+string(2 == f)
+string(2 > b)
+string(2 >= 0)
+string(2 >= a)
+string(2 ^ 0)
+string(2 in arr)
+string([arr])
+string([div, a])
+string(a != 0.5)
+string(a != a)
+string(a != b)
+string(a % b)
+string(a * 0.5)
+string(a * 2)
+string(a * b)
+string(a ** f)
+string(a + a)
+string(a + f)
+string(a - 0)
+string(a - a)
+string(a - f)
+string(a .. a)
+string(a .. b)
+string(a / 0)
+string(a / f)
+string(a < 0)
+string(a < a)
+string(a < f)
+string(a <= 0.5)
+string(a <= a)
+string(a <= f)
+string(a == b)
+string(a == nil)
+string(a > b)
+string(a > f)
+string(a >= 0)
+string(a >= 1)
+string(a >= a)
+string(a in arr)
+string(a)
+string(a) == s
+string(a) > lower("c")
+string(a) endsWith s
+string(a) in obj
+string(a)[b:b]
+string(abs(0.5))
+string(abs(a))
+string(add != add)
+string(add != div)
+string(add == nil)
+string(add(0, 1))
+string(add(0, b))
+string(add(1, 2))
+string(add(2, a))
+string(add(b, 0))
+string(add(b, 1))
+string(add(b, a))
+string(add(b, b))
+string(add)
+string(add) + s
+string(add) < s
+string(add) <= s
+string(add) > s
+string(add) >= s
+string(add) startsWith "b" ? div : f
+string(any(arr, true))
+string(arr != nil)
+string(arr == obj.obj)
+string(arr)
+string(arr) <= s
+string(arr) == lower(s)
+string(arr) contains s
+string(arr) in obj
+string(arr) matches s == nil
+string(arr) matches trim("b", s)
+string(arr) startsWith lower(s)
+string(arr[0])
+string(arr[1])
+string(arr[2:0])
+string(arr[a])
+string(arr[b:a])
+string(b != 0)
+string(b != a)
+string(b != b)
+string(b != f)
+string(b % 1)
+string(b % b)
+string(b * 0)
+string(b ** 0.5)
+string(b ** 1)
+string(b ** 2)
+string(b ** a)
+string(b ** b)
+string(b + 1)
+string(b + 2)
+string(b + b)
+string(b - a)
+string(b - f)
+string(b .. 0)
+string(b .. b)
+string(b / 0.5)
+string(b / 1)
+string(b / a)
+string(b < 0)
+string(b < 1)
+string(b < a)
+string(b < b)
+string(b < f == nil)
+string(b <= a)
+string(b <= b)
+string(b <= f)
+string(b == 0)
+string(b == 0.5)
+string(b == 1)
+string(b == a)
+string(b == f)
+string(b == nil)
+string(b > 0.5)
+string(b > 1)
+string(b > b)
+string(b ^ 0.5)
+string(b ^ 2)
+string(b ^ b)
+string(b ^ f)
+string(b)
+string(b) < s
+string(b) <= s
+string(b) >= s
+string(b) matches s
+string(count(arr, false))
+string(count(arr, ok))
+string(div != nil)
+string(div == div)
+string(div == nil)
+string(div(0, 2))
+string(div(0, a))
+string(div(0, b))
+string(div(2, a))
+string(div(a, 1))
+string(div(a, a))
+string(div(a, b))
+string(div(b, 1))
+string(div(b, 2))
+string(div(b, a))
+string(div(b, b))
+string(div)
+string(div) != string(b)
+string(div) >= s
+string(div) endsWith s
+string(div)[a:count(arr, true)]
+string(f != 0.5)
+string(f != f)
+string(f != nil)
+string(f * 0)
+string(f * a)
+string(f * f)
+string(f ** b)
+string(f ** f)
+string(f + b)
+string(f - 2)
+string(f - a)
+string(f - b)
+string(f / 0)
+string(f / 0.5)
+string(f / a)
+string(f / f)
+string(f / obj.a)
+string(f < 0.5)
+string(f < a)
+string(f < b)
+string(f < f)
+string(f <= a)
+string(f <= b)
+string(f <= f)
+string(f == 0)
+string(f == 0.5)
+string(f == b)
+string(f == nil)
+string(f > a)
+string(f > b)
+string(f > f)
+string(f >= 0)
+string(f >= 1)
+string(f ^ a)
+string(f ^ b)
+string(f ^ f)
+string(f)
+string(f) + s
+string(f) < s
+string(f) > s
+string(f) >= s
+string(f) endsWith s
+string(false != nil)
+string(false != ok)
+string(false && ok)
+string(false && true)
+string(false == nil)
+string(false ? arr : f)
+string(false ? div : div)
+string(false ? f : a)
+string(false || true)
+string(filter(arr, ok))
+string(float(0))
+string(float(0.5))
+string(float(a))
+string(float(b))
+string(float(f))
+string(get(arr, a))
+string(get(obj, s))
+string(int(0))
+string(int(b))
+string(int(f))
+string(keys(obj))
+string(last(arr))
+string(len("b"))
+string(len(obj))
+string(len(s))
+string(lower("c"))
+string(map(arr, 0.5))
+string(map(arr, a))
+string(map(arr, add))
+string(map(arr, arr))
+string(map(arr, b))
+string(map(arr, div))
+string(map(arr, obj))
+string(map(arr, ok))
+string(max(0))
+string(max(0.5))
+string(max(f))
+string(min(2))
+string(min(f))
+string(nil != "b")
+string(nil != "c")
+string(nil != 2)
+string(nil != a)
+string(nil != add)
+string(nil != b)
+string(nil != f)
+string(nil != obj)
+string(nil != ok)
+string(nil != s)
+string(nil == 2)
+string(nil == add)
+string(nil == b)
+string(nil == div)
+string(nil == false)
+string(nil == obj)
+string(nil == ok)
+string(nil == s)
+string(nil in arr)
+string(nil in obj)
+string(nil) != toJSON(true)
+string(nil) + s
+string(nil) == obj.a
+string(nil) in obj
+string(nil) matches s
+string(none(arr, false))
+string(none(arr, ok))
+string(none(arr, true))
+string(not false)
+string(not ok)
+string(not true)
+string(obj == obj)
+string(obj)
+string(obj) < s
+string(obj) <= s
+string(obj) contains s
+string(obj.a)
+string(obj.b)
+string(obj.fn(1))
+string(obj.fn(2))
+string(obj.fn(a))
+string(obj.fn(b))
+string(obj.head("a"))
+string(obj.head("c", b, "b", 2))
+string(obj.head(2))
+string(obj.head(a))
+string(obj.head(a, 0, arr, obj, b))
+string(obj.head(a, div))
+string(obj.head(add))
+string(obj.head(add, b, arr))
+string(obj.head(arr))
+string(obj.head(arr, f, obj))
+string(obj.head(arr, obj))
+string(obj.head(b))
+string(obj.head(b, a, s))
+string(obj.head(div))
+string(obj.head(f, "b", a, 0))
+string(obj.head(f, arr, "b", 2))
+string(obj.head(f, nil, a, f))
+string(obj.head(nil, 1))
+string(obj.head(obj, f))
+string(obj.head(ok))
+string(obj.head(ok, div, add))
+string(obj.head(s))
+string(obj.head(s, b, b, arr))
+string(obj.head(s, true))
+string(obj.obj == s)
+string(obj.obj)
+string(obj.obj.b)
+string(obj.obj.obj)
+string(obj.obj?.b)
+string(obj?.a)
+string(obj?.b <= f)
+string(obj?.b)
+string(obj?.b) contains s
+string(obj?.fn(0))
+string(obj?.fn(a))
+string(obj?.fn(b))
+string(obj?.head("c", 0.5, f))
+string(obj?.head(0, "a"))
+string(obj?.head(0.5))
+string(obj?.head(0.5, s))
+string(obj?.head(a))
+string(obj?.head(a, add))
+string(obj?.head(add))
+string(obj?.head(add, f, "a"))
+string(obj?.head(arr))
+string(obj?.head(arr, true))
+string(obj?.head(b, obj, arr))
+string(obj?.head(div))
+string(obj?.head(div, s, arr))
+string(obj?.head(f))
+string(obj?.head(false, true))
+string(obj?.head(nil))
+string(obj?.head(nil)?.a)
+string(obj?.head(obj))
+string(obj?.head(ok))
+string(obj?.head(s, b, s))
+string(obj?.obj)
+string(obj?.obj.a)
+string(obj?.obj.obj)
+string(obj[nil])
+string(obj[s])
+string(obj[s]?.a)
+string(obj[s]?.b)
+string(ok != ok)
+string(ok && false)
+string(ok && ok)
+string(ok ? a : b)
+string(ok ? add : 1)
+string(ok ? add : a)
+string(ok ? add : div)
+string(ok ? arr : div)
+string(ok ? b : true)
+string(ok ? div : nil)
+string(ok ? s : obj)
+string(ok ? true : add)
+string(ok and ok)
+string(ok or true)
+string(ok || ok)
+string(ok || true)
+string(ok)
+string(ok) < s == ok
+string(one(arr, true))
+string(s != "c")
+string(s != nil)
+string(s != s)
+string(s < "b")
+string(s <= "a")
+string(s <= s)
+string(s == s)
+string(s > s)
+string(s >= "b")
+string(s >= s)
+string(s contains "c")
+string(s contains s)
+string(s endsWith s)
+string(s in obj)
+string(s startsWith s)
+string(s)
+string(s) startsWith s
+string(s[a:a])
+string(string("b"))
+string(string("c"))
+string(string(0.5))
+string(string(1))
+string(string(2))
+string(string(a))
+string(string(add))
+string(string(arr))
+string(string(b))
+string(string(div))
+string(string(nil))
+string(string(obj?.head(obj, a)))
+string(string(ok))
+string(string(s))
+string(toJSON(2))
+string(toJSON(a))
+string(toJSON(arr))
+string(toJSON(b))
+string(toJSON(f))
+string(toJSON(nil))
+string(toJSON(ok))
+string(toJSON(s))
+string(trim("a"))
+string(trimSuffix("a"))
+string(true != nil)
+string(true ? "a" : div)
+string(true ? a : ok)
+string(true ? add : add)
+string(true ? arr : f)
+string(true ? div : b)
+string(true ? s : div)
+string(true) == s
+string(values(obj))
+string({"b": div, "b": nil})
+toBase64("c" + "c")
+toBase64(lower(s))
+toBase64(obj.head("b", add))
+toBase64(obj.head("b", arr, s, 2))
+toBase64(obj.head("c"))
+toBase64(obj.head(s))
+toBase64(obj.head(s, ok, 0))
+toBase64(obj?.head("c", div))
+toBase64(obj?.head(s))
+toBase64(obj?.head(s, arr, 1, b))
+toBase64(ok ? "a" : obj)
+toBase64(ok ? s : obj?.fn(div(1, ok), true ** obj))
+toBase64(s + s)
+toBase64(s)
+toBase64(s) != "a" ? false : 0
+toBase64(s) + s[b:a]
+toBase64(s) == obj.head(ok, false)
+toBase64(s) endsWith s
+toBase64(string(2))
+toBase64(string(a))
+toBase64(string(add))
+toBase64(string(arr))
+toBase64(string(b))
+toBase64(string(obj))
+toBase64(string(true))
+toBase64(toBase64("a"))
+toBase64(toBase64(s))
+toBase64(toJSON(a))
+toBase64(toJSON(b))
+toBase64(toJSON(f))
+toBase64(toJSON(nil))
+toBase64(toJSON(ok))
+toBase64(toJSON(s))
+toBase64(trim("c"))
+toBase64(trimPrefix("b"))
+toBase64(trimPrefix(s))
+toBase64(trimSuffix("b"))
+toBase64(trimSuffix(s))
+toBase64(true ? "b" : arr)
+toBase64(upper("b"))
+toJSON(!false)
+toJSON(!ok)
+toJSON(!true)
+toJSON("a" != nil)
+toJSON("a" == "b")
+toJSON("a" == nil)
+toJSON("a" == s)
+toJSON("a" contains s)
+toJSON("a" matches s)
+toJSON("a") >= trimSuffix("c")
+toJSON("b" != s)
+toJSON("b" < s)
+toJSON("b" <= "a")
+toJSON("b" == nil)
+toJSON("b" > "b")
+toJSON("b" >= s)
+toJSON("b" in obj)
+toJSON("b" matches "b")
+toJSON("b" matches s)
+toJSON("b") <= s
+toJSON("b") matches s
+toJSON("c" < "a")
+toJSON("c" <= s)
+toJSON("c" == nil)
+toJSON("c" endsWith "a")
+toJSON("c" matches "c")
+toJSON("c" startsWith "c")
+toJSON("c" startsWith s)
+toJSON("c") in obj
+toJSON("c") startsWith lower("c")
+toJSON(-(a - 0))
+toJSON(-(f - 0.5))
+toJSON(-0)
+toJSON(-0.5)
+toJSON(-1)
+toJSON(-2)
+toJSON(-a)
+toJSON(-b)
+toJSON(-f)
+toJSON(0 != 0)
+toJSON(0 != 1)
+toJSON(0 != 2)
+toJSON(0 != b)
+toJSON(0 != f)
+toJSON(0 % a)
+toJSON(0 % b)
+toJSON(0 * 1)
+toJSON(0 * f)
+toJSON(0 ** 0.5)
+toJSON(0 ** a)
+toJSON(0 + 1)
+toJSON(0 + a)
+toJSON(0 + b)
+toJSON(0 + f)
+toJSON(0 - 0)
+toJSON(0 - a)
+toJSON(0 - b)
+toJSON(0 .. 1)
+toJSON(0 .. 2)
+toJSON(0 .. a)
+toJSON(0 < 0)
+toJSON(0 < a)
+toJSON(0 < f)
+toJSON(0 <= 0)
+toJSON(0 <= a)
+toJSON(0 <= obj?.a)
+toJSON(0 == 0)
+toJSON(0 == 0.5)
+toJSON(0 == 1)
+toJSON(0 == a)
+toJSON(0 == nil)
+toJSON(0 >= 1)
+toJSON(0 >= a)
+toJSON(0 >= b)
+toJSON(0 >= f)
+toJSON(0 ^ 0.5)
+toJSON(0 ^ b)
+toJSON(0 in arr)
+toJSON(0) + s
+toJSON(0) in obj?.obj
+toJSON(0.5 != 1)
+toJSON(0.5 != a)
+toJSON(0.5 * 0.5)
+toJSON(0.5 * b)
+toJSON(0.5 * f)
+toJSON(0.5 ** 2)
+toJSON(0.5 - b)
+toJSON(0.5 / b)
+toJSON(0.5 < 0)
+toJSON(0.5 < b)
+toJSON(0.5 == b)
+toJSON(0.5 == f)
+toJSON(0.5 == nil)
+toJSON(0.5 > a)
+toJSON(0.5 >= 1)
+toJSON(0.5 >= f)
+toJSON(0.5 ^ 0)
+toJSON(0.5 ^ f)
+toJSON(0.5) contains s
+toJSON(1 != 2)
+toJSON(1 != b)
+toJSON(1 % a)
+toJSON(1 % b)
+toJSON(1 * 0)
+toJSON(1 ** 0)
+toJSON(1 + b)
+toJSON(1 - 0)
+toJSON(1 - 0.5)
+toJSON(1 - a)
+toJSON(1 == a)
+toJSON(1 > 0.5)
+toJSON(1 > b)
+toJSON(1 >= b)
+toJSON(1) startsWith s
+toJSON(1) startsWith string(0)
+toJSON(2 != 1)
+toJSON(2 != f)
+toJSON(2 % obj.a)
+toJSON(2 * 0)
+toJSON(2 * b)
+toJSON(2 + 2)
+toJSON(2 + f)
+toJSON(2 - 0.5)
+toJSON(2 - a)
+toJSON(2 .. a)
+toJSON(2 <= 1)
+toJSON(2 == f)
+toJSON(2 >= f)
+toJSON(2 ^ 0)
+toJSON(2 ^ a)
+toJSON(2 ^ b)
+toJSON([0])
+toJSON([b])
+toJSON(a != 0)
+toJSON(a != 0.5 and obj?.b)
+toJSON(a != b)
+toJSON(a != nil)
+toJSON(a % a)
+toJSON(a % b)
+toJSON(a * b)
+toJSON(a ** 0)
+toJSON(a ** 0.5)
+toJSON(a ** f)
+toJSON(a + 0.5)
+toJSON(a + 2)
+toJSON(a + b)
+toJSON(a + f)
+toJSON(a - 0)
+toJSON(a - 0.5)
+toJSON(a - a)
+toJSON(a .. 0)
+toJSON(a .. a)
+toJSON(a .. b)
+toJSON(a / 0.5)
+toJSON(a / b)
+toJSON(a < a)
+toJSON(a <= 0)
+toJSON(a <= 0.5)
+toJSON(a <= 1)
+toJSON(a <= a)
+toJSON(a <= b)
+toJSON(a <= f)
+toJSON(a == 0)
+toJSON(a == 0.5)
+toJSON(a == 2)
+toJSON(a == b)
+toJSON(a > 0)
+toJSON(a > 0.5)
+toJSON(a > b)
+toJSON(a > f)
+toJSON(a >= 0.5)
+toJSON(a >= a)
+toJSON(a >= b)
+toJSON(a >= f)
+toJSON(a >= obj.a)
+toJSON(a ^ f)
+toJSON(a)
+toJSON(a) != obj.obj
+toJSON(a) < s
+toJSON(a) == "c" ? 0.5 : nil
+toJSON(abs(0.5))
+toJSON(abs(a))
+toJSON(abs(b))
+toJSON(abs(obj.a))
+toJSON(add != div)
+toJSON(add != nil)
+toJSON(add != obj.b)
+toJSON(add == add)
+toJSON(add(0, a))
+toJSON(add(1, 2))
+toJSON(add(a, 0))
+toJSON(add(a, 1))
+toJSON(add(a, a))
+toJSON(add(b, 0))
+toJSON(add(b, 2))
+toJSON(add(b, b))
+toJSON(all(arr, ok))
+toJSON(any(arr, ok))
+toJSON(arr == arr)
+toJSON(arr == nil)
+toJSON(arr)
+toJSON(arr) > s
+toJSON(arr) endsWith s
+toJSON(arr) in obj?.obj
+toJSON(arr) matches "b" ? b : obj
+toJSON(arr[0])
+toJSON(arr[a])
+toJSON(arr[b:b])
+toJSON(arr[b])
+toJSON(b != 0)
+toJSON(b != b)
+toJSON(b % 1)
+toJSON(b * 0.5)
+toJSON(b * a)
+toJSON(b ** a)
+toJSON(b ** b)
+toJSON(b ** f)
+toJSON(b + 0.5)
+toJSON(b + 2)
+toJSON(b + f)
+toJSON(b + obj.a)
+toJSON(b - 0)
+toJSON(b - 2)
+toJSON(b - a)
+toJSON(b - b)
+toJSON(b - f)
+toJSON(b / b)
+toJSON(b < a)
+toJSON(b < f)
+toJSON(b <= 0)
+toJSON(b <= 2)
+toJSON(b <= a)
+toJSON(b <= b)
+toJSON(b == 0)
+toJSON(b == 0.5)
+toJSON(b == a)
+toJSON(b == f)
+toJSON(b == nil)
+toJSON(b > a)
+toJSON(b > b)
+toJSON(b > obj.a)
+toJSON(b >= b)
+toJSON(b >= f)
+toJSON(b ^ 2)
+toJSON(b)
+toJSON(b) != s
+toJSON(b) >= s
+toJSON(b) contains s
+toJSON(b) startsWith s
+toJSON(count(arr, false))
+toJSON(count(arr, true))
+toJSON(date("b", "b"))
+toJSON(div == add)
+toJSON(div == div)
+toJSON(div == nil)
+toJSON(div == obj.a)
+toJSON(div == obj?.b)
+toJSON(div(0, a))
+toJSON(div(1, a))
+toJSON(div(a, 2))
+toJSON(div(a, a))
+toJSON(div(a, b))
+toJSON(div(b, 2))
+toJSON(div(b, a))
+toJSON(div(b, b))
+toJSON(f != b)
+toJSON(f != f)
+toJSON(f != obj?.b)
+toJSON(f * a)
+toJSON(f * b)
+toJSON(f * f)
+toJSON(f ** a)
+toJSON(f ** b)
+toJSON(f ** f)
+toJSON(f + 0.5)
+toJSON(f + a)
+toJSON(f + b)
+toJSON(f - 0.5)
+toJSON(f - a)
+toJSON(f - b)
+toJSON(f - f)
+toJSON(f / a)
+toJSON(f < 0)
+toJSON(f < f)
+toJSON(f <= 0)
+toJSON(f <= f)
+toJSON(f == a)
+toJSON(f > 0)
+toJSON(f > 0.5)
+toJSON(f > a)
+toJSON(f > f)
+toJSON(f >= b)
+toJSON(f ^ 0.5)
+toJSON(f ^ 1)
+toJSON(f)
+toJSON(f) endsWith s
+toJSON(f) startsWith s
+toJSON(false ? false : 0)
+toJSON(false ? false : b)
+toJSON(false ? obj : 1)
+toJSON(false or ok)
+toJSON(false || true)
+toJSON(false) contains s
+toJSON(filter(arr, false))
+toJSON(filter(arr, ok))
+toJSON(first(arr))
+toJSON(float(2))
+toJSON(float(a))
+toJSON(float(b))
+toJSON(get(arr, 0))
+toJSON(get(arr, b))
+toJSON(get(obj, s))
+toJSON(get(obj, s)?.a)
+toJSON(int(0))
+toJSON(int(2))
+toJSON(int(a))
+toJSON(int(b))
+toJSON(int(f))
+toJSON(last(arr))
+toJSON(len("c"))
+toJSON(len(arr))
+toJSON(len(s))
+toJSON(lower("c"))
+toJSON(lower(s))
+toJSON(map(arr, "c"))
+toJSON(map(arr, 0))
+toJSON(map(arr, 0.5))
+toJSON(map(arr, 2))
+toJSON(map(arr, a))
+toJSON(map(arr, b))
+toJSON(map(arr, f))
+toJSON(map(arr, false))
+toJSON(map(arr, s))
+toJSON(max(0))
+toJSON(max(b))
+toJSON(max(f))
+toJSON(min(2))
+toJSON(min(a))
+toJSON(min(f))
+toJSON(nil != "b")
+toJSON(nil != 0)
+toJSON(nil != a)
+toJSON(nil != add)
+toJSON(nil != b)
+toJSON(nil != div)
+toJSON(nil != true)
+toJSON(nil == 0)
+toJSON(nil == a)
+toJSON(nil == arr)
+toJSON(nil == f)
+toJSON(nil == false)
+toJSON(nil == nil)
+toJSON(nil == s)
+toJSON(nil == true)
+toJSON(nil in arr)
+toJSON(nil in obj)
+toJSON(nil) < s
+toJSON(nil) endsWith s
+toJSON(nil) in obj
+toJSON(none(arr, false))
+toJSON(none(arr, true))
+toJSON(not false)
+toJSON(not ok)
+toJSON(not true)
+toJSON(obj != obj)
+toJSON(obj == nil)
+toJSON(obj.a <= f)
+toJSON(obj.a)
+toJSON(obj.b / a)
+toJSON(obj.b)
+toJSON(obj.c)
+toJSON(obj.fn(0))
+toJSON(obj.fn(a))
+toJSON(obj.fn(b))
+toJSON(obj.head(!true))
+toJSON(obj.head(0.5))
+toJSON(obj.head(1, 0.5, nil, f))
+toJSON(obj.head(2, a, div))
+toJSON(obj.head(a))
+toJSON(obj.head(a, "a"))
+toJSON(obj.head(a, ok))
+toJSON(obj.head(arr))
+toJSON(obj.head(arr, "c"))
+toJSON(obj.head(b))
+toJSON(obj.head(b, "a"))
+toJSON(obj.head(f))
+toJSON(obj.head(f, f))
+toJSON(obj.head(false))
+toJSON(obj.head(nil))
+toJSON(obj.head(nil, add))
+toJSON(obj.head(obj).a)
+toJSON(obj.head(obj)?.obj)
+toJSON(obj.head(obj?.b))
+toJSON(obj.head(ok))
+toJSON(obj.head(ok, div, ok, b, nil))
+toJSON(obj.head(s == f, div != s))
+toJSON(obj.head(s))
+toJSON(obj.head(s, add, 1))
+toJSON(obj.head(true, "b"))
+toJSON(obj.head(true, div))
+toJSON(obj.obj)
+toJSON(obj.obj.b)
+toJSON(obj.obj.obj)
+toJSON(obj.obj?.a)
+toJSON(obj.obj?.obj)
+toJSON(obj?.a)
+toJSON(obj?.b)
+toJSON(obj?.c)
+toJSON(obj?.fn(a))
+toJSON(obj?.fn(b))
+toJSON(obj?.head("a", 0, 0.5, "a"))
+toJSON(obj?.head("a", div))
+toJSON(obj?.head("c"))
+toJSON(obj?.head(-a))
+toJSON(obj?.head(0))
+toJSON(obj?.head(0, true))
+toJSON(obj?.head(1))
+toJSON(obj?.head(1, s, 1))
+toJSON(obj?.head(a))
+toJSON(obj?.head(a, 0, arr))
+toJSON(obj?.head(arr, nil, s, arr, "b"))
+toJSON(obj?.head(f))
+toJSON(obj?.head(f, b))
+toJSON(obj?.head(false))
+toJSON(obj?.head(nil))
+toJSON(obj?.head(ok, add, arr, ok))
+toJSON(obj?.obj)
+toJSON(obj?.obj[s])
+toJSON(obj[nil])
+toJSON(obj[s])
+toJSON(ok != nil)
+toJSON(ok != obj?.obj)
+toJSON(ok != ok)
+toJSON(ok != true)
+toJSON(ok && false)
+toJSON(ok == false)
+toJSON(ok == nil)
+toJSON(ok ? "b" : "c")
+toJSON(ok ? "b" : ok)
+toJSON(ok ? "c" : 0)
+toJSON(ok ? 0.5 : s)
+toJSON(ok ? 1 : a)
+toJSON(ok ? a : add)
+toJSON(ok ? a : arr)
+toJSON(ok ? arr : arr)
+toJSON(ok ? b : b)
+toJSON(ok ? f : div)
+toJSON(ok ? f : obj)
+toJSON(ok ? nil : div)
+toJSON(ok ? nil : true)
+toJSON(ok ? ok : b)
+toJSON(ok ? s : obj)
+toJSON(ok and ok)
+toJSON(ok || obj?.b)
+toJSON(ok || true)
+toJSON(ok)
+toJSON(ok) == obj?.a
+toJSON(ok) >= s
+toJSON(ok) >= toJSON(b)
+toJSON(one(arr, true))
+toJSON(repeat(s, 2))
+toJSON(s != "a")
+toJSON(s != nil)
+toJSON(s + "b")
+toJSON(s < "b")
+toJSON(s <= s)
+toJSON(s == "b")
+toJSON(s == nil)
+toJSON(s == s)
+toJSON(s > "a")
+toJSON(s > s)
+toJSON(s >= s)
+toJSON(s contains s)
+toJSON(s matches "b")
+toJSON(s matches s)
+toJSON(s startsWith "a")
+toJSON(s startsWith "c")
+toJSON(s startsWith s)
+toJSON(s)
+toJSON(s) in obj
+toJSON(s[0:0])
+toJSON(splitAfterN(s, s, 0))
+toJSON(string("a"))
+toJSON(string("c"))
+toJSON(string(0.5))
+toJSON(string(add))
+toJSON(string(arr))
+toJSON(string(div))
+toJSON(string(false))
+toJSON(string(obj))
+toJSON(string(ok))
+toJSON(string(true))
+toJSON(toBase64(s))
+toJSON(toJSON(0))
+toJSON(toJSON(2))
+toJSON(toJSON(a))
+toJSON(toJSON(arr))
+toJSON(toJSON(b))
+toJSON(toJSON(f))
+toJSON(toJSON(nil))
+toJSON(toJSON(ok))
+toJSON(toJSON(s))
+toJSON(trimPrefix("a"))
+toJSON(trimPrefix(s))
+toJSON(trimSuffix("b"))
+toJSON(trimSuffix("c"))
+toJSON(true != false)
+toJSON(true != ok)
+toJSON(true && ok)
+toJSON(true && true)
+toJSON(true ? arr : arr)
+toJSON(true ? b : add)
+toJSON(true ? false : s)
+toJSON(true ? ok : obj)
+toJSON(true ? ok : s)
+toJSON(true and false)
+toJSON(true and obj.obj)
+toJSON(true and ok)
+toJSON(true || ok)
+toJSON(true) + upper("a")
+toJSON(true) > obj?.head("a")
+toJSON(upper("a"))
+toJSON(upper(s))
+toJSON({"a": true, "b": 2, "c": a})
+trim("a") != s
+trim("b" + "a")
+trim("c" + "c")
+trim(b != b ? s : "b")
+trim(false ? obj : s)
+trim(lower(s))
+trim(obj.head("a"))
+trim(obj.head("a", 0))
+trim(obj.head("c"))
+trim(obj.head("c", obj))
+trim(obj.head("c", ok, 0.5))
+trim(obj.head(s))
+trim(obj.head(s, 1, ok))
+trim(obj.head(s, false, f), s)
+trim(obj?.head("c"))
+trim(obj?.head("c", a, nil, s, "a"))
+trim(obj?.head(s))
+trim(ok ? "a" : false)
+trim(s + s)
+trim(s)
+trim(s) != obj?.head(div, s, nil, add)
+trim(s) in obj?.obj
+trim(s) startsWith string(nil)
+trim(s, s)
+trim(s, toBase64("a"))
+trim(s, toBase64(s))
+trim(s[a:1])
+trim(s[a:b])
+trim(string("a"))
+trim(string(a))
+trim(string(b))
+trim(string(div))
+trim(string(false))
+trim(string(nil))
+trim(string(obj))
+trim(string(ok))
+trim(toBase64("a"))
+trim(toBase64(s))
+trim(toBase64(trim(s)))
+trim(toJSON(0 != a))
+trim(toJSON(0 + 0.5))
+trim(toJSON(b))
+trim(toJSON(false))
+trim(toJSON(nil != div))
+trim(toJSON(nil))
+trim(toJSON(ok))
+trim(toJSON(s))
+trim(toJSON(true))
+trim(trim(s))
+trim(trim(trimSuffix(s)))
+trim(trimPrefix("b"))
+trim(trimPrefix("c"))
+trim(trimSuffix("a"))
+trim(trimSuffix(s))
+trim(true ? "c" : add)
+trim(upper(s))
+trimPrefix("a" + "b")
+trimPrefix("a") == obj.head(b)
+trimPrefix("b" + "b")
+trimPrefix("c" + s)
+trimPrefix(lower("c"))
+trimPrefix(lower(s))
+trimPrefix(obj.head("b", s))
+trimPrefix(obj.head("c", f))
+trimPrefix(obj.head(s))
+trimPrefix(obj?.head("a", div))
+trimPrefix(obj?.head("c"))
+trimPrefix(obj?.head(s))
+trimPrefix(ok ? "c" : div)
+trimPrefix(ok ? s : obj)
+trimPrefix(s + s)
+trimPrefix(s)
+trimPrefix(s) > s
+trimPrefix(s, s)
+trimPrefix(s[0:2])
+trimPrefix(string("b"))
+trimPrefix(string(a))
+trimPrefix(string(arr))
+trimPrefix(string(b))
+trimPrefix(string(f))
+trimPrefix(string(false))
+trimPrefix(string(obj))
+trimPrefix(string(ok))
+trimPrefix(string(s))
+trimPrefix(toBase64("b"))
+trimPrefix(toBase64(s))
+trimPrefix(toJSON(0.5))
+trimPrefix(toJSON(1))
+trimPrefix(toJSON(2))
+trimPrefix(toJSON(ok))
+trimPrefix(toJSON(s))
+trimPrefix(trim("b"))
+trimPrefix(trim("c", "a"))
+trimPrefix(trim(s))
+trimPrefix(trimPrefix("b"))
+trimPrefix(trimPrefix(s))
+trimPrefix(trimSuffix("b"))
+trimPrefix(trimSuffix("c"))
+trimPrefix(trimSuffix(s))
+trimSuffix("b" + s)
+trimSuffix("b") contains s
+trimSuffix("c") endsWith s
+trimSuffix(false ? obj : s)
+trimSuffix(lower("b"))
+trimSuffix(obj.head("c", 0.5, arr, obj))
+trimSuffix(obj.head(s, nil, obj))
+trimSuffix(obj.head(toJSON(b, b, s, 0.5, nil)))
+trimSuffix(obj?.head("a"))
+trimSuffix(obj?.head("c"))
+trimSuffix(obj?.head("c", 0.5))
+trimSuffix(obj?.head(s))
+trimSuffix(obj?.head(s, 2, div))
+trimSuffix(obj?.head(s, div, true, b))
+trimSuffix(ok ? s : add)
+trimSuffix(repeat(s, 0))
+trimSuffix(s + "a")
+trimSuffix(s + "b")
+trimSuffix(s + "c")
+trimSuffix(s + s)
+trimSuffix(s)
+trimSuffix(s) == s
+trimSuffix(s) > s
+trimSuffix(s, "b") startsWith s
+trimSuffix(s, s)
+trimSuffix(string("a"))
+trimSuffix(string("b"))
+trimSuffix(string(0.5))
+trimSuffix(string(a))
+trimSuffix(string(add))
+trimSuffix(string(arr))
+trimSuffix(string(b))
+trimSuffix(string(false))
+trimSuffix(string(nil))
+trimSuffix(toJSON("a"))
+trimSuffix(toJSON("b"))
+trimSuffix(toJSON(a))
+trimSuffix(toJSON(arr))
+trimSuffix(toJSON(b))
+trimSuffix(toJSON(f))
+trimSuffix(toJSON(nil))
+trimSuffix(toJSON(obj?.head("b", add)))
+trimSuffix(toJSON(obj?.obj))
+trimSuffix(toJSON(ok))
+trimSuffix(toJSON(toJSON(s)))
+trimSuffix(toJSON(true))
+trimSuffix(trim("c"))
+trimSuffix(trim(s))
+trimSuffix(trimPrefix("a"))
+trimSuffix(trimPrefix("b"))
+trimSuffix(trimPrefix(s))
+trimSuffix(trimSuffix("b"))
+trimSuffix(trimSuffix("c"))
+trimSuffix(trimSuffix(s))
+trimSuffix(true ? s : a)
+trimSuffix(upper("b"))
+trimSuffix(upper(s))
+true != false && a != a
+true != false == obj.a
+true != nil or ok && ok
+true != obj.a
+true != obj.b
+true != obj.head(a % a)
+true != obj.obj
+true != obj.obj.a
+true != obj?.a
+true != obj?.b
+true != obj?.obj
+true != ok and arr != nil
+true != true || obj?.obj
+true && false or false ? f : add
+true && obj.a
+true && obj.b
+true && obj.obj
+true && obj.obj?.obj
+true && obj?.a
+true && obj?.b
+true && obj?.head(add)
+true && obj?.head(s)
+true && obj?.obj
+true && obj?.obj?.obj
+true && ok ? arr : b
+true && ok or ok
+true && true || ok
+true == nil != obj?.head(obj)
+true == nil in obj?.head(arr, div, obj)
+true == obj.a
+true == obj.b
+true == obj.head(ok ? one("b", ok) : arr)
+true == obj.obj
+true == obj.obj?.b
+true == obj?.a
+true == obj?.b
+true == obj?.head(b)
+true == obj?.obj
+true == ok != ok
+true == ok == obj.head(add)
+true == ok or obj.b
+true ? "a" : f > f
+true ? "b" : obj.obj
+true ? "b" : obj?.a
+true ? "b" : obj?.b
+true ? "c" : nil == ok
+true ? "c" : obj?.b
+true ? 0 : arr != nil != ok
+true ? 0 : obj?.b
+true ? 0 : obj?.obj
+true ? 0.5 : obj.a
+true ? 0.5 : obj.b
+true ? 0.5 : obj?.a
+true ? 1 : obj.head(s or obj)
+true ? 1 : obj?.head(s[obj])
+true ? 2 : obj.fn(b?.fn(div))
+true ? 2 : obj.fn(div(obj), keys(2), a?.a, ok * div)
+true ? 2 : obj.head(filter(arr, any(arr, div)))
+true ? 2 : obj.obj
+true ? 2 : obj?.fn(ok, b startsWith obj)
+true ? 2 : obj?.obj
+true ? a : b + f
+true ? a : obj.b
+true ? a : obj.fn(abs(true).a)
+true ? a : obj.obj
+true ? a : obj?.a
+true ? a : obj?.b
+true ? a : obj?.fn(f.a)
+true ? a : obj?.obj
+true ? add : obj.b
+true ? add : obj.fn(all(div(b), div(add)))
+true ? add : obj.obj
+true ? add : obj?.head(add(f, b))
+true ? arr : "c" + s
+true ? arr : a == obj.a
+true ? arr : nil == f
+true ? arr : obj.a
+true ? arr : obj.b
+true ? arr : obj.fn(arr?.head(f.fn(false)))
+true ? arr : obj.fn(s matches s)
+true ? arr : obj.head(keys(s >= obj, 1 .. true, any("a", a)), add(div.fn(add, 0.5, nil), a, add(f, false), a.a, -f)).b
+true ? arr : obj.obj
+true ? arr : obj?.a
+true ? b : 0 / b
+true ? b : 2 * obj.a
+true ? b : a >= b
+true ? b : div == div
+true ? b : nil != b
+true ? b : obj.a
+true ? b : obj.fn(a > obj)
+true ? b : obj.head(1 matches f.b, div(count(s, div), f < obj, obj?.obj, div(f)))
+true ? b : obj.obj
+true ? b : obj.obj?.obj
+true ? b : obj?.a
+true ? b : obj?.a.obj
+true ? b : obj?.b
+true ? div : obj.b
+true ? div : obj?.a
+true ? div : obj?.obj
+true ? f : 2 + a
+true ? f : arr[b]
+true ? f : f != obj.a
+true ? f : f < a ** 2
+true ? f : obj.head(add(f.b, ok, a?.head(s, 0, f, true)))
+true ? f : obj.head(none(b, "b"), a.a)
+true ? f : obj.obj
+true ? f : obj?.a?.obj
+true ? f : obj?.b
+true ? f : obj?.obj
+true ? f : obj?.obj.fn(div(obj)?.obj .. none(ok, s).obj)
+true ? f : obj?.obj?.obj
+true ? false : obj.a
+true ? false : obj.fn(none(obj, arr) startsWith b?.fn(f))
+true ? false : obj.head(div(any(0, b)))
+true ? false : obj?.head(add and div)
+true ? false : obj?.head(b)
+true ? nil : 0 % b
+true ? nil : a - f
+true ? nil : a <= obj.head(nil, "a", ok, nil)
+true ? nil : nil != b
+true ? nil : obj.head(all(add(add), f and 0.5))
+true ? nil : obj.obj
+true ? nil : obj.obj?.a
+true ? nil : obj?.b
+true ? nil : obj?.head(obj.obj < a.fn(false))
+true ? nil : obj?.obj
+true ? obj : f * f
+true ? obj : f + b - 1
+true ? obj : obj.a
+true ? obj : obj.b
+true ? obj : obj.fn(none(a, div or arr)).obj
+true ? obj : obj.fn(s.head(arr), ok > ok)
+true ? obj : obj.head(ok, map(arr, !ok))?.a?.a
+true ? obj : obj.head(values(s?.b), -b <= (ok and add))
+true ? obj : obj?.a
+true ? ok : b in obj.b
+true ? ok : obj.b
+true ? ok : obj.obj.obj
+true ? ok : obj?.b.b
+true ? ok : obj?.fn(not 0)
+true ? ok : obj?.obj
+true ? s : "a" matches s
+true ? s : arr in obj?.head(b)
+true ? s : f ^ (0.5 / b)
+true ? s : obj.a
+true ? s : obj.b
+true ? s : obj.head(div(add?.head(arr, f, 0.5)))
+true ? s : obj.obj
+true ? s : obj?.a
+true ? s : obj?.head(obj.a, div)
+true ? true : nil == obj.obj
+true ? true : obj.obj
+true ? true : ok && ok
+true and false ? b : obj
+true and obj.a
+true and obj.b
+true and obj.head(obj.obj)
+true and obj.obj
+true and obj?.a
+true and obj?.a >= b
+true and obj?.b
+true and obj?.obj
+true and obj?.obj == ok
+true and obj?.obj.obj
+true and ok and obj?.head(div)
+true or obj.a
+true or obj.a.a
+true or obj.a.obj
+true or obj.b
+true or obj.fn(a?.obj, b?.b, ok)
+true or obj.fn(b, add(add)?.obj).a
+true or obj.fn(div?.fn(add), ok?.head(div, b))
+true or obj.fn(join(b))
+true or obj.fn(s != add)
+true or obj.head(add?.a, false > div)
+true or obj.head(any(f, ok))
+true or obj.head(div(arr != b, add(add), 2 != arr, div || ok), b[b] >= ok > s, fromJSON(get(obj)))
+true or obj.head(duration(f.a))
+true or obj.head(filter(div, a) endsWith div.fn(obj, s, obj, b), arr.obj.obj, not b or a ? ok : true)
+true or obj.head(join(1))
+true or obj.head(none(ok?.b, count(0, 0.5)))
+true or obj.obj
+true or obj.obj.a?.obj
+true or obj.obj?.head(map(0.5, f) matches one(obj, "c"))
+true or obj?.a
+true or obj?.a.fn(ok + b?.fn(obj))
+true or obj?.a.head("c" * b matches not div)
+true or obj?.a?.a
+true or obj?.b
+true or obj?.fn(arr.b && obj?.head(b), ok.fn(obj .. arr))
+true or obj?.fn(div(b, arr) and obj?.b, obj[add(b)])
+true or obj?.fn(f, f).a
+true or obj?.fn(hasPrefix(add(ok)))
+true or obj?.fn(map(not ok, "b" < add), map("b" && a, one(0, add)))
+true or obj?.head(add(f))
+true or obj?.head(one(none(add, add), add?.b))
+true or obj?.obj
+true or obj?.obj.head(get(add(s), div))
+true or ok || obj.a
+true || obj.a
+true || obj.a.a
+true || obj.b
+true || obj.fn((add || div) - b)
+true || obj.fn(arr, any(add(arr, ok, div), 0 startsWith false))
+true || obj.head(a?.fn(arr contains b, div?.head(0, add, false), obj.head(0.5), values(f), s.b))?.a
+true || obj.head(add(abs(b)))
+true || obj.head(add(ok.obj), any(add, f) != obj.head(b, add, arr))
+true || obj.head(all(f, 0), div("a", true))
+true || obj.head(count("a", obj))
+true || obj.head(f.b)
+true || obj.head(f?.fn(0) <= b.b)
+true || obj.head(filter(add.head(s), map(s, 0.5)))
+true || obj.head(obj.b)
+true || obj.head(obj?.fn(b))
+true || obj.obj
+true || obj.obj == add
+true || obj.obj.a
+true || obj.obj?.b
+true || obj.obj?.obj
+true || obj?.a
+true || obj?.b
+true || obj?.fn(a?.head(div(div)), 2 .. add?.b)
+true || obj?.fn(div * a == ok?.b)
+true || obj?.fn(div(0.5 && 0.5, s?.head(0.5))).a
+true || obj?.fn(get(a, arr))
+true || obj?.head(all(f.b, #))
+true || obj?.head(div(nil, "b"), add(nil, f))
+true || obj?.head(repeat(now(true, div, b, ok)), now(s, div(add, "c"))).a
+true || obj?.head(true == nil)
+true || obj?.obj
+true || true or obj.obj
+upper("a" + "a")
+upper("a") startsWith s
+upper("b") < s
+upper("b") <= s
+upper("c") <= s
+upper(f >= 2 ? b : s)
+upper(false ? 0.5 : s)
+upper(lower(s))
+upper(obj.head(s))
+upper(obj.head(s, arr, obj))
+upper(obj.head(s, ok))
+upper(obj?.head("a"))
+upper(obj?.head("b"))
+upper(obj?.head(s))
+upper(obj?.head(s, f))
+upper(ok ? s : ok)
+upper(s + s)
+upper(s)
+upper(s) <= s
+upper(s) matches s
+upper(string("a"))
+upper(string("b"))
+upper(string(0))
+upper(string(0.5))
+upper(string(a))
+upper(string(add))
+upper(string(b))
+upper(string(f))
+upper(string(nil))
+upper(string(obj))
+upper(string(ok))
+upper(string(true))
+upper(toBase64("c"))
+upper(toBase64(s))
+upper(toJSON("c"))
+upper(toJSON(2))
+upper(toJSON(a))
+upper(toJSON(arr))
+upper(toJSON(f))
+upper(toJSON(false))
+upper(toJSON(ok))
+upper(toJSON(s))
+upper(toJSON(true))
+upper(trim("c"))
+upper(trim(s))
+upper(trimPrefix(s))
+upper(trimSuffix("a"))
+upper(trimSuffix(s))
+upper(upper(s))
+values(obj)
+values(obj) != obj?.obj
+values(obj)[a]
+{"a": "a", "c": a}.obj
+{"a": "a"}?.obj
+{"a": "c"}?.a
+{"a": 0 > b}
+{"a": 0, "a": "a", "a": nil, "c": ok}.b
+{"a": 0, "b": f}.obj
+{"a": 0, "c": 0.5}.a
+{"a": 0.5, "a": s}?.b
+{"a": 0.5, "b": b}?.obj
+{"a": 0.5, "b": obj}?.obj
+{"a": 0.5, "c": a}.b
+{"a": 0.5, "c": false, "c": arr, "c": obj}.b
+{"a": 0}.b
+{"a": 0}?.a
+{"a": 0}?.b
+{"a": 0}?.obj
+{"a": 1}.b
+{"a": 1}.obj
+{"a": 2 >= 1}
+{"a": 2, "a": obj, "b": ok}?.obj
+{"a": 2, "b": a, "b": f}.b
+{"a": 2}.b
+{"a": a - 1}
+{"a": a / 0.5}
+{"a": a, "a": arr}
+{"a": a, "a": b, "a": "b", "c": f, "c": ok}?.obj
+{"a": a, "a": div}?.obj?.a
+{"a": a, "a": ok}?.b
+{"a": a, "b": obj?.b}
+{"a": a, "c": add, "c": nil}?.obj?.b
+{"a": a, "c": obj.a}
+{"a": a, "c": s, "b": nil}?.a
+{"a": add(b, 2)}
+{"a": add(b, b)}
+{"a": add, "a": ok ? add : obj}?.b
+{"a": add, "a": s, "b": div}.b
+{"a": add}
+{"a": add}.a
+{"a": arr, "b": 1, "c": 0.5, "b": f}?.b
+{"a": arr, "c": arr}
+{"a": arr}
+{"a": arr} == obj
+{"a": arr}.a
+{"a": arr}.b
+{"a": a}
+{"a": a}.obj
+{"a": a}?.a
+{"a": a}?.obj
+{"a": b + b}
+{"a": b - a}
+{"a": b - f}
+{"a": b / b}
+{"a": b, "a": obj, "a": div}?.b
+{"a": b, "a": ok}
+{"a": b, "b": a, "c": 0}?.b
+{"a": b, "b": s, "b": s}.b
+{"a": b, "c": "b"}.a
+{"a": b, "c": b}?.a
+{"a": b}
+{"a": b}.a
+{"a": b}.b
+{"a": b}.obj
+{"a": b}?.a
+{"a": b}?.b
+{"a": b}?.obj
+{"a": b}?.obj?.obj
+{"a": div == nil}
+{"a": div, "a": b, "c": nil, "a": 0}?.obj
+{"a": div, "a": ok, "b": s}.a
+{"a": div, "b": arr}.b
+{"a": div, "c": nil}.a
+{"a": div, "c": true}.b
+{"a": div}
+{"a": div}.b
+{"a": div}.obj
+{"a": div}?.obj
+{"a": f, "a": add}.b
+{"a": f, "a": obj}?.b
+{"a": f, "b": div(b, a)}
+{"a": false, "b": 1}?.b
+{"a": false}.obj
+{"a": f}
+{"a": f}.a
+{"a": f}.obj
+{"a": f}?.a
+{"a": f}?.obj
+{"a": map(arr, a)}
+{"a": map(arr, obj)}
+{"a": nil, "a": b}.a
+{"a": nil, "b": 1}?.b
+{"a": nil}.obj
+{"a": nil}?.a
+{"a": obj, "a": arr}.a
+{"a": obj, "a": nil}?.b
+{"a": obj, "b": obj?.obj, "a": add}
+{"a": obj, "b": obj}.b
+{"a": obj, "c": f, "a": true}.obj
+{"a": obj, "c": false, "b": arr, "b": "b"}?.a
+{"a": obj.a}
+{"a": obj.b}
+{"a": obj.head(b, ok, nil)}
+{"a": obj.obj}
+{"a": obj?.a}
+{"a": obj?.head(arr)}
+{"a": obj?.head(b)}
+{"a": obj?.head(f)}
+{"a": obj?.head(obj, nil, s, false)}
+{"a": obj?.obj}.b
+{"a": obj}
+{"a": obj}.b
+{"a": obj}.obj
+{"a": obj}?.b
+{"a": ok, "b": f}
+{"a": ok, "b": ok}?.obj
+{"a": ok}
+{"a": ok}.a
+{"a": ok}.b
+{"a": ok}?.a
+{"a": ok}?.obj
+{"a": s, "a": "a", "a": b}.a
+{"a": s, "a": arr}?.obj
+{"a": s, "a": b}.obj
+{"a": s, "a": obj}.b
+{"a": s, "b": nil, "c": add}?.b?.obj
+{"a": s, "c": div}.obj
+{"a": s, "c": div}?.a
+{"a": string(f)}
+{"a": s}
+{"a": s}.a
+{"a": toBase64("a")}
+{"a": true || true}
+{"a": true}.a
+{"a": true}.b
+{"a": true}?.a
+{"b": "a", "a": "b", "a": add}.a
+{"b": "a", "b": add, "a": div}?.obj
+{"b": "a"}?.a
+{"b": "b", "b": "b"}.a
+{"b": "b", "b": arr, "b": a}.obj
+{"b": "b", "b": true}?.a
+{"b": "c", "b": "a"}.a
+{"b": 0 == a, "a": ok}
+{"b": 0, "c": arr}.b
+{"b": 0.5, "b": arr, "a": 0}?.b
+{"b": 0.5, "c": f, "b": div, "c": ok}?.b
+{"b": 0.5, "c": ok}.b
+{"b": 0}.obj
+{"b": 0}.obj?.obj != div
+{"b": 0}?.a
+{"b": 0}?.obj
+{"b": 1 .. a}
+{"b": 1 < b}
+{"b": 1, "c": f}?.a
+{"b": 1}.a
+{"b": 2, "b": a}?.a
+{"b": 2}?.b
+{"b": a, "a": add}
+{"b": a, "a": false, "c": arr}.obj
+{"b": a, "c": b != a}
+{"b": add, "a": a, "a": div, "a": nil, "a": a}.obj
+{"b": add, "a": true, "b": 0, "c": 0.5, "b": nil}.obj
+{"b": add, "b": ok}?.a
+{"b": add, "b": s}.b
+{"b": add}
+{"b": add}.b
+{"b": add}.obj?.obj
+{"b": add}?.obj
+{"b": arr, "a": arr, "b": add}?.obj
+{"b": arr, "a": div}
+{"b": arr, "b": add}
+{"b": arr, "b": f, "b": arr, "b": 0}?.b
+{"b": arr, "c": f, "a": nil}[s]?.a
+{"b": arr}
+{"b": arr}?.a
+{"b": a}
+{"b": a}.a
+{"b": a}.b
+{"b": a}?.obj
+{"b": b .. b}
+{"b": b < f}
+{"b": b == a}
+{"b": b, "a": ok}?.a
+{"b": b, "b": 0, "b": b}.obj
+{"b": b, "b": a}?.a
+{"b": b, "b": div, "b": arr, "b": add}.a
+{"b": b, "b": obj.obj}
+{"b": b, "c": a}.obj
+{"b": b}
+{"b": b}.a
+{"b": b}.obj
+{"b": b}?.a
+{"b": b}?.obj
+{"b": div, "a": a > a}
+{"b": div, "a": arr, "a": obj, "c": 0}.a
+{"b": div, "b": add}?.b
+{"b": div, "c": ok, "c": 2}?.obj
+{"b": div}
+{"b": div}.b
+{"b": div}?.a
+{"b": div}?.obj
+{"b": f != 0}
+{"b": f <= 0.5}
+{"b": f, "a": false}?.a
+{"b": f, "b": add}?.obj
+{"b": f, "b": s}?.obj
+{"b": f, "c": arr, "b": div}?.obj
+{"b": f, "c": arr, "b": f}.a
+{"b": f, "c": f}?.a
+{"b": false ? 0 : 2}
+{"b": false, "a": obj}.b
+{"b": false, "c": s}.a
+{"b": f}
+{"b": f}?.a?.a
+{"b": f}?.obj
+{"b": nil == nil, "c": obj?.obj}?.b
+{"b": nil, "a": f, "b": "c"}.obj
+{"b": nil, "a": f, "c": 1}.obj
+{"b": nil, "a": obj, "a": f}.a
+{"b": nil, "a": obj}.b
+{"b": nil, "b": b}.b
+{"b": nil, "b": div}.b
+{"b": nil, "b": true}.b
+{"b": nil, "c": div, "c": div}.b
+{"b": nil}.obj
+{"b": nil}?.a
+{"b": not ok, "a": a}
+{"b": not ok}
+{"b": obj != obj.b}
+{"b": obj, "a": add, "c": s}.a
+{"b": obj, "a": a}?.obj
+{"b": obj, "c": f, "b": nil}?.a
+{"b": obj.a}
+{"b": obj.b}
+{"b": obj.head("b")}
+{"b": obj.head(nil, b, obj)}
+{"b": obj.head(s)}
+{"b": obj.obj}
+{"b": obj?.a}
+{"b": obj?.b}
+{"b": obj}
+{"b": obj}.b
+{"b": obj}.b?.a
+{"b": obj}.obj
+{"b": obj}?.b
+{"b": ok, "a": a}.obj
+{"b": ok, "a": b}.obj
+{"b": ok, "c": 1, "c": f}?.a
+{"b": ok}
+{"b": ok}.obj
+{"b": ok}?.a
+{"b": s, "a": b, "c": obj, "b": f}?.obj
+{"b": s, "b": 0, "b": nil, "c": 0}?.a
+{"b": s, "b": f}?.obj
+{"b": s, "c": "a", "b": div, "c": 1}.b
+{"b": string(div)}
+{"b": s}
+{"b": s}.a
+{"b": s}?.a
+{"b": true ? obj : add}
+{"b": true, "b": arr, "a": add} == obj ? add : b
+{"b": true}.obj
+{"b": true}?.obj
+{"c": "a", "a": obj, "c": "b"}?.b?.obj?.b
+{"c": "a", "c": obj}.b
+{"c": "a"}?.a
+{"c": "b", "b": false}?.obj
+{"c": "b"}.a
+{"c": "b"}.obj
+{"c": "b"}?.obj
+{"c": "c"}?.obj?.fn(arr)
+{"c": 0 ** 0, "c": ok ? arr : f}
+{"c": 0, "a": s, "c": add}.b
+{"c": 0, "c": 0, "a": "b", "b": false}.b
+{"c": 0, "c": f, "b": false}?.obj
+{"c": 0, "c": f}.a
+{"c": 0, "c": obj}?.a?.a
+{"c": 0, "c": s, "b": s, "c": false, "b": obj}.a
+{"c": 0.5, "b": b, "c": a, "b": 2}?.b
+{"c": 0.5, "c": b, "b": 0}.b
+{"c": 0.5, "c": true, "a": true}.b
+{"c": 0}.b
+{"c": 0}.obj
+{"c": 1, "b": ok}?.b
+{"c": 1}?.a
+{"c": 2, "a": "c"}.b
+{"c": 2}.a
+{"c": 2}?.b
+{"c": a != 1}
+{"c": a .. 2}.obj
+{"c": a / 0}
+{"c": a <= 1}
+{"c": a, "a": arr}?.obj
+{"c": a, "a": b, "b": div, "b": f, "b": div}.b
+{"c": a, "b": ok ? "c" : div}
+{"c": a, "b": s, "a": s, "c": b, "a": add}.obj
+{"c": a, "c": true}?.obj
+{"c": abs(a)}
+{"c": add, "a": true, "b": s}?.a
+{"c": add, "b": 0, "b": b, "b": 1}?.obj
+{"c": add, "b": 0.5, "c": arr}?.obj
+{"c": add, "b": a, "b": s}?.a
+{"c": add, "b": arr}?.obj
+{"c": add, "b": obj, "b": false}?.b
+{"c": add, "b": ok, "b": f, "b": s}.a
+{"c": add, "c": arr}
+{"c": add, "c": b}?.b
+{"c": add}
+{"c": add}.a?.obj
+{"c": add}.b
+{"c": add}.obj
+{"c": add}?.a
+{"c": arr != nil}
+{"c": arr == arr}
+{"c": arr, "a": nil, "b": b}.obj
+{"c": arr, "c": arr}?.a
+{"c": arr, "c": s}.obj
+{"c": arr}
+{"c": arr}.a
+{"c": arr}.obj
+{"c": arr}?.b
+{"c": arr}?.obj
+{"c": arr}?.obj?.b
+{"c": a}
+{"c": a}.a
+{"c": a}.obj
+{"c": a}?.a
+{"c": b % a}
+{"c": b, "a": obj, "b": 0.5, "a": obj, "a": s}.b
+{"c": b, "c": "c", "a": f, "b": div, "c": b}?.obj
+{"c": b, "c": f, "a": arr}?.b
+{"c": b}
+{"c": b}.a
+{"c": b}.obj
+{"c": b}?.b
+{"c": b}?.obj
+{"c": div, "a": a}
+{"c": div, "a": ok, "b": obj}?.obj
+{"c": div, "b": add}.obj
+{"c": div, "b": b, "a": arr, "b": true}.b
+{"c": div, "c": ok}?.a
+{"c": div}
+{"c": div}.a
+{"c": div}.b
+{"c": div}.obj
+{"c": div}?.b
+{"c": f - f}
+{"c": f, "a": "b", "b": "a", "b": 0.5}?.b
+{"c": f, "b": 0.5}.b
+{"c": f, "b": add, "a": a}.b
+{"c": f, "b": obj, "b": 2}?.obj
+{"c": false}?.b
+{"c": first(arr)}.a
+{"c": f}
+{"c": f}.a
+{"c": f}.obj
+{"c": f}?.a
+{"c": f}?.obj
+{"c": get(arr, a), "a": a != nil}
+{"c": get(arr, b)}
+{"c": get(obj, s)}
+{"c": nil, "a": false, "c": arr, "a": f, "a": nil}.b
+{"c": nil, "b": false}?.a
+{"c": nil}.a
+{"c": nil}.b
+{"c": nil}?.a
+{"c": obj, "a": div}.b
+{"c": obj, "b": b}?.a
+{"c": obj, "c": add}
+{"c": obj, "c": nil}?.b
+{"c": obj.fn(a)}
+{"c": obj.head(arr, f), "a": div, "b": s}.obj
+{"c": obj.head(div)}
+{"c": obj.obj}
+{"c": obj?.a}
+{"c": obj?.obj}
+{"c": obj}
+{"c": obj}.a
+{"c": obj}.b
+{"c": obj}.obj
+{"c": obj}?.a
+{"c": obj}?.b
+{"c": ok and ok}
+{"c": ok, "c": 0}?.a
+{"c": ok}
+{"c": ok}.b
+{"c": s, "a": b}?.a
+{"c": s, "b": a}?.b
+{"c": s, "b": f}?.a
+{"c": s, "b": obj, "a": div}?.a
+{"c": s, "c": "c", "b": false, "a": a}?.a
+{"c": s, "c": add, "b": arr, "a": ok, "b": obj}?.obj
+{"c": s, "c": div}.obj
+{"c": s}
+{"c": s}.b
+{"c": s}.obj
+{"c": toBase64(s)}
+{"c": toJSON(a)}
+{"c": true, "c": a}.obj
+{"c": true}?.b
diff --git a/testdata/fuzz/FuzzExpr/1fedafb72e35699d b/testdata/fuzz/FuzzExpr/1fedafb72e35699d
deleted file mode 100644
index fb2cb204e..000000000
--- a/testdata/fuzz/FuzzExpr/1fedafb72e35699d
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("one(m[\"\"],#)")
diff --git a/testdata/fuzz/FuzzExpr/37464e3dcb75a05c b/testdata/fuzz/FuzzExpr/37464e3dcb75a05c
deleted file mode 100644
index 992d44c28..000000000
--- a/testdata/fuzz/FuzzExpr/37464e3dcb75a05c
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("repeat(\"0\",1/0)")
diff --git a/testdata/fuzz/FuzzExpr/42564f0e9eda1ad1 b/testdata/fuzz/FuzzExpr/42564f0e9eda1ad1
deleted file mode 100644
index 7c21a804e..000000000
--- a/testdata/fuzz/FuzzExpr/42564f0e9eda1ad1
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("duration(\"0A\")")
diff --git a/testdata/fuzz/FuzzExpr/b1aef962e961045a b/testdata/fuzz/FuzzExpr/b1aef962e961045a
deleted file mode 100644
index c5c870587..000000000
--- a/testdata/fuzz/FuzzExpr/b1aef962e961045a
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("fn()")
diff --git a/testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c b/testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c
deleted file mode 100644
index fb870a2c8..000000000
--- a/testdata/fuzz/FuzzExpr/bb7a381b0a9ef95c
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("fromJSON(\"A\")")
diff --git a/testdata/fuzz/FuzzExpr/c6717d9f77902b9c b/testdata/fuzz/FuzzExpr/c6717d9f77902b9c
deleted file mode 100644
index 0f3984207..000000000
--- a/testdata/fuzz/FuzzExpr/c6717d9f77902b9c
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("toJSON(2^1070)")
diff --git a/testdata/fuzz/FuzzExpr/cd662894c578ed90 b/testdata/fuzz/FuzzExpr/cd662894c578ed90
deleted file mode 100644
index d6b71bb6f..000000000
--- a/testdata/fuzz/FuzzExpr/cd662894c578ed90
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("duration(\"\")")
diff --git a/testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd b/testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd
deleted file mode 100644
index 7790bd025..000000000
--- a/testdata/fuzz/FuzzExpr/d0974d3e16e6f0fd
+++ /dev/null
@@ -1,2 +0,0 @@
-go test fuzz v1
-string("fromJSON(\"\")")

From 7a61bfd5b60328c824c8b65be2aeab32308b6817 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 15:33:04 +0200
Subject: [PATCH 089/506] Update README.md

---
 README.md | 32 ++++++++++++++++++--------------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index 5c0a1e027..4456f456d 100644
--- a/README.md
+++ b/README.md
@@ -145,20 +145,24 @@ func main() {
 
 ## Who uses Expr?
 
-* [Aviasales](https://aviasales.ru) uses Expr as a business rule engine for our flight search engine.
-* [Wish.com](https://www.wish.com) uses Expr for decision-making rule engine in the Wish Assistant.
-* [Argo](https://argoproj.github.io) uses Expr in Argo Rollouts and Argo Workflows for Kubernetes.
-* [Crowdsec](https://crowdsec.net) uses Expr in a security automation tool.
-* [FACEIT](https://www.faceit.com) uses Expr to allow customization of its eSports matchmaking algorithm.
-* [qiniu](https://www.qiniu.com) uses Expr in trade systems.
-* [Junglee Games](https://www.jungleegames.com/) uses Expr for an in house marketing retention tool [Project Audience](https://www.linkedin.com/pulse/meet-project-audience-our-no-code-swiss-army-knife-product-bharti).
-* [OpenTelemetry](https://opentelemetry.io) uses Expr in the OpenTelemetry Collector.
-* [Philips Labs](https://github.com/philips-labs/tabia) uses Expr in Tabia, a tool for collecting insights on the characteristics of our code bases.
-* [CoreDNS](https://coredns.io) uses Expr in CoreDNS, a DNS server.
-* [Chaos Mesh](https://chaos-mesh.org) uses Expr in Chaos Mesh, a cloud-native Chaos Engineering platform.
-* [Milvus](https://milvus.io) uses Expr in Milvus, an open-source vector database.
-* [Visually.io](https://visually.io) uses Expr as a business rule engine for our personalization targeting algorithm.
-* [Akvorado](https://github.com/akvorado/akvorado) uses Expr to classify exporters and interfaces in network flows.
+* [Google](https://google.com) uses Expr as one of its expression languages on the [Google Cloud Platform](https://cloud.google.com).
+* [Uber](https://uber.com) uses Expr to allow customization of its Uber Eats marketplace.
+* [GoDaddy](https://godaddy.com) employs Expr for the customization of its GoDaddy Pro product.
+* [ByteDance](https://bytedance.com) incorporates Expr into its internal business rule engine.
+* [Aviasales](https://aviasales.ru) utilizes Expr as a business rule engine for its flight search engine.
+* [Wish.com](https://www.wish.com) employs Expr in its decision-making rule engine for the Wish Assistant.
+* [Argo](https://argoproj.github.io) integrates Expr into Argo Rollouts and Argo Workflows for Kubernetes.
+* [Crowdsec](https://crowdsec.net) incorporates Expr into its security automation tool.
+* [FACEIT](https://www.faceit.com) uses Expr to enhance customization of its eSports matchmaking algorithm.
+* [qiniu](https://www.qiniu.com) implements Expr in its trade systems.
+* [Junglee Games](https://www.jungleegames.com/) uses Expr for its in-house marketing retention tool, Project Audience.
+* [OpenTelemetry](https://opentelemetry.io) integrates Expr into the OpenTelemetry Collector.
+* [Philips Labs](https://github.com/philips-labs/tabia) employs Expr in Tabia, a tool designed to collect insights on the characteristics of their code bases.
+* [CoreDNS](https://coredns.io) uses Expr in CoreDNS, which is a DNS server.
+* [Chaos Mesh](https://chaos-mesh.org) incorporates Expr into Chaos Mesh, a cloud-native Chaos Engineering platform.
+* [Milvus](https://milvus.io) integrates Expr into Milvus, an open-source vector database.
+* [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
+* [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 
 [Add your company too](https://github.com/antonmedv/expr/edit/master/README.md)
 

From 06dd006d14f6b2d9fa3edf6ffa178484457ff3d4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 15:36:31 +0200
Subject: [PATCH 090/506] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4456f456d..054409df2 100644
--- a/README.md
+++ b/README.md
@@ -157,7 +157,7 @@ func main() {
 * [qiniu](https://www.qiniu.com) implements Expr in its trade systems.
 * [Junglee Games](https://www.jungleegames.com/) uses Expr for its in-house marketing retention tool, Project Audience.
 * [OpenTelemetry](https://opentelemetry.io) integrates Expr into the OpenTelemetry Collector.
-* [Philips Labs](https://github.com/philips-labs/tabia) employs Expr in Tabia, a tool designed to collect insights on the characteristics of their code bases.
+* [Philips Labs](https://github.com/philips-labs/tabia) employs Expr in Tabia, a tool designed to collect insights on their code bases.
 * [CoreDNS](https://coredns.io) uses Expr in CoreDNS, which is a DNS server.
 * [Chaos Mesh](https://chaos-mesh.org) incorporates Expr into Chaos Mesh, a cloud-native Chaos Engineering platform.
 * [Milvus](https://milvus.io) integrates Expr into Milvus, an open-source vector database.

From b22c301c16c31f65951d258e557a7753398034af Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 18 Aug 2023 22:08:19 +0200
Subject: [PATCH 091/506] Add crowdsec testdata

---
 test/crowdsec/crowdsec.go      | 196 ++++++++++
 test/crowdsec/crowdsec_test.go |  47 +++
 test/crowdsec/funcs.go         | 353 +++++++++++++++++
 testdata/crowdsec.json         | 675 +++++++++++++++++++++++++++++++++
 4 files changed, 1271 insertions(+)
 create mode 100644 test/crowdsec/crowdsec.go
 create mode 100644 test/crowdsec/crowdsec_test.go
 create mode 100644 test/crowdsec/funcs.go
 create mode 100644 testdata/crowdsec.json

diff --git a/test/crowdsec/crowdsec.go b/test/crowdsec/crowdsec.go
new file mode 100644
index 000000000..e1ec1becb
--- /dev/null
+++ b/test/crowdsec/crowdsec.go
@@ -0,0 +1,196 @@
+package crowdsec
+
+import (
+	"time"
+)
+
+type Event struct {
+	Type            int                    `yaml:"Type,omitempty" json:"Type,omitempty"`
+	ExpectMode      int                    `yaml:"ExpectMode,omitempty" json:"ExpectMode,omitempty"`
+	Whitelisted     bool                   `yaml:"Whitelisted,omitempty" json:"Whitelisted,omitempty"`
+	WhitelistReason string                 `yaml:"WhitelistReason,omitempty" json:"whitelist_reason,omitempty"`
+	Stage           string                 `yaml:"Stage,omitempty" json:"Stage,omitempty"`
+	Line            Line                   `yaml:"Line,omitempty" json:"Line,omitempty"`
+	Parsed          map[string]string      `yaml:"Parsed,omitempty" json:"Parsed,omitempty"`
+	Enriched        map[string]string      `yaml:"Enriched,omitempty" json:"Enriched,omitempty"`
+	Unmarshaled     map[string]interface{} `yaml:"Unmarshaled,omitempty" json:"Unmarshaled,omitempty"`
+	Overflow        RuntimeAlert           `yaml:"Overflow,omitempty" json:"Alert,omitempty"`
+	Time            time.Time              `yaml:"Time,omitempty" json:"Time,omitempty"`
+	StrTime         string                 `yaml:"StrTime,omitempty" json:"StrTime,omitempty"`
+	StrTimeFormat   string                 `yaml:"StrTimeFormat,omitempty" json:"StrTimeFormat,omitempty"`
+	MarshaledTime   string                 `yaml:"MarshaledTime,omitempty" json:"MarshaledTime,omitempty"`
+	Process         bool                   `yaml:"Process,omitempty" json:"Process,omitempty"`
+	Meta            map[string]string      `yaml:"Meta,omitempty" json:"Meta,omitempty"`
+}
+
+func (e *Event) GetType() string {
+	return ""
+}
+
+func (e *Event) GetMeta(key string) string {
+	return ""
+}
+
+type Alert struct {
+	Capacity        *int32      `json:"capacity"`
+	CreatedAt       string      `json:"created_at,omitempty"`
+	Decisions       []*Decision `json:"decisions"`
+	Events          []*Event    `json:"events"`
+	EventsCount     *int32      `json:"events_count"`
+	ID              int64       `json:"id,omitempty"`
+	Labels          []string    `json:"labels"`
+	Leakspeed       *string     `json:"leakspeed"`
+	MachineID       string      `json:"machine_id,omitempty"`
+	Message         *string     `json:"message"`
+	Meta            Meta        `json:"meta,omitempty"`
+	Remediation     bool        `json:"remediation,omitempty"`
+	Scenario        *string     `json:"scenario"`
+	ScenarioHash    *string     `json:"scenario_hash"`
+	ScenarioVersion *string     `json:"scenario_version"`
+	Simulated       *bool       `json:"simulated"`
+	Source          *Source     `json:"source"`
+	StartAt         *string     `json:"start_at"`
+	StopAt          *string     `json:"stop_at"`
+	UUID            string      `json:"uuid,omitempty"`
+	Edges           AlertEdges  `json:"edges"`
+}
+
+func (a *Alert) HasRemediation() bool {
+	return true
+}
+
+func (a *Alert) GetScope() string {
+	return ""
+}
+
+func (a *Alert) GetValue() string {
+	return ""
+}
+
+func (a *Alert) GetScenario() string {
+	return ""
+}
+
+func (a *Alert) GetEventsCount() int32 {
+	return 0
+}
+
+func (a *Alert) GetMeta(_ string) string {
+	return ""
+}
+
+func (s Source) GetValue() string {
+	return *s.Value
+}
+
+func (s Source) GetScope() string {
+	return *s.Scope
+}
+
+func (s Source) GetAsNumberName() string {
+	return ""
+}
+
+type AlertEdges struct {
+	Owner     *Machine    `json:"owner,omitempty"`
+	Decisions []*Decision `json:"decisions,omitempty"`
+	Events    []*Event    `json:"events,omitempty"`
+	Metas     []*Meta     `json:"metas,omitempty"`
+}
+
+func (e AlertEdges) OwnerOrErr() (*Machine, error) {
+	return nil, nil
+}
+
+func (e AlertEdges) DecisionsOrErr() ([]*Decision, error) {
+	return nil, nil
+}
+
+func (e AlertEdges) EventsOrErr() ([]*Event, error) {
+	return nil, nil
+}
+
+func (e AlertEdges) MetasOrErr() ([]*Meta, error) {
+	return nil, nil
+}
+
+type Machine struct {
+	ID            int          `json:"id,omitempty"`
+	CreatedAt     *time.Time   `json:"created_at,omitempty"`
+	UpdatedAt     *time.Time   `json:"updated_at,omitempty"`
+	LastPush      *time.Time   `json:"last_push,omitempty"`
+	LastHeartbeat *time.Time   `json:"last_heartbeat,omitempty"`
+	MachineId     string       `json:"machineId,omitempty"`
+	Password      string       `json:"-"`
+	IpAddress     string       `json:"ipAddress,omitempty"`
+	Scenarios     string       `json:"scenarios,omitempty"`
+	Version       string       `json:"version,omitempty"`
+	IsValidated   bool         `json:"isValidated,omitempty"`
+	Status        string       `json:"status,omitempty"`
+	AuthType      string       `json:"auth_type"`
+	Edges         MachineEdges `json:"edges"`
+}
+
+type MachineEdges struct {
+	Alerts []*Alert `json:"alerts,omitempty"`
+}
+
+type Decision struct {
+	Duration  *string `json:"duration"`
+	ID        int64   `json:"id,omitempty"`
+	Origin    *string `json:"origin"`
+	Scenario  *string `json:"scenario"`
+	Scope     *string `json:"scope"`
+	Simulated *bool   `json:"simulated,omitempty"`
+	Type      *string `json:"type"`
+	Until     string  `json:"until,omitempty"`
+	UUID      string  `json:"uuid,omitempty"`
+	Value     *string `json:"value"`
+}
+
+type Line struct {
+	Raw     string `yaml:"Raw,omitempty"`
+	Src     string `yaml:"Src,omitempty"`
+	Time    time.Time
+	Labels  map[string]string `yaml:"Labels,omitempty"`
+	Process bool
+	Module  string `yaml:"Module,omitempty"`
+}
+
+type ScopeType struct {
+	Scope  string `yaml:"type"`
+	Filter string `yaml:"expression"`
+}
+
+type RuntimeAlert struct {
+	Mapkey      string            `yaml:"MapKey,omitempty" json:"MapKey,omitempty"`
+	BucketId    string            `yaml:"BucketId,omitempty" json:"BucketId,omitempty"`
+	Whitelisted bool              `yaml:"Whitelisted,omitempty" json:"Whitelisted,omitempty"`
+	Reprocess   bool              `yaml:"Reprocess,omitempty" json:"Reprocess,omitempty"`
+	Sources     map[string]Source `yaml:"Sources,omitempty" json:"Sources,omitempty"`
+	Alert       *Alert            `yaml:"Alert,omitempty" json:"Alert,omitempty"`
+	APIAlerts   []Alert           `yaml:"APIAlerts,omitempty" json:"APIAlerts,omitempty"`
+}
+
+func (r RuntimeAlert) GetSources() []string {
+	return nil
+}
+
+type Source struct {
+	AsName    string  `json:"as_name,omitempty"`
+	AsNumber  string  `json:"as_number,omitempty"`
+	Cn        string  `json:"cn,omitempty"`
+	IP        string  `json:"ip,omitempty"`
+	Latitude  float32 `json:"latitude,omitempty"`
+	Longitude float32 `json:"longitude,omitempty"`
+	Range     string  `json:"range,omitempty"`
+	Scope     *string `json:"scope"`
+	Value     *string `json:"value"`
+}
+
+type Meta []*MetaItems0
+
+type MetaItems0 struct {
+	Key   string `json:"key,omitempty"`
+	Value string `json:"value,omitempty"`
+}
diff --git a/test/crowdsec/crowdsec_test.go b/test/crowdsec/crowdsec_test.go
new file mode 100644
index 000000000..0ff2f6211
--- /dev/null
+++ b/test/crowdsec/crowdsec_test.go
@@ -0,0 +1,47 @@
+package crowdsec_test
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+
+	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/test/crowdsec"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCrowdsec(t *testing.T) {
+	b, err := os.ReadFile("../../testdata/crowdsec.json")
+	require.NoError(t, err)
+
+	var examples []string
+	err = json.Unmarshal(b, &examples)
+	require.NoError(t, err)
+
+	env := map[string]interface{}{
+		"evt": &crowdsec.Event{},
+	}
+
+	var opt = []expr.Option{
+		expr.Env(env),
+	}
+	for _, fn := range crowdsec.CustomFunctions {
+		opt = append(
+			opt,
+			expr.Function(
+				fn.Name,
+				func(params ...interface{}) (interface{}, error) {
+					return nil, nil
+				},
+				fn.Func...,
+			),
+		)
+	}
+
+	for _, line := range examples {
+		t.Run(line, func(t *testing.T) {
+			_, err = expr.Compile(line, opt...)
+			require.NoError(t, err)
+		})
+	}
+}
diff --git a/test/crowdsec/funcs.go b/test/crowdsec/funcs.go
new file mode 100644
index 000000000..acc14c545
--- /dev/null
+++ b/test/crowdsec/funcs.go
@@ -0,0 +1,353 @@
+package crowdsec
+
+import (
+	"time"
+)
+
+var CustomFunctions = []struct {
+	Name string
+	Func []interface{}
+}{
+	{
+		Name: "Distance",
+		Func: []interface{}{
+			new(func(string, string, string, string) (float64, error)),
+		},
+	},
+	{
+		Name: "GetFromStash",
+		Func: []interface{}{
+			new(func(string, string) (string, error)),
+		},
+	},
+	{
+		Name: "Atof",
+		Func: []interface{}{
+			new(func(string) float64),
+		},
+	},
+	{
+		Name: "JsonExtract",
+		Func: []interface{}{
+			new(func(string, string) string),
+		},
+	},
+	{
+		Name: "JsonExtractUnescape",
+		Func: []interface{}{
+			new(func(string, ...string) string),
+		},
+	},
+	{
+		Name: "JsonExtractLib",
+		Func: []interface{}{
+			new(func(string, ...string) string),
+		},
+	},
+	{
+		Name: "JsonExtractSlice",
+		Func: []interface{}{
+			new(func(string, string) []interface{}),
+		},
+	},
+	{
+		Name: "JsonExtractObject",
+		Func: []interface{}{
+			new(func(string, string) map[string]interface{}),
+		},
+	},
+	{
+		Name: "ToJsonString",
+		Func: []interface{}{
+			new(func(interface{}) string),
+		},
+	},
+	{
+		Name: "File",
+		Func: []interface{}{
+			new(func(string) []string),
+		},
+	},
+	{
+		Name: "RegexpInFile",
+		Func: []interface{}{
+			new(func(string, string) bool),
+		},
+	},
+	{
+		Name: "Upper",
+		Func: []interface{}{
+			new(func(string) string),
+		},
+	},
+	{
+		Name: "Lower",
+		Func: []interface{}{
+			new(func(string) string),
+		},
+	},
+	{
+		Name: "IpInRange",
+		Func: []interface{}{
+			new(func(string, string) bool),
+		},
+	},
+	{
+		Name: "TimeNow",
+		Func: []interface{}{
+			new(func() string),
+		},
+	},
+	{
+		Name: "ParseUri",
+		Func: []interface{}{
+			new(func(string) map[string][]string),
+		},
+	},
+	{
+		Name: "PathUnescape",
+		Func: []interface{}{
+			new(func(string) string),
+		},
+	},
+	{
+		Name: "QueryUnescape",
+		Func: []interface{}{
+			new(func(string) string),
+		},
+	},
+	{
+		Name: "PathEscape",
+		Func: []interface{}{
+			new(func(string) string),
+		},
+	},
+	{
+		Name: "QueryEscape",
+		Func: []interface{}{
+			new(func(string) string),
+		},
+	},
+	{
+		Name: "XMLGetAttributeValue",
+		Func: []interface{}{
+			new(func(string, string, string) string),
+		},
+	},
+	{
+		Name: "XMLGetNodeValue",
+		Func: []interface{}{
+			new(func(string, string) string),
+		},
+	},
+	{
+		Name: "IpToRange",
+		Func: []interface{}{
+			new(func(string, string) string),
+		},
+	},
+	{
+		Name: "IsIPV6",
+		Func: []interface{}{
+			new(func(string) bool),
+		},
+	},
+	{
+		Name: "IsIPV4",
+		Func: []interface{}{
+			new(func(string) bool),
+		},
+	},
+	{
+		Name: "IsIP",
+		Func: []interface{}{
+			new(func(string) bool),
+		},
+	},
+	{
+		Name: "LookupHost",
+		Func: []interface{}{
+			new(func(string) []string),
+		},
+	},
+	{
+		Name: "GetDecisionsCount",
+		Func: []interface{}{
+			new(func(string) int),
+		},
+	},
+	{
+		Name: "GetDecisionsSinceCount",
+		Func: []interface{}{
+			new(func(string, string) int),
+		},
+	},
+	{
+		Name: "Sprintf",
+		Func: []interface{}{
+			new(func(string, ...interface{}) string),
+		},
+	},
+	{
+		Name: "ParseUnix",
+		Func: []interface{}{
+			new(func(string) string),
+		},
+	},
+	{
+		Name: "SetInStash",
+		Func: []interface{}{
+			new(func(string, string, string, *time.Duration) error),
+		},
+	},
+	{
+		Name: "Fields",
+		Func: []interface{}{
+			new(func(string) []string),
+		},
+	},
+	{
+		Name: "Index",
+		Func: []interface{}{
+			new(func(string, string) int),
+		},
+	},
+	{
+		Name: "IndexAny",
+		Func: []interface{}{
+			new(func(string, string) int),
+		},
+	},
+	{
+		Name: "Join",
+		Func: []interface{}{
+			new(func([]string, string) string),
+		},
+	},
+	{
+		Name: "Split",
+		Func: []interface{}{
+			new(func(string, string) []string),
+		},
+	},
+	{
+		Name: "SplitAfter",
+		Func: []interface{}{
+			new(func(string, string) []string),
+		},
+	},
+	{
+		Name: "SplitAfterN",
+		Func: []interface{}{
+			new(func(string, string, int) []string),
+		},
+	},
+	{
+		Name: "SplitN",
+		Func: []interface{}{
+			new(func(string, string, int) []string),
+		},
+	},
+	{
+		Name: "Replace",
+		Func: []interface{}{
+			new(func(string, string, string, int) string),
+		},
+	},
+	{
+		Name: "ReplaceAll",
+		Func: []interface{}{
+			new(func(string, string, string) string),
+		},
+	},
+	{
+		Name: "Trim",
+		Func: []interface{}{
+			new(func(string, string) string),
+		},
+	},
+	{
+		Name: "TrimLeft",
+		Func: []interface{}{
+			new(func(string, string) string),
+		},
+	},
+	{
+		Name: "TrimRight",
+		Func: []interface{}{
+			new(func(string, string) string),
+		},
+	},
+	{
+		Name: "TrimSpace",
+		Func: []interface{}{
+			new(func(string) string),
+		},
+	},
+	{
+		Name: "TrimPrefix",
+		Func: []interface{}{
+			new(func(string, string) string),
+		},
+	},
+	{
+		Name: "TrimSuffix",
+		Func: []interface{}{
+			new(func(string, string) string),
+		},
+	},
+	{
+		Name: "Get",
+		Func: []interface{}{
+			new(func([]string, int) string),
+		},
+	},
+	{
+		Name: "ToString",
+		Func: []interface{}{
+			new(func(interface{}) string),
+		},
+	},
+	{
+		Name: "Match",
+		Func: []interface{}{
+			new(func(string, string) bool),
+		},
+	},
+	{
+		Name: "KeyExists",
+		Func: []interface{}{
+			new(func(string, map[string]interface{}) bool),
+		},
+	},
+	{
+		Name: "LogInfo",
+		Func: []interface{}{
+			new(func(string, ...interface{}) bool),
+		},
+	},
+	{
+		Name: "B64Decode",
+		Func: []interface{}{
+			new(func(string) string),
+		},
+	},
+	{
+		Name: "UnmarshalJSON",
+		Func: []interface{}{
+			new(func(string, map[string]interface{}, string) error),
+		},
+	},
+	{
+		Name: "ParseKV",
+		Func: []interface{}{
+			new(func(string, map[string]interface{}, string) error),
+		},
+	},
+	{
+		Name: "Hostname",
+		Func: []interface{}{
+			new(func() (string, error)),
+		},
+	},
+}
diff --git a/testdata/crowdsec.json b/testdata/crowdsec.json
new file mode 100644
index 000000000..599448c04
--- /dev/null
+++ b/testdata/crowdsec.json
@@ -0,0 +1,675 @@
+[
+  " {Jan:'01',Feb:'02',Mar:'03',Apr:'04',May:'05',Jun:'06',Jul:'07',Aug:'08',Sep:'09',Oct:'10',Nov:'11',Dec:'12'}[evt.Parsed.ts_m] + '/' + evt.Parsed.ts_d + '/' + evt.Parsed.ts_y + ' ' + evt.Parsed.ts_t",
+  "\"20\" + evt.Parsed.year + \"/\" + evt.Parsed.month + \"/\" + evt.Parsed.day + \" \" + evt.Parsed.time",
+  "'source_ip' in evt.Meta",
+  "(\nUpper(evt.Meta.http_path) contains Upper('/service/extension/backup/mboximport?account-name=admin&ow=2&no-switch=1&append=1') ||\nUpper(evt.Meta.http_path) contains Upper('/service/extension/backup/mboximport?account-name=admin&account-status=1&ow=cmd') \n)\nand evt.Meta.http_status startsWith ('40') and\nUpper(evt.Meta.http_verb) == 'POST'\n",
+  "GetFromStash(\"auditd_pid_progname\", evt.Unmarshaled.auditd.ppid)",
+  "IpToRange(evt.Overflow.Alert.Source.IP, \"/64\")",
+  "IsIP(evt.Unmarshaled.cloudtrail.sourceIPAddress) ? evt.Unmarshaled.cloudtrail.sourceIPAddress : \"\"\n",
+  "JsonExtract(evt.Line.Raw, \"common_log\")",
+  "JsonExtract(evt.Line.Raw, \"metric_name\")",
+  "JsonExtract(evt.Line.Raw, \"path_info\")",
+  "JsonExtract(evt.Line.Raw, \"request.headers.User-Agent\")",
+  "JsonExtract(evt.Line.Raw, \"request.host\")",
+  "JsonExtract(evt.Line.Raw, \"request.method\")",
+  "JsonExtract(evt.Line.Raw, \"request.remote_addr\")",
+  "JsonExtract(evt.Line.Raw, \"request.remote_ip\")",
+  "JsonExtract(evt.Line.Raw, \"request.uri\")",
+  "JsonExtract(evt.Line.Raw, \"request_ip\")",
+  "JsonExtract(evt.Line.Raw, \"resp_headers.Date[0]\")",
+  "JsonExtract(evt.Line.Raw, \"status\")",
+  "JsonExtract(evt.Line.Raw, \"time\")",
+  "JsonExtract(evt.Line.Raw, \"timestamp\")",
+  "JsonExtract(evt.Line.Raw, \"user_agent\")",
+  "JsonExtract(evt.Line.Raw, 'status') == '401' && JsonExtract(evt.Line.Raw, 'request.headers.Authorization[0]') startsWith 'Basic ' ? 'auth_fail' : ''",
+  "JsonExtract(evt.Parsed.line, \"bouncer_agent\")",
+  "JsonExtract(evt.Parsed.line, \"customer_id\")",
+  "JsonExtract(evt.Parsed.line, \"ip\")",
+  "JsonExtract(evt.Parsed.line, \"order_id\")",
+  "JsonExtract(evt.Parsed.line, \"payment_method\")",
+  "JsonExtract(evt.Parsed.line, \"product_id\")",
+  "JsonExtract(evt.Parsed.line, \"quote_id\")",
+  "JsonExtract(evt.Parsed.line, \"type\")",
+  "JsonExtract(evt.Parsed.line, \"x-forwarded-for-ip\")",
+  "JsonExtract(evt.Parsed.message, \"alert.rev\")",
+  "JsonExtract(evt.Parsed.message, \"alert.severity\")",
+  "JsonExtract(evt.Parsed.message, \"alert.signature\")",
+  "JsonExtract(evt.Parsed.message, \"alert.signature_id\")",
+  "JsonExtract(evt.Parsed.message, \"attr.authenticationDatabase\")",
+  "JsonExtract(evt.Parsed.message, \"attr.principalName\")",
+  "JsonExtract(evt.Parsed.message, \"attr.remote\")",
+  "JsonExtract(evt.Parsed.message, \"client_ip\")",
+  "JsonExtract(evt.Parsed.message, \"dest_ip\")",
+  "JsonExtract(evt.Parsed.message, \"dest_port\")",
+  "JsonExtract(evt.Parsed.message, \"eventAudience\")",
+  "JsonExtract(evt.Parsed.message, \"eventData.eventConfidence\")",
+  "JsonExtract(evt.Parsed.message, \"eventData.httpSourceId\")",
+  "JsonExtract(evt.Parsed.message, \"eventData.matchedLocation\")",
+  "JsonExtract(evt.Parsed.message, \"eventData.matchedParameter\")",
+  "JsonExtract(evt.Parsed.message, \"eventData.matchedSample\")",
+  "JsonExtract(evt.Parsed.message, \"eventData.securityAction\")",
+  "JsonExtract(evt.Parsed.message, \"eventData.sourceIP\")",
+  "JsonExtract(evt.Parsed.message, \"eventData.waapIncidentType\")",
+  "JsonExtract(evt.Parsed.message, \"eventName\")",
+  "JsonExtract(evt.Parsed.message, \"eventPriority\")",
+  "JsonExtract(evt.Parsed.message, \"eventSeverity\")",
+  "JsonExtract(evt.Parsed.message, \"eventTime\")",
+  "JsonExtract(evt.Parsed.message, \"flow_id\")",
+  "JsonExtract(evt.Parsed.message, \"message\")",
+  "JsonExtract(evt.Parsed.message, \"msg\")",
+  "JsonExtract(evt.Parsed.message, \"proto\")",
+  "JsonExtract(evt.Parsed.message, \"remote_ip\")",
+  "JsonExtract(evt.Parsed.message, \"request_method\")",
+  "JsonExtract(evt.Parsed.message, \"request_referer\")",
+  "JsonExtract(evt.Parsed.message, \"request_user_agent\")",
+  "JsonExtract(evt.Parsed.message, \"response_body_size\")",
+  "JsonExtract(evt.Parsed.message, \"response_status\")",
+  "JsonExtract(evt.Parsed.message, \"src_ip\")",
+  "JsonExtract(evt.Parsed.message, \"t.$date\")",
+  "JsonExtract(evt.Parsed.message, \"time\")",
+  "JsonExtract(evt.Parsed.message, \"timestamp\")",
+  "JsonExtract(evt.Parsed.message, \"url\")",
+  "JsonExtractUnescape(evt.Line.Raw, \"log\")",
+  "Lower(evt.Meta.http_path) contains '/index.php' &&\nUpper(evt.Parsed.verb) == 'POST' &&\nevt.Meta.http_status == '302' &&\nLower(evt.Parsed.http_args) matches 'login=.*[$|%24][\\\\(|%28].*[\\\\)|%29]'\n",
+  "Lower(evt.Unmarshaled.iptables.PROTO)",
+  "ParseKV(evt.Parsed.message, evt.Unmarshaled, \"iptables\")",
+  "RegexpInFile(evt.Enriched.reverse_dns, 'rdns_seo_bots.regex')",
+  "Split(evt.Unmarshaled.traefik.ClientAddr, ':')[0]",
+  "Split(evt.Unmarshaled.traefik.RequestProtocol, '/')[1]",
+  "UnmarshalJSON(evt.Line.Raw, evt.Unmarshaled, \"k8s_audit\")",
+  "UnmarshalJSON(evt.Line.Raw, evt.Unmarshaled, 'cloudtrail')",
+  "Upper(PathUnescape(evt.Meta.http_path)) contains Upper('${script:javascript:java.lang.Runtime.getRuntime().exec(')\nor\nUpper(PathUnescape(evt.Meta.http_path)) contains Upper('${script:js:java.lang.Runtime.getRuntime().exec(')\nor\nUpper(PathUnescape(evt.Meta.http_path)) contains Upper('${url:UTF-8:') \nor\nUpper(PathUnescape(evt.Meta.http_path)) contains Upper('${dns:address|') \n",
+  "Upper(PathUnescape(evt.Meta.http_path)) contains Upper('@java.lang.Runtime@getRuntime().exec(')",
+  "Upper(evt.Meta.http_path) contains Upper('/autodiscover/autodiscover.json') &&\nUpper(evt.Parsed.http_args) contains Upper('powershell')\n",
+  "Upper(evt.Meta.http_path) contains Upper('/ghost/api/admin/session') &&\nUpper(evt.Parsed.verb) == 'POST' &&\nevt.Meta.http_status == '404'\n",
+  "Upper(evt.Meta.http_path) contains Upper('/remote_agent.php') &&\nUpper(evt.Parsed.verb) == 'GET' &&\nLower(evt.Parsed.http_args) contains 'action=polldata' &&\nLower(evt.Parsed.http_args) matches 'poller_id=.*(;|%3b)'\n",
+  "Upper(evt.Meta.http_path) contains Upper('/remote_agent.php') &&\nUpper(evt.Parsed.verb) == 'GET' &&\nLower(evt.Parsed.http_args) contains 'host_id' &&\nLower(evt.Parsed.http_args) contains 'local_data_ids'\n",
+  "Upper(evt.Meta.http_path) contains Upper('/vendor/htmlawed/htmlawed/htmLawedTest.php')",
+  "Upper(evt.Parsed.file_ext) in ['.JPG', '.CSS', '.JS', '.JPEG', '.PNG', '.SVG', '.MAP', '.ICO', '.OTF', '.GIF', '.MP3', '.MP4', '.WOFF', '.WOFF2', '.TTF', '.OTF', '.EOT', '.WEBP', '.WAV', '.GZ', '.BROTLI', '.BVR', '.TS', '.BMP'] ? 'true' : 'false'",
+  "Upper(evt.Parsed.program) == 'BAIKAL'",
+  "Upper(evt.Parsed.program) == 'GITLAB'",
+  "Upper(evt.Parsed.program) == 'MONGODB'",
+  "Upper(evt.Parsed.program) == 'NAMED'",
+  "Upper(evt.Parsed.program) == 'NEXTCLOUD'",
+  "Upper(evt.Parsed.program) == 'PAPERLESS-NGX'",
+  "Upper(evt.Parsed.program) == 'UPTIME-KUMA'",
+  "Upper(evt.Parsed.program) == 'VAULTWARDEN'",
+  "Upper(evt.Parsed.program) == 'WEBMIN'",
+  "XMLGetAttributeValue(evt.Line.Raw, \"/Event/System[1]/Provider\", \"Name\")",
+  "XMLGetAttributeValue(evt.Line.Raw, \"/Event/System[1]/Security\", \"UserID\")",
+  "XMLGetAttributeValue(evt.Line.Raw, \"/Event/System[1]/TimeCreated\", \"SystemTime\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[1]\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[2]\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[3]\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Archived']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='CallTrace']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ClientInfo']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='CommandLine']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Company']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Configuration']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ConfigurationFileHash']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Consumer']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='CreationUtcTime']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='CurrentDirectory']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Description']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Destination']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='DestinationHostname']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='DestinationIp']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='DestinationIsIpv6']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='DestinationPort']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='DestinationPortName']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Details']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Device']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='EventNamespace']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='EventType']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='FileVersion']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Filter']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='GrantedAccess']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Hashes']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Image']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ImageLoaded']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Initiated']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='IntegrityLevel']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='IpAddress']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='IsExecutable']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='LogonGuid']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='LogonId']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Name']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='NewName']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='NewThreadId']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Operation']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='OriginalFileName']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ParentCommandLine']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ParentImage']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ParentProcessGuid']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ParentProcessId']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ParentUser']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='PipeName']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ProcessGuid']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='ProcessId']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Protocol']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Query']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='QueryName']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='QueryResults']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='QueryStatus']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='RuleName']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SchemaVersion']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Session']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Signature']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SignatureStatus']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Signed']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourceHostname']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourceImage']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourceIp']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourceIsIpv6']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourcePort']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourcePortName']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourceProcessGUID']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourceProcessGuid']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourceProcessId']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='SourceThreadId']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='StartAddress']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='StartFunction']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='StartModule']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='State']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='TargetFilename']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='TargetImage']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='TargetObject']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='TargetProcessGUID']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='TargetProcessGuid']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='TargetProcessId']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='TargetUserName']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='TerminalSessionId']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Type']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='User']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='Version']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='c-ip']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='cs-method']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='cs-uri-query']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='cs-uri-stem']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='csUser-Agent']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='date']\") + \" \" + XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='time']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='s-sitename']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/EventData[1]/Data[@Name='sc-status']\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/System[1]/Channel\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/System[1]/Computer\")",
+  "XMLGetNodeValue(evt.Line.Raw, \"/Event/System[1]/EventID\")",
+  "all(evt.Overflow.Alert.Events, {.GetMeta('parent_progname') in ['/usr/bin/dpkg', '/usr/bin/dnf']})",
+  "any(File('cloudflare_ip6s.txt'), { IpInRange(evt.Overflow.Alert.Source.IP ,#)})",
+  "any(File('cloudflare_ips.txt'), { IpInRange(evt.Overflow.Alert.Source.IP ,#)})",
+  "any(File('ip_seo_bots.txt'), { len(#) > 0 && IpInRange(evt.Overflow.Alert.Source.IP ,#)})",
+  "any(File('rdns_seo_bots.txt'), { len(#) > 0 && evt.Enriched.reverse_dns endsWith #})",
+  "any(['Authentication failure', 'Password mismatch', 'password mismatch', 'auth failed', 'unknown user'], {evt.Parsed.dovecot_login_message contains #}) ? 'auth_failed' : ''",
+  "evt.Enriched.ASNNumber",
+  "evt.Enriched.ASNOrg",
+  "evt.Enriched.GeoCoords",
+  "evt.Enriched.IsInEU",
+  "evt.Enriched.IsoCode",
+  "evt.Enriched.MarshaledTime",
+  "evt.Enriched.SourceRange",
+  "evt.Enriched.reverse_dns",
+  "evt.Enriched.reverse_dns endsWith '.ptr.discord.com.'",
+  "evt.GetType() == 'overflow' && evt.Overflow.Alert.Remediation == true",
+  "evt.Line.Labels.external_format == 'fastly'",
+  "evt.Line.Labels.program",
+  "evt.Line.Labels.type",
+  "evt.Line.Labels.type != 'syslog'",
+  "evt.Line.Labels.type == 'aws-alb'",
+  "evt.Line.Labels.type == 'containerd'",
+  "evt.Line.Labels.type == 'docker'",
+  "evt.Line.Labels.type == 'syslog'",
+  "evt.Line.Labels.type == 'unifi'",
+  "evt.Line.Module",
+  "evt.Line.Module != 'wineventlog'",
+  "evt.Line.Module == 'wineventlog'",
+  "evt.Line.Raw",
+  "evt.Line.Src",
+  "evt.Meta.error in ['user_not_found', 'invalid_user_credentials']",
+  "evt.Meta.http_path + '?' + evt.Parsed.http_args",
+  "evt.Meta.http_status == '200' && evt.Parsed.static_ressource == 'false' && evt.Meta.http_verb == 'GET' && evt.Meta.http_path contains '/apps/photos/api/v1/preview' && evt.Parsed.http_args contains '&x=' && evt.Parsed.http_args contains '&y=' && evt.Parsed.http_args contains 'etag='",
+  "evt.Meta.http_status == '403' && evt.Meta.http_verb == 'POST' && evt.Meta.http_path contains \"/Sessions/Playing/Progress\"",
+  "evt.Meta.http_status == '404' && evt.Meta.http_verb == 'GET' && evt.Meta.http_path contains '/apps/files_trashbin/preview' && evt.Parsed.http_args contains 'fileId=' && evt.Parsed.http_args contains '&file='",
+  "evt.Meta.http_status == '404' && evt.Meta.http_verb == 'GET' && evt.Meta.http_path contains '/apps/files_versions/preview' && evt.Parsed.http_args contains 'version'",
+  "evt.Meta.http_status == '404' && evt.Meta.http_verb == 'GET' && evt.Meta.http_path contains '/apps/photos/api/v1/preview' && evt.Parsed.http_args contains 'x' && evt.Parsed.http_args contains 'y'",
+  "evt.Meta.http_status == '404' && evt.Meta.http_verb == 'GET' && evt.Meta.http_path matches '\\\\/apps\\\\/files\\\\/api\\\\/v1\\\\/thumbnail\\\\/(\\\\d+)/(\\\\d+)'",
+  "evt.Meta.http_status == '404' && evt.Meta.http_verb == 'GET' && evt.Meta.http_path startsWith '/apps/mail/api/avatars/url/'",
+  "evt.Meta.http_status == '404' && evt.Meta.http_verb == 'GET' && evt.Parsed.file_ext == '.vcf' && evt.Parsed.http_args contains \"photo\"",
+  "evt.Meta.http_status == '404' && evt.Meta.http_verb == 'GET' && evt.Parsed.request == '/ocs/v2.php/apps/text/workspace' && evt.Parsed.http_args contains 'path=%2F'",
+  "evt.Meta.http_status == '404' && evt.Meta.http_verb == 'GET' && evt.Parsed.request contains '/core/preview' && evt.Parsed.http_args contains 'x=' && evt.Parsed.http_args contains 'y=' && evt.Parsed.http_args contains 'fileId='",
+  "evt.Meta.http_status == '404' && evt.Meta.http_verb in ['PROPFIND', 'GET'] && evt.Meta.http_path matches '^/remote.php/(web)?dav/'",
+  "evt.Meta.http_status in ['404', '403', '502'] ? 'false' : 'true'",
+  "evt.Meta.log_subtype == 'zm_bad_password'",
+  "evt.Meta.log_subtype == 'zm_bad_user'",
+  "evt.Meta.log_type  == 'gotify_failed_auth'",
+  "evt.Meta.log_type == \"palo_alto\" && evt.Meta.severity in [\"medium\", \"high\", \"critical\"]",
+  "evt.Meta.log_type == 'ADMIN_LOGIN_FAILED'",
+  "evt.Meta.log_type == 'CVE-2021-4034-xpl'",
+  "evt.Meta.log_type == 'PAYMENT_FAILED'",
+  "evt.Meta.log_type == 'PAYMENT_FAILED' and evt.Meta.ASNNumber != '' ",
+  "evt.Meta.log_type == 'PAYMENT_FAILED' and evt.Meta.IsoCode != '' ",
+  "evt.Meta.log_type == 'adguardhome_failed_auth'",
+  "evt.Meta.log_type == 'apache-guacamole_failed_auth'",
+  "evt.Meta.log_type == 'asterisk_failed_auth'",
+  "evt.Meta.log_type == 'auth_bf_attempt'",
+  "evt.Meta.log_type == 'auth_bf_log'",
+  "evt.Meta.log_type == 'aws-cloudtrail'",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\n(\n     (evt.Unmarshaled.cloudtrail.errorCode != nil && evt.Unmarshaled.cloudtrail.errorCode matches \".*UnauthorizedOperation$\") ||\n     (evt.Unmarshaled.cloudtrail.errorCode != nil && evt.Unmarshaled.cloudtrail.errorCode matches \"^AccessDenied.*\")\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\n(\n  evt.Meta.event_name == \"DeleteGroupPolicy\" ||\n  evt.Meta.event_name == \"DeleteRolePolicy\" ||\n  evt.Meta.event_name == \"DeleteUserPolicy\" ||\n  evt.Meta.event_name == \"PutGroupPolicy\" ||\n  evt.Meta.event_name == \"PutRolePolicy\" ||\n  evt.Meta.event_name == \"PutUserPolicy\" ||\n  evt.Meta.event_name == \"CreatePolicy\" ||\n  evt.Meta.event_name == \"DeletePolicy\" ||\n  evt.Meta.event_name == \"CreatePolicyVersion\" ||\n  evt.Meta.event_name == \"DeletePolicyVersion\" ||\n  evt.Meta.event_name == \"AttachRolePolicy\" ||\n  evt.Meta.event_name == \"DetachRolePolicy\" ||\n  evt.Meta.event_name == \"AttachUserPolicy\" ||\n  evt.Meta.event_name == \"DetachUserPolicy\" ||\n  evt.Meta.event_name == \"AttachGroupPolicy\" ||\n  evt.Meta.event_name == \"DetachGroupPolicy\"\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\n(\nevt.Meta.event_name == \"AuthorizeSecurityGroupIngress\" ||\nevt.Meta.event_name == \"AuthorizeSecurityGroupEgress\" ||\nevt.Meta.event_name == \"RevokeSecurityGroupIngress\" ||\nevt.Meta.event_name == \"RevokeSecurityGroupEgress\" ||\nevt.Meta.event_name == \"CreateSecurityGroup\" ||\nevt.Meta.event_name == \"DeleteSecurityGroup\"\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\n(\nevt.Meta.event_name == \"CreateCustomerGateway\" ||\nevt.Meta.event_name == \"DeleteCustomerGateway\" ||\nevt.Meta.event_name == \"AttachInternetGateway\" ||\nevt.Meta.event_name == \"CreateInternetGateway\" ||\nevt.Meta.event_name == \"DeleteInternetGateway\" ||\nevt.Meta.event_name == \"DetachInternetGateway\"\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\n(\nevt.Meta.event_name == \"CreateNetworkAcl\" ||\nevt.Meta.event_name == \"CreateNetworkAclEntry\" ||\nevt.Meta.event_name == \"DeleteNetworkAcl\" ||\nevt.Meta.event_name == \"DeleteNetworkAclEntry\" ||\nevt.Meta.event_name == \"ReplaceNetworkAclEntry\" ||\nevt.Meta.event_name == \"ReplaceNetworkAclAssociation\"\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\n(\nevt.Meta.event_name == \"CreateRoute\" ||\nevt.Meta.event_name == \"CreateRouteTable\" ||\nevt.Meta.event_name == \"ReplaceRoute\" ||\nevt.Meta.event_name == \"ReplaceRouteTableAssociation\" ||\nevt.Meta.event_name == \"DeleteRouteTable\" ||\nevt.Meta.event_name == \"DeleteRoute\" ||\nevt.Meta.event_name == \"DisassociateRouteTable\"\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\n(\nevt.Meta.event_name == \"CreateTrail\" ||\nevt.Meta.event_name == \"UpdateTrail\" ||\nevt.Meta.event_name == \"DeleteTrail\" ||\nevt.Meta.event_name == \"StartLogging\" ||\nevt.Meta.event_name == \"StopLogging\"\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\n(\nevt.Meta.event_name == \"CreateVpc\" ||\nevt.Meta.event_name == \"DeleteVpc\" ||\nevt.Meta.event_name == \"ModifyVpcAttribute\" ||\nevt.Meta.event_name == \"AcceptVpcPeeringConnection\" ||\nevt.Meta.event_name == \"CreateVpcPeeringConnection\" ||\nevt.Meta.event_name == \"DeleteVpcPeeringConnection\" ||\nevt.Meta.event_name == \"RejectVpcPeeringConnection\" ||\nevt.Meta.event_name == \"AttachClassicLinkVpc\" ||\nevt.Meta.event_name == \"DetachClassicLinkVpc\" ||\nevt.Meta.event_name == \"DisableVpcClassicLink\" ||\nevt.Meta.event_name == \"EnableVpcClassicLink\"\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\n(evt.Meta.event_name == 'ConsoleLogin' || evt.Meta.event_name == 'GetSessionToken' || evt.Meta.event_name == 'GetFederationToken') &&\nevt.Unmarshaled.cloudtrail.responseElements?.ConsoleLogin == 'Success' &&\n(\n (evt.Time.Hour() >= 18 || evt.Time.Hour() < 6) || \n (evt.Time.Weekday().String() == 'Saturday' || evt.Time.Weekday().String() == 'Sunday')\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\nevt.Meta.event_name == \"ConsoleLogin\" &&\nevt.Unmarshaled.cloudtrail.additionalEventData.MFAUsed != \"Yes\" &&\nevt.Unmarshaled.cloudtrail.userIdentity.type == \"IAMUser\" &&\nevt.Unmarshaled.cloudtrail.responseElements.ConsoleLogin == \"Success\"\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\nevt.Unmarshaled.cloudtrail.eventSource == \"kms.amazonaws.com\" &&\n(evt.Meta.event_name == \"DisableKey\" || evt.Meta.event_name == \"ScheduleKeyDeletion\")\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\nevt.Unmarshaled.cloudtrail.eventSource == \"s3.amazonaws.com\" &&\n(\n evt.Meta.event_name == \"PutBucketAcl\" ||\n evt.Meta.event_name == \"PutBucketPolicy\" ||\n evt.Meta.event_name == \"PutBucketCors\" ||\n evt.Meta.event_name == \"PutBucketLifecycle\" ||\n evt.Meta.event_name == \"PutBucketReplication\" ||\n evt.Meta.event_name == \"DeleteBucketPolicy\" ||\n evt.Meta.event_name == \"DeleteBucketCors\" ||\n evt.Meta.event_name == \"DeleteBucketLifecycle\" ||\n evt.Meta.event_name == \"DeleteBucketReplication\"\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' &&\nevt.Unmarshaled.cloudtrail.userIdentity.type == \"Root\" &&\nevt.Unmarshaled.cloudtrail.userIdentity.invokedBy == nil &&\nevt.Unmarshaled.cloudtrail.eventType != \"AwsServiceEvent\"\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' && \nevt.Meta.event_name == \"ConsoleLogin\" && \nevt.Unmarshaled.cloudtrail.errorMessage == \"Failed authentication\"\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' && \nevt.Unmarshaled.cloudtrail.eventSource == \"config.amazonaws.com\" &&\n(\n evt.Meta.event_name == \"StopConfigurationRecorder\" ||\n evt.Meta.event_name == \"DeleteDeliveryChannel\" ||\n evt.Meta.event_name == \"PutDeliveryChannel\" ||\n evt.Meta.event_name == \"PutConfigurationRecorder\"\n)\n",
+  "evt.Meta.log_type == 'aws-cloudtrail' && (\n  (evt.Meta.event_name == 'ConsoleLogin' && evt.Unmarshaled.cloudtrail.responseElements.ConsoleLogin == 'Failure') || \n  (evt.Meta.event_name == 'GetSessionToken' && evt.Meta.error_code=='AccessDenied') || \n  (evt.Meta.event_name == 'GetFederationToken' && evt.Meta.error_code=='AccessDenied')\n)\n",
+  "evt.Meta.log_type == 'baikal_failed_auth'",
+  "evt.Meta.log_type == 'bind9_denied'",
+  "evt.Meta.log_type == 'cas_failed-auth'",
+  "evt.Meta.log_type == 'dovecot_logs' && evt.Meta.dovecot_login_result == 'auth_failed'",
+  "evt.Meta.log_type == 'emby_failed_auth'",
+  "evt.Meta.log_type == 'endlessh_accept'",
+  "evt.Meta.log_type == 'execve'",
+  "evt.Meta.log_type == 'execve' && evt.Meta.exe == '/usr/bin/pgrep'",
+  "evt.Meta.log_type == 'execve' && evt.Meta.exe in ['/usr/bin/rm', '/bin/rm']",
+  "evt.Meta.log_type == 'execve' and ( evt.Meta.exe startsWith \"/tmp/\" or evt.Meta.exe contains \"/.\" )",
+  "evt.Meta.log_type == 'exim_failed_auth'",
+  "evt.Meta.log_type == 'ftp_failed_auth'",
+  "evt.Meta.log_type == 'gitea_failed_auth'",
+  "evt.Meta.log_type == 'gitlab_failed_password'",
+  "evt.Meta.log_type == 'grafana_failed_auth'",
+  "evt.Meta.log_type == 'harbor_failed_auth'",
+  "evt.Meta.log_type == 'home-assistant_failed_auth'",
+  "evt.Meta.log_type == 'http_access-log' && Upper(evt.Parsed.http_args) contains 'AUTHOR='",
+  "evt.Meta.log_type == 'http_access-log' && evt.Meta.http_path startsWith '/apps/login' && evt.Parsed.verb == 'POST' && evt.Meta.http_status == '200'",
+  "evt.Meta.log_type == 'http_access-log' && evt.Meta.http_status in ['400','405'] && (evt.Parsed.verb == 'CONNECT' || evt.Parsed.request matches '^http[s]?://')",
+  "evt.Meta.log_type == 'http_access-log' && evt.Parsed.file_name == 'wp-login.php' && evt.Parsed.verb == 'POST' && evt.Meta.http_status == '200'",
+  "evt.Meta.log_type == 'http_access-log' && evt.Parsed.file_name == 'xmlrpc.php' && evt.Parsed.verb == 'POST'",
+  "evt.Meta.log_type == 'http_access-log' && evt.Parsed.file_name contains 'w00tw00t.at.ISC.SANS.DFind'",
+  "evt.Meta.log_type == 'http_access-log' && evt.Parsed.file_name contains 'wp-config.php'",
+  "evt.Meta.log_type == 'http_access-log' && evt.Parsed.verb == 'POST' && evt.Meta.http_status == '401'",
+  "evt.Meta.log_type == 'http_access-log' && evt.Parsed.verb == 'POST' && evt.Meta.http_status == '403'",
+  "evt.Meta.log_type == 'http_error-log' && evt.Parsed.program == 'nginx'",
+  "evt.Meta.log_type == 'immich_failed_auth'",
+  "evt.Meta.log_type == 'iptables_drop' && evt.Meta.service == 'tcp'",
+  "evt.Meta.log_type == 'jellyfin_failed_auth'",
+  "evt.Meta.log_type == 'jellyseerr_failed_auth'",
+  "evt.Meta.log_type == 'k8s-audit' &&\n(\n (\n  evt.Meta.datasource_type == \"k8s-audit\" &&\n  evt.Unmarshaled.k8s_audit.ObjectRef?.Resource == 'pods' &&\n  evt.Unmarshaled.k8s_audit.RequestObject != nil &&\n  evt.Unmarshaled.k8s_audit.RequestObject.spec != nil &&\n  evt.Unmarshaled.k8s_audit.RequestObject.spec.volumes != nil &&\n  any(evt.Unmarshaled.k8s_audit.RequestObject.spec.volumes, { .hostPath != nil && .hostPath.path in [\"/proc\", \"/var/run/docker.sock\", \"/\", \"/etc\", \"/root\", \"/var/run/crio/crio.sock\", \"/home/admin\", \"/var/lib/kubelet\", \"/var/lib/kubelet/pki\", \"/etc/kubernetes\", \"/etc/kubernetes/manifests\"] })\n )\n ||\n (\n  evt.Meta.datasource_type != \"k8s-audit\" &&\n  evt.Unmarshaled.k8s_audit.objectRef?.resource == 'pods' &&\n  evt.Unmarshaled.k8s_audit.requestObject != nil &&\n  evt.Unmarshaled.k8s_audit.requestObject.spec != nil &&\n  evt.Unmarshaled.k8s_audit.requestObject.spec.volumes != nil &&\n  any(evt.Unmarshaled.k8s_audit.requestObject.spec.volumes, { .hostPath != nil && .hostPath.path in [\"/proc\", \"/var/run/docker.sock\", \"/\", \"/etc\", \"/root\", \"/var/run/crio/crio.sock\", \"/home/admin\", \"/var/lib/kubelet\", \"/var/lib/kubelet/pki\", \"/etc/kubernetes\", \"/etc/kubernetes/manifests\"] })\n )\n)\n",
+  "evt.Meta.log_type == 'k8s-audit' &&\n(\n (\n  evt.Meta.datasource_type == \"k8s-audit\" &&\n  evt.Unmarshaled.k8s_audit.Verb == 'create' &&\n  evt.Unmarshaled.k8s_audit.ObjectRef?.Resource == 'pods' &&\n  evt.Unmarshaled.k8s_audit.RequestObject != nil &&\n  evt.Unmarshaled.k8s_audit.RequestObject.spec != nil &&\n  any(evt.Unmarshaled.k8s_audit.RequestObject.spec.containers, { .securityContext != nil && .securityContext.privileged == true })\n )\n ||\n (\n  evt.Meta.datasource_type != \"k8s-audit\" &&\n  evt.Unmarshaled.k8s_audit.verb == 'create' &&\n  evt.Unmarshaled.k8s_audit.objectRef?.resource == 'pods' &&\n  evt.Unmarshaled.k8s_audit.requestObject != nil &&\n  evt.Unmarshaled.k8s_audit.requestObject.spec != nil &&\n  any(evt.Unmarshaled.k8s_audit.requestObject.spec.containers, { .securityContext != nil && .securityContext.privileged == true })\n )\n)\n",
+  "evt.Meta.log_type == 'k8s-audit' &&\n(\n (evt.Meta.datasource_type == \"k8s-audit\" && evt.Unmarshaled.k8s_audit.ObjectRef?.Resource == 'pods' && evt.Unmarshaled.k8s_audit.ObjectRef?.Subresource == 'exec')\n ||\n (evt.Meta.datasource_type != \"k8s-audit\" && evt.Unmarshaled.k8s_audit.objectRef?.resource == 'pods' && evt.Unmarshaled.k8s_audit.objectRef?.subresource == 'exec')\n)\n",
+  "evt.Meta.log_type == 'k8s-audit' &&\n(\n (evt.Meta.datasource_type == \"k8s-audit\" && evt.Unmarshaled.k8s_audit.ObjectRef?.Resource not in [\"healthz\", \"livez\", \"readyz\"]) \n || \n (evt.Meta.datasource_type != \"k8s-audit\" && evt.Unmarshaled.k8s_audit.objectRef?.resource not in [\"healthz\", \"livez\", \"readyz\"])\n)\n&& evt.Meta.user in [\"system:anonymous\", \"system:unauthenticated\"]\n",
+  "evt.Meta.log_type == 'k8s-audit' &&\n(\n (evt.Meta.datasource_type == \"k8s-audit\" && evt.Unmarshaled.k8s_audit.Verb == 'create' && evt.Unmarshaled.k8s_audit.ObjectRef?.Resource == 'pods' && evt.Unmarshaled.k8s_audit.RequestObject?.spec?.hostNetwork == true)\n ||\n (evt.Meta.datasource_type != \"k8s-audit\" && evt.Unmarshaled.k8s_audit.verb == 'create' && evt.Unmarshaled.k8s_audit.objectRef?.resource == 'pods' && evt.Unmarshaled.k8s_audit.requestObject?.spec?.hostNetwork == true)\n)\n",
+  "evt.Meta.log_type == 'k8s-audit' &&\nevt.Meta.user startsWith \"system:serviceaccount:\" &&\n(\n (evt.Meta.datasource_type == \"k8s-audit\" && evt.Unmarshaled.k8s_audit.Annotations[\"authorization.k8s.io/decision\"] == \"forbid\")\n ||\n (evt.Meta.datasource_type != \"k8s-audit\" && evt.Unmarshaled.k8s_audit.annotations[\"authorization.k8s.io/decision\"] == \"forbid\")\n)\n",
+  "evt.Meta.log_type == 'k8s-audit' && \n(\n (evt.Meta.datasource_type == \"k8s-audit\" && evt.Unmarshaled.k8s_audit.ResponseStatus.code in [401, 403])\n ||\n (evt.Meta.datasource_type != \"k8s-audit\" && evt.Unmarshaled.k8s_audit.responseStatus.code in [401, 403])\n)\n",
+  "evt.Meta.log_type == 'mail_auth' && evt.Meta.sub_type == 'auth_fail'",
+  "evt.Meta.log_type == 'mailu_admin_auth_attempt'",
+  "evt.Meta.log_type == 'mariadb_failed_auth'",
+  "evt.Meta.log_type == 'meshcentral_failed_auth'",
+  "evt.Meta.log_type == 'mikrotik_drop' && evt.Meta.service == 'tcp_udp'",
+  "evt.Meta.log_type == 'mikrotik_failed_auth'",
+  "evt.Meta.log_type == 'modsecurity' && (evt.Parsed.ruleseverity == 'CRITICAL' || evt.Parsed.ruleseverity == '2')",
+  "evt.Meta.log_type == 'mongodb_failed_auth'",
+  "evt.Meta.log_type == 'mssql_failed_auth'",
+  "evt.Meta.log_type == 'mysql_failed_auth'",
+  "evt.Meta.log_type == 'nextcloud_domain_error'",
+  "evt.Meta.log_type == 'nextcloud_failed_auth'",
+  "evt.Meta.log_type == 'odoo_failed_auth'",
+  "evt.Meta.log_type == 'ombi_auth_failed'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'bot protection'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'cross site redirect'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'cross site request forgery'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'cross site scripting'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'error disclosure'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'error limit'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'evasion techniques'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'general'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'http limit violation'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'illegal http method violation'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'ldap injection'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'open redirect'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'path traversal'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'remote code execution'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'request rate limit'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'schema validation'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'sql injection'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'url instead of file'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'vulnerability scanning'",
+  "evt.Meta.log_type == 'openappsec_security_log' and Lower(evt.Meta.security_action) in ['prevent', 'detect'] and Lower(evt.Meta.incident_type) contains 'xml external entity'",
+  "evt.Meta.log_type == 'opnsense-gui-failed-auth'",
+  "evt.Meta.log_type == 'paperless_ngx_failed_auth'",
+  "evt.Meta.log_type == 'pf' and evt.Parsed.action == 'block'",
+  "evt.Meta.log_type == 'pf_drop' && evt.Meta.service == 'tcp_udp'",
+  "evt.Meta.log_type == 'pftpd_failed-auth'",
+  "evt.Meta.log_type == 'pgsql_failed_auth'",
+  "evt.Meta.log_type == 'pterodactly_wings_invalid_format'",
+  "evt.Meta.log_type == 'pterodactly_wings_invalid_username_or_password'",
+  "evt.Meta.log_type == 'pve_failed-auth'",
+  "evt.Meta.log_type == 'redmine_failed_auth'",
+  "evt.Meta.log_type == 'smb_failed_auth'",
+  "evt.Meta.log_type == 'spam-attempt' && evt.Meta.service == 'exim'",
+  "evt.Meta.log_type == 'ssh_bad_keyexchange'",
+  "evt.Meta.log_type == 'ssh_failed-auth'",
+  "evt.Meta.log_type == 'sshesame_cmd'",
+  "evt.Meta.log_type == 'sshesame_input'",
+  "evt.Meta.log_type == 'sshesame_login'",
+  "evt.Meta.log_type == 'suricata_alert' && evt.Parsed.proto == 'TCP' && evt.Meta.suricata_rule_severity == '1'",
+  "evt.Meta.log_type == 'suricata_alert' && evt.Parsed.proto == 'TCP' && evt.Meta.suricata_rule_severity == '2'",
+  "evt.Meta.log_type == 'synology-dsm_failed_auth'",
+  "evt.Meta.log_type == 'telnet_new_session'",
+  "evt.Meta.log_type == 'thehive_failed_auth'",
+  "evt.Meta.log_type == 'ts3_fail_auth'",
+  "evt.Meta.log_type == 'vaultwarden_failed_auth'",
+  "evt.Meta.log_type == 'waf_naxsi-log' && len(evt.Parsed.naxsi_id) > 4",
+  "evt.Meta.log_type == 'webmin_failed_auth_wrong_pass'",
+  "evt.Meta.log_type == 'windows_failed_auth'",
+  "evt.Meta.log_type == 'wireguard_failed_auth'",
+  "evt.Meta.log_type == 'zimbra_auth_fail'",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"]\nand \n  (\n    ( Upper(evt.Meta.http_verb) == \"POST\" and\n        Upper(evt.Meta.http_path) matches Upper('^(?P<path>/.*index.php)?.*(?P<file_query>file=.*&lt;/td&gt;&lt;/tr(?P<payload>.*)&gt;)')\n    )\n    or \n    Upper(evt.Parsed.rawrequest) matches Upper('^(?P<verb>POST) (?P<path>/.*index.php)?.*(?P<file_query>file=.*&lt;/td&gt;&lt;/tr(?P<payload>.*)&gt;)')\n  )\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"]\nand \n(\n( Upper(evt.Meta.http_verb) == \"POST\" and\nUpper(evt.Meta.http_path) matches Upper('^(?P<path>/.*index.php)?.*(?P<view>view=request|request=log|task=create)+.*(?P<request_query>view=request|request=log|task=create)+.*(?P<task_query>view=request|request=log|task=create)+.*')\n\n)\nor\nUpper(evt.Parsed.rawrequest) matches Upper('^(?P<verb>POST) (?P<path>/.*index.php)?.*(?P<view>view=request|request=log|task=create)+.*(?P<request_query>view=request|request=log|task=create)+.*(?P<task_query>view=request|request=log|task=create)+.*')\n)\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"]\nand Upper(evt.Meta.http_verb) == \"GET\"\nand  Upper(evt.Meta.http_path) matches Upper('.*action=.*')\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] && RegexpInFile(evt.Parsed.http_user_agent, \"bad_user_agents.regex.txt\")",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and\n  (Upper(evt.Meta.http_path) contains 'CLASS.MODULE.CLASSLOADER.')\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and \n  (\n  Upper(evt.Meta.http_path) matches Upper('/tmui/login.jsp/..;/tmui/[^.]+.jsp\\\\?(fileName|command|directoryPath|tabId)=')\n  or\n  Upper(evt.Meta.http_path) matches Upper('/tmui/login.jsp/%2E%2E;/tmui/[^.]+.jsp\\\\?(fileName|command|directoryPath|tabId)=')\n  )\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and \n  (Upper(evt.Meta.http_path) contains \"/.%2E/.%2E/\"\n    or\n   Upper(evt.Meta.http_path) contains \"/%2E%2E/%2E%2E\")\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and \n  (Upper(evt.Meta.http_path) matches '/PUBLIC/PLUGINS/[^/]+/../[./]+/'\n  or\n  Upper(evt.Meta.http_path) matches '/PUBLIC/PLUGINS/[^/]+/%2E%2E/[%2E/]+/')\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and \n  (Upper(evt.Meta.http_path) matches Upper('/dana-na/../dana/html5acc/guacamole/../../../../../../../[^?]+\\\\?/dana/html5acc/guacamole/')\n  or\n  Upper(evt.Meta.http_path) matches Upper('/dana-na/%2E%2E/dana/html5acc/guacamole/%2E%2E/%2E%2E/%2E%2E/%2E%2E/%2E%2E/%2E%2E/%2E%2E/[^?]+\\\\?/dana/html5acc/guacamole/'))\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and \n  Upper(evt.Meta.http_path) contains \"/%%32%65%%32%65/\"\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and \n  Upper(evt.Meta.http_path) contains Upper('/remote/fgt_lang?lang=/../../../..//////////dev/cmdb/sslvpn_websession')\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and \n(\n  any(File(\"log4j2_cve_2021_44228.txt\"), { Upper(evt.Meta.http_path) contains Upper(#)})\nor\n  any(File(\"log4j2_cve_2021_44228.txt\"), { Upper(evt.Parsed.http_user_agent) contains Upper(#)})\nor\n  any(File(\"log4j2_cve_2021_44228.txt\"), { Upper(evt.Parsed.http_referer) contains Upper(#)})  \n)\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and \nUpper(evt.Meta.http_path) startsWith Upper('/api/v2/cmdb/system/admin/') and Lower(evt.Parsed.http_user_agent) == 'report runner'\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and any(File(\"backdoors.txt\"), { evt.Parsed.file_name == #})",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and any(File(\"jira_cve_2021-26086.txt\"), {Upper(evt.Meta.http_path) contains Upper(#)})\n",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and any(File(\"sensitive_data.txt\"), { evt.Parsed.request endsWith #})",
+  "evt.Meta.log_type in [\"http_access-log\", \"http_error-log\"] and any(File(\"thinkphp_cve_2018-20062.txt\"), {Upper(evt.Meta.http_path) matches Upper(#)})\n",
+  "evt.Meta.log_type in ['authelia_failed_clf_auth', 'authelia_failed_json_auth']",
+  "evt.Meta.log_type in ['baikal_failed_auth', 'baikal_failed_auth_no_user']",
+  "evt.Meta.log_type in ['bitwarden_failed_auth','bitwarden_failed_auth_2fa']",
+  "evt.Meta.log_type in ['gitlab_failed_password', 'gitlab_failed_totp']",
+  "evt.Meta.log_type in ['http_access-log', 'http_error-log'] && Lower(QueryUnescape(evt.Meta.http_path)) startsWith Lower('/setup.cgi?next_file=netgear.cfg&todo=syscmd&cmd=')\n",
+  "evt.Meta.log_type in ['http_access-log', 'http_error-log'] && Upper(QueryUnescape(evt.Meta.http_path)) startsWith Upper('/Telerik.Web.UI.WebResource.axd?type=rau')\n",
+  "evt.Meta.log_type in ['http_access-log', 'http_error-log'] && Upper(QueryUnescape(evt.Meta.http_path)) startsWith Upper('/catalog-portal/ui/oauth/verify?error=&deviceUdid=${\"freemarker.template.utility.Execute\"?new()(')\n",
+  "evt.Meta.log_type in ['http_access-log', 'http_error-log'] && any(File('http_path_traversal.txt'),{evt.Meta.http_path contains #})",
+  "evt.Meta.log_type in ['http_access-log', 'http_error-log'] && any(File('sqli_probe_patterns.txt'), {Upper(evt.Parsed.http_args) contains Upper(#)})",
+  "evt.Meta.log_type in ['http_access-log', 'http_error-log'] && any(File('xss_probe_patterns.txt'), {Upper(evt.Parsed.http_args) contains Upper(#)})",
+  "evt.Meta.log_type in ['http_access-log', 'http_error-log'] && evt.Meta.http_path matches '/ui/vcav-bootstrap/rest/vcav-providers/provider-logo\\\\?url=(file|http)'\n",
+  "evt.Meta.log_type in ['http_access-log', 'http_error-log'] && evt.Parsed.static_ressource == 'false' && evt.Parsed.verb in ['GET', 'HEAD']",
+  "evt.Meta.log_type in ['nextcloud_failed_auth', 'nextcloud_bruteforce_attempt']",
+  "evt.Meta.log_type in ['prowlarr_failed_authentication']",
+  "evt.Meta.log_type in ['radarr_failed_authentication']",
+  "evt.Meta.log_type in ['sonarr_failed_authentication']",
+  "evt.Meta.log_type in ['uptime_kuma_failed_password', 'uptime_kuma_failed_totp']",
+  "evt.Meta.log_type in ['vaultwarden_failed_auth', 'vaultwarden_failed_admin_auth', 'vaultwarden_failed_totp']",
+  "evt.Meta.log_type_enh == 'spam-attempt' || evt.Meta.log_type == 'postfix' && evt.Meta.action == 'reject'",
+  "evt.Meta.metric_name in ['account.login.failed_invalid_user', 'account.login.failed_invalid_password']",
+  "evt.Meta.ppid",
+  "evt.Meta.service == 'exchange' && evt.Meta.sub_type == 'auth_fail'",
+  "evt.Meta.service == 'freeswitch' && evt.Meta.sub_type == 'acl_reject'",
+  "evt.Meta.service == 'freeswitch' && evt.Meta.sub_type == 'auth_failure'",
+  "evt.Meta.service == 'freeswitch' && evt.Meta.sub_type == 'user_enumeration'",
+  "evt.Meta.service == 'http' && evt.Meta.http_status in ['404', '403', '400'] && evt.Parsed.static_ressource == 'false'",
+  "evt.Meta.service == 'http' && evt.Meta.log_type in ['http_access-log', 'http_error-log']",
+  "evt.Meta.service == 'http' && evt.Meta.sub_type == 'auth_fail'",
+  "evt.Meta.service == 'http' && evt.Meta.sub_type == 'litespeed_admin_auth_fail'",
+  "evt.Meta.service == 'llng' and evt.Meta.log_type == 'llng_auth_fail'",
+  "evt.Meta.service == 'postscreen' && evt.Meta.pregreet == 'PREGREET'",
+  "evt.Meta.service == 'sysmon' && evt.Parsed.EventID == '1' &&\nevt.Parsed.ParentImage endsWith \"\\\\svchost.exe\" &&\nevt.Parsed.Image endsWith \"\\\\rundll32.exe\" &&\nevt.Parsed.CommandLine contains \"C:\\\\windows\\\\system32\\\\davclnt.dll,DavSetCookie\" &&\nevt.Parsed.CommandLine matches '://\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}' &&\n(not (evt.Parsed.CommandLine contains \"://10.\" ||\n      evt.Parsed.CommandLine contains \"://192.168.\" ||\n      evt.Parsed.CommandLine contains \"://172.16.\" ||\n      evt.Parsed.CommandLine contains \"://172.17.\" ||\n      evt.Parsed.CommandLine contains \"://172.18.\" ||\n      evt.Parsed.CommandLine contains \"://172.19.\" ||\n      evt.Parsed.CommandLine contains \"://172.20.\" ||\n      evt.Parsed.CommandLine contains \"://172.21.\" ||\n      evt.Parsed.CommandLine contains \"://172.22.\" ||\n      evt.Parsed.CommandLine contains \"://172.23.\" ||\n      evt.Parsed.CommandLine contains \"://172.24.\" ||\n      evt.Parsed.CommandLine contains \"://172.25.\" ||\n      evt.Parsed.CommandLine contains \"://172.26.\" ||\n      evt.Parsed.CommandLine contains \"://172.27.\" ||\n      evt.Parsed.CommandLine contains \"://172.28.\" ||\n      evt.Parsed.CommandLine contains \"://172.29.\" ||\n      evt.Parsed.CommandLine contains \"://172.30.\" ||\n      evt.Parsed.CommandLine contains \"://172.31.\" ||\n      evt.Parsed.CommandLine contains \"://127.\" ||\n      evt.Parsed.CommandLine contains \"://169.254.\"))\n",
+  "evt.Meta.service == 'sysmon' && evt.Parsed.EventID == '1' && \nUpper(evt.Parsed.Image) endsWith 'MSDT.EXE' && \nUpper(evt.Parsed.ParentImage) endsWith 'WINWORD.EXE' &&\n(Upper(evt.Parsed.CommandLine) contains 'PCWDIAGNOSTIC' && Upper(evt.Parsed.CommandLine) contains 'IT_REBROWSEFORFILE' && Upper(evt.Parsed.CommandLine) contains 'IT_BROWSEFORFILE')\n",
+  "evt.Meta.service in [\"tcp\", \"udp\"] && evt.Unmarshaled.iptables.OUT == \"\" ? \"iptables_drop\" : \"\"",
+  "evt.Meta.source_ip",
+  "evt.Meta.sub_type == 'req_limit_exceeded'",
+  "evt.Meta.target_user",
+  "evt.Meta.user_arn",
+  "evt.Overflow.Alert.GetScenario() == 'crowdsecurity/auditd-sus-exec' && all(evt.Overflow.Alert.Events, {.GetMeta('exe') matches '\\\\.nvm\\\\/versions\\\\/node\\\\/v(\\\\d+)\\\\.(\\\\d+)\\\\.(\\\\d+)\\\\/bin\\\\/node$'})",
+  "evt.Overflow.Alert.Remediation == true && IsIPV6(evt.Overflow.Alert.Source.IP)",
+  "evt.Overflow.Alert.Remediation == true && evt.Overflow.Alert.GetScope() == 'Ip'",
+  "evt.Overflow.Alert.Source.IP",
+  "evt.Parsed.Channel == 'Application' && evt.Parsed.Source == 'MSSQLSERVER' && evt.Parsed.EventID == '18456'",
+  "evt.Parsed.Channel == 'Microsoft-Windows-Sysmon/Operational'",
+  "evt.Parsed.Channel == 'Security' && evt.Parsed.EventID == '4625'",
+  "evt.Parsed.User",
+  "evt.Parsed.action",
+  "evt.Parsed.app",
+  "evt.Parsed.asterisk_service",
+  "evt.Parsed.asterisk_session_id",
+  "evt.Parsed.auth_method",
+  "evt.Parsed.auth_result",
+  "evt.Parsed.cas_client_ip",
+  "evt.Parsed.cas_invalid_user",
+  "evt.Parsed.client",
+  "evt.Parsed.client_ip",
+  "evt.Parsed.clientip",
+  "evt.Parsed.cri_timestamp",
+  "evt.Parsed.date",
+  "evt.Parsed.date + ' ' + evt.Parsed.time",
+  "evt.Parsed.datetime",
+  "evt.Parsed.day + \" \" + evt.Parsed.month + \" \" + evt.Parsed.monthday + \" \" + evt.Parsed.time + \".000000\" + \" \" + evt.Parsed.year",
+  "evt.Parsed.db_name",
+  "evt.Parsed.dest_ip",
+  "evt.Parsed.dest_port",
+  "evt.Parsed.dovecot_remote_ip",
+  "evt.Parsed.dst_country",
+  "evt.Parsed.dst_port",
+  "evt.Parsed.elb_status_code",
+  "evt.Parsed.email",
+  "evt.Parsed.error",
+  "evt.Parsed.event_inc_id",
+  "evt.Parsed.fastly_timestamp + \".00+\" + evt.Parsed.tz_part1 + \":\" + evt.Parsed.tz_part2",
+  "evt.Parsed.file_frag + evt.Parsed.file_ext",
+  "evt.Parsed.haproxy_monthday + '/' + evt.Parsed.haproxy_month   + '/' + evt.Parsed.haproxy_year  + ':' +   evt.Parsed.haproxy_hour + ':' + evt.Parsed.haproxy_minute + ':' +  evt.Parsed.haproxy_second[0:2] + ' -0000'",
+  "evt.Parsed.http_path",
+  "evt.Parsed.http_request",
+  "evt.Parsed.http_status_code",
+  "evt.Parsed.http_user_agent",
+  "evt.Parsed.http_verb",
+  "evt.Parsed.invalid_user",
+  "evt.Parsed.ipAddress",
+  "evt.Parsed.ip_source",
+  "evt.Parsed.log_level",
+  "evt.Parsed.logsource",
+  "evt.Parsed.message contains 'PVEFW-reject' or evt.Parsed.message contains 'DROP' or evt.Parsed.message contains 'REJECT'",
+  "evt.Parsed.method",
+  "evt.Parsed.naxsi_src_ip",
+  "evt.Parsed.pgsql_dbname",
+  "evt.Parsed.pgsql_target_user",
+  "evt.Parsed.pregreet",
+  "evt.Parsed.program == \"gotify\"",
+  "evt.Parsed.program == \"suricata-evelogs\" && JsonExtract(evt.Parsed.message, \"event_type\") == \"alert\"\n",
+  "evt.Parsed.program == \"zoneminder\"",
+  "evt.Parsed.program == 'Prowlarr'",
+  "evt.Parsed.program == 'Radarr'",
+  "evt.Parsed.program == 'adguardhome'",
+  "evt.Parsed.program == 'apache-guacamole'",
+  "evt.Parsed.program == 'asterisk'",
+  "evt.Parsed.program == 'audit'",
+  "evt.Parsed.program == 'auditd'",
+  "evt.Parsed.program == 'authelia'",
+  "evt.Parsed.program == 'aws-cloudtrail'",
+  "evt.Parsed.program == 'bitwarden'",
+  "evt.Parsed.program == 'cas'",
+  "evt.Parsed.program == 'cowrie'",
+  "evt.Parsed.program == 'cpanel'",
+  "evt.Parsed.program == 'dovecot'",
+  "evt.Parsed.program == 'dropbear'",
+  "evt.Parsed.program == 'emby'",
+  "evt.Parsed.program == 'endlessh'",
+  "evt.Parsed.program == 'exchange-imap'",
+  "evt.Parsed.program == 'exchange-pop'",
+  "evt.Parsed.program == 'exchange-smtp'",
+  "evt.Parsed.program == 'exim'",
+  "evt.Parsed.program == 'filterlog' or evt.Parsed.message matches '^filterlog:'",
+  "evt.Parsed.program == 'gitea'",
+  "evt.Parsed.program == 'grafana'",
+  "evt.Parsed.program == 'harbor'",
+  "evt.Parsed.program == 'home-assistant' or evt.Parsed.program endsWith 'homeassistant'",
+  "evt.Parsed.program == 'iis'",
+  "evt.Parsed.program == 'immich'",
+  "evt.Parsed.program == 'jellyfin'",
+  "evt.Parsed.program == 'jellyseerr'",
+  "evt.Parsed.program == 'k8s-audit'",
+  "evt.Parsed.program == 'kernel' and evt.Parsed.message contains 'IN=' and not (evt.Parsed.message contains 'ACCEPT')",
+  "evt.Parsed.program == 'kernel' and evt.Parsed.message contains 'wireguard:'",
+  "evt.Parsed.program == 'keycloak'",
+  "evt.Parsed.program == 'laurel'",
+  "evt.Parsed.program == 'litespeed'",
+  "evt.Parsed.program == 'magento-extension'",
+  "evt.Parsed.program == 'mailu-admin'",
+  "evt.Parsed.program == 'meshcentral'",
+  "evt.Parsed.program == 'mikrotik'",
+  "evt.Parsed.program == 'modsecurity'",
+  "evt.Parsed.program == 'mssql'",
+  "evt.Parsed.program == 'mysql'",
+  "evt.Parsed.program == 'odoo'",
+  "evt.Parsed.program == 'ombi'",
+  "evt.Parsed.program == 'openappsec' && JsonExtract(evt.Parsed.message, 'eventAudience') == 'Security' && Lower(JsonExtract(evt.Parsed.message, 'eventSeverity')) in ['critical', 'high'] && Lower(JsonExtract(evt.Parsed.message, 'eventData.practiceSubType')) in ['web application','web api']",
+  "evt.Parsed.program == 'palo-alto-threat'",
+  "evt.Parsed.program == 'pkexec'",
+  "evt.Parsed.program == 'postgres'",
+  "evt.Parsed.program == 'proftpd'",
+  "evt.Parsed.program == 'pterodactyl'",
+  "evt.Parsed.program == 'pure-ftpd'",
+  "evt.Parsed.program == 'pvedaemon'",
+  "evt.Parsed.program == 'redmine'",
+  "evt.Parsed.program == 'smb'",
+  "evt.Parsed.program == 'sshd'",
+  "evt.Parsed.program == 'sshesame'",
+  "evt.Parsed.program == 'sudo'",
+  "evt.Parsed.program == 'suricata-fastlogs'",
+  "evt.Parsed.program == 'tcpdump'",
+  "evt.Parsed.program == 'thehive'",
+  "evt.Parsed.program == 'ts3'",
+  "evt.Parsed.program == 'vsftpd'",
+  "evt.Parsed.program == 'windows-firewall' and evt.Parsed.message contains ' DROP TCP ' and evt.Parsed.message contains ' RECEIVE'",
+  "evt.Parsed.program in ['LLNG','lemonldap-ng']",
+  "evt.Parsed.program in ['mono', 'Sonarr']",
+  "evt.Parsed.program in ['postfix/postscreen', 'haproxy/postscreen']",
+  "evt.Parsed.program in ['postfix/smtpd','postfix/smtps/smtpd','postfix/submission/smtpd', 'postfix/smtps-haproxy/smtpd', 'postfix/submission-haproxy/smtpd']",
+  "evt.Parsed.program matches 'synoscgi_SYNO.API.Auth_[1-9]([0-9])?_login'",
+  "evt.Parsed.program startsWith 'apache2'",
+  "evt.Parsed.program startsWith 'caddy'",
+  "evt.Parsed.program startsWith 'freeswitch'",
+  "evt.Parsed.program startsWith 'haproxy'",
+  "evt.Parsed.program startsWith 'kasm'",
+  "evt.Parsed.program startsWith 'mariadb'",
+  "evt.Parsed.program startsWith 'nginx'",
+  "evt.Parsed.program startsWith 'nginx-proxy-manager'",
+  "evt.Parsed.program startsWith 'traefik'",
+  "evt.Parsed.program startsWith 'zimbra'",
+  "evt.Parsed.rbl_url",
+  "evt.Parsed.remote_addr",
+  "evt.Parsed.remote_host",
+  "evt.Parsed.remote_ip",
+  "evt.Parsed.remote_user",
+  "evt.Parsed.request",
+  "evt.Parsed.request_creation_time",
+  "evt.Parsed.response",
+  "evt.Parsed.rule",
+  "evt.Parsed.rule_id",
+  "evt.Parsed.ruledata",
+  "evt.Parsed.ruleid",
+  "evt.Parsed.rulemessage",
+  "evt.Parsed.severity",
+  "evt.Parsed.smtp_message",
+  "evt.Parsed.source_dns",
+  "evt.Parsed.source_helo",
+  "evt.Parsed.source_ip",
+  "evt.Parsed.source_rdns",
+  "evt.Parsed.source_user",
+  "evt.Parsed.sourcehost",
+  "evt.Parsed.src_country",
+  "evt.Parsed.src_ip",
+  "evt.Parsed.sshd_client_ip",
+  "evt.Parsed.sshd_invalid_user",
+  "evt.Parsed.sshesame_cmd",
+  "evt.Parsed.sshesame_input",
+  "evt.Parsed.sshesame_user",
+  "evt.Parsed.status",
+  "evt.Parsed.suricata_rule_severity",
+  "evt.Parsed.syslog_timestamp",
+  "evt.Parsed.target_fqdn",
+  "evt.Parsed.target_ip",
+  "evt.Parsed.target_port",
+  "evt.Parsed.target_uri",
+  "evt.Parsed.target_user",
+  "evt.Parsed.tcpflags contains 'S' ? 'true' : 'false'",
+  "evt.Parsed.telnet_session",
+  "evt.Parsed.threat_id",
+  "evt.Parsed.time",
+  "evt.Parsed.time + 'Z'",
+  "evt.Parsed.time_local",
+  "evt.Parsed.timestamp",
+  "evt.Parsed.timestamp + \"Z\"",
+  "evt.Parsed.timestamp8601",
+  "evt.Parsed.traefik_router_name",
+  "evt.Parsed.unix_epoch",
+  "evt.Parsed.user",
+  "evt.Parsed.user_agent",
+  "evt.Parsed.username",
+  "evt.Parsed.verb",
+  "evt.Parsed.year+ \"/\" + evt.Parsed.month + \"/\" + evt.Parsed.day + \" \" + evt.Parsed.time",
+  "evt.StrTime",
+  "evt.StrTime != ''",
+  "evt.Unmarshaled.auditd.auid",
+  "evt.Unmarshaled.auditd.exe",
+  "evt.Unmarshaled.auditd.msg",
+  "evt.Unmarshaled.auditd.ppid",
+  "evt.Unmarshaled.auditd.tty",
+  "evt.Unmarshaled.auditd.uid",
+  "evt.Unmarshaled.cloudtrail.awsRegion",
+  "evt.Unmarshaled.cloudtrail.errorCode",
+  "evt.Unmarshaled.cloudtrail.eventID",
+  "evt.Unmarshaled.cloudtrail.eventName",
+  "evt.Unmarshaled.cloudtrail.eventSource",
+  "evt.Unmarshaled.cloudtrail.eventTime",
+  "evt.Unmarshaled.cloudtrail.userAgent",
+  "evt.Unmarshaled.cloudtrail.userIdentity.accountId",
+  "evt.Unmarshaled.cloudtrail.userIdentity.type",
+  "evt.Unmarshaled.cloudtrail.userIdentity?.arn ?? evt.Unmarshaled.cloudtrail.userIdentity.userName\n",
+  "evt.Unmarshaled.iptables.CODE",
+  "evt.Unmarshaled.iptables.DPT",
+  "evt.Unmarshaled.iptables.DST",
+  "evt.Unmarshaled.iptables.IN",
+  "evt.Unmarshaled.iptables.LEN",
+  "evt.Unmarshaled.iptables.PROTO",
+  "evt.Unmarshaled.iptables.SPT",
+  "evt.Unmarshaled.iptables.SRC",
+  "evt.Unmarshaled.iptables.TYPE",
+  "evt.Unmarshaled.k8s_audit.ObjectRef?.Name",
+  "evt.Unmarshaled.k8s_audit.ObjectRef?.Namespace",
+  "evt.Unmarshaled.k8s_audit.RequestObject?.kind",
+  "evt.Unmarshaled.k8s_audit.RequestReceivedTimestamp",
+  "evt.Unmarshaled.k8s_audit.SourceIPs[0]",
+  "evt.Unmarshaled.k8s_audit.User.username",
+  "evt.Unmarshaled.k8s_audit.objectRef?.name",
+  "evt.Unmarshaled.k8s_audit.objectRef?.namespace",
+  "evt.Unmarshaled.k8s_audit.requestObject?.kind",
+  "evt.Unmarshaled.k8s_audit.requestReceivedTimestamp",
+  "evt.Unmarshaled.k8s_audit.sourceIPs[0]",
+  "evt.Unmarshaled.k8s_audit.user.username",
+  "evt.Unmarshaled.laurel.ID",
+  "evt.Unmarshaled.laurel.SYSCALL.PPID.exe",
+  "evt.Unmarshaled.laurel.SYSCALL.SYSCALL",
+  "evt.Unmarshaled.laurel.SYSCALL.exe",
+  "evt.Unmarshaled.laurel.SYSCALL.tty",
+  "evt.Unmarshaled.traefik.ClientHost",
+  "evt.Unmarshaled.traefik.DownstreamContentSize != nil ? int(evt.Unmarshaled.traefik.DownstreamContentSize) : nil",
+  "evt.Unmarshaled.traefik.RequestAddr",
+  "evt.Unmarshaled.traefik.RequestMethod",
+  "evt.Unmarshaled.traefik.RequestPath",
+  "evt.Unmarshaled.traefik.RouterName",
+  "evt.Unmarshaled.traefik.ServiceAddr != nil ? Split(evt.Unmarshaled.traefik.ServiceAddr, ':')[0] : nil",
+  "evt.Unmarshaled.traefik.time",
+  "evt.Unmarshaled.traefik[\"request_User-Agent\"]",
+  "filter(JsonExtractSlice(evt.Parsed.message, \"params\"), {.key == 'user' && .value.login != ''})[0]['value']['login']",
+  "int(evt.Unmarshaled.laurel.SYSCALL.auid)",
+  "int(evt.Unmarshaled.laurel.SYSCALL.ppid)",
+  "int(evt.Unmarshaled.laurel.SYSCALL.uid)",
+  "int(evt.Unmarshaled.traefik.DownstreamStatus)",
+  "int(evt.Unmarshaled.traefik.Duration)",
+  "len(evt.Parsed.http_args)"
+]

From ab22e901e74890895c8bc35452cfb8b2a9fc1610 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 19 Aug 2023 12:36:31 +0200
Subject: [PATCH 092/506] Add coredns tests

---
 test/coredns/coredns.go      | 179 +++++++++++++++++++++++++++++++++++
 test/coredns/coredns_test.go |  32 +++++++
 2 files changed, 211 insertions(+)
 create mode 100644 test/coredns/coredns.go
 create mode 100644 test/coredns/coredns_test.go

diff --git a/test/coredns/coredns.go b/test/coredns/coredns.go
new file mode 100644
index 000000000..068946487
--- /dev/null
+++ b/test/coredns/coredns.go
@@ -0,0 +1,179 @@
+package coredns
+
+import (
+	"context"
+	"errors"
+	"net"
+)
+
+func DefaultEnv(ctx context.Context, state *Request) map[string]interface{} {
+	return map[string]interface{}{
+		"incidr": func(ipStr, cidrStr string) (bool, error) {
+			ip := net.ParseIP(ipStr)
+			if ip == nil {
+				return false, errors.New("first argument is not an IP address")
+			}
+			_, cidr, err := net.ParseCIDR(cidrStr)
+			if err != nil {
+				return false, err
+			}
+			return cidr.Contains(ip), nil
+		},
+		"metadata": func(label string) string {
+			return ""
+		},
+		"type":        state.Type,
+		"name":        state.Name,
+		"class":       state.Class,
+		"proto":       state.Proto,
+		"size":        state.Len,
+		"client_ip":   state.IP,
+		"port":        state.Port,
+		"id":          func() int { return int(state.Req.Id) },
+		"opcode":      func() int { return state.Req.Opcode },
+		"do":          state.Do,
+		"bufsize":     state.Size,
+		"server_ip":   state.LocalIP,
+		"server_port": state.LocalPort,
+	}
+}
+
+type Request struct {
+	Req  *Msg
+	W    ResponseWriter
+	Zone string
+}
+
+func (r *Request) NewWithQuestion(name string, typ uint16) Request {
+	return Request{}
+}
+
+func (r *Request) IP() string {
+	return ""
+}
+
+func (r *Request) LocalIP() string {
+	return ""
+}
+
+func (r *Request) Port() string {
+	return ""
+}
+
+func (r *Request) LocalPort() string {
+	return ""
+}
+
+func (r *Request) RemoteAddr() string { return r.W.RemoteAddr().String() }
+
+func (r *Request) LocalAddr() string { return r.W.LocalAddr().String() }
+
+func (r *Request) Proto() string {
+	return "udp"
+}
+
+func (r *Request) Family() int {
+	return 2
+}
+
+func (r *Request) Do() bool {
+	return true
+}
+
+func (r *Request) Len() int { return 0 }
+
+func (r *Request) Size() int {
+	return 0
+}
+
+func (r *Request) SizeAndDo(m *Msg) bool {
+	return true
+}
+
+func (r *Request) Scrub(reply *Msg) *Msg {
+	return reply
+}
+
+func (r *Request) Type() string {
+	return ""
+}
+
+func (r *Request) QType() uint16 {
+	return 0
+}
+
+func (r *Request) Name() string {
+	return "."
+}
+
+func (r *Request) QName() string {
+	return "."
+}
+
+func (r *Request) Class() string {
+	return ""
+}
+
+func (r *Request) QClass() uint16 {
+	return 0
+}
+
+func (r *Request) Clear() {
+}
+
+func (r *Request) Match(reply *Msg) bool {
+	return true
+}
+
+type Msg struct {
+	MsgHdr
+	Compress bool `json:"-"`
+	Question []Question
+	Answer   []RR
+	Ns       []RR
+	Extra    []RR
+}
+
+type MsgHdr struct {
+	Id                 uint16
+	Response           bool
+	Opcode             int
+	Authoritative      bool
+	Truncated          bool
+	RecursionDesired   bool
+	RecursionAvailable bool
+	Zero               bool
+	AuthenticatedData  bool
+	CheckingDisabled   bool
+	Rcode              int
+}
+
+type Question struct {
+	Name   string `dns:"cdomain-name"`
+	Qtype  uint16
+	Qclass uint16
+}
+
+type RR interface {
+	Header() *RR_Header
+	String() string
+}
+
+type RR_Header struct {
+	Name     string `dns:"cdomain-name"`
+	Rrtype   uint16
+	Class    uint16
+	Ttl      uint32
+	Rdlength uint16
+}
+
+type ResponseWriter interface {
+	LocalAddr() net.Addr
+	RemoteAddr() net.Addr
+	WriteMsg(*Msg) error
+	Write([]byte) (int, error)
+	Close() error
+	TsigStatus() error
+	TsigTimersOnly(bool)
+	Hijack()
+}
diff --git a/test/coredns/coredns_test.go b/test/coredns/coredns_test.go
new file mode 100644
index 000000000..07a7a39cb
--- /dev/null
+++ b/test/coredns/coredns_test.go
@@ -0,0 +1,32 @@
+package coredns_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/test/coredns"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCoreDNS(t *testing.T) {
+	env := coredns.DefaultEnv(context.Background(), &coredns.Request{})
+
+	tests := []struct {
+		input string
+	}{
+		{`metadata('geoip/city/name') == 'Exampleshire'`},
+		{`(type() == 'A' && name() == 'example.com') || client_ip() == '1.2.3.4'`},
+		{`name() matches '^abc\\..*\\.example\\.com\\.$'`},
+		{`type() in ['A', 'AAAA']`},
+		{`incidr(client_ip(), '192.168.0.0/16')`},
+		{`incidr(client_ip(), '127.0.0.0/24')`},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			_, err := expr.Compile(test.input, expr.Env(env))
+			assert.NoError(t, err)
+		})
+	}
+}

From 5597289d61367f1715f4bc7b2f24bd4b25f45cb2 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 19 Aug 2023 22:24:42 +0200
Subject: [PATCH 093/506] Allow to disable builtins

---
 builtin/builtin.go      | 19 ++++-------
 builtin/builtin_test.go | 71 +++++++++++++++++++++++++++++++++++++++++
 checker/checker.go      |  5 ++-
 compiler/compiler.go    |  2 +-
 conf/config.go          | 34 ++++++++++----------
 expr.go                 | 33 +++++++++++++++----
 parser/parser.go        | 20 ++++++------
 parser/parser_test.go   |  5 +--
 vm/program.go           |  2 +-
 vm/vm.go                |  2 +-
 10 files changed, 141 insertions(+), 52 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 5a0136175..c822b59fb 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -12,19 +12,13 @@ import (
 )
 
 type Function struct {
-	Name  string
-	Func  func(args ...interface{}) (interface{}, error)
-	Types []reflect.Type
-
-	builtin  bool // true if function is builtin
+	Name     string
+	Func     func(args ...interface{}) (interface{}, error)
+	Types    []reflect.Type
 	Builtin1 func(arg interface{}) interface{}
 	Validate func(args []reflect.Type) (reflect.Type, error)
 }
 
-func (f Function) Builtin() bool {
-	return f.builtin
-}
-
 var (
 	Index map[string]int
 	Names []string
@@ -32,15 +26,14 @@ var (
 
 func init() {
 	Index = make(map[string]int)
-	Names = make([]string, len(Functions))
-	for i, fn := range Functions {
-		fn.builtin = true
+	Names = make([]string, len(Builtins))
+	for i, fn := range Builtins {
 		Index[fn.Name] = i
 		Names[i] = fn.Name
 	}
 }
 
-var Functions = []*Function{
+var Builtins = []*Function{
 	{
 		Name:     "len",
 		Builtin1: Len,
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 4cde5ab48..f3fd9dffb 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/conf"
 	"github.com/antonmedv/expr/parser"
@@ -218,3 +219,73 @@ func TestBuiltin_disallow_builtins_override(t *testing.T) {
 		})
 	})
 }
+
+func TestBuiltin_DisableBuiltin(t *testing.T) {
+	t.Run("via env", func(t *testing.T) {
+		for _, name := range builtin.Names {
+			t.Run(name, func(t *testing.T) {
+				env := map[string]interface{}{
+					name: func() int { return 42 },
+				}
+				program, err := expr.Compile(name+"()", expr.Env(env), expr.DisableBuiltin(name))
+				require.NoError(t, err)
+
+				out, err := expr.Run(program, env)
+				require.NoError(t, err)
+				assert.Equal(t, 42, out)
+			})
+		}
+	})
+	t.Run("via expr.Function", func(t *testing.T) {
+		for _, name := range builtin.Names {
+			t.Run(name, func(t *testing.T) {
+				fn := expr.Function(name,
+					func(params ...interface{}) (interface{}, error) {
+						return 42, nil
+					},
+					new(func() int),
+				)
+				program, err := expr.Compile(name+"()", fn, expr.DisableBuiltin(name))
+				require.NoError(t, err)
+
+				out, err := expr.Run(program, nil)
+				require.NoError(t, err)
+				assert.Equal(t, 42, out)
+			})
+		}
+	})
+}
+
+func TestBuiltin_DisableAllBuiltins(t *testing.T) {
+	_, err := expr.Compile(`len("foo")`, expr.Env(nil), expr.DisableAllBuiltins())
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "unknown name len")
+}
+
+func TestBuiltin_EnableBuiltin(t *testing.T) {
+	t.Run("via env", func(t *testing.T) {
+		env := map[string]interface{}{
+			"repeat": func() string { return "repeat" },
+		}
+		program, err := expr.Compile(`len(repeat())`, expr.Env(env), expr.DisableAllBuiltins(), expr.EnableBuiltin("len"))
+		require.NoError(t, err)
+
+		out, err := expr.Run(program, env)
+		require.NoError(t, err)
+		assert.Equal(t, 6, out)
+	})
+	t.Run("via expr.Function", func(t *testing.T) {
+		fn := expr.Function("repeat",
+			func(params ...interface{}) (interface{}, error) {
+				return "repeat", nil
+			},
+			new(func() string),
+		)
+		program, err := expr.Compile(`len(repeat())`, fn, expr.DisableAllBuiltins(), expr.EnableBuiltin("len"))
+		require.NoError(t, err)
+
+		out, err := expr.Run(program, nil)
+		require.NoError(t, err)
+		assert.Equal(t, 6, out)
+	})
+}
diff --git a/checker/checker.go b/checker/checker.go
index c04c09f31..fe31f8c92 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -138,6 +138,9 @@ func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 	if node.Value == "$env" {
 		return mapType, info{}
 	}
+	if fn, ok := v.config.Builtins[node.Value]; ok {
+		return functionType, info{fn: fn}
+	}
 	if fn, ok := v.config.Functions[node.Value]; ok {
 		return functionType, info{fn: fn}
 	}
@@ -664,7 +667,7 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 		case "get":
 			return v.checkBuiltinGet(node)
 		}
-		return v.checkFunction(builtin.Functions[id], node, node.Arguments)
+		return v.checkFunction(builtin.Builtins[id], node, node.Arguments)
 	}
 
 	return v.error(node, "unknown builtin %v", node.Name)
diff --git a/compiler/compiler.go b/compiler/compiler.go
index d32ba55e4..89a44039e 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -700,7 +700,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
-		f := builtin.Functions[id]
+		f := builtin.Builtins[id]
 		for _, arg := range node.Arguments {
 			c.compile(arg)
 		}
diff --git a/conf/config.go b/conf/config.go
index 2989eab81..f89e6cca0 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -19,22 +19,26 @@ type Config struct {
 	ExpectAny   bool
 	Optimize    bool
 	Strict      bool
+	Pipes       bool
 	ConstFns    map[string]reflect.Value
 	Visitors    []ast.Visitor
 	Functions   map[string]*builtin.Function
-	Pipes       bool
+	Builtins    map[string]*builtin.Function
+	Disabled    map[string]bool // disabled builtins
 }
 
 // CreateNew creates new config with default values.
 func CreateNew() *Config {
 	c := &Config{
+		Optimize:  true,
 		Operators: make(map[string][]string),
 		ConstFns:  make(map[string]reflect.Value),
 		Functions: make(map[string]*builtin.Function),
-		Optimize:  true,
+		Builtins:  make(map[string]*builtin.Function),
+		Disabled:  make(map[string]bool),
 	}
-	for _, f := range builtin.Functions {
-		c.Functions[f.Name] = f
+	for _, f := range builtin.Builtins {
+		c.Builtins[f.Name] = f
 	}
 	return c
 }
@@ -95,23 +99,19 @@ func (c *Config) Check() {
 			}
 		}
 	}
-	for name, t := range c.Types {
-		if kind(t.Type) != reflect.Func {
-			continue
-		}
-		for _, b := range builtin.Names {
-			if b == name {
-				panic(fmt.Errorf(`cannot override builtin %s(); it is already defined in expr`, name))
+	for fnName, t := range c.Types {
+		if kind(t.Type) == reflect.Func {
+			for _, b := range c.Builtins {
+				if b.Name == fnName {
+					panic(fmt.Errorf(`cannot override builtin %s(): use expr.DisableBuiltin("%s") to override`, b.Name, b.Name))
+				}
 			}
 		}
 	}
 	for _, f := range c.Functions {
-		if f.Builtin() {
-			continue
-		}
-		for _, b := range builtin.Names {
-			if b == f.Name {
-				panic(fmt.Errorf(`cannot override builtin %s(); it is already defined in expr`, f.Name))
+		for _, b := range c.Builtins {
+			if b.Name == f.Name {
+				panic(fmt.Errorf(`cannot override builtin %s(); use expr.DisableBuiltin("%s") to override`, f.Name, f.Name))
 			}
 		}
 	}
diff --git a/expr.go b/expr.go
index 6314314b1..973bdc108 100644
--- a/expr.go
+++ b/expr.go
@@ -137,13 +137,38 @@ func ExperimentalPipes() Option {
 	}
 }
 
+// DisableAllBuiltins disables all builtins.
+func DisableAllBuiltins() Option {
+	return func(c *conf.Config) {
+		for name := range c.Builtins {
+			c.Disabled[name] = true
+		}
+	}
+}
+
+// DisableBuiltin disables builtin function.
+func DisableBuiltin(name string) Option {
+	return func(c *conf.Config) {
+		c.Disabled[name] = true
+	}
+}
+
+// EnableBuiltin enables builtin function.
+func EnableBuiltin(name string) Option {
+	return func(c *conf.Config) {
+		delete(c.Disabled, name)
+	}
+}
+
 // Compile parses and compiles given input expression to bytecode program.
 func Compile(input string, ops ...Option) (*vm.Program, error) {
 	config := conf.CreateNew()
-
 	for _, op := range ops {
 		op(config)
 	}
+	for name := range config.Disabled {
+		delete(config.Builtins, name)
+	}
 	config.Check()
 
 	if len(config.Operators) > 0 {
@@ -153,11 +178,7 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 		})
 	}
 
-	parseConfig := parser.Config{
-		Pipes: config.Pipes,
-	}
-
-	tree, err := parser.ParseWithConfig(input, parseConfig)
+	tree, err := parser.ParseWithConfig(input, config)
 	if err != nil {
 		return nil, err
 	}
diff --git a/parser/parser.go b/parser/parser.go
index b1de4c9c0..102091748 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -7,6 +7,7 @@ import (
 
 	. "github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/builtin"
+	"github.com/antonmedv/expr/conf"
 	"github.com/antonmedv/expr/file"
 	. "github.com/antonmedv/expr/parser/lexer"
 	"github.com/antonmedv/expr/parser/operator"
@@ -31,7 +32,7 @@ type parser struct {
 	pos     int
 	err     *file.Error
 	depth   int // closure call depth
-	pipes   bool
+	config  *conf.Config
 }
 
 type Tree struct {
@@ -39,15 +40,14 @@ type Tree struct {
 	Source *file.Source
 }
 
-type Config struct {
-	Pipes bool
-}
-
 func Parse(input string) (*Tree, error) {
-	return ParseWithConfig(input, Config{})
+	return ParseWithConfig(input, &conf.Config{
+		Pipes:    false,
+		Disabled: map[string]bool{},
+	})
 }
 
-func ParseWithConfig(input string, config Config) (*Tree, error) {
+func ParseWithConfig(input string, config *conf.Config) (*Tree, error) {
 	source := file.NewSource(input)
 
 	tokens, err := Lex(source)
@@ -58,7 +58,7 @@ func ParseWithConfig(input string, config Config) (*Tree, error) {
 	p := &parser{
 		tokens:  tokens,
 		current: tokens[0],
-		pipes:   config.Pipes,
+		config:  config,
 	}
 
 	node := p.parseExpression(0)
@@ -340,7 +340,7 @@ func (p *parser) parseCall(token Token) Node {
 				Arguments: arguments,
 			}
 			node.SetLocation(token.Location)
-		} else if _, ok := builtin.Index[token.Value]; ok {
+		} else if _, ok := builtin.Index[token.Value]; ok && !p.config.Disabled[token.Value] {
 			node = &BuiltinNode{
 				Name:      token.Value,
 				Arguments: p.parseArguments(),
@@ -556,7 +556,7 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 }
 
 func (p *parser) parsePipe(node Node) Node {
-	if !p.pipes {
+	if !p.config.Pipes {
 		p.error("enable Pipes via expr.ExperimentalPipes()")
 		return &NilNode{}
 	}
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 0d5d62d47..bbd38476d 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	. "github.com/antonmedv/expr/ast"
+	"github.com/antonmedv/expr/conf"
 	"github.com/antonmedv/expr/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -453,7 +454,7 @@ func TestParse(t *testing.T) {
 					&BoolNode{Value: true}}}},
 	}
 	for _, test := range parseTests {
-		actual, err := parser.ParseWithConfig(test.input, parser.Config{Pipes: true})
+		actual, err := parser.ParseWithConfig(test.input, &conf.Config{Pipes: true})
 		if err != nil {
 			t.Errorf("%s:\n%v", test.input, err)
 			continue
@@ -657,7 +658,7 @@ func TestParse_pipe_operator(t *testing.T) {
 									Property: &StringNode{Value: "foo"},
 								}}}}}}}}
 
-	actual, err := parser.ParseWithConfig(input, parser.Config{Pipes: true})
+	actual, err := parser.ParseWithConfig(input, &conf.Config{Pipes: true})
 	require.NoError(t, err)
 	assert.Equal(t, Dump(expect), Dump(actual.Node))
 }
diff --git a/vm/program.go b/vm/program.go
index ea954cc7c..ccc7cfb41 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -73,7 +73,7 @@ func (program *Program) Opcodes(w io.Writer) {
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, c)
 		}
 		builtin := func(label string) {
-			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, builtin.Functions[arg].Name)
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, builtin.Builtins[arg].Name)
 		}
 		funcName := func(label string) {
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v()\n", pp, label, arg, program.FuncNames[arg])
diff --git a/vm/vm.go b/vm/vm.go
index 51e8bf1c0..343a02064 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -380,7 +380,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			vm.push(vm.call(vm.pop(), arg))
 
 		case OpCallBuiltin1:
-			vm.push(builtin.Functions[arg].Builtin1(vm.pop()))
+			vm.push(builtin.Builtins[arg].Builtin1(vm.pop()))
 
 		case OpArray:
 			size := vm.pop().(int)

From 887c98ea15c7e14b1fb619abb541608e4c62fec5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 19 Aug 2023 22:44:50 +0200
Subject: [PATCH 094/506] Remove splitN() and splitAfterN()

---
 builtin/builtin.go          | 40 ++++++++++++++++++++-----------------
 builtin/builtin_test.go     |  4 ++--
 docs/Language-Definition.md | 28 ++++++++------------------
 3 files changed, 32 insertions(+), 40 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index c822b59fb..f6f2a608a 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -164,30 +164,34 @@ var Builtins = []*Function{
 	{
 		Name: "split",
 		Func: func(args ...interface{}) (interface{}, error) {
-			return strings.Split(args[0].(string), args[1].(string)), nil
-		},
-		Types: types(strings.Split),
-	},
-	{
-		Name: "splitN",
-		Func: func(args ...interface{}) (interface{}, error) {
-			return strings.SplitN(args[0].(string), args[1].(string), runtime.ToInt(args[2])), nil
+			if len(args) == 2 {
+				return strings.Split(args[0].(string), args[1].(string)), nil
+			} else if len(args) == 3 {
+				return strings.SplitN(args[0].(string), args[1].(string), runtime.ToInt(args[2])), nil
+			} else {
+				return nil, fmt.Errorf("invalid number of arguments for split (expected 2 or 3, got %d)", len(args))
+			}
 		},
-		Types: types(strings.SplitN),
+		Types: types(
+			strings.Split,
+			strings.SplitN,
+		),
 	},
 	{
 		Name: "splitAfter",
 		Func: func(args ...interface{}) (interface{}, error) {
-			return strings.SplitAfter(args[0].(string), args[1].(string)), nil
-		},
-		Types: types(strings.SplitAfter),
-	},
-	{
-		Name: "splitAfterN",
-		Func: func(args ...interface{}) (interface{}, error) {
-			return strings.SplitAfterN(args[0].(string), args[1].(string), runtime.ToInt(args[2])), nil
+			if len(args) == 2 {
+				return strings.SplitAfter(args[0].(string), args[1].(string)), nil
+			} else if len(args) == 3 {
+				return strings.SplitAfterN(args[0].(string), args[1].(string), runtime.ToInt(args[2])), nil
+			} else {
+				return nil, fmt.Errorf("invalid number of arguments for splitAfter (expected 2 or 3, got %d)", len(args))
+			}
 		},
-		Types: types(strings.SplitAfterN),
+		Types: types(
+			strings.SplitAfter,
+			strings.SplitAfterN,
+		),
 	},
 	{
 		Name: "replace",
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index f3fd9dffb..937001ede 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -42,9 +42,9 @@ func TestBuiltin(t *testing.T) {
 		{`upper("foo")`, "FOO"},
 		{`lower("FOO")`, "foo"},
 		{`split("foo,bar,baz", ",")`, []string{"foo", "bar", "baz"}},
-		{`splitN("foo,bar,baz", ",", 2)`, []string{"foo", "bar,baz"}},
+		{`split("foo,bar,baz", ",", 2)`, []string{"foo", "bar,baz"}},
 		{`splitAfter("foo,bar,baz", ",")`, []string{"foo,", "bar,", "baz"}},
-		{`splitAfterN("foo,bar,baz", ",", 2)`, []string{"foo,", "bar,baz"}},
+		{`splitAfter("foo,bar,baz", ",", 2)`, []string{"foo,", "bar,baz"}},
 		{`replace("foo,bar,baz", ",", ";")`, "foo;bar;baz"},
 		{`replace("foo,bar,baz,goo", ",", ";", 2)`, "foo;bar;baz,goo"},
 		{`repeat("foo", 3)`, "foofoofoo"},
diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index d99f55cd3..7882a148b 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -303,36 +303,22 @@ Converts all the characters in string `v` to lowercase.
 lower("HELLO") == "hello"
 ```
 
-### split(v, delimiter)
+### split(v, delimiter[, n])
 
 Splits the string `v` at each instance of the delimiter and returns an array of substrings.
 
 ```expr
 split("apple,orange,grape", ",") == ["apple", "orange", "grape"]
+split("apple,orange,grape", ",", 2) == ["apple", "orange,grape"]
 ```
 
-### splitN(v, delimiter, n)
-
-Splits the string `v` at each instance of the delimiter but limits the result to `n` substrings.
-
-```expr
-splitN("apple,orange,grape", ",", 2) == ["apple", "orange,grape"]
-```
-
-### splitAfter(v, delimiter)
+### splitAfter(v, delimiter[, n])
 
 Splits the string `v` after each instance of the delimiter.
 
 ```expr
 splitAfter("apple,orange,grape", ",") == ["apple,", "orange,", "grape"]
-```
-
-### splitAfterN(v, delimiter, n)
-
-Splits the string `v` after each instance of the delimiter but limits the result to `n` substrings.
-
-```expr
-splitAfterN("apple,orange,grape", ",", 2) == ["apple,", "orange,grape"]
+splitAfter("apple,orange,grape", ",", 2) == ["apple,", "orange,grape"]
 ```
 
 ### replace(v, old, new)
@@ -351,12 +337,14 @@ Repeats the string `v` `n` times.
 repeat("Hi", 3) == "HiHiHi"
 ```
 
-### join(v, delimiter)
+### join(v[, delimiter])
 
 Joins an array of strings `v` into a single string with the given delimiter.
+If no delimiter is given, an empty string is used.
 
 ```expr
 join(["apple", "orange", "grape"], ",") == "apple,orange,grape"
+join(["apple", "orange", "grape"]) == "appleorangegrape"
 ```
 
 ### indexOf(v, substring)
@@ -457,7 +445,7 @@ Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
 duration("1h").Seconds() == 3600
 ```
 
-### date(v[, format, timezone])
+### date(v[, format[, timezone]])
 
 Converts the given value `v` into a date representation.
 

From b48b21c0469fba6113d9ea98e7f7fc6af93bbac7 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 19 Aug 2023 22:45:50 +0200
Subject: [PATCH 095/506] Remove invalid tests

---
 testdata/examples.txt | 2 --
 1 file changed, 2 deletions(-)

diff --git a/testdata/examples.txt b/testdata/examples.txt
index 46e90f47f..4e3782b00 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -14088,7 +14088,6 @@ obj.head(s, s) != obj.a
 obj.head(s[0])
 obj.head(s[a:1])
 obj.head(s[f])
-obj.head(splitAfter("c", "b", s, nil))
 obj.head(splitAfter("c", "c"))
 obj.head(string("a"), obj, a)
 obj.head(string("c", ok, ok))
@@ -19460,7 +19459,6 @@ toJSON(s startsWith s)
 toJSON(s)
 toJSON(s) in obj
 toJSON(s[0:0])
-toJSON(splitAfterN(s, s, 0))
 toJSON(string("a"))
 toJSON(string("c"))
 toJSON(string(0.5))

From 8dfd410f3a403cb14d93ab1b92bd2672b928720e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 19 Aug 2023 23:47:29 +0200
Subject: [PATCH 096/506] Add type() builtin

---
 builtin/builtin.go           |  5 +++++
 builtin/builtin_test.go      | 40 ++++++++++++++++++++++++++++++++++
 builtin/func.go              | 42 ++++++++++++++++++++++++++++++++++++
 builtin/utils.go             |  1 +
 docs/Language-Definition.md  | 13 +++++++++++
 test/coredns/coredns_test.go |  2 +-
 6 files changed, 102 insertions(+), 1 deletion(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index f6f2a608a..a58d2f953 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -48,6 +48,11 @@ var Builtins = []*Function{
 			return anyType, fmt.Errorf("invalid argument for len (type %s)", args[0])
 		},
 	},
+	{
+		Name:     "type",
+		Builtin1: Type,
+		Types:    types(new(func(interface{}) string)),
+	},
 	{
 		Name:     "abs",
 		Builtin1: Abs,
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 937001ede..fdc89aa1b 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -289,3 +289,43 @@ func TestBuiltin_EnableBuiltin(t *testing.T) {
 		assert.Equal(t, 6, out)
 	})
 }
+
+func TestBuiltin_type(t *testing.T) {
+	type Foo struct{}
+	var b interface{} = 1
+	var a interface{} = &b
+	tests := []struct {
+		obj  interface{}
+		want string
+	}{
+		{nil, "nil"},
+		{true, "bool"},
+		{1, "int"},
+		{int8(1), "int"},
+		{uint(1), "uint"},
+		{1.0, "float"},
+		{float32(1.0), "float"},
+		{"string", "string"},
+		{[]string{"foo", "bar"}, "array"},
+		{map[string]interface{}{"foo": "bar"}, "map"},
+		{func() {}, "func"},
+		{time.Now(), "time.Time"},
+		{time.Second, "time.Duration"},
+		{Foo{}, "github.com/antonmedv/expr/builtin_test.Foo"},
+		{struct{}{}, "struct"},
+		{a, "int"},
+	}
+	for _, test := range tests {
+		t.Run(test.want, func(t *testing.T) {
+			env := map[string]interface{}{
+				"obj": test.obj,
+			}
+			program, err := expr.Compile(`type(obj)`, expr.Env(env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, env)
+			require.NoError(t, err)
+			assert.Equal(t, test.want, out)
+		})
+	}
+}
diff --git a/builtin/func.go b/builtin/func.go
index 54fd383a0..a14f6553d 100644
--- a/builtin/func.go
+++ b/builtin/func.go
@@ -18,6 +18,48 @@ func Len(x interface{}) interface{} {
 	}
 }
 
+func Type(arg interface{}) interface{} {
+	if arg == nil {
+		return "nil"
+	}
+	v := reflect.ValueOf(arg)
+	for {
+		if v.Kind() == reflect.Ptr {
+			v = v.Elem()
+		} else if v.Kind() == reflect.Interface {
+			v = v.Elem()
+		} else {
+			break
+		}
+	}
+	if v.Type().Name() != "" && v.Type().PkgPath() != "" {
+		return fmt.Sprintf("%s.%s", v.Type().PkgPath(), v.Type().Name())
+	}
+	switch v.Type().Kind() {
+	case reflect.Invalid:
+		return "invalid"
+	case reflect.Bool:
+		return "bool"
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return "int"
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return "uint"
+	case reflect.Float32, reflect.Float64:
+		return "float"
+	case reflect.String:
+		return "string"
+	case reflect.Array, reflect.Slice:
+		return "array"
+	case reflect.Map:
+		return "map"
+	case reflect.Func:
+		return "func"
+	case reflect.Struct:
+		return "struct"
+	}
+	return "unknown"
+}
+
 func Abs(x interface{}) interface{} {
 	switch x.(type) {
 	case float32:
diff --git a/builtin/utils.go b/builtin/utils.go
index 1699c5ddd..afe169f76 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -8,6 +8,7 @@ var (
 	anyType     = reflect.TypeOf(new(interface{})).Elem()
 	integerType = reflect.TypeOf(0)
 	floatType   = reflect.TypeOf(float64(0))
+	stringType  = reflect.TypeOf("")
 	arrayType   = reflect.TypeOf([]interface{}{})
 )
 
diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 7882a148b..c08781a97 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -237,6 +237,19 @@ len(filter(array, predicate))
 
 Returns the length of an array, a map or a string.
 
+### type(v)
+
+Returns the type of the given value `v`.
+Returns on of the following types: `nil`, `bool`, `int`, `uint`, `float`, `string`, `array`, `map`.
+For named types and structs, the type name is returned.
+
+
+```expr
+type(42) == "int"
+type("hello") == "string"
+type(now()) == "time.Time"
+```
+
 ### abs(v)
 
 Returns the absolute value of a number.
diff --git a/test/coredns/coredns_test.go b/test/coredns/coredns_test.go
index 07a7a39cb..702b66c17 100644
--- a/test/coredns/coredns_test.go
+++ b/test/coredns/coredns_test.go
@@ -25,7 +25,7 @@ func TestCoreDNS(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
-			_, err := expr.Compile(test.input, expr.Env(env))
+			_, err := expr.Compile(test.input, expr.Env(env), expr.DisableBuiltin("type"))
 			assert.NoError(t, err)
 		})
 	}

From 956b65012a7d9a349200fea5e3389ed3aa80c71c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 19 Aug 2023 23:50:09 +0200
Subject: [PATCH 097/506] Add type to fuzz

---
 fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fuzz_test.go b/fuzz_test.go
index 3bbc789d8..00078e154 100644
--- a/fuzz_test.go
+++ b/fuzz_test.go
@@ -53,6 +53,7 @@ func FuzzExpr(f *testing.F) {
 		`a[:]`,
 		`a[1:-1]`,
 		`len(a)`,
+		`type(a)`,
 		`abs(-1)`,
 		`int(0.5)`,
 		`float(42)`,

From 1e991e4aa8f30fe2d03916bb9318bd4078115abb Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 20 Aug 2023 15:45:50 +0200
Subject: [PATCH 098/506] Remove redundant type for join()

---
 builtin/builtin.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index a58d2f953..32c03b94b 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -247,7 +247,6 @@ var Builtins = []*Function{
 		Types: types(
 			strings.Join,
 			new(func([]interface{}, string) string),
-			new(func([]string) string),
 			new(func([]interface{}) string),
 		),
 	},

From 3dd930053f2446468e481d5bc155bc6b2a09338a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 20 Aug 2023 15:49:37 +0200
Subject: [PATCH 099/506] Fix join() types

---
 builtin/builtin.go |  2 ++
 fuzz_test.go       | 40 +++++++++++++++++++---------------------
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 32c03b94b..6677a968d 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -248,6 +248,8 @@ var Builtins = []*Function{
 			strings.Join,
 			new(func([]interface{}, string) string),
 			new(func([]interface{}) string),
+			new(func([]string, string) string),
+			new(func([]string) string),
 		),
 	},
 	{
diff --git a/fuzz_test.go b/fuzz_test.go
index 00078e154..af8e1ffba 100644
--- a/fuzz_test.go
+++ b/fuzz_test.go
@@ -2,7 +2,6 @@ package expr_test
 
 import (
 	"regexp"
-	"strings"
 	"testing"
 
 	"github.com/antonmedv/expr"
@@ -10,15 +9,17 @@ import (
 
 func FuzzExpr(f *testing.F) {
 	env := map[string]interface{}{
-		"i": 1,
-		"j": 2,
-		"a": []int{1, 2, 3},
-		"m": map[string]interface{}{"a": 1, "b": 2, "m": map[string]int{"a": 1}},
-		"s": "abc",
+		"i":   1,
+		"j":   2,
+		"b":   true,
+		"a":   []int{1, 2, 3},
+		"m":   map[string]interface{}{"a": 1, "b": 2, "m": map[string]int{"a": 1}},
+		"s":   "abc",
+		"add": func(a, b int) int { return a + b },
 	}
 
-	fn := expr.Function(
-		"fn",
+	head := expr.Function(
+		"head",
 		func(params ...interface{}) (interface{}, error) {
 			return params[0], nil
 		},
@@ -85,9 +86,17 @@ func FuzzExpr(f *testing.F) {
 		`s matches "a"`,
 		`s matches "a+"`,
 		`true ? 1 : 2`,
-		`fn(1)`,
+		`false ? 1 : 2`,
+		`b ?? true`,
+		`head(1)`,
 		`{a: 1, b: 2}`,
 		`[1, 2, 3]`,
+		`type(1)`,
+		`type("a")`,
+		`type([1, 2, 3])`,
+		`type({a: 1, b: 2})`,
+		`type(head)`,
+		`keys(m)`,
 	}
 
 	for _, s := range corpus {
@@ -122,19 +131,8 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`operator "in" not defined on int`),
 	}
 
-	skipCode := []string{
-		`??`,
-	}
-
 	f.Fuzz(func(t *testing.T, code string) {
-		for _, skipCase := range skipCode {
-			if strings.Contains(code, skipCase) {
-				t.Skipf("skip code: %s", skipCase)
-				return
-			}
-		}
-
-		program, err := expr.Compile(code, expr.Env(env), fn, expr.ExperimentalPipes())
+		program, err := expr.Compile(code, expr.Env(env), head, expr.ExperimentalPipes())
 		if err != nil {
 			t.Skipf("compile error: %s", err)
 		}

From 32bcae1881f99d63cd9a70f2eb318309d59ff418 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 20 Aug 2023 15:52:09 +0200
Subject: [PATCH 100/506] Update fuzz_test.go

---
 fuzz_test.go | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/fuzz_test.go b/fuzz_test.go
index af8e1ffba..bd03c9ca2 100644
--- a/fuzz_test.go
+++ b/fuzz_test.go
@@ -16,6 +16,7 @@ func FuzzExpr(f *testing.F) {
 		"m":   map[string]interface{}{"a": 1, "b": 2, "m": map[string]int{"a": 1}},
 		"s":   "abc",
 		"add": func(a, b int) int { return a + b },
+		"foo": Foo{A: 1, B: 2, Bar: Bar{A: 1, B: 2}},
 	}
 
 	head := expr.Function(
@@ -97,13 +98,16 @@ func FuzzExpr(f *testing.F) {
 		`type({a: 1, b: 2})`,
 		`type(head)`,
 		`keys(m)`,
+		`values(m)`,
+		`foo.bar.a`,
+		`foo.bar.b`,
 	}
 
 	for _, s := range corpus {
 		f.Add(s)
 	}
 
-	okCases := []*regexp.Regexp{
+	skip := []*regexp.Regexp{
 		regexp.MustCompile(`cannot fetch .* from .*`),
 		regexp.MustCompile(`cannot get .* from .*`),
 		regexp.MustCompile(`cannot slice`),
@@ -139,8 +143,8 @@ func FuzzExpr(f *testing.F) {
 
 		_, err = expr.Run(program, env)
 		if err != nil {
-			for _, okCase := range okCases {
-				if okCase.MatchString(err.Error()) {
+			for _, r := range skip {
+				if r.MatchString(err.Error()) {
 					t.Skipf("skip error: %s", err)
 					return
 				}
@@ -149,3 +153,14 @@ func FuzzExpr(f *testing.F) {
 		}
 	})
 }
+
+type Foo struct {
+	A   int `expr:"a"`
+	B   int `expr:"b"`
+	Bar Bar `expr:"bar"`
+}
+
+type Bar struct {
+	A int `expr:"a"`
+	B int `expr:"b"`
+}

From 7601c630a7487c67c44bba4655ed66614f3d51a1 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 20 Aug 2023 18:11:33 +0200
Subject: [PATCH 101/506] Add fuzz dict and corpus

---
 fuzz_test.go             | 81 +++-------------------------------------
 testdata/fuzz_corpus.sh  | 21 +++++++++++
 testdata/fuzz_corpus.txt | 73 ++++++++++++++++++++++++++++++++++++
 testdata/fuzz_expr.dict  | 78 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 178 insertions(+), 75 deletions(-)
 create mode 100644 testdata/fuzz_corpus.sh
 create mode 100644 testdata/fuzz_corpus.txt
 create mode 100644 testdata/fuzz_expr.dict

diff --git a/fuzz_test.go b/fuzz_test.go
index bd03c9ca2..5770d8704 100644
--- a/fuzz_test.go
+++ b/fuzz_test.go
@@ -1,7 +1,9 @@
 package expr_test
 
 import (
+	"os"
 	"regexp"
+	"strings"
 	"testing"
 
 	"github.com/antonmedv/expr"
@@ -27,82 +29,11 @@ func FuzzExpr(f *testing.F) {
 		new(func(int) int),
 	)
 
-	corpus := []string{
-		`.5 + .5`,
-		`i + j`,
-		`i - j`,
-		`i * j`,
-		`i / j`,
-		`i % j`,
-		`true || false`,
-		`true && false`,
-		`i == j`,
-		`i != j`,
-		`i > j`,
-		`i >= j`,
-		`i < j`,
-		`i <= j`,
-		`i in a`,
-		`i not in a`,
-		`s in m`,
-		`m.a`,
-		`m.m.a`,
-		`a[0]`,
-		`a[i]`,
-		`a[i:j]`,
-		`a[i:]`,
-		`a[:j]`,
-		`a[:]`,
-		`a[1:-1]`,
-		`len(a)`,
-		`type(a)`,
-		`abs(-1)`,
-		`int(0.5)`,
-		`float(42)`,
-		`string(i)`,
-		`trim(" a ")`,
-		`trim("_a_", "_")`,
-		`trimPrefix("  a", " ")`,
-		`trimSuffix("a  ")`,
-		`upper("a")`,
-		`lower("A")`,
-		`split("a,b,c", ",")`,
-		`replace("a,b,c", ",", "_")`,
-		`repeat("a", 3)`,
-		`join(["a", "b", "c"], ",")`,
-		`indexOf("abc", "b")`,
-		`max(1,2,3)`,
-		`min(1,2,3)`,
-		`toJSON(a)`,
-		`fromJSON("[1,2,3]")`,
-		`now()`,
-		`duration("1s")`,
-		`first(a)`,
-		`last(a)`,
-		`get(m, "a")`,
-		`1..9 | filter(i > 5) | map(i * 2)`,
-		`s startsWith "a"`,
-		`s endsWith "c"`,
-		`s contains "a"`,
-		`s matches "a"`,
-		`s matches "a+"`,
-		`true ? 1 : 2`,
-		`false ? 1 : 2`,
-		`b ?? true`,
-		`head(1)`,
-		`{a: 1, b: 2}`,
-		`[1, 2, 3]`,
-		`type(1)`,
-		`type("a")`,
-		`type([1, 2, 3])`,
-		`type({a: 1, b: 2})`,
-		`type(head)`,
-		`keys(m)`,
-		`values(m)`,
-		`foo.bar.a`,
-		`foo.bar.b`,
+	b, err := os.ReadFile("./testdata/fuzz_corpus.txt")
+	if err != nil {
+		panic(err)
 	}
-
+	corpus := strings.Split(strings.TrimSpace(string(b)), "\n")
 	for _, s := range corpus {
 		f.Add(s)
 	}
diff --git a/testdata/fuzz_corpus.sh b/testdata/fuzz_corpus.sh
new file mode 100644
index 000000000..aa114a6a6
--- /dev/null
+++ b/testdata/fuzz_corpus.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+inputfile=./fuzz_corpus.txt
+zipname=fuzz_expr_seed_corpus.zip
+
+if [ ! -f "$inputfile" ]; then
+  echo "Error: File $inputfile not found!"
+  exit 1
+fi
+
+lineno=1
+while IFS= read -r line; do
+  echo "$line" >"file_${lineno}.txt"
+  ((lineno++))
+done <"$inputfile"
+
+zip "$zipname" file_*.txt
+
+rm file_*.txt
+
+echo "Done!"
diff --git a/testdata/fuzz_corpus.txt b/testdata/fuzz_corpus.txt
new file mode 100644
index 000000000..43b3f7e4a
--- /dev/null
+++ b/testdata/fuzz_corpus.txt
@@ -0,0 +1,73 @@
+.5 + .5
+i + j
+i - j
+i * j
+i / j
+i % j
+true || false
+true && false
+i == j
+i != j
+i > j
+i >= j
+i < j
+i <= j
+i in a
+i not in a
+s in m
+m.a
+m.m.a
+a[0]
+a[i]
+a[i:j]
+a[i:]
+a[:j]
+a[:]
+a[1:-1]
+len(a)
+type(a)
+abs(-1)
+int(0.5)
+float(42)
+string(i)
+trim(" a ")
+trim("_a_", "_")
+trimPrefix("  a", " ")
+trimSuffix("a  ")
+upper("a")
+lower("A")
+split("a,b,c", ",")
+replace("a,b,c", ",", "_")
+repeat("a", 3)
+join(["a", "b", "c"], ",")
+indexOf("abc", "b")
+max(1,2,3)
+min(1,2,3)
+toJSON(a)
+fromJSON("[1,2,3]")
+now()
+duration("1s")
+first(a)
+last(a)
+get(m, "a")
+1..9 | filter(i > 5) | map(i * 2)
+s startsWith "a"
+s endsWith "c"
+s contains "a"
+s matches "a"
+s matches "a+"
+true ? 1 : 2
+false ? 1 : 2
+b ?? true
+head(1)
+{a: 1, b: 2}
+[1, 2, 3]
+type(1)
+type("a")
+type([1, 2, 3])
+type({a: 1, b: 2})
+type(head)
+keys(m)
+values(m)
+foo.bar.a
+foo.bar.b
diff --git a/testdata/fuzz_expr.dict b/testdata/fuzz_expr.dict
new file mode 100644
index 000000000..9a22cae47
--- /dev/null
+++ b/testdata/fuzz_expr.dict
@@ -0,0 +1,78 @@
+"{"
+"}"
+","
+"["
+"]"
+"("
+")"
+":"
+"'"
+"\""
+"0.1"
+"1.2"
+"2.3"
+"-3.4"
+"-4.5"
+"-5.6"
+"1e2"
+"2e3"
+"-3e4"
+"-4e5"
+"0"
+"1"
+"2"
+"-3"
+"-4"
+"0x"
+"true"
+"false"
+"map"
+"filter"
+"all"
+"any"
+"none"
+"one"
+"and"
+"or"
+"in"
+"not"
+"in"
+"contains"
+"matches"
+"startsWith"
+"endsWith"
+"nil"
+"len"
+"type"
+"abs"
+"int"
+"float"
+"string"
+"trim"
+"trimPrefix"
+"trimSuffix"
+"upper"
+"lower"
+"split"
+"splitAfter"
+"replace"
+"repeat"
+"join"
+"indexOf"
+"lastIndexOf"
+"hasPrefix"
+"hasSuffix"
+"max"
+"min"
+"toJSON"
+"fromJSON"
+"toBase64"
+"fromBase64"
+"now"
+"duration"
+"date"
+"first"
+"last"
+"get"
+"keys"
+"values"

From 8cd12a9101da80c16bec41884016889e7730b828 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 20 Aug 2023 18:12:47 +0200
Subject: [PATCH 102/506] Add fuzz_expr_seed_corpus.zip

---
 testdata/fuzz_corpus.sh            |   0
 testdata/fuzz_expr_seed_corpus.zip | Bin 0 -> 11768 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 mode change 100644 => 100755 testdata/fuzz_corpus.sh
 create mode 100644 testdata/fuzz_expr_seed_corpus.zip

diff --git a/testdata/fuzz_corpus.sh b/testdata/fuzz_corpus.sh
old mode 100644
new mode 100755
diff --git a/testdata/fuzz_expr_seed_corpus.zip b/testdata/fuzz_expr_seed_corpus.zip
new file mode 100644
index 0000000000000000000000000000000000000000..5dfe76d50f2ef2cb0343ea613647f1a8d4396c46
GIT binary patch
literal 11768
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
F@;@7=Uwr@o

literal 0
HcmV?d00001


From cc5d2941ae614305b7a32584730c48d6aef4ced2 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 21 Aug 2023 11:58:29 +0200
Subject: [PATCH 103/506] Fix SliceNode String()

---
 ast/print.go      | 9 +++++++++
 ast/print_test.go | 7 +++++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/ast/print.go b/ast/print.go
index e95e88796..2e8744730 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -94,6 +94,15 @@ func (n *MemberNode) String() string {
 }
 
 func (n *SliceNode) String() string {
+	if n.From == nil && n.To == nil {
+		return fmt.Sprintf("%s[:]", n.Node.String())
+	}
+	if n.From == nil {
+		return fmt.Sprintf("%s[:%s]", n.Node.String(), n.To.String())
+	}
+	if n.To == nil {
+		return fmt.Sprintf("%s[%s:]", n.Node.String(), n.From.String())
+	}
 	return fmt.Sprintf("%s[%s:%s]", n.Node.String(), n.From.String(), n.To.String())
 }
 
diff --git a/ast/print_test.go b/ast/print_test.go
index 9517a0820..1b992511c 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/parser"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -63,14 +64,16 @@ func TestPrint(t *testing.T) {
 		{`a.b()`, `a.b()`},
 		{`a.b(c)`, `a.b(c)`},
 		{`a[1:-1]`, `a[1:-1]`},
+		{`a[1:]`, `a[1:]`},
+		{`a[1:]`, `a[1:]`},
+		{`a[:]`, `a[:]`},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.input, func(t *testing.T) {
 			tree, err := parser.Parse(tt.input)
 			require.NoError(t, err)
-
-			require.Equal(t, tt.want, tree.Node.String())
+			assert.Equal(t, tt.want, tree.Node.String())
 		})
 	}
 }

From c2c760322514aed85fe1fd3ac2fa7d6aba8e2dbe Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 21 Aug 2023 22:42:27 +0200
Subject: [PATCH 104/506] Fix builtin type checks for any

---
 builtin/builtin.go      |  8 ++++++++
 builtin/builtin_test.go | 27 +++++++++++++++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 6677a968d..f03162b2f 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -289,6 +289,8 @@ var Builtins = []*Function{
 			}
 			for _, arg := range args {
 				switch kind(arg) {
+				case reflect.Interface:
+					return anyType, nil
 				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
 				default:
 					return anyType, fmt.Errorf("invalid argument for max (type %s)", arg)
@@ -306,6 +308,8 @@ var Builtins = []*Function{
 			}
 			for _, arg := range args {
 				switch kind(arg) {
+				case reflect.Interface:
+					return anyType, nil
 				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
 				default:
 					return anyType, fmt.Errorf("invalid argument for min (type %s)", arg)
@@ -493,6 +497,8 @@ var Builtins = []*Function{
 				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 			switch kind(args[0]) {
+			case reflect.Interface:
+				return arrayType, nil
 			case reflect.Map:
 				return arrayType, nil
 			}
@@ -521,6 +527,8 @@ var Builtins = []*Function{
 				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 			switch kind(args[0]) {
+			case reflect.Interface:
+				return arrayType, nil
 			case reflect.Map:
 				return arrayType, nil
 			}
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index fdc89aa1b..ea273cce7 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -3,6 +3,7 @@ package builtin_test
 import (
 	"fmt"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 
@@ -104,6 +105,32 @@ func TestBuiltin(t *testing.T) {
 	}
 }
 
+func TestBuiltin_works_with_any(t *testing.T) {
+	config := map[string]struct {
+		arity int
+	}{
+		"get": {2},
+	}
+
+	for _, b := range builtin.Builtins {
+		t.Run(b.Name, func(t *testing.T) {
+			arity := 1
+			if c, ok := config[b.Name]; ok {
+				arity = c.arity
+			}
+			if len(b.Types) > 0 {
+				arity = b.Types[0].NumIn()
+			}
+			args := make([]string, arity)
+			for i := 1; i <= arity; i++ {
+				args[i-1] = fmt.Sprintf("arg%d", i)
+			}
+			_, err := expr.Compile(fmt.Sprintf(`%s(%s)`, b.Name, strings.Join(args, ", "))) // expr.Env(env) is not needed
+			assert.NoError(t, err)
+		})
+	}
+}
+
 func TestBuiltin_errors(t *testing.T) {
 	var errorTests = []struct {
 		input string

From 8b5c45d5dc5ee5bb571a13380e837cf96b976908 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 22 Aug 2023 14:02:53 +0200
Subject: [PATCH 105/506] Refactor lexer_test.go

---
 parser/lexer/lexer_test.go | 340 ++++++++++++++++++-------------------
 1 file changed, 170 insertions(+), 170 deletions(-)

diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index 03ccbd14f..d69ff7750 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -12,183 +12,196 @@ import (
 	. "github.com/antonmedv/expr/parser/lexer"
 )
 
-type lexTest struct {
-	input  string
-	tokens []Token
-}
-
-var lexTests = []lexTest{
-	{
-		".5 0.025 1 02 1e3 0xFF 1.2e-4 1_000_000 _42 -.5",
-		[]Token{
-			{Kind: Number, Value: ".5"},
-			{Kind: Number, Value: "0.025"},
-			{Kind: Number, Value: "1"},
-			{Kind: Number, Value: "02"},
-			{Kind: Number, Value: "1e3"},
-			{Kind: Number, Value: "0xFF"},
-			{Kind: Number, Value: "1.2e-4"},
-			{Kind: Number, Value: "1_000_000"},
-			{Kind: Identifier, Value: "_42"},
-			{Kind: Operator, Value: "-"},
-			{Kind: Number, Value: ".5"},
-			{Kind: EOF},
+func TestLex(t *testing.T) {
+	tests := []struct {
+		input  string
+		tokens []Token
+	}{
+		{
+			".5 0.025 1 02 1e3 0xFF 1.2e-4 1_000_000 _42 -.5",
+			[]Token{
+				{Kind: Number, Value: ".5"},
+				{Kind: Number, Value: "0.025"},
+				{Kind: Number, Value: "1"},
+				{Kind: Number, Value: "02"},
+				{Kind: Number, Value: "1e3"},
+				{Kind: Number, Value: "0xFF"},
+				{Kind: Number, Value: "1.2e-4"},
+				{Kind: Number, Value: "1_000_000"},
+				{Kind: Identifier, Value: "_42"},
+				{Kind: Operator, Value: "-"},
+				{Kind: Number, Value: ".5"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		`"double" 'single' "abc \n\t\"\\" '"\'' "'\"" "\xC3\xBF\u263A\U000003A8" '❤️'`,
-		[]Token{
-			{Kind: String, Value: "double"},
-			{Kind: String, Value: "single"},
-			{Kind: String, Value: "abc \n\t\"\\"},
-			{Kind: String, Value: "\"'"},
-			{Kind: String, Value: "'\""},
-			{Kind: String, Value: "ÿ☺Ψ"},
-			{Kind: String, Value: "❤️"},
-			{Kind: EOF},
+		{
+			`"double" 'single' "abc \n\t\"\\" '"\'' "'\"" "\xC3\xBF\u263A\U000003A8" '❤️'`,
+			[]Token{
+				{Kind: String, Value: "double"},
+				{Kind: String, Value: "single"},
+				{Kind: String, Value: "abc \n\t\"\\"},
+				{Kind: String, Value: "\"'"},
+				{Kind: String, Value: "'\""},
+				{Kind: String, Value: "ÿ☺Ψ"},
+				{Kind: String, Value: "❤️"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		"a and orb().val #.",
-		[]Token{
-			{Kind: Identifier, Value: "a"},
-			{Kind: Operator, Value: "and"},
-			{Kind: Identifier, Value: "orb"},
-			{Kind: Bracket, Value: "("},
-			{Kind: Bracket, Value: ")"},
-			{Kind: Operator, Value: "."},
-			{Kind: Identifier, Value: "val"},
-			{Kind: Operator, Value: "#"},
-			{Kind: Operator, Value: "."},
-			{Kind: EOF},
+		{
+			"a and orb().val #.",
+			[]Token{
+				{Kind: Identifier, Value: "a"},
+				{Kind: Operator, Value: "and"},
+				{Kind: Identifier, Value: "orb"},
+				{Kind: Bracket, Value: "("},
+				{Kind: Bracket, Value: ")"},
+				{Kind: Operator, Value: "."},
+				{Kind: Identifier, Value: "val"},
+				{Kind: Operator, Value: "#"},
+				{Kind: Operator, Value: "."},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		"foo?.bar",
-		[]Token{
+		{
+			"foo?.bar",
+			[]Token{
 
-			{Kind: Identifier, Value: "foo"},
-			{Kind: Operator, Value: "?."},
-			{Kind: Identifier, Value: "bar"},
-			{Kind: EOF},
+				{Kind: Identifier, Value: "foo"},
+				{Kind: Operator, Value: "?."},
+				{Kind: Identifier, Value: "bar"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		"foo ? .bar : .baz",
-		[]Token{
+		{
+			"foo ? .bar : .baz",
+			[]Token{
 
-			{Kind: Identifier, Value: "foo"},
-			{Kind: Operator, Value: "?"},
-			{Kind: Operator, Value: "."},
-			{Kind: Identifier, Value: "bar"},
-			{Kind: Operator, Value: ":"},
-			{Kind: Operator, Value: "."},
-			{Kind: Identifier, Value: "baz"},
-			{Kind: EOF},
+				{Kind: Identifier, Value: "foo"},
+				{Kind: Operator, Value: "?"},
+				{Kind: Operator, Value: "."},
+				{Kind: Identifier, Value: "bar"},
+				{Kind: Operator, Value: ":"},
+				{Kind: Operator, Value: "."},
+				{Kind: Identifier, Value: "baz"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		"func?()",
-		[]Token{
+		{
+			"func?()",
+			[]Token{
 
-			{Kind: Identifier, Value: "func"},
-			{Kind: Operator, Value: "?"},
-			{Kind: Bracket, Value: "("},
-			{Kind: Bracket, Value: ")"},
-			{Kind: EOF},
+				{Kind: Identifier, Value: "func"},
+				{Kind: Operator, Value: "?"},
+				{Kind: Bracket, Value: "("},
+				{Kind: Bracket, Value: ")"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		"array?[]",
-		[]Token{
+		{
+			"array?[]",
+			[]Token{
 
-			{Kind: Identifier, Value: "array"},
-			{Kind: Operator, Value: "?"},
-			{Kind: Bracket, Value: "["},
-			{Kind: Bracket, Value: "]"},
-			{Kind: EOF},
+				{Kind: Identifier, Value: "array"},
+				{Kind: Operator, Value: "?"},
+				{Kind: Bracket, Value: "["},
+				{Kind: Bracket, Value: "]"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		`not in not abc not i not(false) not  in not   in`,
-		[]Token{
-			{Kind: Operator, Value: "not"},
-			{Kind: Operator, Value: "in"},
-			{Kind: Operator, Value: "not"},
-			{Kind: Identifier, Value: "abc"},
-			{Kind: Operator, Value: "not"},
-			{Kind: Identifier, Value: "i"},
-			{Kind: Operator, Value: "not"},
-			{Kind: Bracket, Value: "("},
-			{Kind: Identifier, Value: "false"},
-			{Kind: Bracket, Value: ")"},
-			{Kind: Operator, Value: "not"},
-			{Kind: Operator, Value: "in"},
-			{Kind: Operator, Value: "not"},
-			{Kind: Operator, Value: "in"},
-			{Kind: EOF},
+		{
+			`not in not abc not i not(false) not  in not   in`,
+			[]Token{
+				{Kind: Operator, Value: "not"},
+				{Kind: Operator, Value: "in"},
+				{Kind: Operator, Value: "not"},
+				{Kind: Identifier, Value: "abc"},
+				{Kind: Operator, Value: "not"},
+				{Kind: Identifier, Value: "i"},
+				{Kind: Operator, Value: "not"},
+				{Kind: Bracket, Value: "("},
+				{Kind: Identifier, Value: "false"},
+				{Kind: Bracket, Value: ")"},
+				{Kind: Operator, Value: "not"},
+				{Kind: Operator, Value: "in"},
+				{Kind: Operator, Value: "not"},
+				{Kind: Operator, Value: "in"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		"not in_var",
-		[]Token{
-			{Kind: Operator, Value: "not"},
-			{Kind: Identifier, Value: "in_var"},
-			{Kind: EOF},
+		{
+			"not in_var",
+			[]Token{
+				{Kind: Operator, Value: "not"},
+				{Kind: Identifier, Value: "in_var"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		"not in",
-		[]Token{
-			{Kind: Operator, Value: "not"},
-			{Kind: Operator, Value: "in"},
-			{Kind: EOF},
+		{
+			"not in",
+			[]Token{
+				{Kind: Operator, Value: "not"},
+				{Kind: Operator, Value: "in"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		`1..5`,
-		[]Token{
-			{Kind: Number, Value: "1"},
-			{Kind: Operator, Value: ".."},
-			{Kind: Number, Value: "5"},
-			{Kind: EOF},
+		{
+			`1..5`,
+			[]Token{
+				{Kind: Number, Value: "1"},
+				{Kind: Operator, Value: ".."},
+				{Kind: Number, Value: "5"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		`$i _0 früh`,
-		[]Token{
-			{Kind: Identifier, Value: "$i"},
-			{Kind: Identifier, Value: "_0"},
-			{Kind: Identifier, Value: "früh"},
-			{Kind: EOF},
+		{
+			`$i _0 früh`,
+			[]Token{
+				{Kind: Identifier, Value: "$i"},
+				{Kind: Identifier, Value: "_0"},
+				{Kind: Identifier, Value: "früh"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		`foo // comment
+		{
+			`foo // comment
 		bar // comment`,
-		[]Token{
-			{Kind: Identifier, Value: "foo"},
-			{Kind: Identifier, Value: "bar"},
-			{Kind: EOF},
+			[]Token{
+				{Kind: Identifier, Value: "foo"},
+				{Kind: Identifier, Value: "bar"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		`foo /* comment */ bar`,
-		[]Token{
-			{Kind: Identifier, Value: "foo"},
-			{Kind: Identifier, Value: "bar"},
-			{Kind: EOF},
+		{
+			`foo /* comment */ bar`,
+			[]Token{
+				{Kind: Identifier, Value: "foo"},
+				{Kind: Identifier, Value: "bar"},
+				{Kind: EOF},
+			},
 		},
-	},
-	{
-		`foo ?? bar`,
-		[]Token{
-			{Kind: Identifier, Value: "foo"},
-			{Kind: Operator, Value: "??"},
-			{Kind: Identifier, Value: "bar"},
-			{Kind: EOF},
+		{
+			`foo ?? bar`,
+			[]Token{
+				{Kind: Identifier, Value: "foo"},
+				{Kind: Operator, Value: "??"},
+				{Kind: Identifier, Value: "bar"},
+				{Kind: EOF},
+			},
 		},
-	},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			tokens, err := Lex(file.NewSource(test.input))
+			if err != nil {
+				t.Errorf("%s:\n%v", test.input, err)
+				return
+			}
+			if !compareTokens(tokens, test.tokens) {
+				t.Errorf("%s:\ngot\n\t%+v\nexpected\n\t%v", test.input, tokens, test.tokens)
+			}
+		})
+	}
 }
 
 func compareTokens(i1, i2 []Token) bool {
@@ -206,19 +219,6 @@ func compareTokens(i1, i2 []Token) bool {
 	return true
 }
 
-func TestLex(t *testing.T) {
-	for _, test := range lexTests {
-		tokens, err := Lex(file.NewSource(test.input))
-		if err != nil {
-			t.Errorf("%s:\n%v", test.input, err)
-			return
-		}
-		if !compareTokens(tokens, test.tokens) {
-			t.Errorf("%s:\ngot\n\t%+v\nexpected\n\t%v", test.input, tokens, test.tokens)
-		}
-	}
-}
-
 func TestLex_location(t *testing.T) {
 	source := file.NewSource("1..2 3..4")
 	tokens, err := Lex(source)

From 988663ce4e70968bc1420a26eefc548c35bc7ce9 Mon Sep 17 00:00:00 2001
From: Andreas Deininger <andreas@deininger.net>
Date: Tue, 22 Aug 2023 21:25:36 +0200
Subject: [PATCH 106/506] Bump GitHub workflow actions

---
 .github/workflows/check.yml | 4 ++--
 .github/workflows/diff.yml  | 6 +++---
 .github/workflows/test.yml  | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 0b1c6ad04..98c843195 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -10,9 +10,9 @@ jobs:
   coverage:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Setup Go 1.19
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v4
         with:
           go-version: 1.19
       - name: Test
diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml
index d76a77ccf..84aad6610 100644
--- a/.github/workflows/diff.yml
+++ b/.github/workflows/diff.yml
@@ -9,18 +9,18 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Setup Go 1.19
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v4
         with:
           go-version: 1.19
       - name: Install benchstat
         run: go install golang.org/x/perf/cmd/benchstat@latest
 
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Benchmark new code
         run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/new.txt
 
       - name: Checkout master
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           ref: master
       - name: Benchmark master
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 0d781a35b..e41af94a4 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -13,9 +13,9 @@ jobs:
       matrix:
         go-versions: [ '1.13', '1.14', '1.15', '1.16' , '1.17', '1.18', '1.19', '1.20', '1.21' ]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Setup Go ${{ matrix.go-version }}
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v4
         with:
           go-version: ${{ matrix.go-version }}
       - name: Test

From 604a9e0a39ca9b31a0735e5ba4c4b7a48ef864fb Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 22 Aug 2023 15:18:03 +0200
Subject: [PATCH 107/506] Add variables

---
 ast/node.go                |  7 +++++
 ast/print.go               |  4 +++
 ast/visitor.go             |  3 ++
 checker/checker.go         | 29 ++++++++++++++++++++
 checker/checker_test.go    |  1 +
 compiler/compiler.go       | 56 +++++++++++++++++++++++++++++++++++---
 expr_test.go               | 12 ++++++++
 parser/lexer/lexer_test.go | 11 ++++++++
 parser/lexer/state.go      |  4 ++-
 parser/parser.go           | 21 ++++++++++++++
 parser/parser_test.go      | 11 ++++++++
 vm/opcodes.go              |  2 ++
 vm/program.go              | 27 +++++++++++-------
 vm/program_test.go         |  1 -
 vm/vm.go                   |  6 ++++
 15 files changed, 179 insertions(+), 16 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index ba6545871..1adf95ac9 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -151,6 +151,13 @@ type ConditionalNode struct {
 	Exp2 Node
 }
 
+type VariableDeclaratorNode struct {
+	base
+	Name  string
+	Value Node
+	Expr  Node
+}
+
 type ArrayNode struct {
 	base
 	Nodes []Node
diff --git a/ast/print.go b/ast/print.go
index 2e8744730..dd9e0db0f 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -130,6 +130,10 @@ func (n *PointerNode) String() string {
 	return "#"
 }
 
+func (n *VariableDeclaratorNode) String() string {
+	return fmt.Sprintf("let %s = %s; %s", n.Name, n.Value.String(), n.Expr.String())
+}
+
 func (n *ConditionalNode) String() string {
 	var cond, exp1, exp2 string
 	if _, ok := n.Cond.(*ConditionalNode); ok {
diff --git a/ast/visitor.go b/ast/visitor.go
index 351e5d72b..287a75589 100644
--- a/ast/visitor.go
+++ b/ast/visitor.go
@@ -45,6 +45,9 @@ func Walk(node *Node, v Visitor) {
 	case *ClosureNode:
 		Walk(&n.Node, v)
 	case *PointerNode:
+	case *VariableDeclaratorNode:
+		Walk(&n.Value, v)
+		Walk(&n.Expr, v)
 	case *ConditionalNode:
 		Walk(&n.Cond, v)
 		Walk(&n.Exp1, v)
diff --git a/checker/checker.go b/checker/checker.go
index fe31f8c92..30246c986 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -58,10 +58,17 @@ func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
 type visitor struct {
 	config      *conf.Config
 	collections []reflect.Type
+	scopes      []scope
 	parents     []ast.Node
 	err         *file.Error
 }
 
+type scope struct {
+	name  string
+	vtype reflect.Type
+	info  info
+}
+
 type info struct {
 	method bool
 	fn     *builtin.Function
@@ -104,6 +111,8 @@ func (v *visitor) visit(node ast.Node) (reflect.Type, info) {
 		t, i = v.ClosureNode(n)
 	case *ast.PointerNode:
 		t, i = v.PointerNode(n)
+	case *ast.VariableDeclaratorNode:
+		t, i = v.VariableDeclaratorNode(n)
 	case *ast.ConditionalNode:
 		t, i = v.ConditionalNode(n)
 	case *ast.ArrayNode:
@@ -135,6 +144,9 @@ func (v *visitor) NilNode(*ast.NilNode) (reflect.Type, info) {
 }
 
 func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info) {
+	if s, ok := v.lookupVariable(node.Value); ok {
+		return s.vtype, s.info
+	}
 	if node.Value == "$env" {
 		return mapType, info{}
 	}
@@ -862,6 +874,23 @@ func (v *visitor) PointerNode(node *ast.PointerNode) (reflect.Type, info) {
 	return v.error(node, "cannot use %v as array", collection)
 }
 
+func (v *visitor) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (reflect.Type, info) {
+	vtype, vinfo := v.visit(node.Value)
+	v.scopes = append(v.scopes, scope{node.Name, vtype, vinfo})
+	t, i := v.visit(node.Expr)
+	v.scopes = v.scopes[:len(v.scopes)-1]
+	return t, i
+}
+
+func (v *visitor) lookupVariable(name string) (scope, bool) {
+	for i := len(v.scopes) - 1; i >= 0; i-- {
+		if v.scopes[i].name == name {
+			return v.scopes[i], true
+		}
+	}
+	return scope{}, false
+}
+
 func (v *visitor) ConditionalNode(node *ast.ConditionalNode) (reflect.Type, info) {
 	c, _ := v.visit(node.Cond)
 	if !isBool(c) && !isAny(c) {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 4b4f77c46..987f03520 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -125,6 +125,7 @@ var successTests = []string{
 	"Any.A?.B == nil",
 	"(Any.Bool ?? Bool) > 0",
 	"Bool ?? Bool",
+	"let foo = 1; foo == 1",
 }
 
 func TestCheck(t *testing.T) {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 89a44039e..b40e12756 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -28,6 +28,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		locations:      make([]file.Location, 0),
 		constantsIndex: make(map[interface{}]int),
 		functionsIndex: make(map[string]int),
+		debugInfo:      make(map[string]string),
 	}
 
 	if config != nil {
@@ -50,11 +51,12 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		Node:      tree.Node,
 		Source:    tree.Source,
 		Locations: c.locations,
+		Variables: c.variables,
 		Constants: c.constants,
 		Bytecode:  c.bytecode,
 		Arguments: c.arguments,
 		Functions: c.functions,
-		FuncNames: c.functionNames,
+		DebugInfo: c.debugInfo,
 	}
 	return
 }
@@ -62,11 +64,13 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 type compiler struct {
 	locations      []file.Location
 	bytecode       []Opcode
+	variables      []interface{}
+	scopes         []scope
 	constants      []interface{}
 	constantsIndex map[interface{}]int
 	functions      []Function
-	functionNames  []string
 	functionsIndex map[string]int
+	debugInfo      map[string]string
 	mapEnv         bool
 	cast           reflect.Kind
 	nodes          []ast.Node
@@ -74,6 +78,11 @@ type compiler struct {
 	arguments      []int
 }
 
+type scope struct {
+	variableName string
+	index        int
+}
+
 func (c *compiler) emitLocation(loc file.Location, op Opcode, arg int) int {
 	c.bytecode = append(c.bytecode, op)
 	current := len(c.bytecode)
@@ -129,6 +138,13 @@ func (c *compiler) addConstant(constant interface{}) int {
 	return p
 }
 
+func (c *compiler) addVariable(name string) int {
+	c.variables = append(c.variables, nil)
+	p := len(c.variables) - 1
+	c.debugInfo[fmt.Sprintf("var_%d", p)] = name
+	return p
+}
+
 // emitFunction adds builtin.Function.Func to the program.Functions and emits call opcode.
 func (c *compiler) emitFunction(fn *builtin.Function, argsLen int) {
 	switch argsLen {
@@ -156,8 +172,8 @@ func (c *compiler) addFunction(fn *builtin.Function) int {
 	}
 	p := len(c.functions)
 	c.functions = append(c.functions, fn.Func)
-	c.functionNames = append(c.functionNames, fn.Name)
 	c.functionsIndex[fn.Name] = p
+	c.debugInfo[fmt.Sprintf("func_%d", p)] = fn.Name
 	return p
 }
 
@@ -209,6 +225,8 @@ func (c *compiler) compile(node ast.Node) {
 		c.ClosureNode(n)
 	case *ast.PointerNode:
 		c.PointerNode(n)
+	case *ast.VariableDeclaratorNode:
+		c.VariableDeclaratorNode(n)
 	case *ast.ConditionalNode:
 		c.ConditionalNode(n)
 	case *ast.ArrayNode:
@@ -227,6 +245,10 @@ func (c *compiler) NilNode(_ *ast.NilNode) {
 }
 
 func (c *compiler) IdentifierNode(node *ast.IdentifierNode) {
+	if index, ok := c.lookupVariable(node.Value); ok {
+		c.emit(OpLoadVar, index)
+		return
+	}
 	if node.Value == "$env" {
 		c.emit(OpLoadEnv)
 		return
@@ -742,10 +764,36 @@ func (c *compiler) ClosureNode(node *ast.ClosureNode) {
 	c.compile(node.Node)
 }
 
-func (c *compiler) PointerNode(node *ast.PointerNode) {
+func (c *compiler) PointerNode(_ *ast.PointerNode) {
 	c.emit(OpPointer)
 }
 
+func (c *compiler) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) {
+	c.compile(node.Value)
+	index := c.addVariable(node.Name)
+	c.emit(OpStore, index)
+	c.beginScope(node.Name, index)
+	c.compile(node.Expr)
+	c.endScope()
+}
+
+func (c *compiler) beginScope(name string, index int) {
+	c.scopes = append(c.scopes, scope{name, index})
+}
+
+func (c *compiler) endScope() {
+	c.scopes = c.scopes[:len(c.scopes)-1]
+}
+
+func (c *compiler) lookupVariable(name string) (int, bool) {
+	for i := len(c.scopes) - 1; i >= 0; i-- {
+		if c.scopes[i].variableName == name {
+			return c.scopes[i].index, true
+		}
+	}
+	return 0, false
+}
+
 func (c *compiler) ConditionalNode(node *ast.ConditionalNode) {
 	c.compile(node.Cond)
 	otherwise := c.emit(OpJumpIfFalse, placeholder)
diff --git a/expr_test.go b/expr_test.go
index 3e959bb19..792586278 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -948,6 +948,18 @@ func TestExpr(t *testing.T) {
 			`1 /* one */ + 2 // two`,
 			3,
 		},
+		{
+			`let x = 1; x + 2`,
+			3,
+		},
+		{
+			`map(1..3, let x = #; let y = x * x; y * y)`,
+			[]interface{}{1, 16, 81},
+		},
+		{
+			`map(1..2, let x = #; map(2..3, let y = #; x + y))`,
+			[]interface{}{[]interface{}{3, 4}, []interface{}{4, 5}},
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index d69ff7750..1a9418068 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -188,6 +188,17 @@ func TestLex(t *testing.T) {
 				{Kind: EOF},
 			},
 		},
+		{
+			`let foo = bar;`,
+			[]Token{
+				{Kind: Operator, Value: "let"},
+				{Kind: Identifier, Value: "foo"},
+				{Kind: Operator, Value: "="},
+				{Kind: Identifier, Value: "bar"},
+				{Kind: Operator, Value: ";"},
+				{Kind: EOF},
+			},
+		},
 	}
 
 	for _, test := range tests {
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index c8f0d1725..8e1001b26 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -37,7 +37,7 @@ func root(l *lexer) stateFn {
 		l.emit(Bracket)
 	case strings.ContainsRune(")]}", r):
 		l.emit(Bracket)
-	case strings.ContainsRune("#,:%+-^", r): // single rune operator
+	case strings.ContainsRune("#,:;%+-^", r): // single rune operator
 		l.emit(Operator)
 	case strings.ContainsRune("&!=*<>", r): // possible double rune operator
 		l.accept("&=*")
@@ -124,6 +124,8 @@ loop:
 				return not
 			case "in", "or", "and", "matches", "contains", "startsWith", "endsWith":
 				l.emit(Operator)
+			case "let":
+				l.emit(Operator)
 			default:
 				l.emit(Identifier)
 			}
diff --git a/parser/parser.go b/parser/parser.go
index 102091748..4268101a4 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -110,6 +110,12 @@ func (p *parser) expect(kind Kind, values ...string) {
 // parse functions
 
 func (p *parser) parseExpression(precedence int) Node {
+	if precedence == 0 {
+		if p.current.Is(Operator, "let") {
+			return p.parseVariableDeclaration()
+		}
+	}
+
 	nodeLeft := p.parsePrimary()
 
 	prevOperator := ""
@@ -179,6 +185,21 @@ func (p *parser) parseExpression(precedence int) Node {
 	return nodeLeft
 }
 
+func (p *parser) parseVariableDeclaration() Node {
+	p.expect(Operator, "let")
+	variableName := p.current
+	p.expect(Identifier)
+	p.expect(Operator, "=")
+	value := p.parseExpression(0)
+	p.expect(Operator, ";")
+	node := p.parseExpression(0)
+	return &VariableDeclaratorNode{
+		Name:  variableName.Value,
+		Value: value,
+		Expr:  node,
+	}
+}
+
 func (p *parser) parseConditional(node Node) Node {
 	var expr1, expr2 Node
 	for p.current.Is(Operator, "?") && p.err == nil {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index bbd38476d..002f1f34b 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -452,6 +452,17 @@ func TestParse(t *testing.T) {
 				Callee: &IdentifierNode{Value: "ok"},
 				Arguments: []Node{
 					&BoolNode{Value: true}}}},
+		{
+			`let foo = a + b; foo + c`,
+			&VariableDeclaratorNode{
+				Name: "foo",
+				Value: &BinaryNode{Operator: "+",
+					Left:  &IdentifierNode{Value: "a"},
+					Right: &IdentifierNode{Value: "b"}},
+				Expr: &BinaryNode{Operator: "+",
+					Left:  &IdentifierNode{Value: "foo"},
+					Right: &IdentifierNode{Value: "c"}}},
+		},
 	}
 	for _, test := range parseTests {
 		actual, err := parser.ParseWithConfig(test.input, &conf.Config{Pipes: true})
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 1720fd4c2..079d1c76f 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -7,6 +7,8 @@ const (
 	OpPush
 	OpPushInt
 	OpPop
+	OpStore
+	OpLoadVar
 	OpLoadConst
 	OpLoadField
 	OpLoadFast
diff --git a/vm/program.go b/vm/program.go
index ccc7cfb41..1481dbf93 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -19,11 +19,12 @@ type Program struct {
 	Node      ast.Node
 	Source    *file.Source
 	Locations []file.Location
+	Variables []interface{}
 	Constants []interface{}
 	Bytecode  []Opcode
 	Arguments []int
 	Functions []Function
-	FuncNames []string
+	DebugInfo map[string]string
 }
 
 func (program *Program) Disassemble() string {
@@ -54,6 +55,9 @@ func (program *Program) Opcodes(w io.Writer) {
 		argument := func(label string) {
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\n", pp, label, arg)
 		}
+		argumentWithInfo := func(label string, prefix string) {
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, program.DebugInfo[fmt.Sprintf("%s_%d", prefix, arg)])
+		}
 		constant := func(label string) {
 			var c interface{}
 			if arg < len(program.Constants) {
@@ -72,12 +76,9 @@ func (program *Program) Opcodes(w io.Writer) {
 			}
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, c)
 		}
-		builtin := func(label string) {
+		builtinArg := func(label string) {
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, builtin.Builtins[arg].Name)
 		}
-		funcName := func(label string) {
-			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v()\n", pp, label, arg, program.FuncNames[arg])
-		}
 
 		switch op {
 		case OpInvalid:
@@ -92,6 +93,12 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpPop:
 			code("OpPop")
 
+		case OpStore:
+			argumentWithInfo("OpStore", "var")
+
+		case OpLoadVar:
+			argumentWithInfo("OpLoadVar", "var")
+
 		case OpLoadConst:
 			constant("OpLoadConst")
 
@@ -222,16 +229,16 @@ func (program *Program) Opcodes(w io.Writer) {
 			argument("OpCall")
 
 		case OpCall0:
-			funcName("OpCall0")
+			argumentWithInfo("OpCall0", "func")
 
 		case OpCall1:
-			funcName("OpCall1")
+			argumentWithInfo("OpCall1", "func")
 
 		case OpCall2:
-			funcName("OpCall2")
+			argumentWithInfo("OpCall2", "func")
 
 		case OpCall3:
-			funcName("OpCall3")
+			argumentWithInfo("OpCall3", "func")
 
 		case OpCallN:
 			argument("OpCallN")
@@ -244,7 +251,7 @@ func (program *Program) Opcodes(w io.Writer) {
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, "OpCallTyped", arg, signature)
 
 		case OpCallBuiltin1:
-			builtin("OpCallBuiltin1")
+			builtinArg("OpCallBuiltin1")
 
 		case OpArray:
 			code("OpArray")
diff --git a/vm/program_test.go b/vm/program_test.go
index c1cdf4f4c..06e83b18c 100644
--- a/vm/program_test.go
+++ b/vm/program_test.go
@@ -13,7 +13,6 @@ func TestProgram_Disassemble(t *testing.T) {
 			Constants: []interface{}{1, 2},
 			Bytecode:  []vm.Opcode{op},
 			Arguments: []int{1},
-			FuncNames: []string{"foo", "bar"},
 		}
 		d := program.Disassemble()
 		if strings.Contains(d, "(unknown)") {
diff --git a/vm/vm.go b/vm/vm.go
index 343a02064..49bee401f 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -102,6 +102,12 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 		case OpPop:
 			vm.pop()
 
+		case OpStore:
+			program.Variables[arg] = vm.pop()
+
+		case OpLoadVar:
+			vm.push(program.Variables[arg])
+
 		case OpLoadConst:
 			vm.push(runtime.Fetch(env, program.Constants[arg]))
 

From f716dc5d7cbda78c14fedb736ddb0133c083448a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 22 Aug 2023 17:50:57 +0200
Subject: [PATCH 108/506] Add predicates to list of builtins

---
 builtin/builtin.go       | 46 +++++++++++++++++++++++++++++++++++-----
 builtin/builtin_test.go  | 25 +++++++++++++++-------
 checker/checker_test.go  |  4 ++--
 test/deref/deref_test.go | 16 +++++++-------
 4 files changed, 68 insertions(+), 23 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index f03162b2f..82922e9dd 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -12,11 +12,12 @@ import (
 )
 
 type Function struct {
-	Name     string
-	Func     func(args ...interface{}) (interface{}, error)
-	Types    []reflect.Type
-	Builtin1 func(arg interface{}) interface{}
-	Validate func(args []reflect.Type) (reflect.Type, error)
+	Name      string
+	Func      func(args ...interface{}) (interface{}, error)
+	Types     []reflect.Type
+	Builtin1  func(arg interface{}) interface{}
+	Validate  func(args []reflect.Type) (reflect.Type, error)
+	Predicate bool
 }
 
 var (
@@ -34,6 +35,41 @@ func init() {
 }
 
 var Builtins = []*Function{
+	{
+		Name:      "all",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) bool) bool)),
+	},
+	{
+		Name:      "none",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) bool) bool)),
+	},
+	{
+		Name:      "any",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) bool) bool)),
+	},
+	{
+		Name:      "one",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) bool) bool)),
+	},
+	{
+		Name:      "filter",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) bool) []interface{})),
+	},
+	{
+		Name:      "map",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) interface{}) []interface{})),
+	},
+	{
+		Name:      "count",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) bool) int)),
+	},
 	{
 		Name:     "len",
 		Builtin1: Len,
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index ea273cce7..d1e4b88fc 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -113,6 +113,9 @@ func TestBuiltin_works_with_any(t *testing.T) {
 	}
 
 	for _, b := range builtin.Builtins {
+		if b.Predicate {
+			continue
+		}
 		t.Run(b.Name, func(t *testing.T) {
 			arity := 1
 			if c, ok := config[b.Name]; ok {
@@ -249,12 +252,15 @@ func TestBuiltin_disallow_builtins_override(t *testing.T) {
 
 func TestBuiltin_DisableBuiltin(t *testing.T) {
 	t.Run("via env", func(t *testing.T) {
-		for _, name := range builtin.Names {
-			t.Run(name, func(t *testing.T) {
+		for _, b := range builtin.Builtins {
+			if b.Predicate {
+				continue // TODO: allow to disable predicates
+			}
+			t.Run(b.Name, func(t *testing.T) {
 				env := map[string]interface{}{
-					name: func() int { return 42 },
+					b.Name: func() int { return 42 },
 				}
-				program, err := expr.Compile(name+"()", expr.Env(env), expr.DisableBuiltin(name))
+				program, err := expr.Compile(b.Name+"()", expr.Env(env), expr.DisableBuiltin(b.Name))
 				require.NoError(t, err)
 
 				out, err := expr.Run(program, env)
@@ -264,15 +270,18 @@ func TestBuiltin_DisableBuiltin(t *testing.T) {
 		}
 	})
 	t.Run("via expr.Function", func(t *testing.T) {
-		for _, name := range builtin.Names {
-			t.Run(name, func(t *testing.T) {
-				fn := expr.Function(name,
+		for _, b := range builtin.Builtins {
+			if b.Predicate {
+				continue // TODO: allow to disable predicates
+			}
+			t.Run(b.Name, func(t *testing.T) {
+				fn := expr.Function(b.Name,
 					func(params ...interface{}) (interface{}, error) {
 						return 42, nil
 					},
 					new(func() int),
 				)
-				program, err := expr.Compile(name+"()", fn, expr.DisableBuiltin(name))
+				program, err := expr.Compile(b.Name+"()", fn, expr.DisableBuiltin(b.Name))
 				require.NoError(t, err)
 
 				out, err := expr.Run(program, nil)
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 987f03520..51a234f18 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -635,7 +635,7 @@ func TestCheck_AllowUndefinedVariables(t *testing.T) {
 		A int
 	}
 
-	tree, err := parser.Parse(`any + fn()`)
+	tree, err := parser.Parse(`Any + fn()`)
 	require.NoError(t, err)
 
 	config := conf.New(Env{})
@@ -648,7 +648,7 @@ func TestCheck_AllowUndefinedVariables(t *testing.T) {
 func TestCheck_AllowUndefinedVariables_DefaultType(t *testing.T) {
 	env := map[string]bool{}
 
-	tree, err := parser.Parse(`any`)
+	tree, err := parser.Parse(`Any`)
 	require.NoError(t, err)
 
 	config := conf.New(env)
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 761e779f2..1e1bb83a1 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -12,12 +12,12 @@ func TestDeref_binary(t *testing.T) {
 	i := 1
 	env := map[string]interface{}{
 		"i": &i,
-		"map": map[string]interface{}{
+		"obj": map[string]interface{}{
 			"i": &i,
 		},
 	}
 	t.Run("==", func(t *testing.T) {
-		program, err := expr.Compile(`i == 1 && map.i == 1`, expr.Env(env))
+		program, err := expr.Compile(`i == 1 && obj.i == 1`, expr.Env(env))
 		require.NoError(t, err)
 
 		out, err := expr.Run(program, env)
@@ -25,7 +25,7 @@ func TestDeref_binary(t *testing.T) {
 		require.Equal(t, true, out)
 	})
 	t.Run("><", func(t *testing.T) {
-		program, err := expr.Compile(`i > 0 && map.i < 99`, expr.Env(env))
+		program, err := expr.Compile(`i > 0 && obj.i < 99`, expr.Env(env))
 		require.NoError(t, err)
 
 		out, err := expr.Run(program, env)
@@ -33,7 +33,7 @@ func TestDeref_binary(t *testing.T) {
 		require.Equal(t, true, out)
 	})
 	t.Run("??+", func(t *testing.T) {
-		program, err := expr.Compile(`(i ?? map.i) + 1`, expr.Env(env))
+		program, err := expr.Compile(`(i ?? obj.i) + 1`, expr.Env(env))
 		require.NoError(t, err)
 
 		out, err := expr.Run(program, env)
@@ -47,12 +47,12 @@ func TestDeref_unary(t *testing.T) {
 	ok := true
 	env := map[string]interface{}{
 		"i": &i,
-		"map": map[string]interface{}{
+		"obj": map[string]interface{}{
 			"ok": &ok,
 		},
 	}
 
-	program, err := expr.Compile(`-i < 0 && !!map.ok`, expr.Env(env))
+	program, err := expr.Compile(`-i < 0 && !!obj.ok`, expr.Env(env))
 	require.NoError(t, err)
 
 	out, err := expr.Run(program, env)
@@ -64,11 +64,11 @@ func TestDeref_eval(t *testing.T) {
 	i := 1
 	env := map[string]interface{}{
 		"i": &i,
-		"map": map[string]interface{}{
+		"obj": map[string]interface{}{
 			"i": &i,
 		},
 	}
-	out, err := expr.Eval(`i == 1 && map.i == 1`, env)
+	out, err := expr.Eval(`i == 1 && obj.i == 1`, env)
 	require.NoError(t, err)
 	require.Equal(t, true, out)
 }

From 1d1b5bb839d8481fb7866df88a2b313f5923c343 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 22 Aug 2023 21:27:07 +0200
Subject: [PATCH 109/506] Forbid to redeclare variables, builtins, functions.

---
 checker/checker.go      | 12 ++++++++++++
 checker/checker_test.go | 20 ++++++++++++++++++++
 parser/parser.go        |  4 +++-
 3 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/checker/checker.go b/checker/checker.go
index 30246c986..4a001f4d2 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -875,6 +875,18 @@ func (v *visitor) PointerNode(node *ast.PointerNode) (reflect.Type, info) {
 }
 
 func (v *visitor) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (reflect.Type, info) {
+	if _, ok := v.config.Types[node.Name]; ok {
+		return v.error(node, "cannot redeclare %v", node.Name)
+	}
+	if _, ok := v.config.Functions[node.Name]; ok {
+		return v.error(node, "cannot redeclare function %v", node.Name)
+	}
+	if _, ok := v.config.Builtins[node.Name]; ok {
+		return v.error(node, "cannot redeclare builtin %v", node.Name)
+	}
+	if _, ok := v.lookupVariable(node.Name); ok {
+		return v.error(node, "cannot redeclare variable %v", node.Name)
+	}
 	vtype, vinfo := v.visit(node.Value)
 	v.scopes = append(v.scopes, scope{node.Name, vtype, vinfo})
 	t, i := v.visit(node.Expr)
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 51a234f18..e1c7e50b2 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -507,6 +507,26 @@ repeat("0", 1/0)
 cannot use float64 as argument (type int) to call repeat  (1:14)
  | repeat("0", 1/0)
  | .............^
+
+let map = 42; map
+cannot redeclare builtin map (1:5)
+ | let map = 42; map
+ | ....^
+
+let len = 42; len
+cannot redeclare builtin len (1:5)
+ | let len = 42; len
+ | ....^
+
+let Float = 42; Float
+cannot redeclare Float (1:5)
+ | let Float = 42; Float
+ | ....^
+
+let foo = 1; let foo = 2; foo
+cannot redeclare variable foo (1:18)
+ | let foo = 1; let foo = 2; foo
+ | .................^
 `
 
 func TestCheck_error(t *testing.T) {
diff --git a/parser/parser.go b/parser/parser.go
index 4268101a4..f2afc2eca 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -193,11 +193,13 @@ func (p *parser) parseVariableDeclaration() Node {
 	value := p.parseExpression(0)
 	p.expect(Operator, ";")
 	node := p.parseExpression(0)
-	return &VariableDeclaratorNode{
+	let := &VariableDeclaratorNode{
 		Name:  variableName.Value,
 		Value: value,
 		Expr:  node,
 	}
+	let.SetLocation(variableName.Location)
+	return let
 }
 
 func (p *parser) parseConditional(node Node) Node {

From 5a5fa0d5fde3877f33932ce78586eddbac2969e5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 23 Aug 2023 11:31:30 +0200
Subject: [PATCH 110/506] Update benchmarks

---
 bench_test.go | 388 +++++++++++++++++++++++++++-----------------------
 1 file changed, 212 insertions(+), 176 deletions(-)

diff --git a/bench_test.go b/bench_test.go
index 1f7f14769..b97897393 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -4,8 +4,8 @@ import (
 	"testing"
 
 	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/test/real_world"
 	"github.com/antonmedv/expr/vm"
+	"github.com/stretchr/testify/require"
 )
 
 func Benchmark_expr(b *testing.B) {
@@ -16,9 +16,7 @@ func Benchmark_expr(b *testing.B) {
 	params["Value"] = 100
 
 	program, err := expr.Compile(`(Origin == "MOW" || Country == "RU") && (Value >= 100 || Adults == 1)`, expr.Env(params))
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
 
 	var out interface{}
 
@@ -28,12 +26,8 @@ func Benchmark_expr(b *testing.B) {
 	}
 	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
-	if !out.(bool) {
-		b.Fail()
-	}
+	require.NoError(b, err)
+	require.True(b, out.(bool))
 }
 
 func Benchmark_expr_reuseVm(b *testing.B) {
@@ -44,9 +38,7 @@ func Benchmark_expr_reuseVm(b *testing.B) {
 	params["Value"] = 100
 
 	program, err := expr.Compile(`(Origin == "MOW" || Country == "RU") && (Value >= 100 || Adults == 1)`, expr.Env(params))
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
 
 	var out interface{}
 	v := vm.VM{}
@@ -57,67 +49,179 @@ func Benchmark_expr_reuseVm(b *testing.B) {
 	}
 	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
+	require.NoError(b, err)
+	require.True(b, out.(bool))
+}
+
+func Benchmark_len(b *testing.B) {
+	env := map[string]interface{}{
+		"arr": make([]int, 100),
 	}
-	if !out.(bool) {
-		b.Fail()
+
+	program, err := expr.Compile(`len(arr)`, expr.Env(env))
+	require.NoError(b, err)
+
+	var out interface{}
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.Equal(b, 100, out)
 }
 
 func Benchmark_filter(b *testing.B) {
-	type Item struct {
-		Value int
+	type Env struct {
+		Ints []int
 	}
+	env := Env{
+		Ints: make([]int, 1000),
+	}
+	for i := 1; i <= len(env.Ints); i++ {
+		env.Ints[i-1] = i
+	}
+
+	program, err := expr.Compile(`filter(Ints, # % 7 == 0)`, expr.Env(Env{}))
+	require.NoError(b, err)
+
+	var out interface{}
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.Len(b, out.([]interface{}), 142)
+}
+
+func Benchmark_filterLen(b *testing.B) {
 	type Env struct {
-		Items []Item
+		Ints []int
+	}
+	env := Env{
+		Ints: make([]int, 1000),
+	}
+	for i := 1; i <= len(env.Ints); i++ {
+		env.Ints[i-1] = i
 	}
 
-	program, err := expr.Compile(`filter(filter(Items, {.Value % 2 == 0}), {.Value % 3 == 0})`, expr.Env(Env{}))
-	if err != nil {
-		b.Fatal(err)
+	program, err := expr.Compile(`len(filter(Ints, # % 7 == 0))`, expr.Env(Env{}))
+	require.NoError(b, err)
+
+	var out interface{}
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.Equal(b, 142, out)
+}
 
+func Benchmark_filterFirst(b *testing.B) {
+	type Env struct {
+		Ints []int
+	}
 	env := Env{
-		Items: make([]Item, 100),
+		Ints: make([]int, 1000),
 	}
-	for i := 1; i <= 100; i++ {
-		env.Items[i-1].Value = i
+	for i := 1; i <= len(env.Ints); i++ {
+		env.Ints[i-1] = i
 	}
 
+	program, err := expr.Compile(`filter(Ints, # % 7 == 0)[0]`, expr.Env(Env{}))
+	require.NoError(b, err)
+
 	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
+	require.NoError(b, err)
+	require.Equal(b, 7, out)
+}
+
+func Benchmark_filterLast(b *testing.B) {
+	type Env struct {
+		Ints []int
 	}
-	if len(out.([]interface{})) != 16 {
-		b.Fail()
+	env := Env{
+		Ints: make([]int, 1000),
+	}
+	for i := 1; i <= len(env.Ints); i++ {
+		env.Ints[i-1] = i
 	}
+
+	program, err := expr.Compile(`filter(Ints, # % 7 == 0)[-1]`, expr.Env(Env{}))
+	require.NoError(b, err)
+
+	var out interface{}
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = vm.Run(program, env)
+	}
+
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.Equal(b, 994, out)
 }
 
-func Benchmark_len(b *testing.B) {
-	program, err := expr.Compile(`len(1..100)`)
-	if err != nil {
-		b.Fatal(err)
+func Benchmark_filterMap(b *testing.B) {
+	type Env struct {
+		Ints []int
+	}
+	env := Env{
+		Ints: make([]int, 1000),
 	}
+	for i := 1; i <= len(env.Ints); i++ {
+		env.Ints[i-1] = i
+	}
+
+	program, err := expr.Compile(`map(filter(Ints, # % 7 == 0), # * 2)`, expr.Env(Env{}))
+	require.NoError(b, err)
 
 	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		out, err = vm.Run(program, nil)
+		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
+	require.NoError(b, err)
+	require.Len(b, out.([]interface{}), 142)
+	require.Equal(b, 14, out.([]interface{})[0])
+}
+
+func Benchmark_arrayIndex(b *testing.B) {
+	env := map[string]interface{}{
+		"arr": make([]int, 100),
 	}
-	if out.(int) != 100 {
-		b.Fail()
+	for i := 0; i < 100; i++ {
+		env["arr"].([]int)[i] = i
 	}
+
+	program, err := expr.Compile(`arr[50]`, expr.Env(env))
+	require.NoError(b, err)
+
+	var out interface{}
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.Equal(b, 50, out)
 }
 
-func Benchmark_access(b *testing.B) {
+func Benchmark_envStruct(b *testing.B) {
 	type Price struct {
 		Value int
 	}
@@ -126,22 +230,22 @@ func Benchmark_access(b *testing.B) {
 	}
 
 	program, err := expr.Compile(`Price.Value > 0`, expr.Env(Env{}))
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
 
 	env := Env{Price: Price{Value: 1}}
 
+	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		_, err = vm.Run(program, env)
+		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
+	require.True(b, out.(bool))
 }
 
-func Benchmark_accessMap(b *testing.B) {
+func Benchmark_envMap(b *testing.B) {
 	type Price struct {
 		Value int
 	}
@@ -150,17 +254,17 @@ func Benchmark_accessMap(b *testing.B) {
 	}
 
 	program, err := expr.Compile(`price.Value > 0`, expr.Env(env))
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
 
+	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		_, err = vm.Run(program, env)
+		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
+	require.True(b, out.(bool))
 }
 
 type CallEnv struct {
@@ -188,43 +292,41 @@ func (CallFoo) Method() string {
 
 func Benchmark_callFunc(b *testing.B) {
 	program, err := expr.Compile(`Func()`, expr.Env(CallEnv{}))
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
 
 	env := CallEnv{}
 
+	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		_, err = vm.Run(program, env)
+		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
+	require.Equal(b, "func", out)
 }
 
 func Benchmark_callMethod(b *testing.B) {
 	program, err := expr.Compile(`Foo.Method()`, expr.Env(CallEnv{}))
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
 
 	env := CallEnv{}
 
+	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		_, err = vm.Run(program, env)
+		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
+	require.Equal(b, "method", out)
 }
 
 func Benchmark_callField(b *testing.B) {
 	program, err := expr.Compile(`Fn()`, expr.Env(CallEnv{}))
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
 
 	env := CallEnv{
 		Fn: func() bool {
@@ -232,13 +334,15 @@ func Benchmark_callField(b *testing.B) {
 		},
 	}
 
+	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		_, err = vm.Run(program, env)
+		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
+	require.True(b, out.(bool))
 }
 
 func Benchmark_callFast(b *testing.B) {
@@ -254,37 +358,31 @@ func Benchmark_callFast(b *testing.B) {
 	}
 
 	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
-	if out.(string) != "fn_fast" {
-		b.Fail()
-	}
+	require.NoError(b, err)
+	require.Equal(b, "fn_fast", out)
 }
 
 func Benchmark_callConstExpr(b *testing.B) {
 	program, err := expr.Compile(`Func()`, expr.Env(CallEnv{}), expr.ConstExpr("Func"))
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
 
 	env := CallEnv{}
 
 	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
-	if out.(string) != "func" {
-		b.Fail()
-	}
+	require.NoError(b, err)
+	require.Equal(b, "func", out)
 }
 
 func Benchmark_largeStructAccess(b *testing.B) {
@@ -293,20 +391,20 @@ func Benchmark_largeStructAccess(b *testing.B) {
 		Field int
 	}
 
-	program, err := expr.Compile(`Field > 0 && Field > 1 && Field < 20`, expr.Env(Env{}))
-	if err != nil {
-		b.Fatal(err)
-	}
+	program, err := expr.Compile(`Field > 0 && Field > 1 && Field < 99`, expr.Env(Env{}))
+	require.NoError(b, err)
 
 	env := Env{Field: 21}
 
+	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		_, err = vm.Run(program, &env)
+		out, err = vm.Run(program, &env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
+	require.True(b, out.(bool))
 }
 
 func Benchmark_largeNestedStructAccess(b *testing.B) {
@@ -317,21 +415,21 @@ func Benchmark_largeNestedStructAccess(b *testing.B) {
 		}
 	}
 
-	program, err := expr.Compile(`Inner.Field > 0 && Inner.Field > 1 && Inner.Field < 20`, expr.Env(Env{}))
-	if err != nil {
-		b.Fatal(err)
-	}
+	program, err := expr.Compile(`Inner.Field > 0 && Inner.Field > 1 && Inner.Field < 99`, expr.Env(Env{}))
+	require.NoError(b, err)
 
 	env := Env{}
 	env.Inner.Field = 21
 
+	var out interface{}
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		_, err = vm.Run(program, &env)
+		out, err = vm.Run(program, &env)
 	}
+	b.StopTimer()
 
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
+	require.True(b, out.(bool))
 }
 
 func Benchmark_largeNestedArrayAccess(b *testing.B) {
@@ -340,80 +438,18 @@ func Benchmark_largeNestedArrayAccess(b *testing.B) {
 	}
 
 	program, err := expr.Compile(`Data[0][0] > 0`, expr.Env(Env{}))
-	if err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
 
 	env := Env{}
-
-	for n := 0; n < b.N; n++ {
-		_, err = vm.Run(program, &env)
-	}
-
-	if err != nil {
-		b.Fatal(err)
-	}
-}
-
-func Benchmark_realWorld(b *testing.B) {
-	env := real_world.NewEnv()
-	expression := `(UserAgentDevice == 'DESKTOP') and ((OriginCountry == 'RU' or DestinationCountry == 'RU') and Market in ['ru', 'kz','by','uz','ua','az','am'])`
-	program, err := expr.Compile(expression, expr.Env(env))
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	var out interface{}
-	for n := 0; n < b.N; n++ {
-		out, err = vm.Run(program, env)
-	}
-	if err != nil {
-		b.Fatal(err)
-	}
-	if !out.(bool) {
-		b.Fail()
-	}
-}
-
-func Benchmark_realWorld_reuseVm(b *testing.B) {
-	env := real_world.NewEnv()
-	expression := `(UserAgentDevice == 'DESKTOP') and ((OriginCountry == 'RU' or DestinationCountry == 'RU') and Market in ['ru', 'kz','by','uz','ua','az','am'])`
-	program, err := expr.Compile(expression, expr.Env(env))
-	if err != nil {
-		b.Fatal(err)
-	}
+	env.Data[0][0] = 1
 
 	var out interface{}
-	v := vm.VM{}
-
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		out, err = v.Run(program, env)
-	}
-
-	if err != nil {
-		b.Fatal(err)
-	}
-	if !out.(bool) {
-		b.Fail()
-	}
-}
-
-func Benchmark_realWorldInsane(b *testing.B) {
-	env := real_world.NewEnv()
-	expression := `(UserAgentDevice == 'DESKTOP') and (Segments[0].Origin in ['HKT','GOJ'] and Segments[0].Destination in ['HKT','GOJ'] or Segments[0].Origin in ['SKG','GOJ'] and Segments[0].Destination in ['SKG','GOJ'] or Segments[0].Origin in ['SSH','SVX'] and Segments[0].Destination in ['SSH','SVX'] or Segments[0].Origin in ['AYT','LED'] and Segments[0].Destination in ['AYT','LED'] or Segments[0].Origin in ['PUJ','KRR'] and Segments[0].Destination in ['PUJ','KRR'] or Segments[0].Origin in ['USM','CEK'] and Segments[0].Destination in ['USM','CEK'] or Segments[0].Origin in ['SHJ','LED'] and Segments[0].Destination in ['SHJ','LED'] or Segments[0].Origin in ['MOW','PRG'] and Segments[0].Destination in ['MOW','PRG'] or Segments[0].Origin in ['BKK','NOZ'] and Segments[0].Destination in ['BKK','NOZ'] or Segments[0].Origin in ['NHA','GOJ'] and Segments[0].Destination in ['NHA','GOJ'] or Segments[0].Origin in ['HRG','VOG'] and Segments[0].Destination in ['HRG','VOG'] or Segments[0].Origin in ['CFU','MSQ'] and Segments[0].Destination in ['CFU','MSQ'] or Segments[0].Origin in ['UFA','PUJ'] and Segments[0].Destination in ['UFA','PUJ'] or Segments[0].Origin in ['OMS','PUJ'] and Segments[0].Destination in ['OMS','PUJ'] or Segments[0].Origin in ['SKG','MSQ'] and Segments[0].Destination in ['SKG','MSQ'] or Segments[0].Origin in ['SSH','VOZ'] and Segments[0].Destination in ['SSH','VOZ'] or Segments[0].Origin in ['SSH','EGO'] and Segments[0].Destination in ['SSH','EGO'] or Segments[0].Origin in ['UUS','NHA'] and Segments[0].Destination in ['UUS','NHA'] or Segments[0].Origin in ['PUJ','MCX'] and Segments[0].Destination in ['PUJ','MCX'] or Segments[0].Origin in ['NHA','VVO'] and Segments[0].Destination in ['NHA','VVO'] or Segments[0].Origin in ['SKD','MOW'] and Segments[0].Destination in ['SKD','MOW'] or Segments[0].Origin in ['REN','NHA'] and Segments[0].Destination in ['REN','NHA'] or Segments[0].Origin in ['ASF','VRA'] and Segments[0].Destination in ['ASF','VRA'] or Segments[0].Origin in ['YKS','VRA'] and Segments[0].Destination in ['YKS','VRA'] or Segments[0].Origin in ['MOW','RIX'] and Segments[0].Destination in ['MOW','RIX'] or Segments[0].Origin in ['HER','IEV'] and Segments[0].Destination in ['HER','IEV'] or Segments[0].Origin in ['HRG','EGO'] and Segments[0].Destination in ['HRG','EGO'] or Segments[0].Origin in ['MOW','ATH'] and Segments[0].Destination in ['MOW','ATH'] or Segments[0].Origin in ['EGO','SSH'] and Segments[0].Destination in ['EGO','SSH'] or Segments[0].Origin in ['CEK','CUN'] and Segments[0].Destination in ['CEK','CUN'] or Segments[0].Origin in ['VAR','MOW'] and Segments[0].Destination in ['VAR','MOW'] or Segments[0].Origin in ['ASF','NHA'] and Segments[0].Destination in ['ASF','NHA'] or Segments[0].Origin in ['SKG','OVB'] and Segments[0].Destination in ['SKG','OVB'] or Segments[0].Origin in ['CUN','VOZ'] and Segments[0].Destination in ['CUN','VOZ'] or Segments[0].Origin in ['HRG','OVB'] and Segments[0].Destination in ['HRG','OVB'] or Segments[0].Origin in ['LED','VAR'] and Segments[0].Destination in ['LED','VAR'] or Segments[0].Origin in ['OMS','CUN'] and Segments[0].Destination in ['OMS','CUN'] or Segments[0].Origin in ['PUJ','NOZ'] and Segments[0].Destination in ['PUJ','NOZ'] or Segments[0].Origin in ['CUN','OMS'] and Segments[0].Destination in ['CUN','OMS'] or Segments[0].Origin in ['BAX','NHA'] and Segments[0].Destination in ['BAX','NHA'] or Segments[0].Origin in ['TDX','TJM'] and Segments[0].Destination in ['TDX','TJM'] or Segments[0].Origin in ['BKK','YKS'] and Segments[0].Destination in ['BKK','YKS'] or Segments[0].Origin in ['PUJ','MRV'] and Segments[0].Destination in ['PUJ','MRV'] or Segments[0].Origin in ['KUF','MOW'] and Segments[0].Destination in ['KUF','MOW'] or Segments[0].Origin in ['NHA','YKS'] and Segments[0].Destination in ['NHA','YKS'] or Segments[0].Origin in ['UFA','CUN'] and Segments[0].Destination in ['UFA','CUN'] or Segments[0].Origin in ['MIR','MOW'] and Segments[0].Destination in ['MIR','MOW'] or Segments[0].Origin in ['OVB','PUJ'] and Segments[0].Destination in ['OVB','PUJ'] or Segments[0].Origin in ['SGN','KJA'] and Segments[0].Destination in ['SGN','KJA'] or Segments[0].Origin in ['UTP','CEK'] and Segments[0].Destination in ['UTP','CEK'] or Segments[0].Origin in ['SKG','IEV'] and Segments[0].Destination in ['SKG','IEV'] or Segments[0].Origin in ['PKC','MOW'] and Segments[0].Destination in ['PKC','MOW'] or Segments[0].Origin in ['NHA','OGZ'] and Segments[0].Destination in ['NHA','OGZ'] or Segments[0].Origin in ['USM','UFA'] and Segments[0].Destination in ['USM','UFA'] or Segments[0].Origin in ['KGD','VRA'] and Segments[0].Destination in ['KGD','VRA'] or Segments[0].Origin in ['TDX','KZN'] and Segments[0].Destination in ['TDX','KZN'] or Segments[0].Origin in ['KRR','CUN'] and Segments[0].Destination in ['KRR','CUN'] or Segments[0].Origin in ['DXB','PEE'] and Segments[0].Destination in ['DXB','PEE'] or Segments[0].Origin in ['AER','KUF'] and Segments[0].Destination in ['AER','KUF'] or Segments[0].Origin in ['REN','SSH'] and Segments[0].Destination in ['REN','SSH'] or Segments[0].Origin in ['HKT','NJC'] and Segments[0].Destination in ['HKT','NJC'] or Segments[0].Origin in ['AER','CUN'] and Segments[0].Destination in ['AER','CUN'] or Segments[0].Origin in ['ETH','SVX'] and Segments[0].Destination in ['ETH','SVX'] or Segments[0].Origin in ['SSH','CEK'] and Segments[0].Destination in ['SSH','CEK'] or Segments[0].Origin in ['BKK','UFA'] and Segments[0].Destination in ['BKK','UFA'] or Segments[0].Origin in ['SVX','SKG'] and Segments[0].Destination in ['SVX','SKG'] or Segments[0].Origin in ['BKK','VOG'] and Segments[0].Destination in ['BKK','VOG'] or Segments[0].Origin in ['SKG','MOW'] and Segments[0].Destination in ['SKG','MOW'] or Segments[0].Origin in ['NHA','NOZ'] and Segments[0].Destination in ['NHA','NOZ'] or Segments[0].Origin in ['YKS','OVB'] and Segments[0].Destination in ['YKS','OVB'] or Segments[0].Origin in ['UFA','VRA'] and Segments[0].Destination in ['UFA','VRA'] or Segments[0].Origin in ['MOW','TCI'] and Segments[0].Destination in ['MOW','TCI'] or Segments[0].Origin in ['ASF','PUJ'] and Segments[0].Destination in ['ASF','PUJ'] or Segments[0].Origin in ['GOJ','CUN'] and Segments[0].Destination in ['GOJ','CUN'] or Segments[0].Origin in ['ASF','CUN'] and Segments[0].Destination in ['ASF','CUN'] or Segments[0].Origin in ['SGN','CEK'] and Segments[0].Destination in ['SGN','CEK'] or Segments[0].Origin in ['TJM','SSH'] and Segments[0].Destination in ['TJM','SSH'] or Segments[0].Origin in ['UTP','KZN'] and Segments[0].Destination in ['UTP','KZN'] or Segments[0].Origin in ['HRG','REN'] and Segments[0].Destination in ['HRG','REN'] or Segments[0].Origin in ['HKT','KJA'] and Segments[0].Destination in ['HKT','KJA'] or Segments[0].Origin in ['BEG','MOW'] and Segments[0].Destination in ['BEG','MOW'] or Segments[0].Origin in ['OMS','SSH'] and Segments[0].Destination in ['OMS','SSH'] or Segments[0].Origin in ['MSQ','SKG'] and Segments[0].Destination in ['MSQ','SKG'] or Segments[0].Origin in ['BKK','HTA'] and Segments[0].Destination in ['BKK','HTA'] or Segments[0].Origin in ['TDX','PEE'] and Segments[0].Destination in ['TDX','PEE'] or Segments[0].Origin in ['SKG','MRV'] and Segments[0].Destination in ['SKG','MRV'] or Segments[0].Origin in ['SGN','OVB'] and Segments[0].Destination in ['SGN','OVB'] or Segments[0].Origin in ['SVX','HRG'] and Segments[0].Destination in ['SVX','HRG'] or Segments[0].Origin in ['HKT','AER'] and Segments[0].Destination in ['HKT','AER'] or Segments[0].Origin in ['CEE','CUN'] and Segments[0].Destination in ['CEE','CUN'] or Segments[0].Origin in ['NHA','SVX'] and Segments[0].Destination in ['NHA','SVX'] or Segments[0].Origin in ['CUN','GOJ'] and Segments[0].Destination in ['CUN','GOJ'] or Segments[0].Origin in ['MOW','OGZ'] and Segments[0].Destination in ['MOW','OGZ'] or Segments[0].Origin in ['SCW','SSH'] and Segments[0].Destination in ['SCW','SSH'] or Segments[0].Origin in ['PUJ','PEE'] and Segments[0].Destination in ['PUJ','PEE'] or Segments[0].Origin in ['CUN','ASF'] and Segments[0].Destination in ['CUN','ASF'] or Segments[0].Origin in ['AQJ','SVX'] and Segments[0].Destination in ['AQJ','SVX'] or Segments[0].Origin in ['VRA','IKT'] and Segments[0].Destination in ['VRA','IKT'] or Segments[0].Origin in ['SHJ','SVX'] and Segments[0].Destination in ['SHJ','SVX'] or Segments[0].Origin in ['NBC','VRA'] and Segments[0].Destination in ['NBC','VRA'] or Segments[0].Origin in ['HTA','CUN'] and Segments[0].Destination in ['HTA','CUN'] or Segments[0].Origin in ['MOW','TOF'] and Segments[0].Destination in ['MOW','TOF'] or Segments[0].Origin in ['NJC','CUN'] and Segments[0].Destination in ['NJC','CUN'] or Segments[0].Origin in ['CUN','NOZ'] and Segments[0].Destination in ['CUN','NOZ'] or Segments[0].Origin in ['BTK','NHA'] and Segments[0].Destination in ['BTK','NHA'] or Segments[0].Origin in ['PUJ','OMS'] and Segments[0].Destination in ['PUJ','OMS'] or Segments[0].Origin in ['HTA','OVB'] and Segments[0].Destination in ['HTA','OVB'] or Segments[0].Origin in ['AQJ','KZN'] and Segments[0].Destination in ['AQJ','KZN'] or Segments[0].Origin in ['DXB','VOZ'] and Segments[0].Destination in ['DXB','VOZ'] or Segments[0].Origin in ['NHA','PEE'] and Segments[0].Destination in ['NHA','PEE'] or Segments[0].Origin in ['HKT','OGZ'] and Segments[0].Destination in ['HKT','OGZ'] or Segments[0].Origin in ['KLV','MOW'] and Segments[0].Destination in ['KLV','MOW'] or Segments[0].Origin in ['MRV','SKG'] and Segments[0].Destination in ['MRV','SKG'] or Segments[0].Origin in ['SKG','LED'] and Segments[0].Destination in ['SKG','LED'] or Segments[0].Origin in ['AQJ','MOW'] and Segments[0].Destination in ['AQJ','MOW'] or Segments[0].Origin in ['MOW','NHA'] and Segments[0].Destination in ['MOW','NHA'] or Segments[0].Origin in ['ARH','HRG'] and Segments[0].Destination in ['ARH','HRG'] or Segments[0].Origin in ['SGN','AER'] and Segments[0].Destination in ['SGN','AER'] or Segments[0].Origin in ['VRA','MCX'] and Segments[0].Destination in ['VRA','MCX'] or Segments[0].Origin in ['BKK','OVB'] and Segments[0].Destination in ['BKK','OVB'] or Segments[0].Origin in ['AYT','UFA'] and Segments[0].Destination in ['AYT','UFA'] or Segments[0].Origin in ['SGN','NOZ'] and Segments[0].Destination in ['SGN','NOZ'] or Segments[0].Origin in ['SGN','NBC'] and Segments[0].Destination in ['SGN','NBC'] or Segments[0].Origin in ['MOW','BEG'] and Segments[0].Destination in ['MOW','BEG'] or Segments[0].Origin in ['TDX','BQS'] and Segments[0].Destination in ['TDX','BQS'] or Segments[0].Origin in ['KRR','NHA'] and Segments[0].Destination in ['KRR','NHA'] or Segments[0].Origin in ['NHA','SGC'] and Segments[0].Destination in ['NHA','SGC'] or Segments[0].Origin in ['NHA','UFA'] and Segments[0].Destination in ['NHA','UFA'] or Segments[0].Origin in ['NHA','ARH'] and Segments[0].Destination in ['NHA','ARH'] or Segments[0].Origin in ['EGO','VRA'] and Segments[0].Destination in ['EGO','VRA'] or Segments[0].Origin in ['BCN','MOW'] and Segments[0].Destination in ['BCN','MOW'] or Segments[0].Origin in ['TDX','ROV'] and Segments[0].Destination in ['TDX','ROV'] or Segments[0].Origin in ['TSN','MOW'] and Segments[0].Destination in ['TSN','MOW'] or Segments[0].Origin in ['GOJ','HRG'] and Segments[0].Destination in ['GOJ','HRG'] or Segments[0].Origin in ['BKK','KZN'] and Segments[0].Destination in ['BKK','KZN'] or Segments[0].Origin in ['NHA','ROV'] and Segments[0].Destination in ['NHA','ROV'] or Segments[0].Origin in ['DXB','KJA'] and Segments[0].Destination in ['DXB','KJA'] or Segments[0].Origin in ['PEE','AER'] and Segments[0].Destination in ['PEE','AER'] or Segments[0].Origin in ['DXB','CEK'] and Segments[0].Destination in ['DXB','CEK'] or Segments[0].Origin in ['PUJ','ASF'] and Segments[0].Destination in ['PUJ','ASF'] or Segments[0].Origin in ['KBV','OVB'] and Segments[0].Destination in ['KBV','OVB'] or Segments[0].Origin in ['MOW','EVN'] and Segments[0].Destination in ['MOW','EVN'] or Segments[0].Origin in ['IKT','CUN'] and Segments[0].Destination in ['IKT','CUN'] or Segments[0].Origin in ['KGD','HRG'] and Segments[0].Destination in ['KGD','HRG'] or Segments[0].Origin in ['KBV','PEE'] and Segments[0].Destination in ['KBV','PEE'] or Segments[0].Origin in ['VOG','VRA'] and Segments[0].Destination in ['VOG','VRA'] or Segments[0].Origin in ['MOW','HKT'] and Segments[0].Destination in ['MOW','HKT'] or Segments[0].Origin in ['NHA','ASF'] and Segments[0].Destination in ['NHA','ASF'] or Segments[0].Origin in ['LED','SVX'] and Segments[0].Destination in ['LED','SVX'] or Segments[0].Origin in ['AAQ','CUN'] and Segments[0].Destination in ['AAQ','CUN'] or Segments[0].Origin in ['BKK','KEJ'] and Segments[0].Destination in ['BKK','KEJ'] or Segments[0].Origin in ['BKK','BQS'] and Segments[0].Destination in ['BKK','BQS'] or Segments[0].Origin in ['DXB','IKT'] and Segments[0].Destination in ['DXB','IKT'] or Segments[0].Origin in ['SSH','TJM'] and Segments[0].Destination in ['SSH','TJM'] or Segments[0].Origin in ['PUJ','ROV'] and Segments[0].Destination in ['PUJ','ROV'] or Segments[0].Origin in ['AER','SVX'] and Segments[0].Destination in ['AER','SVX'] or Segments[0].Origin in ['UFA','ETH'] and Segments[0].Destination in ['UFA','ETH'] or Segments[0].Origin in ['BKK','KUF'] and Segments[0].Destination in ['BKK','KUF'] or Segments[0].Origin in ['BKK','VVO'] and Segments[0].Destination in ['BKK','VVO'] or Segments[0].Origin in ['HKT','OVB'] and Segments[0].Destination in ['HKT','OVB'] or Segments[0].Origin in ['ZTH','LED'] and Segments[0].Destination in ['ZTH','LED'] or Segments[0].Origin in ['KZN','NHA'] and Segments[0].Destination in ['KZN','NHA'] or Segments[0].Origin in ['VRA','BAX'] and Segments[0].Destination in ['VRA','BAX'] or Segments[0].Origin in ['RTW','NHA'] and Segments[0].Destination in ['RTW','NHA'] or Segments[0].Origin in ['SKG','DNK'] and Segments[0].Destination in ['SKG','DNK'] or Segments[0].Origin in ['SGN','VOG'] and Segments[0].Destination in ['SGN','VOG'] or Segments[0].Origin in ['KBV','VVO'] and Segments[0].Destination in ['KBV','VVO'] or Segments[0].Origin in ['IEV','CFU'] and Segments[0].Destination in ['IEV','CFU'] or Segments[0].Origin in ['PUJ','TOF'] and Segments[0].Destination in ['PUJ','TOF'] or Segments[0].Origin in ['HKT','KEJ'] and Segments[0].Destination in ['HKT','KEJ'] or Segments[0].Origin in ['PUJ','NJC'] and Segments[0].Destination in ['PUJ','NJC'] or Segments[0].Origin in ['PEE','CUN'] and Segments[0].Destination in ['PEE','CUN'] or Segments[0].Origin in ['HKT','TJM'] and Segments[0].Destination in ['HKT','TJM'] or Segments[0].Origin in ['ETH','KZN'] and Segments[0].Destination in ['ETH','KZN'] or Segments[0].Origin in ['MCX','CUN'] and Segments[0].Destination in ['MCX','CUN'] or Segments[0].Origin in ['HRG','KUF'] and Segments[0].Destination in ['HRG','KUF'] or Segments[0].Origin in ['VRA','VOG'] and Segments[0].Destination in ['VRA','VOG'] or Segments[0].Origin in ['SVX','CUN'] and Segments[0].Destination in ['SVX','CUN'] or Segments[0].Origin in ['VRA','EGO'] and Segments[0].Destination in ['VRA','EGO'] or Segments[0].Origin in ['ROV','CUN'] and Segments[0].Destination in ['ROV','CUN'] or Segments[0].Origin in ['KJA','VRA'] and Segments[0].Destination in ['KJA','VRA'] or Segments[0].Origin in ['VRA','PEE'] and Segments[0].Destination in ['VRA','PEE'] or Segments[0].Origin in ['MOW','SKD'] and Segments[0].Destination in ['MOW','SKD'] or Segments[0].Origin in ['POP','ROV'] and Segments[0].Destination in ['POP','ROV'] or Segments[0].Origin in ['AYT','KZN'] and Segments[0].Destination in ['AYT','KZN'] or Segments[0].Origin in ['ETH','REN'] and Segments[0].Destination in ['ETH','REN'] or Segments[0].Origin in ['ETH','LED'] and Segments[0].Destination in ['ETH','LED'] or Segments[0].Origin in ['CEK','ETH'] and Segments[0].Destination in ['CEK','ETH'] or Segments[0].Origin in ['NHA','VOZ'] and Segments[0].Destination in ['NHA','VOZ'] or Segments[0].Origin in ['SVX','AER'] and Segments[0].Destination in ['SVX','AER'] or Segments[0].Origin in ['FEG','MOW'] and Segments[0].Destination in ['FEG','MOW'] or Segments[0].Origin in ['VRA','KZN'] and Segments[0].Destination in ['VRA','KZN'] or Segments[0].Origin in ['USM','PEE'] and Segments[0].Destination in ['USM','PEE'] or Segments[0].Origin in ['VVO','MOW'] and Segments[0].Destination in ['VVO','MOW'] or Segments[0].Origin in ['SGN','KEJ'] and Segments[0].Destination in ['SGN','KEJ'] or Segments[0].Origin in ['DXB','AER'] and Segments[0].Destination in ['DXB','AER'] or Segments[0].Origin in ['MOW','VOG'] and Segments[0].Destination in ['MOW','VOG'] or Segments[0].Origin in ['SGN','YKS'] and Segments[0].Destination in ['SGN','YKS'] or Segments[0].Origin in ['VRA','NJC'] and Segments[0].Destination in ['VRA','NJC'] or Segments[0].Origin in ['VOG','PUJ'] and Segments[0].Destination in ['VOG','PUJ'] or Segments[0].Origin in ['HKT','MOW'] and Segments[0].Destination in ['HKT','MOW'] or Segments[0].Origin in ['VOG','SKG'] and Segments[0].Destination in ['VOG','SKG'] or Segments[0].Origin in ['OVB','YKS'] and Segments[0].Destination in ['OVB','YKS'] or Segments[0].Origin in ['SGC','SSH'] and Segments[0].Destination in ['SGC','SSH'] or Segments[0].Origin in ['VOZ','NHA'] and Segments[0].Destination in ['VOZ','NHA'] or Segments[0].Origin in ['CUN','NBC'] and Segments[0].Destination in ['CUN','NBC'] or Segments[0].Origin in ['KZN','SSH'] and Segments[0].Destination in ['KZN','SSH'] or Segments[0].Origin in ['HER','MOW'] and Segments[0].Destination in ['HER','MOW'] or Segments[0].Origin in ['TDX','UFA'] and Segments[0].Destination in ['TDX','UFA'] or Segments[0].Origin in ['KZN','ETH'] and Segments[0].Destination in ['KZN','ETH'] or Segments[0].Origin in ['ABA','CUN'] and Segments[0].Destination in ['ABA','CUN'] or Segments[0].Origin in ['PEE','NHA'] and Segments[0].Destination in ['PEE','NHA'] or Segments[0].Origin in ['CUN','TOF'] and Segments[0].Destination in ['CUN','TOF'] or Segments[0].Origin in ['TJM','HRG'] and Segments[0].Destination in ['TJM','HRG'] or Segments[0].Origin in ['EGO','HRG'] and Segments[0].Destination in ['EGO','HRG'] or Segments[0].Origin in ['GOJ','SSH'] and Segments[0].Destination in ['GOJ','SSH'] or Segments[0].Origin in ['HKT','HTA'] and Segments[0].Destination in ['HKT','HTA'] or Segments[0].Origin in ['MOW','ETH'] and Segments[0].Destination in ['MOW','ETH'] or Segments[0].Origin in ['OGZ','VRA'] and Segments[0].Destination in ['OGZ','VRA'] or Segments[0].Origin in ['HKT','NBC'] and Segments[0].Destination in ['HKT','NBC'] or Segments[0].Origin in ['GPA','MSQ'] and Segments[0].Destination in ['GPA','MSQ'] or Segments[0].Origin in ['SGN','TOF'] and Segments[0].Destination in ['SGN','TOF'] or Segments[0].Origin in ['HKT','MCX'] and Segments[0].Destination in ['HKT','MCX'] or Segments[0].Origin in ['KRR','VRA'] and Segments[0].Destination in ['KRR','VRA'] or Segments[0].Origin in ['ROV','PUJ'] and Segments[0].Destination in ['ROV','PUJ'] or Segments[0].Origin in ['CEE','VRA'] and Segments[0].Destination in ['CEE','VRA'] or Segments[0].Origin in ['TJM','NHA'] and Segments[0].Destination in ['TJM','NHA'] or Segments[0].Origin in ['RTW','CUN'] and Segments[0].Destination in ['RTW','CUN'] or Segments[0].Origin in ['AER','KZN'] and Segments[0].Destination in ['AER','KZN'] or Segments[0].Origin in ['MRV','ETH'] and Segments[0].Destination in ['MRV','ETH'] or Segments[0].Origin in ['SGN','VOZ'] and Segments[0].Destination in ['SGN','VOZ'] or Segments[0].Origin in ['USM','BQS'] and Segments[0].Destination in ['USM','BQS'] or Segments[0].Origin in ['USM','SGC'] and Segments[0].Destination in ['USM','SGC'] or Segments[0].Origin in ['HER','SVX'] and Segments[0].Destination in ['HER','SVX'] or Segments[0].Origin in ['DXB','KZN'] and Segments[0].Destination in ['DXB','KZN'] or Segments[0].Origin in ['TDX','KEJ'] and Segments[0].Destination in ['TDX','KEJ'] or Segments[0].Origin in ['HRG','SGC'] and Segments[0].Destination in ['HRG','SGC'] or Segments[0].Origin in ['SOF','LED'] and Segments[0].Destination in ['SOF','LED'] or Segments[0].Origin in ['DXB','UFA'] and Segments[0].Destination in ['DXB','UFA'] or Segments[0].Origin in ['EVN','MOW'] and Segments[0].Destination in ['EVN','MOW'] or Segments[0].Origin in ['HKT','LED'] and Segments[0].Destination in ['HKT','LED'] or Segments[0].Origin in ['SGN','NJC'] and Segments[0].Destination in ['SGN','NJC'] or Segments[0].Origin in ['SHJ','KUF'] and Segments[0].Destination in ['SHJ','KUF'] or Segments[0].Origin in ['AQJ','LED'] and Segments[0].Destination in ['AQJ','LED'] or Segments[0].Origin in ['HRG','GOJ'] and Segments[0].Destination in ['HRG','GOJ'] or Segments[0].Origin in ['PRG','LED'] and Segments[0].Destination in ['PRG','LED'] or Segments[0].Origin in ['NOZ','NHA'] and Segments[0].Destination in ['NOZ','NHA'] or Segments[0].Origin in ['ARH','SSH'] and Segments[0].Destination in ['ARH','SSH'] or Segments[0].Origin in ['SSH','REN'] and Segments[0].Destination in ['SSH','REN'] or Segments[0].Origin in ['AYT','GOJ'] and Segments[0].Destination in ['AYT','GOJ'] or Segments[0].Origin in ['ATH','MSQ'] and Segments[0].Destination in ['ATH','MSQ'] or Segments[0].Origin in ['MOW','VAR'] and Segments[0].Destination in ['MOW','VAR'] or Segments[0].Origin in ['HER','LED'] and Segments[0].Destination in ['HER','LED'] or Segments[0].Origin in ['SIP','KJA'] and Segments[0].Destination in ['SIP','KJA'] or Segments[0].Origin in ['TJM','CUN'] and Segments[0].Destination in ['TJM','CUN'] or Segments[0].Origin in ['PUJ','LED'] and Segments[0].Destination in ['PUJ','LED'] or Segments[0].Origin in ['BKK','SGC'] and Segments[0].Destination in ['BKK','SGC'] or Segments[0].Origin in ['PUJ','KEJ'] and Segments[0].Destination in ['PUJ','KEJ'] or Segments[0].Origin in ['BKK','KJA'] and Segments[0].Destination in ['BKK','KJA'] or Segments[0].Origin in ['DXB','VOG'] and Segments[0].Destination in ['DXB','VOG'] or Segments[0].Origin in ['PUJ','KJA'] and Segments[0].Destination in ['PUJ','KJA'] or Segments[0].Origin in ['RMI','MOW'] and Segments[0].Destination in ['RMI','MOW'] or Segments[0].Origin in ['USM','KEJ'] and Segments[0].Destination in ['USM','KEJ'] or Segments[0].Origin in ['MOW','RVN'] and Segments[0].Destination in ['MOW','RVN'] or Segments[0].Origin in ['VRA','AER'] and Segments[0].Destination in ['VRA','AER'] or Segments[0].Origin in ['SGN','VVO'] and Segments[0].Destination in ['SGN','VVO'] or Segments[0].Origin in ['SIP','MOW'] and Segments[0].Destination in ['SIP','MOW'] or Segments[0].Origin in ['ETH','MRV'] and Segments[0].Destination in ['ETH','MRV'] or Segments[0].Origin in ['VRA','MRV'] and Segments[0].Destination in ['VRA','MRV'] or Segments[0].Origin in ['ROV','MOW'] and Segments[0].Destination in ['ROV','MOW'] or Segments[0].Origin in ['KBV','TJM'] and Segments[0].Destination in ['KBV','TJM'] or Segments[0].Origin in ['PUJ','VOZ'] and Segments[0].Destination in ['PUJ','VOZ'] or Segments[0].Origin in ['LED','AER'] and Segments[0].Destination in ['LED','AER'] or Segments[0].Origin in ['AER','VRA'] and Segments[0].Destination in ['AER','VRA'] or Segments[0].Origin in ['CUN','SVX'] and Segments[0].Destination in ['CUN','SVX'] or Segments[0].Origin in ['HKT','ROV'] and Segments[0].Destination in ['HKT','ROV'] or Segments[0].Origin in ['KUF','NHA'] and Segments[0].Destination in ['KUF','NHA'] or Segments[0].Origin in ['KGD','SKG'] and Segments[0].Destination in ['KGD','SKG'] or Segments[0].Origin in ['DXB','YKS'] and Segments[0].Destination in ['DXB','YKS'] or Segments[0].Origin in ['AER','PEE'] and Segments[0].Destination in ['AER','PEE'] or Segments[0].Origin in ['ROV','CFU'] and Segments[0].Destination in ['ROV','CFU'] or Segments[0].Origin in ['VOG','CUN'] and Segments[0].Destination in ['VOG','CUN'] or Segments[0].Origin in ['PUJ','KZN'] and Segments[0].Destination in ['PUJ','KZN'] or Segments[0].Origin in ['MOW','SZG'] and Segments[0].Destination in ['MOW','SZG'] or Segments[0].Origin in ['GDX','MOW'] and Segments[0].Destination in ['GDX','MOW'] or Segments[0].Origin in ['HKT','VOG'] and Segments[0].Destination in ['HKT','VOG'] or Segments[0].Origin in ['BOJ','MOW'] and Segments[0].Destination in ['BOJ','MOW'] or Segments[0].Origin in ['OVB','HTA'] and Segments[0].Destination in ['OVB','HTA'] or Segments[0].Origin in ['BKK','EGO'] and Segments[0].Destination in ['BKK','EGO'] or Segments[0].Origin in ['ETH','KUF'] and Segments[0].Destination in ['ETH','KUF'] or Segments[0].Origin in ['HRG','ARH'] and Segments[0].Destination in ['HRG','ARH'] or Segments[0].Origin in ['MOW','KGD'] and Segments[0].Destination in ['MOW','KGD'] or Segments[0].Origin in ['HRG','CEK'] and Segments[0].Destination in ['HRG','CEK'] or Segments[0].Origin in ['LED','HER'] and Segments[0].Destination in ['LED','HER'] or Segments[0].Origin in ['USM','IKT'] and Segments[0].Destination in ['USM','IKT'] or Segments[0].Origin in ['CUN','TJM'] and Segments[0].Destination in ['CUN','TJM'] or Segments[0].Origin in ['NHA','UUS'] and Segments[0].Destination in ['NHA','UUS'] or Segments[0].Origin in ['NHA','KZN'] and Segments[0].Destination in ['NHA','KZN'] or Segments[0].Origin in ['NBC','HRG'] and Segments[0].Destination in ['NBC','HRG'] or Segments[0].Origin in ['SKG','SVX'] and Segments[0].Destination in ['SKG','SVX'] or Segments[0].Origin in ['HRG','UFA'] and Segments[0].Destination in ['HRG','UFA'] or Segments[0].Origin in ['TDX','MOW'] and Segments[0].Destination in ['TDX','MOW'] or Segments[0].Origin in ['LED','SKG'] and Segments[0].Destination in ['LED','SKG'] or Segments[0].Origin in ['SGN','SVX'] and Segments[0].Destination in ['SGN','SVX'] or Segments[0].Origin in ['CUN','AER'] and Segments[0].Destination in ['CUN','AER'] or Segments[0].Origin in ['MOW','KUT'] and Segments[0].Destination in ['MOW','KUT'] or Segments[0].Origin in ['VRN','KRR'] and Segments[0].Destination in ['VRN','KRR'] or Segments[0].Origin in ['MSQ','ATH'] and Segments[0].Destination in ['MSQ','ATH'] or Segments[0].Origin in ['PUJ','BAX'] and Segments[0].Destination in ['PUJ','BAX'] or Segments[0].Origin in ['KEJ','CUN'] and Segments[0].Destination in ['KEJ','CUN'] or Segments[0].Origin in ['KUF','PUJ'] and Segments[0].Destination in ['KUF','PUJ'] or Segments[0].Origin in ['VRA','KUF'] and Segments[0].Destination in ['VRA','KUF'] or Segments[0].Origin in ['LED','HRG'] and Segments[0].Destination in ['LED','HRG'] or Segments[0].Origin in ['BKK','ASF'] and Segments[0].Destination in ['BKK','ASF'] or Segments[0].Origin in ['IEV','HER'] and Segments[0].Destination in ['IEV','HER'] or Segments[0].Origin in ['SHJ','ROV'] and Segments[0].Destination in ['SHJ','ROV'] or Segments[0].Origin in ['KUT','MOW'] and Segments[0].Destination in ['KUT','MOW'] or Segments[0].Origin in ['HKT','KRR'] and Segments[0].Destination in ['HKT','KRR'] or Segments[0].Origin in ['AYT','MOW'] and Segments[0].Destination in ['AYT','MOW'] or Segments[0].Origin in ['VRA','MOW'] and Segments[0].Destination in ['VRA','MOW'] or Segments[0].Origin in ['SCW','PUJ'] and Segments[0].Destination in ['SCW','PUJ'] or Segments[0].Origin in ['MOW','TAS'] and Segments[0].Destination in ['MOW','TAS'] or Segments[0].Origin in ['IEV','SKG'] and Segments[0].Destination in ['IEV','SKG'] or Segments[0].Origin in ['LED','BOJ'] and Segments[0].Destination in ['LED','BOJ'] or Segments[0].Origin in ['HKT','SVX'] and Segments[0].Destination in ['HKT','SVX'] or Segments[0].Origin in ['BKK','SVX'] and Segments[0].Destination in ['BKK','SVX'] or Segments[0].Origin in ['SGN','MOW'] and Segments[0].Destination in ['SGN','MOW'] or Segments[0].Origin in ['SVX','ETH'] and Segments[0].Destination in ['SVX','ETH'] or Segments[0].Origin in ['SSH','PEE'] and Segments[0].Destination in ['SSH','PEE'] or Segments[0].Origin in ['NHA','KUF'] and Segments[0].Destination in ['NHA','KUF'] or Segments[0].Origin in ['SSH','KUF'] and Segments[0].Destination in ['SSH','KUF'] or Segments[0].Origin in ['DXB','MOW'] and Segments[0].Destination in ['DXB','MOW'] or Segments[0].Origin in ['PUJ','YKS'] and Segments[0].Destination in ['PUJ','YKS'] or Segments[0].Origin in ['SSH','ARH'] and Segments[0].Destination in ['SSH','ARH'] or Segments[0].Origin in ['AUH','MOW'] and Segments[0].Destination in ['AUH','MOW'] or Segments[0].Origin in ['UTP','IKT'] and Segments[0].Destination in ['UTP','IKT'] or Segments[0].Origin in ['KRR','SSH'] and Segments[0].Destination in ['KRR','SSH'] or Segments[0].Origin in ['HRG','KZN'] and Segments[0].Destination in ['HRG','KZN'] or Segments[0].Origin in ['BKK','ROV'] and Segments[0].Destination in ['BKK','ROV'] or Segments[0].Origin in ['CEK','PUJ'] and Segments[0].Destination in ['CEK','PUJ'] or Segments[0].Origin in ['SGN','KGD'] and Segments[0].Destination in ['SGN','KGD'] or Segments[0].Origin in ['KEJ','PUJ'] and Segments[0].Destination in ['KEJ','PUJ'] or Segments[0].Origin in ['HKT','SCW'] and Segments[0].Destination in ['HKT','SCW'] or Segments[0].Origin in ['BKK','KGD'] and Segments[0].Destination in ['BKK','KGD'] or Segments[0].Origin in ['HKT','SGC'] and Segments[0].Destination in ['HKT','SGC'] or Segments[0].Origin in ['REN','HRG'] and Segments[0].Destination in ['REN','HRG'] or Segments[0].Origin in ['SKG','TSE'] and Segments[0].Destination in ['SKG','TSE'] or Segments[0].Origin in ['BKK','PKC'] and Segments[0].Destination in ['BKK','PKC'] or Segments[0].Origin in ['VRA','KJA'] and Segments[0].Destination in ['VRA','KJA'] or Segments[0].Origin in ['SCW','CUN'] and Segments[0].Destination in ['SCW','CUN'] or Segments[0].Origin in ['SKG','KZN'] and Segments[0].Destination in ['SKG','KZN'] or Segments[0].Origin in ['MOW','GRV'] and Segments[0].Destination in ['MOW','GRV'] or Segments[0].Origin in ['HRG','NBC'] and Segments[0].Destination in ['HRG','NBC'] or Segments[0].Origin in ['SCW','VRA'] and Segments[0].Destination in ['SCW','VRA'] or Segments[0].Origin in ['UFA','HRG'] and Segments[0].Destination in ['UFA','HRG'] or Segments[0].Origin in ['EGO','CUN'] and Segments[0].Destination in ['EGO','CUN'] or Segments[0].Origin in ['KUF','HRG'] and Segments[0].Destination in ['KUF','HRG'] or Segments[0].Origin in ['CUN','ROV'] and Segments[0].Destination in ['CUN','ROV'] or Segments[0].Origin in ['KBV','KEJ'] and Segments[0].Destination in ['KBV','KEJ'] or Segments[0].Origin in ['NHA','IKT'] and Segments[0].Destination in ['NHA','IKT'] or Segments[0].Origin in ['SSH','KRR'] and Segments[0].Destination in ['SSH','KRR'] or Segments[0].Origin in ['CFU','MOW'] and Segments[0].Destination in ['CFU','MOW'] or Segments[0].Origin in ['MSQ','GPA'] and Segments[0].Destination in ['MSQ','GPA'] or Segments[0].Origin in ['ZTH','MOW'] and Segments[0].Destination in ['ZTH','MOW'] or Segments[0].Origin in ['AER','KJA'] and Segments[0].Destination in ['AER','KJA'] or Segments[0].Origin in ['MOW','CFU'] and Segments[0].Destination in ['MOW','CFU'] or Segments[0].Origin in ['BKK','SCW'] and Segments[0].Destination in ['BKK','SCW'] or Segments[0].Origin in ['PUJ','OGZ'] and Segments[0].Destination in ['PUJ','OGZ'] or Segments[0].Origin in ['AMM','MOW'] and Segments[0].Destination in ['AMM','MOW'] or Segments[0].Origin in ['OVB','TOF'] and Segments[0].Destination in ['OVB','TOF'] or Segments[0].Origin in ['SGN','KZN'] and Segments[0].Destination in ['SGN','KZN'] or Segments[0].Origin in ['VOG','AER'] and Segments[0].Destination in ['VOG','AER'] or Segments[0].Origin in ['VRA','SVX'] and Segments[0].Destination in ['VRA','SVX'] or Segments[0].Origin in ['DXB','SVX'] and Segments[0].Destination in ['DXB','SVX'] or Segments[0].Origin in ['HKT','BQS'] and Segments[0].Destination in ['HKT','BQS'] or Segments[0].Origin in ['PUJ','EGO'] and Segments[0].Destination in ['PUJ','EGO'] or Segments[0].Origin in ['DXB','LED'] and Segments[0].Destination in ['DXB','LED'] or Segments[0].Origin in ['ETH','MOW'] and Segments[0].Destination in ['ETH','MOW'] or Segments[0].Origin in ['MOW','KJA'] and Segments[0].Destination in ['MOW','KJA'] or Segments[0].Origin in ['IKT','MOW'] and Segments[0].Destination in ['IKT','MOW'] or Segments[0].Origin in ['KBV','ROV'] and Segments[0].Destination in ['KBV','ROV'] or Segments[0].Origin in ['BKK','REN'] and Segments[0].Destination in ['BKK','REN'] or Segments[0].Origin in ['HKT','PEE'] and Segments[0].Destination in ['HKT','PEE'] or Segments[0].Origin in ['SVX','VRA'] and Segments[0].Destination in ['SVX','VRA'] or Segments[0].Origin in ['BKK','AER'] and Segments[0].Destination in ['BKK','AER'] or Segments[0].Origin in ['ETH','ROV'] and Segments[0].Destination in ['ETH','ROV'] or Segments[0].Origin in ['SGN','SCW'] and Segments[0].Destination in ['SGN','SCW'] or Segments[0].Origin in ['SIP','KUF'] and Segments[0].Destination in ['SIP','KUF'] or Segments[0].Origin in ['CEK','NHA'] and Segments[0].Destination in ['CEK','NHA'] or Segments[0].Origin in ['AQJ','KRR'] and Segments[0].Destination in ['AQJ','KRR'] or Segments[0].Origin in ['KBV','MOW'] and Segments[0].Destination in ['KBV','MOW'] or Segments[0].Origin in ['BHK','MOW'] and Segments[0].Destination in ['BHK','MOW'] or Segments[0].Origin in ['BKK','PEE'] and Segments[0].Destination in ['BKK','PEE'] or Segments[0].Origin in ['MOW','BAX'] and Segments[0].Destination in ['MOW','BAX'] or Segments[0].Origin in ['GPA','MOW'] and Segments[0].Destination in ['GPA','MOW'] or Segments[0].Origin in ['RIX','MOW'] and Segments[0].Destination in ['RIX','MOW'] or Segments[0].Origin in ['DXB','NBC'] and Segments[0].Destination in ['DXB','NBC'] or Segments[0].Origin in ['PUJ','OVB'] and Segments[0].Destination in ['PUJ','OVB'] or Segments[0].Origin in ['ETH','CEK'] and Segments[0].Destination in ['ETH','CEK'] or Segments[0].Origin in ['KRR','ETH'] and Segments[0].Destination in ['KRR','ETH'] or Segments[0].Origin in ['HKT','UUD'] and Segments[0].Destination in ['HKT','UUD'] or Segments[0].Origin in ['TOF','VRA'] and Segments[0].Destination in ['TOF','VRA'] or Segments[0].Origin in ['MOW','SKG'] and Segments[0].Destination in ['MOW','SKG'] or Segments[0].Origin in ['BTK','OVB'] and Segments[0].Destination in ['BTK','OVB'] or Segments[0].Origin in ['KRR','LCA'] and Segments[0].Destination in ['KRR','LCA'] or Segments[0].Origin in ['OGZ','CUN'] and Segments[0].Destination in ['OGZ','CUN'] or Segments[0].Origin in ['PUJ','KGD'] and Segments[0].Destination in ['PUJ','KGD'] or Segments[0].Origin in ['USM','OVB'] and Segments[0].Destination in ['USM','OVB'] or Segments[0].Origin in ['MOW','SHE'] and Segments[0].Destination in ['MOW','SHE'] or Segments[0].Origin in ['RTW','VRA'] and Segments[0].Destination in ['RTW','VRA'] or Segments[0].Origin in ['SHJ','VOZ'] and Segments[0].Destination in ['SHJ','VOZ'] or Segments[0].Origin in ['SSH','VOG'] and Segments[0].Destination in ['SSH','VOG'] or Segments[0].Origin in ['DXB','NOZ'] and Segments[0].Destination in ['DXB','NOZ'] or Segments[0].Origin in ['SGN','SGC'] and Segments[0].Destination in ['SGN','SGC'] or Segments[0].Origin in ['VVO','NHA'] and Segments[0].Destination in ['VVO','NHA'] or Segments[0].Origin in ['CUN','KZN'] and Segments[0].Destination in ['CUN','KZN'] or Segments[0].Origin in ['AYT','SVX'] and Segments[0].Destination in ['AYT','SVX'] or Segments[0].Origin in ['CUN','KGD'] and Segments[0].Destination in ['CUN','KGD'] or Segments[0].Origin in ['KBV','KZN'] and Segments[0].Destination in ['KBV','KZN'] or Segments[0].Origin in ['VRN','MOW'] and Segments[0].Destination in ['VRN','MOW'] or Segments[0].Origin in ['OVB','UUD'] and Segments[0].Destination in ['OVB','UUD'] or Segments[0].Origin in ['USM','TJM'] and Segments[0].Destination in ['USM','TJM'] or Segments[0].Origin in ['HRG','MMK'] and Segments[0].Destination in ['HRG','MMK'] or Segments[0].Origin in ['KUF','SSH'] and Segments[0].Destination in ['KUF','SSH'] or Segments[0].Origin in ['AER','LED'] and Segments[0].Destination in ['AER','LED'] or Segments[0].Origin in ['SGN','ROV'] and Segments[0].Destination in ['SGN','ROV'] or Segments[0].Origin in ['KZN','CUN'] and Segments[0].Destination in ['KZN','CUN'] or Segments[0].Origin in ['VRA','NBC'] and Segments[0].Destination in ['VRA','NBC'] or Segments[0].Origin in ['KUF','CUN'] and Segments[0].Destination in ['KUF','CUN'] or Segments[0].Origin in ['SSH','SGC'] and Segments[0].Destination in ['SSH','SGC'] or Segments[0].Origin in ['VRA','OVB'] and Segments[0].Destination in ['VRA','OVB'] or Segments[0].Origin in ['ODS','SKG'] and Segments[0].Destination in ['ODS','SKG'] or Segments[0].Origin in ['AMM','LED'] and Segments[0].Destination in ['AMM','LED'] or Segments[0].Origin in ['RTW','PUJ'] and Segments[0].Destination in ['RTW','PUJ'] or Segments[0].Origin in ['BKK','NJC'] and Segments[0].Destination in ['BKK','NJC'] or Segments[0].Origin in ['CUN','KRR'] and Segments[0].Destination in ['CUN','KRR'] or Segments[0].Origin in ['MRV','SSH'] and Segments[0].Destination in ['MRV','SSH'] or Segments[0].Origin in ['SGC','HRG'] and Segments[0].Destination in ['SGC','HRG'] or Segments[0].Origin in ['KZN','SKG'] and Segments[0].Destination in ['KZN','SKG'] or Segments[0].Origin in ['UFA','MOW'] and Segments[0].Destination in ['UFA','MOW'] or Segments[0].Origin in ['ROM','MOW'] and Segments[0].Destination in ['ROM','MOW'] or Segments[0].Origin in ['NBC','PUJ'] and Segments[0].Destination in ['NBC','PUJ'] or Segments[0].Origin in ['KHV','MOW'] and Segments[0].Destination in ['KHV','MOW'] or Segments[0].Origin in ['VRA','CEK'] and Segments[0].Destination in ['VRA','CEK'] or Segments[0].Origin in ['VRA','KEJ'] and Segments[0].Destination in ['VRA','KEJ'] or Segments[0].Origin in ['MOW','VVO'] and Segments[0].Destination in ['MOW','VVO'] or Segments[0].Origin in ['TOF','CUN'] and Segments[0].Destination in ['TOF','CUN'] or Segments[0].Origin in ['OVB','SKG'] and Segments[0].Destination in ['OVB','SKG'] or Segments[0].Origin in ['CUN','VOG'] and Segments[0].Destination in ['CUN','VOG'] or Segments[0].Origin in ['BKK','VOZ'] and Segments[0].Destination in ['BKK','VOZ'] or Segments[0].Origin in ['ROV','ETH'] and Segments[0].Destination in ['ROV','ETH'] or Segments[0].Origin in ['HTA','NHA'] and Segments[0].Destination in ['HTA','NHA'] or Segments[0].Origin in ['GOJ','VRA'] and Segments[0].Destination in ['GOJ','VRA'] or Segments[0].Origin in ['MOW','VRN'] and Segments[0].Destination in ['MOW','VRN'] or Segments[0].Origin in ['KZN','HRG'] and Segments[0].Destination in ['KZN','HRG'] or Segments[0].Origin in ['NHA','BAX'] and Segments[0].Destination in ['NHA','BAX'] or Segments[0].Origin in ['VRA','ASF'] and Segments[0].Destination in ['VRA','ASF'] or Segments[0].Origin in ['GOJ','SKG'] and Segments[0].Destination in ['GOJ','SKG'] or Segments[0].Origin in ['SKG','LWO'] and Segments[0].Destination in ['SKG','LWO'] or Segments[0].Origin in ['MRV','CUN'] and Segments[0].Destination in ['MRV','CUN'] or Segments[0].Origin in ['SOF','MOW'] and Segments[0].Destination in ['SOF','MOW'] or Segments[0].Origin in ['BAX','VRA'] and Segments[0].Destination in ['BAX','VRA'] or Segments[0].Origin in ['SSH','MRV'] and Segments[0].Destination in ['SSH','MRV'] or Segments[0].Origin in ['KRR','LED'] and Segments[0].Destination in ['KRR','LED'] or Segments[0].Origin in ['NHA','REN'] and Segments[0].Destination in ['NHA','REN'] or Segments[0].Origin in ['ATH','MOW'] and Segments[0].Destination in ['ATH','MOW'] or Segments[0].Origin in ['KZN','VRA'] and Segments[0].Destination in ['KZN','VRA'] or Segments[0].Origin in ['HRG','VOZ'] and Segments[0].Destination in ['HRG','VOZ'] or Segments[0].Origin in ['SGN','KUF'] and Segments[0].Destination in ['SGN','KUF'] or Segments[0].Origin in ['LED','CFU'] and Segments[0].Destination in ['LED','CFU'] or Segments[0].Origin in ['SGN','MRV'] and Segments[0].Destination in ['SGN','MRV'] or Segments[0].Origin in ['CUN','EGO'] and Segments[0].Destination in ['CUN','EGO'] or Segments[0].Origin in ['KJA','AER'] and Segments[0].Destination in ['KJA','AER'] or Segments[0].Origin in ['VRA','SCW'] and Segments[0].Destination in ['VRA','SCW'] or Segments[0].Origin in ['BQS','NHA'] and Segments[0].Destination in ['BQS','NHA'] or Segments[0].Origin in ['KGD','SSH'] and Segments[0].Destination in ['KGD','SSH'] or Segments[0].Origin in ['BKK','KRR'] and Segments[0].Destination in ['BKK','KRR'] or Segments[0].Origin in ['DXB','OVB'] and Segments[0].Destination in ['DXB','OVB'] or Segments[0].Origin in ['KRR','HRG'] and Segments[0].Destination in ['KRR','HRG'] or Segments[0].Origin in ['VRA','OMS'] and Segments[0].Destination in ['VRA','OMS'] or Segments[0].Origin in ['BKK','MRV'] and Segments[0].Destination in ['BKK','MRV'] or Segments[0].Origin in ['IKT','PUJ'] and Segments[0].Destination in ['IKT','PUJ'] or Segments[0].Origin in ['KZN','PUJ'] and Segments[0].Destination in ['KZN','PUJ'] or Segments[0].Origin in ['BKK','LED'] and Segments[0].Destination in ['BKK','LED'] or Segments[0].Origin in ['SGN','LED'] and Segments[0].Destination in ['SGN','LED'] or Segments[0].Origin in ['NHA','CEK'] and Segments[0].Destination in ['NHA','CEK'] or Segments[0].Origin in ['KJA','SSH'] and Segments[0].Destination in ['KJA','SSH'] or Segments[0].Origin in ['CUN','MOW'] and Segments[0].Destination in ['CUN','MOW'] or Segments[0].Origin in ['UUD','NHA'] and Segments[0].Destination in ['UUD','NHA'] or Segments[0].Origin in ['KUF','ETH'] and Segments[0].Destination in ['KUF','ETH'] or Segments[0].Origin in ['HKT','REN'] and Segments[0].Destination in ['HKT','REN'] or Segments[0].Origin in ['BKK','MOW'] and Segments[0].Destination in ['BKK','MOW'] or Segments[0].Origin in ['BKK','UUD'] and Segments[0].Destination in ['BKK','UUD'] or Segments[0].Origin in ['CUN','OVB'] and Segments[0].Destination in ['CUN','OVB'] or Segments[0].Origin in ['SVX','SSH'] and Segments[0].Destination in ['SVX','SSH'] or Segments[0].Origin in ['LED','ETH'] and Segments[0].Destination in ['LED','ETH'] or Segments[0].Origin in ['MSQ','CFU'] and Segments[0].Destination in ['MSQ','CFU'] or Segments[0].Origin in ['KGD','PUJ'] and Segments[0].Destination in ['KGD','PUJ'] or Segments[0].Origin in ['OVB','AER'] and Segments[0].Destination in ['OVB','AER'] or Segments[0].Origin in ['OMS','NHA'] and Segments[0].Destination in ['OMS','NHA'] or Segments[0].Origin in ['PUJ','GOJ'] and Segments[0].Destination in ['PUJ','GOJ'] or Segments[0].Origin in ['NHA','TOF'] and Segments[0].Destination in ['NHA','TOF'] or Segments[0].Origin in ['TDX','BAX'] and Segments[0].Destination in ['TDX','BAX'] or Segments[0].Origin in ['UTP','KJA'] and Segments[0].Destination in ['UTP','KJA'] or Segments[0].Origin in ['BKK','KHV'] and Segments[0].Destination in ['BKK','KHV'] or Segments[0].Origin in ['NHA','BQS'] and Segments[0].Destination in ['NHA','BQS'] or Segments[0].Origin in ['CMF','MOW'] and Segments[0].Destination in ['CMF','MOW'] or Segments[0].Origin in ['BER','MOW'] and Segments[0].Destination in ['BER','MOW'] or Segments[0].Origin in ['SGN','KHV'] and Segments[0].Destination in ['SGN','KHV'] or Segments[0].Origin in ['DXB','NJC'] and Segments[0].Destination in ['DXB','NJC'] or Segments[0].Origin in ['IKT','VRA'] and Segments[0].Destination in ['IKT','VRA'] or Segments[0].Origin in ['TAS','MOW'] and Segments[0].Destination in ['TAS','MOW'] or Segments[0].Origin in ['GOJ','AYT'] and Segments[0].Destination in ['GOJ','AYT'] or Segments[0].Origin in ['VRA','GOJ'] and Segments[0].Destination in ['VRA','GOJ'] or Segments[0].Origin in ['MOW','BQS'] and Segments[0].Destination in ['MOW','BQS'] or Segments[0].Origin in ['NOZ','VRA'] and Segments[0].Destination in ['NOZ','VRA'] or Segments[0].Origin in ['PUJ','CEK'] and Segments[0].Destination in ['PUJ','CEK'] or Segments[0].Origin in ['USM','BAX'] and Segments[0].Destination in ['USM','BAX'] or Segments[0].Origin in ['ROV','VRN'] and Segments[0].Destination in ['ROV','VRN'] or Segments[0].Origin in ['OVB','CUN'] and Segments[0].Destination in ['OVB','CUN'] or Segments[0].Origin in ['OVB','MOW'] and Segments[0].Destination in ['OVB','MOW'] or Segments[0].Origin in ['SKG','ROV'] and Segments[0].Destination in ['SKG','ROV'] or Segments[0].Origin in ['MOW','BKK'] and Segments[0].Destination in ['MOW','BKK'] or Segments[0].Origin in ['BKK','IKT'] and Segments[0].Destination in ['BKK','IKT'] or Segments[0].Origin in ['TDX','SGC'] and Segments[0].Destination in ['TDX','SGC'] or Segments[0].Origin in ['ROV','VRA'] and Segments[0].Destination in ['ROV','VRA'] or Segments[0].Origin in ['BKK','TOF'] and Segments[0].Destination in ['BKK','TOF'] or Segments[0].Origin in ['CUN','MRV'] and Segments[0].Destination in ['CUN','MRV'] or Segments[0].Origin in ['ZTH','MSQ'] and Segments[0].Destination in ['ZTH','MSQ'] or Segments[0].Origin in ['MOW','CMF'] and Segments[0].Destination in ['MOW','CMF'] or Segments[0].Origin in ['CUN','PEE'] and Segments[0].Destination in ['CUN','PEE'] or Segments[0].Origin in ['CEK','HRG'] and Segments[0].Destination in ['CEK','HRG'] or Segments[0].Origin in ['HRG','KRR'] and Segments[0].Destination in ['HRG','KRR'] or Segments[0].Origin in ['VAR','LED'] and Segments[0].Destination in ['VAR','LED'] or Segments[0].Origin in ['NBC','SSH'] and Segments[0].Destination in ['NBC','SSH'] or Segments[0].Origin in ['PUJ','AER'] and Segments[0].Destination in ['PUJ','AER'] or Segments[0].Origin in ['SIP','SVX'] and Segments[0].Destination in ['SIP','SVX'] or Segments[0].Origin in ['ROV','NHA'] and Segments[0].Destination in ['ROV','NHA'] or Segments[0].Origin in ['CUN','IKT'] and Segments[0].Destination in ['CUN','IKT'] or Segments[0].Origin in ['OVB','VRA'] and Segments[0].Destination in ['OVB','VRA'] or Segments[0].Origin in ['MOW','OVB'] and Segments[0].Destination in ['MOW','OVB'] or Segments[0].Origin in ['UUD','OVB'] and Segments[0].Destination in ['UUD','OVB'] or Segments[0].Origin in ['KRR','OVB'] and Segments[0].Destination in ['KRR','OVB'] or Segments[0].Origin in ['TJM','PUJ'] and Segments[0].Destination in ['TJM','PUJ'] or Segments[0].Origin in ['PEE','HRG'] and Segments[0].Destination in ['PEE','HRG'] or Segments[0].Origin in ['KZN','AYT'] and Segments[0].Destination in ['KZN','AYT'] or Segments[0].Origin in ['GVA','MOW'] and Segments[0].Destination in ['GVA','MOW'] or Segments[0].Origin in ['CUN','OGZ'] and Segments[0].Destination in ['CUN','OGZ'] or Segments[0].Origin in ['MUC','MOW'] and Segments[0].Destination in ['MUC','MOW'] or Segments[0].Origin in ['VOZ','SSH'] and Segments[0].Destination in ['VOZ','SSH'] or Segments[0].Origin in ['AER','OVB'] and Segments[0].Destination in ['AER','OVB'] or Segments[0].Origin in ['HRG','KEJ'] and Segments[0].Destination in ['HRG','KEJ'] or Segments[0].Origin in ['TJM','VRA'] and Segments[0].Destination in ['TJM','VRA'] or Segments[0].Origin in ['HKT','BAX'] and Segments[0].Destination in ['HKT','BAX'] or Segments[0].Origin in ['KUF','AER'] and Segments[0].Destination in ['KUF','AER'] or Segments[0].Origin in ['SGN','HTA'] and Segments[0].Destination in ['SGN','HTA'] or Segments[0].Origin in ['SSH','UFA'] and Segments[0].Destination in ['SSH','UFA'] or Segments[0].Origin in ['SHJ','MOW'] and Segments[0].Destination in ['SHJ','MOW'] or Segments[0].Origin in ['SSH','KZN'] and Segments[0].Destination in ['SSH','KZN'] or Segments[0].Origin in ['SVX','PUJ'] and Segments[0].Destination in ['SVX','PUJ'] or Segments[0].Origin in ['PRG','MOW'] and Segments[0].Destination in ['PRG','MOW'] or Segments[0].Origin in ['VOZ','VRA'] and Segments[0].Destination in ['VOZ','VRA'] or Segments[0].Origin in ['AER','MOW'] and Segments[0].Destination in ['AER','MOW'] or Segments[0].Origin in ['SSH','OMS'] and Segments[0].Destination in ['SSH','OMS'] or Segments[0].Origin in ['SSH','SCW'] and Segments[0].Destination in ['SSH','SCW'] or Segments[0].Origin in ['CUN','MCX'] and Segments[0].Destination in ['CUN','MCX'] or Segments[0].Origin in ['MMK','HRG'] and Segments[0].Destination in ['MMK','HRG'] or Segments[0].Origin in ['LED','SOF'] and Segments[0].Destination in ['LED','SOF'] or Segments[0].Origin in ['KBV','UFA'] and Segments[0].Destination in ['KBV','UFA'] or Segments[0].Origin in ['DJE','MOW'] and Segments[0].Destination in ['DJE','MOW'] or Segments[0].Origin in ['NJC','VRA'] and Segments[0].Destination in ['NJC','VRA'] or Segments[0].Origin in ['YKS','NHA'] and Segments[0].Destination in ['YKS','NHA'] or Segments[0].Origin in ['SSH','MMK'] and Segments[0].Destination in ['SSH','MMK'] or Segments[0].Origin in ['PUJ','TJM'] and Segments[0].Destination in ['PUJ','TJM'] or Segments[0].Origin in ['TOF','NHA'] and Segments[0].Destination in ['TOF','NHA'] or Segments[0].Origin in ['SGN','PEE'] and Segments[0].Destination in ['SGN','PEE'] or Segments[0].Origin in ['NOZ','CUN'] and Segments[0].Destination in ['NOZ','CUN'] or Segments[0].Origin in ['PEE','PUJ'] and Segments[0].Destination in ['PEE','PUJ'] or Segments[0].Origin in ['SVX','NHA'] and Segments[0].Destination in ['SVX','NHA'] or Segments[0].Origin in ['ARH','NHA'] and Segments[0].Destination in ['ARH','NHA'] or Segments[0].Origin in ['SCW','NHA'] and Segments[0].Destination in ['SCW','NHA'] or Segments[0].Origin in ['KEJ','SSH'] and Segments[0].Destination in ['KEJ','SSH'] or Segments[0].Origin in ['AER','UFA'] and Segments[0].Destination in ['AER','UFA'] or Segments[0].Origin in ['NHA','MCX'] and Segments[0].Destination in ['NHA','MCX'] or Segments[0].Origin in ['CUN','LED'] and Segments[0].Destination in ['CUN','LED'] or Segments[0].Origin in ['MOW','FEG'] and Segments[0].Destination in ['MOW','FEG'] or Segments[0].Origin in ['MOW','SVX'] and Segments[0].Destination in ['MOW','SVX'] or Segments[0].Origin in ['KBV','SGC'] and Segments[0].Destination in ['KBV','SGC'] or Segments[0].Origin in ['VRA','KRR'] and Segments[0].Destination in ['VRA','KRR'] or Segments[0].Origin in ['SKG','KRR'] and Segments[0].Destination in ['SKG','KRR'] or Segments[0].Origin in ['NJC','PUJ'] and Segments[0].Destination in ['NJC','PUJ'] or Segments[0].Origin in ['MSQ','ZTH'] and Segments[0].Destination in ['MSQ','ZTH'] or Segments[0].Origin in ['SKG','VOG'] and Segments[0].Destination in ['SKG','VOG'] or Segments[0].Origin in ['KJA','CUN'] and Segments[0].Destination in ['KJA','CUN'] or Segments[0].Origin in ['DXB','GOJ'] and Segments[0].Destination in ['DXB','GOJ'] or Segments[0].Origin in ['SGN','BAX'] and Segments[0].Destination in ['SGN','BAX'] or Segments[0].Origin in ['KUF','AYT'] and Segments[0].Destination in ['KUF','AYT'] or Segments[0].Origin in ['ETH','KRR'] and Segments[0].Destination in ['ETH','KRR'] or Segments[0].Origin in ['IKT','NHA'] and Segments[0].Destination in ['IKT','NHA'] or Segments[0].Origin in ['ROV','HRG'] and Segments[0].Destination in ['ROV','HRG'] or Segments[0].Origin in ['PUJ','IKT'] and Segments[0].Destination in ['PUJ','IKT'] or Segments[0].Origin in ['TIV','MOW'] and Segments[0].Destination in ['TIV','MOW'] or Segments[0].Origin in ['PUJ','MOW'] and Segments[0].Destination in ['PUJ','MOW'] or Segments[0].Origin in ['CEK','VRA'] and Segments[0].Destination in ['CEK','VRA'] or Segments[0].Origin in ['EGO','PUJ'] and Segments[0].Destination in ['EGO','PUJ'] or Segments[0].Origin in ['TDX','IKT'] and Segments[0].Destination in ['TDX','IKT'] or Segments[0].Origin in ['SKG','KGD'] and Segments[0].Destination in ['SKG','KGD'] or Segments[0].Origin in ['SGN','UFA'] and Segments[0].Destination in ['SGN','UFA'] or Segments[0].Origin in ['MOW','BOJ'] and Segments[0].Destination in ['MOW','BOJ'] or Segments[0].Origin in ['NHA','KRR'] and Segments[0].Destination in ['NHA','KRR'] or Segments[0].Origin in ['HKT','KHV'] and Segments[0].Destination in ['HKT','KHV'] or Segments[0].Origin in ['RIX','SKG'] and Segments[0].Destination in ['RIX','SKG'] or Segments[0].Origin in ['SIP','KRR'] and Segments[0].Destination in ['SIP','KRR'] or Segments[0].Origin in ['AAQ','VRA'] and Segments[0].Destination in ['AAQ','VRA'] or Segments[0].Origin in ['VOZ','HRG'] and Segments[0].Destination in ['VOZ','HRG'] or Segments[0].Origin in ['CFU','LED'] and Segments[0].Destination in ['CFU','LED'] or Segments[0].Origin in ['KBV','BQS'] and Segments[0].Destination in ['KBV','BQS'] or Segments[0].Origin in ['BKK','NBC'] and Segments[0].Destination in ['BKK','NBC'] or Segments[0].Origin in ['SSH','GOJ'] and Segments[0].Destination in ['SSH','GOJ'] or Segments[0].Origin in ['LED','OVB'] and Segments[0].Destination in ['LED','OVB'] or Segments[0].Origin in ['NHA','UUD'] and Segments[0].Destination in ['NHA','UUD'] or Segments[0].Origin in ['CUN','UFA'] and Segments[0].Destination in ['CUN','UFA'] or Segments[0].Origin in ['MMK','SSH'] and Segments[0].Destination in ['MMK','SSH'] or Segments[0].Origin in ['MOW','PKC'] and Segments[0].Destination in ['MOW','PKC'] or Segments[0].Origin in ['SKG','ODS'] and Segments[0].Destination in ['SKG','ODS'] or Segments[0].Origin in ['UFA','SKG'] and Segments[0].Destination in ['UFA','SKG'] or Segments[0].Origin in ['UFA','AER'] and Segments[0].Destination in ['UFA','AER'] or Segments[0].Origin in ['VRA','NOZ'] and Segments[0].Destination in ['VRA','NOZ'] or Segments[0].Origin in ['NHA','MOW'] and Segments[0].Destination in ['NHA','MOW'] or Segments[0].Origin in ['HKT','NOZ'] and Segments[0].Destination in ['HKT','NOZ'] or Segments[0].Origin in ['MCX','VRA'] and Segments[0].Destination in ['MCX','VRA'] or Segments[0].Origin in ['SIP','LED'] and Segments[0].Destination in ['SIP','LED'] or Segments[0].Origin in ['MOW','BGY'] and Segments[0].Destination in ['MOW','BGY'] or Segments[0].Origin in ['HKT','EGO'] and Segments[0].Destination in ['HKT','EGO'] or Segments[0].Origin in ['KZN','AER'] and Segments[0].Destination in ['KZN','AER'] or Segments[0].Origin in ['NHA','OVB'] and Segments[0].Destination in ['NHA','OVB'] or Segments[0].Origin in ['VRA','VOZ'] and Segments[0].Destination in ['VRA','VOZ'] or Segments[0].Origin in ['OVB','LED'] and Segments[0].Destination in ['OVB','LED'] or Segments[0].Origin in ['NBC','CUN'] and Segments[0].Destination in ['NBC','CUN'] or Segments[0].Origin in ['VRA','KGD'] and Segments[0].Destination in ['VRA','KGD'] or Segments[0].Origin in ['CUN','CEK'] and Segments[0].Destination in ['CUN','CEK'] or Segments[0].Origin in ['VOZ','CUN'] and Segments[0].Destination in ['VOZ','CUN'] or Segments[0].Origin in ['DYR','MOW'] and Segments[0].Destination in ['DYR','MOW'] or Segments[0].Origin in ['MOW','SOF'] and Segments[0].Destination in ['MOW','SOF'] or Segments[0].Origin in ['LED','PRG'] and Segments[0].Destination in ['LED','PRG'] or Segments[0].Origin in ['PKC','NHA'] and Segments[0].Destination in ['PKC','NHA'] or Segments[0].Origin in ['BKK','TJM'] and Segments[0].Destination in ['BKK','TJM'] or Segments[0].Origin in ['NHA','OMS'] and Segments[0].Destination in ['NHA','OMS'] or Segments[0].Origin in ['DXB','BAX'] and Segments[0].Destination in ['DXB','BAX'] or Segments[0].Origin in ['OVB','HRG'] and Segments[0].Destination in ['OVB','HRG'] or Segments[0].Origin in ['AYT','KUF'] and Segments[0].Destination in ['AYT','KUF'] or Segments[0].Origin in ['HKT','CEK'] and Segments[0].Destination in ['HKT','CEK'] or Segments[0].Origin in ['GRV','MOW'] and Segments[0].Destination in ['GRV','MOW'] or Segments[0].Origin in ['IEV','ATH'] and Segments[0].Destination in ['IEV','ATH'] or Segments[0].Origin in ['OGZ','NHA'] and Segments[0].Destination in ['OGZ','NHA'] or Segments[0].Origin in ['ROV','SSH'] and Segments[0].Destination in ['ROV','SSH'] or Segments[0].Origin in ['SKG','UFA'] and Segments[0].Destination in ['SKG','UFA'] or Segments[0].Origin in ['CUN','BAX'] and Segments[0].Destination in ['CUN','BAX'] or Segments[0].Origin in ['SZG','MOW'] and Segments[0].Destination in ['SZG','MOW'] or Segments[0].Origin in ['HKT','KGD'] and Segments[0].Destination in ['HKT','KGD'] or Segments[0].Origin in ['ROV','SKG'] and Segments[0].Destination in ['ROV','SKG'] or Segments[0].Origin in ['USM','SVX'] and Segments[0].Destination in ['USM','SVX'] or Segments[0].Origin in ['KBV','BAX'] and Segments[0].Destination in ['KBV','BAX'] or Segments[0].Origin in ['BQS','MOW'] and Segments[0].Destination in ['BQS','MOW'] or Segments[0].Origin in ['SSH','KEJ'] and Segments[0].Destination in ['SSH','KEJ'] or Segments[0].Origin in ['SIP','UFA'] and Segments[0].Destination in ['SIP','UFA'] or Segments[0].Origin in ['CUN','YKS'] and Segments[0].Destination in ['CUN','YKS'] or Segments[0].Origin in ['GOJ','NHA'] and Segments[0].Destination in ['GOJ','NHA'] or Segments[0].Origin in ['MOW','PUJ'] and Segments[0].Destination in ['MOW','PUJ'] or Segments[0].Origin in ['NHA','LED'] and Segments[0].Destination in ['NHA','LED'] or Segments[0].Origin in ['HKT','VOZ'] and Segments[0].Destination in ['HKT','VOZ'] or Segments[0].Origin in ['OMS','VRA'] and Segments[0].Destination in ['OMS','VRA'] or Segments[0].Origin in ['OVB','BQS'] and Segments[0].Destination in ['OVB','BQS'] or Segments[0].Origin in ['BKK','GOJ'] and Segments[0].Destination in ['BKK','GOJ'] or Segments[0].Origin in ['HKT','ASF'] and Segments[0].Destination in ['HKT','ASF'] or Segments[0].Origin in ['LED','PUJ'] and Segments[0].Destination in ['LED','PUJ'] or Segments[0].Origin in ['CUN','KUF'] and Segments[0].Destination in ['CUN','KUF'] or Segments[0].Origin in ['MOW','LCA'] and Segments[0].Destination in ['MOW','LCA'] or Segments[0].Origin in ['CUN','KEJ'] and Segments[0].Destination in ['CUN','KEJ'] or Segments[0].Origin in ['LWO','SKG'] and Segments[0].Destination in ['LWO','SKG'] or Segments[0].Origin in ['HRG','SVX'] and Segments[0].Destination in ['HRG','SVX'] or Segments[0].Origin in ['TCI','MOW'] and Segments[0].Destination in ['TCI','MOW'] or Segments[0].Origin in ['SIP','AER'] and Segments[0].Destination in ['SIP','AER'] or Segments[0].Origin in ['SGN','TJM'] and Segments[0].Destination in ['SGN','TJM'] or Segments[0].Origin in ['PUJ','VOG'] and Segments[0].Destination in ['PUJ','VOG'] or Segments[0].Origin in ['UFA','SSH'] and Segments[0].Destination in ['UFA','SSH'] or Segments[0].Origin in ['MIL','MOW'] and Segments[0].Destination in ['MIL','MOW'] or Segments[0].Origin in ['AER','PUJ'] and Segments[0].Destination in ['AER','PUJ'] or Segments[0].Origin in ['NHA','HTA'] and Segments[0].Destination in ['NHA','HTA'] or Segments[0].Origin in ['BQS','OVB'] and Segments[0].Destination in ['BQS','OVB'] or Segments[0].Origin in ['USM','MOW'] and Segments[0].Destination in ['USM','MOW'] or Segments[0].Origin in ['KBV','IKT'] and Segments[0].Destination in ['KBV','IKT'] or Segments[0].Origin in ['HKT','UFA'] and Segments[0].Destination in ['HKT','UFA'] or Segments[0].Origin in ['MOW','KHV'] and Segments[0].Destination in ['MOW','KHV'] or Segments[0].Origin in ['UTP','EGO'] and Segments[0].Destination in ['UTP','EGO'] or Segments[0].Origin in ['DXB','HTA'] and Segments[0].Destination in ['DXB','HTA'] or Segments[0].Origin in ['SGN','OMS'] and Segments[0].Destination in ['SGN','OMS'] or Segments[0].Origin in ['MOW','AER'] and Segments[0].Destination in ['MOW','AER'] or Segments[0].Origin in ['HTA','PUJ'] and Segments[0].Destination in ['HTA','PUJ'] or Segments[0].Origin in ['KJA','NHA'] and Segments[0].Destination in ['KJA','NHA'] or Segments[0].Origin in ['HKT','OMS'] and Segments[0].Destination in ['HKT','OMS'] or Segments[0].Origin in ['OGZ','PUJ'] and Segments[0].Destination in ['OGZ','PUJ'] or Segments[0].Origin in ['PUJ','UFA'] and Segments[0].Destination in ['PUJ','UFA'] or Segments[0].Origin in ['DXB','KUF'] and Segments[0].Destination in ['DXB','KUF'] or Segments[0].Origin in ['BKK','MCX'] and Segments[0].Destination in ['BKK','MCX'] or Segments[0].Origin in ['NHA','PKC'] and Segments[0].Destination in ['NHA','PKC'] or Segments[0].Origin in ['CUN','KJA'] and Segments[0].Destination in ['CUN','KJA'] or Segments[0].Origin in ['KRR','PUJ'] and Segments[0].Destination in ['KRR','PUJ'] or Segments[0].Origin in ['HKT','IKT'] and Segments[0].Destination in ['HKT','IKT'] or Segments[0].Origin in ['DXB','ROV'] and Segments[0].Destination in ['DXB','ROV'] or Segments[0].Origin in ['DXB','TJM'] and Segments[0].Destination in ['DXB','TJM'] or Segments[0].Origin in ['NHA','KJA'] and Segments[0].Destination in ['NHA','KJA'] or Segments[0].Origin in ['USM','OMS'] and Segments[0].Destination in ['USM','OMS'] or Segments[0].Origin in ['KHV','NHA'] and Segments[0].Destination in ['KHV','NHA'] or Segments[0].Origin in ['HRG','KGD'] and Segments[0].Destination in ['HRG','KGD'] or Segments[0].Origin in ['VOG','SSH'] and Segments[0].Destination in ['VOG','SSH'] or Segments[0].Origin in ['MCX','PUJ'] and Segments[0].Destination in ['MCX','PUJ'] or Segments[0].Origin in ['MOW','TIV'] and Segments[0].Destination in ['MOW','TIV'] or Segments[0].Origin in ['DXB','KRR'] and Segments[0].Destination in ['DXB','KRR'] or Segments[0].Origin in ['DNK','SKG'] and Segments[0].Destination in ['DNK','SKG'] or Segments[0].Origin in ['HKT','KZN'] and Segments[0].Destination in ['HKT','KZN'] or Segments[0].Origin in ['USM','LED'] and Segments[0].Destination in ['USM','LED'] or Segments[0].Origin in ['HKT','MRV'] and Segments[0].Destination in ['HKT','MRV'] or Segments[0].Origin in ['HKT','TOF'] and Segments[0].Destination in ['HKT','TOF'] or Segments[0].Origin in ['MOW','UFA'] and Segments[0].Destination in ['MOW','UFA'] or Segments[0].Origin in ['DXB','KEJ'] and Segments[0].Destination in ['DXB','KEJ'] or Segments[0].Origin in ['YKS','CUN'] and Segments[0].Destination in ['YKS','CUN'] or Segments[0].Origin in ['KEJ','HRG'] and Segments[0].Destination in ['KEJ','HRG'] or Segments[0].Origin in ['MCX','NHA'] and Segments[0].Destination in ['MCX','NHA'] or Segments[0].Origin in ['NHA','SCW'] and Segments[0].Destination in ['NHA','SCW'] or Segments[0].Origin in ['DXB','MRV'] and Segments[0].Destination in ['DXB','MRV'] or Segments[0].Origin in ['BKK','OGZ'] and Segments[0].Destination in ['BKK','OGZ'] or Segments[0].Origin in ['UTP','PEE'] and Segments[0].Destination in ['UTP','PEE'] or Segments[0].Origin in ['USM','ROV'] and Segments[0].Destination in ['USM','ROV'] or Segments[0].Origin in ['VRA','YKS'] and Segments[0].Destination in ['VRA','YKS'] or Segments[0].Origin in ['SHE','MOW'] and Segments[0].Destination in ['SHE','MOW'] or Segments[0].Origin in ['MOW','TSN'] and Segments[0].Destination in ['MOW','TSN'] or Segments[0].Origin in ['TOF','OVB'] and Segments[0].Destination in ['TOF','OVB'] or Segments[0].Origin in ['NHA','KEJ'] and Segments[0].Destination in ['NHA','KEJ'] or Segments[0].Origin in ['KGD','CUN'] and Segments[0].Destination in ['KGD','CUN'] or Segments[0].Origin in ['UTP','KUF'] and Segments[0].Destination in ['UTP','KUF'] or Segments[0].Origin in ['SIP','KZN'] and Segments[0].Destination in ['SIP','KZN'] or Segments[0].Origin in ['CUN','SCW'] and Segments[0].Destination in ['CUN','SCW'] or Segments[0].Origin in ['SHJ','REN'] and Segments[0].Destination in ['SHJ','REN'] or Segments[0].Origin in ['SGN','KRR'] and Segments[0].Destination in ['SGN','KRR'] or Segments[0].Origin in ['KEJ','NHA'] and Segments[0].Destination in ['KEJ','NHA'] or Segments[0].Origin in ['CFU','IEV'] and Segments[0].Destination in ['CFU','IEV'] or Segments[0].Origin in ['MOW','CUN'] and Segments[0].Destination in ['MOW','CUN'] or Segments[0].Origin in ['LCA','MOW'] and Segments[0].Destination in ['LCA','MOW'] or Segments[0].Origin in ['SSH','ROV'] and Segments[0].Destination in ['SSH','ROV'] or Segments[0].Origin in ['BUH','MOW'] and Segments[0].Destination in ['BUH','MOW'] or Segments[0].Origin in ['SGN','BQS'] and Segments[0].Destination in ['SGN','BQS'] or Segments[0].Origin in ['KUF','VRA'] and Segments[0].Destination in ['KUF','VRA'] or Segments[0].Origin in ['NHA','KHV'] and Segments[0].Destination in ['NHA','KHV'] or Segments[0].Origin in ['DXB','TOF'] and Segments[0].Destination in ['DXB','TOF'] or Segments[0].Origin in ['HKT','KUF'] and Segments[0].Destination in ['HKT','KUF'] or Segments[0].Origin in ['EGO','NHA'] and Segments[0].Destination in ['EGO','NHA'] or Segments[0].Origin in ['MOW','BCN'] and Segments[0].Destination in ['MOW','BCN'] or Segments[0].Origin in ['SCW','HRG'] and Segments[0].Destination in ['SCW','HRG'] or Segments[0].Origin in ['BAX','CUN'] and Segments[0].Destination in ['BAX','CUN'] or Segments[0].Origin in ['AYT','PEE'] and Segments[0].Destination in ['AYT','PEE'] or Segments[0].Origin in ['BKK','OMS'] and Segments[0].Destination in ['BKK','OMS'] or Segments[0].Origin in ['LCA','KRR'] and Segments[0].Destination in ['LCA','KRR'] or Segments[0].Origin in ['BKK','CEK'] and Segments[0].Destination in ['BKK','CEK'] or Segments[0].Origin in ['MOW','VRA'] and Segments[0].Destination in ['MOW','VRA'] or Segments[0].Origin in ['LED','ZTH'] and Segments[0].Destination in ['LED','ZTH'] or Segments[0].Origin in ['KEJ','VRA'] and Segments[0].Destination in ['KEJ','VRA'] or Segments[0].Origin in ['MOW','DYR'] and Segments[0].Destination in ['MOW','DYR'] or Segments[0].Origin in ['HKT','YKS'] and Segments[0].Destination in ['HKT','YKS'] or Segments[0].Origin in ['MOW','MIR'] and Segments[0].Destination in ['MOW','MIR'] or Segments[0].Origin in ['TRN','MOW'] and Segments[0].Destination in ['TRN','MOW'] or Segments[0].Origin in ['RVN','MOW'] and Segments[0].Destination in ['RVN','MOW'] or Segments[0].Origin in ['CEK','SSH'] and Segments[0].Destination in ['CEK','SSH'] or Segments[0].Origin in ['ETH','UFA'] and Segments[0].Destination in ['ETH','UFA'] or Segments[0].Origin in ['VRA','UFA'] and Segments[0].Destination in ['VRA','UFA'] or Segments[0].Origin in ['MOW','HER'] and Segments[0].Destination in ['MOW','HER'] or Segments[0].Origin in ['DXB','OMS'] and Segments[0].Destination in ['DXB','OMS'] or Segments[0].Origin in ['VRA','ROV'] and Segments[0].Destination in ['VRA','ROV'] or Segments[0].Origin in ['MRV','PUJ'] and Segments[0].Destination in ['MRV','PUJ'] or Segments[0].Origin in ['NHA','EGO'] and Segments[0].Destination in ['NHA','EGO'] or Segments[0].Origin in ['VRA','TOF'] and Segments[0].Destination in ['VRA','TOF'] or Segments[0].Origin in ['BOJ','LED'] and Segments[0].Destination in ['BOJ','LED'] or Segments[0].Origin in ['MOW','BHK'] and Segments[0].Destination in ['MOW','BHK'] or Segments[0].Origin in ['HKT','VVO'] and Segments[0].Destination in ['HKT','VVO'] or Segments[0].Origin in ['TOF','MOW'] and Segments[0].Destination in ['TOF','MOW'] or Segments[0].Origin in ['USM','KZN'] and Segments[0].Destination in ['USM','KZN'] or Segments[0].Origin in ['PUJ','KUF'] and Segments[0].Destination in ['PUJ','KUF'] or Segments[0].Origin in ['VOZ','PUJ'] and Segments[0].Destination in ['VOZ','PUJ'] or Segments[0].Origin in ['OVB','KRR'] and Segments[0].Destination in ['OVB','KRR'] or Segments[0].Origin in ['MOW','IKT'] and Segments[0].Destination in ['MOW','IKT'] or Segments[0].Origin in ['PEE','VRA'] and Segments[0].Destination in ['PEE','VRA'] or Segments[0].Origin in ['CFU','ROV'] and Segments[0].Destination in ['CFU','ROV'] or Segments[0].Origin in ['POP','MOW'] and Segments[0].Destination in ['POP','MOW'] or Segments[0].Origin in ['PUJ','SCW'] and Segments[0].Destination in ['PUJ','SCW'] or Segments[0].Origin in ['BAX','MOW'] and Segments[0].Destination in ['BAX','MOW'] or Segments[0].Origin in ['PUJ','SVX'] and Segments[0].Destination in ['PUJ','SVX'] or Segments[0].Origin in ['CUN','NJC'] and Segments[0].Destination in ['CUN','NJC'] or Segments[0].Origin in ['UTP','LED'] and Segments[0].Destination in ['UTP','LED'] or Segments[0].Origin in ['NHA','TJM'] and Segments[0].Destination in ['NHA','TJM'] or Segments[0].Origin in ['SGN','GOJ'] and Segments[0].Destination in ['SGN','GOJ'] or Segments[0].Origin in ['SSH','NBC'] and Segments[0].Destination in ['SSH','NBC'] or Segments[0].Origin in ['KJA','MOW'] and Segments[0].Destination in ['KJA','MOW'] or Segments[0].Origin in ['MOW','GPA'] and Segments[0].Destination in ['MOW','GPA'] or Segments[0].Origin in ['ATH','IEV'] and Segments[0].Destination in ['ATH','IEV'] or Segments[0].Origin in ['USM','VVO'] and Segments[0].Destination in ['USM','VVO'] or Segments[0].Origin in ['MOW','RMI'] and Segments[0].Destination in ['MOW','RMI'] or Segments[0].Origin in ['CEE','PUJ'] and Segments[0].Destination in ['CEE','PUJ'] or Segments[0].Origin in ['KRR','SKG'] and Segments[0].Destination in ['KRR','SKG'] or Segments[0].Origin in ['CUN','HTA'] and Segments[0].Destination in ['CUN','HTA'] or Segments[0].Origin in ['MRV','VRA'] and Segments[0].Destination in ['MRV','VRA'] or Segments[0].Origin in ['VRA','TJM'] and Segments[0].Destination in ['VRA','TJM'] or Segments[0].Origin in ['SKG','RIX'] and Segments[0].Destination in ['SKG','RIX'] or Segments[0].Origin in ['PRG','SVX'] and Segments[0].Destination in ['PRG','SVX'] or Segments[0].Origin in ['ABA','VRA'] and Segments[0].Destination in ['ABA','VRA'] or Segments[0].Origin in ['SGN','IKT'] and Segments[0].Destination in ['SGN','IKT'] or Segments[0].Origin in ['VOG','HRG'] and Segments[0].Destination in ['VOG','HRG'] or Segments[0].Origin in ['SVX','HER'] and Segments[0].Destination in ['SVX','HER'] or Segments[0].Origin in ['SHJ','VOG'] and Segments[0].Destination in ['SHJ','VOG'] or Segments[0].Origin in ['VRA','OGZ'] and Segments[0].Destination in ['VRA','OGZ'] or Segments[0].Origin in ['MOW','ZTH'] and Segments[0].Destination in ['MOW','ZTH'] or Segments[0].Origin in ['KJA','PUJ'] and Segments[0].Destination in ['KJA','PUJ'] or Segments[0].Origin in ['SSH','KJA'] and Segments[0].Destination in ['SSH','KJA'] or Segments[0].Origin in ['PUJ','NBC'] and Segments[0].Destination in ['PUJ','NBC'] or Segments[0].Origin in ['BKK','BAX'] and Segments[0].Destination in ['BKK','BAX'] or Segments[0].Origin in ['GOJ','HKT'] and Segments[0].Destination in ['GOJ','HKT'] or Segments[0].Origin in ['LED','AYT'] and Segments[0].Destination in ['LED','AYT'] or Segments[0].Origin in ['CEK','USM'] and Segments[0].Destination in ['CEK','USM'] or Segments[0].Origin in ['LED','SHJ'] and Segments[0].Destination in ['LED','SHJ'] or Segments[0].Origin in ['NOZ','BKK'] and Segments[0].Destination in ['NOZ','BKK'] or Segments[0].Origin in ['NOZ','PUJ'] and Segments[0].Destination in ['NOZ','PUJ'] or Segments[0].Origin in ['TJM','TDX'] and Segments[0].Destination in ['TJM','TDX'] or Segments[0].Origin in ['YKS','BKK'] and Segments[0].Destination in ['YKS','BKK'] or Segments[0].Origin in ['MOW','KUF'] and Segments[0].Destination in ['MOW','KUF'] or Segments[0].Origin in ['KJA','SGN'] and Segments[0].Destination in ['KJA','SGN'] or Segments[0].Origin in ['CEK','UTP'] and Segments[0].Destination in ['CEK','UTP'] or Segments[0].Origin in ['UFA','USM'] and Segments[0].Destination in ['UFA','USM'] or Segments[0].Origin in ['KZN','TDX'] and Segments[0].Destination in ['KZN','TDX'] or Segments[0].Origin in ['PEE','DXB'] and Segments[0].Destination in ['PEE','DXB'] or Segments[0].Origin in ['NJC','HKT'] and Segments[0].Destination in ['NJC','HKT'] or Segments[0].Origin in ['UFA','BKK'] and Segments[0].Destination in ['UFA','BKK'] or Segments[0].Origin in ['VOG','BKK'] and Segments[0].Destination in ['VOG','BKK'] or Segments[0].Origin in ['CEK','SGN'] and Segments[0].Destination in ['CEK','SGN'] or Segments[0].Origin in ['KZN','UTP'] and Segments[0].Destination in ['KZN','UTP'] or Segments[0].Origin in ['KJA','HKT'] and Segments[0].Destination in ['KJA','HKT'] or Segments[0].Origin in ['HTA','BKK'] and Segments[0].Destination in ['HTA','BKK'] or Segments[0].Origin in ['PEE','TDX'] and Segments[0].Destination in ['PEE','TDX'] or Segments[0].Origin in ['OVB','SGN'] and Segments[0].Destination in ['OVB','SGN'] or Segments[0].Origin in ['AER','HKT'] and Segments[0].Destination in ['AER','HKT'] or Segments[0].Origin in ['CUN','CEE'] and Segments[0].Destination in ['CUN','CEE'] or Segments[0].Origin in ['OGZ','MOW'] and Segments[0].Destination in ['OGZ','MOW'] or Segments[0].Origin in ['SVX','AQJ'] and Segments[0].Destination in ['SVX','AQJ'] or Segments[0].Origin in ['SVX','SHJ'] and Segments[0].Destination in ['SVX','SHJ'] or Segments[0].Origin in ['NHA','BTK'] and Segments[0].Destination in ['NHA','BTK'] or Segments[0].Origin in ['KZN','AQJ'] and Segments[0].Destination in ['KZN','AQJ'] or Segments[0].Origin in ['VOZ','DXB'] and Segments[0].Destination in ['VOZ','DXB'] or Segments[0].Origin in ['OGZ','HKT'] and Segments[0].Destination in ['OGZ','HKT'] or Segments[0].Origin in ['MOW','KLV'] and Segments[0].Destination in ['MOW','KLV'] or Segments[0].Origin in ['MOW','AQJ'] and Segments[0].Destination in ['MOW','AQJ'] or Segments[0].Origin in ['AER','SGN'] and Segments[0].Destination in ['AER','SGN'] or Segments[0].Origin in ['OVB','BKK'] and Segments[0].Destination in ['OVB','BKK'] or Segments[0].Origin in ['UFA','AYT'] and Segments[0].Destination in ['UFA','AYT'] or Segments[0].Origin in ['NOZ','SGN'] and Segments[0].Destination in ['NOZ','SGN'] or Segments[0].Origin in ['NBC','SGN'] and Segments[0].Destination in ['NBC','SGN'] or Segments[0].Origin in ['BQS','TDX'] and Segments[0].Destination in ['BQS','TDX'] or Segments[0].Origin in ['SGC','NHA'] and Segments[0].Destination in ['SGC','NHA'] or Segments[0].Origin in ['UFA','NHA'] and Segments[0].Destination in ['UFA','NHA'] or Segments[0].Origin in ['ROV','TDX'] and Segments[0].Destination in ['ROV','TDX'] or Segments[0].Origin in ['KZN','BKK'] and Segments[0].Destination in ['KZN','BKK'] or Segments[0].Origin in ['KJA','DXB'] and Segments[0].Destination in ['KJA','DXB'] or Segments[0].Origin in ['CEK','DXB'] and Segments[0].Destination in ['CEK','DXB'] or Segments[0].Origin in ['OVB','KBV'] and Segments[0].Destination in ['OVB','KBV'] or Segments[0].Origin in ['PEE','KBV'] and Segments[0].Destination in ['PEE','KBV'] or Segments[0].Origin in ['SVX','LED'] and Segments[0].Destination in ['SVX','LED'] or Segments[0].Origin in ['CUN','AAQ'] and Segments[0].Destination in ['CUN','AAQ'] or Segments[0].Origin in ['KEJ','BKK'] and Segments[0].Destination in ['KEJ','BKK'] or Segments[0].Origin in ['BQS','BKK'] and Segments[0].Destination in ['BQS','BKK'] or Segments[0].Origin in ['IKT','DXB'] and Segments[0].Destination in ['IKT','DXB'] or Segments[0].Origin in ['KUF','BKK'] and Segments[0].Destination in ['KUF','BKK'] or Segments[0].Origin in ['VVO','BKK'] and Segments[0].Destination in ['VVO','BKK'] or Segments[0].Origin in ['OVB','HKT'] and Segments[0].Destination in ['OVB','HKT'] or Segments[0].Origin in ['NHA','RTW'] and Segments[0].Destination in ['NHA','RTW'] or Segments[0].Origin in ['VOG','SGN'] and Segments[0].Destination in ['VOG','SGN'] or Segments[0].Origin in ['VVO','KBV'] and Segments[0].Destination in ['VVO','KBV'] or Segments[0].Origin in ['TOF','PUJ'] and Segments[0].Destination in ['TOF','PUJ'] or Segments[0].Origin in ['KEJ','HKT'] and Segments[0].Destination in ['KEJ','HKT'] or Segments[0].Origin in ['TJM','HKT'] and Segments[0].Destination in ['TJM','HKT'] or Segments[0].Origin in ['ROV','POP'] and Segments[0].Destination in ['ROV','POP'] or Segments[0].Origin in ['REN','ETH'] and Segments[0].Destination in ['REN','ETH'] or Segments[0].Origin in ['PEE','USM'] and Segments[0].Destination in ['PEE','USM'] or Segments[0].Origin in ['KEJ','SGN'] and Segments[0].Destination in ['KEJ','SGN'] or Segments[0].Origin in ['AER','DXB'] and Segments[0].Destination in ['AER','DXB'] or Segments[0].Origin in ['VOG','MOW'] and Segments[0].Destination in ['VOG','MOW'] or Segments[0].Origin in ['YKS','SGN'] and Segments[0].Destination in ['YKS','SGN'] or Segments[0].Origin in ['UFA','TDX'] and Segments[0].Destination in ['UFA','TDX'] or Segments[0].Origin in ['CUN','ABA'] and Segments[0].Destination in ['CUN','ABA'] or Segments[0].Origin in ['HRG','TJM'] and Segments[0].Destination in ['HRG','TJM'] or Segments[0].Origin in ['HTA','HKT'] and Segments[0].Destination in ['HTA','HKT'] or Segments[0].Origin in ['NBC','HKT'] and Segments[0].Destination in ['NBC','HKT'] or Segments[0].Origin in ['TOF','SGN'] and Segments[0].Destination in ['TOF','SGN'] or Segments[0].Origin in ['MCX','HKT'] and Segments[0].Destination in ['MCX','HKT'] or Segments[0].Origin in ['VRA','CEE'] and Segments[0].Destination in ['VRA','CEE'] or Segments[0].Origin in ['CUN','RTW'] and Segments[0].Destination in ['CUN','RTW'] or Segments[0].Origin in ['VOZ','SGN'] and Segments[0].Destination in ['VOZ','SGN'] or Segments[0].Origin in ['BQS','USM'] and Segments[0].Destination in ['BQS','USM'] or Segments[0].Origin in ['SGC','USM'] and Segments[0].Destination in ['SGC','USM'] or Segments[0].Origin in ['KZN','DXB'] and Segments[0].Destination in ['KZN','DXB'] or Segments[0].Origin in ['KEJ','TDX'] and Segments[0].Destination in ['KEJ','TDX'] or Segments[0].Origin in ['UFA','DXB'] and Segments[0].Destination in ['UFA','DXB'] or Segments[0].Origin in ['LED','HKT'] and Segments[0].Destination in ['LED','HKT'] or Segments[0].Origin in ['NJC','SGN'] and Segments[0].Destination in ['NJC','SGN'] or Segments[0].Origin in ['KUF','SHJ'] and Segments[0].Destination in ['KUF','SHJ'] or Segments[0].Origin in ['LED','AQJ'] and Segments[0].Destination in ['LED','AQJ'] or Segments[0].Origin in ['KJA','SIP'] and Segments[0].Destination in ['KJA','SIP'] or Segments[0].Origin in ['SGC','BKK'] and Segments[0].Destination in ['SGC','BKK'] or Segments[0].Origin in ['KJA','BKK'] and Segments[0].Destination in ['KJA','BKK'] or Segments[0].Origin in ['VOG','DXB'] and Segments[0].Destination in ['VOG','DXB'] or Segments[0].Origin in ['KEJ','USM'] and Segments[0].Destination in ['KEJ','USM'] or Segments[0].Origin in ['VVO','SGN'] and Segments[0].Destination in ['VVO','SGN'] or Segments[0].Origin in ['MOW','SIP'] and Segments[0].Destination in ['MOW','SIP'] or Segments[0].Origin in ['MOW','ROV'] and Segments[0].Destination in ['MOW','ROV'] or Segments[0].Origin in ['TJM','KBV'] and Segments[0].Destination in ['TJM','KBV'] or Segments[0].Origin in ['ROV','HKT'] and Segments[0].Destination in ['ROV','HKT'] or Segments[0].Origin in ['YKS','DXB'] and Segments[0].Destination in ['YKS','DXB'] or Segments[0].Origin in ['MOW','GDX'] and Segments[0].Destination in ['MOW','GDX'] or Segments[0].Origin in ['VOG','HKT'] and Segments[0].Destination in ['VOG','HKT'] or Segments[0].Origin in ['EGO','BKK'] and Segments[0].Destination in ['EGO','BKK'] or Segments[0].Origin in ['KGD','MOW'] and Segments[0].Destination in ['KGD','MOW'] or Segments[0].Origin in ['IKT','USM'] and Segments[0].Destination in ['IKT','USM'] or Segments[0].Origin in ['MOW','TDX'] and Segments[0].Destination in ['MOW','TDX'] or Segments[0].Origin in ['SVX','SGN'] and Segments[0].Destination in ['SVX','SGN'] or Segments[0].Origin in ['KRR','VRN'] and Segments[0].Destination in ['KRR','VRN'] or Segments[0].Origin in ['BAX','PUJ'] and Segments[0].Destination in ['BAX','PUJ'] or Segments[0].Origin in ['HRG','LED'] and Segments[0].Destination in ['HRG','LED'] or Segments[0].Origin in ['ASF','BKK'] and Segments[0].Destination in ['ASF','BKK'] or Segments[0].Origin in ['ROV','SHJ'] and Segments[0].Destination in ['ROV','SHJ'] or Segments[0].Origin in ['KRR','HKT'] and Segments[0].Destination in ['KRR','HKT'] or Segments[0].Origin in ['MOW','AYT'] and Segments[0].Destination in ['MOW','AYT'] or Segments[0].Origin in ['SVX','HKT'] and Segments[0].Destination in ['SVX','HKT'] or Segments[0].Origin in ['SVX','BKK'] and Segments[0].Destination in ['SVX','BKK'] or Segments[0].Origin in ['MOW','SGN'] and Segments[0].Destination in ['MOW','SGN'] or Segments[0].Origin in ['PEE','SSH'] and Segments[0].Destination in ['PEE','SSH'] or Segments[0].Origin in ['MOW','DXB'] and Segments[0].Destination in ['MOW','DXB'] or Segments[0].Origin in ['YKS','PUJ'] and Segments[0].Destination in ['YKS','PUJ'] or Segments[0].Origin in ['MOW','AUH'] and Segments[0].Destination in ['MOW','AUH'] or Segments[0].Origin in ['IKT','UTP'] and Segments[0].Destination in ['IKT','UTP'] or Segments[0].Origin in ['ROV','BKK'] and Segments[0].Destination in ['ROV','BKK'] or Segments[0].Origin in ['KGD','SGN'] and Segments[0].Destination in ['KGD','SGN'] or Segments[0].Origin in ['SCW','HKT'] and Segments[0].Destination in ['SCW','HKT'] or Segments[0].Origin in ['KGD','BKK'] and Segments[0].Destination in ['KGD','BKK'] or Segments[0].Origin in ['SGC','HKT'] and Segments[0].Destination in ['SGC','HKT'] or Segments[0].Origin in ['TSE','SKG'] and Segments[0].Destination in ['TSE','SKG'] or Segments[0].Origin in ['PKC','BKK'] and Segments[0].Destination in ['PKC','BKK'] or Segments[0].Origin in ['KEJ','KBV'] and Segments[0].Destination in ['KEJ','KBV'] or Segments[0].Origin in ['SCW','BKK'] and Segments[0].Destination in ['SCW','BKK'] or Segments[0].Origin in ['MOW','AMM'] and Segments[0].Destination in ['MOW','AMM'] or Segments[0].Origin in ['KZN','SGN'] and Segments[0].Destination in ['KZN','SGN'] or Segments[0].Origin in ['AER','VOG'] and Segments[0].Destination in ['AER','VOG'] or Segments[0].Origin in ['SVX','DXB'] and Segments[0].Destination in ['SVX','DXB'] or Segments[0].Origin in ['BQS','HKT'] and Segments[0].Destination in ['BQS','HKT'] or Segments[0].Origin in ['LED','DXB'] and Segments[0].Destination in ['LED','DXB'] or Segments[0].Origin in ['ROV','KBV'] and Segments[0].Destination in ['ROV','KBV'] or Segments[0].Origin in ['REN','BKK'] and Segments[0].Destination in ['REN','BKK'] or Segments[0].Origin in ['PEE','HKT'] and Segments[0].Destination in ['PEE','HKT'] or Segments[0].Origin in ['AER','BKK'] and Segments[0].Destination in ['AER','BKK'] or Segments[0].Origin in ['SCW','SGN'] and Segments[0].Destination in ['SCW','SGN'] or Segments[0].Origin in ['KUF','SIP'] and Segments[0].Destination in ['KUF','SIP'] or Segments[0].Origin in ['KRR','AQJ'] and Segments[0].Destination in ['KRR','AQJ'] or Segments[0].Origin in ['MOW','KBV'] and Segments[0].Destination in ['MOW','KBV'] or Segments[0].Origin in ['PEE','BKK'] and Segments[0].Destination in ['PEE','BKK'] or Segments[0].Origin in ['NBC','DXB'] and Segments[0].Destination in ['NBC','DXB'] or Segments[0].Origin in ['UUD','HKT'] and Segments[0].Destination in ['UUD','HKT'] or Segments[0].Origin in ['OVB','BTK'] and Segments[0].Destination in ['OVB','BTK'] or Segments[0].Origin in ['OVB','USM'] and Segments[0].Destination in ['OVB','USM'] or Segments[0].Origin in ['VRA','RTW'] and Segments[0].Destination in ['VRA','RTW'] or Segments[0].Origin in ['VOZ','SHJ'] and Segments[0].Destination in ['VOZ','SHJ'] or Segments[0].Origin in ['NOZ','DXB'] and Segments[0].Destination in ['NOZ','DXB'] or Segments[0].Origin in ['SGC','SGN'] and Segments[0].Destination in ['SGC','SGN'] or Segments[0].Origin in ['SVX','AYT'] and Segments[0].Destination in ['SVX','AYT'] or Segments[0].Origin in ['KZN','KBV'] and Segments[0].Destination in ['KZN','KBV'] or Segments[0].Origin in ['TJM','USM'] and Segments[0].Destination in ['TJM','USM'] or Segments[0].Origin in ['ROV','SGN'] and Segments[0].Destination in ['ROV','SGN'] or Segments[0].Origin in ['LED','AMM'] and Segments[0].Destination in ['LED','AMM'] or Segments[0].Origin in ['PUJ','RTW'] and Segments[0].Destination in ['PUJ','RTW'] or Segments[0].Origin in ['NJC','BKK'] and Segments[0].Destination in ['NJC','BKK'] or Segments[0].Origin in ['MOW','ROM'] and Segments[0].Destination in ['MOW','ROM'] or Segments[0].Origin in ['VOZ','BKK'] and Segments[0].Destination in ['VOZ','BKK'] or Segments[0].Origin in ['LED','KRR'] and Segments[0].Destination in ['LED','KRR'] or Segments[0].Origin in ['KUF','SGN'] and Segments[0].Destination in ['KUF','SGN'] or Segments[0].Origin in ['MRV','SGN'] and Segments[0].Destination in ['MRV','SGN'] or Segments[0].Origin in ['SSH','KGD'] and Segments[0].Destination in ['SSH','KGD'] or Segments[0].Origin in ['KRR','BKK'] and Segments[0].Destination in ['KRR','BKK'] or Segments[0].Origin in ['OVB','DXB'] and Segments[0].Destination in ['OVB','DXB'] or Segments[0].Origin in ['MRV','BKK'] and Segments[0].Destination in ['MRV','BKK'] or Segments[0].Origin in ['LED','BKK'] and Segments[0].Destination in ['LED','BKK'] or Segments[0].Origin in ['LED','SGN'] and Segments[0].Destination in ['LED','SGN'] or Segments[0].Origin in ['REN','HKT'] and Segments[0].Destination in ['REN','HKT'] or Segments[0].Origin in ['UUD','BKK'] and Segments[0].Destination in ['UUD','BKK'] or Segments[0].Origin in ['GOJ','PUJ'] and Segments[0].Destination in ['GOJ','PUJ'] or Segments[0].Origin in ['BAX','TDX'] and Segments[0].Destination in ['BAX','TDX'] or Segments[0].Origin in ['KJA','UTP'] and Segments[0].Destination in ['KJA','UTP'] or Segments[0].Origin in ['KHV','BKK'] and Segments[0].Destination in ['KHV','BKK'] or Segments[0].Origin in ['MOW','BER'] and Segments[0].Destination in ['MOW','BER'] or Segments[0].Origin in ['KHV','SGN'] and Segments[0].Destination in ['KHV','SGN'] or Segments[0].Origin in ['NJC','DXB'] and Segments[0].Destination in ['NJC','DXB'] or Segments[0].Origin in ['BAX','USM'] and Segments[0].Destination in ['BAX','USM'] or Segments[0].Origin in ['VRN','ROV'] and Segments[0].Destination in ['VRN','ROV'] or Segments[0].Origin in ['IKT','BKK'] and Segments[0].Destination in ['IKT','BKK'] or Segments[0].Origin in ['SGC','TDX'] and Segments[0].Destination in ['SGC','TDX'] or Segments[0].Origin in ['TOF','BKK'] and Segments[0].Destination in ['TOF','BKK'] or Segments[0].Origin in ['SVX','SIP'] and Segments[0].Destination in ['SVX','SIP'] or Segments[0].Origin in ['HRG','PEE'] and Segments[0].Destination in ['HRG','PEE'] or Segments[0].Origin in ['MOW','GVA'] and Segments[0].Destination in ['MOW','GVA'] or Segments[0].Origin in ['MOW','MUC'] and Segments[0].Destination in ['MOW','MUC'] or Segments[0].Origin in ['BAX','HKT'] and Segments[0].Destination in ['BAX','HKT'] or Segments[0].Origin in ['HTA','SGN'] and Segments[0].Destination in ['HTA','SGN'] or Segments[0].Origin in ['MOW','SHJ'] and Segments[0].Destination in ['MOW','SHJ'] or Segments[0].Origin in ['UFA','KBV'] and Segments[0].Destination in ['UFA','KBV'] or Segments[0].Origin in ['MOW','DJE'] and Segments[0].Destination in ['MOW','DJE'] or Segments[0].Origin in ['PEE','SGN'] and Segments[0].Destination in ['PEE','SGN'] or Segments[0].Origin in ['LED','CUN'] and Segments[0].Destination in ['LED','CUN'] or Segments[0].Origin in ['SVX','MOW'] and Segments[0].Destination in ['SVX','MOW'] or Segments[0].Origin in ['SGC','KBV'] and Segments[0].Destination in ['SGC','KBV'] or Segments[0].Origin in ['GOJ','DXB'] and Segments[0].Destination in ['GOJ','DXB'] or Segments[0].Origin in ['BAX','SGN'] and Segments[0].Destination in ['BAX','SGN'] or Segments[0].Origin in ['HRG','ROV'] and Segments[0].Destination in ['HRG','ROV'] or Segments[0].Origin in ['IKT','TDX'] and Segments[0].Destination in ['IKT','TDX'] or Segments[0].Origin in ['UFA','SGN'] and Segments[0].Destination in ['UFA','SGN'] or Segments[0].Origin in ['KHV','HKT'] and Segments[0].Destination in ['KHV','HKT'] or Segments[0].Origin in ['KRR','SIP'] and Segments[0].Destination in ['KRR','SIP'] or Segments[0].Origin in ['VRA','AAQ'] and Segments[0].Destination in ['VRA','AAQ'] or Segments[0].Origin in ['BQS','KBV'] and Segments[0].Destination in ['BQS','KBV'] or Segments[0].Origin in ['NBC','BKK'] and Segments[0].Destination in ['NBC','BKK'] or Segments[0].Origin in ['NOZ','HKT'] and Segments[0].Destination in ['NOZ','HKT'] or Segments[0].Origin in ['LED','SIP'] and Segments[0].Destination in ['LED','SIP'] or Segments[0].Origin in ['BGY','MOW'] and Segments[0].Destination in ['BGY','MOW'] or Segments[0].Origin in ['EGO','HKT'] and Segments[0].Destination in ['EGO','HKT'] or Segments[0].Origin in ['OVB','NHA'] and Segments[0].Destination in ['OVB','NHA'] or Segments[0].Origin in ['TJM','BKK'] and Segments[0].Destination in ['TJM','BKK'] or Segments[0].Origin in ['BAX','DXB'] and Segments[0].Destination in ['BAX','DXB'] or Segments[0].Origin in ['CEK','HKT'] and Segments[0].Destination in ['CEK','HKT'] or Segments[0].Origin in ['KGD','HKT'] and Segments[0].Destination in ['KGD','HKT'] or Segments[0].Origin in ['SVX','USM'] and Segments[0].Destination in ['SVX','USM'] or Segments[0].Origin in ['BAX','KBV'] and Segments[0].Destination in ['BAX','KBV'] or Segments[0].Origin in ['UFA','SIP'] and Segments[0].Destination in ['UFA','SIP'] or Segments[0].Origin in ['LED','NHA'] and Segments[0].Destination in ['LED','NHA'] or Segments[0].Origin in ['VOZ','HKT'] and Segments[0].Destination in ['VOZ','HKT'] or Segments[0].Origin in ['GOJ','BKK'] and Segments[0].Destination in ['GOJ','BKK'] or Segments[0].Origin in ['ASF','HKT'] and Segments[0].Destination in ['ASF','HKT'] or Segments[0].Origin in ['AER','SIP'] and Segments[0].Destination in ['AER','SIP'] or Segments[0].Origin in ['TJM','SGN'] and Segments[0].Destination in ['TJM','SGN'] or Segments[0].Origin in ['MOW','MIL'] and Segments[0].Destination in ['MOW','MIL'] or Segments[0].Origin in ['MOW','USM'] and Segments[0].Destination in ['MOW','USM'] or Segments[0].Origin in ['IKT','KBV'] and Segments[0].Destination in ['IKT','KBV'] or Segments[0].Origin in ['UFA','HKT'] and Segments[0].Destination in ['UFA','HKT'] or Segments[0].Origin in ['EGO','UTP'] and Segments[0].Destination in ['EGO','UTP'] or Segments[0].Origin in ['HTA','DXB'] and Segments[0].Destination in ['HTA','DXB'] or Segments[0].Origin in ['OMS','SGN'] and Segments[0].Destination in ['OMS','SGN'] or Segments[0].Origin in ['PUJ','HTA'] and Segments[0].Destination in ['PUJ','HTA'] or Segments[0].Origin in ['OMS','HKT'] and Segments[0].Destination in ['OMS','HKT'] or Segments[0].Origin in ['KUF','DXB'] and Segments[0].Destination in ['KUF','DXB'] or Segments[0].Origin in ['MCX','BKK'] and Segments[0].Destination in ['MCX','BKK'] or Segments[0].Origin in ['IKT','HKT'] and Segments[0].Destination in ['IKT','HKT'] or Segments[0].Origin in ['ROV','DXB'] and Segments[0].Destination in ['ROV','DXB'] or Segments[0].Origin in ['TJM','DXB'] and Segments[0].Destination in ['TJM','DXB'] or Segments[0].Origin in ['OMS','USM'] and Segments[0].Destination in ['OMS','USM'] or Segments[0].Origin in ['KRR','DXB'] and Segments[0].Destination in ['KRR','DXB'] or Segments[0].Origin in ['KZN','HKT'] and Segments[0].Destination in ['KZN','HKT'] or Segments[0].Origin in ['LED','USM'] and Segments[0].Destination in ['LED','USM'] or Segments[0].Origin in ['MRV','HKT'] and Segments[0].Destination in ['MRV','HKT'] or Segments[0].Origin in ['TOF','HKT'] and Segments[0].Destination in ['TOF','HKT'] or Segments[0].Origin in ['KEJ','DXB'] and Segments[0].Destination in ['KEJ','DXB'] or Segments[0].Origin in ['MRV','DXB'] and Segments[0].Destination in ['MRV','DXB'] or Segments[0].Origin in ['OGZ','BKK'] and Segments[0].Destination in ['OGZ','BKK'] or Segments[0].Origin in ['PEE','UTP'] and Segments[0].Destination in ['PEE','UTP'] or Segments[0].Origin in ['ROV','USM'] and Segments[0].Destination in ['ROV','USM'] or Segments[0].Origin in ['KUF','UTP'] and Segments[0].Destination in ['KUF','UTP'] or Segments[0].Origin in ['KZN','SIP'] and Segments[0].Destination in ['KZN','SIP'] or Segments[0].Origin in ['REN','SHJ'] and Segments[0].Destination in ['REN','SHJ'] or Segments[0].Origin in ['KRR','SGN'] and Segments[0].Destination in ['KRR','SGN'] or Segments[0].Origin in ['MOW','BUH'] and Segments[0].Destination in ['MOW','BUH'] or Segments[0].Origin in ['BQS','SGN'] and Segments[0].Destination in ['BQS','SGN'] or Segments[0].Origin in ['TOF','DXB'] and Segments[0].Destination in ['TOF','DXB'] or Segments[0].Origin in ['KUF','HKT'] and Segments[0].Destination in ['KUF','HKT'] or Segments[0].Origin in ['HRG','SCW'] and Segments[0].Destination in ['HRG','SCW'] or Segments[0].Origin in ['PEE','AYT'] and Segments[0].Destination in ['PEE','AYT'] or Segments[0].Origin in ['OMS','BKK'] and Segments[0].Destination in ['OMS','BKK'] or Segments[0].Origin in ['CEK','BKK'] and Segments[0].Destination in ['CEK','BKK'] or Segments[0].Origin in ['YKS','HKT'] and Segments[0].Destination in ['YKS','HKT'] or Segments[0].Origin in ['MOW','TRN'] and Segments[0].Destination in ['MOW','TRN'] or Segments[0].Origin in ['OMS','DXB'] and Segments[0].Destination in ['OMS','DXB'] or Segments[0].Origin in ['VVO','HKT'] and Segments[0].Destination in ['VVO','HKT'] or Segments[0].Origin in ['KZN','USM'] and Segments[0].Destination in ['KZN','USM'] or Segments[0].Origin in ['MOW','POP'] and Segments[0].Destination in ['MOW','POP'] or Segments[0].Origin in ['LED','UTP'] and Segments[0].Destination in ['LED','UTP'] or Segments[0].Origin in ['GOJ','SGN'] and Segments[0].Destination in ['GOJ','SGN'] or Segments[0].Origin in ['VVO','USM'] and Segments[0].Destination in ['VVO','USM'] or Segments[0].Origin in ['PUJ','CEE'] and Segments[0].Destination in ['PUJ','CEE'] or Segments[0].Origin in ['SVX','PRG'] and Segments[0].Destination in ['SVX','PRG'] or Segments[0].Origin in ['VRA','ABA'] and Segments[0].Destination in ['VRA','ABA'] or Segments[0].Origin in ['IKT','SGN'] and Segments[0].Destination in ['IKT','SGN'] or Segments[0].Origin in ['VOG','SHJ'] and Segments[0].Destination in ['VOG','SHJ'])`
-	program, err := expr.Compile(expression, expr.Env(env))
-	if err != nil {
-		b.Fatal(err)
+		out, err = vm.Run(program, &env)
 	}
+	b.StopTimer()
 
-	var out interface{}
-	for n := 0; n < b.N; n++ {
-		out, err = vm.Run(program, env)
-	}
-	if err != nil {
-		b.Fatal(err)
-	}
-	if !out.(bool) {
-		b.Fail()
-	}
+	require.NoError(b, err)
+	require.True(b, out.(bool))
 }

From cb5654705be4f72efc18fbbcaa9f23c922ebf1df Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 23 Aug 2023 14:40:33 +0200
Subject: [PATCH 111/506] Move fuzz

---
 {testdata => test/fuzz}/fuzz_corpus.sh        |   0
 {testdata => test/fuzz}/fuzz_corpus.txt       |   0
 {testdata => test/fuzz}/fuzz_expr.dict        |   0
 .../fuzz}/fuzz_expr_seed_corpus.zip           | Bin
 fuzz_test.go => test/fuzz/fuzz_test.go        |  21 +++++++++---------
 5 files changed, 10 insertions(+), 11 deletions(-)
 rename {testdata => test/fuzz}/fuzz_corpus.sh (100%)
 rename {testdata => test/fuzz}/fuzz_corpus.txt (100%)
 rename {testdata => test/fuzz}/fuzz_expr.dict (100%)
 rename {testdata => test/fuzz}/fuzz_expr_seed_corpus.zip (100%)
 rename fuzz_test.go => test/fuzz/fuzz_test.go (97%)

diff --git a/testdata/fuzz_corpus.sh b/test/fuzz/fuzz_corpus.sh
similarity index 100%
rename from testdata/fuzz_corpus.sh
rename to test/fuzz/fuzz_corpus.sh
diff --git a/testdata/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
similarity index 100%
rename from testdata/fuzz_corpus.txt
rename to test/fuzz/fuzz_corpus.txt
diff --git a/testdata/fuzz_expr.dict b/test/fuzz/fuzz_expr.dict
similarity index 100%
rename from testdata/fuzz_expr.dict
rename to test/fuzz/fuzz_expr.dict
diff --git a/testdata/fuzz_expr_seed_corpus.zip b/test/fuzz/fuzz_expr_seed_corpus.zip
similarity index 100%
rename from testdata/fuzz_expr_seed_corpus.zip
rename to test/fuzz/fuzz_expr_seed_corpus.zip
diff --git a/fuzz_test.go b/test/fuzz/fuzz_test.go
similarity index 97%
rename from fuzz_test.go
rename to test/fuzz/fuzz_test.go
index 5770d8704..2496e4e1a 100644
--- a/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -1,4 +1,4 @@
-package expr_test
+package fuzz
 
 import (
 	"os"
@@ -10,6 +10,15 @@ import (
 )
 
 func FuzzExpr(f *testing.F) {
+	b, err := os.ReadFile("./fuzz_corpus.txt")
+	if err != nil {
+		panic(err)
+	}
+	corpus := strings.Split(strings.TrimSpace(string(b)), "\n")
+	for _, s := range corpus {
+		f.Add(s)
+	}
+
 	env := map[string]interface{}{
 		"i":   1,
 		"j":   2,
@@ -20,7 +29,6 @@ func FuzzExpr(f *testing.F) {
 		"add": func(a, b int) int { return a + b },
 		"foo": Foo{A: 1, B: 2, Bar: Bar{A: 1, B: 2}},
 	}
-
 	head := expr.Function(
 		"head",
 		func(params ...interface{}) (interface{}, error) {
@@ -29,15 +37,6 @@ func FuzzExpr(f *testing.F) {
 		new(func(int) int),
 	)
 
-	b, err := os.ReadFile("./testdata/fuzz_corpus.txt")
-	if err != nil {
-		panic(err)
-	}
-	corpus := strings.Split(strings.TrimSpace(string(b)), "\n")
-	for _, s := range corpus {
-		f.Add(s)
-	}
-
 	skip := []*regexp.Regexp{
 		regexp.MustCompile(`cannot fetch .* from .*`),
 		regexp.MustCompile(`cannot get .* from .*`),

From b7458fcfc215edb74a593457bf6add53a0adf1b9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 23 Aug 2023 15:09:21 +0200
Subject: [PATCH 112/506] Add len(filter()) optimization

---
 optimizer/filter_len.go     | 22 ++++++++++++++++++++++
 optimizer/optimizer.go      |  1 +
 optimizer/optimizer_test.go | 27 +++++++++++++++++++++++++++
 3 files changed, 50 insertions(+)
 create mode 100644 optimizer/filter_len.go

diff --git a/optimizer/filter_len.go b/optimizer/filter_len.go
new file mode 100644
index 000000000..2293de81d
--- /dev/null
+++ b/optimizer/filter_len.go
@@ -0,0 +1,22 @@
+package optimizer
+
+import (
+	. "github.com/antonmedv/expr/ast"
+)
+
+type filterLen struct{}
+
+func (*filterLen) Visit(node *Node) {
+	if ln, ok := (*node).(*BuiltinNode); ok &&
+		ln.Name == "len" &&
+		len(ln.Arguments) == 1 {
+		if filter, ok := ln.Arguments[0].(*BuiltinNode); ok &&
+			filter.Name == "filter" &&
+			len(filter.Arguments) == 2 {
+			Patch(node, &BuiltinNode{
+				Name:      "count",
+				Arguments: filter.Arguments,
+			})
+		}
+	}
+}
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index 9c97496c8..cd7802711 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -33,5 +33,6 @@ func Optimize(node *Node, config *conf.Config) error {
 	}
 	Walk(node, &inRange{})
 	Walk(node, &constRange{})
+	Walk(node, &filterLen{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 0fc9f55bd..162a355f1 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -138,3 +138,30 @@ func TestOptimize_const_expr(t *testing.T) {
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
+
+func TestOptimize_filter_len(t *testing.T) {
+	tree, err := parser.Parse(`len(filter(users, .Name == "Bob"))`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "count",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BinaryNode{
+					Operator: "==",
+					Left: &ast.MemberNode{
+						Node:     &ast.PointerNode{},
+						Property: &ast.StringNode{Value: "Name"},
+					},
+					Right: &ast.StringNode{Value: "Bob"},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}

From 8b8934fc7140d346f8e249b56ed384c17122250a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 23 Aug 2023 18:37:12 +0200
Subject: [PATCH 113/506] Add find() and findIndex()

---
 builtin/builtin.go      | 10 +++++++++
 checker/checker.go      | 46 +++++++++++++++++++++++++++++++++++++++++
 checker/checker_test.go |  5 +++++
 compiler/compiler.go    | 38 +++++++++++++++++++++++++++++++++-
 debug/debugger.go       |  2 +-
 expr_test.go            | 21 +++++++++++++------
 parser/parser.go        | 16 +++++++-------
 repl/repl.go            |  5 +++++
 vm/opcodes.go           |  3 ++-
 vm/program.go           |  7 +++++--
 vm/vm.go                | 16 +++++++++-----
 11 files changed, 146 insertions(+), 23 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 82922e9dd..fe1f36ab8 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -60,6 +60,16 @@ var Builtins = []*Function{
 		Predicate: true,
 		Types:     types(new(func([]interface{}, func(interface{}) bool) []interface{})),
 	},
+	{
+		Name:      "find",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) bool) interface{})),
+	},
+	{
+		Name:      "findIndex",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) bool) int)),
+	},
 	{
 		Name:      "map",
 		Predicate: true,
diff --git a/checker/checker.go b/checker/checker.go
index 4a001f4d2..5cf25380f 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -672,6 +672,52 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return integerType, info{}
 		}
 		return v.error(node.Arguments[1], "closure should has one input and one output param")
+
+	case "find":
+		collection, _ := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isAny(collection) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		}
+
+		v.collections = append(v.collections, collection)
+		closure, _ := v.visit(node.Arguments[1])
+		v.collections = v.collections[:len(v.collections)-1]
+
+		if isFunc(closure) &&
+			closure.NumOut() == 1 &&
+			closure.NumIn() == 1 && isAny(closure.In(0)) {
+
+			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
+				return v.error(node.Arguments[1], "closure should return boolean (got %v)", closure.Out(0).String())
+			}
+			if isAny(collection) {
+				return anyType, info{}
+			}
+			return collection.Elem(), info{}
+		}
+		return v.error(node.Arguments[1], "closure should has one input and one output param")
+
+	case "findIndex":
+		collection, _ := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isAny(collection) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		}
+
+		v.collections = append(v.collections, collection)
+		closure, _ := v.visit(node.Arguments[1])
+		v.collections = v.collections[:len(v.collections)-1]
+
+		if isFunc(closure) &&
+			closure.NumOut() == 1 &&
+			closure.NumIn() == 1 && isAny(closure.In(0)) {
+
+			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
+				return v.error(node.Arguments[1], "closure should return boolean (got %v)", closure.Out(0).String())
+			}
+			return integerType, info{}
+		}
+		return v.error(node.Arguments[1], "closure should has one input and one output param")
+
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index e1c7e50b2..c4b322498 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -428,6 +428,11 @@ closure should return boolean (got string) (1:20)
  | filter(ArrayOfFoo, {.Bar.Baz})
  | ...................^
 
+find(ArrayOfFoo, {.Bar.Baz})
+closure should return boolean (got string) (1:18)
+ | find(ArrayOfFoo, {.Bar.Baz})
+ | .................^
+
 map(1, {2})
 builtin map takes only array (got int) (1:5)
  | map(1, {2})
diff --git a/compiler/compiler.go b/compiler/compiler.go
index b40e12756..c99207183 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -719,6 +719,42 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpGetCount)
 		c.emit(OpEnd)
 		return
+
+	case "find":
+		c.compile(node.Arguments[0])
+		c.emit(OpBegin)
+		var loopBreak int
+		c.emitLoop(func() {
+			c.compile(node.Arguments[1])
+			noop := c.emit(OpJumpIfFalse, placeholder)
+			c.emit(OpPop)
+			c.emit(OpPointer)
+			loopBreak = c.emit(OpJump, placeholder)
+			c.patchJump(noop)
+			c.emit(OpPop)
+		})
+		c.emit(OpNil)
+		c.patchJump(loopBreak)
+		c.emit(OpEnd)
+		return
+
+	case "findIndex":
+		c.compile(node.Arguments[0])
+		c.emit(OpBegin)
+		var loopBreak int
+		c.emitLoop(func() {
+			c.compile(node.Arguments[1])
+			noop := c.emit(OpJumpIfFalse, placeholder)
+			c.emit(OpPop)
+			c.emit(OpGetIndex)
+			loopBreak = c.emit(OpJump, placeholder)
+			c.patchJump(noop)
+			c.emit(OpPop)
+		})
+		c.emit(OpPushInt, -1)
+		c.patchJump(loopBreak)
+		c.emit(OpEnd)
+		return
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
@@ -755,7 +791,7 @@ func (c *compiler) emitLoop(body func()) {
 
 	body()
 
-	c.emit(OpIncrementIt)
+	c.emit(OpIncrementIndex)
 	c.emit(OpJumpBackward, c.calcBackwardJump(begin))
 	c.patchJump(end)
 }
diff --git a/debug/debugger.go b/debug/debugger.go
index 7de851769..a002e0558 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -126,7 +126,7 @@ func StartDebugger(program *Program, env interface{}) {
 					value int
 				}
 				var keys []pair
-				keys = append(keys, pair{"It", s.It})
+				keys = append(keys, pair{"Index", s.Index})
 				keys = append(keys, pair{"Len", s.Len})
 				keys = append(keys, pair{"Count", s.Count})
 				row := 0
diff --git a/expr_test.go b/expr_test.go
index 792586278..757a6d9d8 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -537,7 +537,7 @@ func TestExpr(t *testing.T) {
 		Abstract:           nil,
 		ArrayOfAny:         nil,
 		ArrayOfInt:         []int{1, 2, 3, 4, 5},
-		ArrayOfFoo:         nil,
+		ArrayOfFoo:         []*mock.Foo{{Value: "foo"}, {Value: "bar"}, {Value: "baz"}},
 		MapOfFoo:           nil,
 		MapOfAny:           nil,
 		FuncParam:          nil,
@@ -960,11 +960,22 @@ func TestExpr(t *testing.T) {
 			`map(1..2, let x = #; map(2..3, let y = #; x + y))`,
 			[]interface{}{[]interface{}{3, 4}, []interface{}{4, 5}},
 		},
+		{
+			`len(filter(1..99, # % 7 == 0))`,
+			14,
+		},
+		{
+			`find(ArrayOfFoo, .Value == "baz")`,
+			env.ArrayOfFoo[2],
+		},
+		{
+			`findIndex(ArrayOfFoo, .Value == "baz")`,
+			2,
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.code, func(t *testing.T) {
-			tt := tt
 			program, err := expr.Compile(tt.code, expr.Env(mock.Env{}))
 			require.NoError(t, err, "compile error")
 
@@ -974,8 +985,7 @@ func TestExpr(t *testing.T) {
 		})
 	}
 	for _, tt := range tests {
-		t.Run(tt.code, func(t *testing.T) {
-			tt := tt
+		t.Run("Unoptimized "+tt.code, func(t *testing.T) {
 			program, err := expr.Compile(tt.code, expr.Optimize(false))
 			require.NoError(t, err, "unoptimized")
 
@@ -985,8 +995,7 @@ func TestExpr(t *testing.T) {
 		})
 	}
 	for _, tt := range tests {
-		t.Run(tt.code, func(t *testing.T) {
-			tt := tt
+		t.Run("Eval "+tt.code, func(t *testing.T) {
 			got, err := expr.Eval(tt.code, env)
 			require.NoError(t, err, "eval")
 			assert.Equal(t, tt.want, got, "eval")
diff --git a/parser/parser.go b/parser/parser.go
index f2afc2eca..cef232d7a 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -17,13 +17,15 @@ import (
 var predicates = map[string]struct {
 	arity int
 }{
-	"all":    {2},
-	"none":   {2},
-	"any":    {2},
-	"one":    {2},
-	"filter": {2},
-	"map":    {2},
-	"count":  {2},
+	"all":       {2},
+	"none":      {2},
+	"any":       {2},
+	"one":       {2},
+	"filter":    {2},
+	"map":       {2},
+	"count":     {2},
+	"find":      {2},
+	"findIndex": {2},
 }
 
 type parser struct {
diff --git a/repl/repl.go b/repl/repl.go
index c249af0d9..d50b3b157 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -25,9 +25,14 @@ var keywords = []string{
 }
 
 func main() {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		panic(err)
+	}
 	rl, err := readline.NewEx(&readline.Config{
 		Prompt:       "❯ ",
 		AutoComplete: completer{append(builtin.Names, keywords...)},
+		HistoryFile:  home + "/.expr_history",
 	})
 	if err != nil {
 		panic(err)
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 079d1c76f..75e7081df 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -65,8 +65,9 @@ const (
 	OpLen
 	OpCast
 	OpDeref
-	OpIncrementIt
+	OpIncrementIndex
 	OpIncrementCount
+	OpGetIndex
 	OpGetCount
 	OpGetLen
 	OpPointer
diff --git a/vm/program.go b/vm/program.go
index 1481dbf93..b99aa1b81 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -268,12 +268,15 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpDeref:
 			code("OpDeref")
 
-		case OpIncrementIt:
-			code("OpIncrementIt")
+		case OpIncrementIndex:
+			code("OpIncrementIndex")
 
 		case OpIncrementCount:
 			code("OpIncrementCount")
 
+		case OpGetIndex:
+			code("OpGetIndex")
+
 		case OpGetCount:
 			code("OpGetCount")
 
diff --git a/vm/vm.go b/vm/vm.go
index 49bee401f..5eb4bbaf3 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -40,7 +40,7 @@ type VM struct {
 
 type Scope struct {
 	Array reflect.Value
-	It    int
+	Index int
 	Len   int
 	Count int
 }
@@ -99,6 +99,9 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 		case OpPush:
 			vm.push(program.Constants[arg])
 
+		case OpPushInt:
+			vm.push(arg)
+
 		case OpPop:
 			vm.pop()
 
@@ -196,7 +199,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 
 		case OpJumpIfEnd:
 			scope := vm.Scope()
-			if scope.It >= scope.Len {
+			if scope.Index >= scope.Len {
 				vm.ip += arg
 			}
 
@@ -431,14 +434,17 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			a := vm.pop()
 			vm.push(runtime.Deref(a))
 
-		case OpIncrementIt:
+		case OpIncrementIndex:
 			scope := vm.Scope()
-			scope.It++
+			scope.Index++
 
 		case OpIncrementCount:
 			scope := vm.Scope()
 			scope.Count++
 
+		case OpGetIndex:
+			vm.push(vm.Scope().Index)
+
 		case OpGetCount:
 			scope := vm.Scope()
 			vm.push(scope.Count)
@@ -449,7 +455,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 
 		case OpPointer:
 			scope := vm.Scope()
-			vm.push(scope.Array.Index(scope.It).Interface())
+			vm.push(scope.Array.Index(scope.Index).Interface())
 
 		case OpBegin:
 			a := vm.pop()

From a875bbab447c95c857ed448d12a777be4a41a156 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 23 Aug 2023 21:11:13 +0200
Subject: [PATCH 114/506] Add filter()[0] optimization

---
 ast/node.go                 |  1 +
 compiler/compiler.go        |  9 ++++--
 expr_test.go                | 39 ++++++++++++++++++++++++++
 optimizer/filter_first.go   | 36 ++++++++++++++++++++++++
 optimizer/optimizer.go      |  1 +
 optimizer/optimizer_test.go | 56 +++++++++++++++++++++++++++++++++++++
 vm/opcodes.go               |  1 +
 vm/program.go               |  3 ++
 vm/vm.go                    |  3 ++
 9 files changed, 147 insertions(+), 2 deletions(-)
 create mode 100644 optimizer/filter_first.go

diff --git a/ast/node.go b/ast/node.go
index 1adf95ac9..da2173d0b 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -133,6 +133,7 @@ type BuiltinNode struct {
 	base
 	Name      string
 	Arguments []Node
+	Throws    bool
 }
 
 type ClosureNode struct {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index c99207183..62d128234 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -733,7 +733,12 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 			c.patchJump(noop)
 			c.emit(OpPop)
 		})
-		c.emit(OpNil)
+		if node.Throws {
+			c.emit(OpPush, c.addConstant(fmt.Errorf("reflect: slice index out of range")))
+			c.emit(OpThrow)
+		} else {
+			c.emit(OpNil)
+		}
 		c.patchJump(loopBreak)
 		c.emit(OpEnd)
 		return
@@ -751,7 +756,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 			c.patchJump(noop)
 			c.emit(OpPop)
 		})
-		c.emit(OpPushInt, -1)
+		c.emit(OpNil)
 		c.patchJump(loopBreak)
 		c.emit(OpEnd)
 		return
diff --git a/expr_test.go b/expr_test.go
index 757a6d9d8..97d032889 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -972,6 +972,18 @@ func TestExpr(t *testing.T) {
 			`findIndex(ArrayOfFoo, .Value == "baz")`,
 			2,
 		},
+		{
+			`filter(ArrayOfFoo, .Value == "baz")[0]`,
+			env.ArrayOfFoo[2],
+		},
+		{
+			`first(filter(ArrayOfFoo, .Value == "baz"))`,
+			env.ArrayOfFoo[2],
+		},
+		{
+			`first(filter(ArrayOfFoo, false))`,
+			nil,
+		},
 	}
 
 	for _, tt := range tests {
@@ -1003,6 +1015,33 @@ func TestExpr(t *testing.T) {
 	}
 }
 
+func TestExpr_error(t *testing.T) {
+	env := mock.Env{}
+
+	tests := []struct {
+		code string
+		want string
+	}{
+		{
+			`filter(1..9, # > 9)[0]`,
+			`reflect: slice index out of range (1:20)
+ | filter(1..9, # > 9)[0]
+ | ...................^`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			program, err := expr.Compile(tt.code, expr.Env(mock.Env{}))
+			require.NoError(t, err)
+
+			_, err = expr.Run(program, env)
+			require.Error(t, err)
+			assert.Equal(t, tt.want, err.Error())
+		})
+	}
+}
+
 func TestExpr_optional_chaining(t *testing.T) {
 	env := map[string]interface{}{}
 	program, err := expr.Compile("foo?.bar.baz", expr.Env(env), expr.AllowUndefinedVariables())
diff --git a/optimizer/filter_first.go b/optimizer/filter_first.go
new file mode 100644
index 000000000..71b907701
--- /dev/null
+++ b/optimizer/filter_first.go
@@ -0,0 +1,36 @@
+package optimizer
+
+import (
+	. "github.com/antonmedv/expr/ast"
+)
+
+type filterFirst struct{}
+
+func (*filterFirst) Visit(node *Node) {
+	if member, ok := (*node).(*MemberNode); ok && member.Property != nil && !member.Optional {
+		if prop, ok := member.Property.(*IntegerNode); ok && prop.Value == 0 {
+			if filter, ok := member.Node.(*BuiltinNode); ok &&
+				filter.Name == "filter" &&
+				len(filter.Arguments) == 2 {
+				Patch(node, &BuiltinNode{
+					Name:      "find",
+					Arguments: filter.Arguments,
+					Throws:    true, // to match the behavior of filter()[0]
+				})
+			}
+		}
+	}
+	if first, ok := (*node).(*BuiltinNode); ok &&
+		first.Name == "first" &&
+		len(first.Arguments) == 1 {
+		if filter, ok := first.Arguments[0].(*BuiltinNode); ok &&
+			filter.Name == "filter" &&
+			len(filter.Arguments) == 2 {
+			Patch(node, &BuiltinNode{
+				Name:      "find",
+				Arguments: filter.Arguments,
+				Throws:    false, // as first() will return nil if not found
+			})
+		}
+	}
+}
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index cd7802711..62684d7f8 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -34,5 +34,6 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &inRange{})
 	Walk(node, &constRange{})
 	Walk(node, &filterLen{})
+	Walk(node, &filterFirst{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 162a355f1..d71f672da 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -165,3 +165,59 @@ func TestOptimize_filter_len(t *testing.T) {
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
+
+func TestOptimize_filter_0(t *testing.T) {
+	tree, err := parser.Parse(`filter(users, .Name == "Bob")[0]`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "find",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BinaryNode{
+					Operator: "==",
+					Left: &ast.MemberNode{
+						Node:     &ast.PointerNode{},
+						Property: &ast.StringNode{Value: "Name"},
+					},
+					Right: &ast.StringNode{Value: "Bob"},
+				},
+			},
+		},
+		Throws: true,
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_filter_first(t *testing.T) {
+	tree, err := parser.Parse(`first(filter(users, .Name == "Bob"))`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "find",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BinaryNode{
+					Operator: "==",
+					Left: &ast.MemberNode{
+						Node:     &ast.PointerNode{},
+						Property: &ast.StringNode{Value: "Name"},
+					},
+					Right: &ast.StringNode{Value: "Bob"},
+				},
+			},
+		},
+		Throws: false,
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 75e7081df..031d3ad87 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -71,6 +71,7 @@ const (
 	OpGetCount
 	OpGetLen
 	OpPointer
+	OpThrow
 	OpBegin
 	OpEnd // This opcode must be at the end of this list.
 )
diff --git a/vm/program.go b/vm/program.go
index b99aa1b81..f3739e3f1 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -286,6 +286,9 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpPointer:
 			code("OpPointer")
 
+		case OpThrow:
+			code("OpThrow")
+
 		case OpBegin:
 			code("OpBegin")
 
diff --git a/vm/vm.go b/vm/vm.go
index 5eb4bbaf3..33c65bbd2 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -457,6 +457,9 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			scope := vm.Scope()
 			vm.push(scope.Array.Index(scope.Index).Interface())
 
+		case OpThrow:
+			panic(vm.pop().(error))
+
 		case OpBegin:
 			a := vm.pop()
 			array := reflect.ValueOf(a)

From 88a191324279251a7a6784050b12abbba879f29d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 24 Aug 2023 09:11:14 +0200
Subject: [PATCH 115/506] Add filter()[-1] optimization

---
 builtin/builtin.go          | 16 ++++++++--
 checker/checker.go          | 27 ++++++++---------
 checker/checker_test.go     |  8 ++---
 compiler/compiler.go        | 60 +++++++++++++++++++++++++++++++++++++
 expr_test.go                | 56 +++++++++++++++++++++-------------
 optimizer/filter_last.go    | 36 ++++++++++++++++++++++
 optimizer/optimizer.go      |  1 +
 optimizer/optimizer_test.go | 56 ++++++++++++++++++++++++++++++++++
 parser/parser.go            | 20 +++++++------
 repl/repl.go                |  5 +---
 vm/opcodes.go               |  4 ++-
 vm/program.go               | 10 +++++--
 vm/vm.go                    | 10 ++++++-
 13 files changed, 250 insertions(+), 59 deletions(-)
 create mode 100644 optimizer/filter_last.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index fe1f36ab8..64d705fd8 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -60,6 +60,16 @@ var Builtins = []*Function{
 		Predicate: true,
 		Types:     types(new(func([]interface{}, func(interface{}) bool) []interface{})),
 	},
+	{
+		Name:      "map",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) interface{}) []interface{})),
+	},
+	{
+		Name:      "count",
+		Predicate: true,
+		Types:     types(new(func([]interface{}, func(interface{}) bool) int)),
+	},
 	{
 		Name:      "find",
 		Predicate: true,
@@ -71,12 +81,12 @@ var Builtins = []*Function{
 		Types:     types(new(func([]interface{}, func(interface{}) bool) int)),
 	},
 	{
-		Name:      "map",
+		Name:      "findLast",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) interface{}) []interface{})),
+		Types:     types(new(func([]interface{}, func(interface{}) bool) interface{})),
 	},
 	{
-		Name:      "count",
+		Name:      "findLastIndex",
 		Predicate: true,
 		Types:     types(new(func([]interface{}, func(interface{}) bool) int)),
 	},
diff --git a/checker/checker.go b/checker/checker.go
index 5cf25380f..20e270f2c 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -604,11 +604,11 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			closure.NumIn() == 1 && isAny(closure.In(0)) {
 
 			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
-				return v.error(node.Arguments[1], "closure should return boolean (got %v)", closure.Out(0).String())
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
 			return boolType, info{}
 		}
-		return v.error(node.Arguments[1], "closure should has one input and one output param")
+		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "filter":
 		collection, _ := v.visit(node.Arguments[0])
@@ -625,14 +625,14 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			closure.NumIn() == 1 && isAny(closure.In(0)) {
 
 			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
-				return v.error(node.Arguments[1], "closure should return boolean (got %v)", closure.Out(0).String())
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
 			if isAny(collection) {
 				return arrayType, info{}
 			}
 			return reflect.SliceOf(collection.Elem()), info{}
 		}
-		return v.error(node.Arguments[1], "closure should has one input and one output param")
+		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "map":
 		collection, _ := v.visit(node.Arguments[0])
@@ -650,7 +650,7 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 
 			return reflect.SliceOf(closure.Out(0)), info{}
 		}
-		return v.error(node.Arguments[1], "closure should has one input and one output param")
+		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "count":
 		collection, _ := v.visit(node.Arguments[0])
@@ -666,14 +666,14 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			closure.NumOut() == 1 &&
 			closure.NumIn() == 1 && isAny(closure.In(0)) {
 			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
-				return v.error(node.Arguments[1], "closure should return boolean (got %v)", closure.Out(0).String())
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
 
 			return integerType, info{}
 		}
-		return v.error(node.Arguments[1], "closure should has one input and one output param")
+		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
-	case "find":
+	case "find", "findLast":
 		collection, _ := v.visit(node.Arguments[0])
 		if !isArray(collection) && !isAny(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
@@ -688,16 +688,16 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			closure.NumIn() == 1 && isAny(closure.In(0)) {
 
 			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
-				return v.error(node.Arguments[1], "closure should return boolean (got %v)", closure.Out(0).String())
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
 			if isAny(collection) {
 				return anyType, info{}
 			}
 			return collection.Elem(), info{}
 		}
-		return v.error(node.Arguments[1], "closure should has one input and one output param")
+		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
-	case "findIndex":
+	case "findIndex", "findLastIndex":
 		collection, _ := v.visit(node.Arguments[0])
 		if !isArray(collection) && !isAny(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
@@ -712,12 +712,11 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			closure.NumIn() == 1 && isAny(closure.In(0)) {
 
 			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
-				return v.error(node.Arguments[1], "closure should return boolean (got %v)", closure.Out(0).String())
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
 			return integerType, info{}
 		}
-		return v.error(node.Arguments[1], "closure should has one input and one output param")
-
+		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index c4b322498..c451736ef 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -414,22 +414,22 @@ builtin count takes only array (got int) (1:7)
  | ......^
 
 count(ArrayOfInt, {#})
-closure should return boolean (got int) (1:19)
+predicate should return boolean (got int) (1:19)
  | count(ArrayOfInt, {#})
  | ..................^
 
 all(ArrayOfInt, {# + 1})
-closure should return boolean (got int) (1:17)
+predicate should return boolean (got int) (1:17)
  | all(ArrayOfInt, {# + 1})
  | ................^
 
 filter(ArrayOfFoo, {.Bar.Baz})
-closure should return boolean (got string) (1:20)
+predicate should return boolean (got string) (1:20)
  | filter(ArrayOfFoo, {.Bar.Baz})
  | ...................^
 
 find(ArrayOfFoo, {.Bar.Baz})
-closure should return boolean (got string) (1:18)
+predicate should return boolean (got string) (1:18)
  | find(ArrayOfFoo, {.Bar.Baz})
  | .................^
 
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 62d128234..805f7577d 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -760,6 +760,48 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.patchJump(loopBreak)
 		c.emit(OpEnd)
 		return
+
+	case "findLast":
+		c.compile(node.Arguments[0])
+		c.emit(OpBegin)
+		var loopBreak int
+		c.emitLoopBackwards(func() {
+			c.compile(node.Arguments[1])
+			noop := c.emit(OpJumpIfFalse, placeholder)
+			c.emit(OpPop)
+			c.emit(OpPointer)
+			loopBreak = c.emit(OpJump, placeholder)
+			c.patchJump(noop)
+			c.emit(OpPop)
+		})
+		if node.Throws {
+			c.emit(OpPush, c.addConstant(fmt.Errorf("reflect: slice index out of range")))
+			c.emit(OpThrow)
+		} else {
+			c.emit(OpNil)
+		}
+		c.patchJump(loopBreak)
+		c.emit(OpEnd)
+		return
+
+	case "findLastIndex":
+		c.compile(node.Arguments[0])
+		c.emit(OpBegin)
+		var loopBreak int
+		c.emitLoopBackwards(func() {
+			c.compile(node.Arguments[1])
+			noop := c.emit(OpJumpIfFalse, placeholder)
+			c.emit(OpPop)
+			c.emit(OpGetIndex)
+			loopBreak = c.emit(OpJump, placeholder)
+			c.patchJump(noop)
+			c.emit(OpPop)
+		})
+		c.emit(OpNil)
+		c.patchJump(loopBreak)
+		c.emit(OpEnd)
+		return
+
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
@@ -801,6 +843,24 @@ func (c *compiler) emitLoop(body func()) {
 	c.patchJump(end)
 }
 
+func (c *compiler) emitLoopBackwards(body func()) {
+	c.emit(OpGetLen)
+	c.emit(OpInt, 1)
+	c.emit(OpSubtract)
+	c.emit(OpSetIndex)
+	begin := len(c.bytecode)
+	c.emit(OpGetIndex)
+	c.emit(OpInt, 0)
+	c.emit(OpMoreOrEqual)
+	end := c.emit(OpJumpIfFalse, placeholder)
+
+	body()
+
+	c.emit(OpDecrementIndex)
+	c.emit(OpJumpBackward, c.calcBackwardJump(begin))
+	c.patchJump(end)
+}
+
 func (c *compiler) ClosureNode(node *ast.ClosureNode) {
 	c.compile(node.Node)
 }
diff --git a/expr_test.go b/expr_test.go
index 97d032889..6cc97203f 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -984,33 +984,47 @@ func TestExpr(t *testing.T) {
 			`first(filter(ArrayOfFoo, false))`,
 			nil,
 		},
+		{
+			`findLast(1..9, # % 2 == 0)`,
+			8,
+		},
+		{
+			`findLastIndex(1..9, # % 2 == 0)`,
+			7,
+		},
+		{
+			`filter(1..9, # % 2 == 0)[-1]`,
+			8,
+		},
+		{
+			`last(filter(1..9, # % 2 == 0))`,
+			8,
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.code, func(t *testing.T) {
-			program, err := expr.Compile(tt.code, expr.Env(mock.Env{}))
-			require.NoError(t, err, "compile error")
+			{
+				program, err := expr.Compile(tt.code, expr.Env(mock.Env{}))
+				require.NoError(t, err, "compile error")
 
-			got, err := expr.Run(program, env)
-			require.NoError(t, err, "run error")
-			assert.Equal(t, tt.want, got)
-		})
-	}
-	for _, tt := range tests {
-		t.Run("Unoptimized "+tt.code, func(t *testing.T) {
-			program, err := expr.Compile(tt.code, expr.Optimize(false))
-			require.NoError(t, err, "unoptimized")
+				got, err := expr.Run(program, env)
+				require.NoError(t, err, "run error")
+				assert.Equal(t, tt.want, got)
+			}
+			{
+				program, err := expr.Compile(tt.code, expr.Optimize(false))
+				require.NoError(t, err, "unoptimized")
 
-			got, err := expr.Run(program, env)
-			require.NoError(t, err, "unoptimized")
-			assert.Equal(t, tt.want, got, "unoptimized")
-		})
-	}
-	for _, tt := range tests {
-		t.Run("Eval "+tt.code, func(t *testing.T) {
-			got, err := expr.Eval(tt.code, env)
-			require.NoError(t, err, "eval")
-			assert.Equal(t, tt.want, got, "eval")
+				got, err := expr.Run(program, env)
+				require.NoError(t, err, "unoptimized")
+				assert.Equal(t, tt.want, got, "unoptimized")
+			}
+			{
+				got, err := expr.Eval(tt.code, env)
+				require.NoError(t, err, "eval")
+				assert.Equal(t, tt.want, got, "eval")
+			}
 		})
 	}
 }
diff --git a/optimizer/filter_last.go b/optimizer/filter_last.go
new file mode 100644
index 000000000..0195dfa6e
--- /dev/null
+++ b/optimizer/filter_last.go
@@ -0,0 +1,36 @@
+package optimizer
+
+import (
+	. "github.com/antonmedv/expr/ast"
+)
+
+type filterLast struct{}
+
+func (*filterLast) Visit(node *Node) {
+	if member, ok := (*node).(*MemberNode); ok && member.Property != nil && !member.Optional {
+		if prop, ok := member.Property.(*IntegerNode); ok && prop.Value == -1 {
+			if filter, ok := member.Node.(*BuiltinNode); ok &&
+				filter.Name == "filter" &&
+				len(filter.Arguments) == 2 {
+				Patch(node, &BuiltinNode{
+					Name:      "findLast",
+					Arguments: filter.Arguments,
+					Throws:    true, // to match the behavior of filter()[-1]
+				})
+			}
+		}
+	}
+	if first, ok := (*node).(*BuiltinNode); ok &&
+		first.Name == "last" &&
+		len(first.Arguments) == 1 {
+		if filter, ok := first.Arguments[0].(*BuiltinNode); ok &&
+			filter.Name == "filter" &&
+			len(filter.Arguments) == 2 {
+			Patch(node, &BuiltinNode{
+				Name:      "findLast",
+				Arguments: filter.Arguments,
+				Throws:    false, // as last() will return nil if not found
+			})
+		}
+	}
+}
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index 62684d7f8..ce239724d 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -35,5 +35,6 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &constRange{})
 	Walk(node, &filterLen{})
 	Walk(node, &filterFirst{})
+	Walk(node, &filterLast{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index d71f672da..457d8826a 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -221,3 +221,59 @@ func TestOptimize_filter_first(t *testing.T) {
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
+
+func TestOptimize_filter_minus_1(t *testing.T) {
+	tree, err := parser.Parse(`filter(users, .Name == "Bob")[-1]`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "findLast",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BinaryNode{
+					Operator: "==",
+					Left: &ast.MemberNode{
+						Node:     &ast.PointerNode{},
+						Property: &ast.StringNode{Value: "Name"},
+					},
+					Right: &ast.StringNode{Value: "Bob"},
+				},
+			},
+		},
+		Throws: true,
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_filter_last(t *testing.T) {
+	tree, err := parser.Parse(`last(filter(users, .Name == "Bob"))`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "findLast",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BinaryNode{
+					Operator: "==",
+					Left: &ast.MemberNode{
+						Node:     &ast.PointerNode{},
+						Property: &ast.StringNode{Value: "Name"},
+					},
+					Right: &ast.StringNode{Value: "Bob"},
+				},
+			},
+		},
+		Throws: false,
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
diff --git a/parser/parser.go b/parser/parser.go
index cef232d7a..108b201a7 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -17,15 +17,17 @@ import (
 var predicates = map[string]struct {
 	arity int
 }{
-	"all":       {2},
-	"none":      {2},
-	"any":       {2},
-	"one":       {2},
-	"filter":    {2},
-	"map":       {2},
-	"count":     {2},
-	"find":      {2},
-	"findIndex": {2},
+	"all":           {2},
+	"none":          {2},
+	"any":           {2},
+	"one":           {2},
+	"filter":        {2},
+	"map":           {2},
+	"count":         {2},
+	"find":          {2},
+	"findIndex":     {2},
+	"findLast":      {2},
+	"findLastIndex": {2},
 }
 
 type parser struct {
diff --git a/repl/repl.go b/repl/repl.go
index d50b3b157..cd326fa7b 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -13,12 +13,9 @@ import (
 )
 
 var keywords = []string{
+	// Commands:
 	"exit", "opcodes", "debug",
 
-	// Predicate functions:
-	"map", "filter", "all",
-	"any", "none", "one",
-
 	// Operators:
 	"and", "or", "in", "not", "not in",
 	"contains", "matches", "startsWith", "endsWith",
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 031d3ad87..2efe09ded 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -5,7 +5,7 @@ type Opcode byte
 const (
 	OpInvalid Opcode = iota
 	OpPush
-	OpPushInt
+	OpInt
 	OpPop
 	OpStore
 	OpLoadVar
@@ -66,8 +66,10 @@ const (
 	OpCast
 	OpDeref
 	OpIncrementIndex
+	OpDecrementIndex
 	OpIncrementCount
 	OpGetIndex
+	OpSetIndex
 	OpGetCount
 	OpGetLen
 	OpPointer
diff --git a/vm/program.go b/vm/program.go
index f3739e3f1..c4cd8103b 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -87,8 +87,8 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpPush:
 			constant("OpPush")
 
-		case OpPushInt:
-			argument("OpPushInt")
+		case OpInt:
+			argument("OpInt")
 
 		case OpPop:
 			code("OpPop")
@@ -271,12 +271,18 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpIncrementIndex:
 			code("OpIncrementIndex")
 
+		case OpDecrementIndex:
+			code("OpDecrementIndex")
+
 		case OpIncrementCount:
 			code("OpIncrementCount")
 
 		case OpGetIndex:
 			code("OpGetIndex")
 
+		case OpSetIndex:
+			code("OpSetIndex")
+
 		case OpGetCount:
 			code("OpGetCount")
 
diff --git a/vm/vm.go b/vm/vm.go
index 33c65bbd2..f083e74c2 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -99,7 +99,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 		case OpPush:
 			vm.push(program.Constants[arg])
 
-		case OpPushInt:
+		case OpInt:
 			vm.push(arg)
 
 		case OpPop:
@@ -438,6 +438,10 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			scope := vm.Scope()
 			scope.Index++
 
+		case OpDecrementIndex:
+			scope := vm.Scope()
+			scope.Index--
+
 		case OpIncrementCount:
 			scope := vm.Scope()
 			scope.Count++
@@ -445,6 +449,10 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 		case OpGetIndex:
 			vm.push(vm.Scope().Index)
 
+		case OpSetIndex:
+			scope := vm.Scope()
+			scope.Index = vm.pop().(int)
+
 		case OpGetCount:
 			scope := vm.Scope()
 			vm.push(scope.Count)

From 80f169a2eebc6fada92024b16e6c2b13919d9527 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 24 Aug 2023 10:27:52 +0200
Subject: [PATCH 116/506] Add map(filter()) optimization

---
 ast/node.go                 |  1 +
 compiler/compiler.go        | 18 +++++++++--
 expr_test.go                | 28 +++++++++++++++++
 optimizer/filter_first.go   |  2 ++
 optimizer/filter_last.go    |  2 ++
 optimizer/filter_map.go     | 25 +++++++++++++++
 optimizer/optimizer.go      |  3 +-
 optimizer/optimizer_test.go | 63 +++++++++++++++++++++++++++++++++++++
 8 files changed, 138 insertions(+), 4 deletions(-)
 create mode 100644 optimizer/filter_map.go

diff --git a/ast/node.go b/ast/node.go
index da2173d0b..e5b87078b 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -134,6 +134,7 @@ type BuiltinNode struct {
 	Name      string
 	Arguments []Node
 	Throws    bool
+	Map       Node
 }
 
 type ClosureNode struct {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 805f7577d..b817a60ce 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -688,7 +688,11 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 			c.compile(node.Arguments[1])
 			c.emitCond(func() {
 				c.emit(OpIncrementCount)
-				c.emit(OpPointer)
+				if node.Map != nil {
+					c.compile(node.Map)
+				} else {
+					c.emit(OpPointer)
+				}
 			})
 		})
 		c.emit(OpGetCount)
@@ -728,7 +732,11 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 			c.compile(node.Arguments[1])
 			noop := c.emit(OpJumpIfFalse, placeholder)
 			c.emit(OpPop)
-			c.emit(OpPointer)
+			if node.Map != nil {
+				c.compile(node.Map)
+			} else {
+				c.emit(OpPointer)
+			}
 			loopBreak = c.emit(OpJump, placeholder)
 			c.patchJump(noop)
 			c.emit(OpPop)
@@ -769,7 +777,11 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 			c.compile(node.Arguments[1])
 			noop := c.emit(OpJumpIfFalse, placeholder)
 			c.emit(OpPop)
-			c.emit(OpPointer)
+			if node.Map != nil {
+				c.compile(node.Map)
+			} else {
+				c.emit(OpPointer)
+			}
 			loopBreak = c.emit(OpJump, placeholder)
 			c.patchJump(noop)
 			c.emit(OpPop)
diff --git a/expr_test.go b/expr_test.go
index 6cc97203f..78ef15cf1 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1000,6 +1000,34 @@ func TestExpr(t *testing.T) {
 			`last(filter(1..9, # % 2 == 0))`,
 			8,
 		},
+		{
+			`map(filter(1..9, # % 2 == 0), # * 2)`,
+			[]interface{}{4, 8, 12, 16},
+		},
+		{
+			`map(map(filter(1..9, # % 2 == 0), # * 2), # * 2)`,
+			[]interface{}{8, 16, 24, 32},
+		},
+		{
+			`first(map(filter(1..9, # % 2 == 0), # * 2))`,
+			4,
+		},
+		{
+			`map(filter(1..9, # % 2 == 0), # * 2)[-1]`,
+			16,
+		},
+		{
+			`len(map(filter(1..9, # % 2 == 0), # * 2))`,
+			4,
+		},
+		{
+			`len(filter(map(1..9, # * 2), # % 2 == 0))`,
+			9,
+		},
+		{
+			`first(filter(map(1..9, # * 2), # % 2 == 0))`,
+			2,
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/optimizer/filter_first.go b/optimizer/filter_first.go
index 71b907701..852e2c268 100644
--- a/optimizer/filter_first.go
+++ b/optimizer/filter_first.go
@@ -16,6 +16,7 @@ func (*filterFirst) Visit(node *Node) {
 					Name:      "find",
 					Arguments: filter.Arguments,
 					Throws:    true, // to match the behavior of filter()[0]
+					Map:       filter.Map,
 				})
 			}
 		}
@@ -30,6 +31,7 @@ func (*filterFirst) Visit(node *Node) {
 				Name:      "find",
 				Arguments: filter.Arguments,
 				Throws:    false, // as first() will return nil if not found
+				Map:       filter.Map,
 			})
 		}
 	}
diff --git a/optimizer/filter_last.go b/optimizer/filter_last.go
index 0195dfa6e..0a072004b 100644
--- a/optimizer/filter_last.go
+++ b/optimizer/filter_last.go
@@ -16,6 +16,7 @@ func (*filterLast) Visit(node *Node) {
 					Name:      "findLast",
 					Arguments: filter.Arguments,
 					Throws:    true, // to match the behavior of filter()[-1]
+					Map:       filter.Map,
 				})
 			}
 		}
@@ -30,6 +31,7 @@ func (*filterLast) Visit(node *Node) {
 				Name:      "findLast",
 				Arguments: filter.Arguments,
 				Throws:    false, // as last() will return nil if not found
+				Map:       filter.Map,
 			})
 		}
 	}
diff --git a/optimizer/filter_map.go b/optimizer/filter_map.go
new file mode 100644
index 000000000..9044ac34d
--- /dev/null
+++ b/optimizer/filter_map.go
@@ -0,0 +1,25 @@
+package optimizer
+
+import (
+	. "github.com/antonmedv/expr/ast"
+)
+
+type filterMap struct{}
+
+func (*filterMap) Visit(node *Node) {
+	if mapBuiltin, ok := (*node).(*BuiltinNode); ok &&
+		mapBuiltin.Name == "map" &&
+		len(mapBuiltin.Arguments) == 2 {
+		if closure, ok := mapBuiltin.Arguments[1].(*ClosureNode); ok {
+			if filter, ok := mapBuiltin.Arguments[0].(*BuiltinNode); ok &&
+				filter.Name == "filter" &&
+				filter.Map == nil /* not already optimized */ {
+				Patch(node, &BuiltinNode{
+					Name:      "filter",
+					Arguments: filter.Arguments,
+					Map:       closure.Node,
+				})
+			}
+		}
+	}
+}
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index ce239724d..15f50fd73 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -33,8 +33,9 @@ func Optimize(node *Node, config *conf.Config) error {
 	}
 	Walk(node, &inRange{})
 	Walk(node, &constRange{})
+	Walk(node, &filterMap{})
 	Walk(node, &filterLen{})
-	Walk(node, &filterFirst{})
 	Walk(node, &filterLast{})
+	Walk(node, &filterFirst{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 457d8826a..948fc6e14 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -277,3 +277,66 @@ func TestOptimize_filter_last(t *testing.T) {
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
+
+func TestOptimize_filter_map(t *testing.T) {
+	tree, err := parser.Parse(`map(filter(users, .Name == "Bob"), .Age)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "filter",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BinaryNode{
+					Operator: "==",
+					Left: &ast.MemberNode{
+						Node:     &ast.PointerNode{},
+						Property: &ast.StringNode{Value: "Name"},
+					},
+					Right: &ast.StringNode{Value: "Bob"},
+				},
+			},
+		},
+		Map: &ast.MemberNode{
+			Node:     &ast.PointerNode{},
+			Property: &ast.StringNode{Value: "Age"},
+		},
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_filter_map_first(t *testing.T) {
+	tree, err := parser.Parse(`first(map(filter(users, .Name == "Bob"), .Age))`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "find",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BinaryNode{
+					Operator: "==",
+					Left: &ast.MemberNode{
+						Node:     &ast.PointerNode{},
+						Property: &ast.StringNode{Value: "Name"},
+					},
+					Right: &ast.StringNode{Value: "Bob"},
+				},
+			},
+		},
+		Map: &ast.MemberNode{
+			Node:     &ast.PointerNode{},
+			Property: &ast.StringNode{Value: "Age"},
+		},
+		Throws: false,
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}

From 0baed263e9a5c2b216ce503f52930a77432d0068 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 24 Aug 2023 11:18:45 +0200
Subject: [PATCH 117/506] Fix flaky test

---
 bench_test.go           | 4 ++--
 builtin/builtin_test.go | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/bench_test.go b/bench_test.go
index b97897393..024d2c4fb 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -178,7 +178,7 @@ func Benchmark_filterMap(b *testing.B) {
 		Ints []int
 	}
 	env := Env{
-		Ints: make([]int, 1000),
+		Ints: make([]int, 100),
 	}
 	for i := 1; i <= len(env.Ints); i++ {
 		env.Ints[i-1] = i
@@ -195,7 +195,7 @@ func Benchmark_filterMap(b *testing.B) {
 	b.StopTimer()
 
 	require.NoError(b, err)
-	require.Len(b, out.([]interface{}), 142)
+	require.Len(b, out.([]interface{}), 14)
 	require.Equal(b, 14, out.([]interface{})[0])
 }
 
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index d1e4b88fc..873fff5ff 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -65,7 +65,7 @@ func TestBuiltin(t *testing.T) {
 		{`fromJSON("[1, 2, 3]")`, []interface{}{1.0, 2.0, 3.0}},
 		{`toBase64("hello")`, "aGVsbG8="},
 		{`fromBase64("aGVsbG8=")`, "hello"},
-		{`now().Format("2006-01-02T15:04:05Z")`, time.Now().Format("2006-01-02T15:04:05Z")},
+		{`now().Format("2006-01-02T15:04Z")`, time.Now().Format("2006-01-02T15:04Z")},
 		{`duration("1h")`, time.Hour},
 		{`date("2006-01-02T15:04:05Z")`, time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
 		{`date("2006.01.02", "2006.01.02")`, time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC)},

From 532017a5c7516faeed5fd7268d33e4b628fcc0e5 Mon Sep 17 00:00:00 2001
From: Wytse Vellema <w.vellema@slash2.nl>
Date: Thu, 24 Aug 2023 10:48:20 +0200
Subject: [PATCH 118/506] Add docgen types for most builtin types

---
 docgen/docgen.go | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/docgen/docgen.go b/docgen/docgen.go
index 3c2134555..672cd0183 100644
--- a/docgen/docgen.go
+++ b/docgen/docgen.go
@@ -46,6 +46,33 @@ var (
 		"filter": {Kind: "func", Arguments: []*Type{{Kind: "array", Type: &Type{Kind: "any"}}, {Kind: "func"}}, Return: &Type{Kind: "array", Type: &Type{Kind: "any"}}},
 		"map":    {Kind: "func", Arguments: []*Type{{Kind: "array", Type: &Type{Kind: "any"}}, {Kind: "func"}}, Return: &Type{Kind: "array", Type: &Type{Kind: "any"}}},
 		"count":  {Kind: "func", Arguments: []*Type{{Kind: "array", Type: &Type{Kind: "any"}}, {Kind: "func"}}, Return: &Type{Kind: "int"}},
+
+		"trim":       {Kind: "func", Arguments: []*Type{{Name: "string", Kind: "string"}, {Name: "cutstr", Kind: "string"}}, Return: &Type{Name: "string", Kind: "string"}},
+		"trimPrefix": {Kind: "func", Arguments: []*Type{{Name: "string", Kind: "string"}, {Name: "cutstr", Kind: "string"}}, Return: &Type{Name: "string", Kind: "string"}},
+		"trimSuffix": {Kind: "func", Arguments: []*Type{{Name: "string", Kind: "string"}, {Name: "cutstr", Kind: "string"}}, Return: &Type{Name: "string", Kind: "string"}},
+
+		"upper":  {Kind: "func", Arguments: []*Type{{Name: "string", Kind: "string"}}, Return: &Type{Name: "string", Kind: "string"}},
+		"lower":  {Kind: "func", Arguments: []*Type{{Name: "string", Kind: "string"}}, Return: &Type{Name: "string", Kind: "string"}},
+		"repeat": {Kind: "func", Arguments: []*Type{{Name: "n", Kind: "int"}}, Return: &Type{Name: "string", Kind: "string"}},
+
+		"join":        {Kind: "func", Arguments: []*Type{{Kind: "array", Type: &Type{Kind: "any"}}, {Name: "glue", Kind: "string"}}, Return: &Type{Name: "string", Kind: "string"}},
+		"indexOf":     {Kind: "func", Arguments: []*Type{{Name: "string", Kind: "string"}, {Name: "substr", Kind: "string"}}, Return: &Type{Name: "index", Kind: "int"}},
+		"lastIndexOf": {Kind: "func", Arguments: []*Type{{Name: "string", Kind: "string"}, {Name: "substr", Kind: "string"}}, Return: &Type{Name: "index", Kind: "int"}},
+
+		"hasPrefix": {Kind: "func", Arguments: []*Type{{Name: "string", Kind: "string"}, {Name: "prefix", Kind: "string"}}, Return: &Type{Kind: "bool"}},
+		"hasSuffix": {Kind: "func", Arguments: []*Type{{Name: "string", Kind: "string"}, {Name: "prefix", Kind: "string"}}, Return: &Type{Kind: "bool"}},
+
+		"toJSON":   {Kind: "func", Arguments: []*Type{{Kind: "any"}}, Return: &Type{Kind: "string"}},
+		"fromJSON": {Kind: "func", Arguments: []*Type{{Kind: "string"}}, Return: &Type{Kind: "any"}},
+
+		"toBase64":   {Kind: "func", Arguments: []*Type{{Kind: "string"}}, Return: &Type{Kind: "string"}},
+		"fromBase64": {Kind: "func", Arguments: []*Type{{Kind: "string"}}, Return: &Type{Kind: "string"}},
+
+		"first": {Kind: "func", Arguments: []*Type{{Kind: "array", Type: &Type{Kind: "any"}}}, Return: &Type{Kind: "any"}},
+		"last":  {Kind: "func", Arguments: []*Type{{Kind: "array", Type: &Type{Kind: "any"}}}, Return: &Type{Kind: "any"}},
+
+		"now":      {Kind: "func", Return: &Type{Name: "time.Time", Kind: "struct"}},
+		"duration": {Kind: "func", Arguments: []*Type{{Kind: "string"}}, Return: &Type{Kind: "time.Duration"}},
 	}
 )
 

From 5af4fe26f5609460674d5fae6ffe0eaac6ed9e60 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 24 Aug 2023 11:25:08 +0200
Subject: [PATCH 119/506] Upgrade to go1.18

---
 .github/workflows/check.yml |  4 ++--
 .github/workflows/diff.yml  |  4 ++--
 .github/workflows/test.yml  |  2 +-
 debug/go.sum                |  2 ++
 go.mod                      | 10 ++++++++--
 go.sum                      |  9 ++-------
 repl/go.sum                 |  2 ++
 7 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 98c843195..63037cd61 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -11,9 +11,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - name: Setup Go 1.19
+      - name: Setup Go 1.18
         uses: actions/setup-go@v4
         with:
-          go-version: 1.19
+          go-version: 1.18
       - name: Test
         run: npx zx --experimental .github/scripts/coverage.mjs
diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml
index 84aad6610..d9fd20c59 100644
--- a/.github/workflows/diff.yml
+++ b/.github/workflows/diff.yml
@@ -8,10 +8,10 @@ jobs:
   bench:
     runs-on: ubuntu-latest
     steps:
-      - name: Setup Go 1.19
+      - name: Setup Go 1.18
         uses: actions/setup-go@v4
         with:
-          go-version: 1.19
+          go-version: 1.18
       - name: Install benchstat
         run: go install golang.org/x/perf/cmd/benchstat@latest
 
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index e41af94a4..8a8b87873 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.13', '1.14', '1.15', '1.16' , '1.17', '1.18', '1.19', '1.20', '1.21' ]
+        go-versions: [ '1.18', '1.19', '1.20', '1.21' ]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Go ${{ matrix.go-version }}
diff --git a/debug/go.sum b/debug/go.sum
index 879eeb41d..e08364c2c 100644
--- a/debug/go.sum
+++ b/debug/go.sum
@@ -20,9 +20,11 @@ github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
diff --git a/go.mod b/go.mod
index d064da5b9..03d6b62df 100644
--- a/go.mod
+++ b/go.mod
@@ -1,5 +1,11 @@
 module github.com/antonmedv/expr
 
-go 1.13
+go 1.18
 
-require github.com/stretchr/testify v1.8.0
+require github.com/stretchr/testify v1.8.4
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
diff --git a/go.sum b/go.sum
index 51648299d..fa4b6e682 100644
--- a/go.sum
+++ b/go.sum
@@ -1,15 +1,10 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/repl/go.sum b/repl/go.sum
index ba8ef9af6..c6908b013 100644
--- a/repl/go.sum
+++ b/repl/go.sum
@@ -26,9 +26,11 @@ github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=

From e5e5d19ed330b6be9cfb4fcebfa3860946164317 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 24 Aug 2023 15:26:36 +0200
Subject: [PATCH 120/506] Remove ExperimentalPipe()

---
 ast/node.go              | 1 +
 conf/config.go           | 1 -
 expr.go                  | 7 -------
 repl/repl.go             | 2 +-
 test/fuzz/fuzz_test.go   | 2 +-
 test/pipes/pipes_test.go | 4 ++--
 6 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index e5b87078b..d228e52ee 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -144,6 +144,7 @@ type ClosureNode struct {
 
 type PointerNode struct {
 	base
+	Name string
 }
 
 type ConditionalNode struct {
diff --git a/conf/config.go b/conf/config.go
index f89e6cca0..7e98e7ead 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -19,7 +19,6 @@ type Config struct {
 	ExpectAny   bool
 	Optimize    bool
 	Strict      bool
-	Pipes       bool
 	ConstFns    map[string]reflect.Value
 	Visitors    []ast.Visitor
 	Functions   map[string]*builtin.Function
diff --git a/expr.go b/expr.go
index 973bdc108..4c07ab43e 100644
--- a/expr.go
+++ b/expr.go
@@ -130,13 +130,6 @@ func Function(name string, fn func(params ...interface{}) (interface{}, error),
 	}
 }
 
-// ExperimentalPipes enables pipes syntax.
-func ExperimentalPipes() Option {
-	return func(c *conf.Config) {
-		c.Pipes = true
-	}
-}
-
 // DisableAllBuiltins disables all builtins.
 func DisableAllBuiltins() Option {
 	return func(c *conf.Config) {
diff --git a/repl/repl.go b/repl/repl.go
index cd326fa7b..b3bb9a00b 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -70,7 +70,7 @@ func main() {
 			continue
 		}
 
-		program, err = expr.Compile(line, expr.Env(env), expr.ExperimentalPipes())
+		program, err = expr.Compile(line, expr.Env(env))
 		if err != nil {
 			fmt.Printf("compile error: %s\n", err)
 			continue
diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 2496e4e1a..595987c6c 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -66,7 +66,7 @@ func FuzzExpr(f *testing.F) {
 	}
 
 	f.Fuzz(func(t *testing.T, code string) {
-		program, err := expr.Compile(code, expr.Env(env), head, expr.ExperimentalPipes())
+		program, err := expr.Compile(code, expr.Env(env), head)
 		if err != nil {
 			t.Skipf("compile error: %s", err)
 		}
diff --git a/test/pipes/pipes_test.go b/test/pipes/pipes_test.go
index 1658dd6aa..6a0e2950b 100644
--- a/test/pipes/pipes_test.go
+++ b/test/pipes/pipes_test.go
@@ -37,7 +37,7 @@ func TestPipes(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
-			program, err := expr.Compile(test.input, expr.Env(env), expr.ExperimentalPipes())
+			program, err := expr.Compile(test.input, expr.Env(env))
 			require.NoError(t, err)
 
 			out, err := expr.Run(program, env)
@@ -48,7 +48,7 @@ func TestPipes(t *testing.T) {
 }
 
 func TestPipes_map_filter(t *testing.T) {
-	program, err := expr.Compile(`1..9 | map(# + 1) | filter(# % 2 == 0)`, expr.ExperimentalPipes())
+	program, err := expr.Compile(`1..9 | map(# + 1) | filter(# % 2 == 0)`)
 	require.NoError(t, err)
 
 	out, err := expr.Run(program, nil)

From 881dad50f8f9d69ec68d0373ed69e5ed259128de Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 24 Aug 2023 15:27:00 +0200
Subject: [PATCH 121/506] Add parsing support for pointer names

---
 parser/parser.go      | 13 ++++++-------
 parser/parser_test.go | 34 ++++++++++++++++++++++------------
 2 files changed, 28 insertions(+), 19 deletions(-)

diff --git a/parser/parser.go b/parser/parser.go
index 108b201a7..f60ff8936 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -46,7 +46,6 @@ type Tree struct {
 
 func Parse(input string) (*Tree, error) {
 	return ParseWithConfig(input, &conf.Config{
-		Pipes:    false,
 		Disabled: map[string]bool{},
 	})
 }
@@ -255,10 +254,15 @@ func (p *parser) parsePrimary() Node {
 
 	if p.depth > 0 {
 		if token.Is(Operator, "#") || token.Is(Operator, ".") {
+			name := ""
 			if token.Is(Operator, "#") {
 				p.next()
+				if p.current.Is(Identifier) {
+					name = p.current.Value
+					p.next()
+				}
 			}
-			node := &PointerNode{}
+			node := &PointerNode{Name: name}
 			node.SetLocation(token.Location)
 			return p.parsePostfixExpression(node)
 		}
@@ -583,11 +587,6 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 }
 
 func (p *parser) parsePipe(node Node) Node {
-	if !p.config.Pipes {
-		p.error("enable Pipes via expr.ExperimentalPipes()")
-		return &NilNode{}
-	}
-
 	identifier := p.current
 	p.expect(Identifier)
 
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 002f1f34b..07cbef22a 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -6,16 +6,15 @@ import (
 	"testing"
 
 	. "github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/conf"
 	"github.com/antonmedv/expr/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestParse(t *testing.T) {
-	parseTests := []struct {
-		input    string
-		expected Node
+	tests := []struct {
+		input string
+		want  Node
 	}{
 		{
 			"a",
@@ -463,14 +462,25 @@ func TestParse(t *testing.T) {
 					Left:  &IdentifierNode{Value: "foo"},
 					Right: &IdentifierNode{Value: "c"}}},
 		},
+		{
+			`map([], #index)`,
+			&BuiltinNode{
+				Name: "map",
+				Arguments: []Node{
+					&ArrayNode{},
+					&ClosureNode{
+						Node: &PointerNode{Name: "index"},
+					},
+				},
+			},
+		},
 	}
-	for _, test := range parseTests {
-		actual, err := parser.ParseWithConfig(test.input, &conf.Config{Pipes: true})
-		if err != nil {
-			t.Errorf("%s:\n%v", test.input, err)
-			continue
-		}
-		assert.Equal(t, Dump(test.expected), Dump(actual.Node), test.input)
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			actual, err := parser.Parse(test.input)
+			require.NoError(t, err)
+			assert.Equal(t, Dump(test.want), Dump(actual.Node))
+		})
 	}
 }
 
@@ -669,7 +679,7 @@ func TestParse_pipe_operator(t *testing.T) {
 									Property: &StringNode{Value: "foo"},
 								}}}}}}}}
 
-	actual, err := parser.ParseWithConfig(input, &conf.Config{Pipes: true})
+	actual, err := parser.Parse(input)
 	require.NoError(t, err)
 	assert.Equal(t, Dump(expect), Dump(actual.Node))
 }

From d8701c560377481815cc8cbbc019bab968e838d5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 25 Aug 2023 11:23:44 +0200
Subject: [PATCH 122/506] Add named pointers #index

---
 checker/checker.go      | 159 +++++++++++++++-----------
 checker/checker_test.go | 246 +++++++++++++++++++++-------------------
 compiler/compiler.go    |  11 +-
 3 files changed, 228 insertions(+), 188 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 20e270f2c..ea63ded5a 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -18,11 +18,7 @@ func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
 		config = conf.New(nil)
 	}
 
-	v := &visitor{
-		config:      config,
-		collections: make([]reflect.Type, 0),
-		parents:     make([]ast.Node, 0),
-	}
+	v := &checker{config: config}
 
 	t, _ = v.visit(tree.Node)
 
@@ -55,15 +51,20 @@ func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
 	return t, nil
 }
 
-type visitor struct {
-	config      *conf.Config
-	collections []reflect.Type
-	scopes      []scope
-	parents     []ast.Node
-	err         *file.Error
+type checker struct {
+	config          *conf.Config
+	predicateScopes []predicateScope
+	varScopes       []varScope
+	parents         []ast.Node
+	err             *file.Error
+}
+
+type predicateScope struct {
+	vtype reflect.Type
+	vars  map[string]reflect.Type
 }
 
-type scope struct {
+type varScope struct {
 	name  string
 	vtype reflect.Type
 	info  info
@@ -74,7 +75,7 @@ type info struct {
 	fn     *builtin.Function
 }
 
-func (v *visitor) visit(node ast.Node) (reflect.Type, info) {
+func (v *checker) visit(node ast.Node) (reflect.Type, info) {
 	var t reflect.Type
 	var i info
 	v.parents = append(v.parents, node)
@@ -129,7 +130,7 @@ func (v *visitor) visit(node ast.Node) (reflect.Type, info) {
 	return t, i
 }
 
-func (v *visitor) error(node ast.Node, format string, args ...interface{}) (reflect.Type, info) {
+func (v *checker) error(node ast.Node, format string, args ...interface{}) (reflect.Type, info) {
 	if v.err == nil { // show first error
 		v.err = &file.Error{
 			Location: node.Location(),
@@ -139,11 +140,11 @@ func (v *visitor) error(node ast.Node, format string, args ...interface{}) (refl
 	return anyType, info{} // interface represent undefined type
 }
 
-func (v *visitor) NilNode(*ast.NilNode) (reflect.Type, info) {
+func (v *checker) NilNode(*ast.NilNode) (reflect.Type, info) {
 	return nilType, info{}
 }
 
-func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info) {
+func (v *checker) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info) {
 	if s, ok := v.lookupVariable(node.Value); ok {
 		return s.vtype, s.info
 	}
@@ -174,27 +175,27 @@ func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 	return anyType, info{}
 }
 
-func (v *visitor) IntegerNode(*ast.IntegerNode) (reflect.Type, info) {
+func (v *checker) IntegerNode(*ast.IntegerNode) (reflect.Type, info) {
 	return integerType, info{}
 }
 
-func (v *visitor) FloatNode(*ast.FloatNode) (reflect.Type, info) {
+func (v *checker) FloatNode(*ast.FloatNode) (reflect.Type, info) {
 	return floatType, info{}
 }
 
-func (v *visitor) BoolNode(*ast.BoolNode) (reflect.Type, info) {
+func (v *checker) BoolNode(*ast.BoolNode) (reflect.Type, info) {
 	return boolType, info{}
 }
 
-func (v *visitor) StringNode(*ast.StringNode) (reflect.Type, info) {
+func (v *checker) StringNode(*ast.StringNode) (reflect.Type, info) {
 	return stringType, info{}
 }
 
-func (v *visitor) ConstantNode(node *ast.ConstantNode) (reflect.Type, info) {
+func (v *checker) ConstantNode(node *ast.ConstantNode) (reflect.Type, info) {
 	return reflect.TypeOf(node.Value), info{}
 }
 
-func (v *visitor) UnaryNode(node *ast.UnaryNode) (reflect.Type, info) {
+func (v *checker) UnaryNode(node *ast.UnaryNode) (reflect.Type, info) {
 	t, _ := v.visit(node.Node)
 
 	t = deref(t)
@@ -224,7 +225,7 @@ func (v *visitor) UnaryNode(node *ast.UnaryNode) (reflect.Type, info) {
 	return v.error(node, `invalid operation: %v (mismatched type %v)`, node.Operator, t)
 }
 
-func (v *visitor) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
+func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 	l, _ := v.visit(node.Left)
 	r, _ := v.visit(node.Right)
 
@@ -423,11 +424,11 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 	return v.error(node, `invalid operation: %v (mismatched types %v and %v)`, node.Operator, l, r)
 }
 
-func (v *visitor) ChainNode(node *ast.ChainNode) (reflect.Type, info) {
+func (v *checker) ChainNode(node *ast.ChainNode) (reflect.Type, info) {
 	return v.visit(node.Node)
 }
 
-func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
+func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 	base, _ := v.visit(node.Node)
 	prop, _ := v.visit(node.Property)
 
@@ -507,7 +508,7 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 	return v.error(node, "type %v[%v] is undefined", base, prop)
 }
 
-func (v *visitor) SliceNode(node *ast.SliceNode) (reflect.Type, info) {
+func (v *checker) SliceNode(node *ast.SliceNode) (reflect.Type, info) {
 	t, _ := v.visit(node.Node)
 
 	switch kind(t) {
@@ -534,7 +535,7 @@ func (v *visitor) SliceNode(node *ast.SliceNode) (reflect.Type, info) {
 	return t, info{}
 }
 
-func (v *visitor) CallNode(node *ast.CallNode) (reflect.Type, info) {
+func (v *checker) CallNode(node *ast.CallNode) (reflect.Type, info) {
 	fn, fnInfo := v.visit(node.Callee)
 
 	if fnInfo.fn != nil {
@@ -587,7 +588,7 @@ func (v *visitor) CallNode(node *ast.CallNode) (reflect.Type, info) {
 	return v.error(node, "%v is not callable", fn)
 }
 
-func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
+func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 	switch node.Name {
 	case "all", "none", "any", "one":
 		collection, _ := v.visit(node.Arguments[0])
@@ -595,9 +596,9 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
-		v.collections = append(v.collections, collection)
+		v.begin(collection)
 		closure, _ := v.visit(node.Arguments[1])
-		v.collections = v.collections[:len(v.collections)-1]
+		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
@@ -616,9 +617,9 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
-		v.collections = append(v.collections, collection)
+		v.begin(collection)
 		closure, _ := v.visit(node.Arguments[1])
-		v.collections = v.collections[:len(v.collections)-1]
+		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
@@ -640,9 +641,9 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
-		v.collections = append(v.collections, collection)
+		v.begin(collection, scopeVar{"index", integerType})
 		closure, _ := v.visit(node.Arguments[1])
-		v.collections = v.collections[:len(v.collections)-1]
+		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
@@ -658,9 +659,9 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
-		v.collections = append(v.collections, collection)
+		v.begin(collection)
 		closure, _ := v.visit(node.Arguments[1])
-		v.collections = v.collections[:len(v.collections)-1]
+		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
@@ -679,9 +680,9 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
-		v.collections = append(v.collections, collection)
+		v.begin(collection)
 		closure, _ := v.visit(node.Arguments[1])
-		v.collections = v.collections[:len(v.collections)-1]
+		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
@@ -703,9 +704,9 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
-		v.collections = append(v.collections, collection)
+		v.begin(collection)
 		closure, _ := v.visit(node.Arguments[1])
-		v.collections = v.collections[:len(v.collections)-1]
+		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
@@ -730,7 +731,24 @@ func (v *visitor) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 	return v.error(node, "unknown builtin %v", node.Name)
 }
 
-func (v *visitor) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
+type scopeVar struct {
+	name  string
+	vtype reflect.Type
+}
+
+func (v *checker) begin(vtype reflect.Type, vars ...scopeVar) {
+	scope := predicateScope{vtype: vtype, vars: make(map[string]reflect.Type)}
+	for _, v := range vars {
+		scope.vars[v.name] = v.vtype
+	}
+	v.predicateScopes = append(v.predicateScopes, scope)
+}
+
+func (v *checker) end() {
+	v.predicateScopes = v.predicateScopes[:len(v.predicateScopes)-1]
+}
+
+func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
 	if len(node.Arguments) != 2 {
 		return v.error(node, "invalid number of arguments (expected 2, got %d)", len(node.Arguments))
 	}
@@ -771,7 +789,7 @@ func (v *visitor) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
 	return v.error(val, "type %v does not support indexing", t)
 }
 
-func (v *visitor) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) (reflect.Type, info) {
+func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) (reflect.Type, info) {
 	if f.Validate != nil {
 		args := make([]reflect.Type, len(arguments))
 		for i, arg := range arguments {
@@ -812,7 +830,7 @@ func (v *visitor) checkFunction(f *builtin.Function, node ast.Node, arguments []
 	return v.error(node, "no matching overload for %v", f.Name)
 }
 
-func (v *visitor) checkArguments(name string, fn reflect.Type, method bool, arguments []ast.Node, node ast.Node) (reflect.Type, *file.Error) {
+func (v *checker) checkArguments(name string, fn reflect.Type, method bool, arguments []ast.Node, node ast.Node) (reflect.Type, *file.Error) {
 	if isAny(fn) {
 		return anyType, nil
 	}
@@ -896,7 +914,7 @@ func (v *visitor) checkArguments(name string, fn reflect.Type, method bool, argu
 	return fn.Out(0), nil
 }
 
-func (v *visitor) ClosureNode(node *ast.ClosureNode) (reflect.Type, info) {
+func (v *checker) ClosureNode(node *ast.ClosureNode) (reflect.Type, info) {
 	t, _ := v.visit(node.Node)
 	if t == nil {
 		return v.error(node.Node, "closure cannot be nil")
@@ -904,22 +922,29 @@ func (v *visitor) ClosureNode(node *ast.ClosureNode) (reflect.Type, info) {
 	return reflect.FuncOf([]reflect.Type{anyType}, []reflect.Type{t}, false), info{}
 }
 
-func (v *visitor) PointerNode(node *ast.PointerNode) (reflect.Type, info) {
-	if len(v.collections) == 0 {
+func (v *checker) PointerNode(node *ast.PointerNode) (reflect.Type, info) {
+	if len(v.predicateScopes) == 0 {
 		return v.error(node, "cannot use pointer accessor outside closure")
 	}
-
-	collection := v.collections[len(v.collections)-1]
-	switch collection.Kind() {
-	case reflect.Interface:
-		return anyType, info{}
-	case reflect.Array, reflect.Slice:
-		return collection.Elem(), info{}
+	scope := v.predicateScopes[len(v.predicateScopes)-1]
+	if node.Name == "" {
+		switch scope.vtype.Kind() {
+		case reflect.Interface:
+			return anyType, info{}
+		case reflect.Array, reflect.Slice:
+			return scope.vtype.Elem(), info{}
+		}
+		return v.error(node, "cannot use %v as array", scope)
+	}
+	if scope.vars != nil {
+		if t, ok := scope.vars[node.Name]; ok {
+			return t, info{}
+		}
 	}
-	return v.error(node, "cannot use %v as array", collection)
+	return v.error(node, "unknown pointer #%v", node.Name)
 }
 
-func (v *visitor) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (reflect.Type, info) {
+func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (reflect.Type, info) {
 	if _, ok := v.config.Types[node.Name]; ok {
 		return v.error(node, "cannot redeclare %v", node.Name)
 	}
@@ -933,22 +958,22 @@ func (v *visitor) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (refl
 		return v.error(node, "cannot redeclare variable %v", node.Name)
 	}
 	vtype, vinfo := v.visit(node.Value)
-	v.scopes = append(v.scopes, scope{node.Name, vtype, vinfo})
+	v.varScopes = append(v.varScopes, varScope{node.Name, vtype, vinfo})
 	t, i := v.visit(node.Expr)
-	v.scopes = v.scopes[:len(v.scopes)-1]
+	v.varScopes = v.varScopes[:len(v.varScopes)-1]
 	return t, i
 }
 
-func (v *visitor) lookupVariable(name string) (scope, bool) {
-	for i := len(v.scopes) - 1; i >= 0; i-- {
-		if v.scopes[i].name == name {
-			return v.scopes[i], true
+func (v *checker) lookupVariable(name string) (varScope, bool) {
+	for i := len(v.varScopes) - 1; i >= 0; i-- {
+		if v.varScopes[i].name == name {
+			return v.varScopes[i], true
 		}
 	}
-	return scope{}, false
+	return varScope{}, false
 }
 
-func (v *visitor) ConditionalNode(node *ast.ConditionalNode) (reflect.Type, info) {
+func (v *checker) ConditionalNode(node *ast.ConditionalNode) (reflect.Type, info) {
 	c, _ := v.visit(node.Cond)
 	if !isBool(c) && !isAny(c) {
 		return v.error(node.Cond, "non-bool expression (type %v) used as condition", c)
@@ -972,27 +997,27 @@ func (v *visitor) ConditionalNode(node *ast.ConditionalNode) (reflect.Type, info
 	return anyType, info{}
 }
 
-func (v *visitor) ArrayNode(node *ast.ArrayNode) (reflect.Type, info) {
+func (v *checker) ArrayNode(node *ast.ArrayNode) (reflect.Type, info) {
 	for _, node := range node.Nodes {
 		v.visit(node)
 	}
 	return arrayType, info{}
 }
 
-func (v *visitor) MapNode(node *ast.MapNode) (reflect.Type, info) {
+func (v *checker) MapNode(node *ast.MapNode) (reflect.Type, info) {
 	for _, pair := range node.Pairs {
 		v.visit(pair)
 	}
 	return mapType, info{}
 }
 
-func (v *visitor) PairNode(node *ast.PairNode) (reflect.Type, info) {
+func (v *checker) PairNode(node *ast.PairNode) (reflect.Type, info) {
 	v.visit(node.Key)
 	v.visit(node.Value)
 	return nilType, info{}
 }
 
-func (v *visitor) findTypedFunc(node *ast.CallNode, fn reflect.Type, method bool) {
+func (v *checker) findTypedFunc(node *ast.CallNode, fn reflect.Type, method bool) {
 	// OnCallTyped doesn't work for functions with variadic arguments,
 	// and doesn't work named function, like `type MyFunc func() int`.
 	// In PkgPath() is an empty string, it's unnamed function.
diff --git a/checker/checker_test.go b/checker/checker_test.go
index c451736ef..0dede3edf 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -17,128 +17,131 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-var successTests = []string{
-	"nil == nil",
-	"nil == IntPtr",
-	"nil == nil",
-	"nil in ArrayOfFoo",
-	"!Bool",
-	"!BoolPtr == Bool",
-	"'a' == 'b' + 'c'",
-	"'foo' contains 'bar'",
-	"'foo' endsWith 'bar'",
-	"'foo' startsWith 'bar'",
-	"(1 == 1) || (String matches Any)",
-	"Int % Int > 1",
-	"Int + Int + Int > 0",
-	"Int == Any",
-	"Int in Int..Int",
-	"IntPtrPtr + 1 > 0",
-	"1 + 2 + Int64 > 0",
-	"Int64 % 1 > 0",
-	"IntPtr == Int",
-	"FloatPtr == 1 + 2.",
-	"1 + 2 + Float + 3 + 4 < 0",
-	"1 + Int + Float == 0.5",
-	"-1 + +1 == 0",
-	"1 / 2 == 0",
-	"2**3 + 1 != 0",
-	"2^3 + 1 != 0",
-	"Float == 1",
-	"Float < 1.0",
-	"Float <= 1.0",
-	"Float > 1.0",
-	"Float >= 1.0",
-	`"a" < "b"`,
-	"String + (true ? String : String) == ''",
-	"(Any ? nil : '') == ''",
-	"(Any ? 0 : nil) == 0",
-	"(Any ? nil : nil) == nil",
-	"!(Any ? Foo : Foo.Bar).Anything",
-	"Int in ArrayOfInt",
-	"Int not in ArrayOfAny",
-	"String in ArrayOfAny",
-	"String in ArrayOfString",
-	"String in Foo",
-	"String in MapOfFoo",
-	"String matches 'ok'",
-	"String matches Any",
-	"String not matches Any",
-	"StringPtr == nil",
-	"[1, 2, 3] == []",
-	"len([]) > 0",
-	"Any matches Any",
-	"!Any.Things.Contains.Any",
-	"!ArrayOfAny[0].next.goes['any thing']",
-	"ArrayOfFoo[0].Bar.Baz == ''",
-	"ArrayOfFoo[0:10][0].Bar.Baz == ''",
-	"!ArrayOfAny[Any]",
-	"Bool && Any",
-	"FuncParam(true, 1, 'str')",
-	"FuncParamAny(nil)",
-	"!Fast(Any, String)",
-	"Foo.Method().Baz == ''",
-	"Foo.Bar == MapOfAny.id.Bar",
-	"Foo.Bar.Baz == ''",
-	"MapOfFoo['any'].Bar.Baz == ''",
-	"Func() == 0",
-	"FuncFoo(Foo) > 1",
-	"Any() > 0",
-	"Embed.EmbedString == ''",
-	"EmbedString == ''",
-	"EmbedMethod(0) == ''",
-	"Embed.EmbedMethod(0) == ''",
-	"Embed.EmbedString == ''",
-	"EmbedString == ''",
-	"{id: Foo.Bar.Baz, 'str': String} == {}",
-	"Variadic(0, 1, 2) || Variadic(0)",
-	"count(1..30, {# % 3 == 0}) > 0",
-	"map(1..3, {#}) == [1,2,3]",
-	"map(filter(ArrayOfFoo, {.Bar.Baz != ''}), {.Bar}) == []",
-	"filter(Any, {.AnyMethod()})[0] == ''",
-	"Time == Time",
-	"Any == Time",
-	"Any != Time",
-	"Any > Time",
-	"Any >= Time",
-	"Any < Time",
-	"Any <= Time",
-	"Any - Time > Duration",
-	"Any == Any",
-	"Any != Any",
-	"Any > Any",
-	"Any >= Any",
-	"Any < Any",
-	"Any <= Any",
-	"Any - Any < Duration",
-	"Time == Any",
-	"Time != Any",
-	"Time > Any",
-	"Time >= Any",
-	"Time < Any",
-	"Time <= Any",
-	"Time - Any == Duration",
-	"Time + Duration == Time",
-	"Duration + Time == Time",
-	"Duration + Any == Time",
-	"Any + Duration == Time",
-	"Any.A?.B == nil",
-	"(Any.Bool ?? Bool) > 0",
-	"Bool ?? Bool",
-	"let foo = 1; foo == 1",
-}
-
 func TestCheck(t *testing.T) {
-	for _, input := range successTests {
-		var err error
-		tree, err := parser.Parse(input)
-		require.NoError(t, err, input)
+	var tests = []struct{ input string }{
+		{"nil == nil"},
+		{"nil == IntPtr"},
+		{"nil == nil"},
+		{"nil in ArrayOfFoo"},
+		{"!Bool"},
+		{"!BoolPtr == Bool"},
+		{"'a' == 'b' + 'c'"},
+		{"'foo' contains 'bar'"},
+		{"'foo' endsWith 'bar'"},
+		{"'foo' startsWith 'bar'"},
+		{"(1 == 1) || (String matches Any)"},
+		{"Int % Int > 1"},
+		{"Int + Int + Int > 0"},
+		{"Int == Any"},
+		{"Int in Int..Int"},
+		{"IntPtrPtr + 1 > 0"},
+		{"1 + 2 + Int64 > 0"},
+		{"Int64 % 1 > 0"},
+		{"IntPtr == Int"},
+		{"FloatPtr == 1 + 2."},
+		{"1 + 2 + Float + 3 + 4 < 0"},
+		{"1 + Int + Float == 0.5"},
+		{"-1 + +1 == 0"},
+		{"1 / 2 == 0"},
+		{"2**3 + 1 != 0"},
+		{"2^3 + 1 != 0"},
+		{"Float == 1"},
+		{"Float < 1.0"},
+		{"Float <= 1.0"},
+		{"Float > 1.0"},
+		{"Float >= 1.0"},
+		{`"a" < "b"`},
+		{"String + (true ? String : String) == ''"},
+		{"(Any ? nil : '') == ''"},
+		{"(Any ? 0 : nil) == 0"},
+		{"(Any ? nil : nil) == nil"},
+		{"!(Any ? Foo : Foo.Bar).Anything"},
+		{"Int in ArrayOfInt"},
+		{"Int not in ArrayOfAny"},
+		{"String in ArrayOfAny"},
+		{"String in ArrayOfString"},
+		{"String in Foo"},
+		{"String in MapOfFoo"},
+		{"String matches 'ok'"},
+		{"String matches Any"},
+		{"String not matches Any"},
+		{"StringPtr == nil"},
+		{"[1, 2, 3] == []"},
+		{"len([]) > 0"},
+		{"Any matches Any"},
+		{"!Any.Things.Contains.Any"},
+		{"!ArrayOfAny[0].next.goes['any thing']"},
+		{"ArrayOfFoo[0].Bar.Baz == ''"},
+		{"ArrayOfFoo[0:10][0].Bar.Baz == ''"},
+		{"!ArrayOfAny[Any]"},
+		{"Bool && Any"},
+		{"FuncParam(true, 1, 'str')"},
+		{"FuncParamAny(nil)"},
+		{"!Fast(Any, String)"},
+		{"Foo.Method().Baz == ''"},
+		{"Foo.Bar == MapOfAny.id.Bar"},
+		{"Foo.Bar.Baz == ''"},
+		{"MapOfFoo['any'].Bar.Baz == ''"},
+		{"Func() == 0"},
+		{"FuncFoo(Foo) > 1"},
+		{"Any() > 0"},
+		{"Embed.EmbedString == ''"},
+		{"EmbedString == ''"},
+		{"EmbedMethod(0) == ''"},
+		{"Embed.EmbedMethod(0) == ''"},
+		{"Embed.EmbedString == ''"},
+		{"EmbedString == ''"},
+		{"{id: Foo.Bar.Baz, 'str': String} == {}"},
+		{"Variadic(0, 1, 2) || Variadic(0)"},
+		{"count(1..30, {# % 3 == 0}) > 0"},
+		{"map(1..3, {#}) == [1,2,3]"},
+		{"map(1..3, #index) == [0,1,2]"},
+		{"map(filter(ArrayOfFoo, {.Bar.Baz != ''}), {.Bar}) == []"},
+		{"filter(Any, {.AnyMethod()})[0] == ''"},
+		{"Time == Time"},
+		{"Any == Time"},
+		{"Any != Time"},
+		{"Any > Time"},
+		{"Any >= Time"},
+		{"Any < Time"},
+		{"Any <= Time"},
+		{"Any - Time > Duration"},
+		{"Any == Any"},
+		{"Any != Any"},
+		{"Any > Any"},
+		{"Any >= Any"},
+		{"Any < Any"},
+		{"Any <= Any"},
+		{"Any - Any < Duration"},
+		{"Time == Any"},
+		{"Time != Any"},
+		{"Time > Any"},
+		{"Time >= Any"},
+		{"Time < Any"},
+		{"Time <= Any"},
+		{"Time - Any == Duration"},
+		{"Time + Duration == Time"},
+		{"Duration + Time == Time"},
+		{"Duration + Any == Time"},
+		{"Any + Duration == Time"},
+		{"Any.A?.B == nil"},
+		{"(Any.Bool ?? Bool) > 0"},
+		{"Bool ?? Bool"},
+		{"let foo = 1; foo == 1"},
+	}
 
-		config := conf.New(mock.Env{})
-		expr.AsBool()(config)
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			var err error
+			tree, err := parser.Parse(tt.input)
+			require.NoError(t, err)
 
-		_, err = checker.Check(tree, config)
-		assert.NoError(t, err, input)
+			config := conf.New(mock.Env{})
+			expr.AsBool()(config)
+
+			_, err = checker.Check(tree, config)
+			assert.NoError(t, err)
+		})
 	}
 }
 
@@ -532,6 +535,11 @@ let foo = 1; let foo = 2; foo
 cannot redeclare variable foo (1:18)
  | let foo = 1; let foo = 2; foo
  | .................^
+
+map(1..9, #unknown)
+unknown pointer #unknown (1:11)
+ | map(1..9, #unknown)
+ | ..........^
 `
 
 func TestCheck_error(t *testing.T) {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index b817a60ce..1455aac9e 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -877,8 +877,15 @@ func (c *compiler) ClosureNode(node *ast.ClosureNode) {
 	c.compile(node.Node)
 }
 
-func (c *compiler) PointerNode(_ *ast.PointerNode) {
-	c.emit(OpPointer)
+func (c *compiler) PointerNode(node *ast.PointerNode) {
+	switch node.Name {
+	case "index":
+		c.emit(OpGetIndex)
+	case "":
+		c.emit(OpPointer)
+	default:
+		panic(fmt.Sprintf("unknown pointer %v", node.Name))
+	}
 }
 
 func (c *compiler) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) {

From 3ffdbf3397ae8c592f634e10cbcc74eb21a3e5fc Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 25 Aug 2023 15:50:57 +0200
Subject: [PATCH 123/506] Add better pointer lexer

---
 checker/checker_test.go    |  4 +++-
 parser/lexer/lexer_test.go | 11 +++++++++++
 parser/lexer/state.go      | 20 +++++++++++++++++++-
 3 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/checker/checker_test.go b/checker/checker_test.go
index 0dede3edf..eeade988a 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -18,7 +18,9 @@ import (
 )
 
 func TestCheck(t *testing.T) {
-	var tests = []struct{ input string }{
+	var tests = []struct {
+		input string
+	}{
 		{"nil == nil"},
 		{"nil == IntPtr"},
 		{"nil == nil"},
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index 1a9418068..031966108 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -199,6 +199,17 @@ func TestLex(t *testing.T) {
 				{Kind: EOF},
 			},
 		},
+		{
+			`#index #1 #`,
+			[]Token{
+				{Kind: Operator, Value: "#"},
+				{Kind: Identifier, Value: "index"},
+				{Kind: Operator, Value: "#"},
+				{Kind: Identifier, Value: "1"},
+				{Kind: Operator, Value: "#"},
+				{Kind: EOF},
+			},
+		},
 	}
 
 	for _, test := range tests {
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index 8e1001b26..bb150878a 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -30,6 +30,8 @@ func root(l *lexer) stateFn {
 		return questionMark
 	case r == '/':
 		return slash
+	case r == '#':
+		return pointer
 	case r == '|':
 		l.accept("|")
 		l.emit(Operator)
@@ -37,7 +39,7 @@ func root(l *lexer) stateFn {
 		l.emit(Bracket)
 	case strings.ContainsRune(")]}", r):
 		l.emit(Bracket)
-	case strings.ContainsRune("#,:;%+-^", r): // single rune operator
+	case strings.ContainsRune(",:;%+-^", r): // single rune operator
 		l.emit(Operator)
 	case strings.ContainsRune("&!=*<>", r): // possible double rune operator
 		l.accept("&=*")
@@ -203,3 +205,19 @@ func multiLineComment(l *lexer) stateFn {
 	l.ignore()
 	return root
 }
+
+func pointer(l *lexer) stateFn {
+	l.accept("#")
+	l.emit(Operator)
+	for {
+		switch r := l.next(); {
+		case utils.IsAlphaNumeric(r): // absorb
+		default:
+			l.backup()
+			if l.word() != "" {
+				l.emit(Identifier)
+			}
+			return root
+		}
+	}
+}

From 3a29e6bdce6d3fabfd533d5d8e7c741aaac008d9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 28 Aug 2023 11:23:57 +0200
Subject: [PATCH 124/506] Add sort builtin

---
 ast/func.go             |  12 ++++
 ast/node.go             |   3 +-
 builtin/builtin.go      | 151 +++++++++++++++++++++++++++++++++-------
 builtin/builtin_test.go |  33 ++++++++-
 builtin/sort.go         |  91 ++++++++++++++++++++++++
 builtin/utils.go        |  30 ++++++++
 checker/checker.go      |   4 +-
 compiler/compiler.go    |   6 +-
 conf/config.go          |   8 +--
 debug/debugger.go       |   3 +-
 debug/go.mod            |  12 +++-
 debug/go.sum            |  19 +----
 expr.go                 |   3 +-
 vm/vm.go                |   2 +-
 14 files changed, 314 insertions(+), 63 deletions(-)
 create mode 100644 ast/func.go
 create mode 100644 builtin/sort.go

diff --git a/ast/func.go b/ast/func.go
new file mode 100644
index 000000000..92be2a197
--- /dev/null
+++ b/ast/func.go
@@ -0,0 +1,12 @@
+package ast
+
+import "reflect"
+
+type Function struct {
+	Name      string
+	Func      func(args ...interface{}) (interface{}, error)
+	Fast      func(arg interface{}) interface{}
+	Types     []reflect.Type
+	Validate  func(args []reflect.Type) (reflect.Type, error)
+	Predicate bool
+}
diff --git a/ast/node.go b/ast/node.go
index d228e52ee..3f083dfc6 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -4,7 +4,6 @@ import (
 	"reflect"
 	"regexp"
 
-	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/file"
 )
 
@@ -126,7 +125,7 @@ type CallNode struct {
 	Arguments []Node
 	Typed     int
 	Fast      bool
-	Func      *builtin.Function
+	Func      *Function
 }
 
 type BuiltinNode struct {
diff --git a/builtin/builtin.go b/builtin/builtin.go
index 64d705fd8..cc7a081ee 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -5,21 +5,14 @@ import (
 	"encoding/json"
 	"fmt"
 	"reflect"
+	"sort"
 	"strings"
 	"time"
 
+	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/vm/runtime"
 )
 
-type Function struct {
-	Name      string
-	Func      func(args ...interface{}) (interface{}, error)
-	Types     []reflect.Type
-	Builtin1  func(arg interface{}) interface{}
-	Validate  func(args []reflect.Type) (reflect.Type, error)
-	Predicate bool
-}
-
 var (
 	Index map[string]int
 	Names []string
@@ -34,7 +27,7 @@ func init() {
 	}
 }
 
-var Builtins = []*Function{
+var Builtins = []*ast.Function{
 	{
 		Name:      "all",
 		Predicate: true,
@@ -91,8 +84,8 @@ var Builtins = []*Function{
 		Types:     types(new(func([]interface{}, func(interface{}) bool) int)),
 	},
 	{
-		Name:     "len",
-		Builtin1: Len,
+		Name: "len",
+		Fast: Len,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
@@ -105,13 +98,13 @@ var Builtins = []*Function{
 		},
 	},
 	{
-		Name:     "type",
-		Builtin1: Type,
-		Types:    types(new(func(interface{}) string)),
+		Name:  "type",
+		Fast:  Type,
+		Types: types(new(func(interface{}) string)),
 	},
 	{
-		Name:     "abs",
-		Builtin1: Abs,
+		Name: "abs",
+		Fast: Abs,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
@@ -124,8 +117,8 @@ var Builtins = []*Function{
 		},
 	},
 	{
-		Name:     "int",
-		Builtin1: Int,
+		Name: "int",
+		Fast: Int,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
@@ -142,8 +135,8 @@ var Builtins = []*Function{
 		},
 	},
 	{
-		Name:     "float",
-		Builtin1: Float,
+		Name: "float",
+		Fast: Float,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
@@ -160,9 +153,9 @@ var Builtins = []*Function{
 		},
 	},
 	{
-		Name:     "string",
-		Builtin1: String,
-		Types:    types(new(func(any interface{}) string)),
+		Name:  "string",
+		Fast:  String,
+		Types: types(new(func(any interface{}) string)),
 	},
 	{
 		Name: "trim",
@@ -210,14 +203,14 @@ var Builtins = []*Function{
 	},
 	{
 		Name: "upper",
-		Builtin1: func(arg interface{}) interface{} {
+		Fast: func(arg interface{}) interface{} {
 			return strings.ToUpper(arg.(string))
 		},
 		Types: types(strings.ToUpper),
 	},
 	{
 		Name: "lower",
-		Builtin1: func(arg interface{}) interface{} {
+		Fast: func(arg interface{}) interface{} {
 			return strings.ToLower(arg.(string))
 		},
 		Types: types(strings.ToLower),
@@ -591,4 +584,110 @@ var Builtins = []*Function{
 			return anyType, fmt.Errorf("cannot get values from %s", args[0])
 		},
 	},
+	{
+		Name: "sort",
+		Func: func(args ...interface{}) (interface{}, error) {
+			if len(args) != 1 && len(args) != 2 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1 or 2, got %d)", len(args))
+			}
+
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+				return nil, fmt.Errorf("cannot sort %s", v.Kind())
+			}
+
+			orderBy := OrderBy{}
+			if len(args) == 2 {
+				dir, err := ascOrDesc(args[1])
+				if err != nil {
+					return nil, err
+				}
+				orderBy.Desc = dir
+			}
+
+			sortable, err := copyArray(v, orderBy)
+			if err != nil {
+				return nil, err
+			}
+			sort.Sort(sortable)
+			return sortable.Array, nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 && len(args) != 2 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1 or 2, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+			default:
+				return anyType, fmt.Errorf("cannot sort %s", args[0])
+			}
+			if len(args) == 2 {
+				switch kind(args[1]) {
+				case reflect.String, reflect.Interface:
+				default:
+					return anyType, fmt.Errorf("invalid argument for sort (expected string, got %s)", args[1])
+				}
+			}
+			return arrayType, nil
+		},
+	},
+	{
+		Name: "sortBy",
+		Func: func(args ...interface{}) (interface{}, error) {
+			if len(args) != 2 && len(args) != 3 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 2 or 3, got %d)", len(args))
+			}
+
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+				return nil, fmt.Errorf("cannot sort %s", v.Kind())
+			}
+
+			orderBy := OrderBy{}
+
+			field, ok := args[1].(string)
+			if !ok {
+				return nil, fmt.Errorf("invalid argument for sort (expected string, got %s)", reflect.TypeOf(args[1]))
+			}
+			orderBy.Field = field
+
+			if len(args) == 3 {
+				dir, err := ascOrDesc(args[2])
+				if err != nil {
+					return nil, err
+				}
+				orderBy.Desc = dir
+			}
+
+			sortable, err := copyArray(v, orderBy)
+			if err != nil {
+				return nil, err
+			}
+			sort.Sort(sortable)
+			return sortable.Array, nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 2 && len(args) != 3 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 2 or 3, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+			default:
+				return anyType, fmt.Errorf("cannot sort %s", args[0])
+			}
+			switch kind(args[1]) {
+			case reflect.String, reflect.Interface:
+			default:
+				return anyType, fmt.Errorf("invalid argument for sort (expected string, got %s)", args[1])
+			}
+			if len(args) == 3 {
+				switch kind(args[2]) {
+				case reflect.String, reflect.Interface:
+				default:
+					return anyType, fmt.Errorf("invalid argument for sort (expected string, got %s)", args[1])
+				}
+			}
+			return arrayType, nil
+		},
+	},
 }
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 873fff5ff..34704bdad 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -12,6 +12,7 @@ import (
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/conf"
 	"github.com/antonmedv/expr/parser"
+	"github.com/antonmedv/expr/test/mock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -109,7 +110,8 @@ func TestBuiltin_works_with_any(t *testing.T) {
 	config := map[string]struct {
 		arity int
 	}{
-		"get": {2},
+		"get":    {2},
+		"sortBy": {2},
 	}
 
 	for _, b := range builtin.Builtins {
@@ -365,3 +367,32 @@ func TestBuiltin_type(t *testing.T) {
 		})
 	}
 }
+
+func TestBuiltin_sort(t *testing.T) {
+	env := map[string]interface{}{
+		"ArrayOfString": []string{"foo", "bar", "baz"},
+		"ArrayOfInt":    []int{3, 2, 1},
+		"ArrayOfFoo":    []mock.Foo{{Value: "c"}, {Value: "a"}, {Value: "b"}},
+	}
+	tests := []struct {
+		input string
+		want  any
+	}{
+		{`sort([])`, []any{}},
+		{`sort(ArrayOfInt)`, []any{1, 2, 3}},
+		{`sort(ArrayOfInt, 'desc')`, []any{3, 2, 1}},
+		{`sortBy(ArrayOfFoo, 'Value')`, []any{mock.Foo{Value: "a"}, mock.Foo{Value: "b"}, mock.Foo{Value: "c"}}},
+		{`sortBy([{id: "a"}, {id: "b"}], "id", "desc")`, []any{map[string]any{"id": "b"}, map[string]any{"id": "a"}}},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			program, err := expr.Compile(test.input, expr.Env(env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, env)
+			require.NoError(t, err)
+			assert.Equal(t, test.want, out)
+		})
+	}
+}
diff --git a/builtin/sort.go b/builtin/sort.go
new file mode 100644
index 000000000..31e302c72
--- /dev/null
+++ b/builtin/sort.go
@@ -0,0 +1,91 @@
+package builtin
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type Sortable struct {
+	Array  []any
+	Values []reflect.Value
+	OrderBy
+}
+
+type OrderBy struct {
+	Field string
+	Desc  bool
+}
+
+func (s *Sortable) Len() int {
+	return len(s.Array)
+}
+
+func (s *Sortable) Swap(i, j int) {
+	s.Array[i], s.Array[j] = s.Array[j], s.Array[i]
+	s.Values[i], s.Values[j] = s.Values[j], s.Values[i]
+}
+
+func (s *Sortable) Less(i, j int) bool {
+	a, b := s.Values[i], s.Values[j]
+	switch a.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		if s.Desc {
+			return a.Int() > b.Int()
+		}
+		return a.Int() < b.Int()
+	case reflect.String:
+		if s.Desc {
+			return a.String() > b.String()
+		}
+		return a.String() < b.String()
+	default:
+		panic(fmt.Sprintf("sort: unsupported type %s", a.Kind()))
+	}
+}
+
+func copyArray(v reflect.Value, orderBy OrderBy) (*Sortable, error) {
+	s := &Sortable{
+		Array:   make([]any, v.Len()),
+		Values:  make([]reflect.Value, v.Len()),
+		OrderBy: orderBy,
+	}
+	var prev reflect.Value
+	for i := 0; i < s.Len(); i++ {
+		elem := deref(v.Index(i))
+		var value reflect.Value
+		switch elem.Kind() {
+		case reflect.Struct:
+			value = elem.FieldByName(s.Field)
+		case reflect.Map:
+			value = elem.MapIndex(reflect.ValueOf(s.Field))
+		default:
+			value = elem
+		}
+		value = deref(value)
+
+		s.Array[i] = elem.Interface()
+		s.Values[i] = value
+
+		if i == 0 {
+			prev = value
+		} else if value.Type() != prev.Type() {
+			return nil, fmt.Errorf("cannot sort array of different types (%s and %s)", value.Type(), prev.Type())
+		}
+	}
+	return s, nil
+}
+
+func ascOrDesc(arg any) (bool, error) {
+	dir, ok := arg.(string)
+	if !ok {
+		return false, fmt.Errorf("invalid argument for sort (expected string, got %s)", reflect.TypeOf(arg))
+	}
+	switch dir {
+	case "desc":
+		return true, nil
+	case "asc":
+		return false, nil
+	default:
+		return false, fmt.Errorf(`invalid argument for sort (expected "asc" or "desc", got %q)`, dir)
+	}
+}
diff --git a/builtin/utils.go b/builtin/utils.go
index afe169f76..9850b09a9 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -1,6 +1,7 @@
 package builtin
 
 import (
+	"fmt"
 	"reflect"
 )
 
@@ -33,3 +34,32 @@ func types(types ...interface{}) []reflect.Type {
 	}
 	return ts
 }
+
+func deref(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface {
+		if v.IsNil() {
+			return v
+		}
+		v = v.Elem()
+	}
+
+loop:
+	for v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			return v
+		}
+		indirect := reflect.Indirect(v)
+		switch indirect.Kind() {
+		case reflect.Struct, reflect.Map, reflect.Array, reflect.Slice:
+			break loop
+		default:
+			v = v.Elem()
+		}
+	}
+
+	if v.IsValid() {
+		return v
+	}
+
+	panic(fmt.Sprintf("cannot deref %s", v))
+}
diff --git a/checker/checker.go b/checker/checker.go
index ea63ded5a..8bb9a2839 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -72,7 +72,7 @@ type varScope struct {
 
 type info struct {
 	method bool
-	fn     *builtin.Function
+	fn     *ast.Function
 }
 
 func (v *checker) visit(node ast.Node) (reflect.Type, info) {
@@ -789,7 +789,7 @@ func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
 	return v.error(val, "type %v does not support indexing", t)
 }
 
-func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) (reflect.Type, info) {
+func (v *checker) checkFunction(f *ast.Function, node ast.Node, arguments []ast.Node) (reflect.Type, info) {
 	if f.Validate != nil {
 		args := make([]reflect.Type, len(arguments))
 		for i, arg := range arguments {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 1455aac9e..ecf2c5ba1 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -146,7 +146,7 @@ func (c *compiler) addVariable(name string) int {
 }
 
 // emitFunction adds builtin.Function.Func to the program.Functions and emits call opcode.
-func (c *compiler) emitFunction(fn *builtin.Function, argsLen int) {
+func (c *compiler) emitFunction(fn *ast.Function, argsLen int) {
 	switch argsLen {
 	case 0:
 		c.emit(OpCall0, c.addFunction(fn))
@@ -163,7 +163,7 @@ func (c *compiler) emitFunction(fn *builtin.Function, argsLen int) {
 }
 
 // addFunction adds builtin.Function.Func to the program.Functions and returns its index.
-func (c *compiler) addFunction(fn *builtin.Function) int {
+func (c *compiler) addFunction(fn *ast.Function) int {
 	if fn == nil {
 		panic("function is nil")
 	}
@@ -821,7 +821,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		for _, arg := range node.Arguments {
 			c.compile(arg)
 		}
-		if f.Builtin1 != nil {
+		if f.Fast != nil {
 			c.emit(OpCallBuiltin1, id)
 		} else if f.Func != nil {
 			c.emitFunction(f, len(node.Arguments))
diff --git a/conf/config.go b/conf/config.go
index 7e98e7ead..f44cfe7b1 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -21,8 +21,8 @@ type Config struct {
 	Strict      bool
 	ConstFns    map[string]reflect.Value
 	Visitors    []ast.Visitor
-	Functions   map[string]*builtin.Function
-	Builtins    map[string]*builtin.Function
+	Functions   map[string]*ast.Function
+	Builtins    map[string]*ast.Function
 	Disabled    map[string]bool // disabled builtins
 }
 
@@ -32,8 +32,8 @@ func CreateNew() *Config {
 		Optimize:  true,
 		Operators: make(map[string][]string),
 		ConstFns:  make(map[string]reflect.Value),
-		Functions: make(map[string]*builtin.Function),
-		Builtins:  make(map[string]*builtin.Function),
+		Functions: make(map[string]*ast.Function),
+		Builtins:  make(map[string]*ast.Function),
 		Disabled:  make(map[string]bool),
 	}
 	for _, f := range builtin.Builtins {
diff --git a/debug/debugger.go b/debug/debugger.go
index a002e0558..6bd66f977 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -123,9 +123,10 @@ func StartDebugger(program *Program, env interface{}) {
 			if s != nil {
 				type pair struct {
 					key   string
-					value int
+					value any
 				}
 				var keys []pair
+				keys = append(keys, pair{"Array", s.Array})
 				keys = append(keys, pair{"Index", s.Index})
 				keys = append(keys, pair{"Len", s.Len})
 				keys = append(keys, pair{"Count", s.Count})
diff --git a/debug/go.mod b/debug/go.mod
index 831ec776e..f8d73c9fb 100644
--- a/debug/go.mod
+++ b/debug/go.mod
@@ -1,13 +1,19 @@
 module github.com/antonmedv/expr/debug
 
-go 1.13
+go 1.18
 
 require (
-	github.com/antonmedv/expr v1.13.0
+	github.com/antonmedv/expr v0.0.0
 	github.com/gdamore/tcell/v2 v2.6.0
-	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703
+)
+
+require (
+	github.com/gdamore/encoding v1.0.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/rivo/uniseg v0.4.4 // indirect
+	golang.org/x/sys v0.11.0 // indirect
 	golang.org/x/term v0.11.0 // indirect
 	golang.org/x/text v0.12.0 // indirect
 )
diff --git a/debug/go.sum b/debug/go.sum
index e08364c2c..1078cbe99 100644
--- a/debug/go.sum
+++ b/debug/go.sum
@@ -1,6 +1,4 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
 github.com/gdamore/tcell/v2 v2.6.0 h1:OKbluoP9VYmJwZwq/iLb4BxwKcwGthaa1YNBJIyCySg=
@@ -11,32 +9,22 @@ github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh
 github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
 github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703 h1:ZyM/+FYnpbZsFWuCohniM56kRoHRB4r5EuIzXEYkpxo=
 github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703/go.mod h1:nVwGv4MP47T0jvlk7KuTTjjuSmrGO4JF0iaiNt4bufE=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -59,10 +47,5 @@ golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/expr.go b/expr.go
index 4c07ab43e..fa6e7101d 100644
--- a/expr.go
+++ b/expr.go
@@ -5,7 +5,6 @@ import (
 	"reflect"
 
 	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/compiler"
 	"github.com/antonmedv/expr/conf"
@@ -122,7 +121,7 @@ func Function(name string, fn func(params ...interface{}) (interface{}, error),
 			}
 			ts[i] = t
 		}
-		c.Functions[name] = &builtin.Function{
+		c.Functions[name] = &ast.Function{
 			Name:  name,
 			Func:  fn,
 			Types: ts,
diff --git a/vm/vm.go b/vm/vm.go
index f083e74c2..41390fe71 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -389,7 +389,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			vm.push(vm.call(vm.pop(), arg))
 
 		case OpCallBuiltin1:
-			vm.push(builtin.Builtins[arg].Builtin1(vm.pop()))
+			vm.push(builtin.Builtins[arg].Fast(vm.pop()))
 
 		case OpArray:
 			size := vm.pop().(int)

From 2dc1c7de303b02a9b38e3d7e4123916d671d5687 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 28 Aug 2023 17:26:52 +0200
Subject: [PATCH 125/506] Add sort benchmarks

---
 bench_test.go | 45 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/bench_test.go b/bench_test.go
index 024d2c4fb..a294bb06a 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -453,3 +453,48 @@ func Benchmark_largeNestedArrayAccess(b *testing.B) {
 	require.NoError(b, err)
 	require.True(b, out.(bool))
 }
+
+func Benchmark_sort(b *testing.B) {
+	env := map[string]interface{}{
+		"arr": []any{55, 58, 42, 61, 75, 52, 64, 62, 16, 79, 40, 14, 50, 76, 23, 2, 5, 80, 89, 51, 21, 96, 91, 13, 71, 82, 65, 63, 11, 17, 94, 81, 74, 4, 97, 1, 39, 3, 28, 8, 84, 90, 47, 85, 7, 56, 49, 93, 33, 12, 19, 60, 86, 100, 44, 45, 36, 72, 95, 77, 34, 92, 24, 73, 18, 38, 43, 26, 41, 69, 67, 57, 9, 27, 66, 87, 46, 35, 59, 70, 10, 20, 53, 15, 32, 98, 68, 31, 54, 25, 83, 88, 22, 48, 29, 37, 6, 78, 99, 30},
+	}
+
+	program, err := expr.Compile(`sort(arr)`, expr.Env(env))
+	require.NoError(b, err)
+
+	var out interface{}
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 1, out.([]any)[0])
+	require.Equal(b, 100, out.([]any)[99])
+}
+
+func Benchmark_sortBy(b *testing.B) {
+	type Foo struct {
+		Value int
+	}
+	arr := []any{55, 58, 42, 61, 75, 52, 64, 62, 16, 79, 40, 14, 50, 76, 23, 2, 5, 80, 89, 51, 21, 96, 91, 13, 71, 82, 65, 63, 11, 17, 94, 81, 74, 4, 97, 1, 39, 3, 28, 8, 84, 90, 47, 85, 7, 56, 49, 93, 33, 12, 19, 60, 86, 100, 44, 45, 36, 72, 95, 77, 34, 92, 24, 73, 18, 38, 43, 26, 41, 69, 67, 57, 9, 27, 66, 87, 46, 35, 59, 70, 10, 20, 53, 15, 32, 98, 68, 31, 54, 25, 83, 88, 22, 48, 29, 37, 6, 78, 99, 30}
+	env := map[string]interface{}{
+		"arr": make([]Foo, len(arr)),
+	}
+	for i, v := range arr {
+		env["arr"].([]Foo)[i] = Foo{Value: v.(int)}
+	}
+
+	program, err := expr.Compile(`sortBy(arr, "Value")`, expr.Env(env))
+	require.NoError(b, err)
+
+	var out interface{}
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 1, out.([]any)[0].(Foo).Value)
+	require.Equal(b, 100, out.([]any)[99].(Foo).Value)
+}

From e81f517f81a6fc91fc01134b7f76f731f1f3eb52 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 28 Aug 2023 17:36:33 +0200
Subject: [PATCH 126/506] Apply in range optimization only for int type on lhs

---
 optimizer/in_range.go       | 15 ++++++++++++---
 optimizer/optimizer_test.go | 10 ++++++++++
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/optimizer/in_range.go b/optimizer/in_range.go
index 7895249e0..b361c6c39 100644
--- a/optimizer/in_range.go
+++ b/optimizer/in_range.go
@@ -1,6 +1,8 @@
 package optimizer
 
 import (
+	"reflect"
+
 	. "github.com/antonmedv/expr/ast"
 )
 
@@ -10,9 +12,16 @@ func (*inRange) Visit(node *Node) {
 	switch n := (*node).(type) {
 	case *BinaryNode:
 		if n.Operator == "in" {
-			if rng, ok := n.Right.(*BinaryNode); ok && rng.Operator == ".." {
-				if from, ok := rng.Left.(*IntegerNode); ok {
-					if to, ok := rng.Right.(*IntegerNode); ok {
+			t := n.Left.Type()
+			if t == nil {
+				return
+			}
+			if t.Kind() != reflect.Int {
+				return
+			}
+			if rangeOp, ok := n.Right.(*BinaryNode); ok && rangeOp.Operator == ".." {
+				if from, ok := rangeOp.Left.(*IntegerNode); ok {
+					if to, ok := rangeOp.Right.(*IntegerNode); ok {
 						Patch(node, &BinaryNode{
 							Operator: "and",
 							Left: &BinaryNode{
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 948fc6e14..1616ebbb8 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -4,6 +4,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/conf"
@@ -77,6 +78,9 @@ func TestOptimize_in_range(t *testing.T) {
 	tree, err := parser.Parse(`age in 18..31`)
 	require.NoError(t, err)
 
+	config := conf.New(map[string]int{"age": 30})
+	_, err = checker.Check(tree, config)
+
 	err = optimizer.Optimize(&tree.Node, nil)
 	require.NoError(t, err)
 
@@ -104,6 +108,12 @@ func TestOptimize_in_range(t *testing.T) {
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
 
+func TestOptimize_in_range_with_floats(t *testing.T) {
+	out, err := expr.Eval(`f in 1..3`, map[string]any{"f": 1.5})
+	require.NoError(t, err)
+	assert.Equal(t, false, out)
+}
+
 func TestOptimize_const_range(t *testing.T) {
 	tree, err := parser.Parse(`-1..1`)
 	require.NoError(t, err)

From 4629871ec39fffeb8533b932927c8e9f362b8b55 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 28 Aug 2023 22:24:46 +0200
Subject: [PATCH 127/506] Fix float folding optimization

---
 checker/checker.go          | 23 ++++++++++--
 checker/types.go            | 37 --------------------
 expr_test.go                | 35 +++++++++++++------
 optimizer/fold.go           | 70 ++++++++++++++++++++++---------------
 optimizer/optimizer_test.go |  2 ++
 5 files changed, 89 insertions(+), 78 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 8bb9a2839..41b1b2c8c 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -894,9 +894,9 @@ func (v *checker) checkArguments(name string, fn reflect.Type, method bool, argu
 			in = fn.In(i + fnInOffset)
 		}
 
-		if isIntegerOrArithmeticOperation(arg) && (isInteger(in) || isFloat(in)) {
-			t = in
-			setTypeForIntegers(arg, t)
+		if isFloat(in) {
+			t = floatType
+			traverseAndReplaceIntegerNodesWithFloatNodes(&arg)
 		}
 
 		if t == nil {
@@ -914,6 +914,23 @@ func (v *checker) checkArguments(name string, fn reflect.Type, method bool, argu
 	return fn.Out(0), nil
 }
 
+func traverseAndReplaceIntegerNodesWithFloatNodes(node *ast.Node) {
+	switch (*node).(type) {
+	case *ast.IntegerNode:
+		*node = &ast.FloatNode{Value: float64((*node).(*ast.IntegerNode).Value)}
+	case *ast.UnaryNode:
+		unaryNode := (*node).(*ast.UnaryNode)
+		traverseAndReplaceIntegerNodesWithFloatNodes(&unaryNode.Node)
+	case *ast.BinaryNode:
+		binaryNode := (*node).(*ast.BinaryNode)
+		switch binaryNode.Operator {
+		case "+", "-", "*":
+			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Left)
+			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Right)
+		}
+	}
+}
+
 func (v *checker) ClosureNode(node *ast.ClosureNode) (reflect.Type, info) {
 	t, _ := v.visit(node.Node)
 	if t == nil {
diff --git a/checker/types.go b/checker/types.go
index d1a5e85e6..5248b760c 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -4,7 +4,6 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/conf"
 )
 
@@ -228,39 +227,3 @@ func kind(t reflect.Type) reflect.Kind {
 	}
 	return t.Kind()
 }
-
-func isIntegerOrArithmeticOperation(node ast.Node) bool {
-	switch n := node.(type) {
-	case *ast.IntegerNode:
-		return true
-	case *ast.UnaryNode:
-		switch n.Operator {
-		case "+", "-":
-			return true
-		}
-	case *ast.BinaryNode:
-		switch n.Operator {
-		case "+", "-", "*":
-			return true
-		}
-	}
-	return false
-}
-
-func setTypeForIntegers(node ast.Node, t reflect.Type) {
-	switch n := node.(type) {
-	case *ast.IntegerNode:
-		n.SetType(t)
-	case *ast.UnaryNode:
-		switch n.Operator {
-		case "+", "-":
-			setTypeForIntegers(n.Node, t)
-		}
-	case *ast.BinaryNode:
-		switch n.Operator {
-		case "+", "/", "-", "*":
-			setTypeForIntegers(n.Left, t)
-			setTypeForIntegers(n.Right, t)
-		}
-	}
-}
diff --git a/expr_test.go b/expr_test.go
index 78ef15cf1..f98e926e4 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1028,6 +1028,18 @@ func TestExpr(t *testing.T) {
 			`first(filter(map(1..9, # * 2), # % 2 == 0))`,
 			2,
 		},
+		{
+			`first(map(filter(1..9, # % 2 == 0), # * 2))`,
+			4,
+		},
+		{
+			`2^3 == 8`,
+			true,
+		},
+		{
+			`4/2 == 2`,
+			true,
+		},
 	}
 
 	for _, tt := range tests {
@@ -1198,13 +1210,13 @@ func TestExpr_calls_with_nil(t *testing.T) {
 	require.Equal(t, true, out)
 }
 
-func TestExpr_call_floatarg_func_with_int(t *testing.T) {
+func TestExpr_call_float_arg_func_with_int(t *testing.T) {
 	env := map[string]interface{}{
 		"cnv": func(f float64) interface{} {
 			return f
 		},
 	}
-	for _, each := range []struct {
+	tests := []struct {
 		input    string
 		expected float64
 	}{
@@ -1214,15 +1226,18 @@ func TestExpr_call_floatarg_func_with_int(t *testing.T) {
 		{"1-1", 0.0},
 		{"1/1", 1.0},
 		{"1*1", 1.0},
-	} {
-		p, err := expr.Compile(
-			fmt.Sprintf("cnv(%s)", each.input),
-			expr.Env(env))
-		require.NoError(t, err)
+		{"1^1", 1.0},
+	}
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			p, err := expr.Compile(fmt.Sprintf("cnv(%s)", tt.input), expr.Env(env))
+			require.NoError(t, err)
 
-		out, err := expr.Run(p, env)
-		require.NoError(t, err)
-		require.Equal(t, each.expected, out)
+			p.Disassemble()
+			out, err := expr.Run(p, env)
+			require.NoError(t, err)
+			require.Equal(t, tt.expected, out)
+		})
 	}
 }
 
diff --git a/optimizer/fold.go b/optimizer/fold.go
index b62b2d7ed..8d31a5cc5 100644
--- a/optimizer/fold.go
+++ b/optimizer/fold.go
@@ -1,6 +1,7 @@
 package optimizer
 
 import (
+	"fmt"
 	"math"
 	"reflect"
 
@@ -8,6 +9,12 @@ import (
 	"github.com/antonmedv/expr/file"
 )
 
+var (
+	integerType = reflect.TypeOf(0)
+	floatType   = reflect.TypeOf(float64(0))
+	stringType  = reflect.TypeOf("")
+)
+
 type fold struct {
 	applied bool
 	err     *file.Error
@@ -18,11 +25,18 @@ func (fold *fold) Visit(node *Node) {
 		fold.applied = true
 		Patch(node, newNode)
 	}
-	// for IntegerNode the type may have been changed from int->float
-	// preserve this information by setting the type after the Patch
-	patchWithType := func(newNode Node, leafType reflect.Type) {
+	patchWithType := func(newNode Node) {
 		patch(newNode)
-		newNode.SetType(leafType)
+		switch newNode.(type) {
+		case *IntegerNode:
+			newNode.SetType(integerType)
+		case *FloatNode:
+			newNode.SetType(floatType)
+		case *StringNode:
+			newNode.SetType(stringType)
+		default:
+			panic(fmt.Sprintf("unknown type %T", newNode))
+		}
 	}
 
 	switch n := (*node).(type) {
@@ -30,17 +44,17 @@ func (fold *fold) Visit(node *Node) {
 		switch n.Operator {
 		case "-":
 			if i, ok := n.Node.(*IntegerNode); ok {
-				patchWithType(&IntegerNode{Value: -i.Value}, n.Node.Type())
+				patchWithType(&IntegerNode{Value: -i.Value})
 			}
 			if i, ok := n.Node.(*FloatNode); ok {
-				patchWithType(&FloatNode{Value: -i.Value}, n.Node.Type())
+				patchWithType(&FloatNode{Value: -i.Value})
 			}
 		case "+":
 			if i, ok := n.Node.(*IntegerNode); ok {
-				patchWithType(&IntegerNode{Value: i.Value}, n.Node.Type())
+				patchWithType(&IntegerNode{Value: i.Value})
 			}
 			if i, ok := n.Node.(*FloatNode); ok {
-				patchWithType(&FloatNode{Value: i.Value}, n.Node.Type())
+				patchWithType(&FloatNode{Value: i.Value})
 			}
 		case "!", "not":
 			if a := toBool(n.Node); a != nil {
@@ -55,28 +69,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&IntegerNode{Value: a.Value + b.Value}, a.Type())
+					patchWithType(&IntegerNode{Value: a.Value + b.Value})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) + b.Value}, a.Type())
+					patchWithType(&FloatNode{Value: float64(a.Value) + b.Value})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value + float64(b.Value)}, a.Type())
+					patchWithType(&FloatNode{Value: a.Value + float64(b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value + b.Value}, a.Type())
+					patchWithType(&FloatNode{Value: a.Value + b.Value})
 				}
 			}
 			{
@@ -91,28 +105,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&IntegerNode{Value: a.Value - b.Value}, a.Type())
+					patchWithType(&IntegerNode{Value: a.Value - b.Value})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) - b.Value}, a.Type())
+					patchWithType(&FloatNode{Value: float64(a.Value) - b.Value})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value - float64(b.Value)}, a.Type())
+					patchWithType(&FloatNode{Value: a.Value - float64(b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value - b.Value}, a.Type())
+					patchWithType(&FloatNode{Value: a.Value - b.Value})
 				}
 			}
 		case "*":
@@ -120,28 +134,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&IntegerNode{Value: a.Value * b.Value}, a.Type())
+					patchWithType(&IntegerNode{Value: a.Value * b.Value})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) * b.Value}, a.Type())
+					patchWithType(&FloatNode{Value: float64(a.Value) * b.Value})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value * float64(b.Value)}, a.Type())
+					patchWithType(&FloatNode{Value: a.Value * float64(b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value * b.Value}, a.Type())
+					patchWithType(&FloatNode{Value: a.Value * b.Value})
 				}
 			}
 		case "/":
@@ -149,28 +163,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) / float64(b.Value)}, a.Type())
+					patchWithType(&FloatNode{Value: float64(a.Value) / float64(b.Value)})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) / b.Value}, a.Type())
+					patchWithType(&FloatNode{Value: float64(a.Value) / b.Value})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value / float64(b.Value)}, a.Type())
+					patchWithType(&FloatNode{Value: a.Value / float64(b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value / b.Value}, a.Type())
+					patchWithType(&FloatNode{Value: a.Value / b.Value})
 				}
 			}
 		case "%":
@@ -191,28 +205,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: math.Pow(float64(a.Value), float64(b.Value))}, a.Type())
+					patchWithType(&FloatNode{Value: math.Pow(float64(a.Value), float64(b.Value))})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: math.Pow(float64(a.Value), b.Value)}, a.Type())
+					patchWithType(&FloatNode{Value: math.Pow(float64(a.Value), b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: math.Pow(a.Value, float64(b.Value))}, a.Type())
+					patchWithType(&FloatNode{Value: math.Pow(a.Value, float64(b.Value))})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: math.Pow(a.Value, b.Value)}, a.Type())
+					patchWithType(&FloatNode{Value: math.Pow(a.Value, b.Value)})
 				}
 			}
 		case "and", "&&":
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 1616ebbb8..4f2130618 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -1,6 +1,7 @@
 package optimizer_test
 
 import (
+	"reflect"
 	"strings"
 	"testing"
 
@@ -39,6 +40,7 @@ func TestOptimize_constant_folding_with_floats(t *testing.T) {
 	expected := &ast.FloatNode{Value: 3.0}
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+	assert.Equal(t, reflect.Float64, tree.Node.Type().Kind())
 }
 
 func TestOptimize_constant_folding_with_bools(t *testing.T) {

From 578b265082c46d1433013a61b5e33684f16b99da Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 28 Aug 2023 22:27:43 +0200
Subject: [PATCH 128/506] Remove extra disassemble

---
 expr_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/expr_test.go b/expr_test.go
index f98e926e4..0bf03be5d 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1233,7 +1233,6 @@ func TestExpr_call_float_arg_func_with_int(t *testing.T) {
 			p, err := expr.Compile(fmt.Sprintf("cnv(%s)", tt.input), expr.Env(env))
 			require.NoError(t, err)
 
-			p.Disassemble()
 			out, err := expr.Run(p, env)
 			require.NoError(t, err)
 			require.Equal(t, tt.expected, out)

From 3d909203fce0a920089d0f312f0bfd1cb39b6330 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 29 Aug 2023 10:44:53 +0200
Subject: [PATCH 129/506] Update test gen

---
 test/gen/gen.go       |   236 +-
 testdata/examples.txt | 35965 ++++++++++++++++++----------------------
 2 files changed, 16123 insertions(+), 20078 deletions(-)

diff --git a/test/gen/gen.go b/test/gen/gen.go
index 7e1f433ed..a96a5f334 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"math/rand"
+	"reflect"
 	"runtime/debug"
 
 	"github.com/antonmedv/expr"
@@ -10,36 +11,101 @@ import (
 	"github.com/antonmedv/expr/builtin"
 )
 
-var env = map[string]interface{}{
-	"a":   1,
-	"b":   2,
-	"f":   0.5,
-	"ok":  true,
-	"s":   "abc",
-	"arr": []int{1, 2, 3},
-	"obj": map[string]interface{}{
-		"a": 1,
-		"b": 2,
-		"obj": map[string]interface{}{
-			"a": 1,
-			"b": 2,
-			"obj": map[string]int{
-				"a": 1,
-				"b": 2,
-			},
-		},
-		"fn":   func(a int) int { return a + 1 },
-		"head": func(xs ...interface{}) interface{} { return xs[0] },
+var env = map[string]any{
+	"ok":    true,
+	"f64":   .5,
+	"f32":   float32(.5),
+	"i":     1,
+	"i64":   int64(1),
+	"i32":   int32(1),
+	"array": []int{1, 2, 3, 4, 5},
+	"list":  []Foo{{"bar"}, {"baz"}},
+	"foo":   Foo{"bar"},
+	"add":   func(a, b int) int { return a + b },
+	"div":   func(a, b int) int { return a / b },
+	"half":  func(a float64) float64 { return a / 2 },
+	"score": func(a int, x ...int) int {
+		s := a
+		for _, n := range x {
+			s += n
+		}
+		return s
 	},
-	"add": func(a, b int) int { return a + b },
-	"div": func(a, b int) int { return a / b },
+	"greet": func(name string) string { return "Hello, " + name },
+}
+
+type Foo struct {
+	Bar string
+}
+
+func (f Foo) String() string {
+	return "foo"
+}
+
+func (f Foo) Qux(s string) string {
+	return f.Bar + s
 }
 
-var names []string
+var (
+	dict       []string
+	predicates []string
+	builtins   []string
+	operators  = []string{
+		"or",
+		"||",
+		"and",
+		"&&",
+		"==",
+		"!=",
+		"<",
+		">",
+		">=",
+		"<=",
+		"..",
+		"+",
+		"-",
+		"*",
+		"/",
+		"%",
+		"**",
+		"^",
+		"in",
+		"matches",
+		"contains",
+		"startsWith",
+		"endsWith",
+		"not in",
+		"not matches",
+		"not contains",
+		"not startsWith",
+		"not endsWith",
+	}
+)
 
 func init() {
-	for name := range env {
-		names = append(names, name)
+	for name, x := range env {
+		dict = append(dict, name)
+		v := reflect.ValueOf(x)
+		if v.Kind() == reflect.Struct {
+			for i := 0; i < v.NumField(); i++ {
+				dict = append(dict, v.Type().Field(i).Name)
+			}
+			for i := 0; i < v.NumMethod(); i++ {
+				dict = append(dict, v.Type().Method(i).Name)
+			}
+		}
+		if v.Kind() == reflect.Map {
+			for _, key := range v.MapKeys() {
+				dict = append(dict, fmt.Sprintf("%v", key.Interface()))
+			}
+		}
+	}
+	for _, b := range builtin.Builtins {
+		if b.Predicate {
+			predicates = append(predicates, b.Name)
+		} else {
+			builtins = append(builtins, b.Name)
+		}
 	}
 }
 
@@ -47,12 +113,13 @@ func main() {
 	var code string
 	defer func() {
 		if r := recover(); r != nil {
-			fmt.Printf("==========================\n%s\n==========================\n", code)
+			fmt.Printf("==========================\n%s\n==========================\n%s\n==========================\n", code, r)
 			debug.PrintStack()
 		}
 	}()
 
-	corpus := map[string]struct{}{}
+	var corpus = map[string]struct{}{}
+
 	for {
 		code = node(weightedRandomInt([]intWeight{
 			{3, 100},
@@ -91,6 +158,7 @@ func node(depth int) ast.Node {
 			{stringNode, 1},
 			{booleanNode, 1},
 			{identifierNode, 10},
+			{pointerNode, 10},
 		})(depth - 1)
 	}
 	return weightedRandom([]fnWeight{
@@ -109,58 +177,49 @@ func node(depth int) ast.Node {
 	})(depth - 1)
 }
 
-func nilNode(depth int) ast.Node {
+func nilNode(_ int) ast.Node {
 	return &ast.NilNode{}
 }
 
-func floatNode(depth int) ast.Node {
-	cases := []float64{
-		0.0,
-		0.5,
-	}
+func floatNode(_ int) ast.Node {
 	return &ast.FloatNode{
-		Value: cases[rand.Intn(len(cases))],
+		Value: .5,
 	}
 }
 
-func integerNode(depth int) ast.Node {
+func integerNode(_ int) ast.Node {
 	return &ast.IntegerNode{
-		Value: rand.Intn(3),
+		Value: 1,
 	}
 }
 
-func stringNode(depth int) ast.Node {
-	corpus := []string{
-		"a", "b", "c",
+func stringNode(_ int) ast.Node {
+	words := []string{
+		"foo",
+		"bar",
 	}
 	return &ast.StringNode{
-		Value: corpus[rand.Intn(len(corpus))],
+		Value: words[rand.Intn(len(words))],
 	}
 }
 
-func booleanNode(depth int) ast.Node {
+func booleanNode(_ int) ast.Node {
 	return &ast.BoolNode{
 		Value: maybe(),
 	}
 }
 
-func identifierNode(depth int) ast.Node {
+func identifierNode(_ int) ast.Node {
 	return &ast.IdentifierNode{
-		Value: names[rand.Intn(len(names))],
+		Value: dict[rand.Intn(len(dict))],
 	}
 }
 
 func memberNode(depth int) ast.Node {
-	cases := []string{
-		"a",
-		"b",
-		"obj",
-	}
-
 	return &ast.MemberNode{
 		Node: node(depth - 1),
 		Property: weightedRandom([]fnWeight{
-			{func(_ int) ast.Node { return &ast.StringNode{Value: cases[rand.Intn(len(cases))]} }, 5},
+			{func(_ int) ast.Node { return &ast.StringNode{Value: dict[rand.Intn(len(dict))]} }, 5},
 			{node, 1},
 		})(depth - 1),
 		Optional: maybe(),
@@ -168,11 +227,7 @@ func memberNode(depth int) ast.Node {
 }
 
 func unaryNode(depth int) ast.Node {
-	cases := []string{
-		"-",
-		"!",
-		"not",
-	}
+	cases := []string{"-", "!", "not"}
 	return &ast.UnaryNode{
 		Operator: cases[rand.Intn(len(cases))],
 		Node:     node(depth - 1),
@@ -180,65 +235,31 @@ func unaryNode(depth int) ast.Node {
 }
 
 func binaryNode(depth int) ast.Node {
-	cases := []string{
-		"or",
-		"||",
-		"and",
-		"&&",
-		"==",
-		"!=",
-		"<",
-		">",
-		">=",
-		"<=",
-		"in",
-		"matches",
-		"contains",
-		"startsWith",
-		"endsWith",
-		"..",
-		"+",
-		"-",
-		"*",
-		"/",
-		"%",
-		"**",
-		"^",
-	}
 	return &ast.BinaryNode{
-		Operator: cases[rand.Intn(len(cases))],
+		Operator: operators[rand.Intn(len(operators))],
 		Left:     node(depth - 1),
 		Right:    node(depth - 1),
 	}
 }
 
 func methodNode(depth int) ast.Node {
-	cases := []string{
-		"fn",
-		"head",
-	}
-
 	return &ast.MemberNode{
 		Node:     node(depth - 1),
-		Property: &ast.StringNode{Value: cases[rand.Intn(len(cases))]},
+		Property: &ast.StringNode{Value: dict[rand.Intn(len(dict))]},
 		Optional: maybe(),
 	}
 }
 
-func funcNode(depth int) ast.Node {
-	cases := []string{
-		"add",
-		"div",
-	}
-
+func funcNode(_ int) ast.Node {
 	return &ast.IdentifierNode{
-		Value: cases[rand.Intn(len(cases))],
+		Value: dict[rand.Intn(len(dict))],
 	}
 }
 
 func callNode(depth int) ast.Node {
 	var args []ast.Node
 	max := weightedRandomInt([]intWeight{
+		{0, 100},
 		{1, 100},
 		{2, 50},
 		{3, 25},
@@ -262,36 +283,29 @@ func builtinNode(depth int) ast.Node {
 	max := weightedRandomInt([]intWeight{
 		{1, 100},
 		{2, 50},
-		{3, 25},
+		{3, 50},
 		{4, 10},
-		{5, 5},
 	})
 	for i := 0; i < max; i++ {
 		args = append(args, node(depth-1))
 	}
 	return &ast.BuiltinNode{
-		Name:      builtin.Names[rand.Intn(len(builtin.Names))],
+		Name:      builtins[rand.Intn(len(builtins))],
 		Arguments: args,
 	}
 }
 
 func predicateNode(depth int) ast.Node {
-	cases := []string{
-		"all",
-		"none",
-		"any",
-		"one",
-		"filter",
-		"map",
-		"count",
-	}
 	return &ast.BuiltinNode{
-		Name:      cases[rand.Intn(len(cases))],
-		Arguments: []ast.Node{node(depth - 1), node(depth - 1)},
+		Name: predicates[rand.Intn(len(predicates))],
+		Arguments: []ast.Node{
+			node(depth - 1),
+			node(depth - 1),
+		},
 	}
 }
 
-func pointerNode(depth int) ast.Node {
+func pointerNode(_ int) ast.Node {
 	return &ast.PointerNode{}
 }
 
@@ -301,8 +315,6 @@ func arrayNode(depth int) ast.Node {
 		{1, 100},
 		{2, 50},
 		{3, 25},
-		{4, 10},
-		{5, 5},
 	})
 	for i := 0; i < max; i++ {
 		items = append(items, node(depth-1))
@@ -318,8 +330,6 @@ func mapNode(depth int) ast.Node {
 		{1, 100},
 		{2, 50},
 		{3, 25},
-		{4, 10},
-		{5, 5},
 	})
 	for i := 0; i < max; i++ {
 		items = append(items, &ast.PairNode{
diff --git a/testdata/examples.txt b/testdata/examples.txt
index 4e3782b00..f427f787d 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -1,367 +1,491 @@
-!!(obj?.head(obj, div) == obj.obj)
+!!!true
+!!(f32 > f64)
+!!(half != greet)
+!!(nil == add)
+!!(ok or true)
 !!false
+!!not false
 !!ok
 !!true
-!("a" != nil)
-!("a" != s)
-!("a" < "b")
-!("a" < s)
-!("a" <= "a")
-!("a" == nil)
-!("a" == s)
-!("a" > s)
-!("a" endsWith "a")
-!("a" endsWith s)
-!("a" in obj)
-!("a" matches s)
-!("a" startsWith "a")
-!("a" startsWith "c")
-!("a" startsWith s)
-!("b" != "b")
-!("b" != s)
-!("b" < "c")
-!("b" < s)
-!("b" <= "c")
-!("b" <= s)
-!("b" > "b")
-!("b" > "c")
-!("b" > s)
-!("b" >= "c")
-!("b" >= s)
-!("b" contains "a")
-!("b" contains "c")
-!("b" contains s)
-!("b" endsWith "a")
-!("b" endsWith "b")
-!("b" in obj)
-!("b" startsWith "c")
-!("c" != "c")
-!("c" != nil)
-!("c" < "b")
-!("c" < s)
-!("c" <= s)
-!("c" == "c")
-!("c" == nil)
-!("c" == s)
-!("c" > s)
-!("c" >= "b")
-!("c" >= s)
-!("c" endsWith "b")
-!("c" endsWith "c")
-!("c" endsWith s)
-!("c" in obj)
-!("c" matches "c")
-!("c" matches s)
-!("c" startsWith "a")
-!("c" startsWith s)
-!(0 != 0)
-!(0 != 1)
-!(0 != a)
-!(0 != f)
-!(0 != nil)
-!(0 < 0)
-!(0 < 0.5)
-!(0 < 2)
-!(0 < a)
-!(0 < b)
-!(0 < f)
-!(0 <= 0)
-!(0 <= 0.5)
-!(0 <= 1)
-!(0 <= a)
-!(0 <= b)
-!(0 <= f)
-!(0 == 0)
-!(0 == 0.5)
-!(0 == 1)
-!(0 == 2)
-!(0 == a)
-!(0 == b)
-!(0 == f)
-!(0 == nil)
-!(0 > 0)
-!(0 > 2)
-!(0 > b)
-!(0 > f)
-!(0 >= 0)
-!(0 >= 0.5)
-!(0 >= 1)
-!(0 >= 2)
-!(0 >= a)
-!(0 >= b)
-!(0 >= f)
-!(0 in arr)
-!(0.5 != 0)
+!("bar" != "bar")
+!("bar" != "foo")
+!("bar" != nil)
+!("bar" < "bar")
+!("bar" < "foo")
+!("bar" <= "bar")
+!("bar" <= "foo")
+!("bar" == "bar")
+!("bar" == "foo")
+!("bar" == nil)
+!("bar" > "bar")
+!("bar" > "foo")
+!("bar" >= "bar")
+!("bar" >= "foo")
+!("bar" contains "foo")
+!("bar" in foo)
+!("bar" matches "foo")
+!("bar" not contains "bar")
+!("bar" not contains "foo")
+!("bar" not endsWith "foo")
+!("bar" not in foo)
+!("bar" not matches "foo")
+!("bar" not startsWith "bar")
+!("bar" not startsWith "foo")
+!("bar" startsWith "bar")
+!("foo" != "bar")
+!("foo" != "foo")
+!("foo" != nil)
+!("foo" < "bar")
+!("foo" <= "bar")
+!("foo" <= "foo")
+!("foo" == "foo")
+!("foo" == nil)
+!("foo" > "bar")
+!("foo" > "foo")
+!("foo" >= "bar")
+!("foo" >= "foo")
+!("foo" contains "bar")
+!("foo" contains "foo")
+!("foo" endsWith "bar")
+!("foo" endsWith "foo")
+!("foo" in foo)
+!("foo" matches "bar")
+!("foo" matches "foo")
+!("foo" not contains "bar")
+!("foo" not contains "foo")
+!("foo" not endsWith "bar")
+!("foo" not endsWith "foo")
+!("foo" not in foo)
+!("foo" not matches "bar")
+!("foo" not matches "foo")
+!("foo" not startsWith "bar")
+!("foo" not startsWith "foo")
+!("foo" startsWith "bar")
+!("foo" startsWith "foo")
 !(0.5 != 0.5)
-!(0.5 != 2)
-!(0.5 != a)
-!(0.5 != b)
-!(0.5 != f)
+!(0.5 != 1)
+!(0.5 != f32)
+!(0.5 != f64)
+!(0.5 != i)
+!(0.5 != i32)
+!(0.5 != i64)
 !(0.5 != nil)
-!(0.5 < 0)
-!(0.5 < 2)
-!(0.5 < a)
-!(0.5 < b)
-!(0.5 < f)
-!(0.5 <= 0)
-!(0.5 <= a)
-!(0.5 <= b)
-!(0.5 <= f)
-!(0.5 == 2)
-!(0.5 == a)
-!(0.5 == b)
-!(0.5 == f)
+!(0.5 / i32 > i)
+!(0.5 < 0.5)
+!(0.5 < 1)
+!(0.5 < f32)
+!(0.5 < f64)
+!(0.5 < i)
+!(0.5 < i32)
+!(0.5 < i64)
+!(0.5 <= 0.5)
+!(0.5 <= 1)
+!(0.5 <= f32)
+!(0.5 <= i)
+!(0.5 <= i32)
+!(0.5 <= i64)
+!(0.5 == 0.5)
+!(0.5 == 1)
+!(0.5 == f32)
+!(0.5 == f64)
+!(0.5 == i)
+!(0.5 == i32)
+!(0.5 == i64)
 !(0.5 == nil)
-!(0.5 > 0)
+!(0.5 > 0.5)
 !(0.5 > 1)
-!(0.5 > 2)
-!(0.5 > a)
-!(0.5 > b)
-!(0.5 > f)
-!(0.5 >= 0)
+!(0.5 > f32)
+!(0.5 > f64)
+!(0.5 > i)
+!(0.5 > i32)
+!(0.5 > i64)
 !(0.5 >= 0.5)
 !(0.5 >= 1)
-!(0.5 >= a)
-!(0.5 >= b)
-!(0.5 >= f)
-!(1 < 0)
+!(0.5 >= f32)
+!(0.5 >= f64)
+!(0.5 >= i)
+!(0.5 >= i32)
+!(0.5 >= i64)
+!(0.5 ^ i64 < i64)
+!(1 != 0.5)
+!(1 != 1)
+!(1 != f32)
+!(1 != f64)
+!(1 != i)
+!(1 != i32)
+!(1 != i64)
+!(1 != nil)
+!(1 < 0.5)
 !(1 < 1)
-!(1 < a)
-!(1 < b)
-!(1 <= 0)
-!(1 <= a)
-!(1 <= b)
-!(1 <= f)
-!(1 == 0)
-!(1 == a)
-!(1 == f)
+!(1 < f32)
+!(1 < f64)
+!(1 < i)
+!(1 < i32)
+!(1 < i64)
+!(1 <= 0.5)
+!(1 <= 1)
+!(1 <= f32)
+!(1 <= f64)
+!(1 <= i)
+!(1 <= i32)
+!(1 <= i64)
+!(1 == 0.5)
+!(1 == 1)
+!(1 == f32)
+!(1 == f64)
+!(1 == i)
+!(1 == i32)
+!(1 == i64)
 !(1 == nil)
-!(1 > a)
-!(1 > b)
-!(1 > f)
-!(1 >= 0)
+!(1 > 0.5)
+!(1 > 1)
+!(1 > f64)
+!(1 > i)
+!(1 > i32)
+!(1 > i64)
 !(1 >= 0.5)
-!(1 >= b)
-!(1 in arr)
-!(2 != 0.5)
-!(2 != 2)
-!(2 != a)
-!(2 != b)
-!(2 != f)
-!(2 / a < f)
-!(2 < 0)
-!(2 < 1)
-!(2 < 2)
-!(2 < a)
-!(2 < f)
-!(2 <= 2)
-!(2 <= b)
-!(2 <= f)
-!(2 == 0)
-!(2 == 0.5)
-!(2 == 1)
-!(2 == 2)
-!(2 == a)
-!(2 == b)
-!(2 == f)
-!(2 > 0)
-!(2 > a)
-!(2 > f)
-!(2 >= a)
-!(2 >= b)
-!(2 >= f)
-!(2 in arr)
-!(a != 0.5)
-!(a != 1)
-!(a != 2)
-!(a != a)
-!(a != b)
-!(a != f)
-!(a != nil)
-!(a + 0.5 >= a)
-!(a < 0)
-!(a < 0.5)
-!(a < 2)
-!(a < a)
-!(a < b)
-!(a < div(0, a))
-!(a < f)
-!(a <= 0)
-!(a <= 0.5)
-!(a <= 2)
-!(a <= a)
-!(a <= b)
-!(a <= f)
-!(a == 0)
-!(a == 0.5)
-!(a == 1)
-!(a == 2)
-!(a == a)
-!(a == b)
-!(a == f)
-!(a == nil)
-!(a > 0)
-!(a > 0.5)
-!(a > 1)
-!(a > 2 && div == add)
-!(a > 2)
-!(a > a)
-!(a > b)
-!(a > f)
-!(a >= 0)
-!(a >= 0.5)
-!(a >= 1)
-!(a >= 2)
-!(a >= a)
-!(a >= b)
-!(a >= f)
-!(a in arr)
+!(1 >= 1)
+!(1 >= f32)
+!(1 >= f64)
+!(1 >= i)
+!(1 >= i32)
+!(1 >= i64)
+!(1 in array)
+!(1 not in array)
 !(add != add)
 !(add != div)
+!(add != greet)
+!(add != half)
 !(add != nil)
+!(add != score)
 !(add == add)
 !(add == div)
+!(add == half)
 !(add == nil)
-!(arr != nil)
-!(arr == arr)
-!(arr == nil)
-!(b != 0)
-!(b != 0.5)
-!(b != a)
-!(b != b)
-!(b != f)
-!(b != nil)
-!(b < 0)
-!(b < 0.5 * 0.5)
-!(b < 0.5)
-!(b < 1)
-!(b < a)
-!(b < b)
-!(b < f)
-!(b <= 0)
-!(b <= 1)
-!(b <= a)
-!(b <= b)
-!(b <= f)
-!(b == 0)
-!(b == 0.5)
-!(b == a)
-!(b == b)
-!(b == f)
-!(b == nil)
-!(b == obj.a)
-!(b > 0)
-!(b > 0.5)
-!(b > 1)
-!(b > 2)
-!(b > a)
-!(b > b)
-!(b > f)
-!(b >= 0)
-!(b >= 0.5)
-!(b >= 1)
-!(b >= 2)
-!(b >= a)
-!(b >= b)
-!(b >= f)
-!(b in arr)
+!(add == score)
+!(array != array)
+!(array != nil)
+!(array == array)
+!(array == list)
+!(array == nil)
 !(div != add)
 !(div != div)
+!(div != greet)
+!(div != half)
 !(div != nil)
+!(div != score)
 !(div == add)
 !(div == div)
-!(f != 0)
-!(f != 0.5)
-!(f != 1)
-!(f != 2)
-!(f != a)
-!(f != b)
-!(f != f)
-!(f != nil)
-!(f < 0)
-!(f < 0.5)
-!(f < 1)
-!(f < a)
-!(f < b)
-!(f < f)
-!(f < obj.b)
-!(f <= 0)
-!(f <= 0.5)
-!(f <= 2)
-!(f <= a)
-!(f <= b)
-!(f <= f)
-!(f <= obj.b)
-!(f == 0)
-!(f == 0.5)
-!(f == 1)
-!(f == 2)
-!(f == a)
-!(f == b)
-!(f == f)
-!(f == nil)
-!(f > 0)
-!(f > 0.5)
-!(f > 1)
-!(f > a)
-!(f > b)
-!(f > div(b, a))
-!(f > f)
-!(f >= 0)
-!(f >= 0.5)
-!(f >= 1)
-!(f >= 2)
-!(f >= a)
-!(f >= b)
-!(f >= f)
+!(div == greet)
+!(div == half)
+!(div == nil)
+!(div == score)
+!(f32 != 0.5)
+!(f32 != 1)
+!(f32 != f32)
+!(f32 != i32)
+!(f32 != i64)
+!(f32 != nil)
+!(f32 + i == 0.5 * i)
+!(f32 < 0.5)
+!(f32 < 1)
+!(f32 < f32)
+!(f32 < f64)
+!(f32 < i)
+!(f32 < i32)
+!(f32 < i64)
+!(f32 <= 0.5)
+!(f32 <= 1)
+!(f32 <= f32)
+!(f32 <= f64)
+!(f32 <= i)
+!(f32 <= i32)
+!(f32 <= i64)
+!(f32 == 0.5)
+!(f32 == 1)
+!(f32 == f32)
+!(f32 == f64)
+!(f32 == i)
+!(f32 == i32)
+!(f32 == i64)
+!(f32 == nil)
+!(f32 > 0.5)
+!(f32 > 1)
+!(f32 > f32)
+!(f32 > f64)
+!(f32 > i)
+!(f32 > i32)
+!(f32 > i64)
+!(f32 >= 0.5)
+!(f32 >= 1)
+!(f32 >= f32)
+!(f32 >= f64)
+!(f32 >= i)
+!(f32 >= i64)
+!(f64 != 0.5)
+!(f64 != 1)
+!(f64 != f32)
+!(f64 != f64)
+!(f64 != i32)
+!(f64 != i64)
+!(f64 != nil)
+!(f64 < 0.5)
+!(f64 < 1)
+!(f64 < f32)
+!(f64 < f64)
+!(f64 < i)
+!(f64 < i32)
+!(f64 < i64)
+!(f64 <= 0.5)
+!(f64 <= 1)
+!(f64 <= f32)
+!(f64 <= f64)
+!(f64 <= i)
+!(f64 <= i32)
+!(f64 <= i64)
+!(f64 == 0.5)
+!(f64 == 1)
+!(f64 == f32)
+!(f64 == i32)
+!(f64 == i64)
+!(f64 == nil)
+!(f64 > 0.5)
+!(f64 > 1)
+!(f64 > f64)
+!(f64 > i32)
+!(f64 > i64)
+!(f64 >= 0.5)
+!(f64 >= 1)
+!(f64 >= f32)
+!(f64 >= f64)
+!(f64 >= i)
+!(f64 >= i32)
+!(f64 >= i64)
+!(false != false)
 !(false != nil)
 !(false != ok)
 !(false != true)
 !(false && false)
 !(false && ok)
-!(false && true)
+!(false == false)
 !(false == nil)
+!(false == ok)
 !(false and ok)
 !(false or ok)
+!(false or true)
+!(false || false)
 !(false || ok)
-!(nil != "a")
-!(nil != "c")
-!(nil != 0)
+!(false || true)
+!(foo != foo)
+!(foo != nil)
+!(foo == foo)
+!(foo == nil)
+!(foo in list)
+!(foo not in list)
+!(greet != div)
+!(greet != greet)
+!(greet != half)
+!(greet != nil)
+!(greet != score)
+!(greet == add)
+!(greet == div)
+!(greet == greet)
+!(greet == half)
+!(greet == nil)
+!(greet == score)
+!(half != add)
+!(half != div)
+!(half != greet)
+!(half != half)
+!(half != nil)
+!(half != score)
+!(half == add)
+!(half == div)
+!(half == greet)
+!(half == half)
+!(half == nil)
+!(half == score)
+!(i != 0.5)
+!(i != 1)
+!(i != f32)
+!(i != f64)
+!(i != i)
+!(i != i32)
+!(i != i64)
+!(i != nil)
+!(i < 0.5)
+!(i < 1)
+!(i < f32)
+!(i < f64)
+!(i < i)
+!(i < i32)
+!(i < i64)
+!(i <= 0.5)
+!(i <= 1)
+!(i <= f32)
+!(i <= f64)
+!(i <= i)
+!(i <= i32)
+!(i <= i64)
+!(i == 0.5)
+!(i == 1)
+!(i == f32)
+!(i == f64)
+!(i == i)
+!(i == i32)
+!(i == i64)
+!(i == nil)
+!(i > 0.5)
+!(i > 1)
+!(i > f32)
+!(i > f64)
+!(i > i)
+!(i > i32)
+!(i > i64)
+!(i >= 0.5)
+!(i >= 1)
+!(i >= f32)
+!(i >= f64)
+!(i >= i32)
+!(i >= i64)
+!(i in array)
+!(i32 != 0.5)
+!(i32 != 1)
+!(i32 != f64)
+!(i32 != i)
+!(i32 != i32)
+!(i32 != i64)
+!(i32 != nil)
+!(i32 * 0.5 != i32)
+!(i32 < 0.5)
+!(i32 < 1)
+!(i32 < f32)
+!(i32 < f64)
+!(i32 < i)
+!(i32 < i32)
+!(i32 < i64)
+!(i32 <= 0.5)
+!(i32 <= 1)
+!(i32 <= f32)
+!(i32 <= f64)
+!(i32 <= i)
+!(i32 <= i32)
+!(i32 <= i64)
+!(i32 == 0.5)
+!(i32 == 1)
+!(i32 == f64)
+!(i32 == i)
+!(i32 == i32)
+!(i32 == i64)
+!(i32 == nil)
+!(i32 > 0.5)
+!(i32 > 1)
+!(i32 > f64)
+!(i32 > i)
+!(i32 > i32)
+!(i32 > i64)
+!(i32 >= 0.5)
+!(i32 >= 1)
+!(i32 >= f32)
+!(i32 >= f64)
+!(i32 >= i)
+!(i32 >= i32)
+!(i32 >= i64)
+!(i32 in array)
+!(i32 not in array)
+!(i64 != 0.5)
+!(i64 != 1)
+!(i64 != f32)
+!(i64 != f64)
+!(i64 != i)
+!(i64 != i32)
+!(i64 != nil)
+!(i64 < 0.5)
+!(i64 < 1)
+!(i64 < f32)
+!(i64 < f64)
+!(i64 < i)
+!(i64 < i32)
+!(i64 < i64)
+!(i64 <= 0.5)
+!(i64 <= 1)
+!(i64 <= f32)
+!(i64 <= f64)
+!(i64 <= i)
+!(i64 <= i32)
+!(i64 <= i64)
+!(i64 == 0.5)
+!(i64 == 1)
+!(i64 == f32)
+!(i64 == f64)
+!(i64 == i)
+!(i64 == i32)
+!(i64 == nil)
+!(i64 > 0.5)
+!(i64 > 1)
+!(i64 > f32)
+!(i64 > f64)
+!(i64 > i)
+!(i64 > i32)
+!(i64 > i64)
+!(i64 >= 0.5)
+!(i64 >= 1)
+!(i64 >= f32)
+!(i64 >= f64)
+!(i64 >= i)
+!(i64 >= i32)
+!(i64 in array)
+!(i64 not in array)
+!(list != array)
+!(list != list)
+!(list != nil)
+!(list == array)
+!(list == list)
+!(list == nil)
+!(nil != "bar")
+!(nil != "foo")
 !(nil != 0.5)
-!(nil != 2)
-!(nil != a)
+!(nil != 1)
 !(nil != add)
-!(nil != arr)
-!(nil != b)
+!(nil != array)
 !(nil != div)
-!(nil != f)
+!(nil != f32)
+!(nil != f64)
 !(nil != false)
+!(nil != foo)
+!(nil != greet)
+!(nil != half)
+!(nil != i)
+!(nil != i32)
+!(nil != i64)
+!(nil != list)
 !(nil != nil)
-!(nil != obj)
 !(nil != ok)
-!(nil != s)
+!(nil != score)
 !(nil != true)
-!(nil == "b")
-!(nil == 0)
+!(nil == "bar")
+!(nil == "foo")
 !(nil == 0.5)
 !(nil == 1)
-!(nil == a)
-!(nil == add)
-!(nil == arr)
-!(nil == b)
+!(nil == array)
 !(nil == div)
-!(nil == false)
+!(nil == f32)
+!(nil == f64)
+!(nil == foo)
+!(nil == greet)
+!(nil == half)
+!(nil == i)
+!(nil == i32)
+!(nil == i64)
+!(nil == list)
 !(nil == nil)
-!(nil == obj)
 !(nil == ok)
-!(nil == s)
-!(nil in arr)
-!(nil in obj)
-!(obj != nil)
-!(obj != obj)
-!(obj == nil)
-!(obj == obj)
-!(obj.b == a ** a)
+!(nil == score)
+!(nil == true)
+!(nil in array)
+!(nil in list)
+!(nil not in array)
+!(nil not in list)
 !(ok != false)
 !(ok != nil)
 !(ok != ok)
@@ -372,10830 +496,11294 @@
 !(ok == false)
 !(ok == nil)
 !(ok == ok)
-!(ok == true)
-!(ok and false)
 !(ok and ok)
 !(ok and true)
 !(ok or ok)
-!(ok or true)
 !(ok || false)
 !(ok || ok)
-!(ok || true)
-!(s != "b")
-!(s != "c")
-!(s != nil)
-!(s != s)
-!(s < "a")
-!(s < "b")
-!(s < "c")
-!(s < s)
-!(s <= "c")
-!(s <= s)
-!(s == "a")
-!(s == "b")
-!(s == "c")
-!(s == nil)
-!(s == s)
-!(s > "b")
-!(s > s)
-!(s >= "a")
-!(s >= s)
-!(s contains "c")
-!(s contains s)
-!(s endsWith "a")
-!(s endsWith "c")
-!(s endsWith s)
-!(s in obj)
-!(s matches "a")
-!(s matches "b")
-!(s matches s || ok)
-!(s matches s)
-!(s startsWith "a")
-!(s startsWith "b")
-!(s startsWith s)
-!(string(s) startsWith "b" != false)
+!(score != add)
+!(score != div)
+!(score != greet)
+!(score != half)
+!(score != nil)
+!(score != score)
+!(score == add)
+!(score == div)
+!(score == greet)
+!(score == half)
+!(score == nil)
+!(true != false)
+!(true != nil)
 !(true != ok)
 !(true != true)
 !(true && false)
 !(true && ok)
+!(true && true)
+!(true == false)
+!(true == nil)
 !(true == ok)
 !(true == true)
+!(true and false)
+!(true and ok)
 !(true and true)
-!(true or ok)
-!(true || false)
+!(true or true)
 !(true || ok)
 !(true || true)
-!all(arr, 2 != a)
-!all(arr, false)
-!all(arr, ok)
-!all(arr, true)
-!any(arr, false)
-!any(arr, ok)
-!any(arr, true)
-!false && obj != obj.obj
-!false && obj.b
-!false == obj.head(ok)
-!false ? "a" : s
-!false ? "b" : add
-!false ? "b" : f
-!false ? "c" : f
-!false ? 0 : "b"
-!false ? 0 : false
-!false ? 0 : s
-!false ? 2 : false
-!false ? a : add
-!false ? a : false
-!false ? a : s
-!false ? add : ok
-!false ? add : s
-!false ? b : s
-!false ? div : s
-!false ? f : f
-!false ? f : obj.head(obj)
-!false ? false : b
-!false ? nil : "a"
-!false ? nil : f
-!false ? nil : true
-!false ? obj : nil
-!false ? obj : obj
-!false ? ok : obj
+!all(array, false)
+!all(array, ok)
+!all(array, true)
+!all(list, false)
+!all(list, ok)
+!all(list, true)
+!any(array, false)
+!any(array, ok)
+!any(array, true)
+!any(list, # != #)
+!any(list, ok)
+!false && ok
+!false ? "bar" : i
+!false ? "foo" : false
+!false ? 0.5 : "bar"
+!false ? 0.5 : 1
+!false ? 0.5 : div
+!false ? 0.5 : i64
+!false ? 1 : add
+!false ? 1 : true
+!false ? add : array
+!false ? add : nil
+!false ? array : array
+!false ? div : 0.5
+!false ? div : foo
+!false ? div : map(list, #)
+!false ? div : nil
+!false ? f32 : 0.5
+!false ? f32 : greet
+!false ? f64 : 1
+!false ? f64 : half
+!false ? false : f32
+!false ? false : false
+!false ? foo : 1
+!false ? foo : i64
+!false ? greet : array
+!false ? greet : i32
+!false ? half : nil
+!false ? half : ok
+!false ? i : foo
+!false ? i32 : "foo"
+!false ? i64 : f32
+!false ? i64 : nil
+!false ? list : list
+!false ? nil : 1
+!false ? nil : add
+!false ? nil : f64
+!false ? nil : foo
 !false ? ok : ok
-!false ? s : add
-!false ? s : nil
-!false ? s : obj?.head(a.head("a"))
-!false ? true : arr
-!false ? true : div
-!false or obj.a
-!false or obj?.fn(obj, div)
-!false or ok
-!fromJSON(string(false))
-!hasSuffix("a", s)
-!none(arr, false)
-!none(arr, ok)
-!none(arr, true)
-!not (a < 0)
-!not (f != 1)
-!not (f == 0)
-!not (s != s)
-!not (s contains s)
+!false ? true : array
+!false and (true or false)
+!false and ok
+!false or 0.5 != 1
+!false || not false
+!hasSuffix("bar", "bar")
+!none(array, false)
+!none(array, true)
+!none(list, false)
+!none(list, ok)
+!none(list, true)
+!not (1 != i)
+!not (i64 != 0.5)
+!not any(list, ok)
 !not false
 !not ok
 !not true
-!obj.head(2 == s)
-!obj.head(add != nil)
-!obj.head(arr != s)
-!obj.head(false == add)
-!obj.head(false)
-!obj.head(ok)
-!obj.head(ok, 1, obj)
-!obj.head(ok, add)
-!obj.head(ok, map("a", 2))
-!obj.head(ok, nil)
-!obj.head(ok, s)
-!obj.head(ok, s, obj, div, s)
-!obj.head(true, 0, arr)
-!obj.head(true, a)
-!obj.head(true, b, nil, f)
-!obj.head(true, s)
-!obj?.head(any(s, true))
-!obj?.head(false)
-!obj?.head(false, "b")
-!obj?.head(false, div, 2, obj)
-!obj?.head(false, true)
-!obj?.head(ok)
-!obj?.head(ok, arr)
-!obj?.head(ok, div, ok)
-!obj?.head(ok, false)
-!obj?.head(ok, nil, "c")
-!obj?.head(ok, ok)
-!obj?.head(ok, s)
-!obj?.head(ok, true, b)
-!obj?.head(true)
-!obj?.head(true, 0)
+!not true ? i64 : true
 !ok
-!ok != (ok or false)
 !ok != ok
-!ok && a == 1
-!ok && obj.b
-!ok && ok
+!ok && (ok || ok)
+!ok == !ok
 !ok == ok
-!ok ? "a" : 0.5
-!ok ? "a" : div
-!ok ? "b" : 0
-!ok ? "b" : obj.b
-!ok ? "b" : ok
-!ok ? "c" : 0.5
-!ok ? 0 : add
-!ok ? 0.5 : 0
-!ok ? 0.5 : 0.5
-!ok ? 0.5 : div
-!ok ? 1 : nil
-!ok ? 2 : "b"
-!ok ? a : arr
-!ok ? a : b
-!ok ? a : div
-!ok ? a : s
-!ok ? a : true
-!ok ? add : 1
-!ok ? add : a
-!ok ? add : add
-!ok ? add : f
+!ok ? "bar" : 0.5
+!ok ? "foo" : nil
+!ok ? 0.5 : "foo"
+!ok ? 1 : 0.5
+!ok ? 1 : 1
+!ok ? 1 : div
+!ok ? 1 : foo
+!ok ? 1 : greet
+!ok ? 1 : ok
+!ok ? add : f32
 !ok ? add : false
-!ok ? add : obj
-!ok ? add : ok
-!ok ? add : s
-!ok ? arr : b
-!ok ? arr == arr : div
-!ok ? b : "a"
-!ok ? b : "b"
-!ok ? b : 1
-!ok ? b : a
-!ok ? b : f
-!ok ? div : a
-!ok ? div : b
-!ok ? div : obj
-!ok ? div : s
-!ok ? f : a
-!ok ? f : div
-!ok ? f : s
-!ok ? false : 0
-!ok ? false : f
-!ok ? nil : div
-!ok ? obj : 1
-!ok ? obj : ok
-!ok ? ok : a
-!ok ? ok : arr
-!ok ? ok : false
-!ok ? ok : nil
-!ok ? ok : ok
-!ok ? s : 0.5
-!ok ? s : obj
-!ok ? true : s
-!ok and a <= b
-!ok and arr == nil
-!ok and obj.a
-!ok and obj.a?.obj
-!ok and obj?.a
-!ok and obj[nil]
+!ok ? add : i
+!ok ? add : score
+!ok ? f32 : "foo"
+!ok ? f32 : 1
+!ok ? f64 : i
+!ok ? false : "foo"
+!ok ? false : half
+!ok ? greet : "bar"
+!ok ? greet : add
+!ok ? greet : false
+!ok ? half : array
+!ok ? i : foo
+!ok ? i : greet
+!ok ? i : true
+!ok ? i64 : list
+!ok ? list : "foo"
+!ok ? list : true
+!ok ? nil : i
+!ok ? nil : true
+!ok ? ok : 1
+!ok ? ok : i64
+!ok ? ok : score
+!ok ? score : array
+!ok ? score : i
+!ok ? true : greet
+!ok and i != f32
 !ok and ok
-!ok or nil != a
-!ok or obj?.a
-!ok or obj?.b
-!ok or ok
-!ok or ok || false
-!ok || nil == s
-!ok || obj.a
-!ok || obj.fn(2)
-!ok || ok
-!one(arr, false)
-!one(arr, ok)
-!true != obj.a
-!true && obj?.obj
-!true && ok == nil
-!true == obj.obj
-!true == obj?.obj
+!ok or none(array, ok)
+!one(array, ok)
+!one(array, true)
+!one(list, false)
+!one(list, ok)
+!one(list, true)
+!true != false ? ok : 0.5
+!true != nil == nil
+!true != ok
+!true && ok
 !true == ok
-!true ? "a" : a
-!true ? "a" : ok
-!true ? 0 : true
-!true ? 0.5 : b
-!true ? 1 : add
-!true ? a : add
-!true ? a : arr
-!true ? add : ok
-!true ? arr : 0.5
+!true ? "bar" : false
+!true ? "bar" : i
+!true ? "foo" : ok
+!true ? 0.5 : 1
+!true ? 0.5 : div
+!true ? 0.5 : i
+!true ? add : div
+!true ? add : greet
+!true ? array : foo
+!true ? array : i
+!true ? array : i64
+!true ? array : score
+!true ? div : f32
 !true ? div : ok
-!true ? div : true
-!true ? f : 0
-!true ? f : f
-!true ? false : b
-!true ? nil : "b"
-!true ? nil : "c"
-!true ? nil : div
-!true ? nil : ok
-!true ? obj : add
-!true ? ok : add
-!true ? ok : obj
-!true ? s : "a"
-!true ? s : false
-!true ? true : a
-!true ? true : f
-!true and f != b
-!true and nil != "a"
-!true and obj.a
+!true ? f32 : 0.5
+!true ? f32 : add
+!true ? f32 : foo
+!true ? f32 : i32
+!true ? f64 : "bar"
+!true ? f64 : f64
+!true ? f64 : i32
+!true ? foo : 1
+!true ? greet : array
+!true ? greet : list
+!true ? half : add
+!true ? half : greet
+!true ? i32 : i64
+!true ? i64 : score
+!true ? list : div
+!true ? list : score
+!true ? nil : 0.5
+!true ? nil : f32
+!true ? nil : f64
+!true ? nil : foo
+!true ? nil : half
+!true ? nil : i
+!true ? ok : list
+!true ? score : array
+!true ? score : nil
 !true and ok
-!true or obj?.head(1, nil, ok, div, arr)
-!true || !true
-"a" != nil or a <= 0
-"a" != obj.a
-"a" != obj.b
-"a" != obj.obj
-"a" != obj.obj.b
-"a" != obj?.a
-"a" != obj?.b
-"a" != obj?.fn(b)
-"a" != obj?.head(add)
-"a" != obj?.head(f == ok)
-"a" != obj?.head(ok and nil)
-"a" != obj?.obj
-"a" < "a" ? obj.fn(true, 2, div, arr) : ok
-"a" < "c" && obj.head(ok)
-"a" < s || ok && false
-"a" <= s && ok
-"a" == "a" || ok
-"a" == nil != ok
-"a" == nil == obj?.head(obj, "c", b, 0, true)
-"a" == obj.a
-"a" == obj.b
-"a" == obj.obj
-"a" == obj?.a
-"a" == obj?.b
-"a" == obj?.head(-0.5)
-"a" == obj?.head(filter("a", false))
-"a" == obj?.obj
-"a" == s && ok
-"a" == s == ok
-"a" == s ? s : f
-"a" > s or obj.fn(b)
-"a" >= "a" && 0 == a
-"a" >= "b" || obj?.head(div, 2, div)
-"a" >= "b" || obj?.obj
-"a" >= obj.head(string(s contains "b"))
-"a" >= obj?.head(s)
-"a" >= s ? s : string(s)
-"a" contains "c" && any(arr, true)
-"a" contains "c" == obj?.a
-"a" contains s and obj?.obj
-"a" contains s and ok
-"a" endsWith s != ok
-"a" endsWith s || obj?.head(div)
-"a" in obj && obj.head(1)
-"a" in obj.obj
-"a" in obj?.obj
-"a" matches "b" || obj?.b
-"a" matches s and obj?.b
-"b" != "b" == true ? b : nil
-"b" != obj.a
-"b" != obj.b
-"b" != obj.head(f)
-"b" != obj.obj
-"b" != obj.obj.a
-"b" != obj.obj?.a
-"b" != obj?.a
-"b" != obj?.b
-"b" != obj?.fn(a)
-"b" != obj?.obj
-"b" != obj?.obj.obj
-"b" != s or ok
-"b" + "a" contains s + s
-"b" + s == obj.a
-"b" + s in obj ? div : f
-"b" < "c" != ok
-"b" < "c" && obj.head(div, b, b)
-"b" < s and obj?.head(div, ok)
-"b" <= "a" and ok
-"b" <= "a" or obj?.a
-"b" <= "b" and nil == ok
-"b" <= obj.head(s)
-"b" == obj.a
-"b" == obj.b
-"b" == obj.obj
-"b" == obj.obj?.obj
-"b" == obj?.a
-"b" == obj?.b
-"b" == obj?.head(div)
-"b" == obj?.obj
-"b" == obj[string(add)]
-"b" == s != obj.b
-"b" == s == obj.obj
-"b" > "b" ? f : obj
-"b" > "b" and !true
-"b" > s && arr != arr
-"b" contains "b" || obj.a
-"b" endsWith "b" || add != obj.a
-"b" in obj.obj
-"b" in obj?.head(obj?.obj)
-"b" in obj?.obj
-"b" matches obj?.head(s)
-"b" startsWith s ? a : s
-"b" startsWith s or ok
-"b" startsWith s || true && false
-"c" != "a" || ok
-"c" != "a" || ok ? add : add
-"c" != "b" && a > a
-"c" != "c" == ok
-"c" != nil || false or ok
-"c" != obj.a
-"c" != obj.b
-"c" != obj.fn(b)
-"c" != obj.obj
-"c" != obj.obj?.b
-"c" != obj?.a
-"c" != obj?.b
-"c" != obj?.head(obj?.obj)
-"c" != obj?.obj
-"c" != obj?.obj.a
-"c" != obj?.obj?.b
-"c" != s != ok
-"c" + s matches s
-"c" < "b" != ok
-"c" < s == obj.obj
-"c" < s ? add : min(0.5)
-"c" < s || obj?.fn(b)
-"c" == obj.a
-"c" == obj.b
-"c" == obj.head(0 ^ b)
-"c" == obj.obj
-"c" == obj.obj?.b
-"c" == obj?.a
-"c" == obj?.b
-"c" == obj?.obj
-"c" == s and "c" < "b"
-"c" == s || false != nil
-"c" > "a" && obj.b
-"c" > "c" and obj?.b
-"c" > s ? obj : s
-"c" >= "b" or obj.fn("c")
-"c" >= s ? arr : obj.b
-"c" contains "c" || 1 >= a
-"c" contains s && obj?.obj.a
-"c" endsWith s == obj?.obj
-"c" endsWith s or s < s
-"c" endsWith s || ok
-"c" in obj or obj?.obj
-"c" in obj || true ? b : div
-"c" in obj.head(arr)
-"c" in obj.obj
-"c" in obj?.obj
-"c" matches s && obj?.obj
-"c" matches s ? div : add
-"c" startsWith "c" && ok
-"c" startsWith "c" ? s : ok
-"c" startsWith s and nil != 1
-(0 % a) ^ (a * f)
-(0 * 0) ^ f
-(0 * 2) ^ obj?.head(1, "b", s, a, s)
-(0 * f) ^ f
-(0 + 0) ^ obj?.a
-(0 + 0.5) ^ (a - b)
-(0 + 1) ^ a ^ f
-(0 + 2) ^ (a - f)
-(0 + a) % a
-(0 + a) ^ a
-(0 + b) ** b
-(0 + f) * f
-(0 + f) / b
-(0 + f) / obj.b
-(0 + f) ^ f
-(0 - 0) * f
-(0 - 0) ^ (f * b)
-(0 - a) * a
-(0 - a) ^ a
-(0 - b) / 0.5 ** f
-(0 - b) / a
-(0 - b) ^ f
-(0 - f) * max(0)
-(0 / 0) ^ f
-(0 / 2) ^ obj?.b
-(0.5 * 0) ** (0 * 2)
-(0.5 * a) ** a
-(0.5 * b) ^ obj.a
-(0.5 * f) ** f
-(0.5 + a) / f
-(0.5 + b) ** b
-(0.5 + b) ^ obj.b
-(0.5 - f) / b
-(0.5 / a) ^ a
-(0.5 / f) ** max(0.5)
-(0.5 / f) ^ obj?.a
-(1 % a) ^ obj.head(2)
-(1 * a) ^ a
-(1 - 0) / f
-(1 - 2) ** (a * a)
-(1 - b) ^ min(0)
-(1 - f) / a
-(1 - f) ^ b
-(1 / 0) ** obj?.a
-(1 / 0) ^ f
-(1 / 0.5 + f) * f
-(1 / b) ^ f
-(1 / f) ** a
-(1 / f) ** b
-(2 % a) ** f
-(2 % a) ^ -b
-(2 % b) ** b
-(2 % b) ** f
-(2 % b) ** obj?.head(f, add, ok, false)
-(2 * a) ^ b
-(2 + 0) ** a
-(2 + 0.5) / min(f)
-(2 + 2) ^ len(s) * f
-(2 + f) * a ** 0
-(2 + f) ** b
-(2 - 2) ** -0
-(2 - 2) ** b
-(2 - 2) / f
-(2 - a) ^ a
-(2 - a) ^ add(0, a)
-(2 - f) / obj.a
-(2 / f) ** (a - f)
-(2 / f) ^ f == b
-(2 / f) ^ obj.a
-(a % 2) ^ b
-(a % a) ** obj.head(b, b)
-(a * a) ** f
-(a * a) ** obj.b
-(a * f) ^ a
-(a * f) ^ f ** a
-(a + 0) % a
-(a + 0) / obj.b
-(a + a) % obj?.a
-(a + a) / b
-(a + b) % a
-(a + b) % add(a, b)
-(a - 0) / a
-(a - 0) / b
-(a - 0) ^ int(b)
-(a - 0.5) / (0.5 + 0)
-(a - 0.5) / obj.head(a)
-(a - 0.5) / obj?.b
-(a - 0.5) ^ b
-(a - 1) ^ f
-(a - 2) % a
-(a - a) % b
-(a - b) * b
-(a - b) ** a ** 0
-(a - b) ^ f
-(a - f) * b
-(a - f) * f
-(a - f) * obj.head(f)
-(a - f) ^ a
-(a / 1) ** f
-(a / b) ^ f
-(a / f) ** a
-(a / f) ^ b
-(a / f) ^ min(0)
-(b % 2) ** b
-(b % 2) ^ add(b, b)
-(b % a) ^ b
-(b * 0) ** a
-(b * 0) ** f
-(b * a) ** a
-(b * b) ^ a ** 0
-(b * f) ^ float(a)
-(b + 0) * div(b, b)
-(b + 0) / b
-(b + 0.5) ** f
-(b + 2) % b
-(b + 2) ** f
-(b + a) ** f
-(b + b) * a
-(b + b) ^ b
-(b + b) ^ obj?.b
-(b + f) / b
-(b + f) ^ a
-(b - 0) * b
-(b - 0) / b != f
-(b - 1) * obj?.b
-(b - 1) / a
-(b - a) ** obj.a
-(b - a) / a
-(b - b) * b
-(b - f) * f
-(b - f) ** b
-(b - f) ^ (a - 1)
-(b / 0) ^ f
-(b / 1) ** b
-(b / a) ^ (b / 1)
-(b / a) ^ obj?.obj.obj?.b
-(b / b) ** f
-(f * 0.5) ** obj?.a
-(f * a) ** obj.fn(1)
-(f * b) ** f
-(f * b) ^ f
-(f * f) ** a ** a
-(f * f) ** b
-(f * f) ** f
-(f * f) ^ b
-(f + 0) * b ^ b
-(f + 0) ** f
-(f + 0.5) ^ f
-(f + a) * a
-(f + a) ** f
-(f + a) ** obj?.a
-(f + b) * f
-(f + b) ** add(2, b)
-(f + b) ** obj.b
-(f + f) * b
-(f + f) ** arr[2]
-(f + f) / b
-(f + f) ^ (1 / 2)
-(f + f) ^ arr[a]
-(f + f) ^ b
-(f + f) ^ f
-(f - 0) ** obj?.fn(b)
-(f - 0) / a
-(f - 0) ^ (f / 0.5)
-(f - 0) ^ a
-(f - 0.5) * f
-(f - 0.5) / f
-(f - 0.5) ^ a
-(f - 2) * a
-(f - a) * -a
-(f - a) ** b ^ f
-(f - a) / add(a, b)
-(f - b) ** b
-(f / a) ^ f
-(f / a) ^ obj.b
-(f / b) ** b
-(false or false) != obj?.b
-(false or false) and s >= "b"
-(false or true) != obj.head(add)
-(false || true) == obj?.b
-(min(f, f) / b) ** (b % obj?.b)
-(ok ? true : 0) ? div : arr
-(ok ? true : 0) ? obj?.b : (true ? false : true)
-(ok and ok) != ok
-(ok or false) and false ? 2 : div
-(ok or ok) == obj?.a
-(ok or ok) == ok
-(ok or ok) and obj.obj?.a
-(ok or true) and ok
-(ok || ok) == ok
-(ok || ok) and obj.obj
-(ok || ok) and ok
-(true and true) != obj.a
-(true or ok) != ok
-(true || false) and a == 0.5
-(true || ok) == obj.a
-(true || true) != a + obj?.b
--((f - 1) ** len(s))
--(0 % 1)
--(0 % 2)
--(0 % a)
--(0 % b)
--(0 * 0)
--(0 * b)
--(0 * f * obj?.b)
--(0 * f)
--(0 ** 0)
--(0 ** a)
--(0 ** b)
--(0 ** f)
--(0 + 0)
--(0 + 0.5)
--(0 + 1)
--(0 + 2)
--(0 + a)
--(0 + f)
--(0 - 0)
--(0 - 0.5)
--(0 - 1)
--(0 - 2)
--(0 - a)
--(0 - b)
--(0 - f)
--(0 / 0)
--(0 / 0.5)
--(0 / 2)
--(0 / a)
--(0 / b)
--(0 / f)
--(0 ^ 0)
--(0 ^ 0.5)
--(0 ^ 2)
--(0 ^ a)
--(0 ^ b)
--(0 ^ f)
+!true or !false
+!true or nil != ok
+!true || ok
+"bar" != foo.Bar
+"bar" != foo?.Bar
+"bar" != foo?.String()
+"bar" != nil and true ? i64 : 0.5
+"bar" + "foo" not endsWith greet("bar")
+"bar" + foo.Bar
+"bar" + foo?.Bar
+"bar" + foo?.String()
+"bar" < foo.Bar
+"bar" < foo?.Bar
+"bar" <= foo.Bar
+"bar" <= foo.String()
+"bar" <= foo?.Bar
+"bar" == foo.Bar
+"bar" == foo?.Bar
+"bar" > foo.Bar
+"bar" > foo.String()
+"bar" > foo?.Bar
+"bar" contains "bar" == ok
+"bar" contains "foo" ? array : f64
+"bar" contains foo.Bar
+"bar" contains foo?.Bar
+"bar" contains foo?.String()
+"bar" endsWith foo.Bar
+"bar" endsWith foo?.Bar
+"bar" endsWith foo?.String()
+"bar" in foo || ok
+"bar" matches "bar" != ok
+"bar" matches foo.Bar
+"bar" matches foo?.Bar
+"bar" not contains foo.Bar
+"bar" not contains foo.String()
+"bar" not contains foo?.Bar
+"bar" not endsWith foo.Bar
+"bar" not endsWith foo?.Bar
+"bar" not endsWith foo?.String()
+"bar" not in list[i]
+"bar" not matches "foo" ? i32 < 0.5 : ok
+"bar" not matches foo.Bar
+"bar" not matches foo.String()
+"bar" not matches foo?.Bar
+"bar" not startsWith "foo" ? add : ok
+"bar" not startsWith foo.Bar
+"bar" not startsWith foo?.Bar
+"bar" startsWith foo.Bar
+"bar" startsWith foo?.Bar
+"foo" != "bar" != ok
+"foo" != foo.Bar
+"foo" != foo?.Bar
+"foo" != foo?.String()
+"foo" + "foo" not in foo
+"foo" + foo.Bar
+"foo" + foo.String()
+"foo" + foo?.Bar
+"foo" + foo?.String()
+"foo" < "bar" and i32 != 0.5
+"foo" < "foo" ? list : f32
+"foo" < foo.Bar
+"foo" < foo?.Bar
+"foo" <= foo.Bar
+"foo" <= foo?.Bar
+"foo" == "foo" && i32 > 1
+"foo" == foo.Bar
+"foo" == foo.String()
+"foo" == foo?.String()
+"foo" == nil ? foo : f64
+"foo" > "bar" && ok
+"foo" > "foo" == not false
+"foo" > foo?.Bar
+"foo" > foo?.String()
+"foo" >= foo.Bar
+"foo" >= foo?.Bar
+"foo" contains foo.Bar
+"foo" contains foo?.Bar
+"foo" endsWith foo.Bar
+"foo" endsWith foo.String()
+"foo" endsWith foo?.Bar
+"foo" endsWith foo?.String()
+"foo" in foo && nil == 1
+"foo" matches "bar" ? f64 > f64 : half
+"foo" matches foo.Bar
+"foo" matches foo.String()
+"foo" matches foo?.Bar
+"foo" not contains foo.Bar
+"foo" not contains foo?.Bar
+"foo" not endsWith foo.Bar
+"foo" not endsWith foo?.Bar
+"foo" not endsWith foo?.String()
+"foo" not matches foo.Bar
+"foo" not matches foo.String()
+"foo" not matches foo?.Bar
+"foo" not startsWith foo.Bar
+"foo" not startsWith foo?.String()
+"foo" startsWith foo.Bar
+"foo" startsWith foo?.Bar
+"foo" startsWith foo?.String()
+("bar" not endsWith "bar") and i64 < i32
+("bar" not endsWith "foo") == ok
+("bar" not in foo) == ok
+("foo" not matches "bar") and false ? f64 : array
+(0.5 * 0.5) ** f32
+(0.5 * 0.5) ** i
+(0.5 * 0.5) ** i64
+(0.5 * 0.5) ^ f32
+(0.5 * 0.5) ^ i32
+(0.5 * f32) ** i
+(0.5 * f64) ^ f32
+(0.5 * i32) ** f32
+(0.5 + 1) * i
+(0.5 + 1) ** i64
+(0.5 + 1) / i
+(0.5 + i64) / f32
+(0.5 - 0.5) ^ half(f64)
+(0.5 - 1) * i64
+(0.5 - 1) ** i64
+(0.5 - f32) ** (0.5 * f64)
+(0.5 - f64) * f64
+(0.5 - f64) / f32
+(0.5 - i) ^ f32
+(0.5 - i32) ** i64
+(0.5 - i32) ^ f64
+(0.5 / 0.5) ^ f64
+(0.5 / f32) ** f32
+(0.5 / f32) ^ i32
+(0.5 / f64) ** i
+(0.5 / f64) ** i32
+(0.5 / i32) ** i
+(0.5 / i64) ** f32
+(1 % i) ** f32
+(1 % i) ^ i
+(1 % i64) ** f32
+(1 * 1) ** f64
+(1 * 1) ^ i
+(1 * f32) ** f32
+(1 * i32) ** i
+(1 * i64) ** i32
+(1 + 0.5) * f64
+(1 + 0.5) ^ i32
+(1 + 1) / i32
+(1 + 1) ^ i
+(1 + f32) / f32 / i64
+(1 + f64) ** i64
+(1 + f64) / i32
+(1 + f64) ^ f64
+(1 + i32) / f32
+(1 + i64) / f64
+(1 - 0.5) / f64
+(1 - 0.5) ^ i32
+(1 - 1) * i
+(1 - 1) * i32
+(1 - 1) ** f32
+(1 - 1) / i
+(1 - f64) * 1 * i
+(1 - f64) ^ i32
+(1 - i) ** i
+(1 - i) / i64
+(1 - i32) ** i ^ 0.5
+(1 - i64) % i64
+(1 / 0.5) ^ f32
+(1 / 0.5) ^ f64
+(1 / 1) ** i32
+(1 / 1) ^ i32
+(1 / f64) ** f64
+(1 / i) ** i64
+(1 not in array) and none(list, true)
+(f32 * 1) ** f32
+(f32 * 1) ** i64
+(f32 * i) ^ i64
+(f32 * i32) ** i
+(f32 * i64) ** i64
+(f32 * i64) ^ i
+(f32 + 0.5) / 0.5 ** 0.5
+(f32 + 1) ** i
+(f32 + 1) / i
+(f32 + 1) / i64
+(f32 + i32) ** i64
+(f32 + i64) ** i32
+(f32 - 0.5) * f64
+(f32 - 0.5) * i
+(f32 - f32) ** f32
+(f32 - i) / f64
+(f32 - i) ^ i64
+(f32 - i64) * i64
+(f32 - i64) ** i64
+(f32 - i64) / i64
+(f32 / f64) ^ f32
+(f32 / f64) ^ i
+(f32 / i32) ^ i32
+(f64 * 0.5) ^ i
+(f64 * f64) ** i32
+(f64 * i64) ** i32
+(f64 + f32) ** i64
+(f64 + i32) * f32
+(f64 + i64) / i32
+(f64 - 0.5) * -i
+(f64 - 0.5) * i
+(f64 - 0.5) / f32
+(f64 - 0.5) / i64
+(f64 - 0.5) ^ i
+(f64 - 0.5) ^ i64
+(f64 - 1) * f32
+(f64 - f32) * i64
+(f64 - f64) / i32
+(f64 - i) * i32 ** 1
+(f64 - i64) / i64
+(f64 / 0.5) ** f64
+(f64 / i) ^ i64
+(false || ok) and ok
+(i % 1) ** -f32
+(i % 1) ** f64
+(i % i) ** f32
+(i * 1) ** i
+(i * f32) ** i32
+(i * f32) ^ f64
+(i * i) ^ count(array, true)
+(i + 0.5) ** i32
+(i + 0.5) ^ f32
+(i + 1) % i32
+(i + 1) / i64
+(i + f64) ^ (f32 * f64)
+(i + i) * -f64
+(i + i32) ^ i64
+(i - 0.5) / f32
+(i - 0.5) ^ f64
+(i - 1) ** i64
+(i - 1) / f32
+(i - 1) ^ f64
+(i - i64) ** f64
+(i - i64) ^ i
+(i / 0.5) ^ i32
+(i / 1) ** f64
+(i / 1) ** i64
+(i / i32) ^ f32
+(i < i32 ? nil : f64) ** f64
+(i32 * 1) ** f32
+(i32 * f32) ^ i64
+(i32 * i) ^ i
+(i32 * i32) ** f64
+(i32 + 0.5) / f64
+(i32 + 0.5) ^ i64
+(i32 + 1) * f64
+(i32 + 1) ** float(1)
+(i32 + 1) / i
+(i32 + 1) / i64
+(i32 + f32) ** f32
+(i32 + f64) ** i
+(i32 + i32) * i32
+(i32 + i32) / i64
+(i32 + i64) ^ i
+(i32 - 0.5) * i64
+(i32 - f32) * i32
+(i32 - i32) ** i
+(i32 - i32) ** i64
+(i32 / 0.5) ^ i32
+(i32 / i32) ^ f32
+(i32 / i32) ^ i
+(i64 * 0.5) ^ f32
+(i64 * 1) ** i64
+(i64 * 1) ^ f32
+(i64 * 1) ^ f64
+(i64 * f32) ** findIndex(list, ok)
+(i64 + 1) * i32
+(i64 + f32) ^ f64
+(i64 + f64) / 1 * 1
+(i64 + f64) ^ f64
+(i64 + i) ^ i64
+(i64 + i32) * f32
+(i64 - 0.5) * i64
+(i64 - 0.5) / i32
+(i64 - i) % i32
+(i64 - i32) / len(array)
+(i64 - i64) / i64
+(i64 / f64) ** f32
+(i64 / i32) ** f32
+(i64 / i32) ** i
+(i64 / i32) ^ -1
+(i64 not in array) && ok
+(ok && ok) == ok
+(ok or false) and ok
+(ok or ok) == not false
+(ok || true) && i32 >= f64
 -(0.5 * 0.5)
--(0.5 * 2)
--(0.5 * a)
--(0.5 * b)
--(0.5 * f)
--(0.5 ** 0)
+-(0.5 * 1)
+-(0.5 * f32)
+-(0.5 * f64)
+-(0.5 * i)
+-(0.5 * i32)
+-(0.5 * i64)
 -(0.5 ** 0.5)
--(0.5 ** a)
--(0.5 ** b)
--(0.5 ** f)
--(0.5 + 0)
+-(0.5 ** 1)
+-(0.5 ** f32)
+-(0.5 ** f64)
+-(0.5 ** i)
+-(0.5 ** i32)
+-(0.5 ** i64)
+-(0.5 + 0.5)
 -(0.5 + 1)
--(0.5 + 2)
--(0.5 + a)
--(0.5 + b)
--(0.5 + f)
--(0.5 - 0)
+-(0.5 + f32)
+-(0.5 + f64)
+-(0.5 + i)
+-(0.5 + i32)
+-(0.5 + i64)
 -(0.5 - 0.5)
 -(0.5 - 1)
--(0.5 - 2)
--(0.5 - a)
--(0.5 - b)
--(0.5 - f)
--(0.5 / 0)
--(0.5 / 2)
--(0.5 / a)
--(0.5 / b)
--(0.5 / f)
+-(0.5 - f32)
+-(0.5 - f64)
+-(0.5 - i)
+-(0.5 - i32)
+-(0.5 - i64)
+-(0.5 / 0.5)
+-(0.5 / 0.5) < i32
+-(0.5 / 1)
+-(0.5 / f32)
+-(0.5 / f64)
+-(0.5 / i)
+-(0.5 / i32)
+-(0.5 / i64)
 -(0.5 ^ 0.5)
--(0.5 ^ 2)
--(0.5 ^ a)
--(0.5 ^ b)
--(1 % 2)
--(1 % a)
--(1 % b)
--(1 * 0)
+-(0.5 ^ 1)
+-(0.5 ^ f32)
+-(0.5 ^ f64)
+-(0.5 ^ i)
+-(0.5 ^ i32)
+-(0.5 ^ i64)
+-(1 % 1)
+-(1 % i)
+-(1 % i32)
+-(1 % i64)
+-(1 * 0.5)
 -(1 * 1)
--(1 * a)
--(1 ** a)
--(1 ** f)
+-(1 * f32)
+-(1 * i)
+-(1 * i32)
+-(1 * i64)
+-(1 ** 0.5)
+-(1 ** 1)
+-(1 ** f32)
+-(1 ** f64)
+-(1 ** i)
+-(1 ** i32)
+-(1 ** i64)
+-(1 + 0.5)
 -(1 + 1)
--(1 + a)
--(1 + b)
--(1 - 0)
--(1 - 0.5) / a
--(1 - a)
--(1 - b)
--(1 - f)
--(1 / 0)
+-(1 + f32)
+-(1 + f64)
+-(1 + i)
+-(1 + i32)
+-(1 + i64)
+-(1 - 0.5)
+-(1 - 1)
+-(1 - f32)
+-(1 - f64)
+-(1 - i)
+-(1 - i32)
+-(1 - i64)
 -(1 / 0.5)
--(1 / 2)
--(1 / f)
+-(1 / 1)
+-(1 / f32)
+-(1 / f64)
+-(1 / i)
+-(1 / i32)
+-(1 / i64)
 -(1 ^ 0.5)
--(1 ^ b)
--(1 ^ f)
--(2 % a)
--(2 % b)
--(2 * 0)
--(2 * 2)
--(2 * b)
--(2 * f)
--(2 ** b)
--(2 + 0.5)
--(2 + a)
--(2 + b)
--(2 + f)
--(2 - 0.5)
--(2 - 2)
--(2 - b)
--(2 / 0)
--(2 / 0.5)
--(2 / a)
--(2 ^ 1)
--(2 ^ 2)
--(2 ^ a)
--(a % 1)
--(a % 2)
--(a % a)
--(a % b)
--(a * 0)
--(a * 1)
--(a * 2)
--(a * a)
--(a * b)
--(a * f)
--(a ** 0)
--(a ** 0.5)
--(a ** a)
--(a ** b)
--(a ** f)
--(a + 0)
--(a + 1)
--(a + 2)
--(a + a)
--(a + b)
--(a + f)
--(a - 0)
--(a - 1)
--(a - 2)
--(a - a)
--(a - b)
--(a - f)
--(a / 0)
--(a / 0.5)
--(a / 1)
--(a / 2)
--(a / a)
--(a / b)
--(a ^ 0)
--(a ^ 0.5)
--(a ^ 2)
--(a ^ a)
--(a ^ b)
--(a ^ f)
--(b % 1)
--(b % a)
--(b % b)
--(b % obj.a)
--(b * 0)
--(b * 0.5)
--(b * 1)
--(b * 2)
--(b * a)
--(b * b)
--(b * f)
--(b ** 0)
--(b ** 0.5)
--(b ** 1)
--(b ** a)
--(b ** b)
--(b ** f)
--(b + 0)
--(b + 1)
--(b + 2)
--(b + a)
--(b + b)
--(b + f)
--(b - 0.5)
--(b - 1)
--(b - 2)
--(b - 2) - b
--(b - a)
--(b - b)
--(b - f)
--(b / 0)
--(b / 0.5)
--(b / 1)
--(b / 2)
--(b / a)
--(b / b)
--(b / f)
--(b ^ 0)
--(b ^ 0.5)
--(b ^ 1)
--(b ^ 2)
--(b ^ a)
--(b ^ b)
--(b ^ f)
--(f * 0)
--(f * 0.5)
--(f * 1)
--(f * 2)
--(f * a)
--(f * b)
--(f * f)
--(f * int(a))
--(f ** 0)
--(f ** 0.5)
--(f ** 1)
--(f ** a)
--(f ** b)
--(f ** f)
--(f + 2)
--(f + a)
--(f + b)
--(f + f)
--(f + f) - b
--(f - 0)
--(f - 1)
--(f - 2)
--(f - a)
--(f - b)
--(f - f)
--(f - obj.a)
--(f / 0)
--(f / 0.5)
--(f / a)
--(f / b)
--(f / f)
--(f ^ 0)
--(f ^ 0.5)
--(f ^ 1)
--(f ^ 2)
--(f ^ a)
--(f ^ b)
--(f ^ f)
--(obj.fn(b) + b)
--(obj.head(1) - a)
--(obj.head(b, 2, f, nil) / obj.a)
---(a % b)
---(f ** a)
---0
+-(1 ^ 1)
+-(1 ^ f32)
+-(1 ^ f64)
+-(1 ^ i)
+-(1 ^ i32)
+-(1 ^ i64)
+-(f32 * 0.5)
+-(f32 * 1)
+-(f32 * f32)
+-(f32 * f64)
+-(f32 * i)
+-(f32 * i32)
+-(f32 * i64)
+-(f32 ** 0.5)
+-(f32 ** 1)
+-(f32 ** f32)
+-(f32 ** f64)
+-(f32 ** i)
+-(f32 ** i32)
+-(f32 ** i64)
+-(f32 + 0.5)
+-(f32 + 1)
+-(f32 + f32)
+-(f32 + f64)
+-(f32 + i)
+-(f32 + i32)
+-(f32 + i64)
+-(f32 - 0.5)
+-(f32 - 1)
+-(f32 - f64)
+-(f32 - i - f32)
+-(f32 - i)
+-(f32 - i32)
+-(f32 - i64)
+-(f32 / 0.5)
+-(f32 / 1)
+-(f32 / f32)
+-(f32 / f64)
+-(f32 / i)
+-(f32 / i32)
+-(f32 / i64)
+-(f32 ^ 0.5)
+-(f32 ^ 1)
+-(f32 ^ f32)
+-(f32 ^ i)
+-(f32 ^ i32)
+-(f32 ^ i64)
+-(f64 * 0.5)
+-(f64 * 1)
+-(f64 * f32)
+-(f64 * f64)
+-(f64 * i)
+-(f64 * i32)
+-(f64 * i64)
+-(f64 ** 0.5)
+-(f64 ** 1)
+-(f64 ** f32)
+-(f64 ** f64)
+-(f64 ** i)
+-(f64 ** i32)
+-(f64 ** i32) > i32
+-(f64 ** i64)
+-(f64 + 0.5)
+-(f64 + 1)
+-(f64 + f32)
+-(f64 + i)
+-(f64 + i32)
+-(f64 + i64)
+-(f64 - 0.5)
+-(f64 - 1)
+-(f64 - f32)
+-(f64 - f64)
+-(f64 - i)
+-(f64 - i32)
+-(f64 - i64)
+-(f64 / 0.5)
+-(f64 / 1)
+-(f64 / f32)
+-(f64 / f64)
+-(f64 / i)
+-(f64 / i32)
+-(f64 / i64)
+-(f64 ^ 0.5)
+-(f64 ^ 1)
+-(f64 ^ f32)
+-(f64 ^ f64)
+-(f64 ^ i)
+-(f64 ^ i32)
+-(f64 ^ i64)
+-(i % 1)
+-(i % i)
+-(i % i32)
+-(i % i64)
+-(i % score(1))
+-(i * 0.5)
+-(i * 1)
+-(i * f32)
+-(i * f64)
+-(i * i)
+-(i * i32)
+-(i * i64)
+-(i ** 1)
+-(i ** f32)
+-(i ** f64)
+-(i ** i)
+-(i ** i32)
+-(i ** i64)
+-(i ** int(i))
+-(i + 0.5)
+-(i + 1)
+-(i + f32)
+-(i + f64)
+-(i + i)
+-(i + i64)
+-(i - 0.5)
+-(i - 1)
+-(i - f32)
+-(i - f64)
+-(i - i)
+-(i - i32)
+-(i / 0.5)
+-(i / 1)
+-(i / f32)
+-(i / f64)
+-(i / i)
+-(i / i32)
+-(i ^ 0.5)
+-(i ^ 1)
+-(i ^ f32)
+-(i ^ f64)
+-(i ^ i)
+-(i32 % 1 % i)
+-(i32 % 1)
+-(i32 % i)
+-(i32 % i32)
+-(i32 % i64)
+-(i32 * 0.5)
+-(i32 * 1)
+-(i32 * f32)
+-(i32 * f64)
+-(i32 * i)
+-(i32 * i32)
+-(i32 * i64)
+-(i32 ** 0.5)
+-(i32 ** 1)
+-(i32 ** f32)
+-(i32 ** i)
+-(i32 ** i32)
+-(i32 ** i64)
+-(i32 + 0.5)
+-(i32 + 1 ^ i64)
+-(i32 + 1)
+-(i32 + f32)
+-(i32 + f64)
+-(i32 + i)
+-(i32 + i32)
+-(i32 + i64)
+-(i32 - 0.5)
+-(i32 - 1)
+-(i32 - f32)
+-(i32 - f64)
+-(i32 - i)
+-(i32 - i32)
+-(i32 - i64)
+-(i32 / 0.5)
+-(i32 / 1)
+-(i32 / f32)
+-(i32 / f64)
+-(i32 / i)
+-(i32 / i32)
+-(i32 / i64)
+-(i32 ^ 0.5)
+-(i32 ^ 1)
+-(i32 ^ f32)
+-(i32 ^ f64)
+-(i32 ^ i)
+-(i64 % 1)
+-(i64 % i)
+-(i64 % i32)
+-(i64 % i64)
+-(i64 * 0.5)
+-(i64 * 1)
+-(i64 * f32)
+-(i64 * f64)
+-(i64 * i)
+-(i64 * i32)
+-(i64 * i64)
+-(i64 ** 0.5)
+-(i64 ** 1)
+-(i64 ** f32)
+-(i64 ** f64)
+-(i64 ** i)
+-(i64 ** i32)
+-(i64 ** i64)
+-(i64 + 0.5)
+-(i64 + 1)
+-(i64 + f32)
+-(i64 + f64)
+-(i64 + i)
+-(i64 + i32)
+-(i64 + i64)
+-(i64 - 0.5)
+-(i64 - 1)
+-(i64 - f64)
+-(i64 - i)
+-(i64 - i32)
+-(i64 - i64)
+-(i64 / 0.5)
+-(i64 / 1 / 1)
+-(i64 / 1)
+-(i64 / f32)
+-(i64 / f64)
+-(i64 / i)
+-(i64 / i32)
+-(i64 / i64)
+-(i64 ^ 0.5)
+-(i64 ^ 1)
+-(i64 ^ f32)
+-(i64 ^ f64)
+-(i64 ^ i)
+-(i64 ^ i32)
+-(i64 ^ i64)
+-(max(0.5) + i64)
+--(1 * i64)
+--(i64 * 1)
+---1
+---i
 --0.5
 --1
---2
---a
---abs(b)
---b
---f
---int(0.5)
---obj.a
---obj.b
---obj.b % b
--0 != a ? ok : 0
--0 != b
--0 != f
--0 != obj.b
--0 % a
--0 * obj.fn(2)
--0 ** a
--0 ** b
--0 - a
--0 - abs(2)
--0 - div(a, a)
--0 - obj.a
--0 - obj.b
--0 .. 1 * a
--0 .. obj.b
--0 / b
--0 / obj.a
--0 / obj.head(1, a)
--0 / obj?.a
--0 < a
--0 < b
--0 < f
--0 <= a
--0 <= f
--0 == a
--0 == b / 0
--0 == nil ? b : obj
--0 > b * f
--0 > f
--0 >= -0
--0 >= a
--0 >= obj?.b
--0 ^ -0
--0 ^ a
--0 ^ b
--0 ^ f
--0 in arr
--0.5 != 0.5 ? s : b
--0.5 != a
--0.5 != nil ? false : nil
--0.5 * obj?.b
--0.5 + b
--0.5 - add(0, a)
--0.5 - f
--0.5 / a
--0.5 / obj?.fn(a)
--0.5 < f
--0.5 <= f ? f : add
--0.5 == 0 % b
--0.5 >= 0 == ok
--0.5 >= obj.b
--0.5 ^ (a / b)
--1 % a
--1 * -b
--1 ** b
--1 ** obj.b
--1 + b
--1 - b
--1 - f
--1 .. obj?.a
--1 / b
--1 > 2 != nil
--1 > a
--1 > b
--1 > obj?.b
--1 >= f ? arr : div
--1 ^ (f / a)
--1 ^ b
--1 ^ obj.head(a)
--2 != b
--2 != f
--2 * f
--2 ** f
--2 ** min(0, f)
--2 - 0.5 ^ 0
--2 .. -b
--2 .. a
--2 < abs(1)
--2 < f ** a
--2 < obj.b
--2 == obj?.b
--2 ^ a
--2 ^ b
--2 ^ f
--a
--a != f
--a != obj.fn(a)
--a != obj.obj?.a
--a % int(a)
--a * b
--a * obj.a
--a ** a
--a ** f
--a ** float(2)
--a ** max(a)
--a + b
--a + obj.b
--a - f
--a .. a
--a .. obj.a
--a / f
--a / max(0.5)
--a < f
--a < obj?.a
--a <= a ** b
--a == 0 + b
--a == a
--a > add(a, a)
--a > b
--a > get(arr, 1)
--a > obj.b
--a >= a - 0
--a >= obj?.b
--a ^ a
--a ^ f
--abs(0)
+--abs(f64)
+--f32
+--f64
+--i
+--i32
+--i64
+--max(0.5)
+-0.5 != 1 ? array : f64
+-0.5 != f32
+-0.5 != f64 ** 0.5
+-0.5 != i32
+-0.5 != max(i64)
+-0.5 * f64
+-0.5 * i
+-0.5 * i32
+-0.5 * i64
+-0.5 * len(array)
+-0.5 ** f32
+-0.5 ** i
+-0.5 ** i32
+-0.5 ** i64
+-0.5 + f32
+-0.5 + f64
+-0.5 + f64 / f64
+-0.5 + i
+-0.5 + i32
+-0.5 - -i32
+-0.5 - 1 + 1
+-0.5 - f32
+-0.5 - f64
+-0.5 - i
+-0.5 - i32
+-0.5 - i32 * i
+-0.5 / (f32 + 0.5)
+-0.5 / -i32
+-0.5 / f32
+-0.5 / f64
+-0.5 / float(f64)
+-0.5 / i
+-0.5 / i64
+-0.5 / i64 ** 1
+-0.5 < f32
+-0.5 < f64
+-0.5 < i32
+-0.5 < i32 ? false : "bar"
+-0.5 < i32 ^ f64
+-0.5 <= 1 == false
+-0.5 <= f32
+-0.5 <= f64
+-0.5 <= f64 + f32
+-0.5 <= i64
+-0.5 == f32
+-0.5 == f64 / 0.5
+-0.5 == i
+-0.5 == i32
+-0.5 == i64
+-0.5 > f32
+-0.5 > f64
+-0.5 > i32
+-0.5 > i64
+-0.5 >= f64
+-0.5 >= i
+-0.5 >= i32
+-0.5 >= i64
+-0.5 ^ f32
+-0.5 ^ f64
+-0.5 ^ i
+-0.5 ^ i32
+-0.5 ^ i64
+-1 != f64
+-1 != i
+-1 != i64
+-1 != i64 * f32
+-1 % i32
+-1 % i64
+-1 * 1 ** i64
+-1 * f32
+-1 * i32
+-1 * i64
+-1 ** f32
+-1 ** i
+-1 ** i64
+-1 + 1 + 0.5
+-1 + f32
+-1 + half(f64)
+-1 + i
+-1 + i64
+-1 - f32
+-1 - i
+-1 - i32
+-1 - i64
+-1 .. i
+-1 .. i32
+-1 .. i64
+-1 / 1 * 1
+-1 / f32
+-1 / i32
+-1 < 0.5 ^ i64
+-1 < f32
+-1 < f64 * 1
+-1 < i32
+-1 < i64
+-1 <= f32
+-1 <= f32 == true
+-1 <= f64
+-1 <= i32
+-1 == f32
+-1 == f64
+-1 == nil != nil
+-1 > -i32
+-1 > f32
+-1 > half(0.5)
+-1 > i
+-1 > i32
+-1 > i64
+-1 > i64 ? array : nil
+-1 >= 0.5 * 0.5
+-1 >= f32
+-1 >= f64
+-1 >= i32
+-1 >= i32 - 1
+-1 >= i64
+-1 ^ f32
+-1 ^ f64
+-1 ^ i64
+-1 in array
+-1 not in array
+-abs(0.5 * f64)
 -abs(0.5)
 -abs(1)
--abs(2 / f)
--abs(2)
--abs(a)
--abs(b)
--abs(f)
--add(0, 0)
--add(0, 2)
--add(0, a)
--add(0, b)
--add(1, 0)
+-abs(1) .. i
+-abs(f32)
+-abs(f64)
+-abs(i)
+-abs(i32)
+-abs(i64)
 -add(1, 1)
--add(1, 2)
--add(1, a)
--add(1, b)
--add(2, 0)
--add(a, 0)
--add(a, 2)
--add(a, a)
--add(a, b)
--add(b, 0)
--add(b, 1)
--add(b, 2)
--add(b, a)
--add(b, b)
--add(b, ok ? a : "b")
--arr[0]
--arr[1]
--arr[2]
--arr[a]
--arr[b]
--b
--b != a
--b != b
--b != f
--b != obj.a
--b % b
--b % b % obj.b
--b % obj.b
--b % obj.fn(a)
--b * a
--b * b
--b ** a
--b + a
--b + obj?.b
--b - a
--b - b
--b - f
--b - obj.a
--b .. b
--b / a ^ 0.5
--b / b
--b / obj?.a
--b < 2 / 0
--b < b
--b < f
--b <= f
--b <= obj?.a
--b <= obj?.b
--b == int(0)
--b == len("b")
--b == max(0)
--b > a
--b > a * 0.5
--b > b
--b > b ? b : 1
--b > div(2, b)
--b > obj.b
--b >= a
--b >= b
--b >= f
--b >= f ? b : true
--b >= obj.head(a)
--b ^ (b - 0.5)
--b ^ a
--count(arr, false)
--count(arr, ok)
--count(arr, true)
--div(0, 2)
--div(0, a)
--div(0, b)
+-add(i, 1)
+-array[1]
+-array[i32]
+-array[i64]
+-array[i]
+-count(array, false)
+-count(array, ok)
+-count(array, true)
+-count(list, ok)
+-count(list, true)
 -div(1, 1)
--div(1, 2)
--div(1, b)
--div(2, 1)
--div(2, 1) / a
--div(2, a)
--div(2, b)
--div(a, 1)
--div(a, 2)
--div(a, a)
--div(a, b)
--div(a, obj.a)
--div(b, 1)
--div(b, a)
--div(b, b)
--f
--f != a
--f != f
--f != f != true
--f != len(s)
--f != obj.b
--f != obj.fn(b)
--f * a
--f * b ^ a
--f ** -a
--f ** b
--f + a
--f + b
--f + f
--f + int(b)
--f + obj.a
--f - a * 1
--f - arr[b]
--f - b
--f - f
--f / add(a, b)
--f / b
--f / f
--f / f ^ b
--f < a
--f < f ? ok : b
--f < f ^ b
--f < obj.a
--f <= a
--f <= f
--f == add(0, b)
--f == f
--f == obj.obj
--f == obj?.obj
--f > a
--f > f / a
--f > len(s)
--f > obj.a
--f >= 0 / b
--f >= a
--f >= a * a
--f >= b
--f >= obj.a
--f ^ a
--f ^ a ** f
--f ^ f
--first(arr)
--first(arr) < f
--first(arr) ^ a
--float(0)
+-div(1, i)
+-div(i, i)
+-f32
+-f32 != 1 / i
+-f32 != f32
+-f32 != f64
+-f32 != i64
+-f32 * 1 ** i32
+-f32 * f32
+-f32 ** f32
+-f32 ** f32 ** 1
+-f32 ** i64
+-f32 + f32
+-f32 + i32
+-f32 + i64
+-f32 - f32
+-f32 - f64
+-f32 - i
+-f32 - i32
+-f32 - i64
+-f32 / f32
+-f32 / i32
+-f32 / i64
+-f32 < f64
+-f32 < i32
+-f32 < i64
+-f32 <= i
+-f32 <= i32
+-f32 == f32
+-f32 == f64
+-f32 == i
+-f32 == i32
+-f32 == i64
+-f32 > f32
+-f32 > f64
+-f32 > i
+-f32 > i64
+-f32 >= 1 / f32
+-f32 >= f32
+-f32 >= f64
+-f32 >= i64
+-f32 ^ f32
+-f32 ^ f64
+-f32 ^ i64
+-f32 ^ min(f64)
+-f64
+-f64 != f64
+-f64 != i
+-f64 != i64
+-f64 * f64
+-f64 ** f32
+-f64 ** i32
+-f64 ** i64
+-f64 + f32
+-f64 + i32
+-f64 + i64
+-f64 - 0.5 / i32
+-f64 - f64
+-f64 - i32
+-f64 / f64
+-f64 / i
+-f64 / i64
+-f64 < f32
+-f64 < i
+-f64 <= f32
+-f64 <= f64
+-f64 <= i32
+-f64 == f32
+-f64 == i
+-f64 == i32
+-f64 > f64
+-f64 > i32
+-f64 > i64
+-f64 >= f64
+-f64 >= f64 ^ 0.5
+-f64 >= i
+-f64 ^ 0.5 ** i64
+-f64 ^ f32
+-f64 ^ f64
+-f64 ^ i
+-f64 ^ i32
+-f64 ^ i64
+-find(array, ok)
+-find(array, true)
+-findIndex(array, ok)
+-findIndex(array, true)
+-findIndex(list, ok)
+-findLast(array, ok)
+-findLast(array, true)
+-findLastIndex(array, ok)
+-findLastIndex(array, true)
+-findLastIndex(list, ok)
+-findLastIndex(list, true)
+-first(array)
+-float(-1)
 -float(0.5)
--float(2)
--float(a)
--float(b)
--float(f)
--get(arr, 0)
--get(arr, 1)
--get(arr, 2)
--get(arr, a)
--get(arr, b)
--indexOf(s, "c")
--indexOf(s, s)
--int(0)
+-float(1)
+-float(f32 ** 0.5)
+-float(f32)
+-float(f64)
+-float(i)
+-float(i32)
+-float(i64)
+-get(array, 1)
+-get(array, i)
+-get(array, i32)
+-get(array, i64)
+-half(-1)
+-half(0.5)
+-half(f64)
+-i
+-i != f64
+-i != i32
+-i != i32 * 1
+-i != i64
+-i % i
+-i % i32
+-i % i64
+-i * f32
+-i * f64
+-i * i32
+-i * i64
+-i ** f32
+-i ** f64
+-i ** i32
+-i ** i64
+-i + f32
+-i + i
+-i + i32
+-i + i64
+-i - f32
+-i - f64
+-i - i
+-i - i64
+-i .. i32
+-i / f64
+-i / i
+-i / i32
+-i / i64
+-i < f32
+-i < i64
+-i <= f32
+-i <= i32
+-i == -0.5
+-i == 1 ** f64
+-i == 1 + 0.5
+-i > f32
+-i > i
+-i > i32
+-i >= f32
+-i >= i32
+-i ^ -i
+-i ^ f64
+-i ^ i32
+-i not in array
+-i32
+-i32 != f32
+-i32 != f64
+-i32 != i
+-i32 != i64
+-i32 % i32
+-i32 % i64
+-i32 * f32
+-i32 * f64
+-i32 * i
+-i32 * i32
+-i32 ** f64
+-i32 ** i32
+-i32 ** i64
+-i32 + 1 + i
+-i32 + f32
+-i32 + f64
+-i32 + i
+-i32 + i32
+-i32 - i32
+-i32 - i64
+-i32 .. i
+-i32 .. i64
+-i32 / (i32 - f64)
+-i32 / f64
+-i32 / i
+-i32 < 0.5 * 1
+-i32 < f32
+-i32 < f64 - f64
+-i32 < i32
+-i32 < i64
+-i32 <= 0.5 ? f64 : 1
+-i32 <= f32
+-i32 <= f64
+-i32 <= f64 + i
+-i32 == f32
+-i32 == i32
+-i32 > i
+-i32 > i32
+-i32 > i64
+-i32 >= f32
+-i32 >= f64
+-i32 >= i64
+-i32 ^ (i - 0.5)
+-i32 ^ i
+-i32 ^ i32
+-i32 ^ i64
+-i32 ^ i64 ** i32
+-i32 in array
+-i32 not in array
+-i64
+-i64 != i
+-i64 != i ? i : foo
+-i64 != i64
+-i64 % i
+-i64 % i32
+-i64 * f32
+-i64 * f64
+-i64 * i
+-i64 * i32
+-i64 * i64
+-i64 ** f64
+-i64 ** i64
+-i64 + 0.5 * i32
+-i64 + f64
+-i64 + i
+-i64 - f32
+-i64 - f64
+-i64 - i32
+-i64 - i64
+-i64 .. i
+-i64 .. i32
+-i64 / f32
+-i64 / i
+-i64 / i64
+-i64 / i64 * f32
+-i64 < -0.5
+-i64 < f32
+-i64 < f64
+-i64 < i
+-i64 < i32
+-i64 < i64
+-i64 <= i32
+-i64 <= i64
+-i64 == f32
+-i64 == i
+-i64 == i32
+-i64 == i64
+-i64 > f32
+-i64 > f64
+-i64 > i32
+-i64 >= i
+-i64 >= i32
+-i64 >= i64
+-i64 ^ f64
+-i64 ^ i32
+-i64 ^ i64
+-i64 not in array
+-i64 not in sort(array)
 -int(0.5)
 -int(1)
--int(2)
--int(a)
--int(b)
--int(f)
--int(obj?.a)
--last(arr)
--len("b")
--len(arr)
--len(map(arr, obj))
--len(obj)
--len(s)
--max(0)
+-int(f32)
+-int(f64)
+-int(i)
+-int(i32)
+-int(i64 - i)
+-int(i64)
+-int(int(1))
+-last(array)
+-len("bar")
+-len("foo")
+-len([foo])
+-len(array)
+-len(false ? greet : "foo")
+-len(list)
+-max(0.5 * i)
 -max(0.5)
--max(0.5, f)
+-max(0.5, 1)
 -max(1)
--max(1, 2)
--max(1, a)
--max(2)
--max(a)
--max(a, f)
--max(b)
--max(b, 0, f)
--max(f)
--max(f, b)
--min(0)
--min(0, b)
--min(0.5, b)
+-max(f32)
+-max(f32, 0.5, f32)
+-max(f32, i64)
+-max(f64)
+-max(i)
+-max(i, 1)
+-max(i, i64)
+-max(i32)
+-max(i32, 0.5)
+-max(i64)
+-max(score(1))
+-min(0.5)
+-min(0.5, 1)
+-min(0.5, i32)
 -min(1)
--min(2)
--min(a)
--min(a, b)
--min(b)
--min(b, 1)
--min(f)
--min(f, 0)
--obj.a
--obj.a > f
--obj.a ^ b
--obj.b
--obj.fn(0)
--obj.fn(1)
--obj.fn(2)
--obj.fn(a - b)
--obj.fn(a)
--obj.fn(b)
--obj.fn(count("c", true))
--obj.head(0)
--obj.head(0, arr)
--obj.head(0, obj)
--obj.head(0, s)
--obj.head(0.5)
--obj.head(0.5, add)
--obj.head(0.5, b, add)
--obj.head(0.5, div, ok)
--obj.head(0.5, f)
--obj.head(0.5, true)
--obj.head(1)
--obj.head(1, "a", nil)
--obj.head(1, f)
--obj.head(1, ok, arr)
--obj.head(2)
--obj.head(2, 1, b)
--obj.head(2, arr)
--obj.head(2, ok, 2)
--obj.head(a)
--obj.head(a, div, "a", b)
--obj.head(a, f, add, "a")
--obj.head(a, nil)
--obj.head(a, true, obj)
--obj.head(b)
--obj.head(b, "b", s, ok)
--obj.head(b, add)
--obj.head(b, b, ok, obj)
--obj.head(b, f)
--obj.head(b, nil, add, ok)
--obj.head(b, nil, f)
--obj.head(b, nil, true)
--obj.head(f)
--obj.head(f, 0, add)
--obj.head(f, b)
--obj.head(f, ok)
--obj.head(first("a"))
--obj.head(obj, 0.5)?.b
--obj.obj.a
--obj.obj.b
--obj.obj.obj?.a
--obj.obj.obj?.b
--obj.obj?.a
--obj.obj?.b
--obj.obj?.obj?.obj
--obj?.a
--obj?.a != a
--obj?.a > b
--obj?.b
--obj?.fn(0)
--obj?.fn(1)
--obj?.fn(2)
--obj?.fn(a)
--obj?.fn(b)
--obj?.head(0)
--obj?.head(0, 0.5, s)
--obj?.head(0, 2)
--obj?.head(0, add)
--obj?.head(0, b)
--obj?.head(0, nil)
--obj?.head(0, nil, obj, obj, 2)
--obj?.head(0, obj, ok, nil)
--obj?.head(0, s)
--obj?.head(0.5)
--obj?.head(0.5, a)
--obj?.head(0.5, add)
--obj?.head(0.5, f, arr)
--obj?.head(0.5, obj)
--obj?.head(1)
--obj?.head(2)
--obj?.head(a)
--obj?.head(a, "c", "a")
--obj?.head(a, 0, f, b, a)
--obj?.head(a, 1, a)
--obj?.head(a, a)
--obj?.head(a, obj, obj)
--obj?.head(a, ok, b)
--obj?.head(a, s)
--obj?.head(b)
--obj?.head(b, 0)
--obj?.head(b, 0, obj)
--obj?.head(b, 0.5, arr)
--obj?.head(b, 1)
--obj?.head(b, false, add)
--obj?.head(b, nil)
--obj?.head(b, ok)
--obj?.head(f)
--obj?.head(f, add, ok)
--obj?.head(f, obj)
--obj?.head(f, obj, 0)
--obj?.head(f, ok)
--obj?.head(f, true, nil)
--obj?.head(min(nil, 2, a), a)
--obj?.obj.a
--obj?.obj.b
--obj?.obj?.a
--obj?.obj?.b
--obj?.obj?.obj.b
--obj?.obj?.obj?.obj
-0 != 0.5 == obj?.head(a)
-0 != 0.5 ? s <= s : obj?.head(false)
-0 != 2 && s != "c"
-0 != a || a != f
-0 != arr[b]
-0 != arr[obj.a]
-0 != b and f != 0
-0 != b and obj.head(b, "b", div)
-0 != b || obj.b
-0 != b || obj.obj
-0 != f or 0.5 == 1
-0 != nil and obj?.b
-0 != obj.a
-0 != obj.a % a
-0 != obj.b
-0 != obj.head(arr)
-0 != obj.head(obj)
-0 != obj.obj
-0 != obj.obj?.a
-0 != obj.obj?.obj
-0 != obj.obj?.obj?.b
-0 != obj?.a
-0 != obj?.b
-0 != obj?.b ^ b
-0 != obj?.head(b)
-0 != obj?.head(ok, a)
-0 != obj?.obj
-0 != obj?.obj.a
-0 % 1 - obj.b
-0 % 1 < b ^ 0
-0 % 1 == f
-0 % 1 >= obj.a
-0 % a - b
-0 % a < a
-0 % a <= a * f
-0 % arr[b]
-0 % b != f
-0 % b % div(b, b)
-0 % b * a
-0 % b * f
-0 % b + add(a, a)
-0 % b + b
-0 % b + obj?.a
-0 % b / b / 0.5
-0 % b == obj.head(s, 0)
-0 % b >= a
-0 % obj.a
-0 % obj.b
-0 % obj?.a
-0 % obj?.b
-0 % obj?.fn(b)
-0 % obj?.head(b)
-0 % obj?.obj.b
-0 * 0 / b
-0 * 0 < f
-0 * 0 <= a
-0 * 0 <= obj.a
-0 * 0 == a
-0 * 0 >= a
-0 * 0.5 + a
-0 * 0.5 / b
-0 * 0.5 < b
-0 * 0.5 <= int(a)
-0 * 0.5 >= max(0)
-0 * 1 < 0 - a
-0 * 1 == a
-0 * 1 > f
-0 * a + obj?.b
-0 * a / f
-0 * a == f ** 0
-0 * a == obj[s]
-0 * a > f
-0 * a in arr
-0 * arr[0 - 0]
-0 * arr[b]
-0 * b != f
-0 * b * f
-0 * b + f
-0 * b + obj?.a
-0 * b < obj.b
-0 * b == b
-0 * f != a
-0 * f != a % 1
-0 * f != f
-0 * f * b
-0 * f + b
-0 * f - b
-0 * f < obj?.b
-0 * f < obj?.head(f, obj)
-0 * f <= b + 0
-0 * f <= obj.a
-0 * f >= b ^ 2
-0 * obj.a
-0 * obj.b
-0 * obj.head(b + f)
-0 * obj?.a
-0 * obj?.b
-0 * obj?.fn(abs(obj.b))
-0 ** 0 - f
-0 ** 0 <= f != ok
-0 ** 0 ^ a
-0 ** 0.5 + a
-0 ** 0.5 - b
-0 ** 0.5 <= a
-0 ** 0.5 <= f
-0 ** 0.5 <= obj.fn(a)
-0 ** 0.5 ^ (b - 0)
-0 ** 1 * add(0, a)
-0 ** 1 > b
-0 ** 2 * f
-0 ** 2 * obj?.b
-0 ** 2 <= a ? true : div
-0 ** 2 > b
-0 ** a * -2
-0 ** a == b
-0 ** a ^ (0 % 2)
-0 ** b != f
-0 ** b - b ^ 2
-0 ** b > f ? s : add
-0 ** f * obj?.b
-0 ** f + b
-0 ** f > f
-0 ** f >= f
-0 ** obj.a
-0 ** obj.b
-0 ** obj?.a
-0 ** obj?.b
-0 ** obj?.head(b)
-0 + 0 == obj?.a
-0 + 0.5 == obj?.head(nil, true, b, arr)
-0 + 2 < f
-0 + a != f
-0 + a + b
-0 + a .. a
-0 + a .. get(arr, 0)
-0 + a > b
-0 + b + a
-0 + b < a
-0 + b == f * f
-0 + f - b
-0 + f < obj.a
-0 + f < obj.b
-0 + f > b
-0 + f >= a
-0 + obj.a
-0 + obj.a != div
-0 + obj.b
-0 + obj.b == s
-0 + obj.obj?.b
-0 + obj?.a
-0 + obj?.b
-0 - 0 .. obj?.a
-0 - 0 in arr
-0 - 0.5 != obj.b
-0 - 0.5 >= obj.a
-0 - 1 + a
-0 - 1 + b
-0 - 1 > obj.head(f, a)
-0 - a - a
-0 - a .. a
-0 - a < a
-0 - a <= a
-0 - a > a
-0 - a >= a
-0 - b .. obj?.b
-0 - b < 0 / 2
-0 - b < a
-0 - b < obj.a
-0 - b <= a
-0 - b >= b
-0 - b in arr
-0 - f != 0.5 == false
-0 - f + div(b, a)
-0 - f < a
-0 - f <= b
-0 - obj.a
-0 - obj.b
-0 - obj.obj.b
-0 - obj?.a
-0 - obj?.b
-0 .. b != arr
-0 .. obj.a
-0 .. obj.b
-0 .. obj.fn(a)
-0 .. obj.obj.a
-0 .. obj?.a
-0 .. obj?.b
-0 .. obj?.obj.a
-0 / 0 - f
-0 / 0 > f ? arr : b
-0 / 0.5 - a
-0 / 1 / abs(0)
-0 / 1 > b
-0 / 2 <= b
-0 / a != f / f
-0 / arr[a]
-0 / arr[b]
-0 / b != f + 2
-0 / b * obj.b
-0 / b / a
-0 / b == obj?.a
-0 / b >= f
-0 / f / f
-0 / f == b
-0 / obj.a
-0 / obj.b
-0 / obj.head(min(a), arr in arr)
-0 / obj?.a
-0 / obj?.b
-0 / obj?.fn(true and 2)
-0 / obj?.obj?.a
-0 < 0 && obj?.obj
-0 < 0 and obj?.fn(s, arr).b
-0 < 0.5 == ok
-0 < 1 || !ok
-0 < a && "c" in obj
-0 < arr[a]
-0 < b != obj?.b
-0 < b && 2 <= b
-0 < f && ok
-0 < f && true ? nil : 1
-0 < f or a in arr
-0 < obj.a
-0 < obj.b
-0 < obj.obj?.a
-0 < obj?.a
-0 < obj?.b
-0 <= 0 and obj.a
-0 <= 0 or obj?.b
-0 <= 0.5 != obj?.obj
-0 <= 0.5 and one(arr, true)
-0 <= 1 and 0 >= f
-0 <= a == none(arr, false)
-0 <= a || ok ? f : obj
-0 <= b ? a <= a : f
-0 <= obj.a
-0 <= obj.b
-0 <= obj?.a
-0 <= obj?.b
-0 <= obj?.obj.b
-0 <= obj?.obj?.b
-0 == 0 and div == nil
-0 == 2 or ok
-0 == a != ok
-0 == b or ok
-0 == b || ok
-0 == f == !true
-0 == f and obj?.a
-0 == nil or one(arr, true)
-0 == nil || obj.b
-0 == obj.a
-0 == obj.b
-0 == obj.obj
-0 == obj.obj.a
-0 == obj?.a
-0 == obj?.b
-0 == obj?.head(!(obj != div))
-0 == obj?.head(arr)
-0 == obj?.head(obj)
-0 == obj?.obj
-0 == obj?.obj.b
-0 == obj[toJSON(nil)]
-0 > 0 != nil == ok
-0 > 0.5 ? add : ok
-0 > 1 ? s : s
-0 > 2 && ok
-0 > a || 0 != 2
-0 > b != obj.a
-0 > b && "b" == s
-0 > b == ok
-0 > b or 0 == nil
-0 > f && 0 != b
-0 > f && obj.head(s)
-0 > obj.a
-0 > obj.b
-0 > obj.fn(obj?.b)
-0 > obj?.a
-0 > obj?.b
-0 > obj?.fn(a)
-0 > obj?.head(b)
-0 > obj?.obj.a
-0 >= 0.5 and ok ? arr : s
-0 >= 2 && obj?.a
-0 >= b != ok ? b : nil
-0 >= b && obj?.fn(true)
-0 >= b == obj?.head(b, s)
-0 >= b and b in obj?.obj
-0 >= f && obj.head(obj)
-0 >= f or ok
-0 >= obj.a
-0 >= obj.b
-0 >= obj.head(obj?.fn(b))
-0 >= obj?.a
-0 >= obj?.b
-0 >= obj?.obj.b
-0 >= obj?.obj?.a
-0 ^ 0 / f
-0 ^ 0 == f
-0 ^ 0.5 ** obj?.a
-0 ^ 0.5 - b
-0 ^ 0.5 <= f
-0 ^ 1 * a
-0 ^ 2 < a / b
-0 ^ 2 < f
-0 ^ 2 ^ f
-0 ^ a != a / a
-0 ^ a + b
-0 ^ a - obj.a
-0 ^ a - obj?.b
-0 ^ a < a
-0 ^ a <= b
-0 ^ b != b
-0 ^ b - -b
-0 ^ b / b
-0 ^ b >= b
-0 ^ b ^ f
-0 ^ f < obj.b
-0 ^ f <= obj?.a
-0 ^ f > f
-0 ^ obj.a
-0 ^ obj.b
-0 ^ obj.obj.b
-0 ^ obj.obj?.a
-0 ^ obj?.a
-0 ^ obj?.b
-0 in arr or s != nil
-0 in arr || ok
-0.5 != 0 == ok
-0.5 != 0 and ok
-0.5 != 0 || obj?.a
-0.5 != 0.5 == true ? a : arr
-0.5 != 0.5 || nil != s
-0.5 != 1 && s <= "b"
-0.5 != a || obj?.obj
-0.5 != b and false ? nil : add
-0.5 != b or ok
-0.5 != f and ok
-0.5 != nil && s >= s
-0.5 != obj.a
-0.5 != obj.b
-0.5 != obj.obj
-0.5 != obj.obj.obj
-0.5 != obj?.a
-0.5 != obj?.b
-0.5 != obj?.head(arr, obj)
-0.5 != obj?.obj
-0.5 != obj?.obj.b
-0.5 * 0 >= obj.head(a)
-0.5 * 0.5 * f
-0.5 * 0.5 / add(b, 0)
-0.5 * 0.5 < f ? obj : obj
-0.5 * 1 < f
-0.5 * a < f
-0.5 * a == f
-0.5 * a >= 0.5 ? "b" : b
-0.5 * arr[a]
-0.5 * b <= f
-0.5 * f < div(b, b)
-0.5 * f > div(a, b)
-0.5 * f > f
-0.5 * obj.a
-0.5 * obj.b
-0.5 * obj.fn(b)
-0.5 * obj.obj?.a
-0.5 * obj?.a
-0.5 * obj?.b
-0.5 * obj?.head(obj.a)
-0.5 * obj?.obj?.b
-0.5 ** 0 / a
-0.5 ** 0 <= b
-0.5 ** 0 ^ a
-0.5 ** 0.5 > f
-0.5 ** 0.5 >= f
-0.5 ** 1 != b
-0.5 ** 1 > b
-0.5 ** a + b
-0.5 ** a > b
-0.5 ** a > b ** 0
-0.5 ** a >= b
-0.5 ** a ^ obj?.b
-0.5 ** arr[b]
-0.5 ** arr[obj.a]
-0.5 ** b < a + b
-0.5 ** b > a
-0.5 ** b ^ obj?.a
-0.5 ** f * f
-0.5 ** f ** (a - 0)
-0.5 ** f <= -a
-0.5 ** f <= a
-0.5 ** f >= b
-0.5 ** obj.a
-0.5 ** obj.b
-0.5 ** obj.obj?.a
-0.5 ** obj?.a
-0.5 ** obj?.b
-0.5 ** obj?.obj?.b
-0.5 + 0 >= b ? f : s
-0.5 + 2 + a
-0.5 + 2 + b ^ a
-0.5 + a - -0
-0.5 + a - f
-0.5 + f != obj?.b
-0.5 + f == b / f
-0.5 + obj.a
-0.5 + obj.b
-0.5 + obj?.a
-0.5 + obj?.b
-0.5 - 0.5 > 0.5 - b
-0.5 - 1 + b
-0.5 - a != f + b
-0.5 - f != obj.head(s)
-0.5 - f - div(b, a)
-0.5 - f < f * a
-0.5 - f == obj.a
-0.5 - obj.a
-0.5 - obj.b
-0.5 - obj.head(f)
-0.5 - obj.head(min(0, b))
-0.5 - obj.obj.a
-0.5 - obj?.a
-0.5 - obj?.a * b > obj?.a
-0.5 - obj?.b
-0.5 - obj?.obj.a
-0.5 - obj?.obj.b
-0.5 - obj?.obj?.b
-0.5 / 0 * b
-0.5 / 0.5 * div(0, b)
-0.5 / 0.5 - b
-0.5 / 1 < b
-0.5 / 1 == obj.a
-0.5 / a * a
-0.5 / a <= b ? f : div
-0.5 / a > obj.head(b, s)
-0.5 / arr[a % 1]
-0.5 / b != f
-0.5 / b / f
-0.5 / b == get(arr, b)
-0.5 / b > a
-0.5 / b >= a
-0.5 / obj.a
-0.5 / obj.b
-0.5 / obj.obj.a
-0.5 / obj?.a
-0.5 / obj?.b
-0.5 / obj?.obj.a
-0.5 / obj?.obj.b
-0.5 < 0 && true ? ok : obj
-0.5 < 0 or obj?.b
-0.5 < 0 or obj?.obj
-0.5 < 0 || obj?.obj
-0.5 < 0 || ok
-0.5 < 0.5 && !false
-0.5 < 0.5 ? b - a : s
-0.5 < 0.5 in obj.head(arr, ok)
-0.5 < f != ok
-0.5 < obj.a
-0.5 < obj.b
-0.5 < obj.fn(a)
-0.5 < obj?.a
-0.5 < obj?.b
-0.5 <= 0 || arr != arr
-0.5 <= a != ok
-0.5 <= arr[b]
-0.5 <= b || obj.fn(true).a.obj
-0.5 <= f && ok
-0.5 <= f == obj.b
-0.5 <= obj.a
-0.5 <= obj.b
-0.5 <= obj?.a
-0.5 <= obj?.b
-0.5 <= obj?.b * b
-0.5 == 1 and obj.head(obj, f, true)
-0.5 == 2 || 0.5 < 0
-0.5 == a && obj?.b
-0.5 == b && ok
-0.5 == f != obj.a
-0.5 == f ? 0.5 ** 0 : div
-0.5 == f ? ok : obj
-0.5 == f or ok
-0.5 == nil != obj.obj
-0.5 == nil == obj.fn(b)
-0.5 == nil == obj.obj
-0.5 == obj.a
-0.5 == obj.a + b
-0.5 == obj.b
-0.5 == obj.fn(a)
-0.5 == obj.fn(b)
-0.5 == obj.head(s == add, arr)
-0.5 == obj.obj
-0.5 == obj?.a
-0.5 == obj?.b
-0.5 == obj?.fn(a)
-0.5 == obj?.obj
-0.5 > 0 == obj?.b
-0.5 > 0 ? b : b
-0.5 > 0.5 ? a ** 1 : add
-0.5 > 0.5 and obj?.a
-0.5 > 1 == true ? add : nil
-0.5 > a != not false
-0.5 > a == ok
-0.5 > b ? a : obj
-0.5 > f ? (false ? arr : ok) : obj.head(0.5, s, arr)
-0.5 > f and div == add
-0.5 > obj.a
-0.5 > obj.b
-0.5 > obj.head(a ** a)
-0.5 > obj.head(f)
-0.5 > obj?.a
-0.5 > obj?.b
-0.5 > obj?.head(obj.head(obj?.b))
-0.5 > obj?.obj?.b
-0.5 >= 0.5 && obj.head(add, 0, arr, 0.5, s)
-0.5 >= a and ok
-0.5 >= b == true ? nil : div
-0.5 >= b ? div : string(0.5)
-0.5 >= obj.a
-0.5 >= obj.b
-0.5 >= obj.obj?.a
-0.5 >= obj.obj?.b
-0.5 >= obj?.a
-0.5 >= obj?.b
-0.5 ^ 0 - 0 * 1
-0.5 ^ 0 - a
-0.5 ^ 0 <= a * a
-0.5 ^ 0 > f
-0.5 ^ 0.5 + a
-0.5 ^ 0.5 ^ f
-0.5 ^ 1 >= a
-0.5 ^ 2 == f
-0.5 ^ a + obj?.b
-0.5 ^ a ^ (b * 0)
-0.5 ^ arr[a]
-0.5 ^ b > a
-0.5 ^ b > f
-0.5 ^ b >= obj.a
-0.5 ^ f * b
-0.5 ^ f > add(2, b)
-0.5 ^ f > f
-0.5 ^ f >= f
-0.5 ^ obj.a
-0.5 ^ obj.b
-0.5 ^ obj?.a
-0.5 ^ obj?.b
-0.5 ^ obj?.obj?.b
-1 != 0 != obj.a
-1 != 0 or obj?.head(false, div, div)
-1 != 0.5 || b < a
-1 != b != ok
-1 != f == ok
-1 != obj.a
-1 != obj.b
-1 != obj.fn(b)
-1 != obj.obj
-1 != obj?.a
-1 != obj?.b
-1 != obj?.obj
-1 != obj?.obj?.b
-1 % 1 .. 2 - a
-1 % 1 > f
-1 % a * add(1, b)
-1 % a - b
-1 % a / f
-1 % a > b + f
-1 % b / b
-1 % b == b
-1 % b >= b
-1 % obj.a
-1 % obj.b
-1 % obj?.a
-1 % obj?.b
-1 % obj?.obj.b
-1 * 0 .. obj?.head(b)
-1 * 2 == f
-1 * b != 0 ^ a
-1 * b < a
-1 * f < a / b
-1 * f > b
-1 * obj.a
-1 * obj.b
-1 * obj.obj.b
-1 * obj?.a
-1 * obj?.b
-1 ** 0 != obj.obj
-1 ** 0 ** float(2)
-1 ** 0 ^ a
-1 ** 0 ^ b
-1 ** 0.5 / obj?.a
-1 ** 2 ** count(arr, false)
-1 ** 2 < b
-1 ** a >= b
-1 ** b != b
-1 ** b + f
-1 ** b <= -b
-1 ** b >= 1 ** f
-1 ** obj.a
-1 ** obj.b
-1 ** obj.fn(b)
-1 ** obj?.a
-1 ** obj?.b
-1 + 0 == len(arr)
-1 + 0 == obj?.fn(b)
-1 + a > 0 != false
-1 + a > f
-1 + b - a
-1 + f != a
-1 + f >= 0 == false
-1 + f >= add(b, 0)
-1 + obj.a
-1 + obj.b
-1 + obj?.a
-1 + obj?.b
-1 - 0 .. abs(1)
-1 - 1 != a
-1 - 1 < a
-1 - 2 <= f
-1 - a != b ? arr : f
-1 - a > f
-1 - b != f
-1 - b > f
-1 - b >= add(b, 2)
-1 - b in arr ? s : b
-1 - obj.a
-1 - obj.b
-1 - obj.fn(2 - b)
-1 - obj?.a
-1 - obj?.b
-1 - obj?.obj.a
-1 .. 0 == obj.a
-1 .. obj.a
-1 .. obj.b
-1 .. obj.obj.b
-1 .. obj?.a
-1 .. obj?.b
-1 / 0 < f
-1 / 0 in obj?.head(arr)
-1 / 2 * f
-1 / a < f
-1 / a <= abs(a)
-1 / f * b
-1 / f == b
-1 / obj.a
-1 / obj.b
-1 / obj.obj.a
-1 / obj?.a
-1 / obj?.b
-1 < a && obj?.head(ok).b
-1 < a ? a : a
-1 < a ? ok : b
-1 < a || nil != obj
-1 < b == obj.obj
-1 < obj.a
-1 < obj.b
-1 < obj.head(obj?.b)
-1 < obj?.a
-1 < obj?.b
-1 < obj?.fn(b)
-1 <= 0 ? ok : add
-1 <= 1 or obj.head(a)
-1 <= 2 != true == ok
-1 <= a == obj?.b
-1 <= a or obj.a
-1 <= f != obj?.a
-1 <= f == all(arr, ok)
-1 <= f == obj?.head(nil)
-1 <= obj.a
-1 <= obj.b
-1 <= obj?.a
-1 <= obj?.b
-1 <= obj?.head(a)
-1 <= obj?.head(b)
-1 <= obj?.obj.obj.a
-1 == a or obj.head(any(ok and ok, #), div.fn(b, arr, 0, a).a)
-1 == b || obj?.a
-1 == nil != true ? ok : f
-1 == obj.a
-1 == obj.b
-1 == obj.head(first(true, "b", add))
-1 == obj.obj
-1 == obj?.a
-1 == obj?.b
-1 == obj?.obj
-1 > 0.5 and obj?.obj
-1 > 0.5 || 0 == f
-1 > f and ok
-1 > obj.a
-1 > obj.b
-1 > obj?.a
-1 > obj?.b
-1 > obj?.obj?.b
-1 >= 0 || one(arr, ok)
-1 >= 2 ? arr : a
-1 >= f == not false
-1 >= f || obj?.obj
-1 >= obj.a
-1 >= obj.b
-1 >= obj.fn(b)
-1 >= obj?.a
-1 >= obj?.b
-1 >= obj?.fn(b)
-1 ^ 0 != a
-1 ^ 1 != f
-1 ^ 1 != obj?.obj
-1 ^ b ^ f
-1 ^ f - a
-1 ^ obj.a
-1 ^ obj.b
-1 ^ obj.head(b)
-1 ^ obj.obj.b
-1 ^ obj?.a
-1 ^ obj?.b
-2 != 0 != obj?.b
-2 != 0 != ok
-2 != b != ok
-2 != b && b != f
-2 != b or obj?.b
-2 != nil != ok
-2 != nil == ok ? nil : div
-2 != obj.a
-2 != obj.b
-2 != obj.head(add)
-2 != obj.obj
-2 != obj.obj?.a
-2 != obj?.a
-2 != obj?.b
-2 != obj?.fn(b)
-2 != obj?.obj
-2 % 2 == a
-2 % a % a
-2 % a .. a
-2 % a .. obj.b
-2 % a > 0.5 ? b : obj
-2 % b + arr[a]
-2 % b > b
-2 % obj.a
-2 % obj.b
-2 % obj?.a
-2 % obj?.b
-2 * 0 * b
-2 * 0 <= f
-2 * 0.5 - a - b
-2 * 0.5 < b
-2 * 0.5 >= f
-2 * a >= b
-2 * arr[b]
-2 * f != b
-2 * obj.a
-2 * obj.b
-2 * obj?.a
-2 * obj?.b
-2 ** 0 != 0 - f
-2 ** 0 / a
-2 ** 0 > a
-2 ** 0 > f
-2 ** 0.5 ** f
-2 ** 0.5 > a
-2 ** 2 * obj.b
-2 ** a * f
-2 ** a >= f
-2 ** b / a
-2 ** b ^ a
-2 ** obj.a
-2 ** obj.b
-2 ** obj?.a
-2 ** obj?.b
-2 ** obj?.obj.a
-2 + 0 > b
-2 + 0.5 <= f - f
-2 + 2 + obj.b
-2 + arr[b]
-2 + b >= 0 ? arr : true
-2 + f != obj?.b
-2 + f + add(a, b)
-2 + obj.a
-2 + obj.a > f
-2 + obj.b
-2 + obj?.a
-2 + obj?.b
-2 + obj?.obj?.a
-2 - 0 > a ? div : 0
-2 - a == f - f
-2 - a in arr
-2 - b + len("c")
-2 - f < obj?.a
-2 - f == a
-2 - obj.a
-2 - obj.b
-2 - obj?.a
-2 - obj?.b
-2 - obj?.obj?.a
-2 .. obj.a
-2 .. obj.b
-2 .. obj.obj?.a
-2 .. obj?.a
-2 .. obj?.b
-2 .. obj?.obj.a
-2 / 0.5 - a
-2 / 0.5 >= obj.a
-2 / 1 > a
-2 / 2 * a
-2 / a >= obj.head(0.5)
-2 / b * obj.b
-2 / b > a ? arr : f
-2 / f - obj?.b
-2 / obj.a
-2 / obj.b
-2 / obj?.a
-2 / obj?.b
-2 / obj?.fn(a)
-2 < a and obj.obj
-2 < arr[b]
-2 < b ? fromBase64(s) : ok
-2 < f and obj?.head(f, true, false)
-2 < f || none(arr, ok)
-2 < obj.a
-2 < obj.b
-2 < obj?.a
-2 < obj?.b
-2 < obj?.obj.a
-2 <= a == obj.b
-2 <= a ? ok : s
-2 <= a and one(arr, ok)
-2 <= obj.a
-2 <= obj.b
-2 <= obj?.a
-2 <= obj?.b
-2 <= obj?.fn(a)
-2 <= obj?.fn(b)
-2 == 0 || b > f
-2 == arr[b - a]
-2 == f && a in arr
-2 == f and nil != f
-2 == nil == obj?.a
-2 == obj.a
-2 == obj.b
-2 == obj.obj
-2 == obj.obj.a
-2 == obj?.a
-2 == obj?.b
-2 == obj?.fn(a)
-2 == obj?.obj
-2 == obj?.obj?.a
-2 == obj?.obj?.b
-2 > 1 and obj.b
-2 > a || obj.b
-2 > obj.a
-2 > obj.b
-2 > obj?.a
-2 > obj?.b
-2 > obj?.obj.a
-2 >= 1 or f <= a
-2 >= a == nil ? ok : a
-2 >= b and ok
-2 >= f or obj.fn("b", false)
-2 >= obj.a
-2 >= obj.b
-2 >= obj.fn(count(s, true))
-2 >= obj?.a
-2 >= obj?.b
-2 >= obj?.fn(obj?.head(0, 0.5))
-2 ^ 0 / -a
-2 ^ 0 < b
-2 ^ 0 < b ? 0.5 : a
-2 ^ 0 <= float(0)
-2 ^ 0 >= -0
-2 ^ 0.5 >= add(b, b)
-2 ^ 1 != 0 ? add : false
-2 ^ 1 * b
-2 ^ 1 > b
-2 ^ 2 > b
-2 ^ a <= a
-2 ^ b - a
-2 ^ b - b
-2 ^ b <= max(b)
-2 ^ b == b
-2 ^ f == f
-2 ^ f >= a
-2 ^ obj.a
-2 ^ obj.b
-2 ^ obj.obj.a
-2 ^ obj?.a
-2 ^ obj?.b
-2 ^ obj?.fn(obj.head(0))
+-min(1, f32)
+-min(f32)
+-min(f32, 0.5)
+-min(f64)
+-min(f64, 0.5)
+-min(f64, f32)
+-min(f64, i64)
+-min(i)
+-min(i, i)
+-min(i32)
+-min(i32, 1)
+-min(i32, f64)
+-min(i64)
+-min(i64, f32)
+-min(i64, f64)
+-score(1)
+-score(1, 1)
+-score(1, i)
+-score(i)
+-score(i, 1)
+-score(i32 * i)
+0.5 != 0.5 ? f64 : half
+0.5 != 0.5 ? i64 : f64
+0.5 != 0.5 ? list : array
+0.5 != 0.5 or ok
+0.5 != f32 || 0.5 > 0.5
+0.5 != i && i64 > 1
+0.5 != i64 != ok
+0.5 != i64 ? -f32 : add
+0.5 != nil or ok
+0.5 * 0.5 != i / 1
+0.5 * 0.5 * i
+0.5 * 0.5 * i32
+0.5 * 0.5 + i32
+0.5 * 0.5 - i
+0.5 * 0.5 / f64
+0.5 * 0.5 / i32
+0.5 * 0.5 < f32
+0.5 * 0.5 < i
+0.5 * 0.5 > i32
+0.5 * 1 + f32
+0.5 * 1 + half(f64)
+0.5 * 1 < f64
+0.5 * 1 > f64
+0.5 * 1 > i32
+0.5 * f32 / i64
+0.5 * f32 == i32
+0.5 * f64 * f64
+0.5 * f64 + i64
+0.5 * f64 > i
+0.5 * f64 >= i
+0.5 * f64 >= i64
+0.5 * i - i
+0.5 * i / i64
+0.5 * i / i64 ^ 0.5
+0.5 * i == f32
+0.5 * i32 < i32
+0.5 * i32 in [f64]
+0.5 * i64 != f32
+0.5 * i64 != i
+0.5 * i64 + f32
+0.5 * i64 <= i64
+0.5 ** 0.5 != i
+0.5 ** 0.5 ** f32
+0.5 ** 0.5 / f32
+0.5 ** 0.5 / i
+0.5 ** 0.5 < i / i32
+0.5 ** 0.5 == f32
+0.5 ** 0.5 == i32
+0.5 ** 1 + i64
+0.5 ** 1 / f32
+0.5 ** f32 < 1 / f64
+0.5 ** f32 < i
+0.5 ** f32 < i32
+0.5 ** f32 < min(i64)
+0.5 ** f32 == f64
+0.5 ** f32 ^ f32
+0.5 ** f32 ^ i64
+0.5 ** f64 * f32
+0.5 ** f64 + -i
+0.5 ** i * 0.5 ** i
+0.5 ** i < f32
+0.5 ** i <= i32
+0.5 ** i > f32
+0.5 ** i ^ f64
+0.5 ** i32 != f64
+0.5 ** i32 <= i32
+0.5 ** i32 ^ f32
+0.5 ** i64 != f32
+0.5 ** i64 - f32
+0.5 ** i64 - i64
+0.5 ** i64 ^ min(i)
+0.5 + 0.5 != i32
+0.5 + 0.5 - f32
+0.5 + 0.5 - i64
+0.5 + 0.5 < 1 ? f32 : score
+0.5 + 0.5 <= f32
+0.5 + 0.5 == f64
+0.5 + 0.5 > i64
+0.5 + 0.5 >= i64
+0.5 + 1 != i
+0.5 + 1 < f32
+0.5 + 1 >= i
+0.5 + f32 != i
+0.5 + f32 != i + i64
+0.5 + f32 >= i
+0.5 + f64 == i32
+0.5 + f64 > f64
+0.5 + i > f32
+0.5 + i32 + i64
+0.5 + i32 < f32
+0.5 + i64 + f64
+0.5 + i64 < f64
+0.5 + i64 <= 0.5 + 1
+0.5 + i64 == i32
+0.5 + i64 >= i64
+0.5 - 0.5 != i64
+0.5 - 0.5 + i32
+0.5 - 0.5 - f64
+0.5 - 0.5 < 0.5 * f32
+0.5 - 0.5 == f32
+0.5 - 1 != i ? "foo" : div
+0.5 - 1 + f32
+0.5 - 1 - f64
+0.5 - 1 <= i32
+0.5 - 1 <= i64
+0.5 - f32 + i
+0.5 - f64 <= i32
+0.5 - i - i32
+0.5 - i > f64
+0.5 - i > i
+0.5 - i32 + 0.5 ^ i
+0.5 - i32 + f32
+0.5 - i32 < i
+0.5 - i32 <= i64
+0.5 - i64 == f64
+0.5 - i64 > f32
+0.5 - i64 >= f64
+0.5 - i64 >= i
+0.5 / 0.5 != i32
+0.5 / 0.5 / i
+0.5 / 0.5 / i32
+0.5 / 0.5 < i
+0.5 / 0.5 == i
+0.5 / 0.5 >= i32
+0.5 / 0.5 >= min(i32)
+0.5 / 1 != i32 == nil
+0.5 / 1 - i
+0.5 / 1 < f32
+0.5 / 1 < i32
+0.5 / 1 == i64
+0.5 / 1 > 1 ** 0.5
+0.5 / f32 != i32
+0.5 / f32 * f64
+0.5 / f64 / i
+0.5 / f64 <= f64
+0.5 / f64 == i
+0.5 / f64 == i64
+0.5 / f64 >= f64 ^ 1
+0.5 / i < f64 ? i64 : i64
+0.5 / i <= i
+0.5 / i == i64 - f32
+0.5 / i32 + i32
+0.5 / i32 < f32
+0.5 / i64 * i32
+0.5 < 0.5 == nil ? true : foo
+0.5 < 0.5 || ok
+0.5 < 1 and ok
+0.5 < 1 or fromJSON("foo")?.Bar
+0.5 < f32 ? map(list, i32) : i
+0.5 < f64 != false ? f32 : score
+0.5 < f64 ? list : greet
+0.5 < f64 || ok
+0.5 < i ? f64 : foo
+0.5 < i32 or i32 == 1
+0.5 < i64 or ok
+0.5 <= 0.5 and ok
+0.5 <= 1 ? half : greet
+0.5 <= array[i32]
+0.5 <= f32 or ok
+0.5 <= f64 and !true
+0.5 <= f64 or ok
+0.5 <= i == ok
+0.5 <= i and nil == list
+0.5 <= i32 and i < i64
+0.5 <= i64 && f64 >= f64
+0.5 == 0.5 ? score : i
+0.5 == 1 == ok
+0.5 == 1 == ok ? "foo" : div
+0.5 == 1 or ok
+0.5 == 1 || nil != score
+0.5 == f32 ? score : i32
+0.5 == f64 && ok
+0.5 == nil || div != score
+0.5 == nil || ok
+0.5 > 1 == ok
+0.5 > 1 or ok
+0.5 > f32 or !true
+0.5 > f64 != ok
+0.5 >= 0.5 == ok
+0.5 >= 0.5 || ok
+0.5 >= 1 != ok
+0.5 >= 1 and ok
+0.5 >= i32 && i > f32
+0.5 >= i64 and ok
+0.5 ^ 0.5 != i32
+0.5 ^ 0.5 + i32
+0.5 ^ 0.5 / i
+0.5 ^ 0.5 < f64
+0.5 ^ 0.5 > i
+0.5 ^ 0.5 > i64
+0.5 ^ 0.5 >= i32
+0.5 ^ 1 * f64
+0.5 ^ 1 * i
+0.5 ^ 1 + i64
+0.5 ^ 1 - -i
+0.5 ^ 1 / i
+0.5 ^ 1 == f32
+0.5 ^ 1 == i32
+0.5 ^ f32 + i32
+0.5 ^ f32 <= i32
+0.5 ^ f32 > f64 ? array : nil
+0.5 ^ f32 >= f64
+0.5 ^ f32 ^ i32
+0.5 ^ f64 - i32
+0.5 ^ f64 > f32
+0.5 ^ f64 >= f32
+0.5 ^ f64 >= f64
+0.5 ^ f64 >= i
+0.5 ^ f64 ^ i64
+0.5 ^ i == i64
+0.5 ^ i >= i32
+0.5 ^ i32 * i
+0.5 ^ i32 * score(i)
+0.5 ^ i32 / i
+0.5 ^ i32 == i
+0.5 ^ i64 < i
+0.5 ^ i64 <= f32
+0.5 ^ i64 == f64
+0.5 ^ i64 > f64
+0.5 ^ i64 > i
+0.5 ^ i64 > i32
+0.5 ^ i64 >= f32
+1 != 1 != hasPrefix("bar", "bar")
+1 != array[i - 1]
+1 != f32 && i32 <= 0.5
+1 != f32 == ok
+1 != f32 ? i64 : foo
+1 != f32 and i in array
+1 != f64 != ok
+1 != i32 ? score : greet
+1 != i64 && ok
+1 != i64 ? f32 : greet
+1 != nil && ok
+1 != nil ? half : foo
+1 % 1 != f64
+1 % 1 * f32
+1 % 1 < f32
+1 % 1 > f32
+1 % 1 > i
+1 % 1 >= i64
+1 % i / i32
+1 % i < f64
+1 % i < i32
+1 % i == f32
+1 % i32 * i64
+1 % i32 < max(i64)
+1 % i64 != f32
+1 % i64 * f64
+1 % i64 + f32
+1 % i64 .. i64
+1 % i64 <= i64
+1 % i64 > f32
+1 % i64 > i32
+1 * 0.5 + i
+1 * 0.5 - -i
+1 * 0.5 <= f32
+1 * 0.5 > f32
+1 * 1 % i
+1 * 1 + i32
+1 * 1 <= f64
+1 * array[i64]
+1 * f32 < i
+1 * f32 < i32
+1 * f32 <= i32
+1 * f64 * -i
+1 * f64 * f32
+1 * f64 + i
+1 * i % i
+1 * i + f32
+1 * i < int(1)
+1 * i <= 1 % 1
+1 * i > f32
+1 * i not in array
+1 * i32 % i64
+1 * i32 * i32
+1 * i32 / i32
+1 * i32 > f32
+1 * i64 + f64
+1 * i64 == i32
+1 * i64 > i64
+1 ** 0.5 * f64
+1 ** 0.5 - i
+1 ** 0.5 > i32
+1 ** 0.5 ^ f64
+1 ** 1 != i
+1 ** 1 != i64
+1 ** 1 - i
+1 ** 1 / i64
+1 ** 1 < i64
+1 ** 1 == i32
+1 ** 1 >= i
+1 ** f32 != i64
+1 ** f32 / i
+1 ** f64 != i64
+1 ** f64 ** i64
+1 ** f64 + i
+1 ** f64 / f32
+1 ** f64 < i
+1 ** i != i
+1 ** i ** i64
+1 ** i < f64
+1 ** i < i32
+1 ** i > f64
+1 ** i32 ** (1 / 1)
+1 ** i32 == i
+1 ** i32 > i
+1 ** i64 ** f64
+1 ** i64 - f64
+1 + 0.5 != i
+1 + 0.5 <= f64 / f32
+1 + 0.5 <= i32
+1 + 1 - i32
+1 + 1 < i
+1 + 1 == f64
+1 + 1 == i64
+1 + 1 >= i64
+1 + f32 != i
+1 + f32 > i
+1 + f64 != f64
+1 + f64 - i
+1 + f64 >= i32
+1 + i <= f64
+1 + i in map(list, i32)
+1 + i32 - i64
+1 + i32 < i
+1 + i64 >= f32
+1 - 0.5 != half(0.5)
+1 - 0.5 + i
+1 - 0.5 + i32
+1 - 0.5 - i64
+1 - 0.5 <= f64
+1 - 0.5 == i64
+1 - 1 .. i64
+1 - 1 < i64
+1 - 1 == f64
+1 - 1 > -f32
+1 - f32 != i
+1 - f32 <= f64
+1 - f32 <= i32
+1 - f64 - f32
+1 - f64 - f64
+1 - f64 < i64
+1 - f64 <= i
+1 - i .. i64
+1 - i < min(f64)
+1 - i32 < f64
+1 - i32 <= f64
+1 - i32 <= i32
+1 - i32 >= f64
+1 - i64 + i
+1 - i64 - f32
+1 .. 1 == list
+1 .. array[i]
+1 .. i == list
+1 .. i64 == list
+1 / 0.5 + f64
+1 / 0.5 - array[i64]
+1 / 0.5 < f64
+1 / 1 + -0.5
+1 / 1 + i32
+1 / 1 - -0.5
+1 / 1 / f64
+1 / 1 < f32
+1 / 1 <= f32
+1 / 1 <= i
+1 / 1 == f64
+1 / 1 == i
+1 / 1 == i32
+1 / 1 > f32
+1 / 1 > i64
+1 / f32 + -1
+1 / f64 * i
+1 / f64 * i32
+1 / f64 + i32
+1 / f64 / f32
+1 / f64 == f32
+1 / f64 == i
+1 / f64 > i
+1 / i * i
+1 / i < f64 ? ok : add
+1 / i32 <= f32
+1 / i32 == i
+1 / i32 == i64
+1 / i32 > i
+1 / i64 + i64
+1 / i64 == i64
+1 / i64 > i
+1 / i64 >= i32
+1 < array[i64]
+1 < f64 != ok
+1 < i32 and 1 == nil
+1 < i64 ? "foo" not endsWith "foo" : i
+1 <= 0.5 and i32 == 1
+1 <= 0.5 || ok
+1 <= 1 && greet != greet
+1 <= 1 and ok
+1 <= f32 != ok
+1 <= f32 == !ok
+1 <= f64 ? add : f64
+1 <= i64 or nil == f32
+1 == array[i]
+1 > 0.5 != ok
+1 > 1 and ok
+1 > 1 || ok
+1 > f32 and ok
+1 > f64 == ok
+1 > f64 and ok
+1 > i32 == ok
+1 > i64 || i32 < i
+1 >= 1 || ok
+1 >= i || ok
+1 >= i64 or nil in list
+1 ^ 0.5 - f32
+1 ^ 0.5 <= f32
+1 ^ 0.5 <= i64
+1 ^ 0.5 ^ i32
+1 ^ 1 - f64
+1 ^ 1 - i32
+1 ^ 1 - i64
+1 ^ 1 / f32
+1 ^ 1 < f32
+1 ^ 1 < i64 / f32
+1 ^ 1 <= 1 ** f64
+1 ^ 1 == f64
+1 ^ 1 >= f32
+1 ^ 1 >= i64
+1 ^ f32 == i64
+1 ^ f32 > max(f32)
+1 ^ f64 != i32
+1 ^ f64 * f32
+1 ^ f64 ** f64
+1 ^ i != findLast(array, false)
+1 ^ i != i
+1 ^ i * f64
+1 ^ i < i32
+1 ^ i <= f32
+1 ^ i == abs(1)
+1 ^ i32 + i
+1 ^ i32 < i
+1 ^ i32 < i64
+1 ^ i32 >= i32
+1 ^ i64 ** f64
+1 ^ i64 ** i32
+1 ^ i64 + i
+1 ^ i64 <= i
+1 ^ i64 <= i32
+1 ^ i64 > i
+1 ^ i64 >= i64
+[!false]
 [!ok]
-["a"] != arr
+["foo" != nil]
+["foo" endsWith "bar"]
 [-0.5]
-[-0]
-[-a]
-[0 ** 2]
-[0.5 + 1]
-[0.5 > 0]
-[0.5 > 2]
-[2 == a, a]
-[2] == obj.head(f, 2, "a", f)
-[a % a, a, add]
-[a % a]
-[a ** 0.5]
-[a ^ b]
-[a, "b" != s]
-[a]
-[abs(f)]
-[add(div(a, b), last(arr))]
-[add, add]
+[-f32]
+[-f64]
+[-i32]
+[-i64, add]
+[-i64]
+[0.5 * 1]
+[0.5 + 0.5]
+[0.5 / i]
+[0.5 <= f64]
+[0.5 <= i, -1]
+[0.5 >= i]
+[0.5 ^ 1]
+[1 != 1]
+[1 % 1, !true]
+[1 < 0.5]
+[1 == i]
+[abs(0.5)]
+[add != div]
+[add == nil]
+[add, array]
+[add, f32]
+[add, f64]
+[add, greet]
+[add, half]
+[add, i64]
+[add, score]
+[add, toJSON(array)]
 [add]
-[arr, 2 == 0]
-[arr, add]
-[arr, div]
-[arr[b]]
-[arr]
-[b - f]
-[b / a]
-[b <= 0]
-[b <= 2]
-[b, arr]
-[b, obj]
-[b]
-[div, b]
-[div, f]
+[array == list]
+[array, f32]
+[array, f64]
+[array, greet]
+[array, half]
+[array, list]
+[array, ok]
+[array, score]
+[array[1]]
+[array[i64]]
+[array]
+[div == half]
+[div, f32]
+[div, greet]
+[div, map(list, half)]
+[div, ok]
+[div, score]
 [div]
-[f * f]
-[f + 0]
-[f / a]
-[f >= 0]
-[f, a]
-[f, f ** 0]
-[f]
-[false ? add : f]
-[len(obj)]
-[lower("a")]
-[map(arr, div), ok, a]
+[f32 + 1]
+[f32 - 0.5]
+[f32 < i]
+[f32 ^ 0.5]
+[f32 ^ f64]
+[f32, f64]
+[f32, half]
+[f32, max(f64)]
+[f32]
+[f64 != 1]
+[f64 != i32]
+[f64 * f64]
+[f64 < f32]
+[f64 >= 1]
+[f64, f64]
+[f64, foo]
+[f64, i32]
+[f64, i64]
+[f64, list]
+[f64, score]
+[f64]
+[false ? f64 : f32]
+[findIndex(array, true)]
+[first(array)]
+[float(i64)]
+[foo, add]
+[foo, f32]
+[foo, foo]
+[foo, i]
+[foo, list]
+[foo.Qux]
+[foo.String(), greet]
+[foo.String()]
+[foo?.Bar]
+[foo?.Qux]
+[foo]
+[greet, div]
+[greet, f32 ^ 0.5]
+[greet, f32]
+[greet, f64]
+[greet, half]
+[greet, i32]
+[greet, i64]
+[greet, list]
+[greet]
+[half, div]
+[half, foo]
+[half, greet]
+[half]
+[i != i64]
+[i != i]
+[i - 1]
+[i .. 1]
+[i / 0.5]
+[i < f32]
+[i > f64]
+[i, add]
+[i, half]
+[i32 * 1]
+[i32 <= 0.5]
+[i32 == 0.5]
+[i32 > 1]
+[i32 > f32]
+[i32, i]
+[i32, score]
+[i32]
+[i64 / f64]
+[i64 == i32]
+[i64 >= 1]
+[i64 ^ i, i32]
+[i64, add]
+[i64, div]
+[i64, foo]
+[i64, i32]
+[i64, ok]
+[i64]
+[i64] == array
+[i]
+[int(1)]
+[len(array)]
+[list == list]
+[list, div]
+[list, f64]
+[list, i]
+[list]
+[map(array, #)]
+[map(array, 1 >= i32)]
+[map(array, foo)]
+[map(list, #)]
+[map(list, half)]
+[map(list, ok)]
+[max(1)]
+[max(i32)]
 [min(0.5)]
-[min(f)]
-[obj, div]
-[obj, obj]
-[obj.b]
-[obj.fn(a)]
-[obj.head(b, arr)]
-[obj.head(b, div)]
-[obj.head(f)]
-[obj.head(obj)]
-[obj.obj.obj]
-[obj.obj]
-[obj?.a]
-[obj?.b]
-[obj?.fn(a)]
-[obj?.fn(b)]
-[obj?.head("b")]
-[obj?.head("c")]
-[obj?.head(a, ok, nil, add, nil)]
-[obj?.head(div), f]
-[obj?.head(div, 0)]
-[obj?.head(s)]
-[obj?.obj]
-[obj]
-[ok, 0.5 / f]
-[ok, add]
-[ok, arr]
-[ok, obj?.obj.b]
-[ok, obj]
-[ok, s]
+[min(f64)]
+[min(i32)]
+[nil != ok, foo]
+[nil == 0.5]
+[nil not in list]
+[not false]
+[not ok]
+[not true]
+[ok && ok]
+[ok, f32]
+[ok, half]
+[ok, score]
 [ok]
-[s != "a"]
-[s != nil]
-[s != s]
-[s + "a"]
-[s endsWith "c"]
-[s matches "a"]
-[s, b]
-[s]
-[string(f)]
-[true] != arr
-a
-a != -a
-a != 0 % 1
-a != 0 * b
-a != 0 + b
-a != 0 ? b : nil
-a != 0 ? div : obj
-a != 0 ? f : ok
-a != 0 ? s : arr
-a != 0 ^ 1
-a != 0 ^ b
-a != 0.5 * f
-a != 0.5 / b
-a != 0.5 ? false : ok
-a != 0.5 ? s : nil
-a != 1 != false
-a != 1 * b
-a != 1 ? 0 : obj
-a != 2 ** 0
-a != a
-a != a + 0.5
-a != a - 0
-a != a - a
-a != a / 0
-a != a == nil
-a != a == ok
-a != a ? "c" : 0.5
-a != a ? 0 : div
-a != a and ok != nil
-a != add(0, a)
-a != add(0, b)
-a != add(b, a)
-a != arr[1]
-a != arr[b]
-a != arr[obj?.a]
-a != b
-a != b != true
-a != b && b > f
-a != b && ok
-a != b ** 0.5
-a != b ** a
-a != b ** f
-a != b / a
-a != b == nil
-a != b == obj?.b
-a != b ? 0 : add
-a != b and obj.head(arr)
-a != b and obj.obj
-a != b and obj?.a
-a != div(b, a)
-a != f
-a != f ** f
-a != f == ok
-a != f ? 1 : obj
-a != f ^ a
-a != f || ok
-a != first(arr)
-a != float(a)
-a != min(0.5)
-a != min(a, 1, b)
-a != min(b)
-a != nil != obj.a
-a != nil != ok ? ok : a
-a != nil ? 0 : a
-a != nil or obj.head(obj)
-a != obj.a
-a != obj.b
-a != obj.head(add, ok)
-a != obj.head(arr, 2, add)
-a != obj.head(div)
-a != obj.head(ok)
-a != obj.head(true)
-a != obj.obj
-a != obj.obj?.b
-a != obj?.a
-a != obj?.b
-a != obj?.fn(a)
-a != obj?.head(0.5)
-a != obj?.head(a * a)
-a != obj?.head(obj, a)
-a != obj?.obj
-a != obj?.obj.a
-a != obj?.obj.obj
-a != obj?.obj?.b
-a != obj?.obj?.obj
-a % (b - a)
-a % -a
-a % -b
-a % 1 != -b
-a % 1 != b
-a % 1 / 0
-a % 1 / f
-a % 1 < a
-a % 1 >= f
-a % 2 != a + a
-a % 2 != b
-a % 2 * f
-a % a
-a % a % a
-a % a * add(2, 0)
-a % a * b
-a % a - obj?.b
-a % a / b
-a % a < b
-a % a <= f
-a % a > 0 ? add : obj?.obj.a
-a % a > a
-a % add(a, b)
-a % add(b, a)
-a % arr[b]
-a % arr[obj.head(f)]
-a % b
-a % b != b
-a % b % a
-a % b * f
-a % b * obj.b
-a % b - a
-a % b .. obj?.head(f)
-a % b / a
-a % b == -f
-a % b == f
-a % b > b
-a % b > f
-a % b >= a
-a % count(arr, ok)
-a % div(1, a)
-a % div(b, 1)
-a % int(max(a))
-a % len("b")
-a % len(obj)
-a % min(a)
-a % obj.a
-a % obj.b
-a % obj.b < a
-a % obj.head(a)
-a % obj.head(a, add(b, a))
-a % obj.head(b)
-a % obj.obj.a
-a % obj.obj?.a
-a % obj.obj?.b
-a % obj?.a
-a % obj?.b
-a % obj?.head(a)
-a % obj?.obj?.a
-a % obj?.obj?.b
-a * (0.5 + b)
-a * (1 - 1)
-a * (1 - f)
-a * (2 - 0)
-a * (2 - b)
-a * (a + 1)
-a * (b - f)
-a * -a
-a * -f
-a * 0 % a
-a * 0 * f
-a * 0 ** b
-a * 0 / a
-a * 0 > obj.head(b)
-a * 0 > obj?.head(b, add)
-a * 0.5 / b
-a * 0.5 < f
-a * 2 % b
-a * 2 % div(a, a)
-a * 2 == a != false
-a * a
-a * a != obj.b
-a * a % b
-a * a ** 0
-a * a - obj.a
-a * a .. a
-a * a .. b
-a * a / 2
-a * a / f
-a * a < f
-a * a >= f
-a * a >= f ? nil : a
-a * abs(a)
-a * abs(f)
-a * add(1, a)
-a * add(a, 0)
-a * add(b, 0)
-a * add(b, a)
-a * b
-a * b % a
-a * b * obj.b
-a * b ** f
-a * b + a
-a * b - a
-a * b - b
-a * b - f - 0
-a * b - obj.a
-a * b <= b
-a * b >= f
-a * div(0, 1)
-a * div(0, b)
-a * div(a, 1)
-a * div(a, a)
-a * f
-a * f != b * b
-a * f * f
-a * f ** 0.5
-a * f - a
-a * f / a
-a * f / b
-a * f < a
-a * f <= f
-a * f <= f ^ 0.5
-a * f == max(a)
-a * f >= f
-a * f ^ 0.5
-a * f ^ 1
-a * float(1)
-a * len("a")
-a * min(a)
-a * min(b)
-a * obj.a
-a * obj.b
-a * obj.head(0.5, a)
-a * obj.head(a)
-a * obj.head(obj).b
-a * obj?.a
-a * obj?.b
-a * obj?.fn(0)
-a * obj?.fn(b)
-a * obj?.fn(get(arr, b))
-a * obj?.head(b)
-a * obj?.head(obj).a
-a * obj?.obj.a
-a * obj?.obj?.a
-a ** (0 * f)
-a ** (0.5 - 2)
-a ** (0.5 - b)
-a ** (0.5 / a)
-a ** (2 * 0.5)
-a ** (2 * b)
-a ** (2 - f)
-a ** (a / b)
-a ** (b * a)
-a ** (b - 0.5)
-a ** (b / b)
-a ** (f * a)
-a ** (f * b)
-a ** (f - 0)
-a ** (f / 2)
-a ** -0
-a ** -0.5
-a ** -a
-a ** -b
-a ** 0 != a
-a ** 0 ** 0
-a ** 0 - b
-a ** 0 ^ add(b, a)
-a ** 0.5 ** 0.5
-a ** 0.5 / a
-a ** 0.5 <= b
-a ** 0.5 > b
-a ** 0.5 ^ a
-a ** 1 / a
-a ** 1 > f
-a ** 1 ^ f
-a ** 2 != 2 - f
-a ** 2 ** (f + 2)
-a ** 2 <= b
-a ** a
-a ** a ** (f / b)
-a ** a ** f
-a ** a - f
-a ** a / b
-a ** a / obj.head(f)
-a ** a <= a
-a ** a <= obj.head(0)
-a ** a == a
-a ** a == b * 0.5
-a ** a > a
-a ** a ^ 2 ** f
-a ** abs(-f)
-a ** abs(2)
-a ** add(1, 2)
-a ** add(b, a)
-a ** arr[-0]
-a ** arr[a]
-a ** arr[b]
-a ** b
-a ** b != b
-a ** b != f
-a ** b != min(1)
-a ** b ** a
-a ** b - a
-a ** b > f
-a ** b ^ f
-a ** div(2, b)
-a ** div(a, 2)
-a ** f
-a ** f != obj?.head(obj).b
-a ** f ** 0
-a ** f ** f
-a ** f ** obj?.a
-a ** f <= a
-a ** f ^ a
-a ** f ^ f
-a ** float(f)
-a ** int(f)
-a ** len(obj)
-a ** max(0)
-a ** max(a, f)
-a ** min(b)
-a ** obj.a
-a ** obj.b
-a ** obj.fn(a)
-a ** obj.fn(b)
-a ** obj.head(f)
-a ** obj.obj.a
-a ** obj?.a
-a ** obj?.b
-a ** obj?.b ^ b
-a ** obj?.head(1, ok)
-a ** obj?.head(a)
-a ** obj?.head(a, 0.5, add, "c")
-a ** obj?.head(f, ok)
-a ** obj?.obj?.a
-a + -0
-a + -2 * f
-a + -f
-a + 0 + a
-a + 0 + f
-a + 0 - f
-a + 0 <= b
-a + 0 <= f
-a + 0 == obj?.a
-a + 0 ^ b
-a + 0.5 != b
-a + 0.5 * 2
-a + 0.5 > f
-a + 0.5 ^ f
-a + a
-a + a % a
-a + a % b
-a + a * 1
-a + a * f
-a + a + a
-a + a + f
-a + a - a
-a + a - b
-a + a / 0
-a + a / b
-a + a < a + a
-a + a >= f
-a + a ^ b
-a + add(0, 2)
-a + add(b, b)
-a + b
-a + b % a
-a + b - 0
-a + b - f
-a + b .. a
-a + count(arr, a != a)
-a + div(0, 2)
-a + div(a, b)
-a + div(b, b)
-a + f
-a + f * 0.5
-a + f + b * 0
-a + f + f
-a + f - a - 2
-a + f - b
-a + f <= b
-a + f == f
-a + f == obj?.obj
-a + f > float(b)
-a + f >= obj.b
-a + f ^ b
-a + f ^ f
-a + get(arr, 1)
-a + int(f)
-a + last(arr)
-a + len(s)
-a + min(f, 2)
-a + obj.a
-a + obj.b
-a + obj.fn(2)
-a + obj.fn(a)
-a + obj.fn(b)
-a + obj.fn(obj.head(b))
-a + obj.head(1, ok)
-a + obj.head(a)
-a + obj.head(a, ok, arr, nil)
-a + obj.obj.a
-a + obj.obj.b
-a + obj?.a
-a + obj?.b
-a + obj?.head(f)
-a + obj?.head(f, "c" != f)
-a + obj?.head(obj?.a)
-a + obj?.obj.a
-a - -2
-a - -a
-a - -b
-a - 0 != a
-a - 0 != f
-a - 0 != obj?.obj?.a
-a - 0 ** f
-a - 0 - b
-a - 0 / 0
-a - 0 < obj.b
-a - 0 <= min(1)
-a - 0 == obj.b
-a - 0 > a
-a - 0 ^ f
-a - 0 in arr
-a - 0.5 != f
-a - 0.5 * 0.5
-a - 0.5 > b
-a - 0.5 >= a
-a - 1 .. obj.b
-a - 1 == obj?.head(div, div)
-a - 1 > b
-a - 2 * f
-a - 2 - 0.5
-a - 2 .. b
-a - a
-a - a != nil != false
-a - a * 0
-a - a * f
-a - a ** b
-a - a - f
-a - a .. -2
-a - a .. a
-a - a < b / 0
-a - a <= a
-a - a <= f ** 0.5
-a - a == a
-a - a == obj?.a
-a - a > 0 ? f : obj
-a - a in arr
-a - add(a, 0)
-a - add(b, 0)
-a - b
-a - b * f
-a - b + b - b
-a - b + float(0)
-a - b - a
-a - b / 0
-a - b / 0.5
-a - div(a, 1)
-a - f
-a - f != b
-a - f ** 1
-a - f + b
-a - float(f)
-a - get(arr, a)
-a - len("c")
-a - max(f)
-a - obj.a
-a - obj.b
-a - obj.fn(a)
-a - obj.head(0.5, b, b)
-a - obj.head(2, obj)
-a - obj.head(f)
-a - obj.head(f, "b")
-a - obj.obj?.b
-a - obj?.a
-a - obj?.b
-a - obj?.head(a)
-a - obj?.head(b, arr)
-a - obj?.obj.b
-a .. -2
-a .. 0 - 1
-a .. a
-a .. a + 2
-a .. a + b
-a .. a + obj.obj.a
-a .. a - 1
-a .. add(b, b)
-a .. arr[a]
-a .. arr[b]
-a .. b
-a .. b + obj?.b
-a .. b - a
-a .. b - b
-a .. b == arr
-a .. div(1, 2)
-a .. div(a, b)
-a .. len(arr)
-a .. len(s)
-a .. min(0, 2)
-a .. obj.a
-a .. obj.b
-a .. obj.head(a)
-a .. obj.head(b, "a")
-a .. obj.obj?.a
-a .. obj?.a
-a .. obj?.b
-a .. obj?.head(1, obj, ok, false)
-a .. obj?.head(2, s, nil)
-a .. obj?.head(a, true, nil)
-a .. obj?.obj.a
-a .. obj?.obj.b
-a .. obj?.obj.obj?.b
-a / (0 - 0)
-a / (1 + 0.5)
-a / (a - a)
-a / (f + 0)
-a / (f + f)
-a / -0
-a / -a
-a / -b
-a / -obj.obj.b
-a / 0 != obj?.obj
-a / 0 * 1
-a / 0 ** a
-a / 0 + obj.a
-a / 0 / obj.b
-a / 0 < obj.a
-a / 0 <= a
-a / 0 == f
-a / 0 >= a
-a / 0 >= b
-a / 0.5 < f
-a / 0.5 == obj?.a
-a / 1 - b
-a / 1 / a
-a / 1 < obj?.b
-a / a
-a / a != f
-a / a - a ^ 2
-a / a < b
-a / a <= add(1, 0)
-a / a == f
-a / a > float(f)
-a / add(0, b)
-a / add(a, b)
-a / add(b, 0)
-a / add(b, b)
-a / arr[a]
-a / b
-a / b * obj?.head(f, arr, 0.5)
-a / b ** b
-a / b / (b + 0)
-a / b / 2
-a / b < a
-a / b == a
-a / b > f
-a / b >= 1 * obj?.a
-a / b ^ b
-a / count(arr, false)
-a / div(0, a)
-a / div(a, a)
-a / div(b, b)
-a / f
-a / f * f
-a / f ** 0.5
-a / f + a
-a / f - f
-a / f / b
-a / f / f
-a / f < obj?.b
-a / f <= 0 % b
-a / int(0)
-a / max(0, 1, a)
-a / max(2, b)
-a / min(f)
-a / obj.a
-a / obj.b
-a / obj.fn(a)
-a / obj.fn(b)
-a / obj.head(0, a)
-a / obj.head(a, arr, 0.5)
-a / obj.head(f)
-a / obj.head(f, a)
-a / obj?.a
-a / obj?.b
-a / obj?.fn(obj?.a)
-a / obj?.head(0, obj, b, f, "b")
-a / obj?.head(2, add)
-a / obj?.head(a)
-a / obj?.head(b, div)
-a / obj?.head(f)
-a / obj?.obj?.a
-a < -0
-a < -a
-a < -obj.a
-a < 0 && obj.head(obj)
-a < 0 * 0.5
-a < 0 ** b
-a < 0 ** f
-a < 0 / a
-a < 0.5 != ok
-a < 0.5 + f
-a < 0.5 ? 0 : arr
-a < 0.5 ? a != nil : f
-a < 1 && obj.fn(ok, "a", obj)
-a < 1 * 2
-a < 1 ? obj : true
-a < 1 ^ b
-a < 2 && obj?.a
-a < 2 ** 2
-a < a
-a < a % b
-a < a * f
-a < a - f
-a < a / a
-a < a == false
-a < a ? 0 : ok
-a < a ? 0.5 : arr
-a < a ? a : add
-a < a ? div : add
-a < a ? f : add
-a < a ? nil : 2
-a < a ? s : a
-a < abs(a)
-a < abs(b)
-a < add(2, b)
-a < add(a, a)
-a < arr[a]
-a < b
-a < b != ok
-a < b + 0.5
-a < b + b
-a < b + f
-a < b - f
-a < b == obj?.head(ok)
-a < b ? "c" : ok
-a < b or obj.obj
-a < div(b, 1)
-a < f
-a < f && obj.b?.b
-a < f * b
-a < f * f
-a < f - 0
-a < f ? "b" : false
-a < f ? a : ok
-a < f ? add : b
-a < f ? s : arr
-a < f || ok
-a < get(arr, b)
-a < last(arr)
-a < min(a)
-a < min(f)
-a < obj.a
-a < obj.b
-a < obj.fn(a)
-a < obj.head(0)
-a < obj.head(0, a, a)
-a < obj.head(a, obj)
-a < obj.head(b)
-a < obj.obj.b
-a < obj.obj?.a
-a < obj?.a
-a < obj?.b
-a < obj?.obj.b
-a <= -0
-a <= -0.5
-a <= -1
-a <= -b
-a <= -f
-a <= 0 != nil
-a <= 0 && obj?.a
-a <= 0 && obj?.fn(add)
-a <= 0 * b
-a <= 0 + 0.5
-a <= 0 - 1
-a <= 0 ? obj : s startsWith "c"
-a <= 0 ^ 0.5
-a <= 0 || !ok
-a <= 0 || ok
-a <= 0.5 && obj?.head(true)
-a <= 0.5 == obj.b
-a <= 0.5 ? f != b : b
-a <= 0.5 ? false : ok
-a <= 0.5 ? obj : a
-a <= 1 + 0
-a <= 2 != ok
-a <= 2 ** a
-a <= a
-a <= a != true
-a <= a ** 0
-a <= a / 2
-a <= a ? arr : "c"
-a <= a || ok
-a <= add(b, 1)
-a <= arr[b]
-a <= b
-a <= b != nil ? 1 : s
-a <= b % a
-a <= b ** a
-a <= b + 2
-a <= b - a
-a <= b ? f : a
-a <= b ? f : nil
-a <= b ? f : obj.a
-a <= b ? false : b
-a <= b and obj.a
-a <= f
-a <= f ** a
-a <= f ? 2 : f
-a <= f ? obj?.head(b) : obj?.b
-a <= f ? true : ok
-a <= f and ok
-a <= float(a)
-a <= get(arr, b)
-a <= len(obj)
-a <= max(a)
-a <= obj.a
-a <= obj.b
-a <= obj.head(a, "a", b, b, a)
-a <= obj.head(b * 0.5)
-a <= obj.head(b)
-a <= obj.head(f)
-a <= obj.obj.b
-a <= obj?.a
-a <= obj?.b
-a <= obj?.fn(b)
-a <= obj?.obj.a
-a == -obj?.b
-a == 0 != nil
-a == 0 % a
-a == 0 && obj?.b
-a == 0 + 1
-a == 0 ? obj?.b : arr
-a == 0 ? s : b
-a == 0.5 != obj?.a
-a == 0.5 + b
-a == 0.5 ? b : b
-a == 0.5 and obj.fn("b", nil)
-a == 1 + b
-a == 1 - f
-a == 1 ? div : obj
-a == 1 ? s : f
-a == 1 ^ b
-a == 2 * f
-a == 2 or obj.a
-a == a
-a == a && obj.obj
-a == a * b
-a == a + a
-a == a ? 1 : a
-a == a ? 2 : f
-a == a ? f : obj
-a == a ? s : 0
-a == add(2, a)
-a == arr[b]
-a == b
-a == b != nil
-a == b % b
-a == b * 1
-a == b ? b : obj.b
-a == b ? s : add
-a == b ^ 0.5
-a == b and "a" endsWith s
-a == b or obj.b
-a == b or ok
-a == f
-a == f != nil
-a == f != nil ? s : obj
-a == f != ok
-a == f && obj == obj
-a == f * a
-a == f == obj?.a
-a == f ? f : "b"
-a == f ? ok : div
-a == f and obj?.obj
-a == f or obj.b
-a == f || obj.head(b)
-a == first(obj?.a)
-a == int(b)
-a == last(arr)
-a == len("b")
-a == len(obj)
-a == nil != true
-a == nil == ok
-a == nil ? 0 : b
-a == nil ? a : "b"
-a == nil ? s : div
-a == nil and obj.head(false)
-a == obj.a
-a == obj.b
-a == obj.head("c")
-a == obj.head(a, s)
-a == obj.head(add)
-a == obj.head(arr)
-a == obj.head(f)
-a == obj.head(obj, s, 0).obj
-a == obj.head(ok, nil, add, "c")
-a == obj.head(s, "a", ok, b)
-a == obj.obj
-a == obj.obj.b
-a == obj?.a
-a == obj?.b
-a == obj?.b / a
-a == obj?.b or ok
-a == obj?.c
-a == obj?.head(0.5)
-a == obj?.head(add)
-a == obj?.head(arr)
-a == obj?.head(b or true)
-a == obj?.head(b)
-a == obj?.head(b, obj, "c")
-a == obj?.head(s)
-a == obj?.head(s, map(s, obj), a)
-a == obj?.obj
-a == obj?.obj?.b
-a == obj?.obj?.obj
-a > -a
-a > -b
-a > -f
-a > 0 != obj?.b
-a > 0 != ok
-a > 0 && ok
-a > 0 * 0.5
-a > 0 + 1
-a > 0 ^ 0.5
-a > 0 or nil == add
-a > 1 != ok
-a > 1 * 0
-a > 1 - 0
-a > 1 || obj?.obj
-a > 2 * 0
-a > 2 ? add : div
-a > 2 and obj.obj
-a > a
-a > a != ok
-a > a != true
-a > a * a
-a > a ** f
-a > a - b
-a > a / f
-a > a ? add : 1
-a > a ? add : ok
-a > add(a, b)
-a > add(b, a)
-a > arr[a]
-a > b
-a > b != ok
-a > b && !true
-a > b * b
-a > b + b
-a > b ? "b" : 0 >= f
-a > b ^ 0
-a > div(1, b)
-a > f
-a > f != ok
-a > f ** b
-a > f ** f
-a > f / 0
-a > f ? f : add
-a > f ? s : div
-a > f ^ a
-a > f || obj.head(0, add)
-a > get(arr, b)
-a > int(f)
-a > len(obj)
-a > len(s)
-a > max(a)
-a > min(b, f)
-a > obj.a
-a > obj.a % a
-a > obj.a ? obj.head(f, obj) : add
-a > obj.b
-a > obj.fn(b)
-a > obj.head(0.5)
-a > obj.head(a)
-a > obj.head(b)
-a > obj.obj.a
-a > obj?.a
-a > obj?.b
-a > obj?.fn(0)
-a > obj?.fn(b)
-a > obj?.head(f)
-a > obj?.obj.a
-a > obj?.obj.b
-a > obj?.obj?.a
-a > obj?.obj?.b
-a >= -0
-a >= -a
-a >= -f
-a >= 0 != !ok
-a >= 0 != obj.head(a, nil)
-a >= 0 && ok
-a >= 0 ** 0
-a >= 0 ** 1
-a >= 0 ** a
-a >= 0 + b
-a >= 0 ? s : b
-a >= 0 ^ 0
-a >= 0 ^ a
-a >= 0 or ok
-a >= 0.5 && obj?.a
-a >= 0.5 ? div : f ** 1
-a >= 0.5 || !ok
-a >= 1 && f >= b
-a >= 1 + 1
-a >= 1 ? add : obj.obj
-a >= 1 ^ a
-a >= 1 ^ f
-a >= 1 || any(arr, true)
-a >= 2 ? s : -f
-a >= a
-a >= a != nil
-a >= a != ok
-a >= a != true
-a >= a * a
-a >= a ** 2
-a >= a ** a
-a >= a ** b
-a >= a - b
-a >= a ? arr : a
-a >= a ^ 0
-a >= a ^ 1 * b
-a >= a and obj?.b
-a >= a || obj.head("a", f).head(f.head(div ^ ok), add contains b.b)
-a >= add(a, 0)
-a >= add(a, a)
-a >= add(b, b)
-a >= arr[b]
-a >= b
-a >= b % 1
-a >= b && f < f
-a >= b - 0.5
-a >= b ? 1 : false
-a >= b ^ a
-a >= b and obj.obj
-a >= b or ok
-a >= b || b >= 0.5
-a >= f
-a >= f * 2
-a >= f ** 2
-a >= f ? arr : add
-a >= f ? b : ok
-a >= f and ok
-a >= f || obj.b.fn(add(f, any(obj, arr))?.b)
-a >= float(b)
-a >= get(arr, 0)
-a >= int(0)
-a >= int(f)
-a >= len("c")
-a >= min(f)
-a >= obj.a
-a >= obj.b
-a >= obj.b || 0.5 <= obj.a
-a >= obj.fn(1)
-a >= obj.fn(a * a)
-a >= obj.fn(div(a, b))
-a >= obj.head(1, nil, "a")
-a >= obj.head(a, nil)
-a >= obj.head(f)
-a >= obj.obj?.b
-a >= obj?.a
-a >= obj?.a / b
-a >= obj?.b
-a >= obj?.fn(0)
-a >= obj?.head(a)
-a >= obj?.obj.a
-a >= obj?.obj?.a
-a >= obj?.obj?.b
-a ^ (0 / b)
-a ^ (2 + 0.5)
-a ^ (a % 2)
-a ^ (a % b)
-a ^ (a * a)
-a ^ (a - a)
-a ^ (a - f)
-a ^ (b - 2)
-a ^ (b / 0)
-a ^ (f - f)
-a ^ (f / 2)
-a ^ -0
-a ^ -0.5
-a ^ -a
-a ^ -b
-a ^ -f
-a ^ 0 * b
-a ^ 0 + f
-a ^ 0 - a
-a ^ 0 >= a
-a ^ 0.5 ** b
-a ^ 0.5 + -1
-a ^ 0.5 < f
-a ^ 0.5 >= a
-a ^ 1 ** f
-a ^ 1 > obj?.b
-a ^ 1 ^ obj.a
-a ^ 2 * f
-a ^ 2 + b
-a ^ 2 == obj?.obj?.a
-a ^ 2 ^ a
-a ^ a
-a ^ a ** a
-a ^ a ** f
-a ^ a + a * f
-a ^ a / (b + f)
-a ^ a / a
-a ^ a / b
-a ^ a < obj.a
-a ^ a == 2 == nil
-a ^ a > f
-a ^ a ^ arr[a]
-a ^ a ^ obj?.head(0)
-a ^ abs(a)
-a ^ add(1, 1)
-a ^ add(a, b)
-a ^ add(b, 2)
-a ^ arr[0]
-a ^ arr[a]
-a ^ arr[b]
-a ^ b
-a ^ b != obj.obj?.a
-a ^ b ** f
-a ^ b ** obj?.b
-a ^ b + 2 ^ f
-a ^ b + a
-a ^ b - b - a
-a ^ b < 0 == ok
-a ^ b > a
-a ^ b ^ a
-a ^ div(a, 2)
-a ^ f
-a ^ f != a
-a ^ f ** 0.5
-a ^ f ** f
-a ^ f + a
-a ^ f + b
-a ^ f - a
-a ^ f / b
-a ^ f > 0 ? div : arr
-a ^ f ^ obj?.a
-a ^ first(arr)
-a ^ get(arr, 0)
-a ^ min(f)
-a ^ obj.a
-a ^ obj.b
-a ^ obj.fn(b)
-a ^ obj.fn(obj.a)
-a ^ obj.head(a)
-a ^ obj.head(f)
-a ^ obj.obj.b
-a ^ obj.obj?.b
-a ^ obj?.a
-a ^ obj?.b
-a ^ obj?.head(b)
-a ^ obj?.obj?.b
-a in a .. 0
-a in a .. 2
-a in arr
-a in arr && obj.a
-a in arr == true
-a in arr ? 0.5 : 0.5
-a in arr ? 1 : obj
-a in arr ? f : nil
-a in arr ? f : ok
-a in arr || 0.5 == f
-a in b .. 0
-a in filter(arr, false)
-a in filter(arr, ok)
-a in map(arr, #)
-a in obj?.head(nil)?.obj
-a in obj[nil]
+[score != add]
+[score(1)]
+[score(i)]
+[score, array, foo]
+[score, f32]
+[score, f64]
+[score, greet]
+[score]
+[string(0.5), foo]
+[string(f64)]
+[string(i32)]
+[toJSON(1)]
+[toJSON(nil)]
+[type(0.5)]
+[type(1)]
+[type(add)]
+[type(false)]
+[type(i32)]
+[{"foo": foo}]
 abs(-0.5)
 abs(-1)
-abs(-2)
-abs(-a)
-abs(-b)
-abs(-f)
-abs(0 % 2)
-abs(0 % a)
-abs(0 % b)
-abs(0 * 0.5)
-abs(0 * b)
-abs(0 + 0)
-abs(0 + a)
-abs(0 + b)
-abs(0 + f)
-abs(0 - a)
-abs(0 / a)
-abs(0 / b)
-abs(0 / f)
-abs(0 ^ 0.5)
-abs(0 ^ b)
-abs(0) ** lastIndexOf("b", "b")
-abs(0) ** obj?.b
-abs(0) / b
-abs(0) < b * 0
-abs(0) <= f
-abs(0) == obj.a
-abs(0) ^ obj?.a
-abs(0.5 * f)
+abs(-f32)
+abs(-f64)
+abs(-i)
+abs(-i32)
+abs(-i64)
+abs(0.5 * 0.5)
+abs(0.5 * 1)
+abs(0.5 * f64)
+abs(0.5 * i32)
+abs(0.5 * i64)
 abs(0.5 ** 0.5)
-abs(0.5 ** b)
+abs(0.5 ** 1)
+abs(0.5 ** f32)
+abs(0.5 ** f64)
+abs(0.5 ** i64)
 abs(0.5 + 0.5)
-abs(0.5 + f)
-abs(0.5 - 1)
-abs(0.5 - b)
-abs(0.5 - f)
-abs(0.5 ^ b)
-abs(0.5) != obj.a
-abs(0.5) == a
-abs(0.5) == f != ok
+abs(0.5 + f32)
+abs(0.5 + i)
+abs(0.5 + i64)
+abs(0.5 - 0.5)
+abs(0.5 - f32)
+abs(0.5 - i)
+abs(0.5 - i64)
+abs(0.5 / 0.5)
+abs(0.5 / 1)
+abs(0.5 / f32)
+abs(0.5 / f64)
+abs(0.5 / i)
+abs(0.5 / i64)
+abs(0.5 ^ 0.5)
+abs(0.5 ^ 1)
+abs(0.5 ^ f64)
+abs(0.5 ^ i32)
+abs(0.5) * i
+abs(0.5) - i
+abs(0.5) - i64
+abs(0.5) / i32
+abs(0.5) < f32
+abs(0.5) == i32
+abs(0.5) > f32
+abs(0.5) >= f32
+abs(0.5) >= i
+abs(0.5) >= i32
+abs(0.5) ^ f64
 abs(1 % 1)
-abs(1 ** b)
-abs(1 - a)
-abs(1 / 0)
-abs(1 / a)
-abs(1 / f)
-abs(1 ^ a)
-abs(1) * 0 * a
-abs(1) - min(a, 0)
-abs(1) / f
-abs(1) == f
-abs(1) > obj?.b
-abs(2 - 0)
-abs(2 - 1)
-abs(2 - a)
-abs(2 ^ f)
-abs(a * 0)
-abs(a * a)
-abs(a ** 0.5)
-abs(a ** a)
-abs(a ** f)
-abs(a + 0)
-abs(a + b)
-abs(a - a)
-abs(a / 1)
-abs(a / b)
-abs(a / f)
-abs(a ^ 0.5)
-abs(a ^ 1)
-abs(a ^ f)
-abs(a)
-abs(a) * obj?.a
-abs(a) + b
-abs(a) + f
-abs(a) - a == a
-abs(a) <= b
-abs(a) <= b % 1
-abs(a) > f
-abs(a) >= add(0, b)
+abs(1 % i)
+abs(1 * 0.5)
+abs(1 * 1)
+abs(1 * f32)
+abs(1 ** 1)
+abs(1 ** i)
+abs(1 + 1)
+abs(1 + f64)
+abs(1 - 0.5)
+abs(1 - i)
+abs(1 - i32)
+abs(1 / 0.5)
+abs(1 / 1)
+abs(1 / f32)
+abs(1 / f64)
+abs(1 / i32)
+abs(1 / i64)
+abs(1 ^ 0.5)
+abs(1 ^ 1)
+abs(1 ^ f64)
+abs(1) * f64
+abs(1) * i
+abs(1) ** f64
+abs(1) + f64
+abs(1) + i
+abs(1) - f64
+abs(1) .. i
+abs(1) / f32
+abs(1) < f32
+abs(1) < i
+abs(1) == f64 ? 1 : foo
+abs(1) > i
+abs(1) ^ f32
+abs(1) ^ i32
 abs(abs(0.5))
-abs(abs(a))
-abs(abs(f))
-abs(abs(obj.head(b)))
-abs(add(0, 0))
-abs(add(0, a))
-abs(add(0, b))
-abs(add(1, b))
-abs(add(2, b))
-abs(add(a, 0))
-abs(add(a, a))
-abs(add(a, b))
-abs(add(b, 1))
-abs(add(b, a))
-abs(add(b, b))
-abs(arr[a])
-abs(arr[a]) ** b
-abs(b % a)
-abs(b % b)
-abs(b * 1)
-abs(b * b)
-abs(b ** 0)
-abs(b ** 0.5)
-abs(b ** 2)
-abs(b ** b)
-abs(b ** f)
-abs(b + b)
-abs(b + f)
-abs(b - a)
-abs(b - f)
-abs(b / 0.5)
-abs(b / a)
-abs(b / f)
-abs(b ^ 0)
-abs(b ^ 2)
-abs(b ^ a)
-abs(b ^ f)
-abs(b ^ obj.b)
-abs(b)
-abs(b) % a
-abs(b) * a
-abs(b) * b
-abs(b) - f
-abs(b) .. a
-abs(b) < a
-abs(b) < b
-abs(b) <= f
-abs(b) <= obj?.b
-abs(b) >= b ? "c" : 0
-abs(div(0, 1))
-abs(div(0, a))
-abs(div(a, a))
-abs(div(a, b))
-abs(div(b, a))
-abs(div(b, b))
-abs(f * 1)
-abs(f ** 0)
-abs(f ** 2)
-abs(f ** a)
-abs(f ** b)
-abs(f ** f)
-abs(f + 0)
-abs(f + 2)
-abs(f + a)
-abs(f + b)
-abs(f - a)
-abs(f - f)
-abs(f / b)
-abs(f / f)
-abs(f ^ 0)
-abs(f ^ 1)
-abs(f ^ f)
-abs(f ^ obj.a)
-abs(f ^ obj?.b)
-abs(f)
-abs(f) != f
-abs(f) * obj.b
-abs(f) ** f
-abs(f) + b
-abs(f) < obj?.a
-abs(f) == a
-abs(false ? "b" : 2)
-abs(false ? s : 0)
-abs(float(0))
+abs(abs(1))
+abs(abs(abs(i)))
+abs(abs(f32))
+abs(abs(f64))
+abs(abs(i))
+abs(abs(i32))
+abs(abs(i64))
+abs(array[1])
+abs(array[i])
+abs(count(list, true))
+abs(f32 * 0.5)
+abs(f32 * 1)
+abs(f32 * f64)
+abs(f32 ** 0.5)
+abs(f32 ** 1)
+abs(f32 ** i32)
+abs(f32 + 0.5)
+abs(f32 + 1)
+abs(f32 + f32)
+abs(f32 + f64)
+abs(f32 + i)
+abs(f32 + i32)
+abs(f32 - 0.5)
+abs(f32 - 1)
+abs(f32 - f32)
+abs(f32 / 1)
+abs(f32 / f32)
+abs(f32 / f64)
+abs(f32 / i32)
+abs(f32 ^ 1)
+abs(f32 ^ f64)
+abs(f32 ^ i32)
+abs(f32 ^ i64)
+abs(f32)
+abs(f32) != i64 / i64
+abs(f32) * i32
+abs(f32) + i32
+abs(f32) <= i64
+abs(f32) == i
+abs(f32) ^ f64
+abs(f64 * 1)
+abs(f64 * f32)
+abs(f64 * i32)
+abs(f64 ** 1)
+abs(f64 ** f32)
+abs(f64 ** i32)
+abs(f64 + 0.5)
+abs(f64 + 1)
+abs(f64 + i32)
+abs(f64 + i64)
+abs(f64 - 0.5)
+abs(f64 - 1)
+abs(f64 - f32)
+abs(f64 - i32)
+abs(f64 / 0.5)
+abs(f64 / f64)
+abs(f64 / i)
+abs(f64 / i64)
+abs(f64 ^ i32)
+abs(f64)
+abs(f64) * i64
+abs(f64) - f32
+abs(f64) - i64 - i32
+abs(f64) / i
+abs(f64) / i64
+abs(f64) < f64
+abs(f64) <= abs(i32)
+abs(f64) <= i
+abs(f64) <= i32
+abs(f64) == i
+abs(false ? 1 : f32)
+abs(false ? f64 : 0.5)
+abs(false ? false : i64)
+abs(findIndex(array, # > i32))
+abs(findIndex(array, ok))
+abs(findIndex(array, true))
+abs(findIndex(list, true))
+abs(findLastIndex(array, ok))
+abs(findLastIndex(array, true))
+abs(findLastIndex(list, ok))
+abs(first(array))
 abs(float(0.5))
-abs(float(add(b, b)))
-abs(float(b))
-abs(float(f ^ a))
-abs(get(arr, 2))
-abs(get(arr, b))
-abs(int(0))
+abs(float(1))
+abs(float(f32))
+abs(float(f64))
+abs(float(i))
+abs(float(i32))
+abs(float(i64))
+abs(get(array, i32))
+abs(get(array, i64))
+abs(half(0.5))
+abs(half(f64))
+abs(i % i64)
+abs(i * 1)
+abs(i * i)
+abs(i * i32)
+abs(i ** 0.5)
+abs(i ** 1)
+abs(i ** i32)
+abs(i + 1)
+abs(i + i32)
+abs(i - 0.5)
+abs(i - 1)
+abs(i / 1)
+abs(i / i32)
+abs(i ^ 0.5)
+abs(i ^ f32)
+abs(i ^ i32)
+abs(i)
+abs(i) != float(0.5)
+abs(i) % i64
+abs(i) * f32
+abs(i) ** i
+abs(i) ** max(1)
+abs(i) / i64
+abs(i) <= i32
+abs(i) <= i64
+abs(i) > f64
+abs(i32 % i64)
+abs(i32 * 0.5)
+abs(i32 * 1)
+abs(i32 * i32)
+abs(i32 * i64)
+abs(i32 ** 0.5)
+abs(i32 ** 1)
+abs(i32 ** f64)
+abs(i32 ** i)
+abs(i32 ** i64)
+abs(i32 + 0.5)
+abs(i32 + f64)
+abs(i32 + i32)
+abs(i32 - 1)
+abs(i32 - f32)
+abs(i32 - f64)
+abs(i32 - i64)
+abs(i32 / 1)
+abs(i32 / i)
+abs(i32 / i32)
+abs(i32 ^ 0.5)
+abs(i32 ^ 1)
+abs(i32 ^ i)
+abs(i32 ^ i64)
+abs(i32)
+abs(i32) % i32
+abs(i32) ** i64
+abs(i32) / -f32
+abs(i32) < f32
+abs(i32) > min(i64, f64, i32)
+abs(i32) ^ f64
+abs(i32) not in array
+abs(i64 % 1)
+abs(i64 % i32)
+abs(i64 * 1)
+abs(i64 * f32)
+abs(i64 * i)
+abs(i64 * i32)
+abs(i64 * i64)
+abs(i64 ** 0.5)
+abs(i64 ** 1)
+abs(i64 ** i64)
+abs(i64 + 0.5)
+abs(i64 + 1)
+abs(i64 + i)
+abs(i64 + i32)
+abs(i64 + i64)
+abs(i64 - 1)
+abs(i64 - f64)
+abs(i64 - i32)
+abs(i64 / i32)
+abs(i64 ^ i64)
+abs(i64)
+abs(i64) != f64
+abs(i64) - f64
+abs(i64) - i64
+abs(i64) .. i64
+abs(i64) == f32
+abs(i64) == i
+abs(i64) == i32
+abs(i64) == nil ? i : f64
+abs(i64) > i64
+abs(i64) >= f64
+abs(i64) in array
+abs(int(0.5))
 abs(int(1))
-abs(int(b))
-abs(int(f))
-abs(len("b"))
-abs(len(arr))
-abs(max(a))
-abs(max(f))
-abs(max(f, f))
-abs(min(0, f))
-abs(min(a))
-abs(min(b))
-abs(min(b, f))
-abs(min(f))
-abs(obj.a)
-abs(obj.a) != b
-abs(obj.b)
-abs(obj.fn(0))
-abs(obj.fn(a))
-abs(obj.fn(b))
-abs(obj.head(0.5, b))
-abs(obj.head(1))
-abs(obj.head(2))
-abs(obj.head(2, nil, obj))
-abs(obj.head(a))
-abs(obj.head(a, a))
-abs(obj.head(b))
-abs(obj.head(b, 0.5))
-abs(obj.head(f))
-abs(obj.obj.b)
-abs(obj?.a)
-abs(obj?.b ** (a / b))
-abs(obj?.b)
-abs(obj?.fn(0))
-abs(obj?.fn(1))
-abs(obj?.fn(a))
-abs(obj?.fn(b))
-abs(obj?.head(0))
-abs(obj?.head(2))
-abs(obj?.head(a))
-abs(obj?.head(a, 2))
-abs(obj?.head(a, b, add))
-abs(obj?.head(a, ok, b))
-abs(obj?.head(b))
-abs(obj?.head(b, a))
-abs(obj?.head(b, arr, div, f))
-abs(obj?.head(f, add, 0.5))
-abs(obj?.obj.a)
-abs(obj?.obj.b)
-abs(obj?.obj?.a)
-abs(ok ? 0.5 : 0.5)
-abs(ok ? 0.5 : nil)
-abs(ok ? a : b)
-abs(ok ? b : arr)
-abs(true ? b : b)
-abs(true ? f : ok)
-abs(true ? f : s)
+abs(int(f32))
+abs(int(f64))
+abs(int(i))
+abs(int(i32))
+abs(int(i64))
+abs(last(array))
+abs(len("bar"))
+abs(len("foo"))
+abs(len(array))
+abs(len(list))
+abs(max(0.5))
+abs(max(1))
+abs(max(1, 1))
+abs(max(1, i64, f64))
+abs(max(f32))
+abs(max(f64))
+abs(max(i))
+abs(max(i32))
+abs(max(i64))
+abs(min(0.5))
+abs(min(0.5, 1))
+abs(min(1))
+abs(min(1, f32))
+abs(min(f32))
+abs(min(f64))
+abs(min(i))
+abs(min(i32))
+abs(min(i64))
+abs(ok ? 1 : "foo")
+abs(ok ? f32 : 1)
+abs(ok ? i : "bar")
+abs(score(1))
+abs(score(i))
+abs(true ? f32 : "bar")
+abs(true ? f64 : i32)
 add
 add != add
-add != add != ok
-add != add && obj?.b
-add != add ? add : !ok
-add != add ? add(a, a) : add
-add != add ? arr : "b"
-add != add ? b : a
-add != add ? obj : obj
-add != add ? s : nil
 add != div
-add != div && obj.b
-add != div == ok
-add != div ? 0 : a
-add != div ? f : obj
-add != div ? nil : false
-add != div ? ok : ok
-add != div || obj?.head(0)
-add != nil ? 1 : 2
-add != nil ? div : s
-add != nil and obj?.obj
-add != nil || obj.a
-add != obj.a
-add != obj.a + a
-add != obj.b
-add != obj.head("a")
-add != obj.head(-a)
-add != obj.head(0 == obj)
-add != obj.head(0, s, ok)
-add != obj.head(add, "c")
-add != obj.head(arr)
-add != obj.head(arr, "a", f)
-add != obj.head(b)
-add != obj.head(f)
-add != obj.head(f, 0, a, 2, f)
-add != obj.head(ok, a, 0)
-add != obj.head(s)
-add != obj.obj
-add != obj.obj.a
-add != obj.obj.obj
-add != obj.obj?.a
-add != obj.obj?.b
-add != obj.obj?.obj
-add != obj?.a
-add != obj?.b
-add != obj?.head(0.5)
-add != obj?.head(a, div, add)
-add != obj?.head(add, 0.5)
-add != obj?.head(div, ok)
-add != obj?.head(f, nil, obj, true, nil)
-add != obj?.head(s, add, div)
-add != obj?.obj
-add != obj?.obj.obj?.a
-add != obj?.obj?.a
-add != obj[nil]
+add != div ? foo : i64
+add != div and ok
+add != foo.Qux
+add != foo.String
+add != foo?.Qux
+add != foo?.String
+add != greet
+add != greet ? score : f32
+add != half
+add != half == nil
+add != half ? 0.5 : ok
+add != nil == nil
+add != nil ? "bar" : f32
+add != nil ? half : f32
+add != score
 add == add
-add == add != ok
-add == add == true
-add == add ? 1 : f
-add == add ? ok : a
-add == add ? ok : f
-add == add or obj.obj
-add == add or ok
+add == add == ok
 add == div
-add == div != nil
-add == div && obj.fn(nil, 0)
-add == div ? f : a
-add == div || s >= "b"
-add == get(obj, s)
-add == nil == nil
-add == nil or obj.obj
-add == nil or ok
-add == obj.a
-add == obj.b
-add == obj.head("c", s)
-add == obj.head(2, a)
-add == obj.head(add, add, obj)
-add == obj.head(f, "b", false, f)
-add == obj.head(f, arr)
-add == obj.head(obj)
-add == obj.obj
-add == obj.obj.b
-add == obj.obj?.a
-add == obj.obj?.b
-add == obj?.a
-add == obj?.b
-add == obj?.c?.b
-add == obj?.fn(b)
-add == obj?.head("c")
-add == obj?.head(add)
-add == obj?.head(add, f, nil)
-add == obj?.head(b, nil)
-add == obj?.head(div)
-add == obj?.head(obj)
-add == obj?.head(s)
-add == obj?.obj
-add == obj?.obj.a
-add == obj?.obj.obj
-add == obj?.obj?.a
-add in [b]
-add in obj.head(nil)
-add in obj?.head(arr)
-add in obj?.head(arr, ok)
-add in obj[toJSON(nil)]
-add(-0, a)
-add(-0, b)
-add(-0, obj?.b)
-add(-0, ok ? b : div)
-add(-1, a)
-add(-2, a)
-add(-2, b)
-add(-a, a)
-add(-a, obj.a)
-add(-b, b)
-add(0 * b, obj?.a)
-add(0 - a, a - a)
-add(0, 0) <= f
-add(0, 0) == obj.head(f)
-add(0, 0) > last(arr)
-add(0, 1) + f
-add(0, 1) .. obj.b
-add(0, 2) % (0 - b)
-add(0, 2) > b
-add(0, 2) > f
-add(0, 2) ^ obj.b
-add(0, a) != f
-add(0, a) % (0 + a)
-add(0, a) + a
-add(0, a) + f
-add(0, a) + obj.head(f)
-add(0, a) <= f
-add(0, a) > 0.5 ? obj : div
-add(0, b) ** (f * f)
-add(0, b) ** 0.5 ^ f
-add(0, b) ** b
-add(0, b) - max(f)
-add(0, b) - obj.b
-add(0, b) .. a
-add(0, b) .. b
-add(0, b) <= a + 0
-add(1 % b, b)
-add(1 + 0, b)
-add(1, 0) == f
-add(1, 0) ^ a
-add(1, 1) > f
-add(1, 2) ^ f
-add(1, a) * obj.b
-add(1, a) in arr
-add(1, b) % a
-add(1, b) + obj.head(a)
-add(1, b) == f
-add(2 - a, obj.fn(a))
-add(2 - b, min(0))
-add(2, 0) < a
-add(2, 0) <= div(b, 2)
-add(2, 2) + f
-add(2, 2) / obj.fn(b)
-add(2, 2) > b
-add(2, a) - a
-add(2, a) .. a
-add(2, a) ^ a
-add(2, b) != a
-add(2, b) / b
-add(2, b) > b
-add(2, b) >= a
-add(2, b) ^ obj.b
-add(a % 2, a)
-add(a % a, obj.b)
-add(a % b, b)
-add(a * 0, a)
-add(a * 0, b * b)
-add(a * a, a)
-add(a * a, get(arr, b))
-add(a * b, obj?.head(b))
-add(a - 0, obj.b)
-add(a - 1, a)
-add(a - 2, a)
-add(a - b, b)
-add(a, -0)
-add(a, -1)
-add(a, -a)
-add(a, -b)
-add(a, 0) ** f
-add(a, 0) - f ** 0.5
-add(a, 0) .. -b
-add(a, 0) .. obj?.a
-add(a, 0) < 2 ? f : 1
-add(a, 0) < b
-add(a, 0) > a
-add(a, 0) >= float(2)
-add(a, 0) ^ f
-add(a, 1) != 0.5 ? ok : add
-add(a, 1) ** a
-add(a, 1) - f
-add(a, 1) < b
-add(a, 1) > obj.a
-add(a, 1) >= a
-add(a, 1) in 1 .. a
-add(a, 2) ** f
-add(a, 2) / f
-add(a, a * 2)
-add(a, a - a)
-add(a, a)
-add(a, a) != 0.5 ? s : b
-add(a, a) != f
-add(a, a) != obj?.obj
-add(a, a) % obj?.a
-add(a, a) % obj?.fn(b)
-add(a, a) - f
-add(a, a) .. obj.a
-add(a, a) / a
-add(a, a) / b
-add(a, a) / f
-add(a, a) < b
-add(a, a) < f
-add(a, a) == a
-add(a, a) > 1 - a
-add(a, a) >= -b
-add(a, a) >= 0.5 * 0
-add(a, a) >= a
-add(a, a) ^ f
-add(a, abs(b))
-add(a, add(a, 2))
-add(a, add(a, b))
-add(a, add(b, a))
-add(a, add(b, b))
-add(a, arr[a])
-add(a, arr[b])
-add(a, b * a)
-add(a, b)
-add(a, b) ** obj.b
-add(a, b) ** obj.head(1, div)
-add(a, b) + f / a
-add(a, b) - b
-add(a, b) - obj.a
-add(a, b) / int(b)
-add(a, b) == a
-add(a, b) == b
-add(a, b) == obj.obj
-add(a, b) ^ b
-add(a, b) ^ obj.b
-add(a, count(arr, ok))
-add(a, div(1, 1))
-add(a, get(arr, a))
-add(a, int(a))
-add(a, int(f))
-add(a, len(obj))
-add(a, max(1))
-add(a, obj.a)
-add(a, obj.b)
-add(a, obj?.a)
-add(a, obj?.b)
-add(a, obj?.fn(a))
-add(a, obj?.head(0))
-add(a, obj?.head(0, div, nil))
-add(a, obj?.obj.b)
-add(abs(0), b)
-add(abs(a), obj?.a)
-add(add(0, a), b)
-add(add(2, a), b)
-add(add(a, 0), -2)
-add(add(a, 2), b)
-add(add(a, b), b)
-add(add(b, 0), a)
-add(add(b, 0), b)
-add(add(b, 2), a)
-add(add(b, 2), b)
-add(add(b, b), a)
-add(arr[b], b)
-add(b % 1, b + b)
-add(b % a, a)
-add(b * b, -a)
-add(b + 0, a)
-add(b + 0, len("b"))
-add(b + 1, obj?.b)
-add(b + 2, get(arr, 1))
-add(b - 0, b)
-add(b - 0, get(arr, 1))
-add(b - 1, a)
-add(b - a, obj.a)
-add(b, -1)
-add(b, -2)
-add(b, -a)
-add(b, -b)
-add(b, 0 * a)
-add(b, 0 + b)
-add(b, 0) != b ? arr : obj
-add(b, 0) != f
-add(b, 0) * obj.b
-add(b, 0) ** a
-add(b, 0) ** obj.a
-add(b, 0) + a
-add(b, 0) + f
-add(b, 0) == b + 0
-add(b, 0) > a - f
-add(b, 0) >= b
-add(b, 0) >= obj?.b
-add(b, 0) ^ (0 + 0.5)
-add(b, 1) ** -2
-add(b, 1) + a
-add(b, 1) <= a
-add(b, 1) == obj?.head(add, f)
-add(b, 1) ^ f
-add(b, 2 % a)
-add(b, 2) == obj.obj.a
-add(b, a * b)
-add(b, a)
-add(b, a) != a ? s : obj
-add(b, a) != f
-add(b, a) * obj.a
-add(b, a) + a
-add(b, a) - b
-add(b, a) .. obj?.head(0, nil, f)
-add(b, a) > a % b
-add(b, a) > b == true
-add(b, a) >= b
-add(b, a) ^ b
-add(b, a) ^ obj?.a
-add(b, add(0, b))
-add(b, add(1, b))
-add(b, add(2, b))
-add(b, add(b, 2))
-add(b, arr[0])
-add(b, b % a)
-add(b, b * a)
-add(b, b + a)
-add(b, b)
-add(b, b) % div(a, 1)
-add(b, b) + b
-add(b, b) - -b
-add(b, b) - a
-add(b, b) - f
-add(b, b) < a + 0
-add(b, b) >= a + 0.5
-add(b, b) ^ obj?.b
-add(b, div(0, a))
-add(b, div(1, b))
-add(b, div(a, a))
-add(b, div(b, a))
-add(b, div(b, b))
-add(b, first(arr))
-add(b, get(arr, b))
-add(b, int(a))
-add(b, len(arr))
-add(b, max(b))
-add(b, min(a))
-add(b, obj.a)
-add(b, obj.a) % a
-add(b, obj.b)
-add(b, obj.head(a))
-add(b, obj.obj.a)
-add(b, obj.obj?.b)
-add(b, obj?.a)
-add(b, obj?.b)
-add(b, obj?.head(a))
-add(b, obj?.obj.b)
-add(b, ok ? 1 : a)
-add(div(0, a), b)
-add(div(a, a), add(0, 0))
-add(div(a, b), b)
-add(div(b, 2), a)
-add(div(b, a), -a)
-add(div(b, a), obj?.head(a, div))
-add(div(b, b), b)
-add(div(b, b), obj?.a)
-add(false ? add : 0, 0 + a)
-add(get(arr, 0), last(arr))
-add(get(arr, a), a)
-add(get(arr, a), b)
-add(get(arr, b), b)
-add(indexOf("a", "b"), b)
-add(indexOf(s, s), a)
-add(int(0), 0 - a)
-add(int(0), b)
-add(int(2), div(b, b))
-add(int(a), b)
-add(int(b), a)
-add(int(f), 1 * b)
-add(last(arr), a)
-add(len(obj), b)
-add(len(s), a)
-add(max(0), a)
-add(max(2), int(a))
-add(min(0), len(arr))
-add(min(2), a)
-add(min(a), b)
-add(min(a), len(arr))
-add(min(a), obj.a)
-add(obj.a, a)
-add(obj.a, b)
-add(obj.a, obj.a)
-add(obj.a, obj.b)
-add(obj.b, a * a)
-add(obj.b, a)
-add(obj.b, arr[0])
-add(obj.b, b)
-add(obj.b, obj.a)
-add(obj.b, obj.b)
-add(obj.b, obj.fn(b))
-add(obj.b, obj?.a)
-add(obj.b, obj?.b)
-add(obj.b, obj?.head(0))
-add(obj.b, obj?.head(b))
-add(obj.fn(0), b)
-add(obj.fn(a), obj.a)
-add(obj.fn(b), a)
-add(obj.head(0), 2 * a)
-add(obj.head(0), obj?.head(b))
-add(obj.head(1, add), obj.a)
-add(obj.head(2, 0, "a"), b)
-add(obj.head(a), b)
-add(obj.head(b), a)
-add(obj.head(b), b)
-add(obj.head(b, obj), b)
-add(obj.obj?.b, a)
-add(obj?.a, -a)
-add(obj?.a, a + 0)
-add(obj?.a, a - b)
-add(obj?.a, a)
-add(obj?.a, b % 1)
-add(obj?.a, b)
-add(obj?.a, div(a, b))
-add(obj?.a, div(b, a))
-add(obj?.a, obj.a)
-add(obj?.a, obj.b)
-add(obj?.a, obj?.head(a, f, obj))
-add(obj?.b, -0)
-add(obj?.b, -1)
-add(obj?.b, 0 * a)
-add(obj?.b, 0 * b)
-add(obj?.b, 2 + a)
-add(obj?.b, a)
-add(obj?.b, add(0, a))
-add(obj?.b, b)
-add(obj?.b, min(0))
-add(obj?.b, obj.a)
-add(obj?.b, obj.b)
-add(obj?.b, obj?.a)
-add(obj?.b, obj?.b)
-add(obj?.b, obj?.head(0))
-add(obj?.fn(0), int(a))
-add(obj?.fn(0), obj.a)
-add(obj?.fn(b), obj.a)
-add(obj?.head(0, 0, false), arr[a])
-add(obj?.head(a), b)
-add(obj?.head(b), b)
-add(obj?.head(b, s), a)
-add(obj?.obj.a, b)
-add(ok ? 2 : f, obj.b)
-add(ok ? a : f, obj.b)
-add(ok ? a : s, b)
-all(0 .. 0, nil != 0)
-all(0 .. 2, "c" startsWith s)
-all(0 .. 2, ok)
-all(0 .. a, ok)
-all(0 .. b, ok)
-all(a .. 0, "a" matches s)
-all(a .. 0, a > b)
-all(a .. b, !ok)
-all(arr, "a" <= s)
-all(arr, "a" contains "b")
-all(arr, "a" in obj)
-all(arr, "b" matches "a")
-all(arr, "c" in obj)
-all(arr, "c" matches s)
-all(arr, # != f)
-all(arr, 0 == nil)
-all(arr, 0 > b)
-all(arr, 0.5 != b)
-all(arr, 0.5 <= a)
-all(arr, 0.5 >= a)
-all(arr, 2 != 1)
-all(arr, 2 < 0)
-all(arr, 2 < a)
-all(arr, 2 <= a)
-all(arr, 2 > f)
-all(arr, a != a)
-all(arr, a < 0)
-all(arr, a < 1)
-all(arr, a < b)
-all(arr, a < obj.b)
-all(arr, a <= f)
-all(arr, a == a)
-all(arr, a == f)
-all(arr, a > f)
-all(arr, a >= b)
-all(arr, add != add)
-all(arr, add == nil)
-all(arr, all(arr, ok))
-all(arr, all(arr, true))
-all(arr, any(arr, ok))
-all(arr, b < 0)
-all(arr, b <= b)
-all(arr, b == a)
-all(arr, f != a)
-all(arr, f < #)
-all(arr, f == b)
-all(arr, f == f)
-all(arr, f >= b)
-all(arr, f >= f)
-all(arr, false == ok)
-all(arr, false ? div : false)
-all(arr, false and ok)
-all(arr, false) and f <= b
-all(arr, nil != 2)
-all(arr, nil != nil)
-all(arr, nil == "b")
-all(arr, nil == add)
-all(arr, nil == arr)
-all(arr, none(arr, ok))
-all(arr, not true)
-all(arr, obj.head(false))
-all(arr, obj?.head(true))
-all(arr, ok != nil)
-all(arr, ok && ok)
-all(arr, ok == obj.b)
-all(arr, ok || false)
-all(arr, ok)
-all(arr, ok) != obj?.b
-all(arr, ok) != obj?.obj
-all(arr, ok) or obj.b
-all(arr, ok) or obj?.head(a)
-all(arr, one(arr, ok))
-all(arr, s != s)
-all(arr, s <= "b")
-all(arr, s > "a")
-all(arr, s contains s)
-all(arr, s matches s)
-all(arr, true or false)
-all(arr, true or true)
-all(arr, true) && a == nil
-all(b .. a, a > f)
-all(filter(arr, false), ok || ok)
-all(filter(arr, true), "a" >= "a")
-all(map(arr, "b"), ok)
-all(map(arr, 0), ok)
-all(map(arr, 0.5), 1 < 2)
-all(map(arr, 0.5), ok)
-all(map(arr, 2), b != b)
-all(map(arr, add), 2 < f)
-all(map(arr, arr), 2 == b)
-all(map(arr, b), b >= b)
-all(map(arr, b), not true)
-all(map(arr, b), ok)
-all(map(arr, f), a > f)
-all(map(arr, false), #)
-all(map(arr, obj), 0 <= f)
-all(map(arr, ok), #)
-all(map(arr, s), ok)
-all(obj.head("c"), ok)
-all(obj.head(arr, 0.5, div), true or false)
-all(obj.head(obj, a), ok)
-all(obj.head(obj, f, b), ok)
-all(obj.head(obj, s), 0 >= f)
-all(obj.head(s), b < 0)
-all(obj.obj, "a" == s)
-all(obj.obj, a >= a)
-all(obj.obj, add == add)
-all(obj.obj, all(arr, ok))
-all(obj.obj, div == nil)
-all(obj.obj, f <= a)
-all(obj.obj, obj.head(ok, div))
-all(obj.obj, ok || ok)
-all(obj.obj, ok)
-all(obj?.head("b", ok, add, 0), ok)
-all(obj?.head("c", b), 0 < a)
-all(obj?.head(arr), 0.5 > f)
-all(obj?.head(arr), b < f)
-all(obj?.head(arr), obj.head(ok))
-all(obj?.head(arr, 0.5, add, nil), f != 0.5)
-all(obj?.head(obj), a <= 0)
-all(obj?.head(obj, nil), ok)
-all(obj?.head(s), 1 == f)
-all(obj?.obj, 0 > 0)
-all(obj?.obj, b == 0.5)
-all(obj?.obj, b >= 1)
-all(obj?.obj, b >= a)
-all(obj?.obj, div != nil)
-all(obj?.obj, nil in arr)
-all(obj?.obj, obj.head(ok))
-all(obj?.obj, obj?.head(ok, ok))
-all(obj?.obj, ok && false)
-all(obj?.obj, ok)
-all(obj?.obj, s endsWith "c")
-all(obj?.obj, s matches s)
-all(ok ? arr : s, ok or true)
-all(ok ? obj : f, b > f)
-any(0 .. a, ok)
-any([false, "c"], ok)
-any([ok, false], #)
-any(a .. b, ok ? ok : obj)
-any(a .. b, ok)
-any(arr, !false)
-any(arr, !true)
-any(arr, "a" == obj.b)
-any(arr, "b" < s)
-any(arr, "c" != obj?.obj)
-any(arr, "c" startsWith "c")
-any(arr, # != a)
-any(arr, # != b)
-any(arr, 0 != 0.5)
-any(arr, 0.5 != b)
-any(arr, 0.5 >= f)
-any(arr, 1 != 0)
-any(arr, 2 < 0.5)
-any(arr, a != b)
-any(arr, a < b)
-any(arr, a == 0.5)
-any(arr, a == f)
-any(arr, a > 0.5)
-any(arr, a > b)
-any(arr, a in arr)
-any(arr, add != div)
-any(arr, any(arr, true))
-any(arr, b != f)
-any(arr, b < f)
-any(arr, b <= f)
-any(arr, b == 0)
-any(arr, b > 0)
-any(arr, b > f)
-any(arr, div == div)
-any(arr, f < a)
-any(arr, f < b)
-any(arr, f <= 0.5)
-any(arr, f > 0.5)
-any(arr, f >= a)
-any(arr, false and false)
-any(arr, false and ok)
-any(arr, false || false)
-any(arr, false) != ok
-any(arr, false) && ok
-any(arr, false) ? div(nil, a) : obj
-any(arr, false) || false ? div : 0
-any(arr, nil != add)
-any(arr, nil != f)
-any(arr, nil != s)
-any(arr, nil == "b")
-any(arr, nil == "c")
-any(arr, nil == 1)
-any(arr, nil == a)
-any(arr, nil == add)
-any(arr, nil == b)
-any(arr, nil == s)
-any(arr, not ok)
-any(arr, obj.head(false))
-any(arr, obj.head(false, div, 0, add))
-any(arr, obj.head(false, true))
-any(arr, obj.head(ok, add))
-any(arr, ok != nil)
-any(arr, ok ? ok : b)
-any(arr, ok)
-any(arr, ok) && obj.a
-any(arr, ok) && obj.obj
-any(arr, ok) && ok
-any(arr, ok) == ok
-any(arr, ok) ? s : keys(obj)
-any(arr, ok) and obj.a
-any(arr, ok) or obj.b
-any(arr, ok) or ok
-any(arr, one(arr, false))
-any(arr, s <= s)
-any(arr, s contains "c")
-any(arr, s endsWith "b")
-any(arr, string(2) != s)
-any(arr, true) != ok
-any(arr, true) && obj?.head(false)
-any(arr, true) and b != f
-any(arr, true) or obj?.a
-any(arr, true) || obj.obj
-any(arr[0:b], div != div)
-any(b .. 2, a == b)
-any(b .. a, obj?.a)
-any(false ? add : obj, nil == f)
-any(false ? div : "a", ok)
-any(false ? false : s, !true)
-any(filter(arr, ok), a != a)
-any(filter(arr, ok), ok ? ok : 0)
-any(filter(arr, ok), ok)
-any(filter(arr, true), "b" in obj)
-any(keys(obj), ok)
-any(map(arr, 0), a < a)
-any(map(arr, 0), b <= 0)
-any(map(arr, 0), nil != "b")
-any(map(arr, 0.5), a <= a)
-any(map(arr, a), false && ok)
-any(map(arr, add), ok)
-any(map(arr, arr), 2 == nil)
-any(map(arr, div), 0 > f)
-any(map(arr, div), ok)
-any(map(arr, f), b == 0)
-any(map(arr, f), nil != a)
-any(map(arr, f), ok)
-any(map(arr, ok), #)
-any(map(obj.head(s), a), ok)
-any(obj.head("b"), ok)
-any(obj.head("c", obj), 1 != nil)
-any(obj.head(arr), 0 < b)
-any(obj.head(obj), a < b)
-any(obj.head(s), 0 >= 0)
-any(obj.obj, 0.5 > b)
-any(obj.obj, 2 == 0.5)
-any(obj.obj, a < f)
-any(obj.obj, obj != obj)
-any(obj.obj, ok && false)
-any(obj.obj, ok and ok)
-any(obj.obj, ok)
-any(obj.obj, s <= s)
-any(obj.obj, s > "a")
-any(obj?.head(arr), ok)
-any(obj?.head(upper(a, 0, "c")), ok)
-any(obj?.obj, 0 >= 0.5)
-any(obj?.obj, a <= 0.5)
-any(obj?.obj, arr == arr)
-any(obj?.obj, b == b)
-any(obj?.obj, f == 1)
-any(obj?.obj, f == nil)
-any(obj?.obj, f > a)
-any(obj?.obj, not false)
-any(obj?.obj, not ok)
-any(obj?.obj, ok != nil)
-any(obj?.obj, ok)
-any(obj?.obj, s >= "c")
-any(obj?.obj?.obj, ok)
-any(ok ? "b" : ok, 2 != b)
-any(ok ? arr : ok, ok)
-any(ok ? obj : 0, b < b)
-any(ok ? obj : ok, 0 < 0.5)
-arr
-arr != arr
-arr != arr && ok ? arr : f
-arr != arr == obj.head(a)
-arr != b .. 0
-arr != filter(arr, true)
-arr != map(arr, 0)
-arr != map(arr, arr)
-arr != map(arr, obj)
-arr != nil ? ok : f
-arr != nil ? ok : ok
-arr != nil and f != b
-arr != nil or a == 0
-arr != nil || true && false
-arr != obj.a
-arr != obj.b
-arr != obj.head(0.5)
-arr != obj.head(add, add)
-arr != obj.head(all("c", ok))
-arr != obj.head(arr, add)
-arr != obj.head(arr, s)
-arr != obj.head(b)
-arr != obj.head(b, 0)
-arr != obj.head(b, b, b, true)
-arr != obj.head(nil)
-arr != obj.head(s)
-arr != obj.head(true, b, "a")
-arr != obj.obj
-arr != obj.obj.a
-arr != obj?.a
-arr != obj?.b
-arr != obj?.head("a" >= s)
-arr != obj?.head(0)
-arr != obj?.head(0.5)
-arr != obj?.head(div)
-arr != obj?.head(false)
-arr != obj?.head(nil)
-arr != obj?.head(obj, add)
-arr != obj?.head(obj, s, arr, add).a
-arr != obj?.head(s)
-arr != obj?.obj
-arr != obj?.obj.b
-arr != obj?.obj?.a
-arr == a .. a
-arr == arr
-arr == arr != ok
-arr == arr == ok
-arr == arr ? "b" : add
-arr == arr ? a : 0
-arr == arr ? add : obj
-arr == arr ? nil : "a"
-arr == arr ? obj : nil
-arr == arr ? obj?.head(div, "b") : s
-arr == arr ? ok : a
-arr == arr ? s : a
-arr == arr and obj?.fn(a)
-arr == arr and obj?.head(a, 0.5, arr, arr)
-arr == arr or obj.b != b
-arr == map(arr, true)
-arr == nil ? a : ok
-arr == nil ? ok : div
-arr == nil or add == div
-arr == nil or obj.fn(b)
-arr == nil || obj.b
-arr == obj.a
-arr == obj.b
-arr == obj.head(0, div)
-arr == obj.head(arr, f, ok)
-arr == obj.head(f, obj)
-arr == obj.head(s, 0)
-arr == obj.obj
-arr == obj.obj ? arr : obj
-arr == obj.obj.b
-arr == obj.obj.obj
-arr == obj?.a
-arr == obj?.b
-arr == obj?.head(a)
-arr == obj?.head(a, nil)
-arr == obj?.head(arr)
-arr == obj?.head(arr, "c")
-arr == obj?.head(b, ok)
-arr == obj?.head(div)
-arr == obj?.head(false)
-arr == obj?.head(nil, f, "b")
-arr == obj?.head(obj, arr)
-arr == obj?.head(s, 0.5)
-arr == obj?.head(s, a)
-arr == obj?.obj
-arr == obj?.obj.b
-arr == obj?.obj.obj
-arr == obj?.obj.obj?.a
-arr in keys(obj)
-arr in obj.head(arr)
-arr in obj?.head(get(0, b))
-arr[-a]
-arr[0 * 2]
-arr[0 * a]
-arr[0 + 0]
-arr[0 + 2:a]
-arr[0] % b
-arr[0] - a
-arr[0] / obj?.head(f, 0)
-arr[0] <= min(1)
-arr[0] >= f
-arr[1 % b]
-arr[1 * a]
-arr[1] < a
-arr[1] == b
-arr[2 % b]
-arr[2 * 0:b]
-arr[2] * obj.a
-arr[a + a]
-arr[a - b]
-arr[a]
-arr[a] != f
-arr[a] != f + 1
-arr[a] * a
-arr[a] ** a
-arr[a] + f
-arr[a] - 1 / 1
-arr[a] .. b
-arr[a] <= a
-arr[a] > -a
-arr[a] >= f
-arr[a] ^ f
-arr[add(a, 0)]
-arr[add(b, 0):b]
-arr[add(b, 0)]
-arr[b % b]
-arr[b - 0]
-arr[b - a]
-arr[b:a * b]
-arr[b:obj.b]
-arr[b]
-arr[b] % a
-arr[b] * (b + a)
-arr[b] ** a
-arr[b] - add(b, 1)
-arr[b] - arr[a]
-arr[b] - b
-arr[b] - f
-arr[b] - obj?.b
-arr[b] == obj.b
-arr[b] > -0
-arr[b] > a
-arr[b] > b
-arr[b] > get(arr, 0)
-arr[b] > last(arr)
-arr[div(a, 1)]
-arr[div(a, 2)]
-arr[div(a, b)]
-arr[len("a")]
-arr[max(0)]
-arr[max(b)]
-arr[obj.a]
-arr[obj.b:obj?.fn(2)]
-arr[obj.b]
-arr[obj.fn(a)]
-arr[obj.head(a)]
-arr[obj.head(a, obj)]
-arr[obj.head(f)]
-arr[obj?.a]
-arr[obj?.b]
-arr[obj?.fn(0)]
-arr[obj?.head(b)]
-arr[obj?.head(f)]
-arr[true ? b : obj]
-b
-b != -a
-b != -f
-b != 0 % b
-b != 0 && obj?.head("c", 0.5)
-b != 0 * a
-b != 0 ? false : 1
-b != 0 ? obj : arr
-b != 0 ? ok : nil
-b != 0 ? true : arr
-b != 0 or s <= "b"
-b != 0.5 * a
-b != 0.5 == ok != ok
-b != 0.5 ? ok : ok
-b != 0.5 ^ obj?.b
-b != 1 - b
-b != 1 - f
-b != 1 / a
-b != 1 == ok
-b != 2 || f > a
-b != a
-b != a % a
-b != a * a
-b != a - a
-b != a / 0.5
-b != a ? "b" : arr
-b != a ? "c" : obj
-b != a ? a : "a"
-b != a ? f : div
-b != a ? obj : add
-b != add(2, 0)
-b != add(2, a)
-b != add(a, a)
-b != b
-b != b != false
-b != b - a
-b != b - b
-b != b == nil
-b != b == ok
-b != b ? ok : div
-b != b ? s : obj.a
-b != div(2, b)
-b != f
-b != f != ok
-b != f / a
-b != f == true
-b != f ? 0.5 : arr
-b != f ? arr : ok
-b != f ? obj : add
-b != f or obj.b
-b != float(a)
-b != get(arr, 2)
-b != get(obj, s)
-b != nil ? nil : s
-b != nil ? obj : f
-b != nil || ok
-b != obj.a
-b != obj.b
-b != obj.c
-b != obj.head("b", obj)
-b != obj.head(add)
-b != obj.head(arr)
-b != obj.head(arr, f < b)
-b != obj.head(b, obj, false)
-b != obj.head(div, f)
-b != obj.head(nil, s)
-b != obj.head(obj)?.a
-b != obj.head(ok or not b)
-b != obj.head(ok)
-b != obj.obj
-b != obj.obj.obj
-b != obj?.a
-b != obj?.a ** b
-b != obj?.b
-b != obj?.head(div)
-b != obj?.head(false, ok)
-b != obj?.head(map(obj, add))
-b != obj?.head(not (0 == 0))
-b != obj?.head(obj)
-b != obj?.obj
-b != obj?.obj.obj
-b != obj?.obj?.a
-b % (0 + b)
-b % (0 - a)
-b % (b - a)
-b % -1
-b % -a
-b % -obj.b
-b % -obj?.b
-b % 1 - f - b
-b % 1 / 0.5
-b % 2 >= obj?.head(f)
-b % 2 in arr
-b % a
-b % a % a
-b % a % b
-b % a * a
-b % a * f
-b % a + 0.5 + b
-b % a - a
-b % a - f
-b % a .. b
-b % a / a
-b % a <= a
-b % a == b
-b % a > b
-b % a in arr
-b % add(0, b)
-b % add(1, 2)
-b % add(a, a)
-b % arr[a]
-b % arr[obj?.b]
-b % b
-b % b != a
-b % b % obj.a
-b % b * b
-b % b + -0.5
-b % b - b
-b % b - f
-b % b < a
-b % b < f
-b % b <= f ? s : s
-b % b == b
-b % get(arr, b)
-b % max(0, a)
-b % obj.a
-b % obj.b
-b % obj.fn(1)
-b % obj.head(a, div)
-b % obj.obj.a
-b % obj?.a
-b % obj?.b
-b % obj?.fn(b)
-b % obj?.head(a)
-b % obj?.head(a, obj)
-b % obj?.head(b)
-b % obj?.head(b, ok, div)
-b % obj?.head(obj, false).b
-b % obj?.obj?.a
-b % obj?.obj?.b
-b * (0 + f)
-b * (2 + 0.5)
-b * (a + f)
-b * (a - 1)
-b * -0
-b * -0.5
-b * -a
-b * -b
-b * -f
-b * 0 != a
-b * 0 * 0
-b * 0 ** 1
-b * 0 - get(arr, a)
-b * 0 .. a
-b * 0 / a
-b * 0 / f
-b * 0 < b
-b * 0 >= b
-b * 0 >= f
-b * 0.5 / (b - b)
-b * 0.5 / b
-b * 0.5 <= f
-b * 0.5 == b
-b * 1 * a
-b * 1 * min(b)
-b * 2 == f
-b * 2 > obj.b
-b * a
-b * a * a
-b * a ** f
-b * a + a
-b * a - a
-b * a .. b
-b * a / 0.5
-b * a <= f
-b * a == 0.5 - f
-b * a == obj?.a
-b * a > 2 ** f
-b * a > f
-b * a ^ 0
-b * abs(0)
-b * abs(a)
-b * abs(b)
-b * add(2, b)
-b * b
-b * b != 0 % a
-b * b != f
-b * b % a
-b * b * obj.a
-b * b + b
-b * b - obj.a
-b * b / a
-b * b / f
-b * b / obj?.a
-b * b == f
-b * b == len(s)
-b * b > f
-b * b ^ a
-b * b in arr
-b * f
-b * f * 0
-b * f * 2
-b * f * b
-b * f + b
-b * f + obj.a
-b * f / b
-b * f <= a == true
-b * f <= b
-b * f == b
-b * f ^ 0.5
-b * first(arr)
-b * float(0.5)
-b * float(f)
-b * get(arr, 0)
-b * get(arr, 1)
-b * int(a)
-b * max(2)
-b * obj.a
-b * obj.b
-b * obj.fn(b)
-b * obj.head(a)
-b * obj.head(b)
-b * obj.obj.a
-b * obj.obj.b
-b * obj.obj?.a
-b * obj.obj?.b
-b * obj?.a
-b * obj?.b
-b * obj?.fn(obj.b)
-b * obj?.fn(obj?.b)
-b * obj?.head(b, a) * obj.a
-b * obj?.head(f)
-b * obj?.head(f, f < 0)
-b * obj?.obj.b
-b ** (0 * 0.5)
-b ** (0 * f)
-b ** (0 - a)
-b ** (0 / b)
-b ** (1 % 1)
-b ** (2 * a)
-b ** (a % b)
-b ** (a - a)
-b ** (b + b)
-b ** (b / f)
-b ** (f * b)
-b ** (f + 0)
-b ** (f - 0)
-b ** (f - 2)
-b ** (f / f)
-b ** -a
-b ** -b
-b ** 0 * b * a
-b ** 0 - b
-b ** 0 < f
-b ** 0 < obj?.fn(2)
-b ** 0 == a
-b ** 0 ^ a ** f
-b ** 0 ^ obj.b
-b ** 0.5 ** a
-b ** 0.5 ** f
-b ** 0.5 + obj?.a
-b ** 0.5 >= b
-b ** 0.5 ^ (a * b)
-b ** 0.5 ^ b
-b ** 1 / a
-b ** 1 / f
-b ** 2 ** a
-b ** 2 ** b
-b ** 2 + 0.5 ^ f
-b ** 2 - a
-b ** a
-b ** a != obj?.a
-b ** a != obj?.b
-b ** a * b
-b ** a * obj.b
-b ** a ** b
-b ** a + obj?.head(0)
-b ** a - obj?.fn(b)
-b ** a / b
-b ** a / obj.fn(a)
-b ** a < a
-b ** a == obj?.fn(b)
-b ** a > b
-b ** a ^ 2
-b ** a ^ a
-b ** arr[0]
-b ** arr[a]
-b ** b
-b ** b * obj?.b
-b ** b ** 0
-b ** b ** 0.5
-b ** b + a
-b ** b < a % 2
-b ** b ^ f
-b ** div(a, a)
-b ** div(b, 2)
-b ** f
-b ** f != f
-b ** f != obj.a
-b ** f * a
-b ** f * f
-b ** f * obj.b
-b ** f ** f
-b ** f < 0 * 0.5
-b ** f < b
-b ** f ^ a
-b ** f ^ b
-b ** int(0.5)
-b ** int(a)
-b ** int(b)
-b ** max(1)
-b ** max(a, a, f)
-b ** min(1)
-b ** obj.a
-b ** obj.b
-b ** obj.fn(2)
-b ** obj.fn(b)
-b ** obj.head(a)
-b ** obj.head(b)
-b ** obj.obj?.a
-b ** obj.obj?.b
-b ** obj?.a
-b ** obj?.b
-b ** obj?.fn(b)
-b ** obj?.head(0.5)
-b ** obj?.head(0.5, arr, "c")
-b ** obj?.head(b, arr)
-b ** obj?.obj.b
-b ** obj?.obj?.a
-b + -2
-b + -b
-b + -f
-b + 0 % b
-b + 0 + a
-b + 0 + b
-b + 0 - b
-b + 0 - obj.head(0.5, obj, div, obj, a)
-b + 0 >= a
-b + 0 ^ 1
-b + 0.5 != b - 0
-b + 0.5 + -0
-b + 0.5 + a % a
-b + 0.5 / 2
-b + 0.5 / b
-b + 0.5 >= b ? "c" : arr
-b + 1 == obj.obj
-b + 2 < -b
-b + 2 < b
-b + 2 <= b
-b + 2 == obj.b
-b + 2 ^ 0
-b + a
-b + a != 1 * b
-b + a != obj.obj
-b + a % a
-b + a ** 0
-b + a .. a
-b + a .. b
-b + a < a == false
-b + a <= b
-b + a > a
-b + add(b, a)
-b + b
-b + b % b
-b + b - a
-b + b - obj?.head(0.5)
-b + b / 1
-b + b / b
-b + b <= a
-b + b == a
-b + b >= get(arr, 0)
-b + b ^ 1
-b + count(arr, true)
-b + div(0, 1)
-b + f
-b + f != b ? nil : f
-b + f ** a
-b + f + a
-b + f - b
-b + f - b - b
-b + f - obj.fn(a)
-b + f == f
-b + f == obj?.a
-b + f > b
-b + f > div(2, a)
-b + float(0.5)
-b + int(f)
-b + len("c")
-b + max(f)
-b + min(0.5)
-b + obj.a
-b + obj.a > f
-b + obj.b
-b + obj.head(b)
-b + obj.head(f, "c", 0)
-b + obj.head(f, 1, 0.5)
-b + obj.obj.a
-b + obj.obj.b
-b + obj.obj?.b
-b + obj?.a
-b + obj?.b
-b + obj?.head(0, 0.5, nil, b, obj)
-b + obj?.head(0, add)
-b + obj?.head(1, a, obj, obj)
-b + obj?.head(b)
-b + obj?.obj.b
-b + obj?.obj?.a
-b + obj?.obj?.b
-b - -2
-b - -b
-b - -f
-b - 0 - 0
-b - 0 == a ? obj : false
-b - 0 > b
-b - 0 > f
-b - 0 ^ 0
-b - 0.5 != f
-b - 0.5 / b
-b - 1 - b
-b - 1 .. b
-b - 1 / 0
-b - 1 / 2
-b - 1 / a
-b - 1 / f
-b - 1 < b
-b - 1 <= add(b, 0)
-b - 2 ** 2
-b - 2 - 2
-b - 2 / a
-b - 2 < b
-b - a
-b - a % b
-b - a * f
-b - a ** 1
-b - a + f
-b - a - 0.5
-b - a .. a
-b - a == a
-b - a == f
-b - a ^ 0
-b - a ^ b
-b - a in arr
-b - abs(0)
-b - add(2, b)
-b - add(a, 0)
-b - arr[0]
-b - arr[obj.b]
-b - b
-b - b + a
-b - b - b
-b - b - f
-b - b .. a
-b - b < a
-b - b < a ^ 0.5
-b - b ^ 0
-b - b ^ f
-b - div(2, 2)
-b - div(a, a)
-b - f
-b - f ** a
-b - f + 0
-b - f + 1
-b - f + obj?.b
-b - f - 0 ** a
-b - f - 0.5
-b - f - f
-b - f < f
-b - f == a
-b - f >= len(arr)
-b - get(arr, a)
-b - int(0.5)
-b - max(0, a)
-b - max(a)
-b - min(2)
-b - obj.a
-b - obj.a + a
-b - obj.a == b
-b - obj.b
-b - obj.fn(b)
-b - obj.fn(true && a)
-b - obj.head(0, obj)
-b - obj.head(f, 2, f)
-b - obj.obj.a
-b - obj.obj?.a
-b - obj?.a
-b - obj?.b
-b - obj?.fn(b)
-b - obj?.head(1)
-b - obj?.head(f)
-b - obj?.obj.b
-b - obj?.obj?.a
-b - obj?.obj?.b
-b .. -2
-b .. -a
-b .. -b
-b .. 0 * a
-b .. 0 + b
-b .. 0 == obj.b
-b .. 1 * 2
-b .. a
-b .. a % a
-b .. a + b
-b .. add(a, count(arr, false))
-b .. add(b, 0)
-b .. add(b, a)
-b .. add(b, b)
-b .. arr[b % 2]
-b .. b
-b .. b * a
-b .. b + b
-b .. count(arr, ok)
-b .. first(obj.head("b", obj))
-b .. get(arr, 0)
-b .. get(arr, b)
-b .. len(s)
-b .. min(b)
-b .. obj.a
-b .. obj.b
-b .. obj.head(b)
-b .. obj?.a
-b .. obj?.b
-b .. obj?.fn(a)
-b .. obj?.head(2)
-b .. obj?.head(a)
-b .. obj?.head(obj, s, div)?.b
-b .. obj?.obj.b
-b .. obj?.obj?.a
-b / (0 + 0)
-b / (1 + b)
-b / (a + f)
-b / (a - 0.5)
-b / (a - 2)
-b / (b - b)
-b / (f + b)
-b / (f - f)
-b / -0
-b / -0.5
-b / 0 * f
-b / 0 - b
-b / 0 / a
-b / 0 < a
-b / 0 > b
-b / 0 > b ? f : s
-b / 0 >= f
-b / 0.5 * a
-b / 0.5 * f
-b / 0.5 ** 2
-b / 0.5 + b
-b / 0.5 - b
-b / 0.5 <= a
-b / 0.5 <= obj?.a
-b / 0.5 >= 0.5 ? obj : arr
-b / 1 / b
-b / 2 != a
-b / 2 <= abs(1)
-b / 2 ^ 2
-b / a
-b / a != a
-b / a != obj.obj
-b / a ** f
-b / a + a
-b / a + b
-b / a / 0
-b / a / a
-b / a / b
-b / a == obj?.b
-b / a > 2 ? div : arr
-b / a > b
-b / add(1, a)
-b / add(a, a)
-b / add(b, 1)
-b / add(b, b)
-b / arr[a]
-b / b
-b / b * 0 ** b
-b / b ** f
-b / b < b
-b / b < obj.b
-b / b <= b
-b / b ^ 0
-b / f
-b / f != a
-b / f != abs(0.5)
-b / f * f
-b / f ** 0.5
-b / f + b
-b / f / f
-b / f < f
-b / f <= b
-b / f <= f
-b / f <= obj?.a
-b / f == a
-b / f >= a
-b / get(arr, 0)
-b / get(arr, b)
-b / int(a)
-b / min(1)
-b / min(b)
-b / obj.a
-b / obj.b
-b / obj.fn(2)
-b / obj.fn(a)
-b / obj.fn(b)
-b / obj.head(a, arr, add, a)
-b / obj.obj.a
-b / obj.obj.b
-b / obj.obj?.obj.a
-b / obj?.a
-b / obj?.b
-b / obj?.head(b, arr, f)
-b / obj?.obj.a
-b / obj?.obj.b
-b < -2
-b < 0 != obj.b
-b < 0 % b
-b < 0 + 1
-b < 0 - a
-b < 0 or ok
-b < 0 || ok
-b < 0.5 ? a : b
-b < 0.5 ? nil : div
-b < 1 == ok
-b < 1 ? b : 0
-b < 2 && obj.fn(b)
-b < 2 ** 1
-b < 2 / 1
-b < 2 / a
-b < 2 ^ a
-b < a
-b < a ** 0.5
-b < a + a
-b < a - 1
-b < a - f
-b < a / b
-b < a ? "a" : obj
-b < a ? 0 : nil
-b < a ? div : s
-b < a ? obj : f
-b < a ^ a and obj.head("c", 2)?.a
-b < a ^ f
-b < a and ok
-b < add(b, 1)
-b < add(b, a)
-b < b
-b < b && ok
-b < b - 1
-b < b == ok
-b < b ? b : true
-b < b ? f : arr
-b < b ? nil : ok
-b < b ? s : s
-b < b ^ b
-b < b and "b" in obj
-b < b and nil != 0
-b < b and obj.a
-b < b and ok
-b < b or obj?.a
-b < f
-b < f != ok
-b < f ** b
-b < f == ok
-b < f ? 1 : div
-b < f ? obj : b
-b < f ? obj.fn(arr, nil, nil, div) : obj
-b < f ? ok : s
-b < float(0)
-b < float(b)
-b < int(0)
-b < int(f)
-b < obj.a
-b < obj.a != obj?.obj
-b < obj.b
-b < obj.head(f)
-b < obj.obj.a
-b < obj?.a
-b < obj?.b
-b < obj?.b == true != obj.a
-b < obj?.fn(0)
-b < obj?.head(0)
-b < obj?.head(0, s, a)
-b < obj?.head(b)
-b < obj?.head(b, nil)
-b < obj?.obj?.a
-b < obj?.obj?.b
-b <= -0
-b <= -1
-b <= -a
-b <= 0 != ok
-b <= 0 % b
-b <= 0 && obj[s]
-b <= 0 * 0.5
-b <= 0 - 0.5
-b <= 0.5 + 0.5
-b <= 0.5 ? ok : b
-b <= 1 - f
-b <= 1 ? b : a
-b <= 1 || ok
-b <= 2 ? s : obj
-b <= 2 and ok
-b <= a
-b <= a * 1
-b <= a ** 0
-b <= a == nil
-b <= a ? 0 : div
-b <= a ? obj : arr
-b <= a ^ a
-b <= a || obj?.a
-b <= a || ok
-b <= abs(a)
-b <= abs(f)
-b <= add(b, 1)
-b <= arr[b]
-b <= b
-b <= b != nil
-b <= b % b
-b <= b * a
-b <= b + b
-b <= b / f
-b <= b ? add : ok
-b <= b ^ b
-b <= b or b < b
-b <= b or obj.b
-b <= b || ok
-b <= count(arr, ok)
-b <= div(b, b)
-b <= f
-b <= f != false
-b <= f != ok
-b <= f != ok ? arr : add
-b <= f * f
-b <= f ** f
-b <= f + b
-b <= f - obj?.b
-b <= float(b)
-b <= get(arr, 0)
-b <= int(a)
-b <= int(arr[0])
-b <= len(keys(obj))
-b <= max(0)
-b <= max(a)
-b <= max(f, f, a, f, f)
-b <= min(b, 0)
-b <= obj.a
-b <= obj.b
-b <= obj.head(1)
-b <= obj.head(a, 0)
-b <= obj.head(b)
-b <= obj.obj.b
-b <= obj?.a
-b <= obj?.b
-b <= obj?.fn(a)
-b <= obj?.fn(arr[0.5])
-b <= obj?.head(0, ok, false)
-b <= obj?.obj.a
-b == -0.5
-b == -b
-b == -f
-b == 0 != true ? b : arr
-b == 0 * 0
-b == 0 + 0
-b == 0 / a
-b == 0 == obj.b
-b == 0 ? arr : a
-b == 0 ? s : 0.5
-b == 0 and obj?.obj
-b == 0 or obj?.head(s)
-b == 0 || obj.obj
-b == 0.5 != obj.head(a, s, ok)
-b == 1 + obj.a
-b == 1 ? add : false
-b == 1 ^ b
-b == 2 ^ a
-b == a
-b == a != nil
-b == a / 1
-b == a == nil
-b == a ? a : b
-b == a ? div : ok
-b == a ? f : false
-b == a ? f : ok
-b == a or ok
-b == abs(f)
-b == add(0, b)
-b == add(a, 2)
-b == add(a, a)
-b == add(a, b)
-b == arr[a]
-b == arr[b]
-b == b
-b == b != obj?.obj
-b == b != ok
-b == b && 0 != 0
-b == b * 2
-b == b - a
-b == b - b
-b == b / 0.5
-b == b / b
-b == b == not false
-b == b or f < 0
-b == div(b, a)
-b == f
-b == f && ok
-b == f * 0
-b == f - b
-b == f == ok
-b == f ? add : div
-b == f or ok
-b == f || obj.b
-b == float(b)
-b == get(arr, 0)
-b == get(arr, 1)
-b == get(obj.head(nil, 0.5, div), a)
-b == int(0)
-b == len("a")
-b == max(f)
-b == min(0)
-b == nil != obj.a
-b == obj.a
-b == obj.b
-b == obj.b != obj.obj
-b == obj.fn(0)
-b == obj.fn(a)
-b == obj.fn(add(a, 1))
-b == obj.fn(b)
-b == obj.head(arr)
-b == obj.head(div)
-b == obj.head(f)
-b == obj.head(obj?.head(ok, 0, div))
-b == obj.head(ok, b, 2)
-b == obj.head(one(arr, ok))
-b == obj.head(true, add, div)
-b == obj.obj
-b == obj?.a
-b == obj?.b
-b == obj?.head("b")
-b == obj?.head(0)
-b == obj?.head(a)
-b == obj?.head(div)
-b == obj?.head(nil, add, ok)
-b == obj?.head(obj).a
-b == obj?.head(obj?.b)
-b == obj?.head(s)
-b == obj?.obj
-b == obj?.obj.b
-b == obj?.obj?.obj
-b == obj[s]
-b > 0 != true
-b > 0 - 2
-b > 0 / a
-b > 0 || ok
-b > 0 || ok ? 0 : a
-b > 0.5 ? arr : div
-b > 0.5 ^ 2
-b > 0.5 || nil == "a"
-b > 0.5 || obj.head(1 .. s.obj)
-b > 1 * f
-b > 1 ? 0 : 0
-b > 1 ? false : f
-b > 1 and 2 <= b
-b > 2 != ok
-b > 2 ? "a" : false
-b > a
-b > a != false
-b > a != nil
-b > a * a
-b > a * f
-b > a ** 0
-b > a ** b
-b > a ** f
-b > a / 2
-b > a / obj?.b
-b > a ^ b
-b > a or 0.5 > 2
-b > a or a != 0
-b > a || f != 0
-b > a || obj?.fn(div, arr).obj
-b > a || ok
-b > abs(0.5)
-b > arr[0]
-b > arr[a]
-b > b
-b > b % a
-b > b * 0.5
-b > b * f
-b > b ** a
-b > b + f
-b > b - 0.5
-b > b - f
-b > b ? ok : ok
-b > b ? ok : s
-b > b ^ a
-b > b or obj?.head(a, 1)
-b > b || ok
-b > div(a, -b)
-b > div(b, a)
-b > f
-b > f != obj?.b
-b > f * a
-b > f / b
-b > f == obj.b
-b > f ? arr : div
-b > f ? b : s
-b > f ? f : "c"
-b > f ^ b
-b > f and not ok
-b > f or obj.obj
-b > float(b)
-b > float(f)
-b > int(0)
-b > len(obj)
-b > obj.a
-b > obj.b
-b > obj.fn(a)
-b > obj.head(f)
-b > obj.obj.b
-b > obj?.a
-b > obj?.b
-b > obj?.head(0)
-b > obj?.head(0.5, 0)
-b > obj?.obj.a
-b > obj?.obj?.b
-b >= -a
-b >= -b
-b >= -f
-b >= 0 != ok
-b >= 0 - b
-b >= 0 ? 0.5 : true
-b >= 0 ? add : arr
-b >= 0 ? s : "c"
-b >= 0 ^ 0.5
-b >= 0 and obj.head(s, f, arr, 0)
-b >= 0.5 == ok
-b >= 0.5 ? f : 0
-b >= 0.5 and obj.a
-b >= a
-b >= a - 0.5
-b >= a == nil
-b >= a ? obj.obj : add
-b >= a ^ f
-b >= a and 0.5 >= b
-b >= abs(1)
-b >= b
-b >= b % a
-b >= b % b
-b >= b && nil != arr
-b >= b ** 0
-b >= b ** obj.b
-b >= b + 0.5
-b >= b and obj.b
-b >= b in obj?.head(nil, 0.5)?.obj
-b >= b or obj.fn(b)?.a
-b >= b || f - obj?.obj
-b >= div(a, b)
-b >= div(b, a)
-b >= div(b, b)
-b >= f
-b >= f != false
-b >= f ** b
-b >= f ? 0.5 : s
-b >= f ? nil : false
-b >= f ^ 0.5
-b >= f ^ b
-b >= f || a == f
-b >= f || obj?.head(nil, s)
-b >= int(0) != obj?.obj
-b >= int(a)
-b >= last(arr)
-b >= min(b)
-b >= obj.a
-b >= obj.b
-b >= obj.head(a)
-b >= obj.head(f, arr, add)
-b >= obj.obj?.a
-b >= obj?.a
-b >= obj?.a + a
-b >= obj?.b
-b >= obj?.b and ok
-b >= obj?.fn(0)
-b >= obj?.fn(a)
-b >= obj?.fn(b)
-b >= obj?.head(f)
-b >= obj?.obj.a
-b ^ (0 * 1)
-b ^ (0.5 + 0)
-b ^ (0.5 + b)
-b ^ (0.5 - a)
-b ^ (1 - 0.5)
-b ^ (1 / 0)
-b ^ (a * b)
-b ^ (a - a)
-b ^ (a / a)
-b ^ (b * a)
-b ^ (b + 0)
-b ^ (b + 0.5)
-b ^ (b / 0)
-b ^ (b / b)
-b ^ (f * 0)
-b ^ (f * 0.5)
-b ^ (f + b)
-b ^ (f - b)
-b ^ (f / 0.5)
-b ^ -a
-b ^ -b
-b ^ 0 != count(arr, ok)
-b ^ 0 != f ? arr : obj
-b ^ 0 + f
-b ^ 0 / f / f
-b ^ 0 ^ b
-b ^ 0.5 * f
-b ^ 0.5 < f
-b ^ 0.5 <= f
-b ^ 0.5 > obj?.a
-b ^ 0.5 >= b
-b ^ 1 - f
-b ^ 1 == obj?.obj
-b ^ 1 > f - f
-b ^ 1 ^ b
-b ^ 2 < obj.b
-b ^ 2 <= a
-b ^ 2 > a
-b ^ 2 ^ f
-b ^ 2 ^ obj?.fn(0)
-b ^ a
-b ^ a ** (f / a)
-b ^ a ** a
-b ^ a + f
-b ^ a - b + a
-b ^ a - max(a)
-b ^ a - min(b)
-b ^ a <= arr[a]
-b ^ a <= f ? add : true
-b ^ a == b
-b ^ a == obj.obj
-b ^ a ^ f
-b ^ add(0, a)
-b ^ add(2, a)
-b ^ add(a, b)
-b ^ add(b, 2)
-b ^ b
-b ^ b < -0.5
-b ^ b < f
-b ^ b == 0 / 1
-b ^ b == a
-b ^ b == a + 0
-b ^ b > f
-b ^ count(arr, true)
-b ^ div(0, b)
-b ^ div(1, a)
-b ^ div(b, a)
-b ^ f
-b ^ f >= 0 ? b : b
-b ^ f ^ 0.5
-b ^ f ^ a
-b ^ f ^ b
-b ^ get(arr, b)
-b ^ int(f)
-b ^ len(arr)
-b ^ min(f)
-b ^ obj.a
-b ^ obj.b
-b ^ obj.head(1)
-b ^ obj.head(b)
-b ^ obj.obj?.a
-b ^ obj?.a
-b ^ obj?.b
-b ^ obj?.fn(2)
-b ^ obj?.head(0.5, div, a)
-b ^ obj?.head(a, a)
-b ^ obj?.head(b)
-b ^ obj?.obj.a
-b ^ obj?.obj?.a
-b ^ obj?.obj?.b
-b in arr
-b in arr && true ? obj : div
-b in arr == not ok
-b in arr == true
-b in arr || nil == obj
-b in arr[2:1]
-b in filter(arr, ok)
-b in map(arr, 0)
-b in obj.head(arr)
-b in obj.head(nil, b, arr, 0, 0.5)?.a
-b in obj[s]
-count([f], ok)
-count([nil, arr, ok], ok)
-count(a .. 0, obj.a)
-count(a .. 0, ok || ok)
-count(arr, "b" < s)
-count(arr, "b" <= "a")
-count(arr, "c" > s)
-count(arr, # != #)
-count(arr, # == f)
-count(arr, # >= a)
-count(arr, # >= add(b, 0))
-count(arr, 0 != a)
-count(arr, 0 != f)
-count(arr, 0 <= 0)
-count(arr, 0 <= 0.5)
-count(arr, 0 == a)
-count(arr, 0 > 0.5)
-count(arr, 0 > a)
-count(arr, 0 > f)
-count(arr, 0.5 == 0.5)
-count(arr, 0.5 > 0.5)
-count(arr, 0.5 >= 0.5)
-count(arr, 1 < f)
-count(arr, 1 == b)
-count(arr, 2 < a)
-count(arr, 2 >= f)
-count(arr, a <= b)
-count(arr, a == nil)
-count(arr, a >= 0.5)
-count(arr, a >= a)
-count(arr, add != div)
-count(arr, add == add)
-count(arr, all(arr, false))
-count(arr, any(arr, ok))
-count(arr, any(arr, true))
-count(arr, arr == nil)
-count(arr, b != b)
-count(arr, b <= 1)
-count(arr, b == 0)
-count(arr, b == b)
-count(arr, b > 1)
-count(arr, b >= 1)
-count(arr, b >= a)
-count(arr, b in arr)
-count(arr, f != nil)
-count(arr, f < b)
-count(arr, f > a)
-count(arr, false or false)
-count(arr, false) % b
-count(arr, false) + abs(0.5)
-count(arr, false) == a
-count(arr, false) == f
-count(arr, false) > f
-count(arr, false) >= f + 0
-count(arr, false) >= obj?.a
-count(arr, false) ^ f
-count(arr, false) in arr
-count(arr, nil != 0)
-count(arr, nil != arr)
-count(arr, nil != div)
-count(arr, nil == 0.5)
-count(arr, nil == a)
-count(arr, nil == s)
-count(arr, not false)
-count(arr, obj != obj)
-count(arr, obj.head(ok))
-count(arr, obj?.a == arr)
-count(arr, ok != ok)
-count(arr, ok or 0 > 0.5)
-count(arr, ok)
-count(arr, ok) != b ? "b" : a
-count(arr, ok) % add(0, b)
-count(arr, ok) ** a
-count(arr, ok) + b
-count(arr, ok) - int(a)
-count(arr, ok) / a
-count(arr, ok) < a
-count(arr, ok) == b
-count(arr, ok) > a
-count(arr, ok) > b
-count(arr, ok) > obj.a
-count(arr, ok) in arr
-count(arr, one(arr, false))
-count(arr, s != s)
-count(arr, s contains "c")
-count(arr, s endsWith "a")
-count(arr, true) * obj?.a
-count(arr, true) - b
-count(arr, true) <= a
-count(arr, true) == b
-count(arr, true) > a
-count(arr, true) >= arr[b]
-count(b .. a, a == 0)
-count(b .. a, obj?.head(ok, obj, f, ok, arr))
-count(b .. a, ok)
-count(b .. b, not false)
-count(b .. b, ok == false)
-count(false ? f : obj, not true)
-count(false ? true : obj, 2 <= 1)
-count(filter(arr, false), obj?.obj)
-count(keys(obj), b >= f)
-count(keys(obj), ok)
-count(map(arr, "b"), ok)
-count(map(arr, 0.5), ok)
-count(map(arr, a), ok)
-count(map(arr, add), ok)
-count(map(arr, arr), f == b)
-count(map(arr, arr), ok)
-count(map(arr, f), ok)
-count(map(arr, obj), 0 != b)
-count(map(arr, obj), f == f)
-count(map(arr, true), #)
-count(map(obj.obj, arr), ok)
-count(obj.head("b", arr, add), 0.5 == 0.5)
-count(obj.head(obj), nil == nil)
-count(obj.head(obj, obj, s), ok)
-count(obj.head(s), any(arr, false))
-count(obj.head(s, s, arr, add, obj), ok)
-count(obj.obj, 0 < 0)
-count(obj.obj, all(arr, false))
-count(obj.obj, b > 0)
-count(obj.obj, f != 0)
-count(obj.obj, nil == s)
-count(obj.obj, obj != nil)
-count(obj.obj, obj != obj)
-count(obj.obj, obj?.head(ok))
-count(obj.obj, ok)
-count(obj?.head("a", a), ok) != f
-count(obj?.head("c", a, obj), f == 0)
-count(obj?.head(s), ok)
-count(obj?.head(s, s), f <= a)
-count(obj?.obj, "c" >= "c")
-count(obj?.obj, 0 == nil)
-count(obj?.obj, a != nil)
-count(obj?.obj, a == 1)
-count(obj?.obj, f >= f)
-count(obj?.obj, none(arr, false))
-count(obj?.obj, obj.head(true))
-count(obj?.obj, obj?.head(false))
-count(obj?.obj, ok != true)
-count(obj?.obj, ok)
-count(values(obj), ok)
-count(values(obj), true and ok)
-date(s, s)
+add == div ? i32 : f64
+add == div or ok
+add == foo.Qux
+add == foo.String
+add == foo?.Qux
+add == foo?.String
+add == greet
+add == greet ? 1 : 1
+add == half
+add == nil && ok
+add == nil ? "foo" : list
+add == nil ? add : half
+add == nil ? add : score
+add == nil ? i32 : div
+add == nil ? score : i64
+add == nil || ok
+add == score
+add == score != true
+add == score and i32 >= 1
+add == score or 0.5 < 1
+add in [div]
+add not in [f64]
+add not in sort(array)
+add(1, 1) ** i
+add(1, 1) ^ i
+add(1, i) .. i64
+add(i, 1 - i32)
+add(i, abs(i))
+add(i, i)
+add(i, i64 % 1)
+add(i, min(i))
+add(min(1, 1), i32 * 1)
+add(score(i, i), i)
+all(1 .. i32, ok)
+all(array, !(# <= #))
+all(array, !false)
+all(array, !ok)
+all(array, !true or 0.5 < #)
+all(array, "bar" in foo)
+all(array, "bar" matches "bar")
+all(array, # != #)
+all(array, # != 1)
+all(array, # != f32)
+all(array, # != f64)
+all(array, # != i64)
+all(array, # != nil)
+all(array, # + # >= 0.5 + i)
+all(array, # < #)
+all(array, # < 0.5)
+all(array, # < 1)
+all(array, # <= #)
+all(array, # <= 0.5)
+all(array, # <= f64)
+all(array, # <= i)
+all(array, # == #)
+all(array, # == 0.5)
+all(array, # == i32)
+all(array, # == i64)
+all(array, # == nil)
+all(array, # > #)
+all(array, # > 0.5)
+all(array, # > 1)
+all(array, # > f32)
+all(array, # > f64)
+all(array, # > i)
+all(array, # > i64)
+all(array, # >= #)
+all(array, # >= 0.5)
+all(array, # >= f64)
+all(array, # >= i)
+all(array, # ^ # == i64)
+all(array, # in array)
+all(array, # not in array)
+all(array, 0.5 != #)
+all(array, 0.5 != f32)
+all(array, 0.5 + 0.5 >= #)
+all(array, 0.5 < #)
+all(array, 0.5 < 1)
+all(array, 0.5 < i64)
+all(array, 0.5 <= #)
+all(array, 0.5 == #)
+all(array, 0.5 == f32)
+all(array, 0.5 > #)
+all(array, 0.5 > 1)
+all(array, 0.5 >= #)
+all(array, 1 != #)
+all(array, 1 != i)
+all(array, 1 != i64)
+all(array, 1 != nil)
+all(array, 1 < #)
+all(array, 1 <= #)
+all(array, 1 == #)
+all(array, 1 > #)
+all(array, 1 in array)
+all(array, all(array, add != score))
+all(array, all(array, false))
+all(array, all(list, false))
+all(array, f32 >= #)
+all(array, f64 != #)
+all(array, f64 != i32)
+all(array, f64 < #)
+all(array, f64 <= #)
+all(array, f64 == #)
+all(array, f64 > #)
+all(array, false or ok)
+all(array, i != f32)
+all(array, i == #)
+all(array, i > #)
+all(array, i >= #)
+all(array, i32 != i64)
+all(array, i32 < #)
+all(array, i32 <= #)
+all(array, i32 <= i32)
+all(array, i32 > #)
+all(array, i32 >= 1 % #)
+all(array, i64 < #)
+all(array, i64 < 1)
+all(array, i64 < i64)
+all(array, i64 == #)
+all(array, i64 == 0.5)
+all(array, i64 > #)
+all(array, list != list)
+all(array, nil != #)
+all(array, nil != i)
+all(array, nil == "foo")
+all(array, nil == div)
+all(array, nil in list)
+all(array, not (nil in array))
+all(array, not false)
+all(array, not true)
+all(array, ok)
+all(array, one(array, ok))
+all(array, score == add)
+all(array, score(#) > f32)
+all(array, true || false)
+all(array, true) or ok
+all(false ? greet : "foo", # == i32)
+all(filter(array, ok), # < #)
+all(filter(array, true), ok)
+all(i32 .. 1, 0.5 < i32)
+all(i64 .. i64, # != #)
+all(list, !any(array, false))
+all(list, !false)
+all(list, !ok)
+all(list, "bar" not in #)
+all(list, "foo" >= "foo")
+all(list, # != #)
+all(list, # != foo)
+all(list, # == #)
+all(list, # == foo)
+all(list, 0.5 != f64)
+all(list, 0.5 != nil)
+all(list, 0.5 <= f64)
+all(list, 0.5 > 1)
+all(list, 1 != 0.5)
+all(list, 1 != i)
+all(list, 1 < f32)
+all(list, 1 < i)
+all(list, 1 <= 0.5)
+all(list, 1 == 1)
+all(list, 1 > f32)
+all(list, 1 >= i64)
+all(list, all(array, true))
+all(list, array != nil)
+all(list, div != div)
+all(list, f32 != 0.5)
+all(list, f32 == f64)
+all(list, f64 < 1)
+all(list, f64 <= 1)
+all(list, f64 <= i)
+all(list, f64 <= i32)
+all(list, f64 >= 1)
+all(list, false) or 0.5 <= 1
+all(list, foo != #)
+all(list, greet != half)
+all(list, greet == score)
+all(list, i <= i64)
+all(list, i32 != i64)
+all(list, i32 < i64)
+all(list, i32 <= 0.5)
+all(list, i32 <= f64)
+all(list, int(i32) != i32)
+all(list, list != nil)
+all(list, nil != 1)
+all(list, nil != foo)
+all(list, nil == #)
+all(list, nil == greet)
+all(list, nil in list)
+all(list, none(array, ok))
+all(list, not false)
+all(list, not ok)
+all(list, not true)
+all(list, ok and false)
+all(list, ok)
+all(list, ok) or ok
+all(list, true != false)
+all(list, true != true)
+all(list, true ? true : 1)
+all(list[i64:i32], !false)
+all(map(array, #), # != #)
+all(map(array, #), # != 0.5)
+all(map(array, #), # >= #)
+all(map(array, #), i64 == #)
+all(map(array, #), true or false)
+all(map(array, 1), ok)
+all(map(array, i), f64 > #)
+all(map(array, ok), #)
+all(map(list, "bar"), ok)
+all(map(list, #), "bar" not in #)
+all(map(list, #), f32 > 1)
+all(map(list, 1), ok)
+all(map(list, false), #)
+all(map(list, i64), # <= #)
+all(map(list, ok), #)
+all(map(list, true), # == #)
+all(map(list, true), #)
+all(map(list, true), ok)
+any([0.5, add, 0.5], # == #)
+any([1], i64 >= #)
+any(array, !false)
+any(array, "foo" <= "foo")
+any(array, # != #)
+any(array, # != 0.5)
+any(array, # != 1)
+any(array, # != i)
+any(array, # != i32)
+any(array, # != i64)
+any(array, # != nil)
+any(array, # < #)
+any(array, # < 0.5)
+any(array, # < 1)
+any(array, # < f32)
+any(array, # < f64)
+any(array, # < i)
+any(array, # < i32)
+any(array, # <= #)
+any(array, # <= 0.5)
+any(array, # <= 1 ^ #)
+any(array, # <= 1)
+any(array, # <= i)
+any(array, # <= i32)
+any(array, # == #)
+any(array, # == 1)
+any(array, # == f64)
+any(array, # == i)
+any(array, # == i32)
+any(array, # == i64)
+any(array, # == nil)
+any(array, # > #)
+any(array, # > 1)
+any(array, # > i32)
+any(array, # > i64)
+any(array, # >= #)
+any(array, # >= 0.5)
+any(array, # >= 1)
+any(array, # >= f64)
+any(array, # >= i)
+any(array, # >= i32)
+any(array, # in array)
+any(array, # not in array)
+any(array, 0.5 != #)
+any(array, 0.5 != f64)
+any(array, 0.5 != i)
+any(array, 0.5 < 0.5)
+any(array, 0.5 <= #)
+any(array, 0.5 == #)
+any(array, 0.5 == 0.5)
+any(array, 0.5 > #)
+any(array, 0.5 > f32)
+any(array, 1 < #)
+any(array, 1 <= i64)
+any(array, 1 == #)
+any(array, 1 > f64)
+any(array, 1 >= i)
+any(array, 1 >= i32)
+any(array, all(list, true))
+any(array, array == array)
+any(array, div != nil)
+any(array, f32 < #)
+any(array, f32 > #)
+any(array, f64 != #)
+any(array, f64 != 1)
+any(array, f64 < #)
+any(array, f64 <= 0.5)
+any(array, f64 <= f32)
+any(array, f64 == #)
+any(array, f64 > #)
+any(array, f64 > 0.5)
+any(array, f64 >= i64)
+any(array, false != nil)
+any(array, false) and f32 != f32
+any(array, greet != half)
+any(array, half != div)
+any(array, half != nil)
+any(array, i != 1)
+any(array, i < # ** #)
+any(array, i <= #)
+any(array, i == #)
+any(array, i == i)
+any(array, i > #)
+any(array, i >= #)
+any(array, i32 != #)
+any(array, i32 != i64)
+any(array, i32 <= #)
+any(array, i32 == #)
+any(array, i32 > #)
+any(array, i32 >= i64)
+any(array, i64 != #)
+any(array, i64 != i64)
+any(array, i64 <= 0.5)
+any(array, i64 == #)
+any(array, i64 > #)
+any(array, i64 > 1)
+any(array, i64 > f32)
+any(array, i64 >= i)
+any(array, nil != #)
+any(array, nil != f64)
+any(array, nil != greet)
+any(array, nil == #)
+any(array, nil == 1)
+any(array, not ok)
+any(array, not true)
+any(array, ok)
+any(array, one(list, false))
+any(array, true ? ok : f32)
+any(array, true) and ok
+any(filter(array, ok), ok)
+any(filter(list, false), ok)
+any(filter(list, true), # == #)
+any(list, !true)
+any(list, "bar" contains "foo")
+any(list, "bar" matches "foo")
+any(list, "bar" not in #)
+any(list, "bar" not startsWith "foo")
+any(list, # != #)
+any(list, # != foo)
+any(list, # != nil)
+any(list, # == #)
+any(list, # == nil)
+any(list, # in list)
+any(list, # not in list)
+any(list, 0.5 < 1)
+any(list, 0.5 <= f32)
+any(list, 0.5 == 0.5)
+any(list, 0.5 >= 0.5)
+any(list, 0.5 >= f32)
+any(list, 0.5 >= i64)
+any(list, 1 <= 0.5)
+any(list, 1 == f32)
+any(list, f32 != i)
+any(list, f32 == nil)
+any(list, f32 >= i)
+any(list, f64 <= 1)
+any(list, f64 > 0.5)
+any(list, false ? nil : false)
+any(list, foo == foo)
+any(list, greet == div)
+any(list, half != nil)
+any(list, i != 1)
+any(list, i < f32)
+any(list, i < f64)
+any(list, i > i64)
+any(list, i32 != i32)
+any(list, i32 < 0.5)
+any(list, i32 == f64)
+any(list, i64 < 1)
+any(list, i64 < f64)
+any(list, i64 < i64)
+any(list, i64 <= i32)
+any(list, i64 >= 1)
+any(list, i64 >= f32)
+any(list, list != nil)
+any(list, nil != #)
+any(list, nil != #?.String())
+any(list, nil != nil)
+any(list, nil == #)
+any(list, nil == 1)
+any(list, nil == i64)
+any(list, nil == nil)
+any(list, not false)
+any(list, not ok)
+any(list, ok and foo != #)
+any(list, ok)
+any(list, ok) && i <= 1
+any(list, ok) ? array : foo
+any(list, true or ok)
+any(list, true) ? f64 : foo.Bar
+any(map(array, #), # == #)
+any(map(array, #), ok)
+any(map(array, 0.5), # <= #)
+any(map(array, f64), # < #)
+any(map(array, false), #)
+any(map(array, ok), #)
+any(map(list, #), i == f64)
+any(map(list, #), ok)
+any(map(list, 1), # != #)
+any(map(list, array), ok)
+any(map(list, foo), # != #)
+any(map(list, greet), # == #)
+any(ok ? "bar" : half, ok)
+any(splitAfter("bar", "foo"), # not startsWith #)
+array
+array != [array]
+array != array
+array != filter(list, true)
+array != list
+array != map(array, i)
+array != nil != ok
+array != nil ? 0.5 : i32
+array != nil ? true : nil
+array != nil or nil == f32
+array != nil || ok
+array != sort(array)
+array != {"bar": f32, "foo": 1}.ok
+array == array
+array == array ? "foo" : 0.5
+array == list
+array == list ? i : half
+array == map(array, #)
+array == map(array, add)
+array == nil != nil
+array == nil != true ? 0.5 : 0.5
+array == nil && (false || ok)
+array in [i]
+array[-1]
+array[-i32]
+array[-i64]
+array[-i]
+array[1 % 1]
+array[1 % i:i64]
+array[1] != f32
+array[1] != score(i)
+array[1] <= f64
+array[1] == f32
+array[1] == i64
+array[1] ^ 0.5 ^ f64
+array[1] ^ i32
+array[false ? half : 0.5]
+array[false ? i : i32]
+array[i - i64]
+array[i32:i32]
+array[i32]
+array[i32] - f64
+array[i32] .. i32
+array[i64 % 1]
+array[i64:i32]
+array[i64:i]
+array[i64]
+array[i64] ** f32
+array[i64] / i
+array[i64] < i
+array[i64] == f64
+array[i64] > f32
+array[i64] >= -i64
+array[i:i64]
+array[i:i]
+array[i]
+array[i] ** i64
+array[i] + f32
+array[i] < i
+array[i] == min(i32, i)
+array[i] > i32
+array[int(1)]
+array[int(i32)]
+array[max(i64)]
+array[min(1)]
+array[min(i32)]
+array[min(i64)]
+array[score(1)]
+array[score(i)]
+count([list], false or ok)
+count(array, !ok)
+count(array, "bar" != "bar")
+count(array, "bar" not endsWith "bar")
+count(array, # != #)
+count(array, # != f32)
+count(array, # != i32)
+count(array, # < #)
+count(array, # < 0.5)
+count(array, # < 1)
+count(array, # < f32)
+count(array, # < f64)
+count(array, # < i)
+count(array, # < i64)
+count(array, # <= #)
+count(array, # <= 0.5)
+count(array, # <= f32)
+count(array, # <= f64)
+count(array, # <= i)
+count(array, # <= i32)
+count(array, # == #)
+count(array, # == 1)
+count(array, # == f32)
+count(array, # == i)
+count(array, # == i64)
+count(array, # == nil)
+count(array, # > #)
+count(array, # > 0.5)
+count(array, # > i)
+count(array, # > i64)
+count(array, # >= # / #)
+count(array, # >= #)
+count(array, # >= 0.5)
+count(array, # >= 1)
+count(array, # >= f64)
+count(array, # >= i)
+count(array, # >= i64)
+count(array, 0.5 != #)
+count(array, 0.5 <= #)
+count(array, 0.5 == #)
+count(array, 0.5 > #)
+count(array, 0.5 > 1)
+count(array, 0.5 >= #)
+count(array, 0.5 >= 0.5)
+count(array, 0.5 >= i)
+count(array, 1 != #)
+count(array, 1 < #)
+count(array, 1 < 0.5)
+count(array, 1 < 1)
+count(array, 1 <= #)
+count(array, 1 > #)
+count(array, 1 >= #)
+count(array, add == half)
+count(array, f32 != i)
+count(array, f32 < # ? true : half)
+count(array, f32 < #)
+count(array, f32 < 0.5)
+count(array, f32 <= #)
+count(array, f32 <= 1)
+count(array, f32 <= i)
+count(array, f32 == #)
+count(array, f32 == 1)
+count(array, f64 != #)
+count(array, f64 < #)
+count(array, f64 <= #)
+count(array, f64 == #)
+count(array, f64 > #)
+count(array, false == true)
+count(array, false) != f64
+count(array, false) / i
+count(array, false) >= f32
+count(array, foo not in list)
+count(array, greet != greet)
+count(array, greet == score)
+count(array, i != f32)
+count(array, i == nil)
+count(array, i > #)
+count(array, i >= #)
+count(array, i32 != 1)
+count(array, i32 < #)
+count(array, i32 < 0.5)
+count(array, i32 == #)
+count(array, i32 > i)
+count(array, i32 >= #)
+count(array, i32 >= 1)
+count(array, i64 != #)
+count(array, i64 < #)
+count(array, i64 <= 1)
+count(array, i64 <= f64)
+count(array, i64 == #)
+count(array, i64 == i64)
+count(array, i64 > 1)
+count(array, i64 > f32)
+count(array, nil != #)
+count(array, nil == #)
+count(array, nil == foo)
+count(array, not ok)
+count(array, ok)
+count(array, ok) + i64
+count(array, ok) - i64
+count(array, ok) .. i64
+count(array, one(array, false))
+count(array, true ? false : 0.5)
+count(array, true) != 1 ^ f32
+count(array, true) ** f32
+count(array, true) / int(0.5)
+count(array, true) >= f64 / 0.5
+count(filter(list, false), ok)
+count(i .. 1, # > #)
+count(i .. i32, # > #)
+count(i32 .. 1, # == #)
+count(i64 .. i, div == nil)
+count(i64 .. i, ok)
+count(list, !false)
+count(list, !ok)
+count(list, "bar" == "bar")
+count(list, "bar" in #)
+count(list, "bar" matches "foo")
+count(list, "bar" not in #)
+count(list, "foo" in #)
+count(list, "foo" not in #)
+count(list, # != #)
+count(list, # != nil)
+count(list, # == #)
+count(list, # == nil)
+count(list, 0.5 == f32)
+count(list, 0.5 > 0.5)
+count(list, 0.5 >= i32)
+count(list, 1 != 1)
+count(list, 1 != f32)
+count(list, 1 < 0.5)
+count(list, 1 <= i)
+count(list, 1 >= f32)
+count(list, 1 >= i32)
+count(list, all(list, true))
+count(list, f32 <= i32)
+count(list, f64 != i)
+count(list, false ? # : ok)
+count(list, false or ok)
+count(list, false || false)
+count(list, false) .. i32
+count(list, false) > i64
+count(list, foo != #)
+count(list, half == div)
+count(list, i == i64)
+count(list, i32 == i)
+count(list, i32 == i32)
+count(list, list == array)
+count(list, nil != #)
+count(list, nil != score)
+count(list, nil == #)
+count(list, nil == add)
+count(list, nil == true)
+count(list, none(list, ok))
+count(list, not false)
+count(list, not ok)
+count(list, not true)
+count(list, ok == nil)
+count(list, ok)
+count(list, ok) - i32
+count(list, ok) < f64
+count(list, ok) > -0.5
+count(list, ok) >= i
+count(list, true and ok)
+count(list, true) ** i64
+count(list, true) == f64
+count(list, true) ^ i64
+count(map(array, #), # != #)
+count(map(array, #), # > #)
+count(map(array, #), i == #)
+count(map(array, #), ok)
+count(map(array, add), ok)
+count(map(array, div), ok)
+count(map(array, foo), ok)
+count(map(array, i32), 0.5 == f32)
+count(map(array, i32), 1 != #)
+count(map(array, i64), # == 0.5)
+count(map(array, true), #)
+count(map(list, #), "bar" in #)
+count(map(list, #), # == #)
+count(map(list, #), # == nil)
+count(map(list, 0.5), # != nil)
+count(map(list, f32), # <= #)
+count(map(list, true), #)
+count(sort(array), foo == #)
+count(sort(array), ok)
+date("bar", "bar")?.String
 div
 div != add
-div != add != true
-div != add ? 0.5 : ok
-div != add and 1 == f
-div != add or ok
+div != add != ok
 div != div
-div != div ? arr : b
-div != div ? false : false
-div != div and 0 >= 2
-div != div or obj?.a
-div != nil && obj.b
-div != nil == ok ? s : 0
-div != nil == true
-div != nil ? s : obj
-div != nil ? s : ok
-div != nil || obj?.obj
-div != obj.a
-div != obj.b
-div != obj.fn(a)
-div != obj.fn(b)
-div != obj.head(a)
-div != obj.head(div)
-div != obj.head(div, "b")
-div != obj.head(f, arr)
-div != obj.head(obj)
-div != obj.head(ok)
-div != obj.obj
-div != obj.obj.obj
-div != obj.obj?.a
-div != obj.obj?.obj
-div != obj?.a
-div != obj?.b
-div != obj?.head(add)
-div != obj?.head(arr)
-div != obj?.head(b, "a")
-div != obj?.head(div)
-div != obj?.head(f)
-div != obj?.head(s)
-div != obj?.head(s, arr, 1, true)
-div != obj?.obj
-div != obj?.obj.obj
-div != obj?.obj?.obj
+div != div ? score : 0.5
+div != div or half != greet
+div != foo.Qux
+div != foo.String
+div != foo?.Qux
+div != greet
+div != half
+div != half ? f32 : ok
+div != half and !ok
+div != nil != ok
+div != nil ? array : add
+div != nil ? i : i64
+div != score
 div == add
-div == add != obj?.obj
-div == add != ok
-div == add ? 0 : ok
-div == add or ok
 div == div
-div == div != obj.b
-div == div != obj?.b
-div == div != ok
-div == div == ok
-div == div ? 1 / f : obj
-div == div ? obj : div
-div == get(obj, s)
-div == nil ? "a" : "c"
-div == nil ? 0 : b
-div == nil ? a : true
-div == nil ? ok : arr
-div == nil or obj.obj
-div == nil or obj?.a
-div == nil || ok ? obj : true
-div == obj.a
-div == obj.b
-div == obj.head(a, b)
-div == obj.head(arr, nil, false, obj)
-div == obj.head(f)
-div == obj.head(f, a, nil)
-div == obj.head(obj)
-div == obj.head(ok)
-div == obj.head(true, obj)
-div == obj.obj
-div == obj.obj?.b
-div == obj?.a
-div == obj?.b
-div == obj?.head(arr)
-div == obj?.head(b)
-div == obj?.head(obj)
-div == obj?.head(ok)
-div == obj?.head(s)
-div == obj?.obj
-div == obj?.obj.a
-div == obj?.obj?.b
-div in map(arr, add)
-div in obj?.head(nil)
-div in obj[s]?.b
-div(-1, b)
-div(-a, a)
-div(-a, get(arr, 2))
-div(-a, obj.b)
-div(-b, a + 2)
-div(-b, a)
-div(-b, b)
-div(-obj.head(a, s), b)
-div(0 * a, a)
-div(0 * obj.b, a)
-div(0 - a, a)
-div(0, 1) != count(arr, false)
-div(0, 1) % b
-div(0, 1) + b ^ f
-div(0, 1) - b
-div(0, 2) ** b
-div(0, 2) < b
-div(0, 2) > obj.a
-div(0, 2) >= abs(0.5)
-div(0, a) != f
-div(0, a) * b
-div(0, a) .. obj.fn(b)
-div(0, a) < b
-div(0, a) <= b
-div(0, a) ^ a
-div(0, a) ^ f
-div(0, a) in arr
-div(0, b) != b
-div(0, b) + b
-div(0, b) + obj.a
-div(0, b) + obj?.a
-div(0, b) < a
-div(0, b) > b
-div(0, b) >= b
-div(1 - b, a)
-div(1, 2) % a
-div(1, 2) * f ** b
-div(1, 2) / -2
-div(1, 2) >= f
-div(1, a) ** b
-div(1, a) - b
-div(1, a) / obj?.a
-div(1, a) < a ? s : ok
-div(1, b) - obj.a
-div(1, b) - obj?.a
-div(1, b) > b
-div(2 % 1, min(1))
-div(2 * 0, a)
-div(2 * 2, obj?.b)
-div(2 + b, b)
-div(2, 2) * a
-div(2, a) + 1 ** 1
-div(2, a) == b ? obj : 0
-div(2, a) > obj?.a
-div(2, b) != obj?.obj
-div(2, b) % a
-div(2, b) ** a
-div(2, b) - b
-div(2, b) / a
-div(a % a, a)
-div(a % a, obj.b)
-div(a * 0, b)
-div(a * 2, b)
-div(a * b, obj.b)
-div(a * b, obj?.b)
-div(a - 1, b)
-div(a - 2, b)
-div(a - b, get(arr, 0))
-div(a, -2)
-div(a, -a)
-div(a, 0 + a)
-div(a, 1) % a
-div(a, 1) ** obj.a
-div(a, 1) - a
-div(a, 1) < b
-div(a, 1) < obj?.a
-div(a, 1) <= obj.b
-div(a, 1) == a
-div(a, 1) >= a * b
-div(a, 2) ** a
-div(a, 2) + obj.b
-div(a, 2) < a
-div(a, 2) <= f ? s : s
-div(a, 2) <= obj.b
-div(a, 2) == b
-div(a, 2) > obj.b
-div(a, 2) ^ obj?.a
-div(a, a * a)
-div(a, a - 0)
-div(a, a)
-div(a, a) != 0 ? a : add
-div(a, a) != obj?.b
-div(a, a) % b
-div(a, a) * obj?.b
-div(a, a) ** b
-div(a, a) - f
-div(a, a) .. b
-div(a, a) / get(arr, 0)
-div(a, a) <= 2 ? b : "b"
-div(a, a) == b
-div(a, a) > 0 ? div : s
-div(a, a) > a
-div(a, a) > f
-div(a, a) >= a
-div(a, a) >= b
-div(a, a) ^ -f
-div(a, a) ^ f
-div(a, abs(b))
-div(a, add(0, b))
-div(a, add(2, 0))
-div(a, add(a, 0))
-div(a, add(a, b))
-div(a, add(b, 0))
-div(a, b + 0)
-div(a, b)
-div(a, b) % a
-div(a, b) % b
-div(a, b) ** (a % 1)
-div(a, b) ** a
-div(a, b) ** f
-div(a, b) + div(a, b)
-div(a, b) + f ^ a
-div(a, b) .. a
-div(a, b) / a
-div(a, b) < obj?.a
-div(a, b) <= b
-div(a, b) ^ get(arr, a)
-div(a, div(a, 1))
-div(a, div(a, a))
-div(a, div(b, 1))
-div(a, div(b, b))
-div(a, false ? b : a)
-div(a, get(arr, a))
-div(a, get(arr, b))
-div(a, int(1))
-div(a, int(a))
-div(a, last(arr))
-div(a, len(s))
-div(a, max(2))
-div(a, min(a))
-div(a, obj.a)
-div(a, obj.b)
-div(a, obj.fn(0))
-div(a, obj.fn(b))
-div(a, obj.head(1, obj))
-div(a, obj.obj?.a)
-div(a, obj.obj?.b)
-div(a, obj?.a)
-div(a, obj?.b)
-div(a, obj?.head(b))
-div(a, true ? 2 : div)
-div(abs(a), b)
-div(abs(b), a)
-div(add(0, a), b)
-div(add(2, a), a)
-div(add(2, a), b)
-div(add(a, 0), max(a)) == a
-div(add(a, a), obj.b)
-div(add(a, b), -2)
-div(add(b, 0), a)
-div(add(b, b), obj?.b)
-div(arr[1], a * b)
-div(arr[b], div(b, b))
-div(b % a, a)
-div(b % a, obj.a)
-div(b % b, a)
-div(b % b, b)
-div(b * 0, obj.a)
-div(b * a, a)
-div(b * a, obj?.b)
-div(b, -a)
-div(b, 1) % obj.b
-div(b, 1) * max(a)
-div(b, 1) / a
-div(b, 1) >= 0 ^ f
-div(b, 2 * b)
-div(b, 2) ** add(b, a)
-div(b, 2) ** f
-div(b, 2) ** f ** 1
-div(b, 2) + float(0)
-div(b, 2) > b
-div(b, 2) in arr
-div(b, a + 0)
-div(b, a)
-div(b, a) != a + 0.5
-div(b, a) != obj?.a
-div(b, a) % b
-div(b, a) * 0 / b
-div(b, a) + a
-div(b, a) - f
-div(b, a) < a ^ f
-div(b, a) < obj.obj.obj.b
-div(b, a) <= a
-div(b, a) == obj?.obj
-div(b, a) > a
-div(b, a) >= 0 ? add : "a"
-div(b, a) >= obj.b
-div(b, a) ^ a
-div(b, a) in arr
-div(b, add(0, a))
-div(b, add(b, 2))
-div(b, b * a)
-div(b, b * b)
-div(b, b)
-div(b, b) != b
-div(b, b) != obj?.obj
-div(b, b) * -b
-div(b, b) ** a
-div(b, b) ** obj?.a
-div(b, b) + obj.b
-div(b, b) / a
-div(b, b) / obj?.a
-div(b, b) < f
-div(b, b) <= b
-div(b, b) <= b != nil
-div(b, b) == a
-div(b, b) == f
-div(b, b) > obj.a
-div(b, b) ^ -f
-div(b, b) ^ a
-div(b, div(b, a))
-div(b, get(arr, 0))
-div(b, int(a))
-div(b, last(arr))
-div(b, obj.a)
-div(b, obj.b)
-div(b, obj.fn(a))
-div(b, obj.head(a))
-div(b, obj.head(a, nil))
-div(b, obj.head(b))
-div(b, obj?.a)
-div(b, obj?.b)
-div(b, obj?.head(a))
-div(b, obj?.head(get(arr, 0)))
-div(b, ok ? b : s)
-div(count(arr, false), b)
-div(count(arr, ok), a)
-div(count(arr, ok), b)
-div(div(2, a), a)
-div(div(a, 2), a)
-div(div(a, a), b)
-div(div(b, b), add(b, 2))
-div(false ? arr : a, a)
-div(first(arr), b)
-div(first(arr), obj.b)
-div(get(arr, 0), b)
-div(get(arr, 2), obj.a)
-div(get(arr, a), a)
-div(get(arr, b), b)
-div(int(1 - f), b)
-div(int(b), a)
-div(int(b), obj.b)
-div(int(obj.a), b)
-div(last(arr), a)
-div(last(arr), b)
-div(len(obj), a)
-div(len(obj), obj.a)
-div(len(obj), obj.fn(a))
-div(len(s), max(2, a))
-div(max(1), b)
-div(max(b), b)
-div(max(b), obj.b)
-div(min(1), b)
-div(min(2), a)
-div(min(a), b)
-div(obj.a, -2)
-div(obj.a, a)
-div(obj.a, add(b, 1))
-div(obj.a, b)
-div(obj.a, obj.b)
-div(obj.a, obj?.a)
-div(obj.a, obj?.b)
-div(obj.b, a + 0)
-div(obj.b, a)
-div(obj.b, add(b, b))
-div(obj.b, b)
-div(obj.b, len("c"))
-div(obj.b, obj.b)
-div(obj.b, obj.head(2))
-div(obj.b, obj?.a)
-div(obj.b, obj?.b)
-div(obj.fn(2), a)
-div(obj.fn(a), b)
-div(obj.fn(b), 0 - a)
-div(obj.fn(b), b)
-div(obj.head(0, nil), b)
-div(obj.head(1), b)
-div(obj.head(a, arr), b + b)
-div(obj?.a, 1 * a)
-div(obj?.a, a)
-div(obj?.a, add(a, b))
-div(obj?.a, b)
-div(obj?.a, div(b, a))
-div(obj?.a, int(2))
-div(obj?.a, obj.a)
-div(obj?.a, obj.fn(2))
-div(obj?.a, obj?.a)
-div(obj?.a, obj?.b)
-div(obj?.b, -b)
-div(obj?.b, a)
-div(obj?.b, add(b, 0))
-div(obj?.b, b * 2)
-div(obj?.b, b * a)
-div(obj?.b, b)
-div(obj?.b, div(b, 1))
-div(obj?.b, obj.a)
-div(obj?.b, obj.b)
-div(obj?.b, obj.head(a, div, nil, nil, nil))
-div(obj?.b, obj?.a)
-div(obj?.b, obj?.b)
-div(obj?.fn(0), obj.a)
-div(obj?.fn(a), int(1))
-div(obj?.head(0), obj?.a)
-div(obj?.head(0, 0), a)
-div(obj?.head(0, add), b * a)
-div(obj?.head(0, b, a, f), obj.head(a))
-div(obj?.head(2), b)
-div(obj?.head(a), a)
-div(obj?.head(a, a, f, b), b)
-div(obj?.head(b, 2), get(arr, b))
-div(obj?.head(b, add, "c", 0.5), len(arr))
-div(obj?.head(b, b), obj?.a)
-div(ok ? 1 : a, a)
-div(true ? a : f, 0 + b)
-div(true ? b : 0.5, b)
-duration(string(0))
-duration(toJSON(0))
-f
-f != -0.5
-f != 0 % b
-f != 0 ? 1 : b
-f != 0 || obj?.b
-f != 0.5 ? arr : a
-f != 0.5 ? obj.b : arr
-f != 0.5 ^ a
-f != 0.5 and obj.head(div(add)).fn(add(obj && b, div(f), none(0.5, f), div(true, obj, true))?.head(s, arr))
-f != 0.5 and obj?.obj
-f != 1 * b
-f != 1 / 1
-f != 1 == ok
-f != 1 ? 0.5 : a
-f != 1 ? arr : "b"
-f != 2 != true
-f != 2 % b
-f != 2 / 0
-f != 2 / a
-f != 2 ^ 0
-f != a
-f != a != not ok
-f != a && ok
-f != a ** 0
-f != a - 0.5
-f != a - 2
-f != a / f
-f != a == nil
-f != a ? add : 0
-f != a ? obj : arr
-f != a ? obj.head(0.5, b, 0, obj, 0) : arr
-f != a and obj?.a
-f != abs(b)
-f != add(2, b)
-f != arr[0]
-f != arr[b]
-f != b
-f != b != obj.head(div)
-f != b % 2
-f != b % a
-f != b && obj.b
-f != b && s != "b"
-f != b ** b
-f != b + 0
-f != b ? b : false
-f != b ^ 0
-f != b ^ f
-f != b and ok ? 0 : nil
-f != b or b >= f
-f != b or obj.b.head(get(nil, add).b)?.obj
-f != f
-f != f && obj.obj
-f != f - 0
-f != f / b
-f != f ? a : s
-f != f ? s : "c"
-f != f ^ 0.5
-f != f and f >= f
-f != f || b <= a
-f != f || obj?.head("b")
-f != f || ok ? arr : 0
-f != get(arr, 0)
-f != get(arr, b)
-f != indexOf("a", s)
-f != int(a)
-f != max(0, f)
-f != nil != obj.b
-f != nil != ok
-f != nil == ok
-f != nil ? div : s
-f != nil and obj.obj
-f != obj.a
-f != obj.b
-f != obj.fn(b)
-f != obj.head("a", false)
-f != obj.head(0.5)
-f != obj.head(0.5, div)
-f != obj.head(1)
-f != obj.head(b, ok, false)
-f != obj.head(div, false, f, b)
-f != obj.head(ok)
-f != obj.obj
-f != obj.obj || ok
-f != obj.obj.a
-f != obj?.a
-f != obj?.b
-f != obj?.fn(a)
-f != obj?.head(0)
-f != obj?.head(a, "b", 0)
-f != obj?.head(arr, div, 0, div, 0)
-f != obj?.head(b)
-f != obj?.head(div)
-f != obj?.head(f, nil, f)
-f != obj?.head(false)
-f != obj?.head(get(obj, ok))
-f != obj?.head(nil)
-f != obj?.head(nil, add, f)
-f != obj?.head(nil, s)?.b
-f != obj?.head(obj?.obj)
-f != obj?.head(s)
-f != obj?.obj
-f != obj?.obj.obj
-f != obj?.obj?.a
-f * (0.5 - a)
-f * (a + 0)
-f * (b + b)
-f * (b - f)
-f * -(a + b)
-f * -0.5
-f * -f
-f * -obj?.b
-f * 0 ** 0
-f * 0 ** 1
-f * 0 == b ? div : f
-f * 0 >= obj.head(0, add, div)
-f * 0.5 != a
-f * 0.5 != f
-f * 0.5 * 2
-f * 0.5 / 1
-f * 0.5 / b
-f * 0.5 >= f ^ 0
-f * 0.5 ^ 0.5
-f * 1 * a
-f * 1 == b
-f * 2 - f * 0.5
-f * 2 >= a + a
-f * a
-f * a != obj?.b
-f * a + f
-f * a / (0 + f)
-f * a / (f + b)
-f * a / b
-f * a / f
-f * a / obj.fn(b)
-f * a < a
-f * a <= -0
-f * a == obj?.b
-f * a > a
-f * a ^ b
-f * abs(b)
-f * add(a, 0)
-f * arr[0]
-f * arr[a]
-f * b
-f * b != 0 + a
-f * b * f
-f * b / -a
-f * b / 0.5
-f * b / b ** b
-f * b == f
-f * b ^ 0
-f * f
-f * f != a
-f * f != b
-f * f != obj.a
-f * f + 0 ^ 0
-f * f == b
-f * f ^ a
-f * get(arr, a)
-f * int(0)
-f * int(f)
-f * min(0)
-f * obj.a
-f * obj.a < b
-f * obj.b
-f * obj.fn(a)
-f * obj.head(f)
-f * obj.obj.b
-f * obj.obj?.b
-f * obj?.a
-f * obj?.a ^ f
-f * obj?.b
-f * obj?.fn(0)
-f * obj?.head(0, a)
-f * obj?.obj.b
-f * obj?.obj?.a
-f ** (0 % a)
-f ** (0 % b)
-f ** (0.5 + f)
-f ** (0.5 / b)
-f ** (2 + a)
-f ** (2 + f)
-f ** (2 - f)
-f ** (2 / 0)
-f ** (2 / f)
-f ** (a * 0)
-f ** (a * 2)
-f ** (a * b)
-f ** (a + a)
-f ** (a - a)
-f ** (a - f)
-f ** (a / b)
-f ** (b * a)
-f ** (b + 1)
-f ** (b + b)
-f ** (b - a)
-f ** (b / 0)
-f ** (f * 0)
-f ** (f * f)
-f ** -0.5
-f ** 0 != f
-f ** 0 * obj?.a
-f ** 0 + obj?.head(b, add)
-f ** 0 / obj?.b
-f ** 0 < 0 * 0
-f ** 0 < f
-f ** 0 >= b
-f ** 0.5 != f
-f ** 0.5 - b
-f ** 0.5 / obj.fn(b)
-f ** 0.5 >= b
-f ** 0.5 ^ a
-f ** 1 != a
-f ** 1 / min(f)
-f ** 1 <= b
-f ** 2 * a
-f ** 2 ** 0
-f ** 2 - b
-f ** 2 ^ obj?.a
-f ** a
-f ** a ** 0 ** f
-f ** a < a / f
-f ** a <= b
-f ** a <= max(f)
-f ** a > obj.b
-f ** a >= b
-f ** a ^ b
-f ** add(1, a)
-f ** arr[0]
-f ** arr[add(1, a)]
-f ** arr[obj.a]
-f ** arr[obj?.head(b)]
-f ** b
-f ** b != 1 ** 2
-f ** b ** a
-f ** b ** f
-f ** b ** obj?.fn(b)
-f ** b + a / f
-f ** b / f
-f ** b < float(f)
-f ** b <= b
-f ** b <= f
-f ** b > b
-f ** f
-f ** f != b / 0
-f ** f - f
-f ** f > b
-f ** f >= a
-f ** f ^ 1
-f ** get(arr, a)
-f ** int(f)
-f ** len(arr) <= a
-f ** max(b, 1)
-f ** min(a)
-f ** obj.a
-f ** obj.b
-f ** obj.head(0)
-f ** obj.head(add(0, b))
-f ** obj.obj.b
-f ** obj?.a
-f ** obj?.b
-f ** obj?.fn(a)
-f ** obj?.head(2, s)
-f ** obj?.head(a)
-f ** obj?.head(b, add, obj)
-f ** obj?.obj.a
-f + -0.5
-f + -f
-f + 0 + a
-f + 0 - b
-f + 0 < a
-f + 0 == a
-f + 0 == add(b, b)
-f + 0.5 * b
-f + 0.5 - b
-f + 0.5 <= a
-f + 0.5 ^ 1
-f + 1 ** b
-f + 1 - f
-f + 1 >= obj?.b
-f + 2 < obj.b
-f + 2 == b
-f + 2 >= max(b)
-f + a
-f + a != last(arr)
-f + a * 2
-f + a + 2
-f + a / 0
-f + a >= obj?.a
-f + a ^ a
-f + a ^ f
-f + add(b, 2)
-f + add(b, a)
-f + b
-f + b != a
-f + b ** 2
-f + b ** b
-f + b + 2
-f + b + b
-f + b - a
-f + b - f
-f + b ^ 2
-f + count(arr, false)
-f + div(2, 1)
-f + div(b, a)
-f + div(b, b)
-f + f
-f + f != f
-f + f + 1
-f + f + a
-f + f + a ** 0
-f + f - b
-f + f / 2
-f + f / a
-f + f < f
-f + f > b
-f + float(0)
-f + get(arr, a)
-f + int(b)
-f + len("a")
-f + min(0.5)
-f + obj.a
-f + obj.b
-f + obj.head(0.5)
-f + obj.head(f)
-f + obj.obj.obj.b
-f + obj.obj?.a
-f + obj?.a
-f + obj?.b
-f + obj?.b .. a
-f + obj?.fn(0)
-f + obj?.fn(b)
-f + obj?.obj.a
-f + obj?.obj?.a
-f - -f
-f - 0 != a
-f - 0 * a
-f - 0 ** a
-f - 0 + a
-f - 0 - 2
-f - 0 >= a % a
-f - 0.5 != b
-f - 0.5 ** b
-f - 1 - a
-f - 1 == 0 ? arr : f
-f - 1 > obj?.b
-f - 2 + 1
-f - 2 >= f
-f - a
-f - a % a
-f - a + 0
-f - a + b
-f - a - a
-f - a < b
-f - a < obj.fn(b)
-f - a < obj?.b
-f - a > b ** a
-f - a >= b
-f - add(b, b)
-f - arr[1]
-f - arr[b]
-f - arr[obj?.a]
-f - b
-f - b != b
-f - b * f
-f - b + f
-f - b + obj.head(b)
-f - b - b
-f - b / a
-f - b / b
-f - b < 0 ? 1 : 0
-f - b <= abs(a)
-f - b <= b - 0.5
-f - b == obj.obj
-f - b > f
-f - b >= a ? div : ok
-f - b >= f
-f - div(a, b)
-f - f
-f - f + a
-f - f - div(a, b)
-f - f / 2
-f - f / b
-f - f < a
-f - f <= obj.a
-f - f == b
-f - f == div(0, a)
-f - float(1)
-f - float(f)
-f - get(arr, b)
-f - int(0)
-f - int(2)
-f - obj.a
-f - obj.b
-f - obj.head(b)
-f - obj.obj.a
-f - obj.obj.obj.a
-f - obj.obj?.b
-f - obj?.a
-f - obj?.b
-f - obj?.head(f)
-f - obj?.head(f, a, add)
-f - obj?.obj.b
-f / (0 - f)
-f / (0.5 + b)
-f / (1 + 2)
-f / (2 + 0)
-f / (a + b)
-f / (a + f)
-f / (b + f)
-f / (b - f)
-f / (f - a)
-f / -a
-f / -b
-f / -f
-f / 0 * 0
-f / 0 * f
-f / 0 + obj?.b
-f / 0 / a
-f / 0.5 != b
-f / 0.5 * obj?.a
-f / 0.5 - a
-f / 0.5 - b
-f / 0.5 == obj?.b
-f / 1 != obj?.obj?.a
-f / 1 / b
-f / 2 != nil ? 0.5 : 0
-f / 2 / obj?.b
-f / 2 == obj?.b
-f / 2 >= f
-f / a
-f / a != a
-f / a != b - 1
-f / a != obj.b
-f / a != obj?.b
-f / a ** 0
-f / a - f
-f / a < 2 ** f
-f / a <= b
-f / a == a
-f / a == b
-f / a >= b ^ a
-f / a >= obj?.b
-f / add(a, 0)
-f / add(a, 2)
-f / add(a, b)
-f / add(b, a)
-f / b
-f / b != add(0, 1)
-f / b * 0
-f / b * b
-f / b ** 0.5
-f / b / a
-f / b <= b / a
-f / b <= f
-f / b == b
-f / b > a
-f / f
-f / f != obj.obj?.b
-f / f * 0
-f / f ** a
-f / f + add(2, b)
-f / f - -a
-f / f - a ^ a
-f / f - f
-f / f < a
-f / float(0)
-f / int(b)
-f / len(s)
-f / min(0)
-f / obj.a
-f / obj.b
-f / obj.fn(a)
-f / obj.head(b)
-f / obj.obj.a
-f / obj.obj?.a
-f / obj?.a
-f / obj?.b
-f / obj?.fn(0)
-f / obj?.fn(1)
-f / obj?.fn(2)
-f / obj?.fn(a)
-f / obj?.head(a, nil)
-f / obj?.head(f)
-f / obj?.head(f, nil)
-f / obj?.obj?.b
-f < -0
-f < -0.5
-f < 0 * b
-f < 0 - 0
-f < 0 == false
-f < 0 ? obj : add
-f < 0 ^ b
-f < 0 and obj.a
-f < 0 or 0.5 != b
-f < 0.5 == obj?.b
-f < 0.5 == obj?.head("a", div)
-f < 0.5 ? b : "b"
-f < 0.5 ? nil : add
-f < 0.5 ? obj : ok
-f < 1 != nil
-f < 1 * obj.a
-f < 2 - b
-f < 2 / 0.5
-f < a
-f < a && obj.b
-f < a && ok
-f < a ** b
-f < a + 1
-f < a / f
-f < a ? add : div
-f < a ? s : "c"
-f < a or obj?.a
-f < a or ok
-f < arr[0]
-f < b
-f < b != ok
-f < b - 0
-f < b ? a : a
-f < b ? a : f
-f < b ^ 0
-f < b ^ a
-f < b and f < 0.5
-f < b or nil == div
-f < div(a, a)
-f < div(a, b)
-f < f
-f < f != false
-f < f && obj.a
-f < f * 0
-f < f * 0.5
-f < f - 0
-f < f - b
-f < f == nil
-f < f == true
-f < f ? 0 : nil
-f < f ? 0.5 : a
-f < f ^ f
-f < f and obj.obj
-f < f or obj.b
-f < f or obj?.b
-f < float(0)
-f < float(b)
-f < float(f)
-f < get(arr, 0)
-f < get(arr, b)
-f < len(obj)
-f < min(0 % b)
-f < min(a)
-f < obj.a
-f < obj.b
-f < obj.fn(a)
-f < obj.head(0, arr, add, b)
-f < obj.head(b, b)
-f < obj.head(obj.b) and ok
-f < obj.obj?.a
-f < obj.obj?.b ^ f
-f < obj?.a
-f < obj?.b
-f < obj?.fn(b)
-f < obj?.head(0.5, true, add)
-f < obj?.head(a)
-f <= -a
-f <= -b
-f <= -f
-f <= 0 % b
-f <= 0 * 0
-f <= 0 ? "a" : "c"
-f <= 0 ? b : a
-f <= 0 ^ b
-f <= 0 and obj.obj
-f <= 0.5 ** b
-f <= 0.5 - b
-f <= 0.5 / a
-f <= 0.5 ? false : div
-f <= 0.5 ? obj : 0
-f <= 0.5 ^ 1
-f <= 0.5 and obj?.head(false)
-f <= 1 ** 0
-f <= 1 ** f
-f <= 1 - 2
-f <= 2 != false
-f <= 2 ? div : nil
-f <= 2 ? f : nil
-f <= a
-f <= a != ok
-f <= a % a
-f <= a && "c" <= s
-f <= a + 0
-f <= a / a
-f <= a / b
-f <= a ? 1 : 2
-f <= a and b == a
-f <= a or ok ? s : s
-f <= a || obj.fn(add)
-f <= add(2, b)
-f <= add(a, b)
-f <= arr[a]
-f <= arr[b]
-f <= arr[div(a, a)]
-f <= b
-f <= b != ok
-f <= b != true
-f <= b && ok
-f <= b * a
-f <= b == nil
-f <= b ? arr : add
-f <= b ? b : 2 != a
-f <= b ^ b
-f <= div(a, 1)
-f <= f
-f <= f - a
-f <= f - obj?.b
-f <= f / f
-f <= f ? a : div
-f <= f ? nil : true
-f <= f ^ a
-f <= f ^ b
-f <= f and obj.obj
-f <= f or false ? nil : s
-f <= f or ok
-f <= f || obj?.fn(s, 2)?.obj.fn(b)
-f <= float(f)
-f <= get(arr, b)
-f <= int(a)
-f <= last(arr)
-f <= obj.a
-f <= obj.a ** b
-f <= obj.b
-f <= obj.fn(0)
-f <= obj.head(0, nil)
-f <= obj?.a
-f <= obj?.b
-f <= obj?.head(a)
-f <= obj?.obj.a
-f <= obj?.obj?.b
-f == -0
-f == -b
-f == 0 ? b >= 1 : div
-f == 0 ? false : s
-f == 0.5 == ok
-f == 0.5 ? add : add
-f == 1 * 0
-f == 1 ** 0.5
-f == 1 ** b
-f == 1 / a
-f == 1 / f
-f == 1 ? true : "c"
-f == 2 ? ok : a
-f == a
-f == a != ok
-f == a * 0
-f == a * b
-f == a + a
-f == a and b < 2
-f == a and obj.head(obj, add)
-f == a || obj?.obj
-f == abs(b)
-f == add(b, 0)
-f == arr[b]
-f == b
-f == b != false
-f == b ** 0
-f == b + 0.5
-f == b + b
-f == b - 0
-f == b - 2
-f == b == nil
-f == b and obj?.b
-f == b or not ok
-f == div(a, b)
-f == div(b, b)
-f == f
-f == f != nil
-f == f ? arr : b
-f == f ^ 0
-f == f ^ a
-f == int(a)
-f == int(b)
-f == max(0)
-f == max(a)
-f == max(b)
-f == nil && obj?.fn(count(s == 0, "b" matches div))
-f == nil && ok ? f : obj
-f == nil == true ? obj : add
-f == nil ? arr : add
-f == nil ? nil == div : a
-f == nil and obj.fn(s)
-f == nil and ok
-f == nil || obj?.obj
-f == obj.a
-f == obj.b
-f == obj.b == ok
-f == obj.head(1)
-f == obj.head(2 != ok)
-f == obj.head(b)
-f == obj.head(f)
-f == obj.head(obj == div)
-f == obj.head(obj)
-f == obj.head(ok)
-f == obj.head(s)
-f == obj.obj
-f == obj.obj.obj
-f == obj.obj?.obj
-f == obj.obj?.obj?.b
-f == obj.obj?.obj?.obj
-f == obj?.a
-f == obj?.a % b
-f == obj?.b
-f == obj?.fn(0)
-f == obj?.head(b < 0)
-f == obj?.head(b, add)
-f == obj?.head(div)
-f == obj?.head(div, b, 2, b)
-f == obj?.obj
-f == obj?.obj.b
-f == {"a": b, "b": add, "a": arr}.obj
-f > -1
-f > -a
-f > -b
-f > -f
-f > 0 / f
-f > 0.5 ** 1
-f > 0.5 == ok
-f > 0.5 or not ok
-f > 0.5 or obj?.a
-f > 1 != ok
-f > 1 && s <= s
-f > 2 != false
-f > 2 - a
-f > 2 == obj.b
-f > a
-f > a != obj.b
-f > a * a
-f > a + 0
-f > a + f
-f > a / 0.5
-f > a ? arr : "c"
-f > a ? div : obj
-f > a ? f : obj?.obj
-f > a || div == nil
-f > a || true ? 1 : arr
-f > abs(a)
-f > add(b, 0)
-f > add(b, b)
-f > arr[a]
-f > arr[obj?.head(0.5)]
-f > b
-f > b && "a" <= "b"
-f > b ** 0
-f > b ** b
-f > b ** obj?.a
-f > b + 0
-f > b + 1
-f > b == ok
-f > b ? obj : f
-f > b || obj.head(0)
-f > count(arr, true)
-f > div(2, a)
-f > f
-f > f * b
-f > f ** 2
-f > f - a
-f > f / a
-f > f ? obj : nil
-f > f ^ b
-f > f in obj?.head(nil, "c")
-f > f or obj.head(nil)
-f > f or obj?.head(obj)
-f > int(0)
-f > len(obj)
-f > obj.a
-f > obj.b
-f > obj.fn(b)
-f > obj.obj.b
-f > obj.obj?.a
-f > obj.obj?.b
-f > obj?.a
-f > obj?.b
-f > obj?.fn(a)
-f > obj?.fn(b)
-f > obj?.head(a)
-f > obj?.obj.a
-f > obj?.obj?.obj?.b
-f >= -0
-f >= -1
-f >= -a
-f >= 0 != obj?.head(s, f)
-f >= 0 ** b
-f >= 0 + f
-f >= 0 - 0
-f >= 0 / b
-f >= 0 == ok
-f >= 0 ? nil : div
-f >= 0.5 != false
-f >= 0.5 ^ a
-f >= 1 * b
-f >= 1 ? a : add
-f >= 1 ? add : true
-f >= 1 ? obj : 1
-f >= 1 ^ a
-f >= 2 ^ a
-f >= a
-f >= a % b
-f >= a * a
-f >= a ? 0 : arr
-f >= a and obj?.head(a)
-f >= a in obj?.c
-f >= a or ok
-f >= add(a, a)
-f >= arr[b]
-f >= b
-f >= b != ok
-f >= b % 2
-f >= b && ok
-f >= b ** a
-f >= b + 2
-f >= b + a
-f >= b / a
-f >= b == false
-f >= b == obj.a
-f >= b ? s : div
-f >= b ^ a
-f >= b and obj?.b
-f >= count(arr, ok)
-f >= div(2, a)
-f >= div(b, b)
-f >= f
-f >= f && false ? f : a
-f >= f && ok
-f >= f * 0
-f >= f * 0.5
-f >= f ** 0
-f >= f ** a
-f >= f == ok
-f >= f == true
-f >= f ? "b" : 0
-f >= f ? b : f
-f >= first(arr)
-f >= float(b)
-f >= get(arr, a)
-f >= obj.a
-f >= obj.b
-f >= obj.fn(2)
-f >= obj.head(0.5, nil)
-f >= obj.head(a)
-f >= obj.head(b, add)
-f >= obj.obj.b
-f >= obj.obj?.b
-f >= obj?.a
-f >= obj?.b
-f >= obj?.b && ok
-f >= obj?.head(obj, b, 1)?.a
-f >= obj?.obj.b
-f >= obj?.obj?.a
-f ^ (0 + 1)
-f ^ (0 + a)
-f ^ (0 - b)
-f ^ (0.5 * a)
-f ^ (1 / a)
-f ^ (2 - b)
-f ^ (a * 0.5)
-f ^ (a * b)
-f ^ (a + a)
-f ^ (a + b)
-f ^ (a - f)
-f ^ (a / a)
-f ^ (b + 0)
-f ^ (f * f)
-f ^ (f / 0.5)
-f ^ -0
-f ^ -2
-f ^ -a
-f ^ 0 ** obj?.b
-f ^ 0 <= f
-f ^ 0 == a
-f ^ 0 >= obj.a
-f ^ 0 ^ 1
-f ^ 0.5 ** a
-f ^ 0.5 ** b
-f ^ 0.5 ** f
-f ^ 0.5 ** obj?.head(0, arr)
-f ^ 0.5 < a
-f ^ 0.5 ^ 0
-f ^ 0.5 ^ 0.5
-f ^ 0.5 ^ f
-f ^ 1 * a
-f ^ 1 ** 2
-f ^ 1 > a
-f ^ 1 > b ? nil : a
-f ^ 2 + div(a, 1)
-f ^ a
-f ^ a != obj.a
-f ^ a - a
-f ^ a <= b
-f ^ a == obj?.b
-f ^ a > a
-f ^ a > f
-f ^ a > obj.b
-f ^ a ^ obj?.b
-f ^ abs(b)
-f ^ abs(f)
-f ^ b
-f ^ b ** b ** obj?.b
-f ^ b + f
-f ^ b >= a + a
-f ^ div(b, 2)
-f ^ f
-f ^ f != b
-f ^ f * a
-f ^ f ** b
-f ^ f ** f
-f ^ f - b
-f ^ f / 0 ^ 2
-f ^ f / b
-f ^ f < b * b
-f ^ f <= 0.5 * b
-f ^ f >= f
-f ^ f ^ (b % a)
-f ^ f ^ abs(a)
-f ^ max(b)
-f ^ min(b, 2 * 2)
-f ^ obj.a
-f ^ obj.b
-f ^ obj.fn(0)
-f ^ obj.head(0.5, true)
-f ^ obj.head(f)
-f ^ obj.obj?.a
-f ^ obj?.a
-f ^ obj?.b
-f ^ obj?.obj.a
-f in get(obj.b, b)
-f in get(obj?.head(ok), s >= "c")
-f in map(arr, f)
-f in obj?.c
-f in obj?.head(get(f, obj))?.obj
-f in obj[nil]
-false != nil ? add : f
-false != nil ? f : ok
-false != obj.a
-false != obj.b
-false != obj.head(b)
-false != obj.head(ok)
-false != obj.obj
-false != obj.obj.b
-false != obj.obj?.a
-false != obj.obj?.obj
-false != obj?.a
-false != obj?.b
-false != obj?.head(add)
-false != obj?.obj
-false != obj?.obj.obj
-false != obj?.obj?.b
-false != ok or ok
-false != true or obj?.fn(0, nil)
-false && false && obj.b
-false && obj.a
-false && obj.b
-false && obj.fn(0 / div)
-false && obj.fn(add(f))
-false && obj.fn(filter(div .. obj, add.b), arr)
-false && obj.fn(obj)?.b
-false && obj.fn(ok?.b.a)
-false && obj.head(add?.b, add(b, f, s, add) contains add(arr, "a"))
-false && obj.head(any(ok, "c"))
-false && obj.head(div(0), duration(s, a, add))
-false && obj.head(div(filter(nil, arr), get(ok, nil)))
-false && obj.head(f?.obj, toBase64(nil, add, false))
-false && obj.head(none(arr, true), "a" / obj)
-false && obj.head(ok.fn(obj?.b, 0.5 endsWith obj))
-false && obj.obj
-false && obj?.a
-false && obj?.b
-false && obj?.b?.obj
-false && obj?.fn(add?.fn(map(b, 1)))
-false && obj?.fn(b - f <= div(0.5, "c"))
-false && obj?.fn(count(0, a)?.obj, arr?.head(nil) in div(true, 0, f), lastIndexOf(filter(nil, 0)), b?.head(none(0, obj), nil <= div, a .. s, "b" ** arr))
-false && obj?.fn(f * s ? nil : nil)
-false && obj?.head(a)
-false && obj?.head(a.obj)
-false && obj?.head(add(0, s)?.obj, arr startsWith div?.b)
-false && obj?.head(add(nil - b))
-false && obj?.head(add)
-false && obj?.head(all(0.5, ok), count(f, ok), f ? a : 0)
-false && obj?.head(all(f, add) && count("c", b), add.head(arr?.obj))
-false && obj?.obj
-false && obj[obj.fn(obj)]
-false && ok && obj.obj
-false && ok && obj[nil]
-false == nil == obj.a
-false == nil and obj.obj
-false == nil or ok
-false == obj.a
-false == obj.b
-false == obj.head(arr)
-false == obj.head(ok)
-false == obj.obj
-false == obj.obj?.a
-false == obj?.a
-false == obj?.b
-false == obj?.head(ok)
-false == obj?.obj
-false ? "b" : 0 >= obj.b
-false ? "c" : 0 / b
-false ? 0 : obj.a
-false ? 0 : obj.b
-false ? 0 : obj.obj
-false ? 0 : obj?.head(arr)
-false ? 0 : obj?.obj
-false ? 0.5 : a <= 0 + b
-false ? 0.5 : b / f
-false ? 0.5 : f * a
-false ? 0.5 : obj.obj
-false ? 0.5 : obj?.obj
-false ? 1 : obj.a
-false ? 1 : obj.b
-false ? 1 : obj?.obj
-false ? 2 : obj.obj
-false ? 2 : obj?.a
-false ? 2 : obj?.obj
-false ? a : 1 > min(f, f)
-false ? a : a != f
-false ? a : f + b
-false ? a : obj?.a
-false ? a : obj?.obj
-false ? a : true or obj?.b
-false ? add : a / a
-false ? add : f != a
-false ? add : obj.a
-false ? add : obj.b
-false ? add : obj?.a
-false ? add : obj?.b
-false ? add : obj?.obj
-false ? arr : 0 == a ^ 0.5
-false ? arr : obj.obj
-false ? arr : obj?.a
-false ? arr : obj?.b
-false ? b : 0 >= 0.5 - f
-false ? b : obj.b
-false ? b : obj.obj
-false ? b : obj.obj?.obj
-false ? b : obj?.a
-false ? b : obj?.obj
-false ? div : 1 - a
-false ? div : f * (2 - 2)
-false ? div : obj.a
-false ? div : obj.b
-false ? div : obj.obj
-false ? div : obj?.b
-false ? f : a ** f
-false ? f : obj.a
-false ? f : obj.obj
-false ? f : obj?.a
-false ? f : obj?.obj
-false ? false : obj.a
-false ? false : obj.obj
-false ? false : obj?.obj
-false ? nil : 0.5 ^ b
-false ? nil : 2 == a ? 0.5 : "b"
-false ? nil : obj.obj
-false ? nil : obj?.b
-false ? obj : 0.5 + b
-false ? obj : 2 != f ^ f
-false ? obj : a - b
-false ? obj : b <= add(0, b)
-false ? obj : obj?.a
-false ? obj : obj?.obj
-false ? ok : 0.5 > f ^ a
-false ? ok : b <= a
-false ? ok : b <= f
-false ? ok : b == a ? true : b
-false ? ok : obj?.a
-false ? s : 1 != obj.b
-false ? s : obj.b
-false ? s : obj?.a
-false ? true : obj.b
-false ? true : obj?.b
-false and false and obj.obj
-false and obj.a
-false and obj.a.obj
-false and obj.a?.b
-false and obj.b
-false and obj.b.a
-false and obj.fn((obj or b) + ok.fn(b, a))
-false and obj.fn(add?.a >= add(arr))
-false and obj.fn(any(obj, f startsWith obj))
-false and obj.fn(arr endsWith obj.obj)
-false and obj.fn(div(add?.obj), div.b != add)
-false and obj.fn(div, div(obj).a, a == div >= div(0.5, f))
-false and obj.fn(one(s, obj).b)
-false and obj.head("c" <= b, b, ok / obj)
-false and obj.head(any(arr, b))
-false and obj.head(div(nil, s)?.b)
-false and obj.head(div?.a)
-false and obj.head(get(false, obj))
-false and obj.head(s.head(arr), all(f, ok))?.b
-false and obj.obj
-false and obj?.a
-false and obj?.a?.a
-false and obj?.b
-false and obj?.b?.fn(all(map(a, get(add, 1)), !s[b]), lower(f) % f)
-false and obj?.b?.head(map(b, 0.5 - 1))
-false and obj?.b?.head(obj[ok].obj.b)
-false and obj?.b?.obj
-false and obj?.fn(a + a == div(0.5, obj, ok, div))
-false and obj?.fn(div or obj)
-false and obj?.head((ok or 0) in b.a, 0.5 / a.obj)
-false and obj?.head(1 != a)
-false and obj?.head(a && b)
-false and obj?.head(a)
-false and obj?.head(add && a, map(true, ok))
-false and obj?.head(add(1, false, 1, b))
-false and obj?.head(any(b, 0))
-false and obj?.head(arr <= f, ok.head(ok, "a", ok), arr, arr && ok)
-false and obj?.head(b <= add)
-false and obj?.head(f)
-false and obj?.head(ok.b or div endsWith div, div)
-false and obj?.head(s.head(b, false, s)?.a)
-false and obj?.head(toBase64(add))
-false and obj?.obj
-false and obj?.obj || obj?.b
-false and ok ? obj?.head(obj) : obj
-false and ok and obj.obj
-false or false or obj?.a
-false or obj.a
-false or obj.b
-false or obj.head(b)
-false or obj.obj
-false or obj.obj.a
-false or obj.obj.obj
-false or obj.obj?.obj
-false or obj?.a
-false or obj?.b
-false or obj?.fn(obj?.head(0, "b", b, 0))
-false or obj?.head(arr)
-false or obj?.head(s, arr)
-false or obj?.obj
-false or obj?.obj?.b
-false or ok ? f : div
-false or ok or obj?.obj
-false or true or obj.a
-false || false || true ? obj : 0
-false || obj.a
-false || obj.a == a
-false || obj.b
-false || obj.head(b)
-false || obj.obj
-false || obj?.a
-false || obj?.b
-false || obj?.fn(a)
-false || obj?.fn(b)
-false || obj?.obj
-false || true or obj?.obj
-filter(0 .. b, ok)
-filter(a .. a, 2 < f)
-filter(a .. b, ok)
-filter(arr, !false)
-filter(arr, !ok)
-filter(arr, "a" <= "c")
-filter(arr, "a" > "b")
-filter(arr, "a" endsWith s)
-filter(arr, "b" > "a")
-filter(arr, "c" > s)
-filter(arr, 0 == f)
-filter(arr, 0.5 != b)
-filter(arr, 0.5 < 0.5)
-filter(arr, 0.5 == 1)
-filter(arr, 1 == nil)
-filter(arr, 1 in arr)
-filter(arr, 2 < obj?.b)
-filter(arr, 2 > 2)
-filter(arr, 2 > a)
-filter(arr, a != nil)
-filter(arr, a < a)
-filter(arr, a <= 0)
-filter(arr, a > obj.b)
-filter(arr, a >= f)
-filter(arr, add == add)
-filter(arr, add == div)
-filter(arr, any(arr, ok))
-filter(arr, any(arr, true))
-filter(arr, arr == arr)
-filter(arr, b < 0)
-filter(arr, b < 0.5)
-filter(arr, b < b)
-filter(arr, b <= b)
-filter(arr, b > f)
-filter(arr, b >= a)
-filter(arr, f != nil)
-filter(arr, f != obj.obj)
-filter(arr, f < 0)
-filter(arr, f < f)
-filter(arr, f == b)
-filter(arr, f == nil)
-filter(arr, false) == arr
-filter(arr, false) == nil ? 2 : ok
-filter(arr, nil != add)
-filter(arr, nil != div)
-filter(arr, nil == "a")
-filter(arr, nil == a)
-filter(arr, nil == div)
-filter(arr, nil == false)
-filter(arr, nil == s)
-filter(arr, none(map(arr, 0), ok))
-filter(arr, not ok)
-filter(arr, obj.head(ok, "b"))
-filter(arr, obj?.head(false))
-filter(arr, obj?.head(ok))
-filter(arr, ok && ok)
-filter(arr, ok && true)
-filter(arr, ok == true)
-filter(arr, ok or ok)
-filter(arr, ok || ok)
-filter(arr, ok)
-filter(arr, ok) != b .. 1
-filter(arr, s == nil)
-filter(arr, s matches s)
-filter(arr, s startsWith "c")
-filter(arr[2:0], ok)
-filter(b .. 1, obj.obj)
-filter(b .. a, nil != a)
-filter(false ? a : arr, s != nil)
-filter(filter(arr, ok), 0.5 != nil)
-filter(filter(arr, ok), ok)
-filter(filter(arr, true), a <= 0)
-filter(keys(obj), ok)
-filter(map(arr, 0), s != s)
-filter(map(arr, 0.5), f != nil)
-filter(map(arr, 1), a != 2)
-filter(map(arr, add), ok)
-filter(map(arr, arr), ok)
-filter(map(arr, b), !ok)
-filter(map(arr, b), ok)
-filter(map(arr, div), add != add)
-filter(map(arr, div), ok)
-filter(map(arr, ok), #)
-filter(map(arr, ok), ok)
-filter(map(arr, s), ok)
-filter(map(obj?.obj, a == a), #)
-filter(obj.head(s), ok)
-filter(obj.obj, "b" endsWith s)
-filter(obj.obj, f < f)
-filter(obj.obj, s in obj)
-filter(obj?.head("b"), ok)
-filter(obj?.head("c"), ok)
-filter(obj?.head(s), ok)
-filter(obj?.head(s, s), ok)
-filter(ok ? "c" : true, ok)
-filter(ok ? arr : obj, a in arr)
-filter(ok ? s : arr, b in arr)
-filter(ok ? s : true, nil != f)
-filter(true ? arr : add, not true)
-filter(true ? arr : f, b == nil)
-first(0 .. 0)
-first(2 .. b)
-first([ok])
-first(a * obj?.b)
-first(a .. 0)
-first(a .. 1)
-first(a .. 2)
-first(a .. a)
-first(arr)
-first(arr) != a
-first(arr) != max(2, a)
-first(arr) != obj.b
-first(arr) % a
-first(arr) * f
-first(arr) ** -0.5
-first(arr) - 0 / a
-first(arr) - f ** a
-first(arr) .. obj.fn(b)
-first(arr) > f
-first(arr) ^ a
-first(arr[b:0])
-first(b * obj?.a)
-first(b .. 1)
-first(b .. b)
-first(false ? "a" : 0.5)
-first(false ? add : 1)
-first(false ? add : true)
-first(false ? b : arr)
-first(false ? false : "a")
-first(filter(arr, false))
-first(filter(arr, ok))
-first(filter(arr, true))
-first(get(obj, s))
-first(keys(obj))
-first(map(arr, "c"))
-first(map(arr, 0.5))
-first(map(arr, a))
-first(map(arr, add))
-first(map(arr, arr))
-first(map(arr, b))
-first(map(arr, div))
-first(map(arr, f))
-first(map(arr, false))
-first(map(arr, obj))
-first(map(arr, ok))
-first(map(arr, s))
-first(obj.a)
-first(obj.a)?.a
-first(obj.b)
-first(obj.b)?.a
-first(obj.fn(0))
-first(obj.fn(a))
-first(obj.fn(a))?.b
-first(obj.fn(b))
-first(obj.head("a"))
-first(obj.head("b"))
-first(obj.head(0.5))
-first(obj.head(0.5, add))
-first(obj.head(1))
-first(obj.head(1, 0, true))
-first(obj.head(1, add, add))
-first(obj.head(2, div))
-first(obj.head(a))
-first(obj.head(a, arr))
-first(obj.head(add, obj, div))
-first(obj.head(arr, "b")) == add
-first(obj.head(arr, 0, nil))
-first(obj.head(b))
-first(obj.head(b, "c"))
-first(obj.head(b, a))
-first(obj.head(b, a, 0))
-first(obj.head(b, s))
-first(obj.head(div))
-first(obj.head(f))
-first(obj.head(f, false, 0, a))
-first(obj.head(nil))
-first(obj.head(nil, 0))
-first(obj.head(obj, a)?.a)
-first(obj.head(ok))
-first(obj.head(ok, add, b))
-first(obj.head(s))
-first(obj.head(s, 0))
-first(obj.head(s, add))
-first(obj.head(s, div, f, add))
-first(obj.head(s, ok, add))
-first(obj.head(true))
-first(obj.obj)
-first(obj?.a)
-first(obj?.a)?.obj
-first(obj?.b)
-first(obj?.fn(0 + a))
-first(obj?.fn(0))
-first(obj?.fn(a))
-first(obj?.fn(b))
-first(obj?.head("a", false))
-first(obj?.head("b"))
-first(obj?.head("c", f))
-first(obj?.head(0))
-first(obj?.head(1))
-first(obj?.head(2))
-first(obj?.head(a))
-first(obj?.head(a, div))
-first(obj?.head(a, f))
-first(obj?.head(a, f, div, "b", a))
-first(obj?.head(a, f, nil))
-first(obj?.head(add))
-first(obj?.head(add, nil, f))?.obj
-first(obj?.head(arr))
-first(obj?.head(b))
-first(obj?.head(b, "b", false, add))
-first(obj?.head(b, s, div))
-first(obj?.head(div))
-first(obj?.head(f))
-first(obj?.head(false, nil, a, obj, f))
-first(obj?.head(get(s, obj)))
-first(obj?.head(nil))
-first(obj?.head(nil, f))
-first(obj?.head(obj))
-first(obj?.head(obj, f, 2).a)
-first(obj?.head(obj, nil, s))
-first(obj?.head(ok))
-first(obj?.head(ok, b))
-first(obj?.head(true))
-first(obj?.obj)
-first(obj?.obj.a)
-first(obj?.obj?.obj)
-first(obj[nil])
-first(obj[s])
-first(ok ? a : ok)
-first(ok ? obj : "b")
-first(ok ? obj : false)
-first(ok ? obj : ok)
-first(ok ? ok : s)
-first(ok ? s : ok)
-first(split(s, s))
-first(true ? arr : false)
-first(values(obj))
-float(-(f * 0))
-float(-0)
+div == div ? 0.5 : half
+div == div ? nil : i
+div == div || true ? f32 : add
+div == foo.Qux
+div == foo.String
+div == foo?.Qux
+div == foo?.String
+div == greet
+div == greet != ok
+div == greet || !false
+div == half
+div == nil ? greet : foo
+div == nil ? half : half
+div == nil ? score : i64
+div == nil || ok
+div == score
+div == score == ok
+div == score ? true : "bar"
+div in map(list, add)
+div not in [add]
+div not in [half, f32, false]
+div not in map(array, div)
+div(-1, i)
+div(1, 1) > i64
+div(1, i) >= i64
+div(i, 1) / f32
+div(i, 1) == i
+div(i, i)
+f32
+f32 != --f64
+f32 != -1
+f32 != 0.5 * f32
+f32 != 0.5 + i64
+f32 != 0.5 / i64
+f32 != 0.5 == ok
+f32 != 0.5 ? array : ok
+f32 != 0.5 ? list : 1
+f32 != 0.5 ^ i32
+f32 != 1 % i32
+f32 != 1 * 1
+f32 != 1 * i64
+f32 != 1 ** 0.5
+f32 != 1 - i
+f32 != 1 ? "foo" : foo
+f32 != 1 ^ f32
+f32 != abs(i64)
+f32 != f32
+f32 != f32 + f64
+f32 != f32 - f64
+f32 != f64
+f32 != f64 ** i32
+f32 != f64 + i32
+f32 != f64 - f32
+f32 != f64 ^ i32
+f32 != findIndex(list, ok)
+f32 != float(i)
+f32 != i
+f32 != i * i64
+f32 != i - f64
+f32 != i32
+f32 != i64
+f32 != i64 * 1
+f32 != i64 ? f64 : f32
+f32 != len(array)
+f32 != max(i)
+f32 != min(1)
+f32 != min(f64)
+f32 != nil ? half : greet
+f32 != score(1)
+f32 * (1 - f32)
+f32 * (i + 1)
+f32 * (i32 + f32)
+f32 * (i64 + f32)
+f32 * (i64 - i64)
+f32 * -0.5
+f32 * -f32
+f32 * -f64
+f32 * -i32
+f32 * 0.5 != f32
+f32 * 0.5 ** f32
+f32 * 0.5 - f32
+f32 * 0.5 < f64
+f32 * 0.5 < i32
+f32 * 0.5 <= f32
+f32 * 0.5 <= f32 ? "bar" : array
+f32 * 0.5 <= i64
+f32 * 1 != f32
+f32 * 1 * 1
+f32 * 1 ** f64
+f32 * 1 + i
+f32 * 1 - i
+f32 * 1 / i64
+f32 * 1 < f64
+f32 * 1 <= f32
+f32 * 1 >= i32
+f32 * array[i64]
+f32 * count(array, ok)
+f32 * f32
+f32 * f32 * i
+f32 * f32 ^ i64
+f32 * f64
+f32 * f64 * i64
+f32 * f64 + f32
+f32 * f64 - i
+f32 * f64 ^ f32
+f32 * findIndex(list, true)
+f32 * float(0.5)
+f32 * i
+f32 * i < f64
+f32 * i <= -i64
+f32 * i <= min(0.5, f64)
+f32 * i32
+f32 * i32 ** 1
+f32 * i32 - i64
+f32 * i64
+f32 * i64 ** 0.5
+f32 * i64 ** i64
+f32 * i64 < f64
+f32 * i64 < half(f64)
+f32 * i64 ^ i
+f32 * i64 ^ i64
+f32 * int(f64)
+f32 * max(f32)
+f32 * min(0.5)
+f32 * min(f64)
+f32 * score(1)
+f32 ** (0.5 + i)
+f32 ** (0.5 - 0.5)
+f32 ** (1 - i64)
+f32 ** (1 / 0.5)
+f32 ** (f32 * i)
+f32 ** (f32 + 0.5)
+f32 ** (f32 + i64)
+f32 ** (f32 - 1)
+f32 ** (f64 - i32)
+f32 ** (i32 * 1)
+f32 ** (i32 * i)
+f32 ** -0.5
+f32 ** -1
+f32 ** -f64
+f32 ** -i
+f32 ** -i32
+f32 ** -i64
+f32 ** 0.5 >= i64
+f32 ** 0.5 ^ i64
+f32 ** 1 * f32
+f32 ** 1 ** 0.5
+f32 ** 1 / i32
+f32 ** 1 <= i
+f32 ** array[i64]
+f32 ** f32
+f32 ** f32 * i ^ f64
+f32 ** f32 + f32
+f32 ** f32 - 0.5 + 1
+f32 ** f32 ^ 1
+f32 ** f32 ^ i
+f32 ** f64
+f32 ** f64 + i64
+f32 ** f64 <= f64
+f32 ** f64 >= f32
+f32 ** float(i64)
+f32 ** half(f64)
+f32 ** i
+f32 ** i * f64
+f32 ** i / f64
+f32 ** i == score(i)
+f32 ** i32
+f32 ** i32 ** i32
+f32 ** i32 >= i32
+f32 ** i64
+f32 ** i64 * i32
+f32 ** i64 + i64
+f32 ** i64 / i64
+f32 ** int(0.5)
+f32 ** int(1)
+f32 ** len("foo")
+f32 ** len(list)
+f32 ** max(f32)
+f32 ** max(f64)
+f32 ** max(i64)
+f32 + -0.5
+f32 + -1
+f32 + -f32
+f32 + -i
+f32 + -i64
+f32 + 0.5 + 1
+f32 + 0.5 + f32
+f32 + 1 * 0.5
+f32 + 1 * i32
+f32 + 1 ** f64
+f32 + 1 - f32
+f32 + 1 - i64
+f32 + 1 < i32
+f32 + abs(0.5)
+f32 + abs(f32)
+f32 + count(array, true)
+f32 + f32
+f32 + f32 + i32
+f32 + f32 == 0.5 ^ i
+f32 + f64
+f32 + f64 - 0.5
+f32 + f64 - f32
+f32 + f64 / f64
+f32 + f64 < f32
+f32 + f64 ^ f32
+f32 + find(array, ok)
+f32 + float(f64)
+f32 + half(0.5)
+f32 + i
+f32 + i != i
+f32 + i - i
+f32 + i ^ f64
+f32 + i32
+f32 + i32 * 0.5
+f32 + i32 + 0.5
+f32 + i32 >= f32
+f32 + i64
+f32 + i64 % 1
+f32 + i64 - 1
+f32 + i64 - f32
+f32 + int(1)
+f32 + int(f64)
+f32 + int(i32)
+f32 + len(array)
+f32 + max(0.5)
+f32 + max(f64)
+f32 + max(i64)
+f32 + min(1)
+f32 + min(f32)
+f32 + min(i32)
+f32 + min(i64, 1, 1)
+f32 + score(1)
+f32 + score(i)
+f32 - -0.5
+f32 - -1
+f32 - -f64
+f32 - -i
+f32 - -i32
+f32 - 0.5 + f64
+f32 - 0.5 - i32
+f32 - 0.5 - i64
+f32 - 0.5 <= f64
+f32 - 0.5 <= i64
+f32 - 0.5 >= i64
+f32 - 0.5 ^ f64
+f32 - 0.5 ^ i32
+f32 - 1 != i64
+f32 - 1 % 1
+f32 - 1 % i64
+f32 - 1 + 1
+f32 - 1 + i32 % i
+f32 - 1 - f32
+f32 - abs(i32)
+f32 - array[i]
+f32 - f32
+f32 - f32 - f64
+f32 - f32 - i32
+f32 - f32 == i
+f32 - f32 == min(1)
+f32 - f32 >= i
+f32 - f64
+f32 - f64 * 1
+f32 - f64 ** i32
+f32 - f64 + f32
+f32 - f64 + i64
+f32 - f64 - f32
+f32 - f64 - i
+f32 - f64 <= f32
+f32 - f64 ^ 1
+f32 - float(0.5)
+f32 - float(1)
+f32 - float(i32)
+f32 - half(0.5)
+f32 - i
+f32 - i % 1
+f32 - i * f32
+f32 - i + i32 % 1
+f32 - i + i32 ** 0.5
+f32 - i - 0.5
+f32 - i32
+f32 - i32 * 1
+f32 - i32 ** f32
+f32 - i32 ** i32
+f32 - i32 + 1
+f32 - i32 >= i
+f32 - i32 ^ i
+f32 - i64
+f32 - i64 - 1
+f32 - i64 <= i32
+f32 - i64 ^ 1
+f32 - int(0.5)
+f32 - int(i64)
+f32 - len("bar")
+f32 - len(list)
+f32 - max(i32)
+f32 - min(1)
+f32 - min(i64)
+f32 - score(i)
+f32 / (0.5 + i64)
+f32 / (1 - i)
+f32 / (i64 - f64)
+f32 / -0.5
+f32 / -f32
+f32 / -f64
+f32 / -i
+f32 / -i32
+f32 / 0.5 * 0.5
+f32 / 0.5 * i
+f32 / 0.5 - f64
+f32 / 0.5 - i
+f32 / 0.5 - i64
+f32 / 0.5 > f64
+f32 / 1 != f64
+f32 / 1 * i64
+f32 / 1 ** f32
+f32 / 1 - f64 - i64
+f32 / 1 >= f32
+f32 / 1 ^ 0.5
+f32 / 1 ^ i
+f32 / abs(1)
+f32 / abs(f32)
+f32 / f32
+f32 / f32 / f32
+f32 / f32 < f32
+f32 / f64
+f32 / f64 ^ 0.5
+f32 / float(i64)
+f32 / get(array, 1)
+f32 / half(0.5)
+f32 / i
+f32 / i <= i64
+f32 / i32
+f32 / i32 != i
+f32 / i32 ** i
+f32 / i32 / f64
+f32 / i32 >= i
+f32 / i64
+f32 / i64 * i64
+f32 / i64 > i32
+f32 / i64 ^ 1
+f32 / i64 ^ i
+f32 / int(f32)
+f32 / int(f64)
+f32 / int(i)
+f32 / int(i32)
+f32 / last(array)
+f32 / max(0.5)
+f32 / max(1)
+f32 / min(f32)
+f32 < -0.5
+f32 < -f32
+f32 < -f64
+f32 < -i32
+f32 < -i64
+f32 < 0.5 != true
+f32 < 0.5 ? array : array
+f32 < 0.5 ? false : score
+f32 < 0.5 ? i64 : i32
+f32 < 0.5 ? ok : f32
+f32 < 0.5 ^ f32
+f32 < 1 != ok
+f32 < 1 * f32
+f32 < 1 ** 1
+f32 < 1 ** i
+f32 < 1 - i
+f32 < 1 / 0.5
+f32 < 1 ? f32 : i64
+f32 < 1 ? foo : i
+f32 < 1 ? i64 : foo
+f32 < 1 || not ok
+f32 < abs(1)
+f32 < abs(i)
+f32 < array[i64]
+f32 < array[i]
+f32 < div(1, 1)
+f32 < f32
+f32 < f32 ** 1
+f32 < f32 ^ 0.5
+f32 < f64
+f32 < f64 != ok
+f32 < f64 / f64
+f32 < f64 == nil
+f32 < f64 == true
+f32 < f64 ? "foo" : half
+f32 < float(f32)
+f32 < float(i64)
+f32 < half(f64)
+f32 < i
+f32 < i * 1
+f32 < i - i32
+f32 < i ? greet : "foo"
+f32 < i32
+f32 < i32 ** 0.5
+f32 < i32 or ok
+f32 < i32 || ok
+f32 < i64
+f32 < i64 != nil
+f32 < i64 && ok
+f32 < i64 * i32
+f32 < i64 - f32
+f32 < int(f64)
+f32 < max(1)
+f32 < score(1)
+f32 < score(i)
+f32 <= -0.5
+f32 <= -1
+f32 <= -f32
+f32 <= -f64
+f32 <= -i
+f32 <= -i64
+f32 <= -min(i64)
+f32 <= 0.5 * 0.5
+f32 <= 0.5 ** i32
+f32 <= 0.5 - 1
+f32 <= 0.5 / 0.5
+f32 <= 0.5 == ok
+f32 <= 0.5 == true
+f32 <= 1 != nil
+f32 <= 1 % i
+f32 <= 1 * 0.5
+f32 <= 1 * i32
+f32 <= 1 == ok
+f32 <= abs(1)
+f32 <= f32
+f32 <= f32 ** i64
+f32 <= f32 ? 0.5 : foo
+f32 <= f64
+f32 <= f64 ? ok : f64
+f32 <= f64 ^ f32
+f32 <= f64 and ok
+f32 <= findIndex(list, ok)
+f32 <= first(array)
+f32 <= half(0.5)
+f32 <= i
+f32 <= i != nil
+f32 <= i % i64
+f32 <= i ** i32
+f32 <= i - 0.5
+f32 <= i / f32
+f32 <= i == ok
+f32 <= i32
+f32 <= i32 * i64
+f32 <= i32 ** i32
+f32 <= i32 + i32
+f32 <= i32 - 1
+f32 <= i32 / 1
+f32 <= i32 ? 0.5 : i32
+f32 <= i32 and ok
+f32 <= i64
+f32 <= i64 * i
+f32 <= i64 ? true : array
+f32 <= i64 or ok
+f32 <= int(0.5)
+f32 <= int(i)
+f32 <= len("foo")
+f32 <= max(f32)
+f32 <= max(i64)
+f32 <= min(i64, i32)
+f32 <= score(1)
+f32 <= score(i)
+f32 == --f64
+f32 == -0.5
+f32 == -1
+f32 == -f32
+f32 == -i32
+f32 == -i64
+f32 == 0.5 && i32 == i32
+f32 == 0.5 * i32
+f32 == 0.5 ** 1
+f32 == 0.5 and ok
+f32 == 1 && ok ? add : f32
+f32 == 1 ^ i
+f32 == abs(1)
+f32 == array[1]
+f32 == count(array, ok)
+f32 == f32
+f32 == f32 ** f32
+f32 == f32 - i32
+f32 == f32 ? 1 : greet
+f32 == f32 ? list : "bar"
+f32 == f64
+f32 == f64 - 1
+f32 == f64 - f64
+f32 == f64 ? ok : i64
+f32 == find(array, ok)
+f32 == findLast(array, ok)
+f32 == findLastIndex(list, true)
+f32 == get(array, 1)
+f32 == i
+f32 == i * i64
+f32 == i + f64 + 0.5
+f32 == i - f64
+f32 == i - i32
+f32 == i / 0.5
+f32 == i ? "foo" : i64
+f32 == i ? i : 0.5
+f32 == i32
+f32 == i32 % 1
+f32 == i32 - 0.5
+f32 == i64
+f32 == i64 % i
+f32 == i64 * 0.5
+f32 == int(1)
+f32 == max(0.5, 1)
+f32 == max(i)
+f32 == min(0.5)
+f32 == min(i64)
+f32 == nil ? "foo" : div
+f32 == nil ? i32 : greet
+f32 == score(1)
+f32 > -0.5
+f32 > -f64
+f32 > -i
+f32 > -i32
+f32 > -i64
+f32 > 0.5 != false
+f32 > 0.5 != ok
+f32 > 0.5 - 0.5
+f32 > 0.5 / 0.5
+f32 > 0.5 ? foo : f64
+f32 > 0.5 ? greet : half
+f32 > 1 % 1
+f32 > 1 ** 0.5
+f32 > 1 + f32
+f32 > 1 / i64
+f32 > 1 == true
+f32 > 1 ? nil : half
+f32 > 1 ^ i32
+f32 > array[i32]
+f32 > f32
+f32 > f32 ** f32
+f32 > f32 - i
+f32 > f32 == true
+f32 > f64
+f32 > f64 - i32
+f32 > f64 / i64
+f32 > f64 ? array : false
+f32 > f64 ? true : array
+f32 > f64 or ok
+f32 > i
+f32 > i * 0.5
+f32 > i + f32
+f32 > i32
+f32 > i32 != ok
+f32 > i32 * i
+f32 > i64
+f32 > i64 ? 1 : f64
+f32 > i64 ? ok : greet
+f32 > int(0.5)
+f32 > int(f64)
+f32 > max(i32)
+f32 > max(i32, 1)
+f32 > min(f64)
+f32 > score(1)
+f32 > score(i)
+f32 >= -f64
+f32 >= -i
+f32 >= -i32
+f32 >= -i64
+f32 >= 0.5 ** f64
+f32 >= 0.5 - 0.5
+f32 >= 0.5 == ok
+f32 >= 1 != ok
+f32 >= 1 != true
+f32 >= 1 % 1
+f32 >= 1 % i
+f32 >= 1 - 1
+f32 >= 1 - i
+f32 >= 1 - i64
+f32 >= 1 ? "foo" endsWith "foo" : f64
+f32 >= abs(1)
+f32 >= f32
+f32 >= f32 ** 1
+f32 >= f32 ** f32
+f32 >= f32 + i32
+f32 >= f64
+f32 >= f64 + i32
+f32 >= first(array)
+f32 >= float(i32)
+f32 >= float(i64)
+f32 >= half(f64)
+f32 >= i
+f32 >= i != true
+f32 >= i * 0.5
+f32 >= i ** 0.5
+f32 >= i ** i32
+f32 >= i + f64
+f32 >= i ? "bar" : nil
+f32 >= i ? ok : i
+f32 >= i32
+f32 >= i32 * 0.5
+f32 >= i32 ? array : foo
+f32 >= i32 ^ i32
+f32 >= i64
+f32 >= i64 % i64
+f32 >= i64 ** 0.5
+f32 >= i64 ? 1 : i32
+f32 >= i64 ? i64 : add
+f32 >= i64 || ok
+f32 >= len("foo")
+f32 >= max(i)
+f32 >= min(i)
+f32 >= score(1)
+f32 ^ (1 * f32)
+f32 ^ (1 + 1)
+f32 ^ (1 - 0.5)
+f32 ^ (f32 * 0.5)
+f32 ^ (f32 / 1)
+f32 ^ (i + i)
+f32 ^ (i32 % 1)
+f32 ^ (i32 % i64)
+f32 ^ (i32 / 1)
+f32 ^ (i32 / f64)
+f32 ^ (i64 - f32)
+f32 ^ -0.5
+f32 ^ -1
+f32 ^ -f32
+f32 ^ -i
+f32 ^ -i32
+f32 ^ -i64
+f32 ^ 0.5 != i64
+f32 ^ 0.5 + f32
+f32 ^ 0.5 + i64
+f32 ^ 0.5 - f64
+f32 ^ 0.5 <= 0.5 ^ 0.5
+f32 ^ 0.5 ^ f32
+f32 ^ 1 - i
+f32 ^ 1 - i32
+f32 ^ 1 <= 1 * 1
+f32 ^ 1 <= i32
+f32 ^ 1 ^ 0.5
+f32 ^ f32
+f32 ^ f32 ** i
+f32 ^ f32 + f32
+f32 ^ f32 / f32
+f32 ^ f64
+f32 ^ f64 < f64
+f32 ^ f64 < i64
+f32 ^ f64 <= f64
+f32 ^ f64 == f64
+f32 ^ f64 > i
+f32 ^ half(f64)
+f32 ^ i
+f32 ^ i ** i32
+f32 ^ i32
+f32 ^ i32 + f32
+f32 ^ i64
+f32 ^ last(array)
+f32 ^ max(0.5)
+f32 ^ max(f32)
+f32 ^ max(i64)
+f32 ^ min(1)
+f32 ^ min(1, 1)
+f32 ^ score(i)
+f32 in [false, list]
+f32 in [nil]
+f32 not in sort(array)
+f64
+f64 != -(0.5 ** 0.5)
+f64 != -1
+f64 != -f64
+f64 != -i
+f64 != -i32
+f64 != 0.5 && ok
+f64 != 0.5 + 1
+f64 != 0.5 + f64
+f64 != 0.5 == nil
+f64 != 0.5 == true
+f64 != 0.5 ? false : array
+f64 != 0.5 and ok
+f64 != 1 ? list : false
+f64 != 1 ^ i64
+f64 != abs(f32)
+f64 != array[i64]
+f64 != f32
+f64 != f32 * i32
+f64 != f64
+f64 != f64 * f32
+f64 != f64 ^ 1
+f64 != findLastIndex(list, ok)
+f64 != first(array)
+f64 != get(array, i32)
+f64 != half(0.5)
+f64 != half(f64)
+f64 != i
+f64 != i && ok
+f64 != i + 1
+f64 != i32
+f64 != i32 + f64
+f64 != i32 ? "bar" : nil
+f64 != i32 ? add : 1
+f64 != i32 ^ 0.5
+f64 != i64
+f64 != i64 ** 0.5
+f64 != int(i64)
+f64 != max(i64)
+f64 != min(1)
+f64 != min(i32)
+f64 != nil == ok
+f64 != score(1)
+f64 != score(i)
+f64 * (0.5 - f32)
+f64 * (0.5 - i64)
+f64 * (f32 + i32)
+f64 * (i32 - 0.5)
+f64 * (i64 - f64)
+f64 * -1
+f64 * -f32
+f64 * -f64
+f64 * -i32
+f64 * -i64
+f64 * 0.5 * 0.5 ^ i64
+f64 * 0.5 / i32
+f64 * 0.5 ^ 1
+f64 * 1 ** 0.5
+f64 * 1 + i64
+f64 * 1 / i32
+f64 * 1 < 0.5 * 0.5
+f64 * abs(i)
+f64 * f32
+f64 * f32 * f32
+f64 * f32 - f32
+f64 * f32 - f64
+f64 * f32 / f64
+f64 * f32 >= f64
+f64 * f64
+f64 * f64 / i
+f64 * f64 < f64
+f64 * f64 >= score(1)
+f64 * float(i)
+f64 * i
+f64 * i != i
+f64 * i * 0.5
+f64 * i * i
+f64 * i * i64
+f64 * i - f64
+f64 * i32
+f64 * i32 * 1
+f64 * i32 > f64
+f64 * i64
+f64 * i64 + f32
+f64 * i64 + i
+f64 * i64 - f32
+f64 * i64 ^ i32
+f64 * int(0.5)
+f64 * int(f32)
+f64 * int(f64)
+f64 * last(array)
+f64 * len(list)
+f64 * max(i64)
+f64 * min(i32)
+f64 * score(1)
+f64 * score(i)
+f64 ** (0.5 * i32)
+f64 ** (0.5 + 1)
+f64 ** (0.5 + i)
+f64 ** (1 + 1)
+f64 ** (1 + f64)
+f64 ** (1 - 1)
+f64 ** (1 / i64)
+f64 ** (f32 * i)
+f64 ** (f64 + 0.5)
+f64 ** (f64 + f64)
+f64 ** (f64 + i)
+f64 ** (i % 1)
+f64 ** (i % i32)
+f64 ** (i32 * 1)
+f64 ** (i32 + 0.5)
+f64 ** (i32 - f32)
+f64 ** (i64 * 1)
+f64 ** (i64 + 0.5)
+f64 ** (i64 / i)
+f64 ** -0.5
+f64 ** -1
+f64 ** -f32
+f64 ** -f64
+f64 ** -i
+f64 ** -i32
+f64 ** -i64
+f64 ** 0.5 ** i64
+f64 ** 0.5 <= 1 - 1
+f64 ** 1 ** 0.5 ** 0.5
+f64 ** 1 < 1 - i64
+f64 ** 1 == f64 + f32
+f64 ** 1 ^ i
+f64 ** 1 ^ i64
+f64 ** abs(1)
+f64 ** abs(f64)
+f64 ** f32
+f64 ** f32 ** 0.5
+f64 ** f32 == i64
+f64 ** f64
+f64 ** f64 != f32
+f64 ** f64 ** 0.5
+f64 ** f64 / f32
+f64 ** f64 < f64
+f64 ** f64 <= f64
+f64 ** f64 ^ f64
+f64 ** f64 ^ i32
+f64 ** float(i32)
+f64 ** get(array, i64)
+f64 ** half(0.5)
+f64 ** i
+f64 ** i != i
+f64 ** i - i32
+f64 ** i / f32
+f64 ** i >= i32
+f64 ** i ^ i32
+f64 ** i32
+f64 ** i32 != max(f64, 0.5)
+f64 ** i32 ** 1
+f64 ** i32 ^ 1
+f64 ** i64
+f64 ** i64 ** i64
+f64 ** i64 / f64
+f64 ** i64 ^ i
+f64 ** int(0.5)
+f64 ** int(1)
+f64 ** max(i32)
+f64 ** min(1)
+f64 ** min(f32)
+f64 ** score(1, 1)
+f64 + -0.5
+f64 + -f64
+f64 + -i
+f64 + -i32
+f64 + -i64
+f64 + 0.5 * 1
+f64 + 0.5 * i32
+f64 + 0.5 / f32
+f64 + 0.5 == i64
+f64 + 1 != f64
+f64 + 1 + f64
+f64 + 1 - 0.5
+f64 + 1 < i64
+f64 + 1 > 0.5 ? 1 : 0.5
+f64 + 1 > i64
+f64 + 1 >= f32
+f64 + abs(i)
+f64 + abs(i64)
+f64 + array[1]
+f64 + array[i64]
+f64 + count(array, ok)
+f64 + f32
+f64 + f32 * i32
+f64 + f32 - i64
+f64 + f64
+f64 + f64 + i64
+f64 + f64 == i32
+f64 + f64 > i32
+f64 + f64 ^ 0.5
+f64 + float(i64)
+f64 + half(0.5)
+f64 + half(f64)
+f64 + i
+f64 + i ** 0.5
+f64 + i + 1
+f64 + i / 0.5
+f64 + i32
+f64 + i32 ** i64
+f64 + i32 + i32
+f64 + i32 / 1
+f64 + i32 <= i
+f64 + i32 >= i64
+f64 + i64
+f64 + i64 - f64
+f64 + i64 ^ f32
+f64 + int(0.5)
+f64 + int(i32)
+f64 + len(array)
+f64 + min(0.5, 0.5)
+f64 + min(f32)
+f64 + score(i)
+f64 - -0.5
+f64 - -1
+f64 - -f64
+f64 - -i
+f64 - -i32
+f64 - -i64
+f64 - 0.5 != f64
+f64 - 0.5 * 0.5
+f64 - 0.5 ** i
+f64 - 0.5 + f32
+f64 - 0.5 + i
+f64 - 0.5 + i32
+f64 - 0.5 >= -0.5
+f64 - 1 * f32
+f64 - 1 ** f32
+f64 - 1 ** i32
+f64 - 1 + 1
+f64 - 1 - f64
+f64 - 1 / 0.5
+f64 - 1 < f32
+f64 - 1 ^ 0.5
+f64 - 1 ^ 1
+f64 - abs(0.5)
+f64 - abs(i)
+f64 - array[i64]
+f64 - f32
+f64 - f32 * f64
+f64 - f32 + 1 + 0.5
+f64 - f32 - f64
+f64 - f32 < f64
+f64 - f32 >= i32
+f64 - f64
+f64 - f64 - 0.5
+f64 - f64 - i32
+f64 - f64 <= i
+f64 - f64 == f64
+f64 - f64 > f32
+f64 - f64 >= get(array, i64)
+f64 - get(array, i)
+f64 - half(0.5)
+f64 - i
+f64 - i % i32
+f64 - i + 1
+f64 - i / 1
+f64 - i < i32
+f64 - i < i64
+f64 - i == i
+f64 - i == i64
+f64 - i > f64
+f64 - i32
+f64 - i32 + i
+f64 - i32 - i64
+f64 - i32 >= i32
+f64 - i64
+f64 - i64 * 0.5
+f64 - i64 * 1
+f64 - i64 - f32
+f64 - int(0.5)
+f64 - int(i32)
+f64 - max(1)
+f64 - min(1)
+f64 - min(i32, i64)
+f64 - score(i)
+f64 / (0.5 + f32)
+f64 / (0.5 - 0.5)
+f64 / (0.5 - f64)
+f64 / (0.5 - i32)
+f64 / (1 + i32)
+f64 / (1 - 1)
+f64 / (i32 + f64)
+f64 / (i32 - 1)
+f64 / (i64 - i64)
+f64 / -0.5
+f64 / -1
+f64 / -f32
+f64 / -i
+f64 / -i32
+f64 / 0.5 * i
+f64 / 0.5 ** 0.5
+f64 / 0.5 ** f64
+f64 / 0.5 / f64
+f64 / 0.5 / i64
+f64 / 0.5 > f64
+f64 / 0.5 ^ i
+f64 / 1 != i
+f64 / 1 * abs(i64)
+f64 / 1 * i
+f64 / 1 ** 0.5
+f64 / 1 ^ i64
+f64 / array[i32]
+f64 / array[i]
+f64 / f32
+f64 / f32 != f64
+f64 / f32 * i
+f64 / f32 > f64
+f64 / f32 ^ i32
+f64 / f32 in [f32]
+f64 / f64
+f64 / f64 != f32
+f64 / f64 * f32
+f64 / f64 - f32
+f64 / f64 - f64
+f64 / get(array, i64)
+f64 / half(0.5)
+f64 / i
+f64 / i * i32
+f64 / i ** 0.5
+f64 / i ** i32
+f64 / i + i64
+f64 / i < f64
+f64 / i > 1 ** 1
+f64 / i > f64
+f64 / i >= f64
+f64 / i32
+f64 / i32 / i32
+f64 / i32 < f64
+f64 / i64
+f64 / i64 * i64 ^ i
+f64 / i64 - f32
+f64 / i64 / 0.5
+f64 / i64 / i64
+f64 / i64 <= f64
+f64 / i64 > i
+f64 / int(f32)
+f64 / int(i64)
+f64 / max(i)
+f64 / min(0.5)
+f64 / score(i)
+f64 < -0.5
+f64 < -1
+f64 < -i32
+f64 < -i64
+f64 < 0.5 ** f32
+f64 < 0.5 == true
+f64 < 0.5 ? 0.5 : foo
+f64 < 0.5 ? 1 : array
+f64 < 0.5 ? greet : false
+f64 < 0.5 ^ 1
+f64 < 0.5 or ok
+f64 < 1 == not ok
+f64 < 1 ? 1 : half
+f64 < 1 ? 1 : i
+f64 < 1 ? ok : i
+f64 < 1 and nil == i32
+f64 < abs(1)
+f64 < abs(i32)
+f64 < array[i32]
+f64 < count(list, true)
+f64 < f32
+f64 < f32 * 0.5
+f64 < f32 * f64
+f64 < f32 ** i32
+f64 < f32 - 1
+f64 < f32 ? array : 0.5
+f64 < f64
+f64 < f64 * f32
+f64 < get(array, i)
+f64 < half(0.5)
+f64 < i
+f64 < i - f64
+f64 < i == ok
+f64 < i ? false : nil
+f64 < i32
+f64 < i32 % i32
+f64 < i32 % i64
+f64 < i32 == ok
+f64 < i32 and ok
+f64 < i64
+f64 < i64 * i
+f64 < int(0.5)
+f64 < max(1, i64)
+f64 < min(1)
+f64 < min(f64)
+f64 < min(i64)
+f64 <= -0.5
+f64 <= -1
+f64 <= -f32
+f64 <= -i
+f64 <= -i32
+f64 <= 0.5 != ok
+f64 <= 0.5 - 1
+f64 <= 0.5 / 0.5
+f64 <= 0.5 == true
+f64 <= 0.5 ? foo : list
+f64 <= 0.5 ? nil : add
+f64 <= 1 != true
+f64 <= 1 ** 0.5
+f64 <= 1 + 0.5
+f64 <= 1 == false
+f64 <= 1 ? array : foo
+f64 <= 1 ^ i64
+f64 <= abs(f32)
+f64 <= abs(i)
+f64 <= array[i]
+f64 <= f32
+f64 <= f32 + f64
+f64 <= f32 - 0.5
+f64 <= f32 ? false : "foo"
+f64 <= f32 ? false : i
+f64 <= f32 ? i64 : false
+f64 <= f64
+f64 <= f64 + f64
+f64 <= f64 - 0.5
+f64 <= f64 - f64
+f64 <= f64 ^ 0.5
+f64 <= find(array, true)
+f64 <= float(f64)
+f64 <= half(0.5)
+f64 <= i
+f64 <= i * i32
+f64 <= i ? false : false
+f64 <= i ? foo : false
+f64 <= i32
+f64 <= i32 == true
+f64 <= i32 ? "bar" : nil
+f64 <= i32 ? add : ok
+f64 <= i32 ? i32 : false
+f64 <= i64
+f64 <= i64 % 1
+f64 <= i64 - f32
+f64 <= i64 - i64
+f64 <= i64 ^ 1
+f64 <= i64 and ok
+f64 <= int(1)
+f64 <= int(f64)
+f64 <= int(i)
+f64 <= max(f32)
+f64 <= min(0.5)
+f64 <= score(1)
+f64 == -0.5
+f64 == -1
+f64 == -f32
+f64 == -f64
+f64 == -i
+f64 == -i32
+f64 == 0.5 != ok
+f64 == 0.5 ** 0.5
+f64 == 0.5 ** i32
+f64 == 0.5 / i
+f64 == 0.5 / i32
+f64 == 0.5 ? i64 : div
+f64 == 1 * f64
+f64 == 1 == nil
+f64 == 1 ? false : "foo"
+f64 == abs(1)
+f64 == abs(i32)
+f64 == array[i32]
+f64 == array[i64]
+f64 == f32
+f64 == f32 + i64
+f64 == f32 - 1
+f64 == f32 / 0.5
+f64 == f64
+f64 == f64 ** i32
+f64 == f64 - 1
+f64 == f64 / 1
+f64 == float(0.5)
+f64 == float(i)
+f64 == get(array, i64)
+f64 == half(f64)
+f64 == i
+f64 == i ** f32
+f64 == i + 0.5
+f64 == i / i32
+f64 == i ? false : f32
+f64 == i ^ f32
+f64 == i32
+f64 == i32 * 1
+f64 == i32 + f64
+f64 == i32 / 1
+f64 == i32 ? greet : array
+f64 == i64
+f64 == i64 - f32
+f64 == i64 == true
+f64 == int(0.5)
+f64 == int(f32)
+f64 == min(0.5)
+f64 == min(i64)
+f64 == nil == ok
+f64 == nil ? i32 : div
+f64 == nil ? nil : 0.5
+f64 == score(1)
+f64 > -0.5
+f64 > -1
+f64 > -f32
+f64 > -f64
+f64 > -i
+f64 > -i32
+f64 > 0.5 - f64
+f64 > 0.5 / 0.5
+f64 > 0.5 ? 0.5 : nil
+f64 > 0.5 ? score(1, 1) : nil == nil
+f64 > 0.5 ^ 1
+f64 > 0.5 || ok
+f64 > 1 != ok
+f64 > 1 != true
+f64 > 1 % i
+f64 > 1 * 0.5
+f64 > 1 - 0.5
+f64 > 1 - i32
+f64 > 1 / 0.5
+f64 > 1 / f64
+f64 > 1 ? 0.5 : ok
+f64 > 1 ? false : true
+f64 > 1 ^ 1
+f64 > abs(0.5)
+f64 > abs(1)
+f64 > abs(i)
+f64 > abs(i32)
+f64 > count(array, true)
+f64 > f32
+f64 > f32 - 0.5
+f64 > f64
+f64 > f64 ** 0.5
+f64 > f64 ? f64 : list
+f64 > f64 ^ 0.5
+f64 > findIndex(array, ok)
+f64 > float(1)
+f64 > float(f32)
+f64 > half(0.5)
+f64 > i
+f64 > i != ok
+f64 > i ** i32
+f64 > i - i32
+f64 > i32
+f64 > i32 ** f32
+f64 > i32 - f32
+f64 > i32 == ok
+f64 > i32 ? i : 0.5
+f64 > i64
+f64 > i64 ** i64
+f64 > int(0.5)
+f64 > int(i64)
+f64 > max(0.5)
+f64 > max(i64)
+f64 > min(1)
+f64 > min(f64)
+f64 > min(i)
+f64 > min(i32)
+f64 > score(i)
+f64 >= -0.5
+f64 >= -1
+f64 >= -f64
+f64 >= -i32
+f64 >= -i64
+f64 >= 0.5 * 1
+f64 >= 0.5 ** 0.5
+f64 >= 0.5 ** i32
+f64 >= 0.5 + 0.5
+f64 >= 0.5 + i
+f64 >= 0.5 - i
+f64 >= 0.5 - i32
+f64 >= 0.5 ? nil : 0.5
+f64 >= 0.5 ^ 0.5
+f64 >= 1 * i
+f64 >= 1 - 0.5
+f64 >= 1 / i64
+f64 >= 1 == ok
+f64 >= 1 ^ 1
+f64 >= 1 || ok
+f64 >= abs(1)
+f64 >= abs(f32)
+f64 >= abs(f64)
+f64 >= count(list, true)
+f64 >= f32
+f64 >= f32 != true
+f64 >= f32 - f32
+f64 >= f32 ? true : nil
+f64 >= f64
+f64 >= f64 * 0.5
+f64 >= f64 ? nil : f64
+f64 >= f64 ? score : f32
+f64 >= half(f64)
+f64 >= i
+f64 >= i - 1
+f64 >= i32
+f64 >= i32 != nil
+f64 >= i32 ** 0.5
+f64 >= i32 + f32
+f64 >= i32 + i64
+f64 >= i32 ^ f32
+f64 >= i64
+f64 >= i64 * 0.5
+f64 >= i64 * f64
+f64 >= i64 * i64
+f64 >= i64 ? list : i >= f32
+f64 >= i64 ? ok : true
+f64 >= i64 || ok
+f64 >= max(f64)
+f64 >= min(0.5)
+f64 >= score(1)
+f64 >= score(i)
+f64 ^ (0.5 * 1)
+f64 ^ (0.5 * f32)
+f64 ^ (0.5 / i)
+f64 ^ (1 + i)
+f64 ^ (1 - f32)
+f64 ^ (1 / 0.5)
+f64 ^ (1 / i64)
+f64 ^ -1
+f64 ^ 0.5 != f32
+f64 ^ 0.5 * i64
+f64 ^ 0.5 + f64
+f64 ^ 0.5 < 0.5 ^ 0.5
+f64 ^ 0.5 <= i64
+f64 ^ 0.5 > i == nil
+f64 ^ 0.5 >= i32 / i64
+f64 ^ 1 != i
+f64 ^ 1 ** i
+f64 ^ 1 + i
+f64 ^ 1 / f32
+f64 ^ 1 / i64
+f64 ^ 1 <= i32
+f64 ^ 1 ^ i
+f64 ^ abs(i32)
+f64 ^ count(array, true)
+f64 ^ f32
+f64 ^ f32 != i32
+f64 ^ f32 * f32
+f64 ^ f32 ** i
+f64 ^ f32 + f64
+f64 ^ f32 / i64
+f64 ^ f32 < i
+f64 ^ f32 >= i64
+f64 ^ f32 ^ i64
+f64 ^ f64
+f64 ^ f64 != f32
+f64 ^ f64 * i
+f64 ^ f64 + int(0.5)
+f64 ^ float(i64)
+f64 ^ half(0.5)
+f64 ^ half(f64)
+f64 ^ i
+f64 ^ i ** i32
+f64 ^ i / i
+f64 ^ i <= f32
+f64 ^ i32
+f64 ^ i32 ** i
+f64 ^ i32 + f64
+f64 ^ i32 >= i
+f64 ^ i32 ^ f64
+f64 ^ i64
+f64 ^ i64 + i64
+f64 ^ i64 - i
+f64 ^ i64 < i
+f64 ^ i64 >= i32
+f64 ^ int(f64)
+f64 ^ last(array)
+f64 ^ len(list)
+f64 ^ max(0.5)
+f64 ^ score(1)
+false != true || 1 > f64
+false && ok or ok
+false ? "bar" : 0.5 == f32
+false ? "bar" : 1 != i
+false ? "bar" : foo.Qux
+false ? 0.5 : foo.Qux
+false ? 1 : half != div
+false ? 1 : true != ok
+false ? add : foo?.Bar
+false ? f32 : foo.Bar
+false ? f32 : foo?.String()
+false ? f32 : i .. i32
+false ? f64 : 0.5 >= f64
+false ? f64 : f32 / f32
+false ? false : 0.5 + i32
+false ? false : i64 >= i
+false ? foo : foo.Qux
+false ? greet : i64 != i
+false ? half : 0.5 > 1 + i64
+false ? half : f32 > min(0.5)
+false ? i : 1 != i
+false ? i32 : 1 >= f64
+false ? i64 : "foo" < toJSON(f64)
+false ? i64 : foo?.Qux
+false ? list : 1 < f32
+false ? list : f32 ** i32
+false ? list : foo.Bar
+false ? nil : 1 >= get(array, 1)
+false ? nil : foo?.Qux
+false ? ok : foo.String
+false ? score : 0.5 == i
+false ? score : 1 / i64
+false ? score : f64 - -f32
+false ? true : 0.5 == f32
+false or ok ? string(1) : f64 == f32
+filter(1 .. 1, # == 0.5)
+filter(1 .. i64, ok)
+filter([div], any(array, true))
+filter([i32, i], # <= f64)
+filter(array, !false)
+filter(array, !ok)
+filter(array, "bar" == "bar")
+filter(array, "bar" matches "bar")
+filter(array, "foo" not matches "bar")
+filter(array, # != #)
+filter(array, # != f64)
+filter(array, # != i)
+filter(array, # != i32)
+filter(array, # != i64)
+filter(array, # < #)
+filter(array, # < 1)
+filter(array, # < f32)
+filter(array, # < f64)
+filter(array, # < i)
+filter(array, # < i32)
+filter(array, # <= #)
+filter(array, # <= 0.5)
+filter(array, # <= 1)
+filter(array, # <= f64)
+filter(array, # <= i)
+filter(array, # <= i32)
+filter(array, # == #)
+filter(array, # == 1)
+filter(array, # == f32)
+filter(array, # == f64)
+filter(array, # == i)
+filter(array, # == nil)
+filter(array, # > #)
+filter(array, # > 1)
+filter(array, # > i)
+filter(array, # >= #)
+filter(array, # >= 1)
+filter(array, # >= f32)
+filter(array, # >= f64)
+filter(array, # >= i32)
+filter(array, # in array)
+filter(array, # not in array)
+filter(array, 0.5 != #)
+filter(array, 0.5 < #)
+filter(array, 0.5 < f32)
+filter(array, 0.5 < f64)
+filter(array, 0.5 == #)
+filter(array, 0.5 > 0.5)
+filter(array, 0.5 >= #)
+filter(array, 1 != #)
+filter(array, 1 != f32)
+filter(array, 1 < #)
+filter(array, 1 < f64)
+filter(array, 1 <= #)
+filter(array, 1 == #)
+filter(array, 1 > #)
+filter(array, 1 > 0.5)
+filter(array, add == div)
+filter(array, all(list, ok))
+filter(array, f32 != #)
+filter(array, f32 < i32)
+filter(array, f32 <= f32)
+filter(array, f32 == #)
+filter(array, f32 > 1)
+filter(array, f32 >= #)
+filter(array, f64 != #)
+filter(array, f64 != 0.5)
+filter(array, f64 <= #)
+filter(array, f64 == #)
+filter(array, f64 > #)
+filter(array, f64 >= 1)
+filter(array, foo == nil)
+filter(array, greet == add)
+filter(array, greet == half)
+filter(array, i <= 1)
+filter(array, i <= f64)
+filter(array, i == f32)
+filter(array, i >= 1)
+filter(array, i >= f64 != false)
+filter(array, i32 != #)
+filter(array, i32 <= #)
+filter(array, i32 == #)
+filter(array, i32 == 1)
+filter(array, i32 > # % #)
+filter(array, i32 > #)
+filter(array, i32 > 0.5)
+filter(array, i32 >= #)
+filter(array, i64 != #)
+filter(array, i64 < #)
+filter(array, i64 < 1)
+filter(array, i64 < i64)
+filter(array, i64 <= #)
+filter(array, i64 == 1)
+filter(array, nil != #)
+filter(array, nil != greet)
+filter(array, nil == #)
+filter(array, nil == f32)
+filter(array, nil in list)
+filter(array, none(array, ok))
+filter(array, ok)
+filter(array, score(#) != #)
+filter(array, true && ok)
+filter(array, true or false)
+filter(array, true)[i:i32]
+filter(filter(array, true), i >= f32)
+filter(filter(list, false), "bar" in #)
+filter(filter(list, ok), ok)
+filter(i .. 1, not ok)
+filter(i32 .. i32, nil == true)
+filter(i32 .. i64, ok)
+filter(list, !false)
+filter(list, !ok)
+filter(list, !true)
+filter(list, "bar" not in #)
+filter(list, "bar" not matches "foo")
+filter(list, "bar" startsWith "bar")
+filter(list, "foo" in #)
+filter(list, "foo" not in #)
+filter(list, # != #)
+filter(list, # != foo)
+filter(list, # != nil)
+filter(list, # == #)
+filter(list, # == foo)
+filter(list, # == nil)
+filter(list, 0.5 != f64)
+filter(list, 0.5 != i)
+filter(list, 0.5 > f32)
+filter(list, 1 != 0.5)
+filter(list, 1 != i32)
+filter(list, 1 != nil)
+filter(list, 1 < 0.5)
+filter(list, 1 < 1)
+filter(list, all(array, false))
+filter(list, all(array, true))
+filter(list, div == half)
+filter(list, f32 < 0.5)
+filter(list, f32 <= f32)
+filter(list, f32 == i64)
+filter(list, f32 >= 1)
+filter(list, f64 >= 0.5)
+filter(list, false == ok)
+filter(list, foo != #)
+filter(list, foo == #)
+filter(list, foo == foo)
+filter(list, foo in list)
+filter(list, greet != nil)
+filter(list, half != half)
+filter(list, i <= 0.5)
+filter(list, i <= i)
+filter(list, i == f32)
+filter(list, i == i32)
+filter(list, i == i64)
+filter(list, i >= i32)
+filter(list, i32 != 1)
+filter(list, i32 != nil)
+filter(list, i32 < i64)
+filter(list, i32 <= i32)
+filter(list, i32 == i)
+filter(list, i64 > f32)
+filter(list, nil != f64)
+filter(list, nil != score)
+filter(list, nil != true)
+filter(list, nil == #)
+filter(list, not ok)
+filter(list, ok or true)
+filter(list, ok || true)
+filter(list, ok)
+filter(list, true == nil)
+filter(map(array, "bar"), # >= #)
+filter(map(array, "foo"), ok)
+filter(map(array, #), # != 0.5)
+filter(map(array, #), ok)
+filter(map(array, 0.5 >= #), ok)
+filter(map(list, "bar"), i >= i)
+filter(map(list, "foo"), "bar" not matches #)
+filter(map(list, #), # != #)
+filter(map(list, #), ok)
+filter(map(list, 1), f32 != #)
+filter(map(list, false), #)
+filter(sort(array), ok)
+filter(split("foo", "bar"), ok)
+find(1 .. 1, # <= #)
+find([nil], 0.5 == 0.5)
+find([ok], #)
+find(array, !ok)
+find(array, !true)
+find(array, "bar" startsWith "foo")
+find(array, # != #)
+find(array, # != 0.5)
+find(array, # != f32)
+find(array, # != i32)
+find(array, # - # != #)
+find(array, # < #)
+find(array, # < 0.5)
+find(array, # < 1)
+find(array, # < f32)
+find(array, # < f64)
+find(array, # < i32)
+find(array, # <= #)
+find(array, # <= 0.5)
+find(array, # <= 1)
+find(array, # <= f32)
+find(array, # <= i)
+find(array, # == #)
+find(array, # == 0.5)
+find(array, # == 1)
+find(array, # == f32)
+find(array, # == f64)
+find(array, # == i)
+find(array, # == i32)
+find(array, # == nil)
+find(array, # > #)
+find(array, # > 0.5)
+find(array, # > i)
+find(array, # > i64)
+find(array, # >= #)
+find(array, # >= 1)
+find(array, # >= i)
+find(array, # >= i32)
+find(array, 0.5 < i64)
+find(array, 0.5 <= #)
+find(array, 0.5 == #)
+find(array, 0.5 > #)
+find(array, 0.5 > 1)
+find(array, 1 <= #)
+find(array, 1 <= 0.5)
+find(array, 1 == f32)
+find(array, 1 == i64)
+find(array, 1 > #)
+find(array, 1 > 0.5)
+find(array, 1 > i32)
+find(array, 1 > i64)
+find(array, 1 >= #)
+find(array, 1 >= i)
+find(array, add != div)
+find(array, add != nil)
+find(array, any(array, true))
+find(array, array == list)
+find(array, div == half)
+find(array, f32 <= #)
+find(array, f32 > #)
+find(array, f32 > 0.5)
+find(array, f32 >= #)
+find(array, f32 >= 1)
+find(array, f64 != #)
+find(array, f64 != i32)
+find(array, f64 != nil)
+find(array, f64 < #)
+find(array, f64 == nil)
+find(array, f64 >= 0.5)
+find(array, false == false)
+find(array, false) != i32
+find(array, i < #)
+find(array, i <= #)
+find(array, i == #)
+find(array, i > #)
+find(array, i >= #)
+find(array, i >= i64)
+find(array, i32 != #)
+find(array, i32 != 1)
+find(array, i32 < #)
+find(array, i32 <= #)
+find(array, i32 <= f32)
+find(array, i32 <= f64)
+find(array, i32 == #)
+find(array, i32 == 1)
+find(array, i32 == f64)
+find(array, i32 > #)
+find(array, i64 != #)
+find(array, i64 < #)
+find(array, nil != "bar")
+find(array, nil != #)
+find(array, nil == #)
+find(array, nil not in array)
+find(array, not false)
+find(array, not true)
+find(array, ok && ok)
+find(array, ok == nil)
+find(array, ok)
+find(array, ok) * f64
+find(array, ok) ** i64
+find(array, ok) ^ i32
+find(array, score(#) >= #)
+find(array, true) / get(array, i64)
+find(array, true) > i
+find(array, true) ^ i32
+find(filter(array, ok), # >= #)
+find(filter(array, true), # != #)
+find(i32 .. 1, # > 0.5)
+find(i64 .. 1, ok)
+find(list, !true)
+find(list, "bar" startsWith "foo")
+find(list, "foo" < "foo")
+find(list, "foo" in #)
+find(list, "foo" not in #)
+find(list, # != #)
+find(list, # == #)
+find(list, # == nil)
+find(list, # not in list)
+find(list, 0.5 < f64)
+find(list, 0.5 <= i64)
+find(list, 0.5 > i)
+find(list, 1 < 0.5)
+find(list, 1 <= 0.5)
+find(list, 1 > i)
+find(list, add == add)
+find(list, f32 != f32)
+find(list, f32 < f64)
+find(list, f32 <= f32)
+find(list, f32 <= i32)
+find(list, f32 == f32)
+find(list, f64 != f32)
+find(list, f64 <= i64)
+find(list, f64 >= f32)
+find(list, false)?.Bar
+find(list, foo != #)
+find(list, foo == #)
+find(list, i < 1)
+find(list, i >= f64)
+find(list, i32 <= f32)
+find(list, i64 != f64)
+find(list, i64 >= 0.5)
+find(list, list != array)
+find(list, nil != #)
+find(list, nil != greet)
+find(list, nil != half)
+find(list, nil != ok)
+find(list, nil == #)
+find(list, nil == half)
+find(list, nil == score)
+find(list, nil not in array)
+find(list, nil not in list)
+find(list, not ok)
+find(list, ok or ok)
+find(list, ok)
+find(list, ok).Bar
+find(list, ok).Qux
+find(list, ok).String
+find(list, ok)?.Qux
+find(list, ok)?.String
+find(list, score != add)
+find(list, score != greet)
+find(list, true).Bar
+find(list, true).Qux
+find(list, true).String
+find(list, true)?.Bar
+find(list, true)?.Qux
+find(list, true)?.String
+find(list, true)?.String()
+find(map(array, #), # == #)
+find(map(array, #), ok)
+find(map(array, i), ok)
+find(map(array, true), #)
+find(map(list, "foo"), ok)
+find(map(list, #), # != #)
+find(map(list, 0.5), # >= #)
+find(map(list, ok), ok)
+find(map(list, true), #)
+find(ok ? "bar" : 0.5, # != i32)
+find(sort(array), ok)
+find(true ? array : false, 0.5 > #)?.list
+findIndex(["bar"], ok)
+findIndex(["foo"], 0.5 > i64)
+findIndex(["foo"], ok)
+findIndex([1], # < #)
+findIndex([f64, greet], 1 > f64)
+findIndex([false], #)
+findIndex(array, !(# != #))
+findIndex(array, !(# == 1))
+findIndex(array, !false)
+findIndex(array, !ok)
+findIndex(array, !true)
+findIndex(array, "bar" not endsWith "bar")
+findIndex(array, "bar" not startsWith "foo")
+findIndex(array, # != #)
+findIndex(array, # != 0.5)
+findIndex(array, # != f32)
+findIndex(array, # != f64)
+findIndex(array, # != i32)
+findIndex(array, # != i64)
+findIndex(array, # != nil)
+findIndex(array, # ** # > #)
+findIndex(array, # < #)
+findIndex(array, # < 1)
+findIndex(array, # < f64)
+findIndex(array, # < i)
+findIndex(array, # < i32)
+findIndex(array, # < i64)
+findIndex(array, # <= #)
+findIndex(array, # <= 1)
+findIndex(array, # <= i)
+findIndex(array, # <= i32)
+findIndex(array, # == #)
+findIndex(array, # == 1)
+findIndex(array, # == f64)
+findIndex(array, # == i32)
+findIndex(array, # > #)
+findIndex(array, # > 0.5)
+findIndex(array, # > 1)
+findIndex(array, # > f32)
+findIndex(array, # > f64)
+findIndex(array, # > i64 - i)
+findIndex(array, # > i64)
+findIndex(array, # >= #)
+findIndex(array, # >= 1)
+findIndex(array, # >= f32)
+findIndex(array, # >= i)
+findIndex(array, # >= i32)
+findIndex(array, # in array)
+findIndex(array, # not in array)
+findIndex(array, 0.5 < #)
+findIndex(array, 0.5 <= 1)
+findIndex(array, 0.5 <= f32)
+findIndex(array, 0.5 == #)
+findIndex(array, 0.5 > i64)
+findIndex(array, 0.5 >= #)
+findIndex(array, 0.5 >= i)
+findIndex(array, 1 != #)
+findIndex(array, 1 < #)
+findIndex(array, 1 < f32)
+findIndex(array, 1 < i64)
+findIndex(array, 1 <= #)
+findIndex(array, 1 == #)
+findIndex(array, 1 > #)
+findIndex(array, 1 >= #)
+findIndex(array, add != half)
+findIndex(array, any(array, f32 < #))
+findIndex(array, f32 <= #)
+findIndex(array, f32 == #)
+findIndex(array, f32 == nil)
+findIndex(array, f32 > #)
+findIndex(array, f32 >= #)
+findIndex(array, f64 <= #)
+findIndex(array, f64 <= i64)
+findIndex(array, f64 == #)
+findIndex(array, f64 > #)
+findIndex(array, f64 >= #)
+findIndex(array, f64 >= 1)
+findIndex(array, half != greet)
+findIndex(array, i != #)
+findIndex(array, i < 0.5)
+findIndex(array, i <= #)
+findIndex(array, i <= i32)
+findIndex(array, i == #)
+findIndex(array, i == i)
+findIndex(array, i > #)
+findIndex(array, i >= i)
+findIndex(array, i32 != #)
+findIndex(array, i32 < #)
+findIndex(array, i32 < f64)
+findIndex(array, i32 < i)
+findIndex(array, i32 <= #)
+findIndex(array, i32 == #)
+findIndex(array, i32 == nil)
+findIndex(array, i32 > #)
+findIndex(array, i64 != #)
+findIndex(array, i64 == #)
+findIndex(array, i64 > #)
+findIndex(array, i64 >= #)
+findIndex(array, nil != #)
+findIndex(array, nil != 1)
+findIndex(array, nil != list)
+findIndex(array, nil == foo)
+findIndex(array, nil == i)
+findIndex(array, not ok)
+findIndex(array, ok)
+findIndex(array, ok) * f64
+findIndex(array, ok) - i32
+findIndex(array, ok) / f64
+findIndex(array, ok) >= f64
+findIndex(array, score == greet)
+findIndex(array, true or false)
+findIndex(false ? div : list, ok)
+findIndex(list, !false)
+findIndex(list, !true)
+findIndex(list, "bar" == "bar")
+findIndex(list, "foo" != "bar")
+findIndex(list, "foo" contains "bar")
+findIndex(list, "foo" matches "bar")
+findIndex(list, # != #)
+findIndex(list, # != foo)
+findIndex(list, # != nil)
+findIndex(list, # == #)
+findIndex(list, # == nil)
+findIndex(list, # in list)
+findIndex(list, 0.5 < i)
+findIndex(list, 0.5 <= f64)
+findIndex(list, 0.5 <= i64)
+findIndex(list, 0.5 > f64)
+findIndex(list, 0.5 >= f32)
+findIndex(list, 1 == nil)
+findIndex(list, array != list)
+findIndex(list, f32 < f64)
+findIndex(list, f64 <= f32)
+findIndex(list, f64 <= f64)
+findIndex(list, f64 == nil)
+findIndex(list, f64 > f64)
+findIndex(list, false && true)
+findIndex(list, foo != #)
+findIndex(list, foo == #)
+findIndex(list, greet != half)
+findIndex(list, half == add)
+findIndex(list, i32 == i)
+findIndex(list, i32 > f64)
+findIndex(list, i32 >= i32)
+findIndex(list, i64 < 0.5)
+findIndex(list, i64 > f64)
+findIndex(list, nil != #)
+findIndex(list, nil != f64)
+findIndex(list, nil != false)
+findIndex(list, nil == #)
+findIndex(list, nil == 0.5)
+findIndex(list, nil == ok)
+findIndex(list, nil in list)
+findIndex(list, not false)
+findIndex(list, not ok)
+findIndex(list, ok != ok)
+findIndex(list, ok or ok)
+findIndex(list, ok)
+findIndex(list, ok) + f32
+findIndex(list, ok) / i
+findIndex(list, ok) > i32
+findIndex(list, one(list, ok))
+findIndex(list, true ? true : true)
+findIndex(list, true) .. i
+findIndex(list, true) == 0.5 ^ i32
+findIndex(list, true) > i32 ** f32
+findIndex(list, true) not in array
+findIndex(map(array, #), # > #)
+findIndex(map(array, #), # >= f32)
+findIndex(map(array, 1), # != #)
+findIndex(map(array, add), i64 >= i64)
+findIndex(map(array, div), # == #)
+findIndex(map(array, false), #)
+findIndex(map(array, i64), ok)
+findIndex(map(list, #), !ok)
+findIndex(map(list, #), div == div)
+findIndex(map(list, #), ok)
+findIndex(map(list, f32), i32 == f64)
+findIndex(map(list, list), ok)
+findIndex(map(list, ok), # == ok)
+findIndex(sort(array), # < #)
+findIndex(true ? "bar" : i32, # < #)
+findIndex(true ? "bar" : true, ok)
+findLast([0.5], i64 != 0.5)
+findLast(array, !false)
+findLast(array, !true)
+findLast(array, "bar" > "bar")
+findLast(array, "foo" startsWith "foo")
+findLast(array, # != #)
+findLast(array, # != f64)
+findLast(array, # != nil)
+findLast(array, # < #)
+findLast(array, # < 0.5)
+findLast(array, # < 1)
+findLast(array, # < f32)
+findLast(array, # < f64)
+findLast(array, # < i)
+findLast(array, # <= #)
+findLast(array, # <= 0.5)
+findLast(array, # <= 1)
+findLast(array, # <= f32)
+findLast(array, # <= f64)
+findLast(array, # <= i)
+findLast(array, # <= i64)
+findLast(array, # == #)
+findLast(array, # == 0.5)
+findLast(array, # == f64)
+findLast(array, # == i64)
+findLast(array, # > #)
+findLast(array, # > 0.5)
+findLast(array, # > i)
+findLast(array, # > i32)
+findLast(array, # > i64)
+findLast(array, # >= #)
+findLast(array, # >= 0.5)
+findLast(array, # >= f64)
+findLast(array, # >= i)
+findLast(array, # >= i32)
+findLast(array, # not in array)
+findLast(array, 0.5 != #)
+findLast(array, 0.5 != 0.5)
+findLast(array, 0.5 != i)
+findLast(array, 0.5 < #)
+findLast(array, 0.5 < i64)
+findLast(array, 0.5 <= #)
+findLast(array, 0.5 == #)
+findLast(array, 0.5 > 0.5)
+findLast(array, 0.5 >= 1)
+findLast(array, 0.5 >= f64)
+findLast(array, 1 != #)
+findLast(array, 1 != i64)
+findLast(array, 1 < #)
+findLast(array, 1 <= #)
+findLast(array, 1 <= 0.5)
+findLast(array, 1 <= f32)
+findLast(array, 1 == #)
+findLast(array, 1 == nil)
+findLast(array, 1 > #)
+findLast(array, 1 >= #)
+findLast(array, 1 >= 1)
+findLast(array, add != greet)
+findLast(array, array == array)
+findLast(array, div != score)
+findLast(array, f32 != nil)
+findLast(array, f32 < #)
+findLast(array, f32 >= #)
+findLast(array, f32 >= 1)
+findLast(array, f64 != i)
+findLast(array, f64 < i64)
+findLast(array, f64 >= #)
+findLast(array, foo != nil)
+findLast(array, half == nil)
+findLast(array, i != i32)
+findLast(array, i < #)
+findLast(array, i <= #)
+findLast(array, i >= #)
+findLast(array, i32 != #)
+findLast(array, i32 <= f32)
+findLast(array, i32 == 1)
+findLast(array, i32 > #)
+findLast(array, i32 >= #)
+findLast(array, i32 >= 0.5)
+findLast(array, i64 != #)
+findLast(array, i64 != 1)
+findLast(array, i64 < #)
+findLast(array, i64 <= #)
+findLast(array, i64 <= 0.5)
+findLast(array, i64 == #)
+findLast(array, i64 == nil)
+findLast(array, i64 >= #)
+findLast(array, i64 >= i32)
+findLast(array, nil != #)
+findLast(array, nil != nil)
+findLast(array, nil == #)
+findLast(array, nil == nil)
+findLast(array, not false)
+findLast(array, not true)
+findLast(array, ok)
+findLast(array, ok) < f64
+findLast(array, true) + i
+findLast(array, true) + i32
+findLast(array, true) <= f64
+findLast(array, true) > i
+findLast(i .. 1, # > f32)
+findLast(i32 .. 1, # >= #)
+findLast(i32 .. i32, ok)
+findLast(i64 .. 1, f32 <= #)
+findLast(list, !true)
+findLast(list, "bar" in #)
+findLast(list, "bar" not contains "bar")
+findLast(list, "bar" not in #)
+findLast(list, "bar" not matches "bar")
+findLast(list, "foo" == "foo")
+findLast(list, "foo" > "foo")
+findLast(list, "foo" in #)
+findLast(list, "foo" not in #)
+findLast(list, # != #)
+findLast(list, # == #)
+findLast(list, # == foo)
+findLast(list, # == nil)
+findLast(list, # not in list)
+findLast(list, 0.5 == nil)
+findLast(list, 0.5 > f32)
+findLast(list, 1 != 0.5)
+findLast(list, 1 != 1)
+findLast(list, 1 <= i)
+findLast(list, 1 > 1)
+findLast(list, 1 > i)
+findLast(list, 1 >= 0.5)
+findLast(list, 1 >= 1)
+findLast(list, add == nil)
+findLast(list, all(list, false))
+findLast(list, f32 < f64)
+findLast(list, false)?.Bar
+findLast(list, foo != #)?.Bar
+findLast(list, foo == #)
+findLast(list, greet == half)
+findLast(list, i != 1)
+findLast(list, i != i64)
+findLast(list, i >= f32)
+findLast(list, i32 == 1)
+findLast(list, i64 <= 0.5)
+findLast(list, i64 <= i)
+findLast(list, i64 == i32)
+findLast(list, i64 > 0.5)
+findLast(list, i64 > i)
+findLast(list, i64 >= i32)
+findLast(list, nil != "bar")
+findLast(list, nil != #)
+findLast(list, nil != add)
+findLast(list, nil != false)
+findLast(list, nil != foo)
+findLast(list, nil != nil)
+findLast(list, nil != ok)
+findLast(list, nil == #)
+findLast(list, nil == i32)
+findLast(list, nil == i64)
+findLast(list, nil == list)
+findLast(list, nil == nil)
+findLast(list, not ok)
+findLast(list, ok ? ok : nil)
+findLast(list, ok)
+findLast(list, ok).Bar
+findLast(list, ok).Qux
+findLast(list, ok).String
+findLast(list, ok).String()
+findLast(list, ok)?.Bar
+findLast(list, ok)?.Qux
+findLast(list, ok)?.String
+findLast(list, one(list, true))
+findLast(list, true != nil)
+findLast(list, true).Bar
+findLast(list, true).Qux
+findLast(list, true).String
+findLast(list, true)?.Bar
+findLast(list, true)?.Qux
+findLast(list, true)?.String
+findLast(map(array, #), # > f32)
+findLast(map(array, #), # >= #)
+findLast(map(array, #), i32 == #)
+findLast(map(array, #), ok)
+findLast(map(array, f64), # <= #)
+findLast(map(array, i), # <= #)
+findLast(map(array, ok), #)
+findLast(map(array, ok), not #)
+findLast(map(array, true), #)
+findLast(map(list, #), # != #)
+findLast(map(list, array), # == #)
+findLast(map(list, i), # >= #)
+findLast(map(list, list), ok)
+findLast(map(list, score), 0.5 > f32)
+findLast(ok ? array : div, # >= #)
+findLast(sort(array), # && false)
+findLastIndex([i32], # >= 0.5)
+findLastIndex(array, !false)
+findLastIndex(array, !ok)
+findLastIndex(array, !true)
+findLastIndex(array, "bar" != "bar")
+findLastIndex(array, # != #)
+findLastIndex(array, # != 0.5)
+findLastIndex(array, # != i64)
+findLastIndex(array, # != nil)
+findLastIndex(array, # / f32 == #)
+findLastIndex(array, # < # ** i32)
+findLastIndex(array, # < #)
+findLastIndex(array, # < 0.5)
+findLastIndex(array, # < 1)
+findLastIndex(array, # < f32)
+findLastIndex(array, # < f64)
+findLastIndex(array, # < i)
+findLastIndex(array, # < i64)
+findLastIndex(array, # <= #)
+findLastIndex(array, # <= 0.5)
+findLastIndex(array, # <= 1)
+findLastIndex(array, # <= f32)
+findLastIndex(array, # <= f64)
+findLastIndex(array, # <= i)
+findLastIndex(array, # <= i32)
+findLastIndex(array, # <= i64)
+findLastIndex(array, # == #)
+findLastIndex(array, # == 0.5)
+findLastIndex(array, # == 1)
+findLastIndex(array, # == i32)
+findLastIndex(array, # == nil)
+findLastIndex(array, # > #)
+findLastIndex(array, # > 0.5)
+findLastIndex(array, # > 1)
+findLastIndex(array, # > i)
+findLastIndex(array, # > i64)
+findLastIndex(array, # >= #)
+findLastIndex(array, # >= 1)
+findLastIndex(array, # >= f64)
+findLastIndex(array, # in array)
+findLastIndex(array, # not in array)
+findLastIndex(array, 0.5 != #)
+findLastIndex(array, 0.5 != 0.5)
+findLastIndex(array, 0.5 < #)
+findLastIndex(array, 0.5 < i)
+findLastIndex(array, 0.5 <= #)
+findLastIndex(array, 0.5 <= 0.5)
+findLastIndex(array, 0.5 == #)
+findLastIndex(array, 0.5 > #)
+findLastIndex(array, 0.5 > i)
+findLastIndex(array, 0.5 >= #)
+findLastIndex(array, 0.5 >= f32)
+findLastIndex(array, 1 != #)
+findLastIndex(array, 1 < #)
+findLastIndex(array, 1 <= #)
+findLastIndex(array, 1 <= i)
+findLastIndex(array, 1 <= i64)
+findLastIndex(array, 1 == #)
+findLastIndex(array, 1 > #)
+findLastIndex(array, 1 > 1)
+findLastIndex(array, 1 >= #)
+findLastIndex(array, 1 in array)
+findLastIndex(array, add != add)
+findLastIndex(array, any(list, false))
+findLastIndex(array, f32 != #)
+findLastIndex(array, f32 < #)
+findLastIndex(array, f32 <= f64)
+findLastIndex(array, f32 == f64)
+findLastIndex(array, f32 > #)
+findLastIndex(array, f32 >= f64)
+findLastIndex(array, f64 != #)
+findLastIndex(array, f64 < #)
+findLastIndex(array, f64 == #)
+findLastIndex(array, f64 > i)
+findLastIndex(array, f64 >= #)
+findLastIndex(array, i == #)
+findLastIndex(array, i > #)
+findLastIndex(array, i > 1)
+findLastIndex(array, i >= #)
+findLastIndex(array, i32 != #)
+findLastIndex(array, i32 < #)
+findLastIndex(array, i32 <= 0.5)
+findLastIndex(array, i32 == #)
+findLastIndex(array, i32 == i32)
+findLastIndex(array, i32 > #)
+findLastIndex(array, i64 != #)
+findLastIndex(array, i64 != f32)
+findLastIndex(array, i64 >= #)
+findLastIndex(array, list != nil)
+findLastIndex(array, nil != "foo")
+findLastIndex(array, nil != #)
+findLastIndex(array, nil != 0.5)
+findLastIndex(array, nil != foo)
+findLastIndex(array, nil != nil)
+findLastIndex(array, nil == #)
+findLastIndex(array, nil == i)
+findLastIndex(array, nil not in list)
+findLastIndex(array, none(array, true))
+findLastIndex(array, not (# != #))
+findLastIndex(array, not false)
+findLastIndex(array, ok)
+findLastIndex(array, ok) * f64
+findLastIndex(array, ok) / i64
+findLastIndex(array, ok) <= i64
+findLastIndex(array, ok) ^ f32
+findLastIndex(array, true ? ok : 1)
+findLastIndex(array, true) / f32
+findLastIndex(array, true) <= i64
+findLastIndex(array, true) > f64
+findLastIndex(false ? i : "bar", ok)
+findLastIndex(filter(list, true), ok)
+findLastIndex(i .. i32, # == 1)
+findLastIndex(i32 .. i, ok)
+findLastIndex(i32 .. i64, f64 == nil)
+findLastIndex(i64 .. 1, # != nil)
+findLastIndex(i64 .. 1, add == nil)
+findLastIndex(list, !ok)
+findLastIndex(list, !true)
+findLastIndex(list, "bar" in #)
+findLastIndex(list, "foo" matches "bar")
+findLastIndex(list, # != #)
+findLastIndex(list, # != foo)
+findLastIndex(list, # != nil)
+findLastIndex(list, # == #)
+findLastIndex(list, # == nil)
+findLastIndex(list, # in list)
+findLastIndex(list, 0.5 != i)
+findLastIndex(list, 0.5 <= 0.5)
+findLastIndex(list, 0.5 <= f32)
+findLastIndex(list, 1 != 0.5)
+findLastIndex(list, 1 != f64)
+findLastIndex(list, 1 != i64)
+findLastIndex(list, 1 < i32)
+findLastIndex(list, 1 <= f32)
+findLastIndex(list, 1 <= i)
+findLastIndex(list, array != list)
+findLastIndex(list, array != nil)
+findLastIndex(list, array == list)
+findLastIndex(list, div == add)
+findLastIndex(list, div == score)
+findLastIndex(list, f32 != 0.5)
+findLastIndex(list, f32 < f64)
+findLastIndex(list, f32 < i32)
+findLastIndex(list, f32 <= i64)
+findLastIndex(list, f32 == i32)
+findLastIndex(list, f32 > f32)
+findLastIndex(list, f64 <= 1)
+findLastIndex(list, f64 == f64)
+findLastIndex(list, false == false)
+findLastIndex(list, false and false)
+findLastIndex(list, false and ok)
+findLastIndex(list, false) != i
+findLastIndex(list, foo != #)
+findLastIndex(list, foo == foo)
+findLastIndex(list, greet != half)
+findLastIndex(list, greet == nil)
+findLastIndex(list, half != nil)
+findLastIndex(list, i < i64)
+findLastIndex(list, i <= i)
+findLastIndex(list, i32 != nil)
+findLastIndex(list, i32 < f64)
+findLastIndex(list, i32 <= i32)
+findLastIndex(list, i32 >= 0.5)
+findLastIndex(list, i32 >= i)
+findLastIndex(list, i64 < f64)
+findLastIndex(list, i64 == f32)
+findLastIndex(list, i64 >= i)
+findLastIndex(list, i64 not in array)
+findLastIndex(list, nil != #)
+findLastIndex(list, nil == #)
+findLastIndex(list, none(array, ok))
+findLastIndex(list, not ok)
+findLastIndex(list, not true)
+findLastIndex(list, ok != nil)
+findLastIndex(list, ok)
+findLastIndex(list, ok) ** f32
+findLastIndex(list, ok) ** f64
+findLastIndex(list, ok) - i
+findLastIndex(list, ok) >= i64
+findLastIndex(list, true == nil)
+findLastIndex(list, true) ** i64
+findLastIndex(list, true) + i
+findLastIndex(list, true) .. i64
+findLastIndex(list, true) < i
+findLastIndex(list, true) > f32
+findLastIndex(list, true) >= f32
+findLastIndex(list, true) in array
+findLastIndex(map(array, "foo"), # == #)
+findLastIndex(map(array, #), i < #)
+findLastIndex(map(array, #), nil != half)
+findLastIndex(map(array, #), ok)
+findLastIndex(map(array, 0.5), ok)
+findLastIndex(map(array, array), 1 != i)
+findLastIndex(map(array, false), #)
+findLastIndex(map(array, true), #)
+findLastIndex(map(list, #), !ok)
+findLastIndex(map(list, #), 0.5 < f32)
+findLastIndex(map(list, 0.5), # <= #)
+findLastIndex(map(list, f32), # == #)
+findLastIndex(map(list, f32), # >= #)
+findLastIndex(map(list, f32), ok)
+findLastIndex(map(list, false), #)
+findLastIndex(map(list, half), ok)
+findLastIndex(map(list, ok), # or #)
+findLastIndex(map(list, ok), #)
+findLastIndex(sort(array), ok)
+first(1 .. i)
+first(1 .. i32)
+first([f32])
+first([f64])
+first([false, list])
+first([i64, nil])
+first([list, i32])
+first([not false])
+first(array)
+first(array) * i
+first(array) ** i32
+first(array) ** i64
+first(array) + i32
+first(array) / 1 * 0.5
+first(array) <= i32
+first(array) <= i64
+first(array) == i64
+first(array) > i32
+first(array) > i64
+first(array) in array
+first(false ? f64 : true)
+first(false ? greet : i)
+first(filter(array, false))
+first(filter(list, ok))
+first(i .. 1)
+first(i .. i)
+first(i .. i32)
+first(i32 .. 1)
+first(i32 .. i)
+first(i32 .. i64)
+first(i64 .. i32)
+first(list)
+first(list) not in list
+first(list).Bar
+first(list).Qux
+first(list).String
+first(list).String()
+first(list)?.Bar
+first(list)?.Qux
+first(list)?.String
+first(list)?.String()
+first(map(array, "bar"))
+first(map(array, #))
+first(map(array, 0.5))
+first(map(array, 1))
+first(map(array, add))
+first(map(array, f32))
+first(map(array, f64))
+first(map(array, foo))
+first(map(array, greet))
+first(map(array, half))
+first(map(array, i))
+first(map(array, list))
+first(map(array, ok))
+first(map(array, score))
+first(map(list, #))
+first(map(list, 0.5))
+first(map(list, add))
+first(map(list, array))
+first(map(list, div))
+first(map(list, f32))
+first(map(list, f64))
+first(map(list, i32))
+first(map(list, list))
+first(map(list, score))
+first(ok ? "bar" : 0.5)
+first(ok ? 1 : "foo")
+first(ok ? add : f32)
+first(ok ? array : "bar")
+first(ok ? list : nil)
+first(ok ? ok : array)
+first(ok ? ok : foo)
+first(ok ? ok : score)
+first(sort(array))
+first(true ? 0.5 : i64)
+first(true ? add : ok)
+first(true ? array : false)
+first(true ? ok : div)
+float(-(1 / i32))
 float(-0.5)
 float(-1)
-float(-2)
-float(-a)
-float(-add(b, a))
-float(-b)
-float(-f)
-float(0 * a)
-float(0 * b)
-float(0 * f)
-float(0 ** 0)
-float(0 + 2)
-float(0 + b)
-float(0 - 0.5)
-float(0 - b)
-float(0 - f)
-float(0 / b)
-float(0 / f)
-float(0 ^ 0)
-float(0 ^ 0.5)
-float(0 ^ a)
-float(0 ^ f)
-float(0) != b ** a
-float(0) - f
-float(0) - obj.a
-float(0) == b
-float(0.5 * b)
-float(0.5 * f)
+float(-f32)
+float(-f64)
+float(-i)
+float(-i32)
+float(-i64)
+float(0.5 * 0.5)
+float(0.5 * f32)
+float(0.5 * i)
+float(0.5 * i32)
+float(0.5 * i64)
+float(0.5 ** 0.5)
+float(0.5 ** 1)
+float(0.5 ** f32)
+float(0.5 ** i32)
+float(0.5 + 1)
+float(0.5 + f32)
+float(0.5 + i)
+float(0.5 + i64)
 float(0.5 - 0.5)
-float(0.5 - a)
-float(0.5 - b)
+float(0.5 - 1)
+float(0.5 - f32)
+float(0.5 - i)
+float(0.5 - i32)
+float(0.5 - i64)
+float(0.5 / 0.5)
+float(0.5 / 1)
+float(0.5 / f32)
+float(0.5 / f64)
+float(0.5 / i)
+float(0.5 ^ 0.5)
 float(0.5 ^ 1)
-float(0.5 ^ f)
-float(0.5) != a + a
-float(0.5) * obj?.head(0.5)
-float(0.5) ** (0 - 0)
-float(0.5) / b ** 0
-float(0.5) <= a
-float(0.5) >= b
-float(0.5) >= f / 0
-float(1 % a)
+float(0.5 ^ f64)
+float(0.5 ^ i32)
+float(0.5 ^ i64)
+float(0.5) != i32
+float(0.5) ** (1 % 1)
+float(0.5) + 0.5 - f64
+float(0.5) + f32
+float(0.5) + i32
+float(0.5) - -f32
+float(0.5) - f32
+float(0.5) / f32
+float(0.5) < i32
+float(0.5) >= i32
+float(1 % 1)
+float(1 % i)
+float(1 % i32)
+float(1 % i64)
+float(1 * 0.5)
+float(1 * 1)
+float(1 * i)
+float(1 * i32)
+float(1 * i64)
+float(1 ** 0.5)
+float(1 ** i)
+float(1 + 0.5)
+float(1 + 1)
+float(1 + f32)
+float(1 + f64)
+float(1 + i)
+float(1 - 0.5)
 float(1 - 1)
-float(1 - a)
-float(1 - b)
-float(1 - f)
-float(1) + a
-float(1) > a
-float(2 % a)
-float(2 ** b)
-float(2 + b)
-float(2 + f)
-float(2 / f)
-float(2 ^ 0)
-float(2 ^ 0.5)
-float(2) ** obj?.head(0, 0, "a", 0.5, obj)
-float(2) - obj?.a
-float(2) < float(b)
-float(2) <= a
-float(2) > b
-float(2) > f
-float(2) ^ b
-float(a % a)
-float(a % b)
-float(a * 0)
-float(a * 2)
-float(a * a)
-float(a * b)
-float(a ** 1)
-float(a ** f)
-float(a + 0)
-float(a + 2)
-float(a + a)
-float(a + b)
-float(a + f)
-float(a - 0)
-float(a - a)
-float(a - b)
-float(a - f)
-float(a / 0)
-float(a / a)
-float(a / b)
-float(a ^ 1)
-float(a ^ a)
-float(a ^ b)
-float(a ^ f)
-float(a)
-float(a) != add(a, a)
-float(a) ** f
-float(a) + a
-float(a) - a
-float(a) / obj?.head(f)
-float(a) < a
-float(a) < f
-float(a) <= obj.a
-float(a) > f
-float(a) >= -0
-float(abs(a))
-float(abs(b))
-float(abs(f))
-float(add(0, a))
-float(add(1, b))
-float(add(2, a))
-float(add(2, b))
-float(add(a, 0))
-float(add(a, 2))
-float(add(a, a))
-float(add(a, b))
-float(add(b, 0))
-float(add(b, a))
-float(add(b, b))
-float(arr[a])
-float(arr[b])
-float(b % b)
-float(b * 0)
-float(b * a)
-float(b * b)
-float(b ** a)
-float(b ** b)
-float(b + 0)
-float(b + f)
-float(b - 0)
-float(b - b)
-float(b / a)
-float(b ^ 0.5)
-float(b ^ a)
-float(b ^ b)
-float(b)
-float(b) * a
-float(b) * b
-float(b) ** (a / 0.5)
-float(b) + a
-float(b) + b
-float(b) + obj?.a
-float(b) - b
-float(b) - f
-float(b) / a - obj?.b
-float(b) == a
-float(count(arr, ok))
-float(div(0, a))
-float(div(0, b))
-float(div(1, a))
-float(div(2, a))
-float(div(a, a))
-float(div(b, 1))
-float(div(b, b))
-float(f * 0)
-float(f * a)
-float(f * b)
-float(f * f)
-float(f ** 0)
-float(f ** b)
-float(f ** f)
-float(f + 0)
-float(f + a)
-float(f + obj.a)
-float(f - 0)
-float(f - a)
-float(f - b)
-float(f - f)
-float(f / a)
-float(f / f)
-float(f ^ a)
-float(f)
-float(f) * a
-float(f) + f
-float(f) + obj.a
-float(f) / a
-float(f) < a ^ b
-float(f) > a
-float(f) >= b
-float(f) ^ obj.b
-float(false ? obj : b)
-float(false ? ok : b)
-float(first(arr))
+float(1 - f32)
+float(1 - i)
+float(1 / 0.5)
+float(1 / 1)
+float(1 / f64)
+float(1 / i)
+float(1 ^ 1)
+float(1 ^ f32)
+float(1 ^ f64)
+float(1 ^ i)
+float(1 ^ i32)
+float(1 ^ i64)
+float(1) != abs(f32)
+float(1) != {"foo": i32}?.add
+float(1) ** i64
+float(1) - i64
+float(1) / i
+float(1) / i64
+float(1) < i32
+float(1) <= i64
+float(1) == int(0.5)
+float(1) > i
+float(1) >= f32
+float(1) >= i - i
+float(abs(0.5))
+float(abs(1))
+float(abs(f32))
+float(abs(i))
+float(abs(i32))
+float(abs(i64))
+float(add(i, 1))
+float(array[1])
+float(array[i32])
+float(array[i64])
+float(array[i])
+float(count(array, true))
+float(count(list, false) * (i - 1))
+float(count(list, false))
+float(div(1, i))
+float(div(i, 1))
+float(f32 * 0.5)
+float(f32 * f32)
+float(f32 * i32)
+float(f32 * i64)
+float(f32 ** 0.5)
+float(f32 ** 1)
+float(f32 ** i)
+float(f32 ** i64)
+float(f32 + 0.5)
+float(f32 + 1)
+float(f32 + f32)
+float(f32 + i32)
+float(f32 - 0.5)
+float(f32 - 1)
+float(f32 - f64)
+float(f32 - i)
+float(f32 / 0.5)
+float(f32 / 1)
+float(f32 / f32)
+float(f32 / i)
+float(f32 / i64)
+float(f32 ^ 0.5)
+float(f32 ^ f32)
+float(f32 ^ f64)
+float(f32 ^ i64)
+float(f32)
+float(f32) * f32
+float(f32) + f32
+float(f32) - f32
+float(f32) - f64
+float(f32) - i64
+float(f32) / f64
+float(f32) < i32
+float(f32) <= f32
+float(f32) >= f32
+float(f32) >= f32 ** f32
+float(f32) ^ f64
+float(f32) ^ i32
+float(f64 * 0.5)
+float(f64 * f32)
+float(f64 * i)
+float(f64 * i32)
+float(f64 ** 1)
+float(f64 ** f32)
+float(f64 + 0.5)
+float(f64 + 1)
+float(f64 + i)
+float(f64 - 0.5)
+float(f64 - i)
+float(f64 - i32)
+float(f64 - i32) / i
+float(f64 / -i32)
+float(f64 / 1)
+float(f64 / f32)
+float(f64 / i32)
+float(f64 ^ 0.5)
+float(f64 ^ 1)
+float(f64 ^ f32)
+float(f64 ^ f64)
+float(f64)
+float(f64) != int(i32)
+float(f64) * i32
+float(f64) / f32
+float(f64) / f64
+float(f64) / i64
+float(f64) < i
+float(f64) < i32
+float(f64) <= f32
+float(f64) <= i64
+float(f64) == i32
+float(f64) > i32
+float(f64) >= f64
+float(f64) >= i
+float(f64) >= i32
+float(f64) ^ i
+float(false ? div : i32)
+float(false ? f32 : 0.5)
+float(find(array, ok))
+float(find(array, true))
+float(findIndex(list, true))
+float(findLast(array, ok))
+float(findLast(array, true))
+float(first(array))
 float(float(0.5))
 float(float(1))
-float(float(2))
-float(float(a))
-float(float(b))
-float(float(f))
-float(get(arr, 0))
-float(get(arr, a))
-float(get(arr, b))
+float(float(f32))
+float(float(f64))
+float(float(i))
+float(float(i32))
+float(float(i64))
+float(get(array, 1))
+float(get(array, i))
+float(get(array, i64))
+float(half(-f64))
+float(half(0.5))
+float(half(f64))
+float(i % 1)
+float(i * 0.5)
+float(i * 1)
+float(i * f64)
+float(i * i)
+float(i * i32 * i32)
+float(i * i32)
+float(i * i64)
+float(i ** 1)
+float(i ** f64)
+float(i ** i32)
+float(i + 0.5)
+float(i + f64)
+float(i + i64)
+float(i - 0.5)
+float(i - 1)
+float(i - findIndex(array, true))
+float(i / 1)
+float(i / f64)
+float(i / i64)
+float(i ^ f32)
+float(i ^ f64)
+float(i ^ i64)
+float(i)
+float(i) != f32
+float(i) != i32
+float(i) != i64
+float(i) ** f32
+float(i) / i32
+float(i) < f32
+float(i) < i64
+float(i) <= f32
+float(i) == i32
+float(i) > f64
+float(i) ^ f64
+float(i) ^ i64
+float(i32 % 1)
+float(i32 % i)
+float(i32 * 1)
+float(i32 * f32)
+float(i32 ** 0.5)
+float(i32 ** f64)
+float(i32 ** i32)
+float(i32 ** i64)
+float(i32 + 1)
+float(i32 + f32)
+float(i32 - 0.5)
+float(i32 - f64)
+float(i32 - i)
+float(i32 - i32)
+float(i32 / 0.5)
+float(i32 / 1)
+float(i32 / 1) > f64
+float(i32 / i)
+float(i32 ^ 1)
+float(i32 ^ f64)
+float(i32 ^ i)
+float(i32)
+float(i32) != f64
+float(i32) * i64
+float(i32) + i
+float(i32) + i64
+float(i32) - i64
+float(i32) / i
+float(i32) / i32
+float(i32) < -0.5
+float(i32) == f32
+float(i32) == i32
+float(i32) > f32
+float(i32) > i32
+float(i32) >= f32
+float(i32) >= f64
+float(i32) ^ f32
+float(i32) ^ f64
+float(i32) ^ i32
+float(i64 % i)
+float(i64 % i32)
+float(i64 * 0.5)
+float(i64 * 1)
+float(i64 ** f64)
+float(i64 ** i64)
+float(i64 + 0.5)
+float(i64 + f64)
+float(i64 - 1)
+float(i64 - f32)
+float(i64 - f64)
+float(i64 - i32)
+float(i64 - i64)
+float(i64 / 0.5)
+float(i64 / 1)
+float(i64 / f32)
+float(i64 ^ f64)
+float(i64)
+float(i64) ** i
+float(i64) / i32
+float(i64) > f64 ^ f32
+float(i64) >= i
+float(i64) >= i64
 float(int(0.5))
-float(int(a))
-float(int(b))
-float(last(arr))
-float(len(arr))
+float(int(1))
+float(int(f32))
+float(int(f64))
+float(int(i))
+float(int(i32))
+float(int(i64))
+float(len("bar"))
+float(len("foo"))
+float(len(array))
+float(len(list))
 float(max(0.5))
-float(max(b))
-float(min(0))
-float(min(a ** a))
-float(min(a, 0))
-float(min(f))
-float(obj.a)
-float(obj.b)
-float(obj.fn(0))
-float(obj.fn(2))
-float(obj.fn(a))
-float(obj.fn(b))
-float(obj.head(0))
-float(obj.head(0.5, 1))
-float(obj.head(1))
-float(obj.head(2))
-float(obj.head(a))
-float(obj.head(a, obj))
-float(obj.head(b))
-float(obj.head(b, arr, obj, nil))
-float(obj.head(b, b, a))
-float(obj.head(b, nil))
-float(obj.head(f))
-float(obj.obj.b)
-float(obj.obj?.b)
-float(obj?.a)
-float(obj?.b)
-float(obj?.fn(0))
-float(obj?.fn(a))
-float(obj?.fn(b))
-float(obj?.head(0))
-float(obj?.head(0, arr, ok))
-float(obj?.head(0, false, false))
-float(obj?.head(0.5))
-float(obj?.head(a))
-float(obj?.head(a, s))
-float(obj?.head(b))
-float(obj?.head(b, div, div))
-float(obj?.head(b, nil))
-float(obj?.head(b, obj?.obj))
-float(obj?.head(f, s))
-float(obj?.obj?.a)
-float(ok ? 0 : arr)
-float(ok ? 0 : true)
-float(ok ? 2 : 2)
-float(ok ? b : b)
-float(ok ? f : s)
-float(string(0))
-float(string(f))
-float(toJSON(0))
+float(max(0.5, i32))
+float(max(1))
+float(max(1, i))
+float(max(1, i64))
+float(max(f64))
+float(max(i))
+float(max(i32))
+float(max(i64))
+float(min(0.5))
+float(min(1))
+float(min(f32))
+float(min(f64))
+float(min(i))
+float(min(i32))
+float(min(i64))
+float(ok ? f64 : half)
+float(ok ? i : greet)
+float(score(1))
+float(score(i))
+float(score(i, i)) <= f32
+float(score(score(i)))
+float(string(0.5))
+float(string(1))
+float(string(f32))
+float(string(f64))
+float(string(i))
+float(string(i64))
+float(toJSON(0.5))
 float(toJSON(1))
-float(toJSON(2))
-float(toJSON(b))
-float(toJSON(f))
-float(true ? a : a)
-float(true ? a : add)
-float(true ? b : f)
-float(true ? f : obj?.obj)
-fromBase64(s + "a")
-fromBase64(s[2:b])
-fromBase64(s[a:0])
-fromBase64(s[a:a])
-fromBase64(s[b:b])
+float(toJSON(f32))
+float(toJSON(f64))
+float(toJSON(i))
+float(toJSON(i32))
+float(true ? 1 : div)
+float(true ? 1 : i64)
+float(true ? f64 : div)
+foo
+foo != first(list)
+foo != foo
+foo != foo ? 1 : 1
+foo != get(list, i)
+foo != last(list)
+foo != nil ? half : nil
+foo == foo
+foo == foo ? i : score
+foo == last(list)
+foo == nil == nil
+foo == nil || ok
+foo in [half]
+foo in filter(list, false)
+foo in list
+foo in list ? nil : i32
+foo in map(list, #)
+foo not in list
+foo.Bar
+foo.Bar != string(i64)
+foo.Bar + type(greet)
+foo.Bar < toJSON(0.5)
+foo.Bar == type(0.5)
+foo.Bar not matches string(half)
+foo.Bar not startsWith foo.String()
+foo.Qux
+foo.Qux != add
+foo.Qux != half
+foo.Qux != score
+foo.Qux == div
+foo.Qux == foo?.Qux
+foo.Qux(foo?.String())
+foo.Qux(greet("bar"))
+foo.Qux(toJSON(0.5))
+foo.Qux(toJSON(i))
+foo.Qux(toJSON(nil))
+foo.Qux(trimSuffix("foo"))
+foo.Qux(type("bar"))
+foo.Qux(type(i))
+foo.String
+foo.String != div
+foo.String == add
+foo.String == greet
+foo.String == half
+foo.String == score
+foo.String()
+foo?.Bar
+foo?.Bar + type(score)
+foo?.Bar in foo
+foo?.Bar not endsWith "bar" ? score : array
+foo?.Qux
+foo?.Qux != div
+foo?.Qux != greet
+foo?.Qux != half
+foo?.Qux != score
+foo?.Qux == add
+foo?.Qux == greet
+foo?.Qux == half
+foo?.Qux == score
+foo?.Qux(foo?.Bar)
+foo?.Qux(string(0.5))
+foo?.Qux(type(0.5))
+foo?.Qux(upper("bar"))
+foo?.String
+foo?.String != div
+foo?.String != greet
+foo?.String != half
+foo?.String != nil ? half : list
+foo?.String != score
+foo?.String == add
+foo?.String == half
+foo?.String()
+foo?.String() + type(list)
+foo?.String() < string(i32)
+foo?.String() < toJSON(nil)
+foo?.String() matches toBase64("bar")
 fromBase64(string(ok))
-fromBase64(toBase64(s))
+fromBase64(string(true))
+fromBase64(toBase64("foo"))
+fromBase64(toBase64(toJSON(nil)))
 fromBase64(toJSON(nil))
 fromBase64(toJSON(ok))
 fromBase64(toJSON(true))
-fromJSON(string(b))
+fromBase64(type(add))
+fromBase64(type(div))
+fromBase64(type(false))
+fromBase64(type(greet))
+fromBase64(type(half))
+fromBase64(type(nil == score))
+fromBase64(type(ok))
+fromBase64(type(score))
+fromBase64(type(true))
+fromJSON("foo") not in list && false
+fromJSON(string(0.5))
+fromJSON(string(1))
+fromJSON(string(f32))
+fromJSON(string(f64))
+fromJSON(string(false))
+fromJSON(string(i))
+fromJSON(string(i32))
+fromJSON(string(i64))
+fromJSON(string(i64)) ** f64
 fromJSON(string(ok))
-fromJSON(toJSON(b))
-fromJSON(toJSON(f))
+fromJSON(string(true))
+fromJSON(toJSON("foo"))
+fromJSON(toJSON(0.5 ** 0.5))
+fromJSON(toJSON(1))
+fromJSON(toJSON(abs(1)))
+fromJSON(toJSON(array))
+fromJSON(toJSON(f32))
+fromJSON(toJSON(f64))
+fromJSON(toJSON(i))
+fromJSON(toJSON(i32))
+fromJSON(toJSON(i64))
+fromJSON(toJSON(list))
 fromJSON(toJSON(nil))
-fromJSON(toJSON(s))
+fromJSON(toJSON(ok))
 fromJSON(toJSON(true))
-get(0 .. b, -b)
-get(0 .. b, a)
-get(0 .. b, obj.obj)
-get(1 .. 0, a)
-get(1 .. 1, get(arr, a))
-get(2 .. 2, b)
-get(2 .. a, a)
-get(2 .. b, true ? div : "c")
-get([1, arr], obj.a)
-get([a, "a", div, 0, a], obj?.b)
-get([b], obj.head(s))
-get([f], b)
-get(a .. 0, b)
-get(a .. b, b)
-get(arr, -a)
-get(arr, -b)
-get(arr, 0 % a)
-get(arr, 0 % b)
-get(arr, 0) != obj?.head(s)
-get(arr, 0) + a
-get(arr, 0) - a
-get(arr, 0) - b
-get(arr, 0) == f
-get(arr, 0) ^ 0 ** f
-get(arr, 1 + a)
-get(arr, 1) != b
-get(arr, 1) ** a
-get(arr, 1) - a
-get(arr, 1) >= get(arr, b)
-get(arr, 2) / obj?.b
-get(arr, 2) == obj.a
-get(arr, a)
-get(arr, a) != b
-get(arr, a) * a
-get(arr, a) * b
-get(arr, a) * obj.head(0, add)
-get(arr, a) ** f ^ f
-get(arr, a) .. b
-get(arr, a) < f
-get(arr, a) > f ** f
-get(arr, a) ^ min(f)
-get(arr, a) in arr
-get(arr, add(0, a))
-get(arr, add(a, 0))
-get(arr, b * 1)
-get(arr, b + 2)
-get(arr, b + a)
-get(arr, b - obj.a)
-get(arr, b)
-get(arr, b) != b
-get(arr, b) != obj.head("a")
-get(arr, b) % a * f
-get(arr, b) % b
-get(arr, b) * b
-get(arr, b) ** f
-get(arr, b) + b
-get(arr, b) - 0 * 1
-get(arr, b) - b
-get(arr, b) .. obj?.a
-get(arr, b) < a
-get(arr, b) <= obj?.b
-get(arr, b) == a ? f : 1
-get(arr, b) >= obj?.b
-get(arr, b) ^ f
-get(arr, b) ^ obj?.a
-get(arr, div(2, a))
-get(arr, div(a, b))
-get(arr, div(b, b))
-get(arr, int(0.5))
-get(arr, max(a, a, 0.5))
-get(arr, obj.a)
-get(arr, obj.b)
-get(arr, obj.fn(a))
-get(arr, obj.head(a, nil))
-get(arr, obj.head(add))
-get(arr, obj.head(add, 0, 0))
-get(arr, obj.head(arr))
-get(arr, obj.head(f))
-get(arr, obj.head(s, "c"))
-get(arr, obj.obj)
-get(arr, obj.obj?.obj)
-get(arr, obj?.a)
-get(arr, obj?.b)
-get(arr, obj?.head(0.5))
-get(arr, obj?.head(1))
-get(arr, obj?.head(1, ok, 0))
-get(arr, obj?.head(add, add))
-get(arr, obj?.head(arr))
-get(arr, obj?.head(arr, "c"))
-get(arr, obj?.head(false))
-get(arr, obj?.head(nil))
-get(arr, obj?.head(obj))
-get(arr, obj?.head(obj, f, div)?.b)
-get(arr, obj?.obj)
-get(arr, obj?.obj.a)
-get(arr, obj[nil])
-get(arr, ok ? "a" : add)
-get(arr, ok ? arr : div)
-get(arr, ok ? obj : 0)
-get(arr, ok ? obj : b)
-get(arr[0:1], b)
-get(arr[0:2], obj?.head(ok))
-get(arr[b:a], obj.b)
-get(b .. 2, obj.head(arr, ok))
-get(b .. a, a)
-get(b .. b, ok ? b : div)
-get(false ? "a" : ok, get(add, f))
-get(false ? "b" : b, f != b)
-get(false ? 0 : 0.5, s)
-get(false ? 0 : add, obj.head(add, div))
-get(false ? 0 : arr, arr)
-get(false ? 0 : ok, a)
-get(false ? 0.5 : arr, div)
-get(false ? 0.5 : s, f)
-get(false ? 2 : f, 0.5 .. 0.5)
-get(false ? arr : b, upper(0, true, "c"))
-get(false ? div : b, 0 / f)
-get(false ? div : b, s)
-get(false ? f : add, ok)
-get(false ? false : s, s)
-get(false ? obj : 0, s)
-get(false ? obj : ok, obj.head(s, div, "b"))
-get(false ? ok : arr, count(arr, ok))
-get(filter(arr, ok), a)
-get(get(obj, s), add)
-get(get(obj, s), int(1))
-get(get(obj, s), now(0))
-get(get(obj, s), obj.a)
-get(get(obj, s), s)
-get(map(arr, "b"), obj.head(b, s))
-get(map(arr, 0.5), obj.a)
-get(map(arr, add), a)
-get(map(arr, add), obj.head(b))
-get(map(arr, b), a - a)
-get(map(arr, b), add(b, 0))
-get(map(arr, div), b)
-get(map(arr, false), a)
-get(map(arr, obj), b)
-get(map(arr, s), min(b, b))
-get(map(arr, s), obj.a)
-get(map(arr, true), b)
-get(obj, get(obj, s))
-get(obj, lower("a"))
-get(obj, lower("c"))
-get(obj, obj.a)
-get(obj, obj.b)
-get(obj, obj.head("b", add, 0.5))
-get(obj, obj.head(0))
-get(obj, obj.head(b, a))
-get(obj, obj.head(div))
-get(obj, obj.head(div, add))
-get(obj, obj.head(f, add))
-get(obj, obj.head(obj))
-get(obj, obj.head(obj, "b", b))
-get(obj, obj.head(ok, add, 0, 2, obj))
-get(obj, obj.head(s))
-get(obj, obj.obj)
-get(obj, obj.obj.b)
-get(obj, obj.obj?.obj)
-get(obj, obj?.a)
-get(obj, obj?.b)
-get(obj, obj?.fn(0))
-get(obj, obj?.fn(1))
-get(obj, obj?.head("b", nil, a, f, f))
-get(obj, obj?.head(2))
-get(obj, obj?.head(a))
-get(obj, obj?.head(f, ok))
-get(obj, obj?.head(false, false, b))
-get(obj, obj?.head(s))
-get(obj, obj?.head(s))?.b
-get(obj, obj?.head(true))
-get(obj, obj?.obj)
-get(obj, ok ? "a" : a)
-get(obj, ok ? a : true)
-get(obj, ok ? obj : div)
-get(obj, ok ? s : obj)
-get(obj, s)
-get(obj, s) != f
-get(obj, s) != ok
-get(obj, s)?.a
-get(obj, s)?.a?.b
-get(obj, s)?.a?.head(f, div)
-get(obj, s)?.a?.obj
-get(obj, s)?.b
-get(obj, s)?.b?.b
-get(obj, s)?.fn(a)
-get(obj, s)?.fn(div)
-get(obj, s)?.fn(s)
-get(obj, s)?.head(add)
-get(obj, s)?.head(add, int(1))
-get(obj, s)?.head(s)
-get(obj, s)?.obj
-get(obj, s)?.obj.b
-get(obj, s)?.obj?.b
-get(obj, string(b))
-get(obj, string(div))
-get(obj, string(ok))
-get(obj, toBase64(s))
-get(obj, toJSON(b))
-get(obj, toJSON(f))
-get(obj, toJSON(false))
-get(obj, toJSON(nil == add))
-get(obj, toJSON(ok))?.a
-get(obj, trimPrefix("a"))
-get(obj, trimSuffix(s))
-get(obj.a, "a" matches s)
-get(obj.a, -f)
-get(obj.a, 0 != a)
-get(obj.a, 0 - 0)
-get(obj.a, 0 .. a)
-get(obj.a, 0 == arr)
-get(obj.a, 0.5 * b)
-get(obj.a, 0.5 >= f)
-get(obj.a, 1 <= b)
-get(obj.a, 1 > f)
-get(obj.a, 2 == add)
-get(obj.a, [s, a, obj])
-get(obj.a, a != nil)
-get(obj.a, a / a)
-get(obj.a, a)
-get(obj.a, a)?.a
-get(obj.a, abs(arr, false, 0))
-get(obj.a, add)
-get(obj.a, arr and false)
-get(obj.a, arr)
-get(obj.a, b + a)
-get(obj.a, b <= a)
-get(obj.a, b == a)
-get(obj.a, b)
-get(obj.a, div)
-get(obj.a, f * f)
-get(obj.a, f ** 2)
-get(obj.a, f <= 1)
-get(obj.a, f == add)
-get(obj.a, f == div)
-get(obj.a, f == s)
-get(obj.a, f)
-get(obj.a, false != "b")
-get(obj.a, float(nil, 2))
-get(obj.a, get("c", obj))
-get(obj.a, get(div, div))
-get(obj.a, get(div, obj))
-get(obj.a, get(f, 1))
-get(obj.a, get(false, b))
-get(obj.a, get(obj, true))
-get(obj.a, get(ok, true))
-get(obj.a, last(a, "a"))
-get(obj.a, len(true, s, ok, "c", s))
-get(obj.a, lower(add, "c"))?.b
-get(obj.a, map("c", 1))
-get(obj.a, map(arr, b))
-get(obj.a, map(obj, f))
-get(obj.a, map(s, s))
-get(obj.a, max(false))
-get(obj.a, obj != "c")
-get(obj.a, obj)
-get(obj.a, obj)?.b
-get(obj.a, obj.b)
-get(obj.a, obj.b)?.a
-get(obj.a, obj.head(div, nil))
-get(obj.a, obj?.head(ok))
-get(obj.a, ok == f)
-get(obj.a, ok || nil)
-get(obj.a, ok)
-get(obj.a, s != nil)
-get(obj.a, s)
-get(obj.a, s[f])
-get(obj.a, string(ok))
-get(obj.a, toJSON(0, b, 0, f))
-get(obj.a, toJSON(2))
-get(obj.a, true != s)
-get(obj.a, true and "c")
-get(obj.b, !true)
-get(obj.b, "a" startsWith "a")
-get(obj.b, "b" != add)
-get(obj.b, "c" in nil)
-get(obj.b, 0 + 0.5)
-get(obj.b, 0 < f)
-get(obj.b, 0.5 .. 0)
-get(obj.b, a == nil)
-get(obj.b, a == ok)
-get(obj.b, a >= a)
-get(obj.b, a and true)?.head(arr)
-get(obj.b, a)
-get(obj.b, a)?.head(s)
-get(obj.b, add)
-get(obj.b, arr == obj)?.a
-get(obj.b, arr)
-get(obj.b, b != f)
-get(obj.b, b .. a)
-get(obj.b, b >= b)
-get(obj.b, b)
-get(obj.b, div)
-get(obj.b, f != ok)
-get(obj.b, f)
-get(obj.b, false != "b")
-get(obj.b, filter(f .. 0.5, b or true))
-get(obj.b, get("b"))
-get(obj.b, get(2, false))
-get(obj.b, get(arr, a))
-get(obj.b, get(b, div))
-get(obj.b, get(div, 0))
-get(obj.b, get(ok))
-get(obj.b, last("b", 0))
-get(obj.b, lower("b"))
-get(obj.b, lower(f, s))
-get(obj.b, map(arr, arr))
-get(obj.b, map(obj, nil))
-get(obj.b, map(s, s))
-get(obj.b, max(nil, div))
-get(obj.b, not ok)
-get(obj.b, now(add, a, div))
-get(obj.b, obj == 0.5)
-get(obj.b, obj || true)
-get(obj.b, obj)
-get(obj.b, obj)?.b
-get(obj.b, obj)?.b?.b
-get(obj.b, obj.a)
-get(obj.b, obj.fn(1))
-get(obj.b, obj.head(f, obj, 0))
-get(obj.b, obj.obj)
-get(obj.b, obj?.a)
-get(obj.b, obj?.b)
-get(obj.b, obj?.head("b", nil, f))
-get(obj.b, obj?.head(div))
-get(obj.b, ok && s)
-get(obj.b, ok == a)
-get(obj.b, ok and arr)
-get(obj.b, ok)
-get(obj.b, one("b", true))
-get(obj.b, s == ok)
-get(obj.b, s)
-get(obj.b, s)?.a
-get(obj.b, toJSON(2))
-get(obj.b, upper(s))
-get(obj.c, a)
-get(obj.c, arr)
-get(obj.c, ok)
-get(obj.fn(0), a)
-get(obj.fn(0), add)
-get(obj.fn(0), arr)
-get(obj.fn(0), f in nil)
-get(obj.fn(0), int(b))
-get(obj.fn(0), ok)
-get(obj.fn(1) + obj?.fn(0), obj)
-get(obj.fn(1), div == a)
-get(obj.fn(1), div)
-get(obj.fn(1), f && false)
-get(obj.fn(1), now(arr))
-get(obj.fn(2), arr)
-get(obj.fn(a), f * f)
-get(obj.fn(a), get(nil))
-get(obj.fn(a), now(nil))
-get(obj.fn(b), 0 + a)
-get(obj.fn(b), 2 < 0.5)
-get(obj.fn(b), arr)
-get(obj.fn(b), div)
-get(obj.fn(b), ok)
-get(obj.fn(b), s)
-get(obj.head("a"), obj?.obj)
-get(obj.head("a", "a"), false ? obj : s)
-get(obj.head("a", nil), add != div)
-get(obj.head("b"), f)
-get(obj.head("b", f, add), div)
-get(obj.head("b", s, nil), a)
-get(obj.head(0), div)
-get(obj.head(0), f)
-get(obj.head(0, "c"), get("a", arr))
-get(obj.head(0, "c"), toJSON(a))
-get(obj.head(0, "c", b), add)
-get(obj.head(0, 0.5, div, s, a), b ** a)
-get(obj.head(0, add), a)
-get(obj.head(0, add, f), f)
-get(obj.head(0, nil), arr)
-get(obj.head(0.5), s)
-get(obj.head(0.5, 0, ok), obj)
-get(obj.head(0.5, false), add)
-get(obj.head(1, false, obj, f, arr), obj)
-get(obj.head(2, ok), get(obj, b))
-get(obj.head(a), a)
-get(obj.head(a), add)
-get(obj.head(a), obj == div)
-get(obj.head(a), obj?.a)
-get(obj.head(a), s)
-get(obj.head(a, 0, "a"), f)
-get(obj.head(a, 2, a, obj), div != ok)
-get(obj.head(a, a, arr), ok || f)
-get(obj.head(a, nil, a), arr)
-get(obj.head(a, s, add), obj.b)
-get(obj.head(add), add)
-get(obj.head(add), first(s))
-get(obj.head(add), float(s, 1))
-get(obj.head(add), ok && a)
-get(obj.head(add, 1), arr[0:a])
-get(obj.head(add, a, 2), b)
-get(obj.head(add, add, add), div)
-get(obj.head(arr), !ok)
-get(obj.head(arr), a)
-get(obj.head(arr), arr)
-get(obj.head(arr), f != arr)
-get(obj.head(arr), get(s, 2))
-get(obj.head(arr), ok)
-get(obj.head(arr, 0), f)
-get(obj.head(arr, 2), arr == nil)
-get(obj.head(arr, nil), -0.5)
-get(obj.head(arr, nil, nil), ok)
-get(obj.head(b), a)
-get(obj.head(b), arr)
-get(obj.head(b), f ** a)
-get(obj.head(b, 0), f != ok)
-get(obj.head(b, 1), div)
-get(obj.head(b, arr), "a" < s)
-get(obj.head(b, b), get(1, s))
-get(obj.head(b, div, f), a / b)
-get(obj.head(b, obj, s, true), 0 <= a)
-get(obj.head(div), add)
-get(obj.head(div), b - b)
-get(obj.head(div), b)
-get(obj.head(div), div != 1)?.b
-get(obj.head(div), obj)
-get(obj.head(div, "c", add), arr)
-get(obj.head(div, a), obj and false)
-get(obj.head(div, arr), a)?.b?.a
-get(obj.head(div, div), s matches s)
-get(obj.head(div, false), false != arr)
-get(obj.head(div, ok), !ok)
-get(obj.head(f), arr)
-get(obj.head(f), obj.a)?.obj
-get(obj.head(f), upper("c"))
-get(obj.head(f, add, f, ok), 0.5 and false)
-get(obj.head(f, b), obj.b)
-get(obj.head(f, false), arr)
-get(obj.head(f, nil), add)
-get(obj.head(f, s), arr[a])
-get(obj.head(false), add != s)
-get(obj.head(false), add)
-get(obj.head(false), div)
-get(obj.head(false), s)
-get(obj.head(false, add), s)
-get(obj.head(false, arr), div)
-get(obj.head(false, b, 0, obj), get(f, b))
-get(obj.head(false, div), s in obj)
-get(obj.head(get(s, 1)), div)
-get(obj.head(nil), add)
-get(obj.head(nil), obj?.head(true, "a"))
-get(obj.head(nil), obj?.obj)
-get(obj.head(nil), s)
-get(obj.head(nil), s[b])
-get(obj.head(nil, obj, arr, add, arr), b)
-get(obj.head(nil, true), string(b))
-get(obj.head(obj), div)
-get(obj.head(obj), get(add, s))
-get(obj.head(obj), get(div, ok, obj))
-get(obj.head(obj), ok)
-get(obj.head(obj), true || false)
-get(obj.head(obj, "a"), s)
-get(obj.head(obj, "c", nil), a)
-get(obj.head(obj, 0, "a"), obj.obj)?.b
-get(obj.head(obj, f), a)
-get(obj.head(obj, f, obj), toJSON(s))
-get(obj.head(obj, nil), nil != a)
-get(obj.head(obj, s, 0), arr)
-get(obj.head(ok), a != true)
-get(obj.head(ok), b ** 2)
-get(obj.head(ok), get(1, add))
-get(obj.head(ok), obj)
-get(obj.head(ok), obj?.a)
-get(obj.head(ok), s)
-get(obj.head(ok), toJSON(nil))
-get(obj.head(ok), true ? a : nil)
-get(obj.head(ok, "a"), add)
-get(obj.head(ok, 0.5, add, div), obj)
-get(obj.head(ok, 1), 0.5 != 0)
-get(obj.head(ok, a), "b" contains "b")
-get(obj.head(ok, arr, div, true, s), get(2, nil))
-get(obj.head(ok, s), map(obj, true))
-get(obj.head(s), add && true)
-get(obj.head(s), b)
-get(obj.head(s), div == "a")
-get(obj.head(s), get(obj, f))
-get(obj.head(s), map(s, f))
-get(obj.head(s), obj.head(0.5, true, ok))
-get(obj.head(s, a), get(div, nil))
-get(obj.head(s, arr, f), "a" in obj)
-get(obj.head(s, f), last(nil, arr))
-get(obj.head(true), ok != 0.5)
-get(obj.head(true, "c"), get(b, ok))
-get(obj.head(true, false, obj), true != f)
-get(obj.obj, !true)
-get(obj.obj, "a" == obj)
-get(obj.obj, "a" == ok)
-get(obj.obj, 0 <= 0)
-get(obj.obj, 0 == nil)
-get(obj.obj, 0 == s)
-get(obj.obj, 0 == true)
-get(obj.obj, 0 > a)
-get(obj.obj, 0.5 ^ b)
-get(obj.obj, a + f)
-get(obj.obj, a - 0)
-get(obj.obj, a)
-get(obj.obj, a)?.a
-get(obj.obj, abs(0))
-get(obj.obj, add(b, b))
-get(obj.obj, add)
-get(obj.obj, all("b", ok)) != b
-get(obj.obj, arr)
-get(obj.obj, b)
-get(obj.obj, count(s, false))
-get(obj.obj, div != "a")
-get(obj.obj, div != add)
-get(obj.obj, div)
-get(obj.obj, f != obj)
-get(obj.obj, f .. 0)
-get(obj.obj, f < a)
-get(obj.obj, f)
-get(obj.obj, false or false)
-get(obj.obj, false or s)
-get(obj.obj, filter(obj, false))
-get(obj.obj, get(arr))
-get(obj.obj, get(arr, obj))
-get(obj.obj, get(arr, s))
-get(obj.obj, get(b, a))
-get(obj.obj, get(f, false))
-get(obj.obj, get(nil, s))
-get(obj.obj, get(obj, true))
-get(obj.obj, int(b, 0.5))
-get(obj.obj, int(b, b))
-get(obj.obj, last("c"))
-get(obj.obj, map(arr, "a"))
-get(obj.obj, map(s, "a"))
-get(obj.obj, min(arr))
-get(obj.obj, nil != a)
-get(obj.obj, now(obj))
-get(obj.obj, obj)
-get(obj.obj, obj)?.obj
-get(obj.obj, obj?.a)
-get(obj.obj, obj?.b)
-get(obj.obj, obj?.obj)
-get(obj.obj, obj[s])
-get(obj.obj, ok != b)
-get(obj.obj, ok)
-get(obj.obj, one(obj, ok))
-get(obj.obj, one(s, ok))
-get(obj.obj, s)
-get(obj.obj, s)?.obj
-get(obj.obj, s[f])
-get(obj.obj, string(a, b))
-get(obj.obj, toBase64("a", 1))
-get(obj.obj, toJSON(arr))
-get(obj.obj, true or nil)
-get(obj.obj.a, obj)?.fn(a)
-get(obj.obj?.b, f)
-get(obj?.a, "b" in arr)
-get(obj?.a, -a)
-get(obj?.a, -f)
-get(obj?.a, 0 + a)
-get(obj?.a, 0 - a)
-get(obj?.a, 0 / a)
-get(obj?.a, 0 <= f)?.a
-get(obj?.a, 0.5 != 1)
-get(obj?.a, 0.5 > 0.5)
-get(obj?.a, 1 + f)
-get(obj?.a, 1 <= 1)
-get(obj?.a, a - a)
-get(obj?.a, a == nil)
-get(obj?.a, a)
-get(obj?.a, a)?.b
-get(obj?.a, add(a, a))?.obj
-get(obj?.a, add)
-get(obj?.a, all(s, false))
-get(obj?.a, arr)
-get(obj?.a, b ** a)
-get(obj?.a, b - a)
-get(obj?.a, b < b)
-get(obj?.a, b)
-get(obj?.a, div(0, b))
-get(obj?.a, div)
-get(obj?.a, f .. b)
-get(obj?.a, f ^ f)
-get(obj?.a, f)
-get(obj?.a, false != ok)
-get(obj?.a, false && s)
-get(obj?.a, false ? 0 : false)
-get(obj?.a, false || s)
-get(obj?.a, get("a", nil))
-get(obj?.a, get(0, ok))
-get(obj?.a, get(0.5, 2))
-get(obj?.a, get(2, true))
-get(obj?.a, get(s, f))
-get(obj?.a, get(s, s))
-get(obj?.a, get(true, nil))
-get(obj?.a, int(f))
-get(obj?.a, last(0.5, add, 0.5))
-get(obj?.a, last(add))
-get(obj?.a, map(arr, div))
-get(obj?.a, max(f))
-get(obj?.a, min(a, 0.5) <= 2 != ok)
-get(obj?.a, not ok)
-get(obj?.a, now(0.5, 1, s, 0, f))
-get(obj?.a, now(div))
-get(obj?.a, obj)
-get(obj?.a, obj.a)
-get(obj?.a, obj.b)
-get(obj?.a, obj.head(ok, 0))
-get(obj?.a, obj?.b)
-get(obj?.a, obj?.head(f))
-get(obj?.a, ok && "a")
-get(obj?.a, ok ? div : "a")
-get(obj?.a, ok || f)
-get(obj?.a, ok)
-get(obj?.a, s)
-get(obj?.a, string(div))
-get(obj?.a, toJSON(f, nil, s))
-get(obj?.a, true && false)
-get(obj?.a, true ? false : add)
-get(obj?.b, -f)
-get(obj?.b, 0 or true)
-get(obj?.b, 0 || false)?.fn(f)
-get(obj?.b, 1 - b)
-get(obj?.b, 2 % b)
-get(obj?.b, 2 == 0)
-get(obj?.b, a .. 0)
-get(obj?.b, a < b)
-get(obj?.b, a)
-get(obj?.b, a)?.obj
-get(obj?.b, add == s)
-get(obj?.b, add in arr)
-get(obj?.b, add)
-get(obj?.b, arr == 0.5)
-get(obj?.b, arr == a)
-get(obj?.b, arr)
-get(obj?.b, arr)?.b
-get(obj?.b, arr[b])
-get(obj?.b, b % a)
-get(obj?.b, b + 1)
-get(obj?.b, b)
-get(obj?.b, count(obj, true))
-get(obj?.b, div != "b")
-get(obj?.b, div)
-get(obj?.b, f != ok)
-get(obj?.b, f + 0)
-get(obj?.b, f / b)
-get(obj?.b, f == div)
-get(obj?.b, f)
-get(obj?.b, false == nil)
-get(obj?.b, false and f)
-get(obj?.b, float(a))
-get(obj?.b, get(0.5, ok))
-get(obj?.b, get(a, 2))
-get(obj?.b, get(a, a))
-get(obj?.b, get(add))
-get(obj?.b, get(add, arr))
-get(obj?.b, get(add, s))
-get(obj?.b, get(f, 0.5))
-get(obj?.b, get(f, arr))?.obj
-get(obj?.b, get(false, false))
-get(obj?.b, get(obj, div))
-get(obj?.b, get(obj, nil))
-get(obj?.b, get(ok, f))
-get(obj?.b, get(s))
-get(obj?.b, get(s, 0))
-get(obj?.b, int(2))
-get(obj?.b, last(ok, true, 0.5))
-get(obj?.b, map("a", s))
-get(obj?.b, map(obj, 0))
-get(obj?.b, map(obj, nil))
-get(obj?.b, map(s, 1))
-get(obj?.b, map(s, b))
-get(obj?.b, max(f))
-get(obj?.b, min(nil))
-get(obj?.b, nil or true)
-get(obj?.b, nil || false)
-get(obj?.b, now(s))
-get(obj?.b, now(true))
-get(obj?.b, obj == b)
-get(obj?.b, obj)
-get(obj?.b, obj.a)
-get(obj?.b, obj.b)
-get(obj?.b, obj.head(false))
-get(obj?.b, obj?.head(a, 0.5))
-get(obj?.b, obj?.head(obj, 0))
-get(obj?.b, obj?.head(ok))
-get(obj?.b, ok && arr)
-get(obj?.b, ok ? f : arr)
-get(obj?.b, ok and div)
-get(obj?.b, ok)
-get(obj?.b, s != obj)
-get(obj?.b, s == s)
-get(obj?.b, s > "a")
-get(obj?.b, s)
-get(obj?.b, s)?.obj
-get(obj?.b, toJSON(f))
-get(obj?.c?.a?.b, ok)
-get(obj?.fn(0), a)
-get(obj?.fn(0), ok)
-get(obj?.fn(0), s)
-get(obj?.fn(1 + 0), ok ? ok : s?.a)
-get(obj?.fn(1), obj)
-get(obj?.fn(2), a / 0)
-get(obj?.fn(2), a)
-get(obj?.fn(2), none(s, true))
-get(obj?.fn(a), add)
-get(obj?.fn(a), f)
-get(obj?.fn(a), get(arr, b))
-get(obj?.fn(a), get(nil, 0))
-get(obj?.fn(a), obj)
-get(obj?.fn(a), s)
-get(obj?.fn(b + b), a)
-get(obj?.fn(b), div)
-get(obj?.fn(b), f .. f)
-get(obj?.fn(b), obj)
-get(obj?.head("a"), arr)
-get(obj?.head("a"), map("a", a))
-get(obj?.head("a", f), obj?.b)?.b
-get(obj?.head("b"), add)
-get(obj?.head("b", 2, arr), ok)
-get(obj?.head("c"), s > "c")
-get(obj?.head("c"), s matches s)
-get(obj?.head("c", 0.5, a), "a" || false)
-get(obj?.head("c", b), nil == div)
-get(obj?.head("c", div, ok), count("b", true))
-get(obj?.head(0), b .. b)
-get(obj?.head(0), div)
-get(obj?.head(0), map(s, add))
-get(obj?.head(0), obj)
-get(obj?.head(0), obj?.b)
-get(obj?.head(0), ok)
-get(obj?.head(0), s)
-get(obj?.head(0, 0), b)
-get(obj?.head(0, 0, add, "b", 2), arr)
-get(obj?.head(0, a, 0.5, a), a - b)
-get(obj?.head(0, b, add, false, nil), b)
-get(obj?.head(0, nil, obj, 0, add), div)
-get(obj?.head(0.5), min(arr))
-get(obj?.head(0.5), s)
-get(obj?.head(0.5, b), ok or b)
-get(obj?.head(0.5, b), s)
-get(obj?.head(0.5, div), add)
-get(obj?.head(0.5, s, a, "c", b), obj?.head(add, 0))
-get(obj?.head(1), get(ok, 0))
-get(obj?.head(1, a), add)
-get(obj?.head(1, a, f), get(f, nil))
-get(obj?.head(2), a)
-get(obj?.head(2), max(0.5))
-get(obj?.head(2, true, a, ok), arr)
-get(obj?.head(a), add)
-get(obj?.head(a), arr)
-get(obj?.head(a), b)
-get(obj?.head(a), obj?.obj)
-get(obj?.head(a), s)
-get(obj?.head(a, "c", "c"), a)
-get(obj?.head(a, add, b), div)
-get(obj?.head(a, div), obj.head(b))
-get(obj?.head(a, s, s), map("a", a))
-get(obj?.head(add), b)
-get(obj?.head(add), none(obj, false))
-get(obj?.head(add), now(obj, 1, add))
-get(obj?.head(add), s)
-get(obj?.head(add, a, obj, "b", a), obj.obj)
-get(obj?.head(add, b), div)
-get(obj?.head(add, false), div != b)
-get(obj?.head(add, float(f)), s)
-get(obj?.head(add, obj, a), s)
-get(obj?.head(add, obj, a, 0.5), add)
-get(obj?.head(add, obj, obj), f)
-get(obj?.head(add, ok), a)
-get(obj?.head(arr), get(s, arr))
-get(obj?.head(arr), obj)
-get(obj?.head(arr), s)
-get(obj?.head(arr, 0.5, false), 0 > f)
-get(obj?.head(arr, a), obj.obj)
-get(obj?.head(arr, add), 0.5 / a)
-get(obj?.head(arr, add), b)
-get(obj?.head(arr, add), div)
-get(obj?.head(arr, nil), f)
-get(obj?.head(arr, nil, arr, ok), obj)
-get(obj?.head(arr, obj, "a"), false == div)
-get(obj?.head(arr, ok, arr), obj?.head(true, 0))
-get(obj?.head(arr, s), div)
-get(obj?.head(arr, s), obj.a)
-get(obj?.head(b), all(s, ok))
-get(obj?.head(b), b)
-get(obj?.head(b), f)?.obj
-get(obj?.head(b), false && 0)
-get(obj?.head(b), get(0.5, b))
-get(obj?.head(b), obj?.b)
-get(obj?.head(b, "b", nil), arr)
-get(obj?.head(b, 0), obj.b)
-get(obj?.head(b, div), add)
-get(obj?.head(b, nil, ok), nil == f)
-get(obj?.head(div), a)
-get(obj?.head(div), arr)
-get(obj?.head(div), div)
-get(obj?.head(div, 1, ok, a), div)
-get(obj?.head(div, a), obj && false)
-get(obj?.head(div, arr), nil == "c")
-get(obj?.head(div, false), f)
-get(obj?.head(div, false, arr), map(s, b))
-get(obj?.head(div, obj), f)
-get(obj?.head(f), arr)
-get(obj?.head(f), obj.obj)
-get(obj?.head(f), s)
-get(obj?.head(f, nil), ok ? f : div)
-get(obj?.head(f, ok, add), "a" == f)
-get(obj?.head(false), false and f)
-get(obj?.head(false), ok && obj)
-get(obj?.head(false), ok)
-get(obj?.head(false, b, ok, "a"), any(obj, ok))
-get(obj?.head(false, obj, 0, arr), div)
-get(obj?.head(false, s, 0, f), true or s)
-get(obj?.head(nil), a)
-get(obj?.head(nil), add)
-get(obj?.head(nil), f)
-get(obj?.head(nil), get(false, add))
-get(obj?.head(nil), ok)
-get(obj?.head(nil), s == arr)
-get(obj?.head(nil), s)
-get(obj?.head(nil, "c"), arr)
-get(obj?.head(nil, arr), ok or obj)
-get(obj?.head(nil, obj), first(f, nil))
-get(obj?.head(obj), add != true)
-get(obj?.head(obj), arr)
-get(obj?.head(obj), f)
-get(obj?.head(obj), obj)
-get(obj?.head(obj), ok)
-get(obj?.head(obj, "a", add), ok == ok)
-get(obj?.head(obj, arr), arr)
-get(obj?.head(obj, f), obj)
-get(obj?.head(obj, obj, ok), div)
-get(obj?.head(obj?.a), a)
-get(obj?.head(ok), a)
-get(obj?.head(ok), b)
-get(obj?.head(ok, 1), b == b)
-get(obj?.head(ok, 1), ok)
-get(obj?.head(ok, arr, div), get(add, s))
-get(obj?.head(ok, f, 0.5, b), 1 != true)
-get(obj?.head(s), b % 2)
-get(obj?.head(s), f)
-get(obj?.head(s), get(a, obj))
-get(obj?.head(s), obj)
-get(obj?.head(s), ok)
-get(obj?.head(s, 0, arr), false or s)
-get(obj?.head(s, 2, f, div), get(f, 0.5))
-get(obj?.head(s, add, s), hasPrefix("b", s))
-get(obj?.head(s, div, arr), s)
-get(obj?.head(s, false), obj == add)
-get(obj?.head(true), b)
-get(obj?.head(true), f != s)
-get(obj?.head(true), f)
-get(obj?.head(true), first(div, b))
-get(obj?.head(true, add), a)
-get(obj?.head(true, add, add), obj.head(ok, obj, 2, nil, 2))
-get(obj?.head(true, b), obj)
-get(obj?.head(true, div), a)
-get(obj?.head(true, f), filter(s, true))
-get(obj?.head(true, obj, 1, b), div)
-get(obj?.obj, "a" matches s)
-get(obj?.obj, -b)
-get(obj?.obj, 0 != f)
-get(obj?.obj, 0 != s)
-get(obj?.obj, 0 / a)
-get(obj?.obj, 0.5 + a)?.a
-get(obj?.obj, 1 .. a)
-get(obj?.obj, 2 + 2)
-get(obj?.obj, a != 2)
-get(obj?.obj, a * f)
-get(obj?.obj, a ** f)
-get(obj?.obj, a < b)
-get(obj?.obj, a or true)
-get(obj?.obj, a)
-get(obj?.obj, add and false)
-get(obj?.obj, add(a, b))
-get(obj?.obj, add)
-get(obj?.obj, arr)
-get(obj?.obj, b * b)
-get(obj?.obj, b ** 2)
-get(obj?.obj, b > a)
-get(obj?.obj, b)
-get(obj?.obj, div == 0)
-get(obj?.obj, div)
-get(obj?.obj, f < 0)
-get(obj?.obj, f)
-get(obj?.obj, false or "c")
-get(obj?.obj, filter("a", ok))
-get(obj?.obj, filter(s, ok))
-get(obj?.obj, get("b", arr))
-get(obj?.obj, get("c", arr))
-get(obj?.obj, get(0, a))
-get(obj?.obj, get(add, s))
-get(obj?.obj, get(arr, 0))
-get(obj?.obj, get(nil, a))
-get(obj?.obj, get(nil, b))
-get(obj?.obj, int(false, arr, b))
-get(obj?.obj, map(obj, "b"))
-get(obj?.obj, map(obj, div))
-get(obj?.obj, min(arr))
-get(obj?.obj, now("c", obj))
-get(obj?.obj, obj)
-get(obj?.obj, obj)?.a?.a
-get(obj?.obj, obj.a)
-get(obj?.obj, obj.b)
-get(obj?.obj, obj.head(nil))
-get(obj?.obj, obj.obj)
-get(obj?.obj, obj?.a)
-get(obj?.obj, obj?.head(add))
-get(obj?.obj, obj?.head(s, 0))
-get(obj?.obj, obj?.obj)
-get(obj?.obj, ok != a)
-get(obj?.obj, ok != false)
-get(obj?.obj, ok ? 2 : true)
-get(obj?.obj, ok and nil)
-get(obj?.obj, ok or ok)
-get(obj?.obj, ok)
-get(obj?.obj, ok)?.obj
-get(obj?.obj, one(obj, true))
-get(obj?.obj, s)
-get(obj?.obj, string(f))
-get(obj?.obj, string(f, 0))
-get(obj?.obj, string(ok, s, s))
-get(obj?.obj, toJSON(b, b, nil))
-get(obj?.obj, toJSON(f))
-get(obj?.obj, true || 1)
-get(obj?.obj.b, arr)
-get(obj?.obj?.a, div)
-get(obj?.obj?.b, obj)
-get(obj?.obj?.b, s)
-get(obj?.obj?.obj, f)
-get(obj[nil], add)
-get(obj[nil], arr)
-get(obj[nil], f)
-get(obj[nil], get(s, a))
-get(obj[nil], ok)
-get(obj[nil], s)
-get(obj[s], obj)
-get(obj[s], obj?.a)
-get(ok ? "a" : add, ok ? s : add)
-get(ok ? "a" : arr, arr)
-get(ok ? 0 : "c", obj)
-get(ok ? 0 : arr, arr)
-get(ok ? add : 0.5, b)
-get(ok ? add : obj, ok)
-get(ok ? arr : add, div)
-get(ok ? arr : b, f)
-get(ok ? arr : f, toJSON("c"))
-get(ok ? b : div, first(nil))
-get(ok ? div : 1, add)
-get(ok ? f : "a", f)
-get(ok ? f : div, arr)
-get(ok ? f : obj, div)
-get(ok ? f : ok, obj.obj)
-get(ok ? false : arr, s)
-get(ok ? obj : 0, arr)
-get(ok ? obj : a, a)
-get(ok ? obj : div, div)
-get(ok ? ok : b, ok and ok)
-get(ok ? ok : f, last(ok))
-get(ok ? ok : obj, a)
-get(ok ? ok : obj, arr)
-get(ok ? s : f, arr)
-get(ok ? s : false, 0 != f)
-get(ok ? s : obj, obj?.head(ok, add))?.b
-get(ok ? true : a, count(arr, ok))
-get(true ? "c" : 0, get("b", div))
-get(true ? 0.5 : 0, s)
-get(true ? 1 : arr, f)
-get(true ? 1 : ok, f == a)
-get(true ? 1 : ok, ok or add)
-get(true ? a : ok, f * 0.5)
-get(true ? a : ok, get(nil, "c"))
-get(true ? add : "a", a)
-get(true ? add : 0.5, s[0.5:b])
-get(true ? b : s, div)
-get(true ? div : 2, add)
-get(true ? f : "c", get(arr))
-get(true ? obj : add, arr)
-get(true ? ok : 0, 0 / a)
-get(true ? s : 0.5, get(obj, f))
-get(values(obj), obj.a)
-get({"b": b, "c": "c", "a": nil}?.b, obj.obj)
-indexOf("b", s) != a
-indexOf(s, s)
-indexOf(s, upper(s))
-int(-0)
+get(1 .. i32, i)
+get(1 .. i64, abs(1))
+get(1 .. i64, i)
+get(1 .. i64, i32)
+get(["bar"], i64)
+get([array], i)
+get([greet], i)
+get([nil, half], i)
+get([score, 0.5, score], i64)
+get(array, -1)
+get(array, -i)
+get(array, -i32)
+get(array, 1 % 1)
+get(array, 1 % i64)
+get(array, 1 - 1)
+get(array, 1 - i)
+get(array, 1) * f64
+get(array, 1) < f32
+get(array, 1) <= i32
+get(array, 1) > i
+get(array, 1) ^ f64
+get(array, 1) ^ i
+get(array, array[1])
+get(array, count(list, true))
+get(array, false ? div : false)
+get(array, first(array))
+get(array, i % i64)
+get(array, i * 1)
+get(array, i)
+get(array, i) + i
+get(array, i) > i32
+get(array, i) ^ f32
+get(array, i32 * i64)
+get(array, i32)
+get(array, i32) ** f32
+get(array, i32) == i32
+get(array, i32) > f64
+get(array, i64)
+get(array, i64) ** i
+get(array, i64) ** i64
+get(array, i64) .. i32
+get(array, i64) <= -i32
+get(array, i64) <= f64 / f32
+get(array, i64) <= i
+get(array, i64) == i64
+get(array, int(1))
+get(array, int(f32))
+get(array, int(f64))
+get(array, int(i32))
+get(array, len(array))
+get(array, max(1))
+get(array, min(i))
+get(array, min(i32))
+get(array, score(1))
+get(array, true ? i : 1)
+get(false ? "bar" : f64, list)
+get(false ? "bar" : i32, greet)
+get(false ? "foo" : i, ok)
+get(false ? 0.5 : i64, true not in String)
+get(false ? 1 : greet, ok)
+get(false ? div : true, min("foo"))
+get(false ? greet : score, score)
+get(false ? half : list, i32)
+get(false ? list : 1, i32)
+get(false ? list : i64, i >= f64)
+get(false ? score : 0.5, add)
+get(false ? score : 0.5, half)
+get(false ? score : f64, half)
+get(filter(list, ok), i32)
+get(filter(list, ok), i64)
+get(i .. i, i)
+get(i32 .. 1, i)
+get(i64 .. 1, i32)
+get(list, -i)
+get(list, -i32)
+get(list, -i64)
+get(list, 1 * i)
+get(list, 1).Bar
+get(list, 1).Qux
+get(list, 1).String
+get(list, 1).String()
+get(list, 1)?.Bar
+get(list, 1)?.Qux
+get(list, 1)?.String
+get(list, 1)?.String()
+get(list, abs(i))
+get(list, abs(i32))
+get(list, i)
+get(list, i) != foo
+get(list, i) == foo
+get(list, i).Bar
+get(list, i).Qux
+get(list, i).String
+get(list, i)?.Bar
+get(list, i)?.Qux
+get(list, i)?.String
+get(list, i)?.String()
+get(list, i32)
+get(list, i32).Bar
+get(list, i32).Qux
+get(list, i32).String
+get(list, i32).String()
+get(list, i32)?.Bar
+get(list, i32)?.Qux
+get(list, i32)?.String
+get(list, i32)?.String()
+get(list, i64 * i32)
+get(list, i64)
+get(list, i64).Bar
+get(list, i64).Qux
+get(list, i64).String
+get(list, i64).String()
+get(list, i64)?.Bar
+get(list, i64)?.Qux
+get(list, i64)?.String
+get(list, i64)?.String()
+get(list, int(1) > 0.5 ? div : 0.5)
+get(list, int(i))
+get(list, int(i32))
+get(list, int(i64))
+get(list, last(array))
+get(list, max(1, i64, i64))
+get(list, min(i32))
+get(list, min(i64))
+get(list, score(1))
+get(list[i32:i], i64)
+get(map(array, #), i)
+get(map(array, #), i64)
+get(map(array, #), last(array))
+get(map(array, 0.5), i)
+get(map(array, 1), i)
+get(map(array, i32), i64)
+get(map(array, ok), i)
+get(map(array, ok), i64)
+get(map(list, #), i)
+get(map(list, #), i32)
+get(map(list, #), i64)
+get(map(list, 0.5), i64)
+get(map(list, array), i)
+get(map(list, div), i32)
+get(map(list, i32), i64)
+get(map(list, ok), i32)
+get(map(list, true), i64)
+get(ok ? 0.5 : add, f32)
+get(ok ? add : 0.5, ok)
+get(ok ? add : false, div)
+get(ok ? array : 0.5, Bar)
+get(ok ? array : i, add)
+get(ok ? div : foo, filter("bar", ok))
+get(ok ? greet : 0.5, foo in String)
+get(ok ? greet : f32, Bar)
+get(ok ? i : f64, greet)?.f64
+get(ok ? i32 : "foo", score)
+get(ok ? i32 : add, div)
+get(ok ? list : "foo", f32)
+get(ok ? ok : half, array)
+get(ok ? true : i32, f32)
+get(sort(array), i32)
+get(true ? 0.5 : score, foo)
+get(true ? 1 : f64, foo)
+get(true ? 1 : greet, greet)?.foo
+get(true ? 1 : score, String?.Qux())
+get(true ? add : score, i)
+get(true ? array : 1, half)
+get(true ? array : i64, ok)
+get(true ? div : foo, list)
+get(true ? f32 : 1, greet)
+get(true ? f64 : greet, String)
+get(true ? f64 : ok, Bar?.ok)
+get(true ? i : f64, add)
+get(true ? i64 : score, i)
+get(true ? list : ok, ok)
+get({"bar": i32}.i32, ok)
+greet
+greet != add
+greet != div
+greet != div != nil
+greet != foo.Qux
+greet != foo.String
+greet != foo?.Qux
+greet != foo?.String
+greet != greet
+greet != greet != nil
+greet != greet or 0.5 == i
+greet != half
+greet != half ? 1 : ok
+greet != half ? array : 0.5
+greet != half ? false : f64
+greet != half ? greet : greet
+greet != nil ? i64 : 0.5
+greet != score
+greet == add
+greet == add == ok
+greet == add ? div == greet : i64
+greet == div
+greet == div ? add : i32
+greet == foo.Qux
+greet == foo.String
+greet == foo?.Qux
+greet == foo?.String
+greet == greet
+greet == half
+greet == nil != nil
+greet == nil && ok
+greet == nil == ok
+greet == score
+greet in [nil]
+greet("bar" + "bar")
+greet("bar" + "foo")
+greet("bar") != foo.String()
+greet("bar") != nil != false
+greet("bar") in foo
+greet("foo" + "bar")
+greet("foo" + "foo")
+greet("foo") >= string(foo)
+greet("foo") not contains "bar" ? array : half
+greet("foo") startsWith greet("bar")
+greet(false ? f32 : "foo")
+greet(false ? i : "bar")
+greet(foo.Bar)
+greet(foo.String())
+greet(foo?.Bar)
+greet(foo?.String())
+greet(greet("bar"))
+greet(greet("foo"))
+greet(lower("bar"))
+greet(lower("foo"))
+greet(ok ? "bar" : div)
+greet(string("bar"))
+greet(string("foo"))
+greet(string(-i64))
+greet(string(0.5 == 1))
+greet(string(0.5))
+greet(string(1))
+greet(string([0.5]))
+greet(string(add))
+greet(string(array))
+greet(string(div))
+greet(string(f32))
+greet(string(f64))
+greet(string(false))
+greet(string(foo))
+greet(string(foo?.Qux))
+greet(string(greet))
+greet(string(half))
+greet(string(i))
+greet(string(i32))
+greet(string(i64))
+greet(string(list))
+greet(string(nil != false))
+greet(string(nil))
+greet(string(ok))
+greet(string(score))
+greet(string(true))
+greet(toBase64("bar"))
+greet(toBase64("foo"))
+greet(toJSON("bar"))
+greet(toJSON("foo"))
+greet(toJSON(0.5))
+greet(toJSON(1))
+greet(toJSON(array))
+greet(toJSON(f32))
+greet(toJSON(f64))
+greet(toJSON(false))
+greet(toJSON(foo))
+greet(toJSON(i))
+greet(toJSON(i32))
+greet(toJSON(i64))
+greet(toJSON(list))
+greet(toJSON(nil))
+greet(toJSON(ok))
+greet(toJSON(string(array)))
+greet(toJSON(true))
+greet(trim("bar"))
+greet(trim("foo"))
+greet(trim(string(array)))
+greet(trimPrefix("bar"))
+greet(trimPrefix("foo"))
+greet(trimSuffix("bar"))
+greet(trimSuffix("foo"))
+greet(trimSuffix("foo", "foo"))
+greet(true ? "foo" : 0.5)
+greet(type("bar"))
+greet(type("foo"))
+greet(type(0.5))
+greet(type(1))
+greet(type(abs(f32)))
+greet(type(add))
+greet(type(array))
+greet(type(div))
+greet(type(f32))
+greet(type(f64 / i))
+greet(type(f64))
+greet(type(false))
+greet(type(foo))
+greet(type(greet))
+greet(type(half))
+greet(type(i))
+greet(type(i32))
+greet(type(i64))
+greet(type(list))
+greet(type(nil))
+greet(type(ok))
+greet(type(score))
+greet(type(true))
+greet(upper("bar"))
+greet(upper("foo"))
+half
+half != add
+half != add ? ok : half
+half != div
+half != div == true
+half != foo.Qux
+half != foo.String
+half != foo?.Qux
+half != foo?.String
+half != greet
+half != half
+half != score
+half == add
+half == add ? "bar" : half
+half == div
+half == div ? add : 0.5
+half == div and 1 >= 1
+half == foo.Qux
+half == foo.String
+half == foo?.Qux
+half == foo?.String
+half == greet
+half == greet == nil
+half == greet ? ok : foo
+half == greet || ok
+half == half
+half == half && i >= 0.5
+half == half ? score : "bar"
+half == half and ok
+half == nil == true
+half == nil ? 1 : 0.5
+half == nil ? 1 : score
+half == score
+half not in [list, i64, ok]
+half not in {"bar": list, "foo": 0.5}.ok
+half(-(f32 - 0.5))
+half(--1)
+half(-0.5)
+half(-1)
+half(-f32 ^ i)
+half(-f64)
+half(0.5 * 0.5)
+half(0.5 * 1)
+half(0.5 * f64)
+half(0.5 * i)
+half(0.5 * i32)
+half(0.5 * i64)
+half(0.5 ** 0.5)
+half(0.5 ** 1)
+half(0.5 ** f32)
+half(0.5 ** f64)
+half(0.5 ** i)
+half(0.5 ** i32)
+half(0.5 ** i64)
+half(0.5 + 0.5)
+half(0.5 + 1)
+half(0.5 + f32)
+half(0.5 + f64)
+half(0.5 + i32)
+half(0.5 + i64)
+half(0.5 - 0.5)
+half(0.5 - 1)
+half(0.5 - f32)
+half(0.5 - f64)
+half(0.5 - i)
+half(0.5 - i32)
+half(0.5 - i64)
+half(0.5 / 0.5)
+half(0.5 / 1)
+half(0.5 / f32)
+half(0.5 / f64)
+half(0.5 / i)
+half(0.5 / i32)
+half(0.5 / i64)
+half(0.5 ^ 0.5)
+half(0.5 ^ 1)
+half(0.5 ^ f32)
+half(0.5 ^ f64)
+half(0.5 ^ i)
+half(0.5 ^ i32)
+half(0.5 ^ i64)
+half(0.5) != f32
+half(0.5) != i64
+half(0.5) * f32
+half(0.5) ** f32
+half(0.5) ** f64
+half(0.5) + 1 * f64
+half(0.5) + f64
+half(0.5) + i32
+half(0.5) + i64
+half(0.5) - f32
+half(0.5) - f64
+half(0.5) - i
+half(0.5) - i32
+half(0.5) / i
+half(0.5) / i32
+half(0.5) / i64
+half(0.5) < i32
+half(0.5) <= i
+half(0.5) == f32 != true
+half(0.5) == i
+half(0.5) == i32
+half(0.5) == i64
+half(0.5) > i
+half(0.5) > i32
+half(0.5) > i64
+half(0.5) >= f32
+half(0.5) >= f64
+half(0.5) >= i
+half(0.5) >= i32
+half(0.5) >= i64
+half(0.5) ^ (i32 - 1)
+half(0.5) ^ i32
+half(1 * 0.5)
+half(1 * 1)
+half(1 * f32)
+half(1 * f64)
+half(1 * i)
+half(1 * i32)
+half(1 * i64)
+half(1 ** 0.5)
+half(1 ** 1)
+half(1 ** f32)
+half(1 ** f64)
+half(1 ** i)
+half(1 ** i32)
+half(1 ** i64)
+half(1 + 0.5)
+half(1 + 1)
+half(1 + f32)
+half(1 + f64)
+half(1 + i)
+half(1 + i32)
+half(1 + i64)
+half(1 - 0.5)
+half(1 - 1)
+half(1 - f32)
+half(1 - f64)
+half(1 - i)
+half(1 - i32)
+half(1 - i64)
+half(1 / 0.5)
+half(1 / 1)
+half(1 / f32)
+half(1 / f64)
+half(1 / i)
+half(1 / i32)
+half(1 / i64)
+half(1 ^ 0.5)
+half(1 ^ 1)
+half(1 ^ f32)
+half(1 ^ f64)
+half(1 ^ i)
+half(1 ^ i32)
+half(abs(0.5))
+half(abs(f64))
+half(abs(f64)) - i
+half(f32 * 0.5)
+half(f32 * 1)
+half(f32 * f64)
+half(f32 * i)
+half(f32 * i32)
+half(f32 * i64)
+half(f32 ** 0.5)
+half(f32 ** f32)
+half(f32 ** f64)
+half(f32 + 0.5)
+half(f32 + 1)
+half(f32 + f32)
+half(f32 + f64)
+half(f32 + i)
+half(f32 + i32)
+half(f32 + i64)
+half(f32 - 0.5)
+half(f32 - 1)
+half(f32 - f64)
+half(f32 - i)
+half(f32 - i32)
+half(f32 - i64)
+half(f32 / 0.5)
+half(f32 / 1)
+half(f32 / f32)
+half(f32 / f64)
+half(f32 / i32)
+half(f32 / i64)
+half(f32 ^ 0.5)
+half(f32 ^ f32)
+half(f32 ^ f64)
+half(f32 ^ i32)
+half(f32 ^ i64)
+half(f64 * 0.5)
+half(f64 * 1)
+half(f64 * f32)
+half(f64 * i)
+half(f64 * i32)
+half(f64 ** 0.5)
+half(f64 ** 1)
+half(f64 ** f32)
+half(f64 ** f64)
+half(f64 ** i)
+half(f64 ** i32)
+half(f64 + 1)
+half(f64 + f32)
+half(f64 + i)
+half(f64 + i32)
+half(f64 - 0.5)
+half(f64 - 1)
+half(f64 - f32)
+half(f64 - f64)
+half(f64 - i)
+half(f64 - i32)
+half(f64 - i64)
+half(f64 / 1)
+half(f64 / f32)
+half(f64 / f64)
+half(f64 / i32)
+half(f64 / i64)
+half(f64 ^ 0.5)
+half(f64 ^ 1)
+half(f64 ^ f32)
+half(f64 ^ i)
+half(f64 ^ i32)
+half(f64 ^ i64)
+half(f64)
+half(f64) != f32
+half(f64) != f64
+half(f64) != i64
+half(f64) * f32
+half(f64) * i64
+half(f64) ** (i32 * 0.5)
+half(f64) ** 0.5 ** i
+half(f64) ** f64
+half(f64) ** i64
+half(f64) + 1 + f64
+half(f64) + f64
+half(f64) + i
+half(f64) + i32
+half(f64) + i64
+half(f64) - f64
+half(f64) - i32
+half(f64) / f32
+half(f64) / f64
+half(f64) / i32
+half(f64) / i64
+half(f64) < f64
+half(f64) < i
+half(f64) < i32
+half(f64) < i64
+half(f64) <= 0.5 + f64
+half(f64) <= f64
+half(f64) <= i64
+half(f64) == i64
+half(f64) > abs(i)
+half(f64) > f32 * 0.5
+half(f64) > max(i64)
+half(f64) >= f32
+half(f64) >= i
+half(f64) >= i64
+half(f64) ^ f32
+half(false ? 0.5 : 0.5)
+half(float(-f64))
+half(float(0.5))
+half(float(1))
+half(float(f32))
+half(float(f64))
+half(float(i))
+half(float(i32))
+half(float(i64))
+half(greet == div ? "bar" : 0.5)
+half(half(0.5))
+half(half(f64))
+half(half(i - 0.5))
+half(i * 0.5)
+half(i * 1)
+half(i * f32)
+half(i * f64)
+half(i ** 0.5)
+half(i ** 1)
+half(i ** f32)
+half(i ** f64)
+half(i ** i)
+half(i ** i64)
+half(i + 0.5)
+half(i + 1)
+half(i + f32)
+half(i + f64)
+half(i - 0.5)
+half(i - 1)
+half(i - f64)
+half(i / 0.5)
+half(i / 1)
+half(i / f32)
+half(i / f64)
+half(i / i)
+half(i / i32)
+half(i / i64)
+half(i ^ 0.5)
+half(i ^ 1)
+half(i ^ f32)
+half(i ^ i32)
+half(i ^ i64)
+half(i32 * 0.5)
+half(i32 * 1)
+half(i32 * f32)
+half(i32 * f64)
+half(i32 ** 0.5)
+half(i32 ** 1)
+half(i32 ** f32)
+half(i32 ** f64)
+half(i32 ** i)
+half(i32 ** i32)
+half(i32 ** i64)
+half(i32 + 0.5)
+half(i32 + 1)
+half(i32 + f64)
+half(i32 - 0.5)
+half(i32 - 1)
+half(i32 - f32)
+half(i32 - f64)
+half(i32 / 0.5)
+half(i32 / 1)
+half(i32 / f32)
+half(i32 / f64)
+half(i32 / i)
+half(i32 / i32)
+half(i32 / i64)
+half(i32 ^ 0.5)
+half(i32 ^ 1)
+half(i32 ^ f32)
+half(i32 ^ i)
+half(i32 ^ i32)
+half(i32 ^ i64)
+half(i64 * 0.5)
+half(i64 * 1)
+half(i64 * f64)
+half(i64 ** 0.5)
+half(i64 ** 1)
+half(i64 ** f32)
+half(i64 ** f64)
+half(i64 ** i64)
+half(i64 + 0.5)
+half(i64 + 1)
+half(i64 + f32)
+half(i64 + f64)
+half(i64 - 0.5)
+half(i64 - 1)
+half(i64 - f32)
+half(i64 / 0.5)
+half(i64 / 1)
+half(i64 / f32)
+half(i64 / f64)
+half(i64 / i)
+half(i64 / i32)
+half(i64 / i64)
+half(i64 ^ 0.5)
+half(i64 ^ 1)
+half(i64 ^ f32)
+half(i64 ^ f64)
+half(i64 ^ i32)
+half(i64 ^ i64)
+half(max(0.5))
+half(max(0.5, f32))
+half(max(f64))
+half(min(0.5))
+half(min(0.5, 0.5))
+half(min(1, 0.5, 1))
+half(min(f64))
+half(ok ? 0.5 : f32)
+half(ok ? 0.5 : false)
+half(ok ? 0.5 : foo)
+half(true ? 0.5 : 0.5)
+hasPrefix("bar", "foo") != ok
+hasSuffix("foo", "foo") or 0.5 <= i
+i
+i != -0.5
+i != -1
+i != -f32
+i != -f64
+i != -i
+i != -i64
+i != 0.5 / 0.5
+i != 0.5 == ok
+i != 0.5 ? 1 : array
+i != 0.5 ? i32 : 0.5
+i != 0.5 ? score : score
+i != 1 % i64
+i != 1 * i
+i != 1 + 1
+i != 1 - 0.5
+i != 1 - 1
+i != 1 - i64
+i != 1 == ok
+i != 1 ? ok : i64
+i != 1 or i64 != 1
+i != f32
+i != f32 + i
+i != f32 / 1
+i != f32 ? div : list
+i != f64
+i != f64 * 0.5
+i != f64 + 1
+i != f64 / 0.5
+i != f64 ? 0.5 : nil
+i != f64 ? array : div
+i != f64 ? half : 1
+i != f64 || ok
+i != first(array)
+i != float(1)
+i != float(f32)
+i != float(f64)
+i != half(0.5)
+i != i
+i != i != nil
+i != i ^ f64
+i != i32
+i != i32 % i32
+i != i32 * f64
+i != i32 - i64
+i != i32 / i64
+i != i32 ? 1 : i
+i != i32 ? list : i
+i != i32 || half != nil
+i != i64
+i != i64 - f32
+i != i64 ? true : "foo"
+i != i64 ^ f64
+i != int(1)
+i != max(i32)
+i != min(1)
+i != nil != true
+i != nil ? ok : "bar"
+i != score(i)
+i % -1
+i % -i
+i % -i32
+i % -i64
+i % 1 != i64
+i % 1 .. i32
+i % 1 / i
+i % 1 >= i
+i % 1 >= i32
+i % array[i]
+i % first(array)
+i % get(array, i64)
+i % i
+i % i % i32
+i % i + i32
+i % i == i
+i % i in array
+i % i32
+i % i32 / i32
+i % i32 <= f32
+i % i64
+i % i64 != i
+i % int(i64)
+i % len(array)
+i % score(1)
+i % score(i)
+i * (0.5 + 0.5)
+i * (f32 + f32)
+i * (i32 + 0.5)
+i * (i32 - f64)
+i * (i64 + 1)
+i * -1
+i * -f32
+i * -i
+i * -i64
+i * 0.5 * f64
+i * 0.5 + i
+i * 0.5 - i
+i * 0.5 < i
+i * 0.5 <= i64 ** f64
+i * 1 % i
+i * 1 ** i32
+i * 1 / f64
+i * 1 / i64
+i * 1 <= f32
+i * abs(0.5)
+i * add(1, 1)
+i * array[i32]
+i * f32
+i * f32 != f32
+i * f32 ** 0.5
+i * f32 >= f32
+i * f32 ^ f32
+i * f64
+i * f64 * 1
+i * float(f64)
+i * half(f64)
+i * i
+i * i != i64
+i * i / f32
+i * i / f64
+i * i / i32
+i * i / i64
+i * i32
+i * i32 ** f64
+i * i32 ** i32
+i * i32 - i
+i * i32 / i32
+i * i32 <= i32
+i * i64
+i * i64 % i32
+i * i64 * 0.5
+i * i64 + f32
+i * i64 >= i32
+i * i64 ^ i64
+i * int(f64)
+i * int(i)
+i * int(i64)
+i * max(0.5)
+i * min(i64)
+i * score(1)
+i ** (0.5 + f64)
+i ** (0.5 + i64)
+i ** (1 * 1)
+i ** (1 - 0.5)
+i ** (i32 % i64)
+i ** (i32 - 1)
+i ** -0.5
+i ** -i
+i ** -i32
+i ** -i64
+i ** 0.5 ** 0.5
+i ** 0.5 ** 1
+i ** 0.5 < f32
+i ** 0.5 <= i64 ^ i32
+i ** 1 != f64
+i ** 1 ** 1
+i ** 1 ** f64
+i ** 1 ** i
+i ** 1 == f32
+i ** f32
+i ** f32 ** 0.5
+i ** f32 ** f64
+i ** f32 + f64
+i ** f32 <= f32
+i ** f32 <= i32 ? 1 : f32
+i ** f32 >= float(i64)
+i ** f64
+i ** f64 != f64
+i ** f64 < 1 / 0.5
+i ** float(0.5)
+i ** float(f32)
+i ** float(i32)
+i ** half(f64)
+i ** i
+i ** i + f64
+i ** i <= i
+i ** i ^ i
+i ** i32
+i ** i32 != i
+i ** i32 != i32
+i ** i32 + i32
+i ** i64
+i ** i64 ** 1
+i ** i64 ** f64
+i ** i64 ** i64
+i ** i64 - f64
+i ** i64 >= i
+i ** i64 >= i32
+i ** i64 ^ 1
+i ** int(1)
+i ** max(f32)
+i ** min(0.5, 1)
+i ** min(f32)
+i ** min(i)
+i ** min(i32)
+i ** score(1)
+i + -1
+i + -f32
+i + -f64
+i + -i
+i + 0.5 != i
+i + 0.5 ** i32
+i + 0.5 - i
+i + 0.5 < 1 + f32
+i + 0.5 <= i32
+i + 0.5 > f32
+i + 1 / array[i32]
+i + 1 / f32
+i + 1 <= f32
+i + 1 > i64
+i + 1 >= f64
+i + array[i32]
+i + count(list, false)
+i + f32
+i + f32 != f64
+i + f32 * i
+i + f32 ** i
+i + f64
+i + f64 <= i64
+i + f64 == f64
+i + float(0.5)
+i + float(f32)
+i + get(array, i64)
+i + half(0.5)
+i + half(f64)
+i + i
+i + i + f32
+i + i - i32
+i + i32
+i + i32 != i64
+i + i32 - 0.5
+i + i32 .. i
+i + i32 > f32
+i + i64
+i + i64 + f64
+i + i64 ^ 1
+i + int(f32)
+i + int(i64)
+i + last(array)
+i + len("bar")
+i + max(0.5)
+i + max(f32)
+i - -1
+i - -f32
+i - -i
+i - -i64
+i - 0.5 * 0.5
+i - 0.5 * 1
+i - 0.5 / 1
+i - 1 * 1
+i - 1 * i32
+i - 1 - i
+i - 1 ^ 0.5
+i - 1 ^ i32
+i - abs(0.5)
+i - abs(f32)
+i - abs(i32)
+i - f32
+i - f32 * i32
+i - f32 ** 1
+i - f32 + f64
+i - f32 - 1
+i - f32 / 0.5
+i - f32 / f32
+i - f32 / i32
+i - f32 ^ i64
+i - f64
+i - findIndex(list, ok)
+i - half(0.5)
+i - i
+i - i * 1
+i - i < i + f64
+i - i <= i
+i - i <= i32
+i - i >= f32
+i - i not in array
+i - i32
+i - i32 > len(array)
+i - i32 ^ 0.5
+i - i64
+i - i64 ** 1
+i - i64 + i32
+i - i64 - 1 / 1
+i - i64 - f64
+i - int(1)
+i - int(f32)
+i - int(i)
+i - last(array)
+i - max(0.5)
+i - max(i64)
+i - min(f32)
+i - score(1)
+i - score(i)
+i .. -i32
+i .. 1 % i32
+i .. 1 == array
+i .. abs(1)
+i .. abs(i32)
+i .. i
+i .. i % 1
+i .. i32
+i .. i32 == array
+i .. i64
+i .. i64 + i
+i .. i64 == list
+i .. int(i64)
+i .. last(array)
+i .. len(list)
+i .. min(1)
+i .. score(i)
+i / (f32 + f64)
+i / (f64 + f32)
+i / (i32 + f32)
+i / -0.5
+i / -1
+i / -i32
+i / -i64
+i / 0.5 * f32
+i / 0.5 * f64
+i / 0.5 ** f32
+i / 0.5 / i32
+i / 0.5 < i64
+i / 0.5 <= i64
+i / 0.5 == 0.5 - f64
+i / 0.5 >= i64
+i / 1 ** 1
+i / 1 / i64
+i / 1 == f64
+i / 1 ^ 1
+i / 1 ^ i64
+i / abs(i64)
+i / f32
+i / f32 != f32
+i / f32 ** i64
+i / f32 / i
+i / f64
+i / f64 * f32
+i / f64 - f32
+i / float(i32)
+i / half(0.5)
+i / half(f64)
+i / i
+i / i != i64
+i / i > i32
+i / i > i64
+i / i32
+i / i32 - i
+i / i32 / i
+i / i32 / i64
+i / i32 ^ f32
+i / i64
+i / i64 != i
+i / i64 ** f32
+i / i64 < i % 1
+i / i64 >= i32 ? div : div
+i / len("bar")
+i / len(list)
+i / max(1 / i)
+i / min(0.5)
+i / min(f64)
+i / min(i32)
+i / score(1)
+i / score(i)
+i < -(f32 - 1)
+i < -1
+i < -f32
+i < -i
+i < -i32
+i < 0.5 != false
+i < 0.5 != ok
+i < 0.5 * i
+i < 0.5 + 0.5
+i < 0.5 == ok
+i < 0.5 ? "bar" : "bar"
+i < 0.5 ? f32 : array
+i < 0.5 ? f32 : half
+i < 1 * 1
+i < 1 ** f32
+i < 1 == ok
+i < 1 ? false : nil
+i < abs(f64)
+i < f32
+i < f32 * i
+i < f32 ^ f32
+i < f64
+i < f64 * f64
+i < findIndex(list, ok)
+i < half(f32 ^ i64)
+i < half(f64)
+i < i
+i < i % 1
+i < i / 1
+i < i ? i32 : add
+i < i ^ 0.5
+i < i ^ i32
+i < i32
+i < i32 ** 0.5
+i < i32 - f32
+i < i32 == nil
+i < i64
+i < i64 && ok
+i < i64 - f64
+i < i64 - i32
+i < i64 ? nil : "foo"
+i < i64 ^ 0.5
+i < int(0.5)
+i < int(i64)
+i < len(array)
+i < len(list)
+i < min(i64)
+i < score(1)
+i < score(i)
+i <= -f32
+i <= -i
+i <= -i64
+i <= 0.5 ** 0.5
+i <= 0.5 ** f32
+i <= 0.5 == nil
+i <= 0.5 ? score : array
+i <= 1 != all(array, true)
+i <= 1 != nil
+i <= 1 % i
+i <= 1 + 1
+i <= 1 - f64
+i <= 1 ? ok : 1
+i <= abs(1)
+i <= abs(i32)
+i <= add(1, 1)
+i <= f32
+i <= f32 != nil
+i <= f32 * 0.5
+i <= f32 / f32
+i <= f32 ? ok : 1
+i <= f32 or ok
+i <= f64
+i <= f64 * 1
+i <= f64 == nil
+i <= f64 ? foo : div
+i <= f64 or add == greet
+i <= float(f64)
+i <= float(i)
+i <= float(i32)
+i <= half(-1)
+i <= half(0.5)
+i <= i
+i <= i ** 1
+i <= i == true
+i <= i32
+i <= i32 - f32
+i <= i32 - i64
+i <= i64
+i <= i64 % i32
+i <= i64 / 1
+i <= i64 ? ok : 1
+i <= int(1)
+i <= int(i32)
+i <= len("bar")
+i <= len(array)
+i <= max(i)
+i <= min(f32)
+i <= min(f64)
+i <= min(i)
+i <= min(i64)
+i == -0.5
+i == -1
+i == -f32
+i == -f64
+i == -i
+i == -i32
+i == -i64
+i == 0.5 + f32
+i == 0.5 - i32
+i == 0.5 == ok
+i == 0.5 ? false : true
+i == 0.5 ? list : i32
+i == 0.5 ^ 0.5
+i == 1 != true
+i == 1 % i
+i == 1 * f32
+i == 1 ** 1
+i == 1 ? foo : list
+i == 1 || ok
+i == abs(0.5)
+i == abs(1)
+i == div(1, i)
+i == f32
+i == f32 * i64
+i == f64
+i == f64 != nil
+i == f64 + i64
+i == f64 == ok
+i == i
+i == i - f64
+i == i / i32
+i == i ? ok : score
+i == i ^ i
+i == i32
+i == i32 ** f32
+i == i32 ** i
+i == i32 ? list : foo
+i == i64
+i == i64 != ok
+i == i64 + i32
+i == i64 ? array : 0.5
+i == i64 ? score : 1
+i == i64 ^ f64
+i == int(f64)
+i == len(array)
+i == max(0.5)
+i == max(i64)
+i == min(i)
+i == nil ? false : 1
+i == score(1)
+i > -i64
+i > 0.5 * f64
+i > 0.5 ** 0.5
+i > 0.5 / 0.5
+i > 0.5 / 1
+i > 0.5 == nil
+i > 0.5 ^ 0.5
+i > 1 ? greet : "bar"
+i > 1 ? greet : f64
+i > abs(i64)
+i > array[i]
+i > f32
+i > f64
+i > f64 + 0.5
+i > float(1)
+i > half(f64)
+i > i
+i > i ** i32
+i > i ** i64
+i > i / i
+i > i or ok
+i > i32
+i > i32 ? 1 : true
+i > i32 ? foo : score
+i > i32 ^ i
+i > i64
+i > int(0.5)
+i > int(i)
+i > int(i32)
+i > max(f32)
+i > max(i)
+i > min(0.5)
+i > score(i)
+i > score(len(array))
+i >= -0.5
+i >= -1
+i >= -i32
+i >= -i64
+i >= 0.5 ** f64
+i >= 0.5 + i32
+i >= 0.5 - 1
+i >= 0.5 == nil
+i >= 0.5 ? div : i
+i >= 0.5 ? score : f64
+i >= 1 / i
+i >= 1 ? nil : 0.5
+i >= abs(0.5)
+i >= abs(i64)
+i >= f32
+i >= f32 ** f64
+i >= f32 - i
+i >= f32 ? "bar" : array
+i >= f32 ? score : half
+i >= f64
+i >= f64 * i32
+i >= f64 + i32
+i >= f64 - i
+i >= i
+i >= i ** 0.5
+i >= i / 1
+i >= i / i
+i >= i == nil
+i >= i == ok
+i >= i32
+i >= i32 ** 0.5
+i >= i32 - f64
+i >= i32 ? f64 : div
+i >= i64
+i >= i64 * i
+i >= i64 ^ 0.5
+i >= int(i32)
+i >= len("foo")
+i >= min(f32 ^ i64)
+i >= score(i)
+i ^ (0.5 * 1)
+i ^ (0.5 - 0.5)
+i ^ (f32 * 1)
+i ^ (f32 * f32)
+i ^ (f32 * f64)
+i ^ (f32 / f64)
+i ^ (i * 1)
+i ^ (i - i64)
+i ^ (i32 % 1)
+i ^ (i32 + i)
+i ^ (i32 / 0.5)
+i ^ (i64 / 0.5)
+i ^ (i64 / 1)
+i ^ --f32
+i ^ -1
+i ^ -i
+i ^ -i32
+i ^ -i64
+i ^ 0.5 != 1 + i
+i ^ 0.5 * f32
+i ^ 0.5 - i
+i ^ 0.5 / f64
+i ^ 0.5 <= f32
+i ^ 0.5 > i64
+i ^ 0.5 ^ f32
+i ^ 1 != f32
+i ^ 1 * f32
+i ^ 1 ** i
+i ^ 1 - f32
+i ^ 1 / i32
+i ^ 1 ^ i64
+i ^ abs(1)
+i ^ abs(f32)
+i ^ abs(i64)
+i ^ add(1, 1)
+i ^ array[i]
+i ^ f32
+i ^ f32 != 1 - i
+i ^ f32 != i64 ? list : i32
+i ^ f32 + f64
+i ^ f32 / i
+i ^ f32 < i
+i ^ f32 >= i32
+i ^ f64
+i ^ f64 * i
+i ^ f64 >= f64
+i ^ find(array, true)
+i ^ float(f64)
+i ^ i
+i ^ i ** f64
+i ^ i + i32
+i ^ i >= f64
+i ^ i32
+i ^ i32 - f32
+i ^ i32 == i64 * i
+i ^ i32 >= f64
+i ^ i32 >= max(i64)
+i ^ i64
+i ^ i64 * i64
+i ^ i64 ** i
+i ^ i64 == f32
+i ^ i64 >= i64 ^ f32
+i ^ i64 ^ f64
+i ^ int(f32)
+i ^ max(1)
+i ^ min(i32)
+i ^ score(1)
+i in array
+i in array == ok
+i in array ? f32 : greet
+i in array ? foo : false
+i in array || ok
+i not in array
+i not in array ? foo : list
+i not in array and true
+i not in i64 .. 1
+i not in map(array, #)
+i not in {"foo": 1}.div
+i32
+i32 != -0.5
+i32 != -1
+i32 != -f32
+i32 != -i
+i32 != 0.5 && nil == i64
+i32 != 1 && ok
+i32 != 1 * i64
+i32 != 1 + 1
+i32 != 1 / 1
+i32 != 1 ? 0.5 : greet
+i32 != 1 ? false : i64
+i32 != 1 ? greet : half
+i32 != 1 ? greet : ok
+i32 != abs(i64)
+i32 != array[i]
+i32 != count(array, ok)
+i32 != f32
+i32 != f32 && ok
+i32 != f32 / f64
+i32 != f32 ? f64 : i32
+i32 != f32 and ok
+i32 != f64
+i32 != f64 == true
+i32 != findIndex(list, false)
+i32 != first(array)
+i32 != float(i)
+i32 != get(array, i64)
+i32 != half(f64)
+i32 != i
+i32 != i ** 1
+i32 != i ** f64
+i32 != i32
+i32 != i32 * 1
+i32 != i32 - 0.5
+i32 != i32 ? array : add
+i32 != i64
+i32 != i64 % i32
+i32 != i64 * 0.5
+i32 != i64 ? div : nil
+i32 != i64 ? true : nil
+i32 != int(f32)
+i32 != max(1)
+i32 != max(f64, 0.5)
+i32 != min(1, 0.5, f64)
+i32 != min(i)
+i32 != nil ? half : 1
+i32 != nil ? list : half(nil)
+i32 % -i
+i32 % -i32
+i32 % 1 != i64
+i32 % 1 % (i64 + i64)
+i32 % 1 % i64
+i32 % 1 * f64
+i32 % 1 + f64
+i32 % 1 > i
+i32 % add(1, 1)
+i32 % count(list, ok)
+i32 % i
+i32 % i != f32
+i32 % i32
+i32 % i32 != i
+i32 % i32 * f32
+i32 % i32 * i
+i32 % i64
+i32 % i64 != f32
+i32 % i64 / i32
+i32 % i64 == i
+i32 % i64 >= i64
+i32 % min(1, i64)
+i32 % min(i)
+i32 * (f32 + 1)
+i32 * (f32 + f32)
+i32 * (f32 + i)
+i32 * (f64 - f32)
+i32 * (i32 - 0.5)
+i32 * (i32 - f64)
+i32 * (i32 - i64)
+i32 * -f32
+i32 * -f64
+i32 * -i
+i32 * 0.5 ** 0.5
+i32 * 0.5 + f64
+i32 * 0.5 <= f32
+i32 * 1 % i64
+i32 * 1 * f32
+i32 * 1 * i32
+i32 * 1 < i
+i32 * array[i32]
+i32 * count(array, true)
+i32 * f32
+i32 * f32 != i
+i32 * f64
+i32 * f64 * i
+i32 * f64 + f32
+i32 * f64 / i
+i32 * f64 > i32
+i32 * i
+i32 * i != i32
+i32 * i * 0.5
+i32 * i .. i
+i32 * i / array[i32]
+i32 * i / i32
+i32 * i / i64
+i32 * i32
+i32 * i32 % i32
+i32 * i32 * 0.5
+i32 * i32 ** 1
+i32 * i32 - f32
+i32 * i32 == i32
+i32 * i64
+i32 * i64 % 1
+i32 * i64 .. i
+i32 * i64 / 1
+i32 * i64 / i32
+i32 * int(f32)
+i32 * max(f64)
+i32 * max(i64)
+i32 * min(1)
+i32 ** (0.5 * 0.5)
+i32 ** (0.5 + 0.5)
+i32 ** (0.5 + i32)
+i32 ** (0.5 / f64)
+i32 ** (f32 / i)
+i32 ** (f64 + 0.5)
+i32 ** (i + 1)
+i32 ** (i64 - i)
+i32 ** -1 ^ i32
+i32 ** -f32
+i32 ** -i32
+i32 ** -i64
+i32 ** 0.5 / f32
+i32 ** 0.5 <= i32
+i32 ** 0.5 ^ i
+i32 ** 1 ** i64
+i32 ** 1 + f64
+i32 ** 1 + i64
+i32 ** 1 - f32
+i32 ** 1 >= i64 * 0.5
+i32 ** 1 ^ f64
+i32 ** array[i]
+i32 ** f32
+i32 ** f32 ** i
+i32 ** f32 == i64
+i32 ** f64
+i32 ** f64 != i64 ? i : half
+i32 ** f64 + f64
+i32 ** f64 >= i
+i32 ** f64 ^ f32
+i32 ** float(1)
+i32 ** float(f64)
+i32 ** half(0.5)
+i32 ** i
+i32 ** i ** 0.5
+i32 ** i ^ 0.5
+i32 ** i32
+i32 ** i64
+i32 ** i64 != 0.5 == true
+i32 ** i64 - f64
+i32 ** i64 / f64
+i32 ** i64 / i
+i32 ** i64 > i
+i32 ** i64 ^ 1
+i32 ** i64 ^ i
+i32 ** int(0.5)
+i32 ** int(f64)
+i32 ** len(array)
+i32 ** min(f64)
+i32 ** min(i32)
+i32 ** score(1)
+i32 ** score(i)
+i32 + -0.5
+i32 + -1
+i32 + -f32
+i32 + -f64
+i32 + -i
+i32 + -i32
+i32 + 0.5 * 0.5
+i32 + 0.5 * i32
+i32 + 0.5 + 1
+i32 + 0.5 + i64
+i32 + 0.5 - 0.5
+i32 + 0.5 - f32
+i32 + 0.5 <= i
+i32 + 0.5 > i % 1
+i32 + 0.5 >= i
+i32 + 1 / f64
+i32 + 1 < i32
+i32 + 1 ^ i
+i32 + 1 ^ i32
+i32 + abs(i32)
+i32 + count(array, false)
+i32 + f32
+i32 + f64
+i32 + f64 * 1
+i32 + f64 * f64
+i32 + f64 ** 0.5
+i32 + f64 - f32 * 0.5
+i32 + f64 == i32
+i32 + f64 >= i
+i32 + f64 ^ i32
+i32 + find(array, ok)
+i32 + i
+i32 + i * 1
+i32 + i - f32
+i32 + i > half(f64)
+i32 + i >= -1
+i32 + i32
+i32 + i32 ** 0.5
+i32 + i32 >= f32
+i32 + i32 ^ i64
+i32 + i64
+i32 + i64 + i64
+i32 + i64 / f64
+i32 + i64 <= f32
+i32 + i64 ^ f32
+i32 + i64 not in array
+i32 + int(f64)
+i32 + last(array)
+i32 + len("foo")
+i32 + len(list)
+i32 + min(0.5, i32)
+i32 + min(1, i)
+i32 + min(i)
+i32 + min(i, i32)
+i32 + score(i)
+i32 - -0.5
+i32 - -1
+i32 - -f32
+i32 - -i32
+i32 - -i64
+i32 - 0.5 * 0.5
+i32 - 0.5 * i64
+i32 - 0.5 + i
+i32 - 0.5 + i32
+i32 - 0.5 - f32
+i32 - 0.5 < i32
+i32 - 0.5 <= f64
+i32 - 1 != f32
+i32 - 1 * f32
+i32 - 1 ** i32
+i32 - 1 / 0.5
+i32 - 1 <= i64
+i32 - 1 not in array
+i32 - array[1]
+i32 - f32
+i32 - f32 * f32
+i32 - f32 ** f64
+i32 - f32 + 0.5
+i32 - f32 / f64
+i32 - f64
+i32 - f64 ** f64
+i32 - f64 + 0.5
+i32 - f64 - i64
+i32 - f64 / i64
+i32 - f64 < i64
+i32 - first(array)
+i32 - float(i)
+i32 - get(array, i64)
+i32 - i
+i32 - i % i
+i32 - i + f32
+i32 - i - 1
+i32 - i / i
+i32 - i <= i64
+i32 - i == i
+i32 - i > f64
+i32 - i >= f64
+i32 - i32
+i32 - i32 ** 0.5
+i32 - i32 <= i32 + i64
+i32 - i32 ^ 1
+i32 - i64
+i32 - i64 % i
+i32 - i64 % i64
+i32 - i64 .. i
+i32 - i64 <= i
+i32 - i64 ^ 0.5
+i32 - i64 ^ f64
+i32 - int(1)
+i32 - int(f64)
+i32 - max(i64)
+i32 - max(i64, i)
+i32 - min(0.5)
+i32 - score(i)
+i32 .. -1
+i32 .. -i
+i32 .. -i32
+i32 .. -i64
+i32 .. 1 - 1
+i32 .. abs(i)
+i32 .. array[i32]
+i32 .. count(array, ok)
+i32 .. i
+i32 .. i - 1
+i32 .. i32
+i32 .. i32 != list
+i32 .. i64
+i32 .. i64 - i32
+i32 .. int(0.5)
+i32 .. len(list)
+i32 .. min(1)
+i32 .. min(1, 0.5)
+i32 .. min(i32)
+i32 .. min(i64)
+i32 .. score(i)
+i32 / (0.5 + i32)
+i32 / (1 + f32)
+i32 / (1 - f32)
+i32 / (1 - i)
+i32 / (f32 + i)
+i32 / (f32 - f64)
+i32 / (f64 + 0.5)
+i32 / (f64 - 1)
+i32 / (i32 - 1)
+i32 / -0.5
+i32 / -1
+i32 / -f32
+i32 / -i
+i32 / -i32
+i32 / 0.5 * i
+i32 / 0.5 / i64
+i32 / 0.5 >= f64
+i32 / 1 != f64
+i32 / 1 < i32
+i32 / abs(0.5)
+i32 / f32
+i32 / f64
+i32 / f64 * i32
+i32 / f64 >= f32
+i32 / half(f64)
+i32 / i
+i32 / i <= i
+i32 / i32
+i32 / i32 * 1
+i32 / i32 / f32 / f64
+i32 / i32 / i64
+i32 / i64
+i32 / i64 != i64
+i32 / i64 * i
+i32 / i64 / i
+i32 / i64 == f32
+i32 / i64 == f64
+i32 / int(i)
+i32 / len("bar")
+i32 / len("foo")
+i32 / max(i32)
+i32 / min(f32)
+i32 / min(f64)
+i32 / min(i)
+i32 / min(i32)
+i32 < -(i - f32)
+i32 < -0.5
+i32 < -f32
+i32 < -i32
+i32 < 0.5 ** i32
+i32 < 0.5 - f32
+i32 < 0.5 ^ 1
+i32 < 1 % 1
+i32 < 1 ** 1
+i32 < 1 + 0.5
+i32 < 1 + 1
+i32 < 1 ? "foo" : i32
+i32 < 1 ? 1 : 0.5
+i32 < 1 ^ i32
+i32 < abs(i64)
+i32 < div(1, 1)
+i32 < f32
+i32 < f32 == nil
+i32 < f32 ? div : true
+i32 < f32 || i64 != f32
+i32 < f64
+i32 < f64 != nil
+i32 < f64 != true
+i32 < f64 * f32
+i32 < f64 == nil
+i32 < f64 ? f32 : half
+i32 < f64 ? greet : false
+i32 < f64 ? list : i32
+i32 < f64 ^ f32
+i32 < f64 || 1 < 1
+i32 < float(i)
+i32 < float(i32)
+i32 < half(0.5)
+i32 < i
+i32 < i != true
+i32 < i ^ 0.5
+i32 < i32
+i32 < i32 != ok
+i32 < i32 * f32
+i32 < i32 / i32
+i32 < i32 ? ok : 1
+i32 < i64
+i32 < i64 - 0.5
+i32 < i64 ^ f64
+i32 < int(0.5)
+i32 < int(i32)
+i32 < int(i64)
+i32 < max(0.5)
+i32 < max(1)
+i32 < min(1, i32)
+i32 < min(f64)
+i32 < min(i)
+i32 < min(i64)
+i32 < score(1)
+i32 <= -0.5
+i32 <= -f32
+i32 <= -i
+i32 <= -i32
+i32 <= 0.5 != nil
+i32 <= 0.5 != ok
+i32 <= 0.5 * 0.5
+i32 <= 0.5 * i
+i32 <= 0.5 + i64
+i32 <= 1 ? i : f32
+i32 <= 1 ? true : true
+i32 <= 1 or 0.5 == 0.5
+i32 <= abs(i32)
+i32 <= count(list, ok)
+i32 <= f32
+i32 <= f32 * i64
+i32 <= f32 / 0.5
+i32 <= f32 ^ i64
+i32 <= f64
+i32 <= f64 * i
+i32 <= f64 ^ 1
+i32 <= float(i)
+i32 <= half(0.5)
+i32 <= i
+i32 <= i % i64
+i32 <= i32
+i32 <= i32 != nil
+i32 <= i32 % 1
+i32 <= i32 ** f64
+i32 <= i64
+i32 <= i64 != false
+i32 <= i64 != ok
+i32 <= i64 + f32
+i32 <= i64 ? div : nil
+i32 <= last(array)
+i32 <= len(array)
+i32 <= len(list)
+i32 <= max(f64)
+i32 <= min(i)
+i32 <= score(1)
+i32 <= score(i)
+i32 == -0.5
+i32 == -1
+i32 == -f64
+i32 == -i
+i32 == -i64
+i32 == 0.5 / f64
+i32 == 0.5 ? half : array
+i32 == 0.5 ^ i
+i32 == 0.5 ^ i64
+i32 == 1 ** 1
+i32 == 1 ** i
+i32 == 1 || f32 < f64
+i32 == f32
+i32 == f32 ? f32 : nil
+i32 == f32 ? half : "bar"
+i32 == f32 ? score : false
+i32 == f32 or ok
+i32 == f64
+i32 == f64 != ok
+i32 == f64 * 0.5
+i32 == f64 ** f32
+i32 == f64 ** i64
+i32 == f64 ? add : half
+i32 == findLastIndex(array, ok)
+i32 == float(i)
+i32 == half(0.5)
+i32 == i
+i32 == i % i64
+i32 == i ? "foo" : greet
+i32 == i ? type(false) : array
+i32 == i ^ f64
+i32 == i and ok
+i32 == i || ok
+i32 == i32
+i32 == i32 ? add : add
+i32 == i32 ? f32 : f64
+i32 == i32 ^ 1
+i32 == i64
+i32 == i64 + f32
+i32 == i64 ? foo : list
+i32 == len(list)
+i32 == max(0.5)
+i32 == min(f32)
+i32 == min(i32)
+i32 == nil ? f32 : add
+i32 == nil and ok
+i32 == {"foo": f32, "foo": list}?.String?.Qux
+i32 > -0.5
+i32 > -1
+i32 > -f32
+i32 > -f64
+i32 > -i
+i32 > -i32
+i32 > -i64
+i32 > 0.5 != ok
+i32 > 0.5 != true
+i32 > 0.5 * f64
+i32 > 0.5 ** f32
+i32 > 0.5 ** i
+i32 > 0.5 + 0.5
+i32 > 0.5 + 1
+i32 > 0.5 - 1
+i32 > 0.5 / i64
+i32 > 0.5 == nil
+i32 > 0.5 ? greet : f32
+i32 > 0.5 ? ok : false
+i32 > 0.5 ^ f32
+i32 > 1 ** f64
+i32 > 1 - i
+i32 > 1 / 1
+i32 > 1 ? i : add
+i32 > 1 || ok
+i32 > abs(1)
+i32 > abs(f64)
+i32 > array[1]
+i32 > array[i32]
+i32 > f32
+i32 > f32 != ok
+i32 > f32 && "bar" == nil
+i32 > f32 * i64
+i32 > f32 ? "bar" : half
+i32 > f64
+i32 > f64 * 0.5
+i32 > f64 - 1
+i32 > f64 / 1
+i32 > f64 / i32
+i32 > f64 == nil
+i32 > f64 == ok
+i32 > f64 == true
+i32 > f64 ? 0.5 : add
+i32 > f64 ^ i64
+i32 > float(i)
+i32 > float(i32)
+i32 > half(0.5)
+i32 > half(f64)
+i32 > i
+i32 > i + f32
+i32 > i / f32
+i32 > i ^ i32
+i32 > i32
+i32 > i32 - 0.5
+i32 > i32 ? "bar" : div
+i32 > i32 ? array : 0.5
+i32 > i32 ? foo : 1
+i32 > i64
+i32 > i64 ** f32
+i32 > i64 + f64
+i32 > i64 - i
+i32 > i64 ? list : list
+i32 > int(i)
+i32 > int(i64)
+i32 > max(i)
+i32 > min(0.5)
+i32 > score(1)
+i32 >= -0.5
+i32 >= -1
+i32 >= -i
+i32 >= 0.5 ** 0.5
+i32 >= 0.5 ^ f32
+i32 >= 0.5 || ok
+i32 >= 1 && ok
+i32 >= abs(i)
+i32 >= abs(i64)
+i32 >= array[i]
+i32 >= f32
+i32 >= f32 != true
+i32 >= f32 - 0.5
+i32 >= f32 ^ 0.5
+i32 >= f64
+i32 >= f64 && nil == 0.5
+i32 >= f64 - f64
+i32 >= f64 / 1
+i32 >= f64 ? f32 : list
+i32 >= f64 ^ 1
+i32 >= float(1)
+i32 >= half(0.5)
+i32 >= half(f64)
+i32 >= i
+i32 >= i % i64
+i32 >= i ** i32
+i32 >= i / i
+i32 >= i ? div : list
+i32 >= i ? foo : 0.5
+i32 >= i32
+i32 >= i64
+i32 >= i64 != ok
+i32 >= i64 ** i64
+i32 >= i64 / i64
+i32 >= i64 ? list : greet
+i32 >= i64 ^ i32
+i32 >= int(i64)
+i32 >= last(array)
+i32 >= len(array)
+i32 >= min(i32)
+i32 >= score(1)
+i32 >= score(i)
+i32 ^ (f32 + i64)
+i32 ^ (f64 + 0.5)
+i32 ^ (i - f64)
+i32 ^ (i32 + f32)
+i32 ^ (i64 % i)
+i32 ^ (i64 * 0.5)
+i32 ^ (i64 + f32)
+i32 ^ (i64 - f64)
+i32 ^ --0.5
+i32 ^ -0.5
+i32 ^ -f64
+i32 ^ -i32
+i32 ^ 0.5 ** i
+i32 ^ 0.5 + i32
+i32 ^ 0.5 - i
+i32 ^ 0.5 < i
+i32 ^ 0.5 == i64
+i32 ^ abs(1)
+i32 ^ f32
+i32 ^ f32 * i64
+i32 ^ f32 ** 0.5
+i32 ^ f32 ** i
+i32 ^ f32 < 0.5 * i
+i32 ^ f32 ^ i
+i32 ^ f64
+i32 ^ f64 ^ 1
+i32 ^ float(f32)
+i32 ^ half(0.5)
+i32 ^ half(f64)
+i32 ^ i
+i32 ^ i + i32
+i32 ^ i - f32
+i32 ^ i <= f32
+i32 ^ i ^ 1
+i32 ^ i32
+i32 ^ i32 ** f32
+i32 ^ i32 ** f64
+i32 ^ i32 + i32
+i32 ^ i32 + i64
+i32 ^ i32 <= i64
+i32 ^ i64
+i32 ^ i64 - f32
+i32 ^ max(0.5)
+i32 ^ max(1)
+i32 ^ max(i)
+i32 ^ min(f32)
+i32 ^ score(1)
+i32 in array
+i32 in map(array, #)
+i32 not in array
+i32 not in array ? score : score
+i32 not in map(array, #)
+i32 not in map(array, 1)
+i64
+i64 != -0.5
+i64 != -1
+i64 != -f32
+i64 != -f64
+i64 != -i
+i64 != 0.5 != nil
+i64 != 0.5 != ok
+i64 != 0.5 != true
+i64 != 0.5 * 1
+i64 != 0.5 ? false : i64
+i64 != 0.5 ^ 1
+i64 != 0.5 and f64 == 1
+i64 != 1 || f64 < i
+i64 != 1 || ok
+i64 != abs(f64)
+i64 != f32
+i64 != f32 + f32
+i64 != f32 / f32
+i64 != f32 ? div : 1
+i64 != f32 ? f64 : i64
+i64 != f32 ^ i
+i64 != f64
+i64 != f64 != false
+i64 != f64 - i32
+i64 != f64 / i32
+i64 != f64 / i64
+i64 != f64 ? 0.5 : score
+i64 != f64 ? i64 : true
+i64 != findLast(array, false)
+i64 != first(array)
+i64 != float(i32)
+i64 != get(array, i64)
+i64 != half(0.5)
+i64 != half(f64)
+i64 != i
+i64 != i == nil
+i64 != i ? array : f32
+i64 != i and ok
+i64 != i32
+i64 != i32 ? 1 : f32
+i64 != i64
+i64 != i64 ? true : score
+i64 != last(array)
+i64 != len("foo")
+i64 != min(0.5)
+i64 != min(f32)
+i64 != min(f64)
+i64 != min(i64)
+i64 != nil && ok
+i64 != score(1)
+i64 % -1
+i64 % -i
+i64 % -i32
+i64 % 1 * i32
+i64 % 1 .. i
+i64 % 1 / 0.5
+i64 % 1 / f64
+i64 % 1 < i32
+i64 % 1 <= -i32
+i64 % 1 == 0.5 + 0.5
+i64 % 1 not in array
+i64 % abs(i64)
+i64 % array[1]
+i64 % find(array, true)
+i64 % first(array)
+i64 % i
+i64 % i .. i32
+i64 % i not in array
+i64 % i32
+i64 % i32 != f64
+i64 % i32 * f32
+i64 % i32 == i
+i64 % i32 > f64 ^ i32
+i64 % i64
+i64 % i64 * 1
+i64 % i64 * f32
+i64 % i64 + -i64
+i64 % max(i32)
+i64 % min(i)
+i64 % score(1)
+i64 * (0.5 + i64)
+i64 * (0.5 - 1)
+i64 * (1 + 1)
+i64 * (f64 + f32)
+i64 * (f64 - i)
+i64 * (i - 1)
+i64 * (i64 + 0.5)
+i64 * --f64
+i64 * -0.5
+i64 * -1
+i64 * -f32
+i64 * -f64
+i64 * 0.5 != f64
+i64 * 0.5 * i32
+i64 * 0.5 - f32
+i64 * 0.5 < f32
+i64 * 0.5 == min(i64)
+i64 * 0.5 >= f32
+i64 * 0.5 ^ i
+i64 * 1 * 1
+i64 * 1 .. i32
+i64 * 1 <= i64
+i64 * 1 == i32
+i64 * 1 >= i32
+i64 * array[i32]
+i64 * f32
+i64 * f32 - f32
+i64 * f32 / f64
+i64 * f32 >= i64
+i64 * f32 ^ i
+i64 * f32 ^ i32
+i64 * f64
+i64 * f64 * i32
+i64 * f64 ^ f64
+i64 * float(i64)
+i64 * get(array, i64)
+i64 * half(f64)
+i64 * i
+i64 * i * i64
+i64 * i == i32
+i64 * i ^ i64
+i64 * i32
+i64 * i32 ** f32
+i64 * i32 >= f64
+i64 * i32 >= i64
+i64 * i32 ^ 1
+i64 * i64
+i64 * i64 ** 1
+i64 * i64 ** f32
+i64 * i64 - f64
+i64 * i64 in array
+i64 * int(1)
+i64 * min(f32, 0.5)
+i64 * score(1)
+i64 ** (0.5 * i64)
+i64 ** (0.5 + 1)
+i64 ** (1 % i)
+i64 ** (f64 / i)
+i64 ** (i * 0.5)
+i64 ** (i - i)
+i64 ** (i32 + i)
+i64 ** -1
+i64 ** -i
+i64 ** -i32
+i64 ** 0.5 * f64
+i64 ** 0.5 + f32
+i64 ** 0.5 + f32 - 1
+i64 ** 0.5 - i
+i64 ** 0.5 ^ 1
+i64 ** 0.5 ^ f32
+i64 ** 1 != i
+i64 ** 1 ** f32
+i64 ** 1 ** float(1)
+i64 ** 1 / f64
+i64 ** 1 / i
+i64 ** 1 == i64
+i64 ** 1 ^ i64
+i64 ** abs(f32)
+i64 ** abs(i64)
+i64 ** f32
+i64 ** f32 != f64
+i64 ** f32 != i64
+i64 ** f32 ** i32
+i64 ** f32 / i64 / 1
+i64 ** f32 <= i64
+i64 ** f32 > f32
+i64 ** f64
+i64 ** f64 / i
+i64 ** f64 <= f32
+i64 ** f64 > f64
+i64 ** f64 >= f64
+i64 ** f64 >= i32
+i64 ** float(1)
+i64 ** half(0.5)
+i64 ** i
+i64 ** i32
+i64 ** i32 != f32
+i64 ** i32 <= f64
+i64 ** i32 <= min(0.5)
+i64 ** i64
+i64 ** i64 / f64
+i64 ** i64 >= f64
+i64 ** int(0.5)
+i64 ** int(f64)
+i64 ** len("foo")
+i64 ** min(0.5)
+i64 ** score(1)
+i64 + -(f32 / i)
+i64 + -0.5
+i64 + -f32
+i64 + -f64
+i64 + -i
+i64 + -i64
+i64 + 0.5 * i
+i64 + 0.5 ** 1
+i64 + 0.5 + 1
+i64 + 0.5 + i32
+i64 + 1 % i
+i64 + 1 ** i
+i64 + 1 + i32
+i64 + 1 - f64
+i64 + 1 - i32
+i64 + 1 .. i
+i64 + 1 < i32
+i64 + 1 < i64
+i64 + 1 <= i
+i64 + 1 == i
+i64 + abs(1)
+i64 + f32
+i64 + f32 ** 1
+i64 + f32 >= f64
+i64 + f64
+i64 + f64 != f32
+i64 + f64 + i
+i64 + f64 <= f32
+i64 + f64 == i32
+i64 + findIndex(list, ok)
+i64 + first(array)
+i64 + get(array, i32)
+i64 + half(0.5)
+i64 + half(f64)
+i64 + i
+i64 + i + i
+i64 + i - f64
+i64 + i / 1
+i64 + i32
+i64 + i32 * 1
+i64 + i32 * i
+i64 + i32 < f64
+i64 + i32 >= f32
+i64 + i32 in array
+i64 + i64
+i64 + i64 % i64
+i64 + i64 ** f32
+i64 + i64 + 0.5
+i64 + i64 - int(f64)
+i64 + i64 ^ i
+i64 + max(f32)
+i64 + min(0.5)
+i64 + min(1)
+i64 + min(f32)
+i64 + min(i32)
+i64 + score(i)
+i64 - -1
+i64 - -f32
+i64 - -i32
+i64 - -i64
+i64 - 0.5 != i32
+i64 - 0.5 * 1
+i64 - 0.5 + f32
+i64 - 0.5 + f64
+i64 - 0.5 / f64
+i64 - 0.5 == -0.5
+i64 - 0.5 ^ i32
+i64 - 1 - 0.5
+i64 - 1 - f32
+i64 - 1 - i32
+i64 - 1 == i32
+i64 - 1 >= f64
+i64 - 1 >= i
+i64 - abs(1)
+i64 - abs(i32)
+i64 - array[i64]
+i64 - f32
+i64 - f32 != score(i)
+i64 - f32 * i32
+i64 - f32 - 1
+i64 - f32 <= f64
+i64 - f32 ^ f32
+i64 - f64
+i64 - f64 ** 0.5
+i64 - float(0.5)
+i64 - float(f32)
+i64 - float(i)
+i64 - i
+i64 - i != i32
+i64 - i * i64
+i64 - i + i32
+i64 - i - i64
+i64 - i > f64 - 0.5
+i64 - i >= i
+i64 - i ^ i64
+i64 - i32
+i64 - i32 % i32
+i64 - i32 + i32
+i64 - i32 <= i
+i64 - i64
+i64 - i64 + i32
+i64 - i64 .. i64
+i64 - i64 / i32
+i64 - max(f64)
+i64 - min(1, 0.5)
+i64 - score(1)
+i64 .. -1
+i64 .. -i64
+i64 .. 1 == list
+i64 .. findIndex(list, ok)
+i64 .. get(array, 1)
+i64 .. i
+i64 .. i32
+i64 .. i32 * i
+i64 .. i64
+i64 .. i64 + 1
+i64 .. int(f32)
+i64 .. int(i32)
+i64 .. last(array)
+i64 .. len(list)
+i64 .. score(1)
+i64 / (0.5 + f64)
+i64 / (1 - 0.5)
+i64 / (i32 - 1)
+i64 / -0.5
+i64 / -1
+i64 / -f32
+i64 / -f64
+i64 / -i
+i64 / -i64
+i64 / 0.5 < f64
+i64 / 0.5 == f32
+i64 / 0.5 ^ f64
+i64 / 1 ** 1
+i64 / 1 - f32
+i64 / 1 - min(0.5)
+i64 / 1 / 0.5
+i64 / abs(i64)
+i64 / array[i]
+i64 / f32
+i64 / f32 ** i
+i64 / f32 <= i
+i64 / f64
+i64 / f64 * 1
+i64 / f64 ** 0.5
+i64 / f64 ** f64
+i64 / f64 + i32
+i64 / f64 <= f32
+i64 / f64 <= i64
+i64 / float(f32)
+i64 / float(f64)
+i64 / float(i)
+i64 / float(i64)
+i64 / half(0.5)
+i64 / half(f64)
+i64 / i
+i64 / i != i64
+i64 / i * 0.5
+i64 / i * f32
+i64 / i - i32
+i64 / i ^ i64
+i64 / i32
+i64 / i32 * i
+i64 / i64
+i64 / i64 ** f32
+i64 / i64 - f64
+i64 / i64 / i64
+i64 / i64 < f32
+i64 / int(0.5)
+i64 / min(f32)
+i64 / score(1)
+i64 < -1
+i64 < -i32
+i64 < -i64
+i64 < 1 != true
+i64 < 1 * f64
+i64 < 1 + i64
+i64 < 1 / i32
+i64 < 1 ? half : ok
+i64 < 1 ^ f64
+i64 < abs(f32)
+i64 < array[1]
+i64 < f32
+i64 < f32 * i32
+i64 < f32 ? "bar" : ok
+i64 < f32 ^ 0.5
+i64 < f64
+i64 < f64 + f64
+i64 < f64 - f32
+i64 < f64 - i
+i64 < f64 ? i64 : score
+i64 < f64 or ok
+i64 < float(f64)
+i64 < half(0.5)
+i64 < i
+i64 < i != false
+i64 < i32
+i64 < i32 * 1
+i64 < i32 + i64
+i64 < i32 - 0.5
+i64 < i32 - f32
+i64 < i32 ? greet : 1
+i64 < i32 ? nil : array
+i64 < i32 ? true : "bar"
+i64 < i64
+i64 < i64 + 1
+i64 < i64 ? f32 : foo
+i64 < i64 ? half : i
+i64 < int(i64)
+i64 < max(0.5)
+i64 < min(0.5)
+i64 < min(i)
+i64 < score(1)
+i64 < score(1) * i64
+i64 <= -1
+i64 <= -f32
+i64 <= -i
+i64 <= -i32
+i64 <= -i64
+i64 <= 0.5 != true
+i64 <= 0.5 + i
+i64 <= 0.5 - 1
+i64 <= 0.5 == nil
+i64 <= 0.5 ? 0.5 : "foo"
+i64 <= 1 != true
+i64 <= 1 ** f64
+i64 <= 1 == ok
+i64 <= 1 ? array : ok
+i64 <= 1 and ok
+i64 <= array[i32]
+i64 <= f32
+i64 <= f32 && ok
+i64 <= f32 + 1
+i64 <= f32 / f32
+i64 <= f32 ^ i32
+i64 <= f64
+i64 <= f64 + 1
+i64 <= f64 - f32
+i64 <= half(0.5)
+i64 <= i
+i64 <= i != true
+i64 <= i * 1
+i64 <= i + 1
+i64 <= i / i64
+i64 <= i ? i32 : list
+i64 <= i ^ 0.5
+i64 <= i32
+i64 <= i32 && ok
+i64 <= i32 ? f64 : i < 1
+i64 <= i64
+i64 <= i64 - 0.5
+i64 <= i64 ? greet : div
+i64 <= int(i64)
+i64 <= last(array)
+i64 <= min(0.5)
+i64 <= min(f64)
+i64 <= score(1)
+i64 <= score(i)
+i64 == -0.5
+i64 == -1
+i64 == -f64
+i64 == -i
+i64 == 0.5 == ok
+i64 == 0.5 ? 1 : list
+i64 == 0.5 ? div : i64
+i64 == 0.5 ? foo : f32
+i64 == 0.5 ^ 0.5
+i64 == 0.5 ^ i
+i64 == 1 % i64
+i64 == 1 && ok
+i64 == 1 ** f64
+i64 == 1 + f32
+i64 == 1 - f64
+i64 == abs(0.5)
+i64 == abs(i32)
+i64 == count(array, true)
+i64 == count(list, true)
+i64 == f32
+i64 == f64
+i64 == f64 != ok
+i64 == f64 != true
+i64 == f64 - i
+i64 == f64 ? f64 : add
+i64 == findIndex(array, false)
+i64 == i
+i64 == i * f32
+i64 == i == false
+i64 == i == ok
+i64 == i ^ 1
+i64 == i32
+i64 == i32 ** 0.5
+i64 == i32 / f64
+i64 == i64
+i64 == i64 ^ 0.5
+i64 == int(1)
+i64 == int(f32)
+i64 == last(array)
+i64 == max(0.5)
+i64 == nil ? true : ok
+i64 == score(1)
+i64 == score(i)
+i64 > -0.5
+i64 > -1
+i64 > -f32
+i64 > -f64
+i64 > -i
+i64 > -i32
+i64 > -i64
+i64 > 0.5 * 1
+i64 > 0.5 ** 0.5
+i64 > 0.5 == true
+i64 > 0.5 ? f64 : greet
+i64 > 0.5 ? foo : add
+i64 > 1 ** 0.5
+i64 > 1 - 0.5
+i64 > 1 ? false : array
+i64 > 1 ? half : i64
+i64 > abs(1)
+i64 > abs(f64)
+i64 > array[i64]
+i64 > f32
+i64 > f32 - 1
+i64 > f32 ? div : false
+i64 > f64
+i64 > f64 == nil
+i64 > f64 and 1 > i64
+i64 > first(array)
+i64 > float(f32)
+i64 > half(f64)
+i64 > i
+i64 > i % i32
+i64 > i * f64
+i64 > i ** 1
+i64 > i + i
+i64 > i + i32
+i64 > i ^ i32
+i64 > i32
+i64 > i32 && ok
+i64 > i32 ** 0.5
+i64 > i32 ** i
+i64 > i64
+i64 > i64 % i32
+i64 > i64 - i64
+i64 > int(f32)
+i64 > int(i32)
+i64 > int(i64)
+i64 > score(i)
+i64 >= -0.5
+i64 >= -1
+i64 >= -f64
+i64 >= -i
+i64 >= 0.5 * f64
+i64 >= 0.5 ** f32
+i64 >= 0.5 + f32
+i64 >= 0.5 == nil
+i64 >= 0.5 == true
+i64 >= 0.5 ? array : array
+i64 >= 0.5 ? i32 : nil
+i64 >= 0.5 ^ 0.5
+i64 >= 0.5 and f32 != nil
+i64 >= 1 + f64
+i64 >= 1 + i32
+i64 >= 1 ? i : false
+i64 >= 1 ? i : string(array)
+i64 >= 1 ? true : i
+i64 >= f32
+i64 >= f32 * f32
+i64 >= f32 ** f64
+i64 >= f32 ** i32
+i64 >= f32 / f64
+i64 >= f64
+i64 >= f64 + i
+i64 >= f64 / i64
+i64 >= f64 == ok
+i64 >= f64 and ok
+i64 >= find(array, ok)
+i64 >= float(f32)
+i64 >= float(i)
+i64 >= float(i32)
+i64 >= half(0.5)
+i64 >= i
+i64 >= i and ok
+i64 >= i32
+i64 >= i32 % i64
+i64 >= i64
+i64 >= i64 % i
+i64 >= i64 && i64 > f32
+i64 >= i64 / i32
+i64 >= i64 == nil
+i64 >= i64 in {"foo": f64}.half
+i64 >= max(f64)
+i64 >= max(i64)
+i64 >= min(f32)
+i64 >= score(1)
+i64 ^ (0.5 + 1)
+i64 ^ (0.5 / i32)
+i64 ^ (1 * f32)
+i64 ^ (1 / i)
+i64 ^ (1 / i64)
+i64 ^ (f32 + f32)
+i64 ^ (f32 - f32)
+i64 ^ (f64 * f32)
+i64 ^ (i % i32)
+i64 ^ (i - 0.5)
+i64 ^ (i32 - f32)
+i64 ^ (i64 + i32)
+i64 ^ (i64 / f64)
+i64 ^ -0.5
+i64 ^ -i32
+i64 ^ 0.5 ** f32
+i64 ^ 0.5 <= i
+i64 ^ 0.5 >= f32
+i64 ^ 0.5 >= f64
+i64 ^ 0.5 >= i64
+i64 ^ 0.5 ^ 0.5
+i64 ^ 1 != i
+i64 ^ 1 != i32
+i64 ^ 1 ** i32
+i64 ^ 1 + f32
+i64 ^ 1 < f32
+i64 ^ 1 <= i
+i64 ^ abs(1)
+i64 ^ abs(i)
+i64 ^ array[i64]
+i64 ^ f32
+i64 ^ f32 - f32
+i64 ^ f64
+i64 ^ f64 * i32
+i64 ^ f64 ** i
+i64 ^ f64 + f32
+i64 ^ f64 < f32
+i64 ^ f64 == i64
+i64 ^ f64 > 1 + i64
+i64 ^ f64 ^ f32
+i64 ^ get(array, i)
+i64 ^ half(f64)
+i64 ^ i
+i64 ^ i ** f32
+i64 ^ i ** i64
+i64 ^ i32
+i64 ^ i32 != f32
+i64 ^ i32 != i32
+i64 ^ i32 ** i
+i64 ^ i32 + f32
+i64 ^ i32 + f64
+i64 ^ i32 / f32
+i64 ^ i64
+i64 ^ i64 * f64
+i64 ^ i64 * i64
+i64 ^ i64 ** f64
+i64 ^ i64 ^ f32
+i64 ^ i64 ^ f64
+i64 ^ i64 ^ i
+i64 ^ int(i64)
+i64 ^ last(array)
+i64 ^ len(array)
+i64 ^ max(0.5)
+i64 ^ max(1)
+i64 ^ max(f32)
+i64 ^ score(1)
+i64 ^ score(1, 1)
+i64 ^ score(i)
+i64 in array
+i64 in array == nil
+i64 in array ? false : greet
+i64 in map(array, #)
+i64 not in array
+indexOf("bar", "bar") + i64
+indexOf(foo.Bar, string(i32))
+int(-(i * 0.5))
 int(-0.5)
 int(-1)
-int(-a)
-int(-b)
-int(-f)
-int(0 % 1)
-int(0 % a)
-int(0 * 0)
-int(0 * 0.5)
-int(0 * f)
-int(0 ** 0.5)
-int(0 + 0)
-int(0 + a)
-int(0 + b)
-int(0 + f)
-int(0 - 0)
-int(0 - a)
-int(0 - b)
-int(0 - f)
-int(0 / a)
-int(0 / f)
-int(0 ^ a)
-int(0) != -f
-int(0) != a ? nil : a
-int(0) != obj.obj
-int(0) ** obj.b
-int(0) + get(arr, 0)
-int(0) .. b
-int(0) / f
-int(0) < min(1)
-int(0) <= obj.b
-int(0) > obj.head(b)
-int(0) ^ f
-int(0.5 * a)
-int(0.5 * f)
-int(0.5 ** 2)
-int(0.5 ** a)
-int(0.5 + f)
-int(0.5 - f)
+int(-abs(f64))
+int(-f32)
+int(-f64)
+int(-i)
+int(-i32)
+int(-i32) != i
+int(-i64)
+int(0.5 * 0.5)
+int(0.5 * 1)
+int(0.5 * f32)
+int(0.5 * i)
+int(0.5 * i32)
+int(0.5 * i64)
+int(0.5 ** 0.5)
+int(0.5 ** 1)
+int(0.5 ** f32)
+int(0.5 ** f64)
+int(0.5 ** i64)
+int(0.5 + f32)
+int(0.5 + f64)
+int(0.5 + i)
+int(0.5 + i32)
+int(0.5 - 0.5)
+int(0.5 - f32)
+int(0.5 - i32)
 int(0.5 / 0.5)
-int(0.5 / a)
-int(0.5 / b)
-int(0.5 / f)
-int(0.5 ^ 0)
+int(0.5 / 1)
+int(0.5 / f32)
+int(0.5 / f64)
+int(0.5 / i32)
+int(0.5 / i64)
 int(0.5 ^ 0.5)
-int(0.5) != f ? 0.5 : arr
-int(0.5) < b
-int(0.5) > f
-int(1 % 1 % b)
-int(1 * f)
-int(1 ** 0)
-int(1 ** a)
-int(1 ** b)
-int(1 / b)
-int(1) != a
-int(1) * a
-int(1) ** a
-int(1) / 0 ^ f
-int(1) <= b
-int(2 % b)
-int(2 ** 1)
-int(2 ** f)
-int(2 + 0)
-int(2 - b)
-int(2 / a)
-int(2) != a
-int(2) ** a
-int(2) + int(b)
-int(2) .. b
-int(2) <= a * f
-int(2) > b
-int(a % 2)
-int(a % b)
-int(a * 0)
-int(a * 0.5)
-int(a * f)
-int(a ** 0)
-int(a ** b)
-int(a ** f)
-int(a + a)
-int(a + b)
-int(a - 0.5)
-int(a - a)
-int(a / 0)
-int(a / a)
-int(a / b)
-int(a / f)
-int(a ^ 0)
-int(a ^ 0.5)
-int(a ^ b)
-int(a)
-int(a) != b
-int(a) != f != true
-int(a) * a
-int(a) * f
-int(a) ** a
-int(a) + -f
-int(a) + a
-int(a) - b
-int(a) - f
-int(a) / a
-int(a) / obj.a
-int(a) < obj.head(obj).a
-int(a) <= b
-int(a) == b
-int(a) >= a
-int(a) >= obj.fn(a)
-int(a) ^ b
-int(abs(a))
-int(abs(b))
-int(abs(f))
-int(add(0, 0))
-int(add(0, 2))
-int(add(a, 0))
-int(add(a, 2))
-int(add(a, a))
-int(add(a, b))
-int(add(add(0, b), b))
-int(add(add(b, a), b))
-int(add(b, 0))
-int(add(b, b))
-int(arr[0])
-int(arr[a])
-int(arr[b])
-int(b % a)
-int(b * a)
-int(b * b)
-int(b ** a)
-int(b ** b)
-int(b ** f)
-int(b + 0.5)
-int(b + 2)
-int(b + a)
-int(b + b)
-int(b - 0)
-int(b - 2)
-int(b - b)
-int(b - f)
-int(b / 1)
-int(b / b)
-int(b ^ b)
-int(b ^ f)
-int(b)
-int(b) != 0 * 0
-int(b) != f
-int(b) % a
-int(b) * 0 % 2
-int(b) * a
-int(b) - a
-int(b) - b
-int(b) .. a
-int(b) / a
-int(b) ^ f
-int(count(arr, true))
-int(div(0, 2))
-int(div(0, a))
-int(div(1, a))
-int(div(1, b))
-int(div(2, a))
-int(div(2, b))
-int(div(a, 1))
-int(div(a, b))
-int(div(b, a))
-int(div(b, b))
-int(f * 0.5)
-int(f * a)
-int(f * b)
-int(f ** b)
-int(f + 0)
-int(f + 0.5)
-int(f + 2)
-int(f + a)
-int(f + b)
-int(f + f)
-int(f - 0)
-int(f - 1)
-int(f - a)
-int(f - b)
-int(f / 0)
-int(f / f)
-int(f ^ 0)
-int(f ^ a)
-int(f ^ b)
-int(f ^ obj?.a)
-int(f)
-int(f) != a
-int(f) * obj.a
-int(f) * obj.fn(b)
-int(f) ** b
-int(f) .. a
-int(f) < obj?.a
-int(f) == obj?.b
-int(f) >= 2 / a
-int(f) ^ b
-int(false ? "a" : a)
-int(false ? 0 : a)
-int(false ? add : 0)
-int(first(arr))
-int(float(0))
-int(float(2))
-int(float(a))
-int(float(f))
-int(get(arr, 0))
-int(get(arr, a))
-int(get(arr, b))
+int(0.5 ^ 1)
+int(0.5 ^ f32)
+int(0.5 ^ i)
+int(0.5) ** i64
+int(0.5) ** int(i64)
+int(0.5) + f32
+int(0.5) + f64
+int(0.5) + i64
+int(0.5) - i
+int(0.5) - i64
+int(0.5) .. i32
+int(0.5) < int(f64)
+int(0.5) == f32
+int(0.5) == i
+int(0.5) > -1
+int(0.5) >= i - i64
+int(0.5) ^ i32
+int(0.5) ^ i64
+int(0.5) in array
+int(0.5) not in array
+int(1 % 1)
+int(1 % i)
+int(1 % i32)
+int(1 * 0.5)
+int(1 * f32)
+int(1 * f64)
+int(1 * i)
+int(1 * i64)
+int(1 ** 0.5)
+int(1 ** 1)
+int(1 ** f32)
+int(1 ** i32)
+int(1 ** i64)
+int(1 + 0.5)
+int(1 + 1)
+int(1 + f64)
+int(1 + i)
+int(1 - 0.5)
+int(1 - 1)
+int(1 - i64)
+int(1 / 1)
+int(1 / f64)
+int(1 / i32)
+int(1 / i64)
+int(1 ^ 0.5)
+int(1 ^ 1)
+int(1 ^ i32)
+int(1 ^ i64)
+int(1) * f64
+int(1) * i
+int(1) ** f32
+int(1) ** i64
+int(1) + 0.5 + 1
+int(1) + i64
+int(1) - f64
+int(1) - i64
+int(1) .. i
+int(1) / f32
+int(1) / i
+int(1) < f64
+int(1) <= f32
+int(1) <= f64
+int(1) == i
+int(1) == i64
+int(1) > f64
+int(1) > float(1)
+int(1) > i32
+int(1) >= f32
+int(1) >= f64
+int(1) >= half(0.5)
+int(1) ^ f32
+int(1) ^ f64
+int(1) ^ i
+int(1) ^ i32
+int(1) in array
+int(abs(0.5))
+int(abs(f32))
+int(abs(f64))
+int(abs(i))
+int(abs(i32))
+int(abs(i64))
+int(array[1])
+int(array[i32])
+int(array[i64])
+int(count(list, ok))
+int(div(1, i))
+int(f32 * f32)
+int(f32 * i64)
+int(f32 ** 0.5)
+int(f32 ** f64)
+int(f32 ** i32)
+int(f32 + f32)
+int(f32 + i64)
+int(f32 - 0.5)
+int(f32 - f32)
+int(f32 - i)
+int(f32 / f64)
+int(f32 ^ 1)
+int(f32 ^ f32)
+int(f32 ^ i)
+int(f32 ^ i64)
+int(f32)
+int(f32) != f32
+int(f32) % i
+int(f32) * f64
+int(f32) .. i32
+int(f32) / f32
+int(f32) / i
+int(f32) == 0.5 != nil
+int(f32) == i
+int(f32) > i
+int(f32) >= i32
+int(f32) ^ i64
+int(f32) in array
+int(f64 * 0.5)
+int(f64 * 1)
+int(f64 * f32)
+int(f64 * f64)
+int(f64 * i32)
+int(f64 * i64)
+int(f64 ** 0.5)
+int(f64 ** 1)
+int(f64 ** f32)
+int(f64 ** i)
+int(f64 ** i32)
+int(f64 ** i64)
+int(f64 + f32)
+int(f64 + i64)
+int(f64 - 0.5)
+int(f64 - 1)
+int(f64 - f64)
+int(f64 / 1)
+int(f64 / i)
+int(f64 ^ 0.5)
+int(f64 ^ 1)
+int(f64 ^ f32)
+int(f64)
+int(f64) != i32
+int(f64) * i32
+int(f64) ** i64
+int(f64) - i
+int(f64) < i32
+int(f64) <= i32
+int(f64) == float(i32)
+int(f64) ^ i32
+int(f64) ^ i64
+int(f64) not in array
+int(false ? add : 0.5)
+int(false ? f32 : 0.5)
+int(false ? f64 : i32)
+int(find(array, true))
+int(findIndex(array, ok))
+int(findIndex(array, true))
+int(findIndex(list, # == foo))
+int(findIndex(list, ok))
+int(findLastIndex(array, ok))
+int(findLastIndex(array, true))
+int(findLastIndex(list, true))
+int(first(array))
+int(float(0.5))
+int(float(1))
+int(float(f32))
+int(float(f64) ** i64)
+int(float(f64))
+int(float(i))
+int(float(i32))
+int(float(i64))
+int(get(array, 1))
+int(get(array, i64))
+int(half(0.5))
+int(half(1 / f32))
+int(half(f64))
+int(i % 1)
+int(i % i64)
+int(i * 0.5)
+int(i * 1)
+int(i * f32)
+int(i * f64)
+int(i ** 0.5)
+int(i ** f32)
+int(i ** f64)
+int(i ** i64)
+int(i + 0.5)
+int(i + f32)
+int(i + i32)
+int(i + i64)
+int(i - f64)
+int(i - i64)
+int(i / 1) <= i32
+int(i / f64)
+int(i / i)
+int(i ^ f32)
+int(i ^ f64)
+int(i ^ i)
+int(i ^ i32)
+int(i)
+int(i) != i
+int(i) + f32
+int(i) + i32
+int(i) - i32
+int(i) .. i64
+int(i) / i
+int(i) < f32
+int(i) < f64
+int(i) <= f64
+int(i) == f32
+int(i) > i32
+int(i) > i64
+int(i) > int(i)
+int(i) >= i
+int(i) ^ i64
+int(i32 % i64)
+int(i32 * 0.5)
+int(i32 * 1)
+int(i32 * f64)
+int(i32 ** i)
+int(i32 + 0.5)
+int(i32 + 1)
+int(i32 + f32)
+int(i32 - 0.5)
+int(i32 - 1)
+int(i32 - f64)
+int(i32 - i)
+int(i32 - i64)
+int(i32 / 0.5)
+int(i32 / f64)
+int(i32 ^ 0.5)
+int(i32 ^ f32)
+int(i32 ^ f64)
+int(i32 ^ i)
+int(i32 ^ i64)
+int(i32)
+int(i32) != f32
+int(i32) % i64
+int(i32) ** -0.5
+int(i32) + i
+int(i32) - f32
+int(i32) .. i32
+int(i32) / i
+int(i32) / i32
+int(i32) < i64
+int(i32) <= f32
+int(i32) == -i32
+int(i32) == f64
+int(i32) > f64
+int(i64 % i32)
+int(i64 * f32)
+int(i64 * f64)
+int(i64 * i)
+int(i64 ** i)
+int(i64 + 1)
+int(i64 + i)
+int(i64 + i64)
+int(i64 - f32)
+int(i64 - f64)
+int(i64 - i32)
+int(i64 / f32)
+int(i64 / f64)
+int(i64 / i)
+int(i64 / i64)
+int(i64 ^ 0.5)
+int(i64 ^ f64)
+int(i64 ^ i32)
+int(i64 ^ i64)
+int(i64)
+int(i64) != f64
+int(i64) != i
+int(i64) != nil ? 1 : half
+int(i64) % i
+int(i64) % i32
+int(i64) ** f64
+int(i64) - i32
+int(i64) .. i32
+int(i64) <= i
+int(i64) <= i64
+int(i64) == min(i)
+int(i64) > f64
+int(i64) > i32
+int(i64) >= f64
+int(i64) ^ f32
+int(i64) ^ i32
+int(i64) in array
+int(i64) not in array
+int(int(0.5))
 int(int(1))
-int(int(a))
-int(int(f))
-int(last(arr))
-int(len(arr))
-int(len(obj))
-int(len(s))
+int(int(f32))
+int(int(f64))
+int(int(i32))
+int(int(i64))
+int(last(array))
+int(len("bar"))
+int(len(array))
+int(len(list))
 int(max(0.5))
-int(max(0.5, 0))
-int(max(1, b, f))
-int(max(b))
-int(max(b, f))
-int(max(f))
-int(min(0))
+int(max(1))
+int(max(f64))
+int(max(i))
+int(max(i64))
 int(min(0.5))
-int(min(2))
-int(min(a))
-int(min(b))
-int(min(f))
-int(obj.a + f)
-int(obj.a)
-int(obj.b / f)
-int(obj.b)
-int(obj.fn(0))
-int(obj.fn(1))
-int(obj.fn(a))
-int(obj.fn(b))
-int(obj.head(0))
-int(obj.head(0, obj))
-int(obj.head(a))
-int(obj.head(a, "a", div))
-int(obj.head(a, f))
-int(obj.head(a, nil, nil))
-int(obj.head(a, obj))
-int(obj.head(b))
-int(obj.head(b, s, nil, 0))
-int(obj.head(f))
-int(obj.head(f, s, "a"))
-int(obj.obj?.b)
-int(obj?.a)
-int(obj?.b)
-int(obj?.fn(0))
-int(obj?.fn(b))
-int(obj?.fn(obj.b))
-int(obj?.head(0.5, add))
-int(obj?.head(2, 1, obj))
-int(obj?.head(a))
-int(obj?.head(a, 0.5))
-int(obj?.head(a, a == b))
-int(obj?.head(b))
-int(obj?.head(b, add, 0))
-int(obj?.head(f))
-int(obj?.head(f, a, 1))
-int(obj?.obj.a)
-int(obj?.obj?.b)
-int(ok ? 0 : ok)
-int(ok ? 0.5 : add)
-int(ok ? 1 : 0.5)
-int(ok ? a : f)
-int(ok ? b : ok)
-int(ok ? f : s)
-int(string(a))
-int(string(b))
-int(toJSON(0))
-int(toJSON(a))
-int(toJSON(b))
-int(true ? 0 : nil)
-join(map(arr, s))
-keys(obj)
-keys(obj) == obj?.head(0, obj)
-keys(obj)[a]
-keys(ok ? obj : nil)
-keys({"b": 1, "c": obj})
-last(0 .. b)
-last(2 .. 1)
-last(["b"])
-last([nil, obj, b])
-last(a .. 0)
-last(a .. 2)
-last(a .. a)
-last(abs(obj?.head(a, add, div)))
-last(arr)
-last(arr) * 0 * 0
-last(arr) * abs(b)
-last(arr) * f * a
-last(arr) * obj.head(obj, arr).a
-last(arr) < b / 0.5
-last(arr) >= b
-last(arr[b:a])
-last(b + obj?.b)
-last(b - obj.b)
-last(b .. 2)
-last(b .. a)
-last(div(0, a) > a ? "c" : false)
-last(false ? f : a)
-last(false ? f : s)
-last(false ? obj : s)
-last(false ? s : 1)
-last(false ? s : obj)
-last(filter(arr, false))
-last(filter(arr, true))
-last(first(obj?.obj))
-last(get(obj.a, obj.b))
-last(get(obj.b, ok != 0.5))
-last(get(obj.obj, ok))
-last(last(obj?.b))
-last(map(arr, "a"))
-last(map(arr, 0))
-last(map(arr, 0.5))
-last(map(arr, a))
-last(map(arr, add))
-last(map(arr, arr))
-last(map(arr, b))
-last(map(arr, div))
-last(map(arr, false))
-last(map(arr, ok))
-last(map(arr, s))
-last(map(obj?.head("b"), b))
-last(obj.a)
-last(obj.b)
-last(obj.b)?.a
-last(obj.b)?.obj
-last(obj.fn(0))
-last(obj.fn(1))
-last(obj.fn(a))
-last(obj.fn(b))
-last(obj.head("a"))
-last(obj.head("c", 0, ok))
-last(obj.head(0))
-last(obj.head(0, nil))
-last(obj.head(0, ok, ok))
-last(obj.head(0.5))
-last(obj.head(2))
-last(obj.head(2, add, "a", "a", "a"))
-last(obj.head(a))
-last(obj.head(a, f))
-last(obj.head(a, true, f))
-last(obj.head(add, 2))
-last(obj.head(arr == div))
-last(obj.head(arr, s))
-last(obj.head(div))
-last(obj.head(div, 0.5, obj, s, 2))
-last(obj.head(f, a, s, a))
-last(obj.head(obj))
-last(obj.head(obj, b, add).a)
-last(obj.head(ok))
-last(obj.head(ok, false))
-last(obj.head(s))
-last(obj.head(s, a, ok))
-last(obj.head(true))
-last(obj.head(true, div))
-last(obj.obj)
-last(obj.obj)?.b
-last(obj.obj.a)
-last(obj.obj?.a)
-last(obj.obj?.obj.a)
-last(obj?.a)
-last(obj?.a)?.b
-last(obj?.b)
-last(obj?.b)?.obj
-last(obj?.fn(0))
-last(obj?.fn(a))
-last(obj?.fn(b))
-last(obj?.fn(b))?.b
-last(obj?.head("a", 0, 1))
-last(obj?.head(0, 0.5, a))
-last(obj?.head(1, s, "a", obj))
-last(obj?.head(2))
-last(obj?.head(a, b))
-last(obj?.head(a, obj))
-last(obj?.head(add))
-last(obj?.head(add, false, 0, div, f))
-last(obj?.head(arr))
-last(obj?.head(arr, 1))
-last(obj?.head(b))
-last(obj?.head(div, add, nil, ok))
-last(obj?.head(div, nil, ok))
-last(obj?.head(f))
-last(obj?.head(f, div, s))
-last(obj?.head(nil)?.obj)
-last(obj?.head(nil, div, ok))
-last(obj?.head(obj))
-last(obj?.head(obj))?.b
-last(obj?.head(obj, a))
-last(obj?.head(obj, false))
-last(obj?.head(ok, arr, div))
-last(obj?.head(ok, div))
-last(obj?.head(s))
-last(obj?.head(true))
-last(obj?.obj)
-last(obj?.obj)?.a
-last(obj?.obj)?.b
-last(obj?.obj.a)
-last(obj?.obj.b)
-last(obj?.obj?.obj)
-last(obj[nil])
-last(obj[obj[nil]])
-last(ok ? "a" : div)
-last(ok ? "c" : a)
-last(ok ? 0 : obj)
-last(ok ? a : s)
-last(ok ? add : arr)
-last(ok ? arr : false)
-last(ok ? div : 0.5)
-last(ok ? div : b)
-last(ok ? div : f)
-last(ok ? div : true)
-last(ok ? f : "c")
-last(ok ? f : b)
-last(ok ? f : ok)
-last(ok ? false : s)
-last(ok ? obj : div)
-last(ok ? obj : s)
-last(ok ? ok : 2)
-last(ok ? ok : f)?.obj
-last(ok ? true : "c")
-last(ok ? true : b)
-last(split(s, "c"))
-last(splitAfter("a", "a"))
-last(true ? a : ok)
-last(true ? add : f)
-last(true ? div : false)
-last(true ? div : ok)
-last(true ? obj : 0.5)
-last(true ? ok : b)
-last(true ? ok : div)
-lastIndexOf("a", "a") + f
-lastIndexOf("b", s) * a
-lastIndexOf(s, ok ? s : 0)
-lastIndexOf(s, s)
-len("a" + s)
-len("a") .. b
-len("a") == a
-len("a") >= 0 * b
-len("b" + "c")
-len("b") ** b
-len("b") >= f
-len("c" + "a")
-len(0 .. 0)
-len(0 .. a)
-len(2 .. 0)
-len([s])
-len(a .. 1)
-len(a .. a)
-len(a .. b)
-len(add != add or ok ? "c" : div)
-len(arr)
-len(arr) != f
-len(arr) != obj?.obj
-len(arr) - f
-len(arr) - int(a)
-len(arr) / a
-len(arr) > f
-len(arr) > last(arr)
-len(arr) ^ -f
-len(arr[a:2])
-len(filter(arr, false))
-len(filter(arr, ok))
-len(filter(arr, true))
-len(keys(obj))
-len(map(arr, "b"))
-len(map(arr, 0))
-len(map(arr, 1))
-len(map(arr, a))
-len(map(arr, arr))
-len(map(arr, b))
-len(map(arr, f))
-len(map(arr, ok))
-len(map(arr, s))
-len(obj)
-len(obj) % b
-len(obj) ** f
-len(obj) ** obj.b
-len(obj) + b
-len(obj) .. -b
-len(obj) / obj?.a
-len(obj) <= f
-len(obj) <= min(0)
-len(obj) == a
-len(obj) > get(arr, a)
-len(obj) > obj.a
-len(obj) >= a
-len(obj) >= count(arr, true)
-len(obj.head("a", 2, false))
-len(obj.head("b"))
-len(obj.head("c", ok))
-len(obj.head("c", true, obj, false, obj))
-len(obj.head(arr))
-len(obj.head(arr, div, b))
-len(obj.head(obj))
-len(obj.head(obj, 2))
-len(obj.head(s))
-len(obj.head(s, 0, div, s, add))
-len(obj.head(s, nil))
-len(obj.obj)
-len(obj.obj) > b
-len(obj?.head("c", b))
-len(obj?.head(arr, nil, f))
-len(obj?.head(arr, s, "c", div, "c"))
-len(obj?.head(obj))
-len(obj?.head(s))
-len(obj?.head(s, add))
-len(obj?.obj)
-len(obj?.obj.obj)
-len(obj?.obj?.obj)
-len(ok ? arr : a)
-len(ok ? arr : obj)
-len(s + "c")
-len(s + s)
-len(s)
-len(s) != a
-len(s) != obj.b
-len(s) ** obj?.a
-len(s) + a
-len(s) + f
-len(s) / f
-len(s) >= a
-len(s) >= b
-len(s) ^ f
-len(string(0))
+int(min(1))
+int(min(f32))
+int(min(f32, i32))
+int(min(f64))
+int(min(f64, 1))
+int(min(i))
+int(min(i32))
+int(min(i64))
+int(min(i64, 1))
+int(ok ? 0.5 : i64)
+int(ok ? 1 : div)
+int(ok ? i32 : add)
+int(score(1))
+int(score(i))
+int(string(1))
+int(string(i))
+int(string(i32))
+int(string(i64))
+int(toJSON(1))
+int(toJSON(i))
+int(toJSON(i32))
+int(toJSON(i64))
+int(true ? f64 : 0.5)
+int(true ? f64 : 1)
+join(["bar"])
+join(map(array, "bar"))
+join(map(array, "foo"))
+join(map(list, "bar"))
+keys({"bar": i64})
+keys({"foo": 0.5})
+keys({"foo": f32})
+keys({"foo": i})
+last(1 .. i32)
+last([0.5])
+last([array])
+last([f64])
+last([half, i32])
+last(array)
+last(array) != f32
+last(array) != i32
+last(array) % i32
+last(array) * i32
+last(array) + f32
+last(array) + i
+last(array) - f32
+last(array) - i64
+last(array) - score(i)
+last(array) .. max(i)
+last(array) / f64
+last(array) > f64
+last(array) > max(1)
+last(array) >= f32
+last(array) >= f64
+last(false ? 0.5 : greet)
+last(false ? div : 1)
+last(false ? f32 : 1)
+last(false ? list : 1)?.add
+last(false ? list : add)
+last(filter(array, false))
+last(filter(array, ok))
+last(filter(list, true))
+last(i .. i32)
+last(i32 .. i32)
+last(i32 .. i64)
+last(i64 .. i)
+last(list)
+last(list) == foo
+last(list) not in list
+last(list).Bar
+last(list).Qux
+last(list).String
+last(list).String()
+last(list)?.Bar
+last(list)?.Qux
+last(list)?.String
+last(list)?.String()
+last(map(array, "bar"))
+last(map(array, #))
+last(map(array, array))
+last(map(array, i64))
+last(map(list, "bar"))
+last(map(list, "foo"))
+last(map(list, #))
+last(map(list, 0.5))
+last(map(list, add))
+last(map(list, f32))
+last(map(list, foo))
+last(map(list, i))
+last(map(list, i32))
+last(map(list, true))
+last(ok ? 0.5 : score)
+last(ok ? array : false)
+last(ok ? foo : add != half)
+last(ok ? nil : list)
+last(ok ? ok : i32)
+last(true ? 1 : list)?.String
+last(true ? foo : half)
+last(true ? half : 1)
+last(true ? i32 : ok)
+last(true ? i64 : 1)
+last(true ? ok : f64)
+lastIndexOf("bar", "foo") < f32 ^ f64
+len("bar" + "foo")
+len("bar") != f32
+len("bar") % score(i)
+len("bar") * i32
+len("bar") ** f64
+len("bar") ** i32
+len("bar") <= i64
+len("bar") > i32
+len("bar") >= 0.5 ^ 0.5
+len("bar") >= f32
+len("bar") >= f64
+len("foo" + foo.Bar)
+len("foo") * i32
+len("foo") * i64
+len("foo") - i
+len("foo") .. i
+len("foo") < f32
+len("foo") <= f32
+len("foo") <= f64
+len("foo") == i
+len("foo") == i32
+len("foo") == i64
+len("foo") > f64
+len("foo") not in array
+len([f64])
+len([false, add, half])
+len([false, foo, false])
+len([false])
+len(array)
+len(array) != i
+len(array) != i32
+len(array) * i
+len(array) ** i
+len(array) .. 1 - 1
+len(array) / f32
+len(array) < f32
+len(array) <= i
+len(array) >= f32
+len(array) >= f64
+len(array) >= i64
+len(false ? 1 : list)
+len(false ? nil : "foo")
+len(foo.Bar)
+len(foo.String())
+len(foo?.Bar)
+len(foo?.String())
+len(greet("bar"))
+len(greet("foo"))
+len(i .. 1)
+len(i32 .. 1)
+len(i32 .. i)
+len(i32 .. i32)
+len(i32 .. i64)
+len(i64 .. 1)
+len(i64 .. i)
+len(list)
+len(list) != i64
+len(list) * f32
+len(list) ** i
+len(list) / f64
+len(list) <= f64
+len(list) == f32
+len(list) == i
+len(list) > i
+len(list) > i64 - i
+len(list) >= i
+len(list) not in map(array, #)
+len(lower("foo"))
+len(lower(toBase64("foo")))
+len(lower(type(list)))
+len(map(array, "bar"))
+len(map(array, #))
+len(map(array, 0.5))
+len(map(array, array))
+len(map(array, f64))
+len(map(array, foo))
+len(map(array, half))
+len(map(array, i))
+len(map(array, i64))
+len(map(array, list))
+len(map(array, ok))
+len(map(array, score))
+len(map(list, "bar"))
+len(map(list, "foo"))
+len(map(list, #))
+len(map(list, 0.5))
+len(map(list, 1))
+len(map(list, f64))
+len(map(list, false))
+len(map(list, greet))
+len(map(list, half))
+len(map(list, i))
+len(map(list, score))
+len(map(list, true))
+len(sort(array))
+len(string("bar"))
+len(string("foo"))
 len(string(0.5))
 len(string(1))
-len(string(div == div))
-len(string(f))
-len(string(false))
+len(string(add))
+len(string(array))
+len(string(div))
+len(string(f32))
+len(string(f64))
+len(string(foo))
+len(string(greet))
+len(string(half))
+len(string(i32))
+len(string(i64))
+len(string(list))
 len(string(nil))
-len(string(obj))
 len(string(ok))
-len(string(s))
-len(toBase64("c"))
-len(toJSON("a"))
-len(toJSON("c"))
-len(toJSON(a))
-len(toJSON(b))
-len(toJSON(f))
-len(toJSON(nil == ok))
-len(toJSON(s))
-len(trim("b"))
-len(trim(s))
-len(trimPrefix("a"))
-len(trimPrefix(s))
-len(trimSuffix("a"))
-len(trimSuffix(s))
-len(true ? arr : add)
-len(true ? arr : obj)
-len(upper("b"))
-len(values(obj))
-len({"a": arr, "b": a})
-lower("b") != obj.head(f, ok)
-lower("b") contains s
-lower("b") matches "c" ? f : b
-lower("c" + s)
-lower(false ? 0 : "c")
-lower(obj.head(s))
-lower(obj.head(s, 2, s, "c"))
-lower(obj?.head(s))
-lower(s + "b")
-lower(s + "c")
-lower(s)
-lower(s) contains s
-lower(s) in obj?.obj
-lower(s[b:0])
-lower(string("a"))
-lower(string(0))
+len(string(score))
+len(string(true))
+len(toJSON("bar"))
+len(toJSON("foo"))
+len(toJSON(0.5))
+len(toJSON(1 <= i32))
+len(toJSON(1))
+len(toJSON(array))
+len(toJSON(f32))
+len(toJSON(f64))
+len(toJSON(false))
+len(toJSON(foo))
+len(toJSON(foo.Bar))
+len(toJSON(i))
+len(toJSON(i32))
+len(toJSON(i64))
+len(toJSON(list))
+len(toJSON(nil))
+len(toJSON(ok))
+len(toJSON(true))
+len(trim("bar"))
+len(trim("foo"))
+len(trimPrefix("bar"))
+len(trimPrefix("foo"))
+len(trimSuffix("bar"))
+len(trimSuffix("foo"))
+len(type(0.5))
+len(type(1))
+len(type(array))
+len(type(div))
+len(type(f32))
+len(type(f64))
+len(type(false))
+len(type(foo))
+len(type(greet))
+len(type(half))
+len(type(half)) > f32
+len(type(i))
+len(type(i32))
+len(type(i64))
+len(type(list))
+len(type(nil))
+len(type(ok))
+len(type(score))
+len(upper("bar"))
+len(upper("foo"))
+len({"bar": 1})
+len({"bar": add})
+len({"bar": f64, "bar": i})
+len({"bar": greet, "bar": greet})
+len({"foo": "foo"})
+list
+list != array
+list != array == ok
+list != array ? 0.5 : "bar"
+list != filter(list, true)
+list != list
+list != map(array, #)
+list != map(array, 1)
+list != map(array, div)
+list != map(list, #)
+list != map(list, div)
+list != map(list, list)
+list == [add]
+list == array
+list == array ? div : i
+list == list
+list == list == nil
+list == list ? f64 : array
+list == list or add != nil
+list == map(list, f32)
+list == map(list, i64)
+list == nil == nil
+list == nil == ok
+list == nil or i == 0.5
+list == sort(array)
+list == {"bar": half, "foo": "foo"}?.i32
+list[-1]
+list[-i32]
+list[-i64]
+list[-i64].String
+list[-i]
+list[-i].String
+list[1 % i32]
+list[1 * i64]
+list[1:i] == list
+list[1].Bar
+list[1].Qux
+list[1].String
+list[1].String()
+list[1]?.Bar
+list[1]?.Qux
+list[1]?.String
+list[1]?.String()
+list[false ? add : 1]
+list[false ? nil : i]
+list[false ? true : f64]
+list[findIndex(list, ok)]
+list[i * i32]
+list[i32:i32]
+list[i32:i64]
+list[i32:i]
+list[i32]
+list[i32].Bar
+list[i32].Qux
+list[i32].String
+list[i32].String()
+list[i32]?.Bar
+list[i32]?.Qux
+list[i32]?.String
+list[i64 % 1]
+list[i64:i32]
+list[i64:i64]
+list[i64:i]
+list[i64]
+list[i64].Bar
+list[i64].Qux
+list[i64].String
+list[i64].String()
+list[i64]?.Bar
+list[i64]?.Qux
+list[i64]?.String
+list[i:false ? false : i64]
+list[i:i]
+list[i]
+list[i].Bar
+list[i].Qux
+list[i].String
+list[i].String()
+list[i]?.Bar
+list[i]?.Qux
+list[i]?.String()
+list[int(0.5)]
+list[int(f64)]
+list[int(i)]
+list[max(i)]
+list[min(i)]
+list[ok ? f32 : add]
+list[score(1)]
+list[score(i)]
+list[true ? f64 : true]
+lower("bar" + "bar")
+lower(foo.Bar)
+lower(foo.String())
+lower(foo?.Bar)
+lower(foo?.String())
+lower(greet("bar"))
+lower(greet("foo"))
+lower(lower("bar"))
+lower(lower(trimSuffix("bar")))
+lower(string("bar"))
+lower(string("foo"))
 lower(string(0.5))
-lower(string(2))
-lower(string(a))
-lower(string(b))
-lower(string(f))
+lower(string(add))
+lower(string(array))
+lower(string(div))
+lower(string(f32))
+lower(string(f64))
 lower(string(false))
+lower(string(foo))
+lower(string(greet))
+lower(string(half))
+lower(string(i))
+lower(string(i32))
+lower(string(i64))
+lower(string(list))
 lower(string(nil))
 lower(string(ok))
-lower(string(s))
+lower(string(score))
 lower(string(true))
-lower(toBase64("b"))
-lower(toBase64("c"))
-lower(toBase64(s))
-lower(toJSON("b"))
-lower(toJSON("c"))
-lower(toJSON(a))
-lower(toJSON(f))
+lower(toBase64("bar" + "bar"))
+lower(toBase64("bar"))
+lower(toBase64("foo"))
+lower(toJSON("bar"))
+lower(toJSON("foo"))
+lower(toJSON(0.5))
+lower(toJSON(1))
+lower(toJSON(array))
+lower(toJSON(f32))
+lower(toJSON(f64))
+lower(toJSON(false))
+lower(toJSON(foo))
+lower(toJSON(i))
+lower(toJSON(i32))
+lower(toJSON(i64))
+lower(toJSON(list))
+lower(toJSON(nil))
 lower(toJSON(ok))
-lower(toJSON(s))
-lower(trim("a"))
-lower(trim(s))
-lower(trimPrefix("a"))
-lower(trimPrefix("c"))
-lower(trimPrefix(s))
-lower(trimSuffix(s))
-lower(upper(s))
-map(0 .. 0, a)
-map(0 .. 0, b)
-map(0 .. 1, #)
-map(0 .. a, !ok)
-map(0 .. a, arr)
-map(0 .. a, ok)
-map(0 .. a, s)
-map(0 .. b, #)
-map(1 .. 0, count(arr, ok))
-map(1 .. 1, b)
-map(1 .. a, #)
-map(1 .. b, #)
-map(1 .. b, obj.head(div))
-map(2 .. 1, b)
-map(2 .. 2, map(arr, a))
-map(2 .. 2, true ? obj : a)
-map(2 .. b, arr)
-map([a], add)
-map([nil], div)
-map([obj, s], add)
-map([ok], #)
-map([s], arr)
-map([true, obj, s], not ok)
-map(a .. 0, #)
-map(a .. 0, arr)
-map(a .. 0, b)
-map(a .. 1, f)
-map(a .. a, #)
-map(a .. a, div(0, a))
-map(a .. a, s)
-map(a .. b, b)
-map(a .. b, f)
-map(a .. obj?.obj?.a, f != #)
-map(arr, !any(arr, ok))
-map(arr, "a" startsWith "b")
-map(arr, "b")[b]
-map(arr, # * #)
-map(arr, # + #)
-map(arr, # + b)
-map(arr, #)
-map(arr, -#)
-map(arr, -0)
-map(arr, -1)
-map(arr, -a)
-map(arr, -b)
-map(arr, -f)
-map(arr, 0 != nil)
-map(arr, 0 * 0)
-map(arr, 0 * 0.5 > b)
-map(arr, 0 + a)
-map(arr, 0 >= 0)
-map(arr, 0 ^ 0)
-map(arr, 0 in arr)
-map(arr, 0) != arr
-map(arr, 0.5 != nil)
-map(arr, 0.5 + 2)
-map(arr, 0.5 - b)
-map(arr, 0.5 <= b)
-map(arr, 0.5 > b)
-map(arr, 0.5 ^ a)
-map(arr, 0.5 ^ f)
-map(arr, 0.5) == arr
-map(arr, 0.5) == obj.head(1, a)
-map(arr, 1 + b)
-map(arr, 1 - 0)
-map(arr, 1 / a)
-map(arr, 1 == b)
-map(arr, 2 != nil)
-map(arr, 2 * a)
-map(arr, 2 ** 0.5)
-map(arr, 2 - f)
-map(arr, 2 ^ 2)
-map(arr, a != nil)
-map(arr, a % 2)
-map(arr, a % a <= #)
-map(arr, a * 0.5)
-map(arr, a ** a)
-map(arr, a + b)
-map(arr, a - f)
-map(arr, a / f)
-map(arr, a < 2)
-map(arr, a > 0)
-map(arr, a > a)
-map(arr, a > b)
-map(arr, a ^ b)
-map(arr, a)
-map(arr, abs(0))
-map(arr, add != add)
-map(arr, add != nil)
-map(arr, add == add)
-map(arr, add(#, #))
-map(arr, add(0, a))
-map(arr, add(0, b))
-map(arr, add(2, b))
-map(arr, add)
-map(arr, add)[a]
-map(arr, any(arr, ok))
-map(arr, arr)
-map(arr, b != 0.5)
-map(arr, b * 0.5)
-map(arr, b * b)
-map(arr, b + f)
-map(arr, b - 0.5)
-map(arr, b / f)
-map(arr, b <= 0.5)
-map(arr, b <= 2)
-map(arr, b <= a)
-map(arr, b > 1)
-map(arr, b > a)
-map(arr, b >= a)
-map(arr, b ^ f)
-map(arr, b)
-map(arr, b) != obj.b
-map(arr, b)[obj.b]
-map(arr, count(arr, ok))
-map(arr, count(arr, true))
-map(arr, div == add)
-map(arr, div(1, 1))
-map(arr, div(1, 2))
-map(arr, div(b, b))
-map(arr, div)
-map(arr, div) == arr
-map(arr, div)[obj.b]
-map(arr, div)[obj?.a]
-map(arr, f != b)
-map(arr, f != nil)
-map(arr, f ** 2)
-map(arr, f + a)
-map(arr, f + f)
-map(arr, f - 0.5)
-map(arr, f - f)
-map(arr, f / f)
-map(arr, f < b)
-map(arr, f <= 0)
-map(arr, f <= a)
-map(arr, f == a)
-map(arr, f == nil)
-map(arr, f > a)
-map(arr, f > f)
-map(arr, f >= a)
-map(arr, f ^ 0.5)
-map(arr, f ^ 1)
-map(arr, f)
-map(arr, false ? 0 : f)
-map(arr, false ? 0.5 : arr)
-map(arr, false ? div : a)
-map(arr, false) == obj.obj
-map(arr, filter(arr, ok))
-map(arr, float(1))
-map(arr, float(b))
-map(arr, get(arr, 0))
-map(arr, get(obj, s))
-map(arr, int(f))
-map(arr, len("b"))
-map(arr, lower(s))
-map(arr, map(arr, 0))
-map(arr, map(arr, 0.5))
-map(arr, map(arr, arr))
-map(arr, map(arr, true))
-map(arr, max(f))
-map(arr, min(0))
-map(arr, min(2))
-map(arr, min(b))
-map(arr, min(f))
-map(arr, nil != a)
-map(arr, nil != div)
-map(arr, nil == obj)
-map(arr, not ok)
-map(arr, not true)
-map(arr, obj != nil)
-map(arr, obj != obj?.b)
-map(arr, obj)
-map(arr, obj) != arr ? false : nil
-map(arr, obj) != obj.b
-map(arr, obj)[obj.a]
-map(arr, obj)[obj?.b]
-map(arr, obj.a)
-map(arr, obj.b)
-map(arr, obj.c)
-map(arr, obj.head(add, nil))
-map(arr, obj.head(arr))
-map(arr, obj.head(div))
-map(arr, obj.head(ok, f))
-map(arr, obj.obj)
-map(arr, obj.obj?.b)
-map(arr, obj?.a)
-map(arr, obj?.b)
-map(arr, obj?.fn(0))
-map(arr, obj?.fn(a))
-map(arr, obj?.head("a", b, obj))
-map(arr, obj?.head(0))
-map(arr, obj?.head(1))
-map(arr, obj?.head(add, ok, f))
-map(arr, obj?.head(arr))
-map(arr, obj?.head(b))
-map(arr, obj?.head(s))
-map(arr, obj?.obj)
-map(arr, obj?.obj.b)
-map(arr, obj?.obj?.a)
-map(arr, ok ? arr : s)
-map(arr, ok)
-map(arr, ok)[a]
-map(arr, ok)[b]
-map(arr, one(arr, ok))
-map(arr, repeat(s, a))
-map(arr, s + "a")
-map(arr, s < s)
-map(arr, s > s)
-map(arr, s endsWith s)
-map(arr, s in obj)
-map(arr, s)
-map(arr, s) != obj.a
-map(arr, s) != obj?.obj
-map(arr, s)[obj?.a]
-map(arr, s)[ok ? f : ok:a]
-map(arr, split(s, s))
-map(arr, string(arr))
-map(arr, toJSON(a))
-map(arr, trimPrefix(s))
-map(arr, true || ok)
-map(arr[b:a], ok)
-map(arr[b:b], b)
-map(arr[b:b], ok)
-map(b .. 0, b / b)
-map(b .. 1, #)
-map(b .. 1, s)
-map(b .. a, arr != arr)
-map(b .. a, b)
-map(b .. a, f > 0.5)
-map(b .. a, obj?.fn(ok, add))
-map(b .. a, s)
-map(b .. b, #)
-map(b .. b, ok)
-map(b .. b, string(arr))
-map(div(1, b) <= a ? arr : ok, #)
-map(false ? 0 : "a", obj?.obj)
-map(false ? 0 : obj, b)
-map(false ? 0.5 : arr, #)
-map(false ? a : arr, s)
-map(false ? b : "b", #)
-map(false ? div : arr, 2 * f)
-map(false ? obj : s, a)
-map(false ? s : arr, #)
-map(filter(arr, false), obj?.fn(nil))
-map(filter(arr, false), s)
-map(filter(arr, ok), 1 >= b)
-map(filter(arr, ok), 2 == nil)
-map(filter(arr, ok), a)
-map(filter(arr, ok), arr)
-map(filter(arr, ok), div)
-map(filter(arr, ok), obj)
-map(filter(arr, ok), s)
-map(filter(arr, true), #)
-map(keys(obj), #)
-map(keys(obj), b)
-map(map(arr, "a"), arr)
-map(map(arr, "a"), b)
-map(map(arr, "b"), f)
-map(map(arr, "b"), s)
-map(map(arr, "c"), #)
-map(map(arr, 0), #)
-map(map(arr, 0), obj.head(ok))
-map(map(arr, 0.5), #)
-map(map(arr, 0.5), a)
-map(map(arr, 0.5), arr)
-map(map(arr, 0.5), f)
-map(map(arr, 1), #)
-map(map(arr, 1), arr)
-map(map(arr, 1), b)
-map(map(arr, a), #)
-map(map(arr, a), arr)
-map(map(arr, add), "a" == nil)
-map(map(arr, add), #)
-map(map(arr, add), b)
-map(map(arr, add), obj)
-map(map(arr, arr), #)
-map(map(arr, arr), div)
-map(map(arr, arr), obj)
-map(map(arr, arr), obj?.b)
-map(map(arr, arr), ok)
-map(map(arr, b), #)
-map(map(arr, b), add)
-map(map(arr, b), f)
-map(map(arr, b), map(arr, ok))
-map(map(arr, b), obj)
-map(map(arr, b), ok)
-map(map(arr, b), s)
-map(map(arr, div), !true)
-map(map(arr, div), #)
-map(map(arr, div), add(b, 1))
-map(map(arr, div), add)
-map(map(arr, div), obj)
-map(map(arr, div), obj?.a)
-map(map(arr, div), split(s, s))
-map(map(arr, f), #)
-map(map(arr, f), s)
-map(map(arr, false), #)
-map(map(arr, false), add)
-map(map(arr, false), arr)
-map(map(arr, obj), 0 >= a)
-map(map(arr, obj), a in arr)
-map(map(arr, obj), a)
-map(map(arr, obj), add)
-map(map(arr, obj), b)
-map(map(arr, obj), ok)
-map(map(arr, ok), #)
-map(map(arr, s), #)
-map(map(arr, s), f)
-map(map(arr, s), obj)
-map(map(arr, true), #)
-map(map(arr, true), add)
-map(map(arr, true), f > f)
-map(map(arr, true), f ^ 1)
-map(map(arr, true), obj)
-map(obj.head("a"), #)
-map(obj.head("a", a, 0), #)
-map(obj.head("a", add, ok), b)
-map(obj.head("a", obj, "b", obj), #)
-map(obj.head("b"), a)
-map(obj.head("b"), ok)
-map(obj.head("b", nil, a, div, true), obj.a)
-map(obj.head("c"), b * 1)
-map(obj.head("c", 1, div, "a", f), #)
-map(obj.head("c", arr), #)
-map(obj.head("c", b), 0 * b)
-map(obj.head("c", b), arr)
-map(obj.head(arr), #)
-map(obj.head(arr), a)
-map(obj.head(arr), add)
-map(obj.head(arr), obj.obj)
-map(obj.head(arr), s)
-map(obj.head(arr, 0.5), a)
-map(obj.head(arr, arr, 0), a)
-map(obj.head(arr, false), arr)
-map(obj.head(arr, ok), #)
-map(obj.head(obj), a .. 0)
-map(obj.head(obj), a)
-map(obj.head(obj), arr)
-map(obj.head(obj), f)
-map(obj.head(obj), obj)
-map(obj.head(obj, a), 1 .. b)
-map(obj.head(obj, div), obj.obj)
-map(obj.head(s), #)
-map(obj.head(s), 0 + f)
-map(obj.head(s), a)
-map(obj.head(s), arr)
-map(obj.head(s), b % a)
-map(obj.head(s), b)
-map(obj.head(s), f)
-map(obj.head(s), ok)
-map(obj.head(s), s)
-map(obj.head(s, add, div), f)
-map(obj.head(s, b, f, ok, f), #)
-map(obj.head(s, ok, 0), a / 0.5)
-map(obj.obj, !false)
-map(obj.obj, "b" startsWith s)
-map(obj.obj, "c" > s)
-map(obj.obj, -0.5)
-map(obj.obj, -obj?.b)
-map(obj.obj, 0 == 1)
-map(obj.obj, 0.5 >= b)
-map(obj.obj, 2 + a)
-map(obj.obj, 2 .. b)
-map(obj.obj, a)
-map(obj.obj, add)
-map(obj.obj, arr)
-map(obj.obj, b ** b)
-map(obj.obj, b == 2)
-map(obj.obj, b)
-map(obj.obj, div(0, a))
-map(obj.obj, div)
-map(obj.obj, f)
-map(obj.obj, false || true)
-map(obj.obj, not false)
-map(obj.obj, obj)
-map(obj.obj, obj.a)
-map(obj.obj, obj.b)
-map(obj.obj, obj.fn(a))
-map(obj.obj, obj.head(a, obj, f, f))
-map(obj.obj, obj?.a)
-map(obj.obj, obj?.head(f, add, s))
-map(obj.obj, obj?.head(nil, true))
-map(obj.obj, obj?.head(obj, arr))
-map(obj.obj, ok)
-map(obj.obj, s > s)
-map(obj.obj, s matches s)
-map(obj.obj, s startsWith s)
-map(obj.obj, s)
-map(obj.obj, string(0.5))
-map(obj.obj, toBase64("c"))
-map(obj.obj, toJSON(ok))
-map(obj.obj.obj, a)
-map(obj.obj?.obj, b)
-map(obj?.head("a"), a)
-map(obj?.head("a"), add)
-map(obj?.head("a"), obj)
-map(obj?.head("b"), add)
-map(obj?.head("b", a, arr, ok, true), add)
-map(obj?.head("b", b), obj)
-map(obj?.head("c"), #)
-map(obj?.head("c"), ok && ok)
-map(obj?.head("c", add, f, "b"), #)
-map(obj?.head("c", arr, true), f ^ 0)
-map(obj?.head("c", false), #)
-map(obj?.head(arr), a)
-map(obj?.head(arr), s)
-map(obj?.head(arr, "b"), #)
-map(obj?.head(arr, 2), obj)
-map(obj?.head(arr, add), b)
-map(obj?.head(arr, b, nil, arr), toJSON(ok))
-map(obj?.head(arr, true, f), s)
-map(obj?.head(obj), -a)
-map(obj?.head(obj), b)
-map(obj?.head(obj), obj.b)
-map(obj?.head(obj), ok)
-map(obj?.head(obj, "c"), s)
-map(obj?.head(obj, 0.5), add)
-map(obj?.head(obj, a, false), arr)
-map(obj?.head(obj, f, add, s, true), s >= "b")
-map(obj?.head(obj, ok, b, a), div)
-map(obj?.head(s), b > 0.5)
-map(obj?.head(s), b)
-map(obj?.head(s), f)
-map(obj?.head(s), obj)
-map(obj?.head(s, "a", arr, obj), arr)
-map(obj?.head(s, b), obj?.a)
-map(obj?.head(s, obj), #)
-map(obj?.head(s, ok), a / 2)
-map(obj?.obj, -2)
-map(obj?.obj, 0 + a)
-map(obj?.obj, 0 == f)
-map(obj?.obj, 1 != 0)
-map(obj?.obj, 1 .. 0)
-map(obj?.obj, a != nil)
-map(obj?.obj, a + 0)
-map(obj?.obj, a)
-map(obj?.obj, abs(0))
-map(obj?.obj, add)
-map(obj?.obj, arr)
-map(obj?.obj, b > a)
-map(obj?.obj, b > f)
-map(obj?.obj, b)
-map(obj?.obj, count(arr, false))
-map(obj?.obj, count(arr, true))
-map(obj?.obj, div == add)
-map(obj?.obj, div)
-map(obj?.obj, f * a)
-map(obj?.obj, f)
-map(obj?.obj, first(arr))
-map(obj?.obj, len(s))
-map(obj?.obj, max(f, f * a))
-map(obj?.obj, nil != add)
-map(obj?.obj, nil == obj?.a)
-map(obj?.obj, obj)
-map(obj?.obj, obj.a)
-map(obj?.obj, obj.b)
-map(obj?.obj, obj.fn(0))
-map(obj?.obj, obj.head(b))
-map(obj?.obj, obj.obj)
-map(obj?.obj, obj?.a)
-map(obj?.obj, obj?.b)
-map(obj?.obj, obj?.fn(0))
-map(obj?.obj, obj?.head(ok, 0))
-map(obj?.obj, obj?.obj)
-map(obj?.obj, ok == true)
-map(obj?.obj, ok ? 0.5 : s)
-map(obj?.obj, ok ? false : ok)
-map(obj?.obj, ok)
-map(obj?.obj, s)
-map(obj?.obj, toBase64(s))
-map(obj?.obj, true ? 0 : arr)
-map(obj?.obj.obj, a)
-map(obj?.obj.obj, add)
-map(obj?.obj.obj, div)
-map(obj?.obj.obj, obj.a)
-map(obj?.obj.obj, ok)
-map(ok ? arr : "b", 1 + a)
-map(ok ? arr : nil, a)
-map(ok ? obj : "c", ok)
-map(ok ? obj : 0, arr)
-map(ok ? obj : add, div(b, a))
-map(ok ? obj : arr, arr)
-map(ok ? s : arr, b)
-map(ok ? s : div, #)
-map(ok ? s : div, add)
-map(split(s, "c"), #)
-map(true ? "a" : obj, #)
-map(true ? "b" : div, s)
-map(true ? arr : arr, #)
-map(true ? arr : f, abs(0.5))
-map(true ? arr : nil, arr)
-map(true ? obj : f, obj.head(0, true, 0.5, s))
-map(true ? s : 0, a)
-map(values(obj), f)
-map(values(obj), filter(arr, ok))
-max(-0)
+lower(toJSON(true))
+lower(trim("foo"))
+lower(trimPrefix("bar"))
+lower(trimSuffix("bar"))
+lower(trimSuffix("foo"))
+lower(trimSuffix(foo?.String()))
+lower(type("bar"))
+lower(type("foo"))
+lower(type(0.5 * i64))
+lower(type(0.5))
+lower(type(1))
+lower(type(array))
+lower(type(div))
+lower(type(f32))
+lower(type(f64))
+lower(type(false))
+lower(type(foo))
+lower(type(greet))
+lower(type(half))
+lower(type(i))
+lower(type(i64))
+lower(type(nil))
+lower(type(ok))
+lower(type(score))
+lower(type(true))
+lower(upper("bar"))
+lower(upper("foo"))
+map(1 .. 1, # .. #)
+map(1 .. 1, # == f64)
+map(1 .. i, #)
+map(1 .. i, foo)
+map(1 .. i, greet)
+map(1 .. i32, #)
+map(1 .. i32, ok)
+map(1 .. i64, f64 ^ 1)
+map(1 .. i64, foo)
+map(1 .. i64, list)
+map(["bar"], # == #)
+map(["foo"], #)
+map([1, i], #)
+map([add], foo)
+map([f32], f64)
+map([false], score)
+map([greet, i32], #)
+map([greet], #)
+map([half], #)
+map([i32], foo)
+map([i64], #)
+map([i], max(#))
+map([list, nil], i64)
+map([list], #)
+map([nil], #?.div(#))
+map([score, "bar"], #)
+map([score], #)
+map([score], array)
+map(array, !false)
+map(array, !true)
+map(array, "bar" != "foo")
+map(array, "bar" contains "foo")
+map(array, "bar")[i64]
+map(array, # != # ? # : array)
+map(array, # != #)
+map(array, # != 1)
+map(array, # != f64)
+map(array, # != i32)
+map(array, # != nil)
+map(array, # % #)
+map(array, # % 1)
+map(array, # % i)
+map(array, # % i32)
+map(array, # % i64)
+map(array, # * #)
+map(array, # * 0.5)
+map(array, # * f64)
+map(array, # * i32)
+map(array, # * i64)
+map(array, # ** #)
+map(array, # ** 0.5)
+map(array, # ** i)
+map(array, # ** i32)
+map(array, # ** i64)
+map(array, # + #)
+map(array, # + 0.5)
+map(array, # + 1)
+map(array, # + f64)
+map(array, # + i)
+map(array, # + i32)
+map(array, # + i64)
+map(array, # - #)
+map(array, # - 0.5)
+map(array, # - 1)
+map(array, # - f32)
+map(array, # - i)
+map(array, # - i32)
+map(array, # .. #)
+map(array, # .. 1)
+map(array, # .. i)
+map(array, # .. i32)
+map(array, # .. i64)
+map(array, # / #)
+map(array, # / 0.5)
+map(array, # / f64)
+map(array, # / i)
+map(array, # / i32)
+map(array, # / i64)
+map(array, # < #)
+map(array, # < 0.5)
+map(array, # < 1)
+map(array, # < f32)
+map(array, # < f64)
+map(array, # <= #)
+map(array, # <= 1)
+map(array, # <= i64)
+map(array, # == #)
+map(array, # == 1)
+map(array, # == i64)
+map(array, # > #)
+map(array, # > 1)
+map(array, # > f32)
+map(array, # > i32)
+map(array, # > i64)
+map(array, # >= #)
+map(array, # >= 0.5)
+map(array, # >= 1)
+map(array, # >= f64)
+map(array, # >= i)
+map(array, # >= i32)
+map(array, # ^ #)
+map(array, # ^ 0.5)
+map(array, # ^ i)
+map(array, # ^ i32)
+map(array, # ^ i64)
+map(array, # in array)
+map(array, #)
+map(array, #) != array
+map(array, #) != list
+map(array, #) != nil == nil
+map(array, #)[i64]
+map(array, #)[i]
+map(array, -#)
+map(array, -(# ** f64))
+map(array, -0.5)
+map(array, -1)
+map(array, -f64)
+map(array, -i)
+map(array, -i64)
+map(array, 0.5 != #)
+map(array, 0.5 != 0.5)
+map(array, 0.5 != i32)
+map(array, 0.5 * #)
+map(array, 0.5 ** #)
+map(array, 0.5 + #)
+map(array, 0.5 - #)
+map(array, 0.5 / #)
+map(array, 0.5 < #)
+map(array, 0.5 < 1)
+map(array, 0.5 <= f32)
+map(array, 0.5 == #)
+map(array, 0.5 == i32)
+map(array, 0.5 > #)
+map(array, 0.5 ^ #)
+map(array, 1 != #)
+map(array, 1 != 1)
+map(array, 1 != f32)
+map(array, 1 % #)
+map(array, 1 % i)
+map(array, 1 * #)
+map(array, 1 * f32)
+map(array, 1 ** #)
+map(array, 1 ** 1)
+map(array, 1 ** i32)
+map(array, 1 + #)
+map(array, 1 .. #)
+map(array, 1 / #)
+map(array, 1 / 1)
+map(array, 1 < 0.5)
+map(array, 1 <= #)
+map(array, 1 == #)
+map(array, 1 == nil)
+map(array, 1 >= #)
+map(array, 1 >= f64)
+map(array, 1 ^ #)
+map(array, 1 ^ 1)
+map(array, 1 in array)
+map(array, 1)[i64]
+map(array, 1)[i]
+map(array, [array])
+map(array, [i32, foo])
+map(array, abs(#))
+map(array, abs(0.5))
+map(array, add(#, #))
+map(array, add(#, i))
+map(array, add(1, #))
+map(array, add)
+map(array, add) != list
+map(array, all(array, true))
+map(array, array != nil)
+map(array, array)
+map(array, array) == array
+map(array, array[#:#])
+map(array, array[1])
+map(array, div(#, #))
+map(array, div)
+map(array, f32 ** #)
+map(array, f32 ** f64)
+map(array, f32 + #)
+map(array, f32 - f64)
+map(array, f32 / #)
+map(array, f32 < #)
+map(array, f32 <= #)
+map(array, f32 <= 1)
+map(array, f32 == #)
+map(array, f32 > #)
+map(array, f32)
+map(array, f64 != #)
+map(array, f64 != 0.5)
+map(array, f64 * 1)
+map(array, f64 ** #)
+map(array, f64 - #)
+map(array, f64 / 1)
+map(array, f64 <= f64)
+map(array, f64 > #)
+map(array, f64)
+map(array, f64) != list
+map(array, f64) == i .. 1
+map(array, false ? "foo" : #)
+map(array, false ? 0.5 : #)
+map(array, false)[i]
+map(array, findLast(array, true))
+map(array, float(# * f64))
+map(array, float(#))
+map(array, float(1))
+map(array, float(i64))
+map(array, foo)
+map(array, foo.Bar)
+map(array, foo.Qux)
+map(array, foo.String())
+map(array, foo.String)
+map(array, foo?.Qux)
+map(array, foo?.String)
+map(array, get(array, #))
+map(array, get(list, #))
+map(array, greet != half)
+map(array, greet("bar"))
+map(array, greet("foo"))
+map(array, greet)
+map(array, greet) == list
+map(array, half(0.5))
+map(array, half)
+map(array, i != #)
+map(array, i != f64)
+map(array, i % i)
+map(array, i * 0.5)
+map(array, i ** #)
+map(array, i ** 0.5)
+map(array, i .. #)
+map(array, i / #)
+map(array, i == #)
+map(array, i > #)
+map(array, i >= f64)
+map(array, i ^ #)
+map(array, i)
+map(array, i)[i64]
+map(array, i32 % #)
+map(array, i32 % i)
+map(array, i32 * #)
+map(array, i32 + 0.5)
+map(array, i32 + i64)
+map(array, i32 - #)
+map(array, i32 / #)
+map(array, i32 < 0.5)
+map(array, i32 == #)
+map(array, i32 == 0.5)
+map(array, i32 == nil)
+map(array, i32 > #)
+map(array, i32 >= f32)
+map(array, i32 ^ #)
+map(array, i32)
+map(array, i64 != #)
+map(array, i64 * #)
+map(array, i64 ** #)
+map(array, i64 + #)
+map(array, i64 - #)
+map(array, i64 .. #)
+map(array, i64 / #)
+map(array, i64 <= 1)
+map(array, i64 == #)
+map(array, i64 == f64)
+map(array, i64 > #)
+map(array, i64 >= i64)
+map(array, i64 ^ #)
+map(array, i64 ^ i32)
+map(array, i64)
+map(array, i64)[i32]
+map(array, int(#))
+map(array, int(0.5))
+map(array, int(f64))
+map(array, last(array))
+map(array, len(array))
+map(array, list)
+map(array, map(array, #))
+map(array, map(array, true))
+map(array, map(list, #))
+map(array, map(list, f64))
+map(array, max(#))
+map(array, max(#, #, #))
+map(array, max(0.5))
+map(array, max(0.5, #))
+map(array, max(i64, #, i))
+map(array, min(# ^ #))
+map(array, min(#))
+map(array, min(#, #, #, #))
+map(array, min(#, 1))
+map(array, min(#, 1, #))
+map(array, min(#, 1, f64))
+map(array, min(#, f32))
+map(array, min(#, f64))
+map(array, nil != #)
+map(array, nil == #)
+map(array, nil == half)
+map(array, not (# < 1))
+map(array, not false)
+map(array, not true)
+map(array, ok ? # : i64)
+map(array, ok ? f32 : div)
+map(array, ok || ok)
+map(array, ok)
+map(array, one(array, ok))
+map(array, one(array, true))
+map(array, score != nil)
+map(array, score(#))
+map(array, score(#, #))
+map(array, score(#, #, 1))
+map(array, score(1))
+map(array, score)
+map(array, sort(array))
+map(array, string("bar"))
+map(array, string(# ** f64))
+map(array, string(#))
+map(array, string(array))
+map(array, string(foo))
+map(array, string(list))
+map(array, string(score))
+map(array, toJSON(#))
+map(array, toJSON(array))
+map(array, toJSON(ok))
+map(array, true ? # : #)
+map(array, true ? f32 : i)
+map(array, true ? nil : #)
+map(array, true)[i]
+map(array, type(#))
+map(array, type(half))
+map(array, type(i))
+map(array, upper("foo"))
+map(array[i64:1], array)
+map(array[i64:i64], #)
+map(array[i:1], i > #)
+map(false ? 0.5 : "bar", greet)
+map(false ? 1 : list, half)
+map(false ? array : "foo", i64 / 1)
+map(false ? true : array, #)
+map(filter(array, false), foo)
+map(filter(array, ok), # <= #)
+map(filter(array, ok), #)
+map(filter(array, ok), i32 + #)
+map(filter(array, ok), score)
+map(filter(array, true), f64)
+map(filter(array, true), i)
+map(filter(list, false), #)
+map(filter(list, true), score)
+map(i .. 1, # > #)
+map(i .. 1, -i64)
+map(i .. 1, f64)
+map(i .. i32, #)
+map(i .. i32, score)
+map(i .. i64, #)
+map(i .. i64, f64)
+map(i .. i64, score)
+map(i32 .. 1, #)
+map(i32 .. 1, list)
+map(i32 .. i, add)
+map(i32 .. i, half)
+map(i32 .. i32, #)
+map(i32 .. i32, greet)
+map(i32 .. i64, abs(#))
+map(i32 .. i64, f64)
+map(i64 .. i, #)
+map(i64 .. i, i)
+map(i64 .. i32, #)
+map(list, !false)
+map(list, !true)
+map(list, "bar" in #)
+map(list, "bar" not in #)
+map(list, "bar") != list
+map(list, "foo" + "foo")
+map(list, "foo" in #)
+map(list, "foo" not matches "bar")
+map(list, "foo") == list
+map(list, # != #)
+map(list, # != foo)
+map(list, # != nil)
+map(list, # == #)
+map(list, # == foo)
+map(list, # not in list)
+map(list, #)
+map(list, #) == array
+map(list, #) == list
+map(list, #)[i32]
+map(list, #)[i64]
+map(list, #)[i]
+map(list, #?.Bar)
+map(list, #?.Qux("bar"))
+map(list, #?.Qux)
+map(list, #?.String())
+map(list, #?.String)
+map(list, -0.5)
+map(list, -1)
+map(list, -f64)
+map(list, -i)
+map(list, .Bar not in # != true)
+map(list, .Bar)
+map(list, .Qux)
+map(list, .String())
+map(list, .String)
+map(list, 0.5 - i64)
+map(list, 0.5 < f32)
+map(list, 0.5 <= f32)
+map(list, 0.5 <= i64)
+map(list, 0.5 >= 1)
+map(list, 0.5 ^ 1)
+map(list, 1 + i)
+map(list, 1 - f64)
+map(list, 1 .. 1)
+map(list, 1 .. i64)
+map(list, 1 / 1)
+map(list, 1 / f32)
+map(list, 1 < i32)
+map(list, 1 > i32)
+map(list, 1 >= f64)
+map(list, [1])
+map(list, [false])
+map(list, abs(0.5))
+map(list, abs(1))
+map(list, add)
+map(list, array)
+map(list, div != greet)
+map(list, div == div)
+map(list, div)
+map(list, div) != list
+map(list, f32 != f32)
+map(list, f32 ** f32)
+map(list, f32 / i32)
+map(list, f32 < 0.5)
+map(list, f32 <= 1)
+map(list, f32)
+map(list, f64 * 0.5)
+map(list, f64 * f32)
+map(list, f64 ** i32)
+map(list, f64 + 1)
+map(list, f64 + i32)
+map(list, f64 - 0.5)
+map(list, f64 < f64)
+map(list, f64 ^ i64)
+map(list, f64)
+map(list, f64) != list
+map(list, false ? # : nil)
+map(list, false ? f32 : #)
+map(list, false ? f32 : foo)
+map(list, false and true)
+map(list, filter(list, false))
+map(list, first(list))
+map(list, float(0.5))
+map(list, float(1))
+map(list, float(f32))
+map(list, float(i64))
+map(list, foo == #)
+map(list, foo)
+map(list, foo.Bar)
+map(list, foo.String)
+map(list, foo?.String())
+map(list, foo?.String)
+map(list, greet == greet)
+map(list, greet("foo"))
+map(list, greet)
+map(list, greet) != array ? 0.5 : 1
+map(list, half != score)
+map(list, half(0.5))
+map(list, half)
+map(list, i * 1)
+map(list, i * i64)
+map(list, i + i)
+map(list, i >= f64)
+map(list, i >= i64)
+map(list, i ^ f32)
+map(list, i ^ i64)
+map(list, i)
+map(list, i32 * f32)
+map(list, i32 == i64)
+map(list, i32 == nil)
+map(list, i32 > i)
+map(list, i32 ^ 0.5)
+map(list, i32)
+map(list, i64 == 1)
+map(list, i64 == f32)
+map(list, i64 ^ (i + i32))
+map(list, i64)
+map(list, int(1))
+map(list, len(array))
+map(list, list)
+map(list, map(array, score))
+map(list, map(list, #))
+map(list, min(i64))
+map(list, nil != #)
+map(list, nil != 1)
+map(list, nil != array)
+map(list, nil != i)
+map(list, nil != nil)
+map(list, nil == #)
+map(list, nil == div)
+map(list, nil == foo)
+map(list, nil == i32)
+map(list, nil not in array)
+map(list, not false)
+map(list, not ok)
+map(list, not true)
+map(list, ok ? i64 : i64)
+map(list, ok)
+map(list, ok) != array
+map(list, score != greet)
+map(list, score(i))
+map(list, score)
+map(list, string(#))
+map(list, string(foo))
+map(list, string(nil))
+map(list, toBase64("foo"))
+map(list, toJSON(#))
+map(list, toJSON(1))
+map(list, toJSON(foo))
+map(list, toJSON(i))
+map(list, trimPrefix("bar"))
+map(list, trimSuffix("foo"))
+map(list, true ? false : score)
+map(list, true ? nil : #)
+map(list, true)[i32]
+map(list, type(#))
+map(list, type(greet))
+map(list, type(half))
+map(list, type(i))
+map(list, type(i64))
+map(list[i:i], i)
+map(map(array, "bar"), #)
+map(map(array, # >= #), add)
+map(map(array, #), # < #)
+map(map(array, #), # ^ i32)
+map(map(array, #), #)
+map(map(array, #), add)
+map(map(array, #), div)
+map(map(array, #), f32)
+map(map(array, #), f64)
+map(map(array, #), foo)
+map(map(array, #), foo.Qux)
+map(map(array, #), greet)
+map(map(array, #), half)
+map(map(array, #), i)
+map(map(array, #), i64)
+map(map(array, #), int(#))
+map(map(array, #), nil != half)
+map(map(array, #), score(i))
+map(map(array, #), score)
+map(map(array, 0.5), # != #)
+map(map(array, 0.5), #)
+map(map(array, 0.5), -1)
+map(map(array, 0.5), list)
+map(map(array, 1), #)
+map(map(array, 1), ok)
+map(map(array, 1), score)
+map(map(array, add), #)
+map(map(array, add), list)
+map(map(array, array), add)
+map(map(array, array), f64)
+map(map(array, f32), #)
+map(map(array, f64), add)
+map(map(array, f64), nil == nil)
+map(map(array, foo), #)
+map(map(array, foo), f64)
+map(map(array, foo), greet)
+map(map(array, half), div)
+map(map(array, i64), f64)
+map(map(array, list), #)
+map(map(array, true), #)
+map(map(array, true), div)
+map(map(array, true), foo)
+map(map(list, "foo"), add)
+map(map(list, "foo"), div)
+map(map(list, "foo"), i32)
+map(map(list, #), "bar" + "foo")
+map(map(list, #), # != #)
+map(map(list, #), #)
+map(map(list, #), array)
+map(map(list, #), div)
+map(map(list, #), f32)
+map(map(list, #), f64)
+map(map(list, #), greet)
+map(map(list, #), i)
+map(map(list, #), i32)
+map(map(list, #), i64 < i32)
+map(map(list, #), i64)
+map(map(list, #), nil != i)
+map(map(list, #), ok)
+map(map(list, #), score)
+map(map(list, 0.5), # / #)
+map(map(list, 0.5), #)
+map(map(list, 0.5), greet)
+map(map(list, 0.5), list)
+map(map(list, 0.5), score)
+map(map(list, 1), # <= #)
+map(map(list, 1), foo)
+map(map(list, add), [#, #])
+map(map(list, add), f64)
+map(map(list, f32), #)
+map(map(list, f32), greet)
+map(map(list, f32), true ? "foo" : "foo")
+map(map(list, f64), #)
+map(map(list, false), array)
+map(map(list, false), f64)
+map(map(list, false), i32)
+map(map(list, false), list)
+map(map(list, foo), #)
+map(map(list, foo), ok)
+map(map(list, greet), "bar" != "foo")
+map(map(list, greet), # == #)
+map(map(list, greet), #)
+map(map(list, greet), ["foo", 1])
+map(map(list, greet), half)
+map(map(list, half), #)
+map(map(list, i), i32)
+map(map(list, i32), half)
+map(map(list, i32), list)
+map(map(list, i64), #)
+map(map(list, i64), array)
+map(map(list, i64), div)
+map(map(list, i64), f64)
+map(map(list, i64), list)
+map(map(list, list), #)
+map(map(list, list), div)
+map(map(list, list), i)
+map(map(list, ok), #)
+map(map(list, score), #)
+map(map(list, score), ok)
+map(map(list, true), #)
+map(ok ? "foo" : 0.5, #)
+map(ok ? "foo" : greet, f32)
+map(ok ? array : "bar", ok)
+map(ok ? array : foo, # / 1)
+map(sort(array), # > #)
+map(sort(array), i32 > #)
+map(true ? "bar" : true, #)
+map(true ? "foo" : add, i64)
+map(true ? array : f64, #)
+map(true ? array : true, #)
+max(--1)
 max(-0.5)
-max(-2)
-max(-a)
-max(-a, 0 + a)
-max(-b)
-max(-f)
-max(0 % 2, b)
-max(0 % a)
-max(0 ** 0.5)
-max(0 ** 2)
-max(0 ** b)
-max(0 ** f)
-max(0 + 0.5)
-max(0 + a)
-max(0 - 2)
-max(0 - a)
-max(0 / 0)
-max(0 / b)
-max(0 / f)
-max(0 ^ b)
-max(0 ^ f)
-max(0) != obj.head(false, f)
-max(0) + b
-max(0) .. a
-max(0) <= b
-max(0) == b
-max(0) > b != ok
-max(0, 0) != f
-max(0, a) < f
-max(0, b) * f
-max(0.5 * f)
-max(0.5 - a)
-max(0.5 - f)
-max(0.5 ^ 0)
-max(0.5) != obj?.a
-max(0.5) + f
-max(0.5) <= 0 * b
-max(0.5) ^ obj.head(b)
-max(0.5, 2) != obj?.b
-max(0.5, b) < b ? div : 2
-max(0.5, b, 0.5) < obj?.a
+max(-1)
+max(-1, i)
+max(-count(list, false), i64)
+max(-f32)
+max(-f64)
+max(-i)
+max(-i, i32, i)
+max(-i32)
+max(-i64)
+max(-i64, 0.5 / f64)
+max(0.5 * 0.5)
+max(0.5 * f64)
+max(0.5 * i)
+max(0.5 * i, i32)
+max(0.5 * i32)
+max(0.5 ** 0.5)
+max(0.5 ** 1)
+max(0.5 ** f32)
+max(0.5 ** f64)
+max(0.5 ** i)
+max(0.5 ** i64)
+max(0.5 + 0.5)
+max(0.5 + 1)
+max(0.5 + i)
+max(0.5 + i32)
+max(0.5 + i64)
+max(0.5 - 0.5)
+max(0.5 - 1)
+max(0.5 - i)
+max(0.5 - i32)
+max(0.5 - i64)
+max(0.5 / 0.5)
+max(0.5 / f32)
+max(0.5 / f64)
+max(0.5 / f64, f64)
+max(0.5 / i)
+max(0.5 / i64)
+max(0.5 ^ 0.5)
+max(0.5 ^ 1)
+max(0.5 ^ f32)
+max(0.5 ^ i)
+max(0.5 ^ i32)
+max(0.5 ^ i64)
+max(0.5) != i == ok
+max(0.5) * f32
+max(0.5) * f64
+max(0.5) + i
+max(0.5) - f32
+max(0.5) - f64
+max(0.5) < f64
+max(0.5) <= 0.5 - 0.5
+max(0.5) <= f64
+max(0.5) == f32
+max(0.5) == i64
+max(0.5) > f32
+max(0.5) >= i32
+max(0.5) ^ i32
+max(0.5, 1) <= i32
 max(1 % 1)
-max(1 * a)
-max(1 ** f)
-max(1 - a)
-max(1 / 2)
-max(1 / f)
-max(1 ^ f)
-max(1) .. b
-max(1) / int(f)
-max(1) / max(b, a, 0.5, 2)
-max(1) > 0.5 ? add : ok
-max(2 * 2)
-max(2 * f)
-max(2 + f)
-max(2 - 0.5)
-max(2 / a)
-max(2 / f)
-max(2 ^ 1)
-max(2 ^ f)
-max(2) * b
-max(2) - 0 % a
-max(2) ^ a ^ 0
-max(2, b) != b
-max(a % a)
-max(a % b)
-max(a * 0.5)
-max(a * f)
-max(a ** a)
-max(a ** f)
-max(a + 0.5)
-max(a + 1)
-max(a + 1, f)
-max(a + a)
-max(a - 0)
-max(a - 1)
-max(a - f)
-max(a / a, a)
-max(a / obj?.b)
-max(a / obj?.head(0.5, s, div))
-max(a ^ 0)
-max(a ^ f)
-max(a)
-max(a) - b
-max(a) - div(0, b)
-max(a) .. a
-max(a) < f
-max(a) <= b
-max(a) <= f
-max(a) == b ? 0 : nil
-max(a) > f
-max(a, -b)
-max(a, 0) - b
-max(a, 1) ^ b ** f
-max(a, a)
-max(a, a, b)
-max(a, b)
-max(a, f)
-max(abs(a))
-max(abs(arr[b]))
-max(abs(b))
-max(abs(f ^ 0.5))
-max(add(0, 0))
-max(add(0, b))
-max(add(1, 1))
-max(add(1, 2))
-max(add(2, a))
-max(add(a, 1))
-max(add(a, 2))
-max(add(a, a))
-max(add(b - a, obj.a))
-max(add(b, b))
-max(arr[0])
-max(arr[0], a)
-max(arr[1])
-max(arr[a])
-max(arr[b])
-max(b % b)
-max(b * 0)
-max(b * a)
-max(b * f)
-max(b ** 0)
-max(b ** 0.5)
-max(b ** 2)
-max(b ** a)
-max(b ** f)
-max(b + a)
-max(b - b)
-max(b - f)
-max(b / 0)
-max(b / 2)
-max(b / b)
-max(b / f)
-max(b ^ 0)
-max(b ^ 0.5)
-max(b ^ 1)
-max(b ^ b)
-max(b ^ f)
-max(b)
-max(b) != 0.5 ** 0
-max(b) * f
-max(b) ** a
-max(b) < b
-max(b) == div(b, b)
-max(b) == max(b)
-max(b, 2) ^ b
-max(b, a)
-max(b, a) >= float(f)
-max(b, b)
-max(b, f)
-max(b, float(a))
-max(count(arr, true))
-max(div(0, 2))
-max(div(0, a))
+max(1 % i)
+max(1 % i32)
+max(1 % i64)
+max(1 * 0.5)
+max(1 * 1)
+max(1 ** 0.5)
+max(1 ** 1)
+max(1 ** f64)
+max(1 ** i64)
+max(1 + f32, f64)
+max(1 + i64)
+max(1 - 1)
+max(1 - i32)
+max(1 - i64)
+max(1 / 0.5)
+max(1 / 1)
+max(1 / f32)
+max(1 / f64)
+max(1 ^ 1)
+max(1 ^ i32)
+max(1) != i
+max(1) * i
+max(1) - f64
+max(1) - i64
+max(1) .. i32
+max(1) / i
+max(1) / i64
+max(1) <= f32
+max(1) <= i
+max(1) <= i32
+max(1) <= i64
+max(1) == f32
+max(1) > f32
+max(1) > f64
+max(1) > i
+max(1) > i64
+max(1, i32, f32) != i64
+max(abs(0.5))
+max(abs(1))
+max(abs(f32))
+max(abs(f64))
+max(abs(i))
+max(abs(i32))
+max(abs(i64))
+max(array[1])
+max(array[i64])
+max(array[i])
+max(count(array, false))
+max(count(list, false))
 max(div(1, 1))
-max(div(1, a))
-max(div(1, b))
-max(div(a, 2))
-max(div(a, b))
-max(div(b, 2))
-max(div(b, a))
-max(div(b, b))
-max(f * 0)
-max(f * a)
-max(f * b)
-max(f * b, a)
-max(f * f)
-max(f ** a)
-max(f ** obj.b)
-max(f + 0)
-max(f + a)
-max(f + b)
-max(f - 0)
-max(f - 1)
-max(f - 2)
-max(f - b)
-max(f - f)
-max(f / 0)
-max(f / 0.5)
-max(f / 1)
-max(f / a)
-max(f / b)
-max(f / f)
-max(f ^ a)
-max(f ^ b)
-max(f ^ f)
-max(f ^ f) ^ b
-max(f)
-max(f) != obj.a
-max(f) * a
-max(f) - int(0)
-max(f) / obj?.head(a, ok)
-max(f, 2 / f)
-max(f, a)
-max(f, b)
-max(f, f)
-max(false ? 0 : b)
-max(false ? b : b)
+max(f32 * 0.5)
+max(f32 * 1)
+max(f32 * f32)
+max(f32 * i32)
+max(f32 ** 0.5)
+max(f32 ** 1)
+max(f32 ** i32)
+max(f32 ** i64)
+max(f32 + 1)
+max(f32 + f64)
+max(f32 + i64)
+max(f32 - f64)
+max(f32 - i)
+max(f32 - i32)
+max(f32 / 0.5)
+max(f32 / f32)
+max(f32 ^ 0.5)
+max(f32 ^ 1)
+max(f32 ^ f32)
+max(f32 ^ i32)
+max(f32 ^ i64)
+max(f32)
+max(f32) != -i32
+max(f32) != i32
+max(f32) + i64
+max(f32) - f32
+max(f32) <= i
+max(f32) <= max(f64)
+max(f32) >= i64
+max(f32) ^ f32
+max(f32) ^ i32
+max(f32, -f32)
+max(f32, 1) > i32
+max(f32, f32)
+max(f32, f64)
+max(f32, i)
+max(f32, i32)
+max(f32, i64)
+max(f32, min(i))
+max(f64 * 0.5)
+max(f64 * f64)
+max(f64 * i, f32)
+max(f64 * i32)
+max(f64 ** 1)
+max(f64 ** i)
+max(f64 ** i64)
+max(f64 + 0.5)
+max(f64 - i32)
+max(f64 - i64)
+max(f64 / 0.5)
+max(f64 / f32)
+max(f64 / i32)
+max(f64 ^ 0.5)
+max(f64 ^ i32)
+max(f64 ^ i64)
+max(f64)
+max(f64) != i
+max(f64) + f32
+max(f64) + i64
+max(f64) - f32
+max(f64) / f32
+max(f64) / i32
+max(f64) == f64
+max(f64) == i32
+max(f64) > f32
+max(f64) > f64
+max(f64) > i64
+max(f64) ^ 1 ^ i64
+max(f64) ^ i
+max(f64) ^ min(i32, 1)
+max(f64, -1)
+max(f64, 0.5 ** i64)
+max(f64, 1) <= f64
+max(f64, 1) == i32
+max(f64, f32)
+max(f64, f32, i32)
+max(f64, f32, i64)
+max(f64, f64)
+max(f64, f64, score(1))
+max(f64, float(i))
+max(f64, half(f64))
+max(f64, i)
+max(f64, i32)
+max(f64, i64)
+max(false ? 1 : 0.5)
+max(false ? 1 : nil)
+max(false ? add : ok)
+max(false ? half : list)
+max(false ? i : nil)
+max(false ? i32 : score)
+max(false ? true : 1)
+max(find(array, ok))
+max(find(array, true))
+max(findIndex(array, ok))
+max(findIndex(array, true))
+max(findIndex(list, ok))
+max(findIndex(list, true))
+max(findLast(array, false))
+max(findLast(array, true))
+max(findLastIndex(array, false))
+max(findLastIndex(list, true))
+max(first(array))
 max(float(0.5))
-max(float(2))
-max(float(b))
-max(float(f))
-max(get(arr, 0), a)
-max(get(arr, a))
-max(get(arr, b))
-max(int(0))
+max(float(1))
+max(float(f32))
+max(float(f64))
+max(float(i))
+max(float(i64))
+max(float(i64), f64)
+max(get(array, 1))
+max(get(array, i))
+max(get(array, i32))
+max(get(array, i64))
+max(half(-0.5))
+max(half(0.5))
+max(half(f64))
+max(i % i)
+max(i % i32)
+max(i % i64)
+max(i * 0.5)
+max(i * 1)
+max(i * f32)
+max(i * i32)
+max(i ** 0.5)
+max(i ** 1)
+max(i ** f64)
+max(i ** i)
+max(i ** i64)
+max(i + 0.5)
+max(i + 1)
+max(i + f32)
+max(i + f64)
+max(i + i)
+max(i - 1)
+max(i - i32)
+max(i - i32, f32)
+max(i - i64)
+max(i / 0.5)
+max(i / f32)
+max(i / i32, f64)
+max(i ^ 0.5)
+max(i ^ 1)
+max(i ^ f32)
+max(i ^ f64)
+max(i)
+max(i) != f64
+max(i) ** f64
+max(i) + f32
+max(i) + i64
+max(i) - f32
+max(i) - f64
+max(i) - i32
+max(i) - i64
+max(i) / f64
+max(i) >= i64
+max(i) ^ (i * i)
+max(i) ^ f32
+max(i, -f32)
+max(i, f32)
+max(i, f32, f32)
+max(i, f64)
+max(i, i)
+max(i, i32)
+max(i, i64)
+max(i, i64, i64)
+max(i32 % 1)
+max(i32 % i32)
+max(i32 * 0.5)
+max(i32 * 1)
+max(i32 * f32)
+max(i32 * i64)
+max(i32 + 0.5, f64)
+max(i32 + f64)
+max(i32 + i)
+max(i32 + i32)
+max(i32 - i)
+max(i32 - i64)
+max(i32 / f32)
+max(i32 / f64)
+max(i32 / i64)
+max(i32 ^ 0.5)
+max(i32 ^ 1)
+max(i32 ^ f32)
+max(i32 ^ i)
+max(i32 ^ i32)
+max(i32)
+max(i32) != min(i64)
+max(i32) - f32
+max(i32) - i64
+max(i32) / f32
+max(i32) >= i32
+max(i32) ^ i64
+max(i32, 1) == i32
+max(i32, abs(f64))
+max(i32, f32)
+max(i32, f32) != i32
+max(i32, f64)
+max(i32, f64) - f32
+max(i32, i)
+max(i32, i, i)
+max(i32, i32)
+max(i32, i32, i)
+max(i32, i64)
+max(i64 % i)
+max(i64 % i32)
+max(i64 * 0.5)
+max(i64 * 1)
+max(i64 * f32)
+max(i64 * i32)
+max(i64 ** 1)
+max(i64 ** i64)
+max(i64 + 0.5)
+max(i64 + f32)
+max(i64 + i32)
+max(i64 - 0.5)
+max(i64 - 1)
+max(i64 - f32)
+max(i64 - f64)
+max(i64 - i)
+max(i64 / 1)
+max(i64 / f64)
+max(i64 / i)
+max(i64 / i64)
+max(i64 ^ 0.5)
+max(i64 ^ 1)
+max(i64 ^ i)
+max(i64 ^ i64)
+max(i64)
+max(i64) != f32
+max(i64) != i32
+max(i64) * i32
+max(i64) * i64
+max(i64) ** i64
+max(i64) + f32
+max(i64) + i64
+max(i64) / f32
+max(i64) / i
+max(i64) / i64
+max(i64) < f32
+max(i64) < i64
+max(i64) <= i
+max(i64) == f32
+max(i64) == f64
+max(i64) >= i32
+max(i64) ^ (i64 / f32)
+max(i64) in array
+max(i64, 1) * i32
+max(i64, f32)
+max(i64, f64)
+max(i64, i)
+max(i64, i32)
+max(i64, i64)
 max(int(0.5))
-max(int(a))
-max(int(b))
-max(last(arr))
-max(len("a"))
-max(len("c"), b)
-max(len(obj.head(s)))
-max(max(0, f, b, a))
-max(max(2))
-max(max(a, 0.5))
-max(max(b))
-max(max(b, 2, f))
-max(max(f))
+max(int(1))
+max(int(f32))
+max(int(f64))
+max(int(i))
+max(int(i32))
+max(int(i64))
+max(last(array))
+max(len("bar"))
+max(len("foo"))
+max(len(array))
+max(len(list))
+max(len(list), 0.5 - i)
+max(max(0.5))
+max(max(0.5, 0.5))
+max(max(1))
+max(max(f32))
+max(max(f64))
+max(max(i))
+max(max(i32))
+max(max(i64))
 max(min(0.5))
-max(min(2))
-max(min(a))
-max(min(a, b))
-max(min(b, 0))
-max(min(f))
-max(true ? a : 0)
-min(-(0.5 ^ b))
-min(-0)
-min(-2)
-min(-a)
-min(-b)
-min(-f)
-min(-f, a)
-min(0 % 2)
-min(0 % b)
-min(0 * a)
-min(0 * b, b)
-min(0 ** a)
-min(0 ** b)
-min(0 ** f, f)
-min(0 + 0)
-min(0 - b)
-min(0 / 1)
-min(0 / 2)
-min(0 / f)
-min(0 ^ 0)
-min(0) % b
-min(0) % obj.b
-min(0) * obj?.b
-min(0) + b
-min(0) - b
-min(0) / a
-min(0) / obj?.head(a)
-min(0) > a / b
-min(0) ^ get(arr, a)
-min(0, 2) ^ f
-min(0.5 * 0)
-min(0.5 ** a)
-min(0.5 - f)
-min(0.5 / a)
-min(0.5 / b)
-min(0.5 / f)
-min(0.5 ^ 0)
+max(min(0.5, i))
+max(min(1))
+max(min(1, i64, 1))
+max(min(f32))
+max(min(f64))
+max(min(f64, i64))
+max(min(i))
+max(min(i32))
+max(min(i32, i))
+max(ok ? 1 : foo)
+max(ok ? 1 : i)
+max(ok ? 1 : i32)
+max(ok ? div : foo)
+max(ok ? div : i64)
+max(ok ? i : true)
+max(ok ? ok : i64)
+max(ok ? true : 0.5)
+max(score(1))
+max(score(1), i64)
+max(score(i))
+max(score(i, i))
+max(true ? 0.5 : half)
+max(true ? 1 : i64)
+max(true ? add : list)
+max(true ? foo : add)
+max(true ? foo : f32)
+max(true ? i : ok)
+max(true ? i64 : "bar")
+min(-(0.5 + i))
+min(-(f32 + i64))
+min(-0.5)
+min(-0.5, i)
+min(-1)
+min(-1, i)
+min(-1, i64)
+min(-f32)
+min(-f32, i64)
+min(-f64)
+min(-f64, i32)
+min(-i)
+min(-i32)
+min(-i64)
+min(0.5 * 0.5)
+min(0.5 * 1)
+min(0.5 * f64)
+min(0.5 * i32)
+min(0.5 ** 0.5)
+min(0.5 ** f64)
+min(0.5 ** i64)
+min(0.5 + 1)
+min(0.5 + f32)
+min(0.5 + f64)
+min(0.5 + i)
+min(0.5 - 0.5)
+min(0.5 - 1)
+min(0.5 - f64)
+min(0.5 - i)
+min(0.5 / 0.5)
+min(0.5 / f64)
 min(0.5 ^ 1)
-min(0.5 ^ a)
-min(0.5) != f
-min(0.5) * a
-min(0.5) ** a
-min(0.5) - f
-min(0.5) > a
-min(1 % b)
-min(1 * f)
-min(1 ** b)
+min(0.5 ^ f32)
+min(0.5 ^ i)
+min(0.5) != i32
+min(0.5) * 0.5 ** i64
+min(0.5) ** i
+min(0.5) + i
+min(0.5) + i32
+min(0.5) + i64
+min(0.5) < f32
+min(0.5) <= i ? f32 : 1
+min(0.5) <= i64
+min(0.5) == i - 0.5
+min(0.5) > i64
+min(0.5) >= i
+min(0.5, 0.5) == f32
+min(0.5, 1) >= i64
+min(0.5, i) == i64
+min(0.5, i32, f32) + f32
+min(1 % i32)
+min(1 % i64)
+min(1 * 0.5)
+min(1 * 1)
+min(1 * i)
+min(1 * i32)
+min(1 * i64)
+min(1 ** 0.5)
+min(1 ** f32)
+min(1 ** f64)
+min(1 ** i32)
+min(1 + 0.5)
 min(1 + 1)
-min(1 + a)
-min(1 - a)
-min(1 / a)
-min(1 / b)
-min(1 ^ 0)
-min(1) .. obj?.b
-min(1) == obj.obj
-min(1) >= f ? b : arr
-min(1) ^ b
-min(2 % b + a)
-min(2 % b)
-min(2 * b)
-min(2 ** 0)
-min(2 ** f)
-min(2 + 0.5)
-min(2 - b)
-min(2 ^ a)
-min(2) ** f
-min(a % 1)
-min(a % a)
-min(a % b)
-min(a * a)
-min(a * b, int(0))
-min(a * f)
-min(a ** 0)
-min(a ** a, b)
-min(a ** b)
-min(a ** f)
-min(a - 2)
-min(a - a)
-min(a - f)
-min(a / a)
-min(a / b)
-min(a ^ 0.5)
-min(a ^ b)
-min(a ^ obj.a)
-min(a)
-min(a) != f
-min(a) % a
-min(a) ** f
-min(a) - obj.b
-min(a) / b
-min(a) < a / 0
-min(a) == a
-min(a) > b
-min(a) > obj?.a
-min(a) >= a ^ b
-min(a) >= obj.head(f, nil)
-min(a) ^ a
-min(a) ^ f
-min(a, 0.5 / a)
-min(a, 2) ^ f
-min(a, a ** f)
-min(a, a)
-min(a, a) > f ** 0.5
-min(a, b)
-min(a, b) != f / a
-min(abs(0))
-min(abs(a))
-min(abs(b))
-min(add(0, 0))
-min(add(0, 1))
-min(add(0, 2))
-min(add(0, a))
-min(add(2, b))
-min(add(a, a))
-min(add(a, a), b)
-min(add(a, b))
-min(add(b, 0))
-min(add(b, 1))
-min(add(b, a))
-min(add(b, b))
-min(arr[0])
-min(arr[1])
-min(arr[a])
-min(arr[b])
-min(b % a)
-min(b * b)
-min(b * f)
-min(b ** 0)
-min(b ** 0.5)
-min(b ** a)
-min(b + 1)
-min(b + a)
-min(b + b)
-min(b + f)
-min(b - 0)
-min(b - 0.5)
-min(b - a)
-min(b / f)
-min(b / obj.a)
-min(b ^ a)
-min(b ^ f)
-min(b)
-min(b) * obj.a
-min(b) * obj.head(f, b)
-min(b) ** a
-min(b) + div(0, a)
-min(b) .. obj.a
-min(b) < -f
-min(b) <= a / f
-min(b) <= len(s)
-min(b) == obj.a
-min(b) ^ b
-min(b, 0) >= b
-min(b, 0, f) - b
-min(b, 1) != obj?.head(f)
-min(b, a - a)
-min(b, a)
-min(b, a) % obj.b
-min(b, a) ^ 0.5 ^ 0.5
-min(b, f)
-min(count(arr, ok))
-min(count(map(arr, add), f != nil))
-min(div(0, a) / f)
-min(div(0, b))
-min(div(1, a))
-min(div(2, a))
-min(div(2, b))
-min(div(a, 1))
-min(div(a, 2))
-min(div(a, b))
-min(div(a, b), a)
-min(div(b, 2))
-min(div(b, b))
-min(f * a, a)
-min(f ** 0.5)
-min(f ** a)
-min(f ** b)
-min(f ** f)
-min(f - 0.5)
-min(f - a)
-min(f / 0)
-min(f / a)
-min(f / b)
-min(f / f)
-min(f ^ 0)
-min(f ^ 0.5)
-min(f ^ b)
-min(f)
-min(f) * a ^ f
-min(f) ** obj?.head(b, nil, true, 2, add)
-min(f) / obj.a
-min(f) > f
-min(f, a)
-min(f, f)
-min(first(arr))
-min(float(0))
-min(float(b))
-min(get(arr, 0))
-min(get(arr, 1))
-min(get(arr, 2))
-min(get(arr, a))
-min(get(arr, b))
-min(indexOf(s, s))
-min(int(0))
+min(1 + f32)
+min(1 + i32)
+min(1 + i64)
+min(1 - 1)
+min(1 - f64)
+min(1 - i)
+min(1 - i32)
+min(1 / 1)
+min(1 / i)
+min(1 / i32)
+min(1 / i32, f64)
+min(1 / i64)
+min(1 ^ 1)
+min(1 ^ f32)
+min(1 ^ f64)
+min(1) != 1 ? list : f64
+min(1) != i
+min(1) % i64
+min(1) * -0.5
+min(1) * 1 ** 1
+min(1) - i64 ^ 0.5
+min(1) .. i
+min(1) .. i64
+min(1) / f64
+min(1) / i
+min(1) < i
+min(1) == f64
+min(1) == i32
+min(1) >= i64
+min(1) ^ f32
+min(abs(0.5))
+min(abs(1))
+min(abs(f32))
+min(abs(f64))
+min(abs(i * 1))
+min(abs(i))
+min(abs(i32))
+min(abs(i64))
+min(abs(i64), f64)
+min(add(1, i))
+min(add(i, i))
+min(array[1])
+min(array[i])
+min(count(array, false))
+min(count(array, ok))
+min(count(array, true))
+min(count(list, ok))
+min(f32 * 1)
+min(f32 * f32)
+min(f32 * i32)
+min(f32 ** i32)
+min(f32 ** i64)
+min(f32 ** i64, f32)
+min(f32 + f64)
+min(f32 + i)
+min(f32 + i32)
+min(f32 + i64)
+min(f32 - f32)
+min(f32 - i)
+min(f32 - i32)
+min(f32 - i64)
+min(f32 / 0.5)
+min(f32 / f64)
+min(f32 / i)
+min(f32 / i32)
+min(f32 / i64)
+min(f32 ^ 1)
+min(f32 ^ f32)
+min(f32 ^ i)
+min(f32 ^ i32)
+min(f32)
+min(f32) * f32
+min(f32) * f64
+min(f32) + i
+min(f32) + i32
+min(f32) + i64
+min(f32) - f32
+min(f32) < i64
+min(f32) == i
+min(f32) == i32 * i32
+min(f32) == i64
+min(f32) > i32
+min(f32) ^ f64
+min(f32, 0.5 ^ 0.5)
+min(f32, 0.5) <= i64
+min(f32, f32)
+min(f32, f64)
+min(f32, f64) >= i
+min(f32, get(array, i64))
+min(f32, i)
+min(f32, i32)
+min(f32, i64)
+min(f32, len(array))
+min(f32, len(list))
+min(f64 * 0.5)
+min(f64 * 1)
+min(f64 * f64)
+min(f64 * i)
+min(f64 * i32)
+min(f64 ** 1)
+min(f64 ** f64)
+min(f64 ** i)
+min(f64 ** i32)
+min(f64 ** i64)
+min(f64 + 1)
+min(f64 + i)
+min(f64 + i64)
+min(f64 - 0.5)
+min(f64 - i)
+min(f64 - i32)
+min(f64 - i64)
+min(f64 / 1)
+min(f64 / f32)
+min(f64 / i)
+min(f64 / i32)
+min(f64 / i64)
+min(f64 ^ 0.5)
+min(f64 ^ f64)
+min(f64 ^ i32)
+min(f64)
+min(f64) + f64
+min(f64) + i32
+min(f64) + i64
+min(f64) / f32
+min(f64) ^ 1 ^ 1
+min(f64) ^ i32
+min(f64) ^ i64
+min(f64, 0.5 ** 1)
+min(f64, 0.5, i) <= f64
+min(f64, 1 ** i)
+min(f64, 1) < i64
+min(f64, f32)
+min(f64, f64)
+min(f64, f64, i64)
+min(f64, i)
+min(f64, i32)
+min(f64, i64)
+min(false ? 1 : add)
+min(false ? f64 : false)
+min(false ? f64 : score)
+min(false ? foo : 1)
+min(false ? greet : i)
+min(false ? i32 : "foo")
+min(false ? i32 : i64)
+min(false ? true : 0.5)
+min(find(array, false))
+min(find(array, ok))
+min(findIndex(list, ok))
+min(findLast(array, true))
+min(findLastIndex(array, false))
+min(findLastIndex(array, ok))
+min(findLastIndex(array, true))
+min(findLastIndex(list, ok))
+min(first(array))
+min(float(0.5))
+min(float(1))
+min(float(f32))
+min(float(f64))
+min(float(i))
+min(float(i32))
+min(float(i64))
+min(get(array, i))
+min(get(array, i64))
+min(half(0.5 ^ i32))
+min(half(0.5))
+min(half(0.5), f32)
+min(half(f64))
+min(i % 1)
+min(i % i32)
+min(i % i64)
+min(i * 0.5)
+min(i * 1)
+min(i * i)
+min(i * i64)
+min(i ** 0.5)
+min(i ** f32)
+min(i ** f64)
+min(i ** i)
+min(i ** i64)
+min(i + 0.5)
+min(i + f32)
+min(i + f64)
+min(i + i)
+min(i - 0.5)
+min(i - 1)
+min(i - i)
+min(i / 0.5)
+min(i / i64)
+min(i / i64, i)
+min(i ^ 0.5)
+min(i ^ i, i32)
+min(i)
+min(i) != i32
+min(i) % i
+min(i) * f32
+min(i) ** i
+min(i) .. i
+min(i) / f64
+min(i) < f32
+min(i) <= i64
+min(i, f32)
+min(i, f64)
+min(i, i)
+min(i, i32 - i)
+min(i, i32)
+min(i, i64 * f32)
+min(i, i64)
+min(i32 % i)
+min(i32 * 1)
+min(i32 * f64)
+min(i32 * i32)
+min(i32 ** 1 ^ i64)
+min(i32 ** f32)
+min(i32 ** i)
+min(i32 ** i64)
+min(i32 + 0.5)
+min(i32 + 1)
+min(i32 + f32)
+min(i32 - 0.5)
+min(i32 - 1)
+min(i32 - i32)
+min(i32 / 1)
+min(i32 / i)
+min(i32 / i64)
+min(i32 / i64, score(1))
+min(i32 ^ 1)
+min(i32 ^ f64)
+min(i32 ^ i)
+min(i32 ^ i64)
+min(i32)
+min(i32) != i64
+min(i32) + f32
+min(i32) - i64
+min(i32) / f32
+min(i32) < i32
+min(i32) == f32
+min(i32) == i32
+min(i32) >= i32
+min(i32) ^ f64
+min(i32, 0.5) .. i32
+min(i32, f32)
+min(i32, f64)
+min(i32, i)
+min(i32, i32)
+min(i32, i32, i)
+min(i32, i64)
+min(i32, i64) .. i
+min(i32, i64) <= f64
+min(i32, min(i))
+min(i64 % i32)
+min(i64 * 1, f32)
+min(i64 * f64)
+min(i64 * i32)
+min(i64 ** 0.5)
+min(i64 ** 1)
+min(i64 ** i)
+min(i64 + 0.5)
+min(i64 + 1)
+min(i64 + f32)
+min(i64 + i)
+min(i64 + i32)
+min(i64 - 0.5)
+min(i64 - f32)
+min(i64 - f64)
+min(i64 - i)
+min(i64 - i64)
+min(i64 / 0.5)
+min(i64 / f64)
+min(i64 / i)
+min(i64 / i64)
+min(i64 ^ 1)
+min(i64 ^ i32)
+min(i64 ^ i64)
+min(i64)
+min(i64) != i64
+min(i64) % i32
+min(i64) ** -1
+min(i64) ** -f64
+min(i64) ** i
+min(i64) + i32
+min(i64) .. i
+min(i64) .. i64
+min(i64) <= f32
+min(i64) == i
+min(i64) ^ f32
+min(i64) ^ f64
+min(i64) in array
+min(i64, 1 ** 0.5)
+min(i64, 1) <= f64
+min(i64, f32)
+min(i64, f64)
+min(i64, f64) != f64
+min(i64, f64) * i32
+min(i64, f64, i32)
+min(i64, i)
+min(i64, i32)
+min(i64, i32, i)
+min(i64, i64)
+min(i64, i64, f32)
+min(int(0.5))
 min(int(1))
-min(int(a))
-min(int(b))
-min(last(arr))
-min(len("c"))
-min(len(arr))
-min(len(obj))
-min(len(obj?.obj))
-min(len(s))
-min(len(s), a)
-min(max(a))
-min(max(b))
-min(max(b, 0.5))
-min(max(f))
+min(int(f32))
+min(int(f64))
+min(int(i))
+min(int(i64))
+min(last(array))
+min(len("bar"))
+min(len("foo"))
+min(len(array))
+min(len(list))
+min(len(list), f64)
+min(max(0.5))
+min(max(1))
+min(max(1, 0.5))
+min(max(1, f32))
+min(max(1, i32))
+min(max(f32))
+min(max(f64))
+min(max(i), i64)
+min(max(i32))
+min(min(0.5))
+min(min(0.5, 1))
 min(min(1))
-min(min(a))
-min(min(b, 0))
-min(min(f))
-min(min(int(f), b))
-min(ok ? b : 2)
-min(ok ? b : a)
-min(true ? 2 : 2)
-nil != "a" == ok
-nil != "a" || b <= 0
-nil != "c" or ok
-nil != 0 && obj.a
-nil != 0 || ok
-nil != 0.5 != ok
-nil != a and ok
-nil != a or ok
-nil != add && b > 0
-nil != add or obj.b
-nil != arr != obj.obj
-nil != arr or ok
-nil != b != obj.obj
-nil != b && obj.b
-nil != b and ok ? ok : add
-nil != b || obj.fn(s, ok).b
-nil != div != obj?.head(ok)
-nil != div != ok
-nil != div and ok
-nil != f and f < 2
-nil != f or obj?.obj
-nil != false or obj.obj
-nil != obj != (ok or ok)
-nil != obj && "c" > "b"
-nil != obj or ok
-nil != obj.a
-nil != obj.b
-nil != obj.obj
-nil != obj.obj.a
-nil != obj.obj.obj
-nil != obj?.a
-nil != obj?.b
-nil != obj?.b .. b
-nil != obj?.obj
-nil != obj?.obj?.b
-nil != obj?.obj?.obj
-nil != ok ? obj.a : add
-nil != s and 0.5 == 2
-nil != s or obj?.fn(1)
-nil != s or ok
-nil != true ? ok != ok : int("c")
-nil == "a" or nil != false
-nil == "c" and obj.fn("b", s, a)
-nil == a || 2 != b
-nil == a || ok
-nil == add != obj?.head(nil, add)
-nil == add != obj?.obj
-nil == add && obj.b
-nil == add and obj == nil
-nil == arr != true ? b : b
-nil == arr && obj.b
-nil == arr && obj?.head(obj, nil, a)
-nil == arr and obj.head(div(arr, a)?.head(add?.fn(nil), arr ? "c" : 0), 0 matches a.obj)
-nil == arr and ok
-nil == div || any(arr, true)
-nil == f != obj.a
-nil == f && obj.a
-nil == f and obj.obj
-nil == false and nil == arr
-nil == false and not false
-nil == nil || 0 >= 0
-nil == obj && obj?.obj
-nil == obj ? f / b : obj
-nil == obj and ok
-nil == obj || obj?.a
-nil == obj || ok
-nil == obj.a
-nil == obj.b
-nil == obj.head(add)
-nil == obj.obj
-nil == obj.obj.obj
-nil == obj?.a
-nil == obj?.b
-nil == obj?.obj
-nil == obj?.obj.a
-nil == obj?.obj.obj
-nil == obj[s]
-nil == ok && !true
-nil == ok && obj?.fn(b)
-nil == ok ? s : b
-nil == ok and obj.obj
-nil == ok and obj?.head("c")
-nil == ok or ok
-nil == ok || obj.a
-nil == ok || ok
-nil == s != ok
-nil == s and obj?.fn(true, 1)
-nil == s or ok
-nil == true and {"b": arr}.b
-nil in arr && obj.a
-nil in arr == ok
-nil in arr ? 2 .. 2 : obj
-nil in obj && ok
-nil in obj or 2 < 0
-nil in obj.obj
-nil in obj?.head(obj)
-nil in obj?.obj
-nil in obj?.obj?.obj
-none(0 .. a, ok)
-none(1 .. b, ok)
-none([true], ok)
-none(a .. 0, obj.a)
-none(a .. a, "b" > "b")
-none(a .. a, nil == obj)
-none(arr, "a" < s)
-none(arr, "a" contains s)
-none(arr, "a" startsWith s)
-none(arr, 0 < 1)
-none(arr, 0 <= b)
-none(arr, 0 == nil)
-none(arr, 0 > 0.5)
-none(arr, 0 >= 0)
-none(arr, 0 >= b)
-none(arr, 0.5 < b)
-none(arr, 0.5 == b)
-none(arr, 0.5 >= 0)
-none(arr, 1 != a)
-none(arr, 1 <= b)
-none(arr, 1 in arr)
-none(arr, 2 <= a)
-none(arr, a != 0)
-none(arr, a != 2)
-none(arr, a != a)
-none(arr, a != nil)
-none(arr, a < 0)
-none(arr, a < f)
-none(arr, a <= 0.5)
-none(arr, a == nil)
-none(arr, a in arr)
-none(arr, add != add)
-none(arr, add == nil)
-none(arr, all(arr, ok))
-none(arr, arr != arr)
-none(arr, b != get(arr, 0))
-none(arr, b < 0)
-none(arr, b < f)
-none(arr, b == a)
-none(arr, b >= a)
-none(arr, div != obj.obj)
-none(arr, div == div)
-none(arr, f != 0)
-none(arr, f != nil)
-none(arr, f == 0.5)
-none(arr, f > f)
-none(arr, false) and ok
-none(arr, nil != add)
-none(arr, nil != b)
-none(arr, nil != f)
-none(arr, nil == 0)
-none(arr, nil == arr)
-none(arr, nil == f)
-none(arr, nil == obj)
-none(arr, none(arr, false))
-none(arr, not ok)
-none(arr, obj.head(false, "b", nil))
-none(arr, obj?.head(false))
-none(arr, obj?.obj == (true and false))
-none(arr, ok ? true : b)
-none(arr, ok and false)
-none(arr, ok or ok)
-none(arr, ok || false)
-none(arr, ok)
-none(arr, ok) && obj.obj
-none(arr, ok) && obj?.obj
-none(arr, ok) == obj.b
-none(arr, ok) == obj?.obj
-none(arr, ok) == ok
-none(arr, s != "b")
-none(arr, s != "c")
-none(arr, s != s)
-none(arr, s endsWith "c")
-none(arr, s matches s)
-none(arr, s startsWith "c")
-none(arr, true) != obj.b
-none(arr, true) and obj.b
-none(arr, true) or obj.head(s, arr)
-none(b .. 0, obj.a)
-none(b .. 2, ok)
-none(false ? 0.5 : arr, s <= "b")
-none(filter(arr, ok), any(arr, ok))
-none(filter(arr, ok), ok and false)
-none(keys(obj), nil == obj)
-none(map(arr, "b"), f < b)
-none(map(arr, add), 0 == f)
-none(map(arr, add), b > a)
-none(map(arr, b), ok)
-none(map(arr, f), ok)
-none(map(arr, false), #)
-none(map(arr, false), ok)
-none(map(arr, obj), s > s)
-none(map(arr, ok), "b" <= "b")
-none(map(arr, ok), #)
-none(map(arr, s), b != nil)
-none(map(arr, s), ok && ok)
-none(map(arr, s), ok || ok)
-none(obj.head(arr), nil == s)
-none(obj.head(obj), s matches "b")
-none(obj.head(obj, true), ok)
-none(obj.head(s), !ok)
-none(obj.obj, 1 < f)
-none(obj.obj, b != a)
-none(obj.obj, b == b)
-none(obj.obj, nil != arr)
-none(obj.obj, ok and true)
-none(obj.obj, ok)
-none(obj.obj, s endsWith s)
-none(obj.obj, s matches s)
-none(obj.obj, true ? ok : "c")
-none(obj?.head("a"), 1 <= 0.5)
-none(obj?.head("b", nil), ok)
-none(obj?.head("b", true), f < f)
-none(obj?.head(obj, b, obj), ok)
-none(obj?.head(obj, nil), ok)
-none(obj?.obj, !ok)
-none(obj?.obj, 1 > b)
-none(obj?.obj, a != f)
-none(obj?.obj, a > f)
-none(obj?.obj, div != add)
-none(obj?.obj, f < 0.5)
-none(obj?.obj, f >= f)
-none(obj?.obj, ok != false)
-none(obj?.obj, ok)
-none(obj?.obj, s contains "b")
-none(obj?.obj, s startsWith s)
-none(obj?.obj, true == false)
-none(obj?.obj.obj, ok)
-none(ok ? "b" : false, ok == ok)
-not !!true
-not !(nil == 0.5)
-not !all(arr, true)
+min(min(f32))
+min(min(f32, i, i32))
+min(min(f64))
+min(min(i))
+min(min(i32))
+min(min(i64))
+min(ok ? add : 0.5)
+min(ok ? f32 : "foo")
+min(ok ? f64 : true)
+min(ok ? foo : 1)
+min(ok ? true : 1)
+min(score(1))
+min(score(i))
+min(true ? 0.5 : ok)
+min(true ? 1 : greet)
+min(true ? add : greet)
+min(true ? f32 : i)
+min(true ? foo : 0.5)
+min(true ? foo : half)
+min(true ? i : 1)
+min(true ? i32 : score)
+nil != "bar" ? i64 : 0.5 - i
+nil != 0.5 && 0.5 != f32
+nil != 1 && ok
+nil != 1 or any(list, false)
+nil != 1 || ok
+nil != f32 || ok
+nil != f64 && ok
+nil != f64 or ok
+nil != f64 || array != array
+nil != false and not true
+nil != false and ok
+nil != false || ok
+nil != foo == ok
+nil != foo || ok
+nil != foo.Bar
+nil != foo.Qux
+nil != foo.String
+nil != foo?.Bar
+nil != foo?.Qux
+nil != foo?.String
+nil != greet ? half : half
+nil != greet or f32 < i
+nil != i32 or f32 >= 1
+nil != i64 or i >= 1
+nil != ok == not true
+nil != true == ok
+nil == 1 != nil ? "bar" : i32
+nil == add == ("bar" not endsWith "foo")
+nil == f32 && i64 < f64
+nil == foo.Bar
+nil == foo.Qux
+nil == foo.String
+nil == foo.String()
+nil == foo?.Bar
+nil == foo?.Qux
+nil == foo?.String
+nil == foo?.String()
+nil == i64 ? add : add
+nil == nil == ok
+nil == true ? i64 ^ f32 : foo
+nil == true || ok
+nil in array || ok
+nil in array[i32:i64]
+nil in list and ok
+none(array, !ok)
+none(array, !true)
+none(array, "bar" == "bar")
+none(array, # != #)
+none(array, # != 1)
+none(array, # != f32)
+none(array, # != f64)
+none(array, # != i32)
+none(array, # != i64)
+none(array, # < #)
+none(array, # < 0.5)
+none(array, # < 1)
+none(array, # < f32)
+none(array, # < i)
+none(array, # < i32)
+none(array, # < i64)
+none(array, # <= #)
+none(array, # <= 0.5)
+none(array, # <= 1)
+none(array, # <= f32)
+none(array, # <= i)
+none(array, # <= i32)
+none(array, # == #)
+none(array, # == 0.5)
+none(array, # == 1)
+none(array, # == i)
+none(array, # == nil)
+none(array, # > #)
+none(array, # > 0.5)
+none(array, # > f32)
+none(array, # > f64)
+none(array, # > i)
+none(array, # > i32)
+none(array, # >= #)
+none(array, # >= 0.5)
+none(array, # >= 1)
+none(array, # >= f32)
+none(array, # >= f64)
+none(array, # in array)
+none(array, # not in array)
+none(array, 0.5 != #)
+none(array, 0.5 != f32)
+none(array, 0.5 < #)
+none(array, 0.5 <= 0.5)
+none(array, 0.5 <= 1)
+none(array, 0.5 <= i)
+none(array, 0.5 > #)
+none(array, 0.5 >= #)
+none(array, 1 != #)
+none(array, 1 < #)
+none(array, 1 < 0.5)
+none(array, 1 < i)
+none(array, 1 < i64)
+none(array, 1 <= 1)
+none(array, 1 == #)
+none(array, 1 == f64)
+none(array, 1 > #)
+none(array, 1 > f64)
+none(array, 1 >= i)
+none(array, add != greet)
+none(array, all(array, true))
+none(array, div == greet)
+none(array, f32 != #)
+none(array, f32 != nil)
+none(array, f32 <= #)
+none(array, f32 >= #)
+none(array, f64 != #)
+none(array, f64 == #)
+none(array, f64 >= 0.5)
+none(array, half != nil)
+none(array, i < #)
+none(array, i < 1)
+none(array, i <= #)
+none(array, i == i64)
+none(array, i not in array)
+none(array, i32 != #)
+none(array, i32 != f64)
+none(array, i32 != nil)
+none(array, i32 < #)
+none(array, i32 > #)
+none(array, i32 >= #)
+none(array, i64 < #)
+none(array, i64 < f64)
+none(array, i64 >= #)
+none(array, nil != 0.5)
+none(array, nil != div)
+none(array, nil == #)
+none(array, nil == 1)
+none(array, nil == div)
+none(array, none(array, !true))
+none(array, not ok)
+none(array, ok == nil)
+none(array, ok)
+none(array, ok) != ok
+none(array, ok) ? f32 : !ok
+none(array, score == nil)
+none(array, score == score)
+none(array, true ? ok : f64)
+none(array, true or true)
+none(i64 .. i32, # > #)
+none(list, "bar" not in #)
+none(list, # != #)
+none(list, # != foo)
+none(list, # != nil)
+none(list, # == #)
+none(list, # == nil)
+none(list, 0.5 != i)
+none(list, 0.5 <= 1)
+none(list, 0.5 <= f64)
+none(list, 0.5 == nil)
+none(list, 1 < i32)
+none(list, 1 == f32)
+none(list, any(list, ok))
+none(list, array == nil)
+none(list, f32 > i)
+none(list, f64 == i32)
+none(list, false && false)
+none(list, false) or f64 >= i64
+none(list, foo != #)
+none(list, foo == #)
+none(list, greet != add)
+none(list, greet != half)
+none(list, i <= i64)
+none(list, i >= 1)
+none(list, i >= f64)
+none(list, i not in array)
+none(list, i32 != nil)
+none(list, i32 == f64)
+none(list, i32 == nil)
+none(list, i32 >= 1)
+none(list, i32 >= f32)
+none(list, i64 < f64)
+none(list, i64 <= f64)
+none(list, i64 > f64)
+none(list, i64 > i64)
+none(list, nil != array)
+none(list, nil != true)
+none(list, nil == foo)
+none(list, not false)
+none(list, not ok)
+none(list, ok)
+none(list, one(array, false))
+none(list, score != nil)
+none(list, score == add)
+none(list, true && ok)
+none(list, true == ok)
+none(list, true) ? div : array
+none(map(array, "bar"), # not endsWith #)
+none(map(array, "foo"), # not endsWith #)
+none(map(array, #), ok)
+none(map(array, 0.5), # == #)
+none(map(array, 1), # >= #)
+none(map(array, half), # == #)
+none(map(array, ok), #)
+none(map(list, "bar"), # not startsWith #)
+none(map(list, "bar"), # startsWith #)
+none(map(list, #), # != #)
+none(map(list, #), ok)
+none(map(list, i32), f64 > #)
+none(map(list, true), # != #)
+none(ok ? "bar" : ok, # >= f64)
+not !("foo" not matches "foo")
+not !(0.5 > 1)
+not !(f64 >= i32)
+not !(false && ok)
+not !(i >= i32)
 not !false
 not !ok
 not !true
-not ("a" != "b")
-not ("a" != nil)
-not ("a" <= "c")
-not ("a" <= s)
-not ("a" == "a")
-not ("a" == "c")
-not ("a" == nil)
-not ("a" > s)
-not ("a" >= s)
-not ("a" contains "a")
-not ("a" contains "b")
-not ("a" contains s)
-not ("a" endsWith "b")
-not ("a" endsWith s)
-not ("a" in obj)
-not ("a" matches "c")
-not ("a" startsWith "a")
-not ("a" startsWith "b")
-not ("b" != "a")
-not ("b" != nil)
-not ("b" <= "a")
-not ("b" <= "c")
-not ("b" <= s)
-not ("b" == "a")
-not ("b" == "c")
-not ("b" == nil)
-not ("b" == s)
-not ("b" > s)
-not ("b" >= s)
-not ("b" contains "a")
-not ("b" contains "b")
-not ("b" contains s)
-not ("b" endsWith "a")
-not ("b" endsWith "b")
-not ("b" endsWith s)
-not ("b" in obj)
-not ("b" matches "b")
-not ("b" startsWith "b")
-not ("b" startsWith s)
-not ("c" != "a")
-not ("c" != s)
-not ("c" <= "c")
-not ("c" == "a")
-not ("c" > "b")
-not ("c" >= "a")
-not ("c" >= s)
-not ("c" contains "a")
-not ("c" contains "c")
-not ("c" contains s)
-not ("c" endsWith s)
-not ("c" in obj)
-not ("c" matches "a")
-not ("c" matches "b")
-not ("c" matches s)
-not ("c" startsWith s)
-not (-0.5 < a)
-not (0 != 0)
-not (0 != 2)
-not (0 != a)
-not (0 != b)
-not (0 != f)
-not (0 != nil)
-not (0 < 0.5)
-not (0 < 2)
-not (0 < a)
-not (0 < b)
-not (0 < f)
-not (0 <= 0)
-not (0 <= 0.5)
-not (0 <= 1)
-not (0 <= a)
-not (0 <= b)
-not (0 <= f)
-not (0 == 0.5)
-not (0 == 1)
-not (0 == 2)
-not (0 == a)
-not (0 == f)
-not (0 == nil)
-not (0 > 0)
-not (0 > 0.5)
-not (0 > 2)
-not (0 > a)
-not (0 > b)
-not (0 > f)
-not (0 >= 0)
-not (0 >= 0.5)
-not (0 >= 1)
-not (0 >= 2)
-not (0 >= a)
-not (0 >= b)
-not (0 >= f)
-not (0 in arr)
-not (0.5 != 0)
+not ("bar" != "foo")
+not ("bar" != nil)
+not ("bar" < "foo")
+not ("bar" <= "bar")
+not ("bar" <= "foo")
+not ("bar" == "bar")
+not ("bar" == "foo")
+not ("bar" == nil)
+not ("bar" > "bar")
+not ("bar" > "foo")
+not ("bar" >= "bar")
+not ("bar" >= "foo")
+not ("bar" contains "bar")
+not ("bar" contains "foo")
+not ("bar" endsWith "bar")
+not ("bar" endsWith "foo")
+not ("bar" in foo)
+not ("bar" matches "bar")
+not ("bar" not contains "bar")
+not ("bar" not contains "foo")
+not ("bar" not endsWith "bar")
+not ("bar" not endsWith "foo")
+not ("bar" not in foo)
+not ("bar" not matches "bar")
+not ("bar" not matches "foo")
+not ("bar" startsWith "bar")
+not ("bar" startsWith "foo")
+not ("foo" != "bar")
+not ("foo" != "foo")
+not ("foo" != nil)
+not ("foo" < "bar")
+not ("foo" < "foo")
+not ("foo" <= "bar")
+not ("foo" <= "foo")
+not ("foo" == "bar")
+not ("foo" == "foo")
+not ("foo" == nil)
+not ("foo" > "bar")
+not ("foo" > "foo")
+not ("foo" >= "foo")
+not ("foo" contains "foo")
+not ("foo" endsWith "bar")
+not ("foo" endsWith "foo")
+not ("foo" in foo)
+not ("foo" matches "bar")
+not ("foo" matches "foo")
+not ("foo" not contains "bar")
+not ("foo" not contains "foo")
+not ("foo" not endsWith "bar")
+not ("foo" not endsWith "foo")
+not ("foo" not in foo)
+not ("foo" not matches "bar")
+not ("foo" not matches "foo")
+not ("foo" not startsWith "bar")
+not ("foo" not startsWith "foo")
+not ("foo" startsWith "foo")
 not (0.5 != 0.5)
-not (0.5 != a)
-not (0.5 != b)
-not (0.5 != f)
+not (0.5 != 1)
+not (0.5 != f64)
+not (0.5 != i)
+not (0.5 != i32)
+not (0.5 != i64)
 not (0.5 != nil)
 not (0.5 < 0.5)
-not (0.5 < a)
-not (0.5 < b)
-not (0.5 < f)
-not (0.5 <= 0)
-not (0.5 <= a)
-not (0.5 <= b)
-not (0.5 == 0)
+not (0.5 < 1)
+not (0.5 < f32)
+not (0.5 < f64)
+not (0.5 < i)
+not (0.5 < i32)
+not (0.5 < i64)
+not (0.5 <= 0.5)
+not (0.5 <= 1)
+not (0.5 <= f32)
+not (0.5 <= f64)
+not (0.5 <= i)
+not (0.5 <= i32)
+not (0.5 <= i64)
 not (0.5 == 0.5)
-not (0.5 == 2)
-not (0.5 == a)
-not (0.5 == b)
-not (0.5 == f)
+not (0.5 == 1)
+not (0.5 == f32)
+not (0.5 == f64)
+not (0.5 == i)
+not (0.5 == i32)
+not (0.5 == i64)
 not (0.5 == nil)
-not (0.5 > 0)
+not (0.5 > 0.5)
 not (0.5 > 1)
-not (0.5 > a)
-not (0.5 > b)
-not (0.5 > f)
-not (0.5 >= 0)
+not (0.5 > f32)
+not (0.5 > f64)
+not (0.5 > i)
+not (0.5 > i32)
+not (0.5 > i64)
 not (0.5 >= 0.5)
-not (0.5 >= a)
-not (0.5 >= b)
-not (0.5 >= f)
-not (1 != 0)
-not (1 != b)
-not (1 != f)
+not (0.5 >= 1)
+not (0.5 >= f32)
+not (0.5 >= f64)
+not (0.5 >= i)
+not (0.5 >= i32)
+not (0.5 >= i64)
+not (1 != 0.5)
+not (1 != 1)
+not (1 != f32)
+not (1 != f64)
+not (1 != i)
+not (1 != i32)
+not (1 != i64)
 not (1 != nil)
-not (1 < 0)
-not (1 < a)
-not (1 < f)
-not (1 <= f)
+not (1 + i > 0.5 ** i32)
+not (1 < 0.5)
+not (1 < 1)
+not (1 < f32)
+not (1 < f64)
+not (1 < i)
+not (1 < i32)
+not (1 < i64)
+not (1 <= 0.5)
+not (1 <= 1)
+not (1 <= f32)
+not (1 <= f64)
+not (1 <= i)
+not (1 <= i32)
+not (1 <= i64)
 not (1 == 0.5)
-not (1 == b)
-not (1 == f)
+not (1 == 1)
+not (1 == f32)
+not (1 == f64)
+not (1 == i)
+not (1 == i64)
+not (1 == nil)
 not (1 > 0.5)
-not (1 > b)
-not (1 > f)
-not (1 >= 0)
+not (1 > 1)
+not (1 > f32)
+not (1 > f64)
+not (1 > i)
+not (1 > i32)
+not (1 > i64)
 not (1 >= 0.5)
-not (1 >= 2)
-not (1 >= a)
-not (1 >= f)
-not (1 in arr)
-not (2 != 0.5)
-not (2 != 2)
-not (2 != a)
-not (2 != f)
-not (2 != nil)
-not (2 < 0.5)
-not (2 < b)
-not (2 < f)
-not (2 <= 0.5)
-not (2 <= b)
-not (2 <= f)
-not (2 == a)
-not (2 > 0)
-not (2 > 1)
-not (2 > a)
-not (2 > b)
-not (2 > f)
-not (2 >= a)
-not (2 >= b)
-not (2 >= b) && ok
-not (2 in arr)
-not (a != 0)
-not (a != 0.5)
-not (a != 2)
-not (a != a)
-not (a != b)
-not (a != f)
-not (a < 0)
-not (a < 1)
-not (a < 2)
-not (a < a)
-not (a < b)
-not (a < f)
-not (a <= 0)
-not (a <= 0.5)
-not (a <= 1)
-not (a <= a)
-not (a <= b)
-not (a <= f)
-not (a == 0)
-not (a == 0.5)
-not (a == 1)
-not (a == 2)
-not (a == a)
-not (a == b)
-not (a == f)
-not (a == nil)
-not (a > 0)
-not (a > 1)
-not (a > a)
-not (a > b)
-not (a > f)
-not (a >= 0)
-not (a >= 0.5)
-not (a >= 1)
-not (a >= a)
-not (a >= b)
-not (a >= f)
-not (a in arr)
+not (1 >= 1)
+not (1 >= f32)
+not (1 >= f64)
+not (1 >= i)
+not (1 >= i32)
+not (1 >= i64)
+not (1 ^ f32 != i64)
+not (1 in array)
+not (1 not in array)
+not (abs(i) <= i)
 not (add != add)
 not (add != div)
+not (add != greet)
+not (add != half)
 not (add != nil)
+not (add != score)
 not (add == add)
 not (add == div)
+not (add == greet)
+not (add == half)
 not (add == nil)
-not (arr != arr)
-not (arr != nil)
-not (arr == arr)
-not (arr == nil)
-not (b != 0)
-not (b != 0.5)
-not (b != 1)
-not (b != 2)
-not (b != a)
-not (b != b)
-not (b != f)
-not (b != nil)
-not (b ** 0 >= a)
-not (b < 0)
-not (b < 0.5)
-not (b < a)
-not (b < b)
-not (b < f)
-not (b <= 0.5)
-not (b <= 1)
-not (b <= 2)
-not (b <= a)
-not (b <= b)
-not (b <= f)
-not (b == 0)
-not (b == 0.5)
-not (b == 1)
-not (b == 2)
-not (b == a)
-not (b == b)
-not (b == f)
-not (b == nil)
-not (b > 0)
-not (b > 1)
-not (b > 2)
-not (b > a)
-not (b > b)
-not (b > f)
-not (b >= 0)
-not (b >= 0.5)
-not (b >= a)
-not (b >= b)
-not (b >= f)
-not (b in arr)
+not (add == score)
+not (array != array)
+not (array != list)
+not (array != nil)
+not (array == array)
+not (array == list)
+not (array == nil)
 not (div != add)
 not (div != div)
+not (div != greet)
+not (div != half)
 not (div != nil)
+not (div != score)
 not (div == add)
 not (div == div)
+not (div == greet)
+not (div == half)
 not (div == nil)
-not (f != 0)
-not (f != 0.5)
-not (f != a)
-not (f != b)
-not (f != f)
-not (f < 0)
-not (f < 1)
-not (f < 2)
-not (f < a)
-not (f < b)
-not (f < f)
-not (f <= 1)
-not (f <= a)
-not (f <= b)
-not (f <= f)
-not (f == 0)
-not (f == 0.5)
-not (f == 1)
-not (f == 2)
-not (f == a)
-not (f == b)
-not (f == f)
-not (f == nil)
-not (f > 0)
-not (f > 0.5)
-not (f > 1)
-not (f > 2)
-not (f > a)
-not (f > b)
-not (f > f)
-not (f > obj.b)
-not (f >= 0)
-not (f >= 1)
-not (f >= 2)
-not (f >= a)
-not (f >= b)
-not (f >= f)
+not (div == score)
+not (f32 != 0.5)
+not (f32 != 1)
+not (f32 != f32)
+not (f32 != f64)
+not (f32 != i)
+not (f32 != i32)
+not (f32 != i64)
+not (f32 != nil)
+not (f32 < 0.5)
+not (f32 < 1)
+not (f32 < abs(0.5))
+not (f32 < f32)
+not (f32 < f64)
+not (f32 < i)
+not (f32 < i32)
+not (f32 < i64)
+not (f32 <= 0.5)
+not (f32 <= 1)
+not (f32 <= f32)
+not (f32 <= f64)
+not (f32 <= i)
+not (f32 <= i32)
+not (f32 <= i64)
+not (f32 == 0.5)
+not (f32 == 1)
+not (f32 == f32)
+not (f32 == f64)
+not (f32 == i32)
+not (f32 == i64)
+not (f32 == nil)
+not (f32 > 0.5)
+not (f32 > 1)
+not (f32 > f32)
+not (f32 > f64)
+not (f32 > i32)
+not (f32 >= 0.5)
+not (f32 >= 1)
+not (f32 >= f32)
+not (f32 >= f64)
+not (f32 >= i)
+not (f32 >= i64)
+not (f64 != 0.5)
+not (f64 != 1 * 0.5)
+not (f64 != 1)
+not (f64 != f32)
+not (f64 != f64)
+not (f64 != i)
+not (f64 != i32)
+not (f64 != i64)
+not (f64 != nil)
+not (f64 < 0.5)
+not (f64 < 1)
+not (f64 < f32)
+not (f64 < f64)
+not (f64 < i)
+not (f64 < i32)
+not (f64 < i64)
+not (f64 <= 0.5)
+not (f64 <= 1)
+not (f64 <= f32)
+not (f64 <= f64)
+not (f64 <= i32)
+not (f64 <= i64)
+not (f64 == 0.5)
+not (f64 == 1)
+not (f64 == f32)
+not (f64 == f64)
+not (f64 == i)
+not (f64 == i32)
+not (f64 == i64 - f32)
+not (f64 == nil)
+not (f64 > 0.5)
+not (f64 > 1)
+not (f64 > f32)
+not (f64 > f64)
+not (f64 > i)
+not (f64 > i64)
+not (f64 >= 0.5)
+not (f64 >= 1)
+not (f64 >= f32)
+not (f64 >= f64)
+not (f64 >= i)
+not (f64 >= i32)
+not (f64 >= i64)
 not (false != false)
 not (false != nil)
 not (false != ok)
+not (false != true)
 not (false && ok)
 not (false && true)
+not (false == false)
 not (false == nil)
-not (false == ok)
 not (false == true)
+not (false and false)
 not (false and true)
 not (false or false)
+not (false or ok)
+not (false or true)
 not (false || false)
 not (false || ok)
 not (false || true)
-not (nil != "b")
-not (nil != "c")
-not (nil != 0)
-not (nil != 2)
-not (nil != a)
+not (foo != foo)
+not (foo != nil)
+not (foo == foo)
+not (foo == nil)
+not (foo in list)
+not (foo not in list)
+not (greet != add)
+not (greet != div)
+not (greet != greet)
+not (greet != half)
+not (greet != nil)
+not (greet != score)
+not (greet == add)
+not (greet == div)
+not (greet == greet)
+not (greet == half)
+not (greet == nil)
+not (greet == score)
+not (half != add)
+not (half != div)
+not (half != greet)
+not (half != nil)
+not (half != score)
+not (half == add)
+not (half == div)
+not (half == greet)
+not (half == half)
+not (half == nil)
+not (half == score)
+not (i != 0.5)
+not (i != 1)
+not (i != f32)
+not (i != f64)
+not (i != i)
+not (i != i32)
+not (i != i64)
+not (i != nil)
+not (i < 0.5)
+not (i < 1)
+not (i < f32)
+not (i < f64)
+not (i < i)
+not (i < i32)
+not (i < i64)
+not (i <= 0.5)
+not (i <= 1)
+not (i <= f32)
+not (i <= f64)
+not (i <= i32)
+not (i <= i64)
+not (i == 0.5)
+not (i == 1)
+not (i == f32)
+not (i == f64)
+not (i == i)
+not (i == i32)
+not (i == nil)
+not (i > 0.5)
+not (i > 1)
+not (i > f32)
+not (i > f64)
+not (i > i)
+not (i > i64)
+not (i >= 0.5)
+not (i >= 1)
+not (i >= div(1, 1))
+not (i >= f32)
+not (i >= f64)
+not (i >= i)
+not (i >= i64)
+not (i in array)
+not (i not in array)
+not (i32 != 0.5)
+not (i32 != 1)
+not (i32 != f32)
+not (i32 != f64)
+not (i32 != i)
+not (i32 != i64)
+not (i32 != nil)
+not (i32 < 0.5)
+not (i32 < 1)
+not (i32 < f64)
+not (i32 < i)
+not (i32 < i32)
+not (i32 < i64)
+not (i32 <= 0.5)
+not (i32 <= 1)
+not (i32 <= f32)
+not (i32 <= f64)
+not (i32 <= i)
+not (i32 <= i32)
+not (i32 <= i64)
+not (i32 == 0.5)
+not (i32 == 1)
+not (i32 == f32)
+not (i32 == f64)
+not (i32 == i)
+not (i32 == i32)
+not (i32 == i64)
+not (i32 == nil)
+not (i32 > 0.5)
+not (i32 > 1)
+not (i32 > f32)
+not (i32 > f64)
+not (i32 > i)
+not (i32 > i32)
+not (i32 > i64)
+not (i32 >= 0.5)
+not (i32 >= 1)
+not (i32 >= f32)
+not (i32 >= f64)
+not (i32 >= i)
+not (i32 >= i32)
+not (i32 >= i64)
+not (i32 in array)
+not (i64 != 0.5)
+not (i64 != 1)
+not (i64 != f32)
+not (i64 != f64)
+not (i64 != i)
+not (i64 != i32)
+not (i64 != i64)
+not (i64 != nil)
+not (i64 < 0.5)
+not (i64 < 1)
+not (i64 < f32)
+not (i64 < f64)
+not (i64 < i)
+not (i64 < i32)
+not (i64 < i64)
+not (i64 < int(f64))
+not (i64 <= 0.5)
+not (i64 <= 1)
+not (i64 <= f32)
+not (i64 <= f64)
+not (i64 <= i)
+not (i64 <= i64)
+not (i64 == 0.5)
+not (i64 == 1)
+not (i64 == f32)
+not (i64 == f64)
+not (i64 == i)
+not (i64 == i32)
+not (i64 == i64)
+not (i64 == nil)
+not (i64 > 0.5)
+not (i64 > 1)
+not (i64 > f64)
+not (i64 > i)
+not (i64 > i32)
+not (i64 > i64)
+not (i64 >= 0.5)
+not (i64 >= 1)
+not (i64 >= f32)
+not (i64 >= f64)
+not (i64 >= i)
+not (i64 >= i32)
+not (i64 >= max(i))
+not (i64 in array)
+not (i64 not in array)
+not (list != array)
+not (list != list)
+not (list != nil)
+not (list == array)
+not (list == list)
+not (list == nil)
+not (nil != "bar")
+not (nil != "foo")
+not (nil != 0.5)
+not (nil != 1)
 not (nil != add)
-not (nil != arr)
-not (nil != b)
+not (nil != array)
 not (nil != div)
-not (nil != f)
+not (nil != f32)
+not (nil != f64)
+not (nil != false)
+not (nil != foo)
+not (nil != greet)
+not (nil != half)
+not (nil != i)
+not (nil != i32)
+not (nil != i64)
+not (nil != list)
 not (nil != nil)
-not (nil != obj)
 not (nil != ok)
-not (nil != s)
+not (nil != score)
 not (nil != true)
-not (nil == "b")
-not (nil == 0)
+not (nil == "bar")
+not (nil == "foo")
 not (nil == 0.5)
-not (nil == a)
+not (nil == 1)
 not (nil == add)
-not (nil == arr)
-not (nil == b)
+not (nil == array)
 not (nil == div)
-not (nil == f)
+not (nil == f32)
+not (nil == f64)
 not (nil == false)
+not (nil == foo)
+not (nil == greet)
+not (nil == half)
+not (nil == i)
+not (nil == i32)
+not (nil == i64)
+not (nil == list)
 not (nil == nil)
-not (nil == obj)
 not (nil == ok)
-not (nil == s)
+not (nil == score)
 not (nil == true)
-not (nil in arr)
-not (nil in obj)
-not (obj != nil)
-not (obj != obj)
-not (obj == nil)
-not (obj == obj)
-not (obj.b != a ** a)
-not (obj.b == ok)
-not (obj.head(a) ** f <= f)
-not (obj.head(b, div) == s)
-not (obj.obj == f)
-not (obj?.a != f ** 1)
-not (obj?.b < b)
-not (obj?.b == ok)
+not (nil in array)
+not (nil in list)
+not (nil not in array)
+not (nil not in list)
 not (ok != false)
 not (ok != nil)
 not (ok != ok)
@@ -11205,9137 +11793,4584 @@ not (ok && ok)
 not (ok && true)
 not (ok == false)
 not (ok == nil)
+not (ok == ok)
 not (ok == true)
 not (ok and false)
 not (ok and ok)
 not (ok and true)
 not (ok or false)
 not (ok or ok)
-not (ok || obj.b)
+not (ok or true)
 not (ok || ok)
 not (ok || true)
-not (s != "a")
-not (s != "b")
-not (s != "c")
-not (s != nil)
-not (s != s)
-not (s < "a")
-not (s < "b")
-not (s < "c")
-not (s < s)
-not (s <= "a")
-not (s <= "b")
-not (s <= "c")
-not (s <= s)
-not (s == "a")
-not (s == "b")
-not (s == "c")
-not (s == nil)
-not (s == s)
-not (s > "c")
-not (s > s)
-not (s >= "a")
-not (s >= "b")
-not (s >= "c")
-not (s >= s)
-not (s contains "c")
-not (s contains s)
-not (s endsWith "a")
-not (s endsWith "b")
-not (s endsWith lower("b"))
-not (s endsWith s)
-not (s in obj)
-not (s matches "a")
-not (s matches "c")
-not (s matches s)
-not (s startsWith "a")
-not (s startsWith "b")
-not (s startsWith s)
+not (score != add)
+not (score != div)
+not (score != greet)
+not (score != half)
+not (score != nil)
+not (score != score)
+not (score == add)
+not (score == div)
+not (score == greet)
+not (score == half)
+not (score == nil)
+not (score == score)
 not (true != false)
 not (true != nil)
 not (true != ok)
 not (true != true)
-not (true && false)
+not (true && ok)
 not (true && true)
 not (true == nil)
 not (true == ok)
 not (true == true)
 not (true and false)
 not (true and ok)
+not (true and true)
 not (true or false)
 not (true or ok)
-not (true or true)
-not (true || ok)
-not (true || true)
-not all(arr, false)
-not all(arr, ok)
-not all(arr, true)
-not any(arr, false)
-not any(arr, ok)
-not any(arr, true)
-not false ? "a" : obj
-not false ? "c" : 0.5
-not false ? 0 : obj.obj
-not false ? 0.5 : 0.5
-not false ? 0.5 : a
-not false ? 2 : 1
-not false ? a : div
-not false ? a : s
-not false ? add : 2
-not false ? add : obj
-not false ? arr : arr
-not false ? b : div
-not false ? b : ok
-not false ? b : s
-not false ? div : nil
-not false ? div : ok
-not false ? f : "a"
-not false ? f : 0
-not false ? f : 1
-not false ? false : s
-not false ? nil : "b"
-not false ? nil : f
-not false ? obj : "c"
-not false ? obj : add
-not false ? ok : nil
-not false ? ok : ok
-not false ? s : 0
-not false ? s : add
-not false ? s : b
-not false ? s : obj
-not false ? s : true
-not false ? true : false
-not false and obj.head(add)
-not false and obj?.obj.obj
-not false or b == nil
-not false or obj?.fn(false)
-not false or obj?.head(arr, obj)?.b
-not false or obj?.obj
-not false || a <= b
-not hasPrefix(s, "c")
-not hasSuffix("a", "a")
-not hasSuffix(s, "a")
-not none(arr, false)
-not none(arr, ok)
-not none(arr, true)
-not not (f > f)
-not not (nil == div)
+not (true || false)
+not all(array, ok)
+not all(array, true)
+not all(list, false)
+not all(list, ok)
+not all(list, true)
+not any(array, false)
+not any(array, ok)
+not any(array, true)
+not any(list, # != #)
+not any(list, false)
+not any(list, ok)
+not any(list, true)
+not false && ok
+not false && ok ? list : array
+not false ? "bar" : 0.5
+not false ? "bar" : foo
+not false ? "foo" : 0.5
+not false ? 0.5 : greet
+not false ? 1 : div
+not false ? 1 : i32
+not false ? add : i
+not false ? array : "foo"
+not false ? array : array
+not false ? array : greet
+not false ? array : ok
+not false ? div : greet
+not false ? foo : 1
+not false ? foo : array
+not false ? greet : ok
+not false ? half : 0.5
+not false ? half : i32
+not false ? i : i64
+not false ? i : score
+not false ? i32 : 0.5
+not false ? i32 : add
+not false ? i32 : f32
+not false ? i32 : true
+not false ? i64 : list
+not false ? list : i32
+not false ? nil : greet
+not false ? nil : i32
+not false ? nil : nil
+not false ? ok : "bar"
+not false ? ok : 1
+not false ? ok : list
+not false ? score : "foo"
+not false ? score : array
+not false ? score : score
+not false ? score : true
+not false ? true : 0.5
+not false ? true : 1
+not false ? true : nil
+not false or "foo" > "bar"
+not none(array, # == #)
+not none(array, false)
+not none(array, ok)
+not none(array, true)
+not none(list, false)
+not none(list, ok)
+not none(list, true)
+not not ("bar" >= "foo")
+not not (1 < i)
+not not (add == nil)
+not not (half == nil)
 not not false
-not not obj.head(ok, ok)
 not not ok
 not not true
-not obj.head(f != true)
-not obj.head(false)
-not obj.head(false, add)
-not obj.head(false, div)
-not obj.head(obj, arr, b, nil).head(f <= 0)
-not obj.head(ok)
-not obj.head(ok, a)
-not obj.head(ok, add, a, s)
-not obj.head(ok, b, s)
-not obj.head(ok, div)
-not obj.head(true == "c")
-not obj.head(true)
-not obj?.head(0.5 <= a)
-not obj?.head(false)
-not obj?.head(false, 1)
-not obj?.head(false, b)
-not obj?.head(false, nil)
-not obj?.head(ok)
-not obj?.head(ok, "c")
-not obj?.head(ok, 0)
-not obj?.head(ok, a)
-not obj?.head(ok, div)
-not obj?.head(ok, div, a)
-not obj?.head(ok, f, true)
-not obj?.head(ok, s)
-not obj?.head(true)
 not ok
-not ok != obj.obj
-not ok != obj.obj?.obj
-not ok != ok
-not ok && obj.obj
-not ok && obj?.b
-not ok && obj?.head(b).a
-not ok && s > obj?.a
-not ok == obj?.a
-not ok == obj?.b
+not ok && ok
 not ok == ok
-not ok ? "a" : b
-not ok ? "a" : f
-not ok ? "b" : a
-not ok ? "b" : f
-not ok ? "b" : s
-not ok ? "c" : a
-not ok ? 0 : obj
-not ok ? 0 : true
-not ok ? 0.5 : false
-not ok ? 1 : b
-not ok ? 1 : f
-not ok ? 1 : true
-not ok ? 2 : div
-not ok ? 2 : true
-not ok ? a : 1
-not ok ? a : a
-not ok ? a : obj
-not ok ? a : s
-not ok ? add : 1
-not ok ? add : b
-not ok ? add : nil
-not ok ? add : s
-not ok ? arr : nil
-not ok ? arr : ok
-not ok ? arr : true
-not ok ? b : a
-not ok ? b : add
-not ok ? b : div
-not ok ? b : obj
+not ok ? "bar" : 1
+not ok ? "bar" : f32
+not ok ? 0.5 + f64 : half
+not ok ? 0.5 : "foo"
+not ok ? 0.5 : 0.5
+not ok ? 0.5 : div
+not ok ? 0.5 : f32
+not ok ? 0.5 : greet
+not ok ? 1 : 1
+not ok ? add : 0.5
+not ok ? array : f64
+not ok ? array : true
 not ok ? div : 1
-not ok ? div : a
-not ok ? div : b
-not ok ? div : obj.b
-not ok ? f : "c"
-not ok ? f : false
-not ok ? f : obj?.obj
-not ok ? f : s
-not ok ? false : "c"
-not ok ? obj : arr
-not ok ? obj : b
-not ok ? obj : div
-not ok ? ok : "c"
-not ok ? ok : 0
-not ok ? ok : a
-not ok ? ok : add
-not ok ? ok : arr
-not ok ? ok : ok
-not ok ? s : a
-not ok ? true : add
+not ok ? div : add
+not ok ? f32 : div
+not ok ? f64 : 1
+not ok ? f64 : half
+not ok ? false : f32
+not ok ? false : i
+not ok ? false : true
+not ok ? foo : add
+not ok ? foo : false
+not ok ? foo : i64
+not ok ? greet : add
+not ok ? half : true
+not ok ? i : div
+not ok ? i : true
+not ok ? i32 : nil
+not ok ? i64 : add
+not ok ? nil : 0.5
+not ok ? nil : div
+not ok ? nil : foo
+not ok ? nil : half
+not ok ? nil : i
+not ok ? score : div
+not ok ? score : i
+not ok ? score : true
+not ok ? true : f32
 not ok ? true : false
-not ok and obj?.a.obj
-not ok or obj.a
+not ok ? true : score
+not ok and not ok
 not ok or ok
-not ok || 0 <= f
-not ok || obj.head(0, nil)
-not ok || obj?.obj
+not ok or one(array, true)
 not ok || ok
-not one(arr, false)
-not one(arr, ok)
-not one(arr, true)
-not true != obj?.b
-not true ? "b" : b
-not true ? 0 : div
-not true ? 0.5 : ok
-not true ? 1 : obj
-not true ? a : a
-not true ? arr : 1
-not true ? arr : b
-not true ? b : "a"
-not true ? b : 2
-not true ? b : a
-not true ? b : div
-not true ? b : obj
+not ok || true ? 0.5 : 1
+not one(array, # > f32)
+not one(array, false)
+not one(array, ok)
+not one(array, true)
+not one(list, false)
+not one(list, ok)
+not one(list, true)
+not true && i32 <= i32
+not true ? "foo" : i
+not true ? 1 : i64
+not true ? add : add
+not true ? add : foo
+not true ? array : 1
+not true ? array : add
+not true ? array : array
+not true ? array : i32
+not true ? array : i64
 not true ? div : nil
-not true ? div : true
-not true ? f : false
-not true ? f : obj
-not true ? f : true
-not true ? nil : "c"
-not true ? nil : a
-not true ? obj : arr
-not true ? obj : f
-not true ? obj : ok
-not true ? s : ok
-not true and obj[s]
-not true and ok
-not true or obj.obj?.a
+not true ? f64 : i64
+not true ? foo : foo
+not true ? greet : "bar"
+not true ? greet : add
+not true ? greet : foo
+not true ? greet : i32
+not true ? half : half
+not true ? i : 1
+not true ? i : i
+not true ? i32 : 0.5
+not true ? i64 : 1
+not true ? list : "bar"
+not true ? list : 0.5
+not true ? list : 1
+not true ? list : array
+not true ? list : type(add)
+not true ? nil : list
+not true ? score : 1
+not true ? score : list
+not true ? score : true
 not true || ok
-obj
-obj != get(obj, s)
-obj != nil == true
-obj != nil ? f : "b"
-obj != nil and obj?.fn(a)
-obj != nil and s <= "a"
-obj != nil || b <= obj.fn(fromJSON(a), trimSuffix(div(true), true % s, a startsWith obj, f ^ add), f)
-obj != obj
-obj != obj != ok
-obj != obj && obj?.head(0, true)
-obj != obj == ok
-obj != obj ? 0 : obj
-obj != obj ? 1 : 0.5
-obj != obj or obj.obj
-obj != obj || obj?.obj
-obj != obj.a
-obj != obj.b
-obj != obj.c
-obj != obj.fn(a)
-obj != obj.fn(b)
-obj != obj.head(b, f)
-obj != obj.head(f, s, s, ok)
-obj != obj.head(false)
-obj != obj.head(nil or false)
-obj != obj.head(ok)
-obj != obj.obj
-obj != obj.obj.b
-obj != obj.obj?.b
-obj != obj.obj?.obj
-obj != obj?.a
-obj != obj?.b
-obj != obj?.fn(b)
-obj != obj?.head(0, b)
-obj != obj?.head(a, 0)
-obj != obj?.head(obj)
-obj != obj?.obj
-obj != obj?.obj.b
-obj != obj?.obj.obj
-obj != obj?.obj?.b
-obj != obj?.obj?.obj
-obj != obj[s]
-obj != {"a": 2, "b": b}
-obj == nil && obj?.fn(nil)
-obj == nil == true ? 0.5 : obj
-obj == nil ? add : add
-obj == nil ? arr : arr
-obj == nil ? b : 1
-obj == nil ? obj : "c"
-obj == obj
-obj == obj != any(arr, true)
-obj == obj != ok
-obj == obj && ok
-obj == obj ? false : f
-obj == obj ? ok : s
-obj == obj or obj?.head(f, false, obj)
-obj == obj.a
-obj == obj.b
-obj == obj.head(0.5)
-obj == obj.head(2 == s)
-obj == obj.head(a)
-obj == obj.head(b)
-obj == obj.head(false)
-obj == obj.head(int(arr, ok, b, a), 2 * b)
-obj == obj.head(obj, s)
-obj == obj.head(s == div)
-obj == obj.obj
-obj == obj.obj.b
-obj == obj?.a
-obj == obj?.b
-obj == obj?.fn(0 + b)
-obj == obj?.fn(2)
-obj == obj?.head(0, f)
-obj == obj?.head(a)
-obj == obj?.head(add, "c", add, "a")
-obj == obj?.head(add, ok)
-obj == obj?.head(filter(arr, ok))
-obj == obj?.head(nil)
-obj == obj?.head(obj, 0)
-obj == obj?.obj
-obj == obj?.obj.a
-obj == obj?.obj?.a
-obj == obj?.obj?.b
-obj == obj[nil]
-obj in [0.5, a, true, obj]
-obj in [arr]
-obj in obj?.head(arr)
-obj in obj[s]
-obj.a
-obj.a != "c" ? obj : a
-obj.a != 0.5 - b
-obj.a != a
-obj.a != a * 0.5
-obj.a != add
-obj.a != add ? false : ok
-obj.a != arr
-obj.a != b
-obj.a != b / a && ok
-obj.a != div
-obj.a != div != false
-obj.a != div ? s : a
-obj.a != div or ok
-obj.a != f
-obj.a != last(arr)
-obj.a != obj
-obj.a != obj ? f : ok
-obj.a != obj.a
-obj.a != obj.head(add, obj)
-obj.a != obj.obj.obj
-obj.a != obj?.b
-obj.a != obj?.obj.a
-obj.a != ok
-obj.a != ok ? ok : 0.5
-obj.a != s
-obj.a != string(nil)
-obj.a != string(ok)
-obj.a != toJSON(0.5)
-obj.a % a
-obj.a % b
-obj.a % int(b)
-obj.a % obj.a
-obj.a % obj?.b
-obj.a * (0.5 + 0)
-obj.a * -a
-obj.a * 0 ^ f
-obj.a * a
-obj.a * b
-obj.a * count(arr, ok)
-obj.a * div(0, b)
-obj.a * f
-obj.a * len(arr)
-obj.a * obj.b
-obj.a * obj?.b
-obj.a ** (a % 2)
-obj.a ** (a + a)
-obj.a ** (b - f)
-obj.a ** 0 ** a
-obj.a ** 0.5 ^ 0.5
-obj.a ** a
-obj.a ** b
-obj.a ** div(a, 1)
-obj.a ** f
-obj.a + -b
-obj.a + a
-obj.a + b
-obj.a + f
-obj.a + int(b)
-obj.a + max(b, 2)
-obj.a + obj.a
-obj.a + obj.b
-obj.a + obj.head(a, true, nil)
-obj.a + obj?.a
-obj.a + obj?.b
-obj.a + obj?.fn(0)
-obj.a - 0 + f
-obj.a - a
-obj.a - a - 0.5
-obj.a - b
-obj.a - f
-obj.a - obj.a
-obj.a - obj.b
-obj.a - obj.head(obj).a
-obj.a - obj?.b
-obj.a .. a
-obj.a .. add(a, a)
-obj.a .. b
-obj.a .. div(0, a)
-obj.a .. max(a)
-obj.a / -f
-obj.a / 0 ^ b
-obj.a / a
-obj.a / b
-obj.a / f
-obj.a / f * b
-obj.a / obj.head(a, nil)
-obj.a / obj?.b
-obj.a < -2
-obj.a < 0 ? f : a
-obj.a < a
-obj.a < b
-obj.a < b ^ f
-obj.a < f
-obj.a < obj.b
-obj.a <= 0.5 / b
-obj.a <= 1 / a
-obj.a <= a
-obj.a <= a + f
-obj.a <= a ? 0 : nil
-obj.a <= a ? 2 : 0.5
-obj.a <= b
-obj.a <= b ** f
-obj.a <= count(arr, ok)
-obj.a <= f
-obj.a <= f ** a
-obj.a <= obj.a
-obj.a == (true && ok)
-obj.a == 2 / b
-obj.a == a
-obj.a == a * a
-obj.a == abs(0.5)
-obj.a == add
-obj.a == arr
-obj.a == arr != true
-obj.a == arr[0]
-obj.a == b
-obj.a == div
-obj.a == div == obj?.b
-obj.a == f
-obj.a == false ? div : add
-obj.a == filter(arr, ok)
-obj.a == map(arr, true)
-obj.a == not false
-obj.a == obj
-obj.a == obj ? 0 : a
-obj.a == obj ? arr : 0.5
-obj.a == obj.a
-obj.a == obj.b
-obj.a == obj.obj
-obj.a == obj?.b
-obj.a == obj?.obj
-obj.a == ok
-obj.a == s
-obj.a == string(false)
-obj.a > a
-obj.a > a ** f
-obj.a > a ? div : s
-obj.a > add(a, a)
-obj.a > add(b, 0)
-obj.a > b
-obj.a > f
-obj.a > f ? f : 0
-obj.a > max(f)
-obj.a > obj?.a
-obj.a > obj?.b
-obj.a >= 0 - 0
-obj.a >= a
-obj.a >= abs(0)
-obj.a >= add(b, 1)
-obj.a >= b
-obj.a >= f
-obj.a >= f ^ 0.5
-obj.a >= obj.a
-obj.a >= obj.b
-obj.a >= obj?.b
-obj.a ^ (a % a)
-obj.a ^ a
-obj.a ^ b
-obj.a ^ f
-obj.a ^ len(arr)
-obj.a ^ obj.a
-obj.a ^ obj.b
-obj.a ^ obj.fn(a)
-obj.a ^ obj?.a
-obj.a and !true
-obj.a in arr
-obj.a or not false
-obj.a or true || obj?.a
-obj.b
-obj.b != "c" ? s : ok
-obj.b != 0 / a
-obj.b != 1 / a
-obj.b != a
-obj.b != a ** f
-obj.b != add
-obj.b != arr
-obj.b != arr[1]
-obj.b != b
-obj.b != div
-obj.b != f
-obj.b != f - 0.5
-obj.b != f ? ok : add
-obj.b != int(f)
-obj.b != nil ? f : obj.b
-obj.b != obj
-obj.b != obj.a
-obj.b != obj.b
-obj.b != obj?.a
-obj.b != obj?.head(b, obj)
-obj.b != obj?.obj
-obj.b != ok
-obj.b != ok ? 0 : b
-obj.b != s
-obj.b != s ? nil : arr
-obj.b != trimSuffix("b")
-obj.b % 2 * f
-obj.b % a
-obj.b % abs(a)
-obj.b % b
-obj.b % len(arr)
-obj.b % len(obj)
-obj.b % obj.a
-obj.b % obj?.a
-obj.b && false ? 0.5 : f
-obj.b * (0.5 - b)
-obj.b * (a + 0.5)
-obj.b * 0.5 / a
-obj.b * a
-obj.b * add(0, a)
-obj.b * b
-obj.b * div(b, b)
-obj.b * f
-obj.b * f / f
-obj.b * get(arr, a)
-obj.b * obj.a
-obj.b * obj.b
-obj.b * obj.head(2, add, false, arr)
-obj.b ** a
-obj.b ** add(1, 2)
-obj.b ** add(b, a) != f
-obj.b ** b
-obj.b ** f
-obj.b ** f ^ 1
-obj.b ** obj.a
-obj.b ** obj.b
-obj.b ** obj?.b
-obj.b ** obj?.head(f, obj, 0.5, arr, ok)
-obj.b + -b
-obj.b + 0 / 2
-obj.b + a
-obj.b + a % 2
-obj.b + b
-obj.b + f
-obj.b + f / 2
-obj.b + len(s)
-obj.b + obj.b
-obj.b + obj?.a
-obj.b + obj?.b
-obj.b - 0 * f
-obj.b - 0 ^ a
-obj.b - a
-obj.b - b
-obj.b - div(a, a)
-obj.b - f
-obj.b - obj.b
-obj.b - obj?.a
-obj.b - obj?.b
-obj.b .. 0 - b
-obj.b .. 2 - a
-obj.b .. a
-obj.b .. b
-obj.b .. b * 0
-obj.b .. b - 0
-obj.b .. obj.a
-obj.b .. obj.b
-obj.b .. obj?.head(f, ok, obj, add, 0.5)
-obj.b / (0.5 + a)
-obj.b / -f
-obj.b / 0.5 ** a
-obj.b / 0.5 / a
-obj.b / a
-obj.b / b
-obj.b / f
-obj.b / obj?.a
-obj.b / obj?.head(a, div)
-obj.b < 0 - b
-obj.b < 1 / a
-obj.b < 2 * 0
-obj.b < 2 + b
-obj.b < a
-obj.b < b
-obj.b < f
-obj.b < get(obj, "b")
-obj.b < len("c")
-obj.b < min(f)
-obj.b < obj.a
-obj.b < obj.b
-obj.b <= 0.5 == nil
-obj.b <= 2 ? "a" : a
-obj.b <= a
-obj.b <= a * f
-obj.b <= a - f
-obj.b <= a ? a : 0
-obj.b <= arr[a]
-obj.b <= b
-obj.b <= f
-obj.b <= f != ok
-obj.b <= get(arr, a)
-obj.b <= min(b)
-obj.b <= obj.a
-obj.b <= obj.fn(0)
-obj.b <= obj?.a
-obj.b <= obj?.b
-obj.b <= obj?.head(b, 0)
-obj.b == !false
-obj.b == "c" ? a : nil
-obj.b == (ok && true)
-obj.b == (ok and true)
-obj.b == 0.5 ? arr : "c"
-obj.b == a
-obj.b == a .. a
-obj.b == a ? false : false
-obj.b == a ^ a
-obj.b == add
-obj.b == arr
-obj.b == b
-obj.b == b / 0
-obj.b == div
-obj.b == f
-obj.b == f ? 1 : "c"
-obj.b == f ? nil : b
-obj.b == f ? obj : ok
-obj.b == f ? s : arr
-obj.b == int(0.5)
-obj.b == map(arr, 0)
-obj.b == obj
-obj.b == obj.a
-obj.b == obj.b
-obj.b == obj.head(nil)
-obj.b == obj.obj
-obj.b == obj?.a
-obj.b == obj?.b
-obj.b == ok
-obj.b == s
-obj.b == toBase64(s)
-obj.b > -a
-obj.b > 0 ? b : f
-obj.b > a
-obj.b > a ** a
-obj.b > b
-obj.b > b + 0
-obj.b > f
-obj.b > int(1)
-obj.b > obj.a
-obj.b > obj.b
-obj.b > obj?.b
-obj.b > obj?.fn(0)
-obj.b >= 0 ** 1
-obj.b >= 0.5 / f
-obj.b >= 0.5 ^ 1
-obj.b >= 1 ? 2 : obj
-obj.b >= a
-obj.b >= a ? ok : b
-obj.b >= b
-obj.b >= b + b
-obj.b >= f
-obj.b >= max(b)
-obj.b >= obj.a
-obj.b >= obj.fn(b)
-obj.b >= obj?.a
-obj.b >= obj?.head(b)
-obj.b ^ a
-obj.b ^ b
-obj.b ^ f
-obj.b ^ obj.head(a, true, arr, s)
-obj.b ^ obj.obj.b
-obj.b ^ obj?.b
-obj.b and !false
-obj.b and !true
-obj.b and false == true
-obj.b in arr
-obj.b or false and true
-obj.c in obj
-obj.c?.a
-obj.c?.b
-obj.c?.b.b
-obj.c?.b?.b
-obj.c?.fn(b)
-obj.c?.head("a" != arr)
-obj.c?.head(a)
-obj.c?.head(b)
-obj.c?.obj
-obj.c?.obj?.head(div)
-obj.fn(-0)
-obj.fn(-1)
-obj.fn(-2)
-obj.fn(-a)
-obj.fn(-b)
-obj.fn(0 && true)
-obj.fn(0 * a)
-obj.fn(0 + 0)
-obj.fn(0 + b)
-obj.fn(0 - 0)
-obj.fn(0 and true)
-obj.fn(0 || false)
-obj.fn(0) != b
-obj.fn(0) * a
-obj.fn(0) ** f
-obj.fn(0) + f
-obj.fn(0) - b
-obj.fn(0) / a
-obj.fn(0) / b
-obj.fn(0) <= b + 0
-obj.fn(0) == a
-obj.fn(0) == b
-obj.fn(0) == s
-obj.fn(0) >= a
-obj.fn(0) ^ f
-obj.fn(1 % b)
-obj.fn(1 * b)
-obj.fn(1 + b)
-obj.fn(1 and true)
-obj.fn(1) ** obj?.b
-obj.fn(1) + b
-obj.fn(1) == add
-obj.fn(2 % 1)
-obj.fn(2 * 1)
-obj.fn(2 * a)
-obj.fn(2 + b)
-obj.fn(2) != add
-obj.fn(2) < f
-obj.fn(a % a)
-obj.fn(a * 0)
-obj.fn(a + 1)
-obj.fn(a + 2)
-obj.fn(a + a)
-obj.fn(a - 1)
-obj.fn(a - 2)
-obj.fn(a and true)
-obj.fn(a or false)
-obj.fn(a)
-obj.fn(a) != 2 - b
-obj.fn(a) != b
-obj.fn(a) != f
-obj.fn(a) != ok
-obj.fn(a) % a
-obj.fn(a) % b
-obj.fn(a) * a
-obj.fn(a) ** a
-obj.fn(a) ** b
-obj.fn(a) - a
-obj.fn(a) < a
-obj.fn(a) == add
-obj.fn(a) == arr
-obj.fn(a) == map(arr, arr)
-obj.fn(a) > b
-obj.fn(a) >= b
-obj.fn(a) ^ f
-obj.fn(a) and !true
-obj.fn(abs(1))
-obj.fn(abs(2))
-obj.fn(abs(f, s, b, b))
-obj.fn(add(0, 2))
-obj.fn(add(0, a))
-obj.fn(add(0, b))
-obj.fn(add(1, 1))
-obj.fn(add(1, b))
-obj.fn(add(2, a))
-obj.fn(add(a, 0))
-obj.fn(add(a, a))
-obj.fn(add(a, b))
-obj.fn(add(b, 2))
-obj.fn(add(b, b))
-obj.fn(arr[0])
-obj.fn(arr[a])
-obj.fn(arr[b])
-obj.fn(b % a)
-obj.fn(b % b)
-obj.fn(b && true)
-obj.fn(b * 0)
-obj.fn(b * 1)
-obj.fn(b * b)
-obj.fn(b + obj?.a)
-obj.fn(b - 1)
-obj.fn(b - 2)
-obj.fn(b - a)
-obj.fn(b or false)
-obj.fn(b || false)
-obj.fn(b)
-obj.fn(b) != a
-obj.fn(b) != div
-obj.fn(b) * b ^ f
-obj.fn(b) ** b
-obj.fn(b) + b
-obj.fn(b) .. a % 2
-obj.fn(b) .. b * b
-obj.fn(b) < b
-obj.fn(b) < f
-obj.fn(b) <= 0 % b
-obj.fn(b) <= b
-obj.fn(b) == a / 1
-obj.fn(b) == div ? obj : div
-obj.fn(b) == ok
-obj.fn(b) > f
-obj.fn(b) ^ obj?.a
-obj.fn(count("a", false))
-obj.fn(count("b", ok))
-obj.fn(count("b", true))
-obj.fn(count("c", ok))
-obj.fn(count("c", true))
-obj.fn(count(1 .. f, s))
-obj.fn(count(arr, false))
-obj.fn(count(arr, ok))
-obj.fn(count(obj, ok))
-obj.fn(count(s, ok))
-obj.fn(div(0, a))
-obj.fn(div(0, b))
-obj.fn(div(1, 1))
-obj.fn(div(1, b))
-obj.fn(div(a, a))
-obj.fn(div(a, b))
-obj.fn(div(b, a))
-obj.fn(div(b, b))
-obj.fn(f == obj or b)
-obj.fn(false ? 0 : b)
-obj.fn(false or 0)
-obj.fn(false or a)
-obj.fn(false || 0)
-obj.fn(false || 2)
-obj.fn(false || a)
-obj.fn(get(arr, 0))
-obj.fn(get(arr, 0.5))
-obj.fn(get(arr, b))
-obj.fn(int("b", a))
-obj.fn(int(0))
-obj.fn(int(1))
-obj.fn(int(a))
-obj.fn(int(a, 0))
-obj.fn(int(b))
-obj.fn(int(b, s, a, "a", f))
-obj.fn(int(obj, true, b))
-obj.fn(int(true, f))
-obj.fn(last(arr))
-obj.fn(last(arr, b))
-obj.fn(len("b"))
-obj.fn(len(0, obj))
-obj.fn(len(arr))
-obj.fn(len(arr, s))
-obj.fn(len(f, arr))
-obj.fn(len(false, 1, s, obj))
-obj.fn(len(nil, arr))
-obj.fn(len(s))
-obj.fn(max(0))
-obj.fn(max(0, b))
-obj.fn(max(1))
-obj.fn(max(1, 0.5))
-obj.fn(max(a))
-obj.fn(max(b))
-obj.fn(min(0))
-obj.fn(min(0, f, a))
-obj.fn(min(1))
-obj.fn(min(a))
-obj.fn(min(b))
-obj.fn(min(f, f, 0))
-obj.fn(obj.a)
-obj.fn(obj.a) < b
-obj.fn(obj.b)
-obj.fn(obj.fn(1))
-obj.fn(obj.fn(2))
-obj.fn(obj.fn(a))
-obj.fn(obj.head(0))
-obj.fn(obj.head(0, add))
-obj.fn(obj.head(2))
-obj.fn(obj.head(a))
-obj.fn(obj.head(a, s))
-obj.fn(obj.head(b))
-obj.fn(obj?.a)
-obj.fn(obj?.b)
-obj.fn(obj?.fn(0))
-obj.fn(obj?.fn(a))
-obj.fn(obj?.fn(b))
-obj.fn(obj?.head(0))
-obj.fn(obj?.head(0, div))
-obj.fn(obj?.head(1))
-obj.fn(obj?.head(a, arr))
-obj.fn(obj?.head(b))
-obj.fn(ok && 2)
-obj.fn(ok && a)
-obj.fn(ok && b)
-obj.fn(ok ? 1 : 0)
-obj.fn(ok ? a : s)
-obj.fn(ok ? b : "b" .. all(obj, ok))
-obj.fn(ok and 0)
-obj.fn(ok and a)
-obj.fn(ok and b)
-obj.fn(s, obj, nil) || true ? 0 : b
-obj.fn(true && 0)
-obj.fn(true && 2)
-obj.fn(true ? 0 : add)
-obj.fn(true and a)
-obj.head(!false)
-obj.head(!false, s, div)
-obj.head(!ok)
-obj.head(!true)
-obj.head(!true, div)
-obj.head(!true, ok ? true : add)
-obj.head("a" != "c")
-obj.head("a" != a)
-obj.head("a" != add)
-obj.head("a" != b)
-obj.head("a" != div)
-obj.head("a" != s)
-obj.head("a" < s)
-obj.head("a" == "c")
-obj.head("a" == 0)
-obj.head("a" == arr)
-obj.head("a" == b)
-obj.head("a" == f)
-obj.head("a" >= "c")
-obj.head("a" contains "a")
-obj.head("a" in arr, obj)
-obj.head("a" in nil)
-obj.head("a" or true)
-obj.head("a" || true)
-obj.head("a") == add
-obj.head("a", a) == b - 0.5
-obj.head("b" != "c", last(arr, ok, f), arr)
-obj.head("b" != 1)
-obj.head("b" != a)
-obj.head("b" != add)
-obj.head("b" != arr)
-obj.head("b" != b)
-obj.head("b" != s)
-obj.head("b" + "b")
-obj.head("b" <= "b")
-obj.head("b" == f)
-obj.head("b" == obj)
-obj.head("b" || false)
-obj.head("b") + s
-obj.head("b") startsWith s
-obj.head("b", ok) != add
-obj.head("c" != a)
-obj.head("c" != ok)
-obj.head("c" + "a")
-obj.head("c" + s)
-obj.head("c" == "c")
-obj.head("c" == add, ok)
-obj.head("c" == arr)
-obj.head("c" == div)
-obj.head("c" == false)
-obj.head("c" >= "b")
-obj.head("c" >= s, get(0, ok))
-obj.head("c" and false)
-obj.head("c" and true)
-obj.head("c" contains "b")
-obj.head("c" endsWith "c")
-obj.head("c" startsWith "c")
-obj.head("c" || false)
-obj.head("c") endsWith s
-obj.head("c", "c") > s
-obj.head((nil || true) == arr)
-obj.head(-0)
-obj.head(-0.5)
-obj.head(-0.5, add)
-obj.head(-2)
-obj.head(-a)
-obj.head(-b)
-obj.head(-f)
-obj.head(-f, obj?.head(obj, ok, arr))
-obj.head(0 != arr)
-obj.head(0 != b)
-obj.head(0 != div)
-obj.head(0 != nil)
-obj.head(0 != nil, b)
-obj.head(0 != ok)
-obj.head(0 && true)
-obj.head(0 * 0.5)
-obj.head(0 * a)
-obj.head(0 ** 0)
-obj.head(0 ** 1)
-obj.head(0 ** b)
-obj.head(0 ** f)
-obj.head(0 + 2)
-obj.head(0 + a)
-obj.head(0 + f)
-obj.head(0 - 0.5)
-obj.head(0 - 1)
-obj.head(0 - a)
-obj.head(0 - f)
-obj.head(0 .. 0)
-obj.head(0 .. 0.5)
-obj.head(0 .. b)
-obj.head(0 / b)
-obj.head(0 < 0)
-obj.head(0 < b, obj?.head(obj, obj, add, "a"))
-obj.head(0 <= 0.5)
-obj.head(0 <= 0.5, obj.a)
-obj.head(0 <= 1)
-obj.head(0 == "a")
-obj.head(0 == 0)
-obj.head(0 == 1)
-obj.head(0 == add, f)
-obj.head(0 == arr)
-obj.head(0 == div)
-obj.head(0 == f)
-obj.head(0 == false)
-obj.head(0 == ok)
-obj.head(0 == s, float(b))
-obj.head(0 == true)
-obj.head(0 > 0)
-obj.head(0 > b)
-obj.head(0 >= 0)
-obj.head(0 >= a, s)
-obj.head(0 ^ 0.5)
-obj.head(0 ^ 1)
-obj.head(0 ^ a)
-obj.head(0 ^ f)
-obj.head(0 in nil)
-obj.head(0 || true)
-obj.head(0) != s
-obj.head(0) - b
-obj.head(0) .. obj?.head(1)
-obj.head(0) / a
-obj.head(0) / b
-obj.head(0) < b ^ b
-obj.head(0) == b
-obj.head(0) > a - b
-obj.head(0) >= 0.5 ? 2 : obj
-obj.head(0) >= a
-obj.head(0) ^ (b % 1)
-obj.head(0) ^ b
-obj.head(0, "a") - f
-obj.head(0, "b") + f
-obj.head(0, "b") .. add(b, b)
-obj.head(0, 0) == "c" ? nil : a
-obj.head(0, 0, "c") == obj?.a
-obj.head(0, 0.5, "b", 0) <= 0.5 != true
-obj.head(0, 1, div) < a
-obj.head(0, add) / a
-obj.head(0, arr) > b
-obj.head(0, arr, add, nil) < a
-obj.head(0, b, s) .. a
-obj.head(0, div) + f
-obj.head(0, div, a) < obj?.a
-obj.head(0, f) <= b
-obj.head(0, f, arr) == ok
-obj.head(0, f, b) == s
-obj.head(0, f, obj, 0, "a") + a
-obj.head(0, ok) - a
-obj.head(0, ok) > -b
-obj.head(0, true, b) - a
-obj.head(0.5 != 1)
-obj.head(0.5 != a)
-obj.head(0.5 != add)
-obj.head(0.5 != arr)
-obj.head(0.5 != b)
-obj.head(0.5 != f)
-obj.head(0.5 != obj)
-obj.head(0.5 * 0)
-obj.head(0.5 * a, arr)
-obj.head(0.5 ** a)
-obj.head(0.5 + a)
-obj.head(0.5 + f)
-obj.head(0.5 - 1)
-obj.head(0.5 - a)
-obj.head(0.5 - f)
-obj.head(0.5 .. 0)
-obj.head(0.5 .. a, max(div))
-obj.head(0.5 / 0)
-obj.head(0.5 < 0.5)
-obj.head(0.5 <= 0)
-obj.head(0.5 <= b)
-obj.head(0.5 == a)
-obj.head(0.5 == add, div)
-obj.head(0.5 == obj)
-obj.head(0.5 >= a)
-obj.head(0.5 >= f)
-obj.head(0.5 ^ 1)
-obj.head(0.5 and true)
-obj.head(0.5 in nil)
-obj.head(0.5) - b / f
-obj.head(0.5) / obj.head(2, obj)
-obj.head(0.5, f) != a
-obj.head(0.5, false, b) + obj.a
-obj.head(0.5, nil) >= f
-obj.head(0.5, nil, s) > a
-obj.head(1 != add, obj.a)
-obj.head(1 != arr)
-obj.head(1 != nil)
-obj.head(1 != obj)
-obj.head(1 != s)
-obj.head(1 && true)
-obj.head(1 * 0)
-obj.head(1 ** 2)
-obj.head(1 - a)
-obj.head(1 .. b)
-obj.head(1 / 0.5)
-obj.head(1 / 1)
-obj.head(1 / a)
-obj.head(1 / f)
-obj.head(1 < 1)
-obj.head(1 < a)
-obj.head(1 == 0, get(div, b))
-obj.head(1 == b)
-obj.head(1 == div)
-obj.head(1 == div, get(div, false))
-obj.head(1 == s, 0 ** 0, ok)
-obj.head(1 >= 0)
-obj.head(1 >= a, ok)
-obj.head(1 >= f)
-obj.head(1 and false)
-obj.head(1) + a
-obj.head(1) + a + a
-obj.head(1) == f
-obj.head(1) ^ obj.b
-obj.head(1, a, ok) <= a
-obj.head(1, add, ok) > a
-obj.head(1, div) == b ? a : a
-obj.head(2 != "a")
-obj.head(2 != b)
-obj.head(2 != true)
-obj.head(2 % b)
-obj.head(2 * b)
-obj.head(2 ** b)
-obj.head(2 + 2)
-obj.head(2 + b)
-obj.head(2 - 1)
-obj.head(2 - f, obj, get(obj, a))
-obj.head(2 .. a)
-obj.head(2 / 0)
-obj.head(2 / a, add)
-obj.head(2 / f)
-obj.head(2 == ok)
-obj.head(2 >= 0.5)
-obj.head(2 >= b)
-obj.head(2 >= f)
-obj.head(2 ^ b, 0.5 && false)
-obj.head(2 ^ f)
-obj.head(2 in arr)
-obj.head(2 in nil, a)
-obj.head(2) != s
-obj.head(2) + f
-obj.head(2) == obj.a
-obj.head(2, 0.5) % obj?.b
-obj.head(2, 0.5) - obj.a
-obj.head(2, arr, 2, obj, div) > f
-obj.head(2, div, ok) in 2 .. 2
-obj.head(["c"])
-obj.head([arr, add])
-obj.head(a != 0)
-obj.head(a != a)
-obj.head(a != arr)
-obj.head(a != b)
-obj.head(a != f)
-obj.head(a != nil)
-obj.head(a != obj)
-obj.head(a != ok)
-obj.head(a != ok, obj.b)
-obj.head(a % 2)
-obj.head(a % b)
-obj.head(a * 0)
-obj.head(a * 0.5)
-obj.head(a * 1)
-obj.head(a * a)
-obj.head(a * b)
-obj.head(a * b, get(0.5, nil))
-obj.head(a * f)
-obj.head(a ** a)
-obj.head(a ** f)
-obj.head(a + 0)
-obj.head(a + 0.5, none(obj, true), a)
-obj.head(a - 0)
-obj.head(a - 0.5)
-obj.head(a - 1)
-obj.head(a - 2)
-obj.head(a - a)
-obj.head(a - b)
-obj.head(a - b, 0 && false, f)
-obj.head(a - f)
-obj.head(a .. f)
-obj.head(a / 0)
-obj.head(a / 1)
-obj.head(a < 0)
-obj.head(a < 1)
-obj.head(a < a)
-obj.head(a < b)
-obj.head(a <= a)
-obj.head(a <= b, false in arr)
-obj.head(a <= b, ok ? a : div)
-obj.head(a <= f)
-obj.head(a == "b")
-obj.head(a == 0)
-obj.head(a == 0, f == nil)
-obj.head(a == add)
-obj.head(a == b)
-obj.head(a == f)
-obj.head(a == f, ok ? obj : arr)
-obj.head(a == obj)
-obj.head(a > 1)
-obj.head(a >= a)
-obj.head(a >= f)
-obj.head(a ^ 0)
-obj.head(a ^ a)
-obj.head(a ^ a, add)
-obj.head(a ^ f)
-obj.head(a and true)
-obj.head(a in arr)
-obj.head(a or true)
-obj.head(a)
-obj.head(a) != div
-obj.head(a) * a
-obj.head(a) * b
-obj.head(a) ** f
-obj.head(a) + b
-obj.head(a) + f
-obj.head(a) < add(b, a)
-obj.head(a) < b ** 0
-obj.head(a) <= 0.5 - 0.5
-obj.head(a) >= 0.5 ^ f
-obj.head(a) >= int(a)
-obj.head(a) ^ a
-obj.head(a, "a", false, 0) % b
-obj.head(a, "b", "b") == obj ? "b" : arr
-obj.head(a, 1 != arr)
-obj.head(a, a)
-obj.head(a, add)
-obj.head(a, add) != div ? 0 : 0.5
-obj.head(a, arr)
-obj.head(a, arr) < obj.a
-obj.head(a, b)
-obj.head(a, b, f)
-obj.head(a, div)
-obj.head(a, f)
-obj.head(a, f) == f
-obj.head(a, f, div, "b") ^ b
-obj.head(a, f, f) * b ** a
-obj.head(a, f, obj.a)
-obj.head(a, false) ^ 0.5 ** a
-obj.head(a, nil) == f
-obj.head(a, nil) == obj
-obj.head(a, obj, ok, nil, ok) <= b
-obj.head(a, obj.a)
-obj.head(a, obj.b)
-obj.head(a, obj.obj)
-obj.head(a, obj?.head(s))
-obj.head(a, ok)
-obj.head(a, s)
-obj.head(a, s) - a
-obj.head(a, string(0.5, 1), f)
-obj.head(a, true || arr)
-obj.head(abs(0))
-obj.head(abs(1), ok && add)
-obj.head(abs(2))
-obj.head(abs(b))
-obj.head(abs(b, add, true, b))
-obj.head(abs(div, "b", b))
-obj.head(abs(div, arr, f))
-obj.head(abs(f))
-obj.head(abs(f, "b", a))
-obj.head(abs(obj, b), add != obj)
-obj.head(abs(obj, div, 1), a, get(0, f))
-obj.head(add != "a")
-obj.head(add != "c", ok)
-obj.head(add != 0)
-obj.head(add != 2)
-obj.head(add != add)
-obj.head(add != arr)
-obj.head(add != b)
-obj.head(add != f)
-obj.head(add != false, a)
-obj.head(add != nil, s)
-obj.head(add != obj)
-obj.head(add != ok)
-obj.head(add != true)
-obj.head(add && false, map(obj, obj))
-obj.head(add && true)
-obj.head(add == 0.5)
-obj.head(add == add)
-obj.head(add == arr)
-obj.head(add == f)
-obj.head(add == ok)
-obj.head(add == s)
-obj.head(add == true)
-obj.head(add in arr)
-obj.head(add in nil)
-obj.head(add or true)
-obj.head(add(0, 0))
-obj.head(add(0, 1), obj, s)
-obj.head(add(0, a))
-obj.head(add(1, a), int(0))
-obj.head(add(2, 0))
-obj.head(add(2, b))
-obj.head(add(a, 0))
-obj.head(add(a, 0), div)
-obj.head(add(a, a))
-obj.head(add(a, a), get(s, a))
-obj.head(add(b, 0))
-obj.head(add(b, a))
-obj.head(add(b, b))
-obj.head(add)
-obj.head(add) != div
-obj.head(add) != f
-obj.head(add) == f ** 1
-obj.head(add, a)
-obj.head(add, a, b, arr) == add
-obj.head(add, add)
-obj.head(add, b)
-obj.head(add, b, s) == ok
-obj.head(add, div)
-obj.head(add, f)
-obj.head(add, filter(arr, true))
-obj.head(add, obj)
-obj.head(add, s <= "b")
-obj.head(add, s)
-obj.head(add, s, arr) != add(a, 0)
-obj.head(add, string(b))
-obj.head(all("b", ok))
-obj.head(all("b", true))
-obj.head(all("c", false))
-obj.head(all("c", ok))
-obj.head(all(arr, false) == map(s, nil))
-obj.head(all(arr, ok))
-obj.head(all(arr, true))
-obj.head(all(arr, true), a)
-obj.head(all(obj, false))
-obj.head(all(obj, true))
-obj.head(all(s, ok))
-obj.head(any("a", false))
-obj.head(any("b", false))
-obj.head(any(arr, ok))
-obj.head(any(arr, true))
-obj.head(any(obj, false))
-obj.head(any(obj, true))
-obj.head(arr != 2)
-obj.head(arr != a)
-obj.head(arr != add)
-obj.head(arr != arr)
-obj.head(arr != b)
-obj.head(arr != div)
-obj.head(arr != f)
-obj.head(arr != false)
-obj.head(arr != s)
-obj.head(arr && false)
-obj.head(arr && true)
-obj.head(arr == "a")
-obj.head(arr == a)
-obj.head(arr == arr)
-obj.head(arr == b)
-obj.head(arr == f)
-obj.head(arr == nil)
-obj.head(arr == nil, all("b", ok), b)
-obj.head(arr == obj)
-obj.head(arr == s)
-obj.head(arr in nil)
-obj.head(arr || true)
-obj.head(arr)
-obj.head(arr) != a
-obj.head(arr) != a ** b
-obj.head(arr) != add
-obj.head(arr) != obj
-obj.head(arr) != obj.head(ok)
-obj.head(arr) in arr
-obj.head(arr)[obj?.a]
-obj.head(arr, 0) != obj?.head(obj)
-obj.head(arr, a) == 0.5 * f
-obj.head(arr, add)
-obj.head(arr, add)[obj.b]
-obj.head(arr, arr)
-obj.head(arr, b)
-obj.head(arr, b, arr)
-obj.head(arr, div)
-obj.head(arr, div, 0, "b", arr) != f
-obj.head(arr, div, arr)
-obj.head(arr, div, false, a, div) != arr
-obj.head(arr, f or true)
-obj.head(arr, f)
-obj.head(arr, f, arr, 0) != ok
-obj.head(arr, map(obj, false))
-obj.head(arr, obj)
-obj.head(arr, obj, add) == ok
-obj.head(arr, obj?.a)
-obj.head(arr, ok)
-obj.head(arr, ok, false) == add
-obj.head(arr[0:f])
-obj.head(arr[0], get(ok, f), arr)
-obj.head(arr[1])
-obj.head(arr[1], ok)
-obj.head(arr[a])
-obj.head(arr[b:f])
-obj.head(arr[b])
-obj.head(arr[b], s)
-obj.head(arr[f])
-obj.head(b != 0, ok, a)
-obj.head(b != a)
-obj.head(b != arr)
-obj.head(b != arr, s)
-obj.head(b != f)
-obj.head(b != false)
-obj.head(b != obj)
-obj.head(b != ok)
-obj.head(b != true)
-obj.head(b % 1, obj.b)
-obj.head(b % b, get(arr, arr))
-obj.head(b * 0.5)
-obj.head(b * 1)
-obj.head(b * a)
-obj.head(b * b, b)
-obj.head(b * f)
-obj.head(b ** 0)
-obj.head(b ** 0.5, add)
-obj.head(b ** b)
-obj.head(b ** f, div)
-obj.head(b + a)
-obj.head(b + b)
-obj.head(b + f)
-obj.head(b - 0)
-obj.head(b - 0, b ** b)
-obj.head(b - 0.5)
-obj.head(b - 1)
-obj.head(b - 2, obj.head(obj))
-obj.head(b - a)
-obj.head(b - f)
-obj.head(b .. a)
-obj.head(b .. a, 2 <= a)
-obj.head(b .. b)
-obj.head(b .. f, get(obj, a), map(arr, true))
-obj.head(b / 0)
-obj.head(b / b)
-obj.head(b / b, a)
-obj.head(b < a)
-obj.head(b < b)
-obj.head(b < f)
-obj.head(b <= a)
-obj.head(b <= f)
-obj.head(b == "a")
-obj.head(b == "b")
-obj.head(b == 0)
-obj.head(b == a)
-obj.head(b == add)
-obj.head(b == arr)
-obj.head(b == b)
-obj.head(b == div)
-obj.head(b == nil)
-obj.head(b == obj)
-obj.head(b == ok)
-obj.head(b == ok, div)
-obj.head(b == s)
-obj.head(b > 0)
-obj.head(b > 0.5)
-obj.head(b > 1)
-obj.head(b > a)
-obj.head(b >= a, arr)
-obj.head(b >= b, obj.a)
-obj.head(b >= f)
-obj.head(b ^ 0.5)
-obj.head(b ^ 1, not ok)
-obj.head(b ^ a)
-obj.head(b in arr)
-obj.head(b in nil)
-obj.head(b or false)
-obj.head(b || false)
-obj.head(b || true)
-obj.head(b)
-obj.head(b) != a
-obj.head(b) % a
-obj.head(b) % b
-obj.head(b) * b
-obj.head(b) ** div(1, 1)
-obj.head(b) ** obj?.a
-obj.head(b) - -0
-obj.head(b) - a
-obj.head(b) - b
-obj.head(b) .. div(a, a)
-obj.head(b) / (b + a)
-obj.head(b) / b
-obj.head(b) < -f
-obj.head(b) <= a + a
-obj.head(b) <= obj.b
-obj.head(b) == add
-obj.head(b) == map(arr, add)
-obj.head(b) == obj
-obj.head(b) > obj.b
-obj.head(b) >= a
-obj.head(b) ^ obj.a
-obj.head(b) in arr
-obj.head(b, 0 / 2, max(div))
-obj.head(b, 0.5, add, nil) == f
-obj.head(b, 2) != first(arr)
-obj.head(b, a + a)
-obj.head(b, a - a)
-obj.head(b, a)
-obj.head(b, a) ^ b
-obj.head(b, a, obj) <= b ? ok : "c"
-obj.head(b, a, obj) ^ f
-obj.head(b, a, s) >= obj?.a
-obj.head(b, add) - f
-obj.head(b, add, false, false, false) == s ? 1 : div
-obj.head(b, add, s, arr) < 0.5 + b
-obj.head(b, add, true) == f
-obj.head(b, arr)
-obj.head(b, arr) != add
-obj.head(b, arr) ** b
-obj.head(b, arr) >= b
-obj.head(b, b + f)
-obj.head(b, b)
-obj.head(b, b) != obj.obj
-obj.head(b, b, ok) / b
-obj.head(b, div)
-obj.head(b, f != "b")
-obj.head(b, f) != add
-obj.head(b, f, b, obj, a) ^ f ** f
-obj.head(b, f, false) + a
-obj.head(b, f, s, div, b) > b
-obj.head(b, false, b) - obj?.a
-obj.head(b, first(0.5))
-obj.head(b, get(b, arr))
-obj.head(b, get(div, true), "a" != 0)
-obj.head(b, get(s, 0))
-obj.head(b, get(true, obj))
-obj.head(b, last(nil))
-obj.head(b, nil != div)
-obj.head(b, nil or false)
-obj.head(b, obj)
-obj.head(b, obj) % b
-obj.head(b, obj.a)
-obj.head(b, obj.head(add))
-obj.head(b, ok or ok?.a)
-obj.head(b, ok)
-obj.head(b, s)
-obj.head(b, true) == div
-obj.head(count("a", true))
-obj.head(count("c", ok))
-obj.head(count(arr, false))
-obj.head(count(arr, ok))
-obj.head(count(arr, ok), 0 == arr)
-obj.head(count(arr, true))
-obj.head(count(obj, false))
-obj.head(count(obj, ok))
-obj.head(count(s, false))
-obj.head(count(s, ok))
-obj.head(count(s, ok), obj.b)
-obj.head(count(s, true))
-obj.head(date(s, s))
-obj.head(div != "a")
-obj.head(div != 1)
-obj.head(div != a)
-obj.head(div != add)
-obj.head(div != arr)
-obj.head(div != b, f)
-obj.head(div != f)
-obj.head(div != false)
-obj.head(div != obj, arr)
-obj.head(div != s)
-obj.head(div && true)
-obj.head(div == "b", div, b == nil)
-obj.head(div == 0)
-obj.head(div == 0.5)
-obj.head(div == 1)
-obj.head(div == 2)
-obj.head(div == a)
-obj.head(div == a, add)
-obj.head(div == div)
-obj.head(div == f)
-obj.head(div == f, add)
-obj.head(div == nil)
-obj.head(div == obj, b)
-obj.head(div == obj, toBase64(s))
-obj.head(div and true)
-obj.head(div in arr)
-obj.head(div in nil)
-obj.head(div || true)
-obj.head(div(0, a))
-obj.head(div(0, b), ok ? b : "a")
-obj.head(div(1, a))
-obj.head(div(1, a), obj, "b" in arr)
-obj.head(div(a, 2))
-obj.head(div(a, a))
-obj.head(div(a, b))
-obj.head(div(a, b), s)
-obj.head(div(b, 2))
-obj.head(div(b, a))
-obj.head(div(b, b))
-obj.head(div)
-obj.head(div) != ok
-obj.head(div) == a
-obj.head(div) == b
-obj.head(div) == div
-obj.head(div) == obj
-obj.head(div, 0 > f)
-obj.head(div, 0.5) != -0.5
-obj.head(div, a == f)
-obj.head(div, a)
-obj.head(div, add)
-obj.head(div, b ** a)
-obj.head(div, b + a, b, a)
-obj.head(div, b) == a
-obj.head(div, b, div)
-obj.head(div, b, obj, add) == b
-obj.head(div, div != obj)
-obj.head(div, div(0, 2))
-obj.head(div, div)
-obj.head(div, f != false)
-obj.head(div, f >= f)
-obj.head(div, f)
-obj.head(div, false, "c", s) != obj.head(add, "c")
-obj.head(div, get(a, 0))
-obj.head(div, get(false, f))
-obj.head(div, get(false, obj))
-obj.head(div, max(b))
-obj.head(div, not ok)
-obj.head(div, obj)
-obj.head(div, obj.a)
-obj.head(div, ok != arr)
-obj.head(div, ok and div)
-obj.head(div, ok)
-obj.head(div, s != div)
-obj.head(div, s < s, a)
-obj.head(div, s)
-obj.head(div, s[2])
-obj.head(f != "c")
-obj.head(f != "c", 0 * 0.5)
-obj.head(f != a)
-obj.head(f != a, ok, obj)
-obj.head(f != add)
-obj.head(f != b)
-obj.head(f != nil)
-obj.head(f != ok)
-obj.head(f != s)
-obj.head(f != s, upper(0.5, s))
-obj.head(f != true)
-obj.head(f * 0)
-obj.head(f * 0.5)
-obj.head(f * 2)
-obj.head(f * b)
-obj.head(f * f)
-obj.head(f ** 0)
-obj.head(f ** 2)
-obj.head(f ** b)
-obj.head(f ** obj.a)
-obj.head(f + 0)
-obj.head(f + a)
-obj.head(f + b)
-obj.head(f - 0)
-obj.head(f - 0.5)
-obj.head(f - 2)
-obj.head(f - a)
-obj.head(f - b, f ** f)
-obj.head(f - f)
-obj.head(f .. a)
-obj.head(f .. b, add == nil)
-obj.head(f .. f)
-obj.head(f .. f) != arr
-obj.head(f / 0.5)
-obj.head(f / 1)
-obj.head(f / a)
-obj.head(f / f)
-obj.head(f < b)
-obj.head(f <= 1, obj)
-obj.head(f <= b)
-obj.head(f == "b", now(ok, 2))
-obj.head(f == "c", one(arr, true))
-obj.head(f == 0)
-obj.head(f == add)
-obj.head(f == b)
-obj.head(f == f)
-obj.head(f == obj, div)
-obj.head(f == s)
-obj.head(f == s, ok)
-obj.head(f > 0)
-obj.head(f > 1)
-obj.head(f > f)
-obj.head(f > f, any(s, ok), f ^ 0)
-obj.head(f >= 0)
-obj.head(f >= 0.5)
-obj.head(f >= f)
-obj.head(f >= f, int(s, nil, f))
-obj.head(f ^ 2, a)
-obj.head(f ^ b)
-obj.head(f ^ f)
-obj.head(f ^ f, s < s)
-obj.head(f in arr)
-obj.head(f in arr, f == 0)
-obj.head(f in nil)
-obj.head(f or false)
-obj.head(f)
-obj.head(f) != abs(0.5)
-obj.head(f) != div
-obj.head(f) != ok
-obj.head(f) * b
-obj.head(f) .. int(0.5)
-obj.head(f) / a
-obj.head(f) < b
-obj.head(f) < f / 0
-obj.head(f) == f
-obj.head(f) == obj.a
-obj.head(f) == ok
-obj.head(f) == s
-obj.head(f) >= b
-obj.head(f) ^ f
-obj.head(f, 0 / f, a - a)
-obj.head(f, 0, 0.5) * a
-obj.head(f, 0, arr, a) >= f
-obj.head(f, a)
-obj.head(f, arr != div)
-obj.head(f, arr)
-obj.head(f, arr) == obj
-obj.head(f, b + f)
-obj.head(f, b and true, s)
-obj.head(f, b)
-obj.head(f, b, s) * f / 1
-obj.head(f, div != arr)
-obj.head(f, div) != ok
-obj.head(f, div, get(f, obj))
-obj.head(f, div, true, div) ** obj.a
-obj.head(f, f)
-obj.head(f, f) != obj.a
-obj.head(f, false ? true : 0)
-obj.head(f, float(b))
-obj.head(f, get(false, false))
-obj.head(f, last(obj))
-obj.head(f, nil != ok)
-obj.head(f, obj)
-obj.head(f, obj) != add
-obj.head(f, ok && f)
-obj.head(f, ok)
-obj.head(f, ok, f ** f)
-obj.head(f, s) && false ? add : ok
-obj.head(f, s) >= a / b
-obj.head(f, s, obj)
-obj.head(f, s[b])
-obj.head(false != 0)
-obj.head(false != add)
-obj.head(false != arr)
-obj.head(false != b)
-obj.head(false != div)
-obj.head(false != f)
-obj.head(false != obj)
-obj.head(false != s)
-obj.head(false && add)
-obj.head(false && b)
-obj.head(false && f)
-obj.head(false && obj)
-obj.head(false && s, obj?.head("a", nil, b))
-obj.head(false && s, s[2])
-obj.head(false == 0.5)
-obj.head(false == a)
-obj.head(false == add)
-obj.head(false == f, true != 2)
-obj.head(false == nil)
-obj.head(false == obj)
-obj.head(false ? add : add)
-obj.head(false ? arr : ok)
-obj.head(false ? obj : 0)
-obj.head(false ? obj : s)
-obj.head(false and "c")
-obj.head(false and add)
-obj.head(false and b)
-obj.head(false and div)
-obj.head(false and false)
-obj.head(false and obj)
-obj.head(false and s)
-obj.head(false in nil)
-obj.head(false or "b")
-obj.head(false or b)
-obj.head(false or f, get("a", arr))
-obj.head(false or ok)
-obj.head(false or s)
-obj.head(false or s, ok ? 0 : 0.5)
-obj.head(false || 0)
-obj.head(false || 1)
-obj.head(false || add)
-obj.head(false || arr)
-obj.head(false || b)
-obj.head(false || obj, get(arr, div))
-obj.head(false || s)
-obj.head(false || true)
-obj.head(false) && 2 == nil
-obj.head(false) && arr == nil
-obj.head(false) == a
-obj.head(false, "b") || "b" startsWith "a"
-obj.head(false, 0, nil, "c") == obj
-obj.head(false, a) != arr
-obj.head(false, arr, obj, 2, div) == arr
-obj.head(false, f) != div
-obj.head(false, obj) != a == ok
-obj.head(false, ok) == obj.b
-obj.head(filter("b", ok))
-obj.head(filter("c", ok), obj, get("c", add))
-obj.head(filter(arr, true))
-obj.head(filter(obj, false))
-obj.head(filter(s, ok))
-obj.head(first("a", 0.5, s))
-obj.head(first("b", add, nil, div))
-obj.head(first(0))
-obj.head(first(0.5))
-obj.head(first(0.5), obj?.a) == obj
-obj.head(first(0.5, ok))
-obj.head(first(2))
-obj.head(first(a))
-obj.head(first(a, 1, f))
-obj.head(first(add))
-obj.head(first(arr))
-obj.head(first(b, arr))
-obj.head(first(false, obj))
-obj.head(first(nil, "b", obj))
-obj.head(first(obj))
-obj.head(first(ok, b))
-obj.head(first(ok, ok))
-obj.head(first(s))
-obj.head(float("a", a))
-obj.head(float(0))
-obj.head(float(1))
-obj.head(float(2))
-obj.head(float(a))
-obj.head(float(a), ok and f)
-obj.head(float(a, 0, a))
-obj.head(float(a, b), add)
-obj.head(float(add, 2))
-obj.head(float(arr, b))
-obj.head(float(b))
-obj.head(float(div, obj, add, 0), false && obj)
-obj.head(float(f))
-obj.head(float(f), f)
-obj.head(float(f, 0))
-obj.head(float(ok, b))
-obj.head(get("a"))
-obj.head(get("a"))?.a
-obj.head(get("a"), b)
-obj.head(get("a", arr))
-obj.head(get("a", b))
-obj.head(get("a", div))
-obj.head(get("a", f))
-obj.head(get("a", obj))
-obj.head(get("a", ok))
-obj.head(get("b"))
-obj.head(get("b", 0))
-obj.head(get("b", a))
-obj.head(get("b", add))
-obj.head(get("b", arr))
-obj.head(get("b", nil))
-obj.head(get("b", obj, a))
-obj.head(get("b", ok))
-obj.head(get("b", s))
-obj.head(get("c", a))
-obj.head(get("c", arr))
-obj.head(get("c", arr)) == a
-obj.head(get("c", b))
-obj.head(get(0))
-obj.head(get(0, 0))
-obj.head(get(0, add))
-obj.head(get(0, arr))
-obj.head(get(0, arr), obj)
-obj.head(get(0, arr)?.b)
-obj.head(get(0, b))
-obj.head(get(0, div))
-obj.head(get(0, f), b)
-obj.head(get(0, ok))
-obj.head(get(0, s))
-obj.head(get(0, true))
-obj.head(get(0.5))
-obj.head(get(0.5, 0))
-obj.head(get(0.5, arr))
-obj.head(get(0.5, false))
-obj.head(get(0.5, nil, arr, 1, 2))
-obj.head(get(0.5, obj))
-obj.head(get(0.5, obj), ok)
-obj.head(get(1), map(arr, obj))?.b
-obj.head(get(1, a))
-obj.head(get(1, div))
-obj.head(get(1, f))
-obj.head(get(1, false))
-obj.head(get(1, s))
-obj.head(get(2, f))
-obj.head(get(a, 0))
-obj.head(get(a, 0.5))
-obj.head(get(a, add))
-obj.head(get(a, b))
-obj.head(get(a, b), min(false))
-obj.head(get(a, div))
-obj.head(get(a, nil))
-obj.head(get(a, nil), arr)
-obj.head(get(a, obj))
-obj.head(get(a, obj), div == nil)
-obj.head(get(a, s))
-obj.head(get(add, 0.5))
-obj.head(get(add, 0.5), ok)
-obj.head(get(add, 1))
-obj.head(get(add, 2))
-obj.head(get(add, a))
-obj.head(get(add, arr))
-obj.head(get(add, b))
-obj.head(get(add, div))
-obj.head(get(add, f))
-obj.head(get(add, f, a, s))
-obj.head(get(add, nil))
-obj.head(get(add, obj))
-obj.head(get(add, ok))
-obj.head(get(add, s))
-obj.head(get(arr))
-obj.head(get(arr, 0.5))
-obj.head(get(arr, 2))
-obj.head(get(arr, a))
-obj.head(get(arr, add))
-obj.head(get(arr, arr))
-obj.head(get(arr, f))
-obj.head(get(arr, f)) * f
-obj.head(get(arr, f), add)
-obj.head(get(arr, f, obj, a))
-obj.head(get(arr, nil))
-obj.head(get(arr, obj))?.a
-obj.head(get(arr, ok))
-obj.head(get(arr, s))
-obj.head(get(b))
-obj.head(get(b, 0.5))
-obj.head(get(b, 2))
-obj.head(get(b, a))
-obj.head(get(b, add))
-obj.head(get(b, b))
-obj.head(get(b, b), div, toJSON(arr))
-obj.head(get(b, b), ok)
-obj.head(get(b, div))
-obj.head(get(b, f))
-obj.head(get(b, nil))
-obj.head(get(b, obj))
-obj.head(get(b, ok))
-obj.head(get(b, s))
-obj.head(get(b, s))?.obj
-obj.head(get(b, true))
-obj.head(get(b, true), ok)?.a
-obj.head(get(div))
-obj.head(get(div, 0.5))
-obj.head(get(div, a))
-obj.head(get(div, add))
-obj.head(get(div, b))
-obj.head(get(div, b))?.obj
-obj.head(get(div, div))
-obj.head(get(div, nil))
-obj.head(get(div, obj.b))
-obj.head(get(div, ok))
-obj.head(get(div, s)?.obj)
-obj.head(get(div, true))
-obj.head(get(f, 0))
-obj.head(get(f, 0.5))
-obj.head(get(f, a))
-obj.head(get(f, add))
-obj.head(get(f, arr))
-obj.head(get(f, b))
-obj.head(get(f, div))
-obj.head(get(f, div, arr))
-obj.head(get(f, nil))
-obj.head(get(f, nil), add)
-obj.head(get(f, nil, a), a)
-obj.head(get(f, obj))
-obj.head(get(f, true))
-obj.head(get(false ? s : arr, obj?.head(a, add)))
-obj.head(get(false, arr))
-obj.head(get(false, div))
-obj.head(get(false, false))
-obj.head(get(false, ok))
-obj.head(get(nil))
-obj.head(get(nil, 0))
-obj.head(get(nil, 0.5))
-obj.head(get(nil, 1))
-obj.head(get(nil, a), arr)
-obj.head(get(nil, add))
-obj.head(get(nil, add))?.b
-obj.head(get(nil, div))
-obj.head(get(nil, div)) != float(a ** 0)
-obj.head(get(nil, f))
-obj.head(get(nil, nil))
-obj.head(get(nil, obj))
-obj.head(get(nil, ok))
-obj.head(get(nil, s))
-obj.head(get(nil, s), a)
-obj.head(get(nil, true))
-obj.head(get(obj))
-obj.head(get(obj), ok)
-obj.head(get(obj, 0))
-obj.head(get(obj, 1))
-obj.head(get(obj, 1))?.b
-obj.head(get(obj, a))
-obj.head(get(obj, arr) != a)
-obj.head(get(obj, arr))
-obj.head(get(obj, arr))?.obj
-obj.head(get(obj, b))
-obj.head(get(obj, div))
-obj.head(get(obj, f))
-obj.head(get(obj, false))
-obj.head(get(obj, nil))
-obj.head(get(obj, obj))
-obj.head(get(obj, ok))
-obj.head(get(obj, s))
-obj.head(get(obj, true))
-obj.head(get(ok))
-obj.head(get(ok, 0))
-obj.head(get(ok, 0.5))
-obj.head(get(ok, 1))
-obj.head(get(ok, a))?.b
-obj.head(get(ok, add))
-obj.head(get(ok, add), obj)
-obj.head(get(ok, arr))
-obj.head(get(ok, div))
-obj.head(get(ok, f))
-obj.head(get(ok, false), map(arr, "a"), toJSON(0.5))
-obj.head(get(ok, nil))
-obj.head(get(ok, ok))
-obj.head(get(ok, ok), 0 + 0.5)
-obj.head(get(ok, s), a > 0.5)
-obj.head(get(ok, s), arr[0:b])
-obj.head(get(s))
-obj.head(get(s, "a", ok))
-obj.head(get(s, 0.5))
-obj.head(get(s, 1))
-obj.head(get(s, 1), b)
-obj.head(get(s, a))
-obj.head(get(s, a), obj.head(0.5, div))
-obj.head(get(s, add))
-obj.head(get(s, arr))
-obj.head(get(s, div))
-obj.head(get(s, div))?.b
-obj.head(get(s, f))
-obj.head(get(s, nil))
-obj.head(get(s, obj))
-obj.head(get(s, obj), get(a, f))
-obj.head(get(s, ok), true ? b : "a")
-obj.head(get(s, true))
-obj.head(get(true && nil))
-obj.head(get(true))
-obj.head(get(true, 0))
-obj.head(get(true, 0), arr)
-obj.head(get(true, a))
-obj.head(get(true, add))
-obj.head(get(true, add), arr)
-obj.head(get(true, arr))
-obj.head(get(true, f), ok || 1)
-obj.head(get(true, nil))
-obj.head(int("b", arr, f))
-obj.head(int("b", nil, a))
-obj.head(int(a))
-obj.head(int(a), string(true))
-obj.head(int(arr, a, f))
-obj.head(int(s, 0))
-obj.head(keys(obj))
-obj.head(last(0.5))
-obj.head(last(0.5), arr)
-obj.head(last(0.5), get(nil, ok))
-obj.head(last(a))
-obj.head(last(a, "a"))
-obj.head(last(a, obj))
-obj.head(last(add))
-obj.head(last(add), ok)
-obj.head(last(add, obj, add))
-obj.head(last(arr))
-obj.head(last(arr, s), f)
-obj.head(last(b))
-obj.head(last(b, b))
-obj.head(last(div))
-obj.head(last(f))
-obj.head(last(f, b, b))
-obj.head(last(false))
-obj.head(last(obj))
-obj.head(last(obj, 2, obj))
-obj.head(last(obj, a, s))
-obj.head(last(ok, arr, nil, ok))
-obj.head(last(s))
-obj.head(last(s, ok, a), nil == arr)
-obj.head(len(add, add, s, obj))
-obj.head(len(add, obj))
-obj.head(len(arr))
-obj.head(len(b, s))
-obj.head(len(obj))
-obj.head(len(obj, "a"))
-obj.head(len(s) <= f)
-obj.head(len(s))
-obj.head(len(s, arr, "b"), obj?.b)
-obj.head(lower(a, "b"))
-obj.head(lower(a, div, "b"))
-obj.head(lower(s))
-obj.head(map("a", 0.5))
-obj.head(map("a", a))
-obj.head(map("a", nil))
-obj.head(map("a", s))
-obj.head(map("b", 0))
-obj.head(map("b", div))
-obj.head(map("b", f))
-obj.head(map("b", nil))
-obj.head(map("b", s))
-obj.head(map("b", true))
-obj.head(map("c", "b"))
-obj.head(map("c", a))
-obj.head(map("c", a), get(arr, div))
-obj.head(map("c", arr))
-obj.head(map("c", arr), ok)
-obj.head(map("c", b))
-obj.head(map("c", f))
-obj.head(map("c", s))
-obj.head(map(arr, "c"))
-obj.head(map(arr, 0))
-obj.head(map(arr, 1))
-obj.head(map(arr, a))
-obj.head(map(arr, arr))
-obj.head(map(arr, b))
-obj.head(map(arr, b), div != obj)
-obj.head(map(arr, div))
-obj.head(map(arr, f))
-obj.head(map(arr, false))
-obj.head(map(arr, nil))
-obj.head(map(arr, obj), toJSON(b))
-obj.head(map(arr, ok) == b)
-obj.head(map(arr, ok))
-obj.head(map(arr, s))
-obj.head(map(obj, "a"))
-obj.head(map(obj, "b"))
-obj.head(map(obj, "c"))
-obj.head(map(obj, 0))
-obj.head(map(obj, 0.5))
-obj.head(map(obj, a))
-obj.head(map(obj, add))
-obj.head(map(obj, div))
-obj.head(map(obj, f))
-obj.head(map(obj, false))
-obj.head(map(obj, nil))
-obj.head(map(obj, obj))
-obj.head(map(obj, ok))
-obj.head(map(obj, s))
-obj.head(map(s, "a"))
-obj.head(map(s, 0))
-obj.head(map(s, 0.5))
-obj.head(map(s, a))
-obj.head(map(s, add))
-obj.head(map(s, arr))
-obj.head(map(s, div))
-obj.head(map(s, f))
-obj.head(map(s, false))
-obj.head(map(s, get(f, f)))
-obj.head(map(s, nil))
-obj.head(map(s, nil), obj.a)
-obj.head(map(s, obj))
-obj.head(map(s, ok))
-obj.head(map(s, ok), int(b))
-obj.head(map(s, s))
-obj.head(map(s, true))
-obj.head(max("a"))
-obj.head(max("c"))
-obj.head(max(0.5))
-obj.head(max(1))
-obj.head(max(a))
-obj.head(max(add))
-obj.head(max(b))
-obj.head(max(f))
-obj.head(max(f), a)
-obj.head(max(nil, 0), div)
-obj.head(max(obj))
-obj.head(max(ok))
-obj.head(max(s))
-obj.head(min(0))
-obj.head(min(0, 0))
-obj.head(min(0, a, f, f))
-obj.head(min(a))
-obj.head(min(a, f), obj)
-obj.head(min(add))
-obj.head(min(arr))
-obj.head(min(div))
-obj.head(min(f))
-obj.head(min(nil))
-obj.head(min(ok))
-obj.head(min(s))
-obj.head(min(true))
-obj.head(nil != 0)
-obj.head(nil != 0, a)
-obj.head(nil != a)
-obj.head(nil != add)
-obj.head(nil != add, f)
-obj.head(nil != f)
-obj.head(nil != false)
-obj.head(nil != obj)
-obj.head(nil != true)
-obj.head(nil != true, obj?.b)
-obj.head(nil && true)
-obj.head(nil == "a")
-obj.head(nil == 0)
-obj.head(nil == 0.5)
-obj.head(nil == a)
-obj.head(nil == add)
-obj.head(nil == b, arr)
-obj.head(nil == f)
-obj.head(nil == nil, div, a)
-obj.head(nil == obj)
-obj.head(nil == s)
-obj.head(nil and false)
-obj.head(nil and true)
-obj.head(nil in arr, a)
-obj.head(nil in obj)
-obj.head(nil || true, b % a)
-obj.head(nil) != div
-obj.head(nil) != s
-obj.head(nil) == f / f
-obj.head(nil) in obj?.obj
-obj.head(nil)?.a
-obj.head(nil)?.a?.a
-obj.head(nil)?.b
-obj.head(nil)?.b.obj
-obj.head(nil)?.fn(div)
-obj.head(nil)?.fn(map(arr, arr))
-obj.head(nil)?.head(arr)
-obj.head(nil)?.head(f ^ b)
-obj.head(nil)?.obj
-obj.head(nil)?.obj.a
-obj.head(nil, "a", 0)?.obj
-obj.head(nil, "b")?.a
-obj.head(nil, "b")?.obj
-obj.head(nil, "c")?.head(arr)
-obj.head(nil, 0)?.b
-obj.head(nil, 0, nil)?.obj
-obj.head(nil, 0, obj, s)?.a
-obj.head(nil, 0, s)?.b
-obj.head(nil, 1)?.obj
-obj.head(nil, 1, arr)?.obj
-obj.head(nil, a)?.a.head(s, a)
-obj.head(nil, a)?.b
-obj.head(nil, a, 0)?.head(false or a)
-obj.head(nil, a, a, arr)?.b
-obj.head(nil, a, add)?.a
-obj.head(nil, a, arr)?.b
-obj.head(nil, a, b, true, a)?.b
-obj.head(nil, a, f)?.b
-obj.head(nil, add)?.b
-obj.head(nil, add)?.b?.a
-obj.head(nil, add, 2, ok) == ok
-obj.head(nil, add, a)?.obj
-obj.head(nil, add, b)?.a
-obj.head(nil, add, b)?.fn(a)
-obj.head(nil, add, b)?.obj
-obj.head(nil, arr) == arr
-obj.head(nil, arr)?.b
-obj.head(nil, arr)?.b.obj
-obj.head(nil, arr)?.obj
-obj.head(nil, arr, 0.5, obj, ok)?.b
-obj.head(nil, arr, arr)?.a
-obj.head(nil, arr, div)?.a
-obj.head(nil, arr, f)?.a
-obj.head(nil, b)?.a
-obj.head(nil, b)?.b?.obj
-obj.head(nil, b)?.obj
-obj.head(nil, b, 0, s, f)?.b
-obj.head(nil, b, div) in arr
-obj.head(nil, b, s)?.obj
-obj.head(nil, div) == f
-obj.head(nil, div)?.a
-obj.head(nil, div)?.b
-obj.head(nil, div, 0, b)?.b
-obj.head(nil, div, a)?.b
-obj.head(nil, div, nil, 1)?.obj
-obj.head(nil, f)?.a
-obj.head(nil, f)?.b.obj
-obj.head(nil, f)?.obj
-obj.head(nil, f, b, a)?.a?.b
-obj.head(nil, f, div)?.a
-obj.head(nil, f, div, arr)?.b
-obj.head(nil, f, f)?.a
-obj.head(nil, f, obj)?.a
-obj.head(nil, false)?.a
-obj.head(nil, false)?.b
-obj.head(nil, nil)?.b
-obj.head(nil, nil)?.obj
-obj.head(nil, nil, add)?.a
-obj.head(nil, nil, arr, nil, s)?.obj
-obj.head(nil, obj)?.a
-obj.head(nil, obj)?.b
-obj.head(nil, obj)?.obj
-obj.head(nil, obj, 1)?.b
-obj.head(nil, obj, f, div, a)?.b
-obj.head(nil, ok)?.a
-obj.head(nil, ok)?.b
-obj.head(nil, ok)?.obj
-obj.head(nil, ok, 0.5)?.a
-obj.head(nil, ok, f)?.head(ok)
-obj.head(nil, ok, ok)?.obj
-obj.head(nil, s)?.b
-obj.head(nil, s)?.obj
-obj.head(nil, s, a)?.b
-obj.head(nil, true)?.a
-obj.head(nil, true)?.b
-obj.head(nil, true, 0)?.a
-obj.head(nil, true, s)?.a
-obj.head(none("c", false))
-obj.head(none(arr, false))
-obj.head(none(arr, ok))
-obj.head(none(obj, false))
-obj.head(none(obj, ok))
-obj.head(none(s, false))
-obj.head(none(s, ok))
-obj.head(none(s, true))
-obj.head(none(s, true), a)
-obj.head(not (obj == obj))
-obj.head(not false)
-obj.head(not ok)
-obj.head(not true)
-obj.head(now("b"))
-obj.head(now("c"))
-obj.head(now(1, s, 0), add)
-obj.head(now(a))
-obj.head(now(add))
-obj.head(now(arr))
-obj.head(now(b))
-obj.head(now(b, nil))
-obj.head(now(div))
-obj.head(now(f))
-obj.head(now(f, a, s))
-obj.head(now(false, a, 0.5, arr))
-obj.head(now(nil))
-obj.head(now(nil, obj))
-obj.head(now(obj))
-obj.head(now(obj, div, ok, obj))
-obj.head(now(obj, ok))
-obj.head(now(ok))
-obj.head(now(ok, "b"))
-obj.head(obj != "a")
-obj.head(obj != 0)
-obj.head(obj != a)
-obj.head(obj != add)
-obj.head(obj != arr)
-obj.head(obj != b)
-obj.head(obj != div)
-obj.head(obj != f, filter("c", ok))
-obj.head(obj != obj)
-obj.head(obj != obj, b, true and 2)
-obj.head(obj != obj, get(add, a))
-obj.head(obj != ok)
-obj.head(obj != s)
-obj.head(obj && true)
-obj.head(obj == 0)
-obj.head(obj == 1)
-obj.head(obj == add)
-obj.head(obj == b)
-obj.head(obj == div)
-obj.head(obj == false)
-obj.head(obj == nil)
-obj.head(obj in nil)
-obj.head(obj or true)
-obj.head(obj)
-obj.head(obj) != a ? nil : 2
-obj.head(obj) != add
-obj.head(obj) == obj.a
-obj.head(obj) == s
-obj.head(obj).a
-obj.head(obj).b
-obj.head(obj).b * a
-obj.head(obj).fn(add(b, b))
-obj.head(obj).head(add)
-obj.head(obj).obj
-obj.head(obj).obj != obj
-obj.head(obj).obj.b
-obj.head(obj)?.a
-obj.head(obj)?.b
-obj.head(obj)?.fn(a)
-obj.head(obj)?.head(-0.5)
-obj.head(obj)?.head(arr)
-obj.head(obj)?.head(get(0.5 / f))
-obj.head(obj)?.head(last(ok, "b" contains "a"))
-obj.head(obj)?.head(s)
-obj.head(obj)?.obj
-obj.head(obj)?.obj == add
-obj.head(obj)?.obj.obj
-obj.head(obj)?.obj?.a
-obj.head(obj)?.obj?.obj
-obj.head(obj, "a").a
-obj.head(obj, "a")?.obj
-obj.head(obj, "a", add, arr, div)?.b
-obj.head(obj, "b" in arr)
-obj.head(obj, "b").b
-obj.head(obj, "b").obj
-obj.head(obj, "b")?.a
-obj.head(obj, "b", "b", arr)?.a
-obj.head(obj, "b", a).a
-obj.head(obj, "b", b)?.a
-obj.head(obj, "b", div, div, a).obj
-obj.head(obj, "c").obj
-obj.head(obj, "c")?.obj
-obj.head(obj, "c", obj)?.a
-obj.head(obj, 0 ** f)
-obj.head(obj, 0) == add
-obj.head(obj, 0).b
-obj.head(obj, 0).obj
-obj.head(obj, 0)?.a
-obj.head(obj, 0)?.b
-obj.head(obj, 0)?.obj
-obj.head(obj, 0, "b")?.a
-obj.head(obj, 0, "b")?.b
-obj.head(obj, 0, 0.5)?.obj?.obj?.b
-obj.head(obj, 0, 1, nil).obj
-obj.head(obj, 0, b).b
-obj.head(obj, 0, f, true).b
-obj.head(obj, 0, false)?.b
-obj.head(obj, 0, ok)?.obj
-obj.head(obj, 0, s)?.a
-obj.head(obj, 0.5 ^ b)
-obj.head(obj, 0.5).a
-obj.head(obj, 0.5).b
-obj.head(obj, 0.5).obj
-obj.head(obj, 0.5)?.a
-obj.head(obj, 0.5, "c")?.a
-obj.head(obj, 0.5, div)?.obj
-obj.head(obj, 0.5, obj).b
-obj.head(obj, 1).b
-obj.head(obj, 1).obj
-obj.head(obj, 1)?.a
-obj.head(obj, 1, a).obj?.obj?.a
-obj.head(obj, 1, false).obj
-obj.head(obj, 2, "a")?.b
-obj.head(obj, 2, true) != s
-obj.head(obj, a)
-obj.head(obj, a).a
-obj.head(obj, a).b
-obj.head(obj, a)?.b
-obj.head(obj, a)?.obj
-obj.head(obj, a, 0).a
-obj.head(obj, a, 1)?.b
-obj.head(obj, a, 2, a).b
-obj.head(obj, a, a).b
-obj.head(obj, a, a, false).b
-obj.head(obj, a, add, add, s).a
-obj.head(obj, a, add, s)?.obj
-obj.head(obj, a, arr).b
-obj.head(obj, a, ok, b)?.obj
-obj.head(obj, a, s, 2).obj
-obj.head(obj, add)
-obj.head(obj, add).a
-obj.head(obj, add).b
-obj.head(obj, add).obj
-obj.head(obj, add)?.a
-obj.head(obj, add)?.b
-obj.head(obj, add)?.head(div)
-obj.head(obj, add)?.obj
-obj.head(obj, add, "c", false, div).b
-obj.head(obj, add, 0, add).b
-obj.head(obj, add, obj)?.b
-obj.head(obj, add, ok, ok).a
-obj.head(obj, arr)
-obj.head(obj, arr).a
-obj.head(obj, arr).b
-obj.head(obj, arr)?.a
-obj.head(obj, arr)?.b
-obj.head(obj, arr, add)?.a
-obj.head(obj, arr, arr).obj
-obj.head(obj, arr, b).b
-obj.head(obj, arr, b)?.obj
-obj.head(obj, arr, b, obj, div)?.b
-obj.head(obj, arr, obj, add)?.b
-obj.head(obj, arr, ok).b
-obj.head(obj, arr, ok).obj
-obj.head(obj, arr, ok)?.obj
-obj.head(obj, arr, ok, 0).a
-obj.head(obj, arr, ok, arr).b
-obj.head(obj, arr, s, b, add)?.obj
-obj.head(obj, b)
-obj.head(obj, b).a
-obj.head(obj, b).b
-obj.head(obj, b).obj
-obj.head(obj, b)?.b
-obj.head(obj, b)?.obj
-obj.head(obj, b)?.obj?.obj
-obj.head(obj, b, add).obj
-obj.head(obj, b, b)?.a
-obj.head(obj, b, b, a).obj
-obj.head(obj, b, nil)?.obj
-obj.head(obj, b, true)?.b
-obj.head(obj, div)
-obj.head(obj, div).a
-obj.head(obj, div).obj
-obj.head(obj, div)?.a
-obj.head(obj, div)?.b
-obj.head(obj, div)?.head(div)
-obj.head(obj, div)?.obj
-obj.head(obj, div, "a", a).obj
-obj.head(obj, div, "b")?.a
-obj.head(obj, div, "b")?.b
-obj.head(obj, div, 0).a
-obj.head(obj, div, 0, ok).b
-obj.head(obj, div, arr, add)?.b
-obj.head(obj, div, f, div, add)?.obj
-obj.head(obj, div, f, obj, ok)?.obj
-obj.head(obj, div, obj)
-obj.head(obj, div, obj, a)?.obj
-obj.head(obj, div, s)
-obj.head(obj, f <= 0.5)?.a
-obj.head(obj, f)
-obj.head(obj, f).a
-obj.head(obj, f).b
-obj.head(obj, f).obj
-obj.head(obj, f)?.a
-obj.head(obj, f)?.b
-obj.head(obj, f, 2)?.head(arr)
-obj.head(obj, f, arr, a, "a").b
-obj.head(obj, f, f, true, s)?.obj
-obj.head(obj, f, obj).b
-obj.head(obj, f, obj)?.a
-obj.head(obj, false).a
-obj.head(obj, false).b
-obj.head(obj, false).obj
-obj.head(obj, false)?.a
-obj.head(obj, false, f).obj
-obj.head(obj, false, ok, f).obj
-obj.head(obj, false, s, ok).a
-obj.head(obj, get(arr, b), b < b).b
-obj.head(obj, get(ok, arr))
-obj.head(obj, last(add))
-obj.head(obj, map(obj, nil))
-obj.head(obj, nil).a
-obj.head(obj, nil).b
-obj.head(obj, nil)?.a
-obj.head(obj, nil)?.b
-obj.head(obj, nil)?.obj
-obj.head(obj, nil, 1)?.obj
-obj.head(obj, nil, a).b
-obj.head(obj, nil, arr)?.a
-obj.head(obj, nil, div).obj
-obj.head(obj, nil, obj).a
-obj.head(obj, not ok)
-obj.head(obj, obj)
-obj.head(obj, obj).b
-obj.head(obj, obj).obj
-obj.head(obj, obj)?.a
-obj.head(obj, obj)?.obj
-obj.head(obj, obj, arr).obj
-obj.head(obj, obj, b).a
-obj.head(obj, obj, b, ok, div).obj
-obj.head(obj, obj, div)
-obj.head(obj, obj, div)?.b
-obj.head(obj, obj, false)?.a
-obj.head(obj, obj, s)?.a
-obj.head(obj, obj.obj)
-obj.head(obj, ok in nil)
-obj.head(obj, ok or 0, s == "a", add, max("c"))
-obj.head(obj, ok)
-obj.head(obj, ok) and false ? 1 : arr
-obj.head(obj, ok).a
-obj.head(obj, ok).b
-obj.head(obj, ok)?.a
-obj.head(obj, ok)?.b
-obj.head(obj, ok)?.obj
-obj.head(obj, ok, "b")?.a
-obj.head(obj, ok, a)?.head(f)
-obj.head(obj, ok, add).obj
-obj.head(obj, ok, b).b
-obj.head(obj, ok, f)?.b
-obj.head(obj, ok, nil)?.a
-obj.head(obj, ok, obj)?.b
-obj.head(obj, ok, s)?.a
-obj.head(obj, ok, true, s)?.obj
-obj.head(obj, s)
-obj.head(obj, s).a
-obj.head(obj, s).b
-obj.head(obj, s)?.a
-obj.head(obj, s)?.b
-obj.head(obj, s)?.obj
-obj.head(obj, s, 0, nil).a
-obj.head(obj, s, 2, b)?.obj
-obj.head(obj, s, a)?.b
-obj.head(obj, s, b)?.a
-obj.head(obj, s, div, s)?.obj
-obj.head(obj, true != 0.5, add, abs(b))
-obj.head(obj, true) == obj?.b
-obj.head(obj, true).b
-obj.head(obj, true)?.obj
-obj.head(obj, true)[s]
-obj.head(obj, true, "a").b
-obj.head(obj, true, "a", div, true)?.a
-obj.head(obj.a)
-obj.head(obj.a, f && false)
-obj.head(obj.a, map(obj, "a"), obj)
-obj.head(obj.b)
-obj.head(obj.b, 0 == obj)
-obj.head(obj.b, 0.5 != nil)
-obj.head(obj.b, arr)
-obj.head(obj.b, false ? 0 : add)
-obj.head(obj.b, true ? arr : 0)
-obj.head(obj.fn(0))
-obj.head(obj.fn(a))
-obj.head(obj.fn(b))
-obj.head(obj.head(0))
-obj.head(obj.head(0, b, b, obj))
-obj.head(obj.head(0.5), string(f, a))
-obj.head(obj.head(1, ok, b, 0, div))
-obj.head(obj.head(a))
-obj.head(obj.head(a), arr)
-obj.head(obj.head(a, b))
-obj.head(obj.head(add))
-obj.head(obj.head(add, a, false))
-obj.head(obj.head(arr))
-obj.head(obj.head(arr), f)
-obj.head(obj.head(arr), ok)
-obj.head(obj.head(arr, 0.5))
-obj.head(obj.head(b, add))
-obj.head(obj.head(b, obj, ok))
-obj.head(obj.head(div))
-obj.head(obj.head(false))
-obj.head(obj.head(false, false, "a", "c", 2))
-obj.head(obj.head(nil))
-obj.head(obj.head(nil, b))
-obj.head(obj.head(nil, nil))
-obj.head(obj.head(obj))
-obj.head(obj.head(obj, s, a, s, add)).obj
-obj.head(obj.head(ok))
-obj.head(obj.head(ok, b))
-obj.head(obj.head(ok, s, 0))
-obj.head(obj.head(s))
-obj.head(obj.head(true))
-obj.head(obj.obj)
-obj.head(obj.obj)?.a
-obj.head(obj.obj)?.b
-obj.head(obj.obj, div, b)
-obj.head(obj.obj, f)
-obj.head(obj?.a)
-obj.head(obj?.a, first(div))
-obj.head(obj?.a, get(div, add))
-obj.head(obj?.a, ok)
-obj.head(obj?.b)
-obj.head(obj?.b, a)
-obj.head(obj?.b, div)
-obj.head(obj?.b, f)
-obj.head(obj?.b, get(0, div))
-obj.head(obj?.b, s)
-obj.head(obj?.c)
-obj.head(obj?.fn(1))
-obj.head(obj?.fn(a))
-obj.head(obj?.fn(b))
-obj.head(obj?.head("a", 1))
-obj.head(obj?.head("a", ok, 0.5, a))
-obj.head(obj?.head("b"))
-obj.head(obj?.head(0.5))
-obj.head(obj?.head(0.5), obj?.obj)
-obj.head(obj?.head(0.5, add))
-obj.head(obj?.head(1))
-obj.head(obj?.head(2))
-obj.head(obj?.head(2, f, 0.5, "b", b))
-obj.head(obj?.head(a))
-obj.head(obj?.head(a, f, obj, obj, nil))
-obj.head(obj?.head(add))
-obj.head(obj?.head(arr))
-obj.head(obj?.head(arr, true))
-obj.head(obj?.head(b))
-obj.head(obj?.head(b, a), a && true)
-obj.head(obj?.head(b, b))
-obj.head(obj?.head(div))
-obj.head(obj?.head(div), get(s, 1))
-obj.head(obj?.head(f), get(nil, a, "b"))
-obj.head(obj?.head(false))
-obj.head(obj?.head(false, arr))
-obj.head(obj?.head(false, false))
-obj.head(obj?.head(false, obj), b)
-obj.head(obj?.head(nil))
-obj.head(obj?.head(nil, a))
-obj.head(obj?.head(nil, true), a / f)
-obj.head(obj?.head(obj))
-obj.head(obj?.head(obj).head(arr))
-obj.head(obj?.head(obj, div, obj))
-obj.head(obj?.head(ok))
-obj.head(obj?.head(ok, "b", true, b, f))
-obj.head(obj?.head(ok, b, false))
-obj.head(obj?.head(ok, ok, ok))
-obj.head(obj?.head(s))
-obj.head(obj?.head(s, "b"), b, a)
-obj.head(obj?.head(true, ok))
-obj.head(obj?.obj)
-obj.head(obj?.obj).a
-obj.head(obj?.obj).obj
-obj.head(obj?.obj)?.obj
-obj.head(obj?.obj, add != nil)
-obj.head(obj?.obj, b)
-obj.head(obj?.obj, obj?.obj)
-obj.head(obj[s])?.obj
-obj.head(ok != "b", obj.a)
-obj.head(ok != 0)
-obj.head(ok != add)
-obj.head(ok != arr)
-obj.head(ok != f)
-obj.head(ok != nil)
-obj.head(ok != obj)
-obj.head(ok != ok)
-obj.head(ok != s)
-obj.head(ok != true)
-obj.head(ok && "c")
-obj.head(ok && "c", ok)
-obj.head(ok && 0)
-obj.head(ok && 0, s)
-obj.head(ok && 0.5)
-obj.head(ok && a)
-obj.head(ok && add)
-obj.head(ok && add, div)
-obj.head(ok && arr)
-obj.head(ok && arr, a ^ 0, add)
-obj.head(ok && b)
-obj.head(ok && div)
-obj.head(ok && f)
-obj.head(ok && false)
-obj.head(ok && nil)
-obj.head(ok && s)
-obj.head(ok && true)
-obj.head(ok == 0)
-obj.head(ok == 0.5)
-obj.head(ok == 2, a / 0.5)
-obj.head(ok == a)
-obj.head(ok == add)
-obj.head(ok == arr)
-obj.head(ok == b)
-obj.head(ok == f)
-obj.head(ok == false)
-obj.head(ok == ok)
-obj.head(ok == s)
-obj.head(ok ? 0 : add)
-obj.head(ok ? 2 : s)
-obj.head(ok ? add : 0)
-obj.head(ok ? arr : false)
-obj.head(ok ? arr : ok)
-obj.head(ok ? b : f)
-obj.head(ok ? b : nil)
-obj.head(ok ? div : 0)
-obj.head(ok ? obj : s)
-obj.head(ok ? ok : obj)
-obj.head(ok ? ok : s)
-obj.head(ok ? s : add)
-obj.head(ok and a) == obj
-obj.head(ok and add)
-obj.head(ok and arr)
-obj.head(ok and div)
-obj.head(ok and f)
-obj.head(ok and obj)
-obj.head(ok and true)
-obj.head(ok in map("b", nil))
-obj.head(ok or "a")
-obj.head(ok or "c")
-obj.head(ok or 0)
-obj.head(ok or 1)
-obj.head(ok or a)
-obj.head(ok or add)
-obj.head(ok or div)
-obj.head(ok or false)
-obj.head(ok or int(a)?.a?.b)
-obj.head(ok or obj)
-obj.head(ok or ok)
-obj.head(ok or s, get(0, nil))
-obj.head(ok || "a")
-obj.head(ok || a)
-obj.head(ok || add)
-obj.head(ok || arr)
-obj.head(ok || arr, any(obj, ok), b)
-obj.head(ok || div)
-obj.head(ok || f)
-obj.head(ok || nil)
-obj.head(ok || ok)
-obj.head(ok || s)
-obj.head(ok)
-obj.head(ok) != add
-obj.head(ok) != arr
-obj.head(ok) != f
-obj.head(ok) != obj.a
-obj.head(ok) && obj.a
-obj.head(ok) == add
-obj.head(ok) == string(a)
-obj.head(ok) ? arr : ok
-obj.head(ok) or !false
-obj.head(ok) or ok
-obj.head(ok, 1) == obj?.a
-obj.head(ok, 2, 0) != ok
-obj.head(ok, a + a)
-obj.head(ok, a <= a)
-obj.head(ok, a) == obj
-obj.head(ok, add)
-obj.head(ok, add) && obj.b
-obj.head(ok, arr, "a") or f != nil
-obj.head(ok, div)
-obj.head(ok, div) || obj.a.head(ok, a.head(nil, div) < false < "c", add)
-obj.head(ok, f != "a")
-obj.head(ok, f)
-obj.head(ok, false) == add(1, 1)
-obj.head(ok, get(a, obj))
-obj.head(ok, get(nil, a))
-obj.head(ok, map(obj, f))
-obj.head(ok, obj)
-obj.head(ok, obj.head(f))
-obj.head(ok, obj.obj)
-obj.head(ok, ok, div)
-obj.head(ok, s && false)
-obj.head(ok, s)
-obj.head(ok, s, add)
-obj.head(one("c", ok))
-obj.head(one(obj, ok))
-obj.head(one(s, false))
-obj.head(one(s, ok))
-obj.head(repeat("b", b))
-obj.head(repeat(s, 0))
-obj.head(s != "c")
-obj.head(s != 2, 0 .. b)
-obj.head(s != add, f ^ 0)
-obj.head(s != arr)
-obj.head(s != false)
-obj.head(s != obj)
-obj.head(s != ok)
-obj.head(s != s)
-obj.head(s + "a")
-obj.head(s + s)
-obj.head(s < "b")
-obj.head(s < s)
-obj.head(s <= "b", arr)
-obj.head(s <= s)
-obj.head(s == a)
-obj.head(s == arr)
-obj.head(s == b)
-obj.head(s == div)
-obj.head(s == f, a)
-obj.head(s == false)
-obj.head(s == ok)
-obj.head(s == true)
-obj.head(s > "b")
-obj.head(s >= "c")
-obj.head(s and false)
-obj.head(s contains s)
-obj.head(s contains s, obj.a)
-obj.head(s matches "b")
-obj.head(s matches "c")
-obj.head(s startsWith s)
-obj.head(s)
-obj.head(s) != "a" ? ok : s
-obj.head(s) != a
-obj.head(s) != obj?.obj
-obj.head(s) != string(b)
-obj.head(s) != true ? f : true
-obj.head(s) == 0 .. b
-obj.head(s) == div
-obj.head(s) == div != ok
-obj.head(s) == f
-obj.head(s) == nil ? arr : 0
-obj.head(s) == obj
-obj.head(s) in obj
-obj.head(s) in obj.obj
-obj.head(s) matches s ? obj : b
-obj.head(s) or false and ok
-obj.head(s)[a]
-obj.head(s)[obj?.b]
-obj.head(s, "a" == "a")
-obj.head(s, 0) <= s
-obj.head(s, 0, nil, a) <= s
-obj.head(s, 0.5 ** 1)
-obj.head(s, 0.5, 0.5) >= s
-obj.head(s, 2)[obj?.a]
-obj.head(s, a + f)
-obj.head(s, a)
-obj.head(s, all(arr, true), 0.5 * 0.5)
-obj.head(s, b ^ 0)
-obj.head(s, b)
-obj.head(s, b) == div
-obj.head(s, div)
-obj.head(s, f * b)
-obj.head(s, f == obj)
-obj.head(s, f)
-obj.head(s, f, obj)
-obj.head(s, false and nil)
-obj.head(s, false, true)[b]
-obj.head(s, get("a", obj), s != f)
-obj.head(s, nil != arr, ok)
-obj.head(s, now(add))
-obj.head(s, now(nil))
-obj.head(s, obj == arr)
-obj.head(s, obj)
-obj.head(s, ok, a)
-obj.head(s, s)
-obj.head(s, s) != obj.a
-obj.head(s[0])
-obj.head(s[a:1])
-obj.head(s[f])
-obj.head(splitAfter("c", "c"))
-obj.head(string("a"), obj, a)
-obj.head(string("c", ok, ok))
-obj.head(string(0, ok))
-obj.head(string(0.5, "a", b))
-obj.head(string(1))
-obj.head(string(2, nil))
-obj.head(string(a))
-obj.head(string(a, nil))
-obj.head(string(add))
-obj.head(string(add, a, arr, f))
-obj.head(string(arr))
-obj.head(string(arr, b, f, s, f))
-obj.head(string(arr, obj, s, arr), all("c", ok))
-obj.head(string(b))
-obj.head(string(b, arr))
-obj.head(string(div))
-obj.head(string(div), ok == 1)
-obj.head(string(f, ok))
-obj.head(string(obj, false))
-obj.head(string(ok))
-obj.head(string(ok, true))
-obj.head(string(s))
-obj.head(string(s), div)
-obj.head(string(s, 0, obj))
-obj.head(string(true, div, obj, b))
-obj.head(toBase64("a", "b"))
-obj.head(toBase64("c"))
-obj.head(toBase64("c", b, a))
-obj.head(toBase64(s))
-obj.head(toJSON("a"))
-obj.head(toJSON("b"))
-obj.head(toJSON("b"), obj)
-obj.head(toJSON("c"))
-obj.head(toJSON("c", s))
-obj.head(toJSON(0))
-obj.head(toJSON(0, 0.5))
-obj.head(toJSON(0.5 < a))
-obj.head(toJSON(0.5))
-obj.head(toJSON(0.5, f, arr))
-obj.head(toJSON(1, ok, arr))
-obj.head(toJSON(2), f, 0.5 < f)
-obj.head(toJSON(a, f, 0, f))
-obj.head(toJSON(arr))
-obj.head(toJSON(b, add, ok))
-obj.head(toJSON(b, f, b))
-obj.head(toJSON(f))
-obj.head(toJSON(f, "b"))
-obj.head(toJSON(f, add, nil, obj))
-obj.head(toJSON(f, div))
-obj.head(toJSON(false), ok)
-obj.head(toJSON(false, f))
-obj.head(toJSON(nil))
-obj.head(toJSON(nil, div))
-obj.head(toJSON(ok))
-obj.head(toJSON(ok, obj, f))
-obj.head(toJSON(s, nil, ok))
-obj.head(toJSON(true), string(nil))
-obj.head(trim(s))
-obj.head(trimPrefix("c"))
-obj.head(trimPrefix(s), s)
-obj.head(trimSuffix("b"))
-obj.head(trimSuffix("c"))
-obj.head(trimSuffix(s))
-obj.head(true != 0)
-obj.head(true != add)
-obj.head(true != add, b == false)
-obj.head(true != div)
-obj.head(true != f, a)
-obj.head(true != obj)
-obj.head(true != ok, string(false, b, b, arr))
-obj.head(true && a) != f
-obj.head(true && add, get(nil, ok))
-obj.head(true && ok)
-obj.head(true && s)
-obj.head(true == "a")
-obj.head(true == 0.5)
-obj.head(true == a)
-obj.head(true == arr, ok)
-obj.head(true == f)
-obj.head(true == nil)
-obj.head(true ? add : false)
-obj.head(true ? arr : b)
-obj.head(true ? b : ok startsWith add.fn(true))
-obj.head(true ? div : arr, b)
-obj.head(true ? f : "b", s)
-obj.head(true ? obj : f)
-obj.head(true ? obj : nil)
-obj.head(true ? s : "a")
-obj.head(true and a)
-obj.head(true and arr)
-obj.head(true and b, s)
-obj.head(true and div)
-obj.head(true and nil)
-obj.head(true and obj)
-obj.head(true in arr)
-obj.head(true in nil)
-obj.head(true or 0)
-obj.head(true or 1, b)
-obj.head(true or a)
-obj.head(true or arr)
-obj.head(true or b)
-obj.head(true or obj)
-obj.head(true or ok)
-obj.head(true || arr)
-obj.head(true || obj)
-obj.head(true) != b
-obj.head(true) != obj
-obj.head(true) && obj?.obj?.b
-obj.head(true) == f
-obj.head(true, 0) or ok
-obj.head(true, add) or obj.b
-obj.head(true, add, b) && ok
-obj.head(true, div) || 0 == f
-obj.head(true, f) == s
-obj.head(upper("b"), b)
-obj.head(upper("c"))
-obj.head(upper("c"), b)
-obj.head(upper(a, "c"))
-obj.head(upper(s))
-obj.head(upper(s, a, 0.5, s))
-obj.head(upper(true, "a"))
-obj.head(values(obj))
-obj.head({"a": add})
-obj.head({"b": add, "b": b, "c": s})
-obj.obj
-obj.obj != 2 % 1
-obj.obj != a
-obj.obj != a / 1
-obj.obj != a == true
-obj.obj != a ? f : true
-obj.obj != add
-obj.obj != add(a, a)
-obj.obj != any(arr, true)
-obj.obj != arr
-obj.obj != arr ? false : b
-obj.obj != b
-obj.obj != b .. b
-obj.obj != b ? a : s
-obj.obj != div
-obj.obj != div(b, b)
-obj.obj != f
-obj.obj != f != nil
-obj.obj != f / f
-obj.obj != float(b)
-obj.obj != min(b)
-obj.obj != obj
-obj.obj != obj.a
-obj.obj != obj.head(0)
-obj.obj != obj?.a
-obj.obj != obj?.b
-obj.obj != ok
-obj.obj != s
-obj.obj != string(0.5)
-obj.obj != string(2)
-obj.obj && !false
-obj.obj == -b
-obj.obj == 0 == nil ? get(arr, a) : ok
-obj.obj == 2 ** f
-obj.obj == a
-obj.obj == a ** f
-obj.obj == add
-obj.obj == add ? arr : obj
-obj.obj == add ? div : "c"
-obj.obj == add(a, 0)
-obj.obj == any(arr, false)
-obj.obj == arr
-obj.obj == b
-obj.obj == div
-obj.obj == div != ok
-obj.obj == f
-obj.obj == f == ok
-obj.obj == f ? div : 0.5
-obj.obj == none(arr, ok)
-obj.obj == not true
-obj.obj == obj
-obj.obj == obj.obj
-obj.obj == obj.obj?.obj
-obj.obj == obj?.b
-obj.obj == obj?.head(0, ok)
-obj.obj == ok
-obj.obj == ok == ok
-obj.obj == s
-obj.obj == true ? 1 : a
-obj.obj == true ? nil : "a"
-obj.obj in arr
-obj.obj in map(arr, "a")
-obj.obj or "b" == "a"
-obj.obj or false and obj?.b?.b
-obj.obj.a
-obj.obj.a != b
-obj.obj.a ** a
-obj.obj.b
-obj.obj.b ** b
-obj.obj.b .. b
-obj.obj.b < b
-obj.obj.b ^ -f ^ -f
-obj.obj.obj
-obj.obj.obj.a
-obj.obj.obj.b
-obj.obj.obj.obj
-obj.obj.obj?.a
-obj.obj.obj?.b
-obj.obj.obj?.obj
-obj.obj?.a
-obj.obj?.a ** f
-obj.obj?.a == arr
-obj.obj?.b
-obj.obj?.b != add
-obj.obj?.b * f
-obj.obj?.obj
-obj.obj?.obj != b
-obj.obj?.obj.a
-obj.obj?.obj.b
-obj.obj?.obj.obj
-obj.obj?.obj?.a
-obj.obj?.obj?.b
-obj.obj?.obj?.obj
-obj.obj?.obj[s]
-obj.obj[obj.head(nil)]
-obj.obj[s]
-obj.obj[toJSON(s)]
-obj.obj[trimPrefix(s)]
-obj?.a
-obj?.a != (ok and ok)
-obj?.a != a
-obj?.a != add
-obj?.a != arr
-obj?.a != b
-obj?.a != div
-obj?.a != f
-obj?.a != f ** a
-obj?.a != obj
-obj?.a != obj.head(s, div, "b", 1)
-obj?.a != obj.obj
-obj?.a != obj?.a
-obj?.a != obj?.b
-obj?.a != ok
-obj?.a != ok ? b : arr
-obj?.a != s
-obj?.a != s != false
-obj?.a != toJSON(arr)
-obj?.a != trimPrefix("a")
-obj?.a % a
-obj?.a % b
-obj?.a % obj.a
-obj?.a % obj?.b
-obj?.a * -0.5
-obj?.a * a
-obj?.a * arr[a]
-obj?.a * b
-obj?.a * f
-obj?.a * min(f, f)
-obj?.a * obj.a
-obj?.a ** a
-obj?.a ** abs(0)
-obj?.a ** add(b, 0)
-obj?.a ** b
-obj?.a ** f
-obj?.a ** obj?.head(f, ok)
-obj?.a + a
-obj?.a + abs(a)
-obj?.a + add(0, 0)
-obj?.a + arr[b]
-obj?.a + b
-obj?.a + f
-obj?.a + f ** a
-obj?.a + obj.a
-obj?.a + obj?.a
-obj?.a + obj?.b
-obj?.a - 0 % 1
-obj?.a - 0 * 0
-obj?.a - 0 * 0.5
-obj?.a - 0 * 2
-obj?.a - a
-obj?.a - b
-obj?.a - f
-obj?.a - obj.b
-obj?.a - obj?.a
-obj?.a .. a
-obj?.a .. b
-obj?.a .. count(arr, true)
-obj?.a .. div(b, 2)
-obj?.a .. obj.b
-obj?.a .. obj?.a
-obj?.a / (b + f)
-obj?.a / a
-obj?.a / b
-obj?.a / b ** f
-obj?.a / f
-obj?.a / obj.head(b, a)
-obj?.a / obj?.b
-obj?.a < a
-obj?.a < a ? "c" : add
-obj?.a < a ? s : false
-obj?.a < b
-obj?.a < f
-obj?.a < float(b)
-obj?.a < obj.a
-obj?.a < obj?.a
-obj?.a <= 0 * 0.5
-obj?.a <= 0 == false
-obj?.a <= 2 ? b : ok
-obj?.a <= a
-obj?.a <= a + f
-obj?.a <= b
-obj?.a <= b + a
-obj?.a <= count(arr, ok)
-obj?.a <= div(b, a)
-obj?.a <= f
-obj?.a <= f ^ f
-obj?.a <= len(arr)
-obj?.a <= obj.head(0.5, add, false, nil)
-obj?.a <= obj?.b
-obj?.a == -1
-obj?.a == 0.5 ^ a
-obj?.a == a
-obj?.a == a ** f
-obj?.a == add
-obj?.a == arr
-obj?.a == b
-obj?.a == b ? ok : obj
-obj?.a == count(arr, ok)
-obj?.a == div
-obj?.a == div ? 2 : true
-obj?.a == div ? b : div
-obj?.a == div ? s : b
-obj?.a == f
-obj?.a == f != ok
-obj?.a == f ^ 0.5
-obj?.a == min(2, 0)
-obj?.a == nil ? 0 : a
-obj?.a == obj
-obj?.a == ok
-obj?.a == s
-obj?.a == toJSON(s)
-obj?.a > -1
-obj?.a > 1 ? 2 : 0.5
-obj?.a > a
-obj?.a > a ^ f
-obj?.a > b
-obj?.a > b + a
-obj?.a > b ? "b" : obj.a
-obj?.a > f
-obj?.a > f * b
-obj?.a > get(arr, 0)
-obj?.a > obj.a
-obj?.a > obj?.a
-obj?.a > obj?.b
-obj?.a >= 0 != nil
-obj?.a >= 0 * 0
-obj?.a >= 2 != nil
-obj?.a >= 2 / a
-obj?.a >= a
-obj?.a >= b
-obj?.a >= div(b, a)
-obj?.a >= f
-obj?.a >= f ? true : a == obj?.a?.a
-obj?.a >= obj.a
-obj?.a >= obj.b
-obj?.a >= obj.head(2, obj)
-obj?.a >= obj?.a
-obj?.a >= obj?.head(f, f)
-obj?.a ^ (b * 1)
-obj?.a ^ -b
-obj?.a ^ a
-obj?.a ^ arr[b]
-obj?.a ^ b
-obj?.a ^ f
-obj?.a ^ len(s)
-obj?.a ^ obj.a
-obj?.a ^ obj?.a
-obj?.a ^ obj?.b
-obj?.a ^ obj?.head(b, "c", 1)
-obj?.a in arr
-obj?.a in values(obj)
-obj?.a || !true
-obj?.a || not false
-obj?.b
-obj?.b != "a" ? f : false
-obj?.b != "a" ? nil : nil
-obj?.b != 0 ** f
-obj?.b != 0.5 + b
-obj?.b != 2 * b
-obj?.b != a
-obj?.b != a ? a : add
-obj?.b != a ? false : b
-obj?.b != add
-obj?.b != add == nil
-obj?.b != add ? 0 : "a"
-obj?.b != arr
-obj?.b != arr[a]
-obj?.b != b
-obj?.b != b ** 0
-obj?.b != div
-obj?.b != div ? div : 2
-obj?.b != f
-obj?.b != float(b)
-obj?.b != map(arr, a)
-obj?.b != map(arr, arr)
-obj?.b != max(0)
-obj?.b != min(a)
-obj?.b != obj
-obj?.b != obj.head(b, b)
-obj?.b != obj.obj
-obj?.b != obj?.a
-obj?.b != ok
-obj?.b != s
-obj?.b != toBase64(s)
-obj?.b % -a
-obj?.b % a
-obj?.b % b
-obj?.b % get(arr, 2)
-obj?.b % obj.a
-obj?.b % obj.head(a, f, arr)
-obj?.b % obj?.a
-obj?.b % obj?.head(1)
-obj?.b * (a + a)
-obj?.b * (f + b)
-obj?.b * 0 ^ f
-obj?.b * a
-obj?.b * a ** b
-obj?.b * a / f
-obj?.b * b
-obj?.b * div(b, a)
-obj?.b * f
-obj?.b * float(b)
-obj?.b * obj.a
-obj?.b * obj.head(2, add)
-obj?.b * obj.head(b, 0)
-obj?.b * obj?.b
-obj?.b ** (0 + b)
-obj?.b ** (b + b)
-obj?.b ** a
-obj?.b ** add(a, 0)
-obj?.b ** b
-obj?.b ** b ^ 0.5
-obj?.b ** f
-obj?.b ** max(0)
-obj?.b ** obj.a
-obj?.b ** obj.b
-obj?.b ** obj.head(a)
-obj?.b ** obj?.a
-obj?.b + a
-obj?.b + add(b, 2)
-obj?.b + b
-obj?.b + b * f
-obj?.b + div(a, 2)
-obj?.b + obj.a
-obj?.b + obj.b
-obj?.b + obj?.b
-obj?.b - -a
-obj?.b - 0 * 0
-obj?.b - 0 + a
-obj?.b - 0 ^ b
-obj?.b - a
-obj?.b - a + a
-obj?.b - b
-obj?.b - b - 1
-obj?.b - f
-obj?.b - f ** a
-obj?.b - obj.a
-obj?.b - obj.b
-obj?.b - obj?.a
-obj?.b .. 2 - 0
-obj?.b .. a
-obj?.b .. add(b, a)
-obj?.b .. b
-obj?.b .. obj.b
-obj?.b .. obj?.a
-obj?.b .. obj?.b
-obj?.b .. obj?.fn(a)
-obj?.b / (0 - b)
-obj?.b / 0 * f
-obj?.b / 0.5 ** b
-obj?.b / a
-obj?.b / b
-obj?.b / count(arr, ok)
-obj?.b / div(a, b)
-obj?.b / f
-obj?.b / get(arr, 0)
-obj?.b / obj.b
-obj?.b / obj?.a
-obj?.b / obj?.b
-obj?.b < 0 != ok
-obj?.b < 1 + 2
-obj?.b < 1 - a
-obj?.b < a
-obj?.b < add(b, 0)
-obj?.b < b
-obj?.b < b != ok
-obj?.b < f
-obj?.b < f * b
-obj?.b < obj?.b
-obj?.b <= -a
-obj?.b <= a
-obj?.b <= add(0, 1)
-obj?.b <= b
-obj?.b <= f
-obj?.b <= f + b
-obj?.b <= f / 2
-obj?.b <= f / b
-obj?.b <= obj?.b
-obj?.b == !false
-obj?.b == 0 * a
-obj?.b == 1 .. 0
-obj?.b == a
-obj?.b == a + f
-obj?.b == add
-obj?.b == arr
-obj?.b == arr ? add : s
-obj?.b == b
-obj?.b == b - a
-obj?.b == div
-obj?.b == f
-obj?.b == obj
-obj?.b == obj.obj
-obj?.b == obj?.b
-obj?.b == obj?.obj
-obj?.b == ok
-obj?.b == s
-obj?.b == s == nil
-obj?.b == s == ok
-obj?.b == s ? 0.5 : "a"
-obj?.b == s ? add : obj
-obj?.b == upper("c")
-obj?.b > 0 * a
-obj?.b > a
-obj?.b > b
-obj?.b > b ^ 0
-obj?.b > f
-obj?.b > max(1)
-obj?.b > min(0.5)
-obj?.b >= -a
-obj?.b >= 0 ** a
-obj?.b >= 0.5 != true
-obj?.b >= 0.5 ? div : arr
-obj?.b >= a
-obj?.b >= b
-obj?.b >= b + 0
-obj?.b >= b + b
-obj?.b >= div(b, 1)
-obj?.b >= f
-obj?.b >= max(f, f)
-obj?.b >= obj.a
-obj?.b >= obj.head(a, arr, add)
-obj?.b >= obj?.b
-obj?.b ^ (0 * f)
-obj?.b ^ -b
-obj?.b ^ a
-obj?.b ^ arr[2]
-obj?.b ^ b
-obj?.b ^ f
-obj?.b ^ int(f)
-obj?.b ^ obj.a
-obj?.b ^ obj.head(0)
-obj?.b ^ obj?.head(obj, obj, a).a
-obj?.b and (true || false)
-obj?.b in arr
-obj?.b in arr ? arr : a
-obj?.b in map(arr, true)
-obj?.c != div
-obj?.c != obj
-obj?.c?.a
-obj?.c?.a?.b
-obj?.c?.b
-obj?.c?.b.obj
-obj?.c?.fn(div)
-obj?.c?.obj
-obj?.c?.obj.b
-obj?.fn(-0)
-obj?.fn(-1)
-obj?.fn(-2)
-obj?.fn(-a)
-obj?.fn(-b)
-obj?.fn(0 % a)
-obj?.fn(0 * a)
-obj?.fn(0 + 0)
-obj?.fn(0 + a)
-obj?.fn(0 + b)
-obj?.fn(0 - 0)
-obj?.fn(0 - b)
-obj?.fn(0 or false)
-obj?.fn(0) != a
-obj?.fn(0) != ok
-obj?.fn(0) != {"b": 1, "a": div}
-obj?.fn(0) ** f
-obj?.fn(0) + b
-obj?.fn(0) / b
-obj?.fn(0) == a
-obj?.fn(0) == add
-obj?.fn(0) == obj
-obj?.fn(0) >= b
-obj?.fn(0) ^ b
-obj?.fn(0) ^ obj?.a
-obj?.fn(1 % a)
-obj?.fn(1 * b)
-obj?.fn(1 + 0)
-obj?.fn(1 + a)
-obj?.fn(1 - b)
-obj?.fn(1) != string(f)
-obj?.fn(1) * f / b
-obj?.fn(1) / b
-obj?.fn(1) < obj.head(0.5, s)
-obj?.fn(1) < obj?.head(a)
-obj?.fn(2 - 0)
-obj?.fn(2 - b)
-obj?.fn(2) % a
-obj?.fn(2) - obj.head(0.5, 0, b, 0.5)
-obj?.fn(2) <= a
-obj?.fn(2) == arr ? obj : b
-obj?.fn(a % 2)
-obj?.fn(a % a)
-obj?.fn(a % b)
-obj?.fn(a * 0)
-obj?.fn(a * 1)
-obj?.fn(a * 2)
-obj?.fn(a * a)
-obj?.fn(a + 2)
-obj?.fn(a + a)
-obj?.fn(a + b)
-obj?.fn(a - 1)
-obj?.fn(a - 2)
-obj?.fn(a - b)
-obj?.fn(a || false)
-obj?.fn(a)
-obj?.fn(a) != 0 .. b
-obj?.fn(a) != arr
-obj?.fn(a) != b
-obj?.fn(a) != div
-obj?.fn(a) != toBase64(s)
-obj?.fn(a) - 0.5 ** f
-obj?.fn(a) .. b
-obj?.fn(a) / a
-obj?.fn(a) == add
-obj?.fn(a) == s
-obj?.fn(a) > b
-obj?.fn(a) > obj.a
-obj?.fn(a) >= a
-obj?.fn(a) ^ a
-obj?.fn(a) || ok || true
-obj?.fn(abs(0.5, div, a))
-obj?.fn(abs(2))
-obj?.fn(abs(a))
-obj?.fn(abs(add, b, "b", a))
-obj?.fn(abs(arr, a))
-obj?.fn(abs(b))
-obj?.fn(abs(s, a))
-obj?.fn(add(0, 1))
-obj?.fn(add(0, b))
-obj?.fn(add(1, 0))
-obj?.fn(add(1, 2))
-obj?.fn(add(2, a))
-obj?.fn(add(2, b))
-obj?.fn(add(a, 0))
-obj?.fn(add(a, 2))
-obj?.fn(add(a, b))
-obj?.fn(add(b, a))
-obj?.fn(add(b, b))
-obj?.fn(arr[0.5])
-obj?.fn(arr[1])
-obj?.fn(arr[b])
-obj?.fn(arr[f])
-obj?.fn(b % 2)
-obj?.fn(b % a)
-obj?.fn(b && true)
-obj?.fn(b * b)
-obj?.fn(b + 0)
-obj?.fn(b + a)
-obj?.fn(b + b)
-obj?.fn(b - a)
-obj?.fn(b - b)
-obj?.fn(b)
-obj?.fn(b) != (false and ok)
-obj?.fn(b) != obj
-obj?.fn(b) != ok
-obj?.fn(b) != string("c")
-obj?.fn(b) * obj.obj?.a
-obj?.fn(b) - a
-obj?.fn(b) - f
-obj?.fn(b) - obj.b
-obj?.fn(b) .. b
-obj?.fn(b) < a
-obj?.fn(b) < b
-obj?.fn(b) == obj
-obj?.fn(b) > div(b, a)
-obj?.fn(b) ^ a
-obj?.fn(b) ^ b
-obj?.fn(b) in arr
-obj?.fn(count("a", false))
-obj?.fn(count("a", true))
-obj?.fn(count(arr, false))
-obj?.fn(count(arr, ok))
-obj?.fn(count(obj, false))
-obj?.fn(count(s, ok))
-obj?.fn(count(s, true))
-obj?.fn(div(0, 1))
-obj?.fn(div(0, b))
-obj?.fn(div(1, a))
-obj?.fn(div(2, 1))
-obj?.fn(div(2, a))
-obj?.fn(div(2, b))
-obj?.fn(div(a, 1))
-obj?.fn(div(a, a))
-obj?.fn(div(a, b))
-obj?.fn(div(b, 1))
-obj?.fn(div(b, 2))
-obj?.fn(div(b, a))
-obj?.fn(div(b, b))
-obj?.fn(false ? false : a)
-obj?.fn(false or 2)
-obj?.fn(false || 0)
-obj?.fn(get(arr, 0))
-obj?.fn(get(arr, 1))
-obj?.fn(get(arr, 2))
-obj?.fn(get(arr, a))
-obj?.fn(get(arr, b))
-obj?.fn(get(arr, f))
-obj?.fn(get(obj, "b"))
-obj?.fn(int(0))
-obj?.fn(int(0.5))
-obj?.fn(int(2))
-obj?.fn(int(a))
-obj?.fn(int(a, nil, 0))
-obj?.fn(int(add, b))
-obj?.fn(int(b))
-obj?.fn(int(b, 1))
-obj?.fn(int(f))
-obj?.fn(int(f, a, s, a))
-obj?.fn(int(ok, ok, 0))
-obj?.fn(int(s, "c", 0.5))
-obj?.fn(last(arr))
-obj?.fn(last(arr, 0.5))
-obj?.fn(len(0, f, obj, nil, "c"))
-obj?.fn(len(arr))
-obj?.fn(len(f, arr, obj))
-obj?.fn(len(obj))
-obj?.fn(len(ok, s))
-obj?.fn(max(0))
-obj?.fn(max(a))
-obj?.fn(max(b, a))
-obj?.fn(min(0))
-obj?.fn(min(2))
-obj?.fn(min(a))
-obj?.fn(obj.a)
-obj?.fn(obj.b)
-obj?.fn(obj.fn(1))
-obj?.fn(obj.head(0))
-obj?.fn(obj.head(0, nil))
-obj?.fn(obj.head(2, f, 0))
-obj?.fn(obj.head(a))
-obj?.fn(obj.head(a, arr))
-obj?.fn(obj.head(b))
-obj?.fn(obj.head(b, nil, 2))
-obj?.fn(obj.head(b, true))
-obj?.fn(obj.obj?.b)
-obj?.fn(obj?.a)
-obj?.fn(obj?.a) == b
-obj?.fn(obj?.b)
-obj?.fn(obj?.fn(0))
-obj?.fn(obj?.fn(1))
-obj?.fn(obj?.fn(2))
-obj?.fn(obj?.fn(a))
-obj?.fn(obj?.fn(b))
-obj?.fn(obj?.head(0))
-obj?.fn(obj?.head(0, arr))
-obj?.fn(obj?.head(0, s))
-obj?.fn(obj?.head(a))
-obj?.fn(obj?.head(a, 0, nil))
-obj?.fn(obj?.head(a, arr))
-obj?.fn(obj?.head(a, div, add))
-obj?.fn(obj?.head(b, 2))
-obj?.fn(obj?.head(b, add))
-obj?.fn(obj?.head(b, add, b))
-obj?.fn(obj?.head(b, add, nil))
-obj?.fn(obj?.obj.a)
-obj?.fn(ok ? 2 : 0)
-obj?.fn(ok ? b : obj)
-obj?.fn(ok and 1)
-obj?.fn(ok and a)
-obj?.fn(ok and b)
-obj?.fn(ok) and not true
-obj?.fn(true && 0)
-obj?.fn(true and 0)
-obj?.fn(true and a)
-obj?.head(!(add == arr))
-obj?.head(!false)
-obj?.head(!ok)
-obj?.head(!true)
-obj?.head("a" != 2)
-obj?.head("a" != arr)
-obj?.head("a" != b)
-obj?.head("a" != false)
-obj?.head("a" != true)
-obj?.head("a" < "b")
-obj?.head("a" == add)
-obj?.head("a" == arr, div)
-obj?.head("a" == false)
-obj?.head("a" > "b")
-obj?.head("a" > s)
-obj?.head("a" matches "c")
-obj?.head("a" startsWith "a")
-obj?.head("a" startsWith "b")
-obj?.head("a") <= s
-obj?.head("a") == arr
-obj?.head("a") > s
-obj?.head("a") contains s
-obj?.head("a") in 0 .. a
-obj?.head("a") in obj.obj
-obj?.head("a", 0) == b ** 0
-obj?.head("a", a) != arr ? s : false
-obj?.head("b" != "c")
-obj?.head("b" != 0)
-obj?.head("b" != 1)
-obj?.head("b" != 2)
-obj?.head("b" != arr)
-obj?.head("b" != nil)
-obj?.head("b" + "a")
-obj?.head("b" + s)
-obj?.head("b" == 0)
-obj?.head("b" == b, indexOf(s, s), a, b)
-obj?.head("b" == nil)
-obj?.head("b" > s)
-obj?.head("b" endsWith "a")
-obj?.head("b" in obj)
-obj?.head("b" matches s)
-obj?.head("b") == obj.a
-obj?.head("b", s, arr) == obj
-obj?.head("c" != "a")
-obj?.head("c" != arr)
-obj?.head("c" != div)
-obj?.head("c" + s)
-obj?.head("c" == arr)
-obj?.head("c" == div)
-obj?.head("c" == obj)
-obj?.head("c" == s)
-obj?.head("c" >= s)
-obj?.head("c" startsWith s)
-obj?.head("c") != ok
-obj?.head("c") == false == false
-obj?.head("c") == s
-obj?.head("c", 2, 0) + s
-obj?.head("c", add) contains s
-obj?.head("c", add) in obj
-obj?.head("c", b) != arr
-obj?.head("c", b) in arr
-obj?.head((b + 0) * a < b)
-obj?.head(-0)
-obj?.head(-0.5)
-obj?.head(-1)
-obj?.head(-a)
-obj?.head(-a, add)
-obj?.head(-b)
-obj?.head(-b, obj?.head("c", 0))
-obj?.head(-f)
-obj?.head(-f, add)
-obj?.head(0 != 0)
-obj?.head(0 != 1)
-obj?.head(0 != a)
-obj?.head(0 != arr)
-obj?.head(0 != b)
-obj?.head(0 != div)
-obj?.head(0 != f)
-obj?.head(0 != false)
-obj?.head(0 != nil)
-obj?.head(0 != obj)
-obj?.head(0 != obj, obj, -b)
-obj?.head(0 != obj?.obj)
-obj?.head(0 % 2)
-obj?.head(0 % a)
-obj?.head(0 % b)
-obj?.head(0 && false)
-obj?.head(0 * 0)
-obj?.head(0 * f)
-obj?.head(0 + 0)
-obj?.head(0 + 2)
-obj?.head(0 + a)
-obj?.head(0 + b)
-obj?.head(0 - 0)
-obj?.head(0 - 0.5)
-obj?.head(0 - 2)
-obj?.head(0 - a)
-obj?.head(0 - b)
-obj?.head(0 - f)
-obj?.head(0 .. 2)
-obj?.head(0 .. b)
-obj?.head(0 / 0)
-obj?.head(0 < 0.5)
-obj?.head(0 < a)
-obj?.head(0 <= 0)
-obj?.head(0 <= 0.5)
-obj?.head(0 <= a, get("a", b))
-obj?.head(0 <= b, obj)
-obj?.head(0 <= f)
-obj?.head(0 == "b")
-obj?.head(0 == 1)
-obj?.head(0 == add)
-obj?.head(0 == arr)
-obj?.head(0 == b)
-obj?.head(0 == div)
-obj?.head(0 == div, f != b)
-obj?.head(0 == nil)
-obj?.head(0 == obj)
-obj?.head(0 == s)
-obj?.head(0 > 0)
-obj?.head(0 > b)
-obj?.head(0 > f)
-obj?.head(0 > f, false or "b")
-obj?.head(0 >= 0)
-obj?.head(0 >= 2)
-obj?.head(0 >= a)
-obj?.head(0 >= f)
-obj?.head(0 ^ 0)
-obj?.head(0 ^ 0, f != obj)
-obj?.head(0 ^ 0, string(div, f, b, s))
-obj?.head(0 ^ b, obj, now(0.5))
-obj?.head(0 or true)
-obj?.head(0) != add
-obj?.head(0) != b
-obj?.head(0) != div
-obj?.head(0) != filter(arr, ok)
-obj?.head(0) % obj.a
-obj?.head(0) ** b
-obj?.head(0) - obj?.fn(b)
-obj?.head(0) .. a
-obj?.head(0) .. obj.b
-obj?.head(0) / obj?.a
-obj?.head(0) < div(b, b)
-obj?.head(0) in map(arr, false)
-obj?.head(0, 1) != f
-obj?.head(0, 1) != nil ? "a" : arr
-obj?.head(0, 2, ok) == f
-obj?.head(0, 2, s) * b
-obj?.head(0, arr) .. b
-obj?.head(0, arr, ok, ok) % b
-obj?.head(0, f, 0, ok) .. a
-obj?.head(0, ok) % a
-obj?.head(0, ok) % b
-obj?.head(0.5 != 0)
-obj?.head(0.5 != 1)
-obj?.head(0.5 != 2)
-obj?.head(0.5 != a, add, 0 == ok)
-obj?.head(0.5 != arr, obj)
-obj?.head(0.5 != false)
-obj?.head(0.5 != obj)
-obj?.head(0.5 && true)
-obj?.head(0.5 * 0.5)
-obj?.head(0.5 * b)
-obj?.head(0.5 * b, f <= a)
-obj?.head(0.5 ** 0)
-obj?.head(0.5 ** 0.5, a)
-obj?.head(0.5 ** a)
-obj?.head(0.5 + 2)
-obj?.head(0.5 + f)
-obj?.head(0.5 - f)
-obj?.head(0.5 - f, add, a)
-obj?.head(0.5 .. f)
-obj?.head(0.5 / 0.5)
-obj?.head(0.5 / 2)
-obj?.head(0.5 < 0)
-obj?.head(0.5 <= 0)
-obj?.head(0.5 <= f)
-obj?.head(0.5 == "c")
-obj?.head(0.5 == a)
-obj?.head(0.5 == arr)
-obj?.head(0.5 == ok)
-obj?.head(0.5 == true)
-obj?.head(0.5 > f)
-obj?.head(0.5) != a
-obj?.head(0.5) != arr
-obj?.head(0.5) != b
-obj?.head(0.5) - f
-obj?.head(0.5) <= f ? true : a
-obj?.head(0.5) == b
-obj?.head(0.5) == ok ? 0 : obj
-obj?.head(0.5) > f
-obj?.head(0.5) > f / f
-obj?.head(0.5, a) in arr ? add : f
-obj?.head(0.5, a, f) + 2 * f
-obj?.head(0.5, arr, div, f, "a") >= f
-obj?.head(0.5, arr, true) > obj?.b
-obj?.head(0.5, b) == obj
-obj?.head(0.5, nil) != b
-obj?.head(0.5, nil) ^ b
-obj?.head(0.5, nil, 0) / add(b, a)
-obj?.head(0.5, ok) <= a
-obj?.head(0.5, true) < obj?.a
-obj?.head(1 != 0)
-obj?.head(1 != ok)
-obj?.head(1 % b, ok, obj)
-obj?.head(1 * a)
-obj?.head(1 * b)
-obj?.head(1 + 0)
-obj?.head(1 + b, obj.head(add, ok))
-obj?.head(1 - b)
-obj?.head(1 - f, get(add, 1))
-obj?.head(1 .. b)
-obj?.head(1 < b)
-obj?.head(1 == add)
-obj?.head(1 == arr)
-obj?.head(1 == s)
-obj?.head(1 > b)
-obj?.head(1 >= f)
-obj?.head(1 ^ 1)
-obj?.head(1 ^ a)
-obj?.head(1 ^ f)
-obj?.head(1 and false)
-obj?.head(1 in nil)
-obj?.head(1 or true)
-obj?.head(1) != div
-obj?.head(1) * a
-obj?.head(1) >= f
-obj?.head(1, add) != obj.a
-obj?.head(1, add, s, ok) / obj.a
-obj?.head(1, s) + obj.head(0)
-obj?.head(2 != 0.5, filter(arr, false))
-obj?.head(2 != b)
-obj?.head(2 != div)
-obj?.head(2 != f)
-obj?.head(2 != nil)
-obj?.head(2 != nil, one("c", false))
-obj?.head(2 != s)
-obj?.head(2 != true)
-obj?.head(2 * f)
-obj?.head(2 ** b, upper(false, s))
-obj?.head(2 ** f)
-obj?.head(2 + 0.5)
-obj?.head(2 - b)
-obj?.head(2 .. 0)
-obj?.head(2 .. 0, f, s endsWith s)
-obj?.head(2 .. a)
-obj?.head(2 .. f)
-obj?.head(2 / a, arr, obj.obj)
-obj?.head(2 < 0.5)
-obj?.head(2 <= 0)
-obj?.head(2 <= a)
-obj?.head(2 <= f, f && false, add)
-obj?.head(2 == nil)
-obj?.head(2 == true)
-obj?.head(2 ^ b)
-obj?.head(2 in arr)
-obj?.head(2 || false)
-obj?.head(2) != a
-obj?.head(2) * a
-obj?.head(2) ** a
-obj?.head(2) - f
-obj?.head(2) == arr
-obj?.head(2) > a * f
-obj?.head(2) in obj?.head(nil)
-obj?.head(2, 1, arr, b, add) in arr
-obj?.head(2, arr, div) == a
-obj?.head(2, obj, "a", div) <= b % a
-obj?.head(2, obj, nil) .. b
-obj?.head(2, s, b) in arr
-obj?.head(["c", "a"])
-obj?.head(a != "a")
-obj?.head(a != "b")
-obj?.head(a != arr)
-obj?.head(a != div)
-obj?.head(a != false)
-obj?.head(a != nil)
-obj?.head(a != obj)
-obj?.head(a != obj, arr)
-obj?.head(a != ok)
-obj?.head(a % b)
-obj?.head(a * 0)
-obj?.head(a * a, obj)
-obj?.head(a ** 0)
-obj?.head(a ** 0.5)
-obj?.head(a ** a)
-obj?.head(a ** b)
-obj?.head(a ** f)
-obj?.head(a + 0)
-obj?.head(a + 0.5)
-obj?.head(a + 1)
-obj?.head(a + a)
-obj?.head(a + b)
-obj?.head(a - 0)
-obj?.head(a - 0.5)
-obj?.head(a - 1)
-obj?.head(a - b)
-obj?.head(a - f, ok)
-obj?.head(a .. 1)
-obj?.head(a .. a)
-obj?.head(a .. f)
-obj?.head(a / 0)
-obj?.head(a / a)
-obj?.head(a / b)
-obj?.head(a < 0)
-obj?.head(a < 0.5)
-obj?.head(a < a)
-obj?.head(a < a, a)
-obj?.head(a < b)
-obj?.head(a <= 0)
-obj?.head(a <= b)
-obj?.head(a == 0.5, string(2, true))
-obj?.head(a == add)
-obj?.head(a == arr)
-obj?.head(a == obj)
-obj?.head(a == obj, a, obj in nil, s)
-obj?.head(a == obj, obj.b)
-obj?.head(a == ok)
-obj?.head(a == s)
-obj?.head(a > 0)
-obj?.head(a > a)
-obj?.head(a >= 0)
-obj?.head(a >= 0, a)
-obj?.head(a ^ 0.5)
-obj?.head(a ^ 2, map(arr, obj))
-obj?.head(a ^ a)
-obj?.head(a ^ b)
-obj?.head(a ^ f)
-obj?.head(a and false)
-obj?.head(a in arr)
-obj?.head(a || false)
-obj?.head(a)
-obj?.head(a) != s
-obj?.head(a) * 2 ^ f
-obj?.head(a) ** (b * 0)
-obj?.head(a) ** b
-obj?.head(a) + obj?.a
-obj?.head(a) - 0.5 / f
-obj?.head(a) / b
-obj?.head(a) / obj?.head(2, s, arr)
-obj?.head(a) < -a
-obj?.head(a) <= a
-obj?.head(a) == nil ? nil : nil
-obj?.head(a) == one(arr, ok)
-obj?.head(a) > f
-obj?.head(a) > obj?.b
-obj?.head(a) >= b - b
-obj?.head(a) ^ a
-obj?.head(a, "c", 1, div, nil) != ok
-obj?.head(a, "c", arr) % a
-obj?.head(a, 0, ok, add) .. b
-obj?.head(a, 0.5, s, f) ^ a
-obj?.head(a, a)
-obj?.head(a, a, add)
-obj?.head(a, all(obj, true))
-obj?.head(a, arr)
-obj?.head(a, arr, obj)
-obj?.head(a, b > b)
-obj?.head(a, b) <= a
-obj?.head(a, b) == 0 + f
-obj?.head(a, div, div, ok)
-obj?.head(a, f ** f, a != 0.5)
-obj?.head(a, f, s) >= b
-obj?.head(a, false or f)
-obj?.head(a, false) != div
-obj?.head(a, max(a, f, f))
-obj?.head(a, obj)
-obj?.head(a, obj, f, 0) ^ obj?.a
-obj?.head(a, obj.head(b))
-obj?.head(a, obj?.a)
-obj?.head(a, ok, a)
-obj?.head(a, ok, b, s, add) in arr
-obj?.head(a, s)
-obj?.head(a, s, a)
-obj?.head(a, true, a) * b
-obj?.head(abs(0))
-obj?.head(abs(0, b))
-obj?.head(abs(0, b, s, obj, 0))
-obj?.head(abs(0.5))
-obj?.head(abs(2))
-obj?.head(abs(a, s, a))
-obj?.head(abs(b))
-obj?.head(abs(f))
-obj?.head(abs(obj, a))
-obj?.head(abs(obj, b))
-obj?.head(abs(obj, true, a))
-obj?.head(abs(s, a))
-obj?.head(abs(s, a), add, f)
-obj?.head(add != 0.5)
-obj?.head(add != a)
-obj?.head(add != add)
-obj?.head(add != div)
-obj?.head(add != false)
-obj?.head(add != nil)
-obj?.head(add != ok)
-obj?.head(add != s)
-obj?.head(add != true)
-obj?.head(add && false)
-obj?.head(add && true)
-obj?.head(add == "a")
-obj?.head(add == 0.5, b != nil)
-obj?.head(add == a, s != obj)
-obj?.head(add == arr)
-obj?.head(add == b)
-obj?.head(add == div)
-obj?.head(add == f)
-obj?.head(add == obj)
-obj?.head(add == ok)
-obj?.head(add == ok, obj)
-obj?.head(add == s)
-obj?.head(add and true)
-obj?.head(add in arr)
-obj?.head(add in arr, div)
-obj?.head(add in nil)
-obj?.head(add or false)
-obj?.head(add || false)
-obj?.head(add(0, 0))
-obj?.head(add(1, 0))
-obj?.head(add(1, 1))
-obj?.head(add(1, b))
-obj?.head(add(2, a))
-obj?.head(add(a, 0))
-obj?.head(add(b, 0))
-obj?.head(add(b, a))
-obj?.head(add(b, b))
-obj?.head(add)
-obj?.head(add) != arr
-obj?.head(add) != s
-obj?.head(add) == arr
-obj?.head(add) in arr
-obj?.head(add, "a") == div
-obj?.head(add, 0.5 ^ b)
-obj?.head(add, 2 / f)
-obj?.head(add, add)
-obj?.head(add, add, nil) == ok
-obj?.head(add, arr == add)
-obj?.head(add, arr) != s
-obj?.head(add, arr, s) != a
-obj?.head(add, b)
-obj?.head(add, div)
-obj?.head(add, f)
-obj?.head(add, f) != upper("c")
-obj?.head(add, get(b, s))
-obj?.head(add, get(false, obj))
-obj?.head(add, get(ok, b))
-obj?.head(add, obj)
-obj?.head(add, obj?.b)
-obj?.head(add, ok)
-obj?.head(add, s)
-obj?.head(add, string(s))
-obj?.head(all("a", ok))
-obj?.head(all("b", ok))
-obj?.head(all(arr, false))
-obj?.head(all(arr, ok))
-obj?.head(all(obj, false))
-obj?.head(all(s, ok))
-obj?.head(all(s, true))
-obj?.head(any("c", ok))
-obj?.head(any(obj, false))
-obj?.head(any(obj, ok))
-obj?.head(any(obj, ok), 1 == arr, b == 0.5)
-obj?.head(any(obj, true))
-obj?.head(any(s, ok), ok)
-obj?.head(arr != "b")
-obj?.head(arr != "c")
-obj?.head(arr != "c", arr)
-obj?.head(arr != 0.5)
-obj?.head(arr != div)
-obj?.head(arr != nil)
-obj?.head(arr != obj)
-obj?.head(arr != s)
-obj?.head(arr && true, ok and obj)
-obj?.head(arr == 0)
-obj?.head(arr == 0.5)
-obj?.head(arr == 1)
-obj?.head(arr == a)
-obj?.head(arr == add)
-obj?.head(arr == arr)
-obj?.head(arr == b)
-obj?.head(arr == div)
-obj?.head(arr == f)
-obj?.head(arr == nil)
-obj?.head(arr == obj)
-obj?.head(arr == ok)
-obj?.head(arr and false)
-obj?.head(arr)
-obj?.head(arr) != div(a, a)
-obj?.head(arr) != s
-obj?.head(arr) == a ? 1 : b
-obj?.head(arr) == arr
-obj?.head(arr) == obj.b
-obj?.head(arr) == obj?.obj
-obj?.head(arr) == ok
-obj?.head(arr)[-1]
-obj?.head(arr)[0.5 - a]
-obj?.head(arr)[b]
-obj?.head(arr, 0) == ok
-obj?.head(arr, 1 - f, ok)
-obj?.head(arr, a, a)
-obj?.head(arr, a, false) == 2 ? obj : "b"
-obj?.head(arr, add(0, 0), 0 - 0.5)
-obj?.head(arr, add)
-obj?.head(arr, all(obj, false), obj.a)
-obj?.head(arr, all(s, ok))
-obj?.head(arr, arr) in arr
-obj?.head(arr, b)
-obj?.head(arr, b) != a
-obj?.head(arr, b, div) != ok
-obj?.head(arr, div(a, b))
-obj?.head(arr, div)
-obj?.head(arr, filter(obj, false))
-obj?.head(arr, map(arr, obj))
-obj?.head(arr, max(ok))
-obj?.head(arr, none(obj, ok), any(arr, true))
-obj?.head(arr, obj)
-obj?.head(arr, obj?.head(a, 0))
-obj?.head(arr, obj?.head(add, add, 0))
-obj?.head(arr, obj?.obj)
-obj?.head(arr, ok)
-obj?.head(arr, ok)[b]
-obj?.head(arr, one(arr, ok))
-obj?.head(arr, s && true)
-obj?.head(arr, s)
-obj?.head(arr, string(div, 0))
-obj?.head(arr, true) == a
-obj?.head(arr[0.5:0])
-obj?.head(arr[0])
-obj?.head(arr[a])
-obj?.head(arr[a], s)
-obj?.head(arr[b])
-obj?.head(arr[f])
-obj?.head(b != "c")
-obj?.head(b != 0)
-obj?.head(b != 0.5)
-obj?.head(b != a)
-obj?.head(b != a, ok)
-obj?.head(b != add)
-obj?.head(b != arr)
-obj?.head(b != b)
-obj?.head(b != div)
-obj?.head(b != nil)
-obj?.head(b != obj)
-obj?.head(b != obj?.obj)
-obj?.head(b != ok)
-obj?.head(b != s)
-obj?.head(b != true)
-obj?.head(b % 2, f)
-obj?.head(b % a)
-obj?.head(b % a, s in nil)
-obj?.head(b && true)
-obj?.head(b * 0.5)
-obj?.head(b * a)
-obj?.head(b * b)
-obj?.head(b ** b)
-obj?.head(b + 0)
-obj?.head(b + 1)
-obj?.head(b + a)
-obj?.head(b + f)
-obj?.head(b - 0)
-obj?.head(b - 1)
-obj?.head(b - a)
-obj?.head(b - b)
-obj?.head(b - f)
-obj?.head(b .. 0.5)
-obj?.head(b .. 2)
-obj?.head(b .. a)
-obj?.head(b / 0)
-obj?.head(b / f)
-obj?.head(b < 0.5)
-obj?.head(b < 2)
-obj?.head(b < a)
-obj?.head(b < a, arr)
-obj?.head(b < f)
-obj?.head(b <= 0)
-obj?.head(b <= 1)
-obj?.head(b <= b)
-obj?.head(b == "b")
-obj?.head(b == "c")
-obj?.head(b == 0)
-obj?.head(b == 0.5)
-obj?.head(b == arr)
-obj?.head(b == div) != ok
-obj?.head(b == obj)
-obj?.head(b == ok)
-obj?.head(b > f)
-obj?.head(b >= 0)
-obj?.head(b >= 0.5)
-obj?.head(b >= 2)
-obj?.head(b >= b)
-obj?.head(b >= f)
-obj?.head(b ^ 0)
-obj?.head(b ^ b)
-obj?.head(b ^ f)
-obj?.head(b and false)
-obj?.head(b and true)
-obj?.head(b in nil)
-obj?.head(b or true)
-obj?.head(b || false)
-obj?.head(b)
-obj?.head(b) != 1 == ok
-obj?.head(b) % obj?.head(obj, div).a
-obj?.head(b) + 0.5 - b
-obj?.head(b) + b
-obj?.head(b) .. a
-obj?.head(b) / a
-obj?.head(b) <= a
-obj?.head(b) <= f
-obj?.head(b) == -f
-obj?.head(b) == b
-obj?.head(b) == f
-obj?.head(b) > 0 * 2
-obj?.head(b) >= a + b
-obj?.head(b, "a") .. b
-obj?.head(b, 0, b) > b
-obj?.head(b, 1 < f)
-obj?.head(b, 1 > b)
-obj?.head(b, add(b, 1))
-obj?.head(b, add)
-obj?.head(b, arr) - f
-obj?.head(b, arr) == div
-obj?.head(b, arr) == s
-obj?.head(b, arr) ^ b
-obj?.head(b, b > 1)
-obj?.head(b, b)
-obj?.head(b, b) ^ b
-obj?.head(b, b, b - a)
-obj?.head(b, div != ok)
-obj?.head(b, div) <= 0 ^ f
-obj?.head(b, f)
-obj?.head(b, f, a and false)
-obj?.head(b, f, div) <= f
-obj?.head(b, f, f) < obj?.b
-obj?.head(b, false, nil) / (0.5 - f)
-obj?.head(b, first(nil))
-obj?.head(b, get(nil, 0))
-obj?.head(b, get(s, a))
-obj?.head(b, max(arr))
-obj?.head(b, obj)
-obj?.head(b, obj) ** f
-obj?.head(b, obj, ok) .. 0 + a
-obj?.head(b, obj.a)
-obj?.head(b, obj.fn(b))
-obj?.head(b, obj?.obj)
-obj?.head(b, ok && add)
-obj?.head(b, ok ? b : 0)
-obj?.head(b, ok, 0.5) != b
-obj?.head(b, s)
-obj?.head(b, trim(s), b)
-obj?.head(count("a", ok))
-obj?.head(count("b", ok))
-obj?.head(count("c", ok))
-obj?.head(count(arr, ok))
-obj?.head(count(arr, true))
-obj?.head(count(obj, false))
-obj?.head(count(obj, ok))
-obj?.head(count(obj, true))
-obj?.head(count(s, false))
-obj?.head(count(s, ok))
-obj?.head(count(s, true), div, map("c", add))
-obj?.head(div != "c")
-obj?.head(div != 2, obj)
-obj?.head(div != a)
-obj?.head(div != f)
-obj?.head(div != f, div)
-obj?.head(div != s)
-obj?.head(div && false)
-obj?.head(div == "b", arr)
-obj?.head(div == 0)
-obj?.head(div == 2)
-obj?.head(div == a)
-obj?.head(div == arr)
-obj?.head(div == arr, arr)
-obj?.head(div == arr, ok)
-obj?.head(div == div)
-obj?.head(div == f)
-obj?.head(div == nil)
-obj?.head(div == obj)
-obj?.head(div == ok)
-obj?.head(div in arr)
-obj?.head(div or false)
-obj?.head(div || false)
-obj?.head(div(0, 1))
-obj?.head(div(0, 2))
-obj?.head(div(2, a))
-obj?.head(div(a, 1))
-obj?.head(div(a, 2), b)
-obj?.head(div(a, a))
-obj?.head(div(a, b))
-obj?.head(div(b, 1))
-obj?.head(div(b, a))
-obj?.head(div(b, b))
-obj?.head(div)
-obj?.head(div) != add
-obj?.head(div) != arr
-obj?.head(div) != f
-obj?.head(div) != s
-obj?.head(div) == obj
-obj?.head(div, 0, ok) != add
-obj?.head(div, 0.5 .. f)
-obj?.head(div, a == f)
-obj?.head(div, a)
-obj?.head(div, add == nil, get(0, arr))
-obj?.head(div, add)
-obj?.head(div, arr)
-obj?.head(div, arr, ok)
-obj?.head(div, b .. 0)
-obj?.head(div, b)
-obj?.head(div, b, arr) != arr
-obj?.head(div, div)
-obj?.head(div, f)
-obj?.head(div, f, ok) != f ** f
-obj?.head(div, false && "b")
-obj?.head(div, get(b, b))
-obj?.head(div, get(nil, div, nil, ok))
-obj?.head(div, nil) != s
-obj?.head(div, now(f, ok, ok, a), f)
-obj?.head(div, now(ok))
-obj?.head(div, obj)
-obj?.head(div, obj.a, s != 0.5)
-obj?.head(div, obj.head(f))
-obj?.head(div, obj?.a)
-obj?.head(div, ok)
-obj?.head(div, s)
-obj?.head(div, s) == ok ? f : a
-obj?.head(div, s, string(ok))
-obj?.head(f != "c")
-obj?.head(f != 0)
-obj?.head(f != 2)
-obj?.head(f != any(obj, ok))
-obj?.head(f != arr)
-obj?.head(f != b)
-obj?.head(f != div)
-obj?.head(f != f, ok)
-obj?.head(f != false)
-obj?.head(f != obj)
-obj?.head(f != s, b or true)
-obj?.head(f && false)
-obj?.head(f * 0)
-obj?.head(f * 0.5)
-obj?.head(f * 1)
-obj?.head(f * 2)
-obj?.head(f * a)
-obj?.head(f * f)
-obj?.head(f ** 0)
-obj?.head(f ** 2)
-obj?.head(f ** b)
-obj?.head(f ** f)
-obj?.head(f + 0.5)
-obj?.head(f + 1)
-obj?.head(f + f)
-obj?.head(f - 0)
-obj?.head(f - 0.5)
-obj?.head(f - 1)
-obj?.head(f - 2)
-obj?.head(f - b)
-obj?.head(f .. a)
-obj?.head(f .. b)
-obj?.head(f .. f)
-obj?.head(f / 0)
-obj?.head(f / 2)
-obj?.head(f / a)
-obj?.head(f / b)
-obj?.head(f < a)
-obj?.head(f < b)
-obj?.head(f < f)
-obj?.head(f <= 0)
-obj?.head(f <= a)
-obj?.head(f <= a, a)
-obj?.head(f <= f)
-obj?.head(f == add)
-obj?.head(f == arr)
-obj?.head(f == f)
-obj?.head(f == obj)
-obj?.head(f == ok)
-obj?.head(f == s)
-obj?.head(f == true, obj != false)
-obj?.head(f > b)
-obj?.head(f >= 0)
-obj?.head(f >= 0.5)
-obj?.head(f >= b)
-obj?.head(f >= f)
-obj?.head(f ^ 2)
-obj?.head(f ^ a)
-obj?.head(f in arr)
-obj?.head(f in nil)
-obj?.head(f or false)
-obj?.head(f or true)
-obj?.head(f)
-obj?.head(f) * b
-obj?.head(f) ** -f
-obj?.head(f) + obj?.a
-obj?.head(f) - b
-obj?.head(f) / a
-obj?.head(f) <= a
-obj?.head(f) == 0 ^ 0.5
-obj?.head(f) == b != true
-obj?.head(f) == f
-obj?.head(f) > 1 + 1
-obj?.head(f) > a
-obj?.head(f) >= b
-obj?.head(f) >= b ^ b
-obj?.head(f) in arr
-obj?.head(f, 0) <= a - f
-obj?.head(f, 2, arr, false, a) > a
-obj?.head(f, a)
-obj?.head(f, add)
-obj?.head(f, add, f) < add(a, a)
-obj?.head(f, add, obj) - a
-obj?.head(f, arr, 0.5, b) + f
-obj?.head(f, arr, f) + f
-obj?.head(f, b != "a")
-obj?.head(f, b, s, b) ^ obj.a
-obj?.head(f, div == arr)
-obj?.head(f, div)
-obj?.head(f, div, f) ** b
-obj?.head(f, f * b)
-obj?.head(f, f)
-obj?.head(f, f) + -b
-obj?.head(f, f, obj) != f
-obj?.head(f, f, ok, arr) <= f + 0
-obj?.head(f, get(0.5, arr), map(arr, nil))
-obj?.head(f, get(ok, add))
-obj?.head(f, nil) - a
-obj?.head(f, obj != arr)
-obj?.head(f, obj != b)
-obj?.head(f, obj)
-obj?.head(f, obj?.head(b, arr, "c"), b)
-obj?.head(f, ok ? add : b)
-obj?.head(f, ok ? s : 0)
-obj?.head(f, ok and add, string(add))
-obj?.head(f, ok)
-obj?.head(f, s)
-obj?.head(f, true and f)
-obj?.head(f, true || a)
-obj?.head(false != a)
-obj?.head(false != f)
-obj?.head(false != false)
-obj?.head(false != ok)
-obj?.head(false != s)
-obj?.head(false != s, upper(0, "b"), obj)
-obj?.head(false && a, a)
-obj?.head(false && add)
-obj?.head(false && b)
-obj?.head(false && obj)
-obj?.head(false == obj)
-obj?.head(false == s)
-obj?.head(false ? "c" : false)
-obj?.head(false ? a : 0, obj.fn(2))
-obj?.head(false ? a : add)
-obj?.head(false ? a : false)
-obj?.head(false ? add : ok, a ^ b)
-obj?.head(false ? arr : nil)
-obj?.head(false ? nil : 0.5)
-obj?.head(false ? obj : s, obj?.head("c"))
-obj?.head(false ? s : add)
-obj?.head(false ? s : f, div)
-obj?.head(false and "a", b)
-obj?.head(false and "b")
-obj?.head(false and 0.5)
-obj?.head(false and a)
-obj?.head(false and add)
-obj?.head(false and arr)
-obj?.head(false and obj)
-obj?.head(false or add)
-obj?.head(false or arr)
-obj?.head(false or b)
-obj?.head(false or f)
-obj?.head(false or true)
-obj?.head(false || add, arr != "a")
-obj?.head(false || arr)
-obj?.head(false || b)
-obj?.head(false || ok)
-obj?.head(false) == obj
-obj?.head(false) ? 0 % 1 : obj.obj
-obj?.head(false) in arr
-obj?.head(false, 0, b) == s + "a"
-obj?.head(false, 0.5, div) || obj.head(add, obj)
-obj?.head(false, 1) || b > 2
-obj?.head(false, b) == b
-obj?.head(false, b, "a") || obj?.a
-obj?.head(false, obj) in arr
-obj?.head(filter(arr, false))
-obj?.head(filter(arr, ok))
-obj?.head(filter(arr, true))
-obj?.head(filter(s, ok))
-obj?.head(filter(s, true))
-obj?.head(first(0))
-obj?.head(first(0.5, 1, arr, obj, arr))
-obj?.head(first(a), map(arr, add))
-obj?.head(first(a, 0.5))
-obj?.head(first(a, div))
-obj?.head(first(add))
-obj?.head(first(b, div))
-obj?.head(first(b, false, a))
-obj?.head(first(b, nil))
-obj?.head(first(div))
-obj?.head(first(f))
-obj?.head(first(f))?.b
-obj?.head(first(f), f)
-obj?.head(first(f, a), true != nil)
-obj?.head(first(false))
-obj?.head(first(false, nil), a != f)?.a
-obj?.head(first(false, ok))
-obj?.head(first(nil, nil))
-obj?.head(first(obj, 0), b * b)
-obj?.head(first(ok))
-obj?.head(first(ok, arr))
-obj?.head(first(s))
-obj?.head(first(s, b))
-obj?.head(first(s, s), abs(0.5))
-obj?.head(first(true, div, 0))
-obj?.head(float(0))
-obj?.head(float(0.5))
-obj?.head(float(2))
-obj?.head(float(b))
-obj?.head(float(b, 0.5))
-obj?.head(float(f))
-obj?.head(float(f, div, f))
-obj?.head(get("a", "b"))?.b
-obj?.head(get("a", nil))
-obj?.head(get("a", nil), f)
-obj?.head(get("a", ok))
-obj?.head(get("b", a))
-obj?.head(get("b", add))
-obj?.head(get("b", b))
-obj?.head(get("b", div))
-obj?.head(get("b", false))
-obj?.head(get("c", arr), a)
-obj?.head(get(0, 0))
-obj?.head(get(0, 0.5))
-obj?.head(get(0, a))
-obj?.head(get(0, add))
-obj?.head(get(0, arr))
-obj?.head(get(0, b))
-obj?.head(get(0, b), add)
-obj?.head(get(0, f))
-obj?.head(get(0, f), add)
-obj?.head(get(0, nil))
-obj?.head(get(0, obj))?.b
-obj?.head(get(0, ok))
-obj?.head(get(0, ok)?.b)
-obj?.head(get(0.5), get(ok, false))
-obj?.head(get(0.5, 0.5))
-obj?.head(get(0.5, b))
-obj?.head(get(0.5, false))
-obj?.head(get(0.5, nil))
-obj?.head(get(0.5, obj))
-obj?.head(get(0.5, ok))
-obj?.head(get(0.5, s))
-obj?.head(get(0.5, true))
-obj?.head(get(1, 0))
-obj?.head(get(1, a))
-obj?.head(get(1, add))
-obj?.head(get(1, b))
-obj?.head(get(1, nil))
-obj?.head(get(1, obj))
-obj?.head(get(1, ok))
-obj?.head(get(1, s))
-obj?.head(get(1, s), obj.head(nil), div)
-obj?.head(get(2))
-obj?.head(get(2, 0))
-obj?.head(get(2, a))
-obj?.head(get(2, add))
-obj?.head(get(2, div))
-obj?.head(get(a))
-obj?.head(get(a), ok)
-obj?.head(get(a, 0))
-obj?.head(get(a, 2))
-obj?.head(get(a, a))
-obj?.head(get(a, b))
-obj?.head(get(a, b))?.a
-obj?.head(get(a, div))
-obj?.head(get(a, f))
-obj?.head(get(a, false))
-obj?.head(get(a, obj))
-obj?.head(get(a, obj), b in nil)
-obj?.head(get(a, s))
-obj?.head(get(add, 0))
-obj?.head(get(add, 2))
-obj?.head(get(add, arr))
-obj?.head(get(add, b))
-obj?.head(get(add, div))
-obj?.head(get(add, f))
-obj?.head(get(add, false))
-obj?.head(get(add, nil))
-obj?.head(get(add, ok))
-obj?.head(get(add, s))
-obj?.head(get(add, true))
-obj?.head(get(arr))
-obj?.head(get(arr, 0.5))
-obj?.head(get(arr, a))
-obj?.head(get(arr, arr))
-obj?.head(get(arr, div))
-obj?.head(get(arr, false))
-obj?.head(get(arr, nil))
-obj?.head(get(arr, s))
-obj?.head(get(b))
-obj?.head(get(b, 0.5))
-obj?.head(get(b, 1), add)
-obj?.head(get(b, 2))
-obj?.head(get(b, a))
-obj?.head(get(b, arr))
-obj?.head(get(b, b))
-obj?.head(get(b, b), obj)
-obj?.head(get(b, div), obj.obj)
-obj?.head(get(b, nil))
-obj?.head(get(b, obj))
-obj?.head(get(b, ok))
-obj?.head(get(div, 0))
-obj?.head(get(div, 0.5))
-obj?.head(get(div, a))
-obj?.head(get(div, a, nil), ok || div)
-obj?.head(get(div, add))
-obj?.head(get(div, b))
-obj?.head(get(div, div))
-obj?.head(get(div, f))
-obj?.head(get(div, nil))
-obj?.head(get(div, obj))
-obj?.head(get(div, s))
-obj?.head(get(div, s), f == nil)
-obj?.head(get(div, true))
-obj?.head(get(f, 0))
-obj?.head(get(f, 0.5))
-obj?.head(get(f, 1))
-obj?.head(get(f, 2))
-obj?.head(get(f, a))?.a
-obj?.head(get(f, add))
-obj?.head(get(f, b), toBase64("c", ok, f))
-obj?.head(get(f, f))
-obj?.head(get(f, false))
-obj?.head(get(f, nil))
-obj?.head(get(f, ok))
-obj?.head(get(false, 0))
-obj?.head(get(false, 0)?.a)
-obj?.head(get(false, 0.5), s == div)
-obj?.head(get(false, div))
-obj?.head(get(false, nil))
-obj?.head(get(false, ok))
-obj?.head(get(false, s))
-obj?.head(get(nil))
-obj?.head(get(nil, add))
-obj?.head(get(nil, arr))
-obj?.head(get(nil, arr, s))
-obj?.head(get(nil, b), obj?.fn(b))
-obj?.head(get(nil, div))
-obj?.head(get(nil, nil))
-obj?.head(get(nil, nil), ok)
-obj?.head(get(nil, ok))
-obj?.head(get(nil, ok), map("c", add))
-obj?.head(get(nil, ok), ok)
-obj?.head(get(nil, s))
-obj?.head(get(obj)?.fn(ok))
-obj?.head(get(obj, 0))
-obj?.head(get(obj, 0.5))
-obj?.head(get(obj, 2))
-obj?.head(get(obj, a))
-obj?.head(get(obj, add))
-obj?.head(get(obj, arr))
-obj?.head(get(obj, b))
-obj?.head(get(obj, obj))
-obj?.head(get(obj, s))
-obj?.head(get(obj, s)?.obj?.obj)
-obj?.head(get(obj, s, arr))
-obj?.head(get(ok))
-obj?.head(get(ok, a))
-obj?.head(get(ok, add))
-obj?.head(get(ok, arr))
-obj?.head(get(ok, b))
-obj?.head(get(ok, div))
-obj?.head(get(ok, nil))
-obj?.head(get(ok, nil), false and add)
-obj?.head(get(ok, obj))
-obj?.head(get(ok, obj))?.b
-obj?.head(get(ok, obj), s)
-obj?.head(get(ok, s))
-obj?.head(get(ok, true))
-obj?.head(get(s))
-obj?.head(get(s), f == a)
-obj?.head(get(s)?.a)
-obj?.head(get(s, 1))
-obj?.head(get(s, 2), add)
-obj?.head(get(s, a))
-obj?.head(get(s, a, true))
-obj?.head(get(s, add))
-obj?.head(get(s, arr))
-obj?.head(get(s, arr), get(arr, arr))
-obj?.head(get(s, b))
-obj?.head(get(s, div))
-obj?.head(get(s, div), a, a)
-obj?.head(get(s, f))
-obj?.head(get(s, nil))
-obj?.head(get(s, obj))?.b
-obj?.head(get(s, ok))
-obj?.head(get(s, ok))?.a
-obj?.head(get(s, s))
-obj?.head(get(s, true))
-obj?.head(get(s, true), obj)
-obj?.head(get(true, 0.5), arr)
-obj?.head(get(true, a))
-obj?.head(get(true, add))
-obj?.head(get(true, div))
-obj?.head(get(true, div), any("b", false))
-obj?.head(get(true, f))
-obj?.head(get(true, false))
-obj?.head(get(true, s))
-obj?.head(int("b", a))
-obj?.head(int(2))
-obj?.head(int(a))
-obj?.head(int(b))
-obj?.head(int(f))
-obj?.head(int(false, s, false, a))
-obj?.head(last(0))
-obj?.head(last(0.5))
-obj?.head(last(0.5, add))
-obj?.head(last(0.5, b, f, "b"))
-obj?.head(last(1, true, a, s))
-obj?.head(last(a))
-obj?.head(last(a, false, f, "a"))
-obj?.head(last(add))
-obj?.head(last(arr, arr))
-obj?.head(last(b))
-obj?.head(last(b, add, ok, 2))
-obj?.head(last(div))
-obj?.head(last(div, b))
-obj?.head(last(f))
-obj?.head(last(f, arr, arr))
-obj?.head(last(obj))
-obj?.head(last(obj, "c", a, ok))
-obj?.head(last(ok))
-obj?.head(last(ok, ok))
-obj?.head(last(s))
-obj?.head(len("a"))
-obj?.head(len(add, "a"))
-obj?.head(len(arr))
-obj?.head(len(arr), arr)
-obj?.head(len(false, div, obj))
-obj?.head(len(obj, "c"))
-obj?.head(lower("a"))
-obj?.head(lower("b"))
-obj?.head(lower(arr, s))
-obj?.head(lower(false, true, s))
-obj?.head(lower(s))
-obj?.head(map("a", "a"))
-obj?.head(map("a", "b"))
-obj?.head(map("a", 0))
-obj?.head(map("a", 2))
-obj?.head(map("a", a), obj.head(a))
-obj?.head(map("a", add), s, get(arr, b))
-obj?.head(map("a", arr))
-obj?.head(map("a", div))
-obj?.head(map("a", f))
-obj?.head(map("b", add))
-obj?.head(map("b", f))
-obj?.head(map("b", nil))
-obj?.head(map("b", ok), add)
-obj?.head(map("c", 0.5))
-obj?.head(map("c", div), b)
-obj?.head(map("c", nil), get(s))
-obj?.head(map("c", obj))
-obj?.head(map("c", s))
-obj?.head(map(arr, "a"))
-obj?.head(map(arr, "b"))
-obj?.head(map(arr, 0))
-obj?.head(map(arr, 0.5))
-obj?.head(map(arr, arr))
-obj?.head(map(arr, b))
-obj?.head(map(arr, div))
-obj?.head(map(arr, f))
-obj?.head(map(arr, false))
-obj?.head(map(arr, false), f)
-obj?.head(map(arr, nil))
-obj?.head(map(arr, obj))
-obj?.head(map(arr, ok))
-obj?.head(map(arr, s))
-obj?.head(map(arr, true))
-obj?.head(map(obj, 0.5))
-obj?.head(map(obj, 1), add == f)
-obj?.head(map(obj, add))
-obj?.head(map(obj, arr))
-obj?.head(map(obj, b))
-obj?.head(map(obj, b), get(nil, ok), arr)
-obj?.head(map(obj, b), obj)
-obj?.head(map(obj, div))
-obj?.head(map(obj, f))
-obj?.head(map(obj, nil), ok || true)
-obj?.head(map(obj, obj))
-obj?.head(map(obj, obj), obj.b)
-obj?.head(map(obj, ok))
-obj?.head(map(obj, s))
-obj?.head(map(obj.obj, a or false))
-obj?.head(map(s, #))
-obj?.head(map(s, 0))
-obj?.head(map(s, 0.5))
-obj?.head(map(s, 1))
-obj?.head(map(s, 2), arr)
-obj?.head(map(s, a))
-obj?.head(map(s, add))
-obj?.head(map(s, arr))
-obj?.head(map(s, div))
-obj?.head(map(s, f))
-obj?.head(map(s, nil), add(a, a))
-obj?.head(map(s, obj), f, b + 2)
-obj?.head(map(s, ok))
-obj?.head(map(s, ok), 0 ** f)
-obj?.head(map(s, s))
-obj?.head(max("a"))
-obj?.head(max("b"))
-obj?.head(max("c"))
-obj?.head(max(1, b))
-obj?.head(max(b, b))
-obj?.head(max(div))
-obj?.head(max(f != 0))
-obj?.head(max(false))
-obj?.head(max(get(ok, b)))
-obj?.head(max(obj)?.obj)
-obj?.head(max(ok))
-obj?.head(max(s))
-obj?.head(min("a"))
-obj?.head(min("c"), arr)
-obj?.head(min(0))
-obj?.head(min(a))
-obj?.head(min(add))
-obj?.head(min(arr))
-obj?.head(min(b))
-obj?.head(min(f))
-obj?.head(min(nil))
-obj?.head(min(nil, 1), 0 / f)
-obj?.head(min(ok))
-obj?.head(min(ok), arr, f)
-obj?.head(min(s, s), f)
-obj?.head(nil != 0)
-obj?.head(nil != 0.5)
-obj?.head(nil != 1)
-obj?.head(nil != 2)
-obj?.head(nil != a)
-obj?.head(nil != add, obj.fn(b))
-obj?.head(nil != arr)
-obj?.head(nil != b, "b" != 0)
-obj?.head(nil != false)
-obj?.head(nil != nil)
-obj?.head(nil != obj)
-obj?.head(nil != ok)
-obj?.head(nil != true)
-obj?.head(nil == "b") or add(a, 0) - obj.b
-obj?.head(nil == "c" || add == f)
-obj?.head(nil == arr)
-obj?.head(nil == div)
-obj?.head(nil == nil)
-obj?.head(nil == obj)
-obj?.head(nil == ok)
-obj?.head(nil == s)
-obj?.head(nil in arr)
-obj?.head(nil || false)
-obj?.head(nil || true)
-obj?.head(nil) != add
-obj?.head(nil) != arr
-obj?.head(nil) != div
-obj?.head(nil) != f
-obj?.head(nil) == 2 + a
-obj?.head(nil) == add
-obj?.head(nil) == map(arr, "b")
-obj?.head(nil) == obj.obj
-obj?.head(nil) in obj
-obj?.head(nil) in obj?.obj
-obj?.head(nil)?.a
-obj?.head(nil)?.a.b
-obj?.head(nil)?.a?.b
-obj?.head(nil)?.b
-obj?.head(nil)?.b.a
-obj?.head(nil)?.b.obj
-obj?.head(nil)?.b?.obj
-obj?.head(nil)?.fn(obj.obj)
-obj?.head(nil)?.fn(s, "b" != f)
-obj?.head(nil)?.head(ok)
-obj?.head(nil)?.obj
-obj?.head(nil)?.obj?.a
-obj?.head(nil)?.obj?.b
-obj?.head(nil, "a")?.obj
-obj?.head(nil, "b")?.b
-obj?.head(nil, "b", obj)?.b
-obj?.head(nil, "b", s)?.b
-obj?.head(nil, "b", s, f)?.obj
-obj?.head(nil, "c")?.obj
-obj?.head(nil, "c", 0.5)?.obj
-obj?.head(nil, "c", f)?.a
-obj?.head(nil, 0)?.a
-obj?.head(nil, 0)?.b
-obj?.head(nil, 0)?.obj
-obj?.head(nil, 0, b, s)?.a
-obj?.head(nil, 0.5, 0, s)?.b
-obj?.head(nil, 1)?.b
-obj?.head(nil, 1)?.obj
-obj?.head(nil, 1, false)?.a
-obj?.head(nil, 1, nil)?.obj
-obj?.head(nil, 2)?.b
-obj?.head(nil, 2)?.obj
-obj?.head(nil, 2, 0, nil)?.a
-obj?.head(nil, a) != s ? add : obj?.b
-obj?.head(nil, a) == s
-obj?.head(nil, a)?.a
-obj?.head(nil, a)?.obj
-obj?.head(nil, a, 0.5, a)?.a
-obj?.head(nil, a, 0.5, add, false)?.b
-obj?.head(nil, a, add)?.a
-obj?.head(nil, a, ok, nil)?.obj
-obj?.head(nil, a, s)?.b
-obj?.head(nil, add)?.a
-obj?.head(nil, add)?.obj
-obj?.head(nil, add, "b")?.obj
-obj?.head(nil, add, b)?.obj.obj
-obj?.head(nil, add, false)?.a
-obj?.head(nil, add, false)?.b
-obj?.head(nil, add, nil, add)?.obj
-obj?.head(nil, arr)?.a
-obj?.head(nil, arr)?.b
-obj?.head(nil, arr)?.obj
-obj?.head(nil, arr, "a")?.obj
-obj?.head(nil, arr, "c")?.b
-obj?.head(nil, arr, 1)?.b
-obj?.head(nil, arr, s)?.a
-obj?.head(nil, b)?.a
-obj?.head(nil, b)?.b
-obj?.head(nil, b)?.obj
-obj?.head(nil, b, a, ok, ok)?.b
-obj?.head(nil, b, add)?.a
-obj?.head(nil, b, b)?.b
-obj?.head(nil, b, false)?.a
-obj?.head(nil, b, s)?.a
-obj?.head(nil, div)?.a
-obj?.head(nil, div)?.obj
-obj?.head(nil, div, arr)?.b
-obj?.head(nil, f)?.b
-obj?.head(nil, f)?.obj
-obj?.head(nil, f, add, add)?.b
-obj?.head(nil, f, nil)?.a
-obj?.head(nil, f, s)?.a
-obj?.head(nil, false)?.a
-obj?.head(nil, false)?.obj
-obj?.head(nil, false, s)?.a
-obj?.head(nil, nil)?.a
-obj?.head(nil, nil, 0.5)?.obj
-obj?.head(nil, nil, add)?.b
-obj?.head(nil, nil, add, arr)?.obj
-obj?.head(nil, nil, ok)?.obj
-obj?.head(nil, obj) in obj
-obj?.head(nil, obj)?.a
-obj?.head(nil, obj)?.b
-obj?.head(nil, obj)?.b.a
-obj?.head(nil, obj)?.obj
-obj?.head(nil, ok)?.a
-obj?.head(nil, ok)?.b
-obj?.head(nil, ok)?.obj
-obj?.head(nil, ok, "b")?.b
-obj?.head(nil, ok, 0.5)?.a
-obj?.head(nil, ok, arr)?.b
-obj?.head(nil, ok, div, arr, obj)?.obj
-obj?.head(nil, ok, nil, ok)?.obj
-obj?.head(nil, ok, s, 1, true)?.obj.a
-obj?.head(nil, s)?.a
-obj?.head(nil, s)?.obj
-obj?.head(nil, s, 0.5)?.obj
-obj?.head(nil, s, a)?.obj
-obj?.head(nil, s, false, s)?.a
-obj?.head(nil, s, s)?.b
-obj?.head(nil, true)?.a
-obj?.head(nil, true)?.head(f, arr)
-obj?.head(nil, true)?.obj
-obj?.head(none("b", true), s == f)
-obj?.head(none("c", false))
-obj?.head(none("c", ok))
-obj?.head(none("c", true))
-obj?.head(none(arr, ok), get(nil, 1), now(div, "a", s, div, f), a)
-obj?.head(none(obj, false))
-obj?.head(none(obj, ok))
-obj?.head(none(s, false))
-obj?.head(not false)
-obj?.head(not ok)
-obj?.head(not true)
-obj?.head(now(0, s))
-obj?.head(now(0, s), f + b)
-obj?.head(now(0.5), arr, obj.a)
-obj?.head(now(1))
-obj?.head(now(a))
-obj?.head(now(a, a, a))
-obj?.head(now(arr))
-obj?.head(now(b, b))
-obj?.head(now(b, div, f))
-obj?.head(now(b, s))
-obj?.head(now(div))
-obj?.head(now(div, div, "b", obj, 1))
-obj?.head(now(f, add))
-obj?.head(now(false))
-obj?.head(now(nil))
-obj?.head(now(nil, obj))
-obj?.head(now(obj), 0 == 1)
-obj?.head(now(obj, 0))
-obj?.head(now(ok))
-obj?.head(now(ok, arr))
-obj?.head(now(ok, b))
-obj?.head(now(ok, b, arr, nil))
-obj?.head(now(ok, f), true == 0.5)
-obj?.head(now(ok, true, a))
-obj?.head(now(s))
-obj?.head(now(s, b, s), "a" startsWith s)
-obj?.head(now(s, nil))
-obj?.head(now(true))
-obj?.head(now(true, "b", add))
-obj?.head(obj != "a")
-obj?.head(obj != 0)
-obj?.head(obj != 0.5)
-obj?.head(obj != add)
-obj?.head(obj != nil)
-obj?.head(obj != s)
-obj?.head(obj && true)
-obj?.head(obj == 0.5)
-obj?.head(obj == 1)
-obj?.head(obj == a)
-obj?.head(obj == div)
-obj?.head(obj == f, now(1))
-obj?.head(obj == false)
-obj?.head(obj == obj)
-obj?.head(obj == ok)
-obj?.head(obj and true, 2 .. b)
-obj?.head(obj in arr)
-obj?.head(obj in nil)
-obj?.head(obj or true)
-obj?.head(obj)
-obj?.head(obj) != a ** 0.5
-obj?.head(obj) != a ? obj : s
-obj?.head(obj) != div
-obj?.head(obj) != map(arr, s)
-obj?.head(obj) != ok
-obj?.head(obj) != s
-obj?.head(obj) == add
-obj?.head(obj) == div
-obj?.head(obj) == f
-obj?.head(obj) == s
-obj?.head(obj) in arr
-obj?.head(obj).a
-obj?.head(obj).b
-obj?.head(obj).head(b)
-obj?.head(obj).head(get(div, f))
-obj?.head(obj).obj
-obj?.head(obj).obj.obj
-obj?.head(obj).obj?.a
-obj?.head(obj).obj?.b
-obj?.head(obj)?.a
-obj?.head(obj)?.b
-obj?.head(obj)?.head(0 <= f)
-obj?.head(obj)?.head(a)
-obj?.head(obj)?.head(add)
-obj?.head(obj)?.obj
-obj?.head(obj)?.obj.obj
-obj?.head(obj)[s]
-obj?.head(obj, "a").b
-obj?.head(obj, "a").obj
-obj?.head(obj, "a")?.a
-obj?.head(obj, "a")?.obj
-obj?.head(obj, "a", arr, obj)?.head(obj == s)
-obj?.head(obj, "b").a
-obj?.head(obj, "b").b
-obj?.head(obj, "b", nil).b
-obj?.head(obj, "c").b
-obj?.head(obj, "c")?.a
-obj?.head(obj, "c")?.obj
-obj?.head(obj, 0 > a)
-obj?.head(obj, 0).a
-obj?.head(obj, 0).b
-obj?.head(obj, 0).obj
-obj?.head(obj, 0)?.a
-obj?.head(obj, 0)?.b
-obj?.head(obj, 0, add).b
-obj?.head(obj, 0.5).a
-obj?.head(obj, 0.5).obj
-obj?.head(obj, 0.5)[s]
-obj?.head(obj, 0.5, div)?.b
-obj?.head(obj, 0.5, nil).b
-obj?.head(obj, 1).b
-obj?.head(obj, 1, 0).obj
-obj?.head(obj, 1, 0)?.head(add)
-obj?.head(obj, 1, ok)?.b
-obj?.head(obj, 2).a
-obj?.head(obj, 2).obj
-obj?.head(obj, 2)?.obj
-obj?.head(obj, 2, true).a
-obj?.head(obj, a <= a)
-obj?.head(obj, a)
-obj?.head(obj, a).a
-obj?.head(obj, a).b
-obj?.head(obj, a).obj
-obj?.head(obj, a)?.a
-obj?.head(obj, a)?.b
-obj?.head(obj, a)?.obj
-obj?.head(obj, a, "c").a
-obj?.head(obj, a, 1, add, s)?.obj
-obj?.head(obj, a, 2, obj).obj
-obj?.head(obj, a, a).a
-obj?.head(obj, a, add, "b").b
-obj?.head(obj, a, b)?.b * b
-obj?.head(obj, a, f, b, a)?.b
-obj?.head(obj, a, obj, 0.5).obj?.b
-obj?.head(obj, a, ok, 1).obj?.a
-obj?.head(obj, a, ok, add).b
-obj?.head(obj, a, s)?.obj
-obj?.head(obj, a, s, ok).b
-obj?.head(obj, a, true)?.b
-obj?.head(obj, add == ok)
-obj?.head(obj, add)
-obj?.head(obj, add).b
-obj?.head(obj, add).obj
-obj?.head(obj, add)?.a
-obj?.head(obj, add)?.b
-obj?.head(obj, add)?.obj
-obj?.head(obj, add, nil).b
-obj?.head(obj, add, s).a
-obj?.head(obj, arr).a
-obj?.head(obj, arr).a == ok
-obj?.head(obj, arr).b
-obj?.head(obj, arr).obj
-obj?.head(obj, arr)?.b
-obj?.head(obj, arr)?.obj
-obj?.head(obj, arr, 0).b
-obj?.head(obj, arr, a, b, s)?.a
-obj?.head(obj, arr, f).b
-obj?.head(obj, arr, f)?.b
-obj?.head(obj, arr, nil).a
-obj?.head(obj, arr, nil).b
-obj?.head(obj, b)
-obj?.head(obj, b).obj
-obj?.head(obj, b)?.a
-obj?.head(obj, b)?.b
-obj?.head(obj, b)?.obj
-obj?.head(obj, b, "a")?.obj
-obj?.head(obj, b, 0.5).b
-obj?.head(obj, b, b).obj
-obj?.head(obj, b, div)?.b
-obj?.head(obj, b, f).obj
-obj?.head(obj, b, false, s)?.b
-obj?.head(obj, b, nil, arr, true).a
-obj?.head(obj, b, obj)?.b
-obj?.head(obj, b, obj)?.obj
-obj?.head(obj, b, ok).obj
-obj?.head(obj, b, s).obj
-obj?.head(obj, div != a)
-obj?.head(obj, div)
-obj?.head(obj, div).a
-obj?.head(obj, div).head(add)
-obj?.head(obj, div).obj
-obj?.head(obj, div)?.a
-obj?.head(obj, div)?.b
-obj?.head(obj, div)?.fn(-b)
-obj?.head(obj, div, "b")?.a
-obj?.head(obj, div, "b", 0, "b").obj
-obj?.head(obj, div, 0).b
-obj?.head(obj, div, 0)?.a
-obj?.head(obj, div, 1, false, b).a
-obj?.head(obj, div, f).obj
-obj?.head(obj, div, nil).a
-obj?.head(obj, div, nil).obj
-obj?.head(obj, div, obj.b)
-obj?.head(obj, div, ok).b
-obj?.head(obj, div, ok, nil).a
-obj?.head(obj, div, true, a)?.b
-obj?.head(obj, f * b)
-obj?.head(obj, f)
-obj?.head(obj, f) != obj?.head(arr, div)
-obj?.head(obj, f) == b
-obj?.head(obj, f).b
-obj?.head(obj, f).obj
-obj?.head(obj, f)?.b
-obj?.head(obj, f)?.obj
-obj?.head(obj, f, a).a
-obj?.head(obj, f, a, f).a
-obj?.head(obj, f, div).obj
-obj?.head(obj, f, f)?.b
-obj?.head(obj, f, false, b).b
-obj?.head(obj, f, obj).a
-obj?.head(obj, f, obj)?.obj?.b
-obj?.head(obj, f, ok, obj.a)
-obj?.head(obj, f, true).a
-obj?.head(obj, false).a
-obj?.head(obj, false).b
-obj?.head(obj, false)?.b
-obj?.head(obj, false, obj)?.obj
-obj?.head(obj, false, ok)?.obj
-obj?.head(obj, filter(arr, ok), arr)
-obj?.head(obj, first(0.5), f).obj
-obj?.head(obj, get(0.5), 0.5 ^ a)
-obj?.head(obj, get(a, obj))
-obj?.head(obj, get(add, add), add)
-obj?.head(obj, get(div, 0))
-obj?.head(obj, nil).a
-obj?.head(obj, nil).obj
-obj?.head(obj, nil)?.b
-obj?.head(obj, nil, 1, s, obj).b
-obj?.head(obj, nil, a).b
-obj?.head(obj, nil, add, obj).obj?.b
-obj?.head(obj, nil, b, a)?.obj
-obj?.head(obj, nil, f).obj
-obj?.head(obj, obj)
-obj?.head(obj, obj).a
-obj?.head(obj, obj).head(add)
-obj?.head(obj, obj)?.a
-obj?.head(obj, obj)?.b
-obj?.head(obj, obj)?.obj
-obj?.head(obj, obj, 0)?.b
-obj?.head(obj, obj, a, "a", a)?.b
-obj?.head(obj, obj, arr).a
-obj?.head(obj, obj, b)?.a
-obj?.head(obj, obj, false, f, 1).obj
-obj?.head(obj, obj, nil, true)?.obj
-obj?.head(obj, obj.b)
-obj?.head(obj, obj.fn(b))
-obj?.head(obj, obj?.head(f)).b
-obj?.head(obj, obj?.obj)
-obj?.head(obj, ok == arr)?.b
-obj?.head(obj, ok)
-obj?.head(obj, ok).obj
-obj?.head(obj, ok)?.a
-obj?.head(obj, ok)?.b
-obj?.head(obj, ok)?.obj
-obj?.head(obj, ok, 0.5).obj
-obj?.head(obj, ok, a).b
-obj?.head(obj, ok, a, "b")?.obj
-obj?.head(obj, ok, a, div, 0.5).a
-obj?.head(obj, ok, a, true)?.a
-obj?.head(obj, ok, b).obj
-obj?.head(obj, ok, f).obj
-obj?.head(obj, ok, false, f, div)?.obj
-obj?.head(obj, ok, nil)?.b
-obj?.head(obj, ok, obj).a
-obj?.head(obj, s)
-obj?.head(obj, s).a
-obj?.head(obj, s).obj
-obj?.head(obj, s).obj.a
-obj?.head(obj, s)?.head(get(b, a)?.obj)
-obj?.head(obj, s, 0, 0)?.obj
-obj?.head(obj, s, a, a, ok).b
-obj?.head(obj, s, add)
-obj?.head(obj, s, add, obj)?.a
-obj?.head(obj, s, f, a, b)?.b
-obj?.head(obj, s, nil, s)?.a
-obj?.head(obj, s, s, a, 2).b
-obj?.head(obj, s[2])
-obj?.head(obj, string(a))
-obj?.head(obj, true).a
-obj?.head(obj, true)?.a
-obj?.head(obj, true)?.b
-obj?.head(obj, true, 1, arr)?.b
-obj?.head(obj, true, div, obj)?.b
-obj?.head(obj, true, nil).obj
-obj?.head(obj.a)
-obj?.head(obj.a, add)
-obj?.head(obj.a, get(a, add))
-obj?.head(obj.b)
-obj?.head(obj.b, get(a, 2))
-obj?.head(obj.b, obj.head(ok, 0, add, 0.5, add))
-obj?.head(obj.b, string("a"))
-obj?.head(obj.fn(2))
-obj?.head(obj.fn(a))
-obj?.head(obj.head("c", "c"), map(obj, true))
-obj?.head(obj.head(0))
-obj?.head(obj.head(0, false, s))
-obj?.head(obj.head(0.5, true))
-obj?.head(obj.head(2))
-obj?.head(obj.head(add))
-obj?.head(obj.head(arr))
-obj?.head(obj.head(arr, add))
-obj?.head(obj.head(arr, div))
-obj?.head(obj.head(b))
-obj?.head(obj.head(b), b, 0 == add)
-obj?.head(obj.head(b, 0.5, a))
-obj?.head(obj.head(div))
-obj?.head(obj.head(div, div))
-obj?.head(obj.head(f))
-obj?.head(obj.head(false, b, f, b, a))
-obj?.head(obj.head(obj))
-obj?.head(obj.head(ok))
-obj?.head(obj.head(ok, nil, f))
-obj?.head(obj.head(s, a, add, add, add))
-obj?.head(obj.head(s, ok))
-obj?.head(obj.head(true))
-obj?.head(obj.obj)
-obj?.head(obj.obj).b
-obj?.head(obj.obj)?.b
-obj?.head(obj.obj, f)
-obj?.head(obj.obj, get(add, 0))
-obj?.head(obj.obj, obj)
-obj?.head(obj.obj, ok)
-obj?.head(obj?.a)
-obj?.head(obj?.a, div)
-obj?.head(obj?.a, obj)
-obj?.head(obj?.a, obj.a)
-obj?.head(obj?.a, ok or false)
-obj?.head(obj?.a, s)
-obj?.head(obj?.b)
-obj?.head(obj?.b, "c" <= s)
-obj?.head(obj?.b, f)
-obj?.head(obj?.b, filter(arr, ok))
-obj?.head(obj?.fn(a), b)
-obj?.head(obj?.fn(b))
-obj?.head(obj?.head("a"))
-obj?.head(obj?.head(0))
-obj?.head(obj?.head(0.5))
-obj?.head(obj?.head(1))
-obj?.head(obj?.head(a))
-obj?.head(obj?.head(a, arr))
-obj?.head(obj?.head(a, ok, obj, add))
-obj?.head(obj?.head(add))
-obj?.head(obj?.head(add, add))
-obj?.head(obj?.head(add, false))
-obj?.head(obj?.head(arr, nil))
-obj?.head(obj?.head(b))
-obj?.head(obj?.head(b, a))
-obj?.head(obj?.head(b, a, div))
-obj?.head(obj?.head(b, false))
-obj?.head(obj?.head(b, s))
-obj?.head(obj?.head(f, a, 1))
-obj?.head(obj?.head(false))
-obj?.head(obj?.head(false, "c"))
-obj?.head(obj?.head(obj))
-obj?.head(obj?.head(obj)).obj
-obj?.head(obj?.head(obj, 0))
-obj?.head(obj?.head(ok))
-obj?.head(obj?.head(ok), div)
-obj?.head(obj?.head(ok, 0))
-obj?.head(obj?.head(ok, 0, add), obj?.a)
-obj?.head(obj?.head(s))
-obj?.head(obj?.head(s, arr, 0.5))
-obj?.head(obj?.head(s, arr, true))
-obj?.head(obj?.head(s, nil, 0))
-obj?.head(obj?.head(s, true))
-obj?.head(obj?.obj)
-obj?.head(obj?.obj).obj
-obj?.head(obj?.obj)?.obj
-obj?.head(obj?.obj, a)
-obj?.head(obj?.obj, map(obj, ok))
-obj?.head(obj[nil])
-obj?.head(obj[s])
-obj?.head(ok != "c", b)
-obj?.head(ok != a)
-obj?.head(ok != arr)
-obj?.head(ok != b)
-obj?.head(ok != div)
-obj?.head(ok != f)
-obj?.head(ok != false)
-obj?.head(ok != obj)
-obj?.head(ok != s, get(s, 1), add)
-obj?.head(ok && "a")
-obj?.head(ok && 0)
-obj?.head(ok && 1 % b)
-obj?.head(ok && a)
-obj?.head(ok && a, obj != f)
-obj?.head(ok && arr)
-obj?.head(ok && f)
-obj?.head(ok && obj)
-obj?.head(ok && ok)
-obj?.head(ok == 0)
-obj?.head(ok == 0, f)
-obj?.head(ok == 1, add == obj)
-obj?.head(ok == 2)
-obj?.head(ok == a)
-obj?.head(ok == b)
-obj?.head(ok == div)
-obj?.head(ok == div, f)
-obj?.head(ok == obj)
-obj?.head(ok == ok)
-obj?.head(ok == s)
-obj?.head(ok == true)
-obj?.head(ok ? "b" : add)
-obj?.head(ok ? "c" : "b")
-obj?.head(ok ? 1 : arr)
-obj?.head(ok ? 1 : div.b)
-obj?.head(ok ? a : "c")
-obj?.head(ok ? a : f)
-obj?.head(ok ? a : obj, add)
-obj?.head(ok ? add : div)
-obj?.head(ok ? add : obj, s, obj.head(a, obj))
-obj?.head(ok ? arr : div)
-obj?.head(ok ? arr : nil)
-obj?.head(ok ? b : 0.5)
-obj?.head(ok ? b : b)
-obj?.head(ok ? b : nil && div)
-obj?.head(ok ? div : 0.5)
-obj?.head(ok ? div : arr)
-obj?.head(ok ? div : nil)
-obj?.head(ok ? f : 1)
-obj?.head(ok ? false : ok)
-obj?.head(ok ? nil : 0.5)
-obj?.head(ok ? nil : arr)
-obj?.head(ok ? nil : b, obj?.b)
-obj?.head(ok ? nil : f, arr)
-obj?.head(ok ? nil : ok)
-obj?.head(ok ? obj : add)
-obj?.head(ok ? obj : b)
-obj?.head(ok ? obj : s)
-obj?.head(ok ? ok : arr)
-obj?.head(ok ? true : add)
-obj?.head(ok and "a")
-obj?.head(ok and a, last(0.5))
-obj?.head(ok and add)
-obj?.head(ok and b)
-obj?.head(ok and div, get(0, arr))
-obj?.head(ok and f)
-obj?.head(ok and nil, f)?.obj
-obj?.head(ok and obj)
-obj?.head(ok and obj).obj
-obj?.head(ok and ok)
-obj?.head(ok and s)
-obj?.head(ok in arr)
-obj?.head(ok or "a")
-obj?.head(ok or "c")
-obj?.head(ok or 2)
-obj?.head(ok or a)
-obj?.head(ok or add)
-obj?.head(ok or arr)
-obj?.head(ok or div)
-obj?.head(ok or get(div >= b, arr?.head("b")))
-obj?.head(ok or nil)
-obj?.head(ok or obj)
-obj?.head(ok or true, a)
-obj?.head(ok || 0)
-obj?.head(ok || 0, f)
-obj?.head(ok || a)
-obj?.head(ok || add)
-obj?.head(ok || arr.obj in map("b" / a, min(f)).obj)
-obj?.head(ok || b || add.fn(0.5, obj))
-obj?.head(ok || div)
-obj?.head(ok || div, 1 != add)
-obj?.head(ok || s)
-obj?.head(ok)
-obj?.head(ok) != a
-obj?.head(ok) != f
-obj?.head(ok) != obj?.a
-obj?.head(ok) != obj?.b
-obj?.head(ok) && not ok
-obj?.head(ok) && ok
-obj?.head(ok) == a
-obj?.head(ok) == obj.obj
-obj?.head(ok) == ok
-obj?.head(ok) ? s : arr
-obj?.head(ok) and 0 == nil
-obj?.head(ok) and 0.5 != a
-obj?.head(ok) or ok
-obj?.head(ok) || obj?.a?.head(b <= a ? s : a / a || lastIndexOf(2) % (arr matches 0.5))
-obj?.head(ok, "a" contains "b")
-obj?.head(ok, 2) == keys(obj)
-obj?.head(ok, a)
-obj?.head(ok, add != a)
-obj?.head(ok, arr)
-obj?.head(ok, b)
-obj?.head(ok, div)
-obj?.head(ok, f)
-obj?.head(ok, f) == s
-obj?.head(ok, f, b)
-obj?.head(ok, false or ok)
-obj?.head(ok, false) or ok
-obj?.head(ok, map(arr, false))
-obj?.head(ok, none(s, false))
-obj?.head(ok, not ok)
-obj?.head(ok, obj)
-obj?.head(ok, obj) != add ? b : nil
-obj?.head(ok, obj.head(s), obj)
-obj?.head(ok, obj?.obj)
-obj?.head(ok, ok or 0.5)
-obj?.head(ok, s)
-obj?.head(ok, s, ok, 0.5) == obj
-obj?.head(ok, s, s) == a
-obj?.head(one("a", ok))
-obj?.head(one("b", true))
-obj?.head(one(arr, false))
-obj?.head(one(arr, ok))
-obj?.head(one(arr, ok), ok)
-obj?.head(one(arr, true))
-obj?.head(one(obj, false))
-obj?.head(one(obj, ok))
-obj?.head(one(obj, true))
-obj?.head(one(s, # < #))
-obj?.head(one(s, ok))
-obj?.head(one(s, true))
-obj?.head(s != "a", f)
-obj?.head(s != "b")
-obj?.head(s != 0)
-obj?.head(s != 1)
-obj?.head(s != 2)
-obj?.head(s != 2, obj)
-obj?.head(s != a)
-obj?.head(s != add)
-obj?.head(s != arr)
-obj?.head(s != b)
-obj?.head(s != div)
-obj?.head(s != f)
-obj?.head(s != nil)
-obj?.head(s != obj)
-obj?.head(s != ok)
-obj?.head(s + s)
-obj?.head(s <= "b")
-obj?.head(s <= s)
-obj?.head(s == "b")
-obj?.head(s == "c")
-obj?.head(s == 0)
-obj?.head(s == 2)
-obj?.head(s == a)
-obj?.head(s == add)
-obj?.head(s == arr)
-obj?.head(s == f)
-obj?.head(s == false)
-obj?.head(s == obj)
-obj?.head(s == ok)
-obj?.head(s == s)
-obj?.head(s == true)
-obj?.head(s > s)
-obj?.head(s >= s)
-obj?.head(s and false)
-obj?.head(s contains "a")
-obj?.head(s contains s, add != 0.5)
-obj?.head(s endsWith "a")
-obj?.head(s endsWith s)
-obj?.head(s in arr)
-obj?.head(s in obj)
-obj?.head(s matches s, ok or ok)
-obj?.head(s or false)
-obj?.head(s startsWith "b")
-obj?.head(s startsWith s)
-obj?.head(s)
-obj?.head(s) != div
-obj?.head(s) != obj.a
-obj?.head(s) == arr
-obj?.head(s) == ok
-obj?.head(s) endsWith string(0.5)
-obj?.head(s)[a]
-obj?.head(s, "a") != s
-obj?.head(s, "b" == a)
-obj?.head(s, "b", 0.5) == div
-obj?.head(s, a % a)
-obj?.head(s, a)
-obj?.head(s, add)
-obj?.head(s, add, nil, arr) != f
-obj?.head(s, arr)
-obj?.head(s, arr) == f
-obj?.head(s, arr) == ok
-obj?.head(s, arr, div)
-obj?.head(s, b == add)
-obj?.head(s, div)
-obj?.head(s, f)
-obj?.head(s, get(0, div))
-obj?.head(s, get(f, obj))
-obj?.head(s, nil) != ok
-obj?.head(s, nil, add)[2 + 0]
-obj?.head(s, nil, ok, f)[a]
-obj?.head(s, none(s, ok))
-obj?.head(s, now(0.5, f, ok))
-obj?.head(s, obj.obj)
-obj?.head(s, ok in nil)
-obj?.head(s, ok)
-obj?.head(s, ok) in obj
-obj?.head(s, ok, ok) != f == nil
-obj?.head(s, s)
-obj?.head(s[0.5])
-obj?.head(s[a])
-obj?.head(s[b])
-obj?.head(s[f])
-obj?.head(string("a"))
-obj?.head(string("a", b))
-obj?.head(string("c"))
-obj?.head(string(1, nil))
-obj?.head(string(2))
-obj?.head(string(a))
-obj?.head(string(a), 0 or false)
-obj?.head(string(arr))
-obj?.head(string(arr), arr)
-obj?.head(string(arr), b == 2)
-obj?.head(string(div))
-obj?.head(string(div, f))
-obj?.head(string(f))
-obj?.head(string(nil))
-obj?.head(string(nil, "c", s))
-obj?.head(string(nil, s))
-obj?.head(string(obj))
-obj?.head(string(obj, arr, ok, nil))
-obj?.head(string(s))
-obj?.head(string(s, "b"))
-obj?.head(string(s, 2))
-obj?.head(string(s, arr, ok, obj))
-obj?.head(toBase64("a"))
-obj?.head(toBase64("b"))
-obj?.head(toBase64(s))
-obj?.head(toBase64(s, 0.5))
-obj?.head(toBase64(s, 1))
-obj?.head(toJSON("a"))
-obj?.head(toJSON("c"))
-obj?.head(toJSON("c", nil))
-obj?.head(toJSON(0.5, nil))
-obj?.head(toJSON(2, "c"))
-obj?.head(toJSON(2, b))
-obj?.head(toJSON(a))
-obj?.head(toJSON(a, 0))
-obj?.head(toJSON(a, s))
-obj?.head(toJSON(arr))
-obj?.head(toJSON(arr), div)
-obj?.head(toJSON(b))
-obj?.head(toJSON(b, 0, s))
-obj?.head(toJSON(f))
-obj?.head(toJSON(f, "b"))
-obj?.head(toJSON(false), ok)
-obj?.head(toJSON(nil))
-obj?.head(toJSON(nil, nil, 2, div))
-obj?.head(toJSON(true, a))
-obj?.head(trim("c"))
-obj?.head(trimPrefix("a", ok, "c", s, 0.5))
-obj?.head(trimPrefix("c"))
-obj?.head(trimPrefix("c", s))
-obj?.head(trimSuffix("b"))
-obj?.head(true != 0.5)
-obj?.head(true != ok)
-obj?.head(true != s)
-obj?.head(true != true)
-obj?.head(true && a)
-obj?.head(true && arr)
-obj?.head(true && arr, any(arr, ok))
-obj?.head(true && b)
-obj?.head(true == add)
-obj?.head(true == div)
-obj?.head(true == obj, div(2, 1))
-obj?.head(true == ok)
-obj?.head(true ? "b" : obj)
-obj?.head(true ? a : obj)
-obj?.head(true ? add : div)
-obj?.head(true ? arr : add)
-obj?.head(true ? div : b)
-obj?.head(true ? nil : arr)
-obj?.head(true ? obj : arr)
-obj?.head(true ? obj : ok)
-obj?.head(true ? ok : b)
-obj?.head(true and "c")
-obj?.head(true and nil)
-obj?.head(true and obj)
-obj?.head(true and true, b)
-obj?.head(true in nil)
-obj?.head(true or b, string("c"))
-obj?.head(true or nil)
-obj?.head(true or obj)
-obj?.head(true or s)
-obj?.head(true || div)
-obj?.head(true || false, s contains s)
-obj?.head(true || nil, add)
-obj?.head(true) != div
-obj?.head(true) or f < 1
-obj?.head(true, div) or obj.b
-obj?.head(true, f, ok, obj) and add == add
-obj?.head(true, obj) == b ? 0 : obj.b
-obj?.head(true, ok, b, 0) or obj.a
-obj?.head(true, s, div, f) == obj.b
-obj?.head(upper("a"))
-obj?.head(upper("b"))
-obj?.head(upper(1, s))
-obj?.head(upper(s))
-obj?.head(upper(true, f, 1, s))
-obj?.head(values(obj))
-obj?.head({"a": 0, "b": div})
-obj?.head({"b": s})
-obj?.head({"c": f})
-obj?.obj
-obj?.obj != -a
-obj?.obj != -f
-obj?.obj != a
-obj?.obj != add
-obj?.obj != any(arr, false)
-obj?.obj != arr
-obj?.obj != arr ? ok : s
-obj?.obj != arr ? s : nil
-obj?.obj != b
-obj?.obj != div
-obj?.obj != div(b, a)
-obj?.obj != f
-obj?.obj != float(0.5)
-obj?.obj != map(arr, true)
-obj?.obj != max(0.5)
-obj?.obj != nil == nil
-obj?.obj != nil == ok
-obj?.obj != obj ? arr : ok
-obj?.obj != obj.obj
-obj?.obj != obj?.a
-obj?.obj != obj?.b
-obj?.obj != ok
-obj?.obj != s
-obj?.obj == -a
-obj?.obj == a
-obj?.obj == a ** a
-obj?.obj == a ** f
-obj?.obj == add
-obj?.obj == add(2, b)
-obj?.obj == add(a, b)
-obj?.obj == add(b, 0)
-obj?.obj == arr
-obj?.obj == b
-obj?.obj == b ? 2 : div
-obj?.obj == b ? add : a
-obj?.obj == div
-obj?.obj == div ? arr : a
-obj?.obj == f
-obj?.obj == map(arr, ok)
-obj?.obj == obj
-obj?.obj == obj ? b : false
-obj?.obj == obj.obj
-obj?.obj == obj.obj.a
-obj?.obj == obj?.b
-obj?.obj == ok
-obj?.obj == s
-obj?.obj == s + "a"
-obj?.obj in arr
-obj?.obj in obj.head(arr, obj)
-obj?.obj or 1 == 0
-obj?.obj.a
-obj?.obj.a != add
-obj?.obj.a != arr
-obj?.obj.a == arr
-obj?.obj.a == f
-obj?.obj.b
-obj?.obj.b > b
-obj?.obj.b >= a
-obj?.obj.obj
-obj?.obj.obj == arr
-obj?.obj.obj.a
-obj?.obj.obj.b
-obj?.obj.obj.b == add
-obj?.obj.obj.obj
-obj?.obj.obj?.a
-obj?.obj.obj?.b
-obj?.obj.obj?.obj
-obj?.obj?.a
-obj?.obj?.a <= b
-obj?.obj?.a == add
-obj?.obj?.b
-obj?.obj?.b == div
-obj?.obj?.b == obj
-obj?.obj?.obj
-obj?.obj?.obj != ok
-obj?.obj?.obj.a
-obj?.obj?.obj.b
-obj?.obj?.obj.obj
-obj?.obj?.obj?.a
-obj?.obj?.obj?.b
-obj?.obj?.obj?.obj
-obj?.obj[obj.head(s, 0)] == add
-obj?.obj[obj?.head(nil, "a")]
-obj?.obj[obj?.head(s)]
-obj?.obj[s]
-obj?.obj[string(0.5)]?.a
-obj[nil] != div
-obj[nil] != s
-obj[nil] == add
-obj[nil] == arr
-obj[nil] == f
-obj[nil]?.a
-obj[nil]?.a.a
-obj[nil]?.a.b
-obj[nil]?.a.obj
-obj[nil]?.a?.a
-obj[nil]?.b
-obj[nil]?.b?.b
-obj[nil]?.fn(b)
-obj[nil]?.fn(ok)
-obj[nil]?.head(arr)
-obj[nil]?.obj
-obj[nil]?.obj.obj
-obj[obj.head(s)]
-obj[ok ? "b" : add]
-obj[s[a:b]]
-obj[s]
-obj[s] != arr
-obj[s] != div
-obj[s] != f
-obj[s] != f ? add : div
-obj[s] != s
-obj[s] == !ok
-obj[s] == add
-obj[s] == obj.head(s)
-obj[s]?.a
-obj[s]?.a.b
-obj[s]?.a?.b
-obj[s]?.b
-obj[s]?.b.a
-obj[s]?.b.b
-obj[s]?.b?.obj
-obj[s]?.fn(a > 0).b
-obj[s]?.fn(f)
-obj[s]?.head(get(b == a))
-obj[s]?.head(obj.a)
-obj[s]?.head(ok || a)
-obj[s]?.obj
-obj[s]?.obj.b
-obj[s]?.obj.obj
-obj[s]?.obj?.a
-obj[s]?.obj?.b.obj
-obj[s]?.obj?.obj
-obj[string("a")]
-obj[string(2)]?.a
-obj[string(add)]
-obj[string(nil)]
-obj[string(obj)]
-obj[toJSON("b")]
-obj[toJSON(a)]
-obj[toJSON(f)]
-obj[toJSON(ok)]?.obj
-obj[trimPrefix("b")]
-obj[upper(s)]
 ok
+ok != !ok
 ok != !true
-ok != (arr != arr || a > a)
-ok != (ok or true)
-ok != (true || true)
-ok != false ? 1 : "b"
-ok != first(obj?.head(0.5))
-ok != nil != nil
-ok != nil != ok
-ok != nil != true
-ok != nil == ok
-ok != nil ? true : f
-ok != nil || one(arr, ok)
-ok != none(arr, false)
-ok != obj.a
-ok != obj.b
-ok != obj.head("a", true)
-ok != obj.head(add)
-ok != obj.head(arr)
-ok != obj.head(f, "c")
-ok != obj.head(ok, "c", nil, nil)
-ok != obj.obj
-ok != obj.obj.obj
-ok != obj?.a
-ok != obj?.b
-ok != obj?.fn(a)
-ok != obj?.fn(b)
-ok != obj?.head(1)
-ok != obj?.head(get(ok, obj))?.b
-ok != obj?.head(nil, add)
-ok != obj?.head(obj == obj)
-ok != obj?.head(ok)
-ok != obj?.obj
-ok != obj?.obj.a
-ok != obj?.obj.obj == nil ? s : obj.obj?.obj
-ok != obj?.obj?.a
-ok != obj?.obj?.b
+ok != false != ok
+ok != false ? 1 : i
+ok != nil == nil
+ok != none(list, ok)
+ok != not !ok
+ok != not ok
 ok != ok
-ok != ok != ok
-ok != ok and obj.fn(f, nil)
-ok != ok or b >= a
-ok != one(arr, false)
-ok != true ? "b" : nil
-ok && !ok
-ok && "a" > "a"
-ok && "a" >= s
-ok && "c" < s
-ok && (true || ok)
-ok && 0 != f
-ok && 0 <= f
-ok && 0 == nil
-ok && 0.5 != b
-ok && 0.5 >= f
-ok && 1 != 2
-ok && 2 != f
-ok && 2 > f
-ok && a < 1
-ok && a < b
-ok && a <= 0
-ok && a <= a
-ok && a <= f
-ok && a == 0
-ok && a >= f
-ok && all(arr, ok)
-ok && all(arr, true)
-ok && arr != arr
-ok && arr == arr
-ok && b < 0.5
-ok && b == b
-ok && b >= f
-ok && b in arr
-ok && div == nil
-ok && f != 0
-ok && f != f
-ok && f < f
-ok && false && ok
-ok && false ? f : toJSON("c")
-ok && nil == "c"
-ok && nil == f
-ok && none(arr, ok)
-ok && not ok
-ok && obj.a
-ok && obj.b
-ok && obj.head(a)
-ok && obj.head(b)
-ok && obj.head(b, obj)
-ok && obj.head(false)
-ok && obj.obj
-ok && obj.obj?.a
-ok && obj.obj?.obj
-ok && obj?.a
-ok && obj?.b
-ok && obj?.head(a, b)
-ok && obj?.head(add, b, nil, obj)
-ok && obj?.head(arr)
-ok && obj?.head(false)
-ok && obj?.head(nil)
-ok && obj?.obj
-ok && obj?.obj != obj.b
-ok && obj?.obj?.a
-ok && obj?.obj?.b
+ok != ok || ok
+ok && !ok ? f32 : 0.5
+ok && !true
+ok && "bar" >= "bar"
+ok && "foo" <= "bar"
+ok && 0.5 != nil
+ok && 0.5 == 0.5
+ok && 0.5 >= f32
+ok && 1 != f64
+ok && 1 != i32
+ok && 1 < 1
+ok && 1 <= 0.5
+ok && 1 == f64
+ok && 1 >= f32
+ok && div == half
+ok && f32 != 0.5
+ok && f32 < 0.5
+ok && f32 == f32
+ok && f32 == i64
+ok && f64 < 1
+ok && f64 < i32
+ok && f64 == i32
+ok && f64 >= i32
+ok && false == false
+ok && i != i
+ok && i32 != 0.5
+ok && i32 < f32
+ok && i32 <= i64
+ok && i32 == 1
+ok && i32 >= 1
+ok && i64 < i32
+ok && i64 <= i32
+ok && i64 > 1
+ok && list != array
+ok && nil != f64
+ok && nil == add
+ok && nil == i32
+ok && nil == true
 ok && ok
-ok && ok ? a : ok
-ok && ok ? add : s
-ok && ok ? b : a
-ok && ok ? f : obj
-ok && ok and obj?.obj
-ok && ok or nil == a
-ok && ok or obj?.head(div, f)
-ok && ok || ok
-ok && s != s
-ok && s contains "b"
-ok && true && obj.obj
-ok && true and ok
-ok && true or obj?.obj
-ok == !true
-ok == (false || ok)
-ok == (ok and true)
-ok == false == ok ? b : obj
-ok == false || 0.5 >= f
-ok == false || s != nil
-ok == nil ? 2 : arr
-ok == nil ? add : arr
-ok == nil ? div : "a"
-ok == nil ? div : obj.b
-ok == nil ? f : ok
-ok == nil ? nil : "c"
-ok == obj.a
-ok == obj.b
-ok == obj.head(a)
-ok == obj.head(add)
-ok == obj.head(b)
-ok == obj.head(div)
-ok == obj.head(f, s, 0, 2)
-ok == obj.head(ok)
-ok == obj.head(s)
-ok == obj.head(true)
-ok == obj.obj
-ok == obj?.a
-ok == obj?.b
-ok == obj?.head(0, s)
-ok == obj?.head(a != a)
-ok == obj?.head(a, 0, obj)
-ok == obj?.head(a, obj, 0, s, obj)
-ok == obj?.head(add)
-ok == obj?.head(add, add)
-ok == obj?.head(b, "a", add)
-ok == obj?.head(div, "b")
-ok == obj?.head(nil, false)
-ok == obj?.head(obj.head(arr, b))
-ok == obj?.head(ok)
-ok == obj?.head(ok, div, f, nil, 0.5)
-ok == obj?.obj
+ok && score != add
+ok && true != ok
+ok && true == nil
+ok == !false
+ok == !ok
+ok == (false or true)
+ok == (ok and ok)
+ok == any(list, ok)
+ok == false == nil
+ok == nil ? false : add
+ok == nil ? score : array
+ok == not false
+ok == not true
 ok == ok
-ok == ok != (ok or true)
-ok == ok == obj?.a
-ok == ok ? add : nil
-ok == ok ? b : s
-ok == ok and arr == arr
-ok == ok || obj.obj
-ok == one(arr, ok)
-ok == true != nil
-ok == true ? add : s
-ok == true and ok
-ok ? "a" : a != b / b
-ok ? "a" : f == obj.b
-ok ? "a" : obj.a
-ok ? "a" : obj.b
-ok ? "a" : obj?.a
-ok ? "b" : b % obj.head(ok)
-ok ? "b" : obj.b
-ok ? "b" : obj.obj
-ok ? "b" : obj?.b?.b
-ok ? "b" : obj?.obj
-ok ? "b" : s endsWith obj.head(add)
-ok ? "c" : 0 % a
-ok ? "c" : 0.5 * f
-ok ? "c" : obj?.b
-ok ? "c" : obj?.fn(add(arr, a) in none(0, b))
-ok ? "c" : obj?.head(arr?.head(a), arr.head(!arr, div?.head(obj, "c"), int(div, div)))
-ok ? 0 * b : obj?.obj
-ok ? 0 : 1 / obj.fn(add, false, add)
-ok ? 0 : a == b
-ok ? 0 : f * b
-ok ? 0 : obj != obj
-ok ? 0 : obj.a
-ok ? 0 : obj.obj
-ok ? 0 : obj?.a
-ok ? 0 : obj?.b
-ok ? 0 : obj?.b.head(add(map(f / b, add(0.5)), add(arr * s, upper(b))))
-ok ? 0 : obj?.fn(add?.obj).b
-ok ? 0 : obj?.fn(any(a, ok))
-ok ? 0 : obj?.fn(div(a.head("c", obj), div(div)))
-ok ? 0 : obj?.fn(div(false))?.a
-ok ? 0 : obj?.head(any(ok, div(obj)))
-ok ? 0 : obj?.head(hasPrefix(true, "c", add, f), div.a)
-ok ? 0 : obj?.obj
-ok ? 0 : s <= obj.b
-ok ? 0 == 0 : s
-ok ? 0.5 != 0 : trim(nil, s)
-ok ? 0.5 : add == obj.fn(s)
-ok ? 0.5 : b == obj?.a
-ok ? 0.5 : f ^ f
-ok ? 0.5 : obj.a
-ok ? 0.5 : obj.b
-ok ? 0.5 : obj.fn(obj)
-ok ? 0.5 : obj.head(add.a * div.fn(0, f))
-ok ? 0.5 : obj.obj
-ok ? 0.5 : obj?.a
-ok ? 0.5 : obj?.b
-ok ? 0.5 : obj?.head(nil - arr)
-ok ? 0.5 : obj?.obj
-ok ? 1 + b : a
-ok ? 1 : obj in obj.b
-ok ? 1 : obj.b
-ok ? 1 : obj?.head(arr[0:obj], a?.a)
-ok ? 1 : obj?.obj
-ok ? 2 : add == div
-ok ? 2 : obj.b
-ok ? 2 : obj.obj
-ok ? 2 : obj?.a
-ok ? a : "a" != s
-ok ? a : -0
-ok ? a : 0 < b
-ok ? a : 0 > a
-ok ? a : 0.5 / a
-ok ? a : 1 + f
-ok ? a : 2 / a
-ok ? a : a / obj.obj
-ok ? a : a >= a
-ok ? a : add
-ok ? a : obj.a
-ok ? a : obj.b
-ok ? a : obj.head(all(b, a))
-ok ? a : obj.obj
-ok ? a : obj.obj < a
-ok ? a : obj?.a
-ok ? a : obj?.b
-ok ? a : obj?.head(add).head(join(nil, ok) + f)
-ok ? a : obj?.head(div(add(arr, div, b, "a", b)))
-ok ? a : obj?.head(now(add(div, obj, add), add.obj, get(ok, b), div(arr)))
-ok ? a : obj?.obj
-ok ? a : s
-ok ? a < 1 : add
-ok ? a < a : obj
-ok ? abs(0) : f
-ok ? add : 0.5 * a
-ok ? add : 0.5 >= a
-ok ? add : a
-ok ? add : arr
-ok ? add : b .. a
+ok ? "bar" : i == f32
+ok ? "bar" : i32 < i32
+ok ? "foo" : foo.String
+ok ? -0.5 : foo
+ok ? -f32 : i64 + 1
+ok ? -f64 : score
+ok ? -i64 : ok
+ok ? 0.5 * array[i64] : greet
+ok ? 0.5 : f64 < i64
+ok ? 0.5 : half != add
+ok ? 0.5 : i .. i
+ok ? 0.5 < i32 : score
+ok ? 0.5 == 0.5 : half
+ok ? 1 : 1 + i64 + i32
+ok ? 1 : foo.Bar
+ok ? 1 : foo.String
+ok ? add : add
+ok ? add : array
 ok ? add : div
-ok ? add : f
-ok ? add : nil != obj.b
-ok ? add : nil == div
-ok ? add : obj
-ok ? add : obj in obj.b
-ok ? add : obj.a
-ok ? add : obj.b
-ok ? add : obj.b?.obj
-ok ? add : obj.fn("c", b).obj
-ok ? add : obj.fn(f.a < a?.head(1), f)
-ok ? add : obj.head(arr, s)
-ok ? add : obj.head(true)?.obj
-ok ? add : obj.obj
-ok ? add : obj.obj != obj.obj
-ok ? add : obj?.a
-ok ? add : obj?.b
-ok ? add : obj?.b.b
-ok ? add : obj?.fn(a?.fn(filter(0.5, "b"), add(a, arr)))
-ok ? add : obj?.fn(add(obj endsWith obj), obj)
-ok ? add : obj?.fn(none(arr, ok) > f - arr)
-ok ? add : obj?.obj
+ok ? add : f32
+ok ? add : greet
+ok ? add : i
+ok ? add : i32
+ok ? add : i64
+ok ? add : list
 ok ? add : ok
-ok ? add : s
-ok ? arr : "c" == obj?.obj
-ok ? arr : 0 ** a
-ok ? arr : a
-ok ? arr : a + add(b, nil)
-ok ? arr : a > b
-ok ? arr : add
-ok ? arr : arr
-ok ? arr : arr in fromJSON(s)
-ok ? arr : arr in obj?.fn(a)
-ok ? arr : b
-ok ? arr : b .. a
-ok ? arr : b > obj.head(0.5, 0, ok)
-ok ? arr : div == obj?.head(nil)
-ok ? arr : f
-ok ? arr : obj.b
-ok ? arr : obj.fn(arr)?.a
-ok ? arr : obj.head(all(f, a) matches div?.head("a", a), all(arr, b) / s?.fn(2), obj?.b?.a, count("b", add).b)
-ok ? arr : obj.head(div(add(a), arr?.fn(nil)), none(nil, ok) < hasSuffix(true, add), min(0.5, "c", true, div) ? div.obj : lower(false, a, 0))
-ok ? arr : obj.head(f.head(ok) + a)
-ok ? arr : obj.head(s, s)
-ok ? arr : obj.obj
-ok ? arr : obj?.b
-ok ? arr : obj?.b.b
-ok ? arr : obj?.fn(f startsWith len(true, obj, 0), arr matches b?.a).b
-ok ? arr : obj?.fn(obj in min(true, ok), all(a .. arr, f), ("c" == ok) * a)
-ok ? arr : obj?.obj
-ok ? arr : ok
-ok ? arr : s + s
-ok ? arr : s contains obj.a
-ok ? arr : s matches obj?.b
-ok ? arr[a:a] : nil != false
-ok ? b ** f : arr
-ok ? b + f : obj?.b
-ok ? b : (false ? b : nil)
-ok ? b : 0 + b
-ok ? b : add
-ok ? b : b
-ok ? b : div
-ok ? b : f >= f
-ok ? b : int(s)
-ok ? b : obj
-ok ? b : obj.a
-ok ? b : obj.obj
-ok ? b : obj?.a
-ok ? b : obj?.b
-ok ? b : obj?.fn("b" .. 0)
-ok ? b : obj?.fn(b?.obj, none(obj, ok))
-ok ? b : obj?.obj
-ok ? b : ok
-ok ? b : s < s
-ok ? b : s endsWith obj.b
-ok ? div : 1 * obj.a
-ok ? div : a
-ok ? div : a < f
-ok ? div : add
-ok ? div : b
-ok ? div : b - b ^ 0
+ok ? array : div
+ok ? array : f64
+ok ? array : float(i32)
+ok ? array : foo
+ok ? array : foo?.Bar
+ok ? array : i32
+ok ? array : i64
+ok ? array : list
+ok ? array : ok in map(array, ok)
 ok ? div : div
-ok ? div : f
-ok ? div : keys(obj)
-ok ? div : nil == ok
-ok ? div : obj.b
-ok ? div : obj.fn(ok != f, div?.obj)
-ok ? div : obj.obj
-ok ? div : obj?.a
-ok ? div : obj?.b
-ok ? div : obj?.fn(add)
-ok ? div : obj?.fn(obj.head(1))
-ok ? div : obj?.head(div, a.a)
-ok ? div : obj?.head(false ** true <= date(arr, s))
-ok ? div : obj?.head(obj?.head(s, 0, obj) .. add, none(div.a, false != 2))
-ok ? div : obj?.head(ok, add.fn(add)) * a
-ok ? div : obj?.obj
-ok ? div : obj[obj?.head(arr)]
-ok ? div : ok
-ok ? div : s <= s
-ok ? div : s contains s != true
-ok ? div : toJSON(0)
-ok ? div(a, b) : f
-ok ? f - 0 : a / a
-ok ? f : (true ? arr : "b")?.a
-ok ? f : 0 == obj.obj
-ok ? f : 0.5 ** b
-ok ? f : 0.5 - f
-ok ? f : 0.5 > f
-ok ? f : 2 % obj.fn(div)
-ok ? f : a * a
-ok ? f : a <= obj.head(true, ok)
-ok ? f : add
-ok ? f : b
-ok ? f : f
-ok ? f : f - obj.obj
-ok ? f : f >= f
-ok ? f : obj.a?.a
-ok ? f : obj.b
-ok ? f : obj.fn(any(div, f))
-ok ? f : obj.head(obj.head(1), all(s, b), add(true))
-ok ? f : obj.obj
-ok ? f : obj?.a
-ok ? f : obj?.b
-ok ? f : obj?.fn(div.obj, a, map(f, f), one(s, b))
-ok ? f : obj?.obj
-ok ? f : obj[obj.head("c")]?.b
-ok ? false : a / obj.a?.fn(div(arr, a, ok).b, add(obj[nil]))
-ok ? false : b - f
-ok ? false : obj.a
-ok ? false : obj.b
-ok ? false : obj.fn(div).a
-ok ? false : obj.head(ok)
-ok ? false : obj.head(s.fn(obj, add, obj))
-ok ? false : obj.obj
-ok ? false : obj?.a
-ok ? false : obj?.head(map(b, ok)).b
-ok ? false : obj?.obj
-ok ? map(arr, f) : arr
-ok ? map(arr, f) : obj?.b
-ok ? max(b) : s
-ok ? nil : 0 * get(arr, b)
-ok ? nil : a == f * b
-ok ? nil : arr[a:obj.obj]
-ok ? nil : b .. obj.b?.obj
-ok ? nil : f == a - a
-ok ? nil : obj.a
-ok ? nil : obj.b
-ok ? nil : obj.fn(0 % add.a)
-ok ? nil : obj.fn(div(s))
-ok ? nil : obj.obj
-ok ? nil : obj?.a
-ok ? nil : obj?.fn(add(arr, nil, b, obj))
-ok ? nil : obj?.fn(arr != ok, f.obj)
-ok ? nil : obj?.fn(filter(obj, b) and div(ok, b))?.head(b)
-ok ? nil : obj?.head(get("b" ** div, count(ok, add)))
-ok ? nil : obj?.obj
-ok ? nil == add : s
-ok ? not false : true || false
-ok ? obj : "b" startsWith obj.a
-ok ? obj : "c" < "a"
-ok ? obj : 0 - a ^ b
-ok ? obj : 0.5 * obj.b
-ok ? obj : 2 >= obj?.obj
-ok ? obj : a
-ok ? obj : a >= f
-ok ? obj : add
-ok ? obj : b ^ b
-ok ? obj : div
-ok ? obj : f
-ok ? obj : nil != s
-ok ? obj : obj
-ok ? obj : obj.a
-ok ? obj : obj.b
-ok ? obj : obj.fn(indexOf(map(add, div)))
-ok ? obj : obj.head(none(a, a / 0), nil .. f?.obj, div(0).a)
-ok ? obj : obj.obj
-ok ? obj : obj?.a
-ok ? obj : obj?.b
-ok ? obj : obj?.head(add.obj.a)
-ok ? obj : obj?.head(arr)
-ok ? obj : obj?.obj
-ok ? obj : ok
-ok ? obj : s
-ok ? obj : true != nil
-ok ? obj.a : 0.5 != 1
-ok ? obj.b : (ok ? 2 : add)
-ok ? obj.b : a
-ok ? obj.head(a) : a
-ok ? obj.head(nil, div, 0.5, add) : add
-ok ? obj.obj : s
-ok ? obj?.fn(0) : 1 * a
-ok ? obj?.obj : obj
-ok ? ok : a
-ok ? ok : a ^ obj.fn(a, 1)
-ok ? ok : add
-ok ? ok : arr
-ok ? ok : b > a - 0
-ok ? ok : div
-ok ? ok : obj.b
-ok ? ok : obj.b?.obj?.b
-ok ? ok : obj.fn(0.5 ^ f, none(arr, b), f?.obj, all(b, obj), splitN(true))
-ok ? ok : obj.fn(a || 0.5)
-ok ? ok : obj.fn(add.head(true && f, arr.head(f)))
-ok ? ok : obj.fn(arr.a, obj.head(a), any(f, obj), 0.5 - obj)
-ok ? ok : obj.fn(div, hasSuffix(f, 1)[ok], get(0 ? add : div, one(arr, s)))
-ok ? ok : obj.head(a)
-ok ? ok : obj.obj?.b
-ok ? ok : obj?.a
-ok ? ok : obj?.b
-ok ? ok : obj?.obj
-ok ? ok : obj?.obj.fn(arr)
-ok ? ok : s >= obj?.fn(false, "b")
-ok ? s : 0 - -0
-ok ? s : 0 - f
-ok ? s : 2 in arr ? a : a
-ok ? s : a % b
-ok ? s : add
-ok ? s : add in map(arr, add)
-ok ? s : add(b, a)
-ok ? s : arr
-ok ? s : arr == arr
-ok ? s : div
-ok ? s : f
-ok ? s : f + 2
-ok ? s : map(arr, #)
-ok ? s : nil == div
-ok ? s : obj
-ok ? s : obj.a
-ok ? s : obj.a.fn(add(s?.fn(a)).obj, get(arr.head("c"), 0 <= 0.5) > count(obj.a, s startsWith obj))
-ok ? s : obj.b
-ok ? s : obj.fn(a)
-ok ? s : obj.fn(div, a, false)
-ok ? s : obj.fn(filter(nil, arr) ^ div(ok, nil, f, s), arr?.head(not 0.5), div?.a)
-ok ? s : obj.fn(join(1))
-ok ? s : obj.fn(one(add, 1), div?.b)
-ok ? s : obj.head(div % f?.b)
-ok ? s : obj.obj
-ok ? s : obj?.a
-ok ? s : obj?.b
-ok ? s : obj?.obj
-ok ? s : obj?.obj.a
-ok ? s : s endsWith s
-ok ? trimSuffix("b") : obj
-ok ? true : false and 0 < a
-ok ? true : obj.a
-ok ? true : obj.fn((a startsWith add) - ok ? false : obj)
-ok ? true : obj.head(s <= div)
-ok ? true : obj?.a
-ok ? true : obj?.b
-ok ? true : obj?.obj
-ok ? true || obj?.a : obj
+ok ? div : f32
+ok ? div : f64
+ok ? div : foo?.String
+ok ? div : greet
+ok ? div : half
+ok ? div : half(1)
+ok ? div : i32
+ok ? div : i64
+ok ? div : list
+ok ? div : list == array
+ok ? div : score
+ok ? div : score(i)
+ok ? f32 : add
+ok ? f32 : array
+ok ? f32 : div
+ok ? f32 : f32
+ok ? f32 : f64
+ok ? f32 : foo
+ok ? f32 : foo?.Bar
+ok ? f32 : half
+ok ? f32 : i != i64
+ok ? f32 : i32
+ok ? f64 : array
+ok ? f64 : greet
+ok ? f64 : half
+ok ? f64 : i64
+ok ? f64 : score
+ok ? false : foo?.String()
+ok ? foo : add
+ok ? foo : foo
+ok ? foo : foo?.Bar
+ok ? foo : greet
+ok ? foo : i
+ok ? foo : i == i32
+ok ? foo : i32
+ok ? foo : i64
+ok ? foo : i64 ^ f32
+ok ? foo : list
+ok ? get(array, i32) : ok
+ok ? greet : add
+ok ? greet : div
+ok ? greet : f64 == i64
+ok ? greet : greet
+ok ? greet : half
+ok ? greet : i / i32
+ok ? greet : i32
+ok ? greet : i64 % i64
+ok ? greet : list
+ok ? greet : type(f64)
+ok ? half : 0.5 ^ i32
+ok ? half : add
+ok ? half : array
+ok ? half : div
+ok ? half : f32 == f64
+ok ? half : f64
+ok ? half : f64 <= i
+ok ? half : foo
+ok ? half : foo?.Bar
+ok ? half : greet
+ok ? half : half
+ok ? half : i
+ok ? half : i32
+ok ? half : list
+ok ? half : ok
+ok ? half : type(add)
+ok ? i : -i32
+ok ? i : 0.5 * i64
+ok ? i : 1 ** f64
+ok ? i : array
+ok ? i : div
+ok ? i : f32
+ok ? i : f64
+ok ? i : foo.Bar
+ok ? i : i
+ok ? i : i32
+ok ? i : ok
+ok ? i : score
+ok ? i32 + f32 : half
+ok ? i32 : -i32
+ok ? i32 : 1 not in array
+ok ? i32 : add
+ok ? i32 : array
+ok ? i32 : f32
+ok ? i32 : foo.Qux
+ok ? i32 : foo?.Qux
+ok ? i32 : half
+ok ? i32 : i
+ok ? i32 : i32
+ok ? i32 : list
+ok ? i32 : ok
+ok ? i32 >= f64 : f32
+ok ? i64 : array
+ok ? i64 : div
+ok ? i64 : f32
+ok ? i64 : f64
+ok ? i64 : half
+ok ? i64 : i32
+ok ? i64 : i64
+ok ? i64 : ok
+ok ? int(1) : div
+ok ? list : -1
+ok ? list : add
+ok ? list : array
+ok ? list : div
+ok ? list : f32
+ok ? list : i32
+ok ? list : i64
+ok ? list : list
+ok ? list : nil in array
+ok ? list : ok
+ok ? list : score
+ok ? lower("foo") : f32
+ok ? map(array, #) : duration("foo")
+ok ? map(list, #) : score
+ok ? min(f32) : score
+ok ? min(i) : score
+ok ? nil : foo?.Bar
+ok ? ok : -f32
+ok ? ok : 0.5 + i
+ok ? ok : array
+ok ? ok : f64
+ok ? ok : foo
+ok ? ok : greet
+ok ? ok : i64
+ok ? ok : list
+ok ? ok : score
+ok ? score : add
+ok ? score : array
+ok ? score : f32
+ok ? score : foo.String
+ok ? score : foo?.String
+ok ? score : greet
+ok ? score : half
+ok ? score : half("bar")
+ok ? score : i
+ok ? score : i32
+ok ? score : list
+ok ? score : nil != div
+ok ? score : ok
+ok ? score : score
+ok ? string(half) : array
+ok ? toJSON("foo") : i32
+ok ? true : foo?.Qux
 ok and !ok
-ok and "a" == obj.a
-ok and "a" > "a"
-ok and 0 >= 0
-ok and 0.5 != b
-ok and 0.5 < f
-ok and 0.5 <= f
-ok and 0.5 > f
-ok and 1 >= 0
-ok and 2 >= 1
-ok and a < b
-ok and a == 0
-ok and a > b
-ok and b != 2
-ok and div != div
-ok and div == add
-ok and f <= a
-ok and f <= f
-ok and f == nil
-ok and f >= 0.5
-ok and f >= f
-ok and false && nil != obj
-ok and false && ok
-ok and false and ok
-ok and nil == "b"
-ok and nil == div
-ok and nil == obj
+ok and "bar" not endsWith foo?.Bar
+ok and "foo" endsWith "foo"
+ok and 0.5 <= f32
+ok and 0.5 > f64
+ok and 0.5 >= f64
+ok and 1 != 1
+ok and 1 != nil
+ok and 1 < i64
+ok and 1 == 1
+ok and add == add
+ok and any(list, false)
+ok and f32 >= 1
+ok and f64 != i
+ok and f64 != nil
+ok and f64 > 1
+ok and false != true
+ok and i > i32
+ok and i >= f64
+ok and i >= i64
+ok and i32 != nil
+ok and i32 == 0.5
+ok and i32 >= f64
+ok and i64 != nil
+ok and i64 <= i
+ok and i64 > 1
+ok and list == list
+ok and nil != i
+ok and nil != true
+ok and none(list, ok)
 ok and not ok
-ok and obj.a
-ok and obj.b
-ok and obj.fn(b)
-ok and obj.head(1, 0.5)
-ok and obj.head(f, "a", s)
-ok and obj.head(s)
-ok and obj.obj
-ok and obj.obj.b
-ok and obj.obj.obj
-ok and obj?.a
-ok and obj?.b
-ok and obj?.fn(not false ? 1 : arr)
-ok and obj?.head(add)
-ok and obj?.head(div)
-ok and obj?.head(obj?.head(arr))
-ok and obj?.head(one("c", ok))
-ok and obj?.obj
-ok and obj?.obj.obj
-ok and obj?.obj?.a
-ok and obj?.obj?.obj
-ok and obj[s]
+ok and not true
 ok and ok
-ok and ok && ok
-ok and ok ? 1 > b : a ** 1
-ok and ok ? add : !ok
-ok and ok ? arr : "c"
-ok and ok ? div : s
-ok and ok ? nil : arr
-ok and ok ? s : f
-ok and ok and true == false
-ok and s contains s
-ok and true or arr == arr
-ok in obj.head(nil, div, s)
-ok in obj?.head(arr, ok, add)
-ok in values(obj)
-ok or !obj?.obj
+ok not in sort(array)
+ok or !false
 ok or !ok
-ok or "b" <= s
-ok or "b" == nil
-ok or "b" > s
-ok or 0 < f
-ok or 0 <= b
-ok or 0 == f
-ok or 0 >= b
-ok or 0.5 != 0
-ok or 0.5 >= 0
-ok or 2 <= 0
-ok or a < 0
-ok or a <= b
-ok or a == nil
-ok or add != nil
-ok or add == div
-ok or b > f
-ok or b in arr
-ok or div != div
-ok or div != nil
-ok or div == div
-ok or f != 0.5
-ok or f != b
-ok or f < 0
-ok or f == f
-ok or f > 0
-ok or f >= b
-ok or false && ok
-ok or false ? s : nil
-ok or false or 2 < a
-ok or fromJSON(nil)
-ok or nil != add
-ok or nil != arr
-ok or nil == ok
-ok or nil in obj?.fn(obj != splitN("c", true, "b"), count(nil * f, div), add(0.5)?.b)
+ok or !true
+ok or "bar" < "bar"
+ok or "foo" != nil
+ok or 0.5 != i32
+ok or 0.5 != i64
+ok or 0.5 <= 0.5
+ok or 0.5 == 1
+ok or 0.5 >= i
+ok or 1 != i32
+ok or 1 >= 0.5
+ok or f64 < f32
+ok or f64 < i64
+ok or fromJSON("bar")
+ok or greet != add
+ok or half == nil
+ok or half == score
+ok or i != 0.5
+ok or i < 1
+ok or i32 < 0.5
+ok or i32 == f64
+ok or i32 > 0.5
+ok or i64 != f32
+ok or i64 == 1
+ok or list == array
+ok or nil != 0.5
 ok or not false
 ok or not ok
 ok or not true
-ok or obj.a
-ok or obj.a.b
-ok or obj.a.head(all(0 && nil, add(obj, false, "b")))
-ok or obj.a.obj
-ok or obj.a?.b
-ok or obj.a?.obj
-ok or obj.b
-ok or obj.b?.head(f)
-ok or obj.fn(-nil endsWith (nil || nil))
-ok or obj.fn(a, div)
-ok or obj.fn(a, s[div:arr]?.a)
-ok or obj.fn(add(arr)[arr:f], none(none(f, b), 0 .. 0))
-ok or obj.fn(arr .. a)?.b?.b
-ok or obj.fn(arr.b <= ok, b in add?.fn(obj))?.fn(add(arr, nil)?.head(b?.fn(nil, "b", false) .. none(add, b), filter(a.obj, div >= a), 0.5 ? div : arr matches date(nil), 0 ** nil * obj.head(ok), count(add(div), map(0, a))).a)
-ok or obj.fn(arr.fn(ok.head(0, add, a, a)))
-ok or obj.fn(b?.head(1, nil, 1, a, nil) matches add(s, a))
-ok or obj.fn(div(div .. 0, add(div)), indexOf(nil endsWith add))
-ok or obj.fn(div).head(filter(count(s, 0.5), add(obj)), arr startsWith obj || obj != div)
-ok or obj.fn(f, nil, arr)?.head(true contains b, ok.head(ok, arr)).b
-ok or obj.fn(fromBase64(any(b, true), s, add(div)), s)?.obj
-ok or obj.fn(map(2, b)?.obj, arr * 0.5 > filter(a, a))
-ok or obj.fn(obj ? div : div - add(add), b, none(div, a).obj)
-ok or obj.fn(ok, 0)
-ok or obj.head(0.5)
-ok or obj.head(0.5, obj)
-ok or obj.head(1, b, add, obj).b
-ok or obj.head(2 matches b, float(obj), none(b, div), add[add:1], 0.5 && s)
-ok or obj.head(a)
-ok or obj.head(add(div(0.5)), f)
-ok or obj.head(add.fn(2) matches obj?.head(nil, "c"))
-ok or obj.head(arr)
-ok or obj.head(arr?.obj, count(s, 0))
-ok or obj.head(b - nil)
-ok or obj.head(b ? s : "b" < div(arr), f.obj.fn(map(s, b)))
-ok or obj.head(b, b[nil] startsWith filter(false, b), s, div?.fn("a", obj, f) ? obj ** false : ok)
-ok or obj.head(div(count(2, obj), false || obj), filter(ok.fn(add), add?.head(ok)))
-ok or obj.head(div(count(nil, b), add("c")))
-ok or obj.head(div, a)
-ok or obj.head(div, ok)
-ok or obj.head(f)
-ok or obj.head(filter(add.head(s), one(a, 0.5)), add)
-ok or obj.head(obj)
-ok or obj.head(obj?.head(f))
-ok or obj.head(split(b))
-ok or obj.head(splitAfterN(a?.a) != (f && div(nil, 0)) != -min(div, 1), b)
-ok or obj.head(true)
-ok or obj.head(true, add)
-ok or obj.obj
-ok or obj.obj.a
-ok or obj.obj.obj
-ok or obj?.a
-ok or obj?.a.a
-ok or obj?.a.obj
-ok or obj?.a?.b
-ok or obj?.b
-ok or obj?.b.obj
-ok or obj?.fn("c" + 0)
-ok or obj?.fn("c", ok)
-ok or obj?.fn(a)
-ok or obj?.fn(a, div(filter(2, f)), add(first(a, true, s, "c")))
-ok or obj?.fn(add(a), b != b.b)
-ok or obj?.fn(add(s))
-ok or obj?.fn(add.b, ok endsWith arr)
-ok or obj?.fn(add?.b > s)
-ok or obj?.fn(arr, 1 ** nil)
-ok or obj?.fn(b)
-ok or obj?.fn(b?.head(s), arr)
-ok or obj?.fn(count(s?.head(0.5), add in f), join(add.a))
-ok or obj?.fn(div(s, obj, add))?.a.b
-ok or obj?.fn(f?.a)
-ok or obj?.fn(float(div))
-ok or obj?.fn(min(arr)[b:get(0.5, nil)])
-ok or obj?.fn(ok?.head(add(ok)), add(add?.obj))
-ok or obj?.fn(one(add(f, obj), a.fn(a)))
-ok or obj?.fn(one(arr, false) <= ok?.a)
-ok or obj?.fn(s)
-ok or obj?.fn(s?.b)
-ok or obj?.head(0)
-ok or obj?.head(2, a)
-ok or obj?.head(a in false matches add(nil), last(add(0), a.a), arr ^ obj == keys(nil, add), ok.obj)
-ok or obj?.head(add <= obj, "b" || a, a, get(a, div))
-ok or obj?.head(add == f, filter("a", ok))
-ok or obj?.head(add.obj, s)
-ok or obj?.head(all(div, add), max(s, ok))
-ok or obj?.head(arr).b
-ok or obj?.head(b)
-ok or obj?.head(f, a)
-ok or obj?.head(f, div)
-ok or obj?.head(fromJSON(b) endsWith b.a, none(map(b, b), s?.fn(arr, b)))
-ok or obj?.head(nil ? ok : f.a)
-ok or obj?.head(nil)
-ok or obj?.head(nil, ok, ok, a)
-ok or obj?.head(none(f.head(ok), f))
-ok or obj?.head(obj >= "c")
-ok or obj?.head(obj, f)
-ok or obj?.head(s)
-ok or obj?.head(s?.a)
-ok or obj?.obj
-ok or obj?.obj.b
-ok or obj?.obj?.b
-ok or obj[toJSON("b")]
 ok or ok
-ok or ok != false
-ok or ok == ok
-ok or ok ? 0 : a
-ok or ok ? false : a
-ok or ok ? obj : "b"
-ok or ok || !obj?.a
-ok or ok || nil != s
-ok or s != nil
-ok or s <= "b"
-ok or s == nil
-ok or s endsWith s
-ok or true ? 0 : true
-ok or true || ok
-ok || !ok
-ok || !true
-ok || "b" in obj
-ok || "c" != s
-ok || "c" > obj.obj
-ok || 0 in arr
-ok || 0.5 != 2
-ok || 0.5 <= f
-ok || 0.5 >= 0.5
-ok || 2 < f
-ok || 2 > f
-ok || a < f
-ok || a == 1
-ok || arr != arr
-ok || b != 2
-ok || b == a
-ok || b == f
-ok || b > 0
-ok || b > f
-ok || div == div
-ok || f == obj?.b
-ok || f > 0
-ok || f > b
-ok || f >= 0.5
-ok || f in obj.head(obj)
-ok || false ? obj : 0
-ok || false or obj.fn(div)
-ok || get(false ? b : 0.5, add.head(0.5, div))?.a
-ok || nil != b
-ok || nil == "b"
-ok || nil == f
-ok || nil == nil
-ok || nil == s
-ok || not obj?.head(b.head(div(ok)).a)
-ok || obj != obj
-ok || obj.a
-ok || obj.a startsWith toJSON(nil)
-ok || obj.a.b
-ok || obj.a?.a
-ok || obj.b
-ok || obj.b.b
-ok || obj.b.obj
-ok || obj.b?.b
-ok || obj.b?.obj
-ok || obj.fn(a.head(arr))
-ok || obj.fn(add(add.b, div?.a), s?.head(add.fn("b", b)), count(div, obj) % int(a, b, "c", false), obj)
-ok || obj.fn(add(f))
-ok || obj.fn(add, nil)?.head(arr contains a)
-ok || obj.fn(b)
-ok || obj.fn(div(obj), obj / obj, div(a, nil))
-ok || obj.fn(div).a
-ok || obj.fn(int(ok, nil, s, obj)[ok.a])
-ok || obj.fn(map("c", add), div(ok))
-ok || obj.fn(map(arr, div(f)))
-ok || obj.fn(nil, div)?.a
-ok || obj.fn(not 0 || nil - nil)
-ok || obj.fn(ok, obj)
-ok || obj.fn(ok.fn(nil))
-ok || obj.fn(s)
-ok || obj.fn(s[1], f < add)
-ok || obj.fn(true < arr matches div?.fn(a, s), div(add startsWith obj))
-ok || obj.fn(true <= a || f)
-ok || obj.head(0.5)
-ok || obj.head(2)
-ok || obj.head(a)
-ok || obj.head(add)
-ok || obj.head(arr)
-ok || obj.head(arr, filter(div(obj), -arr), fromBase64(1)?.obj, filter(f, 1) && b?.head(s, b))
-ok || obj.head(arr?.a?.obj)
-ok || obj.head(div.a)
-ok || obj.head(f, b)
-ok || obj.head(f, nil)?.obj.obj
-ok || obj.head(f.head(0 in arr, arr.head(s, s), div && a), s).b
-ok || obj.head(get(arr, false) && a ^ s)
-ok || obj.head(get(s?.b, f.a), s?.a ** ok)
-ok || obj.head(obj ? s : f, b * nil, one(false, nil))
-ok || obj.head(obj[add(b)], ok[add] in arr, arr)
-ok || obj.head(trim(false) matches filter(f, ok))
-ok || obj.obj
-ok || obj.obj.a
-ok || obj.obj?.a
-ok || obj.obj?.b
-ok || obj.obj?.fn(count(div(add || true, f, a?.fn(f, a, ok, nil)), add(a.b, add(nil))))
-ok || obj?.a
-ok || obj?.a?.b
-ok || obj?.a?.obj
-ok || obj?.b
-ok || obj?.b.b
-ok || obj?.b?.a
-ok || obj?.b?.head(f?.b ** arr.a)
-ok || obj?.b?.obj
-ok || obj?.fn("a", s)?.a
-ok || obj?.fn(-map(f, a), arr.fn(obj) == 0 .. arr)
-ok || obj?.fn(0, a)?.a
-ok || obj?.fn(0, nil, false)
-ok || obj?.fn(2, s)
-ok || obj?.fn(a)
-ok || obj?.fn(a.a)
-ok || obj?.fn(a.b, string(arr), ok).a
-ok || obj?.fn(a?.b >= hasSuffix(add))
-ok || obj?.fn(add("a"), arr matches nil, a?.obj)
-ok || obj?.fn(add(obj))
-ok || obj?.fn(add?.a)
-ok || obj?.fn(add[arr] in obj)
-ok || obj?.fn(any(a, arr), add(add, arr, f, 0.5, obj))
-ok || obj?.fn(arr)
-ok || obj?.fn(div >= true, a - arr, obj <= nil)
-ok || obj?.fn(div(0, arr, 0.5, b, div), ok ^ a)
-ok || obj?.fn(div, trimPrefix(add, arr, s, div))
-ok || obj?.fn(f?.a, b[0:false])
-ok || obj?.fn(f?.head(ok, div, add) < (arr or ok), div(0.5, s).b)
-ok || obj?.fn(get(f, ok) ^ div(2))
-ok || obj?.fn(get(get(ok, obj), div(b, 0.5, div)))
-ok || obj?.fn(hasPrefix(2), div.head(1))
-ok || obj?.fn(hasPrefix(b))
-ok || obj?.fn(map(none(add, 0), div))
-ok || obj?.fn(obj ** a, arr.fn("a", add, s)).head(ok)
-ok || obj?.fn(ok.fn(f, ok), get(nil, f))
-ok || obj?.fn(ok.head(arr), s)
-ok || obj?.fn(s[ok .. s])
-ok || obj?.head(-ok[ok], add(s < div))
-ok || obj?.head(0)?.a
-ok || obj?.head(0, "a", f, 0)
-ok || obj?.head(0.5, nil)
-ok || obj?.head(a in 2)
-ok || obj?.head(a)
-ok || obj?.head(add(b, add), div && nil)
-ok || obj?.head(add)
-ok || obj?.head(any(arr, true))
-ok || obj?.head(arr)
-ok || obj?.head(b)
-ok || obj?.head(b, ok, 2)
-ok || obj?.head(div || s)
-ok || obj?.head(div, div).a
-ok || obj?.head(f)
-ok || obj?.head(fromBase64(add(div)), b.b.obj)
-ok || obj?.head(ok && f)
-ok || obj?.head(ok)
-ok || obj?.head(ok, "c", 0, nil, s)
-ok || obj?.head(one(add, ok))
-ok || obj?.head(s)
-ok || obj?.head(s, f)
-ok || obj?.head(s.a)
-ok || obj?.head(true)
-ok || obj?.obj
-ok || obj?.obj.a
-ok || obj?.obj.b
-ok || obj?.obj.obj?.obj
-ok || obj?.obj?.b
-ok || obj[obj.b]
-ok || obj[s]?.b
+ok or ok || false
+ok or one(array, true)
+ok || "bar" not contains string(true)
+ok || 0.5 < i32
+ok || 0.5 <= 0.5
+ok || 0.5 == i64
+ok || 1 != 0.5
+ok || 1 != 1
+ok || 1 != nil
+ok || 1 < 0.5
+ok || 1 <= 1
+ok || add != score
+ok || all(array, ok)
+ok || div == nil
+ok || f32 <= 0.5
+ok || f32 <= 1
+ok || f32 > i64
+ok || f32 >= f64
+ok || false && ok
+ok || i != f64
+ok || i <= 0.5
+ok || i32 != 0.5
+ok || i32 < 0.5
+ok || i32 > 1
+ok || i64 > 0.5
 ok || ok
-ok || ok && true
-ok || ok == nil
-ok || ok ? false : arr
-ok || ok ? obj : s
-ok || ok or obj?.obj
-ok || s <= s
-ok || s >= s
-ok || s endsWith "b"
-ok || true ? f : ok
-ok || true or 1 != f
-ok || true or s matches s
-ok || true || obj?.c
-one(0 .. 2, ok)
-one(0 .. b, ok)
-one(2 .. 0, f > 0)
-one([add, false], ok)
-one(arr, !false)
-one(arr, !ok)
-one(arr, "b" contains "b")
-one(arr, "b" endsWith s)
-one(arr, "b" startsWith "c")
-one(arr, "c" contains "c")
-one(arr, # <= #)
-one(arr, 0 != 0.5)
-one(arr, 0 != nil)
-one(arr, 0 != obj?.obj)
-one(arr, 0 == 1)
-one(arr, 0 == nil)
-one(arr, 0 > b)
-one(arr, 0.5 <= b)
-one(arr, 0.5 == obj.obj)
-one(arr, 0.5 >= b)
-one(arr, 1 == 0)
-one(arr, a != 0.5)
-one(arr, a != a)
-one(arr, a < 0)
-one(arr, a <= b)
-one(arr, a == 0.5)
-one(arr, a == a)
-one(arr, a >= 0)
-one(arr, a >= a)
-one(arr, a >= b)
-one(arr, any(arr, ok))
-one(arr, arr != arr)
-one(arr, arr != nil)
-one(arr, arr == nil)
-one(arr, b != b)
-one(arr, b < #)
-one(arr, b < f)
-one(arr, b == f)
-one(arr, div != div)
-one(arr, div != nil)
-one(arr, div == div)
-one(arr, f != a)
-one(arr, f <= 0)
-one(arr, f <= a)
-one(arr, f == nil)
-one(arr, f >= 0)
-one(arr, false != obj.b)
-one(arr, false == obj.obj)
-one(arr, false) ? (true ? s : b) : 0 < 0
-one(arr, false) and ok
-one(arr, hasSuffix(s, "b"))
-one(arr, nil != 0)
-one(arr, nil != arr)
-one(arr, nil != f)
-one(arr, nil == add)
-one(arr, not ok)
-one(arr, obj.head(true, a))
-one(arr, ok != nil)
-one(arr, ok == ok)
-one(arr, ok)
-one(arr, ok) != obj.obj
-one(arr, ok) != ok
-one(arr, ok) && obj.obj
-one(arr, ok) && ok
-one(arr, ok) && ok ? a : div
-one(arr, ok) == obj.fn(0)
-one(arr, ok) and obj?.b
-one(arr, one(arr, ok))
-one(arr, s != "b")
-one(arr, s > s)
-one(arr, s endsWith s)
-one(arr, true && true)
-one(arr, true ? false : add)
-one(arr, true and true)
-one(arr, true) or obj?.head(0.5)
-one(b .. 0, obj.b)
-one(b .. 1, ok)
-one(b .. 2, any(arr, true))
-one(b .. a, ok)
-one(b .. b, "a" == nil)
-one(b .. b, f != nil)
-one(false ? 0 : arr, "a" < s)
-one(filter(arr, false), obj?.a)
-one(filter(arr, ok), nil == div)
-one(map(arr, "b"), div != add)
-one(map(arr, 0), f != f)
-one(map(arr, 0), ok == false)
-one(map(arr, 0), ok)
-one(map(arr, 0.5), ok)
-one(map(arr, 2), b <= 0.5)
-one(map(arr, a), ok)
-one(map(arr, add), ok)
-one(map(arr, arr), ok)
-one(map(arr, b), ok)
-one(map(arr, div), div != add)
-one(map(arr, div), ok)
-one(map(arr, f), s contains "b")
-one(map(arr, false), #)
-one(map(arr, ok), #)
-one(map(arr, ok), 0.5 < 0.5)
-one(map(arr, ok), ok)
-one(map(arr, true), #)
-one(obj.head("c"), obj == obj)
-one(obj.head("c", add), b == f)
-one(obj.head(arr), ok)
-one(obj.head(obj), ok)
-one(obj.head(s, obj), ok)
-one(obj.obj, b <= a)
-one(obj.obj, b > 1)
-one(obj.obj, f < 0.5)
-one(obj.obj, ok)
-one(obj?.head("c"), ok)
-one(obj?.head(arr), "a" matches "b")
-one(obj?.head(arr), "c" < s)
-one(obj?.head(s), b == nil)
-one(obj?.head(s), ok)
-one(obj?.head(s), s > s)
-one(obj?.obj, "b" != nil)
-one(obj?.obj, a == b)
-one(obj?.obj, b != 0)
-one(obj?.obj, false == true)
-one(obj?.obj, nil in obj)
-one(obj?.obj, obj.head(ok, 0, "b", 1, div))
-one(obj?.obj, ok)
-one(ok ? arr : f, ok)
-one(ok ? s : ok, ok)
-one(values(obj), nil == ok)
-repeat(s, a)
-repeat(s, b)
-repeat(toJSON(arr), obj?.a)
-s
-s != "b" ? add : add
-s != "b" ? obj : f
-s != "c" && nil != b
-s != nil != obj.a
-s != nil == ok
-s != nil ? arr : ok
-s != nil ? b : false
-s != nil and "b" < "c"
-s != nil || obj.b
-s != obj.a
-s != obj.b
-s != obj.head(0)
-s != obj.head(a)
-s != obj.head(arr)
-s != obj.head(div, arr)
-s != obj.head(f)
-s != obj.head(nil, add, f, s)
-s != obj.head(ok, "b", add)
-s != obj.head(s)
-s != obj.obj
-s != obj.obj.obj
-s != obj.obj?.a
-s != obj.obj?.b
-s != obj.obj?.obj
-s != obj?.a
-s != obj?.b
-s != obj?.b or add != obj.a
-s != obj?.fn(1)
-s != obj?.fn(int(b))
-s != obj?.head(add)
-s != obj?.head(add, 0.5, arr, add)
-s != obj?.obj
-s != obj?.obj.a
-s != obj?.obj?.obj
-s != s
-s != s != obj.head(obj)
-s != s != true
-s != s == ok
-s != s ? 1 : ok
-s != s ? b : s
-s != s || ok
-s != string(0.5)
-s != string(b)
-s != toJSON(1)
-s != toJSON(b)
-s != toJSON(true)
-s != trim("c")
-s + lower("a")
-s + repeat(s, 0)
-s + s
-s + s != s
-s + s + trimPrefix("a")
-s + s == obj?.obj
-s + s >= s
-s + s matches lower(s)
-s + string("c")
-s + string(f)
-s + toJSON("b")
-s + toJSON(ok)
-s + trim(s)
-s < "a" + s
-s < "a" ? 2 : ok
-s < "a" and obj?.obj
-s < "c" && s <= "b"
-s < "c" ? b : arr
-s < "c" and a > f
-s < "c" or obj.a
-s < "c" or obj?.head(s, obj)
-s < lower(s)
-s < obj.head(s)
-s < obj?.head("b", 0.5)
-s < s
-s < s != nil
-s < s || a == 1
-s < s || ok
-s < s[a:0]
-s < string(s)
-s < toJSON(0)
-s < trimPrefix("b")
-s <= "a" != nil
-s <= "a" ? nil : f
-s <= "b" ? "c" : nil
-s <= "c" ? "b" : a
-s <= "c" ? 1 : 2
-s <= "c" ? obj : add
-s <= "c" || obj.fn(b, b)
-s <= obj.head(s, b, "a", add)
-s <= s
-s <= s != ok
-s <= s == obj.b
-s <= s == ok
-s <= s ? 2 : 0.5
-s <= s ? b : ok
-s <= s || !ok
-s <= string(obj)
-s == "a" + "b"
-s == "b" ? obj : s
-s == -obj?.b
-s == f + obj.b
-s == get(obj, s)
-s == nil != nil
-s == nil != obj?.a
-s == nil == obj.obj
-s == nil ? obj : f
-s == nil ? obj : s
-s == nil or ok
-s == nil || obj?.b
-s == nil || true ? 2 : s
-s == obj.a
-s == obj.b
-s == obj.head(0.5)
-s == obj.head(0.5, b, true)
-s == obj.head(arr)
-s == obj.head(b)
-s == obj.head(nil, arr)?.fn(arr)?.obj
-s == obj.head(true or f)
-s == obj.obj
-s == obj.obj.b
-s == obj.obj?.b
-s == obj.obj?.obj?.b
-s == obj?.a
-s == obj?.b
-s == obj?.fn(a)
-s == obj?.head(arr)
-s == obj?.head(f, div)
-s == obj?.head(obj)
-s == obj?.head(obj).b
-s == obj?.head(obj, ok)
-s == obj?.head(ok)
-s == obj?.obj
-s == obj?.obj.obj
-s == obj?.obj?.a
-s == s
-s == s != ok
-s == s ? arr : "c"
-s == s || obj.b
-s == s[1:a]
-s == string("c")
-s == string(0)
-s == string(1)
-s == string(arr)
-s == string(div)
-s == toJSON(a)
-s == trimPrefix("b")
-s > "b" ? "c" : obj
-s > "b" ? b : 0.5
-s > "b" ? div : "b"
-s > "c" && obj.head(s, obj)
-s > obj.head(s)
-s > obj?.head(s)
-s > s
-s > s != true
-s > s && ok
-s > s + "c"
-s > s == obj?.a
-s > s ? add : ok
-s > s ? div : obj?.fn(2)
-s > s ? div : true
-s > s ? ok : obj.a
-s > s ? s : add
-s > s and b == 0
-s > s || obj.a
-s > string(2)
-s > string(arr)
-s > string(s)
-s > toBase64("c")
-s > toJSON(false)
-s > trimPrefix(s)
-s >= "a" + s
-s >= "a" == obj.a
-s >= "a" ? arr : b
-s >= "c" ? b : ok
-s >= "c" ? f : obj
-s >= "c" and obj.obj
-s >= "c" or obj?.head(add, 0, 2, add)
-s >= obj.head("c", s)
-s >= s
-s >= s != obj?.fn(b)
-s >= s && obj.b
-s >= s && obj?.a
-s >= s and obj?.a
-s >= s or obj.head(a)
-s >= string(0)
-s >= string(a)
-s >= string(nil)
-s >= string(s)
-s >= toJSON(arr)
-s >= toJSON(b)
-s >= trim(s)
-s contains "a" && a < f
-s contains "a" ? arr : true
-s contains "b" == ok
-s contains "b" ? a : f
-s contains "b" ? s : a
-s contains "c" ? "c" : b
-s contains "c" ? a : obj?.a
-s contains "c" ? b : obj.fn(obj)
-s contains "c" || obj?.obj
-s contains obj.head(s)
-s contains obj.head(s, div, add)
-s contains obj?.head("c")
-s contains obj?.head(s)
-s contains s
-s contains s == ok
-s contains s ? f : obj
-s contains s and !ok
-s contains s or obj?.head(b, b, obj)?.a in obj
-s contains s or ok
-s contains string(ok)
-s contains toBase64(s)
-s contains toJSON(nil)
-s contains toJSON(ok)
-s contains toJSON(s)
-s endsWith "a" && obj.head(0)
-s endsWith "a" == nil
-s endsWith "a" ? obj : 0
-s endsWith "b" and (ok || true)
-s endsWith "c" != ok ? arr : obj
-s endsWith "c" == ok
-s endsWith "c" ? b : arr
-s endsWith lower("c")
-s endsWith lower(s)
-s endsWith s
-s endsWith s != nil
-s endsWith s && ok
-s endsWith s + s
-s endsWith s == nil
-s endsWith s ? 0 : 0
-s endsWith s ? div : f
-s endsWith s ? div : obj?.b
-s endsWith s ? obj : arr
-s endsWith s ? ok : add
-s endsWith s and obj.head(arr, s)
-s endsWith s and ok
-s endsWith s or a < b
-s endsWith s || obj.fn(nil)
-s endsWith s || ok
-s endsWith string(add)
-s endsWith string(arr)
-s endsWith string(s)
-s endsWith toJSON(2)
-s in [0.5]
-s in map(arr, s)
-s in obj
-s in obj && s matches s
-s in obj == ok
-s in obj ? div : arr
-s in obj ? div : div
-s in obj or obj?.a
-s in obj.head(arr, div)
-s in obj.head(nil)
-s in obj.obj
-s in obj.obj.obj
-s in obj?.head(last(b))
-s in obj?.obj
-s in obj?.obj?.obj
-s matches "a" ? false : true
-s matches "b" != obj.b
-s matches "b" == ok
-s matches "b" ? arr : ok
-s matches "b" ? b : b < b
-s matches "b" ? nil : obj
-s matches "b" or "c" contains "b"
-s matches "b" or obj.head(add)?.obj
-s matches "c" && obj?.obj
-s matches "c" ? add : 1
-s matches "c" ? ok : nil
-s matches "c" ? s : add
-s matches obj?.head("a")
-s matches obj?.head(lower(s, s))
-s matches s
-s matches s == obj.b
-s matches s == obj?.head(a)
-s matches s == ok
-s matches s ? a : 2
-s matches s ? add : a
-s matches s ? nil : a >= a
-s matches s ? obj : arr
-s matches s and ok
-s matches toJSON(f)
-s matches toJSON(s)
-s matches trimSuffix(s, s)
-s startsWith "a" ? s : false
-s startsWith "c" || obj.b
-s startsWith s
-s startsWith s == false
-s startsWith s ? "a" : b
-s startsWith s ? arr : f
-s startsWith s ? obj : arr
-s startsWith s ? s : "a"
-s startsWith s || add == add
-s startsWith s || ok
-s startsWith string(arr)
-s startsWith toJSON(arr)
-s startsWith trimSuffix("b")
-s[0 + 2:min(0)]
-s[2:b] >= s
-s[a:a]
-s[a:a] == obj?.head(ok)
-s[a:b]
-s[a:obj?.a]
-s[add(a, a):obj.b]
-s[b:a]
-split(s, s)
-splitAfter(s, s)
-splitAfter(s[b:b], s)
+ok || score != score
+ok || toJSON(f64) > trimSuffix("bar")
+one([1], ok)
+one([i32], i32 >= #)
+one([score, greet], # == #)
+one([score], ok)
+one(array, "bar" matches "foo")
+one(array, "bar" not in foo)
+one(array, "foo" != "foo")
+one(array, "foo" > "foo")
+one(array, # != #)
+one(array, # != 0.5)
+one(array, # != f64)
+one(array, # != i32)
+one(array, # != nil)
+one(array, # % # <= #)
+one(array, # < #)
+one(array, # < 0.5)
+one(array, # < 1)
+one(array, # < f32)
+one(array, # < f64)
+one(array, # < i)
+one(array, # < i32)
+one(array, # <= #)
+one(array, # <= f32)
+one(array, # <= f64)
+one(array, # <= i)
+one(array, # <= i32)
+one(array, # == #)
+one(array, # == 0.5)
+one(array, # == 1)
+one(array, # == f64)
+one(array, # == i)
+one(array, # == i32)
+one(array, # == i64)
+one(array, # > #)
+one(array, # > f64)
+one(array, # > i32)
+one(array, # > i64)
+one(array, # >= #)
+one(array, # >= 0.5)
+one(array, # >= 1)
+one(array, # >= f32)
+one(array, # >= i)
+one(array, # >= i32)
+one(array, # in array)
+one(array, 0.5 != #)
+one(array, 0.5 < #)
+one(array, 0.5 <= #)
+one(array, 0.5 == #)
+one(array, 0.5 > #)
+one(array, 0.5 > f32)
+one(array, 0.5 >= #)
+one(array, 1 != #)
+one(array, 1 < 0.5)
+one(array, 1 < i)
+one(array, 1 <= #)
+one(array, 1 <= 0.5)
+one(array, 1 == #)
+one(array, 1 == i32)
+one(array, 1 > #)
+one(array, 1 >= #)
+one(array, 1 >= f32)
+one(array, f32 < 1)
+one(array, f32 <= #)
+one(array, f32 <= i64)
+one(array, f32 == #)
+one(array, f32 == 0.5)
+one(array, f32 == 1)
+one(array, f32 >= #)
+one(array, f64 != #)
+one(array, f64 != 1)
+one(array, f64 != i)
+one(array, f64 != nil)
+one(array, f64 == #)
+one(array, f64 > #)
+one(array, false == nil)
+one(array, greet == score)
+one(array, i != 0.5)
+one(array, i < i32)
+one(array, i <= #)
+one(array, i == #)
+one(array, i > f64)
+one(array, i >= #)
+one(array, i >= f32)
+one(array, i32 != #)
+one(array, i32 <= #)
+one(array, i32 == #)
+one(array, i32 == i)
+one(array, i32 > #)
+one(array, i64 <= #)
+one(array, i64 == #)
+one(array, i64 > #)
+one(array, i64 > 1)
+one(array, nil != #)
+one(array, nil != foo)
+one(array, nil == i64)
+one(array, not ok)
+one(array, not true)
+one(array, ok && true)
+one(array, ok)
+one(array, one(array, false))
+one(array, score != greet)
+one(array, score == div)
+one(array, true || ok)
+one(array, true || true)
+one(filter(list, true), ok)
+one(i32 .. i32, ok)
+one(i32 .. i64, # >= #)
+one(list, !ok)
+one(list, !true)
+one(list, "bar" not in #)
+one(list, "foo" != "bar")
+one(list, "foo" < "foo")
+one(list, "foo" not in #)
+one(list, # != #)
+one(list, # != nil)
+one(list, # == #)
+one(list, # == foo)
+one(list, # == nil)
+one(list, # in list)
+one(list, 0.5 != f32)
+one(list, 0.5 > 0.5)
+one(list, 1 < 1)
+one(list, any(array, true))
+one(list, any(list, ok))
+one(list, any(list, true))
+one(list, f32 == 0.5)
+one(list, f32 == f64)
+one(list, f32 > f32)
+one(list, f64 != nil)
+one(list, f64 == f32)
+one(list, f64 >= 0.5)
+one(list, f64 >= 1)
+one(list, foo == #)
+one(list, greet != nil)
+one(list, greet == score)
+one(list, half != add)
+one(list, i != nil)
+one(list, i == i64)
+one(list, i64 != f32)
+one(list, i64 < 1)
+one(list, i64 <= 0.5)
+one(list, i64 > 0.5)
+one(list, i64 > 1)
+one(list, list != nil)
+one(list, nil != nil)
+one(list, nil != score)
+one(list, nil == #)
+one(list, none(array, ok))
+one(list, none(list, ok))
+one(list, not false)
+one(list, not ok)
+one(list, not true)
+one(list, ok)
+one(list, ok) and ok
+one(list, one(list, ok))
+one(list, score == half)
+one(list, true) && ok ? i : i64
+one(map(array, "foo"), # matches #)
+one(map(array, #), # != #)
+one(map(array, #), # < #)
+one(map(array, #), # <= #)
+one(map(array, #), # > #)
+one(map(array, #), # > 1)
+one(map(array, #), f64 <= 0.5)
+one(map(array, #), ok)
+one(map(array, div), # == nil)
+one(map(array, i64), ok)
+one(map(array, true), #)
+one(map(list, "bar"), ok)
+one(map(list, #), nil != #)
+one(map(list, 1), # < 0.5)
+one(map(list, f64), # <= #)
+one(map(list, false), #)
+one(map(list, i), ok)
+one(map(list, list), ok)
+one(map(list, ok), #)
+repeat(toJSON(nil), i)
+score
+score != add
+score != add != true
+score != add ? i64 : "foo"
+score != div
+score != div ? i : f32
+score != div and ok
+score != foo.Qux
+score != foo.String
+score != foo?.Qux
+score != foo?.String
+score != greet
+score != greet ? score : array
+score != half
+score != score
+score != score ? 1 : i
+score == add
+score == add == false
+score == add ? f64 : not false
+score == div
+score == div || foo == foo
+score == foo.Qux
+score == foo.String
+score == foo?.Qux
+score == foo?.String
+score == greet
+score == greet ? half : f64
+score == greet and ok
+score == half
+score == score
+score == score ? 0.5 : foo
+score == score ? nil : i32
+score == score or ok
+score == {"bar": 0.5}.f32
+score(-1)
+score(-i)
+score(-i, i)
+score(1 % 1)
+score(1 % i)
+score(1 % i32)
+score(1 % i64)
+score(1 * 1)
+score(1 * 1, i)
+score(1 * i)
+score(1 * i32)
+score(1 * i64)
+score(1 + 1)
+score(1 + i)
+score(1 + i32)
+score(1 + i64)
+score(1 - 1)
+score(1 - i)
+score(1 - i32)
+score(1 - i64)
+score(1) != -0.5
+score(1) != f32
+score(1) != float(f64)
+score(1) != i
+score(1) % i32
+score(1) * f32
+score(1) * f64
+score(1) * i64
+score(1) ** -1
+score(1) ** f32
+score(1) ** i64
+score(1) + f32
+score(1) + f64
+score(1) - f32
+score(1) - i
+score(1) .. i64
+score(1) / f64
+score(1) / i
+score(1) / i32
+score(1) / i64
+score(1) < i32
+score(1) < i64
+score(1) <= i32
+score(1) <= i64
+score(1) == 1 ^ 1
+score(1) == f64
+score(1) == i ** f64
+score(1) == i32
+score(1) == i64
+score(1) > i64
+score(1) >= f32
+score(1) >= f64
+score(1) >= i
+score(1) >= i32
+score(1) >= i64
+score(1) ^ f32
+score(1) ^ f64
+score(1) ^ i
+score(1) in array
+score(1, i) > f32
+score(abs(1))
+score(abs(i))
+score(add(1, 1))
+score(add(1, i))
+score(array[1])
+score(array[i32])
+score(array[i64])
+score(array[i])
+score(count(array, f64 < 1))
+score(count(array, false))
+score(count(array, ok))
+score(count(array, true))
+score(count(list, false))
+score(count(list, ok))
+score(count(list, true))
+score(div(1, 1))
+score(div(i, 1))
+score(false ? true : i)
+score(find(array, ok))
+score(findIndex(array, ok))
+score(findIndex(array, true))
+score(findIndex(list, ok))
+score(findIndex(list, true))
+score(findLast(array, 0.5 != #))
+score(findLast(array, ok))
+score(findLastIndex(array, ok))
+score(findLastIndex(array, true))
+score(findLastIndex(list, ok))
+score(findLastIndex(list, true))
+score(first(array))
+score(get(array, 1))
+score(get(array, i))
+score(get(array, i32))
+score(get(array, i64))
+score(i % i)
+score(i % i32)
+score(i * 1)
+score(i * i32)
+score(i * i64)
+score(i + 1)
+score(i + i)
+score(i + i32)
+score(i + i64)
+score(i - 1)
+score(i - i)
+score(i - i32)
+score(i - i64)
+score(i)
+score(i) != 1 == true
+score(i) != float(i32)
+score(i) != i
+score(i) != i32
+score(i) % i32 % i64
+score(i) % i64
+score(i) * f64
+score(i) * i32
+score(i) * i64
+score(i) ** f64
+score(i) ** i32
+score(i) + f32
+score(i) + i
+score(i) + i32
+score(i) + i64
+score(i) - f32
+score(i) - i
+score(i) - i32
+score(i) / f32
+score(i) / i
+score(i) < f32
+score(i) < i32
+score(i) <= f32 - f32
+score(i) == f32
+score(i) == i32
+score(i) == i64
+score(i) >= f32
+score(i) ^ f64
+score(i) ^ i
+score(i, i + i)
+score(i, i)
+score(i, i) >= i
+score(i, int(i64))
+score(i, score(i)) - i32
+score(i32 % i)
+score(i32 % i64)
+score(i32 * 1)
+score(i32 * i)
+score(i32 + i)
+score(i32 + i64)
+score(i32 - 1)
+score(i32 - i)
+score(i64 % 1)
+score(i64 % i)
+score(i64 * 1)
+score(i64 * i)
+score(i64 * i32)
+score(i64 + 1)
+score(i64 - 1)
+score(i64 - i)
+score(i64 - i32)
+score(int(0.5))
+score(int(1))
+score(int(f32 * i))
+score(int(f32))
+score(int(f64))
+score(int(i))
+score(int(i32))
+score(int(i64))
+score(last(array))
+score(len("bar"))
+score(len("foo"))
+score(len(array))
+score(len(i32 .. i64))
+score(len(list))
+score(max(1))
+score(max(1, 1))
+score(max(i))
+score(max(i, 1))
+score(min(1))
+score(min(1, i64))
+score(min(i))
+score(score(1))
+score(score(1, 1))
+score(score(i))
+score(score(i32 % 1))
+score(true ? 1 : true)
+score(true ? i : i64)
+sort(1 .. 1)
+sort(1 .. i64)
+sort([0.5])
+sort([1])
+sort([i32])
+sort([i64])
+sort([nil])
+sort(array)
+sort(array) != list
+sort(false ? i64 : array)
+sort(filter(array, false))
+sort(filter(array, true))
+sort(filter(list, false))
+sort(i .. 1)
+sort(i .. i64)
+sort(i32 .. 1)
+sort(i32 .. i32)
+sort(map(array, "bar"))
+sort(map(array, "foo"))
+sort(map(array, #))
+sort(map(array, 1))
+sort(map(array, i32))
+sort(map(list, "foo")) != list
+sort(map(list, i))
+sort(sort(array))
+string(!(i <= f32))
 string(!false)
 string(!ok)
 string(!true)
-string("a" < s)
-string("a" == nil)
-string("a" == s)
-string("a" >= s)
-string("b" + "a")
-string("b" + s)
-string("b" <= "c")
-string("b" contains "c")
-string("b" matches "a")
-string("b" matches s)
-string("b") matches s
-string("c" != "b")
-string("c" != nil)
-string("c" <= "c")
-string("c" == "a")
-string("c" matches s)
-string("c") != string(s)
-string("c") <= string(s)
-string("c") in obj
-string(-(f >= 0 ? f : add))
-string(-0)
+string("bar" != "bar")
+string("bar" < "bar")
+string("bar" == "bar")
+string("bar" > "bar")
+string("bar" contains "foo")
+string("bar" endsWith "bar")
+string("bar" not endsWith "bar")
+string("bar" not matches "foo")
+string("bar" not startsWith "foo")
+string("bar" startsWith "bar")
+string("bar") >= type(score)
+string("bar") endsWith "foo" + "foo"
+string("bar") in foo
+string("foo" != nil)
+string("foo" <= "foo")
+string("foo" >= "bar")
+string("foo" matches "foo")
+string("foo" not endsWith "foo")
+string("foo" not in foo)
+string("foo" not matches "foo")
+string("foo" startsWith "bar")
+string(-(0.5 + f64))
 string(-0.5)
-string(-2)
-string(-a)
-string(-b)
-string(-f)
-string(-obj.obj?.b)
-string(-obj?.b)
-string(0 != 0)
-string(0 != 1)
-string(0 != a)
-string(0 != nil)
-string(0 % 1)
-string(0 % 2)
-string(0 % a)
-string(0 % b)
-string(0 * 0)
-string(0 * a)
-string(0 * f)
-string(0 ** 1)
-string(0 ** 2)
-string(0 ** a)
-string(0 ** f)
-string(0 + 0)
-string(0 + 2)
-string(0 + b)
-string(0 - 1)
-string(0 - 2)
-string(0 - a)
-string(0 - b)
-string(0 / 2)
-string(0 / f)
-string(0 < a)
-string(0 < f)
-string(0 < obj.b)
-string(0 <= 0)
-string(0 <= 0.5)
-string(0 <= a)
-string(0 <= b)
-string(0 <= f)
-string(0 == a)
-string(0 == b)
-string(0 == f)
-string(0 > 2)
-string(0 > b)
-string(0 >= b)
-string(0 ^ 0)
-string(0 ^ 2)
-string(0) < s
-string(0) > s
-string(0) startsWith string(a)
-string(0.5 != a)
-string(0.5 != b)
+string(-1)
+string(-f32)
+string(-f64)
+string(-i)
+string(-i32)
+string(-i64)
+string(0.5 != 0.5)
+string(0.5 != 1)
+string(0.5 != f32)
+string(0.5 != f64)
+string(0.5 != i)
+string(0.5 != nil)
+string(0.5 * 0.5)
+string(0.5 * f32)
+string(0.5 * i)
+string(0.5 * i32)
+string(0.5 ** 0.5)
 string(0.5 ** 1)
-string(0.5 ** b)
-string(0.5 ** f)
+string(0.5 ** i32)
+string(0.5 ** i64)
+string(0.5 + 0.5)
 string(0.5 + 1)
-string(0.5 + a)
-string(0.5 - b)
+string(0.5 + f32)
+string(0.5 + f64)
+string(0.5 + i64)
+string(0.5 - 0.5)
+string(0.5 - 1)
 string(0.5 / 0.5)
-string(0.5 / a)
-string(0.5 / f)
-string(0.5 < 2)
-string(0.5 < arr[-1])
-string(0.5 < b)
-string(0.5 < f)
-string(0.5 == 0)
-string(0.5 == b)
-string(0.5 == f)
+string(0.5 / f64)
+string(0.5 / i)
+string(0.5 < 1)
+string(0.5 < f32)
+string(0.5 < i)
+string(0.5 < i32)
+string(0.5 <= f64)
+string(0.5 <= i)
+string(0.5 <= i64)
+string(0.5 == 0.5)
+string(0.5 == 1)
+string(0.5 == f32)
+string(0.5 == f64)
+string(0.5 == i)
+string(0.5 == i32)
+string(0.5 == i64)
 string(0.5 == nil)
-string(0.5 > a)
-string(0.5 > b)
-string(0.5 > f)
-string(0.5 ^ 0)
+string(0.5 > 0.5)
+string(0.5 > 1)
+string(0.5 > i64)
+string(0.5 >= 0.5)
+string(0.5 >= 1)
+string(0.5 >= f32)
+string(0.5 >= f64)
+string(0.5 >= i)
+string(0.5 >= i32)
 string(0.5 ^ 0.5)
+string(0.5 ^ 1)
+string(0.5 ^ f32)
+string(0.5 ^ i)
+string(0.5 ^ i32)
+string(0.5) not endsWith type(1)
+string(1 != 1)
+string(1 != f32)
+string(1 != f64)
+string(1 != i)
+string(1 != i32)
 string(1 != nil)
-string(1 % a)
-string(1 ** a)
-string(1 + b)
-string(1 + f)
-string(1 - 0)
-string(1 .. a)
+string(1 % 1)
+string(1 % i)
+string(1 % i32)
+string(1 % i64)
+string(1 * 1)
+string(1 * i)
+string(1 * i64)
+string(1 ** 0.5)
+string(1 ** 1)
+string(1 ** f64)
+string(1 ** i)
+string(1 ** i32)
+string(1 + 0.5)
+string(1 + f32)
+string(1 + f64)
+string(1 + i64)
+string(1 - f32)
+string(1 - i)
+string(1 - i64)
+string(1 .. 1)
+string(1 .. i)
+string(1 .. i32)
 string(1 / 0.5)
-string(1 < 0)
-string(1 < b)
-string(1 <= 0)
-string(1 <= f)
-string(1 == 2)
-string(1 == b)
+string(1 / 1)
+string(1 / f32)
+string(1 / i)
+string(1 < i)
+string(1 < i32)
+string(1 < i64)
+string(1 <= 0.5)
+string(1 <= 1)
+string(1 <= f32)
+string(1 <= f64)
+string(1 <= i32)
+string(1 == 0.5)
+string(1 == 1)
+string(1 == f64)
+string(1 == i)
+string(1 == i64)
 string(1 == nil)
 string(1 > 1)
-string(1 > f)
-string(1 ^ 0)
-string(1 ^ f)
-string(1) != s
-string(1) == obj.b
-string(2 != 0)
-string(2 != nil)
-string(2 != obj.b)
-string(2 * f)
-string(2 + 0)
-string(2 + a)
-string(2 - a)
-string(2 .. a)
-string(2 / 0.5)
-string(2 < 0)
-string(2 <= 0)
-string(2 <= a)
-string(2 == f)
-string(2 > b)
-string(2 >= 0)
-string(2 >= a)
-string(2 ^ 0)
-string(2 in arr)
-string([arr])
-string([div, a])
-string(a != 0.5)
-string(a != a)
-string(a != b)
-string(a % b)
-string(a * 0.5)
-string(a * 2)
-string(a * b)
-string(a ** f)
-string(a + a)
-string(a + f)
-string(a - 0)
-string(a - a)
-string(a - f)
-string(a .. a)
-string(a .. b)
-string(a / 0)
-string(a / f)
-string(a < 0)
-string(a < a)
-string(a < f)
-string(a <= 0.5)
-string(a <= a)
-string(a <= f)
-string(a == b)
-string(a == nil)
-string(a > b)
-string(a > f)
-string(a >= 0)
-string(a >= 1)
-string(a >= a)
-string(a in arr)
-string(a)
-string(a) == s
-string(a) > lower("c")
-string(a) endsWith s
-string(a) in obj
-string(a)[b:b]
+string(1 > f32)
+string(1 >= 0.5)
+string(1 >= 1)
+string(1 >= f32)
+string(1 >= f64)
+string(1 >= i)
+string(1 >= i32)
+string(1 >= i64)
+string(1 ^ 1)
+string(1 ^ f32)
+string(1 ^ f64)
+string(1 ^ i)
+string(1 ^ i32)
+string(1 ^ i64)
+string(1 in array)
+string(1 not in array)
+string(1)[i64:i64]
+string([0.5, f32])
+string([add])
+string([f32])
+string([greet])
+string([i32, half])
+string([i32])
+string([i])
+string([ok])
+string([score])
 string(abs(0.5))
-string(abs(a))
+string(abs(1))
+string(abs(f32))
+string(abs(f64))
+string(abs(half(0.5)))
+string(abs(i))
+string(abs(i64))
 string(add != add)
-string(add != div)
-string(add == nil)
-string(add(0, 1))
-string(add(0, b))
-string(add(1, 2))
-string(add(2, a))
-string(add(b, 0))
-string(add(b, 1))
-string(add(b, a))
-string(add(b, b))
+string(add != half)
+string(add != nil)
+string(add != score)
+string(add == greet)
 string(add)
-string(add) + s
-string(add) < s
-string(add) <= s
-string(add) > s
-string(add) >= s
-string(add) startsWith "b" ? div : f
-string(any(arr, true))
-string(arr != nil)
-string(arr == obj.obj)
-string(arr)
-string(arr) <= s
-string(arr) == lower(s)
-string(arr) contains s
-string(arr) in obj
-string(arr) matches s == nil
-string(arr) matches trim("b", s)
-string(arr) startsWith lower(s)
-string(arr[0])
-string(arr[1])
-string(arr[2:0])
-string(arr[a])
-string(arr[b:a])
-string(b != 0)
-string(b != a)
-string(b != b)
-string(b != f)
-string(b % 1)
-string(b % b)
-string(b * 0)
-string(b ** 0.5)
-string(b ** 1)
-string(b ** 2)
-string(b ** a)
-string(b ** b)
-string(b + 1)
-string(b + 2)
-string(b + b)
-string(b - a)
-string(b - f)
-string(b .. 0)
-string(b .. b)
-string(b / 0.5)
-string(b / 1)
-string(b / a)
-string(b < 0)
-string(b < 1)
-string(b < a)
-string(b < b)
-string(b < f == nil)
-string(b <= a)
-string(b <= b)
-string(b <= f)
-string(b == 0)
-string(b == 0.5)
-string(b == 1)
-string(b == a)
-string(b == f)
-string(b == nil)
-string(b > 0.5)
-string(b > 1)
-string(b > b)
-string(b ^ 0.5)
-string(b ^ 2)
-string(b ^ b)
-string(b ^ f)
-string(b)
-string(b) < s
-string(b) <= s
-string(b) >= s
-string(b) matches s
-string(count(arr, false))
-string(count(arr, ok))
+string(add) contains type(list)
+string(add) not in foo
+string(all(array, false))
+string(all(array, true))
+string(any(array, false))
+string(any(list, true))
+string(array != array)
+string(array == nil)
+string(array)
+string(array) not in foo
+string(array[1:i])
+string(array[1])
+string(array[i64])
+string(count(array, # <= #))
+string(count(array, ok))
+string(div != greet)
 string(div != nil)
-string(div == div)
 string(div == nil)
-string(div(0, 2))
-string(div(0, a))
-string(div(0, b))
-string(div(2, a))
-string(div(a, 1))
-string(div(a, a))
-string(div(a, b))
-string(div(b, 1))
-string(div(b, 2))
-string(div(b, a))
-string(div(b, b))
+string(div == score)
 string(div)
-string(div) != string(b)
-string(div) >= s
-string(div) endsWith s
-string(div)[a:count(arr, true)]
-string(f != 0.5)
-string(f != f)
-string(f != nil)
-string(f * 0)
-string(f * a)
-string(f * f)
-string(f ** b)
-string(f ** f)
-string(f + b)
-string(f - 2)
-string(f - a)
-string(f - b)
-string(f / 0)
-string(f / 0.5)
-string(f / a)
-string(f / f)
-string(f / obj.a)
-string(f < 0.5)
-string(f < a)
-string(f < b)
-string(f < f)
-string(f <= a)
-string(f <= b)
-string(f <= f)
-string(f == 0)
-string(f == 0.5)
-string(f == b)
-string(f == nil)
-string(f > a)
-string(f > b)
-string(f > f)
-string(f >= 0)
-string(f >= 1)
-string(f ^ a)
-string(f ^ b)
-string(f ^ f)
-string(f)
-string(f) + s
-string(f) < s
-string(f) > s
-string(f) >= s
-string(f) endsWith s
-string(false != nil)
-string(false != ok)
-string(false && ok)
-string(false && true)
-string(false == nil)
-string(false ? arr : f)
-string(false ? div : div)
-string(false ? f : a)
-string(false || true)
-string(filter(arr, ok))
-string(float(0))
+string(f32 != 0.5)
+string(f32 != 1)
+string(f32 != f32)
+string(f32 != f64)
+string(f32 != nil)
+string(f32 * 0.5)
+string(f32 * f64)
+string(f32 * i)
+string(f32 * i32)
+string(f32 ** 1)
+string(f32 ** i64)
+string(f32 + 1)
+string(f32 + f32)
+string(f32 - i)
+string(f32 / 1)
+string(f32 / i)
+string(f32 / i64)
+string(f32 < 0.5)
+string(f32 < f64)
+string(f32 < i32)
+string(f32 <= 0.5)
+string(f32 <= 1)
+string(f32 <= f32)
+string(f32 <= i)
+string(f32 <= i32)
+string(f32 == 0.5)
+string(f32 == 1)
+string(f32 == i64)
+string(f32 == nil)
+string(f32 > 1)
+string(f32 > f32)
+string(f32 > f64)
+string(f32 > i)
+string(f32 > i32)
+string(f32 >= 0.5)
+string(f32 >= f32)
+string(f32 >= f64)
+string(f32 >= i32)
+string(f32 ^ 1)
+string(f32 ^ f32)
+string(f32 ^ f64)
+string(f32 ^ i)
+string(f32 ^ i64)
+string(f32)
+string(f32) matches trim("bar")
+string(f64 != 1)
+string(f64 != f32)
+string(f64 * 0.5)
+string(f64 * 1)
+string(f64 * f32)
+string(f64 * f64)
+string(f64 * i)
+string(f64 ** 0.5)
+string(f64 ** 1)
+string(f64 ** f64)
+string(f64 ** i32)
+string(f64 + 0.5)
+string(f64 + 1)
+string(f64 + f32)
+string(f64 + i)
+string(f64 + i32)
+string(f64 + i64)
+string(f64 - 0.5)
+string(f64 - f64)
+string(f64 - i32)
+string(f64 / 0.5)
+string(f64 / f64)
+string(f64 / i64)
+string(f64 < 1)
+string(f64 < f64)
+string(f64 < i32)
+string(f64 <= f64)
+string(f64 <= i)
+string(f64 == 0.5)
+string(f64 == 1)
+string(f64 == f32)
+string(f64 == f64)
+string(f64 == i)
+string(f64 == i32)
+string(f64 == i64)
+string(f64 > 0.5)
+string(f64 > 1)
+string(f64 > f32)
+string(f64 > f64)
+string(f64 > i64)
+string(f64 >= 1)
+string(f64 >= f32)
+string(f64 >= i)
+string(f64 >= i64)
+string(f64 ^ 0.5)
+string(f64 ^ i)
+string(f64 ^ i32)
+string(f64 ^ i64)
+string(f64)
+string(false && false)
+string(false ? 0.5 : i32)
+string(false ? 1 : "bar")
+string(false ? 1 : f32)
+string(false ? 1 : score)
+string(false ? div : "foo")
+string(false ? f32 : foo)
+string(false and true)
+string(false) <= foo.Bar
+string(false) > string(add)
+string(filter(list, ok))
+string(find(array, ok))
+string(findIndex(array, true))
+string(findIndex(list, ok))
+string(findLast(array, # >= #))
+string(findLast(array, false))
+string(findLast(array, ok))
+string(findLast(list, ok))
+string(findLastIndex(array, not false))
+string(findLastIndex(array, ok))
+string(findLastIndex(array, true))
+string(findLastIndex(list, false))
+string(findLastIndex(list, ok))
+string(findLastIndex(list, true))
+string(first(array))
+string(first(list))
 string(float(0.5))
-string(float(a))
-string(float(b))
-string(float(f))
-string(get(arr, a))
-string(get(obj, s))
-string(int(0))
-string(int(b))
-string(int(f))
-string(keys(obj))
-string(last(arr))
-string(len("b"))
-string(len(obj))
-string(len(s))
-string(lower("c"))
-string(map(arr, 0.5))
-string(map(arr, a))
-string(map(arr, add))
-string(map(arr, arr))
-string(map(arr, b))
-string(map(arr, div))
-string(map(arr, obj))
-string(map(arr, ok))
-string(max(0))
+string(float(1))
+string(float(f32))
+string(float(f64))
+string(float(i))
+string(float(i64))
+string(foo != nil)
+string(foo not in list)
+string(foo)
+string(foo.Bar)
+string(foo.Qux)
+string(foo.String())
+string(foo.String)
+string(foo?.Bar)
+string(foo?.Qux)
+string(foo?.String())
+string(foo?.String)
+string(get(array, 1))
+string(get(array, i))
+string(get(list, i))
+string(get(list, i64))
+string(greet != add)
+string(greet != greet)
+string(greet != nil)
+string(greet != score)
+string(greet == add)
+string(greet == greet)
+string(greet == half)
+string(greet == nil)
+string(greet == score)
+string(greet("bar"))
+string(greet("foo"))
+string(greet)
+string(greet)[i64:i]
+string(half != add)
+string(half != div)
+string(half != half)
+string(half == greet)
+string(half == nil)
+string(half == score)
+string(half(-1))
+string(half(0.5))
+string(half(f64))
+string(half)
+string(half) > toJSON(nil)
+string(half) not endsWith type("foo")
+string(i != 0.5)
+string(i != f32)
+string(i != f64)
+string(i % 1)
+string(i % i32)
+string(i * i32)
+string(i * i64)
+string(i ** 1)
+string(i ** f32)
+string(i + 1)
+string(i + i)
+string(i + i32)
+string(i + i64)
+string(i - f32)
+string(i - i64)
+string(i .. 1)
+string(i .. i)
+string(i .. i64)
+string(i / 1)
+string(i / f32)
+string(i / i)
+string(i / i32)
+string(i / i64)
+string(i < 1)
+string(i < f32)
+string(i < i32)
+string(i <= 0.5)
+string(i <= 1)
+string(i == 0.5)
+string(i == f32)
+string(i == i32)
+string(i > 0.5)
+string(i > 1)
+string(i > f64)
+string(i > i64)
+string(i >= 1)
+string(i >= f64)
+string(i ^ 0.5)
+string(i ^ 1)
+string(i ^ i)
+string(i in array)
+string(i not in array)
+string(i)
+string(i32 != f64)
+string(i32 != i)
+string(i32 != nil)
+string(i32 * 0.5)
+string(i32 * 1)
+string(i32 * f32)
+string(i32 * f64)
+string(i32 * i64)
+string(i32 ** 0.5)
+string(i32 ** f64)
+string(i32 ** i)
+string(i32 + f64)
+string(i32 + i32)
+string(i32 - f32)
+string(i32 - f64)
+string(i32 .. 1)
+string(i32 .. i32)
+string(i32 .. i64)
+string(i32 / 0.5)
+string(i32 / i64)
+string(i32 < 0.5)
+string(i32 < f32)
+string(i32 < i)
+string(i32 < i32)
+string(i32 < i64)
+string(i32 <= f64)
+string(i32 <= i64)
+string(i32 == 1)
+string(i32 == f32)
+string(i32 == f64)
+string(i32 == i)
+string(i32 == nil)
+string(i32 > 1)
+string(i32 > f64)
+string(i32 >= 0.5)
+string(i32 >= 1)
+string(i32 >= f64)
+string(i32 >= i)
+string(i32 >= i64)
+string(i32 ^ 1)
+string(i32 ^ f64)
+string(i32 ^ i32)
+string(i32 ^ i64)
+string(i32 in array)
+string(i32 not in array)
+string(i32)
+string(i32) == type("bar")
+string(i64 != 0.5)
+string(i64 != 1)
+string(i64 != i)
+string(i64 != i32)
+string(i64 != i64)
+string(i64 != nil)
+string(i64 % 1)
+string(i64 % i64)
+string(i64 * 1)
+string(i64 * f32)
+string(i64 * i32)
+string(i64 * i64)
+string(i64 ** 0.5)
+string(i64 ** f32)
+string(i64 ** i)
+string(i64 ** i32)
+string(i64 + 0.5)
+string(i64 + f32)
+string(i64 + f64)
+string(i64 + i)
+string(i64 + i32)
+string(i64 - f32)
+string(i64 - i)
+string(i64 / 0.5)
+string(i64 / 1)
+string(i64 / f32)
+string(i64 / f64)
+string(i64 / i)
+string(i64 / i64)
+string(i64 < 1)
+string(i64 <= 0.5)
+string(i64 <= f32)
+string(i64 <= i)
+string(i64 <= i32)
+string(i64 <= i64)
+string(i64 == 1)
+string(i64 == i)
+string(i64 == i32)
+string(i64 == nil)
+string(i64 > 1)
+string(i64 > f32)
+string(i64 > f64)
+string(i64 > i)
+string(i64 > i32)
+string(i64 > i64)
+string(i64 >= f64)
+string(i64 >= i64)
+string(i64 ^ 0.5)
+string(i64 ^ f64)
+string(i64 ^ i)
+string(i64 in array)
+string(i64)
+string(i64) >= foo.Bar
+string(i64) not in foo
+string(int(0.5))
+string(int(1))
+string(int(f32 - i))
+string(int(f32))
+string(int(f64))
+string(int(i))
+string(int(i32))
+string(int(i64))
+string(last(array))
+string(last(list))
+string(len(array))
+string(len(list))
+string(len(string("foo")))
+string(list == array)
+string(list == list)
+string(list == nil)
+string(list)
+string(list) != toJSON(i64)
+string(list[1])
+string(list[i64])
+string(list[i64].String)
+string(lower("bar"))
+string(lower("foo"))
+string(map(array, "bar"))
+string(map(array, #))
+string(map(array, 0.5))
+string(map(array, 1))
+string(map(array, array))
+string(map(array, div))
+string(map(array, greet))
+string(map(array, i))
+string(map(array, i32))
+string(map(array, ok))
+string(map(array, true))
+string(map(list, "bar"))
+string(map(list, "foo"))
+string(map(list, #))
+string(map(list, 0.5))
+string(map(list, 1))
+string(map(list, add))
+string(map(list, f32))
+string(map(list, f64))
+string(map(list, false))
+string(map(list, greet))
+string(map(list, i64))
+string(map(list, list))
 string(max(0.5))
-string(max(f))
-string(min(2))
-string(min(f))
-string(nil != "b")
-string(nil != "c")
-string(nil != 2)
-string(nil != a)
-string(nil != add)
-string(nil != b)
-string(nil != f)
-string(nil != obj)
-string(nil != ok)
-string(nil != s)
-string(nil == 2)
+string(max(1))
+string(max(1, 0.5))
+string(max(1, f32))
+string(max(f32))
+string(max(f64))
+string(max(i))
+string(max(i32))
+string(max(i32, 1, i64))
+string(max(i64))
+string(min(0.5))
+string(min(0.5, f64, f32))
+string(min(1))
+string(min(f32))
+string(min(f64))
+string(min(i))
+string(min(i32))
+string(min(i32, i64))
+string(min(i64))
+string(nil != "foo")
+string(nil != 0.5)
+string(nil != 1)
+string(nil != array)
+string(nil != div)
+string(nil != f64)
+string(nil != false)
+string(nil != greet)
+string(nil != i)
+string(nil != i64)
+string(nil != nil)
+string(nil != score)
+string(nil == "foo")
+string(nil == 1)
 string(nil == add)
-string(nil == b)
-string(nil == div)
+string(nil == f32)
+string(nil == f64)
 string(nil == false)
-string(nil == obj)
+string(nil == list)
 string(nil == ok)
-string(nil == s)
-string(nil in arr)
-string(nil in obj)
-string(nil) != toJSON(true)
-string(nil) + s
-string(nil) == obj.a
-string(nil) in obj
-string(nil) matches s
-string(none(arr, false))
-string(none(arr, ok))
-string(none(arr, true))
+string(nil == true)
+string(nil in array)
+string(nil in list)
+string(nil) > string(1)
+string(nil) >= string(greet)
+string(nil) in foo
+string(none(array, ok))
+string(none(list, true))
 string(not false)
 string(not ok)
 string(not true)
-string(obj == obj)
-string(obj)
-string(obj) < s
-string(obj) <= s
-string(obj) contains s
-string(obj.a)
-string(obj.b)
-string(obj.fn(1))
-string(obj.fn(2))
-string(obj.fn(a))
-string(obj.fn(b))
-string(obj.head("a"))
-string(obj.head("c", b, "b", 2))
-string(obj.head(2))
-string(obj.head(a))
-string(obj.head(a, 0, arr, obj, b))
-string(obj.head(a, div))
-string(obj.head(add))
-string(obj.head(add, b, arr))
-string(obj.head(arr))
-string(obj.head(arr, f, obj))
-string(obj.head(arr, obj))
-string(obj.head(b))
-string(obj.head(b, a, s))
-string(obj.head(div))
-string(obj.head(f, "b", a, 0))
-string(obj.head(f, arr, "b", 2))
-string(obj.head(f, nil, a, f))
-string(obj.head(nil, 1))
-string(obj.head(obj, f))
-string(obj.head(ok))
-string(obj.head(ok, div, add))
-string(obj.head(s))
-string(obj.head(s, b, b, arr))
-string(obj.head(s, true))
-string(obj.obj == s)
-string(obj.obj)
-string(obj.obj.b)
-string(obj.obj.obj)
-string(obj.obj?.b)
-string(obj?.a)
-string(obj?.b <= f)
-string(obj?.b)
-string(obj?.b) contains s
-string(obj?.fn(0))
-string(obj?.fn(a))
-string(obj?.fn(b))
-string(obj?.head("c", 0.5, f))
-string(obj?.head(0, "a"))
-string(obj?.head(0.5))
-string(obj?.head(0.5, s))
-string(obj?.head(a))
-string(obj?.head(a, add))
-string(obj?.head(add))
-string(obj?.head(add, f, "a"))
-string(obj?.head(arr))
-string(obj?.head(arr, true))
-string(obj?.head(b, obj, arr))
-string(obj?.head(div))
-string(obj?.head(div, s, arr))
-string(obj?.head(f))
-string(obj?.head(false, true))
-string(obj?.head(nil))
-string(obj?.head(nil)?.a)
-string(obj?.head(obj))
-string(obj?.head(ok))
-string(obj?.head(s, b, s))
-string(obj?.obj)
-string(obj?.obj.a)
-string(obj?.obj.obj)
-string(obj[nil])
-string(obj[s])
-string(obj[s]?.a)
-string(obj[s]?.b)
-string(ok != ok)
 string(ok && false)
 string(ok && ok)
-string(ok ? a : b)
-string(ok ? add : 1)
-string(ok ? add : a)
-string(ok ? add : div)
-string(ok ? arr : div)
-string(ok ? b : true)
-string(ok ? div : nil)
-string(ok ? s : obj)
-string(ok ? true : add)
-string(ok and ok)
-string(ok or true)
+string(ok == nil)
+string(ok == true)
+string(ok ? 0.5 : "foo")
+string(ok ? 0.5 : true)
+string(ok ? true : i32)
+string(ok or false)
+string(ok or ok)
 string(ok || ok)
-string(ok || true)
 string(ok)
-string(ok) < s == ok
-string(one(arr, true))
-string(s != "c")
-string(s != nil)
-string(s != s)
-string(s < "b")
-string(s <= "a")
-string(s <= s)
-string(s == s)
-string(s > s)
-string(s >= "b")
-string(s >= s)
-string(s contains "c")
-string(s contains s)
-string(s endsWith s)
-string(s in obj)
-string(s startsWith s)
-string(s)
-string(s) startsWith s
-string(s[a:a])
-string(string("b"))
-string(string("c"))
+string(one(array, false))
+string(one(array, ok))
+string(one(array, true))
+string(one(list, true))
+string(score != nil)
+string(score == div)
+string(score == nil)
+string(score(1))
+string(score(i))
+string(score(score(i)))
+string(score)
+string(score) < string(ok)
+string(score) not in foo
+string(sort(array))
+string(string("bar"))
+string(string("foo"))
 string(string(0.5))
 string(string(1))
-string(string(2))
-string(string(a))
 string(string(add))
-string(string(arr))
-string(string(b))
+string(string(array))
 string(string(div))
+string(string(f64))
+string(string(false))
+string(string(foo))
+string(string(greet))
+string(string(half))
+string(string(i))
+string(string(i32))
+string(string(i64))
+string(string(list))
 string(string(nil))
-string(string(obj?.head(obj, a)))
 string(string(ok))
-string(string(s))
-string(toJSON(2))
-string(toJSON(a))
-string(toJSON(arr))
-string(toJSON(b))
-string(toJSON(f))
+string(string(score))
+string(string(true))
+string(toJSON("bar"))
+string(toJSON("foo"))
+string(toJSON(0.5))
+string(toJSON(1))
+string(toJSON(array))
+string(toJSON(f32))
+string(toJSON(f64))
+string(toJSON(false))
+string(toJSON(foo))
+string(toJSON(i))
+string(toJSON(i64))
+string(toJSON(list))
 string(toJSON(nil))
 string(toJSON(ok))
-string(toJSON(s))
-string(trim("a"))
-string(trimSuffix("a"))
-string(true != nil)
-string(true ? "a" : div)
-string(true ? a : ok)
-string(true ? add : add)
-string(true ? arr : f)
-string(true ? div : b)
-string(true ? s : div)
-string(true) == s
-string(values(obj))
-string({"b": div, "b": nil})
-toBase64("c" + "c")
-toBase64(lower(s))
-toBase64(obj.head("b", add))
-toBase64(obj.head("b", arr, s, 2))
-toBase64(obj.head("c"))
-toBase64(obj.head(s))
-toBase64(obj.head(s, ok, 0))
-toBase64(obj?.head("c", div))
-toBase64(obj?.head(s))
-toBase64(obj?.head(s, arr, 1, b))
-toBase64(ok ? "a" : obj)
-toBase64(ok ? s : obj?.fn(div(1, ok), true ** obj))
-toBase64(s + s)
-toBase64(s)
-toBase64(s) != "a" ? false : 0
-toBase64(s) + s[b:a]
-toBase64(s) == obj.head(ok, false)
-toBase64(s) endsWith s
-toBase64(string(2))
-toBase64(string(a))
-toBase64(string(add))
-toBase64(string(arr))
-toBase64(string(b))
-toBase64(string(obj))
+string(toJSON(true))
+string(trim("foo"))
+string(trim(toJSON(0.5)))
+string(trimPrefix("bar"))
+string(trimPrefix("foo"))
+string(trimPrefix(type(f32)))
+string(trimSuffix("bar"))
+string(true != true)
+string(true == nil)
+string(true == ok)
+string(true ? 1 : true)
+string(true ? array : f32)
+string(true ? div : i64)
+string(true ? i32 : "foo")
+string(true ? i32 : greet)
+string(true ? score : 0.5)
+string(true ? true : i32)
+string(true and false)
+string(true or true)
+string(true || false)
+string(true) endsWith string(i64)
+string(true) not in foo
+string(type("foo"))
+string(type(0.5))
+string(type(1 < f64))
+string(type(1))
+string(type(add))
+string(type(array))
+string(type(div))
+string(type(f32))
+string(type(f64))
+string(type(false))
+string(type(foo))
+string(type(half))
+string(type(i))
+string(type(i32))
+string(type(i64))
+string(type(list))
+string(type(nil))
+string(type(ok))
+string(type(score(1)))
+string(type(score))
+string(type(true))
+string(type(type(false)))
+string(upper("bar"))
+string(upper("foo"))
+string({"bar": 0.5})
+string({"bar": i32, "foo": i64})
+string({"foo": f64})
+string({"foo": true})
+toBase64(foo.Bar)
+toBase64(foo.String())
+toBase64(foo?.Bar)
+toBase64(foo?.String())
+toBase64(greet("bar"))
+toBase64(greet("foo"))
+toBase64(greet(string(array)))
+toBase64(lower("bar"))
+toBase64(lower("foo"))
+toBase64(lower(type(i32)))
+toBase64(ok ? "foo" : 1)
+toBase64(ok ? "foo" : foo)
+toBase64(string("bar"))
+toBase64(string("foo"))
+toBase64(string(0.5))
+toBase64(string(1))
+toBase64(string(array))
+toBase64(string(f32 <= i32))
+toBase64(string(f32))
+toBase64(string(f64))
+toBase64(string(false))
+toBase64(string(foo))
+toBase64(string(greet))
+toBase64(string(half))
+toBase64(string(i))
+toBase64(string(i32))
+toBase64(string(i64))
+toBase64(string(list))
+toBase64(string(nil))
+toBase64(string(ok))
+toBase64(string(score))
 toBase64(string(true))
-toBase64(toBase64("a"))
-toBase64(toBase64(s))
-toBase64(toJSON(a))
-toBase64(toJSON(b))
-toBase64(toJSON(f))
+toBase64(toBase64("bar"))
+toBase64(toBase64("foo"))
+toBase64(toJSON("bar"))
+toBase64(toJSON("foo"))
+toBase64(toJSON(0.5))
+toBase64(toJSON(1))
+toBase64(toJSON(array))
+toBase64(toJSON(f32))
+toBase64(toJSON(f64))
+toBase64(toJSON(false))
+toBase64(toJSON(foo))
+toBase64(toJSON(i))
+toBase64(toJSON(i32))
+toBase64(toJSON(i64))
+toBase64(toJSON(list))
 toBase64(toJSON(nil))
 toBase64(toJSON(ok))
-toBase64(toJSON(s))
-toBase64(trim("c"))
-toBase64(trimPrefix("b"))
-toBase64(trimPrefix(s))
-toBase64(trimSuffix("b"))
-toBase64(trimSuffix(s))
-toBase64(true ? "b" : arr)
-toBase64(upper("b"))
+toBase64(toJSON(true))
+toBase64(trim("bar"))
+toBase64(trim("foo"))
+toBase64(trimPrefix("foo"))
+toBase64(trimSuffix("bar"))
+toBase64(trimSuffix("foo"))
+toBase64(true ? "bar" : ok)
+toBase64(type("bar"))
+toBase64(type("foo"))
+toBase64(type(0.5))
+toBase64(type(1))
+toBase64(type(add))
+toBase64(type(array))
+toBase64(type(div))
+toBase64(type(f32))
+toBase64(type(f64))
+toBase64(type(false))
+toBase64(type(foo))
+toBase64(type(get(array, i)))
+toBase64(type(greet))
+toBase64(type(i))
+toBase64(type(i32))
+toBase64(type(i64))
+toBase64(type(list))
+toBase64(type(ok))
+toBase64(type(true))
+toBase64(upper("bar"))
+toBase64(upper("foo"))
+toBase64(upper(foo.Bar))
 toJSON(!false)
 toJSON(!ok)
 toJSON(!true)
-toJSON("a" != nil)
-toJSON("a" == "b")
-toJSON("a" == nil)
-toJSON("a" == s)
-toJSON("a" contains s)
-toJSON("a" matches s)
-toJSON("a") >= trimSuffix("c")
-toJSON("b" != s)
-toJSON("b" < s)
-toJSON("b" <= "a")
-toJSON("b" == nil)
-toJSON("b" > "b")
-toJSON("b" >= s)
-toJSON("b" in obj)
-toJSON("b" matches "b")
-toJSON("b" matches s)
-toJSON("b") <= s
-toJSON("b") matches s
-toJSON("c" < "a")
-toJSON("c" <= s)
-toJSON("c" == nil)
-toJSON("c" endsWith "a")
-toJSON("c" matches "c")
-toJSON("c" startsWith "c")
-toJSON("c" startsWith s)
-toJSON("c") in obj
-toJSON("c") startsWith lower("c")
-toJSON(-(a - 0))
-toJSON(-(f - 0.5))
-toJSON(-0)
+toJSON("bar" != "foo")
+toJSON("bar" + "bar")
+toJSON("bar" + "foo")
+toJSON("bar" <= "foo")
+toJSON("bar" >= "foo")
+toJSON("bar" contains "bar")
+toJSON("bar" matches "bar")
+toJSON("bar" not matches "bar")
+toJSON("bar" not matches "foo")
+toJSON("foo" != "bar")
+toJSON("foo" + "bar")
+toJSON("foo" <= "bar")
+toJSON("foo" == nil)
+toJSON("foo" contains "bar")
+toJSON("foo" matches "foo")
+toJSON("foo" not in foo)
+toJSON("foo" not matches "bar")
+toJSON("foo") > foo?.Bar
+toJSON("foo") not in foo
 toJSON(-0.5)
 toJSON(-1)
-toJSON(-2)
-toJSON(-a)
-toJSON(-b)
-toJSON(-f)
-toJSON(0 != 0)
-toJSON(0 != 1)
-toJSON(0 != 2)
-toJSON(0 != b)
-toJSON(0 != f)
-toJSON(0 % a)
-toJSON(0 % b)
-toJSON(0 * 1)
-toJSON(0 * f)
-toJSON(0 ** 0.5)
-toJSON(0 ** a)
-toJSON(0 + 1)
-toJSON(0 + a)
-toJSON(0 + b)
-toJSON(0 + f)
-toJSON(0 - 0)
-toJSON(0 - a)
-toJSON(0 - b)
-toJSON(0 .. 1)
-toJSON(0 .. 2)
-toJSON(0 .. a)
-toJSON(0 < 0)
-toJSON(0 < a)
-toJSON(0 < f)
-toJSON(0 <= 0)
-toJSON(0 <= a)
-toJSON(0 <= obj?.a)
-toJSON(0 == 0)
-toJSON(0 == 0.5)
-toJSON(0 == 1)
-toJSON(0 == a)
-toJSON(0 == nil)
-toJSON(0 >= 1)
-toJSON(0 >= a)
-toJSON(0 >= b)
-toJSON(0 >= f)
-toJSON(0 ^ 0.5)
-toJSON(0 ^ b)
-toJSON(0 in arr)
-toJSON(0) + s
-toJSON(0) in obj?.obj
+toJSON(-f32)
+toJSON(-f64)
+toJSON(-i)
+toJSON(-i32)
+toJSON(-i64)
+toJSON(0.5 != 0.5)
 toJSON(0.5 != 1)
-toJSON(0.5 != a)
+toJSON(0.5 != f32)
+toJSON(0.5 != f64)
+toJSON(0.5 != i)
+toJSON(0.5 != i32)
 toJSON(0.5 * 0.5)
-toJSON(0.5 * b)
-toJSON(0.5 * f)
-toJSON(0.5 ** 2)
-toJSON(0.5 - b)
-toJSON(0.5 / b)
-toJSON(0.5 < 0)
-toJSON(0.5 < b)
-toJSON(0.5 == b)
-toJSON(0.5 == f)
-toJSON(0.5 == nil)
-toJSON(0.5 > a)
+toJSON(0.5 * i)
+toJSON(0.5 * i32)
+toJSON(0.5 ** f64)
+toJSON(0.5 ** i)
+toJSON(0.5 ** i64)
+toJSON(0.5 + 0.5)
+toJSON(0.5 + f32)
+toJSON(0.5 - 0.5)
+toJSON(0.5 - 1)
+toJSON(0.5 - f32)
+toJSON(0.5 - f64)
+toJSON(0.5 / 0.5)
+toJSON(0.5 / 1)
+toJSON(0.5 / f32)
+toJSON(0.5 / f64)
+toJSON(0.5 / i)
+toJSON(0.5 / i32)
+toJSON(0.5 / i64)
+toJSON(0.5 < 0.5)
+toJSON(0.5 < 1)
+toJSON(0.5 < f32)
+toJSON(0.5 < i)
+toJSON(0.5 <= 1)
+toJSON(0.5 <= f32)
+toJSON(0.5 <= f64)
+toJSON(0.5 <= i)
+toJSON(0.5 == 0.5)
+toJSON(0.5 == 1)
+toJSON(0.5 == f32)
+toJSON(0.5 == i)
+toJSON(0.5 == i64)
+toJSON(0.5 > 1)
+toJSON(0.5 > f32)
+toJSON(0.5 > f64)
+toJSON(0.5 > i32)
+toJSON(0.5 >= 0.5)
 toJSON(0.5 >= 1)
-toJSON(0.5 >= f)
-toJSON(0.5 ^ 0)
-toJSON(0.5 ^ f)
-toJSON(0.5) contains s
-toJSON(1 != 2)
-toJSON(1 != b)
-toJSON(1 % a)
-toJSON(1 % b)
-toJSON(1 * 0)
-toJSON(1 ** 0)
-toJSON(1 + b)
-toJSON(1 - 0)
+toJSON(0.5 >= f32)
+toJSON(0.5 >= f64)
+toJSON(0.5 >= i)
+toJSON(0.5 >= i32)
+toJSON(0.5 >= i64)
+toJSON(0.5 ^ 0.5)
+toJSON(0.5 ^ 1)
+toJSON(0.5 ^ f32)
+toJSON(0.5 ^ f64)
+toJSON(0.5 ^ i)
+toJSON(0.5 ^ i32)
+toJSON(0.5 ^ i64)
+toJSON(0.5) contains "bar" ? "bar" : array
+toJSON(1 != 0.5)
+toJSON(1 != f32)
+toJSON(1 != nil)
+toJSON(1 % 1)
+toJSON(1 % i32)
+toJSON(1 * 0.5)
+toJSON(1 * f32)
+toJSON(1 * f64)
+toJSON(1 * i32)
+toJSON(1 * i64)
+toJSON(1 ** 0.5)
+toJSON(1 ** 1)
+toJSON(1 ** f32)
+toJSON(1 ** f64)
+toJSON(1 ** i >= f64)
+toJSON(1 ** i32)
+toJSON(1 + 0.5)
+toJSON(1 + f32)
+toJSON(1 + f64)
+toJSON(1 + i64)
 toJSON(1 - 0.5)
-toJSON(1 - a)
-toJSON(1 == a)
+toJSON(1 - 1)
+toJSON(1 - f32)
+toJSON(1 - f64)
+toJSON(1 - i32)
+toJSON(1 .. 1)
+toJSON(1 .. i)
+toJSON(1 .. i64)
+toJSON(1 / 0.5)
+toJSON(1 / 1)
+toJSON(1 / f32)
+toJSON(1 / i32)
+toJSON(1 < 0.5)
+toJSON(1 < 1)
+toJSON(1 < f32)
+toJSON(1 < f64)
+toJSON(1 < i)
+toJSON(1 <= 0.5)
+toJSON(1 <= 1)
+toJSON(1 <= i)
+toJSON(1 <= i32)
+toJSON(1 <= i64)
+toJSON(1 == 0.5)
+toJSON(1 == f32)
+toJSON(1 == i)
+toJSON(1 == i32)
+toJSON(1 == i64)
+toJSON(1 == nil)
 toJSON(1 > 0.5)
-toJSON(1 > b)
-toJSON(1 >= b)
-toJSON(1) startsWith s
-toJSON(1) startsWith string(0)
-toJSON(2 != 1)
-toJSON(2 != f)
-toJSON(2 % obj.a)
-toJSON(2 * 0)
-toJSON(2 * b)
-toJSON(2 + 2)
-toJSON(2 + f)
-toJSON(2 - 0.5)
-toJSON(2 - a)
-toJSON(2 .. a)
-toJSON(2 <= 1)
-toJSON(2 == f)
-toJSON(2 >= f)
-toJSON(2 ^ 0)
-toJSON(2 ^ a)
-toJSON(2 ^ b)
-toJSON([0])
-toJSON([b])
-toJSON(a != 0)
-toJSON(a != 0.5 and obj?.b)
-toJSON(a != b)
-toJSON(a != nil)
-toJSON(a % a)
-toJSON(a % b)
-toJSON(a * b)
-toJSON(a ** 0)
-toJSON(a ** 0.5)
-toJSON(a ** f)
-toJSON(a + 0.5)
-toJSON(a + 2)
-toJSON(a + b)
-toJSON(a + f)
-toJSON(a - 0)
-toJSON(a - 0.5)
-toJSON(a - a)
-toJSON(a .. 0)
-toJSON(a .. a)
-toJSON(a .. b)
-toJSON(a / 0.5)
-toJSON(a / b)
-toJSON(a < a)
-toJSON(a <= 0)
-toJSON(a <= 0.5)
-toJSON(a <= 1)
-toJSON(a <= a)
-toJSON(a <= b)
-toJSON(a <= f)
-toJSON(a == 0)
-toJSON(a == 0.5)
-toJSON(a == 2)
-toJSON(a == b)
-toJSON(a > 0)
-toJSON(a > 0.5)
-toJSON(a > b)
-toJSON(a > f)
-toJSON(a >= 0.5)
-toJSON(a >= a)
-toJSON(a >= b)
-toJSON(a >= f)
-toJSON(a >= obj.a)
-toJSON(a ^ f)
-toJSON(a)
-toJSON(a) != obj.obj
-toJSON(a) < s
-toJSON(a) == "c" ? 0.5 : nil
+toJSON(1 > f64)
+toJSON(1 > i)
+toJSON(1 > i32)
+toJSON(1 > i64)
+toJSON(1 >= 0.5)
+toJSON(1 >= 1)
+toJSON(1 >= f32)
+toJSON(1 >= i32)
+toJSON(1 ^ 0.5)
+toJSON(1 ^ 1)
+toJSON(1 ^ f32)
+toJSON(1 ^ f64)
+toJSON(1 ^ i32)
+toJSON(1 ^ i64)
+toJSON(1 in array)
+toJSON(1) == nil == true
+toJSON(1) in foo
+toJSON(1) not in foo
+toJSON(1) startsWith foo.String()
+toJSON([1])
+toJSON([i64])
 toJSON(abs(0.5))
-toJSON(abs(a))
-toJSON(abs(b))
-toJSON(abs(obj.a))
-toJSON(add != div)
+toJSON(abs(1))
+toJSON(abs(f32))
+toJSON(abs(f64))
+toJSON(abs(i))
+toJSON(abs(i32))
+toJSON(abs(i64))
 toJSON(add != nil)
-toJSON(add != obj.b)
-toJSON(add == add)
-toJSON(add(0, a))
-toJSON(add(1, 2))
-toJSON(add(a, 0))
-toJSON(add(a, 1))
-toJSON(add(a, a))
-toJSON(add(b, 0))
-toJSON(add(b, 2))
-toJSON(add(b, b))
-toJSON(all(arr, ok))
-toJSON(any(arr, ok))
-toJSON(arr == arr)
-toJSON(arr == nil)
-toJSON(arr)
-toJSON(arr) > s
-toJSON(arr) endsWith s
-toJSON(arr) in obj?.obj
-toJSON(arr) matches "b" ? b : obj
-toJSON(arr[0])
-toJSON(arr[a])
-toJSON(arr[b:b])
-toJSON(arr[b])
-toJSON(b != 0)
-toJSON(b != b)
-toJSON(b % 1)
-toJSON(b * 0.5)
-toJSON(b * a)
-toJSON(b ** a)
-toJSON(b ** b)
-toJSON(b ** f)
-toJSON(b + 0.5)
-toJSON(b + 2)
-toJSON(b + f)
-toJSON(b + obj.a)
-toJSON(b - 0)
-toJSON(b - 2)
-toJSON(b - a)
-toJSON(b - b)
-toJSON(b - f)
-toJSON(b / b)
-toJSON(b < a)
-toJSON(b < f)
-toJSON(b <= 0)
-toJSON(b <= 2)
-toJSON(b <= a)
-toJSON(b <= b)
-toJSON(b == 0)
-toJSON(b == 0.5)
-toJSON(b == a)
-toJSON(b == f)
-toJSON(b == nil)
-toJSON(b > a)
-toJSON(b > b)
-toJSON(b > obj.a)
-toJSON(b >= b)
-toJSON(b >= f)
-toJSON(b ^ 2)
-toJSON(b)
-toJSON(b) != s
-toJSON(b) >= s
-toJSON(b) contains s
-toJSON(b) startsWith s
-toJSON(count(arr, false))
-toJSON(count(arr, true))
-toJSON(date("b", "b"))
-toJSON(div == add)
+toJSON(add != score)
+toJSON(add == div)
+toJSON(add == half)
+toJSON(add == nil)
+toJSON(add == score)
+toJSON(all(list, false))
+toJSON(all(list, ok))
+toJSON(all(list, true))
+toJSON(any(array, false))
+toJSON(any(array, true))
+toJSON(array != array)
+toJSON(array != nil)
+toJSON(array)
+toJSON(array) != toJSON(ok)
+toJSON(array) > "bar" != false
+toJSON(array) endsWith greet("foo")
+toJSON(array) endsWith string(i32)
+toJSON(array) in foo
+toJSON(array) not startsWith greet("foo")
+toJSON(array[1:1])
+toJSON(array[i32])
+toJSON(array[i])
+toJSON(count(array, false))
+toJSON(count(array, ok))
+toJSON(div != div)
+toJSON(div != greet)
+toJSON(div != score)
 toJSON(div == div)
+toJSON(div == half)
 toJSON(div == nil)
-toJSON(div == obj.a)
-toJSON(div == obj?.b)
-toJSON(div(0, a))
-toJSON(div(1, a))
-toJSON(div(a, 2))
-toJSON(div(a, a))
-toJSON(div(a, b))
-toJSON(div(b, 2))
-toJSON(div(b, a))
-toJSON(div(b, b))
-toJSON(f != b)
-toJSON(f != f)
-toJSON(f != obj?.b)
-toJSON(f * a)
-toJSON(f * b)
-toJSON(f * f)
-toJSON(f ** a)
-toJSON(f ** b)
-toJSON(f ** f)
-toJSON(f + 0.5)
-toJSON(f + a)
-toJSON(f + b)
-toJSON(f - 0.5)
-toJSON(f - a)
-toJSON(f - b)
-toJSON(f - f)
-toJSON(f / a)
-toJSON(f < 0)
-toJSON(f < f)
-toJSON(f <= 0)
-toJSON(f <= f)
-toJSON(f == a)
-toJSON(f > 0)
-toJSON(f > 0.5)
-toJSON(f > a)
-toJSON(f > f)
-toJSON(f >= b)
-toJSON(f ^ 0.5)
-toJSON(f ^ 1)
-toJSON(f)
-toJSON(f) endsWith s
-toJSON(f) startsWith s
-toJSON(false ? false : 0)
-toJSON(false ? false : b)
-toJSON(false ? obj : 1)
-toJSON(false or ok)
-toJSON(false || true)
-toJSON(false) contains s
-toJSON(filter(arr, false))
-toJSON(filter(arr, ok))
-toJSON(first(arr))
-toJSON(float(2))
-toJSON(float(a))
-toJSON(float(b))
-toJSON(get(arr, 0))
-toJSON(get(arr, b))
-toJSON(get(obj, s))
-toJSON(get(obj, s)?.a)
-toJSON(int(0))
-toJSON(int(2))
-toJSON(int(a))
-toJSON(int(b))
-toJSON(int(f))
-toJSON(last(arr))
-toJSON(len("c"))
-toJSON(len(arr))
-toJSON(len(s))
-toJSON(lower("c"))
-toJSON(lower(s))
-toJSON(map(arr, "c"))
-toJSON(map(arr, 0))
-toJSON(map(arr, 0.5))
-toJSON(map(arr, 2))
-toJSON(map(arr, a))
-toJSON(map(arr, b))
-toJSON(map(arr, f))
-toJSON(map(arr, false))
-toJSON(map(arr, s))
-toJSON(max(0))
-toJSON(max(b))
-toJSON(max(f))
-toJSON(min(2))
-toJSON(min(a))
-toJSON(min(f))
-toJSON(nil != "b")
-toJSON(nil != 0)
-toJSON(nil != a)
+toJSON(div == score)
+toJSON(f32 != 1)
+toJSON(f32 * 0.5)
+toJSON(f32 * 1)
+toJSON(f32 * f32)
+toJSON(f32 * f64)
+toJSON(f32 * i32)
+toJSON(f32 ** f32)
+toJSON(f32 ** i32)
+toJSON(f32 ** i64)
+toJSON(f32 + 1)
+toJSON(f32 + i)
+toJSON(f32 + i32)
+toJSON(f32 - f64)
+toJSON(f32 - i32)
+toJSON(f32 / 0.5)
+toJSON(f32 / 1)
+toJSON(f32 < 0.5)
+toJSON(f32 < f32)
+toJSON(f32 < f64)
+toJSON(f32 <= f32)
+toJSON(f32 == 1)
+toJSON(f32 == f64)
+toJSON(f32 == i)
+toJSON(f32 == nil)
+toJSON(f32 > 0.5)
+toJSON(f32 > f64)
+toJSON(f32 > i)
+toJSON(f32 >= 1)
+toJSON(f32 >= f32)
+toJSON(f32 ^ 0.5)
+toJSON(f32 ^ 1)
+toJSON(f32 ^ f64)
+toJSON(f32 ^ i)
+toJSON(f32 ^ i64)
+toJSON(f32)
+toJSON(f64 != 1)
+toJSON(f64 != f32)
+toJSON(f64 != f64)
+toJSON(f64 != i)
+toJSON(f64 != i32 / i32)
+toJSON(f64 != i32)
+toJSON(f64 != nil)
+toJSON(f64 * 0.5)
+toJSON(f64 * f64)
+toJSON(f64 * i)
+toJSON(f64 * i64)
+toJSON(f64 ** 0.5)
+toJSON(f64 ** f32)
+toJSON(f64 ** i)
+toJSON(f64 ** i64)
+toJSON(f64 + 1)
+toJSON(f64 + f32)
+toJSON(f64 + i)
+toJSON(f64 + i32)
+toJSON(f64 - 1)
+toJSON(f64 - f64)
+toJSON(f64 - i)
+toJSON(f64 - i32)
+toJSON(f64 / 0.5)
+toJSON(f64 / f32)
+toJSON(f64 / i32)
+toJSON(f64 < 1)
+toJSON(f64 < f32)
+toJSON(f64 < i32)
+toJSON(f64 < i64)
+toJSON(f64 <= 0.5)
+toJSON(f64 <= 1)
+toJSON(f64 <= i32)
+toJSON(f64 == 1)
+toJSON(f64 == i64)
+toJSON(f64 == nil)
+toJSON(f64 > 1)
+toJSON(f64 > f64)
+toJSON(f64 >= 0.5)
+toJSON(f64 >= i64)
+toJSON(f64 ^ 1)
+toJSON(f64 ^ f64)
+toJSON(f64 ^ i)
+toJSON(f64)
+toJSON(false != nil)
+toJSON(false && false)
+toJSON(false == false)
+toJSON(false ? 0.5 : nil)
+toJSON(false ? 1 : f32)
+toJSON(false ? f32 : list)
+toJSON(false ? false : i32)
+toJSON(false ? greet : 1)
+toJSON(false ? greet : i32)
+toJSON(false ? nil : f64)
+toJSON(false and ok)
+toJSON(false and true)
+toJSON(filter(array, ok))
+toJSON(filter(list, false))
+toJSON(filter(list, true))
+toJSON(find(array, false))
+toJSON(find(array, ok))
+toJSON(findIndex(array, ok))
+toJSON(findIndex(array, true))
+toJSON(findIndex(list, ok))
+toJSON(findIndex(list, true))
+toJSON(findLast(array, false))
+toJSON(findLast(list, true))
+toJSON(findLastIndex(array, true))
+toJSON(findLastIndex(list, false))
+toJSON(findLastIndex(list, ok))
+toJSON(first(array))
+toJSON(first(list))
+toJSON(float(0.5))
+toJSON(float(1))
+toJSON(float(f32))
+toJSON(float(f64))
+toJSON(float(i))
+toJSON(float(i32))
+toJSON(float(i64))
+toJSON(foo != foo)
+toJSON(foo != nil)
+toJSON(foo == foo)
+toJSON(foo == nil)
+toJSON(foo in list)
+toJSON(foo)
+toJSON(foo.Bar)
+toJSON(foo.String())
+toJSON(foo?.Bar)
+toJSON(foo?.String())
+toJSON(get(array, 1))
+toJSON(get(array, i64))
+toJSON(get(list, 1))
+toJSON(get(list, i))
+toJSON(get(list, i64))
+toJSON(greet != div)
+toJSON(greet != greet)
+toJSON(greet != half)
+toJSON(greet == add)
+toJSON(greet == div)
+toJSON(greet == greet)
+toJSON(greet == half)
+toJSON(greet("bar"))
+toJSON(greet("foo"))
+toJSON(half != greet)
+toJSON(half != nil)
+toJSON(half != score)
+toJSON(half == add)
+toJSON(half == div)
+toJSON(half == greet)
+toJSON(half == nil)
+toJSON(half == score)
+toJSON(half(0.5))
+toJSON(half(f64))
+toJSON(i != 1)
+toJSON(i != f32)
+toJSON(i != i)
+toJSON(i != i32)
+toJSON(i % 1)
+toJSON(i % i64)
+toJSON(i * 0.5)
+toJSON(i * 1)
+toJSON(i * f32)
+toJSON(i * i32)
+toJSON(i ** 0.5)
+toJSON(i ** f32)
+toJSON(i ** i32)
+toJSON(i + 0.5)
+toJSON(i + 1)
+toJSON(i + f32)
+toJSON(i + f64)
+toJSON(i + i)
+toJSON(i - 1)
+toJSON(i .. 1)
+toJSON(i .. i)
+toJSON(i / f32)
+toJSON(i < i32)
+toJSON(i < i64)
+toJSON(i <= 1)
+toJSON(i <= f32)
+toJSON(i <= f64)
+toJSON(i <= i)
+toJSON(i <= i32)
+toJSON(i == i32)
+toJSON(i == i64)
+toJSON(i == nil)
+toJSON(i > 0.5)
+toJSON(i > 1)
+toJSON(i > f32)
+toJSON(i >= 0.5)
+toJSON(i >= 1)
+toJSON(i >= f32)
+toJSON(i >= i)
+toJSON(i ^ 1)
+toJSON(i ^ f64)
+toJSON(i)
+toJSON(i) != string(1)
+toJSON(i32 != f32)
+toJSON(i32 != i)
+toJSON(i32 % 1)
+toJSON(i32 % i64)
+toJSON(i32 * i)
+toJSON(i32 * i64)
+toJSON(i32 ** i64)
+toJSON(i32 + f64)
+toJSON(i32 + i)
+toJSON(i32 + i32)
+toJSON(i32 + i64)
+toJSON(i32 - 0.5)
+toJSON(i32 - 1)
+toJSON(i32 - f32)
+toJSON(i32 - f64)
+toJSON(i32 - i)
+toJSON(i32 .. i)
+toJSON(i32 .. i64)
+toJSON(i32 / 0.5)
+toJSON(i32 / f32)
+toJSON(i32 / i)
+toJSON(i32 / i64)
+toJSON(i32 < 0.5)
+toJSON(i32 < f32)
+toJSON(i32 <= 0.5)
+toJSON(i32 <= i32)
+toJSON(i32 == 1)
+toJSON(i32 == f32)
+toJSON(i32 == i)
+toJSON(i32 == nil ? i32 : i32)
+toJSON(i32 == nil)
+toJSON(i32 > 0.5)
+toJSON(i32 > f64)
+toJSON(i32 > i)
+toJSON(i32 >= 0.5)
+toJSON(i32 >= 1)
+toJSON(i32 >= f32)
+toJSON(i32 >= f64)
+toJSON(i32 >= i)
+toJSON(i32 ^ 1)
+toJSON(i32 ^ f64)
+toJSON(i32 ^ i)
+toJSON(i32 in array)
+toJSON(i32 not in array)
+toJSON(i32)
+toJSON(i32) < string(i64)
+toJSON(i64 != 0.5)
+toJSON(i64 != 1)
+toJSON(i64 != f32)
+toJSON(i64 != i)
+toJSON(i64 != i32)
+toJSON(i64 != nil)
+toJSON(i64 % 1)
+toJSON(i64 % i)
+toJSON(i64 % i32)
+toJSON(i64 % i64)
+toJSON(i64 * i)
+toJSON(i64 + 0.5)
+toJSON(i64 + i)
+toJSON(i64 + i64)
+toJSON(i64 - 0.5)
+toJSON(i64 - 1)
+toJSON(i64 - i64)
+toJSON(i64 .. 1)
+toJSON(i64 / 1)
+toJSON(i64 / f32)
+toJSON(i64 / i)
+toJSON(i64 / i64)
+toJSON(i64 < 0.5)
+toJSON(i64 < i32)
+toJSON(i64 <= 0.5)
+toJSON(i64 <= 1)
+toJSON(i64 <= f32)
+toJSON(i64 <= i64)
+toJSON(i64 == 0.5)
+toJSON(i64 == 1)
+toJSON(i64 == i32)
+toJSON(i64 == nil)
+toJSON(i64 > f32)
+toJSON(i64 > i)
+toJSON(i64 >= 0.5)
+toJSON(i64 >= 1)
+toJSON(i64 >= i64)
+toJSON(i64 ^ i)
+toJSON(i64)
+toJSON(int(0.5))
+toJSON(int(1))
+toJSON(int(f32))
+toJSON(int(f64))
+toJSON(int(i))
+toJSON(int(i32))
+toJSON(last(list))
+toJSON(len("bar"))
+toJSON(len("foo"))
+toJSON(len(array))
+toJSON(len(list))
+toJSON(list != list)
+toJSON(list == nil)
+toJSON(list)
+toJSON(list) <= foo?.Bar
+toJSON(list[1])
+toJSON(list[i32])
+toJSON(list[i64:1])
+toJSON(list[i64])
+toJSON(list[i])
+toJSON(lower("bar"))
+toJSON(lower("foo"))
+toJSON(map(array, #))
+toJSON(map(array, 0.5))
+toJSON(map(array, 1))
+toJSON(map(array, false))
+toJSON(map(array, i))
+toJSON(map(array, i32))
+toJSON(map(array, list))
+toJSON(map(array, true))
+toJSON(map(list, "foo"))
+toJSON(map(list, #))
+toJSON(map(list, 1))
+toJSON(map(list, f32))
+toJSON(map(list, f64))
+toJSON(map(list, list))
+toJSON(max(0.5))
+toJSON(max(1))
+toJSON(max(f32))
+toJSON(max(f64))
+toJSON(max(i))
+toJSON(max(i32))
+toJSON(max(i64))
+toJSON(min(0.5))
+toJSON(min(0.5, f32))
+toJSON(min(1))
+toJSON(min(1, 1))
+toJSON(min(f32))
+toJSON(min(f64))
+toJSON(min(i))
+toJSON(min(i32) / f32)
+toJSON(min(i32))
+toJSON(min(i64))
+toJSON(nil != "bar")
+toJSON(nil != "foo")
+toJSON(nil != 0.5)
 toJSON(nil != add)
-toJSON(nil != b)
-toJSON(nil != div)
+toJSON(nil != f32)
+toJSON(nil != f64)
+toJSON(nil != foo)
+toJSON(nil != i32)
+toJSON(nil != list)
+toJSON(nil != nil)
+toJSON(nil != score)
 toJSON(nil != true)
-toJSON(nil == 0)
-toJSON(nil == a)
-toJSON(nil == arr)
-toJSON(nil == f)
+toJSON(nil == 0.5)
+toJSON(nil == 1)
+toJSON(nil == add)
+toJSON(nil == div)
+toJSON(nil == f32)
+toJSON(nil == f64)
 toJSON(nil == false)
-toJSON(nil == nil)
-toJSON(nil == s)
+toJSON(nil == foo)
+toJSON(nil == i)
+toJSON(nil == i64)
+toJSON(nil == list)
+toJSON(nil == ok)
+toJSON(nil == score)
 toJSON(nil == true)
-toJSON(nil in arr)
-toJSON(nil in obj)
-toJSON(nil) < s
-toJSON(nil) endsWith s
-toJSON(nil) in obj
-toJSON(none(arr, false))
-toJSON(none(arr, true))
+toJSON(nil in array)
+toJSON(nil not in array)
+toJSON(nil not in list)
+toJSON(nil) + string("bar")
+toJSON(nil) == toJSON(1)
+toJSON(nil) == type(nil)
+toJSON(nil) in foo
+toJSON(none(array, true))
+toJSON(none(list, true))
+toJSON(not ("foo" not in foo))
 toJSON(not false)
 toJSON(not ok)
 toJSON(not true)
-toJSON(obj != obj)
-toJSON(obj == nil)
-toJSON(obj.a <= f)
-toJSON(obj.a)
-toJSON(obj.b / a)
-toJSON(obj.b)
-toJSON(obj.c)
-toJSON(obj.fn(0))
-toJSON(obj.fn(a))
-toJSON(obj.fn(b))
-toJSON(obj.head(!true))
-toJSON(obj.head(0.5))
-toJSON(obj.head(1, 0.5, nil, f))
-toJSON(obj.head(2, a, div))
-toJSON(obj.head(a))
-toJSON(obj.head(a, "a"))
-toJSON(obj.head(a, ok))
-toJSON(obj.head(arr))
-toJSON(obj.head(arr, "c"))
-toJSON(obj.head(b))
-toJSON(obj.head(b, "a"))
-toJSON(obj.head(f))
-toJSON(obj.head(f, f))
-toJSON(obj.head(false))
-toJSON(obj.head(nil))
-toJSON(obj.head(nil, add))
-toJSON(obj.head(obj).a)
-toJSON(obj.head(obj)?.obj)
-toJSON(obj.head(obj?.b))
-toJSON(obj.head(ok))
-toJSON(obj.head(ok, div, ok, b, nil))
-toJSON(obj.head(s == f, div != s))
-toJSON(obj.head(s))
-toJSON(obj.head(s, add, 1))
-toJSON(obj.head(true, "b"))
-toJSON(obj.head(true, div))
-toJSON(obj.obj)
-toJSON(obj.obj.b)
-toJSON(obj.obj.obj)
-toJSON(obj.obj?.a)
-toJSON(obj.obj?.obj)
-toJSON(obj?.a)
-toJSON(obj?.b)
-toJSON(obj?.c)
-toJSON(obj?.fn(a))
-toJSON(obj?.fn(b))
-toJSON(obj?.head("a", 0, 0.5, "a"))
-toJSON(obj?.head("a", div))
-toJSON(obj?.head("c"))
-toJSON(obj?.head(-a))
-toJSON(obj?.head(0))
-toJSON(obj?.head(0, true))
-toJSON(obj?.head(1))
-toJSON(obj?.head(1, s, 1))
-toJSON(obj?.head(a))
-toJSON(obj?.head(a, 0, arr))
-toJSON(obj?.head(arr, nil, s, arr, "b"))
-toJSON(obj?.head(f))
-toJSON(obj?.head(f, b))
-toJSON(obj?.head(false))
-toJSON(obj?.head(nil))
-toJSON(obj?.head(ok, add, arr, ok))
-toJSON(obj?.obj)
-toJSON(obj?.obj[s])
-toJSON(obj[nil])
-toJSON(obj[s])
+toJSON(ok != false)
 toJSON(ok != nil)
-toJSON(ok != obj?.obj)
 toJSON(ok != ok)
-toJSON(ok != true)
-toJSON(ok && false)
-toJSON(ok == false)
+toJSON(ok && true)
 toJSON(ok == nil)
-toJSON(ok ? "b" : "c")
-toJSON(ok ? "b" : ok)
-toJSON(ok ? "c" : 0)
-toJSON(ok ? 0.5 : s)
-toJSON(ok ? 1 : a)
-toJSON(ok ? a : add)
-toJSON(ok ? a : arr)
-toJSON(ok ? arr : arr)
-toJSON(ok ? b : b)
-toJSON(ok ? f : div)
-toJSON(ok ? f : obj)
-toJSON(ok ? nil : div)
-toJSON(ok ? nil : true)
-toJSON(ok ? ok : b)
-toJSON(ok ? s : obj)
-toJSON(ok and ok)
-toJSON(ok || obj?.b)
-toJSON(ok || true)
+toJSON(ok == ok)
+toJSON(ok ? 1 : half)
+toJSON(ok ? f32 : div)
+toJSON(ok ? false : i32)
+toJSON(ok ? nil : f32)
+toJSON(ok or true)
+toJSON(ok || ok)
 toJSON(ok)
-toJSON(ok) == obj?.a
-toJSON(ok) >= s
-toJSON(ok) >= toJSON(b)
-toJSON(one(arr, true))
-toJSON(repeat(s, 2))
-toJSON(s != "a")
-toJSON(s != nil)
-toJSON(s + "b")
-toJSON(s < "b")
-toJSON(s <= s)
-toJSON(s == "b")
-toJSON(s == nil)
-toJSON(s == s)
-toJSON(s > "a")
-toJSON(s > s)
-toJSON(s >= s)
-toJSON(s contains s)
-toJSON(s matches "b")
-toJSON(s matches s)
-toJSON(s startsWith "a")
-toJSON(s startsWith "c")
-toJSON(s startsWith s)
-toJSON(s)
-toJSON(s) in obj
-toJSON(s[0:0])
-toJSON(string("a"))
-toJSON(string("c"))
+toJSON(one(array, i32 < #))
+toJSON(score != div)
+toJSON(score != greet)
+toJSON(score != nil)
+toJSON(score != score)
+toJSON(score == add)
+toJSON(score == div)
+toJSON(score == nil)
+toJSON(score(1))
+toJSON(score(i))
+toJSON(score(i, i))
+toJSON(string("bar"))
+toJSON(string("foo"))
 toJSON(string(0.5))
-toJSON(string(add))
-toJSON(string(arr))
+toJSON(string(1))
+toJSON(string(array))
 toJSON(string(div))
+toJSON(string(f32))
+toJSON(string(f64))
 toJSON(string(false))
-toJSON(string(obj))
+toJSON(string(foo))
+toJSON(string(greet))
+toJSON(string(half))
+toJSON(string(i))
+toJSON(string(i32))
+toJSON(string(i64))
+toJSON(string(list))
+toJSON(string(nil))
 toJSON(string(ok))
-toJSON(string(true))
-toJSON(toBase64(s))
-toJSON(toJSON(0))
-toJSON(toJSON(2))
-toJSON(toJSON(a))
-toJSON(toJSON(arr))
-toJSON(toJSON(b))
-toJSON(toJSON(f))
+toJSON(string(score))
+toJSON(toBase64("bar"))
+toJSON(toBase64("foo"))
+toJSON(toJSON("bar"))
+toJSON(toJSON("foo"))
+toJSON(toJSON(1))
+toJSON(toJSON(array))
+toJSON(toJSON(f32))
+toJSON(toJSON(f64))
+toJSON(toJSON(false))
+toJSON(toJSON(foo))
+toJSON(toJSON(i))
+toJSON(toJSON(i32))
+toJSON(toJSON(i64))
+toJSON(toJSON(list))
 toJSON(toJSON(nil))
 toJSON(toJSON(ok))
-toJSON(toJSON(s))
-toJSON(trimPrefix("a"))
-toJSON(trimPrefix(s))
-toJSON(trimSuffix("b"))
-toJSON(trimSuffix("c"))
-toJSON(true != false)
-toJSON(true != ok)
-toJSON(true && ok)
+toJSON(toJSON(true))
+toJSON(trim("bar"))
+toJSON(trim("foo"))
+toJSON(trimPrefix("foo"))
+toJSON(trimSuffix("foo"))
 toJSON(true && true)
-toJSON(true ? arr : arr)
-toJSON(true ? b : add)
-toJSON(true ? false : s)
-toJSON(true ? ok : obj)
-toJSON(true ? ok : s)
-toJSON(true and false)
-toJSON(true and obj.obj)
+toJSON(true ? array : nil)
+toJSON(true ? i32 : div)
+toJSON(true ? list : true)
+toJSON(true ? nil : array)
+toJSON(true ? ok : list)
+toJSON(true ? true : f64)
 toJSON(true and ok)
-toJSON(true || ok)
-toJSON(true) + upper("a")
-toJSON(true) > obj?.head("a")
-toJSON(upper("a"))
-toJSON(upper(s))
-toJSON({"a": true, "b": 2, "c": a})
-trim("a") != s
-trim("b" + "a")
-trim("c" + "c")
-trim(b != b ? s : "b")
-trim(false ? obj : s)
-trim(lower(s))
-trim(obj.head("a"))
-trim(obj.head("a", 0))
-trim(obj.head("c"))
-trim(obj.head("c", obj))
-trim(obj.head("c", ok, 0.5))
-trim(obj.head(s))
-trim(obj.head(s, 1, ok))
-trim(obj.head(s, false, f), s)
-trim(obj?.head("c"))
-trim(obj?.head("c", a, nil, s, "a"))
-trim(obj?.head(s))
-trim(ok ? "a" : false)
-trim(s + s)
-trim(s)
-trim(s) != obj?.head(div, s, nil, add)
-trim(s) in obj?.obj
-trim(s) startsWith string(nil)
-trim(s, s)
-trim(s, toBase64("a"))
-trim(s, toBase64(s))
-trim(s[a:1])
-trim(s[a:b])
-trim(string("a"))
-trim(string(a))
-trim(string(b))
+toJSON(true) in foo
+toJSON(type("bar"))
+toJSON(type("foo"))
+toJSON(type(0.5))
+toJSON(type(1))
+toJSON(type(add))
+toJSON(type(array))
+toJSON(type(f32))
+toJSON(type(f64))
+toJSON(type(false))
+toJSON(type(foo))
+toJSON(type(greet))
+toJSON(type(half))
+toJSON(type(i))
+toJSON(type(i32))
+toJSON(type(i64))
+toJSON(type(list))
+toJSON(type(nil))
+toJSON(type(ok))
+toJSON(type(score))
+toJSON(type(true))
+toJSON(upper("bar"))
+toJSON(upper("foo"))
+toJSON({"bar": 0.5, "bar": array})
+toJSON({"foo": "foo"})
+toJSON({"foo": 0.5})
+toJSON({"foo": nil})
+toJSON({"foo": ok, "bar": 0.5})
+trim("bar") in foo
+trim("foo" + "foo")
+trim(false ? greet : "bar")
+trim(foo.Bar)
+trim(foo.String())
+trim(foo?.Bar)
+trim(foo?.String())
+trim(greet("bar"))
+trim(greet("foo"))
+trim(lower("bar"))
+trim(lower(toJSON(0.5)))
+trim(ok ? "bar" : i32)
+trim(string("foo"))
+trim(string(0.5))
+trim(string(1))
+trim(string(add))
 trim(string(div))
+trim(string(f32))
+trim(string(f64))
 trim(string(false))
+trim(string(foo))
+trim(string(greet))
+trim(string(half))
+trim(string(i))
+trim(string(i32))
+trim(string(i64))
+trim(string(list))
 trim(string(nil))
-trim(string(obj))
 trim(string(ok))
-trim(toBase64("a"))
-trim(toBase64(s))
-trim(toBase64(trim(s)))
-trim(toJSON(0 != a))
-trim(toJSON(0 + 0.5))
-trim(toJSON(b))
+trim(string(score))
+trim(string(true))
+trim(toBase64("bar"))
+trim(toBase64("foo"))
+trim(toJSON("foo"))
+trim(toJSON(0.5))
+trim(toJSON(1))
+trim(toJSON(array))
+trim(toJSON(f32))
+trim(toJSON(f64))
 trim(toJSON(false))
-trim(toJSON(nil != div))
+trim(toJSON(foo))
+trim(toJSON(i))
+trim(toJSON(i32))
+trim(toJSON(i64))
+trim(toJSON(list))
 trim(toJSON(nil))
 trim(toJSON(ok))
-trim(toJSON(s))
 trim(toJSON(true))
-trim(trim(s))
-trim(trim(trimSuffix(s)))
-trim(trimPrefix("b"))
-trim(trimPrefix("c"))
-trim(trimSuffix("a"))
-trim(trimSuffix(s))
-trim(true ? "c" : add)
-trim(upper(s))
-trimPrefix("a" + "b")
-trimPrefix("a") == obj.head(b)
-trimPrefix("b" + "b")
-trimPrefix("c" + s)
-trimPrefix(lower("c"))
-trimPrefix(lower(s))
-trimPrefix(obj.head("b", s))
-trimPrefix(obj.head("c", f))
-trimPrefix(obj.head(s))
-trimPrefix(obj?.head("a", div))
-trimPrefix(obj?.head("c"))
-trimPrefix(obj?.head(s))
-trimPrefix(ok ? "c" : div)
-trimPrefix(ok ? s : obj)
-trimPrefix(s + s)
-trimPrefix(s)
-trimPrefix(s) > s
-trimPrefix(s, s)
-trimPrefix(s[0:2])
-trimPrefix(string("b"))
-trimPrefix(string(a))
-trimPrefix(string(arr))
-trimPrefix(string(b))
-trimPrefix(string(f))
-trimPrefix(string(false))
-trimPrefix(string(obj))
+trim(trim("bar"))
+trim(trimPrefix("bar"))
+trim(trimPrefix("foo"))
+trim(trimPrefix(string(i)))
+trim(trimSuffix("bar"))
+trim(trimSuffix("foo"))
+trim(type("foo"))
+trim(type(0.5))
+trim(type(1))
+trim(type(add))
+trim(type(array))
+trim(type(div))
+trim(type(f32))
+trim(type(f64))
+trim(type(false))
+trim(type(foo))
+trim(type(greet))
+trim(type(half))
+trim(type(i))
+trim(type(i32))
+trim(type(i64))
+trim(type(list))
+trim(type(nil != list))
+trim(type(nil))
+trim(type(ok))
+trim(type(score))
+trim(type(toJSON(1)))
+trim(type(true))
+trim(upper("bar"))
+trimPrefix("foo" + "foo")
+trimPrefix(foo.Bar)
+trimPrefix(foo.String())
+trimPrefix(foo?.Bar)
+trimPrefix(foo?.String())
+trimPrefix(greet("bar"))
+trimPrefix(greet("foo"))
+trimPrefix(greet(foo.String()))
+trimPrefix(lower("bar"))
+trimPrefix(lower("foo"))
+trimPrefix(ok ? "bar" : i64)
+trimPrefix(string("foo"))
+trimPrefix(string(0.5))
+trimPrefix(string(1))
+trimPrefix(string(add))
+trimPrefix(string(array))
+trimPrefix(string(div))
+trimPrefix(string(f32))
+trimPrefix(string(foo))
+trimPrefix(string(greet))
+trimPrefix(string(half))
+trimPrefix(string(i))
+trimPrefix(string(i32))
+trimPrefix(string(i64))
+trimPrefix(string(list))
+trimPrefix(string(nil))
 trimPrefix(string(ok))
-trimPrefix(string(s))
-trimPrefix(toBase64("b"))
-trimPrefix(toBase64(s))
+trimPrefix(string(score))
+trimPrefix(toBase64("bar"))
+trimPrefix(toBase64("foo"))
+trimPrefix(toJSON("bar"))
+trimPrefix(toJSON("foo"))
 trimPrefix(toJSON(0.5))
 trimPrefix(toJSON(1))
-trimPrefix(toJSON(2))
-trimPrefix(toJSON(ok))
-trimPrefix(toJSON(s))
-trimPrefix(trim("b"))
-trimPrefix(trim("c", "a"))
-trimPrefix(trim(s))
-trimPrefix(trimPrefix("b"))
-trimPrefix(trimPrefix(s))
-trimPrefix(trimSuffix("b"))
-trimPrefix(trimSuffix("c"))
-trimPrefix(trimSuffix(s))
-trimSuffix("b" + s)
-trimSuffix("b") contains s
-trimSuffix("c") endsWith s
-trimSuffix(false ? obj : s)
-trimSuffix(lower("b"))
-trimSuffix(obj.head("c", 0.5, arr, obj))
-trimSuffix(obj.head(s, nil, obj))
-trimSuffix(obj.head(toJSON(b, b, s, 0.5, nil)))
-trimSuffix(obj?.head("a"))
-trimSuffix(obj?.head("c"))
-trimSuffix(obj?.head("c", 0.5))
-trimSuffix(obj?.head(s))
-trimSuffix(obj?.head(s, 2, div))
-trimSuffix(obj?.head(s, div, true, b))
-trimSuffix(ok ? s : add)
-trimSuffix(repeat(s, 0))
-trimSuffix(s + "a")
-trimSuffix(s + "b")
-trimSuffix(s + "c")
-trimSuffix(s + s)
-trimSuffix(s)
-trimSuffix(s) == s
-trimSuffix(s) > s
-trimSuffix(s, "b") startsWith s
-trimSuffix(s, s)
-trimSuffix(string("a"))
-trimSuffix(string("b"))
+trimPrefix(toJSON(array))
+trimPrefix(toJSON(f32))
+trimPrefix(toJSON(f64))
+trimPrefix(toJSON(false))
+trimPrefix(toJSON(foo))
+trimPrefix(toJSON(i))
+trimPrefix(toJSON(i32))
+trimPrefix(toJSON(i64))
+trimPrefix(toJSON(nil))
+trimPrefix(toJSON(true))
+trimPrefix(trim("bar"))
+trimPrefix(trim("foo"))
+trimPrefix(trimPrefix("bar"))
+trimPrefix(trimPrefix("foo"))
+trimPrefix(trimSuffix("bar"))
+trimPrefix(trimSuffix("foo"))
+trimPrefix(type("bar"))
+trimPrefix(type(0.5 == 0.5))
+trimPrefix(type(0.5))
+trimPrefix(type(1 == f64))
+trimPrefix(type(1))
+trimPrefix(type(add))
+trimPrefix(type(array))
+trimPrefix(type(div))
+trimPrefix(type(f32))
+trimPrefix(type(f64))
+trimPrefix(type(false))
+trimPrefix(type(foo))
+trimPrefix(type(greet))
+trimPrefix(type(half))
+trimPrefix(type(i))
+trimPrefix(type(i32))
+trimPrefix(type(i64))
+trimPrefix(type(list))
+trimPrefix(type(nil))
+trimPrefix(type(ok))
+trimPrefix(type(score))
+trimPrefix(upper("foo"))
+trimSuffix("bar" + "bar")
+trimSuffix("foo") <= trimPrefix("foo")
+trimSuffix(foo.Bar)
+trimSuffix(foo.String())
+trimSuffix(foo?.Bar)
+trimSuffix(foo?.Qux("bar"))
+trimSuffix(foo?.String())
+trimSuffix(greet("bar"))
+trimSuffix(greet("foo"))
+trimSuffix(greet(toJSON(i64)))
+trimSuffix(lower("bar"))
+trimSuffix(lower("foo"))
+trimSuffix(repeat("foo", i))
+trimSuffix(string("bar"))
 trimSuffix(string(0.5))
-trimSuffix(string(a))
+trimSuffix(string(1))
 trimSuffix(string(add))
-trimSuffix(string(arr))
-trimSuffix(string(b))
+trimSuffix(string(array))
+trimSuffix(string(f32))
+trimSuffix(string(f64))
 trimSuffix(string(false))
+trimSuffix(string(foo))
+trimSuffix(string(greet))
+trimSuffix(string(half))
+trimSuffix(string(i))
+trimSuffix(string(i32))
+trimSuffix(string(i64))
+trimSuffix(string(list))
 trimSuffix(string(nil))
-trimSuffix(toJSON("a"))
-trimSuffix(toJSON("b"))
-trimSuffix(toJSON(a))
-trimSuffix(toJSON(arr))
-trimSuffix(toJSON(b))
-trimSuffix(toJSON(f))
+trimSuffix(string(score))
+trimSuffix(string(type("foo")))
+trimSuffix(toBase64("bar"))
+trimSuffix(toJSON("bar"))
+trimSuffix(toJSON(0.5))
+trimSuffix(toJSON(1))
+trimSuffix(toJSON(array))
+trimSuffix(toJSON(f64))
+trimSuffix(toJSON(false))
+trimSuffix(toJSON(first(array)))
+trimSuffix(toJSON(foo))
+trimSuffix(toJSON(i))
+trimSuffix(toJSON(i32))
+trimSuffix(toJSON(i64))
+trimSuffix(toJSON(list))
 trimSuffix(toJSON(nil))
-trimSuffix(toJSON(obj?.head("b", add)))
-trimSuffix(toJSON(obj?.obj))
 trimSuffix(toJSON(ok))
-trimSuffix(toJSON(toJSON(s)))
-trimSuffix(toJSON(true))
-trimSuffix(trim("c"))
-trimSuffix(trim(s))
-trimSuffix(trimPrefix("a"))
-trimSuffix(trimPrefix("b"))
-trimSuffix(trimPrefix(s))
-trimSuffix(trimSuffix("b"))
-trimSuffix(trimSuffix("c"))
-trimSuffix(trimSuffix(s))
-trimSuffix(true ? s : a)
-trimSuffix(upper("b"))
-trimSuffix(upper(s))
-true != false && a != a
-true != false == obj.a
-true != nil or ok && ok
-true != obj.a
-true != obj.b
-true != obj.head(a % a)
-true != obj.obj
-true != obj.obj.a
-true != obj?.a
-true != obj?.b
-true != obj?.obj
-true != ok and arr != nil
-true != true || obj?.obj
-true && false or false ? f : add
-true && obj.a
-true && obj.b
-true && obj.obj
-true && obj.obj?.obj
-true && obj?.a
-true && obj?.b
-true && obj?.head(add)
-true && obj?.head(s)
-true && obj?.obj
-true && obj?.obj?.obj
-true && ok ? arr : b
-true && ok or ok
-true && true || ok
-true == nil != obj?.head(obj)
-true == nil in obj?.head(arr, div, obj)
-true == obj.a
-true == obj.b
-true == obj.head(ok ? one("b", ok) : arr)
-true == obj.obj
-true == obj.obj?.b
-true == obj?.a
-true == obj?.b
-true == obj?.head(b)
-true == obj?.obj
-true == ok != ok
-true == ok == obj.head(add)
-true == ok or obj.b
-true ? "a" : f > f
-true ? "b" : obj.obj
-true ? "b" : obj?.a
-true ? "b" : obj?.b
-true ? "c" : nil == ok
-true ? "c" : obj?.b
-true ? 0 : arr != nil != ok
-true ? 0 : obj?.b
-true ? 0 : obj?.obj
-true ? 0.5 : obj.a
-true ? 0.5 : obj.b
-true ? 0.5 : obj?.a
-true ? 1 : obj.head(s or obj)
-true ? 1 : obj?.head(s[obj])
-true ? 2 : obj.fn(b?.fn(div))
-true ? 2 : obj.fn(div(obj), keys(2), a?.a, ok * div)
-true ? 2 : obj.head(filter(arr, any(arr, div)))
-true ? 2 : obj.obj
-true ? 2 : obj?.fn(ok, b startsWith obj)
-true ? 2 : obj?.obj
-true ? a : b + f
-true ? a : obj.b
-true ? a : obj.fn(abs(true).a)
-true ? a : obj.obj
-true ? a : obj?.a
-true ? a : obj?.b
-true ? a : obj?.fn(f.a)
-true ? a : obj?.obj
-true ? add : obj.b
-true ? add : obj.fn(all(div(b), div(add)))
-true ? add : obj.obj
-true ? add : obj?.head(add(f, b))
-true ? arr : "c" + s
-true ? arr : a == obj.a
-true ? arr : nil == f
-true ? arr : obj.a
-true ? arr : obj.b
-true ? arr : obj.fn(arr?.head(f.fn(false)))
-true ? arr : obj.fn(s matches s)
-true ? arr : obj.head(keys(s >= obj, 1 .. true, any("a", a)), add(div.fn(add, 0.5, nil), a, add(f, false), a.a, -f)).b
-true ? arr : obj.obj
-true ? arr : obj?.a
-true ? b : 0 / b
-true ? b : 2 * obj.a
-true ? b : a >= b
-true ? b : div == div
-true ? b : nil != b
-true ? b : obj.a
-true ? b : obj.fn(a > obj)
-true ? b : obj.head(1 matches f.b, div(count(s, div), f < obj, obj?.obj, div(f)))
-true ? b : obj.obj
-true ? b : obj.obj?.obj
-true ? b : obj?.a
-true ? b : obj?.a.obj
-true ? b : obj?.b
-true ? div : obj.b
-true ? div : obj?.a
-true ? div : obj?.obj
-true ? f : 2 + a
-true ? f : arr[b]
-true ? f : f != obj.a
-true ? f : f < a ** 2
-true ? f : obj.head(add(f.b, ok, a?.head(s, 0, f, true)))
-true ? f : obj.head(none(b, "b"), a.a)
-true ? f : obj.obj
-true ? f : obj?.a?.obj
-true ? f : obj?.b
-true ? f : obj?.obj
-true ? f : obj?.obj.fn(div(obj)?.obj .. none(ok, s).obj)
-true ? f : obj?.obj?.obj
-true ? false : obj.a
-true ? false : obj.fn(none(obj, arr) startsWith b?.fn(f))
-true ? false : obj.head(div(any(0, b)))
-true ? false : obj?.head(add and div)
-true ? false : obj?.head(b)
-true ? nil : 0 % b
-true ? nil : a - f
-true ? nil : a <= obj.head(nil, "a", ok, nil)
-true ? nil : nil != b
-true ? nil : obj.head(all(add(add), f and 0.5))
-true ? nil : obj.obj
-true ? nil : obj.obj?.a
-true ? nil : obj?.b
-true ? nil : obj?.head(obj.obj < a.fn(false))
-true ? nil : obj?.obj
-true ? obj : f * f
-true ? obj : f + b - 1
-true ? obj : obj.a
-true ? obj : obj.b
-true ? obj : obj.fn(none(a, div or arr)).obj
-true ? obj : obj.fn(s.head(arr), ok > ok)
-true ? obj : obj.head(ok, map(arr, !ok))?.a?.a
-true ? obj : obj.head(values(s?.b), -b <= (ok and add))
-true ? obj : obj?.a
-true ? ok : b in obj.b
-true ? ok : obj.b
-true ? ok : obj.obj.obj
-true ? ok : obj?.b.b
-true ? ok : obj?.fn(not 0)
-true ? ok : obj?.obj
-true ? s : "a" matches s
-true ? s : arr in obj?.head(b)
-true ? s : f ^ (0.5 / b)
-true ? s : obj.a
-true ? s : obj.b
-true ? s : obj.head(div(add?.head(arr, f, 0.5)))
-true ? s : obj.obj
-true ? s : obj?.a
-true ? s : obj?.head(obj.a, div)
-true ? true : nil == obj.obj
-true ? true : obj.obj
-true ? true : ok && ok
-true and false ? b : obj
-true and obj.a
-true and obj.b
-true and obj.head(obj.obj)
-true and obj.obj
-true and obj?.a
-true and obj?.a >= b
-true and obj?.b
-true and obj?.obj
-true and obj?.obj == ok
-true and obj?.obj.obj
-true and ok and obj?.head(div)
-true or obj.a
-true or obj.a.a
-true or obj.a.obj
-true or obj.b
-true or obj.fn(a?.obj, b?.b, ok)
-true or obj.fn(b, add(add)?.obj).a
-true or obj.fn(div?.fn(add), ok?.head(div, b))
-true or obj.fn(join(b))
-true or obj.fn(s != add)
-true or obj.head(add?.a, false > div)
-true or obj.head(any(f, ok))
-true or obj.head(div(arr != b, add(add), 2 != arr, div || ok), b[b] >= ok > s, fromJSON(get(obj)))
-true or obj.head(duration(f.a))
-true or obj.head(filter(div, a) endsWith div.fn(obj, s, obj, b), arr.obj.obj, not b or a ? ok : true)
-true or obj.head(join(1))
-true or obj.head(none(ok?.b, count(0, 0.5)))
-true or obj.obj
-true or obj.obj.a?.obj
-true or obj.obj?.head(map(0.5, f) matches one(obj, "c"))
-true or obj?.a
-true or obj?.a.fn(ok + b?.fn(obj))
-true or obj?.a.head("c" * b matches not div)
-true or obj?.a?.a
-true or obj?.b
-true or obj?.fn(arr.b && obj?.head(b), ok.fn(obj .. arr))
-true or obj?.fn(div(b, arr) and obj?.b, obj[add(b)])
-true or obj?.fn(f, f).a
-true or obj?.fn(hasPrefix(add(ok)))
-true or obj?.fn(map(not ok, "b" < add), map("b" && a, one(0, add)))
-true or obj?.head(add(f))
-true or obj?.head(one(none(add, add), add?.b))
-true or obj?.obj
-true or obj?.obj.head(get(add(s), div))
-true or ok || obj.a
-true || obj.a
-true || obj.a.a
-true || obj.b
-true || obj.fn((add || div) - b)
-true || obj.fn(arr, any(add(arr, ok, div), 0 startsWith false))
-true || obj.head(a?.fn(arr contains b, div?.head(0, add, false), obj.head(0.5), values(f), s.b))?.a
-true || obj.head(add(abs(b)))
-true || obj.head(add(ok.obj), any(add, f) != obj.head(b, add, arr))
-true || obj.head(all(f, 0), div("a", true))
-true || obj.head(count("a", obj))
-true || obj.head(f.b)
-true || obj.head(f?.fn(0) <= b.b)
-true || obj.head(filter(add.head(s), map(s, 0.5)))
-true || obj.head(obj.b)
-true || obj.head(obj?.fn(b))
-true || obj.obj
-true || obj.obj == add
-true || obj.obj.a
-true || obj.obj?.b
-true || obj.obj?.obj
-true || obj?.a
-true || obj?.b
-true || obj?.fn(a?.head(div(div)), 2 .. add?.b)
-true || obj?.fn(div * a == ok?.b)
-true || obj?.fn(div(0.5 && 0.5, s?.head(0.5))).a
-true || obj?.fn(get(a, arr))
-true || obj?.head(all(f.b, #))
-true || obj?.head(div(nil, "b"), add(nil, f))
-true || obj?.head(repeat(now(true, div, b, ok)), now(s, div(add, "c"))).a
-true || obj?.head(true == nil)
-true || obj?.obj
-true || true or obj.obj
-upper("a" + "a")
-upper("a") startsWith s
-upper("b") < s
-upper("b") <= s
-upper("c") <= s
-upper(f >= 2 ? b : s)
-upper(false ? 0.5 : s)
-upper(lower(s))
-upper(obj.head(s))
-upper(obj.head(s, arr, obj))
-upper(obj.head(s, ok))
-upper(obj?.head("a"))
-upper(obj?.head("b"))
-upper(obj?.head(s))
-upper(obj?.head(s, f))
-upper(ok ? s : ok)
-upper(s + s)
-upper(s)
-upper(s) <= s
-upper(s) matches s
-upper(string("a"))
-upper(string("b"))
-upper(string(0))
+trimSuffix(trim("bar"))
+trimSuffix(trim("foo"))
+trimSuffix(trimPrefix("bar"))
+trimSuffix(trimPrefix("foo"))
+trimSuffix(trimSuffix("foo"))
+trimSuffix(type("bar"))
+trimSuffix(type("foo"))
+trimSuffix(type(0.5))
+trimSuffix(type(1))
+trimSuffix(type(add))
+trimSuffix(type(array))
+trimSuffix(type(div))
+trimSuffix(type(f32))
+trimSuffix(type(f64))
+trimSuffix(type(false))
+trimSuffix(type(foo))
+trimSuffix(type(half))
+trimSuffix(type(i))
+trimSuffix(type(i32))
+trimSuffix(type(i64))
+trimSuffix(type(list))
+trimSuffix(type(nil))
+trimSuffix(type(ok))
+trimSuffix(type(true))
+trimSuffix(upper("bar"))
+trimSuffix(upper("foo"))
+true != nil || true != nil
+true == nil && ok
+true ? "bar" : 0.5 ^ i
+true ? "bar" : 1 <= 1 / 1
+true ? "bar" : i != i32
+true ? "foo" : foo?.Bar
+true ? 0.5 : foo.Qux
+true ? 1 : f64 + f32
+true ? 1 : nil == array
+true ? array : foo.Qux
+true ? array : foo.String
+true ? array : i32 / i32
+true ? array : nil != map(list, #)
+true ? array : nil != ok
+true ? f32 : f64 == i32
+true ? f64 : foo?.String
+true ? greet : 0.5 == i
+true ? i : 0.5 + i64
+true ? i : 0.5 >= i64
+true ? i32 : foo.Bar
+true ? i64 : foo.Bar
+true ? list : f64 / f64
+true ? nil : 0.5 != i32
+true ? nil : foo.Qux
+true ? nil : foo.String
+true ? nil : i32 .. i
+true ? nil : i64 ** -i
+true ? ok : f32 / f32
+true ? ok : f64 + f64
+true ? score : foo.Qux
+true ? true : f32 >= i64
+true ? true : foo?.String
+true and ok and ok
+true || 1 not in array
+type(!false)
+type(!ok)
+type(!true)
+type("bar" != nil)
+type("bar" + "foo")
+type("bar" < "bar")
+type("bar" <= "bar")
+type("bar" <= "foo")
+type("bar" == nil)
+type("bar" > "foo")
+type("bar" endsWith "foo")
+type("bar" matches "bar")
+type("bar" matches "foo")
+type("bar" not contains "bar")
+type("bar" not endsWith "bar")
+type("bar" not endsWith "foo")
+type("bar" startsWith "foo")
+type("bar") == string(array)
+type("foo" != "bar")
+type("foo" == "foo")
+type("foo" > "bar")
+type("foo" contains "foo")
+type("foo" endsWith "foo")
+type("foo" in foo)
+type("foo" not endsWith "bar")
+type("foo" not endsWith "foo")
+type("foo" startsWith "foo")
+type("foo" startsWith foo.Bar)
+type(-0.5)
+type(-1)
+type(-f32)
+type(-f64)
+type(-i)
+type(-i32)
+type(-i64)
+type(0.5 != 0.5)
+type(0.5 != 1)
+type(0.5 != i)
+type(0.5 != i32)
+type(0.5 != nil)
+type(0.5 * 0.5)
+type(0.5 * 1)
+type(0.5 * i)
+type(0.5 * i32)
+type(0.5 * i64)
+type(0.5 ** 0.5)
+type(0.5 ** 1)
+type(0.5 ** f32)
+type(0.5 ** i)
+type(0.5 ** i32)
+type(0.5 ** i64)
+type(0.5 + f32)
+type(0.5 + i32)
+type(0.5 + i64)
+type(0.5 - 0.5)
+type(0.5 - i)
+type(0.5 / 0.5)
+type(0.5 / 1)
+type(0.5 / f64)
+type(0.5 / i)
+type(0.5 < 1)
+type(0.5 < f64)
+type(0.5 < i)
+type(0.5 < i64)
+type(0.5 <= 1)
+type(0.5 <= f32)
+type(0.5 <= i)
+type(0.5 <= i64)
+type(0.5 == 1)
+type(0.5 == i)
+type(0.5 == nil)
+type(0.5 > 0.5)
+type(0.5 > 1)
+type(0.5 > f64)
+type(0.5 > i)
+type(0.5 >= 0.5)
+type(0.5 >= 1)
+type(0.5 >= f64)
+type(0.5 >= i)
+type(0.5 >= i32)
+type(0.5 ^ 0.5)
+type(0.5 ^ 1)
+type(0.5 ^ f32)
+type(0.5 ^ f64)
+type(0.5 ^ i)
+type(0.5) not contains trimPrefix("bar")
+type(0.5) not in foo
+type(0.5) startsWith "bar" == nil
+type(0.5)[i32:i64]
+type(1 != 0.5)
+type(1 != 1)
+type(1 != f32)
+type(1 != i32)
+type(1 != nil)
+type(1 % 1)
+type(1 % i)
+type(1 % i32)
+type(1 % i64)
+type(1 * 1)
+type(1 * f32)
+type(1 * i)
+type(1 * i64)
+type(1 ** 0.5)
+type(1 ** 1)
+type(1 ** f64)
+type(1 ** i32)
+type(1 ** i64)
+type(1 + 0.5)
+type(1 + f32)
+type(1 + f64)
+type(1 + i64)
+type(1 - 0.5)
+type(1 - 1)
+type(1 - f64)
+type(1 - i32)
+type(1 .. 1)
+type(1 .. i)
+type(1 .. i64)
+type(1 / 1)
+type(1 / f32)
+type(1 / f64)
+type(1 < 1)
+type(1 < f32)
+type(1 < i)
+type(1 <= f32)
+type(1 <= f64)
+type(1 <= i32)
+type(1 <= i64)
+type(1 == 1)
+type(1 == i)
+type(1 == i64)
+type(1 == nil)
+type(1 > 0.5)
+type(1 > 1)
+type(1 > f32)
+type(1 > f64)
+type(1 >= 0.5)
+type(1 >= 1)
+type(1 >= f64)
+type(1 >= i)
+type(1 >= i32)
+type(1 >= i64)
+type(1 ^ 0.5)
+type(1 ^ f32)
+type(1 ^ i64)
+type(1 in array)
+type(1 not in array)
+type(1) != toJSON(0.5)
+type(1) == nil ? 1 : f64
+type(1) endsWith greet("foo")
+type(1) in foo
+type(1) in foo != true
+type(1) not contains type(nil)
+type(1) not endsWith toJSON(ok)
+type([half, 1])
+type([nil])
+type(abs(0.5))
+type(abs(1))
+type(abs(f64))
+type(abs(i))
+type(abs(i32))
+type(abs(i64))
+type(add != add)
+type(add != greet)
+type(add != half)
+type(add == half)
+type(add == nil)
+type(add(1, 1))
+type(add)
+type(add) in foo
+type(all(array, true))
+type(all(list, false))
+type(any(array, false))
+type(any(list, true))
+type(array == array)
+type(array == list)
+type(array)
+type(array) in foo
+type(array) not in foo
+type(array[1])
+type(array[i32])
+type(array[i])
+type(count(list, ok))
+type(count(list, true))
+type(div != div)
+type(div != half)
+type(div != nil)
+type(div == add)
+type(div == greet)
+type(div == half)
+type(div)
+type(div) not in foo
+type(f32 != 0.5)
+type(f32 != 1)
+type(f32 != f32)
+type(f32 != i32)
+type(f32 * 0.5)
+type(f32 * 1)
+type(f32 * f32)
+type(f32 * f64)
+type(f32 * i)
+type(f32 * i64)
+type(f32 ** 0.5)
+type(f32 ** 1)
+type(f32 ** f32)
+type(f32 ** i)
+type(f32 ** i32)
+type(f32 + 0.5)
+type(f32 + 1)
+type(f32 + f64)
+type(f32 + i)
+type(f32 + i64)
+type(f32 - 0.5)
+type(f32 - 1)
+type(f32 - f32)
+type(f32 - i)
+type(f32 - i32)
+type(f32 - i64)
+type(f32 < 1)
+type(f32 < f64)
+type(f32 < i32)
+type(f32 <= 0.5)
+type(f32 <= 1)
+type(f32 <= i64)
+type(f32 == 0.5)
+type(f32 == 1)
+type(f32 == i32)
+type(f32 > 1)
+type(f32 > f32)
+type(f32 > f64)
+type(f32 >= 0.5)
+type(f32 ^ 0.5)
+type(f32 ^ f32)
+type(f32 ^ f64)
+type(f32 ^ i32)
+type(f32 ^ i64)
+type(f32)
+type(f64 != f64)
+type(f64 != i64)
+type(f64 * 0.5)
+type(f64 * 1)
+type(f64 * i32)
+type(f64 * i64)
+type(f64 ** 0.5)
+type(f64 ** 1)
+type(f64 ** f32)
+type(f64 ** i)
+type(f64 ** i32)
+type(f64 + 0.5)
+type(f64 + f64)
+type(f64 + i)
+type(f64 - 0.5)
+type(f64 - f32)
+type(f64 - f64)
+type(f64 - i)
+type(f64 / 1)
+type(f64 / i)
+type(f64 < 0.5)
+type(f64 < 1)
+type(f64 < f64)
+type(f64 < i64)
+type(f64 <= 0.5)
+type(f64 <= i)
+type(f64 <= i32)
+type(f64 == 1)
+type(f64 == f64)
+type(f64 == nil)
+type(f64 > 1)
+type(f64 > f64)
+type(f64 > i)
+type(f64 > i32)
+type(f64 >= 0.5)
+type(f64 >= 1)
+type(f64 ^ 1)
+type(f64 ^ f64)
+type(f64 ^ i)
+type(f64 ^ i32)
+type(f64 ^ i64)
+type(f64)
+type(false != nil)
+type(false && true)
+type(false == ok)
+type(false ? add : div)
+type(false ? half : i)
+type(false ? half : i32)
+type(false ? i32 : 1)
+type(false ? i32 : true)
+type(false ? list : "foo")
+type(false || ok)
+type(false) not contains toJSON(i)
+type(filter(array, true))
+type(filter(list, false))
+type(find([f64], "foo" == nil))
+type(find(array, false))
+type(find(list, false))
+type(findIndex(array, false))
+type(findIndex(list, ok))
+type(findIndex(list, true))
+type(findLast(array, false))
+type(findLast(array, ok))
+type(findLast(list, false))
+type(findLastIndex(array, ok))
+type(findLastIndex(array, true))
+type(findLastIndex(list, ok))
+type(first(array))
+type(first(list))
+type(float(0.5))
+type(float(1))
+type(float(f32))
+type(float(f64))
+type(float(i))
+type(float(i32))
+type(float(i64))
+type(foo != foo)
+type(foo in list)
+type(foo)
+type(foo) in foo
+type(foo.Bar)
+type(foo.Qux)
+type(foo.String())
+type(foo.String)
+type(foo?.Bar)
+type(foo?.Qux)
+type(foo?.String())
+type(foo?.String)
+type(get(array, 1))
+type(get(array, i))
+type(get(array, i32))
+type(get(list, 1))
+type(get(list, i32))
+type(greet != div)
+type(greet != half)
+type(greet != score)
+type(greet == div)
+type(greet == greet)
+type(greet == half)
+type(greet("bar"))
+type(greet("foo"))
+type(greet(lower("foo")))
+type(greet)
+type(greet) not in foo
+type(half != add)
+type(half != nil)
+type(half == add)
+type(half == div)
+type(half(0.5))
+type(half(f64))
+type(half)
+type(half) endsWith toJSON(1)
+type(i != 0.5)
+type(i != 1)
+type(i != f32)
+type(i != i64)
+type(i % 1)
+type(i * 0.5)
+type(i * i64)
+type(i ** 0.5)
+type(i ** 1)
+type(i ** f32)
+type(i ** f64)
+type(i ** i)
+type(i ** i32)
+type(i + 1)
+type(i + i)
+type(i + i32)
+type(i .. i64)
+type(i / 0.5)
+type(i / 1)
+type(i < f32)
+type(i < i64)
+type(i == f32)
+type(i == i32)
+type(i == i64)
+type(i > f64)
+type(i >= 1)
+type(i >= f32)
+type(i >= f64)
+type(i ^ 0.5)
+type(i ^ 1)
+type(i ^ f32)
+type(i ^ f64)
+type(i ^ i64)
+type(i not in array)
+type(i)
+type(i) not endsWith greet("foo")
+type(i32 != 0.5)
+type(i32 != 1)
+type(i32 != nil)
+type(i32 % 1)
+type(i32 % i64)
+type(i32 * 0.5)
+type(i32 * 1)
+type(i32 * i32)
+type(i32 * i64)
+type(i32 ** f32)
+type(i32 ** f64)
+type(i32 ** i)
+type(i32 + 1)
+type(i32 + f32)
+type(i32 + f64)
+type(i32 + i)
+type(i32 + i32)
+type(i32 + i64)
+type(i32 - f32)
+type(i32 - i32)
+type(i32 .. 1)
+type(i32 .. i)
+type(i32 / f64)
+type(i32 / i32)
+type(i32 < 1)
+type(i32 < f32)
+type(i32 < i)
+type(i32 < i64)
+type(i32 <= f64)
+type(i32 <= i32)
+type(i32 <= i64)
+type(i32 == 0.5)
+type(i32 == 1)
+type(i32 == f32)
+type(i32 == f64)
+type(i32 == i)
+type(i32 == i64)
+type(i32 > 0.5)
+type(i32 > 1)
+type(i32 > f64)
+type(i32 > i32)
+type(i32 >= 1)
+type(i32 >= f32)
+type(i32 >= i)
+type(i32 >= i32)
+type(i32 ^ 0.5)
+type(i32 ^ i)
+type(i32 ^ i32)
+type(i32 ^ i64)
+type(i32 in array)
+type(i32)
+type(i32) startsWith greet("foo")
+type(i64 != 1)
+type(i64 != array[i32])
+type(i64 != f32)
+type(i64 != i)
+type(i64 != nil)
+type(i64 % i)
+type(i64 % i64)
+type(i64 * 0.5)
+type(i64 * f32)
+type(i64 * f64)
+type(i64 * i64)
+type(i64 ** 1)
+type(i64 + 0.5)
+type(i64 + f64)
+type(i64 + i)
+type(i64 + i64)
+type(i64 - 0.5)
+type(i64 .. 1)
+type(i64 .. i32)
+type(i64 .. i64)
+type(i64 / 0.5)
+type(i64 / 1)
+type(i64 / i)
+type(i64 / i64)
+type(i64 < 1)
+type(i64 < f64)
+type(i64 < i)
+type(i64 < i64)
+type(i64 <= 1)
+type(i64 <= f32)
+type(i64 <= i64)
+type(i64 == i32)
+type(i64 == nil)
+type(i64 > f64)
+type(i64 >= 0.5)
+type(i64 >= f32)
+type(i64 >= i)
+type(i64 >= i64)
+type(i64 ^ 0.5)
+type(i64 ^ 1)
+type(i64 ^ f32)
+type(i64 ^ f64)
+type(i64 ^ i)
+type(i64 ^ i32)
+type(i64 in array)
+type(i64 not in array)
+type(i64)
+type(i64) != foo?.Bar
+type(i64) contains string(foo) ? i : array
+type(i64) not in foo
+type(i64) not startsWith lower("foo")
+type(int(0.5))
+type(int(1))
+type(int(f32))
+type(int(f64))
+type(int(i))
+type(int(i32))
+type(int(i64) <= f32)
+type(int(i64))
+type(last(array))
+type(last(list))
+type(len("bar"))
+type(len("foo"))
+type(len(array))
+type(len(list))
+type(list == array)
+type(list == nil)
+type(list)
+type(list[1])
+type(list[i32])
+type(list[i64])
+type(list[i])
+type(lower("bar"))
+type(lower("foo"))
+type(lower(string(nil)))
+type(map(array, "foo"))
+type(map(array, #))
+type(map(array, 0.5))
+type(map(array, add))
+type(map(array, array))
+type(map(array, false))
+type(map(array, foo))
+type(map(array, half))
+type(map(array, i))
+type(map(array, i64))
+type(map(array, ok))
+type(map(i .. i32, i64))
+type(map(list, #))
+type(map(list, 0.5))
+type(map(list, 1))
+type(map(list, array))
+type(map(list, f32))
+type(map(list, f64))
+type(map(list, foo))
+type(map(list, greet))
+type(map(list, i))
+type(map(list, list))
+type(map(list, ok))
+type(max(0.5))
+type(max(1))
+type(max(f32))
+type(max(f32, i32))
+type(max(f64))
+type(max(f64, 0.5))
+type(max(i))
+type(max(i32))
+type(max(i32, i64))
+type(max(i64))
+type(min(0.5))
+type(min(1))
+type(min(1, 0.5))
+type(min(1, 1, f32))
+type(min(f32))
+type(min(f64))
+type(min(i))
+type(min(i, 1))
+type(min(i32))
+type(min(i32, 0.5))
+type(min(i64))
+type(nil != "bar")
+type(nil != 0.5)
+type(nil != 1)
+type(nil != div)
+type(nil != f64)
+type(nil != false)
+type(nil != foo)
+type(nil != greet)
+type(nil != i32)
+type(nil != nil)
+type(nil != ok)
+type(nil == "bar")
+type(nil == "foo")
+type(nil == 0.5)
+type(nil == 1)
+type(nil == add)
+type(nil == array)
+type(nil == f32)
+type(nil == f64)
+type(nil == i)
+type(nil == i32)
+type(nil == nil)
+type(nil == ok)
+type(nil == score)
+type(nil == true)
+type(nil in array)
+type(nil not in array)
+type(nil) != type(1)
+type(none(array, ok))
+type(none(array, true))
+type(none(list, ok))
+type(none(list, true))
+type(not false)
+type(not ok)
+type(not true)
+type(ok != nil)
+type(ok == false)
+type(ok ? 0.5 : i32)
+type(ok ? 0.5 : list)
+type(ok ? 1 : f32)
+type(ok ? add : "bar")
+type(ok ? false : i64)
+type(ok ? foo : false)
+type(ok ? half : half)
+type(ok ? i32 : f64)
+type(ok ? i64 : "bar")
+type(ok ? list : "foo")
+type(ok ? ok : half)
+type(ok ? true : false)
+type(ok and ok)
+type(ok and true)
+type(ok or false)
+type(ok or true)
+type(ok || true)
+type(ok)
+type(ok) in foo
+type(ok) not matches string(i64)
+type(ok) not startsWith lower("bar")
+type(score != div)
+type(score != greet)
+type(score != half)
+type(score != nil)
+type(score == add)
+type(score == foo.String)
+type(score == greet)
+type(score == half)
+type(score == nil)
+type(score == score)
+type(score(1))
+type(score(i))
+type(score(i, 1))
+type(score)
+type(score) < foo?.Bar
+type(score) > string(score)
+type(score) in foo
+type(score) not contains type(1)
+type(sort(array))
+type(string("bar"))
+type(string("foo"))
+type(string(0.5))
+type(string(1))
+type(string(add))
+type(string(array))
+type(string(div))
+type(string(f64))
+type(string(false))
+type(string(foo))
+type(string(greet))
+type(string(half))
+type(string(i <= i32))
+type(string(i))
+type(string(i64))
+type(string(list))
+type(string(nil))
+type(string(ok))
+type(string(score))
+type(toBase64("foo"))
+type(toJSON("bar"))
+type(toJSON("foo"))
+type(toJSON(0.5 < i))
+type(toJSON(0.5))
+type(toJSON(1))
+type(toJSON(array))
+type(toJSON(f32))
+type(toJSON(f64))
+type(toJSON(false))
+type(toJSON(foo))
+type(toJSON(i32))
+type(toJSON(i64))
+type(toJSON(list))
+type(toJSON(nil))
+type(toJSON(ok))
+type(toJSON(true))
+type(trim("bar"))
+type(trim("foo"))
+type(trimPrefix("foo"))
+type(trimPrefix(toJSON(true)))
+type(trimSuffix("bar"))
+type(true == false)
+type(true == nil)
+type(true ? "bar" : 0.5)
+type(true ? div : 0.5)
+type(true ? f64 : array)
+type(true ? foo : foo)
+type(true ? foo : true)
+type(true ? greet : "foo")
+type(true ? list : ok)
+type(true ? nil : list)
+type(true ? nil : ok)
+type(true ? true : 1)
+type(true and true)
+type(true) endsWith toBase64("foo")
+type(type("bar"))
+type(type("foo"))
+type(type(0.5))
+type(type(1))
+type(type(add))
+type(type(array))
+type(type(div))
+type(type(f32))
+type(type(f64))
+type(type(false))
+type(type(foo))
+type(type(half))
+type(type(i))
+type(type(i32))
+type(type(i64))
+type(type(list))
+type(type(nil))
+type(type(ok))
+type(type(score))
+type(type(true))
+type(upper("bar"))
+type(upper("foo"))
+type({"bar": 0.5})
+type({"bar": 1})
+type({"bar": greet})
+type({"foo": 0.5, "bar": foo})
+type({"foo": div})
+type({"foo": i64})
+type({"foo": nil})
+upper("bar" + "foo")
+upper("bar") <= type(nil)
+upper("bar") contains lower("foo")
+upper("foo" + "bar")
+upper(false ? 0.5 : "foo")
+upper(foo.Bar)
+upper(foo.String())
+upper(foo?.Bar)
+upper(foo?.String())
+upper(greet("foo"))
+upper(greet(string(ok)))
+upper(lower("bar"))
+upper(ok ? "bar" : i)
+upper(string("bar"))
+upper(string("foo"))
 upper(string(0.5))
-upper(string(a))
-upper(string(add))
-upper(string(b))
-upper(string(f))
+upper(string(1))
+upper(string(array))
+upper(string(div))
+upper(string(f32))
+upper(string(f64))
+upper(string(foo))
+upper(string(greet))
+upper(string(half))
+upper(string(i))
+upper(string(i32))
+upper(string(i64))
+upper(string(list))
 upper(string(nil))
-upper(string(obj))
 upper(string(ok))
+upper(string(score))
+upper(string(string(0.5)))
 upper(string(true))
-upper(toBase64("c"))
-upper(toBase64(s))
-upper(toJSON("c"))
-upper(toJSON(2))
-upper(toJSON(a))
-upper(toJSON(arr))
-upper(toJSON(f))
+upper(toBase64("foo"))
+upper(toJSON("foo"))
+upper(toJSON(0.5))
+upper(toJSON(1))
+upper(toJSON(array))
+upper(toJSON(f32))
+upper(toJSON(f64))
 upper(toJSON(false))
+upper(toJSON(foo))
+upper(toJSON(i))
+upper(toJSON(i32))
+upper(toJSON(i64))
+upper(toJSON(list))
+upper(toJSON(nil))
 upper(toJSON(ok))
-upper(toJSON(s))
 upper(toJSON(true))
-upper(trim("c"))
-upper(trim(s))
-upper(trimPrefix(s))
-upper(trimSuffix("a"))
-upper(trimSuffix(s))
-upper(upper(s))
-values(obj)
-values(obj) != obj?.obj
-values(obj)[a]
-{"a": "a", "c": a}.obj
-{"a": "a"}?.obj
-{"a": "c"}?.a
-{"a": 0 > b}
-{"a": 0, "a": "a", "a": nil, "c": ok}.b
-{"a": 0, "b": f}.obj
-{"a": 0, "c": 0.5}.a
-{"a": 0.5, "a": s}?.b
-{"a": 0.5, "b": b}?.obj
-{"a": 0.5, "b": obj}?.obj
-{"a": 0.5, "c": a}.b
-{"a": 0.5, "c": false, "c": arr, "c": obj}.b
-{"a": 0}.b
-{"a": 0}?.a
-{"a": 0}?.b
-{"a": 0}?.obj
-{"a": 1}.b
-{"a": 1}.obj
-{"a": 2 >= 1}
-{"a": 2, "a": obj, "b": ok}?.obj
-{"a": 2, "b": a, "b": f}.b
-{"a": 2}.b
-{"a": a - 1}
-{"a": a / 0.5}
-{"a": a, "a": arr}
-{"a": a, "a": b, "a": "b", "c": f, "c": ok}?.obj
-{"a": a, "a": div}?.obj?.a
-{"a": a, "a": ok}?.b
-{"a": a, "b": obj?.b}
-{"a": a, "c": add, "c": nil}?.obj?.b
-{"a": a, "c": obj.a}
-{"a": a, "c": s, "b": nil}?.a
-{"a": add(b, 2)}
-{"a": add(b, b)}
-{"a": add, "a": ok ? add : obj}?.b
-{"a": add, "a": s, "b": div}.b
-{"a": add}
-{"a": add}.a
-{"a": arr, "b": 1, "c": 0.5, "b": f}?.b
-{"a": arr, "c": arr}
-{"a": arr}
-{"a": arr} == obj
-{"a": arr}.a
-{"a": arr}.b
-{"a": a}
-{"a": a}.obj
-{"a": a}?.a
-{"a": a}?.obj
-{"a": b + b}
-{"a": b - a}
-{"a": b - f}
-{"a": b / b}
-{"a": b, "a": obj, "a": div}?.b
-{"a": b, "a": ok}
-{"a": b, "b": a, "c": 0}?.b
-{"a": b, "b": s, "b": s}.b
-{"a": b, "c": "b"}.a
-{"a": b, "c": b}?.a
-{"a": b}
-{"a": b}.a
-{"a": b}.b
-{"a": b}.obj
-{"a": b}?.a
-{"a": b}?.b
-{"a": b}?.obj
-{"a": b}?.obj?.obj
-{"a": div == nil}
-{"a": div, "a": b, "c": nil, "a": 0}?.obj
-{"a": div, "a": ok, "b": s}.a
-{"a": div, "b": arr}.b
-{"a": div, "c": nil}.a
-{"a": div, "c": true}.b
-{"a": div}
-{"a": div}.b
-{"a": div}.obj
-{"a": div}?.obj
-{"a": f, "a": add}.b
-{"a": f, "a": obj}?.b
-{"a": f, "b": div(b, a)}
-{"a": false, "b": 1}?.b
-{"a": false}.obj
-{"a": f}
-{"a": f}.a
-{"a": f}.obj
-{"a": f}?.a
-{"a": f}?.obj
-{"a": map(arr, a)}
-{"a": map(arr, obj)}
-{"a": nil, "a": b}.a
-{"a": nil, "b": 1}?.b
-{"a": nil}.obj
-{"a": nil}?.a
-{"a": obj, "a": arr}.a
-{"a": obj, "a": nil}?.b
-{"a": obj, "b": obj?.obj, "a": add}
-{"a": obj, "b": obj}.b
-{"a": obj, "c": f, "a": true}.obj
-{"a": obj, "c": false, "b": arr, "b": "b"}?.a
-{"a": obj.a}
-{"a": obj.b}
-{"a": obj.head(b, ok, nil)}
-{"a": obj.obj}
-{"a": obj?.a}
-{"a": obj?.head(arr)}
-{"a": obj?.head(b)}
-{"a": obj?.head(f)}
-{"a": obj?.head(obj, nil, s, false)}
-{"a": obj?.obj}.b
-{"a": obj}
-{"a": obj}.b
-{"a": obj}.obj
-{"a": obj}?.b
-{"a": ok, "b": f}
-{"a": ok, "b": ok}?.obj
-{"a": ok}
-{"a": ok}.a
-{"a": ok}.b
-{"a": ok}?.a
-{"a": ok}?.obj
-{"a": s, "a": "a", "a": b}.a
-{"a": s, "a": arr}?.obj
-{"a": s, "a": b}.obj
-{"a": s, "a": obj}.b
-{"a": s, "b": nil, "c": add}?.b?.obj
-{"a": s, "c": div}.obj
-{"a": s, "c": div}?.a
-{"a": string(f)}
-{"a": s}
-{"a": s}.a
-{"a": toBase64("a")}
-{"a": true || true}
-{"a": true}.a
-{"a": true}.b
-{"a": true}?.a
-{"b": "a", "a": "b", "a": add}.a
-{"b": "a", "b": add, "a": div}?.obj
-{"b": "a"}?.a
-{"b": "b", "b": "b"}.a
-{"b": "b", "b": arr, "b": a}.obj
-{"b": "b", "b": true}?.a
-{"b": "c", "b": "a"}.a
-{"b": 0 == a, "a": ok}
-{"b": 0, "c": arr}.b
-{"b": 0.5, "b": arr, "a": 0}?.b
-{"b": 0.5, "c": f, "b": div, "c": ok}?.b
-{"b": 0.5, "c": ok}.b
-{"b": 0}.obj
-{"b": 0}.obj?.obj != div
-{"b": 0}?.a
-{"b": 0}?.obj
-{"b": 1 .. a}
-{"b": 1 < b}
-{"b": 1, "c": f}?.a
-{"b": 1}.a
-{"b": 2, "b": a}?.a
-{"b": 2}?.b
-{"b": a, "a": add}
-{"b": a, "a": false, "c": arr}.obj
-{"b": a, "c": b != a}
-{"b": add, "a": a, "a": div, "a": nil, "a": a}.obj
-{"b": add, "a": true, "b": 0, "c": 0.5, "b": nil}.obj
-{"b": add, "b": ok}?.a
-{"b": add, "b": s}.b
-{"b": add}
-{"b": add}.b
-{"b": add}.obj?.obj
-{"b": add}?.obj
-{"b": arr, "a": arr, "b": add}?.obj
-{"b": arr, "a": div}
-{"b": arr, "b": add}
-{"b": arr, "b": f, "b": arr, "b": 0}?.b
-{"b": arr, "c": f, "a": nil}[s]?.a
-{"b": arr}
-{"b": arr}?.a
-{"b": a}
-{"b": a}.a
-{"b": a}.b
-{"b": a}?.obj
-{"b": b .. b}
-{"b": b < f}
-{"b": b == a}
-{"b": b, "a": ok}?.a
-{"b": b, "b": 0, "b": b}.obj
-{"b": b, "b": a}?.a
-{"b": b, "b": div, "b": arr, "b": add}.a
-{"b": b, "b": obj.obj}
-{"b": b, "c": a}.obj
-{"b": b}
-{"b": b}.a
-{"b": b}.obj
-{"b": b}?.a
-{"b": b}?.obj
-{"b": div, "a": a > a}
-{"b": div, "a": arr, "a": obj, "c": 0}.a
-{"b": div, "b": add}?.b
-{"b": div, "c": ok, "c": 2}?.obj
-{"b": div}
-{"b": div}.b
-{"b": div}?.a
-{"b": div}?.obj
-{"b": f != 0}
-{"b": f <= 0.5}
-{"b": f, "a": false}?.a
-{"b": f, "b": add}?.obj
-{"b": f, "b": s}?.obj
-{"b": f, "c": arr, "b": div}?.obj
-{"b": f, "c": arr, "b": f}.a
-{"b": f, "c": f}?.a
-{"b": false ? 0 : 2}
-{"b": false, "a": obj}.b
-{"b": false, "c": s}.a
-{"b": f}
-{"b": f}?.a?.a
-{"b": f}?.obj
-{"b": nil == nil, "c": obj?.obj}?.b
-{"b": nil, "a": f, "b": "c"}.obj
-{"b": nil, "a": f, "c": 1}.obj
-{"b": nil, "a": obj, "a": f}.a
-{"b": nil, "a": obj}.b
-{"b": nil, "b": b}.b
-{"b": nil, "b": div}.b
-{"b": nil, "b": true}.b
-{"b": nil, "c": div, "c": div}.b
-{"b": nil}.obj
-{"b": nil}?.a
-{"b": not ok, "a": a}
-{"b": not ok}
-{"b": obj != obj.b}
-{"b": obj, "a": add, "c": s}.a
-{"b": obj, "a": a}?.obj
-{"b": obj, "c": f, "b": nil}?.a
-{"b": obj.a}
-{"b": obj.b}
-{"b": obj.head("b")}
-{"b": obj.head(nil, b, obj)}
-{"b": obj.head(s)}
-{"b": obj.obj}
-{"b": obj?.a}
-{"b": obj?.b}
-{"b": obj}
-{"b": obj}.b
-{"b": obj}.b?.a
-{"b": obj}.obj
-{"b": obj}?.b
-{"b": ok, "a": a}.obj
-{"b": ok, "a": b}.obj
-{"b": ok, "c": 1, "c": f}?.a
-{"b": ok}
-{"b": ok}.obj
-{"b": ok}?.a
-{"b": s, "a": b, "c": obj, "b": f}?.obj
-{"b": s, "b": 0, "b": nil, "c": 0}?.a
-{"b": s, "b": f}?.obj
-{"b": s, "c": "a", "b": div, "c": 1}.b
-{"b": string(div)}
-{"b": s}
-{"b": s}.a
-{"b": s}?.a
-{"b": true ? obj : add}
-{"b": true, "b": arr, "a": add} == obj ? add : b
-{"b": true}.obj
-{"b": true}?.obj
-{"c": "a", "a": obj, "c": "b"}?.b?.obj?.b
-{"c": "a", "c": obj}.b
-{"c": "a"}?.a
-{"c": "b", "b": false}?.obj
-{"c": "b"}.a
-{"c": "b"}.obj
-{"c": "b"}?.obj
-{"c": "c"}?.obj?.fn(arr)
-{"c": 0 ** 0, "c": ok ? arr : f}
-{"c": 0, "a": s, "c": add}.b
-{"c": 0, "c": 0, "a": "b", "b": false}.b
-{"c": 0, "c": f, "b": false}?.obj
-{"c": 0, "c": f}.a
-{"c": 0, "c": obj}?.a?.a
-{"c": 0, "c": s, "b": s, "c": false, "b": obj}.a
-{"c": 0.5, "b": b, "c": a, "b": 2}?.b
-{"c": 0.5, "c": b, "b": 0}.b
-{"c": 0.5, "c": true, "a": true}.b
-{"c": 0}.b
-{"c": 0}.obj
-{"c": 1, "b": ok}?.b
-{"c": 1}?.a
-{"c": 2, "a": "c"}.b
-{"c": 2}.a
-{"c": 2}?.b
-{"c": a != 1}
-{"c": a .. 2}.obj
-{"c": a / 0}
-{"c": a <= 1}
-{"c": a, "a": arr}?.obj
-{"c": a, "a": b, "b": div, "b": f, "b": div}.b
-{"c": a, "b": ok ? "c" : div}
-{"c": a, "b": s, "a": s, "c": b, "a": add}.obj
-{"c": a, "c": true}?.obj
-{"c": abs(a)}
-{"c": add, "a": true, "b": s}?.a
-{"c": add, "b": 0, "b": b, "b": 1}?.obj
-{"c": add, "b": 0.5, "c": arr}?.obj
-{"c": add, "b": a, "b": s}?.a
-{"c": add, "b": arr}?.obj
-{"c": add, "b": obj, "b": false}?.b
-{"c": add, "b": ok, "b": f, "b": s}.a
-{"c": add, "c": arr}
-{"c": add, "c": b}?.b
-{"c": add}
-{"c": add}.a?.obj
-{"c": add}.b
-{"c": add}.obj
-{"c": add}?.a
-{"c": arr != nil}
-{"c": arr == arr}
-{"c": arr, "a": nil, "b": b}.obj
-{"c": arr, "c": arr}?.a
-{"c": arr, "c": s}.obj
-{"c": arr}
-{"c": arr}.a
-{"c": arr}.obj
-{"c": arr}?.b
-{"c": arr}?.obj
-{"c": arr}?.obj?.b
-{"c": a}
-{"c": a}.a
-{"c": a}.obj
-{"c": a}?.a
-{"c": b % a}
-{"c": b, "a": obj, "b": 0.5, "a": obj, "a": s}.b
-{"c": b, "c": "c", "a": f, "b": div, "c": b}?.obj
-{"c": b, "c": f, "a": arr}?.b
-{"c": b}
-{"c": b}.a
-{"c": b}.obj
-{"c": b}?.b
-{"c": b}?.obj
-{"c": div, "a": a}
-{"c": div, "a": ok, "b": obj}?.obj
-{"c": div, "b": add}.obj
-{"c": div, "b": b, "a": arr, "b": true}.b
-{"c": div, "c": ok}?.a
-{"c": div}
-{"c": div}.a
-{"c": div}.b
-{"c": div}.obj
-{"c": div}?.b
-{"c": f - f}
-{"c": f, "a": "b", "b": "a", "b": 0.5}?.b
-{"c": f, "b": 0.5}.b
-{"c": f, "b": add, "a": a}.b
-{"c": f, "b": obj, "b": 2}?.obj
-{"c": false}?.b
-{"c": first(arr)}.a
-{"c": f}
-{"c": f}.a
-{"c": f}.obj
-{"c": f}?.a
-{"c": f}?.obj
-{"c": get(arr, a), "a": a != nil}
-{"c": get(arr, b)}
-{"c": get(obj, s)}
-{"c": nil, "a": false, "c": arr, "a": f, "a": nil}.b
-{"c": nil, "b": false}?.a
-{"c": nil}.a
-{"c": nil}.b
-{"c": nil}?.a
-{"c": obj, "a": div}.b
-{"c": obj, "b": b}?.a
-{"c": obj, "c": add}
-{"c": obj, "c": nil}?.b
-{"c": obj.fn(a)}
-{"c": obj.head(arr, f), "a": div, "b": s}.obj
-{"c": obj.head(div)}
-{"c": obj.obj}
-{"c": obj?.a}
-{"c": obj?.obj}
-{"c": obj}
-{"c": obj}.a
-{"c": obj}.b
-{"c": obj}.obj
-{"c": obj}?.a
-{"c": obj}?.b
-{"c": ok and ok}
-{"c": ok, "c": 0}?.a
-{"c": ok}
-{"c": ok}.b
-{"c": s, "a": b}?.a
-{"c": s, "b": a}?.b
-{"c": s, "b": f}?.a
-{"c": s, "b": obj, "a": div}?.a
-{"c": s, "c": "c", "b": false, "a": a}?.a
-{"c": s, "c": add, "b": arr, "a": ok, "b": obj}?.obj
-{"c": s, "c": div}.obj
-{"c": s}
-{"c": s}.b
-{"c": s}.obj
-{"c": toBase64(s)}
-{"c": toJSON(a)}
-{"c": true, "c": a}.obj
-{"c": true}?.b
+upper(trim("bar"))
+upper(trim("bar", "bar"))
+upper(trim("foo"))
+upper(trimPrefix("bar"))
+upper(trimPrefix("foo"))
+upper(trimSuffix("bar"))
+upper(trimSuffix("foo"))
+upper(true ? "bar" : f32)
+upper(true ? "foo" : i32)
+upper(type("bar"))
+upper(type("foo"))
+upper(type(0.5))
+upper(type(1))
+upper(type(add))
+upper(type(div))
+upper(type(f32))
+upper(type(f64))
+upper(type(false))
+upper(type(foo))
+upper(type(greet))
+upper(type(half))
+upper(type(i))
+upper(type(i64))
+upper(type(list))
+upper(type(nil))
+upper(type(score))
+upper(type(true))
+upper(upper("bar"))
+values({"bar": f32})
+values({"bar": greet})
+values({"bar": i64})
+values({"foo": 1})
+values({"foo": div})
+values({"foo": false})
+values({"foo": foo, "foo": ok})
+values({"foo": list, "bar": 1})
+{"bar": !false}
+{"bar": !true}
+{"bar": "bar", "foo": nil}?.String
+{"bar": "bar", "foo": score}.i
+{"bar": "bar", "foo": true}?.i?.foo
+{"bar": "bar"}.add
+{"bar": "bar"}.array
+{"bar": "bar"}.f32
+{"bar": "bar"}.f64
+{"bar": "bar"}.list
+{"bar": "bar"}.ok
+{"bar": "bar"}?.Bar
+{"bar": "bar"}?.greet
+{"bar": "bar"}?.half
+{"bar": "bar"}?.i
+{"bar": "foo", "foo": 0.5}.add
+{"bar": "foo", "foo": 1}.String?.ok
+{"bar": "foo", "foo": greet}.half
+{"bar": "foo", "foo": ok, "bar": f64}?.Bar
+{"bar": "foo", "foo": ok}.Qux
+{"bar": "foo", "foo": true}.ok
+{"bar": "foo"}.Qux
+{"bar": "foo"}.String
+{"bar": "foo"}.add
+{"bar": "foo"}.array
+{"bar": "foo"}.div
+{"bar": "foo"}.f32
+{"bar": "foo"}.i
+{"bar": "foo"}.i64
+{"bar": "foo"}.score
+{"bar": "foo"}?.Qux
+{"bar": "foo"}?.Qux?.score
+{"bar": "foo"}?.String
+{"bar": "foo"}?.div
+{"bar": "foo"}?.foo
+{"bar": "foo"}?.i32
+{"bar": "foo"}?.i64
+{"bar": -0.5}
+{"bar": -1}
+{"bar": -1}?.array
+{"bar": -f32}
+{"bar": 0.5 * f64}
+{"bar": 0.5 + 1}
+{"bar": 0.5 - i32}
+{"bar": 0.5 - i64}
+{"bar": 0.5 < i64}
+{"bar": 0.5 == nil}
+{"bar": 0.5 > 1}.Qux
+{"bar": 0.5, "bar": "bar"}.ok
+{"bar": 0.5, "bar": 0.5}.f32
+{"bar": 0.5, "bar": 1}?.half
+{"bar": 0.5, "foo": array}?.ok
+{"bar": 0.5, "foo": i32, "bar": add}?.Bar
+{"bar": 0.5}.Bar
+{"bar": 0.5}.Qux
+{"bar": 0.5}.String
+{"bar": 0.5}.add
+{"bar": 0.5}.div
+{"bar": 0.5}.div?.array.foo
+{"bar": 0.5}.f32
+{"bar": 0.5}.f64
+{"bar": 0.5}.foo
+{"bar": 0.5}.greet
+{"bar": 0.5}.i32
+{"bar": 0.5}.ok
+{"bar": 0.5}.score
+{"bar": 0.5}?.Bar
+{"bar": 0.5}?.String
+{"bar": 0.5}?.add
+{"bar": 0.5}?.array
+{"bar": 0.5}?.div
+{"bar": 0.5}?.f32
+{"bar": 0.5}?.foo
+{"bar": 0.5}?.greet?.i32
+{"bar": 0.5}?.half
+{"bar": 0.5}?.i
+{"bar": 0.5}?.i32
+{"bar": 0.5}?.i32?.i32
+{"bar": 0.5}?.i64
+{"bar": 1 * i32}
+{"bar": 1 * i}
+{"bar": 1 + i32}
+{"bar": 1 - f32}
+{"bar": 1 / 0.5}
+{"bar": 1 < f32}
+{"bar": 1 <= 1}
+{"bar": 1, "bar": "bar"}.i32
+{"bar": 1, "bar": array}?.f32
+{"bar": 1, "bar": false}.array
+{"bar": 1, "bar": greet, "foo": "bar"}?.i64
+{"bar": 1, "bar": i64}?.array
+{"bar": 1, "foo": 0.5}?.String
+{"bar": 1, "foo": add, "foo": f32}?.i
+{"bar": 1, "foo": foo}.div
+{"bar": 1, "foo": i64}.i64
+{"bar": 1}.Bar
+{"bar": 1}.Qux
+{"bar": 1}.String
+{"bar": 1}.add
+{"bar": 1}.div
+{"bar": 1}.f64
+{"bar": 1}.greet
+{"bar": 1}.half
+{"bar": 1}.i
+{"bar": 1}.ok
+{"bar": 1}?.Bar
+{"bar": 1}?.add
+{"bar": 1}?.add?.i32
+{"bar": 1}?.div?.list
+{"bar": 1}?.f32
+{"bar": 1}?.f64
+{"bar": 1}?.i
+{"bar": 1}?.i32
+{"bar": 1}?.ok
+{"bar": ["bar", score]}
+{"bar": add, "bar": "foo"}.String?.array
+{"bar": add, "bar": 1}?.i64
+{"bar": add, "bar": div}?.f32
+{"bar": add, "bar": foo}
+{"bar": add, "bar": list}.Bar
+{"bar": add, "bar": score}.f64?.f64
+{"bar": add, "foo": "foo"}.i64
+{"bar": add, "foo": f64}?.score
+{"bar": add, "foo": i32}?.half
+{"bar": add, "foo": ok}
+{"bar": add, "foo": score}
+{"bar": add}
+{"bar": add}.Qux
+{"bar": add}.String
+{"bar": add}.f64
+{"bar": add}.foo
+{"bar": add}.greet
+{"bar": add}.i32
+{"bar": add}.list
+{"bar": add}?.String
+{"bar": add}?.add
+{"bar": add}?.div
+{"bar": add}?.i
+{"bar": add}?.i64
+{"bar": add}?.score
+{"bar": any(array, false)}
+{"bar": any(list, ok)}
+{"bar": array, "bar": f64}
+{"bar": array, "bar": false, "bar": i}?.Qux
+{"bar": array, "bar": false}.Qux
+{"bar": array, "bar": half}.i32
+{"bar": array, "bar": i64}.i64
+{"bar": array, "bar": score}
+{"bar": array, "foo": "foo"}?.array
+{"bar": array, "foo": add == add}
+{"bar": array, "foo": count(list, true)}.add
+{"bar": array}
+{"bar": array}.Bar
+{"bar": array}.Qux
+{"bar": array}.String
+{"bar": array}.add
+{"bar": array}.f32
+{"bar": array}.half?.foo
+{"bar": array}.i
+{"bar": array}.i64
+{"bar": array}?.Bar
+{"bar": array}?.div
+{"bar": array}?.greet
+{"bar": array}?.half
+{"bar": array}?.i32
+{"bar": array}?.i64
+{"bar": array}?.ok
+{"bar": div != greet}
+{"bar": div, "bar": "bar", "bar": foo}.greet
+{"bar": div, "bar": "bar", "foo": 1}?.div
+{"bar": div, "bar": greet}?.i32
+{"bar": div, "bar": i32}?.array
+{"bar": div, "foo": div}?.list
+{"bar": div, "foo": greet, "foo": 1}?.score?.Qux
+{"bar": div, "foo": i}?.i
+{"bar": div, "foo": list}.f64
+{"bar": div, "foo": ok}?.i64
+{"bar": div, "foo": score}
+{"bar": div}
+{"bar": div}.add
+{"bar": div}.div
+{"bar": div}.f32
+{"bar": div}.f32?.score
+{"bar": div}.half
+{"bar": div}.i32
+{"bar": div}.i64
+{"bar": div}.score
+{"bar": div}?.div
+{"bar": div}?.div?.f32
+{"bar": div}?.foo
+{"bar": div}?.half
+{"bar": div}?.i
+{"bar": div}?.i64
+{"bar": div}?.list
+{"bar": div}?.ok
+{"bar": f32 ** 1}
+{"bar": f32 - i32}
+{"bar": f32, "bar": true, "bar": list}?.Bar
+{"bar": f32, "foo": i32}
+{"bar": f32, "foo": ok, "foo": f32}.half
+{"bar": f32, "foo": score}?.greet
+{"bar": f32}
+{"bar": f32}.Bar
+{"bar": f32}.Qux?.i64
+{"bar": f32}.String
+{"bar": f32}.add
+{"bar": f32}.half
+{"bar": f32}.list
+{"bar": f32}?.String?.score
+{"bar": f32}?.f64
+{"bar": f32}?.foo
+{"bar": f32}?.i32
+{"bar": f32}?.i64
+{"bar": f32}?.list
+{"bar": f32}?.score
+{"bar": f64, "bar": 0.5}.div
+{"bar": f64, "bar": i}
+{"bar": f64, "bar": nil}?.f64
+{"bar": f64, "foo": "foo"}?.half
+{"bar": f64, "foo": 0.5, "bar": foo}?.half
+{"bar": f64, "foo": f64}.foo
+{"bar": f64, "foo": i32}
+{"bar": f64}
+{"bar": f64}.String
+{"bar": f64}.div?.String()
+{"bar": f64}.f32
+{"bar": f64}.f64
+{"bar": f64}.f64?.list
+{"bar": f64}.greet
+{"bar": f64}.half
+{"bar": f64}.i
+{"bar": f64}.ok
+{"bar": f64}?.Bar
+{"bar": f64}?.Qux
+{"bar": f64}?.f64
+{"bar": f64}?.half
+{"bar": f64}?.i32
+{"bar": f64}?.i64
+{"bar": f64}?.score
+{"bar": false, "bar": 0.5, "bar": foo}.add
+{"bar": false, "foo": greet, "foo": i64}.div
+{"bar": false}.add
+{"bar": false}.div
+{"bar": false}.f64
+{"bar": false}.foo
+{"bar": false}.greet
+{"bar": false}.half
+{"bar": false}.i32
+{"bar": false}.list
+{"bar": false}.ok
+{"bar": false}.score
+{"bar": false}?.array
+{"bar": false}?.greet
+{"bar": false}?.i32
+{"bar": false}?.ok?.Qux?.score()
+{"bar": false}?.score
+{"bar": first(list)}
+{"bar": float(f32)}
+{"bar": foo, "bar": 0.5}.div
+{"bar": foo, "bar": div}.array
+{"bar": foo, "bar": half}
+{"bar": foo, "bar": list}.f32
+{"bar": foo, "foo": greet}?.div
+{"bar": foo, "foo": i32}.score
+{"bar": foo, "foo": true}?.f32
+{"bar": foo.Bar}
+{"bar": foo.String()}
+{"bar": foo?.Qux}?.foo
+{"bar": foo?.String}
+{"bar": foo}
+{"bar": foo}.Qux
+{"bar": foo}.String
+{"bar": foo}.array
+{"bar": foo}.div
+{"bar": foo}.f64
+{"bar": foo}.half
+{"bar": foo}.half?.list(i32).array
+{"bar": foo}.i
+{"bar": foo}.list
+{"bar": foo}.ok
+{"bar": foo}?.div
+{"bar": foo}?.f64
+{"bar": foo}?.greet
+{"bar": foo}?.i
+{"bar": foo}?.i64
+{"bar": foo}?.list
+{"bar": greet, "bar": foo}
+{"bar": greet, "bar": nil}.f64
+{"bar": greet, "foo": foo}
+{"bar": greet}
+{"bar": greet}.Qux
+{"bar": greet}.add
+{"bar": greet}.array
+{"bar": greet}.div
+{"bar": greet}.foo
+{"bar": greet}.i
+{"bar": greet}.i32
+{"bar": greet}.ok
+{"bar": greet}.score
+{"bar": greet}?.Bar
+{"bar": greet}?.String
+{"bar": greet}?.add
+{"bar": greet}?.f32
+{"bar": greet}?.foo?.foo
+{"bar": greet}?.half
+{"bar": greet}?.i
+{"bar": greet}?.list
+{"bar": greet}?.ok
+{"bar": half(0.5), "bar": ok}
+{"bar": half(0.5)}
+{"bar": half(0.5)}?.array
+{"bar": half, "bar": "foo", "bar": ok}?.String
+{"bar": half, "bar": array}?.div?.i32
+{"bar": half, "bar": div}
+{"bar": half, "bar": f32}
+{"bar": half, "bar": greet}?.i64
+{"bar": half, "bar": list}
+{"bar": half, "bar": score, "bar": i == f32}
+{"bar": half, "bar": score}
+{"bar": half, "foo": array}
+{"bar": half, "foo": f64 == i64}
+{"bar": half, "foo": greet}
+{"bar": half, "foo": i64}.array
+{"bar": half, "foo": list}?.list?.ok
+{"bar": half}
+{"bar": half}.String
+{"bar": half}.String?.score
+{"bar": half}.half
+{"bar": half}.i32
+{"bar": half}.i64
+{"bar": half}.ok
+{"bar": half}.score
+{"bar": half}?.Qux
+{"bar": half}?.Qux?.f32
+{"bar": half}?.div
+{"bar": half}?.f32
+{"bar": half}?.foo?.f32()
+{"bar": half}?.half
+{"bar": half}?.half?.f32
+{"bar": half}?.i
+{"bar": i ** 0.5}
+{"bar": i + i64}
+{"bar": i .. i32}
+{"bar": i .. i}
+{"bar": i > i32}
+{"bar": i >= 0.5, "bar": array}
+{"bar": i >= i}
+{"bar": i, "bar": 0.5}?.Qux
+{"bar": i, "bar": foo}.foo
+{"bar": i, "bar": nil}?.f32
+{"bar": i, "foo": 1 >= f64}
+{"bar": i, "foo": array}.array
+{"bar": i, "foo": f64}.i64
+{"bar": i, "foo": greet}?.foo
+{"bar": i32 + 0.5}
+{"bar": i32 < i32}
+{"bar": i32 <= f64}
+{"bar": i32, "bar": "foo"}?.half
+{"bar": i32, "foo": f64}?.foo
+{"bar": i32, "foo": foo, "foo": i32}?.i32?.String()
+{"bar": i32, "foo": i64, "bar": true}?.i64
+{"bar": i32, "foo": i64}.half
+{"bar": i32, "foo": list}
+{"bar": i32, "foo": score, "foo": 1}.array
+{"bar": i32, "foo": score, "foo": greet}.add
+{"bar": i32, "foo": score, "foo": ok}.foo
+{"bar": i32}
+{"bar": i32}.Bar
+{"bar": i32}.i
+{"bar": i32}.i64
+{"bar": i32}.list
+{"bar": i32}.score?.f32
+{"bar": i32}?.String
+{"bar": i32}?.div
+{"bar": i32}?.f32
+{"bar": i32}?.foo
+{"bar": i32}?.greet
+{"bar": i32}?.half
+{"bar": i32}?.i
+{"bar": i32}?.list?.list
+{"bar": i32}?.ok
+{"bar": i32}?.score
+{"bar": i64 != f32, "bar": score}
+{"bar": i64 ** f64}
+{"bar": i64 / f64}
+{"bar": i64, "bar": "bar", "foo": i64}.array
+{"bar": i64, "bar": foo}.list
+{"bar": i64, "bar": greet, "foo": score}.array
+{"bar": i64, "bar": half}?.f64
+{"bar": i64, "bar": i64}?.Qux?.array()
+{"bar": i64, "bar": list}
+{"bar": i64, "foo": "foo"}.Bar
+{"bar": i64, "foo": 0.5, "foo": list}.i64
+{"bar": i64, "foo": f32, "foo": nil}.i32
+{"bar": i64, "foo": f32}?.half
+{"bar": i64, "foo": i, "foo": greet}.array
+{"bar": i64, "foo": nil}.add
+{"bar": i64, "foo": nil}?.Qux
+{"bar": i64}
+{"bar": i64}.add
+{"bar": i64}.array
+{"bar": i64}.div
+{"bar": i64}.div?.i64
+{"bar": i64}.f32
+{"bar": i64}.foo
+{"bar": i64}.greet
+{"bar": i64}.i64
+{"bar": i64}.list
+{"bar": i64}.ok
+{"bar": i64}?.Qux
+{"bar": i64}?.String
+{"bar": i64}?.array
+{"bar": i64}?.array?.foo
+{"bar": i64}?.div
+{"bar": i64}?.f32
+{"bar": i64}?.i64
+{"bar": i64}?.list
+{"bar": i64}?.ok
+{"bar": i64}?.score
+{"bar": i}
+{"bar": i}.Bar
+{"bar": i}.String
+{"bar": i}.array
+{"bar": i}.div
+{"bar": i}.f64
+{"bar": i}.foo
+{"bar": i}.greet
+{"bar": i}.half
+{"bar": i}.i
+{"bar": i}.i32
+{"bar": i}.i64
+{"bar": i}.list?.list
+{"bar": i}?.Qux
+{"bar": i}?.String
+{"bar": i}?.add
+{"bar": i}?.foo
+{"bar": i}?.greet
+{"bar": i}?.list
+{"bar": list, "bar": 1}?.f64
+{"bar": list, "bar": div}
+{"bar": list, "bar": f32, "bar": i64}.Bar
+{"bar": list, "bar": f32, "bar": ok}.add
+{"bar": list, "bar": f64}.foo
+{"bar": list, "bar": false, "bar": 1}?.f32
+{"bar": list, "bar": i32}.half
+{"bar": list, "bar": ok}
+{"bar": list, "foo": div, "foo": ok}?.i64
+{"bar": list, "foo": f64, "foo": list}.half
+{"bar": list, "foo": half}?.Qux
+{"bar": list, "foo": i}
+{"bar": list, "foo": list}
+{"bar": list, "foo": ok, "foo": f64}?.half
+{"bar": list}
+{"bar": list}.Bar
+{"bar": list}.add
+{"bar": list}.f32
+{"bar": list}.f64
+{"bar": list}.greet
+{"bar": list}.score
+{"bar": list}?.add
+{"bar": list}?.add?.array
+{"bar": list}?.div
+{"bar": list}?.half
+{"bar": list}?.i32
+{"bar": list}?.list
+{"bar": list}?.score
+{"bar": map(list, i32)}
+{"bar": min(0.5)}
+{"bar": min(f32)}
+{"bar": nil != "bar"}
+{"bar": nil != false}
+{"bar": nil == "foo"}
+{"bar": nil == 1}
+{"bar": nil == f64}
+{"bar": nil, "bar": div}.f32
+{"bar": nil, "bar": greet, "foo": "bar"}?.i64
+{"bar": nil, "bar": greet}.score
+{"bar": nil, "bar": i}.f64
+{"bar": nil, "foo": 0.5}?.array
+{"bar": nil, "foo": f64}?.add
+{"bar": nil, "foo": half}?.foo
+{"bar": nil}.String
+{"bar": nil}.add
+{"bar": nil}.array
+{"bar": nil}.f32
+{"bar": nil}.foo
+{"bar": nil}.half
+{"bar": nil}?.Bar
+{"bar": nil}?.add
+{"bar": nil}?.array
+{"bar": nil}?.f32
+{"bar": nil}?.f64
+{"bar": nil}?.foo
+{"bar": nil}?.foo?.i32
+{"bar": nil}?.greet
+{"bar": nil}?.half
+{"bar": nil}?.i32
+{"bar": nil}?.i64
+{"bar": nil}?.list
+{"bar": nil}?.ok
+{"bar": ok or ok}
+{"bar": ok || ok}
+{"bar": ok, "bar": list}
+{"bar": ok, "bar": nil == half}.f64
+{"bar": ok, "foo": div, "bar": "bar"}.Qux
+{"bar": ok, "foo": i32, "bar": 1}.score
+{"bar": ok}
+{"bar": ok}.String
+{"bar": ok}.add
+{"bar": ok}.array
+{"bar": ok}.i
+{"bar": ok}.i64
+{"bar": ok}.ok
+{"bar": ok}?.Qux
+{"bar": ok}?.array
+{"bar": ok}?.f64
+{"bar": ok}?.foo
+{"bar": ok}?.greet
+{"bar": ok}?.i
+{"bar": ok}?.i32
+{"bar": ok}?.i64
+{"bar": score != score}
+{"bar": score, "bar": 0.5}?.Bar
+{"bar": score, "bar": div}
+{"bar": score, "bar": foo}
+{"bar": score, "bar": i64}.div
+{"bar": score, "bar": i}
+{"bar": score, "foo": greet}
+{"bar": score}
+{"bar": score}.Bar
+{"bar": score}.add
+{"bar": score}.array
+{"bar": score}.div
+{"bar": score}.f64
+{"bar": score}.i32
+{"bar": score}.i64
+{"bar": score}.list
+{"bar": score}.ok
+{"bar": score}.score
+{"bar": score}?.f32
+{"bar": score}?.f64
+{"bar": score}?.i32
+{"bar": score}?.list
+{"bar": score}?.score
+{"bar": string(array)}
+{"bar": toJSON(array)}
+{"bar": toJSON(i)}.i64?.i64
+{"bar": toJSON(i32)}
+{"bar": true, "bar": false}.Bar
+{"bar": true, "bar": foo}?.String
+{"bar": true, "foo": 0.5}?.i
+{"bar": true, "foo": div}.score
+{"bar": true, "foo": foo}.div
+{"bar": true}.Bar
+{"bar": true}.Qux?.greet()
+{"bar": true}.f32
+{"bar": true}.f64
+{"bar": true}.half
+{"bar": true}.i
+{"bar": true}.list?.String()
+{"bar": true}.score
+{"bar": true}?.Bar
+{"bar": true}?.i64
+{"bar": true}?.list
+{"bar": type(f64)}
+{"bar": type(greet)}
+{"bar": {"foo": "bar", "bar": "bar", "bar": nil}}
+{"foo": "bar", "bar": i32}.half
+{"foo": "bar", "bar": nil}?.add?.i64
+{"foo": "bar"}.Bar
+{"foo": "bar"}.Qux
+{"foo": "bar"}.String
+{"foo": "bar"}.array
+{"foo": "bar"}.f64
+{"foo": "bar"}.half
+{"foo": "bar"}.i
+{"foo": "bar"}.i64
+{"foo": "bar"}.list
+{"foo": "bar"}.ok
+{"foo": "bar"}?.add
+{"foo": "bar"}?.div?.ok
+{"foo": "bar"}?.f64
+{"foo": "bar"}?.foo
+{"foo": "bar"}?.half
+{"foo": "foo" != "bar"}
+{"foo": "foo", "bar": nil}?.String
+{"foo": "foo", "foo": add, "foo": "foo"}?.i
+{"foo": "foo", "foo": div}.i64
+{"foo": "foo", "foo": greet}.array
+{"foo": "foo", "foo": i, "bar": greet}?.score
+{"foo": "foo", "foo": i32, "bar": f32}.greet
+{"foo": "foo", "foo": i}?.foo
+{"foo": "foo", "foo": list}.f32
+{"foo": "foo"}.Bar
+{"foo": "foo"}.array
+{"foo": "foo"}.f32
+{"foo": "foo"}.foo
+{"foo": "foo"}.greet
+{"foo": "foo"}.i64
+{"foo": "foo"}?.Bar
+{"foo": "foo"}?.add
+{"foo": "foo"}?.div
+{"foo": "foo"}?.greet
+{"foo": "foo"}?.half
+{"foo": "foo"}?.score
+{"foo": -1}
+{"foo": -i64}
+{"foo": -i}
+{"foo": 0.5 ** i64}
+{"foo": 0.5 - 0.5}
+{"foo": 0.5 <= 0.5}
+{"foo": 0.5 > i64}
+{"foo": 0.5, "bar": 1}.half
+{"foo": 0.5, "bar": add}.Bar
+{"foo": 0.5, "bar": div}.array
+{"foo": 0.5, "bar": i32}?.String
+{"foo": 0.5, "bar": score, "foo": score}.half
+{"foo": 0.5, "foo": 1, "foo": list}.div
+{"foo": 0.5, "foo": nil}?.div
+{"foo": 0.5, "foo": nil}?.i64
+{"foo": 0.5}.Bar
+{"foo": 0.5}.Qux
+{"foo": 0.5}.array
+{"foo": 0.5}.f32
+{"foo": 0.5}.f64
+{"foo": 0.5}.greet
+{"foo": 0.5}.half
+{"foo": 0.5}.i
+{"foo": 0.5}.i64
+{"foo": 0.5}.list
+{"foo": 0.5}.ok
+{"foo": 0.5}?.Bar?.i
+{"foo": 0.5}?.String
+{"foo": 0.5}?.add
+{"foo": 0.5}?.array
+{"foo": 0.5}?.array?.score
+{"foo": 0.5}?.foo
+{"foo": 0.5}?.greet
+{"foo": 0.5}?.half
+{"foo": 0.5}?.i64
+{"foo": 0.5}?.ok
+{"foo": 1 + 0.5}
+{"foo": 1 / 0.5}
+{"foo": 1 / i64}
+{"foo": 1 < i32}?.i64
+{"foo": 1 not in array}
+{"foo": 1, "bar": 0.5}.array
+{"foo": 1, "bar": div}.f32
+{"foo": 1, "bar": f32}.Qux?.half?.list
+{"foo": 1, "bar": i64, "foo": 0.5}.list
+{"foo": 1, "bar": i64}?.ok
+{"foo": 1, "bar": score}.foo
+{"foo": 1, "foo": 0.5}.f32
+{"foo": 1, "foo": array}?.array
+{"foo": 1, "foo": ok}.add
+{"foo": 1, "foo": true}?.Qux
+{"foo": 1}.add
+{"foo": 1}.f32
+{"foo": 1}.foo
+{"foo": 1}.greet
+{"foo": 1}.half
+{"foo": 1}.i64
+{"foo": 1}.list
+{"foo": 1}.ok
+{"foo": 1}?.Bar
+{"foo": 1}?.add
+{"foo": 1}?.div
+{"foo": 1}?.f32
+{"foo": 1}?.foo
+{"foo": 1}?.greet
+{"foo": 1}?.half
+{"foo": 1}?.i
+{"foo": 1}?.i32
+{"foo": 1}?.score
+{"foo": abs(0.5)}
+{"foo": add, "bar": 0.5}.i
+{"foo": add, "bar": nil}.score
+{"foo": add, "bar": ok}
+{"foo": add, "bar": score}.half
+{"foo": add, "foo": "bar"}?.String
+{"foo": add, "foo": half, "foo": div}?.greet
+{"foo": add, "foo": i32}.foo
+{"foo": add, "foo": nil}?.list
+{"foo": add}
+{"foo": add}.Bar
+{"foo": add}.div
+{"foo": add}.foo
+{"foo": add}.half
+{"foo": add}.i
+{"foo": add}.i64
+{"foo": add}.list
+{"foo": add}.ok
+{"foo": add}?.String
+{"foo": add}?.array
+{"foo": add}?.div
+{"foo": add}?.greet
+{"foo": add}?.half
+{"foo": add}?.i32
+{"foo": add}?.ok
+{"foo": array, "bar": "foo"}?.f32
+{"foo": array, "bar": f64}
+{"foo": array, "bar": greet}
+{"foo": array, "bar": list}?.f32
+{"foo": array, "bar": ok}
+{"foo": array, "foo": add}
+{"foo": array, "foo": greet}
+{"foo": array, "foo": true}?.i
+{"foo": array}
+{"foo": array}.Qux
+{"foo": array}.Qux?.String
+{"foo": array}.String
+{"foo": array}.f64
+{"foo": array}.greet
+{"foo": array}.i32
+{"foo": array}.ok
+{"foo": array}?.Bar
+{"foo": array}?.String
+{"foo": array}?.add
+{"foo": array}?.array
+{"foo": array}?.div
+{"foo": array}?.f64
+{"foo": array}?.half
+{"foo": array}?.ok
+{"foo": div, "bar": 1}?.add
+{"foo": div, "bar": add}
+{"foo": div, "bar": div}
+{"foo": div, "bar": half}.half
+{"foo": div, "bar": list, "bar": 0.5}?.Qux
+{"foo": div, "foo": array}.Bar
+{"foo": div, "foo": true}?.Qux
+{"foo": div}
+{"foo": div}.Qux
+{"foo": div}.array
+{"foo": div}.div
+{"foo": div}.foo
+{"foo": div}.greet
+{"foo": div}?.Bar
+{"foo": div}?.Qux
+{"foo": div}?.String
+{"foo": div}?.add
+{"foo": div}?.f64
+{"foo": div}?.half
+{"foo": div}?.i
+{"foo": div}?.i64
+{"foo": div}?.list
+{"foo": div}?.ok
+{"foo": f32 != i}
+{"foo": f32 - f32}
+{"foo": f32 == 0.5}
+{"foo": f32, "bar": "bar"}?.String
+{"foo": f32, "bar": 0.5}.f32
+{"foo": f32, "bar": i32}
+{"foo": f32, "bar": list}
+{"foo": f32, "foo": 1, "foo": i32}?.i32
+{"foo": f32, "foo": div}
+{"foo": f32, "foo": i}
+{"foo": f32, "foo": ok}?.i
+{"foo": f32, "foo": type("bar")}
+{"foo": f32}
+{"foo": f32}.String
+{"foo": f32}.add
+{"foo": f32}.array
+{"foo": f32}.f32
+{"foo": f32}.foo
+{"foo": f32}.greet
+{"foo": f32}.half
+{"foo": f32}.i
+{"foo": f32}.i32
+{"foo": f32}.list
+{"foo": f32}?.Bar
+{"foo": f32}?.Qux
+{"foo": f32}?.add
+{"foo": f32}?.f32
+{"foo": f32}?.f64
+{"foo": f32}?.half
+{"foo": f32}?.i32
+{"foo": f32}?.score
+{"foo": f64 * i}
+{"foo": f64 / 1}
+{"foo": f64 == 0.5}
+{"foo": f64 >= 1}
+{"foo": f64 ^ f32}
+{"foo": f64, "bar": "foo"}.Qux
+{"foo": f64, "bar": "foo"}.add
+{"foo": f64, "bar": 0.5}.div
+{"foo": f64, "bar": div}
+{"foo": f64, "bar": greet}
+{"foo": f64, "bar": half}?.list
+{"foo": f64, "bar": ok}.half
+{"foo": f64, "foo": foo, "bar": greet}.String
+{"foo": f64, "foo": foo, "foo": "foo"}.Bar
+{"foo": f64, "foo": greet}
+{"foo": f64, "foo": ok, "foo": i64}?.f64
+{"foo": f64}
+{"foo": f64}.Qux
+{"foo": f64}.String?.f32
+{"foo": f64}.String?.i64
+{"foo": f64}.add
+{"foo": f64}.array
+{"foo": f64}.f64
+{"foo": f64}.foo
+{"foo": f64}.greet
+{"foo": f64}.i
+{"foo": f64}.list
+{"foo": f64}?.Bar
+{"foo": f64}?.String
+{"foo": f64}?.div
+{"foo": f64}?.f32
+{"foo": f64}?.f64
+{"foo": f64}?.foo
+{"foo": f64}?.greet
+{"foo": f64}?.i
+{"foo": f64}?.ok
+{"foo": false, "foo": greet}?.add
+{"foo": false, "foo": ok}.score
+{"foo": false}.Bar
+{"foo": false}.array
+{"foo": false}.div
+{"foo": false}.half
+{"foo": false}.i
+{"foo": false}?.array
+{"foo": false}?.f32
+{"foo": false}?.f64
+{"foo": false}?.foo
+{"foo": false}?.i64
+{"foo": false}?.list
+{"foo": foo, "bar": add, "foo": foo}.Bar
+{"foo": foo, "bar": ok, "foo": array}.String
+{"foo": foo, "foo": foo}
+{"foo": foo, "foo": list, "foo": greet}.i
+{"foo": foo, "foo": nil}?.f32
+{"foo": foo, "foo": true}?.array
+{"foo": foo?.Qux}
+{"foo": foo}
+{"foo": foo}.div
+{"foo": foo}.f64
+{"foo": foo}.greet
+{"foo": foo}.list
+{"foo": foo}.ok
+{"foo": foo}.score
+{"foo": foo}?.String
+{"foo": foo}?.array
+{"foo": foo}?.div
+{"foo": foo}?.f32
+{"foo": foo}?.foo
+{"foo": foo}?.greet
+{"foo": foo}?.half
+{"foo": foo}?.list
+{"foo": foo}?.ok
+{"foo": get(array, i32)}?.i64
+{"foo": greet, "bar": 0.5, "bar": "foo"}?.half
+{"foo": greet, "bar": 0.5}.Bar
+{"foo": greet, "bar": f64}
+{"foo": greet, "bar": f64}.list
+{"foo": greet, "bar": i, "foo": foo}?.f32
+{"foo": greet, "foo": "bar", "foo": score}.i
+{"foo": greet, "foo": f32}
+{"foo": greet}
+{"foo": greet}.Qux
+{"foo": greet}.String
+{"foo": greet}.add
+{"foo": greet}.array
+{"foo": greet}.f32?.greet
+{"foo": greet}.half?.greet
+{"foo": greet}.i64
+{"foo": greet}.list
+{"foo": greet}.ok
+{"foo": greet}?.add
+{"foo": greet}?.array
+{"foo": greet}?.f32
+{"foo": greet}?.half
+{"foo": greet}?.i32
+{"foo": greet}?.i64
+{"foo": greet}?.list
+{"foo": greet}?.score
+{"foo": half(0.5)}
+{"foo": half(f64)}
+{"foo": half, "bar": 1}?.half
+{"foo": half, "bar": add}?.foo
+{"foo": half, "bar": f32}.i32
+{"foo": half, "bar": foo}
+{"foo": half, "bar": half}
+{"foo": half, "bar": i64, "bar": i32}.foo
+{"foo": half, "bar": i64}
+{"foo": half, "bar": nil}?.ok
+{"foo": half, "foo": 1}?.ok
+{"foo": half, "foo": div}
+{"foo": half, "foo": greet, "bar": f32}?.add
+{"foo": half, "foo": true}.f64
+{"foo": half}
+{"foo": half}.Bar
+{"foo": half}.String
+{"foo": half}.div
+{"foo": half}.f64
+{"foo": half}.greet
+{"foo": half}.half
+{"foo": half}.i
+{"foo": half}.i32
+{"foo": half}.ok
+{"foo": half}?.Bar
+{"foo": half}?.Qux
+{"foo": half}?.add
+{"foo": half}?.f64
+{"foo": half}?.foo
+{"foo": half}?.greet
+{"foo": half}?.half
+{"foo": half}?.list
+{"foo": half}?.score
+{"foo": hasPrefix("bar", "foo")}
+{"foo": i < f64}
+{"foo": i > 0.5}
+{"foo": i, "bar": score}
+{"foo": i, "foo": i}.i64
+{"foo": i, "foo": ok}
+{"foo": i, "foo": ok}?.ok
+{"foo": i32, "bar": 0.5, "foo": array}.Bar
+{"foo": i32, "bar": i32}.i64
+{"foo": i32, "bar": nil}?.i64
+{"foo": i32, "foo": 0.5}.i
+{"foo": i32, "foo": add}
+{"foo": i32, "foo": div, "foo": nil}.Bar
+{"foo": i32, "foo": foo}
+{"foo": i32, "foo": greet}?.foo
+{"foo": i32, "foo": i32}?.score
+{"foo": i32, "foo": ok, "bar": true}.f32
+{"foo": i32, "foo": ok}?.i32
+{"foo": i32}
+{"foo": i32}.Bar
+{"foo": i32}.Qux
+{"foo": i32}.i64
+{"foo": i32}.list
+{"foo": i32}.ok
+{"foo": i32}.score
+{"foo": i32}?.Bar
+{"foo": i32}?.Qux
+{"foo": i32}?.add
+{"foo": i32}?.div
+{"foo": i32}?.f32
+{"foo": i32}?.greet
+{"foo": i32}?.half
+{"foo": i32}?.i
+{"foo": i32}?.i64
+{"foo": i32}?.score
+{"foo": i64 * f64, "foo": i64}
+{"foo": i64 <= 0.5}
+{"foo": i64 ^ i32}
+{"foo": i64, "bar": "bar"}.Qux
+{"foo": i64, "bar": array}.add
+{"foo": i64, "bar": div}
+{"foo": i64, "bar": f64, "bar": greet}.f32
+{"foo": i64, "bar": list}
+{"foo": i64, "foo": 0.5, "bar": 0.5}.half
+{"foo": i64, "foo": div}
+{"foo": i64, "foo": i32}
+{"foo": i64}
+{"foo": i64}.Qux
+{"foo": i64}.add
+{"foo": i64}.array
+{"foo": i64}?.Qux
+{"foo": i64}?.String
+{"foo": i64}?.f32
+{"foo": i64}?.foo
+{"foo": i64}?.greet
+{"foo": i64}?.i32
+{"foo": i64}?.list
+{"foo": i64}?.score
+{"foo": i}
+{"foo": i}.Bar
+{"foo": i}.String
+{"foo": i}.div
+{"foo": i}.foo
+{"foo": i}.greet
+{"foo": i}.i32?.add
+{"foo": i}.ok
+{"foo": i}.score
+{"foo": i}?.Bar
+{"foo": i}?.array
+{"foo": i}?.div
+{"foo": i}?.f64
+{"foo": i}?.foo
+{"foo": i}?.half
+{"foo": i}?.i64
+{"foo": i}?.score
+{"foo": list == list}.f32
+{"foo": list, "bar": f32, "foo": i32}.i32
+{"foo": list, "bar": foo}?.list
+{"foo": list, "bar": i64}
+{"foo": list, "bar": score}
+{"foo": list, "foo": score}
+{"foo": list}
+{"foo": list}.Bar
+{"foo": list}.String
+{"foo": list}.add
+{"foo": list}.div
+{"foo": list}.foo
+{"foo": list}.half
+{"foo": list}.i32
+{"foo": list}.score
+{"foo": list}?.add
+{"foo": list}?.div
+{"foo": list}?.i
+{"foo": list}?.i64
+{"foo": list}?.ok
+{"foo": map(array, #)}
+{"foo": map(array, 0.5)}
+{"foo": map(array, foo)}
+{"foo": map(array, ok), "bar": i32}
+{"foo": map(list, 0.5)}
+{"foo": map(list, score)}
+{"foo": min(0.5)}
+{"foo": min(1)}?.f32
+{"foo": nil == 0.5}
+{"foo": nil, "bar": 0.5}.score
+{"foo": nil, "bar": add}?.array
+{"foo": nil, "bar": div}.Bar
+{"foo": nil, "bar": f64, "foo": div}.i32
+{"foo": nil, "bar": greet}?.add
+{"foo": nil, "bar": i64}?.i64
+{"foo": nil, "bar": list}?.i32
+{"foo": nil, "foo": "foo"}.add
+{"foo": nil, "foo": 1}.score
+{"foo": nil, "foo": false}?.add
+{"foo": nil, "foo": i64}.add
+{"foo": nil}.Bar
+{"foo": nil}.Qux
+{"foo": nil}.String
+{"foo": nil}.array
+{"foo": nil}.div
+{"foo": nil}.f32
+{"foo": nil}.f64
+{"foo": nil}.greet?.i()
+{"foo": nil}.greet?.i32
+{"foo": nil}.half
+{"foo": nil}.i
+{"foo": nil}.i64
+{"foo": nil}.list
+{"foo": nil}?.Bar
+{"foo": nil}?.Qux
+{"foo": nil}?.String
+{"foo": nil}?.array
+{"foo": nil}?.div
+{"foo": nil}?.f32?.ok
+{"foo": nil}?.greet
+{"foo": nil}?.i32
+{"foo": nil}?.i?.half
+{"foo": nil}?.list
+{"foo": nil}?.list?.greet()
+{"foo": nil}?.score
+{"foo": not false}
+{"foo": not ok}
+{"foo": ok && ok}
+{"foo": ok == nil}
+{"foo": ok ? true : div}
+{"foo": ok, "bar": f32}
+{"foo": ok, "bar": i, "foo": greet}.i32
+{"foo": ok, "bar": i32}
+{"foo": ok, "foo": 0.5}?.array
+{"foo": ok, "foo": 1}.Qux
+{"foo": ok, "foo": half, "bar": div}.score
+{"foo": ok, "foo": i64}
+{"foo": ok, "foo": i64}.i
+{"foo": ok, "foo": nil}?.add
+{"foo": ok}
+{"foo": ok}.Bar
+{"foo": ok}.add
+{"foo": ok}.div
+{"foo": ok}.f64
+{"foo": ok}.greet
+{"foo": ok}.i
+{"foo": ok}.score
+{"foo": ok}?.Qux
+{"foo": ok}?.String
+{"foo": ok}?.div
+{"foo": ok}?.f32
+{"foo": ok}?.greet
+{"foo": ok}?.half?.half
+{"foo": ok}?.i32
+{"foo": ok}?.i64
+{"foo": ok}?.list
+{"foo": score(1)}
+{"foo": score, "bar": 0.5}.list
+{"foo": score, "bar": 1 ^ 1}
+{"foo": score, "bar": i32}
+{"foo": score, "bar": i64}
+{"foo": score, "foo": 0.5}.add
+{"foo": score, "foo": 1}?.div
+{"foo": score, "foo": add, "bar": ok}
+{"foo": score, "foo": f32, "bar": false}.div
+{"foo": score, "foo": f32}?.i32
+{"foo": score, "foo": i}?.f32
+{"foo": score}
+{"foo": score}.Bar
+{"foo": score}.array
+{"foo": score}.list
+{"foo": score}?.Bar
+{"foo": score}?.String
+{"foo": score}?.add
+{"foo": score}?.f32
+{"foo": score}?.greet
+{"foo": score}?.half
+{"foo": score}?.i
+{"foo": score}?.list
+{"foo": score}?.score
+{"foo": string(i32)}
+{"foo": string(list)}
+{"foo": toBase64("bar")}
+{"foo": toJSON(f32)}
+{"foo": toJSON(i64)}?.i32
+{"foo": toJSON(nil)}
+{"foo": true, "bar": false}?.array
+{"foo": true, "bar": nil}?.div
+{"foo": true, "bar": true}.f64
+{"foo": true, "foo": array, "bar": i32}?.ok
+{"foo": true, "foo": i32}.i64
+{"foo": true, "foo": ok, "foo": add}.foo
+{"foo": true}.String
+{"foo": true}.f32
+{"foo": true}.foo
+{"foo": true}.i
+{"foo": true}.i64
+{"foo": true}?.String
+{"foo": true}?.greet
+{"foo": true}?.i32
+{"foo": type(1)}
+{"foo": type(list)}
+{"foo": type(nil)}
+{"foo": type(ok)}

From 3c8c30596c70aaa387c9014fbb2cb3c0bed0814a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 09:39:45 +0200
Subject: [PATCH 130/506] Replace chzyer/readline with bettercap/readline

---
 repl/go.mod  |  3 ++-
 repl/go.sum  | 23 +++--------------------
 repl/repl.go |  2 +-
 3 files changed, 6 insertions(+), 22 deletions(-)

diff --git a/repl/go.mod b/repl/go.mod
index c099d3b85..ea7e9c9b2 100644
--- a/repl/go.mod
+++ b/repl/go.mod
@@ -5,10 +5,11 @@ go 1.20
 require (
 	github.com/antonmedv/expr v1.13.0
 	github.com/antonmedv/expr/debug v0.0.0
-	github.com/chzyer/readline v1.5.1
+	github.com/bettercap/readline v0.0.0-20210228151553-655e48bcb7bf
 )
 
 require (
+	github.com/chzyer/test v1.0.0 // indirect
 	github.com/gdamore/encoding v1.0.0 // indirect
 	github.com/gdamore/tcell/v2 v2.6.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
diff --git a/repl/go.sum b/repl/go.sum
index c6908b013..b584a8acf 100644
--- a/repl/go.sum
+++ b/repl/go.sum
@@ -1,12 +1,10 @@
+github.com/bettercap/readline v0.0.0-20210228151553-655e48bcb7bf h1:pwGPRc5PIp4KCF9QbKn0iLVMhfigUMw4IzGZEZ81m1I=
+github.com/bettercap/readline v0.0.0-20210228151553-655e48bcb7bf/go.mod h1:03rWiUf60r1miMVzMEtgtkq7RdZniecZFw3/Zgvyxcs=
 github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
 github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
-github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
-github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk=
 github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=
 github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
 github.com/gdamore/tcell/v2 v2.6.0 h1:OKbluoP9VYmJwZwq/iLb4BxwKcwGthaa1YNBJIyCySg=
@@ -17,36 +15,25 @@ github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh
 github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
 github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703 h1:ZyM/+FYnpbZsFWuCohniM56kRoHRB4r5EuIzXEYkpxo=
 github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703/go.mod h1:nVwGv4MP47T0jvlk7KuTTjjuSmrGO4JF0iaiNt4bufE=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -66,9 +53,5 @@ golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/repl/repl.go b/repl/repl.go
index b3bb9a00b..1e70feffe 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -9,7 +9,7 @@ import (
 	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/debug"
 	"github.com/antonmedv/expr/vm"
-	"github.com/chzyer/readline"
+	"github.com/bettercap/readline"
 )
 
 var keywords = []string{

From e67d2edbb744aabda40ea22fef2184fbea120b37 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 09:55:05 +0200
Subject: [PATCH 131/506] Update fuzz testing

---
 test/fuzz/fuzz_corpus.txt           | 16445 +++++++++++++++++++++++++-
 test/fuzz/fuzz_expr.dict            |    47 +-
 test/fuzz/fuzz_expr_seed_corpus.zip |   Bin 11768 -> 2827388 bytes
 test/fuzz/fuzz_test.go              |    67 +-
 4 files changed, 16445 insertions(+), 114 deletions(-)

diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
index 43b3f7e4a..f427f787d 100644
--- a/test/fuzz/fuzz_corpus.txt
+++ b/test/fuzz/fuzz_corpus.txt
@@ -1,73 +1,16376 @@
-.5 + .5
-i + j
-i - j
-i * j
-i / j
-i % j
-true || false
-true && false
-i == j
-i != j
-i > j
-i >= j
-i < j
-i <= j
-i in a
-i not in a
-s in m
-m.a
-m.m.a
-a[0]
-a[i]
-a[i:j]
-a[i:]
-a[:j]
-a[:]
-a[1:-1]
-len(a)
-type(a)
+!!!true
+!!(f32 > f64)
+!!(half != greet)
+!!(nil == add)
+!!(ok or true)
+!!false
+!!not false
+!!ok
+!!true
+!("bar" != "bar")
+!("bar" != "foo")
+!("bar" != nil)
+!("bar" < "bar")
+!("bar" < "foo")
+!("bar" <= "bar")
+!("bar" <= "foo")
+!("bar" == "bar")
+!("bar" == "foo")
+!("bar" == nil)
+!("bar" > "bar")
+!("bar" > "foo")
+!("bar" >= "bar")
+!("bar" >= "foo")
+!("bar" contains "foo")
+!("bar" in foo)
+!("bar" matches "foo")
+!("bar" not contains "bar")
+!("bar" not contains "foo")
+!("bar" not endsWith "foo")
+!("bar" not in foo)
+!("bar" not matches "foo")
+!("bar" not startsWith "bar")
+!("bar" not startsWith "foo")
+!("bar" startsWith "bar")
+!("foo" != "bar")
+!("foo" != "foo")
+!("foo" != nil)
+!("foo" < "bar")
+!("foo" <= "bar")
+!("foo" <= "foo")
+!("foo" == "foo")
+!("foo" == nil)
+!("foo" > "bar")
+!("foo" > "foo")
+!("foo" >= "bar")
+!("foo" >= "foo")
+!("foo" contains "bar")
+!("foo" contains "foo")
+!("foo" endsWith "bar")
+!("foo" endsWith "foo")
+!("foo" in foo)
+!("foo" matches "bar")
+!("foo" matches "foo")
+!("foo" not contains "bar")
+!("foo" not contains "foo")
+!("foo" not endsWith "bar")
+!("foo" not endsWith "foo")
+!("foo" not in foo)
+!("foo" not matches "bar")
+!("foo" not matches "foo")
+!("foo" not startsWith "bar")
+!("foo" not startsWith "foo")
+!("foo" startsWith "bar")
+!("foo" startsWith "foo")
+!(0.5 != 0.5)
+!(0.5 != 1)
+!(0.5 != f32)
+!(0.5 != f64)
+!(0.5 != i)
+!(0.5 != i32)
+!(0.5 != i64)
+!(0.5 != nil)
+!(0.5 / i32 > i)
+!(0.5 < 0.5)
+!(0.5 < 1)
+!(0.5 < f32)
+!(0.5 < f64)
+!(0.5 < i)
+!(0.5 < i32)
+!(0.5 < i64)
+!(0.5 <= 0.5)
+!(0.5 <= 1)
+!(0.5 <= f32)
+!(0.5 <= i)
+!(0.5 <= i32)
+!(0.5 <= i64)
+!(0.5 == 0.5)
+!(0.5 == 1)
+!(0.5 == f32)
+!(0.5 == f64)
+!(0.5 == i)
+!(0.5 == i32)
+!(0.5 == i64)
+!(0.5 == nil)
+!(0.5 > 0.5)
+!(0.5 > 1)
+!(0.5 > f32)
+!(0.5 > f64)
+!(0.5 > i)
+!(0.5 > i32)
+!(0.5 > i64)
+!(0.5 >= 0.5)
+!(0.5 >= 1)
+!(0.5 >= f32)
+!(0.5 >= f64)
+!(0.5 >= i)
+!(0.5 >= i32)
+!(0.5 >= i64)
+!(0.5 ^ i64 < i64)
+!(1 != 0.5)
+!(1 != 1)
+!(1 != f32)
+!(1 != f64)
+!(1 != i)
+!(1 != i32)
+!(1 != i64)
+!(1 != nil)
+!(1 < 0.5)
+!(1 < 1)
+!(1 < f32)
+!(1 < f64)
+!(1 < i)
+!(1 < i32)
+!(1 < i64)
+!(1 <= 0.5)
+!(1 <= 1)
+!(1 <= f32)
+!(1 <= f64)
+!(1 <= i)
+!(1 <= i32)
+!(1 <= i64)
+!(1 == 0.5)
+!(1 == 1)
+!(1 == f32)
+!(1 == f64)
+!(1 == i)
+!(1 == i32)
+!(1 == i64)
+!(1 == nil)
+!(1 > 0.5)
+!(1 > 1)
+!(1 > f64)
+!(1 > i)
+!(1 > i32)
+!(1 > i64)
+!(1 >= 0.5)
+!(1 >= 1)
+!(1 >= f32)
+!(1 >= f64)
+!(1 >= i)
+!(1 >= i32)
+!(1 >= i64)
+!(1 in array)
+!(1 not in array)
+!(add != add)
+!(add != div)
+!(add != greet)
+!(add != half)
+!(add != nil)
+!(add != score)
+!(add == add)
+!(add == div)
+!(add == half)
+!(add == nil)
+!(add == score)
+!(array != array)
+!(array != nil)
+!(array == array)
+!(array == list)
+!(array == nil)
+!(div != add)
+!(div != div)
+!(div != greet)
+!(div != half)
+!(div != nil)
+!(div != score)
+!(div == add)
+!(div == div)
+!(div == greet)
+!(div == half)
+!(div == nil)
+!(div == score)
+!(f32 != 0.5)
+!(f32 != 1)
+!(f32 != f32)
+!(f32 != i32)
+!(f32 != i64)
+!(f32 != nil)
+!(f32 + i == 0.5 * i)
+!(f32 < 0.5)
+!(f32 < 1)
+!(f32 < f32)
+!(f32 < f64)
+!(f32 < i)
+!(f32 < i32)
+!(f32 < i64)
+!(f32 <= 0.5)
+!(f32 <= 1)
+!(f32 <= f32)
+!(f32 <= f64)
+!(f32 <= i)
+!(f32 <= i32)
+!(f32 <= i64)
+!(f32 == 0.5)
+!(f32 == 1)
+!(f32 == f32)
+!(f32 == f64)
+!(f32 == i)
+!(f32 == i32)
+!(f32 == i64)
+!(f32 == nil)
+!(f32 > 0.5)
+!(f32 > 1)
+!(f32 > f32)
+!(f32 > f64)
+!(f32 > i)
+!(f32 > i32)
+!(f32 > i64)
+!(f32 >= 0.5)
+!(f32 >= 1)
+!(f32 >= f32)
+!(f32 >= f64)
+!(f32 >= i)
+!(f32 >= i64)
+!(f64 != 0.5)
+!(f64 != 1)
+!(f64 != f32)
+!(f64 != f64)
+!(f64 != i32)
+!(f64 != i64)
+!(f64 != nil)
+!(f64 < 0.5)
+!(f64 < 1)
+!(f64 < f32)
+!(f64 < f64)
+!(f64 < i)
+!(f64 < i32)
+!(f64 < i64)
+!(f64 <= 0.5)
+!(f64 <= 1)
+!(f64 <= f32)
+!(f64 <= f64)
+!(f64 <= i)
+!(f64 <= i32)
+!(f64 <= i64)
+!(f64 == 0.5)
+!(f64 == 1)
+!(f64 == f32)
+!(f64 == i32)
+!(f64 == i64)
+!(f64 == nil)
+!(f64 > 0.5)
+!(f64 > 1)
+!(f64 > f64)
+!(f64 > i32)
+!(f64 > i64)
+!(f64 >= 0.5)
+!(f64 >= 1)
+!(f64 >= f32)
+!(f64 >= f64)
+!(f64 >= i)
+!(f64 >= i32)
+!(f64 >= i64)
+!(false != false)
+!(false != nil)
+!(false != ok)
+!(false != true)
+!(false && false)
+!(false && ok)
+!(false == false)
+!(false == nil)
+!(false == ok)
+!(false and ok)
+!(false or ok)
+!(false or true)
+!(false || false)
+!(false || ok)
+!(false || true)
+!(foo != foo)
+!(foo != nil)
+!(foo == foo)
+!(foo == nil)
+!(foo in list)
+!(foo not in list)
+!(greet != div)
+!(greet != greet)
+!(greet != half)
+!(greet != nil)
+!(greet != score)
+!(greet == add)
+!(greet == div)
+!(greet == greet)
+!(greet == half)
+!(greet == nil)
+!(greet == score)
+!(half != add)
+!(half != div)
+!(half != greet)
+!(half != half)
+!(half != nil)
+!(half != score)
+!(half == add)
+!(half == div)
+!(half == greet)
+!(half == half)
+!(half == nil)
+!(half == score)
+!(i != 0.5)
+!(i != 1)
+!(i != f32)
+!(i != f64)
+!(i != i)
+!(i != i32)
+!(i != i64)
+!(i != nil)
+!(i < 0.5)
+!(i < 1)
+!(i < f32)
+!(i < f64)
+!(i < i)
+!(i < i32)
+!(i < i64)
+!(i <= 0.5)
+!(i <= 1)
+!(i <= f32)
+!(i <= f64)
+!(i <= i)
+!(i <= i32)
+!(i <= i64)
+!(i == 0.5)
+!(i == 1)
+!(i == f32)
+!(i == f64)
+!(i == i)
+!(i == i32)
+!(i == i64)
+!(i == nil)
+!(i > 0.5)
+!(i > 1)
+!(i > f32)
+!(i > f64)
+!(i > i)
+!(i > i32)
+!(i > i64)
+!(i >= 0.5)
+!(i >= 1)
+!(i >= f32)
+!(i >= f64)
+!(i >= i32)
+!(i >= i64)
+!(i in array)
+!(i32 != 0.5)
+!(i32 != 1)
+!(i32 != f64)
+!(i32 != i)
+!(i32 != i32)
+!(i32 != i64)
+!(i32 != nil)
+!(i32 * 0.5 != i32)
+!(i32 < 0.5)
+!(i32 < 1)
+!(i32 < f32)
+!(i32 < f64)
+!(i32 < i)
+!(i32 < i32)
+!(i32 < i64)
+!(i32 <= 0.5)
+!(i32 <= 1)
+!(i32 <= f32)
+!(i32 <= f64)
+!(i32 <= i)
+!(i32 <= i32)
+!(i32 <= i64)
+!(i32 == 0.5)
+!(i32 == 1)
+!(i32 == f64)
+!(i32 == i)
+!(i32 == i32)
+!(i32 == i64)
+!(i32 == nil)
+!(i32 > 0.5)
+!(i32 > 1)
+!(i32 > f64)
+!(i32 > i)
+!(i32 > i32)
+!(i32 > i64)
+!(i32 >= 0.5)
+!(i32 >= 1)
+!(i32 >= f32)
+!(i32 >= f64)
+!(i32 >= i)
+!(i32 >= i32)
+!(i32 >= i64)
+!(i32 in array)
+!(i32 not in array)
+!(i64 != 0.5)
+!(i64 != 1)
+!(i64 != f32)
+!(i64 != f64)
+!(i64 != i)
+!(i64 != i32)
+!(i64 != nil)
+!(i64 < 0.5)
+!(i64 < 1)
+!(i64 < f32)
+!(i64 < f64)
+!(i64 < i)
+!(i64 < i32)
+!(i64 < i64)
+!(i64 <= 0.5)
+!(i64 <= 1)
+!(i64 <= f32)
+!(i64 <= f64)
+!(i64 <= i)
+!(i64 <= i32)
+!(i64 <= i64)
+!(i64 == 0.5)
+!(i64 == 1)
+!(i64 == f32)
+!(i64 == f64)
+!(i64 == i)
+!(i64 == i32)
+!(i64 == nil)
+!(i64 > 0.5)
+!(i64 > 1)
+!(i64 > f32)
+!(i64 > f64)
+!(i64 > i)
+!(i64 > i32)
+!(i64 > i64)
+!(i64 >= 0.5)
+!(i64 >= 1)
+!(i64 >= f32)
+!(i64 >= f64)
+!(i64 >= i)
+!(i64 >= i32)
+!(i64 in array)
+!(i64 not in array)
+!(list != array)
+!(list != list)
+!(list != nil)
+!(list == array)
+!(list == list)
+!(list == nil)
+!(nil != "bar")
+!(nil != "foo")
+!(nil != 0.5)
+!(nil != 1)
+!(nil != add)
+!(nil != array)
+!(nil != div)
+!(nil != f32)
+!(nil != f64)
+!(nil != false)
+!(nil != foo)
+!(nil != greet)
+!(nil != half)
+!(nil != i)
+!(nil != i32)
+!(nil != i64)
+!(nil != list)
+!(nil != nil)
+!(nil != ok)
+!(nil != score)
+!(nil != true)
+!(nil == "bar")
+!(nil == "foo")
+!(nil == 0.5)
+!(nil == 1)
+!(nil == array)
+!(nil == div)
+!(nil == f32)
+!(nil == f64)
+!(nil == foo)
+!(nil == greet)
+!(nil == half)
+!(nil == i)
+!(nil == i32)
+!(nil == i64)
+!(nil == list)
+!(nil == nil)
+!(nil == ok)
+!(nil == score)
+!(nil == true)
+!(nil in array)
+!(nil in list)
+!(nil not in array)
+!(nil not in list)
+!(ok != false)
+!(ok != nil)
+!(ok != ok)
+!(ok != true)
+!(ok && false)
+!(ok && ok)
+!(ok && true)
+!(ok == false)
+!(ok == nil)
+!(ok == ok)
+!(ok and ok)
+!(ok and true)
+!(ok or ok)
+!(ok || false)
+!(ok || ok)
+!(score != add)
+!(score != div)
+!(score != greet)
+!(score != half)
+!(score != nil)
+!(score != score)
+!(score == add)
+!(score == div)
+!(score == greet)
+!(score == half)
+!(score == nil)
+!(true != false)
+!(true != nil)
+!(true != ok)
+!(true != true)
+!(true && false)
+!(true && ok)
+!(true && true)
+!(true == false)
+!(true == nil)
+!(true == ok)
+!(true == true)
+!(true and false)
+!(true and ok)
+!(true and true)
+!(true or true)
+!(true || ok)
+!(true || true)
+!all(array, false)
+!all(array, ok)
+!all(array, true)
+!all(list, false)
+!all(list, ok)
+!all(list, true)
+!any(array, false)
+!any(array, ok)
+!any(array, true)
+!any(list, # != #)
+!any(list, ok)
+!false && ok
+!false ? "bar" : i
+!false ? "foo" : false
+!false ? 0.5 : "bar"
+!false ? 0.5 : 1
+!false ? 0.5 : div
+!false ? 0.5 : i64
+!false ? 1 : add
+!false ? 1 : true
+!false ? add : array
+!false ? add : nil
+!false ? array : array
+!false ? div : 0.5
+!false ? div : foo
+!false ? div : map(list, #)
+!false ? div : nil
+!false ? f32 : 0.5
+!false ? f32 : greet
+!false ? f64 : 1
+!false ? f64 : half
+!false ? false : f32
+!false ? false : false
+!false ? foo : 1
+!false ? foo : i64
+!false ? greet : array
+!false ? greet : i32
+!false ? half : nil
+!false ? half : ok
+!false ? i : foo
+!false ? i32 : "foo"
+!false ? i64 : f32
+!false ? i64 : nil
+!false ? list : list
+!false ? nil : 1
+!false ? nil : add
+!false ? nil : f64
+!false ? nil : foo
+!false ? ok : ok
+!false ? true : array
+!false and (true or false)
+!false and ok
+!false or 0.5 != 1
+!false || not false
+!hasSuffix("bar", "bar")
+!none(array, false)
+!none(array, true)
+!none(list, false)
+!none(list, ok)
+!none(list, true)
+!not (1 != i)
+!not (i64 != 0.5)
+!not any(list, ok)
+!not false
+!not ok
+!not true
+!not true ? i64 : true
+!ok
+!ok != ok
+!ok && (ok || ok)
+!ok == !ok
+!ok == ok
+!ok ? "bar" : 0.5
+!ok ? "foo" : nil
+!ok ? 0.5 : "foo"
+!ok ? 1 : 0.5
+!ok ? 1 : 1
+!ok ? 1 : div
+!ok ? 1 : foo
+!ok ? 1 : greet
+!ok ? 1 : ok
+!ok ? add : f32
+!ok ? add : false
+!ok ? add : i
+!ok ? add : score
+!ok ? f32 : "foo"
+!ok ? f32 : 1
+!ok ? f64 : i
+!ok ? false : "foo"
+!ok ? false : half
+!ok ? greet : "bar"
+!ok ? greet : add
+!ok ? greet : false
+!ok ? half : array
+!ok ? i : foo
+!ok ? i : greet
+!ok ? i : true
+!ok ? i64 : list
+!ok ? list : "foo"
+!ok ? list : true
+!ok ? nil : i
+!ok ? nil : true
+!ok ? ok : 1
+!ok ? ok : i64
+!ok ? ok : score
+!ok ? score : array
+!ok ? score : i
+!ok ? true : greet
+!ok and i != f32
+!ok and ok
+!ok or none(array, ok)
+!one(array, ok)
+!one(array, true)
+!one(list, false)
+!one(list, ok)
+!one(list, true)
+!true != false ? ok : 0.5
+!true != nil == nil
+!true != ok
+!true && ok
+!true == ok
+!true ? "bar" : false
+!true ? "bar" : i
+!true ? "foo" : ok
+!true ? 0.5 : 1
+!true ? 0.5 : div
+!true ? 0.5 : i
+!true ? add : div
+!true ? add : greet
+!true ? array : foo
+!true ? array : i
+!true ? array : i64
+!true ? array : score
+!true ? div : f32
+!true ? div : ok
+!true ? f32 : 0.5
+!true ? f32 : add
+!true ? f32 : foo
+!true ? f32 : i32
+!true ? f64 : "bar"
+!true ? f64 : f64
+!true ? f64 : i32
+!true ? foo : 1
+!true ? greet : array
+!true ? greet : list
+!true ? half : add
+!true ? half : greet
+!true ? i32 : i64
+!true ? i64 : score
+!true ? list : div
+!true ? list : score
+!true ? nil : 0.5
+!true ? nil : f32
+!true ? nil : f64
+!true ? nil : foo
+!true ? nil : half
+!true ? nil : i
+!true ? ok : list
+!true ? score : array
+!true ? score : nil
+!true and ok
+!true or !false
+!true or nil != ok
+!true || ok
+"bar" != foo.Bar
+"bar" != foo?.Bar
+"bar" != foo?.String()
+"bar" != nil and true ? i64 : 0.5
+"bar" + "foo" not endsWith greet("bar")
+"bar" + foo.Bar
+"bar" + foo?.Bar
+"bar" + foo?.String()
+"bar" < foo.Bar
+"bar" < foo?.Bar
+"bar" <= foo.Bar
+"bar" <= foo.String()
+"bar" <= foo?.Bar
+"bar" == foo.Bar
+"bar" == foo?.Bar
+"bar" > foo.Bar
+"bar" > foo.String()
+"bar" > foo?.Bar
+"bar" contains "bar" == ok
+"bar" contains "foo" ? array : f64
+"bar" contains foo.Bar
+"bar" contains foo?.Bar
+"bar" contains foo?.String()
+"bar" endsWith foo.Bar
+"bar" endsWith foo?.Bar
+"bar" endsWith foo?.String()
+"bar" in foo || ok
+"bar" matches "bar" != ok
+"bar" matches foo.Bar
+"bar" matches foo?.Bar
+"bar" not contains foo.Bar
+"bar" not contains foo.String()
+"bar" not contains foo?.Bar
+"bar" not endsWith foo.Bar
+"bar" not endsWith foo?.Bar
+"bar" not endsWith foo?.String()
+"bar" not in list[i]
+"bar" not matches "foo" ? i32 < 0.5 : ok
+"bar" not matches foo.Bar
+"bar" not matches foo.String()
+"bar" not matches foo?.Bar
+"bar" not startsWith "foo" ? add : ok
+"bar" not startsWith foo.Bar
+"bar" not startsWith foo?.Bar
+"bar" startsWith foo.Bar
+"bar" startsWith foo?.Bar
+"foo" != "bar" != ok
+"foo" != foo.Bar
+"foo" != foo?.Bar
+"foo" != foo?.String()
+"foo" + "foo" not in foo
+"foo" + foo.Bar
+"foo" + foo.String()
+"foo" + foo?.Bar
+"foo" + foo?.String()
+"foo" < "bar" and i32 != 0.5
+"foo" < "foo" ? list : f32
+"foo" < foo.Bar
+"foo" < foo?.Bar
+"foo" <= foo.Bar
+"foo" <= foo?.Bar
+"foo" == "foo" && i32 > 1
+"foo" == foo.Bar
+"foo" == foo.String()
+"foo" == foo?.String()
+"foo" == nil ? foo : f64
+"foo" > "bar" && ok
+"foo" > "foo" == not false
+"foo" > foo?.Bar
+"foo" > foo?.String()
+"foo" >= foo.Bar
+"foo" >= foo?.Bar
+"foo" contains foo.Bar
+"foo" contains foo?.Bar
+"foo" endsWith foo.Bar
+"foo" endsWith foo.String()
+"foo" endsWith foo?.Bar
+"foo" endsWith foo?.String()
+"foo" in foo && nil == 1
+"foo" matches "bar" ? f64 > f64 : half
+"foo" matches foo.Bar
+"foo" matches foo.String()
+"foo" matches foo?.Bar
+"foo" not contains foo.Bar
+"foo" not contains foo?.Bar
+"foo" not endsWith foo.Bar
+"foo" not endsWith foo?.Bar
+"foo" not endsWith foo?.String()
+"foo" not matches foo.Bar
+"foo" not matches foo.String()
+"foo" not matches foo?.Bar
+"foo" not startsWith foo.Bar
+"foo" not startsWith foo?.String()
+"foo" startsWith foo.Bar
+"foo" startsWith foo?.Bar
+"foo" startsWith foo?.String()
+("bar" not endsWith "bar") and i64 < i32
+("bar" not endsWith "foo") == ok
+("bar" not in foo) == ok
+("foo" not matches "bar") and false ? f64 : array
+(0.5 * 0.5) ** f32
+(0.5 * 0.5) ** i
+(0.5 * 0.5) ** i64
+(0.5 * 0.5) ^ f32
+(0.5 * 0.5) ^ i32
+(0.5 * f32) ** i
+(0.5 * f64) ^ f32
+(0.5 * i32) ** f32
+(0.5 + 1) * i
+(0.5 + 1) ** i64
+(0.5 + 1) / i
+(0.5 + i64) / f32
+(0.5 - 0.5) ^ half(f64)
+(0.5 - 1) * i64
+(0.5 - 1) ** i64
+(0.5 - f32) ** (0.5 * f64)
+(0.5 - f64) * f64
+(0.5 - f64) / f32
+(0.5 - i) ^ f32
+(0.5 - i32) ** i64
+(0.5 - i32) ^ f64
+(0.5 / 0.5) ^ f64
+(0.5 / f32) ** f32
+(0.5 / f32) ^ i32
+(0.5 / f64) ** i
+(0.5 / f64) ** i32
+(0.5 / i32) ** i
+(0.5 / i64) ** f32
+(1 % i) ** f32
+(1 % i) ^ i
+(1 % i64) ** f32
+(1 * 1) ** f64
+(1 * 1) ^ i
+(1 * f32) ** f32
+(1 * i32) ** i
+(1 * i64) ** i32
+(1 + 0.5) * f64
+(1 + 0.5) ^ i32
+(1 + 1) / i32
+(1 + 1) ^ i
+(1 + f32) / f32 / i64
+(1 + f64) ** i64
+(1 + f64) / i32
+(1 + f64) ^ f64
+(1 + i32) / f32
+(1 + i64) / f64
+(1 - 0.5) / f64
+(1 - 0.5) ^ i32
+(1 - 1) * i
+(1 - 1) * i32
+(1 - 1) ** f32
+(1 - 1) / i
+(1 - f64) * 1 * i
+(1 - f64) ^ i32
+(1 - i) ** i
+(1 - i) / i64
+(1 - i32) ** i ^ 0.5
+(1 - i64) % i64
+(1 / 0.5) ^ f32
+(1 / 0.5) ^ f64
+(1 / 1) ** i32
+(1 / 1) ^ i32
+(1 / f64) ** f64
+(1 / i) ** i64
+(1 not in array) and none(list, true)
+(f32 * 1) ** f32
+(f32 * 1) ** i64
+(f32 * i) ^ i64
+(f32 * i32) ** i
+(f32 * i64) ** i64
+(f32 * i64) ^ i
+(f32 + 0.5) / 0.5 ** 0.5
+(f32 + 1) ** i
+(f32 + 1) / i
+(f32 + 1) / i64
+(f32 + i32) ** i64
+(f32 + i64) ** i32
+(f32 - 0.5) * f64
+(f32 - 0.5) * i
+(f32 - f32) ** f32
+(f32 - i) / f64
+(f32 - i) ^ i64
+(f32 - i64) * i64
+(f32 - i64) ** i64
+(f32 - i64) / i64
+(f32 / f64) ^ f32
+(f32 / f64) ^ i
+(f32 / i32) ^ i32
+(f64 * 0.5) ^ i
+(f64 * f64) ** i32
+(f64 * i64) ** i32
+(f64 + f32) ** i64
+(f64 + i32) * f32
+(f64 + i64) / i32
+(f64 - 0.5) * -i
+(f64 - 0.5) * i
+(f64 - 0.5) / f32
+(f64 - 0.5) / i64
+(f64 - 0.5) ^ i
+(f64 - 0.5) ^ i64
+(f64 - 1) * f32
+(f64 - f32) * i64
+(f64 - f64) / i32
+(f64 - i) * i32 ** 1
+(f64 - i64) / i64
+(f64 / 0.5) ** f64
+(f64 / i) ^ i64
+(false || ok) and ok
+(i % 1) ** -f32
+(i % 1) ** f64
+(i % i) ** f32
+(i * 1) ** i
+(i * f32) ** i32
+(i * f32) ^ f64
+(i * i) ^ count(array, true)
+(i + 0.5) ** i32
+(i + 0.5) ^ f32
+(i + 1) % i32
+(i + 1) / i64
+(i + f64) ^ (f32 * f64)
+(i + i) * -f64
+(i + i32) ^ i64
+(i - 0.5) / f32
+(i - 0.5) ^ f64
+(i - 1) ** i64
+(i - 1) / f32
+(i - 1) ^ f64
+(i - i64) ** f64
+(i - i64) ^ i
+(i / 0.5) ^ i32
+(i / 1) ** f64
+(i / 1) ** i64
+(i / i32) ^ f32
+(i < i32 ? nil : f64) ** f64
+(i32 * 1) ** f32
+(i32 * f32) ^ i64
+(i32 * i) ^ i
+(i32 * i32) ** f64
+(i32 + 0.5) / f64
+(i32 + 0.5) ^ i64
+(i32 + 1) * f64
+(i32 + 1) ** float(1)
+(i32 + 1) / i
+(i32 + 1) / i64
+(i32 + f32) ** f32
+(i32 + f64) ** i
+(i32 + i32) * i32
+(i32 + i32) / i64
+(i32 + i64) ^ i
+(i32 - 0.5) * i64
+(i32 - f32) * i32
+(i32 - i32) ** i
+(i32 - i32) ** i64
+(i32 / 0.5) ^ i32
+(i32 / i32) ^ f32
+(i32 / i32) ^ i
+(i64 * 0.5) ^ f32
+(i64 * 1) ** i64
+(i64 * 1) ^ f32
+(i64 * 1) ^ f64
+(i64 * f32) ** findIndex(list, ok)
+(i64 + 1) * i32
+(i64 + f32) ^ f64
+(i64 + f64) / 1 * 1
+(i64 + f64) ^ f64
+(i64 + i) ^ i64
+(i64 + i32) * f32
+(i64 - 0.5) * i64
+(i64 - 0.5) / i32
+(i64 - i) % i32
+(i64 - i32) / len(array)
+(i64 - i64) / i64
+(i64 / f64) ** f32
+(i64 / i32) ** f32
+(i64 / i32) ** i
+(i64 / i32) ^ -1
+(i64 not in array) && ok
+(ok && ok) == ok
+(ok or false) and ok
+(ok or ok) == not false
+(ok || true) && i32 >= f64
+-(0.5 * 0.5)
+-(0.5 * 1)
+-(0.5 * f32)
+-(0.5 * f64)
+-(0.5 * i)
+-(0.5 * i32)
+-(0.5 * i64)
+-(0.5 ** 0.5)
+-(0.5 ** 1)
+-(0.5 ** f32)
+-(0.5 ** f64)
+-(0.5 ** i)
+-(0.5 ** i32)
+-(0.5 ** i64)
+-(0.5 + 0.5)
+-(0.5 + 1)
+-(0.5 + f32)
+-(0.5 + f64)
+-(0.5 + i)
+-(0.5 + i32)
+-(0.5 + i64)
+-(0.5 - 0.5)
+-(0.5 - 1)
+-(0.5 - f32)
+-(0.5 - f64)
+-(0.5 - i)
+-(0.5 - i32)
+-(0.5 - i64)
+-(0.5 / 0.5)
+-(0.5 / 0.5) < i32
+-(0.5 / 1)
+-(0.5 / f32)
+-(0.5 / f64)
+-(0.5 / i)
+-(0.5 / i32)
+-(0.5 / i64)
+-(0.5 ^ 0.5)
+-(0.5 ^ 1)
+-(0.5 ^ f32)
+-(0.5 ^ f64)
+-(0.5 ^ i)
+-(0.5 ^ i32)
+-(0.5 ^ i64)
+-(1 % 1)
+-(1 % i)
+-(1 % i32)
+-(1 % i64)
+-(1 * 0.5)
+-(1 * 1)
+-(1 * f32)
+-(1 * i)
+-(1 * i32)
+-(1 * i64)
+-(1 ** 0.5)
+-(1 ** 1)
+-(1 ** f32)
+-(1 ** f64)
+-(1 ** i)
+-(1 ** i32)
+-(1 ** i64)
+-(1 + 0.5)
+-(1 + 1)
+-(1 + f32)
+-(1 + f64)
+-(1 + i)
+-(1 + i32)
+-(1 + i64)
+-(1 - 0.5)
+-(1 - 1)
+-(1 - f32)
+-(1 - f64)
+-(1 - i)
+-(1 - i32)
+-(1 - i64)
+-(1 / 0.5)
+-(1 / 1)
+-(1 / f32)
+-(1 / f64)
+-(1 / i)
+-(1 / i32)
+-(1 / i64)
+-(1 ^ 0.5)
+-(1 ^ 1)
+-(1 ^ f32)
+-(1 ^ f64)
+-(1 ^ i)
+-(1 ^ i32)
+-(1 ^ i64)
+-(f32 * 0.5)
+-(f32 * 1)
+-(f32 * f32)
+-(f32 * f64)
+-(f32 * i)
+-(f32 * i32)
+-(f32 * i64)
+-(f32 ** 0.5)
+-(f32 ** 1)
+-(f32 ** f32)
+-(f32 ** f64)
+-(f32 ** i)
+-(f32 ** i32)
+-(f32 ** i64)
+-(f32 + 0.5)
+-(f32 + 1)
+-(f32 + f32)
+-(f32 + f64)
+-(f32 + i)
+-(f32 + i32)
+-(f32 + i64)
+-(f32 - 0.5)
+-(f32 - 1)
+-(f32 - f64)
+-(f32 - i - f32)
+-(f32 - i)
+-(f32 - i32)
+-(f32 - i64)
+-(f32 / 0.5)
+-(f32 / 1)
+-(f32 / f32)
+-(f32 / f64)
+-(f32 / i)
+-(f32 / i32)
+-(f32 / i64)
+-(f32 ^ 0.5)
+-(f32 ^ 1)
+-(f32 ^ f32)
+-(f32 ^ i)
+-(f32 ^ i32)
+-(f32 ^ i64)
+-(f64 * 0.5)
+-(f64 * 1)
+-(f64 * f32)
+-(f64 * f64)
+-(f64 * i)
+-(f64 * i32)
+-(f64 * i64)
+-(f64 ** 0.5)
+-(f64 ** 1)
+-(f64 ** f32)
+-(f64 ** f64)
+-(f64 ** i)
+-(f64 ** i32)
+-(f64 ** i32) > i32
+-(f64 ** i64)
+-(f64 + 0.5)
+-(f64 + 1)
+-(f64 + f32)
+-(f64 + i)
+-(f64 + i32)
+-(f64 + i64)
+-(f64 - 0.5)
+-(f64 - 1)
+-(f64 - f32)
+-(f64 - f64)
+-(f64 - i)
+-(f64 - i32)
+-(f64 - i64)
+-(f64 / 0.5)
+-(f64 / 1)
+-(f64 / f32)
+-(f64 / f64)
+-(f64 / i)
+-(f64 / i32)
+-(f64 / i64)
+-(f64 ^ 0.5)
+-(f64 ^ 1)
+-(f64 ^ f32)
+-(f64 ^ f64)
+-(f64 ^ i)
+-(f64 ^ i32)
+-(f64 ^ i64)
+-(i % 1)
+-(i % i)
+-(i % i32)
+-(i % i64)
+-(i % score(1))
+-(i * 0.5)
+-(i * 1)
+-(i * f32)
+-(i * f64)
+-(i * i)
+-(i * i32)
+-(i * i64)
+-(i ** 1)
+-(i ** f32)
+-(i ** f64)
+-(i ** i)
+-(i ** i32)
+-(i ** i64)
+-(i ** int(i))
+-(i + 0.5)
+-(i + 1)
+-(i + f32)
+-(i + f64)
+-(i + i)
+-(i + i64)
+-(i - 0.5)
+-(i - 1)
+-(i - f32)
+-(i - f64)
+-(i - i)
+-(i - i32)
+-(i / 0.5)
+-(i / 1)
+-(i / f32)
+-(i / f64)
+-(i / i)
+-(i / i32)
+-(i ^ 0.5)
+-(i ^ 1)
+-(i ^ f32)
+-(i ^ f64)
+-(i ^ i)
+-(i32 % 1 % i)
+-(i32 % 1)
+-(i32 % i)
+-(i32 % i32)
+-(i32 % i64)
+-(i32 * 0.5)
+-(i32 * 1)
+-(i32 * f32)
+-(i32 * f64)
+-(i32 * i)
+-(i32 * i32)
+-(i32 * i64)
+-(i32 ** 0.5)
+-(i32 ** 1)
+-(i32 ** f32)
+-(i32 ** i)
+-(i32 ** i32)
+-(i32 ** i64)
+-(i32 + 0.5)
+-(i32 + 1 ^ i64)
+-(i32 + 1)
+-(i32 + f32)
+-(i32 + f64)
+-(i32 + i)
+-(i32 + i32)
+-(i32 + i64)
+-(i32 - 0.5)
+-(i32 - 1)
+-(i32 - f32)
+-(i32 - f64)
+-(i32 - i)
+-(i32 - i32)
+-(i32 - i64)
+-(i32 / 0.5)
+-(i32 / 1)
+-(i32 / f32)
+-(i32 / f64)
+-(i32 / i)
+-(i32 / i32)
+-(i32 / i64)
+-(i32 ^ 0.5)
+-(i32 ^ 1)
+-(i32 ^ f32)
+-(i32 ^ f64)
+-(i32 ^ i)
+-(i64 % 1)
+-(i64 % i)
+-(i64 % i32)
+-(i64 % i64)
+-(i64 * 0.5)
+-(i64 * 1)
+-(i64 * f32)
+-(i64 * f64)
+-(i64 * i)
+-(i64 * i32)
+-(i64 * i64)
+-(i64 ** 0.5)
+-(i64 ** 1)
+-(i64 ** f32)
+-(i64 ** f64)
+-(i64 ** i)
+-(i64 ** i32)
+-(i64 ** i64)
+-(i64 + 0.5)
+-(i64 + 1)
+-(i64 + f32)
+-(i64 + f64)
+-(i64 + i)
+-(i64 + i32)
+-(i64 + i64)
+-(i64 - 0.5)
+-(i64 - 1)
+-(i64 - f64)
+-(i64 - i)
+-(i64 - i32)
+-(i64 - i64)
+-(i64 / 0.5)
+-(i64 / 1 / 1)
+-(i64 / 1)
+-(i64 / f32)
+-(i64 / f64)
+-(i64 / i)
+-(i64 / i32)
+-(i64 / i64)
+-(i64 ^ 0.5)
+-(i64 ^ 1)
+-(i64 ^ f32)
+-(i64 ^ f64)
+-(i64 ^ i)
+-(i64 ^ i32)
+-(i64 ^ i64)
+-(max(0.5) + i64)
+--(1 * i64)
+--(i64 * 1)
+---1
+---i
+--0.5
+--1
+--abs(f64)
+--f32
+--f64
+--i
+--i32
+--i64
+--max(0.5)
+-0.5 != 1 ? array : f64
+-0.5 != f32
+-0.5 != f64 ** 0.5
+-0.5 != i32
+-0.5 != max(i64)
+-0.5 * f64
+-0.5 * i
+-0.5 * i32
+-0.5 * i64
+-0.5 * len(array)
+-0.5 ** f32
+-0.5 ** i
+-0.5 ** i32
+-0.5 ** i64
+-0.5 + f32
+-0.5 + f64
+-0.5 + f64 / f64
+-0.5 + i
+-0.5 + i32
+-0.5 - -i32
+-0.5 - 1 + 1
+-0.5 - f32
+-0.5 - f64
+-0.5 - i
+-0.5 - i32
+-0.5 - i32 * i
+-0.5 / (f32 + 0.5)
+-0.5 / -i32
+-0.5 / f32
+-0.5 / f64
+-0.5 / float(f64)
+-0.5 / i
+-0.5 / i64
+-0.5 / i64 ** 1
+-0.5 < f32
+-0.5 < f64
+-0.5 < i32
+-0.5 < i32 ? false : "bar"
+-0.5 < i32 ^ f64
+-0.5 <= 1 == false
+-0.5 <= f32
+-0.5 <= f64
+-0.5 <= f64 + f32
+-0.5 <= i64
+-0.5 == f32
+-0.5 == f64 / 0.5
+-0.5 == i
+-0.5 == i32
+-0.5 == i64
+-0.5 > f32
+-0.5 > f64
+-0.5 > i32
+-0.5 > i64
+-0.5 >= f64
+-0.5 >= i
+-0.5 >= i32
+-0.5 >= i64
+-0.5 ^ f32
+-0.5 ^ f64
+-0.5 ^ i
+-0.5 ^ i32
+-0.5 ^ i64
+-1 != f64
+-1 != i
+-1 != i64
+-1 != i64 * f32
+-1 % i32
+-1 % i64
+-1 * 1 ** i64
+-1 * f32
+-1 * i32
+-1 * i64
+-1 ** f32
+-1 ** i
+-1 ** i64
+-1 + 1 + 0.5
+-1 + f32
+-1 + half(f64)
+-1 + i
+-1 + i64
+-1 - f32
+-1 - i
+-1 - i32
+-1 - i64
+-1 .. i
+-1 .. i32
+-1 .. i64
+-1 / 1 * 1
+-1 / f32
+-1 / i32
+-1 < 0.5 ^ i64
+-1 < f32
+-1 < f64 * 1
+-1 < i32
+-1 < i64
+-1 <= f32
+-1 <= f32 == true
+-1 <= f64
+-1 <= i32
+-1 == f32
+-1 == f64
+-1 == nil != nil
+-1 > -i32
+-1 > f32
+-1 > half(0.5)
+-1 > i
+-1 > i32
+-1 > i64
+-1 > i64 ? array : nil
+-1 >= 0.5 * 0.5
+-1 >= f32
+-1 >= f64
+-1 >= i32
+-1 >= i32 - 1
+-1 >= i64
+-1 ^ f32
+-1 ^ f64
+-1 ^ i64
+-1 in array
+-1 not in array
+-abs(0.5 * f64)
+-abs(0.5)
+-abs(1)
+-abs(1) .. i
+-abs(f32)
+-abs(f64)
+-abs(i)
+-abs(i32)
+-abs(i64)
+-add(1, 1)
+-add(i, 1)
+-array[1]
+-array[i32]
+-array[i64]
+-array[i]
+-count(array, false)
+-count(array, ok)
+-count(array, true)
+-count(list, ok)
+-count(list, true)
+-div(1, 1)
+-div(1, i)
+-div(i, i)
+-f32
+-f32 != 1 / i
+-f32 != f32
+-f32 != f64
+-f32 != i64
+-f32 * 1 ** i32
+-f32 * f32
+-f32 ** f32
+-f32 ** f32 ** 1
+-f32 ** i64
+-f32 + f32
+-f32 + i32
+-f32 + i64
+-f32 - f32
+-f32 - f64
+-f32 - i
+-f32 - i32
+-f32 - i64
+-f32 / f32
+-f32 / i32
+-f32 / i64
+-f32 < f64
+-f32 < i32
+-f32 < i64
+-f32 <= i
+-f32 <= i32
+-f32 == f32
+-f32 == f64
+-f32 == i
+-f32 == i32
+-f32 == i64
+-f32 > f32
+-f32 > f64
+-f32 > i
+-f32 > i64
+-f32 >= 1 / f32
+-f32 >= f32
+-f32 >= f64
+-f32 >= i64
+-f32 ^ f32
+-f32 ^ f64
+-f32 ^ i64
+-f32 ^ min(f64)
+-f64
+-f64 != f64
+-f64 != i
+-f64 != i64
+-f64 * f64
+-f64 ** f32
+-f64 ** i32
+-f64 ** i64
+-f64 + f32
+-f64 + i32
+-f64 + i64
+-f64 - 0.5 / i32
+-f64 - f64
+-f64 - i32
+-f64 / f64
+-f64 / i
+-f64 / i64
+-f64 < f32
+-f64 < i
+-f64 <= f32
+-f64 <= f64
+-f64 <= i32
+-f64 == f32
+-f64 == i
+-f64 == i32
+-f64 > f64
+-f64 > i32
+-f64 > i64
+-f64 >= f64
+-f64 >= f64 ^ 0.5
+-f64 >= i
+-f64 ^ 0.5 ** i64
+-f64 ^ f32
+-f64 ^ f64
+-f64 ^ i
+-f64 ^ i32
+-f64 ^ i64
+-find(array, ok)
+-find(array, true)
+-findIndex(array, ok)
+-findIndex(array, true)
+-findIndex(list, ok)
+-findLast(array, ok)
+-findLast(array, true)
+-findLastIndex(array, ok)
+-findLastIndex(array, true)
+-findLastIndex(list, ok)
+-findLastIndex(list, true)
+-first(array)
+-float(-1)
+-float(0.5)
+-float(1)
+-float(f32 ** 0.5)
+-float(f32)
+-float(f64)
+-float(i)
+-float(i32)
+-float(i64)
+-get(array, 1)
+-get(array, i)
+-get(array, i32)
+-get(array, i64)
+-half(-1)
+-half(0.5)
+-half(f64)
+-i
+-i != f64
+-i != i32
+-i != i32 * 1
+-i != i64
+-i % i
+-i % i32
+-i % i64
+-i * f32
+-i * f64
+-i * i32
+-i * i64
+-i ** f32
+-i ** f64
+-i ** i32
+-i ** i64
+-i + f32
+-i + i
+-i + i32
+-i + i64
+-i - f32
+-i - f64
+-i - i
+-i - i64
+-i .. i32
+-i / f64
+-i / i
+-i / i32
+-i / i64
+-i < f32
+-i < i64
+-i <= f32
+-i <= i32
+-i == -0.5
+-i == 1 ** f64
+-i == 1 + 0.5
+-i > f32
+-i > i
+-i > i32
+-i >= f32
+-i >= i32
+-i ^ -i
+-i ^ f64
+-i ^ i32
+-i not in array
+-i32
+-i32 != f32
+-i32 != f64
+-i32 != i
+-i32 != i64
+-i32 % i32
+-i32 % i64
+-i32 * f32
+-i32 * f64
+-i32 * i
+-i32 * i32
+-i32 ** f64
+-i32 ** i32
+-i32 ** i64
+-i32 + 1 + i
+-i32 + f32
+-i32 + f64
+-i32 + i
+-i32 + i32
+-i32 - i32
+-i32 - i64
+-i32 .. i
+-i32 .. i64
+-i32 / (i32 - f64)
+-i32 / f64
+-i32 / i
+-i32 < 0.5 * 1
+-i32 < f32
+-i32 < f64 - f64
+-i32 < i32
+-i32 < i64
+-i32 <= 0.5 ? f64 : 1
+-i32 <= f32
+-i32 <= f64
+-i32 <= f64 + i
+-i32 == f32
+-i32 == i32
+-i32 > i
+-i32 > i32
+-i32 > i64
+-i32 >= f32
+-i32 >= f64
+-i32 >= i64
+-i32 ^ (i - 0.5)
+-i32 ^ i
+-i32 ^ i32
+-i32 ^ i64
+-i32 ^ i64 ** i32
+-i32 in array
+-i32 not in array
+-i64
+-i64 != i
+-i64 != i ? i : foo
+-i64 != i64
+-i64 % i
+-i64 % i32
+-i64 * f32
+-i64 * f64
+-i64 * i
+-i64 * i32
+-i64 * i64
+-i64 ** f64
+-i64 ** i64
+-i64 + 0.5 * i32
+-i64 + f64
+-i64 + i
+-i64 - f32
+-i64 - f64
+-i64 - i32
+-i64 - i64
+-i64 .. i
+-i64 .. i32
+-i64 / f32
+-i64 / i
+-i64 / i64
+-i64 / i64 * f32
+-i64 < -0.5
+-i64 < f32
+-i64 < f64
+-i64 < i
+-i64 < i32
+-i64 < i64
+-i64 <= i32
+-i64 <= i64
+-i64 == f32
+-i64 == i
+-i64 == i32
+-i64 == i64
+-i64 > f32
+-i64 > f64
+-i64 > i32
+-i64 >= i
+-i64 >= i32
+-i64 >= i64
+-i64 ^ f64
+-i64 ^ i32
+-i64 ^ i64
+-i64 not in array
+-i64 not in sort(array)
+-int(0.5)
+-int(1)
+-int(f32)
+-int(f64)
+-int(i)
+-int(i32)
+-int(i64 - i)
+-int(i64)
+-int(int(1))
+-last(array)
+-len("bar")
+-len("foo")
+-len([foo])
+-len(array)
+-len(false ? greet : "foo")
+-len(list)
+-max(0.5 * i)
+-max(0.5)
+-max(0.5, 1)
+-max(1)
+-max(f32)
+-max(f32, 0.5, f32)
+-max(f32, i64)
+-max(f64)
+-max(i)
+-max(i, 1)
+-max(i, i64)
+-max(i32)
+-max(i32, 0.5)
+-max(i64)
+-max(score(1))
+-min(0.5)
+-min(0.5, 1)
+-min(0.5, i32)
+-min(1)
+-min(1, f32)
+-min(f32)
+-min(f32, 0.5)
+-min(f64)
+-min(f64, 0.5)
+-min(f64, f32)
+-min(f64, i64)
+-min(i)
+-min(i, i)
+-min(i32)
+-min(i32, 1)
+-min(i32, f64)
+-min(i64)
+-min(i64, f32)
+-min(i64, f64)
+-score(1)
+-score(1, 1)
+-score(1, i)
+-score(i)
+-score(i, 1)
+-score(i32 * i)
+0.5 != 0.5 ? f64 : half
+0.5 != 0.5 ? i64 : f64
+0.5 != 0.5 ? list : array
+0.5 != 0.5 or ok
+0.5 != f32 || 0.5 > 0.5
+0.5 != i && i64 > 1
+0.5 != i64 != ok
+0.5 != i64 ? -f32 : add
+0.5 != nil or ok
+0.5 * 0.5 != i / 1
+0.5 * 0.5 * i
+0.5 * 0.5 * i32
+0.5 * 0.5 + i32
+0.5 * 0.5 - i
+0.5 * 0.5 / f64
+0.5 * 0.5 / i32
+0.5 * 0.5 < f32
+0.5 * 0.5 < i
+0.5 * 0.5 > i32
+0.5 * 1 + f32
+0.5 * 1 + half(f64)
+0.5 * 1 < f64
+0.5 * 1 > f64
+0.5 * 1 > i32
+0.5 * f32 / i64
+0.5 * f32 == i32
+0.5 * f64 * f64
+0.5 * f64 + i64
+0.5 * f64 > i
+0.5 * f64 >= i
+0.5 * f64 >= i64
+0.5 * i - i
+0.5 * i / i64
+0.5 * i / i64 ^ 0.5
+0.5 * i == f32
+0.5 * i32 < i32
+0.5 * i32 in [f64]
+0.5 * i64 != f32
+0.5 * i64 != i
+0.5 * i64 + f32
+0.5 * i64 <= i64
+0.5 ** 0.5 != i
+0.5 ** 0.5 ** f32
+0.5 ** 0.5 / f32
+0.5 ** 0.5 / i
+0.5 ** 0.5 < i / i32
+0.5 ** 0.5 == f32
+0.5 ** 0.5 == i32
+0.5 ** 1 + i64
+0.5 ** 1 / f32
+0.5 ** f32 < 1 / f64
+0.5 ** f32 < i
+0.5 ** f32 < i32
+0.5 ** f32 < min(i64)
+0.5 ** f32 == f64
+0.5 ** f32 ^ f32
+0.5 ** f32 ^ i64
+0.5 ** f64 * f32
+0.5 ** f64 + -i
+0.5 ** i * 0.5 ** i
+0.5 ** i < f32
+0.5 ** i <= i32
+0.5 ** i > f32
+0.5 ** i ^ f64
+0.5 ** i32 != f64
+0.5 ** i32 <= i32
+0.5 ** i32 ^ f32
+0.5 ** i64 != f32
+0.5 ** i64 - f32
+0.5 ** i64 - i64
+0.5 ** i64 ^ min(i)
+0.5 + 0.5 != i32
+0.5 + 0.5 - f32
+0.5 + 0.5 - i64
+0.5 + 0.5 < 1 ? f32 : score
+0.5 + 0.5 <= f32
+0.5 + 0.5 == f64
+0.5 + 0.5 > i64
+0.5 + 0.5 >= i64
+0.5 + 1 != i
+0.5 + 1 < f32
+0.5 + 1 >= i
+0.5 + f32 != i
+0.5 + f32 != i + i64
+0.5 + f32 >= i
+0.5 + f64 == i32
+0.5 + f64 > f64
+0.5 + i > f32
+0.5 + i32 + i64
+0.5 + i32 < f32
+0.5 + i64 + f64
+0.5 + i64 < f64
+0.5 + i64 <= 0.5 + 1
+0.5 + i64 == i32
+0.5 + i64 >= i64
+0.5 - 0.5 != i64
+0.5 - 0.5 + i32
+0.5 - 0.5 - f64
+0.5 - 0.5 < 0.5 * f32
+0.5 - 0.5 == f32
+0.5 - 1 != i ? "foo" : div
+0.5 - 1 + f32
+0.5 - 1 - f64
+0.5 - 1 <= i32
+0.5 - 1 <= i64
+0.5 - f32 + i
+0.5 - f64 <= i32
+0.5 - i - i32
+0.5 - i > f64
+0.5 - i > i
+0.5 - i32 + 0.5 ^ i
+0.5 - i32 + f32
+0.5 - i32 < i
+0.5 - i32 <= i64
+0.5 - i64 == f64
+0.5 - i64 > f32
+0.5 - i64 >= f64
+0.5 - i64 >= i
+0.5 / 0.5 != i32
+0.5 / 0.5 / i
+0.5 / 0.5 / i32
+0.5 / 0.5 < i
+0.5 / 0.5 == i
+0.5 / 0.5 >= i32
+0.5 / 0.5 >= min(i32)
+0.5 / 1 != i32 == nil
+0.5 / 1 - i
+0.5 / 1 < f32
+0.5 / 1 < i32
+0.5 / 1 == i64
+0.5 / 1 > 1 ** 0.5
+0.5 / f32 != i32
+0.5 / f32 * f64
+0.5 / f64 / i
+0.5 / f64 <= f64
+0.5 / f64 == i
+0.5 / f64 == i64
+0.5 / f64 >= f64 ^ 1
+0.5 / i < f64 ? i64 : i64
+0.5 / i <= i
+0.5 / i == i64 - f32
+0.5 / i32 + i32
+0.5 / i32 < f32
+0.5 / i64 * i32
+0.5 < 0.5 == nil ? true : foo
+0.5 < 0.5 || ok
+0.5 < 1 and ok
+0.5 < 1 or fromJSON("foo")?.Bar
+0.5 < f32 ? map(list, i32) : i
+0.5 < f64 != false ? f32 : score
+0.5 < f64 ? list : greet
+0.5 < f64 || ok
+0.5 < i ? f64 : foo
+0.5 < i32 or i32 == 1
+0.5 < i64 or ok
+0.5 <= 0.5 and ok
+0.5 <= 1 ? half : greet
+0.5 <= array[i32]
+0.5 <= f32 or ok
+0.5 <= f64 and !true
+0.5 <= f64 or ok
+0.5 <= i == ok
+0.5 <= i and nil == list
+0.5 <= i32 and i < i64
+0.5 <= i64 && f64 >= f64
+0.5 == 0.5 ? score : i
+0.5 == 1 == ok
+0.5 == 1 == ok ? "foo" : div
+0.5 == 1 or ok
+0.5 == 1 || nil != score
+0.5 == f32 ? score : i32
+0.5 == f64 && ok
+0.5 == nil || div != score
+0.5 == nil || ok
+0.5 > 1 == ok
+0.5 > 1 or ok
+0.5 > f32 or !true
+0.5 > f64 != ok
+0.5 >= 0.5 == ok
+0.5 >= 0.5 || ok
+0.5 >= 1 != ok
+0.5 >= 1 and ok
+0.5 >= i32 && i > f32
+0.5 >= i64 and ok
+0.5 ^ 0.5 != i32
+0.5 ^ 0.5 + i32
+0.5 ^ 0.5 / i
+0.5 ^ 0.5 < f64
+0.5 ^ 0.5 > i
+0.5 ^ 0.5 > i64
+0.5 ^ 0.5 >= i32
+0.5 ^ 1 * f64
+0.5 ^ 1 * i
+0.5 ^ 1 + i64
+0.5 ^ 1 - -i
+0.5 ^ 1 / i
+0.5 ^ 1 == f32
+0.5 ^ 1 == i32
+0.5 ^ f32 + i32
+0.5 ^ f32 <= i32
+0.5 ^ f32 > f64 ? array : nil
+0.5 ^ f32 >= f64
+0.5 ^ f32 ^ i32
+0.5 ^ f64 - i32
+0.5 ^ f64 > f32
+0.5 ^ f64 >= f32
+0.5 ^ f64 >= f64
+0.5 ^ f64 >= i
+0.5 ^ f64 ^ i64
+0.5 ^ i == i64
+0.5 ^ i >= i32
+0.5 ^ i32 * i
+0.5 ^ i32 * score(i)
+0.5 ^ i32 / i
+0.5 ^ i32 == i
+0.5 ^ i64 < i
+0.5 ^ i64 <= f32
+0.5 ^ i64 == f64
+0.5 ^ i64 > f64
+0.5 ^ i64 > i
+0.5 ^ i64 > i32
+0.5 ^ i64 >= f32
+1 != 1 != hasPrefix("bar", "bar")
+1 != array[i - 1]
+1 != f32 && i32 <= 0.5
+1 != f32 == ok
+1 != f32 ? i64 : foo
+1 != f32 and i in array
+1 != f64 != ok
+1 != i32 ? score : greet
+1 != i64 && ok
+1 != i64 ? f32 : greet
+1 != nil && ok
+1 != nil ? half : foo
+1 % 1 != f64
+1 % 1 * f32
+1 % 1 < f32
+1 % 1 > f32
+1 % 1 > i
+1 % 1 >= i64
+1 % i / i32
+1 % i < f64
+1 % i < i32
+1 % i == f32
+1 % i32 * i64
+1 % i32 < max(i64)
+1 % i64 != f32
+1 % i64 * f64
+1 % i64 + f32
+1 % i64 .. i64
+1 % i64 <= i64
+1 % i64 > f32
+1 % i64 > i32
+1 * 0.5 + i
+1 * 0.5 - -i
+1 * 0.5 <= f32
+1 * 0.5 > f32
+1 * 1 % i
+1 * 1 + i32
+1 * 1 <= f64
+1 * array[i64]
+1 * f32 < i
+1 * f32 < i32
+1 * f32 <= i32
+1 * f64 * -i
+1 * f64 * f32
+1 * f64 + i
+1 * i % i
+1 * i + f32
+1 * i < int(1)
+1 * i <= 1 % 1
+1 * i > f32
+1 * i not in array
+1 * i32 % i64
+1 * i32 * i32
+1 * i32 / i32
+1 * i32 > f32
+1 * i64 + f64
+1 * i64 == i32
+1 * i64 > i64
+1 ** 0.5 * f64
+1 ** 0.5 - i
+1 ** 0.5 > i32
+1 ** 0.5 ^ f64
+1 ** 1 != i
+1 ** 1 != i64
+1 ** 1 - i
+1 ** 1 / i64
+1 ** 1 < i64
+1 ** 1 == i32
+1 ** 1 >= i
+1 ** f32 != i64
+1 ** f32 / i
+1 ** f64 != i64
+1 ** f64 ** i64
+1 ** f64 + i
+1 ** f64 / f32
+1 ** f64 < i
+1 ** i != i
+1 ** i ** i64
+1 ** i < f64
+1 ** i < i32
+1 ** i > f64
+1 ** i32 ** (1 / 1)
+1 ** i32 == i
+1 ** i32 > i
+1 ** i64 ** f64
+1 ** i64 - f64
+1 + 0.5 != i
+1 + 0.5 <= f64 / f32
+1 + 0.5 <= i32
+1 + 1 - i32
+1 + 1 < i
+1 + 1 == f64
+1 + 1 == i64
+1 + 1 >= i64
+1 + f32 != i
+1 + f32 > i
+1 + f64 != f64
+1 + f64 - i
+1 + f64 >= i32
+1 + i <= f64
+1 + i in map(list, i32)
+1 + i32 - i64
+1 + i32 < i
+1 + i64 >= f32
+1 - 0.5 != half(0.5)
+1 - 0.5 + i
+1 - 0.5 + i32
+1 - 0.5 - i64
+1 - 0.5 <= f64
+1 - 0.5 == i64
+1 - 1 .. i64
+1 - 1 < i64
+1 - 1 == f64
+1 - 1 > -f32
+1 - f32 != i
+1 - f32 <= f64
+1 - f32 <= i32
+1 - f64 - f32
+1 - f64 - f64
+1 - f64 < i64
+1 - f64 <= i
+1 - i .. i64
+1 - i < min(f64)
+1 - i32 < f64
+1 - i32 <= f64
+1 - i32 <= i32
+1 - i32 >= f64
+1 - i64 + i
+1 - i64 - f32
+1 .. 1 == list
+1 .. array[i]
+1 .. i == list
+1 .. i64 == list
+1 / 0.5 + f64
+1 / 0.5 - array[i64]
+1 / 0.5 < f64
+1 / 1 + -0.5
+1 / 1 + i32
+1 / 1 - -0.5
+1 / 1 / f64
+1 / 1 < f32
+1 / 1 <= f32
+1 / 1 <= i
+1 / 1 == f64
+1 / 1 == i
+1 / 1 == i32
+1 / 1 > f32
+1 / 1 > i64
+1 / f32 + -1
+1 / f64 * i
+1 / f64 * i32
+1 / f64 + i32
+1 / f64 / f32
+1 / f64 == f32
+1 / f64 == i
+1 / f64 > i
+1 / i * i
+1 / i < f64 ? ok : add
+1 / i32 <= f32
+1 / i32 == i
+1 / i32 == i64
+1 / i32 > i
+1 / i64 + i64
+1 / i64 == i64
+1 / i64 > i
+1 / i64 >= i32
+1 < array[i64]
+1 < f64 != ok
+1 < i32 and 1 == nil
+1 < i64 ? "foo" not endsWith "foo" : i
+1 <= 0.5 and i32 == 1
+1 <= 0.5 || ok
+1 <= 1 && greet != greet
+1 <= 1 and ok
+1 <= f32 != ok
+1 <= f32 == !ok
+1 <= f64 ? add : f64
+1 <= i64 or nil == f32
+1 == array[i]
+1 > 0.5 != ok
+1 > 1 and ok
+1 > 1 || ok
+1 > f32 and ok
+1 > f64 == ok
+1 > f64 and ok
+1 > i32 == ok
+1 > i64 || i32 < i
+1 >= 1 || ok
+1 >= i || ok
+1 >= i64 or nil in list
+1 ^ 0.5 - f32
+1 ^ 0.5 <= f32
+1 ^ 0.5 <= i64
+1 ^ 0.5 ^ i32
+1 ^ 1 - f64
+1 ^ 1 - i32
+1 ^ 1 - i64
+1 ^ 1 / f32
+1 ^ 1 < f32
+1 ^ 1 < i64 / f32
+1 ^ 1 <= 1 ** f64
+1 ^ 1 == f64
+1 ^ 1 >= f32
+1 ^ 1 >= i64
+1 ^ f32 == i64
+1 ^ f32 > max(f32)
+1 ^ f64 != i32
+1 ^ f64 * f32
+1 ^ f64 ** f64
+1 ^ i != findLast(array, false)
+1 ^ i != i
+1 ^ i * f64
+1 ^ i < i32
+1 ^ i <= f32
+1 ^ i == abs(1)
+1 ^ i32 + i
+1 ^ i32 < i
+1 ^ i32 < i64
+1 ^ i32 >= i32
+1 ^ i64 ** f64
+1 ^ i64 ** i32
+1 ^ i64 + i
+1 ^ i64 <= i
+1 ^ i64 <= i32
+1 ^ i64 > i
+1 ^ i64 >= i64
+[!false]
+[!ok]
+["foo" != nil]
+["foo" endsWith "bar"]
+[-0.5]
+[-f32]
+[-f64]
+[-i32]
+[-i64, add]
+[-i64]
+[0.5 * 1]
+[0.5 + 0.5]
+[0.5 / i]
+[0.5 <= f64]
+[0.5 <= i, -1]
+[0.5 >= i]
+[0.5 ^ 1]
+[1 != 1]
+[1 % 1, !true]
+[1 < 0.5]
+[1 == i]
+[abs(0.5)]
+[add != div]
+[add == nil]
+[add, array]
+[add, f32]
+[add, f64]
+[add, greet]
+[add, half]
+[add, i64]
+[add, score]
+[add, toJSON(array)]
+[add]
+[array == list]
+[array, f32]
+[array, f64]
+[array, greet]
+[array, half]
+[array, list]
+[array, ok]
+[array, score]
+[array[1]]
+[array[i64]]
+[array]
+[div == half]
+[div, f32]
+[div, greet]
+[div, map(list, half)]
+[div, ok]
+[div, score]
+[div]
+[f32 + 1]
+[f32 - 0.5]
+[f32 < i]
+[f32 ^ 0.5]
+[f32 ^ f64]
+[f32, f64]
+[f32, half]
+[f32, max(f64)]
+[f32]
+[f64 != 1]
+[f64 != i32]
+[f64 * f64]
+[f64 < f32]
+[f64 >= 1]
+[f64, f64]
+[f64, foo]
+[f64, i32]
+[f64, i64]
+[f64, list]
+[f64, score]
+[f64]
+[false ? f64 : f32]
+[findIndex(array, true)]
+[first(array)]
+[float(i64)]
+[foo, add]
+[foo, f32]
+[foo, foo]
+[foo, i]
+[foo, list]
+[foo.Qux]
+[foo.String(), greet]
+[foo.String()]
+[foo?.Bar]
+[foo?.Qux]
+[foo]
+[greet, div]
+[greet, f32 ^ 0.5]
+[greet, f32]
+[greet, f64]
+[greet, half]
+[greet, i32]
+[greet, i64]
+[greet, list]
+[greet]
+[half, div]
+[half, foo]
+[half, greet]
+[half]
+[i != i64]
+[i != i]
+[i - 1]
+[i .. 1]
+[i / 0.5]
+[i < f32]
+[i > f64]
+[i, add]
+[i, half]
+[i32 * 1]
+[i32 <= 0.5]
+[i32 == 0.5]
+[i32 > 1]
+[i32 > f32]
+[i32, i]
+[i32, score]
+[i32]
+[i64 / f64]
+[i64 == i32]
+[i64 >= 1]
+[i64 ^ i, i32]
+[i64, add]
+[i64, div]
+[i64, foo]
+[i64, i32]
+[i64, ok]
+[i64]
+[i64] == array
+[i]
+[int(1)]
+[len(array)]
+[list == list]
+[list, div]
+[list, f64]
+[list, i]
+[list]
+[map(array, #)]
+[map(array, 1 >= i32)]
+[map(array, foo)]
+[map(list, #)]
+[map(list, half)]
+[map(list, ok)]
+[max(1)]
+[max(i32)]
+[min(0.5)]
+[min(f64)]
+[min(i32)]
+[nil != ok, foo]
+[nil == 0.5]
+[nil not in list]
+[not false]
+[not ok]
+[not true]
+[ok && ok]
+[ok, f32]
+[ok, half]
+[ok, score]
+[ok]
+[score != add]
+[score(1)]
+[score(i)]
+[score, array, foo]
+[score, f32]
+[score, f64]
+[score, greet]
+[score]
+[string(0.5), foo]
+[string(f64)]
+[string(i32)]
+[toJSON(1)]
+[toJSON(nil)]
+[type(0.5)]
+[type(1)]
+[type(add)]
+[type(false)]
+[type(i32)]
+[{"foo": foo}]
+abs(-0.5)
 abs(-1)
-int(0.5)
-float(42)
+abs(-f32)
+abs(-f64)
+abs(-i)
+abs(-i32)
+abs(-i64)
+abs(0.5 * 0.5)
+abs(0.5 * 1)
+abs(0.5 * f64)
+abs(0.5 * i32)
+abs(0.5 * i64)
+abs(0.5 ** 0.5)
+abs(0.5 ** 1)
+abs(0.5 ** f32)
+abs(0.5 ** f64)
+abs(0.5 ** i64)
+abs(0.5 + 0.5)
+abs(0.5 + f32)
+abs(0.5 + i)
+abs(0.5 + i64)
+abs(0.5 - 0.5)
+abs(0.5 - f32)
+abs(0.5 - i)
+abs(0.5 - i64)
+abs(0.5 / 0.5)
+abs(0.5 / 1)
+abs(0.5 / f32)
+abs(0.5 / f64)
+abs(0.5 / i)
+abs(0.5 / i64)
+abs(0.5 ^ 0.5)
+abs(0.5 ^ 1)
+abs(0.5 ^ f64)
+abs(0.5 ^ i32)
+abs(0.5) * i
+abs(0.5) - i
+abs(0.5) - i64
+abs(0.5) / i32
+abs(0.5) < f32
+abs(0.5) == i32
+abs(0.5) > f32
+abs(0.5) >= f32
+abs(0.5) >= i
+abs(0.5) >= i32
+abs(0.5) ^ f64
+abs(1 % 1)
+abs(1 % i)
+abs(1 * 0.5)
+abs(1 * 1)
+abs(1 * f32)
+abs(1 ** 1)
+abs(1 ** i)
+abs(1 + 1)
+abs(1 + f64)
+abs(1 - 0.5)
+abs(1 - i)
+abs(1 - i32)
+abs(1 / 0.5)
+abs(1 / 1)
+abs(1 / f32)
+abs(1 / f64)
+abs(1 / i32)
+abs(1 / i64)
+abs(1 ^ 0.5)
+abs(1 ^ 1)
+abs(1 ^ f64)
+abs(1) * f64
+abs(1) * i
+abs(1) ** f64
+abs(1) + f64
+abs(1) + i
+abs(1) - f64
+abs(1) .. i
+abs(1) / f32
+abs(1) < f32
+abs(1) < i
+abs(1) == f64 ? 1 : foo
+abs(1) > i
+abs(1) ^ f32
+abs(1) ^ i32
+abs(abs(0.5))
+abs(abs(1))
+abs(abs(abs(i)))
+abs(abs(f32))
+abs(abs(f64))
+abs(abs(i))
+abs(abs(i32))
+abs(abs(i64))
+abs(array[1])
+abs(array[i])
+abs(count(list, true))
+abs(f32 * 0.5)
+abs(f32 * 1)
+abs(f32 * f64)
+abs(f32 ** 0.5)
+abs(f32 ** 1)
+abs(f32 ** i32)
+abs(f32 + 0.5)
+abs(f32 + 1)
+abs(f32 + f32)
+abs(f32 + f64)
+abs(f32 + i)
+abs(f32 + i32)
+abs(f32 - 0.5)
+abs(f32 - 1)
+abs(f32 - f32)
+abs(f32 / 1)
+abs(f32 / f32)
+abs(f32 / f64)
+abs(f32 / i32)
+abs(f32 ^ 1)
+abs(f32 ^ f64)
+abs(f32 ^ i32)
+abs(f32 ^ i64)
+abs(f32)
+abs(f32) != i64 / i64
+abs(f32) * i32
+abs(f32) + i32
+abs(f32) <= i64
+abs(f32) == i
+abs(f32) ^ f64
+abs(f64 * 1)
+abs(f64 * f32)
+abs(f64 * i32)
+abs(f64 ** 1)
+abs(f64 ** f32)
+abs(f64 ** i32)
+abs(f64 + 0.5)
+abs(f64 + 1)
+abs(f64 + i32)
+abs(f64 + i64)
+abs(f64 - 0.5)
+abs(f64 - 1)
+abs(f64 - f32)
+abs(f64 - i32)
+abs(f64 / 0.5)
+abs(f64 / f64)
+abs(f64 / i)
+abs(f64 / i64)
+abs(f64 ^ i32)
+abs(f64)
+abs(f64) * i64
+abs(f64) - f32
+abs(f64) - i64 - i32
+abs(f64) / i
+abs(f64) / i64
+abs(f64) < f64
+abs(f64) <= abs(i32)
+abs(f64) <= i
+abs(f64) <= i32
+abs(f64) == i
+abs(false ? 1 : f32)
+abs(false ? f64 : 0.5)
+abs(false ? false : i64)
+abs(findIndex(array, # > i32))
+abs(findIndex(array, ok))
+abs(findIndex(array, true))
+abs(findIndex(list, true))
+abs(findLastIndex(array, ok))
+abs(findLastIndex(array, true))
+abs(findLastIndex(list, ok))
+abs(first(array))
+abs(float(0.5))
+abs(float(1))
+abs(float(f32))
+abs(float(f64))
+abs(float(i))
+abs(float(i32))
+abs(float(i64))
+abs(get(array, i32))
+abs(get(array, i64))
+abs(half(0.5))
+abs(half(f64))
+abs(i % i64)
+abs(i * 1)
+abs(i * i)
+abs(i * i32)
+abs(i ** 0.5)
+abs(i ** 1)
+abs(i ** i32)
+abs(i + 1)
+abs(i + i32)
+abs(i - 0.5)
+abs(i - 1)
+abs(i / 1)
+abs(i / i32)
+abs(i ^ 0.5)
+abs(i ^ f32)
+abs(i ^ i32)
+abs(i)
+abs(i) != float(0.5)
+abs(i) % i64
+abs(i) * f32
+abs(i) ** i
+abs(i) ** max(1)
+abs(i) / i64
+abs(i) <= i32
+abs(i) <= i64
+abs(i) > f64
+abs(i32 % i64)
+abs(i32 * 0.5)
+abs(i32 * 1)
+abs(i32 * i32)
+abs(i32 * i64)
+abs(i32 ** 0.5)
+abs(i32 ** 1)
+abs(i32 ** f64)
+abs(i32 ** i)
+abs(i32 ** i64)
+abs(i32 + 0.5)
+abs(i32 + f64)
+abs(i32 + i32)
+abs(i32 - 1)
+abs(i32 - f32)
+abs(i32 - f64)
+abs(i32 - i64)
+abs(i32 / 1)
+abs(i32 / i)
+abs(i32 / i32)
+abs(i32 ^ 0.5)
+abs(i32 ^ 1)
+abs(i32 ^ i)
+abs(i32 ^ i64)
+abs(i32)
+abs(i32) % i32
+abs(i32) ** i64
+abs(i32) / -f32
+abs(i32) < f32
+abs(i32) > min(i64, f64, i32)
+abs(i32) ^ f64
+abs(i32) not in array
+abs(i64 % 1)
+abs(i64 % i32)
+abs(i64 * 1)
+abs(i64 * f32)
+abs(i64 * i)
+abs(i64 * i32)
+abs(i64 * i64)
+abs(i64 ** 0.5)
+abs(i64 ** 1)
+abs(i64 ** i64)
+abs(i64 + 0.5)
+abs(i64 + 1)
+abs(i64 + i)
+abs(i64 + i32)
+abs(i64 + i64)
+abs(i64 - 1)
+abs(i64 - f64)
+abs(i64 - i32)
+abs(i64 / i32)
+abs(i64 ^ i64)
+abs(i64)
+abs(i64) != f64
+abs(i64) - f64
+abs(i64) - i64
+abs(i64) .. i64
+abs(i64) == f32
+abs(i64) == i
+abs(i64) == i32
+abs(i64) == nil ? i : f64
+abs(i64) > i64
+abs(i64) >= f64
+abs(i64) in array
+abs(int(0.5))
+abs(int(1))
+abs(int(f32))
+abs(int(f64))
+abs(int(i))
+abs(int(i32))
+abs(int(i64))
+abs(last(array))
+abs(len("bar"))
+abs(len("foo"))
+abs(len(array))
+abs(len(list))
+abs(max(0.5))
+abs(max(1))
+abs(max(1, 1))
+abs(max(1, i64, f64))
+abs(max(f32))
+abs(max(f64))
+abs(max(i))
+abs(max(i32))
+abs(max(i64))
+abs(min(0.5))
+abs(min(0.5, 1))
+abs(min(1))
+abs(min(1, f32))
+abs(min(f32))
+abs(min(f64))
+abs(min(i))
+abs(min(i32))
+abs(min(i64))
+abs(ok ? 1 : "foo")
+abs(ok ? f32 : 1)
+abs(ok ? i : "bar")
+abs(score(1))
+abs(score(i))
+abs(true ? f32 : "bar")
+abs(true ? f64 : i32)
+add
+add != add
+add != div
+add != div ? foo : i64
+add != div and ok
+add != foo.Qux
+add != foo.String
+add != foo?.Qux
+add != foo?.String
+add != greet
+add != greet ? score : f32
+add != half
+add != half == nil
+add != half ? 0.5 : ok
+add != nil == nil
+add != nil ? "bar" : f32
+add != nil ? half : f32
+add != score
+add == add
+add == add == ok
+add == div
+add == div ? i32 : f64
+add == div or ok
+add == foo.Qux
+add == foo.String
+add == foo?.Qux
+add == foo?.String
+add == greet
+add == greet ? 1 : 1
+add == half
+add == nil && ok
+add == nil ? "foo" : list
+add == nil ? add : half
+add == nil ? add : score
+add == nil ? i32 : div
+add == nil ? score : i64
+add == nil || ok
+add == score
+add == score != true
+add == score and i32 >= 1
+add == score or 0.5 < 1
+add in [div]
+add not in [f64]
+add not in sort(array)
+add(1, 1) ** i
+add(1, 1) ^ i
+add(1, i) .. i64
+add(i, 1 - i32)
+add(i, abs(i))
+add(i, i)
+add(i, i64 % 1)
+add(i, min(i))
+add(min(1, 1), i32 * 1)
+add(score(i, i), i)
+all(1 .. i32, ok)
+all(array, !(# <= #))
+all(array, !false)
+all(array, !ok)
+all(array, !true or 0.5 < #)
+all(array, "bar" in foo)
+all(array, "bar" matches "bar")
+all(array, # != #)
+all(array, # != 1)
+all(array, # != f32)
+all(array, # != f64)
+all(array, # != i64)
+all(array, # != nil)
+all(array, # + # >= 0.5 + i)
+all(array, # < #)
+all(array, # < 0.5)
+all(array, # < 1)
+all(array, # <= #)
+all(array, # <= 0.5)
+all(array, # <= f64)
+all(array, # <= i)
+all(array, # == #)
+all(array, # == 0.5)
+all(array, # == i32)
+all(array, # == i64)
+all(array, # == nil)
+all(array, # > #)
+all(array, # > 0.5)
+all(array, # > 1)
+all(array, # > f32)
+all(array, # > f64)
+all(array, # > i)
+all(array, # > i64)
+all(array, # >= #)
+all(array, # >= 0.5)
+all(array, # >= f64)
+all(array, # >= i)
+all(array, # ^ # == i64)
+all(array, # in array)
+all(array, # not in array)
+all(array, 0.5 != #)
+all(array, 0.5 != f32)
+all(array, 0.5 + 0.5 >= #)
+all(array, 0.5 < #)
+all(array, 0.5 < 1)
+all(array, 0.5 < i64)
+all(array, 0.5 <= #)
+all(array, 0.5 == #)
+all(array, 0.5 == f32)
+all(array, 0.5 > #)
+all(array, 0.5 > 1)
+all(array, 0.5 >= #)
+all(array, 1 != #)
+all(array, 1 != i)
+all(array, 1 != i64)
+all(array, 1 != nil)
+all(array, 1 < #)
+all(array, 1 <= #)
+all(array, 1 == #)
+all(array, 1 > #)
+all(array, 1 in array)
+all(array, all(array, add != score))
+all(array, all(array, false))
+all(array, all(list, false))
+all(array, f32 >= #)
+all(array, f64 != #)
+all(array, f64 != i32)
+all(array, f64 < #)
+all(array, f64 <= #)
+all(array, f64 == #)
+all(array, f64 > #)
+all(array, false or ok)
+all(array, i != f32)
+all(array, i == #)
+all(array, i > #)
+all(array, i >= #)
+all(array, i32 != i64)
+all(array, i32 < #)
+all(array, i32 <= #)
+all(array, i32 <= i32)
+all(array, i32 > #)
+all(array, i32 >= 1 % #)
+all(array, i64 < #)
+all(array, i64 < 1)
+all(array, i64 < i64)
+all(array, i64 == #)
+all(array, i64 == 0.5)
+all(array, i64 > #)
+all(array, list != list)
+all(array, nil != #)
+all(array, nil != i)
+all(array, nil == "foo")
+all(array, nil == div)
+all(array, nil in list)
+all(array, not (nil in array))
+all(array, not false)
+all(array, not true)
+all(array, ok)
+all(array, one(array, ok))
+all(array, score == add)
+all(array, score(#) > f32)
+all(array, true || false)
+all(array, true) or ok
+all(false ? greet : "foo", # == i32)
+all(filter(array, ok), # < #)
+all(filter(array, true), ok)
+all(i32 .. 1, 0.5 < i32)
+all(i64 .. i64, # != #)
+all(list, !any(array, false))
+all(list, !false)
+all(list, !ok)
+all(list, "bar" not in #)
+all(list, "foo" >= "foo")
+all(list, # != #)
+all(list, # != foo)
+all(list, # == #)
+all(list, # == foo)
+all(list, 0.5 != f64)
+all(list, 0.5 != nil)
+all(list, 0.5 <= f64)
+all(list, 0.5 > 1)
+all(list, 1 != 0.5)
+all(list, 1 != i)
+all(list, 1 < f32)
+all(list, 1 < i)
+all(list, 1 <= 0.5)
+all(list, 1 == 1)
+all(list, 1 > f32)
+all(list, 1 >= i64)
+all(list, all(array, true))
+all(list, array != nil)
+all(list, div != div)
+all(list, f32 != 0.5)
+all(list, f32 == f64)
+all(list, f64 < 1)
+all(list, f64 <= 1)
+all(list, f64 <= i)
+all(list, f64 <= i32)
+all(list, f64 >= 1)
+all(list, false) or 0.5 <= 1
+all(list, foo != #)
+all(list, greet != half)
+all(list, greet == score)
+all(list, i <= i64)
+all(list, i32 != i64)
+all(list, i32 < i64)
+all(list, i32 <= 0.5)
+all(list, i32 <= f64)
+all(list, int(i32) != i32)
+all(list, list != nil)
+all(list, nil != 1)
+all(list, nil != foo)
+all(list, nil == #)
+all(list, nil == greet)
+all(list, nil in list)
+all(list, none(array, ok))
+all(list, not false)
+all(list, not ok)
+all(list, not true)
+all(list, ok and false)
+all(list, ok)
+all(list, ok) or ok
+all(list, true != false)
+all(list, true != true)
+all(list, true ? true : 1)
+all(list[i64:i32], !false)
+all(map(array, #), # != #)
+all(map(array, #), # != 0.5)
+all(map(array, #), # >= #)
+all(map(array, #), i64 == #)
+all(map(array, #), true or false)
+all(map(array, 1), ok)
+all(map(array, i), f64 > #)
+all(map(array, ok), #)
+all(map(list, "bar"), ok)
+all(map(list, #), "bar" not in #)
+all(map(list, #), f32 > 1)
+all(map(list, 1), ok)
+all(map(list, false), #)
+all(map(list, i64), # <= #)
+all(map(list, ok), #)
+all(map(list, true), # == #)
+all(map(list, true), #)
+all(map(list, true), ok)
+any([0.5, add, 0.5], # == #)
+any([1], i64 >= #)
+any(array, !false)
+any(array, "foo" <= "foo")
+any(array, # != #)
+any(array, # != 0.5)
+any(array, # != 1)
+any(array, # != i)
+any(array, # != i32)
+any(array, # != i64)
+any(array, # != nil)
+any(array, # < #)
+any(array, # < 0.5)
+any(array, # < 1)
+any(array, # < f32)
+any(array, # < f64)
+any(array, # < i)
+any(array, # < i32)
+any(array, # <= #)
+any(array, # <= 0.5)
+any(array, # <= 1 ^ #)
+any(array, # <= 1)
+any(array, # <= i)
+any(array, # <= i32)
+any(array, # == #)
+any(array, # == 1)
+any(array, # == f64)
+any(array, # == i)
+any(array, # == i32)
+any(array, # == i64)
+any(array, # == nil)
+any(array, # > #)
+any(array, # > 1)
+any(array, # > i32)
+any(array, # > i64)
+any(array, # >= #)
+any(array, # >= 0.5)
+any(array, # >= 1)
+any(array, # >= f64)
+any(array, # >= i)
+any(array, # >= i32)
+any(array, # in array)
+any(array, # not in array)
+any(array, 0.5 != #)
+any(array, 0.5 != f64)
+any(array, 0.5 != i)
+any(array, 0.5 < 0.5)
+any(array, 0.5 <= #)
+any(array, 0.5 == #)
+any(array, 0.5 == 0.5)
+any(array, 0.5 > #)
+any(array, 0.5 > f32)
+any(array, 1 < #)
+any(array, 1 <= i64)
+any(array, 1 == #)
+any(array, 1 > f64)
+any(array, 1 >= i)
+any(array, 1 >= i32)
+any(array, all(list, true))
+any(array, array == array)
+any(array, div != nil)
+any(array, f32 < #)
+any(array, f32 > #)
+any(array, f64 != #)
+any(array, f64 != 1)
+any(array, f64 < #)
+any(array, f64 <= 0.5)
+any(array, f64 <= f32)
+any(array, f64 == #)
+any(array, f64 > #)
+any(array, f64 > 0.5)
+any(array, f64 >= i64)
+any(array, false != nil)
+any(array, false) and f32 != f32
+any(array, greet != half)
+any(array, half != div)
+any(array, half != nil)
+any(array, i != 1)
+any(array, i < # ** #)
+any(array, i <= #)
+any(array, i == #)
+any(array, i == i)
+any(array, i > #)
+any(array, i >= #)
+any(array, i32 != #)
+any(array, i32 != i64)
+any(array, i32 <= #)
+any(array, i32 == #)
+any(array, i32 > #)
+any(array, i32 >= i64)
+any(array, i64 != #)
+any(array, i64 != i64)
+any(array, i64 <= 0.5)
+any(array, i64 == #)
+any(array, i64 > #)
+any(array, i64 > 1)
+any(array, i64 > f32)
+any(array, i64 >= i)
+any(array, nil != #)
+any(array, nil != f64)
+any(array, nil != greet)
+any(array, nil == #)
+any(array, nil == 1)
+any(array, not ok)
+any(array, not true)
+any(array, ok)
+any(array, one(list, false))
+any(array, true ? ok : f32)
+any(array, true) and ok
+any(filter(array, ok), ok)
+any(filter(list, false), ok)
+any(filter(list, true), # == #)
+any(list, !true)
+any(list, "bar" contains "foo")
+any(list, "bar" matches "foo")
+any(list, "bar" not in #)
+any(list, "bar" not startsWith "foo")
+any(list, # != #)
+any(list, # != foo)
+any(list, # != nil)
+any(list, # == #)
+any(list, # == nil)
+any(list, # in list)
+any(list, # not in list)
+any(list, 0.5 < 1)
+any(list, 0.5 <= f32)
+any(list, 0.5 == 0.5)
+any(list, 0.5 >= 0.5)
+any(list, 0.5 >= f32)
+any(list, 0.5 >= i64)
+any(list, 1 <= 0.5)
+any(list, 1 == f32)
+any(list, f32 != i)
+any(list, f32 == nil)
+any(list, f32 >= i)
+any(list, f64 <= 1)
+any(list, f64 > 0.5)
+any(list, false ? nil : false)
+any(list, foo == foo)
+any(list, greet == div)
+any(list, half != nil)
+any(list, i != 1)
+any(list, i < f32)
+any(list, i < f64)
+any(list, i > i64)
+any(list, i32 != i32)
+any(list, i32 < 0.5)
+any(list, i32 == f64)
+any(list, i64 < 1)
+any(list, i64 < f64)
+any(list, i64 < i64)
+any(list, i64 <= i32)
+any(list, i64 >= 1)
+any(list, i64 >= f32)
+any(list, list != nil)
+any(list, nil != #)
+any(list, nil != #?.String())
+any(list, nil != nil)
+any(list, nil == #)
+any(list, nil == 1)
+any(list, nil == i64)
+any(list, nil == nil)
+any(list, not false)
+any(list, not ok)
+any(list, ok and foo != #)
+any(list, ok)
+any(list, ok) && i <= 1
+any(list, ok) ? array : foo
+any(list, true or ok)
+any(list, true) ? f64 : foo.Bar
+any(map(array, #), # == #)
+any(map(array, #), ok)
+any(map(array, 0.5), # <= #)
+any(map(array, f64), # < #)
+any(map(array, false), #)
+any(map(array, ok), #)
+any(map(list, #), i == f64)
+any(map(list, #), ok)
+any(map(list, 1), # != #)
+any(map(list, array), ok)
+any(map(list, foo), # != #)
+any(map(list, greet), # == #)
+any(ok ? "bar" : half, ok)
+any(splitAfter("bar", "foo"), # not startsWith #)
+array
+array != [array]
+array != array
+array != filter(list, true)
+array != list
+array != map(array, i)
+array != nil != ok
+array != nil ? 0.5 : i32
+array != nil ? true : nil
+array != nil or nil == f32
+array != nil || ok
+array != sort(array)
+array != {"bar": f32, "foo": 1}.ok
+array == array
+array == array ? "foo" : 0.5
+array == list
+array == list ? i : half
+array == map(array, #)
+array == map(array, add)
+array == nil != nil
+array == nil != true ? 0.5 : 0.5
+array == nil && (false || ok)
+array in [i]
+array[-1]
+array[-i32]
+array[-i64]
+array[-i]
+array[1 % 1]
+array[1 % i:i64]
+array[1] != f32
+array[1] != score(i)
+array[1] <= f64
+array[1] == f32
+array[1] == i64
+array[1] ^ 0.5 ^ f64
+array[1] ^ i32
+array[false ? half : 0.5]
+array[false ? i : i32]
+array[i - i64]
+array[i32:i32]
+array[i32]
+array[i32] - f64
+array[i32] .. i32
+array[i64 % 1]
+array[i64:i32]
+array[i64:i]
+array[i64]
+array[i64] ** f32
+array[i64] / i
+array[i64] < i
+array[i64] == f64
+array[i64] > f32
+array[i64] >= -i64
+array[i:i64]
+array[i:i]
+array[i]
+array[i] ** i64
+array[i] + f32
+array[i] < i
+array[i] == min(i32, i)
+array[i] > i32
+array[int(1)]
+array[int(i32)]
+array[max(i64)]
+array[min(1)]
+array[min(i32)]
+array[min(i64)]
+array[score(1)]
+array[score(i)]
+count([list], false or ok)
+count(array, !ok)
+count(array, "bar" != "bar")
+count(array, "bar" not endsWith "bar")
+count(array, # != #)
+count(array, # != f32)
+count(array, # != i32)
+count(array, # < #)
+count(array, # < 0.5)
+count(array, # < 1)
+count(array, # < f32)
+count(array, # < f64)
+count(array, # < i)
+count(array, # < i64)
+count(array, # <= #)
+count(array, # <= 0.5)
+count(array, # <= f32)
+count(array, # <= f64)
+count(array, # <= i)
+count(array, # <= i32)
+count(array, # == #)
+count(array, # == 1)
+count(array, # == f32)
+count(array, # == i)
+count(array, # == i64)
+count(array, # == nil)
+count(array, # > #)
+count(array, # > 0.5)
+count(array, # > i)
+count(array, # > i64)
+count(array, # >= # / #)
+count(array, # >= #)
+count(array, # >= 0.5)
+count(array, # >= 1)
+count(array, # >= f64)
+count(array, # >= i)
+count(array, # >= i64)
+count(array, 0.5 != #)
+count(array, 0.5 <= #)
+count(array, 0.5 == #)
+count(array, 0.5 > #)
+count(array, 0.5 > 1)
+count(array, 0.5 >= #)
+count(array, 0.5 >= 0.5)
+count(array, 0.5 >= i)
+count(array, 1 != #)
+count(array, 1 < #)
+count(array, 1 < 0.5)
+count(array, 1 < 1)
+count(array, 1 <= #)
+count(array, 1 > #)
+count(array, 1 >= #)
+count(array, add == half)
+count(array, f32 != i)
+count(array, f32 < # ? true : half)
+count(array, f32 < #)
+count(array, f32 < 0.5)
+count(array, f32 <= #)
+count(array, f32 <= 1)
+count(array, f32 <= i)
+count(array, f32 == #)
+count(array, f32 == 1)
+count(array, f64 != #)
+count(array, f64 < #)
+count(array, f64 <= #)
+count(array, f64 == #)
+count(array, f64 > #)
+count(array, false == true)
+count(array, false) != f64
+count(array, false) / i
+count(array, false) >= f32
+count(array, foo not in list)
+count(array, greet != greet)
+count(array, greet == score)
+count(array, i != f32)
+count(array, i == nil)
+count(array, i > #)
+count(array, i >= #)
+count(array, i32 != 1)
+count(array, i32 < #)
+count(array, i32 < 0.5)
+count(array, i32 == #)
+count(array, i32 > i)
+count(array, i32 >= #)
+count(array, i32 >= 1)
+count(array, i64 != #)
+count(array, i64 < #)
+count(array, i64 <= 1)
+count(array, i64 <= f64)
+count(array, i64 == #)
+count(array, i64 == i64)
+count(array, i64 > 1)
+count(array, i64 > f32)
+count(array, nil != #)
+count(array, nil == #)
+count(array, nil == foo)
+count(array, not ok)
+count(array, ok)
+count(array, ok) + i64
+count(array, ok) - i64
+count(array, ok) .. i64
+count(array, one(array, false))
+count(array, true ? false : 0.5)
+count(array, true) != 1 ^ f32
+count(array, true) ** f32
+count(array, true) / int(0.5)
+count(array, true) >= f64 / 0.5
+count(filter(list, false), ok)
+count(i .. 1, # > #)
+count(i .. i32, # > #)
+count(i32 .. 1, # == #)
+count(i64 .. i, div == nil)
+count(i64 .. i, ok)
+count(list, !false)
+count(list, !ok)
+count(list, "bar" == "bar")
+count(list, "bar" in #)
+count(list, "bar" matches "foo")
+count(list, "bar" not in #)
+count(list, "foo" in #)
+count(list, "foo" not in #)
+count(list, # != #)
+count(list, # != nil)
+count(list, # == #)
+count(list, # == nil)
+count(list, 0.5 == f32)
+count(list, 0.5 > 0.5)
+count(list, 0.5 >= i32)
+count(list, 1 != 1)
+count(list, 1 != f32)
+count(list, 1 < 0.5)
+count(list, 1 <= i)
+count(list, 1 >= f32)
+count(list, 1 >= i32)
+count(list, all(list, true))
+count(list, f32 <= i32)
+count(list, f64 != i)
+count(list, false ? # : ok)
+count(list, false or ok)
+count(list, false || false)
+count(list, false) .. i32
+count(list, false) > i64
+count(list, foo != #)
+count(list, half == div)
+count(list, i == i64)
+count(list, i32 == i)
+count(list, i32 == i32)
+count(list, list == array)
+count(list, nil != #)
+count(list, nil != score)
+count(list, nil == #)
+count(list, nil == add)
+count(list, nil == true)
+count(list, none(list, ok))
+count(list, not false)
+count(list, not ok)
+count(list, not true)
+count(list, ok == nil)
+count(list, ok)
+count(list, ok) - i32
+count(list, ok) < f64
+count(list, ok) > -0.5
+count(list, ok) >= i
+count(list, true and ok)
+count(list, true) ** i64
+count(list, true) == f64
+count(list, true) ^ i64
+count(map(array, #), # != #)
+count(map(array, #), # > #)
+count(map(array, #), i == #)
+count(map(array, #), ok)
+count(map(array, add), ok)
+count(map(array, div), ok)
+count(map(array, foo), ok)
+count(map(array, i32), 0.5 == f32)
+count(map(array, i32), 1 != #)
+count(map(array, i64), # == 0.5)
+count(map(array, true), #)
+count(map(list, #), "bar" in #)
+count(map(list, #), # == #)
+count(map(list, #), # == nil)
+count(map(list, 0.5), # != nil)
+count(map(list, f32), # <= #)
+count(map(list, true), #)
+count(sort(array), foo == #)
+count(sort(array), ok)
+date("bar", "bar")?.String
+div
+div != add
+div != add != ok
+div != div
+div != div ? score : 0.5
+div != div or half != greet
+div != foo.Qux
+div != foo.String
+div != foo?.Qux
+div != greet
+div != half
+div != half ? f32 : ok
+div != half and !ok
+div != nil != ok
+div != nil ? array : add
+div != nil ? i : i64
+div != score
+div == add
+div == div
+div == div ? 0.5 : half
+div == div ? nil : i
+div == div || true ? f32 : add
+div == foo.Qux
+div == foo.String
+div == foo?.Qux
+div == foo?.String
+div == greet
+div == greet != ok
+div == greet || !false
+div == half
+div == nil ? greet : foo
+div == nil ? half : half
+div == nil ? score : i64
+div == nil || ok
+div == score
+div == score == ok
+div == score ? true : "bar"
+div in map(list, add)
+div not in [add]
+div not in [half, f32, false]
+div not in map(array, div)
+div(-1, i)
+div(1, 1) > i64
+div(1, i) >= i64
+div(i, 1) / f32
+div(i, 1) == i
+div(i, i)
+f32
+f32 != --f64
+f32 != -1
+f32 != 0.5 * f32
+f32 != 0.5 + i64
+f32 != 0.5 / i64
+f32 != 0.5 == ok
+f32 != 0.5 ? array : ok
+f32 != 0.5 ? list : 1
+f32 != 0.5 ^ i32
+f32 != 1 % i32
+f32 != 1 * 1
+f32 != 1 * i64
+f32 != 1 ** 0.5
+f32 != 1 - i
+f32 != 1 ? "foo" : foo
+f32 != 1 ^ f32
+f32 != abs(i64)
+f32 != f32
+f32 != f32 + f64
+f32 != f32 - f64
+f32 != f64
+f32 != f64 ** i32
+f32 != f64 + i32
+f32 != f64 - f32
+f32 != f64 ^ i32
+f32 != findIndex(list, ok)
+f32 != float(i)
+f32 != i
+f32 != i * i64
+f32 != i - f64
+f32 != i32
+f32 != i64
+f32 != i64 * 1
+f32 != i64 ? f64 : f32
+f32 != len(array)
+f32 != max(i)
+f32 != min(1)
+f32 != min(f64)
+f32 != nil ? half : greet
+f32 != score(1)
+f32 * (1 - f32)
+f32 * (i + 1)
+f32 * (i32 + f32)
+f32 * (i64 + f32)
+f32 * (i64 - i64)
+f32 * -0.5
+f32 * -f32
+f32 * -f64
+f32 * -i32
+f32 * 0.5 != f32
+f32 * 0.5 ** f32
+f32 * 0.5 - f32
+f32 * 0.5 < f64
+f32 * 0.5 < i32
+f32 * 0.5 <= f32
+f32 * 0.5 <= f32 ? "bar" : array
+f32 * 0.5 <= i64
+f32 * 1 != f32
+f32 * 1 * 1
+f32 * 1 ** f64
+f32 * 1 + i
+f32 * 1 - i
+f32 * 1 / i64
+f32 * 1 < f64
+f32 * 1 <= f32
+f32 * 1 >= i32
+f32 * array[i64]
+f32 * count(array, ok)
+f32 * f32
+f32 * f32 * i
+f32 * f32 ^ i64
+f32 * f64
+f32 * f64 * i64
+f32 * f64 + f32
+f32 * f64 - i
+f32 * f64 ^ f32
+f32 * findIndex(list, true)
+f32 * float(0.5)
+f32 * i
+f32 * i < f64
+f32 * i <= -i64
+f32 * i <= min(0.5, f64)
+f32 * i32
+f32 * i32 ** 1
+f32 * i32 - i64
+f32 * i64
+f32 * i64 ** 0.5
+f32 * i64 ** i64
+f32 * i64 < f64
+f32 * i64 < half(f64)
+f32 * i64 ^ i
+f32 * i64 ^ i64
+f32 * int(f64)
+f32 * max(f32)
+f32 * min(0.5)
+f32 * min(f64)
+f32 * score(1)
+f32 ** (0.5 + i)
+f32 ** (0.5 - 0.5)
+f32 ** (1 - i64)
+f32 ** (1 / 0.5)
+f32 ** (f32 * i)
+f32 ** (f32 + 0.5)
+f32 ** (f32 + i64)
+f32 ** (f32 - 1)
+f32 ** (f64 - i32)
+f32 ** (i32 * 1)
+f32 ** (i32 * i)
+f32 ** -0.5
+f32 ** -1
+f32 ** -f64
+f32 ** -i
+f32 ** -i32
+f32 ** -i64
+f32 ** 0.5 >= i64
+f32 ** 0.5 ^ i64
+f32 ** 1 * f32
+f32 ** 1 ** 0.5
+f32 ** 1 / i32
+f32 ** 1 <= i
+f32 ** array[i64]
+f32 ** f32
+f32 ** f32 * i ^ f64
+f32 ** f32 + f32
+f32 ** f32 - 0.5 + 1
+f32 ** f32 ^ 1
+f32 ** f32 ^ i
+f32 ** f64
+f32 ** f64 + i64
+f32 ** f64 <= f64
+f32 ** f64 >= f32
+f32 ** float(i64)
+f32 ** half(f64)
+f32 ** i
+f32 ** i * f64
+f32 ** i / f64
+f32 ** i == score(i)
+f32 ** i32
+f32 ** i32 ** i32
+f32 ** i32 >= i32
+f32 ** i64
+f32 ** i64 * i32
+f32 ** i64 + i64
+f32 ** i64 / i64
+f32 ** int(0.5)
+f32 ** int(1)
+f32 ** len("foo")
+f32 ** len(list)
+f32 ** max(f32)
+f32 ** max(f64)
+f32 ** max(i64)
+f32 + -0.5
+f32 + -1
+f32 + -f32
+f32 + -i
+f32 + -i64
+f32 + 0.5 + 1
+f32 + 0.5 + f32
+f32 + 1 * 0.5
+f32 + 1 * i32
+f32 + 1 ** f64
+f32 + 1 - f32
+f32 + 1 - i64
+f32 + 1 < i32
+f32 + abs(0.5)
+f32 + abs(f32)
+f32 + count(array, true)
+f32 + f32
+f32 + f32 + i32
+f32 + f32 == 0.5 ^ i
+f32 + f64
+f32 + f64 - 0.5
+f32 + f64 - f32
+f32 + f64 / f64
+f32 + f64 < f32
+f32 + f64 ^ f32
+f32 + find(array, ok)
+f32 + float(f64)
+f32 + half(0.5)
+f32 + i
+f32 + i != i
+f32 + i - i
+f32 + i ^ f64
+f32 + i32
+f32 + i32 * 0.5
+f32 + i32 + 0.5
+f32 + i32 >= f32
+f32 + i64
+f32 + i64 % 1
+f32 + i64 - 1
+f32 + i64 - f32
+f32 + int(1)
+f32 + int(f64)
+f32 + int(i32)
+f32 + len(array)
+f32 + max(0.5)
+f32 + max(f64)
+f32 + max(i64)
+f32 + min(1)
+f32 + min(f32)
+f32 + min(i32)
+f32 + min(i64, 1, 1)
+f32 + score(1)
+f32 + score(i)
+f32 - -0.5
+f32 - -1
+f32 - -f64
+f32 - -i
+f32 - -i32
+f32 - 0.5 + f64
+f32 - 0.5 - i32
+f32 - 0.5 - i64
+f32 - 0.5 <= f64
+f32 - 0.5 <= i64
+f32 - 0.5 >= i64
+f32 - 0.5 ^ f64
+f32 - 0.5 ^ i32
+f32 - 1 != i64
+f32 - 1 % 1
+f32 - 1 % i64
+f32 - 1 + 1
+f32 - 1 + i32 % i
+f32 - 1 - f32
+f32 - abs(i32)
+f32 - array[i]
+f32 - f32
+f32 - f32 - f64
+f32 - f32 - i32
+f32 - f32 == i
+f32 - f32 == min(1)
+f32 - f32 >= i
+f32 - f64
+f32 - f64 * 1
+f32 - f64 ** i32
+f32 - f64 + f32
+f32 - f64 + i64
+f32 - f64 - f32
+f32 - f64 - i
+f32 - f64 <= f32
+f32 - f64 ^ 1
+f32 - float(0.5)
+f32 - float(1)
+f32 - float(i32)
+f32 - half(0.5)
+f32 - i
+f32 - i % 1
+f32 - i * f32
+f32 - i + i32 % 1
+f32 - i + i32 ** 0.5
+f32 - i - 0.5
+f32 - i32
+f32 - i32 * 1
+f32 - i32 ** f32
+f32 - i32 ** i32
+f32 - i32 + 1
+f32 - i32 >= i
+f32 - i32 ^ i
+f32 - i64
+f32 - i64 - 1
+f32 - i64 <= i32
+f32 - i64 ^ 1
+f32 - int(0.5)
+f32 - int(i64)
+f32 - len("bar")
+f32 - len(list)
+f32 - max(i32)
+f32 - min(1)
+f32 - min(i64)
+f32 - score(i)
+f32 / (0.5 + i64)
+f32 / (1 - i)
+f32 / (i64 - f64)
+f32 / -0.5
+f32 / -f32
+f32 / -f64
+f32 / -i
+f32 / -i32
+f32 / 0.5 * 0.5
+f32 / 0.5 * i
+f32 / 0.5 - f64
+f32 / 0.5 - i
+f32 / 0.5 - i64
+f32 / 0.5 > f64
+f32 / 1 != f64
+f32 / 1 * i64
+f32 / 1 ** f32
+f32 / 1 - f64 - i64
+f32 / 1 >= f32
+f32 / 1 ^ 0.5
+f32 / 1 ^ i
+f32 / abs(1)
+f32 / abs(f32)
+f32 / f32
+f32 / f32 / f32
+f32 / f32 < f32
+f32 / f64
+f32 / f64 ^ 0.5
+f32 / float(i64)
+f32 / get(array, 1)
+f32 / half(0.5)
+f32 / i
+f32 / i <= i64
+f32 / i32
+f32 / i32 != i
+f32 / i32 ** i
+f32 / i32 / f64
+f32 / i32 >= i
+f32 / i64
+f32 / i64 * i64
+f32 / i64 > i32
+f32 / i64 ^ 1
+f32 / i64 ^ i
+f32 / int(f32)
+f32 / int(f64)
+f32 / int(i)
+f32 / int(i32)
+f32 / last(array)
+f32 / max(0.5)
+f32 / max(1)
+f32 / min(f32)
+f32 < -0.5
+f32 < -f32
+f32 < -f64
+f32 < -i32
+f32 < -i64
+f32 < 0.5 != true
+f32 < 0.5 ? array : array
+f32 < 0.5 ? false : score
+f32 < 0.5 ? i64 : i32
+f32 < 0.5 ? ok : f32
+f32 < 0.5 ^ f32
+f32 < 1 != ok
+f32 < 1 * f32
+f32 < 1 ** 1
+f32 < 1 ** i
+f32 < 1 - i
+f32 < 1 / 0.5
+f32 < 1 ? f32 : i64
+f32 < 1 ? foo : i
+f32 < 1 ? i64 : foo
+f32 < 1 || not ok
+f32 < abs(1)
+f32 < abs(i)
+f32 < array[i64]
+f32 < array[i]
+f32 < div(1, 1)
+f32 < f32
+f32 < f32 ** 1
+f32 < f32 ^ 0.5
+f32 < f64
+f32 < f64 != ok
+f32 < f64 / f64
+f32 < f64 == nil
+f32 < f64 == true
+f32 < f64 ? "foo" : half
+f32 < float(f32)
+f32 < float(i64)
+f32 < half(f64)
+f32 < i
+f32 < i * 1
+f32 < i - i32
+f32 < i ? greet : "foo"
+f32 < i32
+f32 < i32 ** 0.5
+f32 < i32 or ok
+f32 < i32 || ok
+f32 < i64
+f32 < i64 != nil
+f32 < i64 && ok
+f32 < i64 * i32
+f32 < i64 - f32
+f32 < int(f64)
+f32 < max(1)
+f32 < score(1)
+f32 < score(i)
+f32 <= -0.5
+f32 <= -1
+f32 <= -f32
+f32 <= -f64
+f32 <= -i
+f32 <= -i64
+f32 <= -min(i64)
+f32 <= 0.5 * 0.5
+f32 <= 0.5 ** i32
+f32 <= 0.5 - 1
+f32 <= 0.5 / 0.5
+f32 <= 0.5 == ok
+f32 <= 0.5 == true
+f32 <= 1 != nil
+f32 <= 1 % i
+f32 <= 1 * 0.5
+f32 <= 1 * i32
+f32 <= 1 == ok
+f32 <= abs(1)
+f32 <= f32
+f32 <= f32 ** i64
+f32 <= f32 ? 0.5 : foo
+f32 <= f64
+f32 <= f64 ? ok : f64
+f32 <= f64 ^ f32
+f32 <= f64 and ok
+f32 <= findIndex(list, ok)
+f32 <= first(array)
+f32 <= half(0.5)
+f32 <= i
+f32 <= i != nil
+f32 <= i % i64
+f32 <= i ** i32
+f32 <= i - 0.5
+f32 <= i / f32
+f32 <= i == ok
+f32 <= i32
+f32 <= i32 * i64
+f32 <= i32 ** i32
+f32 <= i32 + i32
+f32 <= i32 - 1
+f32 <= i32 / 1
+f32 <= i32 ? 0.5 : i32
+f32 <= i32 and ok
+f32 <= i64
+f32 <= i64 * i
+f32 <= i64 ? true : array
+f32 <= i64 or ok
+f32 <= int(0.5)
+f32 <= int(i)
+f32 <= len("foo")
+f32 <= max(f32)
+f32 <= max(i64)
+f32 <= min(i64, i32)
+f32 <= score(1)
+f32 <= score(i)
+f32 == --f64
+f32 == -0.5
+f32 == -1
+f32 == -f32
+f32 == -i32
+f32 == -i64
+f32 == 0.5 && i32 == i32
+f32 == 0.5 * i32
+f32 == 0.5 ** 1
+f32 == 0.5 and ok
+f32 == 1 && ok ? add : f32
+f32 == 1 ^ i
+f32 == abs(1)
+f32 == array[1]
+f32 == count(array, ok)
+f32 == f32
+f32 == f32 ** f32
+f32 == f32 - i32
+f32 == f32 ? 1 : greet
+f32 == f32 ? list : "bar"
+f32 == f64
+f32 == f64 - 1
+f32 == f64 - f64
+f32 == f64 ? ok : i64
+f32 == find(array, ok)
+f32 == findLast(array, ok)
+f32 == findLastIndex(list, true)
+f32 == get(array, 1)
+f32 == i
+f32 == i * i64
+f32 == i + f64 + 0.5
+f32 == i - f64
+f32 == i - i32
+f32 == i / 0.5
+f32 == i ? "foo" : i64
+f32 == i ? i : 0.5
+f32 == i32
+f32 == i32 % 1
+f32 == i32 - 0.5
+f32 == i64
+f32 == i64 % i
+f32 == i64 * 0.5
+f32 == int(1)
+f32 == max(0.5, 1)
+f32 == max(i)
+f32 == min(0.5)
+f32 == min(i64)
+f32 == nil ? "foo" : div
+f32 == nil ? i32 : greet
+f32 == score(1)
+f32 > -0.5
+f32 > -f64
+f32 > -i
+f32 > -i32
+f32 > -i64
+f32 > 0.5 != false
+f32 > 0.5 != ok
+f32 > 0.5 - 0.5
+f32 > 0.5 / 0.5
+f32 > 0.5 ? foo : f64
+f32 > 0.5 ? greet : half
+f32 > 1 % 1
+f32 > 1 ** 0.5
+f32 > 1 + f32
+f32 > 1 / i64
+f32 > 1 == true
+f32 > 1 ? nil : half
+f32 > 1 ^ i32
+f32 > array[i32]
+f32 > f32
+f32 > f32 ** f32
+f32 > f32 - i
+f32 > f32 == true
+f32 > f64
+f32 > f64 - i32
+f32 > f64 / i64
+f32 > f64 ? array : false
+f32 > f64 ? true : array
+f32 > f64 or ok
+f32 > i
+f32 > i * 0.5
+f32 > i + f32
+f32 > i32
+f32 > i32 != ok
+f32 > i32 * i
+f32 > i64
+f32 > i64 ? 1 : f64
+f32 > i64 ? ok : greet
+f32 > int(0.5)
+f32 > int(f64)
+f32 > max(i32)
+f32 > max(i32, 1)
+f32 > min(f64)
+f32 > score(1)
+f32 > score(i)
+f32 >= -f64
+f32 >= -i
+f32 >= -i32
+f32 >= -i64
+f32 >= 0.5 ** f64
+f32 >= 0.5 - 0.5
+f32 >= 0.5 == ok
+f32 >= 1 != ok
+f32 >= 1 != true
+f32 >= 1 % 1
+f32 >= 1 % i
+f32 >= 1 - 1
+f32 >= 1 - i
+f32 >= 1 - i64
+f32 >= 1 ? "foo" endsWith "foo" : f64
+f32 >= abs(1)
+f32 >= f32
+f32 >= f32 ** 1
+f32 >= f32 ** f32
+f32 >= f32 + i32
+f32 >= f64
+f32 >= f64 + i32
+f32 >= first(array)
+f32 >= float(i32)
+f32 >= float(i64)
+f32 >= half(f64)
+f32 >= i
+f32 >= i != true
+f32 >= i * 0.5
+f32 >= i ** 0.5
+f32 >= i ** i32
+f32 >= i + f64
+f32 >= i ? "bar" : nil
+f32 >= i ? ok : i
+f32 >= i32
+f32 >= i32 * 0.5
+f32 >= i32 ? array : foo
+f32 >= i32 ^ i32
+f32 >= i64
+f32 >= i64 % i64
+f32 >= i64 ** 0.5
+f32 >= i64 ? 1 : i32
+f32 >= i64 ? i64 : add
+f32 >= i64 || ok
+f32 >= len("foo")
+f32 >= max(i)
+f32 >= min(i)
+f32 >= score(1)
+f32 ^ (1 * f32)
+f32 ^ (1 + 1)
+f32 ^ (1 - 0.5)
+f32 ^ (f32 * 0.5)
+f32 ^ (f32 / 1)
+f32 ^ (i + i)
+f32 ^ (i32 % 1)
+f32 ^ (i32 % i64)
+f32 ^ (i32 / 1)
+f32 ^ (i32 / f64)
+f32 ^ (i64 - f32)
+f32 ^ -0.5
+f32 ^ -1
+f32 ^ -f32
+f32 ^ -i
+f32 ^ -i32
+f32 ^ -i64
+f32 ^ 0.5 != i64
+f32 ^ 0.5 + f32
+f32 ^ 0.5 + i64
+f32 ^ 0.5 - f64
+f32 ^ 0.5 <= 0.5 ^ 0.5
+f32 ^ 0.5 ^ f32
+f32 ^ 1 - i
+f32 ^ 1 - i32
+f32 ^ 1 <= 1 * 1
+f32 ^ 1 <= i32
+f32 ^ 1 ^ 0.5
+f32 ^ f32
+f32 ^ f32 ** i
+f32 ^ f32 + f32
+f32 ^ f32 / f32
+f32 ^ f64
+f32 ^ f64 < f64
+f32 ^ f64 < i64
+f32 ^ f64 <= f64
+f32 ^ f64 == f64
+f32 ^ f64 > i
+f32 ^ half(f64)
+f32 ^ i
+f32 ^ i ** i32
+f32 ^ i32
+f32 ^ i32 + f32
+f32 ^ i64
+f32 ^ last(array)
+f32 ^ max(0.5)
+f32 ^ max(f32)
+f32 ^ max(i64)
+f32 ^ min(1)
+f32 ^ min(1, 1)
+f32 ^ score(i)
+f32 in [false, list]
+f32 in [nil]
+f32 not in sort(array)
+f64
+f64 != -(0.5 ** 0.5)
+f64 != -1
+f64 != -f64
+f64 != -i
+f64 != -i32
+f64 != 0.5 && ok
+f64 != 0.5 + 1
+f64 != 0.5 + f64
+f64 != 0.5 == nil
+f64 != 0.5 == true
+f64 != 0.5 ? false : array
+f64 != 0.5 and ok
+f64 != 1 ? list : false
+f64 != 1 ^ i64
+f64 != abs(f32)
+f64 != array[i64]
+f64 != f32
+f64 != f32 * i32
+f64 != f64
+f64 != f64 * f32
+f64 != f64 ^ 1
+f64 != findLastIndex(list, ok)
+f64 != first(array)
+f64 != get(array, i32)
+f64 != half(0.5)
+f64 != half(f64)
+f64 != i
+f64 != i && ok
+f64 != i + 1
+f64 != i32
+f64 != i32 + f64
+f64 != i32 ? "bar" : nil
+f64 != i32 ? add : 1
+f64 != i32 ^ 0.5
+f64 != i64
+f64 != i64 ** 0.5
+f64 != int(i64)
+f64 != max(i64)
+f64 != min(1)
+f64 != min(i32)
+f64 != nil == ok
+f64 != score(1)
+f64 != score(i)
+f64 * (0.5 - f32)
+f64 * (0.5 - i64)
+f64 * (f32 + i32)
+f64 * (i32 - 0.5)
+f64 * (i64 - f64)
+f64 * -1
+f64 * -f32
+f64 * -f64
+f64 * -i32
+f64 * -i64
+f64 * 0.5 * 0.5 ^ i64
+f64 * 0.5 / i32
+f64 * 0.5 ^ 1
+f64 * 1 ** 0.5
+f64 * 1 + i64
+f64 * 1 / i32
+f64 * 1 < 0.5 * 0.5
+f64 * abs(i)
+f64 * f32
+f64 * f32 * f32
+f64 * f32 - f32
+f64 * f32 - f64
+f64 * f32 / f64
+f64 * f32 >= f64
+f64 * f64
+f64 * f64 / i
+f64 * f64 < f64
+f64 * f64 >= score(1)
+f64 * float(i)
+f64 * i
+f64 * i != i
+f64 * i * 0.5
+f64 * i * i
+f64 * i * i64
+f64 * i - f64
+f64 * i32
+f64 * i32 * 1
+f64 * i32 > f64
+f64 * i64
+f64 * i64 + f32
+f64 * i64 + i
+f64 * i64 - f32
+f64 * i64 ^ i32
+f64 * int(0.5)
+f64 * int(f32)
+f64 * int(f64)
+f64 * last(array)
+f64 * len(list)
+f64 * max(i64)
+f64 * min(i32)
+f64 * score(1)
+f64 * score(i)
+f64 ** (0.5 * i32)
+f64 ** (0.5 + 1)
+f64 ** (0.5 + i)
+f64 ** (1 + 1)
+f64 ** (1 + f64)
+f64 ** (1 - 1)
+f64 ** (1 / i64)
+f64 ** (f32 * i)
+f64 ** (f64 + 0.5)
+f64 ** (f64 + f64)
+f64 ** (f64 + i)
+f64 ** (i % 1)
+f64 ** (i % i32)
+f64 ** (i32 * 1)
+f64 ** (i32 + 0.5)
+f64 ** (i32 - f32)
+f64 ** (i64 * 1)
+f64 ** (i64 + 0.5)
+f64 ** (i64 / i)
+f64 ** -0.5
+f64 ** -1
+f64 ** -f32
+f64 ** -f64
+f64 ** -i
+f64 ** -i32
+f64 ** -i64
+f64 ** 0.5 ** i64
+f64 ** 0.5 <= 1 - 1
+f64 ** 1 ** 0.5 ** 0.5
+f64 ** 1 < 1 - i64
+f64 ** 1 == f64 + f32
+f64 ** 1 ^ i
+f64 ** 1 ^ i64
+f64 ** abs(1)
+f64 ** abs(f64)
+f64 ** f32
+f64 ** f32 ** 0.5
+f64 ** f32 == i64
+f64 ** f64
+f64 ** f64 != f32
+f64 ** f64 ** 0.5
+f64 ** f64 / f32
+f64 ** f64 < f64
+f64 ** f64 <= f64
+f64 ** f64 ^ f64
+f64 ** f64 ^ i32
+f64 ** float(i32)
+f64 ** get(array, i64)
+f64 ** half(0.5)
+f64 ** i
+f64 ** i != i
+f64 ** i - i32
+f64 ** i / f32
+f64 ** i >= i32
+f64 ** i ^ i32
+f64 ** i32
+f64 ** i32 != max(f64, 0.5)
+f64 ** i32 ** 1
+f64 ** i32 ^ 1
+f64 ** i64
+f64 ** i64 ** i64
+f64 ** i64 / f64
+f64 ** i64 ^ i
+f64 ** int(0.5)
+f64 ** int(1)
+f64 ** max(i32)
+f64 ** min(1)
+f64 ** min(f32)
+f64 ** score(1, 1)
+f64 + -0.5
+f64 + -f64
+f64 + -i
+f64 + -i32
+f64 + -i64
+f64 + 0.5 * 1
+f64 + 0.5 * i32
+f64 + 0.5 / f32
+f64 + 0.5 == i64
+f64 + 1 != f64
+f64 + 1 + f64
+f64 + 1 - 0.5
+f64 + 1 < i64
+f64 + 1 > 0.5 ? 1 : 0.5
+f64 + 1 > i64
+f64 + 1 >= f32
+f64 + abs(i)
+f64 + abs(i64)
+f64 + array[1]
+f64 + array[i64]
+f64 + count(array, ok)
+f64 + f32
+f64 + f32 * i32
+f64 + f32 - i64
+f64 + f64
+f64 + f64 + i64
+f64 + f64 == i32
+f64 + f64 > i32
+f64 + f64 ^ 0.5
+f64 + float(i64)
+f64 + half(0.5)
+f64 + half(f64)
+f64 + i
+f64 + i ** 0.5
+f64 + i + 1
+f64 + i / 0.5
+f64 + i32
+f64 + i32 ** i64
+f64 + i32 + i32
+f64 + i32 / 1
+f64 + i32 <= i
+f64 + i32 >= i64
+f64 + i64
+f64 + i64 - f64
+f64 + i64 ^ f32
+f64 + int(0.5)
+f64 + int(i32)
+f64 + len(array)
+f64 + min(0.5, 0.5)
+f64 + min(f32)
+f64 + score(i)
+f64 - -0.5
+f64 - -1
+f64 - -f64
+f64 - -i
+f64 - -i32
+f64 - -i64
+f64 - 0.5 != f64
+f64 - 0.5 * 0.5
+f64 - 0.5 ** i
+f64 - 0.5 + f32
+f64 - 0.5 + i
+f64 - 0.5 + i32
+f64 - 0.5 >= -0.5
+f64 - 1 * f32
+f64 - 1 ** f32
+f64 - 1 ** i32
+f64 - 1 + 1
+f64 - 1 - f64
+f64 - 1 / 0.5
+f64 - 1 < f32
+f64 - 1 ^ 0.5
+f64 - 1 ^ 1
+f64 - abs(0.5)
+f64 - abs(i)
+f64 - array[i64]
+f64 - f32
+f64 - f32 * f64
+f64 - f32 + 1 + 0.5
+f64 - f32 - f64
+f64 - f32 < f64
+f64 - f32 >= i32
+f64 - f64
+f64 - f64 - 0.5
+f64 - f64 - i32
+f64 - f64 <= i
+f64 - f64 == f64
+f64 - f64 > f32
+f64 - f64 >= get(array, i64)
+f64 - get(array, i)
+f64 - half(0.5)
+f64 - i
+f64 - i % i32
+f64 - i + 1
+f64 - i / 1
+f64 - i < i32
+f64 - i < i64
+f64 - i == i
+f64 - i == i64
+f64 - i > f64
+f64 - i32
+f64 - i32 + i
+f64 - i32 - i64
+f64 - i32 >= i32
+f64 - i64
+f64 - i64 * 0.5
+f64 - i64 * 1
+f64 - i64 - f32
+f64 - int(0.5)
+f64 - int(i32)
+f64 - max(1)
+f64 - min(1)
+f64 - min(i32, i64)
+f64 - score(i)
+f64 / (0.5 + f32)
+f64 / (0.5 - 0.5)
+f64 / (0.5 - f64)
+f64 / (0.5 - i32)
+f64 / (1 + i32)
+f64 / (1 - 1)
+f64 / (i32 + f64)
+f64 / (i32 - 1)
+f64 / (i64 - i64)
+f64 / -0.5
+f64 / -1
+f64 / -f32
+f64 / -i
+f64 / -i32
+f64 / 0.5 * i
+f64 / 0.5 ** 0.5
+f64 / 0.5 ** f64
+f64 / 0.5 / f64
+f64 / 0.5 / i64
+f64 / 0.5 > f64
+f64 / 0.5 ^ i
+f64 / 1 != i
+f64 / 1 * abs(i64)
+f64 / 1 * i
+f64 / 1 ** 0.5
+f64 / 1 ^ i64
+f64 / array[i32]
+f64 / array[i]
+f64 / f32
+f64 / f32 != f64
+f64 / f32 * i
+f64 / f32 > f64
+f64 / f32 ^ i32
+f64 / f32 in [f32]
+f64 / f64
+f64 / f64 != f32
+f64 / f64 * f32
+f64 / f64 - f32
+f64 / f64 - f64
+f64 / get(array, i64)
+f64 / half(0.5)
+f64 / i
+f64 / i * i32
+f64 / i ** 0.5
+f64 / i ** i32
+f64 / i + i64
+f64 / i < f64
+f64 / i > 1 ** 1
+f64 / i > f64
+f64 / i >= f64
+f64 / i32
+f64 / i32 / i32
+f64 / i32 < f64
+f64 / i64
+f64 / i64 * i64 ^ i
+f64 / i64 - f32
+f64 / i64 / 0.5
+f64 / i64 / i64
+f64 / i64 <= f64
+f64 / i64 > i
+f64 / int(f32)
+f64 / int(i64)
+f64 / max(i)
+f64 / min(0.5)
+f64 / score(i)
+f64 < -0.5
+f64 < -1
+f64 < -i32
+f64 < -i64
+f64 < 0.5 ** f32
+f64 < 0.5 == true
+f64 < 0.5 ? 0.5 : foo
+f64 < 0.5 ? 1 : array
+f64 < 0.5 ? greet : false
+f64 < 0.5 ^ 1
+f64 < 0.5 or ok
+f64 < 1 == not ok
+f64 < 1 ? 1 : half
+f64 < 1 ? 1 : i
+f64 < 1 ? ok : i
+f64 < 1 and nil == i32
+f64 < abs(1)
+f64 < abs(i32)
+f64 < array[i32]
+f64 < count(list, true)
+f64 < f32
+f64 < f32 * 0.5
+f64 < f32 * f64
+f64 < f32 ** i32
+f64 < f32 - 1
+f64 < f32 ? array : 0.5
+f64 < f64
+f64 < f64 * f32
+f64 < get(array, i)
+f64 < half(0.5)
+f64 < i
+f64 < i - f64
+f64 < i == ok
+f64 < i ? false : nil
+f64 < i32
+f64 < i32 % i32
+f64 < i32 % i64
+f64 < i32 == ok
+f64 < i32 and ok
+f64 < i64
+f64 < i64 * i
+f64 < int(0.5)
+f64 < max(1, i64)
+f64 < min(1)
+f64 < min(f64)
+f64 < min(i64)
+f64 <= -0.5
+f64 <= -1
+f64 <= -f32
+f64 <= -i
+f64 <= -i32
+f64 <= 0.5 != ok
+f64 <= 0.5 - 1
+f64 <= 0.5 / 0.5
+f64 <= 0.5 == true
+f64 <= 0.5 ? foo : list
+f64 <= 0.5 ? nil : add
+f64 <= 1 != true
+f64 <= 1 ** 0.5
+f64 <= 1 + 0.5
+f64 <= 1 == false
+f64 <= 1 ? array : foo
+f64 <= 1 ^ i64
+f64 <= abs(f32)
+f64 <= abs(i)
+f64 <= array[i]
+f64 <= f32
+f64 <= f32 + f64
+f64 <= f32 - 0.5
+f64 <= f32 ? false : "foo"
+f64 <= f32 ? false : i
+f64 <= f32 ? i64 : false
+f64 <= f64
+f64 <= f64 + f64
+f64 <= f64 - 0.5
+f64 <= f64 - f64
+f64 <= f64 ^ 0.5
+f64 <= find(array, true)
+f64 <= float(f64)
+f64 <= half(0.5)
+f64 <= i
+f64 <= i * i32
+f64 <= i ? false : false
+f64 <= i ? foo : false
+f64 <= i32
+f64 <= i32 == true
+f64 <= i32 ? "bar" : nil
+f64 <= i32 ? add : ok
+f64 <= i32 ? i32 : false
+f64 <= i64
+f64 <= i64 % 1
+f64 <= i64 - f32
+f64 <= i64 - i64
+f64 <= i64 ^ 1
+f64 <= i64 and ok
+f64 <= int(1)
+f64 <= int(f64)
+f64 <= int(i)
+f64 <= max(f32)
+f64 <= min(0.5)
+f64 <= score(1)
+f64 == -0.5
+f64 == -1
+f64 == -f32
+f64 == -f64
+f64 == -i
+f64 == -i32
+f64 == 0.5 != ok
+f64 == 0.5 ** 0.5
+f64 == 0.5 ** i32
+f64 == 0.5 / i
+f64 == 0.5 / i32
+f64 == 0.5 ? i64 : div
+f64 == 1 * f64
+f64 == 1 == nil
+f64 == 1 ? false : "foo"
+f64 == abs(1)
+f64 == abs(i32)
+f64 == array[i32]
+f64 == array[i64]
+f64 == f32
+f64 == f32 + i64
+f64 == f32 - 1
+f64 == f32 / 0.5
+f64 == f64
+f64 == f64 ** i32
+f64 == f64 - 1
+f64 == f64 / 1
+f64 == float(0.5)
+f64 == float(i)
+f64 == get(array, i64)
+f64 == half(f64)
+f64 == i
+f64 == i ** f32
+f64 == i + 0.5
+f64 == i / i32
+f64 == i ? false : f32
+f64 == i ^ f32
+f64 == i32
+f64 == i32 * 1
+f64 == i32 + f64
+f64 == i32 / 1
+f64 == i32 ? greet : array
+f64 == i64
+f64 == i64 - f32
+f64 == i64 == true
+f64 == int(0.5)
+f64 == int(f32)
+f64 == min(0.5)
+f64 == min(i64)
+f64 == nil == ok
+f64 == nil ? i32 : div
+f64 == nil ? nil : 0.5
+f64 == score(1)
+f64 > -0.5
+f64 > -1
+f64 > -f32
+f64 > -f64
+f64 > -i
+f64 > -i32
+f64 > 0.5 - f64
+f64 > 0.5 / 0.5
+f64 > 0.5 ? 0.5 : nil
+f64 > 0.5 ? score(1, 1) : nil == nil
+f64 > 0.5 ^ 1
+f64 > 0.5 || ok
+f64 > 1 != ok
+f64 > 1 != true
+f64 > 1 % i
+f64 > 1 * 0.5
+f64 > 1 - 0.5
+f64 > 1 - i32
+f64 > 1 / 0.5
+f64 > 1 / f64
+f64 > 1 ? 0.5 : ok
+f64 > 1 ? false : true
+f64 > 1 ^ 1
+f64 > abs(0.5)
+f64 > abs(1)
+f64 > abs(i)
+f64 > abs(i32)
+f64 > count(array, true)
+f64 > f32
+f64 > f32 - 0.5
+f64 > f64
+f64 > f64 ** 0.5
+f64 > f64 ? f64 : list
+f64 > f64 ^ 0.5
+f64 > findIndex(array, ok)
+f64 > float(1)
+f64 > float(f32)
+f64 > half(0.5)
+f64 > i
+f64 > i != ok
+f64 > i ** i32
+f64 > i - i32
+f64 > i32
+f64 > i32 ** f32
+f64 > i32 - f32
+f64 > i32 == ok
+f64 > i32 ? i : 0.5
+f64 > i64
+f64 > i64 ** i64
+f64 > int(0.5)
+f64 > int(i64)
+f64 > max(0.5)
+f64 > max(i64)
+f64 > min(1)
+f64 > min(f64)
+f64 > min(i)
+f64 > min(i32)
+f64 > score(i)
+f64 >= -0.5
+f64 >= -1
+f64 >= -f64
+f64 >= -i32
+f64 >= -i64
+f64 >= 0.5 * 1
+f64 >= 0.5 ** 0.5
+f64 >= 0.5 ** i32
+f64 >= 0.5 + 0.5
+f64 >= 0.5 + i
+f64 >= 0.5 - i
+f64 >= 0.5 - i32
+f64 >= 0.5 ? nil : 0.5
+f64 >= 0.5 ^ 0.5
+f64 >= 1 * i
+f64 >= 1 - 0.5
+f64 >= 1 / i64
+f64 >= 1 == ok
+f64 >= 1 ^ 1
+f64 >= 1 || ok
+f64 >= abs(1)
+f64 >= abs(f32)
+f64 >= abs(f64)
+f64 >= count(list, true)
+f64 >= f32
+f64 >= f32 != true
+f64 >= f32 - f32
+f64 >= f32 ? true : nil
+f64 >= f64
+f64 >= f64 * 0.5
+f64 >= f64 ? nil : f64
+f64 >= f64 ? score : f32
+f64 >= half(f64)
+f64 >= i
+f64 >= i - 1
+f64 >= i32
+f64 >= i32 != nil
+f64 >= i32 ** 0.5
+f64 >= i32 + f32
+f64 >= i32 + i64
+f64 >= i32 ^ f32
+f64 >= i64
+f64 >= i64 * 0.5
+f64 >= i64 * f64
+f64 >= i64 * i64
+f64 >= i64 ? list : i >= f32
+f64 >= i64 ? ok : true
+f64 >= i64 || ok
+f64 >= max(f64)
+f64 >= min(0.5)
+f64 >= score(1)
+f64 >= score(i)
+f64 ^ (0.5 * 1)
+f64 ^ (0.5 * f32)
+f64 ^ (0.5 / i)
+f64 ^ (1 + i)
+f64 ^ (1 - f32)
+f64 ^ (1 / 0.5)
+f64 ^ (1 / i64)
+f64 ^ -1
+f64 ^ 0.5 != f32
+f64 ^ 0.5 * i64
+f64 ^ 0.5 + f64
+f64 ^ 0.5 < 0.5 ^ 0.5
+f64 ^ 0.5 <= i64
+f64 ^ 0.5 > i == nil
+f64 ^ 0.5 >= i32 / i64
+f64 ^ 1 != i
+f64 ^ 1 ** i
+f64 ^ 1 + i
+f64 ^ 1 / f32
+f64 ^ 1 / i64
+f64 ^ 1 <= i32
+f64 ^ 1 ^ i
+f64 ^ abs(i32)
+f64 ^ count(array, true)
+f64 ^ f32
+f64 ^ f32 != i32
+f64 ^ f32 * f32
+f64 ^ f32 ** i
+f64 ^ f32 + f64
+f64 ^ f32 / i64
+f64 ^ f32 < i
+f64 ^ f32 >= i64
+f64 ^ f32 ^ i64
+f64 ^ f64
+f64 ^ f64 != f32
+f64 ^ f64 * i
+f64 ^ f64 + int(0.5)
+f64 ^ float(i64)
+f64 ^ half(0.5)
+f64 ^ half(f64)
+f64 ^ i
+f64 ^ i ** i32
+f64 ^ i / i
+f64 ^ i <= f32
+f64 ^ i32
+f64 ^ i32 ** i
+f64 ^ i32 + f64
+f64 ^ i32 >= i
+f64 ^ i32 ^ f64
+f64 ^ i64
+f64 ^ i64 + i64
+f64 ^ i64 - i
+f64 ^ i64 < i
+f64 ^ i64 >= i32
+f64 ^ int(f64)
+f64 ^ last(array)
+f64 ^ len(list)
+f64 ^ max(0.5)
+f64 ^ score(1)
+false != true || 1 > f64
+false && ok or ok
+false ? "bar" : 0.5 == f32
+false ? "bar" : 1 != i
+false ? "bar" : foo.Qux
+false ? 0.5 : foo.Qux
+false ? 1 : half != div
+false ? 1 : true != ok
+false ? add : foo?.Bar
+false ? f32 : foo.Bar
+false ? f32 : foo?.String()
+false ? f32 : i .. i32
+false ? f64 : 0.5 >= f64
+false ? f64 : f32 / f32
+false ? false : 0.5 + i32
+false ? false : i64 >= i
+false ? foo : foo.Qux
+false ? greet : i64 != i
+false ? half : 0.5 > 1 + i64
+false ? half : f32 > min(0.5)
+false ? i : 1 != i
+false ? i32 : 1 >= f64
+false ? i64 : "foo" < toJSON(f64)
+false ? i64 : foo?.Qux
+false ? list : 1 < f32
+false ? list : f32 ** i32
+false ? list : foo.Bar
+false ? nil : 1 >= get(array, 1)
+false ? nil : foo?.Qux
+false ? ok : foo.String
+false ? score : 0.5 == i
+false ? score : 1 / i64
+false ? score : f64 - -f32
+false ? true : 0.5 == f32
+false or ok ? string(1) : f64 == f32
+filter(1 .. 1, # == 0.5)
+filter(1 .. i64, ok)
+filter([div], any(array, true))
+filter([i32, i], # <= f64)
+filter(array, !false)
+filter(array, !ok)
+filter(array, "bar" == "bar")
+filter(array, "bar" matches "bar")
+filter(array, "foo" not matches "bar")
+filter(array, # != #)
+filter(array, # != f64)
+filter(array, # != i)
+filter(array, # != i32)
+filter(array, # != i64)
+filter(array, # < #)
+filter(array, # < 1)
+filter(array, # < f32)
+filter(array, # < f64)
+filter(array, # < i)
+filter(array, # < i32)
+filter(array, # <= #)
+filter(array, # <= 0.5)
+filter(array, # <= 1)
+filter(array, # <= f64)
+filter(array, # <= i)
+filter(array, # <= i32)
+filter(array, # == #)
+filter(array, # == 1)
+filter(array, # == f32)
+filter(array, # == f64)
+filter(array, # == i)
+filter(array, # == nil)
+filter(array, # > #)
+filter(array, # > 1)
+filter(array, # > i)
+filter(array, # >= #)
+filter(array, # >= 1)
+filter(array, # >= f32)
+filter(array, # >= f64)
+filter(array, # >= i32)
+filter(array, # in array)
+filter(array, # not in array)
+filter(array, 0.5 != #)
+filter(array, 0.5 < #)
+filter(array, 0.5 < f32)
+filter(array, 0.5 < f64)
+filter(array, 0.5 == #)
+filter(array, 0.5 > 0.5)
+filter(array, 0.5 >= #)
+filter(array, 1 != #)
+filter(array, 1 != f32)
+filter(array, 1 < #)
+filter(array, 1 < f64)
+filter(array, 1 <= #)
+filter(array, 1 == #)
+filter(array, 1 > #)
+filter(array, 1 > 0.5)
+filter(array, add == div)
+filter(array, all(list, ok))
+filter(array, f32 != #)
+filter(array, f32 < i32)
+filter(array, f32 <= f32)
+filter(array, f32 == #)
+filter(array, f32 > 1)
+filter(array, f32 >= #)
+filter(array, f64 != #)
+filter(array, f64 != 0.5)
+filter(array, f64 <= #)
+filter(array, f64 == #)
+filter(array, f64 > #)
+filter(array, f64 >= 1)
+filter(array, foo == nil)
+filter(array, greet == add)
+filter(array, greet == half)
+filter(array, i <= 1)
+filter(array, i <= f64)
+filter(array, i == f32)
+filter(array, i >= 1)
+filter(array, i >= f64 != false)
+filter(array, i32 != #)
+filter(array, i32 <= #)
+filter(array, i32 == #)
+filter(array, i32 == 1)
+filter(array, i32 > # % #)
+filter(array, i32 > #)
+filter(array, i32 > 0.5)
+filter(array, i32 >= #)
+filter(array, i64 != #)
+filter(array, i64 < #)
+filter(array, i64 < 1)
+filter(array, i64 < i64)
+filter(array, i64 <= #)
+filter(array, i64 == 1)
+filter(array, nil != #)
+filter(array, nil != greet)
+filter(array, nil == #)
+filter(array, nil == f32)
+filter(array, nil in list)
+filter(array, none(array, ok))
+filter(array, ok)
+filter(array, score(#) != #)
+filter(array, true && ok)
+filter(array, true or false)
+filter(array, true)[i:i32]
+filter(filter(array, true), i >= f32)
+filter(filter(list, false), "bar" in #)
+filter(filter(list, ok), ok)
+filter(i .. 1, not ok)
+filter(i32 .. i32, nil == true)
+filter(i32 .. i64, ok)
+filter(list, !false)
+filter(list, !ok)
+filter(list, !true)
+filter(list, "bar" not in #)
+filter(list, "bar" not matches "foo")
+filter(list, "bar" startsWith "bar")
+filter(list, "foo" in #)
+filter(list, "foo" not in #)
+filter(list, # != #)
+filter(list, # != foo)
+filter(list, # != nil)
+filter(list, # == #)
+filter(list, # == foo)
+filter(list, # == nil)
+filter(list, 0.5 != f64)
+filter(list, 0.5 != i)
+filter(list, 0.5 > f32)
+filter(list, 1 != 0.5)
+filter(list, 1 != i32)
+filter(list, 1 != nil)
+filter(list, 1 < 0.5)
+filter(list, 1 < 1)
+filter(list, all(array, false))
+filter(list, all(array, true))
+filter(list, div == half)
+filter(list, f32 < 0.5)
+filter(list, f32 <= f32)
+filter(list, f32 == i64)
+filter(list, f32 >= 1)
+filter(list, f64 >= 0.5)
+filter(list, false == ok)
+filter(list, foo != #)
+filter(list, foo == #)
+filter(list, foo == foo)
+filter(list, foo in list)
+filter(list, greet != nil)
+filter(list, half != half)
+filter(list, i <= 0.5)
+filter(list, i <= i)
+filter(list, i == f32)
+filter(list, i == i32)
+filter(list, i == i64)
+filter(list, i >= i32)
+filter(list, i32 != 1)
+filter(list, i32 != nil)
+filter(list, i32 < i64)
+filter(list, i32 <= i32)
+filter(list, i32 == i)
+filter(list, i64 > f32)
+filter(list, nil != f64)
+filter(list, nil != score)
+filter(list, nil != true)
+filter(list, nil == #)
+filter(list, not ok)
+filter(list, ok or true)
+filter(list, ok || true)
+filter(list, ok)
+filter(list, true == nil)
+filter(map(array, "bar"), # >= #)
+filter(map(array, "foo"), ok)
+filter(map(array, #), # != 0.5)
+filter(map(array, #), ok)
+filter(map(array, 0.5 >= #), ok)
+filter(map(list, "bar"), i >= i)
+filter(map(list, "foo"), "bar" not matches #)
+filter(map(list, #), # != #)
+filter(map(list, #), ok)
+filter(map(list, 1), f32 != #)
+filter(map(list, false), #)
+filter(sort(array), ok)
+filter(split("foo", "bar"), ok)
+find(1 .. 1, # <= #)
+find([nil], 0.5 == 0.5)
+find([ok], #)
+find(array, !ok)
+find(array, !true)
+find(array, "bar" startsWith "foo")
+find(array, # != #)
+find(array, # != 0.5)
+find(array, # != f32)
+find(array, # != i32)
+find(array, # - # != #)
+find(array, # < #)
+find(array, # < 0.5)
+find(array, # < 1)
+find(array, # < f32)
+find(array, # < f64)
+find(array, # < i32)
+find(array, # <= #)
+find(array, # <= 0.5)
+find(array, # <= 1)
+find(array, # <= f32)
+find(array, # <= i)
+find(array, # == #)
+find(array, # == 0.5)
+find(array, # == 1)
+find(array, # == f32)
+find(array, # == f64)
+find(array, # == i)
+find(array, # == i32)
+find(array, # == nil)
+find(array, # > #)
+find(array, # > 0.5)
+find(array, # > i)
+find(array, # > i64)
+find(array, # >= #)
+find(array, # >= 1)
+find(array, # >= i)
+find(array, # >= i32)
+find(array, 0.5 < i64)
+find(array, 0.5 <= #)
+find(array, 0.5 == #)
+find(array, 0.5 > #)
+find(array, 0.5 > 1)
+find(array, 1 <= #)
+find(array, 1 <= 0.5)
+find(array, 1 == f32)
+find(array, 1 == i64)
+find(array, 1 > #)
+find(array, 1 > 0.5)
+find(array, 1 > i32)
+find(array, 1 > i64)
+find(array, 1 >= #)
+find(array, 1 >= i)
+find(array, add != div)
+find(array, add != nil)
+find(array, any(array, true))
+find(array, array == list)
+find(array, div == half)
+find(array, f32 <= #)
+find(array, f32 > #)
+find(array, f32 > 0.5)
+find(array, f32 >= #)
+find(array, f32 >= 1)
+find(array, f64 != #)
+find(array, f64 != i32)
+find(array, f64 != nil)
+find(array, f64 < #)
+find(array, f64 == nil)
+find(array, f64 >= 0.5)
+find(array, false == false)
+find(array, false) != i32
+find(array, i < #)
+find(array, i <= #)
+find(array, i == #)
+find(array, i > #)
+find(array, i >= #)
+find(array, i >= i64)
+find(array, i32 != #)
+find(array, i32 != 1)
+find(array, i32 < #)
+find(array, i32 <= #)
+find(array, i32 <= f32)
+find(array, i32 <= f64)
+find(array, i32 == #)
+find(array, i32 == 1)
+find(array, i32 == f64)
+find(array, i32 > #)
+find(array, i64 != #)
+find(array, i64 < #)
+find(array, nil != "bar")
+find(array, nil != #)
+find(array, nil == #)
+find(array, nil not in array)
+find(array, not false)
+find(array, not true)
+find(array, ok && ok)
+find(array, ok == nil)
+find(array, ok)
+find(array, ok) * f64
+find(array, ok) ** i64
+find(array, ok) ^ i32
+find(array, score(#) >= #)
+find(array, true) / get(array, i64)
+find(array, true) > i
+find(array, true) ^ i32
+find(filter(array, ok), # >= #)
+find(filter(array, true), # != #)
+find(i32 .. 1, # > 0.5)
+find(i64 .. 1, ok)
+find(list, !true)
+find(list, "bar" startsWith "foo")
+find(list, "foo" < "foo")
+find(list, "foo" in #)
+find(list, "foo" not in #)
+find(list, # != #)
+find(list, # == #)
+find(list, # == nil)
+find(list, # not in list)
+find(list, 0.5 < f64)
+find(list, 0.5 <= i64)
+find(list, 0.5 > i)
+find(list, 1 < 0.5)
+find(list, 1 <= 0.5)
+find(list, 1 > i)
+find(list, add == add)
+find(list, f32 != f32)
+find(list, f32 < f64)
+find(list, f32 <= f32)
+find(list, f32 <= i32)
+find(list, f32 == f32)
+find(list, f64 != f32)
+find(list, f64 <= i64)
+find(list, f64 >= f32)
+find(list, false)?.Bar
+find(list, foo != #)
+find(list, foo == #)
+find(list, i < 1)
+find(list, i >= f64)
+find(list, i32 <= f32)
+find(list, i64 != f64)
+find(list, i64 >= 0.5)
+find(list, list != array)
+find(list, nil != #)
+find(list, nil != greet)
+find(list, nil != half)
+find(list, nil != ok)
+find(list, nil == #)
+find(list, nil == half)
+find(list, nil == score)
+find(list, nil not in array)
+find(list, nil not in list)
+find(list, not ok)
+find(list, ok or ok)
+find(list, ok)
+find(list, ok).Bar
+find(list, ok).Qux
+find(list, ok).String
+find(list, ok)?.Qux
+find(list, ok)?.String
+find(list, score != add)
+find(list, score != greet)
+find(list, true).Bar
+find(list, true).Qux
+find(list, true).String
+find(list, true)?.Bar
+find(list, true)?.Qux
+find(list, true)?.String
+find(list, true)?.String()
+find(map(array, #), # == #)
+find(map(array, #), ok)
+find(map(array, i), ok)
+find(map(array, true), #)
+find(map(list, "foo"), ok)
+find(map(list, #), # != #)
+find(map(list, 0.5), # >= #)
+find(map(list, ok), ok)
+find(map(list, true), #)
+find(ok ? "bar" : 0.5, # != i32)
+find(sort(array), ok)
+find(true ? array : false, 0.5 > #)?.list
+findIndex(["bar"], ok)
+findIndex(["foo"], 0.5 > i64)
+findIndex(["foo"], ok)
+findIndex([1], # < #)
+findIndex([f64, greet], 1 > f64)
+findIndex([false], #)
+findIndex(array, !(# != #))
+findIndex(array, !(# == 1))
+findIndex(array, !false)
+findIndex(array, !ok)
+findIndex(array, !true)
+findIndex(array, "bar" not endsWith "bar")
+findIndex(array, "bar" not startsWith "foo")
+findIndex(array, # != #)
+findIndex(array, # != 0.5)
+findIndex(array, # != f32)
+findIndex(array, # != f64)
+findIndex(array, # != i32)
+findIndex(array, # != i64)
+findIndex(array, # != nil)
+findIndex(array, # ** # > #)
+findIndex(array, # < #)
+findIndex(array, # < 1)
+findIndex(array, # < f64)
+findIndex(array, # < i)
+findIndex(array, # < i32)
+findIndex(array, # < i64)
+findIndex(array, # <= #)
+findIndex(array, # <= 1)
+findIndex(array, # <= i)
+findIndex(array, # <= i32)
+findIndex(array, # == #)
+findIndex(array, # == 1)
+findIndex(array, # == f64)
+findIndex(array, # == i32)
+findIndex(array, # > #)
+findIndex(array, # > 0.5)
+findIndex(array, # > 1)
+findIndex(array, # > f32)
+findIndex(array, # > f64)
+findIndex(array, # > i64 - i)
+findIndex(array, # > i64)
+findIndex(array, # >= #)
+findIndex(array, # >= 1)
+findIndex(array, # >= f32)
+findIndex(array, # >= i)
+findIndex(array, # >= i32)
+findIndex(array, # in array)
+findIndex(array, # not in array)
+findIndex(array, 0.5 < #)
+findIndex(array, 0.5 <= 1)
+findIndex(array, 0.5 <= f32)
+findIndex(array, 0.5 == #)
+findIndex(array, 0.5 > i64)
+findIndex(array, 0.5 >= #)
+findIndex(array, 0.5 >= i)
+findIndex(array, 1 != #)
+findIndex(array, 1 < #)
+findIndex(array, 1 < f32)
+findIndex(array, 1 < i64)
+findIndex(array, 1 <= #)
+findIndex(array, 1 == #)
+findIndex(array, 1 > #)
+findIndex(array, 1 >= #)
+findIndex(array, add != half)
+findIndex(array, any(array, f32 < #))
+findIndex(array, f32 <= #)
+findIndex(array, f32 == #)
+findIndex(array, f32 == nil)
+findIndex(array, f32 > #)
+findIndex(array, f32 >= #)
+findIndex(array, f64 <= #)
+findIndex(array, f64 <= i64)
+findIndex(array, f64 == #)
+findIndex(array, f64 > #)
+findIndex(array, f64 >= #)
+findIndex(array, f64 >= 1)
+findIndex(array, half != greet)
+findIndex(array, i != #)
+findIndex(array, i < 0.5)
+findIndex(array, i <= #)
+findIndex(array, i <= i32)
+findIndex(array, i == #)
+findIndex(array, i == i)
+findIndex(array, i > #)
+findIndex(array, i >= i)
+findIndex(array, i32 != #)
+findIndex(array, i32 < #)
+findIndex(array, i32 < f64)
+findIndex(array, i32 < i)
+findIndex(array, i32 <= #)
+findIndex(array, i32 == #)
+findIndex(array, i32 == nil)
+findIndex(array, i32 > #)
+findIndex(array, i64 != #)
+findIndex(array, i64 == #)
+findIndex(array, i64 > #)
+findIndex(array, i64 >= #)
+findIndex(array, nil != #)
+findIndex(array, nil != 1)
+findIndex(array, nil != list)
+findIndex(array, nil == foo)
+findIndex(array, nil == i)
+findIndex(array, not ok)
+findIndex(array, ok)
+findIndex(array, ok) * f64
+findIndex(array, ok) - i32
+findIndex(array, ok) / f64
+findIndex(array, ok) >= f64
+findIndex(array, score == greet)
+findIndex(array, true or false)
+findIndex(false ? div : list, ok)
+findIndex(list, !false)
+findIndex(list, !true)
+findIndex(list, "bar" == "bar")
+findIndex(list, "foo" != "bar")
+findIndex(list, "foo" contains "bar")
+findIndex(list, "foo" matches "bar")
+findIndex(list, # != #)
+findIndex(list, # != foo)
+findIndex(list, # != nil)
+findIndex(list, # == #)
+findIndex(list, # == nil)
+findIndex(list, # in list)
+findIndex(list, 0.5 < i)
+findIndex(list, 0.5 <= f64)
+findIndex(list, 0.5 <= i64)
+findIndex(list, 0.5 > f64)
+findIndex(list, 0.5 >= f32)
+findIndex(list, 1 == nil)
+findIndex(list, array != list)
+findIndex(list, f32 < f64)
+findIndex(list, f64 <= f32)
+findIndex(list, f64 <= f64)
+findIndex(list, f64 == nil)
+findIndex(list, f64 > f64)
+findIndex(list, false && true)
+findIndex(list, foo != #)
+findIndex(list, foo == #)
+findIndex(list, greet != half)
+findIndex(list, half == add)
+findIndex(list, i32 == i)
+findIndex(list, i32 > f64)
+findIndex(list, i32 >= i32)
+findIndex(list, i64 < 0.5)
+findIndex(list, i64 > f64)
+findIndex(list, nil != #)
+findIndex(list, nil != f64)
+findIndex(list, nil != false)
+findIndex(list, nil == #)
+findIndex(list, nil == 0.5)
+findIndex(list, nil == ok)
+findIndex(list, nil in list)
+findIndex(list, not false)
+findIndex(list, not ok)
+findIndex(list, ok != ok)
+findIndex(list, ok or ok)
+findIndex(list, ok)
+findIndex(list, ok) + f32
+findIndex(list, ok) / i
+findIndex(list, ok) > i32
+findIndex(list, one(list, ok))
+findIndex(list, true ? true : true)
+findIndex(list, true) .. i
+findIndex(list, true) == 0.5 ^ i32
+findIndex(list, true) > i32 ** f32
+findIndex(list, true) not in array
+findIndex(map(array, #), # > #)
+findIndex(map(array, #), # >= f32)
+findIndex(map(array, 1), # != #)
+findIndex(map(array, add), i64 >= i64)
+findIndex(map(array, div), # == #)
+findIndex(map(array, false), #)
+findIndex(map(array, i64), ok)
+findIndex(map(list, #), !ok)
+findIndex(map(list, #), div == div)
+findIndex(map(list, #), ok)
+findIndex(map(list, f32), i32 == f64)
+findIndex(map(list, list), ok)
+findIndex(map(list, ok), # == ok)
+findIndex(sort(array), # < #)
+findIndex(true ? "bar" : i32, # < #)
+findIndex(true ? "bar" : true, ok)
+findLast([0.5], i64 != 0.5)
+findLast(array, !false)
+findLast(array, !true)
+findLast(array, "bar" > "bar")
+findLast(array, "foo" startsWith "foo")
+findLast(array, # != #)
+findLast(array, # != f64)
+findLast(array, # != nil)
+findLast(array, # < #)
+findLast(array, # < 0.5)
+findLast(array, # < 1)
+findLast(array, # < f32)
+findLast(array, # < f64)
+findLast(array, # < i)
+findLast(array, # <= #)
+findLast(array, # <= 0.5)
+findLast(array, # <= 1)
+findLast(array, # <= f32)
+findLast(array, # <= f64)
+findLast(array, # <= i)
+findLast(array, # <= i64)
+findLast(array, # == #)
+findLast(array, # == 0.5)
+findLast(array, # == f64)
+findLast(array, # == i64)
+findLast(array, # > #)
+findLast(array, # > 0.5)
+findLast(array, # > i)
+findLast(array, # > i32)
+findLast(array, # > i64)
+findLast(array, # >= #)
+findLast(array, # >= 0.5)
+findLast(array, # >= f64)
+findLast(array, # >= i)
+findLast(array, # >= i32)
+findLast(array, # not in array)
+findLast(array, 0.5 != #)
+findLast(array, 0.5 != 0.5)
+findLast(array, 0.5 != i)
+findLast(array, 0.5 < #)
+findLast(array, 0.5 < i64)
+findLast(array, 0.5 <= #)
+findLast(array, 0.5 == #)
+findLast(array, 0.5 > 0.5)
+findLast(array, 0.5 >= 1)
+findLast(array, 0.5 >= f64)
+findLast(array, 1 != #)
+findLast(array, 1 != i64)
+findLast(array, 1 < #)
+findLast(array, 1 <= #)
+findLast(array, 1 <= 0.5)
+findLast(array, 1 <= f32)
+findLast(array, 1 == #)
+findLast(array, 1 == nil)
+findLast(array, 1 > #)
+findLast(array, 1 >= #)
+findLast(array, 1 >= 1)
+findLast(array, add != greet)
+findLast(array, array == array)
+findLast(array, div != score)
+findLast(array, f32 != nil)
+findLast(array, f32 < #)
+findLast(array, f32 >= #)
+findLast(array, f32 >= 1)
+findLast(array, f64 != i)
+findLast(array, f64 < i64)
+findLast(array, f64 >= #)
+findLast(array, foo != nil)
+findLast(array, half == nil)
+findLast(array, i != i32)
+findLast(array, i < #)
+findLast(array, i <= #)
+findLast(array, i >= #)
+findLast(array, i32 != #)
+findLast(array, i32 <= f32)
+findLast(array, i32 == 1)
+findLast(array, i32 > #)
+findLast(array, i32 >= #)
+findLast(array, i32 >= 0.5)
+findLast(array, i64 != #)
+findLast(array, i64 != 1)
+findLast(array, i64 < #)
+findLast(array, i64 <= #)
+findLast(array, i64 <= 0.5)
+findLast(array, i64 == #)
+findLast(array, i64 == nil)
+findLast(array, i64 >= #)
+findLast(array, i64 >= i32)
+findLast(array, nil != #)
+findLast(array, nil != nil)
+findLast(array, nil == #)
+findLast(array, nil == nil)
+findLast(array, not false)
+findLast(array, not true)
+findLast(array, ok)
+findLast(array, ok) < f64
+findLast(array, true) + i
+findLast(array, true) + i32
+findLast(array, true) <= f64
+findLast(array, true) > i
+findLast(i .. 1, # > f32)
+findLast(i32 .. 1, # >= #)
+findLast(i32 .. i32, ok)
+findLast(i64 .. 1, f32 <= #)
+findLast(list, !true)
+findLast(list, "bar" in #)
+findLast(list, "bar" not contains "bar")
+findLast(list, "bar" not in #)
+findLast(list, "bar" not matches "bar")
+findLast(list, "foo" == "foo")
+findLast(list, "foo" > "foo")
+findLast(list, "foo" in #)
+findLast(list, "foo" not in #)
+findLast(list, # != #)
+findLast(list, # == #)
+findLast(list, # == foo)
+findLast(list, # == nil)
+findLast(list, # not in list)
+findLast(list, 0.5 == nil)
+findLast(list, 0.5 > f32)
+findLast(list, 1 != 0.5)
+findLast(list, 1 != 1)
+findLast(list, 1 <= i)
+findLast(list, 1 > 1)
+findLast(list, 1 > i)
+findLast(list, 1 >= 0.5)
+findLast(list, 1 >= 1)
+findLast(list, add == nil)
+findLast(list, all(list, false))
+findLast(list, f32 < f64)
+findLast(list, false)?.Bar
+findLast(list, foo != #)?.Bar
+findLast(list, foo == #)
+findLast(list, greet == half)
+findLast(list, i != 1)
+findLast(list, i != i64)
+findLast(list, i >= f32)
+findLast(list, i32 == 1)
+findLast(list, i64 <= 0.5)
+findLast(list, i64 <= i)
+findLast(list, i64 == i32)
+findLast(list, i64 > 0.5)
+findLast(list, i64 > i)
+findLast(list, i64 >= i32)
+findLast(list, nil != "bar")
+findLast(list, nil != #)
+findLast(list, nil != add)
+findLast(list, nil != false)
+findLast(list, nil != foo)
+findLast(list, nil != nil)
+findLast(list, nil != ok)
+findLast(list, nil == #)
+findLast(list, nil == i32)
+findLast(list, nil == i64)
+findLast(list, nil == list)
+findLast(list, nil == nil)
+findLast(list, not ok)
+findLast(list, ok ? ok : nil)
+findLast(list, ok)
+findLast(list, ok).Bar
+findLast(list, ok).Qux
+findLast(list, ok).String
+findLast(list, ok).String()
+findLast(list, ok)?.Bar
+findLast(list, ok)?.Qux
+findLast(list, ok)?.String
+findLast(list, one(list, true))
+findLast(list, true != nil)
+findLast(list, true).Bar
+findLast(list, true).Qux
+findLast(list, true).String
+findLast(list, true)?.Bar
+findLast(list, true)?.Qux
+findLast(list, true)?.String
+findLast(map(array, #), # > f32)
+findLast(map(array, #), # >= #)
+findLast(map(array, #), i32 == #)
+findLast(map(array, #), ok)
+findLast(map(array, f64), # <= #)
+findLast(map(array, i), # <= #)
+findLast(map(array, ok), #)
+findLast(map(array, ok), not #)
+findLast(map(array, true), #)
+findLast(map(list, #), # != #)
+findLast(map(list, array), # == #)
+findLast(map(list, i), # >= #)
+findLast(map(list, list), ok)
+findLast(map(list, score), 0.5 > f32)
+findLast(ok ? array : div, # >= #)
+findLast(sort(array), # && false)
+findLastIndex([i32], # >= 0.5)
+findLastIndex(array, !false)
+findLastIndex(array, !ok)
+findLastIndex(array, !true)
+findLastIndex(array, "bar" != "bar")
+findLastIndex(array, # != #)
+findLastIndex(array, # != 0.5)
+findLastIndex(array, # != i64)
+findLastIndex(array, # != nil)
+findLastIndex(array, # / f32 == #)
+findLastIndex(array, # < # ** i32)
+findLastIndex(array, # < #)
+findLastIndex(array, # < 0.5)
+findLastIndex(array, # < 1)
+findLastIndex(array, # < f32)
+findLastIndex(array, # < f64)
+findLastIndex(array, # < i)
+findLastIndex(array, # < i64)
+findLastIndex(array, # <= #)
+findLastIndex(array, # <= 0.5)
+findLastIndex(array, # <= 1)
+findLastIndex(array, # <= f32)
+findLastIndex(array, # <= f64)
+findLastIndex(array, # <= i)
+findLastIndex(array, # <= i32)
+findLastIndex(array, # <= i64)
+findLastIndex(array, # == #)
+findLastIndex(array, # == 0.5)
+findLastIndex(array, # == 1)
+findLastIndex(array, # == i32)
+findLastIndex(array, # == nil)
+findLastIndex(array, # > #)
+findLastIndex(array, # > 0.5)
+findLastIndex(array, # > 1)
+findLastIndex(array, # > i)
+findLastIndex(array, # > i64)
+findLastIndex(array, # >= #)
+findLastIndex(array, # >= 1)
+findLastIndex(array, # >= f64)
+findLastIndex(array, # in array)
+findLastIndex(array, # not in array)
+findLastIndex(array, 0.5 != #)
+findLastIndex(array, 0.5 != 0.5)
+findLastIndex(array, 0.5 < #)
+findLastIndex(array, 0.5 < i)
+findLastIndex(array, 0.5 <= #)
+findLastIndex(array, 0.5 <= 0.5)
+findLastIndex(array, 0.5 == #)
+findLastIndex(array, 0.5 > #)
+findLastIndex(array, 0.5 > i)
+findLastIndex(array, 0.5 >= #)
+findLastIndex(array, 0.5 >= f32)
+findLastIndex(array, 1 != #)
+findLastIndex(array, 1 < #)
+findLastIndex(array, 1 <= #)
+findLastIndex(array, 1 <= i)
+findLastIndex(array, 1 <= i64)
+findLastIndex(array, 1 == #)
+findLastIndex(array, 1 > #)
+findLastIndex(array, 1 > 1)
+findLastIndex(array, 1 >= #)
+findLastIndex(array, 1 in array)
+findLastIndex(array, add != add)
+findLastIndex(array, any(list, false))
+findLastIndex(array, f32 != #)
+findLastIndex(array, f32 < #)
+findLastIndex(array, f32 <= f64)
+findLastIndex(array, f32 == f64)
+findLastIndex(array, f32 > #)
+findLastIndex(array, f32 >= f64)
+findLastIndex(array, f64 != #)
+findLastIndex(array, f64 < #)
+findLastIndex(array, f64 == #)
+findLastIndex(array, f64 > i)
+findLastIndex(array, f64 >= #)
+findLastIndex(array, i == #)
+findLastIndex(array, i > #)
+findLastIndex(array, i > 1)
+findLastIndex(array, i >= #)
+findLastIndex(array, i32 != #)
+findLastIndex(array, i32 < #)
+findLastIndex(array, i32 <= 0.5)
+findLastIndex(array, i32 == #)
+findLastIndex(array, i32 == i32)
+findLastIndex(array, i32 > #)
+findLastIndex(array, i64 != #)
+findLastIndex(array, i64 != f32)
+findLastIndex(array, i64 >= #)
+findLastIndex(array, list != nil)
+findLastIndex(array, nil != "foo")
+findLastIndex(array, nil != #)
+findLastIndex(array, nil != 0.5)
+findLastIndex(array, nil != foo)
+findLastIndex(array, nil != nil)
+findLastIndex(array, nil == #)
+findLastIndex(array, nil == i)
+findLastIndex(array, nil not in list)
+findLastIndex(array, none(array, true))
+findLastIndex(array, not (# != #))
+findLastIndex(array, not false)
+findLastIndex(array, ok)
+findLastIndex(array, ok) * f64
+findLastIndex(array, ok) / i64
+findLastIndex(array, ok) <= i64
+findLastIndex(array, ok) ^ f32
+findLastIndex(array, true ? ok : 1)
+findLastIndex(array, true) / f32
+findLastIndex(array, true) <= i64
+findLastIndex(array, true) > f64
+findLastIndex(false ? i : "bar", ok)
+findLastIndex(filter(list, true), ok)
+findLastIndex(i .. i32, # == 1)
+findLastIndex(i32 .. i, ok)
+findLastIndex(i32 .. i64, f64 == nil)
+findLastIndex(i64 .. 1, # != nil)
+findLastIndex(i64 .. 1, add == nil)
+findLastIndex(list, !ok)
+findLastIndex(list, !true)
+findLastIndex(list, "bar" in #)
+findLastIndex(list, "foo" matches "bar")
+findLastIndex(list, # != #)
+findLastIndex(list, # != foo)
+findLastIndex(list, # != nil)
+findLastIndex(list, # == #)
+findLastIndex(list, # == nil)
+findLastIndex(list, # in list)
+findLastIndex(list, 0.5 != i)
+findLastIndex(list, 0.5 <= 0.5)
+findLastIndex(list, 0.5 <= f32)
+findLastIndex(list, 1 != 0.5)
+findLastIndex(list, 1 != f64)
+findLastIndex(list, 1 != i64)
+findLastIndex(list, 1 < i32)
+findLastIndex(list, 1 <= f32)
+findLastIndex(list, 1 <= i)
+findLastIndex(list, array != list)
+findLastIndex(list, array != nil)
+findLastIndex(list, array == list)
+findLastIndex(list, div == add)
+findLastIndex(list, div == score)
+findLastIndex(list, f32 != 0.5)
+findLastIndex(list, f32 < f64)
+findLastIndex(list, f32 < i32)
+findLastIndex(list, f32 <= i64)
+findLastIndex(list, f32 == i32)
+findLastIndex(list, f32 > f32)
+findLastIndex(list, f64 <= 1)
+findLastIndex(list, f64 == f64)
+findLastIndex(list, false == false)
+findLastIndex(list, false and false)
+findLastIndex(list, false and ok)
+findLastIndex(list, false) != i
+findLastIndex(list, foo != #)
+findLastIndex(list, foo == foo)
+findLastIndex(list, greet != half)
+findLastIndex(list, greet == nil)
+findLastIndex(list, half != nil)
+findLastIndex(list, i < i64)
+findLastIndex(list, i <= i)
+findLastIndex(list, i32 != nil)
+findLastIndex(list, i32 < f64)
+findLastIndex(list, i32 <= i32)
+findLastIndex(list, i32 >= 0.5)
+findLastIndex(list, i32 >= i)
+findLastIndex(list, i64 < f64)
+findLastIndex(list, i64 == f32)
+findLastIndex(list, i64 >= i)
+findLastIndex(list, i64 not in array)
+findLastIndex(list, nil != #)
+findLastIndex(list, nil == #)
+findLastIndex(list, none(array, ok))
+findLastIndex(list, not ok)
+findLastIndex(list, not true)
+findLastIndex(list, ok != nil)
+findLastIndex(list, ok)
+findLastIndex(list, ok) ** f32
+findLastIndex(list, ok) ** f64
+findLastIndex(list, ok) - i
+findLastIndex(list, ok) >= i64
+findLastIndex(list, true == nil)
+findLastIndex(list, true) ** i64
+findLastIndex(list, true) + i
+findLastIndex(list, true) .. i64
+findLastIndex(list, true) < i
+findLastIndex(list, true) > f32
+findLastIndex(list, true) >= f32
+findLastIndex(list, true) in array
+findLastIndex(map(array, "foo"), # == #)
+findLastIndex(map(array, #), i < #)
+findLastIndex(map(array, #), nil != half)
+findLastIndex(map(array, #), ok)
+findLastIndex(map(array, 0.5), ok)
+findLastIndex(map(array, array), 1 != i)
+findLastIndex(map(array, false), #)
+findLastIndex(map(array, true), #)
+findLastIndex(map(list, #), !ok)
+findLastIndex(map(list, #), 0.5 < f32)
+findLastIndex(map(list, 0.5), # <= #)
+findLastIndex(map(list, f32), # == #)
+findLastIndex(map(list, f32), # >= #)
+findLastIndex(map(list, f32), ok)
+findLastIndex(map(list, false), #)
+findLastIndex(map(list, half), ok)
+findLastIndex(map(list, ok), # or #)
+findLastIndex(map(list, ok), #)
+findLastIndex(sort(array), ok)
+first(1 .. i)
+first(1 .. i32)
+first([f32])
+first([f64])
+first([false, list])
+first([i64, nil])
+first([list, i32])
+first([not false])
+first(array)
+first(array) * i
+first(array) ** i32
+first(array) ** i64
+first(array) + i32
+first(array) / 1 * 0.5
+first(array) <= i32
+first(array) <= i64
+first(array) == i64
+first(array) > i32
+first(array) > i64
+first(array) in array
+first(false ? f64 : true)
+first(false ? greet : i)
+first(filter(array, false))
+first(filter(list, ok))
+first(i .. 1)
+first(i .. i)
+first(i .. i32)
+first(i32 .. 1)
+first(i32 .. i)
+first(i32 .. i64)
+first(i64 .. i32)
+first(list)
+first(list) not in list
+first(list).Bar
+first(list).Qux
+first(list).String
+first(list).String()
+first(list)?.Bar
+first(list)?.Qux
+first(list)?.String
+first(list)?.String()
+first(map(array, "bar"))
+first(map(array, #))
+first(map(array, 0.5))
+first(map(array, 1))
+first(map(array, add))
+first(map(array, f32))
+first(map(array, f64))
+first(map(array, foo))
+first(map(array, greet))
+first(map(array, half))
+first(map(array, i))
+first(map(array, list))
+first(map(array, ok))
+first(map(array, score))
+first(map(list, #))
+first(map(list, 0.5))
+first(map(list, add))
+first(map(list, array))
+first(map(list, div))
+first(map(list, f32))
+first(map(list, f64))
+first(map(list, i32))
+first(map(list, list))
+first(map(list, score))
+first(ok ? "bar" : 0.5)
+first(ok ? 1 : "foo")
+first(ok ? add : f32)
+first(ok ? array : "bar")
+first(ok ? list : nil)
+first(ok ? ok : array)
+first(ok ? ok : foo)
+first(ok ? ok : score)
+first(sort(array))
+first(true ? 0.5 : i64)
+first(true ? add : ok)
+first(true ? array : false)
+first(true ? ok : div)
+float(-(1 / i32))
+float(-0.5)
+float(-1)
+float(-f32)
+float(-f64)
+float(-i)
+float(-i32)
+float(-i64)
+float(0.5 * 0.5)
+float(0.5 * f32)
+float(0.5 * i)
+float(0.5 * i32)
+float(0.5 * i64)
+float(0.5 ** 0.5)
+float(0.5 ** 1)
+float(0.5 ** f32)
+float(0.5 ** i32)
+float(0.5 + 1)
+float(0.5 + f32)
+float(0.5 + i)
+float(0.5 + i64)
+float(0.5 - 0.5)
+float(0.5 - 1)
+float(0.5 - f32)
+float(0.5 - i)
+float(0.5 - i32)
+float(0.5 - i64)
+float(0.5 / 0.5)
+float(0.5 / 1)
+float(0.5 / f32)
+float(0.5 / f64)
+float(0.5 / i)
+float(0.5 ^ 0.5)
+float(0.5 ^ 1)
+float(0.5 ^ f64)
+float(0.5 ^ i32)
+float(0.5 ^ i64)
+float(0.5) != i32
+float(0.5) ** (1 % 1)
+float(0.5) + 0.5 - f64
+float(0.5) + f32
+float(0.5) + i32
+float(0.5) - -f32
+float(0.5) - f32
+float(0.5) / f32
+float(0.5) < i32
+float(0.5) >= i32
+float(1 % 1)
+float(1 % i)
+float(1 % i32)
+float(1 % i64)
+float(1 * 0.5)
+float(1 * 1)
+float(1 * i)
+float(1 * i32)
+float(1 * i64)
+float(1 ** 0.5)
+float(1 ** i)
+float(1 + 0.5)
+float(1 + 1)
+float(1 + f32)
+float(1 + f64)
+float(1 + i)
+float(1 - 0.5)
+float(1 - 1)
+float(1 - f32)
+float(1 - i)
+float(1 / 0.5)
+float(1 / 1)
+float(1 / f64)
+float(1 / i)
+float(1 ^ 1)
+float(1 ^ f32)
+float(1 ^ f64)
+float(1 ^ i)
+float(1 ^ i32)
+float(1 ^ i64)
+float(1) != abs(f32)
+float(1) != {"foo": i32}?.add
+float(1) ** i64
+float(1) - i64
+float(1) / i
+float(1) / i64
+float(1) < i32
+float(1) <= i64
+float(1) == int(0.5)
+float(1) > i
+float(1) >= f32
+float(1) >= i - i
+float(abs(0.5))
+float(abs(1))
+float(abs(f32))
+float(abs(i))
+float(abs(i32))
+float(abs(i64))
+float(add(i, 1))
+float(array[1])
+float(array[i32])
+float(array[i64])
+float(array[i])
+float(count(array, true))
+float(count(list, false) * (i - 1))
+float(count(list, false))
+float(div(1, i))
+float(div(i, 1))
+float(f32 * 0.5)
+float(f32 * f32)
+float(f32 * i32)
+float(f32 * i64)
+float(f32 ** 0.5)
+float(f32 ** 1)
+float(f32 ** i)
+float(f32 ** i64)
+float(f32 + 0.5)
+float(f32 + 1)
+float(f32 + f32)
+float(f32 + i32)
+float(f32 - 0.5)
+float(f32 - 1)
+float(f32 - f64)
+float(f32 - i)
+float(f32 / 0.5)
+float(f32 / 1)
+float(f32 / f32)
+float(f32 / i)
+float(f32 / i64)
+float(f32 ^ 0.5)
+float(f32 ^ f32)
+float(f32 ^ f64)
+float(f32 ^ i64)
+float(f32)
+float(f32) * f32
+float(f32) + f32
+float(f32) - f32
+float(f32) - f64
+float(f32) - i64
+float(f32) / f64
+float(f32) < i32
+float(f32) <= f32
+float(f32) >= f32
+float(f32) >= f32 ** f32
+float(f32) ^ f64
+float(f32) ^ i32
+float(f64 * 0.5)
+float(f64 * f32)
+float(f64 * i)
+float(f64 * i32)
+float(f64 ** 1)
+float(f64 ** f32)
+float(f64 + 0.5)
+float(f64 + 1)
+float(f64 + i)
+float(f64 - 0.5)
+float(f64 - i)
+float(f64 - i32)
+float(f64 - i32) / i
+float(f64 / -i32)
+float(f64 / 1)
+float(f64 / f32)
+float(f64 / i32)
+float(f64 ^ 0.5)
+float(f64 ^ 1)
+float(f64 ^ f32)
+float(f64 ^ f64)
+float(f64)
+float(f64) != int(i32)
+float(f64) * i32
+float(f64) / f32
+float(f64) / f64
+float(f64) / i64
+float(f64) < i
+float(f64) < i32
+float(f64) <= f32
+float(f64) <= i64
+float(f64) == i32
+float(f64) > i32
+float(f64) >= f64
+float(f64) >= i
+float(f64) >= i32
+float(f64) ^ i
+float(false ? div : i32)
+float(false ? f32 : 0.5)
+float(find(array, ok))
+float(find(array, true))
+float(findIndex(list, true))
+float(findLast(array, ok))
+float(findLast(array, true))
+float(first(array))
+float(float(0.5))
+float(float(1))
+float(float(f32))
+float(float(f64))
+float(float(i))
+float(float(i32))
+float(float(i64))
+float(get(array, 1))
+float(get(array, i))
+float(get(array, i64))
+float(half(-f64))
+float(half(0.5))
+float(half(f64))
+float(i % 1)
+float(i * 0.5)
+float(i * 1)
+float(i * f64)
+float(i * i)
+float(i * i32 * i32)
+float(i * i32)
+float(i * i64)
+float(i ** 1)
+float(i ** f64)
+float(i ** i32)
+float(i + 0.5)
+float(i + f64)
+float(i + i64)
+float(i - 0.5)
+float(i - 1)
+float(i - findIndex(array, true))
+float(i / 1)
+float(i / f64)
+float(i / i64)
+float(i ^ f32)
+float(i ^ f64)
+float(i ^ i64)
+float(i)
+float(i) != f32
+float(i) != i32
+float(i) != i64
+float(i) ** f32
+float(i) / i32
+float(i) < f32
+float(i) < i64
+float(i) <= f32
+float(i) == i32
+float(i) > f64
+float(i) ^ f64
+float(i) ^ i64
+float(i32 % 1)
+float(i32 % i)
+float(i32 * 1)
+float(i32 * f32)
+float(i32 ** 0.5)
+float(i32 ** f64)
+float(i32 ** i32)
+float(i32 ** i64)
+float(i32 + 1)
+float(i32 + f32)
+float(i32 - 0.5)
+float(i32 - f64)
+float(i32 - i)
+float(i32 - i32)
+float(i32 / 0.5)
+float(i32 / 1)
+float(i32 / 1) > f64
+float(i32 / i)
+float(i32 ^ 1)
+float(i32 ^ f64)
+float(i32 ^ i)
+float(i32)
+float(i32) != f64
+float(i32) * i64
+float(i32) + i
+float(i32) + i64
+float(i32) - i64
+float(i32) / i
+float(i32) / i32
+float(i32) < -0.5
+float(i32) == f32
+float(i32) == i32
+float(i32) > f32
+float(i32) > i32
+float(i32) >= f32
+float(i32) >= f64
+float(i32) ^ f32
+float(i32) ^ f64
+float(i32) ^ i32
+float(i64 % i)
+float(i64 % i32)
+float(i64 * 0.5)
+float(i64 * 1)
+float(i64 ** f64)
+float(i64 ** i64)
+float(i64 + 0.5)
+float(i64 + f64)
+float(i64 - 1)
+float(i64 - f32)
+float(i64 - f64)
+float(i64 - i32)
+float(i64 - i64)
+float(i64 / 0.5)
+float(i64 / 1)
+float(i64 / f32)
+float(i64 ^ f64)
+float(i64)
+float(i64) ** i
+float(i64) / i32
+float(i64) > f64 ^ f32
+float(i64) >= i
+float(i64) >= i64
+float(int(0.5))
+float(int(1))
+float(int(f32))
+float(int(f64))
+float(int(i))
+float(int(i32))
+float(int(i64))
+float(len("bar"))
+float(len("foo"))
+float(len(array))
+float(len(list))
+float(max(0.5))
+float(max(0.5, i32))
+float(max(1))
+float(max(1, i))
+float(max(1, i64))
+float(max(f64))
+float(max(i))
+float(max(i32))
+float(max(i64))
+float(min(0.5))
+float(min(1))
+float(min(f32))
+float(min(f64))
+float(min(i))
+float(min(i32))
+float(min(i64))
+float(ok ? f64 : half)
+float(ok ? i : greet)
+float(score(1))
+float(score(i))
+float(score(i, i)) <= f32
+float(score(score(i)))
+float(string(0.5))
+float(string(1))
+float(string(f32))
+float(string(f64))
+float(string(i))
+float(string(i64))
+float(toJSON(0.5))
+float(toJSON(1))
+float(toJSON(f32))
+float(toJSON(f64))
+float(toJSON(i))
+float(toJSON(i32))
+float(true ? 1 : div)
+float(true ? 1 : i64)
+float(true ? f64 : div)
+foo
+foo != first(list)
+foo != foo
+foo != foo ? 1 : 1
+foo != get(list, i)
+foo != last(list)
+foo != nil ? half : nil
+foo == foo
+foo == foo ? i : score
+foo == last(list)
+foo == nil == nil
+foo == nil || ok
+foo in [half]
+foo in filter(list, false)
+foo in list
+foo in list ? nil : i32
+foo in map(list, #)
+foo not in list
+foo.Bar
+foo.Bar != string(i64)
+foo.Bar + type(greet)
+foo.Bar < toJSON(0.5)
+foo.Bar == type(0.5)
+foo.Bar not matches string(half)
+foo.Bar not startsWith foo.String()
+foo.Qux
+foo.Qux != add
+foo.Qux != half
+foo.Qux != score
+foo.Qux == div
+foo.Qux == foo?.Qux
+foo.Qux(foo?.String())
+foo.Qux(greet("bar"))
+foo.Qux(toJSON(0.5))
+foo.Qux(toJSON(i))
+foo.Qux(toJSON(nil))
+foo.Qux(trimSuffix("foo"))
+foo.Qux(type("bar"))
+foo.Qux(type(i))
+foo.String
+foo.String != div
+foo.String == add
+foo.String == greet
+foo.String == half
+foo.String == score
+foo.String()
+foo?.Bar
+foo?.Bar + type(score)
+foo?.Bar in foo
+foo?.Bar not endsWith "bar" ? score : array
+foo?.Qux
+foo?.Qux != div
+foo?.Qux != greet
+foo?.Qux != half
+foo?.Qux != score
+foo?.Qux == add
+foo?.Qux == greet
+foo?.Qux == half
+foo?.Qux == score
+foo?.Qux(foo?.Bar)
+foo?.Qux(string(0.5))
+foo?.Qux(type(0.5))
+foo?.Qux(upper("bar"))
+foo?.String
+foo?.String != div
+foo?.String != greet
+foo?.String != half
+foo?.String != nil ? half : list
+foo?.String != score
+foo?.String == add
+foo?.String == half
+foo?.String()
+foo?.String() + type(list)
+foo?.String() < string(i32)
+foo?.String() < toJSON(nil)
+foo?.String() matches toBase64("bar")
+fromBase64(string(ok))
+fromBase64(string(true))
+fromBase64(toBase64("foo"))
+fromBase64(toBase64(toJSON(nil)))
+fromBase64(toJSON(nil))
+fromBase64(toJSON(ok))
+fromBase64(toJSON(true))
+fromBase64(type(add))
+fromBase64(type(div))
+fromBase64(type(false))
+fromBase64(type(greet))
+fromBase64(type(half))
+fromBase64(type(nil == score))
+fromBase64(type(ok))
+fromBase64(type(score))
+fromBase64(type(true))
+fromJSON("foo") not in list && false
+fromJSON(string(0.5))
+fromJSON(string(1))
+fromJSON(string(f32))
+fromJSON(string(f64))
+fromJSON(string(false))
+fromJSON(string(i))
+fromJSON(string(i32))
+fromJSON(string(i64))
+fromJSON(string(i64)) ** f64
+fromJSON(string(ok))
+fromJSON(string(true))
+fromJSON(toJSON("foo"))
+fromJSON(toJSON(0.5 ** 0.5))
+fromJSON(toJSON(1))
+fromJSON(toJSON(abs(1)))
+fromJSON(toJSON(array))
+fromJSON(toJSON(f32))
+fromJSON(toJSON(f64))
+fromJSON(toJSON(i))
+fromJSON(toJSON(i32))
+fromJSON(toJSON(i64))
+fromJSON(toJSON(list))
+fromJSON(toJSON(nil))
+fromJSON(toJSON(ok))
+fromJSON(toJSON(true))
+get(1 .. i32, i)
+get(1 .. i64, abs(1))
+get(1 .. i64, i)
+get(1 .. i64, i32)
+get(["bar"], i64)
+get([array], i)
+get([greet], i)
+get([nil, half], i)
+get([score, 0.5, score], i64)
+get(array, -1)
+get(array, -i)
+get(array, -i32)
+get(array, 1 % 1)
+get(array, 1 % i64)
+get(array, 1 - 1)
+get(array, 1 - i)
+get(array, 1) * f64
+get(array, 1) < f32
+get(array, 1) <= i32
+get(array, 1) > i
+get(array, 1) ^ f64
+get(array, 1) ^ i
+get(array, array[1])
+get(array, count(list, true))
+get(array, false ? div : false)
+get(array, first(array))
+get(array, i % i64)
+get(array, i * 1)
+get(array, i)
+get(array, i) + i
+get(array, i) > i32
+get(array, i) ^ f32
+get(array, i32 * i64)
+get(array, i32)
+get(array, i32) ** f32
+get(array, i32) == i32
+get(array, i32) > f64
+get(array, i64)
+get(array, i64) ** i
+get(array, i64) ** i64
+get(array, i64) .. i32
+get(array, i64) <= -i32
+get(array, i64) <= f64 / f32
+get(array, i64) <= i
+get(array, i64) == i64
+get(array, int(1))
+get(array, int(f32))
+get(array, int(f64))
+get(array, int(i32))
+get(array, len(array))
+get(array, max(1))
+get(array, min(i))
+get(array, min(i32))
+get(array, score(1))
+get(array, true ? i : 1)
+get(false ? "bar" : f64, list)
+get(false ? "bar" : i32, greet)
+get(false ? "foo" : i, ok)
+get(false ? 0.5 : i64, true not in String)
+get(false ? 1 : greet, ok)
+get(false ? div : true, min("foo"))
+get(false ? greet : score, score)
+get(false ? half : list, i32)
+get(false ? list : 1, i32)
+get(false ? list : i64, i >= f64)
+get(false ? score : 0.5, add)
+get(false ? score : 0.5, half)
+get(false ? score : f64, half)
+get(filter(list, ok), i32)
+get(filter(list, ok), i64)
+get(i .. i, i)
+get(i32 .. 1, i)
+get(i64 .. 1, i32)
+get(list, -i)
+get(list, -i32)
+get(list, -i64)
+get(list, 1 * i)
+get(list, 1).Bar
+get(list, 1).Qux
+get(list, 1).String
+get(list, 1).String()
+get(list, 1)?.Bar
+get(list, 1)?.Qux
+get(list, 1)?.String
+get(list, 1)?.String()
+get(list, abs(i))
+get(list, abs(i32))
+get(list, i)
+get(list, i) != foo
+get(list, i) == foo
+get(list, i).Bar
+get(list, i).Qux
+get(list, i).String
+get(list, i)?.Bar
+get(list, i)?.Qux
+get(list, i)?.String
+get(list, i)?.String()
+get(list, i32)
+get(list, i32).Bar
+get(list, i32).Qux
+get(list, i32).String
+get(list, i32).String()
+get(list, i32)?.Bar
+get(list, i32)?.Qux
+get(list, i32)?.String
+get(list, i32)?.String()
+get(list, i64 * i32)
+get(list, i64)
+get(list, i64).Bar
+get(list, i64).Qux
+get(list, i64).String
+get(list, i64).String()
+get(list, i64)?.Bar
+get(list, i64)?.Qux
+get(list, i64)?.String
+get(list, i64)?.String()
+get(list, int(1) > 0.5 ? div : 0.5)
+get(list, int(i))
+get(list, int(i32))
+get(list, int(i64))
+get(list, last(array))
+get(list, max(1, i64, i64))
+get(list, min(i32))
+get(list, min(i64))
+get(list, score(1))
+get(list[i32:i], i64)
+get(map(array, #), i)
+get(map(array, #), i64)
+get(map(array, #), last(array))
+get(map(array, 0.5), i)
+get(map(array, 1), i)
+get(map(array, i32), i64)
+get(map(array, ok), i)
+get(map(array, ok), i64)
+get(map(list, #), i)
+get(map(list, #), i32)
+get(map(list, #), i64)
+get(map(list, 0.5), i64)
+get(map(list, array), i)
+get(map(list, div), i32)
+get(map(list, i32), i64)
+get(map(list, ok), i32)
+get(map(list, true), i64)
+get(ok ? 0.5 : add, f32)
+get(ok ? add : 0.5, ok)
+get(ok ? add : false, div)
+get(ok ? array : 0.5, Bar)
+get(ok ? array : i, add)
+get(ok ? div : foo, filter("bar", ok))
+get(ok ? greet : 0.5, foo in String)
+get(ok ? greet : f32, Bar)
+get(ok ? i : f64, greet)?.f64
+get(ok ? i32 : "foo", score)
+get(ok ? i32 : add, div)
+get(ok ? list : "foo", f32)
+get(ok ? ok : half, array)
+get(ok ? true : i32, f32)
+get(sort(array), i32)
+get(true ? 0.5 : score, foo)
+get(true ? 1 : f64, foo)
+get(true ? 1 : greet, greet)?.foo
+get(true ? 1 : score, String?.Qux())
+get(true ? add : score, i)
+get(true ? array : 1, half)
+get(true ? array : i64, ok)
+get(true ? div : foo, list)
+get(true ? f32 : 1, greet)
+get(true ? f64 : greet, String)
+get(true ? f64 : ok, Bar?.ok)
+get(true ? i : f64, add)
+get(true ? i64 : score, i)
+get(true ? list : ok, ok)
+get({"bar": i32}.i32, ok)
+greet
+greet != add
+greet != div
+greet != div != nil
+greet != foo.Qux
+greet != foo.String
+greet != foo?.Qux
+greet != foo?.String
+greet != greet
+greet != greet != nil
+greet != greet or 0.5 == i
+greet != half
+greet != half ? 1 : ok
+greet != half ? array : 0.5
+greet != half ? false : f64
+greet != half ? greet : greet
+greet != nil ? i64 : 0.5
+greet != score
+greet == add
+greet == add == ok
+greet == add ? div == greet : i64
+greet == div
+greet == div ? add : i32
+greet == foo.Qux
+greet == foo.String
+greet == foo?.Qux
+greet == foo?.String
+greet == greet
+greet == half
+greet == nil != nil
+greet == nil && ok
+greet == nil == ok
+greet == score
+greet in [nil]
+greet("bar" + "bar")
+greet("bar" + "foo")
+greet("bar") != foo.String()
+greet("bar") != nil != false
+greet("bar") in foo
+greet("foo" + "bar")
+greet("foo" + "foo")
+greet("foo") >= string(foo)
+greet("foo") not contains "bar" ? array : half
+greet("foo") startsWith greet("bar")
+greet(false ? f32 : "foo")
+greet(false ? i : "bar")
+greet(foo.Bar)
+greet(foo.String())
+greet(foo?.Bar)
+greet(foo?.String())
+greet(greet("bar"))
+greet(greet("foo"))
+greet(lower("bar"))
+greet(lower("foo"))
+greet(ok ? "bar" : div)
+greet(string("bar"))
+greet(string("foo"))
+greet(string(-i64))
+greet(string(0.5 == 1))
+greet(string(0.5))
+greet(string(1))
+greet(string([0.5]))
+greet(string(add))
+greet(string(array))
+greet(string(div))
+greet(string(f32))
+greet(string(f64))
+greet(string(false))
+greet(string(foo))
+greet(string(foo?.Qux))
+greet(string(greet))
+greet(string(half))
+greet(string(i))
+greet(string(i32))
+greet(string(i64))
+greet(string(list))
+greet(string(nil != false))
+greet(string(nil))
+greet(string(ok))
+greet(string(score))
+greet(string(true))
+greet(toBase64("bar"))
+greet(toBase64("foo"))
+greet(toJSON("bar"))
+greet(toJSON("foo"))
+greet(toJSON(0.5))
+greet(toJSON(1))
+greet(toJSON(array))
+greet(toJSON(f32))
+greet(toJSON(f64))
+greet(toJSON(false))
+greet(toJSON(foo))
+greet(toJSON(i))
+greet(toJSON(i32))
+greet(toJSON(i64))
+greet(toJSON(list))
+greet(toJSON(nil))
+greet(toJSON(ok))
+greet(toJSON(string(array)))
+greet(toJSON(true))
+greet(trim("bar"))
+greet(trim("foo"))
+greet(trim(string(array)))
+greet(trimPrefix("bar"))
+greet(trimPrefix("foo"))
+greet(trimSuffix("bar"))
+greet(trimSuffix("foo"))
+greet(trimSuffix("foo", "foo"))
+greet(true ? "foo" : 0.5)
+greet(type("bar"))
+greet(type("foo"))
+greet(type(0.5))
+greet(type(1))
+greet(type(abs(f32)))
+greet(type(add))
+greet(type(array))
+greet(type(div))
+greet(type(f32))
+greet(type(f64 / i))
+greet(type(f64))
+greet(type(false))
+greet(type(foo))
+greet(type(greet))
+greet(type(half))
+greet(type(i))
+greet(type(i32))
+greet(type(i64))
+greet(type(list))
+greet(type(nil))
+greet(type(ok))
+greet(type(score))
+greet(type(true))
+greet(upper("bar"))
+greet(upper("foo"))
+half
+half != add
+half != add ? ok : half
+half != div
+half != div == true
+half != foo.Qux
+half != foo.String
+half != foo?.Qux
+half != foo?.String
+half != greet
+half != half
+half != score
+half == add
+half == add ? "bar" : half
+half == div
+half == div ? add : 0.5
+half == div and 1 >= 1
+half == foo.Qux
+half == foo.String
+half == foo?.Qux
+half == foo?.String
+half == greet
+half == greet == nil
+half == greet ? ok : foo
+half == greet || ok
+half == half
+half == half && i >= 0.5
+half == half ? score : "bar"
+half == half and ok
+half == nil == true
+half == nil ? 1 : 0.5
+half == nil ? 1 : score
+half == score
+half not in [list, i64, ok]
+half not in {"bar": list, "foo": 0.5}.ok
+half(-(f32 - 0.5))
+half(--1)
+half(-0.5)
+half(-1)
+half(-f32 ^ i)
+half(-f64)
+half(0.5 * 0.5)
+half(0.5 * 1)
+half(0.5 * f64)
+half(0.5 * i)
+half(0.5 * i32)
+half(0.5 * i64)
+half(0.5 ** 0.5)
+half(0.5 ** 1)
+half(0.5 ** f32)
+half(0.5 ** f64)
+half(0.5 ** i)
+half(0.5 ** i32)
+half(0.5 ** i64)
+half(0.5 + 0.5)
+half(0.5 + 1)
+half(0.5 + f32)
+half(0.5 + f64)
+half(0.5 + i32)
+half(0.5 + i64)
+half(0.5 - 0.5)
+half(0.5 - 1)
+half(0.5 - f32)
+half(0.5 - f64)
+half(0.5 - i)
+half(0.5 - i32)
+half(0.5 - i64)
+half(0.5 / 0.5)
+half(0.5 / 1)
+half(0.5 / f32)
+half(0.5 / f64)
+half(0.5 / i)
+half(0.5 / i32)
+half(0.5 / i64)
+half(0.5 ^ 0.5)
+half(0.5 ^ 1)
+half(0.5 ^ f32)
+half(0.5 ^ f64)
+half(0.5 ^ i)
+half(0.5 ^ i32)
+half(0.5 ^ i64)
+half(0.5) != f32
+half(0.5) != i64
+half(0.5) * f32
+half(0.5) ** f32
+half(0.5) ** f64
+half(0.5) + 1 * f64
+half(0.5) + f64
+half(0.5) + i32
+half(0.5) + i64
+half(0.5) - f32
+half(0.5) - f64
+half(0.5) - i
+half(0.5) - i32
+half(0.5) / i
+half(0.5) / i32
+half(0.5) / i64
+half(0.5) < i32
+half(0.5) <= i
+half(0.5) == f32 != true
+half(0.5) == i
+half(0.5) == i32
+half(0.5) == i64
+half(0.5) > i
+half(0.5) > i32
+half(0.5) > i64
+half(0.5) >= f32
+half(0.5) >= f64
+half(0.5) >= i
+half(0.5) >= i32
+half(0.5) >= i64
+half(0.5) ^ (i32 - 1)
+half(0.5) ^ i32
+half(1 * 0.5)
+half(1 * 1)
+half(1 * f32)
+half(1 * f64)
+half(1 * i)
+half(1 * i32)
+half(1 * i64)
+half(1 ** 0.5)
+half(1 ** 1)
+half(1 ** f32)
+half(1 ** f64)
+half(1 ** i)
+half(1 ** i32)
+half(1 ** i64)
+half(1 + 0.5)
+half(1 + 1)
+half(1 + f32)
+half(1 + f64)
+half(1 + i)
+half(1 + i32)
+half(1 + i64)
+half(1 - 0.5)
+half(1 - 1)
+half(1 - f32)
+half(1 - f64)
+half(1 - i)
+half(1 - i32)
+half(1 - i64)
+half(1 / 0.5)
+half(1 / 1)
+half(1 / f32)
+half(1 / f64)
+half(1 / i)
+half(1 / i32)
+half(1 / i64)
+half(1 ^ 0.5)
+half(1 ^ 1)
+half(1 ^ f32)
+half(1 ^ f64)
+half(1 ^ i)
+half(1 ^ i32)
+half(abs(0.5))
+half(abs(f64))
+half(abs(f64)) - i
+half(f32 * 0.5)
+half(f32 * 1)
+half(f32 * f64)
+half(f32 * i)
+half(f32 * i32)
+half(f32 * i64)
+half(f32 ** 0.5)
+half(f32 ** f32)
+half(f32 ** f64)
+half(f32 + 0.5)
+half(f32 + 1)
+half(f32 + f32)
+half(f32 + f64)
+half(f32 + i)
+half(f32 + i32)
+half(f32 + i64)
+half(f32 - 0.5)
+half(f32 - 1)
+half(f32 - f64)
+half(f32 - i)
+half(f32 - i32)
+half(f32 - i64)
+half(f32 / 0.5)
+half(f32 / 1)
+half(f32 / f32)
+half(f32 / f64)
+half(f32 / i32)
+half(f32 / i64)
+half(f32 ^ 0.5)
+half(f32 ^ f32)
+half(f32 ^ f64)
+half(f32 ^ i32)
+half(f32 ^ i64)
+half(f64 * 0.5)
+half(f64 * 1)
+half(f64 * f32)
+half(f64 * i)
+half(f64 * i32)
+half(f64 ** 0.5)
+half(f64 ** 1)
+half(f64 ** f32)
+half(f64 ** f64)
+half(f64 ** i)
+half(f64 ** i32)
+half(f64 + 1)
+half(f64 + f32)
+half(f64 + i)
+half(f64 + i32)
+half(f64 - 0.5)
+half(f64 - 1)
+half(f64 - f32)
+half(f64 - f64)
+half(f64 - i)
+half(f64 - i32)
+half(f64 - i64)
+half(f64 / 1)
+half(f64 / f32)
+half(f64 / f64)
+half(f64 / i32)
+half(f64 / i64)
+half(f64 ^ 0.5)
+half(f64 ^ 1)
+half(f64 ^ f32)
+half(f64 ^ i)
+half(f64 ^ i32)
+half(f64 ^ i64)
+half(f64)
+half(f64) != f32
+half(f64) != f64
+half(f64) != i64
+half(f64) * f32
+half(f64) * i64
+half(f64) ** (i32 * 0.5)
+half(f64) ** 0.5 ** i
+half(f64) ** f64
+half(f64) ** i64
+half(f64) + 1 + f64
+half(f64) + f64
+half(f64) + i
+half(f64) + i32
+half(f64) + i64
+half(f64) - f64
+half(f64) - i32
+half(f64) / f32
+half(f64) / f64
+half(f64) / i32
+half(f64) / i64
+half(f64) < f64
+half(f64) < i
+half(f64) < i32
+half(f64) < i64
+half(f64) <= 0.5 + f64
+half(f64) <= f64
+half(f64) <= i64
+half(f64) == i64
+half(f64) > abs(i)
+half(f64) > f32 * 0.5
+half(f64) > max(i64)
+half(f64) >= f32
+half(f64) >= i
+half(f64) >= i64
+half(f64) ^ f32
+half(false ? 0.5 : 0.5)
+half(float(-f64))
+half(float(0.5))
+half(float(1))
+half(float(f32))
+half(float(f64))
+half(float(i))
+half(float(i32))
+half(float(i64))
+half(greet == div ? "bar" : 0.5)
+half(half(0.5))
+half(half(f64))
+half(half(i - 0.5))
+half(i * 0.5)
+half(i * 1)
+half(i * f32)
+half(i * f64)
+half(i ** 0.5)
+half(i ** 1)
+half(i ** f32)
+half(i ** f64)
+half(i ** i)
+half(i ** i64)
+half(i + 0.5)
+half(i + 1)
+half(i + f32)
+half(i + f64)
+half(i - 0.5)
+half(i - 1)
+half(i - f64)
+half(i / 0.5)
+half(i / 1)
+half(i / f32)
+half(i / f64)
+half(i / i)
+half(i / i32)
+half(i / i64)
+half(i ^ 0.5)
+half(i ^ 1)
+half(i ^ f32)
+half(i ^ i32)
+half(i ^ i64)
+half(i32 * 0.5)
+half(i32 * 1)
+half(i32 * f32)
+half(i32 * f64)
+half(i32 ** 0.5)
+half(i32 ** 1)
+half(i32 ** f32)
+half(i32 ** f64)
+half(i32 ** i)
+half(i32 ** i32)
+half(i32 ** i64)
+half(i32 + 0.5)
+half(i32 + 1)
+half(i32 + f64)
+half(i32 - 0.5)
+half(i32 - 1)
+half(i32 - f32)
+half(i32 - f64)
+half(i32 / 0.5)
+half(i32 / 1)
+half(i32 / f32)
+half(i32 / f64)
+half(i32 / i)
+half(i32 / i32)
+half(i32 / i64)
+half(i32 ^ 0.5)
+half(i32 ^ 1)
+half(i32 ^ f32)
+half(i32 ^ i)
+half(i32 ^ i32)
+half(i32 ^ i64)
+half(i64 * 0.5)
+half(i64 * 1)
+half(i64 * f64)
+half(i64 ** 0.5)
+half(i64 ** 1)
+half(i64 ** f32)
+half(i64 ** f64)
+half(i64 ** i64)
+half(i64 + 0.5)
+half(i64 + 1)
+half(i64 + f32)
+half(i64 + f64)
+half(i64 - 0.5)
+half(i64 - 1)
+half(i64 - f32)
+half(i64 / 0.5)
+half(i64 / 1)
+half(i64 / f32)
+half(i64 / f64)
+half(i64 / i)
+half(i64 / i32)
+half(i64 / i64)
+half(i64 ^ 0.5)
+half(i64 ^ 1)
+half(i64 ^ f32)
+half(i64 ^ f64)
+half(i64 ^ i32)
+half(i64 ^ i64)
+half(max(0.5))
+half(max(0.5, f32))
+half(max(f64))
+half(min(0.5))
+half(min(0.5, 0.5))
+half(min(1, 0.5, 1))
+half(min(f64))
+half(ok ? 0.5 : f32)
+half(ok ? 0.5 : false)
+half(ok ? 0.5 : foo)
+half(true ? 0.5 : 0.5)
+hasPrefix("bar", "foo") != ok
+hasSuffix("foo", "foo") or 0.5 <= i
+i
+i != -0.5
+i != -1
+i != -f32
+i != -f64
+i != -i
+i != -i64
+i != 0.5 / 0.5
+i != 0.5 == ok
+i != 0.5 ? 1 : array
+i != 0.5 ? i32 : 0.5
+i != 0.5 ? score : score
+i != 1 % i64
+i != 1 * i
+i != 1 + 1
+i != 1 - 0.5
+i != 1 - 1
+i != 1 - i64
+i != 1 == ok
+i != 1 ? ok : i64
+i != 1 or i64 != 1
+i != f32
+i != f32 + i
+i != f32 / 1
+i != f32 ? div : list
+i != f64
+i != f64 * 0.5
+i != f64 + 1
+i != f64 / 0.5
+i != f64 ? 0.5 : nil
+i != f64 ? array : div
+i != f64 ? half : 1
+i != f64 || ok
+i != first(array)
+i != float(1)
+i != float(f32)
+i != float(f64)
+i != half(0.5)
+i != i
+i != i != nil
+i != i ^ f64
+i != i32
+i != i32 % i32
+i != i32 * f64
+i != i32 - i64
+i != i32 / i64
+i != i32 ? 1 : i
+i != i32 ? list : i
+i != i32 || half != nil
+i != i64
+i != i64 - f32
+i != i64 ? true : "foo"
+i != i64 ^ f64
+i != int(1)
+i != max(i32)
+i != min(1)
+i != nil != true
+i != nil ? ok : "bar"
+i != score(i)
+i % -1
+i % -i
+i % -i32
+i % -i64
+i % 1 != i64
+i % 1 .. i32
+i % 1 / i
+i % 1 >= i
+i % 1 >= i32
+i % array[i]
+i % first(array)
+i % get(array, i64)
+i % i
+i % i % i32
+i % i + i32
+i % i == i
+i % i in array
+i % i32
+i % i32 / i32
+i % i32 <= f32
+i % i64
+i % i64 != i
+i % int(i64)
+i % len(array)
+i % score(1)
+i % score(i)
+i * (0.5 + 0.5)
+i * (f32 + f32)
+i * (i32 + 0.5)
+i * (i32 - f64)
+i * (i64 + 1)
+i * -1
+i * -f32
+i * -i
+i * -i64
+i * 0.5 * f64
+i * 0.5 + i
+i * 0.5 - i
+i * 0.5 < i
+i * 0.5 <= i64 ** f64
+i * 1 % i
+i * 1 ** i32
+i * 1 / f64
+i * 1 / i64
+i * 1 <= f32
+i * abs(0.5)
+i * add(1, 1)
+i * array[i32]
+i * f32
+i * f32 != f32
+i * f32 ** 0.5
+i * f32 >= f32
+i * f32 ^ f32
+i * f64
+i * f64 * 1
+i * float(f64)
+i * half(f64)
+i * i
+i * i != i64
+i * i / f32
+i * i / f64
+i * i / i32
+i * i / i64
+i * i32
+i * i32 ** f64
+i * i32 ** i32
+i * i32 - i
+i * i32 / i32
+i * i32 <= i32
+i * i64
+i * i64 % i32
+i * i64 * 0.5
+i * i64 + f32
+i * i64 >= i32
+i * i64 ^ i64
+i * int(f64)
+i * int(i)
+i * int(i64)
+i * max(0.5)
+i * min(i64)
+i * score(1)
+i ** (0.5 + f64)
+i ** (0.5 + i64)
+i ** (1 * 1)
+i ** (1 - 0.5)
+i ** (i32 % i64)
+i ** (i32 - 1)
+i ** -0.5
+i ** -i
+i ** -i32
+i ** -i64
+i ** 0.5 ** 0.5
+i ** 0.5 ** 1
+i ** 0.5 < f32
+i ** 0.5 <= i64 ^ i32
+i ** 1 != f64
+i ** 1 ** 1
+i ** 1 ** f64
+i ** 1 ** i
+i ** 1 == f32
+i ** f32
+i ** f32 ** 0.5
+i ** f32 ** f64
+i ** f32 + f64
+i ** f32 <= f32
+i ** f32 <= i32 ? 1 : f32
+i ** f32 >= float(i64)
+i ** f64
+i ** f64 != f64
+i ** f64 < 1 / 0.5
+i ** float(0.5)
+i ** float(f32)
+i ** float(i32)
+i ** half(f64)
+i ** i
+i ** i + f64
+i ** i <= i
+i ** i ^ i
+i ** i32
+i ** i32 != i
+i ** i32 != i32
+i ** i32 + i32
+i ** i64
+i ** i64 ** 1
+i ** i64 ** f64
+i ** i64 ** i64
+i ** i64 - f64
+i ** i64 >= i
+i ** i64 >= i32
+i ** i64 ^ 1
+i ** int(1)
+i ** max(f32)
+i ** min(0.5, 1)
+i ** min(f32)
+i ** min(i)
+i ** min(i32)
+i ** score(1)
+i + -1
+i + -f32
+i + -f64
+i + -i
+i + 0.5 != i
+i + 0.5 ** i32
+i + 0.5 - i
+i + 0.5 < 1 + f32
+i + 0.5 <= i32
+i + 0.5 > f32
+i + 1 / array[i32]
+i + 1 / f32
+i + 1 <= f32
+i + 1 > i64
+i + 1 >= f64
+i + array[i32]
+i + count(list, false)
+i + f32
+i + f32 != f64
+i + f32 * i
+i + f32 ** i
+i + f64
+i + f64 <= i64
+i + f64 == f64
+i + float(0.5)
+i + float(f32)
+i + get(array, i64)
+i + half(0.5)
+i + half(f64)
+i + i
+i + i + f32
+i + i - i32
+i + i32
+i + i32 != i64
+i + i32 - 0.5
+i + i32 .. i
+i + i32 > f32
+i + i64
+i + i64 + f64
+i + i64 ^ 1
+i + int(f32)
+i + int(i64)
+i + last(array)
+i + len("bar")
+i + max(0.5)
+i + max(f32)
+i - -1
+i - -f32
+i - -i
+i - -i64
+i - 0.5 * 0.5
+i - 0.5 * 1
+i - 0.5 / 1
+i - 1 * 1
+i - 1 * i32
+i - 1 - i
+i - 1 ^ 0.5
+i - 1 ^ i32
+i - abs(0.5)
+i - abs(f32)
+i - abs(i32)
+i - f32
+i - f32 * i32
+i - f32 ** 1
+i - f32 + f64
+i - f32 - 1
+i - f32 / 0.5
+i - f32 / f32
+i - f32 / i32
+i - f32 ^ i64
+i - f64
+i - findIndex(list, ok)
+i - half(0.5)
+i - i
+i - i * 1
+i - i < i + f64
+i - i <= i
+i - i <= i32
+i - i >= f32
+i - i not in array
+i - i32
+i - i32 > len(array)
+i - i32 ^ 0.5
+i - i64
+i - i64 ** 1
+i - i64 + i32
+i - i64 - 1 / 1
+i - i64 - f64
+i - int(1)
+i - int(f32)
+i - int(i)
+i - last(array)
+i - max(0.5)
+i - max(i64)
+i - min(f32)
+i - score(1)
+i - score(i)
+i .. -i32
+i .. 1 % i32
+i .. 1 == array
+i .. abs(1)
+i .. abs(i32)
+i .. i
+i .. i % 1
+i .. i32
+i .. i32 == array
+i .. i64
+i .. i64 + i
+i .. i64 == list
+i .. int(i64)
+i .. last(array)
+i .. len(list)
+i .. min(1)
+i .. score(i)
+i / (f32 + f64)
+i / (f64 + f32)
+i / (i32 + f32)
+i / -0.5
+i / -1
+i / -i32
+i / -i64
+i / 0.5 * f32
+i / 0.5 * f64
+i / 0.5 ** f32
+i / 0.5 / i32
+i / 0.5 < i64
+i / 0.5 <= i64
+i / 0.5 == 0.5 - f64
+i / 0.5 >= i64
+i / 1 ** 1
+i / 1 / i64
+i / 1 == f64
+i / 1 ^ 1
+i / 1 ^ i64
+i / abs(i64)
+i / f32
+i / f32 != f32
+i / f32 ** i64
+i / f32 / i
+i / f64
+i / f64 * f32
+i / f64 - f32
+i / float(i32)
+i / half(0.5)
+i / half(f64)
+i / i
+i / i != i64
+i / i > i32
+i / i > i64
+i / i32
+i / i32 - i
+i / i32 / i
+i / i32 / i64
+i / i32 ^ f32
+i / i64
+i / i64 != i
+i / i64 ** f32
+i / i64 < i % 1
+i / i64 >= i32 ? div : div
+i / len("bar")
+i / len(list)
+i / max(1 / i)
+i / min(0.5)
+i / min(f64)
+i / min(i32)
+i / score(1)
+i / score(i)
+i < -(f32 - 1)
+i < -1
+i < -f32
+i < -i
+i < -i32
+i < 0.5 != false
+i < 0.5 != ok
+i < 0.5 * i
+i < 0.5 + 0.5
+i < 0.5 == ok
+i < 0.5 ? "bar" : "bar"
+i < 0.5 ? f32 : array
+i < 0.5 ? f32 : half
+i < 1 * 1
+i < 1 ** f32
+i < 1 == ok
+i < 1 ? false : nil
+i < abs(f64)
+i < f32
+i < f32 * i
+i < f32 ^ f32
+i < f64
+i < f64 * f64
+i < findIndex(list, ok)
+i < half(f32 ^ i64)
+i < half(f64)
+i < i
+i < i % 1
+i < i / 1
+i < i ? i32 : add
+i < i ^ 0.5
+i < i ^ i32
+i < i32
+i < i32 ** 0.5
+i < i32 - f32
+i < i32 == nil
+i < i64
+i < i64 && ok
+i < i64 - f64
+i < i64 - i32
+i < i64 ? nil : "foo"
+i < i64 ^ 0.5
+i < int(0.5)
+i < int(i64)
+i < len(array)
+i < len(list)
+i < min(i64)
+i < score(1)
+i < score(i)
+i <= -f32
+i <= -i
+i <= -i64
+i <= 0.5 ** 0.5
+i <= 0.5 ** f32
+i <= 0.5 == nil
+i <= 0.5 ? score : array
+i <= 1 != all(array, true)
+i <= 1 != nil
+i <= 1 % i
+i <= 1 + 1
+i <= 1 - f64
+i <= 1 ? ok : 1
+i <= abs(1)
+i <= abs(i32)
+i <= add(1, 1)
+i <= f32
+i <= f32 != nil
+i <= f32 * 0.5
+i <= f32 / f32
+i <= f32 ? ok : 1
+i <= f32 or ok
+i <= f64
+i <= f64 * 1
+i <= f64 == nil
+i <= f64 ? foo : div
+i <= f64 or add == greet
+i <= float(f64)
+i <= float(i)
+i <= float(i32)
+i <= half(-1)
+i <= half(0.5)
+i <= i
+i <= i ** 1
+i <= i == true
+i <= i32
+i <= i32 - f32
+i <= i32 - i64
+i <= i64
+i <= i64 % i32
+i <= i64 / 1
+i <= i64 ? ok : 1
+i <= int(1)
+i <= int(i32)
+i <= len("bar")
+i <= len(array)
+i <= max(i)
+i <= min(f32)
+i <= min(f64)
+i <= min(i)
+i <= min(i64)
+i == -0.5
+i == -1
+i == -f32
+i == -f64
+i == -i
+i == -i32
+i == -i64
+i == 0.5 + f32
+i == 0.5 - i32
+i == 0.5 == ok
+i == 0.5 ? false : true
+i == 0.5 ? list : i32
+i == 0.5 ^ 0.5
+i == 1 != true
+i == 1 % i
+i == 1 * f32
+i == 1 ** 1
+i == 1 ? foo : list
+i == 1 || ok
+i == abs(0.5)
+i == abs(1)
+i == div(1, i)
+i == f32
+i == f32 * i64
+i == f64
+i == f64 != nil
+i == f64 + i64
+i == f64 == ok
+i == i
+i == i - f64
+i == i / i32
+i == i ? ok : score
+i == i ^ i
+i == i32
+i == i32 ** f32
+i == i32 ** i
+i == i32 ? list : foo
+i == i64
+i == i64 != ok
+i == i64 + i32
+i == i64 ? array : 0.5
+i == i64 ? score : 1
+i == i64 ^ f64
+i == int(f64)
+i == len(array)
+i == max(0.5)
+i == max(i64)
+i == min(i)
+i == nil ? false : 1
+i == score(1)
+i > -i64
+i > 0.5 * f64
+i > 0.5 ** 0.5
+i > 0.5 / 0.5
+i > 0.5 / 1
+i > 0.5 == nil
+i > 0.5 ^ 0.5
+i > 1 ? greet : "bar"
+i > 1 ? greet : f64
+i > abs(i64)
+i > array[i]
+i > f32
+i > f64
+i > f64 + 0.5
+i > float(1)
+i > half(f64)
+i > i
+i > i ** i32
+i > i ** i64
+i > i / i
+i > i or ok
+i > i32
+i > i32 ? 1 : true
+i > i32 ? foo : score
+i > i32 ^ i
+i > i64
+i > int(0.5)
+i > int(i)
+i > int(i32)
+i > max(f32)
+i > max(i)
+i > min(0.5)
+i > score(i)
+i > score(len(array))
+i >= -0.5
+i >= -1
+i >= -i32
+i >= -i64
+i >= 0.5 ** f64
+i >= 0.5 + i32
+i >= 0.5 - 1
+i >= 0.5 == nil
+i >= 0.5 ? div : i
+i >= 0.5 ? score : f64
+i >= 1 / i
+i >= 1 ? nil : 0.5
+i >= abs(0.5)
+i >= abs(i64)
+i >= f32
+i >= f32 ** f64
+i >= f32 - i
+i >= f32 ? "bar" : array
+i >= f32 ? score : half
+i >= f64
+i >= f64 * i32
+i >= f64 + i32
+i >= f64 - i
+i >= i
+i >= i ** 0.5
+i >= i / 1
+i >= i / i
+i >= i == nil
+i >= i == ok
+i >= i32
+i >= i32 ** 0.5
+i >= i32 - f64
+i >= i32 ? f64 : div
+i >= i64
+i >= i64 * i
+i >= i64 ^ 0.5
+i >= int(i32)
+i >= len("foo")
+i >= min(f32 ^ i64)
+i >= score(i)
+i ^ (0.5 * 1)
+i ^ (0.5 - 0.5)
+i ^ (f32 * 1)
+i ^ (f32 * f32)
+i ^ (f32 * f64)
+i ^ (f32 / f64)
+i ^ (i * 1)
+i ^ (i - i64)
+i ^ (i32 % 1)
+i ^ (i32 + i)
+i ^ (i32 / 0.5)
+i ^ (i64 / 0.5)
+i ^ (i64 / 1)
+i ^ --f32
+i ^ -1
+i ^ -i
+i ^ -i32
+i ^ -i64
+i ^ 0.5 != 1 + i
+i ^ 0.5 * f32
+i ^ 0.5 - i
+i ^ 0.5 / f64
+i ^ 0.5 <= f32
+i ^ 0.5 > i64
+i ^ 0.5 ^ f32
+i ^ 1 != f32
+i ^ 1 * f32
+i ^ 1 ** i
+i ^ 1 - f32
+i ^ 1 / i32
+i ^ 1 ^ i64
+i ^ abs(1)
+i ^ abs(f32)
+i ^ abs(i64)
+i ^ add(1, 1)
+i ^ array[i]
+i ^ f32
+i ^ f32 != 1 - i
+i ^ f32 != i64 ? list : i32
+i ^ f32 + f64
+i ^ f32 / i
+i ^ f32 < i
+i ^ f32 >= i32
+i ^ f64
+i ^ f64 * i
+i ^ f64 >= f64
+i ^ find(array, true)
+i ^ float(f64)
+i ^ i
+i ^ i ** f64
+i ^ i + i32
+i ^ i >= f64
+i ^ i32
+i ^ i32 - f32
+i ^ i32 == i64 * i
+i ^ i32 >= f64
+i ^ i32 >= max(i64)
+i ^ i64
+i ^ i64 * i64
+i ^ i64 ** i
+i ^ i64 == f32
+i ^ i64 >= i64 ^ f32
+i ^ i64 ^ f64
+i ^ int(f32)
+i ^ max(1)
+i ^ min(i32)
+i ^ score(1)
+i in array
+i in array == ok
+i in array ? f32 : greet
+i in array ? foo : false
+i in array || ok
+i not in array
+i not in array ? foo : list
+i not in array and true
+i not in i64 .. 1
+i not in map(array, #)
+i not in {"foo": 1}.div
+i32
+i32 != -0.5
+i32 != -1
+i32 != -f32
+i32 != -i
+i32 != 0.5 && nil == i64
+i32 != 1 && ok
+i32 != 1 * i64
+i32 != 1 + 1
+i32 != 1 / 1
+i32 != 1 ? 0.5 : greet
+i32 != 1 ? false : i64
+i32 != 1 ? greet : half
+i32 != 1 ? greet : ok
+i32 != abs(i64)
+i32 != array[i]
+i32 != count(array, ok)
+i32 != f32
+i32 != f32 && ok
+i32 != f32 / f64
+i32 != f32 ? f64 : i32
+i32 != f32 and ok
+i32 != f64
+i32 != f64 == true
+i32 != findIndex(list, false)
+i32 != first(array)
+i32 != float(i)
+i32 != get(array, i64)
+i32 != half(f64)
+i32 != i
+i32 != i ** 1
+i32 != i ** f64
+i32 != i32
+i32 != i32 * 1
+i32 != i32 - 0.5
+i32 != i32 ? array : add
+i32 != i64
+i32 != i64 % i32
+i32 != i64 * 0.5
+i32 != i64 ? div : nil
+i32 != i64 ? true : nil
+i32 != int(f32)
+i32 != max(1)
+i32 != max(f64, 0.5)
+i32 != min(1, 0.5, f64)
+i32 != min(i)
+i32 != nil ? half : 1
+i32 != nil ? list : half(nil)
+i32 % -i
+i32 % -i32
+i32 % 1 != i64
+i32 % 1 % (i64 + i64)
+i32 % 1 % i64
+i32 % 1 * f64
+i32 % 1 + f64
+i32 % 1 > i
+i32 % add(1, 1)
+i32 % count(list, ok)
+i32 % i
+i32 % i != f32
+i32 % i32
+i32 % i32 != i
+i32 % i32 * f32
+i32 % i32 * i
+i32 % i64
+i32 % i64 != f32
+i32 % i64 / i32
+i32 % i64 == i
+i32 % i64 >= i64
+i32 % min(1, i64)
+i32 % min(i)
+i32 * (f32 + 1)
+i32 * (f32 + f32)
+i32 * (f32 + i)
+i32 * (f64 - f32)
+i32 * (i32 - 0.5)
+i32 * (i32 - f64)
+i32 * (i32 - i64)
+i32 * -f32
+i32 * -f64
+i32 * -i
+i32 * 0.5 ** 0.5
+i32 * 0.5 + f64
+i32 * 0.5 <= f32
+i32 * 1 % i64
+i32 * 1 * f32
+i32 * 1 * i32
+i32 * 1 < i
+i32 * array[i32]
+i32 * count(array, true)
+i32 * f32
+i32 * f32 != i
+i32 * f64
+i32 * f64 * i
+i32 * f64 + f32
+i32 * f64 / i
+i32 * f64 > i32
+i32 * i
+i32 * i != i32
+i32 * i * 0.5
+i32 * i .. i
+i32 * i / array[i32]
+i32 * i / i32
+i32 * i / i64
+i32 * i32
+i32 * i32 % i32
+i32 * i32 * 0.5
+i32 * i32 ** 1
+i32 * i32 - f32
+i32 * i32 == i32
+i32 * i64
+i32 * i64 % 1
+i32 * i64 .. i
+i32 * i64 / 1
+i32 * i64 / i32
+i32 * int(f32)
+i32 * max(f64)
+i32 * max(i64)
+i32 * min(1)
+i32 ** (0.5 * 0.5)
+i32 ** (0.5 + 0.5)
+i32 ** (0.5 + i32)
+i32 ** (0.5 / f64)
+i32 ** (f32 / i)
+i32 ** (f64 + 0.5)
+i32 ** (i + 1)
+i32 ** (i64 - i)
+i32 ** -1 ^ i32
+i32 ** -f32
+i32 ** -i32
+i32 ** -i64
+i32 ** 0.5 / f32
+i32 ** 0.5 <= i32
+i32 ** 0.5 ^ i
+i32 ** 1 ** i64
+i32 ** 1 + f64
+i32 ** 1 + i64
+i32 ** 1 - f32
+i32 ** 1 >= i64 * 0.5
+i32 ** 1 ^ f64
+i32 ** array[i]
+i32 ** f32
+i32 ** f32 ** i
+i32 ** f32 == i64
+i32 ** f64
+i32 ** f64 != i64 ? i : half
+i32 ** f64 + f64
+i32 ** f64 >= i
+i32 ** f64 ^ f32
+i32 ** float(1)
+i32 ** float(f64)
+i32 ** half(0.5)
+i32 ** i
+i32 ** i ** 0.5
+i32 ** i ^ 0.5
+i32 ** i32
+i32 ** i64
+i32 ** i64 != 0.5 == true
+i32 ** i64 - f64
+i32 ** i64 / f64
+i32 ** i64 / i
+i32 ** i64 > i
+i32 ** i64 ^ 1
+i32 ** i64 ^ i
+i32 ** int(0.5)
+i32 ** int(f64)
+i32 ** len(array)
+i32 ** min(f64)
+i32 ** min(i32)
+i32 ** score(1)
+i32 ** score(i)
+i32 + -0.5
+i32 + -1
+i32 + -f32
+i32 + -f64
+i32 + -i
+i32 + -i32
+i32 + 0.5 * 0.5
+i32 + 0.5 * i32
+i32 + 0.5 + 1
+i32 + 0.5 + i64
+i32 + 0.5 - 0.5
+i32 + 0.5 - f32
+i32 + 0.5 <= i
+i32 + 0.5 > i % 1
+i32 + 0.5 >= i
+i32 + 1 / f64
+i32 + 1 < i32
+i32 + 1 ^ i
+i32 + 1 ^ i32
+i32 + abs(i32)
+i32 + count(array, false)
+i32 + f32
+i32 + f64
+i32 + f64 * 1
+i32 + f64 * f64
+i32 + f64 ** 0.5
+i32 + f64 - f32 * 0.5
+i32 + f64 == i32
+i32 + f64 >= i
+i32 + f64 ^ i32
+i32 + find(array, ok)
+i32 + i
+i32 + i * 1
+i32 + i - f32
+i32 + i > half(f64)
+i32 + i >= -1
+i32 + i32
+i32 + i32 ** 0.5
+i32 + i32 >= f32
+i32 + i32 ^ i64
+i32 + i64
+i32 + i64 + i64
+i32 + i64 / f64
+i32 + i64 <= f32
+i32 + i64 ^ f32
+i32 + i64 not in array
+i32 + int(f64)
+i32 + last(array)
+i32 + len("foo")
+i32 + len(list)
+i32 + min(0.5, i32)
+i32 + min(1, i)
+i32 + min(i)
+i32 + min(i, i32)
+i32 + score(i)
+i32 - -0.5
+i32 - -1
+i32 - -f32
+i32 - -i32
+i32 - -i64
+i32 - 0.5 * 0.5
+i32 - 0.5 * i64
+i32 - 0.5 + i
+i32 - 0.5 + i32
+i32 - 0.5 - f32
+i32 - 0.5 < i32
+i32 - 0.5 <= f64
+i32 - 1 != f32
+i32 - 1 * f32
+i32 - 1 ** i32
+i32 - 1 / 0.5
+i32 - 1 <= i64
+i32 - 1 not in array
+i32 - array[1]
+i32 - f32
+i32 - f32 * f32
+i32 - f32 ** f64
+i32 - f32 + 0.5
+i32 - f32 / f64
+i32 - f64
+i32 - f64 ** f64
+i32 - f64 + 0.5
+i32 - f64 - i64
+i32 - f64 / i64
+i32 - f64 < i64
+i32 - first(array)
+i32 - float(i)
+i32 - get(array, i64)
+i32 - i
+i32 - i % i
+i32 - i + f32
+i32 - i - 1
+i32 - i / i
+i32 - i <= i64
+i32 - i == i
+i32 - i > f64
+i32 - i >= f64
+i32 - i32
+i32 - i32 ** 0.5
+i32 - i32 <= i32 + i64
+i32 - i32 ^ 1
+i32 - i64
+i32 - i64 % i
+i32 - i64 % i64
+i32 - i64 .. i
+i32 - i64 <= i
+i32 - i64 ^ 0.5
+i32 - i64 ^ f64
+i32 - int(1)
+i32 - int(f64)
+i32 - max(i64)
+i32 - max(i64, i)
+i32 - min(0.5)
+i32 - score(i)
+i32 .. -1
+i32 .. -i
+i32 .. -i32
+i32 .. -i64
+i32 .. 1 - 1
+i32 .. abs(i)
+i32 .. array[i32]
+i32 .. count(array, ok)
+i32 .. i
+i32 .. i - 1
+i32 .. i32
+i32 .. i32 != list
+i32 .. i64
+i32 .. i64 - i32
+i32 .. int(0.5)
+i32 .. len(list)
+i32 .. min(1)
+i32 .. min(1, 0.5)
+i32 .. min(i32)
+i32 .. min(i64)
+i32 .. score(i)
+i32 / (0.5 + i32)
+i32 / (1 + f32)
+i32 / (1 - f32)
+i32 / (1 - i)
+i32 / (f32 + i)
+i32 / (f32 - f64)
+i32 / (f64 + 0.5)
+i32 / (f64 - 1)
+i32 / (i32 - 1)
+i32 / -0.5
+i32 / -1
+i32 / -f32
+i32 / -i
+i32 / -i32
+i32 / 0.5 * i
+i32 / 0.5 / i64
+i32 / 0.5 >= f64
+i32 / 1 != f64
+i32 / 1 < i32
+i32 / abs(0.5)
+i32 / f32
+i32 / f64
+i32 / f64 * i32
+i32 / f64 >= f32
+i32 / half(f64)
+i32 / i
+i32 / i <= i
+i32 / i32
+i32 / i32 * 1
+i32 / i32 / f32 / f64
+i32 / i32 / i64
+i32 / i64
+i32 / i64 != i64
+i32 / i64 * i
+i32 / i64 / i
+i32 / i64 == f32
+i32 / i64 == f64
+i32 / int(i)
+i32 / len("bar")
+i32 / len("foo")
+i32 / max(i32)
+i32 / min(f32)
+i32 / min(f64)
+i32 / min(i)
+i32 / min(i32)
+i32 < -(i - f32)
+i32 < -0.5
+i32 < -f32
+i32 < -i32
+i32 < 0.5 ** i32
+i32 < 0.5 - f32
+i32 < 0.5 ^ 1
+i32 < 1 % 1
+i32 < 1 ** 1
+i32 < 1 + 0.5
+i32 < 1 + 1
+i32 < 1 ? "foo" : i32
+i32 < 1 ? 1 : 0.5
+i32 < 1 ^ i32
+i32 < abs(i64)
+i32 < div(1, 1)
+i32 < f32
+i32 < f32 == nil
+i32 < f32 ? div : true
+i32 < f32 || i64 != f32
+i32 < f64
+i32 < f64 != nil
+i32 < f64 != true
+i32 < f64 * f32
+i32 < f64 == nil
+i32 < f64 ? f32 : half
+i32 < f64 ? greet : false
+i32 < f64 ? list : i32
+i32 < f64 ^ f32
+i32 < f64 || 1 < 1
+i32 < float(i)
+i32 < float(i32)
+i32 < half(0.5)
+i32 < i
+i32 < i != true
+i32 < i ^ 0.5
+i32 < i32
+i32 < i32 != ok
+i32 < i32 * f32
+i32 < i32 / i32
+i32 < i32 ? ok : 1
+i32 < i64
+i32 < i64 - 0.5
+i32 < i64 ^ f64
+i32 < int(0.5)
+i32 < int(i32)
+i32 < int(i64)
+i32 < max(0.5)
+i32 < max(1)
+i32 < min(1, i32)
+i32 < min(f64)
+i32 < min(i)
+i32 < min(i64)
+i32 < score(1)
+i32 <= -0.5
+i32 <= -f32
+i32 <= -i
+i32 <= -i32
+i32 <= 0.5 != nil
+i32 <= 0.5 != ok
+i32 <= 0.5 * 0.5
+i32 <= 0.5 * i
+i32 <= 0.5 + i64
+i32 <= 1 ? i : f32
+i32 <= 1 ? true : true
+i32 <= 1 or 0.5 == 0.5
+i32 <= abs(i32)
+i32 <= count(list, ok)
+i32 <= f32
+i32 <= f32 * i64
+i32 <= f32 / 0.5
+i32 <= f32 ^ i64
+i32 <= f64
+i32 <= f64 * i
+i32 <= f64 ^ 1
+i32 <= float(i)
+i32 <= half(0.5)
+i32 <= i
+i32 <= i % i64
+i32 <= i32
+i32 <= i32 != nil
+i32 <= i32 % 1
+i32 <= i32 ** f64
+i32 <= i64
+i32 <= i64 != false
+i32 <= i64 != ok
+i32 <= i64 + f32
+i32 <= i64 ? div : nil
+i32 <= last(array)
+i32 <= len(array)
+i32 <= len(list)
+i32 <= max(f64)
+i32 <= min(i)
+i32 <= score(1)
+i32 <= score(i)
+i32 == -0.5
+i32 == -1
+i32 == -f64
+i32 == -i
+i32 == -i64
+i32 == 0.5 / f64
+i32 == 0.5 ? half : array
+i32 == 0.5 ^ i
+i32 == 0.5 ^ i64
+i32 == 1 ** 1
+i32 == 1 ** i
+i32 == 1 || f32 < f64
+i32 == f32
+i32 == f32 ? f32 : nil
+i32 == f32 ? half : "bar"
+i32 == f32 ? score : false
+i32 == f32 or ok
+i32 == f64
+i32 == f64 != ok
+i32 == f64 * 0.5
+i32 == f64 ** f32
+i32 == f64 ** i64
+i32 == f64 ? add : half
+i32 == findLastIndex(array, ok)
+i32 == float(i)
+i32 == half(0.5)
+i32 == i
+i32 == i % i64
+i32 == i ? "foo" : greet
+i32 == i ? type(false) : array
+i32 == i ^ f64
+i32 == i and ok
+i32 == i || ok
+i32 == i32
+i32 == i32 ? add : add
+i32 == i32 ? f32 : f64
+i32 == i32 ^ 1
+i32 == i64
+i32 == i64 + f32
+i32 == i64 ? foo : list
+i32 == len(list)
+i32 == max(0.5)
+i32 == min(f32)
+i32 == min(i32)
+i32 == nil ? f32 : add
+i32 == nil and ok
+i32 == {"foo": f32, "foo": list}?.String?.Qux
+i32 > -0.5
+i32 > -1
+i32 > -f32
+i32 > -f64
+i32 > -i
+i32 > -i32
+i32 > -i64
+i32 > 0.5 != ok
+i32 > 0.5 != true
+i32 > 0.5 * f64
+i32 > 0.5 ** f32
+i32 > 0.5 ** i
+i32 > 0.5 + 0.5
+i32 > 0.5 + 1
+i32 > 0.5 - 1
+i32 > 0.5 / i64
+i32 > 0.5 == nil
+i32 > 0.5 ? greet : f32
+i32 > 0.5 ? ok : false
+i32 > 0.5 ^ f32
+i32 > 1 ** f64
+i32 > 1 - i
+i32 > 1 / 1
+i32 > 1 ? i : add
+i32 > 1 || ok
+i32 > abs(1)
+i32 > abs(f64)
+i32 > array[1]
+i32 > array[i32]
+i32 > f32
+i32 > f32 != ok
+i32 > f32 && "bar" == nil
+i32 > f32 * i64
+i32 > f32 ? "bar" : half
+i32 > f64
+i32 > f64 * 0.5
+i32 > f64 - 1
+i32 > f64 / 1
+i32 > f64 / i32
+i32 > f64 == nil
+i32 > f64 == ok
+i32 > f64 == true
+i32 > f64 ? 0.5 : add
+i32 > f64 ^ i64
+i32 > float(i)
+i32 > float(i32)
+i32 > half(0.5)
+i32 > half(f64)
+i32 > i
+i32 > i + f32
+i32 > i / f32
+i32 > i ^ i32
+i32 > i32
+i32 > i32 - 0.5
+i32 > i32 ? "bar" : div
+i32 > i32 ? array : 0.5
+i32 > i32 ? foo : 1
+i32 > i64
+i32 > i64 ** f32
+i32 > i64 + f64
+i32 > i64 - i
+i32 > i64 ? list : list
+i32 > int(i)
+i32 > int(i64)
+i32 > max(i)
+i32 > min(0.5)
+i32 > score(1)
+i32 >= -0.5
+i32 >= -1
+i32 >= -i
+i32 >= 0.5 ** 0.5
+i32 >= 0.5 ^ f32
+i32 >= 0.5 || ok
+i32 >= 1 && ok
+i32 >= abs(i)
+i32 >= abs(i64)
+i32 >= array[i]
+i32 >= f32
+i32 >= f32 != true
+i32 >= f32 - 0.5
+i32 >= f32 ^ 0.5
+i32 >= f64
+i32 >= f64 && nil == 0.5
+i32 >= f64 - f64
+i32 >= f64 / 1
+i32 >= f64 ? f32 : list
+i32 >= f64 ^ 1
+i32 >= float(1)
+i32 >= half(0.5)
+i32 >= half(f64)
+i32 >= i
+i32 >= i % i64
+i32 >= i ** i32
+i32 >= i / i
+i32 >= i ? div : list
+i32 >= i ? foo : 0.5
+i32 >= i32
+i32 >= i64
+i32 >= i64 != ok
+i32 >= i64 ** i64
+i32 >= i64 / i64
+i32 >= i64 ? list : greet
+i32 >= i64 ^ i32
+i32 >= int(i64)
+i32 >= last(array)
+i32 >= len(array)
+i32 >= min(i32)
+i32 >= score(1)
+i32 >= score(i)
+i32 ^ (f32 + i64)
+i32 ^ (f64 + 0.5)
+i32 ^ (i - f64)
+i32 ^ (i32 + f32)
+i32 ^ (i64 % i)
+i32 ^ (i64 * 0.5)
+i32 ^ (i64 + f32)
+i32 ^ (i64 - f64)
+i32 ^ --0.5
+i32 ^ -0.5
+i32 ^ -f64
+i32 ^ -i32
+i32 ^ 0.5 ** i
+i32 ^ 0.5 + i32
+i32 ^ 0.5 - i
+i32 ^ 0.5 < i
+i32 ^ 0.5 == i64
+i32 ^ abs(1)
+i32 ^ f32
+i32 ^ f32 * i64
+i32 ^ f32 ** 0.5
+i32 ^ f32 ** i
+i32 ^ f32 < 0.5 * i
+i32 ^ f32 ^ i
+i32 ^ f64
+i32 ^ f64 ^ 1
+i32 ^ float(f32)
+i32 ^ half(0.5)
+i32 ^ half(f64)
+i32 ^ i
+i32 ^ i + i32
+i32 ^ i - f32
+i32 ^ i <= f32
+i32 ^ i ^ 1
+i32 ^ i32
+i32 ^ i32 ** f32
+i32 ^ i32 ** f64
+i32 ^ i32 + i32
+i32 ^ i32 + i64
+i32 ^ i32 <= i64
+i32 ^ i64
+i32 ^ i64 - f32
+i32 ^ max(0.5)
+i32 ^ max(1)
+i32 ^ max(i)
+i32 ^ min(f32)
+i32 ^ score(1)
+i32 in array
+i32 in map(array, #)
+i32 not in array
+i32 not in array ? score : score
+i32 not in map(array, #)
+i32 not in map(array, 1)
+i64
+i64 != -0.5
+i64 != -1
+i64 != -f32
+i64 != -f64
+i64 != -i
+i64 != 0.5 != nil
+i64 != 0.5 != ok
+i64 != 0.5 != true
+i64 != 0.5 * 1
+i64 != 0.5 ? false : i64
+i64 != 0.5 ^ 1
+i64 != 0.5 and f64 == 1
+i64 != 1 || f64 < i
+i64 != 1 || ok
+i64 != abs(f64)
+i64 != f32
+i64 != f32 + f32
+i64 != f32 / f32
+i64 != f32 ? div : 1
+i64 != f32 ? f64 : i64
+i64 != f32 ^ i
+i64 != f64
+i64 != f64 != false
+i64 != f64 - i32
+i64 != f64 / i32
+i64 != f64 / i64
+i64 != f64 ? 0.5 : score
+i64 != f64 ? i64 : true
+i64 != findLast(array, false)
+i64 != first(array)
+i64 != float(i32)
+i64 != get(array, i64)
+i64 != half(0.5)
+i64 != half(f64)
+i64 != i
+i64 != i == nil
+i64 != i ? array : f32
+i64 != i and ok
+i64 != i32
+i64 != i32 ? 1 : f32
+i64 != i64
+i64 != i64 ? true : score
+i64 != last(array)
+i64 != len("foo")
+i64 != min(0.5)
+i64 != min(f32)
+i64 != min(f64)
+i64 != min(i64)
+i64 != nil && ok
+i64 != score(1)
+i64 % -1
+i64 % -i
+i64 % -i32
+i64 % 1 * i32
+i64 % 1 .. i
+i64 % 1 / 0.5
+i64 % 1 / f64
+i64 % 1 < i32
+i64 % 1 <= -i32
+i64 % 1 == 0.5 + 0.5
+i64 % 1 not in array
+i64 % abs(i64)
+i64 % array[1]
+i64 % find(array, true)
+i64 % first(array)
+i64 % i
+i64 % i .. i32
+i64 % i not in array
+i64 % i32
+i64 % i32 != f64
+i64 % i32 * f32
+i64 % i32 == i
+i64 % i32 > f64 ^ i32
+i64 % i64
+i64 % i64 * 1
+i64 % i64 * f32
+i64 % i64 + -i64
+i64 % max(i32)
+i64 % min(i)
+i64 % score(1)
+i64 * (0.5 + i64)
+i64 * (0.5 - 1)
+i64 * (1 + 1)
+i64 * (f64 + f32)
+i64 * (f64 - i)
+i64 * (i - 1)
+i64 * (i64 + 0.5)
+i64 * --f64
+i64 * -0.5
+i64 * -1
+i64 * -f32
+i64 * -f64
+i64 * 0.5 != f64
+i64 * 0.5 * i32
+i64 * 0.5 - f32
+i64 * 0.5 < f32
+i64 * 0.5 == min(i64)
+i64 * 0.5 >= f32
+i64 * 0.5 ^ i
+i64 * 1 * 1
+i64 * 1 .. i32
+i64 * 1 <= i64
+i64 * 1 == i32
+i64 * 1 >= i32
+i64 * array[i32]
+i64 * f32
+i64 * f32 - f32
+i64 * f32 / f64
+i64 * f32 >= i64
+i64 * f32 ^ i
+i64 * f32 ^ i32
+i64 * f64
+i64 * f64 * i32
+i64 * f64 ^ f64
+i64 * float(i64)
+i64 * get(array, i64)
+i64 * half(f64)
+i64 * i
+i64 * i * i64
+i64 * i == i32
+i64 * i ^ i64
+i64 * i32
+i64 * i32 ** f32
+i64 * i32 >= f64
+i64 * i32 >= i64
+i64 * i32 ^ 1
+i64 * i64
+i64 * i64 ** 1
+i64 * i64 ** f32
+i64 * i64 - f64
+i64 * i64 in array
+i64 * int(1)
+i64 * min(f32, 0.5)
+i64 * score(1)
+i64 ** (0.5 * i64)
+i64 ** (0.5 + 1)
+i64 ** (1 % i)
+i64 ** (f64 / i)
+i64 ** (i * 0.5)
+i64 ** (i - i)
+i64 ** (i32 + i)
+i64 ** -1
+i64 ** -i
+i64 ** -i32
+i64 ** 0.5 * f64
+i64 ** 0.5 + f32
+i64 ** 0.5 + f32 - 1
+i64 ** 0.5 - i
+i64 ** 0.5 ^ 1
+i64 ** 0.5 ^ f32
+i64 ** 1 != i
+i64 ** 1 ** f32
+i64 ** 1 ** float(1)
+i64 ** 1 / f64
+i64 ** 1 / i
+i64 ** 1 == i64
+i64 ** 1 ^ i64
+i64 ** abs(f32)
+i64 ** abs(i64)
+i64 ** f32
+i64 ** f32 != f64
+i64 ** f32 != i64
+i64 ** f32 ** i32
+i64 ** f32 / i64 / 1
+i64 ** f32 <= i64
+i64 ** f32 > f32
+i64 ** f64
+i64 ** f64 / i
+i64 ** f64 <= f32
+i64 ** f64 > f64
+i64 ** f64 >= f64
+i64 ** f64 >= i32
+i64 ** float(1)
+i64 ** half(0.5)
+i64 ** i
+i64 ** i32
+i64 ** i32 != f32
+i64 ** i32 <= f64
+i64 ** i32 <= min(0.5)
+i64 ** i64
+i64 ** i64 / f64
+i64 ** i64 >= f64
+i64 ** int(0.5)
+i64 ** int(f64)
+i64 ** len("foo")
+i64 ** min(0.5)
+i64 ** score(1)
+i64 + -(f32 / i)
+i64 + -0.5
+i64 + -f32
+i64 + -f64
+i64 + -i
+i64 + -i64
+i64 + 0.5 * i
+i64 + 0.5 ** 1
+i64 + 0.5 + 1
+i64 + 0.5 + i32
+i64 + 1 % i
+i64 + 1 ** i
+i64 + 1 + i32
+i64 + 1 - f64
+i64 + 1 - i32
+i64 + 1 .. i
+i64 + 1 < i32
+i64 + 1 < i64
+i64 + 1 <= i
+i64 + 1 == i
+i64 + abs(1)
+i64 + f32
+i64 + f32 ** 1
+i64 + f32 >= f64
+i64 + f64
+i64 + f64 != f32
+i64 + f64 + i
+i64 + f64 <= f32
+i64 + f64 == i32
+i64 + findIndex(list, ok)
+i64 + first(array)
+i64 + get(array, i32)
+i64 + half(0.5)
+i64 + half(f64)
+i64 + i
+i64 + i + i
+i64 + i - f64
+i64 + i / 1
+i64 + i32
+i64 + i32 * 1
+i64 + i32 * i
+i64 + i32 < f64
+i64 + i32 >= f32
+i64 + i32 in array
+i64 + i64
+i64 + i64 % i64
+i64 + i64 ** f32
+i64 + i64 + 0.5
+i64 + i64 - int(f64)
+i64 + i64 ^ i
+i64 + max(f32)
+i64 + min(0.5)
+i64 + min(1)
+i64 + min(f32)
+i64 + min(i32)
+i64 + score(i)
+i64 - -1
+i64 - -f32
+i64 - -i32
+i64 - -i64
+i64 - 0.5 != i32
+i64 - 0.5 * 1
+i64 - 0.5 + f32
+i64 - 0.5 + f64
+i64 - 0.5 / f64
+i64 - 0.5 == -0.5
+i64 - 0.5 ^ i32
+i64 - 1 - 0.5
+i64 - 1 - f32
+i64 - 1 - i32
+i64 - 1 == i32
+i64 - 1 >= f64
+i64 - 1 >= i
+i64 - abs(1)
+i64 - abs(i32)
+i64 - array[i64]
+i64 - f32
+i64 - f32 != score(i)
+i64 - f32 * i32
+i64 - f32 - 1
+i64 - f32 <= f64
+i64 - f32 ^ f32
+i64 - f64
+i64 - f64 ** 0.5
+i64 - float(0.5)
+i64 - float(f32)
+i64 - float(i)
+i64 - i
+i64 - i != i32
+i64 - i * i64
+i64 - i + i32
+i64 - i - i64
+i64 - i > f64 - 0.5
+i64 - i >= i
+i64 - i ^ i64
+i64 - i32
+i64 - i32 % i32
+i64 - i32 + i32
+i64 - i32 <= i
+i64 - i64
+i64 - i64 + i32
+i64 - i64 .. i64
+i64 - i64 / i32
+i64 - max(f64)
+i64 - min(1, 0.5)
+i64 - score(1)
+i64 .. -1
+i64 .. -i64
+i64 .. 1 == list
+i64 .. findIndex(list, ok)
+i64 .. get(array, 1)
+i64 .. i
+i64 .. i32
+i64 .. i32 * i
+i64 .. i64
+i64 .. i64 + 1
+i64 .. int(f32)
+i64 .. int(i32)
+i64 .. last(array)
+i64 .. len(list)
+i64 .. score(1)
+i64 / (0.5 + f64)
+i64 / (1 - 0.5)
+i64 / (i32 - 1)
+i64 / -0.5
+i64 / -1
+i64 / -f32
+i64 / -f64
+i64 / -i
+i64 / -i64
+i64 / 0.5 < f64
+i64 / 0.5 == f32
+i64 / 0.5 ^ f64
+i64 / 1 ** 1
+i64 / 1 - f32
+i64 / 1 - min(0.5)
+i64 / 1 / 0.5
+i64 / abs(i64)
+i64 / array[i]
+i64 / f32
+i64 / f32 ** i
+i64 / f32 <= i
+i64 / f64
+i64 / f64 * 1
+i64 / f64 ** 0.5
+i64 / f64 ** f64
+i64 / f64 + i32
+i64 / f64 <= f32
+i64 / f64 <= i64
+i64 / float(f32)
+i64 / float(f64)
+i64 / float(i)
+i64 / float(i64)
+i64 / half(0.5)
+i64 / half(f64)
+i64 / i
+i64 / i != i64
+i64 / i * 0.5
+i64 / i * f32
+i64 / i - i32
+i64 / i ^ i64
+i64 / i32
+i64 / i32 * i
+i64 / i64
+i64 / i64 ** f32
+i64 / i64 - f64
+i64 / i64 / i64
+i64 / i64 < f32
+i64 / int(0.5)
+i64 / min(f32)
+i64 / score(1)
+i64 < -1
+i64 < -i32
+i64 < -i64
+i64 < 1 != true
+i64 < 1 * f64
+i64 < 1 + i64
+i64 < 1 / i32
+i64 < 1 ? half : ok
+i64 < 1 ^ f64
+i64 < abs(f32)
+i64 < array[1]
+i64 < f32
+i64 < f32 * i32
+i64 < f32 ? "bar" : ok
+i64 < f32 ^ 0.5
+i64 < f64
+i64 < f64 + f64
+i64 < f64 - f32
+i64 < f64 - i
+i64 < f64 ? i64 : score
+i64 < f64 or ok
+i64 < float(f64)
+i64 < half(0.5)
+i64 < i
+i64 < i != false
+i64 < i32
+i64 < i32 * 1
+i64 < i32 + i64
+i64 < i32 - 0.5
+i64 < i32 - f32
+i64 < i32 ? greet : 1
+i64 < i32 ? nil : array
+i64 < i32 ? true : "bar"
+i64 < i64
+i64 < i64 + 1
+i64 < i64 ? f32 : foo
+i64 < i64 ? half : i
+i64 < int(i64)
+i64 < max(0.5)
+i64 < min(0.5)
+i64 < min(i)
+i64 < score(1)
+i64 < score(1) * i64
+i64 <= -1
+i64 <= -f32
+i64 <= -i
+i64 <= -i32
+i64 <= -i64
+i64 <= 0.5 != true
+i64 <= 0.5 + i
+i64 <= 0.5 - 1
+i64 <= 0.5 == nil
+i64 <= 0.5 ? 0.5 : "foo"
+i64 <= 1 != true
+i64 <= 1 ** f64
+i64 <= 1 == ok
+i64 <= 1 ? array : ok
+i64 <= 1 and ok
+i64 <= array[i32]
+i64 <= f32
+i64 <= f32 && ok
+i64 <= f32 + 1
+i64 <= f32 / f32
+i64 <= f32 ^ i32
+i64 <= f64
+i64 <= f64 + 1
+i64 <= f64 - f32
+i64 <= half(0.5)
+i64 <= i
+i64 <= i != true
+i64 <= i * 1
+i64 <= i + 1
+i64 <= i / i64
+i64 <= i ? i32 : list
+i64 <= i ^ 0.5
+i64 <= i32
+i64 <= i32 && ok
+i64 <= i32 ? f64 : i < 1
+i64 <= i64
+i64 <= i64 - 0.5
+i64 <= i64 ? greet : div
+i64 <= int(i64)
+i64 <= last(array)
+i64 <= min(0.5)
+i64 <= min(f64)
+i64 <= score(1)
+i64 <= score(i)
+i64 == -0.5
+i64 == -1
+i64 == -f64
+i64 == -i
+i64 == 0.5 == ok
+i64 == 0.5 ? 1 : list
+i64 == 0.5 ? div : i64
+i64 == 0.5 ? foo : f32
+i64 == 0.5 ^ 0.5
+i64 == 0.5 ^ i
+i64 == 1 % i64
+i64 == 1 && ok
+i64 == 1 ** f64
+i64 == 1 + f32
+i64 == 1 - f64
+i64 == abs(0.5)
+i64 == abs(i32)
+i64 == count(array, true)
+i64 == count(list, true)
+i64 == f32
+i64 == f64
+i64 == f64 != ok
+i64 == f64 != true
+i64 == f64 - i
+i64 == f64 ? f64 : add
+i64 == findIndex(array, false)
+i64 == i
+i64 == i * f32
+i64 == i == false
+i64 == i == ok
+i64 == i ^ 1
+i64 == i32
+i64 == i32 ** 0.5
+i64 == i32 / f64
+i64 == i64
+i64 == i64 ^ 0.5
+i64 == int(1)
+i64 == int(f32)
+i64 == last(array)
+i64 == max(0.5)
+i64 == nil ? true : ok
+i64 == score(1)
+i64 == score(i)
+i64 > -0.5
+i64 > -1
+i64 > -f32
+i64 > -f64
+i64 > -i
+i64 > -i32
+i64 > -i64
+i64 > 0.5 * 1
+i64 > 0.5 ** 0.5
+i64 > 0.5 == true
+i64 > 0.5 ? f64 : greet
+i64 > 0.5 ? foo : add
+i64 > 1 ** 0.5
+i64 > 1 - 0.5
+i64 > 1 ? false : array
+i64 > 1 ? half : i64
+i64 > abs(1)
+i64 > abs(f64)
+i64 > array[i64]
+i64 > f32
+i64 > f32 - 1
+i64 > f32 ? div : false
+i64 > f64
+i64 > f64 == nil
+i64 > f64 and 1 > i64
+i64 > first(array)
+i64 > float(f32)
+i64 > half(f64)
+i64 > i
+i64 > i % i32
+i64 > i * f64
+i64 > i ** 1
+i64 > i + i
+i64 > i + i32
+i64 > i ^ i32
+i64 > i32
+i64 > i32 && ok
+i64 > i32 ** 0.5
+i64 > i32 ** i
+i64 > i64
+i64 > i64 % i32
+i64 > i64 - i64
+i64 > int(f32)
+i64 > int(i32)
+i64 > int(i64)
+i64 > score(i)
+i64 >= -0.5
+i64 >= -1
+i64 >= -f64
+i64 >= -i
+i64 >= 0.5 * f64
+i64 >= 0.5 ** f32
+i64 >= 0.5 + f32
+i64 >= 0.5 == nil
+i64 >= 0.5 == true
+i64 >= 0.5 ? array : array
+i64 >= 0.5 ? i32 : nil
+i64 >= 0.5 ^ 0.5
+i64 >= 0.5 and f32 != nil
+i64 >= 1 + f64
+i64 >= 1 + i32
+i64 >= 1 ? i : false
+i64 >= 1 ? i : string(array)
+i64 >= 1 ? true : i
+i64 >= f32
+i64 >= f32 * f32
+i64 >= f32 ** f64
+i64 >= f32 ** i32
+i64 >= f32 / f64
+i64 >= f64
+i64 >= f64 + i
+i64 >= f64 / i64
+i64 >= f64 == ok
+i64 >= f64 and ok
+i64 >= find(array, ok)
+i64 >= float(f32)
+i64 >= float(i)
+i64 >= float(i32)
+i64 >= half(0.5)
+i64 >= i
+i64 >= i and ok
+i64 >= i32
+i64 >= i32 % i64
+i64 >= i64
+i64 >= i64 % i
+i64 >= i64 && i64 > f32
+i64 >= i64 / i32
+i64 >= i64 == nil
+i64 >= i64 in {"foo": f64}.half
+i64 >= max(f64)
+i64 >= max(i64)
+i64 >= min(f32)
+i64 >= score(1)
+i64 ^ (0.5 + 1)
+i64 ^ (0.5 / i32)
+i64 ^ (1 * f32)
+i64 ^ (1 / i)
+i64 ^ (1 / i64)
+i64 ^ (f32 + f32)
+i64 ^ (f32 - f32)
+i64 ^ (f64 * f32)
+i64 ^ (i % i32)
+i64 ^ (i - 0.5)
+i64 ^ (i32 - f32)
+i64 ^ (i64 + i32)
+i64 ^ (i64 / f64)
+i64 ^ -0.5
+i64 ^ -i32
+i64 ^ 0.5 ** f32
+i64 ^ 0.5 <= i
+i64 ^ 0.5 >= f32
+i64 ^ 0.5 >= f64
+i64 ^ 0.5 >= i64
+i64 ^ 0.5 ^ 0.5
+i64 ^ 1 != i
+i64 ^ 1 != i32
+i64 ^ 1 ** i32
+i64 ^ 1 + f32
+i64 ^ 1 < f32
+i64 ^ 1 <= i
+i64 ^ abs(1)
+i64 ^ abs(i)
+i64 ^ array[i64]
+i64 ^ f32
+i64 ^ f32 - f32
+i64 ^ f64
+i64 ^ f64 * i32
+i64 ^ f64 ** i
+i64 ^ f64 + f32
+i64 ^ f64 < f32
+i64 ^ f64 == i64
+i64 ^ f64 > 1 + i64
+i64 ^ f64 ^ f32
+i64 ^ get(array, i)
+i64 ^ half(f64)
+i64 ^ i
+i64 ^ i ** f32
+i64 ^ i ** i64
+i64 ^ i32
+i64 ^ i32 != f32
+i64 ^ i32 != i32
+i64 ^ i32 ** i
+i64 ^ i32 + f32
+i64 ^ i32 + f64
+i64 ^ i32 / f32
+i64 ^ i64
+i64 ^ i64 * f64
+i64 ^ i64 * i64
+i64 ^ i64 ** f64
+i64 ^ i64 ^ f32
+i64 ^ i64 ^ f64
+i64 ^ i64 ^ i
+i64 ^ int(i64)
+i64 ^ last(array)
+i64 ^ len(array)
+i64 ^ max(0.5)
+i64 ^ max(1)
+i64 ^ max(f32)
+i64 ^ score(1)
+i64 ^ score(1, 1)
+i64 ^ score(i)
+i64 in array
+i64 in array == nil
+i64 in array ? false : greet
+i64 in map(array, #)
+i64 not in array
+indexOf("bar", "bar") + i64
+indexOf(foo.Bar, string(i32))
+int(-(i * 0.5))
+int(-0.5)
+int(-1)
+int(-abs(f64))
+int(-f32)
+int(-f64)
+int(-i)
+int(-i32)
+int(-i32) != i
+int(-i64)
+int(0.5 * 0.5)
+int(0.5 * 1)
+int(0.5 * f32)
+int(0.5 * i)
+int(0.5 * i32)
+int(0.5 * i64)
+int(0.5 ** 0.5)
+int(0.5 ** 1)
+int(0.5 ** f32)
+int(0.5 ** f64)
+int(0.5 ** i64)
+int(0.5 + f32)
+int(0.5 + f64)
+int(0.5 + i)
+int(0.5 + i32)
+int(0.5 - 0.5)
+int(0.5 - f32)
+int(0.5 - i32)
+int(0.5 / 0.5)
+int(0.5 / 1)
+int(0.5 / f32)
+int(0.5 / f64)
+int(0.5 / i32)
+int(0.5 / i64)
+int(0.5 ^ 0.5)
+int(0.5 ^ 1)
+int(0.5 ^ f32)
+int(0.5 ^ i)
+int(0.5) ** i64
+int(0.5) ** int(i64)
+int(0.5) + f32
+int(0.5) + f64
+int(0.5) + i64
+int(0.5) - i
+int(0.5) - i64
+int(0.5) .. i32
+int(0.5) < int(f64)
+int(0.5) == f32
+int(0.5) == i
+int(0.5) > -1
+int(0.5) >= i - i64
+int(0.5) ^ i32
+int(0.5) ^ i64
+int(0.5) in array
+int(0.5) not in array
+int(1 % 1)
+int(1 % i)
+int(1 % i32)
+int(1 * 0.5)
+int(1 * f32)
+int(1 * f64)
+int(1 * i)
+int(1 * i64)
+int(1 ** 0.5)
+int(1 ** 1)
+int(1 ** f32)
+int(1 ** i32)
+int(1 ** i64)
+int(1 + 0.5)
+int(1 + 1)
+int(1 + f64)
+int(1 + i)
+int(1 - 0.5)
+int(1 - 1)
+int(1 - i64)
+int(1 / 1)
+int(1 / f64)
+int(1 / i32)
+int(1 / i64)
+int(1 ^ 0.5)
+int(1 ^ 1)
+int(1 ^ i32)
+int(1 ^ i64)
+int(1) * f64
+int(1) * i
+int(1) ** f32
+int(1) ** i64
+int(1) + 0.5 + 1
+int(1) + i64
+int(1) - f64
+int(1) - i64
+int(1) .. i
+int(1) / f32
+int(1) / i
+int(1) < f64
+int(1) <= f32
+int(1) <= f64
+int(1) == i
+int(1) == i64
+int(1) > f64
+int(1) > float(1)
+int(1) > i32
+int(1) >= f32
+int(1) >= f64
+int(1) >= half(0.5)
+int(1) ^ f32
+int(1) ^ f64
+int(1) ^ i
+int(1) ^ i32
+int(1) in array
+int(abs(0.5))
+int(abs(f32))
+int(abs(f64))
+int(abs(i))
+int(abs(i32))
+int(abs(i64))
+int(array[1])
+int(array[i32])
+int(array[i64])
+int(count(list, ok))
+int(div(1, i))
+int(f32 * f32)
+int(f32 * i64)
+int(f32 ** 0.5)
+int(f32 ** f64)
+int(f32 ** i32)
+int(f32 + f32)
+int(f32 + i64)
+int(f32 - 0.5)
+int(f32 - f32)
+int(f32 - i)
+int(f32 / f64)
+int(f32 ^ 1)
+int(f32 ^ f32)
+int(f32 ^ i)
+int(f32 ^ i64)
+int(f32)
+int(f32) != f32
+int(f32) % i
+int(f32) * f64
+int(f32) .. i32
+int(f32) / f32
+int(f32) / i
+int(f32) == 0.5 != nil
+int(f32) == i
+int(f32) > i
+int(f32) >= i32
+int(f32) ^ i64
+int(f32) in array
+int(f64 * 0.5)
+int(f64 * 1)
+int(f64 * f32)
+int(f64 * f64)
+int(f64 * i32)
+int(f64 * i64)
+int(f64 ** 0.5)
+int(f64 ** 1)
+int(f64 ** f32)
+int(f64 ** i)
+int(f64 ** i32)
+int(f64 ** i64)
+int(f64 + f32)
+int(f64 + i64)
+int(f64 - 0.5)
+int(f64 - 1)
+int(f64 - f64)
+int(f64 / 1)
+int(f64 / i)
+int(f64 ^ 0.5)
+int(f64 ^ 1)
+int(f64 ^ f32)
+int(f64)
+int(f64) != i32
+int(f64) * i32
+int(f64) ** i64
+int(f64) - i
+int(f64) < i32
+int(f64) <= i32
+int(f64) == float(i32)
+int(f64) ^ i32
+int(f64) ^ i64
+int(f64) not in array
+int(false ? add : 0.5)
+int(false ? f32 : 0.5)
+int(false ? f64 : i32)
+int(find(array, true))
+int(findIndex(array, ok))
+int(findIndex(array, true))
+int(findIndex(list, # == foo))
+int(findIndex(list, ok))
+int(findLastIndex(array, ok))
+int(findLastIndex(array, true))
+int(findLastIndex(list, true))
+int(first(array))
+int(float(0.5))
+int(float(1))
+int(float(f32))
+int(float(f64) ** i64)
+int(float(f64))
+int(float(i))
+int(float(i32))
+int(float(i64))
+int(get(array, 1))
+int(get(array, i64))
+int(half(0.5))
+int(half(1 / f32))
+int(half(f64))
+int(i % 1)
+int(i % i64)
+int(i * 0.5)
+int(i * 1)
+int(i * f32)
+int(i * f64)
+int(i ** 0.5)
+int(i ** f32)
+int(i ** f64)
+int(i ** i64)
+int(i + 0.5)
+int(i + f32)
+int(i + i32)
+int(i + i64)
+int(i - f64)
+int(i - i64)
+int(i / 1) <= i32
+int(i / f64)
+int(i / i)
+int(i ^ f32)
+int(i ^ f64)
+int(i ^ i)
+int(i ^ i32)
+int(i)
+int(i) != i
+int(i) + f32
+int(i) + i32
+int(i) - i32
+int(i) .. i64
+int(i) / i
+int(i) < f32
+int(i) < f64
+int(i) <= f64
+int(i) == f32
+int(i) > i32
+int(i) > i64
+int(i) > int(i)
+int(i) >= i
+int(i) ^ i64
+int(i32 % i64)
+int(i32 * 0.5)
+int(i32 * 1)
+int(i32 * f64)
+int(i32 ** i)
+int(i32 + 0.5)
+int(i32 + 1)
+int(i32 + f32)
+int(i32 - 0.5)
+int(i32 - 1)
+int(i32 - f64)
+int(i32 - i)
+int(i32 - i64)
+int(i32 / 0.5)
+int(i32 / f64)
+int(i32 ^ 0.5)
+int(i32 ^ f32)
+int(i32 ^ f64)
+int(i32 ^ i)
+int(i32 ^ i64)
+int(i32)
+int(i32) != f32
+int(i32) % i64
+int(i32) ** -0.5
+int(i32) + i
+int(i32) - f32
+int(i32) .. i32
+int(i32) / i
+int(i32) / i32
+int(i32) < i64
+int(i32) <= f32
+int(i32) == -i32
+int(i32) == f64
+int(i32) > f64
+int(i64 % i32)
+int(i64 * f32)
+int(i64 * f64)
+int(i64 * i)
+int(i64 ** i)
+int(i64 + 1)
+int(i64 + i)
+int(i64 + i64)
+int(i64 - f32)
+int(i64 - f64)
+int(i64 - i32)
+int(i64 / f32)
+int(i64 / f64)
+int(i64 / i)
+int(i64 / i64)
+int(i64 ^ 0.5)
+int(i64 ^ f64)
+int(i64 ^ i32)
+int(i64 ^ i64)
+int(i64)
+int(i64) != f64
+int(i64) != i
+int(i64) != nil ? 1 : half
+int(i64) % i
+int(i64) % i32
+int(i64) ** f64
+int(i64) - i32
+int(i64) .. i32
+int(i64) <= i
+int(i64) <= i64
+int(i64) == min(i)
+int(i64) > f64
+int(i64) > i32
+int(i64) >= f64
+int(i64) ^ f32
+int(i64) ^ i32
+int(i64) in array
+int(i64) not in array
+int(int(0.5))
+int(int(1))
+int(int(f32))
+int(int(f64))
+int(int(i32))
+int(int(i64))
+int(last(array))
+int(len("bar"))
+int(len(array))
+int(len(list))
+int(max(0.5))
+int(max(1))
+int(max(f64))
+int(max(i))
+int(max(i64))
+int(min(0.5))
+int(min(1))
+int(min(f32))
+int(min(f32, i32))
+int(min(f64))
+int(min(f64, 1))
+int(min(i))
+int(min(i32))
+int(min(i64))
+int(min(i64, 1))
+int(ok ? 0.5 : i64)
+int(ok ? 1 : div)
+int(ok ? i32 : add)
+int(score(1))
+int(score(i))
+int(string(1))
+int(string(i))
+int(string(i32))
+int(string(i64))
+int(toJSON(1))
+int(toJSON(i))
+int(toJSON(i32))
+int(toJSON(i64))
+int(true ? f64 : 0.5)
+int(true ? f64 : 1)
+join(["bar"])
+join(map(array, "bar"))
+join(map(array, "foo"))
+join(map(list, "bar"))
+keys({"bar": i64})
+keys({"foo": 0.5})
+keys({"foo": f32})
+keys({"foo": i})
+last(1 .. i32)
+last([0.5])
+last([array])
+last([f64])
+last([half, i32])
+last(array)
+last(array) != f32
+last(array) != i32
+last(array) % i32
+last(array) * i32
+last(array) + f32
+last(array) + i
+last(array) - f32
+last(array) - i64
+last(array) - score(i)
+last(array) .. max(i)
+last(array) / f64
+last(array) > f64
+last(array) > max(1)
+last(array) >= f32
+last(array) >= f64
+last(false ? 0.5 : greet)
+last(false ? div : 1)
+last(false ? f32 : 1)
+last(false ? list : 1)?.add
+last(false ? list : add)
+last(filter(array, false))
+last(filter(array, ok))
+last(filter(list, true))
+last(i .. i32)
+last(i32 .. i32)
+last(i32 .. i64)
+last(i64 .. i)
+last(list)
+last(list) == foo
+last(list) not in list
+last(list).Bar
+last(list).Qux
+last(list).String
+last(list).String()
+last(list)?.Bar
+last(list)?.Qux
+last(list)?.String
+last(list)?.String()
+last(map(array, "bar"))
+last(map(array, #))
+last(map(array, array))
+last(map(array, i64))
+last(map(list, "bar"))
+last(map(list, "foo"))
+last(map(list, #))
+last(map(list, 0.5))
+last(map(list, add))
+last(map(list, f32))
+last(map(list, foo))
+last(map(list, i))
+last(map(list, i32))
+last(map(list, true))
+last(ok ? 0.5 : score)
+last(ok ? array : false)
+last(ok ? foo : add != half)
+last(ok ? nil : list)
+last(ok ? ok : i32)
+last(true ? 1 : list)?.String
+last(true ? foo : half)
+last(true ? half : 1)
+last(true ? i32 : ok)
+last(true ? i64 : 1)
+last(true ? ok : f64)
+lastIndexOf("bar", "foo") < f32 ^ f64
+len("bar" + "foo")
+len("bar") != f32
+len("bar") % score(i)
+len("bar") * i32
+len("bar") ** f64
+len("bar") ** i32
+len("bar") <= i64
+len("bar") > i32
+len("bar") >= 0.5 ^ 0.5
+len("bar") >= f32
+len("bar") >= f64
+len("foo" + foo.Bar)
+len("foo") * i32
+len("foo") * i64
+len("foo") - i
+len("foo") .. i
+len("foo") < f32
+len("foo") <= f32
+len("foo") <= f64
+len("foo") == i
+len("foo") == i32
+len("foo") == i64
+len("foo") > f64
+len("foo") not in array
+len([f64])
+len([false, add, half])
+len([false, foo, false])
+len([false])
+len(array)
+len(array) != i
+len(array) != i32
+len(array) * i
+len(array) ** i
+len(array) .. 1 - 1
+len(array) / f32
+len(array) < f32
+len(array) <= i
+len(array) >= f32
+len(array) >= f64
+len(array) >= i64
+len(false ? 1 : list)
+len(false ? nil : "foo")
+len(foo.Bar)
+len(foo.String())
+len(foo?.Bar)
+len(foo?.String())
+len(greet("bar"))
+len(greet("foo"))
+len(i .. 1)
+len(i32 .. 1)
+len(i32 .. i)
+len(i32 .. i32)
+len(i32 .. i64)
+len(i64 .. 1)
+len(i64 .. i)
+len(list)
+len(list) != i64
+len(list) * f32
+len(list) ** i
+len(list) / f64
+len(list) <= f64
+len(list) == f32
+len(list) == i
+len(list) > i
+len(list) > i64 - i
+len(list) >= i
+len(list) not in map(array, #)
+len(lower("foo"))
+len(lower(toBase64("foo")))
+len(lower(type(list)))
+len(map(array, "bar"))
+len(map(array, #))
+len(map(array, 0.5))
+len(map(array, array))
+len(map(array, f64))
+len(map(array, foo))
+len(map(array, half))
+len(map(array, i))
+len(map(array, i64))
+len(map(array, list))
+len(map(array, ok))
+len(map(array, score))
+len(map(list, "bar"))
+len(map(list, "foo"))
+len(map(list, #))
+len(map(list, 0.5))
+len(map(list, 1))
+len(map(list, f64))
+len(map(list, false))
+len(map(list, greet))
+len(map(list, half))
+len(map(list, i))
+len(map(list, score))
+len(map(list, true))
+len(sort(array))
+len(string("bar"))
+len(string("foo"))
+len(string(0.5))
+len(string(1))
+len(string(add))
+len(string(array))
+len(string(div))
+len(string(f32))
+len(string(f64))
+len(string(foo))
+len(string(greet))
+len(string(half))
+len(string(i32))
+len(string(i64))
+len(string(list))
+len(string(nil))
+len(string(ok))
+len(string(score))
+len(string(true))
+len(toJSON("bar"))
+len(toJSON("foo"))
+len(toJSON(0.5))
+len(toJSON(1 <= i32))
+len(toJSON(1))
+len(toJSON(array))
+len(toJSON(f32))
+len(toJSON(f64))
+len(toJSON(false))
+len(toJSON(foo))
+len(toJSON(foo.Bar))
+len(toJSON(i))
+len(toJSON(i32))
+len(toJSON(i64))
+len(toJSON(list))
+len(toJSON(nil))
+len(toJSON(ok))
+len(toJSON(true))
+len(trim("bar"))
+len(trim("foo"))
+len(trimPrefix("bar"))
+len(trimPrefix("foo"))
+len(trimSuffix("bar"))
+len(trimSuffix("foo"))
+len(type(0.5))
+len(type(1))
+len(type(array))
+len(type(div))
+len(type(f32))
+len(type(f64))
+len(type(false))
+len(type(foo))
+len(type(greet))
+len(type(half))
+len(type(half)) > f32
+len(type(i))
+len(type(i32))
+len(type(i64))
+len(type(list))
+len(type(nil))
+len(type(ok))
+len(type(score))
+len(upper("bar"))
+len(upper("foo"))
+len({"bar": 1})
+len({"bar": add})
+len({"bar": f64, "bar": i})
+len({"bar": greet, "bar": greet})
+len({"foo": "foo"})
+list
+list != array
+list != array == ok
+list != array ? 0.5 : "bar"
+list != filter(list, true)
+list != list
+list != map(array, #)
+list != map(array, 1)
+list != map(array, div)
+list != map(list, #)
+list != map(list, div)
+list != map(list, list)
+list == [add]
+list == array
+list == array ? div : i
+list == list
+list == list == nil
+list == list ? f64 : array
+list == list or add != nil
+list == map(list, f32)
+list == map(list, i64)
+list == nil == nil
+list == nil == ok
+list == nil or i == 0.5
+list == sort(array)
+list == {"bar": half, "foo": "foo"}?.i32
+list[-1]
+list[-i32]
+list[-i64]
+list[-i64].String
+list[-i]
+list[-i].String
+list[1 % i32]
+list[1 * i64]
+list[1:i] == list
+list[1].Bar
+list[1].Qux
+list[1].String
+list[1].String()
+list[1]?.Bar
+list[1]?.Qux
+list[1]?.String
+list[1]?.String()
+list[false ? add : 1]
+list[false ? nil : i]
+list[false ? true : f64]
+list[findIndex(list, ok)]
+list[i * i32]
+list[i32:i32]
+list[i32:i64]
+list[i32:i]
+list[i32]
+list[i32].Bar
+list[i32].Qux
+list[i32].String
+list[i32].String()
+list[i32]?.Bar
+list[i32]?.Qux
+list[i32]?.String
+list[i64 % 1]
+list[i64:i32]
+list[i64:i64]
+list[i64:i]
+list[i64]
+list[i64].Bar
+list[i64].Qux
+list[i64].String
+list[i64].String()
+list[i64]?.Bar
+list[i64]?.Qux
+list[i64]?.String
+list[i:false ? false : i64]
+list[i:i]
+list[i]
+list[i].Bar
+list[i].Qux
+list[i].String
+list[i].String()
+list[i]?.Bar
+list[i]?.Qux
+list[i]?.String()
+list[int(0.5)]
+list[int(f64)]
+list[int(i)]
+list[max(i)]
+list[min(i)]
+list[ok ? f32 : add]
+list[score(1)]
+list[score(i)]
+list[true ? f64 : true]
+lower("bar" + "bar")
+lower(foo.Bar)
+lower(foo.String())
+lower(foo?.Bar)
+lower(foo?.String())
+lower(greet("bar"))
+lower(greet("foo"))
+lower(lower("bar"))
+lower(lower(trimSuffix("bar")))
+lower(string("bar"))
+lower(string("foo"))
+lower(string(0.5))
+lower(string(add))
+lower(string(array))
+lower(string(div))
+lower(string(f32))
+lower(string(f64))
+lower(string(false))
+lower(string(foo))
+lower(string(greet))
+lower(string(half))
+lower(string(i))
+lower(string(i32))
+lower(string(i64))
+lower(string(list))
+lower(string(nil))
+lower(string(ok))
+lower(string(score))
+lower(string(true))
+lower(toBase64("bar" + "bar"))
+lower(toBase64("bar"))
+lower(toBase64("foo"))
+lower(toJSON("bar"))
+lower(toJSON("foo"))
+lower(toJSON(0.5))
+lower(toJSON(1))
+lower(toJSON(array))
+lower(toJSON(f32))
+lower(toJSON(f64))
+lower(toJSON(false))
+lower(toJSON(foo))
+lower(toJSON(i))
+lower(toJSON(i32))
+lower(toJSON(i64))
+lower(toJSON(list))
+lower(toJSON(nil))
+lower(toJSON(ok))
+lower(toJSON(true))
+lower(trim("foo"))
+lower(trimPrefix("bar"))
+lower(trimSuffix("bar"))
+lower(trimSuffix("foo"))
+lower(trimSuffix(foo?.String()))
+lower(type("bar"))
+lower(type("foo"))
+lower(type(0.5 * i64))
+lower(type(0.5))
+lower(type(1))
+lower(type(array))
+lower(type(div))
+lower(type(f32))
+lower(type(f64))
+lower(type(false))
+lower(type(foo))
+lower(type(greet))
+lower(type(half))
+lower(type(i))
+lower(type(i64))
+lower(type(nil))
+lower(type(ok))
+lower(type(score))
+lower(type(true))
+lower(upper("bar"))
+lower(upper("foo"))
+map(1 .. 1, # .. #)
+map(1 .. 1, # == f64)
+map(1 .. i, #)
+map(1 .. i, foo)
+map(1 .. i, greet)
+map(1 .. i32, #)
+map(1 .. i32, ok)
+map(1 .. i64, f64 ^ 1)
+map(1 .. i64, foo)
+map(1 .. i64, list)
+map(["bar"], # == #)
+map(["foo"], #)
+map([1, i], #)
+map([add], foo)
+map([f32], f64)
+map([false], score)
+map([greet, i32], #)
+map([greet], #)
+map([half], #)
+map([i32], foo)
+map([i64], #)
+map([i], max(#))
+map([list, nil], i64)
+map([list], #)
+map([nil], #?.div(#))
+map([score, "bar"], #)
+map([score], #)
+map([score], array)
+map(array, !false)
+map(array, !true)
+map(array, "bar" != "foo")
+map(array, "bar" contains "foo")
+map(array, "bar")[i64]
+map(array, # != # ? # : array)
+map(array, # != #)
+map(array, # != 1)
+map(array, # != f64)
+map(array, # != i32)
+map(array, # != nil)
+map(array, # % #)
+map(array, # % 1)
+map(array, # % i)
+map(array, # % i32)
+map(array, # % i64)
+map(array, # * #)
+map(array, # * 0.5)
+map(array, # * f64)
+map(array, # * i32)
+map(array, # * i64)
+map(array, # ** #)
+map(array, # ** 0.5)
+map(array, # ** i)
+map(array, # ** i32)
+map(array, # ** i64)
+map(array, # + #)
+map(array, # + 0.5)
+map(array, # + 1)
+map(array, # + f64)
+map(array, # + i)
+map(array, # + i32)
+map(array, # + i64)
+map(array, # - #)
+map(array, # - 0.5)
+map(array, # - 1)
+map(array, # - f32)
+map(array, # - i)
+map(array, # - i32)
+map(array, # .. #)
+map(array, # .. 1)
+map(array, # .. i)
+map(array, # .. i32)
+map(array, # .. i64)
+map(array, # / #)
+map(array, # / 0.5)
+map(array, # / f64)
+map(array, # / i)
+map(array, # / i32)
+map(array, # / i64)
+map(array, # < #)
+map(array, # < 0.5)
+map(array, # < 1)
+map(array, # < f32)
+map(array, # < f64)
+map(array, # <= #)
+map(array, # <= 1)
+map(array, # <= i64)
+map(array, # == #)
+map(array, # == 1)
+map(array, # == i64)
+map(array, # > #)
+map(array, # > 1)
+map(array, # > f32)
+map(array, # > i32)
+map(array, # > i64)
+map(array, # >= #)
+map(array, # >= 0.5)
+map(array, # >= 1)
+map(array, # >= f64)
+map(array, # >= i)
+map(array, # >= i32)
+map(array, # ^ #)
+map(array, # ^ 0.5)
+map(array, # ^ i)
+map(array, # ^ i32)
+map(array, # ^ i64)
+map(array, # in array)
+map(array, #)
+map(array, #) != array
+map(array, #) != list
+map(array, #) != nil == nil
+map(array, #)[i64]
+map(array, #)[i]
+map(array, -#)
+map(array, -(# ** f64))
+map(array, -0.5)
+map(array, -1)
+map(array, -f64)
+map(array, -i)
+map(array, -i64)
+map(array, 0.5 != #)
+map(array, 0.5 != 0.5)
+map(array, 0.5 != i32)
+map(array, 0.5 * #)
+map(array, 0.5 ** #)
+map(array, 0.5 + #)
+map(array, 0.5 - #)
+map(array, 0.5 / #)
+map(array, 0.5 < #)
+map(array, 0.5 < 1)
+map(array, 0.5 <= f32)
+map(array, 0.5 == #)
+map(array, 0.5 == i32)
+map(array, 0.5 > #)
+map(array, 0.5 ^ #)
+map(array, 1 != #)
+map(array, 1 != 1)
+map(array, 1 != f32)
+map(array, 1 % #)
+map(array, 1 % i)
+map(array, 1 * #)
+map(array, 1 * f32)
+map(array, 1 ** #)
+map(array, 1 ** 1)
+map(array, 1 ** i32)
+map(array, 1 + #)
+map(array, 1 .. #)
+map(array, 1 / #)
+map(array, 1 / 1)
+map(array, 1 < 0.5)
+map(array, 1 <= #)
+map(array, 1 == #)
+map(array, 1 == nil)
+map(array, 1 >= #)
+map(array, 1 >= f64)
+map(array, 1 ^ #)
+map(array, 1 ^ 1)
+map(array, 1 in array)
+map(array, 1)[i64]
+map(array, 1)[i]
+map(array, [array])
+map(array, [i32, foo])
+map(array, abs(#))
+map(array, abs(0.5))
+map(array, add(#, #))
+map(array, add(#, i))
+map(array, add(1, #))
+map(array, add)
+map(array, add) != list
+map(array, all(array, true))
+map(array, array != nil)
+map(array, array)
+map(array, array) == array
+map(array, array[#:#])
+map(array, array[1])
+map(array, div(#, #))
+map(array, div)
+map(array, f32 ** #)
+map(array, f32 ** f64)
+map(array, f32 + #)
+map(array, f32 - f64)
+map(array, f32 / #)
+map(array, f32 < #)
+map(array, f32 <= #)
+map(array, f32 <= 1)
+map(array, f32 == #)
+map(array, f32 > #)
+map(array, f32)
+map(array, f64 != #)
+map(array, f64 != 0.5)
+map(array, f64 * 1)
+map(array, f64 ** #)
+map(array, f64 - #)
+map(array, f64 / 1)
+map(array, f64 <= f64)
+map(array, f64 > #)
+map(array, f64)
+map(array, f64) != list
+map(array, f64) == i .. 1
+map(array, false ? "foo" : #)
+map(array, false ? 0.5 : #)
+map(array, false)[i]
+map(array, findLast(array, true))
+map(array, float(# * f64))
+map(array, float(#))
+map(array, float(1))
+map(array, float(i64))
+map(array, foo)
+map(array, foo.Bar)
+map(array, foo.Qux)
+map(array, foo.String())
+map(array, foo.String)
+map(array, foo?.Qux)
+map(array, foo?.String)
+map(array, get(array, #))
+map(array, get(list, #))
+map(array, greet != half)
+map(array, greet("bar"))
+map(array, greet("foo"))
+map(array, greet)
+map(array, greet) == list
+map(array, half(0.5))
+map(array, half)
+map(array, i != #)
+map(array, i != f64)
+map(array, i % i)
+map(array, i * 0.5)
+map(array, i ** #)
+map(array, i ** 0.5)
+map(array, i .. #)
+map(array, i / #)
+map(array, i == #)
+map(array, i > #)
+map(array, i >= f64)
+map(array, i ^ #)
+map(array, i)
+map(array, i)[i64]
+map(array, i32 % #)
+map(array, i32 % i)
+map(array, i32 * #)
+map(array, i32 + 0.5)
+map(array, i32 + i64)
+map(array, i32 - #)
+map(array, i32 / #)
+map(array, i32 < 0.5)
+map(array, i32 == #)
+map(array, i32 == 0.5)
+map(array, i32 == nil)
+map(array, i32 > #)
+map(array, i32 >= f32)
+map(array, i32 ^ #)
+map(array, i32)
+map(array, i64 != #)
+map(array, i64 * #)
+map(array, i64 ** #)
+map(array, i64 + #)
+map(array, i64 - #)
+map(array, i64 .. #)
+map(array, i64 / #)
+map(array, i64 <= 1)
+map(array, i64 == #)
+map(array, i64 == f64)
+map(array, i64 > #)
+map(array, i64 >= i64)
+map(array, i64 ^ #)
+map(array, i64 ^ i32)
+map(array, i64)
+map(array, i64)[i32]
+map(array, int(#))
+map(array, int(0.5))
+map(array, int(f64))
+map(array, last(array))
+map(array, len(array))
+map(array, list)
+map(array, map(array, #))
+map(array, map(array, true))
+map(array, map(list, #))
+map(array, map(list, f64))
+map(array, max(#))
+map(array, max(#, #, #))
+map(array, max(0.5))
+map(array, max(0.5, #))
+map(array, max(i64, #, i))
+map(array, min(# ^ #))
+map(array, min(#))
+map(array, min(#, #, #, #))
+map(array, min(#, 1))
+map(array, min(#, 1, #))
+map(array, min(#, 1, f64))
+map(array, min(#, f32))
+map(array, min(#, f64))
+map(array, nil != #)
+map(array, nil == #)
+map(array, nil == half)
+map(array, not (# < 1))
+map(array, not false)
+map(array, not true)
+map(array, ok ? # : i64)
+map(array, ok ? f32 : div)
+map(array, ok || ok)
+map(array, ok)
+map(array, one(array, ok))
+map(array, one(array, true))
+map(array, score != nil)
+map(array, score(#))
+map(array, score(#, #))
+map(array, score(#, #, 1))
+map(array, score(1))
+map(array, score)
+map(array, sort(array))
+map(array, string("bar"))
+map(array, string(# ** f64))
+map(array, string(#))
+map(array, string(array))
+map(array, string(foo))
+map(array, string(list))
+map(array, string(score))
+map(array, toJSON(#))
+map(array, toJSON(array))
+map(array, toJSON(ok))
+map(array, true ? # : #)
+map(array, true ? f32 : i)
+map(array, true ? nil : #)
+map(array, true)[i]
+map(array, type(#))
+map(array, type(half))
+map(array, type(i))
+map(array, upper("foo"))
+map(array[i64:1], array)
+map(array[i64:i64], #)
+map(array[i:1], i > #)
+map(false ? 0.5 : "bar", greet)
+map(false ? 1 : list, half)
+map(false ? array : "foo", i64 / 1)
+map(false ? true : array, #)
+map(filter(array, false), foo)
+map(filter(array, ok), # <= #)
+map(filter(array, ok), #)
+map(filter(array, ok), i32 + #)
+map(filter(array, ok), score)
+map(filter(array, true), f64)
+map(filter(array, true), i)
+map(filter(list, false), #)
+map(filter(list, true), score)
+map(i .. 1, # > #)
+map(i .. 1, -i64)
+map(i .. 1, f64)
+map(i .. i32, #)
+map(i .. i32, score)
+map(i .. i64, #)
+map(i .. i64, f64)
+map(i .. i64, score)
+map(i32 .. 1, #)
+map(i32 .. 1, list)
+map(i32 .. i, add)
+map(i32 .. i, half)
+map(i32 .. i32, #)
+map(i32 .. i32, greet)
+map(i32 .. i64, abs(#))
+map(i32 .. i64, f64)
+map(i64 .. i, #)
+map(i64 .. i, i)
+map(i64 .. i32, #)
+map(list, !false)
+map(list, !true)
+map(list, "bar" in #)
+map(list, "bar" not in #)
+map(list, "bar") != list
+map(list, "foo" + "foo")
+map(list, "foo" in #)
+map(list, "foo" not matches "bar")
+map(list, "foo") == list
+map(list, # != #)
+map(list, # != foo)
+map(list, # != nil)
+map(list, # == #)
+map(list, # == foo)
+map(list, # not in list)
+map(list, #)
+map(list, #) == array
+map(list, #) == list
+map(list, #)[i32]
+map(list, #)[i64]
+map(list, #)[i]
+map(list, #?.Bar)
+map(list, #?.Qux("bar"))
+map(list, #?.Qux)
+map(list, #?.String())
+map(list, #?.String)
+map(list, -0.5)
+map(list, -1)
+map(list, -f64)
+map(list, -i)
+map(list, .Bar not in # != true)
+map(list, .Bar)
+map(list, .Qux)
+map(list, .String())
+map(list, .String)
+map(list, 0.5 - i64)
+map(list, 0.5 < f32)
+map(list, 0.5 <= f32)
+map(list, 0.5 <= i64)
+map(list, 0.5 >= 1)
+map(list, 0.5 ^ 1)
+map(list, 1 + i)
+map(list, 1 - f64)
+map(list, 1 .. 1)
+map(list, 1 .. i64)
+map(list, 1 / 1)
+map(list, 1 / f32)
+map(list, 1 < i32)
+map(list, 1 > i32)
+map(list, 1 >= f64)
+map(list, [1])
+map(list, [false])
+map(list, abs(0.5))
+map(list, abs(1))
+map(list, add)
+map(list, array)
+map(list, div != greet)
+map(list, div == div)
+map(list, div)
+map(list, div) != list
+map(list, f32 != f32)
+map(list, f32 ** f32)
+map(list, f32 / i32)
+map(list, f32 < 0.5)
+map(list, f32 <= 1)
+map(list, f32)
+map(list, f64 * 0.5)
+map(list, f64 * f32)
+map(list, f64 ** i32)
+map(list, f64 + 1)
+map(list, f64 + i32)
+map(list, f64 - 0.5)
+map(list, f64 < f64)
+map(list, f64 ^ i64)
+map(list, f64)
+map(list, f64) != list
+map(list, false ? # : nil)
+map(list, false ? f32 : #)
+map(list, false ? f32 : foo)
+map(list, false and true)
+map(list, filter(list, false))
+map(list, first(list))
+map(list, float(0.5))
+map(list, float(1))
+map(list, float(f32))
+map(list, float(i64))
+map(list, foo == #)
+map(list, foo)
+map(list, foo.Bar)
+map(list, foo.String)
+map(list, foo?.String())
+map(list, foo?.String)
+map(list, greet == greet)
+map(list, greet("foo"))
+map(list, greet)
+map(list, greet) != array ? 0.5 : 1
+map(list, half != score)
+map(list, half(0.5))
+map(list, half)
+map(list, i * 1)
+map(list, i * i64)
+map(list, i + i)
+map(list, i >= f64)
+map(list, i >= i64)
+map(list, i ^ f32)
+map(list, i ^ i64)
+map(list, i)
+map(list, i32 * f32)
+map(list, i32 == i64)
+map(list, i32 == nil)
+map(list, i32 > i)
+map(list, i32 ^ 0.5)
+map(list, i32)
+map(list, i64 == 1)
+map(list, i64 == f32)
+map(list, i64 ^ (i + i32))
+map(list, i64)
+map(list, int(1))
+map(list, len(array))
+map(list, list)
+map(list, map(array, score))
+map(list, map(list, #))
+map(list, min(i64))
+map(list, nil != #)
+map(list, nil != 1)
+map(list, nil != array)
+map(list, nil != i)
+map(list, nil != nil)
+map(list, nil == #)
+map(list, nil == div)
+map(list, nil == foo)
+map(list, nil == i32)
+map(list, nil not in array)
+map(list, not false)
+map(list, not ok)
+map(list, not true)
+map(list, ok ? i64 : i64)
+map(list, ok)
+map(list, ok) != array
+map(list, score != greet)
+map(list, score(i))
+map(list, score)
+map(list, string(#))
+map(list, string(foo))
+map(list, string(nil))
+map(list, toBase64("foo"))
+map(list, toJSON(#))
+map(list, toJSON(1))
+map(list, toJSON(foo))
+map(list, toJSON(i))
+map(list, trimPrefix("bar"))
+map(list, trimSuffix("foo"))
+map(list, true ? false : score)
+map(list, true ? nil : #)
+map(list, true)[i32]
+map(list, type(#))
+map(list, type(greet))
+map(list, type(half))
+map(list, type(i))
+map(list, type(i64))
+map(list[i:i], i)
+map(map(array, "bar"), #)
+map(map(array, # >= #), add)
+map(map(array, #), # < #)
+map(map(array, #), # ^ i32)
+map(map(array, #), #)
+map(map(array, #), add)
+map(map(array, #), div)
+map(map(array, #), f32)
+map(map(array, #), f64)
+map(map(array, #), foo)
+map(map(array, #), foo.Qux)
+map(map(array, #), greet)
+map(map(array, #), half)
+map(map(array, #), i)
+map(map(array, #), i64)
+map(map(array, #), int(#))
+map(map(array, #), nil != half)
+map(map(array, #), score(i))
+map(map(array, #), score)
+map(map(array, 0.5), # != #)
+map(map(array, 0.5), #)
+map(map(array, 0.5), -1)
+map(map(array, 0.5), list)
+map(map(array, 1), #)
+map(map(array, 1), ok)
+map(map(array, 1), score)
+map(map(array, add), #)
+map(map(array, add), list)
+map(map(array, array), add)
+map(map(array, array), f64)
+map(map(array, f32), #)
+map(map(array, f64), add)
+map(map(array, f64), nil == nil)
+map(map(array, foo), #)
+map(map(array, foo), f64)
+map(map(array, foo), greet)
+map(map(array, half), div)
+map(map(array, i64), f64)
+map(map(array, list), #)
+map(map(array, true), #)
+map(map(array, true), div)
+map(map(array, true), foo)
+map(map(list, "foo"), add)
+map(map(list, "foo"), div)
+map(map(list, "foo"), i32)
+map(map(list, #), "bar" + "foo")
+map(map(list, #), # != #)
+map(map(list, #), #)
+map(map(list, #), array)
+map(map(list, #), div)
+map(map(list, #), f32)
+map(map(list, #), f64)
+map(map(list, #), greet)
+map(map(list, #), i)
+map(map(list, #), i32)
+map(map(list, #), i64 < i32)
+map(map(list, #), i64)
+map(map(list, #), nil != i)
+map(map(list, #), ok)
+map(map(list, #), score)
+map(map(list, 0.5), # / #)
+map(map(list, 0.5), #)
+map(map(list, 0.5), greet)
+map(map(list, 0.5), list)
+map(map(list, 0.5), score)
+map(map(list, 1), # <= #)
+map(map(list, 1), foo)
+map(map(list, add), [#, #])
+map(map(list, add), f64)
+map(map(list, f32), #)
+map(map(list, f32), greet)
+map(map(list, f32), true ? "foo" : "foo")
+map(map(list, f64), #)
+map(map(list, false), array)
+map(map(list, false), f64)
+map(map(list, false), i32)
+map(map(list, false), list)
+map(map(list, foo), #)
+map(map(list, foo), ok)
+map(map(list, greet), "bar" != "foo")
+map(map(list, greet), # == #)
+map(map(list, greet), #)
+map(map(list, greet), ["foo", 1])
+map(map(list, greet), half)
+map(map(list, half), #)
+map(map(list, i), i32)
+map(map(list, i32), half)
+map(map(list, i32), list)
+map(map(list, i64), #)
+map(map(list, i64), array)
+map(map(list, i64), div)
+map(map(list, i64), f64)
+map(map(list, i64), list)
+map(map(list, list), #)
+map(map(list, list), div)
+map(map(list, list), i)
+map(map(list, ok), #)
+map(map(list, score), #)
+map(map(list, score), ok)
+map(map(list, true), #)
+map(ok ? "foo" : 0.5, #)
+map(ok ? "foo" : greet, f32)
+map(ok ? array : "bar", ok)
+map(ok ? array : foo, # / 1)
+map(sort(array), # > #)
+map(sort(array), i32 > #)
+map(true ? "bar" : true, #)
+map(true ? "foo" : add, i64)
+map(true ? array : f64, #)
+map(true ? array : true, #)
+max(--1)
+max(-0.5)
+max(-1)
+max(-1, i)
+max(-count(list, false), i64)
+max(-f32)
+max(-f64)
+max(-i)
+max(-i, i32, i)
+max(-i32)
+max(-i64)
+max(-i64, 0.5 / f64)
+max(0.5 * 0.5)
+max(0.5 * f64)
+max(0.5 * i)
+max(0.5 * i, i32)
+max(0.5 * i32)
+max(0.5 ** 0.5)
+max(0.5 ** 1)
+max(0.5 ** f32)
+max(0.5 ** f64)
+max(0.5 ** i)
+max(0.5 ** i64)
+max(0.5 + 0.5)
+max(0.5 + 1)
+max(0.5 + i)
+max(0.5 + i32)
+max(0.5 + i64)
+max(0.5 - 0.5)
+max(0.5 - 1)
+max(0.5 - i)
+max(0.5 - i32)
+max(0.5 - i64)
+max(0.5 / 0.5)
+max(0.5 / f32)
+max(0.5 / f64)
+max(0.5 / f64, f64)
+max(0.5 / i)
+max(0.5 / i64)
+max(0.5 ^ 0.5)
+max(0.5 ^ 1)
+max(0.5 ^ f32)
+max(0.5 ^ i)
+max(0.5 ^ i32)
+max(0.5 ^ i64)
+max(0.5) != i == ok
+max(0.5) * f32
+max(0.5) * f64
+max(0.5) + i
+max(0.5) - f32
+max(0.5) - f64
+max(0.5) < f64
+max(0.5) <= 0.5 - 0.5
+max(0.5) <= f64
+max(0.5) == f32
+max(0.5) == i64
+max(0.5) > f32
+max(0.5) >= i32
+max(0.5) ^ i32
+max(0.5, 1) <= i32
+max(1 % 1)
+max(1 % i)
+max(1 % i32)
+max(1 % i64)
+max(1 * 0.5)
+max(1 * 1)
+max(1 ** 0.5)
+max(1 ** 1)
+max(1 ** f64)
+max(1 ** i64)
+max(1 + f32, f64)
+max(1 + i64)
+max(1 - 1)
+max(1 - i32)
+max(1 - i64)
+max(1 / 0.5)
+max(1 / 1)
+max(1 / f32)
+max(1 / f64)
+max(1 ^ 1)
+max(1 ^ i32)
+max(1) != i
+max(1) * i
+max(1) - f64
+max(1) - i64
+max(1) .. i32
+max(1) / i
+max(1) / i64
+max(1) <= f32
+max(1) <= i
+max(1) <= i32
+max(1) <= i64
+max(1) == f32
+max(1) > f32
+max(1) > f64
+max(1) > i
+max(1) > i64
+max(1, i32, f32) != i64
+max(abs(0.5))
+max(abs(1))
+max(abs(f32))
+max(abs(f64))
+max(abs(i))
+max(abs(i32))
+max(abs(i64))
+max(array[1])
+max(array[i64])
+max(array[i])
+max(count(array, false))
+max(count(list, false))
+max(div(1, 1))
+max(f32 * 0.5)
+max(f32 * 1)
+max(f32 * f32)
+max(f32 * i32)
+max(f32 ** 0.5)
+max(f32 ** 1)
+max(f32 ** i32)
+max(f32 ** i64)
+max(f32 + 1)
+max(f32 + f64)
+max(f32 + i64)
+max(f32 - f64)
+max(f32 - i)
+max(f32 - i32)
+max(f32 / 0.5)
+max(f32 / f32)
+max(f32 ^ 0.5)
+max(f32 ^ 1)
+max(f32 ^ f32)
+max(f32 ^ i32)
+max(f32 ^ i64)
+max(f32)
+max(f32) != -i32
+max(f32) != i32
+max(f32) + i64
+max(f32) - f32
+max(f32) <= i
+max(f32) <= max(f64)
+max(f32) >= i64
+max(f32) ^ f32
+max(f32) ^ i32
+max(f32, -f32)
+max(f32, 1) > i32
+max(f32, f32)
+max(f32, f64)
+max(f32, i)
+max(f32, i32)
+max(f32, i64)
+max(f32, min(i))
+max(f64 * 0.5)
+max(f64 * f64)
+max(f64 * i, f32)
+max(f64 * i32)
+max(f64 ** 1)
+max(f64 ** i)
+max(f64 ** i64)
+max(f64 + 0.5)
+max(f64 - i32)
+max(f64 - i64)
+max(f64 / 0.5)
+max(f64 / f32)
+max(f64 / i32)
+max(f64 ^ 0.5)
+max(f64 ^ i32)
+max(f64 ^ i64)
+max(f64)
+max(f64) != i
+max(f64) + f32
+max(f64) + i64
+max(f64) - f32
+max(f64) / f32
+max(f64) / i32
+max(f64) == f64
+max(f64) == i32
+max(f64) > f32
+max(f64) > f64
+max(f64) > i64
+max(f64) ^ 1 ^ i64
+max(f64) ^ i
+max(f64) ^ min(i32, 1)
+max(f64, -1)
+max(f64, 0.5 ** i64)
+max(f64, 1) <= f64
+max(f64, 1) == i32
+max(f64, f32)
+max(f64, f32, i32)
+max(f64, f32, i64)
+max(f64, f64)
+max(f64, f64, score(1))
+max(f64, float(i))
+max(f64, half(f64))
+max(f64, i)
+max(f64, i32)
+max(f64, i64)
+max(false ? 1 : 0.5)
+max(false ? 1 : nil)
+max(false ? add : ok)
+max(false ? half : list)
+max(false ? i : nil)
+max(false ? i32 : score)
+max(false ? true : 1)
+max(find(array, ok))
+max(find(array, true))
+max(findIndex(array, ok))
+max(findIndex(array, true))
+max(findIndex(list, ok))
+max(findIndex(list, true))
+max(findLast(array, false))
+max(findLast(array, true))
+max(findLastIndex(array, false))
+max(findLastIndex(list, true))
+max(first(array))
+max(float(0.5))
+max(float(1))
+max(float(f32))
+max(float(f64))
+max(float(i))
+max(float(i64))
+max(float(i64), f64)
+max(get(array, 1))
+max(get(array, i))
+max(get(array, i32))
+max(get(array, i64))
+max(half(-0.5))
+max(half(0.5))
+max(half(f64))
+max(i % i)
+max(i % i32)
+max(i % i64)
+max(i * 0.5)
+max(i * 1)
+max(i * f32)
+max(i * i32)
+max(i ** 0.5)
+max(i ** 1)
+max(i ** f64)
+max(i ** i)
+max(i ** i64)
+max(i + 0.5)
+max(i + 1)
+max(i + f32)
+max(i + f64)
+max(i + i)
+max(i - 1)
+max(i - i32)
+max(i - i32, f32)
+max(i - i64)
+max(i / 0.5)
+max(i / f32)
+max(i / i32, f64)
+max(i ^ 0.5)
+max(i ^ 1)
+max(i ^ f32)
+max(i ^ f64)
+max(i)
+max(i) != f64
+max(i) ** f64
+max(i) + f32
+max(i) + i64
+max(i) - f32
+max(i) - f64
+max(i) - i32
+max(i) - i64
+max(i) / f64
+max(i) >= i64
+max(i) ^ (i * i)
+max(i) ^ f32
+max(i, -f32)
+max(i, f32)
+max(i, f32, f32)
+max(i, f64)
+max(i, i)
+max(i, i32)
+max(i, i64)
+max(i, i64, i64)
+max(i32 % 1)
+max(i32 % i32)
+max(i32 * 0.5)
+max(i32 * 1)
+max(i32 * f32)
+max(i32 * i64)
+max(i32 + 0.5, f64)
+max(i32 + f64)
+max(i32 + i)
+max(i32 + i32)
+max(i32 - i)
+max(i32 - i64)
+max(i32 / f32)
+max(i32 / f64)
+max(i32 / i64)
+max(i32 ^ 0.5)
+max(i32 ^ 1)
+max(i32 ^ f32)
+max(i32 ^ i)
+max(i32 ^ i32)
+max(i32)
+max(i32) != min(i64)
+max(i32) - f32
+max(i32) - i64
+max(i32) / f32
+max(i32) >= i32
+max(i32) ^ i64
+max(i32, 1) == i32
+max(i32, abs(f64))
+max(i32, f32)
+max(i32, f32) != i32
+max(i32, f64)
+max(i32, f64) - f32
+max(i32, i)
+max(i32, i, i)
+max(i32, i32)
+max(i32, i32, i)
+max(i32, i64)
+max(i64 % i)
+max(i64 % i32)
+max(i64 * 0.5)
+max(i64 * 1)
+max(i64 * f32)
+max(i64 * i32)
+max(i64 ** 1)
+max(i64 ** i64)
+max(i64 + 0.5)
+max(i64 + f32)
+max(i64 + i32)
+max(i64 - 0.5)
+max(i64 - 1)
+max(i64 - f32)
+max(i64 - f64)
+max(i64 - i)
+max(i64 / 1)
+max(i64 / f64)
+max(i64 / i)
+max(i64 / i64)
+max(i64 ^ 0.5)
+max(i64 ^ 1)
+max(i64 ^ i)
+max(i64 ^ i64)
+max(i64)
+max(i64) != f32
+max(i64) != i32
+max(i64) * i32
+max(i64) * i64
+max(i64) ** i64
+max(i64) + f32
+max(i64) + i64
+max(i64) / f32
+max(i64) / i
+max(i64) / i64
+max(i64) < f32
+max(i64) < i64
+max(i64) <= i
+max(i64) == f32
+max(i64) == f64
+max(i64) >= i32
+max(i64) ^ (i64 / f32)
+max(i64) in array
+max(i64, 1) * i32
+max(i64, f32)
+max(i64, f64)
+max(i64, i)
+max(i64, i32)
+max(i64, i64)
+max(int(0.5))
+max(int(1))
+max(int(f32))
+max(int(f64))
+max(int(i))
+max(int(i32))
+max(int(i64))
+max(last(array))
+max(len("bar"))
+max(len("foo"))
+max(len(array))
+max(len(list))
+max(len(list), 0.5 - i)
+max(max(0.5))
+max(max(0.5, 0.5))
+max(max(1))
+max(max(f32))
+max(max(f64))
+max(max(i))
+max(max(i32))
+max(max(i64))
+max(min(0.5))
+max(min(0.5, i))
+max(min(1))
+max(min(1, i64, 1))
+max(min(f32))
+max(min(f64))
+max(min(f64, i64))
+max(min(i))
+max(min(i32))
+max(min(i32, i))
+max(ok ? 1 : foo)
+max(ok ? 1 : i)
+max(ok ? 1 : i32)
+max(ok ? div : foo)
+max(ok ? div : i64)
+max(ok ? i : true)
+max(ok ? ok : i64)
+max(ok ? true : 0.5)
+max(score(1))
+max(score(1), i64)
+max(score(i))
+max(score(i, i))
+max(true ? 0.5 : half)
+max(true ? 1 : i64)
+max(true ? add : list)
+max(true ? foo : add)
+max(true ? foo : f32)
+max(true ? i : ok)
+max(true ? i64 : "bar")
+min(-(0.5 + i))
+min(-(f32 + i64))
+min(-0.5)
+min(-0.5, i)
+min(-1)
+min(-1, i)
+min(-1, i64)
+min(-f32)
+min(-f32, i64)
+min(-f64)
+min(-f64, i32)
+min(-i)
+min(-i32)
+min(-i64)
+min(0.5 * 0.5)
+min(0.5 * 1)
+min(0.5 * f64)
+min(0.5 * i32)
+min(0.5 ** 0.5)
+min(0.5 ** f64)
+min(0.5 ** i64)
+min(0.5 + 1)
+min(0.5 + f32)
+min(0.5 + f64)
+min(0.5 + i)
+min(0.5 - 0.5)
+min(0.5 - 1)
+min(0.5 - f64)
+min(0.5 - i)
+min(0.5 / 0.5)
+min(0.5 / f64)
+min(0.5 ^ 1)
+min(0.5 ^ f32)
+min(0.5 ^ i)
+min(0.5) != i32
+min(0.5) * 0.5 ** i64
+min(0.5) ** i
+min(0.5) + i
+min(0.5) + i32
+min(0.5) + i64
+min(0.5) < f32
+min(0.5) <= i ? f32 : 1
+min(0.5) <= i64
+min(0.5) == i - 0.5
+min(0.5) > i64
+min(0.5) >= i
+min(0.5, 0.5) == f32
+min(0.5, 1) >= i64
+min(0.5, i) == i64
+min(0.5, i32, f32) + f32
+min(1 % i32)
+min(1 % i64)
+min(1 * 0.5)
+min(1 * 1)
+min(1 * i)
+min(1 * i32)
+min(1 * i64)
+min(1 ** 0.5)
+min(1 ** f32)
+min(1 ** f64)
+min(1 ** i32)
+min(1 + 0.5)
+min(1 + 1)
+min(1 + f32)
+min(1 + i32)
+min(1 + i64)
+min(1 - 1)
+min(1 - f64)
+min(1 - i)
+min(1 - i32)
+min(1 / 1)
+min(1 / i)
+min(1 / i32)
+min(1 / i32, f64)
+min(1 / i64)
+min(1 ^ 1)
+min(1 ^ f32)
+min(1 ^ f64)
+min(1) != 1 ? list : f64
+min(1) != i
+min(1) % i64
+min(1) * -0.5
+min(1) * 1 ** 1
+min(1) - i64 ^ 0.5
+min(1) .. i
+min(1) .. i64
+min(1) / f64
+min(1) / i
+min(1) < i
+min(1) == f64
+min(1) == i32
+min(1) >= i64
+min(1) ^ f32
+min(abs(0.5))
+min(abs(1))
+min(abs(f32))
+min(abs(f64))
+min(abs(i * 1))
+min(abs(i))
+min(abs(i32))
+min(abs(i64))
+min(abs(i64), f64)
+min(add(1, i))
+min(add(i, i))
+min(array[1])
+min(array[i])
+min(count(array, false))
+min(count(array, ok))
+min(count(array, true))
+min(count(list, ok))
+min(f32 * 1)
+min(f32 * f32)
+min(f32 * i32)
+min(f32 ** i32)
+min(f32 ** i64)
+min(f32 ** i64, f32)
+min(f32 + f64)
+min(f32 + i)
+min(f32 + i32)
+min(f32 + i64)
+min(f32 - f32)
+min(f32 - i)
+min(f32 - i32)
+min(f32 - i64)
+min(f32 / 0.5)
+min(f32 / f64)
+min(f32 / i)
+min(f32 / i32)
+min(f32 / i64)
+min(f32 ^ 1)
+min(f32 ^ f32)
+min(f32 ^ i)
+min(f32 ^ i32)
+min(f32)
+min(f32) * f32
+min(f32) * f64
+min(f32) + i
+min(f32) + i32
+min(f32) + i64
+min(f32) - f32
+min(f32) < i64
+min(f32) == i
+min(f32) == i32 * i32
+min(f32) == i64
+min(f32) > i32
+min(f32) ^ f64
+min(f32, 0.5 ^ 0.5)
+min(f32, 0.5) <= i64
+min(f32, f32)
+min(f32, f64)
+min(f32, f64) >= i
+min(f32, get(array, i64))
+min(f32, i)
+min(f32, i32)
+min(f32, i64)
+min(f32, len(array))
+min(f32, len(list))
+min(f64 * 0.5)
+min(f64 * 1)
+min(f64 * f64)
+min(f64 * i)
+min(f64 * i32)
+min(f64 ** 1)
+min(f64 ** f64)
+min(f64 ** i)
+min(f64 ** i32)
+min(f64 ** i64)
+min(f64 + 1)
+min(f64 + i)
+min(f64 + i64)
+min(f64 - 0.5)
+min(f64 - i)
+min(f64 - i32)
+min(f64 - i64)
+min(f64 / 1)
+min(f64 / f32)
+min(f64 / i)
+min(f64 / i32)
+min(f64 / i64)
+min(f64 ^ 0.5)
+min(f64 ^ f64)
+min(f64 ^ i32)
+min(f64)
+min(f64) + f64
+min(f64) + i32
+min(f64) + i64
+min(f64) / f32
+min(f64) ^ 1 ^ 1
+min(f64) ^ i32
+min(f64) ^ i64
+min(f64, 0.5 ** 1)
+min(f64, 0.5, i) <= f64
+min(f64, 1 ** i)
+min(f64, 1) < i64
+min(f64, f32)
+min(f64, f64)
+min(f64, f64, i64)
+min(f64, i)
+min(f64, i32)
+min(f64, i64)
+min(false ? 1 : add)
+min(false ? f64 : false)
+min(false ? f64 : score)
+min(false ? foo : 1)
+min(false ? greet : i)
+min(false ? i32 : "foo")
+min(false ? i32 : i64)
+min(false ? true : 0.5)
+min(find(array, false))
+min(find(array, ok))
+min(findIndex(list, ok))
+min(findLast(array, true))
+min(findLastIndex(array, false))
+min(findLastIndex(array, ok))
+min(findLastIndex(array, true))
+min(findLastIndex(list, ok))
+min(first(array))
+min(float(0.5))
+min(float(1))
+min(float(f32))
+min(float(f64))
+min(float(i))
+min(float(i32))
+min(float(i64))
+min(get(array, i))
+min(get(array, i64))
+min(half(0.5 ^ i32))
+min(half(0.5))
+min(half(0.5), f32)
+min(half(f64))
+min(i % 1)
+min(i % i32)
+min(i % i64)
+min(i * 0.5)
+min(i * 1)
+min(i * i)
+min(i * i64)
+min(i ** 0.5)
+min(i ** f32)
+min(i ** f64)
+min(i ** i)
+min(i ** i64)
+min(i + 0.5)
+min(i + f32)
+min(i + f64)
+min(i + i)
+min(i - 0.5)
+min(i - 1)
+min(i - i)
+min(i / 0.5)
+min(i / i64)
+min(i / i64, i)
+min(i ^ 0.5)
+min(i ^ i, i32)
+min(i)
+min(i) != i32
+min(i) % i
+min(i) * f32
+min(i) ** i
+min(i) .. i
+min(i) / f64
+min(i) < f32
+min(i) <= i64
+min(i, f32)
+min(i, f64)
+min(i, i)
+min(i, i32 - i)
+min(i, i32)
+min(i, i64 * f32)
+min(i, i64)
+min(i32 % i)
+min(i32 * 1)
+min(i32 * f64)
+min(i32 * i32)
+min(i32 ** 1 ^ i64)
+min(i32 ** f32)
+min(i32 ** i)
+min(i32 ** i64)
+min(i32 + 0.5)
+min(i32 + 1)
+min(i32 + f32)
+min(i32 - 0.5)
+min(i32 - 1)
+min(i32 - i32)
+min(i32 / 1)
+min(i32 / i)
+min(i32 / i64)
+min(i32 / i64, score(1))
+min(i32 ^ 1)
+min(i32 ^ f64)
+min(i32 ^ i)
+min(i32 ^ i64)
+min(i32)
+min(i32) != i64
+min(i32) + f32
+min(i32) - i64
+min(i32) / f32
+min(i32) < i32
+min(i32) == f32
+min(i32) == i32
+min(i32) >= i32
+min(i32) ^ f64
+min(i32, 0.5) .. i32
+min(i32, f32)
+min(i32, f64)
+min(i32, i)
+min(i32, i32)
+min(i32, i32, i)
+min(i32, i64)
+min(i32, i64) .. i
+min(i32, i64) <= f64
+min(i32, min(i))
+min(i64 % i32)
+min(i64 * 1, f32)
+min(i64 * f64)
+min(i64 * i32)
+min(i64 ** 0.5)
+min(i64 ** 1)
+min(i64 ** i)
+min(i64 + 0.5)
+min(i64 + 1)
+min(i64 + f32)
+min(i64 + i)
+min(i64 + i32)
+min(i64 - 0.5)
+min(i64 - f32)
+min(i64 - f64)
+min(i64 - i)
+min(i64 - i64)
+min(i64 / 0.5)
+min(i64 / f64)
+min(i64 / i)
+min(i64 / i64)
+min(i64 ^ 1)
+min(i64 ^ i32)
+min(i64 ^ i64)
+min(i64)
+min(i64) != i64
+min(i64) % i32
+min(i64) ** -1
+min(i64) ** -f64
+min(i64) ** i
+min(i64) + i32
+min(i64) .. i
+min(i64) .. i64
+min(i64) <= f32
+min(i64) == i
+min(i64) ^ f32
+min(i64) ^ f64
+min(i64) in array
+min(i64, 1 ** 0.5)
+min(i64, 1) <= f64
+min(i64, f32)
+min(i64, f64)
+min(i64, f64) != f64
+min(i64, f64) * i32
+min(i64, f64, i32)
+min(i64, i)
+min(i64, i32)
+min(i64, i32, i)
+min(i64, i64)
+min(i64, i64, f32)
+min(int(0.5))
+min(int(1))
+min(int(f32))
+min(int(f64))
+min(int(i))
+min(int(i64))
+min(last(array))
+min(len("bar"))
+min(len("foo"))
+min(len(array))
+min(len(list))
+min(len(list), f64)
+min(max(0.5))
+min(max(1))
+min(max(1, 0.5))
+min(max(1, f32))
+min(max(1, i32))
+min(max(f32))
+min(max(f64))
+min(max(i), i64)
+min(max(i32))
+min(min(0.5))
+min(min(0.5, 1))
+min(min(1))
+min(min(f32))
+min(min(f32, i, i32))
+min(min(f64))
+min(min(i))
+min(min(i32))
+min(min(i64))
+min(ok ? add : 0.5)
+min(ok ? f32 : "foo")
+min(ok ? f64 : true)
+min(ok ? foo : 1)
+min(ok ? true : 1)
+min(score(1))
+min(score(i))
+min(true ? 0.5 : ok)
+min(true ? 1 : greet)
+min(true ? add : greet)
+min(true ? f32 : i)
+min(true ? foo : 0.5)
+min(true ? foo : half)
+min(true ? i : 1)
+min(true ? i32 : score)
+nil != "bar" ? i64 : 0.5 - i
+nil != 0.5 && 0.5 != f32
+nil != 1 && ok
+nil != 1 or any(list, false)
+nil != 1 || ok
+nil != f32 || ok
+nil != f64 && ok
+nil != f64 or ok
+nil != f64 || array != array
+nil != false and not true
+nil != false and ok
+nil != false || ok
+nil != foo == ok
+nil != foo || ok
+nil != foo.Bar
+nil != foo.Qux
+nil != foo.String
+nil != foo?.Bar
+nil != foo?.Qux
+nil != foo?.String
+nil != greet ? half : half
+nil != greet or f32 < i
+nil != i32 or f32 >= 1
+nil != i64 or i >= 1
+nil != ok == not true
+nil != true == ok
+nil == 1 != nil ? "bar" : i32
+nil == add == ("bar" not endsWith "foo")
+nil == f32 && i64 < f64
+nil == foo.Bar
+nil == foo.Qux
+nil == foo.String
+nil == foo.String()
+nil == foo?.Bar
+nil == foo?.Qux
+nil == foo?.String
+nil == foo?.String()
+nil == i64 ? add : add
+nil == nil == ok
+nil == true ? i64 ^ f32 : foo
+nil == true || ok
+nil in array || ok
+nil in array[i32:i64]
+nil in list and ok
+none(array, !ok)
+none(array, !true)
+none(array, "bar" == "bar")
+none(array, # != #)
+none(array, # != 1)
+none(array, # != f32)
+none(array, # != f64)
+none(array, # != i32)
+none(array, # != i64)
+none(array, # < #)
+none(array, # < 0.5)
+none(array, # < 1)
+none(array, # < f32)
+none(array, # < i)
+none(array, # < i32)
+none(array, # < i64)
+none(array, # <= #)
+none(array, # <= 0.5)
+none(array, # <= 1)
+none(array, # <= f32)
+none(array, # <= i)
+none(array, # <= i32)
+none(array, # == #)
+none(array, # == 0.5)
+none(array, # == 1)
+none(array, # == i)
+none(array, # == nil)
+none(array, # > #)
+none(array, # > 0.5)
+none(array, # > f32)
+none(array, # > f64)
+none(array, # > i)
+none(array, # > i32)
+none(array, # >= #)
+none(array, # >= 0.5)
+none(array, # >= 1)
+none(array, # >= f32)
+none(array, # >= f64)
+none(array, # in array)
+none(array, # not in array)
+none(array, 0.5 != #)
+none(array, 0.5 != f32)
+none(array, 0.5 < #)
+none(array, 0.5 <= 0.5)
+none(array, 0.5 <= 1)
+none(array, 0.5 <= i)
+none(array, 0.5 > #)
+none(array, 0.5 >= #)
+none(array, 1 != #)
+none(array, 1 < #)
+none(array, 1 < 0.5)
+none(array, 1 < i)
+none(array, 1 < i64)
+none(array, 1 <= 1)
+none(array, 1 == #)
+none(array, 1 == f64)
+none(array, 1 > #)
+none(array, 1 > f64)
+none(array, 1 >= i)
+none(array, add != greet)
+none(array, all(array, true))
+none(array, div == greet)
+none(array, f32 != #)
+none(array, f32 != nil)
+none(array, f32 <= #)
+none(array, f32 >= #)
+none(array, f64 != #)
+none(array, f64 == #)
+none(array, f64 >= 0.5)
+none(array, half != nil)
+none(array, i < #)
+none(array, i < 1)
+none(array, i <= #)
+none(array, i == i64)
+none(array, i not in array)
+none(array, i32 != #)
+none(array, i32 != f64)
+none(array, i32 != nil)
+none(array, i32 < #)
+none(array, i32 > #)
+none(array, i32 >= #)
+none(array, i64 < #)
+none(array, i64 < f64)
+none(array, i64 >= #)
+none(array, nil != 0.5)
+none(array, nil != div)
+none(array, nil == #)
+none(array, nil == 1)
+none(array, nil == div)
+none(array, none(array, !true))
+none(array, not ok)
+none(array, ok == nil)
+none(array, ok)
+none(array, ok) != ok
+none(array, ok) ? f32 : !ok
+none(array, score == nil)
+none(array, score == score)
+none(array, true ? ok : f64)
+none(array, true or true)
+none(i64 .. i32, # > #)
+none(list, "bar" not in #)
+none(list, # != #)
+none(list, # != foo)
+none(list, # != nil)
+none(list, # == #)
+none(list, # == nil)
+none(list, 0.5 != i)
+none(list, 0.5 <= 1)
+none(list, 0.5 <= f64)
+none(list, 0.5 == nil)
+none(list, 1 < i32)
+none(list, 1 == f32)
+none(list, any(list, ok))
+none(list, array == nil)
+none(list, f32 > i)
+none(list, f64 == i32)
+none(list, false && false)
+none(list, false) or f64 >= i64
+none(list, foo != #)
+none(list, foo == #)
+none(list, greet != add)
+none(list, greet != half)
+none(list, i <= i64)
+none(list, i >= 1)
+none(list, i >= f64)
+none(list, i not in array)
+none(list, i32 != nil)
+none(list, i32 == f64)
+none(list, i32 == nil)
+none(list, i32 >= 1)
+none(list, i32 >= f32)
+none(list, i64 < f64)
+none(list, i64 <= f64)
+none(list, i64 > f64)
+none(list, i64 > i64)
+none(list, nil != array)
+none(list, nil != true)
+none(list, nil == foo)
+none(list, not false)
+none(list, not ok)
+none(list, ok)
+none(list, one(array, false))
+none(list, score != nil)
+none(list, score == add)
+none(list, true && ok)
+none(list, true == ok)
+none(list, true) ? div : array
+none(map(array, "bar"), # not endsWith #)
+none(map(array, "foo"), # not endsWith #)
+none(map(array, #), ok)
+none(map(array, 0.5), # == #)
+none(map(array, 1), # >= #)
+none(map(array, half), # == #)
+none(map(array, ok), #)
+none(map(list, "bar"), # not startsWith #)
+none(map(list, "bar"), # startsWith #)
+none(map(list, #), # != #)
+none(map(list, #), ok)
+none(map(list, i32), f64 > #)
+none(map(list, true), # != #)
+none(ok ? "bar" : ok, # >= f64)
+not !("foo" not matches "foo")
+not !(0.5 > 1)
+not !(f64 >= i32)
+not !(false && ok)
+not !(i >= i32)
+not !false
+not !ok
+not !true
+not ("bar" != "foo")
+not ("bar" != nil)
+not ("bar" < "foo")
+not ("bar" <= "bar")
+not ("bar" <= "foo")
+not ("bar" == "bar")
+not ("bar" == "foo")
+not ("bar" == nil)
+not ("bar" > "bar")
+not ("bar" > "foo")
+not ("bar" >= "bar")
+not ("bar" >= "foo")
+not ("bar" contains "bar")
+not ("bar" contains "foo")
+not ("bar" endsWith "bar")
+not ("bar" endsWith "foo")
+not ("bar" in foo)
+not ("bar" matches "bar")
+not ("bar" not contains "bar")
+not ("bar" not contains "foo")
+not ("bar" not endsWith "bar")
+not ("bar" not endsWith "foo")
+not ("bar" not in foo)
+not ("bar" not matches "bar")
+not ("bar" not matches "foo")
+not ("bar" startsWith "bar")
+not ("bar" startsWith "foo")
+not ("foo" != "bar")
+not ("foo" != "foo")
+not ("foo" != nil)
+not ("foo" < "bar")
+not ("foo" < "foo")
+not ("foo" <= "bar")
+not ("foo" <= "foo")
+not ("foo" == "bar")
+not ("foo" == "foo")
+not ("foo" == nil)
+not ("foo" > "bar")
+not ("foo" > "foo")
+not ("foo" >= "foo")
+not ("foo" contains "foo")
+not ("foo" endsWith "bar")
+not ("foo" endsWith "foo")
+not ("foo" in foo)
+not ("foo" matches "bar")
+not ("foo" matches "foo")
+not ("foo" not contains "bar")
+not ("foo" not contains "foo")
+not ("foo" not endsWith "bar")
+not ("foo" not endsWith "foo")
+not ("foo" not in foo)
+not ("foo" not matches "bar")
+not ("foo" not matches "foo")
+not ("foo" not startsWith "bar")
+not ("foo" not startsWith "foo")
+not ("foo" startsWith "foo")
+not (0.5 != 0.5)
+not (0.5 != 1)
+not (0.5 != f64)
+not (0.5 != i)
+not (0.5 != i32)
+not (0.5 != i64)
+not (0.5 != nil)
+not (0.5 < 0.5)
+not (0.5 < 1)
+not (0.5 < f32)
+not (0.5 < f64)
+not (0.5 < i)
+not (0.5 < i32)
+not (0.5 < i64)
+not (0.5 <= 0.5)
+not (0.5 <= 1)
+not (0.5 <= f32)
+not (0.5 <= f64)
+not (0.5 <= i)
+not (0.5 <= i32)
+not (0.5 <= i64)
+not (0.5 == 0.5)
+not (0.5 == 1)
+not (0.5 == f32)
+not (0.5 == f64)
+not (0.5 == i)
+not (0.5 == i32)
+not (0.5 == i64)
+not (0.5 == nil)
+not (0.5 > 0.5)
+not (0.5 > 1)
+not (0.5 > f32)
+not (0.5 > f64)
+not (0.5 > i)
+not (0.5 > i32)
+not (0.5 > i64)
+not (0.5 >= 0.5)
+not (0.5 >= 1)
+not (0.5 >= f32)
+not (0.5 >= f64)
+not (0.5 >= i)
+not (0.5 >= i32)
+not (0.5 >= i64)
+not (1 != 0.5)
+not (1 != 1)
+not (1 != f32)
+not (1 != f64)
+not (1 != i)
+not (1 != i32)
+not (1 != i64)
+not (1 != nil)
+not (1 + i > 0.5 ** i32)
+not (1 < 0.5)
+not (1 < 1)
+not (1 < f32)
+not (1 < f64)
+not (1 < i)
+not (1 < i32)
+not (1 < i64)
+not (1 <= 0.5)
+not (1 <= 1)
+not (1 <= f32)
+not (1 <= f64)
+not (1 <= i)
+not (1 <= i32)
+not (1 <= i64)
+not (1 == 0.5)
+not (1 == 1)
+not (1 == f32)
+not (1 == f64)
+not (1 == i)
+not (1 == i64)
+not (1 == nil)
+not (1 > 0.5)
+not (1 > 1)
+not (1 > f32)
+not (1 > f64)
+not (1 > i)
+not (1 > i32)
+not (1 > i64)
+not (1 >= 0.5)
+not (1 >= 1)
+not (1 >= f32)
+not (1 >= f64)
+not (1 >= i)
+not (1 >= i32)
+not (1 >= i64)
+not (1 ^ f32 != i64)
+not (1 in array)
+not (1 not in array)
+not (abs(i) <= i)
+not (add != add)
+not (add != div)
+not (add != greet)
+not (add != half)
+not (add != nil)
+not (add != score)
+not (add == add)
+not (add == div)
+not (add == greet)
+not (add == half)
+not (add == nil)
+not (add == score)
+not (array != array)
+not (array != list)
+not (array != nil)
+not (array == array)
+not (array == list)
+not (array == nil)
+not (div != add)
+not (div != div)
+not (div != greet)
+not (div != half)
+not (div != nil)
+not (div != score)
+not (div == add)
+not (div == div)
+not (div == greet)
+not (div == half)
+not (div == nil)
+not (div == score)
+not (f32 != 0.5)
+not (f32 != 1)
+not (f32 != f32)
+not (f32 != f64)
+not (f32 != i)
+not (f32 != i32)
+not (f32 != i64)
+not (f32 != nil)
+not (f32 < 0.5)
+not (f32 < 1)
+not (f32 < abs(0.5))
+not (f32 < f32)
+not (f32 < f64)
+not (f32 < i)
+not (f32 < i32)
+not (f32 < i64)
+not (f32 <= 0.5)
+not (f32 <= 1)
+not (f32 <= f32)
+not (f32 <= f64)
+not (f32 <= i)
+not (f32 <= i32)
+not (f32 <= i64)
+not (f32 == 0.5)
+not (f32 == 1)
+not (f32 == f32)
+not (f32 == f64)
+not (f32 == i32)
+not (f32 == i64)
+not (f32 == nil)
+not (f32 > 0.5)
+not (f32 > 1)
+not (f32 > f32)
+not (f32 > f64)
+not (f32 > i32)
+not (f32 >= 0.5)
+not (f32 >= 1)
+not (f32 >= f32)
+not (f32 >= f64)
+not (f32 >= i)
+not (f32 >= i64)
+not (f64 != 0.5)
+not (f64 != 1 * 0.5)
+not (f64 != 1)
+not (f64 != f32)
+not (f64 != f64)
+not (f64 != i)
+not (f64 != i32)
+not (f64 != i64)
+not (f64 != nil)
+not (f64 < 0.5)
+not (f64 < 1)
+not (f64 < f32)
+not (f64 < f64)
+not (f64 < i)
+not (f64 < i32)
+not (f64 < i64)
+not (f64 <= 0.5)
+not (f64 <= 1)
+not (f64 <= f32)
+not (f64 <= f64)
+not (f64 <= i32)
+not (f64 <= i64)
+not (f64 == 0.5)
+not (f64 == 1)
+not (f64 == f32)
+not (f64 == f64)
+not (f64 == i)
+not (f64 == i32)
+not (f64 == i64 - f32)
+not (f64 == nil)
+not (f64 > 0.5)
+not (f64 > 1)
+not (f64 > f32)
+not (f64 > f64)
+not (f64 > i)
+not (f64 > i64)
+not (f64 >= 0.5)
+not (f64 >= 1)
+not (f64 >= f32)
+not (f64 >= f64)
+not (f64 >= i)
+not (f64 >= i32)
+not (f64 >= i64)
+not (false != false)
+not (false != nil)
+not (false != ok)
+not (false != true)
+not (false && ok)
+not (false && true)
+not (false == false)
+not (false == nil)
+not (false == true)
+not (false and false)
+not (false and true)
+not (false or false)
+not (false or ok)
+not (false or true)
+not (false || false)
+not (false || ok)
+not (false || true)
+not (foo != foo)
+not (foo != nil)
+not (foo == foo)
+not (foo == nil)
+not (foo in list)
+not (foo not in list)
+not (greet != add)
+not (greet != div)
+not (greet != greet)
+not (greet != half)
+not (greet != nil)
+not (greet != score)
+not (greet == add)
+not (greet == div)
+not (greet == greet)
+not (greet == half)
+not (greet == nil)
+not (greet == score)
+not (half != add)
+not (half != div)
+not (half != greet)
+not (half != nil)
+not (half != score)
+not (half == add)
+not (half == div)
+not (half == greet)
+not (half == half)
+not (half == nil)
+not (half == score)
+not (i != 0.5)
+not (i != 1)
+not (i != f32)
+not (i != f64)
+not (i != i)
+not (i != i32)
+not (i != i64)
+not (i != nil)
+not (i < 0.5)
+not (i < 1)
+not (i < f32)
+not (i < f64)
+not (i < i)
+not (i < i32)
+not (i < i64)
+not (i <= 0.5)
+not (i <= 1)
+not (i <= f32)
+not (i <= f64)
+not (i <= i32)
+not (i <= i64)
+not (i == 0.5)
+not (i == 1)
+not (i == f32)
+not (i == f64)
+not (i == i)
+not (i == i32)
+not (i == nil)
+not (i > 0.5)
+not (i > 1)
+not (i > f32)
+not (i > f64)
+not (i > i)
+not (i > i64)
+not (i >= 0.5)
+not (i >= 1)
+not (i >= div(1, 1))
+not (i >= f32)
+not (i >= f64)
+not (i >= i)
+not (i >= i64)
+not (i in array)
+not (i not in array)
+not (i32 != 0.5)
+not (i32 != 1)
+not (i32 != f32)
+not (i32 != f64)
+not (i32 != i)
+not (i32 != i64)
+not (i32 != nil)
+not (i32 < 0.5)
+not (i32 < 1)
+not (i32 < f64)
+not (i32 < i)
+not (i32 < i32)
+not (i32 < i64)
+not (i32 <= 0.5)
+not (i32 <= 1)
+not (i32 <= f32)
+not (i32 <= f64)
+not (i32 <= i)
+not (i32 <= i32)
+not (i32 <= i64)
+not (i32 == 0.5)
+not (i32 == 1)
+not (i32 == f32)
+not (i32 == f64)
+not (i32 == i)
+not (i32 == i32)
+not (i32 == i64)
+not (i32 == nil)
+not (i32 > 0.5)
+not (i32 > 1)
+not (i32 > f32)
+not (i32 > f64)
+not (i32 > i)
+not (i32 > i32)
+not (i32 > i64)
+not (i32 >= 0.5)
+not (i32 >= 1)
+not (i32 >= f32)
+not (i32 >= f64)
+not (i32 >= i)
+not (i32 >= i32)
+not (i32 >= i64)
+not (i32 in array)
+not (i64 != 0.5)
+not (i64 != 1)
+not (i64 != f32)
+not (i64 != f64)
+not (i64 != i)
+not (i64 != i32)
+not (i64 != i64)
+not (i64 != nil)
+not (i64 < 0.5)
+not (i64 < 1)
+not (i64 < f32)
+not (i64 < f64)
+not (i64 < i)
+not (i64 < i32)
+not (i64 < i64)
+not (i64 < int(f64))
+not (i64 <= 0.5)
+not (i64 <= 1)
+not (i64 <= f32)
+not (i64 <= f64)
+not (i64 <= i)
+not (i64 <= i64)
+not (i64 == 0.5)
+not (i64 == 1)
+not (i64 == f32)
+not (i64 == f64)
+not (i64 == i)
+not (i64 == i32)
+not (i64 == i64)
+not (i64 == nil)
+not (i64 > 0.5)
+not (i64 > 1)
+not (i64 > f64)
+not (i64 > i)
+not (i64 > i32)
+not (i64 > i64)
+not (i64 >= 0.5)
+not (i64 >= 1)
+not (i64 >= f32)
+not (i64 >= f64)
+not (i64 >= i)
+not (i64 >= i32)
+not (i64 >= max(i))
+not (i64 in array)
+not (i64 not in array)
+not (list != array)
+not (list != list)
+not (list != nil)
+not (list == array)
+not (list == list)
+not (list == nil)
+not (nil != "bar")
+not (nil != "foo")
+not (nil != 0.5)
+not (nil != 1)
+not (nil != add)
+not (nil != array)
+not (nil != div)
+not (nil != f32)
+not (nil != f64)
+not (nil != false)
+not (nil != foo)
+not (nil != greet)
+not (nil != half)
+not (nil != i)
+not (nil != i32)
+not (nil != i64)
+not (nil != list)
+not (nil != nil)
+not (nil != ok)
+not (nil != score)
+not (nil != true)
+not (nil == "bar")
+not (nil == "foo")
+not (nil == 0.5)
+not (nil == 1)
+not (nil == add)
+not (nil == array)
+not (nil == div)
+not (nil == f32)
+not (nil == f64)
+not (nil == false)
+not (nil == foo)
+not (nil == greet)
+not (nil == half)
+not (nil == i)
+not (nil == i32)
+not (nil == i64)
+not (nil == list)
+not (nil == nil)
+not (nil == ok)
+not (nil == score)
+not (nil == true)
+not (nil in array)
+not (nil in list)
+not (nil not in array)
+not (nil not in list)
+not (ok != false)
+not (ok != nil)
+not (ok != ok)
+not (ok != true)
+not (ok && false)
+not (ok && ok)
+not (ok && true)
+not (ok == false)
+not (ok == nil)
+not (ok == ok)
+not (ok == true)
+not (ok and false)
+not (ok and ok)
+not (ok and true)
+not (ok or false)
+not (ok or ok)
+not (ok or true)
+not (ok || ok)
+not (ok || true)
+not (score != add)
+not (score != div)
+not (score != greet)
+not (score != half)
+not (score != nil)
+not (score != score)
+not (score == add)
+not (score == div)
+not (score == greet)
+not (score == half)
+not (score == nil)
+not (score == score)
+not (true != false)
+not (true != nil)
+not (true != ok)
+not (true != true)
+not (true && ok)
+not (true && true)
+not (true == nil)
+not (true == ok)
+not (true == true)
+not (true and false)
+not (true and ok)
+not (true and true)
+not (true or false)
+not (true or ok)
+not (true || false)
+not all(array, ok)
+not all(array, true)
+not all(list, false)
+not all(list, ok)
+not all(list, true)
+not any(array, false)
+not any(array, ok)
+not any(array, true)
+not any(list, # != #)
+not any(list, false)
+not any(list, ok)
+not any(list, true)
+not false && ok
+not false && ok ? list : array
+not false ? "bar" : 0.5
+not false ? "bar" : foo
+not false ? "foo" : 0.5
+not false ? 0.5 : greet
+not false ? 1 : div
+not false ? 1 : i32
+not false ? add : i
+not false ? array : "foo"
+not false ? array : array
+not false ? array : greet
+not false ? array : ok
+not false ? div : greet
+not false ? foo : 1
+not false ? foo : array
+not false ? greet : ok
+not false ? half : 0.5
+not false ? half : i32
+not false ? i : i64
+not false ? i : score
+not false ? i32 : 0.5
+not false ? i32 : add
+not false ? i32 : f32
+not false ? i32 : true
+not false ? i64 : list
+not false ? list : i32
+not false ? nil : greet
+not false ? nil : i32
+not false ? nil : nil
+not false ? ok : "bar"
+not false ? ok : 1
+not false ? ok : list
+not false ? score : "foo"
+not false ? score : array
+not false ? score : score
+not false ? score : true
+not false ? true : 0.5
+not false ? true : 1
+not false ? true : nil
+not false or "foo" > "bar"
+not none(array, # == #)
+not none(array, false)
+not none(array, ok)
+not none(array, true)
+not none(list, false)
+not none(list, ok)
+not none(list, true)
+not not ("bar" >= "foo")
+not not (1 < i)
+not not (add == nil)
+not not (half == nil)
+not not false
+not not ok
+not not true
+not ok
+not ok && ok
+not ok == ok
+not ok ? "bar" : 1
+not ok ? "bar" : f32
+not ok ? 0.5 + f64 : half
+not ok ? 0.5 : "foo"
+not ok ? 0.5 : 0.5
+not ok ? 0.5 : div
+not ok ? 0.5 : f32
+not ok ? 0.5 : greet
+not ok ? 1 : 1
+not ok ? add : 0.5
+not ok ? array : f64
+not ok ? array : true
+not ok ? div : 1
+not ok ? div : add
+not ok ? f32 : div
+not ok ? f64 : 1
+not ok ? f64 : half
+not ok ? false : f32
+not ok ? false : i
+not ok ? false : true
+not ok ? foo : add
+not ok ? foo : false
+not ok ? foo : i64
+not ok ? greet : add
+not ok ? half : true
+not ok ? i : div
+not ok ? i : true
+not ok ? i32 : nil
+not ok ? i64 : add
+not ok ? nil : 0.5
+not ok ? nil : div
+not ok ? nil : foo
+not ok ? nil : half
+not ok ? nil : i
+not ok ? score : div
+not ok ? score : i
+not ok ? score : true
+not ok ? true : f32
+not ok ? true : false
+not ok ? true : score
+not ok and not ok
+not ok or ok
+not ok or one(array, true)
+not ok || ok
+not ok || true ? 0.5 : 1
+not one(array, # > f32)
+not one(array, false)
+not one(array, ok)
+not one(array, true)
+not one(list, false)
+not one(list, ok)
+not one(list, true)
+not true && i32 <= i32
+not true ? "foo" : i
+not true ? 1 : i64
+not true ? add : add
+not true ? add : foo
+not true ? array : 1
+not true ? array : add
+not true ? array : array
+not true ? array : i32
+not true ? array : i64
+not true ? div : nil
+not true ? f64 : i64
+not true ? foo : foo
+not true ? greet : "bar"
+not true ? greet : add
+not true ? greet : foo
+not true ? greet : i32
+not true ? half : half
+not true ? i : 1
+not true ? i : i
+not true ? i32 : 0.5
+not true ? i64 : 1
+not true ? list : "bar"
+not true ? list : 0.5
+not true ? list : 1
+not true ? list : array
+not true ? list : type(add)
+not true ? nil : list
+not true ? score : 1
+not true ? score : list
+not true ? score : true
+not true || ok
+ok
+ok != !ok
+ok != !true
+ok != false != ok
+ok != false ? 1 : i
+ok != nil == nil
+ok != none(list, ok)
+ok != not !ok
+ok != not ok
+ok != ok
+ok != ok || ok
+ok && !ok ? f32 : 0.5
+ok && !true
+ok && "bar" >= "bar"
+ok && "foo" <= "bar"
+ok && 0.5 != nil
+ok && 0.5 == 0.5
+ok && 0.5 >= f32
+ok && 1 != f64
+ok && 1 != i32
+ok && 1 < 1
+ok && 1 <= 0.5
+ok && 1 == f64
+ok && 1 >= f32
+ok && div == half
+ok && f32 != 0.5
+ok && f32 < 0.5
+ok && f32 == f32
+ok && f32 == i64
+ok && f64 < 1
+ok && f64 < i32
+ok && f64 == i32
+ok && f64 >= i32
+ok && false == false
+ok && i != i
+ok && i32 != 0.5
+ok && i32 < f32
+ok && i32 <= i64
+ok && i32 == 1
+ok && i32 >= 1
+ok && i64 < i32
+ok && i64 <= i32
+ok && i64 > 1
+ok && list != array
+ok && nil != f64
+ok && nil == add
+ok && nil == i32
+ok && nil == true
+ok && ok
+ok && score != add
+ok && true != ok
+ok && true == nil
+ok == !false
+ok == !ok
+ok == (false or true)
+ok == (ok and ok)
+ok == any(list, ok)
+ok == false == nil
+ok == nil ? false : add
+ok == nil ? score : array
+ok == not false
+ok == not true
+ok == ok
+ok ? "bar" : i == f32
+ok ? "bar" : i32 < i32
+ok ? "foo" : foo.String
+ok ? -0.5 : foo
+ok ? -f32 : i64 + 1
+ok ? -f64 : score
+ok ? -i64 : ok
+ok ? 0.5 * array[i64] : greet
+ok ? 0.5 : f64 < i64
+ok ? 0.5 : half != add
+ok ? 0.5 : i .. i
+ok ? 0.5 < i32 : score
+ok ? 0.5 == 0.5 : half
+ok ? 1 : 1 + i64 + i32
+ok ? 1 : foo.Bar
+ok ? 1 : foo.String
+ok ? add : add
+ok ? add : array
+ok ? add : div
+ok ? add : f32
+ok ? add : greet
+ok ? add : i
+ok ? add : i32
+ok ? add : i64
+ok ? add : list
+ok ? add : ok
+ok ? array : div
+ok ? array : f64
+ok ? array : float(i32)
+ok ? array : foo
+ok ? array : foo?.Bar
+ok ? array : i32
+ok ? array : i64
+ok ? array : list
+ok ? array : ok in map(array, ok)
+ok ? div : div
+ok ? div : f32
+ok ? div : f64
+ok ? div : foo?.String
+ok ? div : greet
+ok ? div : half
+ok ? div : half(1)
+ok ? div : i32
+ok ? div : i64
+ok ? div : list
+ok ? div : list == array
+ok ? div : score
+ok ? div : score(i)
+ok ? f32 : add
+ok ? f32 : array
+ok ? f32 : div
+ok ? f32 : f32
+ok ? f32 : f64
+ok ? f32 : foo
+ok ? f32 : foo?.Bar
+ok ? f32 : half
+ok ? f32 : i != i64
+ok ? f32 : i32
+ok ? f64 : array
+ok ? f64 : greet
+ok ? f64 : half
+ok ? f64 : i64
+ok ? f64 : score
+ok ? false : foo?.String()
+ok ? foo : add
+ok ? foo : foo
+ok ? foo : foo?.Bar
+ok ? foo : greet
+ok ? foo : i
+ok ? foo : i == i32
+ok ? foo : i32
+ok ? foo : i64
+ok ? foo : i64 ^ f32
+ok ? foo : list
+ok ? get(array, i32) : ok
+ok ? greet : add
+ok ? greet : div
+ok ? greet : f64 == i64
+ok ? greet : greet
+ok ? greet : half
+ok ? greet : i / i32
+ok ? greet : i32
+ok ? greet : i64 % i64
+ok ? greet : list
+ok ? greet : type(f64)
+ok ? half : 0.5 ^ i32
+ok ? half : add
+ok ? half : array
+ok ? half : div
+ok ? half : f32 == f64
+ok ? half : f64
+ok ? half : f64 <= i
+ok ? half : foo
+ok ? half : foo?.Bar
+ok ? half : greet
+ok ? half : half
+ok ? half : i
+ok ? half : i32
+ok ? half : list
+ok ? half : ok
+ok ? half : type(add)
+ok ? i : -i32
+ok ? i : 0.5 * i64
+ok ? i : 1 ** f64
+ok ? i : array
+ok ? i : div
+ok ? i : f32
+ok ? i : f64
+ok ? i : foo.Bar
+ok ? i : i
+ok ? i : i32
+ok ? i : ok
+ok ? i : score
+ok ? i32 + f32 : half
+ok ? i32 : -i32
+ok ? i32 : 1 not in array
+ok ? i32 : add
+ok ? i32 : array
+ok ? i32 : f32
+ok ? i32 : foo.Qux
+ok ? i32 : foo?.Qux
+ok ? i32 : half
+ok ? i32 : i
+ok ? i32 : i32
+ok ? i32 : list
+ok ? i32 : ok
+ok ? i32 >= f64 : f32
+ok ? i64 : array
+ok ? i64 : div
+ok ? i64 : f32
+ok ? i64 : f64
+ok ? i64 : half
+ok ? i64 : i32
+ok ? i64 : i64
+ok ? i64 : ok
+ok ? int(1) : div
+ok ? list : -1
+ok ? list : add
+ok ? list : array
+ok ? list : div
+ok ? list : f32
+ok ? list : i32
+ok ? list : i64
+ok ? list : list
+ok ? list : nil in array
+ok ? list : ok
+ok ? list : score
+ok ? lower("foo") : f32
+ok ? map(array, #) : duration("foo")
+ok ? map(list, #) : score
+ok ? min(f32) : score
+ok ? min(i) : score
+ok ? nil : foo?.Bar
+ok ? ok : -f32
+ok ? ok : 0.5 + i
+ok ? ok : array
+ok ? ok : f64
+ok ? ok : foo
+ok ? ok : greet
+ok ? ok : i64
+ok ? ok : list
+ok ? ok : score
+ok ? score : add
+ok ? score : array
+ok ? score : f32
+ok ? score : foo.String
+ok ? score : foo?.String
+ok ? score : greet
+ok ? score : half
+ok ? score : half("bar")
+ok ? score : i
+ok ? score : i32
+ok ? score : list
+ok ? score : nil != div
+ok ? score : ok
+ok ? score : score
+ok ? string(half) : array
+ok ? toJSON("foo") : i32
+ok ? true : foo?.Qux
+ok and !ok
+ok and "bar" not endsWith foo?.Bar
+ok and "foo" endsWith "foo"
+ok and 0.5 <= f32
+ok and 0.5 > f64
+ok and 0.5 >= f64
+ok and 1 != 1
+ok and 1 != nil
+ok and 1 < i64
+ok and 1 == 1
+ok and add == add
+ok and any(list, false)
+ok and f32 >= 1
+ok and f64 != i
+ok and f64 != nil
+ok and f64 > 1
+ok and false != true
+ok and i > i32
+ok and i >= f64
+ok and i >= i64
+ok and i32 != nil
+ok and i32 == 0.5
+ok and i32 >= f64
+ok and i64 != nil
+ok and i64 <= i
+ok and i64 > 1
+ok and list == list
+ok and nil != i
+ok and nil != true
+ok and none(list, ok)
+ok and not ok
+ok and not true
+ok and ok
+ok not in sort(array)
+ok or !false
+ok or !ok
+ok or !true
+ok or "bar" < "bar"
+ok or "foo" != nil
+ok or 0.5 != i32
+ok or 0.5 != i64
+ok or 0.5 <= 0.5
+ok or 0.5 == 1
+ok or 0.5 >= i
+ok or 1 != i32
+ok or 1 >= 0.5
+ok or f64 < f32
+ok or f64 < i64
+ok or fromJSON("bar")
+ok or greet != add
+ok or half == nil
+ok or half == score
+ok or i != 0.5
+ok or i < 1
+ok or i32 < 0.5
+ok or i32 == f64
+ok or i32 > 0.5
+ok or i64 != f32
+ok or i64 == 1
+ok or list == array
+ok or nil != 0.5
+ok or not false
+ok or not ok
+ok or not true
+ok or ok
+ok or ok || false
+ok or one(array, true)
+ok || "bar" not contains string(true)
+ok || 0.5 < i32
+ok || 0.5 <= 0.5
+ok || 0.5 == i64
+ok || 1 != 0.5
+ok || 1 != 1
+ok || 1 != nil
+ok || 1 < 0.5
+ok || 1 <= 1
+ok || add != score
+ok || all(array, ok)
+ok || div == nil
+ok || f32 <= 0.5
+ok || f32 <= 1
+ok || f32 > i64
+ok || f32 >= f64
+ok || false && ok
+ok || i != f64
+ok || i <= 0.5
+ok || i32 != 0.5
+ok || i32 < 0.5
+ok || i32 > 1
+ok || i64 > 0.5
+ok || ok
+ok || score != score
+ok || toJSON(f64) > trimSuffix("bar")
+one([1], ok)
+one([i32], i32 >= #)
+one([score, greet], # == #)
+one([score], ok)
+one(array, "bar" matches "foo")
+one(array, "bar" not in foo)
+one(array, "foo" != "foo")
+one(array, "foo" > "foo")
+one(array, # != #)
+one(array, # != 0.5)
+one(array, # != f64)
+one(array, # != i32)
+one(array, # != nil)
+one(array, # % # <= #)
+one(array, # < #)
+one(array, # < 0.5)
+one(array, # < 1)
+one(array, # < f32)
+one(array, # < f64)
+one(array, # < i)
+one(array, # < i32)
+one(array, # <= #)
+one(array, # <= f32)
+one(array, # <= f64)
+one(array, # <= i)
+one(array, # <= i32)
+one(array, # == #)
+one(array, # == 0.5)
+one(array, # == 1)
+one(array, # == f64)
+one(array, # == i)
+one(array, # == i32)
+one(array, # == i64)
+one(array, # > #)
+one(array, # > f64)
+one(array, # > i32)
+one(array, # > i64)
+one(array, # >= #)
+one(array, # >= 0.5)
+one(array, # >= 1)
+one(array, # >= f32)
+one(array, # >= i)
+one(array, # >= i32)
+one(array, # in array)
+one(array, 0.5 != #)
+one(array, 0.5 < #)
+one(array, 0.5 <= #)
+one(array, 0.5 == #)
+one(array, 0.5 > #)
+one(array, 0.5 > f32)
+one(array, 0.5 >= #)
+one(array, 1 != #)
+one(array, 1 < 0.5)
+one(array, 1 < i)
+one(array, 1 <= #)
+one(array, 1 <= 0.5)
+one(array, 1 == #)
+one(array, 1 == i32)
+one(array, 1 > #)
+one(array, 1 >= #)
+one(array, 1 >= f32)
+one(array, f32 < 1)
+one(array, f32 <= #)
+one(array, f32 <= i64)
+one(array, f32 == #)
+one(array, f32 == 0.5)
+one(array, f32 == 1)
+one(array, f32 >= #)
+one(array, f64 != #)
+one(array, f64 != 1)
+one(array, f64 != i)
+one(array, f64 != nil)
+one(array, f64 == #)
+one(array, f64 > #)
+one(array, false == nil)
+one(array, greet == score)
+one(array, i != 0.5)
+one(array, i < i32)
+one(array, i <= #)
+one(array, i == #)
+one(array, i > f64)
+one(array, i >= #)
+one(array, i >= f32)
+one(array, i32 != #)
+one(array, i32 <= #)
+one(array, i32 == #)
+one(array, i32 == i)
+one(array, i32 > #)
+one(array, i64 <= #)
+one(array, i64 == #)
+one(array, i64 > #)
+one(array, i64 > 1)
+one(array, nil != #)
+one(array, nil != foo)
+one(array, nil == i64)
+one(array, not ok)
+one(array, not true)
+one(array, ok && true)
+one(array, ok)
+one(array, one(array, false))
+one(array, score != greet)
+one(array, score == div)
+one(array, true || ok)
+one(array, true || true)
+one(filter(list, true), ok)
+one(i32 .. i32, ok)
+one(i32 .. i64, # >= #)
+one(list, !ok)
+one(list, !true)
+one(list, "bar" not in #)
+one(list, "foo" != "bar")
+one(list, "foo" < "foo")
+one(list, "foo" not in #)
+one(list, # != #)
+one(list, # != nil)
+one(list, # == #)
+one(list, # == foo)
+one(list, # == nil)
+one(list, # in list)
+one(list, 0.5 != f32)
+one(list, 0.5 > 0.5)
+one(list, 1 < 1)
+one(list, any(array, true))
+one(list, any(list, ok))
+one(list, any(list, true))
+one(list, f32 == 0.5)
+one(list, f32 == f64)
+one(list, f32 > f32)
+one(list, f64 != nil)
+one(list, f64 == f32)
+one(list, f64 >= 0.5)
+one(list, f64 >= 1)
+one(list, foo == #)
+one(list, greet != nil)
+one(list, greet == score)
+one(list, half != add)
+one(list, i != nil)
+one(list, i == i64)
+one(list, i64 != f32)
+one(list, i64 < 1)
+one(list, i64 <= 0.5)
+one(list, i64 > 0.5)
+one(list, i64 > 1)
+one(list, list != nil)
+one(list, nil != nil)
+one(list, nil != score)
+one(list, nil == #)
+one(list, none(array, ok))
+one(list, none(list, ok))
+one(list, not false)
+one(list, not ok)
+one(list, not true)
+one(list, ok)
+one(list, ok) and ok
+one(list, one(list, ok))
+one(list, score == half)
+one(list, true) && ok ? i : i64
+one(map(array, "foo"), # matches #)
+one(map(array, #), # != #)
+one(map(array, #), # < #)
+one(map(array, #), # <= #)
+one(map(array, #), # > #)
+one(map(array, #), # > 1)
+one(map(array, #), f64 <= 0.5)
+one(map(array, #), ok)
+one(map(array, div), # == nil)
+one(map(array, i64), ok)
+one(map(array, true), #)
+one(map(list, "bar"), ok)
+one(map(list, #), nil != #)
+one(map(list, 1), # < 0.5)
+one(map(list, f64), # <= #)
+one(map(list, false), #)
+one(map(list, i), ok)
+one(map(list, list), ok)
+one(map(list, ok), #)
+repeat(toJSON(nil), i)
+score
+score != add
+score != add != true
+score != add ? i64 : "foo"
+score != div
+score != div ? i : f32
+score != div and ok
+score != foo.Qux
+score != foo.String
+score != foo?.Qux
+score != foo?.String
+score != greet
+score != greet ? score : array
+score != half
+score != score
+score != score ? 1 : i
+score == add
+score == add == false
+score == add ? f64 : not false
+score == div
+score == div || foo == foo
+score == foo.Qux
+score == foo.String
+score == foo?.Qux
+score == foo?.String
+score == greet
+score == greet ? half : f64
+score == greet and ok
+score == half
+score == score
+score == score ? 0.5 : foo
+score == score ? nil : i32
+score == score or ok
+score == {"bar": 0.5}.f32
+score(-1)
+score(-i)
+score(-i, i)
+score(1 % 1)
+score(1 % i)
+score(1 % i32)
+score(1 % i64)
+score(1 * 1)
+score(1 * 1, i)
+score(1 * i)
+score(1 * i32)
+score(1 * i64)
+score(1 + 1)
+score(1 + i)
+score(1 + i32)
+score(1 + i64)
+score(1 - 1)
+score(1 - i)
+score(1 - i32)
+score(1 - i64)
+score(1) != -0.5
+score(1) != f32
+score(1) != float(f64)
+score(1) != i
+score(1) % i32
+score(1) * f32
+score(1) * f64
+score(1) * i64
+score(1) ** -1
+score(1) ** f32
+score(1) ** i64
+score(1) + f32
+score(1) + f64
+score(1) - f32
+score(1) - i
+score(1) .. i64
+score(1) / f64
+score(1) / i
+score(1) / i32
+score(1) / i64
+score(1) < i32
+score(1) < i64
+score(1) <= i32
+score(1) <= i64
+score(1) == 1 ^ 1
+score(1) == f64
+score(1) == i ** f64
+score(1) == i32
+score(1) == i64
+score(1) > i64
+score(1) >= f32
+score(1) >= f64
+score(1) >= i
+score(1) >= i32
+score(1) >= i64
+score(1) ^ f32
+score(1) ^ f64
+score(1) ^ i
+score(1) in array
+score(1, i) > f32
+score(abs(1))
+score(abs(i))
+score(add(1, 1))
+score(add(1, i))
+score(array[1])
+score(array[i32])
+score(array[i64])
+score(array[i])
+score(count(array, f64 < 1))
+score(count(array, false))
+score(count(array, ok))
+score(count(array, true))
+score(count(list, false))
+score(count(list, ok))
+score(count(list, true))
+score(div(1, 1))
+score(div(i, 1))
+score(false ? true : i)
+score(find(array, ok))
+score(findIndex(array, ok))
+score(findIndex(array, true))
+score(findIndex(list, ok))
+score(findIndex(list, true))
+score(findLast(array, 0.5 != #))
+score(findLast(array, ok))
+score(findLastIndex(array, ok))
+score(findLastIndex(array, true))
+score(findLastIndex(list, ok))
+score(findLastIndex(list, true))
+score(first(array))
+score(get(array, 1))
+score(get(array, i))
+score(get(array, i32))
+score(get(array, i64))
+score(i % i)
+score(i % i32)
+score(i * 1)
+score(i * i32)
+score(i * i64)
+score(i + 1)
+score(i + i)
+score(i + i32)
+score(i + i64)
+score(i - 1)
+score(i - i)
+score(i - i32)
+score(i - i64)
+score(i)
+score(i) != 1 == true
+score(i) != float(i32)
+score(i) != i
+score(i) != i32
+score(i) % i32 % i64
+score(i) % i64
+score(i) * f64
+score(i) * i32
+score(i) * i64
+score(i) ** f64
+score(i) ** i32
+score(i) + f32
+score(i) + i
+score(i) + i32
+score(i) + i64
+score(i) - f32
+score(i) - i
+score(i) - i32
+score(i) / f32
+score(i) / i
+score(i) < f32
+score(i) < i32
+score(i) <= f32 - f32
+score(i) == f32
+score(i) == i32
+score(i) == i64
+score(i) >= f32
+score(i) ^ f64
+score(i) ^ i
+score(i, i + i)
+score(i, i)
+score(i, i) >= i
+score(i, int(i64))
+score(i, score(i)) - i32
+score(i32 % i)
+score(i32 % i64)
+score(i32 * 1)
+score(i32 * i)
+score(i32 + i)
+score(i32 + i64)
+score(i32 - 1)
+score(i32 - i)
+score(i64 % 1)
+score(i64 % i)
+score(i64 * 1)
+score(i64 * i)
+score(i64 * i32)
+score(i64 + 1)
+score(i64 - 1)
+score(i64 - i)
+score(i64 - i32)
+score(int(0.5))
+score(int(1))
+score(int(f32 * i))
+score(int(f32))
+score(int(f64))
+score(int(i))
+score(int(i32))
+score(int(i64))
+score(last(array))
+score(len("bar"))
+score(len("foo"))
+score(len(array))
+score(len(i32 .. i64))
+score(len(list))
+score(max(1))
+score(max(1, 1))
+score(max(i))
+score(max(i, 1))
+score(min(1))
+score(min(1, i64))
+score(min(i))
+score(score(1))
+score(score(1, 1))
+score(score(i))
+score(score(i32 % 1))
+score(true ? 1 : true)
+score(true ? i : i64)
+sort(1 .. 1)
+sort(1 .. i64)
+sort([0.5])
+sort([1])
+sort([i32])
+sort([i64])
+sort([nil])
+sort(array)
+sort(array) != list
+sort(false ? i64 : array)
+sort(filter(array, false))
+sort(filter(array, true))
+sort(filter(list, false))
+sort(i .. 1)
+sort(i .. i64)
+sort(i32 .. 1)
+sort(i32 .. i32)
+sort(map(array, "bar"))
+sort(map(array, "foo"))
+sort(map(array, #))
+sort(map(array, 1))
+sort(map(array, i32))
+sort(map(list, "foo")) != list
+sort(map(list, i))
+sort(sort(array))
+string(!(i <= f32))
+string(!false)
+string(!ok)
+string(!true)
+string("bar" != "bar")
+string("bar" < "bar")
+string("bar" == "bar")
+string("bar" > "bar")
+string("bar" contains "foo")
+string("bar" endsWith "bar")
+string("bar" not endsWith "bar")
+string("bar" not matches "foo")
+string("bar" not startsWith "foo")
+string("bar" startsWith "bar")
+string("bar") >= type(score)
+string("bar") endsWith "foo" + "foo"
+string("bar") in foo
+string("foo" != nil)
+string("foo" <= "foo")
+string("foo" >= "bar")
+string("foo" matches "foo")
+string("foo" not endsWith "foo")
+string("foo" not in foo)
+string("foo" not matches "foo")
+string("foo" startsWith "bar")
+string(-(0.5 + f64))
+string(-0.5)
+string(-1)
+string(-f32)
+string(-f64)
+string(-i)
+string(-i32)
+string(-i64)
+string(0.5 != 0.5)
+string(0.5 != 1)
+string(0.5 != f32)
+string(0.5 != f64)
+string(0.5 != i)
+string(0.5 != nil)
+string(0.5 * 0.5)
+string(0.5 * f32)
+string(0.5 * i)
+string(0.5 * i32)
+string(0.5 ** 0.5)
+string(0.5 ** 1)
+string(0.5 ** i32)
+string(0.5 ** i64)
+string(0.5 + 0.5)
+string(0.5 + 1)
+string(0.5 + f32)
+string(0.5 + f64)
+string(0.5 + i64)
+string(0.5 - 0.5)
+string(0.5 - 1)
+string(0.5 / 0.5)
+string(0.5 / f64)
+string(0.5 / i)
+string(0.5 < 1)
+string(0.5 < f32)
+string(0.5 < i)
+string(0.5 < i32)
+string(0.5 <= f64)
+string(0.5 <= i)
+string(0.5 <= i64)
+string(0.5 == 0.5)
+string(0.5 == 1)
+string(0.5 == f32)
+string(0.5 == f64)
+string(0.5 == i)
+string(0.5 == i32)
+string(0.5 == i64)
+string(0.5 == nil)
+string(0.5 > 0.5)
+string(0.5 > 1)
+string(0.5 > i64)
+string(0.5 >= 0.5)
+string(0.5 >= 1)
+string(0.5 >= f32)
+string(0.5 >= f64)
+string(0.5 >= i)
+string(0.5 >= i32)
+string(0.5 ^ 0.5)
+string(0.5 ^ 1)
+string(0.5 ^ f32)
+string(0.5 ^ i)
+string(0.5 ^ i32)
+string(0.5) not endsWith type(1)
+string(1 != 1)
+string(1 != f32)
+string(1 != f64)
+string(1 != i)
+string(1 != i32)
+string(1 != nil)
+string(1 % 1)
+string(1 % i)
+string(1 % i32)
+string(1 % i64)
+string(1 * 1)
+string(1 * i)
+string(1 * i64)
+string(1 ** 0.5)
+string(1 ** 1)
+string(1 ** f64)
+string(1 ** i)
+string(1 ** i32)
+string(1 + 0.5)
+string(1 + f32)
+string(1 + f64)
+string(1 + i64)
+string(1 - f32)
+string(1 - i)
+string(1 - i64)
+string(1 .. 1)
+string(1 .. i)
+string(1 .. i32)
+string(1 / 0.5)
+string(1 / 1)
+string(1 / f32)
+string(1 / i)
+string(1 < i)
+string(1 < i32)
+string(1 < i64)
+string(1 <= 0.5)
+string(1 <= 1)
+string(1 <= f32)
+string(1 <= f64)
+string(1 <= i32)
+string(1 == 0.5)
+string(1 == 1)
+string(1 == f64)
+string(1 == i)
+string(1 == i64)
+string(1 == nil)
+string(1 > 1)
+string(1 > f32)
+string(1 >= 0.5)
+string(1 >= 1)
+string(1 >= f32)
+string(1 >= f64)
+string(1 >= i)
+string(1 >= i32)
+string(1 >= i64)
+string(1 ^ 1)
+string(1 ^ f32)
+string(1 ^ f64)
+string(1 ^ i)
+string(1 ^ i32)
+string(1 ^ i64)
+string(1 in array)
+string(1 not in array)
+string(1)[i64:i64]
+string([0.5, f32])
+string([add])
+string([f32])
+string([greet])
+string([i32, half])
+string([i32])
+string([i])
+string([ok])
+string([score])
+string(abs(0.5))
+string(abs(1))
+string(abs(f32))
+string(abs(f64))
+string(abs(half(0.5)))
+string(abs(i))
+string(abs(i64))
+string(add != add)
+string(add != half)
+string(add != nil)
+string(add != score)
+string(add == greet)
+string(add)
+string(add) contains type(list)
+string(add) not in foo
+string(all(array, false))
+string(all(array, true))
+string(any(array, false))
+string(any(list, true))
+string(array != array)
+string(array == nil)
+string(array)
+string(array) not in foo
+string(array[1:i])
+string(array[1])
+string(array[i64])
+string(count(array, # <= #))
+string(count(array, ok))
+string(div != greet)
+string(div != nil)
+string(div == nil)
+string(div == score)
+string(div)
+string(f32 != 0.5)
+string(f32 != 1)
+string(f32 != f32)
+string(f32 != f64)
+string(f32 != nil)
+string(f32 * 0.5)
+string(f32 * f64)
+string(f32 * i)
+string(f32 * i32)
+string(f32 ** 1)
+string(f32 ** i64)
+string(f32 + 1)
+string(f32 + f32)
+string(f32 - i)
+string(f32 / 1)
+string(f32 / i)
+string(f32 / i64)
+string(f32 < 0.5)
+string(f32 < f64)
+string(f32 < i32)
+string(f32 <= 0.5)
+string(f32 <= 1)
+string(f32 <= f32)
+string(f32 <= i)
+string(f32 <= i32)
+string(f32 == 0.5)
+string(f32 == 1)
+string(f32 == i64)
+string(f32 == nil)
+string(f32 > 1)
+string(f32 > f32)
+string(f32 > f64)
+string(f32 > i)
+string(f32 > i32)
+string(f32 >= 0.5)
+string(f32 >= f32)
+string(f32 >= f64)
+string(f32 >= i32)
+string(f32 ^ 1)
+string(f32 ^ f32)
+string(f32 ^ f64)
+string(f32 ^ i)
+string(f32 ^ i64)
+string(f32)
+string(f32) matches trim("bar")
+string(f64 != 1)
+string(f64 != f32)
+string(f64 * 0.5)
+string(f64 * 1)
+string(f64 * f32)
+string(f64 * f64)
+string(f64 * i)
+string(f64 ** 0.5)
+string(f64 ** 1)
+string(f64 ** f64)
+string(f64 ** i32)
+string(f64 + 0.5)
+string(f64 + 1)
+string(f64 + f32)
+string(f64 + i)
+string(f64 + i32)
+string(f64 + i64)
+string(f64 - 0.5)
+string(f64 - f64)
+string(f64 - i32)
+string(f64 / 0.5)
+string(f64 / f64)
+string(f64 / i64)
+string(f64 < 1)
+string(f64 < f64)
+string(f64 < i32)
+string(f64 <= f64)
+string(f64 <= i)
+string(f64 == 0.5)
+string(f64 == 1)
+string(f64 == f32)
+string(f64 == f64)
+string(f64 == i)
+string(f64 == i32)
+string(f64 == i64)
+string(f64 > 0.5)
+string(f64 > 1)
+string(f64 > f32)
+string(f64 > f64)
+string(f64 > i64)
+string(f64 >= 1)
+string(f64 >= f32)
+string(f64 >= i)
+string(f64 >= i64)
+string(f64 ^ 0.5)
+string(f64 ^ i)
+string(f64 ^ i32)
+string(f64 ^ i64)
+string(f64)
+string(false && false)
+string(false ? 0.5 : i32)
+string(false ? 1 : "bar")
+string(false ? 1 : f32)
+string(false ? 1 : score)
+string(false ? div : "foo")
+string(false ? f32 : foo)
+string(false and true)
+string(false) <= foo.Bar
+string(false) > string(add)
+string(filter(list, ok))
+string(find(array, ok))
+string(findIndex(array, true))
+string(findIndex(list, ok))
+string(findLast(array, # >= #))
+string(findLast(array, false))
+string(findLast(array, ok))
+string(findLast(list, ok))
+string(findLastIndex(array, not false))
+string(findLastIndex(array, ok))
+string(findLastIndex(array, true))
+string(findLastIndex(list, false))
+string(findLastIndex(list, ok))
+string(findLastIndex(list, true))
+string(first(array))
+string(first(list))
+string(float(0.5))
+string(float(1))
+string(float(f32))
+string(float(f64))
+string(float(i))
+string(float(i64))
+string(foo != nil)
+string(foo not in list)
+string(foo)
+string(foo.Bar)
+string(foo.Qux)
+string(foo.String())
+string(foo.String)
+string(foo?.Bar)
+string(foo?.Qux)
+string(foo?.String())
+string(foo?.String)
+string(get(array, 1))
+string(get(array, i))
+string(get(list, i))
+string(get(list, i64))
+string(greet != add)
+string(greet != greet)
+string(greet != nil)
+string(greet != score)
+string(greet == add)
+string(greet == greet)
+string(greet == half)
+string(greet == nil)
+string(greet == score)
+string(greet("bar"))
+string(greet("foo"))
+string(greet)
+string(greet)[i64:i]
+string(half != add)
+string(half != div)
+string(half != half)
+string(half == greet)
+string(half == nil)
+string(half == score)
+string(half(-1))
+string(half(0.5))
+string(half(f64))
+string(half)
+string(half) > toJSON(nil)
+string(half) not endsWith type("foo")
+string(i != 0.5)
+string(i != f32)
+string(i != f64)
+string(i % 1)
+string(i % i32)
+string(i * i32)
+string(i * i64)
+string(i ** 1)
+string(i ** f32)
+string(i + 1)
+string(i + i)
+string(i + i32)
+string(i + i64)
+string(i - f32)
+string(i - i64)
+string(i .. 1)
+string(i .. i)
+string(i .. i64)
+string(i / 1)
+string(i / f32)
+string(i / i)
+string(i / i32)
+string(i / i64)
+string(i < 1)
+string(i < f32)
+string(i < i32)
+string(i <= 0.5)
+string(i <= 1)
+string(i == 0.5)
+string(i == f32)
+string(i == i32)
+string(i > 0.5)
+string(i > 1)
+string(i > f64)
+string(i > i64)
+string(i >= 1)
+string(i >= f64)
+string(i ^ 0.5)
+string(i ^ 1)
+string(i ^ i)
+string(i in array)
+string(i not in array)
 string(i)
-trim(" a ")
-trim("_a_", "_")
-trimPrefix("  a", " ")
-trimSuffix("a  ")
-upper("a")
-lower("A")
-split("a,b,c", ",")
-replace("a,b,c", ",", "_")
-repeat("a", 3)
-join(["a", "b", "c"], ",")
-indexOf("abc", "b")
-max(1,2,3)
-min(1,2,3)
-toJSON(a)
-fromJSON("[1,2,3]")
-now()
-duration("1s")
-first(a)
-last(a)
-get(m, "a")
-1..9 | filter(i > 5) | map(i * 2)
-s startsWith "a"
-s endsWith "c"
-s contains "a"
-s matches "a"
-s matches "a+"
-true ? 1 : 2
-false ? 1 : 2
-b ?? true
-head(1)
-{a: 1, b: 2}
-[1, 2, 3]
-type(1)
-type("a")
-type([1, 2, 3])
-type({a: 1, b: 2})
-type(head)
-keys(m)
-values(m)
-foo.bar.a
-foo.bar.b
+string(i32 != f64)
+string(i32 != i)
+string(i32 != nil)
+string(i32 * 0.5)
+string(i32 * 1)
+string(i32 * f32)
+string(i32 * f64)
+string(i32 * i64)
+string(i32 ** 0.5)
+string(i32 ** f64)
+string(i32 ** i)
+string(i32 + f64)
+string(i32 + i32)
+string(i32 - f32)
+string(i32 - f64)
+string(i32 .. 1)
+string(i32 .. i32)
+string(i32 .. i64)
+string(i32 / 0.5)
+string(i32 / i64)
+string(i32 < 0.5)
+string(i32 < f32)
+string(i32 < i)
+string(i32 < i32)
+string(i32 < i64)
+string(i32 <= f64)
+string(i32 <= i64)
+string(i32 == 1)
+string(i32 == f32)
+string(i32 == f64)
+string(i32 == i)
+string(i32 == nil)
+string(i32 > 1)
+string(i32 > f64)
+string(i32 >= 0.5)
+string(i32 >= 1)
+string(i32 >= f64)
+string(i32 >= i)
+string(i32 >= i64)
+string(i32 ^ 1)
+string(i32 ^ f64)
+string(i32 ^ i32)
+string(i32 ^ i64)
+string(i32 in array)
+string(i32 not in array)
+string(i32)
+string(i32) == type("bar")
+string(i64 != 0.5)
+string(i64 != 1)
+string(i64 != i)
+string(i64 != i32)
+string(i64 != i64)
+string(i64 != nil)
+string(i64 % 1)
+string(i64 % i64)
+string(i64 * 1)
+string(i64 * f32)
+string(i64 * i32)
+string(i64 * i64)
+string(i64 ** 0.5)
+string(i64 ** f32)
+string(i64 ** i)
+string(i64 ** i32)
+string(i64 + 0.5)
+string(i64 + f32)
+string(i64 + f64)
+string(i64 + i)
+string(i64 + i32)
+string(i64 - f32)
+string(i64 - i)
+string(i64 / 0.5)
+string(i64 / 1)
+string(i64 / f32)
+string(i64 / f64)
+string(i64 / i)
+string(i64 / i64)
+string(i64 < 1)
+string(i64 <= 0.5)
+string(i64 <= f32)
+string(i64 <= i)
+string(i64 <= i32)
+string(i64 <= i64)
+string(i64 == 1)
+string(i64 == i)
+string(i64 == i32)
+string(i64 == nil)
+string(i64 > 1)
+string(i64 > f32)
+string(i64 > f64)
+string(i64 > i)
+string(i64 > i32)
+string(i64 > i64)
+string(i64 >= f64)
+string(i64 >= i64)
+string(i64 ^ 0.5)
+string(i64 ^ f64)
+string(i64 ^ i)
+string(i64 in array)
+string(i64)
+string(i64) >= foo.Bar
+string(i64) not in foo
+string(int(0.5))
+string(int(1))
+string(int(f32 - i))
+string(int(f32))
+string(int(f64))
+string(int(i))
+string(int(i32))
+string(int(i64))
+string(last(array))
+string(last(list))
+string(len(array))
+string(len(list))
+string(len(string("foo")))
+string(list == array)
+string(list == list)
+string(list == nil)
+string(list)
+string(list) != toJSON(i64)
+string(list[1])
+string(list[i64])
+string(list[i64].String)
+string(lower("bar"))
+string(lower("foo"))
+string(map(array, "bar"))
+string(map(array, #))
+string(map(array, 0.5))
+string(map(array, 1))
+string(map(array, array))
+string(map(array, div))
+string(map(array, greet))
+string(map(array, i))
+string(map(array, i32))
+string(map(array, ok))
+string(map(array, true))
+string(map(list, "bar"))
+string(map(list, "foo"))
+string(map(list, #))
+string(map(list, 0.5))
+string(map(list, 1))
+string(map(list, add))
+string(map(list, f32))
+string(map(list, f64))
+string(map(list, false))
+string(map(list, greet))
+string(map(list, i64))
+string(map(list, list))
+string(max(0.5))
+string(max(1))
+string(max(1, 0.5))
+string(max(1, f32))
+string(max(f32))
+string(max(f64))
+string(max(i))
+string(max(i32))
+string(max(i32, 1, i64))
+string(max(i64))
+string(min(0.5))
+string(min(0.5, f64, f32))
+string(min(1))
+string(min(f32))
+string(min(f64))
+string(min(i))
+string(min(i32))
+string(min(i32, i64))
+string(min(i64))
+string(nil != "foo")
+string(nil != 0.5)
+string(nil != 1)
+string(nil != array)
+string(nil != div)
+string(nil != f64)
+string(nil != false)
+string(nil != greet)
+string(nil != i)
+string(nil != i64)
+string(nil != nil)
+string(nil != score)
+string(nil == "foo")
+string(nil == 1)
+string(nil == add)
+string(nil == f32)
+string(nil == f64)
+string(nil == false)
+string(nil == list)
+string(nil == ok)
+string(nil == true)
+string(nil in array)
+string(nil in list)
+string(nil) > string(1)
+string(nil) >= string(greet)
+string(nil) in foo
+string(none(array, ok))
+string(none(list, true))
+string(not false)
+string(not ok)
+string(not true)
+string(ok && false)
+string(ok && ok)
+string(ok == nil)
+string(ok == true)
+string(ok ? 0.5 : "foo")
+string(ok ? 0.5 : true)
+string(ok ? true : i32)
+string(ok or false)
+string(ok or ok)
+string(ok || ok)
+string(ok)
+string(one(array, false))
+string(one(array, ok))
+string(one(array, true))
+string(one(list, true))
+string(score != nil)
+string(score == div)
+string(score == nil)
+string(score(1))
+string(score(i))
+string(score(score(i)))
+string(score)
+string(score) < string(ok)
+string(score) not in foo
+string(sort(array))
+string(string("bar"))
+string(string("foo"))
+string(string(0.5))
+string(string(1))
+string(string(add))
+string(string(array))
+string(string(div))
+string(string(f64))
+string(string(false))
+string(string(foo))
+string(string(greet))
+string(string(half))
+string(string(i))
+string(string(i32))
+string(string(i64))
+string(string(list))
+string(string(nil))
+string(string(ok))
+string(string(score))
+string(string(true))
+string(toJSON("bar"))
+string(toJSON("foo"))
+string(toJSON(0.5))
+string(toJSON(1))
+string(toJSON(array))
+string(toJSON(f32))
+string(toJSON(f64))
+string(toJSON(false))
+string(toJSON(foo))
+string(toJSON(i))
+string(toJSON(i64))
+string(toJSON(list))
+string(toJSON(nil))
+string(toJSON(ok))
+string(toJSON(true))
+string(trim("foo"))
+string(trim(toJSON(0.5)))
+string(trimPrefix("bar"))
+string(trimPrefix("foo"))
+string(trimPrefix(type(f32)))
+string(trimSuffix("bar"))
+string(true != true)
+string(true == nil)
+string(true == ok)
+string(true ? 1 : true)
+string(true ? array : f32)
+string(true ? div : i64)
+string(true ? i32 : "foo")
+string(true ? i32 : greet)
+string(true ? score : 0.5)
+string(true ? true : i32)
+string(true and false)
+string(true or true)
+string(true || false)
+string(true) endsWith string(i64)
+string(true) not in foo
+string(type("foo"))
+string(type(0.5))
+string(type(1 < f64))
+string(type(1))
+string(type(add))
+string(type(array))
+string(type(div))
+string(type(f32))
+string(type(f64))
+string(type(false))
+string(type(foo))
+string(type(half))
+string(type(i))
+string(type(i32))
+string(type(i64))
+string(type(list))
+string(type(nil))
+string(type(ok))
+string(type(score(1)))
+string(type(score))
+string(type(true))
+string(type(type(false)))
+string(upper("bar"))
+string(upper("foo"))
+string({"bar": 0.5})
+string({"bar": i32, "foo": i64})
+string({"foo": f64})
+string({"foo": true})
+toBase64(foo.Bar)
+toBase64(foo.String())
+toBase64(foo?.Bar)
+toBase64(foo?.String())
+toBase64(greet("bar"))
+toBase64(greet("foo"))
+toBase64(greet(string(array)))
+toBase64(lower("bar"))
+toBase64(lower("foo"))
+toBase64(lower(type(i32)))
+toBase64(ok ? "foo" : 1)
+toBase64(ok ? "foo" : foo)
+toBase64(string("bar"))
+toBase64(string("foo"))
+toBase64(string(0.5))
+toBase64(string(1))
+toBase64(string(array))
+toBase64(string(f32 <= i32))
+toBase64(string(f32))
+toBase64(string(f64))
+toBase64(string(false))
+toBase64(string(foo))
+toBase64(string(greet))
+toBase64(string(half))
+toBase64(string(i))
+toBase64(string(i32))
+toBase64(string(i64))
+toBase64(string(list))
+toBase64(string(nil))
+toBase64(string(ok))
+toBase64(string(score))
+toBase64(string(true))
+toBase64(toBase64("bar"))
+toBase64(toBase64("foo"))
+toBase64(toJSON("bar"))
+toBase64(toJSON("foo"))
+toBase64(toJSON(0.5))
+toBase64(toJSON(1))
+toBase64(toJSON(array))
+toBase64(toJSON(f32))
+toBase64(toJSON(f64))
+toBase64(toJSON(false))
+toBase64(toJSON(foo))
+toBase64(toJSON(i))
+toBase64(toJSON(i32))
+toBase64(toJSON(i64))
+toBase64(toJSON(list))
+toBase64(toJSON(nil))
+toBase64(toJSON(ok))
+toBase64(toJSON(true))
+toBase64(trim("bar"))
+toBase64(trim("foo"))
+toBase64(trimPrefix("foo"))
+toBase64(trimSuffix("bar"))
+toBase64(trimSuffix("foo"))
+toBase64(true ? "bar" : ok)
+toBase64(type("bar"))
+toBase64(type("foo"))
+toBase64(type(0.5))
+toBase64(type(1))
+toBase64(type(add))
+toBase64(type(array))
+toBase64(type(div))
+toBase64(type(f32))
+toBase64(type(f64))
+toBase64(type(false))
+toBase64(type(foo))
+toBase64(type(get(array, i)))
+toBase64(type(greet))
+toBase64(type(i))
+toBase64(type(i32))
+toBase64(type(i64))
+toBase64(type(list))
+toBase64(type(ok))
+toBase64(type(true))
+toBase64(upper("bar"))
+toBase64(upper("foo"))
+toBase64(upper(foo.Bar))
+toJSON(!false)
+toJSON(!ok)
+toJSON(!true)
+toJSON("bar" != "foo")
+toJSON("bar" + "bar")
+toJSON("bar" + "foo")
+toJSON("bar" <= "foo")
+toJSON("bar" >= "foo")
+toJSON("bar" contains "bar")
+toJSON("bar" matches "bar")
+toJSON("bar" not matches "bar")
+toJSON("bar" not matches "foo")
+toJSON("foo" != "bar")
+toJSON("foo" + "bar")
+toJSON("foo" <= "bar")
+toJSON("foo" == nil)
+toJSON("foo" contains "bar")
+toJSON("foo" matches "foo")
+toJSON("foo" not in foo)
+toJSON("foo" not matches "bar")
+toJSON("foo") > foo?.Bar
+toJSON("foo") not in foo
+toJSON(-0.5)
+toJSON(-1)
+toJSON(-f32)
+toJSON(-f64)
+toJSON(-i)
+toJSON(-i32)
+toJSON(-i64)
+toJSON(0.5 != 0.5)
+toJSON(0.5 != 1)
+toJSON(0.5 != f32)
+toJSON(0.5 != f64)
+toJSON(0.5 != i)
+toJSON(0.5 != i32)
+toJSON(0.5 * 0.5)
+toJSON(0.5 * i)
+toJSON(0.5 * i32)
+toJSON(0.5 ** f64)
+toJSON(0.5 ** i)
+toJSON(0.5 ** i64)
+toJSON(0.5 + 0.5)
+toJSON(0.5 + f32)
+toJSON(0.5 - 0.5)
+toJSON(0.5 - 1)
+toJSON(0.5 - f32)
+toJSON(0.5 - f64)
+toJSON(0.5 / 0.5)
+toJSON(0.5 / 1)
+toJSON(0.5 / f32)
+toJSON(0.5 / f64)
+toJSON(0.5 / i)
+toJSON(0.5 / i32)
+toJSON(0.5 / i64)
+toJSON(0.5 < 0.5)
+toJSON(0.5 < 1)
+toJSON(0.5 < f32)
+toJSON(0.5 < i)
+toJSON(0.5 <= 1)
+toJSON(0.5 <= f32)
+toJSON(0.5 <= f64)
+toJSON(0.5 <= i)
+toJSON(0.5 == 0.5)
+toJSON(0.5 == 1)
+toJSON(0.5 == f32)
+toJSON(0.5 == i)
+toJSON(0.5 == i64)
+toJSON(0.5 > 1)
+toJSON(0.5 > f32)
+toJSON(0.5 > f64)
+toJSON(0.5 > i32)
+toJSON(0.5 >= 0.5)
+toJSON(0.5 >= 1)
+toJSON(0.5 >= f32)
+toJSON(0.5 >= f64)
+toJSON(0.5 >= i)
+toJSON(0.5 >= i32)
+toJSON(0.5 >= i64)
+toJSON(0.5 ^ 0.5)
+toJSON(0.5 ^ 1)
+toJSON(0.5 ^ f32)
+toJSON(0.5 ^ f64)
+toJSON(0.5 ^ i)
+toJSON(0.5 ^ i32)
+toJSON(0.5 ^ i64)
+toJSON(0.5) contains "bar" ? "bar" : array
+toJSON(1 != 0.5)
+toJSON(1 != f32)
+toJSON(1 != nil)
+toJSON(1 % 1)
+toJSON(1 % i32)
+toJSON(1 * 0.5)
+toJSON(1 * f32)
+toJSON(1 * f64)
+toJSON(1 * i32)
+toJSON(1 * i64)
+toJSON(1 ** 0.5)
+toJSON(1 ** 1)
+toJSON(1 ** f32)
+toJSON(1 ** f64)
+toJSON(1 ** i >= f64)
+toJSON(1 ** i32)
+toJSON(1 + 0.5)
+toJSON(1 + f32)
+toJSON(1 + f64)
+toJSON(1 + i64)
+toJSON(1 - 0.5)
+toJSON(1 - 1)
+toJSON(1 - f32)
+toJSON(1 - f64)
+toJSON(1 - i32)
+toJSON(1 .. 1)
+toJSON(1 .. i)
+toJSON(1 .. i64)
+toJSON(1 / 0.5)
+toJSON(1 / 1)
+toJSON(1 / f32)
+toJSON(1 / i32)
+toJSON(1 < 0.5)
+toJSON(1 < 1)
+toJSON(1 < f32)
+toJSON(1 < f64)
+toJSON(1 < i)
+toJSON(1 <= 0.5)
+toJSON(1 <= 1)
+toJSON(1 <= i)
+toJSON(1 <= i32)
+toJSON(1 <= i64)
+toJSON(1 == 0.5)
+toJSON(1 == f32)
+toJSON(1 == i)
+toJSON(1 == i32)
+toJSON(1 == i64)
+toJSON(1 == nil)
+toJSON(1 > 0.5)
+toJSON(1 > f64)
+toJSON(1 > i)
+toJSON(1 > i32)
+toJSON(1 > i64)
+toJSON(1 >= 0.5)
+toJSON(1 >= 1)
+toJSON(1 >= f32)
+toJSON(1 >= i32)
+toJSON(1 ^ 0.5)
+toJSON(1 ^ 1)
+toJSON(1 ^ f32)
+toJSON(1 ^ f64)
+toJSON(1 ^ i32)
+toJSON(1 ^ i64)
+toJSON(1 in array)
+toJSON(1) == nil == true
+toJSON(1) in foo
+toJSON(1) not in foo
+toJSON(1) startsWith foo.String()
+toJSON([1])
+toJSON([i64])
+toJSON(abs(0.5))
+toJSON(abs(1))
+toJSON(abs(f32))
+toJSON(abs(f64))
+toJSON(abs(i))
+toJSON(abs(i32))
+toJSON(abs(i64))
+toJSON(add != nil)
+toJSON(add != score)
+toJSON(add == div)
+toJSON(add == half)
+toJSON(add == nil)
+toJSON(add == score)
+toJSON(all(list, false))
+toJSON(all(list, ok))
+toJSON(all(list, true))
+toJSON(any(array, false))
+toJSON(any(array, true))
+toJSON(array != array)
+toJSON(array != nil)
+toJSON(array)
+toJSON(array) != toJSON(ok)
+toJSON(array) > "bar" != false
+toJSON(array) endsWith greet("foo")
+toJSON(array) endsWith string(i32)
+toJSON(array) in foo
+toJSON(array) not startsWith greet("foo")
+toJSON(array[1:1])
+toJSON(array[i32])
+toJSON(array[i])
+toJSON(count(array, false))
+toJSON(count(array, ok))
+toJSON(div != div)
+toJSON(div != greet)
+toJSON(div != score)
+toJSON(div == div)
+toJSON(div == half)
+toJSON(div == nil)
+toJSON(div == score)
+toJSON(f32 != 1)
+toJSON(f32 * 0.5)
+toJSON(f32 * 1)
+toJSON(f32 * f32)
+toJSON(f32 * f64)
+toJSON(f32 * i32)
+toJSON(f32 ** f32)
+toJSON(f32 ** i32)
+toJSON(f32 ** i64)
+toJSON(f32 + 1)
+toJSON(f32 + i)
+toJSON(f32 + i32)
+toJSON(f32 - f64)
+toJSON(f32 - i32)
+toJSON(f32 / 0.5)
+toJSON(f32 / 1)
+toJSON(f32 < 0.5)
+toJSON(f32 < f32)
+toJSON(f32 < f64)
+toJSON(f32 <= f32)
+toJSON(f32 == 1)
+toJSON(f32 == f64)
+toJSON(f32 == i)
+toJSON(f32 == nil)
+toJSON(f32 > 0.5)
+toJSON(f32 > f64)
+toJSON(f32 > i)
+toJSON(f32 >= 1)
+toJSON(f32 >= f32)
+toJSON(f32 ^ 0.5)
+toJSON(f32 ^ 1)
+toJSON(f32 ^ f64)
+toJSON(f32 ^ i)
+toJSON(f32 ^ i64)
+toJSON(f32)
+toJSON(f64 != 1)
+toJSON(f64 != f32)
+toJSON(f64 != f64)
+toJSON(f64 != i)
+toJSON(f64 != i32 / i32)
+toJSON(f64 != i32)
+toJSON(f64 != nil)
+toJSON(f64 * 0.5)
+toJSON(f64 * f64)
+toJSON(f64 * i)
+toJSON(f64 * i64)
+toJSON(f64 ** 0.5)
+toJSON(f64 ** f32)
+toJSON(f64 ** i)
+toJSON(f64 ** i64)
+toJSON(f64 + 1)
+toJSON(f64 + f32)
+toJSON(f64 + i)
+toJSON(f64 + i32)
+toJSON(f64 - 1)
+toJSON(f64 - f64)
+toJSON(f64 - i)
+toJSON(f64 - i32)
+toJSON(f64 / 0.5)
+toJSON(f64 / f32)
+toJSON(f64 / i32)
+toJSON(f64 < 1)
+toJSON(f64 < f32)
+toJSON(f64 < i32)
+toJSON(f64 < i64)
+toJSON(f64 <= 0.5)
+toJSON(f64 <= 1)
+toJSON(f64 <= i32)
+toJSON(f64 == 1)
+toJSON(f64 == i64)
+toJSON(f64 == nil)
+toJSON(f64 > 1)
+toJSON(f64 > f64)
+toJSON(f64 >= 0.5)
+toJSON(f64 >= i64)
+toJSON(f64 ^ 1)
+toJSON(f64 ^ f64)
+toJSON(f64 ^ i)
+toJSON(f64)
+toJSON(false != nil)
+toJSON(false && false)
+toJSON(false == false)
+toJSON(false ? 0.5 : nil)
+toJSON(false ? 1 : f32)
+toJSON(false ? f32 : list)
+toJSON(false ? false : i32)
+toJSON(false ? greet : 1)
+toJSON(false ? greet : i32)
+toJSON(false ? nil : f64)
+toJSON(false and ok)
+toJSON(false and true)
+toJSON(filter(array, ok))
+toJSON(filter(list, false))
+toJSON(filter(list, true))
+toJSON(find(array, false))
+toJSON(find(array, ok))
+toJSON(findIndex(array, ok))
+toJSON(findIndex(array, true))
+toJSON(findIndex(list, ok))
+toJSON(findIndex(list, true))
+toJSON(findLast(array, false))
+toJSON(findLast(list, true))
+toJSON(findLastIndex(array, true))
+toJSON(findLastIndex(list, false))
+toJSON(findLastIndex(list, ok))
+toJSON(first(array))
+toJSON(first(list))
+toJSON(float(0.5))
+toJSON(float(1))
+toJSON(float(f32))
+toJSON(float(f64))
+toJSON(float(i))
+toJSON(float(i32))
+toJSON(float(i64))
+toJSON(foo != foo)
+toJSON(foo != nil)
+toJSON(foo == foo)
+toJSON(foo == nil)
+toJSON(foo in list)
+toJSON(foo)
+toJSON(foo.Bar)
+toJSON(foo.String())
+toJSON(foo?.Bar)
+toJSON(foo?.String())
+toJSON(get(array, 1))
+toJSON(get(array, i64))
+toJSON(get(list, 1))
+toJSON(get(list, i))
+toJSON(get(list, i64))
+toJSON(greet != div)
+toJSON(greet != greet)
+toJSON(greet != half)
+toJSON(greet == add)
+toJSON(greet == div)
+toJSON(greet == greet)
+toJSON(greet == half)
+toJSON(greet("bar"))
+toJSON(greet("foo"))
+toJSON(half != greet)
+toJSON(half != nil)
+toJSON(half != score)
+toJSON(half == add)
+toJSON(half == div)
+toJSON(half == greet)
+toJSON(half == nil)
+toJSON(half == score)
+toJSON(half(0.5))
+toJSON(half(f64))
+toJSON(i != 1)
+toJSON(i != f32)
+toJSON(i != i)
+toJSON(i != i32)
+toJSON(i % 1)
+toJSON(i % i64)
+toJSON(i * 0.5)
+toJSON(i * 1)
+toJSON(i * f32)
+toJSON(i * i32)
+toJSON(i ** 0.5)
+toJSON(i ** f32)
+toJSON(i ** i32)
+toJSON(i + 0.5)
+toJSON(i + 1)
+toJSON(i + f32)
+toJSON(i + f64)
+toJSON(i + i)
+toJSON(i - 1)
+toJSON(i .. 1)
+toJSON(i .. i)
+toJSON(i / f32)
+toJSON(i < i32)
+toJSON(i < i64)
+toJSON(i <= 1)
+toJSON(i <= f32)
+toJSON(i <= f64)
+toJSON(i <= i)
+toJSON(i <= i32)
+toJSON(i == i32)
+toJSON(i == i64)
+toJSON(i == nil)
+toJSON(i > 0.5)
+toJSON(i > 1)
+toJSON(i > f32)
+toJSON(i >= 0.5)
+toJSON(i >= 1)
+toJSON(i >= f32)
+toJSON(i >= i)
+toJSON(i ^ 1)
+toJSON(i ^ f64)
+toJSON(i)
+toJSON(i) != string(1)
+toJSON(i32 != f32)
+toJSON(i32 != i)
+toJSON(i32 % 1)
+toJSON(i32 % i64)
+toJSON(i32 * i)
+toJSON(i32 * i64)
+toJSON(i32 ** i64)
+toJSON(i32 + f64)
+toJSON(i32 + i)
+toJSON(i32 + i32)
+toJSON(i32 + i64)
+toJSON(i32 - 0.5)
+toJSON(i32 - 1)
+toJSON(i32 - f32)
+toJSON(i32 - f64)
+toJSON(i32 - i)
+toJSON(i32 .. i)
+toJSON(i32 .. i64)
+toJSON(i32 / 0.5)
+toJSON(i32 / f32)
+toJSON(i32 / i)
+toJSON(i32 / i64)
+toJSON(i32 < 0.5)
+toJSON(i32 < f32)
+toJSON(i32 <= 0.5)
+toJSON(i32 <= i32)
+toJSON(i32 == 1)
+toJSON(i32 == f32)
+toJSON(i32 == i)
+toJSON(i32 == nil ? i32 : i32)
+toJSON(i32 == nil)
+toJSON(i32 > 0.5)
+toJSON(i32 > f64)
+toJSON(i32 > i)
+toJSON(i32 >= 0.5)
+toJSON(i32 >= 1)
+toJSON(i32 >= f32)
+toJSON(i32 >= f64)
+toJSON(i32 >= i)
+toJSON(i32 ^ 1)
+toJSON(i32 ^ f64)
+toJSON(i32 ^ i)
+toJSON(i32 in array)
+toJSON(i32 not in array)
+toJSON(i32)
+toJSON(i32) < string(i64)
+toJSON(i64 != 0.5)
+toJSON(i64 != 1)
+toJSON(i64 != f32)
+toJSON(i64 != i)
+toJSON(i64 != i32)
+toJSON(i64 != nil)
+toJSON(i64 % 1)
+toJSON(i64 % i)
+toJSON(i64 % i32)
+toJSON(i64 % i64)
+toJSON(i64 * i)
+toJSON(i64 + 0.5)
+toJSON(i64 + i)
+toJSON(i64 + i64)
+toJSON(i64 - 0.5)
+toJSON(i64 - 1)
+toJSON(i64 - i64)
+toJSON(i64 .. 1)
+toJSON(i64 / 1)
+toJSON(i64 / f32)
+toJSON(i64 / i)
+toJSON(i64 / i64)
+toJSON(i64 < 0.5)
+toJSON(i64 < i32)
+toJSON(i64 <= 0.5)
+toJSON(i64 <= 1)
+toJSON(i64 <= f32)
+toJSON(i64 <= i64)
+toJSON(i64 == 0.5)
+toJSON(i64 == 1)
+toJSON(i64 == i32)
+toJSON(i64 == nil)
+toJSON(i64 > f32)
+toJSON(i64 > i)
+toJSON(i64 >= 0.5)
+toJSON(i64 >= 1)
+toJSON(i64 >= i64)
+toJSON(i64 ^ i)
+toJSON(i64)
+toJSON(int(0.5))
+toJSON(int(1))
+toJSON(int(f32))
+toJSON(int(f64))
+toJSON(int(i))
+toJSON(int(i32))
+toJSON(last(list))
+toJSON(len("bar"))
+toJSON(len("foo"))
+toJSON(len(array))
+toJSON(len(list))
+toJSON(list != list)
+toJSON(list == nil)
+toJSON(list)
+toJSON(list) <= foo?.Bar
+toJSON(list[1])
+toJSON(list[i32])
+toJSON(list[i64:1])
+toJSON(list[i64])
+toJSON(list[i])
+toJSON(lower("bar"))
+toJSON(lower("foo"))
+toJSON(map(array, #))
+toJSON(map(array, 0.5))
+toJSON(map(array, 1))
+toJSON(map(array, false))
+toJSON(map(array, i))
+toJSON(map(array, i32))
+toJSON(map(array, list))
+toJSON(map(array, true))
+toJSON(map(list, "foo"))
+toJSON(map(list, #))
+toJSON(map(list, 1))
+toJSON(map(list, f32))
+toJSON(map(list, f64))
+toJSON(map(list, list))
+toJSON(max(0.5))
+toJSON(max(1))
+toJSON(max(f32))
+toJSON(max(f64))
+toJSON(max(i))
+toJSON(max(i32))
+toJSON(max(i64))
+toJSON(min(0.5))
+toJSON(min(0.5, f32))
+toJSON(min(1))
+toJSON(min(1, 1))
+toJSON(min(f32))
+toJSON(min(f64))
+toJSON(min(i))
+toJSON(min(i32) / f32)
+toJSON(min(i32))
+toJSON(min(i64))
+toJSON(nil != "bar")
+toJSON(nil != "foo")
+toJSON(nil != 0.5)
+toJSON(nil != add)
+toJSON(nil != f32)
+toJSON(nil != f64)
+toJSON(nil != foo)
+toJSON(nil != i32)
+toJSON(nil != list)
+toJSON(nil != nil)
+toJSON(nil != score)
+toJSON(nil != true)
+toJSON(nil == 0.5)
+toJSON(nil == 1)
+toJSON(nil == add)
+toJSON(nil == div)
+toJSON(nil == f32)
+toJSON(nil == f64)
+toJSON(nil == false)
+toJSON(nil == foo)
+toJSON(nil == i)
+toJSON(nil == i64)
+toJSON(nil == list)
+toJSON(nil == ok)
+toJSON(nil == score)
+toJSON(nil == true)
+toJSON(nil in array)
+toJSON(nil not in array)
+toJSON(nil not in list)
+toJSON(nil) + string("bar")
+toJSON(nil) == toJSON(1)
+toJSON(nil) == type(nil)
+toJSON(nil) in foo
+toJSON(none(array, true))
+toJSON(none(list, true))
+toJSON(not ("foo" not in foo))
+toJSON(not false)
+toJSON(not ok)
+toJSON(not true)
+toJSON(ok != false)
+toJSON(ok != nil)
+toJSON(ok != ok)
+toJSON(ok && true)
+toJSON(ok == nil)
+toJSON(ok == ok)
+toJSON(ok ? 1 : half)
+toJSON(ok ? f32 : div)
+toJSON(ok ? false : i32)
+toJSON(ok ? nil : f32)
+toJSON(ok or true)
+toJSON(ok || ok)
+toJSON(ok)
+toJSON(one(array, i32 < #))
+toJSON(score != div)
+toJSON(score != greet)
+toJSON(score != nil)
+toJSON(score != score)
+toJSON(score == add)
+toJSON(score == div)
+toJSON(score == nil)
+toJSON(score(1))
+toJSON(score(i))
+toJSON(score(i, i))
+toJSON(string("bar"))
+toJSON(string("foo"))
+toJSON(string(0.5))
+toJSON(string(1))
+toJSON(string(array))
+toJSON(string(div))
+toJSON(string(f32))
+toJSON(string(f64))
+toJSON(string(false))
+toJSON(string(foo))
+toJSON(string(greet))
+toJSON(string(half))
+toJSON(string(i))
+toJSON(string(i32))
+toJSON(string(i64))
+toJSON(string(list))
+toJSON(string(nil))
+toJSON(string(ok))
+toJSON(string(score))
+toJSON(toBase64("bar"))
+toJSON(toBase64("foo"))
+toJSON(toJSON("bar"))
+toJSON(toJSON("foo"))
+toJSON(toJSON(1))
+toJSON(toJSON(array))
+toJSON(toJSON(f32))
+toJSON(toJSON(f64))
+toJSON(toJSON(false))
+toJSON(toJSON(foo))
+toJSON(toJSON(i))
+toJSON(toJSON(i32))
+toJSON(toJSON(i64))
+toJSON(toJSON(list))
+toJSON(toJSON(nil))
+toJSON(toJSON(ok))
+toJSON(toJSON(true))
+toJSON(trim("bar"))
+toJSON(trim("foo"))
+toJSON(trimPrefix("foo"))
+toJSON(trimSuffix("foo"))
+toJSON(true && true)
+toJSON(true ? array : nil)
+toJSON(true ? i32 : div)
+toJSON(true ? list : true)
+toJSON(true ? nil : array)
+toJSON(true ? ok : list)
+toJSON(true ? true : f64)
+toJSON(true and ok)
+toJSON(true) in foo
+toJSON(type("bar"))
+toJSON(type("foo"))
+toJSON(type(0.5))
+toJSON(type(1))
+toJSON(type(add))
+toJSON(type(array))
+toJSON(type(f32))
+toJSON(type(f64))
+toJSON(type(false))
+toJSON(type(foo))
+toJSON(type(greet))
+toJSON(type(half))
+toJSON(type(i))
+toJSON(type(i32))
+toJSON(type(i64))
+toJSON(type(list))
+toJSON(type(nil))
+toJSON(type(ok))
+toJSON(type(score))
+toJSON(type(true))
+toJSON(upper("bar"))
+toJSON(upper("foo"))
+toJSON({"bar": 0.5, "bar": array})
+toJSON({"foo": "foo"})
+toJSON({"foo": 0.5})
+toJSON({"foo": nil})
+toJSON({"foo": ok, "bar": 0.5})
+trim("bar") in foo
+trim("foo" + "foo")
+trim(false ? greet : "bar")
+trim(foo.Bar)
+trim(foo.String())
+trim(foo?.Bar)
+trim(foo?.String())
+trim(greet("bar"))
+trim(greet("foo"))
+trim(lower("bar"))
+trim(lower(toJSON(0.5)))
+trim(ok ? "bar" : i32)
+trim(string("foo"))
+trim(string(0.5))
+trim(string(1))
+trim(string(add))
+trim(string(div))
+trim(string(f32))
+trim(string(f64))
+trim(string(false))
+trim(string(foo))
+trim(string(greet))
+trim(string(half))
+trim(string(i))
+trim(string(i32))
+trim(string(i64))
+trim(string(list))
+trim(string(nil))
+trim(string(ok))
+trim(string(score))
+trim(string(true))
+trim(toBase64("bar"))
+trim(toBase64("foo"))
+trim(toJSON("foo"))
+trim(toJSON(0.5))
+trim(toJSON(1))
+trim(toJSON(array))
+trim(toJSON(f32))
+trim(toJSON(f64))
+trim(toJSON(false))
+trim(toJSON(foo))
+trim(toJSON(i))
+trim(toJSON(i32))
+trim(toJSON(i64))
+trim(toJSON(list))
+trim(toJSON(nil))
+trim(toJSON(ok))
+trim(toJSON(true))
+trim(trim("bar"))
+trim(trimPrefix("bar"))
+trim(trimPrefix("foo"))
+trim(trimPrefix(string(i)))
+trim(trimSuffix("bar"))
+trim(trimSuffix("foo"))
+trim(type("foo"))
+trim(type(0.5))
+trim(type(1))
+trim(type(add))
+trim(type(array))
+trim(type(div))
+trim(type(f32))
+trim(type(f64))
+trim(type(false))
+trim(type(foo))
+trim(type(greet))
+trim(type(half))
+trim(type(i))
+trim(type(i32))
+trim(type(i64))
+trim(type(list))
+trim(type(nil != list))
+trim(type(nil))
+trim(type(ok))
+trim(type(score))
+trim(type(toJSON(1)))
+trim(type(true))
+trim(upper("bar"))
+trimPrefix("foo" + "foo")
+trimPrefix(foo.Bar)
+trimPrefix(foo.String())
+trimPrefix(foo?.Bar)
+trimPrefix(foo?.String())
+trimPrefix(greet("bar"))
+trimPrefix(greet("foo"))
+trimPrefix(greet(foo.String()))
+trimPrefix(lower("bar"))
+trimPrefix(lower("foo"))
+trimPrefix(ok ? "bar" : i64)
+trimPrefix(string("foo"))
+trimPrefix(string(0.5))
+trimPrefix(string(1))
+trimPrefix(string(add))
+trimPrefix(string(array))
+trimPrefix(string(div))
+trimPrefix(string(f32))
+trimPrefix(string(foo))
+trimPrefix(string(greet))
+trimPrefix(string(half))
+trimPrefix(string(i))
+trimPrefix(string(i32))
+trimPrefix(string(i64))
+trimPrefix(string(list))
+trimPrefix(string(nil))
+trimPrefix(string(ok))
+trimPrefix(string(score))
+trimPrefix(toBase64("bar"))
+trimPrefix(toBase64("foo"))
+trimPrefix(toJSON("bar"))
+trimPrefix(toJSON("foo"))
+trimPrefix(toJSON(0.5))
+trimPrefix(toJSON(1))
+trimPrefix(toJSON(array))
+trimPrefix(toJSON(f32))
+trimPrefix(toJSON(f64))
+trimPrefix(toJSON(false))
+trimPrefix(toJSON(foo))
+trimPrefix(toJSON(i))
+trimPrefix(toJSON(i32))
+trimPrefix(toJSON(i64))
+trimPrefix(toJSON(nil))
+trimPrefix(toJSON(true))
+trimPrefix(trim("bar"))
+trimPrefix(trim("foo"))
+trimPrefix(trimPrefix("bar"))
+trimPrefix(trimPrefix("foo"))
+trimPrefix(trimSuffix("bar"))
+trimPrefix(trimSuffix("foo"))
+trimPrefix(type("bar"))
+trimPrefix(type(0.5 == 0.5))
+trimPrefix(type(0.5))
+trimPrefix(type(1 == f64))
+trimPrefix(type(1))
+trimPrefix(type(add))
+trimPrefix(type(array))
+trimPrefix(type(div))
+trimPrefix(type(f32))
+trimPrefix(type(f64))
+trimPrefix(type(false))
+trimPrefix(type(foo))
+trimPrefix(type(greet))
+trimPrefix(type(half))
+trimPrefix(type(i))
+trimPrefix(type(i32))
+trimPrefix(type(i64))
+trimPrefix(type(list))
+trimPrefix(type(nil))
+trimPrefix(type(ok))
+trimPrefix(type(score))
+trimPrefix(upper("foo"))
+trimSuffix("bar" + "bar")
+trimSuffix("foo") <= trimPrefix("foo")
+trimSuffix(foo.Bar)
+trimSuffix(foo.String())
+trimSuffix(foo?.Bar)
+trimSuffix(foo?.Qux("bar"))
+trimSuffix(foo?.String())
+trimSuffix(greet("bar"))
+trimSuffix(greet("foo"))
+trimSuffix(greet(toJSON(i64)))
+trimSuffix(lower("bar"))
+trimSuffix(lower("foo"))
+trimSuffix(repeat("foo", i))
+trimSuffix(string("bar"))
+trimSuffix(string(0.5))
+trimSuffix(string(1))
+trimSuffix(string(add))
+trimSuffix(string(array))
+trimSuffix(string(f32))
+trimSuffix(string(f64))
+trimSuffix(string(false))
+trimSuffix(string(foo))
+trimSuffix(string(greet))
+trimSuffix(string(half))
+trimSuffix(string(i))
+trimSuffix(string(i32))
+trimSuffix(string(i64))
+trimSuffix(string(list))
+trimSuffix(string(nil))
+trimSuffix(string(score))
+trimSuffix(string(type("foo")))
+trimSuffix(toBase64("bar"))
+trimSuffix(toJSON("bar"))
+trimSuffix(toJSON(0.5))
+trimSuffix(toJSON(1))
+trimSuffix(toJSON(array))
+trimSuffix(toJSON(f64))
+trimSuffix(toJSON(false))
+trimSuffix(toJSON(first(array)))
+trimSuffix(toJSON(foo))
+trimSuffix(toJSON(i))
+trimSuffix(toJSON(i32))
+trimSuffix(toJSON(i64))
+trimSuffix(toJSON(list))
+trimSuffix(toJSON(nil))
+trimSuffix(toJSON(ok))
+trimSuffix(trim("bar"))
+trimSuffix(trim("foo"))
+trimSuffix(trimPrefix("bar"))
+trimSuffix(trimPrefix("foo"))
+trimSuffix(trimSuffix("foo"))
+trimSuffix(type("bar"))
+trimSuffix(type("foo"))
+trimSuffix(type(0.5))
+trimSuffix(type(1))
+trimSuffix(type(add))
+trimSuffix(type(array))
+trimSuffix(type(div))
+trimSuffix(type(f32))
+trimSuffix(type(f64))
+trimSuffix(type(false))
+trimSuffix(type(foo))
+trimSuffix(type(half))
+trimSuffix(type(i))
+trimSuffix(type(i32))
+trimSuffix(type(i64))
+trimSuffix(type(list))
+trimSuffix(type(nil))
+trimSuffix(type(ok))
+trimSuffix(type(true))
+trimSuffix(upper("bar"))
+trimSuffix(upper("foo"))
+true != nil || true != nil
+true == nil && ok
+true ? "bar" : 0.5 ^ i
+true ? "bar" : 1 <= 1 / 1
+true ? "bar" : i != i32
+true ? "foo" : foo?.Bar
+true ? 0.5 : foo.Qux
+true ? 1 : f64 + f32
+true ? 1 : nil == array
+true ? array : foo.Qux
+true ? array : foo.String
+true ? array : i32 / i32
+true ? array : nil != map(list, #)
+true ? array : nil != ok
+true ? f32 : f64 == i32
+true ? f64 : foo?.String
+true ? greet : 0.5 == i
+true ? i : 0.5 + i64
+true ? i : 0.5 >= i64
+true ? i32 : foo.Bar
+true ? i64 : foo.Bar
+true ? list : f64 / f64
+true ? nil : 0.5 != i32
+true ? nil : foo.Qux
+true ? nil : foo.String
+true ? nil : i32 .. i
+true ? nil : i64 ** -i
+true ? ok : f32 / f32
+true ? ok : f64 + f64
+true ? score : foo.Qux
+true ? true : f32 >= i64
+true ? true : foo?.String
+true and ok and ok
+true || 1 not in array
+type(!false)
+type(!ok)
+type(!true)
+type("bar" != nil)
+type("bar" + "foo")
+type("bar" < "bar")
+type("bar" <= "bar")
+type("bar" <= "foo")
+type("bar" == nil)
+type("bar" > "foo")
+type("bar" endsWith "foo")
+type("bar" matches "bar")
+type("bar" matches "foo")
+type("bar" not contains "bar")
+type("bar" not endsWith "bar")
+type("bar" not endsWith "foo")
+type("bar" startsWith "foo")
+type("bar") == string(array)
+type("foo" != "bar")
+type("foo" == "foo")
+type("foo" > "bar")
+type("foo" contains "foo")
+type("foo" endsWith "foo")
+type("foo" in foo)
+type("foo" not endsWith "bar")
+type("foo" not endsWith "foo")
+type("foo" startsWith "foo")
+type("foo" startsWith foo.Bar)
+type(-0.5)
+type(-1)
+type(-f32)
+type(-f64)
+type(-i)
+type(-i32)
+type(-i64)
+type(0.5 != 0.5)
+type(0.5 != 1)
+type(0.5 != i)
+type(0.5 != i32)
+type(0.5 != nil)
+type(0.5 * 0.5)
+type(0.5 * 1)
+type(0.5 * i)
+type(0.5 * i32)
+type(0.5 * i64)
+type(0.5 ** 0.5)
+type(0.5 ** 1)
+type(0.5 ** f32)
+type(0.5 ** i)
+type(0.5 ** i32)
+type(0.5 ** i64)
+type(0.5 + f32)
+type(0.5 + i32)
+type(0.5 + i64)
+type(0.5 - 0.5)
+type(0.5 - i)
+type(0.5 / 0.5)
+type(0.5 / 1)
+type(0.5 / f64)
+type(0.5 / i)
+type(0.5 < 1)
+type(0.5 < f64)
+type(0.5 < i)
+type(0.5 < i64)
+type(0.5 <= 1)
+type(0.5 <= f32)
+type(0.5 <= i)
+type(0.5 <= i64)
+type(0.5 == 1)
+type(0.5 == i)
+type(0.5 == nil)
+type(0.5 > 0.5)
+type(0.5 > 1)
+type(0.5 > f64)
+type(0.5 > i)
+type(0.5 >= 0.5)
+type(0.5 >= 1)
+type(0.5 >= f64)
+type(0.5 >= i)
+type(0.5 >= i32)
+type(0.5 ^ 0.5)
+type(0.5 ^ 1)
+type(0.5 ^ f32)
+type(0.5 ^ f64)
+type(0.5 ^ i)
+type(0.5) not contains trimPrefix("bar")
+type(0.5) not in foo
+type(0.5) startsWith "bar" == nil
+type(0.5)[i32:i64]
+type(1 != 0.5)
+type(1 != 1)
+type(1 != f32)
+type(1 != i32)
+type(1 != nil)
+type(1 % 1)
+type(1 % i)
+type(1 % i32)
+type(1 % i64)
+type(1 * 1)
+type(1 * f32)
+type(1 * i)
+type(1 * i64)
+type(1 ** 0.5)
+type(1 ** 1)
+type(1 ** f64)
+type(1 ** i32)
+type(1 ** i64)
+type(1 + 0.5)
+type(1 + f32)
+type(1 + f64)
+type(1 + i64)
+type(1 - 0.5)
+type(1 - 1)
+type(1 - f64)
+type(1 - i32)
+type(1 .. 1)
+type(1 .. i)
+type(1 .. i64)
+type(1 / 1)
+type(1 / f32)
+type(1 / f64)
+type(1 < 1)
+type(1 < f32)
+type(1 < i)
+type(1 <= f32)
+type(1 <= f64)
+type(1 <= i32)
+type(1 <= i64)
+type(1 == 1)
+type(1 == i)
+type(1 == i64)
+type(1 == nil)
+type(1 > 0.5)
+type(1 > 1)
+type(1 > f32)
+type(1 > f64)
+type(1 >= 0.5)
+type(1 >= 1)
+type(1 >= f64)
+type(1 >= i)
+type(1 >= i32)
+type(1 >= i64)
+type(1 ^ 0.5)
+type(1 ^ f32)
+type(1 ^ i64)
+type(1 in array)
+type(1 not in array)
+type(1) != toJSON(0.5)
+type(1) == nil ? 1 : f64
+type(1) endsWith greet("foo")
+type(1) in foo
+type(1) in foo != true
+type(1) not contains type(nil)
+type(1) not endsWith toJSON(ok)
+type([half, 1])
+type([nil])
+type(abs(0.5))
+type(abs(1))
+type(abs(f64))
+type(abs(i))
+type(abs(i32))
+type(abs(i64))
+type(add != add)
+type(add != greet)
+type(add != half)
+type(add == half)
+type(add == nil)
+type(add(1, 1))
+type(add)
+type(add) in foo
+type(all(array, true))
+type(all(list, false))
+type(any(array, false))
+type(any(list, true))
+type(array == array)
+type(array == list)
+type(array)
+type(array) in foo
+type(array) not in foo
+type(array[1])
+type(array[i32])
+type(array[i])
+type(count(list, ok))
+type(count(list, true))
+type(div != div)
+type(div != half)
+type(div != nil)
+type(div == add)
+type(div == greet)
+type(div == half)
+type(div)
+type(div) not in foo
+type(f32 != 0.5)
+type(f32 != 1)
+type(f32 != f32)
+type(f32 != i32)
+type(f32 * 0.5)
+type(f32 * 1)
+type(f32 * f32)
+type(f32 * f64)
+type(f32 * i)
+type(f32 * i64)
+type(f32 ** 0.5)
+type(f32 ** 1)
+type(f32 ** f32)
+type(f32 ** i)
+type(f32 ** i32)
+type(f32 + 0.5)
+type(f32 + 1)
+type(f32 + f64)
+type(f32 + i)
+type(f32 + i64)
+type(f32 - 0.5)
+type(f32 - 1)
+type(f32 - f32)
+type(f32 - i)
+type(f32 - i32)
+type(f32 - i64)
+type(f32 < 1)
+type(f32 < f64)
+type(f32 < i32)
+type(f32 <= 0.5)
+type(f32 <= 1)
+type(f32 <= i64)
+type(f32 == 0.5)
+type(f32 == 1)
+type(f32 == i32)
+type(f32 > 1)
+type(f32 > f32)
+type(f32 > f64)
+type(f32 >= 0.5)
+type(f32 ^ 0.5)
+type(f32 ^ f32)
+type(f32 ^ f64)
+type(f32 ^ i32)
+type(f32 ^ i64)
+type(f32)
+type(f64 != f64)
+type(f64 != i64)
+type(f64 * 0.5)
+type(f64 * 1)
+type(f64 * i32)
+type(f64 * i64)
+type(f64 ** 0.5)
+type(f64 ** 1)
+type(f64 ** f32)
+type(f64 ** i)
+type(f64 ** i32)
+type(f64 + 0.5)
+type(f64 + f64)
+type(f64 + i)
+type(f64 - 0.5)
+type(f64 - f32)
+type(f64 - f64)
+type(f64 - i)
+type(f64 / 1)
+type(f64 / i)
+type(f64 < 0.5)
+type(f64 < 1)
+type(f64 < f64)
+type(f64 < i64)
+type(f64 <= 0.5)
+type(f64 <= i)
+type(f64 <= i32)
+type(f64 == 1)
+type(f64 == f64)
+type(f64 == nil)
+type(f64 > 1)
+type(f64 > f64)
+type(f64 > i)
+type(f64 > i32)
+type(f64 >= 0.5)
+type(f64 >= 1)
+type(f64 ^ 1)
+type(f64 ^ f64)
+type(f64 ^ i)
+type(f64 ^ i32)
+type(f64 ^ i64)
+type(f64)
+type(false != nil)
+type(false && true)
+type(false == ok)
+type(false ? add : div)
+type(false ? half : i)
+type(false ? half : i32)
+type(false ? i32 : 1)
+type(false ? i32 : true)
+type(false ? list : "foo")
+type(false || ok)
+type(false) not contains toJSON(i)
+type(filter(array, true))
+type(filter(list, false))
+type(find([f64], "foo" == nil))
+type(find(array, false))
+type(find(list, false))
+type(findIndex(array, false))
+type(findIndex(list, ok))
+type(findIndex(list, true))
+type(findLast(array, false))
+type(findLast(array, ok))
+type(findLast(list, false))
+type(findLastIndex(array, ok))
+type(findLastIndex(array, true))
+type(findLastIndex(list, ok))
+type(first(array))
+type(first(list))
+type(float(0.5))
+type(float(1))
+type(float(f32))
+type(float(f64))
+type(float(i))
+type(float(i32))
+type(float(i64))
+type(foo != foo)
+type(foo in list)
+type(foo)
+type(foo) in foo
+type(foo.Bar)
+type(foo.Qux)
+type(foo.String())
+type(foo.String)
+type(foo?.Bar)
+type(foo?.Qux)
+type(foo?.String())
+type(foo?.String)
+type(get(array, 1))
+type(get(array, i))
+type(get(array, i32))
+type(get(list, 1))
+type(get(list, i32))
+type(greet != div)
+type(greet != half)
+type(greet != score)
+type(greet == div)
+type(greet == greet)
+type(greet == half)
+type(greet("bar"))
+type(greet("foo"))
+type(greet(lower("foo")))
+type(greet)
+type(greet) not in foo
+type(half != add)
+type(half != nil)
+type(half == add)
+type(half == div)
+type(half(0.5))
+type(half(f64))
+type(half)
+type(half) endsWith toJSON(1)
+type(i != 0.5)
+type(i != 1)
+type(i != f32)
+type(i != i64)
+type(i % 1)
+type(i * 0.5)
+type(i * i64)
+type(i ** 0.5)
+type(i ** 1)
+type(i ** f32)
+type(i ** f64)
+type(i ** i)
+type(i ** i32)
+type(i + 1)
+type(i + i)
+type(i + i32)
+type(i .. i64)
+type(i / 0.5)
+type(i / 1)
+type(i < f32)
+type(i < i64)
+type(i == f32)
+type(i == i32)
+type(i == i64)
+type(i > f64)
+type(i >= 1)
+type(i >= f32)
+type(i >= f64)
+type(i ^ 0.5)
+type(i ^ 1)
+type(i ^ f32)
+type(i ^ f64)
+type(i ^ i64)
+type(i not in array)
+type(i)
+type(i) not endsWith greet("foo")
+type(i32 != 0.5)
+type(i32 != 1)
+type(i32 != nil)
+type(i32 % 1)
+type(i32 % i64)
+type(i32 * 0.5)
+type(i32 * 1)
+type(i32 * i32)
+type(i32 * i64)
+type(i32 ** f32)
+type(i32 ** f64)
+type(i32 ** i)
+type(i32 + 1)
+type(i32 + f32)
+type(i32 + f64)
+type(i32 + i)
+type(i32 + i32)
+type(i32 + i64)
+type(i32 - f32)
+type(i32 - i32)
+type(i32 .. 1)
+type(i32 .. i)
+type(i32 / f64)
+type(i32 / i32)
+type(i32 < 1)
+type(i32 < f32)
+type(i32 < i)
+type(i32 < i64)
+type(i32 <= f64)
+type(i32 <= i32)
+type(i32 <= i64)
+type(i32 == 0.5)
+type(i32 == 1)
+type(i32 == f32)
+type(i32 == f64)
+type(i32 == i)
+type(i32 == i64)
+type(i32 > 0.5)
+type(i32 > 1)
+type(i32 > f64)
+type(i32 > i32)
+type(i32 >= 1)
+type(i32 >= f32)
+type(i32 >= i)
+type(i32 >= i32)
+type(i32 ^ 0.5)
+type(i32 ^ i)
+type(i32 ^ i32)
+type(i32 ^ i64)
+type(i32 in array)
+type(i32)
+type(i32) startsWith greet("foo")
+type(i64 != 1)
+type(i64 != array[i32])
+type(i64 != f32)
+type(i64 != i)
+type(i64 != nil)
+type(i64 % i)
+type(i64 % i64)
+type(i64 * 0.5)
+type(i64 * f32)
+type(i64 * f64)
+type(i64 * i64)
+type(i64 ** 1)
+type(i64 + 0.5)
+type(i64 + f64)
+type(i64 + i)
+type(i64 + i64)
+type(i64 - 0.5)
+type(i64 .. 1)
+type(i64 .. i32)
+type(i64 .. i64)
+type(i64 / 0.5)
+type(i64 / 1)
+type(i64 / i)
+type(i64 / i64)
+type(i64 < 1)
+type(i64 < f64)
+type(i64 < i)
+type(i64 < i64)
+type(i64 <= 1)
+type(i64 <= f32)
+type(i64 <= i64)
+type(i64 == i32)
+type(i64 == nil)
+type(i64 > f64)
+type(i64 >= 0.5)
+type(i64 >= f32)
+type(i64 >= i)
+type(i64 >= i64)
+type(i64 ^ 0.5)
+type(i64 ^ 1)
+type(i64 ^ f32)
+type(i64 ^ f64)
+type(i64 ^ i)
+type(i64 ^ i32)
+type(i64 in array)
+type(i64 not in array)
+type(i64)
+type(i64) != foo?.Bar
+type(i64) contains string(foo) ? i : array
+type(i64) not in foo
+type(i64) not startsWith lower("foo")
+type(int(0.5))
+type(int(1))
+type(int(f32))
+type(int(f64))
+type(int(i))
+type(int(i32))
+type(int(i64) <= f32)
+type(int(i64))
+type(last(array))
+type(last(list))
+type(len("bar"))
+type(len("foo"))
+type(len(array))
+type(len(list))
+type(list == array)
+type(list == nil)
+type(list)
+type(list[1])
+type(list[i32])
+type(list[i64])
+type(list[i])
+type(lower("bar"))
+type(lower("foo"))
+type(lower(string(nil)))
+type(map(array, "foo"))
+type(map(array, #))
+type(map(array, 0.5))
+type(map(array, add))
+type(map(array, array))
+type(map(array, false))
+type(map(array, foo))
+type(map(array, half))
+type(map(array, i))
+type(map(array, i64))
+type(map(array, ok))
+type(map(i .. i32, i64))
+type(map(list, #))
+type(map(list, 0.5))
+type(map(list, 1))
+type(map(list, array))
+type(map(list, f32))
+type(map(list, f64))
+type(map(list, foo))
+type(map(list, greet))
+type(map(list, i))
+type(map(list, list))
+type(map(list, ok))
+type(max(0.5))
+type(max(1))
+type(max(f32))
+type(max(f32, i32))
+type(max(f64))
+type(max(f64, 0.5))
+type(max(i))
+type(max(i32))
+type(max(i32, i64))
+type(max(i64))
+type(min(0.5))
+type(min(1))
+type(min(1, 0.5))
+type(min(1, 1, f32))
+type(min(f32))
+type(min(f64))
+type(min(i))
+type(min(i, 1))
+type(min(i32))
+type(min(i32, 0.5))
+type(min(i64))
+type(nil != "bar")
+type(nil != 0.5)
+type(nil != 1)
+type(nil != div)
+type(nil != f64)
+type(nil != false)
+type(nil != foo)
+type(nil != greet)
+type(nil != i32)
+type(nil != nil)
+type(nil != ok)
+type(nil == "bar")
+type(nil == "foo")
+type(nil == 0.5)
+type(nil == 1)
+type(nil == add)
+type(nil == array)
+type(nil == f32)
+type(nil == f64)
+type(nil == i)
+type(nil == i32)
+type(nil == nil)
+type(nil == ok)
+type(nil == score)
+type(nil == true)
+type(nil in array)
+type(nil not in array)
+type(nil) != type(1)
+type(none(array, ok))
+type(none(array, true))
+type(none(list, ok))
+type(none(list, true))
+type(not false)
+type(not ok)
+type(not true)
+type(ok != nil)
+type(ok == false)
+type(ok ? 0.5 : i32)
+type(ok ? 0.5 : list)
+type(ok ? 1 : f32)
+type(ok ? add : "bar")
+type(ok ? false : i64)
+type(ok ? foo : false)
+type(ok ? half : half)
+type(ok ? i32 : f64)
+type(ok ? i64 : "bar")
+type(ok ? list : "foo")
+type(ok ? ok : half)
+type(ok ? true : false)
+type(ok and ok)
+type(ok and true)
+type(ok or false)
+type(ok or true)
+type(ok || true)
+type(ok)
+type(ok) in foo
+type(ok) not matches string(i64)
+type(ok) not startsWith lower("bar")
+type(score != div)
+type(score != greet)
+type(score != half)
+type(score != nil)
+type(score == add)
+type(score == foo.String)
+type(score == greet)
+type(score == half)
+type(score == nil)
+type(score == score)
+type(score(1))
+type(score(i))
+type(score(i, 1))
+type(score)
+type(score) < foo?.Bar
+type(score) > string(score)
+type(score) in foo
+type(score) not contains type(1)
+type(sort(array))
+type(string("bar"))
+type(string("foo"))
+type(string(0.5))
+type(string(1))
+type(string(add))
+type(string(array))
+type(string(div))
+type(string(f64))
+type(string(false))
+type(string(foo))
+type(string(greet))
+type(string(half))
+type(string(i <= i32))
+type(string(i))
+type(string(i64))
+type(string(list))
+type(string(nil))
+type(string(ok))
+type(string(score))
+type(toBase64("foo"))
+type(toJSON("bar"))
+type(toJSON("foo"))
+type(toJSON(0.5 < i))
+type(toJSON(0.5))
+type(toJSON(1))
+type(toJSON(array))
+type(toJSON(f32))
+type(toJSON(f64))
+type(toJSON(false))
+type(toJSON(foo))
+type(toJSON(i32))
+type(toJSON(i64))
+type(toJSON(list))
+type(toJSON(nil))
+type(toJSON(ok))
+type(toJSON(true))
+type(trim("bar"))
+type(trim("foo"))
+type(trimPrefix("foo"))
+type(trimPrefix(toJSON(true)))
+type(trimSuffix("bar"))
+type(true == false)
+type(true == nil)
+type(true ? "bar" : 0.5)
+type(true ? div : 0.5)
+type(true ? f64 : array)
+type(true ? foo : foo)
+type(true ? foo : true)
+type(true ? greet : "foo")
+type(true ? list : ok)
+type(true ? nil : list)
+type(true ? nil : ok)
+type(true ? true : 1)
+type(true and true)
+type(true) endsWith toBase64("foo")
+type(type("bar"))
+type(type("foo"))
+type(type(0.5))
+type(type(1))
+type(type(add))
+type(type(array))
+type(type(div))
+type(type(f32))
+type(type(f64))
+type(type(false))
+type(type(foo))
+type(type(half))
+type(type(i))
+type(type(i32))
+type(type(i64))
+type(type(list))
+type(type(nil))
+type(type(ok))
+type(type(score))
+type(type(true))
+type(upper("bar"))
+type(upper("foo"))
+type({"bar": 0.5})
+type({"bar": 1})
+type({"bar": greet})
+type({"foo": 0.5, "bar": foo})
+type({"foo": div})
+type({"foo": i64})
+type({"foo": nil})
+upper("bar" + "foo")
+upper("bar") <= type(nil)
+upper("bar") contains lower("foo")
+upper("foo" + "bar")
+upper(false ? 0.5 : "foo")
+upper(foo.Bar)
+upper(foo.String())
+upper(foo?.Bar)
+upper(foo?.String())
+upper(greet("foo"))
+upper(greet(string(ok)))
+upper(lower("bar"))
+upper(ok ? "bar" : i)
+upper(string("bar"))
+upper(string("foo"))
+upper(string(0.5))
+upper(string(1))
+upper(string(array))
+upper(string(div))
+upper(string(f32))
+upper(string(f64))
+upper(string(foo))
+upper(string(greet))
+upper(string(half))
+upper(string(i))
+upper(string(i32))
+upper(string(i64))
+upper(string(list))
+upper(string(nil))
+upper(string(ok))
+upper(string(score))
+upper(string(string(0.5)))
+upper(string(true))
+upper(toBase64("foo"))
+upper(toJSON("foo"))
+upper(toJSON(0.5))
+upper(toJSON(1))
+upper(toJSON(array))
+upper(toJSON(f32))
+upper(toJSON(f64))
+upper(toJSON(false))
+upper(toJSON(foo))
+upper(toJSON(i))
+upper(toJSON(i32))
+upper(toJSON(i64))
+upper(toJSON(list))
+upper(toJSON(nil))
+upper(toJSON(ok))
+upper(toJSON(true))
+upper(trim("bar"))
+upper(trim("bar", "bar"))
+upper(trim("foo"))
+upper(trimPrefix("bar"))
+upper(trimPrefix("foo"))
+upper(trimSuffix("bar"))
+upper(trimSuffix("foo"))
+upper(true ? "bar" : f32)
+upper(true ? "foo" : i32)
+upper(type("bar"))
+upper(type("foo"))
+upper(type(0.5))
+upper(type(1))
+upper(type(add))
+upper(type(div))
+upper(type(f32))
+upper(type(f64))
+upper(type(false))
+upper(type(foo))
+upper(type(greet))
+upper(type(half))
+upper(type(i))
+upper(type(i64))
+upper(type(list))
+upper(type(nil))
+upper(type(score))
+upper(type(true))
+upper(upper("bar"))
+values({"bar": f32})
+values({"bar": greet})
+values({"bar": i64})
+values({"foo": 1})
+values({"foo": div})
+values({"foo": false})
+values({"foo": foo, "foo": ok})
+values({"foo": list, "bar": 1})
+{"bar": !false}
+{"bar": !true}
+{"bar": "bar", "foo": nil}?.String
+{"bar": "bar", "foo": score}.i
+{"bar": "bar", "foo": true}?.i?.foo
+{"bar": "bar"}.add
+{"bar": "bar"}.array
+{"bar": "bar"}.f32
+{"bar": "bar"}.f64
+{"bar": "bar"}.list
+{"bar": "bar"}.ok
+{"bar": "bar"}?.Bar
+{"bar": "bar"}?.greet
+{"bar": "bar"}?.half
+{"bar": "bar"}?.i
+{"bar": "foo", "foo": 0.5}.add
+{"bar": "foo", "foo": 1}.String?.ok
+{"bar": "foo", "foo": greet}.half
+{"bar": "foo", "foo": ok, "bar": f64}?.Bar
+{"bar": "foo", "foo": ok}.Qux
+{"bar": "foo", "foo": true}.ok
+{"bar": "foo"}.Qux
+{"bar": "foo"}.String
+{"bar": "foo"}.add
+{"bar": "foo"}.array
+{"bar": "foo"}.div
+{"bar": "foo"}.f32
+{"bar": "foo"}.i
+{"bar": "foo"}.i64
+{"bar": "foo"}.score
+{"bar": "foo"}?.Qux
+{"bar": "foo"}?.Qux?.score
+{"bar": "foo"}?.String
+{"bar": "foo"}?.div
+{"bar": "foo"}?.foo
+{"bar": "foo"}?.i32
+{"bar": "foo"}?.i64
+{"bar": -0.5}
+{"bar": -1}
+{"bar": -1}?.array
+{"bar": -f32}
+{"bar": 0.5 * f64}
+{"bar": 0.5 + 1}
+{"bar": 0.5 - i32}
+{"bar": 0.5 - i64}
+{"bar": 0.5 < i64}
+{"bar": 0.5 == nil}
+{"bar": 0.5 > 1}.Qux
+{"bar": 0.5, "bar": "bar"}.ok
+{"bar": 0.5, "bar": 0.5}.f32
+{"bar": 0.5, "bar": 1}?.half
+{"bar": 0.5, "foo": array}?.ok
+{"bar": 0.5, "foo": i32, "bar": add}?.Bar
+{"bar": 0.5}.Bar
+{"bar": 0.5}.Qux
+{"bar": 0.5}.String
+{"bar": 0.5}.add
+{"bar": 0.5}.div
+{"bar": 0.5}.div?.array.foo
+{"bar": 0.5}.f32
+{"bar": 0.5}.f64
+{"bar": 0.5}.foo
+{"bar": 0.5}.greet
+{"bar": 0.5}.i32
+{"bar": 0.5}.ok
+{"bar": 0.5}.score
+{"bar": 0.5}?.Bar
+{"bar": 0.5}?.String
+{"bar": 0.5}?.add
+{"bar": 0.5}?.array
+{"bar": 0.5}?.div
+{"bar": 0.5}?.f32
+{"bar": 0.5}?.foo
+{"bar": 0.5}?.greet?.i32
+{"bar": 0.5}?.half
+{"bar": 0.5}?.i
+{"bar": 0.5}?.i32
+{"bar": 0.5}?.i32?.i32
+{"bar": 0.5}?.i64
+{"bar": 1 * i32}
+{"bar": 1 * i}
+{"bar": 1 + i32}
+{"bar": 1 - f32}
+{"bar": 1 / 0.5}
+{"bar": 1 < f32}
+{"bar": 1 <= 1}
+{"bar": 1, "bar": "bar"}.i32
+{"bar": 1, "bar": array}?.f32
+{"bar": 1, "bar": false}.array
+{"bar": 1, "bar": greet, "foo": "bar"}?.i64
+{"bar": 1, "bar": i64}?.array
+{"bar": 1, "foo": 0.5}?.String
+{"bar": 1, "foo": add, "foo": f32}?.i
+{"bar": 1, "foo": foo}.div
+{"bar": 1, "foo": i64}.i64
+{"bar": 1}.Bar
+{"bar": 1}.Qux
+{"bar": 1}.String
+{"bar": 1}.add
+{"bar": 1}.div
+{"bar": 1}.f64
+{"bar": 1}.greet
+{"bar": 1}.half
+{"bar": 1}.i
+{"bar": 1}.ok
+{"bar": 1}?.Bar
+{"bar": 1}?.add
+{"bar": 1}?.add?.i32
+{"bar": 1}?.div?.list
+{"bar": 1}?.f32
+{"bar": 1}?.f64
+{"bar": 1}?.i
+{"bar": 1}?.i32
+{"bar": 1}?.ok
+{"bar": ["bar", score]}
+{"bar": add, "bar": "foo"}.String?.array
+{"bar": add, "bar": 1}?.i64
+{"bar": add, "bar": div}?.f32
+{"bar": add, "bar": foo}
+{"bar": add, "bar": list}.Bar
+{"bar": add, "bar": score}.f64?.f64
+{"bar": add, "foo": "foo"}.i64
+{"bar": add, "foo": f64}?.score
+{"bar": add, "foo": i32}?.half
+{"bar": add, "foo": ok}
+{"bar": add, "foo": score}
+{"bar": add}
+{"bar": add}.Qux
+{"bar": add}.String
+{"bar": add}.f64
+{"bar": add}.foo
+{"bar": add}.greet
+{"bar": add}.i32
+{"bar": add}.list
+{"bar": add}?.String
+{"bar": add}?.add
+{"bar": add}?.div
+{"bar": add}?.i
+{"bar": add}?.i64
+{"bar": add}?.score
+{"bar": any(array, false)}
+{"bar": any(list, ok)}
+{"bar": array, "bar": f64}
+{"bar": array, "bar": false, "bar": i}?.Qux
+{"bar": array, "bar": false}.Qux
+{"bar": array, "bar": half}.i32
+{"bar": array, "bar": i64}.i64
+{"bar": array, "bar": score}
+{"bar": array, "foo": "foo"}?.array
+{"bar": array, "foo": add == add}
+{"bar": array, "foo": count(list, true)}.add
+{"bar": array}
+{"bar": array}.Bar
+{"bar": array}.Qux
+{"bar": array}.String
+{"bar": array}.add
+{"bar": array}.f32
+{"bar": array}.half?.foo
+{"bar": array}.i
+{"bar": array}.i64
+{"bar": array}?.Bar
+{"bar": array}?.div
+{"bar": array}?.greet
+{"bar": array}?.half
+{"bar": array}?.i32
+{"bar": array}?.i64
+{"bar": array}?.ok
+{"bar": div != greet}
+{"bar": div, "bar": "bar", "bar": foo}.greet
+{"bar": div, "bar": "bar", "foo": 1}?.div
+{"bar": div, "bar": greet}?.i32
+{"bar": div, "bar": i32}?.array
+{"bar": div, "foo": div}?.list
+{"bar": div, "foo": greet, "foo": 1}?.score?.Qux
+{"bar": div, "foo": i}?.i
+{"bar": div, "foo": list}.f64
+{"bar": div, "foo": ok}?.i64
+{"bar": div, "foo": score}
+{"bar": div}
+{"bar": div}.add
+{"bar": div}.div
+{"bar": div}.f32
+{"bar": div}.f32?.score
+{"bar": div}.half
+{"bar": div}.i32
+{"bar": div}.i64
+{"bar": div}.score
+{"bar": div}?.div
+{"bar": div}?.div?.f32
+{"bar": div}?.foo
+{"bar": div}?.half
+{"bar": div}?.i
+{"bar": div}?.i64
+{"bar": div}?.list
+{"bar": div}?.ok
+{"bar": f32 ** 1}
+{"bar": f32 - i32}
+{"bar": f32, "bar": true, "bar": list}?.Bar
+{"bar": f32, "foo": i32}
+{"bar": f32, "foo": ok, "foo": f32}.half
+{"bar": f32, "foo": score}?.greet
+{"bar": f32}
+{"bar": f32}.Bar
+{"bar": f32}.Qux?.i64
+{"bar": f32}.String
+{"bar": f32}.add
+{"bar": f32}.half
+{"bar": f32}.list
+{"bar": f32}?.String?.score
+{"bar": f32}?.f64
+{"bar": f32}?.foo
+{"bar": f32}?.i32
+{"bar": f32}?.i64
+{"bar": f32}?.list
+{"bar": f32}?.score
+{"bar": f64, "bar": 0.5}.div
+{"bar": f64, "bar": i}
+{"bar": f64, "bar": nil}?.f64
+{"bar": f64, "foo": "foo"}?.half
+{"bar": f64, "foo": 0.5, "bar": foo}?.half
+{"bar": f64, "foo": f64}.foo
+{"bar": f64, "foo": i32}
+{"bar": f64}
+{"bar": f64}.String
+{"bar": f64}.div?.String()
+{"bar": f64}.f32
+{"bar": f64}.f64
+{"bar": f64}.f64?.list
+{"bar": f64}.greet
+{"bar": f64}.half
+{"bar": f64}.i
+{"bar": f64}.ok
+{"bar": f64}?.Bar
+{"bar": f64}?.Qux
+{"bar": f64}?.f64
+{"bar": f64}?.half
+{"bar": f64}?.i32
+{"bar": f64}?.i64
+{"bar": f64}?.score
+{"bar": false, "bar": 0.5, "bar": foo}.add
+{"bar": false, "foo": greet, "foo": i64}.div
+{"bar": false}.add
+{"bar": false}.div
+{"bar": false}.f64
+{"bar": false}.foo
+{"bar": false}.greet
+{"bar": false}.half
+{"bar": false}.i32
+{"bar": false}.list
+{"bar": false}.ok
+{"bar": false}.score
+{"bar": false}?.array
+{"bar": false}?.greet
+{"bar": false}?.i32
+{"bar": false}?.ok?.Qux?.score()
+{"bar": false}?.score
+{"bar": first(list)}
+{"bar": float(f32)}
+{"bar": foo, "bar": 0.5}.div
+{"bar": foo, "bar": div}.array
+{"bar": foo, "bar": half}
+{"bar": foo, "bar": list}.f32
+{"bar": foo, "foo": greet}?.div
+{"bar": foo, "foo": i32}.score
+{"bar": foo, "foo": true}?.f32
+{"bar": foo.Bar}
+{"bar": foo.String()}
+{"bar": foo?.Qux}?.foo
+{"bar": foo?.String}
+{"bar": foo}
+{"bar": foo}.Qux
+{"bar": foo}.String
+{"bar": foo}.array
+{"bar": foo}.div
+{"bar": foo}.f64
+{"bar": foo}.half
+{"bar": foo}.half?.list(i32).array
+{"bar": foo}.i
+{"bar": foo}.list
+{"bar": foo}.ok
+{"bar": foo}?.div
+{"bar": foo}?.f64
+{"bar": foo}?.greet
+{"bar": foo}?.i
+{"bar": foo}?.i64
+{"bar": foo}?.list
+{"bar": greet, "bar": foo}
+{"bar": greet, "bar": nil}.f64
+{"bar": greet, "foo": foo}
+{"bar": greet}
+{"bar": greet}.Qux
+{"bar": greet}.add
+{"bar": greet}.array
+{"bar": greet}.div
+{"bar": greet}.foo
+{"bar": greet}.i
+{"bar": greet}.i32
+{"bar": greet}.ok
+{"bar": greet}.score
+{"bar": greet}?.Bar
+{"bar": greet}?.String
+{"bar": greet}?.add
+{"bar": greet}?.f32
+{"bar": greet}?.foo?.foo
+{"bar": greet}?.half
+{"bar": greet}?.i
+{"bar": greet}?.list
+{"bar": greet}?.ok
+{"bar": half(0.5), "bar": ok}
+{"bar": half(0.5)}
+{"bar": half(0.5)}?.array
+{"bar": half, "bar": "foo", "bar": ok}?.String
+{"bar": half, "bar": array}?.div?.i32
+{"bar": half, "bar": div}
+{"bar": half, "bar": f32}
+{"bar": half, "bar": greet}?.i64
+{"bar": half, "bar": list}
+{"bar": half, "bar": score, "bar": i == f32}
+{"bar": half, "bar": score}
+{"bar": half, "foo": array}
+{"bar": half, "foo": f64 == i64}
+{"bar": half, "foo": greet}
+{"bar": half, "foo": i64}.array
+{"bar": half, "foo": list}?.list?.ok
+{"bar": half}
+{"bar": half}.String
+{"bar": half}.String?.score
+{"bar": half}.half
+{"bar": half}.i32
+{"bar": half}.i64
+{"bar": half}.ok
+{"bar": half}.score
+{"bar": half}?.Qux
+{"bar": half}?.Qux?.f32
+{"bar": half}?.div
+{"bar": half}?.f32
+{"bar": half}?.foo?.f32()
+{"bar": half}?.half
+{"bar": half}?.half?.f32
+{"bar": half}?.i
+{"bar": i ** 0.5}
+{"bar": i + i64}
+{"bar": i .. i32}
+{"bar": i .. i}
+{"bar": i > i32}
+{"bar": i >= 0.5, "bar": array}
+{"bar": i >= i}
+{"bar": i, "bar": 0.5}?.Qux
+{"bar": i, "bar": foo}.foo
+{"bar": i, "bar": nil}?.f32
+{"bar": i, "foo": 1 >= f64}
+{"bar": i, "foo": array}.array
+{"bar": i, "foo": f64}.i64
+{"bar": i, "foo": greet}?.foo
+{"bar": i32 + 0.5}
+{"bar": i32 < i32}
+{"bar": i32 <= f64}
+{"bar": i32, "bar": "foo"}?.half
+{"bar": i32, "foo": f64}?.foo
+{"bar": i32, "foo": foo, "foo": i32}?.i32?.String()
+{"bar": i32, "foo": i64, "bar": true}?.i64
+{"bar": i32, "foo": i64}.half
+{"bar": i32, "foo": list}
+{"bar": i32, "foo": score, "foo": 1}.array
+{"bar": i32, "foo": score, "foo": greet}.add
+{"bar": i32, "foo": score, "foo": ok}.foo
+{"bar": i32}
+{"bar": i32}.Bar
+{"bar": i32}.i
+{"bar": i32}.i64
+{"bar": i32}.list
+{"bar": i32}.score?.f32
+{"bar": i32}?.String
+{"bar": i32}?.div
+{"bar": i32}?.f32
+{"bar": i32}?.foo
+{"bar": i32}?.greet
+{"bar": i32}?.half
+{"bar": i32}?.i
+{"bar": i32}?.list?.list
+{"bar": i32}?.ok
+{"bar": i32}?.score
+{"bar": i64 != f32, "bar": score}
+{"bar": i64 ** f64}
+{"bar": i64 / f64}
+{"bar": i64, "bar": "bar", "foo": i64}.array
+{"bar": i64, "bar": foo}.list
+{"bar": i64, "bar": greet, "foo": score}.array
+{"bar": i64, "bar": half}?.f64
+{"bar": i64, "bar": i64}?.Qux?.array()
+{"bar": i64, "bar": list}
+{"bar": i64, "foo": "foo"}.Bar
+{"bar": i64, "foo": 0.5, "foo": list}.i64
+{"bar": i64, "foo": f32, "foo": nil}.i32
+{"bar": i64, "foo": f32}?.half
+{"bar": i64, "foo": i, "foo": greet}.array
+{"bar": i64, "foo": nil}.add
+{"bar": i64, "foo": nil}?.Qux
+{"bar": i64}
+{"bar": i64}.add
+{"bar": i64}.array
+{"bar": i64}.div
+{"bar": i64}.div?.i64
+{"bar": i64}.f32
+{"bar": i64}.foo
+{"bar": i64}.greet
+{"bar": i64}.i64
+{"bar": i64}.list
+{"bar": i64}.ok
+{"bar": i64}?.Qux
+{"bar": i64}?.String
+{"bar": i64}?.array
+{"bar": i64}?.array?.foo
+{"bar": i64}?.div
+{"bar": i64}?.f32
+{"bar": i64}?.i64
+{"bar": i64}?.list
+{"bar": i64}?.ok
+{"bar": i64}?.score
+{"bar": i}
+{"bar": i}.Bar
+{"bar": i}.String
+{"bar": i}.array
+{"bar": i}.div
+{"bar": i}.f64
+{"bar": i}.foo
+{"bar": i}.greet
+{"bar": i}.half
+{"bar": i}.i
+{"bar": i}.i32
+{"bar": i}.i64
+{"bar": i}.list?.list
+{"bar": i}?.Qux
+{"bar": i}?.String
+{"bar": i}?.add
+{"bar": i}?.foo
+{"bar": i}?.greet
+{"bar": i}?.list
+{"bar": list, "bar": 1}?.f64
+{"bar": list, "bar": div}
+{"bar": list, "bar": f32, "bar": i64}.Bar
+{"bar": list, "bar": f32, "bar": ok}.add
+{"bar": list, "bar": f64}.foo
+{"bar": list, "bar": false, "bar": 1}?.f32
+{"bar": list, "bar": i32}.half
+{"bar": list, "bar": ok}
+{"bar": list, "foo": div, "foo": ok}?.i64
+{"bar": list, "foo": f64, "foo": list}.half
+{"bar": list, "foo": half}?.Qux
+{"bar": list, "foo": i}
+{"bar": list, "foo": list}
+{"bar": list, "foo": ok, "foo": f64}?.half
+{"bar": list}
+{"bar": list}.Bar
+{"bar": list}.add
+{"bar": list}.f32
+{"bar": list}.f64
+{"bar": list}.greet
+{"bar": list}.score
+{"bar": list}?.add
+{"bar": list}?.add?.array
+{"bar": list}?.div
+{"bar": list}?.half
+{"bar": list}?.i32
+{"bar": list}?.list
+{"bar": list}?.score
+{"bar": map(list, i32)}
+{"bar": min(0.5)}
+{"bar": min(f32)}
+{"bar": nil != "bar"}
+{"bar": nil != false}
+{"bar": nil == "foo"}
+{"bar": nil == 1}
+{"bar": nil == f64}
+{"bar": nil, "bar": div}.f32
+{"bar": nil, "bar": greet, "foo": "bar"}?.i64
+{"bar": nil, "bar": greet}.score
+{"bar": nil, "bar": i}.f64
+{"bar": nil, "foo": 0.5}?.array
+{"bar": nil, "foo": f64}?.add
+{"bar": nil, "foo": half}?.foo
+{"bar": nil}.String
+{"bar": nil}.add
+{"bar": nil}.array
+{"bar": nil}.f32
+{"bar": nil}.foo
+{"bar": nil}.half
+{"bar": nil}?.Bar
+{"bar": nil}?.add
+{"bar": nil}?.array
+{"bar": nil}?.f32
+{"bar": nil}?.f64
+{"bar": nil}?.foo
+{"bar": nil}?.foo?.i32
+{"bar": nil}?.greet
+{"bar": nil}?.half
+{"bar": nil}?.i32
+{"bar": nil}?.i64
+{"bar": nil}?.list
+{"bar": nil}?.ok
+{"bar": ok or ok}
+{"bar": ok || ok}
+{"bar": ok, "bar": list}
+{"bar": ok, "bar": nil == half}.f64
+{"bar": ok, "foo": div, "bar": "bar"}.Qux
+{"bar": ok, "foo": i32, "bar": 1}.score
+{"bar": ok}
+{"bar": ok}.String
+{"bar": ok}.add
+{"bar": ok}.array
+{"bar": ok}.i
+{"bar": ok}.i64
+{"bar": ok}.ok
+{"bar": ok}?.Qux
+{"bar": ok}?.array
+{"bar": ok}?.f64
+{"bar": ok}?.foo
+{"bar": ok}?.greet
+{"bar": ok}?.i
+{"bar": ok}?.i32
+{"bar": ok}?.i64
+{"bar": score != score}
+{"bar": score, "bar": 0.5}?.Bar
+{"bar": score, "bar": div}
+{"bar": score, "bar": foo}
+{"bar": score, "bar": i64}.div
+{"bar": score, "bar": i}
+{"bar": score, "foo": greet}
+{"bar": score}
+{"bar": score}.Bar
+{"bar": score}.add
+{"bar": score}.array
+{"bar": score}.div
+{"bar": score}.f64
+{"bar": score}.i32
+{"bar": score}.i64
+{"bar": score}.list
+{"bar": score}.ok
+{"bar": score}.score
+{"bar": score}?.f32
+{"bar": score}?.f64
+{"bar": score}?.i32
+{"bar": score}?.list
+{"bar": score}?.score
+{"bar": string(array)}
+{"bar": toJSON(array)}
+{"bar": toJSON(i)}.i64?.i64
+{"bar": toJSON(i32)}
+{"bar": true, "bar": false}.Bar
+{"bar": true, "bar": foo}?.String
+{"bar": true, "foo": 0.5}?.i
+{"bar": true, "foo": div}.score
+{"bar": true, "foo": foo}.div
+{"bar": true}.Bar
+{"bar": true}.Qux?.greet()
+{"bar": true}.f32
+{"bar": true}.f64
+{"bar": true}.half
+{"bar": true}.i
+{"bar": true}.list?.String()
+{"bar": true}.score
+{"bar": true}?.Bar
+{"bar": true}?.i64
+{"bar": true}?.list
+{"bar": type(f64)}
+{"bar": type(greet)}
+{"bar": {"foo": "bar", "bar": "bar", "bar": nil}}
+{"foo": "bar", "bar": i32}.half
+{"foo": "bar", "bar": nil}?.add?.i64
+{"foo": "bar"}.Bar
+{"foo": "bar"}.Qux
+{"foo": "bar"}.String
+{"foo": "bar"}.array
+{"foo": "bar"}.f64
+{"foo": "bar"}.half
+{"foo": "bar"}.i
+{"foo": "bar"}.i64
+{"foo": "bar"}.list
+{"foo": "bar"}.ok
+{"foo": "bar"}?.add
+{"foo": "bar"}?.div?.ok
+{"foo": "bar"}?.f64
+{"foo": "bar"}?.foo
+{"foo": "bar"}?.half
+{"foo": "foo" != "bar"}
+{"foo": "foo", "bar": nil}?.String
+{"foo": "foo", "foo": add, "foo": "foo"}?.i
+{"foo": "foo", "foo": div}.i64
+{"foo": "foo", "foo": greet}.array
+{"foo": "foo", "foo": i, "bar": greet}?.score
+{"foo": "foo", "foo": i32, "bar": f32}.greet
+{"foo": "foo", "foo": i}?.foo
+{"foo": "foo", "foo": list}.f32
+{"foo": "foo"}.Bar
+{"foo": "foo"}.array
+{"foo": "foo"}.f32
+{"foo": "foo"}.foo
+{"foo": "foo"}.greet
+{"foo": "foo"}.i64
+{"foo": "foo"}?.Bar
+{"foo": "foo"}?.add
+{"foo": "foo"}?.div
+{"foo": "foo"}?.greet
+{"foo": "foo"}?.half
+{"foo": "foo"}?.score
+{"foo": -1}
+{"foo": -i64}
+{"foo": -i}
+{"foo": 0.5 ** i64}
+{"foo": 0.5 - 0.5}
+{"foo": 0.5 <= 0.5}
+{"foo": 0.5 > i64}
+{"foo": 0.5, "bar": 1}.half
+{"foo": 0.5, "bar": add}.Bar
+{"foo": 0.5, "bar": div}.array
+{"foo": 0.5, "bar": i32}?.String
+{"foo": 0.5, "bar": score, "foo": score}.half
+{"foo": 0.5, "foo": 1, "foo": list}.div
+{"foo": 0.5, "foo": nil}?.div
+{"foo": 0.5, "foo": nil}?.i64
+{"foo": 0.5}.Bar
+{"foo": 0.5}.Qux
+{"foo": 0.5}.array
+{"foo": 0.5}.f32
+{"foo": 0.5}.f64
+{"foo": 0.5}.greet
+{"foo": 0.5}.half
+{"foo": 0.5}.i
+{"foo": 0.5}.i64
+{"foo": 0.5}.list
+{"foo": 0.5}.ok
+{"foo": 0.5}?.Bar?.i
+{"foo": 0.5}?.String
+{"foo": 0.5}?.add
+{"foo": 0.5}?.array
+{"foo": 0.5}?.array?.score
+{"foo": 0.5}?.foo
+{"foo": 0.5}?.greet
+{"foo": 0.5}?.half
+{"foo": 0.5}?.i64
+{"foo": 0.5}?.ok
+{"foo": 1 + 0.5}
+{"foo": 1 / 0.5}
+{"foo": 1 / i64}
+{"foo": 1 < i32}?.i64
+{"foo": 1 not in array}
+{"foo": 1, "bar": 0.5}.array
+{"foo": 1, "bar": div}.f32
+{"foo": 1, "bar": f32}.Qux?.half?.list
+{"foo": 1, "bar": i64, "foo": 0.5}.list
+{"foo": 1, "bar": i64}?.ok
+{"foo": 1, "bar": score}.foo
+{"foo": 1, "foo": 0.5}.f32
+{"foo": 1, "foo": array}?.array
+{"foo": 1, "foo": ok}.add
+{"foo": 1, "foo": true}?.Qux
+{"foo": 1}.add
+{"foo": 1}.f32
+{"foo": 1}.foo
+{"foo": 1}.greet
+{"foo": 1}.half
+{"foo": 1}.i64
+{"foo": 1}.list
+{"foo": 1}.ok
+{"foo": 1}?.Bar
+{"foo": 1}?.add
+{"foo": 1}?.div
+{"foo": 1}?.f32
+{"foo": 1}?.foo
+{"foo": 1}?.greet
+{"foo": 1}?.half
+{"foo": 1}?.i
+{"foo": 1}?.i32
+{"foo": 1}?.score
+{"foo": abs(0.5)}
+{"foo": add, "bar": 0.5}.i
+{"foo": add, "bar": nil}.score
+{"foo": add, "bar": ok}
+{"foo": add, "bar": score}.half
+{"foo": add, "foo": "bar"}?.String
+{"foo": add, "foo": half, "foo": div}?.greet
+{"foo": add, "foo": i32}.foo
+{"foo": add, "foo": nil}?.list
+{"foo": add}
+{"foo": add}.Bar
+{"foo": add}.div
+{"foo": add}.foo
+{"foo": add}.half
+{"foo": add}.i
+{"foo": add}.i64
+{"foo": add}.list
+{"foo": add}.ok
+{"foo": add}?.String
+{"foo": add}?.array
+{"foo": add}?.div
+{"foo": add}?.greet
+{"foo": add}?.half
+{"foo": add}?.i32
+{"foo": add}?.ok
+{"foo": array, "bar": "foo"}?.f32
+{"foo": array, "bar": f64}
+{"foo": array, "bar": greet}
+{"foo": array, "bar": list}?.f32
+{"foo": array, "bar": ok}
+{"foo": array, "foo": add}
+{"foo": array, "foo": greet}
+{"foo": array, "foo": true}?.i
+{"foo": array}
+{"foo": array}.Qux
+{"foo": array}.Qux?.String
+{"foo": array}.String
+{"foo": array}.f64
+{"foo": array}.greet
+{"foo": array}.i32
+{"foo": array}.ok
+{"foo": array}?.Bar
+{"foo": array}?.String
+{"foo": array}?.add
+{"foo": array}?.array
+{"foo": array}?.div
+{"foo": array}?.f64
+{"foo": array}?.half
+{"foo": array}?.ok
+{"foo": div, "bar": 1}?.add
+{"foo": div, "bar": add}
+{"foo": div, "bar": div}
+{"foo": div, "bar": half}.half
+{"foo": div, "bar": list, "bar": 0.5}?.Qux
+{"foo": div, "foo": array}.Bar
+{"foo": div, "foo": true}?.Qux
+{"foo": div}
+{"foo": div}.Qux
+{"foo": div}.array
+{"foo": div}.div
+{"foo": div}.foo
+{"foo": div}.greet
+{"foo": div}?.Bar
+{"foo": div}?.Qux
+{"foo": div}?.String
+{"foo": div}?.add
+{"foo": div}?.f64
+{"foo": div}?.half
+{"foo": div}?.i
+{"foo": div}?.i64
+{"foo": div}?.list
+{"foo": div}?.ok
+{"foo": f32 != i}
+{"foo": f32 - f32}
+{"foo": f32 == 0.5}
+{"foo": f32, "bar": "bar"}?.String
+{"foo": f32, "bar": 0.5}.f32
+{"foo": f32, "bar": i32}
+{"foo": f32, "bar": list}
+{"foo": f32, "foo": 1, "foo": i32}?.i32
+{"foo": f32, "foo": div}
+{"foo": f32, "foo": i}
+{"foo": f32, "foo": ok}?.i
+{"foo": f32, "foo": type("bar")}
+{"foo": f32}
+{"foo": f32}.String
+{"foo": f32}.add
+{"foo": f32}.array
+{"foo": f32}.f32
+{"foo": f32}.foo
+{"foo": f32}.greet
+{"foo": f32}.half
+{"foo": f32}.i
+{"foo": f32}.i32
+{"foo": f32}.list
+{"foo": f32}?.Bar
+{"foo": f32}?.Qux
+{"foo": f32}?.add
+{"foo": f32}?.f32
+{"foo": f32}?.f64
+{"foo": f32}?.half
+{"foo": f32}?.i32
+{"foo": f32}?.score
+{"foo": f64 * i}
+{"foo": f64 / 1}
+{"foo": f64 == 0.5}
+{"foo": f64 >= 1}
+{"foo": f64 ^ f32}
+{"foo": f64, "bar": "foo"}.Qux
+{"foo": f64, "bar": "foo"}.add
+{"foo": f64, "bar": 0.5}.div
+{"foo": f64, "bar": div}
+{"foo": f64, "bar": greet}
+{"foo": f64, "bar": half}?.list
+{"foo": f64, "bar": ok}.half
+{"foo": f64, "foo": foo, "bar": greet}.String
+{"foo": f64, "foo": foo, "foo": "foo"}.Bar
+{"foo": f64, "foo": greet}
+{"foo": f64, "foo": ok, "foo": i64}?.f64
+{"foo": f64}
+{"foo": f64}.Qux
+{"foo": f64}.String?.f32
+{"foo": f64}.String?.i64
+{"foo": f64}.add
+{"foo": f64}.array
+{"foo": f64}.f64
+{"foo": f64}.foo
+{"foo": f64}.greet
+{"foo": f64}.i
+{"foo": f64}.list
+{"foo": f64}?.Bar
+{"foo": f64}?.String
+{"foo": f64}?.div
+{"foo": f64}?.f32
+{"foo": f64}?.f64
+{"foo": f64}?.foo
+{"foo": f64}?.greet
+{"foo": f64}?.i
+{"foo": f64}?.ok
+{"foo": false, "foo": greet}?.add
+{"foo": false, "foo": ok}.score
+{"foo": false}.Bar
+{"foo": false}.array
+{"foo": false}.div
+{"foo": false}.half
+{"foo": false}.i
+{"foo": false}?.array
+{"foo": false}?.f32
+{"foo": false}?.f64
+{"foo": false}?.foo
+{"foo": false}?.i64
+{"foo": false}?.list
+{"foo": foo, "bar": add, "foo": foo}.Bar
+{"foo": foo, "bar": ok, "foo": array}.String
+{"foo": foo, "foo": foo}
+{"foo": foo, "foo": list, "foo": greet}.i
+{"foo": foo, "foo": nil}?.f32
+{"foo": foo, "foo": true}?.array
+{"foo": foo?.Qux}
+{"foo": foo}
+{"foo": foo}.div
+{"foo": foo}.f64
+{"foo": foo}.greet
+{"foo": foo}.list
+{"foo": foo}.ok
+{"foo": foo}.score
+{"foo": foo}?.String
+{"foo": foo}?.array
+{"foo": foo}?.div
+{"foo": foo}?.f32
+{"foo": foo}?.foo
+{"foo": foo}?.greet
+{"foo": foo}?.half
+{"foo": foo}?.list
+{"foo": foo}?.ok
+{"foo": get(array, i32)}?.i64
+{"foo": greet, "bar": 0.5, "bar": "foo"}?.half
+{"foo": greet, "bar": 0.5}.Bar
+{"foo": greet, "bar": f64}
+{"foo": greet, "bar": f64}.list
+{"foo": greet, "bar": i, "foo": foo}?.f32
+{"foo": greet, "foo": "bar", "foo": score}.i
+{"foo": greet, "foo": f32}
+{"foo": greet}
+{"foo": greet}.Qux
+{"foo": greet}.String
+{"foo": greet}.add
+{"foo": greet}.array
+{"foo": greet}.f32?.greet
+{"foo": greet}.half?.greet
+{"foo": greet}.i64
+{"foo": greet}.list
+{"foo": greet}.ok
+{"foo": greet}?.add
+{"foo": greet}?.array
+{"foo": greet}?.f32
+{"foo": greet}?.half
+{"foo": greet}?.i32
+{"foo": greet}?.i64
+{"foo": greet}?.list
+{"foo": greet}?.score
+{"foo": half(0.5)}
+{"foo": half(f64)}
+{"foo": half, "bar": 1}?.half
+{"foo": half, "bar": add}?.foo
+{"foo": half, "bar": f32}.i32
+{"foo": half, "bar": foo}
+{"foo": half, "bar": half}
+{"foo": half, "bar": i64, "bar": i32}.foo
+{"foo": half, "bar": i64}
+{"foo": half, "bar": nil}?.ok
+{"foo": half, "foo": 1}?.ok
+{"foo": half, "foo": div}
+{"foo": half, "foo": greet, "bar": f32}?.add
+{"foo": half, "foo": true}.f64
+{"foo": half}
+{"foo": half}.Bar
+{"foo": half}.String
+{"foo": half}.div
+{"foo": half}.f64
+{"foo": half}.greet
+{"foo": half}.half
+{"foo": half}.i
+{"foo": half}.i32
+{"foo": half}.ok
+{"foo": half}?.Bar
+{"foo": half}?.Qux
+{"foo": half}?.add
+{"foo": half}?.f64
+{"foo": half}?.foo
+{"foo": half}?.greet
+{"foo": half}?.half
+{"foo": half}?.list
+{"foo": half}?.score
+{"foo": hasPrefix("bar", "foo")}
+{"foo": i < f64}
+{"foo": i > 0.5}
+{"foo": i, "bar": score}
+{"foo": i, "foo": i}.i64
+{"foo": i, "foo": ok}
+{"foo": i, "foo": ok}?.ok
+{"foo": i32, "bar": 0.5, "foo": array}.Bar
+{"foo": i32, "bar": i32}.i64
+{"foo": i32, "bar": nil}?.i64
+{"foo": i32, "foo": 0.5}.i
+{"foo": i32, "foo": add}
+{"foo": i32, "foo": div, "foo": nil}.Bar
+{"foo": i32, "foo": foo}
+{"foo": i32, "foo": greet}?.foo
+{"foo": i32, "foo": i32}?.score
+{"foo": i32, "foo": ok, "bar": true}.f32
+{"foo": i32, "foo": ok}?.i32
+{"foo": i32}
+{"foo": i32}.Bar
+{"foo": i32}.Qux
+{"foo": i32}.i64
+{"foo": i32}.list
+{"foo": i32}.ok
+{"foo": i32}.score
+{"foo": i32}?.Bar
+{"foo": i32}?.Qux
+{"foo": i32}?.add
+{"foo": i32}?.div
+{"foo": i32}?.f32
+{"foo": i32}?.greet
+{"foo": i32}?.half
+{"foo": i32}?.i
+{"foo": i32}?.i64
+{"foo": i32}?.score
+{"foo": i64 * f64, "foo": i64}
+{"foo": i64 <= 0.5}
+{"foo": i64 ^ i32}
+{"foo": i64, "bar": "bar"}.Qux
+{"foo": i64, "bar": array}.add
+{"foo": i64, "bar": div}
+{"foo": i64, "bar": f64, "bar": greet}.f32
+{"foo": i64, "bar": list}
+{"foo": i64, "foo": 0.5, "bar": 0.5}.half
+{"foo": i64, "foo": div}
+{"foo": i64, "foo": i32}
+{"foo": i64}
+{"foo": i64}.Qux
+{"foo": i64}.add
+{"foo": i64}.array
+{"foo": i64}?.Qux
+{"foo": i64}?.String
+{"foo": i64}?.f32
+{"foo": i64}?.foo
+{"foo": i64}?.greet
+{"foo": i64}?.i32
+{"foo": i64}?.list
+{"foo": i64}?.score
+{"foo": i}
+{"foo": i}.Bar
+{"foo": i}.String
+{"foo": i}.div
+{"foo": i}.foo
+{"foo": i}.greet
+{"foo": i}.i32?.add
+{"foo": i}.ok
+{"foo": i}.score
+{"foo": i}?.Bar
+{"foo": i}?.array
+{"foo": i}?.div
+{"foo": i}?.f64
+{"foo": i}?.foo
+{"foo": i}?.half
+{"foo": i}?.i64
+{"foo": i}?.score
+{"foo": list == list}.f32
+{"foo": list, "bar": f32, "foo": i32}.i32
+{"foo": list, "bar": foo}?.list
+{"foo": list, "bar": i64}
+{"foo": list, "bar": score}
+{"foo": list, "foo": score}
+{"foo": list}
+{"foo": list}.Bar
+{"foo": list}.String
+{"foo": list}.add
+{"foo": list}.div
+{"foo": list}.foo
+{"foo": list}.half
+{"foo": list}.i32
+{"foo": list}.score
+{"foo": list}?.add
+{"foo": list}?.div
+{"foo": list}?.i
+{"foo": list}?.i64
+{"foo": list}?.ok
+{"foo": map(array, #)}
+{"foo": map(array, 0.5)}
+{"foo": map(array, foo)}
+{"foo": map(array, ok), "bar": i32}
+{"foo": map(list, 0.5)}
+{"foo": map(list, score)}
+{"foo": min(0.5)}
+{"foo": min(1)}?.f32
+{"foo": nil == 0.5}
+{"foo": nil, "bar": 0.5}.score
+{"foo": nil, "bar": add}?.array
+{"foo": nil, "bar": div}.Bar
+{"foo": nil, "bar": f64, "foo": div}.i32
+{"foo": nil, "bar": greet}?.add
+{"foo": nil, "bar": i64}?.i64
+{"foo": nil, "bar": list}?.i32
+{"foo": nil, "foo": "foo"}.add
+{"foo": nil, "foo": 1}.score
+{"foo": nil, "foo": false}?.add
+{"foo": nil, "foo": i64}.add
+{"foo": nil}.Bar
+{"foo": nil}.Qux
+{"foo": nil}.String
+{"foo": nil}.array
+{"foo": nil}.div
+{"foo": nil}.f32
+{"foo": nil}.f64
+{"foo": nil}.greet?.i()
+{"foo": nil}.greet?.i32
+{"foo": nil}.half
+{"foo": nil}.i
+{"foo": nil}.i64
+{"foo": nil}.list
+{"foo": nil}?.Bar
+{"foo": nil}?.Qux
+{"foo": nil}?.String
+{"foo": nil}?.array
+{"foo": nil}?.div
+{"foo": nil}?.f32?.ok
+{"foo": nil}?.greet
+{"foo": nil}?.i32
+{"foo": nil}?.i?.half
+{"foo": nil}?.list
+{"foo": nil}?.list?.greet()
+{"foo": nil}?.score
+{"foo": not false}
+{"foo": not ok}
+{"foo": ok && ok}
+{"foo": ok == nil}
+{"foo": ok ? true : div}
+{"foo": ok, "bar": f32}
+{"foo": ok, "bar": i, "foo": greet}.i32
+{"foo": ok, "bar": i32}
+{"foo": ok, "foo": 0.5}?.array
+{"foo": ok, "foo": 1}.Qux
+{"foo": ok, "foo": half, "bar": div}.score
+{"foo": ok, "foo": i64}
+{"foo": ok, "foo": i64}.i
+{"foo": ok, "foo": nil}?.add
+{"foo": ok}
+{"foo": ok}.Bar
+{"foo": ok}.add
+{"foo": ok}.div
+{"foo": ok}.f64
+{"foo": ok}.greet
+{"foo": ok}.i
+{"foo": ok}.score
+{"foo": ok}?.Qux
+{"foo": ok}?.String
+{"foo": ok}?.div
+{"foo": ok}?.f32
+{"foo": ok}?.greet
+{"foo": ok}?.half?.half
+{"foo": ok}?.i32
+{"foo": ok}?.i64
+{"foo": ok}?.list
+{"foo": score(1)}
+{"foo": score, "bar": 0.5}.list
+{"foo": score, "bar": 1 ^ 1}
+{"foo": score, "bar": i32}
+{"foo": score, "bar": i64}
+{"foo": score, "foo": 0.5}.add
+{"foo": score, "foo": 1}?.div
+{"foo": score, "foo": add, "bar": ok}
+{"foo": score, "foo": f32, "bar": false}.div
+{"foo": score, "foo": f32}?.i32
+{"foo": score, "foo": i}?.f32
+{"foo": score}
+{"foo": score}.Bar
+{"foo": score}.array
+{"foo": score}.list
+{"foo": score}?.Bar
+{"foo": score}?.String
+{"foo": score}?.add
+{"foo": score}?.f32
+{"foo": score}?.greet
+{"foo": score}?.half
+{"foo": score}?.i
+{"foo": score}?.list
+{"foo": score}?.score
+{"foo": string(i32)}
+{"foo": string(list)}
+{"foo": toBase64("bar")}
+{"foo": toJSON(f32)}
+{"foo": toJSON(i64)}?.i32
+{"foo": toJSON(nil)}
+{"foo": true, "bar": false}?.array
+{"foo": true, "bar": nil}?.div
+{"foo": true, "bar": true}.f64
+{"foo": true, "foo": array, "bar": i32}?.ok
+{"foo": true, "foo": i32}.i64
+{"foo": true, "foo": ok, "foo": add}.foo
+{"foo": true}.String
+{"foo": true}.f32
+{"foo": true}.foo
+{"foo": true}.i
+{"foo": true}.i64
+{"foo": true}?.String
+{"foo": true}?.greet
+{"foo": true}?.i32
+{"foo": type(1)}
+{"foo": type(list)}
+{"foo": type(nil)}
+{"foo": type(ok)}
diff --git a/test/fuzz/fuzz_expr.dict b/test/fuzz/fuzz_expr.dict
index 9a22cae47..48bdb059c 100644
--- a/test/fuzz/fuzz_expr.dict
+++ b/test/fuzz/fuzz_expr.dict
@@ -24,24 +24,43 @@
 "-3"
 "-4"
 "0x"
+
 "true"
 "false"
-"map"
-"filter"
+"not"
+"nil"
+
+"String"
+
+"ok"
+"f64"
+"f32"
+"i"
+"i64"
+"i32"
+"array"
+"list"
+"foo"
+"add"
+"div"
+"half"
+"score"
+"greet"
+"Foo"
+"Bar"
+"Qux"
+
 "all"
-"any"
 "none"
+"any"
 "one"
-"and"
-"or"
-"in"
-"not"
-"in"
-"contains"
-"matches"
-"startsWith"
-"endsWith"
-"nil"
+"filter"
+"map"
+"count"
+"find"
+"findIndex"
+"findLast"
+"findLastIndex"
 "len"
 "type"
 "abs"
@@ -76,3 +95,5 @@
 "get"
 "keys"
 "values"
+"sort"
+"sortBy"
diff --git a/test/fuzz/fuzz_expr_seed_corpus.zip b/test/fuzz/fuzz_expr_seed_corpus.zip
index 5dfe76d50f2ef2cb0343ea613647f1a8d4396c46..6f529cbbb50f62c1bc6620238be31de49ee0a9c8 100644
GIT binary patch
literal 2827388
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%0A+4n*K!~<W*4%tlsbQ1I=HQ}%k27Cb2gWziEXA7i
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
Z7uLxsDqogEmcy@{w`z>Y`498u`yUP&!8iZ_

literal 11768
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
F@;@7=Uwr@o

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 595987c6c..2b559e255 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -1,7 +1,7 @@
 package fuzz
 
 import (
-	"os"
+	_ "embed"
 	"regexp"
 	"strings"
 	"testing"
@@ -9,33 +9,37 @@ import (
 	"github.com/antonmedv/expr"
 )
 
+//go:embed fuzz_corpus.txt
+var fuzzCorpus string
+
 func FuzzExpr(f *testing.F) {
-	b, err := os.ReadFile("./fuzz_corpus.txt")
-	if err != nil {
-		panic(err)
-	}
-	corpus := strings.Split(strings.TrimSpace(string(b)), "\n")
+	corpus := strings.Split(strings.TrimSpace(fuzzCorpus), "\n")
 	for _, s := range corpus {
 		f.Add(s)
 	}
 
-	env := map[string]interface{}{
-		"i":   1,
-		"j":   2,
-		"b":   true,
-		"a":   []int{1, 2, 3},
-		"m":   map[string]interface{}{"a": 1, "b": 2, "m": map[string]int{"a": 1}},
-		"s":   "abc",
-		"add": func(a, b int) int { return a + b },
-		"foo": Foo{A: 1, B: 2, Bar: Bar{A: 1, B: 2}},
-	}
-	head := expr.Function(
-		"head",
-		func(params ...interface{}) (interface{}, error) {
-			return params[0], nil
+	var env = map[string]any{
+		"ok":    true,
+		"f64":   .5,
+		"f32":   float32(.5),
+		"i":     1,
+		"i64":   int64(1),
+		"i32":   int32(1),
+		"array": []int{1, 2, 3, 4, 5},
+		"list":  []Foo{{"bar"}, {"baz"}},
+		"foo":   Foo{"bar"},
+		"add":   func(a, b int) int { return a + b },
+		"div":   func(a, b int) int { return a / b },
+		"half":  func(a float64) float64 { return a / 2 },
+		"score": func(a int, x ...int) int {
+			s := a
+			for _, n := range x {
+				s += n
+			}
+			return s
 		},
-		new(func(int) int),
-	)
+		"greet": func(name string) string { return "Hello, " + name },
+	}
 
 	skip := []*regexp.Regexp{
 		regexp.MustCompile(`cannot fetch .* from .*`),
@@ -63,10 +67,12 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`strings: negative Repeat count`),
 		regexp.MustCompile(`strings: illegal bytes to escape`),
 		regexp.MustCompile(`operator "in" not defined on int`),
+		regexp.MustCompile(`invalid date .*`),
+		regexp.MustCompile(`cannot parse .* as .*`),
 	}
 
 	f.Fuzz(func(t *testing.T, code string) {
-		program, err := expr.Compile(code, expr.Env(env), head)
+		program, err := expr.Compile(code, expr.Env(env))
 		if err != nil {
 			t.Skipf("compile error: %s", err)
 		}
@@ -79,18 +85,19 @@ func FuzzExpr(f *testing.F) {
 					return
 				}
 			}
-			t.Errorf("code: %s\nerr: %s", code, err)
+			t.Errorf("%s", err)
 		}
 	})
 }
 
 type Foo struct {
-	A   int `expr:"a"`
-	B   int `expr:"b"`
-	Bar Bar `expr:"bar"`
+	Bar string
+}
+
+func (f Foo) String() string {
+	return "foo"
 }
 
-type Bar struct {
-	A int `expr:"a"`
-	B int `expr:"b"`
+func (f Foo) Qux(s string) string {
+	return f.Bar + s
 }

From 12f7b7c6650bcd507af81b7a0f453788014de36a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 11:14:54 +0200
Subject: [PATCH 132/506] Add groupBy

---
 builtin/builtin.go   |  5 +++++
 checker/checker.go   | 18 ++++++++++++++++++
 compiler/compiler.go | 10 ++++++++++
 debug/debugger.go    |  3 +++
 expr_test.go         | 23 +++++++++++++++++++++++
 parser/parser.go     |  1 +
 vm/opcodes.go        |  2 ++
 vm/program.go        |  6 ++++++
 vm/vm.go             | 21 +++++++++++++++++----
 9 files changed, 85 insertions(+), 4 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index cc7a081ee..299c61eb8 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -690,4 +690,9 @@ var Builtins = []*ast.Function{
 			return arrayType, nil
 		},
 	},
+	{
+		Name:      "groupBy",
+		Predicate: true,
+		Types:     types(new(func([]any, func(any) any) map[any][]any)),
+	},
 }
diff --git a/checker/checker.go b/checker/checker.go
index 41b1b2c8c..c1933a115 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -718,6 +718,24 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return integerType, info{}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
+
+	case "groupBy":
+		collection, _ := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isAny(collection) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		}
+
+		v.begin(collection)
+		closure, _ := v.visit(node.Arguments[1])
+		v.end()
+
+		if isFunc(closure) &&
+			closure.NumOut() == 1 &&
+			closure.NumIn() == 1 && isAny(closure.In(0)) {
+
+			return reflect.TypeOf(map[any][]any{}), info{}
+		}
+		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index ecf2c5ba1..a26d85e5a 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -814,6 +814,16 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpEnd)
 		return
 
+	case "groupBy":
+		c.compile(node.Arguments[0])
+		c.emit(OpBegin)
+		c.emitLoop(func() {
+			c.compile(node.Arguments[1])
+			c.emit(OpGroupBy)
+		})
+		c.emit(OpGetGroupBy)
+		c.emit(OpEnd)
+		return
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
diff --git a/debug/debugger.go b/debug/debugger.go
index 6bd66f977..e8c38fc6f 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -130,6 +130,9 @@ func StartDebugger(program *Program, env interface{}) {
 				keys = append(keys, pair{"Index", s.Index})
 				keys = append(keys, pair{"Len", s.Len})
 				keys = append(keys, pair{"Count", s.Count})
+				if s.GroupBy != nil {
+					keys = append(keys, pair{"GroupBy", s.GroupBy})
+				}
 				row := 0
 				for _, pair := range keys {
 					scope.SetCellSimple(row, 0, fmt.Sprintf("%v: ", pair.key))
diff --git a/expr_test.go b/expr_test.go
index 0bf03be5d..54b216d4a 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1040,6 +1040,29 @@ func TestExpr(t *testing.T) {
 			`4/2 == 2`,
 			true,
 		},
+		{
+			`groupBy(1..9, # % 2)`,
+			map[any][]any{
+				0: {2, 4, 6, 8},
+				1: {1, 3, 5, 7, 9},
+			},
+		},
+		{
+			`groupBy(1..9, # % 2)[0]`,
+			[]any{2, 4, 6, 8},
+		},
+		{
+			`groupBy(1..3, # > 1)[true]`,
+			[]any{2, 3},
+		},
+		{
+			`groupBy(1..3, # > 1 ? nil : "")[nil]`,
+			[]any{2, 3},
+		},
+		{
+			`groupBy(ArrayOfFoo, .Value).foo`,
+			[]any{env.ArrayOfFoo[0]},
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/parser/parser.go b/parser/parser.go
index f60ff8936..87cdb2982 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -28,6 +28,7 @@ var predicates = map[string]struct {
 	"findIndex":     {2},
 	"findLast":      {2},
 	"findLastIndex": {2},
+	"groupBy":       {2},
 }
 
 type parser struct {
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 2efe09ded..8a0283173 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -72,8 +72,10 @@ const (
 	OpSetIndex
 	OpGetCount
 	OpGetLen
+	OpGetGroupBy
 	OpPointer
 	OpThrow
+	OpGroupBy
 	OpBegin
 	OpEnd // This opcode must be at the end of this list.
 )
diff --git a/vm/program.go b/vm/program.go
index c4cd8103b..029458830 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -289,6 +289,9 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpGetLen:
 			code("OpGetLen")
 
+		case OpGetGroupBy:
+			code("OpGetGroupBy")
+
 		case OpPointer:
 			code("OpPointer")
 
@@ -298,6 +301,9 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpBegin:
 			code("OpBegin")
 
+		case OpGroupBy:
+			code("OpGroupBy")
+
 		case OpEnd:
 			code("OpEnd")
 
diff --git a/vm/vm.go b/vm/vm.go
index 41390fe71..b4a15a20d 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -39,10 +39,11 @@ type VM struct {
 }
 
 type Scope struct {
-	Array reflect.Value
-	Index int
-	Len   int
-	Count int
+	Array   reflect.Value
+	Index   int
+	Len     int
+	Count   int
+	GroupBy map[any][]any
 }
 
 func Debug() *VM {
@@ -461,6 +462,9 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			scope := vm.Scope()
 			vm.push(scope.Len)
 
+		case OpGetGroupBy:
+			vm.push(vm.Scope().GroupBy)
+
 		case OpPointer:
 			scope := vm.Scope()
 			vm.push(scope.Array.Index(scope.Index).Interface())
@@ -468,6 +472,15 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 		case OpThrow:
 			panic(vm.pop().(error))
 
+		case OpGroupBy:
+			scope := vm.Scope()
+			if scope.GroupBy == nil {
+				scope.GroupBy = make(map[any][]any)
+			}
+			it := scope.Array.Index(scope.Index).Interface()
+			key := vm.pop()
+			scope.GroupBy[key] = append(scope.GroupBy[key], it)
+
 		case OpBegin:
 			a := vm.pop()
 			array := reflect.ValueOf(a)

From 4a536fda9615a6153164165a0e29f981241ed93e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 11:22:35 +0200
Subject: [PATCH 133/506] Add groupBy bench

---
 bench_test.go | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/bench_test.go b/bench_test.go
index a294bb06a..95b3c2017 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -498,3 +498,17 @@ func Benchmark_sortBy(b *testing.B) {
 	require.Equal(b, 1, out.([]any)[0].(Foo).Value)
 	require.Equal(b, 100, out.([]any)[99].(Foo).Value)
 }
+
+func Benchmark_groupBy(b *testing.B) {
+	program, err := expr.Compile(`groupBy(1..100, # % 7)[6]`)
+	require.NoError(b, err)
+
+	var out interface{}
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 6, out.([]any)[0])
+}

From 7221fe0c260f5ced1428259e28266029ce861dfb Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 11:25:15 +0200
Subject: [PATCH 134/506] Replace interface{} with any

---
 ast/func.go                                   |   4 +-
 ast/node.go                                   |   2 +-
 ast/print_test.go                             |   2 +-
 bench_test.go                                 |  68 ++++-----
 builtin/builtin.go                            | 100 ++++++-------
 builtin/builtin_test.go                       |  36 ++---
 builtin/func.go                               |  20 +--
 builtin/utils.go                              |   6 +-
 checker/checker.go                            |   2 +-
 checker/checker_test.go                       |  26 ++--
 checker/types.go                              |   8 +-
 compiler/compiler.go                          |  12 +-
 compiler/compiler_test.go                     |  24 ++--
 conf/config.go                                |   8 +-
 conf/types_table.go                           |   2 +-
 debug/debugger.go                             |   2 +-
 docgen/docgen.go                              |   2 +-
 docgen/docgen_test.go                         |   4 +-
 expr.go                                       |   8 +-
 expr_test.go                                  | 134 +++++++++---------
 optimizer/const_expr.go                       |   2 +-
 optimizer/fold.go                             |   2 +-
 optimizer/optimizer_test.go                   |   4 +-
 parser/lexer/lexer.go                         |   2 +-
 parser/parser.go                              |   4 +-
 repl/repl.go                                  |   2 +-
 test/coredns/coredns.go                       |   4 +-
 test/crowdsec/crowdsec.go                     |  32 ++---
 test/crowdsec/crowdsec_test.go                |   4 +-
 test/crowdsec/funcs.go                        | 134 +++++++++---------
 test/deref/deref_test.go                      |  24 ++--
 .../interface_method/interface_method_test.go |   2 +-
 test/mock/mock.go                             |  16 +--
 test/pipes/pipes_test.go                      |   6 +-
 test/time/time_test.go                        |  10 +-
 vm/func_types/main.go                         |  38 ++---
 vm/generated.go                               |  84 +++++------
 vm/program.go                                 |   6 +-
 vm/program_test.go                            |   2 +-
 vm/runtime/generated.go                       |  20 +--
 vm/runtime/helpers/main.go                    |   2 +-
 vm/runtime/runtime.go                         |  26 ++--
 vm/vm.go                                      |  30 ++--
 vm/vm_test.go                                 |  12 +-
 44 files changed, 469 insertions(+), 469 deletions(-)

diff --git a/ast/func.go b/ast/func.go
index 92be2a197..a873c35e9 100644
--- a/ast/func.go
+++ b/ast/func.go
@@ -4,8 +4,8 @@ import "reflect"
 
 type Function struct {
 	Name      string
-	Func      func(args ...interface{}) (interface{}, error)
-	Fast      func(arg interface{}) interface{}
+	Func      func(args ...any) (any, error)
+	Fast      func(arg any) any
 	Types     []reflect.Type
 	Validate  func(args []reflect.Type) (reflect.Type, error)
 	Predicate bool
diff --git a/ast/node.go b/ast/node.go
index 3f083dfc6..d037926c1 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -77,7 +77,7 @@ type StringNode struct {
 
 type ConstantNode struct {
 	base
-	Value interface{}
+	Value any
 }
 
 type UnaryNode struct {
diff --git a/ast/print_test.go b/ast/print_test.go
index 1b992511c..7bb5c85b2 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -91,7 +91,7 @@ func TestPrint_MemberNode(t *testing.T) {
 
 func TestPrint_ConstantNode(t *testing.T) {
 	tests := []struct {
-		input interface{}
+		input any
 		want  string
 	}{
 		{nil, `nil`},
diff --git a/bench_test.go b/bench_test.go
index 95b3c2017..935f3a80b 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -9,7 +9,7 @@ import (
 )
 
 func Benchmark_expr(b *testing.B) {
-	params := make(map[string]interface{})
+	params := make(map[string]any)
 	params["Origin"] = "MOW"
 	params["Country"] = "RU"
 	params["Adults"] = 1
@@ -18,7 +18,7 @@ func Benchmark_expr(b *testing.B) {
 	program, err := expr.Compile(`(Origin == "MOW" || Country == "RU") && (Value >= 100 || Adults == 1)`, expr.Env(params))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
@@ -31,7 +31,7 @@ func Benchmark_expr(b *testing.B) {
 }
 
 func Benchmark_expr_reuseVm(b *testing.B) {
-	params := make(map[string]interface{})
+	params := make(map[string]any)
 	params["Origin"] = "MOW"
 	params["Country"] = "RU"
 	params["Adults"] = 1
@@ -40,7 +40,7 @@ func Benchmark_expr_reuseVm(b *testing.B) {
 	program, err := expr.Compile(`(Origin == "MOW" || Country == "RU") && (Value >= 100 || Adults == 1)`, expr.Env(params))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	v := vm.VM{}
 
 	b.ResetTimer()
@@ -54,14 +54,14 @@ func Benchmark_expr_reuseVm(b *testing.B) {
 }
 
 func Benchmark_len(b *testing.B) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"arr": make([]int, 100),
 	}
 
 	program, err := expr.Compile(`len(arr)`, expr.Env(env))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -86,7 +86,7 @@ func Benchmark_filter(b *testing.B) {
 	program, err := expr.Compile(`filter(Ints, # % 7 == 0)`, expr.Env(Env{}))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -94,7 +94,7 @@ func Benchmark_filter(b *testing.B) {
 	b.StopTimer()
 
 	require.NoError(b, err)
-	require.Len(b, out.([]interface{}), 142)
+	require.Len(b, out.([]any), 142)
 }
 
 func Benchmark_filterLen(b *testing.B) {
@@ -111,7 +111,7 @@ func Benchmark_filterLen(b *testing.B) {
 	program, err := expr.Compile(`len(filter(Ints, # % 7 == 0))`, expr.Env(Env{}))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -136,7 +136,7 @@ func Benchmark_filterFirst(b *testing.B) {
 	program, err := expr.Compile(`filter(Ints, # % 7 == 0)[0]`, expr.Env(Env{}))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -161,7 +161,7 @@ func Benchmark_filterLast(b *testing.B) {
 	program, err := expr.Compile(`filter(Ints, # % 7 == 0)[-1]`, expr.Env(Env{}))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -187,7 +187,7 @@ func Benchmark_filterMap(b *testing.B) {
 	program, err := expr.Compile(`map(filter(Ints, # % 7 == 0), # * 2)`, expr.Env(Env{}))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -195,12 +195,12 @@ func Benchmark_filterMap(b *testing.B) {
 	b.StopTimer()
 
 	require.NoError(b, err)
-	require.Len(b, out.([]interface{}), 14)
-	require.Equal(b, 14, out.([]interface{})[0])
+	require.Len(b, out.([]any), 14)
+	require.Equal(b, 14, out.([]any)[0])
 }
 
 func Benchmark_arrayIndex(b *testing.B) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"arr": make([]int, 100),
 	}
 	for i := 0; i < 100; i++ {
@@ -210,7 +210,7 @@ func Benchmark_arrayIndex(b *testing.B) {
 	program, err := expr.Compile(`arr[50]`, expr.Env(env))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -234,7 +234,7 @@ func Benchmark_envStruct(b *testing.B) {
 
 	env := Env{Price: Price{Value: 1}}
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -249,14 +249,14 @@ func Benchmark_envMap(b *testing.B) {
 	type Price struct {
 		Value int
 	}
-	env := map[string]interface{}{
+	env := map[string]any{
 		"price": Price{Value: 1},
 	}
 
 	program, err := expr.Compile(`price.Value > 0`, expr.Env(env))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -272,7 +272,7 @@ type CallEnv struct {
 	B      int
 	C      int
 	Fn     func() bool
-	FnFast func(...interface{}) interface{}
+	FnFast func(...any) any
 	Foo    CallFoo
 }
 
@@ -296,7 +296,7 @@ func Benchmark_callFunc(b *testing.B) {
 
 	env := CallEnv{}
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -313,7 +313,7 @@ func Benchmark_callMethod(b *testing.B) {
 
 	env := CallEnv{}
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -334,7 +334,7 @@ func Benchmark_callField(b *testing.B) {
 		},
 	}
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -352,12 +352,12 @@ func Benchmark_callFast(b *testing.B) {
 	}
 
 	env := CallEnv{
-		FnFast: func(s ...interface{}) interface{} {
+		FnFast: func(s ...any) any {
 			return "fn_fast"
 		},
 	}
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -374,7 +374,7 @@ func Benchmark_callConstExpr(b *testing.B) {
 
 	env := CallEnv{}
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -396,7 +396,7 @@ func Benchmark_largeStructAccess(b *testing.B) {
 
 	env := Env{Field: 21}
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, &env)
@@ -421,7 +421,7 @@ func Benchmark_largeNestedStructAccess(b *testing.B) {
 	env := Env{}
 	env.Inner.Field = 21
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, &env)
@@ -443,7 +443,7 @@ func Benchmark_largeNestedArrayAccess(b *testing.B) {
 	env := Env{}
 	env.Data[0][0] = 1
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, &env)
@@ -455,14 +455,14 @@ func Benchmark_largeNestedArrayAccess(b *testing.B) {
 }
 
 func Benchmark_sort(b *testing.B) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"arr": []any{55, 58, 42, 61, 75, 52, 64, 62, 16, 79, 40, 14, 50, 76, 23, 2, 5, 80, 89, 51, 21, 96, 91, 13, 71, 82, 65, 63, 11, 17, 94, 81, 74, 4, 97, 1, 39, 3, 28, 8, 84, 90, 47, 85, 7, 56, 49, 93, 33, 12, 19, 60, 86, 100, 44, 45, 36, 72, 95, 77, 34, 92, 24, 73, 18, 38, 43, 26, 41, 69, 67, 57, 9, 27, 66, 87, 46, 35, 59, 70, 10, 20, 53, 15, 32, 98, 68, 31, 54, 25, 83, 88, 22, 48, 29, 37, 6, 78, 99, 30},
 	}
 
 	program, err := expr.Compile(`sort(arr)`, expr.Env(env))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, _ = vm.Run(program, env)
@@ -478,7 +478,7 @@ func Benchmark_sortBy(b *testing.B) {
 		Value int
 	}
 	arr := []any{55, 58, 42, 61, 75, 52, 64, 62, 16, 79, 40, 14, 50, 76, 23, 2, 5, 80, 89, 51, 21, 96, 91, 13, 71, 82, 65, 63, 11, 17, 94, 81, 74, 4, 97, 1, 39, 3, 28, 8, 84, 90, 47, 85, 7, 56, 49, 93, 33, 12, 19, 60, 86, 100, 44, 45, 36, 72, 95, 77, 34, 92, 24, 73, 18, 38, 43, 26, 41, 69, 67, 57, 9, 27, 66, 87, 46, 35, 59, 70, 10, 20, 53, 15, 32, 98, 68, 31, 54, 25, 83, 88, 22, 48, 29, 37, 6, 78, 99, 30}
-	env := map[string]interface{}{
+	env := map[string]any{
 		"arr": make([]Foo, len(arr)),
 	}
 	for i, v := range arr {
@@ -488,7 +488,7 @@ func Benchmark_sortBy(b *testing.B) {
 	program, err := expr.Compile(`sortBy(arr, "Value")`, expr.Env(env))
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, _ = vm.Run(program, env)
@@ -503,7 +503,7 @@ func Benchmark_groupBy(b *testing.B) {
 	program, err := expr.Compile(`groupBy(1..100, # % 7)[6]`)
 	require.NoError(b, err)
 
-	var out interface{}
+	var out any
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		out, _ = vm.Run(program, nil)
diff --git a/builtin/builtin.go b/builtin/builtin.go
index 299c61eb8..aacaa0a49 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -31,57 +31,57 @@ var Builtins = []*ast.Function{
 	{
 		Name:      "all",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) bool)),
+		Types:     types(new(func([]any, func(any) bool) bool)),
 	},
 	{
 		Name:      "none",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) bool)),
+		Types:     types(new(func([]any, func(any) bool) bool)),
 	},
 	{
 		Name:      "any",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) bool)),
+		Types:     types(new(func([]any, func(any) bool) bool)),
 	},
 	{
 		Name:      "one",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) bool)),
+		Types:     types(new(func([]any, func(any) bool) bool)),
 	},
 	{
 		Name:      "filter",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) []interface{})),
+		Types:     types(new(func([]any, func(any) bool) []any)),
 	},
 	{
 		Name:      "map",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) interface{}) []interface{})),
+		Types:     types(new(func([]any, func(any) any) []any)),
 	},
 	{
 		Name:      "count",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) int)),
+		Types:     types(new(func([]any, func(any) bool) int)),
 	},
 	{
 		Name:      "find",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) interface{})),
+		Types:     types(new(func([]any, func(any) bool) any)),
 	},
 	{
 		Name:      "findIndex",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) int)),
+		Types:     types(new(func([]any, func(any) bool) int)),
 	},
 	{
 		Name:      "findLast",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) interface{})),
+		Types:     types(new(func([]any, func(any) bool) any)),
 	},
 	{
 		Name:      "findLastIndex",
 		Predicate: true,
-		Types:     types(new(func([]interface{}, func(interface{}) bool) int)),
+		Types:     types(new(func([]any, func(any) bool) int)),
 	},
 	{
 		Name: "len",
@@ -100,7 +100,7 @@ var Builtins = []*ast.Function{
 	{
 		Name:  "type",
 		Fast:  Type,
-		Types: types(new(func(interface{}) string)),
+		Types: types(new(func(any) string)),
 	},
 	{
 		Name: "abs",
@@ -155,11 +155,11 @@ var Builtins = []*ast.Function{
 	{
 		Name:  "string",
 		Fast:  String,
-		Types: types(new(func(any interface{}) string)),
+		Types: types(new(func(any any) string)),
 	},
 	{
 		Name: "trim",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			if len(args) == 1 {
 				return strings.TrimSpace(args[0].(string)), nil
 			} else if len(args) == 2 {
@@ -175,7 +175,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "trimPrefix",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			s := " "
 			if len(args) == 2 {
 				s = args[1].(string)
@@ -189,7 +189,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "trimSuffix",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			s := " "
 			if len(args) == 2 {
 				s = args[1].(string)
@@ -203,21 +203,21 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "upper",
-		Fast: func(arg interface{}) interface{} {
+		Fast: func(arg any) any {
 			return strings.ToUpper(arg.(string))
 		},
 		Types: types(strings.ToUpper),
 	},
 	{
 		Name: "lower",
-		Fast: func(arg interface{}) interface{} {
+		Fast: func(arg any) any {
 			return strings.ToLower(arg.(string))
 		},
 		Types: types(strings.ToLower),
 	},
 	{
 		Name: "split",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			if len(args) == 2 {
 				return strings.Split(args[0].(string), args[1].(string)), nil
 			} else if len(args) == 3 {
@@ -233,7 +233,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "splitAfter",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			if len(args) == 2 {
 				return strings.SplitAfter(args[0].(string), args[1].(string)), nil
 			} else if len(args) == 3 {
@@ -249,7 +249,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "replace",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			if len(args) == 4 {
 				return strings.Replace(args[0].(string), args[1].(string), args[2].(string), runtime.ToInt(args[3])), nil
 			} else if len(args) == 3 {
@@ -265,7 +265,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "repeat",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			n := runtime.ToInt(args[1])
 			if n > 1e6 {
 				panic("memory budget exceeded")
@@ -276,7 +276,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "join",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			glue := ""
 			if len(args) == 2 {
 				glue = args[1].(string)
@@ -284,9 +284,9 @@ var Builtins = []*ast.Function{
 			switch args[0].(type) {
 			case []string:
 				return strings.Join(args[0].([]string), glue), nil
-			case []interface{}:
+			case []any:
 				var s []string
-				for _, arg := range args[0].([]interface{}) {
+				for _, arg := range args[0].([]any) {
 					s = append(s, arg.(string))
 				}
 				return strings.Join(s, glue), nil
@@ -295,36 +295,36 @@ var Builtins = []*ast.Function{
 		},
 		Types: types(
 			strings.Join,
-			new(func([]interface{}, string) string),
-			new(func([]interface{}) string),
+			new(func([]any, string) string),
+			new(func([]any) string),
 			new(func([]string, string) string),
 			new(func([]string) string),
 		),
 	},
 	{
 		Name: "indexOf",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			return strings.Index(args[0].(string), args[1].(string)), nil
 		},
 		Types: types(strings.Index),
 	},
 	{
 		Name: "lastIndexOf",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			return strings.LastIndex(args[0].(string), args[1].(string)), nil
 		},
 		Types: types(strings.LastIndex),
 	},
 	{
 		Name: "hasPrefix",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			return strings.HasPrefix(args[0].(string), args[1].(string)), nil
 		},
 		Types: types(strings.HasPrefix),
 	},
 	{
 		Name: "hasSuffix",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			return strings.HasSuffix(args[0].(string), args[1].(string)), nil
 		},
 		Types: types(strings.HasSuffix),
@@ -369,37 +369,37 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "toJSON",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			b, err := json.MarshalIndent(args[0], "", "  ")
 			if err != nil {
 				return nil, err
 			}
 			return string(b), nil
 		},
-		Types: types(new(func(interface{}) string)),
+		Types: types(new(func(any) string)),
 	},
 	{
 		Name: "fromJSON",
-		Func: func(args ...interface{}) (interface{}, error) {
-			var v interface{}
+		Func: func(args ...any) (any, error) {
+			var v any
 			err := json.Unmarshal([]byte(args[0].(string)), &v)
 			if err != nil {
 				return nil, err
 			}
 			return v, nil
 		},
-		Types: types(new(func(string) interface{})),
+		Types: types(new(func(string) any)),
 	},
 	{
 		Name: "toBase64",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			return base64.StdEncoding.EncodeToString([]byte(args[0].(string))), nil
 		},
 		Types: types(new(func(string) string)),
 	},
 	{
 		Name: "fromBase64",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			b, err := base64.StdEncoding.DecodeString(args[0].(string))
 			if err != nil {
 				return nil, err
@@ -410,21 +410,21 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "now",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			return time.Now(), nil
 		},
 		Types: types(new(func() time.Time)),
 	},
 	{
 		Name: "duration",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			return time.ParseDuration(args[0].(string))
 		},
 		Types: types(time.ParseDuration),
 	},
 	{
 		Name: "date",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			date := args[0].(string)
 			if len(args) == 2 {
 				layout := args[1].(string)
@@ -469,7 +469,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "first",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			defer func() {
 				if r := recover(); r != nil {
 					return
@@ -492,7 +492,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "last",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			defer func() {
 				if r := recover(); r != nil {
 					return
@@ -515,7 +515,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "get",
-		Func: func(args ...interface{}) (out interface{}, err error) {
+		Func: func(args ...any) (out any, err error) {
 			defer func() {
 				if r := recover(); r != nil {
 					return
@@ -526,7 +526,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "keys",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
@@ -535,7 +535,7 @@ var Builtins = []*ast.Function{
 				return nil, fmt.Errorf("cannot get keys from %s", v.Kind())
 			}
 			keys := v.MapKeys()
-			out := make([]interface{}, len(keys))
+			out := make([]any, len(keys))
 			for i, key := range keys {
 				out[i] = key.Interface()
 			}
@@ -556,7 +556,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "values",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
@@ -565,7 +565,7 @@ var Builtins = []*ast.Function{
 				return nil, fmt.Errorf("cannot get values from %s", v.Kind())
 			}
 			keys := v.MapKeys()
-			out := make([]interface{}, len(keys))
+			out := make([]any, len(keys))
 			for i, key := range keys {
 				out[i] = v.MapIndex(key).Interface()
 			}
@@ -586,7 +586,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "sort",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			if len(args) != 1 && len(args) != 2 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1 or 2, got %d)", len(args))
 			}
@@ -633,7 +633,7 @@ var Builtins = []*ast.Function{
 	},
 	{
 		Name: "sortBy",
-		Func: func(args ...interface{}) (interface{}, error) {
+		Func: func(args ...any) (any, error) {
 			if len(args) != 2 && len(args) != 3 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 2 or 3, got %d)", len(args))
 			}
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 34704bdad..e7782fa32 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -20,7 +20,7 @@ import (
 func TestBuiltin(t *testing.T) {
 	var tests = []struct {
 		input string
-		want  interface{}
+		want  any
 	}{
 		{`len(1..10)`, 10},
 		{`len({foo: 1, bar: 2})`, 2},
@@ -63,7 +63,7 @@ func TestBuiltin(t *testing.T) {
 		{`min(1, 2, 3)`, 1},
 		{`min(1.5, 2.5, 3.5)`, 1.5},
 		{`toJSON({foo: 1, bar: 2})`, "{\n  \"bar\": 2,\n  \"foo\": 1\n}"},
-		{`fromJSON("[1, 2, 3]")`, []interface{}{1.0, 2.0, 3.0}},
+		{`fromJSON("[1, 2, 3]")`, []any{1.0, 2.0, 3.0}},
 		{`toBase64("hello")`, "aGVsbG8="},
 		{`fromBase64("aGVsbG8=")`, "hello"},
 		{`now().Format("2006-01-02T15:04Z")`, time.Now().Format("2006-01-02T15:04Z")},
@@ -89,10 +89,10 @@ func TestBuiltin(t *testing.T) {
 		{`1 in values({foo: 1, bar: 2})`, true},
 	}
 
-	env := map[string]interface{}{
+	env := map[string]any{
 		"ArrayOfString": []string{"foo", "bar", "baz"},
 		"ArrayOfInt":    []int{1, 2, 3},
-		"ArrayOfAny":    []interface{}{1, "2", true},
+		"ArrayOfAny":    []any{1, "2", true},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
@@ -171,7 +171,7 @@ func TestBuiltin_errors(t *testing.T) {
 }
 
 func TestBuiltin_types(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"num":           42,
 		"str":           "foo",
 		"ArrayOfString": []string{"foo", "bar", "baz"},
@@ -223,7 +223,7 @@ func TestBuiltin_memory_limits(t *testing.T) {
 
 func TestBuiltin_disallow_builtins_override(t *testing.T) {
 	t.Run("via env", func(t *testing.T) {
-		env := map[string]interface{}{
+		env := map[string]any{
 			"len": func() int { return 42 },
 			"repeat": func(a string) string {
 				return a
@@ -235,13 +235,13 @@ func TestBuiltin_disallow_builtins_override(t *testing.T) {
 	})
 	t.Run("via expr.Function", func(t *testing.T) {
 		length := expr.Function("len",
-			func(params ...interface{}) (interface{}, error) {
+			func(params ...any) (any, error) {
 				return 42, nil
 			},
 			new(func() int),
 		)
 		repeat := expr.Function("repeat",
-			func(params ...interface{}) (interface{}, error) {
+			func(params ...any) (any, error) {
 				return params[0], nil
 			},
 			new(func(string) string),
@@ -259,7 +259,7 @@ func TestBuiltin_DisableBuiltin(t *testing.T) {
 				continue // TODO: allow to disable predicates
 			}
 			t.Run(b.Name, func(t *testing.T) {
-				env := map[string]interface{}{
+				env := map[string]any{
 					b.Name: func() int { return 42 },
 				}
 				program, err := expr.Compile(b.Name+"()", expr.Env(env), expr.DisableBuiltin(b.Name))
@@ -278,7 +278,7 @@ func TestBuiltin_DisableBuiltin(t *testing.T) {
 			}
 			t.Run(b.Name, func(t *testing.T) {
 				fn := expr.Function(b.Name,
-					func(params ...interface{}) (interface{}, error) {
+					func(params ...any) (any, error) {
 						return 42, nil
 					},
 					new(func() int),
@@ -302,7 +302,7 @@ func TestBuiltin_DisableAllBuiltins(t *testing.T) {
 
 func TestBuiltin_EnableBuiltin(t *testing.T) {
 	t.Run("via env", func(t *testing.T) {
-		env := map[string]interface{}{
+		env := map[string]any{
 			"repeat": func() string { return "repeat" },
 		}
 		program, err := expr.Compile(`len(repeat())`, expr.Env(env), expr.DisableAllBuiltins(), expr.EnableBuiltin("len"))
@@ -314,7 +314,7 @@ func TestBuiltin_EnableBuiltin(t *testing.T) {
 	})
 	t.Run("via expr.Function", func(t *testing.T) {
 		fn := expr.Function("repeat",
-			func(params ...interface{}) (interface{}, error) {
+			func(params ...any) (any, error) {
 				return "repeat", nil
 			},
 			new(func() string),
@@ -330,10 +330,10 @@ func TestBuiltin_EnableBuiltin(t *testing.T) {
 
 func TestBuiltin_type(t *testing.T) {
 	type Foo struct{}
-	var b interface{} = 1
-	var a interface{} = &b
+	var b any = 1
+	var a any = &b
 	tests := []struct {
-		obj  interface{}
+		obj  any
 		want string
 	}{
 		{nil, "nil"},
@@ -345,7 +345,7 @@ func TestBuiltin_type(t *testing.T) {
 		{float32(1.0), "float"},
 		{"string", "string"},
 		{[]string{"foo", "bar"}, "array"},
-		{map[string]interface{}{"foo": "bar"}, "map"},
+		{map[string]any{"foo": "bar"}, "map"},
 		{func() {}, "func"},
 		{time.Now(), "time.Time"},
 		{time.Second, "time.Duration"},
@@ -355,7 +355,7 @@ func TestBuiltin_type(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.want, func(t *testing.T) {
-			env := map[string]interface{}{
+			env := map[string]any{
 				"obj": test.obj,
 			}
 			program, err := expr.Compile(`type(obj)`, expr.Env(env))
@@ -369,7 +369,7 @@ func TestBuiltin_type(t *testing.T) {
 }
 
 func TestBuiltin_sort(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"ArrayOfString": []string{"foo", "bar", "baz"},
 		"ArrayOfInt":    []int{3, 2, 1},
 		"ArrayOfFoo":    []mock.Foo{{Value: "c"}, {Value: "a"}, {Value: "b"}},
diff --git a/builtin/func.go b/builtin/func.go
index a14f6553d..7c042c6d2 100644
--- a/builtin/func.go
+++ b/builtin/func.go
@@ -8,7 +8,7 @@ import (
 	"github.com/antonmedv/expr/vm/runtime"
 )
 
-func Len(x interface{}) interface{} {
+func Len(x any) any {
 	v := reflect.ValueOf(x)
 	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
@@ -18,7 +18,7 @@ func Len(x interface{}) interface{} {
 	}
 }
 
-func Type(arg interface{}) interface{} {
+func Type(arg any) any {
 	if arg == nil {
 		return "nil"
 	}
@@ -60,7 +60,7 @@ func Type(arg interface{}) interface{} {
 	return "unknown"
 }
 
-func Abs(x interface{}) interface{} {
+func Abs(x any) any {
 	switch x.(type) {
 	case float32:
 		if x.(float32) < 0 {
@@ -138,7 +138,7 @@ func Abs(x interface{}) interface{} {
 	panic(fmt.Sprintf("invalid argument for abs (type %T)", x))
 }
 
-func Int(x interface{}) interface{} {
+func Int(x any) any {
 	switch x := x.(type) {
 	case float32:
 		return int(x)
@@ -175,7 +175,7 @@ func Int(x interface{}) interface{} {
 	}
 }
 
-func Float(x interface{}) interface{} {
+func Float(x any) any {
 	switch x := x.(type) {
 	case float32:
 		return float64(x)
@@ -212,12 +212,12 @@ func Float(x interface{}) interface{} {
 	}
 }
 
-func String(arg interface{}) interface{} {
+func String(arg any) any {
 	return fmt.Sprintf("%v", arg)
 }
 
-func Max(args ...interface{}) (interface{}, error) {
-	var max interface{}
+func Max(args ...any) (any, error) {
+	var max any
 	for _, arg := range args {
 		if max == nil || runtime.Less(max, arg) {
 			max = arg
@@ -226,8 +226,8 @@ func Max(args ...interface{}) (interface{}, error) {
 	return max, nil
 }
 
-func Min(args ...interface{}) (interface{}, error) {
-	var min interface{}
+func Min(args ...any) (any, error) {
+	var min any
 	for _, arg := range args {
 		if min == nil || runtime.More(min, arg) {
 			min = arg
diff --git a/builtin/utils.go b/builtin/utils.go
index 9850b09a9..349663dd9 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -6,11 +6,11 @@ import (
 )
 
 var (
-	anyType     = reflect.TypeOf(new(interface{})).Elem()
+	anyType     = reflect.TypeOf(new(any)).Elem()
 	integerType = reflect.TypeOf(0)
 	floatType   = reflect.TypeOf(float64(0))
 	stringType  = reflect.TypeOf("")
-	arrayType   = reflect.TypeOf([]interface{}{})
+	arrayType   = reflect.TypeOf([]any{})
 )
 
 func kind(t reflect.Type) reflect.Kind {
@@ -20,7 +20,7 @@ func kind(t reflect.Type) reflect.Kind {
 	return t.Kind()
 }
 
-func types(types ...interface{}) []reflect.Type {
+func types(types ...any) []reflect.Type {
 	ts := make([]reflect.Type, len(types))
 	for i, t := range types {
 		t := reflect.TypeOf(t)
diff --git a/checker/checker.go b/checker/checker.go
index c1933a115..e76472ccc 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -130,7 +130,7 @@ func (v *checker) visit(node ast.Node) (reflect.Type, info) {
 	return t, i
 }
 
-func (v *checker) error(node ast.Node, format string, args ...interface{}) (reflect.Type, info) {
+func (v *checker) error(node ast.Node, format string, args ...any) (reflect.Type, info) {
 	if v.err == nil { // show first error
 		v.err = &file.Error{
 			Location: node.Location(),
diff --git a/checker/checker_test.go b/checker/checker_test.go
index eeade988a..69c0a8e76 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -709,7 +709,7 @@ func TestCheck_AllowUndefinedVariables_OptionalChaining(t *testing.T) {
 
 func TestCheck_OperatorOverload(t *testing.T) {
 	type Date struct{}
-	env := map[string]interface{}{
+	env := map[string]any{
 		"a": Date{},
 		"b": Date{},
 		"add": func(a, b Date) bool {
@@ -738,7 +738,7 @@ func TestCheck_PointerNode(t *testing.T) {
 }
 
 func TestCheck_TypeWeights(t *testing.T) {
-	types := map[string]interface{}{
+	types := map[string]any{
 		"Uint":    uint(1),
 		"Uint8":   uint8(2),
 		"Uint16":  uint16(3),
@@ -766,8 +766,8 @@ func TestCheck_TypeWeights(t *testing.T) {
 }
 
 func TestCheck_CallFastTyped(t *testing.T) {
-	env := map[string]interface{}{
-		"fn": func([]interface{}, string) string {
+	env := map[string]any{
+		"fn": func([]any, string) string {
 			return "foo"
 		},
 	}
@@ -809,7 +809,7 @@ func TestCheck_CallTyped_excludes_named_functions(t *testing.T) {
 }
 
 func TestCheck_works_with_nil_types(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"null": nil,
 	}
 
@@ -823,7 +823,7 @@ func TestCheck_works_with_nil_types(t *testing.T) {
 func TestCheck_cast_to_expected_works_with_interface(t *testing.T) {
 	t.Run("float64", func(t *testing.T) {
 		type Env struct {
-			Any interface{}
+			Any any
 		}
 
 		tree, err := parser.Parse("Any")
@@ -838,8 +838,8 @@ func TestCheck_cast_to_expected_works_with_interface(t *testing.T) {
 	})
 
 	t.Run("kind", func(t *testing.T) {
-		env := map[string]interface{}{
-			"Any": interface{}("foo"),
+		env := map[string]any{
+			"Any": any("foo"),
 		}
 
 		tree, err := parser.Parse("Any")
@@ -867,7 +867,7 @@ func TestCheck_operator_in_works_with_interfaces(t *testing.T) {
 func TestCheck_Function_types_are_checked(t *testing.T) {
 	add := expr.Function(
 		"add",
-		func(p ...interface{}) (interface{}, error) {
+		func(p ...any) (any, error) {
 			out := 0
 			for _, each := range p {
 				out += each.(int)
@@ -914,7 +914,7 @@ func TestCheck_Function_types_are_checked(t *testing.T) {
 func TestCheck_Function_without_types(t *testing.T) {
 	add := expr.Function(
 		"add",
-		func(p ...interface{}) (interface{}, error) {
+		func(p ...any) (any, error) {
 			out := 0
 			for _, each := range p {
 				out += each.(int)
@@ -954,7 +954,7 @@ func TestCheck_dont_panic_on_nil_arguments_for_builtins(t *testing.T) {
 }
 
 func TestCheck_do_not_override_params_for_functions(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"foo": func(p string) string {
 			return "foo"
 		},
@@ -962,7 +962,7 @@ func TestCheck_do_not_override_params_for_functions(t *testing.T) {
 	config := conf.New(env)
 	expr.Function(
 		"bar",
-		func(p ...interface{}) (interface{}, error) {
+		func(p ...any) (any, error) {
 			return p[0].(string), nil
 		},
 		new(func(string) string),
@@ -989,7 +989,7 @@ func TestCheck_do_not_override_params_for_functions(t *testing.T) {
 }
 
 func TestCheck_env_keyword(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"num":  42,
 		"str":  "foo",
 		"name": "str",
diff --git a/checker/types.go b/checker/types.go
index 5248b760c..1665527f0 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -13,12 +13,12 @@ var (
 	integerType  = reflect.TypeOf(0)
 	floatType    = reflect.TypeOf(float64(0))
 	stringType   = reflect.TypeOf("")
-	arrayType    = reflect.TypeOf([]interface{}{})
-	mapType      = reflect.TypeOf(map[string]interface{}{})
-	anyType      = reflect.TypeOf(new(interface{})).Elem()
+	arrayType    = reflect.TypeOf([]any{})
+	mapType      = reflect.TypeOf(map[string]any{})
+	anyType      = reflect.TypeOf(new(any)).Elem()
 	timeType     = reflect.TypeOf(time.Time{})
 	durationType = reflect.TypeOf(time.Duration(0))
-	functionType = reflect.TypeOf(new(func(...interface{}) (interface{}, error))).Elem()
+	functionType = reflect.TypeOf(new(func(...any) (any, error))).Elem()
 )
 
 func combined(a, b reflect.Type) reflect.Type {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index a26d85e5a..978ab6f9c 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -26,7 +26,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 
 	c := &compiler{
 		locations:      make([]file.Location, 0),
-		constantsIndex: make(map[interface{}]int),
+		constantsIndex: make(map[any]int),
 		functionsIndex: make(map[string]int),
 		debugInfo:      make(map[string]string),
 	}
@@ -64,10 +64,10 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 type compiler struct {
 	locations      []file.Location
 	bytecode       []Opcode
-	variables      []interface{}
+	variables      []any
 	scopes         []scope
-	constants      []interface{}
-	constantsIndex map[interface{}]int
+	constants      []any
+	constantsIndex map[any]int
 	functions      []Function
 	functionsIndex map[string]int
 	debugInfo      map[string]string
@@ -106,11 +106,11 @@ func (c *compiler) emit(op Opcode, args ...int) int {
 	return c.emitLocation(loc, op, arg)
 }
 
-func (c *compiler) emitPush(value interface{}) int {
+func (c *compiler) emitPush(value any) int {
 	return c.emit(OpPush, c.addConstant(value))
 }
 
-func (c *compiler) addConstant(constant interface{}) int {
+func (c *compiler) addConstant(constant any) int {
 	indexable := true
 	hash := constant
 	switch reflect.TypeOf(constant).Kind() {
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index 9a21979d8..c2e9c8f3c 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -41,7 +41,7 @@ func TestCompile(t *testing.T) {
 		{
 			`65535`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					math.MaxUint16,
 				},
 				Bytecode: []vm.Opcode{
@@ -53,7 +53,7 @@ func TestCompile(t *testing.T) {
 		{
 			`.5`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					.5,
 				},
 				Bytecode: []vm.Opcode{
@@ -74,7 +74,7 @@ func TestCompile(t *testing.T) {
 		{
 			`"string"`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					"string",
 				},
 				Bytecode: []vm.Opcode{
@@ -86,7 +86,7 @@ func TestCompile(t *testing.T) {
 		{
 			`"string" == "string"`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					"string",
 				},
 				Bytecode: []vm.Opcode{
@@ -100,7 +100,7 @@ func TestCompile(t *testing.T) {
 		{
 			`1000000 == 1000000`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					int64(1000000),
 				},
 				Bytecode: []vm.Opcode{
@@ -114,7 +114,7 @@ func TestCompile(t *testing.T) {
 		{
 			`-1`,
 			vm.Program{
-				Constants: []interface{}{1},
+				Constants: []any{1},
 				Bytecode: []vm.Opcode{
 					vm.OpPush,
 					vm.OpNegate,
@@ -155,7 +155,7 @@ func TestCompile(t *testing.T) {
 		{
 			`A.B.C.D`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					&runtime.Field{
 						Index: []int{0, 1, 2, 3},
 						Path:  []string{"A", "B", "C", "D"},
@@ -170,7 +170,7 @@ func TestCompile(t *testing.T) {
 		{
 			`A?.B.C.D`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					&runtime.Field{
 						Index: []int{0},
 						Path:  []string{"A"},
@@ -191,7 +191,7 @@ func TestCompile(t *testing.T) {
 		{
 			`A.B?.C.D`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					&runtime.Field{
 						Index: []int{0, 1},
 						Path:  []string{"A", "B"},
@@ -212,7 +212,7 @@ func TestCompile(t *testing.T) {
 		{
 			`A.Map["B"].C.D`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					&runtime.Field{
 						Index: []int{0, 2},
 						Path:  []string{"A", "Map"},
@@ -235,7 +235,7 @@ func TestCompile(t *testing.T) {
 		{
 			`A ?? 1`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					&runtime.Field{
 						Index: []int{0},
 						Path:  []string{"A"},
@@ -254,7 +254,7 @@ func TestCompile(t *testing.T) {
 		{
 			`A.Ptr + 1`,
 			vm.Program{
-				Constants: []interface{}{
+				Constants: []any{
 					&runtime.Field{
 						Index: []int{0, 3},
 						Path:  []string{"A", "Ptr"},
diff --git a/conf/config.go b/conf/config.go
index f44cfe7b1..5fb5e1194 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -10,7 +10,7 @@ import (
 )
 
 type Config struct {
-	Env         interface{}
+	Env         any
 	Types       TypesTable
 	MapEnv      bool
 	DefaultType reflect.Type
@@ -43,16 +43,16 @@ func CreateNew() *Config {
 }
 
 // New creates new config with environment.
-func New(env interface{}) *Config {
+func New(env any) *Config {
 	c := CreateNew()
 	c.WithEnv(env)
 	return c
 }
 
-func (c *Config) WithEnv(env interface{}) {
+func (c *Config) WithEnv(env any) {
 	var mapEnv bool
 	var mapValueType reflect.Type
-	if _, ok := env.(map[string]interface{}); ok {
+	if _, ok := env.(map[string]any); ok {
 		mapEnv = true
 	} else {
 		if reflect.ValueOf(env).Kind() == reflect.Map {
diff --git a/conf/types_table.go b/conf/types_table.go
index 592340069..8ebb76c35 100644
--- a/conf/types_table.go
+++ b/conf/types_table.go
@@ -20,7 +20,7 @@ type TypesTable map[string]Tag
 //
 // If map is passed, all items will be treated as variables
 // (key as name, value as type).
-func CreateTypesTable(i interface{}) TypesTable {
+func CreateTypesTable(i any) TypesTable {
 	if i == nil {
 		return nil
 	}
diff --git a/debug/debugger.go b/debug/debugger.go
index e8c38fc6f..6ee9788bf 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -12,7 +12,7 @@ import (
 	"github.com/rivo/tview"
 )
 
-func StartDebugger(program *Program, env interface{}) {
+func StartDebugger(program *Program, env any) {
 	vm := Debug()
 	app := tview.NewApplication()
 	table := tview.NewTable()
diff --git a/docgen/docgen.go b/docgen/docgen.go
index 672cd0183..a1145586f 100644
--- a/docgen/docgen.go
+++ b/docgen/docgen.go
@@ -76,7 +76,7 @@ var (
 	}
 )
 
-func CreateDoc(i interface{}) *Context {
+func CreateDoc(i any) *Context {
 	c := &Context{
 		Variables: make(map[Identifier]*Type),
 		Types:     make(map[TypeName]*Type),
diff --git a/docgen/docgen_test.go b/docgen/docgen_test.go
index 1eaa6d73b..e2b58b874 100644
--- a/docgen/docgen_test.go
+++ b/docgen/docgen_test.go
@@ -20,7 +20,7 @@ type Env struct {
 	Config struct {
 		MaxSize int32
 	}
-	Env map[string]interface{}
+	Env map[string]any
 	// NOTE: conflicting type name
 	TimeWeekday time.Weekday
 	Weekday     Weekday
@@ -201,7 +201,7 @@ func TestCreateDoc_Ambiguous(t *testing.T) {
 }
 
 func TestCreateDoc_FromMap(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"Tweets": []*Tweet{},
 		"Config": struct {
 			MaxSize int
diff --git a/expr.go b/expr.go
index fa6e7101d..eb9eb7683 100644
--- a/expr.go
+++ b/expr.go
@@ -22,7 +22,7 @@ type Option func(c *conf.Config)
 // as well as all fields of embedded structs and struct itself.
 // If map is passed, all items will be treated as variables.
 // Methods defined on this type will be available as functions.
-func Env(env interface{}) Option {
+func Env(env any) Option {
 	return func(c *conf.Config) {
 		c.WithEnv(env)
 	}
@@ -108,7 +108,7 @@ func Patch(visitor ast.Visitor) Option {
 }
 
 // Function adds function to list of functions what will be available in expressions.
-func Function(name string, fn func(params ...interface{}) (interface{}, error), types ...interface{}) Option {
+func Function(name string, fn func(params ...any) (any, error), types ...any) Option {
 	return func(c *conf.Config) {
 		ts := make([]reflect.Type, len(types))
 		for i, t := range types {
@@ -207,12 +207,12 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 }
 
 // Run evaluates given bytecode program.
-func Run(program *vm.Program, env interface{}) (interface{}, error) {
+func Run(program *vm.Program, env any) (any, error) {
 	return vm.Run(program, env)
 }
 
 // Eval parses, compiles and runs given input.
-func Eval(input string, env interface{}) (interface{}, error) {
+func Eval(input string, env any) (any, error) {
 	if _, ok := env.(Option); ok {
 		return nil, fmt.Errorf("misused expr.Eval: second argument (env) should be passed without expr.Env")
 	}
diff --git a/expr_test.go b/expr_test.go
index 54b216d4a..be8e406a9 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -16,7 +16,7 @@ import (
 )
 
 func ExampleEval() {
-	output, err := expr.Eval("greet + name", map[string]interface{}{
+	output, err := expr.Eval("greet + name", map[string]any{
 		"greet": "Hello, ",
 		"name":  "world!",
 	})
@@ -40,7 +40,7 @@ func ExampleEval_runtime_error() {
 }
 
 func ExampleCompile() {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"foo": 1,
 		"bar": 99,
 	}
@@ -176,7 +176,7 @@ func ExampleAsBool() {
 }
 
 func ExampleAsBool_error() {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"foo": 0,
 	}
 
@@ -206,7 +206,7 @@ func ExampleAsInt() {
 }
 
 func ExampleAsInt64() {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"rating": 5.5,
 	}
 
@@ -306,7 +306,7 @@ func fib(n int) int {
 func ExampleConstExpr() {
 	code := `[fib(5), fib(3+3), fib(dyn)]`
 
-	env := map[string]interface{}{
+	env := map[string]any{
 		"fib": fib,
 		"dyn": 0,
 	}
@@ -339,7 +339,7 @@ func ExampleConstExpr() {
 func ExampleAllowUndefinedVariables() {
 	code := `name == nil ? "Hello, world!" : sprintf("Hello, %v!", name)`
 
-	env := map[string]interface{}{
+	env := map[string]any{
 		"sprintf": fmt.Sprintf,
 	}
 
@@ -470,7 +470,7 @@ func ExamplePatch() {
 		return
 	}
 
-	env := map[string]interface{}{
+	env := map[string]any{
 		"greet": "Hello",
 		"get": func(a, b string) string {
 			return a + ", " + b
@@ -488,7 +488,7 @@ func ExamplePatch() {
 }
 
 func TestExpr_readme_example(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"greet":   "Hello, %v!",
 		"names":   []string{"world", "you"},
 		"sprintf": fmt.Sprintf,
@@ -562,7 +562,7 @@ func TestExpr(t *testing.T) {
 
 	tests := []struct {
 		code string
-		want interface{}
+		want any
 	}{
 		{
 			`1`,
@@ -758,11 +758,11 @@ func TestExpr(t *testing.T) {
 		},
 		{
 			`{foo: 0, bar: 1}`,
-			map[string]interface{}{"foo": 0, "bar": 1},
+			map[string]any{"foo": 0, "bar": 1},
 		},
 		{
 			`{foo: 0, bar: 1}`,
-			map[string]interface{}{"foo": 0, "bar": 1},
+			map[string]any{"foo": 0, "bar": 1},
 		},
 		{
 			`(true ? 0+1 : 2+3) + (false ? -1 : -2)`,
@@ -770,11 +770,11 @@ func TestExpr(t *testing.T) {
 		},
 		{
 			`filter(1..9, {# > 7})`,
-			[]interface{}{8, 9},
+			[]any{8, 9},
 		},
 		{
 			`map(1..3, {# * #})`,
-			[]interface{}{1, 4, 9},
+			[]any{1, 4, 9},
 		},
 		{
 			`all(1..3, {# > 0})`,
@@ -910,7 +910,7 @@ func TestExpr(t *testing.T) {
 		},
 		{
 			`map(filter(ArrayOfInt, # >= 3), # + 1)`,
-			[]interface{}{4, 5, 6},
+			[]any{4, 5, 6},
 		},
 		{
 			`Time < Time + Duration`,
@@ -954,11 +954,11 @@ func TestExpr(t *testing.T) {
 		},
 		{
 			`map(1..3, let x = #; let y = x * x; y * y)`,
-			[]interface{}{1, 16, 81},
+			[]any{1, 16, 81},
 		},
 		{
 			`map(1..2, let x = #; map(2..3, let y = #; x + y))`,
-			[]interface{}{[]interface{}{3, 4}, []interface{}{4, 5}},
+			[]any{[]any{3, 4}, []any{4, 5}},
 		},
 		{
 			`len(filter(1..99, # % 7 == 0))`,
@@ -1002,11 +1002,11 @@ func TestExpr(t *testing.T) {
 		},
 		{
 			`map(filter(1..9, # % 2 == 0), # * 2)`,
-			[]interface{}{4, 8, 12, 16},
+			[]any{4, 8, 12, 16},
 		},
 		{
 			`map(map(filter(1..9, # % 2 == 0), # * 2), # * 2)`,
-			[]interface{}{8, 16, 24, 32},
+			[]any{8, 16, 24, 32},
 		},
 		{
 			`first(map(filter(1..9, # % 2 == 0), # * 2))`,
@@ -1120,7 +1120,7 @@ func TestExpr_error(t *testing.T) {
 }
 
 func TestExpr_optional_chaining(t *testing.T) {
-	env := map[string]interface{}{}
+	env := map[string]any{}
 	program, err := expr.Compile("foo?.bar.baz", expr.Env(env), expr.AllowUndefinedVariables())
 	require.NoError(t, err)
 
@@ -1130,8 +1130,8 @@ func TestExpr_optional_chaining(t *testing.T) {
 }
 
 func TestExpr_optional_chaining_property(t *testing.T) {
-	env := map[string]interface{}{
-		"foo": map[string]interface{}{},
+	env := map[string]any{
+		"foo": map[string]any{},
 	}
 	program, err := expr.Compile("foo.bar?.baz", expr.Env(env))
 	require.NoError(t, err)
@@ -1142,10 +1142,10 @@ func TestExpr_optional_chaining_property(t *testing.T) {
 }
 
 func TestExpr_optional_chaining_nested_chains(t *testing.T) {
-	env := map[string]interface{}{
-		"foo": map[string]interface{}{
+	env := map[string]any{
+		"foo": map[string]any{
 			"id": 1,
-			"bar": []map[string]interface{}{
+			"bar": []map[string]any{
 				1: {
 					"baz": "baz",
 				},
@@ -1161,13 +1161,13 @@ func TestExpr_optional_chaining_nested_chains(t *testing.T) {
 }
 
 func TestExpr_eval_with_env(t *testing.T) {
-	_, err := expr.Eval("true", expr.Env(map[string]interface{}{}))
+	_, err := expr.Eval("true", expr.Env(map[string]any{}))
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "misused")
 }
 
 func TestExpr_fetch_from_func(t *testing.T) {
-	_, err := expr.Eval("foo.Value", map[string]interface{}{
+	_, err := expr.Eval("foo.Value", map[string]any{
 		"foo": func() {},
 	})
 	assert.Error(t, err)
@@ -1175,7 +1175,7 @@ func TestExpr_fetch_from_func(t *testing.T) {
 }
 
 func TestExpr_map_default_values(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"foo": map[string]string{},
 		"bar": map[string]*string{},
 	}
@@ -1192,7 +1192,7 @@ func TestExpr_map_default_values(t *testing.T) {
 
 func TestExpr_map_default_values_compile_check(t *testing.T) {
 	tests := []struct {
-		env   interface{}
+		env   any
 		input string
 	}{
 		{
@@ -1211,8 +1211,8 @@ func TestExpr_map_default_values_compile_check(t *testing.T) {
 }
 
 func TestExpr_calls_with_nil(t *testing.T) {
-	env := map[string]interface{}{
-		"equals": func(a, b interface{}) interface{} {
+	env := map[string]any{
+		"equals": func(a, b any) any {
 			assert.Nil(t, a, "a is not nil")
 			assert.Nil(t, b, "b is not nil")
 			return a == b
@@ -1234,8 +1234,8 @@ func TestExpr_calls_with_nil(t *testing.T) {
 }
 
 func TestExpr_call_float_arg_func_with_int(t *testing.T) {
-	env := map[string]interface{}{
-		"cnv": func(f float64) interface{} {
+	env := map[string]any{
+		"cnv": func(f float64) any {
 			return f
 		},
 	}
@@ -1264,7 +1264,7 @@ func TestExpr_call_float_arg_func_with_int(t *testing.T) {
 }
 
 func TestConstExpr_error_panic(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"divide": func(a, b int) int { return a / b },
 	}
 
@@ -1284,7 +1284,7 @@ func (e divideError) Error() string {
 }
 
 func TestConstExpr_error_as_error(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"divide": func(a, b int) (int, error) {
 			if b == 0 {
 				return 0, divideError{"integer divide by zero"}
@@ -1304,7 +1304,7 @@ func TestConstExpr_error_as_error(t *testing.T) {
 }
 
 func TestConstExpr_error_wrong_type(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"divide": 0,
 	}
 	assert.Panics(t, func() {
@@ -1434,7 +1434,7 @@ func TestIssue_nested_closures(t *testing.T) {
 }
 
 func TestIssue138(t *testing.T) {
-	env := map[string]interface{}{}
+	env := map[string]any{}
 
 	_, err := expr.Compile(`1 / (1 - 1)`, expr.Env(env))
 	require.NoError(t, err)
@@ -1446,9 +1446,9 @@ func TestIssue138(t *testing.T) {
 
 func TestIssue154(t *testing.T) {
 	type Data struct {
-		Array  *[2]interface{}
-		Slice  *[]interface{}
-		Map    *map[string]interface{}
+		Array  *[2]any
+		Slice  *[]any
+		Map    *map[string]any
 		String *string
 	}
 
@@ -1460,17 +1460,17 @@ func TestIssue154(t *testing.T) {
 	i := 10
 	s := "value"
 
-	Array := [2]interface{}{
+	Array := [2]any{
 		&b,
 		&i,
 	}
 
-	Slice := []interface{}{
+	Slice := []any{
 		&b,
 		&i,
 	}
 
-	Map := map[string]interface{}{
+	Map := map[string]any{
 		"Bool": &b,
 		"Int":  &i,
 	}
@@ -1505,7 +1505,7 @@ func TestIssue154(t *testing.T) {
 }
 
 func TestIssue270(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"int8":     int8(1),
 		"int16":    int16(3),
 		"int32":    int32(5),
@@ -1603,7 +1603,7 @@ func (i Issue346Array) Len() int {
 func TestIssue346(t *testing.T) {
 	code := `Foo[0].Bar`
 
-	env := map[string]interface{}{
+	env := map[string]any{
 		"Foo": Issue346Array{
 			{Bar: "bar"},
 		},
@@ -1618,8 +1618,8 @@ func TestIssue346(t *testing.T) {
 
 func TestCompile_allow_to_use_interface_to_get_an_element_from_map(t *testing.T) {
 	code := `{"value": "ok"}[vars.key]`
-	env := map[string]interface{}{
-		"vars": map[string]interface{}{
+	env := map[string]any{
+		"vars": map[string]any{
 			"key": "value",
 		},
 	}
@@ -1648,8 +1648,8 @@ func TestCompile_allow_to_use_interface_to_get_an_element_from_map(t *testing.T)
 }
 
 func TestFastCall(t *testing.T) {
-	env := map[string]interface{}{
-		"func": func(in interface{}) float64 {
+	env := map[string]any{
+		"func": func(in any) float64 {
 			return 8
 		},
 	}
@@ -1664,8 +1664,8 @@ func TestFastCall(t *testing.T) {
 }
 
 func TestFastCall_OpCallFastErr(t *testing.T) {
-	env := map[string]interface{}{
-		"func": func(...interface{}) (interface{}, error) {
+	env := map[string]any{
+		"func": func(...any) (any, error) {
 			return 8, nil
 		},
 	}
@@ -1680,7 +1680,7 @@ func TestFastCall_OpCallFastErr(t *testing.T) {
 }
 
 func TestRun_custom_func_returns_an_error_as_second_arg(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"semver": func(value string, cmp string) (bool, error) { return true, nil },
 	}
 
@@ -1695,7 +1695,7 @@ func TestRun_custom_func_returns_an_error_as_second_arg(t *testing.T) {
 func TestFunction(t *testing.T) {
 	add := expr.Function(
 		"add",
-		func(p ...interface{}) (interface{}, error) {
+		func(p ...any) (any, error) {
 			out := 0
 			for _, each := range p {
 				out += each.(int)
@@ -1715,8 +1715,8 @@ func TestFunction(t *testing.T) {
 
 // Nil coalescing operator
 func TestRun_NilCoalescingOperator(t *testing.T) {
-	env := map[string]interface{}{
-		"foo": map[string]interface{}{
+	env := map[string]any{
+		"foo": map[string]any{
 			"bar": "value",
 		},
 	}
@@ -1743,16 +1743,16 @@ func TestRun_NilCoalescingOperator(t *testing.T) {
 		p, err := expr.Compile(`foo?.bar ?? "default"`, expr.Env(env))
 		assert.NoError(t, err)
 
-		out, err := expr.Run(p, map[string]interface{}{})
+		out, err := expr.Run(p, map[string]any{})
 		assert.NoError(t, err)
 		assert.Equal(t, "default", out)
 	})
 }
 
 func TestEval_nil_in_maps(t *testing.T) {
-	env := map[string]interface{}{
-		"m":     map[interface{}]interface{}{nil: "bar"},
-		"empty": map[interface{}]interface{}{},
+	env := map[string]any{
+		"m":     map[any]any{nil: "bar"},
+		"empty": map[any]any{},
 	}
 	t.Run("nil key exists", func(t *testing.T) {
 		p, err := expr.Compile(`m[nil]`, expr.Env(env))
@@ -1791,7 +1791,7 @@ func TestEval_nil_in_maps(t *testing.T) {
 // Test the use of env keyword.  Forms env[] and env[”] are valid.
 // The enclosed identifier must be in the expression env.
 func TestEnv_keyword(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"space test":                       "ok",
 		"space_test":                       "not ok", // Seems to be some underscore substituting happening, check that.
 		"Section 1-2a":                     "ok",
@@ -1825,7 +1825,7 @@ func TestEnv_keyword(t *testing.T) {
 	// No error cases
 	var tests = []struct {
 		code string
-		want interface{}
+		want any
 	}{
 		{"$env['space test']", "ok"},
 		{"$env['Section 1-2a']", "ok"},
@@ -1872,7 +1872,7 @@ func TestEnv_keyword(t *testing.T) {
 	// error cases
 	tests = []struct {
 		code string
-		want interface{}
+		want any
 	}{
 		{"env()", "bad"},
 	}
@@ -1891,7 +1891,7 @@ func TestIssue401(t *testing.T) {
 	program, err := expr.Compile("(a - b + c) / d", expr.AllowUndefinedVariables())
 	require.NoError(t, err, "compile error")
 
-	output, err := expr.Run(program, map[string]interface{}{
+	output, err := expr.Run(program, map[string]any{
 		"a": 1,
 		"b": 2,
 		"c": 3,
@@ -1904,12 +1904,12 @@ func TestIssue401(t *testing.T) {
 func TestEval_slices_out_of_bound(t *testing.T) {
 	tests := []struct {
 		code string
-		want interface{}
+		want any
 	}{
-		{"[1, 2, 3][:99]", []interface{}{1, 2, 3}},
-		{"[1, 2, 3][99:]", []interface{}{}},
-		{"[1, 2, 3][:-99]", []interface{}{}},
-		{"[1, 2, 3][-99:]", []interface{}{1, 2, 3}},
+		{"[1, 2, 3][:99]", []any{1, 2, 3}},
+		{"[1, 2, 3][99:]", []any{}},
+		{"[1, 2, 3][:-99]", []any{}},
+		{"[1, 2, 3][-99:]", []any{1, 2, 3}},
 	}
 
 	for _, tt := range tests {
diff --git a/optimizer/const_expr.go b/optimizer/const_expr.go
index 7ececb3db..694c88bcf 100644
--- a/optimizer/const_expr.go
+++ b/optimizer/const_expr.go
@@ -42,7 +42,7 @@ func (c *constExpr) Visit(node *Node) {
 				in := make([]reflect.Value, len(call.Arguments))
 				for i := 0; i < len(call.Arguments); i++ {
 					arg := call.Arguments[i]
-					var param interface{}
+					var param any
 
 					switch a := arg.(type) {
 					case *NilNode:
diff --git a/optimizer/fold.go b/optimizer/fold.go
index 8d31a5cc5..670ebec09 100644
--- a/optimizer/fold.go
+++ b/optimizer/fold.go
@@ -285,7 +285,7 @@ func (fold *fold) Visit(node *Node) {
 					return
 				}
 			}
-			value := make([]interface{}, len(n.Nodes))
+			value := make([]any, len(n.Nodes))
 			for i, a := range n.Nodes {
 				switch b := a.(type) {
 				case *IntegerNode:
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 4f2130618..7ecbefa29 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -23,7 +23,7 @@ func TestOptimize_constant_folding(t *testing.T) {
 	require.NoError(t, err)
 
 	expected := &ast.MemberNode{
-		Node:     &ast.ConstantNode{Value: []interface{}{1, 2, 3}},
+		Node:     &ast.ConstantNode{Value: []any{1, 2, 3}},
 		Property: &ast.IntegerNode{Value: 0},
 	}
 
@@ -134,7 +134,7 @@ func TestOptimize_const_expr(t *testing.T) {
 	tree, err := parser.Parse(`toUpper("hello")`)
 	require.NoError(t, err)
 
-	env := map[string]interface{}{
+	env := map[string]any{
 		"toUpper": strings.ToUpper,
 	}
 
diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go
index cfb1e8c61..5db2dcbb5 100644
--- a/parser/lexer/lexer.go
+++ b/parser/lexer/lexer.go
@@ -150,7 +150,7 @@ func (l *lexer) acceptWord(word string) bool {
 	return true
 }
 
-func (l *lexer) error(format string, args ...interface{}) stateFn {
+func (l *lexer) error(format string, args ...any) stateFn {
 	if l.err == nil { // show first error
 		l.err = &file.Error{
 			Location: l.loc,
diff --git a/parser/parser.go b/parser/parser.go
index 87cdb2982..229f8e1b3 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -81,11 +81,11 @@ func ParseWithConfig(input string, config *conf.Config) (*Tree, error) {
 	}, nil
 }
 
-func (p *parser) error(format string, args ...interface{}) {
+func (p *parser) error(format string, args ...any) {
 	p.errorAt(p.current, format, args...)
 }
 
-func (p *parser) errorAt(token Token, format string, args ...interface{}) {
+func (p *parser) errorAt(token Token, format string, args ...any) {
 	if p.err == nil { // show first error
 		p.err = &file.Error{
 			Location: token.Location,
diff --git a/repl/repl.go b/repl/repl.go
index 1e70feffe..2508973d4 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -36,7 +36,7 @@ func main() {
 	}
 	defer rl.Close()
 
-	env := map[string]interface{}{
+	env := map[string]any{
 		"ENV": os.Environ(),
 	}
 	var program *vm.Program
diff --git a/test/coredns/coredns.go b/test/coredns/coredns.go
index 068946487..40f005243 100644
--- a/test/coredns/coredns.go
+++ b/test/coredns/coredns.go
@@ -6,8 +6,8 @@ import (
 	"net"
 )
 
-func DefaultEnv(ctx context.Context, state *Request) map[string]interface{} {
-	return map[string]interface{}{
+func DefaultEnv(ctx context.Context, state *Request) map[string]any {
+	return map[string]any{
 		"incidr": func(ipStr, cidrStr string) (bool, error) {
 			ip := net.ParseIP(ipStr)
 			if ip == nil {
diff --git a/test/crowdsec/crowdsec.go b/test/crowdsec/crowdsec.go
index e1ec1becb..7a6a03751 100644
--- a/test/crowdsec/crowdsec.go
+++ b/test/crowdsec/crowdsec.go
@@ -5,22 +5,22 @@ import (
 )
 
 type Event struct {
-	Type            int                    `yaml:"Type,omitempty" json:"Type,omitempty"`
-	ExpectMode      int                    `yaml:"ExpectMode,omitempty" json:"ExpectMode,omitempty"`
-	Whitelisted     bool                   `yaml:"Whitelisted,omitempty" json:"Whitelisted,omitempty"`
-	WhitelistReason string                 `yaml:"WhitelistReason,omitempty" json:"whitelist_reason,omitempty"`
-	Stage           string                 `yaml:"Stage,omitempty" json:"Stage,omitempty"`
-	Line            Line                   `yaml:"Line,omitempty" json:"Line,omitempty"`
-	Parsed          map[string]string      `yaml:"Parsed,omitempty" json:"Parsed,omitempty"`
-	Enriched        map[string]string      `yaml:"Enriched,omitempty" json:"Enriched,omitempty"`
-	Unmarshaled     map[string]interface{} `yaml:"Unmarshaled,omitempty" json:"Unmarshaled,omitempty"`
-	Overflow        RuntimeAlert           `yaml:"Overflow,omitempty" json:"Alert,omitempty"`
-	Time            time.Time              `yaml:"Time,omitempty" json:"Time,omitempty"`
-	StrTime         string                 `yaml:"StrTime,omitempty" json:"StrTime,omitempty"`
-	StrTimeFormat   string                 `yaml:"StrTimeFormat,omitempty" json:"StrTimeFormat,omitempty"`
-	MarshaledTime   string                 `yaml:"MarshaledTime,omitempty" json:"MarshaledTime,omitempty"`
-	Process         bool                   `yaml:"Process,omitempty" json:"Process,omitempty"`
-	Meta            map[string]string      `yaml:"Meta,omitempty" json:"Meta,omitempty"`
+	Type            int               `yaml:"Type,omitempty" json:"Type,omitempty"`
+	ExpectMode      int               `yaml:"ExpectMode,omitempty" json:"ExpectMode,omitempty"`
+	Whitelisted     bool              `yaml:"Whitelisted,omitempty" json:"Whitelisted,omitempty"`
+	WhitelistReason string            `yaml:"WhitelistReason,omitempty" json:"whitelist_reason,omitempty"`
+	Stage           string            `yaml:"Stage,omitempty" json:"Stage,omitempty"`
+	Line            Line              `yaml:"Line,omitempty" json:"Line,omitempty"`
+	Parsed          map[string]string `yaml:"Parsed,omitempty" json:"Parsed,omitempty"`
+	Enriched        map[string]string `yaml:"Enriched,omitempty" json:"Enriched,omitempty"`
+	Unmarshaled     map[string]any    `yaml:"Unmarshaled,omitempty" json:"Unmarshaled,omitempty"`
+	Overflow        RuntimeAlert      `yaml:"Overflow,omitempty" json:"Alert,omitempty"`
+	Time            time.Time         `yaml:"Time,omitempty" json:"Time,omitempty"`
+	StrTime         string            `yaml:"StrTime,omitempty" json:"StrTime,omitempty"`
+	StrTimeFormat   string            `yaml:"StrTimeFormat,omitempty" json:"StrTimeFormat,omitempty"`
+	MarshaledTime   string            `yaml:"MarshaledTime,omitempty" json:"MarshaledTime,omitempty"`
+	Process         bool              `yaml:"Process,omitempty" json:"Process,omitempty"`
+	Meta            map[string]string `yaml:"Meta,omitempty" json:"Meta,omitempty"`
 }
 
 func (e *Event) GetType() string {
diff --git a/test/crowdsec/crowdsec_test.go b/test/crowdsec/crowdsec_test.go
index 0ff2f6211..e38190a38 100644
--- a/test/crowdsec/crowdsec_test.go
+++ b/test/crowdsec/crowdsec_test.go
@@ -18,7 +18,7 @@ func TestCrowdsec(t *testing.T) {
 	err = json.Unmarshal(b, &examples)
 	require.NoError(t, err)
 
-	env := map[string]interface{}{
+	env := map[string]any{
 		"evt": &crowdsec.Event{},
 	}
 
@@ -30,7 +30,7 @@ func TestCrowdsec(t *testing.T) {
 			opt,
 			expr.Function(
 				fn.Name,
-				func(params ...interface{}) (interface{}, error) {
+				func(params ...any) (any, error) {
 					return nil, nil
 				},
 				fn.Func...,
diff --git a/test/crowdsec/funcs.go b/test/crowdsec/funcs.go
index acc14c545..928cc1f9d 100644
--- a/test/crowdsec/funcs.go
+++ b/test/crowdsec/funcs.go
@@ -6,347 +6,347 @@ import (
 
 var CustomFunctions = []struct {
 	Name string
-	Func []interface{}
+	Func []any
 }{
 	{
 		Name: "Distance",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string, string, string) (float64, error)),
 		},
 	},
 	{
 		Name: "GetFromStash",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) (string, error)),
 		},
 	},
 	{
 		Name: "Atof",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) float64),
 		},
 	},
 	{
 		Name: "JsonExtract",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) string),
 		},
 	},
 	{
 		Name: "JsonExtractUnescape",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, ...string) string),
 		},
 	},
 	{
 		Name: "JsonExtractLib",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, ...string) string),
 		},
 	},
 	{
 		Name: "JsonExtractSlice",
-		Func: []interface{}{
-			new(func(string, string) []interface{}),
+		Func: []any{
+			new(func(string, string) []any),
 		},
 	},
 	{
 		Name: "JsonExtractObject",
-		Func: []interface{}{
-			new(func(string, string) map[string]interface{}),
+		Func: []any{
+			new(func(string, string) map[string]any),
 		},
 	},
 	{
 		Name: "ToJsonString",
-		Func: []interface{}{
-			new(func(interface{}) string),
+		Func: []any{
+			new(func(any) string),
 		},
 	},
 	{
 		Name: "File",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) []string),
 		},
 	},
 	{
 		Name: "RegexpInFile",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) bool),
 		},
 	},
 	{
 		Name: "Upper",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) string),
 		},
 	},
 	{
 		Name: "Lower",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) string),
 		},
 	},
 	{
 		Name: "IpInRange",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) bool),
 		},
 	},
 	{
 		Name: "TimeNow",
-		Func: []interface{}{
+		Func: []any{
 			new(func() string),
 		},
 	},
 	{
 		Name: "ParseUri",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) map[string][]string),
 		},
 	},
 	{
 		Name: "PathUnescape",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) string),
 		},
 	},
 	{
 		Name: "QueryUnescape",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) string),
 		},
 	},
 	{
 		Name: "PathEscape",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) string),
 		},
 	},
 	{
 		Name: "QueryEscape",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) string),
 		},
 	},
 	{
 		Name: "XMLGetAttributeValue",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string, string) string),
 		},
 	},
 	{
 		Name: "XMLGetNodeValue",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) string),
 		},
 	},
 	{
 		Name: "IpToRange",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) string),
 		},
 	},
 	{
 		Name: "IsIPV6",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) bool),
 		},
 	},
 	{
 		Name: "IsIPV4",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) bool),
 		},
 	},
 	{
 		Name: "IsIP",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) bool),
 		},
 	},
 	{
 		Name: "LookupHost",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) []string),
 		},
 	},
 	{
 		Name: "GetDecisionsCount",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) int),
 		},
 	},
 	{
 		Name: "GetDecisionsSinceCount",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) int),
 		},
 	},
 	{
 		Name: "Sprintf",
-		Func: []interface{}{
-			new(func(string, ...interface{}) string),
+		Func: []any{
+			new(func(string, ...any) string),
 		},
 	},
 	{
 		Name: "ParseUnix",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) string),
 		},
 	},
 	{
 		Name: "SetInStash",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string, string, *time.Duration) error),
 		},
 	},
 	{
 		Name: "Fields",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) []string),
 		},
 	},
 	{
 		Name: "Index",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) int),
 		},
 	},
 	{
 		Name: "IndexAny",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) int),
 		},
 	},
 	{
 		Name: "Join",
-		Func: []interface{}{
+		Func: []any{
 			new(func([]string, string) string),
 		},
 	},
 	{
 		Name: "Split",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) []string),
 		},
 	},
 	{
 		Name: "SplitAfter",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) []string),
 		},
 	},
 	{
 		Name: "SplitAfterN",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string, int) []string),
 		},
 	},
 	{
 		Name: "SplitN",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string, int) []string),
 		},
 	},
 	{
 		Name: "Replace",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string, string, int) string),
 		},
 	},
 	{
 		Name: "ReplaceAll",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string, string) string),
 		},
 	},
 	{
 		Name: "Trim",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) string),
 		},
 	},
 	{
 		Name: "TrimLeft",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) string),
 		},
 	},
 	{
 		Name: "TrimRight",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) string),
 		},
 	},
 	{
 		Name: "TrimSpace",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) string),
 		},
 	},
 	{
 		Name: "TrimPrefix",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) string),
 		},
 	},
 	{
 		Name: "TrimSuffix",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) string),
 		},
 	},
 	{
 		Name: "Get",
-		Func: []interface{}{
+		Func: []any{
 			new(func([]string, int) string),
 		},
 	},
 	{
 		Name: "ToString",
-		Func: []interface{}{
-			new(func(interface{}) string),
+		Func: []any{
+			new(func(any) string),
 		},
 	},
 	{
 		Name: "Match",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string, string) bool),
 		},
 	},
 	{
 		Name: "KeyExists",
-		Func: []interface{}{
-			new(func(string, map[string]interface{}) bool),
+		Func: []any{
+			new(func(string, map[string]any) bool),
 		},
 	},
 	{
 		Name: "LogInfo",
-		Func: []interface{}{
-			new(func(string, ...interface{}) bool),
+		Func: []any{
+			new(func(string, ...any) bool),
 		},
 	},
 	{
 		Name: "B64Decode",
-		Func: []interface{}{
+		Func: []any{
 			new(func(string) string),
 		},
 	},
 	{
 		Name: "UnmarshalJSON",
-		Func: []interface{}{
-			new(func(string, map[string]interface{}, string) error),
+		Func: []any{
+			new(func(string, map[string]any, string) error),
 		},
 	},
 	{
 		Name: "ParseKV",
-		Func: []interface{}{
-			new(func(string, map[string]interface{}, string) error),
+		Func: []any{
+			new(func(string, map[string]any, string) error),
 		},
 	},
 	{
 		Name: "Hostname",
-		Func: []interface{}{
+		Func: []any{
 			new(func() (string, error)),
 		},
 	},
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 1e1bb83a1..4af128bde 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -10,9 +10,9 @@ import (
 
 func TestDeref_binary(t *testing.T) {
 	i := 1
-	env := map[string]interface{}{
+	env := map[string]any{
 		"i": &i,
-		"obj": map[string]interface{}{
+		"obj": map[string]any{
 			"i": &i,
 		},
 	}
@@ -45,9 +45,9 @@ func TestDeref_binary(t *testing.T) {
 func TestDeref_unary(t *testing.T) {
 	i := 1
 	ok := true
-	env := map[string]interface{}{
+	env := map[string]any{
 		"i": &i,
-		"obj": map[string]interface{}{
+		"obj": map[string]any{
 			"ok": &ok,
 		},
 	}
@@ -62,9 +62,9 @@ func TestDeref_unary(t *testing.T) {
 
 func TestDeref_eval(t *testing.T) {
 	i := 1
-	env := map[string]interface{}{
+	env := map[string]any{
 		"i": &i,
-		"obj": map[string]interface{}{
+		"obj": map[string]any{
 			"i": &i,
 		},
 	}
@@ -77,7 +77,7 @@ func TestDeref_emptyCtx(t *testing.T) {
 	program, err := expr.Compile(`ctx`)
 	require.NoError(t, err)
 
-	output, err := expr.Run(program, map[string]interface{}{
+	output, err := expr.Run(program, map[string]any{
 		"ctx": context.Background(),
 	})
 	require.NoError(t, err)
@@ -85,7 +85,7 @@ func TestDeref_emptyCtx(t *testing.T) {
 }
 
 func TestDeref_emptyCtx_Eval(t *testing.T) {
-	output, err := expr.Eval(`ctx`, map[string]interface{}{
+	output, err := expr.Eval(`ctx`, map[string]any{
 		"ctx": context.Background(),
 	})
 	require.NoError(t, err)
@@ -96,7 +96,7 @@ func TestDeref_context_WithValue(t *testing.T) {
 	program, err := expr.Compile(`ctxWithValue`)
 	require.NoError(t, err)
 
-	output, err := expr.Run(program, map[string]interface{}{
+	output, err := expr.Run(program, map[string]any{
 		"ctxWithValue": context.WithValue(context.Background(), "value", "test"),
 	})
 	require.NoError(t, err)
@@ -104,7 +104,7 @@ func TestDeref_context_WithValue(t *testing.T) {
 }
 
 func TestDeref_method_on_int_pointer(t *testing.T) {
-	output, err := expr.Eval(`foo.Bar()`, map[string]interface{}{
+	output, err := expr.Eval(`foo.Bar()`, map[string]any{
 		"foo": new(foo),
 	})
 	require.NoError(t, err)
@@ -122,7 +122,7 @@ func TestDeref_multiple_pointers(t *testing.T) {
 	b := &a
 	c := &b
 	t.Run("returned as is", func(t *testing.T) {
-		output, err := expr.Eval(`c`, map[string]interface{}{
+		output, err := expr.Eval(`c`, map[string]any{
 			"c": c,
 		})
 		require.NoError(t, err)
@@ -130,7 +130,7 @@ func TestDeref_multiple_pointers(t *testing.T) {
 		require.IsType(t, (**int)(nil), output)
 	})
 	t.Run("+ works", func(t *testing.T) {
-		output, err := expr.Eval(`c+2`, map[string]interface{}{
+		output, err := expr.Eval(`c+2`, map[string]any{
 			"c": c,
 		})
 		require.NoError(t, err)
diff --git a/test/interface_method/interface_method_test.go b/test/interface_method/interface_method_test.go
index 44d765f04..ab49d5356 100644
--- a/test/interface_method/interface_method_test.go
+++ b/test/interface_method/interface_method_test.go
@@ -35,7 +35,7 @@ func TestInterfaceMethod(t *testing.T) {
 	require.True(t, BarImpl{}.Aba())
 	require.True(t, BarImpl{}.Bar() == 42)
 
-	env := map[string]interface{}{
+	env := map[string]any{
 		"var": FooImpl{},
 	}
 	p, err := expr.Compile(`var.Foo().Bar()`, expr.Env(env))
diff --git a/test/mock/mock.go b/test/mock/mock.go
index b2798a045..ad4a91563 100644
--- a/test/mock/mock.go
+++ b/test/mock/mock.go
@@ -12,7 +12,7 @@ import (
 type Env struct {
 	Embed
 	Ambiguous          string
-	Any                interface{}
+	Any                any
 	Bool               bool
 	Float              float64
 	Int64              int64
@@ -30,24 +30,24 @@ type Env struct {
 	StringPtr          *string
 	Foo                Foo
 	Abstract           Abstract
-	ArrayOfAny         []interface{}
+	ArrayOfAny         []any
 	ArrayOfInt         []int
 	ArrayOfString      []string
 	ArrayOfFoo         []*Foo
 	MapOfFoo           map[string]Foo
-	MapOfAny           map[string]interface{}
+	MapOfAny           map[string]any
 	MapIntAny          map[int]string
 	FuncParam          func(_ bool, _ int, _ string) bool
-	FuncParamAny       func(_ interface{}) bool
+	FuncParamAny       func(_ any) bool
 	FuncTooManyReturns func() (int, int, error)
 	FuncNamed          MyFunc
-	NilAny             interface{}
+	NilAny             any
 	NilInt             *int
 	NilFn              func()
 	NilStruct          *Foo
-	NilSlice           []interface{}
+	NilSlice           []any
 	Variadic           func(_ int, _ ...int) bool
-	Fast               func(...interface{}) interface{}
+	Fast               func(...any) any
 	Time               time.Time
 	TimePlusDay        time.Time
 	Duration           time.Duration
@@ -172,6 +172,6 @@ type MapStringIntEnv map[string]int
 
 type Is struct{}
 
-func (Is) Nil(a interface{}) bool {
+func (Is) Nil(a any) bool {
 	return a == nil
 }
diff --git a/test/pipes/pipes_test.go b/test/pipes/pipes_test.go
index 6a0e2950b..98c55f5fc 100644
--- a/test/pipes/pipes_test.go
+++ b/test/pipes/pipes_test.go
@@ -9,13 +9,13 @@ import (
 )
 
 func TestPipes(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"sprintf": fmt.Sprintf,
 	}
 
 	tests := []struct {
 		input string
-		want  interface{}
+		want  any
 	}{
 		{
 			`-1 | abs()`,
@@ -53,5 +53,5 @@ func TestPipes_map_filter(t *testing.T) {
 
 	out, err := expr.Run(program, nil)
 	require.NoError(t, err)
-	require.Equal(t, []interface{}{2, 4, 6, 8, 10}, out)
+	require.Equal(t, []any{2, 4, 6, 8, 10}, out)
 }
diff --git a/test/time/time_test.go b/test/time/time_test.go
index 4b659367c..7012a24cf 100644
--- a/test/time/time_test.go
+++ b/test/time/time_test.go
@@ -19,10 +19,10 @@ func TestTime(t *testing.T) {
 	testDuration := time.Duration(1)
 
 	tests := []struct {
-		a       interface{}
-		b       interface{}
+		a       any
+		b       any
 		op      string
-		want    interface{}
+		want    any
 		wantErr bool
 	}{
 		{a: testTime, b: testTime, op: "<", wantErr: false, want: false},
@@ -72,7 +72,7 @@ func TestTime(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(fmt.Sprintf("time helper test `%T %s %T`", tt.a, tt.op, tt.b), func(t *testing.T) {
 			input := fmt.Sprintf("a %v b", tt.op)
-			env := map[string]interface{}{
+			env := map[string]any{
 				"a": tt.a,
 				"b": tt.b,
 			}
@@ -103,7 +103,7 @@ func TestTime(t *testing.T) {
 }
 
 func TestTime_duration(t *testing.T) {
-	env := map[string]interface{}{
+	env := map[string]any{
 		"foo": time.Date(2000, time.Month(1), 1, 0, 0, 0, 0, time.UTC),
 	}
 	program, err := expr.Compile(`now() - duration("1h") < now() && foo + duration("24h") < now()`, expr.Env(env))
diff --git a/vm/func_types/main.go b/vm/func_types/main.go
index 8d99ba044..6262261ef 100644
--- a/vm/func_types/main.go
+++ b/vm/func_types/main.go
@@ -11,21 +11,21 @@ import (
 )
 
 // Keep sorted.
-var types = []interface{}{
+var types = []any{
 	nil,
 	new(func() Duration),
 	new(func() Month),
 	new(func() Time),
 	new(func() Weekday),
 	new(func() []byte),
-	new(func() []interface{}),
+	new(func() []any),
 	new(func() bool),
 	new(func() byte),
 	new(func() float64),
 	new(func() int),
 	new(func() int64),
-	new(func() interface{}),
-	new(func() map[string]interface{}),
+	new(func() any),
+	new(func() map[string]any),
 	new(func() rune),
 	new(func() string),
 	new(func() uint),
@@ -34,7 +34,7 @@ var types = []interface{}{
 	new(func(Duration) Time),
 	new(func(Time) Duration),
 	new(func(Time) bool),
-	new(func([]interface{}, string) string),
+	new(func([]any, string) string),
 	new(func([]string, string) string),
 	new(func(bool) bool),
 	new(func(bool) float64),
@@ -61,20 +61,20 @@ var types = []interface{}{
 	new(func(string, rune) int),
 	new(func(string, string) bool),
 	new(func(string, string) string),
-	new(func(interface{}) bool),
-	new(func(interface{}) float64),
-	new(func(interface{}) int),
-	new(func(interface{}) string),
-	new(func(interface{}) interface{}),
-	new(func(interface{}) []interface{}),
-	new(func(interface{}) map[string]interface{}),
-	new(func([]interface{}) interface{}),
-	new(func([]interface{}) []interface{}),
-	new(func([]interface{}) map[string]interface{}),
-	new(func(interface{}, interface{}) bool),
-	new(func(interface{}, interface{}) string),
-	new(func(interface{}, interface{}) interface{}),
-	new(func(interface{}, interface{}) []interface{}),
+	new(func(any) bool),
+	new(func(any) float64),
+	new(func(any) int),
+	new(func(any) string),
+	new(func(any) any),
+	new(func(any) []any),
+	new(func(any) map[string]any),
+	new(func([]any) any),
+	new(func([]any) []any),
+	new(func([]any) map[string]any),
+	new(func(any, any) bool),
+	new(func(any, any) string),
+	new(func(any, any) any),
+	new(func(any, any) []any),
 }
 
 func main() {
diff --git a/vm/generated.go b/vm/generated.go
index 9fc7883e2..1a0b36571 100644
--- a/vm/generated.go
+++ b/vm/generated.go
@@ -7,20 +7,20 @@ import (
 	"time"
 )
 
-var FuncTypes = []interface{}{
+var FuncTypes = []any{
 	1:  new(func() time.Duration),
 	2:  new(func() time.Month),
 	3:  new(func() time.Time),
 	4:  new(func() time.Weekday),
 	5:  new(func() []uint8),
-	6:  new(func() []interface{}),
+	6:  new(func() []any),
 	7:  new(func() bool),
 	8:  new(func() uint8),
 	9:  new(func() float64),
 	10: new(func() int),
 	11: new(func() int64),
-	12: new(func() interface{}),
-	13: new(func() map[string]interface{}),
+	12: new(func() any),
+	13: new(func() map[string]any),
 	14: new(func() int32),
 	15: new(func() string),
 	16: new(func() uint),
@@ -29,7 +29,7 @@ var FuncTypes = []interface{}{
 	19: new(func(time.Duration) time.Time),
 	20: new(func(time.Time) time.Duration),
 	21: new(func(time.Time) bool),
-	22: new(func([]interface{}, string) string),
+	22: new(func([]any, string) string),
 	23: new(func([]string, string) string),
 	24: new(func(bool) bool),
 	25: new(func(bool) float64),
@@ -56,23 +56,23 @@ var FuncTypes = []interface{}{
 	46: new(func(string, int32) int),
 	47: new(func(string, string) bool),
 	48: new(func(string, string) string),
-	49: new(func(interface{}) bool),
-	50: new(func(interface{}) float64),
-	51: new(func(interface{}) int),
-	52: new(func(interface{}) string),
-	53: new(func(interface{}) interface{}),
-	54: new(func(interface{}) []interface{}),
-	55: new(func(interface{}) map[string]interface{}),
-	56: new(func([]interface{}) interface{}),
-	57: new(func([]interface{}) []interface{}),
-	58: new(func([]interface{}) map[string]interface{}),
-	59: new(func(interface{}, interface{}) bool),
-	60: new(func(interface{}, interface{}) string),
-	61: new(func(interface{}, interface{}) interface{}),
-	62: new(func(interface{}, interface{}) []interface{}),
+	49: new(func(any) bool),
+	50: new(func(any) float64),
+	51: new(func(any) int),
+	52: new(func(any) string),
+	53: new(func(any) any),
+	54: new(func(any) []any),
+	55: new(func(any) map[string]any),
+	56: new(func([]any) any),
+	57: new(func([]any) []any),
+	58: new(func([]any) map[string]any),
+	59: new(func(any, any) bool),
+	60: new(func(any, any) string),
+	61: new(func(any, any) any),
+	62: new(func(any, any) []any),
 }
 
-func (vm *VM) call(fn interface{}, kind int) interface{} {
+func (vm *VM) call(fn any, kind int) any {
 	switch kind {
 	case 1:
 		return fn.(func() time.Duration)()
@@ -85,7 +85,7 @@ func (vm *VM) call(fn interface{}, kind int) interface{} {
 	case 5:
 		return fn.(func() []uint8)()
 	case 6:
-		return fn.(func() []interface{})()
+		return fn.(func() []any)()
 	case 7:
 		return fn.(func() bool)()
 	case 8:
@@ -97,9 +97,9 @@ func (vm *VM) call(fn interface{}, kind int) interface{} {
 	case 11:
 		return fn.(func() int64)()
 	case 12:
-		return fn.(func() interface{})()
+		return fn.(func() any)()
 	case 13:
-		return fn.(func() map[string]interface{})()
+		return fn.(func() map[string]any)()
 	case 14:
 		return fn.(func() int32)()
 	case 15:
@@ -122,8 +122,8 @@ func (vm *VM) call(fn interface{}, kind int) interface{} {
 		return fn.(func(time.Time) bool)(arg1)
 	case 22:
 		arg2 := vm.pop().(string)
-		arg1 := vm.pop().([]interface{})
-		return fn.(func([]interface{}, string) string)(arg1, arg2)
+		arg1 := vm.pop().([]any)
+		return fn.(func([]any, string) string)(arg1, arg2)
 	case 23:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().([]string)
@@ -212,50 +212,50 @@ func (vm *VM) call(fn interface{}, kind int) interface{} {
 		return fn.(func(string, string) string)(arg1, arg2)
 	case 49:
 		arg1 := vm.pop()
-		return fn.(func(interface{}) bool)(arg1)
+		return fn.(func(any) bool)(arg1)
 	case 50:
 		arg1 := vm.pop()
-		return fn.(func(interface{}) float64)(arg1)
+		return fn.(func(any) float64)(arg1)
 	case 51:
 		arg1 := vm.pop()
-		return fn.(func(interface{}) int)(arg1)
+		return fn.(func(any) int)(arg1)
 	case 52:
 		arg1 := vm.pop()
-		return fn.(func(interface{}) string)(arg1)
+		return fn.(func(any) string)(arg1)
 	case 53:
 		arg1 := vm.pop()
-		return fn.(func(interface{}) interface{})(arg1)
+		return fn.(func(any) any)(arg1)
 	case 54:
 		arg1 := vm.pop()
-		return fn.(func(interface{}) []interface{})(arg1)
+		return fn.(func(any) []any)(arg1)
 	case 55:
 		arg1 := vm.pop()
-		return fn.(func(interface{}) map[string]interface{})(arg1)
+		return fn.(func(any) map[string]any)(arg1)
 	case 56:
-		arg1 := vm.pop().([]interface{})
-		return fn.(func([]interface{}) interface{})(arg1)
+		arg1 := vm.pop().([]any)
+		return fn.(func([]any) any)(arg1)
 	case 57:
-		arg1 := vm.pop().([]interface{})
-		return fn.(func([]interface{}) []interface{})(arg1)
+		arg1 := vm.pop().([]any)
+		return fn.(func([]any) []any)(arg1)
 	case 58:
-		arg1 := vm.pop().([]interface{})
-		return fn.(func([]interface{}) map[string]interface{})(arg1)
+		arg1 := vm.pop().([]any)
+		return fn.(func([]any) map[string]any)(arg1)
 	case 59:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
-		return fn.(func(interface{}, interface{}) bool)(arg1, arg2)
+		return fn.(func(any, any) bool)(arg1, arg2)
 	case 60:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
-		return fn.(func(interface{}, interface{}) string)(arg1, arg2)
+		return fn.(func(any, any) string)(arg1, arg2)
 	case 61:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
-		return fn.(func(interface{}, interface{}) interface{})(arg1, arg2)
+		return fn.(func(any, any) any)(arg1, arg2)
 	case 62:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
-		return fn.(func(interface{}, interface{}) []interface{})(arg1, arg2)
+		return fn.(func(any, any) []any)(arg1, arg2)
 
 	}
 	panic(fmt.Sprintf("unknown function kind (%v)", kind))
diff --git a/vm/program.go b/vm/program.go
index 029458830..ea2c2a0cc 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -19,8 +19,8 @@ type Program struct {
 	Node      ast.Node
 	Source    *file.Source
 	Locations []file.Location
-	Variables []interface{}
-	Constants []interface{}
+	Variables []any
+	Constants []any
 	Bytecode  []Opcode
 	Arguments []int
 	Functions []Function
@@ -59,7 +59,7 @@ func (program *Program) Opcodes(w io.Writer) {
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, program.DebugInfo[fmt.Sprintf("%s_%d", prefix, arg)])
 		}
 		constant := func(label string) {
-			var c interface{}
+			var c any
 			if arg < len(program.Constants) {
 				c = program.Constants[arg]
 			} else {
diff --git a/vm/program_test.go b/vm/program_test.go
index 06e83b18c..4408a565d 100644
--- a/vm/program_test.go
+++ b/vm/program_test.go
@@ -10,7 +10,7 @@ import (
 func TestProgram_Disassemble(t *testing.T) {
 	for op := vm.OpPush; op < vm.OpEnd; op++ {
 		program := vm.Program{
-			Constants: []interface{}{1, 2},
+			Constants: []any{1, 2},
 			Bytecode:  []vm.Opcode{op},
 			Arguments: []int{1},
 		}
diff --git a/vm/runtime/generated.go b/vm/runtime/generated.go
index 011a03325..0832dc991 100644
--- a/vm/runtime/generated.go
+++ b/vm/runtime/generated.go
@@ -8,7 +8,7 @@ import (
 	"time"
 )
 
-func Equal(a, b interface{}) bool {
+func Equal(a, b any) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -351,7 +351,7 @@ func Equal(a, b interface{}) bool {
 	return reflect.DeepEqual(a, b)
 }
 
-func Less(a, b interface{}) bool {
+func Less(a, b any) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -691,7 +691,7 @@ func Less(a, b interface{}) bool {
 	panic(fmt.Sprintf("invalid operation: %T < %T", a, b))
 }
 
-func More(a, b interface{}) bool {
+func More(a, b any) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -1031,7 +1031,7 @@ func More(a, b interface{}) bool {
 	panic(fmt.Sprintf("invalid operation: %T > %T", a, b))
 }
 
-func LessOrEqual(a, b interface{}) bool {
+func LessOrEqual(a, b any) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -1371,7 +1371,7 @@ func LessOrEqual(a, b interface{}) bool {
 	panic(fmt.Sprintf("invalid operation: %T <= %T", a, b))
 }
 
-func MoreOrEqual(a, b interface{}) bool {
+func MoreOrEqual(a, b any) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -1711,7 +1711,7 @@ func MoreOrEqual(a, b interface{}) bool {
 	panic(fmt.Sprintf("invalid operation: %T >= %T", a, b))
 }
 
-func Add(a, b interface{}) interface{} {
+func Add(a, b any) any {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -2056,7 +2056,7 @@ func Add(a, b interface{}) interface{} {
 	panic(fmt.Sprintf("invalid operation: %T + %T", a, b))
 }
 
-func Subtract(a, b interface{}) interface{} {
+func Subtract(a, b any) any {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -2393,7 +2393,7 @@ func Subtract(a, b interface{}) interface{} {
 	panic(fmt.Sprintf("invalid operation: %T - %T", a, b))
 }
 
-func Multiply(a, b interface{}) interface{} {
+func Multiply(a, b any) any {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -2723,7 +2723,7 @@ func Multiply(a, b interface{}) interface{} {
 	panic(fmt.Sprintf("invalid operation: %T * %T", a, b))
 }
 
-func Divide(a, b interface{}) float64 {
+func Divide(a, b any) float64 {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -3053,7 +3053,7 @@ func Divide(a, b interface{}) float64 {
 	panic(fmt.Sprintf("invalid operation: %T / %T", a, b))
 }
 
-func Modulo(a, b interface{}) int {
+func Modulo(a, b any) int {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
diff --git a/vm/runtime/helpers/main.go b/vm/runtime/helpers/main.go
index b9b919283..21d53ea6f 100644
--- a/vm/runtime/helpers/main.go
+++ b/vm/runtime/helpers/main.go
@@ -46,7 +46,7 @@ var types = []string{
 
 func cases(op string, noFloat bool) string {
 	var out string
-	echo := func(s string, xs ...interface{}) {
+	echo := func(s string, xs ...any) {
 		out += fmt.Sprintf(s, xs...) + "\n"
 	}
 	for _, a := range types {
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 7075c7014..b03714e0f 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -8,7 +8,7 @@ import (
 	"reflect"
 )
 
-func Fetch(from, i interface{}) interface{} {
+func Fetch(from, i any) any {
 	v := reflect.ValueOf(from)
 	kind := v.Kind()
 	if kind == reflect.Invalid {
@@ -81,7 +81,7 @@ type Field struct {
 	Path  []string
 }
 
-func FetchField(from interface{}, field *Field) interface{} {
+func FetchField(from any, field *Field) any {
 	v := reflect.ValueOf(from)
 	kind := v.Kind()
 	if kind != reflect.Invalid {
@@ -125,7 +125,7 @@ type Method struct {
 	Name  string
 }
 
-func FetchMethod(from interface{}, method *Method) interface{} {
+func FetchMethod(from any, method *Method) any {
 	v := reflect.ValueOf(from)
 	kind := v.Kind()
 	if kind != reflect.Invalid {
@@ -138,7 +138,7 @@ func FetchMethod(from interface{}, method *Method) interface{} {
 	panic(fmt.Sprintf("cannot fetch %v from %T", method.Name, from))
 }
 
-func Deref(i interface{}) interface{} {
+func Deref(i any) any {
 	if i == nil {
 		return nil
 	}
@@ -173,7 +173,7 @@ loop:
 	panic(fmt.Sprintf("cannot dereference %v", i))
 }
 
-func Slice(array, from, to interface{}) interface{} {
+func Slice(array, from, to any) any {
 	v := reflect.ValueOf(array)
 
 	switch v.Kind() {
@@ -213,7 +213,7 @@ func Slice(array, from, to interface{}) interface{} {
 	panic(fmt.Sprintf("cannot slice %v", from))
 }
 
-func In(needle interface{}, array interface{}) bool {
+func In(needle any, array any) bool {
 	if array == nil {
 		return false
 	}
@@ -270,7 +270,7 @@ func In(needle interface{}, array interface{}) bool {
 	panic(fmt.Sprintf(`operator "in" not defined on %T`, array))
 }
 
-func Len(a interface{}) int {
+func Len(a any) int {
 	v := reflect.ValueOf(a)
 	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
@@ -280,7 +280,7 @@ func Len(a interface{}) int {
 	}
 }
 
-func Negate(i interface{}) interface{} {
+func Negate(i any) any {
 	switch v := i.(type) {
 	case float32:
 		return -v
@@ -311,7 +311,7 @@ func Negate(i interface{}) interface{} {
 	}
 }
 
-func Exponent(a, b interface{}) float64 {
+func Exponent(a, b any) float64 {
 	return math.Pow(ToFloat64(a), ToFloat64(b))
 }
 
@@ -327,7 +327,7 @@ func MakeRange(min, max int) []int {
 	return rng
 }
 
-func ToInt(a interface{}) int {
+func ToInt(a any) int {
 	switch x := a.(type) {
 	case float32:
 		return int(x)
@@ -358,7 +358,7 @@ func ToInt(a interface{}) int {
 	}
 }
 
-func ToInt64(a interface{}) int64 {
+func ToInt64(a any) int64 {
 	switch x := a.(type) {
 	case float32:
 		return int64(x)
@@ -389,7 +389,7 @@ func ToInt64(a interface{}) int64 {
 	}
 }
 
-func ToFloat64(a interface{}) float64 {
+func ToFloat64(a any) float64 {
 	switch x := a.(type) {
 	case float32:
 		return float64(x)
@@ -420,7 +420,7 @@ func ToFloat64(a interface{}) float64 {
 	}
 }
 
-func IsNil(v interface{}) bool {
+func IsNil(v any) bool {
 	if v == nil {
 		return true
 	}
diff --git a/vm/vm.go b/vm/vm.go
index b4a15a20d..ae8fe8d96 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -16,9 +16,9 @@ import (
 var MemoryBudget int = 1e6
 var errorType = reflect.TypeOf((*error)(nil)).Elem()
 
-type Function = func(params ...interface{}) (interface{}, error)
+type Function = func(params ...any) (any, error)
 
-func Run(program *Program, env interface{}) (interface{}, error) {
+func Run(program *Program, env any) (any, error) {
 	if program == nil {
 		return nil, fmt.Errorf("program is nil")
 	}
@@ -28,7 +28,7 @@ func Run(program *Program, env interface{}) (interface{}, error) {
 }
 
 type VM struct {
-	stack        []interface{}
+	stack        []any
 	ip           int
 	scopes       []*Scope
 	debug        bool
@@ -55,7 +55,7 @@ func Debug() *VM {
 	return vm
 }
 
-func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error) {
+func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			f := &file.Error{
@@ -70,7 +70,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 	}()
 
 	if vm.stack == nil {
-		vm.stack = make([]interface{}, 0, 2)
+		vm.stack = make([]any, 0, 2)
 	} else {
 		vm.stack = vm.stack[0:0]
 	}
@@ -119,7 +119,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			vm.push(runtime.FetchField(env, program.Constants[arg].(*runtime.Field)))
 
 		case OpLoadFast:
-			vm.push(env.(map[string]interface{})[program.Constants[arg].(string)])
+			vm.push(env.(map[string]any)[program.Constants[arg].(string)])
 
 		case OpLoadMethod:
 			vm.push(runtime.FetchMethod(env, program.Constants[arg].(*runtime.Method)))
@@ -367,7 +367,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 		case OpCallN:
 			fn := vm.pop().(Function)
 			size := arg
-			in := make([]interface{}, size)
+			in := make([]any, size)
 			for i := int(size) - 1; i >= 0; i-- {
 				in[i] = vm.pop()
 			}
@@ -378,9 +378,9 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			vm.push(out)
 
 		case OpCallFast:
-			fn := vm.pop().(func(...interface{}) interface{})
+			fn := vm.pop().(func(...any) any)
 			size := arg
-			in := make([]interface{}, size)
+			in := make([]any, size)
 			for i := int(size) - 1; i >= 0; i-- {
 				in[i] = vm.pop()
 			}
@@ -394,7 +394,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 
 		case OpArray:
 			size := vm.pop().(int)
-			array := make([]interface{}, size)
+			array := make([]any, size)
 			for i := size - 1; i >= 0; i-- {
 				array[i] = vm.pop()
 			}
@@ -406,7 +406,7 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 
 		case OpMap:
 			size := vm.pop().(int)
-			m := make(map[string]interface{})
+			m := make(map[string]any)
 			for i := size - 1; i >= 0; i-- {
 				value := vm.pop()
 				key := vm.pop()
@@ -513,21 +513,21 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 	return nil, nil
 }
 
-func (vm *VM) push(value interface{}) {
+func (vm *VM) push(value any) {
 	vm.stack = append(vm.stack, value)
 }
 
-func (vm *VM) current() interface{} {
+func (vm *VM) current() any {
 	return vm.stack[len(vm.stack)-1]
 }
 
-func (vm *VM) pop() interface{} {
+func (vm *VM) pop() any {
 	value := vm.stack[len(vm.stack)-1]
 	vm.stack = vm.stack[:len(vm.stack)-1]
 	return value
 }
 
-func (vm *VM) Stack() []interface{} {
+func (vm *VM) Stack() []any {
 	return vm.stack
 }
 
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 202dd3357..dfbd17869 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -78,7 +78,7 @@ func TestRun_Cast(t *testing.T) {
 }
 
 func TestRun_Helpers(t *testing.T) {
-	values := []interface{}{
+	values := []any{
 		uint(1),
 		uint8(1),
 		uint16(1),
@@ -110,7 +110,7 @@ func TestRun_Helpers(t *testing.T) {
 				}
 
 				input := fmt.Sprintf("a %v b", op)
-				env := map[string]interface{}{
+				env := map[string]any{
 					"a": a,
 					"b": b,
 				}
@@ -145,7 +145,7 @@ func (ErrorEnv) WillError(param string) (bool, error) {
 	return true, nil
 }
 
-func (ErrorEnv) FastError(...interface{}) interface{} {
+func (ErrorEnv) FastError(...any) any {
 	return true
 }
 
@@ -185,9 +185,9 @@ func TestRun_FastMethods(t *testing.T) {
 	tree, err := parser.Parse(input)
 	require.NoError(t, err)
 
-	env := map[string]interface{}{
-		"hello": func(...interface{}) interface{} { return "hello " },
-		"world": func(...interface{}) interface{} { return "world" },
+	env := map[string]any{
+		"hello": func(...any) any { return "hello " },
+		"world": func(...any) any { return "world" },
 	}
 	funcConf := conf.New(env)
 	_, err = checker.Check(tree, funcConf)

From 1829e72fa50ccc67f2ce604c7824f24438495477 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 12:07:16 +0200
Subject: [PATCH 135/506] Add countBy()

---
 bench_test.go        | 14 ++++++++++++++
 builtin/builtin.go   |  5 +++++
 checker/checker.go   | 19 +++++++++++++++++++
 compiler/compiler.go | 12 ++++++++++++
 expr_test.go         |  4 ++++
 parser/parser.go     |  1 +
 vm/opcodes.go        |  2 ++
 vm/program.go        |  6 ++++++
 vm/vm.go             | 11 +++++++++++
 9 files changed, 74 insertions(+)

diff --git a/bench_test.go b/bench_test.go
index 935f3a80b..62b787da7 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -512,3 +512,17 @@ func Benchmark_groupBy(b *testing.B) {
 
 	require.Equal(b, 6, out.([]any)[0])
 }
+
+func Benchmark_countBy(b *testing.B) {
+	program, err := expr.Compile(`countBy(1..100, # % 7)[6]`)
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 14, out.(int))
+}
diff --git a/builtin/builtin.go b/builtin/builtin.go
index aacaa0a49..66031b2fd 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -695,4 +695,9 @@ var Builtins = []*ast.Function{
 		Predicate: true,
 		Types:     types(new(func([]any, func(any) any) map[any][]any)),
 	},
+	{
+		Name:      "countBy",
+		Predicate: true,
+		Types:     types(new(func([]any, func(any) any) map[any]int)),
+	},
 }
diff --git a/checker/checker.go b/checker/checker.go
index e76472ccc..a000c1114 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -736,6 +736,25 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return reflect.TypeOf(map[any][]any{}), info{}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
+
+	case "countBy":
+		collection, _ := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isAny(collection) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		}
+
+		v.begin(collection)
+		closure, _ := v.visit(node.Arguments[1])
+		v.end()
+
+		if isFunc(closure) &&
+			closure.NumOut() == 1 &&
+			closure.NumIn() == 1 && isAny(closure.In(0)) {
+
+			return reflect.TypeOf(map[any]int{}), info{}
+		}
+		return v.error(node.Arguments[1], "predicate should has one input and one output param")
+
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 978ab6f9c..ed8a05ad3 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -824,6 +824,18 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpGetGroupBy)
 		c.emit(OpEnd)
 		return
+
+	case "countBy":
+		c.compile(node.Arguments[0])
+		c.emit(OpBegin)
+		c.emitLoop(func() {
+			c.compile(node.Arguments[1])
+			c.emit(OpCountBy)
+		})
+		c.emit(OpGetCountBy)
+		c.emit(OpEnd)
+		return
+
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
diff --git a/expr_test.go b/expr_test.go
index be8e406a9..fb20f395c 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1063,6 +1063,10 @@ func TestExpr(t *testing.T) {
 			`groupBy(ArrayOfFoo, .Value).foo`,
 			[]any{env.ArrayOfFoo[0]},
 		},
+		{
+			`countBy(1..9, # % 2)`,
+			map[any]int{0: 4, 1: 5},
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/parser/parser.go b/parser/parser.go
index 229f8e1b3..71c4337a2 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -29,6 +29,7 @@ var predicates = map[string]struct {
 	"findLast":      {2},
 	"findLastIndex": {2},
 	"groupBy":       {2},
+	"countBy":       {2},
 }
 
 type parser struct {
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 8a0283173..4f6258ac9 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -73,9 +73,11 @@ const (
 	OpGetCount
 	OpGetLen
 	OpGetGroupBy
+	OpGetCountBy
 	OpPointer
 	OpThrow
 	OpGroupBy
+	OpCountBy
 	OpBegin
 	OpEnd // This opcode must be at the end of this list.
 )
diff --git a/vm/program.go b/vm/program.go
index ea2c2a0cc..94b8b4ed3 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -292,6 +292,9 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpGetGroupBy:
 			code("OpGetGroupBy")
 
+		case OpGetCountBy:
+			code("OpGetCountBy")
+
 		case OpPointer:
 			code("OpPointer")
 
@@ -304,6 +307,9 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpGroupBy:
 			code("OpGroupBy")
 
+		case OpCountBy:
+			code("OpCountBy")
+
 		case OpEnd:
 			code("OpEnd")
 
diff --git a/vm/vm.go b/vm/vm.go
index ae8fe8d96..b0a04ce87 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -44,6 +44,7 @@ type Scope struct {
 	Len     int
 	Count   int
 	GroupBy map[any][]any
+	CountBy map[any]int
 }
 
 func Debug() *VM {
@@ -465,6 +466,9 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpGetGroupBy:
 			vm.push(vm.Scope().GroupBy)
 
+		case OpGetCountBy:
+			vm.push(vm.Scope().CountBy)
+
 		case OpPointer:
 			scope := vm.Scope()
 			vm.push(scope.Array.Index(scope.Index).Interface())
@@ -481,6 +485,13 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			key := vm.pop()
 			scope.GroupBy[key] = append(scope.GroupBy[key], it)
 
+		case OpCountBy:
+			scope := vm.Scope()
+			if scope.CountBy == nil {
+				scope.CountBy = make(map[any]int)
+			}
+			scope.CountBy[vm.pop()]++
+
 		case OpBegin:
 			a := vm.pop()
 			array := reflect.ValueOf(a)

From 323f23bcdea9efb9a1c3dd808149044a4b1fa6ff Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 12:11:57 +0200
Subject: [PATCH 136/506] Move tests to builtin_test.go

---
 builtin/builtin_test.go | 18 +++++++++++++-----
 expr_test.go            | 27 ---------------------------
 2 files changed, 13 insertions(+), 32 deletions(-)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index e7782fa32..f34f40a7f 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -18,6 +18,13 @@ import (
 )
 
 func TestBuiltin(t *testing.T) {
+	env := map[string]any{
+		"ArrayOfString": []string{"foo", "bar", "baz"},
+		"ArrayOfInt":    []int{1, 2, 3},
+		"ArrayOfAny":    []any{1, "2", true},
+		"ArrayOfFoo":    []mock.Foo{{Value: "a"}, {Value: "b"}, {Value: "c"}},
+	}
+
 	var tests = []struct {
 		input string
 		want  any
@@ -87,13 +94,14 @@ func TestBuiltin(t *testing.T) {
 		{`get({foo: 1, bar: 2}, "unknown")`, nil},
 		{`"foo" in keys({foo: 1, bar: 2})`, true},
 		{`1 in values({foo: 1, bar: 2})`, true},
+		{`groupBy(1..9, # % 2)`, map[any][]any{0: {2, 4, 6, 8}, 1: {1, 3, 5, 7, 9}}},
+		{`groupBy(1..9, # % 2)[0]`, []any{2, 4, 6, 8}},
+		{`groupBy(1..3, # > 1)[true]`, []any{2, 3}},
+		{`groupBy(1..3, # > 1 ? nil : "")[nil]`, []any{2, 3}},
+		{`groupBy(ArrayOfFoo, .Value).a`, []any{mock.Foo{Value: "a"}}},
+		{`countBy(1..9, # % 2)`, map[any]int{0: 4, 1: 5}},
 	}
 
-	env := map[string]any{
-		"ArrayOfString": []string{"foo", "bar", "baz"},
-		"ArrayOfInt":    []int{1, 2, 3},
-		"ArrayOfAny":    []any{1, "2", true},
-	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
 			program, err := expr.Compile(test.input, expr.Env(env))
diff --git a/expr_test.go b/expr_test.go
index fb20f395c..f24e56f5b 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1040,33 +1040,6 @@ func TestExpr(t *testing.T) {
 			`4/2 == 2`,
 			true,
 		},
-		{
-			`groupBy(1..9, # % 2)`,
-			map[any][]any{
-				0: {2, 4, 6, 8},
-				1: {1, 3, 5, 7, 9},
-			},
-		},
-		{
-			`groupBy(1..9, # % 2)[0]`,
-			[]any{2, 4, 6, 8},
-		},
-		{
-			`groupBy(1..3, # > 1)[true]`,
-			[]any{2, 3},
-		},
-		{
-			`groupBy(1..3, # > 1 ? nil : "")[nil]`,
-			[]any{2, 3},
-		},
-		{
-			`groupBy(ArrayOfFoo, .Value).foo`,
-			[]any{env.ArrayOfFoo[0]},
-		},
-		{
-			`countBy(1..9, # % 2)`,
-			map[any]int{0: 4, 1: 5},
-		},
 	}
 
 	for _, tt := range tests {

From 418fed5b7ef1458dd623b102d8318f97c631cfee Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 12:47:22 +0200
Subject: [PATCH 137/506] Add toPairs() and fromPairs()

---
 builtin/builtin.go      | 64 +++++++++++++++++++++++++++++++++++++++++
 builtin/builtin_test.go |  4 +++
 builtin/utils.go        |  2 +-
 3 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 66031b2fd..d7bb39db3 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -584,6 +584,70 @@ var Builtins = []*ast.Function{
 			return anyType, fmt.Errorf("cannot get values from %s", args[0])
 		},
 	},
+	{
+		Name: "toPairs",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Map {
+				return nil, fmt.Errorf("cannot transform %s to pairs", v.Kind())
+			}
+			keys := v.MapKeys()
+			out := make([][2]any, len(keys))
+			for i, key := range keys {
+				out[i] = [2]any{key.Interface(), v.MapIndex(key).Interface()}
+			}
+			return out, nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Map:
+				return arrayType, nil
+			}
+			return anyType, fmt.Errorf("cannot transform %s to pairs", args[0])
+		},
+	},
+	{
+		Name: "fromPairs",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+				return nil, fmt.Errorf("cannot transform %s from pairs", v)
+			}
+			out := reflect.MakeMap(mapType)
+			for i := 0; i < v.Len(); i++ {
+				pair := deref(v.Index(i))
+				if pair.Kind() != reflect.Array && pair.Kind() != reflect.Slice {
+					return nil, fmt.Errorf("invalid pair %v", pair)
+				}
+				if pair.Len() != 2 {
+					return nil, fmt.Errorf("invalid pair length %v", pair)
+				}
+				key := pair.Index(0)
+				value := pair.Index(1)
+				out.SetMapIndex(key, value)
+			}
+			return out.Interface(), nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+				return mapType, nil
+			}
+			return anyType, fmt.Errorf("cannot transform %s from pairs", args[0])
+		},
+	},
 	{
 		Name: "sort",
 		Func: func(args ...any) (any, error) {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index f34f40a7f..279ae9972 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -94,6 +94,10 @@ func TestBuiltin(t *testing.T) {
 		{`get({foo: 1, bar: 2}, "unknown")`, nil},
 		{`"foo" in keys({foo: 1, bar: 2})`, true},
 		{`1 in values({foo: 1, bar: 2})`, true},
+		{`len(toPairs({foo: 1, bar: 2}))`, 2},
+		{`len(toPairs({}))`, 0},
+		{`fromPairs([["foo", 1], ["bar", 2]])`, map[any]any{"foo": 1, "bar": 2}},
+		{`fromPairs(toPairs({foo: 1, bar: 2}))`, map[any]any{"foo": 1, "bar": 2}},
 		{`groupBy(1..9, # % 2)`, map[any][]any{0: {2, 4, 6, 8}, 1: {1, 3, 5, 7, 9}}},
 		{`groupBy(1..9, # % 2)[0]`, []any{2, 4, 6, 8}},
 		{`groupBy(1..3, # > 1)[true]`, []any{2, 3}},
diff --git a/builtin/utils.go b/builtin/utils.go
index 349663dd9..eff8fdcd1 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -9,8 +9,8 @@ var (
 	anyType     = reflect.TypeOf(new(any)).Elem()
 	integerType = reflect.TypeOf(0)
 	floatType   = reflect.TypeOf(float64(0))
-	stringType  = reflect.TypeOf("")
 	arrayType   = reflect.TypeOf([]any{})
+	mapType     = reflect.TypeOf(map[any]any{})
 )
 
 func kind(t reflect.Type) reflect.Kind {

From 82bb7df9310b4e2e06972ac5f232c36f5b3b7ce0 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 12:54:13 +0200
Subject: [PATCH 138/506] Add take()

---
 builtin/builtin.go      | 36 ++++++++++++++++++++++++++++++++++++
 builtin/builtin_test.go |  3 +++
 2 files changed, 39 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index d7bb39db3..44be51cf0 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -524,6 +524,42 @@ var Builtins = []*ast.Function{
 			return runtime.Fetch(args[0], args[1]), nil
 		},
 	},
+	{
+		Name: "take",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 2 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 2, got %d)", len(args))
+			}
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+				return nil, fmt.Errorf("cannot take from %s", v.Kind())
+			}
+			n := reflect.ValueOf(args[1])
+			if !n.CanInt() {
+				return nil, fmt.Errorf("cannot take %s elements", n.Kind())
+			}
+			if n.Int() > int64(v.Len()) {
+				return args[0], nil
+			}
+			return v.Slice(0, int(n.Int())).Interface(), nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 2 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 2, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+			default:
+				return anyType, fmt.Errorf("cannot take from %s", args[0])
+			}
+			switch kind(args[1]) {
+			case reflect.Interface, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			default:
+				return anyType, fmt.Errorf("cannot take %s elements", args[1])
+			}
+			return args[0], nil
+		},
+	},
 	{
 		Name: "keys",
 		Func: func(args ...any) (any, error) {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 279ae9972..8ac076c7c 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -92,6 +92,8 @@ func TestBuiltin(t *testing.T) {
 		{`get(ArrayOfAny, 1)`, "2"},
 		{`get({foo: 1, bar: 2}, "foo")`, 1},
 		{`get({foo: 1, bar: 2}, "unknown")`, nil},
+		{`take(ArrayOfString, 2)`, []string{"foo", "bar"}},
+		{`take(ArrayOfString, 99)`, []string{"foo", "bar", "baz"}},
 		{`"foo" in keys({foo: 1, bar: 2})`, true},
 		{`1 in values({foo: 1, bar: 2})`, true},
 		{`len(toPairs({foo: 1, bar: 2}))`, 2},
@@ -123,6 +125,7 @@ func TestBuiltin_works_with_any(t *testing.T) {
 		arity int
 	}{
 		"get":    {2},
+		"take":   {2},
 		"sortBy": {2},
 	}
 

From ed3d1f381b0f158e6d8113dd7c6a02f925191c93 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 13:33:16 +0200
Subject: [PATCH 139/506] Add reduce()

---
 bench_test.go           | 14 ++++++++++++++
 builtin/builtin.go      |  5 +++++
 builtin/builtin_test.go |  4 ++++
 checker/checker.go      | 19 +++++++++++++++++++
 compiler/compiler.go    | 21 +++++++++++++++++++++
 debug/debugger.go       |  3 +++
 parser/parser.go        | 28 ++++++++++++++++++++++++++++
 vm/opcodes.go           |  2 ++
 vm/program.go           | 12 +++++++++---
 vm/vm.go                |  7 +++++++
 10 files changed, 112 insertions(+), 3 deletions(-)

diff --git a/bench_test.go b/bench_test.go
index 62b787da7..0aea490b3 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -526,3 +526,17 @@ func Benchmark_countBy(b *testing.B) {
 
 	require.Equal(b, 14, out.(int))
 }
+
+func Benchmark_reduce(b *testing.B) {
+	program, err := expr.Compile(`reduce(1..100, # + #acc)`)
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 5050, out.(int))
+}
diff --git a/builtin/builtin.go b/builtin/builtin.go
index 44be51cf0..88d607ea0 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -800,4 +800,9 @@ var Builtins = []*ast.Function{
 		Predicate: true,
 		Types:     types(new(func([]any, func(any) any) map[any]int)),
 	},
+	{
+		Name:      "reduce",
+		Predicate: true,
+		Types:     types(new(func([]any, func(any, any) any, any) any)),
+	},
 }
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 8ac076c7c..afff89038 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -106,6 +106,10 @@ func TestBuiltin(t *testing.T) {
 		{`groupBy(1..3, # > 1 ? nil : "")[nil]`, []any{2, 3}},
 		{`groupBy(ArrayOfFoo, .Value).a`, []any{mock.Foo{Value: "a"}}},
 		{`countBy(1..9, # % 2)`, map[any]int{0: 4, 1: 5}},
+		{`reduce(1..9, # + #acc, 0)`, 45},
+		{`reduce(1..9, # + #acc)`, 45},
+		{`reduce([.5, 1.5, 2.5], # + #acc, 0)`, 4.5},
+		{`reduce([], 5, 0)`, 0},
 	}
 
 	for _, test := range tests {
diff --git a/checker/checker.go b/checker/checker.go
index a000c1114..5002b7ca2 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -755,6 +755,25 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
+	case "reduce":
+		collection, _ := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isAny(collection) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		}
+
+		v.begin(collection, scopeVar{"index", integerType}, scopeVar{"acc", anyType})
+		closure, _ := v.visit(node.Arguments[1])
+		v.end()
+
+		if len(node.Arguments) == 3 {
+			_, _ = v.visit(node.Arguments[2])
+		}
+
+		if isFunc(closure) && closure.NumOut() == 1 {
+			return closure.Out(0), info{}
+		}
+		return v.error(node.Arguments[1], "predicate should has two input and one output param")
+
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index ed8a05ad3..deb38065b 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -836,6 +836,25 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpEnd)
 		return
 
+	case "reduce":
+		c.compile(node.Arguments[0])
+		c.emit(OpBegin)
+		if len(node.Arguments) == 3 {
+			c.compile(node.Arguments[2])
+			c.emit(OpSetAcc)
+		} else {
+			c.emit(OpPointer)
+			c.emit(OpIncrementIndex)
+			c.emit(OpSetAcc)
+		}
+		c.emitLoop(func() {
+			c.compile(node.Arguments[1])
+			c.emit(OpSetAcc)
+		})
+		c.emit(OpGetAcc)
+		c.emit(OpEnd)
+		return
+
 	}
 
 	if id, ok := builtin.Index[node.Name]; ok {
@@ -903,6 +922,8 @@ func (c *compiler) PointerNode(node *ast.PointerNode) {
 	switch node.Name {
 	case "index":
 		c.emit(OpGetIndex)
+	case "acc":
+		c.emit(OpGetAcc)
 	case "":
 		c.emit(OpPointer)
 	default:
diff --git a/debug/debugger.go b/debug/debugger.go
index 6ee9788bf..1dfe4c162 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -133,6 +133,9 @@ func StartDebugger(program *Program, env any) {
 				if s.GroupBy != nil {
 					keys = append(keys, pair{"GroupBy", s.GroupBy})
 				}
+				if s.Acc != nil {
+					keys = append(keys, pair{"Acc", s.Acc})
+				}
 				row := 0
 				for _, pair := range keys {
 					scope.SetCellSimple(row, 0, fmt.Sprintf("%v: ", pair.key))
diff --git a/parser/parser.go b/parser/parser.go
index 71c4337a2..9f20a5678 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -30,6 +30,7 @@ var predicates = map[string]struct {
 	"findLastIndex": {2},
 	"groupBy":       {2},
 	"countBy":       {2},
+	"reduce":        {3},
 }
 
 type parser struct {
@@ -357,6 +358,9 @@ func (p *parser) parseCall(token Token) Node {
 
 		if b, ok := predicates[token.Value]; ok {
 			p.expect(Bracket, "(")
+
+			// TODO: Refactor parser to use builtin.Builtins instead of predicates map.
+
 			if b.arity == 1 {
 				arguments = make([]Node, 1)
 				arguments[0] = p.parseExpression(0)
@@ -366,6 +370,18 @@ func (p *parser) parseCall(token Token) Node {
 				p.expect(Operator, ",")
 				arguments[1] = p.parseClosure()
 			}
+
+			if token.Value == "reduce" {
+				arguments = make([]Node, 2)
+				arguments[0] = p.parseExpression(0)
+				p.expect(Operator, ",")
+				arguments[1] = p.parseClosure()
+				if p.current.Is(Operator, ",") {
+					p.next()
+					arguments = append(arguments, p.parseExpression(0))
+				}
+			}
+
 			p.expect(Bracket, ")")
 
 			node = &BuiltinNode{
@@ -596,9 +612,21 @@ func (p *parser) parsePipe(node Node) Node {
 
 	if b, ok := predicates[identifier.Value]; ok {
 		p.expect(Bracket, "(")
+
+		// TODO: Refactor parser to use builtin.Builtins instead of predicates map.
+
 		if b.arity == 2 {
 			arguments = append(arguments, p.parseClosure())
 		}
+
+		if identifier.Value == "reduce" {
+			arguments = append(arguments, p.parseClosure())
+			if p.current.Is(Operator, ",") {
+				p.next()
+				arguments = append(arguments, p.parseExpression(0))
+			}
+		}
+
 		p.expect(Bracket, ")")
 
 		node = &BuiltinNode{
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 4f6258ac9..5f36fb1a3 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -74,10 +74,12 @@ const (
 	OpGetLen
 	OpGetGroupBy
 	OpGetCountBy
+	OpGetAcc
 	OpPointer
 	OpThrow
 	OpGroupBy
 	OpCountBy
+	OpSetAcc
 	OpBegin
 	OpEnd // This opcode must be at the end of this list.
 )
diff --git a/vm/program.go b/vm/program.go
index 94b8b4ed3..a81eb3ae2 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -295,21 +295,27 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpGetCountBy:
 			code("OpGetCountBy")
 
+		case OpGetAcc:
+			code("OpGetAcc")
+
 		case OpPointer:
 			code("OpPointer")
 
 		case OpThrow:
 			code("OpThrow")
 
-		case OpBegin:
-			code("OpBegin")
-
 		case OpGroupBy:
 			code("OpGroupBy")
 
 		case OpCountBy:
 			code("OpCountBy")
 
+		case OpSetAcc:
+			code("OpSetAcc")
+
+		case OpBegin:
+			code("OpBegin")
+
 		case OpEnd:
 			code("OpEnd")
 
diff --git a/vm/vm.go b/vm/vm.go
index b0a04ce87..290206ae6 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -45,6 +45,7 @@ type Scope struct {
 	Count   int
 	GroupBy map[any][]any
 	CountBy map[any]int
+	Acc     any
 }
 
 func Debug() *VM {
@@ -469,6 +470,12 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpGetCountBy:
 			vm.push(vm.Scope().CountBy)
 
+		case OpGetAcc:
+			vm.push(vm.Scope().Acc)
+
+		case OpSetAcc:
+			vm.Scope().Acc = vm.pop()
+
 		case OpPointer:
 			scope := vm.Scope()
 			vm.push(scope.Array.Index(scope.Index).Interface())

From 3b2df5a1c5d6f5ab30fb031a910d03cd6e9bf94d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 14:31:40 +0200
Subject: [PATCH 140/506] Add mean() and median()

---
 builtin/builtin.go      | 130 ++++++++++++++++++++++++++++++++++++++++
 builtin/builtin_test.go |  13 ++++
 2 files changed, 143 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 88d607ea0..f33c6059c 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -367,6 +367,136 @@ var Builtins = []*ast.Function{
 			return args[0], nil
 		},
 	},
+	{
+		Name: "sum",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+				return nil, fmt.Errorf("cannot sum %s", v.Kind())
+			}
+			sum := int64(0)
+			i := 0
+			for ; i < v.Len(); i++ {
+				it := deref(v.Index(i))
+				if it.CanInt() {
+					sum += it.Int()
+				} else if it.CanFloat() {
+					goto float
+				} else {
+					return nil, fmt.Errorf("cannot sum %s", it.Kind())
+				}
+			}
+			return int(sum), nil
+		float:
+			fSum := float64(sum)
+			for ; i < v.Len(); i++ {
+				it := deref(v.Index(i))
+				if it.CanInt() {
+					fSum += float64(it.Int())
+				} else if it.CanFloat() {
+					fSum += it.Float()
+				} else {
+					return nil, fmt.Errorf("cannot sum %s", it.Kind())
+				}
+			}
+			return fSum, nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+			default:
+				return anyType, fmt.Errorf("cannot sum %s", args[0])
+			}
+			return anyType, nil
+		},
+	},
+	{
+		Name: "mean",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+				return nil, fmt.Errorf("cannot mean %s", v.Kind())
+			}
+			if v.Len() == 0 {
+				return 0.0, nil
+			}
+			sum := float64(0)
+			i := 0
+			for ; i < v.Len(); i++ {
+				it := deref(v.Index(i))
+				if it.CanInt() {
+					sum += float64(it.Int())
+				} else if it.CanFloat() {
+					sum += it.Float()
+				} else {
+					return nil, fmt.Errorf("cannot mean %s", it.Kind())
+				}
+			}
+			return sum / float64(i), nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+			default:
+				return anyType, fmt.Errorf("cannot avg %s", args[0])
+			}
+			return floatType, nil
+		},
+	},
+	{
+		Name: "median",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+				return nil, fmt.Errorf("cannot median %s", v.Kind())
+			}
+			if v.Len() == 0 {
+				return 0.0, nil
+			}
+			s := make([]float64, v.Len())
+			for i := 0; i < v.Len(); i++ {
+				it := deref(v.Index(i))
+				if it.CanInt() {
+					s[i] = float64(it.Int())
+				} else if it.CanFloat() {
+					s[i] = it.Float()
+				} else {
+					return nil, fmt.Errorf("cannot median %s", it.Kind())
+				}
+			}
+			sort.Float64s(s)
+			if len(s)%2 == 0 {
+				return (s[len(s)/2-1] + s[len(s)/2]) / 2, nil
+			}
+			return s[len(s)/2], nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+			default:
+				return anyType, fmt.Errorf("cannot median %s", args[0])
+			}
+			return floatType, nil
+		},
+	},
 	{
 		Name: "toJSON",
 		Func: func(args ...any) (any, error) {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index afff89038..6b320e72c 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -69,6 +69,19 @@ func TestBuiltin(t *testing.T) {
 		{`max(1.5, 2.5, 3.5)`, 3.5},
 		{`min(1, 2, 3)`, 1},
 		{`min(1.5, 2.5, 3.5)`, 1.5},
+		{`sum(1..9)`, 45},
+		{`sum([.5, 1.5, 2.5])`, 4.5},
+		{`sum([])`, 0},
+		{`sum([1, 2, 3.0, 4])`, 10.0},
+		{`mean(1..9)`, 5.0},
+		{`mean([.5, 1.5, 2.5])`, 1.5},
+		{`mean([])`, 0.0},
+		{`mean([1, 2, 3.0, 4])`, 2.5},
+		{`median(1..9)`, 5.0},
+		{`median([.5, 1.5, 2.5])`, 1.5},
+		{`median([])`, 0.0},
+		{`median([1, 2, 3])`, 2.0},
+		{`median([1, 2, 3, 4])`, 2.5},
 		{`toJSON({foo: 1, bar: 2})`, "{\n  \"bar\": 2,\n  \"foo\": 1\n}"},
 		{`fromJSON("[1, 2, 3]")`, []any{1.0, 2.0, 3.0}},
 		{`toBase64("hello")`, "aGVsbG8="},

From e3bfec77efb0953146b53a335752c16825d6aac5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 14:55:05 +0200
Subject: [PATCH 141/506] Remove countBy

---
 bench_test.go           | 14 --------------
 builtin/builtin.go      | 35 +++++++++++++++--------------------
 builtin/builtin_test.go |  1 -
 checker/checker.go      | 18 ------------------
 compiler/compiler.go    | 11 -----------
 parser/parser.go        |  1 -
 vm/opcodes.go           |  2 --
 vm/program.go           |  6 ------
 vm/vm.go                | 11 -----------
 9 files changed, 15 insertions(+), 84 deletions(-)

diff --git a/bench_test.go b/bench_test.go
index 0aea490b3..8d1a272c3 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -513,20 +513,6 @@ func Benchmark_groupBy(b *testing.B) {
 	require.Equal(b, 6, out.([]any)[0])
 }
 
-func Benchmark_countBy(b *testing.B) {
-	program, err := expr.Compile(`countBy(1..100, # % 7)[6]`)
-	require.NoError(b, err)
-
-	var out any
-	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
-		out, _ = vm.Run(program, nil)
-	}
-	b.StopTimer()
-
-	require.Equal(b, 14, out.(int))
-}
-
 func Benchmark_reduce(b *testing.B) {
 	program, err := expr.Compile(`reduce(1..100, # + #acc)`)
 	require.NoError(b, err)
diff --git a/builtin/builtin.go b/builtin/builtin.go
index f33c6059c..d7248a867 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -58,11 +58,6 @@ var Builtins = []*ast.Function{
 		Predicate: true,
 		Types:     types(new(func([]any, func(any) any) []any)),
 	},
-	{
-		Name:      "count",
-		Predicate: true,
-		Types:     types(new(func([]any, func(any) bool) int)),
-	},
 	{
 		Name:      "find",
 		Predicate: true,
@@ -83,6 +78,21 @@ var Builtins = []*ast.Function{
 		Predicate: true,
 		Types:     types(new(func([]any, func(any) bool) int)),
 	},
+	{
+		Name:      "count",
+		Predicate: true,
+		Types:     types(new(func([]any, func(any) bool) int)),
+	},
+	{
+		Name:      "groupBy",
+		Predicate: true,
+		Types:     types(new(func([]any, func(any) any) map[any][]any)),
+	},
+	{
+		Name:      "reduce",
+		Predicate: true,
+		Types:     types(new(func([]any, func(any, any) any, any) any)),
+	},
 	{
 		Name: "len",
 		Fast: Len,
@@ -920,19 +930,4 @@ var Builtins = []*ast.Function{
 			return arrayType, nil
 		},
 	},
-	{
-		Name:      "groupBy",
-		Predicate: true,
-		Types:     types(new(func([]any, func(any) any) map[any][]any)),
-	},
-	{
-		Name:      "countBy",
-		Predicate: true,
-		Types:     types(new(func([]any, func(any) any) map[any]int)),
-	},
-	{
-		Name:      "reduce",
-		Predicate: true,
-		Types:     types(new(func([]any, func(any, any) any, any) any)),
-	},
 }
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 6b320e72c..62bd12562 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -118,7 +118,6 @@ func TestBuiltin(t *testing.T) {
 		{`groupBy(1..3, # > 1)[true]`, []any{2, 3}},
 		{`groupBy(1..3, # > 1 ? nil : "")[nil]`, []any{2, 3}},
 		{`groupBy(ArrayOfFoo, .Value).a`, []any{mock.Foo{Value: "a"}}},
-		{`countBy(1..9, # % 2)`, map[any]int{0: 4, 1: 5}},
 		{`reduce(1..9, # + #acc, 0)`, 45},
 		{`reduce(1..9, # + #acc)`, 45},
 		{`reduce([.5, 1.5, 2.5], # + #acc, 0)`, 4.5},
diff --git a/checker/checker.go b/checker/checker.go
index 5002b7ca2..287164b64 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -737,24 +737,6 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
-	case "countBy":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
-		}
-
-		v.begin(collection)
-		closure, _ := v.visit(node.Arguments[1])
-		v.end()
-
-		if isFunc(closure) &&
-			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isAny(closure.In(0)) {
-
-			return reflect.TypeOf(map[any]int{}), info{}
-		}
-		return v.error(node.Arguments[1], "predicate should has one input and one output param")
-
 	case "reduce":
 		collection, _ := v.visit(node.Arguments[0])
 		if !isArray(collection) && !isAny(collection) {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index deb38065b..66ad4f1f2 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -825,17 +825,6 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpEnd)
 		return
 
-	case "countBy":
-		c.compile(node.Arguments[0])
-		c.emit(OpBegin)
-		c.emitLoop(func() {
-			c.compile(node.Arguments[1])
-			c.emit(OpCountBy)
-		})
-		c.emit(OpGetCountBy)
-		c.emit(OpEnd)
-		return
-
 	case "reduce":
 		c.compile(node.Arguments[0])
 		c.emit(OpBegin)
diff --git a/parser/parser.go b/parser/parser.go
index 9f20a5678..b7a8752d5 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -29,7 +29,6 @@ var predicates = map[string]struct {
 	"findLast":      {2},
 	"findLastIndex": {2},
 	"groupBy":       {2},
-	"countBy":       {2},
 	"reduce":        {3},
 }
 
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 5f36fb1a3..1106cd3f0 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -73,12 +73,10 @@ const (
 	OpGetCount
 	OpGetLen
 	OpGetGroupBy
-	OpGetCountBy
 	OpGetAcc
 	OpPointer
 	OpThrow
 	OpGroupBy
-	OpCountBy
 	OpSetAcc
 	OpBegin
 	OpEnd // This opcode must be at the end of this list.
diff --git a/vm/program.go b/vm/program.go
index a81eb3ae2..c45a2bff2 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -292,9 +292,6 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpGetGroupBy:
 			code("OpGetGroupBy")
 
-		case OpGetCountBy:
-			code("OpGetCountBy")
-
 		case OpGetAcc:
 			code("OpGetAcc")
 
@@ -307,9 +304,6 @@ func (program *Program) Opcodes(w io.Writer) {
 		case OpGroupBy:
 			code("OpGroupBy")
 
-		case OpCountBy:
-			code("OpCountBy")
-
 		case OpSetAcc:
 			code("OpSetAcc")
 
diff --git a/vm/vm.go b/vm/vm.go
index 290206ae6..1a62b587a 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -44,7 +44,6 @@ type Scope struct {
 	Len     int
 	Count   int
 	GroupBy map[any][]any
-	CountBy map[any]int
 	Acc     any
 }
 
@@ -467,9 +466,6 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpGetGroupBy:
 			vm.push(vm.Scope().GroupBy)
 
-		case OpGetCountBy:
-			vm.push(vm.Scope().CountBy)
-
 		case OpGetAcc:
 			vm.push(vm.Scope().Acc)
 
@@ -492,13 +488,6 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			key := vm.pop()
 			scope.GroupBy[key] = append(scope.GroupBy[key], it)
 
-		case OpCountBy:
-			scope := vm.Scope()
-			if scope.CountBy == nil {
-				scope.CountBy = make(map[any]int)
-			}
-			scope.CountBy[vm.pop()]++
-
 		case OpBegin:
 			a := vm.pop()
 			array := reflect.ValueOf(a)

From b427e166d6ecf2e44bafa5b46c08f5c5c5c0e202 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 14:57:12 +0200
Subject: [PATCH 142/506] Update Language-Definition.md

---
 docs/Language-Definition.md | 155 +++++++++++++++++++++++++++++++++++-
 1 file changed, 152 insertions(+), 3 deletions(-)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index c08781a97..d5967e311 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -220,19 +220,85 @@ If the array is empty, returns **true**.
 Returns new array by applying the [predicate](#predicate) to each element of
 the array.
 
+```
+map(Tweets, {.Size})
+```
+
 ### filter(array, predicate)
 
 Returns new array by filtering elements of the array by [predicate](#predicate).
 
+```
+filter(users, .Name startsWith "J")
+```
+
+### find(array, predicate)
+
+Finds the first element in an array that satisfies the [predicate](#predicate).
+
+```expr
+find([1, 2, 3, 4], # > 2) == 3
+```
+
+### findIndex(array, predicate)
+
+Finds the index of the first element in an array that satisfies the [predicate](#predicate).
+
+```expr
+findIndex([1, 2, 3, 4], # > 2) == 2
+```
+
+### findLast(array, predicate)
+
+Finds the last element in an array that satisfies the [predicate](#predicate).
+
+```expr
+findLast([1, 2, 3, 4], # > 2) == 4
+```
+
+### findLastIndex(array, predicate)
+
+Finds the index of the last element in an array that satisfies the [predicate](#predicate).
+
+```expr
+findLastIndex([1, 2, 3, 4], # > 2) == 3
+```
+
+### groupBy(array, predicate)
+
+Groups the elements of an array by the result of the [predicate](#predicate).
+
+```expr
+groupBy(users, .Age)
+```
+
 ### count(array, predicate)
 
 Returns the number of elements what satisfies the [predicate](#predicate).
+
 Equivalent to:
 
 ```expr
 len(filter(array, predicate))
 ```
 
+### reduce(array, predicate[, initialValue])
+
+Applies a predicate to each element in the array, reducing the array to a single value.
+Optional `initialValue` argument can be used to specify the initial value of the accumulator.
+If `initialValue` is not given, the first element of the array is used as the initial value.
+
+Following variables are available in the predicate:
+
+- `#` - the current element
+- `#acc` - the accumulator
+- `#index` - the index of the current element
+
+```expr
+reduce(1..9, #acc + #)
+reduce(1..9, #acc + #, 0)
+```
+
 ### len(v)
 
 Returns the length of an array, a map or a string.
@@ -243,7 +309,6 @@ Returns the type of the given value `v`.
 Returns on of the following types: `nil`, `bool`, `int`, `uint`, `float`, `string`, `array`, `map`.
 For named types and structs, the type name is returned.
 
-
 ```expr
 type(42) == "int"
 type("hello") == "string"
@@ -408,6 +473,30 @@ Returns the minimum of the two values `v1` and `v2`.
 min(5, 7) == 5
 ```
 
+### sum(array)
+
+Returns the sum of all numbers in the array.
+
+```expr
+sum([1, 2, 3]) == 6
+```
+
+### mean(array)
+
+Returns the average of all numbers in the array.
+
+```expr
+mean([1, 2, 3]) == 2.0
+```
+
+### median(array)
+
+Returns the median of all numbers in the array.
+
+```expr
+median([1, 2, 3]) == 2.0
+```
+
 ### toJSON(v)
 
 Converts the given value `v` to its JSON string representation.
@@ -511,10 +600,70 @@ get([1, 2, 3], 1) == 2
 get({"name": "John", "age": 30}, "name") == "John"
 ```
 
+### take(array, n)
+
+Returns the first `n` elements from an array. If the array has fewer than `n` elements, returns the whole array.
+
+```expr
+take([1, 2, 3, 4], 2) == [1, 2]
+```
+
+### keys(map)
+
+Returns an array containing the keys of the map.
+
+```expr
+keys({"name": "John", "age": 30}) == ["name", "age"]
+```
+
+### values(map)
+
+Returns an array containing the values of the map.
+
+```expr
+values({"name": "John", "age": 30}) == ["John", 30]
+```
+
+### toPairs(map)
+
+Converts a map to an array of key-value pairs.
+
+```expr
+toPairs({"name": "John", "age": 30}) == [["name", "John"], ["age", 30]]
+```
+
+### fromPairs(array)
+
+Converts an array of key-value pairs to a map.
+
+```expr
+fromPairs([["name", "John"], ["age", 30]]) == {"name": "John", "age": 30}
+```
+
+### sort(array[, order])
+
+Sorts an array in ascending order. Optional `order` argument can be used to specify the order of sorting: `asc`
+or `desc`.
+
+```expr
+sort([3, 1, 4]) == [1, 3, 4]
+sort([3, 1, 4], "desc") == [4, 3, 1]
+```
+
+### sortBy(array, key[, order])
+
+Sorts an array of maps by a specific key in ascending order. Optional `order` argument can be used to specify the order
+of sorting: `asc` or `desc`.
+
+```expr
+sortBy(users, "Age")
+sortBy(users, "Age", "desc")
+```
+
 ## Predicate
 
-The predicate is an expression that accepts a single argument. To access
-the argument use the `#` symbol.
+The predicate is an expression. It takes one or more arguments and returns a boolean value.
+To access the arguments, the `#` symbol is used. 
 
 ```expr
 map(0..9, {# / 2})

From 999485d59a7751498b473244041a586592f22480 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 14:59:10 +0200
Subject: [PATCH 143/506] Update Language-Definition.md

---
 docs/Language-Definition.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index d5967e311..6b5343565 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -137,7 +137,7 @@ the last element.
 
 The `in` operator can be used to check if an item is in an array or a map.
 
-```python
+```expr
 user.Name in list["available-names"]
 ```
 
@@ -220,7 +220,7 @@ If the array is empty, returns **true**.
 Returns new array by applying the [predicate](#predicate) to each element of
 the array.
 
-```
+```expr
 map(Tweets, {.Size})
 ```
 
@@ -228,7 +228,7 @@ map(Tweets, {.Size})
 
 Returns new array by filtering elements of the array by [predicate](#predicate).
 
-```
+```expr
 filter(users, .Name startsWith "J")
 ```
 

From 92c90686ec937f285c39c060b895a11f259e2376 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 15:11:30 +0200
Subject: [PATCH 144/506] Update Language-Definition.md

---
 docs/Language-Definition.md | 31 +++++++++++++++++++++++++------
 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 6b5343565..026d1fe26 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -128,6 +128,14 @@ user.Age in 18..45 and user.Name not in ["admin", "root"]
 foo matches "^[A-Z].*"
 ```
 
+```expr
+tweets | filter(.Size < 280) | map(.Content) | join(" -- ")
+```
+
+```expr
+filter(posts, {now() - .CreatedAt >= 7 * duration("24h")})
+```
+
 ### Membership Operator
 
 Fields of structs and items of maps can be accessed with `.` operator
@@ -185,6 +193,16 @@ For example, expression `split(lower(user.Name), " ")` can be written as:
 user.Name | lower() | split(" ")
 ```
 
+### Date Manipulation
+
+The following operators can be used to manipulate dates:
+
+```expr
+date("2023-08-14") + duration("1h")
+date("2023-08-14") - duration("1h")
+date("2023-08-14") - date("2023-08-13") == duration("24h")
+```
+
 ## Built-in Functions
 
 ### all(array, predicate)
@@ -193,7 +211,7 @@ Returns **true** if all elements satisfies the [predicate](#predicate).
 If the array is empty, returns **true**.
 
 ```expr
-all(Tweets, {.Size < 280})
+all(tweets, {.Size < 280})
 ```
 
 ### any(array, predicate)
@@ -207,7 +225,7 @@ Returns **true** if _exactly one_ element satisfies the [predicate](#predicate).
 If the array is empty, returns **false**.
 
 ```expr
-one(Participants, {.Winner})
+one(participants, {.Winner})
 ```
 
 ### none(array, predicate)
@@ -221,7 +239,7 @@ Returns new array by applying the [predicate](#predicate) to each element of
 the array.
 
 ```expr
-map(Tweets, {.Size})
+map(tweets, {.Size})
 ```
 
 ### filter(array, predicate)
@@ -673,13 +691,13 @@ If items of the array is a struct or a map, it is possible to access fields with
 omitted `#` symbol (`#.Value` becomes `.Value`).
 
 ```expr
-filter(Tweets, {len(.Value) > 280})
+filter(tweets, {len(.Value) > 280})
 ```
 
 Braces `{` `}` can be omitted:
 
 ```expr
-filter(Tweets, len(.Value) > 280)
+filter(tweets, len(.Value) > 280)
 ```
 
 ## `$env` variable
@@ -687,5 +705,6 @@ filter(Tweets, len(.Value) > 280)
 The `$env` variable is a map of all variables passed to the expression.
 
 ```expr
-Foo.Name == $env["Foo"].Name
+foo.Name == $env["foo"].Name
+$env["var with spaces"]
 ```

From f32da1ed24a28993721a72f8bd76b51e4fc583de Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 15:23:33 +0200
Subject: [PATCH 145/506] Fix date manipulation operations

---
 expr_test.go               | 32 +++++++++++++++++++++++
 vm/runtime/generated.go    | 52 ++++++++++++++++++++++++++++++--------
 vm/runtime/helpers/main.go | 34 +++++++++++++++++++++++++
 3 files changed, 108 insertions(+), 10 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index f24e56f5b..11f433c24 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -944,6 +944,38 @@ func TestExpr(t *testing.T) {
 			`TimePlusDay - Duration`,
 			date,
 		},
+		{
+			`duration("1h") == duration("1h")`,
+			true,
+		},
+		{
+			`TimePlusDay - Time >= duration("24h")`,
+			true,
+		},
+		{
+			`duration("1h") > duration("1m")`,
+			true,
+		},
+		{
+			`duration("1h") < duration("1m")`,
+			false,
+		},
+		{
+			`duration("1h") >= duration("1m")`,
+			true,
+		},
+		{
+			`duration("1h") <= duration("1m")`,
+			false,
+		},
+		{
+			`duration("1h") > duration("1m")`,
+			true,
+		},
+		{
+			`duration("1h") + duration("1m")`,
+			time.Hour + time.Minute,
+		},
 		{
 			`1 /* one */ + 2 // two`,
 			3,
diff --git a/vm/runtime/generated.go b/vm/runtime/generated.go
index 0832dc991..919899064 100644
--- a/vm/runtime/generated.go
+++ b/vm/runtime/generated.go
@@ -8,7 +8,7 @@ import (
 	"time"
 )
 
-func Equal(a, b any) bool {
+func Equal(a, b interface{}) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -344,6 +344,11 @@ func Equal(a, b any) bool {
 		case time.Time:
 			return x.Equal(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x == y
+		}
 	}
 	if IsNil(a) && IsNil(b) {
 		return true
@@ -351,7 +356,7 @@ func Equal(a, b any) bool {
 	return reflect.DeepEqual(a, b)
 }
 
-func Less(a, b any) bool {
+func Less(a, b interface{}) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -687,11 +692,16 @@ func Less(a, b any) bool {
 		case time.Time:
 			return x.Before(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x < y
+		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T < %T", a, b))
 }
 
-func More(a, b any) bool {
+func More(a, b interface{}) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -1027,11 +1037,16 @@ func More(a, b any) bool {
 		case time.Time:
 			return x.After(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x > y
+		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T > %T", a, b))
 }
 
-func LessOrEqual(a, b any) bool {
+func LessOrEqual(a, b interface{}) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -1367,11 +1382,16 @@ func LessOrEqual(a, b any) bool {
 		case time.Time:
 			return x.Before(y) || x.Equal(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x <= y
+		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T <= %T", a, b))
 }
 
-func MoreOrEqual(a, b any) bool {
+func MoreOrEqual(a, b interface{}) bool {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -1707,11 +1727,16 @@ func MoreOrEqual(a, b any) bool {
 		case time.Time:
 			return x.After(y) || x.Equal(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x >= y
+		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T >= %T", a, b))
 }
 
-func Add(a, b any) any {
+func Add(a, b interface{}) interface{} {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -2051,12 +2076,14 @@ func Add(a, b any) any {
 		switch y := b.(type) {
 		case time.Time:
 			return y.Add(x)
+		case time.Duration:
+			return x + y
 		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T + %T", a, b))
 }
 
-func Subtract(a, b any) any {
+func Subtract(a, b interface{}) interface{} {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -2389,11 +2416,16 @@ func Subtract(a, b any) any {
 		case time.Duration:
 			return x.Add(-y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x - y
+		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T - %T", a, b))
 }
 
-func Multiply(a, b any) any {
+func Multiply(a, b interface{}) interface{} {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -2723,7 +2755,7 @@ func Multiply(a, b any) any {
 	panic(fmt.Sprintf("invalid operation: %T * %T", a, b))
 }
 
-func Divide(a, b any) float64 {
+func Divide(a, b interface{}) float64 {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
@@ -3053,7 +3085,7 @@ func Divide(a, b any) float64 {
 	panic(fmt.Sprintf("invalid operation: %T / %T", a, b))
 }
 
-func Modulo(a, b any) int {
+func Modulo(a, b interface{}) int {
 	switch x := a.(type) {
 	case uint:
 		switch y := b.(type) {
diff --git a/vm/runtime/helpers/main.go b/vm/runtime/helpers/main.go
index 21d53ea6f..ea049dd3b 100644
--- a/vm/runtime/helpers/main.go
+++ b/vm/runtime/helpers/main.go
@@ -100,6 +100,11 @@ func Equal(a, b interface{}) bool {
 		case time.Time:
 			return x.Equal(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x == y
+		}
 	}
 	if IsNil(a) && IsNil(b) {
 		return true
@@ -120,6 +125,11 @@ func Less(a, b interface{}) bool {
 		case time.Time:
 			return x.Before(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x < y
+		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T < %T", a, b))
 }
@@ -137,6 +147,11 @@ func More(a, b interface{}) bool {
 		case time.Time:
 			return x.After(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x > y
+		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T > %T", a, b))
 }
@@ -154,6 +169,11 @@ func LessOrEqual(a, b interface{}) bool {
 		case time.Time:
 			return x.Before(y) || x.Equal(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x <= y
+		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T <= %T", a, b))
 }
@@ -171,6 +191,11 @@ func MoreOrEqual(a, b interface{}) bool {
 		case time.Time:
 			return x.After(y) || x.Equal(y)
 		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x >= y
+		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T >= %T", a, b))
 }
@@ -192,6 +217,8 @@ func Add(a, b interface{}) interface{} {
 		switch y := b.(type) {
 		case time.Time:
 			return y.Add(x)
+		case time.Duration:
+			return x + y
 		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T + %T", a, b))
@@ -204,6 +231,13 @@ func Subtract(a, b interface{}) interface{} {
 		switch y := b.(type) {
 		case time.Time:
 			return x.Sub(y)
+		case time.Duration:
+			return x.Add(-y)
+		}
+	case time.Duration:
+		switch y := b.(type) {
+		case time.Duration:
+			return x - y
 		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T - %T", a, b))

From 5be37aa5430d5833f11a224ff7cdc843d6f3fcf0 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 30 Aug 2023 17:15:22 +0200
Subject: [PATCH 146/506] Fix duration multiplication by integer

---
 expr_test.go               | 12 +++++++
 vm/runtime/generated.go    | 53 +++++++++++++++++++++++++++++++
 vm/runtime/helpers/main.go | 64 ++++++++++++++++++++++++++------------
 3 files changed, 109 insertions(+), 20 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index 11f433c24..84d31bf9e 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -976,6 +976,18 @@ func TestExpr(t *testing.T) {
 			`duration("1h") + duration("1m")`,
 			time.Hour + time.Minute,
 		},
+		{
+			`7 * duration("1h")`,
+			7 * time.Hour,
+		},
+		{
+			`duration("1h") * 7`,
+			7 * time.Hour,
+		},
+		{
+			`duration("1s") * .5`,
+			5e8,
+		},
 		{
 			`1 /* one */ + 2 // two`,
 			3,
diff --git a/vm/runtime/generated.go b/vm/runtime/generated.go
index 919899064..720feb455 100644
--- a/vm/runtime/generated.go
+++ b/vm/runtime/generated.go
@@ -2453,6 +2453,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case uint8:
 		switch y := b.(type) {
@@ -2480,6 +2482,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case uint16:
 		switch y := b.(type) {
@@ -2507,6 +2511,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case uint32:
 		switch y := b.(type) {
@@ -2534,6 +2540,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case uint64:
 		switch y := b.(type) {
@@ -2561,6 +2569,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case int:
 		switch y := b.(type) {
@@ -2588,6 +2598,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case int8:
 		switch y := b.(type) {
@@ -2615,6 +2627,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case int16:
 		switch y := b.(type) {
@@ -2642,6 +2656,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case int32:
 		switch y := b.(type) {
@@ -2669,6 +2685,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case int64:
 		switch y := b.(type) {
@@ -2696,6 +2714,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	case float32:
 		switch y := b.(type) {
@@ -2723,6 +2743,8 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return float64(x) * float64(y)
 		}
 	case float64:
 		switch y := b.(type) {
@@ -2750,6 +2772,37 @@ func Multiply(a, b interface{}) interface{} {
 			return float64(x) * float64(y)
 		case float64:
 			return float64(x) * float64(y)
+		case time.Duration:
+			return float64(x) * float64(y)
+		}
+	case time.Duration:
+		switch y := b.(type) {
+		case uint:
+			return time.Duration(x) * time.Duration(y)
+		case uint8:
+			return time.Duration(x) * time.Duration(y)
+		case uint16:
+			return time.Duration(x) * time.Duration(y)
+		case uint32:
+			return time.Duration(x) * time.Duration(y)
+		case uint64:
+			return time.Duration(x) * time.Duration(y)
+		case int:
+			return time.Duration(x) * time.Duration(y)
+		case int8:
+			return time.Duration(x) * time.Duration(y)
+		case int16:
+			return time.Duration(x) * time.Duration(y)
+		case int32:
+			return time.Duration(x) * time.Duration(y)
+		case int64:
+			return time.Duration(x) * time.Duration(y)
+		case float32:
+			return float64(x) * float64(y)
+		case float64:
+			return float64(x) * float64(y)
+		case time.Duration:
+			return time.Duration(x) * time.Duration(y)
 		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T * %T", a, b))
diff --git a/vm/runtime/helpers/main.go b/vm/runtime/helpers/main.go
index ea049dd3b..66eb68dba 100644
--- a/vm/runtime/helpers/main.go
+++ b/vm/runtime/helpers/main.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"fmt"
 	"go/format"
+	"os"
 	"strings"
 	"text/template"
 )
@@ -13,11 +14,14 @@ func main() {
 	err := template.Must(
 		template.New("helpers").
 			Funcs(template.FuncMap{
-				"cases":          func(op string) string { return cases(op, false) },
-				"cases_int_only": func(op string) string { return cases(op, true) },
+				"cases":          func(op string) string { return cases(op, uints, ints, floats) },
+				"cases_int_only": func(op string) string { return cases(op, uints, ints) },
+				"cases_with_duration": func(op string) string {
+					return cases(op, uints, ints, floats, []string{"time.Duration"})
+				},
 			}).
 			Parse(helpers),
-	).Execute(&b, types)
+	).Execute(&b, nil)
 	if err != nil {
 		panic(err)
 	}
@@ -29,40 +33,48 @@ func main() {
 	fmt.Print(string(formatted))
 }
 
-var types = []string{
-	"uint",
-	"uint8",
-	"uint16",
-	"uint32",
-	"uint64",
+var ints = []string{
 	"int",
 	"int8",
 	"int16",
 	"int32",
 	"int64",
+}
+
+var uints = []string{
+	"uint",
+	"uint8",
+	"uint16",
+	"uint32",
+	"uint64",
+}
+
+var floats = []string{
 	"float32",
 	"float64",
 }
 
-func cases(op string, noFloat bool) string {
+func cases(op string, xs ...[]string) string {
+	var types []string
+	for _, x := range xs {
+		types = append(types, x...)
+	}
+
+	_, _ = fmt.Fprintf(os.Stderr, "Generating %s cases for %v\n", op, types)
+
 	var out string
 	echo := func(s string, xs ...any) {
 		out += fmt.Sprintf(s, xs...) + "\n"
 	}
 	for _, a := range types {
-		aIsFloat := strings.HasPrefix(a, "float")
-		if noFloat && aIsFloat {
-			continue
-		}
 		echo(`case %v:`, a)
 		echo(`switch y := b.(type) {`)
 		for _, b := range types {
-			bIsFloat := strings.HasPrefix(b, "float")
-			if noFloat && bIsFloat {
-				continue
-			}
 			t := "int"
-			if aIsFloat || bIsFloat {
+			if isDuration(a) || isDuration(b) {
+				t = "time.Duration"
+			}
+			if isFloat(a) || isFloat(b) {
 				t = "float64"
 			}
 			echo(`case %v:`, b)
@@ -77,6 +89,18 @@ func cases(op string, noFloat bool) string {
 	return strings.TrimRight(out, "\n")
 }
 
+func isFloat(t string) bool {
+	return strings.HasPrefix(t, "float")
+}
+
+func isInt(t string) bool {
+	return strings.HasPrefix(t, "int")
+}
+
+func isDuration(t string) bool {
+	return t == "time.Duration"
+}
+
 const helpers = `// Code generated by vm/runtime/helpers/main.go. DO NOT EDIT.
 
 package runtime
@@ -245,7 +269,7 @@ func Subtract(a, b interface{}) interface{} {
 
 func Multiply(a, b interface{}) interface{} {
 	switch x := a.(type) {
-	{{ cases "*" }}
+	{{ cases_with_duration "*" }}
 	}
 	panic(fmt.Sprintf("invalid operation: %T * %T", a, b))
 }

From c9d4a55fa95e81408461c1893b7f4f9f5c69b400 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 1 Sep 2023 09:41:34 +0200
Subject: [PATCH 147/506] Add CIFuzz

---
 .github/workflows/fuzz.yml | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 .github/workflows/fuzz.yml

diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
new file mode 100644
index 000000000..b03470d84
--- /dev/null
+++ b/.github/workflows/fuzz.yml
@@ -0,0 +1,34 @@
+name: fuzz
+on: [pull_request]
+permissions: {}
+jobs:
+  fuzzing:
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+    steps:
+      - name: Build Fuzzers
+        id: build
+        uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+        with:
+          oss-fuzz-project-name: 'expr'
+          language: 'go'
+      - name: Run Fuzzers
+        uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+        with:
+          oss-fuzz-project-name: 'expr'
+          language: 'go'
+          fuzz-seconds: 600
+      - name: Upload Crash
+        uses: actions/upload-artifact@v3
+        if: failure() && steps.build.outcome == 'success'
+        with:
+          name: artifacts
+          path: ./out/artifacts
+      - name: Upload Sarif
+        if: always() && steps.build.outcome == 'success'
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+          # Path to SARIF file relative to the root of the repository
+          sarif_file: cifuzz-sarif/results.sarif
+          checkout_path: cifuzz-sarif

From d8f4c25757792df5d54ff2ea985ba6e60387a1c4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 1 Sep 2023 10:00:05 +0200
Subject: [PATCH 148/506] Add fuzz_coverage_test.go

---
 test/fuzz/fuzz_coverage_test.go | 62 +++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 test/fuzz/fuzz_coverage_test.go

diff --git a/test/fuzz/fuzz_coverage_test.go b/test/fuzz/fuzz_coverage_test.go
new file mode 100644
index 000000000..0575d8355
--- /dev/null
+++ b/test/fuzz/fuzz_coverage_test.go
@@ -0,0 +1,62 @@
+package fuzz_test
+
+import (
+	_ "embed"
+	"github.com/stretchr/testify/require"
+	"strings"
+	"testing"
+
+	"github.com/antonmedv/expr"
+)
+
+//go:embed fuzz_corpus.txt
+var fuzzCorpus string
+
+func TestFuzzExpr_Coverage(t *testing.T) {
+	inputs := strings.Split(strings.TrimSpace(fuzzCorpus), "\n")
+
+	var env = map[string]any{
+		"ok":    true,
+		"f64":   .5,
+		"f32":   float32(.5),
+		"i":     1,
+		"i64":   int64(1),
+		"i32":   int32(1),
+		"array": []int{1, 2, 3, 4, 5},
+		"list":  []Foo{{"bar"}, {"baz"}},
+		"foo":   Foo{"bar"},
+		"add":   func(a, b int) int { return a + b },
+		"div":   func(a, b int) int { return a / b },
+		"half":  func(a float64) float64 { return a / 2 },
+		"score": func(a int, x ...int) int {
+			s := a
+			for _, n := range x {
+				s += n
+			}
+			return s
+		},
+		"greet": func(name string) string { return "Hello, " + name },
+	}
+
+	for _, code := range inputs {
+		t.Run(code, func(t *testing.T) {
+			program, err := expr.Compile(code, expr.Env(env))
+			require.NoError(t, err)
+
+			_, err = expr.Run(program, env)
+			require.NoError(t, err)
+		})
+	}
+}
+
+type Foo struct {
+	Bar string
+}
+
+func (f Foo) String() string {
+	return "foo"
+}
+
+func (f Foo) Qux(s string) string {
+	return f.Bar + s
+}

From 85a39152d8d0559059527111df71113c0a86d704 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 3 Sep 2023 11:10:34 +0200
Subject: [PATCH 149/506] Move fuzz env to fuzz_env.go

---
 test/fuzz/fuzz_coverage_test.go | 36 ++-----------------------------
 test/fuzz/fuzz_env.go           | 38 +++++++++++++++++++++++++++++++++
 test/fuzz/fuzz_test.go          | 37 ++------------------------------
 3 files changed, 42 insertions(+), 69 deletions(-)
 create mode 100644 test/fuzz/fuzz_env.go

diff --git a/test/fuzz/fuzz_coverage_test.go b/test/fuzz/fuzz_coverage_test.go
index 0575d8355..0f858e5db 100644
--- a/test/fuzz/fuzz_coverage_test.go
+++ b/test/fuzz/fuzz_coverage_test.go
@@ -2,6 +2,7 @@ package fuzz_test
 
 import (
 	_ "embed"
+	"github.com/antonmedv/expr/test/fuzz"
 	"github.com/stretchr/testify/require"
 	"strings"
 	"testing"
@@ -15,28 +16,7 @@ var fuzzCorpus string
 func TestFuzzExpr_Coverage(t *testing.T) {
 	inputs := strings.Split(strings.TrimSpace(fuzzCorpus), "\n")
 
-	var env = map[string]any{
-		"ok":    true,
-		"f64":   .5,
-		"f32":   float32(.5),
-		"i":     1,
-		"i64":   int64(1),
-		"i32":   int32(1),
-		"array": []int{1, 2, 3, 4, 5},
-		"list":  []Foo{{"bar"}, {"baz"}},
-		"foo":   Foo{"bar"},
-		"add":   func(a, b int) int { return a + b },
-		"div":   func(a, b int) int { return a / b },
-		"half":  func(a float64) float64 { return a / 2 },
-		"score": func(a int, x ...int) int {
-			s := a
-			for _, n := range x {
-				s += n
-			}
-			return s
-		},
-		"greet": func(name string) string { return "Hello, " + name },
-	}
+	var env = fuzz.NewEnv()
 
 	for _, code := range inputs {
 		t.Run(code, func(t *testing.T) {
@@ -48,15 +28,3 @@ func TestFuzzExpr_Coverage(t *testing.T) {
 		})
 	}
 }
-
-type Foo struct {
-	Bar string
-}
-
-func (f Foo) String() string {
-	return "foo"
-}
-
-func (f Foo) Qux(s string) string {
-	return f.Bar + s
-}
diff --git a/test/fuzz/fuzz_env.go b/test/fuzz/fuzz_env.go
new file mode 100644
index 000000000..f761148de
--- /dev/null
+++ b/test/fuzz/fuzz_env.go
@@ -0,0 +1,38 @@
+package fuzz
+
+func NewEnv() map[string]any {
+	return map[string]any{
+		"ok":    true,
+		"f64":   .5,
+		"f32":   float32(.5),
+		"i":     1,
+		"i64":   int64(1),
+		"i32":   int32(1),
+		"array": []int{1, 2, 3, 4, 5},
+		"list":  []Foo{{"bar"}, {"baz"}},
+		"foo":   Foo{"bar"},
+		"add":   func(a, b int) int { return a + b },
+		"div":   func(a, b int) int { return a / b },
+		"half":  func(a float64) float64 { return a / 2 },
+		"score": func(a int, x ...int) int {
+			s := a
+			for _, n := range x {
+				s += n
+			}
+			return s
+		},
+		"greet": func(name string) string { return "Hello, " + name },
+	}
+}
+
+type Foo struct {
+	Bar string
+}
+
+func (f Foo) String() string {
+	return "foo"
+}
+
+func (f Foo) Qux(s string) string {
+	return f.Bar + s
+}
diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 2b559e255..0ff55b23e 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -18,29 +18,6 @@ func FuzzExpr(f *testing.F) {
 		f.Add(s)
 	}
 
-	var env = map[string]any{
-		"ok":    true,
-		"f64":   .5,
-		"f32":   float32(.5),
-		"i":     1,
-		"i64":   int64(1),
-		"i32":   int32(1),
-		"array": []int{1, 2, 3, 4, 5},
-		"list":  []Foo{{"bar"}, {"baz"}},
-		"foo":   Foo{"bar"},
-		"add":   func(a, b int) int { return a + b },
-		"div":   func(a, b int) int { return a / b },
-		"half":  func(a float64) float64 { return a / 2 },
-		"score": func(a int, x ...int) int {
-			s := a
-			for _, n := range x {
-				s += n
-			}
-			return s
-		},
-		"greet": func(name string) string { return "Hello, " + name },
-	}
-
 	skip := []*regexp.Regexp{
 		regexp.MustCompile(`cannot fetch .* from .*`),
 		regexp.MustCompile(`cannot get .* from .*`),
@@ -71,6 +48,8 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`cannot parse .* as .*`),
 	}
 
+	env := NewEnv()
+
 	f.Fuzz(func(t *testing.T, code string) {
 		program, err := expr.Compile(code, expr.Env(env))
 		if err != nil {
@@ -89,15 +68,3 @@ func FuzzExpr(f *testing.F) {
 		}
 	})
 }
-
-type Foo struct {
-	Bar string
-}
-
-func (f Foo) String() string {
-	return "foo"
-}
-
-func (f Foo) Qux(s string) string {
-	return f.Bar + s
-}

From 369aaec0cf2456467507828c25f284fe0bcdfc1f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 3 Sep 2023 11:10:47 +0200
Subject: [PATCH 150/506] Use fuzz env in repl

---
 repl/repl.go | 52 ++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 42 insertions(+), 10 deletions(-)

diff --git a/repl/repl.go b/repl/repl.go
index 2508973d4..cd6201dc5 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -2,7 +2,9 @@ package main
 
 import (
 	"fmt"
+	"github.com/antonmedv/expr/test/fuzz"
 	"os"
+	"runtime"
 	"strings"
 
 	"github.com/antonmedv/expr"
@@ -14,7 +16,7 @@ import (
 
 var keywords = []string{
 	// Commands:
-	"exit", "opcodes", "debug",
+	"exit", "opcodes", "debug", "mem",
 
 	// Operators:
 	"and", "or", "in", "not", "not in",
@@ -36,9 +38,9 @@ func main() {
 	}
 	defer rl.Close()
 
-	env := map[string]any{
-		"ENV": os.Environ(),
-	}
+	env := fuzz.NewEnv()
+
+	var memUsage uint64
 	var program *vm.Program
 
 	for {
@@ -48,20 +50,26 @@ func main() {
 		}
 		line = strings.TrimSpace(line)
 
-		if line == "exit" {
-			break
-		}
+		switch line {
+		case "":
+			continue
 
-		if line == "opcodes" {
+		case "exit":
+			return
+
+		case "mem":
+			fmt.Printf("memory usage: %s\n", humanizeBytes(memUsage))
+			continue
+
+		case "opcodes":
 			if program == nil {
 				fmt.Println("no program")
 				continue
 			}
 			fmt.Println(program.Disassemble())
 			continue
-		}
 
-		if line == "debug" {
+		case "debug":
 			if program == nil {
 				fmt.Println("no program")
 				continue
@@ -75,11 +83,15 @@ func main() {
 			fmt.Printf("compile error: %s\n", err)
 			continue
 		}
+
+		start := memoryUsage()
 		output, err := expr.Run(program, env)
 		if err != nil {
 			fmt.Printf("runtime error: %s\n", err)
 			continue
 		}
+		memUsage = memoryUsage() - start
+
 		fmt.Println(output)
 	}
 }
@@ -106,3 +118,23 @@ func (c completer) Do(line []rune, pos int) ([][]rune, int) {
 
 	return words, len(lastWord)
 }
+
+func memoryUsage() uint64 {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	return m.Alloc
+}
+
+func humanizeBytes(b uint64) string {
+	const unit = 1024
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := uint64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.2f %ciB",
+		float64(b)/float64(div), "KMGTPE"[exp])
+}

From 4762edf594ef4e9bc71a55d96ab1c02fbe0665dd Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 3 Sep 2023 11:13:50 +0200
Subject: [PATCH 151/506] Change memoryBudget type to uint

Fixes #427
---
 vm/vm.go | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/vm/vm.go b/vm/vm.go
index 1a62b587a..0b285d277 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -13,7 +13,7 @@ import (
 	"github.com/antonmedv/expr/vm/runtime"
 )
 
-var MemoryBudget int = 1e6
+var MemoryBudget uint = 1e6
 var errorType = reflect.TypeOf((*error)(nil)).Elem()
 
 type Function = func(params ...any) (any, error)
@@ -34,8 +34,8 @@ type VM struct {
 	debug        bool
 	step         chan struct{}
 	curr         chan int
-	memory       int
-	memoryBudget int
+	memory       uint
+	memoryBudget uint
 }
 
 type Scope struct {
@@ -269,11 +269,8 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			min := runtime.ToInt(a)
 			max := runtime.ToInt(b)
 			size := max - min + 1
-			if vm.memory+size >= vm.memoryBudget {
-				panic("memory budget exceeded")
-			}
+			vm.memGrow(uint(size))
 			vm.push(runtime.MakeRange(min, max))
-			vm.memory += size
 
 		case OpMatches:
 			b := vm.pop()
@@ -395,18 +392,16 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 
 		case OpArray:
 			size := vm.pop().(int)
+			vm.memGrow(uint(size))
 			array := make([]any, size)
 			for i := size - 1; i >= 0; i-- {
 				array[i] = vm.pop()
 			}
 			vm.push(array)
-			vm.memory += size
-			if vm.memory >= vm.memoryBudget {
-				panic("memory budget exceeded")
-			}
 
 		case OpMap:
 			size := vm.pop().(int)
+			vm.memGrow(uint(size))
 			m := make(map[string]any)
 			for i := size - 1; i >= 0; i-- {
 				value := vm.pop()
@@ -414,10 +409,6 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 				m[key.(string)] = value
 			}
 			vm.push(m)
-			vm.memory += size
-			if vm.memory >= vm.memoryBudget {
-				panic("memory budget exceeded")
-			}
 
 		case OpLen:
 			vm.push(runtime.Len(vm.current()))
@@ -534,6 +525,13 @@ func (vm *VM) pop() any {
 	return value
 }
 
+func (vm *VM) memGrow(size uint) {
+	vm.memory += size
+	if vm.memory >= vm.memoryBudget {
+		panic("memory budget exceeded")
+	}
+}
+
 func (vm *VM) Stack() []any {
 	return vm.stack
 }

From 274eec7a91293d0d0bd70d8c17e72ebea3e5b41f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 3 Sep 2023 11:25:31 +0200
Subject: [PATCH 152/506] Fix negative ranges memory budget

---
 vm/vm.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/vm/vm.go b/vm/vm.go
index 0b285d277..ae56c91d4 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -269,6 +269,9 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			min := runtime.ToInt(a)
 			max := runtime.ToInt(b)
 			size := max - min + 1
+			if size <= 0 {
+				size = 0
+			}
 			vm.memGrow(uint(size))
 			vm.push(runtime.MakeRange(min, max))
 

From e13bdd213e351143d97c5e02a95a705f16247d43 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 3 Sep 2023 11:27:32 +0200
Subject: [PATCH 153/506] Add OSS Fuzz badge

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 054409df2..0e11943d3 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,7 @@
 [![test](https://github.com/antonmedv/expr/actions/workflows/test.yml/badge.svg)](https://github.com/antonmedv/expr/actions/workflows/test.yml) 
 [![Go Report Card](https://goreportcard.com/badge/github.com/antonmedv/expr)](https://goreportcard.com/report/github.com/antonmedv/expr) 
 [![GoDoc](https://godoc.org/github.com/antonmedv/expr?status.svg)](https://godoc.org/github.com/antonmedv/expr)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/expr.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:expr)
 
 **Expr** is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed.
 

From 4e9480440d7ce99274d8a3a3a9cd41a4b61a9921 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 5 Sep 2023 18:40:03 +0200
Subject: [PATCH 154/506] Exclude "operator "in" not defined on float64"

---
 test/fuzz/fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 0ff55b23e..d3d092a50 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -46,6 +46,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`operator "in" not defined on int`),
 		regexp.MustCompile(`invalid date .*`),
 		regexp.MustCompile(`cannot parse .* as .*`),
+		regexp.MustCompile(`operator "in" not defined on .*`),
 	}
 
 	env := NewEnv()

From 33e26c525f04c8e87cde35879cec2d203e1f5ef3 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 6 Sep 2023 08:15:15 +0200
Subject: [PATCH 155/506] Update fuzz.yml

---
 .github/workflows/fuzz.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
index b03470d84..b883b8393 100644
--- a/.github/workflows/fuzz.yml
+++ b/.github/workflows/fuzz.yml
@@ -19,6 +19,7 @@ jobs:
           oss-fuzz-project-name: 'expr'
           language: 'go'
           fuzz-seconds: 600
+          output-sarif: true
       - name: Upload Crash
         uses: actions/upload-artifact@v3
         if: failure() && steps.build.outcome == 'success'

From 1894b2ae97b3b62f05b5b7b0b26e185c133f9e01 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 2 Sep 2023 23:19:57 +0200
Subject: [PATCH 156/506] Update vm.go

---
 vm/vm.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/vm/vm.go b/vm/vm.go
index ae56c91d4..d020a31a8 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -431,8 +431,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.push(runtime.Deref(a))
 
 		case OpIncrementIndex:
-			scope := vm.Scope()
-			scope.Index++
+			vm.Scope().Index++
 
 		case OpDecrementIndex:
 			scope := vm.Scope()

From 2683a944fb1b42033e31fc167e71a7b57834b368 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 6 Sep 2023 09:31:11 +0200
Subject: [PATCH 157/506] Add check for int64->int conversion

---
 parser/parser.go | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/parser/parser.go b/parser/parser.go
index b7a8752d5..d4a870f71 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -2,6 +2,7 @@ package parser
 
 import (
 	"fmt"
+	"math"
 	"strconv"
 	"strings"
 
@@ -310,6 +311,10 @@ func (p *parser) parseSecondary() Node {
 			if err != nil {
 				p.error("invalid hex literal: %v", err)
 			}
+			if number > math.MaxInt {
+				p.error("integer literal is too large")
+				return nil
+			}
 			node := &IntegerNode{Value: int(number)}
 			node.SetLocation(token.Location)
 			return node
@@ -326,6 +331,10 @@ func (p *parser) parseSecondary() Node {
 			if err != nil {
 				p.error("invalid integer literal: %v", err)
 			}
+			if number > math.MaxInt {
+				p.error("integer literal is too large")
+				return nil
+			}
 			node := &IntegerNode{Value: int(number)}
 			node.SetLocation(token.Location)
 			return node

From 3f563fc798c668705749ea939019eb6b00cbcf7c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 6 Sep 2023 09:35:42 +0200
Subject: [PATCH 158/506] Check for an overflow before allocating

---
 parser/lexer/utils.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/parser/lexer/utils.go b/parser/lexer/utils.go
index 83d96f49c..8131d7163 100644
--- a/parser/lexer/utils.go
+++ b/parser/lexer/utils.go
@@ -2,6 +2,7 @@ package lexer
 
 import (
 	"fmt"
+	"math"
 	"strings"
 	"unicode/utf8"
 )
@@ -31,6 +32,9 @@ func unescape(value string) (string, error) {
 	// The string contains escape characters.
 	// The following logic is adapted from `strconv/quote.go`
 	var runeTmp [utf8.UTFMax]byte
+	if n >= 2/3*math.MaxInt {
+		return "", fmt.Errorf("too large string")
+	}
 	buf := make([]byte, 0, 3*n/2)
 	for len(value) > 0 {
 		c, multibyte, rest, err := unescapeChar(value)

From bbbabde1484e857c100c75ef917c53f57423c800 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 6 Sep 2023 09:38:31 +0200
Subject: [PATCH 159/506] Fix if

---
 parser/lexer/utils.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parser/lexer/utils.go b/parser/lexer/utils.go
index 8131d7163..4e95a0093 100644
--- a/parser/lexer/utils.go
+++ b/parser/lexer/utils.go
@@ -32,7 +32,7 @@ func unescape(value string) (string, error) {
 	// The string contains escape characters.
 	// The following logic is adapted from `strconv/quote.go`
 	var runeTmp [utf8.UTFMax]byte
-	if n >= 2/3*math.MaxInt {
+	if n >= 2*math.MaxInt/3 {
 		return "", fmt.Errorf("too large string")
 	}
 	buf := make([]byte, 0, 3*n/2)

From b05f8097d4ef5b3aa27e88679c2e9a4cb2c01e0c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 6 Sep 2023 09:49:19 +0200
Subject: [PATCH 160/506] Add SECURITY.md

---
 SECURITY.md | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 SECURITY.md

diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 000000000..6e343ee36
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,25 @@
+# Security Policy
+
+## Supported Versions
+
+Expr is generally backwards compatible with very few exceptions, so we
+recommend users to always use the latest version to experience stability,
+performance and security.
+
+We generally backport security issues to a single previous minor version,
+unless this is not possible or feasible with a reasonable effort.
+
+| Version | Supported          |
+|---------|--------------------|
+| 1.15    | :white_check_mark: |
+| 1.14    | :white_check_mark: |
+| 1.13    | :white_check_mark: |
+| 1.12    | :white_check_mark: |
+| < 1.12  | :x:                |
+
+## Reporting a Vulnerability
+
+If you believe you've discovered a serious vulnerability, please contact the
+Expr core team at anton+security@medv.io. We will evaluate your report and if
+necessary issue a fix and an advisory. If the issue was previously undisclosed,
+we'll also mention your name in the credits.

From 46309b39e9be7d49a6cdf416a427cc82e6ccab0f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 6 Sep 2023 09:51:46 +0200
Subject: [PATCH 161/506] Fix size check

---
 parser/lexer/utils.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/parser/lexer/utils.go b/parser/lexer/utils.go
index 4e95a0093..5c9e6b59d 100644
--- a/parser/lexer/utils.go
+++ b/parser/lexer/utils.go
@@ -32,10 +32,11 @@ func unescape(value string) (string, error) {
 	// The string contains escape characters.
 	// The following logic is adapted from `strconv/quote.go`
 	var runeTmp [utf8.UTFMax]byte
-	if n >= 2*math.MaxInt/3 {
+	size := 3 * uint64(n) / 2
+	if size >= math.MaxInt {
 		return "", fmt.Errorf("too large string")
 	}
-	buf := make([]byte, 0, 3*n/2)
+	buf := make([]byte, 0, size)
 	for len(value) > 0 {
 		c, multibyte, rest, err := unescapeChar(value)
 		if err != nil {

From 6001a17641f45196bbc8f738906e84ab7fda975c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 6 Sep 2023 10:05:00 +0200
Subject: [PATCH 162/506] Add var names in repl

---
 repl/repl.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/repl/repl.go b/repl/repl.go
index cd6201dc5..078aa4f10 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -24,6 +24,10 @@ var keywords = []string{
 }
 
 func main() {
+	env := fuzz.NewEnv()
+	for name := range env {
+		keywords = append(keywords, name)
+	}
 	home, err := os.UserHomeDir()
 	if err != nil {
 		panic(err)
@@ -38,8 +42,6 @@ func main() {
 	}
 	defer rl.Close()
 
-	env := fuzz.NewEnv()
-
 	var memUsage uint64
 	var program *vm.Program
 

From 01c358d5eb221201013d8b85f230960e2b5dd019 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 6 Sep 2023 10:36:40 +0200
Subject: [PATCH 163/506] Fix type checker for "in" operator

Fixes #426
---
 checker/checker.go      | 13 ++-----------
 checker/checker_test.go |  5 +++++
 checker/types.go        | 15 +++++++++++++++
 expr_test.go            |  8 ++++++++
 4 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 287164b64..3e787fa4f 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -242,16 +242,7 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 
 	switch node.Operator {
 	case "==", "!=":
-		if isNumber(l) && isNumber(r) {
-			return boolType, info{}
-		}
-		if l == nil || r == nil { // It is possible to compare with nil.
-			return boolType, info{}
-		}
-		if l.Kind() == r.Kind() {
-			return boolType, info{}
-		}
-		if isAny(l) || isAny(r) {
+		if isComparable(l, r) {
 			return boolType, info{}
 		}
 
@@ -357,7 +348,7 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 			if l == nil { // It is possible to compare with nil.
 				return boolType, info{}
 			}
-			if !isAny(l) && !l.AssignableTo(r.Elem()) && !(isInteger(l) && isInteger(r.Elem())) {
+			if !isComparable(l, r.Elem()) {
 				return v.error(node, "cannot use %v as type %v in array", l, r.Elem())
 			}
 			return boolType, info{}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 69c0a8e76..7528f1da9 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -513,6 +513,11 @@ cannot use float64 as type int in map key (1:5)
  | 1/2 in MapIntAny
  | ....^
 
+0.5 in ArrayOfFoo
+cannot use float64 as type *mock.Foo in array (1:5)
+ | 0.5 in ArrayOfFoo
+ | ....^
+
 repeat("0", 1/0)
 cannot use float64 as argument (type int) to call repeat  (1:14)
  | repeat("0", 1/0)
diff --git a/checker/types.go b/checker/types.go
index 1665527f0..890d74a5f 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -227,3 +227,18 @@ func kind(t reflect.Type) reflect.Kind {
 	}
 	return t.Kind()
 }
+
+func isComparable(l, r reflect.Type) bool {
+	if l == nil || r == nil {
+		return true
+	}
+	switch {
+	case l.Kind() == r.Kind():
+		return true
+	case isNumber(l) && isNumber(r):
+		return true
+	case isAny(l) || isAny(r):
+		return true
+	}
+	return false
+}
diff --git a/expr_test.go b/expr_test.go
index 84d31bf9e..1857403ec 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1084,6 +1084,14 @@ func TestExpr(t *testing.T) {
 			`4/2 == 2`,
 			true,
 		},
+		{
+			`.5 in 0..1`,
+			false,
+		},
+		{
+			`.5 in ArrayOfInt`,
+			false,
+		},
 	}
 
 	for _, tt := range tests {

From f527a33d5a040c9ccd3feb42e16a87de8e23fd37 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 8 Sep 2023 09:08:35 +0200
Subject: [PATCH 164/506] Add fuzz filter

---
 test/fuzz/fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index d3d092a50..e69aaec7b 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -38,6 +38,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`using interface \{} as type .*`),
 		regexp.MustCompile(`reflect.Value.MapIndex: value of type .* is not assignable to type .*`),
 		regexp.MustCompile(`reflect: Call using .* as type .*`),
+		regexp.MustCompile(`reflect: Call with too few input arguments`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Call on .* Value`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Index on map Value`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Len on .* Value`),

From 709c5dd55aa7cfc1b47fc67ee32ac15af6db967a Mon Sep 17 00:00:00 2001
From: hesining <levihe@lilith.com>
Date: Tue, 12 Sep 2023 22:10:41 +0800
Subject: [PATCH 165/506] Propagate uint32 arguments types in ast (#438)

---
 checker/checker.go   | 35 +++++++++++++++++++++++++++++------
 compiler/compiler.go | 12 +++++++++++-
 expr_test.go         | 29 +++++++++++++++++++++++++++++
 3 files changed, 69 insertions(+), 7 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 3e787fa4f..efa1b7eb9 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -924,8 +924,13 @@ func (v *checker) checkArguments(name string, fn reflect.Type, method bool, argu
 		}
 
 		if isFloat(in) {
-			t = floatType
-			traverseAndReplaceIntegerNodesWithFloatNodes(&arg)
+			traverseAndReplaceIntegerNodesWithFloatNodes(&arguments[i], in)
+			continue
+		}
+
+		if isInteger(in) && isInteger(t) && kind(t) != kind(in) {
+			traverseAndReplaceIntegerNodesWithIntegerNodes(&arguments[i], in)
+			continue
 		}
 
 		if t == nil {
@@ -943,19 +948,37 @@ func (v *checker) checkArguments(name string, fn reflect.Type, method bool, argu
 	return fn.Out(0), nil
 }
 
-func traverseAndReplaceIntegerNodesWithFloatNodes(node *ast.Node) {
+func traverseAndReplaceIntegerNodesWithFloatNodes(node *ast.Node, newType reflect.Type) {
 	switch (*node).(type) {
 	case *ast.IntegerNode:
 		*node = &ast.FloatNode{Value: float64((*node).(*ast.IntegerNode).Value)}
+		(*node).SetType(newType)
+	case *ast.UnaryNode:
+		unaryNode := (*node).(*ast.UnaryNode)
+		traverseAndReplaceIntegerNodesWithFloatNodes(&unaryNode.Node, newType)
+	case *ast.BinaryNode:
+		binaryNode := (*node).(*ast.BinaryNode)
+		switch binaryNode.Operator {
+		case "+", "-", "*":
+			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Left, newType)
+			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Right, newType)
+		}
+	}
+}
+
+func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newType reflect.Type) {
+	switch (*node).(type) {
+	case *ast.IntegerNode:
+		(*node).SetType(newType)
 	case *ast.UnaryNode:
 		unaryNode := (*node).(*ast.UnaryNode)
-		traverseAndReplaceIntegerNodesWithFloatNodes(&unaryNode.Node)
+		traverseAndReplaceIntegerNodesWithIntegerNodes(&unaryNode.Node, newType)
 	case *ast.BinaryNode:
 		binaryNode := (*node).(*ast.BinaryNode)
 		switch binaryNode.Operator {
 		case "+", "-", "*":
-			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Left)
-			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Right)
+			traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Left, newType)
+			traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Right, newType)
 		}
 	}
 }
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 66ad4f1f2..8e26d8788 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -307,7 +307,17 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) {
 }
 
 func (c *compiler) FloatNode(node *ast.FloatNode) {
-	c.emitPush(node.Value)
+	t := node.Type()
+	if t == nil {
+		c.emitPush(node.Value)
+		return
+	}
+	switch t.Kind() {
+	case reflect.Float32:
+		c.emitPush(float32(node.Value))
+	case reflect.Float64:
+		c.emitPush(node.Value)
+	}
 }
 
 func (c *compiler) BoolNode(node *ast.BoolNode) {
diff --git a/expr_test.go b/expr_test.go
index 1857403ec..86945867f 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1969,3 +1969,32 @@ func TestMemoryBudget(t *testing.T) {
 		})
 	}
 }
+
+func TestIssue432(t *testing.T) {
+	env := map[string]any{
+		"func": func(
+			paramUint32 uint32,
+			paramUint16 uint16,
+			paramUint8 uint8,
+			paramUint uint,
+			paramInt32 int32,
+			paramInt16 int16,
+			paramInt8 int8,
+			paramInt int,
+			paramFloat64 float64,
+			paramFloat32 float32,
+		) float64 {
+			return float64(paramUint32) + float64(paramUint16) + float64(paramUint8) + float64(paramUint) +
+				float64(paramInt32) + float64(paramInt16) + float64(paramInt8) + float64(paramInt) +
+				float64(paramFloat64) + float64(paramFloat32)
+		},
+	}
+	code := `func(1,1,1,1,1,1,1,1,1,1)`
+
+	program, err := expr.Compile(code, expr.Env(env))
+	assert.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	assert.NoError(t, err)
+	assert.Equal(t, float64(10), out)
+}
\ No newline at end of file

From 89ddc1482d21d776baa2e9eebe2d3da84610c1d7 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 16 Sep 2023 20:32:32 +0200
Subject: [PATCH 166/506] Delete fuzz_coverage_test.go

---
 test/fuzz/fuzz_coverage_test.go | 30 ------------------------------
 1 file changed, 30 deletions(-)
 delete mode 100644 test/fuzz/fuzz_coverage_test.go

diff --git a/test/fuzz/fuzz_coverage_test.go b/test/fuzz/fuzz_coverage_test.go
deleted file mode 100644
index 0f858e5db..000000000
--- a/test/fuzz/fuzz_coverage_test.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package fuzz_test
-
-import (
-	_ "embed"
-	"github.com/antonmedv/expr/test/fuzz"
-	"github.com/stretchr/testify/require"
-	"strings"
-	"testing"
-
-	"github.com/antonmedv/expr"
-)
-
-//go:embed fuzz_corpus.txt
-var fuzzCorpus string
-
-func TestFuzzExpr_Coverage(t *testing.T) {
-	inputs := strings.Split(strings.TrimSpace(fuzzCorpus), "\n")
-
-	var env = fuzz.NewEnv()
-
-	for _, code := range inputs {
-		t.Run(code, func(t *testing.T) {
-			program, err := expr.Compile(code, expr.Env(env))
-			require.NoError(t, err)
-
-			_, err = expr.Run(program, env)
-			require.NoError(t, err)
-		})
-	}
-}

From 5916dc2b68d01606f6c23e1b54da5ee3cd3dc79a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 20 Sep 2023 14:00:15 +0200
Subject: [PATCH 167/506] Add type checks for `42 in ["a"]` as invalid

---
 checker/checker.go                  |  28 +++++++++++++++++++++++++---
 checker/checker_test.go             |  10 ++++++++--
 expr_test.go                        |   7 ++++---
 test/fuzz/fuzz_corpus.txt           |   3 ---
 test/fuzz/fuzz_expr_seed_corpus.zip | Bin 2827388 -> 2827401 bytes
 testdata/examples.txt               |   3 ---
 vm/runtime/runtime.go               |   6 +-----
 7 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index efa1b7eb9..da46b6f9f 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -73,6 +73,12 @@ type varScope struct {
 type info struct {
 	method bool
 	fn     *ast.Function
+
+	// elem is element type of array or map.
+	// Arrays created with type []any, but
+	// we would like to detect expressions
+	// like `42 in ["a"]` as invalid.
+	elem reflect.Type
 }
 
 func (v *checker) visit(node ast.Node) (reflect.Type, info) {
@@ -227,7 +233,7 @@ func (v *checker) UnaryNode(node *ast.UnaryNode) (reflect.Type, info) {
 
 func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 	l, _ := v.visit(node.Left)
-	r, _ := v.visit(node.Right)
+	r, ri := v.visit(node.Right)
 
 	l = deref(l)
 	r = deref(r)
@@ -351,6 +357,9 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 			if !isComparable(l, r.Elem()) {
 				return v.error(node, "cannot use %v as type %v in array", l, r.Elem())
 			}
+			if !isComparable(l, ri.elem) {
+				return v.error(node, "cannot use %v as type %v in array", l, ri.elem)
+			}
 			return boolType, info{}
 		}
 		if isAny(l) && anyOf(r, isString, isArray, isMap) {
@@ -1067,8 +1076,21 @@ func (v *checker) ConditionalNode(node *ast.ConditionalNode) (reflect.Type, info
 }
 
 func (v *checker) ArrayNode(node *ast.ArrayNode) (reflect.Type, info) {
-	for _, node := range node.Nodes {
-		v.visit(node)
+	var prev reflect.Type
+	allElementsAreSameType := true
+	for i, node := range node.Nodes {
+		curr, _ := v.visit(node)
+		if i > 0 {
+			if curr == nil || prev == nil {
+				allElementsAreSameType = false
+			} else if curr.Kind() != prev.Kind() {
+				allElementsAreSameType = false
+			}
+		}
+		prev = curr
+	}
+	if allElementsAreSameType && prev != nil {
+		return arrayType, info{elem: prev}
 	}
 	return arrayType, info{}
 }
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 7528f1da9..f6b109bc2 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -7,14 +7,15 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/conf"
 	"github.com/antonmedv/expr/parser"
 	"github.com/antonmedv/expr/test/mock"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestCheck(t *testing.T) {
@@ -547,6 +548,11 @@ map(1..9, #unknown)
 unknown pointer #unknown (1:11)
  | map(1..9, #unknown)
  | ..........^
+
+42 in ["a", "b", "c"]
+cannot use int as type string in array (1:4)
+ | 42 in ["a", "b", "c"]
+ | ...^
 `
 
 func TestCheck_error(t *testing.T) {
diff --git a/expr_test.go b/expr_test.go
index 86945867f..4cb1902a5 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -7,12 +7,13 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/test/mock"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func ExampleEval() {
@@ -1997,4 +1998,4 @@ func TestIssue432(t *testing.T) {
 	out, err := expr.Run(program, env)
 	assert.NoError(t, err)
 	assert.Equal(t, float64(10), out)
-}
\ No newline at end of file
+}
diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
index f427f787d..3d3491ad4 100644
--- a/test/fuzz/fuzz_corpus.txt
+++ b/test/fuzz/fuzz_corpus.txt
@@ -2711,7 +2711,6 @@ add == score != true
 add == score and i32 >= 1
 add == score or 0.5 < 1
 add in [div]
-add not in [f64]
 add not in sort(array)
 add(1, 1) ** i
 add(1, 1) ^ i
@@ -3113,7 +3112,6 @@ array == map(array, add)
 array == nil != nil
 array == nil != true ? 0.5 : 0.5
 array == nil && (false || ok)
-array in [i]
 array[-1]
 array[-i32]
 array[-i64]
@@ -6102,7 +6100,6 @@ foo == foo ? i : score
 foo == last(list)
 foo == nil == nil
 foo == nil || ok
-foo in [half]
 foo in filter(list, false)
 foo in list
 foo in list ? nil : i32
diff --git a/test/fuzz/fuzz_expr_seed_corpus.zip b/test/fuzz/fuzz_expr_seed_corpus.zip
index 6f529cbbb50f62c1bc6620238be31de49ee0a9c8..aef08934d397fd9ae4b11a9756151e45892a8366 100644
GIT binary patch
literal 2827401
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%0A})+hHpC6s#hKT4|Fe+
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
z%0A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
z%0Av?NXW;2iw>qMmJ(X|(+78+K*1p&y=?c5lqaGk3<>$TYR=QIGV(1$LO#y3%N8Od
z>rbTM&`@6#;=M~ou3$*W$DJ3)L?}I;`ugz`Ax#iz<yn?}a~-+JCX=+>)gT|Agsv(n
z56iU-X~IXUvWR=*%5s%I84~ib%;oYi@{Q$IlPNgl<BKdqugX<!Vo1oxs~rvwm)kOl
zAt4`M4d|CoMz)<o!66^FJ^0;FM($!r$j3%C?#!3lGSgJ567sRNM;2!p*^MC~doCZ#
zZLi*L(;xWRuOUs;NDI%6QC6en1=n(#8ru!BvFx&-X>#9mWkd*>d1i@^GV%aJLV`Cv
zFgQ|1=9o^oA;HW3<Lx8wH2O0nB>02sFBizjBMb=%KIDz%DS2CvZ3YF01h0Sck-NMf
z>dlal;0yXRXe?KGgdripAEm!uP)6pSNx@CXL#sq&?gJh&(vKk_!7YRBJk)Wi-vGxD
z(!@w7!#j_*e5^dkRc0dn4$EeimK!_pWAE~DsQherFhiQClA3a0zR&~m7>Z#?$j3<k
z<_6pJg0m?&<YTvh>3`%kd@w^oK92Qh^H4^fVo1ox{Cy|AlDnti910Hkxcfq_J2G-0
zLqa|tj0`>`BcmA-@-d-H=YOvr6({vWJ?~r!4*9t4m!tNTFujih2?-6$;lVEr9yiA@
zqKWm96koozw3{MNYQ^)+({fjWd@S&Nl)(W5UxtK&A3weSqr4qD!jO=UOK!e3_@-j6
z`4k-T(aU0%k6dLxhJ<_^?9y?pj6BYekdHYpw2hHho_q@^IOJojb&coBkW&8i@(f}~
z6F$<otR32?nxc5>aT&{yCVV7hhf}lv{g#=sM(TYm9Ha$@#?Z1O4)5jM!x+(okF=Q0
zKJJzzclZ^CgnZn!+;^0G4z1Ke$_@EAcgp7K@{&88A)&TB@U4yZLSX$Ey1<Z-k0mD0
zHaNstJeYz*J}$G)IZ&2oC_|d?k%r~vB15YvJ)U~yInR)gj|J^|J(RnrcnAeI;UkU9
z%sEFFmB-~shBV<LA?N?;5T_#bK3*my)Zx8`y>6ir^<&6>k(S%cC%vf1qTa8k%E&Pc
z3HjLkxsAc0>T3)M`Iz~2i%fErB^Fa~6F$<g?Dnf{OZm{)XoiHk=h5-Lk+M8j7}A7~
zRAof;z<)nisD#(|xWf_(4*7U*!|!Es@UaYO!bhrd(1kHc%C)$H)mItEkdTkAGmTz~
zP+}<shkPtlaIUv{mPYSmAR$fk4#{(R&*n|)6{$Y=HAaNi$Ik7(c9qAF(=si070AaT
z1v9>oXUi!J3HdnY(XF@g1<EakG~pw)<=(@-iE@?YmQ!%Z$5)5$=a!LE7!vC7BZIAy
z<sQGqkS2Vj;E&Gu50R^^6iUHO_(;fU*&9rkyJsdtLOu@J=AUx=SlR;r!;p}Ve$xvS
zmwj|yp#_JUvTmNXUh=7=AV!3I%zATbarx}j7lwp<EI+mN5Lxk-D=D`LA87)Py4Yl*
za<t7h)dakSAt4_>ehKeVBn7AZ>F2i0tEfuI$8<l>8@v~65JN&fPQTW<wKDFNKYf*_
z84?;qkG>6#kuN9mt)}3RkMDEjOD`+ln;{_|%M7VpR}OxJAt4_#cyxLs`<OLM3l8Pp
zmehTSTx4%XgnWE8>%>~QclI+R<m0brJx|D0W?VzLP57ul{yPC})h711+~I8*67q43
zZ-vitmEjBt`8Xx1ptD?M5<@~hUdUVTguL>2ucfwxe01(Q!r&3gW`=~uWsL8eb#j$S
z3<>#|99!zB+?K7@QE<q|ZHaYSsCy0leswb;p(4jO7(QPv@(&|IK04Oln@hejYqMU<
zZRQO>B#+nU(gq)r4`)co$7#>+rjx5oyMd~Ne9Y)KzoLw6&ybLh*MHxOkdeC>67q3H
zo3zX29=F&?!66@QZnfSfBRexB<YPd+xnZ)8dl?cM>P=3zGWckT#U=_4`8esqUG4a)
z-p9^_goxQ<j=hqbGLjJ?AJ=w|`za%>Hfy=DPkQ-(pEOEFc4tV)NBe8V$H~b33<>#o
zBy@cyc?@OULct*)XAWsTP_D8&Lqa}gN-Eq{M($@w$j1)PioBPRS+`Pf$j4j0&Hj;*
zJ`4%@cqDUegHIhDWJt)KjxHI~tB;5E2Y#%#slg#&M7;%p>V=tJ@E!z&Y&_+i^P)T`
z4>BTz%)hObgWNY+Q-18yr~iQ7-Q22SpY*y|_SjCjN*{)V1P^;rFR#3m?Po|x@WxGF
z&XcdivxQS|NboKN3mFLBpCKW^D~z3E@B!N63<(L|XTXcza*yZTLBS!xYo*JwSMG5?
zhJ*wkvtUnzT;*|wgnT@6*WFefM0y|d?$m-qmwMk{XEpdCh94tBK0dz@*haoFc9J2X
zD$i!KS*zyO-_$6)i*iFg`XyvsuFjQu<S>SWeEimDfWfx~V;K_ivEJPHl-tMBO~xX-
zDLCX~;Nm5N<Y5`ekdTjgK3LY4kyjWJ@-bxWn{Vo+p1ylZ?xEn2kBMd5jgw#EHJ%|M
zAHP)EW~ElC_wf!Pp<&s5#W+X#5NGART5dCM_@S%Eeow9$`~+|sLqa~DetqMoJX<C(
zBow^Wu63(rq*DY1hkQ)RdTG9loWPKfkK-n;J}M*Q84~jGP{8C^xyKzMDLCX~c>c@o
za+QG$3Hdn1>z=_&ye=^$<m1SUArsZ(>3YTO_EB)i$19%g)5$&#CnPk6oZs*9m6wT2
zj0mld$)g^=kdb!#wcOYne#U><dq+l&WJt)zryFj#$z$juLqcttwq&y<@<=asfPzCl
z#?E<ZBUd?;At4_#cYO3kuJQ~+LO$MKn6Z;wWr2ef9P)AP)ocajDhDtm<fENqe}hT=
z7(+rnW_#t6sP5bJ>tn7%T5zbtqo-WzDd+CTh>(xBcWrtv_s(I4gx1G7ksG_pNbAFt
z8}c!W+qZ!-(uW}-ANzNjX7EsaKSM&@bF9gP&2slx9iiZmk9h_k&Lao!%#e_eiypsp
zkdeC?67tbAX@IAU%n(JvAs>@V?5!`iWqXE%eB8dg)Jb`L+(t;KcdQrR9WJjt>5gi-
zu{ZowdEh)wMz&)}$j4GMtqfk46wZ*4kCC;#uN!puF$xa(_~%mpjxw@6Lqa}oy=#?D
zMusya)Z+mzt-a)JTbkn(9P)8_<_ZS#crzsA<Hh&^0kS-s84~g_+V*j<+?GEW67sR%
zgd+Cx`q=D*)|OCH-m*?(@Ye73j0mldk$wx^Wgin667sQS@neqi7-|+xxgj6h`cI3N
zt6am7kdNn&I^CB${3}D6@R5!sZ60<xLAjx>Ov3tWp2jCBIOOBUbGH)YD%Ub3G>ASF
z4NH{U@+(6^KCT*Vy+uYgiJ{<-k6G%)+?MZ+g)t=L<LphlhRN&WPeMYulM<R6yhyzD
zDJ?hlk%XYV_YFFH6GK8iR>|{zjXYcaWJt)z?Ptpw$m4aIf<r#;Ja<1_oh|k9tYJtK
zKGMChv4=*lk%#4XhJ<{yt!6brMtYs0;E<2IUrq{^k!u+e8kf=I8n2gU;BO2G`4~H=
z^L)9=#%C!w<YVZA6Axt{R}&H{vUjJ1o^p}j7!g_@e{30hT}C!Nr{%^D{50^*X7H|#
zH4F*)`10`dTCzOf84~g_sNUqv^7F^$u@oHg@#f`cm*po3+ZYn^@m6`Sf-*AAd8!if
zab}ekTV!NghJ<|dcWly7?w)Xlgob)&ixItLWcmvf9P+V9;+(l^kL&N}bR;B1%vN~#
zb-BoWj0pKSuw)H`qo!FeYPqokKQ(K+S<4;n!;p}Vzapkyl#vG+67sQKj@Jf<RID#i
zaLC6_i&j;ZH<!H_67n&5o`b>Rse=p&`RFyIj=>!~>&p}z^6}wqzqE4q_%I~oV}0xQ
z^W?TX$dHgdw-2_}4u<Lv{A9iIzu;!xjz!le6^CrKQ?F0-f_EbzWaIAWe!Jy{+|P&*
zGME2@cJezEvtHFwV+Vfhm#k_dPeYv<5)!;)rgwkI-5tS@kl;P<zr8BArDYrihXmg_
z{mXbcco&9*1V8Gu$DqnchJ*yK{ldG3+?H0?C^#he$(rkm%I`_-%8-!Yo#r(#ct#q<
zkdWXxA_jbye}R%SUJDLg>Ye)gTfE$qzKjU@*v7ZtN_h+&V@RmVM-yumkVksn>y#Vv
zF(iJ8!8`c<7!vaFh<lEea+RkT67sQdR=aa@_Y}H8!66^>ubg1;f%ZWR3Hi7*M_Gd{
z)+vUBd_0rI*<g!R=q3e+d~7&ltij1ce};s7bSiqNoI2F?>*E<hLc?<S*Ywp@qW-3a
zZGx5?JMa_vG)VjKt{xe{kdTkJ+72){CU}k^q2N)W?zQC0=AwU7aLC6@(KWZoZ8?k~
zAs=Tp8@xhBUSLSb$Ms7ym62x+yIT|-^6}H$EGuN>D29Z5tdjOX2N`*pAt4{LT}?My
zp4;qGZsh)ZP`g@%N|29{>m#qq7o?*I35}tG<>!o+bH_6xv_1};ax&#+zjDL>|K9X>
zyrbpD4*c}~J<vx+j$=s3$0-+Fr^><O7!qpBTuuB>$yGZ1L%|^*o%^+4Bv(0xAt4`w
ze@FC^FDK#{67q3m#{)y;S)=$}3J&?Wq(E7Nub_-#NXW;S4xbEe30`JM$j9Vj(fQTj
z`t`BoJuNuY;je9c56fd{3?o85=J>IGnLLKBFeJ1-25vrP@EY-w_bE5zqus-A-{lLG
zu?z|M=+Q3ht{nU}LqgqCwvzQc8Cl^01&4eb`K#<f`JDE2hJ<{yn6uH~b4-sJ67sQ8
zjUq+l?(uj?!66@i9nDoxMussY<YV7lMYNOodLNSr3H43^%V%BXB3nPwa$^U6cEnUF
zA%BKyH$y@`TJGMkU3v9K>eqkdd`wkBKHhv*r$f;cr1GcVRS#oG$j1Yj*0(B{f>ZwV
z$lDAF`B;2(;0pOACDor$aHz*iTz8&dETux_PhVviLqa~D-8}2F+?EzksY=Ml&<|q`
zJ~cOhAt4{rHZ8J8UCi{sPctOs<NiHfr_||E@1yNAEjZMa*F7^mkuRf$Fe0=*_P8);
zkevGrLz?iB?kihFH9Dls>B`KZZ_2{YDL3TfC7Y*H<SIuqB;@1r?t5OzZ5hXqkdKjp
zZeenjrCv~Q$j1U(BZkVzaSRC!qR4&wo~pMQ_1$xwAt4_twM?q7UYY5U<zG^8$Vcy-
ze!i+adgN?|gnV34qn-AAOYh?YLPEK_Wt(9oH)Z8lT5jyXPnbtgdpY+!hBV<LoqO3`
z)3cg<;O8+zLOwc8&6=XNqWAw*yvl0|4*BTrRl1#woW+okk3F{MKOzUe%aD+dA@4m6
zPOmz@q2Q2@xqIdrCI_FwkkGhvpI!K>Jhvq<B;;d=<Ioc_vg}(54*A$E^G)q-yLuld
z5fUmg_r~I%<s$!PL}-0HS!u`+8CmX~mK!_pGsm;rN4di%GbH4r!;=aRW#mnUgnaxK
z(7mUOEc2d%Lq3l9Q@N##9M6!DkE^;w?2(bz7!vZ)>-=MFnb5C1r9Mz_$j4vpgIcOb
z+w{oM3<(YONUyS`<lylP3HdlWzI}Ifuc7zR;iDEDA{Ok_KBqhZk7Gp0$L%)VyUDq)
zFeJ1-IxVd{Kt`7MM7bd!`vkwbAqOAHkdTj~=T^8YR~gHYkdM#)B-OA?S;3V*{je<j
znSw(;u8A0E@NIfOhJ<{4xWy^29Q+tVLOvci*r=I|%=LwWLq2ZnlyilQ?8A_dJ!hh$
z8mh;3^#^_qYe;CIKR;ivlKO&Jz2I5Cs<E-}{miXX>7cwi4q`+|aNA*R4Sw_)!;nz!
zlc9-O<i5%KjdDYR@A}i<;8(u=84?ma(~j1Q<+eP^kdWYUF_8ubpmTkv;E>>9PToc2
zw(QH0kl>%1pKLB8k1(VO!RZ!6?A)CHz8p(g&h#@|_CyK}3H~|a?hDmMJ+c==LW28G
zE51Q~<JJK}LL+^PN7aUMQ(FJfa$|~b-t*^@d_n5NkWiHofp<b><Uxjnd<;(9Ueh4>
zPYMqC7}oarA-PH)hJ<|lG4Em>S@DAm3HfL_G`yx<Wwu`w9P-gF?m}9*EqgMg2_NYe
z#P+zDvT~IN7!vZamgm@RGBVq53J&?$t7z{F@&>pkA)#S8*?x|}TWJn4BD6l{>{n;3
zLGC0iH}*-d*`4g)7<4#8Lcve`$&oBqd4M4yAM><*d`?DYOQztEk8XkYU(3jz3<>!-
zXWsA0GV%~ZLOwc_4+)l$+5b>*$j8m=POO!Yy%`enadC9p*76`a!jO=UKL`Cdu1=Tw
z{c83!dH;8Ys3J6mMpOwZA?NPNh>(vl&v)ODPm~;DNN9a*lR2}4IuGf$8ky5lZpg<{
zvx*tKYqvW?LT%Z9-I7h}?nPhaeujj6Jh*$NpFD=F(@}89NB{AY433)mFeK#T{es=I
z%H4C2At4{%JG^=#2hX0Kf<r!*yHdvB70^8y67un5>Ceq&9}f`{>hR&We;E7(Fk1#K
zH}*-dPG8a(d}gC3Lqa|#+;a+(NBUuggnXPF`Yb^nL%A|iaLC8fey#7wb6bCggu3VD
zf-pZBd7L33ALIJXC@LfKT2OGv$5v0S8*DE97!vaFRFunb*~e&xgnX<R?Q&6-M?YQW
zwWQ!Ce59+~9W@7cS01z%Ncq#RkG_P2dS~pbUuERnXBZJ$ABQdetC5T>lu65tebUQi
z)aOj{7#hTokdNKk7P~DYPcbCq<NezKFJ)w*lwVT+cLKU%70Ac=(f$Sxhy586>hTet
z#|@5}o?%GH$8Q(jjF*GkT2XMw$H>ap4PM1Llp!G>9Xdz-ma9C&kS2VjtK3`<p4+QP
zy^pq8wBS%vHgLa^UnS}%jUkK(`Pe_lXBQcHmLZ|_(Jjk|X)>~KR>}?ecyPx0{W3Cu
zAt4{@`8|FnZ`5NM67sRu?zk-SDqb)f1&4fG^<dLFd71EMNN5lxb#pplld?o8fBHdm
znjs+{Z~X4NMxN9itSLC;<Fu}m4L-*-h9Myz2fu4GLhT;Ck8y;AazDA5Q9JUkZ%T*k
zT5jyX&x?QJV&suNo*^M0Z=ZJbS99yDyv~r2k2@o7R+opRQw|Ca`PjS55rdy$Ph?2Q
zN1Kl8!{qZ=2@DDO`0Q4X=5qH`%t^r^AMb{TG?bAu7!n$ng*tnN$~}IUAt4{*A~NKY
zt8~dl!66^-7D?W&R;l-KHX)%RXRPmQ&^r$p5n3OY49TIr=3OsO)!bTc?7&aaZr;u1
zA2}>wNXW-&={p<z?DGvnLOy=A*}Xx2z~zyLf<rz&ol<t9JZmgsNXW;=-kS%?$d?Rh
z!biG{s!(zC5M?n_u=*aaotJ`}@R5)!AAVdZBZC<d8tO}?t*t8Ggm}h~kdN0l=By$6
zSUaB<93r;J*s+>Q)HmfKMudE9+IX3#jC{?I(E2#dqOHM`y}J1+H{@fFz_s_}VY!SU
zAs<(5^j|Cc_?96dA9px*d?Qy`rvL?qe7rh2c9&e`Vum!~BV9&~T9LJ|T;&UfG~pv5
zZ#>>{Uq;p{NWmc=$6Dp^l!FH|BxKK=^=&4pRq7A?Jk^lUsJt?4NOyG&*Dttkh1A&C
z>jw7qy!-Dwsg$V~d>$i0g17bvxGZnl9x)^&c)^IaZ`Fp>S6S1Bazjm7_sY&j^7Olq
zAtAvlmfPA`9zib|5)!<7+?<aF!EGrxB>2U&X>4WWLWYC{4@r}Msoa*&7!ne^K#Qv>
zzu1?)om9Ip1&0KWJ~Qm1d}wz$LqdYjS{k`iZA-n6p9l$!bpQUhTg$l{7SVEJ2Yya1
zp503=QZLV1hJ>n|wYRdthgH5YB;@0%S$;dzsZC#H)1nj{@^RMAYwKm?T84yttaz!^
zR(Yg<XGqA$RfTudmys=sQE<q|k2^v_<lvhb67n%>c9~T&GKnD}A9vo!<0=RDE>6KA
zA19XWR9hYDdLOqF5*n82GKSrji~Pfg(E8YT-0Vv7)nhw5EjM=H$8CM{lwb2ovt=Yh
zLc#5JSp}(0srNB^391tEvEr<-8p@+B<xh|7#gLGXJ;JsPl#wwE3Heyi!o8&Y8+ki>
z3J&@B!EgFpc}FynAt4{ng=D!XBX2V#<l~myV{*$#my#45^6~0o7i-lXy^r$=35_9-
z@DN*-s2@X584>bvooy9^mnGFIrRB!n@N+z*d|G)Y7{ZW{kDqFVHk5sQ#*k232E^Q`
zELT~>fr3LmKD_qbPu^qAXGqA$vrBr%%2hsRNXW;suOBs%M|$<r6ddw#^sh-dWaJ`-
zgnV2z%wBtcx_+p?V@Sxy_6_cSRR@vYM^8sBIMm^d&J4{VclZiMgnT@bvDp+E`Gp~&
z{pzYlOFPK-oSK!P+>no(p5<vHSGj>9As<(TJnJGOlNb`}p65<O66D3KtrG=@d|bSL
z=tFt?63LK|k0<P!HIjqpEK5~FJ|=%YJ5fgZG9=`qd&vwF<d-7EFeK#ThTg}$)p4o!
zv1mChIMh2?EQj5a=b_<@2>IB@=jkjNd4(Y%AJ?4h(n5Y|kYjnu4f*I~Is2tNEN3$$
z<YVl@dl547IYUA|mhN9`sr+iA`py&_>T%~~(-Y<Q5N&2i$j9|w3p>jP3@j^9m5`6~
zp4`7GZ`AuUB;;f0yLDyd;O7_;^3md_<8}2aSMOu#idt}}DU00x_E{zB7x8h72>DpP
zTcvyQ7C4?EAs=_f_joHKohngo$j8=xUwX>Hr!XYs<N2L`M#?|JzQvG`kM**gA1E&q
zPL(OR2_NZEp>2<?d6iis_1luBG9)yJzI~c(DYxZAhJ<`v`|{le8R_am!66@a6|B-;
zZp(QL3HjLaRTJ&)*LokH5faMXZqvvR`A$iVDq3#rz)!6ao`=*$T(9^NhJ<|d9q3d@
zM!sc8$j1{|$`6rO@%mLMIOOAiS=%Se8=}<=3HfN#=J_>wnfS?&CVZqvg&o%a=q&em
z2UiMi!beiPXu*=<isGqnWJNM0G%kw_eg5yPp<wlcD5o1$3HeyGV8hz--hU87LO!1S
zSmc;GF7-ZMBqUU1i|hgY<Ra~=X}R5?^)cYt(0cMnpU9Aqk4L^OJuZ**+YAZ$cqZe4
zlxM(cQhrkQe>=QtbqWsocxS}(?lLl%At4_JP3gHoM!sW6$j35W?;Mc3r%4S8Zo)@W
z-1^j>g>sb}7!vZa%(kY%^4>p9O{x+a>h|e&&XR|E7lt(9BTYnm8m{fETuvx20nz(-
zgpekP)RcdB^S>Z(stecBa+~=q5h3Rs49cdyr9?lqjblj2$3}7M8pyr#kRc%-Z!Rd^
zU0x<?*QVf*kG|P{c+0PIUCxk@k6|&n?#t_AGDAW>&Yv^4uH2Sg+$lKZqkZpxqGaS@
zhJ<{aTW0?<S@HaJs7lC3-%UM>%T)$2BxFw(XN$e+{Z;*epQ{=Y8bWu=W%)<FFw+ZO
z!b6Q+8Co5)kF0X3RLXRr{ON5R&4>^(DsN&Zc}9QEkdWXXmbBY0UrTt@rQDF<$M0=P
zlDj*UA)($mktxF&wRiMw`JEvl!Rs&1^;{0#q8<f@1fTHW!Fw6Gg&`rqPZtT_C?nI>
zrz#=An>DJ}Rc_0U3~54eS{;+R*3GLdxT&}4dl?cE+~r1dOEtLO#~cl`;Lu1<7#&?*
zCF;jeKSqRnJY2M;uZ)alNT|whbGN*er{6*iDL3Tf!(8?a<PIOfkdTjaNAAljBQG-~
z<YPq8OM}l)mGY$EkdI08`+QR`qVzpJmLVY@D?UDVP7WT=kdTjuJ4G5ieROI>!A<x`
z8^MIyCHKhVaw<bYKGr$CGF)A7^*-JuBs47Vt(YAm_fEyeT5jx&ZTmWFipsfXG9=_<
zm68=($jFBb2?cNGu<(XFhN?HA;E<1@ZK6)gyVYQZgnX?1Fz-$I9`HwognZ1p?8XMU
z%6d&HxCtL=<!P1RF+^E;Qhys_9YaDs{_OWQLjHwj8ZW96@^N<L#<Fr-{>6}xk8P|U
zXHd6-dLK6t5*kCzvn?4X`}l_uq4m)@*SwLkJZ+n4O^F@&asF*#@KNzy3<>!d=sokS
z96V!lsuF6;8-LetC12xqW=P1#s`n<u%Cp7+hJ<`fzq6K?jLhDGf}8M>R-SQPpFNe^
zvM)nIK6ZUK>X<x;jxi+UW92z7-^s}QEh#wU<M6$IdZ|dgkN$*&I=uIa+51(Ze)n>Y
z5g{LEj=wWkzA`J`O3Up6t&itB-n5Z#V~uA>$j56_JUrwH_#Q(-KF->jeT3YWm0DA9
zsC!Bs=#Z>#i1ghvhan*!yZDEmR_Am*@&Q9aK9)S*zMCApx;F)fd>p=YU}hN^!jO=U
zn_skeET24l!;p}Vo?{>VR;$$e=>C@$9O|86CtYLZ4qwWMkdI@JF5506-!LTP<LoLI
z&&U(7M;pow`Dk@0?5m7i#*mPYQS+}fkb}QxNXW;?kKG+)Wc{`j9O`k)cRhWSrA_(M
z`?#DTAs-h#Z986Ga$hkd<l~R|g|&|l=&P*Tj)FrzKCQDPPCm1+oFO3}{nmYXqYfgy
zkM9WyHKoI74};td+H1M1LOx#1RI`}eJ1ZFy@-c6p+c#z87lwp<Y}IR-!K?qgI#6)P
zN4KYIGs^O;V@Sxya^r3^khj3!84~hwQW3XV@~~{(k%B{mX!p}5j`An=wlE~*V}W+{
z3{K}*ccLmGAJ;89=Pw^-?8}glkGpCdv{bi(dLPdd63Sg7O_s;<Q`b_RwcOZ&pL|76
zZ<CQz84~jGf>oHOyvKUPkdTl2M!BXuqL&UB)a*jRP54N+HF9}dURRJxc>SEdj3FT(
z1501bBv<)`At4{TXNyVsX`U3kWmgIg`B?E+c4u{1>Vt<fBs4CA_g0ONdpvVDsuJ=s
zJT&x&9K0t(LOzz+({+?O1M7V}PDrT8OeZ4@nlg9F;g$d1qF5O_@KgKh!m{$5?$3~r
zkJit=Z<Q6lz>tuS?e?Fxk;jl@4+?I=N4l+Hx#mMN89ALHAs<U+A8)T-py)^XV}^u$
z9PKl2t=v5|eJD8OW2K-$_v9*<G9={V{z@YZ4u*bUNNA|LRzI6Y?w+PSDLCZg{1P3X
z$othTgoKE%j<-527n#h6(0<iwbqjlW9_rLf%Uuofal(Owt8#}QU`WWv7A?LPkb~#w
zO;tiZE~{I0yc~QWLqa}Yxj!V0yit#3NXW+rS$h4DSDxa1C^+Qf?!v8h$;dGb3HkWu
zb^$9n_zi}HeC&F0uE7^Z%Jrq-kUh^so@?)C(I5Dkq9IN6H*K-p^S(Ty40NS6^$YGz
z0zx(}baV@s8?t;qHML6x2>HZw(+s)0r!yoZ_>9NHljSNOFeD`S+>ZSW9%#Dtr{Iv_
z#b!TtldBA3NE01SYk0L?Z*t1W7Yqpr-X-0K_Hy^s@ulF9;4!sk){^JnP=<sA@9?6w
zy&U{ALqdXob=zm~Fsi8^1&0J*k@LhIwMxB@>j?>s^q(1A44U#MBSJnF8rh_~TBLr{
z<~=~mT@k7>uKUIP>PAD4+|H1YkBOh!{*;Ghx`9+B<YTLcAN$I~vNJ<MKDJsBXDe5^
zk0Bu+)6RR+L`G&GM8P2+15TD%B=>lKhJ<_!>%OjrydR2YNXSRO7sGnUcgBhgrr;)g
zr1kOAwRE$TajEpW-p65tgob6Cgxo%I@0@2u$j97uJ2sVj$KGGdjlJRLcyOG-$9cvw
zBow@2{&-6{_;rSaeB5;4-U2yz`5_b>@^Sy;O&{bv^>l`Wd@Ob4(qMU5K4M77$1@+Y
z9+rc<4W;0akG{obw3CrR3<>$@da#he3npGLqzNBs`;xm<*IDWetoP9)Kno6yp=pCh
z8SDg?Ga}^U&CVVV<i+eGLqhB0$}ab{gTVUrvC%Nf4f$9$$mXov;cFQZYRj?H%P*9X
zKNu47(QaIwH}ajaR>LVc<l|7k;fH19E{24BY!g@A;3Zz!Mo^WIj~UNq50I<$V@Sxy
zZo_>p$`es6Lqb0Gni_pT9qM`?i;mQSLmghE&&99uxtHOL2>H13q=WWaFugpn3<>$@
z;+5S^Zpz}LC^zJz``28#W#mYPgnSGsx!m9@nwJ<7>Yl`O&;4Y@O9WDI$j8}fmL$l*
z$1o)1W62pq;^Zph7!vZa<Hk~h)se0rM2@2=IOJo88DnDPE$~E!gnVrFCQ^Iptlr1F
zgoJv>+hh1I*~cnlwA@u7A76Rae<XMKEQW-9Y`FAFb{Tn}At4`ot_(Hk@G4^|IOOBj
zzbkB#tDMV_kdLo>96q5wG1CvrM+^z|_{5P30kS-<<0v@fV}=6bimTf;eU%Fs67umc
z>qZ8rs$Vc9<l~wScDH54JyPzo|M#rWr3&QZ%^yV%tHJd?E+Zt=lxtqp|MzNCq3WCR
z10$O7kuGwN24yU){31a)T%kuco}lHfYQjfCuIW@WQhDQ+T`J@jhBV<LA*Y{;Y^{V=
z{zYG9=804#<YTS2e~M>J!6|=wqz^+vK7L#mtGyCfkKD<SkdJN$H?>egrw*Qe5(S3_
zQS-(g1LdPMT^SPcv0vQQ2l7k2q8SqM(c_U<X?f`>F`0rxKGt4u-B_L5^gfOxB$WHu
z0Ea&EB7T_>P54L`xod2u1<FXLDOzq<6Fw5s?V<g5`A0`H8PbH0gnTsL{<VCk<T*n^
zKDs8A-z8u3)SF7dP54N&MpTt)bCkAJ!s~rp%aD+d=|5f?CNH_k3<>$TD0eLbr1vxm
z4vov7Y1{h9J-&q@As<VgX`f#9(Q-Of3HcZk*{qs+Q&8_?CqkMik~+LYi3_`xMLhLv
z8Oewyd?aM6jSVg<i&^RqAZD4N<u>z4FGBvf65m@!4q!;g$1snjF0wqA7!vaFa>qr}
zWTewf3J&?WxcBFOFZPs9*ZVk&Ax-#5ZJGCMVjpErPrW0$&yXg3BxHwzQ+F%DQ_mW%
zvnV*^<M#Sh=P3UJ<xd}cF+)N_y|AmZi}GF#$5hA<3<>!d6>xrlykG4yTMG^mM=Yw5
zS^jM5K1MX*Bdt8YU;Mr$|By7}94Zo8AIJ9E^-4yzV@SxyHd}80qc)|!!?!Xd<m33)
zi~QuaOgEQ;oA8m^@}TDd2l<+(HA9;4k&u5jY%zFs{8olE;UgiJw2zo#u;el%<l{o?
zLk4fH@SaC)X~IXU^2O^$6XhRpg)<~%&)BRJwIx@7;OCEqggWQ;bH7RIsMIgGt>&w-
zvAa3PKiHR$Q*UKNNbo0lYwncqll*2#Nbn=Gy=JK!f4z;Z7f^0UaL-9s>dD)oZ43zs
zo+EVq0~wjjkdWZlLvIEd2p&Yip)r)(Hk*?=hV*T@l_4R)f0xQPO}^www~(rY1P{6N
zDo93lV@ODF7pJdL^3Qyu7!nfv;KkBq)$Y;zXdA2rherCh>7)P1FFPN~h>(w?Tzv!O
z={KGsp(>wzvKuEOONUTy$j4sehcuUw;}{b1(e+S)ee&FPjUgc)CohYrt}GeKpI)Al
zizqncqg|=q<>cTa7!vYvc&*IyW#k2hgnZokc|m4*1}?Ukf<r!L>-1@wdiAJp%TWvo
z`B?Z?$sy|8ruXq0A)#SuKO^4YQDK=ST5jwOKLIO`uaMWri3|z(STv9AGBvlpDQ_|)
z6x_jPzoR^coR?B?$j8I6x!TIesSFAESiONqZy9-uAt4{_?=JS0XN~g9C^+O}x;zgu
z%d^HLhJ<_^Teyvd9Q+zXLOwcKRNE*c9hOsY$j3W7qKc}shTg}qgoMUWxbvCeDp5bu
z;~5cJACsFs7%9&~PN7<E><vF}E;vQXice!m$j2jBJ@d=RI}8c6rPo%g7xJu8aRmi8
z;UnF8*<Z2aT4j%w`eD>;hJ<|Vkgv6aEYB;3gnT^lqEBq5lq!`!{UEBbl7d4%x_J!^
zl4p(C3<>!-xLpy0FRtBXNXW;v&x*v#`_&4owBRN>T<MQAX?zE}v}+&#CxbjJr!ykt
zW8+OVB4ow?VMu6wbm^b<w0vdevYK*3KK2~iy^oBX$&iqb*%POZl70M#A))TExZ^oV
z?w%@P6ddyL{G6x=899d`As_GMP2M55<wJ&qeB8gi_7)jgWeo*~d~BDYYjYVniy<K&
zFHTvoT=wxUA)(&sWq&&5`JME8_R4Fu+}JH5&t?k`%N@ReAt4{Fd`lawk53uWgpaiH
zbf~rTynNHY#ySda!bd_Lzt?lLvN2HFQ@>0sXGqA$LR}jg$n%*Yp&lQYys*7ev+}2}
zvhjKf4*3}PGmoD-EcM6@3<>$@cP`#X9+$ru67n(n#hD>;@OB$0IOO9UE0@nDQrc1Z
z)9+XJ5)x|4g~^{C<RWc0YDJoP!;b>V^zV`zp6^95Wtm9b;UgH*gpY*0aiwxw<>Ldz
zQvUQEeuW`T_(&Urn-S%@${p^qiGrK(k&x3j7RV$cgBTL>apCd0#pJ#J8-|2@eB<Ra
zT}C$COu?Z+bnVakVsh{`3<>%8bGq|&xys)R3HkWZz0w~U*>(#BhkSg{r_Kp=BGUV~
zn~+fMF7FTJl8dz1suhX7;b*_Qa|5||x-+B+A8Dl5Kfk|*TxAqPLO%K(KJ-VfGT$}|
z4*BTdn=iLKw+&@T$j2J5hHaDg{+AdM^3i@?FKf9iOKzv&kdHIFyniesCom*5E{k|?
zGib|O3<>$zH&+gWUy{0nQ*g+~^mz;1R<BU>KF%j3RAiZ1lMTM#{EQKy>&MGYiguAl
zy88|-x0wS!<m0~mgB!~ueFa0B@R63>U$*5ZC?7gf-rS~Na=$So<m2Y_(|qLvKOJ{c
zaLC8+d3V>8kp~$P^09A;Wk=-h$+wHDgnV?Zvg56c9LkW8kJg+0kI9N(W=LqL*Lztd
zRG!;P@2238kFgm>H&Mr>-p7fAgor%{cRVdO<!wfUd>rJEria{=RrhGQu{Zpj{61%{
zj0|E(6F!pSmb*ezF1e+Py;lqg`FQ8r)QxhL4fj%T$VcnTa}9pVzlI?pACD|<8zfhm
z$dHha`5W9FCnH-&P;kh{`1ex-)RC^AF2flT@-flM&R`2{8A(+__7uNV(_cM^ra$o0
zLqnQqNm?Z?ZFXv*%o)m}s~3C^0U;a9?aO{cUBdMZnQ5Pzx+?aDpHWsGj&k4hU`S{K
zoc8gsBk~A}Vn|5v4+rY6kdJ@l+fTtE!DraiZY?86FeD^+Lbfa!WaLeTgaj{NC}eN(
zl<}kd>3h8D0SaznSkh$q^!4$Ma`&ueNJ#K~Nwc%c$V7&O1YbAHaizR@X?>7_LxQ{P
zdSUPYWj7(Akv?)*30HYnU~xz*vLdAT%_A2Kz5w2pA)zWCZXRbZ_f8~3LO$9yYaSy9
zw?0h4As_R9@qQsA`!FQr;}QG6Gs?(g3<>!-t?y9}xh?ahY>fZ=p<>mFkdN!qCX|({
z^k+!O$M%n$e#upyV@SxywO;)?%1e)36a|NToN(c!!5c-!5E2@eD^?E8EI;jtXGF-y
zK}+U;k$cDSsFoXh!_TB!L%PVwNel@Ek1YGWje4(5zf9a>NXW;eT=P1}W2nM03J&>L
zIVh*W4`^pIB;@0R7LT*b+n2`-3Hi9Y!_5vdvi5NbZo)^}36?x)(^6?m<zMvOvz#Fz
z9}l^%x-Flv{mhV%k6WMSU!*Fo-><ejp#_J=(APcQ7P6097!mSuOSz>jWqFbr5?UXp
zC-*NTkMy?DlpFHVt;lu<xys!P3AJU1e`Z*yy`vvPnNCubkdJm=8IH(%tR4&r`S_?^
z>nCzs9%o3%$Im6+1<O7bjG^Ere55UKf17zt<@*K07!vaF`&#$P@(g^HAt4_}=4@)<
zqr)jJIMm_QZ`UzcA15#(<m1Y_uZGIGZ!jd}<Mua46J%uBl-pbX+he&vJ|^6}yHXxQ
zQy3ER@#nU{oAMaC$B<C><eo4;Sq@(P3<ZaLT<`MiwLAkaWJt)zJj=HR%T+#SNXW+>
z>F*kR{-yR=3J&==YT5Fw@(dipkdTiBk{olW!S(CoYeGW3(|U2{(()qiaZbyP9r#(h
zEPGbD!&fsT<YRcFkR@`JUl<bdF?Wxj$K{o$RV)REeC%lHVx{(uetq1<kdTi-$8z0~
zXAO(<R3+5okq3${lGn!`3<>#o;o#Pr^2Xo@Lqa|_a=lwxexpd93ltpkvD_@@82Lul
z2!@1wJlfxHj(WRI@8dl}LQQG+XxhJD^HqkXehk&RsO82E{CKvVJ6vhX)Q<{RFeK#T
z`ewb`%3~;rAt4`+RzKTVMz*^|!66^h9b9-%ULW@`B;=#_`ryGbGTUXU67tbKq*zfI
z*`FbyK~z2Y-gVi>(+mmuXg_Q01sPf73I&IJEc-2ftBf4UkS2UoCdmKJwmqrq^zSE2
z6s+FItAvDd&-)a(N}hmAUDa}92Y#}RFSAodPGU&N$JhPmx0RdnABKc{EV$qLhg@Zq
zI0_E=SY>&o+cGkUAt4`oO|IxCBVRKl<l_@-AA<w24X;sf$j49LeBQ}(+ggT%#-*F%
zv2^mR@rxlLAD<)-4w0*D7f-=W_()f|jbkbYsz|+$dk6^?*`V;GAUU_yb*)J3lU}D6
zUQ0PcEIqpK!;p}Vo$9>vlYKnNkdTi%js|v<N4m`o3J&?$z}0J*T;&LcgnXP7++eI+
z<rRj6d~DX}aXz`qGAUQT|GO4<gM7R?tKlWN$|(#9`PedJ-eehhk0GI<{%haPCvxy=
z2^1XivDU<Q+HV#0J_ZvKA}*b|wWgf=H6udzbDo~e`b*B;@NX?QcHpOm(;0)W_JuJd
z<m20;>zB(_{$xnV$5&BH3^oSdw<tK|qkXP`iRuKbzns{~kdTknd&h;z$V|7XO324b
zg~lhzNFRoTd<=J;`aqu4qZktMvFwqAltoKgCkou5;E+96cfHT8{w7R+;AfbIgkrBe
z=RZij=cE_>3;`h<S3DcES{~<x|4~!BVh4VXEw8#=o-;-;B(&fL@3)#MBjXqn5`5mf
zo{#0=W$#jONbr~)nXAcFPGd+&@Os5NTFJ-<3<(Jyo2C3AIe3kf%jy3XT-OSa;BSkj
zNs_Bv#E{TPPZ&FQlU(I{hJ*z7h#LG>uCmd63JwXLSf=Di*~j&SghqOFg_`%|B7ZU>
zr1-PW<zC9uZ<~}k^nV?WebOt@X~8!cxr-qoA04wyNI5woO~08RQk9U8^%e}VldJ5_
zkdTjE660&h$m0wN`FJ49jgfNjf{!RT<m1-%?_y+mhBGAO;{j(cgEt;tW=P1#emg#l
zmWR5-V+s!Wm}B8XANhvuWI{s2@=*0PiE@z-84>ca+WyZMWMs`JT5jyX&)cM@8{}cR
zlp&$uTO+Hsmxtv?hJ<|lJloUY*lx3@6ddw#+6t>Na+RAI67uoa*B7_swoLzws)T&J
zJ~4C3gA!?O>%x$bk58QcF*q%Eh#?^#i`R90D38lr&nY<MW7U~8tIF%+Kte)e=#xX7
zgFLmJVnoQt&Li>}{CJ@73oSSHhM#|aHmD;v<tT<U;iCfi@80+H4aYhvV<`2Lqj-jd
z+A?9{>OAr*ot$4%a1%aKl`SoAl$NWU%8-zct1U{kmmdy4U`P`_Qk52?9&J=!qnP?V
zM73T~aLC7H&BLb1v&L$MgnYa{|I|cP9{t6AB11wxW=ODIr%pur>&KR_wcsW?oNfU>
z=(spgJ`J#)5g{K(g%)@xzui9V8!8goRo^dOW~1Dc-5Jt^j}$z)oNFIB_(6t*eEe*k
zZ@OHib;=JI|F=<hfx72g>tzNnVCut=kdJoD8)lHJjABR=K2lo_%(6e_xw5oA=6OfK
zP54NPFU#%cs>~Xxr%Qi^gnWGJ@YhE9NXaFJgnXRRr?<5_)b&0(z1M<6z2lp6Om(Fd
zlt2BXF^dr)A8YR3GfeKCCkzSsc-zg!Qm(Sj2g(ikIQmj2gIh!^7!vZa(CQVR<SM^0
zB;;eGfIBy2WUG%99P07583NDC$Z&>)e7wBq@CkXOTYjP{P54NP&x>7mP##3R84~hw
zQu;dc<tn2Y67n(Y?+ADGSd!kyqMx<kP*avJX0uD~or#PH`PjRiV^tY>han*!zmECU
zPu{&${X)4RA75wfpgoJyPeefs3HjKr_wtnUEz&aaiXkB%?*@d~%a;=kzfy3>#|vYE
zJIKf|hJ*%D)+bjCZiXf@B;;e=3GEC{R<!y?!66?vocMiJ9z@{`3HjJD+jcAU0gB#7
zi|<;MQ0~JAx?Yis?7)bSk3n9yBjjNj!H|%TQI~eDkjGH=M9K~MIMn{F!7D5JF(l;U
zSU=}Ma+N0;67tc<cAoZ%ZvCub^MiszJ{B5Yb%H!y4r55j$KAdW3GyJi!jRCo%zNm)
zt&DX1Nx>l>=RX^qUmllJ7!vYv!=Q%m)i)UEeY{UdsK_H1#)QhbEBw-OV+Vd(o^RD&
z&OMtUAs^GPTeVFd>CYGv^0Dv@_kA+b{Wk?S;iEFP|GP!>G-1_YC3xy<o@ERP`FMF$
z+M{y!d|^n)$NJ@NUzV>Qn<r6l6FyS#fR^65m9|v=ML%n7Vo1oxsuiypd>-u&LqbEn
z&B$^E<hJaROu-=^zwJC#NM0Wg5E3Hhn&*)+qNP2S)gP_MYS8*<5q-koE1G>667sQI
zVE<tGo?r|^LOwq9nq=@BlwxV}sW)G$nedUWc@|t+a7F&X$T)_Ce6;Jm<dS;BKtIy2
zGo%S0NuK*%_7qc)%In7T$jWIcIOJoO&hZ_UNl1AVr$+`eqzNCX%7DnI`AS<Vn(L7t
z7}A7~ggjZYVr^xpr~dS#XF3WF+0(K_R58^@{ehqL8q!3KG=xUjEp=3Z`UUqZ0ZrIQ
zse2~w@sJmZM(NemZe|Yr5OV2C&jrfFreO7bvw<NY!PC#})?F4nnIR#;Yrft5O1806
z1_}-dp7qtorSfFCmmwj+f4z?~_}!XyMyk?;;53F>7iwa!be8g`@16k+X+m&9M!kO7
zK<=Ki3~54eLIy{jkCUskx1ivVJSSSs{w5<QFeD^+c+Qve<PGp`LP8_GK%HX-C*GYb
zwcOYnek@#V7s$hM217zs9u0ZaNk%?qNXW-E>6*-yd&fN!1&4f`KCFH{S@BSYgnV3F
z*xKON10NX@^6}KV+ePL3md!F#aLC7X6AqS>+j2WYLO!0_l-Wk^aSJP|67n(pdi9BN
zl|Bp!`RGt>(K2~`JW5DtSYG?k{;6DKjx1VkGoSQQApc#L<=Wc*j{Gdjk0Bu+ldFy1
zELVAsA)(+FiTV9yc}irZ;E<1(M%xsScdMfr67q5S^XTL97Z7hTB;?~Ni#M;8*V`+9
z`t`ATHVO{;_@ifRP33Sw>H`L03<>#I>4eob*~fI&RHX?YX<RmoKipo~_1mQi-jyLC
zA2;tiyIuD2Bq5<OG+|S-cj_Y<eedMWuH~+5Vhc=Ljh$~wG?1HeBtt?z9uBB{Tt>z-
zB;@1qI)Pi{Wx_cJ1;^Sl@Yg0;@p%jh`RG2zeX2YWJz+@5$AI_{gD-cu=cM3}kIA3L
zWK++D>IYFMLqa}odmdCq?w+3vX~IVum+k({N%<9>bRE?`7X^oW+`4kvTlI*S{`xVJ
zkWh!8|2fNDp3^hs){1m7;UmpMi_(R;D!G+;UEe!>84~ib#Qn+5<qnTwNXW;_@3T3`
zD^H0$6ddxg^^>ypa+OmV66&6Gp9&6@kxv*B^6~!Vd<W$_)%EjIaLC8T@d=;hwp_)K
zkdJPCs-KWANs}28^3lGt(;E3sb*Fq39P%-Fw$)qpLx6f8BM1rg&h!vBgCCz~%&!%R
zz2V2tIdeOC9_q%BkdHS1Y-ucyp(6|l`8d&i?_PQ3$y0!WLp~;yb~kwM$zX<rd~9{B
z)Ev1jV;K_a@w6AqyUEWHN*1KxkdNUP^NyFhX97b)KK5x<*5JY3-wX-)xO(W~5^|N5
z3Q=&#$BgdZljQYr4k4kYe3Lae<@AxXh~H;K6YC@G3*s|wJ}l?1VWZ`)3i%j4Go-(o
zTfgKkVo1oxqd_MPzDo3xAt4_h`Nh<i6|ZMY!66^N^t^2F8_m@W3Hez0cgPvJ${!2~
z4Wa=VlMEh4{Z*KPLq0A%y71ovvC0~$@9{kh3Hex}Si~?nxOEY#67q3c#D>f2xYVzY
z{Rs)>t``tsEf;x|5g{MTZl3BQZ#4=O)pEN+K2|vQ(%|ZTI731{UO%0?x_p5W$B>YZ
zr=wT@EhC+aQE<q|A(uXT%iS}NAt4`E^!U6%uJQ##LO#|!9BpvMwqbD!4voupkMl&!
z*Wzm#67sP?!;G!vr6-XgAs@ee-MB#Bul{AH1&4|pcy_(Pudp{UBIIM^q;x4ih>@1u
zv?ZuW$j7_yVy?==vI|2(K8~}QV(^BagA57z7*;U%R5^HVdkPNuSh!KWl5+6D3<>#I
zuh@Ho9npD)gnUe#nzNJ~yi`dF4*8f=wNGz()|kwY&`@{&7Bfn2%Lfbz`FMTH<_Yrp
zSfi8{+yqf6>%WH+S2i8$FF%}Ez=)8KK9fEg{E+kwLqa}!k6r65FS(u$lpFFfVX)^X
zc>><RkdTk-W5XlmVfl+8As@?D9hg(T*lU;aV&DIM6XsS8^6|B6-wbk<dl(Y((V_3k
zsxmU0BUNd_M;ezdfwAKiq;juOzhCXokS2U2<eN3E|9#n`qPZS<njuZtLziZbdqZ-m
z=K=Hweu|Y*gG0c-?7w))g8LH?veCYGE?fC7)+t6bfux4a9y)E7GAL8uu(fs4Qdck`
zI3XAMejcm{p86Ep2!@0NZ}pc|H~Cg*JVQc)FDSn!yZkV!a#;!v30{BZjy$s9iy6{{
z;MA5kZTg2P+9=`m<NQ5CLV{;+7CKE9ym>haZbEQU=dVkNd*ufS+ZfV>;DiiJx9*AD
zJ(<f>m5`6`EdB|XA87g!(!@xoBHaqK_K`Ol#~9IskA&RlaOsmghHO(-&HomOYG&T>
zLt|)U^YL$$-bwugdjvy5KK{B?=$pKT-(X0{$2!@pZ_0{SszAXZA1@5N-&`I;!3=4_
zN9vwpbBYd;NBS3rgnXRaY0*j<>0Ob6Lq6`S@o|N$_+EyDd~EaMY058zr3*9bN>nA}
zV;;{^*VF}9e}l-EkkGKK{$uwTxhan@BIM)CF`tji$U>F1+}Im_;tEYql;sIzNGNz%
zg@ujf-nq$;kdIHNRvKjBW6B+~|4l@dARm_nEIDo9BSS(y_WoeoMh^akAt4{j=Sy2v
zej7x~Diqv=k2C`(jv72ksZt5AU&S{uqzNAh*&^;v1!Y{O-eje#N>xHW*4-EpC9jV?
z2nmg$abI?omB&ydBSJnNtG)KL+~Ijr?uq|zSYmJZu?rm+BP;IDkdTl2*Za<tNBR|p
zgxYf3+CA=a@QQ8}9P;sZ!KH!n!>D--X~IVumKiP5{@XoDd+JB}GlqnGv|lmaRX$))
zw;BaE;Ulf$7yIQJpoo)Np7jiA!bd_L=}{(0p42U?Q<ad9CmkOwkbUe$NE01Sy;Ce9
zs<E<PO?|O<fDs`dKaW^>U6v<r4K23|w5y)itxiLE))>Z+kdHNeyj<ilbe$m~ALlo?
z79)3fm6{YB>Yjz3nZxDo31&zWKGLupRC>L^(Y6l^3Hj*${KrGNdz#mx;E<1>9h=RS
zr^}rT3Hewsc~O##%u$=FgnYDho3&fsuMQ<7)H~1DT^p#_sr>0@%NRz4e0-jEox$U+
zBJNu5Dv*zl;!YX7EGdv7As>$&%2Hbnp1_chk0sjF%qkDdN_8kW<m36YFZw7xDp-B@
z1T!Sm<Kf@;Y?tpCd|*h($4n)cm6MUpJt#QjV}SF_L&Z`;D}Van;S34+*!XbfhVn7`
z+;yo+$j6XMk88{8;|M}RO&M0M+*kXQ%*vlWcPt}9K6ZWbPjh*z;Zje_jUD*;J-A{n
z<qKh{zY?~LAt4`aZ`_QRk;x1R`B-w$hvD*)+p9hWH{l~KW|^w2-Bc_kxbmm(p3@8o
z`M9cF3s?CEBV`*<mCzsx>e?evMlNJX$j4)jb*stpd}Bz+$M5&LCCSJR4JkO}WA0<S
zv&lY25faM1_j#G8^03VAsTGNR((A|cy0hi`tHT)*S|3kMy&o-KMqOb@$j4)ADtgNg
zdP+B<;E<2@KkbIe$cYRI`FQ`*gFW&k>E8?q`MA1jy$^DgE{!QT<YW2dodI%>&t*tx
zT;9&PHRZE}(#_Ck3<>#|)$`DNIe6VB6ddyLdgZKFWFJEb2^Bf7>4YeG+xC_bq4m-B
z%f#|>?=)(v<#vO7e7x{ttX$<fhJ<_^8*r|ITxAkNLO!;dV%tF8wzc!3;E<042A%Pd
zuf_K<B;=!Q+bxUbk)Ed+RSEfc+J9&fd8GR@B;;fKs0lq~<T-|fhWf>m^9`Qm7Hdwy
zAs-|6_UR&DKaM6OMC|{xs*}9(Twp}V$Hah8XSpfuTWGnlPkId=(P5>0r(`TcLO#Y>
z-a996E^jfU2_Kbt;=jXFUw7>osK}H0Vy}8j3U0zjLZ+=W@0k)jHF7yaLOzZPIx|>q
z%Wn(``S|v8o6jXus#N~;yK3)N6x@W56uk74`mS<Y9%V?#$MHqIUdlt=wl!7x|FI{d
YMM}mriSCK+$tf==8J_YVrb+Yv0E{NxS^xk5

literal 2827388
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%0A+4n*K!~<W*4%tlsbQ1I=HQ}%k27Cb2gWziEXA7i
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
Z7uLxsDqogEmcy@{w`z>Y`498u`yUP&!8iZ_

diff --git a/testdata/examples.txt b/testdata/examples.txt
index f427f787d..3d3491ad4 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -2711,7 +2711,6 @@ add == score != true
 add == score and i32 >= 1
 add == score or 0.5 < 1
 add in [div]
-add not in [f64]
 add not in sort(array)
 add(1, 1) ** i
 add(1, 1) ^ i
@@ -3113,7 +3112,6 @@ array == map(array, add)
 array == nil != nil
 array == nil != true ? 0.5 : 0.5
 array == nil && (false || ok)
-array in [i]
 array[-1]
 array[-i32]
 array[-i64]
@@ -6102,7 +6100,6 @@ foo == foo ? i : score
 foo == last(list)
 foo == nil == nil
 foo == nil || ok
-foo in [half]
 foo in filter(list, false)
 foo in list
 foo in list ? nil : i32
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index b03714e0f..98c34f5d8 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -237,11 +237,7 @@ func In(needle any, array any) bool {
 		if needle == nil {
 			value = v.MapIndex(reflect.Zero(v.Type().Key()))
 		} else {
-			n := reflect.ValueOf(needle)
-			if !n.IsValid() {
-				panic(fmt.Sprintf("cannot use %T as index to %T", needle, array))
-			}
-			value = v.MapIndex(n)
+			value = v.MapIndex(reflect.ValueOf(needle))
 		}
 		if value.IsValid() {
 			return true

From e3c2d0e4cefd3885b00caaeee02084d80748f2f3 Mon Sep 17 00:00:00 2001
From: Anton Gilgur <4970083+agilgur5@users.noreply.github.com>
Date: Wed, 4 Oct 2023 17:34:04 -0400
Subject: [PATCH 168/506] docs: categorize Language Definition functions (#452)

* docs: categorize Language Definition functions

- multi-type / misc functions
- Type Conversion functions
- String functions
- Date functions
- Number functions
- Array functions
- Map functions

- also consistently use `str`, `array`, `n`, `v` for the variable name when referring to a specific type
  - `array` was used consistently for older functions, but not some newer ones
  - `str` added to match `array`
  - `n` was sometimes used for numbers or ints, but not always
  - `v` is for multi-type "values"

Signed-off-by: Anton Gilgur <agilgur5@gmail.com>

* review feedback -- categories to h2

- categories to h2, individual functions to h3 per review feedback

- rename "Built-in Functions" -> "Miscellaneous Functions" as this is now only around the uncategorized functions
  - move this to the bottom of the function list as well so that "miscellaneous" is not first

- combine "Date Manipulation" with "Date Functions"

Signed-off-by: Anton Gilgur <agilgur5@gmail.com>

* move type functions to second-to-last before misc functions, per code review

Signed-off-by: Anton Gilgur <agilgur5@gmail.com>

* move number to after string per code review

Signed-off-by: Anton Gilgur <agilgur5@gmail.com>

---------

Signed-off-by: Anton Gilgur <agilgur5@gmail.com>
---
 docs/Language-Definition.md | 432 ++++++++++++++++++------------------
 1 file changed, 221 insertions(+), 211 deletions(-)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 026d1fe26..352b2ec79 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -193,302 +193,315 @@ For example, expression `split(lower(user.Name), " ")` can be written as:
 user.Name | lower() | split(" ")
 ```
 
-### Date Manipulation
+## String Functions
 
-The following operators can be used to manipulate dates:
+### trim(str[, chars])
+
+Removes white spaces from both ends of a string `str`.
+If the optional `chars` argument is given, it is a string specifying the set of characters to be removed.
 
 ```expr
-date("2023-08-14") + duration("1h")
-date("2023-08-14") - duration("1h")
-date("2023-08-14") - date("2023-08-13") == duration("24h")
+trim("  Hello  ") == "Hello"
+trim("__Hello__", "_") == "Hello"
 ```
 
-## Built-in Functions
+### trimPrefix(str, prefix)
 
-### all(array, predicate)
-
-Returns **true** if all elements satisfies the [predicate](#predicate).
-If the array is empty, returns **true**.
+Removes the specified prefix from the string `str` if it starts with that prefix.
 
 ```expr
-all(tweets, {.Size < 280})
+trimPrefix("HelloWorld", "Hello") == "World"
 ```
 
-### any(array, predicate)
+### trimSuffix(str, suffix)
 
-Returns **true** if any elements satisfies the [predicate](#predicate).
-If the array is empty, returns **false**.
-
-### one(array, predicate)
-
-Returns **true** if _exactly one_ element satisfies the [predicate](#predicate).
-If the array is empty, returns **false**.
+Removes the specified suffix from the string `str` if it ends with that suffix.
 
 ```expr
-one(participants, {.Winner})
+trimSuffix("HelloWorld", "World") == "Hello"
 ```
 
-### none(array, predicate)
+### upper(str)
 
-Returns **true** if _all elements does not_ satisfy the [predicate](#predicate).
-If the array is empty, returns **true**.
-
-### map(array, predicate)
-
-Returns new array by applying the [predicate](#predicate) to each element of
-the array.
+Converts all the characters in string `str` to uppercase.
 
 ```expr
-map(tweets, {.Size})
+upper("hello") == "HELLO"
 ```
 
-### filter(array, predicate)
+### lower(str)
 
-Returns new array by filtering elements of the array by [predicate](#predicate).
+Converts all the characters in string `str` to lowercase.
 
 ```expr
-filter(users, .Name startsWith "J")
+lower("HELLO") == "hello"
 ```
 
-### find(array, predicate)
+### split(str, delimiter[, n])
 
-Finds the first element in an array that satisfies the [predicate](#predicate).
+Splits the string `str` at each instance of the delimiter and returns an array of substrings.
 
 ```expr
-find([1, 2, 3, 4], # > 2) == 3
+split("apple,orange,grape", ",") == ["apple", "orange", "grape"]
+split("apple,orange,grape", ",", 2) == ["apple", "orange,grape"]
 ```
 
-### findIndex(array, predicate)
+### splitAfter(str, delimiter[, n])
 
-Finds the index of the first element in an array that satisfies the [predicate](#predicate).
+Splits the string `str` after each instance of the delimiter.
 
 ```expr
-findIndex([1, 2, 3, 4], # > 2) == 2
+splitAfter("apple,orange,grape", ",") == ["apple,", "orange,", "grape"]
+splitAfter("apple,orange,grape", ",", 2) == ["apple,", "orange,grape"]
 ```
 
-### findLast(array, predicate)
+### replace(str, old, new)
 
-Finds the last element in an array that satisfies the [predicate](#predicate).
+Replaces all occurrences of `old` in string `str` with `new`.
 
 ```expr
-findLast([1, 2, 3, 4], # > 2) == 4
+replace("Hello World", "World", "Universe") == "Hello Universe"
 ```
 
-### findLastIndex(array, predicate)
+### repeat(str, n)
 
-Finds the index of the last element in an array that satisfies the [predicate](#predicate).
+Repeats the string `str` `n` times.
 
 ```expr
-findLastIndex([1, 2, 3, 4], # > 2) == 3
+repeat("Hi", 3) == "HiHiHi"
 ```
 
-### groupBy(array, predicate)
+### indexOf(str, substring)
 
-Groups the elements of an array by the result of the [predicate](#predicate).
+Returns the index of the first occurrence of the substring in string `str` or -1 if not found.
 
 ```expr
-groupBy(users, .Age)
+indexOf("apple pie", "pie") == 6
 ```
 
-### count(array, predicate)
+### lastIndexOf(str, substring)
 
-Returns the number of elements what satisfies the [predicate](#predicate).
-
-Equivalent to:
+Returns the index of the last occurrence of the substring in string `str` or -1 if not found.
 
 ```expr
-len(filter(array, predicate))
+lastIndexOf("apple pie apple", "apple") == 10
 ```
 
-### reduce(array, predicate[, initialValue])
+### hasPrefix(str, prefix)
 
-Applies a predicate to each element in the array, reducing the array to a single value.
-Optional `initialValue` argument can be used to specify the initial value of the accumulator.
-If `initialValue` is not given, the first element of the array is used as the initial value.
+Returns `true` if string `str` starts with the given prefix.
 
-Following variables are available in the predicate:
+```expr
+hasPrefix("HelloWorld", "Hello") == true
+```
 
-- `#` - the current element
-- `#acc` - the accumulator
-- `#index` - the index of the current element
+### hasSuffix(str, suffix)
+
+Returns `true` if string `str` ends with the given suffix.
 
 ```expr
-reduce(1..9, #acc + #)
-reduce(1..9, #acc + #, 0)
+hasSuffix("HelloWorld", "World") == true
 ```
 
-### len(v)
+## Date Functions
 
-Returns the length of an array, a map or a string.
+The following operators can be used to manipulate dates:
 
-### type(v)
+```expr
+date("2023-08-14") + duration("1h")
+date("2023-08-14") - duration("1h")
+date("2023-08-14") - date("2023-08-13") == duration("24h")
+```
 
-Returns the type of the given value `v`.
-Returns on of the following types: `nil`, `bool`, `int`, `uint`, `float`, `string`, `array`, `map`.
-For named types and structs, the type name is returned.
+### now()
+
+Returns the current date and time.
 
 ```expr
-type(42) == "int"
-type("hello") == "string"
-type(now()) == "time.Time"
+createdAt > now() - duration(1h)
 ```
 
-### abs(v)
+### duration(str)
 
-Returns the absolute value of a number.
+Returns [time.Duration](https://pkg.go.dev/time#Duration) value of the given string `str`.
 
-### int(v)
-
-Returns the integer value of a number or a string.
+Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
 
 ```expr
-int("123") == 123
+duration("1h").Seconds() == 3600
 ```
 
-### float(v)
-
-Returns the float value of a number or a string.
+### date(str[, format[, timezone]])
 
-### string(v)
+Converts the given string `str` into a date representation.
 
-Converts the given value `v` into a string representation.
+If the optional `format` argument is given, it is a string specifying the format of the date.
+The format string uses the same formatting rules as the standard
+Go [time package](https://pkg.go.dev/time#pkg-constants).
 
-```expr
-string(123) == "123"
-```
+If the optional `timezone` argument is given, it is a string specifying the timezone of the date.
 
-### trim(v[, chars])
+If the `format` argument is not given, the `v` argument must be in one of the following formats:
 
-Removes white spaces from both ends of a string `v`.
-If the optional `chars` argument is given, it is a string specifying the set of characters to be removed.
+- 2006-01-02
+- 15:04:05
+- 2006-01-02 15:04:05
+- RFC3339
+- RFC822,
+- RFC850,
+- RFC1123,
 
 ```expr
-trim("  Hello  ") == "Hello"
-trim("__Hello__", "_") == "Hello"
+date("2023-08-14")
+date("15:04:05")
+date("2023-08-14T00:00:00Z")
+date("2023-08-14 00:00:00", "2006-01-02 15:04:05", "Europe/Zurich")
 ```
 
-### trimPrefix(v, prefix)
+## Number Functions
 
-Removes the specified prefix from the string `v` if it starts with that prefix.
+### max(n1, n2)
+
+Returns the maximum of the two numbers `n1` and `n2`.
 
 ```expr
-trimPrefix("HelloWorld", "Hello") == "World"
+max(5, 7) == 7
 ```
 
-### trimSuffix(v, suffix)
+### min(n1, n2)
 
-Removes the specified suffix from the string `v` if it ends with that suffix.
+Returns the minimum of the two numbers `n1` and `n2`.
 
 ```expr
-trimSuffix("HelloWorld", "World") == "Hello"
+min(5, 7) == 5
 ```
 
-### upper(v)
+### abs(n)
 
-Converts all the characters in string `v` to uppercase.
+Returns the absolute value of a number.
 
-```expr
-upper("hello") == "HELLO"
-```
+## Array Functions
 
-### lower(v)
+### all(array, predicate)
 
-Converts all the characters in string `v` to lowercase.
+Returns **true** if all elements satisfies the [predicate](#predicate).
+If the array is empty, returns **true**.
 
 ```expr
-lower("HELLO") == "hello"
+all(tweets, {.Size < 280})
 ```
 
-### split(v, delimiter[, n])
+### any(array, predicate)
+
+Returns **true** if any elements satisfies the [predicate](#predicate).
+If the array is empty, returns **false**.
 
-Splits the string `v` at each instance of the delimiter and returns an array of substrings.
+### one(array, predicate)
+
+Returns **true** if _exactly one_ element satisfies the [predicate](#predicate).
+If the array is empty, returns **false**.
 
 ```expr
-split("apple,orange,grape", ",") == ["apple", "orange", "grape"]
-split("apple,orange,grape", ",", 2) == ["apple", "orange,grape"]
+one(participants, {.Winner})
 ```
 
-### splitAfter(v, delimiter[, n])
+### none(array, predicate)
 
-Splits the string `v` after each instance of the delimiter.
+Returns **true** if _all elements does not_ satisfy the [predicate](#predicate).
+If the array is empty, returns **true**.
+
+### map(array, predicate)
+
+Returns new array by applying the [predicate](#predicate) to each element of
+the array.
 
 ```expr
-splitAfter("apple,orange,grape", ",") == ["apple,", "orange,", "grape"]
-splitAfter("apple,orange,grape", ",", 2) == ["apple,", "orange,grape"]
+map(tweets, {.Size})
 ```
 
-### replace(v, old, new)
+### filter(array, predicate)
 
-Replaces all occurrences of `old` in string `v` with `new`.
+Returns new array by filtering elements of the array by [predicate](#predicate).
 
 ```expr
-replace("Hello World", "World", "Universe") == "Hello Universe"
+filter(users, .Name startsWith "J")
 ```
 
-### repeat(v, n)
+### find(array, predicate)
 
-Repeats the string `v` `n` times.
+Finds the first element in an array that satisfies the [predicate](#predicate).
 
 ```expr
-repeat("Hi", 3) == "HiHiHi"
+find([1, 2, 3, 4], # > 2) == 3
 ```
 
-### join(v[, delimiter])
+### findIndex(array, predicate)
 
-Joins an array of strings `v` into a single string with the given delimiter.
-If no delimiter is given, an empty string is used.
+Finds the index of the first element in an array that satisfies the [predicate](#predicate).
 
 ```expr
-join(["apple", "orange", "grape"], ",") == "apple,orange,grape"
-join(["apple", "orange", "grape"]) == "appleorangegrape"
+findIndex([1, 2, 3, 4], # > 2) == 2
 ```
 
-### indexOf(v, substring)
+### findLast(array, predicate)
 
-Returns the index of the first occurrence of the substring in string `v` or -1 if not found.
+Finds the last element in an array that satisfies the [predicate](#predicate).
 
 ```expr
-indexOf("apple pie", "pie") == 6
+findLast([1, 2, 3, 4], # > 2) == 4
 ```
 
-### lastIndexOf(v, substring)
+### findLastIndex(array, predicate)
 
-Returns the index of the last occurrence of the substring in string `v` or -1 if not found.
+Finds the index of the last element in an array that satisfies the [predicate](#predicate).
 
 ```expr
-lastIndexOf("apple pie apple", "apple") == 10
+findLastIndex([1, 2, 3, 4], # > 2) == 3
 ```
 
-### hasPrefix(v, prefix)
+### groupBy(array, predicate)
 
-Returns `true` if string `v` starts with the given prefix.
+Groups the elements of an array by the result of the [predicate](#predicate).
 
 ```expr
-hasPrefix("HelloWorld", "Hello") == true
+groupBy(users, .Age)
 ```
 
-### hasSuffix(v, suffix)
+### count(array, predicate)
 
-Returns `true` if string `v` ends with the given suffix.
+Returns the number of elements what satisfies the [predicate](#predicate).
+
+Equivalent to:
 
 ```expr
-hasSuffix("HelloWorld", "World") == true
+len(filter(array, predicate))
 ```
 
-### max(v1, v2)
+### join(array[, delimiter])
 
-Returns the maximum of the two values `v1` and `v2`.
+Joins an array of strings into a single string with the given delimiter.
+If no delimiter is given, an empty string is used.
 
 ```expr
-max(5, 7) == 7
+join(["apple", "orange", "grape"], ",") == "apple,orange,grape"
+join(["apple", "orange", "grape"]) == "appleorangegrape"
 ```
 
-### min(v1, v2)
+### reduce(array, predicate[, initialValue])
+
+Applies a predicate to each element in the array, reducing the array to a single value.
+Optional `initialValue` argument can be used to specify the initial value of the accumulator.
+If `initialValue` is not given, the first element of the array is used as the initial value.
 
-Returns the minimum of the two values `v1` and `v2`.
+Following variables are available in the predicate:
+
+- `#` - the current element
+- `#acc` - the accumulator
+- `#index` - the index of the current element
 
 ```expr
-min(5, 7) == 5
+reduce(1..9, #acc + #)
+reduce(1..9, #acc + #, 0)
 ```
 
 ### sum(array)
@@ -515,131 +528,132 @@ Returns the median of all numbers in the array.
 median([1, 2, 3]) == 2.0
 ```
 
-### toJSON(v)
+### first(array)
 
-Converts the given value `v` to its JSON string representation.
+Returns the first element from an array. If the array is empty, returns `nil`.
 
 ```expr
-toJSON({"name": "John", "age": 30})
+first([1, 2, 3]) == 1
 ```
 
-### fromJSON(v)
+### last(array)
 
-Parses the given JSON string `v` and returns the corresponding value.
+Returns the last element from an array. If the array is empty, returns `nil`.
 
 ```expr
-fromJSON('{"name": "John", "age": 30}')
+last([1, 2, 3]) == 3
 ```
 
-### toBase64(v)
+### take(array, n)
 
-Encodes the string `v` into Base64 format.
+Returns the first `n` elements from an array. If the array has fewer than `n` elements, returns the whole array.
 
 ```expr
-toBase64("Hello World") == "SGVsbG8gV29ybGQ="
+take([1, 2, 3, 4], 2) == [1, 2]
 ```
 
-### fromBase64(v)
+### sort(array[, order])
 
-Decodes the Base64 encoded string `v` back to its original form.
+Sorts an array in ascending order. Optional `order` argument can be used to specify the order of sorting: `asc`
+or `desc`.
 
 ```expr
-fromBase64("SGVsbG8gV29ybGQ=") == "Hello World"
+sort([3, 1, 4]) == [1, 3, 4]
+sort([3, 1, 4], "desc") == [4, 3, 1]
 ```
 
-### now()
+### sortBy(array, key[, order])
 
-Returns the current date and time.
+Sorts an array of maps by a specific key in ascending order. Optional `order` argument can be used to specify the order
+of sorting: `asc` or `desc`.
 
 ```expr
-createdAt > now() - duration(1h)
+sortBy(users, "Age")
+sortBy(users, "Age", "desc")
 ```
 
-### duration(v)
+## Map Functions
 
-Returns [time.Duration](https://pkg.go.dev/time#Duration) value of the given string `v`.
+### keys(map)
 
-Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
+Returns an array containing the keys of the map.
 
 ```expr
-duration("1h").Seconds() == 3600
+keys({"name": "John", "age": 30}) == ["name", "age"]
 ```
 
-### date(v[, format[, timezone]])
+### values(map)
 
-Converts the given value `v` into a date representation.
+Returns an array containing the values of the map.
 
-If the optional `format` argument is given, it is a string specifying the format of the date.
-The format string uses the same formatting rules as the standard
-Go [time package](https://pkg.go.dev/time#pkg-constants).
+```expr
+values({"name": "John", "age": 30}) == ["John", 30]
+```
 
-If the optional `timezone` argument is given, it is a string specifying the timezone of the date.
+## Type Conversion Functions
 
-If the `format` argument is not given, the `v` argument must be in one of the following formats:
+### type(v)
 
-- 2006-01-02
-- 15:04:05
-- 2006-01-02 15:04:05
-- RFC3339
-- RFC822,
-- RFC850,
-- RFC1123,
+Returns the type of the given value `v`.
+Returns on of the following types: `nil`, `bool`, `int`, `uint`, `float`, `string`, `array`, `map`.
+For named types and structs, the type name is returned.
 
 ```expr
-date("2023-08-14")
-date("15:04:05")
-date("2023-08-14T00:00:00Z")
-date("2023-08-14 00:00:00", "2006-01-02 15:04:05", "Europe/Zurich")
+type(42) == "int"
+type("hello") == "string"
+type(now()) == "time.Time"
 ```
 
-### first(v)
+### int(v)
 
-Returns the first element from an array `v`. If the array is empty, returns `nil`.
+Returns the integer value of a number or a string.
 
 ```expr
-first([1, 2, 3]) == 1
+int("123") == 123
 ```
 
-### last(v)
+### float(v)
 
-Returns the last element from an array `v`. If the array is empty, returns `nil`.
+Returns the float value of a number or a string.
+
+### string(v)
+
+Converts the given value `v` into a string representation.
 
 ```expr
-last([1, 2, 3]) == 3
+string(123) == "123"
 ```
 
-### get(v, index)
+### toJSON(v)
 
-Retrieves the element at the specified index from an array or map `v`. If the index is out of range, returns `nil`.
-Or the key does not exist, returns `nil`.
+Converts the given value `v` to its JSON string representation.
 
 ```expr
-get([1, 2, 3], 1) == 2
-get({"name": "John", "age": 30}, "name") == "John"
+toJSON({"name": "John", "age": 30})
 ```
 
-### take(array, n)
+### fromJSON(v)
 
-Returns the first `n` elements from an array. If the array has fewer than `n` elements, returns the whole array.
+Parses the given JSON string `v` and returns the corresponding value.
 
 ```expr
-take([1, 2, 3, 4], 2) == [1, 2]
+fromJSON('{"name": "John", "age": 30}')
 ```
 
-### keys(map)
+### toBase64(v)
 
-Returns an array containing the keys of the map.
+Encodes the string `v` into Base64 format.
 
 ```expr
-keys({"name": "John", "age": 30}) == ["name", "age"]
+toBase64("Hello World") == "SGVsbG8gV29ybGQ="
 ```
 
-### values(map)
+### fromBase64(v)
 
-Returns an array containing the values of the map.
+Decodes the Base64 encoded string `v` back to its original form.
 
 ```expr
-values({"name": "John", "age": 30}) == ["John", 30]
+fromBase64("SGVsbG8gV29ybGQ=") == "Hello World"
 ```
 
 ### toPairs(map)
@@ -658,30 +672,26 @@ Converts an array of key-value pairs to a map.
 fromPairs([["name", "John"], ["age", 30]]) == {"name": "John", "age": 30}
 ```
 
-### sort(array[, order])
+## Miscellaneous Functions
 
-Sorts an array in ascending order. Optional `order` argument can be used to specify the order of sorting: `asc`
-or `desc`.
+### len(v)
 
-```expr
-sort([3, 1, 4]) == [1, 3, 4]
-sort([3, 1, 4], "desc") == [4, 3, 1]
-```
+Returns the length of an array, a map or a string.
 
-### sortBy(array, key[, order])
+### get(v, index)
 
-Sorts an array of maps by a specific key in ascending order. Optional `order` argument can be used to specify the order
-of sorting: `asc` or `desc`.
+Retrieves the element at the specified index from an array or map `v`. If the index is out of range, returns `nil`.
+Or the key does not exist, returns `nil`.
 
 ```expr
-sortBy(users, "Age")
-sortBy(users, "Age", "desc")
+get([1, 2, 3], 1) == 2
+get({"name": "John", "age": 30}, "name") == "John"
 ```
 
 ## Predicate
 
 The predicate is an expression. It takes one or more arguments and returns a boolean value.
-To access the arguments, the `#` symbol is used. 
+To access the arguments, the `#` symbol is used.
 
 ```expr
 map(0..9, {# / 2})

From 7f0746399c3812a3a3dc6381f0c5805882f74bbc Mon Sep 17 00:00:00 2001
From: Augustin Peyrard <augustin.peyrard@gmail.com>
Date: Thu, 16 Nov 2023 03:40:28 -0800
Subject: [PATCH 169/506] Fix Fetch and OpDeref (#467)

* Fix OpDeref allowing to deref pointer of interfaces

Loop over `Ptr` and `Interface` kind and get `Elem`. Also return
directly the `nil` otherwise we might are returning the pointer nil
value and not the base nil.

* Fix deref interface in Fetch

We were only de-referencing pointers, but we can have pointer of
interface or interface obfuscating pointers...
So before trying to fetch anything, just deference fully the
variable.
---
 expr_test.go             | 15 ++++++++++
 test/deref/deref_test.go | 63 ++++++++++++++++++++++++++++++++++++++++
 vm/runtime/runtime.go    | 32 ++++++++------------
 3 files changed, 90 insertions(+), 20 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index 4cb1902a5..507729947 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1204,6 +1204,21 @@ func TestExpr_fetch_from_func(t *testing.T) {
 	assert.Contains(t, err.Error(), "cannot fetch Value from func()")
 }
 
+func TestExpr_fetch_from_interface(t *testing.T) {
+	type FooBar struct {
+		Value string
+	}
+	foobar := &FooBar{"waldo"}
+	var foobarAny any = foobar
+	var foobarPtrAny any = &foobarAny
+
+	res, err := expr.Eval("foo.Value", map[string]any{
+		"foo": foobarPtrAny,
+	})
+	assert.NoError(t, err)
+	assert.Equal(t, "waldo", res)
+}
+
 func TestExpr_map_default_values(t *testing.T) {
 	env := map[string]any{
 		"foo": map[string]string{},
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 4af128bde..283631c0d 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -137,3 +137,66 @@ func TestDeref_multiple_pointers(t *testing.T) {
 		require.Equal(t, 44, output)
 	})
 }
+
+func TestDeref_pointer_of_interface(t *testing.T) {
+	v := 42
+	a := &v
+	b := any(a)
+	c := any(&b)
+	t.Run("returned as is", func(t *testing.T) {
+		output, err := expr.Eval(`c`, map[string]any{
+			"c": c,
+		})
+		require.NoError(t, err)
+		require.Equal(t, c, output)
+		require.IsType(t, (*interface{})(nil), output)
+	})
+	t.Run("+ works", func(t *testing.T) {
+		output, err := expr.Eval(`c+2`, map[string]any{
+			"c": c,
+		})
+		require.NoError(t, err)
+		require.Equal(t, 44, output)
+	})
+}
+
+func TestDeref_nil(t *testing.T) {
+	var b *int = nil
+	c := &b
+	t.Run("returned as is", func(t *testing.T) {
+		output, err := expr.Eval(`c`, map[string]any{
+			"c": c,
+		})
+		require.NoError(t, err)
+		require.Equal(t, c, output)
+		require.IsType(t, (**int)(nil), output)
+	})
+	t.Run("== nil works", func(t *testing.T) {
+		output, err := expr.Eval(`c == nil`, map[string]any{
+			"c": c,
+		})
+		require.NoError(t, err)
+		require.Equal(t, true, output)
+	})
+}
+
+func TestDeref_nil_in_pointer_of_interface(t *testing.T) {
+	var a *int32 = nil
+	b := any(a)
+	c := any(&b)
+	t.Run("returned as is", func(t *testing.T) {
+		output, err := expr.Eval(`c`, map[string]any{
+			"c": c,
+		})
+		require.NoError(t, err)
+		require.Equal(t, c, output)
+		require.IsType(t, (*interface{})(nil), output)
+	})
+	t.Run("== nil works", func(t *testing.T) {
+		output, err := expr.Eval(`c == nil`, map[string]any{
+			"c": c,
+		})
+		require.NoError(t, err)
+		require.Equal(t, true, output)
+	})
+}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 98c34f5d8..406f85096 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -8,6 +8,14 @@ import (
 	"reflect"
 )
 
+func deref(kind reflect.Kind, value reflect.Value) (reflect.Kind, reflect.Value) {
+	for kind == reflect.Ptr || kind == reflect.Interface {
+		value = value.Elem()
+		kind = value.Kind()
+	}
+	return kind, value
+}
+
 func Fetch(from, i any) any {
 	v := reflect.ValueOf(from)
 	kind := v.Kind()
@@ -28,10 +36,8 @@ func Fetch(from, i any) any {
 	// Structs, maps, and slices can be access through a pointer or through
 	// a value, when they are accessed through a pointer we don't want to
 	// copy them to a value.
-	if kind == reflect.Ptr {
-		v = reflect.Indirect(v)
-		kind = v.Kind()
-	}
+	// De-reference everything if necessary (interface and pointers)
+	kind, v = deref(kind, v)
 
 	// TODO: We can create separate opcodes for each of the cases below to make
 	// the little bit faster.
@@ -145,27 +151,13 @@ func Deref(i any) any {
 
 	v := reflect.ValueOf(i)
 
-	if v.Kind() == reflect.Interface {
+	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
 		if v.IsNil() {
-			return i
+			return nil
 		}
 		v = v.Elem()
 	}
 
-loop:
-	for v.Kind() == reflect.Ptr {
-		if v.IsNil() {
-			return i
-		}
-		indirect := reflect.Indirect(v)
-		switch indirect.Kind() {
-		case reflect.Struct, reflect.Map, reflect.Array, reflect.Slice:
-			break loop
-		default:
-			v = v.Elem()
-		}
-	}
-
 	if v.IsValid() {
 		return v.Interface()
 	}

From fcf2b55decfdb74892e3f30e28c73f45cd24ec15 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 16 Nov 2023 15:41:43 +0100
Subject: [PATCH 170/506] Do not copy node type in ast.Patch

Fixes #468
---
 ast/node.go                          |  1 -
 checker/checker.go                   |  8 ++++
 test/patch/set_type/set_type_test.go | 56 ++++++++++++++++++++++++++++
 3 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 test/patch/set_type/set_type_test.go

diff --git a/ast/node.go b/ast/node.go
index d037926c1..ea2ddfd30 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -17,7 +17,6 @@ type Node interface {
 }
 
 func Patch(node *Node, newNode Node) {
-	newNode.SetType((*node).Type())
 	newNode.SetLocation((*node).Location())
 	*node = newNode
 }
diff --git a/checker/checker.go b/checker/checker.go
index da46b6f9f..0f6f34b5b 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -536,6 +536,14 @@ func (v *checker) SliceNode(node *ast.SliceNode) (reflect.Type, info) {
 }
 
 func (v *checker) CallNode(node *ast.CallNode) (reflect.Type, info) {
+	t, i := v.functionReturnType(node)
+	if node.Type() != nil {
+		return node.Type(), i
+	}
+	return t, i
+}
+
+func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) {
 	fn, fnInfo := v.visit(node.Callee)
 
 	if fnInfo.fn != nil {
diff --git a/test/patch/set_type/set_type_test.go b/test/patch/set_type/set_type_test.go
new file mode 100644
index 000000000..bdeee7d68
--- /dev/null
+++ b/test/patch/set_type/set_type_test.go
@@ -0,0 +1,56 @@
+package set_type_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/ast"
+)
+
+func TestPatch_SetType(t *testing.T) {
+	_, err := expr.Compile(
+		`Value + "string"`,
+		expr.Env(Env{}),
+		expr.Function(
+			"getValue",
+			func(params ...any) (any, error) {
+				return params[0].(Value).Int, nil
+			},
+			// We can set function type right here,
+			// but we want to check what SetType in
+			// getValuePatcher will take an effect.
+		),
+		expr.Patch(getValuePatcher{}),
+	)
+	require.Error(t, err)
+}
+
+type Value struct {
+	Int int
+}
+
+type Env struct {
+	Value Value
+}
+
+var valueType = reflect.TypeOf((*Value)(nil)).Elem()
+
+type getValuePatcher struct{}
+
+func (getValuePatcher) Visit(node *ast.Node) {
+	id, ok := (*node).(*ast.IdentifierNode)
+	if !ok {
+		return
+	}
+	if id.Type() == valueType {
+		newNode := &ast.CallNode{
+			Callee:    &ast.IdentifierNode{Value: "getValue"},
+			Arguments: []ast.Node{id},
+		}
+		newNode.SetType(reflect.TypeOf(0))
+		ast.Patch(node, newNode)
+	}
+}

From dbbec977b30469c99b7f9d586423d4e7bcbd0bb2 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 16 Nov 2023 15:49:53 +0100
Subject: [PATCH 171/506] Fix checker panic

Fixes #453
---
 checker/checker.go | 5 +++++
 expr_test.go       | 8 ++++++++
 2 files changed, 13 insertions(+)

diff --git a/checker/checker.go b/checker/checker.go
index 0f6f34b5b..fdf474bc3 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -560,6 +560,11 @@ func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) {
 			fnName = name.Value
 		}
 	}
+
+	if fn == nil {
+		return v.error(node, "%v is nil; cannot call nil as function", fnName)
+	}
+
 	switch fn.Kind() {
 	case reflect.Interface:
 		return anyType, info{}
diff --git a/expr_test.go b/expr_test.go
index 507729947..ec3fa1e29 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2014,3 +2014,11 @@ func TestIssue432(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, float64(10), out)
 }
+
+func TestIssue453(t *testing.T) {
+	env := map[string]any{
+		"foo": nil,
+	}
+	_, err := expr.Compile(`foo()`, expr.Env(env))
+	require.Error(t, err)
+}

From 507d734cb9c76a4850112181533208b5911dfb46 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 16 Nov 2023 16:22:34 +0100
Subject: [PATCH 172/506] Fix ast printing for ?? operator

Fixes #442
---
 ast/print.go      | 21 +++++++++++++--------
 ast/print_test.go |  6 ++++--
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/ast/print.go b/ast/print.go
index dd9e0db0f..b4fb4f367 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -58,18 +58,23 @@ func (n *UnaryNode) String() string {
 }
 
 func (n *BinaryNode) String() string {
-	var left, right string
-	if b, ok := n.Left.(*BinaryNode); ok && operator.Less(b.Operator, n.Operator) {
-		left = fmt.Sprintf("(%s)", n.Left.String())
+	var lhs, rhs string
+
+	lb, ok := n.Left.(*BinaryNode)
+	if ok && (operator.Less(lb.Operator, n.Operator) || lb.Operator == "??") {
+		lhs = fmt.Sprintf("(%s)", n.Left.String())
 	} else {
-		left = n.Left.String()
+		lhs = n.Left.String()
 	}
-	if b, ok := n.Right.(*BinaryNode); ok && operator.Less(b.Operator, n.Operator) {
-		right = fmt.Sprintf("(%s)", n.Right.String())
+
+	rb, ok := n.Right.(*BinaryNode)
+	if ok && operator.Less(rb.Operator, n.Operator) {
+		rhs = fmt.Sprintf("(%s)", n.Right.String())
 	} else {
-		right = n.Right.String()
+		rhs = n.Right.String()
 	}
-	return fmt.Sprintf("%s %s %s", left, n.Operator, right)
+
+	return fmt.Sprintf("%s %s %s", lhs, n.Operator, rhs)
 }
 
 func (n *ChainNode) String() string {
diff --git a/ast/print_test.go b/ast/print_test.go
index 7bb5c85b2..077e85582 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -3,10 +3,11 @@ package ast_test
 import (
 	"testing"
 
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	"github.com/antonmedv/expr/ast"
+	"github.com/antonmedv/expr/parser"
 )
 
 func TestPrint(t *testing.T) {
@@ -67,6 +68,7 @@ func TestPrint(t *testing.T) {
 		{`a[1:]`, `a[1:]`},
 		{`a[1:]`, `a[1:]`},
 		{`a[:]`, `a[:]`},
+		{`(nil ?? 1) > 0`, `(nil ?? 1) > 0`},
 	}
 
 	for _, tt := range tests {

From d27e5a322e71bd7e8fa0d970883d525c3ff1413b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 16 Nov 2023 16:29:52 +0100
Subject: [PATCH 173/506] Add support for float in sort() builtin

Fixes #448
---
 builtin/builtin_test.go | 7 +++++--
 builtin/sort.go         | 5 +++++
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 62bd12562..533f59a88 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -7,14 +7,15 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/conf"
 	"github.com/antonmedv/expr/parser"
 	"github.com/antonmedv/expr/test/mock"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestBuiltin(t *testing.T) {
@@ -403,6 +404,7 @@ func TestBuiltin_sort(t *testing.T) {
 	env := map[string]any{
 		"ArrayOfString": []string{"foo", "bar", "baz"},
 		"ArrayOfInt":    []int{3, 2, 1},
+		"ArrayOfFloat":  []float64{3.0, 2.0, 1.0},
 		"ArrayOfFoo":    []mock.Foo{{Value: "c"}, {Value: "a"}, {Value: "b"}},
 	}
 	tests := []struct {
@@ -411,6 +413,7 @@ func TestBuiltin_sort(t *testing.T) {
 	}{
 		{`sort([])`, []any{}},
 		{`sort(ArrayOfInt)`, []any{1, 2, 3}},
+		{`sort(ArrayOfFloat)`, []any{1.0, 2.0, 3.0}},
 		{`sort(ArrayOfInt, 'desc')`, []any{3, 2, 1}},
 		{`sortBy(ArrayOfFoo, 'Value')`, []any{mock.Foo{Value: "a"}, mock.Foo{Value: "b"}, mock.Foo{Value: "c"}}},
 		{`sortBy([{id: "a"}, {id: "b"}], "id", "desc")`, []any{map[string]any{"id": "b"}, map[string]any{"id": "a"}}},
diff --git a/builtin/sort.go b/builtin/sort.go
index 31e302c72..9b9ddc165 100644
--- a/builtin/sort.go
+++ b/builtin/sort.go
@@ -33,6 +33,11 @@ func (s *Sortable) Less(i, j int) bool {
 			return a.Int() > b.Int()
 		}
 		return a.Int() < b.Int()
+	case reflect.Float64, reflect.Float32:
+		if s.Desc {
+			return a.Float() > b.Float()
+		}
+		return a.Float() < b.Float()
 	case reflect.String:
 		if s.Desc {
 			return a.String() > b.String()

From 0354d1b2aae9b78a2b7baeaa37537f1871f1647e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 16 Nov 2023 21:39:50 +0100
Subject: [PATCH 174/506] Only emit OpEqual{Int,String} for simple types

Fixes #461
---
 compiler/compiler.go | 19 +++++++++--
 expr_test.go         | 80 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 97 insertions(+), 2 deletions(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 8e26d8788..eada2ad04 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -360,6 +360,10 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 	l := kind(node.Left)
 	r := kind(node.Right)
 
+	leftIsSimple := isSimpleType(node.Left)
+	rightIsSimple := isSimpleType(node.Right)
+	leftAndRightAreSimple := leftIsSimple && rightIsSimple
+
 	switch node.Operator {
 	case "==":
 		c.compile(node.Left)
@@ -367,9 +371,9 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 		c.compile(node.Right)
 		c.derefInNeeded(node.Left)
 
-		if l == r && l == reflect.Int {
+		if l == r && l == reflect.Int && leftAndRightAreSimple {
 			c.emit(OpEqualInt)
-		} else if l == r && l == reflect.String {
+		} else if l == r && l == reflect.String && leftAndRightAreSimple {
 			c.emit(OpEqualString)
 		} else {
 			c.emit(OpEqual)
@@ -534,6 +538,17 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 	}
 }
 
+func isSimpleType(node ast.Node) bool {
+	if node == nil {
+		return false
+	}
+	t := node.Type()
+	if t == nil {
+		return false
+	}
+	return t.PkgPath() == ""
+}
+
 func (c *compiler) ChainNode(node *ast.ChainNode) {
 	c.chains = append(c.chains, []int{})
 	c.compile(node.Node)
diff --git a/expr_test.go b/expr_test.go
index ec3fa1e29..9338bd72d 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2022,3 +2022,83 @@ func TestIssue453(t *testing.T) {
 	_, err := expr.Compile(`foo()`, expr.Env(env))
 	require.Error(t, err)
 }
+
+func TestIssue461(t *testing.T) {
+	type EnvStr string
+	type EnvField struct {
+		S   EnvStr
+		Str string
+	}
+	type Env struct {
+		S        EnvStr
+		Str      string
+		EnvField EnvField
+	}
+	var tests = []struct {
+		input string
+		env   Env
+		want  bool
+	}{
+		{
+			input: "Str == S",
+			env:   Env{S: "string", Str: "string"},
+			want:  false,
+		},
+		{
+			input: "Str == Str",
+			env:   Env{Str: "string"},
+			want:  true,
+		},
+		{
+			input: "S == S",
+			env:   Env{Str: "string"},
+			want:  true,
+		},
+		{
+			input: `Str == "string"`,
+			env:   Env{Str: "string"},
+			want:  true,
+		},
+		{
+			input: `S == "string"`,
+			env:   Env{Str: "string"},
+			want:  false,
+		},
+		{
+			input: "EnvField.Str == EnvField.S",
+			env:   Env{EnvField: EnvField{S: "string", Str: "string"}},
+			want:  false,
+		},
+		{
+			input: "EnvField.Str == EnvField.Str",
+			env:   Env{EnvField: EnvField{Str: "string"}},
+			want:  true,
+		},
+		{
+			input: "EnvField.S == EnvField.S",
+			env:   Env{EnvField: EnvField{Str: "string"}},
+			want:  true,
+		},
+		{
+			input: `EnvField.Str == "string"`,
+			env:   Env{EnvField: EnvField{Str: "string"}},
+			want:  true,
+		},
+		{
+			input: `EnvField.S == "string"`,
+			env:   Env{EnvField: EnvField{Str: "string"}},
+			want:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			program, err := expr.Compile(tt.input, expr.Env(tt.env), expr.AsBool())
+
+			out, err := expr.Run(program, tt.env)
+			require.NoError(t, err)
+
+			require.Equal(t, tt.want, out)
+		})
+	}
+}

From e9607c76a2c19a0c3548b1be8781830c22bd133f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 16 Nov 2023 22:12:50 +0100
Subject: [PATCH 175/506] Improve type checking for $env

Fixes #462
---
 ast/node.go        | 18 ++++++++++++++++++
 checker/checker.go | 46 ++++++++++++++++++++++++++++++----------------
 expr_test.go       | 12 +++++++++++-
 3 files changed, 59 insertions(+), 17 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index ea2ddfd30..d9c0d73da 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -54,6 +54,15 @@ type IdentifierNode struct {
 	MethodIndex int  // index of method, set only if Method is true
 }
 
+func (n *IdentifierNode) SetFieldIndex(field []int) {
+	n.FieldIndex = field
+}
+
+func (n *IdentifierNode) SetMethodIndex(methodIndex int) {
+	n.Method = true
+	n.MethodIndex = methodIndex
+}
+
 type IntegerNode struct {
 	base
 	Value int
@@ -111,6 +120,15 @@ type MemberNode struct {
 	MethodIndex int
 }
 
+func (n *MemberNode) SetFieldIndex(field []int) {
+	n.FieldIndex = field
+}
+
+func (n *MemberNode) SetMethodIndex(methodIndex int) {
+	n.Method = true
+	n.MethodIndex = methodIndex
+}
+
 type SliceNode struct {
 	base
 	Node Node
diff --git a/checker/checker.go b/checker/checker.go
index fdf474bc3..8e536518c 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -157,23 +157,34 @@ func (v *checker) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 	if node.Value == "$env" {
 		return mapType, info{}
 	}
-	if fn, ok := v.config.Builtins[node.Value]; ok {
+	return v.env(node, node.Value, true)
+}
+
+type NodeWithIndexes interface {
+	ast.Node
+	SetFieldIndex(field []int)
+	SetMethodIndex(methodIndex int)
+}
+
+func (v *checker) env(node NodeWithIndexes, name string, strict bool) (reflect.Type, info) {
+	if fn, ok := v.config.Builtins[name]; ok {
 		return functionType, info{fn: fn}
 	}
-	if fn, ok := v.config.Functions[node.Value]; ok {
+	if fn, ok := v.config.Functions[name]; ok {
 		return functionType, info{fn: fn}
 	}
-	if t, ok := v.config.Types[node.Value]; ok {
+	if t, ok := v.config.Types[name]; ok {
 		if t.Ambiguous {
-			return v.error(node, "ambiguous identifier %v", node.Value)
+			return v.error(node, "ambiguous identifier %v", name)
+		}
+		node.SetFieldIndex(t.FieldIndex)
+		if t.Method {
+			node.SetMethodIndex(t.MethodIndex)
 		}
-		node.Method = t.Method
-		node.MethodIndex = t.MethodIndex
-		node.FieldIndex = t.FieldIndex
 		return t.Type, info{method: t.Method}
 	}
-	if v.config.Strict {
-		return v.error(node, "unknown name %v", node.Value)
+	if v.config.Strict && strict {
+		return v.error(node, "unknown name %v", name)
 	}
 	if v.config.DefaultType != nil {
 		return v.config.DefaultType, info{}
@@ -433,12 +444,16 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 	prop, _ := v.visit(node.Property)
 
 	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "$env" {
-		// If the index is a constant string, can save some
-		// cycles later by finding the type of its referent
 		if name, ok := node.Property.(*ast.StringNode); ok {
-			if t, ok := v.config.Types[name.Value]; ok {
-				return t.Type, info{method: t.Method}
-			} // No error if no type found; it may be added to env between compile and run
+			strict := v.config.Strict
+			if node.Optional {
+				// If user explicitly set optional flag, then we should not
+				// throw error if field is not found (as user trying to handle
+				// this case). But if user did not set optional flag, then we
+				// should throw error if field is not found & v.config.Strict.
+				strict = false
+			}
+			return v.env(node, name.Value, strict)
 		}
 		return anyType, info{}
 	}
@@ -460,8 +475,7 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 				// the same interface.
 				return m.Type, info{}
 			} else {
-				node.Method = true
-				node.MethodIndex = m.Index
+				node.SetMethodIndex(m.Index)
 				node.Name = name.Value
 				return m.Type, info{method: true}
 			}
diff --git a/expr_test.go b/expr_test.go
index 9338bd72d..903336d10 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1884,7 +1884,7 @@ func TestEnv_keyword(t *testing.T) {
 		{"$env[red + irect]", 10},
 		{"$env['String Map']?.five", ""},
 		{"$env.red", "n"},
-		{"$env?.blue", nil},
+		{"$env?.unknown", nil},
 		{"$env.mylist[1]", 2},
 		{"$env?.OtherMap?.a", "b"},
 		{"$env?.OtherMap?.d", ""},
@@ -2102,3 +2102,13 @@ func TestIssue461(t *testing.T) {
 		})
 	}
 }
+
+func TestIssue462(t *testing.T) {
+	env := map[string]any{
+		"foo": func() (string, error) {
+			return "bar", nil
+		},
+	}
+	_, err := expr.Compile(`$env.unknown(int())`, expr.Env(env))
+	require.Error(t, err)
+}

From 5de348e65c8bf02fc73bc1bbd91fbea0713a3c00 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 16 Nov 2023 22:16:12 +0100
Subject: [PATCH 176/506] fuzz: skip too long code

---
 test/fuzz/fuzz_test.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index e69aaec7b..64467a65e 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -53,6 +53,10 @@ func FuzzExpr(f *testing.F) {
 	env := NewEnv()
 
 	f.Fuzz(func(t *testing.T, code string) {
+		if len(code) > 1000 {
+			t.Skip("too long code")
+		}
+
 		program, err := expr.Compile(code, expr.Env(env))
 		if err != nil {
 			t.Skipf("compile error: %s", err)

From 939aca18e66514ca0727c309f8df8c510a0e2fc1 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 16 Nov 2023 22:31:25 +0100
Subject: [PATCH 177/506] fuzz: ignore sun(any) runtime errors

Fixes #464
---
 test/fuzz/fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 64467a65e..03d29e3b8 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -48,6 +48,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`invalid date .*`),
 		regexp.MustCompile(`cannot parse .* as .*`),
 		regexp.MustCompile(`operator "in" not defined on .*`),
+		regexp.MustCompile(`cannot sum bool`),
 	}
 
 	env := NewEnv()

From c7038e8ff272f38d9d720dc87cb7e32c8ad1ee2c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 24 Nov 2023 16:50:09 +0100
Subject: [PATCH 178/506] Fix type checker for float arguments

Fixes #474
---
 checker/checker.go                  |   2 +-
 expr_test.go                        |  54 ++++++++++++++++++++++++++++
 test/fuzz/fuzz_corpus.txt           |   2 --
 test/fuzz/fuzz_expr_seed_corpus.zip | Bin 2827401 -> 2827397 bytes
 testdata/examples.txt               |   2 --
 5 files changed, 55 insertions(+), 5 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 8e536518c..0d10e0bf3 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -959,7 +959,7 @@ func (v *checker) checkArguments(name string, fn reflect.Type, method bool, argu
 			in = fn.In(i + fnInOffset)
 		}
 
-		if isFloat(in) {
+		if isFloat(in) && isInteger(t) {
 			traverseAndReplaceIntegerNodesWithFloatNodes(&arguments[i], in)
 			continue
 		}
diff --git a/expr_test.go b/expr_test.go
index 903336d10..638ae3b84 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2112,3 +2112,57 @@ func TestIssue462(t *testing.T) {
 	_, err := expr.Compile(`$env.unknown(int())`, expr.Env(env))
 	require.Error(t, err)
 }
+
+func TestIssue(t *testing.T) {
+	testCases := []struct {
+		code string
+		fail bool
+	}{
+		{
+			code: `func("invalid")`,
+			fail: true,
+		},
+		{
+			code: `func(true)`,
+			fail: true,
+		},
+		{
+			code: `func([])`,
+			fail: true,
+		},
+		{
+			code: `func({})`,
+			fail: true,
+		},
+		{
+			code: `func(1)`,
+			fail: false,
+		},
+		{
+			code: `func(1.5)`,
+			fail: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		ltc := tc
+		t.Run(ltc.code, func(t *testing.T) {
+			t.Parallel()
+			function := expr.Function("func", func(params ...any) (any, error) {
+				return true, nil
+			}, new(func(float64) bool))
+			_, err := expr.Compile(ltc.code, function)
+			if ltc.fail {
+				if err == nil {
+					t.Error("expected an error, but it was nil")
+					t.FailNow()
+				}
+			} else {
+				if err != nil {
+					t.Errorf("expected nil, but it was %v", err)
+					t.FailNow()
+				}
+			}
+		})
+	}
+}
diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
index 3d3491ad4..2bb8ab7fb 100644
--- a/test/fuzz/fuzz_corpus.txt
+++ b/test/fuzz/fuzz_corpus.txt
@@ -6680,7 +6680,6 @@ half(f32 ** f32)
 half(f32 ** f64)
 half(f32 + 0.5)
 half(f32 + 1)
-half(f32 + f32)
 half(f32 + f64)
 half(f32 + i)
 half(f32 + i32)
@@ -12213,7 +12212,6 @@ ok ? score : foo.String
 ok ? score : foo?.String
 ok ? score : greet
 ok ? score : half
-ok ? score : half("bar")
 ok ? score : i
 ok ? score : i32
 ok ? score : list
diff --git a/test/fuzz/fuzz_expr_seed_corpus.zip b/test/fuzz/fuzz_expr_seed_corpus.zip
index aef08934d397fd9ae4b11a9756151e45892a8366..0fd46ab3a7ed432a2219e2d07e064dd839d54010 100644
GIT binary patch
literal 2827397
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%0A;ROD?WLU~I&j+6
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%0Diy
zT!Gy*Fa7`Ta-tc_$Cg7Dp3okFl|F6*BrA9Jz^85KPXC37to`wGspluPMJjW9)RuGe
z-k+0l)@?t1s@{o^EFT+AZ>{nc^@4SvN|ulQ&Qpui&jR;DNS2R1Pj9?UBaa~@%g3R2
zhODQ@vWn*H^<P`sv3xw6(&Qtp_(X(c^<}e;BTCT7a|p@u@rrXR6Z))Cu`UE>`IvU&
z`abP_4W*C60Ldz{w8e^obnYXF$ntSe?;^cuq`sM)oA>)x=DlWaq*o13gk<@6X<Nu^
zx-AbOq=1ibfzl$+xsbF?NLb}URI(lf7w{2~cAh~lG;%OPvV6Qcd_i^k3gsV!Wck=;
z*83=W)u?C=!C5|T3jW+&+v&=&oQ#mHRv$m<gUajw5)qQ+W8~Sao!YHO>0|Z!a&Q*0
z!M&GZTB0(yFCwyhES4Emg+^XNNY;6^`=iXUv^>=sKyH?guQR{xrmuM>A*6thaDigb
zZ|p)k_)UZq@DY&qmT3#=V_Thu5S-=Xn6M9Tr2m2Rr=0Pb2r1wrtQxOoeVin%8oGB%
zt|KJN$2li&sk|Gkb|VPR^0AFUw=DX`@-&2G*;B6j;nmt1SNfPNBY7{MD)w>Cae8)4
z8*6hr@P6M)zod)GcM_%`B+Eyiq)O{(AFm@M%g4ZR_g~Vt8S6BG;4B}HcowNkZxcZX
z$@1}d)tjT~;Lj0~<>T>vrEAdN3TxgJf(!TvtHy}Rag(%dsZ=}+Az425YiU}FMm|AE
zmX9sgh996?-NpifvwXaFV5sJW&;LG~uk>*NAX%M0bNlr?dcyA`B5Qvfv&u~6bDk!a
za&F%5TlLI0&ZLJj5FuGUetNv?gtWp-f65-Zi;yfIJ$ILgq;F(3wSwR*AD`UyTSVU}
z2}eklk2!fgw$aFE2+8ts>J<}D8tGsS!C5|5KiW#4-prODB+JJUgD$tAt9*r!EFar=
z9I3BeHIzQKvXO(c+A`nkqBULQGDKwg_^tMso;30mLb6tksRv>-Z~3FXBh<<ka<hVa
z-8BlN6^}$nmXF;N$7|kVL{*uIkSrffHvT$BBW;^OaF&m)7T(%RcX}v73it@;)e0XY
zJ4uVW?s+u>Az3~apY8IHKB(K<L2#Cjr|axc`H9!12+8vCOzMlOw2xVUWc5(dw+#!^
zxgG80+`Qkny3p!UckPEV%AIE!Lb7~Z{d#k28kvQVEFT*hO$w!vjt&r<HI~!Pmi<X1
zBM_41<BOcGC+M{;6CnkB1bL>Xy1UiZ$YZAYQ%;Y)BLo-l5zecY8LJCv+fs>)Lr9j7
zd%rZTPTv&#ijXWH-_Kunm_7=2ZVtg&K3<wr$3%-%?vF8m6qs<Boh|ETJd}vKkEwh?
zMArV8z0WF!R@}LToSXOiR_B(U?oQ9nW`tz<==keu1-i<w2+8uXX5}Maq>+{Wlx^wK
z5`qg%4|ICUr0tjK&1^eD3it>}k3T>2Xk@`wP$kR99la~xrN^>ALb7~(;JPx5{&3<T
zLb7~3-uTrXy2?VD#s1$9dK_$6KHkV*m86|<rH}mq$(o%d+v3;L3-Dn?WcfJZhL_6A
z#7nl3bKA1^$4w1iMr+q0Wv358NS2RjuMQrhgC9dkmXAft9&bipKbC0=!C5{Is~I(v
zmS;RdvS$3p3+ImX+I9&cSw0%2Kj}<&dgXQyoaN(f^CkiGy|IZ1Dc~b)J*B6m*h(`l
zRjO>FWQ1h-n6SS85beQ0>7!YDIXG)5SIkW_q-SRaA`18jxp!>x43*^3&3zpqSw7k|
z8a0M)%Q_t(H_OMnb&46%pLfhcNC6)qxJ{W=`z560q;kR^ASBC2=jbt6bf?>Ngy1Y6
zoz}Z9rN?qHLb94D`=2{~v~8&j{sJLcKA!4h;!YzSoglb?k8m(pUf|aodQo43kSrhj
zTON{MZL0J!3y`ebRd#2oY-aYI<lMZUAb5E=<P$xVOAwOfV{?lpo9Ll@j*u)LFDE};
zMz>}2&JbL{N0{*YRUY1<t6YJQEFW8sFF&6i%eM&0@-hBqvJ+ipn=TNX<zv-%Ej;M4
zj6z6OUlvUnREn<h6GF0lTwrQEk*=~+R|wAXu|g{w`GX#%kFkJc6`5J`SzEfuTtpPu
zAE7Nx*RCE$Z@JyO$+>yY=RA1lbB(^5h(Sn}kEh4Ay+v2~5g}PV1~o5rjIOe+GX!V(
z_-a<|g>;pX2+8tsL6w6KY2-76Wcj%9qMi%Ai`#1M?EQCTX3z5R;QS4pX&=K8lGW;=
z-^R6}k<Ss5<>T@LBim}1OQny^UF6^_;`zcJH|ZjmAfkYeaBS;v@okc%xbCqn3n5wi
z<JlU%73eBk_ki3iA9p^yK7jrtVHHBMd@NVn@t$^el*hK$2+8vC?cQZC=}vFu3c*=E
zx~%a!OJ6vzLP(a62Tn9QOb365kSrf97F1RF#JO!x2+s2HMNEai&mKzQmD95fAzAjg
zxm4SwZ6c+Que3-Tk%wtOp1=p`f1kjUx?NeMW3T^mYlti#SFY`0A<d31atT7ReDr#{
zNafLr=Ljj_BLpvUe%NSfW^}8xb%Wq6AKmU0v!qvzMF=V2BUE|r&CtIGb=_<6OoSBh
z5s*_eDi)Ed)I~bDLvWUl7Z&HqUvp44(NctD`54|f>L@*yFA$RD<FQT+>(UP<wdf7O
zSw5cIK1{weQ~J0FkgQJsmQkWSy;?p&L;)Y+ygFj#bd^W&Y(3=MyytTa0`Ga!vlEPv
z0zN{OB|p7Vd5kj+Az40NT>A1GefDqC2Z9Uu2vu5-y|$X3o)Cl-@DY$Pmp6yf$TWmx
z`FQhAyaSE2?hC<LKK2^pe2o4qcOgQue2iY<{*`W`G=yaNxMxkuT<yU?>7z|QIXJ5=
zlMbCOKo4aoBC>q!aQ4U)`p#uKLb6tkGtocy(zD~}3AtIpLj!02razpBKuDI4`nhF0
z6xQrK(w}mhc!!WIA7d-H-lWIUu0I54`52O4YKdg0^rx(HIYP30%<bOYUVCg)BA+89
z%g0CNKELTI?FK+_mXAsH2^Msfp$N(Hac9F1hqQgE^zjiOSv_>c^~5;(0;P$UoSXN2
z&H$@B3uwiI5t8L&_6zp}y2{50$?`FBzPmfUnb~+laMoD9Zrk%U{jIQYgk<^nJ*320
z`o#z@5t8NOk2XEx>EK-kLU5Lkqn2Fvpx@B45g}PV+Lb<}@;grj20@i9AE(xBkxuWA
zeGro6qf=+oH0`}HrH^|6$(rzDt_6eX*~v#l*8b?UGpvfXNabqTcd$H^yytTUR5`Bl
z$j=UhWck?eX0<MKl?8`Dl`J36b*$BmUNzhik~KXEYmDyEYuhe_Wcg?u+|RV8W^a`K
zl+#miC<JHu7&I|_w{(Fj{V9>75R&Di_2C00=;O<Igk<>`uJ@@0Jw3ICL2#Cj#X{$8
zruWC`fMm^1T+{0{=_0QqBFo2nV-4HWxBX3r%ei^a=k$MEaXQ_WlM#~T<A$7_n!CMH
z|NMUsT}4Qik7ZB1Zc8g(V*~_e`Pk!m&E53$Ohic5jE7q8Z%jY=av336J{k-TOrTHI
z<|83E%g3v4kE%S*7=(~49|O|;%hA*G7$I3ch7`UXrEMbR{@7%c9Go?j7i;<cruWBr
zh{*Es&p#hkK5$M&NY;6^!G^%U_XMTmhH?S691XcyKGu0|UtW7Du0)0+B+JLQvCUOp
z&X|UfEFV*C(mK*U+KhqVEFbFx+YY3UZHp0-)kF<{tZhjnpCKg6#|A+kZ0Wvq91Fo&
zKF*AJA4DUUBP7d57rR9XTE&$<z5^sHx1EQ3HeF=PadK|n^EpR0wO4r{YZXGWd~|Q+
zY(`i45g}PVE{rVoj^4#PkB8taA3HbbJwQ7<O2t<rB+JLTJuZ}@k#7)^<zo%UW`${F
z3m*v1^3iW#ygQAIKuCeUgimFnS~j~c&A9Gwp*%%MmX94{hL5CI4TlL3oaJLm&0A*l
z{<sv7tRfSKHO!&6iD!t&+8<X;4jDinF6}4Exp~j$OpI#hO;;I#kSrfd?rXP_Mm|GG
z0Ux1<N_)P4F5S=3y^ON=h2Sh7-E($pzAH<es+S=o%g3g{J^#>mF0&9)z()waw8Nss
zQkA;L7rRLioaLkW<cLVAiFA>R5R%pE9m~}`OZ%9CkSrfPmd`iTPLFbbwD*&PvxqMH
z?k}c`T!e@$AMbe73Z&0inFz_+AKN`Uvxn{>$H|bJ<zv$&A5;`ygpe#B4=x_RKvG<{
zhn^xN%g1hi>My2WK4m)vg0p;#&Ofr4UM`m*q=1jog#7#CaF<V3>PUam{t6)ld<10W
zyScBlovu7<*iD7tEFX(C{kn%<ffpep%bt$MUi_VL39Iz+sf@G~kO!8wm*y*{NJkCn
zgBfLRn`zqImb~Y4w(d%+APuEdq!Jm7kSrfNFFxTx4`nJsvV5Gr%4#dEcvF7}F5n~d
zP@kz4oaid&A|%Vl-;N$C-=V#SkSrf7=4|>(2X8bTg0p;_IM?*=kEiM`L;(oN^6_qo
zUHbG`-bF~3kK>01yrZ|C`ZFLn%f}ifzkIbHX)1l33rJR{yO-MLKo@x%5d{>7wluq4
zbw9lT*Pkip<~^Si<~t>hM$SP<mX9TVn=PY}_YjihV@~~Qo9L_DhO;0z%g2d>+N!+B
zD+nQ3K9*@;)r}7R2q9TM-VE6I4~?`8fZ!}2i}v58^1Iz32+8u%z_gIc@0F(^B+JLw
zRm0?q9;J`gv*qBdw!B=tXCwME><~m``8d?HYD@aOnt_n4Rby=b!vkrg!yL%X3U0JM
zz>@BvNQ7khcx!p`Bf83$2+8vC$f%a5=_*^#h2Sh7E0`pye1x(RAz41UxdyeRgTF^e
zmX8j(Wp~nj*>N5O7w{2|f`*S8g-Xk%gjJr~Vi1z$<LFfnw`zBBrH|hM$?Bm~?e6xW
zhthezoSXN2PJGa`4RjA}Mo5;A2g{Dgp{x9fkSrg=o-X@EBYOoxaMoB_9(c5y?x7tB
z$?`GYbXYo#EF1(?3it?ZdH2!A`_hR>3a@NSZ-iv|n6LNBp04sRLb80^)$n})Jw0U>
zKyU#c;oN38$f&mVaH$MF5+PYW8Vz)-phYTuJPt_Kgr{^UX-8j8lnRz}+pzY>C99I6
zv_&d&dm$vt$IKk>L>jpdA$dM7AKj4-UMK{DvwVCQyeo;W(j6gL({t!q%NQCNkB}@M
zzm$3T_mu<ER-v4pp9snFaY=1E6G?dKPl@am3S%kYBdi*Orsh?YeANBY-fo0s`MAO4
z&NO<}D6$Z$Wcg?xo?40C9|r<bV0K{9c=7SF6MX~kAR@AStkO4Kb30L*ng5@ivSD&=
z-t#$`WnW&Qx7=X}$@1~l4<C6bl|6JEAz41|du&mSz7{XD2!gYGjJe@mg#Ki21VReT
zICT2PUtj<3Ji0y}MM##9gFa51MPE3V)qD=}_xs2;mbL;uLSJTYOX^JrAB~VKADgCM
zR{84v34~<%c(lMmQ`*Oh;c{?+p@i8P=W_9t)akmjGYSz|KE_Sh5=0+0P9vni{s>k6
zm@)P5D_wQZSVj?$Tfj#^Iy<>mlH}11J`N!Td<5jSyIm_vW2sx^d4y#7xIFHtF+G-5
zmOyX;AEDE`J^%HPmd6(%1)2zu&vK&&&<~qlMM##9UMG%iqJx_+h2Sh7Gi^)$pq~Jl
zi;yfIA06w_h4wKSkgVLh;#RACC}SEa=jJ`1vplnq%AL#U2r1wrO!!T=Z6Wmjn1ql5
zJ_2&5n{{t`GpoA{f(!Tv$Y1LZ*QBeQg^(;CucWo~qPL0L2+8s>BG2Zhv1Zkf{*(s;
z)8!Ccz(-h!t|lC;F9nyzQ;7^gNLF9Y@+|B_k7XJ{vV7cpbXRG5EUi~SaF&lJa$=8b
zFDI1Oj|%`PP$UdxNe81#5>a=XxQ~de{jqJ&)^+Knt-(q;H}CnJwQY;3d@XlALb819
zIOB0S+Q$b7$@1~}&Y>CF)l%7(O;<s1mXGg7E;&P28HA85AIDituT59^2q6W0goS8U
zJDZhsl@^-Et^Yf(^4_0gap%t#`eH8xAq83;svL1YuLtd8212rYoL1GOpLQ&jK3cDq
zgR_W{9S-iGiwr?TmXE_H7;K`?1rHIDwLk8#Y`c-Jvi=&#&GIqPJvp03&O}I-k5=}F
zzH4Vk>EjKAWcj$JUFltPr`KK!!C5}eI=^W%jhv2<EFZ^yDO!$Rfs+xEwLi}AUO9~3
zAI+m7ILpV%@1DJ;r)M@ovh4Y`%5RJosr2!VjI?6Olf5oGRZCR%P`!29+*Tsb=fFBN
z{-)br8aWFg1$=~E{IubK6VhEL=}WK5DsLeq%f}HDqBH3#o2-Z6EFUfIFWW-*P#{9G
ze5~{`#gx7`_7EXiKAvk~{++I}@dgOa^6_MJ$Ojr3h>$EFSH=}l`7Y^0gk<^XvQTde
zeU)n&1HoB79$Z}J0exOw0!V>Q2YJGJm$sGuCH*NoJp&P0if^yny$8JjTgA$`dC%v}
z>i)1Gja-P3EFWK5tQ$@Te~OR-KEkT8J=4Fhq_|Y6ax5+5AUMm%R=qZ4(>qTvLb7~(
zS24RkJ(lSR$?|c=?~|u#r0qrs&hoKY!RK*w@Wlwp^3lIQF_q`#o+Bj7$F1QLA88kL
z<^I@wlN_AYmhMfOC(%Q>1QA(2?tZlMH~n;R7DBRC4ad%b?(_m|yBTt`g11?n;ip~N
zl=3V>NC6+w+IH_pIqmEyk?9D@^6_y;pYimnVZ8-{vwXDA@Tp99dJsYi_y`Npyroq&
z&y7<H(PM;U`Plz`nGN(<T5N^jEFUe)f2&M4(E@~I`FQozIhEf>egsHX4_zADXeB*6
zP2=U<yytWFo8-5odng1USw2qa+NB=7YCJ$lmXG6IeSXr&rrRJmYb>)$ub4<rcrZe;
ze2jM3nMorbBP7em8asEjrf1x0I|LW-5f-8@XMXgN?3DhL3sD$CvV44EJ1dtC{sJLc
zKHkg=-$5gr?||SeALl#z*3n*0DEG%mK(Z!$KxV^6^lgpjh{)O>*K}{>P2bOHwo}f{
zdw<SO-=SCNDuWS{<>SS*E{*6aA0Q;l$EAfM&(c+z?}Fg0>G?faFOo*iKuDI4p4b0$
zp?$oLkODr!{&=`R*dD3VrS(neqv>u4&hoLT{e>p9JTnlI<ztv>nPhqePDV(Uk7m`L
z$7`oY>0`Y;a&Xq{IDenqnm!l!BO=Sk$2Q~s{+^ER?A$;|*8bS2-@1YHXV|8DAvep%
zs0J2u=->ee$?`EgYWNwthi)Sz%g09{MO8lNG2aKlSu^fc&8;_mP@j#E0zSh2*lx~d
zD|#$%AtcMk)7?$i(nz!Y5S-;>xoZhKXyi<UWck=+O$}>$e@q4>YbaBfdwSAE);S>O
zZpQL4r`v(z^o08(B+JKHE}vDt!gUQHSw61caJ`RqD3xn^t%DGp<zwgBPv6oz&lH4Y
z`51M?{TY4szk!e}A17U&zm47|Y8-;#tS0)s_0Ti=ygCIT1$=}p_v-hM!}OM$jF2oJ
zbL*E5po5zohTtq8_ZW8990;UC!T*0BIRKCXxnXJBS2y-6-9yQU$nx>$or?$Q9x^{7
z=e85@5oYI0J-f%!s-e5(PDe-q9|7rbHr$d%-b6^2kG~sTD@^Z?b^d|i0zN{O556z-
zl#tRCDOZi@2+8u%Gj5m4ZN?;oWchg3bd*DNO@-2*vP!d~5S-PQy{;P#mxe+5QzF9<
zlI7#-&5ng=A73CO%f}|ex?QBtt1XVn!C6K62Az38-wX{$M3#>u2VHWdx7^1FDc~cl
z8i|n+hv_ZX@;Kxc@DY$pi@tNDkwFN_^3le+=43kfeS{S75vuIx5g|XYtZd6hCm=Y>
z$6n_b)Yq=*O5{9*Wchd^@}E=mLUa!ySw0qiS@-X9DUGMH%7!N)IIGpqZnZl>?-O$o
zlI3H*fs5u`DpmOZ`{OM@vWS(^%K6YeWO_=@?I7SItm)+rel(_!8q*O{z(+t%z14TP
zw6y7N6G;fk@^RPst#9esF*^;xSw5a|cCerq;AsfS@^MAn9us<cZX%?Bk1&>*VJ}uo
zNZqqWodgKZ@^MRIEtRWWe}rWD_#mf730m=+2+8u%`*KJjtvpJ_P0v7ZmOXRkSJ!<1
zmh#bGM)E$KC}%$TuigJrrRQJt^a^PHHqX0;hyp&sn*P3QkAI};m;RKwYo68Swzd%P
z5s=}Q_U-7|nSqcj9|NAOzfIpFN=8VQk8iuwj-!$F&p~jOkBK8{%%_p_5mLZM7|T@w
z)vamdBZOr6m|A?S8NCqMoQL2nAIl&0UO_KJix86K<Bj{JRDL1iDMGS*v_E|&QCp?*
z{;I<TIXJ7+&zvfu^5jc6A`18j3-GJN1QTf^lO|p1<8y>$RXHW+&<X81U5RXQ5puJ9
z{88hbDgAjz1VXZW{8(hX0bOM}Lb80^awWopuF~QX1ZVkp%+SDtu5vCyvV5%Aqh+AB
zEtS)A8zBXJgeGdexYgeeCv;Cl^%5aC%g4(#r`k$5UF2+pWcg?~&!&a;qDSdt3Lsf+
z>9gME8@;rdUzT(89*MON@3WUi&Ou0)kFL(AThquCgk%MO;y-94-9wG9Kya3iA<g<}
z?)LtBdQrCJe1v5An3WKpMt{vA1tD2JR@t>JP1{4tDlM);aF&lL50V?x$Cp5a6z~yt
zai=pu&*<rSh>$EF13P^@O8eO48U$zgxT5;r``Rj%J_ZAl)kDpqKDVHUG8GX8_D2}X
zb(Pksye!q?x}4jZ<>SlZtIN<sIS(OOK0fpJFR2|$Wm`T(NY+>mGWzqFUNxHBfZ!}2
z3yk}&f?R-*EFXXAx9veI{um)yK7O85TIChX&2B<)mX96M9k0?e9)gf8A3M)UUQJKW
z6NF^>STXX~b8QnTeQcH_2WL(Arylnf&_#wJqJWQZ)L7r3!{49nmaxiB&p=3)kMrDJ
z9@B3XX_gGRSw0qXEbx&Iz8oQ0KK^vRGKs!d{RSaf)3c=D@GaU2SB|B_EeOu?@o00;
z=ky93fsia8C#OACc{$^Agk<^H>Cm=Tba2Pp5S-<s)vC(=G;#?-vV5%mC)!(k)=>KR
z9FVNp`8xi~QhFU~c1O-_E8rvSj}CUpwsh_Ygk<@+zqYH&JGGx7B+JLE#qw2N3+!+g
zf(!Tv3(>3B;qRsMs_sG*hL9{Dv);8FM6Vj@2+5l9_#r+jFM_tc2f+n=gy05+C$E;8
zNcu0zRU;T7Sw03-OrNY093cgKgeu>)Pg*SXrSA0Dra*9(j~&DEduv-=>0=lmSwq?V
z%yUcW>Rz|VbVOwNm~p^U<#1_nU(Vf(<zvec?G|ctD<?b@Az40NPOF_vZxd+<Dc~b4
zL~Ab98cZXtA3$)HkI6CVJ?Kl)g$T*=@$-wTD&Lh!Lr8%pg5b`f?p0NSKZM{cAI+xB
ze^1|aT8NMWK0=i{b9NP??~Oe|NS2Sbqb+Z1R}H0)4O8XdtlV#w+w0M}=OH4?$B?hv
zU1{VUgk<@+e_sQYUvaMc2y(N0d|W#-m%i;EfRF+{!U8;C(bQ$qzoe73a@9ydNS2Q&
zhWqEy2X)KG5S-=X!*v~<s%k2f{*+ZlASBDjQ7fY#(#z#Xgk<&Q(~<hMw4JW3vO^jK
zXZcvB(Ct<9j7K9R%f~G<wvUo#T>4Y`m<vc&k>$)1OVd~PF6nY^dzO!lYF$%#o60tX
zWcm1V&Ri?{RGp8IEFV){N57!IE#Bt|1Q+lT7U1}Q9z@Wa*<pla`B-A`5odbmDgG3y
zWce5sUVA@1mID!z<)hv6n5y*emH&f~EFZUzOm8TStn{b!(I^9gvs&Hg=d@H>@sSA0
z^0DN~kMg$_l|G&ZB#W3ay0ywD35J<+ZjtA6pe@TK`<16Bd>lfue0;y#-JD*4FCZk#
z#~;b96X_nR@(hBre7sPw$4t71{1KAnV}~{#&*&byf{-j9y@vK{tX<QUoo@0Rg0p-q
zStMiyUFA%KWcj%0&~OX--q>w~Wcm0qpyVvNiE6!o-~#qYqo=QD8tmW4cf=|eX}Ofb
zD}9_QBY7_qFEM9bF}lcWh{)O>i&QTZNuRMyvb4Evc+cnLPdnvDcX|Lq3it>^IseO2
zJMB;^+wvwtvV8oww1CPFewx07;4B{<^tP&e8Dl0wvV45F@{bX{T;4`VmXFKIH>yKV
zPlHzwoaJMUb+Ibnx0;ENEFbqg?)Qy8Ya}D2fRC{CgzoF)r9~=zG<z)vXYD-U?ITn!
zqh=x^%f~vilQd5eOUI1=KWf}XNLH1VMrF3q=2psM{swXj_y|LJDgVGZ8aW#wSw8;w
zc|zq8^}7hk^6}h<4i<E$*Lw@WSw0ReHDrnQ9=&ob{SlJo;|2$_c66235R&Dit#N_-
zbd|>MAUMlMC%rB5;ZhlV0z$HU9G@GoO}n-!eM|%-t1X?Mr(UGnvWDi~{lBlyv=Mne
z2X>x+vbS1E8@N=cGWTSJWcj#bSIeICRqi!}WCbrUBj6x?Uak89g0p-alfC%>eMuUG
zkSrg!_qp3bJK@T)%tT0*kDEGfSNT}n@goFh`Dh+peiz+DkqF81acS_1(e%ximk7!7
zvCZjeM)dTw`2@iQe1ul7cz?*>Z`kRcS2qBX)kAqfDP8HI%t1uf{y6N)B4_$)qRVGF
zH}CnJZ+(-a=u>qpLb7~pUm|oNUF8>qWQ}EKkHDJrjb-O-2+s0x#PrsCX&*NrB+JLe
z#ha|7kzWy#<)dxS<F%`4R$u8)xoWuNKya3ibH*8sr{&p)kl<tP#X-ZT_?OfxQ22}H
z>kx${Wn8-zC|IKqoQNiSlo?$`^WUXEWt9fGP$l>%fPA;YZK~ED<^JdcNY;ecwJxvn
z(&qDs2tKM735&)a+r&Cjk-Gb%;TJhKdVh{85{9xv$CR>k4~<1g@KF^BRUS;)@P)4O
zJVJtxsz|7^q2r+Sbd^=ULU5QK0p!}?kN~=ed=V0S6hO8!&udNZJhu=Md=x;|zw{`H
z4&LA!1P31lkXiP_AJHEc&PPa=k5*20rL^)WeY}m3EFZT=<QQoeb)}Ey-{s&iJ2`5L
z2DD{Rt+Za!%@^H8V>TiR_y}!z_;}g|dTD!vkZ@iVn4KC<Pdm{&kHZhhE#M<mIp4dd
z%CC<tLP(a6cDsXa((=4ONS2SDLyXJQ_r^N@gy1mas$&T=UZsh{GiiEsXM7_<vV8Qb
z<6DWI9=$xMlI3H&x?}Fq^7KMTmXB_)3cJ&*#x{gx`MB<Pt);Y&dcWl0Fq8s5j#~e9
z0KH9kAR^1hCk5R{(?hunAz40JIDYk@*YtwFAvep%oGFtE(MRC^2+8uX<#l}z?d&KQ
z;C%?m@-eSO+F-iMVt*jGfRC^cjUH{M@@2&V2nkK3syHBn{10Z(!4D!N%SX#G^Ka0|
z68R9E<>Sbo<-XFlhz27h%SWGRr#{;0QSOh2013HOeT1PL*|Kt;^e^d8*+cqz2HN{M
z==ZGzX6JXQ%kAmh{ScDn<I>Un<lmuHR=EoySw1#@Gh-ngJRc!hKJGN$S&a_vS^&n9
z<>UE>)}84!eG@_o_z3&sjN^%s5>i^<lw+BPkSrgM3<yy9{YSTg5FGkapo#jMwtlR#
zs3RoH$3Hj13esa)P_r`sck9xQ<>Oc9HpR3vuJq9pkWi$6kByDnyrmD9yAYAJKOQd}
z+MXWD5{2d5==ZHuX9s#{#JUGz5>i?*l|3{FAz41QSZ$I_A1;p|B+JLM&ZnwsS4(A;
zMnxbv%g5C6vsHc-Z!AIz_y{ZTC10Z-^jYH^Lb7~x`rYv=jjUD_g0p=5<&}GkJ_1ih
zNN9D{CW7FH_g!s3`*;Z<Sw3Eymw8P)<4PZEXg<~dPjMg$_&BpvIhAitOhQDKj|F`v
zmZEcCMo8BF7->KJH9b2f`jDIDW5kBZNpufQLP(yEXC~^?3(+-%Wck=tfBHrmS*th%
zXZct;>+(E0_%wuM`FMVQ%RBVpG8rLRKBku+bCupF>Xm@tEFb4u_*&9^xd0)-9s$KS
z+nxXWUMDHM(#JFz$@_AYN4X+d^nEOA&DVARHQW~czLh|c_QnI}(6bYWkSrggcMW_?
zw`D3qvV3f-KY2Zkv?v9^Sw8yJ-*TSrp<sk$`RI3PbP>AB=LpI2aYy&440>&IEDga~
zKKhttU8bvCjF2oJeeyO2((+^?B+JJEDfanvm5v4woaLi`+|>{C{<sv7(CGsEqhn9w
zz4S*%&k>QeKPH+N-A_-rQyDoo`h6<_#ZxSoEu?2>H9`vb2uI)v{hl3=Rt@Pf1LfiJ
z6GF0loV_>l1HBM+Dht6`KHe_%=MRnCfRHR7-`W_>ppjn?lI5e(;u()<q_gG+hW=aB
zEd_jp>B(z2Xsm>kW?eZwn-G%a<I*M<`q0bePlROoc+S3lC)&rp<>lbema0BN?m#`W
z?}nPpQlZM+yAYA(qqkW-mD`N^6`)91H3WPtGpzayTJeDh3Bd)B*J8&_rw<1E5t8NO
z%4HXl=qd|Tgy1Y6zkll;LnGY~lI3I6G=q|K@GS_*^6~uq_$a!{F9<2%BV6o#UEj7b
zt#~Ix7)t>kq18+5J-a~KA0@1^)i)p{%g1(yW=y7i%mpO$kbsYEUmgjNN|rw4QWn|S
zNY0I3A*tHwkUQeA*JM)-uC5Mp6GF0l?A_5PO`BU;r9maAlI3GVyS6GX@*0YeFqW#p
zp@%jvIQ^Nf@;E}We5_dF;3B#$%T$KoEFXV{r`l@o2`a~O1VXZW%*vXmxg(;dxi9_y
zO>_()Sw4EFOsPgA4XQwJ0Uu#{mRTfyrIAAslI7#Cm8pi>=}}%k9t9*!xT=p(WbbLG
zJm?|~H1`VsJ8Gb>j0m*l#^+xS(#W9*$?`FO{@4)u`PHKc$@1|=ZpTaX>7~4;5wyWs
zJ~j^s&Z9ehB0|FS2#n>CcQ1nJYo7B6$?~yQOp{ppasMjD5S-;>{ipLZuWprG{C^+E
zBP7emYY$Q@(!tLnB+JJ^%{JDg@2FR*4#8PIHn&~1QQPWDAEyBlW=FusjhBo@NOnqp
z%GL53BC^h_mhN2|Y8MS9(zu44+m_{H(x#ARbd`Px$?~zU<<=7PCFuo(6z~xa2JyF+
zt(X3#d-gZ33Bg%Dt{Pda0X>$}5E5owK=J35sx74N7~DiimXE1+%|6lcSeQU?mXCW%
zB^{%uCm11FKCXy9=}(VkIzqC1)bBppO^a0eXj@AT4nry6qu#7>Yw7QOE<!|>kN3w1
zOw%qJN*_}ZlI7!^ORGoF6W+8o<YxJp@u1X1y2=FzDc~cVHF8s?w4zsyRD@*tcy-<(
zm9}hH2ZFPFH2V=fLEA&h=?O$gXd(f{w{BS9fkvhxB+JL6bI(_m);8%+S*4{Z1ZVlU
z=HPQ5dU_TkB+JK)LmO^s`%>v+8XzIJs*kXyw|1IhDiL+>V_DUebMv0hnK0aTueM0#
zP=+ET%g1GD{S0ViIzqC1JmK8$9gVaxgWxP5opNov)5tJ{Wcj$o!(k<T5`2n~EFV*D
zMX3C2w@p0=&hl}0{Z*PLvZ?cG7(zl{3Md|OHGDfgmgxw|^0CwMMpI~{jppSO|6QT*
zp3nJX{c*VV3PtH-7$BiYRUctZ5Bj~qUrSWV^B56X`{R`!iv#F&sA+vUx5)E3P^F(w
z%6huWxd_Sfv2!)kl{E4WLb80UJNxiO8fn%5g0p<I89rE#?xE=jDc~clz;Q8K-%G2n
z^h|(q#*+||<>UD2#(#0T$a)PSxPXsP<(nd7uSi?2?mjUWA)(a;6fb=*;VM0r_Ysn{
zKUUZ~{i61erS!3JBRMz_1$?{}cK0J)<UB-V`Pf`9G@Cy9-$zJ+{Sjto;P+Bvr8~g7
zS7uEcLv8^d0l9ij&@y_$7b7Ig$Mqd<Rid|vX9&siG52h}+Vu3;HG$v)KEm4O{p`YR
z8X1m|EFV9(em_YgpCP1xk5FZa%^&8`W9iTog0p-~|30BQU1c~zf;|F?FR#-;zGbWQ
z@tKU|{h0B&Z(%C;=<O`DxtsBx&&lhvFP6TVSd5SYKEmwGeDrKNjeLfX0zLw=mi45?
z^xZZ`O9;;Lad0Q&Q2JxIwFt@bv8a2WVEV@LJA@SQ5f&n^t~<NX3z3uNN5}s?wl%Y0
z`M7G8y$}7ah4l!@^08Fy@CWo*{z6EWkN=!mGM?TiT&y8D%g2oH`0-lBl|F6-By_s!
z{s^<P%70WL`gwpnL}cxcznw?K(w*MNM$XN9KF4LiiN*9#{)3P#AA`qkiK9OjFJlW;
zvV6>}b*wVIrVm6&mXCIQ<|NZ?c@QB5e1wH)p8ri>`uWu&%^*0-$H;2K`qD^mgk<@6
zBm0Ms%8Vl<%g3)FB}dT6GIkK0<>Q=~YlrFc>PSFBTdMj9vy<Rsr1B$NClHb4qo>t}
zxpWUzu$OaN!Kxu}E^v$vQhCS3aD;^50>~Ts*Qe97a|$5^e1x?vy7Jyy(rPJTl~-nl
z4iH?xM?h9gi;a{%oY4Ix@UaNV@-ZkTXDR)`>kWit`M7P_mDBWCHgtsGEFY)N9QcDi
z5d|V7%g1V2p`~eLDnhb++}3IAT<r?1+#fBQ%fX?C1bp0+draj$&_RgE@^R}TqxN*}
zM+nLCv3%RcIW*F$1>|P=_%k@H5WS`^L`WD*0maAcAJUJmG7}*Me1zrF__5<4?E<V+
z+@U1|XZg5eL}8VW;UW-{<zv&kx%qVP7YNDn@%FgY-ZZj>=681fJ5^h=d<?$t{ggft
zEk{U}j}6zp`g;>Xs#NLYGeE+G3-}mttY-~+X>({T=jJ`1Q}))BHuO+NA|%VlXXU%9
ze4*zRLJIf@JI}Dg-@8e{bsrRL-3EfQeC%wwL**?$Q3wgsBcOP)P0A(dazgr3`uGtc
zSw8xvR}Y}~$8K#QILpU!8S{E;w+UsH+YyrGqgg_X<~?%MM<~A$lI7zh&ksfD+uuFg
zL2#CjHCwLVO<zB51|-amfR70a0yWpi)T4(#5RtV%27U6??Ee(frM;Y+_k7MD^J*`&
zxs?;X2_Xf1gq`Pci8B4@+4+HxEFW`R3_8$NI(LBJEFZggFPcSPi*H0om~jEczhB8z
z`B=PQN2rqJW7<RgLG+^ThL8e2!g5*dPvTB#ETx5AIpaGKlI3IXCcVed(^J3+g0p-~
z`Z!pA6ivB5_5maerGSrjI+w7ZH?!S{$ntS{)$b~Y%fgy3r~G%+K)-J#&_hKx%o|B7
z-X9@ZK1R8giKBaHA40Nx{B|MOnjTC2&JdjC<H}urDv$gOL`as89cT94tr8p|p@{^h
zC*O0~DtdbKyFhROA7Qz)=(J-geK7DsNS2RrH(D2^gC9dkmXANz9o(&*aix#ty2`;J
zw}6l9zI|}j5|!)FNJM1$xbMMjKN@)&AzA0uLW{b_(NFamc7xn3A3M1^H=|d}VF=0c
zF`-k>G4z&u93fdgUV4;0nXa<5GX!V(xaZ+Km1lv6A|%Vlpp18i=_(H)B=n_#;@%Ys
zoTZznM0W_z^6_axyZ3aJgAtPDV~K=bv$PA5(#L-Q2}KI{*l5XzwRG;1E^==4`&I%&
zdH!Tsl}FTvAf$kgaC$k@W38c-TdGvKY8*sJmXB{H4!^A(N+nXi2LxyNShmd>m4mt$
zLb80!_UrwPUegaCB+JK{kJD7%6jj0%g0p<wZTP^IzBe`qAz41=rItQH_vJB!gjN^m
z%fQrdm8TZU_JrUpAB`g1{j@8v(#H{i1fqbC(`NMPL@ydg5s|e&2Il;EMPKt6^pbNs
z2>1x6m-|^+vGj!dASBDj9`#Ea(_eE)L`as8RvYRTqwkc|cZ1+89}U9`rPH6Zhae=&
z$5l^_o#<D(W+5cYM~7k?KGIdTcZc9CA8nm&F4AMU5g}PV&PjXaOC$AqLzQ5Ufa2#o
zdiK?>8cH9%Wh8p|TfoP&?j=sqvvUX$Sw4DMMg<vbHZti?x$~6s(B`&7zi%awd(!1k
zZuC%2Mo0l4Vax58dZeJ#L(<BjtnxNO3it@f#LMgc{y>C;RU$3>KyU#c0l8+&y$=#j
z_s3J0Af$kgfLztOat&!Lb%TFENC6)K`Dg9?rqacp?!9W~z7U+{qu$_2w)CRD4Ix=R
z&VJXxTlySV_p@C6eo!ULN8<(QD$lQu10?J`0zM9!8gQ<Lrby{e*+XX#k>%s4GIdpc
z;<c`)oSXN2PFvq~rnHZ95K_QL*mC0?TYjjm2`&98gQp>+fRBLuV3m2BuF|PL1Q+lT
zkae8PkD!s85mLZMKyK-=Z7%)$$OQ*Ll>$BjGVA9;1G>tg2+8uX?1zj!wKP*B{VAvC
zEJCt;4BYx<EL~-NF9^=^ajS95aoUR><^C7~NN7s|A0KD-x<wx~9w8#j$H$$!kD!+}
zM{hYd@A;guyFOf|t6Yna5L{r(t(Ro-gFdhRKuDI49`9#NqdUF-KnTwA(WA@=N9nyM
zy6-+YiI6NGgKj=vL{E>o=Fx+HZ-3iav3$JPv&&QZW@sovvV7d%YlgmwCb;yc^zk`D
zvV1(fW?55u#=8xM;4B}_milO>;opz;ls@hTB=nGgj~m_`&7jY#1%}8)io8DuR?9&9
zW3}mLpuG_ic5zjC;6PMueZj@jQ0ngDM-fuMM?fB3zOIWj*>yC3$_cMJ6oSK8s#XcX
z+a?-Y)YIUkKP7S=Lb7~ZSoT~UdU`%0B+JJOjZ8MvYn$^h2+r~`rgD-uUFA-MWcj$#
zu8tvHrT%cJlI5e}iHT-3awI~sd>mMA{zBTvOMrw47x1y<spQG@(pGhZoSXN2j^Wiw
zV`=16gcR@*I{oVHxMuWG<2FJH_z1|Z-q}THq=n|A&i}Rv8<vmN52qEUgGV4FOpk!#
z)jEDYL|6F+Az40NFA%nlmZ$S52+s1ce7%i>=uY2)kSrf>Pc;vut1LVks$}`tN`FIp
zy2`-_$@0;sQJxQdKj#b}VRi(3Of4RwvOgM)k#nP0EDQ9|gbM4k>D+z@$?|dZ?UX+B
z?A%63mXFi6Ozuo0n~sIxEFVpRMxLaDFGfg~kFokTOK9X<goGIvn4USQj~dXyyK1h5
z{#%G_Sw60>v%rO}G9DpWK92oR)_`8yijIdWSw2o#bD$iJ9D<N6AA^dFiPnBPp**ji
z1|$rnfR6!L)&1xqEBMH{(N`)3COk2=-7R{;Cm<xt$A|Zy-lUP&5t8NO`M_6JbPv^^
z0Kr*4wl8y{0F4YqNS2S~D<0iPBVQt<fRAuc-}qyeg@n|-W$QE%f<qIj&Nv|5xBodU
z-A&iMoY;bpEFX8q6gxr(*Y|}gSw5bxZm4qCX(U3je5~;~uN?jP<3&J1ZUG<TJlvnr
zSND}B$+^)-D5|pqC&5~&#Z-Q&W*S1WeC*~`;T%0X_YqRSN9ZBb=bMK~NGZJXVy~GW
z1ZVm9qG?D6y2_OZ$@1}u*?{WwLX?Y;0zSg@M1D3uL|55!G6Wa!5s>dJB7^8feIG(X
zUkWtQDVqx+^g+GU6sVHr<666l8|kqegODsAr!5-)fxdoB1SAwG;A89Ook!C}R+}p4
z<~^UYcxcZ*^z8T}B+JL6B}Q7)vvU_A1$=}a+V>{C1bs8qY8nJ*`8X{qbqoCg*K&kp
z`51k%Q*T<HZwSfqF?fHgPV@@w;Sa$De1x^_;O4o1B&6<^djug_KF%!WR*Md9G##ph
zRu@p*wwhUIx{0PBB+JKd#agA&KHdQ&5Cwd^HzhHi&RuVYoZEr*d57D=goiXT7$I3c
zKFzN@g_h?9Lb7}`TK#PVU8U1Z2+s2HV7HySY2+4!WcfIy&!Jg#4;9utIQiejo&(Fr
zLN4oV=qiUGq=1jGwk>KK{D+>Nvk1xZvCp()P3VV8Y6n1YmXH1x=gjHlasfhuJpzgc
zwQ#FPUq8N<k!Uj$@bTNWDb4BqvDIvCZhPMQbNa*-y-H7bG(xg`>{21$mPY<WNS2Sk
zil3TF2k$org0p<Ix|&;t{tWvFLb7}`+Tg76;Y5wOP$kPpw<U$E(PJ5akSrg+4(OXq
zBOfCq%g0v@e<sn$=JOyp%g4HHYn-7!e_V@@EFY_#c(Q@sAAbQ7I$glWpPO2S(hIQb
zd^xuzYk#abXv8i0K(q%Tp-O>usBe?&9`x)O1VWW8AJcCiGN+N_5t8NOg=;q+(qnlY
zAz41Ao}8fas|F2%Ah>{!aJV#>xpk5hT=&8`6d_qYMxXx`MUUl6gk<?>GP0n`hZ9Z<
zAUMlMzrAfT=qk4$B+JM0`wdOB-<nq5Uo9LgR|#z?;A5}7L!#+(K_5h9`M7+%`${_Z
zafD>~7@F~>IDH_h5(2p)xPaoX3w|p@ua+|qQou*(beETg9i%F2>f9oFjF2oJPetz8
zMn6d3G8BRf_y~tfqkb1}(8sn_2+8vCqjQuqJv~1WlI7!?-WfCKD*J0bf&cfQZg0i%
zaZlr|@97y&KuDI4-ScMbr9XeH6(&~+J*4U*^w6#vb;e4MsF>;W&@@C8@DY&dT`X;-
z=ex{xkQoRm;3FXGy`Fbg+IgfIQr-;hz6f%&e7xE#CWhY3b|NH<rGVnSPWi4d(Nrk?
zDXT2L7^-CXIBLQZmD`LH5t8NOPPfZh^zF8r2+8ts(#C3==~bgaI0R?;Sh{wDqSE|J
zf6B28L`as81xLRKrxi~}NS2Q?7LR^OUq7~skb}d7tNIA5W#4l5{*heN^)U(&Sw4O_
zQf;NAxb8ETg_l5)0zN{Oqn%Dvr;ors2+8uXV@&<l^z7V3NS2Q$w;wR2JKbt21c&Jn
zP~2^3n<4b75rL2_A1hs{K7~fULr9j71IBK3rGs~kgy1Y6?K-)4p{v}AkSrhl-WT_#
zk%gB*l`J3Im-gL6?~g+O39}>M<CQjt&e5HI6cGh{1bN*01wW#5S6(jX=Dk11q3~#H
z`UpG~Az41&S$9q4Nwj+i$?|c}wp=qhxb+GM&hqixY9|jG8HtcE;{uA8-0Pf8-^lui
zkSrg+j&%v9H#6sz5S-<so{Q}i6V0M7{VDgyc!Xs6==nM$OS+WMy__&u1y!<qeDt8h
z9eRJ93`iJC0U!6gzgves`d>jrmXBR8ZCXal(;!ODE%N>xX^QprOoRRVyjc*}PD1M5
zgII`=EFbG`&~HsIM6VE%<zwCJueZ_ibY2a?Sw6P<y>T2}<yM4b`M6;4Y*%{5i>`qx
zp@{?(*Bcm7lMX%-Az3~?UB6c4%TX5*Qou)OqE%Oa{{1Xhw~6Ykh2Sh7kG$%8TDuS_
z@8`@1B;;205sIvsYGNrBD9w;^9eRw2EFWJKTQPvXZf+4R=e83#uR@haH<wP4s+6$G
zDmNe`%g2?okNlu}=nq1&e7x$j!<#;~4Oj=kSw6<6`PHSXJc^JkAE$P$6Hg<J)<cyn
zAHQCjxPnGbMo8#O0mWB#-&LPR-bP3PAK~1VRd2{n8fl^V(Bi*aM7-a(y4GcXckNf1
zls-lP5{gvy5sG}gW^`S80e*>yEFXQt>|*Ktu~UqkTjckxz{jrP!w=B=<5q-Z`Dn2A
z;VF7{io`;dEFTlCR#%{d4@F3pkG7*0@202c973{utYDQBKrffI;~+T8#{o_24yCu;
zAcSQ37_jNV0(yF0ASAT9fZ~(uZuX*=%k~=~IBS1=up@FYeO`?LBoGCBOqljc<zdrY
zL}dBsP_3ye-9zr1<lMaX=Zrs;^^kt8(;<Xp`8a3o$&z#rmD&tdvV8QK5PXMz<-mA^
zWcfIu-Iqr6>l;!KlI3H)M+G~XXwDhZpYp8Hd<z6;`S_`CW0mJ~HX<a;$4LfN#?a4J
z6xs?^vV2@s+2|&X9E*@(kAUJHpKgq%KYzR<BhkZc0zUdj>wjsYnHlL%IXh<Y+T0Ez
z&*#8qc5`cB8R;WU-47?C5mMm13cI-N`k-7|@jnR3@^MglTo3x{-g_GaXZbiXd%-69
zv)l^^$@0<o;ni#OmRoN-RLS!3(54S@CYtGy{**HwjF2oJL#%&XrFWk92r1wrG?9Ix
zTaL6pO5v4NcG&^JSw2SpNZzS^m_~_=M@W{B!Ewc1>F;;^0wi?0fREFy3w5M-9v4mV
z{~oFxc+cmQI+ij-d#G0C-inY=rNBD0a*E|UQ_ajse@dj@E~t{_<No2d+@$H3{*=hE
z2+8vCVAps1=sTB}5R&C%&DVjkG_uZa2+s2H=IlGQY2;jlWcfI9Mcx{E)ks4~0Uu!n
zHYm|k<t0ol_CRo!kKw5&RlZWW3L#lO8gI(^s8w8f{g@3%XiEVf%Le3>r{!_lE9bUi
zomXp3zf*%=En^Xq<zw8Jxs7S$FNB2P0*Zh75V(#;_T2};Sw7}YUh|Gt{18I2eC*=W
zOXZ8$W%fgrEFa$#YMw(^ISwINKEAlovJ<U%B0{o!%$&6%lCIM900d|G*faiOJsLR&
zAz40_9{->Xef^jUNa!H}AMg8okEVyR=|MR+@BKMFl1JLpxfdfO%g32Fq88CrzC=it
zk9ln`9Ho&R4nc4jO990@?Y-<t2aiKYmXA9;6N}ST{z6EWkC(<wnNB179fsg6AAR~o
zPNNs~BM8azar3o0Yv|>&>=CGv<)eSkbtUL3#~~!kN7wNQzv%PoB|yT23;5X2uZKOI
zyYfGBZr=NI^6&MGquX*aLb80!*q9@K&Z9hBCLtut$Jc2C9@AAeI10g8K6dfy971>c
z0)&L=5m5Z1?ZZ9vZN^N5WcheFF`*S*Wt(FVoaJNLiqF2#$n^-x^0D)a_yKfZ{zOQY
zj~>g4w5O3C$00b&$8FErYpxTi_sbmsB+QP0j~m++yG^%c(Gzl!y!Yp<Yh8RYJv)OD
zlI7!`b=SAi$kPbP@-aUosS1s(b`pZKd|Y@pIfPz-{SlJoqg$L|HM)mxBP7hYfZ|P7
zHdsg_o1B8+EFbq&nSPu`h9M-&$L-IOV(7liLP(a632)D3(#W=_Avnv&)7J{^r_ZbF
z00~1W;Ny~@1=HwD@z03Jx_%5j9@L0Nx+ciEdC%t*-d1FibbnR%1uc6KQou)PKK^~=
z=Z9rpa|x;Yh(Vb%P$kR9*O?YK=)1rZ5R&ENg7x`n^s14BkSrh1Bz~Pk%hTvA1cxRP
zQ2gb)vZv`?JQN{WK1Q^#TS^DdLP(a6OS`RHLL=LsgWxP5t?oW-M}OWC3rNT<;G_PT
z9v|o;a}bf`<E43{_N(}KUd}D@d=A`g+p$0OEREcYkODpe^3UF)P3X2XxBykMe7w2x
z<{P@oF$l@>vBj$E!8Gy;LJIf@3sLXj5$V#ZA$>BVJo}qpgy1Y6eedrYPJfmgijdHk
z0*X7BG<Z*+HC`hm%g0+gF1XYCWBW@GoaJMSKGQzY*N+<j2}KI{IC=VNm2<%-L}dBc
z&+knXJ(S%N<=i6A=YTw^B}-MIhjI%-vV4qn3T#O)M0%H@N|uk^@1I;wBfSuk<)d3{
zjm0$bI6?~e2xIBne@QC65LLPY!C5})U&?JnSLuh4EFahS_D`i3qGW`GRu@pb%5VMG
zG_vVc2+s0xty%j5^!^wDNFWOMxZ7~sOL{0X5Rv8M!67BS)5uoW<lMaHb3%S^tV<7N
zG(xg`ET`WimTt?R2+8tsL3D?jba0RB5S-;>(?JQJ=_(H*B+JL$MyJcsn^~C~P$kPp
z^Q?U-bnuA?$@1~C>1LIe!QDVe0UzOD(9UXM73moj-HV<EHz7FKBcOQbvA#3t>&FN!
z(iS~TBjDqgLsO>GNB?Jt$nvq^`{cs(?6gh#FSn*h*8QBN``%m8$PEa|@^N4XKb4nj
z<RK)>N3-~kN!oA2DNlm^k|8+D$0cX>J)wi|Lr9j7VN>;A(KBB97F5adap=#_DxW`&
zMM##9x9;>iNIzwJ86jCd)+^~+%tYg(?n5OFZbNXEkJTz!AE(c&k${9w7x3|3|3fOD
z>^(z7mXDpBFHE2}vo?3++`QkndQ<Gx5@{%<KV_%KASBC2gIDRn^uwk_??RO<A6t%1
zI7$bffRHR7=QaK|m_Ga8L`as8g#+vMr@zc^eh-4PeDrR$%T4+Qy6$hG%tJ^4A7L}Q
zdbaQ1pL39Qa^;M_MMwc3;h;XCm2C#S5Oqm`;4B}9?ORry-XG%u32iCh<Ml1JD(lcM
zL}dARtcJB0-9z5@<=njAx9az}UVR#Q6d@tFz)@qh)6A*#NwE9_s8Ya3=%Jlw8;3}D
zN_2b32O(KLUQ6z+^1R$lgk<@6f6?9kbXzuj2*FuCRtlNZl)k)Qh>!w4f;`r#1LxDo
z=LpI2@mz&sGwB&`oeIHOKH7gOlS1#0(SU>=67Vr9tI2tKwS13=0zN`pPFUV=f^^1`
zCSAF-IX#kdTf;7{Di0v*K8)-~BR3%=%g2_n6N2fJpx$Gs62?-X$|t{@o~EnxLP(a6
z24m*5pyfG^kODr!ShoGWU=m$r<unM+^3kNo1C?)SPC-bPkBc0K`_aMgASBDjc(e9%
zX{2R31ZVkpdQZY^?G=jh`PC(Wgb5e$vE(GHdvuX65K+KKSlZs^{<5Rjq4rPY+%^I}
z0<vVYS1ONI#2_Tg$EM?FUZWSHJcJbR5vpwZJ8d5w-2Ev8hv`vO9FTj4oVZR;&pw0{
z@DY%=jA{;}kp>x1CCkSdRgY%U$Z-fM;3KRWL!CSP{lr=KtZ@|~Sw2p^dio(fJq<D;
zILpV<5mEhVAA<o2vm@YR(c0_V(4S#HMnsm6Ki-Y*LSII;cqZrOy+5bwmg-UTW)_W*
zEFV|t@7PVx&Ub`l`MAz&eIYuy`*R4+^0EDjh?Dg697IT%aRJ5irw(~dzsRe?3#gLi
zV?y1vHR&&!O+!clA7Rz-T~^nWzCuYwNS2QavL>jUS8cK&ILpU`&YyN@7j@<SxD=2u
zlmb3}eYUov_KH+_xO|0(EFWtOA7n@mWviERZjtA6V0OC9E_H-Pu0}|fkBy3*QF&S;
z8zEUf{`2D1A!&t|{*+_c;}ryF`PiXR=fAf#q}@k}+<}lRANQT@Hl9{o|20$zO(dXr
zsS>ka(>Fs$AtcMkO+QPYqnFF82+8s>H)HT%8fo?hg0p-K7}w#m_S=d|ALj!Satrtv
znz1f~Ueg~UBFjgY0f8zX9ofH?bMv0hsnY3V0eXL2iI6NG-74kXrQ0$aAz3~)-G1ph
z-Il%HL2v;d;n=qS<?5{xQukq+LkP+8acB7<+vpiLdJk2ye2lo>x-5;Hf{@Uc0*a5A
zcIO`bDd}B=Wcir**g$2~u>AnRSw5E7w@QybuSNk9id6LxCcM+Sm_RAFH0jC(_&p-B
zd~9^n+>SmFxqOs!i#(qLRo0K~{#f!+nsjBA2N06w<MMkyPS8G<`2<z6d~6wVr91sX
zhzSTO;3FIiIxThlMK4765t8NO_AbLtH_(iu^rsw4o6iuO<zt1XV^v;uvjrhpK1PoA
zxj?_Dq);|g39T-mc;TYCDj&6vLP!B0p)c3P_>Pr)l+LWm{qYhYfvD;uO!%@HCG+VC
zH_nlBqgQ|k<Ziv@j1S$G(-D$&KWEN|-}UJ#GZ2#Hqq)Pi?esNIt6T`q@-f(TOAd{U
zLr9j7ecqnQp;wK<U!Y2sj~4dPPV`s~Lr9j7u2Bhh>HYC6LJIf@ot}7N`J?)pE^nx_
zYM6Y5;4B}f9jVj0u?8poDHo!p2nqHGw0dgT&ffI?SooW^O7wCK0Uz6xJO1~5kJ6+o
zi}XZ9*8W(ad!0A*vF$iQvV7eA!TBeRH2w~`Sw1!%Qu7LpoQ;qyA7@QB_NS3g5t8NO
zuP;5i(a3f`AUMm%vR(G*)5y&T$?`GnK#`U7iKysLs8Ya3*e80K+Ml2mAA^uAAD!LS
zs{B^i6@+B@IC@9mMA}F5JUKXYx`2-Z2lRbOpVMa}BFo1PjchN`L-_<Dp-O>u$e>ey
z54y@$zaTfu$B1kCD&I+nK}eR5Mf9>G=*>*;H&n^;vD!4(NE$f^Az40F(9c)da?c<n
z%g11^jWM+1CVwC}%g5L|dpgp==OZM`$J3ijdD6&Cgk<^nu>O!J`u=LWd^tF@rGSrJ
zoJwZWL%9|aSw2?w(s!egzYvn;qt&$UD&M#A)+_VxTeoa2tsuC7;+{kD+-Sv5AtcMk
zMtYv<^g>jl0948H@$1<Y?dd855R&EN)b5EBX=FM=vV5%2)wm>mvDdmF1ZVjepBj}-
zSGgG>Sw0%XIi9C|EK&%nWcgS*ZQlv{{_1c*LJtY}ST<$#W4g$bh{*D>!HxR^X&;RX
z%eh6K&w<lR<?VK-=_+R<B+JJ<&yX~_%5;Q;u~bzYu6g$E+uTG#N=G;4*}qK@2rl3w
zAP*e2oGZPRQo0^jA~zx=%g2<O3Ge7m*DnfHvV5%a&+VD?SdK<WmX9yz#vY=Nz}FCx
z<>ST*jrP)2HZ2ChSw8x#nBR~-uSNnACS1VBZVrCN^gW1|h{*D>)ZnA_>D*oQ<=njI
zbE=L$>`o(hAtcL3qk5)gXvGaQj|l&L(WR}Wjew7^Y8>7^y&Jth`XD4skE-H;G(X-_
z<)D58Az407k87oJh0>%11ZVl^)@<B9dMuY9B+JLIFDz!#$d3rg^6}o!W0v&v^e73z
zSw6Z~Pnt;Yk9z<Kvm@YR->A*M>D)z1$wl(spK~mK!$kV@G8`cV&Z}sfn0Iufv_<It
zD&AFuWcg^f)*^&f+^RGLXZg6S%Q$BmxdI_sKCbUtHl5xkz9J;dxPaoVe3~4l_eW0y
z2+s1cMf2}h>EI_2lI3H5%H@(YvU(Y)lI7!@2IU*mV>t&QSw8mNRrZ7SX&U9{9nSy>
zLn+{+XOR^uKdNqDR?gjwwLcE(U1I}1;cF36z(?37a;NDz(X*3>kSrhH=xyvrBfZK&
zaF&meRqMAm(X1NMpYm{-fRHR7hbO&UNH3RW<)KQJk8gfHSVB)vFhW8T2`FxozPA}&
z<x7NQ`S|gwqY*tlohm?ZmX8Zc=csHw+YyrGW2Jzv3+VUD6|X2)3AqJ)TwdhQTzV+I
z5Rv6$5wE~n^ts>^Lb7~pIc-c)x=Le1$j$OGKiN;^^Nv{v$?|bYcAv6zr>7$%%g4ax
zvrp2O6RnLPILpU1KRw6ORc=H`mXF8JHlIq%Q>YSD34JM`c+K)7PtnNX2+8vC-Mye)
z^!}KLkODr!xvi7ib<OpX-rr|*l>1}D%5rchQozTLaZzLF*_n%oEFbOGE$T=QWd=gB
ze7x@+V@V_1SApCtANQ|~Z%YT?f{-j9r#CA34_#%^s!%1%$F&)A7SqU42+8s>XjR&B
z8hI5VSw7awIgvzPp){%n!C5}e+7g~k%M*!^(CPw;k83z$0Ui7cLJIf@=eBvN!6)hK
z$3Dh#a3Bi!7`lE}XL{$^gNQ62H)j^jpr6|{s18N4d~BIGM`b9-ASBDj)AK`@(zA0N
zAz3~~cpSJ#Bb(HK;4B{(d^WC3?~h9nlI7#+Yro^^$ER`-lI7#<QDKjyL%Q^*JgE1t
z3Bg%D)^Fj|lzx4~IfP{Sn0?ixK7DR$XaZG&JpziK-QT7@eO?Wdk?6-Z1bl3sY35FU
zbuAqc1$;!CxY^Ek($c0oJ1uHyb6fG=pEF|rm!T3)7a5C?EFVvqu6Qin9@4!<RID~s
z$?|c1wKG@iYLL>OvMnbgB+JJa7M^eE9(sz9EFYZ)znM!P3|iNL;4B{tUi&ACM#dr}
z%f}+wE-`fQ0;W(U%f}HPH=U%b9E6YpK0>SKRG8JBKChkyB<wt@J_6BT`|aOSk<z-Z
z>>;DNa&Ghpp1`6J9DCP}-g2iQBvdJYj4QDJ7rjl~M@W{B6IW%-rjd?j5S-<s>!l*&
z>HTp%Lb7}u5SAEDSDBBHEFTY^{vJcO<&b(1T);<YqA+W-=hAsq`lM9ZMCTEb<>Qk0
z*vIr(nwvwFEFS|}xV@yuG7KRFe1!9=)hw^>^m+9?AfYV<eEhvn@2-?vDpWa?9qP-u
z(UvP9k9Tynhji|(2r1wrO!%n6rPAqDqj&?T5`qg<Im*-Z4gLF%V-S+%qoJ4S-?dGu
zR5_N(2+8vCON_-rS{}=W5S-=XeEmW*>EO!{Qou)O%dNY9{(T5SIu$8{e@94`kJVQD
z4Wxq)XavDoJ`QS^_<&aY6hg9mY!O=cBK>(s&Bk(-&_e<~Zuyw^_rrT#A15QCz<CvB
zXXnj6Kj_>k2r1wrAoqOA?M@@@n?P=skD)_HRG=q(EkeRr3Md|5+HNwv5al5x%SVef
zK0)-I67QxEoaN)FxJe`F;O7yN<>SYqHD}SmO)a2GmXGD#cd48;LJ(5GM_ANX2AUR<
zs?=RIULz#S$K8uU>(bYc&X#g;m~d4eq0?8N9T7`+dMqNcd~AHuc^Q55FK7itvV6??
z5#FEfp}`2r@^NO5fA-VJa|p@uanaM;m8I#I{*>E99cu^<(<7kx%bcC_=qhI;B+JL8
zU#pd-r{@VmvV2@K@lF_BWh)y9F5n}`^WgGGI|-?K1dc&SmXA{=yF8NCHr@BH>e)h-
z0zN{OwKMJ8(btc|0SU7s;N!3*y*AN49!Er$k1Jj6yU=grG;Sv6=Dk1X;yHgS8X1g`
zEFW`oja$&jPY5aCBh1cSzkSD~{xQ+~DSh;`gWxP5v&P@~Kv#JNAz{V^6dyA_bagFF
zh0>q0$_DmOrGSqRd}8&JfA5Xe(?KpnNC6*VpXlK0KAaAokB|aB0&>Kr(u++r6-s}~
z;G-QNxPXs<tdqDRhW>s>G9Y0n1$;F8(KUg-nlN{ii{w3@v((l53H{Mg1VRezk1*kz
z20k*AW=D5v%SK3+kMZAIH>S^61DZo{0Uu#@p8s(=N8hqdKu7@}QE<HwNBT}lqZUx5
zfRBJQ%pRE|xhQ>_plr)XgoGv%P&~xtcr1OY{(+DzAJglfaHH>4d$)w(0zN|UHAnCE
zl0r+3qzrx)Az41In6V+4zJ9cBC07Z#1$^vd_h22}mZ6Bq+8?uqBqh)XqPGYs;3IUp
zufN#=`cs*%ts%F7k1#ux?o|FQ1=l?gZ9_-_9|5^HZQFdwM{}JCFWCmF6z~y(e_nk!
zfF4VKgcR@*kORZE#L|b$`v}SMaY$Un!8FpoEd+<Y6j0pnT3i}E<7*I7z()xFG~dOa
zzVH7HAq9Md882*5G+6q6hjfos`Fu_v%{lhpFC|z(kpe!BKUwG;oqIPTvV3$NP-_&O
zyJUMPlI7#|<VpQ$<XD6h@DXNb`1xJ2bnt5kDc~a@4=wzCj+Uo>2MEscapAmr!{|;A
zMM##9JN^tzqpN(4kSrhT*6uu+uCjAS2+s0x%bseTXykT;gjN?&eB-=ND*HqUC#aI;
z<MRHs{ytAGIjQt<G$4T};NxV6ZWrm?rxB6mV>!>b;`D^q>?G&r{k~PDdEwjWDrX}k
z%g5$>_AjE5PY{yj;~R&J;xw{NX9&*nvBK)X@${+@hmb5EuY9=mkzU*K5t8L&k)`8O
z=_&_yf#57352bzxpsPHEkSrf<JWjdL$m(68O0Y*j@$HR16{7F22FOTjkVnAB1asRZ
zv^=*E5s(5!<^~ruqubJ=n>M#K@A;eu+glZ(k&y_=@^QO~eKs9D8zEUfE<Dik5M5<Y
zX9zCfBOHkAt{r(RU749^{*>1|2N06wqlLr#19X*@G|!s+d&aW15bzPIw5_@QlXO#1
zI{z!H^hZdRk7kxjlISW^5t8L&$K@+sX&;-rKyU#cA-JJkmJfY@H5!m`5)|-p?feK^
z`u^%CL}d9m#r$e%dMJDKkaP2X-zqt8)g>Bv5FrJ8grRh47*I$;O5v3~RM8cxWcfJg
zPpryk*i#Tvz(+U&Z>V4}mA<@BK}eR5@p~G!rxzlJo)BEXN2s#D^PU3q^sGimmX9l(
zo;Iep+#d+Z@-Z`E=r1~WpI#7Lz()vP^47B7+V^xT&#OlO32iCh<ACH@D(CbvZgP>l
z=W{;!Rp>*{&P0TSRYPFQ?KG~n9X*t{5E6n5An)AmKbo%6!X1LMe9Sd8=|lHWBto)$
zd|hLw%5T4aL`as8-$obTLyx6PZwSuvu|sCw4Ep}+ZiE!@5ths4NBaFEO^=Dra#`L3
zs$}_CsdLI|x=KHUWcm1E(&AC{`#K%~5_(9$$AGDio#+L)Ngp{kIsyxH`i=b;{OEH*
zBto)$bh*=R6D`kYgk<^Xy7{Tf)5X2|LU0&Mf#B)&>{RYt9z;l%j~m;B1k=Ztiv6HU
zmXE<P$D7h)ITayUK8~<i=1(`#eS{S75q6#v`d6~(56v7sAvnv&kwsgrrh{)lNS2R%
zf0Xv3KYz>zBuuz~j~y~nTheQKpZ;=g8`gO>vQO*`dI3I+kSrh9ejTN<KUN$7RkC~x
zx4)tyj~_y^eC#%+VlBEY?;<2jkAUKS;d8FhJ!Izv!C5}eYJ4h%UM^Q7B+JM1p<Q~>
zRencEmXB+1di&91+0Pq-vwZA0*|HH`<w=BO`MCD;!C>0Q>I3B}VRi(3>|bcPHC^Ns
zL}dBcu4DJVKT9f2y7I~_1tD2J>J6X1oUXFjAjr+~G1JhhJ3Zl12+8ts%aOW$=_-FB
zB+JL~<qU_?RrVhY!C}S)6fb#U|KDfxrAn34a~dI8K4zMkucxc5IRvU?`S_~%#TWEg
z&PPZAAK?i6z}h%~zU%Z1Az40_?>buZ(WRcA^ryUj>^M{o4nry6qyDv9k#z30h$!GA
z<UUzR--FJbhmb5EcND7qo<6pD4TIb)AI}xs^7jEr-L_0XNS2SeuI3A*VUYfmoo+Jx
zf0UhfT#juU$FsAygd$`MA!P6Q*n4E9q=>RdW=4gKkddtHO?Z$!GE>OjTUH2J?|pgP
z_i<crzx(q!k3a4|JfF||eUIOHp5OC4uj@LyE~--GWAvpKHE{QgV@Q#Y`*WwikCAs6
zk_M52;?K{!UdBGwcB9}TALqs#{Dt?c;S8zZBW;26?m4y}2T$uxRf>F^e>(j|{P$J^
z2uZmWe6$^&$4u`WVnhWWDfhzG?Q>yyYzCTg%f4^5<Cb?K-eXN<NRf}$&+lfz9e$r7
zMLs^vn0Ow48Ka>G1sD04$NT3j+?L@Cso*0`m-ZVw9o7z-YG23D&l;%*QI#Se_u8*I
ziVs~5Wk?#AW)-I@8@Aom2cLDi&X5W|5^_N7(kj}lk@7@VLr)4W^0CqCn7#P^Y6Kyv
zNV7gtkv`*3{gFqz@ucsa-;5~oG0m)gWAPa3>t)KV@_j2(JTY#t5AN_23@P&Q<oy$~
z@r85g!BnNl$Kp2e-!O6pLyCOd8GY3XPee}{Qo%=R%g_C1Szu&i!?U!%&mXHR_(+2&
zq+^pPZEj0Bh}JQrf{#>X@}#qE@F2?QO;yrRH>)@ySFcVmvm^3kNRf{LYt9wH_g60v
zl89z~q#`@zYWWKHPSK&J+_LXm1%>_If`{c4h7|2rkG;=73?m;fq{zpyxjR?Fi&>pv
z6kOz^kJq;j7`cogMLxz>ifMzp=PN^sd_3+j(FM0<S04(l;3Ey9Y0f1Buso3rso*0i
z-a06%siwGg@?F19<oBg2MLzy)Q^3rNXU8)n*`uKN@1M=K;`=#wO-Ob#RKdrNrv|jf
zO<8rgF?W@UqV=)-_ta(ZbDqTvDe}?qr^8k8u>8T0A|Fd!9zFqA*>eO17y0;mWUVrI
zq#t8Qk&k)2o;<|C3y-8KWj=Ns{~04EGNj1INuEiQG4eh`D)>l>cinWZCLWh{M^SK*
zk52=CuEkZZVn~sXIXBl>jrXgmMw_ank*?t5!LZ%~aPIDmDDv@rHJ=Rly7>@8Qk4qx
zP}?mhuH#22He)Ea$j7dsF|Tp(@eC>Qv5}44V0=k>k0C`q7JS!gJ03#~#!_&RkJsm4
z9D#$cW=N5bIn!GX!NJpxqbfx{mMC$c5Uz3{Ln`=4OK!iQCz-WzsbTd??m31O`M7t$
zoW1z|YT5Co;4~~1e7x0S;94xtBt{hZ_`Q7B+jtB;WJr;ZgO)UCi+iX31j<dp6%>D!
zCue_*T*HtGK2nFbp7^?vhSY8v=sP@}A62Q~BO%jocwYpMA$Nup`Ix1{wNH2zKg*B`
zK2nu^tvs*c>&FrkDY(eT`9sh4GOj%OwhUlM1s`e2?Y}no6b}A`Aw@pUTmF4?)<3=d
z|Ia%bOfm(hF{I#Ql_NjgaFHR5DDpAk#a=TfUp_LV$j4>NL#N;y>K!LjZjq1SX&%(T
zOYS~~q_$L0{7e3zr5KrS3RS7#BaNYg%L<3#Sz`o4D)>n9B+NOGPHW2|DQ1m$hE(v8
zs+|9BgPFJBIZvhFA|Ef^|GfuK>MIyh<YVZ`1!nGz{bWdyk4_Dq9XHMz`sa_mrkR3M
zhb#ElJvq+ItB4{QQRL&C-AQI1X<GYJks=>&ZdmGwSMjk7De`g0>$`{W9_uzkihL||
z)AfpW{~_f)h`Q4$ICYO%#YvvyF<TyLH<nY%vz{Rpd?b1LzAW<-ziBw@460J(<Cu))
zJK*VZBtwdPyp}Y(6|V9oLyCOt>QHf{){ZILvcXIWuHYke&%epJMryDA)>bsVj~fX|
zy`$h`nfA@D<EBhI%T%Q7`&NCrk8H1H)_(e}hC4%weC+yYe*(Vwa)}`oe59rv^Xg0k
z4Vm(3ROJ8)F7mO-w=JLXJ71PCq=JtmPei)hgYbi%)PYnb^|*rK{YIu8i8q%68B*k9
zKA%?!_(dfb7*gb8u*0ysxGif0QE-uu|8z<J9V@<uAr*Y2?y-x0;%s~szuw0zvrSb}
zQ!4oQIiGhw+~MwwC|V!)SUp>YSDuRuDf01s{M!+DeXKNxax3^qO*tj#eFZ!b&1Xmj
zA4&1t%{;nk9iH<2<ewQ*<l~w*%e&#WbeT)R6?~-Nb!(0*i+lVyL((8Jt2iN#Pqhlb
z$Wp;nrN~Ezx=GO(Ifo%dKKeelYlRj6#E>E%uWo+si_hn{%rgb2+zLL<=zQ`AE^;p;
zihP_@cT_z*(hJY0B1Jy_^DO&Mygp80NRf|W&93#vRX%4(1s`cxK5X3Q4X(1q0tznj
zv2S$cdl<Q$Aw@nesy4PZ4xVQrRVnguhfDvSxXMusN#jyM@n=7-n)&;VI}9oE@l@ec
z7qH^>LMXV%$0rfv&f)9F2trbk3O;@f9Qh4Tz`q$$<fF%-O?Pna{)<exW#@BVR{Zu3
zBcmBo<m3BKH_fc#6&6#KA|LmcO?JUmE?`KJkJZ<29E_3Q7*gb8!wNIae3rEL5(+Nz
zu}5L=Kl^^IQvDUm35FE;*sE(9M?5Y|hf<X^)D;vjQMT=T+?KN$QsiT0=cpCf$B%?0
zqJobt3O;&-i)^*jlv{Q_=YiKgXFLJ#Vo1^Y==vpi5T1bZE~6?%KK?40*B)0nmLWwx
zCb|CG6eI64q{zq6Hb2he;PsYMaFLI1dKKD?NBTO36#4kEOw=BX%(#N86#2NY+MTU<
zTn=VP1s~~hVro=|>l!lU?Y20EBzqJT_i`Jx3-4EJgc*agn=fX4q#~VdGIZAVt0}K}
zf*Db?K8|1CrvPrsWQJ7mk*ZvgG4@~)*pz)%Qf`rtF9NP!!z29+LyCO-HRa|8j4T&U
zRf>G95m{;-Zp(QLso*2ErF(g=p13W)Fr>)G<pYKf!Bx7fqTnJQXWq=S9k=C4hE(v8
zE+@jSSjS>y>D5%F$jAJN^E=}6a&rhtBi*czRHUQTgBQ3dpE07y$H-YFvT1Wr%6X{O
z8dGlB`*S|uPVJ5-;5`f}^3i>l(+<3t<zGuxihSI0uEh;p<v4~E`51A$={k(O&yWf}
zQjfn$N^FgLyx}?uF7h$2b-vuV%8d*u@-f51q;t4?vPMvqA|I_6b-ad=Lm5)!<Bgwd
zbL0D~afGB{so>*5&nY3eDIM0Ea;v;QhbG_$7mGV-9iGz1`3y<3hS_}qA)9OreT3)q
zuMA1S%_3=7_PG@BPW!W?l<&Cjy@7&@d~Efz$TvLFFEXUa$37eUlkl8gc_URR@-dh9
zhO&6NT*8ndAA`J8KgURmO;n}GM~m-`gK+SH3@P%_d*EyjT;)ZE6#1A?HtRfm{aAIg
zDL9QG1s|vFyfFfgp*f5wS|95y*n1Z@<tK(z@R8(k^}Ub^SJ`a~<rewa?Cj`UxXL38
zNo}d1__<VFXW%M}Z>1_lKDvFlW@fq!U`UaV@l7t=!pp>4h7|c2U1`WEjBK}!f{T1S
zJGH)<C3g=)ihMj4QPvW7PyX#xrGk&NPWa5Sx~Tmt<#_-<LQ;n-__))(R%tveZ!n_B
z$2RvZ#^QOX_6}3-Dk2~4T<ea<O}UOC6?~+o-10i4I9_ry@1!b4K3=KvqXTYBABLpv
zQBXYNtGH=6csxUjd@M9=$p<stvx|a@d~Dji!$@4^I))VaxF*%Oi}>Mv=G|1K$j8Ce
zvzqyW(r|`U@R8PuK2-u|<Mr_#A*pv1d|bP@<UhD6tL-u6X19nG#!z3oS66X|uV6@#
zk5%S6+hJrn!}<FE{)V<{RgsTF?cJTQkAoRf<YS{wm22R(yvmRwAKUk;(+DG-BPlrb
zxI*^~Ec|E!K1>tNkP1H1+?K!Nh$q@j!IU2^$-0lK6#01RwVw-qE<TDOMLy0=crah<
zaqXvnD)W#bMLt$@de|QO*lfQkI5nk$kI`p7Eym||S23b!eN3~nq?s|4>Hrlf^6^>4
zS*`G}bZ1BfA8BeUxwl?E+&dQ;Qsm=-W$DZ;W>x;B;36LfEJ!s+`>0pS4|^?TNRf}(
z=e}ubW^Ox3Rnj0*P&{vNm>*uu1~a6{$DTEl?&B)2Go;AJMfP99@F%nC9HQVNAIF{X
z9%kIA>(9$=A|&Nj@X>pw-*`M*W;tvsvYN=pb(RG_<B>jwAw@ox+xYF0F}Hqdd%%z)
zA1ha__znke7)8NFJ|?=R>w$;m4u%x@m?=%L8}`xq2vsTaG5x3d%kT_5jUh!ox^^0N
z8UGc^6NaR5si1hJNp+L(AZl`yf{T1i=lv>9dudS07YA)+NRf{lD}CON*GHRUrYfmO
z1s|)G&6@*{^pT7x@^SR1$p`Rd)J=vI`B=;4&Nhs!bDVOEe2jmY$`uD+!;m5$yN*5U
zkE=|7f~r*Tk#>R=?+4V<klN-zKM{E{q{zq7mzw^0(T#@HBV!m+!AGjHt!H^#t->NH
zkX27oaFLHc&Nj%V;Zh=(F(eIj1;xK+&g6}|C-o_+Qsm?6$Jb6^AKeK_L<JwO7I$ie
zi#*DRA|KQ3cDsa;_NPs`W#6~z=~lh~ekv2dkRl(q1>H9D_V~99De}=V?WF{)c!x6-
zT;$`V+1s79C0DzY(#sRckRl&5-}bwPSMkDUsY;QLPiyrUimRN-kRl)B!^6L8E^0r0
z@DB_r@^R4fr0O_$*Juh(_9!UcY3S6l`1#{86Ow(*Si#4SMLoCT+=b2=i*%B`KWFEa
zuQvE%Zz@BI*2f3uzHh<EmkcTL@l(`+*Eo2a^Aud<<15E{c`!1PAw@psZ&l^bUL)oD
zXmf$86!~~DGXE|-T~1+0k&jWIGu_1N<8y{o@R62WtFh(IY1fY_FP#6mNWm3+BxJvS
zR#!D2QyxXz%a9@;L))I1h|kN}UNTilBVEDA6>YBk#*@YfMii}&&F3}VgooulhNLPL
z=Ap7@+nmH>sPSdWt>7c|&dpa3|J+#CD%DTGn;25$<IKo_b@-lOju@&^!AH95w4_<~
znz(z$GNj1I?n_*^Y9n3y>4QIJNCh9M%3T>hJ;2+SmRBgaf{%o(pOAGB-fL`UNCh7W
zx!{0LZLPPppFVi5SgKOw<6M_ZzqBEx{q*;9#t@Q*rGk&6>@DWtl_!o76?~+To^Gq(
zCOli#h%@DO6#1Ag%yq2RjM`7%lq(sMf-5K<I5Fq}Ry_Sxs#4_RfyI>z;<of;NRf|i
zo?TpmgI{4tk&g{45BI{st6!twA|E%GtaSk28(YDUA|E4@vYL5GVW#U;rO3z5Rjgfb
zaBqfG@R5f4#4VK?Yv)(BJ*(cwtAwO6q~PP~?_uxpP2h6zrrfgcTm4?2#sg1nOBhn*
z<MN+_zv8C+&X6J>2lg-b6wA}+1_h_KR8ai9O{5ckf6i%!6#4kbV&@lJrTtB+Qsm>@
z0Y%nhWFSL|e2lj5)f4yl2Zj{+Sn_u&GjG7|c#DFId~~^c<_+E${L7FcAIlf&^Fw<d
za?0~LMQ@v`qz+f`G4S1?JGjWvjHs|a(!StX!lfKoo(Bvm@^Q|re!Fp%jqgxyk&j2G
zT9`T2x0NA9KBmuK;v!zma^0mWse2R@Z=EAcHynHnLyCM{`lUn@ysLi5kRl(GvfdBD
zPZC<*qu?SRiw&|kfgki7WJr;Z^%8;)l`+Vp{q&ox68EV}1s`dsN2fir9bZ2#CM5Na
zf{#}Ucg~MH{4FDjd>oW%=x^NNogbKTS5@$l_61+Q?8}P3IdPOBMLwQBk=_e;xWhxL
zQsm=;GQ0e6@KA;n`FP0XXGz>WX&zCP)Z+?@@AcZ33m>HSWJr;ZeYUjuf%mI78B*lq
zsTdD$jBN6lf{T3gT>bMUM($=vk&h#*94wBXcNBSIs*;*g!N(D43VPrh24fge<l}{F
ztIyzJ`G_GEe584(wA1rU7}@G6<reuk_56H)yit#2NRf}FpCx<X^|9zPs#4_R`G;HG
z@#b<CLyCON_c``NHp3F3{q)PkJBFk|q@Z{ktDAPl&sgY@jh<6*k&m7YT{auvY^p~t
zV@Q#YXBJ#*f|2hSQskq59Un_=ubOhd+VF)bIOSIGF=JZKoyI39`rP4+DDpA2N4Lwy
zKho4Ae=wxT$L>LKgN^f$9@*(7<reuEG&?yQBeyf8$VcDP0}kO1&-jX}6#3}X>qTAT
zhDaa07ek7CY`)E6rnd9YetP6yh7|c&{QSHd7@6ZW1*dVTp!hGlo)vNTcrv8O$NIxM
z_!{NW2S3G-A|EY%YZo=zqrab1EWs3<id671tm@tQxGDV@QRL&twyln1<V}VY`Pj5a
zO;?Pp@`iGYe7wG^X@A_|a~V?P<H7jrl`--qLn`>FMYXgjK7DkTdi(zEp#4kxOpksH
zHGE6KMLv4H_g#eF)fdK)A|C@r-F3l7@P0F-$j7+G70i56viCa*PD5Qm@%+Qn?8CR)
zjx(glN59M!#v8|_-bcIlrYec3;N#$aQ6=&2WgH`ld>mktvoS`-Fr>)Gk5>u=;ti4g
z2g)t-abkxypD}VgLyCMHRqnxJjErMQ1s`dn?)kg_JiON^lSsiuKEB;P<{m~)Wk`{a
zmeaG?WHHPb+D|`g++j!sA88_5HKO-=Z86gX(jzN;q~IbS3w|3i5qHmQh9r9w6n7r6
z+0!@!>wSD;LbAi(3O=@al===Xvi2uq?rO60Ifu$O-EAyV-;@g(QsiUmujS&5`vN`k
zEklZY{Fru{JKhPl_)Nh?KCUhN;v`0{W=N5bWvY++Y@C4g!IK$M<YV(uuR`%x@j4|@
zaFLI7y!_qq`nZcB6?~+LD9g{)g>aAO`a)HTe2hxhX$9V|4q-@<k3o};H!=3O-p31s
zq>--RWBz`-p5ffZzM67Z60MIXl19|TxhFCtRjDu!-Sf9^fRT3@Qskpgr)}FYvgS7m
zF7nZH=&I=$8Oo3%AEyq;c^Z%OFAOR2@npTR`|-A|OELu)`Piv(<`;MnMKYww$Dd<P
zo2fF_cdAn4<E?+smBtg%FoqQQc=J|i8)I<2kCzBZ!&1S=5+VCsafg@wVal!Y{v4Xx
zLa&uPgXi>F3@P$4%<}qL+>}okl7cHJ{`h-RYK*M^lY)zUjHvIEh(~%DLyCO-T<Kt2
zT;)%O6#4jTX2dv*?EZ^_i+pU~wfrKC+{ch2AImzw55UMgzo|+EA889*{nosx8d94w
z^?QwB3@P$)Lh9d{ja$M0^O2A=h7^4K_tTWQcnp=a$np0t@2knq=M?mqYv#InIzx(l
z960^`CEPnt8B*lq&T{RiV`PI=6r9>pLGh1?FQ(!<B`X<H<YS4g{bTWxYmu6&6!|ze
zZQV5(>B5jAA2+vL-qg5E=tue?h7|c|u`y3aTxI?=6kNeaS|^(NggYDM(N{T=Aw@nq
zeCQfzMCyHvAtZIUf{)eCm&=QNES=Vrn|*RwVOTD98`2jy<xGYY`B=K^iv9RN)-#3_
z`S`NLh4;A1=IJQ7$j4~|Y7N16O4c(Zb&o<@+Gb1VkMERNq^BxHKIW;@I=41RwV!@i
zc3?=6kGr-G3c*#bWk`{aj&?O7F!BpSihL|o|KTtkyhR3TO9dZk$#wbBWRK>fHW}%C
zTt-Oh9R(lzJ3Cw9+@Baxbp7}^(xW&=HnlY6Rym(TQ`^ET-?AI8oAqO8DMN~UtnRa@
zFh(Xaq{zp@53Ua}el1sDWs8gyT;$`+r>9roD#IC)dR#$q508*-82ObUMLr(4t8eBm
zaNA52T;yYoE|ZVo`-~eIQsm>1DGrnIbZL>9s#Nfi#^sByZlT7u)ce?tkkph4J|4;I
zmj)NPgAqkOu8*{?gokCuET-H}qV+Lo%)<l5-1?E;n;}I$ZjX-afUDfckRl)N_IqTB
ztIV2}f{T1C@XqBNMh;*|k&hV~c8kKn4>KeUA_c`GTUEM+tIVB^f{T32UMtCPjM&0L
z`{{e!lOaVuy5H{G6<2wTAw@pU@xOEn?^ms}n}Snr1s|VxarDGR`Y@u%$I8Es^}@(=
z3@P%_Jx8eFEe)u5isqo)A|F@w+V&5wax_DVd@OwBryoYfFr>&wZ*Qjv9K2Lc3NG?-
zi~T(-T%{jFihRs}v+N&nQp$6kA!%GHC_X9Eqbj({a=9qD$j2)=ANphDG=>!Uc(}mQ
z`Pj!hgrp)Bd~CO3S0pa7YHm~R>LMSH&iQ-`FS)ZBQsiUWO}R7Un=j88QsiUaF}_3b
z^<%?46kOzEi>k?H6ko-VA|DIchvvoI^Nk@zKIXG~n;LgdySx-!<YSlXYnI_EH!-Bh
z$DX4+uVZBDd{iY3bp^%iTD8cGk=+?m<fBdC{tej2U4$f}f{)Mp^>2xLC$p6)x9s~?
z=WhDN<71qz3@P&Qc*K>x7`dMzMLt^hedmN%o-Fw(xX8!QH;2+;WIu)!`8eBtNqdak
z&yXS?3$}LXgxfNkH3b*>n7h*CY8cs%Aw@pE&$<364j##nA|HpY_+&UVgEm=N3Q%ye
zM?vx3C$}#&Dz3kN>}Nu<#Z1A+q!**i92+~ph@$oJeC1<T@p-u%1&z6@R}}eJ!{MFb
z91d#A0SqbfakG2tfp`oZWJr;ZA+skL{(uElnY|DN7x|bsRh;1ut`TwoLyCM{lmB5R
zGr<{B<YStGbr<6*v)fQ`k&l_@XM2vT9KetwAGhysI|EmFfFVUbo;#4~&(UIS@22-L
zyR9iWjdTSc)4W;bk8^u6qR7WGnZnInO&noJs#0Md@;r8F1+Fr0VahG?F}?lrVz_ra
z7*gb8|ERvdag|3HQsiSE%kkYXGItRQF7naZC#E|N?#_@RA47jl^}xu(3@P%l(5SeY
zW`Z03wCle&(pRq}^6~7`Nru-npt;SRAr*Y2=N-NW>y6Q#IBPGT)%$pukTfh6d~D_s
zXZT|iRHRK&Q*PP$9LKm49{B07FGGra^lH)C8NYJiGDA{u1;y(%nx2Sns8=aQ!9_lf
z=u+_#Zp%Q16#3{j&wDl=mJb<H<fC8G*QvP5s>La|$j1_o%XY@dK!z0gxcGjL7r1*K
zGNi~y=Wc=B@VKmQPr(&@q~{$UZ@xZm+zRS_Tu4Y7Lkd1FUv+K(?(i3kC|V!=4?2y)
zO<AjiDR*U&k1Z!3e}b=a7civA$BZ^{6>yaa3`uRNpm_D%S(h1mM}LpLVMz)u^3h|(
zn)kTMB@8L@aYU6pA-KwS3@P&QP=(Ki14tHzqf-C>aH3Hu3NG?7$8Wy`j9kW$A|Ja|
zD3D~l*wc4UB14LNOs<h@Aikf|qO>VEb-03$L0PW#z`55jqR7W>*?)Dw@+32)$j8+8
zM?_&{hcc8~<m0ijUY&68Eet90vCImm&G@`rnzB?Sb&rDL-@~qq!*3OFWk`{aQIlre
z!&P2pNRf}n9;JVaM|#C_6kOzE&wl>zF>)qDihS(1>O^Ube87+jKGJ@*^4bcUwQ;Ha
z7ybHJy}T(n^^Ss%mr`%3fr|`gM3Ik$Lw+2@$QKML@^Pj0_L&%2&w+A_d|cM*z$vWw
z5{4A{m@(_Io>=h@3@P$4mCukm7}?CQy8pe5s!Bbspt#$oYpyu>N`@5qczx5Jxww12
zGNj1I3JaU%!du|B6)CvL$FUi2uf$bGFr>)G2;W8dwTEWfUu5Wg{6$D=N(CP`hXvZ;
zB70Oa<z}xuSLpDBm97aGxtk$HKF;lHxdQi2W=E=0<m1sDT`%J*`!b}+#~HTk4X66i
zwfF&s6!~~+&i8S+%IuXXxX8zMj%N+8i$PVoGb9Zng&y}PztGH~lEVxs^6~jU?*6#S
zyj3W;$j9nVi_M%O@?=N_AL;rr*0ywWZEZ}sKAs>X<yP>qd#5LraEIGeHRWc1;;hg+
zNlAfr7&(F=MLv!kdm|S{USvp-kL%ye48}-%Ckig|@nib8X)+snNBik7P$n>>$Vcl%
z%foS%ml;yz<Dte!&B#--8U+{mxGEy_Fs^bUL(;fZ7(^FNSiZr?c!m`DxHQglFGg0V
zPQgV!uC*Hf246qUAS4y3;NzKoN6mEj14b0>SEJpBmdClP*D&R-F7okMHuo63#|mah
zk&iD5e{G79FBww7N4lD*vBvAqksodMqW7_ZGX)p<xaLq)AKaGV3@P$)Np!1$82ObU
zMLurH{r(U}wyjCQMLt^WSh)owH!vg(bp^$vzwL9wORhyNs#4^mTjAqQ*vHO<B%*?k
zS4v)Xz`3_GqR7W%^=ri7Yn}|XO}S;?w{on!awC?<g&{>g=FdN)01m#7Ar*Y2-OI4;
zqif&}&u+K~{ClxiL*(O_nD`zTIe;NWJ{B$CWeg5}kRe4r-n3tQ6<3+NE(I6)*xP#G
zYh0xVLyCM184*z&KkqokkYta7;z<E5J&i+MfBk4v&lsE?Zd35l>e;bzc%=I>qR7Xc
z8NV97YJ@IOE-<8MeO$kC{V&`*Me9>;k&h!Szl_Jou?#8lapCj$wHO)8kRl&19c^KW
z+p<gp3NG@odZYb&aFvr7Qsm?Qv#)1h<PC-t`RE&PxFX*BS8PbZMLtFkzc~S)Sf0X=
zA|GGmAL?baNAKeULefZA@NsgL3xjb}R&Qj=Eqi~C>)w6?Ffy1SsY-=;C}YgWsu=l#
zAw@p+J{oK$c)i9HT;$`$RiDGKJWCi-<YR_w4fo^VZy8eL<H=ZuEygjV-&HqhLcv8o
z{$77)Ek>?nNRf{vqMh4g<X46i`Iu#R;Ah;H?V3_>k&itbb~H6U%hmh1k&rYj6?~i&
zQN$DH{>g}<_0g&D9y9moJ2x}smVMvqU|ei}T;*1Vq~HpQHx9d%9m|uxIaMk0vFO&v
zZSlK^dNQQQ$2_iI_hIBAh7|c&x#szNc$p~Ff`W^DY}D1_3$Ai3LyCMnxwlMb{0X~T
z3@P$)n1{=F{8jZjEh)Ij$I*2*B^t-2-p6o4(il?kaZZIYJ8<r=j41Lk^nyb!<4s`w
z1l+TgDYwe`9J*8T%HfUSiGhWMmR*nB$B+s>5^~k!Ri4_^reXESZ2wS|)RtxyCuG33
z6^8d7qbmC|q=JuxEa8{$&spG<!4EK`f{%nuIGKL{4xYU=1y}Hqki83?FNC|tl_3>;
zB;>~n^*&(aL539h=ondRJidO+)rNwLd`x%3b_c$nGlY=T;R-%ZoagU@i#)@KA|EfT
zFTVp%z{T2{a#s=US8xCB_|rHK>E)TskP1H1&6h^C16$zT%Podf@R5)+2M-;Mk&f*s
zICYO%#R*x!uhAKNoH2kQ6?`P*<I}m8;f=vPhE(v8kmq0KX^g9^(w>4V_(;ghFCF&d
zDrYjJ$j1|l4wl4K-eX9Sk8RxTiW;wS_3NW!2UBqB9kV{tJXHPQKex4!t~se6=~Ed|
z<YQQ3`HZ+J?=YmuM_WHXXN+|0NV!Em?pV9EqH*i54?dG2MLxQvnmJyZ(^D?FcNtRT
zW3>W-7csJm;k4g>w`^<3&gXQwIG{Fe%Rq({`8e)TH(QK+$dDo*H;u@+93!iBrr;tU
z2Y=n`f|0WsQsm>=jE}xs8hTv&>3w`mNNP&6KGHmNyK0p$c+#lU#gtoiKBrLRzdi9M
zv-}xS<l{lNPiFqi;Vnaod>nW>pW*W{=q_-Bt`uD4<AHWf24dtAh7|cYYF_sR82OeV
zX$DqUa=+MQ49Cbu-6%K>A_ZiLfNn)Gaw$WKd`$DJ*w~DQ?$Lhw>GC~8ihQ)4*WYk)
zgQm-R-6^=p#}}_ZM`$i-KfRBO2}!vXd~7z^A`dR|IU|bJNBbx93^zSd?mC8}>wo9;
zY9b%ceA#E%L?UDeLyCNyF!XT&Jcbe&Qskp;j^k%AvO!M@F7nZSK*h@#xr8A_KIZTm
zWVj=O+VU+!ihN8Q<+leT8~38%G%ghsAANP%EgXC~LyCMXdfPh|BNG`?!AII%x`kHC
zsqHMa%QL-?&0I{usYnGMho8?9fQwwih$0_XK0W4xk>40n<m2L{Lvmnbo8FXL<YQ}}
zd4{k1p!IPbLyCN~OzOA^Uq60lNRf}P;>z#C7tS5}P;iltr+?&Jh>=?uQsm>}=eg`L
zGF@M)QskqRXZ?H_>B5jS)D;x})#JlO+~fNgQo%>sU6wk!qEK4HAkuz%AG7u|1t+3{
zkB5F1%Yw&H7e*BMSjKbtM2y_dkRl(`Hwy2Gks10^Zjq0juh<sBz0;c^MLu@vy~fO$
z%e@RK@-fZWG%s-QtgaMX<YS$m!>Z%p0~k`|W6$EJs^Oc02N_c2qtldoX5M08HGqPP
ze5_yPgyG{7Xa*k4kYta7;vUxV^YMQ5gc0e)K1QYB<BmB+CgTpz?e;gffhh8^c}p)d
zkHtM1QsiUNc~O&%_p$U>6UP`*<YQb$&rf&)&h1XYMLs^UT2vFar58hrd~|i*wH}Y5
zlME^HvHr<(X8y9Uz(5Kv^ReWD5;(XILyCN?yfvm24t|ayMLs$|K4+$Tig-|Pk&i1L
zj96wIMEdn{G$CoEEBJVCS7KWuQ9sgS7*XV7+NIOdVr1z-rredNN`-l-eZcdc7&(O@
zMLxDKT5K~OL$?`H<YQXLdLJ>evf-5Dp9^QFij_n@hEDRTih~C-q{zolPk#=;$R`Xb
z^3k$<{2Cm*wig8#`8c3i6EkfY!jK{#U25<7j;nmbkRl(y78@2}TqpECHXdvWPQy~c
z$LLiqHSs*Oh!I6T{#rA!CC;6|kRl%kJ-4iYk&T8>ZVIlTc#h_)ZsXv~8B*lqi6UKJ
z;E|rlkRl&*?Xw(&kuAL`xX8zQ2@_}Gwp`1QA|De^G&FPJ{DUDyK3arKHuH+CjzcN9
z$j4@5k0#^bn;25$<E+~!p5gs!>S3lTX$&d&cs6N4G%m6|BZ_<seG_cvvG^v26!~b~
z_k<b6Q~OYEk&hS8R-Ax?cV|dyO9jRIoUWf6E53^%MLzcR>}}?ht)(vo7y0N{D|a3o
zybnW)d|YkwW|wi9&~LK#Go;AJ`vr0?#<y%U4X5BDA3wGGX6C~seHl{ZW2+ejn;WM~
z{rY%-kksJ{J`Q<Pqa8j>lXHYAx9s~?2OAx^jGNM%Aw@o}FCAasm|NfBrx{Y@<NNiW
zV{ny)M^bQ+kM-OCGanx@7|D>-Jqn5km-Nq$t31z;A|Gpg$@T~%i;kk;A|JDi__Q1c
zAH$F$9~+0n{lZmVVn~sXFB^Bwjgj`FDY(eT`L4-xjpI`9<9I?+?<n}Vw$H|YjYR!O
zzsiWB_3_il<p~&BevB!%?E6;X<vdSf<aCA<`8dB!r0LT{`r!8&QsiTvyOxF%XXwdZ
zwXqaj<YVqm<2vIzmvb1BdR#&A(h0K{V|iXNq{zpjO<h{!CAaQ43NG^T-Q}4v#*?A?
z?pe%`A|G$e{%E+(jk@OpLyCO7(lX(taa`(sY-TvA_4keeHKl@&uIH<S;@$~oM3IlH
z-Z@Ofxj!?cXno9Dcinu9Y&C&$i+l`kn%2w_gEb5(^6_lLH^XpSCNreS$D?P4&&9#p
z_)&0?k6u>44Ue7Bu#8|x8bk_;`@43Wh=c!RNRf|uM-(;uPf?Za4TH-#(nUTVShsNj
zMs8$Ck&lbYJjiAYuJ_SmlBr6{t>EK~_6J7c{c1->6#01GW`-~R_{}bc6#2NbQnA;#
zDYH+e+#(-;<Xid_Bi$HM<YSdJ8RGGq6c00`f{%0n#52{7A=)ybb&-CVu$@A|MLy=N
z*2DBS33}vch7|c2w=QrtULRu_lE$Ti;=}fp^~URCnW+?9<l|lU@F^HMjUh!ozM3#G
z$oQ#Ky^r?@NkuC77&gUmDsIY((@eS9CqWdN((+o8FU~!aAw@pUso>#&k&hTs<m0o+
zzPoYoTK*JV<m21z)*o<{3mH<uM>+t~VB-8j82OeVMLuqhIA`YNQ_ZGRaFLHSZQ5Ai
zD#IC4<YV=)I+l1+Pi9CO>I&mBuF$<47};e81sD1FplY@!czxVMNFpluxVzbxEBJfm
zmNQL7vR8m8<lZpA(a(5@NIwC)Go;AJYadd%;||}&kRl&fm#=#o-xJI-i-L=Mbo|us
zAg<DdAw@oZdG6dzTP?MpzAg7Nq{zqmw_|e{uX*&y+yN9^!ADxf2b{@&MO(qOfuu)z
zF{H@H{I~17;qE!dkRl(`mu@l{Zv_hlQgE_IVW=M~6>tUnIM#$@FV|4;(PCtXnJ4X+
z7*S!rO1%@f(Yv%(q}J*B-YFSm%w0+LeXGM6_M3U(?s$e2`S^7Bk#qR3#ji4?$VclX
z@uiKs7kzN2*%VylqwUbBta!Sd#gHN&PnM|TjTL{vkP1H1D*ie1Cc^_Abg|cP4h0wa
zIC|avEXKcN(zoSOh7|c&;PH%Q*vFR)De`e@m7J#F`u%EC!)5<}SGnxui-M1D)7*B#
zi}(sgRPd2{$2;=yPK-=uNYVP(yHoi|_%>sgV9G7>F?jRNNISzA(ti35-_4LBAM*|@
z)e^tlzu-KoQsiTWsNLJ~u$<12A|EIA^fvP+T-O*<<fG#w&+OR8vWDAm#$hS)@o{Ur
z)cA5@3PXx~9ChIFaQt}q7DI}Byjr%N>7#{uA1fMe9sLbX!_usew3rpGJHDW{$I||b
zeppUrM3IkYEaq;+^Uz&}6!|#p?BP~e@tO-MHw9PNYIq(!WrG!8!jK{#Q_r~481Gj<
zF{H@H6@wR#!d12oq2MAP69?>?jyDFI7*gcpq@YaSaFtmWQI#Seuhxibgnb;ykRl&H
zMMrhOTi~M%Df02=g54#I6OrD>T!zyOe|@AeWY$Mo%+@t?>5Z=@1~Q_^$E{mq_haNS
zh7|cYYG&_cc#l<J3FQ{~STkXTnM=|U3`uRNpm=kOka4)m%M2;<aq;)pt?-|VmkFid
zA|L<pZ?zl$rLP}DihOM5-Tx4tfiE$n$j8--ZbTVJx_+G~x0Hg5e0<!e=J|4lWk>tz
zky9B`<m1ogJ$4y~y57emLQ;n-_*fvUNDkaPt(Tc{%g*PdK5;i0H)R+@ihQ(6n9;(R
zTi=wQ8B*lq$_Zg<@dVs@IRzK_SlacUO}NSkhNSLMP&`wKb~d;ze>0@WN1tB4e=hB{
zO7(5oc?AU*`S`tCfSKdP+Zj^iW2<Wi9^kgj5Jpuh_()s9ZuN>KX-I7gqYvJPAw@n0
z)+xIU-_JQfNa`I0AFmWx5`}kySy!5JR~4;~>H5cH!OO%Th7|dD?dqyAcmh7fkRl(w
zESJy5H(!c{Q*e=wcG;U2$NSZh3@P$))cGH7cqbUckksP}irXzJ8G*Z}+$st#@-eAb
z%bNIFd<H{`d~Dv(X*v%6jv*C%q^)4-SLaXQ?rFK2f{T3gYV~ENan{hUkLw6YO{w5x
z<6V_!<KFqnh$0^+$LFv%P8#}osOuV2ZYPnCyM32O<7=L+45{EF&6d}`j}Ot_8CodC
zY?*y6RVnf@>Py4j8ZIT$n;}I$PQK$ARl<POe)_hIWk`{aUbp@K952x3H$AfMItosM
zNI~(JZ%Pls?_XWPkP1Fh_c*V9wo<#XoU$!{GNgi!g!J(p;H%-ZcRT5W_l%(6A|Gd#
z$a5I`c!ZFYTfxWdFKt`m8|qf;O-0JSZ{_*ivNK-HMlz(x$KvfWWWpVOl_3>;q}kFY
z{nf^JV^C!S1sD04`9i1_M$ThMk&iypCf~!|^Ohk+K5kEC<%*I2Y^2~KAD`QL-^4w>
zg&}ENDk#3VVqwR^2642XUY<;ws7eJNsmJ4QHmQM^+@TC9^3mo_=~u?3N54K^AS4y3
z;A5r_J5S@@DYDs=TXsHY#PNJnaqmoINRf{j;_v3LH}s75)A!C@h7|dDw0-hgEKl<-
z6kOzE<zru>@LnT=Aw@oh#|DhURi@fXRf>Gfk~-BQjC5g0k&pM9SE-H%(Lsh3`RMno
z^$y&Y1-4Oe8tMv)kLYtJ00$qzkRl(ypD9xa`xr||A}aWJb4M3<Tx5yurrfggIq$um
zEyS-ppURLTA8Vv{@W)fzbA}Z8=<GeC6P`61?x5fbKGKG$cf-hFtu3{osh>4gF{FZz
zg#3{8@dWKitk#}-<S&L)@R5+|pJtz=?Xk4~qDS`LNx>C-BxKC8EPqbEXj>RPaz8^V
z_(;gi*7f(}w#>JSs#Nfikaf@Pf2#dU!|JQ_Wk|9|LGeZXG8EI0+E2eeUNRva>0-~U
zk5uG>0+lUsk)?JUb33ZMKZlSlk4MhI9X^#I6?`P*tI==s;41Ghq=JuxY_eg%H;k;d
zhk}cI?CIp?t<4&m=K2nw&yXS?H$Gq57FYR}Aw@pcab6Rr-PX`5)mPbkF9jF*_$6**
zRjtaD!PhXPf{(PhT=3wG6TbcZiy;+!B;@KVKStxFr*k9)7x~yH=-hteEh4>-y9r4n
z-K>vPWa)AdyKwF-`%Fc$BX|mv#;6jO(~U*yJKU8asY(T;*I6eU<8`wh8O4waK2q@D
ztsZvxNrKgW3a;QIA={OF@B|}=Fr<Qygq(8t^h#}{Yd?MPQw%BcF~`H>A=+&X+Z4zm
z2Pn9Lk5uJ=z2$G<lP^;lQsm>{b5s7s$eRo)^0Dya;XUwBukbGg7y0;l<fC=Q?$P@=
zgOD^V6?{y)Y4V@NOdIX`4u8mqwB#ztQ)EbVsIf>r()pk%x9s~?ryhQY!ajyDBn4Nf
z@?x0F9gKX-kRl(8ekx{#gEu`y!9_ks53M~PBUdw|f{!FmyOXao;l2M)h7|eOKDKHt
z+?L%AQ*e=wpAQDlz`=Jhq{zp1_PI0QDzh4n9{hKh#?evaW07RX9Y&<yM>j&!7&7al
zmekUs`1H|TO8R_yiFYqij41MPN6rtf+T@#Z0?vQLlw0<FtEU^Yq}MK?iWq)+#V0VN
zf{zq@TFmW<+OSM{&GV2UsVx;0Z#}!=pUtKAf1<Cl_E8Eh@-f}g*M*E7u179mNRf}b
z(-a(Sya%C2eqczEj}>Ciw!~F7IYz-nJ|-6})EfJ^k|9MtCe;qK#mHoa6#3{;p`f!7
zsrRwdaZ_;WaI-$rY}qvOVRyW#-p+_3AJgm}WqA04PWxv$K}Cx8tGy@pX@GCO^k+zs
zkAqTejL?FoyyiK^kRl)L3Z?xQx25e#3Qpalp!n3f#SMo_QCp5<NRf}jT`St-^)Z$q
z6@1hN;(wER-%|hmQ9{bLbT~!9MLuRMyD%f}@j!+Y`M9)Km0I{N@Jogi`IxF*s<y^U
zGrf<^PMd;L?<n}VsFY&_z8SiT5k)=@^>E36J3QSPDpJ8m>hRS2hyA%#owCFGGNgi!
zG!gkXIQ!Pvl=@{NiXlZl*6g<SFb<yoECm<&xOi5Dwir2_A*sg|6o30Vu@y$fFr>)G
zCF||$Xq}a^d&)&qaFLI1eptT7-7|wBMLyOaekBb?K4eIdkGqaG?_%6*=zXkt&J>)Q
zQo+Zl%xNy*-kHmYA|DI1N!<-2Uo)hFk0ejUidN_Gd4Q(pDYwYSJB~k+@dM}e3@P$4
z*1Bc7B8Fk9{q%}wy+BopeEgBFp*ud9G@KztK00{Se_qy5q4v{Pd7U9?5Gg3W=un=l
zxXNZ1DY(eTqaP|4!hgHAi6Iqyq)9z*d(W3zkEcAJllKx;De|#yV(bm$_C@dGI6_ix
z1s~5@r}DrTdsi4y<YQb+oDc3Dr^}|?vhQ2n4SU-Uf5L7FLyCMHeIv&;96VJFRVngu
z&e|7KvEptFDe^JW?O{cXyugqmAMJYQ_Q2iac!h$Cd|VY*uRBIAWJns93W{6X)X0GE
zuO>01f{!$*uRm~YCBDDfDwcwad|WYOU{7O}dLP#kl8RLD@!x@EXW&Kr8zYK*JlgVU
zCF3HlpMX2WnQ~Vbt&fAO``t3mLwe)}h7|euDx}g&jQq`zA|DrC2{!ZE!_HSJxX8!K
z7reUTF|>^#MLxR5TYSUF^w+3Lk&it>OGInykoMDej|)SJe7qZ6I2*neKfsVQ)D;x3
zwJlG3eAg-8bqX%>@!sG;i;Qil_tBe>L{#w6bMNR6xX9CtDDttfgZFv7Uo9MO%3VX`
zqibM~x%ldS97BqH%vU+*GaURTLyCO7_o4n3JS-gzyPCf@)N6=*eA%ezD*X44vl&w4
z<IaPwNw~^~3@P$4^FIYTV`QzH6kO!vW6#cJJ}1AJAw@p!8S4DfD35;Dc*l@rkAmXQ
z8onD~T+Q@8HZ`mt|Mhrfl1IVE=e?iy$4wc|h=f!qvQ3ltt9Yb;XGoEc`FkB4g^?X^
zQ*M!u#dGD#h-Zzh3@P$)w0G<sJZogULsg1=jL*C*n{h*=A4Bd8De^I`f2Q`vF{DQx
zW=N5b9m3qqyjaibE(I6)=-z$cV7xvKV@Q#YZucfn#P?S(F{H@HR2M3nCUw1!<?oq-
z(@0nFaqQq#udt8)j41N4{K$*VG4cUJQk4pdrz*7e2_ES+?^AA(j}8+<<M1t_P=*xw
zc-Xy%Emr&+LyCOtGUIG*>|>_~6kOzE_bBHv*vHKbDe^Jvy3V&SGTlR}QsiU5>2^7>
zkG&aE<YUO$1+%e_hZs`iW5DIP$;L}Fy^jSSnS#@>RPb?^T{kx@k2fQVe0=I$^%O>)
zV@Q#Y?N{wuh<&twOt~qzg5qJ9?tj5PPGv|1AGN6eJ%;O=bZ%NP!@soqg8G%`F++-c
z^!91@4sQ(pF&xeNyCHHE`B<{0y94f?2!<5-7`QCq1V*NMN>z${483R@ihH~#Ln`=4
z-7~9t)jQhR{FHxE`7c9?e4Ldxf0S_x{C_?^GX<wHq~PPI&5O3-ru1P%k&m~>*)+t+
ziwr69G49>sniyH?Ipr4lXrJs{0#CqG8IsykLGeizNo6te0Yi#>eA2baS3IZJenG(%
ze57INGht0AKI^ocAw@o>J2j;;uF}GA&+PB4QCZ}p`|N$Uaa;CgNChA1{_4CizX$mB
z@rM{v<l~^U9oiZ%@AW>~yfOu+4p;E;X}kBA@jNt?5k)@sYY_eeuRNC+QsiUi)=x{~
zouI>O$}RG-&*$`0aPR<z6#4jIOsAa~`GO&-dlVFZG5x><+?GueD7b=;G%RhxFTTgf
z2!<5-cx}cf8;nf<hN=|#cq8?=vl!{dkRl&%S;wEnv&LzL6#00z_`Frd%L%=Y_HRwW
zsdp57e4cTO8=f@AGNQ=Gz_#<v>;!K!q{v7A1BXxGrmXpna*KTIo@dZ2{LE}ALyCO-
zwf@^kjQqinA|G$>vkt<;(&aq`ryf^O+^OZO&m|4pHtnb1RYx(T$j7LTdH3Ky7ccjL
zsucOSWd4f7xGk43q{zo<iAl%t6X#@x6!~bmC22n1ul7zf1*fJ|@X@;eJu7@(E|L*N
zK3X<QT!hC^fsa(A$j4g^23Tp^{*+t)u?#8lF*^J7Fx=sH8B*lqkipM0<GHQwCkig|
z(Q|vF9eCRo&X6J>6VIHgi+lVhL((8pP<&gx-UD%u_x()46?~*!wS7Cs7WgpDF@_ZR
zxM%uMKRj!cOrk19J|2ADG1+(>rC%Qx5R!5$_}Dv}O9ebE-!P)c$1mkqe!%jy`C`f~
zJD(Hka&{|5?qW!hj~`$C_=J&pzfzSVA192sxEHtOXoeK|IR5#l%S8+mk@nLsX15qp
z<l~IW)7If-qW(7uF7olS-I%=C#|Va`ajBrVL-uaHa9gHNrYc1~W;yaAAD%7;GNj1I
zsW<$08xNJ}eT*g~6{+B3D%&1gagl|;n{vzEpYwHO!%OK6<461H$Iv8(6s?b)YulbT
zUN`HJ7a3CI;}eI3AdIy8LBSP#q&YnxX78VGh-&{uU*!mf6!}=kZmF3MwO?jPk&kb)
zRWi-#`YKEQq~IbSM=c&c7T*P)!jK{#ulRKtitiZQW=I<9W)-LInbkJ`pRYJ;7kv8Q
z)qYWMk&ovGO`mUk(4+S;h>%1y>mwCesA9Wk+74LT6zPk6%7_Z<BOwRnX>?VaEw$-Q
zkF5RMlv{Q_r*7uS{}`Y1=#eWJQsm=PpUDsK&6h-mRPd4Rl=R#6eLr4u+gju_-e#1Y
z&&eM$b`D1FW=I7ese8gR4XvSFi)(A7zAf{mqAEo`Cbmy@#_Qt<h7|d@??&u+<DC+H
zmDd<j!AI(zg!6qo@eEwn@Tri$cY$k=J!TarWXDSOR`~jHq6x`fCa&OPNctOfw5d(A
zT%Y?oBZ_<+{GweUt+P{}qpy(0n7fMX`&KSD=9j}wxsV}6KDMyl;D^W13x*W==s0TR
zJ7e$Y+p?MARp|e9c$JEx^>O=}k&&88+E0%RXGjGfX$)nm=H`nRv+oQk@^Nglqr>oG
z)-fFgSMZT$jf95@*R>fq<zlvjAw@p+s1V|YC-rpcsY;QLa~fW`Yy2dLetqmtNZJW1
z_!$0XcT=r*Qg--eMpW>TI=s^7t_zHdxPA<!&0xySzQSd89-`h!UNz<oo;6$;QsiT-
zM+ql90q<i-k&n)6a(%|gtd<m9!AA<-&ga%Htu3|Du5Zi!3@P%_HI-!*EYD$v6#00i
zwewbdi^w`71sD0a|IE=I+QvY`>Vr>UNRf|Q3XB=AwQS0v{(vDxKKi=%uV&n2>3yu3
z$rPN1rCA?Io)<PHPvG8J!iWk!(ipls<ny1;Jf$2%pBR#64YNK{l{a6^8i}`Utus?@
z3a)@GH|BBe3Wna%e)<mI$&d;@Qt%6>Q;*Zm=cIf~Y{@KCrGk$Xy#3dmx$$j{c?>D?
z(IdyiD|ln@ks(DsrW%}Q5}t@UWToH=K2q@B!Cp>So{bDC@-d=s1H-vE^sa@p*{Dj9
zkN4K5HJrTq52^RD2O((;DfsB`I%pI2aVH~+eEc}QW?{VKX3cKOEqi~?n&52BG1848
zMLvd&&THlcEk_uV+EPLBOGAp}$785K4hk;vvGc~?v+#r05ezBvv3lW!i*S!$Wk`{a
z12e8Vijfs_QgD%vPcM{Ph}$xVAw@oVzHgKlx8-w&6#00(^7lXcHf?O`eQc7;6r4I-
z!N>H2%0%MLWf&tW_()URhK^;;yh8FTLyFeNY7gs0;tp?{n{tbM92c4?2M)f4Aw@pc
z>d^TGt}=Zds*<`#LGi&Inl`{y_G3tqk8ZEJdtl@th7|dD&iTqTjLespf{T3Yx?s_4
z+?GQbQsiS?;d@(gl@}ON<fBE+#!i}xDSa%F&lH?`N5RLb6Y83ofc+Rz!AIJ*`RB8!
zru|E6PW?{sE<=iZ%$xT01Uy?-H{9R)d#9wT$j7I?^AF*hFAEq_<m2wHS(e}qf6b60
z9}CZ%F#;nS=cnM*;|hwGtKG#+TdrhCk&hR)tb30yCz2Ub<m3A@qwnD0y{sv?$j3gx
zzaJUp(T~f03@P%lS#X9?#*Mmueaun7R3$Z~f{#U>MTFpaXaFNB_(<#Hj2rVyVtI}+
zq{zo3$@xbZubcHvS*Rf87Ww!tp?oon9Lta*A7{<A^Tlm>gCRve-VDuS=4EhI3Q=&8
zkD)&KOW~0o%#bvQ6ck@EG%g6wZLb(o<m2oUkF(;oY+ysdMLvE@9QXwX4`WD?k1zZ>
zzBUHe`}mcRlv}~aPDLLVz(uyPHRYCl-|A(WVgqqgZe&Q2kF7E!RK``ND@;|2e2nQb
zXo|5Z^@{gqNRf}_>eWe)tK7$sA|EFO?=|z9wVXvLxX8zclgHTL>C%%SMLv4pZ((Lv
zeVQR@Tq-E;zQtz`Ud)QvQE-uu*KgPRbGtU>E!!~+De`gcqodBo(=>V??-G)VRPeEd
z>!GH&cWM_k<(8e#IbEdmI6N$uFr>)GMNWmvV`L&jihMlOxAqEr=dx8X3NG?7Xl$Lk
z_|D}vh7|dD$18InMrJEcRf>H4e!Wp1j2yy{A|E#&9o7INFEONokJ?E5?{7(GcF1yB
zdx%{m#YK;UJq4$suAq1`t0_N?^5|#a1q`X+BUS1Dz}8BeHMIYt_wf@UiKyVCPo4M+
zc%-)~VahH0zE#mukCtL&1Vf5^-1z2{VZO0297*~AOHzxHRHewri!(#37`OiV-s#Ga
zA|H3#&c1^We{W+*k&jnxpU%L+Gnb;^A|FTk<o)wVQ|lsq@cs-b^6~i94cBm$hZ$1A
zN4n^V9=!J#M&>O|!9_mqy%<v+@7o45B-x{&xW%*Z1ICYR>wSziA=$^p6?`0UxQ^j=
zA{yxh%NTQ4Rr$UZHD#_{*W$5{z6>eyar}}>&bZ2p45{EFO>LK}H5{x>Z7GMPeOU@F
z^6_=2yfyJ2%a0*NK2F+R#2L>T@eC>QvC#d;h6g&R$IF+a;36M)WFPnlBmEgt<YTPY
zMl)@Bmmx(y_O7?MC9cw`JOvl|SaxX0ZtUY6LefZA@X>SMD#N>7&_mJ(j3~OFGw96I
z%h<<i4yN2H=W|H$F|)k-;*ma&Ar*WiWUQTSU(HVKr(Y&sF{H@HDb>pUxv`uQ*|-7)
z7x@^}s<B@>LxtK;Uu8H$ihNwz`PCES7}6sX7*gb8(S+~b_{m<~iWFSrWBJDU*WfC{
z7*gcpt5-ujaF2grNRf{Zito8-tWv)|wyI<bPQy~c#|4Lbn(;A=5k)@U>etWA)2Po3
zNwbE+z94GOj95IiwQ;1}6kGvmd2>ZO+&k+TQsm>N&GmZX1CpsLQ<Wkg>-p!~jt}m3
zVMvjW3yTFD!c}f&NRf~B;R_oXhoxR|iz*ac<l_LRPY?0seFugV`M7wuTN+&DUWOF;
znDJJp;l?Wzy^oevO~GjlDfswma5@h>wYf5)$j8MEo&S8vL3^5@@0}A2De`gU>mB3p
zDsJaQxkWxMyKH|Jui~Q_lG;*1@e>XqxACkI%a9@;*SyPQ=95`vs!?!}kCzMV$%lRP
zXGjGfwb|_NN74e*e%1b^U7hKB{1!useB4xgqM1J#sal<ai+r^1{<AlpfkPNl<l~@K
z!Li1Do8HIwgrp8v@Ui%+)YI?;+^mKvH~W(jv%`{lXU+ZiKVOsA?zriDXE{SE_(;f-
zxl8WDr;EQcq=JuxoEtPQQS(vzFZwE74410^9Wkg{MZrfxrm}DF=T1pV<bH;v?lIez
zw5!fu=g<-31gx(zS52x?=HrVgrSJ^w&5#N{Qk5U(`z2w;FEOOZ#~O7G|HelQiq)dv
zA|EY=T@Nm8=xyz%Z_DWnDe}?LJ?xlqQrG*KL`do#1s`MF=6y60^+mR+ZOYAV5h;wJ
zzKdI>)%r^N>5&^5Qo%>+@Ww^IRW|-ziyoQGkP1E$GGyPftr-m!YCk=)RUHbh;3Fa1
zzM0wt-+WolkRl&FvYyI;gC{a1^|(U!G&r<!E#7N1s!PE|K6(UhdWd~o#*iW(hb&k#
z16TQ;Aw@p+{giGhuCi%83NG^T_ptn(jaBM>Tuw-8N(CS5&J1@l67|C}kr74v)gx&?
zro+hQ^-Z~*L_W5z*xk(C?{J0``Izs<6-zA7SB4b%_-H}Zw|KwWx&Z|j`Pi?p+g*%|
zU`UaVw(I={;o!d*k_M52;+4}5@WNGgY)HXHKJK3B)EgtWFr>)Gq<t?^<8hg`5mhPj
zaew2ixA1<o2O%l9f{!;>pSy!6jopkW^09lK8M$z7%f_bMviIlQT5{D6BYQKX$j88`
z@xd4w$&ex+GiRT+1|zdJq2MAPFHEW47b9I6Qsm>9E&&~Ij~`@6k&k`sx(vfr=4eX6
zX<RBO{$Oj`1{mqikRl(4m9jVUou?><6#2L&Vr+3^mHPEDcQaFPDpJA6osk&~uTw+M
zJ3JUs<YOi0j)o6kBjizr6s?a>7pynDT?-+tnp19(kJf2hl*Yqy2t$f|Y+muK;f2qr
z$`cGJ@-h0*GQ;Pb5VAlE3NG?7=eVaWaqwXbDe`g2`X#Qo%F_%f@-cte^Ib5~#_$mF
z@8x}U8tMv)k8QU95JnDXNRf}(V_&=A_3=C*iKyVC+r_VMaPJgrWy&o(pL6|n{1%*h
zG((Df?Cd^mB}QImNRf|2c6FJHgO~V+f{T32Fn)#uu5uhhihP{${;CZ|#xkVH#{zR_
zzrj1f(yb}D$Va>6iBB<dGDC`dtPyy$JPv-7Aw@o(c-id(uCihq3QqPYC?1wCG(@|5
zr~UNn<4hCMi54>jAGZaaU4@H$#E67cD00d2kW$7X^_Qg1ZH>8|Wbe=UP&;cR?wt^Z
z6#00r+3zTfOkhZnkL$}1F}&~@EoKedQE-uulMkM%h>=SfQsiU8y^eh_@&iMPd|bKw
z(E>cTHEU17MLx!Fju?omT)~hcAM<p4T?1G7i6KQk#`S6vXB_H!ADeeD1*erq!N)t9
zhS=lWYZy`F<4*72BQP?VA*o6Q#b1ss7mktbI#O<tkCU%0Uyg5UY+y){k3G{o$cB$q
z|6)jykClG>FujmoKexGbqTnJQlRSd+;u&}kLyCM{mL-+pnj0O#%hH*u6#4kpwe=M&
zk1Iope0+5KiQ&5dXu3SWkRl(gtQJM%{c4Ubrr<Oz6?~i<HR3QXav&p$e5~ES;CS3S
zM;KD%W83rr<uKB!E9Iu(3W`6R-t!su(VHPfK6?6&HvBmQ8kVORQsiU$d@qM%q)j&p
zF7okY*XRQHk>&`76#2OSY7WB}qR>c>Wk`{aA1k#yf_*IAoq~&eZ0T&b5ueZTV@Q#Y
z_IEPu#Ovb~Ledyg@Ui#&;@ffVvOP?>*(Y8VM*4l*QGeb$t6}wX`Xq)F`Pi`Wob$LT
zuQ8;^$2sYSm&d_N^`zj`mI}eM%_?b&krNnF<l{~Ek`3^z5zCMw9~<WSb{C%jDb<UD
zi+mh$vRQjv<#>h^`S`h6!M+$7%aAf32X{VVCb$a)7x|d8WxaF8xlO-c9ZyK=a0MUN
zcE}%tbKhV@(fU~Ye#^%g>0o%I^xv&9rz#>Jn>yFB#v^?iLyCO-p1b}+toTia6#4i%
zv_nQ*Ww|~SoVrIranHOK&KNnFAw@oZ^m?0wgI{Mzk&n*V(gflvOZTPVA|L;q(sn;a
z`Z1))#|haJ#$sd~LyCNiuq$2)?^jFpGX<yKQSh<Hvs49f?@VGuk&jolOdVt<H$#ei
zY*!?v8%CDuPq{@tb_m@z1_z(OkRl%~YR0|5RmL!+$j3?hCf&wJdshlhJ+7d5M_XSr
zchtu+q{zpbdyn<SZF!j?MLvE#T<9kbUUUEj7x_54QkzQ{If@}gK6WeAz;tP*Umq_J
zlA2P%$I9o1m^t)b%*~XW-Lh5a@X}>kO~koJGNj1IjS+=gVdQy+6#01ml-GKUEaFbV
zMLsqf@4F5U%MlDI^3mNb%|2Y^S%wt(`21DdX&7lUkb=`7Qt0tkY3`iC!F?D~<YVNA
z4pniLrx;S?V~P1wm*9O{0S^i;^6{6&nmD{Z4kaYzR`BuF@zI-bk!KlEv_4k+_w*2a
zB-VD2DYxu=&YlbFrr;X}qZv}<<HL>LkK+!%%#b1<mpl$#g{v&?Nx?-vzP#Qs99KDx
zAw@n$e_fgbR~f^QA|IO%k1mFhCA}y(jY|c^t$MBAgl}Z|F{H@HgTF5Ri;>qEQskp^
zmLq=HM~A_t;8di7k2QV5X5k{IGor{xi!-sNLqz)fIrkV+v_7_*wCpz?mQ{yPZjq1W
zUcAkK$4~%6ihS($yUGe&<wJ%P`8eU@8#51HoxCZy$j6@(qx^C3*$gT2(K#`7Q;dAV
zkRl&HjJQ1%w`I+t6r6^-g5vq^)-iL6D3~EdK5k4Modx^&oRCCR@bO!w;kj_`y2DJl
zW#@C6o~~`?jMqYj6#00j#Sk+m(Oxs8$j97|SH$2k)WC;=i+r3{qF^T6mZ1zO^6^N$
zL^Ed(-!i1g$GR6*nK>cZ*q4Hfd>j(L+RS0o<qRqE@okR}W{$*uWJr;ZLDi=$#Xa7_
z@J#9NeMZ^$tsI|O|M?n~=A{1mag_<lUe2iCW07TV0&tPv7*Vu7hFe7)z{s{EjJc}`
z&*x-0Y>AQU8B*lqut{%gV&pG|6!|#TZ;=&7b{a{+Wj@Y7{}L;{g&{>gUcdXz%*G(q
zD5_HA<GwepX6~<cWk`{a8Cq;Kvx;wJNRf}ZCcnOpw}NR$Q*c_%6qek1(Oqlf=Z`%J
zNh^<nk8dw|xZ~@`NJbR-7*%xIX`DOD7*lT9`*Z4Si~o#~t_&&i@!8JP>2UBv3@P%_
zd+*goxXN5(DY(eT><2er#Xb&VNRf~IuFo-Zm3xFCMLuRYnKlwvnQt5g7x}om{yj67
zq@D~Z^6^u>O0jslJkF2`K57R3_hN)&_jCWbBu%+KS{v@W{<q{-qhYDw<M!6Cd*G%V
z%7`K#yFPX~j&q-4NSZYi=Aj$jSwCQ8p$U|mf-4}`S88PDG@~y=ihP_kJX<|n<ynRl
z`Izx*FJFu->_@>xK3=vdYlnM$BtwdP9F};j6Rz?+LyCO-;5Xk5Ba2R?;36Nx2h5Ad
z$T1A5;3NG7dh(`+yYTg63?XR@Dfn3A<?$!D$WoI`xn<{b8U*ajj*$}?Qsm=~tD#Tv
z7`o1oA|KzDzE>DmS#~l7r?ym3eE(*r8Mw+R3@P%lZq%F=xXO5j6#00>@$NQ^beKZH
zMLxDlIJ8L{q}oq^2hX1&MLssEQ|lDoYg}hYk&k72Yz@Ikhp7}?<m01z)lFA>`s>H(
zgrp8v@Nq)ROBZpGcNkH$KBj6O9fmu+$~04M+4&sjS~VA8WFSL|d~}#{&Iup>e#DRp
zKGN>x#qw{*v{yQ5C#dwpvVlJZr|wZuJhAo|Gq=CP7*gcp+VTai;2uw6NCh7$c+qL`
zXYjj-T2H6oA|IoFr%i`@d;>#@d<?nuA_`BJzZp{GqmRS=CiuKu#~G&J)H@13CI%#B
z#kqGdqR7XU@7#M~WQLhkq-cG-TBuhXM!GPh$j5gc+izp!UWQcgk#;Y;Zlt}0ky#8<
z{k@u~D)RCE;Se)(TYrY69#>HO$ys+ZbKAcRso*08pS3mVG!C9KfP#yBe04FtAVv;k
zNRf}b_m=R*J|1C6k&hWqWUOI)<+*-+%oAt|PED!c<CXpPxp8i9MilvY=<c3|7<rl@
zMLrhqocksI7?n*B<rev9AF*};UM9vdq{v6#$TR0LQv3YVUmu-BKAt(e!|==&{mDq#
z*@P7N*s;eGGatX1%8)dO6cpb!A*ii!nb2<x?lPpv$K}>mfyR-pM>@};;36OU#%}6}
z+j0>@ihOM2F=@K-=!@RRw}hnJ3O-r~KbeJZGd7)T%FQ03DD+PE^<8`7+$$JT<m2`9
zW3yq!KQp9)kF>{Ho;I+brnvU%Lw$$03Z~#9A8Vf|W;$K0M{Z(Bk&kY5lMH{(fP73d
zkE#^;ILGV59o*wR7*gb8`Xkc~7j>x0oeW9iQehBn^3G~FN`R0V=TmTzk0)9-i^akF
zGNj1IM|QS`6aW9ccvkP@K0;EF3O>eVjWIl5MY(esmXE)4y6pQ_6Yus2!^lAlDe^Jf
zjd(9RLzUW3Khlpgq{zqlZQnf9dPmb-k1Vs0f-Cq)io00ki^IrC45{EFA+tBl9D=XR
zt}~>_#}%>1M&fN-MZ@h5V~>k`T(+X1>9aEWw)AI6k&l&zZF9p_-e5=?>I#bQ{Q0vJ
zMwVYh!9_mC-k7=)-(Q_VNFpluIAGP27kJXR#fYN)YQ<#d9{BIfDlRtVt|9U<I(6Vz
zT;()|RPd3md796;aULUYF{FZzgsko#Qo~H}B@|r2M?x;Kp4l8%IgKGjK9;^28H0!A
zErt~NSa#32Y4|*Og-{AE^3i|n&7-)=DGVv{F<nx?M~sYTNU}#k@sF88Uul!4_S3JA
z<(3+Qv&Bro$J_~SyK#}z8Bye8VEvkzaqrw_NRf|qPjnB)RXQxA+#(;He|{^Dky9B`
z<m2mH--qGgHyBdn<06+uRdAJMms4<&kNILxWx&Wu3@P&Q@!*cRaqw#lDe|#t^l39k
z3`(t_;36N-G!F5{!6z`J$j1qZ%PQdO$5=wrNLTQ2U5RHyaFJyVo6i4sFV!oFd|Y_D
z`Ci;RlNge!RG5b{`p@#iRmL%-$j2MGZvMc?QY$IA$j7c>0hcjy0z-;?^r_w}C%$lw
zWk`{a72O)x;3`XpQ*e=w_m(-P!d3b)q{v4XtG<pHd5s}OKDr%ux`D5w%B`Z{A|Ji3
zR_TDRAEyzLhNXg!n{O^HfHy?<8ByfpxxU@b;@nkNn{qpfd~ES1(|3%V&5#saLGd*a
zRY&9CPZ?6=W5J}1EpU}J*HCbgkITk(H=N!>m-h=8Qsm?5%4PQ9k^Y(?MLteyQ?v+H
zyun%uF7okJp?nK*m5Uit<l~R@$yYJ*EklZY%r|JQJHCEwyv`Jy#*l)KMgHw)=KVP<
z7*XV7+jSu)aqdKh6!{oa`t%o!Y#u?mMLu4$8erzBOgKYQTPi4C@8#-icvya6NRf|Y
z_GIdSgST2w!9_lPtKO{-My_E<k&n$5Wi|6x)5#1e@^M44?pJV?Z8lJFk&mUeXMBW_
z5ezBvF=+V&GvBxRNl5B&1s_{n7@H9n*=eIGx61de=pIDfA~|y6VY!7NMLs_B&TEaU
zOtp!s6!}=K_YpHshr2SQ$j5458!y9EZe>X79tFks4bQg$BhzlC;36Ln1q_*nkv$kv
z<l~TDK2EsDcQK^M$KZAC*W)TPY@y&HAN$)*G^~SYui?UwA|D@qOPGS!$4Ej_?<n}#
zKcwFxylu<2)s$QIeXGldbL_#nT^Um3W1C714X1@rQyyYSk&j^!xzk}}o^2Fd<fG+e
z>!NrJc`>BO$9uzbWyT}@1Vd7fD=5CU=twhHX8E^MaFLJ2x7nMye)MKYk&ljhqU+<f
zJk5|IAN?k`H}|5F9TZ&TWBq}b_G2G?2uV$;;A5CoL_3`O93zVMs|D9}zK)T0J59M|
z-?y@jo&O6D%h3!e@^N4K8fMOTU1Ug+kJSPOea69y@1o!$AM<UkZRXvX;}}xpquV@>
zM!3othNMBHp!hQz=TR70ayJDR`8dt5`Erc(V@Q#YeG3*b^RB*Y3@P%l*Q-wJ@%_~@
zh9&9m-B8M{;A5$~C4zA7sf;M{aYMTiM=<ghLyFeNZ!JceIiFK$FXa~bIOeo{ZCvF{
zh7|c&vwc@HuUNj%kRl&<zKdF9e88oD(q1)^f{T3ol6uWmydw%`NRf|o&vtx{k<S>C
z#-)Pd4=hIv!NF_oqu?SRzvUifx*4i(%f$>S@^NLS@1_&W`sa@y2}wmN_}FmC_G`E)
zo9{Q}W{)%#n(}PWu~o*K!1~-P8B*k9=7bu>@cGs63@P%l(qz9zxXNw^D7b=;+Nk;O
zuT$qv&s|nK#+mX%?Ryzg<YV&IUqQA8r1sOdWiG=X!v39rt1I|ORbKA*=3`L<u6PRM
zD25dIn7wS}yr~U1?WeEu0Yi#>>{Qhvn|4b=`{|LT4^nU%>I&oXLH|xoEDbpAr$>%u
zNRf|`W$G8k`_*Vd5>dg&%O`Fg#JTMbnR3hCpR+om*=vmSVMvjWhxSyff}8RLLyCO-
z6j^pRt}@qQ3NG?-<Z{11FH6<tH+_fqXGoEc?pr*}d^L7ILn`>FMKw4$eRP-0<*L=j
z6H&G(3a;QIDZYK@mB-q@G^{@OAcj=%k&wS9b#l|@wv->eKgEzDA6t!|^co+ZDtd&1
zlRXNGud8(Wv+*FketjHiLNa+2e6*_W`wV{&JC+ee`&EaTTgzc&@uSAvHDvG4nKa?+
zzqlz!GNj1I#Q4)0ah2y7Qo%<W>2|;3GT<r;9i!kPAD1SSERK;w8B*k<<H<~ijB~nP
zo|6nI@^MV@h-=!tG3`=HkF+^X!4-UDZJ9pg9R8gA2!<5-ILF2Q7H-Q^3@P$)Yd?!y
z+8m<&^gddjFa@WTN5MybTl<o@NMA-2`FQC_<Eq9<L*F}R7?P?~n1@>RPrDTNPVtkJ
zTjXQyf|;M-jrwqg6!|!?afx!cEzdEe$j3PWr}yA0ZBJ2fk&jO!&Nj#E<8X#l@R8&h
z7XP|6zMP0*NRf|m_PgsFN4kCxIh>~8A|JQsYH}L4<t&C2`8fN{!k5M#*ZX*%kTfh6
ze9V>beHET99nY9@JBoZ<-T22md^0qVAw@n0%qjW+-+Xz%kQ7`&@l2_QnfVjvYKGHA
z|6Q5Ya1{CYVndn|xWnf#q{zpJfQ|Vw7$#rsryrJ27*fGU+6msS)Zm0RhO{oyBORkD
zxX4G(F{e5jhov4logqa&j>?xbAJ4$I7*fGU3f{MCo<HYTwJy?ES>_xC7y0-oD0HTA
zT<U$CNJtt(3O>$Vxnn#YL)REl<YV6>*K1&8S;L>}{vGL+MLrI)wH=O;lNnOvV|37)
z>-hO&JVR1jDk#3iKP(rX(<@w{;0iv{7^*wwr!)R5%>af}@R1g?0>19Y@koEckRl)F
zPrq{*cTe?;6kO!vq5L_0wLeWw`RA!~7*fGU3Ld=tdmmio8-^75m?LXwJ^Z|*;U!aW
z>Tm@gg9aDOgb#l&XGD>YQJJ<B#_Qudh7|djHYrs!uCmc(%B|odjr4yXClA)9HqA->
zY`K^rMLyo_>g$3x>Tem6x<^6rx(}b_!EM<xhJuTHEc^UHO}ylWGo;AJQ5B~&$H=z~
zDe^J+d0#s`Yt*_z!9_m)obrAcMg}pY$j6wVVqV5^sb3%O5R!UF!N(3S+nvW-4To4$
zZrS;qM?vRaVB{2r6#2M!^X?7WM5q1q@?2*~1s`d)?DJ2drucqN$v6rw^3l3a=S(>G
z7={%2c)sD>aTs}#A*sg|6t7^nCnMe%*j=UIA|C_2J#yfU!5D@V`B?h>?zQO+y{-N9
zJ${uT6?~)_c#mVLC0dVb0_l-<hPzRJ_ia^0J|-;cWI8vd_tBS-)RYQ7p6pO`wb5{W
zk>?muv_AF;o}L4bbQ{AC@o#R~`JCIqiDtf1>CKQLAJ6Zv9flvFoMK1?AF0DvSf6&#
z<VksDmM5Nqi+oJAx#KIm#~R3xA|E5}Zn=bmM=>M~A_c{Z-ObSx&l*_`f8k{8agmR%
zxq6qt$i57z;3Lhz=d&NUkK1xDLyCMX)^%MY<J}j%kC|_pf>Uk<9}g7suZwf{XGD>Y
zJA0Ptg^~LhQnWsv7`|Yf@w!<*Yh=DfxkWyPu0Q<`M)qS!1s|!yKfZ5gI<29v@&H4M
ze0=)q@Elxaj@uMm<fC(;byj!_?9PxPACrgfIDq%7hZvH^rGnxWX0(`#H<y|2P;ilt
z5$j{m<0`u|q{zoZk00eT-dNWAxPg#Vq=Jum68F!*xzpV><(8e#x!J!&KHTA*7*gb8
zt`GCl<5heULyCO7v@N+9M*d_-k&jivdYk#GdfR){mLeYuWGESjFG<%hq{zn!-5hMS
zIYj&EXAO({RHevAJKKajcm{6AkRl(g;%7C%-LsA%X{akGUjNK1Ta5h5kRl)N4eVV`
zJL{zV^ggzHU}{SuD)<;4(!Mip%H518S|6v!7p#qu86HxRA|FfLnBN>L-h&}UK7Q_5
z`3T;<>|jWdkIf2LR>M2N^p7aGf{(NX{xRxWS1q_!sa~E=3@P&Q$nzT?aPUnGso*13
zd3#yIXk4YmV+yX|BOyEFZd6qpL>l)0f-|JZNBfDP?znq4G9=lfp!nATRW6k>RH*&*
zK7KVKt5qa<6nu31*YhZzG~Ay2ZAt@?kP1a+cyh(ellB7)De|$x*hdqvkJ+D6l_DP}
zK8X2&Zy2~Tq{zqbzlzPn6VXnFRPd3uz!|&W4#wS+?imFa`RH1=g_$1j%8&{^QkA`1
z>_3aE+{};)J`&QgLg^(K`HLY%KH6sT^u|86droaB@-Zmrn6L42LhoZZA!(#5_&8_M
zz!`Y9OkzX@A8Bga`+4bHZCIw9(_6hT<(7TlDkN~F5AL0ChE(v8s!W*P{?9##loRkr
zhE(v8ko|@<4Z+Jq)0Y%n<fE^5a$P)zmNTTt#|AGe4a0NWYlam0*yHfs!5CTZ6$Kah
z=(?n9Zj20JNRf~J7hf;NL;V#)ihS(5^|9$*wcf{iuT8;eSeo^b#!&fTjqBlk!D2>K
z@R6oA-(g>>;br1AL(;6Fu;lu*9cSj@MBN0+O~DnAtDmjki>sW+kP1Fh@W4^)yI|x~
zh7|c&Z9)+{jI8m7f{T2d7(ZbPM$TqPk&n;zt^ST5p*&<rk&o4iB#yzz8gD7M$jAHD
zFKooY=P{(nN9Ri$_ZTnl^*%l&B#j}nKGGOkZFhMxo;2#eGv$_j->Uol?8|XeE@nuP
zkG~hz?})2>$B-f)8wTe7pf!W`(_f%8eow)vEfo}hlf7aPUd$FTq{zp)gEtn!RX$}%
zk&llotGB{Prw<fd!AF|Z%f8CyrfpyTN7-41b@6n496PWB!4?caK@<d01jRxO5F4=r
z3j^##1zSYL77MVuF;G<OL`4*A5bQ#1eOUkZ?m6>t_PXZ0;Dz^f{Xh47XU=D4c6WZe
z%GOQn%h?Di;UgetyVv-o$fK;0BJu%3vV1JCai`89FY8YboaJK$qXXLK<V7EY00{#w
z;bUf=BgIw2|6guIWUY_a>TIk<Z#5h~Yq@2<Zv~@c6P~t9sUc<1#a1prNC_VSS*ptz
z8+yPWBBX?mfE?x?{Fr{=Tqgs9!|+HbUUpNvWV$bBA|%VlZ@rr&(09}m5t8NO!_{_;
zmFY6OkLF(>ILk-N0+XYZ;MtK=5t8NOxShN2)06sbgk<?>G1)pqU3x?xEi$#>Fgm(E
zLJfs}wRul>WgsF-_z1{)$vJx}#}3P8lP3WoS?i-+=++DBa~{#hdS4;8gpZ2U|NRVb
zS)QA-=(1djkSre?JzP_Z?#t&0$?|c^v4iK;1CnBJ$8QiEMqEPiR)=$pRqsKF$fXD=
z;Un~AYU$xRA5VRSkP<!u(r$*c&UZ<he23sHA4@rnT}}JA5+PYWR<7ibbx-=gLzkkD
z?*Iv1sp});UVP`sPWmBf^B-DndkG%_dG*@_?MEp8Z@>|f<>S#Ox8BnCbJ7r!<>NN9
zL?ikXQG={&p?_ye9Bk|*e1zb;N1BGviZ4J&mXC+54_u_z$7F<*@DZlVBJVbt(z8aL
zUl1IMNLO({#?I(cS!tz$6-RtFLb7~3Tl&Bwx-XLvQo=`QW#HPsHR&But=|xw<)cYR
z>-OsIQuHwpkdRx~M`)y}$B_tnbdnKK!bd=k?sexUeKk?{kCxkk<zwxxx&7&>Ef^tL
zJ{~P?n}e?OB!p!7n6@`xb$aEo`3u2WKAtLj(1X4QF&iNze1uu!Y_xX+dTvWXNC_VS
zX^|c=l<rGwgA(f8<^Xl6t2iLz>YQJst~{dRGZ9k4M?enpb~{10G6^ABKGr!{B7r_H
zXOlw<4vp0H5gOUF$NM$(=*&Sx2_FF&ea+ZeCpSW}d>r-KD3C_l<b>QTAKkm%45Bv%
z!3fFnam|887WABc8zEUfX1?4xfkv9;g5WG4jY9Tk(!m1|lI5dm<(T{QtPzWlEFTTF
zUe|d=R_WXj97<h6@egtJuhOMH6d_qYJ~<t2rp_AT`WOR9AWHZc6gneJHC&vBO6SpX
zqgQ}P<i2NH@;AMh4M#|pkDUv4YEJuj4k1}Su6XY@kG?W9$qT_*J~q4m;5$9w0SL+R
zvA28j3cAwIBP7emCQ~*!(yc6;4}!CNtm+)^Nw?AuAz40-436qc7f~!ivV63de5MP1
z6QWFh2oCm0lzPu^N7}0Ph(3<dkm%z#5<b4Y)bSU6kNz4Wvew5^SK@VESy#S*n!66~
z{W&q0x8J90$R8nDK8E{zY)scs973{u4BQ#FlkQ8Cf)JeL<BYKR73s1Zgpd+G!sSHo
zMeCm^bDM${XW$rwWcj$e#3Y@Mz?3wE;4B|=?kiQ04n7zmSw7~R(yV~e4a%Pw{1ig6
ze5`!F#eVe)Mf9<3AuTwpJQ6+*Gno`euRJ3Wk>z7!`<5?gWE?_5D<$Tkva^RZqYt;0
zEeyF?K2`~slR_)*i;yfIhXn2)LL-kMB+JL+_Z=c>#S0gK;1WK<<wQ{JRyvCNASBDj
zW($LT=@H+LkSrgQHf>L(r^|drAvnv&*M=3l(5>u_kSre^YphRI-$f+)xEGL6mJ&WD
zoY<T}54d45EjRD|IRp0%OQdsqBP7d5myA0l=t|#%kPuu#aa&W%IC{Wy7Kh+0ANx95
zjHZ#D5t8NOkKGBm)CpLe)3+le%g3?DMs%iEo*X40ILpV@TP>E;!Mh+N%f~ds7PDyN
z4uoX+_-bdUA${Te7a>_brpLKv{aBWI-qE(C)|XI25<YH>e(O%(Fo;A%*7|sO(x(Y@
z?hJ%v`MCOOC0DwYuB9NigpaUo+h~$GTN!X=<`64=2|_|&N+|B-z0{hXHC`Yj%g5f^
z+nUfw$I=j-<>T-bubh?DQuz~uFF;6^k1x!J{Gwa=5FuGU&L7|F7Tro4BM8p&@%Qw8
z)9F@DM@R`Dp@<Ua*7H~15L+(mPh21G01^gV!pAzk_q8{Gh@)d$M$66nzEz$xm34j%
zHwz(IK5pydk(-_^A0VWJkFaeUpIJ#~0=71W;4B|MSQfUV_Zl-05{5@Y@g7ly=F)qO
zTL{VWaYmEsI<FzEZUVtsKAz3B$(?THM1*AdSiVz^hO|645R&DiY5XLeZ%vz)h2RoC
zLJ@6i{j{c8mW#@t=;Js*!szJw2!<c6x@kJSOguqE*82F)F7`e>I(Fr>-1S&KrY*A8
z`TgTugk<>`?y+_vEzcu_Wcg@2Ywb<?ooH6&Avnv&1t(fq(tWuAAz{QN6hEJsuMd4K
z{uCiuK4w&KctkH|))gQ)%g4@t%j$fda~eXje7soBc{zOoBmp5=K3=POqo;byR`k)l
zq81#wQrAZ?yj(!wJ9^~_Mnsm6{rxBF{3hW(Lb81H3hdC2emG&3_5FnZ4%5`JXZg6f
z!Ek@t$Jq$U@-c^xcTx4~UfgRWASBDjD_x4@p?$1d8G^HXywdBhsZMZ&gd&nqyzrqt
z|6UyQUm+<|l7T^vtiQ<V2?)vZ@noL}7dp6Q6$sAq@k8%BtLba;X$Z;k@kV^<{OSxW
z`j`Mn$SvXHny>kv(z)$SwcHLY9}l=5YC_LLa}ko|<H+>&R`jfqgpe#Bk2fl7Mz^xI
z83bqf*e12qPkO+oBP7em{C(F>rGqCTB+JJy4?aAmk+rHqaF&m$0mjiZG7ur5E+rKI
zb*4oyjl6@9EFUvYzD%Q$=G7oL%g3sH_CBeQHSs8aqK}gS35}HSabU}x!|1KXV?<>6
zSm@r!6gsy}buD*&mX9uZif^MUJqRILK1P@I)cFB=5<;?k%)cVkhMwE3Yd~<8k9ku&
zCD8ZAW+EiZ$8`%#bI=pfErewGxWnkzQ~GwBnK=Y!`Iz#q_Br)QySUc~Ku9Qc3B}I`
z`0b-xc@-g9K32~0pbx!YEpMR(2cm?JhuY;yq~)1_h%6ty-A12OZvu;5c?}_1KDJ*{
zQs*+NnkD3B`S`n4?%i}NCn6-v$HOCx7Sm4>;t`VNW24(GchR>s%xgk$mXATn1KZQH
z#w3Jf`8c|{{SSJ&yor!39~(^S>_a1K)PmqFAL}*>_ok6k5fbc?P`q}x#R>F&^{$3Q
z4+|xHEYWkvAbQfUwNi7}<-I>=-e1pAI&(TgvV44Ww0JPx%3BD@^6|jKz`HcEiZujh
z`4~B>)FZmmM<FE3$4jMxLullAgk<@6I=<92de$gc8-lZZZ1Uk)0^Q0{2+8u%Bz15u
z8hIWeSw7ZsYUrmE+y;WPd@OYJxFNk?9R*0JbX_0e{%Y^cGGCNCCD}jScLxz!>ti0P
z$RBiW>pEI)-urXTxBK&r-eUzJB+JJ<h0cDXSDplfWck>z%kx|GUc;g;1ZVk}xMj&o
z`f_3lLb8196MwQk9sD{%vV3$rTlp;=yoxOZXZiSZew@zB;Km@NgpW|_@6Y}CcL-Xk
zO>y6L4k1}SnihE%t=?x8uOCh9wBS&dx<11F)x!6Z+tc#+BO=Sk%+>4D=mEcokT7dV
z><gB^>!|Z4#d7r^Hw2eJ`uOhLM^C^*5R&C%N|$XrY2+z{Wck><&2Kk)cuLtraF&lH
zO{bivTR8+FSw6ZHZjwqPPa!1B$F{|aT%n)JlyZRJ5<WtyM|+KaLeCm~5K_WNQ2ay1
zXA6}5s`Ar&(Z@r8gc_3Yv6^SO7qmPj>ub4r@6U0oH}5cw9EgxCA9t<Utn-?+XoO_>
zc&qW@FuIlb9U(aMrLN*II^J_mIV-EUf)yv=?g%O2BOn)t^$t^NNU3%axeFm#K3;cu
z<3r1nqX7hG`FQ$|gU*{2J0m2^$1TC9VrY4y5R&Dib4qG2dT#rUkP<$E;%jY>UZH=F
z?9ou`OBiqoAC3NAX+~e<?m$F|^$}{w(c-3)GGQo(h{PJo=>&~r`S|2!!g9JR`ynLD
z$I(UCS<z(~jgS&P!ss0OabX1A$|8**I1G=j;((kpxZFp&Ec+uQ%g4wTHR5UHQG{gq
z_@zhHel)U>GX!V(*l3dFLmJr|Az41w%N=}*Mjk{+mXF8Iy(vZCU(N5L1&7g*@X=#-
zbPQcX0}xTdN2sC162&^x_j8UTB+JJn>t^%mn=b_#LvEIjL2>?7=~i|_NS2Qaoon2t
zTe$@xSw4oZIXIWT3;Y!!VZ<dAADI-KMo&Z@O`tDXJ|_Bx>+Cfm5mLfOnABGcEt90k
zlYL|G6(LzZhMFv1N(XQ43c*=EzI2<AqAWYv&#!I(By^>&kC40F<FtSGa+F=LxR~W=
zsx^}L{v79;#>VO*E+Ts%B+JLsYdogWCtr>sB+JL7%|AnwIYjvrTWQn`g0p=5Yj9QP
zdvm@B$?~yh@IY^RSA85ISw8MK_&P%wf8|dMUZgn$ha!?t+%&U)S9;|cjF1vO!lZuv
z=j><nDWa1I$?~zbXJUD}FAKGR;4B|g>@MG^oYjxYpLqS)3y_do!bgwpeG=$-C=L->
z>tn<^qy2POnzYn%%e+4aW{pOTj<2R$IS3(HKJMSzbh!HHNG!_}2+8tsL0GOqbfuSb
zgWxP5ZR=iGN6+bF5t8MjQ~IX4^qrC`2+8uXj8k)adTujr1;L>%B@_=x{??5~4n|0p
zk6l;wo<ScmIEIicAN>P&+Lh08QTY>nEa|QVheqo92=h?anOASnlg1cCWce62V5}*P
zyoivj^>O9vlw-8w<yu2-mXA}1oEb}R)Q2D>%g0^QlDE_HoJL5Nk9YnW{iR!3x(x(p
z`S>Md%qzMthax1)M{9#z0d(+V2+8s>f9FGEX=Ks15FAQfLUCKOmQ!hDe}rWDnA>ky
z61`uI1|$$Ae5~mo|C`=imTjly=Dj~B^jPbPbnbBo$@1}@=NvD3Lv$4(Sw32(r+lW7
zl|3Lh%g65#HQ&(kj7CV7kK=8OJJWr686jCdo(kyaO9!vy3Bg%De!cJfibe(?B+JLY
zn-|Zakrxn><zu}xUmtqOE!Q4`gFO<8FEKQKMX!&;G$eXBA>rfqsA==*+44Ffvew5U
zOO|z{b64<EbKA<iKL_@!0gVdQQ7T=z6D)2nha)7*$Cp=b2hlf{&mkns$NO6!9i@@w
zIzVuik1dj0A5wnss{Dz;{SlJo<I>q%x2kixh>S-_mXBMUr>&%C4ZDsIoaLkM!u8MT
z6CiUDlI3H5E7MUlG6^ABK0cWg*04&}&?tZ6e$}dz793U{2_KL9#y6nnp)f>b`S|>H
zxvg|rrXwV@QeqxTtk**4m-jB6Avep%jV-q5+-6*YkSrg4pZ7mQua9X6$?~!G&$U<S
zTegk5Kya3i%dA&B)5Eh6Az41QU!1sx4xWOL5<bEVJU;X4zs;qB6=#hGT_HHj$C7oD
zv;I>91LaRdE<#9_kF)PzUZLJ+6n#twB$TCuk1IN-&7`}sX*Vr5Iua`(kL$X^Yv~$V
zg^(;CV|RShc?|awAtAU#E1wRzXGoW2BX0=K^3l@7&QKj4alpe6lI7#)1$)NO>*EK6
zWck>ronuZqxMz0=&hqhSLP{TcecXbO5<bFxjbWV{9H3kI3n5uPTCevxOt-Rw4+LlV
z_^pATlSP)^%Ae@tRzN}xN%+`ixVg^D8O!w08i}^R5|zH}{{0a8$(|oVvV8oSa<vzI
zi|9B)vV1I6;lmbsA}Z1of<s?Q1fTHwZx}rh^+!mSkADgk)md^6A|%VlxCy^6)4>b&
zg5WG4ON9(SM+fhXkSrey$6wGn1icp_Sw8k^mA4YT70lZkg0p-aRN~n#<>*WH^K#yR
zgaMcEaZI;kMd?NS7$UOvt9N``C(`ni?4#wD`Mwp*mg8@XyG~DS0}+zt<E2Z*{pbn!
zI6|^~JU6mRMH*S6F9e6-kx;x`zrqvgz8s8@EFYcDZqRxC-wA|d`FO(P^J{u|iuZ%y
zEFU}0{4;?LJ`f>UKKdm_45nKdjgTxKdpynIP$|nt<xgB6i}crm!{|u(Sf_ZYYV^&Q
z07PW@Xt1$KUHTT$IfP`bk2}(?h0?7oIRJ9Ad^|tH=QNG%kB}@Mea4zKrh^|sNS2Sk
zzwW+Bw=(xY2o57Ip?K&L7oDGsbV5j$k4X;mljtRPGeWX_3_Z866OH_ZkP<$^C25NT
zcd9EsDp>Jy!pj%>lI7#Nt=_xUdt;)HTL1}NDdFR_B5n85kHzy3(i+J-pHqI~nlSni
ziZ4P+_y}ET+v8+Cx+~8iB+JKE)%X3R2i#;Z1ZVkJbyZ3ReFJX<Lb80^{r2KvdXE*0
zkSrff%<VSND^KYm5FCm~Lh-NlS6o#FOZgKkeGo#jeB4~ZN9QF>XAx4uM`bqq?+b$m
zoEyEP*T*tLAvnv&?#?-*s%PPqKheiwfP~x<KECJ~6ibgzA|kTZ$34BGbUtQWbC{M}
z=6nux<(dz#htL-&(-D&8<CrT0bbP#pkSrfFmrZOyx3Y#G1ZVkZHD$9sy#*eJkSrgK
zJI0=%C!*^JDd8hbmoZVp{=NP$`^r;wI0T2flu*3dhv)<JO^68y$?`G3=lUu1+;#yW
zSw8+qKHQA{J#x7bT5xEjgpc)uqUzI)oQjAnA18H5-9yio@dzogK7x;CcKNo_E05Jk
z$j$Qc+LJkTX?dn0B+JJ=yDRRb<+*{7EFYtzo-Cy2^y;G^ILpT(%VvG2w=a_rQo=_V
zo(;h!ed)eTL`as8x19p6(zAxSKLm$Tmr(rMknR;|<Wz)Y`B=Zm{=F5m)<)$|Tp#ZM
z5{ME$whLHht^Q&}+-lSh&~o$6=XjPlagV<3zZ@Z1KJJ^@q8;6ppAeGeV~dryQs_!|
z8x6r(KJH&^J(Kn^93fdg#;ltjM7J^nAz3~)t^T$ejchdrg0p-alJ2ye-ej#qNS2R2
zV;7mxMf4FNSw6Zucb`TFZ#x!(gFO<8cdAh7-_KK(70u8<x$aY6bh$}G!gx#QxN5ui
zNA>xZD0l_{VRe)sUUIi6MbDKT#;K|8crWDfK2+a??#Kv)ln@+tSb4hpL@3DYJFIUA
zDIqu@D;_zyQyCWpE6!|f$3t+I;PXT8+@<S$BSOM}OH|OF>vJsWnJoh$B?O1y69=Ci
zMhADF0Kr*;FFI4ek6y#qAtXz1hgkzF(z~{w2+0z>ZerIN^xm@bL<r6jd}sWL{`3Qs
z?SO<zm+-NfLDx*Wkp(AdjYQwXlc=FMZ;w6neaoH*39XbsZgqL|mqzYFNC_Wd)Ar$c
zSXX-1_=S)xA0v*Zb)x&S{bcA%mXAAk{_>|=8HJD%K0@##m3NrYKN$IekSrhby0<z@
z2X8qAg0p-aT03zmja-9}EFZlJof@okgYqZN!0!=K!bh0fVsEtBp}x*aTpt@x)q+D=
zO87WB=}=R8PG5zHu;fa}v(&xTS6ZGo2+8uX^vlbu)E5znUD<FN<c8o9t=!+RTOE2%
zUxtt@AIC&_R-^m!6GF0l{8Rhn7P>E+2SRX`k47(3bbj_3hL9{Di#F|Yn7&_-j*vVb
zA11A&eQYotg0p-a-Y=~ijSN9Z2_Io@vk2)mLjC=@=;Jd$LJdjyc(H!WSh_16vwnT{
z->d!Ycn5xF`uAH$=bn#{EFYaK{k};fA0s5oNB91v%FsUA&V=C5mlBG{8?D(vPr#uF
z$?|dc?YjqQAD<#5%g2fzs<fb6X%hs&Sw03V+iOH4rz0fGM~fk~>d_bX@d(NCv1w~l
zXL|2%5e&guKIZP<bdP#GNAz(TAYs5Ie9XAzt8>Hl9wM^V$I-*~cB8wp<}58Y@4(O9
z`OAjU>*EZBWck>`Vp(tc&R8-+vV06~erFRsw>6jz!C`nL6d#!Gca;vl03lgEHhmMZ
zirxahKuDI4F&%Hzr;!ckKya3id0*w~PT$uEMM##9kINdBr0entLb7}ex>fFmT129c
z4s*5OFgg-G_NvqP488J%AtKAieYsto)tgS@<}w{2S?gm&uVLNkV-RlhAUDg$p^KIn
z(gVH)Az40F3^~7=o`An1B+JL+Jyz?y-?Qy}2o57Ip?K==DlO;{k3dM4k6-4QWYA9^
zzak{d#}<|QhtY~RUjV^bJ~lNTYC}(#s}WMdN4S10=(Z_J*<>l@F8cTekkFM9K32L>
zz?E*K+d?fj@4(NSLwhUGUAY<|Sw5!Ny;@J#(0hbr`RMthcP`q;rXdiV<>R|4n+MPn
z@KS_i`Iwk|<`b>>D}-eE*k{?2H}s>4#)}|06p@7Djn;qcK=<WZgk<^n;a);cdc@x#
zB+JJ+lg}B^ec3n^f=l=a*N;~w7LHX%T=a1{AR)Jek7@1On9}mRK}6R2*naA+f@&kh
z^|8rfEjRDLPo1L%yXm{%D-n|A<Nl>XhS0%3BP7emyxrPAppkA%AUMm%EmHzt(|s9^
zkSrfVCK-IETbY57EFS|x{f+5Xwpt3op)Ms9|6IOGO&YlYAz40lv^AMPBflaf%g5M3
z&z7lko9JV^FfBMVQo_d$E}0qhJ;7~=$ntUetdAD-fd4{B*7_J?_A-)2wqFLhSw5yc
z8#{qUZbnF!k1^>FFVO@36CqhXj`V(~^PL*6<q(|Z<0yl{adhx)2+8u%Y`61h`hLzI
zgk<^n#s1kLdJF8a0)j)SODMkWY2XDK8IF)FA0rRFd`jP6eGNz;O8D5MUy&R1R>O6r
zmYa9rr&iwe>uKZ?gk<?xf7Qy{YHo4KeTI-MA6-uT)cH|vgH;fm<zub+U6bj#Z4pAU
ze0=J*MW>a|5R&Di(VHDP>1~_CY6#Bqaqir9A8ExGA|%Vl^v`ZO$Y%)2^6_!24HfAv
zu)`V%4)#bW-eldcg6h?tc;IKghJ?Y9(DAlq>>Bm1zqsHg0T5P431ZE><D%)JbXcpV
zuE#s@Q>a}tKQ*;z<2;093BJ_cKay@`GD5Nhzdrl^J{nm&9D=h1zu;tFg+|UmNS5Gx
z-Y=g@_vKxLgc_14%I=*O>Adc|#ySYj61-r$1v)QfpM;Ps!6W)U8cxp{HxQB~_~hja
zHq(MvT@S%of*Y5uG@d^3J|2)z=@LG!?{r+}33d`9g5nYbe*a#v6nb^E+@R&=eSyoi
z;CBo4O=F_sGZ2#H;|0&LI>!W45t8Mj=jc*@XdfGFgy1Y6t1LKrf<`VxNS2T5!~I^<
z3+@wyWcm2X#!}}<iTx%B&hjzQZAV)=crZdr_y~7bhj{P&_mWE`yjVnu2r1zsAou68
zuC3gx&He^;s|YPPl%<4^_l_^iR99TFkqZ!!<zwkjYuC{O{t_W!){s#A;Jt;$^r11A
zNXQMrC6IZxjaWm^mJ1M)<>L;k`8(+vdV-KFAAg!z8PTn@je_7TA1^ge)H%#J8zEUf
zHduH_XE94aNS2T5nvXd`Kgq4R8G=jr2zOWemiHY=*JUt5O85v!?<do8tG6Kj-+mR4
zP(u<vhFtPmMBfUnvqj6zJMa@(xs}d=*aZkF;UmmLqk@ioRmxJ?!HBa)5<;?kjObjr
zAzkUUw?c5}O9{n&ZdnD<13nWWC47Y758fF@C}pYK6%>QtM@W{BACiW+&^tlfZ4jL0
z<Ba59?sQ+yK}eR5{m=Wm(Hr$-gk<@6{^lGXx|P=3Avnv&H~p&)RJVenk23%X11{lX
zk<3}o=tka0MArJay5>7Gx+|@AXt{X@eqPiae^kvamgO{rWchgP=GVpaF^GEz$?~yC
zrN=t2t8>^1!C`nL6i-<F-h>Xm0wGyGuB&9Wi=H*!BP7emE6-<sp)V(z?}FegAAKSl
z-=>e0Y(+?xkMS*MTd1ey#3IVK8(PWoF*RSKg6i;yKK2GAjE;nlZ<jd~RgVyfjXZ*g
zEFZ(YKa8cjvUJwz!T-+K)~hG6KEl4hcKWk6xwDoC<xgzoXoO_>I4(T#Hodt#g^(;C
z&!qqTL_bF;u@{1~e0)1J$3VK3{SXpHTte}6F5!W6D-R<i%g20?`^M69TfTh|oaJMl
z7AA}6S;H40Sw3E~xpad@o<vBNk4AGc8mWqlK9=0C1&6Mb@Ud_4V&CcYaVR3Pe5^Oi
ze=LnWg^(;CFJ4<ck)Ab59)R2|9|H@Ry3xo{2+8u%EWB0+dLp`kkSrgq@(fr+U*20E
zgy1Y6EAI@oRIho&xoti|LJ>(Q-g$IrPa63QAz40p^j;i7_od?@2+s1c-P<OW=zZHt
zgp}|RE+;0ID{x0?W%f5xz5*oVmhkbS&4c3ViYtze+hHxY1Ix$M3z6Mu<OYOf`S`=T
zRX<vuZwSfqv1svnH`S?44Bq(&1n2oU=cWfe;Cm2~<zv|1eX;ayjT}dzl`J0(F5O?L
zz6C=J-W?%XKCZ5l@|3;_aT+0^E+rI?-W#}{R=iv^1ZVl!s92{@bP@R@q=b*KZ>yGg
z;EG!6;`(?KkkCj8A45yOovsqa(W!Av%Uz%4qxbr?N9Y3v(-4y7<HDY1pXhrKHxQEL
zW9`-f{pbO&dK`kYd^G-T+LHEh5<;?k^vHRxJiW)dhL9{D!*<s;phw*71O#XKxc1Jc
zSM+{$5<;?k9JBI38M-f%5E4pVLh;|ToEOr;txiI4mXCdYw!W!uUql~+0SQD2A5-Gv
z7t@V=iij*9KkW^2qURyU7%jIW%g0@Q^9RzqmlX)f@^Pzk)BUuMnFz`9aq#B0hv-?O
z?I{S(^6{O`NF(*cr8r$~LP(a67xu0Ax5rZYQ$+qjNS2S*j>YfL!F!yB;4B}FLP~8>
zD_v~meuQNC=oe+_NpB2_#zHH>9tp+2$BYb8FU`aQKch7y^rVE2TPu6DRoxK<KMz2#
zQGz(X+L3g6bu>GprncuD`1xDtkj|S|0}zrWc)l|2D$?st970M64%ZTu4@Ip~)KRKP
zte|pdAvjC$IYr~@&~-izAz6YO?)sqfv8<~I$r60`)SVsZR#rI&!J#ZA>fF!vdN_R>
zYb-*t1b4r7w+lW0UP4Hg;Ex8ICD3z5<v0k=5`0sw-&fR~hUnuIKtiQU_&CSEp3ZB;
zlMxXVmlz$d>GqFld1{{5a`O)SytG|mN#A6gj*t>Q!nK5jvCAg9mGKD4@^NU1<L-0~
znO}h5EFWif{iSolb{aymd<^QGcOu=FcMy{0<Fc_Qe$%_QY8N3m%f}Xv-(IKtatcDS
ze9Y)psTMurcMy{0qhGp>oq8oM`e=Dc3l3$e>mw`^bKfWSS8^-eDJ~O1h{*D>^}cSu
z>02*J2nn->gyO#8147h|hS*BG%a9v_OCUG*{kw=B@Hq%6;Uo0rizm&hDE+8}7hCxl
zAz41|uHgBWZl%K&2+s1cgzuJn^zeirB+JLcGje5Z&#2&O2+8ts^)8oZG_vtk2+s1c
zb%PPTY2+$|l<*No{K<d`(aQRm{Q%x4Ktc`a`UuNJ<6-N(=?n4p*R<Tc13y*;ifYI5
z#j=b*NS2S@`_pt@$^Hc)C47XgtdPg1gECuYpNN`Yhv3kc5{i##ux%eL&l-ee`RF;w
z?iaoCd_qW;k9j&?KTYpf-ETl}mXEKO4soQB>k*RW<H?x?bT$SV2+8u%{bkxadRN^l
z>(>2$58CZ*C42;XtRA{KtHUF%k81%511{m?#_LZTszgzq&xpucA1%)p-l%S>MP%z+
zT5jHfpCOAk&7}8OI}lRBN9amtv#Ias-ODe8Wcipc!}d1aO0Reb4#Oj%xbefo*XT-*
zKuDI4KUxKb(6h!jgk<?>X*K8v-Aa$!5S-;>(B*HzbSonflI7#0zMYNfx0n4yNS2S?
zFP+M#UXqGFy5G@)!{|u(cxJ$^Qgm5vMnsm6ITwyBNRQ4hgk-Ick8Tg2M(<bK--X;P
zA9ou++(X|AjY3G4k5hi+J3<G~kpQh^`B-fIa-9!XcScAUaS6qprpG4Hv&IgDl<*Pu
z8mnrTU91FG1QKW9UkEATBOn7OW&Zm%M0RBRtljqi7PER1J_0gm!0~^tZcxfyY~^Nz
zWcgS%roETCnu$LC1SE8&gpZp}T2`ayA+JO&x6B)UAoq-~&yLVL!EFf1^09r2=X|<`
z{vssH$C&&poN0MH??Z5wkHwD~KA`8eD1>DB_#oY~J>ANm2+8u%q49(h^oV;tfZ$L>
z5{hrhb^I0`d<#NK_z2sV&zplb(#YQkDd8g^P3zn-qmdnwAUMm%xkfj#HdFsyIEy}R
z10>{@@G-_Jz?NQlawKbw<Q@14o8l5fA5!UrkSrf7k99Mqk$Vu5<zo-mar0<ofrk*B
z<zuBO4R6rMehA6(u|#U~GU@~@&gmx+lI5fE!6yIS`mMB7M3#O8!C5}OcAKm7p1u(X
z33Vx<_;1%jtLWfy2+8tsOnv{=^h8wQF$8D%_{GS6HvRl@G$5go5<dRCTVfS`k$Vdf
zS^L#paies;+E?|7mb*U7$I~00ET&sI4k1}S4r=N&h92<C2+8u%<K}Cf8_T9oAvnv&
z&JV6NqUZEU2r1zsY+u@6i_5Jbv+o3NAtcYocTvaaR@TV6N&3IdWqp>9C;yy(MkA*n
zB$T>@;%f%^Inl`52+8uX-_q-q)q^kM`e^Z73l2mHA1(eGZB(yF#o2N;BC>p3<?sHK
z&YgmgEFX*IxUrR<+8U%lZkCTL<}b@d-&kIZkP<#Zr8lm3Ay(OIWUut+2+8uX_jLy=
zbweZ$k3%X1m+%p`Z9m@S?m!0*MM##9j(vZAQs09iw(=Q5O85wU`Px6|meP;Plqn)x
zynx^=A18Wt(>dZ5j*wuFgyIwGnjKMhm*Rn+3=IjfC3G~lH9JZ#xGmDu*l4#ZLCl!{
z;{m<yL?9wd@UO>48qzlYL`at4Wgne#r0d)(9dfe-A2xkuBRcpFgp?2*)bWd*QJ6kF
zmFp$6QbKU3^L4xW|NGT__Bo>iLb3#}P#|^&J^yY)NS5HSYcjjjbH-nUgi4oCXXhVZ
zLmJus74#)b@WFk}KdIl}66cHvgk%Z6{dVvu^{1)gf}8ub)=H>!2_Gk2PROLoav&nI
zd>lEn;&B=ogOJcliP347;ogw0A)_~to8{xdbMJ4{$YBV{^6_=b4xLxBpFv0oA3^aW
zwwKcBRvN#B;4B|q(*ruv)8%l4WcfJ!g2y--8HbQ8AD=(jQjMO0%fEx*EFXXRTzpQq
zatuPUe4J_Q{)gTGUj-zTrG$^$TVC;^8)^Ao%Uze{W8Xe;Z)oIngk<?Rq~Z{rhj57q
z3Be^4AHLY86+Hph{s6&QJ|1q9T8&;Grz0fG#|+<>zvx!pLP(a6t8$LtNh8fZLU5Lk
zuhz`&LI)p%kSrfJjhh!qw=xbPC47XvhL^pu&XstXPY|5t<Iyk8o2WZ~aeedyB-D_E
zkLzx3dP&Q36A@WHdi@U3`FeAW&suI<mXDnWj_{{jIT;}(e1y??mA8V4vhpZcarbf?
zA)zlN6d(EFoX$7jEixcD%g5#mZ-vq8V<1AZd^D|?YC*3&2?)vZvD%~JI)^oCe}UjE
z9}Np-B+yTef)P@}N7!rRDbTDtjeLNREFUv&7QUmNr4fCsov8(f0hjR6C!y~F`c`NN
zBC>q!xMh4rI`>nAWcfJa%%S6SS=xVv+!8**=%hro?MPouEI>$>k2hTZxGDb!%ActC
zTZDw+kx+b7jS<E)()k+%XZbj>kC7)mJc|%g!bh0fdK^d(q35;~gk<@+q2eB$%lii3
zAvnv&I;l$@(Dy=@Af$wk5WL`?Gli>VjdqQ!KhekcfP~SJ@UiHiQ^V+sJ?|e{?s_aA
zKVKO6f|h4LLb80^H+P#6y*}pu39V%LxWwd0S9)}MAtcMk<9S|fpig+6KuDI4?N0>8
z(bJ{jF9;4JE}?kE%EQ~zKK4XN2_Io@JJPzqNTo=XKXD>DfRHR78{a>Cn{H*1tcO(p
zJ(F>eIq(CmT;&yBjGo*2A*6(lfE;u0W{O%wqK^jw30*1S<JPYIbq>T9`=jNSIq(CG
zyjt~dE?V(H2+8ts)z2#pX&+A`B+JJPheD0%(JAv6f=l=av!z+h<TvyKltBo|^0D6p
z>)Lei69~!jvF7X!Iq2ajX;4zFbbBZw3B`w;i9JQPawtNwe9W`s(n<A6f~fczgk-Ic
zX`Tah4*XQk0l`^5rVl=xuKZXe`wvFO0upjd_!#`M;|Tg{;vOQh*2gm4M|7kI+$N`%
zoA*gC<Cxa2^nlMnNS2S5hxW{+=k&)2Dd8hbL~SR2+f28zK`sc+^6^WHEjr()T#S$`
zAL|Et&7?;>6(LzZKA+oE=j5StZU_!_DWQ1B$S0Qc{hTm_Wcg?m9krdl>+}L4Sw7Cl
zEPYL#HN^GNK93e08Y$u9buY*Dbnc~y$ntTetM>&OnTn9C_3=xMD=TQELte-&;Ug?&
z`<GVx_hNrVAaMeoi;yfIOBO5AnfCE9Lb7~p<^5?5y=}A42f<lBCT%`@jc(<9gk<>`
z+Ua{!8u<(%Sw4OXD|VYkI_8JqQ0fwj4=_x)MXwW~2+8vC;i~ah>Gd%kkU*61al*`L
zJL!wPRt2=&yia;9nR7UauA%h^$?`Gt%SD~Xa2W_G;Ug?&$KP+#IiT)d5Q4LOY-1Rt
z^A3ac2+8u%{6z0q`e!X)5R&C%yxFg@^oX}Ngy1Y6<2P<uNALZ&Af$wkFkKqEoH(fz
zk>aE{U4BDImXFPz)Okz$*tQS^2YVzGZ}qgpAa$J(5Bx-FNNA&kjz(i_O4A1nz5ozb
zM+st$vW{oziLFavHFbU78-C7Td2*6Q?nX$K;HS>nU#BZ5PZ4OPgy2v?^SpA7S6ZnI
zxmZD+5t1eN`_8c*bnsmW$r8MS{eh}9GIvo3&Jw)qib;cMWOsyQ3GSEXsPhPWKSD|f
z4)d>TuGd+c6oagb&;LI>1&Tp%kVnGCdMlgWrDwK&2+0!M=7is8dclnbBviVDkNX=L
z6jE<FiDg-~xR$#PC@zuP*L!*}ecy5%LP9Ggkjeh<Ea>}|=MhrEM;P#C2P~G;+X9mk
z5S-=Xh=ujn(XAYgkSrgMF6q#MM#dr}%SY4nB17r2EL9SMvwXDM@qDU!&{Qm<AqdIx
zF-P-=W%TgGASBDj9xp#d(!ooXg5WG4GyfdCLa&d50SRR(;bYLgbLZ)m=L#aSd>k`-
z`WkwpQNFa6yRL+fu$UdJRp*lOFXduf9PrTy3Be^4fAX!A&M}A^2+8vC<(*E;>AtLL
z1i@K8t~qD1n=Z>S2r1zs^yPu~uN{@LRMtqbFE1k`%f}_VY(CSKUbzee=lQt!#10xc
z79m+a7F%2`mEIU!MM##9i;VNHtCH1^%Aa_H$Sms@jQ>66sSh<I;bU4(zkef>eRSp_
zBFo3WN%_O*+43nuO85wiS>)>5SLo5HX9BrdK5ne~z95a9kC4!p5{i#J?30te75Wq*
zSw2><9yFP5WrMO1T*61_%MDF4>(a<jgk<^H{K(6y^hERmAz40}^q$|DMmm&(;4B}T
zy&tXf(cw7=$@0<j==|O4DHYMjBtXJ|OZaFpFZC(CA!=A&%WcQ<am$g+kF<{=2+8ts
z>D|V`^fK`bAz3~SnCW($mdBw21ZVkpZC6=W^|-RQ@`NHJ43C83KR)yxN8j{+kB}@M
z8#Ss~oE{#RiV&RT<GJ7FcItf+G5Au1Wchfj=U+?u`Y{zDSw3!C8Qq_5rAs9U&hoL0
z+phFVS!<*6C;GS;kT5zDK5l!rM(3bYCL*$YJhfqG8oe)QS6R!=`=r;i-{(rxTi_^!
zWcgUB-?w;L@!tr^@-ec6`Et63ysAKOmXBSEmU>F}<xYfz5tmT>-prQqG%}Ydw36lH
ziq3}`(MWHEWcj#r@WLGQbh!^9Sw0pj6sFUc1<fEh%g5~#y3eBT=kx(2bftuk_KwYF
z&|P^35m`P~8Zgd_u5^>CT5fyR`WQ3h^BB67!x56@V;zV7S;vy8x0=QwB+JK_>yKBa
zkrk^!aF&m5Nwp5p!N(ya%f}0~qgv9)>j()&B%%0}L(@*uD^IoR5S-=X*jEE?(i?+u
z2+8s>t?B0cbSp0)B+JKkscuE+AB>pP(1Js52_G#R<=aH(o{WerANO^L^Q3cMMM##9
z#or#UK`UO-9CEXKbgA_16<wAA2+8s>-=5Od=~etPLb80k+iQl-Jwa0o2+s0x+O|D9
z)8%-CWce5x++h`cNqP+-p)Ms9zi%)?=k1<mS^L=k-6?Tk`FL=^AD!2ljz&n9kA?$p
z?={Ps)RjMRzZwTfXrzRXCcn$;youAgrk0!cNiVPb3*+dr3`R(nkF{nmnM=#_5FuGU
zzF9J-HvLq_t`-Dm`IvM27(e>TY$igod|Xtlkj|_B?ja=0N25w7a?^90xfKML@DXm=
zzILkl?+lUh;7q)JoPv-NJ_2$^#RK1zzEnnCMBYJ2D0K<NpN$FEc@?L*H3Vn*SZ-Yj
zYx)OV695TBT^}L$oB_peD47+3#N3I9$XXvi<UXbIJ-phrwcIkF^nzBN$><ZOjE+)A
zVk?6XlI3H87vaA2tdWS2EFb&NEaX5VZEPSo%g0d*+9%SA&p}9*j|W|Im!MmjjF1vO
z!Y$kBbrQm8q+J~dF5x2}pA^5@hhB0QASBDjk#<AvXyh}51bZYDH@B#qR~;Vlz)$_U
zYH$GR>IkvJ#^3d&Z`jTQAlN8D{BX2>K05U)L<FQn>hEP*ms3-VHa51^QroZ=+>H?p
z57Vs-Lr9k3ooYwFq>J(uLb3$6wr%yA-ub)QL2#Df2jfC}(#SA`WC{N4?&rKT@&!V&
z1W#B!Xgl4P_3J@!mf*QEn%$wdSfL2X65P+B!W4R^k%o}qqeQ76nLXkUeZ$ttUJDMD
zF5%;zij58F2Phj6k>#WFwjxJqA2SdVS}BoxQp;X`bXU4LKyH?gYX`4?O$QH0NS2Rz
zKF6P;4^MqSNS2S|yY}Br-*akPAA+-djB8X-=K%C(gk<@+Wqr+}^mO?XAz425HCX$e
z_OZPq1ZVm9W~7zQGt#XHDd8h*1ao{3s%oCK3AD)i6E8@=0}{$o!p9b?oYLv3&9{M;
zoA-vF^RIuDRevTUu8*e>Qo={b{djBl-Abir{|;+~hR{j~E}{7J(kJrLPp~H<B+JLT
z4@W(u`|=7xvV2Tgo^LblqnQ%~XZhGP{=3fa)+Qq)%f~r2i%y|~-$qE5k6SvIOQ(yd
zW+MpB@^N^x{L|IVrC6795mLfO*sl(o9`ubq@be0gP(u<vR(OzdiO${LS<B7)q*qwD
zyFER%?LkNhA0hXP&%v(rqr$u{&`Oq%&NCb8ytcSELPB3kD4wU(Go3qQhY^zHW1$u1
z|K7Z+^ru)uMH)kJmXF~>s`}A)#s(lH%SW5jDRbx%KZuYlA1B%d?4@@^hD{(i%g1BA
z+ZCZ_;NA$y^0E2(EwkwxMEd{<11{m?BhLz}=&mf5Wx#(osvUU;e)7f@Ornv#2r1zs
ztdGx|MgDugME0_bK}eR5Mz(I3X~j!6h2Sh7@8x;ilOAwCgoNRdQ2dRD^<TO#V-S+%
z<LHQ+D`;ftW)Pg^<ILSFX4CuCVF=0c@z3h5rD^0Dgk<?R)#zt+8fn}dg0p-al(FPU
z-K?on`4ji6!vP7SBjID0*+0+GjeLQKtn0^uncnZ|>qn;+T5jHfpR_;k^3vP3P=sXp
z*r04J8#?$)gk<^Hc5q&u59PYFgy1Y6UoV`zpKj$+goF{7P&}eW6&D)$5+PYWE{q;%
zM_-G(xIu81k7YbgO{bAd5R&C%lJ#8|db&(SNS2T5M^t;EPU@nM_N}zw(3KKCHtCgo
zpU%Aq5m`Q#H!&Se%kvB&CDupSua0XFWJq72G<1jD5<bF`Td$k@FJ+lfu;NZ|DMGS*
z44Safo38X%2+8uXPJu@A=-`c8LvWUl=eO-0tk#eid?i9c5$P%peQ9nvx~lTK?(Dzk
z`Gk-XJ_2&kodE}xI|kX2?b<+amXG_dj-F3%40a$S%g1_`d#0(wBl?)Lt=3A&E#c#!
zChf}6*N@#0k>z9KVs0k%4fP`k$?`EWu*xPiw^&03+Cgp!A3^cMOD=fO$UX?k@-g7X
zlDaf98X;LeT8+7{^IqxV9uS=6<E0tFo#|PlA3{p_2z}YJ@3GS~G8!SFE_D?L<PIN)
z!n8a^Js~*DN8?{V+S9``5FuGUMwY$zPMzCCA7cOsjg;_l@YOf9=>vFW+H1La2Y$9Z
zcYa8ZjxR#8d^9qs*@Ra7Bto)$tQGzwmR`k+dO>iOk9XI^RiT3qLP(a6SNw7ordt_<
zkSrf34LDYu?#nVAAUMm%u)O8JD@&X5Cr+1x5t8L&&T$UQXnD>dB$T>@;?wF(E>9!N
zcZA?9A4ev&9;*(I=;LTW0#U-p3+3J#)9d3^L}aaxQ$tf%s*{E|I+mTZ+%gA#V75H&
z5aF-p7Lh>+$?|d9Et6yP=sZM7mXGhoUGb#n^m?5kILpVewoUTVw;2~8B+EzpZ&o@t
zL!Tlf%SY$gGjt9Y*Y5(sSw5DGzWPn)Itn3KKAKv-o~4wO@+TJ2GlT?tBoyBo6;MyT
zRU#hvvF-Z5;AkzA(6Razb8EHGMZtps2sTO(Q!Ilj&>i^@5dkTYdg|}F8FWY5bkkDv
z4*cwIkk*`T<#dE(37#>do6ae;I|#`V+<wZe$@CMmTHX+xCHSJn{?q6+d?7-z1V7)V
zSs{96dybGS!5gle|CpYJ8g_@^EWv#}Uhblip$N$m+&ptqU;6w<DnhaZ&l6fPx7wGY
zkFGviaM)T(_?S`7<rKXgT7`%bKEk!V_oF}Olz(NvwttO~&`Jr#>z}Ts{Zd?<D_it{
z+$<k0t6hpxe_SUbw;&|T#}*YLbUs&DpeMAF<>RWUyWi8p(+440J{J74JzA|HG57(5
zWclc}ynj0yY1j*bvwTe4)8)Ln@`$bMhmb5EpFfDYP9sksB+ExP6W2HuDf(Etw-y}A
zQo_fV1_g@Kzq<EBL<t{Zw^}&(+W5*@J}Q4=S6)R(mXGI(Em=-)Ep7WiZU`=+czCs8
z3+Nh}hmb5E@24&(L0{ZILr9j7zD|3~)9Yj1z7U+{qf70L6V->};_%EtNS2Rv0s;!E
z=R!qfIzqC1w7q3tjSk+f9|ULl=v({67rKZd5t8NOk?>Zh)oVS`$De?N8j|pFdhS4f
zI(NtZT5jHfpG}57Y4n`F9U&!rgeCXYl$(d>JM_O0Qo=_-_N;BXn!ZEdbpQm1zLZdW
zPQNiebYC7qNS2Q`hF?2E_od-LXeG<XAL*}R>4~TZLb80U+U-;lJ*gi;NS2R3@-Nc)
zflw)52+s0xS1GS_+Q(rC$?~ySaLI}4u3Gf*EFfXPC46k0Cqd_%7-a@&xp@bE7B88#
zi_Se9Atii-CAW&lTub^kRvbb~_z1}1x60I2w;JM{ZkF}D@83zM`ZjhFK7!(n+O3SS
z%-R%KXWJM|Mo1VQ3B~i7CQPP%e2b7QADeYdT}ZFuE<+$V%g69LMK95<T!fG;A3y9{
zw~9tSMM##9#xrOCrGwiJh2Sh7_bz)pTb<iPA7=s*Mn}TOE9ZtSrgJ|)MAm+F^Tyw?
zG_uw(EjRDL&#xPPzO>>~5t8L&>F0?$-)gywkP<$E;;md>>%8~G+7E)We7xe)Wr;fA
z;;a#jkTBvBieF5xIGA3=A0niLk1!FHoA$T6f>ee`Y^CjR2+s2H&yfPv)Rjj>&P7O;
zkEZE;|NX>Q!HUR72+8u%bj&sF^Jt=vwj;FQ(3KKC?u=<Zg|773h{*Esr;qn;x`rMh
zBx`-#-Y<s}y&<w63AtH57W<yF0lnldLr9j7pG#jlMEB)qgk<@c&(!)JEsy&s2+s1c
z&x-?p=zG;05E6<=Lh-}j6RXq6&j`u#vG4f1{psyX3x5dC@^Mt#<AJo|>k*RW<A_&Y
zt<_eFK4t(Ca!dHw@~hid^^uG?X|xH@ayzhmJhHEh&YR;mASBC2<LT*5=(5a2NS2Rp
zbN13X@Y7~A1ZVk}b}O}<vRW#CVqZogB+JLE%dCQE#lIjV%f}tR7G9^H%Cs2+!C5}m
z9&_<J-O61E33Vx<_!Q^oOX<5#xyM2)Sw7A?IJz}GJpB=p<>Tw937^$<LiF(vAfb^G
zKDIbkPUja1CC6#G(L+*+t{hRaMIm|~8iJ54A5)S%Hq*#c2+8u%@!Bw*ulAK155ZYJ
zo?X|W0=+R9ijXWHQ_96orYrp{Lb80c8ari}I;V@XM%f7voaN)0zkN^APxb;3lI5e#
z*qJ)-&Af?_Q0fwO`L{urXY{0AV<H4+`Pe4*Q+{=LL?5RB5{ME$w%ZsJMc2@6L}aax
zOAD0Ld0%MFNm_2+fuB>=Ygbfri#0R@Az3~eZL+#R|E};pLb80^Gk32yJ!_axhTtq8
zqpwtnrIAw*lI7$4JWkzcWIRH$eB2j1t0}$m)R+RnSw0>Qf4iO@@$m@B^080h`Vs14
zCKk~Rgamse6d$zWw000eJn&;ZRSgackA#k%HqQpBI*Ni%2O!ueK`d$9{3D$@5fK3?
zk@{fExZcXm1LaTbNQY@!YTkjL<j685=?YqckSxLL71+FA?Mktg&k>R(_^OS$E7L{U
zFc5;X1Ye(!dkbyj5`>fx9PZ|{T~r}fSsj&87lWrEBunt74_@`7ucDewhu|#1PwiPT
zm0lfJA|y-jppCgA=vKZ%ND0BAFRQK^y<fSQP)@3dKDy4(g0l?2w_tK>I`<|-Wck>4
zU0Yuo`3)hVl@f}7h-o^Oz5~&2Cgf)MxS;E_e^-v#uO2rdB+JK}iz@ijv&JWcl<*M-
zd}GXu6UwZi>{vy4ng&5|2_Kbq85mTZHNJ~&r^z}8e%2r)%f~mV-DBvv?K48Me9S+#
zjLuI}TL(jMmX9|qBOK_tZ6iXmeB55I<al*>L?1H&31um<KJI!{z9T)Sx1FWs=Dp!3
zDQ|h5Wg-$GSw0TVaW8~^Ci4>^A-II%HA>~p`cJ8EDz=>s!C5|L&g#&YF3T+lDd8i?
zv+8^5dm8x{Az41=?%(1O-IrbFKya3iul<S@pzr2vLr4i9VIsQJ?YW^+mr8hXA}TN!
zTFLTpVEIluOHXfvl<*OTXLPK`c=h65^zkqtp@t-UOitUlgx;?fnWyFE9r#(Fl(3Rs
zAN>%L<)hQdh?(@PaTXz2K6Yrexei_FW#>b1=t~L3rwv@K^D<X|gk<?xV12Dl^h5E>
z2+8tsptn~rJv?O>Kya3itJ)MUO%KmVgp}|RD!oJJgDdFG<pqRf`50Zu+>ySGRc;{!
zXZd*D*s+@$T=a1~AYs5Id|Y3q=Uw`v;@1(8wO@59elUTafGtC`+;%J<y+&7?MI$F8
zB+JKEXNG>EeY}p45<bG5{>RX%ih|6(xvahjg2V9WDh^1K15N+Em@)e@F%=<MKAsB-
zC`dm*xr>l2AB*MRIgRd1`%nnZ@^N&Rt2z(bLlBbX<NGT8Z0H?PDnhb+Y~wn1mx>g9
zbXlwghtZMn(dhHFrRs_+?h95TBFo1<jg23ulZJ@=h>$EFw+%GvPb1xyKyH?g8%?6~
z(#Z7)Dd8i`=`Sw?^`rYT6Covh1muHjNnL29$5IFmBd)7BAe*l7zd#4yijXWHr<zY|
zLbviSLb80k@-}KZ-O8?E5S-=X*18@0(yiQskSrg^I1PQLB1IqbFVk8HT`A$?-qmgH
zs6<ho-iXNZv7p(FAQ~BskSrh9d~hjG-_I$r9CEXKd^WuIS9-}EfRHR7OaC@6K_ibK
zB+EzZIS<Ox$O0=MILpTmQ!oGfB($<;6-T@~LP8NqDE|0MnRT>0`w)`lW08hw5%kTM
z{3{_i%f}2u*VZ($2ST!ZEK>MOL$%aJANK<ia!dGl&ES_gz11kVO3TeV@bi3Z%^mdC
zzb`_vd_4K6xX$yA!wAXpv4+X&7jzBfTMfZkK7Q}lvMAk`JrR=S<9MGnW$BB(!wAXp
z(fHNmvdV^7`4fFCv<8Ap_z1h|`MJ!!l<88bb`j}|kWiNrir+jQsPl~U7(%jq^fRs*
zN&9HH7J^Io2*Gy@n`*E4sO(uqAA1858Y$sp?3)S}bPXLvMArJaW<V32tNUW%TJHKR
zACI_C(Rm59FG8|>EZxcQ7k$7W1|eBK&JDNw_a58qWm$L~1ZVkpW_XbvbPe@INS2SU
zw>jme6+eQI5<bEfcz7wlIC}e1cs&GX`S|*}zs_m7-Utb$E}?i-pMg51z7HWKe1za<
z^EWC@ua5;bXu*Lf;p4^JUnkH$_CZ7mA7Rqyo8hxSsUc<c5ogP2gk<?xbn&%hdNC`q
z5puJ9Y_+IWLpt~Xgk<?RYsYh)1F<I&lI7#m*6Tuaf^UN0EFX7oZF-gVaR5THd^GQM
zBb?q59Y;u(kCiL;{!1f^MnG_uk4>X57}CM}Atcx%q4-cgkN4_CBp&#Q){sz@5;{KI
z(Y%;imEwY1Fj9?;o<2$tz4Nbfpi}ojL<zxR7E0LPA(I}PBM8Y7+@Ns$3i`IPVHD(s
zu9O&?%L_m1OuxPeDIqw_Y-1fAlPYG-YRX3}#F_0BLb3$kAG!7<{iv|&W(dv_eCKWF
zO*AqHAz6a=ObIBTJ1eyECk9VJNS5IKO&0G_)e(`kw?J@~-~}V|O;xH?`4f>d5RxVM
zw+$Uj&^K&v0}?7-!pHO@Ze{7*wYF-x>#%$bj=%3tBc~xGv{FKz&H)1o(OnsjkP<$E
zJWX$Q%Bf6k%Kk+h9kXo^oaLj#mqHtq)ltEU$Vmt(;UjA0=Lgf(D;^OUkB}@MBbTS?
z{6e$lb_mY$@q6f_qqO4F5t8NOh>gb<((A-igk<?x<ot=h^s{@19T1%5<H{3<{pj^^
zIUu1dC43xUR(*sr{K}s=;BOI;<zqX;m!s*fbla)ruFLZA>h<7$^geJMLPBr}#RGf!
z&!caJenCi<j}u?!yG;AoGV8I|e=kL-TbJeIupP_W)5vuQ$@1~p@|tJpy~Y=WWcj%G
z+OQD%*RJh%LvWUl=bD6%ql;({Lb7~(+u->Fdc^bWfmX77d|W%CKD|D60VLFru8%MQ
zcU$*0hce*VecX$PEFZsjj=QK%8lvL)_G-CpSw4RHS~!?S_CiROkL#DLy-OpHASCpq
zgyIH<_x8}sMA3Z^oaN)7`gQs!m7e`H`3Qt$`S|fgArEC&t^A3@a}6O`K1LaoxJ6Iu
zb@xMXmXB?cZfsL;y@;(`h>$EF8$NsLLC+d55R&C%h5i+9s<Vc8{n+e)790j#*GIV6
z>uT%&gD%Teh{*DBboqAoY2-(QWcipoa_3t599pY`kelVB$I<QQ=p}a*Lb7};=a;sO
z9`Fwc3Bx0yc#Vns9OzcII|RX5J|=h+kEfT3D1>DB_%rE67`^0vMM##9$1MYA(5>un
z7=p8W47oh#41Llm3L#lOE~zzMyEGGh%zH#@C5(=QkMTQN_ET3}aUSZ5h%6tI?d(6&
zQ`>%oWcj%B^Sj@4SsEUN+$<jrJg2{<k$n-8<zrxS{399}jgTxK+qa(KLnDhtLvR>z
z3B}KKnEIQZE`1S_<)g{d$2uS8JcW=fALm|5-AB*BM#msH%g4JFXP>2!0}+zt<A&(N
z32I-8J{|@nbftukbz)}qq35B($F<z{EFaHaFV>fS2-gcCSw1ev`|~t?%l05bvV1%d
z?W_IRRh)?OpMc;jA6r}2Za@d`fsia8o7Y}{ghuX1NS2S!TdvtjE1vHp1cxHhRU9sQ
z24r^eQvRi^kz!x=L`as8$IPoQrkC7kgk<^H?M}iUb#p1UvUCgtXZd)tYhqUwDf&1R
zkdRx##~J|>(p93^$kT|(^6_Pb*bMqUmeDCKw*$*ZOOu^hKMbLMZ8ZiVSw7Z{>3EJl
zU~mH=Sw0S`Y@%IFh<#b{Gz4e)Sk%D&CS8`J5t8L&m1!e3)Ay=xBBX?maM2UL^<-~#
znGl0liG|=$m%54rvUA!WoddBG5R&C%+1rE7=u*FlkSrgUHv1W@K1vXMtbRrd4vp0H
z5vI1#DBnEFzm#9Lh+R1z5m`RADf=gr9`M@;$?|b|r?&&>Wuod?$j$O`-HyCE-*B6N
zkP<#ZUw#N|-cDJ0l+qOY@+LyEe7y6`aSL5THO@hBmXCIo1OCu^jVTDp^0CLT<m+@R
zZy_YhM~fn^#p#Ql8gURDN?k(n1C4j+ys<eDAtii-5jSo3H$(}pjJW9IJwO6c*GHI#
z4C+Sgpew!Bc`dgi%g4s|+)C12IUONcKKfN3FoWJ>JwQm7k0X2Ex1)pCxd6c>e1yKV
z4163)2cLzIEFW`KuDVN|fJMb0BP7emQs$#4(pM;TFG6sZk6n8nvZb%gf)JABW5}aj
zH|SR0K}eR5&yPE;r;*h!L2$4~Lh*BUdv2&jBp&z~uOXp?By>FCednb*vx$OV0U+2Y
zLA>|9=qGybQu(r)+SUe;5~;5ac8#WO9FLGJ!A)CL{r5p=1uNG14TNL~UVi0nJGzzC
zuRw4Z9f{xz7y8tof08=|Az6ZlkIZjN56=UHWC`w<@8LbQD8;_4dliC92oCFx=c|}y
ziaN?vBqC=cBuntq4nyaul`bOhBP2`kX?wo!p^>$(L2#Df1{Inls>37t7z{|LbO|3f
z$5!e_H!>L!Sw1#Q`Z|b4*1fLft^=)<sPyI+T>GiH#nG9AkSrfJJ@hV0Z_}S3q=b)9
zmL*E|ucQReK5Nvu0l`^5j=t9@Cp~M-Mo5;Ao?}kyyomD=LQ41uJB`&gD|^w3+uwxX
zEFWu5-uLgYM)tm(kB}@MZydeSiyrZ32+8tsXoW8B>hOp@+TPNFLs{zj2sLCk?MH&r
zmDzL8MMMc70h!qRcsm;T2q9TM4ov@`^8s4hc*qUGB^0l2Wt~DVX7dqJ!bd2}9C=3T
z{8T(0Az425-|euLzK!K_8-h#t2*cxP+^V^9L8=UqIJbo$B+JK(rprR<8Tc7OvV5G~
z<;PuG@%nclILpV3YmQxL9~UAd%g5O@jI<ZyiatI9B-D_uk5EG$rp_^>S01~&T5jGO
zeoim$u07=u2YdlSvV2@Vy?zMY$`piT`8edugA97Wof058^reL2tF~^<M-TX7gp}|R
z<Qek*TBg!UrP{^5e1?!LAH%O6|M&A|r9VZa!#xPj^07gmymi%OLPUljB+JJpC3C0H
zx9C$5lI7z7!)bx^oiUe02+r~`aNBF0PnIkNBn-HOkC!I38>kGw@+Wp>8X`)pkD&OP
zl~sGtv!&~OEjRBCKeI}P`_QAa5+PYW9xk);C$0D=gk<^nZ2gd<ba3|v5FCa_Lh-Hl
z68h7v+<=f0KEm*P@?F}VMt(y`mXDtUD(k#s%`*vtvwTboemsC~<z|Fr`PjXZ!FhVR
z{DY7zA8&dFE>Z8_iR+_BvKAahN5aQ^7yBNh8@Uk?Sw3zxsee*!q^S5Ogk-IcUNL8_
z=+SBZ5OTA8T%EtjVHz2ZkSrg&`COPqKYjdykSrg=`se6PE8hMQ1cwoqQ2f}5mqTgf
z7KCK^m>%}@E!~&D5t8NOy#4m+^!BCGV+bzcBkVQ0wDrHB1kZkHwjCiQd<5jzjF}6R
ze<>F}qK^hov{ph_>iP)8RSx6#EC0%VR>K<+Sw6O{;Gc&c@Iwg6^6{>_mCjbf@G0bG
z`B-$TWdOa$>V=RjAE(_O5l#m`jF2oJ3p&i*Ot-SoGYHP|v3sp~WoTqSgoGlJP`sPt
z=H>LGiDL-K@-bysX@B}*RH5e(T*61#80<ee){;gJKu8H60XZaZYwbh1qK`3vgxnH7
z=8dr(s7!52L&e3cbk_d;zaJgh^4{<h)4XD3dYSM;NS2Q$8c(Z5cjYC7l<*NIq8YKB
z{=ETD2`>gWO@-hrAMJb`&eLT%0U=pFdUdIFo>u${Lb7~pH9KY>-IrBfKyV2kp)YHs
zJ3UZZnY}M3A|%wMuHt|!{CV$KW!A`Emp2iT<)i&9*Qs>y8fg%m<zrIAJ{#4!P4qDk
zkkCk7AHnd;9`#PEM6oOr5RtV$&Y9CtXX|g3uI1*v;m7vJ{_6A->|lhH@DYL+wTQb;
z%X1eYSw4C=P1dRO8ZRL@%g0)gDQR>K1tKKN$DuzW%F#b-xsQ+%K0;siZPRfb-Iorp
zAh?8&fDG$<@;SW)o{NxB>bi;p@=89pRJt#pBBX?mFlz*bzWw)Oam66f#|E#p;6Rk{
zaasj?olhq%LPVC29qJZ5K`Z_OAzAC=fjtw)(Ouc-4diC|_-fX^f3M6}S}ION%Mp_0
zW3RBl8g%ft2+8uXbm;8^bXhig3&B}FZZON0Ov|$tAz3~)xcgu*jeLiYEFZh<ZS6=S
z8^43#EFTYUI5L@@)R!P6*dw8MzY<Rts<%qS13%9+B#gI&j=_GHv@c$Yg4@1VW7~m^
z62u%E%yoW&G8Yj6DUo_*ch_Y4+CB*(S%U9+vE~WA548CJxmkj5e7)9)Zsjb5WC@-(
z^Y}|z@FawU0hj2@b5^AT)Cv-(p}HR-I7{%kZ<74!=Lo?F$rAjoRj|(QWbPv*OYqOf
ztq0S?WBmz&vjo3*J-H8!oQaSu!K)t|+CUv~(Z@tULZwUiSn;7_etLAQKWn*pZ}`cq
z)Oj17dj>*6D<#Tu&BP1eY2-bGWcj%8=^;-#c&!Ww&hoL*#k+nqG7uqIK3cXd(1%9e
zK}eR5`HJK{r|b%qKT&b>FA$vNW3_Xa&(hQ71cYSyIP*lkmGn;I212rY95Qr87#+Mu
zCIn~sn5V<EW3-Rs0SRR(;bXqpIj+*VuOp(w`Ut!9y%!z~Qs#6;AaTH}f7NpH-tbdk
zV*bl?D<>c%1eZ|!b)WKfH1ZZgvV3$sU~q)~iM+)(2+s1cSB}TN^po6q2+8uXWtrOb
z>61<=2+8u%b>Q2+YFUaS-sC$3XZbk1)vYEpawS5te9UoaepUML)O&<v`RM)av%lI(
zaeZ|Dp#_H;()AJK@w-_jK-u^!0*PH2hKLeA!i9KXhqv$P#q0$_vew6ep=CnoZCk^i
zkelUW`-%hB(z9g<LPB3kD87DM^S^ZP#|X*t@$A$Z3u&a?F9^=^F=Fp6omV%^MM##9
z=2kx4>ACF*Lb81PG3KQeJrULa4Z&GHI!(&BN{{#wgk<@+xZ;I8YF&yxJ_jTWxP*_x
zPc5yW47g&s=wrP<T5fbnDp8ikrLCIMqcaa7C47Wg<5Z9RtLaugLr9j7C9g)_rXTY-
z{Dt5wANL2BdrQl+6d_@FB>FN}vr0NIf=fq8mXGf`t=UU&E}gTEef{^y%+8MG<L;n}
z9qC<l7(%jqbj{4zK({g-Az3~y?GtHABb{?VaF&lFKP~;Dj=1P!7$9MEbbW-ytV8`g
zI<HwsM?}{8=r&{7bo$1ab51RHJqaJ7l?G1=7Nl?Ag&-u$$Ic%Hd(p@z2+8uX;j(Wz
zX=L485S-=X!FeIG>A5WkAz{QN6rcIaS?A+C$q32vac|Sqp6a$uoYd>&hTtq8A66e-
zghtLmNS2RR`ll|Vk&h9Q<zufqw<fEKi$2<Cy@%j`a~pJ}gpXT(468vunwXD>EFZ&e
z4DLbaPC-bPk4?LdpRUeB;(#~I3%OZ7-rv1Z=NHqV2+8tsQOucPbSqO4lI3HyJ5@)j
z11<({kPm|Md_3;libjSaBovW^;=Wf#bfeeD7YNDnaf4mS5;U?wehAL;acy)9oxMf~
zLb7~}cxO_V-mj(r5^_uU7~Zz8&QVkQ0$Og~fuFK(dzGN~=^+To^6_4&p9AT85RVa(
z<zv8u)z<W^;ZzWUvwXbvdFNr;$E66#@^PHM#~ylpOh-rwA7StRDcJpm;-eB?RJ^ev
z1ZVj;Zq9XAdc>C_B-EvZ;;SycjH836AtcMkvz_1nJKLsU#o#W5AUMm%SyOXgQCBl@
zeOv)ZXrzRXBfbQVrE|YWMArHkY?0?9Jps2YtmWn%_<6YeNe=qfSU5tmeEb-D(}Zs2
z8-!%}Xpw8#7TQPGA`qPA<I_W3ooM6=gk<@+*f#W-vhpZcu`J&pq=b*4xYem%@0GGt
z{udG1xF`f?`FLblr&jd(xC$Ym)Fl-E)26xu-Is3>lI3IH20voeNnP~OwU`zhh!Q@w
z`R(LRPi-p^QNl+Uotm~6tmz5(B|=K9kAUp%b*&VQbSVzGSw6lmcR7;waT!9ge5|r^
zS6R9*Un3;T$E6kPtyBkGtaPUm5S-=X&-*DsO7QH<#8QNm@KK3sU{H0|_%6Xdk-6wr
zzC=itkEe5f-$@To<B|}Z<zxDi4j0wMOzg|$2nqH`C|)|^ul9pV@xae}4GDuIp<}-k
z7wr-D{}a5F8oM6YC_yw{SV`ymBFhjFkP@jE{w%&#r_K>lLU5>{TAg=>s~dlDY@A9%
zZkFIbT$=u&cN&Wjk|p@v+)V<?W!1d$C$=&TAz6Y~i_1NkzOCHK2!cZmNeoZq6;B`f
z{#_J8vIH;aQEnrBXY30?vIGy=KD{(8c*`;noF%xg<-Ct{E5i|zCHU#o=GuNp^zl6)
zq0%LMES%unozC6VSj){j@ME1h%ZZ+TS0N;{Qlf_b_DP7LkslC}<>R+e<#nEzwKRd?
zEFbe`__n1L--wVbA2%iU3ZsL6M@W{B%f9X_L$5oYS>K-i?<QltIxHWzj2PaHZsj(F
zWcm2x!IK3v(x4o)lI7!pd~M8WAG;tV%f}C&5`5I@QuJ{fAfYTJd^Eq+=_fr~<}R=0
zMqkmCkjLWVvT!<gM}%bg*eopfH5$1YAtAU#D@W&bm`ex$hL9{DO9c7;dl8({QgMBB
zs{nn;^0CjnwK}i<TaAz`A4}f9QHh>4J|ZN`N1Lh}bl!Q`sv-nu`FMXwryleL=>~*k
z`Is`bqYZsQnt_lKKEj3BmCj@PDXW<>bBI2+s-y*n8j|p_?DG0M=z|sO5RtWC9b?h_
zBAxpiLb7~(xL`tgdKGV58FI6H+|hA@&U^YI5EA-QLh<5lR_MH9?K?uUeEivaR1P}0
zdld-I^6{@<C7m~uZ$L<vkCQF(>by-b6CqhXe!ll!=T*opO(8hT$M`9SqUeceEka88
z2-i_9dtB9d16~FoVZe2L1jDPn``uU>aHXN*obGO><>npunVys<nBHn^KuDI4>x=Cx
zNO$E|gk<>`IiTskPtax$?okzjvwW=DIN6A9<raj5;gL{0^6H{$H1aP(vV3e7I(Qqc
zc$aDroaN(~?vJ<7t=xr>EFT;7c-@CCqCC~1l`J2N``>e=kv<5?^3k$>kFqLKTpter
z5=KYYM=-o|&zC#sM-v5VXt~iXB8eL6QNgM>J>XptlI7ze&(;;`C3iPMvV5$)d5O*h
zoXZ@7vwV!5mGO>lWmkk``FM8iZCe_-3n5{|C5ES^PlnEW`f^%8aF&nJkFEyMt?Yo1
zEFUc$2k5*$aw|fzd<>ZuHj|z;z9S^d$K~F0FRG<3`q<u5>r3cL2_G$uqPDAsi|gZN
zM3mUC!jd~~OOaE`C6s~{k-rg=<>Q1+F*>h2^r#8BSw4P085gE@rP#{N2+8vCbg)%1
z8u<$$Sw7yk3#dgSy=p;lmX8yiN+;77&RY=@ibz87TE3^3(wFz&5R&C%lbr3((nxnJ
z2+s0x-{-zMzjs}WkSreu=5EtSorpvqKLZkSOZfPpc(;8jQ7p@r)>>}ffgg+bfu=Na
zEkd$<^!hUJC5`-ukSrgU_1T~Gu#I{s-l8@HXZcvT=c_7oD>ot}%f}Y=hOef5%tT0*
zkAvr)X+$I2*g$ZWk5!%SKA@j)Z9+(>O9{oFOsb)Ci|8{#vV1fyQSUkZDi!xS5M07X
zSbA!#3aYLwJIb;v`nVO4&`1d%f5uzud>Q!<B1)`}umx__t=T+!bUM}5a?2d}f!v1|
zkNWrG;_OTAW`tz<c)m>ZNP1)N6CqhX{?2)J4(+3tEd-bF5rWq?+%Q0?q3oY%--3`V
zA5D$CPt(Ek*g-2<KJLxyT8rKZ`XD6B$2xuev@0`loj8b)Q0fwj*Vx?rC4FgTSPz0r
z_z0!m@_SNUb#4=V^admlC43xMEmG%;KYI|7<)eSC!!u|f^Vw^;9a-yR5nBhHkGpn7
zNS2RL%b(t+%W@Y&vV1hjTzZs7=5~PK5<bF!&opq?`4C`tgk<^X@g?FZeYki(Lb7}u
z@+Y4g{gKn6^&vRR$B_XGFPmgdM9QD&<8Xvz`B<q{jd;2)uOlSbBcb@R+B>JJGq8Bz
zr;?)@9C}hhN5h<pk5$i#to(_B`vVYclpx+(`6{p4M6n|uAtE3pQk$O~vYW0T+Xh-{
z8<yY;Pi9_GALNRy3`Izm;McdD%&E?mBJvGFvII}FKdJK`BG-lxoF(|?pw13-D_0^U
zOYn+!is^hq^BqD$SxSs}$>qM~=vKNqL2#Dfm+rW|rAK@vLb3$+IOGva3!Z_HEWy*<
zpL(e~4bjKujkMrU=@LGcSep5pKH9bx5m`Q#>}z#^&ix)Cp_LK?-fZTwD7ux6ogp{N
zM~fG^ztG5~2+8u%pyFXi`r+^kgk<^HeouFuSI#zef#573Z`JTxOv|$zAz40NAJQ*?
zK11{dAtii-o&V?GepbrPKl_5)yfFl4`8c_M=O3y(;tU*tkSrgQT}pbZNYTfifP}J?
z@NxJ)!_V}l&8vx)n|I)6zh!xypU7`RNS2T9^QNq$m)ySy3Be^4?>=V1Fgm!8D+Fix
zm}oa}30;;45R&C%$fijP==+w1nnEjCKF;~;rSo~To(ReE@rTD`CtC5t2+8vCqTk6)
z%J3-FF3MA=83bqf_#<LN163Xo*$*LEKHkr{b-Y?cqL0S`2{k0)<MRuzbY4JOyt$T}
z_ernDGb`wPNv9t|vV1fQT&VNO%V>mT`S|Ngw*vI&6mJ2+p)VyAcler|n|?Gg7$I3c
zp5C;~lWt`+Lb7~JPf1@uA8jk%5`wdQTsX6%9gQ4-kP<$^mH4Pp&%4r!M<XQ5$Cjfj
z-=-(^qHYkJ<>P#-$=Vx%MIVO&5(Zqt$Ah&FSEF;EMMTzqHF3Z39ePeTX{F`nebOsW
zWVhCISq?==mXFQPdq1J?K%7NLmXC+-%?+Z1o4G@97#<15%UkuTK?fg$kSrg&)N1~3
z7npq~cnu+0J|;Nr_g0q)apkdU4Z&GHE^bjX>pNQp2Fjm^3_?hjk1>_Hji6ik2q7hW
zgkAOUfrtNnO;Ty4=wrP$T5uR02_Ki(3}{0)aseW;d^9XPs40znj*zVNF_-^^Dm1b|
zTgc7w(P%($5Pki)7$I3cz8YAvAbsJSf{-j9pJra`L$|VCI|vRVE}{70eWS+Ht(=39
z5<Ws%W|~L+P=-gDIYfExBP7emQYBqI>BY>(1A?=B{IbUUJN-a&Awo*{2&=f`$_u7y
zU5Y-w1|)Q)gpU*aVpHixHu2PQ+e`QeqcijT)qe*ovX9Psgk<^XQrS-DXJ(lQ$?`FB
zK)o1xW6-8O1ZVjez41U%8o3D}Sw80Yy?c;4;9{kJLr9j7??+u*K)2Gv3xY!tNhrSl
zYo3BMG72GCK882h(TWcK6CqhXJ{c31L?gXAKyV2kq11bJS{kFw8p>Wn^l=*?A-9B&
zO~MWzr{6N1r=!+L-hrQoj~q(VJHden$?~zmwnCQlPVhWJvV81vHGCqCH0}h!Sw6n|
zRp2STxg3I!EFTY!{<W3fww*ypmX8K^R{wj!gd&irc=^r{T*5~v%gD9MHY@*9CUz0&
zkC0H85{kPH>er@H7EbvSk=GEC<>Tx}CmiX^d)qD$T*60K9~+%(VWCb$qK`8H35}HS
z(b3&2RwatL6A_WMKED6E>a<dp%B@BbY28)J%{%auqeA<y%2U$pH8cw$Sw8l@aD5tm
z4<ZR6Sw0Sn9^p?bUb`CvXZdKldSX0%%XT_KvV7b%Z{H(&)_8!B5<Ws%=1BfyN(Zm&
z4Z&GHX3n2Bj&5ZTLPDuaDBf^;)noLd_GE-)`B<sHbuSeu`dFvC795BYKBf;XrE?A~
z7!f6WgwdH0ezPw<rzayMYkdrTTE>jtYS{ZgZkCUB`PUAjH|h%!lI3InCf5?_R=!3^
zmXE`n`yQi_u00?)%g0NhsV`}HRv{$I$Fd{tZl+hB*9gh-vBN+oAG(zddqQxQkIuPv
z6{3*~5fbc?P&{+Rkdms8;(?#X8WLhl=veYe{9bjuMZxR#Qe&gtssypc|5bM0aXr27
zAGZprjI5M0B9U2?nUIXK`Xps<3YDyqJu^ZX$p|5{qR7b1ifrj)Z`mOuqx?EP-*c|(
z{JPHLabJJ*kH_Ql{9Ld5zMl7e*87}8Nw?^^S%`=%!F47LEJhFHzX-_^e3a3Ze`sXg
zL6Dmz_^5L+zVh6t4-0}3Qb2Gx4m@zO{tRh$q>Vz2ypE78!HwHxKchF?I)foNOYot`
zy5`W2-_1fumf)Rpy3VAp<~&A7=yU;f+7_x-kv<S?Jp_WY1m7{_iSoWJ_4I@zBuntB
zeLvdCdzsqDSAc|07x3}kBi$eL>^Kfpa`WEslYFH22>RKnO$Z593d~OVE&~?ON2|XP
zlI3IZLOnHJ#MxsQ1Q+lTjx<6R#97b>ZQBu&<zvGQRo6)W1L;rQLwN|v^09Vm(;#{w
z>OLHTvwXZ%r0)Z|iMApn%g1&(OU~25i;jRQSw32>`RGJX&p!ys@^RwRIwrJ_djJV-
zsp%uE>5m7U50m7PmN)f;>x@)#^B(wFSFJ@Exkxo~Fha6?oa*2@gC5GG2noRj6rX+5
zJ6%51P*-U*3WBqI+%wLlJ^d30Z-iv|81&)NMOvQ22+8tsrIoM7kFX6#LvWUlE!W-p
zMlY8`5t8L&jVu>u`p!`jLb80+TXyOrJ(haj5S-=Xm8<T(<ii*B{x}ej&_kL&!kRwC
zsDZ{0`I8Wlb-Wt5boy0#Y18*na@(+c^w`@wk(Q@FLb80E*C9*et9^+G31casc=g2i
zee^Mw{ul_(^0EA@tSEXchae=&$E>!8@6cnJfRF+{!lIrPGj+Js=@M4Gw&{(9;4B{p
z=-hZqkL5swWcj!(Z1&#|v=_X}cmN?;K291FXfKbY+Q(Akl;AMo0zQ^DyY5Bj9*l@A
zAMf_qTAfBFAtcMkuS4|o=+)A|7jm<F>`;Ee61vj|AtcMkBA?o2(N*q4NSGc0#Ve=0
z$fK()<_E!9K8~G~Tb(}Ea7Rc1AEmnfdj+)H<wCLYHlg-$FG8|>+;*~&#$&s>{t%qy
z<Iq?GjpvmIAf$kgun;}@`Og7qETzLiwU0@FgxL}B@#|uXBlN+g;dmvt$Qyp3NbeGc
z&!w}8f-f!}g^(;Cr&gLimcF`r9w7yMgeqNk>HZ@vZPIY6d#F|b1ZVlEQ_;LCeRDV%
zAz41o8Gqb~UfUiZB+R&g;)ja6xY9_Q2@ss+qjBWOd-N595QJp;*wryPu4?|&NPp_-
zd4Z5DAM3;f@0R9Y`cor2PlVtCKEgsY>P~1Xy+3XRBn+j1k1+|)P3S9^KM_%2e}qnN
z)Y&?W?sS()O73PXA20m7`(Jtijz&lUA7Lo7_j+EVk-rg=<>QBAeqkCr&twSB^6}#B
ziCyXG*^7`YA0NCo3Zs4egOJcf0*d=RdD~GV_!J1v^6_M^j5;)OFG8|>w23v>xH+s7
z2vxFt^r{rzllE}{AR)Jak6szyo#>q>5fKG^gibGh=CBFf>E(iy+;%J<OWJj=E9X`(
zZ9WLe^6|FY>$P;1rxB9nV^Uk4(R2@)OoiYqA3e63PN#221t28L$6X~_YdqSPf{-j9
zKSeKSPp=wPf+0BcrGVmY>2o6Ku^fYtEFagOt7t@5c?KZ`e1xrM#Ow2Qr7ERHQXj8Y
zoTdbaA_aVGxA5I=dbJ#jhyp%Bk#~zXJSH8zNXM*dc~TIP<>T^4{+aabm`{h?EFU*S
z{N7LdI2j>XK8{*>s7ST^(9)ke_%(!N`RHPLU^2ZB+0B69EFU*4e({w?h9V@($E7t4
z!fE6Sgk<@+GTbeWMz)#>!J*X!6ptt!)0RetBP7em*tDq$QWF(Ce|!T-APV^SJaR)V
zx-HwyQgSyJ@DcV$Gl$MLbnbNs$?~!8l?EyFrRvWJ$@1}4sqxq7DxGITaF&nPJP%Ez
z$8sY=vV43qW>iHQ`5hryKJI$_yCaS4F$aRPeC*WnUMM}5I}wuQV=u>24QXVdxlkp`
zN9%~?^XT9n2nqHGD1PO*k%fE(PyN78yn=)pHFbo&EPaYz5WV3Ro+rn)2OBksU}MRJ
zH9yg*`ye791yXlS@=c_X`w)^Pxb=OvA@s3}-h9Z-68v$C*UM;RKZIln?*Fd%8Tzmw
z79m-JcR2mjfj%D6T>!yZf-f84)S0fbA40MOe_HgGF^x<_NS5G<MoEq|Qhy-?2YEF6
z66EO@RQ#EA+f`aO)W<`^5RxT$@vs_>a;vKkfDZu@I$gj=3)@fQ>3hRvLX_OR2Y$v@
zj7*|?Xc$65m6}5dt45+<H;u#eBM8azabUpwKlC16W)TEu`55fz{)9#jM@W{Bl}65b
zLr>2Ugk<>`f2s978fmx~g0p-)lo)oHMh-zpmX8_z`~5xDlblq`a}Xf~e1s;N81`D@
z=CI)s2+s0x*DovO!((b62Lck>QqxCRG}i8{V=u{5aM3t`h^+mw^7knk4;YkMs^o6M
z^6|vkgP-Wbp?(Mn!37jwefzz}Hx&~QlI5d|ZpaY2%95cFoaLjhtyeIO9E6Z8AIo0q
zokH(CNeIdEG1ahTrqoi>pIV;M%OJRbkI<KGB1bfr6ffA9-U!L^G2*CY7G33WgcR@*
zs`Naw=<nyzq&-sYqw#VjIP{RFkFaPgI$@tnPq-f<vV4qN>pg{j4(&WbvV2@JC#D6x
z<yKq)xmi9YeREgd-mC7RF$f7`DWG`G*^4wD;yjIzEFU8b%Z{bxF$#m=0zN_yT`?Qq
zRGRUEJC6@SvV1hIG3*IFJ*N>;z(?rIl4XO;>AtKS4#8PI4x8|{JB{>3NC6+A%FsWa
z*JY&I$8&&$2^a9u-0kgLnW%0{)0IkY-Y31fWtwO_R2_hjEFVk0?OuYe@(e->_y}z|
z@RxND`k^tCRS=xz<I@u(6KQ$;5E7<GQ*o#=;ndi_pDUEYtEcAzLb7~(xb=4g9lYvl
z2rl3wR5|X_)LiLYT*9iW9FLGJAMF-uy%gaLLb7~3yDw(De6pvmvdS6=&hoK}@e()r
z@f@{}0f2<r5%95}$JYUL52Ya@YkxE|)_Fy*mKG68?xrjsr#`*&o<2bdLP!B0VQJfc
z#5;$s@(Mz-e0+2Gkr9owSPQ`ge1s~G`s(G;JrsnHFyoqv1M=xPKYzN)n+Pf3BOvFM
zcA8I5k5wcDXZh&A%P;?0FLek!4Ix=RwkzM;g?@(UUxZ}&=rg}^b=t>P>y+Rylmb5L
z-=15Yes*dVBC>pJFt?XKt@tN|6z~xi;N-L}Go?q{ObaZ)o!3KdmXDvl?CEcokCXn?
ztK}|)WcgU+=S7Y8f|cF?RkD1Xf1_V7sqdvfb(JF!lIP<$-xT_EA_*a(i3AkSDpRp2
zt+?(+2+s1cuD?w?I(R>XWcj!&caT4g+>4MbAB#EmeM<Y72S~^*;NzQ+lbh+;@rY7}
z68&acV0M1J9D0(@y&WM1e3T&nJprxfo_d0w@b3u8@^PwnqiniL*G&+d<>Q=O<A!vV
z8xfM_<E0AiPtrTj7ldT_*l@rkjaw+4HbZchk15{ow$N2>L`djMfhNjJt$mCh%g+eO
z@^QM;#84X9X$u5r`M4{mZFl+bMSZ-w5s*-%fR9!k_Lrm2%)TKaYkzdfuA}j3de>+r
zx5yiQz{h!+4~o!LZb3+vk2*e~jcMc$gk<@6>-WP18rfqj1ZVlU&b{zjx`$#AlI5ex
zonE_WWG+Iod<<y6B#QRYZ5sq<`Pk)jPmPb3#2_TJx`5&aDaYSv1V>1gkFzd4P@b_>
z`{=e^2@XU7A2$!W{*x|pHzKlp^!q+*3XLor14Xj-M~fTPr_o3cgk<@6G%~sb-9vj3
zlI7z<|88UHDhuy`;4B|Y<W?O(BRvq3<)i0Ivn(397a>_b-tl(5Pa})&gy1Y6kCtqs
z@u?$Egk<@6#;t4`J>zi*3HAsm?q#b}RKDY^e&DC*E;%>=1$0bkzbsHb*Ha7L8-QS=
z0I|}po|g37>_tRC3Zzc6J|0UCWYPRz<ct_SX81t+=DbgOMZIcYf!@kI5RxT$=dQ1p
z(r4na2+0z>zi|}}!S(h)aF*bWf){IifOZf<vIHM7=GAa|#t$MSOYqi3O6{j-Tz@YF
zX9+%a*}eq2%0URp68!sHeT|<@97IU)QJ~e&J#a9U`%>+rL97xSwlV=9Gt&dz=?h~+
z5s~HNc>|Npa*^tb8pjb5sualWlcBR#Uf9&g3UQE|<>R*zV>G@k=#7vpAKNdvnSZU9
zy2y9}Az3~Ku39~gZp$k15S-;>`H#ih&`3XoWce5#{O+54UZ$R&a|p@uF~{0t8vPP4
z^L-GU<>R1r)2!%6E`t%0<>QwoyY%GXY9Frv653M0$5GF3X#51Q_I@Qd?+rg^-=_bh
zSIa2~$?~yh+?I_rG7TXixPaoh`j<m#WVHkc&hl~E%#Fur<OGCd`FJ>Bb}HRN7Z8%=
z<DN=a9Ox>mBtmeOk8@leYP`g2973{uoU9W*Q+}3Qt#}GTvV3fqwa=Sg)GHo<;4B}n
zI`=6;`{)Bm=pg|g^QJs`MHiWZh^+l_`j`FpXk_JsN^ag8eqL-%x2Jn(EJCt;EL_WV
zHQni_5E8~xK=IVYuTAJGjglZZ%g2&lPruMrjzmb7kB?U9^rfpjjF2oJH(xU_rmHkK
z1i@K8*036_v8WG3NS2SM=3E|1SDAp2EFTTt49SrX1=ahb&S51uOt^rLcjLBa(X-PR
z5m`PiPTV$tM#do|Ykw?d|7|RdEP4cTvwR%gcb>*gaSw!K`FOm`j2L>tcOxWBkAULk
zeUFr<gXbb7%g2?^UR%=0o=0IUSw1@Fj&Y`u+YplFV_wbu9q6(Afsia84OcywNbeI}
zlOZ_E$K7jdpQiW6O@M^i5%96;<A&4dB6ARt<zwxIdKxcFay_Qx<~{I}*v9Ra#)Kmz
z%f~;LM|;u89|+0vapwcQA~e$VI0R?;7+~AWg+6TCjF2$n0*bFK*+@g4F9^x<G41A<
z09u|-Cm=Y>$5W=y!sxM#L`as8cMJ<@yrcUALb7}uHN(t;-XGhaRD#1$3iz1lv%-P)
zaV;XUeC$#ExE0+)9}tqYKlb*UcZ#mk@f74{`FQbIy+`zfuSQ4#AK|g2m<d-hq^sZ3
zim5*5d4rHFA3t5VlR;P6?lc5v`S{U1Du*7+)d&eqB%t_)Aj2Ir@-0HLd@R*I<t}|~
ztZfPeXZe_$(M{vE-|G;P<>R95aTDnMF$<88TfoQV`yXjcxbqn$H}8R;rscCX(W~V;
zgk<@+`+R*3dEO%=%g5LYkM_t*n_3>nvk+XsM|cb(_;AoBx-BCRlI5dmbG;cf@;ySb
ze2jlRD~v|AI|sp8KAxJ^IhtO9*B~VHrGVn8i~EJrRlY$;mXE{xW(=i~4(A~_%g4ya
zC!f$ht^_0$Dd6Le9l^KgBHtk*Ykzd|HqdxihvNk$H}8R;*GJ~Jrsau1NS2Sw+s`gZ
z-+#<PNS2Scue`iM-%0423c*=E-f7@sOd~fVB+JKzO}p=)k>3%L<)fcfmyY!GxL$<d
zEFb&nP8v=lw<098x`5&aRVUt}k-rd<<)c~7;w5qusjuhsx}*dLqJWQMYqivP)O0T*
zvV3gS#@>*g@S<r@Bx`^Cl`uDrMtUM7%SVqgZ#5oLi9<-1k9}8eu%QnwbuL42mXCQ$
zEj1pV@<d3Mk1qagHLl>rAtcMkCwF}c)6-M*3Iu2Q*ugMsDLs~+2+8s>{?w>=y2`x>
z3HAsme)mvs<yq7J_rTB9{{=^H$I{dhPI(&p@2nx8@~8#x4M4C_lL!ZG<@_Fd(C<*(
zi->>}NNurtgFC&j<su|YaIX>{{-LM)pKHoMHev}r^wIlk^mOk)NS5HS^S?}|gXbY6
zOYmd$_Gwh<ejS3d1aI@ottCB{yAhHl_~}+#%<1=}{y|8V;C+`mY1||2e*=QE1V8id
zx0`hE{RqhtyiCHF@ANNFbZ;tELZ=J(=<YpgJ>5eC5s~HN)0wR+)17`0A)!hE#lvr|
z)_4cM{w>JO^6{ucne}v)!x56@V^#ec7w8E;ijXWHE3KcQ@qzZz=@6Xd<C-$o8i!cJ
z5t8NOxl#=^4zZ3RB+JK+3xYMCJS=+~g0p;___b&Yy46P_B+JKo=7;OcNcH}B9FWkK
z0zM|bSgw2}SACtNe1?*n_rTAc-eWW#JRFUXEFY629a__;%_k8Of(s~K;#8|0@=&US
zSNIo#vwU3W>bs6cjzLJ4kI`#N)TLLA6oh2?_<2dGbu`lW4g_cU*tBqxCyn$)NS2QV
z*NOzuYuj0bWcg^^U~v##rE&hX;lB@RH*eI0<zr%W;x+n&)EAJ@LjpdIopU<>V!w33
z|Nmd~zleye{c-s3u|sI2**zsU?}48=m+a=!LpdHHSw5EQ;&+Cw@&ZD_SPCfKa8#d_
zbd{#}Avnv&u-^&8=+lYu2+8tsvR9Hny=t6BNS2SQD_d)P1;zLQ1ZVk};`v$QlAtd_
zvV44N;(dgk@pA~t@-eU4sY>!#s`tk#50&6B;Q~IE`4JsK_mCeVvV07TIj-><@pA~t
z+8=8?`SzVYL8<x(a<hDN^oV*u2cL?NEFZ0#7%rue*AWt?M?mq(zpM|@&uLpehTtq8
zbr)~b_#D$*gk<^Hsim12Jv~nmlI7#CW95u#WZNeYoaJNX;x7l#$c+fe@^NH2Gv#4_
zwU56639}>M<KC1eHR;b#^?a)27Wt$XTp}tSzje3t>W_l2|JaX^EFW*bZ0l*BkCguY
z-@)ZGsFLMlQi<rE#`!quPmP?4kSrgo2L-O9Us7@pAz41wywxzYT7HGnpSsGn&mlO>
zxPap4V?wg&v5Y}TmXDDigEc;0XYc~5WcgUQtJywz=TQeAfsia8Z#kEEPM`D~Lr9j7
z2lu(0kyl`~kL6w}!C@!`d>njf+&DV-NJJFaAK@afZgQu?(wZ)<Me3nEj*u)LFPprW
zLsw~%3AtH5t{t@R4Lv*K5t8L&VxWB#UFCU%WcgTmXTo?IY4!?&vwTcEaNvb}O;9~O
z6A==cNI>x>J#st9r%`I;RfJ^u=vLOpTkdo<vfgV5&hl}f!2&%x_$-8E`M9p7hjPnI
z?c+T_LT&*cqa2s_p>sEQqvYm2@Dtz4xjFs7&s>CL`B-nRe!kk0-v3|m+X%_>(ZQvT
z2aT-z7J{>U9K5^IQ9Af^gk<>`p5?6Z^y)Q)Wcg?`wEP4*xWzjN&hpV=QPpeo+BO9t
zp)Um#54ReBl15%eNS2RA+p1^N$Qth<ILpU@C2uP)@KyUb8IVw<fRCq}`1{jEUO_~G
z{Sl5=7dsF9L{E6l4@z#{13#9}8$F?slM#~T<F|l8LuuqCgk<?R>5okh8fl&d!C5|T
z=%28UMg|}x%SV@s&y+P?z4M$$NS2Sk`Yi7uKZmA9ntX)dEFTkHtZUQ3Cm<xWx`5)w
zefyN9m&*$X$?`GiW}iXw;fvbGDxZ|#KoszCx5=P^bZ$RHWcgTcjm;Puc?Ka_`{RhP
zH|g|HR{jjRSw03WY4m`u(i<UJKEC{u+p>864lezv+wwR<vV7c>FjnK+^!nKloaN(_
z9rY^E!3QEF%g3Zcom^>T0z$HU+|{@2IvQF03j}BRxTI~9L-f|u7a_qO0maXqO718>
z39NqLCtg89qYLPmdC|Cu{1#ia;Dx`+vC;Q_1c;^+dTacQbQmJC1V0^_Q;MFOg9r(^
z1qL$i&uEQb`RaXx+$_OM?CrIRp6&q%$rAi}N}|Ri)d>j65<IG&n;AWpCB8#&mf)Ye
zo$f{>`yr%&;BW~dbxGO3Z?cm19`(u=kB}_EvlAY?lGRZob#fp$OYj|z%{tP-`yeDs
zaKCxgx6*Ii+5<@FbO9e@_Wij`pO6;)q2xx23&@iYcrTJhdLkrLDS!;i+1-jB$~c5%
z`54tZ^Dtdy(Vq~U<>QZ~X>Do6JrR=SWAX8OTG3U;A|%Vl8rLrsrpL0_F9<H+Bb@T=
zzMf)DSJ?+4Sw6OQ4jxD&V-b?&<7|t?8t;%P_8Wq;d>m#z{1SZt+y{`*mI6MO9o05i
zBR3+l_QyqiE#7HNc&?J0_ermlf6C<1RrWzh2ri&_`QFbi(8ySXWcg?x_~<Q-ES3ks
zSw1da`g=Bw^g>9MkCqL>!)RnYLb7~}*>Z9-jnw@E!C5}8I@P-u-9-HmlI7#1rps&6
zRmLME%g3MNew>h3VD<5;ZlMbQdxoen^pJp$DVg!<^b;jsh{*EMy<|yCdC^cGYV1Nt
z*8W&Kq?*RtdkYta+$<kQZ&|%vKGaZG>4A_imI8_&ieKnM_fQ-{vV8QLK1<_K)1pNn
zILpUJ#)I_f>G4EJmXBGMZ=Tb^;}MeOWBsdjHC_Q-tSAI$`8e_J4~-w}c_Adr$4_;#
zyU{+z0}>`&z{kE{3Tb?1qgXK|H}8{P84v44(VgBGAz41oj(nLx_fP^tvV5%L)9W6+
zTI%UQaF&m+mqq!|$Uz7R(<7kx^-&AVY2-nKWck?h`7MouOMP7k&hqh0vh76L#~}#G
z^0DzL+cde;)yw5Ugk<>`{N`6(y2?_;A-I5#aN@kTmG2<w-hJi#KlT1N5RfoC0zOVy
z^-m|d$fJnJ+8=GFWS5|OsB{S>H}4HU1AAAyOCyIPB+JJ~cLQG2$fF3!@-g(3pT^DM
zviU#G{_hFs#!Xp1PI5k>@u=xYgoGIvQ2g7achl+M#}Ja`W1`J1jaP9R=|OOokCy$C
zf74ZtL`as8P7YTq(a2*6Dc~cVIG1~zX(1!kJ{px$g2PY>_&B;uwyjK5uS25{k>#U(
zsgLt$<Z*;#?T?2RL?5J)<@F&q%g6RU&tB38>fQ*+^09UN^-}aMegq*|K5lrteG9!!
zlr@0hEFW_R);npEzn)8f>KPw_kkCW|il_e`xrtuXFCZk#$9V&0YkZE$)DVKRe0+Xe
zM|qlD9eg}OvV8RY;66#7akY=BfP~xvKEAqtJ%#Rc^U_Lg-UB~(&szD(MXGa8L`as8
zu?e?Z&~2H9kSrgE_dlxfGwkYRAUMlM6R+qf`U$To2+8vC<(<LZ=;^tEkSre`><RBk
zBkPof;4B}j^mC4+XM8$BLSG6fem$XBMY_s#gk<@+AbO<6Sk@~C!C5{&Fw5I52Uq(z
z3y@HxfRC&F%P8+;SId)uh^+n5e4tx5`bQ3pjFjBG2Y%)i?Wggx&!q^-^6{%l{8st~
z*HeUK`S@av^-OxzXj&eEvwZCA7BiMcE<#8FAK{#*QR5(gX)}|s>KT88kODpea{ZG}
z>uID-1qjaaarL~-&FG5|3lI`oT|n{fI$q6XdH!E;gk<@6Yg^ftGE(hhvx-V^APV@{
zwR42COjH-S1QA(2&eQF!acA!tLbCS9!GW6}(rwwi669w2xM7>$X4=P4gk<@+*UIZ1
zUF8#mWche)c4{15WwXi<T);;-=b5rjzbaj22to?@2*~tjdmqurhX~2?F<7sRGacN<
z7=p8WJTUaZ-$h8ORNd<H5fbbXP<(N;`z$%Q`hlN&3KF_fK*y^S{0GU01!}<?RFPw&
z*9`~|dpQPNp%2>TAR<d}<AmPt<<#nde1MQF!P{Mp?L;rXO-vv+45h%_G_Jq1Gu=Up
z5RxVMpzDi2X#__|mf&fH3z^c$CZ-UaC3twDN^9t`T!4@)!7F#amjCm5>f1?=5RxVM
zsdE$3=!bS&RE6Ly!Tm<x?L}7^j*u+DL)Ik5%G0Cv@dF^C(*=Ayvue>WnW&bhotcuG
z_rOocejANXwX8u%s8T?lGa){E<#kA1<vWCA`4|#=Bbr9GGl$?T9~)n;y_4?r2!v$$
zxS{Ia4m9#3Lb81Pv^PAQ4&JF61ZVk}yr}L58o3c6Sw6<5m$##Xe?dr=k41E%?$St?
z>JXge<4o(mZDf1YK5hjhw55QLou@5oLZ3b6AR=pjw2$tV|I=G)wREqc<mNr_QzK4q
zxtv?=V?07aZ~?^|heWlM?n6m`YNSq0sFLO5;HX_=Y2+}3Wcg^U>rjjS)qM&=vV8pL
zGk*zvL{!}Zg0p<Q5MC;cMovXYmXAA(rW(=6bcAI2=(s1`l=iV<EeOu?@!Bd|Lm8>|
zaRDHqhXj1wV%k*WWl0Yak>%rw@CJqHBSG8RN^ag8em=L3>`42#03lgE2Bf6h&{f_?
zNEk~2#h={x?n57AHME4_EFaIW9-c~9xey^)K3czh+KKM;dkD$$G3eK<GBmPj9SF|y
zal-@)<z?sU<#HK9vV81xZhRSfdR`$U%f~)W55CHMsrJ#)N(l}VF5u%)9oIQ@k*g4q
z<>Q7<Ydq;|P9G4Gb-cR$WqEhHN~gMzo8{w%@R$8*<VJ*K`IuSHKZD-Pz9S?|kAUK<
z4vv39AHKNPgWxP5Pu6hlL<irGkSrhbvd_<?k)^DmN|uifwTjK4Uy3jcAz40_Dn8*3
zy=t69NS2RVho5khTV3sAmHJ9>m>mHhM+|upLKo?Wh%6sBo$lYAereD}gk<?xulS<Z
zbX(SI0J&K{rmlFHKqD6-B+JJ-qg$_`Uv2aPAz3~)jF_K8zlW$(LkJEtE}(d{%Zh&V
z0|q+~lI7#l=Z~(@2kLr_ph}jHksr2L)4@k0B+Ey$yWg_uv)ojKWcjH3)9RLtRQqV&
zSP2e8Dd1y+flVIDN5Jaif(eMo@-g=2;P*5#4Ix=R_VW2MRL-rg(xM6EX8CwA_RnPc
zN7z9K$?~y%sf%OjZ6XaJ1$=~Cg{FgdR*+VWf^SQzWdp%kK7RW=yEr|Tvk?-SNI>z;
zuRm<1k^dqj%f~q5rhVwKY+wt)Sw4DfpBzqK*I0m%EFXKk>7u+)TkYdhKtgT-A6rjy
zJ}mFJ>Q1+7s^sQ9@Z&wUUKJV{ijXWHPnK%nPw(O{5R&ENn2_DG=>sB%W)Pg^qltUw
z4SJhchmZn3!mUEj=pX&)9{P!p0zQJ`=Ek-5NQxJ{kmYU%!C5|<jnDkMYDidh6YWPx
z=t}{`&5b*@p^yDb+e4KsAG?<h7)2w;A|%Vl)1S<a%dM{V@e&}RNC6)MUXE{1cY5{a
zN^X1B{&@7;niF)VPen+UkLPrf@^9D{%K!b>|DW&-gk<@6Z&KzU8fnu4g0p-aH)rTp
z8o3N1Sw7Ysa4(6Tp0@}o;3Ft*cxK-Ux=N>(5S-;>-CbS7=wtuQ2+8u%qDX8AEl(ao
zLaPfX{_jA)OY|Xdzg7@jz(-iy_I2FcPdY=9UIL=_F&U6R6!3BJq2&hhD@D{xn^|k6
zNc34Ef!v+0Z*ih$XEs8ze7wD^&LDc5c!ZEFAH5BJxY4h3ZP5mTvwVz7DffupAEOYG
z<zwjLCGF_3%tJ_)j~2u4C)3Ej4iKE><C3}uBWT4BAtcL3@9jgY(^Zyl3stgwEIqmD
z<=Xk;NPp^9_eV&uN1)Y9HPqcNUtd)}@bgeXLJJA#_@I8N`|`P-TJXk>a%>ye9R-NV
z6>|F0EBZo21f)RfkE=a))8`UT5t1eNiHAFK>FI9S4sx>uKUt#KIe946(;b13FgpUl
zJFF^~NeBOkkSxJxJbs)-BRjW;;4Hz<n(f&}Bex(VOK{gt?FZ0f`3oTh1c$9GcR;%e
z(uP~`Fx{;K1ZN4J5p=2r9ef``vIMtH?^aw!s(sXRQmTYb7x3|jc@J-ysBX(4h{*Es
z+mapc>E-t*LPC`So&Kbpg%dsDl{!LhmXAv&AE-bheG!u7W5V*+8lRy$kB}@Mb3;db
zlh1h6(^J(Mg0p;V{OrO7I`{;HWchfcZ=%NC$25c#@DUEvGuqVJNB3o|P7s{s<HL1}
z!s)S`j*u)L+n!y&N8WJNKBfZ_+ET#BK5aLd)48oWE4k4#wgU1rt<|_Yjhu~;EFV2A
zSESQDbPpjRxImSW?#XBAqg9(O5S-;>n<o`+)7OB*5R&Dienk3Ky2|GWDc~dQJUufU
z{iU6!;I|>#cZJ|AAAgQ|pFsaYb2CD+d|Z^c&6*y|uL#NVv75o_X|#{dE)bmMqr2g=
zV)D_Y+Q*H6gdP&`v0=HTlWBRrBO+^mZ1`JO<D=p|T$S9s2Yv$G7M`bvayvq@d`$nh
zLr?k~Hy0scECm#A_Hafjy=wI72EkcA7L9G~LL=i5Qou*pd8Q3``GOwH65XLnmX8BI
zOgT<B(LjV``DnBF^#>Yx2q9TM4qvzEAdM{B1A?=BoVfqbFd3=#(HoF3;Q~G`oPKW!
zeP(tV5m`Q7^tx?AUl=p*spPh0?T<I+I6Be`@C<}x`53aZ^dxyG)klIi5t8L&?Ih1U
z`RGNBwC)ALVR{4<@9!6RR$hSB$XN)<^0C&5J_G6C_Yjih<HVg~OVUVNHwe!1G3HhG
zXY`YYOA(Ug<Al?8sr2+bMo5;A&cRQA%fZz?HvLBl4znZRWAL$v-E@&l5s~HNqNZu*
z=mq#GLb80+I~?_uMmBec+$<lHL$5l~!IvW>%g4k|gDh#}3xs6(Sp37#A=1_+{i%Iy
z(Hnxpj0-5f@<s3I^p?9AAz42D2(7AoDL`H2GlXRM_@eFV>+~}VEj%DN%SX!~M~y0%
zBP7d5pDkbB$$hEzF%yt5lmb4cm1tFso}Jcxl-$i&K2{iU_co1Og^(;Cdk%}xc$wgP
zgk<?>|6;QaEl+z-2+s1c{<L%_`Vcq*Az41oGP4h%+cFy=Sw6<U=wd~GVz09o1cxRP
zP`t87dyS`a;t-PM<Cc{d{OE@nOZ0^*Sw7Y*RO%UhkJJYtSw6<KJXBmhx>Wm^3P{K;
z;A2Jev%BabYxPrd^B(xQq!;B(A7jlyNS2QWrr71*Pp2L*cz}=sKEh><a&E<MNk}QY
zdQETMAA+-d46Kt@g06BELb7}uWRQ~oJ31=(Cxm4A*!WlJhH?+7gS!rZ;4B}*_BTtQ
zXM7hzLSG6fz9%yB2OYfFK&X=CV~NuV8o>u4B+JLT`vy#r7j?Cd#{daM3i#OO+6rrW
zO)s1OJj{P@QMBPb@MHM$`%YT%F$l@>(c|D*6S{{kBBX$ia9N}HrjM>P(sD2aXZcvW
z^mGgPY(m}Xa}ko|W6+SLo9XF!fRHR7n=Bvqkgn2x2n1*Oc(BPNjYmyaASBC2yB6mQ
z(bMw|A)(a;6n}G~=Mfs&c_;*D`50Q$>p6YAx*d=}6!1}RWB2?Yj8Y5mZ$xArug*xy
zxJFNSpJ7Vw<}4q(cmH0Q9?E?P$?`FxU9;(QaKqtHCCkUFkNgYK2kPDk$@1}WsbN3p
zo#!+{vV4rM+B1$unvQ_rEFa(9t*l1}pM;Ps9|xo@(fGp16@+B@xWdYQ4_&3jNC*!0
z2q>Nzo~gX@Mg71}u!4m7*3=P>+8ippJ}S8*O^|xSy$V3EQIiP!&U5GO3+U;#93`i=
zZ3IYx)C-<X%%cZ#7DBQFU*a`N<A&xPgk%X`ZP7D(y2{3*AvjC$=5g=J(#Q~mgb5cI
z%l<_^_MxZe2|}_2PieidHNF0}^oHOp!98EKv7m#mL`at4U+oWQ+>CmMkSxJ}7PHj|
z-oXcgvjksP_T)V|xZ1}JfP_vL@UhC|E`wyE`k?I#BC>qEJ}B*=d{m%Dx{OhBH-;(&
z+A`;J@1JyAMk6H4$DU6<jilQ$7a>_b_FQ+}l&-S(SP0JYvGCI8U1(%HLb7}eI9+!o
zJ>z=gph}jHQG>R$q>qP&ASBC2pH~wG(^tk$ASBC2_Y9*U^jKE#h2R1{!v1*qMv)My
z)ul#K`{)ZuXiEVfjoNv2rDx|XBC>ou5q4eU<2+UUl-#^G{4}m~vp7AJ6A==E3n;!l
z>ESXu_*H~t`FQZz_K);2wWU7<XZcwB>SbTLE$1L4%g1vc^^efO?;s@0NAGG2JZNO&
z@erKlqurq@8ZVd#K}eR5^L(dh9Jf71NC6+==+db6fDn06SNqr^KnV^#B;e!ievXgn
z%`6NNSw61s|44aiSG_;JMo8BFXuaIzJU!v<CO~eMkHPaBte}yR2nk~;pm>dGZQs#X
z#y%q?%g6CP6OYiy9upxr%SZR?Ei_)@6^oE8A9c=`4xp>lp9EF1d>lA&NE*Emc_Spt
zN3#)WU+Je*P9h}B$6<3%CCT=veJnp&2@Vr3;N$w!mdZQ4)be;EBFjfxm(uq1P@YCe
zmX8i!%Nfzg%2OaW%g69qYc;;2ISwINKIRn3^r00$gOD&i0*Wsxv^s+hZW;)|Sw7ZU
z;D4R2ay&w^eDvB@+gEN&brW4gNS2SD3#O*fhrrc?AUMlMH^+&;XdkB|B+EzFcZte-
zY}G#A03^(gfRAsSJ3OT)yzW#bcT<*+9oJkfO(SO_B+JL4>mxNL{5C?eeBAkOqwRE+
z^@AZe%g48akDQcmZ>igI4nnegoH;oofR^W9goGIvP`p^>Y1QRpEOnKQra^F)kN+5U
z(s-&m1R+^IZt|>gmsb2KLb80^^s2+(6Fn)sI(YN^OZWfXE3|FO^6~Z$^CR+Ds(lOt
zBn+jdk8nnMY`IQV=@$vo!xicx-youZkAU3Nw^gF_#;qC!kez2Jxtj_22*~+o5_?Ix
zrGHUZxeFm#KDO@tr@Br)PWn?Li_U~9Sw4Q+lB&GFSB>nBkSrhV4{h%*g)SI;D?+k-
z?AF<FEd40WAB2P^5>R~9^_`FDmv{}C1!Kwb(ebHE9eOi6gODsAkB_k&L2tR0XG4`N
zAKOG5c9xe*wT}}43Ar_Wgfr4jCi4R6BGV92z(+vZKe6~u|LDkSj*{C>z(+tn4Yhbn
zUnyCLkSrhVavQ|a=RD65Qou)8HIkdoTP%&G6khFPySWgY<zvxLmnYC$ZWKbYd|YYN
zS_An7Az42DEZlntJ>#9{L2&3x0mW;b>r<5WaR)*Q_z2VES@Tl7wB;6D+kPV?%g2;N
z*XHtdMzxP_^OfLGq^6HhWY29*SES9X;0F-*AfkYefc$aw=5QKmumFl=`55K6#+H_6
z973{uyyCTT9*s;xNS2SQhG+jh*^_2S?PJ}A5M01V7|ROhb4ExDaKU4&nFuN1BOpDE
z=f+FH3$7afA|%Vl-5r`Omi`CQpE`K65C|^dBUD+{uA!~;>JO^|$Q1|)tuCPWq?Ij8
z(jPg^Lr9j7$pII~(8sIY7Ae7jsOcl@JilN4zC-_zbUPvn_z1}0VR3J0WDY{Ie01M&
z_r9E4J>gvzLvEIj)8DT2p=T!=Aq9Md;D?-(Ea`KeY=ji>5s-hj?$CI3e3vB<T);;_
zuI`gCM`O!HNS2Q)3=eC(wc-mx3it?BzIxkfCjA30*QF4g<>QHu7By+)CWHig1QZX}
zpQ-HP>IZ(Z6(mfKfR1-FeP+pxuHJB+Lgm=#YK{Q$d4*Q7^mURAh{zKB=pvU8`6yj&
zV>Uvv1b3cwwLN_})O8u;W(i&<GWs!%j6z73;I|@gFV_$pAz6YOnHtoSCtN+2U6w;|
z=plio{9U`^Jo=O;8X;MNhhKiPoJJN}0adaDx2^Xznf{q?e}rTS{%wBHANtkg#}JYw
z_@T5q*7A(2eKZSGf<vbZ_&CMRJCI&}Cm<rr$LF7GOrw#h2nkgR^w6;B{@rM#Svcfo
z`Dk~z@&S7J4M0eikFz5ZT1Z=l^rx2R973{utWkS-eL8rhl@Ofe<HXh_Luup~gk<@+
zGkaM{dIdg(kSre!`hK1#pX#Z{(s&gFXZdKc;HJiny#Rz{`B?Q%Eq{5rRQs3;NN7s|
z9|P8(SV!-V)mJOId2jeJFK-$l7pWe~$q32v(bD9g72QME5E6n5D1IchTyGj#YYhZv
z`PjnAaX5_(LP(a677tc=)2qf+gk<?xr2ONO^r}%K0)n%A46f>~O9u}?NS2TFbenIZ
zkrxn><>Q`)=O)stM%A?toaN)ay~*Y>QtjhJKtc}*_?YMVcrv{Xr6D3~e|&eTULvh{
z?MNjz?+rgkuQ^wuk--Sb^3i3d-Ya_5xPg!`mYRygMU8`vy*5k7SOsrJ)msO_Sw4DJ
z>}5&Ivlt;+KAwCvBDF+*mC~Pjxx9~%EFbM%#xJK=je6@LILk+04>OG~u1!ZsmXCdI
z{wYQ`(RGAm`MCL|St@<JYPmrP4ihfmW9RKH6J*2Hvoj45Sw7m1);~+1nWZBnYkwR%
ze$WUSX|)k@vwSR_Gj|H@<1~a6@KMsGP$7%?Q#^F<InSae{5C?u^k^y$$cu}U6KJG$
z6a;7a_^?9WUV1ENBP7emgS*@8ppmx`lI5dEu>sv^WZg{=oaN&%i?jK+#;6}ZPDe<V
zk7;w3t)+du3rLt90Uw=RR~(@yywPSQH@ZY5&_jCObu{+J`3NcCBkVk$t=C+nFZ$m{
zNC6)KdE(*FAnCwBnj!T<)M5(+XZcuVKt~OERw5+J$FX@U`bafPf9fjVASBGV!1M(E
zEbk-tkQ(U}4Z&GH`dqj<gzoh92+8vC)T?v;bnqO6Wcj!vFWZtvx^0EvEFbUb*=E<w
zpBm{;eY_eANEk{@AEmNN{9V)cRD4xU+9nE4c%^Mhks@#S0c84Bo8HpL2dd@&sVCeI
zAq9MdZQ^!9{Q>lZrz50*kAR%Nt#Sz(*?2nyXZg6|M7wJAvHwzpWcm2cWypLQnTe1r
zA8-80szwKQjDg_LL;{NcoZs*kUF8OZWcm2Xp~)W_`5hryKK9Q#T#iQe+yTK^K0Y4N
z_N2VFseRlHNXV_}Bedl~hlWn{>=fRq6v=zTPlt;KThh7vBP7d5pCgC=&{ZZOB+Exj
z?}|qBYH73!g0p;V`DVf{`q+OQLb80cSUSv*9?NqG$?|bw|Ey;;vf6G4&hpXBZI{Ma
z1|cN$rGVli%azgiC22ZBvV5!?GF#(o%MJHHaF&lnD^$KKpY*7GTnI=gQozS6UCjH_
zo&FdRS?7-j4*GVcJH6FjCAYnRkFe$bGHozJ`p}W|<~H?~y9OayKE@QC=S@HG^9vza
zK7Owd--<?h#zJtGk0WbF9Hplx2_acN+BMz#o<<tQL6s~Y4P*R{(~A2dB+JM4ubW2F
zYg;NpLaPfXKGfIiEFHXhJOpR?m|85Ti`?pJAEyBlhyp&2vn({29?A?vWchgd`{E@u
zvhhA8H}4HU#p5FL&yT5-y~PO0^6}n{x!dR}GZB*Iqv4e$8b9TC+z-K7J|11wdpTX@
zT7+czSjp+ZG#Z(WkSrf>X3Y(d+fuz;x+XwymXA4lH8c)^cOWFo$NC3Kr^}m}y2>Jn
zP$k$Spm_Dmt^DL?+td&I^i_~BlA1cg#&bEQUUz93lIm0oz8ipGqb3m!fT!p=TG4Y;
z<ba&I8Sf20g`Z70N_S9ygcR6tp~{a*9oEs0e<UF!OYj9IZF<qjN(Ui0OYjVXQpITG
zWQ1f1-k?hO{_6RYE&ZvRG6Nx5g1>ls!i%0Bha?CNZ7I;_2XYtb)5x_5$r5}^h}C-f
z;3XR&S%OcVP}7dy!+Rcr;4Hyy<6ddpK-mdM=yU-eZy&v+@dfZdhzN=c%+8aTX%_VC
zxF1$>^WN}d>e?-Z9?Cd`WcgU>i`y$2S^Nl8$@1~2#lJc<av(yoe4ID(m?J%wNeIdE
zaZBM0Yr4v^`N!J-{ZO%4W0sG7p4R(CS2-FXSw3!d8RbRqjwuMq@^Rhz@g?bd6Q;=!
zoaN(;OQ$v7C^8<9(3S!|j$0l2g`S;@h{*DB)*b);G_uAqB{%O4KZ(}g-Q^2o>TMzj
zAtAWHs*zi6sVCh-*AbHCqs{WN8b8UccN~JVe0<#fS!w$4WiCRpe2n+J?MWjaA*6th
zaM)JskVy||ETw-@Pfv>z5S-=XVY>}?>1S+LA|%Vlulw9|X&*l!B+JL0FDk8+R}J;?
zs`E)DIP{Q!k2~tG=|RgAg@`O4=jV;CLU;OigoIsOKpuOu-IjEfJx@VymXDtI7wF1E
zsqUej2nk~;P-P95Vn^v?tRknON|ujLJ$gN-$8r!tvV6?0`5}z<@d!c+_z0&HqfM4}
zrLPxMNP*xiAHQ#Qu%TCAe}rWD*y3(mjs5WgLb80ET(+x*k7j3-;4t9=KCXZ8W;~sH
z5+bsE-2LuY293OokSrfFZa-L0_mD;YHMsvBW7)EN{JAUeHr+!r5R&Di(TvbMI`}<=
zgy|7bJlgi<TY61zat?yCd@R3qXBb`OLWE@bxVPv7jnBV4LP(a6QzF*xq*q|u^AMcn
zW3N>u>(E>75`<*=SUK0Kj69a={qZ#*VRi(3+#FF_pPq1s3rcR@13!B@g|DV_uR=(c
zk4A%ko}hQ0&j`u#(W|(vo;;N5{jo<X1ZVlU{CK&0^r{hqkSre)lgwAr`(u%dP$kT`
zfZ~@9?YvDN81zF(mXDq69@L@VC~^QHSw7YeX_!J^$f|S+g0p<A@pRtbZ|_Qtq@M8^
z2+8vC*l3@{@)bO_j}HI|L#gSb)HVM-@Z;Qj$wX-=3*IVhm8RqtdEf_*UZP!x_ojPj
zBSNx#Jl5iTXBwG<kSrgI99r>^-XD8ihTtq8-J-*MX=E%yvV3$1uVzjo^{zmbEFW9s
zJ-kKxI07M|i3Ak42noJKBTpbC%SY>PH+Ry=%2y#c%g3dk12@pir9VOn_z3nqZ&&Z{
zCrhMC)jp;H5^`($2=W+AuNzAjS>u|LoA<!a+tH!D>7ks4kSrgK4;ucUtGtbnEFYV$
zZE}}JHogwQSw0S%-PnglE<s3^kIxN<Xgm;`iI6NGKYttYfnM9%-GJaMAMLG<7ok^;
z^#}=lDWLfCJl}A-${d7b`RG)2)^fVaUN<4QfRA8L=M<Yjxk|N<v4Dgk1$;ca;zs@h
zztpXJ=?irKJ2T^b(yMRV4?eVyLlKhY<KAO|1L;mrMo5;APIfL6=qf9vLvWUlv%;K$
z=_>sYlI5dor)L%EDlZ`<%g1XW9WT>WTI8Ql%QMdMv4>8DJQ_IzAz42DIuQGu4t^IQ
zq16QxU$by$E4oUX3<%EhvGvRk%FiFwK86Akhyp&oIIaJS&Yg*ftm`=~>z&j1YG2!b
zmE61se%>F8UQ1WG4k1}SzDZuKabWNTAz40Jlna<Cua@c)l<s#RILpTt!>>ot$ejqu
z^07&k>A5tr=v}Ci<>MZ^xsT~Zy+1;-e6&8Ak-x)G`@~^{Wcj%6<+zP>6IHke!NDE@
z#jnL>8Oc90Q$O%CPC-I!0Ug(0@Ea#z#!?G@5`bW%0P*<RX1nQCsM38owH@z)pRj{^
z3u)wdgk){FOFs;KM$gS<gk%YxvbSV&y2{!QAUI3#_SL=gXyhz}WC@;Hs=;A8_<e+A
z3I5)^P%d3%)BH2^|2AB^Ml8WIf|qQkt6Ywd(CGr|I41kPr>lI8kSxJZHEQ*cMs|1v
z!C8Xm)U7p{_Av^O(CGp`zU){3HNE_PLqt$qU?_9yE&E0zd*m<6|C?~$13y-!X5>HS
zK`p<#5R&C%`(^$$=qh!eK$R>X`{&$jO(O>(B+JL7Qt6ZF;71UW<>SsiA5v&}Dn5na
zEFY5^x@f%d&=(<DK91V^F^HDu0z$HUJltYa4vnn&41%+KEVJUt5c-1cbU;E|3i#Ok
zVD=@t$OnkX^6`D{i>-89+CNuv^B(xwnb@ok-Iiep3Bd(cjqF9v8jtOMKuDI4^VaE2
zrK{}p0)n%A{Pp$K9eOOcA|%VlTQf`M-_@YjwmgJn`S`ryeT}E(yk0_ZmXFojSv{fq
zG65l3K7O{mZb>ghhM7<$%g1I5TQ#Hi$B}@99un}e-=vBfKOQ)ah%6uP|8#0g52f)d
zCAY{Mek90$w|VAoJ?<s-P{Dgq6A+T+W5&#l<>^;CT|-D1OHIY0${xkj>(Eu!dJVx@
zK5o>l-G{z8JPRQOe1s}>r##&zy_m7!dx#z)B+JK$Zc%gSRm0&81ZVkpEA-4vxzp7r
z_iGW7<>O<oRe|)q`%ehT^08Qk=@xlyQ=dONzg2?6gbVmMC9?7d`t9~x5Rv8Mqw00H
z(L-7I9TW*i)ta3S7pn8>+l`=y(i0(BK4u$MoKII7hmZn3LY3coMQFUzsd)ZxBL8=w
zZVS^R5WL3Pj>YII`y-@)k5J{<QU~*I0#p0r0fZFr5fqOw^0AXvje^T%*$)t$<>L#>
zf40$&l#D}2mXF?Lr?!x4mj2X=ry(TE$2lX08_M>meYDI{g2U_x_}D6b-voMg<{=`>
z$Gi3>#p&En5R&C%(B-}wmxx+@gxoA2t885NnXYmTLb8196mTz{Mt(*}mXE!Q1zx0)
zuAd+{%(#H!S5_W5Nq71VgcR@*6knRU<q+LOx}Tv+mXEWFwhg7L9D<N6AL~>ziKEBz
zBto)$)c>8}AV2A(_R%C;2@XRk;Nx%)t7deO!HCH6@$1xIqv)fT41{F)_*UOjxpAak
z+8Td>+$<kGhOf<k7=_v<79%9f#|HsX7W4^9CPK1&yfih;lSa1v3c*=E>Oa4#aWQl)
zLP8S>DBf;{hsKi?pAnMf<JObEuhC89`VE4!d_0mg;3|!bK}eR5UIx4M<Qphz9}9n1
zs)XDEJ}!5;n?SeaKZwZkG5K=bI=YAA5t8NOc#HQMudFDU1G!l~2KzJ|M^`x%Az3~S
zF<q*>Pg}ieBqJot$0`$>&7had3O^t?%g1={gbcbZ{ScDnV}-+6rZn;*LPB2(C?5LK
zw-Vi#7C#|4%g3Xarbg0L&O}I-k6Xue%#z<=p!V@DAfZSBAA4Nv*@w<u@0XIB_rOol
zEgN>xoxT7eSw2=xcQ`;JA0woIk5X^{cZujl#)czO@Pg+&&3{91mXBAa6h1~z_$q{C
z`PiZU-7EC@V-`XR_z1xRdbk-$V=4WMdev~wh2Sh7n>D_n@p-gO2+8u%eRBQE^jPL0
zB(%DK;^me)<~Iv<MARn_g0p=57JH@&y+0-b5{Lpm>Yh5O@m<d1f0QDdv-Zb<fuqCd
zYl6cNlI7zQmsuLWK{<tx0zSey&$7$QuF^jkF)LJ2zWCCd<ztQEt1ruE_v%ich>!w4
zf;^A<@2e&urPqzAk+%?%<zxSTH@&1qNV;#PM%omH-~v8El>v##q0(4NnyZm35K_QL
zK%TDExQ!%F!B0QFLP!B00XZ~hpCi2jcPIkE!5#s{d(=#>Ci|#<;AfM9gc=2OoK$0t
zl?+sGxSs(CHfj<f^_un0%cO-(O0J$8r=oIdd)@;-MVAa5L<=5;kSxJly^ncA+xQzH
zS%T}o`Lu>!e%*>eaF*b|vXV7^w-$$x0)oRb)T>Gt3u&^XKlSt&=s=YMf&()7?Q17`
zdPX6nfZ%`(OTKuWuJSBG3J4C!lRX!Gqmk8gAvnk*U}NRB$2FdKpNfzy!S|GXy_7xx
z&HyBIx~7kiTi4EX8Qqq3iYvJrgW>|YkA*+&OC#qZBvdJY+*G8?5_)zXBP7em`4c*{
zrxkBm0)n%ATvgRj<JSXW2+8vC%$B?6^mWS*2+8ts%Zx+y>9KSv3Bg%Dp4nc~gr4yj
zgk<@+=T?iEbd^Q*ph}jHH$L`xK_dqsB+Ez3<|`xU{qZm$p)ECil*;<=ysX^LKKJN*
zQTnBn+`LbE<uwnAp>vN$NS2SfIhFiqdCnjt1Q$^Ja*#=7`e@ZeAA+-doS%8>1pQ6L
zAcSQ3xIy>bTj}-o(w};NyoZo1AAbx@Z6!TiQ1AhRwgwQK<zthRdb?;JqY+ZTN9aq}
zn@9RcNBuPl1pkAOEFWiVcl{vW?NE>9P(ujL@-gPX`Q5aSX8{R4r0FB<kFoD+I?+Q}
zxwKNG4Qqcq5@2(JMovITmX9ae2JWD@iE9YS@^MDsukEzr4az`p7)t@g9i}?Wr5B=k
z2+8s>;AXhSmpdLKB+JLV&r=QLhd9-3*|IDIXZg4*b9r5Qde$MNfRE6Z9)A|+|KyE2
zkNSa-EFUla3~``WVE1wmoaN)r^%3vor^eLhkBNYU3D@)y)}fU}qU@yH(z>pmof1Y$
zk+v)!Yd)IYjh^sf2+8vCN|u2oz4M$wNS2Sio?BbcRn{sG!C5{Q`D{F%M$SV>m>vPe
zA6=<<h`v(&0wGyGcD|XBO^;=p3J{#-qy2~$C+SntD1>DBXwk3UCi+VCZ-iv|I6vH8
z<EP^PRD|FxAM+OJy_df&sP-`ykT5%%KEgWW)3Brmy$%(sq!h_}!;i`R9i8bO>W7dl
zA7?u3-%sy62N06wV@4eZjrX3EsSLqcKK49bdoewh-U!L^v2a=gd-^`YIfR567f^gp
zT7~KK^i(s3;4B|U^t9HvRTzknEFU+HUsaQ?@+LyEe0--Lmj7T6wdGn@f#573bsWCu
z();5=K*CT8_;^z%<_MkpJ|eRA$5RW#N6SU3x7?;CO73PXACE0Rt?^Z&MF`3A@u^Qr
z2U_vx2+8vC%g`$tztMCsh2Sh7ZGMNJqpOTWNS2RdbaFLrMtwy{Xd(f{R~%dM_kmbx
zk5tciuc{E7<zvli2@~kxaR|xsv3)>*A&t~CgDP1*&P&*OMQ(NV{x}?vkXyh<>zKK=
z^r6OKL}dBc=)!A_v-^tXN^U!rkGIYmwV+Q>#v>%l$Frw4{!1gTAtcL3|I68K^n^F4
z2EkcAt{a@am98=bAz41QI&w<m8QV;RWcldvto$kZT)bU%2o8NIpm^nuI=$%4Y%M~v
zd>nf|TH`m<UlEe!<F~KdmeI$nJ!&Yyp-2HAJLeY3|Md#BiElwfmX8lUq+FxhG7lkH
zK29^4qw$6x&zg{%<ztkw(Of!sB0{o!tlFu4EjoA^3#gLiWBY1Z8pl{Z2+8s>XKvZr
zbnx>C$?`F`*@)rvs!_8R1ZVl!@LS3hdMsxlB(%Dw;u7S)TM1XUA0AELO1O`ZEFW*}
zh?zm}kIic<!GS2?<B(aOG=50B6cJfIx&?1;NN>5X5R&C%hOhHydI5H_gxoA2qf_@J
z(rvjOAz40JHyc})KH1AbNS2Rp?M4=(tL&Bk_Tm426K3C><)h`u_04ExEJ6zS2%T;l
zm^xiTN>?w{$E$i)P^Ey6fPA;9*WcGiN}8*YBM?%+N4QjCF}$29eTnE4LV`V-iUZPW
ze|S0hc>whTKgM<C-~bfR@gIvXF0|mI0SGo~5@8@qN6rh8nzG;p+hd3bNX^uMT;ZMV
zD+ylkDYQ!Ul+=w_g7^GKZy<dsbOJ)M1Yg!*UupXG)-8l&3EpAh-tx5I&8#7~fZ#Be
zw@pSzN!m!^)qTDkAz6Z#c8#1z3!a6L0)j)I|8qHKKYeSWYkdeVAUGfci)?vLPtPud
zWC?Cxxz`Z-ut2{7R0%$6wmMY#LHGV1`i7=AAfeMWeFWk*%gdkX9y*4IEFUL#oBm#!
zoq~6;E9Gy*|7{Y@d2jgnb-BtndJmt3kSrhD8W`TD6~Bp)EFUk8ebkNaA)7`JT);<|
zo@$HD{pn6$g^(;Cm-Jn^o<@E_NS2QWT7FtbEAG}9g0p;d|M4RK=e*R3SsX&Ld~ER}
zekvWjR1>I@<zsp0+Bf74SABuV8<5bJ0zST;ntg&U@+cw-_y|38y~_L?TAnI4N^ag8
zexe$!=uFSfWQ2s^0!!PAxlP7t_=u1!A0q-*pVja&|03M~7NRCBABTT5b*F=`LP(a6
z4JsCHM!yZ>6G9632)lUB6yI4=l~Q>1F7DhEf(!Tv$nMwgHIn+W;6YY2Lb80E_9f1m
zp7A2hph}jH?Y1Q()BEEPKtc}*_;|d{=CkyKA3#Kwk2NBvrO=9(&A-h4zqS;4!w)Ea
zFxq<|-RXV^$?|d6=6w!y@EZsTV=18cZ{szA^v$RS_7GgaM`%kO-NJvTM;cFcr!PQA
zmX8+errXgE7(7Er0Uu#{(nggVBZ*T`o(|0+xPXs<JUX~;F1@JlKu7@}VJxd<BzKmM
zR|}q+>9l|<Sw5b&dc2JGaVQ{R!UcTHp0xfJEzdzjWcj#sVB3!LI#i*hlG_%Jss%c|
z)esk3x`!qrB+JK8ryD8sgx^L;0Uu$)S2&m4Lr=I(D+mtLBM^LCooJ0m+g2bX%SVUI
zA5ZA%$wEk$kJ(nPOX%gYdus^J^3gbNWiE}}hmZn3g5sH5Zj6;COZro<ZANXNN|ukN
z_95}~@#;80!t4n6m|1v>#_g>Wh{*Es>Gd-jFH5T8pyY1K^6~iLQf=s=oPv-nA8Wd|
z(x=<<CPK1&yjb|v2+2nYtDbP1wh)}<<DT#PcGK4&Rv;wIxPam%YDLtiky!}I@-d*{
z!o$__LrZ_^;I57koaJNZBPBc1kI^S0B+JLB`t`qB<X0&DsjIBi4yt7N7~bSr8+w17
z4M-SD0UrlEzu%2M)JR7}mXE)E8<&&55LWOjVa?ksxp@!#n5N&pNh6~WlI3HqaUUnr
zTdqzAs8Ya3Sb$43-Mqb8esJkeJ>eq|lI7!u`rYm5AB<c^NS2Sw2Mi9RkxiT+I5d%f
z;>WGpHK*lSgODsAzdsz9OCx_GB+JMBnRQ>#P1L_51ZVkZbUfaG_Av#JkXyjVAM@KS
zqOY%3bXJPwebVd9+()PA(<ncL<n51}8oSZ=qEZo(<)g*V8WU(_^-d6+<>RBvkN451
zq=5*@@^NFc_8;jg(-D&8V}rcd0D8vjcZT3BAMcjkng0zz>SE{ugoM5nP+Z^na3~%8
z8A7srT-tR;GJTNMvI_)f`FP7l|0?a{YCuAf0zR64nc0Azo!5xS+8>{-NK2)2x9_Ut
zwrBYm9B`o#UFAlEWck>0j;RxU*p`EkEFZ^=J2!+r7w_!?!C5|<_TI6I?(_o)$@1~6
z-*_{+)62R-l`J1`PMI;3Mvg{EmXB$tLpAQ@o<c}ybpgdkzi3vE-X~1DL2#CjiTg+N
zr_UcJ01}7-KIQ~OHl&C0EF!Xe^qu6np1x92wY!p=_erno#UEav4=#fcQou)Po%ru@
ztgmr<$4c@PJlVU4kODpevT&27FQwoGku7>aaF&l#mY?&b$8rrqvV44>?VepTze?#(
zeN_DgAq9Md;B}sNu%pLvKu-wH@^QMk%WGPmV+hIe@n3_`!}LB;u@_Vc_K=F}=;jYw
Up&W-ChrIlEp7`hghlL9LA9!SSMgRZ+

literal 2827401
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%0A})+hHpC6s#hKT4|Fe+
zzBa0!7RpcAR|LhFSr_NLHeoHfLHpEm;fF=QS@XgTOcIm9f^ROc42T~hFZ`hwcL8jq
zu@eyX`37tC;+|>sssxu7vTYE^OeQB0+x(h>8mG5|3n>LClf=RSn8c%!@9uNsOs&B(
zeuI-3ZlyJ@mGdkLGo@DunsUfm>kfKfO8?`_%iy|?sB&f*oE>HsE@IpHuAMHRq;5XE
zP6CVg^;foR&u?7-VVNW*dqwp6VGrh?kQus{$zqaXSr^Cq+*^A<jXa3OX3d-91;UkN
zlgX@TnPkyHQx~mv(&D`_Sxg3t>xF&hHa+~PClQ+dRHB&=tFz6uW?F)4XlT~_NRCy|
z6-*M-EK5M^?ZcT36<R@HCXoqPM4ET!fU0rzN!9*yJ2REYGSo~&);7p~Y&s_&vem40
zvmNZ%Dx%o;=ITE6%xC&mdsI2|QFR{Rz?w})+MwBwE9t9Yfh_Y`(9EN)hFdjk-(DYy
z3qa}Dpn&#>kfKZz^^VzD9xT)ZG?T{Gq)i}eHb1=m#GlZ;%!b+m7D47+0@5OWbIG^g
zMYYW=Z4)m}AQnRU<H1Xkljsf7pUUHCV<~n(H3z)c=)Vm5I9hm?!(L%#xIG~gf+%u@
zU+=SK$LUtky&MV?x-eTk+0%|*;&8-)*{9t+sd88bgo(qxRW`k|blLaqMrqP4Vzb>V
z4~ui>WU`COl|TPLas@F&eRbwz=tLJK4rO&moKXY)Ba+X0y)sH4p+}W7tJ!R;Dfh@v
z3v}}R9946c{tcVJ=kVI*hQN0>08k0JH=$;2RHe<jHs=?JPdX7@?tf7Mu4~P5Hi-)|
z=jKD_tE0?mR<YTz8VPUz`(b@VLbGs90Lm{LlPGV9u(nEwjJ*0gGL$ED?^d&Te@2Q^
z<h68Wb4@MbQ)=zdld@yi&V$j%p}4SJ?7Y+Ad*Yum%?1rfN`6%-fJF3qcW=x=#abq4
z6VbJK_;0z#cSYf5makdvj-auhWwBx^rH`SND}zJqqRN@YYc?*ea4m_J_}<gs!9CNf
z#sZW{&Eho&Tl9tHZ4&ydPQKK$59++l!ZjP2I!<u#*qG~24}4xk9sQ~K&MaB8V9CcN
z?S8Y3ctShz2urKsGd{NKfQI^bSh!q<N6I~itAcfw>e^uN@{YaV=@JkD&gsQnaO=An
z*wie4|51MUN;$>cg-;4AQ$||?AN-{DU}(6J@d4jkiylwJ$b>RB@yCD3>HdVmP_G5P
z2wt1MS&J;sOh`=fYgZn&-uDVB?9%5(zPq|(Y4NJ9qs}0U&H6Pf1(thxRhrIy#@3I1
zI(t&@?dg466cZO0uYr1h^PzH<w@H>s+3&?p1AM`~u2;z^^c(0;rI1;-<^fjHs`SXo
zeRaMgHxu(c*v6u6c_anF=gAe<&q7zowk#MOMeiY;fjWd<KY#lGB`LF5&2ohetbf|_
zPUPhI5LQN;*<QEe%B9u7yJrVMH}IHkTZ__N$B(9lp+!X;kJvV_e_(c`(9MU?3A_sK
zfO=N0RJh+b{!vdvWa$GVk@cbXcQr;VL$;b#Xi6N2dg5c+o}cUWMIC|pSU3eXpgxg-
zknv!djIIw<mYF4J3a-{J7MwROBML9G_RL0gG|xI6J}ncL2?8_e>j3McoaC>5If$A>
zv*gTUarfSRI}M^^Lj3E@%A3<fLBp9mb`96Q2AuUrjWeh-Hy``vHN0=%Dj>ms+2*LV
z`%0#J!h=a?$83FSw7YWk#?T*3O1r=wq7bRijeh<aHvy^3ZfS5(QkQ~XlQce`fchY_
zzRcs}0R3c<t2(_xbvi=5u+P6{ahYA@Y=M1KagNFE{mphaD1A89q~B7dcdi1Fk14aQ
z`cYI%85%R{hidOBEkwN9!fIQoK~qqwGi%E%x7d1hy*90Ec<C&J<#F7B^#lg3ea=*9
zRSvbB<^$bSYl$XGyCM_m>d#iELji3*(@lX#74^-j$#E$2o0Vq@FxX1YKWJ!WGz?`4
z&#KVJ@S+nU+;DByJflM1pWqwhk=us$<_x0th7S{Fx-M3!El~~Bjtpy0yR-h>e82s;
zvB+GO`por&Ub6Sk{4oi=IF|0rg$?8k8EKC@g_qSoi-;=6Ql6=}*4_gpQeUqzHSg;e
zT|cWy-+YLh5^?^|dWnMLY9FmkNs0bEz@aeP0uI+kCharaJPltWZ=G#VHbkfB^Tp#~
z|JH}T;MHvh7C8A@?&m&%_R8)vSYvMk3#M51%1oc?VaXp*rcadhF9le;ppY~|&-8s}
zeLEc*E2)<PsudBovEHVO2wiB))K7p2&8RtXL}*?n6JUcS2g|sCN`_DbC#DSH&kYAM
z%~}k8d8Ao_rv7rRYx{f6xN?9Akt_w8tDF>Ta@4cM4X9fk<ef;C2+hR?1>^IY%d0_~
zjSF(c6}BKkE6y#h)tL?5%*zaRfO#thC7cIet|<rD8)?3E)i&809HP~JlmFhH1%a7q
z!2(9r{+}(wj>DJ7ObZq;czJhrgw=u$Hs%Gz6MBv7JERWy<|-<(95XRk=K4zoF?m3t
z{+U4=uSmQMOco*G=W>C^ZI<eXDnvyp=^<zqbI;9^Jz%*15v7_g8HL=e*d6o{*11k@
z6_QzfL)$ZVKvs`5E7R<(u6|!BQEPvHZXk7l^uH+OIMOUjQ&ImK-f%)qbw*0WYt(7X
zX~Yln9jkV@S$;tLs2V%*MK>-yHZ#k-1)St7^1DwzdmCjomM~3ZOdFKiDLn-h+3@66
z7!gcD+t{Aj6*;)!**Vi7ER)YRtd@tj-mQKU>{djwq-g<92v)ZbZ1dTTD{=bv^1|ia
zcc)foDd#Y8+FS9-4;>fnsEG0<OP%H#44Uj!TbdmQTgs6vb(;7nxZ5E2^l}jrCB#Ze
zn~|m7dvqD12ur3G?6c!FC&T`Lz`Qzbu}&E5_Lg$tQS9{4H^7W6(tO3LMQRtAHnWH-
zPVmWmlr+0SU3!;30Yao%vS#O_vUM9oGyzu^e3tg=1~9&fWGU99r$JS%SH9K+L>HE7
zO(G|Sl?9n2bJ(D3@ICS<?z-DeNz%_7dp*$sY_~^78H={+XR+NL-K24P&s2z5Uh}6;
z^-&KlqtC!{ZE08LnPyke`(sJhq?ZB98x^h+4Q4`-EbW>^w!WklVeRh*Cccu^(lwB?
z)ndgGuvM{!D}so$(JbZ`S_w$^$-nzi>SL+d0_bkDA!*)s?w|tD-Mn6$Xd<jeUGuuB
znI=JtdBxj7))P})nZ|eEYvgs~4lXSsNS>k<#rU)<#z3=qCESJAa356q><Y>rEM;5Z
z1yVXCp{}o|`SAV8-$SE~B)5{aYqV$OO7#9>U7<;+h|AzG(OYlK8;@K!6*+>XYLkw@
z%i$dlYOF=!Y?igDj*z{m%%d-z|KD!v!6-?q^ft@dtUQX&#-NsFLbZ3AgDts8mYOZ#
z4Szg5`C8k_C>~e}Hi@cbp}%*$@*%2HECpKt7v$zNpG-N2I$V~9EdZ>wT{r*i@e<fC
zi)1R<9A2b!c0$$;yIa9`$E(?NNJxa9>6fe@JP(ZOBV%}6CRAIk<n~;$CofWdzy?HT
znUPI&*2~`M9^s7;<Cy9-GB+};WJ!>T_hmVI2gL+azedQYE)9J>>6+^VmB>u#8o}yC
zX~z5Q*FaF&2n8Dj5U8j~zN~)#??eBCpfdd$LA5$GbZnCmh{8;Xnq?`J2PJIDFvV>J
zJ$~iYWdio6v2CL({Q(`otHl<i=G9rBMt61<oE|&*tkv>Nho4{g28Jr1vuG}Mas9#J
z?(bLE(9)wp`5J+?w;yNN-4&%ov-ZrYkRo5v^&gfrl+vRwWFL$#3|Ht(@fo4Rq&O*g
z<{`8~XKK%E+{iFGvnDASriEkeE|x^EFpkM!%W}QHo_aaCGNPOL$h3gFaT=Sluuv4V
zS0?kI$-%N$&p8K&%=iUWpEwzF3|NsMnhYN5i;YUXI)j@Mq9Ws%Y_=_?zE8*gbKF;l
zQNzPjqS^5Q;yJ_SLx)@js>#B9E}HWC)U-xj_4N+#&UG`TN^9u{1FfAsc-fquUjL#c
zZli!u%{1%K?B<jX5!E*Wt9_DbDsn1QhGshzG<yx|X8!{9O-vb@jjQG0J@HxAp~S|N
zp%E&5-*0VF=)9O%{)HD2kIko`*@0leqIP6)nj7c?)<~unO*DD1A*uPt$?s8mFrRy-
z*sHrC{N36&Agqktpy|Q(uGW-Pju}-GMjEpwTd;t>Pe1tPGBlT2mn~co8A>K20@uzp
zx2KyGR02zD4FndBEn#6w3Xk}-)H<~5W0svc6pltm-ag$wY&@cxS#qX?fkw5KU!Pfr
zdVaIQ%tlQfBxFP|Z2O%llLfsnrpk<x4K)z{&sE0cdb%)*FZ1=Gmcb6JUfs{1nXw%@
zf>(rHT%Z_<%Xpz1w3t_i9b|o>a_YwM@(`CtU<X%E43i(P?F?}xCxRsg2iHqAnvYzV
zT{H^f@)+#mdNK}Cc=t!QUqKX>uqFz-OJPaj4lA<_r{JYJp;lqDw9KaPp3-Fmhdn2-
zkqZtUI@=IPz#^H_GRFn<S!D{XZ>n-#6A|f{8Z+ksT9&AnHF*jm2UA(*!1~uk<dI=-
z#H2@iQ>=r|s)Y6KJEYryaQhxskuCIKey}@V<6`0^(x2x=@@U<sQ$Ke<u!xoB1`p^o
zD5-C<^GKzb(2wbp|C86y(uQ>aT9q(*7`dvnxHMV(804;LxmFcNolzo>^L>(%!>M4U
zfc{a7L6)e1c;ImskNJe2loIy(<{j=6u7)jX8Z4_&%v)bG`IS?Y0X{8#ZixHYta2!t
zaevy@qj~nN2<}o?p&vj~uWU^l5{d_r0;6)#R!smc#mQ2p1JSIaCH{}7gnDpaU2wS%
zprtsGh7U^v#!}k2=0K%(EkUjpr-ks5QH#8L>HLGBi4ms)@NxBxo*w1L-G!*U>6+zU
zAqMfW`PEnZJcd5tr49>KZa>I<x=+8|^#Qb&*AG~@-hnWM*wL^YXl@l{zCcs}RuM7>
z5n_~ld`@`f=ECQp6L=}Xf<=j}!Gz*pfJK;4L$d<Gf)o~e`#2)+thaB0D~O^L{fCLX
zZbL8MSgvz98-q!TkjsT;ENBj&9{9g+ksp}CGuID#Zpis<zy6@GMwz8&Ry+iN(bw}7
zZ_P%X*bZ8mD6<I7kDtPa8Q+g7d>=ZUM{4&6AO^nr@8n%5Z?aBGlLt<KRcgM7N%Nss
zc-(f4CggDIgmrsuDMRt>@NdvLjZx+!(>!ih=UDVMYjzp=KNyBQn!9%EP5<#<;y!||
z4vpu&%tS<gCfhu4v0#)U!!i-wZTqEn=iMyU0g*;2{lS_P*A3LHh!6AiCEJfNH@`yJ
zRLM>pe5XH`%axH&{`L&v5?_?YO?5^JxYlyTIfZ=mVZR(SW1A8OKtmg4zB<&7HtX1p
zaEfMX3sFN*yLz=SL>Q(vZBXC3%^Ee73jjR;$Ckd)0B97V%;GfbCs@ZYIgO`2t3FZV
zx20~U=<z#;?sWW+em?c^O8*`zB3>i?c_29*K0#V(!`dF{mfUq<%cMa)Na!ltW*Ifl
zW#14^zV}{AAcDq7dJ#2rt6t-}LZIBV_JMjOvK}hEXJkMB8R<EvWyylbZx*Zx-_viQ
z=2U28yw#1!e_%nA>tM~V#AQ(OmqpuY@2~394dp<VT+OvsTu$d1P*8GhaVgya<OY^n
zEdY!ZPLuOoU5i>tmQan5trLd*BesOjuN*~LiX~7Bpo%2u>m}C@-PR1Pf>>v**|_5H
z5Y4^Wdf(3uoxthSZCD{6vz;KxQT6l03lt6X;#3}*Pg!%wVI5=vPOJTKVD}TK#;{IW
zBXi|hVAjc0{tn^uJ9!qvw`XLvLps4Wbl~N!f_HO5Tuvn?yJ<g0R7JJ*ASzFJvf*hr
zhbj|zr2rVHtbN8hq}}o=h;J-enqsLQ!F|>aKY=2crAc#<^+Pm|oUd{a)hM$d&3$Fo
zCoaOd;7qZ3FSoMPZe+I_$SheJ*_<Sf{nYDfqXz?9qi|s9(i~Wn(w_Mvdm4z#WwS6>
ziqvIm_g4Pyi7+U*rCPXv!dDN9Cx7d{3?g$YHX(})B#NCcVRrAdb0|dSQkjtLolqb0
z>c!2m&0I3mW~Js0qI0M8l^>zXEMK32&LaKzQ`*ySS89%8f+b9|Vog{Jw6<Fpw$6&^
z%#x+KxGtS#>Bu(ceo=aD^uMT#Gt1JP(y`mxK3JRnn7<!y_8@yKbOdL7Mg}`86Ez1@
zhjP06sViu$%{o#|!3F83UA+b1Rw~hc%YaB>Y2xIzpm)Tqey7LZsP?lCQnL&fG9qoe
z<KIb{nnE{o8SP%E<zrpiy$5qrMxsAYU~u`YSvqBCr-ooZAj*7Tn((e8p&HnCfb-Fl
z$~)rng$aEQA}-66Y2vcJ#4fO^PLzwO`hX=`6NkaV(`%dlUa|;sEK93KpqgU`{MsrP
zkQPR<RBD76pn}W`Pqmp|fLcm_UNGy@L|)ikwyASo<|u8M-t>npxe<L?$~0lDeN?8F
z&M7n8xYiLJM;^sG9!)^g3Qhp){lnW6ZoPz7TP$^&0_-dYq?b$oee4mDm%u#%W+boe
zW$W@8a1C>{B}Ip#V!_g-IR*#T8L}@qknwT@2+OI&4lFf1N~$61jvaVmBkHQ96AaYV
z_OQl`Y`+;9Y8Ix6R3i*c;WC@P69@bNVL5wP7OeR7dh1kd$(S!u3TFw^1S~C9(Cr7$
zpMPyR#N|}r0It4>{iDRRv?!6YL}`ROpl=_06xO-ZfWm4bCl>#7@bqz%AXv&Yfo^}3
zD0uAMZz1S}hPhXu9+jm|6VNmqr0!Smt3MihbTrZ0pDtM^q$$YOR92w}SzUZ=GCH>+
zDxOn`1-5k@h8}fqwpw}*RgHKinUj3i#SoKMy`TJ+TQJr2v9#30WWAyOx890AD2mMr
zHJi({u8=qU$Yj>xk22uKT`^E(lG#}a=_9mTzjqIV26OhK>3z{c2&9RZ_TElLRfr{0
zBV2nK<Q-5_fW7p_!<8tlv1DovFsK%f(oM7Y;O7MEFf;*cDRBfY8pYquJ9Z%Sg>3gy
z?$iagv$oJ#(XdF@F7V~aViX)Wg+tgE_a55ZWrkYmStp^9!KnAIK5^d__~Mup2CYA_
zxZLxV>bth8ES9Jy7VE9_>BZ%Lc4aT>?>CFoY!+)x@0q+ke?z&PB~KF$6|mycS#(~0
zpN}5*24DI{v2<yKoGh+9rtS06@HU8u-swLoE=mRcc|5_X%EDy1XVRr_@}N#h$pga%
z+Iv^j#`~-3sI^}VK=I7dtcj;lPb{zgk)3O)UoSsLxc<)7d^@M;To)~Fl2Yedx#u?-
z5V2XZG{;_%GxVnA#R0iqM_gg4(FCy766*QldVzUQyIk?SO<D3%&KEAMe^X=9ke&^p
zt&)LeP;Zk$yzX~;a)jGwE7CI=cPY@?k)C-=GXXYzv*AMb$190K*@Q{~(Y}wfJw=y4
zV2@t-_eU@#iDt>qEQg|Ef3DHdz!&ApYl>#6&umn8+eLN|y^8$v9q3e}S;8{`DjHN;
zZ=#-W{h38=z?40jr9C6)-o4!%<X*xe?f#?FEp$G4H0w@I0WP!xxC=h}{+SAZywR+q
z&;&5;=7`a!&a#1PFEs*$h%Uz|_Y&C8vlFGhLEo!Kvvg<<tk`eRcKOm~f1(cb12ZW&
zyIOi{xn$2z?}DNi%~GO~!Pef3xU1AtPKnC5cRVcU<_49@vKcl|S=-q<o#uE;^v+m9
zG-0c?Y|&j%xc7%&Ls)5P(A+4NEhxfr&yHAuUKvY*M%IeZ6<pRs_s^zHr+@++&C;GZ
zz$l|_?jODi<w@4*XAZ8r9UxOf^ybd>p|zX|IH8I)23osJeYN(lp#6(xoqi^8op_b~
z$IlZF{6tKkB&jBJv$o9cKWrIM<FEDWI4=(UeKP3JqFL8*3R4}KkBHn7!WE)3>(gv-
z_wGqUu|{s)kLjAZCDijf%%xtmnQbE5l@`8HYbcTV@wr0lT~L+Gasg@}GuYRvGO*KN
zRFN2RGcr{0LzrqUZ7YdS27DuqEMwwgN!jC5_e3+aW(00k(9-tgM?9qnRVVEkPt7bg
z9x+@I;iZ%~0?*LAP0Qy}_s;(nCXA;)^%W`tpCG`_O2O{x`*a%ArAN1c_K@4}q%Rv3
zKK-0{2K{-SV-}f;AK-b8vzsEcR`x?AuO_$Mwx1LqbcUtpA;tu-?@+y;YSUTqKRQ|~
zBA0eb{N4sRI@98clzJX~V<p${SG|4sWB;b(zK@&4qn3<uSeo=v5z6FR{A_Dnxi%z#
zxv2Y~LDzfZtu(zLI4cb}@7A)L@{YnTN(UpF4j6;dfwA#-+jJi$1^wo(sZSw;mEPYR
z^p?RQC#VJ!__3GQEP>$W8t-$pSOodO_e?JQ7%cCj89Fo-yqHKcqLa|VB=4#Wmr;wx
z5TvQ_6?Nps+cJGmM5RBKIt)pg7a7D~=3VpeL#vInSEe1pAz@k@_^{KfE1=az!uyax
zO?u;c%p8bq9@cq10s=hsh9_o2kAy~dF+1@GV8mbXrJ>cKaa|yLnL||n_nT&KqBdTZ
z2t(!9tbKRVGviT4WeC(fJ_b~oapLA?M018h%?Ax)BUhX6CPQ%91aT6Spg0JQkKWF8
z4?0DrR3^CQ@0wLNSAurSSIC9-hKJRvw5nMh+8r9rQG2yuP{}UP?$CHHph0?yEqkRc
zv^zAS3vewzO>C2=DzrN^o(pIYCzTr4M)#jYGY(Z#BV2%c;)Iw!pzOhK5Yy$GOquCo
zkycFi#ObQJZy`@Glxu!t^~h_p|D|mZJhYNdp71s}6xKujxAPN}tIZ-dPmQUp*WBh0
zmu5k^nsF_t>Jv+8@2>;tt}OZ%Vu!|bOYrK)9@Fc=c!({-gOf$9;g%nJY{?@#5E&Ud
zHjht0MW{LO%j+;oLgTruvhdqIyWPN3(C*NfF2J=Ua`o`uN6_xjO1gmdRWf4w@W!2f
zMogE9)xdO5?jXKQFMMVL@&rTI=6i!0bV99<-$I^XsN4L|ZW5t5&XkJmzWndt<pfUc
zyV?Ppg>LHNk*+aIwI<g80nn)Z#fCx4L#gSacEQEty%onkKzwAV-lSUy9IOkrpY5{~
z8XgMQEo{KZPFW+Lg5Wax%!!1+MdsGlN;4lleGPgg6uJ{Q$lOmY+q@Epl%g3DIIqV=
z?sg+l&Pflw@#Q4wmQV<9S?+TS5x(485e?CLU3$etc-`PR%MN8mlxHa7q&uuVQ0*-)
zTvWLtdW($n+Ei$3$nDSBmt*VpLY18%jq_q_iR$M~@2rCk35D*Fa0GC@*lD=*VCdsK
zM#EP4&E(T>Lc2p@dnBY|)*KCwqM&BT<5at;N7DoFz2tX#!#63T+MGxt5z~(qX!HPj
zB$T=?kbO*~f>UwSv~$oSq0rod_T><w`Kmi3-b6H)W}9fPcfwsBge^f_WQgVDD-^b(
zNzUDOB8nkrFa&cxY~bky-%UJ<rgDt4-868pLTK`G{~OTuP}oj>L1k=5y84@;?V&XC
z4!EcZ{v6n-$T7GsW9aC-t`W9to$G(aFZF<q38lW1?T9|ZPR+>!!9(G^SXRT9>eb~{
zGDC35A9F%+z%{q@J^CJ;$0vkBd<Wc9dWiV*E3__&h%d2&62ByxkgWaZlPo9(8TvXU
zNNiVwq4}(Q6FMVjGt_ooc*LLT7YAHKNsA%4^MZpm@ZqW5r@)yF(TvmJ6l_a2AxsCJ
z*}wbUrr^T2XokQ}KET$jiw9Ucnf?T@bk~Bd(D|X1d{+hT2mku5Nv}fZhmrtD3l3`j
z(&jbFp~}qA+)3Y9f(@<d%sMU~Ec)g<NR^RK5=`g&2j@k1P(~+8ewq^teTeKE2om-G
zY<d29cP+0-@MNJ#f%%RE&s*>b@QV$fCb)pgR=+ZxPXSTv?FqJ*)GNa0cPFC;Gln6+
zQ(qdY2P11W9Rvb7hM~gqL5qsx59Epml2OWzVW{yGa9hTsh1;+*#eamBhtfX?hQRg0
znQX%gLU0)tjDSm_IoX?W2+G_s3{9TbEh0O4DjD_1`?EjD4w6R<Lzm|T2bp{Id*@m~
zuY}S(P>iEp+FaE~Plw>4G!F!h>e>6H_Emsh2`PaHaGzI*@0mV|MfV#jTV@8n1LjO_
zn^Y9p%TVemZ_%<>YouOz*traHG~>)Ti7m=5Yyq3>tKAwjJuwW?o(3M!!pI@docq5N
zgYcn{o@^)TcvCl#CvBcu4MBB`VJP?%>#grX{JC)8-)SB~uZPkxxL=3(!M8m(rzvzx
zC>?|N{6ff3(H9FNGgRmV1fDTwWuH>nT}>Q?wLLrT_Ttbmvif=N>^R0O>r-aOyK9v@
zmUH05X0h7zc+>Q2*FhT?!?@H`zD%q8qe!><LDla>{qecFqw9*5gI7${*JE&0)){L-
zdmO`4^*OpD+iVf!LKv<ZO+o&{(J~KEu<(?9&I2e+=xZJQtv;H5Ybn9gZ%}pwV$7mG
z<*kO7DA}O-qQ$9?X>zg(Uv!-Zbcr!MX<zrG-h;%6&-O9NR;c^Mn&hEWS4za7?5i9q
z6r}o7Pf?}}HQxyPXv2Eb!TC)wj05FFRJz!4F{G(P4PB$ycl#i&GHyK;__kxjc?SNV
z+4|+;G(f5u!&C7&uqd}&T=>o+a7JK^`4l<IEjF<H{z{x{t~H9UzWDG8d;+WXJ5La`
zs4%4g>rtw6C=D##71<hf{IVz+(ty*&$<$c<QJP(}RpKX+S<6Qxq61)#IFip*qjX8;
z7ftFti#)<OQBL~Y@`$5a)qMW>{I2L;h!~!t&-OXid=?sh`a0q!Pt2zvgTX=7?)|ob
zfp`p0&gWvI{xkL6_m4oUS=C=b20c;D_J?*tY*z7Cumc{Ead_bCLmlY9sB=-1x%sp?
zB@V6K-AJuI?|)%>Nw6Il!?*`E5QVf~Cs-Niprz%T?-sQ-GBwMMte2KsUqq&z=BYu%
z_mkPWq1zLcv&&3;*VoGBuN@eT609;d2vT$Gw<z|$^x?shbZt(df~l-ejKFkepi=lt
z*a=WN`?Ku%tCOSs=}KvYQh0`RcJ2L3$9#2rjoZgb@W_l=U!jJ=r+<$zpFrmWuRF0W
zXcOBV$X*kLq4G9Uuw51)nzjqtgPnr@zn1O}(L*4<gC3Y&N!MI@q5moRFMp7mFH2Qi
z6D_X%@&!3HK@pK#{)CpZ7W;NUI^*_0Vv!5EyI;kXfat8%zC;&Z50GD?f1Bs{dWdc$
zzw%CL^{l;9qW>#z#|6GzRR?_Xm73_Ucm1cMPkcvjlK#|0%TxMEe+Y}U1^@9fZSO#A
zme9|^?%Nj*R{Bob5P{lRp3cw44jc~y;w0yno&Q6v3Qz5);)_Uuqx?zRsw_gwA;#f#
zfih&BLL=&s_<UIH4T(mzuUGF1oiC%sm|m=n0^po2gV#L?u|uf**1#Q%LM~)p*AG!B
zHU#?9G)}F~lAviu*B*lgEwLfcpU^?QTmSB>??A&t;JyV7xj*KsP3zrnJXP*Xj|b;I
z+$pTK?Wg^e!u@HSC;qd8oJ_Vp^YjN`=Og1EBUkg}e=4|>SSaG`0nXI9e`O_C6MfXA
z#S{P8tCUpJvP@i;W!S7lr^}M)Qx?@(PadHsc+lmtDh1}q;<kI={w9sTPT$1S!VxWJ
zeSiK*l(%^5KieyUkrduAtJKT>{Bww!jDzn2S%vV?Vxm#cQccici*fdy#P&|+{0&|I
zzI_^z`ILG+zBjU8_5C~1cLM#K<bInoucv|09s>7i-3gDc?h!uV5L&`9u4z?#Lx*~*
zJff;UY1hVq?%`Z2^QA{j%-0I@sFOXB+&qS-0Ca*-cmmB;p3l~#s+*|PH^`F!+Spzv
z5N&Gh{S_U85yKPz1yHTi`Lz$o_vQU*B)vQTD#Cnks}gjzR(<6zA!NvXl2GkaLe-F2
z+j+Lxfsv|pABFNgC;4SU)u#@Ji3iZ1$J-%PdFw6G2wn{0tBA7}#4YIBF&0a%M6E9>
zo<V<}=g9h#LQW*UE7#H4cizzu(fz>Lnc>L%+xvy^Y{Y;6y32fkp7lB!ls@c!dwe`y
z=kzt(guVSls>b!wrjt)tdu&)OdL{lWV?IU?Jt2SCf%Luyl!)uN3jPFRF9079_z8Ao
zQC0}gade?eGc_y7TxQA&f#r+z%TFUWRziL;O9qkI6<ohaKJ5EDe_`^A-|;-%pb|z!
zN?3Dfea$iQM$hd9#S`dH4OE_Z(DwvdM%qV&s7aZ4_jQ}1T~PDRIDpT~2l^p;x|`kT
z(a-Q#u=0lTD`*?WIRydq@fnK$lL@6Ko}5s5j7S*pcTB7|AuoJDsA<F5GSTL}n-AVx
z0|QD{M?+q+ldL^nN3Y_qqoXsSF&5*rKIcu_PoNj=G;Z3jxOKEaGt^k|B!=`J>}Nz;
z?^;vOQ@&U<XVeUoFJwY8<_mpzu&Z*V@yItkrJ=N&CQKBiNS^W2*Rxij5aP)Vm1mG}
zkDlVE^2|lcKSb*`p5#zIAW49`OqMBi)%n;d)bG<zQ1g*lbm*p3ce(O$`7HNOYU_#r
zMa*0Rt!HNnJ9LEQz&Ae)c;OUEbLOM{26XG!t<#`z=L8(eJ>tk0zw38Co=_%(a18x<
zoMTK6R#W8bg;s2T{cBfC>p?T-0=vbs=O`Aae19L#&Sq`<_?O6Labc;32g}xN-uUb0
z;zpg+O^Vh0a<Tt}k_s(OTtu`ts|!_wsb>>)s=R$tjN%ibecNB#eB&-26p^9q4pU&g
zB{GDAh_^T7$>Aa@jfXNXOaanS8J5(;pumX<cfgB_HOmYGe$el%TXMMdED*Y}W`Us!
z>NLcnS5h2H4ZxQ7nvS6;p+6<qV$Bjm4?NxF;5mSeu)ELi(-UmT#F|h13t)@wx-$B`
zZ?6qs^9UMkOcoyCX4V;_K8M6?yi^b@fMd<#LKV9Tu=?1QG4FzPd#qVm=tYKRU&vZu
z43I6vn$P_UfLmi^U)s1<Wp!_o7x~)I*mANzPoXc7X`^i21`$nGwG7YjM5_`-^W-kp
zVnAwZnIYTh-*SEQ*e&XwAe2=-g{K6Jr$wdmCMjp!A2+&~i>fkQPVJ2hcefd39z8$q
zcvk`?U#q5?g@pl!glCA{;9F;9T+n<Zg@$hs7;BakDyY%dazB}SS*|GmSHQWV(&s{H
z$t)?fy(>m&?z!{Q4|A6nx=I%NhKsT0GXQOiSFN?{Nz#PG9a=%TIqKbfVA&9BmJzBJ
zi=0ObpYqm0)96&>1%>`b2i3)z@1YGm#?9B#F?l{MzKxnB->N^>d@P`J%%0NC#CgKC
z_Z`Z3Yh<pxKC<+@J?bFJs%9}^z-pXT<4@dOjk2m)PUr!K>8Z{$f9FA2)vP5{vHe+<
zSUxPvkvxdy@=P2f%k>4p&?8SzMXB1XA@rIHeKBV9ZwFDTHtPoi;4)RqBw8i>`LtjW
z6KmEDdSL}^tnD~)>#8<Bi)gd;S<t1&n#F^@XTW}8a=FPrxvx^qt!CL^06kC!Bq6_v
zFI)y?Y_ni6KuD0W%P!dRA)>iiCa9oN#=cu$<m{uj@7P&en%#Rq%iHh)##Mm#0k@+D
z<`P9=$`pUiId!%3TH4p5IQMv)S=vPg56=*Nds433Yy1_bME@>Xz%(P)eDQ4HMZRuL
zGRl)A<jpePwv||)y<Eg(x2CDJU2bg!Wqm0mHA#1E|8$}g{izNyYX&W=!y~l)i6^Ib
zxdjnr3lgla36IcLn)|1|_KEwuJvPd8XFvqY*QHf{c^!gEZw3X8L`N@uQMJ)C5R})W
zhZCsw^GhG@m=>kZXt@wHS}G*K{`LE^w$bGvEN}g8+p1TQ;fq$?hb}Nu*bb;j^etPz
zzdPRq#~H_(ReuU72!a783eJYc@_KOL1K*06X!`WD$LWEvSCNJoXsS_a$LHbq(5o`b
z{N&FE5m2-A>pLMVld0CP*CSx>sKeWlQ_Z?Q*V<D0*1)#MZ!LhJY`T`xnbm)32Xr}f
ztXah;Ed_qP^}>@Kp<mgA6}IYr?K$YZde8-I!ba$R?fgWQ5)hP4*9hIO^*)^nQ%j7o
z%DR3PpnAsIm-7rvgyvKD6j-lciLc*He=$&A)UqnymVvK<%{VH1sjL&OHZ9oO6|Gm4
zNn7xoU4ld+5uy=L*7r1CDp#QRDwGM$*T*_Ouz<b21>vq9*YAI5;%1iQd2oC86?0?S
z5%8Ja=xp7QsLM4g@>KXFA8OUqZ`MLYQ&O$T%c9<D<G~-ksC@&%%7`$*mL!3x&)O9`
zPks+!x%@35s*S!p`RDjImmw^d!33*|2FiEJ`2vLHa#+BY42$qz)p2$B?PV~2xfR!f
z^*WbGT(Mw|m2MtWNi2P9BC#H{N3*4xk8Cw7>;ge6T%fzQd%s-8kZaB2x&Uq|5MNK^
z9y=JqGTY?H5@7;XTmHU2y}=y_%dNa6!XkjRlQ;hp&_k<Dy;(~aaDpfjK8l@4I=2tL
zF+OwYBRtIq&$Y}2GlE$>7cjOgaBapRw+gvI>+u1fx@9#V6fb-k<^%JAd5W!iQmj{N
z$T}DXeBugQJ)R}r=D*S8Rn#m?4;Xl>Etj5dI=>4t)U1yS{C?{Y6klkKh>wkiu-s<3
z1f8wo`TbOPd)%sj14XP^8z-%`&S~?Rn|{XG?;$RqwPHhGx3}V+v@_65(|jggz+N$0
zj|^)c=C2G_rtYZ<E#`AqAnW;S)5i9%p|Pg<G(6SfB&udQ_?dqz)P_dO_%*c(!f2gs
zt3O+k590ExFX3w8Hu!@_BVZKsS?s?ki&)$zUC!s-M5b0>X|0LHdbgkV&sBwx3(R`9
zz<U$lwRk%PV%+eVh5AEWK9LDmb8UgM|8_<#u35aM+Uu`q)qXiP3|h<Qv9MMTu+n2+
zECF%3lPYm35(=<f*B-zCGpo`9UT6<q+OP>d%b>VTko}#BX98AxXOCA6xb4QRT7VPy
z^lh&d;Odi_PeCctEIJFgKzxyIeL3k%>hrsQ_5(!bvX@3+bfA@IZ9)XTKE7In>j;&=
z64*pwy?xGpCf8g<2(!S<_Cu%61H&Ur_*atc9xPu8QJM55)Fcgc$-^Q4p!K?0N9Net
zwQG1}X)#{$n|tN-!M`9dlfPmUnt*kSpRd*IDMVoNd3BD(bhE9vcg%0_q7v`iLNR7m
zjj6aI;b_R|?mt-oA~QK`F`|vAX&Q2~j=!gczF^YWLDq2pt<#}9xT!1FtRJ&|(WUR;
z<U#H?&?5U-U!M6Lp7ng|8bC-E%M_A@dmmy6CDlg|yN@iq^0&JsqX@~Q-%}vBBP8?8
zqY1BM`bRfGwoul^DFE6svIw*hwI$=|@!;F4IHr!w>joi+RDD2Y|8Azo=s=G+rlib^
zZz-DnPw1Gt(feQnFpjAzbDm%;I_=Mt{7?9(V(W5XNEgS{mU*54T=eq09~PzESNc<`
zVVwCsSvB149{@eHa`kVIK{AYE%FM!r@C0YsxAGjl0fA+R2W<}sI0>ciF0)<<hf&GQ
zEcQjMRjiM#=-V9s8{M(yhtu$l%Fa2c;oXyxySfPmywMp)QY{Dah&b~-v-TS$_&Uj5
zyA4g@8I%mxbp3uJSivj9EJHHzq!*&<u5Ghgkp9kh#8;eIZkB@8Fc?ejZhsc!-8i%S
z%>R^t2;2X5`_B5hHmDzQOc7eRbbk<1l`mOlL?PiV`cqkJ7NyDGQNPo`K%H_<M=7FZ
z(D?Slo`Vi!E*a?8s1E}1`eN1bH^Rj4pg+%VVa@>DM+A#mim-H5?_?+}o<V<}=P>gH
zd=8AV7Y7xu2vmJ>OyQap0^~IN7o`|!1-sXJ0R}+`dBp!1_<Ls8ABHYKiDPQo#P1p4
zhMFh9D3fF;xphBkE9CszkV!;~<)`4MBiFqTray5^QCs+{-2%kWoBLx6vwZ@=nQIXR
zTyO9{_;1B~s5CI8ZK~y>8}~SyC{Vs^u{R++b77*|F5K?-`@k!M1BV={3}edL!jq5^
z=EdmW_kt-voLSXor#cH%pENDWHu0((cOF}r*+9$&^^NtV)#p`&wlX^h0;Tun8v&F$
zbSoQ#WfI+j)oJo<@!x-hE|3F&pnXV^*gEpmapLp0`E&e+Is+MD20kbGe|^qZYOX_O
za@A^NrUqKD_D>%pmzoc@bE8Ut>Tl|^?c)|hSeed@E)|PizYD%OwxkVof%K{Y7N|hJ
zT9!T$f-*~clGx(Y{95eI^!K3yn8n-z)&2VAtrjo|M6=l{Y}NhxL9q|!fSc{(%!k%F
zQQ&`3yYrQ}1!Ti<T+N!8)CmcQb;A!;VqYHkyUZYT`*B<}m$0@D#L{c{f|sb<GIATb
z(?;2xHBnc8aTQ}HWB`-9IIfD#c1V)X5vTT!dlAfj;>;)2x$lkKEL>pWN-6UBmE~^G
zfBBTcab^{pB}M*e_m3|(ZoWGvF3q&=#r@w7R)44aIm8U};dB9;g>FTgW^XChYzTzq
zvbY2km^^4a_bmv^<uSp!4we$B4`R!eg|J*6Td<lF5>9^J0>%Tk?h076)0cKx)AkUT
zTX-#8-3^(he|inNflp+=7=#FXV$(Eq_ndN)kcq&0iX2&M@%N}oa7Ar`z@k$6_}l*N
zM_;4g&lR-Upq>p4YHy=2_r3^Wxz*RQRg13N{dSdyu-xj4#V~F2Z9_WbIIfUQI6)V~
zRPQ*yGqjb@TLG$h_W2{(V3sjo8yiSoLJOn8o;bWO5(XEax4IUl)Z7NQp$qt=tq5#=
zb9I>|5SGtbzr=(%n>JVHp{@&*O*lnl6qK`N<yc*ovGq-3D^dybeX<y*%<5BU7XxK%
z)#~Q8#c`j9(@*o)vAEK+zd<=snf;{z9tZ`JY-q92vEo0!LR>z1p{nAkSCYPhxP10P
zRmIY{fs-IEzwkn-Lf)RgTtRWBWO0*!(XMxyytRLI<4j%eDuHH(_2=;!|LZ*q`hd${
zvB`;6XQeiM^R#<pfyY=bg~4YZTgo5!1#K6Y&wF#?*4{@KZKKjO5`*_vSP)MwF1<9B
z!O{mQF!<O{yJMo89Bx@IU8e?ReBZt%tbhCvoW&T&6|{+sjU=%RNo$@GioH}NC+2QZ
zfHH%B$H#o$o0}b)gpVs16PtTb?!d=(vcsEK>H^Za#&NZ6qV}LE(DbXd@1VD5KJm?Y
zdp4}z-@N|A^E(jTxY{<d7fgZ%ez$rdgyq&@3szfR|1k3i99wX8ZDcK&h8%o<$QRJN
zGKPaE2OC!RZm)usVc%drw@tn_FuLf{aawNZU2ZKF_WFhw#N=b~BmP9QE17jtV6wf%
zUDi7dBd*=;JEAu-l&fbG{6(J}KFoe3D}-gvplw(!x{Cc%1}UE7xN0_n1zd=DXVhe9
zEw=(&u$r|o3p>J~P2d(_8&;oL%skTY7_^tmT><Qyj8ZJb7R}lg!gANX0v2$gQk%Jz
zAuN}>7OdvoZ)WZ4j#2_w&_=Oftt9O7BMU_5YXirjp22){nv)VlS)=3gRa_$P%Jon6
za2p)849k>YAg^diRZMziNpoIagr-+qH5-*+eFte$>6gBzW}W`j?#6sTn)HA$mIf>y
zFObD)dZ&E_d6%ncBa6uqeow6UZv58}m&;+o4KyP%8j5~%eF5|^m&5{B_ri&D%@;vy
zxeO*$;Dy(-o~sFQxfCW`;DzkdD*T4JJ@Z|wc0}|JY~^b&Zr)3W^8o=~99PcPyIXR&
zeb%BsByKmp)DR*|#szH}EM##&OJR@AMCCuL#Vm2#e?__`6Iu#PcBE@QA`@cS3he_M
zC`xiry6F@k-O3JjnHOZq*&Y1;c&>Pje!nF`^!$Dzal*<%SHU)IJXf|x$kgfCpEYUl
ztJ`0A2c-6Ru4awkNtB=gr!F#MIUsX9SE|;h(@>Bu>*re49-7Nc5f&=adDTxB@dY%O
znI#BV&pn^4nb;7T%ghlLDl+$%$#?5Pb0sf=@~ux&GVt!iUKxgg)Dv$$_smW`7OGfm
zf~>ZDX@i>3U}l0KXs>^X%BO1|c^@?C%IeiX<s>_i$#Gec;a_edJ1Mg(^*G)vJ+l|Y
z;Tfin`&he_;9kdb9ViaSxgJzwk1kQmX92*;?Fy`c<{AfO0pMA>xoNh{`<z_jn;FKN
z6=f22=Sx|ZAd6p0wK5OkQcm-@!pL9;o9=jA)w0~ntD2_LZwIUW@u>`iu365cF>SOu
zr$$l~`?e~6AHDy$+g5sPH`BTA0MY$X684BBD8b*WItncd;~4_604T6E%iKKM+`8$p
zRW4vt$`AzGMzqzM9RB&1VGF5UqdyO(nZy>R_hSPh@QAQ>zq=k)Yq1Pp6M^+cee?8k
z*U&F#D84K!MYYs^`P0?EO${-P1RiK(f{zv+K3QWC#FRfi=o=Ep@@jStnBOi7#5A|&
zWT)MN_@X}5`k(fIB}zO)$t5vqkDdAiANJcVs+<Lq`FMt)i?CgFwTOQqu7=j%&wCK5
zeB;eWmRWDkx%$<DF6~?%;!g{I*L-z2{1N72Z2buPc3I~UP;}X))p6@m1$v4~Jo9y@
z>W{F+qxj2$Sv|8gc8TbD0*~5BT52P9KVFvgqzkIDTLz<v-FgnLGwwxnW>Gvt0Y=WY
z3<c@3=J*<uz~m&Jp#igC?G9T@?mK?|=mXRMnr}3<UYy&w>q&0lplx4+?-Jt87n)kY
zbnv+oaCkvir1RguLVRPH*6_7u9aX)OKTk!M*u*o=G$Vg2_Uk(J%C$bLh7uM-Am+o?
z=QTBVEv|qX42DX~hmB?mSAP#H3&i5_49S>_Zj;=;sKt_afvj7!<P_NFGqhvg$LJmT
zCx_mQLX?+b6O{7p(H3@*6E9vS643%%%}r+ASgC_$OCAZ&kYhs4niFQaeXblhZU3;v
zuP9I$(lP50?eIb(pNLZu(2%VC=8R)eLNUw720GYwqV^Tc(uE(sjtV?OIp)BMuP%I;
z*|RP=gw|$^Q_vhtt7uuM<WBpVw;@m6t3<*Bf1@8`Y{g5JDY18dy%UY=)-Bz%sW^f^
zRdkI1oY0{SUkIm1`TKnH6{a5WRZUX4cg0J?bM$`I68&k08_T&Ddo42jarYw`py9^0
z+zZ|;V7LtDXF8rN1im(kXB>}azelSSgmvkgJg8Gr@<97a0yS8urZ0QEKL#zi<y$on
z+^Lb$-xG_3XQa=H$aIz7W>uNTCAAOKE0Oh3={=284RkJzmXD}2v)Sq}0q^@nD&DLy
z^E_hrzOqf^W1dLTj&yIgc;;L59QyP86mv_jz5%+Y&b?sE&g4GEZt8mPr6S@P^yhhw
z?5t8+I{2S6a8RcKg9f%t8q`C5-_muvqHm`GXW_@2m1!Q=g_o&Qx}@`dp6H=DE^2h;
zn<#W+WmqwOkaZ-*pke*Gg<JC|J9Onw`EBSgC+LH(Vt%g~m+$INIr?%S1RB@fcc^94
z!{ZM7bx{R3jjs*93yL>igX$!IyD1a0jWE$Y`Ck6$O5Nu`aAOK_!Kovo1zF%yDe0qj
zqrW|kvUaR-9T4yl`9w&@0$JNmP?S5$_0CxsH3!oFhTP$s=2IitywE4sJ>ULpZPvGW
zydmUQw$FW4tbO7K-DuTCAJM8zGb`LY{@C51be)5>BU+@oqm{B6^?!>A6X^cjWWEm7
z`vg;N>N=`I8}M;=d>lJxSYboC$qq|Dz0S`$`#CkQ^kY1(lD%IF9M*nFz+IE{RMBfd
ziIS*CW@zG^+-Lm`HScxqG@!6r=P0gf&g$?CVi`jtXFn!_cBaMNKicW6Gik|Qmk1tL
z8Cwh|Xz5^3zr{InZqDjfW)CPgFX%^kUkcxG3fgJR2Ckhx#!?no^-HxJE~q*ckiXrO
z1@x&vxA`BSFZkk>O}!LiFJPz+`b?kfy^%we?F9p<v%Mf&w3y8^Te-hoeMbyMoD)^F
zZ1fd`ucLSNf}mVxM}UFIi8eWUpuHf57S6VmqF>Y)5U5oiw;zUvBJtc}??7wQme>Co
zF%;S?3rz4A<^cPGmeRq4K@s&Jw2WFFv>s;hqi*Gg?%?v)v04kZogF@z2yN!F*8vW+
z39^#UAJwIWOAVF7(qsdNHDiw)82>NYL1(DrWW2$9(%($J@;gK}&+b)Z5EMDHY{&>C
zAn^>1oQkaZV%h!mJ)p&0Leq<bUk`7+l;%Se5)7T3Vli}ca?Mw^qA+G0{N{nySpD6R
zO6j4^p|G0H;ng!|#dgVY5IPiA+eiHRlXAD6|FwnhP*TL4FyM_HOWF=;1*0w$TKhDK
zRF^M2c=2<$jHsNJuqICH4&Kx4z52)t4AGnn3hVPWzklmo{oyT$915%L?#x$CKN>Op
z5k%%L;)#7iSgmLJ4tL5{fyklo8XlgNWpVro6cdcY;G~~{p!Bt0S1p1Thf=DQ?~-IE
z)cU~WNf0>{R$FH(`y-?C*j9(2FG3-;_>|0#n~-<?M2H&-qbuqHfC;;<-hiHv#4~3K
z>nk<YVq$c^1Fz0<hsBC^PTHFSp<V5qH-ZVV(~um~L5@(0bPABRc21m?>BXehs$7qJ
zzX87{Ftl?rcE#s(>aQo<R*g6I27XOoDCa!5dR9x_c=|F>HWC=3IR)7|L)LHffcG}e
z2URqIA)E6+Yu-4#>xVMXX5;GISs_tYvrmNf+q~wj^wlABC`m$mS0|p}hdy7i?o-em
zp=1dGtu++|&-82tZ4M<#2w>0^e%3g#BZQW`GxM3Cb*h}GeyJ~XM<}U6KzpKtc-`f|
z(7rBLl-i#li)o6yCXFJ!Ib8A%)+>JmIm4`{Q^Jlc)>+taSJJN#S{lvrGe}AEULQXf
zLWj}<2&;W7C(24s4t^%d^|UepNHA;b6o*tsTxnHf$e$>WGVTwRsiU$^m0Je}?}iqK
zLT~HPa6h{n51n`bx;Yefi^(lW9Q_-fn}nFcP}M2U0Ey$_=}Tv!&7rW{{@B;=jyGDa
zy8)p?VK+g069@6T#nz1D+)hB{w~XhM_#I*2apr}jKpqy^|0?n@LuTjkuqPK0a76vJ
z9grIsH-&nE^^|cnapkWllo>~=NoYl*Alup8(KVA0`51SEs>oWMs`>Gj+tA`r%C>c&
zx<A^UtN;5G(Be>NEgCvM?u@72>jy0kh13F9e|z`m4ckn+B)*-Jgs2c|b_wfV<Zj7b
z?JZAhvruz->U7n*1MNlvLvClk%t)GiYOwjQ97A`4B`_`sRbYJ`2eCUYcheP!-Evu(
zGP_0fL*Hr6?lrO{VmCu(r`oEgjm)p#NQZpO5ZWogTGZ|B_qL@GBAeB+$`IPAuzJuf
zs2YhBd<hJpodOIRfqY+8E(}yR3DI0;!wX2WADC7ZqH<XcZy?PzX;cT4D;SD8*9q1=
zYg(?zc(gaf<ucl`Ru8g0#gadVUf>pKcnRs&)?2qhRBnBSw}rmkIPTl@B5LVREzL3v
zQY5c-x!RjUKK>Z_)2x(pn#&Y!^ql+eO4v=Yg>nKH4viacehD3fmcUlYS-@JRo$}N4
zMJRi*RdN=ruaB~33R|vzhq4!2DrW&}+3U=~_nv|F@>z=q+%eln&4B^IEyj^zSqIwd
zk6yho1>*9F3#YpI{@8?Wtx8~A9O@<-IMdzp#`TKOUOsiTi7r*%Oz*tB2a#94x0K17
z<eNLsYg!rI1eRdd!3D@`-LvOUvPZ^U=!eplS^TEpY9V{4P9<0p825#`Z%P~qpr`I}
zZCb8E3}ajr>f)lWtllm9kGRdzKA1=C56m*QfD`BoTEA~&FV0Lt#AWN&tZ%|VulvF;
z2jO~xambqM1~_)#xa8d)Fc|p61xK4qsy-K8Qk4+Puea8baDMl${;5zFXf2<%zCk{b
z_PL9j)?^T|K!0k*l{qm*(u!2*W9|PEIz=E8+4{3cx)#v?!!tMCwH)Ouv+OJouGRr_
ze%uM?W_${9<scyV%*?V@XKjOyX{I9{u*GEp7tV2N<j#B&@m4vA)@U$Tie31j&)d*m
znYbCSzNHv72%Q>LUIl?=aB+Zj50`tnQfdgyCoWCz^##tcj*F~slL=hSjEw6--Ap4U
zouEg!u(Nqi`0DuN6~La}j@bLl^wizb30vt;Wv}!@itP2@IQd_r8E+t;vQ=Z&;mn{-
zyt?t<e(0yOm17pLmKDnUyd7PilfYJw*|2(WZR=WW6Lf@}Aef>SPrE1O${LHZBU?ol
zDQ>ItgaDE3){mJspe)7~kP#{%Z@E`rI0D_kCoi5xH~M<(3>XhGXifeVz?vUE*<Kq-
zZW0(Ls=3s~ljs7q^WTP!;8PdRp*Mc~QasR&DF;cVNM5?P4^XYvzU04<Yn3f&hHEvd
zHE5QvI`V+BBgTQ%)9r!t_4+|zegzh;1&#C0E)|y{swMC_Ebip>Hw?Kx`aT*_jV&0X
zn|=Y+X5_kVov}gKYSm$@#VlMslN~HD{UG!LpTc0Ky(8O=)zAxk{=$iN&9^s=hPeE`
zS>WnkSn}DGOK1y)aju%17=*@O`<|Z4?>jlWW<bre%nT_qScHMEdH$k$foAmKhVSEz
z1hzaZ(i-O@Td7X0Kb>wras%UVHOCDl=(@@B;;)_0@`ssjEQQcq8q)zA;y?j#*2MC=
zKi)?noX90|8*yi-b~41OcgBo_sB+F2JfXEgw$9J6Z!!vC#$}<lhuge5pj)>=nzh>w
zm48SdCDEUn9um1UZX-I~(qTP1_3o}=cZ)sRA9{jIX2RA`zbo+c0e26^V=<S?ZIU$1
zeAzy!<*Kbbn38OUch<L;2b2hW^5@z!Y2T9m6j7LjOo6|SD9lqS3GeqI_ga92pinpk
zz=#M@&V95>{a2qdAf6K0TCg_Omw%ogO_`v5wkMi^s+-8xf>HNDYaD-lT>49~JD~kY
zWJ|&DCC8PgzWy$>mzx8uZb@_>etX~V@MjkY%uNGs8|DZ8WklchAeARFuJ*Ju0Ra<V
zZ8!VjFYo%~5%e=RArQRxxB`lcTGto658c7d1s1F*z<zt5e9$@))Q3dIQEHAmx^|^a
zWRc4K(Bs>5{SoBGM8=(-9%yp5icMtxu11%<U~#P!%oNF-<fHP2O9LAr53rSA;-`B)
zQk7zhgpF@60N>^%GH&klctH6|Sc1Qq?Y-6zoLkw+Zm}A+3Y+R*inmw3Y5E_i5{Yc}
z7l?<a$J7f86Um(Zlq!+P)_oDC{OaG5M9`rje%p`Udu0=1cqDgbW<5uKKkAE@>}k8r
z0;eb?M*g3(>yEFY=-TuuN^c^B9v}p6ZYm;8;H3)*O_~G=5LzH~1Sv{YDGDe}5CsA0
zMFj*4sB}UV1r-$$5Ghg=5cuZo-ObL<Jh^-J`y;+T-ano__sn_DIWzOj44dKo`&)O~
z;5&{M{@m>(H~|~S)`TV6Ux3#%^?0h)IQSE|JwW2XQNe%0&pDFUfNOc;7_V=dkuSaw
zxFSaT1;qcOS#owm#oUhljQMYN_x4%xMGY?`5R;VdKF(bsW*!J`5>~a@nzr%{AT~{_
z?JWB;qA6P?X3TDgs6d;sGRx<0gBCH4trOFxPDK99of|Ag@yFJP1yHRikA5@2?;nl%
z0Hs{UO>Jg$q^2g0>g=nfx1wiC=c|YcCF7zt2ej6iWqvaHQ)n}r_J++gMN<=2j=$!w
z0GCR{vGrmvrVJC8G#g$I3n@=K6#8XTTd#d~01hgb^Nx>zCz1OVTGtQ;y4|q{p9F}v
z&8d!R^~k9Az2`lS_-?nE8S`Ch-bc?UQx^>-TQg=_3J6(xb>6}dnyd9DXw3ES<vTw`
z{$(r2Ola6lTwXBx2UPFb>M;SXhV_i-OSPddxGlVx$WuUoEt@AkD7^r&oN+5#faNB%
zwv1SA?&L6NGneHiu=pR<9m`6bECZprExZM-FQYAq==l?b=5pJF1_51p=ccnjB^$@M
zg3b1{CaEGyzf<I!m%$RdbP_N_N?S)cl+G;gn=>9ETiL2Ia)a@tqB?d9LN8T7(|xwC
zEP(7-lb}l5Y1$j;I{G-atjxsKqpe$+66Fv>*vc{k89a=VRC8Vr6l-i{nF$P5gUh{K
z=_Tl8ZsShS%7J0>a@``U`@*>JLTV@jn|^EGJZP~OPAiZ4kj1~AUNHmWdLcB>zg+$>
z_Z5iCt<mIRpj0{0X4^|vyD#l^ORK9HaakmH%JDvNnRTGitwqN|6k?C9dZ7jyK(^w{
zG+WP{#|wXU8X|M+H6hnVCF;@B<L^Ucdx{dg9SR_Woy2t^uQY?mb~D651`>;*1v{KU
z+-8f<44YxaZnm{O?915#G!t5@*rzwf9)LD`A-Cw51-_c~8|=UPKa@k+x1*UhYiU1s
zr9Mre&0gq@RWg?gJ}3sEy)axfpi0w41^drE&(*eiM49Baqg_ZY+@TQrTCY4;k%!r$
zH1e>pR*Q;at7m_V+`!hQnZTe*-7h-mHiY&<Y~13f^{R9nrDwJ}jjRSbl=drHynr$W
zTbvfa75`N!a;j<>bap+CeaV@LtY_xaC8nXR>^SzlW&vc4dsBR+euTd8QnKqHfm-e&
zsq<lAcwx2BOeoZ&eqi~>Pfdf+URbS5Xo%I5er=W0f|glryTgsubTG^4@D*}btkr6}
zg)Fc4vQ=xw2x`Yf$sa?@w#*Bmy_9W|r|1#AxIp1%h=XkH8d(hlDw{9gJAvYk@ffH*
zk%AHxf3H=4Kx8lTY=NwEaPGhzq0kpz8gd|0`Sr%#Bxtc+O58gbC@5*2b^Z{mMmb{6
z4rf<nHOJjscWM~zS<s&Y(*v)oq~DV(26KS<IGMtiZ!cabii%+jo8*Ft)Jw}hfGEE6
zL|9MDDKf=v`&}q5XrkC!x#^MCh=6Q0n}{~DRggutmbiWCi3v?naIh6^1g)(&5c0wP
z!v~;nW?zFAKz8_-a2u_;`aHCl-H;m=17Ca{vJ=i+*{ZgH#p1uJm-iI<{t4&{Hnk0#
zweq^S?dH#6V6dr8xN!L9CH%4u@gtVa?Ethkej8t!xd_^96T~HH1b~5?&vk#jI)wJZ
zY5m9?vAXbz3$rbE$gH-JU07{A+NMWF*KBvLp=g$bGVb1hhw;WVD%u*woV07tLDt6a
z#)tFax*y~HP_wj(@q_C-Lu+k|fEIgUHh8-_q~^Y{(8uhOZCDK2m!+RAfGdj9QVhq(
zVBXW)SLt<VvlnK=OW~TAF1a2edm*+sQmDsr$?PRcLu4<^hA#rQ3fcA~M7HVY?q}`f
z8}YjAsh*)$wYGI{(%w`Cw6=6_&WcKi*RPJvrmwX7C9PTpkaT-<U_o3d|2>|V6s!Mw
zfmkzq=*Xe%+UCxbmGkSth;4r7<aUV6?(79K#0sSz3s)aM1vJdUX7;>YAcJf1eA6}$
zgcf_r5#m}r-Qw<VZul7@d&v^;cwN_D%Dt+WCE*J%)t?s4bfc$F&V0ZsOLn&`puMCC
zTH8`PmTQN%^n*5g$rAd?7Bz5{tNz^s+UzAwpk=6M2b_5c+UzAu2w<f(BvOBTX~nkO
zVn#xLcKP>9Leb!)PF5(r`<JOrkg04LoQMTliUT20qg~fb$h~YCoC&Rk#GChCy9;gh
zLTO<$sG|jkpWY9ly|9{~b%sQKlK%%pYqk!K+yQS^o6)uCzk0hOV!{ip!TRAlg~#oO
z7JK0|Jjqu4ov^zQ*$b%!vhL-5PmFm9B75PqSm)D`r*-Ug9)`0QQj5hWM;}X+KCp1+
zW2jEs(d<HLZJNHcZ(Fcd?XT&sY%`B%8=<D<AIg~%D({<&yujAAna~=kZw&6x5HXLf
zX|sU!kvn>SMH>_oY+)Ng!)w(Jw0kWpVjf%37C_dVvF6D9-Oyq$j20_p&ZdyYFYMX<
z*CDbOPQx|0w3++sSq-e*0kGw4!WV(!Z%Z`e@6?RZC7L3TUD<3&G@Bo+(yCqSgaqZe
zA9BU-Pqv+?%V7mLo6w2<htPA()GpUjolVSM@vw9k#B95mxG-DW67N3u_CjQ{G*58p
zz)hQd!eZ$~AzQe*zsTb0)}FpRjO+{0tVeI@3rYh+UjKE%)iUrG*y)b{3!tbi`JYv1
z={+Rpn@IkeY*Cx_3rIO9yhQKus9ovPHzw?czk=PPo8urnM1D$1QNQqAxefVrIlK53
z>=a;pA#q^O5c~N<dzfSLe{oaSg$j6f9w7KC#`BUXDd7zgQ;o*brf%73xu(+xv{7&^
z@iKK!w%w2rI{A8`gn08|D*G2K%v9<K`~|ML!76frhm8YrbD(TpyXLFcArsj7A$ed=
zOP;IXQ+CLe=SX=g70a!>9YVpgL;s|K0dzHVmJYl(LVtqFUz0D06NWb(*fVLQWxXcG
zCnhh>vFtSB8DAZj{+SHNAp6NopN5DiqCYts@s)Do8!ZxtNHS^Bg6T5pkTW05fiAOC
zwM$k~zJrf=jGr~BICPmk=H5P|gcS|T+kd4^rS~f7&*3t5;;?>7hNDvU(3#Pp0-pXH
zpI|2s^Ak<wAfux<*liPsw0*Ly_!j*+zUP`t(y1PZ0>}4&@5X2SK2?9XQZR>~Q^1EH
zdkUBClM{Z*OLn2i4*aITSn2MgL=&-WVTje4$%)1eh@go^NMp4bMv>o+UJDVUL4Wdy
z@TGZ<2*@zf7L7dh8NG=~e~$04*9F0M;CO6Ul4rTDv-j6zUl`XbIn_!tRn&~!;?ljh
zs5H`_<7e>G3xSiHH0(>4*F~a<6JNd8KP7P}JUx8p#;77_vd35N8PNJO<<t89^e42L
zoj?p=YA;n+SKQt%2ZUzliU72jjHu8%PJIDhLK7jv&JG5&e$4lJuB`t+o7uS_0Ib+d
z+<*OavsTnI(VxtH+tDuEPgWKTUmaBS9I}<K-AhR!2>>{BkkWVgTd3jUtM>%7d4SWP
ziembz$1BaV@}SH@_oqy)GNQNXZTj5UgH{0e+Py&ctj5|?Uv%|BTz01*aN7(U8NjvM
z@+&cmvryAXsm|d8yBK89fmm(%fg|7Lom?|Yd&K(p^_PcHvY_B_AlsqFK+fSef$c`W
z!^r{DQ5K43Gdd-uF3nI>A3r(v%W)8x&1V7zPA)tm`d@N`^Z9pw&1hFX+fM#OczJ{6
z<$yDY&pkK&JJO0_na{Q_-1uzPayukmIlJ|H3JJA1xeN9j*5=r(ja<GwadpTCsvp?*
z%=J!6Z`}1FQm^{>nh>44k|3e$Il0fWLt9Zlz!vTidZ4e-!Lv<zIS-oLv+tdgz?Gy=
zQ-H^6j=BnMcO|)*=#0adl%><p^V{K)Y4w(V1nxXG?XMZb=6Q`~EvvV|$EH6GZ#@fI
zZpU{9Nkp|A)R*#OqgF$&bNQa`7P#)zr|^KUq3y1$ci1j=kJ7zv^FH@?$?5U{nfJEo
zZoD_w677NPb)ZsvG?4CMK8yFpKyKKozNJnfSZUvL?;>)t<$M8O3umbJfDroGJPmgs
zSF<I3>F6L#8kPF+Z4@T#o9fcRVVKk_yT2N=om<%rcvDNNmbCmakH$i9Ps|Suta+;7
z*+v$5Prr7+Uo+N~`Er1(s4HsT{vDd^iSp)6XzD#^FXis@fFfS4ZPJa7!Se}4pCb|4
zeaYS`^-e=<F5fL|<q$QM`PhydmY|&j8#)->4N;r29{c+n`%03v<Z8J+bJzEoY~S1D
zVABN3+D8|3$<(@e)@-&XT7BL%8Ihf>@H0FixNd~D8XzC}+pR=?X6yVcbinliea^0g
zmUAcO7B-~%D;;0Tf*MTeu(Nygg^G9YRhMKgd+&2=>DV!tT$+>FaLRvZaOO84GMD29
zGHvClHgCG~(GmT&IDgGJF3$;B1ub3Xd~USZ8E4l;cMn$)vWlT8%@Uq#6$(P6(fNJ3
zDhblipTpNS7dfAxd8zYVCv9Vii2q)vm?y3NUXlUY%Uv1p-jV?d$4j$bLTvX;*&`s8
zNCKY>APpIy@mz(3NYyv*#Bo1?u=cTKfXS3m!Fi_-%jQ1}f$g6k+|>p!*mSJC_Spvz
zm^)Pn06U#auGm{7TLdVHKK6U4$srY;iV#8_-6t<NU+(wS<hBTe3O4`WD*kMDu&Cf;
z>;IC4EEM1tnv*{P;&PLQfvbDBe1}OL^;`9XAGj$);DWmhHZIBPgVDfE8U`!~vsE8O
zz5%0wn<|p+dkm=J<;p|^{%-0u<IDz`EVcfUj4lHLACF4&w@Yi^#P4sDmUFgRwBI|i
z@ES5!N(^pf0}}Vjg(AN}p&(hyK-G0CA1>*A8{+aAti6y!R6DqFOJ#`5Z2*!(;Hx%^
zSAPO2%vSpmE>NM}-aIE7QG%`YOAbNr&pbHzbXy3^XE1tyCilAR*Adg$SK1lY0yiY*
z+cFXcFQ3BTo{Zm@R@(rBfzMy<ofu;9@fjsE1JSO}j@=9xY?k0;r2r?UK3Nj|dbYkV
zS-s7Js1O<R5;*nZ_pzmY2C7coEjvOpBd@ZReFm;x9iBdS>jmfqK6Qbv|KmzeU4Yi|
zYp?d$J$bkH#+E%HF1KY*riXZR@7`GPWgMbd1fRJ=b`P4dm<Rh`Kq-N(=Mx4iYFF|@
z%8Gusp}l<OiiskycX#$|ze8X?c?Gai)rq|Wn;icZHPCjLxv*E;JumoX+uq1jwu&#A
zB=;Z~{B!<FL_x+D?<He}dFRcM6%p0gm(UTeL-<UgP-e%`2GCmDvu?ct)PNrjoA3q1
z<x?0cz-xEO0$vRA``D5^;RV2mr87=<gweofuz*ch&)Ul}r%rdi4E?}wpP}lx=$;&(
z!D!%97~GUlddI4tAS$1~LYJ)0exK>r_PjNpmYZig6oQerdPsG_GNt-<+&t@NumkR6
z%j=RuGI|kWYT@=5!P2vjEvZYk_P^l`uZ5PBsZHTQf6`KhkFBP2xR)q=d~*E(&=+h9
z3;nBD3;@wPef;*^h!*S{=fubnv}W_wwb$1`o7t5(01VcOerek5Ik0->i)2$-K*Lk;
z&%X0$KH_pDo682WmV;Yft_bc3^846|H}bNf5R;ilp>e3!aBxSEKxXqffb4Ais37;w
zT;PGVk|=Z99>3t6rblDdx7JGCsB{&L99z&9@B^5tTq-tjBMLY6`=$mm42rK~<KKkP
z_Qb-afRc;h)t6_U-nkL6kNwW6X|=|_Q3EogLuEd;T#bN@RY^7ALWgHTN56b*wORmK
z{8vTZePZGQ7#v<`4VMX??Raz*MD{{!cm_WE(yZXkJim`ERwHkqrGl}!+a|!E^TKOd
zEO7dnh+T2VrKYIUw%r_@*rIt?YW0IjIlCic*=jY@3xL;+d!;^whK{XPBWUd^0Lq*@
zek%PLMD{{!co@FOxrWUlvX^oV@4ejiY_-l1*>1GlQxTjvCr`Rw7*#&@U327T@P=)l
z6E7LEC$d^@hS)dFnYhj{rt!PjG4wL@g%?r_i=CB^kgF_vG#!RByYnVrz;^53sP(xZ
zv=>^_0e+{|MC&F$jVys^ZM(yT*4i<+9?xVhgQ}CeWX)6}(AbG7wAK#Agy$HByuenh
znZU|20*&1#%i1-D&|X+gD-=!#6LjAO>&8NNc%e0|D5!;R`n2;?pv_)bEr3C*oO#uf
z#}KXAkED{P!J<O`pZ);10{MOJ@-!(l;IhKV=@*b_-4|oWv3rUWGj*_bb?~{l^Wgw`
z;Wb)YXuJG}y>I}%uv%YTAXYzdbZ`Z<sBN1ZoYl!nsoqnw)_vpycR89oa3F{$MNDso
ze885X8Ih)CHX>e&pVrPrLCn^n5j0o}x&3CFp{RneC1?R$kSacy7XLLw_QGg*vb;j}
z%y%HNJuP#m2RvE+{=@&W0)?25tve%cWVGaRscg3?;25coeZ3rkn}-hIqRWIi`)*h(
zP;#HamY|6bsCjw(=U?>&vKJrw0ae1J0%*LZrJVyOdJp+%dI40l?Zn|iZ><-<H!Ly&
z@z7m?W)WOm!+?b&%{Kq_2g)660h;Jq2wLk08XRme2?Dc=b^utbtW)aeT?(DSF4-oq
z9vnFjb$km#vng&u>y5^rgSVwYXg0?K(4ZeU7`db-N~P>4RcQ!;mgZ@HS0rfjv1Mlg
zT&1n0<p0$BM>au=?F#6U@Px%cp7Kh^qHu*I&ZZs*S7||s(_j61W4M)yBypJ?%S36y
z9yT&>rp(!HXU>!<8|hF;Tqcr*(zp<!KdRT`)+V8}6en#&yJiWJ6e+Dh{E@~@Kq-mf
z3(O49g2Z|3*&=9-C_=hFi{o1m4Ob3SJ_M){!M<mX;tbz_TCY!&A0f1tTtUlxdafum
zqR}%TzeVtsW&x|U{5Jbh@fV=YUNVKS8I0k=>yM9t(P1wWxsM^dsWc`b5iMCq@bzZG
z8}LTaPkxR-%j^;C_f{!7;Hu~H+nN3XStx@2+-d;XF@VJE_nv;@4Ql{pX4_KCV9c%&
z5-OriSghm>%9|JV_|Q^&1YdY&_yR;mzFr%jK#{>0p9y5RPMbYby&lNRl7z=S=D>?T
zQ%}^N3N7|RZMcXyAgsn{Xt9?r0BEEtj0k@RTI_|`no5e|;)DBRKZ3|!crB3iwk0WH
zd~xUt_RL+xh4TIpSv;(N^(xR}FC73}sIB{DN>^yHmmWY-Hxa7~k3NuoQNGM-XA3~g
zR$2f<iB<z`hi7Ut{iKyBr1?#R)C0Iv151$B{Qdja5ZX>cEND>pa{id77AkyvQJM$|
zTJBV*W@D4K{tw#hh0z487wZR?E)0dxUMQ_E(NZL@9(?yL=ngNe7A>MSfm-%>`x_A0
z3#kRL=I7s%%De`h;f2!#towOpyS4Wrv=>?nXfVrp;m!3(ZXChBbB?ODvg%2^4lh|2
z-SsTpa2UK=3x+5?c(-#?!0QJ72);(muoO`5r~W7UqO8dmsRfYrJm2B3OpQ?1<jd3y
zWG&Waj`;2jwAc%$g``XmwI}YsdJ!Ufp|n8OebHvrTU$^N^Tlf93%K1d{_5^%2<?T_
z0vcFd?1^q)L4SB*H59Eq9n#|$i0p;b-B5Q?azVsd7<FE1wOII+D+zJ>*>M}%f)zOF
zZc!IbYuje6FJ8R?7E&Yl$~6%a87-t{F23L^YjHvD1NhoCJ&0eNl#mnX;Uf5gHGyeF
zv2;hFEs%WwR<|P%-UF|zSc|{<d*>f+tqxu;@kj6#Y~p!unn1~sLDl-$dr9}KRTqb=
z+0|MA>!(VKAE}8hUx?tV*90t0`)H!0+Wc))*TJX};0xFS;2Lnh-%l-qz-(d@u!s}Y
z;w6*M-hy6c^I8Bq9YM7Ib;`fxtVATY;P%+L&^rBoDy3o<oRW7uas*$(M)rytr8;6)
zhw%d-FuM&WVBq1gFWi0yoa~NZ-?`R5{bona=qfkY!}`Y-uo>9!#<lk^hJJ<WA6vp^
z-`uIX`n%|F;R+O6!$#1O(ScKhlru_4HRwv0Ybn=4Mnt(5ZR`Ah(?iEYC)b>N?C+a%
zBb^r$5&qM=CeH;Y=_A;$rjpgP$}DZ7+13wkzq2y^OS!!u!d=Z~S-&qVybWDdqTgQd
zWUH-%U=(tBZdtDM`$YCvON^WWHp!*KIl;-EtZ;nOkvE4}(pNe2v-NC7Y$%{L-nw!Y
z+)5h3R<aqOw0~xvq6dxLwL>xB;W2*%`|dURMrU7Fl`zZde^biJrVfX2OSpk63^tMN
zkgIg;czGfWZ4Nt-U0ZW0<fa{t^iMmPH%Hz+shO2aGphf5el%*v*t)j<DI=0nGq?w4
z?7pL65ZsmR=3c7_ZrpvX`aJEu7KOm&*AeUs*#;yIvTha*>^-Yrn3&H$8YPoxZcUfI
zpkMZTr^3Za;GV$<_v_hA=Sb*kdq$)$l5!k9=pY@Ob0NLfxX*jD{CMOKw%$#$*y{W2
zNI&t{i~-~i8dEva-9>L!q_+%9YZ6wq*_sn=G9@g~u7_Ft)TF`4-|V+lCF|*~95q@7
ztUSF5#UuNwHVHp)1C9EHGg}wTfc|&Q1$x9dJ3=a*&lWxW5%iDU5(Z!9l<Y_STfRwa
z%A;uxTM{SXgG-Z7UM#f$C}<+sx;P0QUd>x})cRZS175NL<@qr4$pdwG2d6Ap20y^<
z0O%K(AJ8%;WrW(b3LLYR2;`pM{sFET!MMpnDcsM_zS0_HdA4NEwp-7VO=C8!Ls7$)
z&Dr2;lBA&T@c4hLq3!lognQ5jd~Rhldtx8CXI3s~JGU#aZKu2V)Oe}#$rpnmyq9zk
zu$|UNRrpE0n=gX!Uh;tn4`yBUZ?C<EqMa?Lvz?>gH%>#lXwcK`;0L&ic=iWyI&OXP
zsR7VIHlMh$V^2%%dN}BQ*g}G*oGjNvcXgdq5BG`*$I&*KW;@FvC4(pXzBmD`>)FXB
zSTZoqNT_+>NLmdvL1!!L=uKEe((PrIKSE0&Y+W4z>-3yjx9W5><6__FX26CS;sTXC
z7eDXR4r24EFH8<I#4;*&`RA6R>r5ip_qmbXi19O*RC@{zAfNF97;ycc*itv(0CML6
zWU=0{+<9;(Gqjh_Z~+Ta-|^Mk^PtqhzR%6D*B=oUB8JfBwp|%IRUdl=T5hw?Ep-UX
z6;BhZhYsD5ezscD*4a^)0jW)Gonzya@P<F}_fe1~r0us10F9k`<6%)HOZ?OBY&iJo
z;*Cz`>#YNl2f{4zb;{p6fErnTl+wkg0boJ8=t#`G&Ktfi0peIZ*5$!=JrTWqat+#@
z7SAAgfJKCUI(y|((AVq^LAV4Fy6D?uia|%PGlc-w3EiOgJ@i(mxU$@XBM_k{{P21|
zFmn>uMSBCrY`*%*;J=`o*^K~sLt!(uFn7m1+zh%?aa$$RY_S$d3u5q&$CjfreUGSZ
zFQ*5mw(zq;?P^1+<OD0y;-)-r=28!!K>u;L1k4(2O`YipM}i|4fBA8##>mBNNu3ES
ztry#A{+XuBcR`16iEV-_SM!qHIlC080HL|mHlc~#im&Gv&K?b2!X>u_ZM@B<fDbtM
z@gNA!rML+W@94d@@#7YVi0q5rOz>pYC8rKFS^>SyWw-^bd%M<%4}OQx9yu<)AX`nv
z`)KDLr>u%7&G#i8iYvp#yOPH2%6g|!8O>Ht#%x5R$yVK&eu4KEFL|o}3<z##sNe;i
zz{OUMmi-L=JeIE$3Kh2U&IH#I%H@{xH=yy9L{KcNmD~5p=HG6`*M`tuI4>MRt%5R;
zFOJOo1cdg&d4kph{L!$t^TJ{D!gzv4>14=-t!2SH%P*~Rv%F2~6sk{p?0vl%*wpd6
zKl^Gfx0)d$7AqBRztMi?FVJc)oEI)J)+r@yBK@RBzwWmJTPD3-a@<L82#h3L3cgCO
zuN#ksQJM<4dpaZ4PFR*@Cy_(gVmxxS0Jn#c&~jxW!#A%?I7@~r>nMIH4Q61twT^P&
z;L*SXppR+K4ecG|A47}&PdOK9{O+&3I>0x#3!OaZ_-pYA&9w(cfBSan7{pA!2hvv|
z-{{Jq_xiQ?0Ic}?+2Xu`DFc(NEi|wsf2Y9XrNK1X&wkz2zz-}T!X^2OT^mn94E1x{
zdi$|QCE6$K>sJR&aQy6oFD_cwiGO_4ncpmON^5$4Kb!ah7O}qQ#suTZD~c4E^>&a1
zWxbG0Q>8Rgtm27#pVVoLsL59ArSuD_R0(JA`qwU;MDAdV^#a(spBt>L7m5Odt=JR5
z!XF~5sHwa5y*}tsdw-;zUo*%iW>E+rt7AxsYHjuz^$}gzLOlU(Jp&GVo*fUeY(spH
z<Q9491Lz0bYmnzPh|jI`20kH+c9W*@N+@1_twvrLid?!2{FGE2ih1VtMMn?(>>KC;
z*m@{dNp1fK#yFSq0(i_AC6`d4|2?j8ElcStQ{Em-7s`t^P;u~=Ri<^bmIUPV#MbWV
zKmYW-(aB&}+|RyuPAV~YpXYDi+=5^m#?O}TNna55t3j7HA@Xa)O16Sef;UK`e&E-=
zKU_hqVe9zl13`*pimz#T)VQ(5e8%LAmXSa@e5_iR1PIQhd;nbJTCm2Ew@BAq5S+{R
zbZ}t#h4T03B3`;{`OHLafP-zNkFqsb2!XkT4*)w?M~U!LyL{Id5#DyS8{xIb*KW_-
zc8fA9#h*-gcOjqIzJ|6sT%*~fH|H;KZZJ|gtGs?rcW{%gpRMOJ{19M^-OVp6wD>Gp
zs|ZN_?g~EH;*)JRv<aPj{igm{WZ{zk{DtVwen~Z8b;ff179r1+M@1~!Zq<S}5JOT@
z&F3i1TxC0F)nj}2PzOj$-Hze3YeELtmUAYzZq{^Kqh{7<+R%4PK6n#C+tKF^oqYE$
zfKI8{wh9r3KIX96mFBk9IYzJ0ZJxL7-biZVsS|VnyEgGQ@MImf;HjZAp}npIw_&GM
zsbT>KmWzqttwZ16WOc1_MYsLnPVm6Nf1|G3gSWO`p6zJx+=Y9R#f=(Gn`_x@LuV@$
z_akx!TeTNDxpkHKNjmWR!`2(mT&q#xF4wbdPVQAn2i`Y+zj1N4N)mUSo&-EC?(0=L
z^!C<EBcL-}xh+B8y{iKk&fX;n4xk5OUuv{!RYe_o#rq|jQqWPMl}X|*%d>4RF)c1x
zM?UlJv%?Yn+!c8?vM4Np7lZ7G`=MBBPUvJ0te*c(V;y+-w|6f?U=O^WZ%3TX>z`U|
zi9m(hHrR#NVsB7k^pXWD;HbH4?rh)2&Hoz2!~Cf^o<&}87u?y%qvpry?yc0NZFy23
zQXI>H=6*|^4Se@|9e3mHd*4z3t9*99r7j&ee&5|jfX<QQUMz&D5$l1@6&o#2N47Tx
zi!T~m7VSsJy7Jj<KFuQzShwC}dXo_l-L+OL=$eX@`nv1S^!kL@s3vCiRduHANa^+d
z;w+7=3h0Otn<^P}8BWV}jYX-n&tHH(aV57CIk3+w&*7+Yw~6pALJYUTgE5>|-n6;+
zter*sAUCtsbf%k;E~NH=#gia5cW2GQ2AYMD`N!2lj%KUsENo-DM|Ly?U&SVGu7Q?w
zm)|V(loV~Ie|7r~bl;bst*bM!oijJG`qIw_hC-`7(j93;;ww$9f+orA8|zG~jja>a
z-8p7O{s;}XTT&JuY5uKZm+k&Ny5!i;7TKAGgEgDGyIT%{KC$`8GFw}(A+8Us|86gf
z>ypIIt_ehSf>-XYF(r1&<|`pS-)L-oE9*&pzqG>cmOaFQc;osdWj*iFs2-cZ@I|t<
zc0*H>2W0RJcduv1?FS2ck?cF{3~X}@jar}v$obv-+QBby)pqoS)~QLol1FB6K5fg%
z|FXg_u(OHu1z0S<+c@rWX;CccPbz4U?3?YR-(cL5YNT`3Q*WhgUIc#!JHLqEkua>6
z>M4qyz$R+BV}+{Gzm!=*q`NZDYO<<SZP^aL+kGJZ*WEBm*-3_W4Dfc%#TWlTNhXqg
z<DIb^A+W8LZQCW`W!BXP`us?Dah~jw4IOH>-4LJ2XYMT9lZM#;8n&T-(Vv_Y>=Nyg
z6q1!>ko}LlRV_7;9Exmpp5cnRfs@f<gGNbYROfO>RIdXT&m!3>J@XS{EtqzIbS=r0
zBZnu$-@s1^B2?<q<`OBI49Y5QDl~3#Blrn^PLMtUWonmhjavXeVb>6s@<ah&H^f+K
z6u%=~FKGwos_<;JXql9<f@82<GlDZXGbOaoLz89o+1{0V-+Kydx<vZeQw;hEi35Ae
zyK%PpcYb(yi2kLf8+Rd}Z2sOF@!+8Su9h)-L4z9UW6v?jbg?BT36gBfx4v<*M~JYz
zoa%Vj)<d%VWZNc(npb)JNZ7vCp_8ZfS}@;vZku|BoaN&8SY3#m9&94Gr3Y=sQT&@%
zCxDHpNVb^IXqPfx`EK5OQFd|^{mC)Oe%Uo}O*pKxZ)Ym}r`19^ux)?1P-@hmBzUY~
z*&BcEM&ZKN^BGqA#M>`ONWb`vF@vllnGU<zsetU(r@NPLMz)0haOJ->-6dRf>aff+
z{i?%JWHaADPEAc5rA-O`iyKu2TFveR2pb*F{%3s8NQlfPJt3pHbm!LB&;ve^?7Q>=
zZJjccCW`m{-|jhx;&vf&qqug0|D^{XH9>>N7V!m)g;Vne!_HktE@o@^0@z?;zIOhu
zd$ek(tQ<zVEBNGK?vvQRmlknptG|93@y}hqCqwHq{&Eo!=z)t!wrbCC20F?z<JWCS
z+7!ta?FEpPc%$xZ&eAN{&7PPI*AWueHl6@u!xOR5D#C)SGq%ujHT}s6lr7XV+yT}Q
zVxQh~9CbKssh$BG*vl9BS)Q^Hx$__R=%6LFk?Xge_k)pJybPq3@2pc7wnp5RmJt{w
zFtB|sTT7u)x6!xgorp-bP|t9N(H{h$$<V;ea%RPSO~}t`r|K@%vl^yVVNE9GPY&$J
zX^m>)<ZJD~QcxsYuQzPapbYP~@y+@HJqZ)ZR_vMJu%-EQ(w$?_a&8HK$=Dq*rUzqH
zuNQl>Y>5!z^|Inmrj7e0d#2Y{wr|!fEPhk`-pJ@<ZCW=wa3tr(LoNC`X0a4F?T%D`
z5&j4+@n13~X=1h+9clgudl#k7mNI=%YsS{>S>P0y8hXte4-TT7<^FQ)(3A#=Lz1E+
zL&dm;H%LsC*+kqQyROzE#C>~UUAV8+^@J@AKSasOUAX74H9@R44eTB2NLDn8nWm<p
zGcA$sB0d?uuIdYdo}Q`Y`)JbPuHJJ(XJq=LWrb!y&)8j523av3-<ZQ^u!6XLOQq8g
z-p=Dpc$fpetCIDZGJ>M?C)3njyQf%hb}Q!Yl^l>X2yb?I=4bdTTq}S2XM$Y=_Eoc7
z(;&QS5>VlxlOku%{vIu-xGVV-_&{ew_W`I5YCoYvbF{D(<vOcR|Ae7!Hj<fGv2mOl
zqm<D2%-%UDCD;QHJSFIdareH|@DlQhyR;9REL^X8CFZ5gOAvS66@KZTFyj*MWA`2~
zc^|}goz!diFmRgO=y4C#4|lDfijVfP7kzQ$4b+dh3;k4deR}VY8T<?Mj9o(9(vCAD
zD2t#YvWE?)BTdS&rbzc!X;s@rpK3f%0B+d`9bB*?bU!~Wm_Gu|%U^wOK3wK=zr0WT
z31F_&;h&AK!U5nX1j}}9GEMoQ+OFsKpnPDv#w8zUEyChg=lz1b?XCgT`~jxu(^D(g
zLH=-;0jlWuuB8$oyRV=U;;sf%@!>MS(LaX2g1G9g2~^?rrGN*!8=ioU=eG!EsG#M5
zHieGFL3GcV0Er7iN{qv9x9bu!&%kAYU0rI<g2vln&V)xx1NFxb-HqlRF|KQV>Y#$<
zff^GhEP?^=IRWT1Zb|^}wQTYLE&kcI2TcIRNo*ylzxLnuj}eF5HG`@@;6%P?vll)k
zcdHY5hH!A-h-P7}qWnigC-~;PS@5+vk=i-i#$Ebeh2XBOKs6aWaBK87<qq7*f94pC
z#?oCunC=);$AJ5oQxE)M5TBm`EPU9<e0QmJPedbkHKA%h>SI=&kJ*fJqx(gDD!Sgs
zO#E<9Hs~3C0x&(J>+)z~^GR~Z4(J)1Ms5kl#78a0liNOO57GHKz(QAA49Wl(C!a5h
z1OPU;O9n_*_<x~ywnXG?cSWH(koX{8mPH?oL+)_Drcc8M9me_HGj^gdbk`NC=z59n
zab|ckXgPn8z#K?aq7UbN@F7I^On+3O|61PWb(GcP_zi$*J1o&<8)kVN8qe<lOn6kH
z8-I3pE-KOP&*G|s3QBb2dUH-e&v+)kRPXH7$EiCKW1wejg1Y7wLtfV-F}0jy#evv=
z_0XYqR{fV$hW4Nm`3XM*m7z!|68#BrLG1S17NWG{AT1HP<r8ho;q=<JiNFO>?)pM|
z_zV}ovi3=l^>x9608#D=LkGI00EFL|wf@{v_zl;-!to8DowEbwi)|<Gz;AfSE|NYE
z{*LYM&B_hG;UUKaL`6mmBbKNv!JGX%YA;`cu78iJX$Pfiz|$@|Zj$<MUVRG2l7~cN
zphN#G9#yt9s2)-77XaGhOz5aV`mgYykzk`B%3WjV#MaxRbJH__3a$2#V#sP$$3f}f
zpRU!GqjbR27Y5!<lQIl-Td|kAK14(4t}t{u0{3!v>b1CxoZ&7mbfP19$b-9WzJ%Bw
z(f~Ocb%|}N{167QJ<#94R(eG8c$X@R7ebGFpuK^uEkY4`lgCaX!B&*dBjE)j9rcZ{
z|ETgX8xTfExeExLquD#jJPa+a=G52iC#=bf&RIpd>j;&vq$VW|)qcZ9|Gwdf`0h$V
zC%WE{hBnVx6UK~3;;Zc_5x?1<7tqq8wBZ)44-i*_X>Gu(3tva4M55e<gNh$Ogx?%f
zt|aIXqufP<PHfoR9_r?w0fa?S?w0^M!9nxcasD6mpxqu>4_nWlvPWMBoo$r#D5F~?
z4kl}uQ7G#Q2+!wzFk!>Is63s)W?Gc=92L)ckynf@Wx3O(+;XkPrtaYKt|<3Q0nMpO
zSxMS!_dnH253X)iOldPV%Kbh-3s&!`e%$oxdT>cbl)HM+!ZZRzD#S$b%I_UUyNS}3
zH7*p_b`Qb}k3Ww>!d*CM+8Jmoop%vah6{**?q=`Vfc{0bOm?licCgyMfAZY<=Xh&U
zqr|7R&vaZ<0396u@g7to-PMB*)2rd*0>ewEMMK9hc-}1GxmJO0n6}8^X@us7D@H(g
zMuC^$MY|@!+kQ{G|J!G@Nv!PiMY)R!9e!_e_(-*;2M<<jpJ|A;a+~G-+4*Qmm}V!A
zp>^%+9iQ0SGOX$0Ce_<#x@q2!X#a@hXRnPVfkcS<1=mGH=NAstXp{bx*PM!bqt~kW
z%zgTV_8G=<f;1F#<=}wCp)dAH8X}L0oo2esem4ycIivOmzC$x0<JxayWkJaeV}H8e
z6}$x~-8L0GH>j(M_4>~DBYL^Z4lQ~a<_dbL){@h+Ej*kBIm2Ce=s+iWA^5N3d;3w9
zb{8Ky;PKhBxH7N31vb&6+@*&O@E21C4oyrRD5Ayw1$OY~-F4=5L@##<VtVi&IMN|L
zJ@74h+3^^jTDUGM*Y39lI(`Plec%>SwOs!>;=^T#SngUx?E~q=vR!5Wkn7LnK&R89
z+~59{zat)UrmIv9F`Gm!3f8z91<?~^QSN#~=Lc+8DIYlX);n#%yPHuQNurS&=v5Bc
z{nRX!I#C;`5haP4OG41*0~MnGSJM(N$SGf1YRs^~3z+H9N0Dns*Zij;`sEx2VgQn+
z=88M-efGf!2+ElCo1o5RR<bm#>BV^X<GBq%^<>q~k3RhH8)zrD38+r<K;_3*t9I))
z1Z6b&fgcafXC9kedK8*axj*k~GC;&9RW2n=$*(cRW)1~H|0wsDeVx!+XuVu<a5A)+
zTh~pSL4ZA6Rjw0+=9Y2`+8JiV+QA#wqVofiqg`05wfJ@WgcL;%<_HFjfG~~K!gu|q
zvVS5kaAblGU_FTQ%;|Out-!e71}FtZRTOUT)P8ygI2aVg(FUd)T~(|}DYP50G_e=7
zn9F7IvcT1Saj}?hIdn6Z&<1i<bcO%G<CWLJ&~WYHWj6zF#Enm^3~hF8-4$RbK`3AB
zT2dt*I@$}ZtD(>+Si5lpi0p;c)ztIzMCt`Y*Il80h5qC%I@=o=k=jRDQ=E}dqV3hy
zcYVlIj_5BvimM|hj9;>)AL0i`@FyW_**G-!yt2?@ZcU~ruC6+l0%GN)uM0wCZecc&
z^-x>8qt^<E?1j_D{Vi&?ICpSp0qA8foUY-No0Bgx7tj4MwAc%wYalOAnA2$zM7Co%
zc<)DE7Rb7nFK#|F1p2}Yp=;<FIc?_i=xA_Mj2Ai!TxUimI$!9tZc#2lW%`rpY#SVu
z&dCayTW8Ia6S<b7-%F>QFjRN#!)IEfqq|Y=(mg2+*G6e#Q`yL9G-&RZ{yC7fG!g%9
z-E+_vUdU`bVyaSZd$)ycp~YUvTw4#b)EwU)KsA&j(n}vbv5uj+;?>MY;3ft~pC<!@
z{x#bhi*};&?0(gsJbFf9Qr$dyRG(GQ9X2`K^Mr7R)?j_SEKfYN*$bV;f{w^TvdzTj
zgFO#zLFL&-4$fz-Jb!m`A$spHilfL&A39;H784~iCpAD$;7IXgU=R~Oua4}229Be{
zlcBYNYhJR~O=z<hN(*Oz{B|t$Rtv;w_nZBsIIg3+`K6glN1!ak(cY!|!Z^z<hZ+^=
z`&n-`gveeBv_RH#{p#Y^Z$o4+1-gz}?#SkL%O{<M1L%d)Vy8l39zl=#@QKMV=xpk_
zXA1%CAPP}>Oy0uXEJ{l<JKM_{FxtG#&k@9gm;2g@JyxViC109DX8>5;=-@@{ipiZ|
zol^Sm=D2(ixHg(2w6g=vxMoz1v{BQyJ%Z4-5Qybk5Nd-@FFg-NE!zFLT$y$t$A`||
z-U{06B~_4w$=S0}q^*4F(pU)XrTi1L&b)~3qpkqvMRW9X>4Vq}(PK&WZ%$fKCoQ-}
zyWh?yIl7yZ9psF6cNhH+TI?lPbVJjG($6(I0+GGs3W2P9`R&okpFm%DNfq6keFZW5
zwTJyKf_*b-5i4V6SENW&DE(a9#xEleaKv&_G=LC3a=Hk*`ze|ul#`Jy-`bl^^*Z(K
zURg|Ls);{2&fFi%H8-1TruoI)X4Y<TVAFoXlw<AlOrzHY)Jx_*UprtF${#*1&5fK2
z%1NQevm`@cF3AJSEqeA?x9S{v`z4yAm@`~&0FzQ)iI$U(=WhUXBGDYVoC#bJ@Ox*L
z-w;<g^0;(V5P^B_4x0jTx$O3dDhS4HMW>Q)LtHMm30LW9iQ5+z-uo1B+g@`D%5AN$
zuXL*E2gpv2AkOqFT!$TTs96z+%dOS)`@wkqQ@=zdh-*6_cn@IUTKR(dsZ7Sxo2v@F
zjM}zn_q+4Vx+HL6ApBC}=F>po70nUASq`qM^CA0&0`pK_h~O@_8TKjxMul`z?FP#s
zu-$07Iv7U8!ydcQ!}if^sheSOa){_yKrKB{xqe}2wg(==fZO$Vma;J5_(ay0=84Gj
zRxaOcrAfK{whKnaL>BQt(Iy%<CHEF=Gr)(8WozGjfk%1Noc`vIb+SNQKAXiZg3h{U
zn++TfartbnhWgi6zdhCf;@aMI3u3sHP`FX|RBO=WuEPDUy!0$lUFULW&z<qmT0WQY
zHp0cLi4d1hWr3@Y+TELfr9oV7uk91t9w4{J9Qd^zN|o*x<fVHzJY08g-7PI+AS|E3
z0#=(p=jzg}KB~laV-}3S`owwXgkl{~24kz!d?93}K3r>0wS-eHwlK{XxUpYN3PX!7
z&4tLoR-_TGW0`~MPv&9ezDB{tmZA|VsB3Azrv4A&+T-Px611HYviD)@mtKLmeDcEW
zh)Va*)qvjRlef0+-T0e@--6cisSCFvj*a`@Qi#hhzkyqam4X)j>T@lj7x>&&HaMvE
zc5CrW2}E6c$bwN<WG=<ZM$?YJi>S+1k%>E(;bP+LNuSk5sf(>8Gk`UYJ-An>8-(ST
zU9_JOyYtFp&<*^mOR)M}^;6&Hbs;dHy9BJK#xv7K#Y12_65Nu4zW+j5VMNuU4InU|
zy#g4dv5r-qn+u1IPhi@3P;>c;osGYM_VW2lu=>zd@)fxWf%ya`VCT>ghy7L7G({Y?
z9UPRyTI;<3jawU#q0)LdBNV`T$anS67e=X3T8?uAu7g$>?hia219ABzhPy7UzMC0?
zQZ8Fg<`c4GEx=X}J2M$t%cn5h$*FpG>Q;!$XRyF^h8GbycE+8vFdXdoave38(jQhB
zIv5c+nonSLcZlqrQ+@tHXfL0@G_lqR+-Up0RuGs^VA^AF0uzD5NBp_e+Ru_Fz_uTP
z5E$(|MdXWLf<l3<AoGR5EsMNA7d(gv!Pbuvu2zHJUH8mPXf2<<c)Oz9z|SBqzX-$4
zis#}6<b$|;0*kE*XBbf69@$!_4#edXSm5deUf<y2Ewnr4{#b1KWKx^~37qdY+C6)3
zVgH0bYt!vSbksy%1z@}u8#n@3^F-SXTifkDa4>TldUR9WOc+t(d=^AG&TVjkCBrJ_
z`4y#4E!%ihUvP#fnynx6Rl#qj5TB1`+fWHe$fQdwgYr39v9)>3C$s5g8s&AGXtsn*
z*g9lrV(QQ#9g>Ikp>r_d3Fe*A%9rlstUMPSmW^gh$~ybHs{K^9=STd9at2#W)>(wK
zhT8tZ4_#1TaBhDy0wb}<5O^<0$w9M<qN3#fe5^?p0@g1DiSD)f6=*M)+XPEBNp<gn
zkIN2(z})I=0E?ud0(a<8r8sniU6q2DeFD}mN%-x=f2q)3Zgn<bfg_&FHev|`=2m9|
zSaAfgxk#20D^Yc}af7p2>#ujlj_HQ-F<U?;ZiXS{IOwpS{Ci$`l-Af1G7~y*y`_>J
zekzw74(;aFX#y8h7`n?vf&RR}pI51>(4SmK;<%;Sgf{MpRj|J=)d#&M7|qs^nb^SH
zW8cbF8oHa!>VQX}yBqnw*aMDmM!UZeYh|MT{X^*njWF}kGu7$&^K9J+4gp7V?r{s`
z(DV<0yEGD~jwlW;E{t}6DONKdUZ+uJLHSE`hL-*uA!GB>B|i-u6>2m!$Uj8<&rcmb
zZ&gD{W@hI<;yrx>-{zLy;RV_yLhN$6=m0_t9N{aKsaJCUq!)aCsV&bSl^l<1E3QdM
z%=%11xN;5ZyD#|ff+&e$i_8*jH%NZATfFPx^&g`crvu%RpJUuFbTj26O~R@+Tho?a
z5%rt50N8uY{f~vD0RqLa#b(9;W{?b%cFq0=bRID^*-6EC@61Riwm&kZO{fdbZpXMk
z4lDcP1UV#hLay_@`=w@9hV<{QBSwSwBVyQ+vp}mZ)*jOD?=Y@LQSxH8>uGH&h(V=4
z$H1~X2g5xfNdtQZ8cXxZ4Z0aXO*Ln;tbD4x_zwL!zGaiig{;cAq|3FHpS86|g{Cm1
z*bPSDQ-Nde3V5YDA(2(ZZ=gTN?_ejL05}~Mms;`+JVz;G?aVCG!Q!4Y<IW&u2yLoy
zTuu1}YuoJK0g8AGTft@oS7%=>z0+S=bW=kJ&D|OgK#RPowfpa;B~=2=U5vYi%_=73
z_s+>0@RfOgt^`*w#<10DFQyC|n0}cVzGC-Lskhdn6z$`#7dXBFO6|x21yF|*!xpg7
z)4igh1dUmfjyt|YY+_5;Oz6M^0ZJ_Pn_0_vES5eXvx%)_Gr?i|RH|uq)MdwT?s+r1
z8v@7OYLlOCETn=!e-693S-^x=yH(=*^Cv$ZZ%w<TwLs~~gkXFp#89A9cydIx?1-9d
zZJTK^=z;THUHJ@(5YAn1vY+7~=4^T7ZNz)dU2g`sm@-pjYio}Go$q-J2zg`JA~ynt
zD!1Z^U*7|(crk31TL4+Jxb^??eg!S&&NTwK;=gKfPCL-?21MpI0w%J)@;D)_b3KU6
zE&BoF^iJAt9DR2dd<6rVTjdR8O;<|Gu;&u@*MrbpcAL<O)kN;h)rM8dDUt^L$>g>h
z(qQCHR?=tpzvd4?hO#AYmZAE<t!%RVTNK3ZSG$?@mY}QYv|AdJXF0^>E+GVPwLP_{
zGhr7{pt-*Y>#$cDGKz+7w;!Q{#xZQ28(9psV^3WD4;{LWalgh*vKgw!Iv?mV9(uzI
zq2bZ?K36M7!141!XdrdU)w1s?Xt5VML-EiDSF?Wuk-e~46Z#OD=iR$L5q0KvR~MAb
z+OlAU9_`T?zZkaajUo+7hkooI^8-p0Y}uQE4EIF;n0e+mRG`_)H-Z*jmR9a|pF3O;
z+HB{_;4?-O7&JrIt`D66ZMH{_1+8VFhX=-;hc<gD(ZU&^%PQODc6}7a?CaLZ9Z)=x
zZ^*tL5ZMc*p?o5~Mjo_J8pFO>Enu_e=B5vxOM>I)h0>~WfEc}@f9EcU(f06V%xFV)
ztQ6>_{R+N=;(;xOGaLYUw<rIz`_ZVe<!}TI_xOude)|qe@zPb(?(6`&{1@wvy96!v
zLTI=jU#4U19B8o@K8u}mwJ(laS)(7c*p3H|C%}$;hq{F;S}V))1X8*P%oSO+_DJTK
zClM>ySFMRm38zZs=6q2fMlriK2Y^MysWvYw{#Gi4W;5A@c6PAD<sXNZ&Wc)Xy9Ely
zWwq7*_T_ibp~e`tB+hiM8DsWpa^<1@o(2Mn7<WmWwVLerw-HOp;zjTHw4AfGdz5cx
zowXZzn0?opWw<_gOZ??FLufXk1A_;uT}1m1|3l2<yuuoo_6uk@J1;$|Ur&h4=Cpwf
zx{6j6J8ec;i1YfYWV4oqj$C~jPHosKIT}IZgp|s@ccy)|4i2CfV&kKJkyVfHg3w-w
zEufX0LBzf=CN>)?(ssKNl-QbLecsngzC?Lb+LUw2#pGY%VAZ`zzO*Nh52U4g9<VdH
z(WLawkhxb-tVyec?$BU*UiIN~a3zTIqH1~!YnSAa#Sb5=H3M4AuF=BF;((j#<on5G
zh9Ex2c;U0a)ze%1$tPcg7TXoX-N)dF+pPZ`d=FY|2QUX0WT0+$M`wl>d*QQKP*8pR
zWtSuQp~YUvtSwX!mtQNfsx9KOZE#R7Yg6dCqf&|>OW8^}%9U{8BkqSx*&#A_Z!3VT
z<TGN%#g?t7KxFokm|-)B;GVJVke)P#t&t;}!O5w<U7{19#a_6qEvb+%b{yz+6e4?J
zvpD6Xv-#=&Mg0nqy|7sz>$!Mnp#mSHG|#?n&G0f5$WPBd?gLbsVr_o7rwVc0M_XLU
zT{*l0wAl-z^#e*o>Bdp<U4Zsg($!{6X*#s2OrdM+E}w#2z}Cu<chUM%v5&qxgIvH?
z%9+3*BJLN9hSPrbWosrhXpFP<o7)hjc(zWCpuwGJyT82m526QKBNxCG|5b}e?!u8s
zd>+HTZOuT2^tiRAV>>v6UN}uBGIXn(miq8V=w~lQ8Z3fTdZWb{=w~mChKnHeU(EG6
zwAc%!l|>NZbKOphzq6JqBoUl#Zw7R>?pkyDmJr8gZvQrI<k6qB2`1I(3?PM~g))TJ
z!GE{;e?=`5rPY*Jwge7@ZS<_nZ-QOzSa;Q%wK+qN^ErfR_N2egqPP1HxFV^GbyvMv
zlm6xhtF&s@Iw2ulQfGs|QLDv#2<|#9cYupi8R_8mw(G4muk{3?%UE~uo5L-2=@g%M
zt`uar<4e9d3}mCRZ1J0+!3n7=?ggo(P9LeoD1Yz#v-Efp{W*e#oivPrtxMSA3&sm|
zM$NKEAh!O>aisTA9#4vOf40;)0v*Puwa+vEo5tFrPJsreeuAT5v(lw6Fn@!g$`QXp
zYY<k|dFThSsMwn9Y@&QYX~`%L<nQ_Iw<r(T9d+<LpmqOc79>?iZedH?tk4l*Nx|bx
zT@*a`8qd6kvI6^(w!jw>2lfOn_3mg=EFQd?6wB7Q+2HE)a%B6{Z<m+?z2lk}Eb1or
zADWbENv44eZQsURb5YQ+b#6iqO<xG6S#MqEpT`k>*-|&hHzdKco#PJe?pOeRf}J6f
z2llkwWQ<7_wJF+CY5rc6<k-TuUeYJPNKE_f;&0#)t5~-7jqsZe?3pyu`W@gSn>UtA
z1Ty7VA3H~=AJK+`(!}pAa~HCn=8@Y4dwQI4nh;6@vGnOv<`jD;T=StgWsBi#?*u{>
zIOo-;{;LLF%8g~K;?!?wz9CNgvyGXEhJY`R6GPA<afpk6b$y7xDGDdPSkC%Pz+dpU
zY#%Z=FOZ1G@^y3ON1DoU3qKV;u)@pmQ|x61$ESkjtHPs4^$QWb0R74B2Itw-z=|sP
z6o|LCPLv5jm5F_&T(9I*D-5)BRl4AW->AKzKgW+?_ZtQ{`ANgR67wF?dBn2cQtj10
zC2^>Bl#?>Yjze!10IQ4A@>j6TA^JNdZ#*o%vN%|ah~?|;3{&;Pp|5{(^d6YV#`4v6
z1~4rys+A_Bcc)?y+D@M?tzrOL^g=51=DG#Y(^Ij0&7A?Q9}#^%`;@%UX7>7G02sLA
z_Q}UCKxj7e1JJ-7U*{Z&q1kOiN(#*v#qk-{(-YQKyaBCduSNu*!F21r^8F7%Xg0M4
zv{+vQR{uWDhg4^=es+HlfL5#~X8-l$b#&v6bVfTEv-K5(zb|E<h7ufKdM8X32ZoFc
zr(}(F5g&blRwwx4J3S!IbW0rx7JFj(syp)$ZpGFkW2R0)RfK)xoP4){8pSWv{%i_L
zpYD&IS`!fS0Z$dUdZ81Yz&X}f_FJdI>bmJyBB<z*1J5ji=v-d+PD*dD^wi&c`?!H<
zCcu8)R6?h9Ox5}vhZF0-5#{om@B<AFF#gi%nh>1Ja2woN1&HHa-!9h~9E6cx-pQEb
zh7wrF+k{7y2=8<4`*vuO&6eazCIfdb>fEpu@(5d&7g&*z&tlo@O8vhm6iMLfvZ1>&
z&stZi(X3^4QVW5Vz0swfACAIYdVW55qmXX7da8*gD$QRQSr7V!ThasQqR@!L_-c&*
zJFayS1m_m@bZ~LXDFALeJ<od+azm%P(%<29yqsEQ?b_PV>D<DeZaH%Li+z7y2mQk4
zerl3nf8Ygc)#?5*m;Z&}Z0-lZMeZ%<$Xdkx89R^8L7ltp^I+W9JNE+HtKUI>X3O`;
zz0{l;{#ISF_)4vtsC#hN@R^0pLRUH+B2L7BH8Id~ZvSp!!{c==Pvu+zE$6NY8t9mn
z5AW1?1!8k4Z(*mC(q5t)apv;_&?{WVTi9?s@9qsh4K26BFL)}n(7|}NeXLF%XgQbh
z7B(EuA4Z041lx<T(#=!umTPlqio>Fz-@O8nxpXJHjgzS|dyG1N@P*dalh*S3p6!sJ
zTo?P<`U>CfF)`V#-a%flU~Br4p%Qxi-Y<8f4wkLxGhk_&u5={_vcA(B+RJ6R0i3MD
zzWl=M`p{l3y#uhiz1de)jR!Yt#Kv&Bog4xlHW_s6ObIlrVQcva6>R4BEcvJv#O3li
z8Ec78)ES)yy<mrKaJCVyw)M7m+pKQTT5i=QR1jk&!oN5Rak&g8T(FIIdhMozs8-wN
z2IH?j7cX*hXBY}vNgv?qRVe-5HvCv^2yAaSGJt_+`}{I-7X;?Bm-NFr&C&`?y@-ZP
zTETR)SbK1Tl6lW!CI3Q!E3Kcn<7$CBX44=4LTkB2IXQ4)iJHa!tFz?*#O2c$zPQo9
z&(@jH3w-(lLGqqoJN1C5HXq!43q->W%a=Wl3PdcQyh1wT7&5B8Tlbb<gt%*?2Ia0c
zyKd2C#ztf&TdkLDD16iiNSU|tF%$u8tzI&I2;r|OhfhOXK5?PgbU@z4e?nY--Gx%q
z$pgl1hwkN<U8DwWcV%1!l)u;#y=1zxA0)<;-NTAOU_NsRSgf-s{nCtrX{Vth_|zr!
zstWt+OEp$Nd->cYSUr)Kd}&f&2y7G0Eh&gemI6!!K7L`$9BXk|Qs>#Q#9xBOSJWvJ
z6hgdvC3-th<wy(;k`jz4P{wM(Kc}7tzdeqv&P%5K1<=+FZyr+;0`u#+09IT;<#F4x
zfk^xr=Pu7P=kwxaE_6-(yeCRF0;M62eIFg+I&wH!TO@PlLm=72u_bwg3ds9vlc?d)
zz5H@6w6)+pz&8$l@(&<y9Q)l<<KZ*S521f{>ILoP=LBIdaKxm|#nC$xaW(l_fkeh?
zvN<y{^el`9o4js0K@k`eeY4H&l5EY>rP;JpDc$HxY$Mf#LgPVSo*#z7j4iH97VGgK
zmERiNVzrfTq^WuwTT-Vv_PJG0>;+5wacmu3auu5Wn>P$<an}C3r=9~lrg7{W<3t)a
z_IdR(F)_JcHWb2a0i6l0xukep*oScN*jyGigBg4H=}(JV(dHODc7Zo=L301{=yCK$
zRUBI(N3H;eGQVAU{T#HIP38cu-jfta&6gR*1)I-=EKGJn6RGD+`|z^G5t-C>n;M+d
zTA#iw^1D6A3v2}(c^6Kq2LHQxG>SB~?k#|<MexlUCx$_bZ6CN~OT%J;uIAw(?@wtA
zk=f090NFWgRGGJgKm961X1D7C89u)FeQFo<q;4Gh$y4$&m}VA#qwO4Mu@^qW2N>VU
zobyA7%&yLc#h`#3&3E%Qj5sfh2B%)LM~^**k}+GDMn0zVDssRPo7ex>?pMTSJKln_
zS->i#`QMJY2BXZw)}>jN>LI+i?gxd?u(6eC1Pu?=`W79?3X#1K8a{8hv6~+~Clklk
zr3Gwuj2qFp`;@(#pv7M3EFMnOy?l7vn~fl{m+}m6KkHHQK|6@-h0yS*Zl=};KZQZ(
zh0tQQ3?>L;d)}-Hp}jB~PsID4NGpg)&DNw*Y={Qg(G?P@TmDhM6e6`98yS;Y;E8F6
zLh6W{xqBifuqA1xrC>tS<D+qdkQ3O7G!xon2yK<-GF}dkJ$(2C3F}FcF1Lg3vNTgG
zLATfho&##Lp+ly@YwCSashDy(`pmX}&Vzoj)2DkQfam>xtjve*gpFeh)W|Pz=6_&{
z58bN~$5yBXkU{l(<=p0DsQR(*g$p2S$!=_iOGuI&$JV78xRBm^Ry3Rg!_N!7#f;j)
zK}yg^Z%w`oL&Hl4uCD<Qy+bCZwLtW?6LfHTYaMu-kte@Lwz73-rhh?59Q^*zJIKFm
z4Vnq9#l$xk!>gcJbJw3)>tcc*%9;g@Tlj$~qfwD!OV7w)xVUim?Fr4H#dcbDPZr9d
zXtH?x)=QIt_$e;Rjt6&K=bLI2U73t5`u?%Ozk%!G<JgzOkvr&tfs8&dd1b>7twm!w
zO|x%`6CaS9TJp%TdKdbG(}i(S9!On9TsC68>!3GDk5)ci9x{f_ZXp#B>pJNTN1$#I
zyD$E9b3Ls{5^Lo7wcR9Tz;5v@i&?H(XG>7uu4~Y#_GQFFw&+ZBicp4<khiTLd4jDs
zGl4;C(5&KHQ=!f5t~_9~mOCac%C-^O%r4s|upW9>*L?gXgl3aG01b8m8fPi>I?5l>
zY@Q2fux{3B?B=Tw*N!-s{9)i~UhaP3^ahkk*>}ZJWC#t7?&NcQUqkw@IJUCPMAmt|
z<nnL*p)b7fT3P8MQm4iij6fyZo}XkuYH`g(osjCn2TDg?Z`J8k<Xpa}OgI<nF>367
zr44ccUsq-zYvHi7z?S3CVlQkK8V7yQMlZ@$03v&#GhEu5(zHK%v^9<|Efc-~OIuSa
z^n}#li^~jL;ES)bS4Fy_IQH|ZL=9D)K{fS{l54(!VPS``dzJu~tv?F?cOD!(cC8i$
z!=;yNNm)OD7JK2cSR#?T3*z#mQYF3zIu+?DxnNw@C)ewu?pH=0;A_kb4}f6El=r<f
zh|J!U7RYcZXKdYf8$e_)WQKB;?5|JSg9<2LW=1wkot53o=4?K+9qK3eO0xj8HrHEK
z<MIh;vzN*&Yz95hzmb=cAheg_Ov_Jt+Fba0ja(4g3!}y2MS2fwdwSVBq3=RZdm**D
zvPD_w!l(HcK%2dAS^z6e1<`tbcVCR91d#h~8#x%Q4MjQd#Pq4l;4*+DVR28Jc!g-v
zwl*CQ2c_+GcW9`#`0>mucTwhK-x)_mq>eLl(&&wRZRun*dh8413|ts-k6r!@9fyx&
z-x+5@YuujXKUf*s?1kGTxzGtXYt6>)(9K@B4Hg7)R4A6N!;+`e?59+Lt?Rq|_da5@
zRP|hfO*~9T{E(|D#l(xgv@#a$9LCzba|d>w1|>FEco-IHUDRT0(WLciA~OL4Et<A!
zN`Px#-&9|}!aY(Fjs;5($x8cv<m~HXbax80n&Cr74s9pyq0Q?4tEpUQ?tCogYzWLQ
z`C^=C9Zv-gFPdCHA17fkyW$IA=fPSU{*nWKcmvwY?%fF%I3g^3>2jU7!d~t~yg%JU
z18)ggHtP4a5Sp73`X>#{;2`7QDQWj1G&dy}(AqIZ^7M+R%Euuzx7-tS;4xP<HXchU
z0A6hozUG#Df|guuZ{ozP>2i_&MeCb(b`Z#}*}>Yx*%uaW95O!YxVVlOef+V}6ZAel
zQo2+zD5JG0dDE?jjZ10BUfEW*D2+To`*~pPr}}qG|FX`dIk363HoU7Oq4?)6pVrrQ
zg#);hHb4!zwRstW@`0rLTfi#>;sacA(+4{1Z@Zq{yYP|T`3PJ#w+UBd4ebTiKfieU
zXBt0k4B6B+kfS5Pi?pMP=PwAYW^>!b)~pUan{TJyNC<zhscj%@xR1}d@krlU5V&k!
zr;HF+=;1Tl-6rl?1;JgZZEoQ74}fdQj<~%m`Ol+>+je9J<+ip%wj=rIY5k;ZWKFh4
zZ9w86>-M_xT5Y|yZu6J=y&D3Z%WerB^;qlgd|3`!Z@VLSw;|y>TP-RqhgO$=SKn<B
z)^k}dq2n70e?2-f4BF4-yYvOU1?jYC?ltIrF6U)*(1}Doyz>D{v+P^fBzz;|s^xdd
zlm3VB16=w`AAncXJ-uk_H}C`8JU|~H)5Ai_X>_F!>i)yslPDLk<!$x{oa~}pkmjp%
z#gbs#6Z=T%po2>;5cl^QeUG??Rg`9>#tm(BsRlBgt#`9c*QwR$$KK(V>2ld;E8c8y
zG+DTm@5*in?<Fq;#?_uOQ0WXPaFPd)_?h5|Tn_796NA;fwG2z!D;l_?Z8FVX;OO5d
zXqs2bTn<eg*pHzONE`{Lq<LrNFNvl)?6*(}SRc%4D+WJ+_Hye#!J=WDGW=eC2+Zfd
z00wiu#w%A9hK}I#ek7RlJuF=LF=#Kh@{=R%IbR^)i0Qd2?;At*QZFPk-7XUuFrBu}
zH@B;q=5LplWwyF?9=~VJFUVYJF~O~R3Uh&bAAOduJOpN!{p5i#fNyjh+#S_Rcj=qi
zS`7#QhZ!r<YPq=_GUz`P73_Q22wkVg!)`4{p!S$8cr#$bgc3_NcuDQC|3N>q3%oEG
z5zl|+P5}taW;6kV$oMelzQ3W1*^CyzdZ)AP!~Kg;zGuIIN-iei;SINDGpgl-?qKuU
zgqH`<sNfG)Ro8dVBc)sTGvGDto+CZ$g>FmFAxqhUH^UKN;I1`{+km<Ow%koL7$ma^
zOqrBc<A<0(qairATwCBq52k>Jud7rPEf2AEZzed{19@%B#OV;)&db3Qs0j^jTbr1#
zX$}a@rM3x8>{c9-WkSg)2+bw81ueovfqp5|o!=ldm);h%ei>)Nf)cMnXl}_ip^4>+
z)eYCwdJ?UTL~-eDLK|}!37Z(c^PSkSh~c)cgEL&4u-9Gv5qRk*vL;*aW*RI0NA<&i
z*5!<w4~dF$Tgz6wnb7dktnH;Tok31!KapyJ8}m5H$<#16n;!8Dij8R3e%x#e2wSXA
z0*XKJ``HdCp|amdHKDcbw`;TJy$5afLU3U-$Q@la?1EHbzmaO%46cN`P^D{iXtfuD
z3#&m|>b3mw(h%AU!3kPVOK0m$oPp{~v=@RCG(EQ>vxXQx`LF%M5W{Vc1ZB9$M@lr8
zsqpJw<OsF`&Ky2b3}su1C^;7li9*rLmcW_N$tv(C5#1I+o4r(U;bE{rTlT5LZBXK1
zzm{s+tY&BO$F|v>8lu*mErT<$#Zv*wAm;ULFfKGzb17R0XClK~`t#abv!P4us^Z>v
z2ydfYn*G}y*%4P_?09y^&PWq~`s>f%MC)xaUN|01bU$oOmLX`#Q+gQD-Fou_YQPZL
zhgJUJUF$jtc_MDx??!e~O)9anZ_pD3^p{d1YqE86B37yh&8w;Ems)HJlE9MH*5B5*
zqnR^#U#{)3u2XVr$?Cwtqa?!*oiHe0)HdU|n2mmTZp=3{|I*N1>93-%3Tu*m$fwF_
zv<oHI4?x+4EuAwQB!W_;M8)^VP7H2}*7(`dxq&GIldKI8xW@e1uVqK0n3t~Db_q%P
zLSQjc`he~HY2((U(z`Lv^ME3JT(d#C^J}z8Yu)U?kq+^heEyq-$M<j9GF%w~f3{iE
zP^M(Rze=Ri>L=ykn$Q1q1}zD&pI;?pJprHToaZVkb?m#`2v$vylmh;o+PNaC_jWH4
zJOyYS{n*zYyN9wlTS=GF&$#JCZBEF!57H*)L&L_F(gm=IKMHY{?4K|c`IjxF3n1$Q
zckxvDKM~p4S~>w-sggEy<c;~a=2e2;;Lg_tv?!av8x?CmIsv`G?dAi>x;MgqNGXX{
zJmXx+ZBA_jaNw0j5^}18_^|bX+-Tj5EvPflMKdpUkicwV?v9yjQR-uB>jLn`BZswA
zX)6tA&ktHY4(+$e7(BNc9}we74-q;S28il+GHpz;Hrpkwon10BU^>0Zs@x$)a6cFN
z3+>%YGMWtV#A=^7c&SYkroQ`f6TlQ7TWcqNeM%~1O4)@|{s!^vlQcxGjvX@wq~%-r
z26wmQi&7urW2^0Sie&on?Kz-*@=5!kF1FegT+GJAxd7)@D+OBfhFu?kuGq&G-5Gs6
zrD;Huj@5gN08#9dmVtx+fOK$p(Rz!~T~<KbxhW(aK0Wc-&Bsgke*2if$$rOpx=t6&
z<|DM#;Tp}_;ny-2)l0kyEw|fkj$=g12CF1Bx;H%q!MV93;1&U{3@K54)9^7!f+t<K
z7L@8*j}Y3e$s5R6DR(eEkv@jh!vu~(U)^8z9Yl7?S_U}S`Fj7ax8^}$*J*)SybKqE
z{hkgdFV+VwlaH;xGl9c|lwYlhv-(u+1uCwOt-*6l!&LMyUM^D;qH`Ms3mwW$p82W9
z^UyDBst-*~9@rc1y|z3THXJlhKDHLmv|QiDoKxXqap)5^%>!0r4R8BD8mxsrVe>qI
zPAr#4lW2avR~c|(E>hB&2BW!H>{6QQuH9akjBI7A@k}36FC*JZCG5tG6a65z-OjkM
zJm3ekt$Y1^=vXv@>=#lkyNx-FYWc;F&NP6QbC>rmbg>|+VpmVx^)0lVJ0&o&1C>`r
zpLFqwgD7pYZ;&(5jow`a&-Crwk%*9N`JD-_r@*OKa*u!xcP;8x-VTHc?X{^^SExO4
z0mSx5cBDJ`?C56fZjV$qR{mteiR%Nmzc9kO&qG@JlS)p;T({Ok6}lf7GS-iL!Is#W
zBS<w}HkasLenRI6G&x`^>`ZLYZ>!K#XBSUGobj{EdLTTEBCMg0JN@C0U<ud9zF2N(
zN`u59NzsuR$g^u4e)Bbm&t<%gFV$cg#=uHz*?*V3LXIa7$sMt~$j<7BC$w(XbXuck
zmN3wU9(;B6NeJy)-X-YdyLSQf$UP^T&?+1y6o=KWl((TL>lRns()9tf*p=-z?6gLW
zrp?u%ziK?dI2cLpaain1b{jhRo5mJ!pdBWn?`#~t&pLD<6WxxFjEQb;9T=U6L3Vra
z2F|;1o0?(OUU#*fWN)uZmc2G`{h^EBK|XfBXifs27Wefk9eTv(OJ||Yu1uGp@7~pc
zqkbFE7=@d=)XoN;ufrC*_4FlZuRV4d^f(f%9TT>XcU0J5+!?J6o@?7K0i(eiJYew}
z;v97eaumDYEN279&HuWh?u)klo?8oj;epYk=Ev#46?UHLN&KLgbC~Rb(|5nuaetWF
z(YR4fa|NH!@r{<JN3l)l1OLWsM1;1-E+axG_83BQA$sabR~0;%6E=t9L5&Hv)=pHx
z0T~pjwG&Hx1+lr!dH`E0Q1*0xU;OO3V9U$LzF>~9Tc;-VN*)=CPd)5<_-7aR1#ZJm
zUq~3%OZ@_Q#N5vO{^LLCUuvvGv58)#YRh)56B05xk55wPv@0a;&XWS0{^a;(Upq&;
zM$V%ZY6n%ZSsiq8#>c*V&in)|S4u1Iwts%;_5PDI0@`n2lb`&vp#vRKXtN<c(~Zc$
zmaiQ}>nh(p3%%r;1<W~u`4a+*?}4ei(jJdpKj9A8KJc-1dFCg?GIuTQ(QvBtKd&2i
zlztKY$(7!2r(6<4U|emtPukS?De5iB^>XOAi}S2(9&mf6g!XxoMY&KF`@YUuuhZA)
z&w<ZR3nDZV2lfOj^A(<%mKkEZ)_Q3`tI&0b`YwCZ>Bq`LY<5BzH7F^AR9RxtAHyKF
zYbvnpHn3r;Z1Mb8zoRKO`)0bKgpE!v7TfXYpjDF`BWcH82Azs*wZ4|-Tm9>^&|+8O
z%eb^$uI8+k-{kKK{mdpj`2w%eg?+!N7PQ*6^vhPOt6oI$)a5;*atXH3pG<Mv9l<EB
zsW!*wj{6Q7%GTx?0fCm#s^mzEMeb!w^8(0l0d0O*^h0Pho7yyVf+1Q^+<K+)L};}q
zV&lcLl?^u{A%Kr9&NDm$m(DsZYWx*qA6uPgK<f)<cl(_`03Gd#)o9tQ-HsF_UGTAG
zc>#;T$&T4$^I<o8;<dJ9MxE65TeD_DcX*<;y1GTQZr8nEIqTX8nbx+=!D($g8KJZr
zZ(e?38%>z#Pfp2f8J^){uwK??$hi<i5_j#LoZawhS*>^Wf*W5WeX*XXO^uSq?FNVL
zrJ==Zw(4%!pg|d4l2Gu>5pcJ&u$x=8O>n7flZykhg9Z0LUr1`W^6E(1GrkOptJ#LF
zY~QR|Sp24Vad7fvoAH|py*9mIwSJoF@%#JXS;#@^-Zxu#Cq5%YcbnofC2ZANz3nG<
zpMc)CD^~`;!3>(0jJa7YI@B;$t>rC7&E5sUZT|4U1vho@ZbcG9gj?v(!6Po~Ez48-
ziDUIW5>w0RKZ0_=kbL>SMBTgnnP53Uk^2}Ezb9`jq(u#NVS^#WvuE;h18hg+oVP#v
zm@*;#KeA8Ub$HdP>_2!iAkIu{pXs<3CkLDKYKqh^3>_XBZAdc3WYs9aVwxn0hwZsu
z`OFP>S*mA;_3l;P_(n=fc!R`LH3(bIK7SOt+dTzXs0m`BKx|iQsVjU?sYswH^)cRB
zHKFSwiw`c2gxl*3F<v@sMkfC<W%Iw#8}583Y-9W~m?3SPJ$W63c4xZ;EoE9eGF~6G
zcol@UNtjV0A!zfa8{)WQ42j;kj^@v6Da9o5on6;5V0S=#r>xfz;LQoo{tfblw6~rC
zVs%;uQ~)VoRBznwYp^~M!O-8?Ki<sN#vD;)$mE#SbAT``f}z5r4;bP`gV2K5)Kn@B
zPuc5_(Dq{lLyJf7<^~~N0?aio$7Im@MKDBp5;mGSf0TJKxW+p&f+59|koB4Ku-7Yv
zK#N_Q24k(&^ah$azu34RxYAr$>^>`yELQa=6oGvn4Sycm%u5=k&FZ|FkoVMhumvLX
za)yNr<{Jh2?tK|_!x8Q`-^qT~?^7a*kN)9M2Qb^0uA2%*@nn@CKj!&+F>(S!bterR
znl~T3)@=`R0z+~qA>(;-&g?IOtAryXBvn$doNNvqoHt*nRN)0MZ;p^e5DaL2-n_GA
z$V%vFUMpaljONV+7JmdDeG|^`#A+lqsZ;xB>}F4_hV$l!$J$<j?(jrwb>2+0o;jk(
zOJI&0!MONNiaRjJO)m3qFBs6gM!+0FeU3}4Ubdj#v#4;pwgN`s28D0#_a(moT}y=2
z3NXSLPMV8+^3^P$jfs#_P%vm)TcY(uG<=QT`{x^oZo7hq4x71I-J6|4W5~Ggj)KGN
zWN<(5cJIjID5N8J441nkrHgsDVp0mqNeqphWVPN8?5VZ$A@l~1-=@WQz5Aa(8h#7C
z!6Uedjp}yim?KpoGOuo1$e?a7y*G9t^aqdO7P7WLO$;wrw9p{LaC?3kv~KHr^9>4q
z0p2~0j9@71q@X~R`*@bKi74C{x;hD2FM;LS6^up$#}L)YxIl3^W77OH5ZU%_@TAc!
z;kj1up0AtZZ-D0ug_k{%8kWGs{k>q%?5?6Sx<oVDPzjvc{GIBk1o}Pk8kE3}Ns&uY
zRq=ZwwNzDzZGi>Ny;0ellg%`Y(gI9`-<8$I@=<8!0uDu?J%2BLXU7B}hKyjm)M`YX
z_>ZLo(Fzt3J9E2zovlf{v`#N&{S1lSvuCJ}E<IDyeUo!DzC#wf%jg1uAz3UHLEF{;
zjB2o&bPcqoCcB!UrlXa*(98uhH(HfEzevfi>kaR=z43|_E40T|Q#yUw1pWkO6&F9j
z631vxr!Jvxi(923K9legzT_f1Xu_U3yc#7G#)WnQI@H)E!Ck`YPlup=xd_G!uIb2V
z&EVSkeR;qFW`w)SE)X=d{i$~d-!)G#gm6?29HGJ_ys;k+cG^ewj++Sm>&kZ9THJSh
zIiYkkDqfMy8cr6g>kvfqg+CYGfoN_|vVze(8PI%xY}Ticr3`UhdL*F!sMp1**CDRE
zg2u)L-BGCz@BV?tj3KJCakbuv*gWpgl<%R%Og3k<b^m3#l&;WXX7MImya17H)1zgm
z!ZHMO>Arx=56gBB%7$pnkj<q7>z!Ab>FusS2Ya9~T6);r>8H#P*8`2w!oxGKJ&WDz
zfy7$RMJ(>J@v~m23%47i3|X9-nm9_lXQ0&T+J7uuj|!2y9L`Q;qJ^Vl)0)9VjV?vX
zu0$SYTv(SL52!`_ZN;NJVEZV7aaUbBE@%*Y9@~drcZgtIQ<n~_uaJ-<nl>8xBw80>
z+)|g0Y_`mz%&9Hcyn&PdMSNzc;B0iHF!&;59(Xn@GJ<hY9Rch50=tbn_F#A|3Oz-M
z8R7m$D|O8ILYuWbu*SR-2X4Dw%yVctnhi5vY89rNJ+tVp&^BYC3V;8M_LUgd)j6>f
z1dY_~Q6hTbC2u_dN7*9mgcqFXBHO7{f9ltbu|QD}!4SqdY=--;)Bm}266nbz7}_`m
z9C?HY^m)W`BsGqRVYTGua0c6hy;fn?QZ%NFTkPzgV158L<qwLKoDd=cp8n)!l%bYW
zKR{ub?kF`G96R{hhwz8ky<U*j1k+O)?fcSDO#ETj4fp}O46#1|J@r}dcel`eS@h@d
zlpX%=A8_ui>I+c47nJ)PhAgZ2n{F~!#qnGzQ=zAuqvFcA>dqc;^9$;niIT*eLSGz4
zNy7dCE=eLfQcV&y4%NSk$`nIkr<trz$Hty}@-O5NhRjYwN87mmFHXLVhLj<-)A6Zc
z(h6<As_j3Azkt>1JA+1@rV+KeztwyW#AmhqPJA@EI@#+;Yl!b9H<%$QsH^#B`lMHy
zz!C708ccjVb$NcnusJCCFs`}N#u!dvdR+eZ9Hf9vEBEAM{set0v$gC~NpJvIQv>G!
zt5X`v32hG-%7$hLHoQwtP%}b_8}p_jgL#rW#b7Wk?>=oG98Y)M9nC<T_;3nxXIFAr
z_yfE&4(52GsmSOn<7OiX5aTvH?FWD<NsVC@FC#`VUYFJ2@zf+==gA9!J~4tP#WP31
zWm~js%gu-2H@xHp`x~%pm|SYvW6)Dxx(0KO6%bjfoz<y4Z+C)U@RAy=FTmfhByaAM
zFj#H=x+fp=3#esyIIeU)a9^HXy(l}-7vS5p4*3mbo9wT3>1oX=q|F0q4=<x^^J2;{
z@p`JU1}dI<F_zVorHPW4wxxkQ?B{9s(!<i&8q-^miLJY*f}!;DgnLeOypsFqwNZJ%
zQ2Ke=J?9rtDNpG9_a6}79!z$qpyN&#W-ToSJ>;boF+)+;f>E>6?BxfC;V<ygj96a)
z%}9sCnSO#1<Spq0HdnP)r)pe{`_TITN4ilfIeBODr4Nci{QpO?L5q~hD>|cA*3VP<
zIpb5Ui<BF__$GRpwR$b*274Kwl^aA!R1!muv~ue}2k7T%{+xzOd%5=R*%!~pPDY;R
zN&l=5i0Yex+I!Y>`O+Z1myX0(f0gH*_R3oO1Ep3|M^f53efGO+0Hu|+(E2s!zFF|K
zIg#3-njAk?`47UoCI$um*xxtj>hNWI_j-|91<iWbtRTZ@j(DZ{@p>(mf3T-qMeD9?
z+e3o~Cq%(-xMl|QjV=F;N&ki&MMMAhjSr5pr~E*BIJg-(*MH&yut?(P2?ebvC4A8+
zSZ}MSTnit%9$g#f_j&3^%#S!yD5Z$bEpw#bG$yAAn+L2EVUSo!5*-$wT?#Hg@bd(O
zvUhys8&n`GT&q_AEHL|dLPEzU9G;=%pD<<S8C1F$*Y(+5zp;&v)=38C&GsA$O`eQU
zwj8%Ujaq&+4O;J-A*4B-VLe(SX?5%8Wf0vpL8$1ct@^b>+vgy<YiiKY!ECqifjw2B
z=RGF{+)~}o+!<Ys>W}c$G!S3W>dwAa@w1@yp0k0zwnO>gx2t99TiaN2KCnC5;Q4^&
z|6$<bj2l(vHUU#~zcf!_w94caxMGyN_ih=K2zY`+nNIq8(Za^l5>PnuM28M+AUuqj
zmt_}3w>{2u4C*lV=C6X??l}#>g`LyiKPU!`_nZgR_LVYlT4a0<YicX)LHKzhMA`9R
zQK$c|TM>vzJRzbCj+b-}zq0iw)FQj95v3#+?ELoYQ&Nl{KodlVcU&`p(LjZ_Y;J7c
ziX+_d+U6}~f=h!-7O<3>awf1Nhm#5H#=vg<a-A<bpH7}vRxEc{Cps(_r^1i5-LSD;
zXy!aQ3NJ60O}%{S%$y{2m#^Plq(~!RiU&mwM!V1ZCqKM^Mwju%t`j>!d`sPZrr4ib
zZT%D!`|fxDIgN)~#m#=&-v}%P`gz(!+cR~;+YA%en?ZeL$JswuMQay4m7@HOj9k=f
z)~X|L3|MV~`GsKH(b1C^&4(XgbqdZ8z@^5rIc^&d5-E=o`57<r+EEnv1?C!zQ3KQ&
zMBaf@-i5!zHB(5jl+kW9rHY2n`BH(hQIer&lqy7X2?flZM{e4SOy(&YP1l<yL)Z7M
za%~}+x-p*WwOyZ@G$<)?XyAT7bW8s4m&+DK9N_64&0k^edtjFRmaA$*RK*zY_S!$g
z{DQhzO=;-X>Bad_fp@<`PzoIrUta-!_kNyVq4lix!Ra3~$@*o*Z+)Quy<`Z}dOXc~
zWooB|@E3SV5#|@rRH#PBqr)LSYck>V5Sl<w>Qz1;^pKa-VA-!Jb165psQGSwlpE|J
zaLEmh9S@4h=&?V&fPBIeOe#JBYt|iq+xiLe2~RNT#MdWT^b5up9EF~I^7EvV&M&~}
z(6&bvvLf2@M3l}C=o6y$wI1sW2f%I(gG^ZzbTB2lcX`Sbi2wgc3uscbt=iYv{dP>U
z?T6E%BFjgH!yoYf$O>p;^q^3oA}~V#A6Ws<Ucwiz-xea;bNZ7f7d&;PbBN`mEOKi?
z+2PdoXRo8|U^^;Ub`WPGwCr%;+vi_Ly)92;X<BY?bHm=Y?dUl-k^gy8%k*y;yIQ!e
zkI7&B2NXd(sipG^sIGtcUy>gs2%gf?iLcl7*3s?Xfd284Ak2;y*WC^Ee!B?$<0VB{
z`<7slF!Ij4i|`kCNf8#lRu`!T^msL4by>kK`jZ*PxU10a+^jDorw%c9@^xYQs-!Dl
zLRWc77S@MAxqSW1*=JxVd1)a`d}pnp1aUO}<Neu%i|9{Yg|Lm!C_#vJO4*RuSFX-2
z<O!a#(i!w<yEy6ZttBA7z2E9yS1eC}pd9-4pNG(-h^MV|+7Ij2^qtK%z#qU`i*$Yf
z)vd^!`A?xmV8(rhTFiqbz48sJOoQfoN($mj87yfGX<O=Ni0>&W82Hkh)Ls`0ACmnr
z+7flwRZ8n(p_wDHPLHpj(YEW$Nj2Yr->?alL5!kr$lI>=@5sHcSsS!F?f$B;{0*`B
zE$>bTc6BKwEZFRuVjXakQ-Ymuf}{jGCglsM5t6LrhPS(XR|kzPPh)9?KJ8E7g8pr@
zU;99OPr1Rsmtx1>>b{*g<Xx17c{d!&_M>*8*x-vlqwN)*z*0unn}w-wCd5L^Jv9sD
z8MFlOR{kROpx-^^1Opwa(ckS@x-YceQ%)d!w9h*Cm#p<6y4@dVz*cGb#pu7$;zFEn
z>KcgdnhP{^P_6z+J6REW-sUOScCCS;H1PcXLffsWgLL(w9W|5%=nGg!>AdNW0H4}2
ztRy(gA?-@I<Q2W+2q`>e67X;&Pe3X2Mvz`pD17>G#Pgt>M)CxdGCEvD=+wT=Q9$}g
zo_bP-ceZuZ{nkrpw*flFQ>Q_+L5<jzSAOaW(e2=1h8|iznDFfZ>~_y71vX(>50<?J
zjrW{UPz%=aL5po*Un#Pt=Zpdxu&U)A&k6(5b3%cl!2iX(z7h1lkvzGi8IbyUSi7?r
zbo6{PlmYA-?Un(w$4ZNp-S!8vnWvO=+AI}*yV<Jx;_UnMFXa)NNOz@VHRE-kE$#Lm
zIM`<8sy3nZ2dO)#SHJwXx}_hL=BV=1tr_x2JfR{)TOtHQDpeAC5T)IECHvZbC{o<@
zkrWx?DrTe05;wMzaITxy&BZTHxecc8k&Newo$$Vp+JS!2r~H5?`u#ovRJTaZm5GiY
zkW3w^NMZ{9^>giZL3~CQ2;ft+2nUJ(G4_BJ{9iIhK7;ZA<Due!hsf~;I_&`~;JZE_
zw-16d@_=EykD#L?L#l=7HML`W^X<?xjJ_froZ^yRJg1&cGM?IiN?%SXh?0Q2B2w6D
z45pR@vOS$J6h%8n32B&Y*qNcbJ6`QL0Yy7U1*yR&h~92sZ^I{cl37)MU3c<1WimMt
zxN9MeB(tGIld!7I*0kLazc(^EJ}u{L^~t9H-F|Bty+fe9MIbIo3m-aiXuGz#Gi42y
zXzB(AQaFglRq$y*;-F9}u3;hN<rQb@JZ|)SG6f}M>9#FTpVCs>4}JUGMDfYFYS9=C
z3Zp>yiwM;-Lz%2wM#CS#%?v~=GcQPkZBHe~et)7T`~i#>!T15jrkD5xr3m^762WK$
zPUY^s9c2fOK+?cZHnFRPi1thYpW5wnB-V?J;ARI4ypAy3flj&M<@jD3th-dCr3Xor
z6Rbg~Dpnq<Rs};^FZ0K<kViP;$bd%zArsIlDIVEe?1LT<-0o_E2fT1YAYMoar6h*+
zGl%V?%=UkjU1xYzMH8k7B1MW6LB)X536P#3O{In!stD3SLN|ooQKTwe1ZkooD7}0N
zQlukQstO{YsHk9}3Zi^F=iGC5&+ePMlONGXf4pbz?6jSIcb4o$4GeZ}WFRmE-p;EV
z6_o_y!WWBjw??MOc;?v6QWOtdLxfp&M)wJ8pl%o&1xN8NzR0m43l^xD^fwfqu}{#z
zp`SkS!0Mf7qrjm@D)=J8poe}+_uDiH<tz?AQbiZWBWyn04FWQw3?KP!Hqt!(0H5Jl
zO9anwj<#IWv~HA=P9*rz0<9ZEaBC3ogA1F?>dRFW16Cee@rl=WP-B2Jnb0x7tY|Vk
zcP0U;TIoE5_E6^xH{hdQH72$3(dkE5kR9sD+s=awXrpw-B=OSX-rCs*{xAF7ZYAC1
zE%B#+S+fCQQwgFjrJW1u!@qOq*3ca#YRw(;i~fO2`4@JjNmIl|^?krv9XKDTd#HZW
z{-duq)r*c}laEz{YL_b+O6|jki*Rl{Wi8Wa$6*JqdarN!q_(?1^)-sY8@aXryZ0`A
zg8qD<_T=w?npgRDesS)+SMK@{?b+TzlmuV-(|>yLG#Ysu&EPc>rn|Qj0b4{@y?pD@
zJuiA-F`6-)Q9_psb8qb_nUXwv_wjeLda6)8TP|2g&lc|=2ext2H-3)p^a$;s>HnzO
zweuLuEiYeJJZVJq>@`WjCygZX=tC8zl0#6O^C4T)x{AEEMTRKj)!L2Q?>&UFB7?Rl
zbu9MHhLWlJ8#{6*deA7E!B~{wZf8Najplu8e?|&2lx=rt30)0~-TceD<G^LMXvVlk
ziQTnNm;SAiQ@g95kSluZ%+Tr-r}a2$AKa*{=>CS~>m8{Z-ZH~=V_7dPU$zNt6JvOu
z?s{eKj;WoyckPdVLE|kgZ_%Amjn5n%V^8YR+V>x<m{j-3(Q@?;9V*u{LyqK>j2W8L
z&-{SY(=Ss7w1i)=XLs!@hwGPl_-Oern&@9~+5oGvK2719E<>roKnB`0g29P~RFoWV
zI=boWddB(o{)b<ZZgl-Hn2XYgDCHnSlHvE})qE!bw>g?YV3eQfpV~1c)v#9ik;29L
zH-R6KeUh}YXYeCsXnPo7kGeb`B_dO>SX61<A1D$rc#O_RoF14+B#!O6;X>Ncq2kw?
zqX=rB2O01;aRH_2nvE!ee%(L00ey)6)Zok*1}Wthk;q}6X<M$x9$1^5$}PR&Yo7<H
zh%Ftgzj3*IYxInd;0LU6Lj6F{x4aKX)0y?_)AhWYMLz9V!-S*~23`=<Q^2v3kGFsx
zW{nLBwBN(z8o0lJg2Vj}n>~yw1*xGlf<rhpcc=#tXe~%<ywu{z2^7`ryhTOpPV5Y7
z9>mVpE55i#^bhh}RrPk}qVko}73!5Q>qXA)f%q(!_tokJXQ4G<a2KWVE8&NB*P`>F
zFZGGcg<kgdVZNVY-4!@X9Zoz4E!+%UcD9c<n#TvpD<Hy+IsBs*4;}<%lqF@TAW7Du
z%Xq(hxtb7CCZ^Dk;;3Hx*(qP8=7c|6nsZ1<gM+&&uJlbPBhSIZ=}cFXvBGD=_CiRW
zV}}ceQz6NTvt{~oxCg0bcqwEkCq_pTrw;Gz>0O>y?T0}yB+I9MsYq79Fkjw0aVwa$
z9L<>8r~n)0*>_LL^AMJo!vpdf%fIZ-zjvS-c%JFOnntkui^dZnFwZ{&z+hL|Y}dU-
zUSHR@a6CUH;Ie4lewbbOghy5L;qsi-#Wj}gw_pFa7NYX})kQT{t-|eHxu6cDKZJ?`
z0aSC*Rt=k04dU`VH-KxpZ@YXmpGNL0VMDvGd9t#r|FK!fycirn&&xz=7Xqu1hRWF3
zjBjQ^e#RKEr~n&w(D%!2uR(eF?knU4Ii}jkVlP8^`3_7qj;@Anb$-tZ<>k9C!I~yk
z?cmlJ2%HZ0b!swQ;`%)=l|i=4c+1#ZI44i&xbyC9_!#2yJy;xmnTjaV@8`E6F5icp
zLp5FAbN{w^5#mZ`v&DvR-7zQye^a~0M9+s64xd~$a$!Qo96mEBL=DQ6>H#V_U1_&j
zf`aeJk9_x^*tar+U>n1r@OdT>Zo0yaE4vQ^g~l+bdmd^<U7;lH%p!LlgVORtLPhgA
zsjqka{X3MF9}g-z^P9Ay?wzhJhd^oh0YNaibz|Leds7vND$UAftW``MOs;k0Q>X)e
zDzAcc@Wq6J?Vz;$P*BCx!HdTiR)*5@1A##G`xn_)@sD?80+}I(LBaFvmIzhql2IHe
zaB=xZ$ZcgWJCxgo2OICoCN%Mp`5-04FnD*0pddGvJ=v!N(tw?B=WIKvoDmu@jP`g^
z9`xW|4C6gwMP9IC;|DMJ0?NzxUD2fTtr!`?)CVI!hOm6s6|jaH7GG_Hp6!WY(CR!j
z2v|_zzd5XTPUH{~eD|$}0`9x-52=mZm%*d+1g>UkcS-Z4icng<`&L82X8GCEPeW<>
zdAyo`(a3uTzZQQNd9Tbl7VkBZZqwgeA3@&BAj}1|3OCYavOm-qnJt4VrvMw?FmgxN
zt59C40$a)vd?Omrpk>Hn1D1wEdHLQ;L?#`!;+bx3p}c(WC0Mfn?HPA=JThDc`OVXB
zJLG0pPSih-3^$VRzU@pm+c#^&94IY6_qId(r#g@R{656xyRX1Ct>My&OIx89`0gvX
z(yB3#`~Lk?^a`*2r`F8U#6r7ovSzdWn^iwlM)a5IPicC@FxYGX8z|%ODmwS=liD%4
zPyaBwZ4?-|rkse#T%WD}BP+luQ4C}FpYMaoeTXfs{hI0*=Dt&0{1W=}{TjAwmk~!?
z@+^&x69UY5?MtzT-+3Awi^MR<Zr;ymBV4kwC<62sB>u?Ia}5e3j5ml0IwFm>WVO$y
zJPar<G0NblP+`x3HDc-W?>(>>%F1(f2Ncw8GoqUphp;?fcVI!l`|p9DnnGBft2?lu
zTsbhHUZi)x<g+@Sr$>a9@JBoH^XLCMa1Ett8S^cEZd_8>nf<3GNJ<8A%{8kM{%Ayn
z<<*{3e?c+M&Q^2kYx?D2nR@^H?HP#5^I`|pjK`0CUw94t{W5fhwtvA0R--Zf{!>%t
zEP#^AWwK!c>wjdy|BgdRd3$2PTQ*nfwK=oOLrJ-g3R`Y>whe|AS~S;BaSOKZu*v^J
zp^8aKbBNpKT1~In3pqcNjOKu9X`URl!mKt+kfX}AvN)<yPro*)&N(Eg(igKB73{k{
zkTw7B5LWKn?Xad>9e#RhIb>K&{#k^$HUygR9mijI2BLDE6?Sqj=2)K%qH^6;pqd(}
zH2;T55LKE$XvM-V?(Mwo>q1nn!x}wY3RpR+C1gUOg-I)m2n#oZ;Mr=OdqPRMSyi-z
zOs!5T(E%ob7;aJ(ja>hhhrG3DjgCJfZ<R_7<*lMGYNXXoi{^ceVil7n7D04=BUY`w
z5VIMAa(z{R`nC>EvM!%@AqoJDL3VBdK%nMA_3V9TFfu77?ThAn7{5Q|z12sNN!i(6
zfx5z3DLq?Xt9b7oMCCdv?29Li-qarcerZ#o-5>O?i<Ou=7fQ;_tD<}DH-0jJi2DVr
zLP@!f3VPR@#&50zjf(50qQ9z%N`6|mNv7?{Pv!3q?We-^wGCTBj$cxdpmxeuz@$h}
z)B3yT`E?J3<$5ahm(8WRJb%+I2+J*j3D%VMyG(BnMRA2ONzM%csJnc6MBJkgl$%vi
zZ+YPSM=C=FaDA0PO$E#gyEX*Ea-9`7tlyuLTom~$V?La#SJ<v@ePT!n<gamDe+A9z
zY|&XChLUpqRkW)8=1T5bB4*|v$X%tN7I!s@;0d3$sEXudva=$>U`xIGQ-2mf%g>}{
z2~^mq?$<BpJ>&t5S#N>m2ZuH_a~_I?vT{pc+@v0y`@MxwR<5_A7IlF_N5?~1x!#H!
z)U)52zX8H>y_I0iAn@$j^RuCC$?Ot3W5cfZ)xm4VK~(7kHdM{CC}(f!ygnMDa{X2G
zko_7Uf34kOT_o~X2^z{@ouhFry)Jtw`X_Wq!K7nF5Jeo`D#$ruP88}FGwE3VTYq{*
zIC;mZlHgWh3}X<R<G5w0*BTfC33jm$4Q)P+$ocfAHU=4!*aGlwx)CE(0z)=5t^e=r
z?S;fcr$65Zn9f{AUQP+Ttw5JBbS;(I@clvLhKvVq13v>c>%ac-@0?KiOz$oexK`k-
zfw)1g>1NH6%ZC87Jtl$a<@&h>{S?srz1X1fy)dDE`tvOT)9u~Q1n&q1jLE$Ex$$<v
z8|auSLHcZ{@Y05+hLsPCcu8Gc3I)Y}9Qn6bWGJjIxds#o2pO@ujBH4VBf@G_2Ej$y
z5Qh#fX6=5X_c2rm#WHDKZN#$qem4cyto6U04U9ULN$Tp@sXtM`%c$xk*jZ0seg~x2
zSjHSSGBAQQr!F3Ntkj24R$eJUptN<-W&I{|(rhRzFM1HHIV^7dkh`BjS$U;^11btk
zUDhX;ztR%IN<$50{thfq!Na{LMuM~z%b2j{ELWE<6n$uxr51gjNqC_FI3J9y#0v`o
zk$~M72{h=)Uy>_>L0_><T2}ztnIfnlljr8Cb*u;ST)CIEc&<^#w|ZegKO`%Y*+sI7
z6sXHej`m%v4KJgWV^X^U$RMCMnpa{V2(+<Ga+d&hAIZ@zBC1={5_Akse@dc=WlT{E
zn3|5*dDr`=pbD7&E37t<LKQn8-9G%lpg%!oj%5<NI`-=2y;KfI1I{bFcN~Og`m%s`
z=SAT+9aEY;d>@Q*iDk09I`$djNssY+M|JoWjB<%(JS6KZq`-H@SCk{K7Pk2P{=?v+
zYpneRS?AJUV0M>r(Usgg!|ef$JquL0BTD}_q<f3Klx8PuCseEqZqCLsnP2XpG~wUQ
zXiW`!=$`%Ky}Cqo7bf`&?j`;=vggkzDBCBaIXyrZ6T8f;(LJF}Glrr$M&ZmW_9m2=
z#FkfIJaZAHKgJ-mAbcBt@kfrn`lUWCQ3PQ!z#N4Tjm4<0j*RI12b7oT;-ro?$p-9m
z1)CN_t{2Ix={xrw&?hzEd|)E#lf(Xb4FwLytTR%wimte}q&|%*c^IZF#<(-W7c-}+
zCZN&Nim#Ak*J}M_P0v?U$Cl-x&9RMk`JR&f8>7U{<b?%fMTvXxqlc;>n`08d0>~h7
zFDw36G6d%J%n4Y;B9XsU^^%u_m+00Mg$*XxD*y~@xy5tFXMt+wrSJeWQuFBAL!DAX
zFE^NUFM+J9VQF&fZ$T#}mNCLCV7~5N7d8W?EUsJ~E*{UbMdyrs1N2~8UHGCMibRa3
zT}kQyuyH~embpbmC@*h29)Q&ve&ov^K9^%N@?~idp?p~wu)tKp1KICiv$Cv2vND-p
z0a?K*)d%bMZbGFplm11(@Cs(nPwM^&nx3)tA!SaUc5#g*dnnKH<xpA~CPQr@T~zT;
z-7hB2zdH}&$|Ymq`kS=0Y@PT2JOgThx080|HCO;I<oM`OC@n8D2T)CE=M^pUIW#i9
z17k8+);33eLJrI%gE;~N>R#;D+FwF>`3@}P)y#n$_&}+7zaj^gt7daxV;BAK(;Z(!
zDqu3g0xB>};pegin<5o3o>lciBfjFB_tUjcA{%3J!bo1o3Ol>7^kL)?%yDEct`Qfi
z&UvE>l$P(mkQa91;`r52T4@QkxFDEedbGKc;oLSTE#H43->lpl9fw0)zW+kT*|477
zpMzT9HNt4k0OxFcg@=1VY5CskTtrm0OU}FIy8<a_i!7CEao%Jt_x8`fFAV*Br5kQD
z0&pX_<)(J%j&Ce;Xqc;1kkC)Z<T{7cs<a3g(wfPk-l@w^LM`x9FJMWHh`F&4O3Qa#
zc+0nZh1=*tUo3MV7-?59rOZNM;A^jajpD6+7+A2Z5wspq<L3Ko4D1fX@_knT8-a0h
zmCHk*ynNTiG^ER~Rmcy4`Q9rET}=_>zJE3C{yoaQQV%xwHHzm?ik~ZsaxarNM#dmy
zHFP_BP2Sg$3hcAJg0>)FfsvJYy>wUPYRrLNBrl*1om>`=uBgW{iDNFR_@^3gsm5*o
zbkB#73&-(Y7!rMQy!!4us9t{V72FZc!bso+buPXO1(q4Y79k;fB;wMWYay;QT{|vN
z@Y?R@#zI`a55wDy7y5q}1#$T<ESM>NgCGx{A9rUR@?a^h&4Z2Vxx@W8G9XczR5G$%
zgG587Q2G4a<zB6zcBq+TGO$=5G;7=eSuK-CCeC=N2?AKEsk@*29s)D-uM4aZiAV=M
zGu|u@b<6Z$0Sr3;F;fPgMNurC>Aw!H5p)a29DucRJkxm{RLy8f3vX?j`v%kk(|KK7
zvus+lv%?m+Y|<M-1_i=}>OE2@wg*aT_D4V6?BfFa^h?egHvPAX==@m5giy}wFiW-a
zIjUps6-Wb2S{ZqSxl5-d+uMC^HlzV2tt<d+?9RTw)xH9hm)C>#VEu8C<UOB#>?CAj
zOez@x!!7mo65C)?EP?O9aP#}dnNMCr4$S0?x$+w7{jqw}U!WHF4h%P`_2yT-19ABd
zY-}fK)xOBn=K#dzJ21Q)6<+an4yaw}X|}+i?JCKA&t$E**-K~&6-?@Yyq9n>70d_+
z4Q~t`1;T++Ia|Vkk;-dje)|#dyW^NdFtRFe+o<92xK|*m<h|Im2_{=DTJ}$Au=a6G
zCK$<D1y!Jhe*YRVg5xUjb2->cuOGiJ2b7i{2jE`1Q=T~!Aud0W!`W8-UpV|e2()pP
z_>lnbrH}7Cof{;EI3^>^SvIjT(>FQ~_qrAf<>f~L+Dn^>VN{<IOQF2{P@wNmDHcpD
z`u6W&&WN%-4eh&nA8f~<Hucf(XA;3ktwK!kFI}<s+WtBT0`r|$0E6S?L0cbfgrWkI
z2SyTujr6>?UYL*kfyn}MQGpsp?feAY?~h|VqUrSV9cc}#J@`hOa40R`d#fR%eYpK)
zbXy>fIpE9D0^FV-dwgve@&+dND*)`vWR%A%A1M13v<1HRf{8|>&iq~oYM1Z2#@?KK
z_pwWbOQF0gYfy{t8hJNz<G79J_cMuJq*k$o)?K&4j;l-2?`KlH0;pz4T-9*fY=|or
zV9V!l!@s%Nfq7niq-^-(m>e%5udacZDUGTCW=R~A*5&XMY0D47S8S7&BLO!rj!Eru
zp~Y*!=*g(bkA)8etd%(CfG-zYL|yZiL&<ka4hIyhI3~f%MHVlN3f^#Kohe0*d}!Po
z8vyk*j!E(I@QH9EK44h%rYbp{=RULxKXFWkmk#eYZF24BTlPNdnYP08QrfT~U0XDw
zMFA{2Pue!S&G|z^0Ix2N$@cQ(7UhZ1iV;0W|JZ&fxCRx+WPJJ2kv)#RJ+K>i?<vmy
zu%+A1=-8`2JyT6IR3Sfn32W+>7EO@JGdW=HZxFB0nI^yL@8eH^=XB$k<GvhZ{jO5q
z#Ab~fiOU(<GQWAM>2dI=R2-8N)-AbLYS$Ex91SUsMfU&jA^ZZfEO);UirxL|N4Iv<
zT`T%igD~T%OQ+CD?$f1o8xe|MD(@~dm6a4ebzNP&-mo|{T4u_p?>PL}@?q{0=^xl!
z>4jHOsEcA|fBHaLilR_a`Gp@QgHF0~vSJApW|)}#%isS4*A3&iL^2_Ay*^#K4i2rD
z$NqjGGqNErt1S2xS37{{TdrTFW%RHP{i!y@<(Fw+fSyol;9I-FlUs4h^TQ#F5b=!$
z9s8$-R#nzMPwj%LV(!|tj{sHOyglX_s4C_T!23d4mP$#vc#o8O;HG9=G&g9ts;Z}&
z7WgSs|J?X#F|p$G=Ua8z;Nq-^?=x`eAFKJ}E6`2&p@Wv*{ZN`lJZ*oIH&N}#oM+Z8
zImNRsU+kmM(W+|7Srj_tn%hE$v4gnP=Jp7bKe-e(M_ST_Pgt^^--eHfLk$2fi>+7R
zj;Zh}=c<jXj-kCIm&N7)o0mB!-^+Cw%FFEEIk0qis3(+C<zLSNftkU;1s0nW9r%YC
zh0x1Gam?p5yE(w-P0@CZ+7yQJGTq*V1&X+~@XH$znCa*)Fi^zK2Jd5FrepW*>zvQ_
z?W=3J$m0Hmpm#890Rb#n^^SWeB_FwR#_+taB3G6=wz#r5^i?3q;dUJ_*#K>Wxs*2Z
z=eKY9?@+X0TsoUT#J94RO}L+e`W9S18-C30QdqO`5S8h{?gR9?4IJvQuMCRk%$aBO
z@Sgkfd}+ghe@;jk2=yxiddSQdgw|!wJ$-W{6e78dw!VF<qt^nTPbi4)kjHWPYy>Nw
zR@bGSoU8vX)DnqhyKnV0Rh-c0(>Ub8v1||auvMwagNH7B5_a=sFbn0uqCsfv_Gk1P
zo(1VaIhYG&4lj2NR;6ZkJKt(g4v5Wb$1B)o!f0@6=@`_dU{c#uY>+jw9Ir49`Jd8T
zv1!Gv)l8*4xNzinaC0h7*^BX@>HJ5v4+_VN>g2cp<>ooJb1jY161eg8ZKnVJfQu=!
zM@YF-x^_(^Xmmeq%Kx?<fI5+O&BE^Axo=8WT_^u^e)1sH3D47AoruOjP$#5?Y#B)1
zUu0MrOVA{{x{HXjI=Xv5yJBL)@FepgV)FDt|GXJ|fK+YnNue#CZlvl>>$87=7LZAO
z3+e$aV26RzG9Vo@>2D5pY4?c$efcVN_@E_(<~8sG(9S3$9eUFCby?7kIi8ohUFcqY
z2Z=tI+b1;q@$~jiYrTp~HIR5-8SZ>RmwM+PjaQ<!HIokKVy1n&e8*>9A3@2B$%}Kk
z;lj<q)!6|bH0TYHd0y@zgY%6K7QGS=k)^kUiXRTL@Ngh=!R@V|fXG%4ce=?QaxivK
zt(+kPIry``T}AvjC3J*#aI+SFwc?v+yz>Cn*qHn{k`?ZK8;=@r8RGKNxPwdQUAiHc
z9$B!HcQomfm*?4pt3wuitJzJ|ZDBIw97s6^Eiiw}IKybRcUcis=`wk8$&>~GoxEY`
z#uLB@rZ^@|&Ve;#z29|Tb|@<^Z9AaUV9@q`t48jIRXKB@nga_c#6^zxFOK460?(0?
z_17~fNf$blQWNdan8VVNO;R$s?;ExAUiKta_;FHB@?Hu$m>;L9lo0oi&sfiMGbQ6I
z={a;j=$+ihne3&l)UT;Ue*`~2o=KCVpAQzQ*5J>61ZEY_oR}t1As6}anRP1x7l>!_
z<Q!PT1%5eu@+Op(m*yQ%ZN12@l3R`63t@S=-Gw!20Qs-{+!U&SSHe56$-2A7H+XFj
zl$9F=@ZH{Fy`Ep-Ie`+v<C*-pWI;nVR;&LbSMEbh=~|(3Ibj+<|GVpz`#~SzWpM}7
z9|Or@x5Sm2mqlcA`coZNro}WJ)+o-Cemx$I7KllSOQx3tfSa!QA+aF(;mpBk$$}sN
z64hr1c6CQf#AL$}s<G^i_de1DO3HOoIOV?RxjYvkD%VFL-}IelPZWcT#dT3pYl481
zc>2}%AS~BO1uP(i9(eJ~X%LoIb|=%JI54fB+MK@uRm=5LamB-oewp7siiXn1+b5nm
z^>#81<@VVYIqJ5~U!C{tRdrNZXNGW8r%P}6>)_gLS0kk|NpOywzy$t2kb6Fal`$oB
z@Do2DXtiQ|i?(R3n6u831z`__f!&#3S>dTwjs8pu9HIJ_ijwN9?^JF8CFMG-)8o|B
zU*<x|qaZ5RVGU{}$$ETr!oLue>#vYlSnB+_37{7i&t$zNdpmnL^lnPAa+kA-bVYx@
zC1X0RuGsNA!pnm<7UP*5w`6VLvD&Or%2@K@-iu=Hc?V6Z56kpm@!@0zkXG;C>Z=-p
zbC7r@&5h`7cpG=-vz;(BFd1$EV8b)6JoD6QD6foSAwz>JFKC|h{Nvq~$c&k6Hj-C+
zvyjv~XljuW-fl*<G$xbHMFnZ6bDe5sAuiLEg|u+zv3c-c6`>ZG&g|eCi&nIMM)dZ4
zJd>bCT7d7jExg}!GSmXok6m0d{njad9KGTl&*Y&w^1?w#m-}xBPViLSSB7<)`x+^D
z->NawkwY*EXr8R55?&qEV*pCROwL&V*w}<*Pnw<&Ss0UOMzCPJH0+O(=nhFdlUnAY
zf=c9{&I48>3yYR3W(zm)E@-9-)!<evn(x10gZI(kfkmOTeD4*g{w*Fwv9dQxpgS+|
z%r`Av?Sd%w?3r8lp}c(mg?CJ+HCzg#E|UjF^1`R`vi-fMr`M`g-B&JJDEAc+!SLRf
zE}cY=FU2!CU?i#7@)`lR#XG|uL%z!-fCXR;-@RO?avQW>O!^nW!uR4fwN3aH;>xnd
z=4IlxscE-w7fJdY#hMtt_kw$&&opdb4N5D`z$Pu+rBCbn-x4S--+RGpbUj+OoeHI8
z?t8_W!QFqk=<*X$-ihJ+uDHDkc4<Q^R*Z+h%q|rPY;*vqcFx{m#!PRcrh2bbZ%FTT
z61rAB-+ga*4kRm+_eBmtvYN?v?qi#~L15+%SOAND1=y`t9&-9DiVRHp7fCFDjeryL
z=_y2~if6uf8Gr=|cw_YIwV)#SE-d5)W)_)s$R?-=z86zRNZ$%}dGGW-D6h0KTW}y)
z(;~LrUyTOK#xn_Eq+$4?-rx16Z$?pv$pCY44SSgJ<xDgHHlE4-a#6KaBOh+t@2`W%
zhh;Fc_^?3Me0bNvY2{FWWKzFeQN=%XOPH18xtEZEDfh)~mY{d>s1`fD{l&kLfiW3h
zj<~SzIzRPlbto@C2@81*hj_4bc0^>2XA->v@&f&~SzkC3t{dNhVLxx{vpJtd4iU%q
zU~sXw<oJ?{p|sL+ZPp-AO)FcPW57&^%TL3w|Mu$grKJJiC|)6E*yI)TYoq%{J{(b?
z!#l`_rNlNLHp=MV>V8qqYm2FE7Uk5~BCYPd;jMRMM=d=jm5Wv?tbc09l+^yMl2g08
zuNDR9QCj@Tcf0aa$nTgF&P1x94xABzU;ce_esGsAp2_M8z^472Me`aHilI2f<a7n_
zLB=mKVfM37A56b?^<l)JUw-a!0?NyDYZn$Y4y%4#?GlO?@l4Maz$MJExv6Ry#5RhL
zmtGRmqFq$8j97Uy*LD;ym}Aap*^I^^IrZm_vi*s+#<FM+<<z1_V&vtFEjz*13zNs?
zN($_2%$W$-Dq@Z~3*efXZPKtKY`!ob&UA6bKlMoTe1od*Ab((zxg1<D?7i@RLklBA
z;Ig-bA;9TrF~@47v8eG}`j&&MRen_Wv@P&(8{}pQeE$U<vrDxL!p=08z~x8_7VW8n
z9}R`t<-0GO$~Jphc}U{nvbco2dcTOgH`jsZg0~wL8kgUBDc+<(<MLZAA->hF=Q0ov
z6z2^c4@3gh^5oFxkCX=iJb}yLa(_A~q3#}C@FWCg?zIEJejSj>W<L{i6&OJRm&PT4
zA@O9^p<;)CD<m+-ol!&p)RXz^-&_SznLBL<)kwRyJGE{Ab->T&qP1u0c5ktczd>pF
z;Q+Mu2K2A~Hk6j1%i+kkBkhh%gwpcE0ch>Lf2nT~D6RBcTa93}_Q-etdFJll$akeb
zSbW#0&s+VJf(RW6Twa&3Ezu`4YTQ*_V)r7?<?^~*SWqL}9~CnQ0y9sUU0`6g7q1_h
z0D+mCYynK|A#)%2#;%d5Es($*c1AHl0E6<jZKuV#k&!VUz9e8saT@jc@L5n3d<Pco
z2GHR=(fN_rATZyDi9TeixOsem^`H<-U_Nr`XaY1y#tzOC1Lfs=G4);iA(Gtqz)Ksl
zd%#M+Td7Awxv^7zh&*8?;@KI?euylBOZpNP0UIyBWto``1xe=YGtw`hQY9>@^$C=g
z@5+!&wW&hE*B~z6lOdhzhoMz^KrQgoFlawrjwuiWrRAq#*naA_eZv{hCQ4wAJ)<>4
zZ6d0k@{g*U1zhk-;4;7jbf3PdX~Os1J?~M_GD={MJ=6S+1l~6O!;IiAZUUDDCOp_-
zSq5%^E9EbF^P2si4@5~>np<dZ7F#L>k>q{qvsZsDCm3+_r!>tHxYRF_w{zb<sU4I1
z^cTIZl;l1ymlhWc%ZRaI$zo=h(>l^VnX~$-)qvHPz$JyzCj*OWJ_x%orE9;E;<wPB
z@At4h-33?LcIvH0?Wf%T>uwK}4Y+(U@#-oiFMYRvwd=AO;NC+5moO$^&CAw{UYWEJ
z%F6V90ZRE$mo@6$j4wb~W(p@*v7$Qc;^*?thbmwuZ~<#xluz9CZA~aEvjQhjpn`>a
z$In7O&t-}cEEzQ&h5IWG^7+YIBS#{im#HAM&zrgXr$<^XM{3}*#RBr`OSbRo-)Q<}
z0+TD&D>&85FotqnhkxP~F{)ED>0%BtoRRcFWWsg`ECXt&%~P+gebTt8ee>y@zd&HQ
zYF1!)Py5}G|LlOkJTE4R-SZfI^;*QQe+U%^%wb~$3|0L8?p>?ERr>@cZHzE!Q(_z<
zQSy5C-lq$}jpPL86PO-0*zlCDQ}H{`>3kN)tH&KpD7k|C__O3}&v=k(B`y~(lpi~k
zDFu;!e!=jBO{hv_^2SI=@b>wXMG3QzAuwrU4yuSb#vA2fjn@r<xV+5l;)?l{y5Y9T
zKKc`=1*Q*^7R(pbb4}QmglbwQYb;PRbn2K=+=yl`Eu8!ygqD^NGB&6~7Bq`!(7DtL
zU^r(&3@;hGQU|Iy@(M%tX?GI#fCI&Z7+zZL-LaoHxG^v#Li+(v3>x?>iWW>lnS%e6
zA$!fd7k8mF9mDf!1zWG#$i2V#zU^4>Fo1G05!$_zHBBUZzoRRXmdPqpq@_^~uG7eA
zExX@4a+T0&E!FsDpDgA~YuVqh{FimhmrY!8GATo|dGp$4Xi`7(1MWNr3QUVTKRf|h
z36o!@$c{(EPVZ9SYp5HZ%d7ZetD*;#<9{^x5$!pd1IH9}XNH0fU-RhsjmX5AuV^ap
zW`X<C^#&QBVtD?qVuPA|NuyHFqm3JreWswJDWp#ii$bA`NkJoU_vUX@WO=6%rt7`)
z-v13lVVB89qYqFHDj(*LEadxFhxF`>Qo9U_7T-6v<v-nf<_J<XlaD5a)k77z=b+Y0
z#~@8GNof+?++?o#z2<7<J4|AlgvLec>%;5kg=*nDzPpBKCtG&K=l38uuV$CBqy22u
z#G|JmI4|id;2>f>^l`p^Q0siRch%w!MAAK{^2jHrLVJ<+9jaiFvU>qb=AoTON}MCL
zP|#BIP@Hu~9?V1gzbIefSW<@RW*RDeeDMtwX_@pjDYq7`$mM?+e)f0d@>1?lF7HtP
zwS@oJ<OhF4yK*Ldt#`-4u$MIMZ1*{+k;3G#5v=Lv!*UElBN`HzbTtA+9$4##j1Qp&
zW75?Eup<0}Ce2r8?|lQ+%k^#{GRTS5I_F;pMdtdo16$rX!_xh3|Gi^#;nH#4dNAmL
zt=d#<57YzKnFT0NZ^eBngP<OyLxheI4lK^xnUX&$4MpY_?gCp|I&$Gpi~RXHs@NrJ
zXctb_9C&r!9KRwl6}n4E6^NNdC|h?)&Grhi0wz_BMj@FFT=Qo4r%~rbITy6a8i9@W
z-3D3LphU-HsyX784-?=hKpdSuEC#BW>BKY^3K(zaXaD>f!ZMvWFl|cr-!jeCj)E)4
z^j`t%WlXuZ8no(EPSi$WlGRAR$wI%zuBXUT;k%&@m<~+1K(!A(*JUP(3rwz>BQ90+
zx@V9BA0IOMYwz?<64sRN7x^!lF(#}ftLsI0=l*Ft(d4AZDBQA;0m13sYcb(}*O!(t
zwJIPhRY)D2+M@YG88X}aOb=aD!C!e{U{SLo6R?t<6AD(ecIc4N9Wts(T;|8S510*R
z0nKaE1)yoUG~n%%j)3qefO)lh0N9}aR6jp(E0mWP5(2Q=P)gEqmIHfBL111`2mn*f
zpebV0^X;F2i^mHK9xy%5q(cv{U-mC3GcUP&&|-_B$=vXrD{Y|6yyy@BhBI87AKUX5
zlv(CshAmU<QDi1}UbFDKZ;(4nAF;W!u`Q3kI0(GY7*mN!VGF21{7aRUjP1oruY(J^
z0$2*mP=eT}C^{hANeP#pLhHsHPeuZZ!xtDRwkO7Z0HOK*Owi6LmnL<?9luvZCc)&f
z1*8TssD0ft3sE>`^4J2vMhv=qHgP?am+#SZ#3lN)nj*%JKG_87nD5VNot<6mG^RR~
zneWj8nyM*H=8nG~&k2F~{!GCBxJmvz`M2`NkUz`BWbtPaBQ#lC#SOTJ?19N*3)q9N
zkRY$Cbn_U@NlX%(2W#rK?Viquk#3p8%L2gSU;3h5*!y=yv#N}##GGFi05;=Kw($EO
zA_HbV<Qc$)v+Uz8jm>RtVT8#1{4DGYJ)4;I?2V71(0q4Ji_iAp)lDbNPMr{%@6aZn
zjp}Q62!DgAan8d8v;mXtGy!jQYPX$s@X)d5O*XVBo$-~NF`KkQok!Z$`rbTS5ZFw=
z?%SuUclHPRX~}=aS47S&lSwG&b|aDI+}odM+ul5dimAk;w)Ig2hR>NzeB!A(=1y1O
zGjlfKyKPrZ9~445A1L(<G8E?1osRG>IF!9dv&ip}zcYzzWP|R}oTl?_xt6vxx4c3p
z%xYZVnn7gpt(>J$lx9B9Nx~vGe}8;fH>d-ioA>QWdngb~ufKP>H4043L1zM&%o&yU
zi>LN^23nley`71m0=YVEr0IoTGq>Cx98n$lH<QJtfRo*+35JsQ??0Ak?d{bi`z5B5
zv<r)WCu^4W%FCY(K|z{HVspfe5SjoL%#@<JS|HzJ64@MRQOwbkxeftDll;JwXU;=-
zS;&N{^&NP}JZK&LWfDb>gJGA3KzJES?eOB^G@%-4gEGaGDD`%2vO)TUnqut3(A*Sr
zwB?#s`|BR6*KAFuW(IL!N1oNyk%2QOqB*J&rcJV&ifMWB&kvzu*#0g!&4N&##<I3r
zm31FVH%y|NBRhEx;iFB_d*95h4|S6c=NBKT3|}3(|NMg8P<UQ)cZ8=HOPZHf<902{
z{i|PSGYF-3S*zLH->BWYC#`xIg>R+*XR-5+eY${bv*+0Q87O=+`ENoMgo_eRlZ4_w
zLS(k%_f0X?OFlpK)RGs`z95F}^8y)({LrSZXCSbQ+ZH8@x4jYYM>DTh^A2CsFv5I0
z(<~B3#61nh2*y-mQr`q1ekw7;zx(o-uj2|_Ud2whRDksEnA*8}*WeWi5Vx}~{dGzS
z5mf2VrxC7yr*&}w<)FGR<ZFhqCzA{3Y{;nm(fX$3>f=5gd)+)4kEtZ1Y$#WEt_f-h
z^PMS;>Y~WUq{0P-h3&@;ZSUST4=9AVyed8jj-KFY-0hKUNXtwfTo4-+nTy(1cnL!D
zJl=&CbtY&!O)fTchxrtk&<M}xgU}+01)haei$Mxk|6cue09;U+4njqh;1}S69=rPR
zR=A+j09oK@LCZb&AZ({H8E`?tg9|F_s_!blw1F0s^rE`Io&V<4RizspshHTpd_RxW
zz3t`lNofDXWWG64YiG#h=-UqW`v*C?42+>2-E7BQuQ9tl5|qh$a|JbzOs{=b>KMwq
zOukzH79E=2?EXVPudGoQjY)TNkag#n*kfrlDpQ&7ZMv9ZT&Hk9=Mh;am`Xc4cqID=
zRO!*<^*)iU-YxCyRP!~>N>?az;86YX*Yq~gTc-<6M}a9W9lo7LD&CfJ7)-^?p=<%o
zP&N+USakNqMnC`7j7o>0!AR2%8AAG|1YUwQPT6AzzHuJ~Cp+KGku*Tf$FD<n>+tDv
zh|R0vJ#1(1p&BLm`iW&1KSsVTYZHsF8%JrU=Ct02bj+l?1*Fw!0Tk}?fAZ!NXk)-+
zyakX=hQzWiLpnl<dF6WmSF-UXrz5g*<1uLEn7lU+IVGjz5X0iOt%{C<Qd|99wK%Ht
zRGT0@7v8tzCPZd>df>9K*r@BsE$>df1ogp8;Q?f4BdTL(_<rTLP->=c%PY=0^5jv4
z+d-+NlZ1>KE;6RzzJ8-dClpng6Wan7V%$d{*Pc7|*+yOtQ#*4qYJ_xc=crCA*!Sj5
ztcp??lL;4)HrX5DtSh?pw75r*gEJX%9=u_8hX&ku0GS4p6zAargWi7l9$Y>qDK3EQ
z^i_3bJXJZzN+@)?{F@3=9r@`4<HOM2pE<-WAhg&3>%bMJZoh{dMY$`*a1=M4>)5Zo
z^7%y6#b(muQu{vFv47XtXzvkY&9KM+6kh~N&U5j=BdR!kfAwds1`u01VkoV6*f4#!
zJ@#x5&&L&}oZRA)ixYYpOgZngfaJ^OJlR`+Z;5}&ILP#rsG$&H(uf)-8b(DWty$k9
zL((hRvkqOVUmcqm`AZa7zX&E_E}#WE<e*tux^*N@?TL<NBAC26iEbbln>p|)5R)R9
zw7CGXS#-Sm(cLb<Dk7Myxd1M{O;a}aW3PkI5uqH)Ff0xcYF|G;ttUk0l?DN+5#Rpj
z9+fjfeeg;H4;hvQi|#IZ4ob}{4LodcLFfL~hJzq-y5a^M+UXYEtoPn|5IJ2@L+6-M
zT~KY&xT4_1PGO{_;o;$8-RSMXWG#56ymCAfs9_?Mn87eNm;|>JPe4U(gd!{h8YRJ}
zZe<5=8pK2}33LIQ07>whS%qGJ+Tb<t0>DmdUAKt>=U&W?Y=TLj6Lo0sG{#!gI@q@@
zL}vQ6gKT6d+DyFv&X!lf0aQc;)2{_`la#LAk_V@ex$}3PcKb<@tLRT@dqhMqeOu!D
zG_R}v)neBlhd+bq=;AZY26S_N2Am!6PlF%oqwvRk6O_yavJ1%JH~i2iXf|p}m)qM=
z4)08Jqo=GzEYTeQl?#7_BdcMu>^z}^O;fpXp7wldn0aY9CW1+{bC9dMr}X0F5)ei^
zCUxHob}|u6!d>74V)u;UuU8$B0Oe-}0b0)Lbk;54l?f?snMQ8)_Ri%+sGOqTpqjm%
zf9H1l%9L%`Voj^M2amQ|lWBV3xL%@f{`2nlgiIFiL$`(l1HEa6SEBV+V(0n4mUv7+
z)1MEX8xtJuI2&rAA9$#q`0O``ixI)(;|10?aBMH4yk_}#>oh8b!hxNS=QLje@WSwg
z{7&N2@H3qnb_G?-OirE;-!DA{gmuS%Moqs6X`G=0f~X7~d8NUOEpcfj{TIosuBe@o
zry5L#W-YV7ZW!a?YM+j#gi826Y`M!xqXv-Jbr01~$`D}~VvTcO7kFC0(w`4nhQ>6Y
zgUeVZtZSbx?lTbD9#d1%ySv_ZxWg1MeczH=Pvcwe&&ZfJvEIa5iQa8!sr$c9P5;f?
zvH5_lje;O>@|`;XxWL05-lS6-+Wz=}nNc8PUa=1}<?YftWiL?)-Pt~mXXuvPt84p+
zn20E=_j~fbZi06Iw}x|-)R5I$26&(o%ak!;KbYEW7u2ma?FV6N)tWfl1RfceYbeyM
zwY>L$%gpWS!Ad&L`A-I-qdTQQw0L$P$4l!P@Ma$8j8RvtosQ=Tn!LBRC#Zz|rrkSR
z(C@cX@q)13N}8}c8ZTXn*2_LnE(kj@Vb5|C`14`2W<z<|-Ya~}gk7Dx_Z`wK$*j5<
zlXO=)W8T6O6Ov8bGKmNGBOkN#?L0lqH9;3wsl6ELfbF<*ktyW7a=0OcWxMWNWD0M^
z9>c0-yKchVJta&n{P14nB`7Z2bBD}L@L;9qRw{8m$>U9_MY@c&p*`2#luHNOS*Nx0
z1}%xIT9%zf=UKp=Z#*d_>ZZzXZA1QL=g@hmd%n0+3;0*n6ZzjGQFTYKKRy}&ex%k1
zL0Gwuc=p)Fk!Ul{<j)Q0*RN|z8e8VP`$mH|v|=KdgX99xaL@eq@fCNV)Y2HzC>5Nt
zWSG;3cD6ku^uo2p_2dSmV?)nYAND~<7{HCnw)+fFe<GN4I!|V&s1JZkvum|G*Y8Dz
z)cPjhK0VH{j%6(q#YSgc(@I}Pol0twm{>m3x-rE!8YJc8e_ebNs@>|@0o~AIRwnA4
zPdij`U)uQ^;?5~e5Q}#kEZN0ni)})}GP!fZoL!T{GxrHgd&|aMzsm!mtp&GF4`O#?
zK=0^U<SeohJ8@2NMe#Hd-18k;GO{D!w?){WDOJFoX}!+x0Bwm9zpp;`l(0kkQ-i9V
zLFfBIkfjo00(HY7G3BAAtT8}|ETk#K5{+H6XgJz{$6BL+3+~=h@a~+z#rXS$%!eqT
z>-opds0(~TkPM&en4-t8$De%kFNzEF=UV}5R+q5N+yi-|<zB8z-x5@e>7}lnP8Y;>
zh*_%4<opvqEbt!S*eD%Ji}M?ex3CO@Ya!#X^XU{x(^A8QCx^a?RBUI}x!_I+PorD=
zNwYDJqrRA(SEphtC(x>{DR!N^-Ekrm-dd--9|$$yb@O+V5>Qjd{@AID?OdjC{84m$
zl6A=!410YDTvMjQ2b6-(pbz(6UlD>c9o_?n<;sW!xeB0s5oaynUA+Xr5#_7<>py{a
zC}Se*v^pQOdHgyzuI7VKA=X^)12)fJ$>B>*S$f(lvea5$#;7zMKDkd9<ua|-6)gCE
zhl@zjc50nZXvFz?;)xLlAhb2-`=HU8@!G?;N<nCAlg$qe=r_wQ-+359Grc`vdBUoV
zWDu5;?`vcr_7_lnQe)Ov%gKv2qbL=hK3_LzUlajLyxShl*ocTvpR1c3i~Xz1Jp+}U
zJ~u~)-Cag4J`JIz$E300@hMwB?Iv~fUH24Lb^09LIGrXxuehh&1D@EbpG#<tpHs75
zPX?1KwIAgnt7VRzXy;Q1m9RQ=rbXF?phG)5$<7B2PQJ&D-7plnjGboZLst1;<RtC{
zgggrtKS9Y?KQpp3?aGCht{Z+lKx<EOTGGbWZ+EMoE+B`rznAJ0-C0Uq;dy=^3y&J@
zbUPPYJ66!)hyR=P0Mt6u-vh_qZV|78e?PAJWN3#>pAUee)c(?vqTpf9n1}?X&j+B*
z)L#0-zrKeGk!~3>m;``vYXA17e60cDPNp*Qc!E!ZaOc0hOhM$(sgWsORjC9K<qSPk
z5UJOvOV`0^R}5pbG;R*oFVfDs^K37%S>r}<wqk`-yHNuo(oVVaLxZ&5;N^(%U<D)X
zoI5`>B!k8Md2kw33A1Jhm<OsE@{Id1uUGdeQ9IJkyYtCyrruVc6h<StA}cZLg@DW`
z_5SnnjJi-A=?fny^)7ih*BKC0BP*pZco?ad(t7^Vy-_I~St)(d10~2T?~SVn5@ckh
z^u-S?L6WQQn3-#x#~M&wUDnuaS4Ty|L%;1Gjr48j;rYxDCb6wwJ^VE?6FU(vfbB5E
z6zY@A?8lb9Q<k(stvl6g>`c5sW*7I>PEl94>2dgI#nm0pptf$LLU#zA4;<0)&UaM)
z#h{%Lshqc3p*?n+q8oXB5uRM^7W@F$@g=<tC;03q`Xs{-aNXZVY<qD}o9gfb+#sNQ
z0Ioq|?d<P^u5YCM;a1Nw9X65ImjPpAHXj`N0sI0tAh>KUX91}5<B{&=;a}DQMUuUQ
zrv?UpSwX=;D=WggiH3n&15lVO55`_R^u?cjk>@G}Mra!y(ywb8M_{eb?@55rGN3V_
z;i@KA&$bSwQae8{u&N|ADm$aMzBw55r6cVF@f2XQ=*)kpbbctWm4u_fqAP@%vUaTv
zfw>WY6oEQE4{aaZ8v=7ZpMX)n=Yzi2M?+w)$2-8FEKII-Efty@H|IORuqfP;cyBqB
znd{;XwAMzVlt1Ky3pbEw%VINB%5M;SIuUvHhR?ekLHe+h?i8ED4XTMRe!m#iK=u)M
z3N&m_4Vf1=5c!{d{+)tsR>=L%eeeoeK>OS~6&4uXn$GR8Ceq{Bu!LPS<HfI`$m#KH
zRKVt~w6hnqi}ZN5+J%wz$YZa+a~Il0dVE_cFl7}ueN~U8giQZOtpcO0&K;-%v&{7I
zBc;rVbMl~rl}P*iyMY~h4d~jxw8u>l!OnM}P5!;G+U8*%k6g{%(mJ^QjVk)_Q{Q{t
zLsykzC*NtJtF#KKnW&qGyL!RN2XD>a8ob#3`7}d2wCG2=ltWf%r{V>{sWPY>W^zqB
zM28=Pa?7ZiM%|%7>r@Sr`-iUk8$zASCFOxThvWgZNIM@MR_GY@FvB!EXE5{XA1c!@
z{Io}A$uOgG_9g>I4qREXkT%e@WZmp72;TUF)&Dj1xFw}i8KY&0eY6s~t{rI~jOTe&
zF;_?0G1t#Oraq5Sg#Go`ATBx62#tXKX15|$NF^G1BQn~W<3DamyUTS=Gc>E5JyGyD
zYqV?Et<lP@?fTVA>ejBZs(uOymCh{L>und*kRZdlEhNCEo;0EVmQ+7UQ(iPSRHU8S
zXa0~^Qbs2ASlKRML-HFLt8Dn3l%+A_Bke>#^BeV&l6wekE!|pl+R-eIt;+8delztH
zB|(Z5Y6!CP{^WNy4i(&O_r9?N-uS`04vC54gb&ynBYeQb-qxY(q^@;_bsI8UBZLYq
zXwf=w*}P#3pfaTCq!D_2z}-sfz*S1szJZdfeTJS2Ong`!dDfrHs}Ns?(0yvQ76dBt
zoo{s9DOsY!pv2a4K*7B=w9&*`I&$XkUcOFdqFq&qv`@(MA^%cq`SO4^<UYRYtk33=
zXVRbQ`ZDmQ%k^bRAnp2>4ui*%;puj5=l%J_C)&8Kna65%nuFHTJ~7V+Jy*xAH2L2X
zC|=n~e;#fV;%^=w)1)O$7J%-a``P1FXquxQuk74E^Bb>k9J-@Kt+_*fxi!=@%-bi*
zl%T*{T>Pm9Z>Ip7A98GH<508~1^0auM~SMO{uy>CkUG2bO^uQ@iyuDp{^@o{%dDM{
zLkq!U=Dby#DiR{t`hJnLT1(VXKech_m=6l*7SMV38%Ll8u%m?hL<vFk-WXgMS<J54
z+U9RmZ`$YVc~yhcpc_#kX~1B;AjzF8%sZm<X~<eRXwc0Z=AnX4^}^lnKHlbaNY$Vr
zb;Ao9X*B?I9Q)xqQjDD}s7Wu{Q;O(RE6>_KW+p1c?NmV>nnqk{;G1^lbp|KuY1Yma
z)WAiRuR*scSMoQg5^HgwL5nS+2EF9N6-&^r-cAzKpp!M=KJ8Ba0A;pD1RdC*lV<2W
z><nB+YXs1sou+{%_o2V{^`rDff2#A?*@1rW>cBCd?E2pfz+;ZI(*pr^^$JM*)VoO!
zq3xjkty%pO(D{EUv}=X;3smQqWlnmWUlt59F76rsMir!gJ84k=0j3{an)eWR*EJ^6
zK9Nty7F&JIZbps#<{2orJQPVIE$P_ez(vE(_gLMY5IddzU%i4k6yc+>R|dFOTmANK
zCk}dYhl_Iyck?P&v3*?3T90?4dXb$m7(|WGF$?^=s4$8scBY_$S-pZol+hHNwb-j&
zp%P?Lvn*aXb=x%5iCK@Hf&xo#v7idghLxqc3OaO~`M<70VcR~3&(j4#mlMq@MP|zG
z8~=)a)YF9O;Iec`+rd-%d*enGP|CY4pX&K8QiPozs7f17N0F+$1bupS{0s<f?Fnko
zrjA#{Pe-%KBklY^6<Un{GNIdl{O0q>q3!HI6<UnV7X5TxBfC%KS%$Ksog1iPR}-cY
z%wQy{OKbe%j|Rsmz39caogC<GC!9-dqu1?dzOvoOShp7?;rHE~|14FmPiV>4K9SD{
zUt>+ro5!cT@u{|Rc&7QFCRDi^=vFWHp^sjdtLN35k@@-`cRwJbUg^|Id1$kxce?Bx
zK}GfD-P>Y;K`JAvSLoZ*aVM#z;^$A)qv`x*buCFJO(U-Oeh2MQ9$Xjo#v7x1O&HuM
zF>&SAh0QwU)!T!A44Saf3kb@{KACwa9?<8sqyA#0Bj_OmWg3jDCkis{O4L6MZWt*C
zfoTSrUVS^JmJT;2CEv`FcLj)tQFh{>qWKYYgG&otONx%j4S~}WU!*5VTlps6gzg{&
zMA=D$K8cMgje=s~ls)L}+$j67J|DKZf%>>(-1ATy)>fhq*sRPRY_RTeuM?%z3sH8)
zpbi{J@D<Dot<HoDk3-?v+XgChDwunyvR9|0OUhAp;-F7>k>)kyn>2hq8u}JxXASy+
zjbe4~w0XHe){L@q27SQJF`Xha`SyWq4aa$vpHe_5C-I?uTj*G4b?1G%b4|2xcA}t9
zTC=XMlrb_E+@OrIvjly>fdDOi`@=_@Tt(`&Qv`juXn)sl!;em*S!-ZN+1Y_Av>eDU
zh2Gg|@P1G?MA^xKeq<Pt=I@G_Kq4Drv%3N0d&0Mkp3aHo@o3t0lyX-+jb!K-8*K|J
ze7Wl=l-gP___57+w=?0!G>Dv@t%1;o8H{otu7fBKQTEAvewqF8lRSI<fE6E-xzL~L
z*>Zy$+Ov(MJ$!xD4PGZv4f=MfpI=lb42iw1v2X61yMHY5L;F}h{|AT}q=Y$2vD-J?
zS%5-^o$%*}*4t*Y%FNl148zX%({KaIkX2*RDj8oT|EBWYr)_KQR;tF88^1aj9h>P9
zw_`4Y$DIaQ--cqR)4$FBM9ycLw@1N0lAX09#1<Ot9Ano$*$5olN7+a2d75^B_3hWE
zm7cl-<z;(zgxHq@d7I66?@<VBt@@?B;q=U;Dlz%>j1^guJugxH+F#<6Z)+ufcsHjS
z7mze>6D01_Va*mHk(EN<5}PB!DiW|NGI?K_EZM(-!0f6#f?lTa>w<vGudCJ=xwW0{
zCzV{Ks@GPL&e!ynK1adEHp<TT3p(G)q|xg>7rW-AYXf^UiJqlG!akyKXuI+#`)jv8
z^n8;i<trz)wqWaAv|Fi2>icRt+bH|fx4thN&)0uavz|Ad54lq|<&XGh^3}t1gjimS
zPxd)`{!dJ9+N}QQEgS9)56fNtg`TVDBzN1Xvp9B?oADdemo=~ZJ{5VmL658IkCE}P
z)sJl^gHAw{ogNspqhKGvt$dWSO6si6m3e3AGbMGMS!06oL)<<<zGh7?T#4@d-iyPw
zHmIO5v?xM!`?&aQRMX4M5jyh=M{{d>DfyN1E345GkWs1G$W9eBBp=;nWxK>~h4o%i
zV%Z+&;1{eh!uSF$^v%%^sI3tS7GWdHJ%TcboiZ3)WYlsP)V0nU2rC1!Eo!2ML*)Ei
zzn~OtpWUZOt5~5l_CpWd{|pMuPX40TXjb+ki{!coVfmSVL<O_-zW>(8*CDLc`4v5w
zd-aC@%M^=J5}ySql%Q{@$;y(Zm3s-LBs&jKkyoo=$*F%T^~zG@)N;`*PVK)NOrj<x
zCN2Q4u1DFKeu}7iMVxtO>2JLTq#7yg)IJ5&*rGRC_QPqURXdSSqM}{&mh*8VA#OUH
z7j1L@tM%e$v^%$t?^ER!PKNeLYZITo3J4=n_D674aN%mzD-f$g+bVru;u?D2KFZGK
zQ_)2Z(Qv2M=nT6z_7Q$QT%+qYWzY|UpuzDgc(F6r&3Hr1^lH#Btf^X+*1yLkH~uVp
z<~<aO=})cRWsnT*#>QZ$&vNcrh2o=~v8M`Z99p#ha>+@uF>OYB6rZg(A?u0C*`0Zu
zYd7kQt#bE1eSnTc%7{NTNbos(bsN+>CMxXN$FE(V-Q(ui`jaBBANLh^vUZs{wOvR0
z8Pu@$ea!0PUS$#Zm~)PFxPg97_5O)G#ZY<5=j;XWn?)WJ1u7`#@BTcn6-5*3zW9ED
z4E|}97}_s5aqW6fy^xRmui6t(d})$A@cxmL>-V@hKi_0sK_71Ty%6nnH1=eaeOR9+
z{^Xh0CpQ&mg@+nkc{Whq$z|?;w84GA0*taV^n71&%WFFCTsl`!bDGr8{D3T-npI0~
z8zz1U{rMJx9Th}K5AGC*C}7fpC`x=%C8ZEb_Oj-&L<z5gm!dycq|73;#o_bxRMDy7
zQN4mzrch1M<ke^X@rDqn8sc;I)X((oskai&Wq<uYkJ04Amu<~7tkny5D!$XQ*FW*q
zbHANMWs&_QUF8!x=-NRaw?g$MpSUOFM*D;hm%Z$~jX;jzQ;0P-sL}>r+}2Wd!fSQV
zwc{xJ%eg*mv-+M}plb!F4Qb%^RTO7?#z|SRCXb=#k)rsNJx9%`u+Q|@MtB~{r|LP-
zW=RmYrr6WS*=7A=adxw^AC&QxerWT^XXQDvg6i=3V;M%F!j{j;BjoDX-pV!qDkl^>
zJ<ct_#V0gNo?E9xeTZzW0aQz_4)&*G|Mx9=!7qwW$a58<7od&KUU(czoG!mc6vBiZ
z;m0Xj=n;cY%yT71=bgP*z1{<b=Xkzj_Zi|1oN})3mC+;VOGol80F>FNc<C>;*daa<
zq_ey5vW&?4_0{17uXnoaRJ~vsQNC>A3eo<(ChC+P>f=O|*&j+Q)ZHuB)%sr+5NSF4
z%UuI>J$g~zF>fh!>vCh?qx&i4wIpC??3qGS&-db%L!z<x`SI*-Yf*lvS^Ym(5Fd*^
zre+)act8B1o;NeqFQ?awr8{@pK$TpW{t;^!Fg`-GuO2re-!RB!Q)_=!fvR4;LvE+^
zncq;`jZ#(ruHAVK(AT2u#6IH-lbpI&FWlGk$s2{rYCgHIu4}1I$$L#4R%|W$!Yuv%
zPWQ*3xkpOUZX`wVIezL_{%YDZf3M!pHV@Y;>kfT3_6rxEp+BEt@dF24@(9+}o%;^x
zlN#`HhqsPemhFG(_?YL6zK`-l34K(LP&=>XMoiSG1nK0q2<5<P{5A?7r5ltv=4Azi
z-skV^6S#KvNA$iveN)q<_+^awG`pt>B`hiJeMVR^dK0sM>HMd6RH^7Unosj{XdbBS
zE&Fl1%b*7qZJ!SqOz5tTVT-)NxU>I2!L1QULpLjtexr(_i#E}GvR^<aW`}L*?BO*4
zK_l8eAW)N<_H}}+VpP`!_KZCO%JyhJ?Jpp^UhLG*eg)l_imqhsL1>bjgoFvXKYW{l
zGX42%FnxhVRFx*%^mNZLgCKS~;|HoMCnbJ22pV`ggGhDbl!D?&=C`YD_f}H%cX`;x
z@prS!a5rw{IIum4=5zmC3xU0bUNcUiyI#?J{+|c#--J=$BIE6vVQ4A&9Kay9(V=cV
z`r_{>n(#@09=35Va%Ia`caW9vS%BggAgox`FlWcB*TO$dKE97~zm}AvBdmLnU<va@
z`4gf|yCeVnId3g$|M8r5v*x{MobNx`_CgQ(Oj*rE?VLd4Gt<Opa$hQZ`pj<`yXy7Q
zgVpA(0%c{i@=`_`X<7Ts3F0h>PAw=at4!IN2)|*C2--IU&)-j0Amel|b#xy+=>lkU
zM%yWazHd;~H-3%akEDpct$H<r;=`-?drv{}LFPYBeDE3*Qug{4M=hmgj?k9c&LK2p
ze{h|%4i~EI5?ht;FWp<xT-mY6zGs~wFAk$ZpZ?VN&nFcM4+)l)$s!Nv$t&MSm%gPs
zT%+?u^SOoU7ieQDI$K5%X*9FlY}$Egw_&3BOhff6qOpov1F_E@_!Dg3qwVkhdU;s=
z2<)zQ>9p%V&|Qs=w8j+W6MDtnfA8lbJahFeGP`~da-$u>j#H79AuzjoaDc@>w1!l8
zl`LH$ur*MqY5;`dY!jZV2O99v_P2d?V0<(Y{`_b8$h+uItsG<{Ev?8vRVBC!^lHYa
ztlpMJT{}MO&`~isix^hETUDfE<#IzB0pF(zvsfrt?=~848O^61IwG6JYLVHEwxLSF
z&O7u;j5>4QzI3h=RI}VWGL(TT)sf9xj|2_5Xgk?Z71}{Y4EcX+v~C3jPnU0_?acA9
zy}Lqfr^~rvsrtX6H){g=Ks29FNETw|njAYGje*Kw?+OCAzWhQNzwFoJ8h}fF3f(NE
zUjsUE=eNJAjMS?%6<8JrP9YxHb+<e6Z2SAZev>om>C)}uUPAiia|Fe<oaoiQo7%L&
zSlldWJk*8^oEB{mvT~_f7FDw@&zK0hztPItr2!o*s-j|#i!#0bq{L<y=g&X%{frlf
zRsC>xag|s~zoGrlt%jlogMGT7r*`ohWG&_Kx#cgZo4rW~`Xw4KBs$va>%L#&p5b3#
zf3d;hek<G6?$oG=-fkSS@UKPG(bT${(fr|p>MwB%9doBmI{WUQuvVzv;S&wTm-KpP
zM5!86q5ZSN0D)>94T=I;Z*S_0qJS*ULPh~mwz@|Xvi@GzcN1*X@kxe`sA6mqDp*I4
z>W9XUMDy8(4mxZCPH!@+6jCyubLe23Ex>0__pXbAjQ!bQ#f?TF_QjuvzA6Nf*-73J
z8ARL;KgKPlO(*@SRT`gjNXXu~uUT4>t1QY|;wdP-)%#Vwh)nNGZiHNY&Vz*^GCR||
z(wi;O_xpcU4kEMbco*3$GQTKTdl*DcmyhdCLr$I)Q|+D1VjbyEE#ak_({gfs>sz|(
z^~NZv@yUnouLlNKv|wd4b0gYLK=d1ftc7Koss357f5FjQbUNsVQBg!c%ypwd&znsn
z59%kF-(PG}p7f$!-izkX3#{vYAj+WY{n_Ea4kWwYZAb^((1pGp*<W;+Mi<w)nTKC}
z!8umcj(DSEWe%`b6GAyb9^F<Y0m~&gJ>uYAVt{HB2&3(91j|ex{EAqHF};=z9ywCX
zftA@_er#&JS}Ab7t?qApOmxg{j`rQSq4@II?>CC0!pP1&3>s@}v{@L*EZS~R|1PMC
zus<HGd_b)tC=T41^K=Qcm6uvcGY(M8*bKAd-b<)KTBkoXN$@#_0&@iB1{KZsQZv+=
z;u8xUY_a|El2B>ARGB`#Bci)S^G5<YpAaEUYxdl`@h6&y5Y1;4y1+(WOTBh|JKB2l
zS%n@jybADc)0wax5oZkrs?`|>P~<Ta=gr=YvKyaT=tvH_K3QTaeC{1(`;1VUbsF)@
zC$ygGM%*n}8SUu#%tA+CW5+pR$xDr)BKT?Ep%ME}C&|5!et$X~xwouLLb|tEk(}QY
zaRrIWXBCnP(4@syiRV^BWO*LRSTj`lwK_a>9I8;_<w*t$85mlx>J>kPLi2a@jyg<5
zXMAznZHUY-<6UGUU_5r9e{~e0`Gfx4B}7$Kt{R&j3<D|M&MORNS@8xzqf>%8m-9x0
zi&r+>yZ7SO-LvxR9JHHzPS>OxwEC%}onxqd$K^d8r_;O(TN*^od~xfnLy>yVqu%v*
zE<pp5Ze%kcdJ_m8F8p&L`8^2DcYPOHBsC@Dknf*6IH|XHDM~HzC9=);#T14J1(ag;
z&|XJZAbIU9!(e1}<rOxhL7(~e>RS++9{>W-25F_l!iC|8lE9w}=sqI>)7S&AF8v(&
zlbuGWsRYEAXA4(-AL@i31zeq&0cPXe#}`4d`H9_y1{=4^jbGe~f|s2zsHwzAm5&u{
zei*JKKeM}1%jhL5?4eDM&PPlN{xCq-OacSVH2eNC+x-}bE*+8;Ma&)}d3(J_Vmf->
zuCM~-Vv@5HzQGC<%_%D7#lO^Im@t=&uQLKv4@%oEbObS6{9?(+-vc%m!zTlJ3O4Qe
zuP5i6q5Z11XN}>r0X^)#J)Qa_(4aE52)~bxIR(}+hCc?-`w+6hjH3qr2n;-i&kgLB
zOjBLSD-GU!>gKP}H02mRJ1{suCV)+==~7Z|<!$yf*kH%liGjhCeDLU3AsQ-2Q{G=j
zyFZPt9b+d5Y9F9Gmg)=;`5S(HqrmI5v>H()#y%EM`$QCR&UNxp_)FcLcSN<eO^kgu
zpoZ?=vILhzixz*bI;kg2{3-jM82gYw-xr!>no(om(4-zc>WOAba88FCCn+v0J3Xl6
zgW?nPr&Jb7!#(Y|P$JCTRY|4)HM`3dQi;B<cD|q~^wPCSE8EeFLuK959{H88uWkJf
ze#Kf{m|qDzH#E;1>mxJB;$^)e!FfRppF$|w%XB8A_Gzf@>iPDi?I`H*`GW-Po^g~m
z;=)H|t{(tBgcv@BP@p?OQ*7<b2KkZ1gw-gf**S#4a)97n>2=MNy0vH>Xp6<znS%<r
z4tlcbhrQrB^2?0AeGzB<ovPI`kx|m0>Y?_xgjH#Ad#w1-50-#pF~&{`^kF+hQ>Atx
zkN>;ivOW(9k?BwMc)5cP>G4K4>|FTOFr;5Q2hb;~f73&L()Qi@6(O+I&3(Y;?j(9_
z>3pE1jo~x=gkQh|yQ4+NRHrFg^rxBxpVb#cb~|{bMR8OH4$Z$Xqu2YOFBZe+_Bo%@
z`(oqXp3xBMMpmD;%9eBkHWJ~h^8E@rZZZ5(f{wt(HlpWudj~>^)8*fY3H58!4nrU^
zzgHl1f!bKle7kJ{3LSh_AL#<`9%lDXsD}Jowy{F`w^8UXdF-2K(Yo;oeXgv!rEPgG
zb1|e{KAkUsYe;<bgT3ex^B6v#&qWRzu`E6IPApcMva5ETG{(;83zi-g6B~w$!^Uf3
z)QNE#nCZe#@u)85j}olw!Cw>Sfizk}Kg&GUciUO2iH%=ib#Uz$xb3#lU5vYb*JmCK
zN0G@sO3;hj%IyVNk2UZ7YYa+>QEWeVVT11~Na#OuH?0Pt*^VB7HpwAHKl>Zab&j#W
zC+t^-kpn1|58JR{A98isQA*p@#lt2>Du3zm#Y2!D_!Pf@9?WDuJmb?1AT&Ff2cU&(
zDg_PI34`ChFdWqhe3D-PT8~ga|9E30lv##SOD^<)4NWH{6wQx<pPl2UnT3%KCnaYZ
zg9>y$sV^Wj>S#QjnlTmSEjyvlFE+Y;cd9^>qiEy8=kU3Ldz%Z*O7>?y^(_=Voj#7n
zQM`30&u)m#ZU=gz`+bspyx_5%bC8eAa2?Xe1IbZlu*pR;{zz)3{*GFrDxJVIjM^9f
zmv8*4zIedI7)AZu$YL)d^HUlMX~63i0$S+bO*yq4c@3Y!=jmB@_3K^U$pXbrr>nzr
z_qVfmM~|Dw@TUiQVh6lkuIBg=r8ZM0*ZWX*9-p_G`|BR6cY>Y;5+g1qU3&Sel#JSt
ztO0w*tVdChKR}RHvNSQu^{x4&TD7}^%Um)18G;g8ZPZKsbo{n%eVS8NQMY!h*ZcI7
zG&*G#ji$S><=z!>J?+AbC5N`8>Ia$c4VhVl2*}zv;28c}!OmKUZ+WAj1r_azyp|}N
zcH!^;w+O`q2IJ42#_q&Msipcqh4n<eQakTY*OHLf=#~C8YS&JPZcY6<x@eOc=u@kI
z>s+MM&kFeDKTqq<$uZpnHD>}&d34&#sO;wx0KJdU?M&l0q@McbJF*<@2t0;Q0`%aW
z(IOYOG|1AX%{Uq-t=s6!t6t3yh9}1G*?_(;1vW6Ul3o$@+-krpj<NFqz3@*S9i+~=
z7p1jKKCgDhljwBFK7SB?L-dEj#9MCQowyA3F3*KO#u_}}huk2p{g}6IMtvV9mY)99
zbj)W0`V>aL0&W#*?C5(Gg$%iQ3ROmUSKDOB7#7}fFLk+y^r^~i=LY(n+Sx^>I9_q}
zW{p`}gU`}Qn@YNWwV!t!>id*6eyGc!=bjFapTCJRKA#;(icf>xc=pM-0?2as3_%rK
zrPs?9c<NY=PpBB8-0V|}-2J6dX{jsl@u|$y_2)!tENlNTDzo@JL05Y7U^o2mk#-PS
zX09}3_AMoNNVR$14^N>@AphZDS7u{BRs7*H=%u(AK2gvGM%$?Y*H$k=r4@e$p@Xec
z@MzmmV^+sxav}OtyZkbAh46RO8+hQ=j2FN~<QP6%P|7M=qQ;JR_!~c-K)T>hA`IZ0
zy@zRCj!%Km^2mc@bx7(bIu?&Z6>L0v-w=>mv^5<307XH%`LBhuJLNb1AJxt60||X@
zzVWNfN&3}*Z!&(|oR(DI3fkF&2K23=$$M+-apdg#y+$IRv@-~O-fmu-?K$E(7)I=r
zK@T`N@Meyl6<W5xn;D8M{l;P{$@G4Z$iiBlzu$TA78LpHa|or#6)Na26OpHf|Mh1A
z@^smI2<_=c`+RoKoI6p&pU(?S4kJ-@6>RU&I1AFPeb}H>K{crX=_03(E@?({G{Q6&
zu~PzrcHDf;`WEinxY?gBSfE79)5bQq?Q8RXf?8pFdU9AbQD(YYk;1=Fc4-Q#$oX>x
z_tV=%f?_LXzkunB;kh3EopxV(zn?!=(7~tEir^zGQu?k_=Ep+mtqDD-dXk<FE0j^`
zviAFOR-Rd?kV=qstIZ#Sn~4b0Kk=Ql-EZ>pmQCmzI%&mD6;ytMdq2wExZnIdzkWfv
zO2zmVv;xK|NH1mo4*CgN1w?V+ZqySsy)s#04a$X}FhCzki!~?`XBj1GInBq{GDU#c
zqVxqq#ul#tl=iZ5Yg{#QRjpqYYiA7_y7so~qpRo~?_x`9{|NGZET29o1Q%gE`1F~S
z|M5y0PJyC3)=n4<${!uubWO(Tfj1PSrJqc>gX+v!K3R~27O$TH3qM(-MlsU5)+33v
za|IQtX`+DpK7;!Fwp2})!|U6_rInrPG)&z05!aDUh*`VhHe)Zne=+Os?XSv+UlJ|;
zlxirJPaNDIEoLLQ9~txX{9O50i^^!mt)V+g)S5fwmm>4@8Yydq%?+u6s9kJ~<<kh|
z2iG2MK#zU9l(V8uCg`(SZ+&(AKGdMK_%Jmnz9k0bf>+XO=kJ>YD%My#uP~T}m7x!G
zM6Tv}3L3*M&g_VShTN`)4jRUh#TQq0{EXIs&nlE_u+DjO;-Z)`wsrTCCA$-K1FJN$
zMGUx&5^EnyXs$uvTU%}{IeBshy!(=2+vfkM@mE$eXFJC*?XQUrb=9!Ru5HQilDk*G
zQ-E3*%O@R*@S?6XoxHBNe5VPh=wkU?Lju+2RuJ(0V!!<YC<L*5mZ1ZzpYoK*Q{*y~
zS0>3cLX=|rdhR88N6h*5Cs5tT+Gi2^fP;h+xo$faU)lk--LZU<p`!_>`+zpE2bTW!
zFKC0s@`;9o56)aE5`6daj+~(BsI=zOjs)cZKVjyv3FnZS`BXz!ShGbiDt`M|h%AE^
z!!nS9*B#1v86vZr53bB6?;$B;mt&NE=}*mte6pd7?DVCT!jBBP{p7W;q7sVFE_AV}
zyP-i}nm+#!*ht0lCkDFEu5-)!BktG>nP{V<bu(h^{6Zy`ek5L4{-S(^G1K&3M%=tY
zS5fHTzgO%^ZS)uWPFxiMSJ9gE)zE=k#C6*4Elj%_Z7fo(on|Oi5|z|sLyNl3K&k8n
zO8s2u1OL{T-29z)m+b|22$aLIP;RaV>8jCB<U|VL^9@D&h1xs8LRd!AFQ3f%Au?+|
z=a8@~N@!_*xev`hO7*pNh8Jrm9V)t}AtXEUJ5z6`FF#eE=J{XB<ebOL4?Q>KWH&0{
z^eq&hg1A50nRY_2hbhxy<rfzHkS&UeZ0*oImd`@;z93%%ULBvXz4XSG71u5+y>^CP
z_}<Oa{TtdDYdi2*`^Z5}cg|fM(MT|9kB_}{r*oM2L@Dv721`3B(f5fOG+|eCS+2O3
zj$)$qi$S?3_Zt8XyJPJvMc;QuuX8R2>FE0=-`xmW6|wd?gg$h4`y(DjTiC3V@tk#o
zbtT%Pn$*r%1m6&&TrOU5CeT$~TwZO8P~4a>Xi0Na9>@c%kZ~h$gdpuUa@gOF<Yc?*
z8r$iMK=Kn)-nejO%c1!%Zf(%{DZRt6sp)I~k+JFq%O6-M;z+PDB@RPG1r<z{@&`>X
z+42KAWYssHc4njbgVtVL;q61@zDGvJY2|nJq`fEo`E<u`Zz{j2PjWAGL;l~HW1W`+
z_0Yv<J*sM>kLX8VRJ%;Q@YGLetHWnNim&KfoucnQaRTLkKJ$@4!BbX;@3nair6fM>
z(FLaGFSJT)#V3Evf->_<3zFHamLDm!t{DY6`tunJznd8VM)S;m%op_l3JbE26f!Ir
z=NUEHeSHwA!OnOLR#+shd1U#<M?K$#!2C^v18gvwUtZcX9N7e)=jhl3D(r`qE4vHI
zoE|?%Ti}gnpYDP7Iee0%BQw|nAG;j;1KKdyIgY;dGb-<<-&cMDO3d#Dh~+~OXzpYG
zzJWH?d|o5z0&J=&y!|)+i3cb}(4XpjG3oMZl`bi>K>hRCYtsHn-$U6cjH;>w*kU*A
zvusNFyIy<y4DxNM^0a+B9CQTQEa;bn)=)X2u<hF&O`9?9lhith1QW|2Sm>^y88)V5
z+=wQm$0}_RmdpZQ3;1DA#n(e|L)nS3kbx5>zgucAiW_!{qTezMFYM9c=Z46f?Tkb}
zFyhxNI56p?H~v<26+Ro$IK=+*o4lD(XOd4oOhygQH(xyRJhWrJQ>Q^io0$94mT=+t
zxf(MHS6zH)5^`mEG8@vB4dY$4HSP-1tesI9Gz3(uRE(JZ1BB%#Y4m=_)Wz$+fw26x
z9(wThsTLFNqt)UQ2Zec|ykC6q<+CV>@<$5_;NTWTW{es~%FIT^HlHgfaP<~Y{+gYC
zgUXd@!WPE_s6jCsQtaAi5LTKj1J*d68h7SQABtdlHEd@H26t&IPEpr!?SnJ*wqt6W
z2G`-TrNevm3Wf4;o&R?IfLeAk+=OyoeZ9_IXj>KK9X>aZ9^!#hyN|}*_!}vJPYWby
z^Im4#gt3z#ZaVx|FL0<jtMFN)Z&4uU69P$I<iTCOJo^p`4R#`+jE~CoB(hj{+Rx)Z
z7o0-{pT6}^2MtgduV`JS<P^;@(0g0{&|0T6PhCqj4cmEuK?ezZ09`LxeE<6=sSi_D
zN4I*ljxMg3T)0Am1Lb20QcF8mjftneh2C7Uzf%l9BTi}2FvKj!2NXihT{}(C_=;dq
z+!U-Ww}t2iZ1ViS|LSoZrEM8dLVCUt{jz-2@7*w=7rjSiXA2q<J5Lom?|(&mEjOwE
za=SkL81;zl>_PoI;+;2@8X-S%a_fb%v~AOOKk48R2JH0OdgE&Uh5DDire2<IruNZ-
ze)*l=ZHjP&3s;=GXbqwsF*pom-Wx)n(w>iwO$VjW`5o@3ghOBGHLWIocw^toF^OT~
zQ}n00ww+z*1tr>R1UsPtGPHOdLfhFq@!rpmqGNFW6hhy33>Id=Jm)?F7rbKaJVSGJ
z#-|t;yrwljI|(sZ(m^p)R^;0Hi-)2`m>RZq%I^8mdT%;u@5w_R574(H(!(uP4yj7*
ze^S^O`Nz573rGsPP{vq_8ibn`yU<B#Wt3$l)JMMmwjG5g`crNxC?$W|!N_GpD}a=K
zm(Jat5v1QZJHJr1N3=sr{5{Wdh|JzcIBEr@NdEk%)<R@<DdHlVorWQ=)Vv6h+0DKH
zvawm)aAjjx3Y_$(7+IX1QRvq*Ds(1w88r@K%LXvVfGePmK%;{H4F#2IoSi@DlN(i(
z5jh)|1H`&GJ5$hv#@)GlS#qK>JI+3IQ2T<}?Ru_%+jdar=?falDVD4_KB%z+O({_(
z{ip5Z&QZJO<F)U-fF2@?v(o`JHF!Hj`r&RVd_DQ6jAS0VS*L^jC*ri2jo@9jakW5^
zsZq88O+imM&QA5yq()|aD%-fyAU($M*?qk`_H*WpmZu9AWz^_T!jH*+4YgV0_(Z?n
z$$j7mfQz%nzKKE<pXo=)BJ>4hmTOsmaf=D`U)r`j&OS^qn9>g(BJxXy>w$bO7qjSR
z!zY6SusA;7PaIx4k8U^<j5Py)bX|cch%R^MmH<fT;!bmM(SR?mujMNZpDF=0&UW<x
zy6;Uq%I1e+57Yxq1?5I<C`Z?u3JaG#c$L;q_eDP0FCb@-2PAD{XuF@BDqq|3#@SyH
zR&0aFI?nuAFunDWC!YO|u0~f7e`<cTj~LWG;5>>vddr4;!^3iyf1&5<Imz9O2e(V5
zW;jW|M5Fh|*@=MYV?Ay<Lj-i{$+^}ue*+bAoShM<eI%-<>=8(hiW>a=y)f|`=+CDx
zcG4HC9o$FI%?+GGXZ`xiUE0QL6ofcCOVA6$>UYSrWGx`=Yh<P!ZRiUcKP1l17W660
z<>>@SO`{*zEBz9c*E|S4Bt3B=jbnq}Q)`q1-KID@bx_fh&Uc_7u`nhI4I)q)+#!R6
z(bWC%tDDZ-T$Hv|!{O5f#e$kA9F+B<28@eBI^eSf9cZ&I|8GoeYY5D)_+4P%@hVBY
zd`pjeD7M?VfxcA(eg0*yEg1xnC0Wa!lZ3DM-?br`YhE9C9wMj5^A#_YF{R>|42W7A
zXXpH>+Q4z7$V2P*L8;}An57TXI0p49J_jPF%d16i+Ss&x^>2oi5IH@WUufDq*1z6l
z2^vVG94>`)YD3cRGOjyC$%g(^r?xZs{3|CU6$~RIW{f*q>1`A^`Sd;VKisC@l&?H`
zWGl|j+4GAIe6T^`FBhTpi)L@<U9nAt6dV5RQHY#Q?=~q3*|NQL5pB5nWIR`9YD8#d
za*;_xtDz{$r{uZN1|?zm$(rb4tT;X;uW!$=zA0gSd+N1!`>4UAp`O{kEs%!~4<gHo
zV}H`>wxD+%7j5<JV8wCtbkgWZg?8))Qp(x?w#b(coEa!*ylK04l^|<J3fuZX?;Byl
zwW%ely0@K?=NDGId6~ag?*eqq5ze|@{zRVHfXW<aA4aHt$Em_1MWrt;Z&rHyqf<G`
zue_j>@*8J~8A&bo()us5W_0sQQE$8<zO<&J@AU(j)u!gmd@-l^4E_0($BqJ~U9S1F
zYHsAEeDa>a#0R)%t7I7r4qD^*>^*`u4{(?D&2$L45`QeAg9~W0i>{nm1RCgZeD)q8
z>)Y9F>m$2EJ*30+5%2Q9)R|=gsUeO}*&}IvF_2t-Z`g$*$mJyiBb3XVdEn-uMYm9}
z<`eaVm^zbz%E!(1-$+2F%jfAi!1_xG1U;g9|BX;)t5bWa+<`U=v2&}E(0lK3e4d^Q
zY}EgG@@}05mBG&A4lwG<zp~?nG04vNJUs_mcZ=GIW41yaOGC5N(Jrh}<CUwJ2VK~U
z;}i8<VB^5M+JaWkQl_PTs~Ugpj{|$5zI3A_6%$)D*)Xn>aZq@z>bC#rf=`$Z&Q9YF
zc;L}RLC2V%Z?Zc9US{(-xwrJE|Dr$j&`s`KLb$e=FA-3+Oy^_fAD)a_L&`B;8f)m&
z2nme{9y_y5-v{BXCvOHknz{e%pMR$UVnLkJw&Y4LCWrPw?}xv(zs>ikI8&M)>`xdY
zH*-83{wQ_-^j@a2`AP%ai&D;sLa=w{IKN)FepxdSku&3z5|Hx|9X2sTl};#L@t+NL
zWJl+<O9x#(0HLLsvm^$k$4}2K_=J{|{?rIyC;a&|j+;*TyA*i?%59AR8o2+Ek8=8s
zC(oBdjxQ^akdAL|8)skMG8W0o=luni&rFf47Brd!p{-7@slk+b*Wc&QKxlSa4@hlR
zIbRnTzZx|b`0T#`G}!LeDRyEgDtP()zW{ci)|2r&W!lUCkwSEP<`V#&q_gr==4Lv7
z^~~l=2cbgP>D?7tG@XnL|H=6Q??CKydN^v8P5Eg2Oo%Ogg%v$e_bJDM|AwOQVdwby
zO<N&z%H%#Qd)^D)l?OGs%jl7|kBbw-aB*_tv{|He%<9qoBK?<sj>;$axz-^L#ZTzw
zu{GkM;i%7NC-ntYk(!d+=jGB)`EDFr=X`g|TnNwh^whqI%^ElI!As3--u(48svM|b
zQ}Y0y(pUP6+u3j3KC%C#Ab>|lt$i@BuAppl5B-5`#ZKk(6cqRcA`BWQ<ON%Aco-F%
zcJf}Zuqsowp(xu@juUmWrz|$5jz0Y{@nt#*(?(Fl*@=6`H^jJtt2f8ipA>ohxJqiJ
zo!Y1W`)?(xf$a3Xpqf$!bPbk3?(w0%Re3YDS)nlTQ|QmP-0YZ;s(wV|=Mf4=Nvdr4
z_D$R9$LL3t3DSqth&_Ilx%AD^T~?xZKSzxjd)(X3DSSTpQz%T(XVT*HQGdFO(vhVC
zW5I@ZwtApS@KMTvkijP+FttNLrN#ZN$nTGX#23%!^pW0Cjkq9YWe;*-`cqako<Ati
zMHYP3z+r&#!f@+3_g6sS`60*=-b{bd*ZQEdzIgt?Kv#IP_R7_0MiMBH;`!u07a1I3
zT-*BQX3zzTx4$f`I;z=SOFW-5HwXand|sa`GSyw)O%!7-Q|1-kKyFHZK67Cg9PUS)
zl14M~oC9A(MQJ>r+vi}T1J-eGZbF-^c>ct{0JOi}C5LZy|M6a4t5kJ(S)^MW-Wjr~
zsUpXm(Up*z`TV|syr77#xM9{QWZHIuU(o)B^y^w$_>56({Pz3W*FdU{=M(%=3EJgJ
zyBlSh6K<W}wT1FQq-J_{f}fWYmbFY2?=>Cou<FfB&GXNmGiPqIHV3n4qlJc^8+nPm
zC`|u~wS6eQa`0%YbxoTjCYEn{d`y#;+2`)9y>V#ai3!PWNh5zs-cI9gQ#GKy91(A4
z{FxsaGB;u4t)Uakl({u@Znu(p@pODo?YH1!Gd3T@oU0sGyi>=N;wW>B`>rf{j4+-<
z0Q5ndR~;55jdC92(dzAZ&cr_-G`vr@c61K(CVf0--k%R$Z<td!xOL-9dvItFFLPbm
z;h<WuvFL7QDD&qE-#ZX3Acq3z6V}XeXZk$xFbXnu2H-G<RT;DmkmMeWd1)BvX~)~i
ze;T%4fwrmoK?SG}#?hZoAO1*As_vQkVG`7b)%7)*LC{UQ{N71a192w)`NZ~}Qjyeg
z#WIFNsnhA<lEWvBug*vBJ_k6}@pcZMUn9=T!qxpJY$W>w+ghM26!DR=22Z2R*YQp3
ze!t?N_E0a@ErfyXJ7XdzkImZmUBL2HT3n%=TsP^fwT=%$S(8KGQ*A@Jc|bqhrSlit
zed0d~quNnTyq&=3rJ4-QvQPS7_QZM<Yb6FIc1!g9DTS+q33NL5SIa@x#6KrnW@uK~
z!LHG+UAIOnx3=q7FR5F*%I=sn`JE2aF7Km@CE9hqcsr?2{))=ko3!hcn0<b(rS!m=
z&h4F<FmWL1NTaL9vj+YJe@PRu&uqQ2-O{-a>A&DawpJsk(O_uGO7Zjmf}u%0demFl
zu2WJ{rxN-%{#ShL4ZygLx0C(+-zYh4_N*5k=<-3K50<`l^2~3}$jiWE5OPT}{P9U2
zBClw}9^+Y4{uG5RU7L5>0{YyCg&#ZhtMko%?)!`KTMzAPb(4%(YX`)$X8tMP>b7!g
z(P?}1lJDRXkC&(Wu3_TOXT;V>;a6LuZm)=ynYT7DPEa-^7hl@+AgT#uUI`g4jKjvy
z=N(%^$(8b;DzKdzC<Wd)w9&*`dR;ngUb$`rO3}y%EH^W0#A6kBVy#*eXY0@@g+9*!
zWtN2z13LJ^j<k*KKlJZG+i61?)`CElxrQ;2v-0PU9fi7(tHu!cms-o0m(X=luTx|;
zsEc&Of{n7;m%2E#CUGED8T5aA>u0S66kXgxmJzmZ;dc<(y6^WPi*1Uoj2S0;&4tL;
z8o-BKW^Pv<dD!RzpOPl@T?C5{7>F8TYo#oqbm?tHpSnc<MStq9U#?&XmqrAFL+!8K
zK<38c14?1hZnIXl^DiJhuqc2Mde0YkYAttl?COCkxQ5-A%mGZic+QwUw{{8l-Jv4P
zfnkeVc^wtiies!E?Nx5!qPW-3+5b=3b%s|}G+{c3fYKBJA#?(v+}u<;NDnQc6MB=-
z0-<~~F?6JN0R^OYr5EYarAV(zQxOmZL3;ak&bjBFJ-hF{yZAg;pZMcFv$ONg%<j(4
zR{1#nV<@ST&o-)vIpfM#JxQ}7-*gK5%+a%LcG~gv%1cOQ;+C%Hx(mb$(XXkC`z&6t
z$DA6TNNGK@Vk3`wRs9g5N>XccnUL44O&Kk{;Ibg=tr7$+39TfvrDReFd*Mo+zj=FW
z4WR@|IBAN|Df08`njLS@c1EcHm(<CL^7>mDDr`rrw%w;+R?Fw?$^JMv8tuvIl>Es;
zvkFkO5z{->{^FFjim9tk`Jem|<4i`}*&teuN!>0}9`+gf@wC+G*(ZO7>5A1da{Dv3
zeV$sDZ4SLZB3vAdP?rXBmVcH#a8olVnfd<6kTRpw&1}5#>&Y{x9uTv?XFYFZpeYi{
zmLt?%{TyFQT$ld(Dx=Huj%i1O#dai@u1r4<dfG&&D+h&-uySv<dSNAEW<{H=wDgtg
zCBiS*wyQ{2%(vgxnP2ce0ByVab&r0_MOh2|9P_Vq8yvTh{r-7tEvkQvP*)Q=faPt(
zEKh3HMczo~VPUVu$|XwVDI#a=Xpx2~f_{Abw{_v$Q?v{yCT;;F8GQ76q+50QphE@n
z30b!sE#5$2Wk&A=maZr5Ts7z>(yh8=&;g9fY&T3Rgc?Ccs7nPM&|p_`OppAztixH}
zgmvl!IfD>quk`!nmOv%j*`N>ZIRut>BvVe91CM=mY6CfW!G7dd-G8Zu4k2~k3g(cd
z-N;4jbN_($vUKVKZCv9BPk!_CK($k4A-Hm(&g<C`bxik0jNUVM7hI&<nTtP0%lnT_
zFPCmj`5XOsTjMGLG>ii6$_{^V@g+HaF@MwP2gvIf1^Lr|HLH!v0l4!EJ*nwZ3I8IC
z9Y=mXTRRg}jCOi&)~2wb2&bmSzq=g+6{DTvo5;v1Rd-MS4f#8DfuPg&fLAKhAYBir
z5M}6gLd*UmaEN;$a!fjp1oM_6(R}E`6Bi+{%@&23xB|GxC2ixFd~RMb2&_$U7kitA
zrjfG^qW6oxYkz?D;A~uf^p-RGuH7GvLxQSH0<B3SLBTpFX3K&hv|}OeTIkdRnsep~
zC}TVkEIuqiN&LD&Px7J@9d&;{TkP)fy#wO92N>>yS2N*fDKh3NTJWgr0loO%H5$!g
zapa`hwYl~)a#A`KfgTlkKVmF*<h*HX<vQu<ogDh{-dkN4D361oe^K11k0SDOC98J!
zJ~UawU%}nU2(1!9V~eKb8P9@;W$x_i<gy`i<5st1JJOzm2%BMrUi}mYm1n1}D(ZTb
zN9OB2*0V>GY1YoYv`i;Ma41jd9lWa@Ycxh57WV4$PvYiYoqT~w!Ht**tqMU)W9FOD
zkG;)n>}=q5`kc9~Jt(d=(CIBmPrhmc*}dvO!3Cx1UT(CNb8%}1&SUs?K|JRSSX<i#
zU$-9ujxQqBwSk<r6W5vVHs5=^J48HIIugC}CV3-TUUJhJsV)(8e1J6seVnO&jJR-(
zUHjlRXuTV$^_;Lhku}HEtZ%+c#ozTJmoz#u>r;^QN9q&_db|a?e0y&1iTe;%JK11+
zP_pC65#DYDgw<Y45Ui9MrLAy$I0#pfI>murC7`_M*4uMImQg#5L*Jc9TX8gN_crDI
z3+h4XL%a?cT@`NnXV+d(T$|Y{@ApM<VLe6Z#i&YWr=(>3pdZg|dztN%+tQ_uycg26
zvV0G(Qk~*I?_5bK+wFt7mZFjCl>J$#sI)TWnx8*_xXOb)d!o=PXY;~{>JV3Znc!lv
z$$0~e3@f(g2OmS+ci=6$iZf&9_AemrI}lgwD?{=&?l5XDSRF*Fd-(DCMbv$Dwa_l)
z6Z8xCNW)-3v%1^f|DXZC19#=sfBI%!>p}&;19io_NJQPs6~=#M9Srf*we8mrb&Upw
z5`*LJ)gFxIOuuN4G>dAa?=>oM03zFtM&ZBOwCx4EQ0|&G<O7fwM(S7WvEvDEW@zN@
z;y&45dBR(QgNjIXlRnFo`A<;i8mOZI|1?Yi);N*sHht(b><T=W#}OmTB<*}Vfcbg)
z@%~xAmX9BX=SHHJMs{Mit9SWEq%NUkC{o?0&&s>1*Q!As8mCXmG<F(0HsCJ~*`MkD
zsIc*5q)^BcsV?#pK0{6Vu6;Z0=sMPwo8DQ>B%XrIZ=Zf5O^mQEh*X#RiC?1j^@+7a
z{H-5WcaaGT2Vs%whJ6CQc?OaYJT{6?CdpZBDv<Lcau#+_QaKB0Cw=##-i5*QF_HS^
ze{?P=*y#M(?^i{>U0wFaaR43GynRz_IRv)drOE-(DW)8kul&CJTL^5cRtH#4eUm5O
zgWA+Zsw?{(s_+ujUP?b}5mplAsOmR+9mt}aEZp`MI<tvXm+?7aB}-fP$-tQ?c&JPE
z9Kb^QOD=Ik*E`QqY*rWOIgq8Kwc39x#(*9FNcBU!Jg$!&{~KMlr=iKDA0PPbL{PzH
zapGQ72rEZ^m419+P}k)-rA2#Q&0CdNh~`eGU!R%2lb1jValP!RzJ^l26Qgk_zz2`A
zj0U^rkvi@Ac&P#TZY~+P2r9&$J`H~%CWK_nrEdNC5_uw>eto>q9&5HE?cLfNKBw3u
zTm+6(ckA=UCwdOuvp4o|_fS@y=B<dd-BMt}@Gns&r_;O7BR`$qcyl>+wk3v_AE#a|
z3$}S9L$ot|!^XXzFqS9cM`n~Mw;2?iM5^oeymWGmgZvg_fOF4<g8H@4FNdI@Zm--_
zjzDs?my#?r9x)R4%+%$4SavH5wT)@>{9#6ibed`2+2~jGRX2?(@!yyjsR`4Yg`qvs
zuAI8APcYTQho{EI)Q^%raB22?c~GvVF7lH;;Mw}~l=Ry?$Z>IOV-%isI{I-u5Y2Mk
z*%3LAPtz~@Gfz(FNI=NiuCAT<5n`^o=Fed@p3?@dxXM<_NBa-l2ggg1I-UJ^rSPR&
zHhQUoaZR9Z-pwzt9ZZQ)X~zE(g;D|i`ah4_#jOzX01FFGxer=~aK|tHJU{_DZWE?5
zY5i~NAx-F4{&~cep@Uj3MxAOS_3QmS&{Dc}wRzRDC>78z@iURpK4HkC{Chzol1Oz`
zpVPKMGDkt%U3AKHD7t<+K*55=2bL!pb7{NUoP+ybq`!nC*+~8BJ;T+mLhWCMM6^By
z<<>s@w^S}Ksgi6s@EgR|-kZ0uWjemel)49^qkhqzg$;7M!P`@(gyhlQ>a)NdCQeL0
zUOV|N#B^IF3Z_erssECl-9ce;q<-xln>lYLL>qsW1=@af^^}XLDIC*}5BA&xLW*RU
z|Au$Jz&7z*>;BD4<}H0dxd`xv<HJFxjU(uxYov$&77lt+lhQ?TV@6%kC!r@>XS@aR
zxI%vMm~w2hgc{(1xkz<!ANUCMfWDS9dD+u!FKhRywBk-vhjv-2pzKB63()bc#C4g+
zj>%LMb`5&<s#rYygwinxpNR5#GTLi+^Ym!vNxuk?S(TU`O>DklA6h->R{#<yNRE~d
zjLC_dLb$e5Fn|ruzy)h^3ISu5Rz*(1&RYCAg(BeE{>Xf9Mk6igSN|EpvVU=+Qk+{_
zZU8Elj?^#yGk{qtCjckU({>|LuYTp90W4-$By+Vq|8_u2b?&~j+Ium-C_kL>VW~Or
zI7Fu*pqb5*(5R>Kn$m0DqWGp??`I;zBz$F~0>_|2l-#y*Aro8<6f+O^908H-_@<?5
zIp9CuId%fH51S-f$RON*kTp#x+C9|i2FTAMzaK}mu6;l3BSdT4VJK)V#roqHGyR6t
z%hm8`DM2pPth~r|5~)|e?9Vg_usQo#XxJs>i}Y*$OlU_gMZDfHbb370hW3^{+l!$S
z)HpMU*y%{4XMg=e$fOZI-%(fid4r!jEXKb4W@l0rCTFjQa$^0$K9ZTWiS*W(+ERa8
zvGDW&Cb4*6$1Nj$SO+KdDNh~Wo(4X<A#58oITX~_MXFo<f$yaMuNJGXOD10I{G&qV
z`6%O5Ki6xyD5fWGR!g_Ngm^Q4ZoikbJ0|XssSEhf2aLTv?h8c!77@)ySZ>9x;o}zI
z#D1C(Up0Kj(QKfAdhh7oTXG?B7*}oQ->H~R$~KzrbvGoV$#mX7V|XQt_wLubVT1RQ
zB-b$-<NjH#b_<&gEE{lGyyG@=S^54H%$(Uh`-ZY=z+o`vTYqBbjIn7m#t~0xac^^#
zf$J|F++nBKF|}J-H%!@kt&&{i$)J@EMv(i_dR7}K_5A2NHT!T{mN;)TGI-^lfdC&>
z<o%e?X>`gSBK0Oe{OPVma+1wHV(%{dm|xD$Me>{vnmkMPVhmI}fne<P@mk5bB~7Nw
z;eugnrw|6VoSWPj+1D@>r&DLZ+8KliO#3t(DJc?-Za!x`l-UmT8cGI71AS-j%O$4}
zVH|N3Y?n3$t1K)27ZO#!y3f#poWNKAwd!s;gJ7a6NzNNuag@LhKmPf5a-e6>N{Tz6
zLFyONrbc~vkDehb8SX&lGe5G2E4AL7g-TX3+X*YpUg(+M-a<{h6Pv{fQWAN@lOKvg
z<aeSpS|pviw|6u|ekVesMN-_5fx{s3J24t<c!dw#`3*#VCqkpczWC1$?UxVx!nkPV
zm(gsoFRcoi<tlLm39Dc3N0es5O2|7u`{5<xw0?^|6B#hCO_$&HLZRP@)9C!XMwQDq
zQE<{P^D~7;^^XY!Mn@rH>(}-%B?qvE8)8IFd-mXU2&_+R23&$QmJmWymD=@#pf>b*
z&4Bp@hrO67m9$bXIEVVoX4vJ*%2F3kY_J3xo<6e~a!cA7GZkVdyi?zVRilL0xf#p|
zsHC=?b-7PktE5UB2Mk%9m0!J3>fa!&)G<VIJE|y1Zk@W>Vi%q=p%xNbU8d(lY;P|l
zdp=|9Jor^Es|YKpU$w`q+q>v8YH-=oT`<Tl)sml*S9a_p`o!lxLR$mE2e$pM@pbtW
zn|;96zA72xJ^)KYI_K_GCxF=y{rEM9eoY^*DDsZX{erEN`nz9MgcI^EUcoydtcb%d
zm$xlz&6@42>7Jpp-wD%~(nB~bD{<|kM?>x|+Lt$=^p3)z8y7Vyv1L(VcZoUg3muND
zov6Bo47sSNJEhZ*K6kxq$%ZTcn$~2WxZr$SZO3Y~a8uU<I=`{bc>7%{9_jK^SZ$h?
zKye7~=0XzJJz9VLXf5|twrKv&bDm_9k$gyG{grc&53y57l@F1^d5y_;zea08{Q^N|
zwj$l!|DFI(^o5nwuM8wmaNzRYUv1JMN1^kKuemL20Gm7DVk$-{?>AGXrhp%K7e`^O
zVp%34>3j5?PCHRh53%P^?TOIkzo3vRuTXf@FA+3UBc4T(Qnn>4173+_)2Z|Z-lYpo
zC&L%qa*nCFjzVQ9dG7?4PL4))@6!+}<6UxvFW|znV#<Bv(DG2f1klhkzdR&rPb=0V
z-r}KM`5VS<$@rso(Ew^*z+=+9y`EVB=3@F4e}<?a2-W_v@lurKsVn{Xi9;*HWq%iH
zB_DDzJ-kaQz#=C+<jQ=dXLTs{JFy#8EWZt}`Y}X)Ct4$qG$rPIHHiE!@gA<^g7-fD
z0wTW?t(nXc{Sq=Z8GsfT`W1a-c({H$Dj?vRwS~^-S)uPlZRVN<U-Win%u3{o^o#jS
znH@(`#Ox7GUyeunb+(rMGn=hf3{mautZ&}seW>rSvuHc4BzKPBBZhcWnW&?Ib<VPv
zJ<Uqkd*~MYXRrDjNm+o9(Wq<sq_5CDd!ucF_(IgsEz6f8KdoQg*Rf64Uhoy6vDZ`d
zM2<wixX%NPBI2*VPOJ{))~CBEx4agrf1(;_K+h&upYJ9#*kC!`=)W*z<6*Wf`Y;@?
z+cvR9@>DI;_#3%|mkF&O$PHk&?*_KguXUK)61fxo!aj2<k$WAV<OA^H1e08uw>wqB
zupQ|QG5=PX&c7k%+e%R|-+@RGz1ZYpAxIPYg?(O4NKX6mhg};%Z2ir8&m78GZ^v?<
zZ%1U*Z_Q`P?M+5(cUZP_{-4Q7iAyj2QobZpJRSf0vTpp7(trHJ*<Lk+ZX^>{sU!bA
zQlA#Z#RP|_U(IKKXK>i0_cGR@+YYPFzF$1>=c7@7iJz;nc4A>7t9U}HU(iRNOVhWQ
zSe01xpQfP{K8lFrP<jE&u@i8;zSPR++o>(5&2AR6@@wgUH>S;t9wfT6L4H_CbtRwk
zE9M&v-WK-uw6{#wr#EdHh)1RBsy^ojYDC9%W_1nR^9A<q*RuS7-a;voet{oLj*Mdp
zeu+%JVf4x`>!CAyJB#t}8$=IW^1~z*t@Q(+7U@^_F-dtL$=%GpoM#G(7y6Zb1PX4}
z=4d=>4g}WE@(I}Ka!KMJa`w800<(TypCK_iajcLyb1||7{lY#2+Uvk<E1S0G{x>M4
z)i3NbkR6#PDP!`qtwy;LDa2tDN}_vX8)+FGdNe%Qc`<V6`fdD3WFO14183tWqev8C
zlS7rJ7~m+E`2N6A(7Pn8q<&$aDY!FnBSxRDG4m{n_I4tnV6=3yTdBm$J;>tpOZ!Y&
z<rT!l%hip=4x#gwp)T#SeJ8u=X+2S4n{wBQts>CW=@<5yA|nDe9X9(i;<kPxKNA}y
z#<yk#42RJA`MhCqfZVN)-QJB{-8)qG8PF2D%f&=3rQj+CSaoTi#qQ5L^fup64x-y)
zfsBq;=4MCPruP<|rU!gVh?Zg}u|BwHSxWU1HES319F9Fq_g}5+UDpg{R~W|a`!>Y9
z!(dxa%0Y`u(;1w24yRw?XV{JRbi+7ql1sElEm-s#od)UG`8hvB3x94mft*3H@H{oG
zenVWLpPfpRFCfLiLO*u2%4(GY1<d0s_9O=mhO5%?=U|F~8-Xnjq%0V~^i4m`4Y<^W
zeqIww=+L3JSKp)v`^?HVq5*YB4x@W8Ma1ve`gj*33LX+PI${#LyB6gRld|-)qjn#m
zjS(SBcX8Dedf!TXXq3-g+kWGZR}0QG+adLK`S4JuvfxC?^$w+gCN<bL%((HM6D6Ar
zn-}J312&pn>QX?*<nWeBNkOkx>8=1*=i+vnedxyt3r=UQCoC)ib^%=aC4dI6tm6~T
z{7LXb?hW9P*f5uV5ugWME(6RyHwJX^X3*LRhXw83y|9fx-yel*Qi~yHRWSp%69XR#
zcX-g{XPLFHJD+?#zlTPyX5laO>La&cb4%eCJi83G#Ov;bbfu*m`AFU^aGpj_;v?0M
z)>wZ&c`v?Y5l!Xl?ZfsX8`Q50^yu4)S2k<*rks+JMnXS_?Aj{}4>Snn)AD2iZ+nNi
z^eY2B*itN?S1+VLlv+FgFp*K++TVvW=R~YjzwGNIJl>nzv*O=2P;%`xh9$X`rP^~@
zHFhlM+|Tr_%soWOLCW{_k5eL{;P1$JRBra-YVtUUt)#ptxYNLi?v+whI7BL<A9qm5
z)xG+od-3AZDdE$Kt_NT#=h80~v}O=c=F1$n8zSS=uNJhx(JD0N`RAawLzqjyK_D3h
z>^(Sl`L~^si_)(cG@w~V<av^u?7@6S>+0n?t7zj&NZeiOf<Y@F9AbXeyxE*AAsxF$
zP{DIo#{S0p&8~(JzK}_~)C~dAH&~Bk)~hcu6JOIte*AUyuMdDFh)dlL(6Vz<lAS)%
z1pv9sZA{gWXB3Xa0IJ^&kk?mYCF#l74P$p-K#81w6F~a|LldOZps%u5C`X%=Mc9uI
zN&3}=Hhi)K)=d4wuIy4x+3&LR%O`RTWkUNr1m!_ocv86r>A)dxz0s@WD^X!Cb%`OI
zVdl=nd~|TXtMiZz=@%F}Y=~NLg8uJ=QvVf9Nf_~tp96J;p_31Z2Hzffk}#WZS3;gv
zBR?nFsJg&V#Agp_NfxxfQu2Y|<iVw`Efmp>^WMbmRFYTX*o9^1T9$AX7$KJ9Rl1YC
zrF_qyO}g?3Qv96J2kG&tqqW2gu*aXr9$D*S$9!m~4K(YbEww3DC<E9qbLn>zG*H2<
z?)H&=j3;O*P&(w*&K68$Se8=0M$+q0Z0&Tx1h@7iO|vAA@Frit&xA~oj87Kqw9<!1
zIDIUHT~=*;B1!a*Y2!K;oGp6(o%@#>w_$}1M3;WqpeeGvgCBJ^8F)NC%%xvDXd)YV
zgHSk;;@-XHmOA)ZRF@C(hQ0D^^2wq;-Zm|K7Hr|W^t%e0Qj5nrBi1y$iA+PkT+o9n
zZ7yg2tIOwLU(%&tFK8l5Ynha13!F!plYX_J0gQ^nVvg774WYFc1RiL)&)Mw-|9%Of
z-;LmC0d}eE;&2H4ZuCYK25$zx1YJVHxTT#BeivhD7P}fE({I44QR$Je`Za?d6|=o|
zVFPF1g~#*ILPNi3&;yOAy`$#eACcVT`*>=r>joXvX8o|DMQ*377hQv3C1~xcL66*E
zee|MU`7fbPY!B^YtA)?6SjJ;7k4*1R>G=;CnjZ^bf(s|)E_GW#TPHyo3fHWCWYr0J
zx-{lgbds@M&Lt!@3M1@wdg8aaCnHy)-y<-Ny$?m3$AZO-Sg^eS1lHzz9DBLf+ZMr=
zczEwtr)fz+KZmtwvpvqcYB4l#N^Yw@E>HSH^q2GjCFi}WKNFp}w)11*)l&-USIc~Q
z6_gHeuP^u~y%}R{S+}<R{s)RNl)v)I&@U%E#AIE^iu}ZT_=nED?18dk{Srb8`QBqW
z=Uy1K`6)fhTU3-=xz*>@aR|HRZ$8S)dQJ@KI=UZKfpl0sw|?7<V%5ykE_26Ic2Ac)
z99mL(0qJY39ho?<MArpT&(VRNOa1Jx<qMco_nM`-5VH1<?AiYP%<WTXv8%2xbc};F
zcc3mEQUilG+osPZhb9`ny2Ma`&&>85M0+~3;6fc*D+-lfE_Ioq0A4@%$hEuMkAB;%
z?9zRC#ZGD&KDhn}aaUb#D12o|d#U!y-6VP;Ev*9B&tXOSet~Q@(Q^xlZOW7pcLB15
z{r<OgZp7#Ow$JqE9?ForWVcaWLh79Q*XCttPDR1hm4^<cR9M5dtGH5N+b*Lj75kLB
z)QEGd?kDK@09~LOa+KD$>lZBx+1QA!az~5n+tUXRca|T02y>~c5v5PD(a4QzvW>Z4
z5Y%G1)CGwgk;Pc}cdpPIC>E-#4|!0qwB4SvX+;RET<tr6<&?VZ&2!Blu=X0C`7`ul
z)|QFq;4)ubTIi4%q+_R|R(yn(aq5~v2ePy#TJv4+^(d>>uOl>6VJCTJDnr@8k}id(
zqT@e1lkrb?`Pe1R>P45(np3}&kc36+w^o}D^@qszS*0S|HIZdo`{PoN1c<E61^9_W
ztG7mnhlWCAW!!fnTbna>68dAn#?BB~JNGxWA<tl{m=V3nv(k@`GWrFDCbGTIvZd~~
zxp60C$`S9xYWPT3i#Kg{Aol4O6`Ep;n<zsXR%;6tZF5A+?5t$URz}37y3?SdmEqiJ
z95%7dfJnriu`2&V(gwLuK91YaK8S7X-K~kP?siABc5~)x)`X=j^X;$SWu!nZo(!pr
z3hm&>fMXc^$><8B&q%Am6{osQK{`>_7J7BU`ZSc`+S%Fqj{N=AW@LQ&<%MhxSq})Z
z6CuHQZ@~PI>2yHSi<0M@Uc5aZ8mw;FIxeNThOosS@#&^u!k50G&v>p4fl=Oyt^)7u
zJtPZFv6zGFmmD%Jc^4AQaf!ORld|UrRAVKsyws(KKv$<HUASFk`SJoA(ZeC*cSWo~
z=TGXsf}AmVhe8ow981Rzr}v@LId#pUV=Tsc$mn&DW?Q2Y`CNtAoxgff$y3<GTRtV%
zUub2dt~wMx#1=1(Vli?Sb3cAB-a1d=>J9DaN4|oboUeLAHp^nY;e&xuM?hx5)dl!)
zK*r{x@!+?>v7f$OeUua;7-q1#-q5Lnwd}Dqz6^@|+RRkjvx1~MnCpwCa`N&9)Qxg+
zok0p4tS%<x%nvm(Xc}{}4Fpzt8wapl%64b>j(Ff9gY~Nh8TauU=U=}l`51)JVExKL
zf<{fd=9FvP5A1>l>lY51$nbP6p=)h)gc7V@H)w*(Y1XcpZ^l7|=;sxNLgcOT<P(mj
z0WmaKT{Fm=hkSvWT*aJRm%c%?wsUX=t)(J?{DX?`M0!xy3p%A`QCZjkPM!P80%Xnl
zg@WeXfu&yARH<$u6?27D8vcUcc(>#H>fV3Owp7gJ-@#lZh6-C;{%^SbvaYqO<ABsp
z9njl}QI+<sgj1)#`1et+duRM_-$8-(*9qw6*pW$1r$bnKdrPTW(6ONX!pgOgKX&O;
z8Mg~*y=inNXl8aAua=h)LtL5?lUHBb5^ojPaVrF_`pqwsjSM@WJRQ6Ql=5u&**3f-
z=Ikyjqu>pW3;$}trHzngMJKFAde*N8jKdewW|#Oa4_G?}bIMSPi?%E(KJPsT5k$WZ
zFph;hbQ5h~)XU>g;&)&)YDH4zV2eEv_Z=uLo;6c~^=G3mUqak>AT-03j)kX`S=|?!
z#5*t=ZYN|uUv3r@_#HTHUx~7rakl7$Gtea7fzoo^AVQzrF?=E@;NxsfL1-&SA&+Ag
zn|@s7*QVh1L9n`j&zo`|4k{kKW@F0J+yc$UzdL^R2jFT?u)2JY$M>w86WBeN#IB<&
zFIgMCI@hFY;*IzZ7k@N?j^6^<k9SG$P{hZ^VttDhf<74#kcU4$Av52->y!Op#Tl%w
z<g=0)N;bSpPRc)oq^3&0FI&@2gHVeYtghyRUx4S&Nvlr}0`-o;?@+>Ls46kRIINLc
zi1+yQzq%+os2c?GV-PjdZpiW5h*|ped&UYM9CDngJpBS%VW_+RIpoD{r6xYfUJ;6|
z?GQ|{ovS%=2wN^>y^0)y9U@c?K}y!k{&_1E5>~%*&lFbP&(8U*s~aNQD+@&kHj(8J
zF}y>Hb!Zu&uG@3Y9@XIpWE_=qdr~O0_CnkgT3);S7CtusWq$gldnU5IH*ANXxFXpm
zLxpI^cmrEZD#`y{j=XaYLTiV4543C`QyS+%T_1w=Ujg<&iyQpu7MB<TW!8@L7O+H@
zXO99JK>K(%ZhK48%{e4)mztLUh?So3*}FZ3YHow3e*<SWnM(B?^y7o1egR*%Ha)Cs
z;rTq5S8U5m{UE9t*jo<PFXH3iS*d~afm0)PRfHd~_c9e;g!=$<CDI2bt$DkFG8Xzd
z6r{~~?gQ~%0_{+59V*z`YLceeRSLuOb9~Eo;2MJ=;|!v@3~4N}Z)cB2$%?wd&vJ}3
z78Bp_Gtw6-r+c;)*}r~mU$?mK@P<`%*4*h)NY-x>NXRZ~TVSQVw&MRhbEyk*zWQAP
zS^boc7Uv(7ulGN2iW98gDUe}%t%j--x#~^ZKeXBOC=kVd+YkHm53GfNtd)8Z6+R1K
zrbs{D9MzS6mbvhfvvkGB(sotBE|Woz>R@%<ANmd*KzUO-d*v~GT%&@-VWD6sSlv6&
zyYe`4)H<*`eY6%^c=W5;vFYlTOV)ad|7>##EnF!DDUE&(#cBHtUUAlyMl0X5$CN&I
zo~@)fDspptN9ixXnB2!|(XBm47io&{|6FeJ9kO3_1t6LoD{^}FZtbxQ|2gGQ@_WKz
zXYe~z0@C~>u4B)RwPbzS#DdJ!tp)~Apb!c&gWsVT(8N#gXijMl;Ij=!=h7N2fc+ek
zq0A~Alfi2BGW8l$pH+&nYn0|aDEk|o_kUji4nmn;2;ZQ|wm)Edk?<vxdLl1kZ>}i3
zh@99S$k4=vHf+?TfSmo<jJ8=eIco@NHx{fe0dxS%)j<hy(F;iD^y6nzUGV1shQ~`k
z{hj$B%02aq{g`XO2W~Sv5558wt@H*CvE@X(_plm6Ah4Z#D$)`|W;wuoa`VDT2y6!}
zEnq1PpFec)W0Xkgm;4zL8=jZ#=@sVBy2&T5NLjiT#8-0Np=t|XI>_p}sC5>UM(Gy-
z8uAMZSXxFDNVg>%+y>z8F8d>RIjJ2$hCY*Oq5~HF>OVtLafw#<$+oYMW$3pOG+`yn
z_-*H<D5P2aM}iGt3S+|7K(}v~&4bAA67*SyBsZWcHELfOi2P2(MknbP_iXwKCDr<s
zf20i`efj#Gx{j*dg7r)POmK7>;(j)v2ULk2s5CqWIuBX)L#Y$iDH-ql^}7k0QZsKS
ztm4UWoEm+yEDA09{RB;PvDA{N{qoYVk=8LXze8Z>1`29RZs@C|m;Q&etS<iJ-5hFp
z5;7rKWu#^Osy|Z?aquXoL`aXcD9Gy9{h8>1<u!H<zK3?>^}7n%(4K+|DZ1QElH)gI
zB<i<=ooYv0f!ju0ZVgqVAIsx=2bk@Z1qWC!>HLe<4i(QFb(x=6YzEDq7!q(FZu+Sb
zv_fsJ$9D-RSP&p*?DN|%P#M}`oFTKNGfk-=bnBVfzeM{|>he8H84S97K<|V;9oT6*
zt!cRr5Zkkt>^sv6yj%&N9c+l~<O6+`@KJKW=QRX6V^^kgz=d$9e+m~O#oOC^>KpCM
zge@(%x`xlzgLm_T`BYO4#18Yoa@fkyujw9;@c6J>UB~BL5&d$`ywn%$W{m<{4~XvE
zxdvR-M>I-)2qb-O{p!B>F5aQAb&@!g<Mm#b0DUyv`V9gPv7sae(@i_JdK^0@Q&I6o
z+yU2;72t-YTV3wQYm0rN%j0BGMa9+WKdCntq2`}Oo$DsIy5i4??#|TfRN}XEDXUO{
z^{X2F5D~en@N}_0_J=aR7&UK_VJX)R!pGQ3SX5JsjH7~}nv@<##+L6q9xPTe6IjH%
z)$IeF=#PSXu?-vVE`hx;o>PC?L2D7uIbyedIiS-ClV^CfDn~X8lS?kRb9=v@0c|f%
z$R9Kx#0$569UwhNC#TD8>py!B;%Xl(60Wt|W~=o?g|u}buJ%y_;mXVF=%cGDLR{OI
zD{@)Fm3uQBEEX{y#7(zLd)Yv^Vx~!1?9L}Ia)RT0H`ho)Lt=5w_k8igZctt&qwP>3
z?~RkZ>q^zH3|5nF{my_)6KMT3w#B5TAX9Ve*8v*9aHnWnl~2+@q3wKLtz>b9LsXu8
zcuaLfW!sEZRF<NA<5k5QBU$yU{|r6IJ4E5dVh4f@&8=SmXaL(rY-bJ&3snlCwXYaJ
z)Fptn8~%Rdd1_iZY?9anB<c3rA3%k?3#ZY-sq4jGTS4G=AvG#fOI+3k71OxYEdV+8
z!6!%?4!D{O@mjy_pRtgkvpX&aCSIr6)cSD%n?m~Wfll4(&yv|d_9kV<;Tl-<-9C}f
z4;)arxm_~_6`kL4u{&kbGs~wUJ~r<93vG1W>b`$?Fy0K)-rYZV@%D#^`L<Cin9s`7
zgei#GP<awbEK1ES8Qw`X-U2wAsJUx4nT_&dF8A>935%$O>l`mplin|5{p7pY8I%2q
z_u@M3rh{?eAkD2`DrkR#<=(6*pO_m@_@sGWGE?e6!kenPPEZ;I%lHz_S8~g5n<1vf
z1^;WcmcAkMGk2@21*Pv$btQf0!_uy$5v(;rf%W6WuPu)%@)J1oa_iR(di6#<&F?)9
z9zR~x+>B1&egfx4nHESR3TAV|zGHsDPVA=j{tn$eaO>9*8uS*uQ@1jgzCy7}zlhL;
z1u5>0&%-N$eOtF%J2&t^i+ih-AH>f~{n`pKe5!9p7=K=(WkBJ$fMQ1ZiQp<GR_&OU
zC`Uh@0{W$d9-)DUF5f=O6^N~!^PAXc`@O*rWuAc&DYt$(p@j|eywjO?_l2U{UfG9x
zbNGF#t!Up~Q2F@VDZ4{#doDGx<<xA(xKgRW7Oq>rBcP=gJ3F&ExpTokCy<5fw*|D&
zg+nmP8`6)<6p1nt{mMcMTwKF^u%*F7D7N;FqJ``=a+*JLuWMO~2RG?2(z=5{O4d6(
z;cC{k?lhmU66p)RoSP1u3v!O!Kj}q9OkLDqI8uauU16`@331&&FU-;yDeuc4TkR1t
zJ^iXe4>&1VLjQVXtEyn@)~)UhXc4k^e5E$MI)sH3&fB(4LSE?u7c-Rn8|p@z@x9|~
z)~{QqFe9Y|ey{ea0iedu9jZ-v4>-%jj5mIyQ=z)~GPQ)_YabzazQDH4CGkIPJ8~xN
z=hBb2as2{9+A{ZM^wv9&Vw@u{&}-AEPeEamTfd^v@hS6M$J*YpS-W;oxBe)7Ro51J
zSsPfS_E}?(nzakJ+aueb*t@<>X-fKnM5XCF2ICWn3C6DR5VPU)X`|tDd3O7kIuqEd
zi1}y#Hvt_I*!h^kRY<j8CAY09gHk+op`lYni3u!!<eDJb8fsUz-yK@P3DtjYb%~+)
zg@@~}AKf=?TC=hNtdEkd7&537O@8Wvh@mbq^g0e^yFM<+emn7TWfZgYA1EekW&4B@
zpQ8s>Ee?_OJ%))a-PMaa)yrG6&XZZcbkLMp3@%Gwq^<=ewoOox)_8EG<?Qv5pOi$A
zMO`K6m_i>F5sS7~`VSh2c6MOMEnn0p>-**W@r!7=q5m|o2i#f0N6Ep_H8-yy#@ojs
z3dT!%F1oE)h_%MxEknO3uy_9+9l(}QxqN@_AllQ<0j#|cFo0oV5Zvc-N2Fo>x<CUP
zg}uOLEAk<W)-MY*pxONbeib^oPOip26=Jiy;^TkX(@!`l_F6P)T2csM`&5XX3Fu&p
z3L$8p3b84!11%_ojQOK6CH}Bf%`b0l4l0c~phywnc{~FCa73~g>r{jXwu7)g;JEGq
zVv<6jvjWqESfJc7zdd<`NzP7~ygY^3YS2@g5Xh|x3G@2CTY*3W+&bK!pxs%Kh7V!y
z6sr7FN=7{TaT?%y@%sdJcnA`5d%bb_DCeLbkEL-+!5S3gDeI_IB*2VymTa>;0}p5?
z-F}2K09ido94p3fUN|J^;-hM10sE@l)jbuoH2kC=?g;_wF>Z0~53+zX`Y!D|w*xMm
zTTUzR9BBg$`qqI~KO;nqpui@mh;ZM85JxOL?(KuZ&yWT)O+-nHjgu_sinORfNdu8j
zJV?UQO^<J}j%qnJ+U|~&=#P!Y>R#mI&U0m^08MgBWq)&nT+!+EtA9d>b`Vq`N}8Pi
z@5_3?#JM%GUqm+D66DkCGt(eQJwlQTmLL~q_`bB2R&W-?t$qDTS=7_aSWbWfdQ6E%
z`gBe_VGC}!7?Y9Rx|9bW{CTc3z%sdIu762I%dGdL*?A<P9vh1RHkO@wWE4WwV<SV9
zW+&Cn$cYG1kB#<=wC1vo`1o<u>664qie?-i?HqxW2>4k4O!c55HCHvLx1nJYcL?7b
zj!?S{TXq%5$*o5H%?*=N8hOt0J$?tlj9Y#BLlj=&BN6A_I3EtU!>u$`fRaCtZ9D~e
zUv7Qr50X6&A|ZBoFenz-IM<-wKcZ;kt@E}<ev(^FD)2n>V%yK#PW|4H{gBV#`~`RC
z%m*TCn##JGHcm3RS=zV*RmIKJK0%vqq1n+RW0`<r>>ygm*}4}xksH~h9vj(n8Pe<|
zuT-%vLeyiU@c@S)W07ok`hw`_95rAg%T?(iT*|R%DIlO`Nps>8U`5<Y(Z?JazL)it
z6!0R#*H;7M=5CEC@FYz(jLG{kLexuDnS_$RsGa*vC160@YS6EYEcum$3>Z))6M}TE
zBnTFTFxFpJmhy)bySF1qy{IT%IVQhWzR0&Dfujs}dURh>GDvZ@pJ!S42a?fgl>PuE
zO-}0>ya7S#QITYn=DWklY%$1!^tf2g%Wm7V^(<2HE{Kdy837lq$hc-Bii~M~|0)@f
zle_HY&n}sq(#YL22Bt-bdYLM_k0wpe{d#5g02AUac=?r4Hlg+zqRxW(j?l|f%P~Mn
z#`n5h8i647$ViZqB4h4;0Tro7#+G1e;$}^RldZ=^qieR{dQ-g0h0L65*zRv?7@{=l
zl*giaf~^ehvX(zYKU*1BzG#%sD)#3x1MZ%d25_(Vgx+Rs6N6g6EtAVw3l%PLb@Cn1
z(+ZW$ix@j{f`U^O`r#R{eeS-NPpP~2Hrj3ofP<gL?@hy!Bl>Y_;I3);19XYQUNL<4
zEhL{tq-65Zai<_(ku*~;BR~yq5+FO`6af2<-aQ`;Sc91iFiwOUn0ZoXB%cN=2~Hkx
zrp8s;S^I(fglLeG0NHAktxrTLU(Vax6iKNOBu!8g(2hP+*L;?r{F~WfJ7<!Paa}vK
za)ohC(tViC>0?KWo=no_v)Z+bbBAk`8O$#`qlVS6n;*E7G6XB;FJ0U8^1;G7W!|)q
z6ILO!^v^<&ux9$M>0#NqhjTZcd<?!=*ACr1B?E$07CJq)E`n4?NduDYSmqVyd|lkR
zI0UJtB0<J7$QB}G?oZ-=M38DS5~Q&P5Fs~C?|Id_ZfVbYICo#kpDvBlf3|CD6d19c
z+q_5-wI6p}DrX?!+@&RdpFm!?K&df1WsZh(?a6&1c5Bm*yfE7xl{k7T!`^K&N5i?c
z<O)zxweRnG+C?T*ICl$40T>h@`S-2kMkbfNXE=B9$RDNzH@08XjFuwpC@HMeAU|0d
z1}!Jq8HhOS!K+uT1bXBy9r+UxgrMmq9vvgkM?cO)xt`++K%-Yz5asZqtd#<fPO|QJ
z^3ZCIk|8m`AWE4;)HiwF&O{ne)6_tf0oOhXYy)PUyJzH21CpheYq@eaAS8FW$S)i)
z%f5%!qyna{@dPG~n7!QzwD?1*SAj^2>X>O@%99=Z^UB?5vYksd8oC(ZJb-4;Hz9JA
z*z`koB&IrS8mRJQM>OdP4kWoFaFWm;CmA(Gi@dnuZ80!(?)H$s88^;USSf&rI(2*D
zu3+fg)ghm#o*s09F0cPE{3S3W?!u4)5SZq$_RpWAp=*%Q6p|UIY)enN_Ayd+XWAYf
ztj=Q1CV9fZcNR@P9}Qfc#TszXx0TObZ4jCrbs|fcz*!zoJ90GAqy`~PK**n6Q?t}X
zVrsCGP-Xt4sya9Y5>tbaCLk0u!<3$%gG|<GMgCZ6q(~xzR{WVU3y_t&+vCsR+2G;K
zzkHKvF+x=*v&PI5D)7f|GGA&7f)ICu$DgcH5E{BI%|Z}_xa&H8;h2b`GXEL<@f%=C
z+{GNfh%(849CLjIV5LUMHtCUh4d9OA2d{00=0=Z|1}3oi?kOrCLqpf2CYbC(JG1|Z
z#MEOY1B8aTG`Pk&gsMkP6ICYs=sGi(TBuwS>vYBbsEHbN6#V{^3P7V8B|KKN6kPn(
z-%Do%#-vfY;{gQ5bpG3Ey%454ef45WEGm9-Q(iQ1r>7$(iCL0~DFIfAyZJ8?(m6kV
z0KvfjJhp16<&C+#U88u%BcwYREdkpdF8@H@lMGka@X(Tyt%m47*845Otr*&2$+op;
zPwSo&FSU}T4tPcbs*#d*YVT%zUBbGTz@sZE>p-XFHiJi%a#!k4t!{0p@*hyLm-|3`
z0_zeaFr$3O9^kFKaA)r0kH6k6B71*q$leRxsLYsVlap0l@#8+>Zpexjs=LEtmMxDi
zndIT!3XX=YG>>CSJU9s!q}=5gAA!cBh&XDNMAKN#@vJvNm-z8yBpJ5zygXc81>}+Y
zP>4He^z)12dHIf-GtL0R4poxcl9&lwKA;#&3duGcx8O+XRPD~>29}|&3i80S2@F7%
zab#)0TdN+JpGBu>0M|jdMGQJponk-<NzV(*4*G?5(rEL8M^=Vm(({R!l1Zk{GIea5
z+@Vj0|448&eLSR+-8Q6L=+N!>g`U9CaaUXXn3}19qTqNed&-rdk~W;{n5~3myW9eg
zi&c5B#FCYZ!%mg@<FVnJ#jLKv^KCaQR8FnxS|Qs8Sm})9EeDRPaR<RFb7UTtrDK8)
zvfb?zj$oA$*@i`>B-cVS7`7#ttGaZEhZX0mN{hXDk*vzVY=ffX;VrQjURisJ{Df(e
z)<xBPl3t&ls=W!gTy-6hDJy|eKt}7uC+TLdL-HzlYeAz*o!6^l-Xc(~U|b}?#X^H@
zvj;AG_Y{F@1z;0Yw%Gg4YnQS>Io3Ky?~}Fcm=tUQ7hFHHDX=Wz+{dTirZ7{20;E8$
zV`<J01Yt(luJ#K{#UUQ!vOV|vgOC4487hg)S*)<-25?Q!&0gLf;^<F9A@SLcf4#k|
zcucK`YZUV`la*CaFjYQpV<;Y0le5gGm}QBMAnE+#y{rWk530#n1C;4in5{?q=S)Pi
z<%|bFt0u23RLKgG&408T9D;G3rwP+1F7-|jMZGz^-))NnyaF`YN(qKMRf!v>=K(H@
z>oBd5(*R|SY?wX-)ixj0A-5$j$62Si{x}P^h;x=|y#*M7y7I`Jt~k01WBF~HT8~~=
z_<~RcYH?kreJH`C)}fHFm^Dc!i|Op5w1u*Qyii?%<dK#67k0rWmYG-!L9>C&l8yjI
zt1d<IATxfkjMLHst)r79A$KsWd!af=yPCYE#R6rrg0yv}rr8YqEZ1Dxhjwjg?O<z9
zTF!tMV+ocN!O?+hEA0c;nlyLxnzbpT#aTOW=>17ZT4$&sXkll;kk(G;4JFvpR$Se^
zD5;jJlz3^KYyhx^w5MW9Ce{NL#@DO=TLc+`UaU2RMJ3yv9{t|TQUXU^C#*l}!hPg9
zi{}0a%u8LC#Hp6K8^OE|-AVS^x=qVzR$ZIKp|avz@{UqMm$&S`ujRV3aIS&04;$mK
zIgevAt#`4dzaU_}z-vw%mnGQ16RUl+3F%mm!jyiYfWDwdp8^O~FZL2Dva-YrHHxB{
z(~G^v)v<swCbkrRb9DJ%4<xZJjVZg6i^kU_Ov(cIrY>mm*n<aEva_q(3f8smoAWm8
zBpmP#4qRhDU*37X_qOXjOBFVmg^=lw%xLF%YvK6ovH?e^tD889i5Z@WvmNEeqrVt!
zTb*t_f@|dLgK{26Nqb_WlS{#P!q&1$<(Z4%nl}4@<>W<`rz?ILo)zKh5}6W6bP4ji
zvpxG+9@w^s2zAAiB`?D*8c@u1mbP{)tvEG>VCnzxuu39(w0o!l+g3^p7OzVEaqGW=
zmWlDOx=fB^T$9t0?a_&Kkq&e@%uwxxl<gw#*C^8k39Agn9@WOtvR9(;g?vrj2vwKD
zaV&?n*kH>VTd93zIfoV!Q-9p`?mF9;`-|K@1*oeoeX_>STqC8A5_KOe$n-05fxtN{
zP?tbi#zlEFNXa6;-uDb}%%!(oWn7FU<w{f5@paV4ND;c+_2j!U@VrH1o+E*EgD?Tx
zcQI}DE;`xoUm^ry^9t5xFWpv4Dfz~gefw{xj|fgdT^D5;1QWMqfDwHHh2$(n<CFnN
z6Iv8DFXGaQLYlf7J*%|`u7PW~?8lv(xVD0AY9yrC*cHKQk=TNj7uiwy+kRugauL{R
zzy4SZ_ncF9$bVigij7d0OVPBM!cz9cjsh8>O9dF;5T>vBkMV=S^r>s7xKE&k=7=+2
zjYhamjrhoSOwqaI!JfZry`SE;6wMJNSc}mnF57sLlF2$(l3hpQYVp|v%dA+!{qsnL
z@$#W_1lMcXuNAw{YI||A!|APv!K*+k6c=UofFkjxBM;({pqeyh8^!Xrz|krJ13|##
znkoAoJQ*$6Y}l5%Y!!J;5y5p&)<T7=pd(jCcC}Q?(b#ERkj5Ti87o8wIj_p3SwIWw
z+A5P_1PpXLvR#537%bN+*}oQ;L+4hPb^yAa5Ojs4C5~~%rLL|rB77sZ2OYge&dq;|
z`sskBS02@=SdtiQxv=Fbmyg+^p1Qeo84^{=SyNQDr<ZJU$AaSS(9iQn?gS1-U2J7e
z7Yk&NU$uTLGYG+Il9uuX)LkNe^!>I7R+F{_Yabigsx7(sQX$&dB%bl}rA(kL)zZ#e
z!;(pQr4!c?6}}$x9kN@^_)7wFc5BClTm`GGw|3(><~nV`A9Fo-5^No;x%Frdsg|VW
zbfB)h;&iZH-hJF~ujdJ%0CoKp*_Y97*>H+dq`6V3LP}r>T<>B(4#C8=Pv~te>|6Wy
zWnwNt^IA|c*U$npfvIs8$86AxjjA*z^P&wA9@IHoz#UkiQ^H!uMCCblVKm>Fk@mMk
zyT9&-w5!aYZS7LpA!VaQ_MCofb-(8&)}n7Q7IP_(u|&+cn8Z>st9z(zz<VmB$OT*^
z*Qwa={Ndy3wFi#QM4(C@o9b}U8bz|S%;)zn0Rb&Ui^8M}xMu(Si`#=NQ8@xTC(a*%
z*`$e~cksFfPk^NA>MLvbup2`4zD+;1B;{;Duk6ZLlThv<<l*->Uke3>t1h@QMWsz9
zPOUc8p2xoai1IoTm={))zlTz^X_rsDq4~6B?Qf6*l=L-aHKMs>Rh{e29&I^rUQnk2
z0H0ukiaI^KepN5h1pRnOP0~^*H&c7IEhtRadtsf>#ue95*e_d6XxYvD^#11ekY+Xc
zY9=3|tYfDA*bbSNCSMIuw6@uFXX_hFSdOty?fPRZLk<-5x}@wJ?^{URl<8Gj84a0?
z^IyrjZr>gY&io?OeVIJg#ps2$1WOm{6A4tS?#{%)+WTyFFsMIp)d=9Y^y;ikHGnn4
zl(O5eA!)UETf$q$=n0Otk2#xaY%aNoF+$z0$q46-Q4wR8mv<7#wuH1pU1w!O%0-Ne
z-V|zX87yyHTFJ6Ge)+(tO7|_b(Nt+s)&!-5R^Y+LlSO)>snX)CiAn|_<uPF$?;NvK
zz;V{80l%D;PoEOE9;zrGZAIu+S$SpkTvZVrLb1BFLlC%DeI%>5H4-o8$eE7WM!BHn
zR|SrD0x?Hja7FYbaJhu%>Vmu}ECq8mrf%qDL88r>uhvyWh8wO)T-x!GP2v3{b<+UD
z73$r61Y8<CnXTk#TMg)PSuTl*Q1^AR#?NZesp~HLQ<$vwwMQNRl+dfUG7hIbwjki1
zt}^{FSU81i5}5X9P}9qquYbsd3_+8@l+ekQ5SK2!Kfwa!=<5{KAAP-tMYi{z_rE$u
zZw%5cXR*TRF|Y&E)fziK;7Dic|1MSm<|Q0#0a()zX#Bu0e$lnrLSO`X6<0?6HE*`I
z5-L=Dlm={gsOzmbC9F?bzh~N!=6;fmoG;z0zv#*XU5Vk<tK_bUe5k>iXhX$~52cvW
zD1fy^w4WlN1#jB!H=BTcTfNdNW?;suL10A1o@07}9aeSSl{s}r2_9|K*yk^{I(Ba<
z`I5{+2<+<4P#$%#1H==lr1PzfvlDj!4y(IEc_j9+X}7x2wCxC1lf$F~)U-Dw?As1j
zOygMWMD@vH+74yRAjv`ZkW|-8{7jGA(T_7Xy$Y-{2C5k<*=7Yj6TtQ=<Tlu2erz-Y
z=tZv}%lycoLGlHxJvXyf1};Od7K;wL+H`L(qdvJ=V0-}62K{)AC|AIwVM1j$f;uL|
zcQYR1F&oQ>kB1Qv_kAAF!g^$e|BRC7=4U93ln?0Eriamh-@NP3bT8(GbN=r0C=VM5
z{rInFt&)wMUJ8O%yBzu`J{CNCZ(D2YX(awT&c&S%?`?jkywSLf;ft?+k+u?6{qr1I
zkTVhWi;pa5Qugu%$k))17uy*ieZtZX9R(iS=55E-EZxNk^p~(_8R=v#fF{SaCYmaU
z50yw(f72!_MA)mnh209QvwXPi4+P5k^alo?#I$*3<k!Knek1jYw^+8wlz=Y6RlGcC
zy<ATbsV?0zjNEiukfh@mZFntT42;w(-eMbHbjVFbY(C7be6_aok=%MdfZZ*jwzaV=
zhZgI!YyR@AiJXr_>J@P@xru>D(Vxyrc2o|*k?LMm9z~NClcMvG4;RAw&|yi=Aer^J
zZEROSnLqovMpfB;N2(iFd1N-insh6-#)`a~Wlt2T?q20ZB|Xs1P8QebR<WRsXX8&T
zkuO6>sykU(_-qF03sm4HFNY3qUma+5m*A-FT)q0Cwsb0$G-;02Brd7M_HdEv(k{ad
zt!>CI=0?}6U%z_tn7*3=#)#QuV#hQsfHKteU8D?8Qc~WmGhs|LgO}|>AG}VHlvXcf
zB)sg(nh-<wjSWkt$Y@<Dwn2M8OPiT$Wa!Z^9#lzf9yINfv^C?NKd+g#QQE*+9mFHy
zY2RF*4Gde|_R6CbBZZI*d&a7sO@LvmyI*-xSp+1zW&s^l_EgP#Vm89pqB)yOGb1sO
zX)dL$q-C9A?gBUB(hA{(&s-F{e=g}I=hUeu<fFDoy}~bsODbWS@ic}*n(4JJ$NNZf
zWhnP(-tz@X@(+&JTma&@)4ctVooQT*<D1|7RKi;DbJnd_0Y+OXOd*n-r)L)0fIyvI
z38XSKegZ`it4FGM@0(e?q|VX%1oZ?$6tBuQX|x;UGI}LnY}cOI8Ka1#g@#p=RsdF@
zZk=Ul!OUflc02qt1C)|Q>Xm%4O<RITxoyU#5AOmm6s*N(hHGqvN?O=GujeqNTrCzG
zs4$<)`pJoD))JSu2CYQg+_^TIQ@~S~Oo6{AfNV~$0*t^t$&sXtiIqN?3<&HDCH@F3
zZ;nr$d1Vx^GQH|A<IW}CwY=GTS|c!Tdi7r>u3he7FGYIYN|GA526g!tS*-~x?^?cb
zZ>)f1b?ViJYcN6WA|+eauP!XUk7U(aahtI69pr^Wb2UV=YAvw6pwhPZhThdbLS~>v
zUJoof&zW*)Gbr$g<Q}vqwfa;o+iC{|9#P|dpDrJZL~_sBD?!D5i#G3%ejm-1R>*D1
zd>1oTNvV7GCW`{ewR8Uc&{b*?6~Da%*i4O7mwcJlPv=3N`#83h_8(Ms0Z^u1y%&vK
z=2P-#8Owu6pjYZekd%E%`CP+W37;cWO_rMHK@#e@;%7DjKB-^KGgV4y0rFE_vff(?
z_@r*UWy5miGWKj8&hu=dynPy}*LlmhfkF|B#h3Eto&n38S+*!FIs5laj6lL`#az!v
zjQm-^U9_(BKS<YFLD$4(l`hg0CLhx0K7!TcE@^|ElS;5xnr06G!Pe<${jpchmRnzM
zfOfs~>b;l(n51m>BuOtV$@?12mtMh_2i9hsy>#8Ycl~NoEMap=lDg)Lmae1g8^=PR
z!n8-?*|LDhdQG;x;))(T={GS@w@z>CGt!W5nQ=)zyixbKH%M5g8Tf>?&YA=!EXnxc
zJcOzlZdrvI3bxtHZfgUAm|oGB!7Mtl5k$SdEhHP*>C@}1Wq}&2T=`Lo!pAx^LIP_t
zmvI(EpO$B9WCpx-s@5NG<s`X8hF257bm>)nnL1!0P1Nk~&zDUCqt~nXGHjK$^n~dO
z{j3VO_!p^H@#O)veSsZ#?iO440q`+;6<;PUMRkc^iC2$L1<qUjG@ltLX{p3qq6FK?
zHQ(E<iE~}*k}n=s)a|wvWxSW@cu=Ql`St~dta6~q8FQ&SQmtmVHB?|vneDzygdY5p
za)rE3_Z_ATw{Cill5J*w^40#NRhGxi%9_1qjjyWIES0u(&8gy!Z1?NM(}A@v_tv|Q
zT-;dhd(JIb{B?;Z7p@l(V=Z=YJJU|3_@=S3PZ21P<D;~5hlA~7btRY~EaiICkdpm}
z<z~!K1oRtMB3A$}p>Dh7MMv8;P3r#E75HCu4VV{|Jr>O@&ptD>N&SB7rbg|Dv-@YH
zx){uhZJsPRUg5S4@aKAGjqZu06pk<IvM|E{S^9ulbpEe(m-%4ZSX~xo$V`)G9{`|}
z->!51UXEr_NpcgPX&P-Brzw81C9*uHIRn?>MYS%;BANGG%iS8utYo@@PTR#u=AmIv
zhk!jYbz?3ss`t!OF42e${~(>U?BwX}l-M7=r8inW`E=WEEADgFrmhon1r#thALTHz
zsloE`mXtiEawpovL~S)nZY<aYK`Qs5O-NLJSvt!<SrMdiWo$yCCB>r_XYY`opdUYQ
zWj1X=im|iP^*ZmN*-_@v9zbJPRB*TfW%ngV<JO=mdzYS4M`<ZlJfimm1gXJOf<)VZ
zS!<6Ri6EV(4ykWK%2IyU?aFhcOl96o$~2ZF@*;9h)5hLQGaMnEkp2kCAjNolE8-B!
z!i35ZUqffEnk`49)UH*5oZ00H-bi(Emoaz>-mHv?J*Fe4`Mr-0jsR{{UEgIOGtW<@
zOOi?TZD0Q%E0N)-6sg5diri=mbmytLeGsS?KM54|vzxkg<Yxpb#Op{UM_If!4(?B!
zP981RmsYGiA`F2lNos+jek?O8jwpzRuSZiheB|?XN8cQbK=p`ffXY<8_S?-efc@&S
zEZX{}#R%J76x`mYXHzV*<n%H%SSX$H%T(F)|G9G`zvNLEX365c`}J<v;JqZteWvlI
zm|$ml?Wre`5}g>PM({K-&H5u@^i!rT_}Lo0mre{-BYv8wXzKUOySG6KcMMd6qtsfC
zIaNW*Lr3S_m!_QoYVgz30Z;NHC$rRSh^9!%PO>E9QmdTb?0(kc7@8s_ISJFVc$1rh
zx<+*Cj|Q*7P9tLi+Zu2C)hL5zU4xrmNJ*m^*ZoipjoumaV0iL?qFuQ9)xYa*jh>^Y
z)9U@vQ#$r3Tw>u|F!Sn~D$ns5n=7de+h6-zlqF13Dn}!AC6$}?U!$ejWcmKu>ViL&
zv_{TjYEhFJC-8N#SxYtm#B^y9GY$~*UPxINl2MD8aa`CWsmz|W6=D+Nff=a_rD%GL
zvOM;7t+bqZk#mUrJXdf@bxSM{Diu_)b&cSc_Af2i77bsEntYoRd-yxUie!=UF(#-M
zHRA&OJbhg&Yuc@V^e!!a(n_ECWhs5Ebv*Sa7AQwgr;Ylhr<Ld08y)}sbSxVk^a^BB
zS3wb(SmpIlPg`^wv0D8k)d4-#ZLd6tF(*<>mrzPfxqZPJIY&?RtAU0^F?FKIxuEbj
zjS;9GLCr)|nxoZkGyeq`r7nFkBxRtq+wO7qwoZRt`FnGuQ)K`(bqX5?HBP@^4U$wR
zfSTzD%I>@Va`GqO@Pl<&YNcahMshvk;{YV74o$7Z$<nD!{=`ZdA*v2VP1KfP_x@<5
z21P8R;yCKGDZd<*Gu-77cUu9^r!I72HbwapTib~$E&1Q1)|QwYq0}`_9HeCX0ka?0
zwu(l0P^W{!NeRg*U-|ug$)2~sn$#}{dc<V=B$AZp&J7!YFm=MHk&Ob(zdrv`J`W2n
zsqSp$k&`36ZJ;kAn(si<u18SVHf}=UA>P*H{0!-_lTH!HmL!#aSaQxaq*6VC60BT_
zQ(^YHU!>DDrcyn6Qc4Cz{o%!wYL?-1{B%yfPkyp_Vhh_qBQvqR^Q>1LPm_NlaXGE3
zYnzyNK4oO2(X*^hPWJS_?lSjppj35rlVMXhC+&H^>Q&%L)#XiIOw@|}a*BEdk)%$i
z=Zp6wseBmRf8M#e!1&e0O@^d#w$HPtX;jbS8wrx8pPwe3AbKk1P>Rg*96c(YZxI@~
z9!2q{>!H|_s}QChM~$RhS}s1D`1fsusYg)0tB|eEapUGqrsSFa53f!oK@F>?7J<>(
zN2Yy|cI0gFQplS>>L0Y`p5v%<p8RoCT9M2d@^62O^_;Bg>Lt^fn1dn@Ei6c?X3BOF
zC{<m%<OMC~!L*h7UbffSfGg3cTOwCtJPqh=3TL~L**&tz?X`nTs>_y4Nf|*=v$Asg
z!pETTJAEmnz1jN-<RuT6ybY9&jG3g)x%Y!f8*fZr<fhu@NWL97zfcXbn)1T3#=k44
zI%gRxZ(163rG~Mne6QxHMh$85=*L59u+{8AD_ZK}-RpzVOev{K#ldDxs}%E-H+}70
zJ#i#;D$^fH!J*5e6DK+YIn~8VUODC5r2Eeiu?W+-spZ3>%p^)0`=*;6mm^G#MAtaH
zu%naB(cuM`$h+;qCDm0*p7w-niEB=~?M&jM|4m9>kBpwPBXxli^Uy}S*?Jq~CYyCL
zb$J2oU0t4J$Z5C|(L8${nm!W{Q{9ouf`lc7Uly*@0!@+@F<BTzC12yOkDemkrDl_)
z#mqQ*k;>VIK!_-HF26bs!jw)$l2OS`-b6CiVQ0T@Z-H_|b*jNHQRNls!dDYfcBWH}
zWC|)Le7^@}s1J-lrv!;XGP`0%AfI4v-Ib*^h$lKFNZy99#;cOvwBKgztOKR404C^^
zAbFd@3I@>bd8LikTycz5mmN_c@f^8H$zSF#$G8!wMocw9kyQ;}n<WdHE~o#8Zq)>Z
z{OY(O$sL61G*&;Tl%`1xICnQ=H1GuKHdLflS3vRN0P}5P^3TxZYlKvzPb+|Y^3AKo
z79>Yhr*H8`RO$5PX4+Jjz`%9tibzPNOqNRtCVJz$rLPdCMm#0Va>f(W0_NkO(-je>
zMm#l}zJg3LVNda3U`pz?Q#9$cB>@ez#)e-@Aykc=*NbXxMcRS-M9$p}X#B)dj`r$K
zQ!G%kcg(pHEgN%3|L7E8V_)5A%7ZDtcY1cqmTAC`sQXJ98f6|Db#a(kdFn$n^-inz
z!FXfqKwg+_`QV$G2vdujahUI?j;}sz4W1*X6Vfj^t+N+9fGil)Reoq7xTH>v5p&5@
z3>4QLJ$HOySK+mmteiRNlo=Vz5r!=DenaTF`M~mZDvUg!wl}e@bYg}4%Slv1=0#O*
z9g&q%;~!LFGbewIFeIuLN$K#7QVGfN^(#^Ceak)bqH2XvN>Jo-m=@KJEJhQh6+{Wr
z@F{{beLF61J2ZNY7|J4@;q^f;mxdorZihtG;3-4()LV#!@}Jebei(`BWECVo1!W3Q
zK-8E@Z*E$m+Ef)v4*XJ8PIzm-?3Gcv=n(AEDKawC2OqK?%rrLIlGQdUmrkLP+1?es
zTrvLOn!R$;>(Z$+GC_-36DAkP{1MQkE)rNtSh{UX87lHECz}5UO1NA)B}ddPl|9wR
zkOdlyOTFPenXWE%n<o;KFs(3c`|CS#`K!rs#Z^*+u4YGDAm;p%=Vv1^HP}j+M&C_g
z<j)JF0E;u1x~-Era#W`M=C^UZ(a1H3N>WlPB`r&KzRB%%ejH7md89v@vf}?hVd!s{
zP3$b6K)M9(Lx<v#Q{0;<w7&CDFmiRVk*Q3WLf0K~zcG?hBi$t_X^kU{JLiF!U@O+8
zQ)^@)O7rt@_|as*GS#h_%#ovti^KnxON$^iLMVyJcDSUde4*-rv1op@I7w+fa~@))
z(YP^<y=8EmQ&zWM^6-&rql5{XzhKU5;5KzCjm*}%3{sk*6g~GC^~nUx%c;dm%AJvu
z8#Cy~0+vEKS~_jhCoRjN^U=!r+>Z%TkW;J1sIg;tWBcOb%a*$2)WM~$GP34~m?>%W
z_L+HKTZ88`s#9lVP7~l}<(ffjfzhjbELoCT8@u-4<KACinf{_5FQ!I<%MRLsd2Yxv
zp|y0!E7+xOtVA+;jxpKgwD>OUu3nq=?FHkX@@J08Xs)z4O8Gd99~}ceYKP`ZD{>Ml
zn5$2}nJc&dV0zHVa+w}Hn39i*nbz$tvH&ff5~^$g%kOuqZ-o$!rOqtO4@;%yhkw+K
zH7sA?sJh08EyNmA=R<GnXnS#YI&k$0!lSw8%v4=uWMQt^D4##vYLZTVSRmM?Zlh$F
zDsy_WGV?V$a|GC@PL&axb%JCOS@I<ZhfKMMP&G(e#&`amFI)V#q*HO8G(xD6dDGF8
z)SPQZK(?`9!Qj>)DBIIv21<8njl{(2$YLA8tu!ga^D}`92}Yo#shhQDC&OCPxL(a8
zzch|HbfiRd^<z<i8GZ>moS3$0VEcrmLc{idH*N1H-TGvvp}}6}VQ6t;+zB>mEG7k2
z@9fWkrc;B&9&prouHe<Pp_UWlc<i(hKRjk3%*=sph0l(0=OryT+L#8rbgGf)VZjE}
z!n8!q+Qp*lZ5UB<i=g5wSF2wI=BHDX#I)d}jrfvFsfq#B>Qp6}kpUWY_F`F$7BJ4L
zELVurN5Zv$2bBegJRYvt>J4r-av}XieBqp$x-f~^^IF=hWd>cnR*mR2$<~SwIEIf*
zQ4U05b>}7X-8bflSocV}5)E^ksbiDN{VthZXpo%Y`Pjj!Jn3$3WDiPqQ#MbGL+)t6
ztMbP!Qt&F);4!t(gk2NopX{|C#9;NydL*a|c8y$8e`G34Opd!wPwbDo@;1}(23vOm
zCg{{D8S5=P_U4r<$PecPyL1Yb7%DR>Hvdx0sCjctQ6#E!p#bS+g2HL~r2cwPsO8eB
zRAO=6^xTrDzoecNAYb!vg*v^g4^b(;GtW)f@}c#%N#USI)1_0c#Bv5~R)_li*Ud63
z&iZxAlqe5@rrJLL+8T1*f=k_AiCI6xv^@)}U;sO=K}}b60$xDfXvyViY>D=<7w+5k
z88R@9fNOSjG`+a67MVZkCl^SZolejXX{9sPnQLoA0Wo!Imb_xh+ZtKJ`tJZ5RX13&
zG};nmr0Kq#b{zOXb%P}W^&H{}>I_fY@c@F<2(l)moHsX%e>wv}YOvJ<DJ{S{Z##Ax
zK{{PEbN~d2iV0gCnb-(HIt|GuB-&&xHaSZUsUK0WD@-Gnl9a~jDwH+(u@3nWutq#J
zfXP#_izM=qSe9}Jb^uqUQ?Eq8l%_~?^|bnk%@!sXRh>%kM^Gyxwzo_EsJQD_3zGAw
zI@L-fCi8&uPSMqn+Gh}^bNkxo{F`1?Ak(FvQ=oOIPO(x;qhx_8RCXn$=kD(dqMuHg
zl8IW*Xgc9tY1n$*`}c+Kf$P($R$|C3s8HF4v~KSDWyb8l_33m;GEt2S&W393tUb@O
zH$M_6iOZXSlCJIsW;e(ar;>U4L)hbAaqZrr00u}u9@J^8K5W3aqR=s}d;3~#di5@B
zq}M^_>p|v%&i>4pv7e^2LKgoSE&6gdA#B8hOJf=W=cUsgiNzJRe<;)TfBVi2xA?%(
z)+wVu+RDlB0Cx%b+2UZAPW2K=Y3xi03|qK<1v<@9znn)A(5wlS?DfLkwO8beN-p)g
zc_t>Ut=jgIFHtxBEzcA%M>_ROM(n4}ePQ%puDcKJ5xOF@A}daSr@fkI@QS#_*`~U3
z$r!wuQ+q;yP1d^=M??a$>Xa^xu5T2DfYz;lrArkEoRv=X64NJhRxkqo+W)^i2-Ru#
zzFdHbD!ahnGgkNr&AnFYOR~yyU+eX!hb^zl@zaUuo1fghH`|SD+jXa=#d&V>b?TQ)
zm9h+7w9)r(1eOL0)u~;wF(r=H*)*yrP^eDvl8IW*BdBepb!QZM1&mbP8;K%{v9Ae?
zG<UPn<KAObq93nOB|~HL7!S{h1vYCM75hCE!=fLLr%Zff*~XU$HaF9Mt<lsdV`!}L
zv>!!#wmBuD9{8|Xcd+RdsSKhX)DGR-_i7y1yHh~kwrvvfis(Vl1B#|*gQp*_03|<T
zsa8WoOKeuRG(vN-2(Uf27)zf-w0biRR<w-LrlfEx>W`ArHMb<^a;A~xW4(J+t&o^}
za;Z=BvD{k`nli<WEyi4$INAmeP8+u`X~gzS1gndZ7+P3J5FIOukS8nF8iNE>E<O!N
z5pC4d?t{p;(T^8U%{|)3WH-Y_z`>Q4g;?{;1FFeKfX0<G5%O*7Jm-*%Y6=o0JFF4`
zKVBDFPIlqJ>WAfG36OSJWV@*_U~)RyPXw#$k1Wi%AXbwhN;>HB7hlR*FsqhT+BQi_
z>n#!STFZosa!3>^2>kI6EQv<1Ez<)`kh%cL7&}{Sib7Vnemq`|2*K+5qgbQwgM{~_
z=-ydia$L%7TZYGa@&uXB9*R=l{$of%G;B2!Y2SiPkO;V}d7u7h*lIGG^-&^T?4PL*
z0_#yXI*O&_oCz2xA})_SGZHXI-Q*~ic`}NH>=iW;^XGhfo*+zhEF?^}k^u4b?mbsw
zgsF~z43oKCdY)61^ZTJ~Iw5VUxoBX5SlIeho;!exPOJ3GMS1;LJVS6SkWvV+C|a9R
z0?+pKH@Sc=1()Fy(dd6H>ax-5Tyme@VD^vFuNhL(<unoU?X0#J(ZJPgG$2{H6%pH2
z$bJ<KTuny<(Rf2a#2me~c}ltHAXr^<L<9;7=pApo8g1C8M9%%khkY*Ry}{}S-3VJ0
zv}A>{>E#7}u)3vDtRWonlFm#-*#6<wjv<|D5R*8`HjCsW>-n}UZxE&iF+G^_+&8)1
zDW8?baA~U3nEX*wIx^W&@OBpvgVeP~rb2_vXRk$lPCJ@zy5&N+bW2@rWT7G|O?w;~
zh(I;iX(|-WeEUykd~Iozm(;0J=tfLXur~X*(+Z?g4T74GkfK-qOS&F75_MZ6Q>C%4
z7UCp*{CrXoV4&(sBM&0^CK0n&n_}zIu%w-SygD_aCXHQ$J74p2`JKMtV09HyEWL}$
z$d2sj@0qhIB2B7^$v`31*H-E2J#*z~>6~!Cw3H*}&{t2pgV|A+4$;tk&@w8|_+RDq
zeXzP>$i%eo%ad9qM_;O6mDwQiRF@8!=rWP!7w!84Qh}PAh6*5!`u?-B5{O3Xk|7dO
zG|yeHTD3(ZR<9~qykM(JX+^LubtSMj7ObudiX}kfGPfvWfkP!vAsN+-BuKV#F9N1G
z_R}ihF+<d`k^qf!b`i4hjW-h!q?(Z?Bv|+!Pxi})R<PhG>6{r%N%Js_))~T{{qnuj
z$^gfqt_Y&pVU9zN=h;48{00nMT@7R+BJWmi)YAzdLsEAwG9js_Jrh(S_tF1V{~Pc|
zT?|C9;(Y&<>`o$5q|;%dpvy#~^_oPSYh@xU09T<d{)zP<f?cvJi|&9+H^J)S9|O}k
zm=g!SV#wxDG~XIzWCJ$}6-3B!>pCYOU24#gL9)FVNtbOVc3p!IHP}d-gTTzsb>3Cp
z8a78p=T4bFGD^Fv*)k+{1Tv~CeQ0i&jPdcJ9!pM(Pl^!LJFEsGu%9*A$^;`sb-rpM
z%I@Oaj33ThdgQVzbzdTL)F}V07*!dxqY75{B{CsljIH%D#|7Xk)NP3fQ=FI2O76Hp
zCq4Az$Lus7=quWE?bU(ZgkhlcY?bVWnyhkXmfnD33sVg?vRZ)}-P?EQXB7+dPUzD?
z@|mmF%xnS{0_qM$u^r<QtU?3{_2!+$9e}G-7y86@>>A&uxA9_$sN}ZuzcX$zP{ia2
z>Qsb3f->!j(X!!!8ffQ3UFj3c*a^=Vn&%kW5D-e;mdHc|7O?oEvdGn`t9(3&vKtB9
zka;xNELB(dn21ug_4beDpwoJ=x~|8>LzGXfl)o^@2-QVB1X(<~Pe0LmTJ^0GB;WN2
z4%eV41FYXWA+G!9g#&%8SsrBj;4L6gxYITv|2c3`<e2hpaw1dGh??>7<%?HplOQ7I
z`uf;ygs2fU2@$CEMzKfUUQrw=og(@rrM#*P9q=>*aLwvE9-4b`$nj^BjRu}bUBMG;
z?7jw}ZTE{YYahxLa>42f9t)GP94|7?*1DbtNvmE>dZY#Zqv7s#nGmKrk+m@8fEP3(
zv8J_h;R2qzjK|UdS{0<YymlcHR83Kjpdh~)-uT8OgsEnxg$V|~ed`l6c&E`LwtFy<
z!@HVe)NrsV6``i40V<mP`mhH>Eg3mpI??>`lIc<mmiMyPIs-C0b@@&#%{FAx_Y*#x
zi6GSptqBPTfA`jnRo2Kk(^Qx4c%+2tJU={7aZov+F5WRf#mRYeA~$lwk!nVo)tRzM
zmhQV?EQsjp=geYFL{Y+1Wp5S&))=X#VjSDykydLP8s#XD#8b1-=&mK<of%SgE65Ha
z)eNMk5W(?r(M9dwB0wi!5T%XF>~h-f{&AtVrIyV<;l#o(|KzwhG;&$2ETmhbTF29n
zTb$)j)@JS~Pm5dKOemIBT!4eG#$&3?M*^xBlMD|<ge%!cCL%y}IArb%mDpsC?@(F}
z2X1xapjZNA<txB;#>fBi6k$5I@u2N6Ot$|IFuyH&Gb<Xn2LBjlIhlcD&;7ngcC>Dd
zx*ZyLIkYm3FV`p~vK|c*(oUnaiU>_Js|?bk1_ucbuJW&@s`Stb1{@8Y;l&>fS%HKY
z20y))Ely5P-5Mo3OqC)9cYRr8FPImNavdt$HF}7MkdH@g{RHSyqhg03nLPqAliqGK
zOkOy+)%}8E2@`GLC0<{1NM16z)!l*&L{?<WEJ#*ohwE?OAUQR-=%Z%v+@AB75uyeY
z2@xE~Om8^$YlNr~41H`1?)ats1B9r-L_!35Y@B^&2=G7Z=g4Swg4pF>(I~rJ{iu*-
zlpGPAk-;Ysjgl{shjY3{H3K}<DA!>!it-Jr9tGM1xiu<v2#i=`)NTleF&}rEFg*p^
zuA-lvi@G&xbtLaNwep=uz}u?30>#D|Pwt5W-k5emJ!?XE(bPF;*ACsy9YxQspIzeK
zt$&G2<ZX%9Jf@O;V~-yWDjvONW5XmT*NTsObepoc6!4H5r8%_Bf(&dtD(iO$Qq4dU
z66^ry$S`mQAdI>ZP^<|l&G-2o*`~-V4tKCR8lu(Z*Q4envpfVxKW850hknx8#<#oL
z_mxlZ+(Lqjk{&vsH@FfMkk4a5q&V|^$>CSO&n6%KyESTZI9T%zI$OVrHXmHN%x?K!
zt6SX)D3(KKOHK*6)y~1IK`>J{1Tuh43y_u3WZ9biNL)2V6-5xsv#;BWCQr#zPTcq|
zk``XRDDnijD2-YjI?#1Vc#l4QfdZvlO;h91b6@}ucb(W`(SUPM8l^haIhjt|MUyIb
zzvvi*sHUmai&;e6GpK*K<(N6DIw#!^RlzAowee4803kKXbVx{+9!SGJ*dy(8xxKAh
zqezF^&9KAq_%85(v+2ffc3OkyCP<?^hj8&)>Wf<a;{c7+eSKmH)AMF4a;lFmX1ou=
zh(?(Xfx`P&yMz7+2NY6w^ob=%Iqf>v<a{4A^XlxC@aVu$G|$Q@?|g<3)ud$2{t6ZZ
zGM<^&cpeCy8nrrx5y^{yxa5&#k%($e5+K@#sQ92r3d<}xPCEUiKTgV<IS*<cjRVG`
zQKv&f!o_ZbBsVLjWPy}^9C<Vfb!5XinB?JiAfjnh=oq3A#lZ&A?}wiz2Q#Blpkttd
z81el-b<!h5r@KUXh=~{{xweFkz01pI`EHFW9RtyG0|I)tSs!FAZkZ83L25R7puy?R
zC&Q|KiZIoDv@qqx(3}a=KSh(TUQc>3;U4;{qp7OMd&=%mH7yNP(Gksi7TnsJd5)7#
zUHajqRAnButyE9>RL`wZuG7mr9j5#M&U^Rlm7ZF=P~5z$oAbnaklBJmveS?I&HEdH
zI+xVY@=bA3T;K9Z!{WdzX%z2xu2;xe+>y5zT}VzfLp_kR1t(7axZ$4-LvlJjG8%mE
z{yjRtOfJa>DdRvGQa>sdYe32a|M!3G3LqKP%rpR*`;>;gX-d^aNSA728jwcHA%RA2
z>aZHgsph2tip=Q4zXLZ~PKo2DbL9TGDIY%8+rMTr@JSk#Is=W{<gB<VKK={Qj=t<P
zU^SR@b+r!N@}nEy;-=I$n@ju*oSeE?#{iU;*{6?W-GStDF5H2g8*pGLP`_H$2?$Wh
zMiWrZW2PQTT!sd$WTF8mIpJi@tCUCbIo-Oi0h28XTW~{9e3T9WI&IM>pgiE7OFn{z
zsN^6Gm{|-vmI8LOXl~C<7Gt;&q3*C_qe{jz>GJ{J8>bu#or3yfp*;8&Ulo}KSg0<|
zvBjiVCd^T~DS-tLs`Hq}#~hg|1v5V`*MN@@sxm;@va-EhQPxTqW>o}xC+apkUQ{^$
z8Ftja2RysF)eZ+M8NfdSpF|^BwYX{M)o6_+s-XMR#cdI+7Dp{uS+l!ZKfZ=wwV3LG
z1rxS^b(@UH44gFZV_ZgK1yKia88ReAsLG&e&6n}6tB4v>u%|as<QVG&_03q=bSLMb
zo!}{Nx4LS_mQ?c65n0o(0i#zp-Qh5019&@gZ305oCaiI{NYrWl(pTCdRILz7W@Ypm
z6;ZdBebW*6Yjp{ar2+QFnTVMz;J4FAQf<02Oj)bvzAFAFLe*xgQ7|LQdM4xK!D#&2
zWM%KOh?oP4RD6si)n=;EcT+@tu_V(0gz6-fAO0JM>>}#aflm{yq}gVwu%qgasnY0w
z?OraYtkDp4b&q9HtXqpHWl>k9%JSGl)CE2qrfg9)Vq8BURBfIb_v=JiS6;~XBO1Rp
zPgye*5wpV=>Bk{SwX$8}zR@63L=EYfp)5kx<|(UQkQ3Fv*Z$KKjbE3ifh@6%6B4VK
zuOjy$OkI`+GUq2^esyLi=;Ixt?$+b6DFajL;(GtXzrYiWA?j{DUR2{f6=D1{N96j;
z%Bnb)I`c|@ECnm5aXk+F4Q5|m{^OMt_40i&r2Yyy`3X_i0eMl)!W}^YqfTa6f`rwj
zYM@#AC7`;-UI6EZA?j)%udu8lh^bb9eg6BE<koE2YoHKyNe~Y!n(OD^Z2JZ&R+p?y
z1E}fjnr&U)AjRsl)o?9>2HHOT{hqa_$!kE1uSUNm(N}dIU27sj)QYKuD8-a=`6t~1
zK1E#`M6<;DLZj7hw)bkEv1Xp*snbgR@>Gse>szmn2P0RP2U&7T(PYY~x6i=H)ipvE
zBJd{RFPeg<<3iLGLLN-kMoyga@*|$4vr-ezh}4xrUPx)qlh-&MgLJ7CN9k=$NysHh
zE`vu4Le$NCOd*X|OvQn($sS$|&5sr*sa-vb_#)=Yy=8Wxk!vy%WckO6r`d(1)MO+>
zlyiq!?=M5Sle$>Q)F#aEze&;LhGj+^C!Oh-KTb+kwD*4fr9hYJnjuR{$%;ak9b5r)
zsV*0?5CJ1M=ASkTVLF|WkM)A*2|m$^{wV)-VT9>arXNf&=k3?;%YiU8IcYpZCd!%W
z#O4PGQ!7|fhi1T_?FFy5L$j{QN|4nTc{}zrl2VhCFsCovx1|eV>amh?Z?>-~MDtg5
zgFpv~5VzLK(}nW+8ky>J0CCbe<$gIS`;I(2!=G80T(}UHvc7DSNr{F&esQuFK%MIP
zAcL5JEMmy&oK<*I1TZ9ZZIBl;PMDxcRbzvYlzOzJg^Vnv`^d}%mfPgj>6|0q>ZI4d
z1u>rtO@?e!T@>UQIC_p`@52fk(9rc*8ECfo5airdt>t4hL3+F-OmXBVD-L-qKSLCv
zE)DXGoUMu246*hKE^4k2A1??TGO=+hB(N?)ttQ`ezGT*~9-jMYBa2L2&~*AwzXX*N
z*(uEj{R^f_T`A;I0`qs$QfptW+{+QBb7kz?N{t;1L7U~CCjG)1J7@Xok|C0leiS^!
zh;(#usm}nN)D=S(sLKOsSE+Z&vb-0Ko$42PIh72Js#WA%_2D;a)vjH;xbVzj%m4LU
zfX42ecpv&CQ7I7-$Nq5Xi@FF@i=zf8GbRyq$k1W6kwUddN}zEP<k<a%>LWR|Vy6KK
z245)as+|Z_i<<^082pNYmrGlq96g;1^+`{&yi`=^wwtNnvoJYxQkM;pkVYXqYkMey
zKH0Mq^b`zHR}9&paS~|bJk`IGi|a$w&v_AOyZAor9*J41ZZwh+MILo72t3*xqAndG
zbY}i|XCP>Mz;xiK)UAJPRB6?)^7)7Bz}}6z^^c9oqKY{F92?tY1shH3`XMhW+!`tO
zSLO`JytMdgs1<AxbR5!h6p~eou^v#cBys;18;%sK#aV)dN3CJYRz_JKizBU50scrU
z8Nj#GD=Y&>rLHBirV4Cm%o`k12#j5?lE@r8`?qLRxgUO>1)*v!Mm?yqsZP6d|7SFQ
zt-RMnjT0rUbG!XwB&jm0+ByXm_1>+q4G^kUTqQ~2rcRmGNxYX4IhU>O1!T#}S{#Vu
zUmW!ZI%-q50J1T`{5N;+Zh>Y>o2cNJbzHN7;Fvi?uhfWi3XfS+jo47s@>3j3or3yf
zDHwgabA_*g+1IN!@<=LMe~V*9qY<iB?rWj~OU?Hp0c{(pdjeVW4>mfcrVj^AnnUzz
zjYv|s)$!9uA>d*15WP|(6BUfV((KO*BduyPl`SdcxjOQ^<Y4(eOo;krFOODDmfE@h
z7dtN%pdRwn35;XD`cW?<_jiY#YEW-OLwbzqMC!@nMb#Dmepmr%z)1lgYXGKKW5Y*U
zseO>Q)>wq98&hd7g-w^RRy&{RkL7@^PEdbr1r{)1Xzes0sn9DlGR9BOdr7-!pX@ES
z)Do4OGQC<O1C~xkh4EKC5`6(^Rox`WvMZBX0&2pj55euV5OtRz1C?!5fK=_zgFR3N
zpjT)_n;)=*FQi_;3^aZ{wi>9w0-mh=+uL-CpDO42$`=C&6)0fc&(-=PvvTHt{z1tM
zgt=<h;^UVHR*$WwtUv{?<2x-tighx}kF+oaZajDMY>NYSa20ld{L)o+tv`L=W0;&;
zgzD8Bkzs)(I5D<yNqO|4di6#oCeUe;^C^-eRJ|nFkQ9WLgUz<=L8y93Fhhl@W!u=2
z>5x|S(qIEsN-euQKYtQQs!di{!T4kMQS}k3Hd*0G<Udh`8X;6|w!*W>pW5f>gHW}}
z3Tyb%{;yRQG*{YO1r>MO@-_l*gb7zL{V|npI|;5T^P{MzVDx$wN5m?4)|YNk>In!{
zFAZj>u!=3JPrKT3!WOD-KI933;@ICSxNZcJQkSJhQYGaSW7<`jgiv)^Y8?G|k}5m7
zEIQ|KBK<`PrXBu5)o+HG$))>bgA<fnCY^kss+e1T&?Fj^8;7bN53|%tHXxYQkDI?d
zi<F>C)j-p(1k{V?Tc$y%x>PlemZS+Q(sbGc`R%7ry`m#V0fuTmn+(EB<>OzivD^R`
zT%FOyCuPf_Gw(J_mV9KzYt9n%YL6^&#reuqdU}32V+qwOKk|Y~OM#OU4|o^uysXag
z`_5Pbjh1186%6`$XA>}AdNoMKHAU;tPR`t(J)fLf-o_3M)+4W@-@3P4!6tF}dl`<=
z>X3S_^XgCrTZ6<=M+56LT+=x5M5DB`Iu@KQ(zxa0yB%^fVEXakdNEh*=bn!hXOcaO
zKC?)YjgzvoFVK(wiXO4Wudqfh;s;XAegC(d44i)a2lO~DegK{(gs!XCJ_m!RAO8ux
z*zEm;pYw{RXIk{L4u3h?I|GX!+DmC#l9C%*=3?T~j}uw1ys0A-xmKHAy=(9d`+@3*
zt=c**fPH{|{73YnHu?xue?*q!Cq8ALpdbGkJ*VLKj5!5hDC>?Ny(jl&2~{^uGGZF{
z_<(4hozI8f0FKhF=OB#t2hdUUjQ4sOugsHU=XIj=42HZ0taTV|7Yw9rT%|0MRnH?B
zptQIZRj_2#@e>GE&jpyUENY6dmy7=#4&s`+f0C^N`S|$ipP7#$S@o!H$cnsRr|TQ1
zg0Sv10zdqwh$%$1UZFGd07>;qrR;|-MA+)($7Kb<Qm<I*^A5eOc4|lqf80;~3}I^#
zna2j!Fu!K|halBcH&!BRpf)?O;-g#kdAkv+bK-pDBL*tXoT%f<AC&8BSp!F2y&9@G
zs)Lu!q20l+zzfr%>W9#1{BdZrugjK#pIR}Amr{$igcv7|yV#=w>(RKiLbZV?CtzRf
z>zE#Rfe<aiGE8{R9r<EYUQ19e96Oz>AG)H%KGW=5*1<8SO<~*2hb0+u$}#>y(|KU%
z!usAHB#`s;KesD^S=TF^ibMNwv!2CdwUo(^+?m|?6w^2{5H0D-^BsR6Of6o<;oY)c
zIhG$oBX`caPdULcZ0725n-QW`Jf-IF(v*++_0#KU+?t$Z>u#Aro!n(35vC?9VV(89
zNil&4Q<IfOm7qB1Tl@Z*(Zb|N=~SjaQp!#<YwBbxElAEZ^~$B<@TSw9)enxzy;4K<
zs-+~C+2B&#Z4ff`%B11~sr8u|>%FT>JKftKemxqEUXPf8W*ic-lA;f)fNGXdy%H%V
zuW>*mV4lykwIy(!dL>eXDc?m+)+0DZZW$S>S080Unr%V_Q5R+z0PZY=svk%*qA=dX
z>N(?b1>ok@kD_@n=^#_uXvz7gruVf^-tzSbYV2Uir=$O;?5g9mEV?$`@FE~3!jdkr
zupPt_0xnA~EgefN%@P8FNQXg*Qi=!&2ugR064E7tfRrLAh=eGhyfb$^_kGW~cIP~Q
ztopsb-*-LdK67f$Tyv&g@#Y(CNnIZ54NfV0D4ZB^`0T7sz({%YD6vwpfEM54_PrLM
zs^ih4gf4LfR<p#JbO@DI-AYtgiu^lhZan&ao|77=B#Ttd{~PK!>z_z7EXu$Hd1S}D
zEsN3j^YW*ON<(z7a*uj|Z4QqfWoQ+ub^VTl&uvq6**}jVWx*1?*3EdRHj<T>Nu>si
z>nm#F+rDq}$4FM5ubQwVvCO$p{iq#OUB2oSH8o!)U;oj}x%<J_^9WLwO2NkFQQ5^y
zfLZC^OtXy@9%7%*v~UtaWjiap^f~$E1z>PM1dk&nRRD|KJFB;XtG*FDj+8_NrD@mQ
zMb4q`XFDrA#=Rca_y$7t)@Uh}(1xU-(-FF)Sa*c#%`2&*0=s(e+3>L-uts}5AQe<l
zo=+I}{S}1C_Ed0)`}5c;OKtCWIjR>jHAe+}lld{HzXlrRv7@9#!HvZ5?;jLKsH}Fd
zM1@<4`w@rh0-f^MQ6?%0RZrp*OCd~lQWeL|YLp(|Z{c?I^}H>q@%6w;3-{~v3>;zW
z-%_)ppDN|n&AUn<DY+hMRQ;ryyf`sKClLB$xE^ZO=;WaFqblEaMX+2KmGyLxFn^^;
z-|;X*2c!e9OQr1j#;Gtt?Ut+OhtyA%tz@cxY8OAw`QI<eE!WFKC+{gvq@ETf&;JgF
z3x?>LW(SWRIV}$IPbS2re<7fzdROf2>MQC~T}1LoQo_5+LhfPNR-Go&_iZDCx!JX>
zJ?S33W0U;TKi8@AMh5eoS8zp2)4s|}XQn?uYT!Aqfhm=t7~0~v6`hf!yd*170RypQ
z*kn++L<aL5*uVq{VP#aN^hi>k0~@F$Al_f{Lq?=ip7)xVRHw;-?|>33k~f=41X$UZ
zwjIrBg-l;MeKoCym7Yy%&P%?&|6e;^qOmKI$CEPTg!`5^?_C*WM;T||63H9QWWkbj
zIJ41-ZAez0yGorxrB<0gJp>p4Z!(jV6;|$fJ0EHXOqDm7$wVazc&TXjScJ)TR8hC9
z&R=)+YOo!S<guhoIYCI-U-B8)x<`hv9aTt5&42v|Q@{|5$Pl)xf*nTCn2`g~>hrR!
zSbbxlfvVN;7kj^A+rLu{EA7x!9hHWZk@H4_L%v8JK}xO^B%ii;=SnN^{XB-0M1?hW
z{KZuj5h~kN;mwwL*TRm|Dl?MDkOKD9vci+rAfWJAQ4-JSTa$XQ`27liB^=3{(`3M+
zAsKI6Yn&aal$%lU48e<4XAMFs;5usA06Bbvs9?<Q7ndVguBRFVIa(68J9E@{EKj<Y
zE3NQmHW``)_gXg0jm`&r)mx{f>Z>$Tom)Nh9{7G9ugNDUDc(P8T=YZAQj6rxZn9zJ
z3r*DnlH_y`vTn6z<^%-iNd0SX#y(DZgrL_E)PZ~Y975XgsyL;cjDczlB~j|uU5!5-
zLdj5(JkFA#jii3?3CaTvUjcV=BExujR$Tc<RH%(NM#S5-o6C0fFTEM6HQu9Cv&^!i
zt=ij`>xSexuYi;#whEg4<%??&D9?2zs8}!+^zVK9YNL<mWmy4gQ=ptpXO7qg#vLbV
z0j?D5-3kG>ZFVNkV4R9eiD|;Zw<<$Pl1Haq1-_m~SCX%W%3?_U`pc`Q)<mGZj*|oh
zD!q_@=I``uFp@XgsgIydS`U({!j_sluorMv9z#jKb6TQH=j0MZ2ZN{8u8Ls2>y<(b
zFkr<jA_^ODc6~ks%W_rcRaR9AZ?u2CI7qfUnv#T-3{Ikhl2I4Hu-3?MmcPn_TohL>
zwb|AfxE62TlX*I<e*M$}S^h>}&+=9SvV!PcsHg+l91gda%H^=$l>!c1JkTV!3yuJ|
z=#%ZAbi+XpheuelWEJiu-k<_L_Uh&@E&|8pQI{k*3b23lC=MQXisVt33{W8H^ik<+
z0xRIne3GDcfOVP;A7*?Ogg&0-u?8dvg_X~~u?K;AtssRkV1R;;|LDu_(;-k+X>7kz
zs+#K$b)L-w@il_ytmf0F$PKDKy08MR6f3_<VX0@uyr0||iOTa=2`S7UEY`>gTVm}v
z;PP0nT2uE}!C_abw#PxAUjmDzbf8nR03j@rwC%q^!3dO<VeMCCRY?b)>beZ9l(LIY
zMN;ZhB^KVRfaGLV!uG?ms+{jPeseDZ<vFU*C@L@J-am3%7F+VqRa^4dOyb#6bAF)l
zjF>9#qJ;eeK;6z`H5t&t1jP1*^v90w?D`dwndPzuu-p}y^^0P)6My`3E7CE`YmK)U
zf!`i}7PlFJvi#Nrr6yKCU~x4&7`U9)tAo^?*0|oHD4@lw!)np7l94=ulLQnNVJ;ig
zZ?A8*9tUZh$91ydMK`K4qK;PST{}kxVaM{%Wy_2Q<`NSXHOy&t;3nnDMn>r!I5E+B
z;8j5^S0mz6gsAsk6EQJqsDilT%Vi7bWxvQMeU9}Z%Ejv6Uuu(V=CgIp`6}>U2Ghww
z@7ym@JZh|n{Xv7S|JvEcy-HroMd8*276MmH7&1&j-7)3&%1B(j<2tC#jK@C};NMH_
zZD5zPZgKU_>jSRtlh@hSp8qG~MhUBIYrWzE_w{XSn>7R5+V^MOe?;GDjbxCXT*5*%
z9RIF&S8yi5;60hh#<RDIYA>g25kfCAMl$9?xiEzZ8zE8{v4}g$FZ@z%U<gR<3<i|>
z3-Zp40{LC&oFz!bTtAkO@>;Oi<0#18s;%1t{5hKI&jxaJdFNW_!g4#u;If9a>TMgG
z%Z~NqqUtxOmmnuQ9X^t<CSx=8+U|qrJ3f^6fxUNvBlT0G#2c<MP?}vzBUiu`EPQ{@
zhaev@cu{VALp8`i{;ahKOnQlo=6bhbddfO}Q7_j_JHWXzvlkM$w!Hy1UV>MPsS-=K
zz6R0<gCiyMAk0mu+Yr++h}-{!y)LT~Swy%DLO(o88pN87E#k&E`RBZ94%0W)PlLqN
z9|)OZ(kwT6Zd#P(7=xpHh$2LYcAYdYlI0FhsQ8;*MY)y0@@An{A#XtcWZT=EP4%3@
z(_Xi2z>UlDWr2&6+`pw(4h2ar#=BEXA$3})FuKnef4UAxaty|lsbnFpljIyNlwR8H
zA&8YR-Yl1@ywxj0fxmcjA-K^K8RK=bl#!iu<TymHj+YI-v^OOyl`rsHJ0%OB04e!)
za^d;(%1o4=G$jM1STjRXVZm}tdx#Qg#un;Un5MTV23^X;2I;L)w)GFGLqsvSQYNH~
z=SBciM6I=@)MI+26~&-QIk?pWjD4n1glxMiKk(O{|7y}i5f#k!WHS*-rB@CBdg*zo
z`zJKdMFn#m+6|AAM(KJpPSfNc#UN6-^<#!P8bot0>$DX~&#JkF5t`E5br#($Z2T)@
zd1N(QN0;~`N769*!GjiuXw@0TpjVk%L7L9@)=$OkSm&f?Wd{n}+)mG?I@J8U|9>Tx
z12<<7tXz`Hf=F(171OTNbzLUlI}DbU8(VJ1q<x4t+tfHx;NxM(fbTFSQ@MXY<Uv_`
zRweLnX6^)T_C+z6R{~y~-L@45t-elQCI7r{fWI(!R|2zN|G^S>Q2%86bWG8B?bfGz
z)ASvsA6F&fhwQS-7i#D=zvG)$tfYOQC<X`1hbs6oil~j>{UbeaJq88K1QnOkAhqM?
zdizV;ZsJrhQ4A86z)cb=z&xZhMOsxwn&l*J32U5^lQXCNgZ6)7qq=<BTXm-H)3k$q
ze*3N>vX+s5E)6h<Sf&P&)ELobOB5K_8O7jWS%9MP1=zy(8f^aF{&=^X-mk~CkW{JB
zZzd`om!Zm45EB?AEFr9Mej(kUf)R3j#9^n{D*5(^^s+RR|BG8_ZMqh_kCTCoj#Y|3
zd+<!c!7~{;s~qwIzkOSe7RgZzT2`Mv;t@va3}K-aL@rX7FZ#lP5wv$16{@ek1+YOK
zuMki?u%sNfR+6YY-`wzwv{a4?)n{lIxN(50iaq-E_;$dNL-o1Yg-o@vZ`jg$bPQ4y
zgQMkwH9ES!yirmWeaE|Xe4@MD+S`Op#jVZ$ql!8sbktE$3^7Psj^t*;LgWy!^D*%q
z)4n`q+CHh70IzB5*<1CG96A|Sp<Mi`GYL)N<0~|6daz-IddK2|Cf+0bmGoU39RTLS
zAaFU~P*Ro~MCUK(`~3%m>{U97CJHh+wwabM??O-_F?d`GvOF17vf%&b)L4bE_2s#W
zEzX@4?92blT@hjX<M)QH<@uX}9lHL{z6jeNw>Pjw1+CiQyG^E+m1F3<gUX`x6RF&G
z*z!cCE>+rQOkb^8Kv=U`*%cbqq^f=X0<o6yjGtTWRjCzT4I6vL&S@^s_hyGwJm2Wa
zsLC$?(QD<Un<_bnLHhDaE9p7PI?k<s>=sZ2V@{P9nmA3}<V?eWJ2L2B9$?_;=VyK0
z6PO-@0Hz=Vbv)YfUwwq_T|ZqA5s6Z=bre-M8Ic`jO2)V<MQ&1`U0>8@J<_#*jxP3x
zB&fbNtLGA=5C7a;AOl@jUe+oSVf&NcOB#bpX;|G>K0`)?t*_SIx)ySS(6=zK(U11V
z#pUAOh@HBN%kn`rkCq?(To;JUAc`p>`y#5-&%D`x)w{sU89XsJb}Y4zbQ6Er0U{HF
zE9M0T=J8L#T(gkO{^j#n%EI`n^yXDaX8(L#3`C)3S8>ISg$UYf8@lje%vw>+<If(8
z{zU5V&&LJ(T?Kv~yWwRdvwtpb(CSs_hNq83fVdRlpNEUS4~a`lKDb#9Ig5Y(Es%YN
zCsmLoO|Smpt=5!k{7mjUq_$oD?Nv1JZ@Znod_@9ir%&GgV^$zBgI4D86qs4s{<tp=
z=vldUsWm$h?bH=4Q1AMBu;pM-%-m9U2r%Qcof92hpPKyE8L1W75p(UP^$!esO1*<e
znx$DEVN&HC>;{b&zbIw*jvJ2B&(QK>AFh-j@gG?DPEhSszQ-=KqW(C$Fh97N>9pXR
z6`)JVprAQ=x3GO-%F)b#Q@P6^&1hZTrJ3LpVJ%K%nl*G&w(rPD?DwB8NH2d){<&Ax
zAHSE<gZg^<yRk(Ov_Fn-LX(R1>odEyfYRNo6yW!Ef896-P#tJw<gE^%_o5umrS6)h
zyr2>(UAa<PV1de!00SIE*tc&D`VL|1n{!?ZL{(*mEhokT>t>MD2)56<9lyN0yxnkM
zB8;(IUUX3I-23Uj?g-jnmj_iz#rZcIAboq&j(#mswrtVj#6KWEFs5`l8VP}M>ecp_
z#v^2ZJl#MhnJ0UP`Z<w4{Bd*>+0HtSg%qkir7fu7y+Wt%>8OIgdF_ivKx77qO;Izb
z;5)4i$^^<k293>)4FYQJ+H>lH6=ZPPJis7=Z2ah(_Ykr_1$>Cy-;wGs&9yrtkuv<L
z;6ubsPzzXkv|0MCecC=;uAowm=$UNp#Mm5{BWoJhY$pfMl=db?29M3@uEy2w^7)d$
zzzgN_y>hd_(q6ri(;9s(=L3qz)m<rt_fEQr(zDuJ9}rhN_;j8@Q=3JQil=1mgKa_U
zoWW^xY^AgKPxJWzv+1uU%%Xdjtwv7dkKc==AWw^l-Ao8A=zDh1RoQ!?vEK`_v1mH`
zn&wU{nN#hjlR#buzs=E!XcocfdS_ed^dL{_nQl_a*1?U1Eslm%O}D=GZ+4K(7!$#~
z=pd+Es_;=iq!fQ#UkYxVI4NzkVb2dQMcDp0zr;p?C3<bOfk-9(<adef3oVYFd@}Du
zYj7;dpuoAbZ9H@XTg1PNdnZ5Ainn@Ay?jVAOq?3Z{?VDUgFwz;!#ScSL4BX7bFL2v
z<P0{P8yRSO@0>cmOX7~FE15VoPX{TuXU<t5pG7kWaUNkoTq-nVWi0jcXa*h5g)Cy8
zh)`gca4!Gg=hUd98O%5@I`H#3RTA@3tBYok;}mG0Qk+!Q^-|s2a_8jD#nF0RoGX=y
z*=<eNtj(A}cBq@{Y?y#_;*X;noFtlL?shNUhPF(i8H6~mPDBC=5v&Q4#HIw*K7&N}
z%hP3SrO+R>`Q<Qz_7=vPAYwpUn`>t^$EGRxmb4VPqE1U7T2F}ctY%oknzS>>VqVRk
z<6WDc<Z^cJ-O3c5UE~3f)*mg|(;QefgBIsn#T2s4got?ufx9zkaRghm2Gq2E>#gzN
zl3_H16X!+uMO9}JhqV6meJQv!Z`UH~`Ec$<JXE2gxR#OeG+D+iF9m=Z{m~3&oFljh
z+pv=QDsRvSXgU4ycMF^BRR8;ILSNwU40fDXZefV<I%=(~*=r+n@yFq%>;hl#5mj?p
zGBAHfT9-sK=yG1^1*OE8DPdG=j>+`dvvi}}jCfzii`GB#=r$SAf;}Ox@yLx;_9T1P
z<J4A5cO=XQ0l?d;N-Y3@Y~NsW9WZ+{nn9v-=|#{rA+>2{?iy8qIWh=!UU1ZfSaV|i
zZM%)>a?((*Hc}7bHfzdR$17#NjF1w0o9WSdR-JntkJq0Nww`V)FK_sGHgF)um@`Kk
zCdFHrxFE8sCf;LJwO;hPUNnzbXKkYl{J@gNLkP4&KK`ileM)qW_KRU>P|8FP85+#m
zLc6zs7~mJn&M+2u>8IU0d!l4p!rPjN<}vLIdBr^s^S+0;o-VR!i3-+<4^`F7qBAzg
zfZ**=MDyr(-IMwZ?v`wCZH1M}-vNb8tAlf%+dkl`2)x_R6a#`MlsQo*{%Og-Y4;<V
zN5At*ZY%|&YIa$*qylgSJq1th_+>#VSfGN&ZJiiU?I#A`8vvp`kA5fi78d1NsvU9g
zj@B#q2rMq+`9~qX*%d0@x!-VmfpLfEl~aQg>83H7N5`{%1UlL1>zRJBt;Q8O8DrHP
z>Fvnrm`zY%Y+4W-7<1Kps3vLCBL9=7<$sBxMP+P|KjIc!TOY{Kd{C5QCk1Qs@bOkn
z*Q}oqObDC7fw?|M+GgzuOl@OZDLUa$f0<w8pIdBiH!g)d<pKu9`@xJ2Z`lnCm-~A=
zL@BzzrDypQY9={xyYMNX3?32BmRTezvZ))f=u&N<3?2>71q_r?r%JYC^aL`RN5nIs
zWjK-DPkNFvEcf>RA#iV`O?441a8QEnF1Dd80{5<?796wjzWlH8dD})@=Eq~>IcfnX
zd7q4^wH2);>m<)aHV&@9-flqtkAFt?r*(Cw>yA&`f<~{-gtXy@mxqW%3{GR0zy3iJ
z`>f5aXFuFrB9mR$g&FVvYTpiU`M7sO2YuWuRD?Z)-B4nOXC1)W@kn^~+6jXLYd2?Q
znFnC)cpN+%TEq^*TgcEacm`NI9tY0`hIF<YS2ylN+VI1>#W5RfO5Uze<`I2vJUYS;
z-*z2x81<AItUK<@eF)S#5ndBXHGCMwzYKl8=p@x)o)zwU9&=Uhh?I_2gx1ZSv>SJ*
zLNn0{q3y}w;m5Xu$j6xN=BpXx8JG|p7~-(xU)CaUKYU$+3sVFM;iV0CS0ZEd!`<Zp
zinxnuE~lgKcb1O1MQM4;@hNb4LCdQY-!Mpy0s*wVl?R$60u$%a@=WJ3<OP1Yc+2xl
z2-@41Ox6A@XcGL^ZOpU=EFq7U=aCwm3x3*tPFW<kA6_rzmi=qhC7a)RuOHY#=_z?m
z{xU0fxs8>Dg9x?io#2LBGv`6#`{DMYih|plQ4Oab0=qLFE6-HBFZsx;`l@<<Ecate
zuvK6@d+Bp~6JPkI(Xdc|pmad97DzXKxPFq<IXGq7(IK)IGD$xiU+!N;$O7OmhSs=c
z7ZI*x?=5?P?-vhDRo~lUTY<ap(L8dVxt>yHQJv7rc>C8kDgb@(xOpyY7{Wig^8+fo
z83W^dhGGcr3gOZ$%*0l_dYTi`3YAu$o}K3;wu48?pETZ0l0o;RIcvxHf$gXNeM727
zZdzR>p`M`U{6Lx+*`{vFHhgXjIYl^j@8)%2;*8;PKGn!(xv)bLz4pw!Y{)HTcgwBK
z_)he)pusjRxK6@kB)8YbQ_U6<9BnRNdYtwoD1@T?@Olf{@Fq1e|GNFZf6#JjJ>OYQ
zySYD*v>z_5p0*y8`Cide_k1C{8VAp;sBAn4rkJ?G4@h0v{rh#Z`&6RoqyECSDly-J
z4nL2tXS%=aL%=@O-%ASq1a=ZU%ASKwTUAfqEnN}VAY<yB<2yoVqZ(IOJGb9k@C~p*
z#^aklXfXg)-iwARseQKkQ2PYP<(hipp5vNS9d#dtW<l!k!`}rc?6_C$QmhH6B=kHz
zM_#FA8KzwNkiwcVJals8X6chs<!*g={RSAg<CB49%QbA_I;eHP>ztbZOaiOk<A=i=
z;A<u|X_;*ziQvnV(*)Y)?Mn7u^weD*7C+%r=WhkaKs=_Nbepy!%~uwAv%MIH0JZ-3
zM$8?MIrV%!L+cGIoUkv^f1jaC#yV{S#;Mnq`>h`EE~uY*l)b*42iO6tq;YWK-X1!u
zyS4e&V(25Z<v;p}D&Qlw>^Ra2eFSUkuY8195t#Dkw%>QPgfLP0=dypsd!HiQD8FGi
zn%Hl+mfY#?e_w2EDR3~yqxHFdNKPD~5hyD2iw!`RgfZUE`x!|B-Pn`S&hzQy_=V^L
zw2?waBG(59;l-(tng)l~Y*`rWXm|uaiEgGVb0jm;P|n%wexdb&;?t=F3sEnD6XRx2
z%9Wtz6T_qWIbusULuWUR`7H1GM|K*MVtC9y?++QIXIixWabn4SnF+i_YYdP5=llY;
z&zOo^R?;*U!{h%s;HGB*^NBtA;Z|z@F?tT5ZJeh0$nBYNQVdRBZtv_k3h9T{E^s~p
zn}6xjzow_5E{4Yibij>*N`3&U?tkt4xB#uJVuD#42l^YT2j6d+_%>Q%c6>0G!1@Fl
z;+Et*^gB|KH{F9uMV=G46+Iv^S}QTpIPw;G8LMd5#(DcdknlF*QV$Z~tl;efv%aLQ
z&KL$oP)Z&mq?OqV-Baj3sn~Ud>=if#o!A4LT<OY5?%PZL`UfrDV)W#|`bSotv8xmF
zuy`#vEFL(jTX7_~wsvqG`s35$VsDH9LqB2|<Uof`U?78rc>in%Vv*GP5TIa_jzNzh
zJ=-B<{SHDwCLQ1|uhw}&_m?q@>3J$LC5c=+p8pWS*1NolP1|C*20fmNuvzYInYOWx
zzFoaz+;_godxoA6D8(^wbNhq<&%r&|xZ*B*JK~g*F$^N0TN{9+RC?7Hv!(Fz&kgL4
zmrM2&u;}lj-(7@c)^h;8G82QI^1p8ZZ$3s(1N1mJJSfgO?!!$;9r|s7S7uS?syXcP
zYbEy~b@=Dt;1Ig?oY|R?%>Mbe0H#hD-Y4i25IPu)KaV;<#q)EsZ>9kkWU&1dWMFvB
z@0ZI#cM~xTcAtVB63~I}CI*b#u$UeLC==CzgWJadqI^QfF6CaDHU_AgLF`k7Rt>L2
zVgO3y3_72JOyd8X9#3Bei^w4IsmRpyX6zo=0_nrQERJf`X$McoBV_-4Tp*Lc)M{kY
zPDmgAxwt?E;bYR~k%35R|GZpalU2;rBLQ3<jS17&?(S8T$aEDa{+8|<(ujXqTw>FJ
z+N;&|MF`u!EH1EpS=`wYZ+&O}98j!#O(b<E2dK-7-2Dcm00wi<t!dw#7)RVqy&L?9
zfc?wjfJQcOO19}Bw=j5nUWtKe{F(9f#R%Fz2Ztk{svrINH1L&h@A9R-btwrqMRS^8
zJqm1&LD=)?1D>ZA-}c%OB(;AYju;Oc-n?`dN$sD93uF+N%6|LnS4e9AJX~Otxb$<U
z%N>!_{`t2=rg7<5-kC4j4&$`<mCkJH{_Se-OEWf)Jm#OdRaMIDJynj;Q}^6k+m?8C
z!<K&zW|B=1?}<l@p1bG8PH~h}yWcv$4)o2S@Hw_Esxe4fS<xU(GAPLyFRv18V1x13
z`;<bG`{VDH<dzjWE4u$-&Jz+_X<h0Gd@ilaF;(c!XrU)%e?fBl<MC2%L53ks?;T}_
z1R-pHd|qOU{7A_DS6>S>W_hbtuJw6UCmR9n@XD;U2S8qk@W<_?;2=%Dd;0yS_T37X
z*L&3sy<S%A(y&3B{?)qwwgSCd26@kG+K~KO>FfTD>^SAxo->B(IpC7HOw8lxwg+Ic
zQ4E8;=K+R=*?}p4^ad$GKTprKKgTn7&i!2-)eH>ko?B`-+H&-Rq0^Dj{?zU!&sg1m
z1&2%+2|STO*z*Vt^VkRZ2fhf-CKzNr2itp^U)B`g34le$ztTpEucVzwf1Eu{vuv9-
z<(^okfHDC)a8qa|kQO5S@paJ@m!1jA?dlIczYN^n8v#>wchGRpaxLH!5S|!xJxAm6
zlnnS}&$U->AZUN8c=G^`xcicS&x0|?F$}JrOKNdYAQVlow@rPsEU<4qRnO(_BB@Jk
zvZHQ!KKDkX5`Qwg#0J_f`B&H{!1fp%J+DgeMT==I+8I*{loZK$0G6POB~?R8?dnHs
zA(eYgJM|5YREv|`oxNn_)Dy>%%C-KkEGNjn=U$or5Twc|f81S)9gEt{Z+#G+1p0Db
zu~YSS7qQS$$KrY;MgcQnu=KnODfc0?hcTer{LSEClflq)p&J94+#ygdpSd4-H%-~s
z0>uAST>QD}2R%#ARjI|*KT@{Q+2(Oa>L<j7MK+apMbw8Y%XQgzi!v-?7@R%lGg2i<
z2Zk4E56+hv%suA^>>3UP^-9@Z&V=CoN&YrGNJQ~x=1l~(g>r2qb$2!9Vv+cm_uryP
z$U6NA1cFR2j;zItTO_i-ux>yZB)8Y6baJEJ$%f7q?jU4;B7u9Fmt*m7=g1!;lfLZU
zxoUhbFbD(9&K!(8Qcv835?pb@2K+3kI4TYmhL27WvW=-m@`aJJOMwDk&(?EA+a$Et
zDV%o;D#De6NS(+cY7wirdb=EWo+3s$0ns3vw=4*Dld@I62lgD}PreuJ9$8C(XuITT
zmxmy2Ds3OV<jA7a2F6xL*xt>h9vh|Pt#7?v1*BvK1J8+mQY$DWXInN1Dcmm?m(Wn*
zWj{Z404c@mjT)txr6Dnu=%dRfkm^26VaEYSFCIuDwG%yBJR0(atWcy%eECv<23H(B
zY;cR_S<|GK!UBO^`SM_Rn4B#|FH|;7TJ}59wE*|0z86+4+dZPep+=HJiTl?RT?=%7
zj@u<VGQgX4l5!IR6xjas>LoTXz<)vy{|`a?<?#kINsc=Q<e*n&gw+0IbyI3kf)6a(
zF%GHQFMpSEgQPJ2$1=GPwm(^2lp%1p)*><bWn_f@IJ|`|N^#W)vn0oyAoZ+JxjznX
zp~Gst{i_?7lOjJ%@t{<l-qp5uiu}Yvp(B98c`Q1M5G2J$zB8iV^lk{-AFsEtiG^?d
zb5LtiMhSKJ<MZ-{4`oDtb)xP?B(*;tFOdz(rE(4DOxj1E*^%27Wc{MiQHg)pIiL{X
za0*@c<L&Y~l}QyfiHoXvKc0F#3u(8B-|)xjrAEZ0DshphG8$F!@rvSW$W}!Bgg?G-
zDBZZH)W5ef3a?1|5nq!-Bmu8=e<Q&iK2o+`&?$?8dGPr68S<(-!R-?lB%oDb1psS4
zm3svc-Tv3d^G?|I<16vQlth<u5D-oZ+W6NJri=&>SzrFSjFQK&^9XKeKP49Mv)+Yk
z*#XS`GpuM}DyBH{sdH7P#~|@pk-)??F9~$*-*0f|q<(|&7|4xx^DK~46g`s^h3Z*h
z!TmFRI}h&Kvs((k5-~M5eX?8p3ach?|B5w5iPVl4)BO8=8SxqN&%Fw)SfT#FpuwG!
z2M=nMG`J_$+32<n?vgE@_!?HwFn<iwk#p}VbrO_LJa(Q77+eHyo^SYm1g#Ada$D+x
z7KuxZp$q4>o`=-IiV!w5O0;dyt$PH*g4Z-t4GW+%6dc_54p0P-mgkbzrw9pV_U3ZW
zdS|r!zhs(q8KIt+CquC{GR>e0gjjDRIMA!R2d9@wL`Hfyv^E-epe?4rK=K5`?)6LR
zfU<)zVb5nB#<4Z+_Yb?(KZ10K!-5%O^}NV}s$zG|9j(O2e__n_l|SItiq`8Ltr#cy
z&Z)J7y`o|19&#a7Y^{?k*z3W*G2`8Mw2$Et^h_Hx4#ZtbaZ2CjkLuB@SwiD}c)A5H
zwo0n6_v-e-6{#cn=hnC%zAjF$;dZy+qtBb$iPTjDcvD2G-VQeyt@od)3MA%H^h{kF
zN7p{{b2J@r`LlNrv>&Nopc<_$RnO^4{?rk;4UeX0N-d#9RQ1IvNA7<8O3<gQ!h#u3
z-THh|f}@S@(q}s_AeDGm5wu&JG-I6Zfs?~FFC>iy8yFr_&r*reR`9i2q@ZTx-h46c
zq}&E5RZzGe&Tbs4v{=(h4xLyt)_$Vg`HA+2j|>IzBwV`<aN<dv7^k_$iB-;mE>1If
z5ZGdb`{DBDVU4gCkTPrCpZXf;FogTz^r>{{e%^U)kj(O){(hL!(*b^O_4noV8rt8l
zeSdvDP?P9sdyXCA^O=ybxyph}spssuf#FS+wYl0CM#$O}uOQQ)U2pQt{~=^=A(g6A
z$`c7+I&h5o&E<EHQS0aJIYuoX(}2y@H|tiT99Ll%+T`xihlo<}CR3x2p8O8NtA5I!
z7hAXsXqj#4HgYCXx7O2L;381@hSfQKKKIAa)*u8jUcU7OZrT16=4Ts;vy^cSx)_mL
z;=3}to~7qrO8k;WyIbqO0(HDMxB?Hi8v8hjjc-!;4p>4SOV3OPhAu?6)-Eg^MVHL<
z7JZR1ESSgAbHGK0BptrMJ^h1_-2S+^Ok=Lv&soI#(|RqG;L2%-o~Y+6V#+hHF7H@g
zOa7Gnb6E(Ft7j@jwmlK!sL9$Kv&e*Rp>IEY-G;7SvDx6{q<%dD3GZ!Rt?Z3K2G-N|
z9OcO54ue(fTRS3=Zv60h`2oVzNoyk@Yf(BlQRv2x<ZeL|TdaTKzgLhg`jOZzXkTt{
ze5gu^S7w8H-m8&Rz24Q?cT9X)_hN})74>vI?<&GNYU0!CB|v;-OxN?p*A&NVZ9doL
zBT$j>2z!?Iz{Y;u2N|o7VIN_^Jhq+*Y|p?-VL;{eCqIlOW3a?8_)*l;?*3bMj%)=r
zE03*bi(NLLOql><cBDG5vrV;+c7nz}kFMvyR}V0U^@`4Z|NhFUM`ZpSvw`<8-oN!(
zi*a-SU*5~mZ_AJX5oqO~E7&ro>v_P-ih~Kcp)%yJSgUiga(ZxmdflmHER$GTZ3Hm9
zNtrFx7K~*ooTkj<9O4_yzanWwW4&9)uwZZSf>FSzzkPc(C$1bCvgJP5jqvz;ax#g1
z-(L)Gp=R0cjj}VraR-mT=R%i)r!*X<@A@D60o&Ab_+)|T`VCpd8NWf3#->rTJ}3M=
zp>|fu@BRr%MU+3HHYny*yz~ZI1y)RO{eV~jfPU}B%uu8uRy`omO%Ilnk_=Lruikac
z=)VQ)&H?Y`QTV(+L9J+BWQ#<kesA(iVaMfw%kfC~q@dTW-<F~u@cNbZ2MkvbKSIA?
z>Fv>F(F$k-gKeYc3doa)l)m9+hd#&TddNRl!_WH*DTfA9&Gd=6S05CSJWijZbhC>n
zg+|p_jqG!dfNaa7_lZ1P-5T9h*_auCG@txgc+*g!68Yzf{5+oDpaFf72G{H^pEEK}
z|HPy)u>>WIHISu=>u8I(bkhohdSntmD*xO+tdAMV$(@HQiKR{C=>f8%BP&2Rm^MDt
zuTU<2Rdd1GoZKkG+Adp_m#E8U3C}M}5xJdo!)gPA4>m4C$QI?&O3~@ro&#HFOxu$m
zE;lsvxLBzbhJW7S94Mg}gg^Tyq(3P-?(qAJD6repzo6?=#zC3EGYlM@FO-}(&0cjc
zLe{IYli}91*F8amalj8BNt^J`d6iJGX>q-qv?5TLIVrn6=)<@BaMmKqQ3}y>{LI?U
zB-#tll*b;GWjjF8^Tv8-21|Sya2-{IC?q9~DiYSTGRKpq8)({}v!!_+{PQqM;RsRq
z4?6sVmC`lav?*KC{<^Bh>+BzNg*K!@7-T=&_~b56JR(QPC++g?ttr35+cXN%Ptx-l
zN#L<c<xa+B_>+uiPR?}vaY+F!|J+K~db)2>-!vki!O5}0VC8_2Q5DHYG}^kS9gQg=
z`f+;ZM~DWrFQzzax^zbONit8!TGB1PwgPa0hW-BH2dC~on4ND`z8nu5n4!=qU|t>@
z|BQx|5T&#RR%0qiBsX73aX`~P{%$>TC9T(cK!q<Q2~Uzue<cn^Rw{f3IKTJAEEVUc
zeaplb&mN>fFhq$bKn*@c`-0#HBnS?EC*9lh*gZu5rY;4~)2yjw<BpLme6{0H8Dr)D
z;xZCF+s}cQ4XF&xOpkYf;{yA=7a%}Aw}iq%7*FaN*;kmf+39LwhOAb`DS5gXYG4_=
zyz@g^afL8=e@0+28@qA~A84@i%n+mQG+z61MiskEbSsG$2-*gPv{!8K_ZCZP*f!_}
z^!B5H#TYi;Hb^806|&Fy$Ab{0*4u5!$Z!?1@u}F?(P!%`e5qR@r3%<<>4bGT4MX!9
z8_%`d%2&gQD*q_HZ<Q^iQ^G6uo3cBT%QFYsHOOxF3|&jZ;OrS6EoDrqEP9dZw-?(N
z5M@vQapQX9PKrw&(%vZYtir&FmN(m6rx#_zLKu(Yn&KL;Mwc^?sA6Q>EuE3bylPww
z0+loivF}xke`!RAj}WZ3E;lVzzzVMwHJAeXNsUzt5iHY5O<1vT3T*qJiwkH&HiW^n
zvlZOIsOmZZO`J}9BhWsTa@z#cXNAZee6^xu5;bqW-kxsELl|T542jJ+SlvjSB7=&G
zR5j&`i(Ys@8!sV@S$Liwkog$|vL4}uy4iuu<<MTEOU0q-QQE3XU6%nhGx&Cfyh#B;
z^59w3LTu}wS|C)WLyIprM(!)-HYT)V@9ZK(%0HJ$Fvj1RveLxx%GdRZfPlsz*7*>H
z0;n5rm|O8XSvkl*x1>xrmMd>Ox=S4S-?jDABE>QtSu7RG6P>#L@fJd5rd)xFmh0cy
z+ur~gjX|R`l`BzI!%Dj=M{8sP%(M$k^;+14F=(lnc~>IJySy~!-rN%368Ngu1XA%;
zyOwr>*Whg1-UiFW;L6zwZ68o6AW8A6jQ8_@jZnG1Dit7xnJTEi@4wm?sFlHxb7YmN
zjO3iP-Bz>%F3VuYIl#u~A4T9ck0<;FcHxW}b}rm%0YSnb6y#;?;_d=JU@+rMWK=P=
z*|BRV@B=*~&a4we6{dRD@0G*0XBFW}{<%Vyo&aYds(3Z?e>(+~91PN%`PGJ3QDx5U
zckLRoR<66Y4=4|OHG77YF9KinM%9#kRrFufZBeb7*E)kmXE5CC&!;}sG|N|X=zmxU
zgWP6g3XkfW)K9({FHT-mk#F9acMGVNF^|rM7bG;2u~rUkVYF{#FT`b6j7fARYQMpO
zA!SwLI$f#pAz)m3Vw+{G0#ry!VCPSWS&Cr2c97yeq;Kb8fx==5Y>6I^c7s+BgU)8C
zK&}{7!MNkQ>LFQ~^|56JMAk~hB9<UnW`Z?ffeK!EXZJ+}%XC|F6GoNLHAjpu47%!J
zZ{3oD-$LeLuT_~&0XZ48HDjsl&7x|rH&&nPM31FH^n|sp{f7u!Z7W-W;^_!;`vD0F
z?HX?X6y#g|d^z(M48IUBT-hg$POs|U47=0G9h1^2WpLJxRXSS!r0@BN_zF!0k<|Bm
zg!2Qn*DlIdTKvE(-T<NJt<|SLa8O*Ki91@qY_8)K4!xZvDLJijlr;DKghF7$swc8}
zw1m%mzm3fF9oYHl`D+v#9HQh~)G`jCYu%lq%gCpcD80HCYbsYn{<(s*p2Vi0gRx%=
z?!Q`v9^{AUN6rywKsKrSuzp6nXmR<!S1Bp_KRKcvoNs4Cpawm8jmS!%gA*#02WrrB
z*9bH)jy0D?7ewG%(kca~yN;2)^Hf4g@irYmQY7G{;^-V-X&#c>yGLR{Q@JlLEc7|>
zbv=Vkl^c*gXRSR~4S1uTzDBWuRaeimB?zH=&6=SWqZO$7`tDDDD~iyy8J@}xcst*H
zl<!BRb#0=j=)_!(uWs4h-t@S<-79#C-VXfc?u1`g16Am`YCu>TREIaH(-){h&s9^<
zMbS>kAU&$wOh(xLdc43Up=wc{JXeuc{B?M_eWzOKUpp>0lH6aP7wE)5?qz+U36fk}
zzf+CNI$lYVMK<2ci_pE*rrs@u<Y2>?E%>KE5N7p{!z!|akv|)+Ut9&kY_!*L^n$}N
zkVT?T(bwg}LZbb3c(Hd>72ddH#umWey~rv1J6*xJwrg?%Md&GLM9089_D^Y;9h}YU
zsb?y<aCgzBBQAd~_T+ECarDG9fUj!$?xy>rfobbU%u#HR&kofaM908|h3JROQFIcl
zzMgxm9g^H%mzNiIsKM-wy!au~xxX$i(1~^D&GpG;B)Pv?USd<p%Vkae4Wawz^I|dK
zg`oZgD>p~zUf0w`6p1cQL5Za|dgn$DTGcD3%qjXkQS^6*yVJ*R!$S4^GmrU6VMXL7
z!oGgAbrOv!p?dZiK?jlhwQWy^B5?oGyc8Y0HIumYej&Pup?cmKmE5NnnZe9E+Yzhx
z@1xwDPzLwRy{$KxEoeqV^4jN#NO=GJ-p~y2&Es2+ze4>!RL?o{s3rvZ&U<$|d`1&}
zsQ&3z1sm+Od(RoN6`6~FPA}gt5Q<TA#H_i`b|Sg`^LYtQf_TyBOgCtv5A~ivrR?yu
z$eg-j(j2gUde)h$W1nF=r*L<6e)0p*gPwGzU;}p_lcn)lB({I<ZoG;>;?$k6x{E3E
zAym&f^N1}5dC4d!se`J0<Y-%c2=GWf+syL=V#gr8h6M2m`EH*tC4!6mb2?O^`e}0n
zT@GKaZp_KEIFRaxtle=a7<iF>=p6bf75v9nuQ#Um>O%G7<^VWw(vG!8Y(|UVUj&eg
zfD&`fh#!_CbpJwtg-)WtCmULv15v<h{3%BPS_9RKe*<)6LzO~8SEX3u5{rB?qs&O4
z3?*uD&{0`&<CpPW5xQ3!Omw2^Q^md;kI?<w;){YAX1G5l{qquVApJNwuZ;_IkmEke
zHMR;8-M_>yMMoAMdg<~#gzjI#FVWGWPCFCR87aoUl3${O<Z=1k#T)50nNU5o&8v0e
zaRVVd8hUuY@1OPPF;=La+(v(*th5~QB}$LwN~t-y=|Q|Q?l7eo0OwY1YrQrY1YAAA
z4arQ|Gh1%_H5sTxKU5CE%S|XbKyMxY_!G+F4%M^XyuTnWk6Y6j<zb?kmYiyR>f-;J
z(^I}sJrT}x2p3l=zG0A<z~DRObE>A}FWy;BFYbow2hDlD!Z!xVHG9DMja7?2c@;Qs
zn17+cxY#U~LCxGlO7xtE(ESSy#(h`N{;O7a$w5$6>dA5*{lJ$A?q7Mg8K^4t6X#TD
zPz+BQJ^vS^6#ps$aUv<h0ZCJzH7+$!F0cG^8vaTiNjVx2yiS7#`~l*xo<Qf-gshHe
zBjDxDFI@zICfvJ=(PeC@3b_4x<GY~ufTs0?IwCvDO!)(M{)#l?UqK*+2YuZ0TefCL
zqWjnKH^6}j9ytC|K7{V4*GtiX33jZ#7wu~FL_4qAMamWiPBvw+aW%d{YWJ@o5bZx?
zkQqvpKZ_LO-(J7~2a2h;;>q8%-5si*I!6>^UW8D?ZG%aVt*I0q-}kO+%DxW*`0j~k
z(*k|yDS1R<$Ag><nkhETCeZKFlk+?oRK8^aXW!K5Q(_UY6g@eQ2oE}eEjRyg41_K{
zM-PAl#ov#K*nt%9pa08CuE>Y-JS~0@p?fVw7k4GPv#d@{F}mWSbHL2?+&zzKEOapV
zIU(I^^a=a0&<Ot`fUN9n>Xsw>Z__G$Myb-F`gwF7*(vVl7qf|%CDk!zq54^LDz4z-
zitwUr0ghx}5(c&a-ZCo{$ESUO?bVy1O`V?9N8~jwyD0L``)b=&;5=MzpT)crS~hNc
zSn6=%%Fs9Rel0f`0picq_|g;mym94t{Rttb^9-8WEP_mzzBYTx9C;JfdmA-W&+zl8
z$C#BQrWqOgN8@Ug8qtUDPHql1GJ2vP`5j~P7$Pos(cMz%BRda(Hm9EqKV$QYuXPmN
zI($9)3a@?Y!j1U@Vmm3=ov4j>W9A*X;PTJC=>A0o^GD>SQWOZ4WKUl)-P2>w*PyQp
zgmP(rp0OIn!oyiL`|1q+7VJN`48SDm7a?-s3ut<L5&TYGutU)5sd%6<mW(v@j=tZ%
z0tjtf2B0CUC{$CBc0k0xNgz~kNr18fwsnDW)z|BDbp#zC{R}(P!DOW;;FBuIA;U5m
zf^BNV^>G!!HdQ~(PW=g*Rla*K^Bx4vtP*5bLlBrvGgR!n)Q)*yfkeoq0$R|v$WCl-
zy|GpXSsX~EyWCVy12ki^^`=0)q(-mV2%07xy6+#1>_uzdrnXJF&1XiE`qAA--3x6a
zLEzU9v7_**J}>g*K#y;bT{4>l?$5AVSY#vhaqeYfLDAsd>ZDvW2+vZpRlT=gp9FNz
z<px?p%jr%c$Wz_#3|To8=!8oSbi=2llS^-mN(UTDKgZ6!yqN2LCw_WQup80OuOrYP
z##GywG!)70S0KRS!KU;Z|0<H3xmPf?Za@RMb5?wz2C^7tWnhAfBrQX)Zx`hRn|vXI
z-jcG*^yCUQdV-)k*cg0@^fSnVtJQZMYk*|;I#7yLjU&6LHh?qDj;vV{Eva7-z@Sr*
zp5Ds~9<BwR??q0<^XYbB!j7_tMZskWnz}HA^{t|_CwnR6r-Psv;<5y7aM&XJq4nqg
z0WEVGf<A0;{GM*%x+1`FxCB8PTGpa8)Sk|A?Gps<m%|&Z2cPLVZZrFGU^AJcz4w<w
z^>5I+-6rnHp)u>?r^bWb(@SUawgH}_pHAlvg+eLvIMOG+V=oCu)~`Ui@v8)o^}lGH
zkZQM9*wgbM3F#-)d1N<seAPvLUK#WtR$V_<9Q03Oy#A>PEUDakd#hCFMe6>_>0S!%
zFXF6k@8uXw^8Jn@Xi+EL)YLvnYY^AWqRxD7Wci9Q!DMn;^VmU!=nhpp38=#-N;f+O
z<iN1x)++H-<?4HV9F>=q-F(uZd2%s*I%<;Q2_wHgAcbMp`7{4#yrLyPz{zsr^&5Y{
zjpt0n>Vn5oa@6^E3KHJ03cxtT6N*u5#)pNPe~Q5UssKa~kQIRCtd3nitRHkk=6)G$
z+?vrw0(T&j&w04|%MSX^Yr}g>tCX!KH@da}aHEUI3B-uQDRt^hnN2E;9@lDuH$B4i
zFV(uuUiMK@4><FJVcTdMKskg@ISP=X;``qQ%mY5k<qw+a&Jq?LRZj|NF$Y)*mqh6N
zfUp#@8TxzowZ$|giNRO?_>h!dfP<GiquQ0u1L6ypN$8Q?Xi*uvb;lI@|L?t$Qhe{O
zI!sR_berPA!=mFE`d~e6cit;hVLEN`h%pL&X-72NVXNWAr@h~lpCbQUe#9jYTFQa#
z{D!xR$0D221^|x-31~;@PMy)_R=Mg(D_Z||gNp&m!eqeK==!%UThnXx;tGgAI=A~T
zj?kwjwLb!qzt_%Fc6(5YzB*>pJ)mPQWzbwc*~=Fv1tc-oEqx3SOT)N~K?mG;AxQ0U
zWxg^TETDeaop%9c$`7KQ;>BOJEJe31VG1!zQ&UL2$o-)r`S~wS4Fd5*p?PSqrA=Ee
zFsoU4Nw2W92;VP<H+$(~&=akPX54=AGs5>P>znw(dnhL^%lPwvG90FVcGkVJCVmH>
z_^xpKr2ZorYP}nzFg<V33b)ED6LoyAOgKMr_{!@EvanDhx}G<Pf1*mj(TvJqho;$c
zJqM9MTawCi08{Cz)qL?wx)@4W3sZI$DO#l*SZ^Ke`JOo-iTb~J=f4G(qtq?j-=Ohv
z`u|!#q~ydfE_KlL4YCYC)9}x}_~|9|3tGjSw(0r>S*xR8=<?zAL+BTn8v@ran2#M$
zE#<k<r7Im}9mb^%x_&|K-z&&HrD0RF(Q&eI^BnZNEi8-~DabG33r2^dK0Qj?`e9ru
zq5D_F7RP#N!M9O%vhU?BBmYDz!z>wGzheX^@k6Q)4zF7AhX4^b<e#gU3S*WH@)yjc
zDP1t-bCCaCKlcOJJ$NlF<uZco)V}}j#ZajjCEV$0hEBM%j)uO^&?O^!wr6yo4YBkP
zI*iLT^eQH$e)jCWwL419%RiU)xr{^SN2KjYGZH&DP#ZQYeDON^7C%CWxyZ7dlRtxa
z{hbca{uFHJ^wa&EIA#7wN~YSWf2DUpy3h~#Gk;)E|K!1Dz7U@v0+kFP#2r3vy!%5?
z;&Hi%p5L&;pp&G(xf57cCL?LN?&a2QFY4E;Q15ILd5U=|Ax*P+e~s8%y3X9;x72Cm
zQ-*D-pFv>DKR3QMT!_q|RE!@NZGF|gDddLI#szt>Ev!&vGX*hy?wpN4{opMTQwaff
ztasEIuw-5yx#f}P&Mq1CY{UA8Dl`-CtHd>^ho0xCl=F+v!KdqKhSsN3WtIu8cMlXH
zdS;=6DDKl4T@G_3vY}c>5p#Fdm?K?JiH3S|p{<CtP5-Hrt<aR1q=0@S5_<K@T0p7&
z&d#XwC7oLsrXL1qeSmPciU~u8DHgGzNu@98K(#Ra`?fAr^QlV(IBHOQL$DXtGYTEx
z>OkJ;j05x2fs<i+BB2FqT&++<E!FbnnzmQCZJ6V-($ByP6Hh-ZQyRoDJ$KL&(`fAq
znwe;l%Hsw_;BgB&jIsrGE(|F3RVr>wTe^XFzNjW`S^l|Hpyv*{<?Y-rQI6I#gmoOF
zar!EIL4?o~2Q9}CZ$O|3QT?_2yMRCI34@lzvhnA<t4KrTSLN$10<8c&UC@JX3^*r8
z3z^>A{ueM}Jw?#MHlmPX6R-SQrY4A(dPbnc6ls`hVD{59nGmA3jJFWQzZ4liY*^t>
z(6Now=3WO;teM<+z-L|J-&yzrS~8X&3l+#;sV-|b0k3v%uJ-8C0_<t@>^_(1;_V_?
zSBc*+{hF%0f57fo;MiXMr0m$B>^y&9MOKhC^h`fXZk#n9{oC^@$QpWvp9>Xcjrh~8
zYlEzz=k__kC~F+MTlNW^dL5?c^SNQ6!0k6oXa`(b|0=D8jPlVE@u~xo)?225eu*1X
zCMJ?N`V2mD7o;UUlh1=J?ARnAD(+n)IcqQ5dR<9G{}io-4)SR6pt9{il-G0jEJ!oT
zoA)W5*K?iZ^eD1lyi|z%4Y$bJ5?dxG>w%&*tq#T=sn={xI_m)>r*#nj^5?z+-j%1d
z@kqAo;1sg?e=G<A>d>?GJnFEESlZ*=H8f*o${-EX)Ad~V&I@ghBDz*>yaRZNo}*{s
zItkBNx-4sUwv{nRdWvi5^yEBi=>i)as}!Fx<o<f~NwW((H-^Y6Ua91xy^WHT-Op67
zZ}x`KkWoD4@ta>Kfb*AVmWK<TrPFi}IYezI75enlYiJQ!dD~)HwiUSQbmyiC!&ZR~
zhMt)x7tzL*J}$QYk~?l3EUG_}HBaHbpxdS&;^+DisU52+E&f+kJ>7nqTo#ly`bmBQ
zD=<hf^a;PH%(8bz(?MSP_MPeG<W&BC<+vsw2kMD=Qa~YJ2<EfwzB1?@Fbh2;&w@=d
zPqj!fn{nN1Um$V4$CKDy0+S4JD@lV;T;#;Z6Mq4Pi=K)n#Wi6?NvD=^3l`OluzR4c
zprN19XQ7g{?>1vhKG5#b^X}*ucTTF?0R%}s#ZFd}BHITA(L=Sy>mQ~^-|MX?!Q$AM
z>WlW5+f*KjtVo;FEI?Vjqi1AlJo{ib!qp~X7cRPH_sgzBf7;&eq+orI+Vo8Uu7;16
zyE2xdf`;pPb1p%}g(%`izvPUGN4Q$PoC{YNJSq8-mj|t<d#-T(v#u^&XP->qH~;Vb
z>ok*v>sfLhc-eFon=aMZI%d4R0qI1WiCy60ESSWWUrSA_Ok+!Uur~c#xW)^A1T}Q=
z#qQL9!}Zhje5mD!2AVvmIUh;N_1_TTY}D4?ZP(Ul$;hznM8R<Vqpgml<-k3=a}AQF
zAO&!JI7HG(lr+#ibl%s%f3;p=`7iBsb;|zvH*^aWuIIe@zFj<?E_THwguRM?DdO%p
zlqNk`FFoPShmLN07Ct-zyjBvfXS!Laox2P&UTjf>om^<^yS8p!W}s)dS+L??3SyZ}
zn==51)pOb$MEP(L3651-+&zVGxehDg(F1lrj|{wsG@vb&ZFz~L%QodGMLQ$m`oVV&
zqP&nxW7gSeJKshs;3i&4ju#1%EZHX`C*?x8T&I<|LbU|9;t!=>rbV&-RMm7`QfDp8
z+w?~urk=6p(kn^@yB{7dN%tG!da|00o769{Ucba{!>l8C`@qrJ`;I%;>jhdLhwB+@
z_Am75-&wrlq}CztG%4NF*00NX^;9(rRt>ZzUmE)|h+KMlnvDlD&Cx11S|e1h<I0CO
zX*jr?^}-q8w)zKIZCQ!6uJ2QSJVNB=S(;;e<_tQ5zMSi?0#RsGt%ypdpO6J)FFnP~
z{&ImT+Rx&j#*6ey_>L+&caW_GSFx<6C|EvAi{%?Xeb53#Lp{6961PvceimIok@Ta!
zL&wm!#=`ZKG7H#v!%TIl6ZgwqL7>{5tPN_sV5UeqsnMwU!2R_j=Ukv-y;NBjHyrsD
zWqO3`2hCZqW@FSiW~>~5n$SfD4fp`b&GlTP3nm_PQ`AwUY)%Nv%DCkM0%eUTK0$>&
z8&#|rS~`~h3fLr(8;PuOYxdPf*2{8X2`Z`%;~7R(+KK7zokYN_oGXEa|3cu+OTViD
z99X+wvK*M2*_{d{(*sHM`)6rpmZZis8C3;E`t2TROX^BrdTN&m47l49=X5`W5Lw<^
zE+9w%E4KREzmMl4L~T5@WTc7f#N>=K5TbU0EJRwqz4Q6*s-P~?6S7Q1*^UvdBl_)4
z_w)`xxJ*Aa+B~SwQ~Jkuwt}#te}C1H7gd`>`%f>9V41Ee#YMLb8W!$S7Qr$d)r6&s
z_HoIbP3?m+SDw{|R>MtQw>h06b3)rq;NT`)Ps4K5D(BM?7dZRE@&8ehZMdF?rQ(XJ
z!(^sb4lr8timUCaSUVJ$o1UHJ`5jt?^=NVAB&fpltSl4PzTR#~>l{6mTG4gBbYr=O
zuHdDoV$~0eY<i+;aE8tm6>`_<mQy}Pa%xS&mQ%jXO*W%17uuO%+nHNVrW1$A4WqJ9
zd+UBb7(p@<Eo$-1-nTaj<Zk`^Hv8LAJN2){S8gLvrsvA{8>l{4-2J_(-A#A-tyZ0u
z-;x3&Y5BM3z^dz6SN4}fpUuA_rXWJq_RMTlbGU`F@DB$D9|In$=UbVmhSRqd4yqpb
z<$l`oIM~tXc~&N_$t$)_`{?HT=65TS?G<x*fSze(qKkhjuHSs=tHq@KOWSe-Y8};d
z{kZhA=BkY0n(s{e2_zZ)i>f{u#fUf>`lhaqE`dIs>8aHEJ52s&ACi-qV+9~=5$vhh
zD-D8Wda8s)Z=Hv{eX5ons9e6P{d&t+g>Kc7wN=8SOdzD_sZ`cF2|;Opd)>MTZNb;;
znN$ua>KMm9Y>=ID7{c{DDhpQWY8lr7lz{L>ubmS>K+tolte-I2TB1Ty)to$F=-w>C
zyX2qC!}N?Q6IV@G6Y7`jgH}!JuofIl1hsG7?~GPWn+bfN;<%Q&?A~^<ODVl4Tu-2K
z!OEw}g;oW<g6`(lUihvY2nl*Nm4#2DVWH2%zLd(9>BhZQTHiIJ;lT_u+GLxk#>2Ha
z#ta0Ws|_=@=hE+9ygGC-SS~$n%J<#Ub4hu1ad+DhK%IKFlm$xwBh$RP5xA6|CglT^
zX9r^Sm8A92xSm<$5=m^=GBK!9M!hPhHJ_mDw)7=R?nYW=Zf1o(p>JhrzxQKsqO9je
zIZCK%Q1SzT2TW<u@pBLjqPdPMWEQzrQE!F?BR`YsmCA6dSDR}rFA(aToPLJt2HP5R
z+62ltJrl~(gBZCA6ma)e$NdOZ>#-)P?3;@JQe*a&0%P|8m(_w=E-QA(Dq{M-e@qMH
z)RUkrIn5}jqE<S0vjjqAmc}x+0-bKUeLD!DGCNNxbV{c+&7T<r13dxC(17T@$?k*L
zz^OVob2f7{WfzC*DNt_QAQ@#;<jc_yx*&;psa8mA><(%8&Nd@WbA-!tS_9V@3v9~k
zY~we-{z@U~vr1Tu;rZ>UrYGXkpUgIwi~uS){mv+)U~K}k6)gW<9x3?ez%dsQvewVM
z$RhHpOV?@s$p_Sd_3b0ufhpqZC(94fMT_9^q(l~zVMb(KvS*%AGNcgIL4<y;m`?|0
z9d3sl#~k|I3Ncs~UUP`hGo_3$F3jOzhLhPQTIS%ucK`5`{nW}L^b9FCEVZ)SJ34l-
zSIkK|5&8*YmL5O{y=ayP+i5)$!J|cqB@0qdD{odRupP<BbzDGbto753Lr6xg&)T1z
zq-<j@w)uHIl9B7JLA1TQw))`f2$JijU}x}h+vn5ly2aVe>f5l=KLuah=#QvA-!;v=
zBlK)1g2#k1>r7+L4Jl)<{TTWtaD5&L$^u3mja~Dv454{8f=7cAxRMMf%s{E$zAKv{
zN}_tJw+KB8%JR?P3@>CF@wr;PwJqFe6q1!!97|b6SCh2kcf7jijBN%kr`HelvaDaU
zH7O@LO{0O!kR5QnG{x3l!sx!!>1kI4j|(N%i>_5b*Ry$KWR<u4+~2QtR%@-|(kEn_
zn{8mWr0!+R1#`mm{GR;}%LP-SzkYU?54!1vfSK8qzW%nFd5YQ#=JH!@Whnesq(5;o
z2g<AhyN`{h*Bm2wR47xeBC(p)p&GF}{nKR@Fk2oS%EInISSwX4rn!nxwQ8`;R{qQ0
zcFEwMCQYyY;jO9`ezpgg7mooYWhH^DXF|8eAaL<GP$r_RxGh}Awo2{mzeeIpFLRk~
zsJ1Y+Z7WPXm$Wuxf*NExZSMRA@LV1b%97WdRjee%#doGRM8MoE+uh`>(W-Fv$7Oy%
z8rC|nWeJk7g0^5ga#cA+*>Dj&UX;*;S{2M1)c|yl^~Z)jza@3+r}@_{20p-}LP-f_
z@*)<Schcww2$i>?m8jzG4ME*>AhryMF#3U7)+!mp#>{Ok*?wm3pX(s-S{@%t>VYKi
zJ-y#qBFinsyYy5j%exMaw=Qlv4jX&*ka6y>LUJAUV1}kcHw8>pvq7(H3+JG3=Vn?v
zvN$m?XvgBxz@PL(u<Vr*n<1prpR@Jb1vV}E$24u7%9dd!tEc7Y^+DY8(g;>t8M|RK
zlUCV>{VG-iSyo$X`Mec0b%srwdqIk-l!Z*@lh7%C@~FVhfq89FU8#V{dop23Y+3()
z<uV{#>&e!Z6-b(;ai>AuB3xehPi|md;XDRZxc~_)@Ajy;X)?~6f|RRWF-zbS+K_Kg
zIkXMIYTeciOOsYY(YetGmg}|#*_6UA?{@G4hz2|=RCzSMw8yx1Pe2w7XJuD`s8)la
zvtH<rB-FaA)Th7`|56Hz`RT3)*jr;)J*-_IpQn<1Ql)w9Wbn=U)|Dlrn)$Q-a=i!m
zX8l&%#v|EuNxj1BfXnl^O-3J3=u%ypR)gPo2y9Ycp_pQt)jwUIt=oQ%K(ewNQ%EV2
ziGWrXeMq~GKOj);s++PJci4y}<(-nb9jJWt^QC;CsGgcXGUj6>Dy#67-;c<NpJqKg
z8-X(2(&~yUN`0{NL{0?C^i4@{vP&taoH#Hf=v^Ds<(}F==eVccR&_9^MWjQW5FW{?
ze1N>W1~$PZKkVBVEWduLl)3y8Rs5HlmsXa0_aZ%jkKmD<$_IGJNQg60tI(sZQZw?;
zmHl~SCx_+Y6jULx%^S-FlcB&3sP$K)plT`UNc-!m+sde`lkb4?Uq4F9)UEudxQQ%7
z4BfO>8ku+tX+UdY7B-2lfp0Ya8w5iAOer6r*$h$KYu%U+!T7oe{hN_)Sn=Nmtg~Kc
z>Ktz(%~oA6t=C%XB^m)IX#M-zKX2^@ZmSJij@#1e<lQDkCIG$i*iOP!&C`7nwlDn`
zum{1iHmoKr;yay68#JDh1|oQTCjl$?PWH$UN+L|ZpaAM;^O#No+-Qb?Ek>P(wO&EG
z&^oVaV@59ogvJ5|z8g*nR1x}TAWc}cAj&do?lgL<J3>D*%7T+!OcnFnBa2$wWuPl;
z@rX{M!zNr-g}nX#rTw-KxFMNIHc7-P+6c*)^~0+mT19Ey)%tc~{wwP&d}d4OO0ZfX
zeVz(Nyq#^bbq+8i9=k~>Q-o`$YI8!>fN?)J1F1#NZZbpF!3?v&u}Gl;qrL?jN*=?>
zlod8Chxf_67A%yW;bbioNh?Fo?VV&Vl*^p-L!f+s0i{XNKKJ>MS_qU`2usG4I1yJe
zRrL!W??B7X%%~=)kXnJQ@kW<D!0q+Zo-753_6O-xjF@%z4N$c4C{1GZF{P>e<U4@U
z6rmsJ<VY%fKrIDdfAGdO=?wDE<*8cFH$ByGC?oPw<R_o~uLtk}9<`~w(NlrvxnpPV
zDgd;rAMj-AL3SxXHu-AX*l>i(I=d+^CY1@o7_BZw2b}`swg?`%$wU=~tFGC>--o3K
zHp`<n2~>1{xBvLcC(!pZeb%6iQ5)Emw^vhy%5++Z3T(D{y(=d{;jSk%Sr#BsBg4f=
zE;*G;i3dX?5`RY$Yg3nrodU`2t@y+5BUG)Mxlu_^sN392#cexqd{@8YG<_F7Iy$pS
z!L76{6v?AA1)*l$fuTi)(8g6HkH{nt)jZH`Uz2u7LYAWnJX-zCU-VXHBq6K&D-hKZ
zt;43znj;BW^{&JtN$SFeAM4ZH7s+ER*=OMN!=IHHFdM<Lywijg1uBtt#%ou<MX=g^
znlyGFEGbpiL^m%$^GPIcnv)4D?~xJQUjn1RX?UdmDMLqG$u=Rl1qbE(%Qgd-cWQTl
zws(@ybUbD`I8=`05t&Q{$SZF|(B*;QxxsqzcuXcP+EmPHzrP@YWjd<WS0UE*Q$)sl
zG?Yf_c}(VV8CPAY4tlTo_7L5vMe-&(iDDI0!Bd}3989a=NFIsFgrst|K2W$Ul9TDO
z@~W#EP|FR@^Bp}^i{#Olq@3n{r8L>9Ud-{zbff@QDwV*f$-MUP<jiRKS(!A*XtRQf
z;!x#vAs~}#P1W{QVOwe;@!G;4YXCuc^d%u^a&qV4ZIje%q#d8E>Q6U-kv!s(qfcl1
z`#9&<Z^<v0p6YA>BlTmOjO}lWxN*}d$Lz?k;GuHiRZML{wJ>3~cJZ`Jkw~A+tSY@9
z3`*_U_tks$_Q(DCtg_e8r$mJn^`J+i1|or(t||qV;aaIrLl;)7jtqdATxt3{ymUc!
z;HCNp1I>6U07Y9xjVX!wk~e`|&EqKvwMtNjuOYwJ<ige4bTu9DQ>|h7{FH8{8Xven
z7^Ep4VaXI#^gc<N8oVyeNCc}*|BhNkT(xqw<E~9htps<lBK4Fd%eBJ7($1hKAr<4x
z-T*ehBP*FYpq<K}7an;CY(URfax?(%{im6^_YWj2*JXumQR?RXKF9t>!g8H8rCYwA
zmP))1f&h=WBs6Q_l1gw|>py!TX_=YTqAk*#wKQS$L1eVd<eE~aK6j4oAAm|&8@X+-
zB^%$vaf{l~)_)|Av_viS&&mZ+QN<%G2{=&v6*zMhMO7YENkTfba3}hWpO$$nsML5g
zB?)R*YHGMXdF<Y0+E9tqzo%!qstqhcwy4^bgcXse+G60Yyva>cXk&+=fM&gYJPKq%
z{o8q#z$9E>dh=3CBqcMgijop!!OFER{0iKZ$5RrYE<qhTaFRfurd!v@pdztdMN7EW
zP0b{5FvH9?Z76HA;Fs6dgWReOt3EHK@nlPp&Ub-Ud88#%0d&9eS><oO0wI;hTrxpH
zT@^q7+8!jTb_?LMD8K?poYtWSFjF3TNr+0e>X)bWHh2(HQrF7sCo)-5!jqLDZ?>uq
z%vAq2o&zcyAjGFuy?r$jsg#*h#n*#G{o>FbJJ9NL9Tn46e?68ROoff)&1Mn{B~XR9
z>K3rvHy6NM_elNgc&1_vx@wos$t6_WImOq$4Lnt=SD&X+QNJF!pd`rr`d+dlDk8w{
z=p7E|OOZVKQjl?~0(R@QW_KB2f4|EMc=RQKiq1bqwRm?5uqz&A$;1Q}Q0?uvx+7F=
z>0_!jg}Vi{YcBc*)B!x=QYGJwd1?i>PF~LdJeD`2NdOxZKGj+i&YsAKq-A-m0F`mT
z*kh=`+iOm$XqT04GhkK0mC#v5@y#8Kfp-$sji^nma=8Se_?J?s)abVAA6uiYCb0I~
zEmwsX;~Jbgei(c=kFq4CBx&X8{avHL2?%dGlR!*TzWR-2)%GC?S;<u5S$cFzo&vod
z8ty4$lxt=5+$5vqX%&1Tti_3R<U+;G*DDRQSI3RYa!+H{f~fk`k8gcw>p&1ndAuYO
z)G&8NryV-~{X3FX8}&`wl<jnps1(p#=Pwu+fK;_=?b8EF?5Xe8r+~E`$s53Asvs7e
z)Wj{whFbqTno=dvP?jTLiLl@I$?&h;Qg^wiHj4OMlx)wt%q<P3c1QA<N>WZ?R7A{Y
z3mc=tN6%9-mr8&-TM1`N*>YXdU!ecVBPvNzecc}-aJm<BhJf71<0?sL$bib%V&^L0
z20X%&MC}0fsOMhWQO7m`R~+EYVlqKh&#EzaTyIdL@Fp--GR`T8T`l@~!zH9qrnja*
z25;Ur5e!g_<gt~UC(WE#ovYQS(`58lf{LD~WX9^aaU@RvzJK2>d(mAks!hv27ZpBG
z)(Cx$lvQ52mQ7+RQtIhRmXzsdM$&umF|m)p9L`7{Hwj%)jShQ06eN=vW+s)5bY$?g
zJO390wtPHZl8`f{d(WAc{jmmw6CN|EQb3PxgKc^;G5*TOYnMWr(Do<H_?J>|vc}uX
z{{pQ<-fMJXc7>8q-<o;52XIjyHA%o3gDYq#t)Cf8;ERmW<|y;q?Q+Tq`@!Q1=0jp?
zJ<11&=+1rOr(d9Ms;^5OH>F#W%$G8OZch}CkYvmjF;0>c=f9g&xgvG`C_O33bbdkl
z^^MkWl-hON^1rB3qx6H79HoNBRR4+}f?<|X`ngILs%1=0;M=#P&lgfmZ{Um4PgJtL
z-I$U{LUhS7+qzKqjN(z0#5##U6$^SuGn(WJwN1*&%u&3@=1f?6*mHE!&>9GonMb9p
z^v2JyK8X*}>T`Wml78(h<=E8USE3FeRIa09D)HsKD;L`Jj+0OI+dZG7k`tNQuNQw#
z%bh45H%Y9MY@nGL+WGbsPs4|TZ|CunEKI7=zrLRIHf={l@un+P3h2{$kd>oUant<L
zV;K@xdpK=6Y6`sMciQ)8j}*(?qDoYfO7A?r-U&&{Or<GseSbZ$b{O6CM}@F9s8vxr
zCOM?%QH03yQ-LTHtEA^*&HworA+nrQB9hcxs(AL<2$AKW0+HtCY6-J?+tJD8oZ5=d
zaZYOV^=i-i7D&k>BS|UAcb^z{Xc%xK9udi)9?J?sULI9a^ZSEG6_tbX<*QGwh|eP=
ztx1rbo;9uFDwK;~)qKs^6Y8DM8aF<Fk-jGt#T%w%iY?w1>)dBhH}SHV(VkT-tXA}k
zQS^ph6mPbY{R1+?R0i2FZNC{)={aqbe!!9pF*bPr-tbYhmcJJ~2NF1M$dZYTZY=hC
z_4UlQHM^IS>BC0PhP=kR?)ye{5Gd1)WrKyrhU_EXS_mR7kF!)&c5NsRYUiart!+VF
zzN}3NjxW=SxYf!ccYvHc!jdJYx^3zER=Q($LEu^?-aB&=leQM;uWj?G{poH<Z5%Ug
zRSpKEWP)`O@7JgM%P1aENy;glSGa=kEfUaz>YSYi0veC5WI^}uFQJu)kals^=168%
zwl#sxctD@w-TCjxDM)5!$_)t^IWnMM|H1S%?T6Wp{fBIf>9w-cM5>NwLpm=&m`taY
zn50B}kmb|`+Q*0rV`kqJM><~amdQ6C#O1fzqRaGKb1HyZA2t}jxDu$kc%-GODG`EO
z_ZZq4gl!&oscJxC($GM34XShbGRtHoF8^HK%i}MJH-$*$RinotaKA2!$6Yc2QG9(?
zW6T)z_1c9pgN*zqYLDe;wD~dmdZx?LDsfRjhF(ZcrlZO>o~V|rJm_rYm(^?>C{0R2
zyH`o;rgAI4CLs=wS!iGIz3srMc(f(sJt@hF7B{$+K=^C^K5v3(rKc@fizSpGaD64C
zvr!zhyLF_Uy<Fa^T`ixtl2~<e!ORwPKuQ#kxMZrpc|KjX9u-xjT@yS8sF=rL68Pq*
z1zP7fSs50LaG6Or#lCLgpZ)`E<|rPKDdlG>LWX77K%1{oJUWvY?4xKk&r7}b+IHY_
z2Og10zyS(hrJ}!01XT=g{E~zeg%OE`=T=6ZC@5T3{<-DUx~=I5Nur7|p0X9ihB3}g
zQA1RfI?qA$;*puqxTNQYXNDuIVrE&P02#Y!HFrP0a(-L6F2B_VMW5e_xTt2?PO~zB
zIXO{0B9rm)0sWKhNb7`{@b-hh1_7K$WHMnztwlC6Z91G;4VH?>WD>BXiY;C^`(&_G
zJQ|Y$C=(5h-I?!Ho`JrfnP_DJTc!;C{?Gn<6XkCnlgShpT@z_=`Q>krv|7uu985?n
z&b5i(hSn+x_y<wE8B9W2+>EVWvfM#X7xP9iRW&$rB!9);SkW8QnvqP8P2m>%n|mHN
zx8tkJU$tS&=dYxGkDQ+=E09xvWMnQ>3jDZdW$xFt<#feYeSh0P6;GDYP?hbo9Xo)d
z@&+#nb}YHZ-u*;*-%BKJ8MUneTSjW0**9)mj6R#^qe4bnx3(N|`55|aZE0mosix@m
zOV2+=GV(lA$VfxpzAQUVgOJA?vLu(rm@;8!5~sMn((7Pl8AK$udxf<7Rin6G+ad+d
z+4AUybwL%(BQXhaC6P;HQ(9FlPKa3svZ+>F$2(~~`K-kPFws7W$7HgE6*qZ}0>#m6
zv!@x2-H@VLJ(bC=SvnrB*5N!`fg$j?OqQ@>gF%vXoe>Z6(5HB!ctj=#7i?VKKV5eO
z$WuHrlR!4Qqcm9;-P`m9kWqMaCIgmU=C1ZnmRCWf=JA;fOjH5>S!^9T-RDhTvQVif
zENp#h50X{u3Rct#k^4+y2023dqE5D+)?}f=rdY{Ky*>a=tIgAn)7pW{sZ}T5SR+QV
zr%5CKT!Bl^Y_bFu|5A1oVL`tHgP6smHHl@Cz%pi$a<$YCaee5k$Wc6clLcJe2#J*g
zXnXXxF~z~;=_nq{NupcwI*}``f9ucW0gOE1ajRCFVy(y}J1%Ql9X#H0O}db+${Q*z
zzAZcegs&KGu9Zz9bOQ59{g5tb@wh2h;&$$rNF8G4h)P>u5{i(2Ze?ieLEFxh*LUee
z%8}LbCrjnaKld+i9l3i_a!RN5M~@Ht2x(jEd6w`g@yU*Ne&-x@Xnn%;IW(AjxFvmy
zdz79Z&Er4`J64OZE5S$B)3g(<XFplro`m;^l>;_`D>TtO{*x3_+@qx-qUy$rZy;g0
zg|g`Cpla!_;>UiVIU-umg7WDA-AnB;^rrxX%JpI6oe~m$e_!)LU4+W@VB?(<lFv>&
zJbj9$iRfUi`_jDo?APV9sZT}oCNxO{kZHna0#4MOvt!x=X#z5eIbk4LKcUHry5gA<
zbm6tZ<XW5TGRfJ_>Z?%GRbyq^F}qKWq~RU9<&rBUwcwIePlIwK1+Qx@8}N^D-&Z2L
zQCYJjEWO%QxKk!n*mAEhuqqxA%0d;~ccr$U&^Gym%#bpxyJgk7tD}LxvWbbR*;)of
z7Em(ehdG}l(o7c38`5M+3^Uoz8MVd&SKy6mlE9>}`MX)rk4U*}mla7@xPnrLEouMN
zddgmj=8bAH<rKYRxe*bqW8?5s`GICvYVQCZ9KubwLJ_ciS|R^H<DDJp#cr$MW?R`h
z^SPU2!ovd2ylbzU%Y(J29kvIPzFC$c$7k8u+a)KHCnXF4@fd%5J$4{4TP9VinlT9#
zK3mg#LGm4t8ue5uD~B0FOX;RR<D`M@5UkdPU9iFs%-HBGR>gsHCQ$NHG?N)+4p|bg
z6=a%Fv2!dukO_&*&ATZyJTqMBnTTMyUYtUIGQ$t+^4W>UZDp*?E4HRVpi|eSOzWw%
zu@=o6<0LU@&vW&_D{si<lYee8Sxze<)iEQTmc2FG{%)7MYVFE)SFsaO7yj=PW2%GC
z=8>VKjKXG>82HtmYdsJoE89v)S{UtHIw%T3Y6F$@C<Bu0MArpoHM~ilQo9yM&xA7a
z>_($I*`!&sgX8bLolniPD_Y#h2C@K;3MIrfT9lweIXk)8Rp3rxEHAZjDar0c&!`3<
zzJ{^9)PjX&LHF5>L+J)Lnm4>j0Ed`oULxgoPD~UTm)hE%`vtby9^qa^R=zcUfnG!i
zZL|7Uki&SKD1iz4R0BG`c^70_ZQsLoU2^hM=*WTXz!rFHC@G~eA2CFoj~Msw;12X?
zJ(@>{60n}9ZD>Ox^p67-Y&E#ni${wR@U{gwJBGKmzO+>8LD}2rc~O=h$EAmRo8r|M
zf#GY>yopYxppd%IZbAFBv|$&`o91NURu_&@*<>&%p*PQOm7aq7mN(YPhb{+^NNR)}
zoud3e$EhtxqV?luUb`dcR5b$!MpgiYK94LVMHUsay*G2L;#8)U1Ef_b`$#=i%C-v0
z?8-<kX@%?<Rmu)Gt^}-&zdkRfmDlq_NiR~qdo+(JWqp5j(OVP?Mt4!8hP@aBtc^#L
zlHjSncM}uv`EC&2c@NfE=nZ_=fhvfPP^*(=uLTt>E|yXLxxxjHHs$(-di@f+4KrSt
ztYGZk)ZdwTzH3fUTJv~R;&)QJcblbL#8J?E<dLcbc9P<Pl^XWj3LJ*VsFHZD7LntI
z5f}gd5ov(y*m8uObVcJGLPg@eeX~465_6NZB!SVu@uc7ra9=Q*Hyp~)1EQ9#4X#)K
zc(}F{@_9Hdv8#2Q+#Gy9k5Od^ikSQ-{wi}9xHgYaWuQ6)OBy&P$BrmMk8GoPyebPl
zNrWW2DN204WH87eJc5-(Ci{)allE;u`qkD}*5*KVP3apvoyO({vj?Mj%qmk(VYc-9
zv(Aesg}z^FVYalSRn~98o?7Vp*{&<xmY!GV{_oCku!rHXs^s?zRCHn;o8_~jpt|NU
zt0b=I5RtZ1wJuY(+n}zztkr<!wQx$*{f<{^02km<tAwD|eN^y7%AYxI?69SEWi=kX
z%0edlf$#S=TMPCBJc5-36+_*GwW^u1{P61FZG&k2+$hUjJ=`EC-3)6mG%MwYM@Mme
zRvhw)U7^v`6H!K7!cbC9!miIwA$)D6W{GX$%gBHW?XIW0e2lcs_2LxzWqZG`_y-6M
zJStW!>On=;>7ETCvU0CLq<QyHgV+F2&+zzH0#U7JE*(9x#_sL7d{--=&v!{Q$Qk@W
zI`GZ<Gi15=QbLkqI<?5y6d|%&S`v{2?ZBpQeg>iok85Qdoyjv~<07qM`umqpx&=&=
z$F}kzTc@4Qj;iX@2I*y%k<hN7rKegMJE~>|na|!(IjB)>#y3K!T0eE6QX<=T-6p&Y
z_EbEsm8k-8&(XMyNbSGI$U7f_(88l!+2Ho|18}uv@x(u?*#6*FwALX^>qRfA^i94C
zrf5d<m{+l)+W>DL%-H+ON;{3Y99P@j_BpN)SWP$O&fc7AW4b<`N4=7gqNfBhUmITt
zfik^U-lU}t-0;V1y@8wYm{(F#k#hl~@z%A+UxIxYk8&kptINv=B5MK5%Jq8hDM$~j
zq${ySuatzw=#WcOK%K~AUB%kBGQ&dEMr5z4cW=vjLH@Zdft6v!@Iy;bC)E5p@{eR0
zYLu3cezKGqYU0wvq2Hr-oCM?aqIr|03^8S!Pzm8Ra@GF@G~{Enu4RS*`A=+JFErdZ
z$F=~+W%b_WxGde?X8vRJHo8zTJaU!L07;EmvNsw-Ju8OCt}+0nN{ONNJ6>P`f@Pf{
znXo7hjO%mmCT+RK@WxA-u;O?_HsgiUqI|xoO~%qR-^B2UR`w61LRr{W_*fFsi#7#Y
z#wPZ8=)%{wH93pYtBEnZ!Bb+AmEscJ3oc5wE!PPLF+8%BfP;I{*Q=Gvfk2t5*64W=
zJF7bHy>-YRn9fTL_w2f^r|g2j<+R%D<#SrHSA28Dk*8qE^(-rM$%Tln+tl(~&Buj$
zeOLw@oW=0wO^G!Uu#~cs@Vv-1piUmkN`R8^a_{1*?J_IKKbIx(-oG;dMUIsRFf?+t
z`7+xK+LMdn@vCfTqm^&ehl&gQbY{>yw9ga6BUuS_OaXfEwDEF;%FMG8RVYHO<Axpz
zXoFC-9U0TYWbZ_ngNpj{me?#bFUIiLRk8Loe9)2U-sxafBreluje%ZN2{l@7Dr<)q
zm*Z*^j^nsg1<%`m8wMoh5v*d(iA%J9_P9i^1ca)MG3IimK+_qzZsAosaJf8<N3Rl-
z96|G;{h9pZKs4ZupOTPjUTJus?=2)FuO^0Mm4MHlZAFm0geoCP%!-|Iay2k~-fSuH
z*#@CR%xtoNouWAJA2VK)nZR2V$AoJA)F_JAn|Ji=ZM~BTvcA>mJlzz;@W@n_yrP07
zl<Qq3zW|R*$M8l>30yo4YtMzB3j;sp(yEMJw;HN4{Z>8$&;XBDWlIY7hu_5RZ)l%S
zxqON@Xv)B)M;&u+Evb$$wSmg;eyLS@d{91r@??amRjLouKGb)t>W#g*pCC-Guc9ei
zKR<}y4k90qQf25<>@|p64ZqO5Sqb4*WxO?po>67HRr58in#3PI-l}Qb(fVa`9j|cc
z?c^`>ojTHBi^Av*xjHAkZMtrA(E6{XX2?}q{ixE*wA&dI#w&{*l8&=-cg8N*2ntRf
zrAla7N-KI$Dj#zH=#l|8tSiB4?ZHg2N&U=ym+87rOkBEP#CeJ8WfaBenN`-}rNAh<
zzb14chzLApm8ApY{W+y9{CfJXhG4aLlq!i!vQ6b@-{nP;a(!1InlI%kk`^nt=@F>B
zd7LUKY09_JzE56p5F|(*tx7_h1KDZ4)$+e5PZ2P$JoW+8;_!<W1<xQQb3NC%KL;xB
zADYabN{?q^czi0M3AI4l7WC^^NKRg9Eb!!35hSvs&p$kF8-vStwMCNYyK?BB*MFU0
zGi~{@k3mT1F{-2nV6UM6(e~gWffyc@%0xxS;fu@PoNtFPR{-a6sBBo;Gr08Y`t?W$
zTo<<JJc<Kn%Dqk8DN^qy#qelShOpwyR<a7k?pbuH74*bnA9V$;#v@8u=q3+N0siOb
z26aG$<T0isFzNB+zx-1iaEb`7^O~&=N)9;{SaB5S_3<W8nUYGfwB1eY-`~)LliG5=
z@qL6e3n{zX+O*DWr8aR9a3FoOWB12xyVymD%ayeuQn<3n6e2tT-oXcNUwRR&8ILq2
zH9=~!FBZ3%EIm#6c0FOr{&q39zX{#yL{;e73s^0WDP;<ZkJrwW%={uf35wwnr7U2x
zQDxh&V+Y~?`*5wqmd@<5gGg=V<kH2O%(Gf%n^Lx{Iw88j{9eBR-{29aEV<FBueu*M
znT`~#H8ZQ!HC}@hhq@)yt=j#~r(4<P>sAKWnT=+Z3c9mZKyw7jt)UIxj0!p{?X%k;
zS@5`1LbWNdPTGcS@C`3^`LFi-ef~=r7=^z41tm)!cdCPY2hkWXt$zQ_jg#&HrSgbV
z2CR4uR|TySTyZf_Dvvm2fEqME753nXD>H$)@`zIc*4Xl($at>M`O`>Vt?x=i3s_t`
zR^_eUH_uq4TWvvR!5VK^tDwt{ov4dsW%;a-Rpv?2uTWtN|6a8v(yi8FZCMRiks?&!
zOy76Pf#hX*ttBte?SxWA1|WI0Y1bvM@wk;LZ{FB&->I0(bG737JXidHig_*j^_oCf
z9(zjaK;(2|_@4?~YTlegkka+@0!%G{3zk3p-tREj>+nca9q9eaU43evL=v*9W`QRJ
zRZ7qCRdQ@a5;C2Yw5xv|Sz-#3km;p>+BTuk`tt~p>7t-n{n@u^8i4|UN091Z^r}To
zXcutKzHa^4PvU@c^4{4qaS=Oc^5Z@=5G>O<WououWk?fc*18@w?Re^PO)aY9nlwD^
z%h2)|5LM6LFg-|$>fEGos=?ad{&rk?yiyJ7r&GylaI!(|TeCJ}vrf6xd$4<p4$O<>
zWi^(~73<(*@;HXD^8Ar@;DCk4k?J7Y)s%7bLW#;}?bUMCfV_A2EJ)(~zpb8m6F35o
z8YMx+#0gmmscp|jbKCC)n|t1qdls&}Cvdd7ZhPcLqylDA#Seo9PbiE|?|JknwDvzQ
z%xe%v<@dW6O6ymq3&?-UaYjm*Zr13fRklU>oHbleVe&bvMX_*vYTOT(4RWM3f1jKJ
zF}UL3VS`&V&zdIvoXgp|$-g1u(WkT-9;Ho_CWHKcH+@R5&3tog9MIYG8VAcIQbD!H
zv_8-$bobu=$~%;=A|z!xsog$yq|CT4F-b0uDy24yT2jgpZ)wTZ%VwuDhmcqz#AIet
z*^_qWJv+jFeY>ks{d>9s0#=()UBa%-m|$*#9oV5)^JSFMs<7Iu>Vn;9!#Y0t&AU&1
z_gvgo#q?3B1VIE*jQ_o$kG3GqYO6@orBZ4{Z+)$NX+i)Knq_*bD&^NJ5`B9=my2pm
z-*Hh|>OQ`jEe{E#;lVr}R0r887NLZM{qD1eQ$nOb)rxBBlLF=%ceV{!ARYxuh$&(o
zDtxlv`;{_mg`8SHwd5ov&$rWWJ|;T{0myXGlwSr6>wS0*S|_cOnvz;KvDE#@!h=gD
zBUG)AI;i5mRMcaqm&G7dri&WQBwG13?bTo_Ir<i=W%{V>CXrqA{12M{h0KcSpav%3
zQhhb|`?u{n!sV#ibmDVVaWbGP_4tNeX@OFCtfvlE-;2;7Ywz7OgmhTLgL!kM#OYI8
zgRWa4K+a20>FayuKUobHjK_VF*g^{`=Hzj2{!5NuguE<=wNA_i^-oUW`OPd3bJxxw
zQkML4<rc<xDG~@i&D-P{Qmo!z&GUdDc@xp<imRqD>3NQ6G9k)8x0rgbwXoG{`eDO{
z(RS_U2Gl#O1!z}5PMZEPu;0H(M!mOMkV#64J|4Y07|E!2RU43Gsg>pLZm<p1<)&I&
zGTqd8uTWi@Lru2#A^V;1U<T*Olu|A_dgP*A=;;Z-`x%@k2Uj$H6`kJyx%qA+tu|1}
zD#|>xl4+F~|BSKCn}aN<A1vj<72G#^K6<NW!Yy)TP^ed*ULAq)wUECjW!p;zc?e{#
zzsiMkUiCzC5&x;tco|X(*K6f3z!6hDryXfY<`oIix!x-;Oj+}8(B+G$oEzwya{`|0
z$;O>2Vj@FJSG^1}FM|$cuB2pbfzqRHT&YWTE6?T9TKlkFnp6mxo1~ivR!z@@vP{{W
zF(rCqY9_0@a%v%4Qdi7naG^{Eh>usixm}@clwB1b%wR$J5as0qf?NLBOZAYX+Bj*c
zfX0Wf>lCjK;tqoaWl1Xjg`QvCJvaYZ5G5HDC<j+GhZMaQnfQ9CVj|VbKle&;9al~e
zk~4nX6L{#HpYa3U`%-S6<)8akxL%wJGc0W5x@@3mV(_6%wYWz62<uQ&-g{~8RYi-*
zP0YsTSp+u~H}m8%OF(wk24vfnL3CJD=}0jkDuWhfDk7zQ{@LCyzDkZb!h;#aC=*w$
zb=qFcHyqe8gArxn!5ZR|2P+%d3Uyf+W0I7ON-K!m+i%qbv4KH{vM@=sX?&yDmuQW&
z>uyCGYpYKZ&g77_L4;Q%)`;uH5;ryKR<6$Dc7uYS!H4o`Lh_c3A&+VV`tG+al#ME6
z=cZsOyK$DFM7B|vhrNJSkL$Yh$Y)Z9Qy<wj=E}cXCHtI~?)$$jKJZ_Vff+O?OR?f#
z@bdnDoByCE^WnjIHk55?a!@msx7;V=jJ~I=Zd`80U_+VmrqKQ<c_TW{|2ezr0IiCz
zy)-PLGz!YnwZL{Du!?jpEM3yD0!u9^h;(;%H{y~%6r~hcx{(%80g+Hj0fBGk#yj_&
zdG?!g_m5ZHf6kmab9$b8#_lON$x@>*?0@{Z^rM>~3)6$3ED;zG9W^9e4!KqZ*f0VA
zWQu?#{_y#nLZd@JL+onR%VIYP@K321^D7{-)X<y6w_hbkJ`6>QOS0OMentZTq6ofN
z@?az)Ofp*!VW7Ho!zb*q{ei=JwQ{hnS7|SWH*WYCa7q9{aicX6KnCDnP7Zdg_*6y0
zg#-{_P$psS5g}%&Va3`-5yzyGm~qUcYF;qQ9FLop=|0F22w*6KV`UI_^^%QR+GpkP
z2ZZraCOx%&C{pjIOo$>W@|HxODt=flEH$D?vR6itostx>`h2#gA)=^NQSJdaMJq25
z*Hm*Vg#FA9-0L|erb${Wt;Oe~Hef@2MosVKJFinw83bBoNypB>s}P1n8LaYhpAB13
zByb`B>7pRQYT5PJsOqi{btv@&gcbta$-}8yHO-74(-P#c1gMiiG>L&bJ?B(vjaVg`
zCm)VutAOZLW=yCw3lSxSR)$S*oRiS2%*`MC##>cVJx3W9W$0DIg!)Xk(ro#vunZ|_
z_~h$gTLT=HPk5TokSy<<D2}@9==yI!yOuC6%AjdG6S4iNl_yN(OmYiwGO0CG)2ylo
zhYg=9-zXQ4pFEALluT2r`yQGNz(C_FS@Z7$c1oBGWpCYqC=yE5c*gLY_9;1HsWwJ?
z>{QJx>n8j>5pYVtK6yAbAe53%J=?gz2#~Gmu}`K?WoPflfYs~|iEgD|_ih3@MHmld
zva1j*JLMrVegf#pCde(-;8G~+)`{ImapRYiN)LOolq%KqFcnZz>rIJ?%Jj9600QjE
z!)el3^#yNtOaz{lfPFHFo8S4#`AOpUxvK!If_^rXsRgE3h5F|?_w=r<{to*mpq>mS
zjZfxen(4|u-vs<LVJ4JC6McPF<=fwl^XG(xo$B!qmYq7j+z~o;r}(VCJWJvCRbumj
z6yy{4{fVjDmN7nZ78F-+yq2AdlXK~$s0CD*TFNK}XE$kzBdR`eS7TM2fdtf(B~AgP
z6hsHk4qB}meIQ{Llu1;{cbfFeUKMevZRuNj$-I*aAADV|vHCG~NT43_B#0Vgr6iA+
z<H?HWX!FE;SIta%epT3bKib<l1rkO+nbKtcMX;B1z8ljcnQ8;6wS9xEY@OZP54o>K
zr$7SO$-}Er?MgEJ(C@!q_PwveKDCPPu}|enr(veGk$_RX$&1|^h$4y6qG#UUth(hu
z0_MrwKb}oAzE|I6h$=DRHD(j38NcuAqSFyoV#b@q#G@xA@~%*8=RgAZ$&f(O;HRE#
zK2hh^g#;4DKAD6&#u*PE$RY2YPv4J0QXraZ5{<eOLze#!QPpO?rg|mOQcK%nV+KT(
zXtGIkzOocf)fG|IW~nBxNi@Fxcz?X7o^qJ1R%JaV3$AVwGt~E2Z~g-b@F%VUR@2M4
z-ITSUec|^jsOfJY0RrWq3_hys+G6`>h^|%)hHNd4S-C3nn`_aKKyYRR2$aPyFM<`P
zczVXED~MZKm}T4=b7$3>Wk;6^yAijvrjkLIO~H|6klpVjxFiZB41@B>z!+pH(~XH9
z`3aH&&2|~Lycl9yCew|4`tAm#y)^6PbQ#~qyCNoKkr?K@;y;%ATu$AQ80yDC8HwSU
z2B)g0I&<0g;|4P_N@I0mXJ1-v=LilX)<y_n#Hup<Q0ZI~AYK|eiW{*h21UGUM)qF}
zl#GUs;&l15(Tb97eYevS#4Xu?jmN0f;5+`t^#2fDt!Qn>z?;`Br<Ii~aLbjifs)a{
zQHB&4U5Ap1q<&4|4%ZQ7vJso@c8^;Z>U-|W@}GGw#^vEqU&@pyRw*&{O-y~-cl3O@
z_xjf7ZUkbOY{$Hf4@I%D)Po`D@W__TDKp<AA70KjxeD58u2T@SNX$ChtY0i8q`5we
z$!?Q$Sg_Wkdn{OC@<Qc|;h?^ufuWd&DVG>iW}lp6v*_404FtsrGL@2ced|f<Lx?2R
zYQe<C@iStpplwqPR{4bW(&&vR5s%uVu{;2{7}@q~g(Zk2)kML~$g_9u7*i~GcyS(%
zHa)gN3vXZ72Nxq#3Wob}55Rv;x>V!jHzUSpf%bSj;ZEB0dzFJ*r`KnkA%S|Nlg)DK
ztnA(J=<#weT<mwYKkz5|xAd$7W8X2dYXUJQPq@~INtbhjFsnT_VWet+`TbF1RkiyV
zNP{^st1<@jo1s><ulJf>k5?Oefi$d>L7WxOvdzAG=P-!hG`y2dQ)w69eG%sotwYaf
zcqc{`4hBrP8ju$>4`_fVizpMV?EaS=Z=FWH*9;^KelinU`<#R+EdTGh5vU~V)#IHk
zQ(!kRDeE(1kV9*mNBswbBA<qHVgg{Ca%_j%>w3KQWFsU3YGh?nmDH;2^+a`yLr5Uu
zc|1#~>>q}5w`D7gc4vxlg@Ms(9iuQ>TLZ*-b*p>eF1G>cy!0?9`@BX(gVS2pW7SBI
zuFx<}{Ira0#g>5J_Qjxn#<XN9Z_|UEY;IFE@LZb+s<o>|=jO&G%Rn1w9aMMtS>9Wa
zU3;!(4lY`mS#7u#WWmU<8OwI&L!#BXZZ1<xw5X3*>$m?d0Rs!uYL`tnsX30nK3&jK
zg#ibKQRA)?25jrEu!&Z?zFmRDK{el`V8FLRGrmx9Gl7JGPo|jVSaapudNqLUYK36h
zF7sRfs=RU8TyQZJNQ61DegStgGNUtYr9wSgBE*RkMNfd7h*>)Zgj&L=Crg~Hc(L7q
zIQ$JU!HqyvB!ZhbuYBs6lFR?MXnTIdtk!TXQ;3Dn^&Gxdp%n-;;Z(y_`JDVJ<YhkQ
zVEE6GX@pZvmY2s&19(H3aqcfvO!%-Pd$yL~qTo_?E}_+1%ZDX~uy8(F4(5ZKr;bAc
zrW!40T!sFu+_^C`5-_!vRda(~PnLdXS2vDQR?DWxXsu?6kY~ooTn9NtDb(mOPqsWq
z#>m3_q<&Np-~ow<CuRg@tX0yO`Jbc%pMD1tMm$+2%l=Vw?ka<>W(6iocq7lEitnp_
z+tB`|?Oq*vs)s$<Cd<ewovr(wr|d<%QZ3fFsZr~sZUF-eB3`Lx3nA5mD}~HLylM^A
z5&$R49IRX*1e|@d3RIwk$xr5SSr<UyWA#oyzp4kUm4<&Rg&I%&-}h@~%hh46TJ!f<
zE7<?E%3Ie1E@{{&#wC-kR2_8ek!1x)ENHMNMp2H}>jOVojyNPWo;W=v{2gj|>M^3I
zO^3NEaf-^GgCe&5YoCn6I`v>DlOpfDs9=hDl`?Mx8czc|8BJDxWuokU@Q*82BC;gw
zG|8e=rR%e_S%H_P;hapeuzVfVdR7MzN@;*6b|Gg}n#zIYx&P}Q=)knLWFDAxDJN<E
zKePLMZW9&uslQ4U_Nk`-j~70^Y||8)6{Lqe*^Hux!n>b{`34cyf<J7cXx!26oGo|p
z?il}M+R3TbPL0UlIG|yIIqogpmW?0#%b2Q8Jr>+T91~48kk2Mklpx^e>8n)L3L?yX
zGW-A|ikcX??_4OXHu8dK7^qT4cTBk;*k8W*zlc+!%^J{TRkyxhFy<kmN(!lrQ$7p4
zMWFlv_N--Tz(>eI0otU}RIVgH?5;b`XO&uJ2hng)rTp6W=*v<dgStO^{YTCNwoZKK
zqM8Zo!3rMRRnBaDqs*balH)&zJ<#A#2wk==Pn~+I;|`($p$vjJ9@M#%5|P!~t$AK7
zr+^LkI{^zjqU{qcmJv6+tEep2-5Su8y8zCsQ=ZzQ)$}jbQ_TQ(CKVejeym2VAQ}S7
z7|~%gU6mkvKgZ)1NT@`E<)URCOCdYx_4m6GS)#>qvgmu&u#~?oLsB4`to6c)>R<+>
zNC%*cL4m|5n^fy+^`xFx>|o%Cvs#4}wyM?v4a<CV5=d4byiF@e>I?R-uWWd&qQ8Um
ze#Im!=fdTxk7x)yHevLW5wVP^a_WWl$8&G?v3;MzvS`RBhNNOSvHWHA`13Ea+DGIh
zsWnz>->e&^@_DsNTzBA7f=K16@wuavutnUA%LDYD26r+D@`kgWSO`}&Z0h@cc?ux8
zD$3J$41Lj<^_1+7boh477f@R~cxN$^DA7iFM~RIOmjn=)?VmhIpNIy^iLx7GSxb-n
zuwQ+>Jw&fg9{U7i+75R0p9PMJ25~Zvinl_Q9B{MW+X_IZXb>kxS0UJ=W{qONkpyeK
zlco90P!ayWdvx4OM3xv%8K2Das}1JcnP>I{3P8g)vF+n#)q=<kw-8mTp)#sWwd54-
z!wnmwkO~lEDu1NINdIKIHTJ$}!fluT9KMP+=c$w*Z!9ri<>)R8qx~gx@KYoRqR}SN
zvpVr=(t1RdXthb8i-(u%RmiSe98p#4u}!P3D4OeH`z>#k@>d%zK{Q-bY19InSI57#
z+FS~v0h<^_*#U0o)&4NzkYufl9y40Wr5>1H*B^06GE_!UcBWHPPuqt$)Se6XC!C&=
zM80n8GYwHBStqBc?78`|H#LA|hL9}NXizx2G$M{}PceQIS9B?khG^4WBjq<=kWHzK
zdoCOCQyE}BdN7kIQKMPMqP}$Q;|srY3OHyQl*yC<D*B4%{cVkXSPrYyo|SEtO3%Oc
zzwuEZkD!5=Y(C}9Uk&MIJb)z~6b-!OA*yJqf3t<3saN(vH2jiDmIZwP;ha-4U?>s-
z(MYW~gd`1^G^gWUpjR{q6T{pY-~~knSH`3Tw^Tti1d~No^#QH&#xw#czaGV8+JNz?
zgS7ohLsteNnQD#ICW+FX-E|7jM?^^hl<ywZ5m}G!S&xX4;wL9s9%NEw=6&dy9^f!k
ztqZgb72M5Sp3%HH;8PD>vL%XY{U^1yWB?~mLoV^ntM}4_>;4VC&<oOomP|f*cak|(
zIW1eX_*fG=A918*gh%R(zz4@MRR8kEpCC}t<}#JGI-V^4$vw|GI~x89stDR(CiHb?
z@5JG2K{TO(l?;Nc*T=*w+34%l+kOS9E)A+=lI2$_#&wNBTEyxj|Bl%XVs)6-Qq5S+
zVUg3+VJ}ZhWFCU#Kr~g}oMgtT$YE2?IxN-a>Av&hbbWp9F;=zLl~82qbD&x@tdc2O
zh}C&{_P|!4S~R#4qigM59MrR7;a9m=kz%zTsbn2gsu><Uq#zo(Z&Dy4stu?fqVo<`
zm4P3x{g0*w0hKn2$=JH+P6$>n{yVNYr^*k@;aBu9C7adhJ3LrOQR*~bwh^^DX;3AT
zSN7$*68-lT?h^R{W0e1#%o2ktcd$&W{(ppFgJZcma`Et=a}BNKa_XhMh|4~F?#gnh
zfces9HI?>DssUW4L#+cKDb_M<o3C<L(`)43i=a)bM=hBmkkjGLZ4O3*z)eFeF?1pO
zYEDhr4o#c99RzL~T!|A^yR=i&-Y<tpYOU7VHs~mZ1m}-OTPK#QvHT?+#R{4=p6tPe
zJ2aFwnTc;*+*b>WZSdo$5_Sx564hpG_U1WUL5i=trv2{+;IRnr(;21|ixK>(?-Vhd
zE0?R2Q?0(+oT8Z;`&NhV0&#@~PeKUTw^{0Lw&m$afVGj@W0Y#gFZZ>qaX^`9;3R`b
zru60+3ICsU>!W-iQPJa*O#jaTpPocTQ0;fRX-Dqqq^P1F%H*NiAYrTeD$~XvSN{o4
zi8h*vNkGYb_STLJ03Ml!R5A#%#8SPQnYnC}A37;*pTbg6rv5enO33uq_}}MpqEe=!
zAIN0MH1&*FHK|y2r~s;`X*eY&0NnAu_~b)hVE8nYl1Y`hJvn@~P8^fUHYtbU(*`q@
zHgL~M|7Ym%4~E+`g_-K_Q9Nd<roLH=$1}ggeUsBa1=BD}j7{`{(1UmD{f}z`|B0;!
z2aq62CQT+#e{KP?R3`;SR8r3>m^PoObW$(=4Ebfz8MRjxOdHTt)|^UfGyr9G|Ey7P
z86r%Is1{+P7bX)v)ak?Fh%m`!J%pJ7%Y<hS`5+h(CPh{cVPFrJGjuJgI<H{b*d|7p
zSFV6;ww<kKs?IBzhFCJlvc8BcgyTPF0&leh)8I;sDC3iH3#1#dd+#BeTZaK_4Z|{E
z_@T|-AAA7@D42#-vY7SAKsfNbhxYjKfXJ1>VZ?gGlHtIcuptBuzC$xK`aapV%g+Cu
zbV;{1Wl=-;#fSF`tG716ga_+b<YE-%d!<Kdx@SQg5{(vof4}PR<i?0YqO~gbO5f(p
z(im|_G*WP{l%rmS5w>DFPlZ&g8hu)p1H?*grKpJ&jcXO}yee4#I-RLP>|6Opr_Q9b
z9?=xZe`5ZAp`4^lR-3Kze8u7wHP~_v3n_0`R1V|RDyGLc6+aTUDC8gD^Ju^%lT$RD
zG-6VdZxC6n8xaC9CjCeSP;~9xQHZQo0D>$kR(=`KrZZ42J)}gCRln336V_}CNLxs+
z((%d{eO!2Z&zfuM=On>2h!Ur1ejX39miIQUy=H5c!@6i#C6lsgTfzt~Ts&18BtrT&
zs43MXMoCxQJMvd_R-|f`Gs;d%DO*NVd$beSt9~4l$*Kh^4i1tV_cK5E=4YE(hrMbW
zARc=K*EV5u{w@#1s!y@Kc$GO_n0q0Z`Ws9GDxnWH?qrzz4iG5~sALdyUfK(-`gOp7
zjJ8M}ib{K=&ZKLH0YS7)t~XbKU!mcYOrprIr0Di9Bufmc{Ca_DtJ1IfFa0O=fEUnD
zUotg-lQrG|RrU4n-kHHX@n9NOiOE4RtjgER9YI<^v{ueA9OY1b=&8Brz=#2s(=}#V
zNbx1dwEupymCIqT+O$g8t6Hx7Rqy;Lz$y);WXO~w_ADh3$?u|)mCtilIcbL-=%Gqx
z=E9z7|4to%J*;8ftLg}vVA@-BWxaa!svy#pOYsN^LhB7pwN0v9|FZVs-fD9_nD#22
zJy=}0f+;CGuCi6YDOaM+G7L1Z*qt9W{|)$T8iI-O$gvx0S1kV84KQ3ZSdU*a1)9Vo
z;MKORt%w9bG+BNTpa$5W*?9&aqC|V;Eq2DVWUU{(S<u?fSsd1?Jt>d1Di<}+yFZ%>
z+!YPI#LuZB&#~-Qqfn~I@Kd2+`!oQPNmt$e=7P~+pnNb5zGM(Z<NuGOdkcnP2h+wc
zF{+BAy8FkZ2Rsj!9F-ooWI8H{R=<6}LL1;pXs9KFNvKe3+Qoq>=)pAD5+iGAsBqF*
zQpeBb`Xsd(^;4Iuy{DeuyiHKu0?L%nAvvzcqy1BDl!ZSOQ|^Cyaw1n#`KYv3YO^cu
z?uG7G8UMDCt@{ou)iwfzmD-(aA=f&4e+%T@1&L8Tbjf0Lq=MSKxurQuS82E<<LEgU
zKsC||ohps9ckc)%H1Lv1mwl-vIljbe1y6x+Lc=aGqU@3Z6c+Oi7HEs8YO^0JoN!pZ
z8ud>txn2*H!8GhrS>uvHanpbQegu4{6ikCJF`6c%UT&$@9^3GJw0~lQDGA(r(Z0hU
zfJT@exWuJe9yJp;JlU8EwCZT1l^8|2nHU-yc*b@n4g=M0+cZ#CNx;t@?#+ns0sE!_
zmKc|IAQ6sa%=2~8h$5+{#3?EX#O8#O;Mw<JJyyv)8w;v!=jMXbs|9a81veD5xk|<Z
z_57wjzIWe_hT#jp*K$I?>HIIAqdUBb9<s#!p7AnOql9!b8vDk+cp;;qF67)i45a>g
z+>($*6ia@}nc5&ZtV;{4RDGZE%zsY4wL!p1ymRl49pl*o=(Y1Mvld(eZZ=%2#9{#z
zczUCA`U19LIJqW8S@Rfs^kyG}OTu_3)tT8yJG4>O<kcAS8P_9TCA@0Tx-MKh_|IX;
zT6RrC<|LCc=Bz~zWd<Dw8i0w<P&HM9mvE9W{0kffb9aJiSSCSPj*xeTeiZ}~c^aC@
zB-^7a(>0my<>=Vo)hPkNwDC)vZrivHe%3pws)t+izl)PWtfWn0Dvu|h`nKIs8$>l4
zxXGl+7?oq?oJj>YBl!{yI?0A<_-{+z=Mz4>r+fs{5KiT-DGc3W`^5Vj?o(!aUFYki
zxSQrbhegxIF(Fufu9y8U0~bMqIT-|5zd)_*GtPSC`5e_@$yyIlz<4l)x6EKnz8M>Z
zu1{!yC!1U5g(Mr!da6%0pbUD*lj+cSKazjvtn@h_eBH1(aO!%{lc39PjU{GZoQgUG
zG>is$GG)Nt`{uJrn0ru9?x&RXz5p6V13)qIif}7`-1t|ZVYD$#20_^AY}LM5X**Up
zEI|)`GG*(8{K`g_G0m8nh+|?bPO8s0VOz%l(C4FJpcq0^(t|rgG7d({rL{3r0DMfR
zeOO$M>3u%$5z?err`dJ6v*p_tcB^mo#+*w$>|dsS^tMJmr<GR`e1|Sfr*axX!#}Z&
z^ITF%LehMYYMPqvh0p*{oM@DphcP2y;Y^b4+x|cFQH>yk27zM4l^)XYXH&y%xe9F!
z(W9TtyqEQm8bqg2YW_!4Q-G&_Ludn<3^qBETCvzjpVi>wnh@HACX*~Wu}ibw<WjvX
zd-%Rg{DAmI4Kw(pntR>1BmeaskkKba>Srl@d{T4Ov=o+kS)P0-nlL?^e<5^OL~~X5
z|KY-=;G?<_8s3TR-?*ER&2`h&X8)*Z411fCxO<GN9Gg(Bl}*)QuiA=I#91&)V$!FR
zLG{O;DWtK=r(Om^WMQE%PwrCFL-wE=kuU;6=I(OqV_O0a%L*hRD#{zJ6sBKt2srq5
z%YH<abk$>0WojT(eerS^_@02h6G7TP{8D%S!^#0b`Dp{1Si?_grnJx0Zi;;;;gl!M
zN*O`5o3J>tXeGoW%|IDR*_J}{rT7`~s4Wx?Pr?Z*sajQ^Ri1>^xow(x8lXX*wJOf3
z`_mz7ZKvljP_1@a2Fm;>OoVIycKHC%Pa5ip9Xs#**r}z6{{MTtI*3Pp&aguW`e{r?
zl-g_#6iBCpsr4Hx)K`n|5ZY8Gi&<woiR+R%^e4rjAzRg4m@rDmQUoprmIw6c!Lk5e
zbV+Hz=Z{xzQH$je8Uo5<Jj$q+Sy!n;2Z{Q+Cg;lAs^OHj_WI9a-T+v6dTc@{E2^vm
z(1H*e5{hx11a7JLf@~X+%2BP@`B|)BcIxPvv1%_VB#3It=9@8XyY(?Uje_vUyZh%t
zXGb+?-tw`lB&Hz7*$GR@@pC)l(@QB&)`kZwPfpm5^5j<|FVqAQrU9djgG11;4u>by
zR;!s18Ze4c<sXWJ%a(tdo|*%adKx^+BCFhseCj)P9O6|gSIZ=f18Wg0W5cR99+6*d
zyob=xQH)nLq;(n?^$oDyV5;r%mVtp@mwdv+3}qG~y42{)=^7t1NOVK%e^)RsbDI3;
z@HI4Clqms6!BmhLL_ukVq1|$I2lf_BHDu1YD9PlAAK&<$*!LLk{O9DKYRx8fo|)tJ
z`~8_Q{cO{7glTPJCc-qxql*M*0~5|e^wqSb&Fmk^?Q9A?REV=F1!x*(Dq(Y@>ZuxB
zRzXvht6X>&C>;$n#g&7JRVbZsl3On<eulW!TC<f-Fm3_Ft5mr*ix9Wkvl3EephUIt
zHGlM&Awb1K$R-^d*TJ5j%cHWK{8uXeDhfn88ia~V*?3=vZ9*no;^38&NFda}oK(N+
zc0|W3>NRZ$Z4MM;ShnGys^OVz8*|t&Z2}ah2a##(CO^q#hYW}1YEP{|aej-zQuc!F
z+V(DJ%2cTC$O6|I@a~f2Z}d1SOLY?)CN!yD>sX1pjS_~Rl5Z-ve|K#$aFsMLl_3Z_
zXGJ%OA6C6l4Fo$Hs)|!rYNO$;>w{MaLuiO9lcLvkut?IvzaDu4*qk0(W!W<0l?4ss
z1YsYqdAoesK$DOLv$8m6X<&yAjJj3Y2_1Q_OysZp7-b#N#%fzfSX0lu%pMncV4bWa
zeG2u;jgFCO)oNR-QjyQk1N#f5Mra;A*>lBG+>g1Nx*_mBw8!qah>hUE;<H3|;p+lZ
zfn95bE9{ylDY9L6S@gUm2uU>D6$_yJi#s)d{*tm`ERZY>du7Q$y}b`8_q;I(7&PRS
zMHMzopY-jW3Z(8d^c5$}dXdU^SQU<?Z)~5J!@JW)M_EKcaC_x@tu5kJ>)&k;!9iVe
z#Egv%2j9tt(BM~$SL4Af^-g)@fUP%?2&g8T1gtCY^Wn!4S*qPyPw>b>==?J4bI?Si
zp|Dsx28<1iTTr!$eOQiItlhuIW?5FIuvsC`D;_ZT&!JZ|7#3$!c37`7C4LI_O&b`+
z397zoYHTyli`PybwOu~0qy|al4(6kKgT|q4YjbCtWUS;*H{{!p7j2uAHgg`;yx_-6
z!PSB5ry;HwN#1=EJyQ`_2Yq*F8mG&hpHrM#-){ug?PePieAK$5<q+_MYzPfwW$_E|
z`CAl@x(fV%ILSgS!VJ|ao!Fb><5ME>l4@Q-Rf(+6Yk!>1)&z%@YMJ#|sp9)f=ll3i
zkkHc5RTigFMkY|suS0A<Ne<to9{VYfE)8MDsPm6TnN=86g_3nzcyT<Z$~~(?$@Bm#
zTgg&q9XKyi&f3b)^*aR;S{l5{;8pZMP?u$2?H}H^J*<;!sulBQo^pJbvwaC((F~y>
ztQgbAC`mOO9_*Ft1;}3_v}SC%FsqrTe&kp6b(JHCur|(k6IRDm{@3d1w;<=Hp{tl6
z)X1<s;Ydkf!!&r6NfCaIbadFQqqZJ6Y*_0WJT}Z~8adK_ktr+q94CYZuCjQw@03J|
zm$FySOh5uOY?Vb74XK?L(eV#(Ry1rCr>lhA$&2Gp0=1$6t4xX*2DWc+&-B27(I8b8
zVO6j-(+^yZsFE^ciz@q^TynN~ZYK^yLZBM0*`)$`+>gU6oCR4dZLSn&*L+@DR@&>?
zK0g9N4-Hhs$U1RgYHRJQfL?(}d9`+Cc^ad&#{OUCdS&>J#xyi85MjRh?vgNHj^C51
zHqM&nw%V`@rQxiYEMg^Hh{*TZQ1!?{X%H(;kDG()6Blg!>`zs3LuueDgRGdZEBwqS
z>Ejn6s?>xzmW`}XQ`|l!R{f}|S11i(W$-HExhjc12V>J9o~b6x-<ejauCFuars^3(
zX*es+vyw5!6}_E^_@oA0-lkK(DUExze1vLTp){D4$tS!+Yk48!E#j7Hw47VjF%DRE
z<e?gI^*vjU$+E;&HrR6Y^L?Y<%7xN^R+a>!{Or$4jC@Hl;X}pKZU(wQLtOC{lqh*2
zaQZlKYBao+Ns%K@Egcj2c#mekZsE>`14Tq;8>*i$W#!|EBcqE{S*5g5zx-y}L*T<`
zkSoqE#@(IC^yUpBOSW7_mdQX?h(AMe4MJq8(Km?>Qm%=Et{}2h`{iVrCYaocBYRb<
zO;=8qtAq2%w3VcNWJiyssQ==UTtiJQ^HUSxb7`;Qu_NR6I;@&xR*b62{ShUq0Xx>V
zYCLxAIW{4P5k5u#&B=toxpoLbkH!*$sBhc^cqWI7xYoL8G0;~H)nl@(6eNl6-#Z;X
z7z7*x4U<(7HUEw-?KTi(AG8@%jG~;0&YJ$yNyH(k)MfN+7b8UZ?>~)}Ac`cT<rEcX
zIH!M>jA+j!du0^mjO)kYYvv#hNruYlDWUuMqEAW#)2HF9j7O`uw^q6*zTfN{#bYcd
z?bLW}j5Rdgc*yva3KXogZIEX;wj(Xprf|YGRVVeyogG8CrSfY)2d8>amEhDcO;58&
znEmAKt>OzavPC4)S~#<Vbd%zBPn4~BKHyyafO8EK8YCV)RzG38I_J1imAGrR*K+Pc
z>$bQTFpp8aU@8^<2^gIhN}EJw5*<9)z84i{wsO?&zY(uQ!!=-y3XV31@74)Gk7<A_
zKGcLYngLew<)q7@b}!T^SE2z2^6w|4l<W5Go@vqci8jo;l`1%;^@YB95m9ZZHP1iL
zfzJ^KH9g?ub3{~Y#Db{maQ>ThIj4P44ja}UzOZ2q=9CkoM*V+i3|OT>srd1u7Si(H
zo^3@$wf1Z89}Nt9JG|={73>^J15<HMql|kI58gl=*YT%S4uZTWMC%@Hc10-)Ea9Ue
zqhA3_piQCTe79D5NjvWUJ{lBaG(=TJqpb`YNd=aaS*m_S5=z5SnN*byc!?Xs_9L1^
zn}u&F9ldxt2iiT+WRqyBw+UOGU%g-mrGcm_dcX3HP--8A&R%ZYgu{HbDUvYX9zA5^
zU4AfEC$7f)=Ww$6c9*HRY9bfdutq7{$2bWR4VMvw{_y0AF=2>LVvuFrN}-@>;A&q`
zE7O2e#ym#eL9?TQNIce@p1z3xCDj{x*p!)gu+e$X+nlLcpxD-(BQyF$*GiRIIGNd<
z)0IS`)hd8>RxI5>;L6`}=N$(+9kjtzOcD%RStG7P#{o9LvPV~0$u5V7{RPZTKdH)M
z+-NT=j$u=#li#8fBpR`W*;EVtnG3!jfW%A;y-7hf)7OcOvB^5DSDVdvtk>uz$)fcc
z+-<)4;c}=RG-Zl5R<eqpyASDayBLS{($G?DmXrfCAoO<V!MUBl@zcOkoG855zj-lJ
zPsA!Q<nnK<)ePzBg}xPmo1r147^_N+cVyT$q@=V7RR%%as4x0rK@VG-oCl><C+pk|
zH>-N@)r%KZMr4V>mhB&Y5We%PAK&Lrk^h|B5>1tpWnClIGqU}yP_B7fe~UvWMzmJ7
ziF$L};?uUaI_y*{0gs(>2Vk11hze0v`xfRzrFNViDP=~5L^i9hx!-s>AoS=M`i;%1
zL##Bo6jLtTKb?N9Sr$Z<7-~6HPeW3i)2`ah?jx#1bLFr;kZ@Lg8d?WY)s{4-8E~qA
z*Hw)pXMvQH2A-;jABDMadU77bDbZkgo0st{yZ^6C%>D;)s?}C&|GarD(;RbT(mKQ`
z(O8X!v>H{b&G7Gws1ofoi2-<Tf**CXD<g-oYFYIdtFrr%uNM!nDLQP5hL^%GHXp7x
zaR_ixG>{Z0DYswy#9df~c%)e<he;~waP_=}XCaa_^Mnw@B42JlfJoA8lao}q4C&a`
z2PhE@4aFqMJc#GAQ#j{kOIAPNj+tXCoJX!TO~W~FO%l`CePBL=rc9S+oEEoYc9CHC
zUYf3ld6br-i5?5(WH_zzEqLbhdyXLK(oEFk*M753IR5P43_M`xX$}+B5)~$@I+N4m
z&piU1(%?{*9<cOJN`61`8T%L%6f`)LpsHM-e)eysuDr!9m4tdYl;gM(ni%cpl$*ab
zibA0abLWkm4s=0}jB*ekn@Z7zMU_wI27!f!i(<0itx{ROPxlooh)#`GzjB)5OGcqz
zt$+RL45F&FULyo@stjDBc$$aN|9+3CQf=4x_Fd_e`>uRA3`tcRuROe}oxJP+_V@sC
zsx>eVO>|K(qfkjt|5;eAzN{2ht0pV^{}~T1AHrxDD5g^oAp5FG!cw(j38Mj_ETXIq
zl9Qk>uKYR!k)?)M&MOnJOtwI9?}=)QFibyd$~vs}J^HfrI_VjNZL8%Qt6oxu(J)a=
z8frzDwqcXeYR^23HgL+M=yks%JXfol8)~SYD@>1tvOE`icD=zVb@0~g*%5K-+>tQa
zLwgp(QO11~{A@8(!ATd9gsCRX4pIs`|JysIyBc=FXw#=S!>q3-I+4OL-kh|iyX_bp
zCai75dQ6zBnW@0y&}I+ll1hbBgy~^X_MxR}@Z6W(*ZMa03(GC_H(%H8v=kTz4G?7s
zBFcQ@k{z9@%5_`rng|3<gGVv?Ng+l@cU`qiMH+<Z;Zc@R%W?8nfp7DuQ6h|ni(-88
z)|Ol{gf|&_3aBk@78R$dbhd^KIMGW*BZmc2<1TONu!~=Y2$Jk!THX##5n*cR<%Aur
zd0`O8AHRr0=T9|VPS|+nRATt~n2eneU1|h2>8d%%&?QH=tC_RDZR#;#F!y3lTrTi<
zV3-~bW$P-F0Rpx*4|@0&&@UPkitCr+7RxOd3C6925m8VEMd%ifr$06joE8xaWz)6Y
zxbTb%@_bW(yIW3MRFPr&fmD`fWS=iLw?AJNRC8QgI*nh>d>~QP=FEcXbKl5$2a5PM
z_MPW9Eu?*+GLqLFx#Y=I_3Ao|Hj>IbIo6yt23muw>$TGl??%!l8#4=TC_nA@#b+--
zen!MjS)U23`B~oEV>2VNR8vj@<hiz5*RO1k?g+)&=8DIX)jPFKProeyIMrjPEJIEL
zd$@W+u1^tJZPwsLR_Ur``=s;}M3$6Jw>DpxW+-(zoqjobd@2wsXecQUS&;sJzPVj9
z#4o9LWf5j&rOa=>tL56*9^K(1Xh<nW)_4S3Cc3^;YH(i}MtiZ(AZlQ~WwK?@J$;Kr
zK(btetbyy1$)4#pw>2V53c?my7A$14qknFF1LR=AB*Sg3wpdHeziYHrII9ke)t<k{
zVh#I}xg7Fs{SSdRq(P;OyL+B8shRD&r~7^kgsPuC#jVz)%i1+c2>vx&P4Hb<7!5CF
zk`;s0L`>_j{oh(#3f{2KFg;j`$F#8qKs6!7j5bRBP(5%xn3WYqgGrg}nxi?S{O(l9
zg@e52;XjAf(y&q{U4Dyg!rvv@y{>;S1VmpNV#=azWaqGpmG$PZMt0nBa!#~i_)Kuo
zJxd-TnnVLOCRoNwQs~|MVH)+SAdH5bVl6TL9j-(&e}zR~gX&kCH+c*gA+Yw08W9Bi
zHw`Vt`81w$l{g*wSFdu2C@JKcL{-y$Q#|kQ_VyhoPn$HwiE>L&YQC$!?=%DFL<3E6
zs;!lCdQvw_WyGk~)0(a;2`FBT))NMURswCfRBJsH@883>0O}x&hM7Y3)3r<K+knVG
zgGd<!d1SCpO!(ToZw_tX;^oo7sRvqXHGQqoV@s*r4m2v$=yP;v#AwR`n1Sh$4B_OX
zwjSu9Bj#!w3Z}_2_v#oIC#wFl)qMj%Y}B{1O$Fn;iXbM)&UpV{l+n_VQs#l7dxx}(
zhk@7P!}LYJ;Fe9fmjpW}`kiG!xoAVBOkQD${?AXNgOO;7w#!A!9D<T|%-YxofUv@7
zm?_4tLa@pgO}|F_*J_p}RF)*cwCip2>9c|74kLzFPF=kv3#hh!D#$iyZ~7U#=g|;D
zdzKxKN{a+RwOjK$e>MAlxp3>(wjwwzS1Si$xndxkFtLUIJdC!fI((NNG-V!JQb5dv
zi)Z>Evc!0sR2Mkagqq7#BxV@xy+1WBR*SA323#!dnLkDjgC_S>tN%F&;QBZIOpzKN
z;!Dou;FZVmh*52(Ws_u?hFZ~Vx-<;ny~DzZCTj;mp-dxh-rtVc)at0kCJtGxv!~dH
zbV(at1yvMWZtSV_05MCnQ{GVK4qG}Y-#raHuM#<|RLiT!N&x`Rf6Bx8Kmatj6jM_p
z1TbMptp51@yWq2gFdAe^#1xSS?X5RICwJAHSBEd5jg%T2!vL6IIP<-p9nS#&Pn#%Z
zaLGZ)($?SocrPjkXz%oyMAZ!7ai2#20LM=QPMJixLMa8o7gw)=>1tuLIZ})+3sday
zOGqO4I_Je`(AJ|p)YsatTiZVI=En#!;a8V4??T$DH38FHyLF5+?%rjxBQ8$@V39D|
zB&pWM$Vy;Zxh6O4WBY1{xoUlY$6S?mY5ze@ssXn`gH5$IZ&uY2Wh0)vxeID70&I$Z
zO~^AVUTX6$e<1rDR`mrx-@d&RXoDU;WlUi9D_WFaPN26^>y^luPyO&EOb?wh35(&z
z99GE64>gJfEiRG{bax0SDnm441=xwnIVsh3fOH_d-X~FK$yb^BeFsQZIQvGvs_KB|
zFv2T-7I`ifb`KAUN2Xi+2=T5D#};w^8Zb}Axc;bf2}5g#96*BC8@hwMp_Yui0^=Hb
z?QSnbU2B@Q;+RvbnPj5MRBGE>lKcL~^_$vGO4z+V>-E^ZF>FTmQTrPD{-B;_I01ZR
zNrYEx=4q-dw+fsyG9Qbq{3oJoI01wu6OSqr6W=>Fu5)pj|K5pz#i%k5CrqaDS|Zl3
zOc_rc6X`*-%R5qXb>x1`xdH7BT`hBve3R<@4eSO1r-B<LY)#W^rv%bGl(^7%@P;qp
zB(E)$y~!Kh7<)8>V1C}J^A9;??+38M^$;x&^;BmY`?C2azL$OH9jt23d=cblN9FmD
zOJ0_ZHWl|GKd)0!-+nuM=gHLH%pYEsm%HAV0pWVMmWTS$lT8v*P8&3ARZe+YjZfR&
zp=x9bCrq)jbjBXv#CjA)drh*`FYlLZ%`fJ?FXzJv$SsS$;lPZqnposBy4Xr4oNv^1
z0H4->;^XlKV7678ena+u$oS?zhdSy(T(<wR_~tIb{M-ekFJ0a#0-p5_C!o13;qdRh
zVBGtp*TTZU6%cS-Hf6(=v24Qt&q;^6rd)-G1({&@&nX<OE3k#bm8G1YF(KBkykC5e
znlbh2qAd4e(5*9Q8(OE}y^s+_)aYHPcD7E4y1p#8gv8N*#t9hj5=%l_Rd4NA+}%hn
zhXDTarp`48e%*Qd<+v<}eR6(avCp#)HD0~@@aCohjD7xdo-sK+;B&0Fb}|ieOsP~7
z?h&h>bw#@%Cko~|NgVO&d=<Lc<)<T2&|)e)u7OEk4zpKpH8`#2W#I&Tn02rQ5Qt0N
zjN_8tT&-TG6Y$6cn3zT0xK?MPw^Hs{iGJ6O4-*mlTAA23Wz)xB1r$5!_d=~0!U@<h
ziG5yAmPT{18b27+9~hP%MP_fnNLoGeVJ9p}sPQ|U%JHE{-h+|CgNS~?sG}I(tB;wb
z1(slE!8ZfTpOGi7PC%!v%^W(#c8l-Wo55XJvc{gPEyT%#5Obh@jT>sKJUmG6Bpmda
zyY^=(zHA7a8w^VC$K=F+4i`ZHn3=R&u(;dGpS_Aa(4LE6Tqw)S?4CEhEYc{whp?7m
zJsI|%FI%Y)zp`aVA+Jz$YTReQOK8KH@DeJ`#rJmJ1jPgad}eZOR4D#_1q`K?86FYw
zZ9(;mgK)y5h~C8QGZmR^-bE=Va$!q(kN#c6T1StSs8RY%b^nqzH=e5>U9+Ztg9ZuP
zM+Jn)Ut{f@v9Jc$m_puKqX(p+6%y<C*EmtV^yt5=WkfUklSBCeim@g5&!L=zM-#n7
zWacPwJ>pplD!zS}j(zYA>bQ6J7ec44cNt!*72+v$A^Eg_^7mT_JT?KnrV<C*za-De
z)`)kii?B4+;9Y_9%?dA+6Y;K3BUIj*9m}H0xvOVUM4sv!ym(iQ__M6T#{tKnO+STW
zP{#>n{NYqQ@W=#!n<SC)s;1;T(z`37t-rTZXe)`@ku%E}oJ{^iGn{~QQ)q*vs%GoQ
zX%Ka-54Pf<=O9@suAbuu+plFna?u{7N?p<LyjA|*hB$X^`s_+VRq$ge#xDfMNdUje
zQU{JDTe0PBfc1p9wtN;=LGE#;U-1!$ch|Ph$SdktG5z9C5$~=oAEyLy{;%Rdhf#Z|
z9?OTLh%RRsgOUOQI8HrHMG<>sU-TGAL_gzOQF7xNOLn!fXD&1Wr%8azNxZW}RS9wZ
zSH)LH#9f;|Bd(~5-^kA2Bf+?~elvrY1+z4L$P`3gt1GhHIeFE04ZVD&BoYm^LhyJ-
zMqbgGMTJJyMZCNA0E{^Jl&b5)ce4P$OL((U(wT~?%JiMLB`c!s+5xb(qI{$y(|o?b
zz6Er&4YVTnSU>On$wY_T{-6(Fn1HfVgrS_{p{12h10^9q?PS`(I4}Kt;{+nE?-;1W
z6;b~<;%*SoKmzbiB@Xh6Pv6;<0+DxZ`(`6lKGSSDb|xV5u5I6h4w&RcHMac4-~diu
z>LKc1dX#FV#)-#be71(lrC7stZ+7$hD5==fgYy*fN6XgdOFXfb5M|hgCFyn`0lCZp
zcrOc;Mn8U#6ZJp|uRwZf4<`@O=@0*Yl~sio=pWqkxB<mZmo;wqD`@xVZ!W!Kg~=~a
z_X3yGfd|~e^>-nVz8Z{bwaUI9947(6r^uT{3@Z%~`d;|Al^r;FE+R+Ku1EBFE2MG9
zm}=U5`LgTxvSTVE?p-<qE`4UNN)q!+(Uu<oKS`L0<|Q2CLPsG!?eF5-5bxTU<bARR
zaiBQ&1E!4x!AY;{GI?M|KZN`=22@Cd_a!B{z}jwpc#h>r>MrvD<8uy0>is8l2hZl{
zITs#4E$O0us~!s&Cg1@jaR>_%{&r&f`ftEF5>SB>agcHC^z9rB&QT8#ly#&csumOO
zUH1iTeF9R@i*t?}VS)iyy8Y)|UInhA38+Eu1-f;!rpvJIshkfiI8dz-uu=ku&}$85
zpfKEx-dwR72p<G2p+er#Z4mx<>&ma*aQafdp+^;Z`(F;iNZ6dFzT$wtNEcH8iN|F&
zz{P`<KQwRA>PSIdx&lrf6b1jJtLS;e!ci1xi3?w##?$kC53K<LA;1ll14R)jX55}j
zh`h^wAgfBDI^KAjr!O#B0_@P6dy_m1tFk%en)^>D#J|h70Oy~zc@*!ywbq8O5qX#S
z04I;sv2T-YgMm5{z=w)>fHzK6cTosp-ep3-nP;k_)MXPs8T|&Gt;@~;yXNMy0lk4H
z{l6^(0C9w;FTJE=;*Z!8;7Qm40sD&sj~}TuS?_@5Sprq{Bg@AWQ(Fc4VD9k>VuX~4
z;{UAe`;nR=L=cdOUb2bhTCbdJlO<`7sEQLoKq9KdnfAywTO<41P(<Ekx4`%q93-m$
zW%!{V5{*lj5DS$)=*ZJ|RM1NVVK$s38fH=4uvp0o?{9N0t_^PVBJ^-XZ^dNy1<)_Y
zOi7&=9f3>Nz{w-G`MhP*Q;57v*TBgmw|TeJ%ae$_%Ot@fuc&{KPd?nM!U-Y>h(zx*
zHj;!w>;)wytmNJG%VPD`P@jT(TmtZxFIQ9;tHzQD0v-`@E!%94Hl0qZd1V9vhzO{I
zINr3(vBuy?32;P}K8WMj&ulA>$h-9kro}4f`P0$kmyqmTrU@MM2&&`D-}eCTB1I6!
z&Uwqmpl)fq$mp|tvAQ=Gjdw>SLXSf9&gc_E7<M~_+EH2X<9~CI<lVXg&OA6+zs@Pa
zC0|6KTUWryGf$(qf<E7Td=qi+GC$x5MAV$jwmGMtJqAP+4El1};|FYbjz|m|eA8}$
znlwcau!mmCVsQ-bC}(tUI131cfIn20K;C`q&3hTtyfT6?vks953Bn&K|9J=acLD%W
zSs*sfPh@Aprt03wS($GkzgL$sLJvTcZ0hLATB9~U*&3=e&3~A-X|4J>R|Elo=(Pn^
zeR4HBa9mA@BM5`+ya=0v(F&D-TK}l_oZ9GsUAhDVq-lJZCI_o|jcyJ?n{eqAj0G50
z6DDYzO0Rx^l*pxLFz}2mV#~2yq?H6Rt@CQoH!8qD-|g}^2gmd*p_&^%EYy_)>xz1-
zrXF=@tLBL4aaF2}n^n%2zeYX3obNpTMM~_!s#YsUtaQCbU?>O37ME7iwid)neCA>~
z-`H`H2lz@gYmBQ>(|6uL-y_Oe#r_z!j|X6W>f%};f(}X?5pAyZ;?n#!!{sMpjx<=Z
z1cY}zAkj+3jqjxx1eb#ZRg-J*L$8^BjBoyP@=i@2cp7VdkHuDCfrj~1L#rfp>eAyE
z&|{AvjLkDG+g=7EeK*7;-d4NH5o81+_o7K*S$i+fyAn9NV5+~cXseRXT(D$XuCM&(
zlswf>ScH+ZQ^x*23AiA_C_Pi!CTU|9kD)d!&?s5wpoy_}Kx09xHy#Ip7;l>O{QtOb
zko*G~d?+*S0mZUDPeIdB3m5ThN8VZ78F}OABlIKpEEkb@*uTta3rbwPOb!2%C9<6K
zKm1ktF1=Go16pIN?)m`KFJx?@wJp90_QAb+7FCv%hyv%WAIE382q%5+CeRw+uiH`>
z*cf3npHrtWf;guA$L)ZNBaG)$Xfqkf0Xg^K5BehN)OLd@9fNaF`L^u3IvUBvoqsUC
zk5FtZyjsH=h;w%?!k`W0(&s^j)`&VaiLm9uTt1M?r<r@L011Q^d1Cqprhx`9Og_uQ
zA8*?aEQyRzG<oJX<h=K#b_ZjcjlKe8LIx>%(O2LVk*Q;YLG41uC<^Lq%7S`xdv@Vb
z0QHR^%=UAdk#PkNnk1XnJ}rtwqxJY+PR9HkRONmD+^UTcb*;Xr)PXW){HFF}(3K?&
z`}3Aed2}=UyldUjAdnLV|H;Ia4uDVH(7t{wMDd>^M<4?fO@(R8u7oX^rCCkLR@MBE
zo40wjC{>K1?mU5G86&pKt6aHQ`7Fp7v~Jkr5%_LoqMII^D+J0pGHTJ35W9}&nJc<L
zsd;e4bYQb&=%Tp*zq55Hk4Qr9japWTlb0G``e}h)Nl216+C>(pj{^RZ3||!7Gx4wv
zp)CF)$NpFg%$D%ls#Ev5bkHSV#n;QbA@1Ed1?vhCxU^Aizl=u8qg6>Sr(@U@S06RU
z_xWscek2}u$pMSqu$6IR(R}c2as*+{pqKE?D^M%>5Slsr$V&q&B5S7BDR^rppY5<6
zU@dmsZMxg`nvU+HRx+kHu(DJ~jvyG%aoI1BGtE!d;WYIiMul;X8SSNfy7zm!nJq!{
zg$!aeZOXj0Wm$+PT!|g*T$%X--vM96xdZJTrPmG;s~@Wo6TL0XSq0}Z>&qQ4fLiKt
zj9z+gT;Bq#Iuf_OHOPnw6AGPbX;4=(s5RI66hWN3^9V^@-uA0mXbqz7&L0@mS;Ip1
zmCq0MoQbGwRbG-h_QbR5Y%GDOyQ>w9duPD=?PBdVAnICY;LSVp^GxHFH0NlI&2{YW
zg&n>?%et2@;ASO@{OY{eA|Qb1;SY#ykD-eDj$Y%#mxAO#f0wGzXLvU|x(Yu~b5h4G
zAUV)q(RllTkR;%4S>|8*0UWBn$*XYBRZ^Dyp`f|hk!;-63;b3R7CWI`CVq{M)}1F{
zXPQJMm_6vp5a8v>SVq&!Tl5{xaG^Xc%NA)5vJX9)(M$Z+3aFblWW~i%=zO(yr7XbC
zS7}bf7g^Z~xOu|JM5mj_UFnPKr%eQ<g4Wv<D9(nL@XDSK>yQ<4Pyf5%<AVq?n9)2@
za}psEcVynO(Lf^!Qxu&7Vf5J?MMS^*w%eD~37`>VIHS$KESI74zt0HtkT68i$v5Yi
zC&9o=w(2qZtU8Y=f-pnTT%dc~o_76e&WGotG7z4$N2O=}>Qt-<GNRGB5O21YKx0LU
zT}fHZk0oaO=Sa>7Llu?X6k-b)eMOK({nfNI060cOQnLleUidO<ZPGi-d!GX^85!W{
zSb(u_o(EcIcAi`(&^lUUw!9Eu$5dVW@XaJeR^!Hh9gkJv40`LfeFjk60SnSUE5nYN
z|HM&8l5vg>)-81scPjSPgi?2%SUut$j-l|rO^npzAMK!D$N!XdHE|(zyEIi=_>GXS
z6hjw{e5!h?NWvsWp~B{oVAX1KeOW!VpA<=WBUh#$$W)hi2bfP+0#N72qgJS3lSnce
zQk;$%E|@LKI+gFzk)vu36G;X__UX~vo@0zmW7~>{%lz0;^Pf|{sP#slp50>OiyJdw
z{H?(+Xqhp=FOH~@I#NHNu~TeZ2ge8}0f7=JYQ&+KCp^dCQgUuVn`1C-t#x|riKEBH
zov&|v5Qmxs3tpVsU_%w1)Cs<Wao(awS3XrqKGf06GDNGNP3pt6?I=`NIxsj@6*V$P
zQqYf#O{+CqK&6}M+Y9aNy2!D83hvQC7v&PO`Uc)F%#MuzoRqa4216w*j!kFQC%$d(
z_&!Zy<GYv>6J>F4?sz(e>kI!mmm;7a#U}8*;nte>6V$eTB;lD|uGrQtk_y22{}{0p
z5hoNF5^-=<bK=Xh1rc$A<x9jtvEF&+t9ig{1rkyRC-Kr|Zlc&v7T@|{ENCPJ_2?uI
zu%?qPe-Gv{L<Z8#-E*FfM!TrC@~wFC$aW>7$DmK1ZL3FC^zM)+*?@gg;EvvsP&y(7
z2A=&8xNHi_(VH^Ry=Bk7DvfBnvVAtI4&9&r^>D;OMBAmYJHGxCC-^je-hJRm^teW+
z&oXB0DJoqft^pVx6G=fddWjp(8M>G1qbG=Om$r_+mHGX6g=)Z!P{t=pd;>kXHF)MU
z#J4uIEAm!)L-p4jD27P8G<4LK$lU$n$7<_9U(6bI&H$aTb?|fCzYBnz^|(cEQ80c%
zrC0A%=LjGS%Cto1Au{5M8~Nh+oC%0;m!{501O0gQ$xk~GahJBviQBDDVeHkuNo<aU
zLg*e!LQ#}&ee**Z5Z^8XJL4O~-h-d_9f*j#G<HTD)T43Dru7H$hJr<O3I%+vx$<bC
zdBAT6yR>!q<@|v93w;sSE{(mS+G39GzUM!X$!m4Qwske*Zq}z>1dsy-faon@Pd8tv
z^xO0GmjRX5;|;x?2x@%YT>iv!nd-=~DF8z+wt)-z<66tBh-;Tt&bU?#u|})vV}Pwt
zAcYdwzz`3FUfQHKzauG_LP4B2wj4Jz;w-lx+EWp+?#j#!>Y%alZjN7{A>yv`cTSvn
z5hc~B{`;DiNW)!OIwuaiNaN{gK1H-$S-MGE31w@4{d7IZ-?dKLwsn-hFRzsD4A5-~
zno#Hnp3Jf^DnmRtLkf^kBF*F>m(-gU9$Sluy9(=pTs=Toe>>*ndx*FzgExo+A2{yZ
zsWBiHglb*3(+BcLrWC!7S(Y;|&^^L?!H!-4rwrs>W>(2@h_)+h=d^*J+VtMQ?+|TQ
z#%|D7lc;sSo?L?T+m)>|+Q5zM`E&m*MB0_98>E%6u={AL%^-u<3fr)BuG8r9Z_3C~
z{XtKJf)f<>$cOi^PBa+aGxocY{)oKxb0eo-TjV{7AD3@>pU-=QG)cWSO>f??_nw3o
zNkR$MI&BR-uYPR9$iQ0TYsT1L^a=Ve0$+W^>3ai?BK0sqql;_N_lfb{vBQ^t$)o^|
z{<sxz99%e1V1h#W{|`uW)S|c7fX^blH|#Ke<_qChzIzWn9||l~KjqMQwwyTdT6gZh
zyBlOF`VogJZQ!>imk*zc#Nx{S4bFiFm|APr6hz#W2e61M(LU(hrApv3PwNzIAK<Ye
zk+P-VTkj#@R}TyH5;cRPpu4Dp!@6t+_D{hC3I(@Da)2PQe)Hvhh`g(SZ;=P0dGk%$
zGC;#ActCINK~ML@tP}ST>#ia`XC0Ts<!2uojmT^BLito#kn>oOaEy&cce>6U7r$q8
z6ju62jGd0Ly7|JKcx^%`Wv`z%c2uz!k(9ZH4#^t<kLx8<9qGf%NWYQ~K*FUT5$Kc;
z!(yrl*Xi{?H3S(zxGVcNP@YOISH4OAzd&8Dbz8Ret95<+z_}<Bq5uJfoDE>7!fdlX
z_vQczQ!s!|(jYio&Y0;vAYncH&-?69`nI&{hzh_NQlNicOf!{J)6P0Se?J2ecV+TS
zm7%ANS^D8bMBJ6ZTf~*H)2qdl%fJy*Kz|Og@H|4bm-Gjp`Xk1*G0p2VlgLr#^=fe$
zxWNdm$pGRkCd&oqd#}^~fyleFb(43{?44iq(-a`uYpEOd-ZriSKsSAzbL|}<Z9N=F
z76|I0Y;EWJFCy+L+vhsSh$}ic=JoO-K-T)3O29dgb=LItmI4*mUy#V;fx{ZLpmKgB
z7k7rAM2c0m&7Qvz<L(Tf5eK&Ub*|l6K^UfB`h?xH#EN??6Qw4F;o`RwE+EOcGJb0T
zB?2WDUI|7FM^cb{-rNga7a35cpmFbUD4JAy>W36MGoZwy$Lc3qL)a&%-^Y*rw&@_H
z;t$os>^%05ntRW-_3fvWR*YysnfL+mjT&a~Nj3MnZ%6*?J0PP^iqy|i`1qve`*tci
zhbO~+LdplHQY#0_sJn6joH}BCYQlpcMBG)n&w#{mKFw#9`>5l>80W6~dyF{F$BV9c
zbkhFp+mkRe>aJXXn!ioioA3*gh%4h~Wc^C=%SOpK$M;Kr7io&N<K)y7gLp}v4oTG8
zzx-Rhqh}IvW%`_YYmnZbKHF@o@|6N3?ketk<|T<tQP_X6jM3@*m{oWo#n=kk;Ow;j
z;w4JfIp6S9lj`+K56jST{yfzM<jo!Yos#m0>dnb;0mhS-a?WzT#WwZsn^AOS|Auw)
z#;tUy)oTCLLkZH1xGVEFiKAn^m+tNqE_D8LSP^9)A@k@KaN5E{G1W;5FQ4V^_0bA2
zpY4L?3cQywHe<orl?YX#>z<uRTr{u1GbQ^OQP`g!R{Ec|N(sjHLGupGWG(VcRMI)8
z9#N!)GW~~9rnv?aBV7Qw_|_FS#_-`YUe8Q2!Zfeoz{9h5ToL|K81RvOO^v7Pcz)y5
zC9R7v4A>rW!#?9}kTC3&(%EfUG4v+zokYl<wGR%CheKyNBuvi$5(8}<G`s@)j0T48
zW2-`u&m^MuoGe>kAuH<s?T5jwfIbq@d*%ul@!ITau@Z=~Rw72IvMGx^PjsT@R{f%%
zl3s@fQ05Xcm*b%9=`RWu+_10o7~VybR8WuHbE;rtJAv$_3?w{ys*wuSWxUhu-{hS&
z|5#-J3Z|bYoNECzoHCTqBN&4??3LsmGqfxh6#qG_lZfCGtg{d$`>x>2pAAQ(wTAD|
z6?VBT+M+^P_GeG`1yUAmQs7P6(Q*~EBmR2l0>}ikG0C=h)rrr!UFJvN#EIxVQ^v*(
zt0`fj*F9!5>%p^9t{#rV(<ApBdR@JCjrxuO34(Z$OVgSm;#yO85@#=6un7R_OBWTE
z_81NFY06MRk5coy8;8XR&VPAbb~oZ&8|@{|;Ts)UJ|9{hm?LG9pf~46w_HBaPhOAe
zjab*ldzp3gHH%-Gi|X)#&;TNQ&(uTapm>u3^yns(>(~bg#*Mji>I`QLdb(?he)<)n
z?#ALdbyi{k-gj@>^QB!idcgUi`l7KwaiezO5&`ckWb7Su9`H;A^I7sX?pC78RBGE>
zN)7*f`d>KkfkZf;MLmhhE*Zn_sz53x53TJx{41Xtg93fo?q3`Q-jFgZ&|^USLP%*`
zmVJFK0SQEF_70|vPdh;n-qdc_F?5t}B0Mi6m~sR4JDn?k2Si<K^-j($!&I+B2ED)Y
z7NYJZ)#o(|zM*ViyRrcdk#egLt=T&~md`Zb@jHBt$+}8{-|xuoOXyVH7=BWX%gmGK
zv;bzWJyeI;11wJ3f{Q*@z$T#qL{y(?m=?!y0{M&ku{A(3ON91$(MJQv-e2{>91xl*
zLjpbaX|b=SLbKDa{~DYoWkjGCapYJQwpx@5$;FNRbH*8MB$rQTPW~Ppt5#baMrx6V
z<2c^-YxjpTM3t$H8z;c&TScMKeUVf0Jw@i{S3X&0Yq)U*jy1S0$xHN_UZgOn5Gf-A
z#R<bv(W7qnKuJGkN}z|bIXy$w%RSZqT5ks>M*^Ugy~7hgTYdiP{3><>!I7a8VSlEr
zs@#6qu}w}OW6DfGha^gXq@u=`nRXz`ZUR5!w@m%M1Eh4tKiysxt`!=fhxj?nhf|J;
z?;RW0St9<w-|ub%r6v*I=Mi%h;JdPab)$X7BdGHP-IzV&I|?(Nu&-8k;8cj%K9lkP
zF9pry`{f^?KTpK>N%WzHuXvexKk(?3A%GrTG#ZpZ8=u~6+ZNGw6Z=itsy+_sR{3xH
zn|X)DYdxXE;!%_sdvoC!5QK;*KU3f)%TUqlwj7~ewT1=|aefZ+sG@kU+M^U8@>5<f
z_C88vM=`lyodcRq#Q1q}4kc4|-N9o((<xK`Wadr!#pT+3^PRb?`3hcGJSKasConTz
zHWtMKDo69VC@sKTlnvS1twqYC4MT>HbPUA7V^Jm_i+UH4*Xq1XJ{Au2>D2%1c?HD4
z<fE+wWb%gogTWbxu4X~bjEMLX<5rA;C2$MA3A24bL7?4%!zr-zNLHL`3zv-Gg5k>J
z2qAj#pGR>t^K|@A6b}cfBM|~91j7NS-gkAPsa9fXovYkAa0PO1LYo;#n@Bu)A$4~7
z<?$KkU+e<Tfd~f_8%RoXDvUW?N0|W?8bEp5m^lZQG)9@Q8ozS98*SY(vU*-leydF_
z_aE?}l=qF<I+|%c>uPk^U6M(k|C}d4^A21zY#T;dz_wxBO!@QO7@q}1mEj&%%Br&8
z=&H`|V^SmeiyCnqIu0n_!ayUjDL85pJ1sWuCuLX~qpmeJ?k;TV{N|2PH@5-WhN;s&
zMIao?kU(V-dkexQ7B1=4mAeaGIXH3%ZF&-Ou6W%OWotHy-qy$`SefrTeNe`?K#6G3
zK}#@!eDDx!k||e%QS<i30ZY(NA96^Y^~e1EjAW3l!Y?L3!))lo*Co&<wC=*W4)1;P
zjmTzJJo4x|P{z_Qgr<Zna6*CN);*`Z#OUZ%PtX#iW`eQ=YbgYlke6uk=iVp4=~1Qy
z+PZ1)0^TzRL@cO^j)3GZytiPhzPKfep0np1$R#M_0cGY5r){_%VOfWE&A3v6Syd@-
zU#Eu@@@Vt-v0630_9R<1Yx*~6!0&FWAFpM-kQ1xCkkfxhp{UYqE&g-(Rz1p4sH=4r
zV!|E<MhFpJ9>1ZHnr!ItL3XmilnPure4O<=WBNGPEU}Y78tl;P)G-1eMV&(T)I2*-
zkCaj*mDJ#?uOHTaiB@poI;^uWRsj9>((UpeMk{FVc<~;9`x`tk-vG3Nd-q}N0i+uL
zJ*!s>t)Q(&@E$<ye7DA?^k@b5{=?XVCovWlaBWMPS!&)INP{Lyx>~X%AIhr6iUx%v
zcBzgkkcLo{)&TLecFcVBsp`-`Jv<Q{1Gv+QT|c5H@DW;=pTkFh8;Z|bHoc=(YJqy!
z1DOWuU)ewOAP_nYo~Q_2L6&5x)}k@uKRF%(j{2H>G`;#+TxcK-n5gov-pQr$c|2K-
z{eiT}f${?2<Ji3Yqo*PI$?*<o@K^TqZ$a)7NW&$n{3|Csy4CU}!1vJLiGaRZsx3Xc
zsS1*ii}J%0WzcQZ?v<IEBl_Cn0N9w3K1#*er4sGts5cgRgs#Igz<zFxsu^zq$<xq@
zlH?iRz&Ye;l|BZopml0kG9Wev_5WA>Tsbt5@`$pOoWhXOyxpr9;C^UOMM*>uPwem0
z{5o)-db}c#P(>9e@qFLRPZ9sgaSrfpgno4n^+XFKCv$++W%io+GOE3UKpJXMIROrC
zD6Qfb*Ib_S80{iC9)iIm)gX{%S-Bs9iwH`Nix8hqi1aGYwS-;j6^A~EIa~y~;&}JM
z+^c|X8k|uUKKKB!<nf<B1O7peYDC%(@iuwZh3`f?NKXF11g}J|SIx&<Lpw-LeZlG5
z(M#0F-z2Oo!&l(hv!luj*47tlecYJ8GPTvhG>a9sY!Cd3&rs*hBIgQPCxKS5KD~RQ
zAg3?n-*X?>80F<;$y4(dAjr?(``?)_&{4SPVOn9{SOBQ&ov)T|14RsNbfK3ySSx^n
zb$NFGZ_qB>dkVe=N>}1$4le}?4Xr*od<7`*YDM<Rr*_c-X$VL~HqeP?YP+)p5Dg6m
zsV)I>>Gxx|H$*GA_ZD3E$Y10tR`?y@k7$rcuRR#gn=1X%?dt~C0{H}O(4j;h*jVxJ
zDxh+VHtJ9z57d9)vWlo)4RN1O@b3vgB#sH|mVgexy_dk#_@4hB@CBmpK9w*A+bIWp
z{^hrU=z!h(2j0$C$T$4pWKWPtXhT7P;>N8L$BUzxXiev=d<~>R14>GIgYutm-!AS6
zvP2qC(u=+|8BJtEjyO4NXJ;NGy`GE@4b;OWl{jh4M>{)lQjTspX4)gtL^2mXKVS^-
zLNw&0*JhZ3!8v2oYjmrPR?x-(CGX-ZpdhoT=DXKHsHDwERQAAD03oMhT$$}4qoBbk
zl{J7dl>g}8BS=i{eFYa2(%ZKe5;LL|+<OaFeZ!-^S29~^bP(?Sg|!0ksZBS&`_P6y
zipx=bhe$XLaJtRY%-jn^L&H;gpDq&(($O}JK3oj+hlZ_GRsj0*w7*YPv<3I+1eZP1
zpL;&bo1qolmmk&&%BL37-Y@Z~A9H&A=O_+ncuOxKahJ+JpMkxojwkPo0|A0IR?%yj
zSiXi5*Y3T%I0c=x`@DjGkixP%`HI)?`Zr-{1MYnV9#r<|NV#0-q}_W8gTANG6k%sn
z<|imdhq?C@czRjxA<suCW0gboeO}=u)Vt{!Y2JJVq)x+NN@~Mggi_w8X*Hq%$hK%8
zOo={l5Ec4=o))q1-a+7p>fWB}gKj@*NK9|`SpY+JHRW-WcY$5eu$amUpyC+u(U;$Y
zx>66tR8keD^2~IZpOZ~@-pl6Q(H@fF8;m6sE&6WXNBw~9(nc?;LIUnBf40s)pcRtg
z9oQC7u)KeM<VKK3&=8r*9@q+=kS`MKYB9&s^E`rgCmeZ%b`uO_#iqU(7^~CDS7ncu
z&G{Uht{##J6$lt{_`(TQfb40IOmE4sD36Tn=hjOC(F)0M6G@~(o9D0j1PRG~9>F{8
zKu81qGyV^4!F|PHEC5Vk{>`Bi(F)qqRXJy-neZ4!&b~GSt>E5ISSu*WR<S3$PJ%Ml
z4Ghz2VOlG2sHg1i2Ctg*7+A6!G^S$_X2}ehDX-D3RHso$RPJ*Lz7e*D;!}rR9{oLN
zRA?8lvWcXgUmCk;V|5Ub-5@e;;lMB3R^Cc`Q~k~*&<!ZlqOT@H6%GwWLZ^*$^m0Uu
zHXL8Jd-&L?;8>G^#^fuoi#TP7@Z`o@&Z8CF`w6~6Ssw1C+w@U?=gR{Uiez9h`3kHk
zQ<vC%^z|AQc^gQZ@#u9B<_BL)|6$SeWtZ_+cwNSSj@m34$V{Vo$7Y+s=3R;MRm-Zg
zy8`tHP2pJ$x(t)f2kV#fGe7ZR;**Z%@e#igAlr5W%`{0Dfcx0D`Qs950iuUH2$!L<
z{L!tV4b?C1gWO;+EtU~Bwp!5*_qnU~KHwld0#kGx?WtNE8k>OTf_K{dtUaeMui+xO
zFn3^lYr_L4983B`;h9%?<J7x(8bq4~Y1)Kynf5*6;@if?^}&lR%DeYS5w;lr3Bw4|
zPx%lU>s-u!KpSrC_kiYqs!AI~dAQlW*EH8Mpp#1DqH5cFU#Xc{P=Jf1!$BT|>Xb+S
zHwP`?qH*C^fQ4(>s?$8Ky95bHo7T&RQ3w_$ogS_D9`Ucu1R!}2|Dq~+l6`O;wJOn1
zShK5=m>3_sDiK7ptUL3XbIoI&LqqkrOvSQ|OZ`CQx_$K0bKz<t6XXV$X&$R_RjuY<
z%TjFqPYt6%dQ_S$c7whVMP<e5Is4|9XbBfZiDL^ahg3`d=!0pxtLa9N8*rvr0^*li
zjz2UBZNf!a;#h&n$wr8X#@*K4|1JR*pzpuSM`7GJ0t*-)T=X|ymT-`WQ(3hxLRMDe
ztJsG8TPSt1-jp><ucD)H?Iw&%FVyE5Qa<JmIttgGg7?btc%Pubt?H;%i5`t;r5L=J
z64$4~Tf9#2Imczgxpy3ZK6OzJAUL=_oORZELEcM1HhM27>kyX>+Xm30E~ztJ2QE)9
z9Jq;8)09q6m*&y;xQa?@>IST7nwpudvJz3`WWw5Vwkm9RZoU=gS-7ZBtW}bj$n|VV
zz&K#ev=NieOev|cT*K3+`U1(xbxL6rB|PI3x8*`kt2e$hFl#)2b;?QWG-Qo3?v0pA
zfiIx)&h7IV5|wM8!F$7O38l->rqZE{z$v-GZJLM87l84h{Mgh7)Vou?&I*qKOl{Sp
zR|Zl_@)vsCrfh17Az=*?wt}gS8%{KN0R-a)xoHW8`%-kFw&|~@b<hf~>k_jg$^4R>
zUyN<vDLc>}+GI+np|KNy4Z}5=!{dQd)k8OB6R;KldkB~pH&X2w2GM3zf;~9Gk1*vf
z%X)W4f^zLJ_&%7KDMikswD|`kLAmx7)&k&uHe17uDARL;-82=}TEcDxh#);{MB!9?
z6OzLV)}|MV(eWoN7*e;F^1b-i6UG(+9Sm*g5zfM9TO97(eVvv9J97ivv;>pX0~V#f
zuRR?UfNpS`Vg+>rw_i+Z0ko4g!P030Z1@9<W$FT7)cfCNw1De6B&m^P6K<Tz!}W;&
z9HG(;Xwwvs%KM!s8-^j?U6&t>v|lM+eMmjKsn7FfMu+R#H}D0@Dz6{R>v?uO;@`Dr
z;N%&q*y3MU?Zw2-;d}upX`~IcG(SH#TWpCZYmM5x#YXdq1^UL<y}~`T_p25`A+Ftm
zamSf3Cc1H(nlm!`MAu4XJRxJg+FI~dL?zIp(4Ml@qe$4^$kU?`o}t5(1}lJPa0A*j
z)zV0#`NIdXlJd-oj;NtNO%UV;w&`4fg%;jTXze*>v6ln;2Lz#&TxS#JUJOn0V;>@`
z2J!T1zVc`#*WSWh$vNZEke<-2bA1xN<!bB4eh#;xf8p8@aHLUHANd_mW2lyp-0kjX
zAENzebxR~M(zq)2r5)^JeBOQR+yZPb{O8<{3s>S;DbSd2#2mVnZ3wyb{NQ_|6<thP
zN9$9d+}Kq0)930ZhOojKCCZh1HSCDQ=b}V$Y>I#3&Bwi<B&ySj%oF|CmiW&pKCPpH
z2W2LLU?NMQLo=7CU!&^ZD6n!6{)Qe*GIPGDxd&9GZt$KCLGfN68bvfUy7e#W<#&)9
z%qL&P^g4X@S^+!e3jJE~*_ERF$R&?YdqUd^Da<bINnq#dS3m3@;~3m8Y;(=OQKdoN
zOq;Z6ras=gu{R@@`0Y*A{ovll4gOOs!JC)<+&gmx_Ea+t$@z>a2O5of6sWglnv(OG
zHou(ji%V9UNGy``apx!8#qcXlhn?sLaiT@ojI(p~qZ_l+*}PM7oMY;Kw-l6Sw1J%F
z;dqS+gF~LKm)I2pZn|hQIn70QoN-J&W2fUaP)Z1H-p+FkxX`$6I|Zk8FhX!<4$~ys
znADTdz^7N=9FOe}5{1sq9JF{e=!t0kv%|%xirggp;zD36G^l9pwteD@w_wQyn^DF4
z2`sFD8uNC$lY2leOhbzrOIX+re1F|*K+!GWu9-Hp(~G>3T1eSM?z4GbbNNV#upTRF
zoNf*OGN<jCm*(M)uwQTz3iQpjwZpkDDekR6da$Uv1b-x|c$pghC9OG6>N9VD&)q%*
z9R?|HaY_r{%YHU~)lyKH=%4H6(N-bv@rA+&+AYh`7A>H)0=NL{TFC9MK1Y{bL+V7z
zOuTmhaJx6&)*S%uA8B||nYzc;gf6Adl6Ex5iSpYPffWtXGH+Ep)sNMx?-QsrSh|0o
zYCn((4J;~it-$+gw=B>F$b^Ozm8tVsDwR{mPW5hq=#z>Zg}&M_?fB!yrARuY(nhAQ
z^xC(Ld%YhRENyb9MBS713ws(jtXKzNPqcxZ3VDx4iUroc`Rp3vpH#jm3n<D{q+s=U
z#D6mU0lvFjwJC2kw1C#6RENVCP}OJou)k1vq)q5l1Z3%t@CY+n6fnL*^G1*BuWBrh
zkXW_>=z+vX);a)$Lc@cqJgY*<+I(3Cpfxl=sP_V>D9k-<(ptoSGF$>9548THO`9j6
z1(M+toHc<kt9y|*GoS^uO>b2#*#ZCql6`L5HNdOU0HNL|0D$j@AD(^$d@>CSDpLpY
zPcyaKWyF0l+yZNA$q{AS<%dHM_sQ@HM$1g5AJX`Tx`@8Eq)-o+(O0c&o&R5{)C&{+
zJ*ZVluy;MxLSj$x&?&0L2Gby)(usmN^>lQ~qN=_J>oK1|B+z0nuB(^^EszYCV4|Pp
zLtW<=@fZmx87_e>py=edEfuyQ{*&PlIC(pb5`iTA=#D>m;qJ$NqRtK0BRZ8b#q*G;
zIu0iwa`+as3)k5K^9hd2XR(XW{OkVW-FsfsId`FT4Dv1lP6e}1s{jU|XyBBSXbY~L
zgS7?aq^r!B6|H)QVA{k@r={@)JT;0CQO@w&aq6v!9>ZW|3~Sfb2N}cs;gdtvTa#ct
zvQxHSlWE}8`W8Qu8OWUm?Nr19T+pdkvk#&LTzd$<1(B5q!PhM{Bo$wP%gLde`gvtY
zHxmF9tj(LH02mZZ!*$9cVqQYY#usPL(ogLs1=HRE2Md67dCjI$p8_{ZgLOKWz>|Vn
z)ZUZ=9kSLx$a-p!2WmRA>W$KBW)d9e+CA_|J_=;y)}HqNA?diz9Pk*QjHjo+wqM5*
z?S){i1r%u8ty^)ciwCbcTAmsVs;po=lv5QutFoAZ$<g<(KG~aqbEP3Uz10TSiPgGA
zg#*d!ah&Q7gl`b}{@HUaViEtYvj=Z9vsmD1PQNBVFKHt;y#)mF{Xah3uo+3mb=#4R
zX9BMIpV$nW5P8>WgF#+#Yn5-k8l>J?1k<K%I%Q*xQF45?CcOWQ9nJp7PuS1f`|Epm
zviJ9i@!hfG-O)vJOE)jMt6!LlcH!DL@Xys)s~<k%_^|iHF6tOPJ$TURA=KhxNWZI9
zL0r*SEV6O2_8?~+^nH(S{;3bhs`P0OS^{|Hx@Rk`00yl0orpfNf#{Vtz!yKkdeJAb
zfMNyLi-m*UelQKU>9hhC)%hVPiS6=_$BYI!A`P`EF965fjb8FyS#$`l{RH0vI)qLk
z(+40$b)7zNlsZ<_UFi?sR`2SAX^>5)lxze!Fow=)E6zo7a_uUNu|u9>Qbe1kFEY1M
z;SzdPa=Hm|T_@;PzInL<h+;I@rc*e4o{^GWO>44r5C}6g$fiUcM6vnLyPy<;2HEr`
zk92cV#9?H=v>}^b<V`24h^N-)ISK&frvWzQ1#p(tXVTE4Krv~PHsvK)o~1as!KHt=
z0Kx!m(x$usNQ8bITcZKmfNKZA;Uegi=bvcZ2OWaz`odZO<kD5*1O3q++<ONz5GaZ?
z|L?7%fp^d*i-vbFK}fL5Xpw40FkqYp-Sj$KlW|3RDpjd7251irxhXFI9FR}Pfiuts
zv;~+P<5^(}=OW(98B_;o4{gY%vH@6$t=dtfDcXbUMkU_^DwVot&DkF9L90GUNNfQR
zA2a^6+4yLW@59llq0QKo#e}T*R?*^%&>q~o2__`A00_Z%GaUFGor7yf!Q{hJ70Zf6
zL31%U-w@Dh)jwA*7c`0N%MaLU%~mt^6BQAqpPlaT6KbuI{^;pxKrS@IrSojLT!elK
zxqP2HePbXOJ=hY-1p*+~rz-dWB+`1QrECElW(_^*{*<eX?*k+Qpg}CXgv3@riQLoZ
z;-k38_|IWsG=QaZ0rh|npQss$4%oGSV5C`=$VveTaI!Od+F#HDuB!|~Fzox1SZRSf
zM?0JZ-hqapbPC6_fbs#$lvBIjfGUHApj4OO*_<M$oZI&8L~?SSN0{4SSDliarXNgu
zT>b7mSnEU`{sHOchw(Yk`MSVN#`4cT0y&@*J|8o)Zi8&VeqA6YdGh92!sDAoos@97
z$77JFxByLBE3khMp!~f%*D?Y1(ZeP^9*9SGa|gU<!}LeV5^rXBd{lkjGgyzC^sHf~
ziUrUa=jicz96AEJlQ4;!uVKc<+3brjP-I=BANaQx{FP6KhtoqPJz>Ct!i)DkPn;}O
z<JhrMqtmPJdu}hXY_IwqK`?FDreV*{{aByhC?WsT=q+tjC~L6(1@t8Mlvu~V#);~s
zM~}6ktU`bt&&&_uUeFtw8?47tDvNR0ESv&WdHJdB;J!nfA{A&GHxS%+2;O@SK44fl
z@5ee0UyrE7yn9f^!opLHYc~ieunSbBb>OTMRnSi;uvp>o+3vl8N=49%5$6itDkWC=
z>6afTfsPLCWpsz)V!U$U4}N}usMCuPa}W62qs@oU<py5X1-Q~d9So^@)_$B1qEAmW
z9P~Y9j?mIs4Xf_vUR>5vZ2*<E)Pwj?2i&~;DzP5YQ>~3jUfjA=_v}Jw(DLQ?QLgF&
zU};K;uK>gK_!UR|z@3LSjd6MjHBD`lt=2toxGpf3CfmkEH0a_?T>N$;P<<B=O9y?W
z6SD8GJiQQgx6Z-1hgNP124!y?2tq$?;-<qX@W);h)_Zq*5rc@k^$DD~!ugrNQ}xiP
zy3H$$i%M{+`^yY%jpXjuCE$zDk>!ew2gXVpt?7_EzXx@8R)ou`J8^e4?sE92XpX?B
zpQ<Ujoa)C858HAkTc7bU_P6K4A-t~lK6oJ|m^M(;u?r(HMUd{dud9Ep_Am995Kf1H
zlG26;I@VRiAL0UIX_~BA(npo4)V8-&F_nImvZQ)P9O43IX{}&SaYBo*`7)uZ4TJ=^
z^$kf)aw>W<ehAtG9V=mO!W`tp^b`$pdfTsjN!8FoXu~ueN@U!SDLyDix8H6e5xI2}
z=KY(B0N&ql@H0f;t(!0&SODMLeAV^&FhpOQIY?2RSDEYp6!|n=f8--%32w6ns}Bww
z>F*O>uS7f0Ms;}yW~W^V1X(vkE>}wn{Z*pjBTW6oDebPspLGPHae=fnsax%Jb^;2P
zD!g|(wQm#R0%<8$fY1L%Z~XCsde0g{o1*EoE#CZAV{p@Xr~X6|a_b+sgm7=Y@&^UF
ztL={v7eGr>LRM=XPT0-+sP;ENL0w=iz1C3LD;K68?~A15)<sx*0CVcHrcED*q~z8~
zSS!Frb<v{V=0m%1>nQ9s?4kZ5V`(?>w~X8x_$ne}2?^9X3Mper@|I(J$I08(TMj)c
zz~L#>>f&<EE-Qfzy8v8zX^*<VtI|!c0QGbMxD*SBTNIJReLlBRG&ooncuOz(z|Gyu
zk+nTq!L6I%s>61`yoKpVh3eED`e$Xn0`FouR7a1w1ggV_71^WF#0qKG{^bXhQ$IBm
zt^mGv$P{z_DM*9#gHNO|$=g4+5()O(=I(l4Z9s(RftND-CmScE%i7p?;Jip>KI-(I
ziLLBF>^uaw9>V5csA&6@Qx727Xgz}@8%7zV>eCj!8j#sg9OtLrdNhwYMZu5FaqZDn
z%Kk(4{MQLE>;h(K+7xHFe%}ES_4{|X1At<P3xuVh9uwa?Hm<X@z=DPIhO5_NAub@6
z@&d)>)Msg`8<8M0aRIXQEP*PcfAUP6kI1`iJ+K3a0w<7nLH@<SqqzWBI=FWnfiT$n
zlfO;FkHF8{qv@~Y6@#rcYD>-WH9_@0{n1)5Iy^*wt0!3%FR+t<Sf2Rh?KTj*TtF;M
zIT<xPFx`1S%>aGj5dBO{umxmkVU=$0w_Td}Ohb>uvs^=z`FsR>l0?2xZT|A?U|?bT
z&IV-Mp+UlFPTu+)z%N4dg%Mf;+1RDE^MgR<qtB=C0;-=&`19KLAg$GVX1oBDQoc(a
zPV*L-cbhCkf5e_O98<ygz%H+wXkpL$Pi?%(?|3A8*5fUOJ<GH7TKJ7H=QN5lZ~I5d
z*XmO`Aud3d(r&D_fl|{9%uqT8=`X$FkQP#d{`u#VYNNf-(+S5C3^QSz4Z8krS|*?$
zKNk6D=-Gv1p;&1dp#k5$%+`-T&BgNqhcD4KqGD>-I#!}?qXah9%D7%_;Pd2L>4TJ#
z4XR%Nr{MyQ>DU1~2{4wgP4j*YxPbW2k=(feWXenML{-tNrnh$92OUTK8|cU!ji}+-
zi#Uma_YPI!i+JC6hv>1HUbbk@&r97dO%-5@RbOm;rVeHd(NE9x+KCzdj1T?{#X<$#
z>NMFuSFevlXm6n#O&)$U=1Qje3LvErTDyL!`+*8VkJJQ0^B$ci+*hvN_wK9107F9E
zc@=Xf=0{cj#>7^5**LXKuWRUl=>CPxTaNNG&W1&J_AQs;`~kkEPLs5+fG5-AH$AE#
z4eCqkb-@CMe=BFd{^xKp+D4NnUEw#g<;<i-DhZzD>d_7;86C`N4g+k#0t%aPXN+hC
zz2a@TZ!Z85UytatC1tMi|Bku)>*t4kLE1vcbb7C$2Cm@~|0)Z-F&)zBy@0sC62_Rl
zdTcYUQQi-bh3G+@wlSJxK)ojFMQ<AwpbRWq@nB&ybRgQO1rG%G*`q%Cq7+gst=cBN
z22id2BXW;NtB`$**Qppg@id}@2P+fx{4iRD>{QfMSl3G~p8MP>P#d@|+EeP><4dcs
zcP!28AtfH4+i<6k3j7Sw3Qh7Tfs!{F)A*<Vzy|2RPiX_}3lBam8}uH(it7I{Fh)88
zR9#6vjXJmAc@1(FIs{Z%0;uoe>gPX0`ylsFl|_`Rz?)UtJV5&(_e_)}z<p-h!@<|l
zBFS|q@Wu7n;e#q5VI|k2uuov+Lr-Ykz9rg+)-sZCTJS5|+y9*dU#N!YQJ_gJ0+N#h
z`41ce9!n4YOnMEVzQ3*h;s|J@Xx*aZM_7_2d6Iu8^m_pUlpg<?H2aES#D2g2Di9GJ
z0V*2?98dp8z>7y{6*8CutYY7khyeB1(@QABqN707RTSIUS?XnLw3B2z68PCw#F};8
z(JIOIB#xUUA+Jx%jxCM!E4i)&6>u%`_b_Tvz8gnvO?#FdgmbnAFu_($O9r8xXl*bF
zOJS=hmQu7-^mKG4<W`ELU2F{y(}T<HUId(pb`i;$u=GuGCN=Zkx&_#$BSlsALH2f|
z+yBae=tRehN~?g6qdWXF^>YxNXiv2Rje_8kH+gdwLHkH<N&*n1&pUiq4K0yePXaJ3
z^XmO~6p1RiZiFqNdff-D@@)XNN1xIuA2|r*PfG6IhSo@KM#7pviha)vzxp*YkmULh
zwg&Ia8fGY}+Y!6dUEr%oJ$XH>6j!&#3&!dz0NpzE-=dZ_`ktxBiv+S(2?OIu%$NHh
zU1MI_c$em(dT41<%pWalyw;|UcpSW@&HL(Mgwi3VUP{Fx2K@MVQHC?S{FK88)niQI
zev%yacz67{^Qsw!(%x@ZJQm*!`0D@7@JnmaBFS?n<|0b=6S<@KDs(K#b123l9%~mi
z(z$fEmgrctc}bGT0^jXj*fBm1Z6<k6g>MEWKw~fE_y(Oz^4tnv1;oU~r{6n+7SW~+
zF#j<ZQ4T-P<LM1mz`FjH#LKDhj-Qm71m(VQ7n}nfi>lbV=<$nWcgMJ*S-8{ncD$i<
zJStiRGy$GnN!eKqRiSiPs@FPr{$%GZVF_yL5UQU63XdDkh)g(A^CH?t^4tj?6uEkT
zwN+@1<arbP5zvF@kLx1k()yC5L<K9UobTnzj&_nfS7J<GRN9s4ZazPP4n28}gnxIW
zEb-p#hUd`|$#Wxo2_?(A_<Ch_^%_Ti2kLPm{Hq|AoAmD8cA(@(c6A*-3mgI+ttwfb
z@FF5K-8f!2jH{F6Mf8AG9GV*Pw`%S5O{`LN-Mm{M0P10@a258-9-fTS=EV3%{Nr-(
z$NWO|4`@T%;9oPF*OMm3TJ9>=e(m=HSfU=s3RmMzeKAi)xcN3~M?D9TP>*Fzautwk
zW$UrF6o@5sJgb+c@vWGnFJzHT?2+;gS|@pKg|EXh6i-nigy!?A%0wiz<hd5U4sb3#
zx=e~in@OH?F&2TFxnC;tG_`}G2S7+3hBY@N|1xs(#lAp+>A+X-Q)l0WAO)^CWBWC5
z7IXltvI<b(4t<WLKwC*(KbC0}Ons{-4!DfAlDsAgUj_6yj-+Th25lvIiHfm^rz8;;
z(&_K>D7Mf+v0kSV3&r(w)nk`I^wq;+q3dEF-KhcoaA4d4v_$e83SUAA@QEWnL8%ZO
z7Ar|gL}76n`&O4qkIp=Ku7u+Ng(Zq8+<RQ^<NPmgP@5j)<N>uA5QK&a!%wx8Fm0PV
zmoEVfgN~5(mJyF1>RH$O#b*%kw{(oGx(MvO7w8Z*7#s#2Dyys`%4l&I8~>bD7^Fmc
zyev$K5<|k+EEn*l%IT2*V$jJX&zo?~0#=ye-r12zV#%v}SWDKSzQRcIjhy>8I{)NV
zKGrHM?8-?>wdOJX&~B3HQ@EE04tPb1FOI7?vrzq8^Uyi+Je3O#++cK%$PC^f57oap
z4;Nw!@O29E`8cxR+JsD)1QHdk7I+dBK4QHbzYdcUm6daf)d44>Z~y*(TTqI{wgv8;
z1Nx=!2mODmu+7L~3Yk)_09q$`xr%ilo;f+f!}KiDIShChed35cOj6@0D>n*`M2C|+
z55u=3+@&!72CXVqMyqI*E6KxQt0*18F8OZ_Q8BHddfaT1t5^e`xP6*>AkHUG!@j@q
z%Lnfla6|O~+9b~BWUWz~Yr&6)PW<_0YZbv28k)Rvh;OO5g$|T;d&>PA)49&^pST?l
zrK4xPVkch-e%~A(cC!KSG}=fYc^YOklBYR*=;<8w8>mpX$XN^1s=`fEZ7zn?IGLDP
zM&GX_7%_P}U|elrEXhR8@>R<6i&9Be#kPN(3!HT_p|gAy)-+I;`F24Xlw9cHv(P5_
zGOam+Qrb+%87U?gW=hL{4#m~KHV;?fmjVoK&M@cY)PmxjDG#av|F3^@KFOu{`KVjU
zId$=uAj6=~OZBov1KEsEsO3k`e?c2co_jGDVqXC$3OBpRKa17(?L*xnX$_CUPA8Tf
zjxl56|2VtyI3KI;KXyhTJE5`9Ff(TT%pzM-wq)!jG??LInPFyR$zCXgh{zHNUqz9%
zLQ2{9B_t}cQ(23)-@W&Fp3ieX_rCq^`Siz!7k|8;^PGF$=bU@)dCo<nJYU|CIndcy
zy50F^->i5T_hSt$-N<}x<Zuvc0&S~J_x8(4%d!iVLU-tOmJ}?12XHme&RQ|Sm2Cp}
zM*%E;YJ27I<@feGT9a55Xm>5&X0R!!Ui2oh@ln4bwFOv%aUS7`3+I-`-v;E)H+$ym
z3@Ah&wrWv`?=_scv^Yr*&ND3?xSxao(;N3e>Z~z0lgfX)(OeMX%oAAs-H%lnugv_Z
z;z@h9A9z6j+&Z2<bJfzBjV~-(c|!E)26vG$2k39CC#a)pT}9=~ymEw(sr4UK8y{%1
zt^F9jVG8M=n$x3qTDIkORK+cizOxY|HO9A6Tn;m1MPCWEOBDmG47BamdJ+6t$dKD(
zJ_TilK)Y_GNBA~0?t(nt_4|*|Ljv45Ne=;(KYlq^Po%5>{fqMuw3q2LZ09)i9s%x{
zq(}JP!`)p({V?%y{t%uAO0L*Eh1Gv|VShL&+OneK)o)pc?0;H}N#zfcA7V_zkuTw0
z8q7P|n=<!JTKA2p#NQ%Bd5EzdgWiPqG{NSXzji)Rgg-%jijjT~dKG>GrWcp~C>)%L
z);_>WueJ6M8glyHxntXaCow+5=Si60un=>!nx`d@KG2?9NqQE0RX><-P5OTHkm$&q
zAvx{a6$;8T`%G{e{|y>aI4D=%JGp{_@^W)QEAgNUNnc2hC=bro18ur>-h_P-qObKw
zlTU%G2jl7UTIEP6x<P<J#pK<84fw01|Kv>MmJ^qNqu=;AnP)+~gdnjz$(WoV0$OJX
zt=F=-O`1C?d}`z|kZuLqd220-^{ua*Zn<xC{_)NO&>Q_HmtvoatV3^feBr`BxkuqY
zS#|%(tMKwDizi^FT%U_~6OrPKj7OBQ9|JGCY(L<Y+IqK(xjdqH7BOQ~$x?1r>AO-_
zmB-wRi{61dFt+rd`nvki9~Jf5h$qlST+7DzW8g<^Kkoi>1$xSVN>!|<00(n>%cob7
z%KlTXBAx=9!LGzKEQucTpIi)o3^QWi+qk4G+cHk%kp3BqC+fesnOJrp1}+2Nx4!Hr
zdT{YX{ilqDZyZ^ex3|IWn{2rgd{WO?JW>D6y~M_*NJo3_Q_2hr-(8vc75|czC(7ts
zpj)=)maOxAR_;Ehd-pO&xpVPvlJ`Uzoy&ut({yi(F{`xi*XOj}HcD^uH`hj8=fc*5
z72FiZGXL2_|LV@s6KFfG&G^)Q*=ZrE89jY-``rCWvp1W30C*B;N3QgsFp&@|?^Ao{
zvtI)f4zwZHevC7+T0F#E^pjV95=U<QecZt1F?Zy`MQ5{cBolTu_S*W1OZ0;Y4}D^+
zoFQ3*tC`nFgR5sZEm{{Dfzi33=;9lZ?b~;`uk`%vo+~*k`A=5de{wM5vRXNXai8-^
zq1!*|39KjD=wr|e@q1rc?MThU8(n+2kDgn4qKzKr0nhMl?%day@o82)Ze#o>tIOzI
z;3KT44_0Mr*Zu!+<K{oNoNGQ1QCtgO4~30`s|QU1kv`BSU5kypDk<d?E*<l&9Qgr=
zD1o-=TDy7CEV3Fji{x9-a~NL;{*xBN+@|}W#bAvOAO)K=YVwc3fd$&8>#B@BMmx&=
z^zGP3(YpMnq=na2rFC)5_t^{kW+RRLC%3|%!crraA*n=c9GlY*Y3x5a75*5cu@7rL
z{;6JB_n61d!qsOFvCqE6MofL9^>-fzS1x#B{*!BAgy(@$J7Vb&SFS5k+kbK{{2^{N
z&!y(5712%jS44bUB)Jx24({u!8-1`tuy^}YYERvJe=hh<Kkf1a+MR2$BqK8;&AFP3
zmF(5k_;*<zFL3mM_UJm#a)%nbOqut0|3AQ5(8tuup`Ke7IvMEQBm6udJ$+EE{1A3}
zi$m|8it9c4yjqX>9(P0({Q%``(CXjOOZ+FF!q2<eupQ=8l(;oDEo2#b%71bx&Qr7_
z+g;VWynqbrKV>QWDG}Oq)|&t30vED*0`1SWY?nWR`$p|Wx}M%~9i(;i;kB}5ant3#
z#FwbJ-Xx;Ji+}N3wfuW@&CL$7H!1dxI%;&%ubaLH(g)g~Yw1W3PfT#qv~=Ox{$haS
zfwt(%&(ZIJo$`A3HRxsjQ*Fh18GhKTz0B5Eg20Ch9&?8-qPg`PmSrn6%wM*~K9E4r
zN7|}(#q1Zby;ZS?o<lnOPd>$Z7e*7^tGx4jji<ndjy}^?e;sxSBl<Y*?!!OK)K6zU
z=4ogCt0N6MwR&3Z)&?z?sM;rJn|?y?3AA5VdLAD@%r{=zqZ(eDwy75L0sJSW;emGS
zDvz?0B(yo+m3PO-pzvZe4tICNst9`F<<Mgt$^xScv~5>;59Xp34)qBh@GmgBKpS_Z
z=kQI7+kE1B=ih(d@UVV+t;hVer&1Mhr$Yy|eJ441eDK8e!E>}b8n$oC-w&9axq<hA
zCT=xTG80!-IHT4lBasRN+$~8e6ixy>X;as~Ya*jC8k_!7R+!*40&OVk`fVt#e+%jf
zw3U~?k^3BeM9ubr`UdUA70><!_D<%0u?M}CWr0<Bd0AVmZw`7h(Zd4VJGrmMU+6)8
zukU+*Uq%lLa1W(FjKvS_&0dQ8yqbP+ZSIUz9FZQ&2jzLx3(9}ygR2LvkEJr*7wtXv
z-VQ({a}oQ258?%9zB(#p!#o#*(USs9gWQD?k-_zP?$+&<J=4d5ooJwqzV4Hl+PJx8
zW`Vc5aNi5^A#(!!ApKd-QkA#or<J|H?kCW8U%ye$x-pc#b9h@37R32a3gl*cPWNVI
z=Y&R!CP-EEXUm+d?A*I6gA%q>E~xIo`Zn(Rp>wg03`=k-9JVtfL>E=m9W#zSg)j-e
z!@~5$X_({cXBFg|BV~hRe0!gZu!{G1;zFUkeOEij+maF}J-L>^oUGv?JYZ;o=k`8#
zz?n89V-wn11U7SO;e5xa0Y5+aNPov^%D@CiAb_p##!Al`^5i$}FGR@3+LmR%oqgYL
zXvo>y(>4LipfuKUnPExM)8$eFCySN!K*%gyO!hs6S4l6MeH8Q>PXYN)#wAorWLz=v
zSb?s#=gkuc+Gx#|f-N=Rt@uBcUx-3$N93~&&34~f<*3oXw%HB?WqlA?Z6ntSiDtTH
zX^x_jg4y+|I24r1sYbCie(QoSh(A3YXq(apD=j4dNJZ1ht=28SLeNBV+dARUS{dT$
z&UJetXd=CBXjW~~p}+m)=^nsFDD!0{g|Hb0nm#^1{%tHmChRBtk!^Kw1r!YGlNr~s
z;fBxJ@_+HW$|dWg^tFc9iacaZ(YMCbY*fBt@Aq5wEd8<pPa=`%&UYoeD<m0~rzZ|R
z-BoYB_fTfXa;-QIa3Yv?=5?e=odclSnrI}C<xcERNrc6)uOdX^sfP5jIe9jK+IJ$6
z{C;1nu!Kp4A6dB0aL3ps_8ZZC?B_`=(>{xnieKs9eM?P{i&0uvx$ec6FWUDmX%!!7
zf<TG1w?3y)b#UuY`AHzbqqL^_BxQ_LVMn!n_6~w226KiezF|>e2Z#UoHi9KG-G<dn
zx$nO{-UQi_x#!d}Wd~O8Y53*ip=S^<k>t#YimY7MZ^7{oReXp!CH|8fQxY+j^DNBL
zt?TO+4eGXxM_Nue8Pdq-7JIm_6Q}*{cG@#Z2deJw(R&%A(8?LfW~o>R46gZ09`s>f
z$Mw4uHmA@kg|&M+Tb|ARy)JJ8r9qVQ!jf0NxNcL#(`y`gT_q<_8bV!IcwJrYKf;eV
zsf>(FjNF#M7P59F=dHZ2_R^Ex1j-0jpVa7{!1o`!^fkgI(pkuiF5#?|`0^dcvCFz3
zCg(OTRCBYzSLX0+z&|5MptN*Ks(65&>-QViOApxz=2lLNB)sNf$5ZP%bJcx5^!Ixe
zkc}8AuHjeJg6Wog?dR)>dV;xeQ^V%fNLBL5qrZB}u@s5t#?a^EIsg7v{{p{k_fIYW
zg;2UR`D#iEkJd!qc6U%+pb$!frh?6T@KuGJ8CU%YgifTpBsniGs_0qmKl&J<6T`QR
z&Vr(f-gm&F@d%wrdl{YG6|bVdlJ>}UK%!_O`6YCb`fB)JHypN6Pf8P_i7{Qm7d22-
z{Ps->UqU8HjO-G;R}=m3q1&P8f%9LuNLBRjKHD7zd}A~*#!I4uWc}oKVHF*{NFKmw
z@2&@6IVJlBpMM&wWa~9%Zs-XthSF83FxC2uMb*okV>NexaAfYMbX_CYH!sVp&<hHF
z`#w-PrHRrJ-GW9=_uQX%b0hEoynqFc9N5xESvLWVC<9IXCAVr0s$%X$f8H9&9)K6H
zWM>~JX<Gm1wWTj3@BmzZ1&(}gn@$n45O@F%zy=4dw|4Sx6A^d-9>4<Udp=9&?hYdH
zyEk9q;M})MX;+Mq|Mm`o9aLLA!|WDN?R<Jf?tcqAnX|-yqb<7p7nKsGafSV#-5xs?
z7$T+h(ccg;`5*O81vQKWO1C427dMGoV*|vnGS$v|kN<5ySWrr*qYs{6R{>|NtqyN9
z9)TN`ZaFUN7F02Dnj5;J_ggnFy`mSu5-5$0KFJ05x%Ayrv$P3uHCFaG4AKnB)KT99
zxUn;QR^d^_pPIM9VuVig0YW$I5Bq3HMgOqHyr-RLCs8Su=mcDJFxenzdC7K2a-t7#
zvEfIXPiHMmc6cgFZgc{c%}9rws!k$rbeiNKOCG?OH7XuJuhu2(2`>da0HtA(8wzhe
zVH18>1ZAtqN;az8Z>MLZ0)12Z6eV~*V<j1U2Nu?8{zknFn?M;LDx>p>@C@Io!zxU@
zTx0KV=mm&wz}Am2b{<U?^jFg!&(LdR352G^ewnE`p%Lulnhgx|g(J6<pi+^1<MbL?
zLYz4Tuz-0=q{v#beybAv0sJQ!H=*Oug4AldpRDXN6Uk`ixdjOPYE0#%r3lhYZyQp#
z;0ld?8i-!o%xMeKYw6L=6uSQP)LKqu?&2gW8&}5Hc+B&JlvTOgs^2m6NKP&TUY^he
zXiKWcsdMYS)exky_K<Ev>iT@^(7mEgHA6BZb7!9g$vurY%~Z`ZF>BUi2-i$hA*zK7
zOzN>8zs)GhmWuymd5x}Dme)1{m!Fr<Z=a8(HCllms=i=e@63-7t~oMGS^$3htICbQ
zDM13E?asx8%a+t}%om{6OqiG{18cq|V{GIY;8+RcF=bd_4wpKm&v6tivDc_yUm#{7
zn8h0P)9Eitjm!h&CA7`S^72Tac<p8D%S8k8CA7);fNMM7-Mi*HdFW4{I$DrOVgAh1
zHQ(B(yYu5+>)Rq}10XSLq)>Hmy8GFJNZJ4>%usb#R{qznyAf^xB#uCzZ5C+!+!mw-
zqmjAVjnLO@eaq<YkhH{b%N=9{TC<{$-~Ap*ON_Y|uC`{qPNjB2(h|e2jjHou%DDaC
zfkfJ<1ckpWBUOlYv13eMAh7v3PF^%%WU>Ez*#+SeLoioF9b{y^ip}{NEE{2hq|Y(1
z&LWj+?{@j<86<501QrukRour8{XG)l20&qkt5Y~L)3X$5Api=q1YDJNMfEdfkhB31
zxGP$-vL|bcJcLUuxn07<N8g%t)z@rv@Yy&dZ2$yjgMM}09(v@baR@g63U?Ko8-;0`
z%fB-nP}nH0LSZJc0-Q4cll4GgLfe|8UO?fkQ|^2Rf;(Ymql0UWC(+7xc|Ryo7}Tf|
zjRylhpCi6mWxL4gx>=MOnmqvQd<i{kuGF<fWq^eZP1nui?;}T%NGEhyh)5xnHLOs5
zPARm8bV74nmPjeMr7QoE8?7Oo()^R!2$oSQz#YF`JQoRUj7ZWNiny%czA(7&w+Por
z6A2d$yKYdXd0~W0XEhr?4isE*(#HP*RvTeeR%?^yFLv+I0<0XNAI-I6{-v_Ea=TBC
zJg&D^ClGEd7r>BoUoAbf4q*}*%`vrTR4(;b4~TJu>4-i#!Ny|F^-cK@Dv`iKQaxt8
zQGIqBgi55Z-RZ2x<40RXwnthel9!`unNEr5F$oBh$Xkx7t<-OiEZd6Sp2%5&si(XH
z=HI@BP>s~GJb^&fS8C1IAHU`J0e2&8j+H*Xikhg_dv^EIV9-37Na#JYjg`${U^%a9
z0efP<JgWDPCK7tjTv%<nk|KY-tt&Rsd<nRtSP>poQ9ta}s<&=fiG+qTTU4-LpZUh<
zpOK_wvclbZsa!{nBUCb38LDnri_88LjNYG2R!{-R^Js&&k)&j@!hL$-=|wIgNy&5t
zyY!DYww{0_C6g8I(RY6uEV}l1vM7<&xQFzSRh(nsPr343Uo;MAfzU^0+bf$iqH>^C
z@ItWBNhI`-*_d$4+xN@;^O2<F;0iXp`K!;X3f9X!zR&Ria9i4AOX|N!QZiq`rnF?i
z;m;vVGF!pcv0T={=h54fxhigmQCEM?Kd*QZDw(ZtJ6d7zk-F&p$!uktQB~5N=SQDF
zl9JgfZE)QaqU_Hb4&~he{Bj40twuAoPl(ve&y<6qVYQxVzq3x8pu*m)T*~J+O}$61
z0;vf-UpBj#)Vkk}Ia0%`AKNDqI=w7ZvBypAo*fFR?){p#O4i5SBobP^B<z<(p9edp
zj*S`7AX2a3HGFdXP5me$kuWXKc?iorm|~QT*r1M4`;oS(To$94G}QDrGv5H#Ot`Ju
z5tg|KMbeRX|9AySN@X*?y{g8!+8q!omCbm&`1TK-FQLVvvYDZx5A~9toAewqVk)7-
z#K`50oKTR1-a2{pD<=n)Xl*Qw+CkVFg{v&tyhXdyfEf@PxEwR6ubIKP&pm^IY6)Fi
zK1?*RsKuDCe%ANliG*$~3Dyhdk`=0Wqz;nTs8}lmbC<(cOZDxEB_5vZESFnsO(gVa
z33)lJ-WczlzxX#KD=`Q=?opL>P~6&?NLC_qIjr6>y{XQfTu4?TaRn&bjjFO1`*-9u
z1WRPDfMwA~g?+A0`Mb`3R9-G3b6GeD^@g);zKVN4sd#U_E@iG$+N@=xH~0|@n{TKd
z`A&Z5SZAOILg$rbU%YFnbF}us|3^jtX$xpZ=(v(#S%}ntbN?`C3j#K#B{t23yevFw
zz+cwx*B&W?%3ljugRM2+^P%2jnMm!e>XA8!xpDiGA~9o0wTwR(9C}%w8kI=xv9cau
zw=0WJfLTe1eg4Wfh3ccWjGk}?y$g}w`lHkbe0etiFMvISA#cKJSZiBoG#j#}3I0O&
zalav4BH1}EWM%h7+rkhok?kzSl)H%B)I0Y5Iv;W)=l>(cXrp_!Q}6#RPvKvI24$<C
zfbP$|A_>S#?ai{}1&Q%vGynP=;Tm`L7AY-UP~CmE+{dpWTq4<RTz!);x8<kb04GA2
zv?lCK;KBl5p@+YG0XUI(VwP<KYgOJ{SsC>atkEDO{enVo`t4&qks646wxtD|ux~$D
zI~A=PF=lgMSd^^uR@34jiKn({S-6^ZhZQ>YE|N9?7E6Umm&Hr7XO-ngm;A#fiN!|k
zw%yw_yh!9TE%vN9*t&W1@HU52*wjF^&GN$qlPUtCsjXU;DgfoKz1#B|!VQ4Ruu3^K
zwcvcPbktrgE-$E4Ze7*s0Fss%v@KLn{hd&0*}q8I0C)`QiQi25^JOG$05pab#b0A~
zUPRIwEzNZgpr+`Jcnh==B@*rv_Blz|M04?(UgMCo#9++V4Ad19J#T})vP8mV!IHGV
zl^w1W){IkH3B^WFR#_gw4tx5aZ~t>Num)<Y7S{u8&$)YdQe}i20E1yY^rc}ZiX+?r
zf-$U!F1!BPG=v)fhhZh~R{me|6lN>Of6`WrFmueY2sJ$|H*4NPBq^Q0;{JB+2!B(P
zt%zxaD|&sB!Y-6WOXqAx@*0iT=NEX@j~SX$?%BJo;B|ycXRyH4s)_F$>AMc$(gQKa
z)oY*cml=K?Y@Utc`f*rnz7$35=)M&hg!%YcQm{CAQE+$l8V~^#L2cDyD~8LJUl!?g
z5F~umPAv-;Rn;y%_Q%r*n9gA_hu<+ZH-}1E+)uQB@f=DbvAOWkV$ZH;!w)r$^&D=u
zYEAo~!@<u#A2Ly$lfQV=mKTwp10l5VY0CP|-qo@<!leh~Fy`A?cBbI2DDm4Sgi9qf
z`~DVgTY^@-y8_`F8DiV9z~$DV$h+&_hIA0>3Dd(Y$0l&SDr)*;UwHtXjb6f{vs~&>
z#648=KqOEDwMUEPk-VKoSHqW$k`99H8?{AC;DX+tnAmrh1JV%&hq>AnSB0nwE?ag&
zd87v_o0%Tq_HE$DLy~|w5bmz^2@JYQh8{fL8KF{1ETq+ptV%@3p-2Z*3Nuu=4?0=>
z?W0KA04NN07TwDAzKWy`fWQn@x7?Y7mR17?QAtLwxsJiY<te+uw!0Hs^mSO_Zja4m
zlWDBaU@mjv%a?UhBvCuJIM?cgL;zK+F7(G<ec_U*y;~NrR(n|X?y`UMg-fC~Z&|3o
z^S)H@_u&XP01C4e(+%RSi^tzbxYUg?Q!m`K?BCkFAkuCCBnFKkiBE1^i=+*J#BeLL
zap%<u2sZ!{!>v&E#LZFqmL<u2#jB5Qsw>}>b8>{<KA%LG3Ff$5tLdK|LI7*HRCYi=
zhinpsjXO=5!YHpE6SucN&@Z)_i?M=lw3xt(%jvnUdm6$u3he5ac?Ty;bw5NbbnsR@
z!liDFxx8o}&~589s0TWWaWlleMRyhewh``Ob*)0b+o-^?#v73q=p4qomah*-u5hf(
z-2)^M#(hcBqFu|s%f5df0n=&xfc}jdyOP@=V0t*VIyf`~ekf<s9i(D<Jm&XB>BQ(9
zx$0@><X$4O(S8|`b3)jMJM3Ut%b-Rt4e1M%K<)1mB<7b+X=MV>V{5@_ND{Th%K=vN
zk<X7D?t$brDnW7%@C%J53%)A~*hcN>67sU$pyJD_tUT9RADNa!nBHZvf}i!WnJMgS
zlg~`iBYnx9e{4YbR5siA%vmyg(1#RTcTZ^$nPRB1*_+YRITr`B>YnTr^gEKCN^J=p
zp1Oa%u2u*AI_4z8eWsT78NPP)nHswXdb<wi&6oTq`91S6FWVs5Gg_vy={R=x0MOEq
z`XAhMOkSeBF}zr`XN5LSe6Y4t>eN~Vv_tI&bMAI=B!??7XK!S2r!X&RhuR-z%{r1N
z*SSTfE0Nb@_|Al@Mus+e0=wvxXGZ>EOP%>?F6^Rni~4dW%b{ghqq=>t<8{!9AI-nc
zor@}~F(J1>UzxW3DIK-O$kL+oT}3sL--nuBLr1;#b=fqe03+pn3YepVcB`<b0$MC1
z(_K)cfm?eU-axR%5bnadDsVH!nDvhj*EiHjgnLDW-{_U*qqE+glW$w4ReD{_TwM`t
zPR$r<Uwo$TsYkszE(-`v?GclN)?0J-E{j+N!T_~VOvVQ7c&Gkt_qXHVB+3y+a|w0x
z@vxy0JOHb{`N?{dnuA1)a9OAejM_b4>px%!!Zp&_^7%qwByahVPwvn=bd#uEVqWxV
z_POoF=YqV3I*QASYtefymu!M0HS*cg07uoTEC((}ZbXtA$?Rfsr79WNwppLoM3NGd
zaW1KrG(X#`auufnAVp-O-xVAd$IL=VH|QjO{>&-P0M1{D0p^x3%a84Bcd*UQIM3K=
zS_8_0n-PV8P6@Yg3I>R`*R#$_BS$79RAcCMR|*{BuX=xFl(W5&m0*m#K2%^->A7AT
z&Le~p&Z)g#OaZL;u3J??`APc_tkDD{SwTAAabH?Jq*!C@bzosd|K+pKRYIs_vchjK
zKNwVK9zrG470yZO|Hrzn2$f7%SkK>C=<J^bnHBJ#L|CI*1!1-Cj!(tM{SI6TwX4f&
z+g03Dh4r7kpx=d=M4i3GF?m96ZCC!kPUO$iZ-bA4lBg|SURDCrJa_NyrLTZRBiu!4
zdl^wyQ$6>mDNprAsKhACB?Vq)@SD%iK&WKq!dmn16$>pys74EOhzl#tH6}h+1)-9O
z3tMjT{8M#UAw~rLll-iQN?diFD!tjGCGdsRrY^6jUF+rAOIPnK<taJ;Nt`vlyWlL}
zj4BLkIwq(j5R=-;Wr?X5<*NVu=937PSgp2Uwes1H-#4^Iu+$J6CIXjMnjA6UTzOzo
z3Dg)XD%BclrD9+0K&Vuv@`|!<0M*l?4j@!2Q$?LxQ*5z*eVQZ1Qkg1>$-1yN2ajBf
zV2$Q#JAen2l7}3f`yJ8&nX9aj%+eQy3RO;J9!99tAj|t+98@=nO`j9}2v1=7Mo}WH
zQPj43*=G>q8{}0TcgDrCakbhf5jlGvng|4@ws0|$2~Vh~;ob9JW+7B6by?9A%))y6
zos41#mC9U!s%<%1Wxe?uLZuRyp@QtV;N5l~fQ_uVam%(^fy&6BhJ-6eA~t{>z4<;!
z2^aQ2ZU5_$w-7Luy<A|J(7%1Lcy$C!<*x+{Qu;D|8<j@DMq2o(0wgm3biT0<Sp=2D
zOk&Wd6S{SNg}jWw{3nsv2wGXok~jTb^&wze=GGDS#ib86+~QoVzVk*Q+yGb$_Xzo)
zT=)XQ4S=^S2iLcX9S&6r0qaB^sl`l+x67&w>)35E=<ZE2*AZRq!d{|0!}450TA&79
zCN2E>q5j_k6Ok4IATHQ=yio0%1W@xNT<>UYJcP8-{It~xXRe)j#-0K5N|KTSATIa<
zqEXzozmOh`1asF7w9t6V9iOh{${uq&6=N+w9MZVEYD&l$%?cP^RAkPOoc8Ss1?8E2
zCOD1%1`R13lq>I@T+CzeOhA?raG_a?etJs-!wrDDERd^QsPg8PF-|$ox1nLEbmppv
zM+)`5tvPLmNRPJGrbf%Wel9bsE>bKtQ)Z!-7bG>@p2?pq)69wqOsB0FWvL`cjlSNk
zf04^j>7*5?nzS#}oKXX5fgWt}Cj_x84~8Nw&?zhSH;NXL&+Ue5MyD*^HO>EV&|JsJ
ze4*B3<^m^ejT#~R%A?`K!A&P;KDpW2!IkJh?aSgh4BL-Iu!9dp5qaNvH7^3DvsdhL
z^vzS7i5Fi$zyT0g%u>-drfsTJ{SX)$b>fy#1&a+DZr+%Nw-9b1G_DUieCCYq7mpMX
z2#t9+jwbN!^M9uy;6RuR+k6T}9AAty5eSvpW>OP4t?5%x!+}uQ-K4rvy=%R-e<FDU
zAu|g>n!JBh9k|qqK@ypb7R<?9uU?3rKJQx8wJz{w)W$3pBG7!-e-@8w0bZZlm1U#q
z8@@gl3)Vrn#`m`q1|}`s?-gsd=oHcdH4qD2tzNw?q|+t925MIp*8<)}7T-{?4+5t0
z*8*nvYC>}6+Njr&eyRLr!0>43=C;Oq0l*U#L#4041&LnJ%rW{{K88!BFT({Nk~bZ;
z^*+)9mAnF#`5INbub<j>0i@4HBeTh?rO!L>&e#Ryq;^(u`+{4^IoGG@eFvT>YB!aI
z%Y&K{*vqAELtcS8Zp+5it#;qes1ZmHM#Z{b0d6K=+}@}J@Cwv%TU=hSnN025P4DAo
z+6{obqU~JO?#RbWltfwxfV(1+skrY|y#9$3a-=+uaQC6L`PJ9!hw_iStrfAE2I#C6
z#|~b_yl$u5(=VE0uyoqu1iIyfN1Hj`R*JdCB#hIxfpr(A)%B{#n{hoUMeBC*L{U4b
zn0eV11zslCGKJ5d{NeymGPRe=LT8=aiqOl#jyH0YAz1^piOL77ZPtEUc1Qm%l4*lV
zVtc@$YQ2rxJTqPE_F%Ba)w6vAgVmesrqvu*6zP^qVFt>>gDUIezZW@+V5tn|u*@h_
z*oOw)o`+OG4ZaLkZ`Eru^T<C)Rw{=%C{V%WCY?$kSSp7(EKtGpp7*CZRx451xL!7e
z`6cCy!unOE@4vYGGY3~<gSnx~vaWt<8KKr)x$2tTeret{1Weom3t%p_W(*6%`+kjp
zi5WBpmiwgL9nbVy>wUM-$*Lgomjm;!u{D89o-UXIEP~ou)jxFz9Hm*J{mUJ+lCCEz
z-e?lm%Gt1Nz8o;(uxoF;4G0%c<T1zAeNL69yS4)1oqFA&07c{Qem(HoL8nnzUN<6<
z9b7=V6K~w=fmV*lWsZ#8*`XHKE;|-1aoMO`i_5Is#F#9`E-R6(=bpGZVAZJYR$N@&
zO)mO1aum=3wckpB0t<V%!IJ3+mdIiO3s!95(|Pr75Kk1f!K%ME19EL=<Ld*FW{EMF
z!|Ht4x+7;QQUR5~3>3xSer5jcj$n=EW%~sV3p6{fXS-2I1;iN4RiGPJsX<jnB3Y@_
z<)Fa0K3%eW27;yXmcs%S%&PTc5l00QZ;cwTcpD8<=m~8;9Sl-vYO|F{(Ajb^Y~C!d
z2H`ywCuD1PnR%iTh(TDOdl`1GthBTo6?}Dc)vG|u)XNUVW$%C%f0cgcJc1>LVGC9_
zwYbFvj%(9inJS1BwqZs5;Zx3??TXvg(>K?u3?7E~YD!@!!ANJTH9fS|{yNRaO=q73
zX}#%>By{$D2_qvD8J(Sz<;~~?{o0WwlimO!nR@r3jjX%2fg5UPf{>g*<h6~9yxZws
z3&$d4BDEc4!0sy}Moo6E<(AlO6xn6BI*fY3*qB#<cB#!+wye4-7d&=18|Z*KPs_mt
zI+#+&8;OvKQ8_2GdD~}OK})+ZCVLIi1(DS@vTkX=d|d7Zl9)(q8y8vH6QibAK*&Zu
zTXEDu23r1b>27_HohK@h$Y&c_w~M+JpAAA18v~S|#3-O9E~sA+#F0cJIc#LsWXuXl
zJOZ*0wADCrq{5kE2%Jc1-ob2x^PsKd#6QLt`5DA)Beu(GCb5FKrs?m8$}%s{f093@
zHf-4fTTvV6<9}%}Bc0AN8QvVUwQCxW-N@AoSOj6FR%Ryecd<Sz7Q0$S2k%8R*bZu{
zgk~)pS(7#9cK6SbtY#+r5N$J1{qXM>lb_>pn*U^lnwe}N^RF_kIcr|kyc(T4T+G?Z
z$<SshThRUZ7wxWo-E1OlN7+L>lTdBU$mJG$4s>k2w*AgMdsA4KaMQib+OEnyP@SA!
z_Ee*Ew0dSfGqKqzEGx_?_K-j9sWBjrC5+bcA+puuxu(dp6!b4cCmzySY;M$WS*%MO
z^wLbwOA$?I-LfQp;L=T6o*Bl4<#yrPM6|hIg)iNzb$sc@v{46SZ!WM=pF!@4CbVu@
z(z42*)dZtx_I%D4yS1qd4A&f&8Ll^jd5C^FX<0Ts;9%f#vyX>4d6ldV60g}4I6D-f
zD-GE4u<n4P2~Av<&>WIk8`p^#7NWp^U88=c?k}PV-CP!Y|I`7tLaM6%;!fcYvh>YO
zbd-_S%zi`obQ-LXAxnOE$oXtf)-i?8kx!&%DGDfmZo*uh%+Z7~TbY?0j)x8@%T&-`
ziF?GS12@q&Uqk4US!_oY)L-(P^5|JawAn{6%?g=ohvW<$kQNHJx|!=YuSVdMkSxF-
z53#d0FkYlv`-stcAvZeOoOIigGlwih2iVg-T)n<B^F#b683v)R%f{w5*FQC<NAI+3
zXGu|^p;YhC7TUEfo@l}dF6lYhIjLDW*&V$(y?KC%Y-{aXRSMPFvgTu8>(P{G9+@&|
zh+;RRUdYrxb7YcJA~=WRwys}$7jw2RIA4p7rtsWB<$6|xJ=dyoZhaRO9Zll7Ei8(!
zgFii&qxT6!M;p^*zD^vMnV_C0AFbWccj>M~bfaCnM7JA8+_b1lgW-?zB+);Wi#9iV
zvDkXNaQMpBEWS3~b6`V()t@T&H|_|Ux*YgCLc^D(f>5T420oirjdtM9%`JfgA>6fS
zqYJn6fTOm)TfeCY90*||mkloYCROm<6Am@ev+`&{2be#$zFVE&|Lws@YATOIZK+ul
z*N)t7rhPIVWHp3oT#nRP-u`U|rKfv`go=|E?FpkN2j4@|Qwbg_JT^W$J(_gnNx*VK
zPnaV;4`jN=Z|~aDR?qsQ2@|*&uH}ste{^!jni@_zBQe~VJX#EAZj<F-P9@bnh+WdO
zYd3vU6;0?0^U2A*vhI*pt~|UE0h7YGr2y{fbay}awQh4k#z^Q3b0ucLD6gq|Z9dq-
zN5>j<?1oS-GYBTlf@Z#qgr+3swmEQQ6i?p%^J+_N@Pj9s&>`m2N2uzFo*CD2jrKJ@
z!=wc21|Z38n%QF$aQK9-Fz)DimTPB>LIJ9@@69@~#bJh&co90p9CW_9(ze;>UaY$(
zoW(!>lVK@=+7g;4bZHqqtu#ycAGQ+`ufVt{8Y2{r|J|(fCk|;OjvKASkK=rNqJmp~
zK}a#Mo`mKxt|2{<%f0RNeV}ndyO@oKeMXsU6Pi1(FKL|6E+)YuV!u0LL0;hH3GHGM
zFral<&u2bB0vi`hBryL^k{Dbgr6N)=C18sM!@e`COSUMLaG7NV(|BzspGd)fJ~t7x
z+D8+vUvw0V{btK!pZ<sxOi99hdT_m_o7_Ivu<Bh7%=0Z-6Gn2g<aPtkZVxui6Fsl^
zq&PLVom9W}N1%LWTsWD+UWLAg%Fo^cGFn38n62GVyF$Qst*ZCT*W=(rAT$xCaXH|=
z4Y3M+?C7GQ!0pEycO?!zLI({Pz$#uib?aAf-W#CUMYxKQ3l4Lv%0-{91~PC$`<M%f
zUEAP2f2D&Qme4`wkBrDyc~;G(Xa#AkwsS3(!~q9)w@Zt<pr%3SBl8!Vm;V}w2e8No
zs*KGVd&VR6(0J~?f=hKb#SOc%XB%2nBh`f!+StrJ>8WVHmcPH|cqb`b8}%-89ZB5e
zlh`-Ff)bj`B&}nII_7w>a*lhF{2rmj%!Ss{#WmUUc7ZJ*VSJYi>g0Ini00Uz!)NlL
z%oY6IwYk^Ka@UbzyZ5#@ez4uDl+f`}v2VPgdF?H~H(tZBReV|?w`?Sof1xUElocmF
z=KH=|YOqJ}pR9RfWRT2|J;Esv=43vRnw{o}vz?>zuzsh;iRKvYedUK4O*1_!v%d|T
zZPf(9@aN0d!}@3=vOUp+`yDlOen4x7BsVxGzjxtXe&(RAhS3|esJ;8ZpyuJN;$shm
z?wSzu*5RACX2!)^A=-t{%1+DX(0sI=tQ@05@Q07xH1_Ym<8H=e$Hm)^aDC2eHA-#<
zp21kLusj3XrZYE*+D?mJuG9jY#t>TAT+K@+ss`-77YlX(0h`dnrojWVsg_b87?=&A
ziA_V7%*IuE#r#K`fHa9PM@+)!<s9bewKS>l-Z^CuxY<J};Jgb#)qB>fW6q#uHTwny
z+&UFh;Xlq*rYC|A#2ZKlHY)tZN|`5-)flZ^ay9~<Cm@<`-i~@K<}t=p{*%~B=x<YW
z!*dX)hN3;?_{pb|Kmw9r^a<)a0K2dFeb^Nz=1OUT(VNN6K<%>#zOi~cSW-g2o1ztw
ze`x9$^i}Csz>*T$-V}I9)B?v(7pu;elmDb8C0r)S&_&yuRVbEEY5DXCcZ#v=6t=dx
z|32VtqPeE$Jj;%QXzvvJ<?mZSqDB~1rhx0sb_)+rd>P42atT65w%n-S?xEbdW+8Br
zL+}F!Eq7;{#U&!sB)J1Wa9+vMOmpOgR;!TCjdbEnmErZG{h$}WpNP~#asqzPpi%zM
z9knU|FJQ#By@2RD_bO@L$yFVD0f7nKajGuBI{w!0!du!^9G+;x-IEC19!{XVKvMq5
zalq{on&y;e0Joc*IiWr9VT86h1zYlAZW7t8@%m|8_1w}WA7-9)#*@f9!FPW@61uBE
z+veVT_nJFh=q~t;htG}R4fI_7GPsfae&FmX5q5WNaKq+pXIR(Qx(~>IzUXM4pYs2a
zA7FF<eh&bbiX5E#kmyb0d7cbxB)=c<>&?C?&%o{Od{^wk<r-~7N;h)fAH7MF*JtYB
z4R&ul&mYAfAd7Bfs2{l3y%NL?LbJLTsLG-F&&>eLC+Rl##f3=nhQQUxjPkJsb)jR-
zopt^~yBChQ&@H}NKSj5Z7(#EIY~kSEl`BJjDT!n@mIeJ}p5rRomHDavrQJi&#%S*k
zjnwgir(Y&_Rotbx<`ENR+yMANC(Ze$x^8;QFTT?ni5(c<ht5gTq3b6vKEkVCTy$CN
zz?gpTq>lXik>&ARXjLJBP<=w{CQFt(&@NwQ{J6uTpV!2gZ?oj>!_gs;k^D<r{{4^=
zZr(fe*AP8k#+aM!TwG6Fct~pZZ16GFi<5V6bn1)}$&Clz{v-!Q*s$=Wp8#!`+wJ_N
z*0eFWM#1rpz>;a0y8{(mmh32c?zhuZ(J6n($VP^9<j$hp--Ruo{)xe~mEOwwxmb+3
z$4&r?BUcWr%9~R2$Da|bk=p`R)Z`KD*v;GD<qY9JSq(;73s|;a4HqSI7n%bV4C<2^
z*Rj}7U(Mt-tV#;Bnbyxn9C|I1e*kwZCF)@8v6P@SJqDGG+1FC5iKeZKIH5PH#hCl*
zxb*gI4-wj!tNy#keuhwuAzVh)7VxoiIh_$jjIrAfRX60TFP&ZDtf0hcqa9nE7KXtq
zdEHa9swfo6`@t9yT{%r8+c4(@lEl$y)OSe6t~rj#GO*DPDZqez-~4oA3!t^Rv(671
z%+T7mpzHSt*ci4IV9hS7+^$*%DT738+lJXFUNN0pS-@Qb>P<(`ByzjZ=#qhyudfE{
zyP_C#OP#C^aVG!^gNoQ~4#z)^RBepf{@83#qyl{B^Jx>1J^~>&Q#G28m{Pq&0VH!E
z>=w|f%pvz<Ryn{Dy^Ut)PjBa7kiWg<ooi;@z6_Esb5~sp=AD~{*J{4vXi8AqL*rL#
z-zTqn<VH{K^A*2up0*|}UysZ|Z1N31W(yC2d)xENAIi_So+0cfxe#-Uog{wK7JI{5
zwO`e->8|j$tH%CjM;BK`uO2)#ircvVMlr_RYbQTrPk62IS<V5En?AOBqp?V*`O{?i
z17SVCw+^_#eD7SX;8=_d9SG~a%%5m+aZR2_hdAXS8Q2)mrG?epU!B7{TOerzAv?RL
zf?bNGko|s@3atRy%`JC+(!vX+@79}C2|))!c5%0c-t6kF^JuaIEz#X*7XEZcRpzJH
z|MWcASeP5^WPPwxKQTsI%}(>I8N3u^r{-=ue{dDH+n5)h(CcF{=59L$R=(7SYu9pt
zeR3^d$~B_w4$Uoh62IB?frs0zT9@yT`h{NQ3VA<6>Nc*VDtdh|WB-)~)n+1f2Sjmw
z>ypzmsyYbj<~uKCnHelsw?#)+*{Pw{2U)7JjXd{LcI=^c2M_1glwGLyTZNFF1QOV}
zC$+cbiYIxeOWfo7X+ca}Ky>HmY*0vqp6=vI$<^A~<4Tk_uBAnJz8QZ&tM07On5BAk
zJjUFUr!FTSa3W@Z>i%kgw`&1lGUnDi@C?;ta&H_c&N>v6G56-FCWH7n?unhhI9iv2
znYlGj7M$fM`mtEu=ic9pR1y&L88SK*d;9e|tr51-SQM$zNT*+}-fW4m0}AhaUZL+~
z$z}iSW!3BRf2m6u5c`|$dxg!jQ@dHO|5flRTF5}S&*z8f3)v{=P#%OF2=DQrt53Ez
z>*!=s66KAWwkXd(i)S5IikI3_IL}_NeCCck$uxwtzU6bX)$-5gehy&=vSAme_(021
zQDye%EjKad&OAwOzD2O-1!!68_c4Fn*PAn9%zb$rUnEit+4?eqsh!tW-R?hELx;<?
z$QQy4oc|<u;vtb<eTt|Ii^`0e5dD>}aWB1%F~&pUzwa^3c=-5FZ#cLGBeGwki?!KH
z@Spr5M%$Ft#TpSfK3A4l8v9dqs|itkr&*gyK8)VU=o{oG@?kPUW9Xf>-iWQBe~uhu
zzPVF=0&9w5&)}~U9>RGde+cM0x>9ZWUgp;3-?$fJzSL91EN4Snr};AxDXZFuAz;VG
zwAQxR4Q?Jj;pBgk|1fII^&di4iU-+UE|(W<+|8YPvYPCC#M-*^P@p{I$iX97V71Nt
zd-6j#I$MlrRwvh=aC*Tn-L)%$Ju&7UKJWx#!rl<;3J>*FhMXvN4C%{Qn~@(R+#-7y
zMj3W$!@BwueNB1)(ksAynFrN9@FAjwO?k@t^q->8Qv&iU&Z`I~iJnrqTL~{(dzx>N
zM~kpt3b^)*jx>B8J;BHfp)LIh`W~rV#iRn@aKPN_$DiO88w_x|v+UDj?}Ebtb8nwO
zWxH~Ap2*ptTF?9my<c#ol^lgJH*y^XcX*1ieAc`61dtb*8~cQ?Y$IU{t5bJti}TS=
zUL*w{b59>fwp>nxrh`7^x_{?5OBvL7LL!6evR;`PeHp=$*zd@y+t*u%rh&1@G3I_f
zSK4S^qfsp(c5lDufrXi`7L{<rz<0Afj|bgDxFk+nYKRU4-*0xFQ)3qotNbUg8i~n1
zTr1;H?DzDv$BKZ`jCp*WpDHY9?L(8tKPuS<)H4%Fn+8X2^nvo3{(WXSik7Hs#I>m`
zn)5imqKv-lhTH)1n)~x)WuOmmn?z>r0ec2>Z=OFeT*01`I!^`l9&=9~!q%3sbnGJ+
zkV*nzHgCVsn>WwgXmkkJw7DVA6<Yu^XQa~m@{?5->7UrgB#{ERWp<j&Sp9j=yGYys
zsBK--u5VTgKU2N~f)0S)44Spd>(J-=c4+SKL~<PF`$t_Rdy%7CJ0STo!Zi}m4_E(C
z{X*kk)0}AP^4fe3XYraZ9m^ikhd39zo$sORIM&>E=O-}a-?L90KdLh%*4%d|Ln9|w
zw#(;(5pV#p+8c(vQMKa53+dh{);!qGUt*|@A(@B2*S%4!x$O>NYu@O1;kiYe6wbBh
zSo3r{30==#@{S8`<5-=H8VI);Do6<0E=UI>cw@~o?fm5hDM7F2d-vDlb}X&s&h~L!
zX1IvyXU2@ui~O;)zB>(ETg6;^V|_72V!5$^=Eri7ix2C+=n5b?t?|wk8*wq>rG3p1
zv{7dNg+y%3RpI@g0b|TF?o?>Fl#!$69MLO^v9u06Stk~{ww9ZFb*=<_iFvx6Bt1*V
zSdy;uvg3rE^#I$=<Lvyf)$HK;Ey+Ux+s#w${80hhA70YoJA@oaAZME(!1nIrD?b9*
zZXRx@$P7(n=FS;!0JfVa+(B^7LM9%Vdf(Z{N^CbqF^lc|D?nB~RTA}2DnFMF=t%3v
zv#pwG8ZrHRa{M<4IuND{Xg#}Wv*?qz0Mlvxc(T-R85ivT;dj7v^Qb%jWpqYu*z3qu
zVRZ;}y1V<;s_b99cq~Op^SC=+&E2^xJn~S=&b_q{MICLosx9keb$X3*uhvenGP6>C
z1&L2gAo)8#d($=sHCyzGL~9#Jp!Yk}bI&{`&Aqk_K?lNp4$VwQby#!uRhom$##p#=
z7gh{p7EO#cy1T5eC&quzzg_bGct6%W`A%BaXI31HI-0UGE;d&Q{o{bwOO@T?>=h*b
z8#j<L|3R=H{Nb#RfWpmt1y?H%I^jF@a>d37Isg|Sput)m`StC(2-@fkU8x^*c3Ay>
zat#n8%pH0TbY~WVlfAf+e{|5@+6bI<q{oLo+a0u3d8t}8@Si(9^#=$*=8<?@auu8@
zT?7l)!m~y!o};%%#+s+&2@8KF{Gi?8+4@^%<ITb&$NZ)ryyyF7Y%F>O68)uD;9o5R
z4fT3s!zrYGk_(XFqY?O<3r7B^U;h(pzFJjLKhNNp?9KwXzOhf<wym9djN}1~wqtn!
zcGD6&-BJ>O^C`a_06vk{z$YohIy+GfvilPY{{o?u*1@Nt>k28{>U>R*G}Bu7IKGt(
zKr+2}C;wQa8Kb{-R#U>(Q}Q2&wqK3VjcW<eb-i2~|LF*%cT(VY^<tAq$FI0>-){(?
z6#rd(E06-39-DBxBElzo0ZaFM<OoC8wSOY_%R3Q1*$vo9<b#O%UAf~sffu7S_qqCc
z(1GO6YHu!b_H&XSFs`oT2bgzJJi*06E7F1YqBZupGV=@rd#_2Yr=z@@*3~DjiL*LD
z*m-t1pXjSPn{l6R-UgIz?(E}~68H?+IW%XgSM>9I$v#)~Q{Y%yZ=VD&8fL=LB}M-%
zyY~`$0?8*>Psqwj9qPOS8y~B_!>JABCIh=SPvdh{WIw?R`wBcQuH31~a$x?Gwl?NF
zU48ggLkugxvn94p&PA7$Xuwh5W=p$LYxQv|vF0ItzNa}Ks);@c_E3KHg|#PCpEY~>
z{LN@>NFGD1jq@yKx#1yTZC<^3_ba{eBQ~CN6d;};TKIT-lz0@|l(U`*#fS^8xH}!}
zA&h=o@*E;<R$$BZI8#P%3XY|<30ktdqrbwfQNij86l{8P7O-9O1V7(uvp~SOA>0R#
z49Yuv_e5G5zIRjhZ?u*{@eVvFum^}^6X>CK6&=3-7!j>&P&|VDVco*X=*O9;zC=d<
zi-my`r*#a9CvgAGp22hlU!m{EPp$$9G_6-KJ2T7vLKcVRn>)T~fXv8fo_vXg;0<`o
z6BAz;DSLs;OjSc4HSE?KnGq?qu%E&E0!2TP58vG+RZod&uJ`K2n%e^TCMh(m)-$Z0
z6V+~2o2I;7?+|O#yE}}{N>M)qSv!8fNZ|U+9f6Xj_*>X|vV5K>s)uT2lg}@<yYFnZ
zrEJ5fFw19%C$J|8b5$tUtw`58fDg3ZKzl8$m~Fp@wj=&M;@um7)U?Jx=LvSmW35oA
z|7=dzoh#8JNR<fX5u!6tPd#p3`Rg`%1ZgW`KSBzu+)t^r7%^zyI<yp|+{1nZi)?J6
znVPKlqb&CDi-Qk@F#pPbQf^?ryH+w;MmqKc0U!Q=Ks_P$)g>T|CIsR`tjA>b6>+*j
zq`n|`Di19MoQU~OTj^bV(VAJXx*Cy1pX-8FgOqL9tHEr^CAdb6hrYN}8UzYjZ=n4I
zJKk|U=_-2V#JDw1C!6FojBnuYHN1)u<*L+qB@mm|CHS&PB}Hr-5h((kF7_WUHQt|}
zSt$QWR!V3V<kwd#(srm<X^&H{k-^NafrH^&pMH+KHW^`>eSw3?Jb{qYjad^9t~<!j
z+xY*;avI6sLiCigt039e&UsSU93C}J)vx?c3n$-{k&RnbD_gECdU3!x-Y-R>eKASK
zHM88&0t?;v%zp6OIm5uANun{{$s(ik=|dws4gkd}LWiIvvvaDXtl;ad%g*CxgS;vr
z>%+Kta96NEw0eW*o<8HJJIAmRg^idNg@u!_owXuug{YJZ+$wk?DM@Q?4|JuS5X}Y<
zTLQaw+^6J|N4Z<(u2aS}o;SF-1!8YbD*4dumZkdjFBPMH71p5em}i_5SQ($rXP!VP
zPU3vlm>)qU&^)fsXKx&oeNM#lIr}m*w`AP?lRr0t)Pc|)=op=iF7h|_1eRYbFHm;o
zuqo&fbdKAPus$UcskLG-3xfwF@zM?t?6TsGboVW+bxUo>rUh=T42dhF+{<>e&HZE$
z&Xeerx90p?Ay?PXh7*T}JM}tQd}A>5EwRXN6}?~E^I~5R3C!2wTBvZcf4k`FWgLI)
zQr>(Tz$u@a(UV=S%U!lTe8nZ^%={<nbDzq+iK~D(bJw7?e*8kcmd$dd+&gK-7Z<qy
zrIZTXDEz;SiZk~N%E0UrV;;W-9{%#Z4#9KMYp6l2>xt>%x}xLE_u~2#?Sx#Hm(9!l
zZ=`N=afH@E!ArJyJfUyEs~L=xESXV^BWCbRzd8#kYup&peKPX^skdHyy!fT{T>bnf
z;}XekHP_<68=R1ytq0yX^Od-=$SCj*Yr1uy9(dyj&4Z4vnJyj>c(46*?OQ$Y#+lm(
zT?5nuZ|6EQ)AcwLM`#;#1O{<tO5;PPotyb2Y8zvtLv8Jz%!Sw2Jk8fjF$Hs%pzqcB
z1>&vqwpIBSeW%k5C-0DKj4+?id42AV*<5T*<ok<;UI%{2+#)E8?D`>>&WF7<Ji3RE
zBXkEkA|nr<ytw!sgi0haD`t0Qn&_eg)0C|5KH=)+l#tbHq_9xJq1Mfthqq~SutU%h
z?F-VLxeCSsq7ga*xfZM&J=oA4>myjjp&e?Kyi%_X#u29Sx!7SMI{6ZRtut%mj;)<}
zCc~d2YsMI-CCwae$F@Vvuydt&Ur+jGxoX=h$`2h5{3oGDP<{<~Z(nw=9tln&DG}V5
zoN|I^X0e&_8SDlKUh6{J`AZdRZUak8XcV;MW*)Q(Us^s9(5iNDEm#e4r!($|`(G7<
zG+&GBsGZ$uj}7wVrPp85Q`0y?qo6Bw82?Z=+qx5my@gt;2_Jf{ULE!-{3qEAp<7UX
z1pk)3M`lJ&sy8Fso(sTYyIpwnIdfNKd$;F)nfDO--y{%6=phtk<<`xa$_}>+jcgWP
zE3C+Y@LjE&PI#?m_0nP9tXxWN+~$wfCG=8M9HEC$yq_~3z^V;GW_yc`Is{T7!qh*%
zC-8cjWL~as&egx<Xy8R-XxTl#bD6g&tLxrvT0ajUviSmCk*x?+tLm;7+?S?4@sm?J
zlTFIF@%BNBeq2@JGw<g;=fFz-!B{w|{Qo+JaXtHd02~9Meb8DxH?wjS;ad5v@pT^q
z8HRc2pXC^u7MRhz+3QWfocYDmiZnyOMqlXy%LD9PTU#)s6qpYeN9Y|C+US=#_<`5{
z?av4)3k)unmJEd2(A*DeCp;aN|NFY$IT1(b8x&HDb3;KrMnSeMQ4KHgvA1R+6EW`I
zEqk_ouf=T@yLX{QTM;&q+zvKW%lW<GZy}8v(*ZxZBUn{H(|F(Co-BnlPNcXkHb3iR
zJ1Tw1&{wg4iaeLwxI}fMsmN64^*dGD`TNvb4>EIeeZWs6Ol(ad|7%wp%=(TabP5U+
zv=yRjBH^co>w$d`Is|3h&P?Pkn#?cH2`+}TVf3he+Th1Os-7Qj+u;(D+PHxJ$f83)
z#qQts=_ioX#`ND0o6}rHPQUWJ7a<46bCxM+$h(sdy^4?nV>vt4(~vvOnDqwIbYL78
zS&oK%<gqg=k<@{aoadaXri1D>@o;V{{5CG3;J4MgXo;+BvR)a{00ja<51`BzCb1~P
z*kZf!d|c_E1pY6sa4E4dcK}*pH`Kb$vT1>V`smwId9RKDzM9bdCri#VZB5zdv!`zY
zr8Gk0pA4;kM6;&TL$iT-m@nP+BO)vPX%av7+Jr#}*=QgB$bc^4^*TZ|2S#zxfS}s+
z-W5xJ1A8?>H=nF#UislAXn2LzZ##y3kMt54+1VpBjlVeU-?I)OWy=nX>g+gL)k@Q8
z1qM5t7b%h(^(`@7KjaR%uyiJHdW3d8S=FLqr3pOY#Pphgh=evh8CxVDsxH2`Uv`jF
z;E<F|=+G0;%FVGV`mfg_sv>k^G<VTqF8TV@%GpTe#E5R+U5azylXFUf3A=HGo;+JG
z;tDrwZ?0-(PFC4aKpBtG04-Ny%Z)O=`2&tj25!}SnXVtQp7Fi0?cBpi(?pWn5{uf4
zX59B~_Wm7dgGh558)Z0`Mz*`^XhY(;F~N~|juQ6vRnC<M0uwsyWYa*2)8#x>djmBS
zI_vz9p`UJ9;94w_+PFRUGYynD9qia=tfOYhg_y6(^+VQUd3eM6`H{qd(Hq6`(bLv}
zNwjf<wmDhPXb<|+n4uMcrzUjD$;dF4Xa3L}?J)@baWXUtw7phjtp$OWFey()27&h5
zQw>GkU#a~Q8scPNdmn0h57n8ze|BrK)4e8<+~}Dqi(VQhtzoCWtm1+?F`D<>^fXve
zLU)|}4lwp^4+(o27&x&njx}d{``b6Rt4f*WsStsXsbm+(Fy?Mbtv4T(uFY5A+GOX*
z|Nnwc9#;P}C|wig>RAeBPiUQ$mhK($0Ns4wuka*<PfX;w)*XDPp+CQUvLwQ%Mt6qa
zc2N3*<^OQ&z$XyCF|4^O;NVO0a}&2tj$Ui~&;j255#qn0G`G~*8_KZVdmoN`rp2BW
z2dxtkcKM9{-F?$CWB+zoE5!`L@I8Bx#TaRkURkWQ7~sCexF0K(;XaN3kK`7NNk!Xm
z{<(m4+?cW|pLUL(RsZ;2z$|l{ovnR-B|OeJtAw6?2O%4q31nnxMco4W^6TGJ1_7Ed
zgwIkoml<W7`(B$9=j@}TMI?6Fg^Fw1^;~mJr8mCUzlMn;cGp>`eE6Qo2vx^;w9@$r
zNEKA_b5)??;!9bj#Q8s8Kv@-3(hFQzTKwwh|BfMvsdVSasIa)J|GIw=t}$>*=7y5)
zb^8t`f*h9EL1!%=|5l(58^xfmUeJYwpFSiAEtA?@N%O^et(7xvbNv#!7UIoKbg~ve
zO{e%L$Bye{jyLzv$+$3&A3i%e8A(hH?c5%im#}r~I?MwJjr((l>2JaD=H@xu?Jo~+
zdaP-IXnp#`)%K<8>e*#HVd$RgeP9i7^v5B|y8DSI%-eH;bsMYj!?~hJzkx6r?KxHz
z?R^&E2Et>s<2c-JIaF^TJcj#?ZVlfCpBcmx8|Ew`quoaB0W;SC5*x#uMPj!D&5dt;
zH!S+WIfQqeZ@jr_P9huFz4X~}{s7=Gv1QIu0Iuf^eZ5~QpoF<)P7)aIC=OSyl*%d1
zf3hZs^|nC+20ZYnd~8B(an7JZ6L;e_G|W#Xw`?*pACs8>WT}lo+1JG5+QPdXuKes+
zmyBhkFUP`P2UWTDXQqCx9B=NDlOUb_C6G9xN!i6nVk3bacoyB2Bd04@GQ7wPjM=XQ
z$q&J~jVaJSR$IHzk=D(t%|}8Odl{w{f@f@g0kPNI1?LFMYzj10f7iV`INppmH^9lT
zZAFWkqJk|`CL9Ky+}r>sA)}V+f+y#vfK@Yhz4_rnkw5sb;R|~6bG*5=&4Ct<N6|yW
zaiu@jTlnM6U2G00|69R)tLnr}NKi6;QOj@jg>OCS*sSCe%*|>-P-e3%<5%QN^W6SP
zFN4IJJJlpe<`bL-AE1f1*QDn`Len_Rgx1|cq3_z~I6EteyT;&Pao3er90V!~xzazM
z7dT0C%bKGQCa&+(3%1!*;NNbXEUqNuhe^^Bn!DCyc>Xa>H19lB2X?)Cb=AutfiT}u
z>!4#7H1|ODogjfQH?GOBkk8v9XPyEs$lSLkAtM*G_}5@?*=@YJY0VE8ihQ8_+R}j8
z=0SH3wCjSnleB78H7Di$ga3<fIAyaiCe?eI?rqkVe*(o@cXPSlJ-Ug+2h~P_@7LnZ
zx6=B_>%@I#Ac{qod;afkz}uS#+xg=UAFfB#K8vOucG63U=f+G;<+)c8x!R)KuL6f}
z?o@L`=6?%JcLf*!a6FOw4PMcdR?ys|=B(h(phJE71kVY6X?<}1VN2C-*=m-kxk3N>
zAl}@nCc)ng{$|&`Cd-361dGmB^$}AizkHLkoWGO&21d6kJ>qpXbVmOWFIV*^L{Uja
zHZG(OnSU}-y~z^oi;1H3H+|tm0$FBK#?3QB-V$Pc9jp851DD2zf>2<-oYpZD7aT?N
z8`DSL1&$=n$ax1IfhN`8{IA|96CX!Q!tGo0I$K>}Y?scz_OLz?ave(0z;CC8F&p7O
zS?9EXZa=~qw_rU<)W5}{)d)6FLt$%7uLWN^(MR$E#wGT70lrsb#dQt%VEUW49AN21
z%w;&f0HG1QFdGuVzj@Z`d#P`?%*z$Ve=@SMHeew~Xje)$sd6vY`94nuG#1M&KrW-A
z)tMXSt}MjF<3AbE$aV`+ld$#mSDpezEOWz}g~xT-RUcaGefXPV=)H}LZ=<q`rt;oT
zY<l;7kRq9<&<RAQNH#?usM9;?gP#DI%?)Z2tfte98H*<%SxIE(Cml>y-kzbTAoX^>
zSCFhE0^6`&74+YMWji>sN-Q<*cN~^-Y4r)T4PIO5aZn{IH8-P4YUM>tMFU^ty_FBa
z()ej9me(*9*j7=`gQJLea}Sy;Ei|suCk_<^+%k`blW{fcIy)o&7m$0K$HB>{{NzN@
zLifkgPa|9!XN7X1*;ZOMvJcXN(ZpnVHM@<?o7N9WONzo48Q`@VYhLqoL%0EOm*MI*
zc6Y<2+{kq4<gJbT*TyCfe+N=+qZa(>t8dj$zPI~(;A_l1X1+zM%|2mKEbRG`6N&>J
znA^)FP++*<%|2Qg!P0^(H{9CD-A;Pt_%sAdi?kLj@L`3EzPcE}8k1^C3BbPgj!jHO
zuypoXDUq^dLpx4vi|l|--U!_eUaZ`4Ad=N+wLTR@pjp8`uFU%cf~8ZJ!RpK%7+M`%
zH5zYjB9o-m+}Glz!>T#5N@3S1sy}bN%4)4%U*ML5DurEhub3>V9vPyO+igX#^spO&
zT;ll|%kCmrI&bSBmsl=u^Dtnt<_<BR66)wC+bnA51tcq-wRMom?%Fi>7=op<mci;K
z`^d}ZTObwCS<Aa06yut`Y<5p1E1k6rR5z}&wfA&Hutq9K%LV-5u%;U~Ay|66?TU=6
z=;5nfLA*7hI=r<;`{?mDecvC~!HSvNx_nybsvGUMSC6j%Ixt_XDuIG{+o9L1?;=<_
zZ@VI+&G@9_RHOoWyagN40>dXnB3bFYWuUszPWbI;MFdOdErZp0TYl;r*Fo}`MCPqE
z3`H9pRr&s?^9YwrU4hF4R$M~Tq^%K14P@?y@tv+F?zYR%-9X|RS?1U+gGIOtO3#_;
zl)T-bYu=Rllh-{5aBFKHP2Rakm)K)&<MNkSQ}FD0GeaGT-GJ^fw{f|+EDyKJ3Ch~t
zsQ2)CeeFEv0cbKbi#-bL?xz24L9k>Nhp}v&F;0P97LoA_f+h1<z-rQt`TUzG1WV>|
z7^@`e27K*IyB85`06Z3{sG@{-=bfFQdq|IY=9#->ED=*ckAJwdH<C2~4l__~!AiEf
znuKHxfWs_ZP-H#Q<*6eM9V7x9^H3jw?cqE6Y1sF{8P$On%q?85YDIRV2)sJ;-$4l0
zD6t=`X114yg)c;~<Om!V@;F$tF~{c3(<?O|^T0D#+Q;i@i}pgEAB*VU3wX?zpt`8+
zz=x5HcSnJapy<E;@?D%G`AG9csDAjWsonKXD+N5ddF+`#s>X}C59Mlta03X%OdEPA
z{-tNDLx6AQOHf^T>uXDQ_SDbUk(~uVVg{<|piG%ryYwX5Ty9lqtghMAErT`#acP}g
z;tPWiCa%V|dOaQ;4wj78$z{X31619lp>_U=;RrVX7PDRwJp}(W{)G#G#<V^zpS-Ga
z`(_WRhNKN30yAlKW5{3nat^``AOv$<ZPmW+w5z;+#OyIoAae=PH6)bD%Obp1$=rCf
z*m-1W0kD{D05oFUif-`*ATh10E0pJXtn3)3#Gn?*m6z*{Tpsfsra}=MRD1pE-xpX7
z;;=Et(+I4sTDR%dJ_Z_~wQ&gzfDP*pl?IDJ>Ks^#5VYnk3sm2$HEuFx4^S(uXG?%;
z6_zRaaw5>n8};g2DP~gY@)vo%W+enl<1Jr)#w``}WUrb}02f2+)8a1=Ewyp+d#CmO
z9uKWW%R<#mb<o#M+aO74Ocjy>i@MYF(Nu&=OPVcIU8^nnclZLmKP}t}RL!OyY0+@E
z;|8Ua*|_>DRZ-K*`)$h}1X`f=V_EA347S=2EzTiSTFz`~LD%im$&Z%<G%z<}+1!Gs
zZ-16(^cL^|aa6*BGqS65+7?1`8W+qbCotE(rGk<XC@scD<MXjw{eHQNUY@qe<)E6e
zCKt&w3CT$%tEe2PzUs5Ftv4c2Dpwh(ZcZbLUK@r$sZ@oBZA&Xx3k7+xag`jd@)l-x
z(}I>(biR=5QLs|PhN)<j03BNKN+0n4=BZz{nZg6Sl#qkZAy8UE%;f}UA#LY;G!(r&
zm7}b<p;}Z>-6NNfoK%jAdWi};dc){b2-LXxK8*r1ZC5E994mN;T~pEQBUq47)?N2y
zD$*#GrQmq&kIfbSMlVn0C_G#n68-Fc1WM&7JX(9M!V|vDpcGGyPS2mCT2Eu_?hNp?
zg~wc*wpSmV*M-$;ISRbKd1#jlsb`bRmp;}Kfl?{T<kX$%o^SdsL!eZO!jrluhi5MV
zR!VG>ie_DnS}xfuJ<kRtCzYb?*h|;w#Vf5}MW9BDvX=>-rM1lS{SNf<REo0Asp_BB
z-)I|;<fKwm>~~er8q;5y4RSs6m6zh>`IH6jpH$R;f)*bEan$(o4oBH4u{g?*m7VmJ
zuZDa8q$M^*iJ1`0_*H46KHHw5w=;W)T~R(%7X7@6yleL^84Icu2{f{DEx>KsPs{)O
z3Rr@9-j-N23s&RS>~nJ#Az5iL)dB_4|MIu(79v?`l(k?rD(w2>onlB<8f9%z-4is+
z*;N(68tqonEAXymy1e%RD6pBQYq_w{3_ky7-)9Jy7G8xG#38N9hvbL87zx;G^fUhK
z)jyf6o3-F|ATO~w%8^%(UO_t!`&zlA>XLbimQTNMZ<#WB?!Ult6Y1myyUP_lH^%`J
zBlbpd9k5nO-EzY({ZatI(#Z=uFrWK3Zaz{0oxEU=IpWrJbncx<CokM({yl2TIHUqP
zdEq`Y`DX5?5v-97KI4Kr%^QPG4M3Wua~BlFm*?K~5FoA*)1SEd*=*_4^+DsAhu9m%
zjTUYU?*-=+2Ra~jM_I61Xn1;iJ<!nSF^{^E)(h0cb~Mib?S~%oq$?R#cU>jU%|8gN
z%RK7J2MafdZ`OD;7-^QyTd+m^qTx-@gz6#oM)Bo>o5Tit7lD>pkNKKNNd+M9$T<EU
z=tcG<(RnM{3Dns5OXnM)bJ}AbZY4<zQiPZb<-}EvoW1U*)|}V+Ggm*)nw&WH9o@bX
zh;31P&EVE9WbXBe2$ohMwqV(xs&W^W+43oZrAJ)27rXJ$=7I>8w!5{Y1ukLW=wIq0
zSbEH5J2KrR3>!JC41y(cmkmyX$>JB&_gvOpLW21oNXu{qthQ(P_VhiFb|et{p%`nK
ztiTR7T<;00&<W=2A0=6}z)+z1a*!V+n5S9Ept{YzxvNt>{Up}Bcl0rrDZ##COW8aY
zA9M9vJzY*9c0>u~LQD8%zqgmZiB2$2wQ>~!PNcU~d38IImdIUh3eXnne{}o~!X=W|
z#?@(dVfFTWNDD;vTDY2#Wv)B=B$74&^1_eeihlm#QNUheGZeQ4uovn6?G&)%PoRyp
z3bjB1dkcJ>cRiAo7<q-Pnqt>9Is>-m3FaFfeMT#78aQ9A@gZOSP(o~>mAGp(T5Cuw
zyWu!CHf2@rH`V(nZ#RrS4174T4~lCRZW=yrb+t3lEU^#Dg4KL@r*mDuLb4il;L|KT
zN;;AG@C^h@=PlebEQ@{;bhReX=2!`v1;<IR=M-s(WTmqf9w-(1qf0h|C2n+u6@Ucc
zK*idXkrfa(x(pU1_XBT!*&fMCCoN3wZ;YItj$n;jQlD|bGobq){Pc;w(KXjU{e!Na
zE-y@b^EeQf*!;u^1~&~Mm%sWM!4lJD3sw(dPfT206v5J&3zPd*N9UXe_C*_7B`5|?
zZhi?n^B9tq9&X{;&BhNs6OgQQ=7NKk23w}gN3zm+3y)g9h&lZcf~E5o?iX5K+w_4x
zG9`gFriw3@x(j=%{^Q?(9ELWRN&t$xqO>N6vu6^0n?`AmYqS6#X)`mypo`j_SIz{|
z5?i47>kDbMKFAR*_U}WuWX?X|i>+MEb}ax_Kx~5&@}e)Rk{_=-3&E1ZE&mXV1si1#
z5;=CaNB?vnA<npHj{g=Pf{7+xX)ogDUzg_H`;w1t;|+3d={_OO$X`C->Iloe4z)XY
zxJ}f-*nBB-)FkX?y`kW^A%Ql9%Ccj=CDC;9enk00$TG-07CLcs?dqb+tH*cfW5g27
z6R0Fzbco8^J!D2<<+kZv|K`nyjDsA7`L|oTBC;ZXcuMbVG~c1)5L$f4$0#lCbx{m&
z=69F20LM=3m=ZK$3BLk*bK>2HfgXrGQx2%+*xvoMR~H0Jj>GuVxT6)i96_)FP+FwW
ziV}YHetZhS20&?%?JBUJoXEQ$!5W$DdJ2(2DzHCno{8Kgv42V|naCg&*q?XyLhh0{
zb;^d-^T*d$-rbIrK+dAWcmk<;oGbf|KZ;-j;P2yrzlF9HN^&l0kOHzX%~AQwN6{(z
zU9+x6HlQ!Dn@Z@HeIKWQ9@<#F1W*I9pUMH%=)39k+QtYr0QxdnwMDDep~PkV=EDTy
z>?upydb|e)`rhhG-=6`35V5(+L1%v}I?i6dV-La&fX4g_L=AVx=2iU>uF=?B_W-}T
zYuEW_a3@-V`MyIJw|)q3;n6BiAB~vY+KFybYT^li%k_D2+bYK^YMxiF%p`|;GI#)t
zt{>7rbx0`Fw3@#^>m5DbX=jpXZA?!bT64|tsH}~=PCfiVJFtf4Qz}W<=rg=>(|&#(
zlw!>_bU$3xTRgw4(+f!20B8+AYx_3;up+=+n2Qgtv|=kOEW*wH=H;E#ox2M@H&wET
z1Y=mXvcDF4!&<dp)sbbw?O8qY9W@uOx2>wLv0X+d(z;(}YEEbb_Zq6Pr8l_S1!<Yc
zYXOWp2&eSB@jbE$qZM0P7P$J&Qu)6a4=$=qpmt&jR9^8`weUga!<k46L^@lzK)Yuv
zS7Kj|SktW~DjQvpLS-~CV_S=+hk=5r%~(QY{qCG24<F11ilDY)S*Sq4qfU2TfN+Uq
zws3)hi<~&#uQF3G|4F<cwqscv7#5eT(e=(Oe{RnTyQjCl{u9?WcO3F_Xzbn@^az`5
z?cAZ~`i!nYrH>#~BddkaV5r{o8aisxrwh*n`%rU#mV-Jc_%l9<+d+1}x1N9a%a=e_
zm`EeF7awfTo&TusN-$ZqMv@3m!9lenk?4URr6W0MbmoxYSnTkLSKb9RYa^z^WwzU3
zQCZKdR{#BXdmt>aIZFtu=MZU&e!c{}1F<!WflAdLcm1R8CwJCAuS_8JW(ibnt#;*}
z^aqlZwo4Y6V6mD_Ik5+!8u{uNl_(skVIpzd%p~;wM!veJTADh$+-uE{q_hAm-XG+U
zVJFugL`FqrDr~5&z4ql-^=~2)h%H%Obc8)_*vYL(P9v*qjlyQyTfuX#a3{-uZqzkL
zMjunzflYD<`d&BR-HEq!aTAH{SX=`<2UGSEC9b8fL7=oswHF^XPij=Ru)bD_#NkvN
zRAXv`ZO>0ba#EQJ&x4cyzE=%_Qi%%NC$AR&b0B(oDo?@r>a4D_;*gwFn!?l7(ucn(
zfIz7%g=eeh`nM~AUY;6HSpiG6(5H882OS}a#MUb>K2#lXb8a1dn`_QA9hUN{6{D#>
z335l1nd5*~iG5c>TAidzYFx-bpj48=liIgVHCqRk%6yBU?ft+xZJ}|mk3@1(NeWMC
zPZU4-7Xqb{6dtE`S}^ed0;Q4^9;Rj`c6mhK+$R$Itayrs6QA@aDk52lL=~`_KRq)y
zCKr;GNK^p|QlGA6QezM-F{E0sIsy6}jccoKWz8ScD0D?pHT^5k34L>zNbI%}iw0Ni
z!;|ln*Hf!RV!M@%t1a8^)aQ00X=z(o8x^cu^XtKXB3vSK`MSZRb@9^pAxH~E@>;lB
zNO<&aq2@?hB71FAy&ZS%u;+&&Tw<KHadq?E9$RYzU<K_4L2>>KQ{vIjRtW))fjDo9
z8w2R;yi%d`TS!(qgJGUoy3hN)^bM@JRN^q0U+RQD>isMK{i8r!V$&7Z0c@5G`K&t_
zWR*yqIc33W<ZZoV=GRD8I(cEU<iW7*zav;WcVTjTtV|j>*-E5c5-5xorpFC0zjq86
zEphe~*DOeohpr87i&Q`-E=-Z{B|i5ef~7}Zm?Sry^)MJjkVtI0vQ(h?#Q#-&{t%Lt
z&Rf`hIC<U(a2a5t(SQ5%mPH(8-x>OGp|e0-V&|2u1Kra$-#e@jf+c3k%(`H%+#sab
zBfw~heOFvskS$-xEL9H4O6M)imlL{u0Zz{oiCtHgteSNt{Ly4Cl9e8DVH&<6r}Y02
zES<M75#Ka1<5dJp<Snbfz?3edOO^*&0WoJ5uv$=<wxrE6BrB1(0u<DBe!6#UEQq(p
z^-_4N9mV&kH0phjA`x4wSh4T{)!iO5yUzlNBC)&5#?_R2U~{pxNLpgVwWI~<^0U#6
zCm>uRb!}YTeJxm8A|Jvvx?5{cZsCH8Y{4<*ssJO4H=2VF7bc)*a*7uQgdp};@kIj(
z==)V(LR&~;ca;SSmaN)G)zOAGo=#qv*T$^f)d*>pPG6XRHtM~9BcQL*FDmrat_>bJ
zrVSWZlt^r?;>rcJ*#%{mrT`rfTdOQkuwsuc>F_OrrIQyXpp_0!{|6W?v9*dz3lh)`
z`IA8JULvuh$^r!{NSN5?4pIS~w=e-My|NydsGI09nwQTVfI4mZo8Bjptn{D@6VMA4
zlLsSMI&T@Q?rC2g*=!zyrSldhie0X>Uk2*RMjiO`maAFGms1}N0W&}oiS1L|z(58X
zdb-ABpaf#?lm!Z`_J1jZzCf^a;<Ch6U$T46Ujn^TiNxM1OInuRs^<$sw^y%+q@~AP
zn1j}B(+P}mPc%2U3y$&bJk;5=`qwS9oYO_OUm-Dp##|dUTyz+ydiXu};-eq~OEB85
zPhiyIHFamZiwKoQ-~QeVsD>X44$44kpt09R4HwffRW-cZ{!d>kx^#YPl-HlZUWLB*
zN(}ZDu%&e~9}8Q`Won2P;)b)6QB~r`vp+rtRBS%X@?oQe+d28mMNY|GmY7E3%)ab?
zciw(12HL6;7rvHMRqt+2G*<(K#4>hjzw9&>J$lT@Cz0edLd)oxnHDxTHS3e_spCu3
z=6$_fdRZ&RfGpaZLc?l3^Z)c&-e398<Vp;f|736ixwBhmrKNj^go-Y*@DOpcyZDC8
z9#!hT!GZ4AZ&hIrsHQx`Nb@~S!;3^d(_+txgRPtIIneQNN>JN(g6}oq&04{p^}*T~
zR7GpYmdec@!hiDH7@6c%xYIs9sEGcJVq&6^>|XwHUIep31#o?>MvsBy+KA^+oS8^+
z2>5Q{#~$sUD#+fJ|D-oIH&a=HMk`_-*mm-B@ZRP&DhrMUW(DxQrA@CQKqIAXK&=?C
zX>CFrdST->*aB1+`u6(TYmj_K;@WVwe6Fp(G;gFB%FMl^ydY+_wrjn%J#U9TSU?-k
z&})SkTnnCPo@6DY<UW!0d}<Sf4}>Sw15V34$jXP>AS9ZZrTaOYtA>wPA3DeX#qnh|
z7@4@oQNyZ^JL5cUR^?v(srWe1h5mPR`*iLP`DdOow2?~^bZD#nb(*(dHTIy|cfKTg
z`yJ;a3O5v+>E!TK9QXR^gj-ioP@l}WjxC3ezN&ZAC7GM4gubIgs)J_AGKtw23Nw8E
zbCr=~zV6S)WZ%##jE#J4WjI2lF_sVMSDnh}5r2G!-kU~QKBQgur#FvpFNCC|@m36|
zSKhnwKSv56DUHOnHOam))ST5j*J@Tnn8xU8V<OhZd>y>Wi6ruh8-uBh*?>6$W}uF+
zF0Y1GTY8Ka0{LE21}0Lr-Of5~cE-i#T4V9mHT%l>XYMY<F!@i$HS$#mtcR49-Gjd4
zQuCigQR8uoN>O&atC+x)uGPN-%Vln)awKKOuhMB;rRp^ircqoUCM*3Ya_;}4Nxb8v
zB#oNesC<|W#1{ZCqiES9?>k_*%vbtZ;2H<&JzDr@eXEdUzRb_TvkpcS74&XWBOIxf
z##XlZ0Dfx9#O-U5q%^j2Oi}z(Bt5@$XEQy@CYgs;`QG2z)#wI0@c7kM`lcqye1)Hc
zEuuGb2zp=Pk?Lz2IYg7qj7VIjj|L%p_r$<e3x4DJTbG^XlQ?XQF&2kYGkWUT%*Vx_
z+74FF+*IY$#qi-eYVm7-E&|@x+)`zsdb6@~LWPFI6tj4*$zN~kCE=tPqY5lw@qv(b
z_B3%yl^^xGQj+-|KM52R*Mf5o1RwS%nP*tZuzGRr(*N?*Kr2S$u-KQg#6VT-(uvDU
z7hs`*|0Jt5-{L2PwcNKG6i-Dzv5gxlUn&{R7;Qzexijx0L+2!^IcDFX-?Vd#U&b^B
zT1!G!Rb{?LF{i<$?@k9^+k9o8g{ke^&Q6~5nqx^4L5(S!MbONwkjm-2P9mgqwVB$f
zr07)Ut1i8{xpT_WCfg6R&ZljTroOvsI4~n~-<0#}{PQPGp{ZYdn}kql{NybSC?V`q
zsZtI?HR{zTt2kLu7Jt{|>tOI^lDTclhiYx))ZAsoxCO;Q05JDWNw{{`y2`5tL;p_J
zzaCC9U)<-jg#Rs1*~w<=<QaG?CVQhYKc;+kude_bVvVe|1lNpV`uOiRqh%v9mPJC*
zMW-y=rm~M@^RK7<zo1Ss&#iK#Wbu{XZp`AVD84E1#U7s1P(K$kPwMtjnD;-jYL-?v
zm^Sav7lAg+eN;ZVkq4XH|IuLm+km7vTB7XD$O+ZL;g;YPkAWC#ZlMx_ifIM<*-hTN
zxppBrX%yz?0Jfa2Tm0<Y{r=q9^4*u@7R~Kb78&;J&6QHU$&%%2oH^MkyDQixm}gaq
z*XOHm?-fObSFx@JKV2w^bW2N?MVUk&VNv_yk99%pjwA54dPsztWDbrR+YF%*Sj*5<
zXE^O*YGvS4;t1I=N7Ewg!O2zoId&vPSYz^I(G%sWe~<lbAdt}9C*@_Or3j}W;BMU8
zUQXEq@)UD_6vvC^u0zK>J9+mdgh>di95XT!+=0CA!!`fYYq&}A1V(a97Eu-3e({+K
zPlMu8JfXP60r?aT1+m<V9fHwo8&}&>CA<cEPvfaCBTNDVt6MeO&fYGHoOLR%Eu=St
zC7BzcxSZ(^-tA1v^cDk|gt-%n<Mv9k_fX;7pu!Z9!+u-yetzaS`A>45@g!cV>vU~a
zdtZ~CL`tJdtw{>Z;@Mp!kx!&%2^n1nzcwaxHa95FcS%Nb3lwwk?RVx)?NK#S$#A}I
zTjf2+d&r1{XvxaRyiTP#q!*`+F9xjML!zdapD?J}JT>hmxa~K|-1fv*-5cV~kd78y
zx3p(ty#@LSP?EXtNub)V?XJ!Ia@!+0jg%dp$4E`FHf&1*&TDdg*zO9*kj%|awum8Y
zB$ZzHTzY!Ne)Qs`=%~Bms;7&+0Q`q}UX&1$<+R+vD`f0hyju-~Nh2f6;Q+y_c3SeJ
zQ-YB=X?$y$lMQ^Nl<cVJr$2y2GPgJJ_wSdMf$KV-Rvp&>Xu#ax#8IuZNXuhazfh|S
z!Xz>C0jbuuoEa}W8+^%um^+);1cngaAj5nJsJ_fuw*46dO9-6|mf1Xm1r?}Uzoqy(
zWMpZLBo)%~-8hu?{FTj9khDgB?}LS(F(p@6QU>J4=C&pamQf4zDBmBj>Qj)-nnyu#
zP%SsEGokrZkSit-h|17(-?Zu6+0srWS|X`2)%GW8+ng+KMz2sc#4lZTcn^4Wb0?E{
zb=60eyt#1#cy)8{l7*%f2Tt~=Q5vka`AcDr$BBf>PsMM%nIFV=bGwoQs-Hyd|LA^I
z1WBSMmy;E=6n7uDpxYh<Nuni()MsXvFHrLc*tD95IXN$GO>?xr4OZkG@mypjuv0M4
zbK>CQ0A2yCT<Ka#;F%MRc5eZ)5192ltjzJ(pF&C{QIl_H^kU|j-rd4^0~Y^D>@*_!
z*vX3l{M1F1n;P&moE4qe0xIfgwBt%8AiBAI!cqsSZ7!VIrUTG0r6Y+i8BC<cAAhtS
z!X(7gT4MGldvn!Cg`Sw+40r+aeS7@X+2~5%Y^eqQJ1@k30a6rm4Nrh(Wu*@7%<N0u
z<TWi{FahL|NhH=fuHQ|d{~CO(6Mu6qs1%#c%}IOO9c<Gymeusv=1Wm)S6^H_aRa@%
zG3(=R&eI5MpqH>uSJYE;8}CA*8tLkYx@wIhstek-#FO#dnmDlh{zi5=ps(f8&NTi=
zi`yT{@c7S1Si&uM7GY~!_27_<%$$(4jGoyYy*a%@#Oyz-SyQ#$>Z9iL(hPz<Eh;i+
zNKX59g@W?TJ`<eAe}je;4$77HPOhM!yj%f7*;+tM|E%v;%?mI%!roMbLhfr7$5P<u
zLwXYdgCsFFT^yD&uc*FvondE3Xq;uJgu+oRak7nWqZsw$!N0V61Op|7SvA1^`A^k1
zHBZIBNK|#o?TRi7J%4H%S{_o;%cli7F2LPN^=!}_t~iOU0#Y-gZp}CDL{b{5%5Bn~
zz@)r*Or5aV2+~MYAEYMb<jG%VI~xdzr$$S6cq*5RTy<6o?wbktNa;gD3B{Dry(ehC
zG$G1-f1Y@6%a=Mih3od#-Fas!H%&jc&rpq&<Zh3*b{@>#R`vQbC%u~mR*2GjBwpN?
zqPk*U8{bA$IsCjc6VpgXpO{WNu8Y|{<LQ}N7-5)3RyvrgRy$$DUG(hC`wh^d(`cz#
z<`b8r2Lj(lX**)7WceMdz-cAI&YMs7N1!xPGElMMQE1t7cBc{ultxRjS=K#L>dJGz
zLbgOqqj5^aL^Y#v`>wtXs6=Tpva~8y@?Cq17}%ttmO&&$nVXC(dx}i~8ASHL-xEOO
zp!63pNm(Th#LKMKFYD(bOiog~<e1uwhxaZlTZg1HvQxMwTrZq7cv(k;X=EqIbUuPp
zY&2m+NM(dcA}2rd1$E6)$49I{n53ZjfJ)(o4e#kQwb%+#2<j{Aft61Pxv5X7Vz?BJ
z`fz~`lJ_rP>+JR=ni>ttkERc(8vT&CcRA3nx!H)>0h2kJr=e=b_+I4$V*vjty+#%$
z{PO<!ABxV?PTdlsVvXL)l9ZP>#kT>fwEw=<s2!5ls9qNre0tw_Qi&T{5rs)h;Vi2i
z>Q#g5MWZHz$VX{2VoKEx>ZkT!UIEER;VOsIqTbnpi7gQzg{U0Rj?J#WuYILRI!|+W
z=IGloG7TD8%KW{!JZxMWD|2!oCp5457dLhuNM%SPK^@3^DdW{_tYYak>p^mBTxW}%
z>;fO@EY!_&3N2cpx4<PtQM!k$Jv}QL>hb<=z73B!jzoHYO81b1D%urTbER$o`=S?x
zgA9ezN5sHICxo6qN6o*ul52$<f-JF-oYsovEuoq~$&Q1ffC*5#h`3ed<-_$=%zn+s
z{h%FOv&AyTQd`JJv`;k4zt`$}q)Qq*qxmtjzWRT>*yvlWq|d~pG1S3x*>w7yxQ5(u
zDg-6mY{v=8YFfEd*e9y0GHVqYzJ$NJib~@sM{Vn@kV~hq;gM6E*daww;{r(}MTzd<
z6(5}hp@Y&(#7v%Pl%L~ij&IuUQNIGcnmdYwIq_PdyK{0^EB^c3U3m{>d4DFw8^foB
z%DODt+zlQd+#w{F+G-Iu?SDI*qb-T3l=dQ96)fquYEU2pnwjt5cwoAeUL%gKskq+h
zx#38~MuV`G5u1X_u_HcPyWQy}m32U4Et8TtZGJSN2mfa4bG_sQ85x;KT~XQt<@ocZ
zGW2_#6QU>$M_jE|#ZYhl{6EUBI#8>k>C-5sAe~oA>H@d#MYuFl(jg&m>5G(<fI*iE
zl2QWFAPoW{B}z(nswf~J5=tl_@XhR=^PI!ZJnzo;$MdT1AHO?ic4}vTI~zGPo<58W
zuvQmV6_sNI6gDJZ%x{bnTea&r@$<AJFE(T@+iwQr#CF<|l2%=?fTc65$_XbnE+?n4
zF{SOJmlUem;XLr~fWS>4-}*~fN3c-N3j@Y(?VF27Z!&Ep3GYZ@;t`?&xwOEUtb`l|
zA8jp$^haY^VIZ#TnSUJP_;%irMkH10`jYGRGKp2fIl_;Ih#lbbc%e1Jt$F#GXkve@
zPDK;!@_Et3L)|g7X$Xpn$o@5#)xWBDn2H>k{E%hc&zwGGuIU!(p7Z1wSF65TQTh_A
zH7-5plh18UJp~N@;#qN~RI^i$9JNLyb*ps`Gk@KU^O>cx6OTMhrU2~I`ov>qs}dv2
zt#BWBh_hAk6kF=86up?JBw`-vCYmDM81D2<mWZT``P-kP)9wTrilOaZU7flxlbq}W
zm7W77uDU(v*L9iBgngn?02T&o8Q=fIrsidsm?z>K>4qO^b`-rf{~b=HRyS2*VkZsi
zKr?&n3fujeo9cYNFCrd6drl8$VvfqgzRq-tumodDTV?gTD_012ZeD#0qXZH6NXyG8
zq4L|eXEKW=q9AEd(n;NPFnc^Fr`1vQVquGtF4ns@vJU1zt$S1j8l*>Av)Pg1O#NV=
z?~KWw5ZPvaTCOM)_G7K}u0nISeqMBXaDDjz4$oSPX*_ZclXcwM2i(_M^N7MTi-!Cm
z+s-nPL&7&w1V}H(dtaPn$ssx}4LnDXI5nm&AB=c(@w-h0TtD}vPb;YQN8IJJ-J?6Z
zVh=E$BVib6VJV4i`1qld-N@mKND_vThQzInVyzk~I34lI6DHBwUysA3hdm9FmuNGp
zNt(u08K0C8jWlXJ(?FSeyZXn>{!T(P0;(!(?9?51j%-xr?74^Bf{FZ7vDrxaY*X{X
zRK^MHgd@~z5K36Z59h^kVv5`puKX}poeIVutH+6HO-WizY#NYg(sRVZwwy^>-3l>-
zu2HLhH@@k5faj}rx`E$Ux!hUwgYTQt&PkYrS5!QtU5~zSzK7R`VRj@pbMNN9M*q=c
zgD?rri1XIW`;XC)hB09hijjiD&`K9<+mBzJrFIo2p%`gYsLhP9GOOiZ6{uZ>NeD&`
zB*h%OeAjYLmm)8vUp;j4CwZxvhLsj2QGipCkF>Vhd^YDIMm|LL0(DqvtB=ACr%CmQ
zi2AG7Q`*JKOz+b-lVI6JUaA{9O#3O>n#^f91&I7KX!j{(ceS<dcEsnWLbegaeKw^g
z`>@K3xQ)c0Ppx+M$C&cJ@8)&Q@%}EFtHLDAqvD!i$LO{~^c%l(pn^)*0R;;)w<S48
zb*(~Kdtnmh5oOxH+I#e6#_8>xBh)DVXj$52@Y*gMq{u<>bxT@EY(5*afbn_z({V~l
zl9h*-s=@iZgm45O?X;gr!mBcNL?>>sMed2H-0-;b^S-*mM9?sicOocWLpGvv+-q~L
zxMQAtzG*c|okO*6KG!Ys3iKOk^EPF4AR!%T&2kmrsV$4{F{^Lq9I4eO>(p^g*E5`q
z*6(-V(C7(h`FkfaF-9-p8^MP|8li2Hi2TKNF-tEQWdx8&i=w;awsA%KaF{aR<Vj4A
zR-Q`khI(I6mP|1!9?~@-*wm?h-}Y$2<R$y7aJWo(=TVuf89Zw(Df&650FjdhVO(8J
zTWutVDe}=Ey{ButDh1}`_<Ypb&G7jsSLXh)e0*BE#SfDZjY4TdWA3J#HE9DPOhPdN
zG@3a!y#MzAPC9{S0-hP>W*o>@iIdK%L(D-86=rUZ2cvMAF?RUu+)gHfnodv4O-4=v
z8Z@6&k_j6UK9R~6Nc=LQdz-J`%)vnl3R(?Ghd6eh`bRv*c>MXl+*-}5x2hQ#e=pMI
zKTbx07Xr%*0BMQvN&nVIIT-~`h>&it#XF=pGbXAR&h5<wKc5F$Pth9ItXZN#gX)J4
z7q4;PK=CH^lJ)M^Ez93z)aa8T?S?QakZ_AoUiG|&vGQS^&IZP`_?AgREYgrvt0}(^
zp_c|@!X$K}&|ufkmL}9q!Gz05kzXdX?ak%2{txnTA=pkRLJLJq_;fQ>+$om67*lrG
z2}OuWgWKB+(~V)uj!2PT0vv1gLn{`hV_;!@M4qWYX#n{l`MjE(pd#l)Os+o4-8kv%
zoVknK6G6d34Rc>w>(}B1z&Y{fb5Lt3qf=zN9^LySBzEuZ+&?R?TTXCQl-73nkG)Ud
zmyZdP5R8-|_{bz)c=@K_ydg|B5%G%}BfW^3<#8)=$603O?Cc`PVnI+E0<L~mlHL}D
zuNS#1uAF-R#aO#pb-x(M_?Co9#GR-{jQrvV8BYf?T5Umncw+bVHM+O&(BJ9c^?1jO
z1fOoHR*ciD$aRAa|J;2hbpo@Em&`A6la;scx|b*BXD0heI79%(WauW(a?<B*L8Bsn
zO~lLcY#2CL@Ng@)&Fb@6t0E1b<-0?BbH#s7i7#Oi4iPGWq0;2)J@^)rswDg&7m+j{
z+V}c^xt|dxVG$uF_Sy+%gTW2k(KC@S35y6Z@$zku2}X;`bnnGDs)S4g$VAYjEt|jO
zwjO*XiiAm|;NbKk=s27GO*5oqyi~#}(%4*0wZHYV{M`485-ervq+h>EO>ojil{-nt
z#I7A$$An1+8G($@CV&G>GY@V}m|vdzZkekBrs}*H0s8Q<EHAhb)#s?z&!&#bZA0(0
zIWdE28Q4ih7_U(cSg+E3%FKUW_?6Lwomb?+((J#k()x-_RI$^F6ezSz2wA1)wK<_o
zRFSZX;OqIu&gODC3vg0ew=1rcgr!mYO6JGh8i{gh@V3qiZNK=4`*>>#KtY2vVD6v0
z^9zS*wN@7sOv=ppS9)jP#9@l6VC4Qllr}N{`@Y%;4pZc*K`1H(6INf$0~Ij-e2!`r
zlXKJ{P2GE2uU}=vmhg%~ojGB|x;nnGyem_%NN7dS(PnNwr90j8GAE><cLacHU=GPv
z<x^%{%D8}JvXR0BYKS_>He&0hob{N?{b3ST5y0YZm4uWRrj9SoL_P_%$bn=wz^Se@
zKE<@-B=d~`G|~9#*`MZ5%0wv1KqEwhYlCLuTbA{|UzrA<gkgk;WVtWjDz($)7Wj%2
z3A;$+;f)_|!9$XsOJJ&AtJ`ZI4U9$MtKQwcyRBigAfXwd)Z`>%eVvqN7)O$Dj5HqB
z6UN#%uij^?%dqlkRzfdwFhR4-lXCSZzQS$HBm^VG<<B#o)JU<C6IPH)0W^5#+t4HH
z1m-|PGRp{Y;Y0&9VCIx^$KP1NG*%=GBS7`d`1UrF!!LBK&jb_6V`~5zWQb#*s?m>_
zSQ=+dR5&07ld0ZMnx9|h{U$9rSgUVoSXKQpnYvW738!fJYd^-M9?O-#;pJvEr$UEI
z$VQ+G2wbQOT3%#owX8FZ1mO~vQ7P`S^T*HXy-VYNxP)c|cxJTz`J0R*IOzm^BtWCl
zdfiWhPjYwyH$^-W_ZGaH`DbeN;gb19>arL#QD9Asz_%~+h;baKpxO<95=p;1mU$2j
zB;j^)5!yVGHDMD;MXh+}+f$sVA_qlOu6dZ_N@8*jROFrr3XLT4{pk*DPD@K(I~{;?
z&LAakiL$SEV^l058fg_{GszL$>-n~MknKLUX`Xv&GA7*4F@h7srug0_u)-RCn<jAg
z#S7UfLl->a<P}uET3)<SLKMBb&eMNs$rdhQ8o}nA>s6#o_rt$5TZK#LMu^BwU3|Ui
zrK7Z73Aax;LT}KQw8@8`Sv+wX-JOI>_(q6Hxf}_{w#IVbE!d%IK)N__KZM-mzFXw4
z>d1?3dLMtXi<zz$E@2ySv)1xwxV6b`OL}`#`&=LGsL+vwiZ{f2KEiXP+dCgAVmX?;
zS5Jo9^D{aU9-eqt{X8E^fBHgw#)s^21q}(}DcU<-rUx_TTxC|?t^^kqY~DyJpWkXk
zhhoNrOSned#MPFamak!Aw1j7*;Ml}>x#`m79H^jsq(QkO)T*_gROePmlud))XnrOC
zhr2mZMZOvAbf<j!idQ&Lk#`2W&iv-f8TQj7qj1S+BiD*NAG(wGw@=+s1U~1qmSdXV
zu=mXpH4aq|1$x8X%pAR8Q-eMindl@T8iA<l?hlE|h3e({opB`z-3T$^;sdGAsz-gi
zfrAv~O$AA$TrqPIGaN5G!m3zwcq-x13L7SK5{k-P+$uoJSj7)-<(rS*9*=1qVSUll
zPCCNq30In38k2`OVRD<vxY}s(enhKd1`z4AkVEDFY{__#<Y6?WN65mo$o=kV3^T4W
z+&<1oEe=`h#Ur+F<E&g%-a@Y6?znvs@y&jEncE(Xb<*sX(5GGJ4!wi$=i@J5Y0U&s
z3F!!Q3i7f$hpf-`S7ElZ65f$U#nWQ9z2_NKT+t(CaZU;nuzW^k=N@UJf;$xJ8si20
z)lIAKE75SZYqeg&zj)--=bSb~o*I;4+UKR&p^V*1s7R%Pc6ru6+S7v*Rg_Ng)I`<J
zX7glpVy?d!^OaDNO1bx&P0R(=UOUENin6IXH=$+e{kIFY<1j_Z6fq$VnsSzVzt~S4
zrpR@JoW*>*^Uut*&l_%CB;vYU(<my%i0zEP5*AXaU`@HYqc&}0%*sweLWW1E>dL`M
ztf|^FnO<(f^o=AmBtSL$M(0ab`Go27Nccy9MpMA>UA+o&(g_kO;3XQh_}KW@j&ssk
z*Ia3kru$hlzaB%I&*4$lOp18eFu|*Rf#+<!Sl9FXh^tIglCX^exa4)sGo5B}wTXmv
zq(R-=eO}O?`cAg<XyryFVdov~Z?w8Twn&c9aVyuW54em;<as8q{eFUWOC-kx$b$S4
z%=jD=CNavD5RbGT;B>=LuBVAQzg$&~BCOGU>CetRay7BKX+1?nUOn`PIW952c=qgW
zjp4@@l)YNu@@m6dhCS{2Zf4y<l;aaFAtOBxj@ux^-Oew1JdSD1Na#p-^_`Muo+UXz
zUptHmmk^Q^AlFH4HKJp4rev28kr2}}2G4z$eSPB|ng;&-3ns{_2noxDF#*`E@H&d2
z()<tFzs2Mg2_>nlI*ewnC?0w|>Nm=o3Xc{fS8ihF<;WiohrpNP&$m^zetZxI4$|{2
zRqsr0X4xd9BqcOhm(C8J57%vxaEgg$c0v;RF!rgKY1#8<XI;zaR>DUDF`X@pCt|sB
zn`dw$T8m&UVnqETw6I>gq;hxn^vq|ik^x5`qMeRAIeBNs86=~Q$~tdhz`j_~lFia3
zB7DzmCX!3W9l6l7d@Xxz-WaBBBbj$ZADzlpwrVsJ0VQv%`L|hKXz6|7-)0=3$X9V&
zY!+<21}~4y4W5cWpSN0zb>3UKQuwXuZH7{!M!1BKggSsnp<w+Xd9`nE#KO0R9XQN{
z00}DzfjI){<PQDvbC9A`i;%QNoOa{#w@d_((2_t((gXXb%lG}5O@M@sq~NeA0F|eq
z$`ykye8qT@gps6Cxd!lwXIY<dqKc|xTy)5-Gy~or*Y^)jpVs_>H8<_}mrRnpH}~aM
z2XNp*3Kw>(LC;HHXtKT^2P*SY#h7(tzXzJ4Ti5eUVQj_pJk`QYiYV~LM~u`GZj#b0
zHZO_27VmZJ2~)gE2ud2XJlX*Ge}1Uu^BZP6{@Yr4If-TN3VP;Z!0CFU8!#o7gr)=%
z14{|q%gj{8u3f&%VT!h~L6}bu=NJEzaW4r&scdjwe*e<hn{X->Ic+f7)Aru&I&q&b
z@>$gqqIvqCv+;j$m?Fmw(h_>MXu@a?)9Paw41!RpCZ;X&2Tic{qZQt5xda<^wNp!4
z6GTV|N<e&Inl29)4*G<K*a!(V2?5QnONNP48gcSTycFR`72LaAnlQ9{Y-4*BYlMCF
z5mdoz^yThj$;iuq*Y_VEP8;J9lJQ6I)!5Bp`|W3!{QM0EE9p6DST+q-yHIOAUU<fz
zUk4ID)v)EY#bRlN4>}s5b<(IMOWbVZ$CtQlIoQNPXDgv=SN)WA3H7|E850-B51K|J
zO@w4X66jm~1zH_+8aw9_CBa0LmUu9N!gD8vA}+o^`Sn*p$@udMWcx8@F#ip*pM4=T
z|GSLf5)PBn1`MDx1mE20SQ#43BJBJn2xh1X?&{{H<GGeF#%zC^&A}`WwGtSdDe9T1
zYRq7T2nlrwL}fYlbE_?8TBs2c?veuuwTx-9oi4Tio~GOg33~}agFMDs>hTu`XjeKy
z!e0VZ+B2V0az;G2NHW(&ZVWgtb*=gn&dlUKUXpN?n9y=@cOG6xqyK{gs^~;yU!1X%
zm{cqea<zKY*&nC6O--NAS`&`vvp{D;{&tH*^NrhA!Y;f;ce4?8GL!NERBjL-nA+s(
zFh;!+LX)<FkRHA0PNdT8^j|QxB_T8+Dmg>nvFu;w5Hdo-X3}^}SNGR0r_(a_YClBR
zDupth&5*@%M5c9(z-L+Z1HJ$(G-83$Rwkr<Vm~9c-u-k{Uncw7PbmV}uviceP;&Kt
zu7O{!PFylhB|;Yt_Ac!=r!FTjDOd7}8?K&$C6~jxHZHS{lU0^-gA%>|Ez_-RQ3wk7
z^ZBr~)9LxJ%dSv6N2iaZ&n(JNM=3d{<pxGI_BvgysN#TylC#y?-HR}zKO^kLg9plN
zCa0V|JC2@-Mo3<DgH<%^n}04JXiZyQ5fTOzqG8c%rt{2s?kr|PnSJ(>`s_q>3VaXV
z@QDF8o=s*#nVkrwQAuawX}XuVWF8@_ps_#2HNAEXc=99n?K02RsP2x(>-}UN*L^4V
z?XuiU@zNjL!!XbzB4j=bcvvVCjdsrT+Y00W;m_x?)+PsaS^ng<b&XW{n2J_Hh(c2Z
zscHYaZ?kV-V)D6!4&`75$>%3J)jGrYm7Nf!&6T@~-v97>hnN^8nZ<;%;srWd)9%}s
zu^SV<B@8G44N9!q+4I%B9IR~Hi?C`}YF6O6+NB@JX;tR5$gLvztLzV7G7}~vBvY9{
z0g41gwYsJ5-5cCe$s9Hav#Qasrvtc;mwBz~qnY}A``4r~`M_QA=W|)>D)BBGWN+K;
z%=|<~84@y-qhat}Q}VEknF}#pB?%h}@(c4?Xp*@V!<nv^gb0OzW)fU>_276;K5GG^
z@*mTc+dZ`9cO0NKygGoSmT%dwKn3oDt&6V#%|hbIKP&fg@(ElM^+(gm_=)A2dp!{n
z7L)=cAACOMlk-e&mN1|I5IcO_1m*EN*EHr(1zzc(a_1(qmo#7L_TPMtX;micm|oY|
z+jv)7ccL&lC5rCb9@%M7u<>4xP1Kb2AD%U-N(VE%xtekbBJ4CMWm2eNkNm=vfVl_G
zoJ<dsA|%t8995TB+j`j3x#s36B;xI@QJg}o4(lqUF~k3;QFzT`#yBJtD3Dk+IT<|^
zoPPNp(=3$mpcE?Ya<06&cLP&eNmx({kz-cnC=&T4ldkM<yeVT~ZzTQ`JM{o1lSD}9
zPfAR8N6$<rSd^(HGwCZr!h%xJ-pw}*f=QBe=@HqqMSQY_h2h`v=W}A~UchtW-hC2!
z_37O-u}^1j^dYnjm<{Z@_;R<HBr73Af&AD*Wwx5Xw;H~KSwcG{N-ZJVm|fL+A@g>4
zgoF_VazZPnNLYywQpC-?bE6BhL6S^q0#w>V?YqAN=eH74l*U7T8A(77rVK2@Nh!;?
zv>O-t;i71!$d(YGP)gVkv7O%RjdpBdf|i5=<-n>b>1zM(#n){MyQ<NYM#8akp;UZ@
zXEu^D38&DVP3xFmh~(8b5Y;SU9$nZ_h2B-S-#23YmEXg@P;btMOrVvpp-^D<R3>)#
z!dMQ|`hJJ<QvN2}`%SN`Vj^v<wTJFtI=f<ZC~h=z3Ph$}!elQABTA_NSXKt&!Hc8A
z8NZT{q7acZGFGk3yPWYW2^~t~@kha%7G507glNf#CJ)y9_6$=-K4fYl$)qL+G*A<P
z#TttJazu`{oMHvrSOg~l@OatY2bjnr8QP@rFkq3J4Y3*4uFeZ77Jt4pYc0Toxvf_&
zd#U{2E-msfl1s=@j^y0n#yY*HlyvVP`HFA}JIX=zMj=D`Hde1*rY)zL6A;NDrvSQg
zVCKkn&9G{9IDJ^FWgQ<N^}vl!VjtC}9lgwWh~&9Alo&c(fLYW~!`cZYhcVtPAxZ&g
z&{ov8*+YhNvRb!jN&`WLBUUbavk(VrEg1u#Osk~JwX&ZxRh(p+6DWY~8@25BSpm+p
ztUjmYL`I*t(K9<Ijq~JF_meTDrA?CC8M|t2bG(WLtiD%eTEO(Ln*Ze<*LeZL-Z$0(
z!dHXyIlX3li$QeJA|(VY(68o=k+Y+HHH&7Zp*K=O!ix7uQ(gdTzCJbwC!`>u$7^;|
zz+b(ZE@g|B^AYs<nl4hr#A>K6fCY$H9%$Z;TbJY7Bd`|~Bke>iC=@klYVvf)C*x0?
zq%IICnHQzMo}L`6IyAZ%jewDox9Bt^ti8*!@IHQE;tyT9kGBQ@_v4u+#An~X*o~G5
zkrJj=JoF&S>mzDN0?HqZ=o&M!V_sS)MoJi0&x6x!u>9DT_Vhf-el)|mEtk{7&%8C1
z*3FR;&Q-kHF*C8YN|Lu8aF~Kx959iHM>!|En%7-L8?})V))n_c*OKx-KjYv8sT<%(
z&c1VL@>@(`kua?k95hvF=`w%w)yA9}1v_N`RYV06QI{|OuNNn%AYsQlH<4&@u`y&>
z0eW31Qt~<-j5slTDOJrHKX6|yD7OI&Hyv~@^G>NVlQ>L4rgkx%CHI2Vj>EN=xuem1
z`P7<98rIx@xG9WtYK(VXlSR;Xb{eGHo=DFSA|>o96cz?l7#i(!etl&o?n_uz2*^>Y
zCe<wQ592-(N)<qoy=Io{KTdbYZuzpEgi)p7AUuabXlA;^YhP~`#)N$dugXP+dIzw%
zO?=;l^$Kx{6*(wq0q;r~YxT6$*2SD+MgB?mnpv-3W-bdyN}i;H&*$%Pyi~dA2HLua
zln|&iCTU#0^V9ihjC)F^L^+7`@VV%?);-*@1U~n)#&=DWf*m$r=5}v)wHYI-gd!EM
zhQULd)vV0-#%}A!C{)6b(wIb{!+N!w%}HquPB<V6_c}})JU-u(BOInxqll^Ndm?Ae
z_L;LW-YFqTxtQM8)Ku%StTUG}aa6*Ug4vSH;rPnqC%<NVQ$m(PKy!<i_s*-;IQgtq
zE+~{eEABmIbyf~gk~tBOR5eArl!&5DgGdQO3M9mxDBcDkuqoPCUggq_e6DHT-1=RU
zD`hL!${){cM(kT$rBD=?Yfs%f+KFi_N7^g!04jY5tWVd~%^1Z>cu|gGefuU{a(&cx
z@{=iDnKUZlMmezM@o)*Uotc*2E;^+R?a@U_2vPxLw~Iy%Vno#w^OyiAdAAPG)u1RN
zjdr}&?Et3<Ng72&_rfI@g@Ii8&-v4t0$Re90$GC`F>Y&gIF<vIc`kx7yRcM$ByYhq
zPa-8nFLxX`{AjMjt_}Fy)>`a5@3ukcQNQHO`U>L_5_%M<6|WSqp{8|Mh3}c9B_T*T
zu<kHI&&$@Ns1)xu(tO3Lgd^o(me)-L@H6h#+5FaBTTuQ;q-1<l0N?dBW+2TwpG{25
zn1$paJA^0EJny*OGnl9=dC5-W;VCiM5o~^Y1~b|=QZiM_LFHokl_#%O<IF*pa^c(I
z=+O*~_dm{YkDk6pN(faTsfkuCr2S+j64<9nscfURzi!O(wyJ5W&s&IP7Fw;(bFINp
zZ&i=L$kgKl9u`V7eL$KD(b<yJtCc*3=M9y!zf+ot-F6C<BQWhL<~#giB@R*2JpzR?
z8{j|Jug=3LRYIA<CE~BvT#o!>4r5D_p;0a<ImD~?s7-RlHziCd#3WvH>%&DIn5Zh@
zNNGHbs;)hGYkua!_kS}kFCj`fu-v`MgeepMq{k_d5~`Gg3dbqnqTF4ja&!J_$SGEq
zU}<H1=k%#$+~Uh}E8t<!Gb)Sy1Jmzt7t80R*4U);E3h(q^e9;=p_hR=`h%TWnYEHo
zqEM^qjFMWw)%vybGae=3L?J5A!mt0)iZreQe2G=UiULr@!UrAXFKTEY?3*MjndZEN
z76q`1hOS#RwDGxiQkO2A8mwCx75sv1ic>YKe~tsS7FsxaN1gw{Z6s3(i$5HEgVU`w
z2LwRXQ|l(|xc8Gh<YcuPt%6l$8<n;9_+HsLSq07t3eccTo8@lqSBrD70-yC@sSWJt
z{M!^aZ28>QDy-jagA~P$B6191B$n``9EsIrdUMelmVa=MX<JHWMggpPd)I^<GV-sY
zj2%drQVJ5vDyrFW1+FjPKm{Eq1O=ys5zVHgSAXj_fCCk{tOE*#r3t$2+E4qqg_5}}
zN~+#8F=2Z)zr{Qi6)E9Lp{x+QS=e`zB<|u=Aahy`OY~Y`Wqcp35b);<-jb*7T7`r%
zS3T}W|F)i~t0gok05qFz3)Wx%m1zfCec$J$T+3<cuY>n6LP{7>AY`JEsVcV1aG0r5
zBupqoBjsO-RCDHVc!D-C;*qUh?DT2JT_yU~STYq#4VgmXS{OFjjPEYL<#7UIkP^m|
z#^spzB|drU0u$vVj3*6Bw|c);U(CuWN}^CifjiRubJjnXC1VOS$=h{WPPiTh+0Ibu
zm@#$!;#6u)OPH8ZR5(~6>woQTbr#g>MJ{M7M$(G2|4ZX;_dKSPHFCO4ClZK`7uzw@
zJyY=VvAvP>oTmp#$iLM1GA}Lrqa-9Jcwq_6pRQE#RPSw~b{Zw&I3Xry`swOa>E^1`
z^V2BFGk6M;?oB2|_gcUSDN4m^j1IBTL!-{F;UGncSoM4f<esw8uX2!9V?z7HN3f{L
zue$yDN1Q4}F3;ZmXwmpH=4pT^$y<1>RR5SMZPV2GlzGA+N<wbZnDF6d@iD*c&)sPR
ziIQ-d05iy#pX@pF^{1B$?Cn_XoMoN9X+rn**z7=mqFd7sKL2zP<D(Kn6UfbzkLEPq
z%$&+cNybQVA@A(zmoL*i8YST}DL9=+X?}`G^RTEpX3yvMk`Yn?T(AT<{lL3ncnm~c
ztX@BcK^Y|>I_W<FeF~CS>h;O|l<`~1NGT0UIWMn%`pp&&QslSbVK^t%NU3vXb-O_m
zb(DnVq@~2p2T|zXrHe64ny4^QqNb`mQ+?T++;@voG<MJ2*za|Z*CsDn3OmQoKSp3b
z?$F)i)%Br!{2)!-^j(G0G)a@VyPCc(>%n(vzFf_TMb-L@)=qcY-)MA0xDf@9=A<NZ
z3{P*K^1v+u{Gfs!GOQKM^Zs8$`?CD~#cak9B;+Rm4>p(R>(gViQxaX2gaZYM%dpjy
zOMA>@f}n)<1YrDG+Op73mNTX$nI(mo+<DC70-;$sF-2agdT7)G_EkN@Fgv3plqV3A
z_-C21>$x;2VLK@}ysSn*XIJgJkseP+NeE9G6psHfP`l3RwdR{&9F)TCMEI&-Yn|pM
zSiXteHg~6<jKxb>Pg-6GeRQS9?Q8HEZOleVcuxUTHO+(;FAG9yFl^x{$#^J$b`q2q
zquw3<?LTOzSP%KaiG4m4#;CoK?2`lYo1}l8v3&{mNr{L~YPx;PqoKpObrKc8Xi#8R
zuC;n!f9_V=`Dm@!<@A5O)l1#4hX~#9T`%@~)_UiBm-0-FDS0tZ>j2^@sV0VAXkC+2
ztSF<Z>r<4X*M4`e>dZDk!h~w2Xn$mz`e*xs9o-tx=cv}*kIzxLhScsOqgyf`FX2Fe
zp!~yQ86J%Mjl&crQ+>!mK7U5>TLl<}N*GWumXf1Q{2t!_8&{z|E0vI+TtqZ~awhxj
zk$)yox<{0R`V_#0gGneU%dle(Gvxb)8KW2_AwT)?6-k+UN9)v#+c`MBSiLt9&grzK
zeJ>h&zB@Z#ffY=wkr1Kqfhrf<C|vem8g`%A!bA$3*N+NY7|3Lxac0Ox%LNsVQ+`d9
zgctSPpTJ!x!#KZ^x?CDp-#*8-hG56BApo=IxX0cYRn#R-`pnzj*Gdd=q{jGOvLqQ)
zcymh3OD?U;4=nI*2e?~8Pq$nyV0IB^HNVr3QMP^e5D@!)r5Ko({9#EtgEV5uZ?#iE
zTEd@Scx$~w3%&PdojJ~ww*p?2?nE$z;qR|K`x_kwe}3t#wgA%M9-o|I+<Yf#M@~k&
zFFSy4a`(A$`B{TG8SRHb4y0Lwq+YP59}_PHd?*cw&1ZN|1h2>HD%Xe*DXZo9jEOq}
zhLpw+V_z%DI{IEY*S&mRYgMe@Yq@-Uu=KvejI;uJlq)S%d8EW?oAKp`Ohy)rm~v6+
zsPw3jz4~#O_QN6<lTx|%9-J|di7f(-l#5wj9Y*k(bMTA#t8?hq8p?4m|0{D;#|37U
zXvjn^0e8xiU5zz{EX2?-LsNG6jOkDaI8+p#)GQ&(#}{*Vfxf^api*h@AdKQBea5%q
zVC~7-f#tiab=yoB$7$N$v(m8bdh`WCk*WzxK>emukhgsqnCrz82><*<R{I1!r+>A+
zalK>_Cr)GzA3HYlpPAEbGWd^mZdT046tV(-l@^{x<h`ZOWpoP&-{J|lRRKgc#9i65
zpc#iNb#N?UxdY5c&1<w{+)%);^5k`ydo(S-lridv8<_ptkUBX^jg=blkpiQS)a4dV
znw;szbMopnJD9GHU=o$12)zMkYRV-0&Q5cOyZDtLP15EIg=(K*mTEJ?F8|83W9+l3
zoN(GPu~%=$4Nd4xs|U|v0*7Eim7^Jc>UyCw>-M`A?MvF$aHNwq_Bz;7yWGo-|7HwY
zK)ce?cIps_MvzuaU5w9ibBHUnZ!HDvD~+zktb_5HxXtH$v5}HJq68EyjhkrHSz}uj
z_?zj?2qsiHc-WvaX*i{7^=`))f?!CM50rXd_9yw@V0>9HtIB~T9oo9dcIIa4HUaf2
zfC$}L^YbUKER}>?d#N9zrzsw$u~uK4`1=p0<`$5zJZZflO7xY<zSGua<Mb=d(6qWr
zcwFm<TmJZ5*9!QY>jq(IJQ*23meI0+l;vmx;xISb{qnJ66F6M^PT9ld==6WD9$uD-
zH-ZsW9<F<F&mE@XZSYof`=ldNT?t5AesoMqP{>mFCGnNlG9E49ZaMHcuZlKY6BoU?
zo{2sJ_Lhdla{<zHyj8kqR+p;l3%zmHU7nNS5EOz>3EY#I;djrPsjA9ERr|4}u8qA{
z80rbgC9tP$!k3K8c!JZ1HP^YKV{6w0%{nggV%G`%GF!dS0mVIfd9}F#(=cP*!)-l>
zyZcFx*JV|;%j;rnVo6AYH(fvRVupPy?T;DdO9lxV-4+(BM@y_|0kumToYsZIn@~9#
z{vT7}pA_17jppcR0oM!uNFhoXeU@%LGXptVK=g9(NZw1GtxjH=_oD5?tk5KYZjEg#
zH`;q!u#oi&r=#Pcv3Z6TEtqB%8Qq{><I*YGj;$T>O3H32LzeDKX>7nozqBiidPcNh
zs+A)#gnH6oNxR|>^DbYsV6K$|%H4Zk`O)%*oTQ=<fx6|mGu<K%&7v*AXaV)hku;v1
zBGx>3vMCMe(E{d|f(*v}npfh<ez!>Rxvw>Q2HaP>nC|P-8t~`D0;gy&ix%*{l+?P3
zfd1?C5WFNhx>pqQOhB}N0H(kbje4!Ykmz3+FB1^JG#q*v1V{t*dc@RXw3Qnzpnqvp
z0$4PA`FWg}qP@4Opj0?8#C#{y=9-Lo3D{n)m@Mga*jxWG<m_m{3xYmabD@SeNi~pD
zsnBI<V42cy%M)5dMhoa(T1qHQ*|o3s%gsZaQbnm;ML_87Knyq5s@t{Fk#0}G=d;$9
zk@nemhp)*!4}Py%z7mXW*=b)o(ST;v@qm)oOEhC{pJ|V3Ko$EEjeXSBewApDs=?98
zYOQJZgf^j~1&lAXYEEqjGMfcKr&%4wxkZv+Udj0tq+4}hZ(=TL`|LBu6a?Ha5Vn}U
zKnKSI8rD<o?-#4QifTnY_(iq$%TTpP8XT#fyurCN6&g%RYvk{hdFtKd#I;t6Xb1su
zNo|{{)8f<Il8HPQVZp!@b<0%mhM~!KaKNHU9Dq@5_Acd&73F{9fJH7G01oUOyp_Ay
zVZbI#yw4Lj?T0W<1H2&+I5%uagA)J}$HeVgYQA?;t4xnJjNAfpm|j4w5XLzwbe-Lt
zb{(Px{4fQ~+$jrv@uk3B6Q2zWXkiW_DHNNpy~@0~5N&6MY3p^afO%_`CuQk|7#58H
zW@m+IFH_@WlQlG#s7INlYZxCBjKWgijYqOv?OCsL<bO;u6AZ)(z_OQ@QZ_pD9aAU^
zXkiLhy<kmN>c*rlaU7`7Z~2=xTZg^K6&(Uzm?J5i?vkV%`cw6ISFOIJYpuH6qze@?
zcNAUo`qf*^PC-Bob7ZBI__>FEechGR=TCy!SPIg)Z4nV}J}_Ktclx>RR>6;Jtvj?=
zJ$E38ohvhjcbPD67*o~>xME6fT6)J9_~;f>%?L<hE+AJar@j|)oD<WUa<v-h9x3}z
z8xAr)5Gl;Hm=h`K^ihq$<Cx$gAcE;{2T%wu#0!drc7DXkD)d*Bm0k-O{^P$RI9Y``
z7C~XZOk{1bZ+mKY@9Fbc>pDH>u|XPBKeug?olYH$77)LbdJ~O`{`(FqGBcKHzk;Q0
zDpA=fQ9!b>J<~9YC7^j}A;GL5$rz&ke7yT0rZ^T1!g4@??Ph-d%IrU_qAlQP8OsZ7
zA8aaU)cWvI>W!QdtY+Y<mfL~7Jm>SP9H`J`)i@-Q3(F4Kah?e*c20yNsk8oG*)qLU
z&Iu?b`j#(X+eu%#Y}uP);#VOP_0GTp9sK?S^;C=rYIRl@bW*B;i_B7};I{e=+?3^W
zRjWE3SAG7>*pqd5hs|mb3c8k00ruv!E9->jX-1l|&f8k75EHFrG%r<I_->zgvJU;{
zw~b7VX&;B>$~tkwhLDfVeO&#^^*&*2%D&BTY>F7^wil+xGnOwHhNayfVl^~PjhK@0
zo3!Vc@F!z+fl2|Ci7Mx=6|2vQYPG7sw?kYpMUAO2U<<eU!W}G%$_13g$u}S6G$72Y
zK`uz#T{L_yhidgztpVp`&8*YLWIcS;-CFvb)v5u%vvQ?y{;(4T7-?mstzzmz2eV(@
z7TP<4$yYMs7NFt@ps9h$AC})nIYrTenONuq&=tVFn@X-Ga!9}G**RoU>&Zn{&lZ@-
zZ&!NnV-DH6fl;>L$gHjln#lP+eEl$oEX%MCGCLC~)0L{(+_d0}-!kqNY6A*bbT?Dt
z>|a+@uLPjfeq5^wySl)VlhyK#>SLG*nb9)37D|j)GKsxCsg!Oyrw5rIBPz%XH`7f$
z+|L?4iaEQr1|99m?Rs?YlaScGcM!r>-`HL=m`EujY=J65)$9jS)IL6$X*#oEmNB&u
zmTqcR?0R<x2Pxaw0wkD)k<q^U^5O&zQtHRdoS)8>%l2iAK*rL75674TUPeT%d*lY!
zMwijF99(D^Q5`fncd#52&t+^a2N*6CD$ROzQvHLwQXr~Pf7)LaRCUs^2BlMEoZhjp
zS=8OQweVX`R;w#G5rIDj-uiU+Zyc)BZ`D{PQi8RcbST8-4*Bx06_k1{mxX6`?pBtO
zS;o_XRpaN%6n&O;uDciaMO?uUEuAsLaJoK5F>Xsby;sd&IgzFQi-86ry5YhvCq2A`
ziC;2`7AV5mk(yn!sh><q&h*b^)GUB?9oX}T3Q>D@V1;9Ngq@Y;ctrJK^`@Kt(B@D~
zs9WRt*GpDAD=GPlLXU2xXvlrOH1*PTifjA$Z+Ci)UsS2<VlLPG7@$oh`tOB!D!$Qc
z_)%0Z#$W&6u=<><Vwi|=Bo%r4Z9sT|jc#q~v9YYG2(Yo}(Pj3C0^iV#ZZDyAZ0OLv
zy?)V~r(h4P*NkBm#>m)MXu6<jbYsKO?tSv;98GL7GX9kV3l2;Y+dtp-OiLX&M#jTJ
zT>i1HoIh`mqplGnBVz?%K^JB<)^*6Va-1Hd6}sZLL6$dhyX_d7p7PsbWLzu|*v!DQ
zSF~4iC!UWtF?Jf3;|zOKWMo=Ed0yNxlm_t_!2~XyA)IM;hHdSb`Je?2H!(6I7JfUi
zs^w2RrR5N<p}?sWAc+|=esz4ryYB63FQ3~tsEp4B=~gGUE%LYfT%i}fVq`2V)PfF?
zSV6-54CX4#`#+v~z?iO#iRJtOZu)r7ck*uLaHW|Y1?O%@)wx&mb;j6aq%22XdXDk+
z&fCX1RH*}_w3PUF<MJ}*DTf#tGs}?`2I(0_w=rVhHBMG(f=5~1;v5@{`mLKv*LpW%
zLatyMm*d3z<7VCW)P0YGm8N*r9-{&G(#6Gvm`ENbb!G3BD?_=%ve$e{D|CB%h<Y?v
zp+9c9_Y$KG8A%Ha0$W;4`uXaO{S7!+D;3lUY>M_o?+mm}*!3p|D|O)@qe{Bu?ZTXI
z#s~&;X-f+-=Dqub(lwaqE~9A`=iVpVQ2R<DCi@Bobb+9NXgcn_PS^kABosL=;L$p1
zdb0k@IYet6iVKg3B%}Q?b5v9An??Q#h-QU2@4b%~a1x3f74b+G|K@(xiteVtmvgP{
z8O}qWOS;~kp+R(Zrcn`NXJDx^sfi{HkuAgQBlE5^?j)mMsg@;@1&BTxJQ>G4ZyzJ$
zU};!7yr4<P9=$kOty<QGh2;h`oE_`(6#GZ2JUK9RA+)cW5wfwgVp9^u_Pn!mIVY^B
zi>)=l4V9}p_UL3L&&t?X8Wx*tMuN$o_X;z2CPv1^(x^~qFeh<^e$L2HW?~|Qo{LMy
z?C{d2yLXD7#Kp)6SzuRe4R`NI`V%f4$>+k>VoSR)Ogh3l3*Jl<GtQ=bu}TX@W*IRH
zWd>pvakG}E+ODH*;TRb;3qfhg)o5}5yquh({OUjwIeUD+elugWGAdSa{Q@~H1uidq
zvk|imk@2yLhdf6hV=v1euJp7zJ?)MWOzl#cjHbqUul2~z0Sc2X&5Q#Rvex5POPFf`
z5W=@MRWBgEz3$pLCLr3!bLmWj<64g-BLVTtysNl&gkU0<Rwjz-b!$Co)2#YFeIW?l
zuffmfx7IkTiO+lAEK%c7_0T5xPIrR_tDCA>v&knlNt0ttT%y^<47)P%9PK*C$XHs6
zTdS!WY}fgv&fB{(ds7)_OM~MmCE|N`_w@Xo@jV%9OXD&jc+HrlS()@Eqitzah&@Eu
zi8(gD#c9|Yg>{Pe5A}6t#CW^O%_;x*l9KFV1dkXh3pA5v{VjucF~L{xdZC63c%CO=
z-jMEZGVUy+Y(Z_~V*+`g8*9DT6Ws-WzWT;a+tNCP3B2m|FSp05aCXCSPF`Ult%m!O
z9ZBEQM=rZI;B#nejMRy^TSA|9ojU|OM4sMY*2_!)wllaKT@Zs^@>Y9>933NLZz=kN
zKdO0)cA((1<V-ZM)3*YGV&OzH(DcXqUuXPQM&Q!&g5Q!I+P#=`6*#>L{niEaqI!Yi
z7yhJ&P%(B2m(D?O$7{%VGkmujP_h*F?N-ZjbP5@WYyK4<)i5cyRKgsLoiFx+M3?V(
zZ0E!k*3O8_9b=?iwr{I@q~i+*(NdoUSpS4fV<&Mfal<vdg7o|~q!_C%sPjIz4fY)4
zYQ2sOt1HHSB;_n3PNJZ#yAjtL^<Y|e_NKW;?V1p5C{nf-JsL5_Vej2Jz#Y05QK~6w
z=sEkgT9p{%kj>*NuHI3^YtSZavGuFQFu5W|=*QTzgFRab%<Lxgn*;w{#7S%|)U+lP
zaSnh@*!$HMGq3%|$T(fa`OB5DgBuLvtifu<o~Vhe4la$U%n(y!WOT0LAwimqjTT%i
z#<a6!gSSGtCgactSq{1}!k2=rk%xFO*Kf|cY2jB)H%~_70&&fq^`QoFbC}PUF}MJa
zCdp})n(yHdMSEaC1T!$)_5N%7r*ep*))gX>uGQK}h15eO=u*BgZl`al1lc%9JMfj4
zGc;kGR7T!X7hbU)NXmm6&HtXs)QK|cmWGAe!_evZML!(mWEFX70F*4%_{I+_bFfz9
zN9WhDT;uNF$uA%0U`1(H!*U&<pQiUez~oyis`gY&<QCdxhqR}TG6_t^-*V)JLX?=q
zfMJ7{Guu)bgDVtTSL}p@iK921XADg?WeZU~LX=l>Jh;D?JKK~ow-hMXBHw&_9&_^{
zMn>F1RQ2qq;S;sf4rhjW#Mrr8+IXSMsAzEpYLP8%cF_A&F|v_bDC++x7>^bBuODXz
zLNC^=xG<9ycWmzB+01?<PUysLO7Qk0*~@R)iiU+Q><hPXR!7s}wtDi3&E30Co?+Ga
zwP9yBD|mb@tBfvRi_}6{`<Bi^nIHDV$_E23cUQR>c9TYfSQ%wYg+<)%(rEBn&bS|F
zbc~g8wluCfhA<3w_x_7pIapyL2Qy%IeA{<MAEMS3E2C_Iv?Q5-+#p$hloM6!Sy!xV
zbk>o^s^fYrS$%WEd%MYwy4>fBN^T`59GF2pZ)mk)^tyr^tY{ytVbxR62JBl?-%sRV
zg^>WX3X4T+k8W4v7{WlTjIyPrg~UtpSEb}PQqfx~v9kGD02_RcZs{%E?$VTQFK0b3
zw(u^ard2*kLvE~$z6GN5b9&d7OOnoQ+xcu*#@PxD`QP(&J2f9Ng0^mBWwW&C8;Tct
z-6~33x3Mz57Qn$tr&*0wSy%LPT6x3@-b_?wBi_?-vyPV_dW?;o&B-ZrVC)B*yQOa?
zHmt@$3Y}M7H8vbK|FsP7aP}m0+(f?Uh+KB*BbUtVw<l|Q)TK<KH#y4FXVR+kr*Mm8
z&EhU*d?0vxpbwsYy`Rat)*Qq8E0=ZOzW(<DM!_<M7Md%zf=L7$zGmlcCX3m}XgSIt
zJEy**hRkG&1K9vA5EC4MJ>mPhMA$y8#IPgbvjjUgOV?g-?>u@#o0=_NJ$_)gd7t^>
zznK}HO00~ZrA4M($m=H>f6ggZ>a}F0X6`Jyk}=zGsn0@YbOV-G(XP9FBMyxUQ?6gD
zR<Cum3RBeTQQFJI6{YWTrYiMX5S6)lopi#MWgM#1ZvmBIy?mDah1svd*W=IYa@l8}
z2XovY9qX4T6uQFHHFn~b<7Xhedad1vx>u8RQ)_3epNzQ$rmJ9SRCsp&g~?3Vl`*#f
z7W(VtzUhJ)$M-YKC!3$8F+otX^E<cT?KB*!s8<~t?0$F84K0(=-fygIidF!XX;kMa
z+4%!bT%i*?t#wlgUsiq)&Y@bpSQ}T6j&jwF*9$TcOh(%R|0O-z9Bn>n!U2jL7y-?4
ztKK)CtaQ0QKHs&jz303C`=GeW?LN%I^|3O#mJ*nx$D$u!`IV`>WMnM`NfN{2jSv1}
zoK^6^BIH_t#LJatfjH@8g%M1$k#V&EQ#~tWnrVk&)i*O<C8KH~sD4z44iP)JB4;I+
z8t=<uGKv-eKSu(il#xew+Pp{4Dq>}`v;f{T+j8ZKXXF-4<gSRvEZEK`MIzlUl3xX)
zl#7_eQjfNJR*c!(%BWfz5!<uOvy9oQueg>E(k=dcZfmWKc()CbaF<To)Sgj@jHZR+
z6F*yeYbL{8i<NP+G$Je<RrK~RmtSQ{0~t39aryf#zdhNRg(<{k<Sc;2izwXbaK3i`
z9%Dj-Y_1mIsxw?OG%Uze<a5T@WUMR~lzpwC=}Vb^<+LlxxDGO`nJMt;VQ(DcV5L5c
zS^yI>VW&1(Uyg&7x^a+HzC3YkQYP}sUQ#TjN6RSQk16k016qt^+EiBMvaZbSdefzw
z%q^dcs|Av)847gyqT{LzW%Mj#Y$;f1fl=6e9o}oe_=b$I<-n4L{<bc6`*O01j*S5n
z8`!XT=F)}5w7<{Tgly=R1FJftCh+w+n?pEYYkbFQ6oFw=qB_ndaP{*g)^UokTAL3T
zN*xn+PpO4(aIhj*26+*kf&Fm(psh>-iWa$YDUOiQ?~e{gm^ws8+5$wg$g6XudIox5
z$v*VNbKc&45_<LdU$^_OR$lZ1qXZdI3q+>f&|>9M&tsGzBWVF*qOpTs({NWkPC{$v
zP8$_N^T>E}^J`2Hkg>AVc`ni?3^B{+`}YsVNM)QX4a%L1q+XS!FjFMN2z}MLnnN21
zCtDBYnw2s_77WN!2m7P~8?<y47hdheLcLb}^_lS_8ct_6&oVj|%m{7U8`*AVP&u2V
z2Q$z&Rz}C-CMu=vczksMD46l*E1Ip*B$%@XeIDuS4o{hh$+7kWWUXXs3pt+TW+w5*
z+Rw5Afaniof70NEvAY=4mA!(fD7-v5y2Pl7V;E1fcLcS#!5(e=bK>Yy%;A-ts-<Dg
zc#!O?zTKETq>Q5lk$`Q5zMPJk>lrH}XaOc!qOAG0q+lYUJ;ONP42hLqOuA9FxMF<a
zF{5v%YkvVzwXB=&O))9)<zwz4fY%8hns?p5s8C#bKdiMm<-iUfPX~bInw_a6y-gTv
zh15Q4O|HN7oyE-djg_&oylmj<V04F!hw=N-t$aGL)3F>K;Az0uDG3ANPKxc!`=YTj
zK9-U*kPtmtzrUBT3)c(n%P*_7Dh|k+l-y2x@%LGsn2;i4V`)M0safI&?T4j{;c$gn
z7Q6I_OY-5npVmLa1OXW(3*?2y0ofLOT`5H-PF7(xj9r8LZ4-LsHxuHJuv3#cTx$Z;
zu|VO%<ywM!G2@X0CVksESsE9|(Zau((iSNilFHSrN6NA~Zh(|U5hwRQ*@^b5?Y_#z
z0&b(+GxD8Cs)slkDXWy8-$A9m^G$4O4plV2!$GB8j)&Q5<#M&_`EHzSh?Yhrb~|_e
z>l-*pt?|II1MJ7p?{8dc({*aKadu7?qLvK_h0&{Qqo8C&jT>~=5hoj;1-O)t_4Tgt
ztvE!{<`@uZ)cWn@-BcW+C=vi7sKD67oSM=3D^8oD7*JLX8wG9v#Z7*%$_ZMs#mQ(`
z8dt57A@0UeJ)Y7&wLKg1E*qpz-7O~1hqOkDlku>$?38@4DsP3f^pq)1M#Cx#+b=p!
zJ$`A1Zy2AIk*^RER?cidy#Ge)Zrrzvd=@b|V&WHxb8c|oZao#$E{mY1oGI@f+fG?+
zak6PyC};T)Z4+e}<L&=e`<1j^7AJenP=klTfJqt=c9l!R(BR`_bF&bbyPLguPVtwR
zFe`i2u&h28qzR#Ik}qyE4lEm*RW_u3Vn2LQ+3D<gHDc0-!wVLH`miYcygjqM?mVss
z0qoshs($r@wTfmqTw-6nBxw_i75sf+k@hpD7dca;ea>9(CN-Y7`?F^#bG#iVBWRUn
z%EoHb%U)x`rHq@U0I_U@w^WU|w)@7TobJUgU;33%v^1{!2zg*^pQrR+mb6%j&hq^8
z*l{wV*6R8|l8=f?1Jjh#e7qqfZ#F~6L$Yj1MJWVvGO8AcPD<$TpWgk6)3K;DSAf{6
zqB_3(dFn-sSIgL10o;Ik@tgHDyvoNOGB+sW!i8BGGyt0^n(Rjxf9XR`55m-pu&k{u
zZj$R7XKU6{T1R8VEsx^*N9cOW=sINhzm&XXzmuc4DC$N^fF`XXbW!|@9`6_q)4j?I
zL)_Zk=P)wzmR`*AA)R`4=+Fl~Lk*cR{y?5{m-jJRlF_)_KY)j|fKSV#$+K!kGtpJX
z=F;fg9rEArj;KV>Y~y5vE)Dy^2askU)fnoCAND#kI6cljjLR_^o|~RB^KVSUFiuA5
z0(mtm-6N!%T13rpMiu+5Ls)qSo3J~pOTlimVHhVH$3-9TEB)Q&(VP(o9bCNz#)PAR
z5xrM4C7f&u7f8vn8msPJJc{<s>}?pITkBC=ygPr}rcMSXiO6VO-2Ka+>*blw=vGGR
zQh=C5NZ3iWE6sThR&+F_VZBiACFo047N~hGhP~RkUD!EWT_2d#kLWG7tP$0JWP*W=
z+ofeK4;p~@Wd?)ODSv6jt(GuDQy$NsbxS_u)GG8>?8d1ptwzx5Gylj`4px|$5f-8>
zDNu&3oH~jrxb1VebSw-)4thFcNfr)On3h%NkVeAJ_a<%(hbV|YU%hQzDLvgnrDK<n
zse6ba3EkW4go#xEXsC=P0UE0RDC^_G%-6`cUSNFK2c?^mrlTJ3<WNPuud<3-%p44+
zdC>eevyYasy)-IeFkF3lD-~00%BWs|3B51aK7qlQZO}3~OO)nRAlyqMFsz!1`etG(
z<|*_z8QDvVOWJ=o#(uDtlT_%`LFicXUwgGYhbr`G&Bh|jHFi_SNTx#}o5clJ7?|!~
zwz}JgaF8;821vRinA4-s?`}l*IkQ!vzIVvfHDA&NJYVu;c_yICC|&sZiH7@EY<=M@
z^YJn=mjWa*=FXA7593iXA{Rh{<MaE%_sR@U%j~mcqqjU@r&jQidQ`KT|6%q)Y+n&-
zXLG5fz9!fxkl_R7HfJ2bK7mVRAFT&UW(j+-+{c^}thVJt1x6dmmAjX&PIOJyuLPO9
zmQ#&7e5}QF22Z_3iuEao!w;UneHLdYbGhnmw7O}LqQ%~9yxM)T-NWvDqQlqNFfp;M
zz8k>aTdDz$a#_8ep1nr>*y^gQYM&QdHDY+N>2hli^!bD-c4WLRFk^K;faaUd73<_;
z_Q5i87r<&FKW>CeKrw0NoeD2k&%qpM$i{F1x@#6*|6#%4SLeCf^%<Ou>ZK9!Xqy=F
zhKYOXa=5a*t0ZM7gY-T;F`UD-R%njnVIzi{{1@8yEHmLgPDb}aJrE7-8#<y16L@4)
zFO3)=4S4I-s_nPmaj3FQu#ywL-`t@rYZ;TCa|WveyISS@6$^5nzU4+UpX*v>HC>nJ
zHv4~%>N8d#V|amXgLNzt5Byn*QZwUZL@&TKgUsSf@jo%EC1ZFY9$t7QU!OHe@rq0o
zkny_^l@tplW?kID6bmwHmqz4^g_ARPy~-&->aJ*C^dxV8w`A!#ai!T8QQ<I;`t181
zzRk#K)|zY_KcH(hIaTh5m?-h*i?4RBmxqX&<yx-E-iw*SIf2w^L0GnF)AM|-ey(<X
zUTcN*do9;(9TfIKZbn`^fyAc@Zo0&tTsN~bDc63=?Zb6XgXl5HN8_(db7Poq0qsX{
z4tnsJnww+h_j2{@N0yx(!@V>hDya*FW|c7LXpV0=MN4yUuzORt-rHY~$r7@uTo5IK
zJe=JxqGBqh0W0HxAuJMKOdUl38_G3{<D{M(WaAq@YA8cukCP4L0$GFHZhB?Yfq$9(
zpNs+q=RM4Rddb4xQErze!2hx*$N>L~Ha!aOFH+LA*Fanl%*=W|E`VDYo8SD!Zj2<m
zX}~RAvQPg$jT^m~B>A+T({#XJ-~MTnBu#NYX_6!<FrK1^;m4cR%;jRk^AK$Ups4MI
zfHX0D^kmFEPDW898zIfgU~QSJRXG_&&aVJTS#WP?Gs;hd&lb5oK;n*{8w?%&;m8lj
z*&*PHa=3$AUX@%ynxCId=rxEG3GfF*>D>7PP}3V`wYzqebR-G_swe_@s6@@LPy6H-
z60QK(TGcw{%JPUh)xExg1GOeyKd7mJl;iWJa5dm_SgRX24hvhQqF5%Gutgrc-<EKR
zV8)%)U&BJ+&=mJ!>IBtTwR^eBZzmNPfLn!j6yff0z2-#opP%l;|9Y-D0f<)DRn3X@
zjjJbb@Sx4Hny;3M7-f##iT$onV0uF!g9EhGiBSmw&rs(DhBk^7+PBcXoa+ArQkT|$
zKqVb)3MF*y-NE<^)$+`zugt<HNSz!1LXTeb<Zt>%D{ph_DD`O?g45jpYLjcteqBiY
z84%fWxBBPp>u|VIe@0yIK^JeQer8qE-EO+{%PVzhh3lPudcf6lRNCbN``p@U&#qfT
zX2)|nl7}yyTX@LD^$9Fve?h=>1g3kS>q%bBNQPU)mX@)=9N_XH3GLg14dc$;FyZtg
z4)zZL2gjdZZmUAvkdfHEeQlV0U!!~b4*hjS&Gp`PzC7`BQvJeLh@GA9k<2R8^;5?D
zWPC7CPOw(S*(;xBBCQM%SL)bi)bCVwb#5j}%jjSrC*R5_Uuy0^mnY$0JE>DA`iQBD
zo@CfYSnu9xTmrNoU+Ub5-)BJ24n_3CT0sh!h@;VkINeBH9XTZ6J%;QXXVv)5-Ff=_
z+-h%*pM!O)^i3VTQ>owYGnOnPgQ=y&Lv2F#7?NUeFGdS83Ydb0x`3e0OWX1)lSpLL
zFGO|XoL3P1@!^s6<Rk>9-dYvw6a;%yG<c9^Owpognz$qq54%;V{4>Z&2w+<iwjVpO
z0+bsE-3xwR;2+(tZ%a<WVwZ+oO?$tGyC2-hDOj4RX}o`Q?T;NyNR#otaLFK}a*dvX
z&9<Ls@`!AlmxBu=40zwL3^&y0(F>o^yK}I1QZEkHHhFo(D+Ary-si_wlTdyPRDSSc
zQiHF^+~6AH!ZHFFr~+Ft47H;|%2V`dA(-DRt-cjqf*y)Zm^g9;C#^I?s}2u^eYNhG
zVx;j0(pnwaN&L|4LsAZS1(0&uw>QFX_oLaunQ}<R2Llx&x-U+8F``_ZY1@iHty1#&
zdc{8L%ZU+7n$+BXxaryk)gz*h)gQdJclal@y4<`!wARPrcaPn?pR88#Zw$(L>inlZ
zU_4wl{VSepE>&rCWh_%%M2gZjAetSUStnlF$4Mwk(||{F+?_SEr*nuRXGTPlj#p3l
zWt1D$d~R$FzCJhR4ob5R8}*D)rHuInf|_;O{+(SXFdr_P@r8I~U$AKIlN}tQ$a@iy
zsPezV-8wPxK*sipcd03)RLFAa41N77wzO=nR{)lw2-hfogU&AkVC&jrpwYnGY197l
zO((h*<tt8QFE2W<+y-&)wY-T;ogjODF@UQL%L`k%20d$msJL)`X{|o0!d64|Qco&!
zVg2dG7Yn(`(T^(hQ|wvN+iv;$9t^xc>2p<UMdP_DTrD@!LH=uP)lGdA)+eZp^QDza
zhg2@#R`o;15oEkC4XQ5f8?rub*?c8qSTgRHhSdqo!2POS(y~keCZm37T;DAc5@=q2
zn5+zw&+QB_&&?bLHrMI8n`Pg6PS^hrC+4~)sq>dS%{W`M)!4MqsvAs`O~UW%o-)S+
z(ZU3a15r%_-th2DVGh#jzpkJ#)X1=hw*61GXG$d5IIs8sS&i0SJ^pA=%LVp1u=VR5
z2ZoGO6pu29g}wXc=D|#~k&(VoU~Y%{#y{2naZlQOkwHfJidRH3La^PqCL4X*BDS=Q
z=%q2isEQivm3_#yij1ww$X<Y|rq_~3if$%rO{rcWt965;4J+tO+^a{g<igD_{``6s
zIxJoN15-kWGZ8?>@rqX)1@4l|vj4^&V$R28L@y0nxNwMS|MNExOZDA*h?86BxwygM
zD$ft&FHK^4Z?XYjT5h-%j+0XOzU+;K1Ma%n!so<Rsg)C}`zhF`R{c%JmOuWwPc6ne
z>?hpX>S)NV_H8bDsRrKH5$%0J9YKx(dc0CC9TRe76fg}->xRqc>n`FzMLS;&N~3w)
z!LIZzR#1S@k5K_ojF6c7!|aB6m|{dW=S$1V79*E)?f8K43fZi$04~`?g!cQetDAa!
zQAalMD*(%EBEEmtb}MsiDr16a;PPtg!!;{P_Zvos`NG->%V=CXjul&b$KNlwI`+A+
z71eQJ-MS*%zh`Bd{>G#s84(OL!5^g5nY(QvV`nlNSOArFnI^sX3LR(+4`d0qzroID
zwihmy*Hx|0&g?h8b^Hnz7PHO^-9zr&g0w;>HjBnpV^%k30*#FF6%U6#TpxGS{#SQ!
zpu&<F-)^GG{gaesn{lAlno;W$k6>u*TC-zhWhTkU=w9&oBp7a<b#o54>Q;|(q=Zz?
z-Q4Uv^}7Hk#Up!JGnYg5Qq&)_R;*Y0x6ZCRd9H6KdH7tPD>@R=$If?)0?+KjWMnU;
zQ9SW;iVm2XVpO=VWUu-c2X9q{r(ZZ}#yS^j8fY#U@L#{Ns||KU@aLCa7z^-^xCapC
zUh2YvY_CvL3zI#@2#O(5HtNMiYuyF(%PNfoSkG|XrRj51gisR>lhMJHpcoX0xN}aW
zSWNvlOhy9Ju<oAM>sh_|S)Lu3bI~OHI<N)>-Lu*Y;~-Zz-Mg<u$@+m?Pq;?T9Fuc@
zw4?jJFc}dHB<5xpZeKO^Bbpk+WOKkAOn2YssiENXK5KD@f>a`(FI%1BxN6$LyPVO-
z8XY;-;7F2p*JnO<pmyXY<A7oK+~o5aP1u8l_Bu7e(2PH)KmDK<qX`)iEMAd<nFFr2
zv)}B*p$Z*12rKx`w#xlzYb8v^1A|BH82av~Zw*o#Uo<zL<;vb+L`XBf9QiCyFDAao
zh+YV&O9RiS=5G6a3&s~Lmi-c1v$*oDb^5+0^V(}f;|~~~SD0+*7YK?i;Z{t6@aL5l
z+n9JLoBQS9a_yfN`emc{wqwI&lfM8rEChD{&Njr;?pIN-^mn!Eb6KmM23$7cXrm+a
zDc!@x=EpEmR>tuHVcA!aR{Wg15t9*Q{4N*NjapuOJ)bH!muO@|z7SSFwq(AkotX6W
zIC`8FCgX7dEG<1>%baSYOVsgsf{enY5s{h5>=_@7Y}l5uSs97TLFVek=?|~m=5VdP
zs{*#t0r(iLk5aU+_A{qjYrb`HNm+2C+siM~CRJFtwTt8-qJQCGJaiFUi9J8t*X&YS
zv|ZGOf9<RVxf8|Io7MFF$UZyj_IJAoKKHfuXPoL8$|Jsk-7$A#E-T8YTWAofNn_@Q
z3s>h(WU6KvbIU<>i4@FhS#!>xn#Lqu8HLM%r@W=ITjvjBqK=)$<ywYnBaqH}!y1di
z7}u~fxE$DE`~5*3XV9tC@Km#`o9*yC(JqWF$%}JJG^YH4un4Iu>$L7g-Hy#0jNlea
z>cTwFb9(LcS-8cLx^beqh(NZ}4V!#Dl_@-Blr69<?iuJq+2fkIqWWCdx@~e?H<2e-
zZ%S7rj&}dTWP~jxse46{bFgf!P9mcbf4(3lqis3hnil5<NY5V1XZ-pU6VhdGGa@!w
zv<7_&jpPum!O`(By49`m{X6#=pOsOyP)3M~-pP)a9G<2v`zqoZC9aUEwXQMlACCk|
zTn{(Ly2@%;tdVr=ge)iNDBRS9OR;l!?=<uvDon`A(rPHLn32%@;MmkJzp#7|r)RMj
z>ozm7h(1jZFf@oT*+Y%Ee*E~W+LijPaO*OkCtD+~>&Xs*n%dj#SKF0#fqnia<ZQvs
zUAS$)U){}m_uwSAZtx>px9W~>1icfSP$By{H>&x8ts4plI0yxEX~(SXIasML2iZ{1
z&9NyJ2Wt(&j<i9p*<Rl>yd9@qt3@DetH3*SGzp(Oc)lqIEK0%%435D*7*}~_uRWY1
zMA;aC)$o2Q??*)jRpjIqIWoe6K2&GltVZ_VTsVZ2*IG_H8pcQrBQH$YzGdIJ<;v^x
zWUG4po(w$!vb$Ik-l(mM>+=d3sSEW0;;Oq}rogLb)IPxhi~QIDW)+;Kz~SK>u*i=c
zVD`<!nRm+PW_nmMZda?2P^O3VTlY5qFo|Bq=K@GtjAVIIBol`ybYO<nTXOWdoE)On
zw6wu8blE!}{TRm-&@$?l+EjCwZhyI-Z8qar_VHa>PEaK{Ed0B%d&uzm)%i?6NXFpO
z!n$2|uVl=S{{HK(jrzRR8ncwQs+ay$4NbiDUfN2v7-41XEiEjJ$}}`^Fv)*Kn3_h$
z-qN7ZSfDk+rGCYiF<TQEgR2$K3fuZ~M(&JA#^2(4qOawc@jGKxGU}EBWSK<|+r9A;
zr&FPuD#8+XrM7>|nK>EPk`cHZap_%}?0<Za6Kiw)`I3N)zok)~mt7p=@(TS=k{4-!
zK^3jm4{gn}Sm=*#SUvfq=`D@3mLr=7Ge^>4GS(JI>v)wX<Fc+FMWeT3LF@BYtBAVO
z+|)T7N_Nx~v|IM#3m9*e5ww(`P;!}_svUpkDau%ujHCsis^<gtW#;Rd9V&AD2^mYv
zA*n%(HDNc_{E*JAj}4Pe>I%+%%hEXQf0X1ACSz)~A|Y_htVlIZ+ptm@Lkr;8%<_Hr
z3~zJGFHEe?t5Zg>zOl4y3MK%^$XO^UjNqaD`|g>$?P5wF88Zt}sh!?9)Qe#!hROI?
z07(+{4=<F<!sJwIUG3ylG<gt{;x0_+$T^gZi=_a0mcZT={|sOpRmR5ha7nakd#~lE
zXjYiDd=b^o#?lcLM!%nPZ|!;o%S#guUSQIojEkj(<%YS|_^ih3oDM|0SPcvIN=u88
z%Puj*=r9>63vfwc^=qx!<GAma`YP;#xYx&4E~$Kg@mARku2#YBs1|8`cotJw$v9aW
zl{EcBLfSmzFs<&Tt813P@J_e7x811Xak8xYv;ZfI2>H{psxQ0d<RxnR(XAT-@Jxvr
z=Tmvpp0sq8!exvs&?invrwO(B3)5pbRN)3VNMGpG+J+D4I)%%gU4#cU)RC}}Q<9`V
zHkCHd!)3%P!0eXL(;XU8z|8+Yj{S>?uHmwgT-|&0fzGB+X0K-J7Z-OvFGN6mImnBG
z;dTxdMnQZOZ0~`F)k_qsxg3W&*Ev+GX5-aEkC+AA+67;1rAM#fGDemo{QpwU^5gOI
zIDG3q5uJ|W6Mt!Sxp(dqpdkGDm1M1KX@Klial$Ism;F%o_yD01P8OI}#=l=S%H;Nt
zeco*K57V1TrI2Pp>W?tB;m;?lfQ;qHYS!G>HdfEce7t~(<p9!(Ys9g$H91IYbcCf*
z`gFH3UJh^4yF)tev+bQ|2U0f%JRhrkq;WC~w^()g^=QrB`_&`T$Ztwnf57xO?N%Oc
z%>8s<VzNbSKdyCi?8kk0)`YEm_uLS78|R0$=5Rl3p{fg)nqgqU=U18A#Nh%ymR2mb
zp6J7w56A!f4deU*HkOA9lmnb-28UJDV|&c~b}W;B1gtC%pO*F0wruFeq+qMrI!+6L
zi%r29c5it``4{2#)b6+gs#v`<1F}Oi%5>lk1q$~-`@^5lGz9!CtqVP{5B{BY&+4ST
z-iJ}MfTQJuCU<ZS92(J%)}!G9ik3!2mKsC|GaC<X-Roo8>kSw1v^1<6$2?yics=!x
zj4#{yS&q{|^Q6HM_fotE+jZIJ^*LCnFDqDjKK$F~#lL4N9l^tkf$s<UI*{(c<4hZy
zaIot*dUrcqz|-<$!=ka?ytCr0_c$|?=3iJj-2EDr-!G-+$1*9{nlW5&b_#0OEWBKF
zv&^M)jG+lwT8=Wvwzt{rf0Cj_7%psQXt{<qtihPLT_m<YY_e;w8_#@^LBPxk2#Pn&
zNe%M%Kj}wsxK`CV0S)bdyGuA{;uj}5Tx(8#9+zx@lcYVpipfR-a+aqD_i~=vx+qKY
z9J+ICSOR*-^Y;+K?IbOC`CtZVn&~hWZ0>?3kyFeuq<{UMt}gBd@aJDedm-&e?+ie6
zw=sIwo#8AClVm!IA7omfq?*Q(tz%-ZV5EoI=MOJ+ds}|_#onzi1kz1tp7wc<xM9Or
zV_U7I2tFSUL@xIJ%j>`WT9=7*0w$N%cBc*w_XFN5qdDrWh+dBv3l~tiG<q=lVV~S}
z&T_cc(#7$dVD}AEELi>pr5}b1W^ieF&6r&Go3C~<sb4_la`5;o^trlSox&}ewdi&}
zALl^2*TQJLe{JBJ7*1$wz7C-K28DTP<W${^$CxxC;Bz^;AaVKe`QIlq6@cI=#sDHH
z0v~IqO4wX%@K8=#sTYGTjF2<2ME}4p(dWL_HFMpUX8dtKj{cr9<iZ8SE$92;A21NK
zS6|$8c!AzqvSZ8MXy=v`zECEZzNP;_aAw$r$mqYAASrlt(LsjSBJ=~%hL)G#z4e4K
zUcoRf4U7#y=IAR)y&*R_SZnZgd?H9+aqxv>KXb5FqwvGhuv@>@(3Tvm)Pog0j>7J2
z_|X$4>Ix=tY2D(r1@Cr{XJ$Em{e?c*92+ipe^KKGX|ImicV!I|%%emuT!`K|`*PEU
zQ|{;c9N4N<?Z83H>yvp${lJJRU~R$IgP3N{3EMU@fr(s#DO?U7iL*Z(dbuq<{0tWi
z;8KV%6pAUTKTY-cJEr+9U}!m@B}<Ym(3VY|0vE@9@k&6^axfKL$A~Dkij^wEeZ9y>
z;k75c-%pZ3)lzdda-ddYLdQo?^+dBF>7_SjE@#|cz}0d=@nWR2{9d`=;X%^|_+QWS
z@x$$8EmiI}F5PJLdVM|8Z4G#y|80@N6POGxAZ$4jlT!r`d+S?g-eSsS>ox-16&ifH
zTqf(*?8K?3E~wAK1f(q`u)1(a1M6$O2VCP&t?hGd4f<*znPhc6&yIUcA5Os8QnGf0
zeU!V0!WzNsKNZWd{9~p#5YV?A_@Fze@NJEDQbI_$fXAhf&4AcBBu8N1<X<zP11E-H
zq#;4^r6kcu7}FK7x3rM%nGbh}_v)Y?i_nnq=a<-OyV@S8u*a5cZR4gcKcHy43!6u1
zIN_$3xI>exPlqrOM?l}wN&sALD8r;Gk4Lx%D!xo>mDY7#S}Nx}o>+kKFadolASm)8
zRlxNk<M@T0QsRH%RVbfY?ffkr8TZ2R<!YeCt-VyCYe|C`S3Bp^2aE{_C|p`#vQ(cp
zzS)7vI0EvP3y5LS$T+i?rJ^rw#)b>1TRu>C^X2LF&fuzb(5%p8{d%=}tfN<;#iaSR
z0(8gg)k>bi%Lpg_ja$qafiUSRUIcB+M27T!$`mpJ7MIe2s<qA7`gYd~hd4>C9-sq2
zkb<~qhDsTkO_zYi1(FsEQH^574ASCy>y^LGvvDXcu9weWt%dgS(v6O&!QXJX|G0Tl
zx30o6W+;5PfXn4c3$x}-)g}p_zl`w%0hLR`h5<j2fL1tN{S`*Db{-e57ibnc#Owu$
zZiPDxWdf{#%jE$>OWRaJ&o*ZxIVFg;vmh_>8Ho~#4gO_3rv$6lI!eHQu-Ar?hZJ1l
zrUPF%5Im`<ln}~Xl*nA9&p>9ABp`EXNN5olq42F%>m!(LoPfxs5zWv#?&lSUISH*!
zrM1Znk>44)>ae@$9)-(#h!LQ0L7X=2XiM`G*WEbfIlld5NF{2hD%kVmOPkBip<f;$
zpm1qT(lX`r!<YW1<xhm*2}Om72hwc$b0D$OChDCL0s>b6m)jcWuTk(n4%WI<dg)PI
zj=-3E+R8`{R_OEy3vb+!LU`=hmaoyf;1PEAmM1NgRzX@$vwFS|!L6JqWvfdUA#kIX
z3f(RBPp4g9@Ip$2;5o&>%DF|Rmj>(ou?<eMFa`R{mI(U@Ei7A(G$@@S!K?zmi+Sf`
z*T4K?3WGoxzjaBHr{Wn`sXni@?l!g8I*ly4$r!Zi;VMR08C45vOQf@dO&D=?(T;r0
zI8>{&+PuQ>1cl1_`uTr4bEu*NB$Sn%1yFTQrFO1jeaj`7oTaQv@8dyObI8xUpPIi!
zHv<uZ@mUJjHGj`iGriJ2AAUZD1HYiwRIM#lF*2AjF{jHVV**T=&{;uDwpUiK?|00|
z-3S?FOKmUJY7xttQF>ZyCI-kzTN>Am0p1>?_y=nghsM;b&|^^t07`=FJ9(PcbXDtf
zS*y8%%j%K}_t``Phrik1nz1VxQ_BPN>?(55qf@9-<Lm9*EXS_khS=_ECKvEb)y;J{
zQ0vFLpcCJvmn1q~yF*_UkByL#vf$J8Aw6y76%H+VnaPGSR#vf)|9zaEG-V%V>_LQ`
zprvDBuv72$D`UQ({k90fV~8reBpO|jdf97K#SJm8nJ>85iCKER_NGXPc*RVFd-G2j
z&%|pPAq#3OJ`0R$`sgGR0m6mOidUs*!W#8j*1+&;pQ~DnH_uhM0C4YMTvNtX?WML}
zdKyt0el$8QldJ3;tN<WSDEV$ei@+(FZ}nv)EL9DwijBmo&xgd0<K(sK)st7x#xd%P
zF89yfV{AY$Axj&-3fSi6ZTgZWskzm%=2u5p=j*+|+U54a2Ph@_fM2WD)av@wgyv~R
znt^rJfz9d`KC0CZYHc(7Koi|~?WMpn38})}T;+!qHLt(|K(A`1gRxK*UrBM9o;O4Y
zreo=ag8zN){)s2>;H5X12bSy>pga~%ia2gxhqQwR)2?8Ij8_FpfEhrf!LslDIvvp@
z@aI#kj7?R{z1vg*=LVV^`I*xSzRko}!CWk*+#n6dk*~~Z$t;<SP6c!|)p1l7VamH9
z+qB0_G>{RiTx6z^_uHH<-*9@6IW9=7xps!>E;)UwJtwWzdsR4a`h#F)rWXG0G^sv^
zYjt23HxbH0#v1PS4q-+dM#zX&s9o$25^1lF_@x6Utt{IjD#TjoKbu-OQg84?w>{`f
zxYi|e-Io^eE%GJV&4h0mu?oJQj4MvPx9!&)pllNhfQhC><%r$tezPwW$oNwzAuR|R
zZ2KXUSsod43LvpR<n0N(=sM$t3>!FHS=&kDs@}Mvf@UrEjHCy!5rSt7F=Y90v6pRN
zPi~*I4HE_gZy9>nbdt=sTdu#up-SBqHB4{uT$}vsO-{eEbgT8C=6)DD_;_vfHKs6<
z(WgMaVc0X(cI(wK|J)n)DgGC3k$k>t4TN}7)I<;GNL{}|_;L3+X%D&So4xj+a*eI0
zokpdKnPbp>%NVF-Jk;qi{nz4uJ<olKu#>5LsBsU+6v{brhIzjAW}aRt8EcTSs+4{?
zV$sQ(p<LY|qg6SmX0Ul_NwMBcK_{bCDNO9ak&1rM@gB1{1y}>OlfA;&?N^$ZF^f21
zttRH6s@qodq@zWNkF#;GQr`{2{Am`q=yT?*!_KX8q;*?+UbwxyB1<oN3Kt=xRKa3l
z2Z}xH=#r{d;6ZVp>sl3{(k%3z^jQzFg0)-w6=UR;F{(UyUGwr>H`TU?ju;ma+?OKl
zqp%#;g=mwkexM!YDR^7eydg~9k<qFgfuWXzL_r@d+frdr2~HWZO|D)%Ul-j|#?T#&
z)d)&dh+i4jB<v}p!Rq8>Mr&ltnB9!|#z<Y5wj>)gEwP&k3Nl(1YFFvij9@iJZCk_X
z)oQ%1n*pkC*p8>y*RGX4hvJ%gwI*LzugM$qbDNVMYWlmY`(dy#P1jl}`%pK85dO>g
z*AwQtG0f+|R#`m{=61T#BP)Hx=vGFpa#oBzP5H5I)OW79KAW|(tK3E7N1~4&{W`Y|
zkuj@4-e7l<A|9<RObGxHGJ+N0nl}4V(Oria-;!~w5RV)p)Ghk~=LLevSh}jk{THSN
z0$gIj<*S?tNOLX%qkEC$@Xn+8x#&fw2pP9Z>i~iAaGBZWwyoW0Hm6~$LpTNo|1fIi
z$!)h@Vrp?A!%B5Jd`DnjKo~y$rkYxS?%?xWYdmnuW_Ueibn^OU0lGhR^()M(2?<tO
zSUg-OS{Rfknt2v3LP)U!U}%0Z%hfPE%@!se2uW5N7KANotl7F%1K;D+AkDcrq?)~o
z^vB3G>M;(K*%!YAj~8lp3u3jcCl7v&Q-d_;2I<vh8Gn2oW4bbuRq>Ee9GirlP*c5M
z7D#@9aWWax3UI*?j0G!m@?0W^C~{jsr17ii>RNFeqSe1J5FjFPfp(cLj&=Jp9@olR
zZ3VbiM2#c5?F+o;>qP*2J6Yv!h_CzuEMI@Q@dKK(B4t!7_;534CH=BU0##(BjA(^;
zM3K{4RJuUB5Ro#9l{)%{rj#k>ir;5mq(x?=U`Uo)Z|uWBaxt4mb8mc+l@ryv>e`AB
z6*|&}v8Q^l`8xIXNEy3Ie?K=Vd1q*r-mZOmu_;n84NGZ2b-4{m$NYJ|7d`Qalu@eS
z!%?N?LY)j9!CaGyv@@!-N|F3P%b>fPOD1ybB=q($_H?T7x9^m3*U9If)&{TkPuv}I
z-JHFLE+jCb$|zN+Q*N9^-k;)LU=~U?0SiHyn|BZLHCf6DYUOCS3&q`Mn>ldLLk?7w
znNd&xB>`pZuj}h^UoZ4h%~CT=zuexF-8f89N=88gcT2oBL$NnsOyDp@HFa@*;&$o`
zsdnODz@N|SWlSor2VZFCk3TShR7RmvfLtIQwk2vBEkz<_)2=isTbHJ6IOto(N3Avr
zKB}Ib<9)QtJ5wh!N|lkQKw4s<sYfL}z<j=)M5TQR0R6i(ZxgY4&$-SR^U<Yzt8brf
zrMe1DxbfXD4t(K9PE?_XqNu*Mif8;c5^_g!xI!mIT$c7(X<d?ybYeoJj6elz1y>?#
zbZ_6Ge-V7Pssy}qX;!<flm60)o_I&fs8sj|f?kSzBU`ChN-T@Cv#PXJ_=#n-yIrZ{
z&9<&*_)SAtQU_~^bgyx=A_ptXw88jl&HugI%Z2sjTC34{e#|kflJ5JYAZ5Wt${1Eq
zXQ-Uud0V$5*?MCsj2`DxshwY?y$x7!CI@bC!<)C6bSPt1fq-n?(s6vYaZDj7cy~}0
zf{9SJm?dldydAz^0-~Kyqb-#dY;%@Yea3ybFuh`TiB{`BeDvB_4pf+5HK<vy&R>0$
z850s2A?h=$S{1KYkc?0yv}Fq>97YJ;6J^DONcwh<`d$xZqLqwNrNs?GshW^?PfFLU
zd@gE@-^xYt@;%uKlzso+0miEAJ7CAE9Hn{=+I{<^JZJzINqi1!XH&TjI`J#FbMGat
z>{&u9Gb<(IQGrImsbCxAu9PS2_P5v0;DoitJXhFBsRk}G8-TAISa6)4WJStIR9aZr
zUqG`CEY?hfYe(d|$+(yOvBAJ{;pwhXXD6?cj~Sd8X@6-@gW?5VP^~HIt;RD~GexXy
zFjetj&E=KD^EP7YcNvFDqY?sOr3d%E<Rlg5Q*0<Q-{14^N%!5Q^7*PYy83*TM3zYj
z3-U9P${1Ao>mh2HE7dSIB{O{^QZ|pOxE^s;gtXSG51lfEX@bePRH2mYmE>ZYG)xmr
zMx+8f*ZaMw(&SEJ0}jy|PSNfG5mae-((6<HO~xTw7u`i9IqK_=$BkklpNul4wpWTT
zL?j*dUp(`sSEOv{l*XmWe|6<6t=tOI7yD%sr!=VAXBt}lsc@eR9IVJc1F%H3txp{N
zz;z~{gIX(<fP;D&#j~mX?XOH>WVQ39v;|<dlIvJ4e$@3fdYTexCro*;uybR&{*w<U
zzRk&N-MxFjT-9Ist^PyY;ODah8D9#BgSs<d*umMAbD8V)kut)R2BksZvu)pZ<s=ol
zEZ++(bfRES*R=efZ?!G0)gZSkhi#6p!J&%EVElfzebZ@wk7i6pm2ssURI{S^GV+y7
z9H!7?k<~@A^!!^n!kOCF`th#2!XcVrPhV`R#??JCj#Q}X1v1%m)|+h^!f&LVAf?yd
zxvd%<Y2H@Nd9!sUrc##?q_~Ugr!zn9$h1CWlcp3PrWSqfNwR<Mb2CaZaYZ(4N`u2@
zg`};6cb9Kqyj8}G(y(B%h8?`utL`c$$I8f28q`O#@OBq}kEr=O`YY<e7X|EZ2CCgf
zW4sPLnv%ob8-1t}X9uEPD@aT7;Pk!McX6LDbXM#N!sdz|D3AOo#eO$u`SPn(PUWz;
z_rdl8vt|9E$!*0zM45eRl`*400gAr_;+kb}kNboBF?x^@qg-5OBQT<9%D<SfEn`Nx
zxWvJJ`ut*2rmrUBMNty{UptQE;Di*`!ijv9Sv2{S#f-bks8Jv!u0FBXU)R4?mID<g
zSN}_dp07@b82>G1EClu&l{LL+U-jLt^)N%Xx4w-Ifd7vl)9L{ZW+R+pwl3Yh+MA4t
zTN}GJuEC^N86OJO3Wb1~4BM7@w8IV9K5w-K0nb~xI`C=j!ZFNR$;ePBDS#3KsQsjD
zO(p`$h)@9PWEF3ribw1z$pmUU1<F|{7&uqYo!j7{wrFrLGlwc`E;Yt6c7bO<ybZ?f
zTt6;g992etQXh|JL+0wgI&DQxPNl*sn6A;JyiwC!bMo1~jQ0d$>NYr8smEt8567=J
zV!xgC<htp^fdeUncSOqt$vI)Ij*4PxVL1x#cgY?u=a$OqQyNzF)o2Sa%lv17YqcH+
z%DPY<2Z}a;+FdRmIB55L-`-VHzOSD^Fb(S3#D;s_<nOJ2l#Buus=9w+?3LQ=WAibO
z2}Q}cP@zt_N;Vf`A7@-b?LSJ!hXUdTxtds_$?{q5ZpHuoR_DjHM?m<eQKmjBU->Dm
zPof0x1ZqgNtHcvl1NUT#ioJ7zPvOrms@0?%QSHaKg?6R*fOf>AWV9$yhVPV>tlWbA
z^;*(4W0Z^^#ZYe2)Xg=Qw(z24+$h8&dzNuu4aq{oKvZc_7|@7J75v?ms(~uV=d%)K
z6htiKTu=+^RP5uwm~WTyqEJ#|v*}O8w_v_qMvBsi412HSgOO!vyp9SJHLVa84_9ay
ze3o!(8wV@(S%hU80{_07n>h}Ql8u=HX@fuakm_EiH<^eKCiPt8SYtpicS7?nw4Tf<
zLR4Xc#6h^wQ~p_#jmZfzo>VD!P%3jOwzx<4W}LjD{0+b^5y=RQkIr5El!FyHF2I5<
zKy^SO)}6mkwREGQ&vUKDtFtYbt)g^7WlXo+>r&S)!Z@&uG*yc04;MMw_%Rb+WvnSc
zG<z*Y|C%z3lhFG0m}~%#HgKy<PH~V!6nQNolAzTmRm>Rfn?-wJKs0NiOv5{=0fs20
zFTu*_QHVz*O!)W<W|U==j1Q$=V_*ppube%ckBKKTGL(jeQwF+3r3-$^4D^hWjhWK8
zaFw2D;cS=2Z_{mXlx)rv5Nte>q_=6?-=tqVOjzjmKIgO=6J7~|EgM`3s+W>n3A+4I
zqtbL293|sGp`g$OB4tI+&tsQSmPwSI38g&=L4#a{>07kwUQS%0kK)rDG&KG6>44l!
zB_Lx&mD0_2x*1y5XaF;CGD=2@0@Pl;5(czLG+XT%Yfohc_(jQH`h(*;vR04VyqlE!
zcu_)CfGXx2`RQ4=e9ZLyC>bqEqcW|44~nK@rea3PSW(>B<=xY_nbF`;GCGt3g!0$S
zBX7KYfSKGFWew4gM3r?Gh5Sj^>DY(s7cv1*#)fi4^;+RxR4H`pNd;Vg#P($XAt|b9
z_2d(qH>YijA?H($VCoYYD@seN*k*=V&3SoE8cqq;7^nja#A%*=yr4s6^;Wj21nZhT
zhf9-T!3r0$a`K9*U{HfP4****tKbC(J}boGN}X2Y(wJ3ceBx3j7|4iGuDs+tpl^#`
z7IV@HYv7=hH_N?!BY`tAVG$gR!(1%(?VK*GFV9-n>^c7>6+y;crz^RrK0mW}vb2c>
zV@5Y=b$uB<Yl)H(r0BWx+j&AWG6o=HMgg2UYa!phzFw`oOxBk1qY%{#Twb@i)S`)8
z?6${QtxyD|QFh13d$%}At&8u1sy4O}wSM^GcmxM3^j7|);f<E}n1Pc~GL{tRloSG+
zem*dqlTzrVxTB;T-ePebm?5T7vXN3CB{8MXn~&M+8mP}Xt*TVcso(gbpFVET<Y7#J
zk};!{lvo2%Ybus?;a7~$%cxNr7s_i#2VTm4Z*hk0xM4$RUnsH9ky0lOP4^BbQ(Xqk
z+r|v=jFNGpw4mHW0S~wCn(Qu?Ur=FM4KfwryAh!;bErZe4Z?{%8`--AhibJf?fF6a
zN(0Mgxxnn#We@a~r9FxgoxYpIbQENaD8Qq(UolzzA2>u&5=BJfq8(GzF6RakpNm?L
zt6dl64r|xkZF`;ZBpDy7ENoMO4untI8Ik#1#%60=QGEs~BSaxAcs=?4qQ^Ss=Rie!
zR0LH-dqdI&_d8zaKt+`=f`XTlkUu41Z6*vW`160h$UhOZyqb*zZwdE!$B;LDt3O`l
z<P|w7LUUb}YEj*1Fg_|{LzPt<b*7k39P@oS4%KR~==p%EHtOUp#)4%}o@0*fVnpeb
z3#J#}e~s%@$zI-5fS8{h8}O3JYtx4pM$f|h=kr#pnAlZnT0H`~N=J?*J8E7u$(||d
z5*_0cB_l#<Vatc)Z=297KWAKzkCkK|S&x#@p)@+zqOQ@b%E!!-$=FZ;OA_^l3Gb>I
z-bSLf6QM9sudWY!>vQzN(e7-UdNQF<HYG|)$@c7?B>Q1B<FGP5lnbld%bszSO8aF8
zGy{B;)E8i4tw}YYfCp)&S2$L4ZfxB4BG9OQ{&m0nS(|_Nf0SK!d=|yl4jn>KK@_Bg
zP9T)@1d&igiuBNtPLR+71e7Wuy-HQ;MLJ0DMXIRu-V~)t2Ne-PP{BJhyZi3EGf$ke
zf5dw~fA@RdvuDn8&Y9U~&md0_iOWv|l6vc@YhC&(A)p(KF;c?H2ll32-&}{b@9x`I
z%FZBG+LX4d)t~(k=A<u)z(!P2Zf%8xR>O)ft#%h|D{0~=HiSW`2Azs72G?;#(qvH#
zj+gIF?Ybqa^}Bb-mX85r&FUy?shn)+ZYr~dM}w=MBWbtqiHR00$*Ko}OFq4J2E-{%
z7iEE>mLT_&Y1<GivBa{6XNf>R4Ids*3*7J-Ns~ue)}nU;^&T&}rc1gb&GIPUQn7C1
z{oV-)eON_MJ>2C*h8p_C$C0$F_$-^_g7{_i<*jnAgm2H}iHCEu6vqD~=EfR1Cfm;2
zPlhjwnu0&0?5dBP-0SM5j7iefP3g%dbLuHOiZOHfpPLoTJ6e_%<QukwgWC1z$o@@_
z1bYAix)-`Y&EltZ7DmwoRm}TZ_Bl24UV6tLuD_#bLMj0Wlo=&<by=eaU=&S9Wr4==
zJw98*PDx413QpYh<cRa)T(+3lp7S{I_0nqcJicsKYA3<V*u*YfNI&!dxgE6&OvH+!
zjhU(t#1()*sJ?VWlW1hCF_tZ+r0~`+|Jj$pg}YHSAr-TgeFdu>O6U0W{XEE0VwF!}
zzkld#jbBh45Hp2?$~$$96}M|$Yv}YP5~a<uDju|~DhY9hen?esbG?0ly)<PNdr7D1
zD6&s`@?6&!M$v>-98kA0NBhznk&U!1HG@<+_4e=?OOTB;zH&fqGaY;@?PCN<qbY~f
zRy-j8mRS8gdK67W#XQLfn!>?HgS9Qe(B&xF#eFt1>q(R>c&d2ADS%Tn6_t&ue*<;A
zONV4#n-xVHIc1|V?FTFG!d!QE^5}W@(tLN~U)H0{Q>Vo4WPRguC&L@B%P_4;V6DVw
z&uXb#;2-01v;cH9hO8K?>Cjb=i9sEk{N=z()qtj>V%|vUD6Gf&%#ZYLGK!|A61e;b
zTnph1CG&z&3sL3~RH7hobJ@~qr%Mmg-}oP><+Qu}gt2i}qsNN52Hvvogl@<aR3e9p
zo=JoKE~3*^5XLmA6|*_TyFw=|95_Kg!HuFRt{AYMZpZxF5L}fQMH5?Dh(X1Q>7M<o
z-k=H~KhVThHZB{Ur_lId_gxG5dU00Bj4;+*o5td9(+t`>k?&J4@8^VpRBnwG!sajA
zS)&hx{#x{Tc|c#9-pY0XIv~G(;2s#d8%2{`aa@hLm4@d77h^@yhEG|DpbO7DbRxJg
zH;SgUvQg3Y@}I}eGa<iHNt@E?O7x#Urqy5IMA7tC%wDxb?p-*eKC+Y6ATzua3i_QJ
zcP8k9!zh~IirWd!EhY|c6oD{lEi%V+$m$-j^y+oJ8At&%#g(vAylzw)kMX4k`9@hw
zTs1Df!&OJQtiV?96LbcY8Jgxw7#qh=+*y$U-?nTD*-{jE!YsV9D<hW$=%+W|ZOC;N
z6a$*@ikqzUwdoc&e-}h7?Mgoj5f+1L-?q4_AF4#rW>ML=Y(vg=&gEI8u~$aQ;%&Y#
zb_DVS?RboNLd%GGOSdVGJVE9zvlX4VH4UjIdQhbgrKzsCC&cN2b2ip7@dL#Z=PPVz
z;Z!oIK+*<NaeV&qh<<`F<(*PLfZa)ivF_RdtbRP=Hs(D#Z4o!ha&(E##+5rGN_j(}
zbv~K;jM|a!F3>y)_<<(DVtz>BbYg0`gxUz!xG}f=AOs1zdoyS4Tou6@HxM?gbC#e4
zLz><P3L;ozU*iX>9jCmOFmeRg{nFG}c>d45PB{X>rk{4*ABR*k!nG&I+94ZB{N;dp
zleA@huYSlz(kmzqY4rzg=szj3<S)KFJkLm6HP5LM&Fp5rCr#Jj+4pMbznY^;eNf40
zIxJ=<KS_vVn=x3)VrL#G<b;$&SEE~<>dRuE_sUA3KAuzJnf?kn%6x>)1J!3T%Z9u@
zXt}(9_kA}JI*GJCbaoKT(47sGyNbiVJu2iX$|}+nTI<9rHU{%m;({W;CyP-unU-y|
z?&!q{k-I@7LYrO1P{q{%nuE75*!U7cH70R;`9fjSkm~uG&Q7RF^oTOXnhzD8QatE&
zYyvWtN@K3saiYNOb?5(?E)b!T`e)%-SN-Rr&a1q#CUOC(>@rk7!OC}X?}lva#?yB5
z48fZaiNr<^ST(l^%RA>9oy^c65Pc1BweR#FfXOuVmTfX?OoNpSQF;27FZJ2pQ8e`y
zgYA&imvuJcTqQ)P!_*(RbU8XFXi;f%t$aUVO%6vd&dRUIQWCVNv@ur<Uk|yaN9PSd
zh{m0e%@4i8{rXR)YoO_+jkV%7vTV%W-fPEUoBI5-9CVK~EtiYS-KvB|z}eYiWD2LA
zlq1Zuty~|lHeD^ui|5W*%Gtt;hKy<?vt5{Lq-pr1?de(tLyL}7bu3jncc@)}!SX*D
zn#yQ*%7GorLMovK^IKoP6YOLoiQq>2MU`e7dGY$l@`{^`Mql0;3yw!<Ixn`0Dqd`@
zhWi{NC0EdtT^x@cV>qmEbK8S|XYJ)N%#UAXRAVb`uiZg*Q}Ec>Z&p}cm5ZAyUxPpS
zduk=pi2AP0jTx@qs<l0Ed<Zyoq3OGX3-lYKyKPVE4blQl+{H1qQ-MOW2b>0{*=A*z
zO)`Eg0!Op09=HB7$TzeL04-CQ)>Y4AseXJ>2)V!*|Bk_0hx26okPnfiRN8W2bc9o&
zW0^LN`avS95!NLtJ0eqZ;+tO-+2LSH44~<`xK~-B)TRa8>G~>AB1X|vT{b8qtD30#
z&pX*3R0f);i@~br3U0QVeC_qZpbw#`yBKl`qKAl#b322*1Wn(?V7c%pPBb8FGocmA
zj+Kvnhm58+(kYw+bgS5Y2ZE(`(iW_C4sdAl&AWhRG?`aLH0I%rq;pF_iJ@t`7@~R#
z5Z|f7d&oi~zc^nRo>N}juzK=YmmChcT=|x<bGGDLZ2f)RxC@!%>gjdP>bN<;+%Ws)
z04-xxOtU(R{^-#(p%#C14e_0AThHo?6HQZUF+?>_rTd^wT4bTIQrnB87pl%VjyFPx
zr1LIrq4vz3zg?E(EVr9WqiMsgDvF~NM<eRC5}Wsy9>N!#7Ze%P$a2x5#B(VE)8T95
z9dcKBbX_mg(X{bamaQy6L6hBK*Sk-3#bq>2l4Suqhxg*(TB%nxpT0X(Kd*|Wjk@x|
zi_@8Q9Xl%El>&lZ)0@m_+SIFx?7RauF8Nyi7VVTRiL%B6C7ZH*e=8;_Xz{kZ{WafI
zJt;J30xfPXdgt)NmGsZR`q4yM9F(md7i6=FB{m(3i+Ap5(n;6BMbpM$S@8UgEIhh<
zwN~rVdV?GtN@O&g;GH3$0T_fEO&f$&(fYDTKf)h7dTkNCLyV^Bw-~B50z{v;U3Ol+
z&v>oie{w{SYIjB72FWcq#STRd04a?o+!BB+$kal6Bz4P6D8xt|w*?v(WS!q4?SGZ0
z6AmCJ5bL;J%liIQA`c+2vGh0u=EvA9Gw3C#_-DUW17SduY%xbz=h?b`?P}WtQ#r|a
zqLjkGEZMSZ2K&5dZ2#cEQI$SeIxExb%C|Lhg37<_I77xZdc!Kj|8cF|z_>a?kT;0*
zO>rj1$7i~nb6O_ZV$#u9Me!jcy4Gk_kJ?rBFJYo-vaO2RMr^>ZM-Bs~(ZpH|E~qF7
zu<5}`V8B2$O|Qj4k#g_NIcJ}MG)og}2~elYaq~=}2eqr~Z{VV7W3f1<t~ot^qH#l~
z!;#9aF`5KxMP+2H1?L5UpX~b$EEG+sWt*y<n)J(22F$F8rm3_zXlt<g{U?5O0whA3
zP>X?TRyJMTWD{T#O`|0M;k%oWZ$AK6hep!|Vp*`T@hZ4!-Fnc@(Ii?vTy-b%>YWGk
zkynW|R^K)}sI>ii<W=K7(aNa&pDy>^jl+Xw0~2_ha%d^-nP*~IMc`oCsXO#<Ok1Zr
zeIL1$SX=pN5jfcSpj-bK#{&{ojS1SHs_H_0GWFv`U@J|e#g?CoTl7Pym-3%#fl!U@
zyuDf+Rc{C{)?Zu@p%SZV3TG~l+Xn`MtV&a8v3dL8?xnY19X$a=KTVv)A=PFu^}{L;
zkd4Out?(z*UgX+;^98bz#!#R3f<puZbV-V6+Wmv)1wm&*(_yiP<{}AHO5%?NtZ_<|
zL{Xal%E5KtYq$n4*;@|iw4-SXEF0K;aqZ@mYkxJ`%pJiSK#8cvwX)s?Hx8IOo4*F0
zt-j~#uqG=|z(>>cSGKv<ajCM~d_2C$4$!R9hG4nCzGDv86J0W9yTSJ`{sYLP&GWEC
zcHL-wBGR-*NXc5O8m;^Iq$<l9`1(iP^^@ah+F&f(a7SXQ?+@yHk-ibnw|pt3xHD_A
zB;$b!CEaTU^69VLqiMP<+i3n(DXS3t&9Gy)8`i^n@2&>2B<*5B_5(tVp&g@a%TT)x
zLZ#JT3svuxa?gJM2XN3~)@#{$jUS{Wat#sqy8YeCJJ;r8YsdfO^`li`Zn1@(+^2V9
zkM}L1gZi?i^Y@buftqa0p>|Cc)7tf|bctnyR&o;YKgn{Mc1x_F?|q0`?w4)6kq4aT
z(q?KgXy^Fe<#@T8AyWZOh+?gc;xeq0skQG%4t}@tJCOBhVlB&1ew?5?_tEO+ClRo*
zkFrCK^A4U<{JN{>R8aq-jCo%IMz3BEpYQuFS~6phIk*~^Fa45ZD&R70tQPkzYo_(B
zWY25&-$Bn$JFv1)(boxk8(t`ZaH%}D4}i2cgDqa4)&OwVn9yAAwg$?`@HGX%oBe3>
zyC-+G@CR@$F8o;y6g!$+i!WMYkB*L7E2*oR$TEDrJr7_7O{>MxQ<}A!DY|A!$IDVK
zqlvV9z}kz_^YM3QA$!Rz7WRUj%hpQi5<#@l1Y6ABl)i*&x;XDg;8h<@u*GoIME*s_
zw}6f@nkLiYcsR-)E*f1GBpce?Ee@+4hs2*7J{vidN?(S^ckXr)bL&p0y9Y{gTpk5d
zmu<{8c9(5`<)FRtoBQo+Ie-Ibk}U23E!$QZ^YcoOZE2z`3z0iOH0|!=U(8T;7w?>S
zdoA(GJZ;PFP7kJS*riL`!*vTD`)-W7)0ljv*KM$5W?`0{!}x!ofqC<0{<8s)mZr_J
zJpp$xou_Y09mE{L|72%SOD{J#u}9FrLQIifh;@@u5rfNcA}brE+IcsB2yz)swZ-gD
z;oh%#<8MAju*OPcyPLzZ|Ei|+iG{LGL$F4MIIwK)2RMeBJ}rJNf~E4=Pf+8=^O~ar
zH}cp}HqAy<KRSa^dNW^IRtcC(lWw(kuBOq%TQ_FUD+)rHCf>4P1x3_V%O6)W9N9}c
z<6^*KsHT1(SMqq7{op*Frri>-%v#mfJDGc*M7ENOumh?G?#brc`Xb+w*vw#ghc3=#
zRD17r>--u5CUw#_u=sjf1^(jdKkp!55`#G~%Rl0TN(HX*<`0vQhe;e}!1fC-6}DmJ
z%w-X*k!?IR2w3aYkCGpc@6J)gIi+-!Tt-`cN-mpaZc;ecFK~cf<IT0$FDYcuYJAAd
z$s_gUilGU)_~WwxgK>~)OyP$Jm~`yTfth>R#!9E}yIYesAz*4&;J{*UsYXJ`kMZsG
zb|<Es@dcn23E=GeYWcgLAVgwP0Hc9={hZ-zy&Z|6&Dv^hohzgB-?zW|DNb+9Vrc3v
z3zvW1tB~N6PSt86Yl*plpMtYi!8vDfkM({^b2c}^HPXvkDF;_;PdDY*S{dOIbAgS^
zenjy@hN*=rJ0a`#=jN_gq;D%$S*mgT;O2z)24uL-U##=|<@S0pW<3{ge8+I9-^j`8
zL2{9ZhrRWe^)WO#S8H}s$PQxFIOzV`?5!ZWXc{gDQ`=2#>RA_TCSqvnEshG0uG%Dz
z`d9A`Vrcp;j_SS!aRYWx<;K?#D6x!(@{7#0=YReEVfWBV5lc7&)mLiWk+*(8m_)`x
zMclScQ@0~bB3n78)^1&B^`6-Aa<<BmPh@I}dbltC4))!KC^6MoTl|@-#(&?bcYy*R
zh9=uW#GkdIL<}dCLVTKDYfQWtZs6SI?M7*?Kl=gsM+|Mk7Bf@Jdwagw@=))sVrav)
z1R!e#^<$Jz&;J7MnvDq~mQ~SVGF&A|*G@mSJu;TaQI3kJpA^wz5P~JLl*1zOzjCC>
zeo(4tLM_X+?D#-0Rfn>@d7Bp){wEQOrq!}=D~crOK)cnd;_ObbJP)WrYvim|t!fOP
z{OvpHcXQ3Z9w#ny<keN;tFdLXy5gqn`uWq1#-!1@;+bC-e*nBdlWet?uX5Hh*SI|~
z&p|xUgj=ms6c?_Y)uo><E{vf`x7gvmLWT*$mz4(<n<m_1aN>QFR<X7|Y3v&?E(I4&
zw`HR`apk71!XJ+V^4%DkYKx(2X3os^N_W7ma3W>-mWWRow{cwp9M9i7k}thdw9J#W
zECR4#ZCHPke(`4RLLIN6wIbG6ZZ7YHlnBW5%76kWPK|733uK84VLF`jZ}U?QtVCF2
z>bB1XSc{D&e01z{zn+6C1r|-YB|?B3tJSXp@%Kj{SmGX*dzN+YT71>Lod<~SV`!7L
zn6;XnneNxii0m|`L3^#(in*_c-FR*DcSwC*5Ex^YZrSmgc4`Y<5ct!c_csA@MG(s@
zx0pq%vsSLL8~1e=_qlRE$RS`Ptz+!8M7_LRUi{BY<N;$l?1FYGrq-+;M+QFUrve;U
zw$#X18+3%WXNw+##)HJr)LSf|u*C3<+!Nv*EtEu6<3c${cqx9x@Xh*VOP%eo<N%s_
ztMz|;mHS@P$E`tZ(bQWEnB5dFb_T&pF3g`h-5ro&&Dt%CUnzX-JMgFPe*ya<nq;fB
zc!Q#y#c$Zr<teh%m|tB>S-w)A|K9d1IS{Hb6f9J~*Box${xT`>1quTrWBpJ=^t<PO
z`nG2;WUi65GO*UTjeM!vD70Kg+HzF(Mh$)3*6WL&!$F@(8>Z!8@)1?K^sVctTm=Dp
zjn1{%%ZyIp8>A|)HmR*^$zo`VET7HpM}O#}%`E3f6x6kFF*Iow`;G4HdOG@!!fG&=
z8PTv8ND^j|7GFpCMhlT7+yb=oXsw}K%$V0dt(#R^M~=Q*bM<fa&eX3}E2QD+1_AN2
z11|>7a_WZ5mxq6>YL%aX^FJwV5~geQ=$O#2UZ)c5jc%DL?Rtj<*)l%Xp9HJkN&VO1
zf}oWkD7RP<Da~H8hznLV*ion7YsjC3|H-x+!;#k}ezLCG`O}l6{b0XC&~0%*EpI+}
z`L#44We{#d<Z%3mighH~Q<v-&UIjh1xrgScAQ7jn-0~+tYGYy(q_*Azie6vqAisFt
zwimFJAk`9<>Mt(ujorHdtPeq=#R0YC`}eI5dy##{gE<jDJkXVr9@zNM9<bm9Etas4
z0iuKMfnCZyLS~xFuRzt^IQ)6;vdBzx<z;~UeS}3v<>8OythyJJGJ*ihhpI8CZ0iru
z8zh1V%ZCX9et(yr7a~i|Mc0R_#nOvI#daZ|l2~c^6a>^4Pb<}Px*4fkHX3SElOys?
zn6_E`s9N7iz*_T*Ump3kwR&6yzr7(lNb}}bQa)4|ShXLOC<oqin3Y%(tQJ`#Z(mA{
zY&Gw09S;b<su>_%*GZuWmc&)zSg{RNVbA_^c_V_QGnSpj=nFQdajID;3`hl(TWe*1
zB@yKLzTp=L)mTuR^%AEhstb~<PM8l!OStyXUNH9FU&XBTRReIzQcMh)v`|Yh?8qgb
zLRliM5!4|qTPLXQ%esH}J>XY@(#rM#)RZh}d+INQYCewgp@J0K^Uq=Z5Gtv(^2ibw
z)vN1O<aEKo2$f9QvS^smm$MgT1d&CUk7awHtiD?u)2nWGWGR`j;)qXu{*2G_wMM99
zzCwvg^IQ2JAXGA6q0a96E_HrHsK(mmWC4b%XRI$XRRkBf#SpGKwAV_=N>snLh)9>l
zsW7gt%1BtBt_l!fW7SXkI~zhb37EMml7R2Ke{BHO*YU3$)nhf5pseyezg7xg|Dr*0
zeWhXvL$Z9BzyU`?cCSH}k~081LR8mj{++5h^)eVs5K~!}T89tXKBeZncPHux1F?jO
zSu!m9?;v1X<$ePsf>?sK%E1;jRw=RN28{=Ig2xh+RT8S^hfdw@B%nZ`CW2tr4=@)f
zw!W1*^9B?M)I<=>Yk`6}@RRi$k)=k;+Q~&=YL<R`DK4)QUJ_@GmC&EFs;z(C&jLQs
zi8bq~e72S;1KuazKG(moe##e1kW@J#z%C7C|CJvxDBeAgHO~Ua5AL~2EJ0c2K(oU`
zebdqPLb_Q_mX%?t)jOD<Nvhs`(y1G`i#3*@ta5B+L-f>X097ZPnTdQ$t=_?0VVKC{
zR*SLzGd}GBBA0Npp<}Ojv#6}ttG{Kah*0UwMQ;G74f^?sv-^}6jLux=WL7cvX-Lz-
z`uMz9^Ua1nN@z!>{D8z7lki8_7lDq|5{r#>M`kg4!P<7t;9y;M8%xkzv6bVO5NL(B
z^NrKs!_!!^;EKCJTx*~*_nZ6Y{sOs{AhvQ4^+T-&YZv|xVUlRezm{O_ylUt3EXO7x
zOwu+vg)cA$5B=XRgh?W;z|=G0_T-Nbp*1Hp+#FMDVOG6<JPuh&VyZyYtsGwaG8m5+
zOORKIRcCL$!4iF#ZrV`iTLX#wgjrY)s21-hsy9mwm}v|oe`e}Awd{lST|i+W2&)`Z
zLI3)q-?cjk)YuJJ<mBQPol776vEc^<YD`WpsJ{F+7oUp(Aw`f?iN`O6RzFqII-i2T
zCy1(SOl|QGjlY`*SxKZPJQK>);-^25l|*`i6QL_p(zQfZ66uLgSWafmjjSY<Q9d43
z^JSsnM3m+Uw-k!i5q*i8lC$1x|I}&vq_Szu$TB%u6QNZ4eZ!A+0MAa)Pzg)H$;!pG
zOCNw0BHT-8BZ7u^{H7(X5hjtA@cbil%#-d2)0pins>9Qd#Fit0S|HY}ow6|D*~ji$
zLzbZxBJz@boS;V1t4TXvMNdv-rRZ-}%<0$f7Dt#wUW)Ek#jO6kTXlp<<E419qP6!g
z3U7EDd6Tp;<#(893|cv>*jJ!v8ka}mrDkci8JGHkQbf>8aUO}26n%>qdA00d1WGHK
zDICuf8xsh|h{Y0wQkJEnz_FtVb(goPV*FXK{sgI%gR8e9{~k+hfiR6}R4|kuOE@A#
zcSEz{QebL?X$%1$rfz3)M8n#kyCcl7vYwqENhqm)R;F@@PLVW<@>d>uJRLpLEg8^>
zFuuw%lVwrG%6)mSPesn85|n*5p;4*xko-kJ=``j$o1%jD`m=wZEdb2%k0nT=tY>E*
zV(Flpx=x7$1SM#oTu|-#>lfS|41$RuezHKpu}+hoBljUYY1Pv@DbnmbysOj|u=W(K
zlSp|LeQWOuw3hWbeu1C!^As&@lg!elBS%Y}DtETgy7(GL4%JH=x?LG?{qW%T7m%&S
zpt4C{5gZx*R$%^9<Wwp{;b*h+24q`~K&e%fgK8_4x$6Fl-~cX)%2EcJ(wv}iOV{=R
z_0;GCo2-mdqDpHfKfh2HjQx+LiJe#qV4pc@GL6X_uAm^G>76W0&CbYIAAAl{Dq#?n
zMOMAXUwNQ3q7_Z`B&=jRWhG6oIe2B2lTsyGMN{i&3I~sawh#Cm1S?_q6nl6s$m0hk
zY9E<5HgE_6B~ewV{8&t>pzH1qn~Fe<amx9hl5}w2;F^m-q9zQVvOyCyI}eS2ZxXVT
z#8hr4KP6Ege)iS9*8oS2DaGL^J0pP#iiDOIIsjv7vL|6ILspG_wtUc81WM|8t#5`y
zTdAPcx?}~DUt(#RC;LO>@GuSb?v7D!0a_6TPw@co-S?qdJGtt|nZOHF!rUnaYh80{
z-9pOd=Be1{kKZ~DUTqNW24vXmdX5sIA?y@ZMg6`^?c4~J#95Z8EmfV0IwrE-a)e4E
zt%b^3brrQ|aIJUHq8aJHQ-MH*2fXj4{~!Uul9+45g0qzTPsdMiVnI4bGNRhtWfNP)
z$thP9s~fhg`TCv(7Mn#Ck|V&OZ1<vX0@ZFTVbqlEU#NnsP%$POhy}tmfj(3a3x97M
zaTKAF`eMFl@PxAI%lCm+CzhswvQXJS)wpdreO@?dVPi@ARtq&z#e6ZbIM9{F#*%pp
z6;QQ%RYGTqgj)gawF0ML*DiKVg;t8pTG0@y&;NF|2NRJ`jr4LTz}hzz^WwH9K7FlE
z{bVMUtA27)mb)to?X{wivn%o?0fI`2eL)}I;ACTKcBDR6YTdrh>olJ-*m7n1^y|~O
zQKo=2GcN}w@V~zOG6$qe`#4oVKw55<^z@Fg?)gggo>!Y{lS3IQsepsHFY@WU##)+U
zc%;*0jwgTU?V8yl<FAdhrDw2I>IeIVT)LPYuKaQmIh5393sc>%W?j@ZqyG2^Ie<$1
z;2@}Y*;Q&iG?vPJe8g1oPW+q5t<;(=I!$Hw@>PX}1+-DZY^kW+7v~pT1q<iTx13l_
zf8EQ_sW|}ZXkOmf?N99^Ac6)^lx<5^D}O@m2E*6iJvjsXOOro|5MxIfihmn-={y$%
z7)|?RVKRM=w(0z7=v%n}8)&*G0n4(hw&9+3=2QK84dz)oZ&TRJei`@jTx2edyyEkG
z@ZLXPmO=;7deO)$P_;Kgug@Ja0a;38uE6B(RifatmqYZvjX9RaTnkmN2H$2btM_dT
zmBw9x3VO_UMi0^jn+%o4SqoLSwN!!ar5zqfW!6||Y|^q`8wG6N$7#wtsJ^q8*m5+X
z6WbB+JOBb~)6L1gd&6Z|TA8(AwaEIuNjF_w$!s;cKy(BaC<v{cv*X^<_Vf&v##swi
z>$5WMtFRpTmCjeFDH&5IX%2#=6PCg1v9;*4j3ohQ2{!@qo|w4+?uve&ka-S5C399N
zjMYpKnQCiugi7Wt+!bX#nR)=ogfs;d_W)3CY+AJGq_#UI2-r(lx7iLF#4cbD#*^i9
zml;0*IDw{uvdm@wR9)MB_*d+`27k99z29I4lUWNS90~t)Z;vp^q-C%5R6B<si5`KT
zp3GP%j>ulC=hw(mGG)QWux#gM(~+fQzQT>+)PFX11e+Mbcqxmnsy{z$v9%Y-D(10L
zc4D=@WY$`&PjiLnw;Zu>qB7M!9a1`h{mp;Zk2M)8wYsJtJa`eb?{&uqQh7BlzL*Nl
z-|CiRchYMvxSyxX4iHl`Nfc)&%PWbB173c%XeNj$nkY(OvX22YOZzX|t&ihppT$sl
z8Z3r^YOsZ_J^2&tjtKVw+M&w71F-Hx0i9Omrt>c$R~T2#7r3k^(rgY1%Qg|AQb~(D
ztq=bW*{12>nS-f)aj-r*#NBwMAHPJuyp4g=O0Bp&JuZmdPS0-t0^MAVH}mI5i%27~
zjn2q{(f{6+JvTz95!yj#CAd6aOEtH>pFO|tYYB<h#<i4q%{Ze_Fjt0Kt%1ojJ(YZS
z5WnUxST%X|{;<N@rFQHqGFlmCHxt$5<64~YHQ+T%hINZq@*y*RgJ#$d(73Mt0DOk?
zw<<L+z<z@NNgDu~-imw3dIsxFQDKn;l9Dt}ZOyo-L2mX7{7?QB8vm7F0gfs-p#L0g
zU=DMXF?vLPVfeM%CHJwOM7&T7;T@g2+=b7UofO0#fd9!4K}!tiN8pMaST^<%S`k``
z@cS8SRp778{%w$cuO{;tEmb7;PPSh?YF<k9ZvOR7eU`mM%M#*(DxTR?=WkhG`)eoH
zOX<Prd+Ra?QTFw!f3|wY8(>FCQ*&9xE>yF$-H{$WfCFf1F84+;%K`4`efpg>w)3*Y
z)0yN~v!07<nuMHbYNulSj@7_fm9$${kL9^J9NA23)U8|4SQDf!+N`$g?;-!vXm4Fs
zrh#tiA2T1>O5?ik1~k>yTq`#AMzF>R6Dh=k1uodMdGk%@2v=S<5}V&ouvx}O->C+N
z)qnoBvul-+Neq^d`7wiv9sf$#E)LsdY!ZomA}<wn&YMkr?;a%%8(kr0jajXGqEg`7
zWE~v{+)ER92}46IjjQH@`IRR(11_M+yaY0D;Z+x`t57{w6MDs#qY1tEy*AomTd5IQ
zSU%u6!7ne+gkIvN9A>8C)wtRvnj%aRZxfkT0Q9EqR=)lvdU6tNIi~jH(;igUwav_z
zB*t<?aK@OU!>fJJlN)1{X90l;yg4r4Nst9;0xyOM-8n6|_g(}_VyFNGPv0ifdEYo}
ziJ-=eVm&#3Ny?1X_h~tn6nq41r765DTXnB~71pa40wp!y0u-FDj<4S4Ay|Hz!Yh%T
zu7bcXexuwqgh{Hc91|?mljOD?5GIkJa6-}t|AyB`m_&lYGvIlxHm*mQM2d<JFVy5z
z`|x#N6_ILF43VPnJG;M|O|I`~8)Zym<Xg1o$Eo;OWmD~tV#onRnnGdBfHTe7I-QEd
zQX{0xQg&FWZIyGkZ1xJs&t}Pq<AOwWp;qQ;+Xg&4O~RFEX|GkxQlEu)Lztu;vB1<b
zNvEmz&Y>qK5|o`xsa6h{Q0@}4l1NW+)}><J`uF*p8CZ?ye^Q9jgj<@0pKt6QsELka
z%h4oT>=h-`KqM+n!?oq5a-xT(@sf|J(Kl#Yx7DbFFloFLqi?iR!!KICG6!KA`6B{d
z9Q10K-|pM_j^j>Otz|4lKDCy%KDQ6&4s%8?yBs&`GX%%QD`ZQ-YoBI_BLHQ+CR7UB
zrWepqnr@5z1eXJ8StM_tCi<tvY^;va6}EHrZ^OQt{WP<_T%k1K7BdrFsk8RqME!$u
zW+jdB0#kePjH?^YK<=b*UX%|#DWBTEN!P|RLuoZxXo_@F%`X+7A9<8kl-U>^(Bl1G
z_p7=HlS+PuX?xT?@i;W$6)^yg*E%=jg_;Fh{KVrR|BCBi+VE}4CtQy<Ub^EjRR*Q9
zpU)6dh}3gr!NuBCIl{~*##O6f#9j09%2DqCmzr~cO(j-Ev>;u!{@-KzrZ$wO(PE7~
zS1alTbYuS?W+PNuQ5L#=&^J$gy0QX#ei}&ys<vgE-{kgoWGRiL0+a9Rl>m4)@n|JL
z{ZJZ9IV#&Vsh}Bpud0AdrLmNO!p%sbQ%6!Er_y*TP&KEnJheXrSxPI?0uyX;-l{&R
z4ML?6m7zlUNXG&RNA%v=EGBfhiarVaxX5^YauOTOMv_2tS^-hYE1fG10?$vILuFxt
zP#xE@$j@N?Y0@kURg2WU|GxYJSxP1<+>*W8<oZE`N~S6tD;v}Q%6)`NrYhW#ji30>
z#|V|oRj6|*US`@<gi7Wr)TAt1xOV|UC9_p*9@T6$V_%boD6YtCWz|Z>{Hw>aJx*Gc
zdSGK%39hmYIjdD#qy9nU<ig<TX?iRk|Dvj@mhQj3?wqdk38m?=7^;fbI8&zLPL`6I
z6v7pM{1lR(!?FFD-uM+88*~pnywRhgqu{Wj{43Qjap9*+o%TmImP%A{Xb7&<-nMQ`
zR}fN!%l;fEup=qO)}9{?13KbRnjlL!R@{KDpkB${HVaxVDp6DTwBkYWdpD2+s7ys4
zL6kmGQXj4!8%h&p2?wwpn#QV!B_7oUOf^P;!&HW;wW@tDKGQ!jWg|qXHI?tubkvrA
z1n8IEFjU(9lv4ms@VIcf)O^4JnkY-Sm8qw|CGa25zI6da7EP7q;Og7T5?veq01^Rh
zWR-xe2u=|1elou+LZ#JKrVA1YTg`>1I*%@ZP-(T5p~Ck(4Q`x8Ju6Lz#lniC>KlQt
zcSiIDjE$f%R-kHCFmzwUQHNVndL`WW$I~Fk^ldKOt@Y{(No~29AQ$_SN~>|D&KzuX
zvI+Yf@KmEQ@h8RI(y1S*JM2OC{w@ieK+{}tgV|6hH3<65XjB7X(r7C%HOEHudz29b
z7EN4b*~$K?TH2;b&_#qwtFg>dQD9WmD;JaRB2;6B6_wjU)oq=$uP1oL9ZFM8aSyP@
zU2k4KsJ;iNi9=~qtT?KeIi-5w$&sHwLLQ*iSPND6z^3rC`gq#dP?`$LvQ>+#;_vPJ
z2U$vMg@vUcuCiafUBp3^7;DUeqQtUeP_BB`YHYQ*6R$g<Qf{H?pZMd$eM{oYk0KB%
znXGV!5tI41kqDJ`$Run9!MbhqqAduOOjo!csM_`VEwCS;&9nlG|JJ%wnL!(1o@Zs#
z-`Wpo%Rlex(uJV3L>YrhhD}tO;pc5i?ajl=3jdR1ib_;rE4$<}D2`n&UtUa%Qhwpw
zKkt7IiUI8gKki-LXegK?TYp>@#Q~MHc(<AKYvT``b(2VIbcID)-ff~o+#Bc9`M!XV
zJWSI(iRWi6fu0QR{CH|VZ~;y5Bw$53P#k;lo8X>~3uI%dv`t}ev}WV^@*s4HswW-;
ztdCcNAfeTlU`9YFZN8Q800-4*mZ!y{`MO3els4Z=z_QIj_rxA0v{G~H`*wBFlF<o_
z`uIz$roDqujbZCc3l+g0@s0PY&qjej?Ty9t4SLj`+L-n=WGtPytlDTB+DrLgtaOZ(
zh-<W!5!X6)wwf4)3!@jkkCuz5gW^HU(t&2{r@dbGU9BK7jCR4F2(J`AWiQYszOMcu
zOej$d#m)VX3n50Pc@KPe97-E{#RCnA#2@Ebw-~(Kqm8`cpt{QT=J1fAAkok!U2#bM
zYC~;iYsN3@jzDR=<)F;F7O1<YD;GMT7cYw(SdIfDZN=--wCy?+u2ZLscw6dX&b{_<
zF2Xbt!Nv^F;b6L-Kz%xLK@>PEq22G-jeVzKeK4ar_3V;Y-UOUACIXkUqVH5VTQ6OU
zSO-<|Doqx}ubD5@zFqG^nz8TJoLL>gl6qwK_Ifq2My79q-fz<8TX9(a#fWBXyZ#F<
zgK&){HObxE^@CiUx1{F+z*X9KD-No2b#-uypOKx$V-3zz4(Za$4cC(&A6kp-Byp94
z>T~Y;&B>Av*=b~|V<*qr>e8RPzWNFRHBwc8vhD&U)IotSS4R(TB$WfIFVgr$jfXjQ
zx>6})JLpQK^b>~@eR{QZdH}ato8P_)=G)&DXkFXp4wpnK<+i%S52MMWc(;ZUf5Xbj
z$Mse)j3$q=LD}R)P*QSlZ1RiaR@q#mW1W>kv0vrHni_hl4x{O$gt<`>=+l+Z(kp7}
zVHHNZ+t2ER)$nh7YWzd={50<K<{CKlXsUp`2$aTs4ho1mE#URfkW*>ww?L6obJaVk
zk7s5#VUZF*QdhR$W*LBgo6Brgir~I)`yAEf(P6aVRsx!D<=Na%6?p7to7OlEmY8d-
zf(~=VQK4dN&%}!jc?ZM)Bqq>wQ^Hsl3d~&gm9=W_*E7a-bj+2ZjrMYqC3i^bodBxV
z*bU+OMM><wF%okvP`$)_J+|v=Cnd_3l1g@RpWcZ*-bbdcIlTy>l8&KmRNdClW5reg
zLeS(>4k}>pynL(QMz|#QI=Fzq4_8l{hP*%`aG#`F@%8Eg-|ie&avnk@(bq=ReY@t|
ztI@~@qyp}s0^be|X<5->f<#<n%sRwHt#;~k^DhEh&2^l!%dr)#SIxoW!t{M?7)?pV
zmD4OWvg*iE0#GT&EUJ40WE+~G$`4$7=~ZZL;AF?g5{J$6uDT?#D$!DGJhWlcp=0O2
z$=~|%KN-|WVFB8`T~B9R0p8cNoBu_31aB<E8hoduBz@bIJAGVHeV#*@dH$6T-ufgS
z8~<C^Q4>IS7G@-N*M$DbB?bymQ9lQ(h2!9~%tsNjk=!;icZLW*4S9KvfjJPek>GyF
ztXI{LPtJ(Q=Fm~1xUqr=ii>k4c+6aR)wH}0tQ3G|1(u(|iJG|!^G1SkV_{|umN-%f
zwWph^3%6%lnN*-tH7l_MYD<<dTB(q~zcu?EKx^~OfEJ|qqC*2s-hVC}*=eM;1<KN!
z26^rDpIt%IXVza?ko*&9u~pH44}6+%2-#|^%K}(Dzv|PF`#;qHEHDqok|42WZouEe
zUPj19<|@egx$V3@MSS-u$V4zQS4Kt}$7a<oJ$3?2BCatMT;j50W~HgF@on#yK`@xr
zShBI`+u$$L)ftX}jV-kdj6NNkSL3th`UzW@S(4=stU6-ptydc(dyQ#PhD9R6dDCvS
zLcqpl^9N>$S6RB-rFvZeH8a9klKp|5orZ!wV@vOApt&+n%aYOAr)1VinF7AIP@Njc
zC&q#-gA2vB0{r69fuRW46RXj?v$&#Zhv-8&!pv$d+2V@A8(KfOIAKq`6VVc{jqAvG
zZO?*6ua7ck=<_{DaAvudpT$US+^PM|u?X1{wc$-vpMTY=o<4Xh%q-m!Hd|9Wo#T%8
zdnY9HQR_*m4CC&Cs5Vc<^7{dH;K4Qx+BzPZa(N>Hr!n2Jp0#WUyhP$#pXnpR!pxd3
zKg)TSEYRc1uwxK~JY{E&da4ie3Ns75&`*F<mPNIvyr(Nj!pwITTKI|G`Xuyrb}7PJ
z+FAL;8&^((U5Z)u1%3ex3Y-1w!Vu&jT4nEKJ-~m=?n?hx@LA`mKuQG0{z)VP>%5ya
ze9Efkzxd>l11hy6W-XZTNn#59bD1__mqE909)@M1vKY5+9Z(6n=1jX^5U%k6!VgzJ
z>1^2bj}FKSwDQi1udr9O_VAj2Kh!4-gqihV!dmf8PFbz0nGbgd1<b4na}n)XeFE5h
z<D0kLikv(-`HvY3Gi$<*)C?(e>fj;vk46WNlx=YEXna5~RT}){_m49m@6zhI@I#p@
z?RqP|SaA2(#R!#F%q`Rgefue>Yja07LmsA)*g}mL2dN5h{d={1bN40o8hs$KS8wu~
zF8y#CIEFH7!rXW$V_9254c@mtsJ`84JEX*5)`hvyabVTDbT9P=f~7H7_&2VMzHECl
zm+1wX4zn;!wid2ix3Mcf2Cbc09i}5|KF-tl_GwU%%n~tyZ9J80zUbL|C_0Q4LxnGF
zmr^%h6v$n470(ySd1ACNoUMFOC*)*}kdn1loox^hKYR9j%E$Wod*2qxi2r~bdNgKB
zZsEsKYFrn{{Z2)&FN&rSoP+Zq3<<(#iC;a;zuO6KiRDJi1<U!nNT&5-EuNA)>b;cQ
z8Q5%AkogwUwi%wTCg18^6>!I_Bva6xC~-v;Uq1P458#ejN~Rzqjl#F-w&q6Iw36+v
zBkx4j82RCY+iejxtyOoikrtrG@D7U+wsAkF_=GK`W_QWfKWs%SNhiD&C;AJeY+tXR
zf~+?3U9lRyZZG-8yHml&D8@({1se{$Es}c8SVSEf-KF>A;vmEd6gLg7e`mpaeA~rm
z_DFO$g0l~*)-^a75!G;A(}PEjHdxnCd|Y+%bm~)TF8r=d&m&+{VHTnZ=Lq}7(J9;3
zS(_pywT$03Ijb{qNXoV5X<aTpi$sRbc*KuV`T4I(ry8dgRs#!cmZ!PD!M_YBA0*1Z
z@&M;QDbW@bIkQU51!rD@v&p+;eHO2emku*))daNtmXAvygxzs=r={3Ge}DEXpa(Dy
z_>zCbS_0(zN#iF}LB6M@1p65{FnbK`NTW!?k2?`KEi2gImh6J<rxnLcD7j@ONI9{z
zwBUe?7r2_?U6ytzhzvIpS9ZDx8?K*H49{FP{RZbC-j%u;>yj&V(;+XF&itdZ?{)Kx
z`Q;gxH?eQP?9IQ{SG@FL<gsEbb@4x!{NZM?8+U`4n_jPzrF3QekmxO}xm&!6(M}q6
z=6u>xFHYfR5u8s>%RUjcenoNkZ=W_@sqfjs&9lOM$SF)t*mHULb3IJL%|bW{xM)xc
zN9cPqrv27gQ`!0ECc`H$W=qQ!Sn<Z&GqT@C-Y_>95-$2uXvo#84-l|9mG}Yc7Jrj}
z)e;13P9rWb`~;^?jjFAYi_Iy-1$IAbam)Vm)>U%yrow;s6K)p99jSTjO#NE5LK>cK
zv~FYLawo$Zk4ZB{E%_1W>Sl1<A(7p9er}VUH=XbUvI_(Dm3MHZfHN!Pq-f^n@><00
zC{Vu(0ybK#0Bb4Z$%N&<=p`WBtdSGIJRz}^!Ty7vL#SE$TJ|E<Kx~+=g7jhYuWR*S
zp77!3oCudjYb%K|T+J67C*K9P7KWSUa+1C5OFbo7JfGC*iL+moV}izM%UXU^tH6d{
zKX?#1fyQVH7EN&6(Q*@bc^+=Q5K?jip5#%n=z0{w=7xZ03fo}D4Q<&feKU8J(+o&t
zHXe7`WEL|$RqtM&Gj1AKG_zt(@&fy|P=#$)>GJ}>2WG*X0;}bR$fBY35U|k+3b5wf
zrp2e617T*C%1OZJb?)rOJHOF;^6)S(9R81w;3{6rd0u}n5FSRV&@EYvY1*1BGtVtX
z29s#qQfv%E_zo^a?B8s7x860lP`MYccmDVIgqsy|yxxte`|i=;y5}0yIC3IG_Mi_|
z6?<Jd?)$6rFB|m_yTijsRoXIMbI7<&OG1!~NqmM{qsG~;r*+y_iO9yb-XSut%1{|s
zH|wW^0h`UuJr82bR5X{lZ1#yC0@4wLasIFxo6G)_e!2eMC7hs*bAefbQz}OP_%R2N
z7mWUuyue4^D6r?gd%J;tIuIUCVzTXAR^LL|_r0MCbkyY`hd}Zn2<2Qqpbr_+ta+<8
z!X<IpHW}5<!L4uIL>?y9WCvHT8m)irw;RP7iM=)~>?*^@-~AN<d!TR-l#%q^@NY*4
zSYom<Bm|S~(Y;7rlrU%976(`Ar3hj<Hz1h7dh0jlqaP-KZK!#A8Rv#09Pyn)DPerL
z#rZt?0b@8pFeiaq$8&IVetLN2${@R&XPF7(aqm8M#Y-O`PaBue!F1kv1}n}ewzc^S
zr(2VkkW`sj7bxC%s-UfU&i=-!95N`0&;m3ibBpe2)&}{3L}{UbO5r=@zAL(CLck<a
z+rXkJR(-MTPQB~82soS|lw;8*)F#?lUiCpg{o~jw(b>3UGM$-1PHQgvd=-5N!~#Jf
z$4#{)ESj-{cFkOgKuKF=8#GaM>bS_G--66e(8alyGHew#aQpnn2$ocm9b5IY%$<`?
zR6{Nxk(VtKm)dB4-Sn_+aRh3N0-h0UP|dFye(lhnzs%%+5^)KNHwKE{RZPFx<Rehp
z2@*F4P;`1)s6LyN&v!M9Y$%DY!ccaUp`YvAtn}$A(CI~zDzFW!w`5%x{_(RDRuW&0
z+0f=IKg$OD?BW9|BNq^KY(Cebntn86g&?qE1R<LbmY+9hE0(j<#q$W4v?aD&%XaYk
zk~Qc!6O2y{k0No_hnuLB#h9B5(gAi6gls-9uwzsOwDjO})j(@b(6Y&(EFb8nTEp_k
zj0J&fR<rSJV0nQzVv51*Zq^FcZ)gpVB2`-p)jkxEBr1i~tedN8RUkkMH;*|JwkLha
zM6gyLrUEaVez2!55e|={u~`83NvhH=IUy>-`33bS*1owdgVU%=)HXUuqBi5UxKvZi
z@Pz|1U)NvchZCf3d`&I$`}a(+N1dpazgFOzFAzGZE=$XaRY6Ar=T`?Ep!xbozNQko
zuCUqMFS<N9At&hG{E=OSjeF{oJwC%(j?MidRTZ=Hji34){BMa@{}M+tBD+cTTJi|X
zteOg@ZPxt-5w@|yDBflbtcD%>_e*7+2$y|g3~>cpysB4&aO#GrjVMe=Wn6NKF5g)-
zd-gNr5)$`iWZ>?S>s$A8ii1RYqtPzu_1m8^ezg&~nIL%c4{MQiRX0~WIVA)X9)jM@
z9~^uFknPr=D?l0{2;TgmEwPbmc+)N4<N?8F9-ig|A9qJe%Eb(y|5gWqliG3~A~rbO
z_7!{Sqaw~8O`?r?oSMJodj1>Ge&PbOmSnD5R=erX6)%QO?r|B}Os2X8t&c+567~TQ
zZHE)|Zg!AZz$o=amp>4I7Lm+z8@gS$<OD7EO)A{t258)k*nULUI^lbJ8tecj69jI4
z-mt#sQW+EYzj{SL-Xo~n{J>$h9<ueqNe~|dRhu8So~-ND`!g5v2&sp6nTT`9%qmeI
zA&+>ZIhR*y0dnF>uK=*AAxPPnN0O6zr!?a4YUYm5KwUK7TFJ9VvNhEPH)iYdHCT&~
zNgQ{OVaEIUVy-~s3u9T7Y(`nB_0b97eys3VBMT*5Jtf_qcH1{b%ayDdW5Op{W9PpX
z_1x|;F6Z4ZIX$?0-L}Ad7=DJ!V)<<YQKuUrLF|;^m{q!CBM6!`HyDuS`$qMpqxDdT
zpvlwhP_SNSs7Yw_^}a8V#iYHyjm(E=skjqbbOvv~BWUV08<&fPRNSC(*JF^q#&D2A
z3>Bx?wLiata7jJCV=w5*Tc!T38Cp3~4`Acs^0EJ|F>mQ9KBAnL^Z;u|^E(xbAXj+F
z4*bMcUAo6Ho54HD2(vIvS~_+bs^QLgW$zD;y%L#?yJNfb^Jowkk|-xCf2EB;{-r6>
z?3Lpki)QZ|AJ%H?*z5M25#|doB|q?-ruz3(+oM~Y7D&eRLS?XRc=~&jzd!`jv}m>;
zaJg@A?cw_%f<wJ<8P@s+b57+&CX>i)Pwm1rIn~4)wGc9i&JHrH$;n@poQ|S`L}wcr
z)#UkY7rv=CY!Nh7nvEN3UnH-ET-Q5&+UaMR5uv1l?||E=ZgoC(I`vo{$UHVALL1}Q
zuFe5dX9u<j8kbp7@-)7XqdizUnlR0_71z)lRa(3YmX4-PvyoA)+cWhPxWz8QJjabE
z3I`V?%+S}*WI&!E_3#cZ+=VUOdifLN2@<0nWKc!7TwnT|zA=cPiPBtLA+=T0X0a2;
zl0Xcb=eJ2-*7r%@{+4A2@`M*UqaxZRXmnGAODfK`Cr}ZM-u4C<^%D{1g~_nm<tWyA
ztdry=G8<#fuFl*CY*Y+0St-vWllq~?m8MLy9f7Lo`S&Vc1yz(LO|x-96`kAaicdE$
z6=#|-&4z`wE@X0^10Wy>quY3r=$+U-1(n61QDvqeTpE=HF06Bf23Pu7KZT5-Dbu*U
z^?N6DO6-?{)xEp+-GR_)^;trPwl_Xi9*la7AdGageI4JoQ_8ldJMdC6vYke4X1jw9
zZEw@J{ZWwS%(rZcG{;{~q3)vNh<#ffwn*$Y28qLN-g`5Bi^A>vosK@%WmysC{khLp
z{S;yDSH*p!BP9aTbZUM0^W)+lQTwGB;8&VNP2i&KbKK+XIS{HbZTdWb8j5K}XMtO>
zBg}Vfx~QO?c$)flSCA<P!`wJ4xM%T1q;UbCUO+yeaarJkR-)+WUZ;??w8G3$@pin$
zl43~?6Xf`!v6tiG&G_hn`$79o)1(RKTChRvQvyvbUFYXbz8UHgdyU&9!Cw1PA@n&=
zeC57>1OC#~X~Jl|p}JT7?Vmt2L>jmGzSu?W)H|P@cnP5z_ZluLU_^(xvr#M%MzuMN
zfUVSu@5(Jj#u~G&&sfy(+;6vIuk(sj3S7c;Hpf`d?hO6#LNZ_(O`Rqp03R8o%{927
z(@o08lGxj~XHPCbftTMj%2oq>kq|)`zs9^^1H-!edGkUSL0+Kg)SUUvp@Y?3%lT&o
zb~uiZsB6rPHg$P*fL{oHe&=nm@8;N&gK1JV$6R)VZ5!-v>UT{}mydr1#8o~ru#vx9
zu(7-e|1Ncdm_*TF=!WpFk=vD9p+0X}VG|#}SV)0464?*FY^^$_Pc^7?>s*)KsgxfW
z_4THP+$sEtWc!U3+5UkeCz@_(7!bc%8z}TvlYa}QW1##`1~#*r9WE-3)5C>_d?WB>
zEMrFJ`G(6kMUSI^#%x<!k3Y5g<i=R@1LdRLlDaC;b!%4cuFJk62&y&NUf(q#g4)VY
zbUwA>sy?|ff*@J5e?p&qsQg0ZpK6x?)sCQDvwwm6Nx`hRC|gY@e@gT=ra7D5V%H45
zINIH<cqh<J5Oiv`sgm4A69;~tXJmf_Ze+L<Cla`(u#34?<WK!0!U%#&O}89e`tsAH
zBKN@o6G5sb!Sm+`3DW!${k+Utu&*;q)nva|*gnhMyt*@T<aq9N?i`8o<}qzY*j&U0
z^*1%<Vz`5;HuQb9(qirF$21R*^#Q#>G>!U<@hw>?Xr;vV^c-(NP-Acle=ty#r2b0P
zq&<ocbNkH~&;ezcgt?dx+)->U`fal`fa8S0Y&JZ%UBTSHsZOkO3@dTmXtBz1`)JG!
ziROimtm7?*lCaGJH4zf)Ha9*v>~#NGvDWAZ7q-EYYR7qr^}j_q!Yobm!KOO(Brvg4
zvA`yQW2;pgJ45|}XD7}ipdT>Ta30Fs?o_9qRSO);UMP&)66kvZS2Z=i@@El%i3E+B
zy^5}Yg*Q;jdLC~veI!CB6>=VeE;>J<73i+_XCyolyI~$N63@*lHJ|s7939qBb$QMM
zPdo8CqqKW5MuJPIsTw@{Ud3&md&D~K3neSX7&$KCHaJ+e;lZ@)v;I-rYWCc9T={m?
zc<vcBz>U;#GKi$-QQVv_x@-iWI26qOWH%en!5zb$R`p<wqczVos9%eHSl)YYqt&}w
zFJ1qN`f>Tr<ip)S6L0)2kpcc=e)<Q~-^`@n^&UZxt+6<7SvpkB*#F%5=X?Ew^$3De
zP2jO^L`59baqT^XXrww{!Iq^NKUBoV%P;=u_)=Op!l*SLBA$Wv(f#RNkuyoOW~Qo!
zZmYhvIM@&pglLwbt+1K@E?y3<aET!3&^T-;zkgm|rcaw~91iM#tdYiInL_yvQ(vhm
z*|vj;JQ0N1X~NR-iLH3D1O@fZ{Tf5{?>8d|@-qS43QPnZlx3)|?z`GE<95o@o>fGb
zb6vdMb(j;UZq+v*joF+Rojn@Ey63kdh4qJzBuLNfhu7y8-^f{Ejegz~Nl=~Hknw2N
z^q1pmk9D>-E>R;11JV3YwRy$Whn=XZw`h?B#hHbR2136)d(l;dN#lNKD>M!I?CkTC
zb^b?|GX|B#DTWE%nj>%4QchgSZZ%eN1y=LxKgC`fsc-8d2|6?GSLX|Vwh!P#8r5Vt
z?byA^2%J>Oec<d^llSZ@ctokkJN4-Skp#h+Y`GZL$Oe?^iEP`^5+Tk?N>n!Pcm1iX
zZZ)2a8t|`vkw_##cP6Y(?9ovSKeRu2U}v+cTlz(J>8~gCNP_;1|3IR3Y^Z|X_`T3z
z1WGIDEUT3V<)`CEz3L)R<C&X?X#uLQTJ-i@n?a%^sLsUWb4%5S|9Ixc^1M6ce-ify
z<IikJ6|hjTgwp82X=LV}1huU1TbU*yP+Bn;pn8p1@#vFGAe$59WzM7Hbe6T{?<1Yf
zvFuV~Z|p3+(<W*8EZ_G<dpU_xVy!Vy#h3UcMM;Nq(2I;d16~A267*$`Cr|}Sp1Wrb
zsKEqnnTx8gT7g&d&UAbrd6%Fpb5UUxDxPOcFo-e2&@%zdKA0}57l|E*vNu7Xv?|Ox
zP?THBSF4<WKxt)Ifa<xW$fX%wKyD#u$?V71b4%)1uVw<d#XR23B7$z?pnQ$fqX(yz
zT;9)v+)^ri>=Fb@q$>y2qx6T>I}13uMPjNk``b*l1`9KTm2;X^Wxws~z)HbSP>$J)
z<fIk__eGtnAA*!cP>w0MTFUzQNU2RA2@u3%4l+tDU!JV~Izl!2*B4o+y{)|>@D4~V
zgrR1xtx{@n55TsBwphTsIsX@kk!Il-KbaYOd{Zqx>96s+rbACQ37plb*m~>8$~{zS
z{#wK0fN0^wnyWK+@10JEGBShtpB!hzdaL#XF|~V72Dv4i$XmqPq^9}74Xu#`O_*3K
z#MuS6@*e^{u`yM<oJE`4W@r9Q3qqA32(t~9BFbIynoHl@2oeE766S}h(KRA5%Qs-x
zNRWhCxQMJBdbjO_Fo|S^JJFY(j_3!dN|1v&c3N)L9FYEp>ch}-5o;^EI-P3`RRSCy
zzjGr(B@&dO@=twK)XO<vtVWI{vXr4FYM5JAR$PuSX;ihY9aZgYnznUagh{Kg-P!Hy
zx}8Ude=-Y@)woQ4WYy|x$0FYh*WaZ^nvb|dT@kl}u(vC0Ll52^R<AQ<2Z#ZJ3XF%W
z&=i#j)z&MpO9@n82{X!ERL8q+!D{~2XNUE7AdzMjm?&6ff=kw6)r#G{!fs#*=+#~o
zyzIH$VF2$oxTmG+5^2n|M-G*(SNgOV^v*tI4LG9-Qr>9&4&oU>5GDrMFcp;e&O+&q
zy1$sxOn+w+Nl=9OP@Qa}zIf~Z*Q;HfFqU0mrmzDoGOh~S_28NID2~l6c41R8dEcFH
zdm(R_*(|W_DTYwV_CsLAqrxmG_@C4@8?&TMYD*c$CLQSqNy>^&dGV+?cm{%0OnwGQ
zH0M%h)oXWxcxB@MMp{wxWHT$c52l({tLE5hwVd1AT;Ovj!kh40bAl9L<L=)FT(sJ(
z?faG_CeF(FhW#5FfzEF%-5LZAVa}OwO!9vX1sJs?7nn^HNtkx#hb?*C?T4o9sS*S>
zFodCJGB)~5;OE-yM<HZmP+GIGY>%*dpnZXO`rijZ$k#;fJIK9zx9hKA|23-YS!6Xa
z0od3`-v2Nz>|caTq`!^Ksj4QetDP$Cb#kG^exo}C`%8(-c)-08tsZR84(ui9#^lIA
z-`#JCD_ae$AK@lXKV<kd;@gL}yoszflHD)r7*#Yccipl5Uu3np8<(xd9}*Pr@>&j%
zRta)385@2~@aDZfUw{pdSu5t}5M7&JWMao`$kE>D%}$s#M~`Xs;5tG!#<Rc0K%<{O
z{tM`4Z{+4Jt7i23*<S`9iANH|V)6<it$v!Exh^_8Hi_Lvn{9TB+RpaZTFYK??8n0$
zT&dog6=QyG2Hyc3uT`KGAc|Qt<_C<w1=zeLsU{!_VV;@nX6d6!w@vsvZ<!(d;z2%9
zQ}&0E-&UJY;?Re+Lh43_pOU(4txH&zW@Hy#E*2SMY~U@|xZ^Hi7x-t+brlf0ac`%h
z!%pG-!ZW`_%St4?{XHxG5+gctHMmzP(kvZwEUy(`udXu$RB2hWE$g`(q!Yq)GZ8Yj
z-KfK<dN*=5NUbr%if$w8pDi9rJD`>m<PzhJunyx{=3}2vb0v;?MMQ_B7T<t1B#6Xh
zU*L}-dlV072mDMBjLF!jzxnFV@e>d-v8LO8Mx988wX;7*{xEXhFYfTCj6a+nu>@I7
z=DLV!)QMy}J^_pki6p4WWKZiQ{mU6mCL@czF&vfj*Q;F`jF5>X-CjZVT1Tt9XC915
zcDN#CZGx~&_602IPXh~~tpGt<CPSl=Uhr6jo{kdIRhSvw>?q9a4<+2vb!=IwdOQ*F
za_%M!^QN2)PYG|pN1KJ8YBVNI1NH4l>CG>l(>sJHg1k(20O%0<1y&B$7cGh)GLwO&
zD(>!QQ(f=#r5<Tf1f`h;o$?Ta-?qLzM^_d_5wvDL<o_IFFgj1gh6taUFQj1rusgVr
zHFH{oPwfsQeApk9d1Km!f-C^}pUcFka>lT>bE%8Z;2ptRiC~TKH}CIhfmWEBOZaEk
zxC`0*d|VcUY;3jdClJWcHw(uG&(%A#D1s`@iXD#3IuJ`+t9c}1?H%y`&3tfX_Y2mQ
ze%k)v!#;(h_3kE$ph@$yS+n;1mq#+_$N5nNDVmF`_e|H84K4!Kj&L)li;DZ2ymjjC
zM}DC82z>3(dC=>B#NR=<RK9au)Gd8k<hyhTm&$X23o7l%_jgrB9;WhJ;KDPTg{dxt
zAd9^)8udxdek%1hve*ls@p;XH+MQc~%1D@j=0+Pltr>FUD=;}J%Gl{TRJK0xW?`Xh
zg67Qaoe7YRAXIY=)*HqipHBJ%EF3|oCZU2*8}@y#RtVSV1}PDvzH3v+pN*Y^QmI4{
zlxnWMpq+W1ePVMEXN221U08hF5kC19@MV4!VFsFu4BMou^{&4JIxvE0O#uJbRE2fT
z&o@WVL^kVl72H0z=(ardxuf~Nk=M^i=p*cV*K&<co{2Aawn6>$rw(feGuxx*UDP${
zQRY!-{QJF7aRU_l3YdSR!nc_U`BvO~eY%q^r1socKm@7(W8})?_3`Nesm-D`pV5in
z)8*x*KdTSOXO^_ds5~7jUKsTv@eRNdv!G4JwbHSI9Fu=#ab&U4!7g%m81O{%A4jKm
z)=dgGv#iY@mt_pa;6k<2ehJz^v#iYpj*1B3p~h6n+Gq1WHEnnUIoepL6?A<G9~J&}
zDxkJ`7Mee@*ljB=Nz60xUHv2`%B*zb&@Dwj-^ym7_A&mS3*y2-+BZwyENtG<b8K}L
zKYZm~L~CRJCexZtIn-)(`HPiMtu_nagt?(1?4uZ9?c7WEdIKkzg>M3t%W_!2=^?T5
z=Uo>Ntg%!JSk|a;SUqK4IDcs_h&1yhofa%_Ga0Z|RFz2k>x=&9L8O@#Z~|H+Am(CW
zxE2yQhD>^aykYFUU2L>=iz05_2Z=s{#ORj1(L|`P&RQ`Q8EY)m!dS}#AR<<$xdiTJ
zi;6H7X$zLg!a?-*n>lL*Nb%;8Xcj1g<O)0ex|UqegI{)hAeCn0df6OiTW9eNtrB7l
zXJje?x(TxyPFTy+V@MF|UzyeX$WsAdF!QA>AQ;SYI3GB2@TwZqK1C+ecx)M4IIaxa
z=mIb2X!qA1Q18sDIAOA2v3*MrGQCBHh(Kozr7~?+#kuGRcJl7*KY$cumc;qNT4xH%
z5^maBU^=MKW?dYI7KkB11+BLZ3i6R{E6#(K#eAWsj4XBx3UH0+OC|J?N>S!nX%eug
z(tP3+yqCH3*s}Y<`Js7en)VAFl6v%Mm)Ij2|IV(&uH&6^P>J%!T<TDsZ?Ve;@$q_a
zZ43Q0vKNST^I^RD7{M+1cQ;}gco=33=#muCw0e^Xefcu@zod>bpY`z_P>qn1wN|kW
zP?P$b(q(^AsoRo(*UsEXt&B`xR41Vch)wemgk*nVzQ|f}+*STSO@vHp)9t7i$Xdsn
zdfSxCpro4xa;nXs6Nz6mH3?xGON5He--{`viklWx0AU+rQN`wm9SU~&7nje1Okf_f
z=7(KWU&bP12OUAcr26h#M)t{{YH`SuGb<3V@x8ZVaiRt6lIBL0QsSO44lXg?*ymWU
z#~Smy1^&|S7MS>Z|9PN3nDue0xq4h={ix&`1a17vT!q%Vhx>_>ngA!8XR7%@m(;@|
z_m*tWkj>uMZGCI2gmUDpu!{)VxYJT>2JG(macEZr?Ty`R<cYqBH?p+{;`b=?95uyi
z&;tJcr2VfTlSUgO+8-LMVodPv)F2~8dm}fSLdf+p$}-+~ku(ii?Tz1j!l8;>bANb$
z2U#Mx(P&Z9#Vy<7HX!}jyjs3tlYu+T8adU`AU?jCa(WTM_C|8<4xQyKEB)FPu-q(@
z^Rv5@&hpi}`nLgmF;7!dfI)avi>}=V+3bzwT+Xb--LR?E1|gfhal8~drl?cn`fJE$
zZw0)R9?>VqzH<!O?2X|JSkFuK)8%}Dpp9%%mJo#9-<#LmK<@Cy@X~tNy*2b#-)Ghm
z!Hu{!!MPXsbzeHcKO3{60&s>|5a;I%>x^CryPIES`5QRHtcO#ewRnEB)VJWe;3)Gw
zp9(PZhDw!Rb}gEPZ1z^fOY8A`Z|A3|qlxuKZU(H|TqJw)P$&6I+kdkf&d(iX%IHy7
zKH=1SgzSyo3|U*kus1$>j*z|4n;~nZa8>k(tDvfw^>C^;fTu&gyl@6#8)>Lv>lN$d
z+6OtDPhDL}oY5bSBo4&#+=D%PI7fzV&M>#<O3p}BXg%jvkN@cui8hPk{G3o$kG9>j
zqE_muDB3KFQ-DEfow_A(41y*d?)kQCR->f2W8$wJt|NDN%NXo6h?<J_ug(;UZ1$Eh
z#QPN$x@y4|fe6}LLm)1wQlSrJF0&oE!&}Ozphw3q1p=NUn~e<di;fDYFTXHo!ct_j
zw}zmCp5-d<O!@`c>@8nZ;ALC&^V5<=KLq49_Rcc7TL+a^_3``4Rk#c+Hf!D#FN2-t
zt@ldb)l+`7S@z}+4bIh`mipugLiWb)3UBEP7@T<s_~awnd=02-Gw2noe$uNDvf3NJ
znczY@XKeNK%v%WA8@(B_R<^fhKKG$s0HZ^_v6~?Sf2?Ts>wdt(P;UgUsJmlp+1g-8
zZnSw?o8KZ<)V<Mp^=|_ZS-jC(+)<>``{gOu+UsZZ=0hq$?;c5gf)aaJ6XSz}iWSqZ
zpx9pi^QXXavl>ou3Fwhxw>&z6ppBVHh1Of7U!LDw4C2~6z|9{TFlNQ3sAeFp&AK=h
z8T1~H##IM`{AjZ{PQ}*PIC4(lKxDNyo>zpDt-l}N`5yV&8`BxK*4LaJn&~jI+9S^y
zvR)N$l>HINQlrDXRr1z)4k=hA_!^38Z&YuMx{s(a6{0{TH};Pu*w7fk?O?9D({7ph
zz4)o(Af3{*alV$9T~ny0ruRO04SaAEO_RsT!20t2_*b<`z{@m+oDA*c4i09$HypKi
zcMBeM{LQ4hNscz(80z=l@Ziz-fQ|MwOztN)7l!`tRecU%G)*Swm~FY)HMo9;b0v_$
zMsmvrpKrwOItfVLro7_(U;1Lrbge_QdFq>-l7jg=PA=6D8zR^6^!<KX!bkb~kF1L}
zYveS;4<0$%U|qU+^{cFzb>|NUsfnhP^SRr7x$G|F*-2jyb*Lx@i6@q`*VgJ7tF#yL
zE_70!v=cXWdYs}(y@M>FLr}XO9d(*tZ84+2E{2JwY2|EZl-4@PezSA^s$VP<P1DLb
zs3i)EBS*$XHHBO$SaJ#Qvw2pW6n~{bseMs8x)XASF_+4?TA6*6?X^+JTI2G`s9;0%
zq~T03-!IyHg{X|HrRPGk-bstB^-{R`RTJu(b<e!zs1w5yHzK^0ZMI~RFv3k4Gjnu}
z=J`lT&Su4&lrqYl3~$V29St;P`_1BwmgstvXqs})j%C|$&~Xg!l#tC~ibQQ=mbR(Q
zq|v;3^NwAxTsd6o^2)&S+)eyXaym^%C)o~ObXHimz7JSWnu<<_2G|#4@?=0}d)bh4
zmxK3j1CF&sCwVj_on$t6$MVMi=KPMV_QG>+H8|R=k^I9s1Z@lxiRv60oQpL{+y5|v
z_QH1yT1$M#r|;McnBz%HC!pC5LvQvb9$L5!1)!H+ouf1QX!UDYno5(9<z5Q8jSV=T
z<)4jljucShywT&F^MeKj33VZF-5GR{wfj<NUm_^aTCk>`By`+-a2S%%G&l-Dd)c0I
zXs}0mJn-+%pfB?zoC}regWH$g&(hrY_ESoO=Gk%*eFU-=;!P7~9S1?^NjN8vL4aRM
zo?is)z|527{Hz87v?BwjHb=n5091gr-XY746X+n^lVpxhUD5bhWk^$?GKx0eN9t#>
zcz><-C5!j|a}q_J7pgOxfzd6pt_*bE$VoIeHaw;6FVz`MRAYB+ZG8e5Yknu^?*}&5
zMn#@n`{G6r$mWr9Dl*7-JCCiM1LDnm8tI1(ih1uMzkta^(dG+C{eaP%>p@-1_CO|k
zspX-llDE%0(RY!Cl#0yL<orx#!->=de4}sF5RjNXspUdhg8-s#U6+j)P}CVC+0SP7
zenjJS&g~EKB4jT$JQP;&Nw<<-NAc{9*1WaWmBEX9yz{`BJ|hv^XtYCYZSB51GH^C<
zgC~_-C~pNc2iHH`03A%5N6Gmu9X{esvvA%QfFqtXa-paZ$agMoGXnOq4d=kNpE)b6
zL%f?8=I!7?q3jdQ)8piQVk3Nrcf4P!U1$xxwCJJICkt-(@^<Nq$H9)=eBG$LhQ3oJ
z*Bi<8<8yE~^M50yBJ<2R$s1$RpINW%n4>~ZgF9WL%>&~kgIlsXBEFYwr6#(@AC}IA
z9PNeK?b;`UudJS|`T7k|u#LbDuR#x&ePZRmK^pQTkK@MjtgJdB{l2~6Uh-&9`Z)Gk
zYKg-9b3qlnP5;EH;E30gM$QJ;$6j2kJq&y+7j3?FR0<Fd&OX)EE&t@$Cnxl;*`hru
z<rui?kU|Nc9&-+AB(```$#K{ePQ9<RS|7yW`2bBB-q@2%WUO)Y(6G>V$JL6Dv|ll}
zTyOQ>nHD_j@pr;9ys?B!@B#7m4be8?UG(HlJ123M^K2rc8!Mt8x(54I(a?&VJpOlQ
zN1Nxz`NIZo+4Ayh>Mg?c3-1haxbDj3j0XGUa{2-12ZcThb`agJz+A(9*~5W!{o3K_
z`pSB}iZM&&{2XxVaFfGMl6J8_n_K-8o<=#oyJj(FwVXfpC<ocCS7|1+X{)D>81n=<
ziQVEeSj6rMzbw0_vpdE-M9v>vWp|c)4?olMbWAxf{XR?oa3A>hgPq{x-5B%TrIN`u
zHh2rr@QqqU_^R?hc^!?3LqP}ItDX1nRznMEOd1MwX{7w0y7TZUWVexm3OG0|-P>T?
z69jE6<O(!6EnW4>-HCeZZ*Hd@l50mMxhm}jAIQXb63p@7K)b8-(Rn`sLG4K~XJczy
zmR-|+YKgGD9MN-Zbo%;v>RJ=P`gu~#acppWIjYawRYCeN-(%_@8fyBOkuMwg6e-4h
zm#GZPhS8v}e!pILv4DOS9pgze$MOcp27CL3L$;MhzV^g%h7OLDzFwLs4+;@a4Cm0`
zY;D!q@<Wl?o+!?+!E2o2vD0UQI&KVXAI0@o6{mk|b`x0ZNiN5i(0A;^!K^K9_7%;3
z&|iJVm?y|dWn5gBv>v?rd=Wcf8M52x3ni=p5z{|?y(b`|C&e77hQ|iv$)$JcF`mS7
z9M-Q(cUzlLxA*PQubGZ9kCXFvh<In4D2ARXZ*JzL|M@<@YKQ+x)!aN*PW}NtyeBBm
z8s5Ne1k(<Mo^?1>fvao$6*e*E+fl)fu#|#+B5ZHq7l8Yogmji{#Zkk!Az$arj%IwD
zR7mlWk^6GUA36H&!<r#whCP(`OYTB1+k9XpNCL(aC|?qAnt2y;$kIB$I&b}?rS&AJ
z>(ni&T_3KC5gnCUh1UFB7+ebz<4IX(|AKZNup>Eq4_Hu7(mD%UA3eLLQvc<k!kM*o
zay$ypaNUXOl_CBAUJ5deCv_c|(iAr^ZUo4Uv=MZ+kbuFWTi=q;Oau3v#dwm}acFiq
zu<DE#zYomn=)&b7^i=K{bi8%lmgej)Zci?WmeNzr_u;G7H~n|~ITVCO=F5S?XJZ4;
zte89V7e|CCZQqR>K%4RKgZ;yQjg14<$dkB^Eu=Hc+j57S2&bo>AI;stE0VOBW|f_s
z2<w#|7COT@Fmkh1;VU241%cv8V)uSRpAyzAF8!45_=Bv)K_#Wlr?crJM#=F?EhYgg
zm9*iFkRs>-j0-Boiui#PW}T=0J$G+}@8!JT#%D`hNMq8K<F9SgUxLKYM%Kv=Qb|<v
z%!NnD^IlSbFkEyoJ^`;AIx(Hf?*+#OW;LGVdA_3X(7VWcr9RhRhQxSM<DqbQF)r{I
z=b~td{>Ihx(O=skkD3+(W{kvm(%vP)9bwn9nVNz$=t+7fkU;~T=f~wWLD-pZb(Iz`
zk<au~!)|EYh7F)zdJ^6xvc?DOVK0=30~5DmX!GlAsxWA<&1|r{*m&e=V_5ikgCPT}
zQync6qrb<B@ifCu>>;%Ne$~;OAE7n$!tg{SUg*>y1iYt?@ifCO5gz&culJ0?$Yd{-
zJrN!Fq>KCWIVkJK(@`I<*+G&T%0FkB`a6gUPx3luEc|ZjOuA(|fFsQF>HH!NsO$EP
znU?4{LTVN~sp~XS@0$D-xGXZpldvukzV!a7>;AVvy6_~d<N8P-fBU1uaqwY$j3-^4
z1+Dob{GVyxBCCzzCa)f|8l<9b>7IjkrZJwhb=>MwC>KrHHAM*MdD)hO!%N$4fdl1#
z;h>FukW)Nyn^_Ld>PBu{eB23YscIV&oy%^0pI$XNIU6w7lg5tw0=$?ASvDd9bVi;;
zb{rb2w8|a4i;i48sq8p7I*~v7O^)(lTjxn=XJdm(_|3lmeTUG!wCXlGP;2!%_9z~$
zr>7du`~nU!=d^pY7#Z%B?z|M}Wv0T8eL$HX<7r48cMB*6O|QSY51fg3no`H0)xwzT
zopcRBVKm?2DyKho&W&D!JbAq26VRX=Gn9|&TC(nbU=f(E5o3O1uUHF`b<O9g?*T`c
z-xI3P0Q=If`%i*+_9VMwSsHyDGdRz1Fq|&N({MTt4Knro+&M-dk9guZgGOTAd^M^T
zMIQ0QaE1*scGaK<sMYhNz2hE1!$F>oc%>L}iLrVqL4p$Y^QcY<ATxQA;BmVdHrOPV
zeX_qFa=538&d@<hJ-d9_5Kz&L$S%#Dw8Rax-jSVHx;+uRBQuNeq;oQU(c`*};2l}}
zVGqHV{V|?Yc-+$<OUDmdP!_Zco-}wCG|1H#lB)j>N`NN~9s^fPz@kH|Hi4k_q`u>@
zT>q(l1|1UB{S~ld_9Vee?7`lj1gloxkA6Qbvf5K2XUM#{QL&4^KQ{_td!jkR<~+2p
z-N=sUf9NBQ%@3KSzTG^mPL6E;8f=|&0_<Y{{CPt$o|&f+8QVxjKkQ?}%Q?{Q31RSt
zY1thWjVr!00z2Y6t&%q?@<(kwX_)!#CJjB1izH;vs~<GRnzeUQcIJnp>XN-Qd*oOi
z#Qul&v7U5y2dkCy9of4JHl@p>B%Ut(C8V)t-JQH()ym-)q751aw$YEfV?F8axMxy&
zAMi<;^)KmfM`Jw+@LYVCD{j!eJ!bW*diIF*B*T;MKye*^K2PF&&Oq)TmnpI4i(6&K
z*I9M4{`m$01?$u)qfFa)sm|<?dIE_p=Ouw~!%=c-bnNK{{S8%YIb&NbMY)ZQ)SCTM
zFT8<P)kt*(o>c?}&u(+kvg@zue_W-%s5e(%i~8^|BqmqG_ImFW>q(N=J+TLSP0wq(
zS`L;JKlVEaLr<bSfvy#U59@yP3tvlrSx2n-23I)@j~zY3!f<FIJq-Uo_Qn&v8;SL#
z$`gi%un%)ouT;vK?L0^?o^*K*I10og-LKRIf#^w~=i;OE5;VR*FTf;EGClhj_*sDJ
zpb0If&qeT_k^m1%>$Wfze)F3T=YSmJX~rEpdx1Om#?Nj(K-gZA0LMoAoL8$CJMDB5
z?g5~=Lw4w|y|pX<Y~4WMXHQZ++gS9P@$SG!dl0;r&*%BD50+f`yij!+PrWhfDd4E5
z33t9(A}aX&a#L!8b@U|J<KXCaq?;qcdI0`=((SS72yyHR(eh|G<jmwxzXAOBB-|7D
zTvuE^h+jvo=nWEn%i9=v$IBMNn(v@rcUk7OR8jg|qF7IYJqOioTb}ky8pbW=ev#T1
zvqn#@7bo5w8NSi!@LlYBr+z5M<6P-Q&DX&y*nXcgxxHMKB^!5ws!x>Xv6~2-Ljo6a
z@E>bKKm>Y{=ZTBfcn$=|(7P)x_y)v>Cvl#@2iw;|vj^`7S;dn$&&Ec@bIYPGV*q(P
z>GNE8RQ|tMus#ks$II!U^$U7V{3rKk{q;Ahv7Ur_0^4G|8{_HHrxGj5JumUcEYp)>
zyu|UcCEd-p8;wQgd=#yVbYjgz@TA5$+0y8VOXIXkakO*xZk(J7K|Kw@vwtAPF>PPA
zEBPE$BigmGwl2f@4ebHG3cmUYNCC!(aVo#>Skqn5pbI-|^2T4;nw#Z%@`9ELK791u
z(Z5A#Qyw3EF!wAVsadV3FDVm@Y5thlrqVkge|Zw@+0GWn7HWN~(7tvAh)7R@JsaO*
zlllXbs-4~sqJ?&?tQ{?Vl4`}*tLw{<?$S=Fo@o_YTH`AMd1(**8TjPS;b3Wdlvo5*
zud$xAdba7TOskHGyZ!7MT3IixKkvEh?nsjhJqoTf0i<_NdOaK8>W&iCC&>L``g8OP
zUUmTXFYw+PeA19NX6!n!4=^sTlMOVJZ!bLEore$qlajk9^`2;So$nXi+<rUNLhxQU
z){}g%Pye0?zA$&8e>(Lwm{l0-Nxdha#ok3-#@*X9S42KBwp~&N6X^OePT|HCvVa)(
zB;o7Zvu8r@64uqImgz4452w1*iSwWThP<4{0P*pE!tsdk^<fjvH3)bVv0XW#TlMGq
zmEgq4gOra?lP%Bw&^@{ti_R>K(CPednOHuQAwz*&a@jH4gP2$NpX?dZ3845yhvgM^
zw8&T~I*pJZOB}3hk81A7^p5_`Q7r9pTIXj%*^gKU$Y^gpE$n(l&=D9nV7?rnZwls@
zF8#O&a}58JoI_LkIaZ6>#NESn-r`1T_d`CHx~*^gSQj*8G~u7~QzA*0w<h=VPF`7r
zf09D8^NVl&FTahYX#hJVcI(6VWmj79i^1?l`@HAQpFzJuN)!IS!m1&A4ES+#(H_6`
z1^oz3Ac%fNbymj61xtgNv-qF9_QsUKvmN*WF2w;K+0QFoFIxZNFE+{;wkiCKv{i9~
zYjW#${n3w*Qi%Vvh@xg4A}Z0fJGe?Lpg3(vAN&!mD*t)8&2#h<q(;L22`hm(@vCtp
z$L@7mK^8H3%9lm-SBV>Lm%IrGK~og^S#3KXuJN-`RmOoA3p8<|^)V{v8qj2XJ>tqf
zu!E*43ms%M6MFaOq4D4yD@|7D0Q)v_Znziut56?=Yup@iP6=E_R**lh9J{(698=JS
z_qn)m`TiGG^*3ZQDGylK;w71y#>%`{lZ?W`7|^aSI4<z=#aC7wL*5{D4z9(}8(FGv
zpM<<YB0A5s{L(<Mf@j0CoB-@LnryKfUQ;>o-61<cS4@);x~7Uvw~|rw{xP%+SUZ}G
z(1uP72?Eosu1`672pLWKvfo8UZP=jXgXNIXr1I}TL;5usp0^rkgw5moL?~N9!G0ix
z4z*j4Z`*_OnHW;NckJd=!NcY9Hd#Icu!W{1l;Hsrzv<aKKVXY_lAmx46QA*mFacZ6
z^c&Iv;Tq}UkE@mOqhC!zQj8cHyKQ@6h-})>sTDW}FakUL*4_su-i#^*YM)tK#9d&u
z8U?LhL*e$*<k@9`Z_UaD30SlP3U1N|&F6w+H1jJ_7gy}#_zhrMb95@h<%6K<rilhE
zZ&={`J)rvo?mqqT+ST1T36*`iSw6`3=?4#mlsVO)eyv&|4Nr@UYaUt~br(KW*u-1h
zIV!x7<1+k_6HObQ9CcC~d)aUDw?co#e?ZzW#F8qw?Hs;ElpN!>G`~D*{HQPk=6^Cc
zsf^3u-1FVr_36+#A=%ont4AdzZoD0hmcU4Q#Yd+bt=rr<z+M9PK|U%_`z|7sk)m#V
z7WT;uQl-wH#)Yo7@|&p{nSc0SpwL7H1f*jBeep2%j{w$4C$zEOv!@G4GxKs_Lf?Lw
z15%}Z%>FlNd5qM5m*ct7@=xl$d$>fFo157WueJ}bT$w)o`ZR9zUx2QGhk9j?b)MZH
zaDfkyV4(}RXhOVC#On|E)CXvn^#8KZedID}f6U3>H1o{l4_JqJ$#S7x$o~t_wJ^_z
z*`_&Z&L41r572JQ{|nHyaB;@T-SMLQ=>xRs{9k~sg;NGrxsMm6c53I5Z3_Pvpljjm
z4h=uX7B2Du+O+*IK-a>xFAq(NEqv+&wAo1mJg~g__m1}4e^KhCaUR*`BMq?5<3eK`
z0j@vu7CV5R!f<&=$v1HrKJnpsV&1$qPj}%ktd-V&VrOL5e?76g$g{pnNW_c$xet)=
z$nGMqTDkQBUgXC<Ku^qDb9Tq?PCx6v$hFfsk4#{mYvGJ6?`FkOv%&}HiFxVr)V<*J
z^ZpjT@Bw;aUSP#Bsrh>*enjLC*do32$ex%NSEt1Y=e)@uaEA}j6Z2*b?q380=E>k#
z=!to47N70wgpEJ*204J9qUQY$Iej;~`akh$AD$=XReR&p`_8*Rf51|#PK%1-Xkci}
z%USc$2!2q`&oli2$NK<1F)yfm!PL&-s6XH@K0tyG-P}-j?SKT{Ve(GdAFzHV=aD@z
z@5?{3WOWwVA8?Hikib0G!bzhqkH^_79pk&TC<NxYx#9NC?YnVqXyF6&#JtbC7VL-<
z_F5mHC+1y$@!l2e!*p!JXg#tg<~=L_`2|Om=g++N96-V%yK8cO;-uzyP1gGG2+VT<
z@7$`r1p}sKAJU2^cEl(D#XNVBhtFI+121xOAD}1Zy;Ai;ExgEUe1M*qSEO9JqquKK
z%TE2QM<y(a`^cBetoQ*(O*0>$C+6L6HLw+4l(jxUPt5CGHJ~Lf^J!T}W<4^2d2ZNL
zFL(M9-@<ZG|76q72k41;XOj#6jV;{i1N6ka|3%cOh?$q0{cG{ap4Q}Az{A1#iM#pm
z2+VV%=2V3Rl`&Bc_y9fa^RlE*+XQz?dD-t+PfTE*yU4M9&!6O{ksQ>2k^A`o3CwdJ
zIc)m1RJgG@?E@q*&$Tea?eNjKmkVbp!+K=GD!Ud=U;NbqY$4yET7U%RxfU+C@N#i%
z;U7Lg0`pu8E46u)gTwPb|3zuUa*$=AC+7X$D$54kd#&~XdSc$-b7$uA(-r>bU-PoE
zBY$C`Cl?+lb6JQAxsm=)+}wxfiFv(tCN06e+%_K|fqCvCzkOm?Vcc!zVgDoRi3!Ye
z7x|}O7u0c%Q2ifyun&;HJlDbt^OBF?Zu3VUAc1+Vg;O_v6yt2>{VgodQik=&o|so=
zP=@-fo(J$hf53@8KtkBK7FK-ul@i#(%RWF)%-cP;N*)Xt$_j(^$ex&2EY0#T{KzAG
zfS#Dwa`f%>4xm5t&N+adp7_D&%3t6oF3M_xcw$GNKx+<@GH0KK0sHv?3CwdBdHB{x
z7ct-wAD}1Z<!rk+Bknfyv-ZS#WCHVC3+MgXA_F_92;hJIYtqL7^b|C+4>fJWHrWCE
z&mV7>gXbw`QpN0<;=b(WEtqp2o{=RC@xY<Z_w2Mq?l-x^6$de^--&oj3DHx={x0jJ
z?L3+BzifVxYh_4Jm~)q%S%Wb%v()Q6xbw+9?a}{tso6YdC*W`A`!c4dh};=Gdn&eb
zpNvTeN{(U;JNYhO^HqGQc}eiMGasw6zGwGT5sI{5+t^ulf6T!$rl+FNJnx=wdDG4R
z{4r0<n1s6EKKtCl?^WRc7w>HSG0U;e&-d(}66H6OZ@z@reS(bXiRjhxZmEDVZ^@XR
z$o@2Mxu2ai@~37c*1tH<?kNM;IDInE*~a+0bGi)aiJEole76%n`p+_^Cp+s`n3lxD
zT@U$pSTE>%bWhYwb+eCe4zB;RFOx9|)O72`?{o89<r^;k=Z~3+$pd|MdZK3PU7sE1
z;jV{#TN%?6HLDJ;SQfAQE*X<RP50S%?D?vSQ_cOKJ!g>g?4GEZ)G&1xY-d*)(-So}
z?Cl<e?c6V8dZOmeV~64#QHnn`a~E`<-BWmO$~N{T_Wv8e|NPzARfhCL&2C9=%*F0J
zD`R@1X3&8x;x!q^^|v#mko4%Do_)xiGOyr}A0cCUqGruLdkZ?EHGey=$(Wv~`8?|{
zYp|Uan2N)pyYmS;tqVCntUBM~0J_hTF+EXpVZ|aHaV35tV|t?IqoT$6z64bFM(kS(
z-?Mw7=Kr3)Kbco|{^!3&8)QsR)cikXXBk(;_O@YAY{do}8x&hqRP63R#li$sYz(j!
z6BQF%Y(=p#umcfW#4hYc#Xhz#bIxzG?)mfV*SSCJ51tR#dG58IYppf2huND_m3NnS
zP3t16PO6n^hO~>3Td4;kDK(c^&$TmMy6B@HMkb}EZ{x9^a-B9sAv&ezPD`(R^6owu
znbdf8yf?0vJniR@NvYZD#*u0Ac-q@Tc52tWcO&e$Jf7o`NvYX6>S}hGc?X%4n!|21
z@t2tu9UwcU=EvV_UdnSc7nzir#b$IHAglQXnAEhpxIFSVeQ}`Is8%r*-Sqd~##ZDK
zw#{eB!?_rll$tyDhc%Xm^CL1THJ2aA<}Rz*qBvxy)C@YD>xev_n~+J(QO$9)ePuN*
z9HCB1%>#Lo@7At~wU2(@J0R15n%b=Vcb#2j_}hP9beZ(}bw4sGHSL4TEtAL7rUYa+
zpr)!bea;d;wHlLNbo56irRJ}K^R=%(6COm>K6qp4954+`kt);Dx5o|bV3Tw>?MkZX
zra!;_|I}1W+cSe5WaemOQfjVwkh_F@0K0`uO3j(Av%HX*6-z;OO3n4j;}ic@Ti^2Y
zkx8i;Y!y>ZZqImR8kl!=UAVVV=@D}F`lTVe0W}pf*Q=U+Wae6AQfi*??|of9&{~v%
zIt{3)>MRzM;)T3*bU`MiX8(#)Z=0BUHTMIP8qRUUdo`1XGizBD-Sjun|DT#Fy0h=J
zLo#y^G7YGybRQ6%w~O{KjjM0@3&^C@9FoH0m|SPEa*&-;Gw(EiOIf2S$TXm)%AW1a
z!Orq3AB#*%%{O&_b<n<;)js<1tXdwjQ@zyWqIYMRxdNG#nrRpJeWiUxt9|r!S~@|U
zl$v|0mPldxmR8U7LMEl=)rTAG<=a4~foUMRns(>o!)Iw_YJXj<FEdvK72U`ed5U>=
zv{zZJ<&z#5MkCXJno9SxsT)VjtLH6bQflUGa4hk6TJ+f~RfO!6nxWIGWRmNgk4yt<
zs_a)@Jx?z)-y@S!v+u_?JG2?oKKkq}DnWKiO^-AK5}#+(GdCmCK!2+2RzDw&Htj}w
zW-@1}lTtIPne{ArJl&B=so846&xZdUX8-p<dk~mZnH`+7q>;ar$XHoLH~p2cv0XE3
zqhg~pEt9G_2$=@dRJvPTKF~$uY0HRyilUK8sd?PFb)a@tpnderQdJ;3rRM7tMQX{{
zg|m=JsoBh-&6b2)hyT9bMPKK0WKwF@ukY<4&%0|?$WE!*rB|ET+LEk&^mXn=CZ*;+
ziyFnXyYkvc&&=!sby7Y5{*OmXd5-!ZlTtG#!}d|Kni0UHko7H+$H}XbO*IwW^e4W?
z)NHhAb4EG(U}PFlQ>~sYoV(YNSNXHZq|{uoz3g$BS+qK2r_?MRZ(my;Pk&@mYL5L>
z_@m5>MJA<YIqx+NrdHCoymJl6PN|t?%Z!1tnt{lq)U0>oVGVhQdxcC&%}sqRM$62G
zH6c6Y(S+Tv*O<mLz3w*92F0X0{_cu2_2eV+Hy~19opi2U=(^lUO==|uCm(~F^5aA=
zdD1r^lZxJS{)8R!RblelP$wmOy;C)($+CAuCMA33Oq)N*jkFh;l<Z|YhR>0&3bWOL
z?3C>1?JiH0$I};?l<ZG`w9%f#{`U{U^$W;FWKyz^PkX+yJf049A-e(D)tPQz<&+Dx
z>`C|bDafQ`A8)hetVwqLjip#%QZ4_jY*1zGqFwvwhqG)w72Wi^8~@)vtfJ3bQEQbp
zMM;mI3z13HX=!=-i>%Q*WKwF{WK33EW;U%4*(o(s`>m=VGdCiWQZv*3oqOe@yj26J
zlTy<nRYo_tP7h=nP*bD)_jOFp1vT?&OR}btzL$<6lT!1`1)G0wC~E%~Ju`1Z$ZkMQ
zb*39RyX^p3_YugX)U;Uo=bNnN4Pa93Svhx_f^wOTjZ}2guVVavYO3g&Cp@bsGXs!G
zsTsGj%*ljDCjb45Z~YWKM<$g$Jok%md3SHp7_w7p?w#Lpj=XbhL?)%Ci&c-rKh@S}
zPu2wLG@z!^DC_e(HMOhPq;~_lAk%=FYTmskeaa#~Qg;-Yl$zJ?Ilh+fgk*0D*(o*K
zb?J~_%bhg)P-IeS_V_k4i>&5#U{bAAH|)oFdG##bOhq^SZiO*5qc5);FJHY*K_;bU
zY`3~$vPSojNvT=<q{|$6+FhDMc4|D+<X!quW-db}rDms_WBSPl+V99Tpr+F3McqR)
z<?(cH0of@vf8N<LTxK3XCZ*<{SZix}JZ)P-os^n8e`fcS>l}_uO3lp<*&fT+npc2H
zP5ZUbLZjsaZIM<gI`@3hhfMt*%gpJ>q|{updwR$G2`ioU(eE7b$fVR9yzPURyn4E|
zhU}D@2kkRgmZyC`GO0PbJ7rus`F?<nE7VD;S@F&4mU7DvMkb}^tWg~;<<rt7WKwEQ
zu6{jA&R(hwWT(`OS!bI=o}&O{Qfgl8_&AxoYd!-eHAVllebik(fK_R$q8oX>NUg}p
z0>e7UEgytTO3gR<s^67$|AI^dYHDYM|E`V356N$@wP(_UO{aE{-GG{knd#|}^x6)m
z9lrHT$N^*;P*X8KrT+QvFAi&MuV?0UgF2~sU*TMDo_zf}0-2PWC3Ex-mzlSaNvXML
z!Yu8tP=)&zmD@vhN=@4gu_a~Z5@b?pHov~3tgPlYU{b?5U}o9G_k-xCy;%npoqN8h
zM$IqQ@^#@>WKwD_+?%7Qtb68;P^SSk)e=%@Z`4`&+rlBpG@zzpKC*cKK;Aj7BGZ7H
ziW#*uaJ$?}<vKxjO3iM^KjxDU$@7p&^^!}+$EWfqXrz7gz4RHGl$z0R^Ctc>ho0%)
z8M0Gq?&-edx!g+;$fVR<>vnL0e4s7tuIi+s=dv9&Sl*3>Ba-?;rfkN#IptQmgG@?I
zmmRL9WsRzKf#{T)!-jY3E4SxzWKwEooqV{ztmYqNQfm5_9~`Rf?%L;n+OsQUr_?-}
zCwXSMJr5z1QnR4fyjt?S=j#S_QvI3k{OoP=9F0Y$0X5Yr#BJ%i#@bjWJ=r`&CZ(p`
zg<a$2U9)C)m7OZ{-gcMITFWObGYFBCn)^#;uOd&;XJk@p?mfLejoeCYdq8vpYN{#f
z{Caa?yM*io5<dEt4@V}YW`jB_M#|aq^@KVNsHy6-nO!xxHb+{1eVt>GNvT<_$sQMN
z&XdmjePmK<-n#$1r>s#O56EsnO_lvynv+H3>>H42py$;oq`gDnV|kfR<q36CYObvH
zV3(|BZ(vf$?3+V=%Vi!yB&B9RlN(3nDaz}mqMLp_z}Q{iv-f9wl$qm^X+TXiMfR!Q
z2g}UI$fVQ^vcI)YX4dZo*$t?v>ikp8d%n!vgiK1!0=>o^)0U*9%ToH@P^SSkl}33_
z@B4Q*O1gv$Lnfu>){UK9wA(=1Z5#cvbQPJDngx5euOat*={}I1^Jvb~VAB^z`sa)0
zC??gNgWK*|ktQLv_R&AY@C1mInB#s%q?M0fPTq;Z%W<z+I_X(pt<0Q{Ollvl_tMAA
zS0^8kNe$<$EFa7~<J_t*WT#|5xT;+(tud1}XBaXm*|U8ZTtFVrjQyZaO7`Dn?$yql
zP^b3MOEdtP24q)@Qqb6fS>!seAk%>CiuwFb@5C2#>gz1mAF@-j7jE)xihLQf5Sf(h
zBZ}wxDXaMjm{iMeJvrpGye8EhprRXjzDNz{#v<2Z<b7j3GO0Ry#>K6Zr#<yRsFPCj
zb%w3~$aVHYrU5n8UNqIJke_x$PP!MJMJA<Y^z9NA<vNQGg6x!<RYR|2moGU2kx8j}
zF4@LNd5+?dNvS!{Ygt?QDBpZAWT(^&>C|<c-1A|`q|^+ZbLpCVV=1eTs*`HZxHAW)
z%ERf2NNOjJ$<zF)+)9ziG@zzx`MT~!Iu}i7`Qk}ddHW#{oyxxF!}NcDi(bpGUy&Ce
z(}0?4S*kO;+%I`I`h-jaYO3se8r83$X{3#*zRnIqAv>k!lh*Yn$#ZlNnFiEUb*{Z$
zqq$aR(ktS8!=O$|&Fmp%Ps#l`9+{My3v%tNBi~`Tk4#F<;&~=Mlhv#-TxF+PX<MUV
zaazl3AN{n?MI@zWh|l`V`4V{AN6-9&Oap4FmVdo*Y_Po2dHO<hO3iU+n~p1(P^0$I
z*BOOOYCNrT)gC6V@@4#>P6KMH>|VJKO^{nD2$=@dR2l`2y5OxH>XI%?pO9%lO;zXi
z=;4p#ow)S~$ZkMQRp<6EExKsgHLiY+b|aHg)1zAXA+qk-MnavGn$@p{?3C3U0!(V!
zb6fkHSv^l8l2Y@|zLj%ijT}a)=th1hL`~7dt)<gyQ>1bAQxt$q18OQ}Xz`Q<<!OJ3
zOap2vrbl>NFRkS@uD;GjqanM2Ia17tr#=MBb%r35Qq$*X``mJ!sm4H^l$ySomM7Pk
z+DD(=6PX6oRJyOf6xm1ar4z`c)Ev;+cbcZU_R-f_cr0Y6)La$uG>?3(IR%&orbtCE
z<}_}UHtk7U={h1QHG3_2y<Z;AisMxD3e>JS=y30E@<DMCG7YGyvL8$rxKiHXej?L=
znu?k3Pu=Qro!!Pmb^~fE=E{|a7Rz&V5}DMz*J~MnUvAGL6QE85YN{o~{=uck+96pR
zQ+>-%MJA=@oeF!k7c2|6t6m|KQgh*^sb;=?ZQ&2uDK+Q$o?b2Qnqk1ChI8qpb)oWb
zT1`}Ca?cm_-Bvolw1ViTs24IRHG6DaeMM_l?W1SzLnfu>^oHA`QYY}VkDi%!5@e^;
zoHFuKfN6^K%#O&U)NKDU?@aCDK>O&KTaihrc`@C^6Y_XwoebFx^paXanokXWCo?^f
zNvY{y$zq*6N8!k%)LcJoO@&MeW2t@g<C$s-WT({Jc)0OcQ_t(aJn0HdD!SeB6}9By
z+>S_U*Ib$Df{)C!oT{Q%qSP#tcEi6vmzDHO30GuNYQ9;}q)*0#>Cry=DcXTdO3mX3
zd>hNmRMQ|krRL)dcXFA&AlKK~1(}qZjgKVjD?g3B3z?Lfb5;-iA!pAJ0NJVj%-8Yv
zK3O9VWKwEAe)2n=>03?xcpgF~rDmN6iwl{SWWAbMrmO5!nPK1NZZs1ek(8R{hD9us
znTL=`sTsGdRUdgcv(13$l$wtp&C4m*>5WWE%?>MEqUH9CKqjSTr%u`G$!g}D3E3$%
zT?-$ymze{QNvT;lG`YK+{RA>8HP;nwIY4IS3WV%b&-dK?dW*~)j7&<+6aCI*lGQv7
zObYp9TbsmJG3Zy2T(eYk?)^m{V}5Lur+pwYDK+!0yps4ko%%W>kx8k!BJ21J@)YHs
z4cRF*8y^_*@2|~kTz#EB$fVSKmNSo|T;~~NQfhiFXpuu^=AQ%E4XCNEHS-j>pH+Jn
zNc%7P?7qmP)ST~M^|IVcmyt=S8J^5;shr(@E@Y=X>UMtWn)C^||NCfn228(?HdZmI
zPAXgBXNZZY--j;&k=iq_b?-M=4qj+pV({|Z^F>dbiVl@0Xe2Tz*+)bq?=IIFjZ8}R
z*G&R!<T{JahwRi8ZEWlMSgvyvGAY>|ZdqKCnU|4C$=*A3%_2?8q+%8eg6sxl*Di)E
zEW8Igxh-6i?SWk9WMopZ|2Q?-%zLZuB9oH+conzO^1PQ{0NE+oo4g5nrHzF4(W^NP
zm{iM`nwR;PJe;=>N$FnapYdB|W|@U5dReN@F-6mQ%FL<AG@z!|jQ{;j>ByIThim^z
z`t`v*WKwDt8?*D5eC)2W2(nXZzRT*CPG-(SCZ*;%ul31g<||}UYUY0A>L<@p?ZuFt
zQnPB#yFKJOmmrf;)Am=SgIwo(WKwDdFPtAP@0tylsO$#XQ>}E-DQl<Jjy2jxf2>)C
zNJ`C7HJ8mYo#ge*FUX|S98$ySwajd^6rxkvpU!+#TV6evBa>3o(_-gfnfV@>l$wK2
zFDNQA>o0@sl$xP8&ZU>fa~U!zHA{3#T}!^h@D`brnl+2JN^5F)eJ|Br4%sO+ErvSv
zkn3EGOiInXxsFXT)v4b#-vX0rrI^Pa59Bgy1*_=X`->`A)UPGqPh5mdN=@fcvkJ)V
z`5u{+ng`Ow9g*9!{tC!Wji-M^1~Y0dK_;bUvgTdPEFo`^NvV1L`BpO*9d%Yhc1q3L
z?HwcK@m!2dO3jgVBRu4Jk3%M<=J(Tc-DGCXRgj%hv(CJ#)8qr~0$@_pzJBf!3wb!7
zA(GlPol*yGk)u~$t)d%wzDVuvPlonOX<C)^tLH3aQffZ^+9vUJP<rMgWKwG05AE_u
z&R$^+WT)mR;6SwlGIKgIDK$TQ+B-sClJ6svQu9XY=~v}ms<0NaQ)>F>{``-eeHt<;
zHHYWC-bT(Ii%d$*rj{ovnEF${YnET9vQtxZ!#>Xn6H?!vQxHk1nLo{*^m6pu$fS17
zX8j6xmYHSNLv%{bh%Bo=$jm9oq|}^xG_aD~N_UY-srl-5o?bGu>;}kA&3j4b(k`+_
zQ;<oidFbr88giYtkV&c8rqhE$+8tEwqwmjBA&{L?^UAg@%j9{Vg-lA#^MP{`w+_9U
zPk>1c=fPp+>}548ZB)^@=Zkigx?5L{J_DJQns&e4Hp$F~$fVT#(t1WQGubymc1lgJ
z<<s}bb<RL0rRLeDmhENcLu68FwmTXcFEcBJLUyW`?yWn!NWNtgh)hb&+>5h5l<Rzo
zOiImchhANhA5E>g8M0GqPQQQ2*0j{=)m#otD*DSAw)N#z=`A9uUGwvV3{&JgV9mFv
z=-l%~xt|VhAv4z_lTx#1%OaiRRsJV3DK*3E=j$rh*=j3fr_}U{X&x&xHzJc#vq7bl
zuVsz?Ad^z_%8?^4WR2XmL3XM?t0b>HR<3g^GAT6=%=T_3GgEAbIw>_X#Z4}dCShmS
zK6*9Xfk~BlWkfwMxjnZcl2UWx@hWHKR!X)*MR%rl&DQO_8_LWM$fVTV|LN5xnYja*
zl$xVHhR%@3Gu2MWPO14K{-v1*4mu-~QuEN+MtSAzyO2q#nW;}vGY^HN4TJ2InuRjA
zbCc`rj!dfO``P%Kxec@rnUtDEM;}ck@0uBQsq7STc39;Ga`di<q}1$Eq|Zs2xfhv~
zn)fzU`64qj?1t!+no%8QW;3mH`s)}EWKwD_ifZqeIbr40K6>UJWKwF@TO1Z5ukzM=
zAUmbz@1f&U$m8jSOiIn0j~wsF%)`i})U3Pf<7jy&&bAk_8&FgG2K&G7v-g*Yt)cxZ
zdy+ZwMkeLa{_@iUO?B$uUlgU7)U0oK_u5I8Jy&>Qa_;@|88h$kk{hWXA}QI!gM-`2
zlOBmoO7@3=zpZ6v?tKuQlD)TG*Gw|g2bq-YZr=~*mcNQRgG_4LS6lUSH8qlc0V%W}
zvQx4bm{y~k%p8GCO7?l3-&)Fd1EP^h$v$YlON?A+p#zZJfb8n~gLifVAIZ!S$fRV?
z5mda6Y2(lzk)wf0wfy9KuM5cghTTCGoqK=LHMiQg<(BtDCROJ*zp>wBW;8N6HRn{R
zBWqOj5M-y++}LxBnWOx8WKwG8{!rgTZlxQ@q}0qB_%fx;EO{8RQ)(V{EmT%s<|iVP
zQnP#K3ZvzDzk^Il&7$tN17&8pBaod^^Pjl*$?~ol08FYqH^c-Sk;}Y;NNU&g@f$f!
zW|ljuqL-u8ymu%2Vwo9$Oe%ZEruA~k%m>J%)O@qnGeTxoItJM(HRmkq*ivTBLMEkV
zrrc?I%FL(8q|~f`?Y_Nf=g{x&F2^A|rRLEsqk79rNFXvPHPh{?Wu})NBa>3ox7VS)
zvYJ&QRCcPB%0%s&BTvyxL{e(nw9L_5W<EwHrDopumy*lODkmU1rDl_dyE@6txyYo(
z^Y|&>A@a`g0-2PW-@_)4l9@FlAv>jJq5K`s$=MeplTx#Jy>rWCW;`+}HFLDxctU2@
zKMC0>HQ&uF^+kKsRr~0dkYHp|YVLStF;rIbD=?{P-#_HWDES^`<0uuKyMB!?(({mQ
zLTv4$kG>L_l$urgW;iO>`5T#(n)!;@&(&@&B)!4ldJ3{rYR2u`R#=|)9mu5S$Ro;e
zy39;>8tSCf?9(vlzPuZGA(K*byxX<+a-D~eNvUaZXG(<3v^@jaDK%e4o_Z~3_dzD7
zX1<f#OeY5YwdQGH8kiz=|0~z3oWE=m+Ee?sRIgEvvno3G`)E<SW|^6y;m9<grmC}8
zxvp!qDboInzRnnAQffNPnLSy)ZBgPJWT({JcR$iyp7!y`q||hFT{J*uUPq>Zc~`eW
zeuPaLDKASU&O>%e%~yNVES8x8$fVRve{5rRtv|Joe%_xUlTvg0vk95yhZyQ!fb5i-
zc^VD$kax}Xz@&zAQrn5G<l+1Wk<@`U!{pd~a`ZMARrHDm)KsnXc+tYC@)YesCZ%SX
zjl28F*|SDNos^m>cRB8nPYi>QNvRpQ_)E)N39YGp^z9jqOiInX1D8bPN#JQ8J+tg3
z$WHZAnayt-$@9JdnUtE(P8BSXJE2DHqp$M|GAT8KZ=Wh4XYUXL*(o)bpLB7P)jSML
zD*6`pf@kIE8853cD^Y5CoEbQ$K*CUJAN_FpAd^z_OtyE2>=Jm|N6);2OiIlOr-pu&
z@6gu10@*1wE4FQ&TfQz_j!a6;Q7!M8IedOXCZ%S(YXu|aIvZbw?39|{Q*0_GGuI%K
z>d%V4z07=h@*SC!nx(`4+?4BVc@45tYVPaqeO^A$ZUiP(W^~)NwdI}TD<Ua12M#?j
zP&<5TAH7CxudC?X^F;++lXsVyJCI4K+4IRQdpUc$8&D^uX0%i5vof<cGAT9BUCs1N
zZl#mRq|~f7qH+oO_DbHHkeyQVeX)pqGIJ<0DK*zFw*G0_jr6^A4w+QX&luR-%rjv5
zZb5cR%?tNxn0dqe5MWZsbdRg<lW(t_L?orAougg6%*=ILMdyAWZRDW$dE_Y?h)hb&
zUDF2rk?V{=CZ%Q%yZmEhrtKZbPN_L3_*|TPt=SKml$zxu=FOC^vm=m6sd*^upVM-k
zHg_RArDoN`)!xc=_CqG6X8$4~jpaIzA(Qf`^3hvIOicarMK-aC*{K<7*1DgWUwZKd
zA|>YL{Jk5=&3Oos6!UC{xdmh~Gv8Ce%TPz;R1;Hmkn8k7CMEmSjBUJS=6+;SvPTrH
zUPsPueIK$@vU_id*(Ni)Ba>>S*9E4US>$&klahT%$Y4MDk|WIn$WF=LZ|hYvduC5$
zQnK%}vOg@(`#xk+vM>3uGV$+|_4j-;JXG1Kmd_T_aI0KqS42{3_S=&)M4qDE$fWAD
zzwd13&wi~RL3B#ZVHMXVzLrsc{OXBJO3fLg-JZ+ixfhv~n(5wIU6q;X9z%9Y%>t9M
z{YaH?38Q`V*}EZ=Qgc&-z>TK8NYC7kOiIl`1v>1OnJJz?c1q3T(Rs}Dd?#d5YF=uV
z;;MZ0x&xS0dwxIgcD+397Ee|5a+I2POVl&-?Q2_PQflsObk$L=GZdLr_USG~3(3qs
z$fVSK-XVO5%xv=v#*<R>z>7R){(@-}GAT809`x%jxBPEpQfgXE``KB3jI_;j$WE!b
z%k|?Ic|5lwlTx!^OxYbWGuaEMlTx!n`*$BrCma2)=>|-ym1_CbtR!C@Y(k^~HMQ?B
z|NHBMYWtl3eVMT~P5RaI7cwa|kAKQ)CD+;Jr5euil$xWfSoYGs@X<c{IyWMd8qYcL
znfAzaen%#yW~QEXrpV0ZuOPbtHPsvy+kJYCb`vP+9IZhnrDo66=Tpip{|%XxnvL52
z-Y4IzY90sKDK%p=2i%pJ>yb&Rx##NIW3rk*fk{n!*vjRT<l$`oT1DrcFB%;7?7SR(
zEix%J^KW`OMrM9TCZ*<@z(?U)vuYo`nyubIc1q296(Tywb#6r_HAiXBxZaWH$m%WB
zX+TYF5&G}Fw%JM@e<9b|0hyGVp)Oh5$aU^OCZ*=KMYYYSnIaytQ)*rhzPCco-Wi#c
znm5aZ?v)R;yMReeQM=56X5MR?{GE!<Jzq3+N^EI4dPihZYCe6sEmCIgL?)%?;aeA{
z$*q+7J!GfUY*hdFRk==gWKwGG+0gx!T<30NQuDqzX0Dk(1x)h+vQui>Uc9@|)SmjK
zt{XBbHQ%0ftuBAPwG)|?n)z(5nE87n>yMC~Qu9gls=@NE=?P3~IE(ZwP*ZNDa6}q7
z(5e+Vdw6a$e@blqNk!+LFUlIXqptjIp(ipaH5=zybV1I37@3@!yPtlSztPS18M0Gq
zMl>AsO=b>6CZ%SHuD#aC*P3UMN%c~IXVIOqM)|)$c1q1HSDfa`b&f$MrRJGi#rJ9_
zCGDeMLarc_Qq!Z($J(-*rT<acsp!?4U%V+_$4o#ZrDmSnz3t_ezlKa|*Zg(5Qhs@g
zN_>Ur2GrCh<iBg;X;Ulb)tE`IxBQVwsX3;uM^?Gco5-ZptkBf8g}iH)`Ucr4HK#tm
zP*R?wiO8hX%)0hKBbj*{nN)wiUbkhtoW1OK$WEzw)Z&_%i;gMCq|{8AfBYs{%~)Vk
zWe!+0+02VAO8-#NohdaJZfdqbZqF&mq}054KD>^+Yu-hs0X5a`9<uR5yxdAoKOsA%
zX1a81{>aQ3$fVS~z5Iij>+DC!q|^)!&O1}Cv+^&<PO16RZ)RRuqdCZ=)GS-wXSrPG
zQ)E&-zcZ}BcA4q&8?sYsZl4sM$#j_4-=UokObYoaRiSb6a6U#PrRH+Sre@yl>ikDV
z=bkTGy!ME*Je+~Zq|^**^Eic^{RuKDH5)m-Js{Uv*}~Got4}}Au4T(qs7$Hp=oZ{c
zX3jw-rRL*Dzt_sypCgk}GcLH*ahd623E3$%ugAZCCug6FOiIl~wP&w4X{0~UzCb4B
zQSV(2$4sYB{qseYlO<-SMl*C`{C;^Ko&iKk%wFfxznAy7SVU6HvUdh<l9?5ftKi)8
zMb#%wG4t2+fyks}cYSDkT5hB#$fRVSe6#pdIeS$r$WF<Ap~3!ia-H*$Ny+}DToW^Y
zKK}}tRD0e@;b7*~0ku*<c1rfSqu%(+3&>(*QnEi7blXfXy+I}=d-05irps#9O{ua|
zN6)vzytB*Gz7Ua=n%68An|XcY8)Q;-TCTIOl#ktYQ$ch}&Dd%_tz?asB9l^cNBhT?
zGV=p6DK%{>eRGzXjZ;H*18S-(cc)pIs@Wu5x!WeWxv~bCl$wF{b99rRE3-%gby8~H
z&oSCwW_Cm-rRI~YD@)0}v>Ta}njt@O_?Y%~{Si5BT9ut@Pmh)7|Gl~LU#U3~Cd%~F
zryUVVsX57iduP*eL4O3<flNxx3X`I@$ir!s4x&@p_oQCFQf78UCZ%TaY}3uW25bj1
zDK#UUd`ijVnKC_OH=w4va&H{;{h*ob$fVSKR(EhanYja*l$x`%p3840dj`l(skyS~
z7Bi3FcSI(o=BR8(tIE6P4q#HPRQ`*7h&-IhtW|XG_tB>I+dE6UkDByeYI|f-YWn52
znJ@1gJCRAL>5!q&Ntu}@BV?z>bF|ylH!`z3GAT9V23VQ7S+yUTl$vEfc|6w^V(p_}
zJ~L&4?39`p2lzgfdub3d4XCMh_aE!;^woAv?dvFgol(f7)C`>-<|yl)KQm;f)cmpd
zb!u77p}?f3ecRhqRpjA}LL{|oCaXU4hRn>9MMdX+AMN?pbVcOh^g$-2=BUoC&dGH~
zA(K+`#?0GAWoDkNke!;Nk)K9Ak(oZoq|`i}qx%<m`8<tGO3fxkE?<!6s6aNzZa_`7
zyFbcVv8yJk_R*_344IUgxrU~zDvxIjGAT8;jG0@)bWN;3(AsBL*{LboyKek-xy(_B
zq|}Ui6zL*==^lejYS&DetnUeV+Dq6#bV|+WDEG5+_VLK1)SUY{Ag$c;*O5u7xx_R7
zEBSh>v@K+(=G|{Xelu?)2tX#K=FUISfpVP>kx8jJ=hC<HvYJ(MKz2$^=csy%W#%Ge
zQfiiHYI|PZH9rEA8qP|yFV>JXs+Utm=YAh8{z^GBZ@ycFOiImMK6Spy&#wGHCZ%Ry
z|IS@yHQVQc?39{2Zv~`~$8#GpDK(3(f7(i}Gfi%&lT!0f-b?oK64Di!R4<h}9T=|N
zR!VwnX&*8vHQR^VrjRwV%>&sfHCs06bWyHz2r?-(E$;nxk$26@z@(yEIECKS?$l`?
z{ehuqUKO2te^Hvi?rmh|BxF)*o+;7HUvBwF$fVTVUiDmi`Fg8bKFCg~dG|}~dih#2
z7@3rsc~TY&lXs)f$fVS~UT*7U?bxV&^z+`r4zg2f+PH7LVQNo3b2T!l{_OiaI)Cbf
z8nus}`30GjngN!v^-MdQo>@OXWT(^|-+F6CQ+EA<b_p=4GBX{X*u{j@m-z;f)PZ*7
z+=vKy+G`h3(Yf~*b^U#+nEWMA5Hcw>zvrF%Uam6^nUtEg)%z`!>#SA~vQujIT->d;
z+@3+mq}1G;a$Ze2`x9hRYC29oK160#ECkspHSd0SXXcgY(~wE^d~n*T&T`M+M<%6a
z;qv<u-)*5+)2Xn^P9fjLp6@TW(iB8eYOaooHuD#DvB;!$%{mWLy_9z&ry>xYQgh(N
zs%K^9Ok`4O9_i4xq0D@OOiIm?g*use4$7q{WT(`O?D*oVJnwUnNvT=)`av^qt$%?`
zO3fmjKbd(}t%f~hr_^kH-ff1QJqVeUN4?kG&S<*m&_7=kr<hdom`2-<m=+Md>@^$`
zlXJ(}!0WlEn~?f_cs?R2*~dQayHOs@7s#Y!pS)@J3%Sl3#UMH*`>5E{dE`2SkV(nz
z_Tf_vnHh&nO7?k8`#8zjYZr&?l<W=H@2fA@xd@q*>`Ti>wUg_7i%hEJYc=1sMqWJY
zI6`(x_6wCAoaIZnWyqvtZ*}rlpeegv&2PY@THbQp4=dC9p;xn62^F3DeYEh}IR=`_
z)HBy2ld7{#$~kT1R{DxeO3lhWEv;l`i;|F?QnNte{8?n?24qrdM!Ua#DPLv(LMEkV
z!RwBn<d%0Y1=%Szz2?MEl5Ya-K_;bU=6AWw{Dg4k(oiR*re}e+o#meIjZ8|-ckjFH
zH!<~U9swrRp81kDG4sy)tYuVm?)^m{KKS*PZvqWMCZ*<;Qm!9m<~d{<$gVZde}A}k
z{cFZBt>tqjxoJ_fEM%wDod0QSGI?2=f=o)ytbV`C%FH{+q|{8c<F=W1B9$oz*(o*G
zZ;48LQHXv?o{UUN&8=7ZtdVa5-9#p(=EzA;Kgr|iSRS%dYF@n5*xK}Up<d1Lz@%E~
zd+NQX<T9@yk~+}3A1n3Mw1ViT$iYcPFHfoYzGtl$GIK044XCNz`uOifA%o+y+>x1A
zkx7kb{!f{`WoGdTkeyO<*TJpF<T)CTOiIn{lQ;a5TmBj{DK+hKL|l^Vbf^f~DK#(7
zp4VDtjzK1+X7l97yUWbW$fVTl+&beX)4c1|w6CPHQ`5d@&@&%-ibf-nQgi+4TI1#D
z(a5CKJe;wSnU`l4c82Jbnx78THnSV~B9l_{TA`wekAUfyrSr(7<|wvvfVVtHc9kJJ
zrDp8r*bVX=`5=>0vyk7L2lCfOr;tgh>25!3fm~;SDv+I0GxSwZ;sXczIU0^kO3l0X
zIxm&gJOfN>isnC`H$aY_ud0g9y}u}H-{bBwa|kjiHK)HlW#%`nP9u|2)7rysq3IB!
zpQ2(ekeyO<Ud;kFa`rLEq|^*f{U^6++Vyo_MkY1yH=4bPlCL!#szG*2P2cc>|Ne%Z
zcHyC~b38IBHMgaE+)kdOJIJKee4EyCjy#^Ft3!55&8Y29`<d$0@0yc=Ne$<kA-Ce?
zR=SBuYS+9uWNHq1l`mOCMd#jMv}uN8N0~VunUtFMUfY;y`76kz)O@<+iJ6zA6srl@
zDK)b{3-*y)X&f>sH8-EGXy(uSuOXA`r3%vv%5@g61=%SzTY1(BH?{o#=#ETE&4@kU
zf5~-TMJA<Y;K{CzCZ=A^;<Z(FD*6D=!I?}*ee`jNq|}_Xbfc%dB40x$wQJ_7{dK=Q
zMJ4M%bV^OzR9n)^*(V^AQuE*q`-d{~1~Mr%OP$SoNxlVEvMyw&)SNkU&L;Uz@-$>p
zYIb%E-7homBa`Y+`@%EL{OMZ7dXSw`(>r;E_VOIfL?)$XhDPagn3#Gs9|4mpbNSG&
zZ?!v=N$*lts;{DR?=QO8=(Cmlz0qQ1Qfe+ene&DG1;Q6(QffvW?;RvR>D#UWWT({3
z?%<tUK85T;CZ*<-0_*+cmQURf>ZH_k+xz*u%<PIxO3hyTj+K^|<h{tG)O_wVKab3`
zZUot>o}X2x;C^}Dy^u+%nPd2~#ODL_YMuZlg$&y;;f*{+wvAQv%G9p8b?o}Oa(fOy
zCZ*=%!~UJ+I!_>zQnP2-n1M1gR};uishQd?*<qPE7@3CE>^soOEyIkb=j8D`jZCHH
zl6z@Ahxw(mu(bMYX<=cdeO=VDiDj~U$^W}Mtub#+Yi;Jyh`dc9yHe8tvxAjodO7=0
zWGXccFax)Ks3J4ZAycVofVtZLVosS^uo+}m9{q*soiLs+90FWSyQcp6q7jOzs$Bg4
z&yYr3?&<s9bP1=I{Q?jTi>Xa||C>d2%8g{#JTbU)8O8idaE<wH$ptgd7Y#+GlHCAv
zQ1%te<Ow>5OeMPkX08FwwsQ7@Eg-v+-2n5*HUDmMoxaFavKwG#$-HQoT<1k(QnC-M
zefg1GXQ7smosxZOT(1+R7lr6Aw?-n9lD*ZQ1rOyq&mmK3WMDj9E?MoAnFU)xc1rf$
z*8-NB=18yR2w<v~|BLOKMm4%MYHC92hw}m=DK*y&5A`t<y|s#7R@G@>IHR*xEhsZb
zAd^z_<>Wa(W#%PhQfj^~@WMrA+Pgw_O3lfZd(3?EJQkS-)co%O4sG7urg!w#j)_VC
zD(WgSDK(>atV<~$XUn#M?39|*pYALmk7ocfDK+C(hMQqNKqjT8Q-|A|OdjdgtkhOz
zSM6z5O*KUhK4(j5H!ZaPqE~YUA}KX5)SKWXUmZL{CZ*=3m5pDSjv)Fv>$HRDD!T#Q
zTV~C9OJ*)XCZ*=J4lRqxH-X}jNvUc5^LLY63G<_U^w}G`L3RUbsw1*r)8M)Cjk+z!
zq|~%bovXJzo)+z)PD;%QlNxoBneC8Csd;hS)KYSPZb2rcW>Bu1^W_6=nhq+vY9+I3
zswuJ=vu2g1Wl}XeA(B$_NttiI<drTQnUtDMvUV(ET9x$eY26W`Q)-^JJ9$s8vnMju
zcpA{XPQTA)o`*SrOiIlqR#9fIvNLvq?39|`eY(ZUE$@X)O3m`)razK*%|pnf)a+ps
zeN?V9TW82lsoBFLz*Vl(8<~`vp0#h~F!iT?*NgzBnsx(fK6-Jxn_Q-iyNV9Kk7l4f
ze^jZG!BnPRqXEdI)cja)ftiQ!Pau<0bL+%MX6}3D=mOa(HNCC7ILo>ZM5dY}1LNts
z<JtpxJfo0FscBoKd#GGz?yiuXQghMXa!X{U4>Bn=t1dtARnC3}nUtFGhqfJ+>&({;
zvQuh4y*NGbS8w%d4g;o|A_Hocf1Ew>@>Q?V8AMXMW_8Ek)yzciuA*0<)I1Wh)mml_
zLnfu>-N<`SW#)NgQfj`7dlV%z3-y5Pl$xvGJ@l2CBax}*-GJ_?dO5w5Z`s5klTy=d
zXJ0cv&rz@^WT({Z7rErQoP7i`DK#xurw*5ymyk)RS+GvUm!>5|ucp0+%C3gffSM&1
z_AM-zISP>m)Ku56BO2Sb)pp{fFXX(8OiIms?S~(d>n!dG(J3{DRD1qfW==pRrKb0)
zLNn!S&6~)i)GTGu?W6oHad|JuPO0gg|4F?3{-XKFRJ~+C_o8K5hR9FlzD6dcW{xXi
zUh;vqelN&Qskyl8!?rSWIWj3VUFK98D_?7V0H%s=R!ybRPTR&WwJFltNxy5>?X9B2
zAAB2_qKNT7v&**_f{{t7d8Y0oGcTolk4#F<MyGe0d2wiiK9HSK^K*00&+;vXU}PFl
zQ_Yc6ahG=5tFV$jX!0GIl$wu=SjWf@uXON+?39}CHbuJ1*$*I7^{0Ve8r~`W8~HV0
zwtb;aO3iY`S5K0&4@V}YrgguxXXRb<1~65bX4O=;ff{^>Jt0ST?5Co`^F;=R({_Ec
zP<fS~j!a6;9%rr2%gk5Eq|{v2{QWq&l^XYl?39}OdUo=ar#%Fj2Gmq@bhGNIEx8la
z)IR#<GxY$dlTtG(S=)mJ5_sB2&+Lm#O3foKsRHvQ@U)Mfc@>$Ink9EMdY(Ulr+xIy
zDgz<A>UjhG*|k;0J$Vy&+DFe^gG>Wz{<nN;j~v8rNk7wcQq&)4Qw>seDx?85J?~%M
zEFVI;Akx5rR<%;!x0@Twx0d!HlTtJ7xvyppHkk%PbV|*11MV!4>-0h<rDn*HmVPqx
z2r?-(8@#S%=1U11AIMIrdGBtZhg@erWKwGSq)!<jGb52nsoCjDr6~CVA<q!VPO0f}
z+4h#aB>N&$d1O|1rKVet^mjFnv|9Dg7hP3MMf{7In(R*Ti}T1w<Pt*@lN*2VPx~@E
zU&RsS<=|rxNy(l*pTC*k^SXmfO7?T%7t3lxt9|rqXSrbzos#`n^AVNhtJhh`q-0;W
zd`oN76zS`HicCuOU$*vU9wu}i4%sQ$$1EFa=3Z(bGAY^nxVGGGIwtC~KSCxY`>=FB
zFUjLs$rrLyvX2?+8YVNRBU7nqR`&lkI8Dv2zG+68vg`NZSYWD_|BLOKnn7_c)+VHW
zILrE}=<xoczm%ylAEtcMTE1|ff=pGX0cNxH{<UT1U1U;fUMLnbSZ0<R0of@vW41OQ
zD_^-!LnftWo+A@J%5~mFCZ%R<d;2u<yq6mZ*(o&#|7e&~W==&WrRICz+{I<)U1U;f
zUT`lzTUN8|D9BE!dH+YphNe38YEA;CYEJ`dKJWjJw+X3N^ClvxUDNZ%-5zrElA~4h
za+I3=Hx99ond6bEvK!F-;^^ML<m^|FNvT;r(yFt}bQlBKDK*z+>2KyJKL(kUnyo^7
z!{s`!A(K+mW^M;Ff3R45EM%wD9N_W%YpR5klJ?Q}r#~_&H6L&4kW*gjVvtFxnXdJw
zv8M6Vt7$(@Wmm0aK+S$m7QN(_AB9Lt%`6@ni<-*R59dW>QffB791$w-Muo;hbV|+G
z$N4YGOkZTG@id_O`8lp;vY$gHrDo9N@gL>!%s&CLQ)-Scd%T6*p2Ltyskym#`4D+L
z&mogi)A32SAem|B57{X-Pp``0r5#1JkG?;LAd^zF^ND|~OdjdgJPAxS?FQ7Gcm9N#
zn*p{HRdnw8qLF`kn)xlWfykuPoHqZTkMa$$6Ue00{63_NjXdpnCqZ^f&Ab^)6qYp_
zj7&9026T^nekD?7Mj?|@^H>M#oAPyb?#YmyQgd$Y41Hv#4>Bn=CtDsKE8k-{gG@@z
zQ#-8g%QwJ^Oo8l_nj!C_5??l?S91(7)f5>})85i0LS8*%5J~Nt3pb}4AV;^Ks-knx
z7quT#&t0DOamb|99C~rrH@W4nBa>3|)4k%&<T@RvL3T>b9t{^%mzn;^RP$~?_p4Pu
z4wtjvLMElA-RRIQa-F3DAUmbz?%w6o%XLmhCZ*;f+vSNG>37ZB$fVS?AG09won3l0
zOHWtX)o>b6bMHg1)bemnL?oqVk^8-0%ik8>Mkcjuo?AWPv^+&sXFzmH&97UF9h0-q
zK_;c<iF>6&<vO1ulTx!-l@Yb&I$dT$c1q25qbt>tAN`w;Ow~&Ubho<I{HnYpKS3s?
zX1RG~&AfQUB@nVxYG$)q+DjhK`N*WyY;&l+mwcdo1xyv)fSQFbtuphMl`gYXbnf}0
z20JF0`R(ZW$fVSq+%aObJngTLNvV0I@#?}dv-WJrPN~_vWuxpeb15<@HB0tw5hl0N
z2V_!ehP<6SS^m<j(HzK5sp%eB%gn3VHXu{=rvcq#8)k8kPjx?$NvV0Y%i)Idg-q+Y
zkeyO<xYxqhrX^XwYi<ChD${_PGhH(;k)wY{q=8-Yzb|yPFHc6ghNae+NuSDXIZs80
z-$yerMd|O?4wdWNfJ{owirZFhlfNMUiA+k(o(=1*kz3wvK4dqbrW()McD7kH-II>z
zZe&tw?j1iot*m?cAgGg4GtJd=$K?9~J&{SNX&qP1%mu<>WU8Jw&`Vw4RX6iT`Pmjg
zc1q1JuTI{V)$9vQg*2e%farp|<W>GCA`Pgio-cY{u5SrhBin^4dSz<YjBgg%TxRx1
zCZ*=W=;5d3_B?@1O3mV*Ctfy9k^VX+*CNPnKutBCRr=*LbIWERGAT6+PA{=Tt}_am
zl$vor8g-P%GxuW1PN})&`-aUj(+8Q9nid_-9F&=7kf}WSi|*PZ2OFZEx|?=l{qsfn
zmzc7{(*b`mQzHfi>`nZkEd4(014Jd}Uy$0KIsV$xX>#x=L@MTAf@@6was6t@jg)t(
z3SNeiy;beAX7&vqWKyzEj;n0ug(hc^Ny)w`GKHNyp81zSc1rd~CAQR)$I};?l<a=4
zZG+`H&m)tPeZkV5kL5ZGEr;xs?7ggVK9TG6LnbBr^J$H5$joSDQnD9HTQBifZuDvv
z4OZDz%NtPh`a2IF`38d@A}KX3Q>5A`@9k%hsp>SK`|VbJ&HR*XffW#)Qgc;Vt5Wh5
z`5}{1v((NuE95^2i$*4;=FoBt6Mw2ezqdQAgzS`>p=G)cm9vjUCZ*=%<e?Abv(hzW
zQfkJg$Z$vQCC62eol?^&@aG1ZIT4wZn$E><C4LR3SMv@qReKsx^O#Nj$?|ZPUag|T
z@1q&eXx5=OX8t^RGBPPOAKw~nFSpWNWUA~2>g?0yNO}2ctNa?sPO0g9*L|LRMI4As
zO3jQvvfPlFFOW&8xnSD<Me@AYSqs@IHM3j2S|>A?Ak%=F>dO6Vp;5E6e`$9F^vhB_
zGAT8az4y(mF}07L*<>ALr_^*D_A2pr-1KUO08_P+Sv6JkE$!#dGCkF=FY_BBsa<ox
zyu0U3CwV>7b-juXzmH}>qq=r4v&+*Sf=o)yVsF>^$vfOHWUBErP-o=)14ZRJ+iigC
z2Gmq@^e*V^FRe~ZPyKjqK_;bUr`cP~yuT<#2-Hcb=}_46h&=C|kZC|ob>&_)<K1NP
zcy31~rRJjhZt*fR#YV_ZsrmA7K;n;D>DBB6Of~Ih)l|_vlkeLh59fA7Qfk)jZ<$Yy
zo_v#v?nLdH!}e8MCTr9InUtDER>eoi2b(ZtQfdy{dpk&GrVWMcYK{!(Uf^}fLo%}m
zGAT80r#WioX4L^?QfkhqUbBU~8)e=M*(o)Ter{#v$9elBlTx$h(&Go^o<D(1O3glH
zZzukan_f-ZEh@X3A_HoUzxgOYZu!25q||)SeqKA78Hr3v%?hs~Lu6*&tq`43^Zu{`
z6XhjjI5H_UhpZ1BAT!S+lT!12eXsm-_JZ3WyP9_cx~DzmYvzZYMj?|@Gu=RUcR70u
zGAT8E<6Pg!+3mMOc1q3F6;>zSpVgm2#v_wbvq$ur{ia)BdNr>CQw^s9HT%Yw^p}Uz
zVTX!d(SVxj0OmLU*c0vAAn7ZT$0Czb^Hhxu1LZpJAd^z_b(S2i^6FW3CuFD8JmNlT
zh+OAnWKwEo34FIgX5K+2rRL3xr)}gNu51`&SG{CF_qeda%jIAA2}CBPX3VznJ>+km
z<B&<IIjxlIaQPlX!(EV_Qq#xR{<-{o(HdZ?=myk$9W`>Xe2d`|A`Pgi4#~N4j(jG!
zQj6UxdL>Ftx9TTe$jtS~q}1$EE~T|R?LUx7soD2tmJ4!ww%-HUDK*P?&*~(<AZ9Nz
zDK+Er6<#2#X|osVq|_{wIcEwvyALu|e;Uxe{`J+j<d^tdLMEkVOpSbYvYMsCAv>k!
z#eNseykR~7n5s+zYA!iG!dIU5SVU54Iy%jJEWaP7+CCNC$n!;NCw`dMuaGwF+S9)J
zL&zFrQfl7p*)WTI*Vke{)Jds1plwxmIlCJ&DK!hN{Cz>L^AIvAHGQl9-YFjxvmSu#
zl$v#C?RX?J`yrE3Gw#sPR5J4<GF8u;)m`;c$H(6GS|25Se^I`JkeyPq`GXaSFSgYm
zXvYClAq}Xx-p*;E{KEoQ5J{<d^6vF6@`_yHkc!SdU$pH{^ZD}bJ{Oskn&l!&G?u6R
zH8LqRlX)MElbQ7nLv~8d-j&9hd0*@bWKwF@D3PVEtovtVQfdZduD(^?jhY^T?39`Z
zoic5cZ-H$<rU5n8sqS^@(HUgsZ)7Tu%<BFh^WUd|_HJ*e{Y(4kpD${6G%>q6C;r7u
zjW{y(w8`=jc>@rYn14ZP&jMALeBI2CrGG`FVww%E*13~AHa*kUxuoyCb3LYlbI%v~
zH(C5#J}>M>CMA3Ag85R*$FFS1p-xKn?6<=U$j9y>$fRWN_SGkieDu78OiK2EJRerc
zVwQ@4?3C;|_gaO^?-87aOarp3UK+A=@ll6_UMiOG(VxHGB9oH6_Ox}W<zDJ?0<u%G
z+x-YO^UnGsz%*>Trlv>td3EIVI7_4|6P{2stEO7#%8&g0KxXzqrmE8b^Yoz+59L-m
zhD=J$JbQfY<nuzVlaQTKGb$)qh`h!RM<%7_+}Q)HWadR=QfjW)RcnoWt|=M?*(o)9
zWiHlJUX~^xlT!2Y$)<C(Wl38?^=jTjrU5mT?z0|WnXcUl(auYHrpqbFPN})l_oA6!
zdYK1I)t&}+&4H`Cbd^`SXNWYgYbrIr<}BDu)~M-e6`gy3(aJ0<^U1BW0hubh0p06=
z3ECv@MwVxwPD;%T*ItInb#_H2rRK0tf&JxU_W@*5Y6b`NJSW$g^(<sJpr&g1Nh=qn
z*G@}$lC=B)WExOY^^)t5L09GFGa8u&)Ktu7R+rDoOviJOol^62$zmr>H$L@OuTz1k
zTFHQ#6B^q&%k6m=k(8R2QBBjy%qr(qbnf}0ma#1k$jrsaq}06BDo=pS{DMq1o(6PZ
zS>?$(x#injfb5i-(O+xSly{@;$fVSq(5(JJxz6+#p-uy8s+RBBsbx#K&R)o*)C?&1
z@|Ij@Br+*A!_He=mg}^OhU}D@DVK-&o4(r9t2r8&YT6B`S+1t*L%GaoL{e(n^l<Jg
zuSz8@sp#DEMK>;7jFvT;hD=J$)Y+E~mFs+lOiImB16JRc>#Q9E+0`5w(A~njf|+kM
zS0R&9GxXbgce&1=$fVTVwbR4Q&tP`E4B06)8(r{7F4wsinUtDaqoR(=^PcSr)Jdt?
zVOITX@~$}um}-g)sJVWBpIEuflZd3$Y=7qELwPt0TvgGz_ZR)?Q}~{|dX7UTrRKAj
zt8U24(rsi?YBp{heM)9lx(3-PHP1#Z|0FYmkg4X~fbK857c+DF?>#apHJ8P%tS8sm
z^g3jx)XaP0T~WC|HzAW!GxTg+pxmD+Za|%snzxc=PkcH+ziajcrW#HIY9`;^y0RR7
zA0jC=Q}&q@EJx3FQ$?>x-3FTS^u{)s>4QuIYHDdyTWGhy){ZR|r7^X;b^6-@myl^d
zO~pL7xo>st>#d~MTcvJ6c1q0w!}{iwv(G^$rDkUDpo8*V%D2c=y<|Xl@1Q5WWi^}M
zhU^B^RO8v;O}(btEuf@xv>BO{niaB6*e{P~+B;AurKa`cybt69ZEs+z=mylR*00nZ
zxy*xzq|{7%s&E#0igMmn(Yfb~@}G>0lj|IgOap4FYoiqP-oBETrK`v^pr&H_g|BZT
z@9t${Av>j}^Sm?>@_5cbCZ*<pqZ^CKb-q9*rRK@vo@VaQ*0~4SReu`Ly-Ojh#_}Ak
zLMEl=)2ZKA$jqO}q|}_2)5c9c(6+y?va2!;sJUZTax-W7t%#)5%<;stlsxU}9zdDY
zu32qM=y16`y^u+%>He#yr#wX`kV&bz`)=lE@<SnZ4<Wk&HMPqA+ui3`-~FZC`Aqt|
zV-t``sk!D@>92B~kB~{J*`>7OcX|1&`v|gAYJOfdE3dq}uR*5jc>}uVuHLhrTxYV!
zP^SSk|C=N2k%RDw)BnBWt^F7Mfwmhk71Ds3nO1I2Eth!!k(8PXdtMnXGjlvq(Yfb~
zhOa)AOlA&8CZ(oVr<kJhv|mLgrDpD7PfKYUX&?O|+36`{H=w54i8p3iSyx`_79f*S
zb8oL|on+=aWKwFDKje8uUh0}WgY1-=v5)3B%JUwAOap4Fr7rLD4Nv5Yjug+KPUX>G
zbl22O>p8ud=|HQ0zNnXCs_y)YnHn+mf_fhEKD-}@O3c3?wJW$QL-U*Y>csj*V(@Zh
z6!R~^HRk?oo43gl^+P7L4^OI*YoN?Lk4!b32I?$7B7Km&x0iSc*(upwi=TfhGXs!G
z$sQcJ>YLo~&yY#U-oLiXQMt~#uOK@md)mEjx#j1zRwI*=z3sI2!{qE1aZslL+127%
z>*0w=xtF>ilal><<TX3_57&+WQ?<MSHQnyC7$cXN<+X~=Jzvyrs&f^2IDL?*>NKEH
z!*@%I$jnQ~<kbArshym?)EmfdKuxvA4=*0?tnI=1lkCH@kV&bz?2p%0d4G#XCZ*<4
zug(``jheiL?39}MD$J=PKL-_xOiIml^F!Op^PVgo>ZH`X*m`*u?Z#iyn}6MqNvRpp
zrNM3asoY3ls`fOX=DLvP0rFLh%{vv{$oq>_dp=24^rqIHNu&EAlTvf-<c%NXzdE^v
zOqJcN?yAlXz27v|)YS6pkF(X^Lv{mdsulT7&I1o+-B%!!QgczY@nhs)_x_DcN==7S
zQ$EQ@<nA9JJEi9LS39lbo%j$kDK(GOe4SNh=KKhCQfi)lJ#W06eK;~HHAnV3kWt<>
zV}Pkz$$*--J-#~2(TjXi(aTc@+V7Wq56et{WKwE|ADPolX5L4p0X3CI&#G@Wvvat7
zhU{uQ&FZe0^|J3cA@4@ZkV&bz<?Hc9@~-(EnUtDg^J=}6$FtoR$ZkMQwbUJ+daSUv
z!zEqnb|I5ev)7kwC*`{Vng4-0DK*FJnmt1vPakAbYMw3dVxPQgUIeC^b^~e-3);0z
zZl(NRRdgf2kEW(*__YtywVfmB-?EHDCZ%SBd=vZTPhe^v{SJ2@nUtEFu8$ibw`YTI
zkeyPqQMSGrWac_#syQ;Cd(BZz+sf@}`5o${)ZA6md$W96>VZrHYN}=Fcninsa`s4M
zQfj(a`nFo$;R^hK?39}Q?|1nv*Et%Ql$x90y$Y0f&0D}!Q)EEREtP`W%7>+rKUMS!
z)UKK4#A!3T(Hvw_YPLMzzp%W7#3PeZv;XtEPi1EFUyz+r(=uPy8uGMnMJA<Y`35_e
z$aSXu4Rxw{H=z6Gdd@lIYq&nhq|`i@X;zS2=P6`TYWlYcnJw2@^bce=pr+b7Tu=P-
z@A9c}^~?MuWKwE6j^2MnR`Ve+)o>b6Gw@fjf4_y(R%Lye6)cijc=hS$*|luhaz@@?
zq*hP&jlK)y>#c>zq}2Si=-NSf+P@%^QggRwg&y*>x3z@ql$sCL%n6iN`CZ7Q)ZFMW
z^rie~d)CRIP6KMH_FQ-DSFm>Np7h&SPh_fIGN5~*k)s#OyZc#WQfhvzS?hw#bW9G}
z4XCO5vu7n+Gk20_B9l_{_4^c~Wi{h~siGTDGh>GPwsOnYuu{>v-$x5`ubR~^VcNBi
zUiTHqq|~hWGjw_J1fKTMGgG91Iw>{%+MQS_GkuXssrml?I5U6v`x2Ryn&DHD-IV_n
zuu)3LZa_`dp6(}FUzP7tZbv4iX1<$s^U3p`H5JsU`qO~!YbNCil$ZID$fVSCSi8s1
zF`<vNkG_{~Ba>3I$L3UR<!jAmsa1AWrU5l=yU$u>pHQOq(U-Xrkp>R5YDMn!;n^SU
zIwtA0rga)9lT!1+sUmjr5;6#xl$sXa$IY~SG%_hQA3W)>PS&VGTF6eR`7zplc>aX(
z)IRz-T82ymYN|O}u*kKfre@ORGkH3wlTtI_YNk8#?%oTTl$wX`-s~X%HSrN-s-8EX
z`{4Ik2g@g$9O)rDrDo06-u>iVa|kdM(tw(UG8N7te;0KMkp|RMEAr@bu`#9<MBhqw
z8B}!c`J!~CY<8wjXeI5VXZj$MQuF&9hsRpg+DFffKqjT;%E^=b<!jAs){vc2v*^OX
zX5QU27?}ptRCBbg;9+Y`RPCeBejb?y)Kt2E_?hy$*790@J<}m0WT(_THT$ZWzbc)G
zOap4FI?pePtSs000GZ08zv!+#4K)4bt+Dd+MO8B;W>=l`7c({Dv3r%f%CZLnQHl8%
zr1mV(w<k7co-=ufNX7h1aE)0z%yXZ-&Q;H>f*W~%k(!{qBbIE?*5jnjxdfS%><($0
z<kxsfnIDm<rpRn|RcCaGkC){}YLNx9Q?h^WTA+=*fP^B`fb6PH&+Lx1wX4FUXQfnG
zp-uy`s|BQ`*SARdCS`AA8jxMpd7?<_M{=F#kZC}6Rp*y>w>{)KOJsxWl<eMDH&!xj
zaQf$bX9H6mJq@Ut$)-;~S)+%DG@zy$&ZXTvGHX{HNxw03$*!W8RdpI@`J+Em?3Isn
z%aKW`IeqqxGV;}yg$>k6shRV9Q5(6=UdW`>EOGSH9J$VO$TXm)YR{tC3U8AyIm+2W
zb^~gvd7l~Q9H+H>(wkLtk!e6pRp<W2ulmcE9G{SBKuuNWimAoVYIBtI6`vh*Kz2&a
zxhJc<m3Pe}z*OyNK+VmczBZMg+sTqsm1*SpA~l?EESBz-S9xD#Qfl5D(y)xY8(l@F
z%5GM7RcDV4%kIm|Qt4cf-GG{kS+M%NZ(0**AN?_LIx-EYsanalS<P|siQySCDK+<`
zJ?kOQQO(?tol<lBh#ZgPISNK5rRI$8sb|P_enlpw=8-J7Gstze%>&sfH8VHr6DzB^
z1DL9n45*pXf3}%Nz^wABGP&oA*4cR6klV8>GAT9ZdhTr{x934*8c<WU{NYV+p2<^`
zJs)IO<7rlR#oX^dH%>l)4ML^?HI?qgk9WHuAHZUeX+TX?r(IZB6S+<&JIHQ8O;u-`
zq7(DWOWguwQfh9n{%IpWZ1E16l$!I$l$s-->RRWA?39`(A1sZN)eHlsnsx(fPHoq3
zk9=54SwNM^Jzo@7<Vbn>P}d)s2Gms3UcjqGcDc?NWKwEo%N{&muG6_7WT(`$bcp!(
z?-jMfqJGz0j!ZR2W_4HDt?v(Vk`Hy?kx8jpb<3JC`S97T5M-y+41OQps6aw)?W50r
z0+|NXR7=Q4f6r(wds1eJ!cZrrW~x1fJmdrIJY-U8Ci{A-w0y1k1(<4z45&FY|G?ey
z%N`pRQPH{Qi{?#!(_6kRzZ#j8n(Z^XE|Tl~icAA)s+M2+y>?o;&Q?Vsy8$&7GflRZ
zMddm-B9l@xU~%&7GSku?>QwV?KzGl=kIejrT}Nb6YNkv5uATh-!7gMPP*aWP<7cOw
zO@CRb*FBvBWH+FuVuoy9SzoTRJ2ELX`_%dTL*6y_15*vB0X6OI&kvK!%uq~4=bkT$
zThhCuJe;1$q|_Yl5*;bmc@UYDnqPJ-|3_wKEe_c!HD_7HxXK#!MJA=@jiB{6<Rv5$
znUtCZLypvu>&)#4*;OwY(0z^Ln?W*jC^9KE@5iOxBWJ&WOiIm<W!@f_>nvOXvQuil
zjNWisR&xw6RdfSt4mouAgIs0|A`RT3RjX1at5GXuX7Q3LI`{q}p9bIZ$Wt^CnUtD`
zLbA=4>%5IjN=+BX28U#3`BIRbQgftpyRmZinaHHn>|dsC2D#41$fVSKbI7*3%ycOY
z*;RiU(B0DF%NUut0GX7U1#=EOE-%S%kx8kUc53ft@`1K~8I@g?X+X`1ds5Ywceurf
zq|}^sz#_&>bYxPyrgcTvM>4a1S%^-lIpgfc{Brgc$fVTlTC%09T<0fbQfl5`oxGdO
zY+4SoQ)+%p{wcHE^6QXEsd=|T|E2O0@(Y=inq5~dvy|&>Qy#Lbo;RTT{Sv3k$;_?D
zq}1GZb^Qo=*G%c8>QqPrYF=#|@l_tqj)>&ctaNUo9DOG;IW-S1-XSy7R)FY~nz?FZ
z^pvyrL?)%?zJCsGHcgTK+UNi>DK+;l?>0=XGh;=_PN`WjQ~CNb(+ioDnmeXtJ0oX5
zj7&<+Ug^sGBiEUw5@e^;d_J{jq|EGtOy$vEbl08+T7Jf&xOQ&TKKl0;9aBs->whs*
zBRaSL(%3Yb`iB@YIVUEE`?G&RYR>|ttLi^h4(@?SO7_9c$JuJP`n8X~;SVB{l70K4
zX@T;dnWr*Dr)1C9ziJQD17P|(eUM4Xp4{nquv}*pGS#&IrIEBbnz(QGHkp~H3S_5b
zx5*Ne(3DzZ{_h<5Ad`~)^4f4axy~qLQnI%${iKA<%u^MzQ?ftEz0+Urc^_m_vUjXH
zd9|$O8DOfGH=yRPXCJefkoxw_>!PA_?=Nb)@7_E!(UGa@G|-;sodQ?O%rnTO)cm}p
z^KdzP{%Vk&QZu;ptW0v9!;nd-nRjh$A(?p|nUtDibLVa@GYeIR?39}AD{Q|nkLO5a
zQfgk_H?)gfXEZV?HCsE`_m`PPYe05N%`s(%#mQH%V}PmJ(}0>S8(SQfhcg<H)UG*k
zt#7;>y>Lwxo%?;Xfp!bG$jnj5RM`#aK4pq+E_p@1j7&<+vDJU%kar`8T9BPmvv?7|
zv~r!Jkx8i;y2-J!%)E?DO3mT5+Ke=ly*6a0)cg_VFioy=G%_hQM^ztnP-b36CZ*<=
z#jkdnJklR%9qOp;s+A0=8Js8RnB4NC5lN}}r9ssWrZV+A@fBoJyJp#=KQ762I@E>e
zl$txsZ+t8>$01XVrvcr6I|o&jvtLIhrRD>N&8_7+9qU1MO3iNTzIK<H{>Y@%?BA!N
znaA{QA(K)w&66dS<+~OY>qB-*&9VEAddrU!&PFDs=J0I${Y~?(SMxP6)wCN>bJd<D
z7v#U$tJy$BhwE1Z?YVt?;WzSdE=4A#W}a2)Ps_}Y$fVT#@%c{?`BAl|4Iw+F=IR^0
zmdWE8f=o3>2F5e@iVXAR?3Rt7PD;(21;;*-vv))$rRKSHWuoLd_aKu}({ECa$1>Bp
zF=VII3=Zm_L(bj{nUtEtn%@qP53~`$R8wR?%}B5LF>)(qYoela&lin5kaM3roCA<a
zsd=Q%Ycsztc?y{Z)Krg^)jC?wTbm+n1=a8F1)D;4O3jU(ug7Ws2koP0jzK1+=JsT#
zZRJ+Fg-kW?W_4HD?eE=ile0TDgY1-=7v2<HEoYyNOiImjMen-E+2fE&so6iSVX)kv
z^_xR>N=^HW2g=L4=1O3y;WVJ;y>s2nX!H@0)PZ)!G}n~!a5inBqI18G)-K1GxAGDa
zf=mNys)sFZeeP~%MYe1Sb#iKUy?jc}-VvFUnrWgt@0D9=4>Ap?sj?r4A8KYNwr&O4
zRWF&<T`}LhJYH4K-V2$On&meItdr+G0-2PWhhv7BIf3PA4cRF*LngjV_=OkkS6=@2
zmtKYeQ$;tR=EdqYzstjU29cDSC7UgJAh%LsR~4OmzG%(;tuy3nqcO;&)SU44>pQv5
ztH`9(wCu6@gv>122C`FXhOSCx=G9_TkV&c8a>Pa-xz1Q*QfglM{G*o4tk@Q^tNt{g
zyGx^7$z<kiWKwGW@;f_7ekkMxGAT7zf0#WhO@fx%M}MtZvz^MW$~2&6-^hiz<-1jL
z5J{=|`&IT6@@4ijWKsv(R(IB$dB&!W8$_qnjB)#7=2@U+$fVTld9d;bc|1QNlTveh
z)6Zs}t!mUBvQuhW9NS>#8L-vJq}068r&uakqi@Kh)O>#Nsgt}Ux9$MhRnHsHebm|d
zwsM`DkV&bzDKP(QS<Pe}Rh<fHK+PZZvlo`jY>h}t&G?;-+sVVZ8JU!tq3$*d<T{ge
zg6Nc*#bfGikeQv3NvYYW&%|>wb2l<6HEZYH|3@Cr44ol6rRLMKukXlpdLWZh)3g53
z7c%oOGAT8k+z)k-nKtf_ol<jmOuV<u9EeQi(O-1eo(8(};dZp?izEH>MW+>0&Cp-W
z)QFKoI_8mYEamEwm>g~b{ROE#yVAbDbul@3KSWZpU+vTOxqJjUiA+lNbc@<`m-n~4
zT_HLpyWiO=X8t;62r?<zzt-<#=C63pA(N7Qle@Q>zhElV4YI3N`b%?a^By`NeLZ>J
zM<J7v{q?|-BjiQtDl#eAQ(oxVR<6^rJ7lM1pHi!gm&}}mOiK2;f6|!wo6=Zds+KpP
z=95hRx#i(3-9ts^o-cB{-tCDTeF`#Fod#OTVeY-<GV?w%DK#&au6Rm5$~*Uj?39|`
z^V_D9$8!NPDK#gR+c{It{u-H-npQ_19hI5&JRm!zW{=n3%{(`~0-2PWZP!1vmh1eC
zOiImb#lot|%;uhuol>)1%99;U+mZh2H3XQdJq@T?d4cO#xy;{)q;}2nXTLo)m8t(q
z!p%!X=bkUB@Ml9AdDq;IOqJb$?koE&{4Cd*q8HRjscHB0WR%QwM<%6awee|M%h~rJ
zlTx$!?<iln&UC#YJEi7Dp9OVgW=~{NYF^&cZIs-f2a!psS=vAEK6&}f)(5gvYPPIY
z(oa6n_64SDB?D@XwaM65j(!-Cl$yVnc5W{-ZM;?V^3<-meL~llGIJm@DK$%HNPk;q
zo<^n`PXoF)-E%fvW)|oR*(o)rx2iQnZl#gPq||(1vpz(wGX|NIn%$Ou36hz``$2X}
zP5)AFGt1d0B9l_H?1axn<T`I7lTve#=l%5ZjivJaRdzM)2GkrEo-$B=G2=u;Qfj*I
zY+&a4;1Mz@HFMqZ@{w2MsskW8rDoeLUXA75Xg)G2HTU|Z=^@wo5}9g_4Cr3*Q^!^^
zv(`Y!PO0gB<&1-zeF-utHJ|rPdqu7@9+{My+r#RadGxQrAjnRsS-8-(&$8~TkV&ce
zGpKfNdDr|0m}-g)sF^%-aWl7p8Vy#_;ntFYR+<<*BA2`>twAQGW{J)t7s<o<1DTYX
zm#2)}EZ5oE2eMOYwoY4YvCQ0zOap4FXMsANy&a)_o1OGID61h*r<!*IbM(39%eL}2
z<Xw?Tsk!EgyRZDf!2x7aYW^OUX_frUQnsOxol<kCUECeH&Oyke)Eu27b0=BNv%plt
zX+X`!6;?f!qvsi>q8oXCk!mHE%?<y^t>lMHO3k?*zsAa~bOo7|n#&@eyppq*8V=bF
zsHw7l{IkMO`&ZJR#hZ>y18S=0cGBL;>LlN;dWK8`YN|R{mi4bA&ruy;$gX<HfbKOs
zdj-oazXF+*n#ITbsxQycS7aJcQ)Pd4=~e?ddmBH<PO0gaYtR7sK)W57D!KtR^Z0jq
zFAwJ*L{bOZEt#uC$-~)Ugo@5RU(|DT8b^6I+Jj6=P5X3hTx6#8NT}0*no6Tolk-~0
z%wEW()T~pwrkO9@k0H~5nySu#6=U|w^PY1QWT({p)$4a(`KKU<AXD|H0o`A3p0q_?
zl4Fo*Kuwjs>x?Y{GPA^J$WEzQGI^F)@~$}*n5s;(YN{0^wv}ybc?G$JNJ`CBy*>_=
z)pQ!8qB~Q&X8S!`|NXratycYA-#N&n)cieV;e2^FibE!)=Cs*!rpnXaa4ck})U3LF
z-x`^@7MTXrRP%nY%;bUcy#GcfrRK@&sjAEK-eDYMr_^+ryZ@V<eGf8K&l}Kv@pG$f
z^1Npn4|P&%Zk=80maJxfU@D|pHPs5zdUD?|dG$PsNJ`Cz>+39%nK>t@=-lt4ojX4D
zlRWK1kV&ceY+3E|a-Gr0q||(2ld^(bXEA@sPN`XO^|&Q+os*GiKutC8lP9<xl9~6B
zNvXMYRrWJ-_R13>y8$&dN@@%3(THv#$FgX3YI^FI<ORs2)bu~v?zx;j9+}Fczv!+#
z4b*9Dz)$)4qDGSvv#Zhki<$qvzbJ)UKW)CWkN%s|Wk6J7{spNG<}BZ!)ba$qMx<i?
zCAh}i@a=rGd=seQWEI@V@1v>aJZI-u()8B{`bl4jOiK2&9oOEM>->aFO7`j3-@TTZ
zO{PG0O7;`oZnTiIuR$gy`<)9P-Q_y}L8fX?1M}Xg)~W$Av-woWZa{W5@8Q2{m6Vz5
zkx9vZd}y+|^8N0g$fRU1(6VJ-lk9pmTTfHj)zQ;{nitPn`k0XVmS2xZO3nT^`nQpz
ze?z9K)4;U9=~TU!%xn<=(J3{f_H4^!COa}IH4oLSc3rOX8!{<1UCs}9Dl=P5hwPM^
zonw6*%(Of*DK%$VmzgIoAwQ8xsrhbfUT3+^Rx=<wrRJay&C|)ujmV_bTzxlrDN`@$
z)%*iY)t&~_Eby|~0lCc9GgWl%_t92+<_nOSn~+JV84-K)iOjSJggRAr1G+oL_A~P`
z7dK>5Y7Q71{z<NL3o<D+-+p*<N@gaX1=%Sz3#~a}=4CD&kx8j}^yTy6a-G|eNvV0|
zR@;;^Gv#c^PO16AGx&<U)VU**QnSp+uh#N`b{8;JD;ZF8+mhp{O}6WIO{+O7I`{i%
zb)!C<kfXOpCZ%R%<JIqE<~C$fYHoNoz}rmrxsY9rrvcrw$G-QG>uirqO3ebd-Mr=Y
z+=fg_&B@!pnt4NCig}QoQgeUbv>)UfHXV^ksTnxJd8C{@9GR4w89w)IBr~n&Lv~8d
zcc&~?ntDmUYkC4xO}ha#124ImdF$UkL{bOZyFIF&lcQ${Qqi3#HGiCbn_T{y!vmR=
znr-7h$H=X87@3rsoi8V!C)b&40c2NmWI*@QlQx)X&mqX9)O<I%pTAt^S!7ab4*FGN
zr_3z05VBKh+W$zCL++)~$fVR<?LDx(T;~;JQfdxr;<`mvv&15mT}_bzHJe?ZW#)%-
z#vzhYv+B%pkL5?eZX%OX^FX@Nk@9X-W-&yk)U;h|eN3)%3Nk4*!-kIEAlG>hnUtFK
z_hlF?*Xgtbva5MFpnH^4m)bIOCNe2CH+(rfOm6un$fVTtUhwv$tY)>PkeyO9ZQIM9
za-BiQq}0s*?)YU>o%&t#4KUSk8c=iktqEp+!miFT72U}5Me43vk5{!qOl9g1$;**R
zsd*>D|G7MzACXC^*{ONVRhijzIb^5QbpB$yUuLdHCZ%R{{V;2JJbxpTQZuNn-zK@v
zw!x5H^^yVIv)yuBDl@kslT!0k<-Gmm?5S2jos^pOA{@*-5Yq*jl$uXmI^L7NDGdjv
zif%y7lg&rvkcTtPN)^2lwQCmpu(XrR?14;5%`CxNhsvw`L1a>D-fka%MBd@Du7d28
znn$Wfc*u43K_;bU^{}~aGV?exDK#(K*Ssrd&$$}1Q)&*}H1C;Q=Rjnt{xqO_e39eV
zWacSkQfl6LzqpdzpLS~?JEi8arbo-lkN)`qQ<Z5z&F)S`r^&0*X+%<L`nLYZ-c0nh
zDmwRk(LeXrWs{kH$fVTl(<I=PoIM7al$sk(hOC$CbXW)3DK(2W`m|7HPCzE5W*tw<
zTJm!{w~<My*}=N;Te;2(>mfU(=JV5CzQ}Vl3z@3t4e0)PYmwh_ollWTso8L4g^Tj8
zS$%`bu8;=Q99CfX1-Z;Qh@{kv4}Tvd59do{QoCm1D#J$0b=C}l=#-l4_7-g+GnXKf
zQnO*&Q|V>q2V_!eey(mgT;4gFY=rETnor8u#ml?qT4Zu+1`qI(>->gHO3hoDtF@Jx
ztu{e+O3l|Tc9{A3txd>O9{ojk?P;L!h~7s{w}JHUFZ!dHD*0c`)QG3Edi|1RZxx!D
z9FDVpL2AzeO-oz-i9DEV5lP9OdP@HrGV=#ADcR4@>(xZQKkK>~qEoW3E&eHuEanbm
zQnIi4Kg!NBtcvez!ytl!fq@->*dn50w}{=?fr^QWie0GKAa-JljfLHX9e~&hV*C^v
zyRcrz|8-o?ysWv{>jNM3!+ou1?{)9JXU?2Ccd{GY>bKqsb&6!S4P2Isud^#MMY7Mf
zJYSq=9z>={_OJ~HOYn<)mTi!oT0RAdwEpy(w`3Dvrw=kkvR5nab%tj~AX6m!`LdZj
z`6F_k?UbEbUO~+?HVqAa#;qSBMQY9sEPcZuIx?wFg(=Ex>7Bqc^X!1=A~kJ?J$b;l
z(okfI)U27mTU)-)OUM+dd179f9z3&PIAj;8>FjdN;4;P^nIbjgO09gzFUdENDN=KC
z_xlU^^McDx$SzXztyyRUU*}|Giqy<Cx%_y3*Ng)uwWorb!FdOLF^Im4q6?od%ClyO
zL3Ct_)O1|@z9!F%LndWc&^^9nOe4PK-F8EEk(!%F#;4|WpNUM7nuBK@Gq_Rr7?~n9
z-=})rhtFPZ4`dgqxh9QYFFyMsWQx>Wn=A1SU*~INiqx$7?fpakN%XpVA-hP;c<Z2}
zyqclFq*hW;Gki$a-TV!PkBAiQnvXLqsm{N6rP)4;E_;8`u@jvP9_-(aOa(RRn-?F)
z?kUB8^TK97)Jfy1pnIEyP&@vc7d?<EQuFqjD1&d@97Cppnv{KRWX+y@_S^>`yGYG4
z5&LTJ*@q%iq^9$Nm=Sz`Mj=zAX0E3e?|5dhgOFXMX4iwikMRfE$-ty(S5R|$+O`HS
zNWP9pk(v$nhSlI#&yt5Iy6pL)l36~~<5$ng$W&01KGAh7`7kv<MfZ>?QgdaQSZ}`0
ziiaUP&5?rc1-DeZ#53n2Q$bD2zOG2WuRQYwGDT{Rn*DVsKc4PKAiGG-dmE;?@O7?4
zrbx}1Z5x&0>->UDk(z_Uo^0cH&6Y<gJ57;-nl&DcS;DV$>kuhYv-U+xgRe0CLZ;|I
z`>AT52K*GYJ_gZ6Y7PspGMZ;@N2W;48nLwt^5dE2IMgXpGbH_8gV$?yLnh6;g6^MN
zPBwVH=nyhRYHpu!@dMxTSx!K9k(wv_jeN|Hr!O)^YBv1j-jJ{J95O{}zAwCQC9h_I
zla!r?Q$fw~Q|Dgh%N&YGk(#fZ-3@-+C>og}HN!?6YsBxwMI#`(NX-W2pZ4d~9FI(q
zn)MnFsl<=xZDfknOv)Z@uq>551=&Sv)|~BZ@IzU_$fRCU(EWtP_-p)lK0&5PP5Z>Y
z4fye_ej2ii)I2zGz9nC02r@-#_Bq=;jz7@82PQ>VQ1fN^JGOlE+Gi*_d?2GRMIAh6
zU*%W27048+8Jae8F<#9t$P}qLH|JP`!)Md8kX@u^<^`o%@YB8#nIbhi^xZdrA5XJ$
zP^U=EpGBjx@O5@Trbx}k>yjSvx9WBylloJkm(D+I7sdByy7Q1-q~^N2!Q1)q?1fB`
znro}=HTdy|6TqZ071TVN!}IUU9<})TCup-=py(AvyQbx=HB0&EzQ`1*`DK;QGyc}n
zIb@2|{8b`VH2*5B!WSXCNKLCBL(lNpCnHm&X4)qOw(u<<k4%x8mD~N-hhOT-UxMr+
zHIrN)b?0@TiA<52*Q!*r=EpMunbh+Ny1!b``ZS-t=4Hq(Qu9mBY{mHl?P6dOQbEn8
zgIX5mhx0iiMQV0kk?@rt&f1X_UH1N>{wK>%;M;RKGDT`m*uLUCKSdvrDN=J)K=xw%
zcs7cH>>@RDH?EVL-#OMHQ>5nUvRhB_<M|tzA~oB*Ia-#V_qNfHU8LrzG|qK+=1yda
z)ZCbO$KbR4bXTBG@+bw}wWonHyxD!+q^AD)B5z_+l_{915zSuIIL#lCcLR~cOaZAq
zzu{8Rb_(B|7BT;VS9B$23c)qzWa}r1yhNRlDcXlOwK{Kb#jzWiBH63#Sz*shl>RDY
z7s)<-!QRR|vo|tDvOho4D>MIWRRl6cvY)T?r9b~^q5U<;E|PtA*q&~D_A$s*kexm@
zy4dgO6^*Io*Pjz_B9k;y=+7>50^RsJOJ9fVBH2409$ncayZ(!7!N8=JS5Wg+_?pao
znem7esX6=JM`ym3D&3&yrKwJZ;oLUeqA=e|i;yW&^X0772KWBnBU3?5YNf3<!(Q{P
z)Z`{)7peKM{@B-i_D#qXsW~<2(?))OOMMIK6sh?x@u|V1lwQabsTt8A(MPLO8&kcS
z`;jS9vq*s!>-p^{^KHm3QZu$fF>7AUzQCmRG*pvXX}GnQGavm3B1LLGihmf)PkZ(|
z6kYcFXpM4)Z03h^5Hcydq3)D@<Ja6yeD({-R8W&XfgDygRY87Pa=HuIMQS#59uv)v
z=LBRbs7cv(cHEmsYj^E`^eulEnIbg{?k;Gs6PJsH><Vhqc=m61?>~Ot=OR<2X6KgU
z`)Ik7XMcfAk(y~2&e^~pXzRvNc4{R<H7R<(KHIJNU2_p4MQUcuuq=UZ&v(ca?V6V@
z3svKpP47W;1vM%A<-EaZ`Ig^;Od3x^-HBOb{@&*Nv|GkQogy{;PIRxp-vH}|Oa(Qm
zPTPae48FK_9GN0DH(SSN=jSN*eaJ3Sv*3jw2R{1<WQx@6XWliEuk!{nMQR2)7eB!7
znq?kPcA9n-HOuz<!MEpRM2ghhKd3-%zCGiSDN-{!(C!d_Bc$>}h%QpoWA((E_J3AS
z?N7gR%tNL~&3x->EY10cr~T=f-;hajq@a7l4Xr(RX8T8wU8JT>?bSX!^B^)sYWjEn
zJdS7P`VZ<9soBq=yul7P3Yj7`WA1nl<oojmGDT|kIc3w8SF`kE%1%?Hpr%=gtOfWo
zCm~X#=Iq3WU333wP3=$Lp7)Wdpr%&Y|K44GJK)XVpIA)Jtn~z<i_{z(d%qxG=W1k%
z)a+ZT!%zNWqf`k{r%26{!NV@`E#D29H17(!k8Lru3_tHDkttGhVbMWH`8xAGh3q0V
zx2(TbksnWgWQx@MJgTcb&x}K+NX_w1GtKw|ZIx$~orY6E&C09pzURxFfk=^>(XCt$
z^3(nTnF?ys0j#Cxu9^J7rtWiyE>bi1UEgq?xel2kHREsk<>Q&DUO=59H77XlvE-Ru
zkttF$ZQ+)F{JbASCiRkn?g!5u?ZGqiy@c!{H4o(|o0n&fMW#s2fMHRY`6VP4nIbh$
zckMZd-!-eeqU;o1LCxJ6VsrA-J`<4&YSIq3FVX&lc9z$;`d#xSGDT{R?J)EVKSlLl
zLv)dvZeuGS=C89iB2%R1{VkIXmXK75P^U=E9d%b^=Xdw6$P}shwb=acJTn5B3To24
z_y6v*OPizQC!2zAAUpM^g6>nT9O~!#!_@xty)+4#A~kO(eEY`t(qm+b)U5NWygRR^
z`&-IRWh$uYP_Nzw{*rhhA{Er69WL{K(=PMT-y>6`<{bA%hx7cI9_>#*MJ?Vzbdj19
zt&2b9SI<4j6sbAiC#S(-$?iSWDN-}ZX>d#a6fy*vA~oj@iyp`?$<fGEP?P4})8B6o
z&n)=?vWwIlGRMb;Up{9blX_l3_hYXTZt*>zfJ~8^BRUoE<`1;)A1ON_71SJ=`G6(A
zD$PfvNX;AB%G~B}*?dH%NX@k42HNw(+4vJg7pZxt<eXxBD{V%mNX^&wxij%!c2Dye
z>J+JYA;+tIrWIMgEOkbvNX^q>4?XzbPzgt-NX;Dm29;0qXX(`b^mST(f$SnR2Sj}y
z!`ImgnIbjUFTG{SGdClXJW4@#?P;Jzo_^U(YU-aa`bA74reLN<+}<xB$@Jik{vn1Y
zU;m9}B@#0Qr1mUO;OXND{5rQ5k;F_PxW=3?rByv%%wNb9$^QLx%r^c=*YO)f7s)>D
z_~@2=okx+WAUhos{hn<f&VTxvI|=F($)4s*&E@<Y4MnC%_LuoboZ^|$$P~#wI;f7p
z$1%mfLw1quZ6+_=V`_Q*0x}JmBH7Q5um7IU9*;~?Glibl)O5D{HP^Ht>(#9EgR)c0
zE2#PWMVlRbd(J?lNX=by&kX1Hw`a(tI#Y<Q>2A5t&)|)zb$>#1k(%{<whrf~XcaOQ
z)TCo#g>7czd1ewaMQYZX)cz6wL4NCBkX@u^-kZzL@yG7%$P}q*T_vNzb7eNap-z#S
zW45|v<Hxf%GDT`G+i3rU@6QNiiqtIFuf+#mO$RdzvtB;^dv+;Zx)Qagf|_q%?DyuQ
z4@RU&&Ba9*7+euYB2%R1!k!Zb^K}+Chv<}DLHFSq*QMi^r76f1srkF*hj5<x2$>=^
zhc%5ec&lxVRFGYyrhClHZ2TwWOOPp2)AH4_7W^E&N2W;46PwLFcxDp|$SzWI^X=!3
zJaZE=MQZ+v%pYqycI$Udi_}ynwUUCG_s^xd#FyC?ks>vJ-JSG{XYN9#NX_@wkw5rV
zK7%Dh7pd95)5_ueZsdbZ8czk?r+bCE^J+#QQ>3O<#Kx=qc-mV*c9ELz9i4CTJI82b
ziqxF*rj8RoN4JqFQnSSr&x?GWZfPL9NX-)ye!u0J^N=Z0b6l+^&v-T80+XiQP))iv
zs?;<#P`e4Ft)Tj|e4Vru-A$zC$sc7_n#$BOmm^c8W>}X}ANhN}?~o}{b77g9>-aib
zSwnV_ng!>scjIr=ZAK=|k%I1z&+jvMZpX$3>J+KDy+$L0d%k^<DN?iJvBDGiCFDFZ
zMQScM=i7!~>YUO+c9EKGqOZ;5nG=vHQnPQM&v8>P>37Y0z@#ZMRFkfa7M*=moj=%=
zPEXOxiPY>|;^}aH^_+oB1vP02Dc(Ajo3_$vAM@ySe~L_zn(1Hq6yc}HBLid?skyP(
z3WM8fp~zHFld``oH#=1OmsYDj`%h%jyesHFvdXtBeD?MkA-hP;d~V)<YfN6}K4gm2
zG%slWh5u+Tt1Z;2peBvyz}5%XX}y&E)7Qbs6sh@h()O(UwdNII(r_xMX&tq3KOen7
zCW<cmeY751%0K0q0mxKPla`RRg|lVlTj>EZMQWa`lF*)KR?7_871X3@4+_ow_bXw^
z+jA*071X5c_Wg&<<agrF$P}r$t;@zd{2aB-0@<mT6m+lNBF2Yj?n9<X&GmcDJMzqI
zS)opmnlBnI8n4Zd#?>!%Ly;*`^K5ae9sI5t15ApppytFuvqtgPTZQZ>y6pW$@f%;I
z<C)`-DN?i0j_M)2Mz@eDQghkF>W}yXm|Hf;uAnAql=1wlFZ_cMvymxMv-<3__4sR}
zH^>yJ+2BH-o!Ww;{ps7YNp{FCQZulwdmcXfW@J)-D(HSN->w{a|J11c>Fc!40d*><
zNpo~(UZ>Igc={q!q-Na>t(Ws^UIHeSsi5X=&-|VFmbcGI(Pi&1nlSodJ${PDB2z(4
z+Kqk}t9DKsPK~RdqBvxV)a*a(LM#3=v&y+3yGTv{jM?v6{Ham<)7Lo{nIbi#J7v0{
zHJ0|LXT~8@q~?Yfd*7RWG)T{M$qm^R)TBA8c>m<z-+D=Y-(n&%MQXa{I#h~ZLSm6g
zJ#VNx)!8RihrhqMrfnbk>=p7rc9EK&ewh352ijS{B&33xGkk2G@M=Clr081H{if4!
z{u!HUc`3T^{Y8r%uA5dR{cz4lrbx{$87@^YJrkm5K0~HR%^S<6FXeTwln=6t)Vyf%
z+TayvbC4-gGfSA|eqPN)WQx?R+AOf8rlr<T`thutAF_+ov`9NK1K*#^k*T02?V3kB
zjC{tQ>b@b9JTlb%e@yL>gEfugc9_)EKVQ_+-jp4FLL~(=HDZpVZAzLtUVme0Ef7ge
zLnN(9QJY8lYxjJUuSs7JNz4?2YY!Y;@M!RjAIxSB6x>x|AEpT!dDHyg51Z>7X%jL<
zvb(SSaF-YJH!?-CPg`1IA1_fGN60RcJ>Wpi(tMp^$P~#Q;V^zM&onOpbt=eCb5y2_
zRaTza4w)j^Pai#P@J`Ad$P~#wu~gOXe1BRyL3WYsi%VPP=hgHECbhhwnlzmCUYrQw
zpUK^aNCh=X_s~+y5_#P-7NqF1_ZNk9@G<y(v|h**scG@C-Vpx0a2%N;HQj4Y{K}7K
zwnC6yq-N!rmz?-k@<pad&5etl4Bozb7MTia(!8H4{qQBf58D@p>>@SO?hLPJYI*&V
zJPMg2HS5HlHuwRmC}fJ%3>fh7lBt*UyJnFhl%3jBLCxm%vfSfaX)GcY)Fj<su1_#{
zclmW>(h{Pu6W{OA?IFJ+mn;g=DZ2vGHvh>DJaaNKMQTRn3AE<NGZvX5HR}(qlbu(y
zY%$0#QnR4TfIr7r?I`>IkF&wZR8W)Vz2%jkeKk?FKfOkekSS8Lbxh`PK6~}zkX@u^
z+<_|Xc;;eciqv$UQR}zqw4_(_EikE-6x6)laz#$QO!pELy{t&hh8c3L;y-;|j!co7
zLzn%k#$RcEMy5#3c1^v!_<O$foFO}nr-JU2&sH|LG73eeNX;Mb)4k=#^E)y{Y922>
zX%@d5wJr(SMQRQU8{ngfs{QHJ3`3?!%{k3}Tk-d2e;`w&=I%4G?fCKR-~!o2YL<*#
z7HeAS^lI(_CQZA7nyE8gI?u0k)}^RSmFJ7-U}Kjj&k!xT*7o`->WNH|nydP?58&@3
zA4jH0&D&)>Liq2;*t<e@k(!?ZJ?itjW&kp2judqNwzi7Fb>SUk%G8X$@6IoEuB9Qn
zNX_?2iyQMA1t3#FP3on_XRIn~%;cYH-bbcL%~DhLhVs2stqf!rsoCgb;tGD(Tmej)
zA_X;{Wt-lEZ>6`06z!TLt5-L8CsO^g6uq2C&0PKJY~WYAb;uN{Ip9fOU;aS*3z;G{
zC%?`*B>$gQ(*E?zQfoKJE>g2xkHJm(`<{o9N%O9td%~HENBD;Wa+ZTSMQU!F_cISa
zM<bA_pe7xXqn6hn#@88xOa(Pb_bHXGCu!rETzA*<kX@waj}DjG^SkCuVA60Js!3&r
zpA3lO%Y1}Lk(xo93)kTf$u%la^ztG#_w_42Q>$A0)3^K*WGbjh+3#Fxa6}tUO;0`Z
zBQiy5-r4^89-qBoMaV8vv)}E*-}xnEEiy%FPAeU}j%OwzlX^)(_aPte4dt`9s07(X
zYIa>R+kroLhapozP0~Ha@y!oD`)_25)Es+rNnc*gHkBzmMK@HF$~;nM+*ZEKEr=AU
zdEs`Wf&5OKstS}TQZr4IOBz#jy+$37sh}ohw-23~hHs^CWQx>W>Ee)<XIfW<>>@P>
z?0OKzAHckkDN?ig@l<8_IwO!NQZwXbojCqLo2MFNr~XvXeSOEPe?QpMYSqvCC}fJ%
zJYU_tIiLM1GDT{}Pt2dow1nudHA_^d>{O<Lnv0s>ugD)l#v@WeP1=oW&adLGy??eq
zvf;dgOa(QG=@Q|7mEYlN)_~|DH6uz4oyjjti;yW&b4SxB_ju-OWQx>`tJ2PuKh)K!
z3E4$z?p(DqHQ%0VkttHsfA)a#{F3|wnIbjw3>{gWzg5?&7G$TMSI~Vyl^i$tIog3t
zk(vh<S6pZsPraH}wW&@*DyaF*Yw8rfOfN(#s7brg<%QRM_$k_pOa(QG`Kw#eQv5^X
z8QdYdNX^+f#ymC+r+!5qfJ~8^Q|n)?t}Q6qpPqRRnIbj4tlq@(bL3P9vWwLGH7cnw
zpM5kkMQXmvmTx&<=QU(1s7Xt**^lC<_$9fx2V@ti=^Ju*K40eqWRgcI=&n5t<alEC
za{l?ETg0S}Pr*!$*d#2<#YEK0UbODN<fTc>6p-4pK#^%fHuJ$pBa)aY1lO2fc29NX
z8$Je^6kUN?esDu~egP?252A}?U+uB27GLKSWQt^O^Qyrzemox{QzZNM^}AhpF)P-G
z>>}A){GJrTGv^{xB>UGBqi*tZ^a7a*veP2};fzB)emrY8fb1gK2aaf9@U@c=WQt@T
z?C59BACcb!lUiOu&Ah)lZsEU1UAG}c2i+AkD$z15fFI7y$fP<AnY11s=oI&XUysci
zL7fU}60`oX_#xWyOZy-Fp4kSOA~l<Jn;grx{7z(w)T~)9sJ3a^^>x}bhU_9W&&TF|
z&o4_|kSS8r=|K9E{JbAVrbx}E_g2j1nOT}Zc9EJVKf1r+@1gr3Q>5nmZ3QZu=19M5
zo&_egr-GVYH=U`<uXMSaQgnED*ia){>B3KV-sC@l9E?l_HHm3{@#<E-<*y@?vMbcN
z`;Nm)o>{UPWEZJfD0bvn{wB~=WGbjhONh_1Dh;(cO8&`n0y0HvuCjQ3fWK=|y*XqT
zsoAJ<y+FR@mmpK5rnSS+SNt4(LZ*V6G@b|hrR&0f`r5PwWEZLFaid#f{y@7GnAA!N
zYP#g|e9BMJFGPwCw9N|CD9hgnY1fjXmldfQ)ZXInhuPYY>UWO)$P}rWdU?`iep$-q
z33bwVD(F6N&CtC3c={q!K}}kg_RUT^gRk=(GDT{ZcWM5CpCkKLkX@u^1&i&I`8vlT
zQ>5niYO9{|y5B^mf|@j*i{}L&<LfNj8nTPjT)WS42ES|0047blf||`I?3>L;zmG_f
znrFV(*~_<Q)ixB}O+igs>FVD9@4R-f(N<8snv0MrQZumDwATDbJg<={QZxPVPQm=N
zySIhxG)D@$e>u~BF~4&xL#9a0RLf_^^9RL`$P}sh=53$4{Kqkk+Cg@ani;#CZ^zHk
zW@L)g4BI~}l)sPs8<`?CohlDLz^mDzJ!PjUQcyFtPtj()M%xi7QuC6{y$}4fr|ke`
zDyT^--N-RMuT0VPYIZ@UNX-TFyms@<J;)TP`Rz;ee>~H=BV-q;IdV#ialD#d$fS8!
z(7oabtC^+)n0`F>BU7Yi#KdYZ`Rq2GAiGG-kd<Y<O^?*+>+FI|k(ym@7dgcD=Wb+*
z)O@@@YP2c4{#w(fGi9gYR8aGm)%hO$O6P@0k(%G97cjVfJ%UV;nllD0jOMRj?Ytnm
zNX=`V9~bARXgD%OYR*m=P@UH(5}6`3XKr*X!`E533uG6m88u?T1Agc5M<(@>g6`G&
zc^kYM`!+H~YQCMi>k5Agaq9}%MQU0dkB&BJq}M$dnIbh`cbT=uwAAU<d<aa6Zm1?5
z6l3?-{`<(1Hud^4%XXvaviBF&TAp?`Kb(Qc6sg&yVWzeG!R8?{MQUECV6%^3mMVBd
zc9EJvm5bEo)m(^7k(!%RB^rFiE)kg`H9cP5ImYYm(H*jj)GRuyej?9Yj!f!L1>LK=
z1$gki^Z}V7HM4#{l)%^7s0U;hsafA{O<$AldNo6VNo6XiIc{Z%ef)<KpAjkAHM9CT
zOy@Of+>@eL6sg&EPuxEK;2nxgk(z_zTx|F$`hiT5nv?Ca7T{aSvlnC+sd+zc!D&AG
z7G#RlET86KPrgpe-cYAV&AW*=EA!0G$P}p={A;f_&)kbl>Ujm-A1*6chG%Bz1KCAt
zo?r65J+Ed@U=mV6%`Q7^M{Dh=t@Qd`^B^KcYDPuhYsx<hl*xyp%idpP=GvnYuaO@z
zMQS$6IAA8<^5>B$QghT;H%tD*lLCDqyGYIN=W{kM^k;swKm8m{M5ahh-#p8Q^A`wj
zkSS7gu3dOx{uI)pA7mG)xung|zn?p6=RAG(9mo`^xxaOnZyGN-GhKhElRQd6ckOAQ
zmCo@aOkdm6zrUzAF{wKZ&HUfp6^;1B!SNJ-MBWEP5;Fy)_AF5Kg6&%H5~cP17rcxs
zF;fVxF`sWp@Z}}yf=tmq99gY%TYl|4h)fzzg*wk~Sr^5h7cvik>>}CwRG#{gXZA*>
zNcP^neSh)Uk0Mhf`^v-T7V&jv8wlA&vR`$`Y;eP-A2LO<w|}!SKc77UnIhSn1QuS)
zU&iDf1ldKhhfI2B@N*JFfJrT{pr&1Xmgf8ohI5D%shM@ie~0<#1^g(w?EOVq4iEC<
z_qQ>~6shSMaO*UGUWi4eNX=uD3w-0pv+7{TE>klp_#D5~Ek>qD&737?tmCu4L#9a0
zd!r8-yaKJ|5Xdf4)1&)@|M*_oj7*W5Hy@N=!jEUFp-`tt&0Myj20y~o37FKL3TlSF
zDb$5;`EW#v)V%KYW*5KGWg14&%g_>HxWmy6unFm(<<gj1+v|@?eUM4n4Vm;2PnwR!
zBKc$D31o`YtnXgSfp7T&!y&s!%_+`_P54i<Cm~a$=B+x<wwMlJ`tf{#Op%(St0hG{
z{h1%_PtPnn0<tTpN%NjB(}AMecqV@__DW=m)XXy1#)en(H!?+PMs8^Fn!kE&Ka#Rj
zD=DZsFWk2$zbb7*q)5#+Pf|zn(XB>7nF?x>M#0&i@8u6*U6CnLv!ZwVtNaqO51BNc
z3cBwf8R5xaAY>d3*+pvF_Wx$^i{U+ysh}pce9hIB9%}Qh&68fE!^jk=d3{K)Tl_L_
zHwLmRs7dp_`a|~3{2UEMrbx|q_8+tG%*)6WsW~%!(^%6|r@!Z0a4cn~X;)BlMCWZa
zc#Vc5QlzHu-qE-C_Pl~jk(x30YeexoM-hLBE>bhJRlC2>ENQjs+jBB9MQS$tKBNOb
z?Xk$DIa1I)*UL<)cxKsgkX=DdYWeYbdR5}*eFic`YNmhIYb(!uf=rQ`y}F$p$unz=
zhwLIXcW!QNP-h4-MQV1ltp1bVH9r88rbt1}tdpv>=BK^h1d1;EeYBGsJ7nb5T!l;p
zHEET%UGc4;HbvV1=r#I`Op%(N-!qltvo{Zb>>@Q|d)<A?Uu$kcrbx}sjW!tkGKs}R
zsFUVhLHC{0`h4L}A>EKEQZs2r+Lruy?nkCbO^b_BS+oU3`_s?6?Ig%9Qgi0WZcX`n
z)7_9MQuAS;ZxpZQabVJLDyW$^yg?ZgQXf6*WQs2PeYBP@iaYVc*$0^lYSJn{_)$AM
z{t>W4$W&01bkERneqQZRmt6OZQy{xY&6cN582zj}GDT`8zUpf5uG|P@iqxDG_^vL0
zA(Lk+WT##-)SbrD`OCGRnwlC{-%CT0DN?gmSizC}GJhGFA~hq^BsAffPSYT}NX;oj
z9v<Wmw4;GZ(G}F3Ji+TYU*=^*iVm~`g9e}CnNHIwdIgc1g~BGU=U3#>$W&01bkBc(
z_%@z-6`3M6UlyBd!LP{010lOe%^Oj%H~F1-Ix<CSR&1JWJAY98519&T(s(YJa&@96
zYVxJ7S`cKX{xsB`n1!bdF!-{22r@-#`nTKiiC^a5B2%Ph_`Ct*O<SD)TC>g!%1&h}
zsF~DgyD#6KOAskiv&%~tgP$&Zi%gN4?_TtB;OlG<4ADhu*1h<C0KaprL8eH}x?_Lr
z;FqN&WQx@MnR@Quc2C~&EoMS?k(wWKOc}yw--b+)noXU0bm!;DY8KQfQgd_vk*!TF
zuiuHikV!qSpu2m}rKkKH?M9|ZP1pR@8k_3Wt7$WvvJ+B4&DhPAZ=0Tr_<zw6DN-{o
zN8e}sio64vA~k)N{OZqtW6^pJL>H-9vcKh$!hcqI?N6V*4>Cn+2JBrsm~YRU$W&01
z4vHlnCFIkX$q$Myb0ND(&FXy*S@CL4MW#s2+Jo)J@GXBInIbh`=MBwjYI*$}m7fRM
zMQY9%(YGmI=L}?$M=9v8Jq<J{Hn^neK&yYg=n*lglTt8KBewK!y3v$eFMHYf|B}N`
zKcs-vo&~!4FzGsfgJBvXMY6{?yZY~|ulfnPhfI;|{hYoY;g5-B7C>~7?EB+3b>#0O
z&qO9oQ3{i;jpxg5?+o6)`vRE?vePl~-n_UfyqN9_A-hQSA$y-R;~RcCGDWiADsjl*
z`?MdBDU#hHQ@RFx_C|{!yGZu13pZx*o6$OCie!I(=7+sWcD<UvfJrT{pk{2Un{D|i
zYQC7F%idp9p#S1MJaZ#5sZNEK&$g`Oc7BR}AycI0+m<b7@_T06C6HaD=5fEG;rvp!
z1DPT<%O3Y`%-3ld0(FYioZY+rBmVr=8JP-d(s|)_P~;7*<+bHbza(!*rbx}lBVPpb
zXQi}DA-hP;eb-ZanszvSox_nSQu9~5<9-uUujVCSQhO?>Sz}1IVf@Zvzl@^G-d|)h
zxqLbP$I{0lQ>12wg@vZ`YCb?FWmnL>#Hah89sabD_NSksO3NX;NX_+43dH97!_)rs
z%r(eVP?K6dxKqSs?co6J6>xf{)e5LnK}}*_Y?9eqyX4TGuhKJnAyYw3+TAZLZBc<g
z*_=V9NX>}m)$8;9>97*Ai_}aUpQ<0v^hc&h&2cRUPv+IU3ruPy1vQWNFu%)}>9UHV
z!y#Fr<*&8c9mX?fAXB8~h2R3e_^a1v$P}rWBit&1KiJe;4cTct6|y&vNPA2ZK>O3T
z{2F8`s7WnveQw=1zRsV>R8W(cKf3ka&ez#?4P+OoIrg>N3ZA(enIbjK52RbhXSWT7
zIz?)h{9M7AuhR#aA~ll^dHVAQ+B3kUX;)Bl){I=!`IRomT8ggn`)D-n3vRtR&Z{{X
znIbjqIvxq;nbF7;skvm5-6uY~^E${bQq!a6@oIdX(~wDXq@a6=b{_70osW?zQgg%5
z;@$Z=YpjRtA~nmEdfJJvb2&0aY6f-8UX!o$3o=D&R%>40=soxwAiGG-!KI=O@oMe>
zCQXronz1#rz2l>sZ=^D1&lh#PTsMMedLdJ!=7|5!F6URz!^jk=+4{#88-Df7wh6L}
z)J*+!(_x<JhfI;0lly(2&NCyCN%O9t`;_7_XLyZ@ZHDY3H9dx`f6dSPWMqoeT-JHW
zUB1qT$P}sh{L00je4SOpAiGG-(apQv=G6=VCJm>8n)3_99pIzCM5O2rZN+*^$Meza
zZlUNZzmKLhWLh)r&Syf>ux%PsJJjkAiffT6QZwLkp;3IDW?P|7k(!^jUt7d$)ESu~
zHBaC3J<Hd55Sb!1yJak$foEpl2HB~X6m(zsGwUlp`w(P`)XcE;_zwP|kZ5Fz)Qldx
zeg>bt<aWp|Qqy&O$)^0ZW)Ltbx`LW3wnkg?YQ`f{q~^v=)vNMTRA~oAmpxyUP_AJ=
ze%D-xOp%(mk51diXMclCk(#dy#Tp#E8-_!6k(&MkV*U9#HzHG{X2#4-uk!7gYA4hw
zQghCLY5n;*>Viz_PX*nt<!$zz&wdb@A~mZ9%#G)>+wFqvA~nN5jPvK!^aCc9si0=}
z?+#(SMrRNyQuE`ql7;x_j=L$k?EOU>js#uhZv%}(rbx{et^5-CI`1J<q~@8_jgRwn
zR^9{IMQS#4x@K_E5rRySn!gJ_>BDFLj7*W5qwcQA&NDstLUxgwy|>k{=9%Hhq@GvM
zec;tO26t#P?1MT*YObr&p*XK*UtkhaLCw8im)r2IbPSOqHA8X+dh^4XZ$Cwsy}!u)
z@!-e&5;7W@A~k>9J%5+~BK1vViqyP(epXBVcWx>ifb1eQx18H>k{{2d$P}r$XZ(!b
z{CIvrrbx{#t?Rh*JDlf1$SzVd<J6o6yXJOeiqyP3EQi5QWmzABI?1CHbl08+dfWDX
ze$%z4{`sPw#H3kI!Ay;~_Q1-DCZhh6(tSWAF;hTlSB0xT1{)l|(jNX7+)eiWq6zg{
z4&|G(J2FK#ma0Y$FjzZJAX6m!sJOz{`8x9*f$SpL<7`LU^UTr6q-jr~k+eCwm}Z2*
z;&}_1BH1rz`kslG-R&r37s<YJPJBB)`y6D7WVdslIG<;}My5#ic_l7Y;j=e92H8cj
zr(IIc;76D?0Fzo?LCxS!J_Y$QlMqR|E3{JkAKotfaJD&4(Pi&1YH_K42mZXU8<`?C
zSA2U=h-YRw0d<Phw8&nsDZdx_AycI0kT0oz@Z)(InIbhK@~vpeXD@aVvWwK5U{$3X
z|6JL0WGbksb>#nUDE6#9(m|^;f3h2j_mL@5^XU9nulci5^$5r=QggapFN2>hTmwvM
zPX#ptGA`K59}_<zQl#dot1jR9X>W6iqRZZ2^mG2ZEgDm+Re#TSFES~+!V*$tZI4j?
zIVii+P^U;uv!}(}_@!<nGDT`$ZQ5u)|MHRR$P}sBtlTVLUL&_NkX@wa$@QC4@y~$G
zK&FD4^r`#fjng*q@0fawOp%(sYyWu4GwYs(>>@R{oGaadKhSOhCbg2GnzSkv{+a5W
zcDp-y%O@dHq~_WdjdJtR+nuB6vfoEry{?DBi?I(OQ>3Qj=-Ai1Mt0|+P8v@I-D~z5
z6v5y39E41fn&uzp#qf1rM5ahh53lI6JhSix$gZF!^-|=X=q}p7v>jf*d`?8BNX^Sd
z<`?Hbj)_O6f|^w4@s9=ner%My&Z-w7yGYGDwml7gglP#dY1$3dq*bZ%tH_D`O7{wp
zA~nNOcf8B*Mjn?ay6pGSR%OcLt_@}KC1f))71X3DDxD@{du=CXo_4(qb&AyN9GS_3
zZ>65dq&ZU1-S3feFP?b{nF?xB_9sRB?(!NrMnZN4HK~_MmOk;8uhSoyA~iqmDqoCe
z#v)TeO{(*7_M7{8W~C^|E>g4or1Jm1zoowov>2E)MG9)hmc4aEn<DK`ztX)#q)5%1
zE}cH`%zDujy&PQ=E41gp83#)8hq|@MR8W(qD9d{9-~8@waRurWsW~H}#wPwS-xHZ4
zHS522@4=7fX=Kv8D~#ufVf)haOotfAE>iQM^}a!T%a28-NX=9e>rdvd-R~k(q~`uv
zy{GYYmb(hsMQTpob#%Y!J4|{t=L3_5Q$fvI5jQULw-}xwQlzGL%=BOUaC%&$=(6XF
zX0Q32Q5#OJ?e$B@YGf*?sWs&PZZXW<)L_4sUE}JRzmO?XGvwI)^!yUi@j7G|so5w~
z{(QVfhmk2#vsvE~E%;j@Ic`9m)JulC(|Gy~^lhg7OIz;r<2f3cA~ie4jY-A#=S^ga
z)a+Aqa5R6>QT8Te7pXbp+`%EH7q95moC!>duApYXoxTQ7kv>4ANX`7VEoz!p5d9QY
zy+zSw&llCZ_{iXk)bo%jQu9)d8xyoCN`6RwgG`Z{%PZDesqvCC8{CHMA~geRX1L<;
zhpGMP$1@C>A~nOFmf2tM4^R8kGqc=*Iz?*sFH+Q2(=z!5!Z>77e=6v{_u8m>+E^yn
z{Q)u+)TAY(SoyBue4VxKLUxgwMKfRBXzF>rnrnecWg4nUW!{)@uo@rzD<VZ|Uiy-!
zfEGRZaJG-7=(6XFCM5PfZU2X<{pnljFftX?qyz1qjs?5(htC3WP^U=EWzBxx=IabV
zrbtbz!e7(!x<5mvNX?)|fjM|)gL{x&K}{OZ<56#R^Yb2tOa(QG`T6R^wETUG^zl$9
z^}M0(#C&(Pi6?(z7=%obnwwSxEa26=224U4s!3&@t6pt7AHC>(ie5>i=8Zie+xck^
zMyBXmbK$0Ki}~w=*T_^*la{6M`{ib8hfl3mz3z=3Kz5Ou|CL-A#@D$8nIbiB3@&n)
zUqY-OLY*Qt&;AN@vHFu+`_pIdgG`Z{+fR?#V|x5e&)kPh1vP1o7B92?dly|h)ase(
z9zk}InpN7|dd#cY8=2%$3c71g19f`T@sR02tAD=eA~9)(QZQ2^PCAf1vx%tRhx7jT
zFFAb4ECr<Y>`LBSfgkt@8i+`d>|s|rgz(LI8kr*5Pt0jKS!)69Pe18Sk0H8(?6lDJ
zTIbuBzu!F`nIhSTkKX;0uk$uCMY6jcd}7aEZMi*x?9@srG^aN2*Pc$E#a|W9LZ(Re
zhZ*xu=0AOXiA<5~uWIb<uRXw!{QOlr0kVr^e`dGjmub(`_tGY0ie&#bbz&hCQ?KSP
zU{cE)s!8kI{i!#5Xh>~H^<{cKrRXZ}FCu1|4Xr0=)1Le$&}L*(oeHgFSH{wgUqY;&
zL7fU}Qk`qIIX>6wOnzgjBQiy5z6qF>lRqLKK&D8|4US(7-nV1_9I`8@N!hcnEF7Vo
zKayW*4n?L&&A#sgqWGom1~L`Yq~){1t&cmks<l6Tf4aPY>>@QA<oc4GU+RL8DN=Kk
zO-y!P&Bwr`_B2$JqK}NpI-6fTE4`%XviBEFKK?9<Up*HgQ>12%qWLZOqx@@RQg#L1
zOLjb&n?KIBcm>%-Y6iOo-!M&)zLj<$Q$bDA=um|MF8uOo`5NjJsaa~niN(B{9g(S^
zCe_)0aNGAh^9V8()FkHJ=iYm@&kwX7)sJVsM93~uvzT9Z8~!SLBr-*6W^yeVY}z{X
zyXIYBQY$H_nfle``I@NOpFX<F8;UM_e^L7R-QV%d3CI+wd3pBm<)-NRI<F#Aq~?|y
z561A!B5xr(ji-X{Yil;k#WTkuQ$bB_1kL__)!q3@R||fri$SJ>n#A1NsjMr{Ecy<z
zE2v4#(VN1*@!7{CQ$bB)4*KH#hJWMXb!3Xv9DK`u8DFRKd&n+QGwa-6mi(iC0l=hb
zS5WiJ>Y|_cDY}M8(Y2<B^O&<dv-k&!uJU{lP0_`GE2sJ43_zwx&4^#)H}K4x$P}sR
zx2220PZyT>2-#_l6m)-ABz;$YJSQSkq-Nita~kp4?;um8rgyp;#dxO6C&(^Rv(d`g
z2202!WQx?hlqJq!sk@6zk(x*5*Z#M4=y%Q1pD8;{k%F2>H(cz&Umr|Cq)1KIyoJO0
zl`bBcqFr<6)ItC8x0cF(f#@PNo84<Tfj@jMM5aj1n&$rXc#U2nQ>5mpwe=HuX6>(#
zo#tIZ_w8rz9OIcG$P}sh_2!`jp7|D;A~h>_%Tk1A*82w8MQT1D{eCOopDU3mQnRXk
z<{hSGNw4N-VA60ZsCm`aY#m=_!z79>`+c-tgX{|N!x@T9k(%kUO&P{Bzadkk=9u|S
zKJd)u-yyq5&EVr-|2>_lKX`9Mrbx|OKJl0MIr@Q2k(&A1+8OBH>IY<}UQ*CK&4_o7
zruNil--1k$nuQA_80c>H6Y3PH*{I%#ef+$)MW#s2Jc%uO^9S1Pz@+F3YG!S@t~+0*
z*)NJ-L9}a*t5B{i&uoiKk(zzpHBRK)b2~CcYFaM1cZ_FR{f6u!HLG5*Sis-?^FpRb
z&8M?3)a2_tfJ~8^M-O@p=WqXIGD~gN%cp<OE~U$qs~}P{E~!d=zD{3cQhzGwzH?Pr
zPM&!NnIbiZE&4f*@6UYZkX@vvZ|W@hP0Nyg*BlB=DpNtt9B;!N`RL~nDN=LvLPtNI
z>5z(|%bqXFdoRhGKYWfvrbx|N53Y^k>x@FCNKNM{wTto0!WNKSq^8}g?*^?j4w)h~
zM+NqE;oI{DGDT|s3LpI5)SmiX(>XO{7pdt!qxDRFsS7|R^}K@a>w2v^#WQ1(DN^(G
z^jalN+4X9cv!v{VR8TWhoZT9}<pU8ZQnT~-Z9918ePoJu&9EOMzVg?^<*XpONX@6Q
zQJ;C{EM$t*%wNwl1Fz;&WQx?>RBYNizLjdEf$SnRQ-4dJmuH3`Q>3P6*B2Ii_7BJu
zshQNEOE3P%G#aIa>>@QY-tSO{f4(RjndDIlx@%7Z#cX`~MZ0OK{pp`C%4+?uP8!V=
z%+!d*Eq}h@W$z9|5;Fy)_MFLyG!v)u-{#nlNMfcCTw{Jr`^(^)?m28IxT{F^uGyN+
z<3HURg-ns`OR9Eo<!@HSB2y%Lt67T+YM&NrfBL<sayrN^l6}X{XTSJGX&Ev_vX9Sx
zHIZk2L?*ST!n}76X<wA@r6%biyGZskyHCaPbF>YaBH0(jm~G=fbx)rG>J-VoyT`F0
z{_1rQFsbDg)I1jv(nfo<D*5|iA`mH3v-o+hd;B_AG$Tcqy}xK+$e#NAdOQP}A~h=)
zcNypSC%g8i*XS)WMQT>?8kLXF-rg3ni`1-Lb9$n~pBlA4eVs>;DN-|a%@0-u{_wOv
zJ+ojYs8gh7?V*LM^3PVyLZ(Pf`(E{m@N@JDnIbipH6CT~@^Y`tkX@vvRq>OT`Cao6
zFsVHi)Lc1X-#q>XL&hvrrtJBmYa4Bs^UQw8q$NaQMPBrK`y77tJdaGuuE4BZs*pd=
zERq$ni_{$QblAUFOzB&GDl%nimVI%NztW6Frbx{&+o0#BR?^p5#tyQJ)ZF48T9vPJ
z8Zt#{mWY05%QNGVDN-|c;TPBW?B%jSc9EKg^JIR;@0vltq*hW;GfR7qeSDd5h!pLb
z_VsTp<%hF$c8V^0f6=PbQ#bR>>BtnRdFWbLM?U*~WYTyl=)P;KWhI{JmIJbj)GXw0
z`HjyWh)j{1>)*98(ER~2MQSc8v}gtYOQjWZLUxgw=W`Z&$3LDq9ho9EzqkxF_^rJJ
zWQx>mTROtvo%J5MC_7ENf|^y!1zPbpfkF@|QuFS`skQkV3~!LBuxrxOnfG_NCTjmm
z{&Z%&+z?%)ru(#B@qEj#MW#s26NNlS@XRD+(i|!1{=NB{@jSCd9>^|Ib5S|hQap1L
zGDT`uytBFuKkvVhDN@s7YfCSl*)}g^7pa+c{>oQ;_8rI+sd?+@T!UYFvC2nv(iADE
zIicR>WBe-L0g)m#y(axM_$}@o$W&019{nqu(El+%oL2cEx=77zgU(gvnVpd-QnORe
z2!kg+_aIZGrhC_Q-h7?b_K=<CT|xK!F}4OvNLOTv)Vy`&Qfa=I_9IiIW{EXT-t*bh
zJ3w}kn*KXo!gywPWQx?Zu=5^i%C7%7<`6JxI1SaL-DrQya#gjRDEU{dGCERp+4Du^
zotGWrSGs=46sg&@>eoj+^As{gYG!Efvx{fuDFE3;YHle%WCqV1f=rQ`Ir=_$%D2)b
zWQx>u$x;82sg?BCngyI7JN1%+?hF3wAHruJflQg2M-OE+ed$?WXEZWJYM!VZ`GCJW
z?Nku5E2#NDkF*a@E>_u4K|6hF^Q2dEEHEj$p_;TCRowsU2mczd7(^=UnxuPBwl;Y+
z)sugK;9Q8J%idoUTH>L><Ag!T6sbA?dHoOk6g@<yNX;>)@}J=~s$3Ydi_{!)Wambn
zITx8CHBT*!F}NS_44EP|qvnlR%a3P`B9NW>Q$hEB_SFq`_a(>_soA~j+-&@KzCosf
zn*Z}iQ}bGdac}wCKy`~!b}Car&5r}e_2<i6f=C55N%tR_Vlwi~H^>z2nuWf)7(7K<
zw-`hhsabMbKrmnD3S^4Zblcd~pglh#Q>5m?n5NhGI-3-S>>@SG70lR)XRbr0NX=>;
z*Hq`3-;pU&^H9jSUcBxtOF(w&c?I3QUk#bc@9tZWDN=LC{tSIgrx5+FY2i$D5>i1;
zpB1e(@wb86B2uL04ClJXv^`Y&(;q^%AycGgs{R)3`QfxK3DHGrZa*@856|p|Op%%e
z553;NkLN*TiqyOn-+B{Yr>zTQ7pXZWW4s5??2Sy3nwjQSdB&f>jw4f~W@z0jIr-<H
za+iYaA~oMPf6|m^4n-z;l!ETsuKBi>TbSwKt$)5KikOr<1v52bsVZLoK0naQ?%?__
zIXo_(0#bVxXoF3bUIxJtDU!Y74#(&GCy-Id6v@8R>)|whJuX=qqKjlVcUrKG7jr5y
zMY1=x3-{vdj6<eK_Qt78uI1}2R|c|+WM95Js3~9P3}lLAe-Qk!5ntzHWKzqgAd%Le
zLH(>o@e4@hvXEUQ`?f7jJoq{nB2y%LZ2g#d{1N#jFsbDY)uby;r_t+=YGrC`vVPC3
z=0?$F?=Sk)HNJ~B?b?v)ne&lJbsA0))j6PZ-raniuaK#rCNWc;2wkoHEBQ^e+T|d-
zf||svYqlf1#?zK2efE{e6scK%>0K+0nY_*)$P}shV&dhSrX!uc&JN`vyGYGXH3JMT
zw{{>?q^8Z9>=CB@O<$)~1*lV`X8yJg8?_5M?N86_fJ~8^;~YA_FpZ~v*W3zBYEMHo
z=}PnXeAicebhC;SUG{uYR`<i^JhK%t71X3Uf26OoiDzy?CS^C&otT5yb++M|Kai=Q
zCNa(S-?*TOs{QGwy?G@VPm!9F+SItmKaso@nIbj6<%lwPJTqfus8gio7mwbf`8xfO
zDN?h0yPJPswykmX<9Q94A~i$$+BP?7q-U0^0@+1s{@R-Hj)|#PGYFW}N(yQ=m|EN5
zg(mTc6dh<irq`Ll-(V<Lm7>d@FFJF3$s+y$7K}`hnnQ+0?BO5qeu7LIPX*nbyuUo+
znI6?3yGYIAw`UvtuE2U^iqx!LZ<WC>T$@*iIz?)FoZDQ5-`zVSQ>5ne7Y?QPCw&hi
zQ>13W;xi2n$pvaac9ELPqy5Y9YWf3{rrl6YI)FLds-2*<ymq~*UqNCJDN^(F;x>=?
zouhb7iY|M9k=OAwQ+VB{B2%QMbAcaY_+9fJGDT`;$`}^SU&oZL1=(qi40WeD8j;~s
zHSN>v<cH*G$W&01m?N7ODXRS|`62l+G8NP$X6F9A|33efyv~}nA-jT_#QfDO#)_|V
z1u{iy=IVOKk^l0=H)M*`-1_UX8-K0o<xbgYiWJlgaw?ie`|gESs$R`-L@KCB!`Wb=
z=T3(|yyV{z$yx`>6dh<gZ(cZFV`_i;I>#VWq~_5cpXxgO;c0(*=6}dkP?NHsEBihb
z|JvoI9*|u@O*$l(nOOY|-%5LsN%O9t`?HY`ZfW0RDU>XGuDVdCf|^vP{n6?5`7cUL
zLZ*V6#GF{I*9xBb0GSGE(j0Z3csQ0{>Z;X)>>@Q?`)4V@@0v@2NyBNVCPi=Uxcu)g
zYbIam5)mm<)2q^=p4zp6_ANVo%QvY{(Ph7nR;TeZH-|sG<ht)brbx{m0aZHk-`330
z0O}N}d4I*d)!G3}t5u(UBr-*6_8VNRIDe?Sk4yzMY2H0Ty5!<pzHURvPQ7HPJ24x~
z2)k%%Pkr{a$P}rWIm_{krrk)-{EAEkHL1=gMbF&j>ul5rvWwIVe^4v4iK)NVTn$W$
zuApYmb&CwXZuAk63TjgHT)vt5^TXMoF-4a>U*vXtVLMZF{S+-nrbx{_WzY8GneULP
zpeAL%)iHA){$_vOCXijEW{qE7qxkFWHOLgHIp*uQk$jy=$P}sheQ3!>JhOFE$WHyK
zpnHXYcX{~i;m8!JdA7^)AihrPW>BX{&2<6Y+n9P@uVxQmQke>B#zam};y>5ihe(l{
z{sW%A;F+14Q*_z;i?Y}pNW*{V-WQo7HMf4---oX=0+}K;Pd-Vtn4k8%Eg-u{%>f?m
zPx9?K0+}K;kHl27<m<eGOp%&ZI}a$&GfT9D>>@RLp8eg4pQEYBq@GvMJ*?A+c6={A
zK&D8|hu>?jHZAjdH7j~jc0wwsd7<Z=#(eZ(M2ggG@ch(xo|%A5(Y5B1ar1xj%$ltr
zx=76~A4=8WnM;u=QqyL0g<Jfze?+E8&Eb#2H}Q2gZVlN*YIcYWp20IWAXB8K_mp<g
ze0H-oP^U=EiaGWN@yvF}6sZ|_?s+1gJsg?jQ3|?iPXi5#>>XmdrKo?t$foVT>{Mk6
zW@^N4BQnqDW$y$;5;Fy)_WXuxpPbM5!3;+vF;fVxG21mi*q<NFwCyOk?EOXN&F63B
z*LZJaiew)==ioYie>;jyk?dE_opRyp%-$Zdi)7zD-qM|C`XN&!`~9j7Gw|6jBU2>1
zeOzBpzRp4&AiGHRRn04P<(U(ZNg65i=Pmaq1NrQ+$P~%mJ#yqgQ_t)7VYiNyo%S~c
zHKQ6;j^U%vM5IW~rssSf@yut)q&gLbGjz=KH9XV36GRuOnSNL<AJcH^uZUM7Q>13Q
zIwRilOWjvwiqw1;IqW=NXY<aGU8H97kwKCCc!nWUq^4if_!)f5TY5pAA~k=+KDo!&
z>4i*@nq%AUOXQgckttHM&B-)VP5ZE3O}j3Xo!V1D%~7TOp7X=m8<8S4OE%uyg^zv$
znIbixSK9H2Z_hkkAv$GO&^=pO4<BBmVaODz>9O?0d%n&{WQx?x*Z4&`zRn`uAiGG-
z1sUcH;_DobOp%)3LPs6f?#U;=FMkJ_A~nrZ*XqT8LSEY&vWwKr^Yog*PpE_-Q>143
zY%RC*YQ6_1wUUCG%lb`d%d6?poubQrAI*A9VrqUkS0YoS=EXsi{yuD>)vDj&J|R=2
z=7yT34W3zQ+5@uFcq-_gb652O{6h>IkttF$Q{>#5Jo6_qMQYm32<XD=?%5Nvi_~0@
z=4yYQxdoXbH7^tzu$s?q(F^Jnsd=))$q1g=9+@IFTQx6#*z!+rYJd7&a|bYK+7;CF
zAF*^PKb+qYDcUvHB<(Ob*m(A);gmgJ)ckl|gLe&WMW#s2nK$Nd;+G|hK2WDf&2}fA
zAK{m!PROJ=QqVmvYECY`&fUlqsp)n)U<E(#>3tx(NX;d^6KC?w9>^4_ne*jQgP;63
zf=rQ`7skG>%GYVv7qW}gOgpXB1zyemz@#ZsP&2e;b%S3}Ie<u!nlV!!4&qm(O#LW&
zInl29p+Pl+RlXN8MQTp%*fyNk=om6ZYR)S7_0R8GaldVztv_TJsafvvLLXku{>Y?x
zSJ1u4gD8W;{2645)I1nAs}Dc#`FtU}NX;4UYYcw!V+b-uYVN$@Xv5ce37H}_^F2Pg
z+v?A}Yk&G(({TW0r{Ppk^S_GSO7dk6K%_`b>z3!X@vG8lWQx=bj9;*lXXYIU(M4)D
z>6&Uj-||C|DN?geHtRdQnvuv9srm4f?<Bs?f`cHtNX>4|s)zGTe`HcGDd_Ins+u{^
zyopSan%BB+`umkdjjO+qDdh**MQT1g+d2zBN7IohQuD!l^FN1nGc)Z^ujYMVQgj71
ze>Yn&mLJaIgDE<E;ag#fo*zsa#7CcmOp%%{w@(}V0K#2liqwqgQRpb2z3dRkE>d%b
zUB+_!QWuO&k(%$Wr#-+gOOKE#Qq#3}kr+OE<)M&Wq-L`{Cl~PZJ|CIXp9;OS{B(VT
z2RL3JQ>13z`gz{-+1-ahc9EI~m)5PoKVP&Qm{g{Mn)NOX_{<MyA|ge*W)shx?tFBQ
z;S^o=d{N~6MuT|fN@R-EJlnnMR$iko$P}q*x8zt^UZW->AiGG-1$M9hetBNw>UWOy
z$P}p=m3Mv=pZzB?MQWb0P29<6_Z$h?MQVCXIy#YOZb2sXyn^mwtDZjLKS8h<1$Bzl
zoR+1B6@Q@h0wy69)LiSH*He2~KKTRlTM#KybAN2=%Y1a3(G<OsXxIFaHgOBj?1@Z~
zn%h2J|HilH31o`Y44*c60?*7o2C|FPTxWGDm~YSi$P}p=5ncI*_U#VsPp|uFWQx@6
zS?;PIpWR_BWEZJ<ByZM8(}xoJI)@`uq-IXr<@HQY?&z5pkx3q<pu6@o(4E`$7i!OD
zYk&IZi|qaXWhY_^W@^M2BR;j^WgiGc5;Fy)_AHS3XI~e-k&Ymem?;F;m|nK&TJU?O
z-8c#^d%kGPgF*(s#O;erk?hrHkD0~Sc^a7_+2?h6+ns0T8xPq<vOgF%(2HM?ha*!Y
zd&0TpKl$_54P=UBulIVxJU+Yg1jsIuJ^l9%rTImE3Nl5qPw&{{I=|38Kqje~LeFbz
z9;wqk2Y>ZiHGs0y{-&VjfhR+n@zJLtQlw_ZgOfJ!Uy6E!OsX@5=$h{SwsSi0%o-CR
zx=79Thg$yT*ZAeg6sehYaw7+aKWnk}r(fgWB2%R1)lcn@@@lr51ldJuX0qrR!oSdD
zKQcvXF1zn_ga0C6uE|iRNKNm2O~><fjz*?P&HGk9Tlu$T#356pW=yIyUi_|EbqZyt
z_B2$JzWTbnPJ*Y_^2v|Lfru2TS>mYUI9{U!WQx?>l<N3m{`loS6{1si1>Ma%)?UrG
zQV23dYChRAb{)UeB_UI!W^Dcph4|g5^)$#XQqw$7`2&2N+mR_!)9Q7|2L5a5*3+R*
zk(zto9J$2L(EwzM)a;jadmX+%qme06^GNSS8F@9G11USTlA)UP9mvtM>}&8-GzyU-
zHS>q1v*Vf9kttHsW&P0u{BV{Eg6JYOUo0Jcm)|vmkxApJp!=-y&#Us;A0ShtrtP}?
zOL;Y`%z*47H47}9>de=<0GT2+Lv!7*=b3MiDN=J)nI7>xvtck~7pYm~=&m^avB&ku
z6sfr++u3paJ>TEJq-j@BGu^ydzxgs-%%tdUA~ly5eO{2ie%*phk(wO>XBxcB*kTsc
zDN@tRK34(0<vSx&q-IaoMc#ZX?L#Kbk%I08#uXmJk7wrDkX@u^jcj3k`FZz2rbx}8
zj~5p4b)G_|NX<vLH_YOhdFDWNk(w_yTEF6%Ly##_^LmSeV@!u+{U@cDfJsxNpr(KE
zgi`zz6`xDd%Zb#yW_RQ^&zy`*k($4&O!&?-<B=&+bGyT&hCH+4JjgCmb7+>fvAmk|
zkSS8L;odd|2in)jq<L4+{r1j^m-ssC&WG$GHEUn|R*zrm)*w@)rgh;y4fr~fkSS9$
z%g-D<v-JYVE>iR5>1I_;CosL5;lQNfR8aFxFPlVuI4u@ZnX=zU%MmtrA0NFFGDT{B
z&pzlA&)knpk(yU}6~4x=o>>+_c9EKGHZ<<S>)sccA~kOow>S7k?P+An)XWuV@Tq40
z#gLtPNkR8%rSsn7vkyn6OwDYAL-={Wf=rQ`>-Xgg<e4RwKz5OuQyw)<V`A#noC-{e
zuApY2%1sZMkor4{4-hHZHHSJjNyjs*giv(Z`-@g&wrj|1v<R6ZHFv*Ay3V&!A~Hp4
zmhH9qDbK9G6taudTsYuxQ9gSpGDT`WdiSj-UuP0BMQS#;2pMA9IrP2MY8hmw{#4LC
zY5UD#+TCvLPtV+hOp%)Bo+V`Gx1&tUp-z#SN3T2gFlE=P=>tqEQ$ful4WgU#8XZBT
zNX_TA0S)+R&#{7{%bqW~+<&+)-=2QR6shU4HL*Qk=LKYn)I8&G)ZiM<X(ePAsd+l<
z9a}!TKQcvXu4uLUI6v<<kSS7gk>|the9OD8g6twScaE98oUbzwnbh+Nx<BX|T#{!#
zMy5zjyA26*P1*Ho)>uv138|oF=hUCy@a?%6ks>w6dSq|Tx6(UgiVn2zHij77u4=Fb
zqKniVTKQlZzRtDC6shUpdcmI`&+o_-sk!>dQiEGytwSNZNX_1*3kUOc?m(tU%|`ii
z@8Fr%YoSh&nz=1=<>#5*kttHMsl&lMJo6|r$)gl>*B&`=yxF6uY1h<0UzB5=DLZ_R
zIt4Q|;@d?3)ciePA0U#LDIm3n1H5ggROEvnMkFy)2(B@AFS&7uXJ%VZ!DY`EC1$*7
z@Vw_hWQt@j9k_b{U*|bwie&FPFZ@2wbld>hMY4B(SYR^0Z;U~vNcNzq=9f(ShW_Yz
z6PY5}-$d={$JbeEBV-rJUZnVYZ@$hTWQt^W_l+IH*ZChZMY8XEzTu$tpJTlCr{9OG
zZ=&q9zbUAB>f!YIe3`QlDN?gk>&|BUa6U&S)v2KSyrdc5_&RHEhUg+Svkbp|k!P+z
zrbtb<{h99aYJNqgNX=QDvw!8!3oXMSyGYF?cH=Mdb%r5Rq-M?~&fj=u>Mc;GNX-kj
zW5@7JFJy|;3~blyG2fpDkSS90(z4m<`CT*fR?1H8si5ZSzO4-IrFKW8NX>vE7pC&j
zk0Dc}<~zT(b$E?(Y=h{OT|xJl?;Be1(>@rPA~i3yo?*djbQzf<HMd5GoZ{;&xE->K
z)O2>g_?BmmL#9a0E3+@wG#wN5JMnE~DyT`%zqS1AT7iH5&3Ol87peIqPpgUi<Aj08
z6sfu4SN=}CnlFJ#t)!r4*M*;!@nu#Er|59*R%rQ)*;WLZKG4-q(JEw$)O-|>XwTRA
z8<`?CeZFjt(|+<I`OjW-+X>leJQcE6c^7bsuk#EtMQYwE5T1d5D!0fks8gh7g-j<t
z@Q>6@MW%w9q>*D_+8~XYd_12bQ$bC7{%x6A-e|tg`nw^!NX>0qBZB$<+>A_-nrUsK
zolHxe{y=NJhw7whS5R~HfTR)puZVafQnYKXunN7+xBLZUiqy2cVRpdb&$MfQdfiLz
zh3FzR9b(rl;Il78rbx{RbEf3vv;ROQ&5?rci(g-vuKiG!_NUL@bsuCGsp%LQJG$r}
zp7y6_o<gRAnxxUhA+7Q_{^4nVdS==EP^U=E2^Mz-^FNfe9GN0D?eh0Y!!y$yfI3BL
zmI+<vU^+4A)f@~=nj!@?v;7zI#^KLUYJd9SJcCG)n#)JtJfi*fmiDJ-mOMz&W$!Nv
zUuCnNe=2t|GDT`Oex5X6Tl2L)eVreXDN^(Ki|uaw!Mph($SzXz^Se>m_zQ$B$fS8!
z&^@qk{7b&h)Q6!?k(z}LwYK7!U63hK^YG0R2EX)j2$>=^-=?+r!q=Jg2xJ$j8GO58
zQ*Dvb{`6`N045Emf|`>D6@S2&c^r`<H3#-xKc7D^<UUH#Rem3hR^-hY3okOQN_ve(
zBU7Yii$3p8^Vfw@$P}rW??mU)JhSjI$gZF!9TZ<xSdmIQENM%VKKnRiDyT`!Cp%sY
z({$J7UeCOZOzI^C-P_*q4dR!O(#IjYNX<O{C&%;5AY>}2N!jg2l>e&bPX3Fk{~=SP
zW{+K8N1FOmuV(cVl%1j*s!3%|iraffn|AGg^iwn!ks>uS*i@>{|0eTGWQq>7HA_x#
z<(UmmLUfUueL^Gm@;mWHWQx>GJ!PB?e_fb50_s#yla{6QuA>t9I=drNq^4Qeo_-oL
z`PU0iAXB8~0hi`;_&W2Qg6!0v3c5S_mkZ;^b2Ks))THt3W9NH@uk#KvMQU2#^7;2k
zsb0<Urzty?si0=BONHC;Qxu3uk(z}sG+W7Qlz>c;nsGLD4)eoV=L|#_sp*k-<6?f=
z*C11*W=+S7CHOkc&O)6cH8WNC?awniBU3?5YR}Xov#sI3QF{oPA~iR-etN>!nduy4
z7pXbMy3bE-+ep53_#%^fUP1Ts#cJN>nHP{LQnO;a@KyXB+Ct|kJ0TU+d@}PwZmmph
zNcFqs2t<n1Y<j%253lAmWQx?>QnvLbemF~CfaoGMefz|1;_IA=Op%(C+KoxYAHZHB
zQ>3Q3W72Wc-9P;t)wu}SMQTR+na|{zE0HNubJyoB(foUXz9LhkW`6s}*8DB7CYK<)
zNKKE&7t$8~)9>1!emujGNgk!3yY@8Dnhq86m=3i1=Zo@R{#Pe;yrG%@TRb&l>uQeC
zyzGO3NMfdd)Sd-OH*tJC-<%PMBxVZ1HReXgOi?^DPb3AGJzrF0oBL0mITV>9+0SQ7
zU54L_B9SSQeRQ962H&f6ih}GS+2`kU@5)~hk3ptL_N)ssdGgF_$P~%$)OJcc{+&oA
zq9MCT_MNLNO7rtR5t$;{H*ay9$<KQ%G8JUkwx6_Snwqz!zxn$twpOeDh+O&#WmmRc
z(`e20WpDU0rz29NW|6FJXZdN5M<&&&qWh}epLk~Z7>F)X^YYF;MR?{cWQx>W5w_nz
z%>-nM)cmx2L3zIAt6zoeA~k<ruF{HUE<~nCP3!HJZ+VSgAycHLPli1s`Tq2{2H8bw
zK3QENoS*k)$W&01cFk+Ea+~vy{(S%@wWq?a*==y1+<bKR>lD3=NKLm2V+<Z`4?(6#
z%{_;Un)Ac?4w;l)LH8;TK6c@=H@E@WMQZLVoG*c|a}_d0YWCjQqzBLZf=rQ`?>3yQ
z#B0>-CS(_>S>fl!F1+rWkSS7g;D&ym_&R?hQ>5l8%hXSJX1iOEU8LrK`q$3!2il#$
zq*hW;Gt0bIz4<aNZc~}E=ZnfNc-@U}rB28cso8P2TOnSfJ;)TPX@5ATHeaXB9mr1O
zsi1q5bHE9n>5WX0npHccGWhv}L&y}Vxq8;^cKp0&z6;q!YTmrv@dcl~FET}HW<PCp
zgrD~aWQx?xe|U2|&&(MM*+ptr>(}bB>FQN~pdA2Ansx;>+wGonpZ}!vBqBw-=5)I@
z&-i<(dE+R$?Dx^KuClMH9Urtm{mp<e$P}r0ZE7uFK6@lGMQR33IAqPYe9?Q5o#seE
z_rz^)4St6_0GT2+A2w*%jK8rIhfI;0?n{1$@M@NihwLIXo4hDw@Meoy$P}p=*=xAL
zn=PIpQ>12Z^UOa@H`VlN*1k{KX^Iro%=@lzB0oio5Ghjgd5!@)`Idi+Owq1+ree!^
zJhRaQh%Qnyw#w0+yha<4DN=Kkuerf@M1CVvq-N3KsSLi)(f%Q1r+HV<{nYh|OZj=<
zjZB%E?P50b%nXm9PLZ0Ht1S$Eji)y<MQZw6xANqB=>#%GY8E>Dya9ip&GR2+r{Ppk
z^XHT_UHLM75h+r$Zm+@l_$fM%Op%(0<MSWknFSt0bdj3b9@J^XGshxRq~<~Q5*>Nw
zO=ODH^qKP3j^B-3pFnnzntiU1`TOvSR;&ILG98)JOA5L_YghCIpZyUsMQRoc{T;;j
zXVnDAE>iPrxgBYF=3-=u)T|#rG8eDrdtg#@1vR~^ncMR_N1dk>UH1EE6<n-_@zGZx
zQ>5np(AIT%=2v8j)a+Y(yFZ`Z^BH6psTmabcp6{lR%D9QG~c``J+Ee(=TN6e%}nu6
z4c=_g1(_l>M+PMrJn4H7nbe;Ox?gU#Fod5YyBCmMq-Lx2chB>4<cmy^nzk{11^GL)
z=YdIODyVtdweoj9dd`;=y`pH>oKhyJAs^ijnIbhC$8TH6x94SKiq!lxuf<S)l`r@T
zvWwJQ7ufO)&m4zLk(vc9%|G+Z+sG8Dx%Sr&3;tQ4GOr=KNX_StUeoxmgv~~#NX>u+
z7v7m}ujqI8x5%WPSI~XJ@rb_sgAsKSA-hP;AzOkn^SkCoU=mV6&7@&&Wq6IgAyTAf
z!`-i+^18QrL(yfwk5>C~?I}ES8!|;|POFt}HJ{z;Ez~JeGfiZ>`8=~5GDT{>^gDQk
zXC6VONX^S`t6ce|F2_5_E>g2f+0F*fEDc1aNX>j}qj&LjUO=Wu%}MRD8{7|Yd=J^l
zqZD-49yy43^lrFm3DG}aG=`Yeohg{95zChAmC^K3l>Ww2BoIl=6p-3O3@xMU*5}uF
zrw{*vmvJR#3c)qzRrhQLH$wc8DcXl$T`CgEH~cMR(r_x&S+h_5dpxtuN60RcJ?jXM
zYW$)!6PY5}=l;&wg|9OKnIhSjz0Ek5pZ8jyAiGHR3ZC5z?xik6rbzbv_sbaE^ZkTO
zk?iX~nZ4#0kY=ADyGZsmRcvRP=18yRMqpCQE2x=py0pPPU-K_iW@(X{8G7xs<)^(P
zGO11ljV#S-dh^4%7nve8r(dr%ov$;)SI90>)7QDwXui(g$P}qraD>YezRu&w6sfuH
zyZ;uRnd=*57pd9Pb3#r&`w(P`)Ew5oWHG+ZOUM+dS>xou&U~GPk|4WCO}o*T{=Iov
zuckjRsXZ0cG;0xb!(_Yu>fj0@MQUz+|KtqMEb*P9ml3I%=AKPuem9zmOv<jHyMNEU
z_4qpPBU7a2&*uq4d1mDwkX@u^nBTYgeD;ON6sZ}SvCTW4nTSl0n*a5*pTTFZ_Y<;<
z)STUV+jpKBicFE3UFPjDc;xdZGDT{-<aRW8A!qAfl$}~hK~1j*(+pk?y%CWjHRJnV
z@5`@r=D(p#k(zB^n|bgnT}Nb!)SNxyRxDrVZe-GUD(G(eeeyG&nZeA`td~#!o?S|p
zEmKycW{Xkt_weo68<`?CCnTOK&od*CDN-|styct}J)b#b7pYmr!TTZ49Dz)cnz@&j
ziQ{`I2ALu?-N%Qw;%_V!OGVjf+7;An{w(nwfA4P$B1LMN=Uf_Ly2#e=#J7<tQnULM
z&oulqOU@P$U8LsPk6zI{a|SX+YHr+H(%`-AFOW%dq@erNH9eC|w;1%}>7E+0i`2{+
z?P~DV?4`&Qsd=tkXFq-?{(?-An*E;KT+TC_TS9h`nyaS9edNb;GcrYLKAQHmfN2TQ
zA85_2s7{(91vRrwOE-a!-X4)6HIKEO;L9_2AycHLf0s{7`0tdaO9RnGY8Lyj!)P}`
zrbx}T&x%GE>_*5Gsd=mXIfL6P`O-pmns-Cp|M#^h?N(j>a<w~aFS1Ggy0Q_-6scL|
z*wlsmcXV$dQ$bCt)343ZBHF)_f9JWJHDnj5nWyRAL3}UGMW#s2$+<?(;y)>U4NMwN
z1vPg?&l_TTnoz$YSF@q$vfoE5HUE{ti!SFOQ>5mb$O;C(cJdjSA~i#6oy}`n>Gau~
zri1JXYEml|zIx3`YkBPxLp^g7GDT{Zy#IJKf3iuN9_mz3^M7B9($w_75aY}<dm@v1
z$xwG<URl#PEB`Xm2xKa#Nz92E%8urBFPH(ci`4vF@Yxjp{aO=|DN-}rz-tDtv3>+h
zimssMqIpge_~>pKDZ0w@Mbw_xU(fQ@qHEKnZ_jzi6sfr)-xNQ7INu{vq^9qt+q?Ky
zYH17E71X3wiru?(7C)YQkSS8rJ$uv^K6{o-P^U=E3{$o`@rU`r$P}r0<5}LN{6h>e
z$fW*M(A{y=j*mREOlHU~QqynX(omi`ADJRGt5(i@)pY%;KhS;zCY7n6ru*Di&H2@{
zQ5K3Wd%mbah4AhCv~NPDNX@nxe}wUMrpXF*iqv#FJtr++XAfkG)GW6Dgdfj5g-nr}
zQ+hXA&NB<xL3WXvwLWco!?$MuGDT`GA5^6^&wPYTk($kK<n!gTyJv&!)bobA)7CNQ
zyYn)QsV#T<ts@kfA~o~$?H<721~Si1brMoV&FCwo`0GMXM2fC8581E(&0l73MW#s2
z={1T6@z)0yIUu@7&1c6uwC0&zkSS8rso83ScLy9srbx}%t4ieK=g2N6WEZLVrDEQ9
z{2cirQ>5nSpP$Y7I!_~0q~^7-LpHqb`Eo&a1vTkp)1jpQE56Qg$Rv*pb^jkzdm3oy
z(8K?}2C09(=oT@llTt8KBM!HHAH&ODB=^7M@YU=TklIzum)3DEeDG0-6v=*O;QPb;
zbCg$+DU!Wo_?cXMbC$~k(M7T^zOmKd)52h6(iEjI>DqW!u`H68AI~Sq6v>`_@z@-E
z_Ud^dyGZuhy^{=nC~F}yMY0Fn4erNZ9wZ`DBzxk1zt{YDHqHmxMY4Yz`)fCUrdy9p
zk?c)Io895nOqHMNq?T7uv&4{M|9&uBe_UvVNRgUPqjDMOz5|(5r$Wo0+?Tg5Kb&dp
zA-YJ-Y7N#O<L}S*M5aj1G@Y^)<e4XsDN-}U&ayn8J&yxq7pducdEX$OITD#7HQ(&q
z*O=Gn1~Nrz-n`_ofgev7N60Qxv+{^_Pk3e^GDT{}bo9Py+K%*BuaALA?Wv$<(>xV+
z@>5i|07aL*zi3sy{<C=IT4ajUOp`uC2Y%YkoS;t1uAuviCL!Vc6tzdDNX`E~wyerC
z_aIZGX7`ciwmj3eAY>P*`Fq&nbo?CkMW#s2AqjgO`Ad#-$P}sReLlD$e_!6I5M&pr
zIkU~|hkTv>$P}qL#pBUMQ-A8!yaP;XB?UDL2XCLiPf_W@6dex93N7!PD)a^)eHJnm
z)YK?x&9sB!?oFO?TAj&n2E0I~f||rUKd9_j?VfMGWH%V<6@lzDo(kFjJGXi)uhC{?
ziqu@wukkwmo^R@+P^U=E&zUpk=dTKTAXB8~v(9y=@fw{$rbx|z3;n9|hk5&AkX@wa
zwOz6QnKaU$6o(^Iq-OS=o_~LuLz{cOn$f_dX;)A)X@B*)yhg=}Q*<}cfwtD0gd2SH
zDace%lWqpo-d3|HKkf0zR8W(cRg?M{{Gw{b5|CY_<~GY&wfL5wk4%~)1>Fz-Om&b~
z^CL1vY9`gTnZYw#IYV}lnlEOQO2_xo9%PEtv{~5K;ECi+C817{n#BgU`OWvI4>Cn+
zKB-i<vgw&Ry_ylgq$yHR^JK9=FVp3#eg(<qLea~K)V!TE+K2xHvJWyvYQ8VMFbjWM
z{vt9(YNqpaJHu;KtQ2Gysrl&q-B*0e2O(3W=D^YoocNQ?3uMx~E9joSL?=(4S<e-+
zi_}b)t#ewQxel2kH4~h^FXS~cFAa5y)ZCJ~_A;K?0huB-r+2#5msfK)Fljgq)ucn+
zr$q-pYX8#ONw20=8Hz4@zNpBK1zq_U9(p5FK~1VNH0z2ut;Xb!svSV4NKL!kUtaTS
z<}3@@MQS#7sOH4)9HWq_peAMCoc{c2?VzOH{nXFV4P+{)Nz8A#fBt<{TXLrB|50|9
zVOeZ#8@4bowu)ja*a?a#Vh3Uuwqm!~g<@i1CpKbtU@O?&ir8Z7R_yNjoc$h;>zdDN
z4%YpHAMPLLzOS|JbJol}Yi8UbyXqxN-4(NEt_JyxmN)*3xz35m)KF6~XNP|sXq?a*
zXG~`1Lu6{GshFv+^qb1-EL9A$i`1-}ci9%(S)F;+3<jo(uA%0J^7avY+Fu}2W7SmA
z6J++h#iLg(uA+O0)Lhm-?7y!|{yptWkg1`js`KQCQ~$k;^zZikicAeP6*HplVmF?>
zp$B9ashP&kw*#M}jmQ+KxpG;?YDOy=tDL#zlazouMQTQeRvN%HYKKhKpBlQ~NY^J3
zAI}J6iqsr%{L53$bnt}iA~kQ<+~&qt&2GR{WooFoX#PrzDcX-nk(%?yC9K4wXDF$n
zmk_C$+qXduV{4VsqUKiWgG`Z{n?HO#ZnWp$YMw%-NKN<Q?HqW^=PU);HPlqs#OXtZ
zIvX|qUFR@lYN)B0RVP&S=ggbP)KF6~Uzh2)(>O@|efTU{8nSDsshG<a#`CtVM&@~+
zjZD?^mbxou=E(i6c=p%G6scLytw;!0vvwJkT_G*iRAo-v>)4qO=MqF}sHvExyDuEW
znLm)Jp{8OEOgX$HAI_#_A-aZ|ikYkGjP<<EoygQsQ!!sg?6!DCj6*r7Q>5mTJE!~c
zI=drNq^3{qaryXl;YnnQ)J!<d{T8n?cX`MzQq#Hhb&EGhjzp$N%`b;*_2t=bAyau2
zi|)p5pdJ-MJKEGV?=LD@;ZJro>#>+=5SvyWTETWuGM^$(0-_Q#7Nqer$FD(cx9|!2
z7m<n?OK^kPvC{BU{Kis+iYmD5`)CgjpKQpP%aAFOecR>l@j27364WV@{p#l7PqY4B
zi;O?>y3q-lYT7l%b7s%2A-vAB$kdSCnCbuhyp=u5p@8wPzfX}}y&$_t_R~K15A$A{
zh)j{}G3_2($o?3a8nUbGF4;C#;QM?lR)*{%*-L!)s%ISXjX$%ROMt1?Hw`uI9)HPi
z+ZSPOrMHL_shPyBP+5M%rlGfrUPRTY(Vju)&yD4E?m(tUO^4xQD|2RsDp03L%_r}N
z&*#h`$kb3%wbB}w1SO4|YKETXIl6;P4K>yI!s-)CvhaK8<*Gt<4K-DrA8-6TYy9hP
z-9wQnQgdG|j}!d->nk!vYHpu=xvkUhI<x;Zo=vJjc9EKivilsdt;1$D4**lOr-qv8
zkBtuGKOZ<$S7plf7uDz#VrNW|@n>$OzQ`1*IVVn<XSNdtGxIz$Rdx;Cmrj0mm`{7Y
z8jxM2=EBKCdf6UeGS?Y|Obs=aMo-_l*W%glAXB7fwlaQ&_#AoGgzOq>sye@W4$8*s
zoP|u0nx96rcjwGk$kb3%)!Dr6D~tE_SE~itMQV1fayXc)xeS=9l{C~G{9|2JK1Cl9
zDOxov_P_g@52sIU6}_lP%?<PReKl?>{e5F;Ju*dVMy@?NjBAvr4%Df}Q$zRcZf+JY
z#%_g7k(yKPhg)pm2uG$!&EUoHEXLEJE@T&}*=B=xAfNXh$P}qLKmL?$#!X7&&wQvm
zflQH_B}yH+$j=y@>p^yrnki4OJ7e2%U|uyx08>r7hMMumEvU=Yj6$SH&2p8GTfA`E
z#YaWg`97La+5fJMrsg_X)fmpdPwK`aQ>12_v9B8P8w@eX6scKc+6{|$!B?&i+0`6r
z=)P;r$0%OsQe<kVsm3$i4Cf3^zsJ-0_n*1te<4$(X2bJ^+VMI&HGu3QHOp?x)|sE#
z96_c?&BAYfoZ*L%><yt#k(xs{mJH!)4gsc`A`La`Z}VEkk09p|DN-}exJZkQ=!F`o
z=*2{<=7c!4mhltsamW;@`D>}e6rMc>nIbjAw&lLYnN=D?c9EJ_^TjWd?YBb4pIM`o
z$W-&Lq5BNqGIw~L$(ul(A~g?HPduJ8yCGAgru)?C*ZH;kX=IAjY!ukI2EP~L(iF0b
z)bx%%5zN(`3QRSe8fu;x?Dd34zlTVXnjV9<F5((_HB-@xi`4AYee6ljT#ihUnpNMl
z{mPHX37SKlA~iz}oS)3kLfRrzq-If%-uHO+eaIB4>2FtXfbpQf-wz99^@Z%Jmo#+G
z+dFkGKAxkHDN=Lvl6e-lf$kwwq-Nt!n@98UEY||Ei_|Qzujvu4<|1IK=o)G+96kFU
zAI>+36sb9(PoA<odYzUky3YP0b?KhL>F{%YL=HoyNX-k62aMtxrDz3piq!mZ*y|D>
z&#uT6saenAyeDU#K&D7drwqd_#xr+o$SzWIpKsx5yv{MmRQ;);dxa7G4)c@b2gnqu
z={hnng!gCpHjrJU=8{@ffAHHti-D=i)KGKc_lO<5<=-JvLrrxZ<5<1bE@L?VzAp4>
ztD?*H7kT@3eaV?&$P}qL_F2LJK1IpeL7gHsuly)lkTbg>Q>5nACw1HNmOq0`k(z5B
zdTix~rTpz7yGYHEtBxe#*~cPNq~^{pPP=*bN61t?uc3RU@O6zi)2jny7pWOD_MxM(
zkQjgF+dxZ!sgN3KKI)X94Ij>Th}2M1t#I)|mJjFA>vvSqW#318czDWQ-b$O1DN?g-
z^nmKT&g7k-PLZ1DlKxo5nSRI=srh0>y-ED=c@mi-HJ!cUrQmhu?F`vPYI^VaGK;Tp
zW05IR)4P1|6`uV8GDT{R+ug>4XRp`=vMY~b(cRb$^z!W4hPGAHyuWC%VyYR6#Y}@Z
zzeL0b8__KLTOcYiV?i2wfv#<6(1r)E-1SfJVzTd}?Mxe1F7xl>k@07~5wZ-KqN~?w
zVRsjEW+FeRQzZL=@XH@L(+`;<*&~)rOTwAwktveB^om6muVF3P4YI3NilsS?dGEG$
z?G--n(~&8Xec>SIto(rd3Yj9=zo+Rnkl&xJ(H*jjWWPHh?k-;E3S^38|J0(u3a)0{
z9;!~&@)~NEc+%o0pP~kcRJv<S`^WM%pYrHikg4j_VE*`0?;vNU=n2t9YSznlqabH?
zMW#qi-+T)f@bNr`Op%&ZlU=sh6q2(SWEZLVIN#3%e2d};WQx=bT%Xk9QGrLu6sftn
z=*a<GO|RaNU8H8-8i@+?c@IUVNX_a;T3Os!`U*_do*HV7UNFgG+jPx7D!Occ(Yqnp
zGxAfV)yNd7dA4QIDSQ)yU0<kEW!KQX$-Kwqd7Z71DN^&cUGdlalx{CFMQToQh`*9E
zGxvk+A~k0hvv1CSk{FCkk(#eux3uOjG`WdPk(vdv_AX>wjm&3YMf*c`k(#%*j1J?^
zJO?3Dq-LHa=PZ7XxdlwsN*Zdqq#5y$PrK^?6<z23MaFUHe;W?I*tM@{{L5H9%)>ba
znIbjM4A^mmuSQRiDN=Jl*2v;KdsTnPuEtYC_ZsJNxpC$yWNN6X#xwHUgFVJiW`F;5
zl5il@siCG~##=T$xpCv~?~9Hu$kb3%F}qZHHPrYu*Xj44dEQSWQ>3PE;WFP0-rr2O
zL6BXfrtkF7NIpmNkttGh=<RPU_?KS308>r7hMMKO&MV4WzFL5aE_;7bf(7T|@#w3N
zDN^&OPp6`Mg-bXX>J+KznQh`s{%c`7WNN6X+B50C=t;cgPaspxk%sOrebSWUD_s5|
zkX=Jfb@T6;|Ei_D<tHLjLrukeT_&N$gA(tMDN@tZHMPYjDjE!h>>@R<%$(bRf8A(1
zGDT`;zEs*`f06w#Ri~OF4K;HXuTt3d<E!~d=Zi?uwPrx!PhLEF7&1j_e%-U&pEDB-
zhv*_T3s#Hq;n|xaQ$tPFp6gbvI>zf<k4%x81q!_Xz?pGJKz23n8oEb~%{qu*AT&az
zNKKD)Q~U89w40GBQgc|Y-d%W|_JNRHq~^~x*_&}@2V{!W?7ew|#je}~z*NJjp=P<x
zPL6yyQ;$^9W$!Nv+v5C;NB2XfNKO0TmhbuPfMduMsX4cFsoi|TywfPiE>hEfahs03
z&Vk4jsTq^5$O=B5QOFdj+2dj!i?5#+8V%W1FKOuRIigJ-Ugub3iqzb<D4!1>&wI!e
zshPU8cSX)DH3qVa)STaM<8$KxZTy*kJedVd6<tHk(QCgH;blHTq-fO~v1pqgZ~5|L
zRdm_@qP$6FJM%i{B2%R1>M=)CbLLxQiqzb&yW>jEtQiE^MQYwX(=Qbt&y~m&sTntY
zk{!IxpU4!c85rDb3}-eO2iaABYUm!bHM%d)z6F^gH6y1swRm*RemvAEQu9%>jUkDD
zYiazM)oc$;Ri=iTb>rJ7;={QWks>vJmZ@v;m|5}(D!R`8B6Xs;#o4_$pQ2946shSG
zTJA2-z8{$)H6vOsXu#{tFcGqg)a;Y+_-TG-(;Jy0HAlxiZ*j-_6f#9>CYT(um#><+
zCP8+QngN44ui@E8AXD|chVDC-+WYW2uOm~W=9%_qxA9feeX`1~kQ!=Uy}ZEU(>Y@h
zDN-|I+zu6a^xMc3ozUJ{>)w`6k>?bME>g2b#*XiJoimUrQZuU0`<h(M7swQ;Ie6+~
ze|`w5JQcEw)ch9zofl^=LZ(Q~wdr4f;LI<`6sg&8#h9CXj_OZ?>>@P>t@>vy@1>2%
zR362myRjQ+NYXSdZEBkL7bTkhr%pARv6yKPlf1fg#MVjXb+|DQm6)+0jeRCx5<We{
z2XiAL6*HFL26NDa@L!ynWQGbZdw)^yYl|Q932Ki_k?eV=N7UwZ?nS0Z_SIRQ4CT!9
zGa<W3cDL4po^y%%B2y&$BD-UkZLMU!p?DUVsy#L4J@l~ScV1_%V8||#J!_rH=Q(pY
zGDWh_3FxwuXTOe2k?a$H`o-{{V~WgD+12`{p=O;1-otqGKtzhvJbx{%#Y;V+k*Vsm
zoObmyNBL%5Tj%+GWl-SvpShKa&4%bAHTQ4mK8WkS9GN0D9a6;W!kIsiDN=Len!6V7
zSZ_23vWwKboFZjK{zHBkGG%J+jrV}Jyxm-=Q>3Q-m;OPV*#em&HCHyvIEOR0BU7a2
zqXl1gaW#|AQ`uE}YN(m}O10&@%od0gsp)^VdRorhj!X?T)z#~#3K?>9X7c$EU1hh_
zT`|`<46`^@>VQm<n)h7amEwDB_90WGrroAgv$^hR7eIEAnqx{=T)~+=kSS90XWPRT
zUll!$Op%(G@>EE}>&z7b*+pvZdmGQ0_tG$AiqxFFdc{`Tq0W3ldj*)Pl{C~$U9Wo)
zUS@%XD!R`8BGvLUZk3J4nWK;?QnOO^9wRt28kr(BM<0)>$eBe$A-ft+4c*gJZr#T=
zMdsCgA~Hp4=54>%hu3)znIbh;$GmLAnVyRvyGYG1?_NZ5=5%C=)bu!gzac-=Jwc{O
z&2rmnd2nX=#gJX3W@6u#75J(-2bgNwHPqZ2n65EDDm_M|Xw}?srIy8YO!*}$y3YHH
zl<xf;7boT|KNp!IHRJZrew4S;OJs`FjJ)5c3TJvRh3smMG<5%2ckn3A3`M3$&D`Ja
zy7KY-h)j{1KJU`Z<aO3u2H8bwMh&mBm@}6nQ>3QL=sLA{_V36PsoAn-nG9S_pXDmM
znj#G~E04bz%GF$oNRgT!#_TE0k4oQ=DOxpue06BanLaBZx=76ud!Hxc+1DUbq~@+7
z`^#}=yp>R=NX_W+gM2u%IWpC}Yv}Hu-?1WRZbPO>%_jNk%;IyDd=+FDskw5m_W@pK
zdt{2#%v~hyJI>sTOp%&J^R2JO)pT5~va8|LQ1jH}_nUZ`9T6!~^J;~MY50+DKQcvX
ze(Q0~gEP~uf#@PNYhRt}!H=FjkttGhZU5-8yw0P@6sej2%ed{FnPn|x7pYld%Ez00
z-uoj{^^%6}KXdl$&DA`IOp%(wh31{%b>><J*+ptrjyPGHGlwBlq^67iv&F_ap7CeC
z*1QT#6<tG3x8y#H__XI;ucCX1)J%FO^%>ssBakUlGjwB_sl3iB$P}rWHG7XeoawRw
zvWwKL<JmnqXO2atNX_%x%a-NL+sG8D8CEgoJ^zuX_(sUCp{BZvek$-;Y2&RP#^!$W
zb@p^*s{Yi_-9N*_cwD15$P}sR>^-O}fB2$$7-Sczc_G23+<br0DqyNIHPo!(v2(id
z68yhkg#QtdA~ioI$}@{Uwby!+iZ0t<l%T2qcdq+3WQx>m^yr2!pLYArP^U=EjJ>8g
z@|B|<GDT_@@3?jpuQLLfA~omlaPGmG4qG6*hMMYrK;y>w((~-ykSS90!KLqgc%6rl
zsd`>R_c{su7jb6ht&m-$X4-feR`XS}KQI+iL(RP<hP32I&tr%bshR2RY>RJ4J8x6b
zW$!P#oxO_-uX7kOMQZL(_3Wi_%s2kbNBQf>6sdVVb7zZB{1n>`*+ps&otYpjKgv%-
zrbx}oMGhR{kFLEyrbx|{_S-k}M;2@Efb1eQ+l=#1&)=`L9+@IFv(3-(#CR0Y_%qLY
zvYk+;@+cPFjom=|ubg{mTaL{8i+U)gN^WW9|IR@SqVH43?gsIHPca!|5GPLD-+#*k
z4**e#X^B+F&d^pxzwk+S*!3s4htB(p)Tz>ImkP;@<}{uwH4kP#WQtCayG1!g@`k^F
zOp)vz_D%o9*LIh1$gUx~${r^&upED;bTl$WvcGNNAHZLX{Ro*N*%Q2ute5lm{1|`c
zIjR)_*+sJ7jJG;Vj^8}v&&&)*rfT_EBr^7@ZEu^i8lU%^yP-~z?77Q2x##~~qw#01
zGZ2{~**8p$H-X<+dIwC^@)~MxsCQ~NU*9V2QPGPi-8F`Dwc{2q&J0DSs#Aj*8rdN?
zKdt$KOp%(;XFprbUjyc|7qV-psSb6&GS3X-hq@ie6sb9|dn${yJ>5R2Q>13qCc6*v
zmhXd1k(z!}OaAw5G=pny`SZvWshPQ&oyB=#!Tpe3q-NFIZx$E_Q{&HEXAm+)YBs&R
zV}$MUz<gur0Wej2YN(mXKY<<B$n$`TE_;7b@|Ua2@M#Z5rbx|1wa(AsYQ90H%C4dN
z_lNDH__oLD2O+yi&Gc=Ke&siTmLpT7X5A`D5Aiy`BU7Yi<mo1FIJ40q$SzVdFtT}h
z&fJ7dk(xz5&OgNa)BZ5jDN^%pn^WaEvjZ|kYQ`<lKX;<vsvCc1H4gw&wUUOKtzXRR
z%gao0L`9eFFIru7#c|%AU63hKbFqj03eG%;Op%(!q6<Fat(4&?WLM*<p?k{@zbu|t
z?2Am1n*Y4~Zt<+<S!9aTY<}8z1kax57-Scz+4*HIH$F#!$P}rWxK`IIyw2;$6sfuV
zrQI>kEP5QWi`1O`_4P=8LOU6lYT7l_%-Ob)#luFo5GgvLz17X*2G`x=go-ZPU-Wot
z^aH+X&OoL}&BJ%k<>GZdL#9a0SFig8@;bdwLUuJr8oK{HJ^UfBa}hE{YC8LV`14tJ
z^GV%TWQx>G-uGl%-trAjL3WXvKCbo_KW}YBrbx|dKk9VgbCmEj)G1PPQ@7^6T+LR%
zR8yp(=3>9pbNRG~AyTB~k(8BA@hP%DqoT{ckCraaoR9p7+#Z=CHDk&Rf5PkBgG`Z{
z*_xCH=5;!rh3q0VJy*N>@j81TQ_Z`E?v2Z($z{7oX;$+DGDT{hkL!_%w|wSvkX@u^
z_TU2*cz^asrbx}D>1X!g%t&O4)V$R%YkYn}Tj0FPu7*=X&Ev!7T0Cks2$33Us=JhV
z`uUaOKW0ZEQ*=W6F8;K`d^p`AA-YJ-MMbl3<;=;*6shUfsBsmpQ4BIgYGxhe*Pb&g
zUV!W(HEZW;wv``3LXfF?NkjMZFH2cmAiPJWNX@z9_iW^IR67c?i_~<_e{mmYu0f_q
z%|}B@B;c!Nf{Ut76<tHk*+&;0<VU&&h}2M1-KFeMB=R2~eFHK@YJTiH>p5?w#Frqt
zNX`5|>sZ_hX^l*gnm?13oWkpjK&D8|Z(XwW<!YwB4B16$HX3`m9j~(+GDT`mt8!)u
zuk#2pRex&e-ttR8TwZ6^E0A5J=0V@{DS4d(kSS7gVum#hxSEl`RAp+YIcreQw7g8G
zt15a4k(!=2;@EL!05U~t#?-1C#F>|nDN?h2iG~(i>Rhftc9EK0eT&!Ub&f@*NX^}+
zJ6_<-yT}x&S*l90`<z+wI%F5A+0P->4t_`uMy5#32`Ps!=S#;cWU8Lm&^<{Wmz=!L
zsy86JNKNlzKE8bG-!fn-q=uTVhjaAg(cdCcq-MHxSEG6K8qq4cY=6<Wbj2;MiB}?1
zq-FxYSzi2z9QP*FDN^(B!LOfq%Qr=)NX;Z^+%0y{Zbha@&G+k@G~{!X;ud5VsaY-a
zs#|<KyC74fX70%~hw$+{h)j{171|}<&+E)|8?q~pV$t2$4OFh#!mGAxck}+DzKW@;
zjKxfYI5cjfImVf&@n`-y<|q)An6V&@{To-eR&lfyX}-bWc;`>>5<2^f)G2cDX>n)p
zUrM_oQ)3-gSHxvQ=5#igfA3j3j!X^N6?1aQn)5g_=UvDylKuVqiS7ADwLoNwWWTuR
z*g3wT?g27Ivgi2vuoC~Od!>7jT|;&?o+T=*9&T*l`1=zTE0HOZJypdkxA}M`x({_K
zjbahg==n8ee-`DNSGpimBzwyC$B%P0&jM4myoQ?D=65K>qi21fqRaLdef6IDm8&@d
znW|2W;oMy{oe%#+#VurNsHqMirRHP^;@L|-gzO?UPi{^;i%)wfGDT|EE&C}2*C^h<
zP^U=Evxl3c;>-@n)KF86=eFGQPVhs>31o`Y9RDEZ0srJj-bavKq~_Mm+1v1~l#`Ju
zQuE(hNgQn7KQOPF?}4e>Q$x)Yfv<}2R`PzVqRaLdjn4AD0RJrBT4ajUESg}*NIsk?
zW1vozT|@UUr=r#PwEH7dq-I3lSxNcM)SJi@sp--q=P=H!@&vMr)JzjF$j|Bb3TOP8
z&z80zQ>5n1OWB<GAvxnys8gh7*3^LyjCI-gGuP>lOp%(;J(gJfLVgjMA~koPotcW?
zSaNx$va43oQ1fT{)#>@w>o7#BlVpvSpS1JBSAJ!56`3M6ojNs3$C+-=A-YJ-t>sc#
zd`e?7GSzr$WN&I0l$6)`2$>=^KU_}sh%+m^fb1eQk0u&u!3;sBNX@_vx!&+PKOs}3
z=8_!U&T^*DOUN!#^WX7BEH>F}K&D8|7q?zpyon+4D^;hOb`3S(KCv6mk4jAtDN=Kz
z+qwh%`gI#JMQTR3>@$$x3`qPMqKni#KV)1GKgzd8rbx|JrS}B!L)~6vsyWioy^zDD
zX8eIL$2X8&q^5h1=n&5AhfI;0H6n)h;3u?E$P}rW@LZd+e2(1SLUxgwHJ)56%$ZY>
zDN?h=ob1i{hWY2fR8yp(X6IMe8}e(oitkkPVj?v|ntRpe(U%}oLrryyq1yomcZ2!&
zZJ?jX6sZ}Ix#<Ajp3UDwc9EJjS`D=Lh;TSEMQVN?Ubh1uPsa~Xr<!+5-PL&7F9}S-
z$FnaoMQUc-u%R>`&q!p7)NI%F&PJZy<s)PlsabT$)6bka5t$-2r|i8D%ui@zfT@O4
zL(NnXg+B7(Eb&Q2mwg{?;q#L3_)0t*nHp-UTMTa9*L(0f-y&0_X00oUR`NRQeunHK
zHGh6|9mSdJkttHsKYIUZo;~pws8d5tHJ)EixLo6Pc0{J?B}?5Evq7@5_PowR$P}r0
zV_?C}{O1^_uaI4&reof#qc}4FnIbh?oM~0p_IXM3ZJ<lQRM9omJUqn1&bAPnFSGN0
zQ_*GbFA6(x@Gw8A8;(qony2H>?ZoT6hD?!~!&*(R!0UAV4%tO&+O5g&!yot_hfI;0
zy`rKs@RRx5$P}sBKI5<2oLT$_WEZJ<scb+b&prj2sy{V!KM_8yC9m@#GDT`;a5-?3
zGfV%3>>@R<ZP;>#ubRQYRAp+YnfCJDg1kK+B2sih8$KYaG-sCirJ~E;U)1^D$bFnS
z8<`?CBU6ow;ZyVqnIbjYr_1<)w`Y|&3FCC^(yc?QB1KD-5UDw2%j3_y&V|SnsrkL^
zw$q&X0huB-yLH|^m1nON7qW}gJaWHTTh3gDOx5!mx_jktzQ_;rUyvzMbNh)LAzaP6
z@l<w&)KIgg@088F%*BWlso8V(>STP{KOs}JYQ6|Mca1aa#E0l2HM=KW_>41GAycI0
z*zUt4_;~(8rbx|(&xhyahowddAiGG-%dHEh<IFH*iqxEvI`SINp4blR6sb9Su<J@*
zXDeii)XX?|Ojpj_g-qp9EV>)Jfi6B85^THmY2IIyD&e2(iWrNT2Jy@D;t|Hhg7IfQ
zMQ#T~C1xy0W3R>hPgk1q;M)+Xn6U&mm;-8fWaP}`iBxde_tC<a_ORHf))AQ^*=PTg
zu`)l#??a|Y_Ox;1p5+ISG>IX*NcPcHiw)r8*$tT@*(aab`H72p6qzE~^FC|Vk=L0y
z31k<^K4xori<fQpN2W;j=z)1}@_9dlOr>TlJ#VO)V3uze+ZC}{&FuCnyIS8g)a-Te
zVSnCAgAplG^L_7{Yi&mm^A+($WU4x2iEij#XU#t+_`T^|Ng=vO%|=(V)ZxFvjYg(O
z&5>RF67crCgG`Z{={*as;&W6Y8Dtl!>2htCqpg+9b2JT^A~g?QxM=Yyji<;Isd;?$
zYm3i3S4<AsMQWz%lRPe;_Yh=?)C?ZK>Zz^g&1!xErfN?OHJ7?yJ;JA`Y6=xyw!f(N
z=dA&}m6jq?q~<%<OZ|DBUy-S@Yv|s0S&%npHuwj!i`3laQff43ZbYU?&Fg)9Ek3oE
zI3?66QZxPJ2En|}*2om8IX7;iRh$`tOp%%wlE3@FdnrvS$SzXTuK3U>e)#N$Op%&l
z-y7cNY90lqY9$RdKQ~F-n;$_OQ>*B*_ZKZJx7>kGQEz05)GQKmIzDHfMy5#3%`J;s
zyazv*17ug@siAx8pc7kookNi+QuAE+jLMvO6`3M6+h+XHkTZ*<f$SnR<J3K~i}%t*
zWQx=r+WuXB&U}PSk(ymEMW*IzR!9rkMQYZ1Tp=@8b3QQDv}>s8_AW_#9{m|2MJKdv
z*A4H*qkB85=sNE&GJeZT9LG4JEphJLC1dxnu`}0v0=5X5A~mNrcs847kDm_e6sh@m
zb#jY03ARM0nj;O}PX`sTcr1MvGDT{Ry1O-suSTiULw1pxLmNM_*z(yGnIbihtn>=z
zy>t|rA~i3(AN!Qgd)5q)U8JVd$jF*p%|XCaQ>3A0y@8jn^D<8%Ql#dY>(4&&;mnm$
zMVGz5=va(PKHf^hkSS8r<#bR0UpcNIQ>5m(Ie|5JorN<&c9EJRwm%um_rr`srkZyR
z-Iqo6e!$=9`!6y@YK~p)waRwi(|q{!&J5W_YDSfR)QvxHG#{BFHGi!xm4o;EcVud)
z`M;&ZxD6C@`(2oETg~Wu^R;H<EGoMiP7O6HHY@#<YqSB8A~owLZBUd)PnZ?T6rIpk
z&oy%#ud@v@MQV-=NwAsM8G%fZnlIPyILMi4vq5%|n%?m;PvW}wLZ(Q~+C#U#<jfPu
zRK293d+SHnHt|E9lM`eYsd=~SM610($P}r$=;?!QJo_bNYN%<flX2o0YW69S+KsQ8
z1)WuP6<tHk@@ua3;lnu;ks>u+509$HqhCd)NX@;ewq4|Px@L#yA~gd-5~t$K@yHaZ
z8C0#C#W&X;AXB7fP|o%iEng}JWEZJ<)GoipMw3~{6sh?*<N9NK-d`e9^{0mJzg#}g
z=5yqo6S9lceAOZTa$e_RWQx=rlR3k6zKP*8FjbivYHlp{Ef0@gHJ6Gmdw)@!q)Q?>
zb15=KY7Q+IT9GrqBU7ZN-J~%`_zKr3H)I#7nW#p;hJ1D3j7*W5Yh0gR;&s~RfjUKM
zes+J-fipWGQ>5mCNv?@G^8hkMYA&6d*W!cJnesw*)$<y<KiZXYKCiPMGDT|6YhA>{
z_B*lpg!Viz6;eaZ3FDSpToUKXr=oj`R?RWt^%`@HMj%t9=B?;aU-*&k1~Nrz4xG4n
zET1B`{E%IwX0oSyES{*Hj7*W5V~U>1!|Qy6Op%(?)^Bdj$Fo8K$SzVdVa{}a_Sl%O
zHRmByq-L1!_htN0_X3$BHQN=5%x2TbT&H(I$gVt!MR((bHs{ZRd2R1aFz+u~_=oAP
zEQ-ZUgSdXumJ0msyDx#LjWq71p1(P12p`PSg>1py3(MYL)Gk?~>6|$WnIhR;9J{3A
z6Z8_9BH1(cxG|a6S=j}$i)1h8vUmj-GZdL3*_RIbcLQgBL8eIdw>=}jab^Qo$S#t7
zWwAULIWr8IBH5GmOl9#NeEY&sr-tn6_XCghzA?tXjGJ|4+1n#iB>Tl=0fGD!`2a9g
z%g187p=P!1=l**Eg;A=x%#=k`blLlh3SC|N!uAl4nb{4Qs?J!Bb4Hy$b)H`1_b3k{
zQ>12xZ`&+h4xQZ%vWwKbd}6^behw0VOp%(;4$Qe@%+KF*bP1UvH3y|nnVQ#GxF}>7
zshRg?^1Xa*pMXq}nkj<c{Nne!?;}$~&Hvp5GJ2`y$Rlewvz$9*7pb|g%d-ny%@AO!
z_S8^wcb5y-_;Y~I5vf*U4UJxH+<K5dkzc)-itZ*-GwkER?7Ysk$W+-i>O8wPM<~D5
zpSU>GDN^(Pg@FZmon4VBQnOjetXF(IPaspIru)y2%lV-$uLooosktaq(Vv_-9+@IF
zONDGd#+gr%DN?ibjW3tEnl(y5c9EKqMan+6ZA~>_y{-nPY9$Rd`&EA8%F9gXsmhe?
zFRFa2lZ&lP^QzennIbixB!7OGGY=tCLrr7t`QOHfF1`Kl7)+z>&2>7LgzRcOHFU3$
zJ8pJ<k~{*LA~lmvO_`CO%wI>QNX-H(d;j2d7A^(ZMQR2O_?nV4$0JjuruXVKX?XVg
z$P}shGfkdkyiU*3kX=K~|Mik_t(hdx$stCa##w_|%^AQ{)2^YW&yn@_c$qPX6s?-S
z_9V~2nH9>Y=sNq0)Je#jCcRtp)o4C4HPlqhr%t`T^J)K#Op%&DTh{XDCyI5-LUuJr
z8oDnkJ@h*t&o#&tsaf>-$5fmduN>4VQgc<JlW+NWHb<sN&G1#HLiizh3o=D&R-aNJ
zInSP|JY?5U^MAc$s2TZVO(El7#-CZuuE11Nq@m`cmW%K5GIt|Vq~<Fx&rN(KPE$ce
zm+ddQ;qk0EXZA*>NKKcGxgGg!i*v{nsX1}m$O)X8uOeg@sW~!vwS=5G8kuU|HFS>`
zn6VgV-a)2F&B1X#KH$ufl_0xF&HD2*jONT)$P}sRwZ3E~e(nAmnIbj!&Mh&Nt69@a
zWmm(gp=P<Y>nuK1un>_VHM`f%{@-iB43*3$il31wI-!lo94DF&XT!=6U8H9932tTh
zv~NbHNX>u#z1f%_>XLawogy_~O`E-h*VzG?A~k(C?Xzh41ISdpq@nwxd@Ty`Ix|&)
z>>@Qgu1JxUGY243q~^`CBd74g`~_r+)ExWbRDZ6fOI4L!Mb}U>Th99@c=X|j6sehL
ze&1reJ#QdWq~=bymLa^(qSYX}NKNM~=jw6Yryx_LX881GUi^giDKbTBCM~k*zc=*#
zeW>%Q4%tO&-r4YeI?uiYnIbjqj_<bPE&l_Vsy{V!zjk#041OD^Sq;c8QnUa1czyY8
zwcW@Rso6izjZoVI-{uqAOf^-Vs!R<vPxksJ6@SBgFGOmnX-xG0Zm(>A5Z2JRE;NSJ
zylP%TriPk|d2W`+G2@!!Z>C!<h%Qp|QO2<DT=(h76sZ|?sdqJg*Y`OxMQZN3?;OC}
zvvzIBuA!zH&+)_8_c7kC|M#;&VaODzSv0}4@%*rqrVi98QnPT=+tK{`wFfd)&ui!&
z-Q4~qUpkH=Q>5mzam{n_RWoZ{m0ck<)Eqi7*;jt_?1@MXHI2gJ{P#%MkI0e9`4pW-
zriPk|x#(12KR%qf>OpjonlV>$JmYE(L#9a0dGBZE=Gm_!Q>13D(!Vb8>_vSbyM~%-
zJY8<|%*b!6O+uzf&7XBoC*ikjo+4AE=B(XQH}Jz!wfc}<q-Oi&wNmgp*CJDS6pQZ0
zZJ>{FHutpsu4&$1l%&C*I#tKVVx~d7<M6`bm(nIcRAR=0G=9(>7doseZ}`=SRLod{
z8%*Z~L2r3;#&4*C%idq~K6&rfw#{1RwcQt)BH82IniI^=LBfzJlD&pkiy!<n(V-D!
z7s=kFP+NcAoV}1KlD%et?@C_hd1PwHuGaR!Umxr+m`1JUIV#u~vWsL7Dc|NDuX8*y
zMY6lLu6BhpA0bmD`<4MiEcO>wYNE1h+iqx-w`JAIyv&)16sh_0RQ|bK&DY3Ob!zCo
z?8VI4oLQ|YL>H;q_;O4Ieh#t}nIbi(b<W?BuWvt*DN^&muxy1n)3+I97pYn1wrf+K
zJp!2;YO1xp*4=^w_&JDUbEs3KW^m4!^gMenWQx>m^tj>%p8Xs$MQT3mn9btpnEbvf
zyJ}C3RkKCQR%3aY0f-c-`DV%`KhC^@Op%(eALbp(r^u}ZL|550bdOmVU6I#04VfY}
z3$@vIoY(mrnIbjE#QbxHA3m$MgzO?U;~bwgkZZIGnIbjEJx}7#$1`p#s8gh7&e9|2
zb7l)<iqzb5VXMV>h9gs?W{-$g{<cTm%{P`DTdVA<l{C~m-FIkF9=!`9MQY{<Z0^QS
zl8+)&q~^Hk={xY2cWMLCMQRSew(1tY_csigYCJV`cRe>_B4^%4riPlvto-jro%82K
zqm1!1@|#Z-%eIB=8fq$L@0V*YbLKo`YN)B01CLy)YTN`elsDJ;9+?_yDrT;2Eq?Gi
zYqW#x8fq%$A@A=0J;7xB7jvB}kttGhueZxd+m2+jn!kXlrrlCaRc4Rbk3JYDihq~c
zsJ)5~kK9<cr(#y<w{R{W&M;(ZsHvF#Tc6zIb=r4;IyKZ(%wi9^d-GOmhfEDM6*JxY
zQcrlD5y(_?q%oemb8h<YC7;Is#oS5`9U;3+&F%}=8wwe#v6<NonIbhC_|@6KvmZmI
zNX?vkue3K>-smTDo!L4;c9EJl#x?oxB|d*=_eZ8k&C{PfHgh#2fvKj*QcZPz@FTcj
zurcL-PkWxuD!T0ZXd6amIK-Kwkg1`js`I4J^jZ98jyuTIP*XAY{e0%jnH9P~c9ELf
zukUzfWdD2GmmyO_O{mk!^CSOm_Ag|rdAHPEF>_TfYq4RzZCA)HQu9W~WtoieG-@?#
zbQqZ$YN|Rn=J|4yXV2vab!w=om_x$?Kl1y?<B%y*^UlWM7mWXd@n>E&p8!)0r=^-k
z^Zf5*Y0Q?cS&S1fV@S=zS+bjoF8e-Ok>>GVb2aB9Q>13jGUMZN=0{|T)T}lkDhFr!
zbcgI3YN~0^5c0S`XKqBMNX?o}5B<xp3+;PAogy{U?f!Mfc9b{IdwXQ6UeeIL$lCjr
zc%6HYDN?i6v6L<Ncsllk>>@P_Uf)uZ*VzY|A~pN0Xj?4te^&i}HO~N3MYmK_wbF<r
zo>zI9nR=<{vhSniOBh*#4`+X5iqxD}u=r12=LKYn)O<h6dnB*3KySz{QggM}W{Y26
zgODjwvssAuA+FJVWQx@M;`i`0AJ39~AiGG-hP!)O{7M{*Ox2$nx=$aP++sXmB2%Ph
z#QSMedG>03A-hP;hOPaw+n#zhubRt%smjz)bH>wF;l}lW@n=4IenO<^Hc-93cb$04
z*X^gG%f63Ra_$L>H}tJXrbx|-XTL`BJD-XAL!BZuQ%9e-czI@fWNN5sjNt#yZ03L4
zzrffBl;f{CI*3dSH5K#vH<x%u_P>9F%sT+Gi`0y`bode<&oRgpsabQ-^nILpADOD>
zHFU4pGHn~D-`R~nbI+IahwLIX`zB9$ke|@50;WQ0sJSoGn+3)t_TQJ;pAo5{rkeKP
zIqP;9M<wIGn4{MpsG@s{R?Rb2J67Y{12!O2q-Kt|Ui)l2Db01J8U%HU)T}lA;RQaP
zosg-araH56>6O`?Z+|<4Obs;^^UOkbi{CXf1VDC?n)iaXe&*TxBU7a2=ILWMa%Lnl
zMQTnOv~Ue)78nfKl}EAYZtMn1d?960+m;yf{-Uvpsk$>3GY#Uqz)Ekq>{o%P#Eb=L
zY+@+n-S8;C$j&?DPjENc`-{eUtPSS-Va6j<B)jwLUlu<b#UN7+XDkzBWKTRi;aGmE
z<TVtsi)3FHccI1WO+%3>lD+?=+)ljCkH{3s-p<?4;?=Hohe39c?45rNXv*tci%gO1
zM_hkw<IDuZp-z$Psk)vRW-LU1FGekqDUv<l#@WXF>NNtGs^vA*yk-A(A&;J9go-YE
zf6<v&EsyZ%?U1SJ)X*rAT|0}{GVVvFNX<vNbGG7Fg&6}OyGYHwwVYP-@$7?4k(#L%
zuCw^k%Nb;f)GS;2j>UN99tqh+YW|FB@SJB4M5aj1ss3pP^GmpBWQx@6lI?Rx-k<KH
zAiGG-rSr>I;;ZH~V5;`iP;=Jxj0gDX!aYQ)l~_Zgv^x(?;~Nf2k5<uT?=Pyn<kK<E
zoR3VEU8Bxvt*c+*Q}h{`A~ol9a!=3Ov%wh1E>bfzSBIYb5V8@OA~lbc-20PfPdFCp
z6sh^?vDa~)y)80DYBu*cpPw`LAXB8~;;%y&@a&F3kX@u^c1MR^T+KefRIQ|;X2sM8
zEWSH-7?C11FUGsshPP6daVmOI(W;rfVd~<1iuxl{q~??{^P)NPJTldIYUuuM#2bqb
z5#<{X*+pu$In~kP<a0DKMQV<#F}Dz3jcy}Tq-K*2?u+?h-eUq}*HF_C=YKcVP874N
zVbp2NllczA3}lMbO#g9rAm0P_44EP|<2F3m+;;V9zUNzGqROtOT|>>Pcc)zCWiCXd
zhMH<PKMkt5*7)JsxDjL?&L7AWsoAsH!K%E@){`K*NX>FJ-)H5_1IQGqS+LBxwOn_n
z$xx@7BMsfx?&@ptb4&m-MQXl!c+#HVREt8UNX@G?>i@SF$T%#U=RNNf$gZKLx&bz@
zljlf2o+FScQuAP7*5Z8WxPeTOnhWlv+0E5-o2s&_Dbi5$REhXmc$uRSsiCGC&W<tT
zUUTM6WQx?xyz0wiK1J@+Ai7A+;b()c^E#&>Q>5m>>^)oXIv*iZq-KIGzn1b9uKaY!
zuI61s_oat>CE#k#L#9a0Y!ezj=i~VbnIbi}HoF~{Gpo#i>>@SGOsr%vo{NwvQqy<y
zo{s#4_A@ZmaB8So`tgD=zH(HXsiMpF7x|`jUd@Md4KhV)K3Mt7p8q5fHyG*^so6g2
zq{S<zn;=u9X0^)wGVyETEyxt9IlIT$&s@!vvmm=j%>z!eEk32u1(~XsEOl3BOHn@t
zlr(zj@4aeAkSS6##{TRIeqESzHe?s6>5%j79saAt2xN-XOtWa_5B@C6Jz%Qn8fs>_
zzqthek=T8XiZ0t<G~v^e%Y3)%bYzOu-0!x+VkhN0WQx>$m2=u+K1B`YLUxgwKhkCl
zbo$+%#-I75ZaXqXYDS%zxQf@AWggTiQgh^ueQ!8(7&0}~RA)<jI)!dCUc6%bnX}(P
zrs_{i-4(Ob{OtRAFL}*}>>@SeIFzcvm!p-)6sZ~PaNrzQGvNYNrz%rJP1my(Uh<=S
zQ$&hRXoud-^nyp<iA<52MGst_!>1@+2t*gD>6gFJeqQGwWQx>mJ+nqIXI@99NX^R~
z&)4Nl&xMd(q~?S%qpI@poQF)2noT$L59YdmL#9a0wogCb<^Aa!3fWc9Yv{h+IZFpV
zo)O3tsoCJ1Ljrz6n{kn<Qz13f%<yLRI9{e7B1LMp9)HqeicTX_q~^zcU7UHH1s6kf
zk(vR|hfn8QBPJnJq^4{CTu*t+KSQQS&E(C;F5r8sYAu26A~jpo+Ip5VHzQM|=Ge?j
zlkx0nmqMK)HLuvuX~voU$P}r$C~1<*yqB&cQ+X7N?#6DQpTn~z=kG7_T=pls>ZDlA
zG>CQ+ecRj4XU+F~#{p4^84J?bW0UbocqBj0Jw&8p#uD6Mj;!0d51*il%T;jM`-^@}
z9AwWYXgM-Pve$3^_AzHBSOImaDbmRPXxid*JbQa&ie#@o?8iA?=P_i8WN&;f&TT&L
zxmQAVk?i?BUBB@<M<Y`t``9PT9XazMGDWg?S=rp;{L5<<WEaVP;8^jcwi}9OHJ1ZZ
zt#2A?CXCF!k)PK5K%_{`15Hbe<-^%>wTfOu)v3|))9NIT<jj4@)KF912x)XW^IBsa
z&idEYR@OC8r-qt}nebM=@0>XlnHp*;rgNu`?Tj_^?>cWHQ$tO~?A^P5G0rT%7P5=f
z>{sPj5k5!DkttI1Znu&1`4w@3bx@~BO_zRQ7BAfCf=rQ`&1)t6^D-B+n#X~u+EYW#
z#tUyQ=8w~6U$3IOiPX&bs(dP=35-AU4Tdqu6scK1XlgV+%HKn#%C4b%ucQg;@K!3f
z0kUhTscwW+u61ZUuX7PHHPlqh+VAfy<;)+*)KF6~@8@h#hclaRgzO?U)0{q%pO0ra
zGDT{Bi`(4dRc#r<piYsRCu{pm<8}HYQ>5mDm)R=V?#r9iyb4U!N*Zdu$v3Mizk+k!
zq@v5dkJjbHmuy_kDaaJ5xxjmTecnn>kttHsV|KiKoLO}<WLM*<q5FxH`7FkBB{D^7
zUc3Gy9k0`F3)Cr6Gt%8Bq3znpeE4jKOp%)1_PuxGEq?%+A~nyA+J2j#)j4g2>>6sS
zGloe)J^!oIxbQG%4@9O&%_qGxrn2p=GOKwHm}=TB)l_9Be&{^UcwRBjUuBlsrlRY-
zzepXCqk}tGy!CG>GDT{h8vFARpQ4}06sb9@Kv)oO&sN(ZyGYIIw@+2(H*EGGQ_Ycv
z?oFoO$<MD}opwN-A~icsTXUX|=SXCV)GR(WWFBWeK&D7d=Y${rd$0cA@7DL)3E4H&
zRQ;K>M^GrQa~(28YI@Zv(ueOaO14YYsiw$MO;u*|fm=@SGFu{2bVA!T->U`u`d~jY
zMQZ;0)Y*}@XU=elE>iPB;{0CxC_fgNA~oM%TbP`$aF38FQZw|M{e51iR|I5N^RA)$
zy_F9-^YL7cOp%(S#x+~O>rA*C>J+Kz+T_9j&g_Uxk(y&V=19)7A48@{&6<TnQ*t%)
z?orv*aB8SoeCX{~JbC~kMQS#Auze?wegl~zHAkc#Wbs*n(t9DgNX_tHIpcGU79vxm
zW}}kHy7KY-hD?!~U!MjAac1*<kX@u^c!8r9<GCA|s+Tl$PrG8E3$HWteyCHV<_`yl
zw7i#wAXB8K%fhg5r{8CZ#-I6w_BJv_YF>$`^qQ;beL!Vb(KXaOeZ1);egZZZks>u4
z1O&h1!}%SVA~lDkOn-w<d&`3mU8Ls0?;VPAHTNM?q-NdXjVAN#nGZpoA~iRae-Oj7
z4@0I%P4|zpV|bmnkttHM?dbYzoqxBx@n>%N@`oY2>Q4>b*K~M(kY`_mOp%(CqHmVr
z^Pc1g)G1Q)g3pdqcE58Qf97k=PQX-UYN&ZKd)fCq`c_1W)a>wfdj`&QII5z{-e1&j
z&a<=p#JevtMQTpiTYVF+^Aa*eYPu&%d4=Crb3X>zMQY}#m~T9<b0#uHYW8iA`3`5k
zL#BqB>b`|bU%PYs2bucEA-jf}iaD%9;klf-6Pc>#Ep=DSBqyua<3Dg^IstWx)SSPy
zNRaIT1hbj}z*I;LHRt$VEz76qJR(JE9<P4CGiSP<RMBPcFZ$4?Zzw;~O+}_i&2+tE
z?idqh{F#sPFOVrxbKH#jC3v0HPC<5&nln?TEzieu6*5I?hBnFCmDic*G}Nh~rn+x2
z>t6f{oY?`H8fq%0XOVI1IrA_wHPlqhPmz~%@$qy%1KE{Fmb(9sY3v4SddeZfc0y}@
ze^H=fs#%Z4OoNzZTmOuFpKlZpm6)+0jlDolX@bV^!OV5`PjGkH`-^t{^l!@7qEW~c
zogz1DRPO>8^FA^~vX`&la1+m7_8epv$^LxQ?G~IFf=o5-u{4q~M}fyrTa4#dWQt^u
zf5!Peue0fS$S#t-$&Z@h{2uyFWQt_ZpFKr<-b-mBp-z$PRXiqbwm7FlrbzZ)7amsU
zYF+}SYIzMc(>aGf=4Ix&prY%%zet^e<Zn0qoAIx|-(5ZqnW|2W_I!Epb0OQ-D)XB8
z5Sb!1N7-%g<I`R?3bKpT^jX;R1HUR<h)j{1|M>mu&)1D#$P}sh`fkI0oZ0FkWEZJ<
zFRptTuI7GZiqzb<fA~qx%zO#z6sg(7r$z+NJ_wm2HFF;fO3l^04ouaa8fqpeRlgr^
z&w`g#blLu*CNG-=^7fpFObs=a?rSP+Y;6puaTqbH`2v|LyN2#nKFl0%ywUdWx7yaa
z0@+1szG<JSCqLBfLZ(Q~8(llU<E@n8D%2@bGh6&^7GDe>giMi|L$6<I&+EK_Op%&b
zl5~pTYL>hP*+puOYq{TIL(CjxiqstD({YpSIcoFO>jz+}R?<+jeB2$=c=VdrRdm_@
zqOIwcx8=+=$P}p=Hnsmr;}Bv@y;;qKH=s_DnkN_i)0DST2V|=8)X;rK=W&~O_M^xY
zshQTb-e+EC_Grj1QZq|}utWTWb|f-IYUb?~K7k+R?;=w}O?5~fGHgj=V?2#o&GTOF
zCS=!8Q!&q{ZCZyjLy##_bHj!8J8f65W;MS6Q%$>unsF-L@Z`f;<Cco9v%g41Uwb9}
zdZU&8Ug6dvQ>5nfNUxd(&sdGkQ)GV|>eNtE)%h?@Xb0o%4#t)(Gt&>5A~i2eyik^p
z=OJXOInvO*&EQinY@aGH*Xeu*vWwL8{`q~0aa+XrGcyMuQ>5mhleg~JPU_6e6Ufw1
zQ{4o5)a;7ItJ*T(h3pz?DrVQtsVu%8<Bv>{nn$9RB(!BWt9cQaYKkn?RPFiLy{&_B
z4QKop^Kj<Ar=sh8A5AewoN<|Iw7YR+GBZaYQ$tNPoZI(*Pr_HDXk==rshA^&9kO`8
ze2M#zU8H7%p5D8Sk@$N&XChOiW`oGDWB5Z2uaK$c-BNcoM;C4clrs*We;?|69zb@H
znh)2k4(As#Tac-trmC~fo<<*yXL$bJ`j_S*)TyDSVm_JFzY%8!AX7ul|1pg_w7EAX
z%xN4xjZO1rHSYpb4X34=sy%Q1S`}%;{yVz+zbd-y{Y4*Mq`t(r{w+YJNX-n+ed}^&
zoJUZnNX<osx4h!IcR;3wnrhn5WPjU$AC?XwQ>5m#zFle>{|DpGe5lLv7_y7h%#>iW
zy>S-u_pQ1?$W*<gq5EF<8EZN71~N6&RQ(zJG-oy2Ms#!bQZbNSLrulJkUMij-t)7O
zsiEfon1-6aR@G0zSIr;5RM9QfRIT)|;kk?a2vYZnimvniBE@XF{^WP#hi5}2^KkA!
zrbx|E<s5_gaAtf8b&Axy7(ZPn+x3CD&Ol^psHvtsV0Cm4+Y|X_<|Sl`)EvHepg*rO
z*E7hjp{A<ySHS{aoH-Dg8fq$LpR4_n@$9FOsru7Wcg5W3k@o|yGxKxEE>hEF_uylk
z*%O%}H512sJ;cT|ubPK|smioeQ$@dg_K=_L$u)B;rFo&Emr%czY7A$mi1B;*8~VB<
zQ>13kqq*;J<`HCy)Li}L#}}SG(@V%MQuD~kI^#LBA2LO1)<67xk?roEd5+E^Q>5mD
zSs5<c_QRN&xn4nbk($q*?%2$kgOMpx)8*6Q<UIQYWU8Lm=+BLVr<LW*e6Jz9NX?e1
zXXfN;1_DzdHPk%Z_d+mlrHhCZsaZVk6g#d_!8a<pY=2SD$bF-EouiN`QnTzZ=T5xN
zo5&QYxv$F0guKq8Zy~!#&9bNW7URrG$P}qr!|!1}-k$#=Q>5nn@7vaKW|?=8U8H8l
zUXSN;<}752)V%ehc{9#@flTF5EV>&fwAa1MkGH95-d|Mt{h#b=hGH?(AQttH*Uv^Y
zufwx}sKkr~Y3yD3R(y7Re(a1vq+-Sr++e<ce&j44%(5R;aM}BdW@h}7iPt$BnIhS*
z9sc~1*ZCZoBH0&oXf%k|>Gct^i)26eDZDgi&PS$dC5<_nSoz#8p8Yj4MY5k9=h%|h
zS@jcS7s=i%Dzqf8GZdL3*|V=Z7>^(1KO$2kd)j+z)^as#eOB4ksi%gTqpCZE@MHWU
zM2ghRf2l`n9{n>iRh=5G6jd*!#g|Fye1Yg9HG>8&Jjv@^jZBf6QxmzZ<IG>k6sfuR
zMRSXHtT*}!*+ptj8QeV?Z}~7}iqu@Pe2_O+GtoDwQ>5n72K8Kdoh^_lQgco8m7KiJ
z?Z_0VIdF7|uUyTf-&J<io*HWUyli@otJwmPA~o~bC#l2Ra|bd-Y7RTt;RUZV`45P$
zvTNw>+<#>uUS~&Siqv$y(b1RJxfhutHT^uIgLr#7{)FrzHJ@Lsafi2O4`hneJRZDl
z4zKeFGDT`uN&k2`XJ-Bd*+ptTT>o${&)yH2A~ioha$j$|sb)T*Jq1kFN*ZeRtzYg;
zzTfv|jX(1ZhKz9%#p&3kTZdLf+>6Qf7bULYu%7?SF%g*}HOt+dw;=oP8jU}5oiWH1
zsagE&f}H$TzfWAquEtYC_g8WJHgVlIAXB7f*#nbO@J$Q};z6AvH7hMku$b4`6qzD5
zXSg@W&Y7E#DN^%if=51_nJ7MF7pZxwe>FGTPbcPHYKcsdnw8$1ddpYMEx=UMuA$~3
z`$u(onF$i8=sNq0)P3X^ep8?Dqf!%Oiq!1>_~s4H+=xt(nwjor*kqC24zi2XygX^n
zLSAPRWU4vR(A{C-jwoK|Mr4ZA96cwvAg?oCLdY&s^UJ=07H3OMkSS8L=irGu_+cpw
znIbhWPxtD^bx)88vWwJo32wfWtJxfwYKk<}96h1REnemZM2b#m6C_OYk~0$|R?&-z
z)I6JWY60F#&5<cmvrW+5Qk=ONnIbjsCEc2sGZQ6&>>@P_hdh|TnJtj1=3PVgPpMi}
z<;<<f6seiCtY<ua2uWfO*+ptbmu=_A>uiBck(v{7wYE6SZ$+j^&8+3yJmzX9Nvg7|
z;nYwwe9`=C{HW9%ks>uW-z^rwnVXO)Qu9T@RH0mVyJQeuq^4i@F9Ufi`65%KW}jtY
z=Xon_LZ(Q~x31s6b7sQikX@vv=ZNrD7TJ-hdPzff=UnsV@j5plQ>12*UyfyXoe5Jw
zc9ELlK@nAWFEvA^NX@Es<L&2aZU&}`uA!!9(kK0RneqQo(RKD0sT11HDW4wY%x1_G
zsTmUz{*f~`BU7a2?Rawo_#q^5O2{r!^U6?<^qkoOnIbg@ggBJs*|#85q~?65w}Ut{
zNh-)LQgiv7E?K#nt&yqvQ$zQr7YF6yYVJU$NX^9V2~+So?NdW`k(#-R&3whxYz<6R
zriPm1b~P-+%iMxU(W==w$Lq9w+7mmd=(6`0_3D-EJ8$_`$P}sRmF!G$UgtJsiqstV
z&$3WnXVNr~U8H8(bmxP3ovo26QghaVkZqi~6PY44D@5O!#d|45TF5R^^TohTV>q)t
zGF8uO=)R}jR(H;fK&D7d?}l64xSA;)Rd$8cP;+$>_ecC@e_KR~)J!&RPEme`b~iFb
ztLDUmmvi&Sx6-GB=pr?f1T>gtZ16Vz%y;VikttGhNA#yqW0$k>XJ%eQrbx{^+wPy{
z8kJ2C*+ptz`}cD)KAy9XDN=LO(wH-R=k$AIiqyPUv(9&?-(zX~na8tv2FNZ_bNeU9
z_xuN$!^l(~#iF~h8_4<JVV`ZQyLo?6ri_2;RHGS-nFevFQ~8oy_U=GbV#b2}Z!b{y
z3l^s!`w^*_u>?1m32WS(#hcS1lL{`|Ulg1(W&vN{x*}5~`>9NMR`ELbBU2>%_4xH>
z@j4wdLw1quTL*pJ&Fl0-rbzZ|YkD{0%tOdj?Wr;EDY}n$;|oWIERbC!dnwN*HTh3w
zeUK@V-R()2lKh1`XOStAJ!Rz!UAdZhva0NAebZ30ag&9;c$tF`DN^%x<87Vz6kSB7
zs#9ayYtPR$fFC;xW`pP=HH&ui$z@z~8-M0w{Agr~)NFTn`DLE{3Nl4%rbyubny;Cz
zPLN%s=KKuD#&G5oWQx@6Q$NKo{>F$G$P}sBy=d#F{EZQ{oFTi0n(FDThA)4m;13tB
zL#9a0IG_60vGtO96GOu6s!r9O8ftDH=UUPz+W0fKXJbT))C@R!BFJ{SU}kPbrbx{l
z!~7oeqi3QV5M5>0&^>sBpGAANMW#s2QO$1L<Ezm@WQx=bYtf?-*FAks$SzXz+|YKf
zc%8kGDN?hdqmMJ!=mauFYGxb!Z8X<CcP_}Tp{Ba=IXw4Si=|^MGDT`uZko-@*7IgH
z?*LP^l7^Z`bN8*oS53FvD!Occ(ZKX)O7m8lgiMi|tFyo9!kPafQ>130TpfM5?q%~p
zb~T<Fx-Xs+WXH#I9x_F0j_?lnZ)N{`b$^FUk(w*JG`-31FjUS9*+ptjT3oUmpQEM7
z6sg(x?#Y(?5b_O~A~l`jH+1E7`s9P`A~jc4Od7$}Tn9`w?HX#n3AWq7%lwH*(W<#(
z>#=Zt^4U1Qita8_({E?h*Ze+R7&1j_CP}$w4X@L#0Msc`b9~6x`JCATnQD$SbZ>X!
z@eH1QJ2FLTHc7fRJ+CuqLC7vrbAHx*2Y4^FL#9a0gw4-A;%e?erbx}=d%YuhoeqT{
zyGYGbdFDUmYIXyrnj#G~Q{-$jnn&M{NRgV4^E>+R=#DNbx@><@s$HA2@mA`IOp%(=
zp?S~pmOqY6k(y=ZOfJpq%;E~!MQUEW7Zk?p?2k+}?;5&4k8^7uuk$oAMQRq9+-3-8
z<|qu=MQRTA>s*m%AB;?qnn5lpy74+MAXB8~rrT-z@N3O{MO1b*oEmEOO>^9dM-M=x
zNX<s!EiIm`j6|kr)x1(H`7J)2dEFqoNX=@OW3ut=BakUlb7-;mp}fv3$P}qr(B+fG
zqgF0OA-hP;0i#D><A=|&$W*<gp?m5#ffm=<caSMkb7JY3LA=i5?vP!iX3S`pG@LmV
znIbjc_;kL{SIrn;s^}VO?#zBGKVLOV6;sh=`-^66N;Q^8pMgw~n)$}&?Z7p9hD?!~
zmsXdsc<{GEamX%Gvq4V3BwWpT$P}rWbkvghd_3PEQ>5m?D)*M~I;(p?c9EJz9!}ZJ
znM;wW`cp&q&7E(J<jk+g6sdW)@9m<T=~Du-i_{G9__BqoxfYnJObs<#|C$_!m-z#c
zqE)lxoq20)i@W&_Z9`8LUADhyMg2Ohd3&xxrbx|xN3z}L%s3^XPLY~^aX%E~<JlCM
zA~lOm8W_zFOPi4?Qq!^6DT@=@M5Q3RNX^;d^Ct7`t&k~FbJ3yJd-xpfM5gL_4c*VB
zE8dkaM=47~c9EJ+)1SHW-!(e{Qz13fEZXLu^*nkwB1LK*>pU+pkDj`WiY|M9(fyCD
zTzH*bkSS90j{V39yp;|iQ>5m*T>C6;EoCeV*+ptjzOi#OSF;Z?MQZ+A&gTiwegc^y
zHLHb``NEk_<siFA&66p6oZ`%Z$P}qr$n{fFKAw@tR362myRjSSMncyJ+j3;yUzEH2
zpX@4mEM^+STJHmfbJ+&~QHdD~(%1`BIsRM+9{dC%6*HFL2D8=>kKUY_wSo#R+h4S3
z^|!oy()%G(BzwA-*DUsXo<XKa_N_t3lkz&VSA^^$+1sX^GoCX8kSUVAZ<Djj`N1;^
znIhSv4qf?&ALI*Eg6yj0HF_yUx3|T4og<Mcl6`oOTq}8<(a03ZK0fQ*m;6l(ZeA+8
zx+>IA^Pqq88WzzJDN^&h@6!pK8I4R;r^Xcd?@eEu>+W6|qKnj=Kf6f?Z}|zx6sbA<
z&`yiTsP7|Fq~__#%?t55OL#+ek(w!5#aQg`o`y`3nin!}cH%An1eqc=OP<PqmCt+m
zDv({K=8c!>_;}7nrbx|94>RQ9tL95!s`k`S({1~h?H19is_3%sqq!V>vC<+sGDT``
zthH|zXTC(H%C4b%MEz6qZKpNnt8DLTkX@u^u}QT{^NkU6kttHMc-;-d_#Uu#$P}qL
zF;k%de6vNJ>X2QeX6^;Khw!~XYmg~Y^URpZ+xQm6BsHK;k(%M9lm7R<{=Xl+=!{H}
znw1)LkGA!vd4JJKV5(NqP_y}+GlTecEvK3)x@>>Zh<{rh;!m9nL#9a0k)H;1<X=0v
zgG`Z{Q};Bi%iFVJEy%9MQ$zQSpQEzy&mo2&Q>5mU%RW*33o40fL!BZuGoE;`iZi<)
zQ>5n8wI7c-{oX=q{Fx7Rr;#aA^WM8!*?BJ&tpnLbYDN@pGKwEUf{`gwvt*M86Zt*g
z_rO%suA%0{C!crl2d%2qRncYdFUs^eL3}>#8;~hdvp}!HtBp@o7=Pwz|EC_*DN-}f
zfZ0d**JJu3Q>13X9yt#4?AMT~=14>L51#@{@$4miAiGG->|OhO=MR~MB2%R1)Ysd0
zIscv?<Ig-tcJ-l7k(!yj{_V~Cvj;LoYEC;*cM3nVxr9uSnvKi!iRNm$Hc;8s6ltjW
zvH7Q=eB~I4NYS<Cvmrx0__gLuWQx?>xP9XVejQV+Aw(CcIq`e)7+&WjWQx?xQ*f*u
zXa0*!k(v)?q_g;xM%hM?UCq0O?k#IK&%o=Pg-nr}Z$l&BbLLBAiqt$*bGZexN@K__
zQZwV?zUg?+FGi+F&A5e9jpAy41*RHK4K)u(<*v!Ew`w&}(PiI9Yt`sS0H2~o$P}r$
zdfcx*{F?YPGDT`WbgCc3nYEijc9EKAS|88HkI2iBDN^&Xr{@4Zp1+VOQuCkb5w-cD
zu1Pb<u6jvB_e!3Q7Eh{%AycI0#N>Ss^Xu${&7n?_nw~v&d2lt`B2%PhKxj6L+dzAO
zsiJGBIiuGQJ03lSuZk|)Uv#JO(WIQ&6`3M6YhGR%$ghcyAycHLU6ji-u2IewkX@u^
zqR?SM{27tq$P}r$s7lhiyw01*6sdVL-p^NjjyzgIc9EKscI-RFv(H4P>Q4>bzqQMD
znrDBFObs=Sw29*wKkl83v!S@bG-@@Uc-LqJ*+pum`!?mzH|)%}fmQ-jm8qd-_*VNB
ze2P9JQglMwdcd^*zHe>BH%D*KT1A)bFDl%6MI$~%VaODzIbr`6JAPeg-v;Uwsd;68
z+s(EU8*}z<$P}r0=vAE!{4V7IWQx>0xVyuDA9^-c4|AQ_+Cp}bn*CSQ?9NxCLC6%T
zxnfc85}bJvnX2bCba&j}Gz(`IY6saxYF2pm!eW0>5HJ-|L(NgHQ*PL9`kJTcIwD1C
z)*0SEhBJ$_SJ7qri}DV0Y-{`7$Xw@mWQx>uoL&C|zr}D9nIbjoA6uP~pD0%B0NF)q
z*2-IF9Dhy9JY<U0{MF&OJ+Jd6GDT``9CpOwgtl@=$SzVdV^rVl{7@HyOp%)D&h+u(
z7c#GrsXU5BcVjouWbaflwmQxGi@ZDi$*!u5#Y}^EA}DS(n?>ezcrFl?n6V&@(}kz~
zvi{41ze1#9#uEI$Jxc?3|H~Vxa%UA>w!bLz%&LWX!-pVKB>R)-OCNZhZ;&aHy-VYu
zW1LyF3uG6`p62;uAD(>?GDWhNs5#o7*ZCfqBH0IbtF+M8@a6+@jjoVgBzs?n=f5~}
z5i*rV8vS|uUCCa&=iebyB>NtZJoD{-pVJtBW;Lt%sqE^iP(#gnPov!V6wN}UNX<<T
zsyp)N&ylI>)ELg)rw(`KQ&h1VL>H-9=a@rXUgvCNiqy<{E9E`Te2z?!nhPpibmntZ
zu{&fJsagHXsAZfv51Ar0Pc@62#+k2?DN^%M^E>bPcvk5F*+pu`pL^cot;-9MDN=J^
zyQ_C>{b^S7EihGkYN$ET+c%64XXTzMx@>>Z=TrZLaApWHMQXa1Xz0tQ=p8aub`9N+
z#P7Y{Hk{_8e6?PXU8Lry1tn|pIu{~Sq-OkdU50b!J7kK~j2hwjgEOo3hU_9W^W3>L
zj^9{XgiMi|lbj30B>ue;8Gq(E`i@MInn4E(733fEs@Vs!i`4ACsMvSgZzpCocK}nh
zl7^Z;%5AL0Z}lhYtICw^FS@b&kcIB8kttI1d8r&>yw07-6shU=YRLxPo+<l5b~T<F
zy8BPfIMjB{VQ!_4$P}sBu1eYboVgE~A~hohzH#N*9s5Iek(yci#<lo}a5rR%)C~RQ
zGm&RMf=rQ`RkBA}e5Ez>0LU&<Gp6shKd;j>tJxozYT7l_Jiak-I&b+Ch!maBjvC&z
zKVLPS{Z(|?`-|-BO;62RX&^F1Y7Tyt+hW7~Ib@2|{MN327;mNA10lPbBMsf-xs<iI
zHX4RZk(z4<4#>*uyo5}Vn)%=7ve?*Pa1dk{safI1$6vh8(a033Ijz=8i^JzlWQx>G
z{Q0P#?Z&5BP4@tmT}_dOnk^n)viRc1SVW4{Y`9=>Ca&f!WQtbJm?|Zk^C@y44ADhu
zhWmOx<;+RQ6sb8kW4#0X5b_Y2A~j3ZYE_okS#k(uSM#o+`?L-}m-0GiAXB7f*G9fm
zd7UxH6scLjz2JDhbd(<o*+pswxVo0$%z4NZscGMO#!TDAky*{Rz*NJjq2||RLz40`
zD-ToAW&4ZfWs2y?nW4xOsabN+m1wT}CuEA$EVk>i#lD@|!y&s!&F$`EEA#BDkSS8r
zE#aVWo;}V8s8gh7`(;;-^Ew+NQ}vRD?)!d)S-kCW6Ea0=ey%n>f*(Q>2SRp{nlmD2
zTD+ODB{D^7`u2Krnya}3m@2x4nukwME5MI*Nk*#Zvi(KDNh`MCt<(mYA~mn<Z}yqD
z(k^6*)C}qOq8zU?)hNg=QZrFrdy8$4oslV0v-#ExZhVdoB2%R1-U`Vo@RrXo8nTPj
z%pH__F|V^HGF5+S=)N*(|CyY59GN0DN3B_zmv4y4HU_eb)GU&=^#ZPD05DaV8freP
zda{7+&XW1I#aTp(PG}1?J!sGGfMpx2qRaLdrT$bh2iIskGDT{3dKr<1KW=mvnIbhC
zlpp8J4<Y4)AiGG-jN@ii;MwOPQ>5mT$6YV-I$tAGq-L3QWgl|gtBr%~A~nOy<g?fi
zvj~~0=QVWS@FDqruKOosiqt$%JMn9NtyyQh%C3+aYQ}BU*5bCs5=4sB47^dq;`YiH
zWQtbJy0zL^+_tDU0iui4tW>ki0^ag#kSS6#!_R;WeA?qoggQlP7Q5hW@pi%{$P}sR
zn>IyruF)oBiqw4Q?Pzg_HsK`5E>bhc>9qlTJX<1Dq~@&E1ueFk>_DdSC>Gs~-9X7t
zRs8dqnR$Ov^2vX)D`G5W8pPQx{Z@0?TLDpt84J?b3lvc4TtR+3-i%1aj3v0i{Ca+2
zHqNx4qJqoz7unw^_JU7(J7kJv4?g33hBy3fWQt@D**aw-XQrA8*+sH{YTL9X&)x}{
zBH52Qw|U0v+>cC=?EU+eo6GA=I}NgnWIxyP+<0DRcVvoWU;eOXMqcM(WGXdd>3KuV
zZ>7F|=4xh|uClB3O+(GbkNQ|_IOvW@k(wLZ7eB_;Jc3MBXDrbT-G2=)=Fgc~W<Ye2
zn)lwF8ONCekSS7g^5J0?SJ~&0DN@t7?c#rUE9IRD*+ps&KQJViXCHw~k(w9VIgIAa
z>&O(T*`P$)t^8ccEf}(k)Eqf5Wiejocw~yyJk?^Gy^U$U=X)QRsy#K-oE10!Dn9Kc
zXQ}A2{YB60W+vuGx*5n6sp+}2@=ji73^G-A4c)_C97l6z`Pq<Nq~?Qw(p`D>xyTf$
z8B;86F<$3OWQx@6wSU_Uesjfp4rCXpnPzxZJN^{U5@d?h^gA*?J-@pWXD-w!QgdI>
zs<`|iNFQX1)ZBF9zyQ8#ZUUxiB@H!m>>l;B!0&BU#-I7dQoMO8x@><@vT~Qh_!hAK
z$P}p=+NVRW+`nry{>*hoAycI0uQy*UUXWaVK4e$psiFIe4y$MI&FyoLDN=J$?+M%a
z%JCeTA~lOHiQ9xTD=mQRA~hFROclbj&qt<6&FY75dht46AycGg=&_(+uBLYgWEZJ9
zaj)AjuI6%Js%h6y^N~a2H9Y!9M2b#mkH7eA@kY5?3srR4{-OdMhU~PRFqqX`g-nr}
zE8INyb7q`Ss8giohn&ftaAs3vsyWioeaWzI2RU;KGDT`OEU`5SUx|}0g6twSmmfL2
zkw2f@4w)h~mwew9%Afz-k4%x8d8@eIwrOPUr3{N9yGYI5T@shFG0i8m-GHg4NJCA>
zLZ0FL1Z*E7MQTo3<QdGTJ<SpoUG{x6r#f2(ab`DUiqvdwKVm1(egv5!HIt9qSC5}4
zW?Tx{MQXMPotTI-`y*4$yN2#H+vRD(-=-IdOp%(?zIYzxKW`OT2H8bwX7L|Tf$KgU
znIbj4Qr$buSIrm56sdXgzVAr>8tWR%RdzL;8ftppKiGknxd4$GYO0q|99eemg~2qY
z$$V7$f=tl~?c#PR#_?%yyaJ+&)STWv?KPf#Co)B9M!l-}FTdVOyAtXYsp)n8&UW6O
z{g5eAv&Flbad`GfWU5}$(0ys`JeBx`jLRy>E>d%9&cQ|bA!H&lMQXM?wqr0q)ICS0
zNX-|6{MzwVv&w3fT}9VW^U?QG=lF2WL!^e9#>IM^|K1Pd-*jalkNy#vA~iR?^a|rG
zUvCXW7pXaRNR3oH`zB<H)XcyBz<16}z82~fsabUV`OBQy6`3M6ldMbKi;w4VWQx=*
zIV{^$KJU5LL3Y)jmb$CM{GoHXZW-B)!-)AXABaqmnt7uZzvqX#+sG8D`Cv%&ORi?g
z^(wn6Q$x*66B9k-*P4?MDN=JxbmuwzcEAH<iqssO)ZgME@)8>$x=78+58@`_Q#2Ks
zA~ml@f4|Ph^BFQlYL;!6W(%*g;zr0WQuD<33-kCKg(6d==EiX6qdfaNWNN6X4)d<Z
z`}p(h)x#jW>Um4u6*FF!wRw4+E0HNub63XK2lxr?4`3>!hMHlil0M~S*4m_^dy3R-
z-!E}*KJCkqDN@txL+70QcEA^8iqu?EGvOw_8r9zn*+puepFX%4AJ0w56sg&+!s~0C
znP>~tDN-|E{msMq9JNHINKOBZmy_}P0b7wNQZr+YLPvP^q+21oNX<kQ+t1{>w?(G%
zC>Gs~EeBD9MqIP~$Yb7LwC@kIn6fAqGY#UcZ*|7=eZDES*^(D4tc^4_2kdyaG9Mqz
zHi%TrSb`hO=S>D=<)=!!kSUTq-@jiI@cW()+abD0_WcviSsduPAyXuKxjO^)@;VPA
zQzX0HsbhIKGxH9}E|NXGQmZU{j`|~0B>RvW`QPw5BatbRz1D)~&3T>qc0zWM><um)
zoz3eUjZBg3n?i42=W5;prfT_EY&SG2anIl4J6VNyspv&SYBno8*5cX1@yJwlYUn<}
z^I;A?MfZ>?Q?q*U6`WZ*9I}hltab3EE1&i`$P}sBs_KnUe)xQiOp%%~(bc!|I;%uL
zc9EJvBQDkD<GC1_A~o-|4J^m&{Dw@Cnr&W2CF9HnyCJ(s&56$nUf^nO0H$hB4K*8k
z^#9JMJ<c9grfh#v;SU!qR*uHV6shTZwB1=goSTrTvTNvm_t<AweoB{QFJu>~nYhre
zRlGghAXB8K$HS5T@XLce$P}rWF#7#EUZ>+e$SzVd(Tnhl{AN{eWNN5soWTC?CDt{k
zdi?hSZ{t$Nd}ApRnIbhET2{W#?{^p657|X(c6nXGm8&@cn5vaD)ZCxNw-x`H;}#-C
ztLFGDIjZoh!ZHU`^r9j)+nvf&ickA|WQx@6THozHSMv)p)p%;?zAyR8M*OO<-a*JN
zQgh<RWO?}Eb0soGYAz3Q>d3SIK&D8|cgtd$@<T|&Ly%oVO?4A!@zfrrcrS$^Q>5nq
zQFfMbRW)B51{KBbRs<Cr8!=Fk#{|2uv9P<lu@%Km?C!@76#KCY6%@N$u>)U5-{ZRX
zf3N*>)`$H8KU}VR&s;OJXU{q3(|{u7c{P(9fjUKMzIy1|*!J{lJjBomnAGeVYW8fu
zZy-N<?n9(V&B;zl8}J&XJ4(@I=Zj8di@eP<`yx}M=4s~#19|2ZWNN5Mqr7YGxs_E{
zQe5LGU+frUr#8~iJuJoM@_hH4hD?!~4X?ae&1Zj!Op%&?o8q6~hxzKqA-hP;<q`9I
z`Rp5zDN^(2KZ}m?btXIkb&Aw1f2V1Ge%9;=Oll$xH9OSVl#Cxe_ajoI=CO<a2J@q5
znv)b=cD|@~sq7DVW;bMt)C>w=)`VXqpG2mHnl#EM+!GMVGhP0J>>@SS&3IYPw$*Rc
zeGoFK-8FO{>XFmpE4xl3Q>3Qdj}s~QpDxUC3bKpTjKAvHWY^eXPF=?AlaVP>vudMM
z_4w)N3o=D&2JRje&A%zFf10w>?bJ|n!Q`4%`B7;VB1LL$Z}#;Qzug`843sHa(AH{~
z+L6DV{>T)m8Pcp^bDp^unIbhOxeN;9e?2DcS;#I@^T*4Zefc)(k4%x87hfhjz_-yA
zWKv(!&^^C*0*kG>!sj5nhMKerxmCLPcGX5IzfsLe$P}p=+P**?{sG|;GDT{Jp6&6C
zSF`MS%1+TW)Qt9;<<FNHgh-K^@Al=s$j@+(kSS90Lx=l4Yzqcs6M0>L=pr>IbXrxM
zU)0S+riPl-l}?{av{EgW%s)&VjZBf6v#+L~&JQ8=E<$#ZnxRPsTg-5qkSS90V{qZK
ze7mQ=1a(sX)X=>|zbQZYA*3fVMQXNdxqB_oJc~?`nwQtyUC*nT_cCRtGBwl;pVRmR
ze>(>wQlw^@T~o92i{x-*iqu@wc3>;MPPZ!%U8H8w(zQnNO*9Uf8fwylHgr?*Vtk$V
zkttF$<B4S-cxKsf$SzW|;n$!CeD*oW6sc)<Z{tnA&S+$c)SNUtV++2{8do7Z^?425
z$G-P!%@1{JkttGhUQmUawyDFo4HWMh)k#PVHIJwCDa+3seuxyQ*?5{qYF^Eq$P}r0
zrtkZBe6uIJ4$(zw9z6TqqKP^nQ>12&(up_nbsj;cNX?w5#yRuPuUR7?yGYG~K?lF{
zUA`YOMQV=ed1wN^^LYuGA~nZ7Dw&C|vv4G27pZyeP15Q-b22i?qrd2`P6IW&SfP_m
zP2>5ZC&Z*4Z)v8g%h65|eUH2TP_3?dlTr54H~u7t0|%B!nl~mCeOiofpkPFbWcLZ`
zY_To>2ALH7FE>*iws4uzF9$z>_}ql(BH2f;``VUo^kv8t$(}EH=CQo&F~}6jKKAys
z&OEbG6l534{<u?Vdp`R%WQt@D`5NNQ*O}}V)G3nv=Ybmid1eP>ie#_X_4s_Ac^H`@
z*~^6lI`OY#vfQTZ)a5nQ?A7y99Dcdb6_Fw}_h&C<u}nOPOsZ2u%^V*SS$v6g_B#+=
zq-Mm-^o{uJgOMpxGi_9pM0~SfMW#s2N~gOw<C%r;LUxgwD;De@&A*bEh)j{1Y1&Nt
zlr47FP?vFs;TbYTYL0e^&cfGO=N@Disrjw?eP4c9+KNn(n%nPp`_t~mSu^Q<s*}2>
zhMGO^ymsT8y&WP&YEJv7k2C){z(dFssoAPdhrRq#-sJ&Ar|cTKN0%L1im!77GBwov
zy|7WU``p88GpSXGs@2#%?;=w}O=9kS^YxzMsV-_{mVXG@MQXNL_{=qPEKglV=3-=u
z)byzkVevNG{t?tEQuAw-nz?y3TOw1WW}NWBFZh+>A!Lfw+;-`)#m17;W6Dll$x=;f
z_ED}6Hmbi=sm3Pifk+KCiFvl%?h$G>QvYIPo<XKaO|PiyX>-Q%)MaGmege@o)TBC>
z9$E40h@u*rjLaFxr2A>9J2BsePk(NE<}fl}AXB7f+GH)Ks(pF2pf@rrJ%#KVYEqqT
zyY@P+&O!bDCJNR0?d<GhuN5N~B2z<6Vs`l9_3Hy+<~rXZQ$tN+t_*5-gukCvpFwsF
zHHkUQBk3UielA6(NX^^3`dPe=`3y{Ib`3TAPEGOat&#b5`aGxT#YJjHv{<m;B04fP
z)TG-PR%_KNzKK2~Q>5mh!82#^b=G+S*+pt@PTuv4x|ga}qeg3xNo}N|dtRT@CwYzR
zUP7HBHJ5l+UczT@fJ~8^NnV_-!811?Q>5nX5*ID*XWUniU8Lsy<wYOxbv8w&NX^2o
zx9ivrniv<f+ki<;q@m{FDvf{rES@UW*p=eErs(i#IE}8fr}XSlUZY0H6scMEa++Vi
z9c}LNTal@uCT)RLxVU2&|E%fw2C{3YNz9ZdMp*ocNE>8os7cJZmo|Li>kLIEwYy~-
z5wk&b$Li`{n(t@Ew~$>!O=8x}*J2-k*rFFQMQZvTP5R0ywodc&>v?2qs7ZBRdV6;&
ze?Q&dL3WXv4-Sv9IA1gkm~=ZW)ub|)<a61>mw6A78nY%bYX#g&!86N7Q}hxVY7#Rn
zAkz)L+2<ltq~@7r!&>oYfj%Hpq^9eu%~3gGyOO$$L!IAy$SzW|#z6N1eD=f06scKa
zOUMxZSu@)QsFV7VhVGvm#XX~jc=Iqn3Yi*eQoCo#mf@{hJE_ZfKO>MSQZv72cUQHt
zF|QQeKSFkqniE#1UCtk3m;y|SuA!#0-GEAbv)@LfNX<Lh22JH}r{^b%?jcfhSG|#0
z_$`~c$P}p=^{LeazRoYm6sfuQ*2Gf$7DI#2kX@waqQPSa@@@1lGDT{h?fP#ao|)nc
z)G1PP=%S=)`60P0GO2%R=-y%MBa0ukI*Ck?n)5s=Cg8KXe1+^HHFHf~b=9^CF)nC_
z0h7wqP&3_%mUsEvc@>c&HM3?NdWvTj`9{%YzmK-{?8n?Zb22hTYOZ<mB^l3rj7*W5
z&b?Ay=bPR8J7gEB*>F<GUVaD(L8eGe*QNdzA0q#TOp%%=H|H<I-_QC#AiGG-w!@cP
z<(Zq2Nqt^J_wL(rSlrJ<F;J&S%|gfW$FtRGRI?p038|sxq{9BgZAjyS;SeH4YQ_n1
z9LT?r$^4U|mlDmIfupt$;=6obWNN6XI{EJp{-#*8B&(X?%r6iwAycI0QNKrbc#R6j
z{;%yib_wt=;$EbbNX-<lMp?W#nv6`5nnQlXKgHkA=g1VPc`va1B)%_IwTJ8?HJdMU
zviSL}<;WDNnP>Iedwllq$Rv;cqPsc`bhCM?#{BuB#&P~+r{4J&GZpbn_^@8K^_Nlh
z^*|&s|AJI+_C`6>s?Rr&V_Yf{z7y#$!4<P$_)&`|;x@<>$zHvEk#T$jg(8z~r$(I~
zZ%$9+vuBP6*+sIa2wa`gwp20>p8b$1lHG4tMvE_VIgd<{?BCi4SLL(kbAaq3*_S0t
z8p#iIfyfleo+eLMi*@2%WQt^WSRPo2pNu@?Lw1quVKb6$v%S$ZsyQ2&)a5nQO!)ld
z2>y0{KqTp|(d7?ZOLm=a_BshDdJ(GAl1X#s#Wf4^spx7W$k^pKAXB8~%dj#Qdw)qB
zp-z#SLx-nX!arrVN2W+kw~j6!dFDxEiquSWxm!n`nKvP17pd9gSkv-6b0RWDYWh@8
zw1VIKdyY(zntM+VTFEnOB!cWBHRGqv)X_F|7}eYiOzNIGYX0}8JFijV#8js2`->Xi
zK30lnwnL_dnzZ-VvAp9pel`k2CS|wOotVWBOdY`QQD#a4*+pumIg=+1UuREbiqwn~
zKcF(tJcUe=nh6gM=*ly5B!%oEHCJ|z9>Ft*AXB7f$4c+|@O>#9nIbj!`+Q%^*I76j
zWEZJ9aOIu%yqXh$NnJ@p&FzQUp5voGM5JieoY3Un5`Mwpm7Jo>zQ1VTe2;#-M)Q#=
zQnN?Y%AR}^y+tP7PYvC-v}s|H-6sWP7pWN%+~hi6=L%$s)J$3Ua2LMae;`w&X6CUA
zzVhwfC?#aqP?J_m(>HZmrI_kpjH{(>$P}sRGbe?`9(s~gP^U=E#pU)6wjE71&YB&8
zNzJaI=D48cV{J%d^b?2_safp9*#O%JVr1q@P0?lFUsODG+x&c28jVbmnk|dFUF7S$
zg-nr}_XAGW;O}RdG?1Oz$WnLeo<p3|UsRi4&Zh1;ADJRGb5%{$K=I7XAIKD`St3JW
ziw`UYq=oDnYSPN)@xwm<@I&$eWNN5M_j78yOr9#Y`E7QZbWo>A&BBq(j@uT=Mm2{3
zlbXm<O)4{HS@|pKTLaAJH=+=!p(ZiyJ+~iH(ak4lE2O9BI^SPJ%#2g}gsYiD>1ot`
zEiyIKB<7BlOMe}<P<k4faWX)i8fp@=N}sL2zBtreXLDqV)XbOCc@dv|Co-wsHFWpP
zUHLsf8zs*O*)`Op>@(l2^;8D~6xVn^J0ep<O=3=VDDKSH8HP-ensINnk5>PK`6PPg
zOpslqX4#qh<|~iXWmL02FzI$`sQI+zfKjR&nY(8sB1LLuuGD%C-$d@2DZ0-2B5I<-
zlYU(0hma}A6seiK!X;0a*zD#Z<SjBqYJR$$*HsO3*<&wb_iT~{vWwJAcOt?=jqv$R
z%rIn%)Eqfyc4ajat7CP>ItyflI;k&d=-%e&lyiI=1tC*IO`0{g9BBHPUoAx=Q$tN+
zK2Dz0+4iEtn7yVGWEZLV_15}O+ZLEn%?-e$=$2|ynTapnkLIH%$wp;*XsAidnFmMC
z;1`PRktx~++H*MNudkRg&qha)si7v-*&u(e=X~~T&X8S0O=2!vy<r*uTsR1s8fp@=
zTZ=3A`8qEnQ$tN++I1Zq$+uBK7s#%mCNa-^KG8!Brs^_w`ANv6{%NT@F|!541oKA}
zA0tzwW}mNh67mlnKG`9=NX@6|k8H5jX;gD9FsV!pHII#(;>q96#5t(Uk|H%9%ui_X
zyJPK<DN=Lzu!u5zokx%<QZrTNs-1aeww#b%q~^L&FZ%L7B0LzGA~pRz+_&0ZkQ=-F
zMP!Q9O#34wBd@!wD`Xd`8Q*1e0H1vXGDT`mh<`quuk$K0sn2WZ-gM!!P5kg#Bo|~C
zsk!5A@eH=?Ml~k_laLx}Hq6m^DIfhdB1LLm-CQ!5XO_-Q(Pih0Hk6!h@%^T=kSS8r
zfBn>dcs1W3Q>5n6@DywK*{FIR$gZKLs_geUsQ+G9zo<re^Wt+YGBwmB=7|prE2u?X
zR?`gUm>25QP?MNt>i4g$7IkK3J7kK~%+sfE3iW_s-U~T_Obs=u&g{1@S5x1;o6nTJ
zU_QuB9{ojkbsFe(|M5F)Y8t=4XaO;)C;i1tMQq{fdzC+e{~CxS=3kKNEYJsslpFXl
zsY3og!Hdbx7cFxdnw)3ON2X{Vjz~4WgK92y8Rw#CWQt_Z*z1_ZZ?4rU0NJUD{?h2`
zey(rj@eiMU4Kg)kr)6S->f5r|HZ6?V?cJbG4cUoVWxQP$zRmz-YRFE^d@rY4d>Aei
znIhRI4*A#O%W={dgzOr!Q=Rjs%}>ftMm>-zlKqrpjX>L4$v6+61}1fR4K-8FZBvnN
zBBw$W9lowiqk9&%FIs~CU{HT#Qk@#i)fsBP<ZtJBWQx@6vHjt%{Y3K~Wxm3YU8LsW
z)&oxR^Y9pCiqu?qq{w(xqq)wz$P}r0d2LCHug)w}1hR|NEO_C_dA`m$$P}r0xYYY;
zJo7CwMQSELTgBpyu5VGuE>iQ~z8h96`PF4qb0sjTdupgT<lnN}ZF^P55&0t`X(rat
zsC)9>C3ubeic$2UA~g?g|FVeJeH$_<yGETe^UgWRH+!PuP^X5PwES}Nv>&b1R7+ap
z{cMX&k(yts$DhmB8HP-enn}vk_veS?%<hm~q-Ke&*=q7{HTxh_q~`9zIll09o<^of
z&3eJhGw{ruB_O*<&EO3V9c_KysOC^$QdiPY^Qv>b5WdW7h!m-r*C9~^&n)ag(Pih0
z3T!J^i&t|3GBwmBjq3L7cAkHNyNgV^pO(54)1hFg6Y6EQ`AM^UNyx6DCNZ7b<u0oB
z6U|R>OOdIeCNaNFdU;m8;wfMnLgJNzIyKZJW?25<=Y00=$P}sR_ps?C{^|81GBwns
zI;*^xAE}tROxa78hU_9W+pW(&i(k-&0F#>CQcWuJMS+dw)a_JFZye>{AyPw4V*2Fk
z6vZ>^m!asg^F_|X@~7rU<ekXWP?MfH`Uh0m!ZVY4LY*3F60_*Sq)+)7t}QaDjVyI1
z=9z>)_wjXxB2z<6Vh+oc)Z*7<)0Tzo8fp^r=j`>-e4Sm8DN?h>&NwCbVg3j*HPoa!
z>rBhvoFC@1l!NRdH6P{fxr$e_4=|~TEY+kkeSCZt@xOw30+AYO5;N}MJU4CoUq;=t
zl&9!A=ZlD0d(Hi;{O#<8Op%)VZ+i^mnWvB`QZuGflfC@2W_B;gE>d%=PtKS8OZVZ(
zq;}WP{hsSPi(eIuLZ(Q~Ag?wSdkpRsAiGG-$^Gy5=ljwWWQx?>?moR7-|qL3DN=J^
zqPWLYZ&jCZL0iU~veWI<P;+0BW1IMqZZaY@)TCL{|H85>sw=6Fg&Ebnk4%kcO=9N%
zzB``ULeFbrR`>^^Yp6-g89^;tsT$Spr?JjW$kb4im@6))aN!qq$tpsf8fp^r>*IcY
zN_Vv<V63wTGBwmBX3>~(S@}B8B9r=(rS8OBz5P{swU9TT*D6#AvTLYG%--j#|K!gs
z%|fO~&3ffJHgk@xQ(eaU`30FGHFtUTO3%-lttwM?imsuicc#1{{91lHA~n>68E$l$
zZ?+Gr8lz{f0%dBbNzAB3V`FURH;l}|$kb4inAg0Y-{4maw~(o!CNa16U+>2+z=~Cc
z>>6qkbM>0`zrN2{by#Ee$;i}DlbEH(RI&It+!JJKs7cIuX#)!K*(+3o?9@Lkbtk4v
z?aUUx0x%z$A~oZ@-C^<K=mRoEYI<yO$;qo((}%KCnHp;Lx9{15e>Pf*NRgWVT(ld`
zFY3M_Q>148`qz^1bvE*a=pr@eRdMy@ncI*lQghVKn-;$xlcYM-DN?iMjXPQRI@=;s
zre>JiC8fGq_fTYt)a<%xY$tyB%v1xii_~m>F4ZFbnBGuiQlGcfoo3>c*Iy1%O!NNA
zO=ODHOz4xogKhQsKMUHLl%0^4YEqev^N(7t4viNujmXmxsi7t@>-oOfpw5^mu5pzA
zicAePiJ7NO>+Nb`<7{I3*MjI8Y7#T3^0k6$QD@%yJc3LOHHrCS>)|N=jE!q;s8d5t
zVs7b{vKYTm9E(g1HHq0FOPTK~xA|cI3uKDaY}su`54TvRx{U2!uMT7vsp<c;Rc2e4
zH!@EmQ$tOfi4VU^ZgEyETV1G=JhIgNH&dMk%2Pe>pI_27o-Z0iOloyYGl^*LzB`dE
zxl#5@KqN8$f>h^WW<725#`cECcr)|V`xCsl?0iwa^(~(88zG~SsUbTxP{F_(-}pN3
zB2z<lV)hvBWO20Jvp!_kke!&TW)1P;-#pJjCN=wCI+ALmw8uuB<CmVFk*Og&)#;n)
zg~i7Y>NJ4tBH70$Up-e1C+afxr47gw$$qu-$o@Rju_4qcl6|7jt^R!fY>P~h>~ZIo
zJ7{Yoqnd|-NnKt;&95FC1Nr4_CO?WUJ73f#INah>68(`$b!v1^`%e{}`6jxIOp%(6
zN8EkI>t3i4WEZLVV*j--e6vqPriPj-?eBBGk0xC@q2^5U{PqNy8fp?VTeCZz6f>Vm
zqgst2yM~&?Oi*tACVs876PX%n64P_?0Uw^3sR`7np(ZgqjF@<b->e#jOp%(S({!E8
zt9cKY)IBZLq%wUA4PT|2r--SEN;jqGvhOddGO)>Dwe(ci|BRl<6sehN-GiHInP@&7
zkgOThN!c}YuQ{W|EVYz39~tk1Op%%;Dx7-5Kfy&HQ$tOf;o7!762otRc{Yda8fp@=
z_whqRZC%OOM$?h0p(ZiI!i$#Xna_}^p(ZiiJRJgf=07bUyM~&?bR6$pjo<iOh)j{1
zZvX5{rTzzX8E4J!z@)BZsV0><+P+wPe$%3cKSeJ_i)4*1Ke#}<vi$8_jZBf6>8gFQ
z_$n;BmQbfi%}lduhVrv!V`S3()X09bc~oouer`vmNX=pO8xP|*SCX}Y>>@RPcs2Ip
z>+Fh5k(!rAbq(O}=Luwr)Z97fLq-0rX7<*QU8H8>ung{e_Cd%LshRJ3V0HepELVU@
z&90$lo4MCY^S3is8;Y*;`)H(lydz&b@M?}krbx{^Ej*g@w=)u%A~l!Pt22(zUc4=2
z*HDvIAv2!@PvAG|f{;mVq@lb2W4}TC^Xq41YN$zdR!vm9rK;2X=DBeIWEZJ9aPiv^
zwNYi>tU8QLk(#%@Is5S|h63%NPLY~Jb9)6@^iO1p)QtaWPj_C;NMKSEX{foa`yPue
zn*!}Ay3X&Tk(wih_ptZ~`9x%j)SO;>W^Vp=K0>BQ%?ek$R^@ds-vP2~s7cx1oVk{s
zXU;>WNX?cHJ(j3vBXt=UpV7#qcGu87B))47zD~c6kX@u^`8f$P^31Ks6sftQ_qF^y
zGjS)VQ>5m9=_(KAnE}WYsaeOp+=95V?V~Q^g7zRV>2_+UnI|B+7C&<&>`c*1h!(U?
z=}KFCjJho{HPob0zWlx}Kls-ihmfhECNb~btzAH6H-GNLr3+-&P?MN%TE?_gb()`v
zhagi!O=6xM-RRfr81w6`C}e7=NzAK5Pajw3wanj%^iNmFPJPKzcVY%rtJI5cqb<l3
zsk!gf`|SLRA!RqHQ>12#{=M7sGjT6uiqw2RC#S0#pw(qm^8_#{x`vv8%S(Bwo2xG4
zh@7E2MVEblkyEPX_4uujKFHKilV+po(_2}bhq;DK4K<1R{rww@PrnxK0ogUwBxav?
z(FghG!U@RKP?MNT>&~!vCVqlU4K;~5Vg9V6{LJxBPspyJCNUk{3m&q)+cWm1MaZQ7
zX{kFghki|0nt#@Ok4%x8<CitB#b>YH3$lyUJb&-1o2pt}Mm1LflgiXk^Y)%1FZeP)
zAyPDJ`uRj{=9zVRQ*_zyqxqd36v)r+>yar^vrG9xtNA+P_klV^YT7pm{lqg{B2%Ph
z=2N}P^TX#}WNN5MGh9-yJqes+yODX;OxG8(Yp6-g567-nR3F_kzvLN)Op%(^q8B{i
z+x-PHsn2WZ{_Rf3<vg=WKgcdpGwSrjuC{~yMm3iKlaLx}4(f7#17GGRM2ggm{PA)&
z&#c>@qRYO&$aV2zH~#(WMr4ZAj5m7KA->Be8US^Q)U1%P><T`6J7kK~+%Ydp2w!Iy
zGBwns*{F1_CI|Q-B<n!PuAwF|GpDP6mT#l}$P}qLsP6fN{Cnan$P}r0!SSa%&n!9!
zvXe)D(OsP{s+QWll}%0K`J!pWq!#*%nToh<T$Q2xJp2HNB<5d`>g>whTv?X$9m#$0
zpWyDY^F?p7&52Y`TIQ#%>Btl<kzb8)59b@`D>6m0+Yj&eknfz0hCp_a?0xoLxA+dl
z9mv#>o#wZXDeL9rp9)hBg*vG#S$0lhp6|6{je3kRAEfMsObywI`D{wsv8s*CZ^*-u
zsUbTt-I{m!^&?E?-GE}lAiIX_#B|E;U0&sOj=hXa`B}&m$-d@l|6B=TdFnFG!{32P
zUEWenD)a5Ewl7p{a})Utr|3H8i->vs-GN&?a|<%5PRp)DWBigeU5fI1zUf9logy_m
z&wX%^*S$M3MQX0g8-0p@dOeFw4K*qIIiFIS`5~mhNXV|CCNXn=4B5tSu1r9thML5@
zQg?M1zKw1nQ$tN+E+|_rj_O(JGHT>83bJdcNzCknRxab$N;8ltQuA}VHQf@%)~GI{
zny-LK-P2M{Dl^LMr89p!%Z;Y!vhzjFmik)!a`YTziqtGVDo-kYN%sbslwCvj^G+kn
zt1k*sm$BJ>#z1zFns<V`tl&3Sb|6!vX5if58hrL7fl#MNO}9;{p79$t?T{%_v-7Rv
z{rEaVkttI1S>2WvKS!NmEMym{S>|TwB3}1i$P}qLt9Pk#yqf2LNnJ@p&1IP*D)3F@
zG>)Rn&KK?Xj_blVQ9opg)I7iPxW!K_UO=XXnl!r~pWu>5&2Z)qFy$W)+39{->Q2l!
zcOI4G7m5>+si7t@FLn>Tp%#heI$t7Fq-OMt({B6_QfmTa7pYml%`<m?Hd=*Dk(#fQ
z*Dc30?I%K=A~l`%eYW^!#%9PAsX2K2q7%HDdw@yJuAyf0EK3IR(GyOh=(6)gL+o=_
z=b3GhDN=L5+&e?~+5I3gHPoaP!{dkVhw*i0m<-u9)Fft|Qch|3VW~GVsf{dkC+5VC
zaYphB+Ox<MshP8neII`2$TtPDi_{EHTl+k}m>-Kwk(wvthTr7te27eunzO&8ILb3C
zOoi+sHPc;8GKW`l5iqHVEY+kDd6JX;Lv=gVHiL0d_Y#q`wWQINyob3o;k#1xAc`*g
z{-Rrx!w>RZel0RZYDTwR;K0`zcN)|wQgd#i4i-PL*b<o<YEm1G8=8Bsnla5=A^VU?
z?XJ;AeUFX&mmij#rbBj-niDHk4&Xm1F%X#=YEt%AH>>)pFI_2Q>Yq1|si7t@mk*qg
zNgYo#f9qeBV8|{~(``je2(RW=VAAc>P}BF3b7y{6&3*=zsdK)FqQ4z}<S@_lN2bQC
zNz9<~H-CNZ#JuZ!0GS$U5_58fY3=z1ZT6XvT|-S`_6d);rJCLRws0geMQXO+G&&9c
zJxkA#DN=JoG4IX%aYEl&ke&LHhVJt#+h5^#<~Ji#Lrq#S*j0NnkFPVsY^YO1O=8ae
zQ0$&_Y#XV|I2{c^rbtb%u<qx1H6H+zqHCx**saxZwGE<<ff>szK8K>q&KK4B`Lc)Y
zt&x!#f=mrH>2|iva{B{6!+k)ehML5@k<BA5-|ThgLUxgwIW8vNrDk_EBN?;rM5czC
zRHxS(|784%A;mnXQ>3Qb*>f#;W+!Bd)U2O!^{-!kRSzD<>_?GF{Zm8t?8)+4{OCv4
z`H)?tX5V+4L--ZLKxE3)oY|_QYB6;gcWAEwlghMIlbSu=X!|?-r{P=|P;}YvqYatz
z@G>7g5Sb!1r?tH_nP=WXrbx}Kt+IRY3$QW^A-hP;XBiXyS}3Y{)Yv^2AyY$5nu#Oq
z*Vk8VWPa%Qj7*W5H&%2R#y`6^S_IieYIYv#ZK3;CWQx>m=>Ih?UuWXQP$%_y4c&jX
z8L*!pmf9jyq^8^3H>G$rLxD+14K-(VPI8#vp-mn_(MyS*H4nC|<-p(0_Q=#wle*{C
z^ULa~4^caty8Izziqvd2X8t2SyXz9jE>g2mzE!>W#ph6Diqv#Vn(UQ&KrrvnMj=x}
zO}d`}lNXlY>nyVrvWwKbFf+wWeigC+nHp+RogLRUtgV>l_wGNDDN@t3P{{`BUYhS`
zn`MxlJo=07>NL>TVp%KNR*J^+MaPLrck?f1Dq^}Zaf<M=XIlQJN_f(=MAFUNaloUT
zlE}Pi(HW5<*<Dsue#p<67mz8EJxgJ`aDM5Te+5Jr$$q8R7mMXrATmX=U-9yCQTNmQ
zlzkVOBH10z{_D@TQRS78T_pR=ub-~vjjgkI>}6aptVbqwPs<KZeJOsyy*1P(kooLz
zmQ_%vNcNA{F8$=Qk4L6R_R49x*WuS+FOeydeem5Gt#~zSt)}eM<u%m&??u>S{&p@w
zq=uT*M1_YnaOaO=Cs_k!Qk@#jZWp>YMs3*SGj*jw$P}rWyi1R8{*287WNN6X8pX~|
z9i`mx<V$US4N__?WY<uWm_J>fKjq(Q1|w5LO=7yH$n=D-^C>bl)FkH6IX55iOHc20
zkX=JfVumew5XL{kEkveB%~PwM|KN8*z9Unl=B@T&N%)PW#_K6Nbx%t*Df*0y<D>Z7
zxfYQcY7%pJ$%CVKX50->riPlt+;%3(6Q0=|nUvj9cVgDDZ+lS<DC#oK9J`PyQqzCZ
z*3tZmA@xScE>iQs^o3{mrF=JJYN$!Wr^m%can!Qg{6u^lnIbhk=BIzj>z;EHWEZK~
zeZr<9d>ai#riPl7y-Ks=8P$^8{EZP2$P}r$VCkCU{Ha{8&6J(Gl7^aPi)T&3N1uvF
zk(w8>#b3>L&u7TgP?K(F@-qw1t3{&uHAkf_5M4t}VtP-$(oQXG%!~O=$fWyesXH-4
z?mHG!3q|vry%bxaP7O7Q`87p{2=%08eu5i`Op%(In}2EJ9Lvlddl`qN2guY=lj=-9
zsYhS_HC**=kX=JfVxE}vbqD|Sx(=BlHLGuP_2*Y$$^L~pMQV=kzpOq#YYqS=HM^yn
z6us!+&%er4-O1QQClM)9b5GqdF{&GxyHe5Z6kX@{(WuVpxf-riuZ_&lG4qhAp(f3m
z(+V8!te#`kWy~IL2h^#dCNY1^81?JdPRzP@L?*S7rS8NGx|8D(zwkbfObs=O>9iv2
zWs4bZCuG-9lbC0}Hyy(d$wQH;p(Zgm?0P+uuk$)GHPj?#>h#;{sUbvN#&$2V3$lyU
ze3+_OJYLNpU{VuVs!3&fwYYwokA54GA~mP1>%5d_mfTIzW#^09uj=f^H~VyCiqssO
zKi?6)&KJlOsk!4u&QAQoyV4%WE>iR2lM?s&1#Jj2sogbnuY0d_R=&<p$P}qLFY}Kn
z{4-pgy^vj`X3V&(@zemVE~7@9kSS8r_jaO+Y9Vi4%qQ9hb&AwHGG=ZhuV!ap((Tkx
zv+1H9b@(RQhe(l{yZThIc<G*YKSeL0v7n_PWU~DZi!ToCj!co7&N)g}<8}WJnIbhi
zF3o+M*FEO}$SzW|Q-jAf`0hCrnIbh8otk(hacuWgm$A!7Ad~u%hVE}7QpV-Cs|tid
zc9EJ>o1FWH@1LWQDN=Jn^4$&jHi|-~NX<=m6HesSEOC&sQ*;eAHy!YJ!QalYh!m+=
zsL1sDJTnTJA~l1S{2ReDiywmMA~ka~82^)RqDjaUshNGilN<aD_W+q9HNDQ|oy9L`
zJ;NZoNX;}A+dSv*=X7L>)EwyY&f<rOpCFU^r={-nAQKoF*-iarUVN564B16$_Gwx@
zns1{8$P}qrCFaO|ej6wnm{g{Qno)O}mE~uS3P&iq?0nIAkN2PX=nIi4QnOj9Q4@LQ
zdt{2#EV!@cO@2hKeiX8c)NFg<#sXgVRmjv(le%Y?$LZ#%#h3Y+_$M+o)FkHGgj;{@
z(5h`P<E+{87-ZK_lbB0>-pi);7xI~yp~w`ed3e*vlIpqLycgnn9O|S#uc5ocrM~I;
z?Y~LL6sh_7ZKq58toag{gtSzXZl}Y#9!s5Lqno!^%ATO;I_Hasng7V{_56<FN@QxN
zNz5w;?&MR?G3Mt3$CFT}hML5@<NM&c+FCMqr2u4Vs7cJid6y4VO!M!}T|lOWnzWcd
z(caz1IhLs|qef-^gX|h=5;N=a#~Jwdh0BpCQZrqOsCE1Y5aOPKIz?(utAAr6|K7bd
zGBwns>~)S`Ib%BuWW1l}kVzg{>i(OlP6G{l9rfp%@Qvq-a-RN^oswIcNyOCmZnjW=
zsmplIcMuS1Ir|r+dg;Du-cfsgE;@}!V*Vw#V*0#Fv6g4Lo}u7{HDv!CT`|+73E#>y
zha*!%c47|fS@AB<j6kM_?8MyuVn={dUtPwIRO~Ed7s)=c?eIXJ8H7xc>^0NH4C2>c
z&ylGiJ7q7Dq*i|Z+)m|lke#}`Mqm2wki=r0xCWUb*}Z!=Yr)^oxaXlxk?bqI!Yn@S
z?GH@q@)~MZ{@%#q=Oi{GQbSD@_V@33MR$B;ubSQ5JriA^=tZbbjV7w;*tagfpBR8l
zk(%L-fqD43=rA%xYK~0v&SIl3`$fnuQuFT2QB(OLWC$`f)TB1@UD9B@`pf)Ocomr<
zHJ$binZ&>5D0&I9i`2}pEp0KLISrX2HG9^`;mY67SI88pd8WjvYW&k{)ytHfx~GPk
zi`OK0shY^F(QHJD)Ev~}(XXYf`DyDNGBwnsu9P}!g<I;wbp>ND<7`y#3Ph*umbw!&
zcOSbesz&n(+C#|HP?MNZjb}XPmx-?7P^U=EVgv4dcaE)7UB>KVkg1_2&2TfHJ^iYl
z3e9hHUm#OMP0BtjPFPdLGru9Pdlj;a)O0PqC4u@M)Md=R8<`?Cy9RmX=XV&=T!T7A
zYA$v!X7QQQuE3<Oq@m`+Yaf37q=K5|jL{DuQbSE@_F{bli}BGjT&L*8G}I(!%*Yar
zd1g;!YN$!fwfj4L=SR;|$fWyesXH;(j9J#7XXcE6>>@QQM)$kTGlwBlq-LR!b{0qK
zt|L=JP0F4r;lC&NI*Ug_c9EL>yJVlkGp8a`q~^6Bb{l!-6J(0ijIO=R;+q(}Z%}q>
zb`3Re*>4M1qrAF|Y6c@xq-Nla!WO^D{1%xaHTR?{VDXa*HEu$5k($*rUI^ivXbmz&
zYPt-maGqzziGn(*jWl$3bew&ce=cl>Op%(ICJrjc4|ThcDN=LDm5LU>e~{u9WEZLF
zUu?h#{(g2sriPj{yPvGHxf#Dnc@&u<HGecnm5Sf<b-7L1sfjGrq%s?y>iXU}R!g<7
zW>m8$A~n<`=Gv?&X7Q&UBao?~CNXO{xDQi%sd-Fw{&NSSi_{EC68CPBSf09!**76m
zq~?}4Ws~z7#kmW0iqyQ}=`etQ71bP>)b1L(ujwA=4BzE<AXB7f$cxAjelIooJ;*Ln
zGxXo09r)}4$kb4iX7`vrGxG6oi4P!Cq~>wwJDGSj)7+=*bUQ88q%uF83Hiv6o^27S
zp(Zi+`c5guch3XJ)KHU{L(BKx!PlAL0Yn$68MUd7#ji{DM5aj16e$l(<FlVarbx}6
zVU0%eUCH$!WEZJf*=OVd{(cTYCiNu^-SZbpVewg(aAazzNkekEMSd0345zm1jKgQa
zN041ZO=7+)8ycey;X9j{laMJ=b58R8y;W~jm+|GvYhY4zOEsy?kqggG;<qil9#eFk
z?=K?eVaMqwcxDJPHPj?#g*Tu3@NZvZkg1_2F~^*2dXHb&w0Z*BMQSEa=9WQiEt$8#
zLXjy_^Fl=*i!)$3o<f}>HGS+nTk}K6AY_WvT-E={DV`aQOzNK+x<B$>v`e*-x{PWT
zeg@e!)TCiPP1{UU_&TQ`Q>12Cw%hr6HJ<>J%CuCI%AECN|0ur9QqL*6?0nItMKve#
z%$dm4P?PFB^7(co&wPzc4K;~*J?*&7N>p_jo89LHWEZJf#pUuKexbMunHp-+5YlT}
z`xuqo+&%4HLY*QtBlkWy&1Y|lOp%(qZueclGj}0Vq~_#x<7V*8)UO~r^?4256EBJx
z#OvN2nIbg@CrWw8cFNf}Yn}lnAuZLUW}n%q!(H{4`TdsDYl^OOzKFW~fg%Zq@LNlR
zkSS6#$<qDvcxD7LHPoc+d-q-sRWq?#+!)m?`3AC!)O4J8<~85!3y>*NGhO5D$@m4>
zXJl%qN!fQl^l7hNbeKP&-0Ur67pb{>XUs-^#c&vzA~mP>sh8e4woY{!+bH)ts8d5t
z%0A@ao={b%`NdHXGRdRA=&sHe4Ieq`lI@|xc)sX8F{w&RGk;s8h>Nx_IA9|hWv>?f
zCppZSe?h8qJI^z{%EHeZA&3+`y)JU!*hxvGE@K0IL8eId#&dpd;OlJm9-?c=PJ>eM
zcik*r$LvI=NcN;PgX{3?g%ls4P7T?q&UXi<?&UXEIwMm<c4GS6PLiA#^9V9UviF*w
zal2AVUB-6L^AWO(WKYtsiN*SB3^GZhzlf>&eBjhQ7LNzFktveh?`M`SwoNsonx#Kc
zcIxsPY9^jDqA-6ugAgfFv(WaL;e7Xej!ddk<90rOwRH?Xzg7MW(KXbh@%ZD_Bm31@
zT-4N+mLpR`O=1p;8umbSd1n(d;TNb=Lrr3)Y#sPX&6nnHNbZJAk(!r|Rkrvo+3Uy@
zsTp`HpT#e|6#EL<MQVoB8UE{w+s*65smK(mxphQhi=V7~flQH_AKyp%^LxJ4zEO7S
zo*HT<bvxdV*JvIhMQTQN%bJYW{XH^8Y9?@RKA7L5to<FLQ+5sAo0eT!kk7srnHp-+
zY}C2W>N<S(ct4;{4K;~b=gIOb{EDF^GDT{7xY)b#b?!x`NX;timU{C?DbvM3c9EL#
zLK|3|a_)yrk(w(C_4ntqUqYrx%@XmuFXfN^75qursVixy`Lfcb{`_n-1d$qQs<6LL
z<+>cb9HT}#^A>spGBwmBW}03ZJ)L8j>TRiUvE&i^OOEY2b_wt=;$E_thML4|Iqk^_
zb->&FNtO^~(*3m5otQI9P3Wg`n~%TQ+e4iiY7+CZqu)^V^lHxD3Yi*e5_4zvQSbSq
zl*f>%p(ZiyUhnFr-ng5;W2$Hz$gZI#F%zEf`=I)g`AKszGBwmB=IN|i3aC$6Imcec
zzVscLA~lyh*pq;tHJit!?9}X*YEqep=3m^RW+OFw7|Yy<NRgV;=I3vxcuILAGk)xM
zyx267eScA}^oQ*DI$I%Aq~^i<y*sIAICJ*B$P}qr`cUTceD+ihke%8{L-%T}i#qbz
zyCPGh=9w)%zkUH!^#o%Z9Y>}}P3IGfZ>ibc%yf<q*+pswU+FTBXAVN9NX@|`((YC@
znit7ekSS6#)G5aUwa!tO@maHQtg^N~Pfetu<{AHY@A<AY5|JV`D>>e7#7Do0OpRHS
z7Iif`EStlh1uE$X(KXa0W<Td8ezr$<WA~hlObs=OSt)(e4}6{Xkg1_2F=yYJ&{N${
zbC)lX5VBLdYv`UN|F-L@%bSO#U}TEa9QVEINyRhQ`2v|5YEt%PX`d8QOmm%85<zwi
zHHjH=r20s;3Ni2XFGHqC%_qsc_N)IvT}CzIC#E{-c3P@QWyX1MVm!Z7=Z8oQHHq0L
z{;`5;L1$jn?MJ3a&4~%xq;iR6s>`TRj@Yjcwv9?9G}Kfb=l8<<(wYp5)YomBKOZw0
znHp*m^K;L8$<+NcA5r{@Obs=O8F_2gHU66e{F6d<k(x=pYmeZWVaTMuWT`u~`?lyP
zCpEjP>wnrP8Pq9K^Wl@NR_CCQDN-}d$Lh6s-NTV7QnS?T1I-;{bF0g!X5r+NouX@~
zX*cZ5CjNE~N2Ey2u9=(1@XYJT6sZ}yVaOx?b{0ti(KXbhuC#q-Zi}z2nv6^hHHkT~
zM@}c(`z>Sle1uF5HHld!ak*9e{VbajvTLYGOoyq9EMA(;My5#33Ej?D;a~E+K_>N2
z4c%A#n{6|{7g9C$fVyo+_7JIgyvn7rJaZ*7MQVmEK4|f*87DQ>No8uN+4x48mi+Et
zT||o19P>5en;P@gW$d0CkSS90^5Z5o_;;m_X&|~t%~RnuQt{b4BU7Yi!6i@Y^4X6e
zQ>13qVzZ+7VaX*eWEZLFSwBe+KKl@4iqy<Ive<Hd2)T+(k(#64U5MbBh0;NG>hl`9
zPrn-C#xutwQ>5nC=QU!d9lO}=!~dN%?*fyM8ftdw7Co6Svq*Z1E<0aTclWZ9>Ji)g
zm^~4hA~m-S`Iw#Gn16yyk(z1pO}x!7=Bs9a>>@SWw7PSOA3`=FQ>5meiZzp}Z-Q5s
zai~j?5$e=XlNQON;xxF)e>P}1GDT|U{(iV4pZys!HPoa!Q_TxKqMiv=I~lXri2dw{
zZPqNMp(ZhF=E!T$pBmqaO!DY2x~tPbKayt2X4|(go-ay~`A?lh{EL~2=-92?c-tDp
zxI}IXM4B@#krX`FkG3QEt?7M;B&KC>VxF!O`bdeco{o$SlqCxV*ZKY;Vm96S<|+SO
zdV`QDl6`!sw4eCp><wg!WWRdk!fT#cG%I8m$)4GxO(4&lfJ_b9X^EW3>)aTAkiUaW
zk?c=?UM*njp2l`B<pkL^WT!e`?#%v}&psWQ8nP3!@xv~?`8uB<lhm~A^S_x&&2ir0
z!49$gU0p^sy|Phun%^wdq%yN#cl5W7AI94`8Ic-l67%T^r`3G)d&s0Z{}Npt*K*i$
zDml+A?F`XHYVKNIvMSFEMy5#3rasBj^UP<+6sb8obpKGE>Fom9MQZv5j9bhvk>?{*
zq~`bAxexNXzelD>&5d1;yyyF8jqH$Jq-N44U25_7b2&0aYTodgGQqajZ&dReFsXZL
zsM+yljbVHf)yzTBi;C2I*|5-Yp1B5@A~g@r9GRS7e#OZNby9W>-5<MnwBYxq1CS|F
zbI_{>@%W|u8Dxso^tA8v)H!xER+n-3EZ_>+HPob4$iY748>;N)gAp^4si7t@yG7^u
z^{YYVLk!=Lsi7t@m$pqBr0%DAi5!p%vTLYG%snZp7Eyi4{7&K+GDT|cbj=dMtC=S^
z)k$4RL(M}g`sCri4}CBqMQSdcpSUtVdR{=LNX?%yZfkjF-aHUpq~@*rYZvm&QOKnG
zsiAw^xM3FG;d29-A~ioZFHx9Z)Vb${>>6s)$|g_iCl>qilaZ;RCNZ~V96XmFk{=>d
zLrr3C@AB*mKf{&J2iY~$BxaTO>n8GhzH^W%QuAKt{f_E?P?vGmd=E@&b`3SZdX*@r
z#uIfJN90QRDSB~{n$7$RE$5qPDKbTB*3J}v4qxXtWQx>$6P;!}znAJ)0J4kJe6(ut
z3O@TbWKtVx=wABC!*Bc$lEe+_)KHUVju$nyw^y@<`Gac#$P}rWx7V2A{L1DGGDT|c
zopHM?zxh|FAY>P*Ioq?`F8;0iOk|4GyyHH6BtL8Z046n&hMJLf%YS{fzIn^0b|H%H
zuAwG1`>v&<e|^8HY9^!Z+mNZDCNX1{yZ7X`fl?HPIyKZJX5{>YF8so#Co)B9W{#NT
z$IozAkSS7gTX<k*ehA551hP}RYv_J^Yfw5~qp`>oshRHB@z?xb|5Id&)GVE=V<SF$
zm7<Vcq^9GPSHAqLxeS>iHJ9fJe$9W}`zJ8zc50|;UvEKeK6;&E6upFonzUdj&|;;<
zH{WeQriPltyxpvFStXUajJn4!4s~j%NzCHWIgjukA#aULk($Nw2hZZ`3`3@dnlyxD
z8P+dC{bhc=mDL@xi_{!hvgIYd&Vk6JzNDeM-S*>AJTn}bA~j=DCFsFxRHOuC7pXaH
ze*y=-&re0BNX>IK;vVGHd<sm8uA%0@RiWMZ6N+U#D7wz~7g3kr7#xv6&2Z{6Y7~M@
z4K=BII&FKKU3E<})2<}csi7t@mk;^qqZUi%?SK}@)KHU{lbZCZ#{V+O5oC(g3}}<4
z5<j~aDh1g!)TBDUe|PK7GlP*SQnUA%W=Z*dix0@8{;8pRP_ykv`Nh0XX~-^8bM4@|
zS$H*<BU7ZN^TgGac{O8zNo8uNIW|Ykcs_dVG87%Yi$UXdt}Zvo;w0r-WNN5My2o{C
zy@S7<aXg_;4K;~b#pP`P|6JG{nHp*mGezk|7Q55Ckg1_2F}IZ2@{^xAQkI468fp@A
zeM8r?eD-e06sbA)zn+0S^CU7wYJLcvG?j1n?ByUk^?8l{nLMqdJHNFw6qzD5YrHOz
zj#o1rn1s|&^ISx#DE@ZlE>F>A=Zh+?C~}d%og<McQu8185|R86aub;%HMftN)t%4o
z?giO3)TG&{;pfM%6jS9lt{8%lDN@sGdZyaye^8f^`4pKNYEqpGE99Bw9LqDmJgHOx
zvTLYG%zZ<qyYpv(HX>7`<^!+POZgR8N^huBq~?^x1HP%f74!Z|FJzKOf6-kXIcQ$8
zS)fgK<N2a1f0*!C_!l!3@#UE#Px!-x`TnsbFHxADG%b<TK;3F>kE0sM{ArFsh$N<E
zaAM9~Q+}YDH_Xe~TgcRqotTpnrR=B#Qcs)44qv7sMAwj=n88Qxc=LzKW+PK1d%qc(
z#;9et`BOX}kSUV=zpMvW@Jr7ol_0x@>@*KwD=>YYx)bU$-p|d*)R3K+S64Nf#Sh4d
zD?^<k+3$_*_p9B_gJ)Z0iew+(Y|#|H&V$Gl$=+}NQ73*L&QOK2Q<t|?lWu3FH3c8@
zWp+ZOhML5zdb9E&ejYx8OsdmTcVdn?*M12<XF64d=o)Ggvu>+u_4xhS0m#%)lbE-v
z$At6u^E@&|YPw&E`pIX{Qw_3<)C~N%IX}-Fg-nr}mtGzj&ogf#Q>13ck%LF`%o0A3
zU8JVR;Lrs;a~d*5YIgtU<T3tr%rjt8_ta3ciBqA|e3@l^DZ1=@QRqLLzwv6$L8eH}
zR-L1c@O8dJCS}*qy;`LkkNBCRdUePyQnQ!qcwb)4HOLgHnJE0kU7l%Q1L_p1S*b?7
z0(|x+$P}qr+TOc2-$px;DN?iGi2AGezLcUSWY<trrTzU`;u$d|s;HHsc|)-?GDT|E
zFH!m|ujYARQdhE6lgi8!JheJsX7*YXy_jg$Y+CcpP5#C6SY(RS>|7=8CH^VqIWk3R
z?(6S&mw#JWy*6a0`>COOr)(W+I>$D<y8dUOh)j{1^$vZnz~9gGb)ZfSHL2aVY}vn2
zecHzSQTHLp)KHU{RW4NCqWV&PQ}*Y`)KHU{KdT(r$Uk({steggYIZ(cqK3Mkc};b0
zLZ(Q~QuWp^;?+!DkLsjmw^WlBVAZC-n8QEEv_qsw&0=paSo|u>K4gm2T=KY85?;+T
z^&z@Q%>}_T;_=MB$P}qLeo==|eule>Oll(y-3t`2^qrqM3N?W28fsFz?~CJU@e4l_
zk*T33F*DC_I>Tqbk4z0Ui8;1g-v)ek&xVj)Lrr2<a5y@de~_7jOp%&1-FkGld1O5L
z_X?QQL>g-TnCoh>2=Vr#=sM?%D0+>(eyjO~%|c{~)LipCw?F?%;v+IeYNo!`vnpR_
zy+)8-q~=eL%ISILMr4ZA46b{v3eQZ?80w^U*U-J_kq<+8W-DZh)a;eA(I7S7smr)x
z*oRD!n!e7?cWis9MrQgZkX@wa&$)Hi^Fv5?WQx=bZ2WBszYTN}m~=ZW)uaVOzwB%K
zsxLb<pU%wGl%m5%vSqUq^Plene=TgBO-(ccnIbhu?OwZ@A3Yx+Q>5mkyYYJRx|eST
z*+pvJyctxLuX7<XMQYZ&P{rc=Vm~2Mq~_&@?@RFAvtDz^PJPL;-Dya!?CH0FKl--;
znIbjs1T1dB>z=3u)G1PPid}Mx?{aR3Op%&TJUd14Y90nAMYmLwZl~LHx8i*CH2xG_
zcE0FFiY^U#W)EbF)NEI-{eE7fGsx6XlZKG8opPR1!-x5qBX3K{uAwF|$G$yXPd&rA
znTDn5$kb4inANrh<xv`$Uq;!rf;u(SBxe3sjosCdoX=EeV`OTmNzA&fzV=Wxn!nff
zATp_cTIx>B7IFIaQO~dDmr>5GA-hP;H8~$X;a3b}kSS7g{QBXsdkNf^q}&1~m8qd-
z;S_ciY-?oWf}vm=iY_}}H2;Q6Fh3%XMy5#3%zon*@ywgZ)KHU#rOjD--{EIC_qLE-
zLrr3OjhMTVZ}w@()KHU{Gs9jl;1_kzkg1_2F{jVm^Xs66%5Q9U?*PcIp(ZgKT<o-x
zA3hf$Q$tN+9uMz6U5TnLW1U}-Nqyc@cVccje#YX1=?&XKc9EKwtIZAPXU#3ZB&3F#
z-i5w}@m(oSdn!}sd=ZUwK{u-YTFWc0@pd*trbx{$LH;HACfb2ak(!N1&%eQ|nX&_9
z7peJVp7R)<*#(&*HT};%J;V=7Cy*&pvs_)@)oOM#&v4EiA-jf})b5R6uDGnewZ4$4
z-NzzRq^84=m1WdR4)cqSXk?1i9Jg%64}NF9Nhioo9{ojkbsEUc!^Ow;{SL<SMF)sU
zJ^n9dD&o0yVR3ocQ+EDSWf9t+{R>ik`AGBQ4!N9TZ>GA8VzxmfF)f2rqYtVzcC<Q%
zp3lTQjZBKJ!3-aF=(KvmHZMIrx<GUd*{RMHCp(noxB8bNQzZMY<u0xG{Y1O2P^U=t
z-u_8$@dJn-GDWiA?X^4~|D?GMnHsXw{C2X~c8ee1O3@9ni)7EVxUR+5adt+ghV0bt
zIUeNkQQz)hK1_HLnIhSjpRZkyS2Is{%1&M0QcWsz+sooz)DwpqmyBu-LZpV8)I=Ni
zk3PnCr5nhkIxW>C<`IWr2UWGYjCGdi0ns(oB<4()G!{Qy7>rDjnjy7|59I57flQH_
z&;LuEh1aNRPslD(Gi=@4R(zeSkSS8La??o`-;^7t7t|?IbI#u2Qhc5M$kb4i+WqV8
zxE*=sK4gm2^p59sQvDC=GQN&U-<z^i_q0@#%KTKJ$Q%BNqXQyEY7Wo*v;p6hjv-T|
zX5BCCEk5>}qYp%<>>9c+Uc0apKZFcJriPlTp?{xUxqYMN2DK4lUV26#Q$tN+CT?=O
zxZ;_YiDmmjc9EJts?IsiFOiocQ$tOvb7JM<pVcsLo{bXrgE}?TB<A)>hpzK0n@-5o
zP?MMwGI^C#8&&yYFXJ%(A2LO1db;<0#~)%S+MlvhSJF^3d+qTX_)iK1B2uL0umQJ2
z_-22MObs>Zb`DAKxTso$sBUk(oizqPbPY9$d8_!RDryKZccqQUr2A>9J28)W#~sY?
z`6eC+b&AyVewL{P|M|~B$P}sB<Kfw8+tZfuenufvLrogyTe;;<#_xm_8wA-k)Ffux
zQhk5@n3tM9jCD>yriPltEMLw3E??&}WNN7SyWQ2ZW=sy}Q;MmEdgH8FaWG}4X4g<N
z^w{cOAG9)W0xd$MNKN1HI2ONH`3adKHRHW}*~}K**hKY)Ky(c?sfm6z&J)h>rEWx~
zhML3-+|u9?-|P-Up-yTeOWlc?`f=y>{Kk?$GDT`Sgu7njR}8z6DN?iUxoUlQX6j*(
zU8LsIWp9V`%x=gOsTo;zr3cUa51ATj{%)gRY7YBm@p12*!znv8k%pRsHjGQkm)Q@I
zA~la*{}942k}o1tq~-yi=jl|PYMe5vS#ShI7pa+~cAaX9XJ$@7rbx}NwaX9Zvp+<p
zhMK=eWVKbdIa#x_&arix-xhk0gzVJr8oG~Im~A?*`#NNb)C^p<-<4;^9R+oY)Ev{t
z|FT*ntIOE#&5)^~Cf(1DE=f<Szs$@7$P}r0+cWEJ{!MAd(UhHTr=^-y=APD@Hmgxy
zE$ocZJ0em;O=6zB`mG1QP&|T6k($eWcYRX7WtQJmr^^_KuAwH?`Kj~bDQYpR4o@4i
z2O(3W<}%+e7Oy$pB2%R1{VPu|@y}a+fskE8P0Aj#Z`OP@gqXYMPGnMFveccJSC(C`
zsUBp^heA@1g*r9VBxbVYccax`<~j!=Q>13GMs=2}2L$KX%h>MW$P}rWro{c{ww-z7
zg0|#1%1+TW)J$-*nWu_vE^{g(MQZwbyJc0M@HaQnYh;SlynN!nPW;yyHyIDnHPobq
zVup#YbMXf__99cH=5r_ad;H9id;-*|p(fS2-=T2@p4kDJ8fp@=^`omzcxD(fHPj^L
z?x3p{&zhMgLU!t(mbw%3lJB~7{6j|{WNN5M%q>g${L8Nt&mdEz=BmzlX7Ddha!;b{
zRHmhxRHoy`6_Nb2(Lh9Ms7Xx!ohJwK%*)8sP?MMsB75}WnQoIIx=782|BZ6znd6Wt
zQgg5Kj!r!DE;2=G#;+ULN6j4SGLG_Pra*R)nge$Eb>O?_9At{rY#!6<0I$(IWQx=r
z*`P{m{(kyQh3wSlHFPf-S!*VLKUW}ALrq0-v{TQTvp3{?r?RWz&Nyq@1yP-Zv{dsq
zQa#7~ytyQ$nl;TE^L~gFsk!b_*I+*SZe)toEOr0;F1{<JnFi4{)THbQ2Q5vnc6`m*
zyCYMiW?<HxMHSD?yo^kdnxTD0rcrHVUeuMI4%s!-r0mZedL~y#ILr?S3y>*NbIQSz
z>-gP%hhV5vLrto)UBKm|{ELqE$kb4im}`Tb9`lR&3&<po{-V25b8-5F-EBMG#`8sP
zGyY_!-f3y(@5x9J-wgIW&CkOlfk<LnA}RRcg&WVPzsw!!G9rojm*8punHzt9T7KzS
zXeI^M`F%8+hwqi^*oj}#jX@^ePK`Pn*S*+^XGS4YB>S^N2fFivQi)lRT_pRQuZ2JG
zbJ28UYRFFab5S|J0sIEob7YES@71M-#eR3y*^pgBcB=E>+?dIH_GQS_ke!%ur=D?C
zeO_J0b<KBViez8p6uE#`v(X&NPV<|knp9@aAq7ME=<5(EQZqreTg&+F8E-C>Np)&y
zR5pJ6C;aX7N2W;4jeQ=@x7|)-6YWE$NX_j}ztysBFc_K1=0SFmn!esg*Yj-@fJ~8^
z&!$8z;p;qzOp%(Wr!}6%Gt<q7>>@SWF0WXFA3nPxQ>13go#RvSed#zdMQU!0+}+)F
zaL2er&c1-MQ}@(Rb9deFgSM&N*p-GOQlw^+{8Kmbw=*1>A~ok1igMwfj0!G<=#*VU
z_X=P7EaJQTSY(RSJnH-H9AD=hWQx?RbfS3}&n&qJvWwJw*l_qao;eMfA~l0OH}>P(
z{RuKfYNozcZXRD}g~gCvq-J>jsaN=RpNCA5n&Ah=1o7vKqJc?W$x=-<X8b;?mcG)>
z#{A*o${`e8=lhF@`C`ia<otp8Rmjv(lb9)1rkko>n>d>mA*q%?ogy_49n5%)f7<Gg
zOuC;Mx>p)7yrp^~HlKrvK&FP8l-<7StOESms<KNVyGYF*H{aLdhvY@b6sg%}<hiGO
zmybrKNX;u1XI<wP-Zhp%c9EJvA2U_p>s*ISk(#@&r@hUq8E-k&NzHDlCM{^oK710N
zFVhc^qFFP`=Pt!~=2m2Cs7ZB>35d6iUnD190ntTjj?1#&p0BeVGDT`ec`SBTQmM<h
z3OR&KY9kHZJLbzUozI?SC1e+=d85>`t30zmGDT_z`?*+r?)MThMQSElS!g6*XZ}@?
zU8LscXy^KTyN^YtNX^nSbDp-%?#2b}9bi%uX{b4PZlf9M1-ZJ6UCCoLMVEblQGz$V
zP53>^*~k>Bc`5K<1)li{nIbi(ZTY!f&F<<lW^c3xvWwJg<k;l4n&H%CWFAGPNX@1{
z=a1)S_nd2?PHJ}z-76;fyvL$@B2%PhowV7K@-y5WWQx>$cqOtkKh%|72iZkxCNE#R
zKff<O51Ar0TkVX_%g>s2>#0t<of>M^F6s4;b8I(Km$56=L!@Zd+>opDbp8t@_aRe5
zO<L5=n%pp#QpkKT!g&Kk7pdu<$2*?NtuABs$;i}Dlj=;G&1H|uuFlyQneUM)QuEb~
zMoajv)OaIg*HDw{9CONHlo~$FuZ<2NllqdS?!-*sKiF9fpXT#g&YPf44K<1R&-OEm
z)x&{v>}9;4Bax}0CNVo5+vLjE`4E{RH9b~M>&dHGc{63F=o)GsPu8di|L8ssks>vx
zr!8*rB`NQasi7t<XnS?6vrOGwbs3w;cMC)psd@N$>J$88X*Du6)TBD+b{ckzzn^io
zLY*Qt`;4wOl4mwWriPkSXU0d@FY?Uo$kb4im`g_u`@pXll5T_S)ITkCC+0ebGSzuz
zS7d6aNz5)QTBhMw3}=xkQqwibZV&!cZtj06JC&)SX0pE1eE1FT{)iN*S?lAz34F7k
zL#9a0sL)7X{&wcx4$(zwc3rq8glCRKrbx}w<Bodr%p1rQsTmQra{|9mbl(BlMQRSX
zbl2jHO)xS=Y8LxEwFjU56*5I?uGw7rg6*Y*aY(MZ6S7mE*U<ga_=^_5P`e75A~nB7
zjvi}!5odhXjI)dCB&3F#6YL}V^S84;B1LKzpBkqke>*oJQ>130;yn`aGhCA05M88Z
zwS&W6^1G?+kttI1g<WQgAH6+|Op%)V0&leBv*+Fe*+pvBwqF`y+qN)v`BBIesrhc_
zVQ;=KMIuwAX3D-%=lSf#_d<4&nl0yM8qV)q1R;|=`it)BG*G6({pQ-HIOF-EH^ii#
z^cORK9VR@O>MAdLrG0;r!>g0OAk|r*r(yMeeV2=QBV-ODHDsr!gVF2V=cpt2=HFcV
zgiMj_B^$;)$uE^!?}z9bvQwSsYX2z2e~kJtGO39y8=aWPi>zA5e=^AR0Mw}=J277+
z*p*Lx30Qv9<H2ZTYRFE^&7S9fov|^u`x|6x$WF}WDaRGyvsVv=>>9EY^MqUBRQ!|X
zI%JAuUsP}A3EPvVaiB|l5b6}k{(VE{3^t~59`*+&b$Janr{*lMlpl|`AyPw4dOB!b
z?{h+)ndlHjFG6)%c6nl6@JdvZXSPPBhML5zb7n&Yp1Bv98fp^rgj>le{9KeO46<ve
zNzBlXU$gLUHM<~FLrr3SS^2IjU*}<DYN$!fZKdl~<R6W)9ER)~Y7%o&^J$HhsOmCm
z)EAi|HTPA@=*ZW35t$-2r~fyxDz9d~Bb1%Gr-qt-8w&dIWe!E8NKFs7ri1xq%~fP-
zs7a&e^4#9V)f1d~lrM4=qEmJa-R<|+NX}=UicFE3T_SG!^UTM{6sb94O=pY40ba)-
zyGYFjgKo#+)trw^k(!P>TYhkkZ6kFVHF}Rsk(y60^cujwKWKIwvWwKbR5Jaq&y<?K
zPA?3ZA~jD$JWau?neznINnJ@p&AQtwPE#eC%j}Ox4K+!lY(9<V^9#jDWQx>G*s;SQ
z^|sLbnxpJVh_0a~)j2g|v+SxHsgIExyHW@;>3&-3PRv~I{kJNf`HMpn{0DVvs7cJV
zzWEOGuO#{+Q$tN+&hD@<BY!_5kSS7gW}hV%Cw<GDg6twSyLv`W;D`BOWQx?h*WSaM
z->7?uOp%)1LlXS34avp@t<P!7PR*{NW>DpJiByBB%h)}aAyPw4T7;Buo8}hJj6tS`
zn#8QX+4D1h*rLf9h_0a~F)yb+)Q_)o4>C2>B<7T-4&8WW+Otq6wUMRn#GF03bbNlJ
zt|u}z)Ffu;vR4=Q?s*=WA~lmvPF0GZi3^;A>>@Rj@2(%j*EtrM8fvOm`F-4VO}sb1
zeoa>0Q)8dMk4%x8xxOt<!oQ9wf1a{a6KSY9V@3TjeDokhiqy>6v`RGJm0loIq~@Hl
z{+0QCI-d&=U8H72vck{#?CX&!QuAevON02cK#muoPLZ0ma-?d(*Vze~)b1L(XKg)p
zuG*?om$7@EK&D8|-aE%-<qumFy#(1c)Fh3zuIM_DUxCd-rbx{r|F$ZlRyGAp*}o%G
zq~_A_{!{rK+D?}#JKau8H7R=GeOo;Fh0T6MYN$!fHf0AqQ_lzHvp`N)piGgP@fscO
z%y-Yx$P}r$Fz7=?ew4q1Op%&(23Ib~GfRg<c9ELCmwNv>@oCg(CNf28uKt>!I$!4t
zWKv(!(EaY%jD`6jx$;%WuAwH)?ko0qzvtV11u`|%B<A^R=OXw;vi&uvQ>5mZEst*T
zYBmEVMYmLw%FMsdt+;KCY;5*Th}2M%nB{UjJfK8Xmywy^Iz{&osadq|jduL)Y=caZ
znt7Y7%fWZgP-JSWIlZQnpLO;O5s;nKtnlGg+r9%5+u6taU~gv^Pu;WHzV>mP;{Lv$
zifNs_4>Czj4W@PW^T;GM|H4%7_R>u(^uTsMjn7+oBPlys^q20bkSPM=)U|C+8<C>`
zNfK!w=jC-QZbKU1X<j2FwT}kz?$IZC`P}(${K;LM6w*LG%U$uXLu^-2mofJkK$1Zk
z$o;h^=TLo0T}I>uK$1Wj$dol#?X!t)M7rFh;N*`6vf#MtY5485A%GM$k9~@;;{3D5
zc|ejq8dY{~+o=sd5NC^`;3SU*^2u@kQ#`UKAhpMKB~Re;bALYJZfu?-fE4-YXSb{i
ze=pPCqTnJQ%QQZ>+xDK!=wkpOMXeKh)iapCmHU7w^6~P&8xQlyq__X%b{F}$^zFCW
zd{6fWq{zolcjr3t$ZdcW`M5mUrZTqmfw2!c+@atiADw#y*WvGFb3lq(yl8v1=;wZ&
zax)-BKGy!&<QiY)Pe6)%EIZ@$I38K&F5OF!kMSRs3gVH=0jc4m8peNr-B)_w%NLc8
zYDP2q_<@k3TiJQ^n%jJlzW4s*hF{0l7%j7u?{S}>%oYJs<YUOaYaYBjuK+3Xv8i9M
z#Q<F4J_Q%~81QCDQ@*Fq0Hnyrmf2fc443x-so^8_p`RTF#Hc=`Mh@es;r@Vvi#k!?
z0z04Z%`+L0A|JcuzL1UYm$v~a@-eP=g<3qa$U_RQ;p6YsznaDKWq8()pC3mPQj|N5
z<AscTABq5?Xnri|@oyDAciu;Ta>Em!hT;wCW>3!}2Ln>%V~uQAy!k$K7LXzzod;D)
z#Uq^`Q*e=wo8ukY&m(&SQo~2;L*?@=9Lo=v#{ntw@k^TJ5BMt6KcV2FemS#e(d|64
z6Cg!C28_*6m+wRe0IA_4jcq;iRd~VAkIA3@2`(zq@&1H3e31b_6!}<e_TWT3au*;)
z^W*E<o?(0+O8AU&i+pUG%r~5G@Fsv1`IxYCWFU{+2uP8Sbzcm%xR-X%DY(eTj`M;n
zTD&eGMLx#+?qt!^R{&Dvqr+L>p8USXM?i|Y`mLc2bJ)&68y5z(UeLYN@R7#00lTMr
z+MZC1>(xz!6cOX+-u#*G=?*Xd6bV0mtudJm`_%o2W9(u`UB=uE0V(ov-Izm9_$pTd
zQsiSk#~C+x<VQe?eC#*=&{95ll~;5xMLrHrJ*^X8<!nHTd`#t6sf}$<(AYeW0V(qF
zTgZ{de3hQBDY%A@H1o{Z@=s1Rw*CI%Q>BreUF@E*-HMS@04efuY1!G;Y~Q1541NcY
zB716j#x&>GtHs~gf_sQ2vs6nO|HqH%6M-l~=Ds|s7LSYqq{zo@9j|uek%iw<Zjq1K
zGIrd{BS!;L<l~N6J#X7S9cFCstAG^wSmQ&x)%;qc)H@0;^3k>Q#8BSHNq`jjcq!SD
zeY}r%0IA`lg4q4~V)VoZKXvBiDH2V=MLzDCJT@*rTm}MC<m03PjZ@n0rEz||LP$|h
zAGUGBdj3}CdH*N3{%_E$hum3(qR*;<PF==sIS`PdD!ucbnP&U!nh|*gkRl&rTz<~w
zgXjA|!9_l9jn3POZ}7o@6!}=L#ri|MkEZ}B^0D8^E%EuDp5-G27x}ok^!L2{z3c%<
zk&i`Btv|%Kco-l>J{H=!ITK%H`cD*G<YUQ3JuTipb|9pvTSjdE>Bi^Y4@A-YIAedF
zE`07(pa0}8D)RB}<}u&+KGX(~qTr+3e)+-&-vvmKj~~1A{k2FpFVvHMq2MAPL-WU7
z$_H--NRf}_vsD?wH_sM8ihMkmXzY0YUfO@9;36Ln&PY>>uhI{YA|K;d9u|+Uat$Cw
zJ|+w9*`8mo#t>4}ht@qznT9X2{<lB3QvWl~YJU6{lWHZ8Tn9*zk1?quTk|uI-FK=|
z<m0G)j?4L(rxqYZ_wv>F^f7!NS_(*!k9#NHUB~<Q4v-=ryARvigm0e8Kj>bHeC!sl
z;#ofULO_aq%pIEPAz$T7K#F`^U9{R&9{EoU1sC}^zUJK3Hl%UAI**W|2G6xAqZfZG
zUjb1xKi<AyCMDm8%K!Y6yST{5YYS)g=8-c1De|%4#huyt;Ew?*^089KM{oHmOU9lo
zYS*z#fPWE>;-cnxcy_}m+W>4_s80r@$j3JSm4Cx;Gu{WJ$j1zOdiJz^qQ+RIw><?H
z`S>E`k3zN+_D19qK#F|4Rc}UB+h(W{X&;BG6!}=bT@Q=j7-~#Njn<)ktdU2qcU4Dt
zRSOx5+z3RGj}r^MxyV01CW<{s`TyNg=X?%TS!nOYQmR{;-(d#;Qsm<SpV?RVZn+<j
zA|K<oxsr`<@XYZjxX8!TtDS$^j@lZVr#B!)Exx?$kn?IIOYK7#k!Jy^;UhKA$*g1c
zDx7K}BhuM{f{T3YdhU8pejw@#NRf}39M)T$Up)gzk&kYb-mJ1!X`CNj;{OS*aVyot
z@OvN2>&w1-Hlp!X_6MTK$H9}UJ>!w*04bUuGrZ{F!6RK0P;QZrcifZx>O<ykIRua*
zA1gIKlAW*eA|ORR?rwVhyKMu{*gSb0DY%A@)Z(8m)!4}omqP(5>O>!t%-_aWc^!}<
zAAfAD`;$kyC8XdYACF&O@`*=|0;I^t*Uf5_wjqr^UL&L^cdmcuHs<?K{zQLr%U+?J
zb-Xs1pC(2DQo~0YfD;cp7o}E$s#0UOj0B{}$Il1e{`ndnBeGy(3NG?7SNt4*zTL)%
z3<RXeNBgA(d)ppRjL1kpihPVdwkU{ip2A5exX8yiOQR3*?~cX;Qq(UWjT!LN*3*r_
zZvax{<B09ET=;>ga8e2`^0C>FfNZuZjXq8yq^QU&rCaXi8~ip9HReZ>C;EriP=z$h
z<DTqK?vffl(wM#?QSP+-vTYI|MLy<TV;{(O%ZGpz`8c{;?wb6)ESsEyi+rp(!*Lfs
zT+RTbhL6-dS)9L4Qb-lv*wdc@Qsm?DlZmJCRaQtr!8LrODl2U4mS5dVbw<Zn<y=6D
zy87L!Z}agj{tA#HA3H?fZ(<8>^s#cvKfy)BMJpEX<@?Y=AZqwX@|=7Y=ZEbRpvGJI
z4v-=rvzI+Ohd(`4GZp0)`Pj#8^?4q-8jvC%gQ}$4$=^%6)KsO&$7MbGy7I_|fYk7j
znrFoIYWex**#Jn9kC{97@4;8;n1+ID_()Z5>oqM6FHZ|VihR7iFIO$wr=5-cawi}~
z_PqSr<)tmS(Z|$jZNW>5<k^#_`(3_Ub^xLVl7_Y&XU_lnl1K9Z90o{{k5l)QwdY$W
zLpsVW@^RhyF==^Z4?v21ToT@MfNiuiHuy<EYWPU^(tF*dV1-owVnk+3Pr*e#K6vsz
zm#q&Ok^KNE@^OEi5w-Z>X8<Yk@pU!N&U}?QGEi`lkJocFF2*AV0#f8-Q}4DF`St2~
zLW+9&v3yT2@jm9r_$Rl{`5fv)Z<eLHsd~D?8XJ5FAVpP{oOARuFV7V~ihOMM!#6!2
zyg=+Jj^De$C5woB3|TSp3twd*AVof|xH#ag>gft=yq8gc6#2Nm-@yH<vCN7W&rHEZ
zKF0HNaOQ&t0aD~+wVqYl@`^tOq{zo!@pg3Kk>#>baFLI`Ia@EVA&v9nEJBL9r9(i@
zYy6qZ=Rnk$A8D!4Y;X5reCyQA`X{&Sd`{q%3FCR>DnN>YSLyTVsqI!8dwL8YMLyQN
z73VHrWdkP)uHhry%ZI1Ertq&cHv&@R<H|VyCAE#|#^CnZs7jHKJ5Rsq&R5wGkRl(?
zRB|57PiE@?De`e&g0hwPg}R+H1sC~v`qtPkwtH#xu^AyneJG^Tw0V5)EkG3cIJQl%
zVtluZ@A4;iF^&0=rrf8!3fxjvDuIlBs0AQJK1TT-K5n~}M&x!tYTQez^3tQ#YxpV?
z#vVQR|0%ba$j4Jl$A<EwhCd)hK33oBIfO^50}{3>MLu>P|GG7gOqzp`8a~p!EW9f+
zx7xu|0vVg9Eg(fcdd-=*gzuN3fE4-Yl&i|WwvA<@kLhy$39ixLlzYpQ=rDCFRiVb*
z9e^nEar?`j7x>%<0jc35O%wNWdpYn8p5B#mYxqdPk8XW_L;0w%#^BumDe^I*VI@D+
zht#Hl5qSiV8qGt&-Mjr5z~9TPxhS~E$9!RzKiIzE+E`^@K#F_}^NQ!hk8Rfgso^69
z-+KJaTpn2<Hw72@nEKkWRs7U55|APv+Yfy@#8#!z$7_TXwa&0@^*{1O=FjsdH~dhu
z#^)ca_G_HgR;01PM*>ph<Lg~_-1%;K6_6qyzcl@kPOY(2rN$}?#(q}e|ECFe4Iilw
zeQHr-0Uvx6AVofQsy%<aZ2&e_c@2=F7XR<x4ZYQ{q%I>eUp@*h@-bnF4i@`4fq)eG
zcsTK{g#5j{2}qHT6KC#i!*`-0`6;-_$DPmi#Mr7d`Z$4*qFcGD?4m!vC}M1#C?JaF
z$EQyxS-g#MFYqUK36YOwa`!F8-^$5=)bNqysW*5-AU_a20Hnyr;IjMg@Ku&}qu?4o
z(kvbxf07e_xGflv8a@)T^S5WcR39=g3?2ef)QMKa<Zfo`mc~w0x*!D?`B<sj?izga
z1OZay<Bp5@dh*Tl5Rf7tOSF4-))w68W7$G~f{SvG*mJT1|59c;5Jf(^)v8gPN4^52
z$j9%l=Q{Aygl}QWE%Nd9vh49}x6;^$76Ve`<AiM$EV^YhAT@lXQ6sTkEl0jvRxLuo
zHGCwb|Det{__Gy@0V(paZH=+V`JVn6kfMHhxzeov_$QRwMJc$*$GJZ?r{Y_DH6TSk
zMn)!{YC{@*{7y)XB5AY?>0k5LHx8)VY3!D@i~Y$hd!;#}e?%p|53L5I$j6~wnk?rV
z{0AU4e5BxB6`~#a4TA>7DY%A@gv^oT`(t%PU41UWcrP~tQsiTzZjT!AJD17asY;QL
z6?#tW&2KZd2Be0M6#UTc!rxSjo2T4RK#F|aF@MAX-p4d0D7Z#fr-5i=?wR{}WM@E%
zd@NpKVSsJwG5UCzkRoFIyM<1v--J?^u@5<U{K+l*{+x+>8_wo)j|Qa3$FN6fEAom*
z0#d_AYMqadT&Fn4hE|s`c;S*1T*F5~9&PX3-1bWpM&ukoihNx3yl=EiY=!DFB7Xo<
z<YV~D|D)_I!>Z`MK8)R+V4<R7fPk1NDkd1%qM~A9i(<E;h=E;TBVZR6qA1wiAYykX
zHrC7d{AbphmvyddejoVoJRfe?Z|`;Qy=TsxIfuN|-!#!9`_!c127IL8zT4jYkZ1fP
zLqa|-u&7%`5nlPzS6Q?cRcXLSS~WUnPn@UxSL)ksqZtyiCv<R`-Rg3w_wkyB#N^pp
zbGd^&lx3XM+%@f>^J@Lu6ZXiTv`=72$j7;1dw<Jcj*4eU$j7=(dWOhVI@YG(kdJPc
zzkA5L_*{mBd@L56_JX{bJ!MG9N55%iadMUQ>rimW#|GzI8_UaOFhfE<x^5{IDX$vu
z8Pb4{v}$~xdu@aKElqc43J&>rHhOz`^-Jw~AGZ_IK&R89ktR)%?MjhKcKtf^hY=wk
zr+8=XD(CjBtL0|DiEQ$gEmis9cltESIbE4_eU%3p(twYI9PvGCKIK6O<#&7Z$XxZP
zO3240D<7_q+tQaIAs?4*8|ERm<r#*Ad~96m$_g22U7vzOK5pvQ=8dfQOooJfEV_8{
z75P({2Mh`MIDB`JY;u(@E)*Q{G1n!x_459>f{+H<k`|4~KgTMoSETy3e9MTCkJp3B
z?Uj)(4Yb_Y^EpE^`e?s^qpxx~Lqfspcyx%B4+b9@67sQq<23c;32)kvf<r#`dAH2O
zBR}gH67n%mr=&OXs_~s6As=Jc4x1*AWy?ks9P+V%`IRN=m6?9V!x<9tF>m?DzVeAE
zZDXnu@^QY4`9j&pE`)@7XmQZJ0J(>DFe2pRvk^-=$g`8NiI&^Q^EtF?41ZykNmjfo
zLqb0Osj{!0T;*<tgvN5#&G7efm06lnaLC6{zvAuXD!VZx<m28EO$*91zK<ax9~Yg8
zH1Xkm4p#~e`PeM*@lyGYdQXOgeC&~JW;S_x_Aw;n<I&@3o5|<ZtZrIxXu^G>E1S51
z*M$)wAIDCpvtAy`oeXK<R82mn`<|z+yr!pZM!6v$+rRMbD<eG^67uneZQMRto*fJc
zP0zprZ#T;FWN1#oAs^3{{61g4gV&WIAs@#Mn^Hrr@)$!xK8EdfdMA&iMGFcJ`Iv6%
z$oDdG7(+rn-s@yxDesSG2no%O*TZ%u?&lO~spZC=&$+dsl!>28_hm=}KGMZr<ncY*
zm7!E7U4MEx$B>YZL#M>ok$o)bPQf7`)2wV`Vk}29B;;d<A^rczRbFC9XvR0>$-P!a
zTD79!kdGF14)u_Co^cEb`S|dVV`2G5)@6o-e6+sUr-NK&#nu!Y^08aIYd+b>DTIWE
zvU1K}^W@pN&WO<d`1r@B1#<54ZM59j^Ep);G&1o`rb!G5`S`{rG?%=l-(X0{$0_$O
zEtVHx+qM)O^0A+Ni1vaO{X*o=kdTjuw$#?XBcw;(Vo0coinh5mL>^1~b`;!zkF)|;
zu6p{ZvWu5WwF1v#NXW+_4{fu{*N^WQ67tbLxyBr|)%EvRo3z)08^}#3!Gc-WOqXwl
zu4F{W$4B>SZjlxL!H@>_N2=1p{q7)nwRG=5xgj63d3E~t;eF~C>uqI713pp@oof~U
z?*(Q`czvg5?MPKZK92Sp7$V;c?aq*pkAqgf-Yic~3`0UbX0}c2CO1(54+;+T<<SQv
zyyPl}GbH4rU$t*j<y%B&84~ibOZ8mY)k`zIk7YY)!J#6}iyewpcU*lBjbTK{$NlX#
z&sB@mBQG!{<fGlbvK}(BL}$tk`RJ7YT>%;C%a8_qq*dcn*Z5b;e<^?Z;3pXp^0D8;
zmRaQKDcFUALq1y8Igw5dK7b)1A8l)lm?t9-GbH3=ffh4n$jIED6dY>xb%XEykjJtY
zLqa~T?$lBH27%tkNJ2uy7d6h9I1pv)s^!KWG3Z{VsD=E1q!&X%K90CBsfN5-9%M+!
z$5Fl8zEh7HdU<kpqu`K_N3N|IDI@zZqyZmk%Uv8bqk)1<z2zQcNCQ3+vVKGVYBDlc
zcM1;qxU9Z^Svh!bhJ<{KZT)PLjErJP$j1kFpVgKX&*??MA$y9&r{APjsrRvmigdsp
zrg``3k(In?>|;b|e~h^HwWcgjmLC7hol+#^<D$ju&#Aff@^oiN$j75=-|m$+v%L%n
z`FQ5S>i6=5XXr`64fse~?$!Km?d9q5U`PW#5;FGt(2Mf)Y-32sM|=OlW98s!dr@%6
z$G>A-Ys)j<o*^M0^X%T)L=L`%At4{zHeEMF4X*dmthW{%>U8VMp=;y`Z^MWNe53{V
z`N^(z6r?hodU-Z5Bvj@0vd8Sy+<Ig(Lqa}wDPWg!6)znwTlAr!gnWGKSjS$jat%X5
zKGtjF>m&EjM}~xaOfEXr#Lvn!@uuLAk0&>l?I{Oe&5)3fN2*oGFCVf#FeKz-^8#6;
zWX0Y3QgFz}=9e;=t4O_%YYAzfElHlw$1WCDKG94q&nHHNd~DLztf}l{qkdX$?D?F^
zi(cMTbL)K!W=I3UX`5JYy|SZ>e8-TGkK6y|doIh<pg#pS;3G}Xovn{O<*^KANXW;I
zIo9uzt9;9lkdK2dUp*!->J0`^aLC7pH40hERW4^p$j2!zc}yVRG9={V1($Xe)F#sV
z*kGU*9O|LXHQscWm$v1MXuwD6bi2<BywoD~^1Nb5Xn(X^k<>zc4nmKtJBV^aK0e-X
z^sn4Q3mFm`%NsYQjgyg28Pb4{G?vf%PB!t`QO&^=9P%-_hUZ~<#^*64<l{W+soHCS
z_0#i^At4`g+pT^ek7bP^6ddxg-iqCq<&UER84~hwXY!&ZYOCvgd`w6K6HW_o@GtM{
z$~vSJsvpYgK3Z-^$j9FU*Swa8axOzcJ`Q`|_`bYaK4eJ9$J^;!m6fZkK9qt(K8{^`
z!^96m&tXVtdIE-B+Na2)OuBx0?lC0f<0sqFVRCT$VH6zl@l2Pi+hn9aLqa}&pa1%$
zj7(%m13pr#2L`TPs2qWn|DzvE8(#_z`S|Ba+tcdWruQ*`kkIU`p89dDYPi10L`H;s
zY@E07Re30Fhikd9-?z$A_;+D>)$n6T$j22!^P6}(?oEb-d~`lheYT0<BPh55A8CI~
z+VHo${K2aqLqap&vq-vVd2PGLkdTkB8)m$rwxzy_97j@c$Vaz;4k;g2OPBWn3~9he
z8q4t5Jr45p++;||$8?>3YZpCwA1jU0f<r_3>B^M>a*<OQ5%O`!xf)$$WE?|6`{Vv+
z-kW8l^=Qfs`8d7o1`~I`CorS|A87&hY5mc}x56$nB;=!e-hs(-r(2Do;E<2Q&nyj+
zeH_h@P!mnIZrN3yo{J0#`8fCC%ti7yUQ3Rp;E<0kZ~wX^Z#`2O67q3c{Epr#Qtx9t
zA)(x%zvi1bW0fDL<;H&B>T#u<ZRH7{z>tuSQ8D?w<Za>_Lqa|VpQ?3F?sVJn6x@K1
zv;g<|;j&Mi9sM>jl_4P?^G%*zMMmCWNXW<O5&2F0B6h_I6ddx=dyCmCdB&$QB-EET
z-sEX5E1tlRkdJ?-q-!A0c*Thn9P;t&%3t9sQt#s=LPAA8%bM|)ocjtRLi^*RbsK-l
zNUKR&ZtVB1zErwiUq+5$NXSRuqqYum4_#nL$Vb<`cWTMVQj;mT0Uv40y;3x`of2Ge
zQm^<JhBV+KArFsjonF49et{t&AL9=kSR$_)#ivkk$j6|Di<9ITAI^|as~^a<GDt?A
zW=P1#YnQgitHJd?7MZFAhluMZ3^MUDaUVv6d^{Cn9ibMf@1fHS3GI)2tKJBaJH4nM
z<u>3WwdMSJR-2V76|BBWUxtKyTy5oAO|J4ZLmKdrw%jq5owKP6u)fM-(<rzB9|_sD
z$@y@3dWJG2<m2DKQoZEhCm9m*v3<dXz2qv3OsC+Gj}6=&o|UT{%8-yfZCw65Q>)bb
zcuGSW`SBZ?ofbcb=aC=HxA0eU+hdRXoX$I^wOXXUhkO|l@^S9zUB~6~>S=~F;3EZp
zV(H;7S6O-n1&4gR;`!Ocvrc0e67n%H)7~tyj~5sc^6^!Ft0wX`Q6hkXLq3MsC9IIE
z9L|uCk3Y(!H*p<xiXkB%|J)56AqO{~Nx>l>kNhd2t!;WA2NM$N^uL?t50F3EJIaXA
z{#b6$06#f*zFAssBk#{4dEBSI?<iN<mmwh^i=GNHaWgcEAt4`=re8=aw`Gpm6ddyL
z>__LUGSZ77As=rxJ~c<4o;?f+`4~96qxRUCeg)1nhk`>shOA%xTV5_ZGbH3=`e8@^
zJ-Dl2^;Pa<NXW<86AqS9$5QWO`amtXfwrV$Tf@>-z9_`hMRsIF$Vb~v8|~$D!B&QZ
zR*jc&YnQ9J^+TCvF6A~5oD^^9Rw+X6^!5x1`Pe_(o`%Xlp#15p+{BQOk9$kb^OC>G
z^n)QG9~V6>vQVC$j`L_NAs@Xh3-*$yXFEeeJ{DWK#>5*T(#)qSAs^c;8T>|`@s11$
z`MCN0;I`^Mq4#kMAr15p`S`@W%fC)f?c+~IG~gp4ub1DxMZqbPu5U~C1=>(z@6UPR
zk=?}m$-@{D^09P>xbt#beq%@jV@Zmip1LSeMz&Z;!66?@7xr1DjAiQS31vvg$7Pm<
z=g4RO?+j_cN1E{$nKM+kN~yA3su^#$h=M~te%v2DM*gy53`0UbHhy)oh&(+-7gLpx
zk7e)2S5+4xy^p?xG%(>blq=d)DW&92{l3SOjA+0|YRh}~o8FgusMHcIw<EMaZn%}v
zMjp!13<>#YVN>AWD?m~|m~@dL4fsf7>CkybsPbP*x9b-otECj&!1T~qR-cjHS>7Kf
zGbH5W;yLL|yixEjLmKdrs%*I6O$m9%9hOmW$j5QN>RwViT|brq3<>!da&`Dgd4Igk
zkdTiX+Rn(RR;l;VcDWWDnw{zGqK?R&K9vz6A3Yn^Gx5t92@DDO==N-OMY+mKL6jTv
z(Y);*6Avc&F{A+>sVy&OT3{)ECn13$As-JdsBYrfL;GL~4$b(PF`oykJ*4k+e};s7
z>}?g{Dt~yN$dHhal{#(fCo5iK1qFwE3_WqEf!suM84~g_WWh0e`Mmm=kkC*DMYuMT
zi*#J6<*o+#SfJY2!}3thW=P1#?30&Vl9#so3<>#IJ*)RA8R@W!f<r!b_W8C<M*1@(
z<l}%t7q836n+ys0*!}$c4l=UhY6=cDk<G&VMdUZrOkzmL$8;C_Sjor)hJ<{~?|ka8
zyb#%~q2Q2@-<tYIs!09*IGvDC?kDwQ?x;llYMH=@kdOBrTg1u8ifgsp)gd2mol9@x
zVsA1-LOwdJIXOz+%;Fgm^6~iVn>*ySt@1hw4*57}avlqLZS!YH13uEJy5#pi2Nk4J
zseZ<9F(l;UmIrUoSf=2VKRvQ?2nC1wa`v2J8PuIek6gx(kdLP~wrMXfL@yW;@^SQu
z8`ITR*Zb(SUJDKtIj%}&6F>Mlj}ajsL-%Yk@p;EXhJ<{)`6l9?{8gE%p_Ci)vD4j>
zi{#k}WJt)z$-Cd1`0m<$hJ<`v@@wrsc@%;4ZRrq3!66^t)c3C``xwBGkdM!^XDlx-
zM0Xex^6}2t&n0D~LpTM8TK#dJdIjYfpUIGrkIjD<JF702dLM5S5+WXodF7@WuAlJA
z8?@Zm`*X5AD(@r@<urzbd~CTtV3<6Vi41ALN7^RbmzDb^w`HY`6ddxgMCX}-SyIGN
z{`6xxl_4P?cXhCNoG}Hb{OOTb8Pb4{bd|d%?`JQ0dWvtN;E<1}a(5mg-*p<nkdTj+
zeppt_loDF`(+9uCkdTj4I=ef`NXyL>9I~g?veWg|zSR3TL_<12o0-{-qM79)V;K=b
zw!T;*N=D|~qULtM-k;O%!}Wh(15~o>XUCHv4fsfHd9{A?*>aUT84~g_;M<UtXPu?b
zAAd6><l`ilO^)h>>w~x4N@EH6_%~C@8*-H)3<>#IXm?d-c~MVdNXW-};}&L@SB=Ko
zC^+QfgxeD*%SYf<3<>%8pqp=^yg$ApB((F)jHsRR#a5|@T()buu}ARgJ-p;2Zxf3d
z5~}iR#pA*9>^x>j$j6sYrk0h1*W5wDAs;t+jvOlopUsevk6oT-IxY9mErx`A+*~tm
zhAdB|ofI7M@m%SnUuEPJhJ<{4^VZ&4M#eED<l_#%9{uF8wBAL*As@Z2m3$@pIF67|
zTiWJy=pq++i4mdwvEK5P#pR*2jL>pp@6YM5y|{^2x{hE-DEQyto{4hs(+mmu*sGq!
zeL1-KZVC?hI5WyKgZ$zBV1|TzJb7taU-<}pmLVY@?dsLZAz$7X+(W@3AIDa2a#0@3
z!3+uc_~TIiKQi(tLqa}!yzEz6J-+DAs|EII!J!^HT=wNadFScNh>(v<E@WS-E*knX
z)?tQ(_Qxe(s+O0LdG}Fn$j9F1%a*G{sjspxLqcP@=3_q-FJ?c;kdTk}KBw6uuNt}c
zQ*g+~LO&K%klV5+Lqa|d?_sk$bIKu0`O}Z(eujj6OmORK;up;_L{f0b$Jar@_2seb
z%#e_e5sijvpOWf*+(t-f!u@`I8zRq+*#Rv#_Wqn^CFkCeukPD1B;;eQF^y6_UzJYP
zyBQMlF{I+CopSJWQ4}2Van!r5F7nRPks+b!iTTyNryM+tAt4`kXL2!dZ|n<0LOzx`
zV|Puivgtt@OUTFc7msa|m&;&=gnYDq^k=?|e8Z5CkC)P3&aLhfdLQc^(t<;?v-$Xv
z+VY~Ym=U4<v2d~QKXUG;3<>$@9Pn+Pd?2b3O}QZ-FN|*bT9#)%Lqa|tOZ#eyJeGGD
z67umu?V9!ERm1i$1&3z*Uf3%W-$L<YNXW-6QzNU&Gak>7kdJ}82l&ckX?=u(Lq7JH
zKWLYX9LJE5k2eOy)K!D)eY`+OXebNkoZ>APSv*F|jXj@Zx5Ounj2z04kdM0x*LIMR
z#~2dw@y4>93F=Vl&sh0mDLCX~{bmhKyfCRRLqa|_|5@awylNa`NXW+qc84D+ANweO
z`rw(5QgEn=JhoNIC;#eCFNTDC+_o#oL%xnW&XACg&t8T1k=Hi!V-y_nv1iD-e~<br
zd!*jS!Gwfzw_opS;<m<7Muhf9&mw;9WqI-)*K%Xe=Y$umV`6FR!;p}V<@e^BDc=l@
zWJt)zzfU%scujYv6BHcsaf*wTwR{rn%#e_e-A6U5B!6>aD?>s)ekh#luPjgIlN224
z%Qkg;6qTE(8$&`q7GHkxrHtIgkdTj$Y(8nPH`4o<_LLSJDzfUhZ#m@!xC0|XKKjI`
zohh$Fp$rM_kBMy}lH`ZmzA+@^V|??6CFLqxpQfRNd~6@PJFkokXGqA$O8!&a)C&~-
zX7+<2As^G<jtG^jY<Y%)Lq1OL_-KKQT+fh@kCmdMzRJPBG9=XM_lpEfm+v|?J4?YK
zANN%I;HOrp_i+UwA>vz$=5g||?HwaRKJJ*8J4i;>Kd0rc3HkWu#iMO%Zhc!WVMxfw
zgy|)1<>vujG9={Vrz<5)EWp*zQ*g*fr%~(Y$h-I~hJ<{)R_9qcxh)eJ67q3xhaz?5
zDy=V2aLC8FsdZBBE=hOr#xNx0W5uxEe`VxZhJ@^?axheTRg~UGi;HUTDv&&WH8*vU
ziyXp;5Yjv%pSL_aF$@X$*l~8Flt+H0*~xW@azj4evzReOMtU(M<YPXcK2GvB5y6m<
zk8^!4f0L0JE>m#G$5j=d6_A5>Vo1oxIX51M$t&;{hJ<|daqf^oZld1|3Hewxb8u~W
zEL&Wmv4niQpV1{r-6!-uh7c0!^kNSR_m|JBUl<YcF=ldw<MQmdT-9=8@6Y)X5M?e8
z<x+-(d`$DQ$29qB;w3{uK2CYK>x_IE<&^SqfOr2veY!hTv4?!@^YHH<xypqM3Hf;A
zXu@q7`IsRgAD6bDvs^}2y-vX)9}i#d{Xs?sFeKz-M~fgwc_B(<NXW;*_Y0O&`%>>?
zg*YuZ)RwCUHR~+<IFS({A15?zX5#%h=NJ-NH3|)$w={jq{;2%v&#RX4lp6}ZxZ$f$
z@&Y`NAt4|4Wu4bbogICZhZxd;kMz|0;IWl&DGRWoxgMD-<ssDnDeeIIICxQbEqS@@
z&5)3f9RmuilaY}O3Hewg=lEr^JXsScIOJo(;lhjLE0it_3Hi7@V0Bt`)zJI6nUGKq
zt%~VAO8#UonGqo$r{CXESbiR$^-XOkvG?aVIMt4ozn!|1At4{TADOgW-pn#5QkBqH
zdTiQtQm(QaLmKc=X+$%#0X~i$H(TsJE>BM+Lqb0OOs?=%UWjtuqTrB^p9&?L*dMzw
zB;;dK%#{Obr|TD@T?`5N=={FoY#EvMHU)=#JUU@)b#(>S``C_<(1bUc`*oRI<VHq>
zd^|lg>ks*ru0I$O+8;aZTX{syt)HFNceJ5&gnXRXd~APNo^XbQeEgJ{=e@j5{9#CF
zdSWX*sV>XY`Yr{Be7xb2FjAiJ5Qc<&Y?$Fy0~z^=At4{*)^=Pg?~je{QE<q|{^@Gg
zk*i$BkdTk{KU7Gs_NCs(7ledn=Y!jY{&EjF-Pdwgg?wyh_N;z}l=WTt)5|lDAt4`6
zn<cH2H?vy|3HkW=?6-9C?ASe^;E<0y-nGmjBmEc>^3m6OL|ysA`#6S#W;{4o0b8|)
z^wU%MAq9tgG@sVEn2empkdTk7=PfNJ&v*huLO%Ywkg<_`W7*~r1&4fG``y7yopHU7
z69@?nWwS%IhRL7oU1UVa#~~Ij-_)B<`Ux-hSj$}v^0CmEwXbF51crosJYe45R$hp%
zG9={V`M-(wa+Ow3C^+O};PeL5<SNH9B;=!6t_=O<o#z5WLQV8>bgwdUmBpS?aLC8~
ziyDW?V>y%|As=h*@3UR5@+3n-KIVR1exJG!>3uBxObZU>Zgp~3q`VFdWJJiv$^FKq
zd?``-aN;OKLO!mHtb9&h+VVc9+>npg&lgB}wo<CH2SY+Wwr$dQo{ZehkdTjy&rI1Q
z2T%8cf<r#0^=wpEuCfh7LO%LkDVSYGhB747m%}y`G|`uz84~g_Y|XI!syzCA!tEuE
zCFJ9RzT>p-lIne2LrAE|uCppEk$wEgh>(xj7nLs~Bb&U^a$~=56<B;+K^eK4At4`K
zZU)zv@05IENXW;WhuglD*L1hn6ddyL-T1Gq<to=QB;@0eZ{a;<<X47-e2nq>@<2wm
zctgP<A5U)Ykw>2KFouL$y?@S}X=G$FLqa|}mK~-Y1@%6*daDJ8h(*sFG4Z?5VT=g*
zSffCWU2^X43<>Rze}f`?Wn{~DlpFG~t<$}pGBS)IAs?gb{PC6-;ADn`d`xS3_utRS
zE0yZk^p@`_IOOAvS+-A21ZPOd$GAKTCz%M&kdTk#D%AfXSK0Cd1&4f0-jMf{j0|H)
z$ezXHzfDn(z<M8(H6-?B#XCcsi^@aU{G*!N5&M0siuNuI<=pES67tctjr~p;`IR9d
zAGh8teb7YkBnl4s*k@vnK)K3w3<>$@=$*5UjQq-wkdLn;-gPn&{1XL-d~7qT<_Q_O
zjv*l*XT=>c@doVA3<>%8KKFAIKL_acnSw(;2Kg6%uAYeWKCUAq)aijkPra5W{4*m$
z`(yIdwp--Wi`y41H}-r^z}1`^<SIiL67tc0&P@}a?0sWM$j2X#@1;{`=l^YHUnw}`
zW8amBR?1@;%8-zcyABQfBadY=Lqb0G{Py^*dYe%nywx`f4*57>X7l+nay>&rJ~~@1
zcp<MEpBWPJv2d0aaq5igeQf$&3l6pA9<Mz<a_&`(2>G}u;O}=i_dAA!R*mY(olN|o
znadB#4F#|3|24aM)X?|PQig<lOy_#NjXahw7!vYvgV}8pFZZvNOu;c9Evnnd(=(4D
zAs@FMuN@-?f5ecGj~8t-$H-MW{-ofLkHOhCnK%*6WJt)zmFYbmsZFH!@eU!O9y<QM
z?M8VhZGUOGu}9RaZaTe19?B^U3Hi9sYDut+jAKa1$0v1{n|Ohl^=}Fejb-mWCyK~b
zPGCsL$Bb7ZKgh@{3<>!dUG`xwdB&~&P;kh{3V-KZm#ZAbkdTkoqq^D4$a4${`S{Dd
zl8M(h6#q-XAs=1yw(KMCk3$IwO?b&8)xWDm{Wfue5uyEYZg|>cc__`zvi<LwOGoVY
zt%9u=)R22<FhfE<E@<4Pl3ZmBLqa}QIUlrMT`l!vnJ?vq3I9E8>gWhf&sV>+Cfd@Q
zAt4`+C)L|42S3P=kdHA<x_yzSCuhpzooaB%$E)?HevyBo$BQ8$A06j+>@HUs!;p}V
zXV(<#pxUF~AM>O<Z1TV0(CjSoobXYeoj!~R`FNsviOn)HiXox>(fM1NiE3_rr{_pd
zxgj4fgx6{y%hQt~4fse8e-F&RdAJf>d00?i<vxaleC#%Q*m^m5mXx2jP$wLk@uZE(
zCVr^B8$&`qPW7ACLLSRK3<>!-=VZCIa`229DLCX~xdPjc$jB}X3Hi9C>}@9%srPXg
zA)%o>^ej^rm8kEb^qI8W*!y$79z9~>RehZp67sQQ$)@Y%N7Q#PB;;ejjY=kdCOCU$
z3U0th<%9759{#QrZMjrlh<Y+4<m1*Kxp&JqU-mO3<YSS2JqpOTh_Yv);7}7eKhKv_
zZlYcc3Hj(fwOfE(<pG9-e5`V}OLciHb7iIAkdM_iZEdD5M0y|l5E9D0YH7Vqat}o^
zBD6oQo#a?f&YdlrmK%G2PKl(x`DJ7ehJ<`v^6LFL6Tul0^0DR1-r;hU*|Jk`$j2-%
z=CqTMJs1-5v9_0)_MJWb3LMFhkdNWbo|yQAD_hC~z5m<At3!S1StYisJUu-a67n&y
z^LP`V<?drh$j6NSdn>97k>1B_Ikn(Wk=bupKaeN9J0n6qcD-1!wT#@ykkI~EI@#C6
z{hVyMC^zKe;vCgYyu7$OLqa|tE9hwA2eJ1tB;=#ZioVwJSZ2#j!66^d|FD}Re`TZx
zLmKdr4(bz++$y8IMO}GKmR|7)hJ<|F@-cTkIe3md6dY>xT&0@Nk&(R^67n%2?~~24
zk5Pn#h~xZPWR}kbIr3_`vER2cKkmFyEmA)_y%`envGMuVH|3#>Vo1nG-+<gEzQUC&
z9|ebee0qAQiCw%GLqa|}wz6DiA~-`rK7QT$T6+hRetL4{r{D&Bq=WkIb4|v|P1Ktq
zAs>5nE%Z}H9%4wy$KO8v*2`m=w*Uo)?CH2Ba)sLJ`u(w=hQz)cb!^AbY4W)snh~M>
zaY~ntc5?3A1=ZYDvER2cOGuwiMtU<O<m2hi2ad|fXoiG*?AgUGyF8Y83sG>$$ALc*
zuF6$<GbH5W!65-{Wn?r%LO#B0R<47L%v+d(Lp~nsU1X$;?8lIhk6A}|&o58U5r%|(
zJXETKiQl)%Ypw-{cAk8nnthXVdov>BWA?C2^JHW+Lqb(H8`-Oce8$RaLAfCxvy|QK
zFIU-<At4`U_iD62Mjl{D13uD8u;S{oQ<VQwPJ{Z*EN2l44*8hNqqT{rZ2L1L<m17}
z$?<aV!wd=en3&Klvy9A_@?O^eE=jA}Lq1mMv}B(A+eG~t67sR(rCGaF#r6B+NkT$x
z*<-_og6fW|pYX!PwA|QFO6GN1Y9${v1~Vk&<JI}6wCiSll_wYy3O?c75f6EG%!^ZS
z$j9$L7G{#~0*_=!$j7>Gb6!-g%9OW%>w{lsNXW--U*7a7k%CkH^hmoB6ddxgg4w<W
z7AZL8Pmf&2kdTiV*JQg}GzF*p>5<<U67sR??pD2vq~Mf4J+iYU1&4h67T0x*`jMvI
z$7n)AJ!EFLw_EX)0+l~~kvU3gMPkqAOxqT<#4-h^{OOUt3<>#IBmbo<#Zqv}pB|aW
zkdTkNFI{*mzptZCDGCma<$#2$kK~1D8ABTIk*>^^Wf}hO$HkQ;Qy=^-Lqa}g?bxV}
zT%}8C3J&?WA>h&#85zuwkdL=*&sCTAi4P13`FQ_nz6)}djjSj*<YT{w`xeXl<0?Wz
z6F$6ZP)WJS_lyXgSDV%iEFkYZjmv1cvFCH1ywCJqMy_W_$j1=3-bwO-=nq3eJ`T26
z8!IE*m8Ia&^fb)nJW8E#y^mWM67sRv=~<K2HC>PV!;p}V0}qr<Ii{GUJlFL9SB+NX
zC^+P!&8ISZ<lyTW67q543GW=T;$ImO^08*}{!(g{`u(w)wH6$jorZZ=yih;U)X&Zu
zMudDc`_O5vockj~Li^+OcQ0M!32$7Uazj1_e{WMj9ZG%hAcll|y!Yeq6B+r2At4`!
z7ukGK4qmSU1&3xlU(^1PGI9|^LO#yEQ|zG}{0T!sKK83pr>2aoQIUc}KAu?6ro4;{
zWJt)zs8LVzs7Sq!4+sejWr0j-x2i;aTUM#0<;I@RdA0q+Mfp9K0SpQG*zQ*Um-7A?
z&ybLhC#yefEeE%^q2Q2@6+bjG@oa@ZLqa|#<c;bkFPDi73Hg|Is6!k1^?#LYDLB+b
zq4~#|c<OyRLqa|dTXwsiyr|z~NXW;cpWL(`Yt*;8O=SuW`RH1*-9EKSy^nr`gmRyc
zU+g8f<qbxJ_Q&?GKD3vQZ58aa+}QIu^-IO2m61~z67uo)@L)F+!5I?rv39}NCho6R
zu&3aVkI^d*gqjG>kdTi9DtzfHU!mM!NXW-M(S`r2ZTbH?-GPEbec3p}*@kkJehdlu
zc<6ZKYPrfphJ<_!x>fh0x?Jjgw5_5Ahl*UjDEO3|dkP~$K7J`58YcHp0z*RkV`9d&
z0W#9Yk#a*m&Mdad#J9z#F(l;U+nrG+zWABQkdTkPVu~i12ws(fLq0yP;{HTNPGd;O
zM~AQy-ZC<gAt4{<{u=8iFPD|8QE;f${ioe{AS0(SB;?~$Kc{e2alMZTgoKDIYhFJl
z4`s#bT5jz5oUu1PS;)w#3<>#|RP}sgc_<SY67n(Gt+$notXPABLq1L)vi6W1d@@5q
zK3WX%`Xztx8qbiBk5Q3FO3780sY$^hAMeaa?<Ftl;~5h2ak<mUUNZ6;Lqa}Ae@@>`
z4qm<%1&8eEle6D4*~iHm(#XXgec=4ex5FOg1DVvHcU)&gXn&kicXKm2cU31fcQx$!
zobnyLX2`!GI)@=4AARrtcr5$)f*~Ovi^MJXBnPiun}S0=hBn>YL#}cWLqa~5t}@fa
zS>qW)LOyP-o-v(VW$ii?9P%+K>}CdeEEg~&<fE_k91|y^XABAXxFCGNPWilA+gS?^
z?L0nTql?Jv&^$(jd>sGb!Ekla&|ghFWk{&XMJ=x!l&h>&mvTcsI;~t_FHiVFhJ<{~
z*W;|G+?LN767sP~ac^fC=~Rz`Lq0a%xzofY>3oKSd^}b9mx&AKrwj@CxM#^M6R#X_
zs!zcoA8n>i7$(p7e1?R4bSyBioZ9O8^XgMVLTx!=#bgtonbl1BgyFyElB!|P=d_>m
zpreW03<>$@c4wQdjC{(FQ1BIxs$7;&f=&%6IOJo8O35DbsxgNlAs<U7RWk9g=_7`O
zd>sAAJ)1n1H5yWI$j3Xi7Y~<%&tpi)$Eh&|Hp$4R3<>$@8F%sDZ-prW>Gz4+jVL(e
z<KEyJ`DGs$5)$g6gq@>4n8?kD(EhmIz4$Wu>8aX{wcOb6Te&RCVd9b4)eH&wI4pM1
zSvmM8hJ?oQi2J&c@*_WPO(;0z<LMUVOnez5lp!G>_dOZsrk=6%ZTX!cAs;th?ATRp
zOFgn#Qwk3Gn622IT{3bVLqa}&KYqNS9Q+GI8t{>>_Od%S|M$ffW!ClkV^dcxI5gqD
zlhc^^CGa(j2>Ez#=j{6OP<~=aXn(v_aM2t2Gqa{{lpFHVDtOoc*~fJZ3Hdl;e#6=_
z@*6`!(_<OGC%=qr*^GiiK926%sieF=hBGAOW9jO*OuXpwCqqI$-tBzQU6!X+a|#am
zIJ;2h?{e@^hBV+KJ<d3^^La;gdh|a2AS5(9S%0J*E8i(`Z=vPJzQWZYa?2gr$88J=
z`S`wXNfW<RlcptA3Hi8SV!HbBgm+*_$j4<Fe%Z*uH!~#UW3Bknu`==xLqapYeEW^G
zGP12ZjV0vc%|^dg$jjv>hJ<{q{pHqXd3wxRQI(L7HRt*EkgIIVkdTiP{0}&*itByc
zN=RrZzu9cKE6<KuYc02tTeh@lbop&#CnMW4B;@0;YrQtgv$KUEAs<Vv{ZL7+@;5_5
zKF)I=e^f@cX+vWP`52sZ;gxbcQvUQO!Ho<F`54mr)KK|UowhAi2{qBh!@YLMRd!)W
z$j2GCKSs%8xt}2+AJ6}48Yv^QwWHvWkIgJY>!^zBee@zEl)HU{F)s3Z^&%M&I<F2m
z5p`MKatpTCa%0cuI1Ox=UH-lD;S34+7}WOkbNMmOBMb@oSfO6kbuuz{2MP}P7`=Vt
zD)}p1JsA@6F>9|J4P+l<84~hwN%LO6)ont*YM6JV;80&i&w5i!uF{7gAs^pZ9c`{2
zF7;KOVMqf$()DBFj|}@1Wa{h35*}J`sK|MXlfKBm|2UEnAs;WF8`w*}M}L_iq5bh*
z+V=MHSJz5+qTG;=&*}`bm$zJhhJ<`P=MWSokL68<gnaB%XLqdZqeEv3Zoo(Cp)B?t
z2dX`!Z_5P?3HkWxZ}c+d8=9%VrTLs8As;Q0VwcJLM3XKQ9BTECE+Hmfg|UGl4fse$
z!7Z*i7pV)8et%3RBt$F~9+h%eP5P>gyQh}h$n!Zg;jeyF>7<+sl#N_J;UNqO`M6+z
zGc&o$uM7$KI5{|tiJhluR|*dKc;4UkwR(Ed2j9SukdHwY^E;^%u1Ef1NCQ4n5B;{<
zI!fMo+I6GgkdF(eUvDJuJlh!(^07>KpU?8zmcBbx3Hi8X{8|&=@94&m2JE3$AJF~Y
zzo%?d?~l7RWOZmWd*y4fQvT*dW-m2&b?o=8{LK4U$U9GOhJ<`<nRU-+xzi&V67tdI
zfYmqoQ<+>nC^+Qf*VsSx<u!dMLqb0GyX(D1-gz!FB;;cm*M-;REw^${3J&?0W20A;
zT;*JbgnZohHA6*t#@{j|<l~Z0?a#{Rwnn`uxB(w&ZOcFDehGCU((jMKgoHZ%RIXB+
zWFOx%BBXfbUb{2Oo!+dsmK*zht3s>CT#`F|8$&`qj?d&};`>(F`cRdSk4^<woRB-c
zJ3~S~HuShYP~IO8GbH5W<^7wt%C|N0c~fx6NB6+@>128OF(l;UQ`b{v)K1qQ3}P7)
z^3kkl$J+8(7V1mEAs<f-Kea|h>U|tcNT@9n4;?A0_^$lvb01?w$j8nHs+)NGU%q}?
zZU<=9_|QD^hMHSn<p73+f=^5D^iWnjmLU!JNT-+5Q^uuJ&REL-(N|fbKLv+;EcE)M
zt9-Z|%aD+dHEx|AC*N+n#*mPY`GXxZ$cM|y11LD;<K#|mp0ba#7!vaF_?U24`K2!p
z7!vX^I<S#erQXMe1GV4=dWd%1g$@%h%14bAjA+0|YRh}G<{wvbTc&EuWQK%%OxLUB
zX?eoC4WitTkHzx8xhW$LFeEgV^YiChE1xy;4yGz0A9DrO+a@E2FeK#Ty<E9%W#l=A
zgnV?^^Kr0@EIWjP8}N~uD6rM+^2)ocQok|Dk0Bu+18NWYDz9x%84~jGVHLkPb)V4t
z=<K5fhbFw@@+K9PQAoX}FJ?poK9b_W%`Ux^bH8Iq$j8RM8OO--G#N^{As-VLAL}Rg
zPzXapK7NV*(@aMGW=LpyT8+zQV&~~JjDkZxJ`U-;M;^;P3<>$zWO2VRId~3Vs?vau
z)I_y5cC02N`!giu<H3sQGswu33<>$T*1F|w^`NfzvE*<qI5ayQmOpJQ7deIzAs?Un
zYzvfqjAKa1$FwtUM$4;)%?Qd3`S_!7&c$+-GZ_-{aYvcRZE}?l84~i*cJq_9GP3qa
z3J%Tq$G#yS<>1R167un{^WI`|l^+-q^0CGBOI77nquD454*3|i<aq_T)x#OmfR9Sl
z%w_|896Ro^a{r~As+IB7`<Q05RwXo)GY{R)A{W__5g{MD+&<n^9?Cro3Heya_3<A0
zRGniC<u>3W4du0&lj4-%$_*I(#ol0sG~gp4o4bb=P^wJ*g3q%I3Hj(%vF{OiddiQb
z;E<1At4?f|?>hN2q=6=);6tzFE-MFr%#e_e^M0;Mr~CuTpMH88jHBR?j|&2wi^|9~
z3~9he+QpB>9XTMMSAP%^$~~dl%Wm@3earD$ZtNqJGPNqFk$Y$>Lqa}Ic{%)?jLbBF
zsx;su4Q2WRSN!C*?8T4<d?e(%O`c=r2|vn^kdGhk|M8ZQMJG~l$Vc0i&zs9*Ihr92
z_(;Lqx4-g3UV*POB-ED;y55~GBW)&8aLC7O-J0c)g9k7q<fD1RSzYAw>SIDeMLvJD
zrKMbCt;t&M8qoge6=9Q6J`gQqNXW<B4TBoXv-6%IAs_cGKQUKEx=x|skdJ1M-cFE%
zhccuA9~A@tI}k<u?CPjYPwHL#7egBGk&wIG>w7A1gD8_~=kb_I!43FG$dXMPZ&fNx
z{gR2p3<>#II`^3_^3Bj9epDsY>cx+4+$p#EWQK%%^miz%{dAQ6yn36E5HYCE{i|}3
zm8WUBjXa-2tL58+Wzxwz&m4w?eDrwqJDa>syktno$Ger550Qg6oKC?ZAIJPXA1));
zF{A+>X)J3*)EOoR|HY67d?e(W6<0ju4|+QKQ*Z-567t!!IR)k5`xz4Q@zmr@+2rLi
z?+mIE^6^TeghBFhIfx-4dyWP*(!Qms_wl5L#5S{jIToAPCd>oW+%>T0bIeC>b(Vb`
z&XACg2?a;|mD}<vLqa|VIrYvb_fVyo6x@K1v`zH7+xV4o_D{W;&16W($H+!|{pH|K
z84~jGop;I3^0j!qSri=dah6TPIJwGo3<>$Tyz{g3GV&)w8t{>($Iq<rBxS~xDbin(
zc9>1UAs-(W%pRydTcP)HHzA=;{}LA4PHxMLbF?Duq4TPL)fH!CAA2$+ROQP_(@lJ#
zCzc@%_(-!e(qr8`rAnnW^|MnXkb)cVk+z8gMJ!FcwRtQ<LO$-uXR}0}o_L0YeEhTC
zf3WPM{agwT`RI}*TSIxq7cwN|W7x2Q-Q`{UJwrl14vG!mr<|x$|Bz72c@!M-F+95U
zO4-Lfgf!5W)I-f98<}`>Tc-J1k=Xll7UizzB==BnhJ<|Fb!E>h^*)wfo>+!75S)B`
zP<DG&rOMPdLkljT;E<2^_O4zkce*b_LO%B0R%d|x#g=Of3Hf;WOOGV^aYo056ddv~
z!aU}H?Bh~~gnaaz6I)%m!cBdZ`-ve9_(-k3sQALYijS$Ua=S00;E<0U&jkHd`%=F@
zo**RDLvBAyf0wVD%@=D$V!v<Ib6Z#?xh*F$B;;dnyAMO<)$%Sw8t{>3=b~%jFY@fv
zUP8g4u`G9OL~r>5C4?a%A16P~_)MK}{X&$?kdTiy*3M~UA6qS@;0Ao8we3%DhvJHl
z3RYib1VchT+F9q^Adh9PWmF~PV{!kpK1$8XpT5d|3<>#oCPRyt>Q%1Z$K!;ACj81P
zi)(W3qRX}1j?j5^T*%#qa_*4~3HjK_DeEQqQ<*Ca3HdlC_n}-e(k6(4Lq5io*jrvk
z&Spqxdba;@PgEyd-$TzC67q4)IF~4Sdg=#La05Ql+BUS{>ZfuOtzt;XN1MqzGs?lg
zFeK#TrcO&*sUJ@0$I^WT1&4gRwQ$}G^(kAuj~fXI%}(!bzq-k@^P3SNAA`1*{Upzh
z$4V`CRmjKmL+lpHvlGFPkdIFu?mH|8&$f!HgnWEesq7c|H$=S|67sS8@!V(SgTYyb
zG%({z)c-z0IsUiiL*<~J`nHDkY6=edXgBs!l)Mm4XGqA$F}}|tWaLAJgnTTr_uW>x
ziJaF^a05QlSk4Kb`ci&ACy0>HP;Ncls<+&h?-&vCG4#OSj55-7t(LnQ<m2vr8F$IE
z6ULB`kL$dH%F9)zSw~euKDK)~cZhuU_hd-O#}-kU^2$}lGNb_?X)~MHV!>JYa-v8G
z1&5mGc7@v=<RkEShJ<`9W7)R79Q+PLLOw=!t2RJxqU!4@xB(w&EDJc)d#P@@`u%YU
zA)(v{ojaQN{^M&#gnT@7>`5g#cau;pH}?LV<!^7AI9!G?qyZn5DgJMpC|TF+iqb==
z@8_fmqbd#fNXSFie~(szE0<FG15r<ggnYd8;rU~^En^rG@-cSNy?<3ImFlas2&dqX
zk9Lh(&y=ei&5%%E7WtOus(diG#*hYlr0IEa=+6&%dh9n)aLC8IJLm6_&#UtYX`o0l
zJZ^KXf4|?6x-FkDBIM&ir<y0_`>TyNYPoAb`{Vbp!uRDP@Op+c;3EZ34lH9U_s~y<
zG~gp4U(H>0Lhhjsn<zNsW5f8mqtqMfdU^ISB;;e`FAkaI;8{0Qm5`6MdzNS=Z@GOK
z(twX7kHgGrk%~OZc<O_nWJm+8PRK^rR{m0Osaw6&777mexXIVdTJ1~y{y3G85Ych=
z$|(7UdLknl@R4$Vds6eQyz@A1)pFN_d>pcKXrO!&T*Z(Ee55L)+C`O+t2En2RYE=<
zh`!KKuCfP1LOup}J^rv%N)IW2|F10>67umzi3ltC!wK8%6ddxgdZq%+<qPLPhBV+K
zt!>wR-PX!gzGp}SJ`!?N{SFrLsk+4u3J%$mW9jZ^^8UC(Lt+oNwN0*2N}llaJJlj<
zV$bJn>i0gItoUGtgnWE|CG3>4TBbf@U1mrFKGN*ev^}s@Uehb>qTrB^&R3U3nP^Lf
zgnWE;xcfvo_<M$gd@NJuMLK!aXdXeqAs=7#_*O_h80=z5$j78My{E|2lWR9s3Hcb7
z<LnzbxDP`@J|5Y(;<)VNbwWa&KIQb{?ea~h@_V%0*z-Bw0VN*G$Y~5|pi0`z4wZiK
zUOsBvWk|@!VH5k5l&h@0mx4n+mKZ(G#8;e`F(l-pPuA1Ua+OI83HjJ}WIs<C*?b=b
zhkWeWpi#1Xg|dMmAs-)IE_hZ(rrl3fLO$jk{%y95?8cA=e5Ag7dm>+)e1G*IA)&TB
z<8FIIJpt<vM7bli+}QIuWwvcus+6q!>5=^z(twY&ncb)n7$R4Bf+3;cvvQp@@nmSR
z0~8$cG0U`N`{m$c7!vaFUX#+t<>1#D67ta_XlW+7%1Tib9P-g|kj)xd@c@Q|e0<vW
z#C%zvhYSh%*e<C;cKHZg=O6_);3M_r&}n-^<@>8E2?_O3g(CB(%0rpNhz717smM~j
zEluo?%@1k0vER1}>ie^pJUbg067q3j%&_)y@U+oXB{Y`v&s=wtk)8|*`Pgwn8!tKd
zeujj642YayEmxWMFa?Kv%-FZJi7yEaVo1ox8L!hml7pXNNXW+l9Uq6tNUI|h9P%-0
z&dMP9ygG%D(1dR)`tF3h0N-Fl$jAKyo8Oj^m1DHrj?n%%Y*y9<@|r%AAt4_>X6O_u
zBOfy)<YV27Pp`|J?i@?Oq3H=~_wb_JLqQA)`B?H`lM8Z{pBWPJaqsxM@8l|59;M)r
zkL6Fk*dbTBg&`pypL*TvE?1fU7*z@Rcq!ka0&1)4@2`3h(!lH}jriZka4X|p)>ev4
z{h8STMl|3fArJgGlTo=8PkmoG|8Xrh_I!@#>mHrtp&Y@GkdK?2oB7J8mn#ej`RMj|
zkd<7e?FkBQz(*R(Q=fBOQIM%`WX)zs12ay?7xU!u&*UnfF(l+;bor4sGScNF1vlU$
z1%KGY`rlhAQ}^W>hJ<{4usGth@((C~`s=8l3<>!dczxba_3>i8j~z~F!J(mS(D-*p
z`3BxrMl|3fO?c&FJ}uQnL!UeIX(|%hA1@yKWa3o|Js1-5@${_s1LXzyFhfE<CVa1J
zV#_UbhJqXLk;ZcJr%?;!Dt#Fe^3l%Te}XK}1%`y0Xi33g1>_sc)@La=<YUq4<vJ@>
zre4(NFeK!o^?rwp@(TQ%At4{@e%f$P_Oa19Ex3W)G~t;aS+0>6jTMXt`PeVw!4nzz
zg&`py!+s~4c>7<g^OPI%@!;(7<>j{A#*mPY9TIczlY?izKvhCMmi}60jod@M7!vYv
zetXY<U;IqH^BiSJ$j63tFS^KMS>hrEhx)SG>?@b$u^i8kkdF!FR(_VZo*N7a`8a8b
zV}JR6PL)eqaHz;o*Krf&37^e~kdH(Atc;XDI(os727FZJ<G)jNpjr7QmMQ;LGUZRd
z<u<)cxgj4b^gRAj{&aXJLqa}UI~MIKe+-xV3RMaDSUGF4j55-PAt4{#;#SO%x7<q%
z3Hg}sck%vm6IoxS;E<1bb`LEpS2=?rp;q79qtaU$`G6q}_(**@C40e|%KoU_)6t(-
zYhBZV8z9pDxW0c$69=OCj0pL-w%SrF`Mmm)Ar1IQRa)dbVB&D;a-DKRK0bU^!Nkjp
zS1}~yW2^GDZ^&)=ogpC~!+!SsEblxW;wU)eV;XDcx-xP%Lqa}AP3q(%Z)Q2;sY=Ml
zgsdBf%VXJ}At4{jZ@6|^4t|;;A$w|E+~_Z#S4-dcU+^kM9;P9~+kY9kMcKra?E0N&
z3?o85w&}m|jXad`3<>#ow)d$$@=#Vupxls;&l~m6E%(rThJ<|l;cz~ejC{qAkdKFl
zW;gNhccYsW9P)8k@$OCKv0TrPkdM=Em(3|7|1c!vWBcAUipfpXIgx@xK4$i<c||_A
z9bibv$F2?bZIaKcg>Pw9LY>~*++mzNls=3I`8aOKf<7|xJVQcNMtvOaAs;o$-KN}-
zk2|h3z9UyTl_4P?<I;RtudbH*we2oLLO$L+Jk(r%#;eL53J&@BZT98N^39j!3<>$T
zdUMHL@~JwRAr1IQ`$W-n<BrKU={wz};E<1pW~^#0k7X1?LO#Cuw&IF9<NEVzv3pvT
zP+LA~J!_n0%HF8_>3hhR5g{Lc4YY7k7Y#i!ks%=;6Py;*l&iGAPr0Gs``+bUrM%fF
z_1let7!vZa>g?PmerWFxLqa~@G5dX^Y)X~NpMEU6KcL`{kCVGJe<xo~TwqAZ$J|G(
zuF404G7qUr13uCfO1u1HPszwB3<>$THrQi@9Q-yzLOym$*!@NJ(eaTM9O@xEyTNbe
z+_M<bfRD7a<z75zvhrWb?xXLaCk$!8M?&uOwo9ihz{-lLN7j8zxgj58_JlQ(x7;-h
z3615Lmp)bH8+hLt(twW?+|6yvzgN~NSbgyJPbjzn9|^g+MVY?J)TBm6FeKz-hIeiz
zPSrV{Qk9sGUtCRmgJ1wdLOu@Yljngl49cH=EKf5e<YVD48``N`kA8nF^-K$HV8Uq~
z@;DV&TP|`eBO36Lke2t>&ykUF3~9heLZ&T!zq{P&m7h~?$j2c=N||`Me;`9bK8F7~
zd`k}goFSp<>71wkWcgI>@`8dxK1SYYdQ~~Eral;~VMqf$DpCKt{oVEag;BENX<ky5
zkdL8eGl$DZ;I0e_`RI}~yNP^B8qJUfe5Bw{4?h~N?2oDMuUfp)f*Y6}>hy+5drbV`
zrw=1SKHB@`EHCdoXBZOlF(PMI3mIAJHRXnUbe*{<myDdikOq9D*%`m-t%<h0!H|%T
z;~Up8@g$nV8ww81c+2I<Z{)RY9zz=Nk(%g0p9zcPv3$*tkdMK)9X#ZPsL@*rZoo&H
zo~F%v{#z~;tbTtCVMqf$QgF|gdv?g@)n9~!hH`o<i?{OZw0@`Mt_Jy7I^!f0zX7v@
zAt4{FV|{GoDzm(&Dh>EZvy(J`z*+^F`o^+1LmKdrX6Ih?CKu%&Q2z82ew-m8A6rFa
zUo5|sviJuIZoo$he%vLSyS$lAV@RlpoF_$BlY`%9NXSRaEX7T{-l*0`3U0thnx1C2
z{*;rOXemQNK01{uw^Tl_CK1v=ZknBq-X(g=v*Vhi<;H&BYR1pHrR1e8oFO3}BNI9=
zmoLTBe4;81_(-$UbV&v$`CHSS84~jGaq>++`Q;kX3<>!->FtFm`Pi1{GX*!`BL(kV
zXZd0I{_0SMgnX=4F#A%u)2}n6fxe_F(+@c?(lTXTQ~va8o81=*Zoo%s^~Vbu&z9c^
zv78|xA1%zve#@Rx;eUV1M46eTN%;$#`kjylilp3UM;=I$57lm8wcOZGf_RQDzev8X
zyon(p9|!NbJw)!I?BA$L$jAK?7jKZC&+%bM$j247cSp-(d4(Y%A3r=<<RAyP{Z7Fl
zAOEb{ogmAzkRc%-S5#}?TOP}I3<>!-;N|OZ8R`Cmf<vty{%Z2SpFmf}Q?K|ghJ<{4
z-fhq&#U<rWe?KQ*vQ{NT98~i|Gx<Q&ixHvoYQ1bh7v!Di3`0Ub`mT3u<B*bB`O^<&
zg`bog^07^&;e9iv;FLc-GL#_=_(%(I=W5r7Dp&T(2}Y0nz>o%fBxJ?Rjs=x1SGh>h
zBb)r9;E<2S7i9e_E53>$As@$X=$0TK4E{2t0Us%Nw>Jx`%a;@Fep7G*J`!^2whvX6
zLzZ%-s~^h<hJ@_dAL{yC-XF96QLDsWuHm_CaftlTf+r&y@R4%wbB!CJAeH4!pF5f%
z4fsgNzjjZ@$e#`u{Y$wa9~+$-{y@G5F@Yf=A3gIOt*_La`i8*`hBV+K9bbGiUj9}(
z1*!b$$I?D!LH6!Hs89DQ_I3t*q_J!n73(Q0zLFsg_(;g`h28<m3ap%p^i_UfNCQ4n
z@M3;$zhuSRq@myjd?aL=Z|6+>$o58tgnX=4*&<H%F;iNtN~qI&7l=P2uS1;}5%O`w
zoU~Kq4-5A*Bvj?v2Hi&~OPkUH`Ux+Pj&d9Dk$R}9^^m!iDY(>+s1IRC13uD(`)%s+
zSw3sTGbH3=lkE$glz%|^(+97Wo`M_jk*a*tKCGVFLwe*KhBV+KAqORX8!jX7F(l-p
z`!(lIa&Y?$6ddw#K)C<z9RJ4g|Bs~~Lqa~jFL`{MTBZKHdV`P#+LDIyv}f~d>K!8e
z?3B%@<;LEhQ{uQ~b@e3%dgLUAG~gpu`MmRE6JL&sXGkdcgf0hq$W_{BqTrB^;Z?gW
zmyt6W67q3Py=`k{<b8&OeC%p-XO(=rty*RZ4*7UJ%@b?&w!ePH7cnH{WBuoyy2{s&
zFBlT?@lHsdPx9rxYZeL)`PkRdypOsN>3!TtNT`RlRqnM>9?Bn#XkdRNd7M4&x0jLb
zS+(5Q`*Wr`bRU>4Woc9X^b;P=kdTk%j=2_<7ou+r36166VB2%bF0TCPt8~vs!66@i
zM>I<#kL4zYgnabs^?s6!{KJrtkH4258ZGZU?XpvF$j3BCvU|ugzKJ0rA0Jh@HC3LT
zWQK%%e15>KgY0A599nQ_!bfC1I7ObFa7KiD%#c*@n2h|%kkJ14=G4Q%@=&(UNx2~(
zBl>LilzrU7kdTj^zxltGFG<tpqAH>3+34Byo!sf33<>$zIr_*bxzl$sB;@0pT2&5Z
zNm+!HKm9_KHa7)_e5_ya<ShAM(1sx)AA^THdL;MdW`=}(%$9y@0oljDgoI|trT(KH
z@`Sg}qYY(M$j3IBcbIrPZa70iK0bfD;-x&4>GM*RkdIqOwf}cpL%C_7@1f2N3Hf-v
zvin)Nhjua~<l{>Jn&C1sV?GKF&3LK4Ut;7tC0!X3@^RYbBd&6lyBQMlv2uy3VKOpH
zehLoxSZ+?t9U1AxkdTkPve(qsHvM@ul913)4%n9Qnp|Y&6!ZUg0}p#X=gH0lFZuJ1
z?hFa}=-J}XI(dIQ%8&+pr29F))5oM$E>Ke66SOEu!43FG$c7OiS(V@OEtg91@eB$1
z7(B1FxqPwroFO3}Pgcu#PQHw4P>6y<O_V>RLsJ<U!jO=U1A3Kcql~Qbr(Z7rG9={V
zs-y-^@&~V-3sZ2&$Ht$VWl#?W|IbH4Lb*reKiopjozYw?5_>+!u63n~a_$}s3Hi9|
z?&QKU@(4p3@R6=^Ck)J6Sq@&rf`S|Hk&r#yDzA{M9L123k9XFZZ;*Yw&XACgiz5>1
z$nsP!Lct*)>*hURBO~WBB-EENYhM5R$z=tr_whADLOz~bp8vKymaau9IOOByogKW@
zv%lWQa6&>wzVm;vQy$8%j0l}q$2M;?SkB$9n3fy+eXG7s&wXX&E{24B49T1Kp&UGW
zajFvX(Whb4+;Wuz7!vaFLzX<P<SI`wB;;e!eIN44NUIVQ9P%-%-F<6$ZS!MD$j5z;
z?`)ITwz~`owR+JS*G&ARWGzby4*BR_IzxNe$EAdXh)uif$|2`|#)y!Qr)IUtCO=}(
zprn=?`+chf=c}*fP7h^B$j5j4lP1e;`IjLfAJ4iDH}SHYuB9kA<m0j6OP+F-Q49(B
zc(mG`W%5`SDos^FKIY50=AK;TaE63@tdPa`wT!&VkdTi)g=@8wk(I3|IAl-DIZyh^
z=he9y68o_5+<9*kzw32}5g{KtUG(TLD_*ONn%lt+I<Gc4m^?~GE@w!{$KFv%=JM=(
zW=I1*DjUOpUjwYV^VD(qL5MbGDLCY#Z^Yl;a+MJb3Hf;Wz~yqXkGaZGm5`5f-*sCr
z?~el+67q3i&`1+Mfqsf1As-h9|1$9l^`)&TIOJpT8W~f*!~NgqaQgG=Btk-+K6`UO
zkUTq=84>dF?cp^y<=LrNUdwF{RXH`Yd%Rrb42Fb!d|Rb)sQiKRBZf5KBV9jc?^1W9
zEKh?96ddx=KmV&ltCR^>{`8koAq)xm7!iHePF~xxSEMQ-A8$8!>@I%`r9VSLK6ZB*
z7b%bB8HR*>tY7u!CK*|_5(S5RT(h@*%A3k0AEy%%YD-tQ(I)P;#WN!0WAehX6Xe`g
zY_!}CkdIHEP46Wm7cwLi{91`~(`Dp)hJ<{4AMm4y-03ZBDLCZg@|=E7a+O;c67tdE
z?!6B(GIM3B67q3=T+JSGaBqf$e7qMJx=()U{WwEHJ|+$R=qlg$FKb7^As-)D1*Lq>
zD1F~*CLy67I_ME$CogTc7!mUEz>}{t<=i#xwcObAIUa7`*2qtWu4G69KGNZGcIcmW
z^5-394pb#HmX`~>-6Vg}tOr9vK5h$H(?FKzBtt?zjx5!0g^Vm+g@Qvq*0BgXBcF(-
zG9=_<(u2UZ@`>mULqa~zn!NIv9K41j1&4fG?`}0rIUgy1`t#~CLP8VnHGJrMd1-sb
zh>(xPB8%LS6>m^g%Z>fM)#!6JbLF92&yWUuq{C%F>%%YP;AYjRO325=15w%JD!Vcy
zG(D#;7s)Rp4>2U<WA}zfO`NLDt5a~uN9U&XPRL_9njs+{)0e6kF9(lfNXSRm&B@>8
z`-~1XC^+O}^MG$D9!mS;B0@s56Eh<|jhy=lBO36LcAkvRX8Yya8ZI@p+}Q71)f-eQ
zM4s>vhJ<|V5P9>GylVVmNXW;enpLCavFuulf<r#${aNyij6B4U(2P&E4M~vO(%gxv
zgnVqBwuy;fsT|9YkdLqDS6(ka&KS>-kdGVgWGyR?rA=)L4*7T?TUg3&E%`WykkC*b
zs@vAY)x=#!G~grcJS%n_d?<IiQyndLH3Qd=r1+@O`Hm?^V9S(0{cVjE3<>%8Xz8pV
z<-1m?zi;)6At4_}#rU?9Pu0DhDLCX~nG1(c%Xgj5G9=_<@u;zT<SHxFr7EE&>i%TW
zTV-mLKmGK~XGqA$>wby#<k#bVWk|@!<Bdk0l#jrk^(Z*x;}*L)`Q-EJ0YXB#FV5>)
zNnSKE*Vl@~p3fOt^>=^SM{kBS;3Fx1Y){Va^40xGhJ<{q`goeHe9dF+Lct*)&&|yg
zD<h{dB;=!2^okwwHgS(34fsfFo5wzv^veF2`n46+8c=Y^$8O%IM#wY1j3J@EY<#Or
zHF>%G!jO=U$*23CkejG$LkbT0xH|VnKY4$QB_vd&>y%Cb@=)e&q!o$1Kj*Oh)=_fq
zVGIfRcz5)~v~s7%F(l;UTek)M<Rft9#uOa#vCh8!qvR?B84~hw){yB9<SL&tqyZmk
zZOdVsr=C3H4VzGK13r@C`R#{KQmRxIcK!Ys%8-zcb&p(XE>~&Rl&XYUeQCA&rRC}A
z&XACg#a4ZekbOKzNQmekUEaj!uGw9++%=)|Y7zVUXXJB1e};s7yy>ywk35to84~g_
z?b_W%<xaPBqu`K_*E2s_BO@m=qyZnP)0f_}ZmVo&sh@hk#gLGXMdI>xmOH&xGYW3N
zM^e1?g*}_);K2+D`RG#RXQI5Qe`QF>$8C=<m6R`>J2j`^kUf*E9PY?IMrp_@2IQd$
z_f6_PPCmV4YoQit=qIyicG@`)H<zz@1~Me%W9cX-H+d*8FeKz-@||>P<sPckl7d4%
z7R>bL-!B>{mFl;NSqy2wM;goQjegIPt9;3jkdL3u+pUw4jom4@0UxP}J~y*@qU?=|
z=KA2F3~9heLLPoJcA(Nk%3T9JGEFP067sR{qxvRZ1l^M%As;iX8go#YEagxCc}EN(
zp-#W?dguySo?NZ9+}JC!0xa7H$rC=5A)zY2$2<y^*Yt}F3HeyvvrJxD@k(tdxB(xj
zhkSC)Ev;0U`pPVjAt4_>m{(dLU*5lFNXW+mKL?IiYF7UAo$lI}f*bIWR*e=fOFGLl
z9>$Ocd?aM&mlf*D!PB&(Dj^>qpX}fvf3>hXLqa}Y3+Q@5-XHf95^Bo^Q}=(6hca_}
zEjRW^Y~wPQOgxa)han*!tuj3rE6>g`hJ=EL?&x48pQ<f8P;di2QV%6=xi(x@d;&v4
zK86jbl14_}VMxfwg|CvI%E;OsDLCX~=IMzho|jw2kOq8YYg=-&FUq=>`k?-kAr1IQ
z$ny_6wN|#<)XQZz4+;+X*d|-fzp{_9goJu%%d@mK<!4IrcG8M8as;Nf{IeqQq&(rH
z7!vYvK`xKa@*_Vt7!vX^zQDS>GO|Wz3J#5B&t-?s%E%QA3Hg}!NzY#L`yPKWB;?~&
z_jcLkPZGSlP;kh{^VQc~ly8P!U`PW#QWM=fFyW&-mX4lOr2!uaIkvX#P0JJ?l|TK#
zU>QR~KIVFya8vmQlt2A>^*136OgJqXH_jDsP;#eUG+K1kayuHhB&FPw2kmv1Kj7NQ
zkdTi{k2dUXnNp?lryt7v-Ka{)$F>%C9?MmZXGq9Luk%aS$!Gru3~69`Xe_;aDhJBT
zW&Q3H9P)9sd(1NVtP#$T27II@I`P)Jys`o-jijHRbY4^?<m0R{`<tat!6|=wWG{w<
zd|X}JBjtA<rI(`ZU`WWvbh&e+T*fOd{(m3MdT7B7%nl8uW!Q?m%As2MkV~Jt4I@H6
zR?e|ygPeOaLqa~5b#VP4Z@E7i(twW?JorexAVr?k3sIMzG?b8!@e3Pmm*4Ue&5)3f
zds|iBF2ATGZ!fCSz>JgP)rY&akT0VKGNb_?30Wh<u!8bSn2s?d<fB!GV)fNd*Y{<?
z-V_}2@#nI#W#omZKSM%3PFvM&qFSYXe>_b{Xeh1UZmFX*sq&}Kt-M+CzxU@<G4lQ#
z>U8&XPDf?MM=&JhW8EeNkH|irXGjA+QV;E@=o%tlKUVan;E<0Q=N|ehw`BlBLOzyz
zQMSIkw%uk($j7BW<1)%fo4ynrYNBN=Dt(l1w@qe9$Vaz1Yj4WabB`e*A0PJZ*<L=V
z*Xl>XAs>A#V^SWIlJ>`SgoJV@p5B~AUel8p5!xTW{O<QqUelZQ*K${fe000+(NJE~
zLl_eB@zT5U$@0q?zcVD{W7oa@p0bZ^22gOw$1wY@mU5LF7!vYv(1;7~<ZZ%iAXN$Z
zSkE_0N;UtrrG8QG#*k27mb5AFDX+j03~9he+9$qL8{(z}SFrjj^9-WkkdJP~HfTp+
z{r>1fNCQREHnH;kDtkG1EF(fb9vPLPmi&yD<zOv0_Wqn+wcVrTP9MXN27IL1$-L`u
z7iHB@x?Mjz7Z?)q@z&ve_R8@$^%1zt5DE_Y_-*{L*7EJ|nG6Z}Xuj@R6M1@`G9=_<
zo7Q8t$=Bj_d?+~NW0t%YgXQ}<>lqSi^*;A!mX{9(>4#F4kdI|I&Y3K~ucHGYA!1Uk
zrmf_iC!7%>A7dU2{~%BJFNTEn#|*ohY>}&MH%uGKng)ENh3Lxa8PDW{!B&QZd|VaM
zxT^9GD1Umz)A&-AkdJ*9PR%dh)@Z|!kdHn3H|{2{ZL1j)^3i?I=X7%Lj|>U<c&~G<
z333y;45zV#e606tNsNqK!H|$W&yJi;`Q26N{QyZC61y4N;YbE6xyS}1)ZC7CkdM!D
z)O3@PD;W~<(RY*09{B?06GK8iM&_FLSl)TsjHKX@kKHr8+A9a&$&iqbFRW(Nl2?sP
zqo_*AM~Bcm-m;Hf84~ib)u;L^<tif>67n(7v&+Am5Xvg7U)wT`rr?l|3C;V@l7n|+
zNXSQThZV<UA9oWH>U6Jc8&1eq6Y0iixv}SSqR*P8lV_&~Lqb(roF8Z6ZPk$s3HdnF
zJStEfO8tcA9819=AIt8KOfUQB#gLGXPVL`alaU7)67uos1nWC;@Z94lIOOBT{n@SL
zI|e-&67n&A{^2Qd@Iwp<`M736Ku#H%Z#)Hue6+o3RZKpw4kRShmK*c6xh)rYkP)H%
zG3N96((=(i?*uJ3_Wqn{2?O%T=hYDm2?d|is!Tt1DD^&`XGqA$(nb7=$qP}Dl)K{p
z-K%zVfPB2@^u$9(4r55j$9q|B#mPRNW=P1#J%gG}myza^C^+O}zZ^Cf<lqAt67sQh
zI{(b_)^n60As?%k4<4=t*Wb@6F<A=^_0W_1OWMmz+fYV?d|W<w)KvKgBF-`-v_D=+
zs_;NY7N0`7As+);PFyJ~KAa(;u?%f7VTb%Yz&VD5d@MeE=n}cgic={#<YUqDIZPn^
z7!vX^zIurg^7JG!B;;e$UB?^BeQBHWjl=(~ZB-y2XQcgbRYnFdB;;dc__=zrj}Hh5
zP59eNrPIkp+E3GRW0#~whr~=!i`4Htvl$ZdaYm5$Ss8hUAt4`M|Na&%BW<TsaLC6i
zGczodky98Fnw~iuVrt9Bmun0O`Pe3Qprwqg;7`FJAIsdH6D6-2ehdluILc>1Ng0{Q
zkdTipEP9rgk#;jEIOOB%(udoqAN1(=#{fb?v*X`ozljeg5*ZQNALH{}&Luz1Xdj^E
z#@?TE#I~V>+(W?(3HjK!{e`RYf#@Sc8t{=mLb2N1Yo+3&GDG@>sL4zU4*7V!!>rYE
zmB9=N&3G~M!ztg1k*a*pkdTi@8{bH|ttKH|W>Ij+$EC-QR+qQjr3?xA_%-ywD;fEU
zAt4_(zk5?#y|JwKvF>awI5d>~H=Rt7Cwx95LOvGUT(hu@e9Dl}{`h&A-6h#ar#X}x
z@-g?%4wvPtiNy?Qz(-|1%*+P(ICgw~ZnLjCJ9-~KGNb_?N%3~!4N54TuJn-}=@Ll6
zAs_3{nSWp2CYCZJ)I_s))+i+hf5VWFkKJaTI4)ONXD$VYe2ldnU?wA%FeK!o{gi7i
z>O!RV@iif#+#Oqg$tW)xb>?ZgvG?cf-tFH-&b^2sAs?MTH_s-2(*BYmAs@F4IP5Pg
z-h4g<hkW!MI_hZV6mgV4y*yzIX~0KP+`n1rLGtu`Vo1oxhA)#${7`$-1r!|e@u;VB
zxcpGbT84!BGUC>`3bNvV8Pb4{w6>XVsIpxdOJ%RnPfx3b6ddv~BKy>o53Bz>80dWr
zC!~QQX~IKyI)uvdd}Bmtf4mdZWt=>eEf;CIvFCHDnKjra%d?gt4fsg2vwT{=%*xCt
zSpDpLV@Sxybfrqi$Ya@JF$ITw%-r?pYWY*rFouMDoYlPh23hemOQ=c%KGImGUo~O9
zGL}ks{aAKjNXW;7&As-^hpcT33AOsWm)%dv$h1o-IOOAlLVmHbj~;}Ci0QuHHt_@X
zTNn}Yv2w!mQgUvyWm<0R_pSE7dSxRcJ20dHA88?)-=<(DS@CTQ3HcZopQ(oYuxa|`
z6ddyLUX4#Z<tn=|B;;e(g=Xz!<bH;Pe2nZ=&RlUZ_1cy*h=M~t7GCgnqCA#;7!vaF
zsrA%5GBSoCA$z=5Ui~EdXdbKv$9`OVXY!`A^6U&`M99a5rR~k-+{YQxz<HGx;2|&V
z|2+?odcupXpxg$0B&7GUHK*hr8o`i|kGZ3}cT;CazfGKHNXW<HnLizp&l<&7QgFz}
z=amZ`lB@J#NCQ67+U9b9;aR!LV+;xTc&GEzJ#v-#R#9-s$B4Qk9?M8?hJ<`9*5&Vf
z^{k;kuSOBlK&R7C_A*;>LH@iW$7(G%_I%Ex+YaMp#l0C4s`ALn2P5VE@d!ggKAtO|
zzPf@;ea6bahJr&rcClzVQLb_TLqa}AH;9c>CtR<1EJH#*nzbCZQJ(PvYbiM7W9!L-
z7swy<3}HwEKGJe&*(*M;@?Xk#uKr(ehBV+KAy@YEIj>Al>P5ZCItmW?c(8un;_CG1
zeH=ze18qq@7K*tvUH+cgNk)YBN3S0}7t3u~GDORbJ)cwC*6g8-9L<nW@Y)u?V&xvX
z$dHha{aW{NmlvWE>nXSaAE}3|j{EFVkcvS1wj9lnkdI!GJx0quUS>$h$I!P6TF6N2
zPzr9qN9xO^tIOV$$8st|8t{>j(K(&2$xmb@G9={V;)%^o++QsprUi$3XkEeGp>n5>
zXGF-yd;ya`$;hh=3GI*jPdk^DSB-MvlpFFflTXewvX9dk(!f}fJh21kqy&`YiDyX2
zN9TuU|9ys?+DGdR6ddw#K-RTEa`4Fv3HfLf9a=_~=PE-Q@R7#yY1Sb}<jaZj8!5N}
z9|`%X>EALkatcF2J}w(#TSwj>69{Qw!fDYMGe7v2Qe^65Tg6RUZtVG-LWhUtQ;XEE
z>3$3e`M76Zt+Mh0oWPKfkN4L8$SwDf-DV1Iz(*QOvkWU{$zwT_A))D+GVAO?8F`-}
zAs<^853V62t8Jm+kdK@CoVg_{K9?a4_()^fcbaFiyqVo+NCQ3+(qVBPAGylPTPZl?
z<I1#;E!9g>{dsjNA)(oEYUeyt&V8K`q5Uz-v&Vhq+@-f^xv}SS!dxwO%ZiU=NXW;I
zBSwFg+wvSkLOw<vd|FkmvgCFO4*59Jv-?dMIf@~n8P7K>lc#)qInR)gk1HqCTrF2w
zat8&6d|a31{8AY?iXkB%KOMf3Lq?uwNXW<2BW(gzq~1r%omy~cDCbvAYvLZn2u6f_
zEWK>-V0psNF(kA<Zmke_NB+Rsau?->d~`AY5~Zx2%AbB0pTdv^e53=By>mNvWp)(J
z^~kFX3Hez4;mo)4LA`7Q1&4gBJfZhXIk+D~LQP~n+Wot{wq0jP$j9ANmzj9$R)yUZ
z+<=cXJ#mdLw^I5t_4G_-NXW+~KPJV<J|++n${pCMsJ}dv6;tjv|MwhyRqXkkyMHWW
zWuzZNLOxzgV>4a;SUiy-As^GNDrDj=aJ9V@+<=dCAZqm4rJNjm9z#Mt7AkaZto+E&
zQ-*|m%ser8zWlXZ$9)tW^6}(_5D)d(reBC=G9=WOujbu7rFOa=d7B{(_(;=}Kg+U*
z@<L>{pMpa^Zf&&oms+KMf1FB4sL1$MQ9*JK#WSLT{gKw8q0^qWmA8pXky>u-`5f~?
z6Hm$)ds7(_@^S2-OcC<zBr+uA<EVtA0qX4Nd#J(z3J&=g{CA{_jGWAnkdJk5t&Wyw
zJdPnDAM1_o87nJZF^YmiK8{=bZnS*Jn#_<;t5=-)*2MEU@eB$1*y+>ggG%Eoe|jG)
z9@K(E#N_q4`pTW|&xi(mq;<$|>5)S6P~K%oXn)*s(9cmuR!RA6`+vJQ_Wqp7HrGr%
zkTr`TAs^4Y8Iw+K%lixo`RFsf))f=MqbWG#<B@y=+Q`UR3<>$z&h^1n`BZ(MAt4_}
zRqg#ouF~l+1&4f`<aU0Zj9kc&kUf2Z@0L_&T<_y^4Qb?MsU**$R)wSFn=iGFsJW|Q
z@6S0ss_01h7EvHWLO%96-pW(1@(x2n`{T-xNtxs-ZDT0-|50{UVO4Ei7`8?1!d6to
zLL~)M3{)&k5W5w-JFt*25fv~{Z0y!!w_;-=qNt!^AqIB-dwI^@W2}FV{XFZt;KFn9
zp7E_Y-Z|%ry%ywS_XBIa<tnE#B;;elzWXiY#q2smLO%X1HzG_%Ry;|;As<7VB%PCy
zQyCKSahHpC5qX`s!;p}VDV3Z}+#arWih@Hv79Cyavwp<YJ_ZmH>hxIGO(yQU#xWwa
zK5nYym`@&^>Zc94?Vu_bcROEHMg}k><l`f!tncL6@&Q9aJ`Ub>?xK7eWq*c(Lq5*=
z5jaNPuLdwA<YUK};+5qp6BrWmvC5bNm*m?~)y`6I$j1k{DlU|R2Qnn&<L=AB+2s+x
z&ybLh7i;aYlh;SPbB5qhTQ-ThUtcbA79&DF_V~VSxO`@oz>pezq*Kx_xld13aw|@%
z&&;Zxr`#HX6Y|Og+i}W(8zZMNB;@0|ki?quvAoTYkdFg~HhiZ)K~V><5<|fuA4h-k
z8!1;Az>tuS_EB#2<PpEmkdTj;H$>)?eYCki!66^}78-RxUUFwJB;;eW14)@=AMX(o
z>Y>&#AI8WlkBx4w|M$$SCiZ=+F?%vhk&*rk3HjL0YO9GK^dvB(1|MmoUcGtcr}BW?
zUZUX8v3wSF<)b{{0SpQGm|@YWw{n$<3<>%8VaT<wa+UU%DLCZgYOB6aWX0z&B;;dA
z$M=KeDjzc><l~06(=Nz;>2igFLq6uqb!3UWUkxE7G~kz;uIVaYP=Cyb(E9kkR#6ih
zq8e8Xxg9n5Nb(f9on&IRoXL=okF!Fu&y@FAcNr4$@y4}x59P}mw$~^)G(1iP+}6oH
z&SOZ(#~iO>o#n+Wi6J2$6DKG7$W_|MQgFz}TJ8xiWFLbVQiG4QBO21~&@N@xP_XK~
z#v_J=d@Q;>d9S=aI$bveheqdM$zEylp$uk3$j7y{&hC(B%S48Rd~CiV`J`N>!wt#}
z`Pet4dw;ntgBcR?@nOi|zt00Gm8u8)9z#Mtj-A}0p4^tzZ&Gk*#J5dPswp4KK!${T
zEIh9NQF+AgGbH5Wi)%SeygSqG76sSfBTed6&L)_6U3CycLOw1nyL-Cq<0C>shw}84
z$nx?cZhza58@ptCbg-j|=W}K=B;=!eSnm<~-0Dt$#E_7We(mSYmV3zI4h4sNbelfa
zS4PfeNXW-V4c45MSMf&-3HkW)#*-|vk1lZ(9BQJrcdloZtDMh}kdH?i1Xb7X1l1#+
z!jO=UW&i2^_jO|mR*iJIOTi%@>-XFCO@A!a*H`Bd63Xp)GxoBa`ynGj>*J3P$Nl6x
z3AXWu+}QW6#z(uIk*l1}kQ#iX-Aj={AOHHOOh)R_xyg`_kIy^R7^xo}HL}t@3J&?$
z@#3M8@^tCPkdTkvdworntGvySkdJxpC75`VV&w!14)x{GLqAMBUOb&4As?GYnwz+y
zewQI3ALE8(`K7;Bt@g3neM4}l$ll8;n0R^dG)9Dc{2A5S#O~!bLqhAL&z^ywO<ZPt
zK)E&eNV}Izg>&1<i&+3eLOvF1e{7rF>Gv5D^6_qyqmA_gu2$SOk%B`$)*s_PSl(;+
zGbH5WnrHhG<zso5At4{VyYw~j%DQR~DY%AKrx`d;ht(m<q;5O|Pi08R$JFy@Ug}3&
z?c;SqY9LaPwJRo@D@5ZWtsWV2yFxy?*8ODSwTBZK67tc-;m<gEnYhG|kdKXe{dSel
z%*sBd;E<2mqTlY4XN`#r3Hewnwvm+_{5C^kK2G2CS-yf-HHm^lK2BZqs=w^xB!+~1
z%+w;giI<{XXGje`(hO|tU$l^1W!Yp3uE8Ec4r#tHLH2RH0f{~Qojoy|iHk3n8Bv3e
zq<GrETGeI6%RbTPcD99l?Bl=bvwSGWF(l;U@ao|vUMP5lAvO3&!OyH8vPG%Vcy258
zl!8M(mY;FBx9sC+hJ<_!ZBxiz-$Uvp_Yy-wK3)wPS6@b!c}Bq@A14gy`%xb8F$@X$
z`1P@KjEua*kdTiL3vP|lZ(r2wqh*RAIMnHlI+gt+?_NeRq6Qyn(%AgNah#m{JVQcN
zem)&EUA|yY@;T*(e9Vy2KU%JGEJJGWk%G_d*1wy4EH5)8<l~z!PkPE#mU%(JAs=7F
z?4BT>i;rbU$j4E31Fp)*7>0y=EaUxcrHm~0l7d4%T9wTiCL;$kB;=!8+r@+R6Or1-
zV}yj-vRR|$=j0;uzcS>uhkU&5e{q5=PalTV;3KU(3&!}BR$eBqe62=3rypfVD0uy+
z8w<-HzbXEjf<r#KyA*boe-$>FAt4_#4hx+l-_nd{NXSQ@)S`FgCD$>Pf<rzIYS<~e
zzAe?mGnXMDANRzyYAhokGbH3=&M8x)<muAs4F!jMJeGK}qrOVDkFyC0^-zbcCEv(J
zCNd)A<It&@bT^izuQ}MI8FD*l@R3%Y6}vmH*5_6a_$-EmeB9%-poM(0caI^VV_B{7
zo#paG<oK3?V?M5{<1JS?pCKV1kNui5Tdwj2Lqa}&G{5#+ZlVV7C^+Qf&#}ECWn>sb
zLO!OO-As_L7`$Xi$j68MvKih8q4u%CdqZ$&z&&TJt08ZQ!Wa?qv19*nCSFMYnjs+{
zdsVfLR_s*%)IPd@pxls;_4{8m@e{7a3<>%8v;K@3^2+m)A)(>P)#{%wa`5`;6ddw#
zjb)ZWa+RSBsli9uzC<@@T}f#o1*;yO7Yqsc*sbXNBeFboKT>eW#}^huCd(61I731{
zjy}<`rhe&B`}mfS(CFNVT-08E6GnqihTPaImNV|Mogp8}H4F*)*k-GPt&IG}kdTkX
zAN@A*lx^G36ddx=ZbFuQ@|DX?3<>#Ipu`~E&upZ<#utW!M!ZJp*Mah0qxlyKuE9sz
zzTDkf^Sb;w`6z~jd~~ke_>Vjh{boqW$3K@BIm%7c`YQ#8eEiV7mWBRUs(p+mBy=cy
zF3x7+)h9m~5n3M|yNx+5Pr&WI8FJTzeC*u)_D*?pHZvsTW7*<4gXPir&XACg+27O(
zH4*$f1&4fG`+Ks9C3iDJLOyyvEOl0{GQ$t55^5rQ_wpw0w0B@g$j5r+t6Y%xtJ@h8
z^0DsI&4cBwV8)*m9P)AU$uHje=~C@u2SP%*Yp%$aLoRYNBSJp@wEp0sFH*gG`NNQq
zkLGKS9+iD;r+Yr)-(R6PJ3~JDUazX#OGzuwI);RN%(?&YIvM$yAt4`q#y-3z2XFS9
zf<r!b+i*|U(Ngf`3<>#o#_Z@Vd2V~dkQ(}uw!n`EU8tqZ8VXk3M2-JYaLC6^E-gLe
z{c0pbLO!l*>l!VukDmw$75TG$q=`3wH`5)5|2o}8gO7A5y?$i<dxBzoD5Dq>^3nZr
zfkX0ue`ZL?$HtS=3&>v?X_b+JLq0CJ<uOTKc{VX5<YVbm?efdZ#2<!)e02L})=-{-
zy>!3j(~mgh<NGpuOx(oY%#a#<RHmMPzoi+~@#aan%0CPVwR$eQp(d^Zx7WR9MIRjU
zv3%m7C9;oO2ni7bpYEC?-|zU%h#GvPL+Ma0#a5n&+GH{0#=dW572kA-{PEPy3<>%8
zdPZ3j@9@o@m8#U>BTYn2hj(17+?-JEd8p^~P7De8*#2Dc5%NT|pCKV1SGBO~Ee}ub
zY!n>wanYn2hf3%|D}U<Xz6=TZIK|CklyYR1KQ;0KLqa}Yjhzr7AItLDDL7<LY_GX@
zWgjOSkXjZqlILLN_V46}zhfB@^6|0lmA&#ZQN~Q4+XZ_*r<Uab6F<fn$B>YZb@o3P
zFIRbmAvO3&$MSR8Yw_}&UOoo}hkWcm?vbU8oXC)nkEy%zd&tOGhJ<{){_)mLc~Y-n
zPQf7`f4<lhCd)IPAvO3&)8*2mA?eD9E0d90@mPk0eDn-<KcL^fsLvm*a~gtc*a=dR
zj@|p^QAS6}t}b#SBSJn#kNEcYcb^JYjf`bT4OLR7+Z=pXT<)O?xhS^=A1Qc1mr>W1
z#Y|at)m2VrNXW<V+~51kE6-hqgnT>}>ONEMblcn%9P;t2SGD`{v7E_}kdN!T?bs_n
zTM^HYkdI!E8y%H>bj?G-HTcMy$YSK*Pl6~;sz*GOAt4_pSl*teA0D-jF9@ljEvZPe
zlCg{RE3Udo*Sv<@*z-BBJJlU2x8(wcgnaal9Q8(C%$_qO6g+Ft$gVQ7ZaxYQ`B;7A
z(g68knlOfhe9RRUlTEJjJwrl1W_diIuZ(P}J5~MnG|I&u@-a*No<jO%Lfu4B3<>$z
z+q&Z%`KnVoLqb089Qk;>()h}sx=N1%6ddxgXY|xCeQ>pp5rl+#=<D?v_2k^I7!g_@
zcbrV_FC*Ow8ggUL=bYIv+F3>}WJnD@()zfkQjWj!C^ui#qw|Czp<}tZ{Zn&!POqnH
z*Z(@*0rD|ylvk20PXt3kK3*T->?u!|X$%SZ=o{ABUOs<pQka56KA!wg<gmWe)x)!y
zAt4{_JMVlUFFn5)67q3GkI8BB`q<9G5F8rtVpn30$OFEP5g{L&{u<L=zB~M#A))or
z{%wqnKDT;wIu)VZkdIRjmDr#JH$I!#%8-zcW$Udm@jk0eMX5??c)CV*%P3#S>dcUk
zj|E=W_#tmD4>Ba=V~;sLQ{>?(R*Zr}K8_q&(?;G^4`xUWKGF<)Guze?%7`1Enw?@u
z$Va=QepdQfL%lv0Ep7-7jn1Eo0}IQ~Ko4d_$Va~kg{#Rubb%ouA6+dso{%SC>k^b(
zgO9XPk8V<}Xj$FpD1U0jgBcR?anZd#x#j)pJBEaOG^^rtRleNjS(1W7BVMEButRdE
zM=~Vjqtk=0_vPRp7!vaF)KIgZa+R%0QE&}D(ujXA`rX7&xYjcy<l}DJ>bl8WX&~i(
zuCfSa$dFO@w|>TVLPCeqtw*r8oV#UdLvHN-IoCg1r^!C9V@Sxy;JTAa$~Ox$mZ2&k
zAN&4UKSrL@yD%i=V{p)!ee$u~&XACgJ!j@K@tU>FmJ}TFF~@QzD-*#P5^ADhktf|v
z1ZPOd$9%uvOqBQjnRRdI|8MVK6Y{aH*;>QL#nm%#7lwp<bn89)h<*#K_Hh>>q1+#O
zJgzTydX{pA+}KZ?-{*RIR9~bzcXx(_e2hEgwOig*?`25H$Ep+SnRtu3d3g#B`8dII
zTn_nJ;9d*~`PlaO+M6=+6hlHj_PN!2rF<;Q>h@m$b-FX;<EgmnZ)L?NFeKEMH5>by
z%g9R%3Hf-@v#zDQ*C<(mf<rzgUcItQe_ccE;}AkZMdr3$l1a{eoDre@YR~pr+sVj$
z)`r~J_pK_mo4i(@HF`57<m35GK`-UDJj#$7e54bUIzK!!E6ap}RZm0(D^hR`J`&Qo
z^Q=}fav(!OK3?h<P)a^SIl+*SkM*a#iI8WFl9ebp<m0-)_qFw%u0EDi7!qprp`+4F
zy#6niAt4__Po-?tFFk4>D^xZFhlo|~JfEW{s&h|dM99bN$+L>d$ZHG<t&c75Cl8k8
zDPM(hLq5Jt{<2*@=b6Ni8hoS^lsugV&z6J7F{B0`3F%^&I9uMfRjo?FAs+|LNqeRI
z50pRki2F071|MnGcroSeC}q|#zEX0VAt4{99lc@V-C$L0C^+O}{X8vF<O|Ew7!tB4
zf6M(#^&_tKG2Vd0UOtum?X<)4=-5=#=XS-uZ)KLVm5JXZ_%S5p<FMEwk+P4s84~i*
zf5_eE@@2-V)hRgS<AKguE6B^lJcfjPJY4+RKsk6SLqa|t-j%zw{Hw5rH7K|SA8FR`
zExKluzAe>?FJef@$4+imxn$&XhJ<{qvwZ#@xz+2~QgFz}JA3-*Uikd)v-xTt=Mxg@
z^vRpA{E!Fy5hFtD<DhVB6Zd&)+8J_V-?wV}r)08xDCaUH<m0;s+m0wRyz-~+p$7~J
z`Pg~8d8m9L%h{fSLq0ybJ$kNur6i0YAs^F!wB95mUo#}+<G72Kon>SL2MP}PSn6P1
zGkGzKU`WVE-<}uh$W^{$NXW<fJ_jo6XAQNF9*&0KP+R`#cFsXAaycVHK7J`TsI82A
z$B@vhF>X(k?k#`PZ-hLYC^r<m+ieSfS@C5I3HjJEW~lBhMpBip7!vZ)a_!GUGSaOk
z1&4gBJNw2?xziUiqy`^pzgqBZXcJ{pH{P$lWJt)z98+7}lQ-)1ohdlv<MHxaOnl;X
zDMLa&o=kXFT=p@IkWde0dtEh)oZH>SkQ@8H)!Dk|Tk3Dhs8^ol3<>$T^yT_`GBS-J
zAs?$+j0%>K?yeLZI+o*4<@+up!x<9t@mYHFBl6t#iXk=lNb*cf@b)UFlgC>3ryidA
zwJ5j-A8Eg8m$WpqzAe?r%?t_oxbstuQu0N?-wX-)_-1D0et9d{rZxqKd^|s`yrmwg
zULT_gsbRorbT&jzx~CA0A5;0oh|v1@VV8ZBthjd_LvHN*R;L#pZz+$?Him?Jto8F!
zLAlD`3<>#Irs#oB%8^z6)NSeGM!_`<4|RInsLdDT#cVf2YVeVeKEJ>JkdfwfsY=Ml
zE$xfmmXBp0hJ<{KZxc30zBzG(At4_RS9`HTt}>@?vj6u+kE<i(<JCXmvHB5L``Cw&
z(CCD0ie4#Cz{eO7@^SdpZYEwPUa-C)w-dBJuB-Zdg?=7VclscPgnUeVv3IW={1ih%
zK4!~zxTbvmSfl|3hkWc?CZdll&sc_pM*Q0|&&KlHc8wt+A1xj}YAScSr8@<Oe7sqy
zx}SV)Yyv}S@R63D+~eb%lo3}dRX0&QLqa~DSlOkweq*5av3f&8aOhAjnVwi!9-Wzt
zsKH0dy=7hJU_~C|+_xDL^3mC5z#zFTt2UzCkdL>^XD=+@@0i7q8hoVSj(Nj(D@esj
z^?*NSNXSRe6@yabPOsCLf<r!ftZcJTK9)-u5^ACk|J>@JZ%cLXHw+2+c&vk^w~Tc6
zpx_#Oq>aJij6Yw=lX?V0LOyn}+h=&SsoKXhLPEKVZBH?=nALA$$c;Up^L&5MJNZyX
zFeKz-ZQJVW<U^UtkdTiTu0LKRw`Ieo6kLOkG~joO-Mb}M8Oe~4kM)KYm?<C2bcTd{
zjJ|f=L$0!EGYSs*SUk0kk9;hn7!vBsY;iqv$yI)3NXW+ktCAz+DqA<F;E<06>pB{4
z^r(H@L`bN}<eX0$$VL8SL=EdBwWZbarG4ckw|xskZtVG-_|##S<+F)shJ<`PKBU17
zxymmL3HdmycCJHmmCZaUIOOAtDdlF%RW4&l$j5+Ud+*7}*9-~yxb|FzR`M$Drn|ED
z-<g>U<m29%tD4F_hA|}6>cL-z)R&Q|3<>$Tcu)TZ`sq^bW5ZU4;1Kal7N2W!kr9lj
z!AIJ*H9Ge?R#Dt|+m^<V(E50)^vHs8l}%bxZpg>2_pWr6?<A~ZNXW<h<!as0kB)lV
z_MRajA7AfW^jz+Ak2Vw>^0C#jZl~lE=T!^|`MBpu&HZxlj|>U<Xd6)6#2x2mZ7De9
z<FlxOf1f>6!mEd8IYUDBc(p3AP2WUnAK&Sbj#?h3A$k1cAO3v;Pw94bk?!sO%dI0q
zK87uCZL5rqF*1T7As@Rvo@?UKid2Tw;3EakdZzC{Wn_%2bn~L%kdI!svfIhC#$txl
z;3HLe`c<F58+GGz@mCC~!AC-lODdFAsnQtPz?*_YKAxTT!|*c)brUURNXW<e)glhc
z$MOwBLOvd9QniBoU{a&@6ddyL^ya>XQ!}-XiwOyJ`j;g00`hG6oDntnNc&aau!$xf
z!E^I5<i?)Q$>V>gvphNr7*d0eRAtV0FHAhf`HUeUAI~j({zcyV*X%&SHTXzXIt;$N
zR34rXhScCAA)_v=50;V77!vaF+O23;8Ckm{1&4fWH^}pld@nbYAt4`EEb;y<H_<bO
zgnZnwEN;4fW1#l2PA5Zfs4Zjn9nUBq%7u&w`Pk^xfwA(H%M^x$W{s08zVDPr$GtP<
zhJpwCPyQv}oCs$~$Van}`5I->tvt$~dYSmhkdTk73%0o?AIo}OC^+O}(4Sl(ik-@z
zy2=#{3HkW3WlI<RwoQ#pWk|@!`;~_MlB=xOm4ZV)#=4xam8)FHkdTjCtETPK_odp$
zCxnE0=wh2AL*x^bn%xY!vFCHT+TRM06<@%RkdGgpd7qH0e9DlJkD)WYz2(KMPIn3p
z9m|&u+P;*36&A*jkdI%3%umTLMtIARkdNQ$w~m&Bx9vf}As+{XT=9|L(6WUgAs?M{
z?=$h8ryM=0O324?73w^c*T)_V3Hj*J)GASbZA|Us0YX9pp1n<`KzVes_cG*mgw{uo
zt#gX$i&W2+JsA@6v1_rzCLa0O!;p}VRj-w3CRb_Rn}S0=o^D*Wg*<C?Wk_gvPAs#y
zBhPL77!vZaWMC(&GP<=<`BM*%c^?W6`8aFD{O!sKs`95sj$la0M~D4;%;oLNWrl=&
zoS)%c9eH>v_od*FkJ*D~te4lv8H9vJXHAVOW#l4nGa}^Uoxz10%9s6Z`WbR#&*yY`
zP-vpumQxrK@^MxAR^8QJrGNgvhi)<?<YT@gFB`~;Tl-RQ$j8=C%WRj2X97b)BOYwG
zyPEvu%XNl?e9Y6!|Af4&w(U>BAs;WjK4{``#(4}0`RMm>LVkI8o-!olV^Efx5&9-l
zua7kc7=lBG@?6=GzvT6CHX}kl{{H8!i5t$z3<<4|RaW``y(Xw^H`Eib>p;p4`B?s`
zO9B0<xEi^TAt4`MudZ$4<&4i567n&@F|o1iW1T@19P+Vzpi>Wd+qQ%up(d*OZMmC_
ze9e%Mk5y)+ImvzLKA3_-K2DB$GfPIUU`WWvR?c%z=oMG{_>quMZf76w4|0)>hZu5W
z&*vOi*U-cRS*sWl^3l7lr?p(=7lwp<oE@4gRbIv045i?Zk4>wz@2Vdiwc@K867sP^
z>$ACJ<Oha?d@Nn7W)>OQXcz^Dd>q{)+FM43Go*&Tq`NW^ZZ+>JBX0aHlot#M`PewB
zUw?VlXfT|DLq5ipxnV7@k4p&&6&cgFYP!5kyk<mbeOxjosH?oWtUtn#8+$%yM1*^H
zxyo>cgnZ1o%RNj+zGg@bK2i_m?)>Jday`fRG^+kc3J&?`oxWZ7TUlvWy__K-A8Q1*
z{ViX)Ok+q5K2q?7jpoi%sx;od)Eh;?As;J^SrDo;kuh>HLqe_IIDeT_vX3tr67tb!
z@yx>d;Zd)T^+y|mL&R3Q?#`2oT+E1&kGFiv`pbK)R}2ZQkM2)S?vQ)PeGKJ>e5?_Y
zW<v4B3<>$TcizwdMRDUEdcly8k1c*zo+rP2%55wKhkRV|=fFI9x?IkX8hlg+<lm3O
zT{v2#v3#ff9YbpHk&s1ie|(|uboE}N-Z%;l`Ix=N=N<A4yqF;&dm0~l_IJb;tlGyH
z2Be(^d1z{TUMXy>vei&-%&2qM8L!W6hdrOOaa&?R<xna`s*wvA67sR>ydysHp-g5-
z$j6D{_8VozohMLm4L(v2br@IBL#{HIAt4`s)$%d%8`?yMgnTTNzV5Re+;JiWhkP6{
z-RkehQ;jF00EUEoyluYCOg@$m7!vYvXdk~+dFip6M8P2+OI!XNslTPE_A!`{P^Ww6
z+T<!1nZSq|6sNYdzFB;?JOSHHHsr>h&zUoF>>3#v#E_7W=D(~L$;d>8gnUe|Tw<Mk
zmg_Kuf<r!z=-I%;i@fGBB;;e>hQ+<);7=G5^6{GA+J9uEs~-i2e9YEmn~CpshcG1M
zV;-x_Ccanxj3FT(UlyNZIO$RQSbM4=IMkLGa<sLP?_q~9BIIKqtKx3*e)T0oLbJx;
zF8h1P$Oh9WHx%4rrJtSLL(3Qv^6|#v>-Xg<-!dfR<ADKg$K@)UOsC+Gj|DAbP256R
z$&iqbUTtPIkb{3>NXSRmkNLLBec5sb1=rvsZ3PS8w+U9JO9iXmw?#7~<m15bdmHtu
zxZ1}IGYwTjJ#@_db_e-TdNU&AWAv=?tK=Tq#*mPYd-M6G%T;Fbr`(W_a~?1HDI+^G
zBy=q8_T1kt_s|}OgnW#)>ibYe=9)#pHTXzvdHep_yULD839oKTUxtKy{FC8@i(KU~
zhJ<|FR`rdaJUm4LD7Xe6Y2Q}3r$ssa=29JeI731{TJ-QLs7I=OJWWVwz~dU_be7L1
z3I!T+W6$S=gvUnci&W?C$B>YZ$?4r=WaL4H#C%*lu(2FGXAlL4e7qO9Emp3wD?>uV
zv+s#pl#JZTkdTj`@;?9j$^m7mP!CV0U<wZT7*fvJQW0MHQzJVwqy`^p*62CzM<K;W
z;~(wqXGqA$RhGBL%d<xA*%Tb|(Pe%@5qW*=Pe=`;LzBj{w--F*3wTEu5n3OMb$qD1
zoT!Y<|Bp`5IfmTW^Et`+o?n!g+#w7J`S{}7FvFo#_t0sEgnZofz_x^ZE?#6V1&4f$
zy4pRfd}nVMLuwdt>h!fgKmT2MjD0-GkdTi(-;SRmpEwuQ-3R&mdt^sDCk;MQUw+sW
z+g=Vnk|7}<YdpMQ;-~j#7!vaFV8+>2vX3R_8-i;%lr%a+TAh2Lbh`2Aj9^5_$2G$@
z%#ybn=NVGN`bbrNn>6n4D_xEESfv+GZVf&X($k|&5k(&3;A0q4gO7yVbh~*W<yab5
zd6^+09~ZAVSW-TgWkV>q1|O-@TRi=FPnKsQLuzOuLO%JpqO1I{=}m@&eC&4Q&^kG|
z?LrC;`IzjK^PBtxNH9Y}KHfjnx|!@_JRzan+tw^KaZ|=7)Q}r{K4)=qW)oK~XE3A&
zA8Ej^d2I@k*T=gIsli7=ZuN3#FE3`*7Ey2wJ`(ch%Kc^JDrYey<m1Iew{G$>k-(6U
zj|+Y{elMw;HIzT~#=vGV1=rvsO+=SY?5(T>SB|F|8N!fIUry<qWte;{pD`rl<NAZ!
za?8iE_7VyX`FJFK^<n+#g!=q(J|Q&}Nry70tHpVRXuM23Vnk?tY|yq|1$k<-4>RP(
zp3hm{AiIg5<<4P9$j8Q$9^{vOe9VxLk59MuNz%`j>b7(ar{Iu}sr^Gv%2m!|NXW+_
zwiC<ARX$-z4L;IDG{xO9Os>*J_qg?c`&I1yIkvZcZ;(&+LKsp*t5cP}cYm~&eSFD~
zkdNbwTXxbPOSO-+ml}dY#Lz~2x5!0?Fe2n*zu|e-$@_vNhJ@C~Ep`po%2nDequh{>
zG2Yid$Vh*NgnYDj+4ogHI%*&9FeK#TGWXou<W8@$oPt9>PC2t~y^Nf}kdTjqKV{1=
z&%p5v39XNlx`*|Z*GJnG6ddxgXzG)f^6&&QBxKK*@X>?xNVSjm4M=-Po)3{967)oM
z57mg&=eF1Kd=AY+L$7)5l##O-QiG4QiXSiB^@wuSN%_&My2^VD3Hj(dd_}TcWzCfo
z9P-ij?xGEH56xvr$j2hj<E-RsV@V7N`FOfcrLS_8POB(5<m1s5L1{8_E<-{-hONnJ
z;<uzp3<>$zYIcSV@>#BH6a|NT+&eFCyu4qHAf$#)Cwb<y&+VlAOZiiG`b$QH6yIF5
zWovl?uC>~b8+$%yO3QnhWMn8qLOwpXjqE1}f5DI%e56@pbMl0aisDM8>SO7;hJr&r
z)@`@ygS_%AU`WWv)IuM+$j35;At4_p{W^MFM!Kz~;E<0sGd*1+2VcUFkdG5GW;gM?
zTq;9CK5m>p;=X=TSFeu^*BOFCZRuUTcC36TBN!3#ar^zPzvQQj(-;z(HEK2W_m(GM
zxAl}83SNI{(rEqErj}<hLu&Am&24wS<=2mn8kxe7kdF@<4;w1a8nri2aL7lOq+vzn
zPM^n+8hoUQXvV_gy648FiRdXqLOynRlXsPTEL}EIaL7ly0$+;CO*Ee&As;UtJ8k0o
z$WI6f_0ajjHevGUI7b_DWAD$|ZTZJd?x7HdgnS&{yjewg)_Ba2kdH&#4Eru4oi|Z%
z=vb!YUNS-+@C6JB`MAP$YqE@d%8-zcrMGUYCy#io%@kaNk2DcAJNd1HVyE(_o`@DP
zB;?~Grzs!h;BOcb^6}b_`CDXU!z~mX@^NOZk>&NL6YBMG86lwo@0wiIM!u|(%81bV
zxU8j3clmlw-K~b)*!Qirj_h+$u5tlGLOz~b-pWR<@-ag~J}%4>dP=U+b{hqUhUZtW
z452b|CPP9#cE0kvne5|jhScCAt&jUN&e@@Kx-!41eYDw5!66@OxSXvn%QKT9As^>h
z<-IP?!0`+T`Dk6@X|#TL)IQeOVF(V5j_21g_2hlQbVh`HeBe0b@Aq_!N9PVhLhGYV
zr^p`iJ#3qulpFFfqKfS_Id}j=LO#xq=yy`?p#+A6e7ql&&BTo!+g%hK8u4x=yxPkf
z^+1Ny;3KV%?$g%W%g6E_Lqa|tZ)vq$MpoZV!66^>Up}!#M*1@(<YV<^r5)t;F`kgn
zp-foZxwBkk)jfvXH6b6<TkOdp5BPM3gnXRR>b;4daNS}^$j6ndu5{2JO7)yxc`pTr
zd~7=P@oRbI@ncBH$A|;oPvpJ-9fpK_9CcylCV82#-bcZqCi=B;-xGPi>c@~8e557!
z($}E<@{$|RkdTibE9dr;gIC{A!66@a6mF^85Gb31|NlL503kKxrm1aLh1H+s9*So~
z$j9%u&h3?Z$o7CCx3dNxX>>kSbbg@B8pccR42IO;BOzT+&9{@0aSRFh_{-*U7I}TF
z`VR%y;3HKT|8;g}1*r^?de)f1kdTj^*K9L!nei?|LO!0d8sJ(=SE2H!uCn?;3J&#U
zyDJv`l*6F>sga8q67q5B`dXP~AKx$}<YV=|EzZgN)kcR5!J#5Y&N>+{UknXnM99bf
zJ<qq1m)xfesli8@HDW>+?3b5Z*Ta-sgO7w<m@T!IjGV`ikdKZIWyZ+CA2Fl`AF0Yt
zJ_`&FEUVkn@dyQnd~A0npt62WS0iULB;@0f(0`7}6Hy{VLOy1BUg7U_sT@yrl@3QK
zIMnK=HaZ`X*NI?;gnayyr<HDBs#N&@>*GB_Lc}78`G?6pWOK}r+f{>)G^gj^`?jRK
z)tJGM8hj+=xEme&DN~#AGI5t7As@G$+4x!>o$ALaIOO9=Pgh%c0-nZ@kdI5&?68!F
zCypUC_(;bxdCs$?3etG5QS}4`hkV=+Q`W>;?sSHPe2h;oZ7wSw$B>YZ-7f@X*2|+-
z+~y<&hwPa)vy|>9y^@d94M^<fME*)+{@VR7ReAm;LxzmHzx6Y2F`@<^X-<EWuk}C5
z@GF1n+!ashb352-@R5-7?OfdD(V5ARkdJ<kR^F5^5ydkk<m2mR<<`hZyVDdL@-fD@
z^h_B!haoliNXIhVuatv~e8P~Bj|n*jTgwwsoih|1^0C0d?n~r}XfZ=VK3=_>%fuHV
zUN9u&qs#G=G5RXi*H;^yH3Ww`{p2xo6HmT`F`@<^X##!`bHY+t$do}>`<Tj*P?clT
z_Z`vi)78jE=O{Pi<G0eOR`UIhaE63@e4BM>9=XaChJ<|FaB+c;T&2r-3J&>rsBj)1
zxyoRMgnTU2+Rb0zmg?b2U`P!<QWMpiSNHGD3F946jTj0J`FNqsI41>Xj0|K*$j8Dn
z9P8*$delBXBqY?9!&W+ek*7A>3x?d-Be5>?JM5H^K@17`*v9jCJsJ6sA)(-pCiLtt
z_mI;?3J&=gRI`)rYVW_h7j;|CVMxfwloQd3^3NO|G9=_<v2B|Y^*yAn(&Z8bhkT5S
zzg|t=zRYDv4L;H;?s0O~6M1-&7!vZ)zscK!vX3<{Q*g+~C8c)W)mN$ZaRDKr9;zAf
zzK(n-lNnLN`bdW|vPh(fm!-N~G30iDe0-i`X<qqI&Spr+$0rje<kTNZbz3GeBy=o$
zTKs+>&l)waQgFz}j6=SfK+b1K$j6^%4O+{JKV?YB$M>Uhn|Q@?-D?ya^0CpwT9@Pz
z4`E2i$EMS+FO`SqIYUA|77G3ORNq8uAM3^%f<puTuJxS&xyVI~sKH0tYOJi%=<jE{
z6|B0`Uos@*;|%Xs59GIs)V)r*As@5X%J^0ezJehkAHREE93@|?{=ksX@PuUQw?RMP
z>SNj91_g(FJXpK)Q+WmsXGqA$F^P{&yqqzWAt4`|?AugV4(@)Ff<r#qhZmh7BO@3R
z^0CzK72WlF4YiM{goH-t^UzNV<$0*?EkkZ64L;KP=<0mkNzNV4kdTkN%e67_PVLtW
z3Hf*_`yUgp1#WPgf@|=RCZZQF=f6?*tHu-2B8G%~Oi6X?DbE@y3<-^Rbnjs%UIguS
zhk|SHk%H&RGG?jLM9P0r&l(FD67tcn(8Dn%f-|HBAF0aJhOzUMzBC>lw>Sz8`Pg{Q
zpZ5AzSNph#kkFxQdGe{9a&~WAWC|lfJ|^wyY+`fia@UZ%Cgh`=ulsC$ZuNjKWJt)z
z3yI~f%ge+whScCAO+?Gim+d7ZYsXV?$j9qZ4_nKpq@fH6`S||XB@@4udB%_$nuvmX
z274Db5&RwnhkUdiJM)cv)hU!AHTXzXZcX2oS-v**gdrgxod(+7)Xy4f9~}}5!J*u*
z7Q1ASbI)c($j6}1o7>39`wR*BxO-O>6JK$zcAs)XK0YXy{87H_AHa|re547u>)dgR
zlz%BZYxS)0kRc%-;|lMdA#c=OA5d_}$9s{DJ&NlpRQ}XehBGAO<AAUg_vGpF3qwME
z`MAGXS$(IgtMp8y;E<1bGv5rCM|>SaLOyPow0VFs;>w@e$Df3Rip*~vlUqK!_jzc@
z?E?8|Q}(inx2f!6NXW<M)27?YyXx$Zs7lDkgf;`8$-frw!H^n!qzO3spZEpxVs?xn
zAs@|q9q^P_p8Ss~IOJo*{BpbHW7(e}As?NeMirO8SAK#aAs;vQe^^yHvdW*@$I?j@
z9BOro@8c6>#fLK_<YUgTw}xLUs(n09NQjs;u%3xK38j(^xwSl>Lv5M=`sf1kfRABF
z$j3L^y(`HR@D+xHeEfF3UX0vBWuH)R$j7spT2GdHXgWheJ~pcF^F;2U8w?5g*sV{e
zYWg`{-RYH{QgFz}oLPgG$W{6?B;@1Vef@0ZYhwuv3HkWkFXt4wi7G#%;2P{vj-FYD
zLBkz8jPwm}rA(Jfc(spH4M^-|;^xyLv&%)^Vnk?t%vvgQsJzFjl%mh=h&`Y4XZ*3z
za;FC{qy``9P|p0c&{=;d)omHakdTjW7iKi^!B3m#6ddx=HN!>|KgRH9NXW-~VZSZp
z=`w*KAs-hNuqiJOkNpb@4*6I*a<z%yTlq62<l~M9oxaF>jd+IC;3F+P!MmDt(<9YB
zR)1*-4y`=%8!j+$8s*Q3kdNi3#_FCTR<;@cztwoakWiIH1|-+l=T^&O`-*aF@R1JX
z`9FJ3%g8{6gnaz={fLQ2)E_V;<m2hIMz(UN*LY3AAs_qX>K&rLMz21W(-{)-ah0pJ
zyIkchhJ<`{Dw*-FT%}bi1&4g}$gsh%xl{)q&ybLhLqGa$($8&bA7cp#wWa6NgmZFR
zTI;Ue|NH7pM=j6i(8}}AhmH2i0<ILQ&OL=8As@GFb89P~<=$dQD0s$6etYHpYPB>9
z4*59f!}>k)Dd{|hgnZoG;dUMUfUA$?D~5!8T-SKBiQD4tZz(wBW2F@Zw#iMjj3FT(
z7X~gFC|`Ve%aD+d^^cFYkcX$~I|{DBM{4y#cYFW+g`M$!bt5669{MpWuDN_De=s7n
zKK8vh*Hb>5X#3uf8+$(IOULUG@~(OlLqa|_G!LFFSNV$}p<~(9$G?nxVcGiw1&4g}
zomg+D?Bhm;gnXQrqk5!_{LPS%k4|k5mn)&0eU(4;tl^VR!66@~4Y3$1%X5$+As@&1
z<Q-T{SE2H!uF~QoRjI*8+GM3J@fxSMN4-9dBP2B76&wnfcxm%xM%3UVO&U9#V#+H;
z8n2I~J{fXj@6Tz}I4+;uL!%i|gO60@-ndnt<SH*SB;;e&T0K|FRhIos!J*+<9vI{&
z_s~R!gnV?b^rN1<^4w!c$j8d(@5jo)?Y~fP$j20ye)r{@g>x7Z^3mSIIhS4@wT}r5
z3Hi8rLAr&0Qdj$E`_&L!!{|_3&MKSOPPzDEJZS_nq6Qyn(%64Eag{u^Jz+>_zgpVk
zaT9svY4DA5Yw(e(oY}ptiLZ|>W=P0K=k2qu$@08mNXW;|y-OC5uZ^|*PQjrOFIL_4
zi84IKBff<pAs<JVA6Y~m9<v`*CFG-fg+X^@c{(#B<fGS%EZ*|0v5O%gA0vO2T`2o#
z_R|nt!=WS}2dw<uRbD2#Ga}^UqfFid<wLoTAt4`aYkl^S=XCR5lpFFfee9^r@)o!c
zLqa~fT`}{~kB)i*KFE-ek3Y;4d&yPi{Y}9&_(&7cz=6&teyrG+AvH7+A!kk4n<NK6
z!jO=Uc7tYKm5~MhP;kh{{@?R|mM;+vWJt)zVJkd3=!ZwWJ{~0`l)JxM(I3izRsPgH
zlrKXb{q-E|`&PelU1%uh?!}Ohj|&HOGJJ<tUFAN8gnX?1YSL^uc=n7G9P)8%$*m>i
z;2jwf^6|_)ho<tJzLg<0_((JGq{A_x3R0Qh)W<S&CJGMuc%ZAFiSIvlVMwSiyI9qG
zU}92dNXW<ESLbAskEOY8X8!Ner8DH?XV3cC^&_tKu{R;1BCD0G|61N$?qft~eLS2c
zxS@O~3uH0m*7AKT>LK6A_&EwvnK9KpG=L!?AL}f&ye@Apk256X<0;Q$#r3nLy2{d7
zDLCX~LV>9!zKS=RAvO3&i`n^+7T@H(#wCV?eDwI$_>zn)pN)b;KK|_X@sPX)p2Cn&
ztMA`+sfz65HHL(IygVcMvVO$XK3ePU>i?%WM4X%}zlmQ?OkzaH$4nzf<dSn=XGmy$
z40Y-EQXZX3W|SN9alxuFv2qVhVo1!#lOxRJiRczXLOwP(o48g+R?b1eAs>sTT$mvT
zpT>}ok7s7O-I6z#@eB$1_^`mBOY%BV!<>RcK2EnCX(#vPe1?SVS?_%2?|Yq;@M<5Q
z8IahIqkQsbO_8r-)z<x7_g}-Eu<u*Bl<YB09-X-i3Hi8UTaVXrTP8Ck<YNP~F)L-H
zOD+ly`8c}rhBI;xEnrB<$I<5pW|gZ<Wk|@!EiEIG<hji~HwA}$9A=$zL9TKMLqa|d
z`?1zvmgf~iLOynlbNM4z>7IvzLq1Meb16+;AD0pm>hxM|OYW3!9i=iNv_8gE%C=h`
z@K$*Zxv}qC#n~;IEsxG>hScCAZGne(da_5EHI&B;)SJt%3<>!-b!TXrJQ20dN5LT<
zZ|3^_TSjhVNXW<6juw+-<S&MVe6*N1>AsBg)_q{;ze(LrgO4;kKdSZ|tRR(9R}art
zhJ<`vSp94VdAiJ0fU1OiJnd4siR@!fLPBlnpTYWTVO?gWP<8Hoj0pMI-MXTQ%Z&L7
z8gko1vqs*&r6$RW_h(2A!Ra*W^6DWI<&D81hJ<_!TXZ&7t};g<3J&@B^-KFG8QFy)
zAs-{g=gBDt-_DSbk7s5^N61zFVn_`>((rs<*`S)Nc<aJ+EH(H@ikt5|6`-t-3Rd0f
z8yOPv(S6^fF|v<838|rnsK^G-5BMqnQf_joi)>?I$gSlSl7w8azuOoq9j<~Aaw|hZ
zKDKW>EK#3ZU8O}4suJ?Cs&fMqFY+49kQ$C9_0al&<L~7vPctOsV<GdsbLF-yQj~&2
zK7OB{;H1AMs6Lj%7!vX^C1r%}ibw|CrSAW4qEieB`Pe;fYzY}@QH+9X@R5dRk!|c}
z89A6CAs>H+B^1^VkNW)aBq5;zZ$JK+k6fgM?poo0TMg_dBWs_2+AAXmGbH5WpP7S$
z<mXpUG9={V)sKzO%e$B2x<=3khkUH<7x+W&^a%_J4bOqpXMyrL&t-;$d@LJPeYO0!
zf7y~09P+X9;~BbFw<<3FzmH=X67unKd_o~P_(g_<eC%0sZ5jEBdYMub9P+WYQ}|ka
ztE+vSMo4IM)}FWURi+T-Pd!`SVnk@aYUkaos(#W?Bdtmsayvmj#;yyhDOWj}At4_-
z+HEwKPf4#Zqy`^pV-S5~(MsiC#(RIOG87#0F}#2FD)O<M#*om6KP^&XwtU4Pjv*l*
z6P#<lljU)-q~MT`J95Pyl80vjLqa|-S#flNd@NHK67tck<v=ezQthK#SwnE>P-d7i
zWV!si&&7-g`FMAz-+29`q4qJEAt4{9onPuJ54dwV$_@FL6rXE^T;+U*)Zim+h(5-R
ztt-zO$qWhkcxlEy6K&~Go`OR@T7O$HT;D_L;hD>jP!nxjwX%_nOlC;P$Ai<)6j$ap
z<xgFus}%)@d|bBo=`eYCmM|pbW757=H}rj}_VF1ZHRPr_y`INdD}`u$9jjIaLvHN(
zoZ<bPcIt~%AIgOc3Hi7vu~QxynZl5ek4HQ^rOL=U))XA_(c`02OBuO{At4_(__&72
zJHZzW3HcazV}Xg!cGsy$!66^FR}R-bkuB|47cr!UzNEP==+gYn^07=|NXW+~i*3fr
z$U3^0PyBa=f<2$}+u?0L{TYhd$3=vMik$Up)dW3JEzeU%gx1H4t>^j4^N@38LvAh4
z=g{bk9u~J!t}>V*As?HTunLor_ZbrMvBK2-=VWB{Dij>@(Xn5z3~~?6U`P!<(hR&N
zYU3Ma_Enw<P>=XshJ<_^I<e$moH4RSRSK@bN2>Bw*1;E*CD(YJ2xdsA)pOrDaY;Uw
zj~EhK9}DiBcuv2`Qv2v+V+alrZ_K&<RxWZjBSJpb&Jg@T-ugdcNDb>FjZTlRxdtm&
zfQ`@0oU2i84L%Zb>9Sdi<N;s8kdTin8{H@(FB7jB67uomsfy*~;i*@hf@|=R=C<xn
z&fb)fVGIfRnAYa&Q5pG~AvO3&Rhq9)n;{>|1~n)+<m1Dy!%N9khA|{$&*Jh`43})x
zKE5^}v5y&_{xZkJHTrtC`rI|K=W~8^*tJ?dn^?k-8hoVDnSB4rVj20GAvO3&$g&Qj
z=E+yv-0dhh<YTWUC4=SLaBCS7@-drthd}wl@<)c$;3G{$-I{N0CQn4IbRQl6ciUFe
z7V<GX++~>ju7wQ@3Hg|--28a?SY~mcDj^^LIT<okUMGAQ67n%=e)Lei;%Xmv5K=>@
z)98dx7?4?h9w4)$A-5g0KK}CbT`hNd4~EoGCCSsO>ydf#p*+EmkdJ|bH>{Cwix+XC
z;E<2WWe*jV=k)#z3Hj*UVcK=MEsrpy1|R8I&X{m*r2PD9?wS-F@-ehT-;OfUmmwh^
zuYUM8%*2Q@B;@1gpq#!kvWPPUhkTqCb$P$MUmZ?Js4Y(nvoP@yt}~1X`PkV$ZMxh;
zC0q=-vFCGYt(axv9TP(t5(<9R?8-!Wbj~rP1|Ml|TTygpS!K3Vu<A3jQmzzSgO7wP
zl(;%nxjA9{CGgP<3HdlHDt)1R<Mj?hLOyO<bn&=+EFEf5aLC7TlY4xVcSLg;67sP`
zN^ou&naq%okDHndp01yP)$5~cZ9{MkJw&tRj*o{-ya#$7BSJoIoNLig&i#ZTq4lvq
zgKFtAvQ{0+4f*&za871<P7h^B=vWTg-Mf=q<tv8N;3ExB$p^K1>L*~e;tkv=IOO9N
z-z+9>!-X>><YSH7AOFa~-!LTP<IN#UyUWN%y6^1#x2tx5d<?wX{jt0wTEUQzk5!ky
z_<IpTsZ{ObYeGT;?suqdX?bdEP|uJXdp;-Mjj{FRL%ED0As?R<Xl~*MJ?|J&gO9ZG
z^xglpg%aHOLBS^VDLCX~Q@brD-trU0kkIg4cZ@r)oK7fzY9GHaB;@1Bho$`F_0g*V
z1&4ghpERSrewk2Lxtk#&AFWSB>E0tJ-9pLgPE|raj_RD2RlfY)i6J2$%ebxFE}uVc
zBP29BCj$I+r`*z`hZ!3ha$`T?n)Pm^ZvB^#J`4%@_`6bxXZqag0pH4y8hoUc=Ye_N
zPV(qvY(&8!AJbdqX(U(a&5)3f&AQK>BA<(IVMu7izg|o>aa-KHF$ITwOuT2-Q=Zhj
zFr)?_X}T=&J7%kLER~5}J>q*A67sQq_4b40;mP4a!66@G-}W**il$y4dk_*jl((9i
z+scdCeny1$tBZ?&HL<zOrTcNpe_IXg`&QXj&FC*H-iIL}A0yi2T_g9<L575U{BkzX
zK|YrGno@Ac$FOaqO+50`pCKV18&B@I-9&JPgqrA2=SAW2@Z@Vo!8Q0u)1_^bEeqw1
zK|h9sd|Y$2UN$-SDTai6{2sY?yMDygJ{D_k2oB|r{F2s2PgKuC!x<6saaa7!(K7Np
zLqh9g=DE$+$WQf^YC*XnADguCtSQfyLl_eB@kEohgXAUmG($o@p1=QLj9g`5PYMqC
zxZ~ao6VCz<W=P1#SxKq;<tmRdB-EGP3uZheH&KC>6ddyL@d@`ga+L!a67tdfM7t^a
ziAe3^2|_|e+JvMnmva|vWyp<v-|EcKd?p@IAH<Lve5BpW$=1sYE4h_Q)w9MChJ<{4
zHKN~5{h?GN^R=enkdOK5pER*i@5hjkj~_<2|02)nhZz#`aq@#i6K{$t(1wCTK5j1@
z-$uSRHh>`^AAcm|J|g$!DTahv-9KTziKiBdwx!^Zj}{BON9$)`wU5IH2@%In>d-`<
zG)^)iv_AT$|9&B#^H{Vq<aX8IBkf-9rlhQv2YehuLO!;xoU^3-Gly7)gnYDLRUx~4
zrNqvQf<rzQo}c-le5XBxAt4{bAD8ryU+J30kdTkA*;l=lt8C#-!66@=JRQ%;$8rlp
zLOxDQd@)i+nzg4YA$v~ywC$*$HPk-(8j#q-->1CIkIAERlo25xyV*s|Dydt@lt1;#
zQ_M%7+Zp@5)u;>ayyQbUg&{TgNK0;~gaetB9#Uowb(IMWsli7=#$1T}`+*1rt46wZ
zpx_#OB;>LUchVG`@yAmm7*d0egbc4&w6t<8je~z?NDV#`^7rzYHI$P*<7?I49Vs~E
zV}@R%oa9M;7ehimPED=SUAd2Id@na&C#n+iv1GtQ6VI=XAtbc&^c?4Ry0orH<xky1
z7Z?%paX{V*CO+|6t+OFF_Wqm(BO|S3AA=ZDgO9Z2M%QvnE2j&s{HcRKV@M4?5;Dy`
z`KDZDt1c8=gO7wP?^(cCMs8zB4L%ZbL+ee`<?kb#ccm&d_(;f<@3ZsBRSsrI$j5wX
zNju8whDP~Q56?x0gnabh_-U|QrCm1)4*9sTq}vevNsoGc3?U@cmJgEK-H^8$PZ$yM
z@j=s;zVg)O-rbNJdp>9IwzLa!m1`Li3SKeR@|(P0&DevggnaaQGikis>3tXy^3f-+
zZ!P7$C&uqSIm?ickF%~lm@5yDt?to-e=mPK+e1E{YuoIxd@*z(Lqb08Za2xyQWsqL
zQ~Q|8kdTkZmo2IxkGNMa3J&>by>OUr82-Jrr}l9_A)y{x_3B`fykE`H+fbyI_vg@T
z>F;u=ocs*5FGFfr#c4xSVr8az%Aqt~#ZNM%1|JD|aB*ZaWw6WZ{?r3rt`7x=j%9<G
zlC~9fIOR``oXwDskF)cgE-w$y7lwp<JZodQUY^^$`%-Yo$Ec#Q-Q_CxG9=_<m~;8U
za+Ue|QI(L7g^!G|mXX6567sP}{+Y97AFmM-8t|OQu8)zYwsO9P+}QIug)fa7EF-5f
zqy`^J@k=+?)Reax2@I*hM?yC5{voT3bkW`F{BN0XgnTTuKQV_KJe(n+;VIGh{XV(M
z4-5(UcqQYUNLijX11LD;V}Ximd&-@@ogpC~Z;q?vFISmsAXN$ZSl4V-L%GU<3<>!-
z%;v{1`FhR;LPDdHkR!;%`dE69AvgAX&hUaOKghW!GbH5Wz?*R$<k3lBNXW<W8^$!1
zk<NoDIOL<{to}#k;7b@1@^Q79V~C7QXGmzorzPC4A_s4$I~V$IB65O!Tv<M#m0aac
zhJ<_^oR%+-Jh$Z;N>xHWj$O7Vzl<EjkdTkFvJP6IzdNDcubw9)bSV8&N{yC_EHTWG
z8~aIR%xd==@_>(LNXW-~cOPGqk+&HV^6`xS3wybT?1oct$j63xk7SgQ3mFpfu|T1N
zyJX~BhScCAZPeF(n_{aVjW5}@8bQG|G!Y@aH~&7aTunDVo!HKhkdIrVvLBFx=Nm~?
zLOz};RoKK;r{N3<`B?h>kNooe$E$>da<B36ej=aUml<Wqjom^in~>eamujXlB;;d@
zZUs-vqw|O%HTXz9Wc74?Uj?azSD)<F9ZkU@AD`6-Y9v>=k|7}<A6a)TB~L^@8B&9f
zv{4UzUumCQWv4L|T!W8<OtlT2B~R)H84~KtV~%Ho<c)fvu~a4G<8tRhYvp4(iXkB%
z$Il&_CZ9jX5)vx1-qWT7<s!?EGvvme&zaY!?QeN>rZXhu<3aQO4)W+cU`P!<QV;EV
z_0U|t7+PyQ1&4ebACa&@zQMJEAt4`EoNLlvmgf&cLOurWuG>VOfxAzj;2M0Sxoz+I
z>Aw}E@sfL-At4_pXZI>A2QNL5s)SnIsf2Y?xrzK367um&_PU9(kM{`)5$}wRiI#KM
zm}JQ93f=GUntkG)j9kEwkdKf56dfze^M)ZIA1#)C@s+D=HJO4#KJIO?b-Rq*&XACg
zV>|4dBKJ@(-Gh_=o$R?nK4xyU(owE*5JPJ4k><9!4FZ45!*h`#As;)8KU7_QsHBP?
z1&4f`V0*ffJYCLbNXVX9b-XId=a26VNNh3tvT1B>d42Sls?Y6$y+5ZzRJKd<fUjdn
z$j4>{|2WCWOw*`J$j6^Kj*XLp_hLxMNBc`3^UC+Ik256Xqs1yu6E`QUr&DmqN3W19
zCFElnz>tuSpSyOvE+d~ZB;@0Zs^4Q}WWyO09P+V3gVHDE`;TiG67sRckw>fK^)bs#
zLzPgce_!VoEKk5484+3^3-$E9A#aEdFeFrE$Ld#n<k7M4r`(W_4{z?PBqPT%B;@1S
z%UAEo$MQBqLOv!O9d6>Q2KKWkxCS3-bD3xI#!*Ue;}hqF3<>$T;>^zo`B=VXNXSRa
z{+UeNoM;t5!66?<@2sCBSGk=bAs-9uE^Mj))wKHhYOX*-l~7x@+u3`Cyf5g%h>(wq
zhkA#}xlc1B<YREss~qx%sB94BhJwG$^d+x6Th3%i4L(w*w|ZW<ky2$Dqf10j84~jG
zSm=&T@`Ln^gDJQMA8B)G(dpb(dE2&%At4{%dPaE4!;?vOyZql>wTnIE<FfWiljJJ<
zFeK#Tj%pj<$Ri%ZkdTipe@xmb-+!z;#}FLqp>3th4^|#gu{P?VX^g1BM{3K5&Fq|%
z=esHyAzw121|JDo@#TzD%F3gRkosb1`?-`G^6^r;s3>_c+slv|jwN+^yJI7lSn4WN
z{?t|GpGQ?fJ`NcE$i!vF2@DDOxYg@IihQ{(jv*l*N3AWfUY<4V=TmUV$K2(rWK+gp
z`BNXuxeN*Um}%g%`Lg0E3<>!-Y2Lu+^7&))1%}|zfOpJ)=O4vIV;`d!5%TfVff8Yg
z;>OQh<_e)AHTX!KKG5SxDR~P#jv*l*8%I^HCy!1XLqa|t-Mq(2?(|v<DL6DdUVZBK
zmS>G{hJ<`9a<SA{8TpYRAs@RA-q=PC-Y%4aLq0k;@opwpxq~4gA4k8*(OpL7T0~Vs
zJ~qrfa-F<B4k9EpIv4BjJ1uwmNk-J*Bgx~{De%6W+j6lXH}-ui*DM1a<Sp=2hJ<{)
z6?xgjlW2(y3Hi8V(?@GLc<m(=9P;t>QV$;)xr`y95zo2P^MiaL>kC6dK7JnDDo|d`
zyu&Cs<YR_bPGc=~le+S!ULSWdB;;e~mq{tgsf6+Aghe=23Hf+GzR@jteVjr_=uqx>
zbGy8}^}oT0kdMvJuUjO`V;^D2t>yhW$`G4n7&P3m!>fQb?h4ZQ8bl~VLOxblWmZp~
zh~6<I<YR>^FE`2Zv{_2QAs_4hT02CpatA{~J_huf+D0DnJj<v`sEIQ4SWrd|KAa&T
zA0Mw=ZsNyLR~b@+kJLorm%jhKmuuWaRhLt6$j1XOIv&?gMC$7~a|o#+Hx*eZ!O~7C
zP#GchJoJ<iAs?S*U(!`RZ*H{0klR_qewC^`xITBBQl)}bSGkcPAs@r09{48rP_{^_
z67uoVur1x?ZChW4gnW!n99==K@+3n-K8|Z%K3YbWUP-|rA3vWTu|!5rVMq;qNt>*&
zmfI@J$OMMe;3FYZD)!zgBVBYiE&jXegni%Ya<knn^*?1&`xs70sK^J)23C+K;J1tj
z`8aZp^J;m0Y#n9Dt>ybx<YV*s{r1S~;|_*|e9W`_-Z6P}a<8T;As=Jxmll+R4`xWn
zN2dYvw#&nFi6J2$3)-jq$<t+(H5453v1^SAedHx~9z#Mt`mKu(kca0DLqe@Sro#Ge
z@^sl^Ed__x$M`Lw^W^<%G$A44iSaK?JZ$=t5g{L4OVns1_fXe$hTPcubB69qxhKEY
z=_o@&K2BSHG^gA{h1OG*kdNJl2i}rjIWU$XAs>gkf3lHZ-|&zjAs;K=&(y?Hx6e@i
z)O(GF8z?yB<GYU4Ogx{ng&`pyN98FtNPe~==SHd$@-e)q#Wfi@njs;3eBNChDBpj)
zZ$M%Xw@p}K_NlsVWRySk=v0r^=XTZdd=4#U*Eag+Rc>h--<(*-kQ(-@wAFB0IqRdW
zc(zScCFEnzhih8PXZOAg3HjLnL%=%uUhWl!gnTS{@6u&?$*r-Of<r#;TbH)RQa3!x
zpL)a>FeKz-ki)l2^2+mxAvO3&P2>{em9DIhN_cgZZMRTx$j24mu5Z;pOru8bWJt)z
zz%@DA$iMH%qWfR{y9LHpo{0{b8_O$?4<kbBW3EGSz4e=Fb?zMu3HcZ{)-KgbH!{kf
z8fmtTazj4u?svmW8GhwYjU3I8kdJ$tr|y!kTwY^H$j34-{a4G#s@o|z<m0uex5~-L
zV1|Tz?7!s4GI`c`#*i9(q!~Dmd0P`NVQRF4f<r#ePdIAgCzY!h67sR+y7aet#ntDJ
z-w6q|Wj??30<t`<b{cZqLq3+Bc&oHLTW(@V$j3FGrdN}ZS$0vCQ1EwY{*f}WCqqI$
zejKwbRaX2cLqa|_8`jRm53!5vrr?l|uQJz8m#ZAZkdTkhuDUgm6^~^|$j9U<OG4!;
zZT3)b$j7$P=PJs`Acll|%sn)|zI^_eOh~AQ?hgC9LOztvdkwj<_vf^}-rq&ey@Vkl
zA17apm@8NLmLVY@e>6CIP)2(0qu|i7Y_ju0XF2$0hJ<|F(m5uFTxFL1R3+r&`9WhR
z%E(>}3HdmzQ|NekQa{d+kdNyxmtQ7NmqiayaLC6AZ6nR)D#tJ+<YSwmCw|KN)oX-=
z2E5bg)-G~x%YO{HvG?cvxzl!y+?G=q67n%=ZMxw;k9u=?mmwh^UnX{aAXjOBkb*-#
zHtW_jNbdCc3<(X-Ij4I&<jah&7!vYvf6R%xa+OUFQE<q|e1)ETl93x267sR>v*@mJ
zUuHT?RYE@cEXvwYMs{aN$j41j8tP6xrT5DnCL}aEYu&Tol-n}T5kqe5{W+2Ka*UBj
zXCOmDKJJLTvPnjsXGqA$KS8m@WMuiH6ddw#_U-FI@&r7cAt4{V))X!w_mJ*nNPoe=
z2^#V0VO3_!$ePCp3Hi9A*u=v!auGv9K5l*z8zuK;8bd-po_KvaSw=QHPQf7`k6+Hb
zTi&m(CnR(zLuLhxmrupNF(P#S7<_n^jg0Jg!jKz#J}1kjtfQ3ctHv*A`G+Aj_^6D>
zzmNQUv-?q7K^i||P~;?43HkUk+4ib@6?i;DLOuqp{F5lp8h05I^6_NM=V`J$j;AO%
z)I`ry^BtF0@r4Wt`M98t^Fldz8bd-pE^HANA|qRzrr?l|_P6i3%lA7r5faL6cCvMv
zT;vZ%gnT?dW58|`KAth;*7AG~U2WU4JK>a!{D&bm_(;g#JF``n+tT7JRSEfcE$rGW
zxyn%t3Hewj{7RsVyupwfe58q}eW33{W!6yc%&7PNw&y4~<m1S@+xp4(au+fr)R(T7
zRo=*ZjrR-*`FLZ?S#NoLY;m4~Lq68&F#er<{<x8lP?2LME;X?)_{xZokDW%pijWVb
zSBxRImgjRwo`jsaiphs^J3~S~uJ-VElP4mx3sfcKW6Qfo7t6?g3<>$@wYu~?8F`u^
zHTX!!a%7i~1bHGVbCH5WKAN5XXd_oSnIRz`myPU_AWuZ`3<<S*v0r8{Wu)^Z3J&?W
z+`3^#d3_8gBt+a^c++$FP`+eD$j80C&A-Y>kIRPK*j>_~Uu!GKhjJZ5LO$j<YrR@-
z%S>0OO32566^+Ws!Migg<YSGVC*I3d9$`qx$L$u!^UI4_k*gFO^089Nt~fdP1cros
zykNE7#LM9BFr)?_X=C7SKf9RnjEeC|kNq_Y4%riYsN*F0{4rdQbkg!L4b7IH_Kh7U
zZ~b30BIIMHH`lYsqth(*zudYaq3bydcfGNfksBEj^07yw(I#H5k@-4R3HfLp{Wezr
zYdG~zuopu@K8Bp!^+*nWkRc%-=ZrIZA&+?B8x$P!vCsGSChk9uW=P1#8@D>`m7lV`
z&XACg6?3-9ZmILp_@NT}n-m=Ku|yGv!}5N086lxgztd%(i936*84>caiRanj@?zHX
zmLWIxeXCd5UxX-!Qu$MNdNe~qKIVDxFi?KjG|z3S67tb)@QH(R@bL@@`8cE6mtOMT
zKaL?GAG7#Z=pz4^-}Vj#hkWc_cbk{;3v}aeq0DAT4L;IhcIi~dzn^nZR&w=-r!%Am
zA8G07TGuH_o`~AUQE<q|zPlFXkk`kZgoN7i$_6JB^H7$%h9a@&a}Jeu=qC4&FGE7J
zMyCfAE6d1}3<(8a>M?noyb~-QPr)_#NIkUmRJ9=GN{Mj~jblj2$II8-n|NL>jv*l*
z@6Ns5MQ%%ndlVe<u}ILg8uICVC_`%Sk>qhm=rL19rZObt<LQFgC(9$=B!PlMKDxZi
z8z--i>j<f#hbVVMO7%1HZ25^1HLQ=+mcti!8m{cIltEWdZLRJbayw}7k&qScg?5sW
zTNx7a(QWncKzS!<_JFF?a4f0HN55(um#gf@kdTjg22HCY%X69`HTXzXHux1VO0Lo}
zk%B`$T4s$m@heR~hJ<{aTdUt_Irx2sgnW#)Za7^=x;~`fkdMcAoS3RVLs37!8bL^C
zz;lkWzatm<h7mRRNQ%Gy_|sXQhgv)`<aX5HBO!Cvd|~3zifD#}e5^5a@@07<%KVtB
z)ZimkS>spYE;)EthJ=P^NADw7<l#BUkQ#iXDsNbn=_?~Gk|;Rj<D}vTlV#)>hScCA
z%^H0?8~wfGY`oXF$&iqb<1QV)Cl8N(G6jcx%)KC@i|pe9LPDdHt=!7`@;&UQj0pMo
zEp=cs`82B06GLw7{W--ql!}lSvvmv!`511tWxG5&8J<#=kdKkwR%VuicV$S($A(K5
z9F>RX2tz_6{%2h8m-36eN<5?BkdG%SEH5Mf&}<q*YVeU}jggBgSjlH7$qWhk7?3jD
z#D29-3I&IJJkj*s7X75IULThd5;~NhpDb^zKO<FdF5fXC<YVc6Jqyc+(&M=yx0dH~
zXmpxQ&2>OVu4YKcN1N;?O+2mfogpC~|9SRepEAQMf9hk|;ROYUd~9UX^zUU2W%W@b
z_b?>n<E~RJhRTZPdr4J7O_a-g>Pz`z=m>^{d|dZE_i1^$yvdM|j~|nI^^%d*Ur}(#
zN53JB-s^v@sP=IVA)(yCNs&SFoSwvpkdLjp`kT0QRR6UhH}-r^u_kXb%Io7whJ<|d
zD)QsD+?L-N67sRe=JQwNw(Oir!8Q0u+qT`$mu^&$#t+jRWk|@!tp$2-l1IGs8>$lW
zalw^(`DCOYLqdJ&JO0)k`7Y@LhJ<{Kd637%tl^eM!66^bcZFw=_p4Ea)KDZ1c$3H|
ze<imv=;{gh6C*-C+FYyTEN_T>-Wqaic|M1#th~DA1I0&W(A8BQW=P1##dp3Pk$o)k
zj;e%wbPKxJQhp)Cc!t#ABW(<tEUfiYo`@bXB;@1fW_^!W(H%$SPkk)wyr<xhj|CqO
zHu18X?F<R|7&>s+S@}gJIX_U98d{x>WtMCoP26f9!H^n!q`r)d8aY_;QQ5Pq*T-vw
z)Ig*n7fs6fM;>sibVF|J6(IGNog5~&<qU>|uIEfk`&C)4@+Ct;K2~zQyjecy@%Tu=
zAs++VY)F@pn;8=FvBT?=>GG_R>l0N8`Dp91!b3imLl_eBu}#E@+w%H&ks&qsNSz*Y
zWbysVx-PG3G;37)Ou-=^#~&zPubK|0{HZ6Rr3?w#lQ3s%dwG4#^+jK$9kiI$&wu#u
z`yQ1+R~Olv5g}y8mgQf`+qTmT3Hi7^&GWmAwE9Z9As?&tE^|>v1~Me%<CKXdC&<Vb
z3<>%8^Hb{<GP3zM3J&?0uh|YW8M%!iAs-X>WDS#dM0vhbl^T4cb)ub>%Mn@eQ49(B
z=;^iG#J9q3FeK#Tz%BkGWFKvR7=lBc-lJ>B=kh*1kP#st8`(IWmk;H0hJ>oj)1-@!
zT&2fP$_@Fr;If&C-y}pcB;;e(3?CNAi<#LksuJ?C#P~L$GI9VzLOvEW`(t9sy}*!=
zkAdCRM#+j-`c1(hA6MVn(O3>Xhan*!kFU?wSw_BMNXW-~m3v3X*H@eWF$9O&vYAKD
zWcg68WkkrwqTS5AWMq~MdH?+lt&^QS<fHxguO@zP<;##z@Xoz|c*%;NV@SwHn+%;F
z$`g@wMhXu3`1#b5hH{kw3<>!-u4T*!8JWV6kdFnMm&_@j>@~?m!66@`6CysyRc>QQ
z$j3ZuYMqgN%$=F4gnTTTxa){~eRU`yp&rT?xAcKr<XJ|9e5`WyZV%Z<t1O1xTAt6L
z-AmEU&d22{0~r$X@ki&NM7hcohSYE@>6~ZhuJzRwq_TBW@BN!*rQjNTB;=m`cGH!&
zQYz=;YUCD%gnW!Eb0Ssl^nBT<O324z|J<A`AIp&p3HkVZ`s#i17WfuJLO!l7XtPtU
z(m6W?hkP8iWM)-)zq*W&8U~y?y@l)OlJYf(w~Pq+n5);p%5v^@W`^9@^Et%_?)R3F
z`xp}P(W0VNURiMq-6O((U!Cb>=cvI)I+pu4Pi!HtkK-5;8lFmr-AruM?=U3f<HR*}
zO`M_BG^gN@k6ty0?2?aV1VchTetu><Sw?<gNXW-K-w)Zz!_y%r1&4g}E)_dMULOw-
z5*nS35$k`+xpU_-6p6h*=g^;3Bjnx7P=?g7UuDb0jD!7^CBpctcsCgm^3i#@ZIG;Z
zt=tqG@^MkKA)Ycak|7}<S2oZ0P+lf}GbA+Pb%#~oFRzci^H6Ze$2zsYUXp{KVMxfw
zKXDgw%E$_NsY=MlS5*pBlaFN(Lqa}w+?Fp*|1^#Ie#dJ<LWi<*)+HuBs$M^zA$Lt^
zeeBu3^eTD4*D|CAA8F<JI6i}iJUW^4Q<ad9uQIIdBqRGVB;;dg@yZP?b+d-@r`}w~
zFeKz-zu4!q<>|6|0SXTJ`09Inh&((C7!qnC%ZEE_%2mE)NXW;xmugwa!_&GT1&4eL
z$enIt>DkSYkdH<DJ_pF}m&;$sP$iUman|3{<wMzz5g{M5cJnVQ?+eZ`B;=#p_(9p^
zDy<4rZpg<!*GHSU-!Y3JAs<6NbjT-ndJ02AKKj?5dQ?80XktOZAs?50?>tnlatlL3
zJ{~?*dz>s!&LUJL)R$!n^gkvehcYDOW9pq*+vN2zmLWCxNc*-XURQMIOBwz?qoZCQ
z9f}%)Lq)z_6ER30onS_Ud~}YS+gLu7FBuZ@@ox7hI~m!c80Ch1+`T-yfgF50Lqa}I
zw8{C8TxFi(R3+r&@}z0=WaJ2jgnXP8p14>>-egF~$BOAkV&yXw#}X7A@^Q+B`5$C?
zmN6vM>O-pf2FSsGF{B0`Y2P*@A@Hbt{@A0WAvi<~Ub(HQyz(4iM99bW$=Q<R=XNbh
zQIU|3ZZXqL9LiA)3Hf+@X7ECJbZ#>w<l_RLJ$Gbe&C(Pc@-g6j$)fW5xRfCwACF)D
z6)itL^@AZHAEyqOb6?q{D}U;ZdY>{B9P+Vp9giCF>l-dHB;@0VOO}=8eVc<NRSDU1
zYIpt0@_u!Z0g3&Xzjm^<xBSz!6h_qGBU{9+x27snoAKy0Dyz?JkG(&~clW103eFh0
zi6J2$k6A5wpj;j@zC@I_990SVxU$5_OBHlT<xky~Qy3ER@tJMs*K!ZNU`WVEk6y2)
z%Nv6x<taGiW2VdhM99cZ3<>#|^+T&DId~2$suJ?i_wBl)a+L!ZQiG4w>gffiw3PR&
z7YV6h<so98%{PB3MJn^Ux`#?vFyzJ_!3$h{+gV<6r!l04DrsM^Cgbj(@-p#=At4_}
zgeOgvk?z(M9P+Wv`K&|b^>G73LOyn#6Ek0~GJ8d;67q5H@vl*GTMlAK4L(v6&2g}P
zs_a*lJEiI-y3CM}k0H^kAIQhjwh{%0eDtg1^;|xdix^UakJOj;Q@XX3_p6@>si7_D
zQ2yGL;kJ@nDO7zZJu4e>V@q!L6(#P;xpy$61|O-)0a<cAlxL0nRj5i0!Rb&A=-lR&
z{QbvK3<>#IxSQ4AxlO55eJtY{67um=l<jO;9@nZA9P)9dS?0-d@Z}7t!ACll8@GM`
z`w)b(D^dr~U_(_xK9*QIx`!ORFGE5;_H>VlmlZ$9kdTjcg0q~H?{`$JW(cmKhp5vx
zy#4X_=Do3xQy5Xhew9XN>$MKw<lGM#QiG3#-0|*XOBq?eI^~9Z4DRDwP#*BL45{H*
zQkBuUoyW)%QRW&{CFG;+vSG92D<!@R3Hdl+&8Yrz@XHJd`S><lnJIE`8(Rtv`B=bv
zn~A+f2t#V{ky<^>-zu|GrSYuso*^M0x6ci(AfG>a+ZlpG1HSZ>?`pZzH!&jQW3{86
zi{!1pxjhvL`Iz!;eiyli1~Me%<K))=?3R(27!vYv?&F(9mEl+Z)XPLw2MP`i&-3)H
zGvq1*84~hw;pY;$<>7hGkdTkdM%<bsSLxwM!8Q0u^2A^0@2nt=x4_X13Hdm7Oso6K
z+-Cg#RWm25QiG3FWw~S*clrErC?TQI=^N5+o$TXjMudC}Yva;PejBG%O+#+%{W<4O
zPq3Gf3m6je@#Dvmb!6mMhScCAjn3`SyACP+W2yU7``Fu=f<r#0484^mS9yUUp%EW6
zG<a!QU4_b@x=MQ&s#1fG6nsRfqkpfBRWw2_XGje`(q5y{Nbi1f@a(Qsr3N1f>ANoX
zJWE}L%AY#;NQTtlBO%MjEQykT-w{tp4TqA5g}*gFA)igy)-vSAp3hm>ru!rL)=@Y^
zYFHm>z}NM-Z>@}u@znO6At4{5zt*cJ@3H#Urr;WUq+|K?x5sJul5Gq_YVeT-&k$5g
zzEa{?hpN=zBOwca=%22*sN79Zx8*X1gqkR*)#26ht~#R|RSEg{u<{Wv`C7FvLu&Am
zf-gIGyPXnRX(V;<n+ys0xMb3*K>7T!c3neoD0c_v_(-`e7cwHWKBn}JJt1$1(iu{N
zkJRZSCs^;1@5;2RN4YilNTXBaR?%NdaN`ZpE{4?LBO!MtZknn1SjlL>3)ZJ9HTX!u
z-!I+oCm+k{45`6KLiU)mVYR%ue8iBDkG<Cv>LnxVH=y89Uyi=KCQ%;oH4Lf2M+*M<
zPpb*?b^kvMsli7Y@ho|=1uDPqP_D76pU>%`+sFR<qXc`X$e~9wpO$m)XGF+H&#q+$
z$hiwPq#_|7uUsG1MMjQhNDV&H==3|YZM7Wy7DH<Ak&ydl|2i$pW7mj+Lq5))QL(Sw
z=?fVW@^Q=W9*J_5?->&Eu|m0~W8^B^G^XH?j~jNBXd)wbGbGgNYiGPOu}&25pei9B
z7k4T9_jz)~Nwtq738{fdJv7F(#W^|mc}9eM%-?xU4tc;UHZkPJzHe1z#{5lkm4OTi
z`B;0$?zuAZIYUA|zH&{<AtReMrQnc{1()`UmS>I43<>#oG3~}%d2Y+zjH-lu%(`$$
zf?Q>PhJ<|FmyqTsS9y*hAs-!mj<u4J6`E6U$eztM?=s8RR|5=42S}b1m7GFkdG0YH
zg!~wo$y#npmlpcm4%qWK@tf;rm66LB67q4grOO97_;-ece4M@Kf0UhNSQT9thOxm8
z5EDhkE<zOS?(QxG5fl|W5Cc&_MHCei3%k28un-Fnu>(a>u@zgtGrpd))_kmUUGw}n
zKYV}O?|Sy$_uhMEHZyhi%T@MlL%}upNE@P>F$Z5MS7s%3KlL@wQHF$ktnM^puUusb
z-C2|W_E`4SHTXzX)+n*%opMu9+5fAn^kqoM$FjByuE|v<F(l+;(?y{jWFH&1qu?5R
zq~I1cpN)|3udXK~v=dxDV}1?!{_0mognS%Z{!%WvDSNdy<i@^lb^XVZ^D^=nLu&Am
znzCJ`shJd{5?(!qiglnWAs+|)4ma`)dn!X}@R7DJs|(~FCtuz_U`WWvO*<<!mM5Zy
z9Vxg5AF0aTZFXjmyC<9>As-hvdsIbUax-+IDj^?}P7eMl2k+028hoVSIbuV8>EF|>
z-mgXyQp2z$VxQ|%jO^1bI~#Ii=X2h97w9hc&IE>pW{u{a^=ryad7B}j;PE$lyUSJ9
z>O#RGA3s@?>@JU?FouMDd||cC$hY6WFeK#T7k9Ira$9!mO2Hu?n<V|1B;Q{>z>pez
zr0H_e!Jdbd?kSmWx-8O-s)T&BY;kj$T;*hjgnWE6I%uf;zK%zPgvQX+arc_Z6R=}<
zLvCyfd}YsBZ+Tx3#*mPY?cy7)m*x4!kdTiZHas$Ny0}*l3J$g9gK{;E+_^l)kdTk-
z8u-taw=czdQk9U8v)3H0Cby*zLqa~fI)qG+2hl@@)Zinn6UR)WpUDr+8ug;!kdJOz
z>n)RmM=&JhV~=mS`pVBAv-LJq33Ygr$9L+=b9#S9g!ZcoyN6GbC*Ttd3Hi7@ZK#p;
zu~;9<4f!~)R<sd$CNm`DW9wn&*7C5t$B<C>c+Z;_Bafl_eJMEP<CH2VZpzbTI731{
zM$Kv2Nv_hQA5{tYxcq8AZ@Dc8G9=_<(=oP{<tooIB;@1r_xoncKHBs*1c!R3ccw-5
za*<OR5%RH7)3$#<OR99b`pWD9Lqa~944Jq{uCm?$$_@FLWMS7<?(j7X3HiA3piK|C
z%8Uc4O326I`78#@RSsrIsK;}h-ShWszEY{Wd(JZ?<YQ9V@~h-3%MGI7kdG;5=aS{N
z3}8qNKGGKWmVL3Q@?ED_3<>#|zm>c0(WQxr@>5?wwjFE;4mG7|Ozc8A_c}(@;3MTe
zZfV+0&Yj7HiiCXJnyJ)ldD}LGAt4{nWZd}ofMoh%d4VAzA3t>{@250_@>7rW@<S*%
z<YV;JR!(yF%w$N&$HN7(K9rG984?;q&tqJ!$v!r9rQnc{3$7pgE$>%1Go%I|X$x$z
z|MX!wcuqH}67n(ReAX-S-&+kQB$V4~jJc8CIm?I|e5Blq+jYt>%VRUtkQ@8H)$Ti9
zALKojKSM%37Jhy|r`+Ms84~jGvDt?h`O6rs-6=Taqq*0wxpG@>W=IV_(sXIFrRxdh
zpsDh84E3y$eHc{<`FOx)?J4=t<phS*FfOUe#vS$!kk2|jU`P!<5^_k~atCGBNPi-$
zwFd=<d~CAr`T_a=>P|vJMUI|w?yo$`jVE>QWb-r>Sqt(p)7(Lm<T2#VkkI=0A%6I1
zxx-@^67uov!>D=kg|qE&3J&>Lrg-8v8M%NVAs_cd->{S?qSp+m!AF`dKM$U3A|u=C
zo~8YJ{#Z+ck2KOlyEKbb=C<^MXa_@T@R6$g?t8JlJc#mnQI#5oIw9AsOEt11@@7cL
z$AI;hO3L?FZx9k9cFo`VrQACeM;dZt-?s`{{b##8ECU!4^6~V$LZf743PVCZPAbsN
zR$k1SjiTU?kE1=mb(WFq84~g_&h~nHxqD1TQ<ad9XR1!?C%5GQhScCAjr3X0<pN}R
zA{kPHkED3JpvdNm;>yW)^*T|~n}S0={%T*u$ctxZF(hQqpI<F@$oF%S4M+!QG3#<}
zNISVH>yFXqcBl>^tNh4VQGU*|h9Myzb$>csLmrly$5NG$k7cionJQQ5!jO=Uf5z3R
zD3A1LhJ<`H_k8+T4qk2?1;>2sGUc<3^k+!OM_-S$=`!*;Lu&Am6z{S1Qf+x$HXl#H
zAs>?ie{GPf+`^EMkNLJat&{hwW)lomLL>dy>i$FI+=Cbq^6_2G(b?qd=Cce5RoP*C
z)J^#jip@mI4f)t3?D{J?_$-Emd~8zOdboT^`ivnVAB(<ivr8UBttL@$$j6%@SH{Z0
zw=yK;W4^4WBjn&YCsUP>k7dgqDJEArk|8ztNK5XZpr<*Maj9U{OKu!PLOvcCGXH>l
zf7O19AviQF@3b1aL6&C@BSJp@sM6!EJceE{B;@0;WsN$>z0-0k<%WX4G|x9!Ms8zB
z4L(wbx108=iGoya8mK!wmk(8`!AC-7-TbbkJchg&67n%;=Y&u4Dt?_IHTXzX4z%=0
zkgp%BPNU$Ek0B#3_SLUE>b4AFNDV&Hk~?@q@HshnDnmj(E?oIzLax8P{r}H9TKO7+
zYZyaRq{GRdu5yv97!mR@HRXVjlP^CQ67q4y%CH&o4fQ_LDL3R}c&0~A@{)U!A)&VX
zQYdJ-jI^3TRci2&x~J%h607A|V=6;x@R8(6oqr^Y(v~ID%^D9GQiG3FWyssjM&5$g
zXeI@Re7ySb&whDQ-^h@Vk6~vQ8M!x>WfoNl`RLf_*%|$;p?>~2gpg2&_xc`h<W)qG
zj0pKSe_xuBN1E1thTPcqt!{5#ZYQteGZ+%`ardkH$K^fN6NZF*EOy%^R=NL>{vJg0
z*%Vwu_mDhiu5W*=+*nR8&n|}4;3LU1@I}R6@|%V&{HaRF$BAZDI?L0g4?{veCZx@4
zBUkyDAt4`oRINTvX~*<!*=i02*We>{&(ZJs$0@J=R#r5%k9!CS^-jf3EpEz9nRBk8
zNbLJo1A2|?q-0ip>aB(sLqh9gkEFw?^39i<45`6KYRZW(FEmn+>7Pc`4xr$WkIlYq
z|17`rC7dBO_(<|ZWGOIAe$bOWkgC+s;}m?*xXk0^&E-gjgnTSG`emy8qLLd73HcaY
zb<};iEgJ?=aLC8D-Lw9X72n2?8hoVgv5tP~tbY~1+DG$whAN?^{9Mp$klf*3j0mld
z`z@cXkXN1rhJ<{4m-uF^ygoY3r`#HRq^6t^^sbsb5iMs(4L;IHFVMohr_$l+-%tLF
zAt4{vzh2o>ZcEn%6kLOk6uf@z$(7_Dzr>KxAUZSCGC)RF52h+1AFI|+i<Xf~7!vZ)
z`?+-+S@E9?3Hf+q+jDREe2(ivLvSd!f48$g<swfoBIKiQ{qYUtkzOu@iiCV@`z+5d
zd3_9ENXW<4EfV_6Rla3N4L;IHf82DyYq`o!izqnc<G^V92Qu;yLqa|-sX3{x9K6_K
zsuJ>XcfY}X<SM5zBs4Cc{k&o1?>n9{B;@0{66Y?<inj=*;E<0`BPL&xuOD|35-Rd*
z;J9z{1e|S&p-Aj}j{EVg_vG9j3<>%8qWZVDGBTDSAs^p;x@}|?uep?hLp~m^^u3>4
z<qC#`e5|!;%WxT)VHs5k`PjJH93!74bz?}#$KEBp{_gvgO4U~=F$@X$*tbVTJ9%8%
zhEZ^6sF$tOAw+J=P=<tjw0DkNCHwe;kPxv|(WE4~$S%tbxv}#(k30`K%M<WXhJ<`{
z`4T)#o`8$5pei9Be;2i|k*l1+kdTjQE=QZo$Yh3ud<<*<Ge!>HVkHHKe0<%v*fx2j
z?_fyC$Bz{w_sht9tEfuI$Hg`8?U2XiSccT#BVA6+jLddZL8iamc9$U`dpupo@0Itf
z4Oi=fYq|MCMLHMH)=k;3roZM{#)!~<b;_mzMdYT;xQ2?<;3HMJ$}H|!NwF!1G9=_<
zO2CZ-d8A)sNXW<EGj4B|kq+S$9P-iWVEK)5TZS>D1|O*{-Ku!@k=ybQLqa~T95QBv
zT&3$;3J&===eGGSxh*d<qy``9a$<FC;W!y-yN;@ad@S@Kq>FrBZV4eZjC3l}&hk-;
z+>~z^5%Tfi+_JfqIVk-+)MdRPH}?LV&v!Gr$rJE#hJ<`{+v~VnUd&2vpei9BcVB9C
zORjPzLqa}AoN2yMMm}dq4L(wjzfSwmPVVv68!0&CqebC@1>`FCFeKz-w#R9g<nFPE
zpei9B3oq%CAR{L*B;@0*UmFU@_gC){5*n7rJZ6N-P3gGFkXy_9b7%s7bft`=(&6cS
zT+WahW(`6%+Y*)}&*>(csY)pLfU5y-l|MU5|Bib%hJ<`<^Q+`Hd88*WB;@0O&3<X}
zoL+ki1&4gh@3py-JY9w}B;;d|SH|Zu(sV0T3HfO9qiK*Fd?Z6cK6(wE=Pp;7z>tuS
zsg-gql&>G_ZZiaj#?Y)ix5mn2XbB@i>tnq|2ky&F`I8|v_(*fQi}&RWa+L$OQ*Ow|
z78fVnk*mDGkWgD*%Fx4KuCnqDsuJ?i^?ibo=`w^NAs-W)UA`kP6KM<y`50|G;+%}^
zxs!rJK3<&J(8!W|oFO3}Pe)WTmAj|pE~-+4kF-vVo@;qU`B(b$0J8}Rb@(2)Iu+z$
z`G^rAAKO1PnIz9cO?Mk|W9M_MUFuJfn{o$3YVeVoa{H^$GV+pJU=LLZ`55c)v$Ncm
zlNb`}9<!J6v*h3p84~ib*sNvmjdagm3J&?$yjSOOa+Nz667q3<hRIjthxY~cQI(L7
z!)xU-@&%<S45`6KS|<iL1kRJ!$7h6udS}DZa&6_NtiRuoTgxpXDsrIp%NufsZ)8Yl
zeRNphY%L>m>CV^x_cydPYCt}Yv~hEkeH_b>kdIBe+B?Z@d5<9>A3OD}*F;7(I!M8x
z9v@mFX{vmfW-~)-@R8=WLS4o_Rc;EV|8R-LA*vGc@#-s|e)4niX$%SZxFGdWh|=TA
zPyJNp1w%qU)^vQ_N%pbBVMA~YO-b@ZU--0CKDWDt5ux=l)1Goh#*o<&DiZSXS@pSX
z<YDQ>kQ#iX;N=c9C@A+%0z*PR9$Asa$YNIKC<TXn9I`0GeC4BF=|AkXjv*l*^DKDX
z+{oN^jH-kNkwx%oA9*nw%aD+deQKvYl&gHekdTi{Y`(0PKbh6+I0c7%oP5D+lzyYG
zJ}<YIkWg-~IX+Y5+0y)kp~#w$j~h*ke3nQ0bcTd{ti0vhRef&t)Rw}KkdO8?s=t+k
zw~nOXkdGf+vh<dR<za?|e9WFH*j4t?`Xp5e`Iz-n!xi!j9K?{2k1kzDU6cO`C6yte
zacS#YKTRG)?M_i}$j2;RFXNS$2Bm*-&;f>oeB5ID`LMh`+MG622^Cqhl0{y5r28-;
z<l}@-(~roPQI8oC^07|8dpl)hvon+%@-gv61{XQ_Him?J>@n%0pIl|`D5_F}kF*o4
z{xG19f>bsK>WRpkAt4_pTy6gMMK=mojl9K>8hoTGJ9t#FQYtK&4q5js1&4h6d9hJ$
z1(zPVo*|*3{xwH-FS&cNpQ9=vAJ;ueh?0HuA|yn-QO2>2T;xSYgnZ1h&-JQ|ta9Fv
z8~eUhAJ-~H<fk$r3<>$TGw807x5uY3B;=!A=Buf);=M0WaL7mBdAppIC0DtWQp*#`
zkdTi#?)oIit9ZGKR3+qNa-H5I<tl?267n%IJp6~^qViJ*|HhDzkHem))slk`h^F9>
zJzYo6tRz2wj5Z*#j~Ra~<*`G~UFMR$NJs4bIeTKi7MCyf0vQroA0J)%v0X;KXGqA$
zPmxDn$-%qFP;kh{mv#-zWn?5nLOvF1<M4N{k$!!&xlC0;K3+LkXs<k71~4S#W8~-T
zx8?QmEkkPXk(OM`NtG`t*N^EhoV#A3;2L}+<e)*8HxwV!A4NOCkdTjI9ipbm=jF;?
zHB<?W^i}O+|HzZZR7Ql>$CeA5Zk31SGlqn!taP#cS$Pb#y+*k;_(;8T`{m=mH<p!3
z)f4buhJ<{ab1-0|d{3~@b*fT>k95~*S&KZi<?flmkdTkPmbvUuM!ND-2Y<zo8hoTG
z_nLirByV3j$5L<&J`%EFYOZ1OUgHo$YVeVei;j%0tMs<=QwJ{+M^!>TF6ejlw=$%Z
zpZb2zbV6zvmQ>_;8<Y9+%5#?yHTXy)J<ATCt@3QyFy4^c4)QU}YL`h$Gb%rIQ*L5N
zD0twsphvRexo=RFkdH@}+834E(wiY6AKO2>vP=$sn;{_|8{3cZl!G@&px}^?+sf5B
zBHtU^$dHha2h(yHc}ZdZn^Yy_V>gGw{p8@|8B&9fG}NbUw{5DNUsd+3Y9H?r5*kD6
zeyn~c-vo9@G~~v<Z}n$WCU<#i3uj2k$CbZ^f0dgu(=DnJ@^R?k%E_`kLm3ik%b4N^
z9p(4uTxCee$0U<IU*syQ+@|1=j|+yB+$19xF(l+;v`ybWa*uywNXW->e=-<(19qP~
z6ddxg-~9`(<&D7^hJ<{qQf$Ca<$cKM&*xOUYp4?H@W8jn@5x2_GNOj{k(S(NsaNyL
z@}w{%<m3FggZ9Z)w!KHWAs<i8G%<3j?*KzWK4vXc_KLii6}eAULfz9YZ_b`_@aYT*
z`MCT`*=F*t`UOKmKBnb*7%D$W==^|!Lq3)sW)dYo=!s%T$j1h$!N)7=<WYX=O;**1
zRHX(VX{bkMzOYNaeq2LHsCQyZbSorxcp4)@J`T%1@{io%{T>-|*U;c2?F+tqIh0HO
z=EOyYgnT?7mDN-3aL30~CFJ9xihF(J;A<HY^6_}TU*+WP$&o}=LOp)K^H6^IAiXz3
zLOu@I-u|b&UwzDwkdNoCyL-vVc26ic<fF&BUoT|jF@}VE9OrPXjQqT#{8K}fP*aZ0
zRMcI*VKAK$As;U%th*o&%a;tP!AF{hDmXsRE+e}nQ*Ow|nK2=L@<u(9At4_tJp1l0
zua6a<QI(L7F^_k+$(zfC3<>#I@N-;LZru{0{M5_D7lwoeQG3hV*80y_sF7`+Q*g*f
zkH-DB>ECRsMy_W_$j1wd5}L`#FANF!=vQyFsj^p1zh7;gVh9f9Hp}d>NB;yxoqIDQ
zLOy16?|DuCN1AG6<`+~X<YTX(_~H6_NR8~vkdTi-^S+16$U_VX`RILq$Z@&D^Sz|t
zkdKaiQ|jwCMC#x}7!vZa<xZ11%FaXisgWlb67sQ3%)(nTvd}9E4vov-)_tnW-Q&%W
zkdF;Vb@tZFqYi$BAt4`4z3Z0J+oQgpQz_LD94c~kjr$>TQ_f~Y$j6Tz+MJP*j~Np3
zv3c*>E;6#tYswAzcyn*_!E%Q$Wk|@!V~IEIW#oH?)Zn8M)zoB|mqYgkhmLku{-u1T
zM?HpGzoFoekDl+mm&otxi(p8|$AIzo`^iV}vc07$As^$LRx|QRNjHXshI*kfnGVUf
z+b%IA<fBiHYE$&%Qte}fcZT2)armIfa`NtFCL=;V4k@0msf@hEkdTibV~YgJ8=@-j
zDL3Tfw9f56%g9*_3Hdm_@}s3P@-9Pa@R2s^9)AWel=m8TA1FBF<C|R*AIQi+hJ<`H
zot?9IPTh>5{M56?Q-;*wBTYnW$M)Z(EM|&8YGloi6ddxg=(iEm<n9S&NXQ=NvD-ZK
zGqBpnR09$_{M{xg<2|{^rl0h=Yhvefj#p{EPhX_EDOWNi<YUIKmE-mM0yQ#?At4_>
zW}f9H?*u!2rr?l|8%m^{m62N+67sQPt;wJD6R<jX#x$xD^0DRkmtpc(@%l0(<YPTg
zKR0=OJj#$7e58pe=dX3e<Q^~bg@QvqMrP@{O5U%IV@SxyAm201^gXWj@dhEGkzQ!f
z-e+>|N?#4RZK3rsDs60SIk!JULRCKSvuPwFlNl27adg+6yJTeJZxkHz(PQM=*)no1
zLqa~z9Fp(6JktL#B;@1S29plU+qVASDLCX~*QPmA<Uth4kdTkRCZ0D^Wsx6LCFJ9s
zqn9ek6VXJ5gnYbxr$TXkaJ7#&2?-6$vZ04u<PNv}X~?bR{W&zXg(Z}`AkXOw84~hw
zwdu_ba#N-<BozF~kF<<3vgI!d4*3|-aP$Xxq(?9$<l|@CV;$rwv;3wiAs>IwiI^-S
z2Qeh%W2YWfmdMDH3<>#I$@yJ?j4bwtf@|=Rw!pRSES#wzl_^ub*O<tVkdIR{{>h==
z3jUvugoMV>(N8lL$YZFQN#1{dd0!JdpHtL*fsyOx`3wp9ICS>At8(wWW=P1#J(WAn
zmXWP8P;jU%KYmD=Dc>pC#E_7WWp@mYlb2l6j8rA$<ATif*ULy(hJ<|F)_P@g{W75*
z>1P=d^3i0Ac^A3Ll9?#D1|MmiXg)gJSuc;eN*{)Ve60GuN1z_5_VE@Wp$@MZQ`tiH
z(KfRoH}=WprLH3e%1s%}kdTiRdaODuAIN&ckdTir%3gjaSJ^QO1&4f`HKfi6`A*3$
zhJ?DuDt8t?`A&&xR;m*6(Y#)}0?Hs&e(GV_n;{_|_wE=LDp$FkAt4{_teqlc<R6BF
zd@R=R@hCZXr)<=g8hoTBx8KiZ`xPIR$w=+vdO||IGuYYLQqKL85uxkHCkNfj$jJ7l
zhTK}t=g`!)IQCl}{dKc?46S2G$j4fvmz0o^-x(6}vBaaBBlKU(Rae=`jDkZxzDPd5
zO0IG<Lqa|7?jE{RMw(=&Dj^@wST{6s7q|yQLOwcmpMFxl&$x#nAs<J~s5)JqE=_Y#
za1B1vxJ>Ec8m4bcwT}Y{2{q+O3!hAKk%t)(@^RC_!nX3T%$L)U+YwqHgC;&cqR*`!
z>23@O`M4|kU}w3?lMD&@cz;lmsa&N+E(#9$SmbTLOEPjeLqa}gYuqzZ4t|ayp+R)8
zjqM$|%A&a`IOJoVI%&FN#3m-nPu=6*3<>$@c6VS8xyopUgnXRuclD0EU$xF-2oB|b
z-rdeaE^-nhLO$C6KHXPF#xW%1qg&oE-CG)@-l>?Eazj3@>ASP7T%|8VLOzy={pBMg
zZ!sj~qnDRsgdDtjJ_-)`xZUP~rCjA~hJ<`9bi2}Danj54fFYrA>6<;tL9WsvKLv+;
zjLrAhPeukYB;@0XBFjT$AD<EuDzf9My$9tY>lQHN#=dWLYX0Xt@{$|MkdTj=w-(4D
z-+Xz)kdTiS6TL^u*N?5uDLCX~s~X>pD87XuAs>s`gjvYllfi<jgnTS${U)Q_Jv|u`
z^0E8P^(*8m_cA2pW1sOJH)Uk@f)pGY>h&#K<&cqs7!vZac;Mm9vX4gz2@#(U8r)j$
zodTAI+}QW6F5UJ?l#g+GG9={VnTXf}GV&BdLOvEA_|{QgdCUt@aLC87*T=KS$YBf#
z`8dyJStl8JiXkB%i?*xURc_0Ig(*1XV*%UgHD%;5hJ<{4mv7T4Id~*PLOzaM^+|VV
zM%rYV7op&gJ^Rk?TC7)Gef>DhfW#KFw3P8ij*XpWL}<SnV}JUFd|s|lQGM=O)gd39
zs=n2o!;zYDI731{ZgXolR31Z73<>!dI?q@42P{&Rmc=MI<fBD~c-`M{OUU623Hi9b
z(Btezf-@xKW2U0@m&#RI7N_8lk2ykeKbNZ<&XACgyAF5om#aL@kdTj;j%5FPv{>1@
zseQDxG6aW4dZyQF{p8%<j0pKyF?+a?tBDH?303KF`symV%Hky`H{@eho0X;I-WkP^
zkdK2S2mX<(yugr<kLIRRddkS6B`G-MW8u-)d&$AQ7!vX^?DtG}8F`K&As>s4kFRYc
zxb9E8{(B>REnCRPi^;ya*EC3Tn-@cB@R6Q(cpqypQF-F5ynI&e<2gb?!?J~YyzY-p
zq#|uf8FFLibL`^Fy30?8Co?4Eqi3sj&hje<5*ZQ--k{0s5AqH5I;AN%<m1@x)palI
zlG<_+Lqa~fF7%ow56c$}3Hj)g_I0LQW!*9q9P+X3lS<uW<RXTId|djlcZ%FSFBlT?
z(Ya?}PkCH6u%X}@e5B_cA8)@pqu&aueOyUMXbi1fdufQ=;qMp`S|9z6IgXc`vPoG(
zZhOeb*3-{Cm9KJFFeK!oS@HO4a+RML5^Bp@1#+#>_m27=ed}@*9P-h9)%tgGmEjBt
z`8d{Lf2dsL7lwp<JYMay?f{aB?x@uNKb&Y&o`OR@=KbT7DkIl3B;;eyYDLoY7kldN
z`Oc7#kKdj050&rdbgEzo4t01?&V=4_?rn?+`M5LB@6NJ387oqekdGN3j*XO&y%`en
z@pL86u5$4G3<>#Iah2mX`Mg|?N)#OGo*%1YC(CaY@nlHI$4FoQ2Xd8(3<>#oIw|WL
zd8F5>Ou-=^`wa4XCnJLy67q4-+NcULGKC>E_(=Oz`wi8$DdST4FY5KNK@~%AsCTYr
z-0mb7xr`AZA4`P(JSHRGF(l;Un!>y0$jBB|DL3TfiZ(~i$%=<FB;=!6uG4*F#lJBm
z<YR`>BkIY>4!YI--(^${sK;GDCAi4JH!&pS<IS!67s%aXQk|-Ve5|&(MSgh;+=C$@
zA19gJT_abylOZ7=BfOUsQXZNqf03c~F{`a1IMkHeRtFZBiyX{|kdLWrTvBD^F@}VE
zTrkjdmE1c8>?k+n<Eh;}uE|xpGbH4rzttw)sebAD@iaq1KAxNZW3pVOr9B0Qe0*zn
zQTMtSsY)+~ga(m&mBmI5m7HTp$j9ex-TdS#i#t$o$j4faOO2c&@@7a4KGOALoK=OE
z%G#KIeT*R_l)G2gr?zs3+te`R#{R@PEiKSmMowi&$j5P$ZsnJe2@DDOxaswrU>RA(
zk%B`$e$4tNQx0A4C_nWDiXTHlJ{DfGGF+}Qks%=;k2gJKM4oCjDLCZg+K8|da+UrJ
z360CkQKqkD<U@vpd|V#yaX?1atVO{gA2(P|c`aW*E+8aS<b^?}jC6PkBSPzAwA;uk
za_$CBhTOFvA5Z6YyDsmsmN6vcV@ipy&1K|!hScCAT}?Qx_xyY0N7=ooeQf1S!66^l
zACDX$x8-JrgnV2U-DaqaG^tHhLOyOU@b0*b?7@(bk0!g<Y?qO{84?=m(ccca%1f?k
z9SRQl=vv~8qwHfpLPEsYa@VTLxeqZS<m2gvPS@pYo;-C8xv}qC+1anzBFp2-kdTjs
z3i%h2gP&wb4L;KDWz?<-PI8A^>MjERUF<nQK2E%z*jq*pXGqA$QdPQ7l!HexB;@05
zo2578DvQ>q;E<2~3lDuIS2>CyAs<7>MwF4CcSJKJWKUW^YY+WUS6@HcG|&gf4!2o8
zJ3Uz*>5~}|@^O#ZSKU{QqzjZA3<<4|o7QalE%#2vhLjufah&OwDKc^fLqa|-exA5N
zM&4ma$j7UvTA9jiY1fE?Lq67Oa(KU7<s62Dd^~*dmA{O9#E_7W-T^17%X|M?jVU<f
zWAvEYQ{@xO0SpQGm{Mq@r`{g5k12$NM*4Jz%fscSY|zAz8+(6_%Yi{dWaKi2gsL>V
z{;`IPe8-TGkNr;t8wuW`DFugoyt4N5YFVCehJ<{~meBaH96XI7As^4iRo$*1L+V|1
zyJi#|^6}56dmCirCWeH3EF10INk*D9rz#;IbB+o8EVpG(hJ<|VU3GVJ{j*%Pk9!CS
z4NKpMk{)vIEG-PVvGX~OCH5P+N8gVjAs>&$#|@UNJiw4p@TRNp<dNmc-I9VsK9<_?
zq=Wn}A{T~)d^C6YdPqi|Wk|?J``R%D<z=EwD+&(z*rbQa7rDwA3<>#o_CUpM@+a()
z7!vYvlzYD^@>kWHwWi>Zj}z)`{h%M0Y9BWf5*kDEt5w`B=Qe3$C=z>rPT1wD`Smw}
z)f2D_Lu&Am?v%W&`datIz{Et!u120@NDV#`a_y6~9?I0FVAaTiZ7H~hwj^Z0&Q-ei
z9!phvFr)?_30c;s;NP>r>4TqUNDV#`GWBesA#!lbb`)HLkA&=BET)*;J)R7y!AC-V
zyxicujErJP$Va<_b*9MIk44&3aLC6jQC7R<`#IwXsiDK^9>lbTexv0guQ4KY{djp(
zmEH0LT&aU0w}S>Bsmi;5y8P15Luz^EGNc9{3E8A>U@Lj|lEjc2d?e(Y;Ug!=Nav0e
z9O|ATK20vj#~DKyQiG3F<&*RISI8TKXAG&qM?%KDFmEbXS*H^P*We=|uf3>xSgtad
zAt4{5mK-Z5SNV(~As^ejS(nmZ<*L_5=gx-U8hVH3p<2h<-c?4r;-q?{2Qnh$<LVDp
z%;ctg%8-zcRz5z?GSayV<%WFRy<tan{nlR{JeVONA6+xdnWD_;>6hGOhJ<{qStRg^
zjI5(O?f2g;TPN&%PWLNA>dI}oh#?^#Cnxo^l94YM67q5DShJNfvVJ!T4*59z>w$hU
zGL#`9A1|6E{V>(_xbjo`_==EFQ{JuN@I{_9oVpuwJ3>AdJ9xB@{K>3&3<>#o%=MFz
zKXXW9NXW;b=L_mSA0yobZq<W=Lp~nq*lehb3};Bl$MFk$Es~LG45?uTrj_SQakFq4
z*`_B2hXzsEfS#pf<T{3ge9ZK_^dvJ~_b5O0borGbAs?+44%S`VNYiDDUKAYiG3C|g
z2&H9}pW4SYgoJXpm~LV&7x|VEAs=m?F4W!hlyW!I9bNx7r`Lphyzu3aZWAdXS1}~y
z<J6H)ipXQ=6GK8iTID@+K}NRfL%|^*ZH838CL_Zc67n&x=P=zJ5veWH7!vaF!+4+l
zGO}%73J#6S2{%^Uk%MnwNXW-hcfI0d<adVD;3MrWUBhhiDLYH$@=Wbxhkl0OP?2L|
zat6pnZev8q$2G~PN6W|z{i#UE$EC|h<du=#84~ib-ROn7ulq>r;|_*|d^An#vQ@r*
z%rt<4Lq5KYuX0GfaPG~JkdNno=36Wy_cJ8q<I?B(ZDeGwffO9_(bA(~K^f`FkkC;7
z-TVC&xyMg3qy`^puTlQgs$!XSgGl+QeY6;42o4dC|0<nR9z*>Z5%RI3$I59k@(@Ep
zK4xta-bY5}8BDn$AG^g`m6UtOjUgc)yZ2vj<jmy>hJ<{~G$~Vx9NfZ%f<r#m`!%YT
z9DF!KLO%8>bFQX*Q!t7lAs-!QJTUSWgAzk1IOJnPhbZ00C8Qa6EJH%}xED?gk@u@H
zdZZ)vF{<73OHP+Nyr}EH+&UuUW6Rc_MjnfMGbH3=sfCf#_4l#VR};|;3Hcar=J83M
zfQ!0OaLC7}mP=~OZ8?S^As=0w_imEM&}D{%d~A63l99hGEH#vZV?LH!R8|f?i6J2$
z?RQ)+F9(lfNXSR$Czp(LPkDC=4*9t1(byIGL8M+EeF+JT^ap!CbkGykBmEX5LOy0*
zJ}a|~v>j&1Z3|V|Dd2e@85zKkkdK{8mEI<gp(hLp`Iy<R!ABWcTX)Lw?}f8tbz8{C
zFkjCaa_~hA3HkUb`PUE`naYrmkET@;*UQ11dQx!6$00468EMN^3<>$zukQXIa+RMM
z67unD=}{5-bwcf9+u?@b(6EeN+po4f53OcI$j9I7r?r-Ie_}|;$6?P+tI5bVBPcf%
zJa5ajcje$47!vX^s$`E8d8B`5NXW<hhfIgb$j)9A9P;r&>a@9XTW)7a$j1*+jg4G5
zXC6saLOz;=PB-$3tUe40`PgF8sqb>|y$lKYIQMSUGkL$7eUu?MG=?swEsB<l?8S(X
zk72KajXW0L%aD+dg$G6%Q9S!-$_@E=<zn@za_~V63AN>b^9>8giXUZ2$j5;m{f(Tm
z&Ff9UAs>C}6fl>A4`oQm$92VD@6|68>P^-uhJ<{4SR~(4`Ic?|F%%r~@l(fdMm}8P
z&XACgZTyS2)K8b{_3<<zp$;GM+Nq;_n5OVpLvHN*R>zv0ye2p0c!q?0+*Bd4p+2{|
z!>=+V<m0<dpRdbRmK#UGAs-udY8xUSG4NqXsC$CT`Q?$TjAuy5$2wnfC&|c)<0&}g
zW6rUkR?5MrGbH3=)6n?ea+Nn367umy(;fw6WR(dN9P%;5<@*BtxK#T%i;z(7Y#6ZR
zsGg`E>Gv2BS|2}+TbU{&YfLoc#=dVAUfJWUjGWJqkdGl14;nsAqz?X^At4{l@0;pQ
zoJmji>QAEJkdFnrPVOe(xm?1KP>)wgowrn$=L17RK9*|UubsT)HlIwvAs^pfn{!=%
zGF06?YZwyp@z%VLy4&1R_k3eW$j8{$sW0^7Qte|0-AS!~cMPDWbct~YlY3_~BSJo|
zeOq;!ock9;LhEC$`Wr)JWS6Ow8}c!{dFBo>avMWJK3;76dX(Ij8GWcq$j4I`#w?Jl
z?9PyokDiu)bdQ~+VY!nbp+V&5(q)<)Jd185=!Yfbqs7=#x@x2<dod*B<B^S97Rksx
z3<>$Tq~fF8`rv9GO??f)q1^tRj*OT0t9=*|@-e2kzqkDHo1+W~`MAfn^eee3EvHj%
z$j6@rmnX}}5ey0W=&(LpqWmVsa}24$M>+uFkzw};WtmXANWDyyok77NAM@4hZTOo6
zHPV+MAs^#62F{b$$2$xOjmuGoDtXE4quopj4*7WBEqsQI3}Q&g$Cp#51?fL^s`l|2
zA)z8y&#;>*H)X9^hTPaEK}-|Uyye`%3<>!-znXhh8TpbSAs?Sj_ueN5Z{kP6As^rD
zD*RrqawS7*@R1IHG@2GtOh%?LB;@0^h)YIZKGk711&4gBUA(=CT;*nlgnX>Ex}K>#
zsb}=3DxsksU+h6%8QGs9As-*r$o*7aACD6fBJOMPC071kdEPmO+}JBXHV?7$(H|mG
zPrzOb3Hg}tK7*Uw;YS$~@^M|2`sd|)g64B6IOL<<r$NW$DqR^8^6|@a=bp-Hsr=M!
zd5R$+9~<6{%d5ZUQ6q~6P;d=C(kedWLZMh?1y=@=8aaj`As-9fZRjd@PaH!+K4z`Z
zY`VM^EE7n<A$v}j4~Uh0oMAv>FV`>`7i#25`%OmFuwSL#3EbjUK`Bz{ban4k3)1Jd
z#lCNKBHLjjFWjBQkdTkbV@_U@|62SWLqa|lUY1xvzk5*!uQ!i^Lq1xKjLaoZmkSvZ
z^6_lhdS0^P?-){pkF<(^&aqYZKu5aRYdxQWLq1N}_%NsbFPYSBxsD+rAB#NkUm^SW
zo*^M0XFB9F1Xu4@+v_g-|GRL;PQJX!bk|W{#5Xdc1|O++ybhk&BO@~gQ<2d6*uQHP
zU->p;e};s74BocqptWucDL-|GA7e<!M~k85Tgxx^FTIe0Lq1lE+_y^}mh%}B@^M-p
zFC%}#b)O+2AMKJnj69XG*WHHG4@=0$C+(~=%9j%X3<>!-{>YOt^5fwohJ<{)QK^C9
zqlIc8Yw2zs{R^&PSkhuvs{WLs${tJkFX~|#$cT`S7fcpxk>{aghJ<_^b@4<SS@Fh;
zDYu5;G;4UAI#*m)Je(mRA2a&LHkJ3QKN%A8an<mp<K-&5g;H?H#}7mH&XzX@dl?e)
z(KjgjH@QmlB~&Hk;|-_yCbEws84~jGQ*>l!c?*1zAt4`cFWOgDzcEnzSVVW4;h&Gt
z7~0sPUw`>(Vk9F%KJM5NcUVS7GbH5W_&NPo$a}0(%P2SGW9`&cMlMOGG9=WNElolv
z%T*>aB;@1LAFtZTe=cqpM!_K;+xoTHC;z4IY=(q<Y~eNdxI6>jWJt)zbxUqV>PNbI
zop4xA!66@?45%GbS-0#cKQ%ItAt4`swd}oDKh)Je{w5^U;YC)L%q#a!w-tum*!i4{
zQTM;gO&P(EkdKzB{;l-6)lK<}At4{vOkJH>o`Acpq~MT`6<peGm8;yzkWlwzFWa%W
z+?Lr^QI(L7qx*XQy|h;<Rkvk7hJ<|l(KEov@!~@a3HjJ2;m9MoE%U6V;2M0Stzgdv
zrPCCovV~CxAIgxBkAd|n?Ue85oF*jHJF!KUManxti#3MaHK6q|%i!xd<z-?tLqa|#
z+*mtNo`A0~B;=!~>B@QX&6i5y6ddx=I#2U5@_yBaAt4{f$NY4acY?PV66$g5CFLUI
z?r~U4!66^h`nIkuUyCnbNXW;QjU8vp!M`x11|R7PrNYaYD7kw&ucP3QkDhJ5%+b#p
z>h*C4A)%&hy4QZ5+&fv;8;Zo<pEEr%Z(;qUp`M2ZFeK#TKJS&$@-@!^hScCA&6Wv2
zri3c*3@w&!wzS+p!66?bzck*b;L;<<GbH5W^m`tWWpzm9r*6wT3<>$@dDrjn@d9Oj
zQzM&iq~OpXdhxo#F!}wf8yQlAkJLTR>z=JqZY-y7%PbL8r3N1fIof-Ow}MmN?W7Lw
z!jO=UbIO{ZkbS&BNDaAZ(#Z3|s<nJWy~HL%ZtVM39?wm?$%~l}Lqa~5>6k6M+~M~a
zQiG2aym;0dP34V2oy`;+@-fHdFiRO3#*mPYqi0QjAa_q1Lqb08%3$dtBfD;);E<2c
zt-Nl_J-(kIp>esidI`G{I&qYrTAut{sY(q#QjaIzZssH}xf2)?^0D~63NQ6bk9vK)
zK}e{`?C<xSmwTuDHbZXge9qW21!u~=<Ij+gkJ%FM=e5!GjPg_WPBKG6KA!6IeS<7d
z$L$mx^3neEmq>Z9v6CSoAH(AUCd*Zt?Vu_lA9H5RutY|>G9={VgO(1p<Uth0kdTi)
z&)V&l+p^S73JwkRu><Y}$ib&FB;@0d3l)pWKHecDM7+JbyPI5O)m?_%*!i4yp3fG`
zuRITANXSR0tX2KwsqHO8LOwcs`FE9Pjn=y<xCS3-L)5?V!C<8=m7%GgHMTIM1|JFe
zKG&0}%8^*5J=Mspd#FkcJ`yr(avoo0kEQ$<HPVeCHTX!#>nn2pJ^7++VbsV|45`6K
zLgpyk@UYyLR(mP91|JDo|I*=P<zEU`UFBqkgzQ-|C|hX-sr=OI<4prn%f~jT$VEl$
zP30o1@6+eD)AIftLbg70aK7B(fefj^M?$`w@Wx!O@+m`V@R5+sHV^qGBkS*{;E<1f
z96i01SwqoW-Qmj_67q4&^W`1nD$^Je^0A)t`grBGhEl1z%8mypIOOA(_$@V*D$@tw
z#*i9(q|N1`M;9FB+uvCaQk5EfB;>l-pA+PzryoN?J`M=FbXb3jNbTb>LTVW4RAhz9
z5qss_=7$Wqu_Jin%bL#C7pd-WPlkl5^t|X;Tz}oHMxJL#4L(xv;2rMP@{@!Thbg!Q
z9|_s9+@q&5avVcy@R5)+PMlw(jCAFv4t|9pAs_QTJ`<|k*04&4EPsT8Yw(e(9CDz_
zE&1e2AVWev4!<<xsEmBfkdTiho{Z@&5A~WyDLCZgt8qyi_1&ZPaRDKrVVQaB^uLRl
zGTPN0{(=#q=N%<SM2G2%R3jT5Gvu~|d_4E~eWdK;Du#rDUs>Jno{UUmNXW-hpGsTG
z!P_6F;E<2eBkP99$gK>i!AFv(<Jni)<-LEF6I3PSW2d+pb>y}j$dHhapN|Fm%fXK_
zB;;d9n*!P7DlK$J5B@t$V`m5XSn|8wZaq@%;|M}(7(+@@Q<Gs{4&BR*{`5lLy_{!6
z$j9CJ-n%H1Z~6(i<VizrdksEPmC0LjW>qesO6q=U#r+skgO7xqb^Y!%Wmu-a=6S)8
z8rqUZdb@dz|86do|B1TFrl%-4<YSiQuZrnAT#XE8NXW;1nTk%(--A#izcD1_W3{-8
zt>r4)ou=TBkKaobYp1kh`nKG}kdTjQbpx$rWX3a8CFG-fwW7{?q}s>6goHZ0`N7A%
z<W2P<MudFKv~Rrb;fr+I-#p5Y8~eUh|LFr7$v0m-7!vYvScWYTO7Qg8JkbmZ`Dk4%
z^HI4i%bum+Q1{HNUq*MRRBFqa3<>!-#-+NAyguGxNDV$J1M$B}ePH?j{wN`RTRNVj
z;E<1Il@^=HJ-&z`As?6bb*LlX1%A(vkdGNUX6T^5G*kQ7;k+R@)H_Sc+eOGXL$@#@
z<l{*9e%a&>&vk){gx1H5he!RrRh_=W-5FAYkF=QiHM;ml-<0ZQ;ygn_KGyEJ;e;H#
z<V6Y&`M7j$wGJ|J3PVCY{^r$(HZt-SLqa|-+hkKuu`_-5I7Cx$$j8?|O<&2~vw$HX
z9~+K|%_JjVFeK#T-cv2R>-QRJ9~)mX1lQ1%G%O=?WV$T(&QeB%d@RyFV^10Rks&qs
zNL5y^ZW$w=2WTHdxgj6#+5P-3KXBf~kdTjYg<EGSsT-EcPp!DcWvUYL@n@FCZt}sT
zDGUkuSk<%P^Gdo3m7luG2Mh@fq9w=8bIDb9xI)1pA5XovFDC!(+Fpj#;3KW#7M(m^
zC_SG3d`|JJR3+qN{SR@s^xGG;k247g<-SxngS&jOcbgF*ALFmbkCuC<-ZevR?E6;t
zSHBq~f5I-DAt4_p+{&9E2RFM;RYE?_-;gp>R(u3QLOvdJeOz5e-e5?`N9+Ct+~w|Z
zj-}v`k89%_^pcS)84?<og^N37lkczoW=IV_(xkrWNWvQV{%V&v3J&?W%717deU)k-
zw-XX7^61b?{_-N8A>L3Vc0T7+>ttK~BCei*dov`oJ`O89=#G9KQX_XWB;@1EP}>(W
zGTRLb4*9q^HrU8(5Bo7B<fHv%&tCEvI>?Zak1mNO-(+O&1PTuM*gLFjwEnh+x_ew1
z67unWaEaXVwfJd<gob*Zo#vh7yG~X&DLCZggW<!L=-X25<9I?sM2`a#-pfT^WkhIw
zY+BVTM&7TMOElzmf_!ud?7cv~x}V9AkdFoJ^F5P;KW0eC#|Q5l#>&IeS+}eCcSGF?
z^6^EJQfuYEe+*?v$j3d$T+-w!Uoa%(V~(~(y2;2Uw<$Q};}ef=Mm{IMh9Myz_m6ab
zp_fNJYkXly$ew47-wx5QW@;bX>(-C|dfXn8=Xw9+!E#e>W<&_tzFFc8d8B8$OGQFH
z7V3L!yo~I_kdTjM^5-{`XN?043Hdm|EAE~=Yvj8}!66?LbF9d%-w>(CkQYNjK4$jI
z-bp`()W~xT3HjK0wX2aA>y@}q!66^rdJP>eua6TM67tdY!SreJ{neWc3Hg}evb|wa
zSNmAwfgw0F(kBgH`%?CC9wS0NRvCAtrHo8rNT|vT#Wp;ZM|$IjlpFG~>a?(U`4-Vy
zhJ<`P;nv$qRy@NasuJ?CyZ^<yvX6Zk67sQEr1M1C$9)V5`Iu{Cw>vU2*JBC}`8a5{
zbw1fgH-?0K486E$p6ugUhJ<_!xVGTC{?bhCW9cMAaA;WWweIOE%QK!4As>^SYn+pj
zaSRFh*lF$F#j=l8o=|Qm`0A?<zsNoYGNc9{m8kzchU<}bX;x|7zm)re>XqjeLqa}!
zjqdnX-WYV%9nJf<A+m#fEZ5qts@y$084~g_a7AjAj5JH8Dj^@ku2_Z1J?_Gg8hoVg
znOm#IJ>_hE`ah{W!;p}Vb1e!*>bJoE=i@U&a1CRKZaR(Mwq&Q=l#>_{^6~EE;*Diw
z0z*PR#=l)!TSiuYPPri;ZN58~l_%gphJ@PE*Cefyj7(uj$j7HWnthe$^rk5kT!W7^
zEJsgWA10r5+Q5*Ik6F&mu$QYe)!j4uH*45KKDy02bXRUmH-^;UBMtS1t9>5Hua7^=
zkdTkVGI#Evzr0ubX!Ft#9P04oj_<C?^UwrFgnS&-DEz0q^4w%d$j2P*lFP|ELC05=
z8}f0$=d3g2;2{hN`S@sJ*F7@w9YaFhlQR3rRJkqNrBZMWKGLu(9)9JWjNHkPkdF!e
zpNh-K+^?xh$j4h5CtsA2BN!6$@lN5yi}I{-l_4P?FP2%jR)0C6_OZ$vLvW~fo||oV
zl_!lEj0pJ{*dfHoPVfmsLO%K(IT0l{W#hM$8}hN2`LLJrGqZIJ3HkVY)3<RlGV?pC
z67uoxp~6A(uykcesK*^!zx-TIw{25?>Rt7DhJ<{K>|(KB{&R7M_Y@rRaaqW!6LMRI
zGbH5WtPg2t<R{J<KTwsBkEYwxLgf9b8zG^lEIjyurF>p4k`W;vO<R0eB9Ea`9}T%3
zAs_EF8e*wz`_pgzXD}q>V|1R`tK|+)W=P1#5yPM7kmt7MpC~xwqsOi$yX9@$W`=}(
z{BYr1eYwZ8e5NX)LA0|$|Dke^yECK)A8A)@)6uS#e3&MhAt4|4&mQR`&l=UzC^+Qf
zvFBaB>#w8K>*ESSYRFBym;Sl?Rg;J1XGVm4{8DAjds&|DUktgi^EqMtF7A+#M;Q|G
z@#D*%pJZh5uT&-E<J7TN4#;ik%aD+dQ=X5%R#G<+DL?gMmc)>dkN)<vHp<IH%Wo7M
z^6|6vL<`x+oeT+$%c^;L_LbW*_jjri@-gShl!EefIg%kEA7|e3+owNNqV_SCkWi5s
zta|T|i!ArUkQ+On^L1R~t66p9NBOD8&>V(@*2ivjtzz`o&1z%<Lqa}2t(qDnBP;x*
z;2M0SIX&R|fxq7nRsM^*%Bc(q`B=|-xseaGCo&}D<D1;JhB;kbWwl=v9P)Ae(lL|d
zyTAbq3Hcc7(|x3T$KVM=Y8dL&J##x0`ui1U<$_Ngy#8+r4*3`}Y<7tLL66$U#e~#A
zq#}z|@AypF0V|s#b&;<bQN#L3$YJJ9ZYZ;*GQFvhP5&5jW9M_~=a}AB|C~pS+{loS
zkIAE_Kay|0d}l}vKGI%e(B2=1<t4X=Nk08;M(lh}q0mY5W#lo2)Zim^Pk8o`PRg~o
zvPP=g(kcU03HkV;(|2cieVodWkdKFM#ZA%QDN$E>pCL8)NZpefGr&Whf$epl3i)>z
z*hzyugzRE#V<}%h`Wuj1UM5bx6Poo_J!NWBELZ1#z=)8K!&5pIQ#w2SIr^HJ^tm0d
z?_2e|6;fGl%9RWW`Pi!PW*>PBy<<qoN4xRk-s*ct-Ig76uR{N?!yT$a>*KEV;|?mF
zrTo;$%?zo*M;b%fYr1;Ni&>^DR3+r&q!y<}$%|PZhScCAjmy->sW+7wIQ?RFm?0q_
zdsho}l_&LFSt&T=<NU_4_w}CyQLm4K2&rKwNV&sb?`y8~PWlet$A}tyqz<?J++&e`
z5m%3)oY@SywS0w(s{Foo;%j-<aAioy$2j-0j`9S2k|7}<o!968EF&#UDYyn7DR{@x
zclIi6sf>1YTY4}g<fBUlQwLd|a|{Xj7~9TyhkT33+KhrjJ|4bss<*N+P_XLYehdlu
zxV^~4DN4(xAL=O#3Hj*lHn^sKlcn~tadty+XjrBcFBc{EPB<fK@R7#Q{Slx4e&#9t
z82ZVO8fFbr{C3LRaq_mUTMo(%1+P5uN!@C?-cf$)4nM+>8hoVSm(ORMtenqD|CZQl
zIjKqwK2q>bU-uM{Z)=1xB;=!e-f6M&#^47-LOx~~Ztg2jM7?uSa1B0E@czM`j<P&^
z7!vX^VqhcPxj5-v3psOBm5`4QHe}YFy!sER_Hi&FHH;z3?dLLVtL)<uMudF)IJ<TU
zdC9fNW5|uYKWBY#?v^rg1VchTuAX3F<OMAk7!qpBt0PJllE+Y~yc8VrvD=nEbL9uG
zQyCKSu~v!2OXMEE$B>YZL(SHnl99FYQE<q|<ja*8%Wb)sAt4_<-Zin1+wv_#LO!0c
z|M7R<ri@LskL~gsf<qmiby&rN^5!yv5jFToif`^x$;c}tO$tzv(E3>Oaf5?$hxcGe
z$j8ZH+4IW5_cJ8qW1Y_3QsgRgn^SP8dxm#z-bk);7(+rny1wk?E+fw}B;?~I=h#^?
z(#nE@Lq7Icv}B&#mJ=8f@-e=|gB@~}Hy9G~(WG`$N5#eTK2|Mg2oCkm%&GN_Ou(}l
zQG<`PZSyN=Qd9Yt(wyp@U@}8OK3ZgcHC3K18|dzD{kv0A1M)H1JLI^0^JN7?LO$;6
zk#m{c;U5_i^0CAm|FJT%Z6OK{^?2pF-Ho*6CWeH3yu5wmJNa@VV_~Wi^6}k;3HRjS
zLl_eBaX|2&B)vT9ae0y<As<@=XB)5IsH@k<LPZS0p{6YPEFx5%hlVqv1|MmC^uHBS
zPL?N{At4`6elIjuf8DHZ$}&YMH{|2n)GDQA<P3&{e4M+$+FNeRM+^!1cstD8$jjjB
z6r<pfk71(=m6u2QGKPc((W;U0LGs-8fgvFu=S4lqCAVd(;uIY6@!N-?U*zBs3<>#|
z;?w1oKDgRP6DvcNQ0}g!o)nRb?9Pagk1sNn9x6BG9)^T`Y?Ce3Uam4%3Ca!mc)k0u
z8TzJFEAGaSkdKuc)XOSYd6FR^AAN%l7<tWF;gS>_^6~NXiN)pV(wiY6AH5#7GP0|_
z%8<~wblX09zr2{0x2E8bk2mi&_<OrH{Vm(+3<>$TA?cK}{xpr+$7Di6MYeJ|-dygT
zrlkzIvGY0SOIDaH56f_dgnV4$SgeYS{LYY&kH-hrT_xYS>{6P7Lp}ygs&`+$b9s;<
zAs_E~<_MIL1<O#CkdHrZHZhlx;}{b1aoed;jb!9ahScDrG7|s$Thck5b6!&(VwX&J
z(c@@C!J(nv!g9thy*%m}cm+dh@R6$Ydt_y)%o@snQTzClkQ#`zxg1?D@v=P9yOcHL
z#=dV=s(jLN8M%`oAs@HAKBt>+Oms(5{{NEHv>a6l`FLecn1g=nukM`z3<>$T&uZR1
z`SABahJ<{)VU_GJ2QN^bf<r!z8*TCTk*3l`>fjy>3Hf;D#^waM%5w~<!ABaG(Zdh?
zmXXCPP;kh{16QuslJ{+684|L`<XQL;{YSRdKE@i5*vG|(oT#U}ohXg;(iQc&YiRkt
z6*Xo4y$Ol3kCPb^@^Q*CTW7h-1cub$BTa4BYBnCOOl|3hWtB=49P;s1SBu*69&0v3
zLO%NLD(NiG8V?x~^0C;%C%OkZQjgcDOu-=^cjp<JBqQfBB;;e9=N2Pvnaq%okNq1g
zZ7o+>uL=c+e5^Dwbf4_w5<)^F-Q$q*x)|vpX$m7k*N?+4Bwv$#tY6iTTg&+zQhefE
z&w=tt4`WCTJ`ys{+G?O;r}9%T6CW57@^MDZN`G%Gr$@G}M!_K;gW5Fp$)c-J`Khbi
z%#e_eYr4IBsvkpY<R^xNd@Pmv!%Kd$*StCfhkUHkw9tCF$_R#pe0=$GguC41-xw0|
z@ll!mSM*h?*T*ilhTzb!Ty&z35g#KM5%TfQpg~5SM*U()Xx50F?;j^mZQboCHx%6T
z_NtC@@9bho$j7bQ8uXD5NM^UEDj^>m_!ZnGAKdNFkdTjyO9vd6tK7$skdHRui<{_&
zrCM=Q2MP}PIK=VOWBKyFH$y@`F5TyvNv`q)Lqa~9-RU|;e}$s<F>eh+aA*v@9G=Bp
zp4vPa5%O_qW9PqLa!{TosCy@dAt4{vyxKikUd1aoQf|n{71wMo%B#39LqcsCRW<ak
zJZs!xNXW<aZ?hZuWR_h`3J&>rt;qg@vXAo^QiG4mZ1(RXX@Qx)D*sZh&eT1g#E_7W
zTgyx{@+Tv8Yf*5>$HKjS^_OShRSXIFIBacjoPOV?_VFtrp$;#zHsdUL0`A~s$c_EU
z$ohwgf4?TL+;LO)&IX3m;3Mns0_6_Lr;9V`t}FjL4^YEFgO7w<5H$IN;-m6k)K$7N
zqy`@enZc&f-#aDgk*63E>YhCHj-S*|!0IZC)TZE=k0~?C%QNtJhScCA?fu_}_@v2-
z-(*P0N2hux{>VoRD%GLjkdG##ZU$G-^|ta;x8;0>gnYDfTYXwTsjGebO-QJBuDdS$
zs3)q6>|WQ98@oj`aA}*&N?$2IHF6I_YVeUdylJU#_WHkTQ6n?fqbfD{NXXDbD|VRa
zDpY=IWEY0i;3FYByq?)izWK6&At4{#bDhg82mj8HP>(k{zGj2G*Jx9p+7j~7J#gz|
z*~j$^3Hdl;(RzQm%C8Iw`8e=XmYH&u?Hf>V$j3jU3U$+0srGRLA)%(MKPTK#PgD=f
z?~DlTS5IdCm_<f*Y-q@hy+5a2^<KZ_o#1AMgnTS`E7nw&$D|Qe3Hg|`sKy()%5Dq^
z`8cSA>wOuylOZ7=tv2}#lY?h%Ou?Z+WS@D6r(9(phJ<|FH^;HRjNH$VkdJAHQZmZp
zGG`MC4*7VvX|6l+eswS*q1?CEUAiYv8pjwB^0Ak>e||Z4-lm4!*!y$tEW2SXBi$Gh
z@-c8`Vz7*iWJt)z9C>D~mys6DC^+Qf<r%dG%1BR!gnXRXJ)pDP<53I=`8dG3`zX1}
zLd_{SG%g?Q$lORqdNCyA<EZjBM!xfOo*^M0*GEh$qpwoEJ{E0Z2o4pw=U_J7>(r#@
z9itc#^3m40i|)hM67nKLLi^R^MVoYQ*OHJWT2gMv$HJLgRgj0}IEI9LY+3!H?uE}%
zl`#wn`51kCh3<1s60%e)3J&?0Z*p>LIrv0|gnV4KX_<>$<yD4+d@NKcrn`)^(LF@`
zcgLU>G}I@xIDA}2PGLyM$2@Vb`pN5KJRu>X>y@vs<=&~(#*iC3pL6q7;&wT=FGE5;
zc5|DxMn)zwB;@0Wz1<hc!K=2V;E<2mrubKttDMP@kdOZFZWNc1cNh}#vB-jXujQSf
zZ957M`Dp!pTC$9s%aD+dPJySY$iW{oB;;e%i=OZ0Dr>c;;E+A53x<U%ckh&+dVLHw
zARVE_Y-iBLwQ`X!84*G*TNzqjU!?kyv{46rZb$6>Iq&P{Iw<$fDu#r7ywu`Pq>TK;
zkdTj?s*KRR@L5{ST6d)2kdM=kovSV**D)mIW9ox017zekhJ<`vvodLsJhye|M8P2+
z6SqYSm8;yykdTk&U0ylKRsLj1$jA7;&EoY#UF~DX&W7O7%5yLK2pc)~Hb#Ve+~f6U
ztc=Xqg^Gl#d@-qVxQy({kdTkl6IQO2Z)@ykNXW-NnI7eqk5y;wO2Hu?ZGZkWypUc!
zx4AMT<YSt9u!TGWA7@C&#}zp<=&re?BY5WBC^+Qf8<%#mvOJy)3Hg|G_o?o?0Mc}M
znjs+{EiIQs%lp+r-3`H^VYwi3><PKZk&FoWSa)#IDRS>zU`WWv4p{>#%g7QvC^r=R
z@$5d&WFN;fB;=!q_XORaGf2bo3PVCZW-a()jEuDDNx>l>&-REeB0tic%8-zchi~N7
zeIZI3>30|s^6{f>>yxsNw!J7g<YQ}R>n-y6oY@Qs`Dk-5+a7s+yiG`G4D}BwvrEox
z-`kKI`^4)*tMPx|JF8&TbNU>HgnVq=bbgH7l=m4D@^OBaF;(Q?)%#Fzs4a8PEoUVo
z{TLGR@wQvJM)It2han*!8|VLaUp@g+y)Olad>nhWMJKt+SqusJ__;;Vfim(ALt;J-
z?{?Bi@O~5=@-biQ2AA}6n|i-Gi;z%<Z|Gd;x}5tFBSPzAnTM^P$Vlap(to$c933DZ
zn>*JjERXachJ<|lQJ~>sS@FjV3HkUcth1S1rNaOU4t0-*g^9C_oXe1qj~_kXq{+b_
zFeK!obM8!ma+S6NDLCZg(HR{M%gEUb3HdlRPwFHYd6yv}A0w>Gl$ZCb)dv}ZL%q}c
zS%#u=@62ID$j8|2Glv<;&5)3f9ZO#CDI=>7rreN^ox^rcl!N;*B;=z>?f4YA%3BNx
z`RIGd_pXer;zGfp9`9o1ZRC#n42Fb!tbO40K)Edw84~jG>xp8&<lq&DP;kh{3AXL8
z%E)O93HjKwSR=!wnR<P^K}e`6?Jtcma_GI1t06ab%eF$rHq+$XJ`4%@xFw=Q8yOkT
zkdTit=R7yb$ntI!9P+Wr6z`4lu$;<}kdJPznGVTSUS~+i$LB9Q%#x8dLn$~kh}vYj
zcR>z5i6J2$55DhQL$2})Lqa~54Vk%2-nW%<r{Iu}zfIQ1%j@F=LPEJ;o|&*!F7i4f
zLhEDoqvuD+M`FtkGvvn3=j^|{afW=uz?UH*A0Kb|aYpX&M23WXT=pbvtz2bg4+;+X
z_~K@laJkBv3<>!d{dIX>xyoA%3HjJ^Omt}(S<RDzL*vr2@4Bt>jjY)W3Hf;J_m!hE
z@&Q9aK04<-=_C8-INT5%Dzf(I)pO+{=QASYqsfIh!yzK|{hVhE39XMEeOLUEhh^On
zlpFGKyUPg&c?^XxB;;e|lsDOA<O_y`eC+whVU--bffogbe4P66wUKAJp$rN6_-k6E
zpBy}uAt4`~KV)n!BO8yT;LuQiKlbiOxh<D7B;@0kjL|t|AKwxZA{M+~&&W}y=A#U`
zvGY0KvX99x=U&Z_kdMvJ*EMo%>?1=$K3-@w!pPyaR--96<YR#+tFFsqXe~oRJ}xX<
zG`rlEUl|he@nnM!MvgPK^`_vEkM%FFHFD^314BYSj!0Z*<oxOnhJ<{4)BC-VQ?{LS
z&y@b%XT-j5W%sP`->*?APO7gTw-}H$p~Wny){N!y7|JkKUt~?}{W&F9ybh3&Js1-5
zG2Alph>YCDkdTk>bDl7jky*!4aLC6|zHe&F$i55-`8dgEiKUF(&ybjpAu%sx#dD0O
z;E<0u?|(D0F&My*kdKF6yBN7;dx#++AG5XEVq_K1Ie~&htJ%Wn9(CpCkAn#bjr9D}
zU)_}Vt0x!{QvA(TcQ^Tx)MBC`H}?LV$WpV;%T;<XB;;egor#}iWE4X}K0e!XK8qZ@
z=p+gb`RH}vMiaTpQ49(BnCIBG8?ukl3<>!-=;nMQ7tU6bDLCX~wzHWJ%2keKNXW;1
z4Idb}%Du#p8hlg?{O`pGrymyhdr6vpeYDoycl~e4tqBdwPYrD2<Oz5JBSJpzYWJ$Q
z+?3ZC5}Gx7Jn45vuCmNj$_)j-<(2EbjGWAnkdK>en;1DD8OM;2k8{W5ZXj1#&WD0S
zKAL^)>n$UF7!vaFTJcKOa*ro4B;@0$52w4zRaTrv!66^t`-Hg4$mtBJ!AJTF^zU0A
z@0G6~ZxIq2L*YXfCdx%t_ci3k&gYbTaptLv^k+!O$3_8r^2o>s3<>$T`$kx@Jcepa
zr{GXqzNzq_gj{6+Lqa|t-sb2pSNWJBAs_2U&R->0={SReLq49gyT4OL&SOZ($2O_Q
zw<_aa`KfOTK4nPA$7c2FoRjw&HD*$9$j77ywG5YL>g&gOgoHZ0Qtut1a*<CM5n3Oo
zw!V5rM%JEX$c>%P$<Q)-wcO#07!vZ)xlZjRGV&!uLOxcVami6WPu|dvf@|m=+7P9z
z{B~M-OO$dbOFb;tG9={Vhq@Du+)@9<kdTiXsuYQpd%Wvx3a-IN3SMef;syEjMmrc1
z@-g~P<}7lLXY;2jAs<Iqeb`JsFV~NdQ167^Nr{vv;G>KP`S>9qEti}-&m2SU8qoT<
z=B-;_8R^Q9kdHTt^^KR2Cm0g)@vZx=yE4*TXTZO!i5ePwqz%#DTbZxQNDqdDdi>#u
zP$P5O8HR*>e0tH%$lO*qfP!oAk%G_Nk#=4VK9V6JA75TcEGi=}FeK!oS(KTR{*~wI
z_0cNO5FBdCeFw^V%RWwIM99b3!!`xv+*cVA^6~in{f%X$O%UaVd@R$gzzg~NR#O-f
z^3f(@!y<W^xWkZ;kKP9_#K=gyc@!M-@xqDSy2rrMU!eprBs7S+^nPmOdpb!B3Hi8l
zYETFL%A?*G)R|AgAs<&3whYwEqeg}?B;;dzci-9iqc3V7KNAwlJuq%-7rA%ZEimN9
z9-$NtemYma%^1OukdM7K_2?s4`I8|bA8%%zlv`H3OE3l3;3Ms^R%Q+yq$sYuO;O$9
z+ZYn^v2Ijp!+~Wr(rh7B3Hj(+KTY=+5|WRD7!vYvzUTXUa*rQnNN8MUJvm!<ohVhA
zH-v&iK5q5Or8}J<A%`*~<YSVxmF~p<e=nX@`*@0wP?1rsTg1stSyVUI|J!3>-?xg-
zbzS$!R?0n!At4{9-S53xMn*Fv<YVqziJsQFDwUslq+2hh;E<0Y9bP|H+EUS6jhxGn
z8hj+h`<WDsmyr({QiG3#%+owasC;EsLw6@Z-{X*vtKv?NlQ&rl7!vYv#j2u)FV(2q
z@+m_?L)~`NPFK0gnoB4+<YU~enQP?xt3iZ>h<kqh>M9rclo6r*>X5ZhQ)I=RmKt(9
zK|WUh?%Z4c)3pT*3HcbEG4QKg<r9X~;3Hl0w48q{Mn*a<qu?5RBxEhWP$wh78B&9f
zgj`m5PD{DUCkzSsSmE};>+&FS3ZvkVkCpaMo+TeqpU;qxkA9PGpOUM5%#e^hAG3$O
zRAxHmr(Pc&m+OOLi&>VmfRA#K!Hfv`SRmDPpNvdqNXW;)hP89Zz2m%sazj4WkLndH
zS2>R%As?N8eJdj)lNb{6@m2mGqvYT<S5k1u$0hxiILK87FeKz-!MJnTWaLAJgnWE5
zyh{N&xWg(64*A$T`n-`N2L22Q`8f5%ifZ!p<2^z`BmF|tP(QgTYv^`}|LtCC*+M>U
zEc<MPj0|8%sLI86TON>m=OIHvKAQQ>^^vQzTSLJiA8+Nq{ZmHzGbH3=kJSO!WaK@D
zgnS%bt8YH}!r3;Qf<r!5cWqQ$u5u1TLOwoNVV6O!@;*aCKK8R5XeT2b)>3fDN6#A$
zo#pGtKte*p()EnvE&0mq86!eIZo9p_h`b@Hx6Y8;4)XERz@8W7Di<>(6ui~z>_22=
zDnmj(u8*iOK@Q$zJq3q+EShH4O0IG_Lqa~TnAA&mAW*uz|G<!tkLT?x9+F3Ts|^$!
z^3k__sgkndYZ(&q@nx}si{&cQ7!vZa;IIvD^7UiejfUXR82Xv@`wh9sjf@ESSn}u~
zBd_H7$&iqb9X5uZm8<L+LAfCxuU9z#MMiFBNT@9nEQc6*D)WaSAs-vOSeGCV%Wj(}
zIOOBR{n<Oq!M8Ca<m0zmJqO6hjGL)S$j25-avAwU?4Aq>`M9}suUNUtoeT;27_@S#
zk?&h&*<uI|b$Iz*W=V39eHjt*vDM{CW-@X=Lqa~*FPS%=JS=l;rQDE@&%7)O%T*3w
zNXW;U{ZATsmV1aHq3)^qwdo4E%ADIMIOOA@F$Fiv$iWN=`FK2F#4H(klp!G>NAw--
zDED~2?GzmHF?eIAO>&j43<>%8_*?1>d3`)VNT_!PTTRm~*3$09Vuv9&_I<0tp@Wvl
z+qU5h3Hf;KMBe>!l~D`{`PkmJvF-qp6ujt83J&?WI-)=p8R^ZCkdLO*3zw3|Pz*yt
zJ^o-!{v7g1FSUz;Lq2XOHO|PD*?5M8d@Qrm#>n;KRfdFowA&xuP;N_`-4q=1vEk6G
zhh-n95E5!ipXr^9yiMf>BSP!rYRia@a_$Oy47suITNT~d?WT<MWk|?JtGJNg@~})~
zNXW-SS)GiW@v6L+f<r#m3>fxV4nC71As-9wsB7ePoOc)!8bq!O-J8f&R@+CxAs?R=
zcOEYzXEP+^<1C++D`n(;hJ<|V`?BjM`TnYdZvFUoHx$Y}uxLpmFBF`|h>(xv@0Sgd
zb0;w*v_5X`IQFEBbUHw}As@fB8fWBuPB244K2AJuQ&+C?IYUA|*6!59$XlE19i-rp
zk9*!mF3~?TQ$J~6%#e_eUox)0A@7LZG9)xE7hLS}Tt+rMM8P2+ADNCFAqQW<kdTjS
zy8bX6FIGQ)Od}*z<hKIj4R>tSz0>BfAvg9&v+=TB335|zW=P1#i$SN?>hCM7tNhK7
zkdHZ1ol48+S9=|y;E<2D(|wxARUT$Y4L&NP=D$C9T`;>qCFK}r`ftCR>;4e--vnF>
z^6~qQ-$7P7r1Dd@<tT>K;3HLeZP4qFrF6J5>5w-W67n%mC3}mEI-K%TS6TlU1&4-u
z*BU0dm17agPmP?zkdTiDD>f`4?^kaV5+Xht+_jmhu0Z9dF4Fe6AvgB^oNH0HkIA`x
z84~hwT||plGBTDSAs>(LujwEMFLi=~Lq2{wSZSYJ<tT=Pd>psZ=kNPhmHAEGJ!cpa
z^3iR(yO9skT1HZE4L&MSO-zP)Ids2Pxn^B?A{x$+8hj+hckPLNqWnw2s)I)}qy`@e
z`Ny}bt1`DKe-fugmN`kmA$vC3p8u>r^{!qYryG!%JZ+}<zLF1Q-DgB-ziL^_`<eWW
zZQE1&+)mi{t*Xx1QCUXLWJt(I->F}Z%E1#D67umw;(0T<$_l3`xCS3-q+9=v&n8zn
znIRz`m#3C1BO|XdB;=#r+3d&l%Y=HQmp((mAs;7}iAYfHjVV`WYUC7#)Zim)%dDZ7
z<S*3UU`WWv9fM5nD8eg0wU1?@48ft5XMR7MJ96*%Fe2ompOsBH85zfrP?c9tHm#wb
zht$1O_AKRwd~7o~^K!X&W-=t?W8I=Tp2{2bc!q?09NM&OWw|XYoTK27kMjf0@0Y8b
z%8-zc$q^S@%Ijl1Lu&Am<QbLts-1i}QSCehhkT5;+1F4nk9rWzV@Sxyd9N40(07m8
z#}q<B!*W;tX6NPJseQqa+Ya(Ef9j95@@%<~At4{vHT}6zz8U(GA)(*_^GiLFZ@$#m
z9R>RD%FM|Q@-chHQAYm6c?m;8KBjEWR95bu*9-~y7!k0gU^d-+uKd))vT-y8*We@V
z1n=55ic*H9(nV_ILWYEV^q6?Ai+-f5k;x1R`8d8{T8KOYJ6)pSkdH}0VRQ6@NbTcX
zLTVU8)RY5znEyS$s&u+K_d`a6d|a?*_Y`>yIq3ej_TNaihkP7(@}`rF3}8se$6;1h
zV`StbhSboOG^a-gy}l_we{{S|!66^F`>oC|&*}3SQiG4w<Mk*0a+d!}^94g{@R5QS
z@pd~SkM!nOC^+O}$n1M3<nCF@kdTkZ3+3}x{xmiHpQpZNNXW;$xxyOA&pX;&H3Ww`
zJb2}g0dnq*j0pJ{G`whb`SAA-hJ<{K%)Y&Zygs(OM!6v$GpA*UmaAOPkQ#iXk$&{a
z_u<NHsW_>g+tL^k>Ym#@y!*);^|se3xCS3dp8AiUnagdtl_4P?D?NWyTV8ViFeK#T
z`06uS%E-2{6ddv~`1wF<dDd9LkdTkpgGzhq2a$Sxd__p8cYe)yH%czDZk!=Ec0Q-`
zi;gk!R%0GRLOv!1T}qLWj~Np3@xZoyo0UPT{M7Q)h^OEhe58>+plz|{^8K9I3<>#I
zctE%8a`0OW3H5kP;{}stWaS$a9P+W6^?oyXW8lk>kdJ|0?s?^n!7YY_e5~+p--fKZ
z-d29<9=F%sI{LS7s{#3#x}>Y&keAv=UqWhVN}AL6+m&CYj3LExb&-jT2(6E2JC|Cg
zpET6S3cBswzuegQoB_eJ^U5QA3PVCZ-VOd><inR&84~g_=5XEB@*|Woi4<IekJLS@
z3ZJj4$dmrc%$p%0A2V$0@>1RrU0_HJgNP=gi2K{G%E624{&+~=<B*S~@8|6!&l;W#
z3Hj)fzkgX7d5R$+A4~Vx*hGJ;MD3&bZ9{M<cTAom59QwRWJJivBc=W7%el`mB(y&6
z=~J<<j4XJEazj2wjaf8Ve<`k>HHI-H<YU;T^KE71X@=C`BaQTr?>ZU|fT*i1beDod
zJ|@3BF<-9Iiy<K&or`U>l()d=84?<o-$(8~BJWp=-lO1<kJbEJEs(c@?hFa}c>GCH
zLH%7|wU0*#2^AT!DK19NUGTmkH+DY9{KH{?IkyW#LO$LeT(+Rx;rkg9@-hGWg<0iQ
z-0T4bhkU%c^LuF-*@qz^A01ZrH}awOT?`5NSR`Ayc=?hv<3kD#`8c&_RV!r<QGV)K
zqd!AJK3ZF)n#(irZia-0x@F?rW^(sreni0`A0G_uUs*Yrr2N!Ab|)l6Y<S_Nm0aXW
zMugVK@X$`(<fhF3*pM50f6na0qIG4YD?>s)mcJF!QdayZLqa}&?qh#a-fQGZqTrB^
zEsB`dly`zd7*d0ev<3b-KB0#aT&Ywo&whr4d_4L5)_Xa)*%Jz`!AGj{?uy3Ia+UoV
zQiG3#>|CHp4P_81*#8U8kdQrJhd5j<ufr)nwU4Gx{{;s>MrAWC%uVj_af}H0=z7%S
zl&ttUhJ@C~Y)@m2JZUeKOt~Q+t4&IpD*HHsAt4{9J-Yr=zF`o>kdTi*ewSV-Pegg2
zQE&}D(iYgP*WF;bdt4Y2^3kP!D<eIAh#@ujNLBW4b@-xOW%lP3T!W8<w5wKOnT+hq
zkdTi-L8ra-dw;c$y9o)6bgS$hUjL))ETg*Ux;~5nb}NE`T_}ozf{G~Ejjf2?fq~rx
zHYTX3h=GlP-QC?Cs3<5ZCbqnc_dB!qJnUI(ejoVYv(|k*=XcJ&&N(x4{xh<VR<T-c
z?EN`&Cib2t&z7wi(nKq1YTNyF>0G5Olh5g!84~g_cvhI7JUWRCX~IWp<=d&v|J{Q~
zJ^?p>O?_#?M?!WTP&Zg!Ce|?|<l~TmKdZ|l{)-_YA3a}}A1u#p4c<_2$jA1FAN$J4
zFouMD?7pOJ4jK7{At4{TY<Z#GSl0VkKTZn{m1V%?xW%$OD;d$m`bah8Ft~ONd0&vg
zkS2Vjscp#MZ!YpO(cmrRhJyQfjWKvQv4SB@_(-i>{c8Pgxs@Ln(u9wMoHb&78yQ*a
z9R-JcbQxE$kc?cykdTiP?v9I)k#89i^6}N))xYFNC^g<waL7lOf}cjo$R!L3`B>%3
z#$D>QxZcMPgoJA7sq3YUa#uEr*K%Xuw_083>Ldfj84~i*`)QWta#toWB;;dakVi|o
zl}$cSaHub9&dTvoQAzpJU!a6DB;@0}ERM6~#q29XLO#y*-Iz~qWv!1C9P;sbTGvK0
zGMFJv_(+p_={K2sD%%%jH>mH+R}5*wM?y|(P~x{z>dG3aM^^qs!66^>Tkq7q{jT>h
zkdV-Tr&|?aaBS=aBbrzrmGSuR*Eb24d$XyN#{cC0tmVeOZ*{r+sxtCcV-Z7|@R3Hx
zF*Ih2(q?7Q^{tF!NE1F1GH07%j`D!JeWBnchKG>-8w5O+9}mxCNXW-LtD8KM`|>$M
zLOy=)>~TlFqweyRf<rz&Ug}&!nJ$z2IE^78AMMkPU8@97j(p6JkdLLtmYt)n6M7#j
zBxu2*(HRl3^}f7J%wR+lK2i<M`{o!gcjZ%tG_gJsvf`tZ9hGB;d6LOf@f+nf;Umo&
z&hs{$RUaMceGFnq6Fw3$*z(#`xhy|1B;;eY$IHsded+m~f<q%d?!c}y>X}P@@Fffh
z`B;BXis9;Q4L$M`Lz?iB`toJ20R|sWt^b39oA8m4&Xe5@zDv52At4_N7H~<rC;i_E
zNxhHX2nls%PPgGpWgnaT)N)rc;Undqe`{}q{75sLAx-#5$V=ZxX}@dvp8;n`$j5zA
z*WbzabLu2rxcoa);^J5d@^NF4d)D$Pq7a5O;Ufj#I;ij*S@AfAgnZmxcIP>HeXRPM
zf}1EJnl3ZHUtL(9HRds-2_Ff0d~%zDN-Gtte#BofB;@1CTsxo0eOdJn1&4gJozt+H
zx)s#>IE#=_?upA2OUrw#7)CVVBXworrhC`Oqf_;-mfOXIkAxiB>DDj#YGOV^LOzyj
zo7zvFh@u%1@^N1-rxbFfS4pJckdHCj(-fCip1BMO`FJ$XuBP%GgI5e`!bh4lPVV=v
zBF}AAEV8R}n~RCMBxI@BHT~qi3}i^i$J6D{%vBdNz2eUq67sS9uIzW@^Kw;EXu+XI
z_V%uKNY1^05l#3=U0Jh3{4#lTVi?kdkA&QR*~VRNWtEha8}e~*ob^N*IhP?J9~-p0
z<}Ysyq8SqMaoOx@rQ|uiLMjRl`IzuJVw8-W%#e_e)^m0w$iZ(gB;;e^f=BMlvqr(x
z6dWpbiw#!{UXeAFAt4{5j_og^Dz0B2FAx$UemL!VNtUOOrIs6e1&IH=$wBI*p`V9_
zG9={VU8fv><i+eVLqa~bPT#7w>|+rt3J&?WIKJLY`O0i0Lqa~*y8qyZJUllT67sQg
zgGY<yN-vg%f<r!fj9Xn<ZsjP3gnTUOe#1*{<t2uMd>j<8wyRu31=CV+$exbh_cm5b
zUGL*?4T(LxFE#c=8~L`z6-I>C$9Lyj{+932mr1AQE|0xGC+Ec*2Cu9e!;p}VM=or-
zFW1m@hJ<_!_4!ysuA!poDLCZg#E8=oa$k;QNXW;@L9^`SvOLR>CVZsJiOzGwqLjH!
z!Rlw={23@X<m1-tV+=k5<HwMYk0~Q_rk8`CV@Sxyf@kXNP%kI+KH6o}f<r4$%5k;Q
zDIKf)>AP|$BSJp*w;gj@UU{xEB-F|pmFm8dkwr66Zpg<x)B4wv54VkCNXW-RL#9W|
zil1Rf$j81Dcl4E!wwWn7<m18nF5$A`{Tb4Pk90ZVU#`A^;s+TL^08K6Krea3vt^;+
zkdF^nZ+a<DmpvI0^09J>u$StKgY-TgAS6_laT)B|$hmW6)pBF+&$)AG-4}Vl`!Xct
zW6#L`_vBXYXGkb`^)I)w%axuv8wH1abSi9rS|0E&3<>$zwQ{MUGIBRVLO%Z7dMA}S
zr|W0nblE95<m2!I16#{0PiKaNd~CR()FL_f9)^T`jLA@Es*FsZgMvdo#-8>}`mwC^
zyrUx_p&EJ<F)xFBDZZN#q4jaq{&x-J8wROzYPqrZ=j<8tX_VZ`77Pjbxb#v1Pq~$=
z7}7*v(zb1tZNfBVz?GRpU+Eti67sRR_rkLBtWi4`^(EwE=S_`mW#kfugnS&Z_>H@=
zS}K3~;BgEI`S_}2-`{d8-K;4%<m0T7ovzERoXe0Ve54V-H>0AT@;cYNNq_qFF^Z7T
zfd84)ZIYb3dTuSZGvs6WUiY<^is(mY0YgITqveT$2ET@T$&iqb8@n`3Ezg#fZ78@2
zA8Fe*GNFLM1RTha(C~b)&txy}HJ&jf<YR}m8E43Q4M$rF4*59QqqxCKLjxER^6_M<
z)eYoU-e*Y2$9%0)RFzA;Y#s`3!bckMjSZibE|TP;@~8K45+R|{DSTs$!Pl$bFro<`
zY0}tNboC^8nW&yu%Uu!j@xAl$`|{{4WJt)zn7L&Qe*YNDkdTj|O_z_B<*AmBf<rz!
zO<jIXeka;&hJ;3Z_MtlVa$m+VB;@0nduh7J*WxwuQ*g+~FZo@b$ctGZLqa~bPRwKQ
zdCn&c3Hf-r=+%zu-B7)c745X(P*<MI>%K@nQ?h^&P54NYM&2P4-^(jcG($o@cJ~`=
z@S6nJr0*yEcbKMpCCJC-6I*nXA5P3>NXW-^RR;LUKE7f|$j1~u-dWTe2Kv25#ex(Z
z^6_Gu%$Bl`^BEE<qKlmp3mXJyNXW-bySM#&anOH-q)bT`7Acbc!Y5TMM8P2+4|iEp
zT@F5jAt4{H-pG|!oi6o0J|QHO`$OkjOXaJ3x58R(7s$tD-_kylb1!5_$j6<YyFKJt
zBbFf{9|y&TImoj{l_C@z^6_A`JVoSI&S6N%$3`!6{*s3$iXkB%({^1xUJmY3l!8M(
zetq!asf?V(kWgK|9AdLyMm}Xo$j9F&>IBG0r(zTw^08=_?NRxYW(nm_@8dK=LXG@#
z_;rlj$Ty4#`Pj2=M1Og!;a*(J?F#vr@$R5#xs`Jn67sRSWwwoSrN3ZE$jAM8ybOMT
zUZn&DhkQ)Cc%Gv?w*@jJ<fGNgR(IrkW6v29@^QuN!YSm5$gv~^hkV>@{rj1GyKOQ<
zLZu%4zT7GG;k|yZaf2Zt9}A{<&_&*_mM*0Qhlpo}_(saPr!ykt<L)Mw_hfnQF(l-p
zcfFy9)%(i&t}J6uxgj5$Ey!VT8RgHAkdJ@rr`{^J@;*aCKJFQ4Jzsv3P`)$;hkUGd
zv+fr8w#GDugnaaW)U%m9Ydl~`$j70zEB%zG%W`EXIOJoMF|B=M<Wz=)>?zl7{vCP0
z`dC9^4+|?)3-y*8S=B+!UBMCZF?+|&y=BE0FeK#T%tWuj26H+?LOwp(mn}eUrDItN
z4*9tA@x<FQaw0=QK86p@`9!YtYYYkbcs^&q92r@x90iAbJa!}J1bNmN&5)3f9v=?e
zkz09<At4`aU-n5QBa1mwaLC7umkwr-_p74`2~~O-x2nE!S3YJ$6F$=Y)y@gIzbbc1
zl7G6-sl1lEJk&}{hwz_rD+3u4^6^ZQzu)CO)(eJ&e6-AX^1Hn9RIEV3As?%@d2wCd
zYfNWI$j5u@7c7x4Cmt~*<YSi`hh6314o(yt^0D&Cg74(u6B!cn@z<==2Cr_r#gLGX
zg)_h3uig~YUq2Rc)`FWTOOhx4)X#s%s+DTj?*zv(q6r`A{%WSXkDAHyTxUqg$AqO}
zG4g<ys7Sd@1gBOmdf(FEO^Tx#67tcfS45;d0iS0`$j9h58zW?-T_p+*`B=NrpL+7}
z3}Hyf#~g*nosnC4o*^M0t7r0fDI@J%C^+O}<E)u4%1>p6Fr*0|$(|2(&u1(9Rpoc`
zdLNGw5~`v7&4)(G^N^jZmK%G2PBE{%uVi`r7!vZaUd5SvWaMdvgnZnxY@NYt)@&+M
zaHub@*Vq#zx3U*Qn(&bZ+<W>_cV!h<u=?rp07IJak&yF)ItM8uu2j1onXw85hkU$J
z{jHBIPiKaNd_4Bo#o)b%yBQMlaectiBXX&yu1dj8_(+rba;JS4<=-Q>C8UV~C!%}w
z%TDraxr-5@_0c-<VlDZSG`*Xa+sylOsD>(+y5^?LLCU!#eGPSCNXW;iYj+mO!A~$G
z<m1pRD;(sqw5dkHq2by6^Xx#mmA(vV!bckM>3#Bkl*{rYLqa}=*C}yBM&@>>;E<1B
zI~46EBl|HV<YTol_K#)cQHF$kJaFo5PWk?7j_O))Xml#34mc_|au6dzJ~o}U|A<^e
zrx+4iAMa()+FHJ!lcxsdhJ1Wjw$?29=1XsegnaZr?N?N8<vxald<=9iaZ_%kl?Mff
zMm%)ct{L)O;MNQY`8eodK#V*QZDmNv$9ug(4fYzTJSn&dA8Arw+%NY-rPPye3|ccJ
z<m2mlqoS2HBKi5%O@xHHa-Qw{g>qMBsHx>P^Zp#l-Q;P^zk4~###+Cab!JG&NB7b;
zHtN1Wk37VXkdMcfHJu=ze6g)X!66?XuKP7dS%;KAeJh7CB;;eF#U+F9&7EOL$j6QW
zJ-y{!b)MQ394eyCyW+km<FEYbgZnZh<YVE4?rr6D;v7So@R2qKSAI=<E}tUGSBHW_
zK1MrVxLPnNwDPCFe(Xm`D0expd->$ixz30t)<^QOY5OjB<awxQT`jkn_vcVou32Hd
zL+;9v3~9ngYGt)*2bapNJj;-fk2^Nh9H2gp(wAl4dK4V;aduFu-g2dnW=P0KrwV6R
z$TRS5hJ<`{i(NfKzEfgfpMpbmncJ;)C3$We!H|%TLmqu^CnL`>B;=#t#0cknNiHgX
zdLL~YXu+XIwhie#Sw6Hdh7nEpNb<Cua_Oq9_$`Kn*2kb8!wbvE5)CQ02_LDIOX8vr
z$cm3<NXW<WeNPORH|pmZ67q4&gh!iXc?vY5;E<2E60H;ERt{xI$j7g9hP{#d@&ZFb
zK9;peHAD_>+n9nwrJlC+?%^_W07F7PruOasP~NYeBqT(1DpGg6+{mI$wA|SHb4vT&
z_#<yFM=>Pi<Gce6?c`S8VMxfwyI#|q%NwH7O({6!qkU}jXBjzxAt4`stSS9gmggoz
zLOzakv}rB(WhpNT4*7U=NVi^c@bL@@`S|U=`x_Z~gCQXw6W7h3E+dOKqu`J|3o?{^
zBd?F6H6-?MqGC)hA9)df#E8)P_+#yaS@LY@&|J;!guOo}^Mc@(ax2F&qzNBszdEE^
z`tnMpD|dqRo6E}#3HkW?;!S_~#&VGs6ddyL{)Q*}WaMaugnX>?sNrtqH?+#1KKONp
zgnV2$ZNmn2nb0H4x1`{ZkL%qhERko8g$xP#*efvXg?s`emLVY@qs9bPEtJ%c%AbC}
zTBVg199ntOIusr(H*ystLOvesb)$+r4}E4xsFg2n=G`EdW!=`4+k}s_U%gkcj=?YQ
zS1=^x<ElFA4Q?}jWJt)zUN5?zkk`jLZ74Y8W4T|;FUhxTmop^fV{qA}?(*=wWk|@!
zX7leYlY`f6OTkU}NHg%rgiHUnf(lkYYlJW)<m0sa7Z$5G1@%6@CnQvsIm$mu`Y$ak
zls|nV>$lT#V@F~aw~m=2cjan^gnaZ|k!iVHL*E$^3VwX^cZ0`p^}H!K<m0oxcQeRk
zxtt*(AMI_OGpGZuAD+()3HkVW_O@a2`q;ER1&4gB)}(SuIruh)gnZn0C%TKgK3e%u
zD^2)FGjRV_Rd&j)Y|oI8kKe2Kx|K>YNBPtHxPy>T4V4Y^*(2vJ)IrOQZGjsNC~5F=
z#^DSJ`51iv{v7$q-X(^FeEb%Dsgrz*C{ITU4)tZu{2$iK6Ok`NLOza)OAL}HqLT~>
z`S>?u7K0@>M<)sn`FMKNp9^yEJ`4%@m~+m6Q*!X53<>#|>Bd=uL(o||Q*g+~-r1jT
zQO>C(KQGsVkkEj4s&7?5-dvt$L}<S{tex_*J88+a?V{y2b3TWrwp+a#-jn6=V@Sxy
zkyl4tktd?l3<>#o{(LrHc>>PUm4ZXVb81i_I~h5cAt4|0cFQzc?#puw3Hj)Da;3rR
z|MGUD;E<1pntqOxhi4E&LO!;f@^_RR{4_&CK6ZGP!lgh`sVjf__0gug791KK-+OEN
z$hpTcBIINFY&na`H(zcrB(y$Stn#QJ-y$l~gK|SYZjQM;Pj00jLqa~Dne1~+MxJCy
z$VZ>yMQX^wbM~a*(1`!}w)LFc%5Dq^`8aPub%URb>|#jB$A>Pn9?DCuWiJX2`8e-X
zWGfljo*^M0S8VX!s@}-b`xr?`6J1Fcxpj8lDz5mbG*o|qlD)T<+syeKWr+X#{^RA$
zjkn8>#d|R%<YT_k%Yx)bC}$YbgpU;5sl(xla_}O3C^+O}{o;|o<N+VakdTi>L!!UP
zx7)5TB;@1PcjxxVJEDSpDY%Iuq7k<(>AX^2d4@71<l{Hj#g~-9QvURHd6pp|AJ=8~
zF?b16;eHex^0B>p%C*IlTB!W#eH>0mDEChHYVYOs@i`+x>*K4A{>SCfap|w+#?I$#
z>$KM3W5zQX(u9vxL(4wI^_4GBq8JkLaoEKk20l9aQgFz}gy7Lt<W^2)NXSQraqB9{
zTi`nk3HfN#^7tWnB61i&!A;a9O_xX3_W$?#zvS!06o!O+EcRjlPWdLpJ%)sQ{P}24
zE&2Dz#RqD^p+=_l3L7WSmNOU;^3m0Qt*eZD%#hIfIHt|ZZSrhceh}q`d@SOeW`n%)
z%w|Z)$IDUEE6DOZVMxfwZCmXkWO>RCrr?l|``1PV$}?~PLqa}g4xai$-o89wNE1HN
zbh$FXwyWHiE`AgoD)pOgLoUg)#x#b6e00scW4m3_+Nk{L*T=_%goxk!w$Cp&(qo90
z8#|xVWJqvX^+zcBt;S-8gnabMe(0`z+y5&=LOw=LsnbLb-fSoZhkUHF<a)GR>FXI1
z@^Q!fvQuOqe={WH<B=7U{N+}*7)HS%A8QtWS4>83U`WWvzOinL<W1HehJ<|d89uj&
zTtr^ODL7<LtNaE2{gzZ&ell1n7isESDI+u_G~OYbyg#ZBqx6FRB_OmqHgIo0K^~h9
zBh=K+*b8~iHz<`;o-21SBqX@^ZdY5ml_^J3D@_PaJ1oogK5G<Y@*P$ihBP5KA?@}a
zj!=eL!RlwW2!@0PeAc{Mx8*vw7)8M$!M9zRZZFSlEf~^-;1qmxpOgLN;2Rkd5`6B7
zbiVQ${)ZtU!Cj{Iw3Byj-lM56A;BYV9O^DVK-o=5sM0IkYdcxqt>zk|H4^(KUM-8Z
z2{N(|Lqe@Q?cH>neBbggLz?iBc32y#KS`948OKs^6Fw61!;7G{@~qLGAt4{v9E@ot
z_vLnmgnW#M`0XdRGW9qLZo)?jzPI4!BJvML+A$>Lqg8|YC*|Pl7!vZaU%7h=W#mtW
zG~pvnM8~f-+N{2NO20lf8L#yvRF=&%9_^!atn#Oy)7LX1wB!zbxVxr2r+;Ti$j5~Z
z%6yaMX*hv$L&0;sz7V3m+ejaLDMLa&?x@<Xyga9WVMxfwVQamL$$i;uA_a$h{9Equ
zdbuyd84~i*`gOFy&ptmhB;;e3nr-&T_Y3MyqTra1j~_0PeGFkp6F$;JRBBGAf$ERN
z^*+8MBveBKy2Z4U8(Ayqhh6`@+TR&F@N>@f$Z)wUmoOyc;}pMcE96$bVMxeF_X2;e
z$w>Dp6ddZy2HkV!mVI2nkdTizte0(;r^|STgnZn3^Y$*;#~S_=9P-ibL!mlyE9WvK
z<l~Uw?bb3fiXkB%OZ6>NQNFk@A3(t&A5(X)xlKJwqxW$-A)x`U*|4y?d^Hiph|v1@
z<$5oJ8@83EYPqokKSTR(Zzp%<OooJfyge(pzq~#^V@Sxy4yA%S%Xh}APNU$^@C4Mp
zwOXFrLKqVAv1hFBB{_H;Lqa~*e7hz@-U8R2PQf7`kF>n%DkGONB;=#jn^f)P`x@~K
z3Hj)MJ?~X@#PvQ_pP>bZM(1fB>l|{WFK0x^$4=#IoRC+Z&kPBzkCCZ8-PQY8`psqC
znUovyaZRWG?d4+->lqUAvESSU8RP-CnnkUIe6*W$W~n?~wq{6Z#1D2@YVdx~2!@1w
zeEFwP9eKo4&Zgjyk6&lnevzL(wq{7k$2tYO2g!<uGo%S0>H0B!z13@#9g$L-dLMrf
z66(sDHvJss3Ak0D)|J?Sp8{9YdCJK33<>%8cK7!Da##LfNXW-%=Qm+;4K<lV!66^L
zes)eJ`?#7RAs^q5Th~LLE<Z6O<m0_ZCqBuF*Plzlp(5%Myx^_;Xd;XuAs?%SeQY83
z<u8VWeEe|tPD**i8_uKPCVZsp$BUyg9ao1(?_(Gtq1@BQp0bul=PM&Z>tjr_Mula0
z8qU{pV+Vekjo*@9&8=S_S285zWBGj+Tjjgo-xw0|amT{GedXZI7f^7>N2_+t9>~b`
z3<>$Te%!=3xi5b+B;@0qF&01MR<>A3!J)bwGSAOOZsi7sgnay*uTW_jnaGfkkH>pI
z4^}54y^pPfwBS%9TRPc}k{cPxh>(vhswaGr?+K<2rba^R<D{t{OUVP?o*^M0=M;Gz
zE+e-yB;;ev^Wmdpq~#(C4*7T__VIanc)S@B@^O&&dxP)PL^34g<6w(Er{&;j7gKP^
z$0A$ZhsyVJIxr+u>R&58-z{%}w=yK;WBBgZ&*b~7zX=HuH$IzqR&HdAC0bWv2Yx)d
zWxgtJHC8bs<YO7DurL|<ks%=;T|<`KRJ&5Y<a&fqaLC8%hkhCSC^v*5As@@kYWql@
z+uk!I<m0n?>kV4zv6O;CK3c!soKoIoEn-N>#~Cx4e3TV`%aD+dv7hT1AU&2*aL68y
z6~EJ~muC6{KZ`UZG&ncyk1tbi(d!r7R|JGs$EWpI+R3|g&*f_Bir9gl(pDq(%SE|}
zAtAvtHmT*ScBJ0M*9-{>zOa&CxZKLBp%fev{K~ZZkuq`)LqdX|b*ofJMm}RmsD`%1
zFB&iRrSl334hi1A)m($uolj**NbvMcW*fYe{Q*Nlg0JcNWPm(plntZckl;3X3XGIb
zyiXw{ROw?E&0Z(__=*uB#lu=1G<bqtWu=xI`vTYfyIG^<)o}(xLOwdB|4~YPd6{1E
zXABAXc-CvU!7;&Ft0*|+qu0=!e`Oy-7!vZa(CmGOWaL|hgnSGO^^KDk-0G_-IOO9e
zM|*=KCBX~{`FOA1=EidHXofW5Bi*pwk*aJt<z{X2H>kU;(Sn;OOCt95j`;W5Or<;Z
zWx0qEAs_D^3{FrNaXm7QA)#3#*Qezx<N>c2PPt74r+aO??grY(hsIVgB;=#z#(~S^
zxh;+%As;t8%!-g}sQOw84*B@2h=aA<$^{Gw`FOteJ%huHuNV^Yu}a`>gT<`kItmW?
zxT5y3z4DXXnG9*dM=B!ks0pdn`vv;_YBV9C8tR&_*C4sltE|^@V+VfboNqo?z7;x;
zAt4{b3)VL{5F5vkCVZrcXt4i*Z%SDzI~e_}QDp-Khx&3&>r7SUN}t1!kdHps9sK3t
zdCrg~e5BwH-e*{&l%;Z`Q6JoOBL#<i{P3`Eb$KVafFU6tCqL@cK<>*JhJ<|Ve#Wn!
zyiu>ZiGo8uzU^MLr@C*``xr<_Xu!{0o9-j$j%Gw?eaxIN^|_36-K^!t4*V=F{l19Y
zm9rVrgpV|}y{a&BpW2oBvV6jjkdFtheVZ>IgQyfi!J*;FT;Qp}>*^LUqzNA>_?@Nk
zwsP<UhJ<`vQJ}~cdDdvMg@QvqUVJg-t9&^T&XACgKH)WP%127lY^7F0KE6y-Exp>8
zdLMfd5*nQwb*Gh5kM!xw@-QPpKE4Zf$)cW0(j%>tP7nTf#<pTbXnhRz{xDqb%ApJi
z`RFw1d85=xON8>LZ{<yfgnS$kdhe#ZxwP9(!66?{#3p`HR8s!*tsKmd(1^e5m!hZK
z$`cHU`B*)4qTI?{krW*AF->^naCvU)$&iqbmUV3B%Cp89hJ<{yp8lnpYLDK>d^@z@
zP*+}dJbzVg<WNS0eC(Pn>koN-yugr<j}@o-4VRI2J1IBh<GIUAN6WK@A45VuPE1$0
zo{YT4kdTi>Ld&#}C!(^uC^+P!gJqAo^5uOXLqbJVFk+s)dKsmkHQq2J<YVih^E%2%
zkKGg;^08^>`E%sHT*8nhe5Aeq=)CD}Dahn+r2IxmD0h>09tGr`V5>b^ZWqYMbB+(P
zsf)ONbk;K@<m1b;;q7E(B11wx{`9WjO_rz4UJ4HRm?c}qYwB#N55AirF(0R2Ybp;<
z=6%#k$j6}Vk;moR8l4#u^3me_{Uz#)HT1y`FeFr$OUp+;lW#&4*iXSBANOyc7$z$|
znjua2NPGWc_jX=X>r%fyUMD2f$ZA<zeUi(v<N+<WE9B$6T<<2Sjnt3MREC6n^bT9T
zS3Y3ygdrgx13MP^B;SK5dys-dK9*}Zq?<h8Qy3ER(dJL#y0VWC7!vZaY06Xi<Q-9&
zLlhkHF=%T!3wgvRGbH5W@>`$Y$otg?3<;I`uq8Wl%Y9kpFa?Kv?DDJOHFd9{_i;8M
zA>yB@?tyYw#xf%0WAu$1^JQd>BU<jtkdL3X`@6}r#uA2veB9zYtEaqsNnl9G#|`c^
zcgQ}rI!eJIAN#Cpyjz|%A{Y|#@x9|9YxNMPe!5I?j9Ll#cs6qJzipe+pL%2mhJ<`9
zTRGb;Irt%lgnYD~lXJZ)kG_@Jj#F^Ro*zdB`K#Aa`U5`$G$hoM8wxgWtQNXn@M8po
zZ1i1g?<MbD@}E#sSHceb%qq4wR$d(^GbAK<V#eJDZ(hB@kdWYMayPM)*PWs#DYyy2
z>GGuD?zJI`I!YDkD`+%BLV{1va=N@+=XV$q5<J6}4+bC0Dt(HALuI*jd_)Vml@l2f
z65QA6N~nAr>o!9|f;YH)yNx{mmOM?tA;DLd`Eya-7U+GPKuD<4pY$nmN1lbAFe0S*
zbiaxQuMw|$M$3&I_-Q_=(o<QUnG6Z}_}Xc)y?m1~iXlz-NS7z2Y^tx8TUq`r1&4g>
zm;GP^xrU}OB;@0iw!aNd*gj!M$VdOyR-@&<bUH`DAs>T>ANnKj+WZ+3^0Cg-cUR=T
ze8iBDkG`>v&gx~e-bbhNT5zZ=zqBh*My{biMl|6gEfX{1?{!ylE8VGICSEWkG;1`B
zZ1+dL^-|>m<%WXy3hgmR-Mi>pxsV|tAJ=tFoGTA_3`3gmk^1sgRINfvKPut%t#rRg
z!66^F=J$Fhw{j6fLOy2iwf?R=JntA1@^R1PR7pENDR`Yr6ddw#>6YrxWn>sbn(&c^
zC#uJ&{mS~7`~co}LP9mvu*$&BawFSZ)^cM9erohz;VoZ?Z)ZrzM~8G-w3Gh&vP^k}
zS_%2+y(7lpmFz7U(nMd<=;XI_Y@y6;$tR+4hBV<LEx7}$Y>brU`N@!wk6yi<f6FUR
zv#ZpXkdKxvuN;&2s~Z^-@-c2<-^w!bFGE5;9-flUU}MlC=|1~^585j^nedT@$Ki23
zceO9|>*EGOLId95b<BHtpPtBwCe}x4<f<#rs;Z6D%hUY2mK!_pV}B;oDs`W(M{Z(B
z$j83(S5J}mSm|$2D^2)F!QG3De=qMf+A}0HJZZi--IQAy$&iqbHjnpQmMcBwO$rYA
z__O}RIr6O0h9Myz?Hzjmlv}x#At4|AFMJP>Tbb$>1&4fWfBtA1^=eP=qc<U;(RtFf
zwT=8fv^|Un`FNtomYi}~THe-jV+Vdx1`bLuk4}4rgnWE*bHD_7zq*|vAs@HeJl-bX
z3Qc{7f<r!z`<Z619K16_LL;6vY>~l-t9LUb<fGf9;}7LoBYo07_WxI&iY9!dy+%m6
zJoA;{ia`1qxIIIf@R5)c$0YpwHbipdc7}v}EPA9_b9L#_`)GMj3vQw-sgeFY4*q)?
zgd&hWw+|yiKCV7&Ure5dA{o-eewA7|`P=io@=h@Aeaa2_*eu#>mRv&}84~jGNZQ5j
zvOL=u67n(Iz6=lKxh?er3J&@BAlAN_+)8hTG*LvfF>t9d>X1C*+ZfV>kAz&G>fm)b
zxYa`nZo)@GeqQIlN=EuHB;?}^>#Irov;VGg^*-((B$T^w`CCQgMy7wH<;D*D9B~-p
zB(FT38PbH0)RjTwsvnULsqA7%$j5@i>)FW2%#SHJ<YNcV5i@0EZ-#_?EHJL>RT+7L
zAt4{LzpR~GozwL*aK0xL9P-g-m&d;si7PGDBZo31RF`q}W*EGu?+QagKK}8{7$OHR
z`jmo0K7O^XG);c~IF^u5BZs;AEtRLX`-}*!kH2nb50NiP9iz0|u8@ygP7gNtYTp!w
zgnT@<GHSlu$~z1R`PjRr+c0^+OFg6DkdIBT#TndKp2U!lkF6hEt|rgG4;a#fkF<Sh
zcKLK_1(|#&=$Ldz^Z)m&u9%PS*B+2tIh7%yQa}9n%ySv}h#?^#yDhv@P(7uhUmq*H
z(1Jt6Wxajf<VMb8M99ZdiPo#si(LI|`HCSSA4B{aJd;~lGn#TkK4wjEb%Q(+g)k)K
z<KkJtspK2W9~jbvk5uV3DxN*A>@|{Cy5~y@4*A&mii?A~$I=haB8D{KBW+)PzE9mk
z4j#{tkdKwS{`#c8T0`GTk5?4jgpbshaen^Sm3~yFOg(ZfLqhh9s!(LFx)szP`1!3N
zq1ZM~MfS-HZj%@_Hnv+G?bXiU6xwD+garRG>*oV`-ANfsjf4dMc3@Bj*+y@Mgaps?
z<Y;BN&LbHT61@MUCDr8M>0eWD6M~aEzQ-qLk`GUHWk?f(Q=PBa(*56W<de@CI~WoY
zJb$|5ljZq0?HdXXRr>K|3GL-Mqa#C_5S;ol;%~1EGIBdZLV|C)88BG=9jSi7O&O;J
zhbp~K*OH&qkA&%Gq3(<b`8ejnodmfoPctOc%0d0?4$8><Zz(tAW0Nlps>(Gqj3FT(
zcb$sADI+g3B;;dU^k#!svKM+s!A<x`Wx3bse5~Bc5ey0W=ovetr953;W=P1#0cV?z
zkdZ~-Q*g+~7g6hr$usa6hJ<{aV$<NSyaB#NNT@7-`J8(p=dKX1<*oqvxT)^N<}z{y
zLqa}w?Q;69jErJPD0pAHz6KBBTs}~6$j1Tm9qY>z@EnGOeB9IMWifeujABU0$1lBJ
z|CU?n_>qD`K8B<m86hJlGbH5Wn`P75$iZ(hB;@1j5i`T(Ru=t4!66^_eXZ@GZqxPa
z<8VTns3F?DG_Pc1aBY8|5g{K}TwDEGmZ#ijEw>ZoWAi_A48Gnxl_4P?TlXC3C%5t;
zLqdJ|#wx$9vhpZc{a&NO7YYvfIOxMEgKxf1XGqA$+JV=D<n{3>Lqa|lwtHDhUU@2h
zrQnc{#hzp{IIJ;;At4_#Wc+eResUDekdTjGu4THV9(>XJSUEup4h^_vx?1h!MlNAQ
z$VZ<$U3bd2Lf<hY<YUYABkkl?*7!!bAs+{x*nLng%V35y;Unz?qt`ZWDewK`7!n$u
ztDb-BDgOt`pI-4s-zhlc<LVLvZDeF9Lqa}|?qcmF56^psG~pwy6CHNO&XMP~nm;Hw
z<l{=aZ3dV3Aq;84M`~sIZ6`7nOB$LINq>4DKN1oeo$@aiJdp3M`ux;#SA=}b()(zC
z`C@NBLqa}&K0D}@EKjyy)Jn+5$Qc{0<@K=_Lqa|-u-)5M?#m+#3Hf-?^36*5JXYS{
z6dW4yW``!8mZ!_U3<>#YS8zaM*~h~SX~IXE+x9k0H%O^_<xf8mWlwsd^xrcXmx_>&
zHSX`ZDYw#>Ax-#5tsHjuTC_UidLK^^66(s3=Al{T+0yQ>mK*z|*M_#;4GzQ(WJt)z
zOGOh?$%>z4NXW;KUl*&&J{Cx%;E<1BTr$>>`*Ju#n(&b(;3B0Ty_FxJoMlMJ$8Mv_
zmXm|$waB4XdL^icN>6K%LLMGJhJ<|Vd*b*}xs?|f67tb<^ZCQ-!wJ3Og;G#($j8_|
zdt#LzizNTS$OJ+{xnsO~8XWkEVnk?t40zpgpnNq^DW#Sh`=nRy_5)kW13s4_As=my
zH1w1QJcc15AMJN<n<3BX?x`ra2_I<!Zan(?I=Pi03<>%8wa$8j?^AwYNXSRmiOr|T
zBVH>t1&8YL#f+K;Cl5mz67sQSc$B?-Kj$+;LOxDT$aPs&T)#fnw$y?{jkMmsc9VP`
zYc(T6K3-{FIZV#|i6No&afzq*Ss7W&igH6fel2lvv5Z{AkS2Vj#capIV*g(3uLz`{
zfMXdF@-au&%&lb~-P2HT$jAELpO(qnwqS;Ye0;d><Yl>)Zx|BtabBw*HD#nnS_%%8
z`uCu$H)Z4!hJ<{495V8fygtSg5+e4<aOb+b@_41wa$}$L8Z~7?gnY5LfgvFu7fj#t
zP_CiB3<>#|@b#R*W4IRSDYywAX)!w(zuMq{`bLI?d~B4#-{2hve;E?;vE-r7$K{{3
zw9G)kAs=rP`8`}7@$C!=`FLa1`W5ot-zp=u(u9vRUD{MXbXX}O#Yz2i*@ht@d+I-H
z(OaF=^#^_;G^B|(QVCfPbIc_lF!)VCXmzX=RsNkUc*jg?N4jEf_$iU6@=1AO+ryBM
z;AbvI9hQ-qGE*xd!H=G*bVaV9?hI){aH^o0%~Ot4TB-D>zJhi$BqVrz>*G!3;2E<}
za7geLm39`Dk=+;)61?r=F@0p@0fvMG_l>D+@CZ9wRtgTu<C!WhY2Ra!bUpjO!_%7~
zA;BFF`F@rc+!KU^D!t;8nz!Y-vPd>9cX>$h9n~x{s&}#UWjTr=p;q?to)jS8x4grU
zkdKf2-j|Z^TNcYs!A<x`vt_NFr54HCf{_df`8Y7pb%or@%M1zmxNkv=Ix@0g4hjzW
zSU5IwKe>p8FeK!o^X3=h)w8SmB0A5IkdG;9uL+iiCx1=~4*8hych^OEee@$FRF)lH
ze+rko@)jdPKKe(VIwP+<_PMm&6(ApnO`Eh#Ud6{Sq>13PnC&W4{=D)p<@#Pf;5Qi(
z@-garPJ?3*WvwYV<m2mGtrp3BIfWr1AD5jfwN)<5TMTK!N9xO+@o|-vB2v~!eP5Q!
zO~D}_7i@9-EZ5}(hQxfFe`vFeyv>l1k8^F(t|*igTKUu8AS#{obHo20^SDAaly!cw
zm-1F)0V6^_#-#N9H!{gb=QTq@J|;d)8zj$`HEb!j2_I=O3txKkqC7f53<>q+s-p4f
zW#k)%gnS&d$0wzHE3`%)3J&?0zijWZaw|g^(u9xHmn&-~RFIMJ3<>#Id++O_@<dcS
zF9nBuwCy~rwTxWEkdTjF`(|xbkCf<rj3Fd6;I-n18hpmMZayuyGvs5bnJ=Ho8=|EQ
z3Hi8wZ^B2}$9D_~`MB_QjR1L>@W@ZWAs>58sdrG8XAwg}!*h8{9#8cIw0`A@XGqA$
zpC3ApkZ;j9v7_LSkJYM`&L$7f3WkJyJoTrfvwG`AAN&(TLOx#am}oCwKh`Qh!66@W
z*V__XAZcw>{`5YsAS5(88<*_wF6T~FP-`T1;Ai9eWd;YGS}`Q#<I$B7G4d+Dg&`py
zpZ__POWp#fE=0j09}9H*enVE=han*!!?TxMB-c<RLqa3oCQHs|a$jaBOu-=^?@p<E
zLq>LGNXW;<t#?<Gk^31E@-d=MU<!G<%vywkLq2XA)qbjcKc^2Np{~rBG00$aE-)gr
zK31w+YqH#xg^FsqD?vUM=rN+XT<Iej67um#-_OJ3R$gXE$j9<7-IGo_OK&wTT8x52
zKE4h+SWrfeV@SxydJoI&l!M=4NT`U;mRnm_MmiLy;E<2wc277guM_?Z3HdnuO^<8x
z#^4S^LOwQmSueBvgOTDTwBS(gn40U-%DHDSBIKiewKS{c+z%NN@-ec-X)n2zrAtz7
z$j5B&4wjG=AIFf8kJSr&e<PRW4Tgk#OtURlad{OlRf>W`KHly$+29V|B!+~1oUn15
z!E||-A)&gQ7tkU^z9cP^wCVi+J0&iVkM}JG8ob?eGDAW>X6Siydy%9WSozcMS8oy$
zYUHjSe+^!g>Q-9IjeXL~_D?>8H*p3sB;;fBw1KDPvW#X($j36%7R-?4aVtZ?As^o^
zm|jkPDzlIwAs<t28s;lsnLTGn$j7-^Ga9`5uaW}=hkUdya45Arw@qV66F$-{+c>w<
z|IQF856<-0kB=DAM5z;Uvfa+_N?$6Yu17kRrQnc{c~@jFEB}CN8X+O#^I@R|FZX=K
zh$hxY%00bDwyR2JMIe1{mvUNe?2}#}QXe(=9^M>=G~pw)^2C=er<KuB>PX+p7Yqsc
znC?|*FL~B*airjokKLzabdiyB84~hw@a$&yWW{3`67q4EXX@;7E31~L;3j;eTeg$R
z-wBeD3mMXckA#fMcCCxN<i;^1WKYRb1+CP+)F1fqsGtUifI%Z~_mXeeE+n7{8!7c5
z=YGy|>d%Y_AwTSMO(P@gJ87vMp#}Fx?uL2Qj?~*2#*iiir{JsBRNW)D@-st1g10KS
z|Fv9{^_?j=BzRe;`f>8ke-%SQg6}##ucM6o%#e`a&u@RWl99D5QgBG{J4<_SlKXNo
zLqdY5`cmtbyv2%VNXW;%(+2*PZ`jtUqy>j6-Pa}mIC<}~nGqo$x7pRmAU{B{aG^#*
zt#sd*d7tcK3x<Sz98<TGuN-_mLqa|-?-Ld$2mj5GkdKz1Zyc2mPc?O=zJz=n*|z&u
z`JPh*Lqa~Du9n{50JLRgY9-|3`moYj<mu9zAt4{TS}c#3ecaBFCVZq_TZ$k4MN1~_
z*h(e+=`TprRMCP%W%+iHgTYhRVT=g*SSQ3SR-W3<FeK#TnYf>M)L-7{*GIdml-opb
z>dL1Z+HX}VJ^6Q7$1)`3<D^`Ntds><`O~-ZK0`u2R(L%4vD}yTZWJ8yF?vy&b+V6>
z84~ib=8Yc)zgv6AkdTklOJ^A;2d_|#f<r#8Z=E+*E~1$XX~IX^Wc8oq|6M-t6H7>_
zh6dD1J4xLE>uac~yOtaKq*wk2(dXsd+Zht_F(|Y_C3$MgT%B5J!bj@LSDyns<wu1*
z7!vAB_bF8kUR!*WAt4_vb3Qk?GnT6c1&4ghxVYrMH?J!FsULA)hJ<_!?OW7WzB6`;
zAt4_fk3~<HM?8lI1&4eb?KEV&yd&z%kdTkH&#a#&-yk|lNNB(hbZ(Map407;%Jsh+
z)s?XWKTo{!hsa$ykRc%-txl(ZC?n4>qzNBseSA?X{NMW}l9y%vniL%J(b}or1zB-F
zhJ=RauI1B?^6*?@NXW;xP0J?AeVM-&1&4eby5`zq899_8As?q~T|7<RuU=$G$j84+
zH{_C$g=$l9$j9Da7VNE%G_NUt`u*w%LPDc6-uhQ@xsmaV2<=zfO#5|8M%J#Q<;Fhg
zl|I2cUcP=@#*ij_r1df8?|UnG+ZNA|kdIaJlyQ`U*Q-mxAs-v}u`>8j?h1y4Mm#QX
z><+n=pBNJIaZQOr)n#P8dK4V;F>rrRXZc!u1w%qU=5Bg)l8pSwkdTjI1B<;<XJEaL
zwd!lZp{{&b_I7o70uE(F$VZP(kM7I4-!mk%KIXG6JXDs)qXFfHd>m25KZAUMvXmiB
z_()4`#dZyTE6ap})$as9F(l-p|EN{oa;4XANWmc=%crY0Qw|=+kWdkw*|@!rT9*3Y
z-x$(_kJOhX?S~dse%GD+_dLxSQE(GJ60-NL9=nt~2Fa0I7!vZa;)RYeYG3MoOy5{*
zrHS0MOzgNcbe6o;=)#DQkG(yb<dv@<_c0{oV~wo!Y~>s3)=elk<YV~6LaWuT)YnjN
zhBV<L_2r%gXPe5%V+;xTIOOVr3Nq5BDFugobQpHu;Jwm=7!vaF{N#Yv@~m-!A)&hL
z*!93M8ENB1!A<x`!?W4PC6iq00~iwWF+9)R_v%EX_wh6#p+?&L{@F|(aJyz&ZtTEM
zpG$Ac$p`R;GbH5W`WNnx<<U9AkdTko7NtF8#q%|%;E<1HLZgn$tM~whgnYcc>~tYH
z_*sU8e7xwJGLziO{4FRr<l~qg2eQe1Ih-LOAA_v&{ZN)R<xf9do?}R;)KiXd36@K}
zNJ|P1`8eod!{KUQ>U|tTNQgM0{MdYQBX2Syv_78A`_4vQA4|8=a$^U6#?O1XM4gB9
zqcejcAs-LAtnpL3QjdJWkdTiPuG=1v`_ip71&4fmKjNa7Jf{aSB;@08Cl4$6He(z^
zLOxdd?qF~;v_=~W4*BRlZL-1P;>8RJ`Iuw>rSAsUQ49&$vtjL!it2rh|2go}_Wy%p
zYgzG&CCjQ+sTX`90U;X;+s93nFG%AU5kf}W`{$QC(yg7A8awba{?Cjrax3RDBqaEb
zDlxU?Rz@)-B>0!f?F>$#IeAlXNbpMIrjC`LZ_Q#zNbtGy{U*q3_*;gA1V7WLRz`Vd
z^K4JSA;GIIne|kjhL$oUBzUi;ueZp^c!q=ox148}S`DuEv6hb(9NJozOc>KuK2fra
z5g{MH<gI>G-VS|dNE5B3YkTh}e@`j@N`7tMpabQGd~`ilO#AV<e!*SKkdTk|#m=u)
zf3K%UT6LsWLO#~XzsBHmg}oUP@-bxm)_8e%jxi+UWBRX~_N!&751zdf1&4gBx2Ss)
z8QGU1As_E;YjZ|j%=E21!H|%T^=v&)t4O_%c{^*tp|X7OVC@x^sBh#DMudEPZILdU
z{Hyy*3~9ngy0*_0aCv0GBp;POeJe|Mq1;gLQ&|@*lDC!%7!vX^v{?Vyat*y^NXW<g
zFK1_$FYZ0MQgFz}UT)j-$?M~MhJ<{qUT)QB^*OtKcw!h5^0EAoA?eklrg~)EZWJ8y
z(dl}nVsh{;3<>$TH?;mS^}<Z=W2)|2E1??dRqoYSxh#Dc5%O_T>WO}G?wt$?`M5fR
zPmDaLr|UtvP54Ml?wfJfcFT9@+cTtzz9eMFa)p=5cj)&rB;@1tZo_=!zRcN^f<r!D
z9dLQC+?RbB67un9?3?5AM0AKDAs>sjJNi(b)N}Tt;E<0$)6O;cfzS|!gnY~zkYlvE
z1=jm`k&w`UZ^_v_R`#(#Z!I@=;HQS=9fNOT3};Bl$N3AUZjoDgnITR1NK0;^rZep2
z+gL@D9?tzc>E!C@Y{ExE4!EAXg1pz5%#bFAhZL{YWXTcxq)kEDWE+Er3<>#|rtqDy
zvX71WQgFz}S}k7&%B%PahJ<_!y_My>+{*V13HkUTaz%)YtkI8xLq2W~emYH^i1a=#
zAS5(8HdCf0%3b-I5ux?*;;H`g<=mC~Yq_xlKkHWgIW8k-F(l;U@2kGOWW^sdB;;eR
z7xxUl)#B_+!A<x`ir23mXYk&WK!$`y{9^Ss3)C9Y?*yY667um}tX&^@6?Ypz!A<x`
z6H(p?iR~4nGDP}TE?`K=$G>~i6;l^8Ju;RdAs-75yR3c7Oz&g0fm(2=D+|YV{r96`
zrJ?#p&Syl($A}}f$H|rciXox(@t2SHR=I|%4WitTkDI!saFaJg!3+ucnDs}>D)N&1
zg&`pyKj%8XTkgx|gDE)VW17Nc@5=IQWJsupy1d%?SH4%B$dD#{q={(Hk9);sWOF|X
z4*A%1<n8YA_GK+YLOu?B)4ZXI)cg3CkWlWyjSo(gCymxawA?O`k9EJ*`=&nS(JQ{0
zAt4|4M&>qn&wC<6LO$9|iuI7ovei%u4*B>lWha9JKbsj6@-gQ6%e+dFDu4REOf`&J
z3Hf*_*uh^`yd^_IK5qUUctw6HvzZ~Gx-2*B+!eW%8HZDF$j5Q+FBZyoow_k3<YV00
zQJ>XGUGL*bLPCw4xoc=cdB6*e&~jrBN$VWQYw(K%KZb;S9GIg{MtRma&ybLh(GQ!h
zlaY2KDLCX~<;(pIzS=j0At4`6u4s{8-WXh9NXW<NyvN7Nm0oxh1&4fe7(TAQx=iS2
zjZq8<`FJ9+>tXph+zp0=O5Jhz6odC>mK#mMAs-tZ|CCnkOTCX%2?-GstF(D8FB6X#
z5n3OctU9t*uAvHJwA|Q%pM~ji7`!iZCPP9#9xYzZPVGv44LxH>$Vcnd4rk@x6}pb4
z;E<2oW^DJCXN_qL3HiAHVxi+Q@)1KqKF+dqYbPVikE7s_kCDfx)|A(YsSFAEcrf%`
zm^|Wl84|Lm_u^yPsRjLkpR(iC;LyV3<@mg}>W*IUNd$y!?2^fKjk<*E>--)gLdYC8
zwLi*8mkC;G?7+{ix~DrUHxHCQeJd9+BqaEw@Z34%3i`;9kl+>5t=plFj=q(i6Dc?(
zc*v^M1?8e#%8-!YVRurmmu>vWkR}ADyE%>L=0C2ij>@R(gV&iv!6CtGK6ukjzKUAI
zkdWX<w=EtouVvpD(uCj?ylBYK9m>vMIaZ?gvGHUrIApm0s#I&_+*=qC^6~EMu?^+i
zDW*^(p;mTX(YTk4Y{QU{j~|ZI94_C1*us#IkF(oO_;=-){OZxdpMpa^UYncWPo6cJ
zF{B9}sfJb^d38vcHIyBzUY^wqX~IXPT^1I72RgTLYBkp2z|T*HgnWGavi%WxZfhPu
zeF^!Pc6e@spQdhNNXW-c6?2SK`%>?t#Z;}8P+4BJU*jUrmTedj@^Q<Pd@bcUJ%S-2
zA0JxfGgu~4O{3gU@IEQ-&XJ$VcrzsAV~LzrNdcvADn>9Q<YU6r7G34Cw3<%AP54Oi
zg#36JFC#lLB;;f2?scBXeYuArAs^#>v!;{p=A@lL!A<x`6Vds0FES`~sf5>0M7<f(
zgpbshLytEdsa}ceeLPA?sD^sxYh|#Q<({eK#@_JrC}!0HdB5t*kdTjI5AQ6I*T+i?
z3Hj)Dc+C`f)+juSf<t}TqW-$_a;1-ANXW+tJ(n81%=J1$LO!MoE7MATgk5Sj1&4g>
z>D@d)9-dJQ3Hcb(C{r$Zc&;*}2_H$G7Oi(JmbZe%11UJ<;}x6A?bKH4eH=|lXu$Vp
zELmB;F?Nj+q4hB=cgNfEN5viHXt|vsAFF5Ebw{3nXD}q>WAmZKrpm~N3<>#I|3ts9
zvX2gPDY%K@p*j6;2Dd^AGWq5*fFVuzNJ!hAHUGVsG5Ip_m?0q_Px%i?FF!zWo=3qU
zAG4;7m>~CMFhfE<4sCPE;6eL4hJ<`<<T-qcx+Bv2SZlr(+{Eb6q!C}Jo1;q9FXEw$
z2>EFJ`SL<_5!WNXF(l+;ml`$?)Okpc^jbi<As;vPwC*k=*E1yK<0{+zRx<K0Lz?iB
zhUfKJ|88<$wpvKRp%H&@`C%Iwxs@RyA8Ri2J1YlI6GW|qd>mhLf`{D7jtmL;c=6rZ
zNpdUqG9={VFt>j1)mG|#%p9x*hq`h@g_d1aqQ265G9u*T_N9$($;hJ&3Hg}5$W?zC
zX|srOLq0D1P(7b~KW8vQLOwnp(D|FZ<ep+k$j4lNN@kal){7}P<YU?C5Aw*!-V6y9
z(TDLD{(TZ!*|X}4=m0}PK0f`Ldxb1d)+H1i@-cJOm^JdPl3ol6`ItG=*Q#n=>U}&!
zNGSK044w_;M&=CBa$^U6E?fLADQ`9UFeK#Ti{Yg=%Ul2B3<>#o_(?W{=N-A0QgFz}
z61GcU$u-oIAt4`sbgP?1?#sgr3HdnEXIUQkVlUS+3J&>b^JZ)wWkam|>3!_SkS6Mq
zcGa^|m29p|mr8Bwk!KhZ^6}cii3ZO|ZI@GU6FyQaH}@Z3N%2wHVd{PCOGv1ZzBZ-9
zWgky4BD6jpf1AIQTtm4-wcM_dkIQ;^7+l>CWJt)zy$!}0yaf6TLqb00YL(%)e83?8
z3JMPSI3v{g-+OG6mt}v3gnT?PAae(K#E&y1<YU}Mx74!Y)?pOfgpagQACS}cw7h-k
z&yY~5$6fI=INNrVAx-#5tvs2wS}u8g%(_ww4iVRO>1iNOZ$^ZCJeT_0DA~tj3~9ng
znuof6@tLjEkh1#dXG@z^lpFFf%lyla<i*UFAt4{@&#hlo4t|OuAs?r1eqnGRHs5Lr
z4*B@3;fgs1!5I?raqEVfmt-GLF(l+;$xc^8<sDI;H5453v0%Z@i868kLqhiS^KBZh
z&KmjyKPNOKRF#i6*UqYzkbc3<5w6Cr0NGe`|Je-k*z{#Y2<e?R#6?CPV@MN%)5LaX
zM~eh`Y^>K(Zm26QGTm4#-&XF+kdWXP0zVo|mS-5!gy1x@4X<4Jp<U9frhFGeKeO4b
zqu`L>JHnSAmLC;PVMs{uh@0-KW#kKngaq#xJtSZ1q|nNrK6uUb6dV%V&tv{J)kZyX
z4nsnMe_z=$yLx+7@8dH<LY1CAJk5Be?v+1%BdcuCa+imEjNMx=kDPlJLqe?#xN*OM
zjC{h7kdLj0^vEa&FTat3oA8n3sd=qcN@ccGwnX~AoXn7rk1k&`u2fb>1*=CsU`P`_
zvQ~b6FiE|L(j&`nqTrB^;frDnexW&&At4`s%zLs=Ry>L!As+{>IuIzY6E!wdaLC6c
zhxYi&>*FFqLS>ox%%Md2G{8GXgnaB#r1(H(_?18XfH#WJa#w(SY?9&iP`NADGb9xJ
z(v^U2@;>knLz?iBR`H3Q{AS9xLR%(1_WJLo2o)+oK8}8!=7Q|wI);RN?7w+YGa31Z
zAt4{1FDiXP-fOhnO2Hu?=U?tWNB*_zc7}v}JmnEOLN21r+o+Y0k59|3ah2D{?u3MD
z=v|c;59As;%!np@qzSm)if<{D0Z;B@mhD<@C&<Sitxum*=OMk~JsA@6@zb|V0W$Ik
zLqdHSwqW^f8EG9!!A<x`id$s3yG>pu1~4S#V{g~;U6e{sewzFWLqa}&e3h}Ova449
z^utqT2L*?GTx*g2x;&}RXGqA$Mh~xURPW~KTltnDAs_R1x4Wh)uHUcL-l+wL2E6L?
zXHDgKXelF_@R4e$t&`tRxh%gkB;@1Jd`<4lNUvR#8}c!Ac*Jt~9NGqkgnVqeZ__Dx
z$^Fid(D3B-jR}^Ar|E7AZo)?zo)V)YUF247VMxfwJ596QkSF!jd#II=kG~$i3X+%H
z)(i>xc+h_0WVw|)7!vYvL79=-b(G%6)O)qy(CEy$F#UvlcB(ZaLO$Nuth_W(I;Xvt
zAt4_hIam59Pi@)uQEte`h|ll;$Yt4=At4_vye7Sqk;fSl@^Rv$8&71U&3+0Fjd-($
zlYM05K!${TJk?_SA9=bw!;p}Vw$Gj#e3;Yj00oD9oN@kTq&x!;V@SxymHYSHQG@G!
zJWWWbD{tFPJ1I9Z-$5;RCCJC}N2Yd>=b`=#3Hf;PO4hFOL%1Uh3HdnN>en&(mTith
z6ddyL(EeW9?`QQJqFxLM`Pk6DTopO^A%=u}tX(c_uZ+xgn1Vw^^rG&v2wCx-3~9ng
zy6EYV(5AWaFJ+C?_vK-RgnT?uviN*?$+bB`!66?Hx4qX^-meZNq>0?Lduey;&R><N
z&wZW|As<T&85Jud3mnyQyFfm^&VT%ieAj6hLqa~<+eRe))<jyxZ!sj~V}&CvPss-i
z${wTOkdM6!+G-al`r#SJkdTjAEGk`-%km~eLOvFnFmRnxQp%scmF138aHuYCY&hIm
zU3v7#i3|z(*gEE~!GYL&3<>$Tu-2~t^}fG;eJpoE3l23h&&@tXWO*hrq6r^qYMZyV
zm!<MA<##ChuDr{TkdKY>{7sMtyuwM!4f(jJ)w>?@GBJfAAs<(4wlesJ+dYOf;Uo3s
zhl#bDC@YUrn)<#hcZz~TKHmCXdA&U1QyCKS(YfG|zw%z=5ko>gcIf};irh-a(-a&k
z^-`HVv&k1dQyJ2Pk2E}mn<UOrTB!_=-p8keG(n{Gac7Oq25)S3KBMKXY{ExET2xrG
zS+4Y13<>#I<8Hkia#uz%B;=!S@g9@qJyzwj6ddw#Q0M#3a`1T!X~IY9OZ$mW=gGle
zG9=_<s)9wgsB^krarbi+9P%+|$)Tg=E0p;R3HjKz<8CMUI_d>OLO#xUvgNAWN~iM_
z9J1$>^R}z%i0cph1ZYU8gbsP%daX`Fdcp4z5VG;bLANkDwZjE9wUZ-+y!#`|CwcEO
zfgvHmFZJ=<FWY#RAtAvF*Dw0-gU||AU*}~nQgCQ=@-5lwEVnX%AtAv71AR)!KcIcY
zkdWY^gVH+5!&CVZ1&0LpP4oD!TIc${oX?OZ1gE9U>&=m1r7o4JNRNEQkdWZVT>8ya
z<<TQuFH>+xaEtsN_td`B`#6V?P^C}U_G6pe$d`-=`MB<Qfp#*o>J=?_d8n0DAAajC
zBj+<D<YVo#p54^0)Q?UKLqa~Te(aq^-lkW-O2JL|NM)HlNB06s@Z__`JcfjP9D27}
zN_p0J#gLGXUc-(Vyoj^fH41LRN7`vDbzIU(Ry>#?As<VRjr@05BY9uGVMxfwe)-!p
zQ2SEvqsMhEI8>Hb_g(BH*U(}{G~pxFkn@C}ca*M7o;#KyP54O2d$kWXk&)GIP;MxA
z&)5$JAD~^pkdTkX9m+<_i`g57G~pwaWeUro20s<Ady|4gK6c;gvRuB6wSpl{_(;R!
zWmCVlazUyLk$!G_$B>YZ=L!eUlV@O$TNE7faax<7w`Ii_GbH5Wv=Y|ZTWs|{z9l47
zLtideZX^5Xd0Wekz2T?D_~{wsm1iMCn(&dz^4R?L+JhtgfX6W;<l~}Au5;v8*1SW(
zp}y?<^}!c;z?U&3<YUN&4Qb@z`M{7Sd?b1L#$QfQTB%gKzAruQQgFz}&`SsZ{k&P}
zPd#!GLqa}Q>0(tuU3v7#cMJ*n=#e9Jw0w)c);$Ui`8aW7oWUncRuB>z@E#c^OqB1n
zePTot>m$i?eoT{|%J3_H`mU^VU(1cX;b+;Bq8;Sfauq{DK2FUM>LZWNH-?0K+>?9B
zFIn+s4=6Y^JkP`W?vsOWWJnV}((r7!d#AhH%0z}V;UghG^;+0WMz(oK!66?%4=HHy
zj<szJ3HcZk@U(~AO3O#oO324+UK1CnH{0~<V+TS)qtm{C#Tj`5-o}WKk7>?z-6bO}
z9&5R=PkL>zbv>-+)+^qOAt4`|A35nDk4`v4LOw1{n|Y6n{LPS%kL`TUPL-cNwtPZ;
z35|GA_Y|FF#kVsg<l})uulvbJtEbdT$j8{AXYb^`^kGQI$C*1S#md{4T?}c$N7`$A
z`!Z#=@-O8oMek#}C@r{&t|Vfc#(rm&u1tQh*NqWP_(;eQmytV^e<eSwv7aHK{c7X<
zewOlp=X^%FAs=rya4^^y^kqoM$1EG{hsb-ZBMb@oIN|2NP&s(6=M)_BF}=%-b#g2F
zF{FtiqV=(TnVGp|<Ozm^d~8>F-6HwEzwHYO4*3|pC6}N4FsdIzn(&c=_qA%MebrX)
z<0(Qyxpy2MZZ9`7Z_;M_zaJernR&wx`Dk^-si!ivDOmktHk2VDACJ_wD=04$mlzWA
z@lcHkW#r%`Us7-rK2q?>$6Nh-1D+CIAAAx+LOweCxSWy8@*YD%J~nSt=8UYk{VNI%
z`B;D2kx02OCo-gox}?4=5$pCqX=U=hyw8v(d?aM1&)bJ9vqti|EEhw;As-)B?XpUp
zi1a>AC8UW)lHrx6dXAU7@)0ANSRV;_p=rfqY9sY!Sus}2jlJP#`t+&>TmRV%3Hj*s
zb4PLc33fC?n(&c=XDN01iY$-wYYGne*wk&TL8VV+NXW-B;n6Yjh(BdW$j5#^*W{Id
z*5dkxf}8M>`m$@ImMi4GT*Q!2sRwmE{6gLW$1<b|A4zfldGG%HvRf&4y^l5GwBRO)
zl>1_udN1YC31&pd#|il>8GJhFJwrn4V~Yyu56OzxeoMI_A9rpWJwgt?oFO3}-%O4C
z_sV>wrTU5JD?>s)b_$wULJr>O9R-Jc%r)=kPPr`CFeK#T$|9*A$@2VSNXW-3w;%M8
zk&WL|aLC6t+Z$Gvkzou8+0!k1RG@laLx14sqlSdWJHYq6_IXOZ;GXenY-h;ET`TvF
zmDimmj0ho9tSo8p3zS%fgalvG-t&=sZC~XB<%R^`@@iR>ybqkqkdWZ3;+9*>t$fLl
z(12Sd9DFScUgaYNhXg<6kZXuql=^9CK0`u+&v^ULPrmCP&5)4bw;ciuekbGliGo9d
ze?C~Yk32kq3<(Kd{6N1d>hS1&d`?KH($8Ia)J1Nj>t`)D_J$w3$CcB{qZ7!GP%9G(
zwB9JU@)<)yJ}w)5_J@qD^o4>$J_bJ9?Ij1F#gLGX)z01am61;w67tc$ak?%t(&;M&
zhkQ(v+3J+Chg1Iaice!m$j4%*E}WF7%X<t7`8efJ#U=7iqig~NhkUebG2wvh<5WUI
zW!bmi;vl&zA2A}dKBk$L;*y-(;hUD*%o~1a<G=mvgWk%Vt_Y+b@BoH{f~Omu_JZ8X
zdkhKr7}q7Avy627PQf7`J$G8{m4DDaogpC~JEeHqOMa63njs+{>*g-!DxY+!`GbN(
zK6>_i*Hx`_{fMt*NXW+l^{;!#$Zre@`RM)qv!9C8ua8ZBYQdozN^yQxQTaGlI3t?y
zk>v5cmV1b@@mB=Wcjae>gx1H2E#Ae;i&^bolpFG~=e*o=<ZathhJ^aEnO%?N^4#{0
zAt4{bHr7s*gS-Ex;E<0e$Cn6{kqa3T@^Q`f>jtlGh-FB~$C3^{?d7?x`X34o`S^3#
zYX^BETFj7;kMr%$TB=2)_wgekp#gUr^W~CULpA?uxy@XXl8*z9F3hhCxH56*eGFnq
z$VZ!84mIV`dCia}e56($?XY91+)9r`3J&?0<5Kud`7zHThJ=P^M?l_pvOJ#{67n%s
ztpWxwf~%W!M(e*vX3ox#kMCP8+b(Y|Lm3kCajU;wOL<rQnIRz`JrlmHlv`Oh1qFwE
z9Q0}7S9N&wK86w!8l8n*!VAld{K$wV)<;F^|2`1h!qw8?r3iIXYPqokKlLUDPm=FC
zg)*cGAE}iVQR&mmx9{FDB;;f34}F@;$m*#mIOJp1;O{AA<a~yNMts-IIn(61?FB<Z
zK2G`VZt!uQs;MbB<m2|5FFUF`LH(pYk0Bu+9~U2*Sw_Y%B;;eKTi3^`_UL_dPkL#<
z|IckuS6=M?GFWcpLPmsqT>rCw3Hi~)8-|3|$DpfyI>@c8X+^mqA8WQ9IZ2(`^aH+>
zAt4{{Z(U{Zi|KfVgnXQP<V1hDm9^4PaLC7Ew~7u@Ye*kFgdw3KnsU&+zKo1#NXW-t
z7YDYJ*T>pvDLCZgO6MHeWn>6LLO!l}Z(Bj$uf8KBlzaL9ItII!>glxHW)A$&$`jhS
ztHDvzV1|Tz%=4~Oc6nF*jv*l*@8<l~Q@#h`o}Pk3J`Q=Xw5&X9EMrK>$IG81_Q*bd
zVo1ox5q?d#$?Id?3>4gikF@vy6wu(6;-eB?uXq?kLUlP}`V~)k#J@5m<YUOW*Qe#+
zbuv<L$j7PUQ(sh<9{u{bf{;)nPqvQ#cUn$qsJ<%`7!g_@2Y#J6T+ZDjla?Dh@DotV
z@}oQfuVYBa$H$AJQph*5elsNG<HzIIY~@xq%uK-{A4{bQUN8H&iXkB%pY3kzCL<FV
z67q4r)4T)9%A;WQMbt101vlX%DeiEzQ@m2?%KxHAhA|{m>U;aQsxPmP-x(6}v1^r|
z$JH5F?_;B^T5yQ?w^4Byd307YBIIMEKW+`=sqGs>nphucbV@s&Eh|sJ^|DcJ6Fw5M
zee=sXW#kHmgnW$8dm&u*@e4yjJ{DTCC6C;f4YE^k$j60t6_=<rq_6a43<>%8>wdJq
z5<K~&{)r(?_^3qv?<PcmPk1W1mGyE^aLC7FDSt%B!xP4kkUhE9Bx*mX)F1fysv)7l
z=@wmGd)}-Uyk1T<c16g>*aa=lsZ03(3^yY}NSnX{2HzL?!jL8er{NC#m2HDTo#&$5
zCIlyBnbr}Z>b1oG1ZPM{@SoLd{*`wc?->#j{B~-OA$gN(Uis6vvW_(chia(U>C|K8
z+sYdl(uCmDm*E$^eB}FgsdG~+A;Hr(&AUpzGuDzJA;ITtnv_cxd>unVf**TXTid+o
zef&*GsM34c&-^Io_Oj8s5<Bpd>5hAQIrnOYgj!iPVXB)v{eEXi$j8JkcaF%&rnVFu
z^6~rNd<IX<)-fdHqt%yQjb+6xlD_Kv-yOk<<slzeKk5`D2XD)ekdMLNB6G`=`Zk7y
zd|W?pKs&jWY4cKW$j6@#qGrp;P7De8_~FwXA9Zfi`?!aYP+9Iw)2O8EW43%+ZtN?X
zC9k*oCC`@K7!vZa)W_gZxs^K^5(-``DD`C-X_=pbLp~0*a+x6qZ^Mv~kJ<fu{d*Cd
z(o+5UxSk;)AG^$4Zt&{A9}EfknB)G{0`jckWk-Dp`RG`5rNKK7H!vjR<Ndy^I>;BK
zi41ANN4ko-*m`(3W$95g*ZbI_fEFC8q3H1~9pwws4U7owSMw}#-7Fuh_`{HpkHbpU
zJ}0-bO+m^H`S^JDsC@D&9>I`MUv6$W%HTbHDGO06As@3fT5Rw_w6+Wh`S`2z;1qK3
zjSLC-nCM%;;637r3<>!-wv?5@+XPz`roM!H{Cqdw;8n=$7}A7~v{A3y;gZ1{@O}{z
z8t@zAcCVGEwq`}N+}MGiV(<UdPzGGV>gV*03<>!->7iwSywyl#NXW;qtdZ&E;H`^N
zaLC8-9yR}cf;M^ZtqchbPth8WtmRf(6{A){K89bKTTDiFWJt)zTJ!pBloj8@kdTkV
z+CN<{w=!dK3J&>LtwUTFxrn+mB;=#LYll24QolYPBqTIC+5GN$szkj!*-B`+v0Fr~
zJHFm5Kbq*xkdTiZ@;hXc2YfF>LO$;HYG@}fxtU5*aLC7U>lPSHz+D*<^6~i8FYo16
z?qx`5#7{22=_DgFmZIR0k9B>%7`&&i3qwLa?tgO0UvA|NhJ<{yuiV4nWshm>DLCZg
zBJUaJ)VkFB*p`q`SI(IbG)10=wlE^JU$wVhyGd5uvb2`Fk_jJapFU!J=A+6bl!DdI
z8a@mO`8aCz5rbDAZe>Ww#~+7J2dSf@Z>41!3J&>rEWjbFjBL-4kdODBhm?_#kqikH
z(P+0^kK_yIG!7IT^07>>V+-ZW`!);-`RI|d*-06>ks%=;d!}wwO`SFLKK>#klsocs
zSA$>BHZ7}lC3fKFLAG|0Y9sY!xsD-C_(=QoQa5@QmXW_067sS6*PgFsq*pl#4*3||
zWk=HUJL#eLT84yt%+&EsA-R<nj?_xX$2t`UER}t1#gLGXeP*1fCL=d9BvhA0-EKcn
z#$Wl<7g37x6ddv~YD@`(TSUzn(u9w+PLv4oFRrW+%8I7<aU&t2M%rYr_(Fa;OClpe
z>*KE*WevWJ+@XTjmDquw`t54Xlt*V5Lz?iBx^mC_!T(-doP5c(bfQ*5KAy?Fe~`Q}
z@McKJ$3H1gPM3X*WJnV}Qt)yaR`yUvJozWut(+-1<YQrL?_+ZC?hFa}xZTRLjJ$6<
z$dFK}m+$JUUF_)<&ry+roA8m=iMl@?R!}D*y^nnf2@y-ItNmKO*gMLIkdHl!g&TbF
zCvzn&cV%dO^eeMxvg~6|hBV<Lb!BEJ7lV(x?qx{G$F+-|-IU8RqYDLxe6&qixKBoQ
zV@MM|Qt&Aj4Gca6cz_`xADez%^GrTmoXwSjLq7KXo2H)pk<$ST3Hdl^NZ<wAq=`uR
z)BAXtAt8H$%SDV=r%U~TABW0naHuCUq?~`CcvAb6KfT}+2?*I(pni!PvN~@W5kg*H
z^2SO{t?$TcRkYNOkl-Z`_uVR2&;o{p1P?r%a8Z3WtZ!vJLqdXIS${aCI{oUA4XaXc
zNbs0ShYj9Cw2C1i!Poh>c9C28jUl13w7Zqn;2WBa-6%LDc#cKA^2)7T#gLHT=Wo?}
zCy)3yhJ*x<Y4EJMx-HQA*rJ*i9IEuDyPF=DecZ%|kdN6HCj60)w*6vAsFgXoI_#8N
z*~Fc4Lq67;61-M!Wf((3K9+iw`m2om#E_7W7Iu3o%MXWZSEt~RkIlBVH+bc27(+rn
zUN6ynzAVpIhJ<{)(zn|X`3zCR8Wh}wkF@ju{KwZp+4(15aKjlA^6^pi9Nw~zDLu4S
zLS;F&d+VPnQ9q}*V?@Zu0g)L#%bT`HhJ<|FVV}?7C-P}MDK`{6-YR;9yySLdNXW<b
z!)EuFgCAr_$j5umJr~GjnY|_jhkTr~ddzJ3zGXj#gnXQy*xcarXondR^6_WWv2L>B
zxoS~x$j5WOhgU1Zqm;Y8)cY|c<m3I68%C-lu3sNd5E81PpKDfDk$tqOt>wl(>Gk65
z8-o{+4q`~i#~M@e8+=LU1VchTW|$ag@X1S?Iuso0%imwyrIY(|5JN&fx_o<-T7EQf
zjv*l*kF5^&l3Qt0mx4n+#zx1^mXEd#Vo1oxz$q=AW#lP_G~pv%i4Pw9qOGjBO+5+@
z`8dmAtoHg|y^jM32@QDNp#^Ws%fx9$gx1GhW%d-4a~H0!<;Fhgb#I5wEqP8K$&iqb
zmf`Ih%4K<hAt4`YpYe{8??4o8K*6Em*?o70zZ`rrLqb00bLdn;4t|RvAs^e6sr_#k
zn0zN#rXdA~e7xhf!&_Z>^o!YShJ<{aU#E1^*T5_+ls`T41w)$fk+#4CdhYr6=|=^r
z_pw?dEjTnfM+&qXDCZ7hM99Yljy)R5$T)_C*2fH)de@YZo{cFt<YOwovxQ`22tz_X
zTK5R>m#-f`FeK#To1Qt+%NNcyn^16Q#GfTx?jpA`h#?^#_e2gJDYr6)Ax-#5m7Y*?
z?N4QRl$k>>k84v34*8ffho_gk^vq>Q6F$<CTY1UZ!fFxeeSAwus4KrNEBQlypy}zQ
z<*o$zILi0<OBuP6Ax-#5qci2qrGLjDl8??`hJ<{qUeMX#XJ)OMQE<q|@E#S9$Qy&r
z3<>$Tf7Q+`GBQPTY9-`jia%R>t2Lyr^fn9$6;b@)%d_QHZe>UlK2oKJeX~q2BU87a
z;E<1@9-HgS!Mz#MgpX909a}9tqA0Fx4D>!m5)#TCH7w|%+{jEVwcOZ&ACI6t2j#a6
zcV|cwKGNtse&Ui#-U*&&NXW-38#CI=JHcYDC^+O}n@gdiW#kBkgnWGeJKZyRb9tU2
zAs=@Q{k=inwiRkk!66?lZY}-yf(b<+z2ajS(nMWSrH3yMUZ?y^nb`Hn>kJ9`=-Inl
zqXJ1d<xh_+(}seZ@R91W+NnCF)LBFC;{rlLjhy!6P-XdsK@1~8>tp2x&5x^%)aQ0-
ztK~Lx;D<&hJ~8B&QkKfCMm;i+Ax-#5$Q1dTeN&#2Ca<BF3<>$z`RtVm@;!(u?I<|p
zWB>gF{ba@GFeKz-;iaQ*$hT~x7!vYv%go3p@~lzWn}VD0kt#jKqrZja;PV+0D)od}
z6Gq6be8G^Aj|IAy?W8_x*ZWwty%roIR^3$efJ)R?`dmhYe2ndv)8HIhG($q`<EYSU
zUFA8wst@Hh;Uf+Byl1(K$Qy%ThJ<`{PP@FfyitG4kdTkvJucsqTiKuk1&4g>@80!*
zj9kT#kdNo*y?iap^PM3fAM*^ny-r>y8g!)KkdG~Ty7|bhT*{D;Jqe5Z=1}d?ANYBz
zA)(kgqHb(g2S+b>^-gMRY`5y3YD-2rbuc4Bg4fx%_m(_1F$@U_ZaKVDYPppzohdgY
zc<&rnTFS^73<(L|`^@@*>Tv5P%ZChULU7s^>^|l&K^bsmq0l28yHIdQa9hvMFXRPx
z8bd;YcRSqhyL|jEiXov&um8Q_MEPz`^{x~g61;{*L2G#<xSSy&!SlEOzsk-!tc&e?
z+a@R~c7lZ{A}R(7CSqY=a_q(i1I5Db4g?beJ2An=KrC!T<*3K*Zp8p!=A7@$TJvMg
z_0IDL|9D;JKI_?g-+S+w*`JvYuIj?0_wf@Up^?7D=b`peFnxzN?WyI)-tcqhzQqr@
zch)c@RAtoRwteKYQ-2r|@-a`7t~2D_YNuWl9P-gJO)G;JaqePB6F$<mVAhOX_VT7J
zV{fVw^3i!!;iby|K>5@6co&9*d@L1PWwbmI?PN&E#|!B?-IWJX`aTpK^098>+_Q3U
zABKc{9R8@ZjqGCtA)#UEu=GO%xx=&e)pDD8!w=2r54xWXR^(BpH+_fqVo1ox6~(IO
zP;={%Cm0e6KE}P-1UY!2eiR(?adN!x4R!aTuW~3uLOzBM@~S8QAR(3^As<J-yKr8X
zr$B!S4*9sqaj?OUum>_E<YSE$*T2cr<w=Hwe6)M-<taZo%I8bLAs;VaY13NWYv|X<
z{)B|akkx|d4|4BBGa|HK9hJMh!4LWK`DwW;Lp}!18-GQf+WZ(2^0D2Hwvn<tQ49&S
z<+S?m4Zhl!djJK8d@LThdyl-w@?%KI$2>3IhskXj&5)3f@9P}8CAVd+ffU??k2I;j
z-#n(bGA<RYes1f}kdTjEGhTZwx8*U0gnS$^Aka+>uJ<v|AT2o5;R}K%|N9mB)b}lY
z84>a^dy%+~a_$oh3Hf-t<%Z%iGT&gz4f*)h$I42cEe9|p<YWCjGv>-8{WwEH-IMNP
z-S={pIs7R&<YR%Dr^#}aJsA@6ao~ug;__Z2k|9m_sMPhp?@(Pzvr}Dp^gd=CLct*)
zH=d|qaBR0XLz?iBW{rnG|JtVnSN3jtACD3e>YbiDvl*O#&NEcYjlJRL>m2*T^5$|N
zLz?iBa{Feoexh7Wq<(SnS%!ps9Fu?iK>6-!sQ?OY!bhsI**1&6l-W}0A^jMd%8-zc
z8S@n_EI%B+!;nyqPZ@fwfjqa>97e$*9}il3HItFS3<>#IFtqO-`HsO0hJ<`<>Jhc8
za7x!GfBNpJKb(S_@R4SXez)ew%Io76LPAYhdh^)r%7{|_^hG8!BD6kkj(B1t-?{8C
zLd%W4;ip35vcd95-_DSbkLUj0{<k~<ryEICn(&c&=ktyZS7l@;hJ<{4cho=FVC7**
z$j9?Hhc}hGC+jE*4h^EaZ*vFBK6YhD$VdN&uNxW!XGqA$6Ri_U%gC&O6ddxgWB!m<
zvX8w83FWT5v#7!2=EIB#`Pebxdjomp$vs-j?P_9uq>*lU>X3~*(uXi4<YQ*n#%0u|
z)K5g`84~jGruWO`a+Sr$P;kh{19dX?m&ed(hJ<`<x50M2{5a|wLqa}o%T&wYXq(+w
z3J#6SkLzdDlV^=UhJ<|dzA+_KZp#Y{X~IX^5%qa_wv2*QdR@O?Eiq0D4i&lbOupQ5
z?$L}0`B-=6o9*&!d66Ma_(-{LTRI<Ab}!1FRWFa-c*+g=7<7NgbGdiMGbH5Ws%5|T
z%0A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
YMM}mriSCK+$tf==8J_YVrb+Yv0E{NxS^xk5

diff --git a/testdata/examples.txt b/testdata/examples.txt
index 3d3491ad4..2bb8ab7fb 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -6680,7 +6680,6 @@ half(f32 ** f32)
 half(f32 ** f64)
 half(f32 + 0.5)
 half(f32 + 1)
-half(f32 + f32)
 half(f32 + f64)
 half(f32 + i)
 half(f32 + i32)
@@ -12213,7 +12212,6 @@ ok ? score : foo.String
 ok ? score : foo?.String
 ok ? score : greet
 ok ? score : half
-ok ? score : half("bar")
 ok ? score : i
 ok ? score : i32
 ok ? score : list

From 281d598ea9e570360846192d375f2a40afa124a5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 24 Nov 2023 16:54:23 +0100
Subject: [PATCH 179/506] fuzz: extend "cannot sum" error to all types

---
 test/fuzz/fuzz_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 03d29e3b8..d8184e2f0 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -48,7 +48,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`invalid date .*`),
 		regexp.MustCompile(`cannot parse .* as .*`),
 		regexp.MustCompile(`operator "in" not defined on .*`),
-		regexp.MustCompile(`cannot sum bool`),
+		regexp.MustCompile(`cannot sum .*`),
 	}
 
 	env := NewEnv()

From ad0e8779ecc8c2c747c68a2ebb6e6daa6894caeb Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 24 Nov 2023 17:26:54 +0100
Subject: [PATCH 180/506] Add ceil(), floor() and round() function

Fixes #476
---
 builtin/builtin.go          | 42 +++++++++++++++++++++++++++++++++++++
 builtin/builtin_test.go     |  7 +++++++
 builtin/func.go             | 37 ++++++++++++++++++++++++++++++++
 docs/Language-Definition.md | 24 +++++++++++++++++++++
 4 files changed, 110 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index d7248a867..1c3d919cc 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -126,6 +126,48 @@ var Builtins = []*ast.Function{
 			return anyType, fmt.Errorf("invalid argument for abs (type %s)", args[0])
 		},
 	},
+	{
+		Name: "ceil",
+		Fast: Ceil,
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
+				return floatType, nil
+			}
+			return anyType, fmt.Errorf("invalid argument for ceil (type %s)", args[0])
+		},
+	},
+	{
+		Name: "floor",
+		Fast: Floor,
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
+				return floatType, nil
+			}
+			return anyType, fmt.Errorf("invalid argument for floor (type %s)", args[0])
+		},
+	},
+	{
+		Name: "round",
+		Fast: Round,
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
+				return floatType, nil
+			}
+			return anyType, fmt.Errorf("invalid argument for floor (type %s)", args[0])
+		},
+	},
 	{
 		Name: "int",
 		Fast: Int,
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 533f59a88..45582d00a 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -36,6 +36,13 @@ func TestBuiltin(t *testing.T) {
 		{`abs(-5)`, 5},
 		{`abs(.5)`, .5},
 		{`abs(-.5)`, .5},
+		{`ceil(5.5)`, 6.0},
+		{`ceil(5)`, 5.0},
+		{`floor(5.5)`, 5.0},
+		{`floor(5)`, 5.0},
+		{`round(5.5)`, 6.0},
+		{`round(5)`, 5.0},
+		{`round(5.49)`, 5.0},
 		{`int(5.5)`, 5},
 		{`int(5)`, 5},
 		{`int("5")`, 5},
diff --git a/builtin/func.go b/builtin/func.go
index 7c042c6d2..d9ec4ff42 100644
--- a/builtin/func.go
+++ b/builtin/func.go
@@ -2,6 +2,7 @@ package builtin
 
 import (
 	"fmt"
+	"math"
 	"reflect"
 	"strconv"
 
@@ -138,6 +139,42 @@ func Abs(x any) any {
 	panic(fmt.Sprintf("invalid argument for abs (type %T)", x))
 }
 
+func Ceil(x any) any {
+	switch x := x.(type) {
+	case float32:
+		return math.Ceil(float64(x))
+	case float64:
+		return math.Ceil(x)
+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
+		return Float(x)
+	}
+	panic(fmt.Sprintf("invalid argument for ceil (type %T)", x))
+}
+
+func Floor(x any) any {
+	switch x := x.(type) {
+	case float32:
+		return math.Floor(float64(x))
+	case float64:
+		return math.Floor(x)
+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
+		return Float(x)
+	}
+	panic(fmt.Sprintf("invalid argument for floor (type %T)", x))
+}
+
+func Round(x any) any {
+	switch x := x.(type) {
+	case float32:
+		return math.Round(float64(x))
+	case float64:
+		return math.Round(x)
+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
+		return Float(x)
+	}
+	panic(fmt.Sprintf("invalid argument for round (type %T)", x))
+}
+
 func Int(x any) any {
 	switch x := x.(type) {
 	case float32:
diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 352b2ec79..46bad9322 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -380,6 +380,30 @@ min(5, 7) == 5
 
 Returns the absolute value of a number.
 
+### ceil(n)
+
+Returns the least integer value greater than or equal to x.
+
+```expr
+ceil(1.5) == 2.0
+```
+
+### floor(n)
+
+Returns the greatest integer value less than or equal to x.
+
+```expr
+floor(1.5) == 1.0
+```
+
+### round(n)
+
+Returns the nearest integer, rounding half away from zero.
+
+```expr
+round(1.5) == 2.0
+```
+
 ## Array Functions
 
 ### all(array, predicate)

From 72442663b6f2862023736e4514f34fab549c1daf Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 27 Nov 2023 13:52:56 +0100
Subject: [PATCH 181/506] Hide fields in vm.Program

---
 compiler/compiler.go | 25 ++++++++++++-------------
 file/source.go       |  3 +++
 vm/program.go        | 39 ++++++++++++++++++++++++++++++---------
 vm/vm.go             | 22 +++++++++++++---------
 vm/vm_test.go        |  5 ++---
 5 files changed, 60 insertions(+), 34 deletions(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index eada2ad04..04f0ff5eb 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -47,17 +47,16 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		c.emit(OpCast, 2)
 	}
 
-	program = &Program{
-		Node:      tree.Node,
-		Source:    tree.Source,
-		Locations: c.locations,
-		Variables: c.variables,
-		Constants: c.constants,
-		Bytecode:  c.bytecode,
-		Arguments: c.arguments,
-		Functions: c.functions,
-		DebugInfo: c.debugInfo,
-	}
+	program = NewProgram(
+		tree.Source,
+		c.locations,
+		c.variables,
+		c.constants,
+		c.bytecode,
+		c.arguments,
+		c.functions,
+		c.debugInfo,
+	)
 	return
 }
 
@@ -145,7 +144,7 @@ func (c *compiler) addVariable(name string) int {
 	return p
 }
 
-// emitFunction adds builtin.Function.Func to the program.Functions and emits call opcode.
+// emitFunction adds builtin.Function.Func to the program.functions and emits call opcode.
 func (c *compiler) emitFunction(fn *ast.Function, argsLen int) {
 	switch argsLen {
 	case 0:
@@ -162,7 +161,7 @@ func (c *compiler) emitFunction(fn *ast.Function, argsLen int) {
 	}
 }
 
-// addFunction adds builtin.Function.Func to the program.Functions and returns its index.
+// addFunction adds builtin.Function.Func to the program.functions and returns its index.
 func (c *compiler) addFunction(fn *ast.Function) int {
 	if fn == nil {
 		panic("function is nil")
diff --git a/file/source.go b/file/source.go
index 9ee297b58..d86a546b1 100644
--- a/file/source.go
+++ b/file/source.go
@@ -40,6 +40,9 @@ func (s *Source) Content() string {
 }
 
 func (s *Source) Snippet(line int) (string, bool) {
+	if s == nil {
+		return "", false
+	}
 	charStart, found := s.findLineOffset(line)
 	if !found || len(s.contents) == 0 {
 		return "", false
diff --git a/vm/program.go b/vm/program.go
index c45a2bff2..1664da24b 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -9,22 +9,43 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/builtin"
 	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/vm/runtime"
 )
 
 type Program struct {
-	Node      ast.Node
-	Source    *file.Source
-	Locations []file.Location
-	Variables []any
-	Constants []any
 	Bytecode  []Opcode
 	Arguments []int
-	Functions []Function
-	DebugInfo map[string]string
+	Constants []any
+
+	source    *file.Source
+	locations []file.Location
+	variables []any
+	functions []Function
+	debugInfo map[string]string
+}
+
+func NewProgram(
+	source *file.Source,
+	locations []file.Location,
+	variables []any,
+	constants []any,
+	bytecode []Opcode,
+	arguments []int,
+	functions []Function,
+	debugInfo map[string]string,
+) *Program {
+	return &Program{
+		source:    source,
+		locations: locations,
+		variables: variables,
+		Constants: constants,
+		Bytecode:  bytecode,
+		Arguments: arguments,
+		functions: functions,
+		debugInfo: debugInfo,
+	}
 }
 
 func (program *Program) Disassemble() string {
@@ -56,7 +77,7 @@ func (program *Program) Opcodes(w io.Writer) {
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\n", pp, label, arg)
 		}
 		argumentWithInfo := func(label string, prefix string) {
-			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, program.DebugInfo[fmt.Sprintf("%s_%d", prefix, arg)])
+			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, label, arg, program.debugInfo[fmt.Sprintf("%s_%d", prefix, arg)])
 		}
 		constant := func(label string) {
 			var c any
diff --git a/vm/vm.go b/vm/vm.go
index d020a31a8..70edb29a8 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -59,14 +59,18 @@ func Debug() *VM {
 func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 	defer func() {
 		if r := recover(); r != nil {
+			var location file.Location
+			if vm.ip-1 < len(program.locations) {
+				location = program.locations[vm.ip-1]
+			}
 			f := &file.Error{
-				Location: program.Locations[vm.ip-1],
+				Location: location,
 				Message:  fmt.Sprintf("%v", r),
 			}
 			if err, ok := r.(error); ok {
 				f.Wrap(err)
 			}
-			err = f.Bind(program.Source)
+			err = f.Bind(program.source)
 		}
 	}()
 
@@ -108,10 +112,10 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.pop()
 
 		case OpStore:
-			program.Variables[arg] = vm.pop()
+			program.variables[arg] = vm.pop()
 
 		case OpLoadVar:
-			vm.push(program.Variables[arg])
+			vm.push(program.variables[arg])
 
 		case OpLoadConst:
 			vm.push(runtime.Fetch(env, program.Constants[arg]))
@@ -126,7 +130,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.push(runtime.FetchMethod(env, program.Constants[arg].(*runtime.Method)))
 
 		case OpLoadFunc:
-			vm.push(program.Functions[arg])
+			vm.push(program.functions[arg])
 
 		case OpFetch:
 			b := vm.pop()
@@ -332,7 +336,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.push(out[0].Interface())
 
 		case OpCall0:
-			out, err := program.Functions[arg]()
+			out, err := program.functions[arg]()
 			if err != nil {
 				panic(err)
 			}
@@ -340,7 +344,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 
 		case OpCall1:
 			a := vm.pop()
-			out, err := program.Functions[arg](a)
+			out, err := program.functions[arg](a)
 			if err != nil {
 				panic(err)
 			}
@@ -349,7 +353,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpCall2:
 			b := vm.pop()
 			a := vm.pop()
-			out, err := program.Functions[arg](a, b)
+			out, err := program.functions[arg](a, b)
 			if err != nil {
 				panic(err)
 			}
@@ -359,7 +363,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			c := vm.pop()
 			b := vm.pop()
 			a := vm.pop()
-			out, err := program.Functions[arg](a, b, c)
+			out, err := program.functions[arg](a, b, c)
 			if err != nil {
 				panic(err)
 			}
diff --git a/vm/vm_test.go b/vm/vm_test.go
index dfbd17869..c343e1aae 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -6,14 +6,14 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/compiler"
 	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/parser"
 	"github.com/antonmedv/expr/vm"
-	"github.com/stretchr/testify/require"
 )
 
 func TestRun_NilProgram(t *testing.T) {
@@ -282,7 +282,6 @@ func TestRun_TaggedFieldName(t *testing.T) {
 
 func TestRun_OpInvalid(t *testing.T) {
 	program := &vm.Program{
-		Locations: []file.Location{{0, 0}},
 		Bytecode:  []vm.Opcode{vm.OpInvalid},
 		Arguments: []int{0},
 	}

From 0531ea58bbd1e7aa05ac17ae9f31d8263983d24a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 27 Nov 2023 19:15:20 +0100
Subject: [PATCH 182/506] Add ast comments

Rename program.Opcodes() to program.DisassembleWriter()
---
 ast/node.go       | 151 ++++++++++++++++++++++++++++++++--------------
 debug/debugger.go |   2 +-
 vm/program.go     |   8 ++-
 3 files changed, 112 insertions(+), 49 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index d9c0d73da..9e4c7a5e6 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -16,179 +16,238 @@ type Node interface {
 	String() string
 }
 
+// Patch replaces the node with a new one.
+// Location information is preserved.
+// Type information is lost.
 func Patch(node *Node, newNode Node) {
 	newNode.SetLocation((*node).Location())
 	*node = newNode
 }
 
+// base is a base struct for all nodes.
 type base struct {
 	loc      file.Location
 	nodeType reflect.Type
 }
 
+// Location returns the location of the node in the source code.
 func (n *base) Location() file.Location {
 	return n.loc
 }
 
+// SetLocation sets the location of the node in the source code.
 func (n *base) SetLocation(loc file.Location) {
 	n.loc = loc
 }
 
+// Type returns the type of the node.
 func (n *base) Type() reflect.Type {
 	return n.nodeType
 }
 
+// SetType sets the type of the node.
 func (n *base) SetType(t reflect.Type) {
 	n.nodeType = t
 }
 
+// NilNode represents nil.
 type NilNode struct {
 	base
 }
 
+// IdentifierNode represents an identifier.
 type IdentifierNode struct {
 	base
-	Value       string
-	FieldIndex  []int
-	Method      bool // true if method, false if field
-	MethodIndex int  // index of method, set only if Method is true
+	Value       string // Name of the identifier. Like "foo" in "foo.bar".
+	FieldIndex  []int  // Index of the field in the list of fields.
+	Method      bool   // If true then the identifier is a method call.
+	MethodIndex int    // Index of the method in the list of methods.
 }
 
+// SetFieldIndex sets the field index of the identifier.
 func (n *IdentifierNode) SetFieldIndex(field []int) {
 	n.FieldIndex = field
 }
 
+// SetMethodIndex sets the method index of the identifier.
 func (n *IdentifierNode) SetMethodIndex(methodIndex int) {
 	n.Method = true
 	n.MethodIndex = methodIndex
 }
 
+// IntegerNode represents an integer.
 type IntegerNode struct {
 	base
-	Value int
+	Value int // Value of the integer.
 }
 
+// FloatNode represents a float.
 type FloatNode struct {
 	base
-	Value float64
+	Value float64 // Value of the float.
 }
 
+// BoolNode represents a boolean.
 type BoolNode struct {
 	base
-	Value bool
+	Value bool // Value of the boolean.
 }
 
+// StringNode represents a string.
 type StringNode struct {
 	base
-	Value string
+	Value string // Value of the string.
 }
 
+// ConstantNode represents a constant.
+// Constants are predefined values like nil, true, false, array, map, etc.
+// The parser.Parse will never generate ConstantNode, it is only generated
+// by the optimizer.
 type ConstantNode struct {
 	base
-	Value any
+	Value any // Value of the constant.
 }
 
+// UnaryNode represents a unary operator.
 type UnaryNode struct {
 	base
-	Operator string
-	Node     Node
+	Operator string // Operator of the unary operator. Like "!" in "!foo" or "not" in "not foo".
+	Node     Node   // Node of the unary operator. Like "foo" in "!foo".
 }
 
+// BinaryNode represents a binary operator.
 type BinaryNode struct {
 	base
-	Regexp   *regexp.Regexp
-	Operator string
-	Left     Node
-	Right    Node
+	Regexp   *regexp.Regexp // Regexp of the "matches" operator. Like "f.+" in `foo matches "f.+"`.
+	Operator string         // Operator of the binary operator. Like "+" in "foo + bar" or "matches" in "foo matches bar".
+	Left     Node           // Left node of the binary operator.
+	Right    Node           // Right node of the binary operator.
 }
 
+// ChainNode represents an optional chaining group.
+// A few MemberNode nodes can be chained together,
+// and will be wrapped in a ChainNode. Example:
+// ```
+// foo.bar?.baz?.qux
+// ```
+// The whole chain will be wrapped in a ChainNode.
 type ChainNode struct {
 	base
-	Node Node
+	Node Node // Node of the chain.
 }
 
+// MemberNode represents a member access.
+// It can be a field access, a method call,
+// or an array element access.
+// Example:
+// ```
+// foo.bar or foo["bar"]
+// foo.bar()
+// array[0]
+// ```
 type MemberNode struct {
 	base
-	Node       Node
-	Property   Node
+	Node       Node   // Node of the member access. Like "foo" in "foo.bar".
+	Property   Node   // Property of the member access. For property access it is a StringNode.
 	Name       string // Name of the filed or method. Used for error reporting.
-	Optional   bool
-	FieldIndex []int
+	Optional   bool   // If true then the member access is optional. Like "foo?.bar".
+	FieldIndex []int  // Index sequence of fields. Generated by type checker.
 
 	// TODO: Combine Method and MethodIndex into a single MethodIndex field of &int type.
-	Method      bool
-	MethodIndex int
+	Method      bool // If true then the member access is a method call.
+	MethodIndex int  // Index of the method in the list of methods. Generated by type checker.
 }
 
+// SetFieldIndex sets the field index of the member access.
 func (n *MemberNode) SetFieldIndex(field []int) {
 	n.FieldIndex = field
 }
 
+// SetMethodIndex sets the method index of the member access.
 func (n *MemberNode) SetMethodIndex(methodIndex int) {
 	n.Method = true
 	n.MethodIndex = methodIndex
 }
 
+// SliceNode represents access to a slice of an array.
+// Example:
+// ```
+// array[1:4]
+// ```
 type SliceNode struct {
 	base
-	Node Node
-	From Node
-	To   Node
+	Node Node // Node of the slice. Like "array" in "array[1:4]".
+	From Node // From an index of the array. Like "1" in "array[1:4]".
+	To   Node // To an index of the array. Like "4" in "array[1:4]".
 }
 
+// CallNode represents a function or a method call.
 type CallNode struct {
 	base
-	Callee    Node
-	Arguments []Node
-	Typed     int
-	Fast      bool
-	Func      *Function
+	Callee    Node      // Node of the call. Like "foo" in "foo()".
+	Arguments []Node    // Arguments of the call.
+	Typed     int       // If more than 0 then the call is one of the types from vm.FuncTypes.
+	Fast      bool      // If true then the call type is "func(...any) any".
+	Func      *Function // If not nil then the func is provider via expr.Function.
 }
 
+// BuiltinNode represents a builtin function call.
 type BuiltinNode struct {
 	base
-	Name      string
-	Arguments []Node
-	Throws    bool
-	Map       Node
+	Name      string // Name of the builtin function. Like "len" in "len(foo)".
+	Arguments []Node // Arguments of the builtin function.
+	Throws    bool   // If true then accessing a field or array index can throw an error. Used by optimizer.
+	Map       Node   // Used by optimizer to fold filter() and map() builtins.
 }
 
+// ClosureNode represents a predicate.
+// Example:
+// ```
+// filter(foo, .bar == 1)
+// ```
+// The predicate is `.bar == 1`.
 type ClosureNode struct {
 	base
-	Node Node
+	Node Node // Node of the predicate body.
 }
 
+// PointerNode represents a pointer to a current value in predicate.
 type PointerNode struct {
 	base
-	Name string
+	Name string // Name of the pointer. Like "index" in "#index".
 }
 
+// ConditionalNode represents a ternary operator.
 type ConditionalNode struct {
 	base
-	Cond Node
-	Exp1 Node
-	Exp2 Node
+	Cond Node // Condition of the ternary operator. Like "foo" in "foo ? bar : baz".
+	Exp1 Node // Expression 1 of the ternary operator. Like "bar" in "foo ? bar : baz".
+	Exp2 Node // Expression 2 of the ternary operator. Like "baz" in "foo ? bar : baz".
 }
 
+// VariableDeclaratorNode represents a variable declaration.
 type VariableDeclaratorNode struct {
 	base
-	Name  string
-	Value Node
-	Expr  Node
+	Name  string // Name of the variable. Like "foo" in "let foo = 1; foo + 1".
+	Value Node   // Value of the variable. Like "1" in "let foo = 1; foo + 1".
+	Expr  Node   // Expression of the variable. Like "foo + 1" in "let foo = 1; foo + 1".
 }
 
+// ArrayNode represents an array.
 type ArrayNode struct {
 	base
-	Nodes []Node
+	Nodes []Node // Nodes of the array.
 }
 
+// MapNode represents a map.
 type MapNode struct {
 	base
-	Pairs []Node
+	Pairs []Node // PairNode nodes.
 }
 
+// PairNode represents a key-value pair of a map.
 type PairNode struct {
 	base
-	Key   Node
-	Value Node
+	Key   Node // Key of the pair.
+	Value Node // Value of the pair.
 }
diff --git a/debug/debugger.go b/debug/debugger.go
index 1dfe4c162..895e70589 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -59,7 +59,7 @@ func StartDebugger(program *Program, env any) {
 
 	index := make(map[int]int)
 	var buf strings.Builder
-	program.Opcodes(&buf)
+	program.DisassembleWriter(&buf)
 
 	for row, line := range strings.Split(buf.String(), "\n") {
 		if line == "" {
diff --git a/vm/program.go b/vm/program.go
index 1664da24b..ae5b64108 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -14,6 +14,7 @@ import (
 	"github.com/antonmedv/expr/vm/runtime"
 )
 
+// Program represents a compiled expression.
 type Program struct {
 	Bytecode  []Opcode
 	Arguments []int
@@ -26,6 +27,7 @@ type Program struct {
 	debugInfo map[string]string
 }
 
+// NewProgram returns a new Program. It's used by the compiler.
 func NewProgram(
 	source *file.Source,
 	locations []file.Location,
@@ -48,15 +50,17 @@ func NewProgram(
 	}
 }
 
+// Disassemble returns opcodes as a string.
 func (program *Program) Disassemble() string {
 	var buf bytes.Buffer
 	w := tabwriter.NewWriter(&buf, 0, 0, 2, ' ', 0)
-	program.Opcodes(w)
+	program.DisassembleWriter(w)
 	_ = w.Flush()
 	return buf.String()
 }
 
-func (program *Program) Opcodes(w io.Writer) {
+// DisassembleWriter takes a writer and writes opcodes to it.
+func (program *Program) DisassembleWriter(w io.Writer) {
 	ip := 0
 	for ip < len(program.Bytecode) {
 		pp := ip

From 9a60147693e87c5271d43fd70d78ee0673e0f7d0 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 27 Nov 2023 20:36:08 +0100
Subject: [PATCH 183/506] Update ast comments

---
 ast/node.go | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index 9e4c7a5e6..bd7805bd5 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -59,9 +59,9 @@ type NilNode struct {
 type IdentifierNode struct {
 	base
 	Value       string // Name of the identifier. Like "foo" in "foo.bar".
-	FieldIndex  []int  // Index of the field in the list of fields.
-	Method      bool   // If true then the identifier is a method call.
-	MethodIndex int    // Index of the method in the list of methods.
+	FieldIndex  []int  // Internal. Index of the field in the list of fields.
+	Method      bool   // Internal. If true then the identifier is a method call.
+	MethodIndex int    // Internal. Index of the method in the list of methods.
 }
 
 // SetFieldIndex sets the field index of the identifier.
@@ -118,10 +118,10 @@ type UnaryNode struct {
 // BinaryNode represents a binary operator.
 type BinaryNode struct {
 	base
-	Regexp   *regexp.Regexp // Regexp of the "matches" operator. Like "f.+" in `foo matches "f.+"`.
 	Operator string         // Operator of the binary operator. Like "+" in "foo + bar" or "matches" in "foo matches bar".
 	Left     Node           // Left node of the binary operator.
 	Right    Node           // Right node of the binary operator.
+	Regexp   *regexp.Regexp // Internal. Regexp of the "matches" operator. Like "f.+" in `foo matches "f.+"`.
 }
 
 // ChainNode represents an optional chaining group.
@@ -149,13 +149,13 @@ type MemberNode struct {
 	base
 	Node       Node   // Node of the member access. Like "foo" in "foo.bar".
 	Property   Node   // Property of the member access. For property access it is a StringNode.
-	Name       string // Name of the filed or method. Used for error reporting.
 	Optional   bool   // If true then the member access is optional. Like "foo?.bar".
-	FieldIndex []int  // Index sequence of fields. Generated by type checker.
+	Name       string // Internal. Name of the filed or method. Used for error reporting.
+	FieldIndex []int  // Internal. Index sequence of fields. Generated by type checker.
 
 	// TODO: Combine Method and MethodIndex into a single MethodIndex field of &int type.
-	Method      bool // If true then the member access is a method call.
-	MethodIndex int  // Index of the method in the list of methods. Generated by type checker.
+	Method      bool // Internal. If true then the member access is a method call.
+	MethodIndex int  // Internal. Index of the method in the list of methods. Generated by type checker.
 }
 
 // SetFieldIndex sets the field index of the member access.
@@ -186,9 +186,9 @@ type CallNode struct {
 	base
 	Callee    Node      // Node of the call. Like "foo" in "foo()".
 	Arguments []Node    // Arguments of the call.
-	Typed     int       // If more than 0 then the call is one of the types from vm.FuncTypes.
-	Fast      bool      // If true then the call type is "func(...any) any".
-	Func      *Function // If not nil then the func is provider via expr.Function.
+	Typed     int       // Internal. Used to indicate compiler what type is one of vm.FuncTypes.
+	Fast      bool      // Internal. Used to indicate compiler what this call is a fast call.
+	Func      *Function // Internal. Used to pass function information from type checker to compiler.
 }
 
 // BuiltinNode represents a builtin function call.
@@ -196,8 +196,8 @@ type BuiltinNode struct {
 	base
 	Name      string // Name of the builtin function. Like "len" in "len(foo)".
 	Arguments []Node // Arguments of the builtin function.
-	Throws    bool   // If true then accessing a field or array index can throw an error. Used by optimizer.
-	Map       Node   // Used by optimizer to fold filter() and map() builtins.
+	Throws    bool   // Internal. If true then accessing a field or array index can throw an error. Used by optimizer.
+	Map       Node   // Internal. Used by optimizer to fold filter() and map() builtins.
 }
 
 // ClosureNode represents a predicate.

From 8249ea06d67ece557999d520b821b4f13354c4f9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 27 Nov 2023 21:52:44 +0100
Subject: [PATCH 184/506] Add expr.WithContext()

---
 expr.go                      |  8 +++++++
 expr_test.go                 | 42 ++++++++++++++++++++++++++++++++++++
 patcher/with_context.go      | 36 +++++++++++++++++++++++++++++++
 patcher/with_context_test.go | 32 +++++++++++++++++++++++++++
 4 files changed, 118 insertions(+)
 create mode 100644 patcher/with_context.go
 create mode 100644 patcher/with_context_test.go

diff --git a/expr.go b/expr.go
index eb9eb7683..bc5dfc31c 100644
--- a/expr.go
+++ b/expr.go
@@ -11,6 +11,7 @@ import (
 	"github.com/antonmedv/expr/file"
 	"github.com/antonmedv/expr/optimizer"
 	"github.com/antonmedv/expr/parser"
+	"github.com/antonmedv/expr/patcher"
 	"github.com/antonmedv/expr/vm"
 )
 
@@ -152,6 +153,13 @@ func EnableBuiltin(name string) Option {
 	}
 }
 
+// WithContext passes context to all functions calls with a context.Context argument.
+func WithContext(name string) Option {
+	return Patch(patcher.WithContext{
+		Name: name,
+	})
+}
+
 // Compile parses and compiles given input expression to bytecode program.
 func Compile(input string, ops ...Option) (*vm.Program, error) {
 	config := conf.CreateNew()
diff --git a/expr_test.go b/expr_test.go
index 638ae3b84..e05fbd54f 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1,6 +1,7 @@
 package expr_test
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"reflect"
@@ -488,6 +489,47 @@ func ExamplePatch() {
 	// Output : Hello, you, world!
 }
 
+func ExampleWithContext() {
+	env := map[string]any{
+		"fn": func(ctx context.Context, _, _ int) int {
+			// An infinite loop that can be canceled by context.
+			for {
+				select {
+				case <-ctx.Done():
+					return 42
+				}
+			}
+		},
+		"ctx": context.TODO(), // Context should be passed as a variable.
+	}
+
+	program, err := expr.Compile(`fn(1, 2)`,
+		expr.Env(env),
+		expr.WithContext("ctx"), // Pass context variable name.
+	)
+	if err != nil {
+		fmt.Printf("%v", err)
+		return
+	}
+
+	// Cancel context after 100 milliseconds.
+	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
+	defer cancel()
+
+	// After program is compiled, context can be passed to Run.
+	env["ctx"] = ctx
+
+	// Run will return 42 after 100 milliseconds.
+	output, err := expr.Run(program, env)
+	if err != nil {
+		fmt.Printf("%v", err)
+		return
+	}
+
+	fmt.Printf("%v", output)
+	// Output: 42
+}
+
 func TestExpr_readme_example(t *testing.T) {
 	env := map[string]any{
 		"greet":   "Hello, %v!",
diff --git a/patcher/with_context.go b/patcher/with_context.go
new file mode 100644
index 000000000..35765474f
--- /dev/null
+++ b/patcher/with_context.go
@@ -0,0 +1,36 @@
+package patcher
+
+import (
+	"reflect"
+
+	"github.com/antonmedv/expr/ast"
+)
+
+// WithContext adds WithContext.Name argument to all functions calls with a context.Context argument.
+type WithContext struct {
+	Name string
+}
+
+// Visit adds WithContext.Name argument to all functions calls with a context.Context argument.
+func (w WithContext) Visit(node *ast.Node) {
+	switch (*node).(type) {
+	case *ast.CallNode:
+		call := (*node).(*ast.CallNode)
+		fn := call.Callee.Type()
+		if fn.Kind() != reflect.Func {
+			return
+		}
+		if fn.NumIn() == 0 {
+			return
+		}
+		if fn.In(0).String() != "context.Context" {
+			return
+		}
+		ast.Patch(node, &ast.CallNode{
+			Callee: call.Callee,
+			Arguments: append([]ast.Node{
+				&ast.IdentifierNode{Value: w.Name},
+			}, call.Arguments...),
+		})
+	}
+}
diff --git a/patcher/with_context_test.go b/patcher/with_context_test.go
new file mode 100644
index 000000000..311cb3922
--- /dev/null
+++ b/patcher/with_context_test.go
@@ -0,0 +1,32 @@
+package patcher_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/antonmedv/expr"
+	"github.com/antonmedv/expr/patcher"
+)
+
+func TestWithContext(t *testing.T) {
+	env := map[string]any{
+		"fn": func(ctx context.Context, a int) int {
+			return ctx.Value("value").(int) + a
+		},
+		"ctx": context.TODO(),
+	}
+
+	withContext := patcher.WithContext{Name: "ctx"}
+
+	program, err := expr.Compile(`fn(40)`, expr.Env(env), expr.Patch(withContext))
+	require.NoError(t, err)
+
+	ctx := context.WithValue(context.Background(), "value", 2)
+	env["ctx"] = ctx
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 42, output)
+}

From f92bb7949de064a05d5b3a61d1b07abef0c521bb Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 27 Nov 2023 21:54:11 +0100
Subject: [PATCH 185/506] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 0e11943d3..4419be468 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
 # Expr 
 [![test](https://github.com/antonmedv/expr/actions/workflows/test.yml/badge.svg)](https://github.com/antonmedv/expr/actions/workflows/test.yml) 
 [![Go Report Card](https://goreportcard.com/badge/github.com/antonmedv/expr)](https://goreportcard.com/report/github.com/antonmedv/expr) 
-[![GoDoc](https://godoc.org/github.com/antonmedv/expr?status.svg)](https://godoc.org/github.com/antonmedv/expr)
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/expr.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:expr)
+[![GoDoc](https://godoc.org/github.com/antonmedv/expr?status.svg)](https://godoc.org/github.com/antonmedv/expr)
 
 **Expr** is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed.
 

From 5455cf894630551e08c0077051933425b6538a5b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 27 Nov 2023 22:03:15 +0100
Subject: [PATCH 186/506] fuzz: skip string index out of range

---
 test/fuzz/fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index d8184e2f0..126a3a7ad 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -42,6 +42,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`reflect: call of reflect.Value.Call on .* Value`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Index on map Value`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Len on .* Value`),
+		regexp.MustCompile(`reflect: string index out of range`),
 		regexp.MustCompile(`strings: negative Repeat count`),
 		regexp.MustCompile(`strings: illegal bytes to escape`),
 		regexp.MustCompile(`operator "in" not defined on int`),

From c89be6a175bfc5e77160274fbbfa6a1d90416d09 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 3 Dec 2023 21:53:01 +0100
Subject: [PATCH 187/506] Use expr-lang/expr

---
 .github/scripts/coverage.mjs                   |  2 +-
 README.md                                      | 16 ++++++++--------
 ast/node.go                                    |  2 +-
 ast/print.go                                   |  4 ++--
 ast/print_test.go                              |  4 ++--
 ast/visitor_test.go                            |  2 +-
 bench_test.go                                  |  4 ++--
 builtin/builtin.go                             |  4 ++--
 builtin/builtin_test.go                        | 14 +++++++-------
 builtin/func.go                                |  2 +-
 checker/checker.go                             | 12 ++++++------
 checker/checker_test.go                        | 12 ++++++------
 checker/types.go                               |  2 +-
 compiler/compiler.go                           | 14 +++++++-------
 compiler/compiler_test.go                      |  8 ++++----
 conf/config.go                                 |  6 +++---
 conf/operators.go                              |  2 +-
 debug/debugger.go                              |  2 +-
 debug/go.mod                                   |  6 +++---
 docgen/README.md                               |  4 ++--
 docgen/docgen.go                               |  2 +-
 docgen/docgen_test.go                          |  6 +++---
 docs/Configuration.md                          |  2 +-
 docs/Operator-Overloading.md                   |  2 +-
 docs/Tips.md                                   |  4 ++--
 docs/Visitor-and-Patch.md                      | 10 +++++-----
 expr.go                                        | 18 +++++++++---------
 expr_test.go                                   |  8 ++++----
 go.mod                                         |  2 +-
 optimizer/const_expr.go                        |  4 ++--
 optimizer/const_range.go                       |  2 +-
 optimizer/filter_first.go                      |  2 +-
 optimizer/filter_last.go                       |  2 +-
 optimizer/filter_len.go                        |  2 +-
 optimizer/filter_map.go                        |  2 +-
 optimizer/fold.go                              |  4 ++--
 optimizer/in_array.go                          |  2 +-
 optimizer/in_range.go                          |  2 +-
 optimizer/optimizer.go                         |  4 ++--
 optimizer/optimizer_test.go                    | 12 ++++++------
 parser/lexer/lexer.go                          |  2 +-
 parser/lexer/lexer_test.go                     |  4 ++--
 parser/lexer/state.go                          |  2 +-
 parser/lexer/token.go                          |  2 +-
 parser/parser.go                               | 14 +++++++-------
 parser/parser_test.go                          |  4 ++--
 patcher/with_context.go                        |  2 +-
 patcher/with_context_test.go                   |  4 ++--
 repl/go.mod                                    | 10 +++++-----
 repl/repl.go                                   | 11 ++++++-----
 test/coredns/coredns_test.go                   |  4 ++--
 test/crowdsec/crowdsec_test.go                 |  4 ++--
 test/deref/deref_test.go                       |  2 +-
 test/fuzz/fuzz_test.go                         |  2 +-
 test/gen/gen.go                                |  6 +++---
 test/gen/gen_test.go                           |  2 +-
 test/gen/utils.go                              |  2 +-
 test/interface_method/interface_method_test.go |  2 +-
 test/mock/mock.go                              |  2 +-
 test/operator/operator_test.go                 |  4 ++--
 test/patch/patch_test.go                       |  6 +++---
 test/patch/set_type/set_type_test.go           |  4 ++--
 test/pipes/pipes_test.go                       |  2 +-
 test/real_world/real_docs/generate.go          |  4 ++--
 test/time/time_test.go                         | 12 ++++++------
 vm/program.go                                  |  6 +++---
 vm/program_test.go                             |  2 +-
 vm/vm.go                                       |  6 +++---
 vm/vm_test.go                                  | 12 ++++++------
 69 files changed, 177 insertions(+), 176 deletions(-)

diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs
index 1fb96c498..330d8d873 100755
--- a/.github/scripts/coverage.mjs
+++ b/.github/scripts/coverage.mjs
@@ -11,7 +11,7 @@ const exclude = [
 cd(path.resolve(__dirname, '..', '..'))
 
 await spinner('Running tests', async () => {
-  await $`go test -coverprofile=coverage.out -coverpkg=github.com/antonmedv/expr/... ./...`
+  await $`go test -coverprofile=coverage.out -coverpkg=github.com/expr-lang/expr/... ./...`
   const coverage = fs.readFileSync('coverage.out').toString()
     .split('\n')
     .filter(line => {
diff --git a/README.md b/README.md
index 4419be468..36362314e 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
 # Expr 
-[![test](https://github.com/antonmedv/expr/actions/workflows/test.yml/badge.svg)](https://github.com/antonmedv/expr/actions/workflows/test.yml) 
-[![Go Report Card](https://goreportcard.com/badge/github.com/antonmedv/expr)](https://goreportcard.com/report/github.com/antonmedv/expr) 
+[![test](https://github.com/expr-lang/expr/actions/workflows/test.yml/badge.svg)](https://github.com/expr-lang/expr/actions/workflows/test.yml) 
+[![Go Report Card](https://goreportcard.com/badge/github.com/expr-lang/expr)](https://goreportcard.com/report/github.com/expr-lang/expr) 
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/expr.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:expr)
-[![GoDoc](https://godoc.org/github.com/antonmedv/expr?status.svg)](https://godoc.org/github.com/antonmedv/expr)
+[![GoDoc](https://godoc.org/github.com/expr-lang/expr?status.svg)](https://godoc.org/github.com/expr-lang/expr)
 
 **Expr** is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed.
 
@@ -53,7 +53,7 @@ Here are its standout features:
 ## Install
 
 ```
-go get github.com/antonmedv/expr
+go get github.com/expr-lang/expr
 ```
 
 ## Documentation
@@ -80,7 +80,7 @@ package main
 
 import (
 	"fmt"
-	"github.com/antonmedv/expr"
+	"github.com/expr-lang/expr"
 )
 
 func main() {
@@ -113,7 +113,7 @@ package main
 
 import (
 	"fmt"
-	"github.com/antonmedv/expr"
+	"github.com/expr-lang/expr"
 )
 
 type Tweet struct {
@@ -165,8 +165,8 @@ func main() {
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 
-[Add your company too](https://github.com/antonmedv/expr/edit/master/README.md)
+[Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 
 ## License
 
-[MIT](https://github.com/antonmedv/expr/blob/master/LICENSE)
+[MIT](https://github.com/expr-lang/expr/blob/master/LICENSE)
diff --git a/ast/node.go b/ast/node.go
index bd7805bd5..7aabf064c 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -4,7 +4,7 @@ import (
 	"reflect"
 	"regexp"
 
-	"github.com/antonmedv/expr/file"
+	"github.com/expr-lang/expr/file"
 )
 
 // Node represents items of abstract syntax tree.
diff --git a/ast/print.go b/ast/print.go
index b4fb4f367..9a7d12391 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/antonmedv/expr/parser/operator"
-	"github.com/antonmedv/expr/parser/utils"
+	"github.com/expr-lang/expr/parser/operator"
+	"github.com/expr-lang/expr/parser/utils"
 )
 
 func (n *NilNode) String() string {
diff --git a/ast/print_test.go b/ast/print_test.go
index 077e85582..12ae6f741 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -6,8 +6,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/parser"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/parser"
 )
 
 func TestPrint(t *testing.T) {
diff --git a/ast/visitor_test.go b/ast/visitor_test.go
index f207d33e5..af0a17b22 100644
--- a/ast/visitor_test.go
+++ b/ast/visitor_test.go
@@ -3,7 +3,7 @@ package ast_test
 import (
 	"testing"
 
-	"github.com/antonmedv/expr/ast"
+	"github.com/expr-lang/expr/ast"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/bench_test.go b/bench_test.go
index 8d1a272c3..6eb450812 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -3,8 +3,8 @@ package expr_test
 import (
 	"testing"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/vm"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/builtin/builtin.go b/builtin/builtin.go
index 1c3d919cc..8576160a6 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -9,8 +9,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/vm/runtime"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/vm/runtime"
 )
 
 var (
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 45582d00a..40f6e32ee 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -10,12 +10,12 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/builtin"
-	"github.com/antonmedv/expr/checker"
-	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/parser"
-	"github.com/antonmedv/expr/test/mock"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/test/mock"
 )
 
 func TestBuiltin(t *testing.T) {
@@ -388,7 +388,7 @@ func TestBuiltin_type(t *testing.T) {
 		{func() {}, "func"},
 		{time.Now(), "time.Time"},
 		{time.Second, "time.Duration"},
-		{Foo{}, "github.com/antonmedv/expr/builtin_test.Foo"},
+		{Foo{}, "github.com/expr-lang/expr/builtin_test.Foo"},
 		{struct{}{}, "struct"},
 		{a, "int"},
 	}
diff --git a/builtin/func.go b/builtin/func.go
index d9ec4ff42..9bcd7827b 100644
--- a/builtin/func.go
+++ b/builtin/func.go
@@ -6,7 +6,7 @@ import (
 	"reflect"
 	"strconv"
 
-	"github.com/antonmedv/expr/vm/runtime"
+	"github.com/expr-lang/expr/vm/runtime"
 )
 
 func Len(x any) any {
diff --git a/checker/checker.go b/checker/checker.go
index 0d10e0bf3..e4e2b50d8 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -5,12 +5,12 @@ import (
 	"reflect"
 	"regexp"
 
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/builtin"
-	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/file"
-	"github.com/antonmedv/expr/parser"
-	"github.com/antonmedv/expr/vm"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/vm"
 )
 
 func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index f6b109bc2..d3b636f5b 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -10,12 +10,12 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/checker"
-	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/parser"
-	"github.com/antonmedv/expr/test/mock"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/test/mock"
 )
 
 func TestCheck(t *testing.T) {
diff --git a/checker/types.go b/checker/types.go
index 890d74a5f..1978fde0b 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -4,7 +4,7 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/antonmedv/expr/conf"
+	"github.com/expr-lang/expr/conf"
 )
 
 var (
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 04f0ff5eb..6f0713b4d 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -4,13 +4,13 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/builtin"
-	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/file"
-	"github.com/antonmedv/expr/parser"
-	. "github.com/antonmedv/expr/vm"
-	"github.com/antonmedv/expr/vm/runtime"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/parser"
+	. "github.com/expr-lang/expr/vm"
+	"github.com/expr-lang/expr/vm/runtime"
 )
 
 const (
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index c2e9c8f3c..083fc688e 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -4,10 +4,10 @@ import (
 	"math"
 	"testing"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/test/playground"
-	"github.com/antonmedv/expr/vm"
-	"github.com/antonmedv/expr/vm/runtime"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/test/playground"
+	"github.com/expr-lang/expr/vm"
+	"github.com/expr-lang/expr/vm/runtime"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/conf/config.go b/conf/config.go
index 5fb5e1194..4de8ca448 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/builtin"
-	"github.com/antonmedv/expr/vm/runtime"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/vm/runtime"
 )
 
 type Config struct {
diff --git a/conf/operators.go b/conf/operators.go
index 13e069d76..ca6606274 100644
--- a/conf/operators.go
+++ b/conf/operators.go
@@ -3,7 +3,7 @@ package conf
 import (
 	"reflect"
 
-	"github.com/antonmedv/expr/ast"
+	"github.com/expr-lang/expr/ast"
 )
 
 // OperatorsTable maps binary operators to corresponding list of functions.
diff --git a/debug/debugger.go b/debug/debugger.go
index 895e70589..a870973ca 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	. "github.com/antonmedv/expr/vm"
+	. "github.com/expr-lang/expr/vm"
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
 )
diff --git a/debug/go.mod b/debug/go.mod
index f8d73c9fb..d329d516f 100644
--- a/debug/go.mod
+++ b/debug/go.mod
@@ -1,9 +1,9 @@
-module github.com/antonmedv/expr/debug
+module github.com/expr-lang/expr/debug
 
 go 1.18
 
 require (
-	github.com/antonmedv/expr v0.0.0
+	github.com/expr-lang/expr v0.0.0
 	github.com/gdamore/tcell/v2 v2.6.0
 	github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703
 )
@@ -18,4 +18,4 @@ require (
 	golang.org/x/text v0.12.0 // indirect
 )
 
-replace github.com/antonmedv/expr => ../
+replace github.com/expr-lang/expr => ../
diff --git a/docgen/README.md b/docgen/README.md
index 8f059d66a..e933c2f4c 100644
--- a/docgen/README.md
+++ b/docgen/README.md
@@ -13,7 +13,7 @@ import (
 	"encoding/json"
 	"fmt"
   
-	"github.com/antonmedv/expr/docgen"
+	"github.com/expr-lang/expr/docgen"
 )
 
 func main() {
@@ -37,7 +37,7 @@ To generate markdown documentation:
 ```go
 package main
 
-import "github.com/antonmedv/expr/docgen"
+import "github.com/expr-lang/expr/docgen"
 
 func main() {
 	// TODO: Replace env with your own types.
diff --git a/docgen/docgen.go b/docgen/docgen.go
index a1145586f..e9a542b8c 100644
--- a/docgen/docgen.go
+++ b/docgen/docgen.go
@@ -5,7 +5,7 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/antonmedv/expr/conf"
+	"github.com/expr-lang/expr/conf"
 )
 
 // Kind can be any of array, map, struct, func, string, int, float, bool or any.
diff --git a/docgen/docgen_test.go b/docgen/docgen_test.go
index e2b58b874..3ffb64ff8 100644
--- a/docgen/docgen_test.go
+++ b/docgen/docgen_test.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	. "github.com/antonmedv/expr/docgen"
+	. "github.com/expr-lang/expr/docgen"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -127,7 +127,7 @@ func TestCreateDoc(t *testing.T) {
 				},
 			},
 		},
-		PkgPath: "github.com/antonmedv/expr/docgen_test",
+		PkgPath: "github.com/expr-lang/expr/docgen_test",
 	}
 
 	assert.EqualValues(t, expected, doc)
@@ -194,7 +194,7 @@ func TestCreateDoc_Ambiguous(t *testing.T) {
 				},
 			},
 		},
-		PkgPath: "github.com/antonmedv/expr/docgen_test",
+		PkgPath: "github.com/expr-lang/expr/docgen_test",
 	}
 
 	assert.EqualValues(t, expected, doc)
diff --git a/docs/Configuration.md b/docs/Configuration.md
index 7dd9d5a18..0e8e56c2e 100644
--- a/docs/Configuration.md
+++ b/docs/Configuration.md
@@ -73,7 +73,7 @@ during the compile step.
 program, err := expr.Compile(`fib(42)`, expr.ConstExpr("fib"))
 ```
 
-[ConstExpr Example](https://pkg.go.dev/github.com/antonmedv/expr?tab=doc#ConstExpr)
+[ConstExpr Example](https://pkg.go.dev/github.com/expr-lang/expr?tab=doc#ConstExpr)
 
 ## Env()
 
diff --git a/docs/Operator-Overloading.md b/docs/Operator-Overloading.md
index 83884103c..2565f820a 100644
--- a/docs/Operator-Overloading.md
+++ b/docs/Operator-Overloading.md
@@ -12,7 +12,7 @@ To use `-` operator:
 Now() - CreatedAt
 ```
 
-To overload the operator use [Operator](https://pkg.go.dev/github.com/antonmedv/expr?tab=doc#Operator) option:
+To overload the operator use [Operator](https://pkg.go.dev/github.com/expr-lang/expr?tab=doc#Operator) option:
 
 ```go
 func main() {
diff --git a/docs/Tips.md b/docs/Tips.md
index 3c5180842..415b78a8b 100644
--- a/docs/Tips.md
+++ b/docs/Tips.md
@@ -10,8 +10,8 @@ package main
 
 import (
 	"fmt"
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/vm"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
 )
 
 func main() {
diff --git a/docs/Visitor-and-Patch.md b/docs/Visitor-and-Patch.md
index 05838dab1..fc4334f34 100644
--- a/docs/Visitor-and-Patch.md
+++ b/docs/Visitor-and-Patch.md
@@ -1,6 +1,6 @@
 # Visitor and Patch
 
-The [ast](https://pkg.go.dev/github.com/antonmedv/expr/ast?tab=doc) package 
+The [ast](https://pkg.go.dev/github.com/expr-lang/expr/ast?tab=doc) package 
 provides the `ast.Visitor` interface and the `ast.Walk` function. It can be
 used to customize the AST before compiling.
 
@@ -12,8 +12,8 @@ package main
 import (
 	"fmt"
 
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/parser"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/parser"
 )
 
 type visitor struct {
@@ -57,8 +57,8 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/ast"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
 )
 
 func main() {
diff --git a/expr.go b/expr.go
index bc5dfc31c..90f1273a1 100644
--- a/expr.go
+++ b/expr.go
@@ -4,15 +4,15 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/checker"
-	"github.com/antonmedv/expr/compiler"
-	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/file"
-	"github.com/antonmedv/expr/optimizer"
-	"github.com/antonmedv/expr/parser"
-	"github.com/antonmedv/expr/patcher"
-	"github.com/antonmedv/expr/vm"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/compiler"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/patcher"
+	"github.com/expr-lang/expr/vm"
 )
 
 // Option for configuring config.
diff --git a/expr_test.go b/expr_test.go
index e05fbd54f..873d726fa 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -11,10 +11,10 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/file"
-	"github.com/antonmedv/expr/test/mock"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/test/mock"
 )
 
 func ExampleEval() {
diff --git a/go.mod b/go.mod
index 03d6b62df..0d2d47190 100644
--- a/go.mod
+++ b/go.mod
@@ -1,4 +1,4 @@
-module github.com/antonmedv/expr
+module github.com/expr-lang/expr
 
 go 1.18
 
diff --git a/optimizer/const_expr.go b/optimizer/const_expr.go
index 694c88bcf..501ea3c58 100644
--- a/optimizer/const_expr.go
+++ b/optimizer/const_expr.go
@@ -5,8 +5,8 @@ import (
 	"reflect"
 	"strings"
 
-	. "github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/file"
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/file"
 )
 
 var errorType = reflect.TypeOf((*error)(nil)).Elem()
diff --git a/optimizer/const_range.go b/optimizer/const_range.go
index 26d6d6f57..506b1c423 100644
--- a/optimizer/const_range.go
+++ b/optimizer/const_range.go
@@ -1,7 +1,7 @@
 package optimizer
 
 import (
-	. "github.com/antonmedv/expr/ast"
+	. "github.com/expr-lang/expr/ast"
 )
 
 type constRange struct{}
diff --git a/optimizer/filter_first.go b/optimizer/filter_first.go
index 852e2c268..7ea8f6fa4 100644
--- a/optimizer/filter_first.go
+++ b/optimizer/filter_first.go
@@ -1,7 +1,7 @@
 package optimizer
 
 import (
-	. "github.com/antonmedv/expr/ast"
+	. "github.com/expr-lang/expr/ast"
 )
 
 type filterFirst struct{}
diff --git a/optimizer/filter_last.go b/optimizer/filter_last.go
index 0a072004b..9a1cc5e29 100644
--- a/optimizer/filter_last.go
+++ b/optimizer/filter_last.go
@@ -1,7 +1,7 @@
 package optimizer
 
 import (
-	. "github.com/antonmedv/expr/ast"
+	. "github.com/expr-lang/expr/ast"
 )
 
 type filterLast struct{}
diff --git a/optimizer/filter_len.go b/optimizer/filter_len.go
index 2293de81d..6577163ec 100644
--- a/optimizer/filter_len.go
+++ b/optimizer/filter_len.go
@@ -1,7 +1,7 @@
 package optimizer
 
 import (
-	. "github.com/antonmedv/expr/ast"
+	. "github.com/expr-lang/expr/ast"
 )
 
 type filterLen struct{}
diff --git a/optimizer/filter_map.go b/optimizer/filter_map.go
index 9044ac34d..d988dc692 100644
--- a/optimizer/filter_map.go
+++ b/optimizer/filter_map.go
@@ -1,7 +1,7 @@
 package optimizer
 
 import (
-	. "github.com/antonmedv/expr/ast"
+	. "github.com/expr-lang/expr/ast"
 )
 
 type filterMap struct{}
diff --git a/optimizer/fold.go b/optimizer/fold.go
index 670ebec09..910c92402 100644
--- a/optimizer/fold.go
+++ b/optimizer/fold.go
@@ -5,8 +5,8 @@ import (
 	"math"
 	"reflect"
 
-	. "github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/file"
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/file"
 )
 
 var (
diff --git a/optimizer/in_array.go b/optimizer/in_array.go
index a51957631..8933d9b91 100644
--- a/optimizer/in_array.go
+++ b/optimizer/in_array.go
@@ -3,7 +3,7 @@ package optimizer
 import (
 	"reflect"
 
-	. "github.com/antonmedv/expr/ast"
+	. "github.com/expr-lang/expr/ast"
 )
 
 type inArray struct{}
diff --git a/optimizer/in_range.go b/optimizer/in_range.go
index b361c6c39..01faabbdf 100644
--- a/optimizer/in_range.go
+++ b/optimizer/in_range.go
@@ -3,7 +3,7 @@ package optimizer
 import (
 	"reflect"
 
-	. "github.com/antonmedv/expr/ast"
+	. "github.com/expr-lang/expr/ast"
 )
 
 type inRange struct{}
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index 15f50fd73..ee9dedeec 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -1,8 +1,8 @@
 package optimizer
 
 import (
-	. "github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/conf"
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/conf"
 )
 
 func Optimize(node *Node, config *conf.Config) error {
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 7ecbefa29..41bd800b7 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -5,12 +5,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/checker"
-	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/optimizer"
-	"github.com/antonmedv/expr/parser"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go
index 5db2dcbb5..d17e19932 100644
--- a/parser/lexer/lexer.go
+++ b/parser/lexer/lexer.go
@@ -5,7 +5,7 @@ import (
 	"strings"
 	"unicode/utf8"
 
-	"github.com/antonmedv/expr/file"
+	"github.com/expr-lang/expr/file"
 )
 
 func Lex(source *file.Source) ([]Token, error) {
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index 031966108..426507579 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -8,8 +8,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/antonmedv/expr/file"
-	. "github.com/antonmedv/expr/parser/lexer"
+	"github.com/expr-lang/expr/file"
+	. "github.com/expr-lang/expr/parser/lexer"
 )
 
 func TestLex(t *testing.T) {
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index bb150878a..5d82329eb 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -3,7 +3,7 @@ package lexer
 import (
 	"strings"
 
-	"github.com/antonmedv/expr/parser/utils"
+	"github.com/expr-lang/expr/parser/utils"
 )
 
 type stateFn func(*lexer) stateFn
diff --git a/parser/lexer/token.go b/parser/lexer/token.go
index 8917b26dc..459fa6905 100644
--- a/parser/lexer/token.go
+++ b/parser/lexer/token.go
@@ -3,7 +3,7 @@ package lexer
 import (
 	"fmt"
 
-	"github.com/antonmedv/expr/file"
+	"github.com/expr-lang/expr/file"
 )
 
 type Kind string
diff --git a/parser/parser.go b/parser/parser.go
index d4a870f71..9b2d909c1 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -6,13 +6,13 @@ import (
 	"strconv"
 	"strings"
 
-	. "github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/builtin"
-	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/file"
-	. "github.com/antonmedv/expr/parser/lexer"
-	"github.com/antonmedv/expr/parser/operator"
-	"github.com/antonmedv/expr/parser/utils"
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/file"
+	. "github.com/expr-lang/expr/parser/lexer"
+	"github.com/expr-lang/expr/parser/operator"
+	"github.com/expr-lang/expr/parser/utils"
 )
 
 var predicates = map[string]struct {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 07cbef22a..5781340be 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -5,8 +5,8 @@ import (
 	"strings"
 	"testing"
 
-	. "github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/parser"
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/patcher/with_context.go b/patcher/with_context.go
index 35765474f..85f095d5d 100644
--- a/patcher/with_context.go
+++ b/patcher/with_context.go
@@ -3,7 +3,7 @@ package patcher
 import (
 	"reflect"
 
-	"github.com/antonmedv/expr/ast"
+	"github.com/expr-lang/expr/ast"
 )
 
 // WithContext adds WithContext.Name argument to all functions calls with a context.Context argument.
diff --git a/patcher/with_context_test.go b/patcher/with_context_test.go
index 311cb3922..0d0917afe 100644
--- a/patcher/with_context_test.go
+++ b/patcher/with_context_test.go
@@ -6,8 +6,8 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/patcher"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/patcher"
 )
 
 func TestWithContext(t *testing.T) {
diff --git a/repl/go.mod b/repl/go.mod
index ea7e9c9b2..b96e6a3be 100644
--- a/repl/go.mod
+++ b/repl/go.mod
@@ -1,10 +1,10 @@
-module github.com/antonmedv/expr/repl
+module github.com/expr-lang/expr/repl
 
 go 1.20
 
 require (
-	github.com/antonmedv/expr v1.13.0
-	github.com/antonmedv/expr/debug v0.0.0
+	github.com/expr-lang/expr v1.13.0
+	github.com/expr-lang/expr/debug v0.0.0
 	github.com/bettercap/readline v0.0.0-20210228151553-655e48bcb7bf
 )
 
@@ -21,6 +21,6 @@ require (
 	golang.org/x/text v0.12.0 // indirect
 )
 
-replace github.com/antonmedv/expr => ../
+replace github.com/expr-lang/expr => ../
 
-replace github.com/antonmedv/expr/debug => ../debug
+replace github.com/expr-lang/expr/debug => ../debug
diff --git a/repl/repl.go b/repl/repl.go
index 078aa4f10..1bbe43c24 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -2,16 +2,17 @@ package main
 
 import (
 	"fmt"
-	"github.com/antonmedv/expr/test/fuzz"
 	"os"
 	"runtime"
 	"strings"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/builtin"
-	"github.com/antonmedv/expr/debug"
-	"github.com/antonmedv/expr/vm"
+	"github.com/expr-lang/expr/test/fuzz"
+
 	"github.com/bettercap/readline"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/debug"
+	"github.com/expr-lang/expr/vm"
 )
 
 var keywords = []string{
diff --git a/test/coredns/coredns_test.go b/test/coredns/coredns_test.go
index 702b66c17..97eb3768f 100644
--- a/test/coredns/coredns_test.go
+++ b/test/coredns/coredns_test.go
@@ -4,8 +4,8 @@ import (
 	"context"
 	"testing"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/test/coredns"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/test/coredns"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/test/crowdsec/crowdsec_test.go b/test/crowdsec/crowdsec_test.go
index e38190a38..2ac25871c 100644
--- a/test/crowdsec/crowdsec_test.go
+++ b/test/crowdsec/crowdsec_test.go
@@ -5,8 +5,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/test/crowdsec"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/test/crowdsec"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 283631c0d..e3bfb7945 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"testing"
 
-	"github.com/antonmedv/expr"
+	"github.com/expr-lang/expr"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 126a3a7ad..e8f3bd8cd 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -6,7 +6,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/antonmedv/expr"
+	"github.com/expr-lang/expr"
 )
 
 //go:embed fuzz_corpus.txt
diff --git a/test/gen/gen.go b/test/gen/gen.go
index a96a5f334..1eb36c9bf 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -6,9 +6,9 @@ import (
 	"reflect"
 	"runtime/debug"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/builtin"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/builtin"
 )
 
 var env = map[string]any{
diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go
index fdb061dc8..424974de8 100644
--- a/test/gen/gen_test.go
+++ b/test/gen/gen_test.go
@@ -5,7 +5,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/antonmedv/expr"
+	"github.com/expr-lang/expr"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/test/gen/utils.go b/test/gen/utils.go
index 0a1b5cc9c..b485fd1a1 100644
--- a/test/gen/utils.go
+++ b/test/gen/utils.go
@@ -3,7 +3,7 @@ package main
 import (
 	"math/rand"
 
-	"github.com/antonmedv/expr/ast"
+	"github.com/expr-lang/expr/ast"
 )
 
 func maybe() bool {
diff --git a/test/interface_method/interface_method_test.go b/test/interface_method/interface_method_test.go
index ab49d5356..23d9862d6 100644
--- a/test/interface_method/interface_method_test.go
+++ b/test/interface_method/interface_method_test.go
@@ -3,7 +3,7 @@ package interface_method_test
 import (
 	"testing"
 
-	"github.com/antonmedv/expr"
+	"github.com/expr-lang/expr"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/test/mock/mock.go b/test/mock/mock.go
index ad4a91563..6d62f3145 100644
--- a/test/mock/mock.go
+++ b/test/mock/mock.go
@@ -6,7 +6,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/antonmedv/expr/ast"
+	"github.com/expr-lang/expr/ast"
 )
 
 type Env struct {
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index 13ef19128..fc5c3b525 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -4,8 +4,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/test/mock"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/test/mock"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/test/patch/patch_test.go b/test/patch/patch_test.go
index cc7b3fd5d..612a63e84 100644
--- a/test/patch/patch_test.go
+++ b/test/patch/patch_test.go
@@ -3,9 +3,9 @@ package patch_test
 import (
 	"testing"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/test/mock"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/test/mock"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/test/patch/set_type/set_type_test.go b/test/patch/set_type/set_type_test.go
index bdeee7d68..673698afb 100644
--- a/test/patch/set_type/set_type_test.go
+++ b/test/patch/set_type/set_type_test.go
@@ -6,8 +6,8 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/ast"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
 )
 
 func TestPatch_SetType(t *testing.T) {
diff --git a/test/pipes/pipes_test.go b/test/pipes/pipes_test.go
index 98c55f5fc..da894d507 100644
--- a/test/pipes/pipes_test.go
+++ b/test/pipes/pipes_test.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/antonmedv/expr"
+	"github.com/expr-lang/expr"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/test/real_world/real_docs/generate.go b/test/real_world/real_docs/generate.go
index 88a14099f..51030e2c5 100644
--- a/test/real_world/real_docs/generate.go
+++ b/test/real_world/real_docs/generate.go
@@ -3,8 +3,8 @@ package main
 import (
 	"fmt"
 
-	"github.com/antonmedv/expr/docgen"
-	"github.com/antonmedv/expr/test/real_world"
+	"github.com/expr-lang/expr/docgen"
+	"github.com/expr-lang/expr/test/real_world"
 )
 
 func main() {
diff --git a/test/time/time_test.go b/test/time/time_test.go
index 7012a24cf..3eeef4a0d 100644
--- a/test/time/time_test.go
+++ b/test/time/time_test.go
@@ -5,12 +5,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/antonmedv/expr"
-	"github.com/antonmedv/expr/checker"
-	"github.com/antonmedv/expr/compiler"
-	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/parser"
-	"github.com/antonmedv/expr/vm"
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/compiler"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/vm"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/vm/program.go b/vm/program.go
index ae5b64108..d634efc62 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -9,9 +9,9 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/antonmedv/expr/builtin"
-	"github.com/antonmedv/expr/file"
-	"github.com/antonmedv/expr/vm/runtime"
+	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/vm/runtime"
 )
 
 // Program represents a compiled expression.
diff --git a/vm/program_test.go b/vm/program_test.go
index 4408a565d..d131e775c 100644
--- a/vm/program_test.go
+++ b/vm/program_test.go
@@ -4,7 +4,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/antonmedv/expr/vm"
+	"github.com/expr-lang/expr/vm"
 )
 
 func TestProgram_Disassemble(t *testing.T) {
diff --git a/vm/vm.go b/vm/vm.go
index 70edb29a8..20e1594fd 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -8,9 +8,9 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/antonmedv/expr/builtin"
-	"github.com/antonmedv/expr/file"
-	"github.com/antonmedv/expr/vm/runtime"
+	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/vm/runtime"
 )
 
 var MemoryBudget uint = 1e6
diff --git a/vm/vm_test.go b/vm/vm_test.go
index c343e1aae..70a0ae057 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -8,12 +8,12 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/antonmedv/expr/ast"
-	"github.com/antonmedv/expr/checker"
-	"github.com/antonmedv/expr/compiler"
-	"github.com/antonmedv/expr/conf"
-	"github.com/antonmedv/expr/parser"
-	"github.com/antonmedv/expr/vm"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/compiler"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/vm"
 )
 
 func TestRun_NilProgram(t *testing.T) {

From 96377f26d9fc75c28e375ceb5da63ca9d6aeae19 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 3 Dec 2023 21:54:16 +0100
Subject: [PATCH 188/506] Fix Expr Code Editor url

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 36362314e..758b87773 100644
--- a/README.md
+++ b/README.md
@@ -64,12 +64,12 @@ go get github.com/expr-lang/expr
 ## Expr Code Editor
 
 <a href="https://bit.ly/expr-code-editor">
-  <img src="https://antonmedv.github.io/expr/ogimage.png" align="center" alt="Expr Code Editor" width="1200"/>
+  <img src="https://expr-lang.github.io/expr/ogimage.png" align="center" alt="Expr Code Editor" width="1200"/>
 </a>
 
 Also, I have an embeddable code editor written in JavaScript which allows editing expressions with syntax highlighting and autocomplete based on your types declaration.
 
-[Learn more →](https://antonmedv.github.io/expr/)
+[Learn more →](https://expr-lang.github.io/expr/)
 
 ## Examples
 

From 4391851a621e2c1b7e9995fcb4f79337f2545b3e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 3 Dec 2023 21:56:26 +0100
Subject: [PATCH 189/506] Transfer antonmedv/expr to expr-lang/expr

---
 README.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 758b87773..1fb477b28 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,8 @@
-# Expr 
+# Expr
+
+> [!IMPORTANT]
+> The repository [github.com/antonmedv/expr](https://github.com/antonmedv/expr) moved to [github.com/**expr-lang**/expr](https://github.com/expr-lang/expr).
+
 [![test](https://github.com/expr-lang/expr/actions/workflows/test.yml/badge.svg)](https://github.com/expr-lang/expr/actions/workflows/test.yml) 
 [![Go Report Card](https://goreportcard.com/badge/github.com/expr-lang/expr)](https://goreportcard.com/report/github.com/expr-lang/expr) 
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/expr.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:expr)

From e2b510d17d2889519eadba41ad7877e2cd498fa7 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 3 Dec 2023 22:24:55 +0100
Subject: [PATCH 190/506] Create FUNDING.yml

---
 .github/FUNDING.yml | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 000000000..bc2800951
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: antonmedv

From 128b62106561041ddb31c62d060a30305d0ab473 Mon Sep 17 00:00:00 2001
From: 100vlx <lxliu@lilith.com>
Date: Wed, 6 Dec 2023 18:02:19 +0800
Subject: [PATCH 191/506]  Get source from *vm.Program (#491)

---
 vm/program.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/vm/program.go b/vm/program.go
index d634efc62..27b8f6098 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -343,3 +343,8 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 		}
 	}
 }
+
+// Source returns origin file.Source.
+func (program *Program) Source() *file.Source {
+	return program.source
+}

From 87c6a94e7089dab4771a0f904af801837f84c0f8 Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Fri, 8 Dec 2023 23:03:50 +0530
Subject: [PATCH 192/506] Enhance the number parser to include support for
 parsing hexadecimal, binary, and octal literals. (#483)

* Enhance the number parser to include support for parsing hexadecimal, binary, and octal literals.

* added invalid literal test cases

* Refactoring code as per comment

---------

Co-authored-by: Ganesan Karuppasamy <ganesan.karuppasamy@sap.com>
---
 parser/lexer/lexer_test.go |  4 ++-
 parser/parser.go           | 60 +++++++++++++++++++++++++-------------
 parser/parser_test.go      | 60 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 103 insertions(+), 21 deletions(-)

diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index 426507579..d4bed139e 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -18,7 +18,7 @@ func TestLex(t *testing.T) {
 		tokens []Token
 	}{
 		{
-			".5 0.025 1 02 1e3 0xFF 1.2e-4 1_000_000 _42 -.5",
+			".5 0.025 1 02 1e3 0xFF 0b0101 0o600 1.2e-4 1_000_000 _42 -.5",
 			[]Token{
 				{Kind: Number, Value: ".5"},
 				{Kind: Number, Value: "0.025"},
@@ -26,6 +26,8 @@ func TestLex(t *testing.T) {
 				{Kind: Number, Value: "02"},
 				{Kind: Number, Value: "1e3"},
 				{Kind: Number, Value: "0xFF"},
+				{Kind: Number, Value: "0b0101"},
+				{Kind: Number, Value: "0o600"},
 				{Kind: Number, Value: "1.2e-4"},
 				{Kind: Number, Value: "1_000_000"},
 				{Kind: Identifier, Value: "_42"},
diff --git a/parser/parser.go b/parser/parser.go
index 9b2d909c1..5f29279bc 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -306,40 +306,44 @@ func (p *parser) parseSecondary() Node {
 	case Number:
 		p.next()
 		value := strings.Replace(token.Value, "_", "", -1)
-		if strings.Contains(value, "x") {
+		var node Node
+		valueLower := strings.ToLower(value)
+		switch {
+		case strings.HasPrefix(valueLower, "0x"):
 			number, err := strconv.ParseInt(value, 0, 64)
 			if err != nil {
 				p.error("invalid hex literal: %v", err)
 			}
-			if number > math.MaxInt {
-				p.error("integer literal is too large")
-				return nil
-			}
-			node := &IntegerNode{Value: int(number)}
-			node.SetLocation(token.Location)
-			return node
-		} else if strings.ContainsAny(value, ".eE") {
+			node = p.toIntegerNode(number)
+		case strings.ContainsAny(valueLower, ".e"):
 			number, err := strconv.ParseFloat(value, 64)
 			if err != nil {
 				p.error("invalid float literal: %v", err)
 			}
-			node := &FloatNode{Value: number}
-			node.SetLocation(token.Location)
-			return node
-		} else {
+			node = p.toFloatNode(number)
+		case strings.HasPrefix(valueLower, "0b"):
+			number, err := strconv.ParseInt(value, 0, 64)
+			if err != nil {
+				p.error("invalid binary literal: %v", err)
+			}
+			node = p.toIntegerNode(number)
+		case strings.HasPrefix(valueLower, "0o"):
+			number, err := strconv.ParseInt(value, 0, 64)
+			if err != nil {
+				p.error("invalid octal literal: %v", err)
+			}
+			node = p.toIntegerNode(number)
+		default:
 			number, err := strconv.ParseInt(value, 10, 64)
 			if err != nil {
 				p.error("invalid integer literal: %v", err)
 			}
-			if number > math.MaxInt {
-				p.error("integer literal is too large")
-				return nil
-			}
-			node := &IntegerNode{Value: int(number)}
+			node = p.toIntegerNode(number)
+		}
+		if node != nil {
 			node.SetLocation(token.Location)
-			return node
 		}
-
+		return node
 	case String:
 		p.next()
 		node := &StringNode{Value: token.Value}
@@ -359,6 +363,22 @@ func (p *parser) parseSecondary() Node {
 	return p.parsePostfixExpression(node)
 }
 
+func (p *parser) toIntegerNode(number int64) Node {
+	if number > math.MaxInt {
+		p.error("integer literal is too large")
+		return nil
+	}
+	return &IntegerNode{Value: int(number)}
+}
+
+func (p *parser) toFloatNode(number float64) Node {
+	if number > math.MaxFloat64 {
+		p.error("float literal is too large")
+		return nil
+	}
+	return &FloatNode{Value: number}
+}
+
 func (p *parser) parseCall(token Token) Node {
 	var node Node
 	if p.current.Is(Bracket, "(") {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 5781340be..2af7635ed 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -36,6 +36,26 @@ func TestParse(t *testing.T) {
 			"0x6E",
 			&IntegerNode{Value: 110},
 		},
+		{
+			"0X63",
+			&IntegerNode{Value: 99},
+		},
+		{
+			"0o600",
+			&IntegerNode{Value: 384},
+		},
+		{
+			"0O45",
+			&IntegerNode{Value: 37},
+		},
+		{
+			"0b10",
+			&IntegerNode{Value: 2},
+		},
+		{
+			"0B101011",
+			&IntegerNode{Value: 43},
+		},
 		{
 			"10_000_000",
 			&IntegerNode{Value: 10_000_000},
@@ -549,6 +569,46 @@ foo ?? bar || baz
 Operator (||) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses. (1:12)
  | foo ?? bar || baz
  | ...........^
+
+0b15
+bad number syntax: "0b15" (1:5)
+ | 0b15
+ | ....^
+
+0X10G
+bad number syntax: "0X10G" (1:6)
+ | 0X10G
+ | .....^
+
+0o1E
+invalid float literal: strconv.ParseFloat: parsing "0o1E": invalid syntax (1:4)
+ | 0o1E
+ | ...^
+
+0b1E
+invalid float literal: strconv.ParseFloat: parsing "0b1E": invalid syntax (1:4)
+ | 0b1E
+ | ...^
+
+0b1E+6
+bad number syntax: "0b1E+6" (1:7)
+ | 0b1E+6
+ | ......^
+
+0b1E+1
+invalid float literal: strconv.ParseFloat: parsing "0b1E+1": invalid syntax (1:6)
+ | 0b1E+1
+ | .....^
+
+0o1E+1
+invalid float literal: strconv.ParseFloat: parsing "0o1E+1": invalid syntax (1:6)
+ | 0o1E+1
+ | .....^
+
+1E
+invalid float literal: strconv.ParseFloat: parsing "1E": invalid syntax (1:2)
+ | 1E
+ | .^
 `
 
 func TestParse_error(t *testing.T) {

From 87fda6772d265db28f82d0501b3de7114515ff9a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 8 Dec 2023 18:42:45 +0100
Subject: [PATCH 193/506] fuzz: exclude error unknown time zone

---
 test/fuzz/fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index e8f3bd8cd..131c3e98b 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -32,6 +32,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`invalid duration`),
 		regexp.MustCompile(`time: missing unit in duration`),
 		regexp.MustCompile(`time: unknown unit .* in duration`),
+		regexp.MustCompile(`unknown time zone`),
 		regexp.MustCompile(`json: unsupported value`),
 		regexp.MustCompile(`unexpected end of JSON input`),
 		regexp.MustCompile(`memory budget exceeded`),

From d7fe04be6483d5a9b7076295fdb96905e3ad9dea Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 10 Dec 2023 10:44:43 +0100
Subject: [PATCH 194/506] checker: forbid accessing custom functions from $env

---
 checker/checker.go | 14 ++++++++------
 expr_test.go       | 25 +++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index e4e2b50d8..c214acf3b 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -157,6 +157,12 @@ func (v *checker) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 	if node.Value == "$env" {
 		return mapType, info{}
 	}
+	if fn, ok := v.config.Builtins[node.Value]; ok {
+		return functionType, info{fn: fn}
+	}
+	if fn, ok := v.config.Functions[node.Value]; ok {
+		return functionType, info{fn: fn}
+	}
 	return v.env(node, node.Value, true)
 }
 
@@ -166,13 +172,9 @@ type NodeWithIndexes interface {
 	SetMethodIndex(methodIndex int)
 }
 
+// env method returns type of environment variable. env only lookups for
+// environment variables, no builtins, no custom functions.
 func (v *checker) env(node NodeWithIndexes, name string, strict bool) (reflect.Type, info) {
-	if fn, ok := v.config.Builtins[name]; ok {
-		return functionType, info{fn: fn}
-	}
-	if fn, ok := v.config.Functions[name]; ok {
-		return functionType, info{fn: fn}
-	}
 	if t, ok := v.config.Types[name]; ok {
 		if t.Ambiguous {
 			return v.error(node, "ambiguous identifier %v", name)
diff --git a/expr_test.go b/expr_test.go
index 873d726fa..eb77408b1 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1971,7 +1971,32 @@ func TestEnv_keyword(t *testing.T) {
 
 		})
 	}
+}
+
+func TestEnv_keyword_with_custom_functions(t *testing.T) {
+	fn := expr.Function("fn", func(params ...any) (any, error) {
+		return "ok", nil
+	})
+
+	var tests = []struct {
+		code  string
+		error bool
+	}{
+		{`fn()`, false},
+		{`$env.fn()`, true},
+		{`$env["fn"]`, true},
+	}
 
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			_, err := expr.Compile(tt.code, expr.Env(mock.Env{}), fn)
+			if tt.error {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
 }
 
 func TestIssue401(t *testing.T) {

From 9ba50946c14428bb17a891f81924c7a6d4b31297 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 10 Dec 2023 10:44:58 +0100
Subject: [PATCH 195/506] fuzz: add custom function to fuzzer

---
 repl/repl.go           |  5 ++++-
 test/fuzz/fuzz_env.go  | 12 ++++++++++++
 test/fuzz/fuzz_test.go |  3 ++-
 3 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/repl/repl.go b/repl/repl.go
index 1bbe43c24..7fddc0ea3 100644
--- a/repl/repl.go
+++ b/repl/repl.go
@@ -9,6 +9,7 @@ import (
 	"github.com/expr-lang/expr/test/fuzz"
 
 	"github.com/bettercap/readline"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/debug"
@@ -29,6 +30,8 @@ func main() {
 	for name := range env {
 		keywords = append(keywords, name)
 	}
+	fn := fuzz.Func()
+	keywords = append(keywords, "fn")
 	home, err := os.UserHomeDir()
 	if err != nil {
 		panic(err)
@@ -81,7 +84,7 @@ func main() {
 			continue
 		}
 
-		program, err = expr.Compile(line, expr.Env(env))
+		program, err = expr.Compile(line, expr.Env(env), fn)
 		if err != nil {
 			fmt.Printf("compile error: %s\n", err)
 			continue
diff --git a/test/fuzz/fuzz_env.go b/test/fuzz/fuzz_env.go
index f761148de..d646ee92d 100644
--- a/test/fuzz/fuzz_env.go
+++ b/test/fuzz/fuzz_env.go
@@ -1,5 +1,11 @@
 package fuzz
 
+import (
+	"fmt"
+
+	"github.com/expr-lang/expr"
+)
+
 func NewEnv() map[string]any {
 	return map[string]any{
 		"ok":    true,
@@ -25,6 +31,12 @@ func NewEnv() map[string]any {
 	}
 }
 
+func Func() expr.Option {
+	return expr.Function("fn", func(params ...any) (any, error) {
+		return fmt.Sprintf("fn(%v)", params), nil
+	})
+}
+
 type Foo struct {
 	Bar string
 }
diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 131c3e98b..f1844b2f7 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -54,13 +54,14 @@ func FuzzExpr(f *testing.F) {
 	}
 
 	env := NewEnv()
+	fn := Func()
 
 	f.Fuzz(func(t *testing.T, code string) {
 		if len(code) > 1000 {
 			t.Skip("too long code")
 		}
 
-		program, err := expr.Compile(code, expr.Env(env))
+		program, err := expr.Compile(code, expr.Env(env), fn)
 		if err != nil {
 			t.Skipf("compile error: %s", err)
 		}

From 515f38b3dbfb85171c6becf2009bb2d39d4c2bb8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 10 Dec 2023 11:02:12 +0100
Subject: [PATCH 196/506] fix: make deref commutative

Fixes #490
---
 compiler/compiler.go     |  4 ++--
 test/deref/deref_test.go | 39 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 6f0713b4d..4831a3103 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -368,7 +368,7 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 		c.compile(node.Left)
 		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
-		c.derefInNeeded(node.Left)
+		c.derefInNeeded(node.Right)
 
 		if l == r && l == reflect.Int && leftAndRightAreSimple {
 			c.emit(OpEqualInt)
@@ -382,7 +382,7 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 		c.compile(node.Left)
 		c.derefInNeeded(node.Left)
 		c.compile(node.Right)
-		c.derefInNeeded(node.Left)
+		c.derefInNeeded(node.Right)
 		c.emit(OpEqual)
 		c.emit(OpNot)
 
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index e3bfb7945..684794a01 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -4,8 +4,9 @@ import (
 	"context"
 	"testing"
 
-	"github.com/expr-lang/expr"
 	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr"
 )
 
 func TestDeref_binary(t *testing.T) {
@@ -200,3 +201,39 @@ func TestDeref_nil_in_pointer_of_interface(t *testing.T) {
 		require.Equal(t, true, output)
 	})
 }
+
+func TestDeref_сommutative(t *testing.T) {
+	a := "ok"
+	b := "ok"
+
+	type Env struct {
+		A string
+		B *string
+	}
+
+	env := Env{
+		A: a,
+		B: &b,
+	}
+
+	tests := []struct {
+		code string
+		want bool
+	}{
+		{`A == B`, true},
+		{`B == A`, true},
+		{`A != B`, false},
+		{`B != A`, false},
+	}
+
+	for _, test := range tests {
+		t.Run(test.code, func(t *testing.T) {
+			program, err := expr.Compile(test.code, expr.Env(env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, env)
+			require.NoError(t, err)
+			require.Equal(t, test.want, out)
+		})
+	}
+}

From bc65b9bce8ae52c67dced8c43ecf24bd3d3eb96c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 10 Dec 2023 11:11:21 +0100
Subject: [PATCH 197/506] MIT License

---
 LICENSE | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LICENSE b/LICENSE
index 7d058f841..ec46ce324 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Anton Medvedev
+Copyright (c) 2018 Anton Medvedev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

From e09a605bd1fe493f331996357734a0afcde52a90 Mon Sep 17 00:00:00 2001
From: Sergey Grebenshchikov <sgreben@users.noreply.github.com>
Date: Mon, 18 Dec 2023 21:46:31 +0100
Subject: [PATCH 198/506] Fix: checker panic on embedded pointer to struct
 field (#500)

* add failing test case: embedded pointer to struct

* fix(dereference embedded pointers to structs)

* add evaluation test for field access and method call on embedded pointer struct
---
 checker/checker_test.go |  1 +
 checker/types.go        |  6 +++-
 expr_test.go            | 62 +++++++++++++++++++++++++++++++++++++++++
 test/mock/mock.go       | 13 +++++++++
 4 files changed, 81 insertions(+), 1 deletion(-)

diff --git a/checker/checker_test.go b/checker/checker_test.go
index d3b636f5b..42301261d 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -131,6 +131,7 @@ func TestCheck(t *testing.T) {
 		{"(Any.Bool ?? Bool) > 0"},
 		{"Bool ?? Bool"},
 		{"let foo = 1; foo == 1"},
+		{"(Embed).EmbedPointerEmbedInt > 0"},
 	}
 
 	for _, tt := range tests {
diff --git a/checker/types.go b/checker/types.go
index 1978fde0b..c7a75278b 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -192,7 +192,11 @@ func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
 		for i := 0; i < t.NumField(); i++ {
 			anon := t.Field(i)
 			if anon.Anonymous {
-				if field, ok := fetchField(anon.Type, name); ok {
+				anonType := anon.Type
+				for anonType.Kind() == reflect.Pointer {
+					anonType = anonType.Elem()
+				}
+				if field, ok := fetchField(anonType, name); ok {
 					field.Index = append(anon.Index, field.Index...)
 					return field, true
 				}
diff --git a/expr_test.go b/expr_test.go
index eb77408b1..d0f5b198b 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2180,6 +2180,68 @@ func TestIssue462(t *testing.T) {
 	require.Error(t, err)
 }
 
+func TestIssue_embedded_pointer_struct(t *testing.T) {
+	var tests = []struct {
+		input string
+		env   mock.Env
+		want  any
+	}{
+		{
+			input: "(Embed).EmbedPointerEmbedInt > 0",
+			env: mock.Env{
+				Embed: mock.Embed{
+					EmbedPointerEmbed: &mock.EmbedPointerEmbed{
+						EmbedPointerEmbedInt: 123,
+					},
+				},
+			},
+			want: true,
+		},
+		{
+			input: "(Embed).EmbedPointerEmbedInt > 0",
+			env: mock.Env{
+				Embed: mock.Embed{
+					EmbedPointerEmbed: &mock.EmbedPointerEmbed{
+						EmbedPointerEmbedInt: 0,
+					},
+				},
+			},
+			want: false,
+		},
+		{
+			input: "(Embed).EmbedPointerEmbedMethod(0)",
+			env: mock.Env{
+				Embed: mock.Embed{
+					EmbedPointerEmbed: &mock.EmbedPointerEmbed{
+						EmbedPointerEmbedInt: 0,
+					},
+				},
+			},
+			want: "",
+		},
+		{
+			input: "(Embed).EmbedPointerEmbedPointerReceiverMethod(0)",
+			env: mock.Env{
+				Embed: mock.Embed{
+					EmbedPointerEmbed: nil,
+				},
+			},
+			want: "",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			program, err := expr.Compile(tt.input, expr.Env(tt.env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, tt.env)
+			require.NoError(t, err)
+
+			require.Equal(t, tt.want, out)
+		})
+	}
+}
+
 func TestIssue(t *testing.T) {
 	testCases := []struct {
 		code string
diff --git a/test/mock/mock.go b/test/mock/mock.go
index 6d62f3145..5c0fa9e3f 100644
--- a/test/mock/mock.go
+++ b/test/mock/mock.go
@@ -103,6 +103,7 @@ func (Env) NotStringerStringerEqual(f fmt.Stringer, g fmt.Stringer) bool {
 
 type Embed struct {
 	EmbedEmbed
+	*EmbedPointerEmbed
 	EmbedString string
 }
 
@@ -110,6 +111,18 @@ func (p Embed) EmbedMethod(_ int) string {
 	return ""
 }
 
+type EmbedPointerEmbed struct {
+	EmbedPointerEmbedInt int
+}
+
+func (p EmbedPointerEmbed) EmbedPointerEmbedMethod(_ int) string {
+	return ""
+}
+
+func (p *EmbedPointerEmbed) EmbedPointerEmbedPointerReceiverMethod(_ int) string {
+	return ""
+}
+
 type EmbedEmbed struct {
 	EmbedEmbedString string
 }

From cd16e732543a766a0d31735dcc4003e39ae9da25 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 19 Dec 2023 08:40:13 +0100
Subject: [PATCH 199/506] Add additional ember test

---
 expr_test.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/expr_test.go b/expr_test.go
index d0f5b198b..ff5eea3f0 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2186,6 +2186,17 @@ func TestIssue_embedded_pointer_struct(t *testing.T) {
 		env   mock.Env
 		want  any
 	}{
+		{
+			input: "EmbedPointerEmbedInt > 0",
+			env: mock.Env{
+				Embed: mock.Embed{
+					EmbedPointerEmbed: &mock.EmbedPointerEmbed{
+						EmbedPointerEmbedInt: 123,
+					},
+				},
+			},
+			want: true,
+		},
 		{
 			input: "(Embed).EmbedPointerEmbedInt > 0",
 			env: mock.Env{

From 632e43778e6e4594ce804e46f3cd104a3ae900ef Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 19 Dec 2023 17:12:18 +0100
Subject: [PATCH 200/506] Update README.md

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index 1fb477b28..73ef1616b 100644
--- a/README.md
+++ b/README.md
@@ -165,7 +165,6 @@ func main() {
 * [Philips Labs](https://github.com/philips-labs/tabia) employs Expr in Tabia, a tool designed to collect insights on their code bases.
 * [CoreDNS](https://coredns.io) uses Expr in CoreDNS, which is a DNS server.
 * [Chaos Mesh](https://chaos-mesh.org) incorporates Expr into Chaos Mesh, a cloud-native Chaos Engineering platform.
-* [Milvus](https://milvus.io) integrates Expr into Milvus, an open-source vector database.
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 

From f0a00de565c26fecf218395e840b7efdc2ee7545 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 19 Dec 2023 18:03:12 +0100
Subject: [PATCH 201/506] Update README.md

---
 README.md | 25 ++++++++++---------------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 73ef1616b..09a9a6335 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Expr
+<h1><a href="https://expr-lang.org"><img src="https://expr-lang.org/img/logo.png" alt="Zx logo" height="48"align="right"></a> Expr</h1>
 
 > [!IMPORTANT]
 > The repository [github.com/antonmedv/expr](https://github.com/antonmedv/expr) moved to [github.com/**expr-lang**/expr](https://github.com/expr-lang/expr).
@@ -10,16 +10,21 @@
 
 **Expr** is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed.
 
-<img src="https://expr.medv.io/img/logo-small.png" width="150" alt="expr logo" align="right"/>
+**Expr** offers a simple [syntax](https://expr-lang.org/docs/Language-Definition) with powerful features, ensuring ease of use:
 
 ```js
 // Allow only admins and moderators to moderate comments.
 user.Group in ["admin", "moderator"] || user.Id == comment.UserId
 ```
 
+```js
+// Determine whether the request is in the permitted time window.
+request.Time - resource.Age < duration("24h")
+```
+
 ```js
 // Ensure all tweets are less than 240 characters.
-all(Tweets, .Size <= 240)
+all(tweets, len(.Content) <= 240)
 ```
 
 ## Features
@@ -62,18 +67,8 @@ go get github.com/expr-lang/expr
 
 ## Documentation
 
-* See [Getting Started](https://expr.medv.io/docs/Getting-Started) page for developer documentation.
-* See [Language Definition](https://expr.medv.io/docs/Language-Definition) page to learn the syntax.
-
-## Expr Code Editor
-
-<a href="https://bit.ly/expr-code-editor">
-  <img src="https://expr-lang.github.io/expr/ogimage.png" align="center" alt="Expr Code Editor" width="1200"/>
-</a>
-
-Also, I have an embeddable code editor written in JavaScript which allows editing expressions with syntax highlighting and autocomplete based on your types declaration.
-
-[Learn more →](https://expr-lang.github.io/expr/)
+* See [Getting Started](https://expr-lang.org/docs/Getting-Started) page for developer documentation.
+* See [Language Definition](https://expr-lang.org/docs/Language-Definition) page to learn the syntax.
 
 ## Examples
 

From 5117651774c6df8b959d8584aa78c0dee6f8c889 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 19 Dec 2023 18:09:15 +0100
Subject: [PATCH 202/506] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 09a9a6335..d8b16ce77 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@
 
 **Expr** is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed.
 
-**Expr** offers a simple [syntax](https://expr-lang.org/docs/Language-Definition) with powerful features, ensuring ease of use:
+**Expr** combines simple [syntax](https://expr-lang.org/docs/Language-Definition) with powerful features for ease of use:
 
 ```js
 // Allow only admins and moderators to moderate comments.

From de39ee0b8c98424808483a3929b205794b16c6b3 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 19 Dec 2023 18:10:39 +0100
Subject: [PATCH 203/506] Update README.md

---
 README.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d8b16ce77..74e3afda3 100644
--- a/README.md
+++ b/README.md
@@ -8,8 +8,7 @@
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/expr.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:expr)
 [![GoDoc](https://godoc.org/github.com/expr-lang/expr?status.svg)](https://godoc.org/github.com/expr-lang/expr)
 
-**Expr** is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed.
-
+**Expr** is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed. 
 **Expr** combines simple [syntax](https://expr-lang.org/docs/Language-Definition) with powerful features for ease of use:
 
 ```js

From 9b18a23fdb09c2023f931847fa9e44bbadaf8306 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 19 Dec 2023 20:45:06 +0100
Subject: [PATCH 204/506] Rename test case

---
 expr_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/expr_test.go b/expr_test.go
index ff5eea3f0..9e0d3a762 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2253,7 +2253,7 @@ func TestIssue_embedded_pointer_struct(t *testing.T) {
 	}
 }
 
-func TestIssue(t *testing.T) {
+func TestIssue474(t *testing.T) {
 	testCases := []struct {
 		code string
 		fail bool

From e7ab66afbb79c3728d7ba6fc80b909d8bacca4f2 Mon Sep 17 00:00:00 2001
From: Sergey Grebenshchikov <sgreben@users.noreply.github.com>
Date: Fri, 22 Dec 2023 10:14:08 +0100
Subject: [PATCH 205/506] remove unnecessary loop (#501)

---
 checker/types.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/checker/types.go b/checker/types.go
index c7a75278b..662139c37 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -193,7 +193,7 @@ func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
 			anon := t.Field(i)
 			if anon.Anonymous {
 				anonType := anon.Type
-				for anonType.Kind() == reflect.Pointer {
+				if anonType.Kind() == reflect.Pointer {
 					anonType = anonType.Elem()
 				}
 				if field, ok := fetchField(anonType, name); ok {

From aea29169cc232ab7079f42b70e996823c25d190a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 22 Dec 2023 22:48:59 +0100
Subject: [PATCH 206/506] Add custom tests

---
 .gitignore   |  1 +
 expr_test.go | 30 ++++++++++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/.gitignore b/.gitignore
index b0df3eb44..b089dce8a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,4 @@
 *.test
 *.out
 *.html
+custom_tests.json
diff --git a/expr_test.go b/expr_test.go
index 9e0d3a762..836702249 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"os"
 	"reflect"
 	"testing"
 	"time"
@@ -2053,6 +2054,35 @@ func TestMemoryBudget(t *testing.T) {
 	}
 }
 
+func TestExpr_custom_tests(t *testing.T) {
+	f, err := os.Open("custom_tests.json")
+	if os.IsNotExist(err) {
+		t.Skip("no custom tests")
+		return
+	}
+
+	require.NoError(t, err, "open file error")
+	defer f.Close()
+
+	var tests []string
+	err = json.NewDecoder(f).Decode(&tests)
+	require.NoError(t, err, "decode json error")
+
+	for id, tt := range tests {
+		t.Run(fmt.Sprintf("line %v", id+2), func(t *testing.T) {
+			program, err := expr.Compile(tt)
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, nil)
+
+			// Make sure out is used.
+			_ = fmt.Sprintf("%v", out)
+
+			assert.Error(t, err)
+		})
+	}
+}
+
 func TestIssue432(t *testing.T) {
 	env := map[string]any{
 		"func": func(

From e4a455598673b33386db37686a314ec29da6d255 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 22 Dec 2023 22:49:31 +0100
Subject: [PATCH 207/506] Remove const range optimization

---
 optimizer/const_range.go    | 40 -------------------------------------
 optimizer/optimizer.go      |  1 -
 optimizer/optimizer_test.go | 19 +++---------------
 3 files changed, 3 insertions(+), 57 deletions(-)
 delete mode 100644 optimizer/const_range.go

diff --git a/optimizer/const_range.go b/optimizer/const_range.go
deleted file mode 100644
index 506b1c423..000000000
--- a/optimizer/const_range.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package optimizer
-
-import (
-	. "github.com/expr-lang/expr/ast"
-)
-
-type constRange struct{}
-
-func (*constRange) Visit(node *Node) {
-	switch n := (*node).(type) {
-	case *BinaryNode:
-		if n.Operator == ".." {
-			if min, ok := n.Left.(*IntegerNode); ok {
-				if max, ok := n.Right.(*IntegerNode); ok {
-					size := max.Value - min.Value + 1
-					// In case the max < min, patch empty slice
-					// as max must be greater than equal to min.
-					if size < 1 {
-						Patch(node, &ConstantNode{
-							Value: make([]int, 0),
-						})
-						return
-					}
-					// In this case array is too big. Skip generation,
-					// and wait for memory budget detection on runtime.
-					if size > 1e6 {
-						return
-					}
-					value := make([]int, size)
-					for i := range value {
-						value[i] = min.Value + i
-					}
-					Patch(node, &ConstantNode{
-						Value: value,
-					})
-				}
-			}
-		}
-	}
-}
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index ee9dedeec..a9c0fa3d3 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -32,7 +32,6 @@ func Optimize(node *Node, config *conf.Config) error {
 		}
 	}
 	Walk(node, &inRange{})
-	Walk(node, &constRange{})
 	Walk(node, &filterMap{})
 	Walk(node, &filterLen{})
 	Walk(node, &filterLast{})
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 41bd800b7..e45de763b 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -5,14 +5,15 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/checker"
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/optimizer"
 	"github.com/expr-lang/expr/parser"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestOptimize_constant_folding(t *testing.T) {
@@ -116,20 +117,6 @@ func TestOptimize_in_range_with_floats(t *testing.T) {
 	assert.Equal(t, false, out)
 }
 
-func TestOptimize_const_range(t *testing.T) {
-	tree, err := parser.Parse(`-1..1`)
-	require.NoError(t, err)
-
-	err = optimizer.Optimize(&tree.Node, nil)
-	require.NoError(t, err)
-
-	expected := &ast.ConstantNode{
-		Value: []int{-1, 0, 1},
-	}
-
-	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
-}
-
 func TestOptimize_const_expr(t *testing.T) {
 	tree, err := parser.Parse(`toUpper("hello")`)
 	require.NoError(t, err)

From cf9f6e864ca3a20b70832f532f59ad3cee6bb6b8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 22 Dec 2023 22:49:43 +0100
Subject: [PATCH 208/506] Update ast comments

---
 ast/node.go | 30 ++++++++++++++----------------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index 7aabf064c..f9d27fc6a 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -121,15 +121,15 @@ type BinaryNode struct {
 	Operator string         // Operator of the binary operator. Like "+" in "foo + bar" or "matches" in "foo matches bar".
 	Left     Node           // Left node of the binary operator.
 	Right    Node           // Right node of the binary operator.
-	Regexp   *regexp.Regexp // Internal. Regexp of the "matches" operator. Like "f.+" in `foo matches "f.+"`.
+	Regexp   *regexp.Regexp // Internal. Regexp of the "matches" operator. Like "f.+".
 }
 
 // ChainNode represents an optional chaining group.
 // A few MemberNode nodes can be chained together,
 // and will be wrapped in a ChainNode. Example:
-// ```
-// foo.bar?.baz?.qux
-// ```
+//
+//	foo.bar?.baz?.qux
+//
 // The whole chain will be wrapped in a ChainNode.
 type ChainNode struct {
 	base
@@ -140,11 +140,10 @@ type ChainNode struct {
 // It can be a field access, a method call,
 // or an array element access.
 // Example:
-// ```
-// foo.bar or foo["bar"]
-// foo.bar()
-// array[0]
-// ```
+//
+//	foo.bar or foo["bar"]
+//	foo.bar()
+//	array[0]
 type MemberNode struct {
 	base
 	Node       Node   // Node of the member access. Like "foo" in "foo.bar".
@@ -171,9 +170,8 @@ func (n *MemberNode) SetMethodIndex(methodIndex int) {
 
 // SliceNode represents access to a slice of an array.
 // Example:
-// ```
-// array[1:4]
-// ```
+//
+//	array[1:4]
 type SliceNode struct {
 	base
 	Node Node // Node of the slice. Like "array" in "array[1:4]".
@@ -202,10 +200,10 @@ type BuiltinNode struct {
 
 // ClosureNode represents a predicate.
 // Example:
-// ```
-// filter(foo, .bar == 1)
-// ```
-// The predicate is `.bar == 1`.
+//
+//	filter(foo, .bar == 1)
+//
+// The predicate is ".bar == 1".
 type ClosureNode struct {
 	base
 	Node Node // Node of the predicate body.

From 7f738559ed6cd76014686f7dea3d7f6809956ba9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 22 Dec 2023 23:09:31 +0100
Subject: [PATCH 209/506] Add timeout to test

---
 expr_test.go | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index 836702249..4992ca2c3 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2073,12 +2073,27 @@ func TestExpr_custom_tests(t *testing.T) {
 			program, err := expr.Compile(tt)
 			require.NoError(t, err)
 
-			out, err := expr.Run(program, nil)
-
-			// Make sure out is used.
-			_ = fmt.Sprintf("%v", out)
-
-			assert.Error(t, err)
+			timeout := make(chan bool, 1)
+			go func() {
+				time.Sleep(time.Second)
+				timeout <- true
+			}()
+
+			done := make(chan bool, 1)
+			go func() {
+				out, err := expr.Run(program, nil)
+				// Make sure out is used.
+				_ = fmt.Sprintf("%v", out)
+				assert.Error(t, err)
+				done <- true
+			}()
+
+			select {
+			case <-done:
+				// Success.
+			case <-timeout:
+				t.Fatal("timeout")
+			}
 		})
 	}
 }

From 202e62236c9113b691b3ff0522d93c2eeee66bbd Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 23 Dec 2023 10:33:54 +0100
Subject: [PATCH 210/506] Update README.md

---
 README.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 74e3afda3..7c08fc672 100644
--- a/README.md
+++ b/README.md
@@ -151,13 +151,13 @@ func main() {
 * [Aviasales](https://aviasales.ru) utilizes Expr as a business rule engine for its flight search engine.
 * [Wish.com](https://www.wish.com) employs Expr in its decision-making rule engine for the Wish Assistant.
 * [Argo](https://argoproj.github.io) integrates Expr into Argo Rollouts and Argo Workflows for Kubernetes.
-* [Crowdsec](https://crowdsec.net) incorporates Expr into its security automation tool.
-* [FACEIT](https://www.faceit.com) uses Expr to enhance customization of its eSports matchmaking algorithm.
-* [qiniu](https://www.qiniu.com) implements Expr in its trade systems.
-* [Junglee Games](https://www.jungleegames.com/) uses Expr for its in-house marketing retention tool, Project Audience.
 * [OpenTelemetry](https://opentelemetry.io) integrates Expr into the OpenTelemetry Collector.
 * [Philips Labs](https://github.com/philips-labs/tabia) employs Expr in Tabia, a tool designed to collect insights on their code bases.
+* [CrowdSec](https://crowdsec.net) incorporates Expr into its security automation tool.
 * [CoreDNS](https://coredns.io) uses Expr in CoreDNS, which is a DNS server.
+* [qiniu](https://www.qiniu.com) implements Expr in its trade systems.
+* [Junglee Games](https://www.jungleegames.com/) uses Expr for its in-house marketing retention tool, Project Audience.
+* [Faceit](https://www.faceit.com) uses Expr to enhance customization of its eSports matchmaking algorithm.
 * [Chaos Mesh](https://chaos-mesh.org) incorporates Expr into Chaos Mesh, a cloud-native Chaos Engineering platform.
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
@@ -167,3 +167,5 @@ func main() {
 ## License
 
 [MIT](https://github.com/expr-lang/expr/blob/master/LICENSE)
+
+<p align="center"><img src="https://expr-lang.org/img/gopher-small.png" width="150" /></p>

From 07f130d0384204fb1d1214e0e33b02bc805b5dd8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 23 Dec 2023 10:35:16 +0100
Subject: [PATCH 211/506] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 7c08fc672..f68b786cd 100644
--- a/README.md
+++ b/README.md
@@ -71,7 +71,7 @@ go get github.com/expr-lang/expr
 
 ## Examples
 
-[Play Online](https://play.golang.org/p/z7T8ytJ1T1d)
+[Play Online](https://go.dev/play/p/XCoNXEjm3TS)
 
 ```go
 package main
@@ -104,7 +104,7 @@ func main() {
 }
 ```
 
-[Play Online](https://play.golang.org/p/4S4brsIvU4i)
+[Play Online](https://go.dev/play/p/tz-ZneBfSuw)
 
 ```go
 package main

From 8cb1a4c3250acb48f26c876dbe6ca370d00d8c86 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 23 Dec 2023 10:49:02 +0100
Subject: [PATCH 212/506] Use lowercase filenames in docs

---
 docs/{Internals.md => internals.md} | 0
 docs/{Tips.md => tips.md}           | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename docs/{Internals.md => internals.md} (100%)
 rename docs/{Tips.md => tips.md} (100%)

diff --git a/docs/Internals.md b/docs/internals.md
similarity index 100%
rename from docs/Internals.md
rename to docs/internals.md
diff --git a/docs/Tips.md b/docs/tips.md
similarity index 100%
rename from docs/Tips.md
rename to docs/tips.md

From 18c44ea59cd1c480829ddc6e2a9befd83b3fec77 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 25 Dec 2023 09:19:44 +0100
Subject: [PATCH 213/506] Rename md docs to lowercase

---
 docs/{Configuration.md => configuration.md}               | 4 ++--
 docs/{Getting-Started.md => getting-started.md}           | 2 +-
 docs/{Language-Definition.md => language-definition.md}   | 0
 docs/{Operator-Overloading.md => operator-overloading.md} | 0
 docs/{Visitor-and-Patch.md => visitor-and-patch.md}       | 0
 5 files changed, 3 insertions(+), 3 deletions(-)
 rename docs/{Configuration.md => configuration.md} (95%)
 rename docs/{Getting-Started.md => getting-started.md} (99%)
 rename docs/{Language-Definition.md => language-definition.md} (100%)
 rename docs/{Operator-Overloading.md => operator-overloading.md} (100%)
 rename docs/{Visitor-and-Patch.md => visitor-and-patch.md} (100%)

diff --git a/docs/Configuration.md b/docs/configuration.md
similarity index 95%
rename from docs/Configuration.md
rename to docs/configuration.md
index 0e8e56c2e..5693ce7f0 100644
--- a/docs/Configuration.md
+++ b/docs/configuration.md
@@ -145,7 +145,7 @@ Here is another example with a few function signatures:
 
 ## Operator()
 
-This options defines an [operator overloading](Operator-Overloading.md).
+This options defines an [operator overloading](operator-overloading).
 
 ## Optimize()
 
@@ -153,4 +153,4 @@ This option enables [optimizations](Internals.md). By default, Expr will optimiz
 
 ## Patch()
 
-This option allows you to [patch the expression](Visitor-and-Patch.md) before compilation.
+This option allows you to [patch the expression](visitor-and-patch) before compilation.
diff --git a/docs/Getting-Started.md b/docs/getting-started.md
similarity index 99%
rename from docs/Getting-Started.md
rename to docs/getting-started.md
index 87653946a..b6b0e4da9 100644
--- a/docs/Getting-Started.md
+++ b/docs/getting-started.md
@@ -73,7 +73,7 @@ if err != nil {
 Expr can work with any Go types. Here is an example:
 
 ```go
-env := map[string]interface{}{
+env := map[string]any{
 	"greet":   "Hello, %v!",
 	"names":   []string{"world", "you"},
 	"sprintf": fmt.Sprintf,
diff --git a/docs/Language-Definition.md b/docs/language-definition.md
similarity index 100%
rename from docs/Language-Definition.md
rename to docs/language-definition.md
diff --git a/docs/Operator-Overloading.md b/docs/operator-overloading.md
similarity index 100%
rename from docs/Operator-Overloading.md
rename to docs/operator-overloading.md
diff --git a/docs/Visitor-and-Patch.md b/docs/visitor-and-patch.md
similarity index 100%
rename from docs/Visitor-and-Patch.md
rename to docs/visitor-and-patch.md

From 529ee7a003c2d1020b8aedc96e230ad375465de3 Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Mon, 25 Dec 2023 22:35:25 +0530
Subject: [PATCH 214/506] Incorporate support for raw string literals (#485)

---
 parser/lexer/lexer.go      | 14 ++++++++++++++
 parser/lexer/lexer_test.go | 13 +++++++++++++
 parser/lexer/state.go      |  2 ++
 parser/parser_test.go      |  5 +++++
 4 files changed, 34 insertions(+)

diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go
index d17e19932..c32658637 100644
--- a/parser/lexer/lexer.go
+++ b/parser/lexer/lexer.go
@@ -219,3 +219,17 @@ func (l *lexer) scanString(quote rune) (n int) {
 	}
 	return
 }
+
+func (l *lexer) scanRawString(quote rune) (n int) {
+	ch := l.next() // read character after back tick
+	for ch != quote {
+		if ch == eof {
+			l.error("literal not terminated")
+			return
+		}
+		ch = l.next()
+		n++
+	}
+	l.emitValue(String, l.input[l.start+1:l.end-1])
+	return
+}
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index d4bed139e..feecf045d 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -49,6 +49,19 @@ func TestLex(t *testing.T) {
 				{Kind: EOF},
 			},
 		},
+		{
+			"`backtick` `hello\u263Aworld` `hello\n\tworld` `hello\"world'`  `\xC3\xBF\u263A\U000003A8` `❤️`",
+			[]Token{
+				{Kind: String, Value: `backtick`},
+				{Kind: String, Value: `hello☺world`},
+				{Kind: String, Value: `hello
+	world`},
+				{Kind: String, Value: `hello"world'`},
+				{Kind: String, Value: `ÿ☺Ψ`},
+				{Kind: String, Value: "❤️"},
+				{Kind: EOF},
+			},
+		},
 		{
 			"a and orb().val #.",
 			[]Token{
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index 5d82329eb..9999fd3c5 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -23,6 +23,8 @@ func root(l *lexer) stateFn {
 			l.error("%v", err)
 		}
 		l.emitValue(String, str)
+	case r == '`':
+		l.scanRawString(r)
 	case '0' <= r && r <= '9':
 		l.backup()
 		return number
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 2af7635ed..fbeb24696 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -24,6 +24,11 @@ func TestParse(t *testing.T) {
 			`"str"`,
 			&StringNode{Value: "str"},
 		},
+		{
+			"`hello\nworld`",
+			&StringNode{Value: `hello
+world`},
+		},
 		{
 			"3",
 			&IntegerNode{Value: 3},

From 9b95d249013334adaabec5a121f1eada2e4cc53f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 25 Dec 2023 18:24:05 +0100
Subject: [PATCH 215/506] Rename back

---
 docs/{language-definition.md => Language-Definition.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename docs/{language-definition.md => Language-Definition.md} (100%)

diff --git a/docs/language-definition.md b/docs/Language-Definition.md
similarity index 100%
rename from docs/language-definition.md
rename to docs/Language-Definition.md

From 9b8d74166566e64506144ff27f832170308728d5 Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Mon, 25 Dec 2023 22:55:26 +0530
Subject: [PATCH 216/506] feat: Implement Bitwise and Shift Operator Support
 (#496)

Co-authored-by: Ganesan Karuppasamy <ganesan.karuppasamy@sap.com>
---
 builtin/builtin.go          | 44 ++++++++++++++++++++++++
 builtin/builtin_test.go     | 35 +++++++++++++++++++
 builtin/func.go             | 22 ++++++++++++
 builtin/utils.go            | 27 +++++++++++++++
 compiler/compiler_test.go   |  5 +--
 docs/Language-Definition.md | 68 +++++++++++++++++++++++++++++++++++++
 expr_test.go                | 32 +++++++++++++++++
 parser/parser_test.go       |  5 +--
 vm/runtime/generated.go     |  2 +-
 9 files changed, 235 insertions(+), 5 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 8576160a6..d76cc9d06 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -972,4 +972,48 @@ var Builtins = []*ast.Function{
 			return arrayType, nil
 		},
 	},
+	bitFunc("bitand", func(x, y int) (any, error) {
+		return x & y, nil
+	}),
+	bitFunc("bitor", func(x, y int) (any, error) {
+		return x | y, nil
+	}),
+	bitFunc("bitxor", func(x, y int) (any, error) {
+		return x ^ y, nil
+	}),
+	bitFunc("bitnand", func(x, y int) (any, error) {
+		return x &^ y, nil
+	}),
+	bitFunc("bitshl", func(x, y int) (any, error) {
+		if y < 0 {
+			return nil, fmt.Errorf("invalid operation: negative shift count %d (type int)", y)
+		}
+		return x << y, nil
+	}),
+	bitFunc("bitshr", func(x, y int) (any, error) {
+		if y < 0 {
+			return nil, fmt.Errorf("invalid operation: negative shift count %d (type int)", y)
+		}
+		return x >> y, nil
+	}),
+	bitFunc("bitushr", func(x, y int) (any, error) {
+		if y < 0 {
+			return nil, fmt.Errorf("invalid operation: negative shift count %d (type int)", y)
+		}
+		return int(uint(x) >> y), nil
+	}),
+	{
+		Name: "bitnot",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments for bitnot (expected 1, got %d)", len(args))
+			}
+			x, err := toInt(args[0])
+			if err != nil {
+				return nil, fmt.Errorf("%v to call bitnot", err)
+			}
+			return ^x, nil
+		},
+		Types: types(new(func(int) int)),
+	},
 }
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 40f6e32ee..a861d0faa 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -199,6 +199,13 @@ func TestBuiltin_errors(t *testing.T) {
 		{`date("error")`, `invalid date`},
 		{`get()`, `invalid number of arguments (expected 2, got 0)`},
 		{`get(1, 2)`, `type int does not support indexing`},
+		{`bitnot("1")`, "cannot use string as argument (type int) to call bitnot  (1:8)"},
+		{`bitand("1", 1)`, "cannot use string as argument (type int) to call bitand  (1:8)"},
+		{`"10" | bitor(1)`, "cannot use string as argument (type int) to call bitor  (1:1)"},
+		{`bitshr("5", 1)`, "cannot use string as argument (type int) to call bitshr  (1:8)"},
+		{`bitshr(-5, -2)`, "invalid operation: negative shift count -2 (type int) (1:1)"},
+		{`bitshl(1, -1)`, "invalid operation: negative shift count -1 (type int) (1:1)"},
+		{`bitushr(-5, -2)`, "invalid operation: negative shift count -2 (type int) (1:1)"},
 	}
 	for _, test := range errorTests {
 		t.Run(test.input, func(t *testing.T) {
@@ -437,3 +444,31 @@ func TestBuiltin_sort(t *testing.T) {
 		})
 	}
 }
+
+func TestBuiltin_bitOpsFunc(t *testing.T) {
+	tests := []struct {
+		input string
+		want  int
+	}{
+		{`bitnot(156)`, -157},
+		{`bitand(bitnot(156), 255)`, 99},
+		{`bitor(987, -123)`, -33},
+		{`bitxor(15, 32)`, 47},
+		{`bitshl(39, 3)`, 312},
+		{`bitshr(5, 1)`, 2},
+		{`bitushr(-5, 2)`, 4611686018427387902},
+		{`bitnand(35, 9)`, 34},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			program, err := expr.Compile(test.input, expr.Env(nil))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, nil)
+			fmt.Printf("%v : %v", test.input, out)
+			require.NoError(t, err)
+			assert.Equal(t, test.want, out)
+		})
+	}
+}
diff --git a/builtin/func.go b/builtin/func.go
index 9bcd7827b..1c2546a2d 100644
--- a/builtin/func.go
+++ b/builtin/func.go
@@ -6,6 +6,7 @@ import (
 	"reflect"
 	"strconv"
 
+	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
@@ -272,3 +273,24 @@ func Min(args ...any) (any, error) {
 	}
 	return min, nil
 }
+
+func bitFunc(name string, fn func(x, y int) (any, error)) *ast.Function {
+	return &ast.Function{
+		Name: name,
+		Func: func(args ...any) (any, error) {
+			if len(args) != 2 {
+				return nil, fmt.Errorf("invalid number of arguments for %s (expected 2, got %d)", name, len(args))
+			}
+			x, err := toInt(args[0])
+			if err != nil {
+				return nil, fmt.Errorf("%v to call %s", err, name)
+			}
+			y, err := toInt(args[1])
+			if err != nil {
+				return nil, fmt.Errorf("%v to call %s", err, name)
+			}
+			return fn(x, y)
+		},
+		Types: types(new(func(int, int) int)),
+	}
+}
diff --git a/builtin/utils.go b/builtin/utils.go
index eff8fdcd1..f831e95b6 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -63,3 +63,30 @@ loop:
 
 	panic(fmt.Sprintf("cannot deref %s", v))
 }
+
+func toInt(val any) (int, error) {
+	switch v := val.(type) {
+	case int:
+		return v, nil
+	case int8:
+		return int(v), nil
+	case int16:
+		return int(v), nil
+	case int32:
+		return int(v), nil
+	case int64:
+		return int(v), nil
+	case uint:
+		return int(v), nil
+	case uint8:
+		return int(v), nil
+	case uint16:
+		return int(v), nil
+	case uint32:
+		return int(v), nil
+	case uint64:
+		return int(v), nil
+	default:
+		return 0, fmt.Errorf("cannot use %T as argument (type int)", val)
+	}
+}
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index 083fc688e..c3b460aa0 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -4,12 +4,13 @@ import (
 	"math"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/test/playground"
 	"github.com/expr-lang/expr/vm"
 	"github.com/expr-lang/expr/vm/runtime"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 type B struct {
diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 46bad9322..5ba643587 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -696,6 +696,74 @@ Converts an array of key-value pairs to a map.
 fromPairs([["name", "John"], ["age", 30]]) == {"name": "John", "age": 30}
 ```
 
+## Bitwise Functions
+
+### bitand(int, int)
+
+Returns the values resulting from the bitwise AND operation.
+
+```expr
+bitand(10, 12) == 8
+```
+
+### bitor(int, int)
+
+Returns the values resulting from the bitwise OR operation.
+
+```expr
+bitor(10, 12) == 14
+```
+
+### bitxor(int, int)
+
+Returns the values resulting from the bitwise XOR operation.
+
+```expr
+bitxor(10, 12) == 6
+```
+
+### bitnand(int, int)
+
+Returns the values resulting from the bitwise AND NOT operation.
+
+```expr
+bitnand(10, 12) == 2
+```
+
+### bitnot(int)
+
+Returns the values resulting from the bitwise NOT operation.
+
+```expr
+bitnot(10) == -11
+```
+
+## Shift Functions
+
+### bitshl(int, int)
+
+Returns the values resulting from the Left Shift operation.
+
+```expr
+bitshl(45, 2) == 180
+```
+
+### bitshr(int, int)
+
+Returns the values resulting from the Right Shift operation.
+
+```expr
+bitshr(45, 2) == 11
+```
+
+### bitushr(int, int)
+
+Returns the values resulting from the unsigned Right Shift operation.
+
+```expr
+bitushr(-5, 2) == 4611686018427387902
+```
+
 ## Miscellaneous Functions
 
 ### len(v)
diff --git a/expr_test.go b/expr_test.go
index 4992ca2c3..9d588f122 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1136,6 +1136,38 @@ func TestExpr(t *testing.T) {
 			`.5 in ArrayOfInt`,
 			false,
 		},
+		{
+			`bitnot(10)`,
+			-11,
+		},
+		{
+			`bitxor(15, 32)`,
+			47,
+		},
+		{
+			`bitand(90, 34)`,
+			2,
+		},
+		{
+			`bitnand(35, 9)`,
+			34,
+		},
+		{
+			`bitor(10, 5)`,
+			15,
+		},
+		{
+			`bitshr(7, 2)`,
+			1,
+		},
+		{
+			`bitshl(7, 2)`,
+			28,
+		},
+		{
+			`bitushr(-100, 5)`,
+			576460752303423484,
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index fbeb24696..ba8e29acc 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -5,10 +5,11 @@ import (
 	"strings"
 	"testing"
 
-	. "github.com/expr-lang/expr/ast"
-	"github.com/expr-lang/expr/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/parser"
 )
 
 func TestParse(t *testing.T) {
diff --git a/vm/runtime/generated.go b/vm/runtime/generated.go
index 720feb455..a5b92f477 100644
--- a/vm/runtime/generated.go
+++ b/vm/runtime/generated.go
@@ -3372,4 +3372,4 @@ func Modulo(a, b interface{}) int {
 		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T %% %T", a, b))
-}
+}
\ No newline at end of file

From 6fa487b3aaa970b1f3ed89f36184c7873a5d436d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 25 Dec 2023 18:36:50 +0100
Subject: [PATCH 217/506] Update Language-Definition.md

---
 docs/Language-Definition.md | 344 ++++++++++++++++++++----------------
 1 file changed, 196 insertions(+), 148 deletions(-)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index 5ba643587..ba0dce1df 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -1,152 +1,167 @@
 # Language Definition
 
+**Expr** is a simple expression language that can be used to evaluate expressions.
+
 ## Literals
 
 <table>
     <tr>
-        <td>Comment</td>
+        <td><strong>Comment</strong></td>
         <td>
              <code>/* */</code> or <code>//</code>
         </td>
     </tr>
     <tr>
-        <td>Boolean</td>
+        <td><strong>Boolean</strong></td>
         <td>
             <code>true</code>, <code>false</code>
         </td>
     </tr>
     <tr>
-        <td>Integer</td>
+        <td><strong>Integer</strong></td>
         <td>
-            <code>42</code>, <code>0x2A</code>
+            <code>42</code>, <code>0x2A</code>, <code>0o52</code>, <code>0b101010</code>
         </td>
     </tr>
     <tr>
-        <td>Float</td>
+        <td><strong>Float</strong></td>
         <td>
             <code>0.5</code>, <code>.5</code>
         </td>
     </tr>
     <tr>
-        <td>String</td>
+        <td><strong>String</strong></td>
         <td>
             <code>"foo"</code>, <code>'bar'</code>
         </td>
     </tr>
     <tr>
-        <td>Array</td>
+        <td><strong>Array</strong></td>
         <td>
             <code>[1, 2, 3]</code>
         </td>
     </tr>
     <tr>
-        <td>Map</td>
+        <td><strong>Map</strong></td>
         <td>
             <code>&#123;a: 1, b: 2, c: 3&#125;</code>
         </td>
     </tr>
     <tr>
-        <td>Nil</td>
+        <td><strong>Nil</strong></td>
         <td>
             <code>nil</code>
         </td>
     </tr>
 </table>
 
+### Strings
+
+Strings can be enclosed in single quotes or double quotes. Strings can contain escape sequences, like `\n` for newline,
+`\t` for tab, `\uXXXX` for Unicode code points.
+
+```expr
+"Hello\nWorld"
+```
+
+For multiline strings, use backticks:
+
+```expr
+`Hello
+World`
+```
+
+Backticks strings are raw strings, they do not support escape sequences.
+
 ## Operators
 
 <table>
     <tr>
-        <td>Arithmetic</td>
+        <td><strong>Arithmetic</strong></td>
         <td>
             <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>%</code> (modulus), <code>^</code> or <code>**</code> (exponent)
         </td>
     </tr>
     <tr>
-        <td>Comparison</td>
+        <td><strong>Comparison</strong></td>
         <td>
             <code>==</code>, <code>!=</code>, <code>&lt;</code>, <code>&gt;</code>, <code>&lt;=</code>, <code>&gt;=</code>
         </td>
     </tr>
     <tr>
-        <td>Logical</td>
+        <td><strong>Logical</strong></td>
         <td>
             <code>not</code> or <code>!</code>, <code>and</code> or <code>&amp;&amp;</code>, <code>or</code> or <code>||</code>
         </td>
     </tr>
     <tr>
-        <td>Conditional</td>
+        <td><strong>Conditional</strong></td>
         <td>
             <code>?:</code> (ternary), <code>??</code> (nil coalescing)
         </td>
     </tr>
     <tr>
-        <td>Membership</td>
+        <td><strong>Membership</strong></td>
         <td>
             <code>[]</code>, <code>.</code>, <code>?.</code>, <code>in</code>
         </td>
     </tr>
     <tr>
-        <td>String</td>
+        <td><strong>String</strong></td>
         <td>
             <code>+</code> (concatenation), <code>contains</code>, <code>startsWith</code>, <code>endsWith</code>
         </td>
     </tr>
     <tr>
-        <td>Regex</td>
+        <td><strong>Regex</strong></td>
         <td>
             <code>matches</code>
         </td>
     </tr>
     <tr>
-        <td>Range</td>
+        <td><strong>Range</strong></td>
         <td>
             <code>..</code>
         </td>
     </tr>
     <tr>
-        <td>Slice</td>
+        <td><strong>Slice</strong></td>
         <td>
             <code>[:]</code>
         </td>
     </tr>
     <tr>
-        <td>Pipe</td>
+        <td><strong>Pipe</strong></td>
         <td>
             <code>|</code>
         </td>
     </tr>
 </table>
 
-Examples:
+### Membership Operator
 
-```expr
-user.Age in 18..45 and user.Name not in ["admin", "root"]
-```
+Fields of structs and items of maps can be accessed with `.` operator
+or `[]` operator. Next two expressions are equivalent:
 
 ```expr
-foo matches "^[A-Z].*"
-```
+user.Name
+user["Name"]
+``` 
 
-```expr
-tweets | filter(.Size < 280) | map(.Content) | join(" -- ")
-```
+Elements of arrays and slices can be accessed with
+`[]` operator. Negative indices are supported with `-1` being
+the last element.
 
 ```expr
-filter(posts, {now() - .CreatedAt >= 7 * duration("24h")})
+array[0] // first element
+array[-1] // last element
 ```
 
-### Membership Operator
-
-Fields of structs and items of maps can be accessed with `.` operator
-or `[]` operator. Elements of arrays and slices can be accessed with
-`[]` operator. Negative indices are supported with `-1` being
-the last element.
-
 The `in` operator can be used to check if an item is in an array or a map.
 
 ```expr
-user.Name in list["available-names"]
+"John" in ["John", "Jane"]
+"name" in {"name": "John", "age": 30}
 ```
 
 #### Optional chaining
@@ -156,7 +171,13 @@ without checking if the struct or the map is `nil`. If the struct or the map is
 `nil`, the result of the expression is `nil`.
 
 ```expr
-author?.User?.Name
+author.User?.Name
+```
+
+Is equivalent to:
+
+```expr
+author.User != nil ? author.User.Name : nil
 ```
 
 #### Nil coalescing
@@ -165,14 +186,20 @@ The `??` operator can be used to return the left-hand side if it is not `nil`,
 otherwise the right-hand side is returned.
 
 ```expr
-author?.User?.Name ?? "Anonymous"
+author.User?.Name ?? "Anonymous"
+```
+
+Is equivalent to:
+
+```expr
+author.User != nil ? author.User.Name : "Anonymous"
 ```
 
 ### Slice Operator
 
 The slice operator `[:]` can be used to access a slice of an array.
 
-For example, variable `array` is `[1, 2, 3, 4, 5]`:
+For example, variable **array** is `[1, 2, 3, 4, 5]`:
 
 ```expr
 array[1:4] == [2, 3, 4]
@@ -187,12 +214,88 @@ array[:] == array
 The pipe operator `|` can be used to pass the result of the left-hand side
 expression as the first argument of the right-hand side expression.
 
-For example, expression `split(lower(user.Name), " ")` can be written as:
-
 ```expr
 user.Name | lower() | split(" ")
 ```
 
+Is equivalent to:
+
+```expr
+split(lower(user.Name), " ")
+```
+
+### Range Operator
+
+The range operator `..` can be used to create a range of integers.
+
+```expr
+1..3 == [1, 2, 3]
+```
+
+## Variables
+
+Variables can be declared with the `let` keyword. The variable name must start with a letter or an underscore.
+The variable name can contain letters, digits and underscores. After the variable is declared, it can be used in the
+expression.
+
+```expr
+let x = 42; x * 2
+```
+
+A few variables can be declared by a few `let` statements separated by a semicolon.
+
+```expr
+let x = 42; 
+let y = 2; 
+x * y
+```
+
+Here is an example of variable with pipe operator:
+
+```expr
+let name = user.Name | lower() | split(" "); 
+"Hello, " + name[0] + "!"
+```
+
+### $env
+
+The `$env` variable is a map of all variables passed to the expression.
+
+```expr
+foo.Name == $env["foo"].Name
+$env["var with spaces"]
+```
+
+Think of `$env` as a global variable that contains all variables.
+
+The `$env` can be used to check if a variable is defined:
+
+```expr
+'foo' in $env
+```
+
+## Predicate
+
+The predicate is an expression. Predicates can be used in functions like `filter`, `all`, `any`, `one`, `none`, etc.
+For example, next expression creates a new array from 0 to 9 and then filters it by even numbers:
+
+```expr
+filter(0..9, {# % 2 == 0})
+```
+
+If items of the array is a struct or a map, it is possible to access fields with
+omitted `#` symbol (`#.Value` becomes `.Value`).
+
+```expr
+filter(tweets, {len(.Content) > 240})
+```
+
+Braces `{` `}` can be omitted:
+
+```expr
+filter(tweets, len(.Content) > 240)
+```
+
 ## String Functions
 
 ### trim(str[, chars])
@@ -305,20 +408,31 @@ hasSuffix("HelloWorld", "World") == true
 
 ## Date Functions
 
-The following operators can be used to manipulate dates:
+Expr has a built-in support for Go's [time package](https://pkg.go.dev/time).
+It is possible to subtract two dates and get the duration between them:
+
+```expr
+createdAt - now()
+```
+
+It is possible to add a duration to a date:
+
+```expr
+createdAt + duration("1h")
+```
+
+And it is possible to compare dates:
 
 ```expr
-date("2023-08-14") + duration("1h")
-date("2023-08-14") - duration("1h")
-date("2023-08-14") - date("2023-08-13") == duration("24h")
+createdAt > now() - duration("1h")
 ```
 
 ### now()
 
-Returns the current date and time.
+Returns the current date as a [time.Time](https://pkg.go.dev/time#Time) value.
 
 ```expr
-createdAt > now() - duration(1h)
+now().Year() == 2024
 ```
 
 ### duration(str)
@@ -380,6 +494,10 @@ min(5, 7) == 5
 
 Returns the absolute value of a number.
 
+```expr
+abs(-5) == 5
+```
+
 ### ceil(n)
 
 Returns the least integer value greater than or equal to x.
@@ -420,6 +538,10 @@ all(tweets, {.Size < 280})
 Returns **true** if any elements satisfies the [predicate](#predicate).
 If the array is empty, returns **false**.
 
+```expr
+any(tweets, {.Size > 280})
+```
+
 ### one(array, predicate)
 
 Returns **true** if _exactly one_ element satisfies the [predicate](#predicate).
@@ -434,6 +556,10 @@ one(participants, {.Winner})
 Returns **true** if _all elements does not_ satisfy the [predicate](#predicate).
 If the array is empty, returns **true**.
 
+```expr
+none(tweets, {.Size > 280})
+```
+
 ### map(array, predicate)
 
 Returns new array by applying the [predicate](#predicate) to each element of
@@ -619,7 +745,18 @@ values({"name": "John", "age": 30}) == ["John", 30]
 ### type(v)
 
 Returns the type of the given value `v`.
-Returns on of the following types: `nil`, `bool`, `int`, `uint`, `float`, `string`, `array`, `map`.
+
+Returns on of the following types:
+
+- `nil`
+- `bool`
+- `int`
+- `uint`
+- `float`
+- `string`
+- `array`
+- `map`.
+
 For named types and structs, the type name is returned.
 
 ```expr
@@ -640,6 +777,10 @@ int("123") == 123
 
 Returns the float value of a number or a string.
 
+```expr
+float("123.45") == 123.45
+```
+
 ### string(v)
 
 Converts the given value `v` into a string representation.
@@ -696,80 +837,18 @@ Converts an array of key-value pairs to a map.
 fromPairs([["name", "John"], ["age", 30]]) == {"name": "John", "age": 30}
 ```
 
-## Bitwise Functions
-
-### bitand(int, int)
-
-Returns the values resulting from the bitwise AND operation.
-
-```expr
-bitand(10, 12) == 8
-```
-
-### bitor(int, int)
-
-Returns the values resulting from the bitwise OR operation.
-
-```expr
-bitor(10, 12) == 14
-```
-
-### bitxor(int, int)
-
-Returns the values resulting from the bitwise XOR operation.
-
-```expr
-bitxor(10, 12) == 6
-```
-
-### bitnand(int, int)
-
-Returns the values resulting from the bitwise AND NOT operation.
-
-```expr
-bitnand(10, 12) == 2
-```
-
-### bitnot(int)
-
-Returns the values resulting from the bitwise NOT operation.
-
-```expr
-bitnot(10) == -11
-```
-
-## Shift Functions
-
-### bitshl(int, int)
-
-Returns the values resulting from the Left Shift operation.
-
-```expr
-bitshl(45, 2) == 180
-```
-
-### bitshr(int, int)
-
-Returns the values resulting from the Right Shift operation.
-
-```expr
-bitshr(45, 2) == 11
-```
-
-### bitushr(int, int)
-
-Returns the values resulting from the unsigned Right Shift operation.
-
-```expr
-bitushr(-5, 2) == 4611686018427387902
-```
-
 ## Miscellaneous Functions
 
 ### len(v)
 
 Returns the length of an array, a map or a string.
 
+```expr
+len([1, 2, 3]) == 3
+len({"name": "John", "age": 30}) == 2
+len("Hello") == 5
+```
+
 ### get(v, index)
 
 Retrieves the element at the specified index from an array or map `v`. If the index is out of range, returns `nil`.
@@ -779,34 +858,3 @@ Or the key does not exist, returns `nil`.
 get([1, 2, 3], 1) == 2
 get({"name": "John", "age": 30}, "name") == "John"
 ```
-
-## Predicate
-
-The predicate is an expression. It takes one or more arguments and returns a boolean value.
-To access the arguments, the `#` symbol is used.
-
-```expr
-map(0..9, {# / 2})
-```
-
-If items of the array is a struct or a map, it is possible to access fields with
-omitted `#` symbol (`#.Value` becomes `.Value`).
-
-```expr
-filter(tweets, {len(.Value) > 280})
-```
-
-Braces `{` `}` can be omitted:
-
-```expr
-filter(tweets, len(.Value) > 280)
-```
-
-## `$env` variable
-
-The `$env` variable is a map of all variables passed to the expression.
-
-```expr
-foo.Name == $env["foo"].Name
-$env["var with spaces"]
-```

From 5eec5b82c1cb7fa8d49f3c36894a891c86475ae9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 25 Dec 2023 18:55:37 +0100
Subject: [PATCH 218/506] Add bitwise

---
 docs/Language-Definition.md | 66 +++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/docs/Language-Definition.md b/docs/Language-Definition.md
index ba0dce1df..eae8c1782 100644
--- a/docs/Language-Definition.md
+++ b/docs/Language-Definition.md
@@ -858,3 +858,69 @@ Or the key does not exist, returns `nil`.
 get([1, 2, 3], 1) == 2
 get({"name": "John", "age": 30}, "name") == "John"
 ```
+
+## Bitwise Functions
+
+### bitand(int, int)
+
+Returns the values resulting from the bitwise AND operation.
+
+```expr
+bitand(10, 12) == 8
+```
+
+### bitor(int, int)
+
+Returns the values resulting from the bitwise OR operation.
+
+```expr
+bitor(10, 12) == 14
+```
+
+### bitxor(int, int)
+
+Returns the values resulting from the bitwise XOR operation.
+
+```expr
+bitxor(10, 12) == 6
+```
+
+### bitnand(int, int)
+
+Returns the values resulting from the bitwise AND NOT operation.
+
+```expr
+bitnand(10, 12) == 2
+```
+
+### bitnot(int)
+
+Returns the values resulting from the bitwise NOT operation.
+
+```expr
+bitnot(10) == -11
+```
+
+### bitshl(int, int)
+
+Returns the values resulting from the Left Shift operation.
+
+```expr
+bitshl(45, 2) == 180
+```
+
+### bitshr(int, int)
+
+Returns the values resulting from the Right Shift operation.
+
+```expr
+bitshr(45, 2) == 11
+```
+
+### bitushr(int, int)
+
+Returns the values resulting from the unsigned Right Shift operation.
+
+```expr
+bitushr(-5, 2) == 4611686018427387902
+```

From 48df1fd3f5ae570cc0eb1853d8587026dd6bcb0f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 25 Dec 2023 18:56:06 +0100
Subject: [PATCH 219/506] Rename language-definition.md

---
 docs/{Language-Definition.md => language-definition.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename docs/{Language-Definition.md => language-definition.md} (100%)

diff --git a/docs/Language-Definition.md b/docs/language-definition.md
similarity index 100%
rename from docs/Language-Definition.md
rename to docs/language-definition.md

From 686742c4034f7ae9ea6c058df05c28dfb0e163ca Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 26 Dec 2023 09:09:19 +0100
Subject: [PATCH 220/506] Update bit* examples to use 0bxxxx integers

---
 docs/language-definition.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/docs/language-definition.md b/docs/language-definition.md
index eae8c1782..d205edc6e 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -866,7 +866,7 @@ get({"name": "John", "age": 30}, "name") == "John"
 Returns the values resulting from the bitwise AND operation.
 
 ```expr
-bitand(10, 12) == 8
+bitand(0b1010, 0b1100) == 0b1000
 ```
 
 ### bitor(int, int)
@@ -874,7 +874,7 @@ bitand(10, 12) == 8
 Returns the values resulting from the bitwise OR operation.
 
 ```expr
-bitor(10, 12) == 14
+bitor(0b1010, 0b1100) == 0b1110
 ```
 
 ### bitxor(int, int)
@@ -882,7 +882,7 @@ bitor(10, 12) == 14
 Returns the values resulting from the bitwise XOR operation.
 
 ```expr
-bitxor(10, 12) == 6
+bitxor(0b1010, 0b1100) == 0b110
 ```
 
 ### bitnand(int, int)
@@ -890,7 +890,7 @@ bitxor(10, 12) == 6
 Returns the values resulting from the bitwise AND NOT operation.
 
 ```expr
-bitnand(10, 12) == 2
+bitnand(0b1010, 0b1100) == 0b10
 ```
 
 ### bitnot(int)
@@ -898,7 +898,7 @@ bitnand(10, 12) == 2
 Returns the values resulting from the bitwise NOT operation.
 
 ```expr
-bitnot(10) == -11
+bitnot(0b1010) == -0b1011
 ```
 
 ### bitshl(int, int)
@@ -906,7 +906,7 @@ bitnot(10) == -11
 Returns the values resulting from the Left Shift operation.
 
 ```expr
-bitshl(45, 2) == 180
+bitshl(0b101101, 2) == 0b10110100
 ```
 
 ### bitshr(int, int)
@@ -914,7 +914,7 @@ bitshl(45, 2) == 180
 Returns the values resulting from the Right Shift operation.
 
 ```expr
-bitshr(45, 2) == 11
+bitshr(0b101101, 2) == 0b1011
 ```
 
 ### bitushr(int, int)
@@ -922,5 +922,5 @@ bitshr(45, 2) == 11
 Returns the values resulting from the unsigned Right Shift operation.
 
 ```expr
-bitushr(-5, 2) == 4611686018427387902
+bitushr(-0b101, 2) == 4611686018427387902
 ```

From c46996e54d93d1bd075899d52c141a648b99d0c4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 26 Dec 2023 09:13:43 +0100
Subject: [PATCH 221/506] Update docs

---
 docs/configuration.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/configuration.md b/docs/configuration.md
index 5693ce7f0..a427515e9 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -149,7 +149,7 @@ This options defines an [operator overloading](operator-overloading).
 
 ## Optimize()
 
-This option enables [optimizations](Internals.md). By default, Expr will optimize the expression.
+This option enables [optimizations](internals.md). By default, Expr will optimize the expression.
 
 ## Patch()
 

From 8774c44ef60676534d6865068dd7d29092af336f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 26 Dec 2023 09:15:10 +0100
Subject: [PATCH 222/506] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index f68b786cd..b393d9380 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@
 [![GoDoc](https://godoc.org/github.com/expr-lang/expr?status.svg)](https://godoc.org/github.com/expr-lang/expr)
 
 **Expr** is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed. 
-**Expr** combines simple [syntax](https://expr-lang.org/docs/Language-Definition) with powerful features for ease of use:
+**Expr** combines simple [syntax](https://expr-lang.org/docs/language-definition) with powerful features for ease of use:
 
 ```js
 // Allow only admins and moderators to moderate comments.
@@ -67,7 +67,7 @@ go get github.com/expr-lang/expr
 ## Documentation
 
 * See [Getting Started](https://expr-lang.org/docs/Getting-Started) page for developer documentation.
-* See [Language Definition](https://expr-lang.org/docs/Language-Definition) page to learn the syntax.
+* See [Language Definition](https://expr-lang.org/docs/language-definition) page to learn the syntax.
 
 ## Examples
 

From 500553e0dfefa516d25ae9a36cbfbe324a928f29 Mon Sep 17 00:00:00 2001
From: Ryan Bullock <rrb3942@gmail.com>
Date: Tue, 26 Dec 2023 07:01:55 -0800
Subject: [PATCH 223/506] Patcher and interfaces for custom types to be used in
 expressions as standard go types (#487)

* A bultin patcher providing interfaces for custom types that can be represented as standard go types for expressions.

* Move node creation inside of loop.

* Reorder imports. Fix some formatting.

* Rename expr function from 'getExprValue' to '$patcher_value_getter'.

* Move to expr-lang

* Rename Patcher to ValueGetter

* Remove use of Expr in naming

* Rename interface functions to use 'AsType()' convention

* Document motivation and an example use case

* Add example usage to AsAny()

* Move under patcher directory

* Fix reference to old import path
---
 patcher/value/bench_test.go         |  73 +++++++++
 patcher/value/value.go              | 227 ++++++++++++++++++++++++++++
 patcher/value/value_example_test.go |  42 +++++
 patcher/value/value_test.go         | 172 +++++++++++++++++++++
 4 files changed, 514 insertions(+)
 create mode 100644 patcher/value/bench_test.go
 create mode 100644 patcher/value/value.go
 create mode 100644 patcher/value/value_example_test.go
 create mode 100644 patcher/value/value_test.go

diff --git a/patcher/value/bench_test.go b/patcher/value/bench_test.go
new file mode 100644
index 000000000..d6a1aae89
--- /dev/null
+++ b/patcher/value/bench_test.go
@@ -0,0 +1,73 @@
+package value
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
+)
+
+func Benchmark_valueAdd(b *testing.B) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customInt{1}
+	env["ValueTwo"] = &customInt{2}
+
+	program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter)
+	require.NoError(b, err)
+
+	var out any
+	v := vm.VM{}
+
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = v.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.Equal(b, 3, out.(int))
+}
+
+func Benchmark_valueUntypedAdd(b *testing.B) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customUntypedInt{1}
+	env["ValueTwo"] = &customUntypedInt{2}
+
+	program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter)
+	require.NoError(b, err)
+
+	var out any
+	v := vm.VM{}
+
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = v.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.Equal(b, 3, out.(int))
+}
+
+func Benchmark_valueTypedAdd(b *testing.B) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customTypedInt{1}
+	env["ValueTwo"] = &customTypedInt{2}
+
+	program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter)
+	require.NoError(b, err)
+
+	var out any
+	v := vm.VM{}
+
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = v.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.Equal(b, 3, out.(int))
+}
diff --git a/patcher/value/value.go b/patcher/value/value.go
new file mode 100644
index 000000000..b7e4a767c
--- /dev/null
+++ b/patcher/value/value.go
@@ -0,0 +1,227 @@
+// Package value provides a Patcher that uses interfaces to allow custom types that can be represented as standard go values to be used more easily in expressions.
+package value
+
+import (
+	"reflect"
+	"time"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/conf"
+)
+
+// ValueGetter is a Patcher that allows custom types to be represented as standard go values for use with expr.
+// It also adds the `$patcher_value_getter` function to the program for efficiently calling matching interfaces.
+//
+// The purpose of this Patcher is to make it seemless to use custom types in expressions without the need to
+// first convert them to standard go values. It may also facilitate using already existing structs or maps as
+// environments when they contain compatabile types.
+//
+// An example usage may be modeling a database record with columns that have varying data types and constraints.
+// In such an example you may have custom types that, beyond storing a simple value, such as an integer, may
+// contain metadata such as column type and if a value is specifically a NULL value.
+//
+// Use it directly as an Option to expr.Compile()
+var ValueGetter = func() expr.Option {
+	vPatcher := patcher{}
+	return func(c *conf.Config) {
+		c.Visitors = append(c.Visitors, vPatcher)
+		vPatcher.ApplyOptions(c)
+	}
+}()
+
+// A AnyValuer provides a generic function for a custom type to return standard go values.
+// It allows for returning a `nil` value but does not provide any type checking at expression compile.
+//
+// A custom type may implement both AnyValuer and a type specific interface to enable both
+// compile time checking and the ability to return a `nil` value.
+type AnyValuer interface {
+	AsAny() any
+}
+
+type IntValuer interface {
+	AsInt() int
+}
+
+type BoolValuer interface {
+	AsBool() bool
+}
+
+type Int8Valuer interface {
+	AsInt8() int8
+}
+
+type Int16Valuer interface {
+	AsInt16() int16
+}
+
+type Int32Valuer interface {
+	AsInt32() int32
+}
+
+type Int64Valuer interface {
+	AsInt64() int64
+}
+
+type UintValuer interface {
+	AsUint() uint
+}
+
+type Uint8Valuer interface {
+	AsUint8() uint8
+}
+
+type Uint16Valuer interface {
+	AsUint16() uint16
+}
+
+type Uint32Valuer interface {
+	AsUint32() uint32
+}
+
+type Uint64Valuer interface {
+	AsUint64() uint64
+}
+
+type Float32Valuer interface {
+	AsFloat32() float32
+}
+
+type Float64Valuer interface {
+	AsFloat64() float64
+}
+
+type StringValuer interface {
+	AsString() string
+}
+
+type TimeValuer interface {
+	AsTime() time.Time
+}
+
+type DurationValuer interface {
+	AsDuration() time.Duration
+}
+
+type ArrayValuer interface {
+	AsArray() []any
+}
+
+type MapValuer interface {
+	AsMap() map[string]any
+}
+
+var supportedInterfaces = []reflect.Type{
+	reflect.TypeOf((*AnyValuer)(nil)).Elem(),
+	reflect.TypeOf((*BoolValuer)(nil)).Elem(),
+	reflect.TypeOf((*IntValuer)(nil)).Elem(),
+	reflect.TypeOf((*Int8Valuer)(nil)).Elem(),
+	reflect.TypeOf((*Int16Valuer)(nil)).Elem(),
+	reflect.TypeOf((*Int32Valuer)(nil)).Elem(),
+	reflect.TypeOf((*Int64Valuer)(nil)).Elem(),
+	reflect.TypeOf((*UintValuer)(nil)).Elem(),
+	reflect.TypeOf((*Uint8Valuer)(nil)).Elem(),
+	reflect.TypeOf((*Uint16Valuer)(nil)).Elem(),
+	reflect.TypeOf((*Uint32Valuer)(nil)).Elem(),
+	reflect.TypeOf((*Uint64Valuer)(nil)).Elem(),
+	reflect.TypeOf((*Float32Valuer)(nil)).Elem(),
+	reflect.TypeOf((*Float64Valuer)(nil)).Elem(),
+	reflect.TypeOf((*StringValuer)(nil)).Elem(),
+	reflect.TypeOf((*TimeValuer)(nil)).Elem(),
+	reflect.TypeOf((*DurationValuer)(nil)).Elem(),
+	reflect.TypeOf((*ArrayValuer)(nil)).Elem(),
+	reflect.TypeOf((*MapValuer)(nil)).Elem(),
+}
+
+type patcher struct{}
+
+func (patcher) Visit(node *ast.Node) {
+	id, ok := (*node).(*ast.IdentifierNode)
+	if !ok {
+		return
+	}
+
+	nodeType := id.Type()
+
+	for _, t := range supportedInterfaces {
+		if nodeType.Implements(t) {
+			callnode := &ast.CallNode{
+				Callee:    &ast.IdentifierNode{Value: "$patcher_value_getter"},
+				Arguments: []ast.Node{id},
+			}
+
+			ast.Patch(node, callnode)
+		}
+	}
+}
+
+func (patcher) ApplyOptions(c *conf.Config) {
+	getValueFunc(c)
+}
+
+func getValue(params ...any) (any, error) {
+	switch v := params[0].(type) {
+	case AnyValuer:
+		return v.AsAny(), nil
+	case BoolValuer:
+		return v.AsBool(), nil
+	case IntValuer:
+		return v.AsInt(), nil
+	case Int8Valuer:
+		return v.AsInt8(), nil
+	case Int16Valuer:
+		return v.AsInt16(), nil
+	case Int32Valuer:
+		return v.AsInt32(), nil
+	case Int64Valuer:
+		return v.AsInt64(), nil
+	case UintValuer:
+		return v.AsUint(), nil
+	case Uint8Valuer:
+		return v.AsUint8(), nil
+	case Uint16Valuer:
+		return v.AsUint16(), nil
+	case Uint32Valuer:
+		return v.AsUint32(), nil
+	case Uint64Valuer:
+		return v.AsUint64(), nil
+	case Float32Valuer:
+		return v.AsFloat32(), nil
+	case Float64Valuer:
+		return v.AsFloat64(), nil
+	case StringValuer:
+		return v.AsString(), nil
+	case TimeValuer:
+		return v.AsTime(), nil
+	case DurationValuer:
+		return v.AsDuration(), nil
+	case ArrayValuer:
+		return v.AsArray(), nil
+	case MapValuer:
+		return v.AsMap(), nil
+	}
+
+	return params[0], nil
+}
+
+var getValueFunc = expr.Function("$patcher_value_getter", getValue,
+	new(func(BoolValuer) bool),
+	new(func(IntValuer) int),
+	new(func(Int8Valuer) int8),
+	new(func(Int16Valuer) int16),
+	new(func(Int32Valuer) int32),
+	new(func(Int64Valuer) int64),
+	new(func(UintValuer) uint),
+	new(func(Uint8Valuer) uint8),
+	new(func(Uint16Valuer) uint16),
+	new(func(Uint32Valuer) uint32),
+	new(func(Uint64Valuer) uint64),
+	new(func(Float32Valuer) float32),
+	new(func(Float64Valuer) float64),
+	new(func(StringValuer) string),
+	new(func(TimeValuer) time.Time),
+	new(func(DurationValuer) time.Duration),
+	new(func(ArrayValuer) []any),
+	new(func(MapValuer) map[string]any),
+	new(func(any) any),
+)
diff --git a/patcher/value/value_example_test.go b/patcher/value/value_example_test.go
new file mode 100644
index 000000000..2da1739b7
--- /dev/null
+++ b/patcher/value/value_example_test.go
@@ -0,0 +1,42 @@
+package value_test
+
+import (
+	"fmt"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/patcher/value"
+	"github.com/expr-lang/expr/vm"
+)
+
+type myInt struct {
+	Int int
+}
+
+func (v *myInt) AsInt() int {
+	return v.Int
+}
+
+func (v *myInt) AsAny() any {
+	return v.Int
+}
+
+func ExampleAnyValuer() {
+	env := make(map[string]any)
+	env["ValueOne"] = &myInt{1}
+	env["ValueTwo"] = &myInt{2}
+
+	program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), value.ValueGetter)
+
+	if err != nil {
+		panic(err)
+	}
+
+	out, err := vm.Run(program, env)
+
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(out)
+	// Output: 3
+}
diff --git a/patcher/value/value_test.go b/patcher/value/value_test.go
new file mode 100644
index 000000000..1b6c5527a
--- /dev/null
+++ b/patcher/value/value_test.go
@@ -0,0 +1,172 @@
+package value
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
+)
+
+type customInt struct {
+	Int int
+}
+
+func (v *customInt) AsInt() int {
+	return v.Int
+}
+
+func (v *customInt) AsAny() any {
+	return v.Int
+}
+
+type customTypedInt struct {
+	Int int
+}
+
+func (v *customTypedInt) AsInt() int {
+	return v.Int
+}
+
+type customUntypedInt struct {
+	Int int
+}
+
+func (v *customUntypedInt) AsAny() any {
+	return v.Int
+}
+
+type customString struct {
+	String string
+}
+
+func (v *customString) AsString() string {
+	return v.String
+}
+
+func (v *customString) AsAny() any {
+	return v.String
+}
+
+type customTypedString struct {
+	String string
+}
+
+func (v *customTypedString) AsString() string {
+	return v.String
+}
+
+type customUntypedString struct {
+	String string
+}
+
+func (v *customUntypedString) AsAny() any {
+	return v.String
+}
+
+type customTypedArray struct {
+	Array []any
+}
+
+func (v *customTypedArray) AsArray() []any {
+	return v.Array
+}
+
+type customTypedMap struct {
+	Map map[string]any
+}
+
+func (v *customTypedMap) AsMap() map[string]any {
+	return v.Map
+}
+
+func Test_valueAddInt(t *testing.T) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customInt{1}
+	env["ValueTwo"] = &customInt{2}
+
+	program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter)
+	require.NoError(t, err)
+
+	out, err := vm.Run(program, env)
+
+	require.NoError(t, err)
+	require.Equal(t, 3, out.(int))
+}
+
+func Test_valueUntypedAddInt(t *testing.T) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customUntypedInt{1}
+	env["ValueTwo"] = &customUntypedInt{2}
+
+	program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter)
+	require.NoError(t, err)
+
+	out, err := vm.Run(program, env)
+
+	require.NoError(t, err)
+	require.Equal(t, 3, out.(int))
+}
+
+func Test_valueTypedAddInt(t *testing.T) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customTypedInt{1}
+	env["ValueTwo"] = &customTypedInt{2}
+
+	program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter)
+	require.NoError(t, err)
+
+	out, err := vm.Run(program, env)
+
+	require.NoError(t, err)
+	require.Equal(t, 3, out.(int))
+}
+
+func Test_valueTypedAddMismatch(t *testing.T) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customTypedInt{1}
+	env["ValueTwo"] = &customTypedString{"test"}
+
+	_, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter)
+	require.Error(t, err)
+}
+
+func Test_valueUntypedAddMismatch(t *testing.T) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customUntypedInt{1}
+	env["ValueTwo"] = &customUntypedString{"test"}
+
+	program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter)
+	require.NoError(t, err)
+
+	_, err = vm.Run(program, env)
+
+	require.Error(t, err)
+}
+
+func Test_valueTypedArray(t *testing.T) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customTypedArray{[]any{1, 2}}
+
+	program, err := expr.Compile("ValueOne[0] + ValueOne[1]", expr.Env(env), ValueGetter)
+	require.NoError(t, err)
+
+	out, err := vm.Run(program, env)
+
+	require.NoError(t, err)
+	require.Equal(t, 3, out.(int))
+}
+
+func Test_valueTypedMap(t *testing.T) {
+	env := make(map[string]any)
+	env["ValueOne"] = &customTypedMap{map[string]any{"one": 1, "two": 2}}
+
+	program, err := expr.Compile("ValueOne.one + ValueOne.two", expr.Env(env), ValueGetter)
+	require.NoError(t, err)
+
+	out, err := vm.Run(program, env)
+
+	require.NoError(t, err)
+	require.Equal(t, 3, out.(int))
+}

From e14c7e5cf90d6d68a3c7cc11497b0f6e5894f420 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 26 Dec 2023 16:06:16 +0100
Subject: [PATCH 224/506] Remove redundant func

---
 patcher/value/value.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/patcher/value/value.go b/patcher/value/value.go
index b7e4a767c..5af784844 100644
--- a/patcher/value/value.go
+++ b/patcher/value/value.go
@@ -26,7 +26,7 @@ var ValueGetter = func() expr.Option {
 	vPatcher := patcher{}
 	return func(c *conf.Config) {
 		c.Visitors = append(c.Visitors, vPatcher)
-		vPatcher.ApplyOptions(c)
+		getValueFunc(c)
 	}
 }()
 
@@ -155,10 +155,6 @@ func (patcher) Visit(node *ast.Node) {
 	}
 }
 
-func (patcher) ApplyOptions(c *conf.Config) {
-	getValueFunc(c)
-}
-
 func getValue(params ...any) (any, error) {
 	switch v := params[0].(type) {
 	case AnyValuer:

From c87f8f2d86297bc56290a40eaa421dd0b6a00b23 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 26 Dec 2023 16:24:00 +0100
Subject: [PATCH 225/506] Add change ident patcher test

---
 test/patch/change_ident_test.go | 61 +++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 test/patch/change_ident_test.go

diff --git a/test/patch/change_ident_test.go b/test/patch/change_ident_test.go
new file mode 100644
index 000000000..4d23b134a
--- /dev/null
+++ b/test/patch/change_ident_test.go
@@ -0,0 +1,61 @@
+package patch_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/vm"
+	"github.com/expr-lang/expr/vm/runtime"
+)
+
+func TestPatch_change_ident(t *testing.T) {
+	program, err := expr.Compile(
+		`foo`,
+		expr.Env(Env{}),
+		expr.Patch(changeIdent{}),
+	)
+	require.NoError(t, err)
+
+	expected := &vm.Program{
+		Bytecode: []vm.Opcode{
+			vm.OpLoadField,
+		},
+		Arguments: []int{
+			0,
+		},
+		Constants: []any{
+			&runtime.Field{
+				Path:  []string{"bar"},
+				Index: []int{1},
+			},
+		},
+	}
+
+	require.Equal(t, expected.Disassemble(), program.Disassemble())
+}
+
+type Env struct {
+	Foo int `expr:"foo"`
+	Bar int `expr:"bar"`
+}
+
+type changeIdent struct{}
+
+func (changeIdent) Visit(node *ast.Node) {
+	id, ok := (*node).(*ast.IdentifierNode)
+	if !ok {
+		return
+	}
+	if id.Value == "foo" {
+		// A correct way to patch the node:
+		//
+		//	newNode := &ast.IdentifierNode{Value: "bar"}
+		//	ast.Patch(node, newNode)
+		//
+		// But we can do it in a wrong way:
+		id.Value = "bar"
+	}
+}

From 280d28dc9f60ab18b81d0631124593c0d744751b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 26 Dec 2023 23:11:40 +0100
Subject: [PATCH 226/506] Use errors.As

---
 expr.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/expr.go b/expr.go
index 90f1273a1..07ef4b7b3 100644
--- a/expr.go
+++ b/expr.go
@@ -1,6 +1,7 @@
 package expr
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 
@@ -199,7 +200,8 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 	if config.Optimize {
 		err = optimizer.Optimize(&tree.Node, config)
 		if err != nil {
-			if fileError, ok := err.(*file.Error); ok {
+			var fileError *file.Error
+			if errors.As(err, &fileError) {
 				return nil, fileError.Bind(tree.Source)
 			}
 			return nil, err

From d3b30e2739c32c7f77e51f57e7ba99d0352926e8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 26 Dec 2023 23:11:55 +0100
Subject: [PATCH 227/506] Sort imports

---
 bench_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bench_test.go b/bench_test.go
index 6eb450812..601be77a2 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -3,9 +3,10 @@ package expr_test
 import (
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/vm"
-	"github.com/stretchr/testify/require"
 )
 
 func Benchmark_expr(b *testing.B) {

From caa7d52602ad36838fd7f77ee2116e71afd0c4a3 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 26 Dec 2023 23:14:20 +0100
Subject: [PATCH 228/506] Simplify ast nodes (#503)

* Move FiendIndex and MethodIndex out of ast nodes

* Remove println statement

* Add method compiler tests
---
 ast/node.go                                   | 39 ++---------
 checker/checker.go                            | 16 +----
 checker/info.go                               | 50 ++++++++++++++
 compiler/compiler.go                          | 62 ++++++++++-------
 compiler/compiler_test.go                     | 68 ++++++++++++++++---
 .../interface_method/interface_method_test.go |  4 +-
 test/operator/operator_test.go                |  3 +-
 7 files changed, 155 insertions(+), 87 deletions(-)
 create mode 100644 checker/info.go

diff --git a/ast/node.go b/ast/node.go
index f9d27fc6a..f70c49cc7 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -58,21 +58,7 @@ type NilNode struct {
 // IdentifierNode represents an identifier.
 type IdentifierNode struct {
 	base
-	Value       string // Name of the identifier. Like "foo" in "foo.bar".
-	FieldIndex  []int  // Internal. Index of the field in the list of fields.
-	Method      bool   // Internal. If true then the identifier is a method call.
-	MethodIndex int    // Internal. Index of the method in the list of methods.
-}
-
-// SetFieldIndex sets the field index of the identifier.
-func (n *IdentifierNode) SetFieldIndex(field []int) {
-	n.FieldIndex = field
-}
-
-// SetMethodIndex sets the method index of the identifier.
-func (n *IdentifierNode) SetMethodIndex(methodIndex int) {
-	n.Method = true
-	n.MethodIndex = methodIndex
+	Value string // Name of the identifier. Like "foo" in "foo.bar".
 }
 
 // IntegerNode represents an integer.
@@ -146,26 +132,9 @@ type ChainNode struct {
 //	array[0]
 type MemberNode struct {
 	base
-	Node       Node   // Node of the member access. Like "foo" in "foo.bar".
-	Property   Node   // Property of the member access. For property access it is a StringNode.
-	Optional   bool   // If true then the member access is optional. Like "foo?.bar".
-	Name       string // Internal. Name of the filed or method. Used for error reporting.
-	FieldIndex []int  // Internal. Index sequence of fields. Generated by type checker.
-
-	// TODO: Combine Method and MethodIndex into a single MethodIndex field of &int type.
-	Method      bool // Internal. If true then the member access is a method call.
-	MethodIndex int  // Internal. Index of the method in the list of methods. Generated by type checker.
-}
-
-// SetFieldIndex sets the field index of the member access.
-func (n *MemberNode) SetFieldIndex(field []int) {
-	n.FieldIndex = field
-}
-
-// SetMethodIndex sets the method index of the member access.
-func (n *MemberNode) SetMethodIndex(methodIndex int) {
-	n.Method = true
-	n.MethodIndex = methodIndex
+	Node     Node // Node of the member access. Like "foo" in "foo.bar".
+	Property Node // Property of the member access. For property access it is a StringNode.
+	Optional bool // If true then the member access is optional. Like "foo?.bar".
 }
 
 // SliceNode represents access to a slice of an array.
diff --git a/checker/checker.go b/checker/checker.go
index c214acf3b..38490bacf 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -166,23 +166,13 @@ func (v *checker) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 	return v.env(node, node.Value, true)
 }
 
-type NodeWithIndexes interface {
-	ast.Node
-	SetFieldIndex(field []int)
-	SetMethodIndex(methodIndex int)
-}
-
 // env method returns type of environment variable. env only lookups for
 // environment variables, no builtins, no custom functions.
-func (v *checker) env(node NodeWithIndexes, name string, strict bool) (reflect.Type, info) {
+func (v *checker) env(node ast.Node, name string, strict bool) (reflect.Type, info) {
 	if t, ok := v.config.Types[name]; ok {
 		if t.Ambiguous {
 			return v.error(node, "ambiguous identifier %v", name)
 		}
-		node.SetFieldIndex(t.FieldIndex)
-		if t.Method {
-			node.SetMethodIndex(t.MethodIndex)
-		}
 		return t.Type, info{method: t.Method}
 	}
 	if v.config.Strict && strict {
@@ -477,8 +467,6 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 				// the same interface.
 				return m.Type, info{}
 			} else {
-				node.SetMethodIndex(m.Index)
-				node.Name = name.Value
 				return m.Type, info{method: true}
 			}
 		}
@@ -508,8 +496,6 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 		if name, ok := node.Property.(*ast.StringNode); ok {
 			propertyName := name.Value
 			if field, ok := fetchField(base, propertyName); ok {
-				node.FieldIndex = field.Index
-				node.Name = propertyName
 				return field.Type, info{}
 			}
 			if len(v.parents) > 1 {
diff --git a/checker/info.go b/checker/info.go
new file mode 100644
index 000000000..3245253a3
--- /dev/null
+++ b/checker/info.go
@@ -0,0 +1,50 @@
+package checker
+
+import (
+	"reflect"
+
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/conf"
+)
+
+func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) {
+	switch n := node.(type) {
+	case *ast.IdentifierNode:
+		if t, ok := types[n.Value]; ok && len(t.FieldIndex) > 0 {
+			return true, t.FieldIndex, n.Value
+		}
+	case *ast.MemberNode:
+		base := n.Node.Type()
+		if kind(base) == reflect.Ptr {
+			base = base.Elem()
+		}
+		if kind(base) == reflect.Struct {
+			if prop, ok := n.Property.(*ast.StringNode); ok {
+				name := prop.Value
+				if field, ok := fetchField(base, name); ok {
+					return true, field.Index, name
+				}
+			}
+		}
+	}
+	return false, nil, ""
+}
+
+func MethodIndex(types conf.TypesTable, node ast.Node) (bool, int, string) {
+	switch n := node.(type) {
+	case *ast.IdentifierNode:
+		if t, ok := types[n.Value]; ok {
+			return t.Method, t.MethodIndex, n.Value
+		}
+	case *ast.MemberNode:
+		if name, ok := n.Property.(*ast.StringNode); ok {
+			base := n.Node.Type()
+			if base != nil && base.Kind() != reflect.Interface {
+				if m, ok := base.MethodByName(name.Value); ok {
+					return true, m.Index, name.Value
+				}
+			}
+		}
+	}
+	return false, 0, ""
+}
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 4831a3103..2b03e5afa 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -6,6 +6,7 @@ import (
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/checker"
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/parser"
@@ -34,6 +35,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 	if config != nil {
 		c.mapEnv = config.MapEnv
 		c.cast = config.Expect
+		c.types = config.Types
 	}
 
 	c.compile(tree.Node)
@@ -75,6 +77,7 @@ type compiler struct {
 	nodes          []ast.Node
 	chains         [][]int
 	arguments      []int
+	types          conf.TypesTable
 }
 
 type scope struct {
@@ -254,15 +257,15 @@ func (c *compiler) IdentifierNode(node *ast.IdentifierNode) {
 	}
 	if c.mapEnv {
 		c.emit(OpLoadFast, c.addConstant(node.Value))
-	} else if len(node.FieldIndex) > 0 {
+	} else if ok, index, name := checker.FieldIndex(c.types, node); ok {
 		c.emit(OpLoadField, c.addConstant(&runtime.Field{
-			Index: node.FieldIndex,
-			Path:  []string{node.Value},
+			Index: index,
+			Path:  []string{name},
 		}))
-	} else if node.Method {
+	} else if ok, index, name := checker.MethodIndex(c.types, node); ok {
 		c.emit(OpLoadMethod, c.addConstant(&runtime.Method{
-			Name:  node.Value,
-			Index: node.MethodIndex,
+			Name:  name,
+			Index: index,
 		}))
 	} else {
 		c.emit(OpLoadConst, c.addConstant(node.Value))
@@ -559,36 +562,43 @@ func (c *compiler) ChainNode(node *ast.ChainNode) {
 }
 
 func (c *compiler) MemberNode(node *ast.MemberNode) {
-	if node.Method {
+	if ok, index, name := checker.MethodIndex(c.types, node); ok {
 		c.compile(node.Node)
 		c.emit(OpMethod, c.addConstant(&runtime.Method{
-			Name:  node.Name,
-			Index: node.MethodIndex,
+			Name:  name,
+			Index: index,
 		}))
 		return
 	}
 	op := OpFetch
-	index := node.FieldIndex
-	path := []string{node.Name}
 	base := node.Node
-	if len(node.FieldIndex) > 0 {
+
+	ok, index, nodeName := checker.FieldIndex(c.types, node)
+	path := []string{nodeName}
+
+	if ok {
 		op = OpFetchField
 		for !node.Optional {
-			ident, ok := base.(*ast.IdentifierNode)
-			if ok && len(ident.FieldIndex) > 0 {
-				index = append(ident.FieldIndex, index...)
-				path = append([]string{ident.Value}, path...)
-				c.emitLocation(ident.Location(), OpLoadField, c.addConstant(
-					&runtime.Field{Index: index, Path: path},
-				))
-				return
+			if ident, isIdent := base.(*ast.IdentifierNode); isIdent {
+				if ok, identIndex, name := checker.FieldIndex(c.types, ident); ok {
+					index = append(identIndex, index...)
+					path = append([]string{name}, path...)
+					c.emitLocation(ident.Location(), OpLoadField, c.addConstant(
+						&runtime.Field{Index: index, Path: path},
+					))
+					return
+				}
 			}
-			member, ok := base.(*ast.MemberNode)
-			if ok && len(member.FieldIndex) > 0 {
-				index = append(member.FieldIndex, index...)
-				path = append([]string{member.Name}, path...)
-				node = member
-				base = member.Node
+
+			if member, isMember := base.(*ast.MemberNode); isMember {
+				if ok, memberIndex, name := checker.FieldIndex(c.types, member); ok {
+					index = append(memberIndex, index...)
+					path = append([]string{name}, path...)
+					node = member
+					base = member.Node
+				} else {
+					break
+				}
 			} else {
 				break
 			}
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index c3b460aa0..8068f5e69 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -24,6 +24,10 @@ type B struct {
 	}
 }
 
+func (B) FuncInB() int {
+	return 0
+}
+
 type Env struct {
 	A struct {
 		_   byte
@@ -33,12 +37,20 @@ type Env struct {
 	}
 }
 
+// AFunc is a method what goes before Func in the alphabet.
+func (e Env) AFunc() int {
+	return 0
+}
+
+func (e Env) Func() B {
+	return B{}
+}
+
 func TestCompile(t *testing.T) {
-	type test struct {
-		input   string
-		program vm.Program
-	}
-	var tests = []test{
+	var tests = []struct {
+		code string
+		want vm.Program
+	}{
 		{
 			`65535`,
 			vm.Program{
@@ -271,13 +283,53 @@ func TestCompile(t *testing.T) {
 				Arguments: []int{0, 0, 1, 0},
 			},
 		},
+		{
+			`Func()`,
+			vm.Program{
+				Constants: []any{
+					&runtime.Method{
+						Index: 1,
+						Name:  "Func",
+					},
+				},
+				Bytecode: []vm.Opcode{
+					vm.OpLoadMethod,
+					vm.OpCall,
+				},
+				Arguments: []int{0, 0},
+			},
+		},
+		{
+			`Func().FuncInB()`,
+			vm.Program{
+				Constants: []any{
+					&runtime.Method{
+						Index: 1,
+						Name:  "Func",
+					},
+					&runtime.Method{
+						Index: 0,
+						Name:  "FuncInB",
+					},
+				},
+				Bytecode: []vm.Opcode{
+					vm.OpLoadMethod,
+					vm.OpCall,
+					vm.OpMethod,
+					vm.OpCallTyped,
+				},
+				Arguments: []int{0, 0, 1, 10},
+			},
+		},
 	}
 
 	for _, test := range tests {
-		program, err := expr.Compile(test.input, expr.Env(Env{}), expr.Optimize(false))
-		require.NoError(t, err, test.input)
+		t.Run(test.code, func(t *testing.T) {
+			program, err := expr.Compile(test.code, expr.Env(Env{}), expr.Optimize(false))
+			require.NoError(t, err)
 
-		assert.Equal(t, test.program.Disassemble(), program.Disassemble(), test.input)
+			assert.Equal(t, test.want.Disassemble(), program.Disassemble())
+		})
 	}
 }
 
diff --git a/test/interface_method/interface_method_test.go b/test/interface_method/interface_method_test.go
index 23d9862d6..51057f7a8 100644
--- a/test/interface_method/interface_method_test.go
+++ b/test/interface_method/interface_method_test.go
@@ -3,9 +3,10 @@ package interface_method_test
 import (
 	"testing"
 
-	"github.com/expr-lang/expr"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr"
 )
 
 type Bar interface {
@@ -39,7 +40,6 @@ func TestInterfaceMethod(t *testing.T) {
 		"var": FooImpl{},
 	}
 	p, err := expr.Compile(`var.Foo().Bar()`, expr.Env(env))
-
 	assert.NoError(t, err)
 
 	out, err := expr.Run(p, env)
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index fc5c3b525..af50a24eb 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -4,9 +4,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/test/mock"
-	"github.com/stretchr/testify/require"
 )
 
 func TestOperator_struct(t *testing.T) {

From 95ec882069b2e6a7b427b6731f0207758ce0f089 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 28 Dec 2023 16:17:10 +0100
Subject: [PATCH 229/506] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index b393d9380..bd34c7d24 100644
--- a/README.md
+++ b/README.md
@@ -161,6 +161,7 @@ func main() {
 * [Chaos Mesh](https://chaos-mesh.org) incorporates Expr into Chaos Mesh, a cloud-native Chaos Engineering platform.
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
+* [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From f6a3d06cde04472b1d3eb6004290662ba4bda2ea Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 29 Dec 2023 19:50:08 +0100
Subject: [PATCH 230/506] Remove redundant fields from CallNode and BinaryNode
 (#504)

---
 ast/node.go               | 19 ++++-----
 checker/checker.go        | 74 ++++-------------------------------
 checker/checker_test.go   | 54 ++++----------------------
 checker/info.go           | 78 +++++++++++++++++++++++++++++++++++++
 checker/info_test.go      | 27 +++++++++++++
 compiler/compiler.go      | 81 ++++++++++++++++++++++++---------------
 compiler/compiler_test.go | 37 ++++++++++++++++++
 parser/parser_test.go     |  2 -
 vm/vm_test.go             | 26 -------------
 9 files changed, 214 insertions(+), 184 deletions(-)
 create mode 100644 checker/info_test.go

diff --git a/ast/node.go b/ast/node.go
index f70c49cc7..68c9e7bef 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -2,7 +2,6 @@ package ast
 
 import (
 	"reflect"
-	"regexp"
 
 	"github.com/expr-lang/expr/file"
 )
@@ -104,10 +103,9 @@ type UnaryNode struct {
 // BinaryNode represents a binary operator.
 type BinaryNode struct {
 	base
-	Operator string         // Operator of the binary operator. Like "+" in "foo + bar" or "matches" in "foo matches bar".
-	Left     Node           // Left node of the binary operator.
-	Right    Node           // Right node of the binary operator.
-	Regexp   *regexp.Regexp // Internal. Regexp of the "matches" operator. Like "f.+".
+	Operator string // Operator of the binary operator. Like "+" in "foo + bar" or "matches" in "foo matches bar".
+	Left     Node   // Left node of the binary operator.
+	Right    Node   // Right node of the binary operator.
 }
 
 // ChainNode represents an optional chaining group.
@@ -151,11 +149,8 @@ type SliceNode struct {
 // CallNode represents a function or a method call.
 type CallNode struct {
 	base
-	Callee    Node      // Node of the call. Like "foo" in "foo()".
-	Arguments []Node    // Arguments of the call.
-	Typed     int       // Internal. Used to indicate compiler what type is one of vm.FuncTypes.
-	Fast      bool      // Internal. Used to indicate compiler what this call is a fast call.
-	Func      *Function // Internal. Used to pass function information from type checker to compiler.
+	Callee    Node   // Node of the call. Like "foo" in "foo()".
+	Arguments []Node // Arguments of the call.
 }
 
 // BuiltinNode represents a builtin function call.
@@ -163,8 +158,8 @@ type BuiltinNode struct {
 	base
 	Name      string // Name of the builtin function. Like "len" in "len(foo)".
 	Arguments []Node // Arguments of the builtin function.
-	Throws    bool   // Internal. If true then accessing a field or array index can throw an error. Used by optimizer.
-	Map       Node   // Internal. Used by optimizer to fold filter() and map() builtins.
+	Throws    bool   // If true then accessing a field or array index can throw an error. Used by optimizer.
+	Map       Node   // Used by optimizer to fold filter() and map() builtins.
 }
 
 // ClosureNode represents a predicate.
diff --git a/checker/checker.go b/checker/checker.go
index 38490bacf..5afe18283 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -10,7 +10,6 @@ import (
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/parser"
-	"github.com/expr-lang/expr/vm"
 )
 
 func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
@@ -374,11 +373,10 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 
 	case "matches":
 		if s, ok := node.Right.(*ast.StringNode); ok {
-			r, err := regexp.Compile(s.Value)
+			_, err := regexp.Compile(s.Value)
 			if err != nil {
 				return v.error(node, err.Error())
 			}
-			node.Regexp = r
 		}
 		if isString(l) && isString(r) {
 			return boolType, info{}
@@ -549,7 +547,6 @@ func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) {
 	fn, fnInfo := v.visit(node.Callee)
 
 	if fnInfo.fn != nil {
-		node.Func = fnInfo.fn
 		return v.checkFunction(fnInfo.fn, node, node.Arguments)
 	}
 
@@ -571,23 +568,6 @@ func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) {
 	case reflect.Interface:
 		return anyType, info{}
 	case reflect.Func:
-		inputParamsCount := 1 // for functions
-		if fnInfo.method {
-			inputParamsCount = 2 // for methods
-		}
-		// TODO: Deprecate OpCallFast and move fn(...any) any to TypedFunc list.
-		// To do this we need add support for variadic arguments in OpCallTyped.
-		if !isAny(fn) &&
-			fn.IsVariadic() &&
-			fn.NumIn() == inputParamsCount &&
-			fn.NumOut() == 1 &&
-			fn.Out(0).Kind() == reflect.Interface {
-			rest := fn.In(fn.NumIn() - 1) // function has only one param for functions and two for methods
-			if kind(rest) == reflect.Slice && rest.Elem().Kind() == reflect.Interface {
-				node.Fast = true
-			}
-		}
-
 		outType, err := v.checkArguments(fnName, fn, fnInfo.method, node.Arguments, node)
 		if err != nil {
 			if v.err == nil {
@@ -595,9 +575,6 @@ func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) {
 			}
 			return anyType, info{}
 		}
-
-		v.findTypedFunc(node, fn, fnInfo.method)
-
 		return outType, info{}
 	}
 	return v.error(node, "%v is not callable", fn)
@@ -883,7 +860,13 @@ func (v *checker) checkFunction(f *ast.Function, node ast.Node, arguments []ast.
 	return v.error(node, "no matching overload for %v", f.Name)
 }
 
-func (v *checker) checkArguments(name string, fn reflect.Type, method bool, arguments []ast.Node, node ast.Node) (reflect.Type, *file.Error) {
+func (v *checker) checkArguments(
+	name string,
+	fn reflect.Type,
+	method bool,
+	arguments []ast.Node,
+	node ast.Node,
+) (reflect.Type, *file.Error) {
 	if isAny(fn) {
 		return anyType, nil
 	}
@@ -1122,44 +1105,3 @@ func (v *checker) PairNode(node *ast.PairNode) (reflect.Type, info) {
 	v.visit(node.Value)
 	return nilType, info{}
 }
-
-func (v *checker) findTypedFunc(node *ast.CallNode, fn reflect.Type, method bool) {
-	// OnCallTyped doesn't work for functions with variadic arguments,
-	// and doesn't work named function, like `type MyFunc func() int`.
-	// In PkgPath() is an empty string, it's unnamed function.
-	if !fn.IsVariadic() && fn.PkgPath() == "" {
-		fnNumIn := fn.NumIn()
-		fnInOffset := 0
-		if method {
-			fnNumIn--
-			fnInOffset = 1
-		}
-	funcTypes:
-		for i := range vm.FuncTypes {
-			if i == 0 {
-				continue
-			}
-			typed := reflect.ValueOf(vm.FuncTypes[i]).Elem().Type()
-			if typed.Kind() != reflect.Func {
-				continue
-			}
-			if typed.NumOut() != fn.NumOut() {
-				continue
-			}
-			for j := 0; j < typed.NumOut(); j++ {
-				if typed.Out(j) != fn.Out(j) {
-					continue funcTypes
-				}
-			}
-			if typed.NumIn() != fnNumIn {
-				continue
-			}
-			for j := 0; j < typed.NumIn(); j++ {
-				if typed.In(j) != fn.In(j+fnInOffset) {
-					continue funcTypes
-				}
-			}
-			node.Typed = i
-		}
-	}
-}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 42301261d..d03e3a8ee 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -554,6 +554,11 @@ unknown pointer #unknown (1:11)
 cannot use int as type string in array (1:4)
  | 42 in ["a", "b", "c"]
  | ...^
+
+"foo" matches "[+"
+error parsing regexp: missing closing ]: ` + "`[+`" + ` (1:7)
+ | "foo" matches "[+"
+ | ......^
 `
 
 func TestCheck_error(t *testing.T) {
@@ -777,49 +782,6 @@ func TestCheck_TypeWeights(t *testing.T) {
 	}
 }
 
-func TestCheck_CallFastTyped(t *testing.T) {
-	env := map[string]any{
-		"fn": func([]any, string) string {
-			return "foo"
-		},
-	}
-
-	tree, err := parser.Parse("fn([1, 2], 'bar')")
-	require.NoError(t, err)
-
-	_, err = checker.Check(tree, conf.New(env))
-	require.NoError(t, err)
-
-	require.False(t, tree.Node.(*ast.CallNode).Fast)
-	require.Equal(t, 22, tree.Node.(*ast.CallNode).Typed)
-}
-
-func TestCheck_CallFastTyped_Method(t *testing.T) {
-	env := mock.Env{}
-
-	tree, err := parser.Parse("FuncTyped('bar')")
-	require.NoError(t, err)
-
-	_, err = checker.Check(tree, conf.New(env))
-	require.NoError(t, err)
-
-	require.False(t, tree.Node.(*ast.CallNode).Fast)
-	require.Equal(t, 42, tree.Node.(*ast.CallNode).Typed)
-}
-
-func TestCheck_CallTyped_excludes_named_functions(t *testing.T) {
-	env := mock.Env{}
-
-	tree, err := parser.Parse("FuncNamed('bar')")
-	require.NoError(t, err)
-
-	_, err = checker.Check(tree, conf.New(env))
-	require.NoError(t, err)
-
-	require.False(t, tree.Node.(*ast.CallNode).Fast)
-	require.Equal(t, 0, tree.Node.(*ast.CallNode).Typed)
-}
-
 func TestCheck_works_with_nil_types(t *testing.T) {
 	env := map[string]any{
 		"null": nil,
@@ -908,8 +870,7 @@ func TestCheck_Function_types_are_checked(t *testing.T) {
 
 			_, err = checker.Check(tree, config)
 			require.NoError(t, err)
-			require.NotNil(t, tree.Node.(*ast.CallNode).Func)
-			require.Equal(t, "add", tree.Node.(*ast.CallNode).Func.Name)
+			require.Equal(t, reflect.Int, tree.Node.Type().Kind())
 		})
 	}
 
@@ -943,8 +904,7 @@ func TestCheck_Function_without_types(t *testing.T) {
 
 	_, err = checker.Check(tree, config)
 	require.NoError(t, err)
-	require.NotNil(t, tree.Node.(*ast.CallNode).Func)
-	require.Equal(t, "add", tree.Node.(*ast.CallNode).Func.Name)
+	require.Equal(t, reflect.Interface, tree.Node.Type().Kind())
 }
 
 func TestCheck_dont_panic_on_nil_arguments_for_builtins(t *testing.T) {
diff --git a/checker/info.go b/checker/info.go
index 3245253a3..112bfab31 100644
--- a/checker/info.go
+++ b/checker/info.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/vm"
 )
 
 func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) {
@@ -48,3 +49,80 @@ func MethodIndex(types conf.TypesTable, node ast.Node) (bool, int, string) {
 	}
 	return false, 0, ""
 }
+
+func TypedFuncIndex(fn reflect.Type, method bool) (int, bool) {
+	if fn == nil {
+		return 0, false
+	}
+	if fn.Kind() != reflect.Func {
+		return 0, false
+	}
+	// OnCallTyped doesn't work for functions with variadic arguments.
+	if fn.IsVariadic() {
+		return 0, false
+	}
+	// OnCallTyped doesn't work named function, like `type MyFunc func() int`.
+	if fn.PkgPath() != "" { // If PkgPath() is not empty, it means that function is named.
+		return 0, false
+	}
+
+	fnNumIn := fn.NumIn()
+	fnInOffset := 0
+	if method {
+		fnNumIn--
+		fnInOffset = 1
+	}
+
+funcTypes:
+	for i := range vm.FuncTypes {
+		if i == 0 {
+			continue
+		}
+		typed := reflect.ValueOf(vm.FuncTypes[i]).Elem().Type()
+		if typed.Kind() != reflect.Func {
+			continue
+		}
+		if typed.NumOut() != fn.NumOut() {
+			continue
+		}
+		for j := 0; j < typed.NumOut(); j++ {
+			if typed.Out(j) != fn.Out(j) {
+				continue funcTypes
+			}
+		}
+		if typed.NumIn() != fnNumIn {
+			continue
+		}
+		for j := 0; j < typed.NumIn(); j++ {
+			if typed.In(j) != fn.In(j+fnInOffset) {
+				continue funcTypes
+			}
+		}
+		return i, true
+	}
+	return 0, false
+}
+
+func IsFastFunc(fn reflect.Type, method bool) bool {
+	if fn == nil {
+		return false
+	}
+	if fn.Kind() != reflect.Func {
+		return false
+	}
+	numIn := 1
+	if method {
+		numIn = 2
+	}
+	if !isAny(fn) &&
+		fn.IsVariadic() &&
+		fn.NumIn() == numIn &&
+		fn.NumOut() == 1 &&
+		fn.Out(0).Kind() == reflect.Interface {
+		rest := fn.In(fn.NumIn() - 1) // function has only one param for functions and two for methods
+		if kind(rest) == reflect.Slice && rest.Elem().Kind() == reflect.Interface {
+			return true
+		}
+	}
+	return false
+}
diff --git a/checker/info_test.go b/checker/info_test.go
new file mode 100644
index 000000000..c91a55ad6
--- /dev/null
+++ b/checker/info_test.go
@@ -0,0 +1,27 @@
+package checker_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/test/mock"
+)
+
+func TestTypedFuncIndex(t *testing.T) {
+	fn := func([]any, string) string {
+		return "foo"
+	}
+	index, ok := checker.TypedFuncIndex(reflect.TypeOf(fn), false)
+	require.True(t, ok)
+	require.Equal(t, 22, index)
+}
+
+func TestTypedFuncIndex_excludes_named_functions(t *testing.T) {
+	var fn mock.MyFunc
+
+	_, ok := checker.TypedFuncIndex(reflect.TypeOf(fn), false)
+	require.False(t, ok)
+}
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 2b03e5afa..50c4816b2 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -3,6 +3,7 @@ package compiler
 import (
 	"fmt"
 	"reflect"
+	"regexp"
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
@@ -26,27 +27,24 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 	}()
 
 	c := &compiler{
+		config:         config,
 		locations:      make([]file.Location, 0),
 		constantsIndex: make(map[any]int),
 		functionsIndex: make(map[string]int),
 		debugInfo:      make(map[string]string),
 	}
 
-	if config != nil {
-		c.mapEnv = config.MapEnv
-		c.cast = config.Expect
-		c.types = config.Types
-	}
-
 	c.compile(tree.Node)
 
-	switch c.cast {
-	case reflect.Int:
-		c.emit(OpCast, 0)
-	case reflect.Int64:
-		c.emit(OpCast, 1)
-	case reflect.Float64:
-		c.emit(OpCast, 2)
+	if c.config != nil {
+		switch c.config.Expect {
+		case reflect.Int:
+			c.emit(OpCast, 0)
+		case reflect.Int64:
+			c.emit(OpCast, 1)
+		case reflect.Float64:
+			c.emit(OpCast, 2)
+		}
 	}
 
 	program = NewProgram(
@@ -63,6 +61,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 }
 
 type compiler struct {
+	config         *conf.Config
 	locations      []file.Location
 	bytecode       []Opcode
 	variables      []any
@@ -72,12 +71,9 @@ type compiler struct {
 	functions      []Function
 	functionsIndex map[string]int
 	debugInfo      map[string]string
-	mapEnv         bool
-	cast           reflect.Kind
 	nodes          []ast.Node
 	chains         [][]int
 	arguments      []int
-	types          conf.TypesTable
 }
 
 type scope struct {
@@ -255,14 +251,22 @@ func (c *compiler) IdentifierNode(node *ast.IdentifierNode) {
 		c.emit(OpLoadEnv)
 		return
 	}
-	if c.mapEnv {
+
+	var mapEnv bool
+	var types conf.TypesTable
+	if c.config != nil {
+		mapEnv = c.config.MapEnv
+		types = c.config.Types
+	}
+
+	if mapEnv {
 		c.emit(OpLoadFast, c.addConstant(node.Value))
-	} else if ok, index, name := checker.FieldIndex(c.types, node); ok {
+	} else if ok, index, name := checker.FieldIndex(types, node); ok {
 		c.emit(OpLoadField, c.addConstant(&runtime.Field{
 			Index: index,
 			Path:  []string{name},
 		}))
-	} else if ok, index, name := checker.MethodIndex(c.types, node); ok {
+	} else if ok, index, name := checker.MethodIndex(types, node); ok {
 		c.emit(OpLoadMethod, c.addConstant(&runtime.Method{
 			Name:  name,
 			Index: index,
@@ -485,10 +489,14 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 		c.emit(OpIn)
 
 	case "matches":
-		if node.Regexp != nil {
+		if str, ok := node.Right.(*ast.StringNode); ok {
+			re, err := regexp.Compile(str.Value)
+			if err != nil {
+				panic(err)
+			}
 			c.compile(node.Left)
 			c.derefInNeeded(node.Left)
-			c.emit(OpMatchesConst, c.addConstant(node.Regexp))
+			c.emit(OpMatchesConst, c.addConstant(re))
 		} else {
 			c.compile(node.Left)
 			c.derefInNeeded(node.Left)
@@ -562,7 +570,12 @@ func (c *compiler) ChainNode(node *ast.ChainNode) {
 }
 
 func (c *compiler) MemberNode(node *ast.MemberNode) {
-	if ok, index, name := checker.MethodIndex(c.types, node); ok {
+	var types conf.TypesTable
+	if c.config != nil {
+		types = c.config.Types
+	}
+
+	if ok, index, name := checker.MethodIndex(types, node); ok {
 		c.compile(node.Node)
 		c.emit(OpMethod, c.addConstant(&runtime.Method{
 			Name:  name,
@@ -573,14 +586,14 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 	op := OpFetch
 	base := node.Node
 
-	ok, index, nodeName := checker.FieldIndex(c.types, node)
+	ok, index, nodeName := checker.FieldIndex(types, node)
 	path := []string{nodeName}
 
 	if ok {
 		op = OpFetchField
 		for !node.Optional {
 			if ident, isIdent := base.(*ast.IdentifierNode); isIdent {
-				if ok, identIndex, name := checker.FieldIndex(c.types, ident); ok {
+				if ok, identIndex, name := checker.FieldIndex(types, ident); ok {
 					index = append(identIndex, index...)
 					path = append([]string{name}, path...)
 					c.emitLocation(ident.Location(), OpLoadField, c.addConstant(
@@ -591,7 +604,7 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 			}
 
 			if member, isMember := base.(*ast.MemberNode); isMember {
-				if ok, memberIndex, name := checker.FieldIndex(c.types, member); ok {
+				if ok, memberIndex, name := checker.FieldIndex(types, member); ok {
 					index = append(memberIndex, index...)
 					path = append([]string{name}, path...)
 					node = member
@@ -640,15 +653,21 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 	for _, arg := range node.Arguments {
 		c.compile(arg)
 	}
-	if node.Func != nil {
-		c.emitFunction(node.Func, len(node.Arguments))
-		return
+	if ident, ok := node.Callee.(*ast.IdentifierNode); ok {
+		if c.config != nil {
+			if fn, ok := c.config.Functions[ident.Value]; ok {
+				c.emitFunction(fn, len(node.Arguments))
+				return
+			}
+		}
 	}
 	c.compile(node.Callee)
-	if node.Typed > 0 {
-		c.emit(OpCallTyped, node.Typed)
+
+	isMethod, _, _ := checker.MethodIndex(c.config.Types, node.Callee)
+	if index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok {
+		c.emit(OpCallTyped, index)
 		return
-	} else if node.Fast {
+	} else if checker.IsFastFunc(node.Callee.Type(), isMethod) {
 		c.emit(OpCallFast, len(node.Arguments))
 	} else {
 		c.emit(OpCall, len(node.Arguments))
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index 8068f5e69..ed11a9dd7 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -8,6 +8,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/test/mock"
 	"github.com/expr-lang/expr/test/playground"
 	"github.com/expr-lang/expr/vm"
 	"github.com/expr-lang/expr/vm/runtime"
@@ -347,3 +348,39 @@ func TestCompile_panic(t *testing.T) {
 		})
 	}
 }
+
+func TestCompile_FuncTypes(t *testing.T) {
+	env := map[string]any{
+		"fn": func([]any, string) string {
+			return "foo"
+		},
+	}
+	program, err := expr.Compile("fn([1, 2], 'bar')", expr.Env(env))
+	require.NoError(t, err)
+	require.Equal(t, vm.OpCallTyped, program.Bytecode[3])
+	require.Equal(t, 22, program.Arguments[3])
+}
+
+func TestCompile_FuncTypes_with_Method(t *testing.T) {
+	env := mock.Env{}
+	program, err := expr.Compile("FuncTyped('bar')", expr.Env(env))
+	require.NoError(t, err)
+	require.Equal(t, vm.OpCallTyped, program.Bytecode[2])
+	require.Equal(t, 42, program.Arguments[2])
+}
+
+func TestCompile_FuncTypes_excludes_named_functions(t *testing.T) {
+	env := mock.Env{}
+	program, err := expr.Compile("FuncNamed('bar')", expr.Env(env))
+	require.NoError(t, err)
+	require.Equal(t, vm.OpCall, program.Bytecode[2])
+	require.Equal(t, 1, program.Arguments[2])
+}
+
+func TestCompile_OpCallFast(t *testing.T) {
+	env := mock.Env{}
+	program, err := expr.Compile("Fast(3, 2, 1)", expr.Env(env))
+	require.NoError(t, err)
+	require.Equal(t, vm.OpCallFast, program.Bytecode[4])
+	require.Equal(t, 3, program.Arguments[4])
+}
diff --git a/parser/parser_test.go b/parser/parser_test.go
index ba8e29acc..453fe91ac 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -222,14 +222,12 @@ world`},
 									},
 								},
 								Arguments: []Node{},
-								Fast:      false,
 							},
 							Property: &StringNode{
 								Value: "c",
 							},
 						},
 						Arguments: []Node{},
-						Fast:      false,
 					},
 					Property: &StringNode{
 						Value: "d",
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 70a0ae057..0cbbb8998 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -8,7 +8,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/checker"
 	"github.com/expr-lang/expr/compiler"
 	"github.com/expr-lang/expr/conf"
@@ -145,10 +144,6 @@ func (ErrorEnv) WillError(param string) (bool, error) {
 	return true, nil
 }
 
-func (ErrorEnv) FastError(...any) any {
-	return true
-}
-
 func (InnerEnv) WillError(param string) (bool, error) {
 	if param == "yes" {
 		return false, errors.New("inner error")
@@ -202,27 +197,6 @@ func TestRun_FastMethods(t *testing.T) {
 	require.Equal(t, "hello world", out)
 }
 
-func TestRun_FastMethodWithError(t *testing.T) {
-	input := `FastError()`
-
-	tree, err := parser.Parse(input)
-	require.NoError(t, err)
-
-	env := ErrorEnv{}
-	funcConf := conf.New(env)
-	_, err = checker.Check(tree, funcConf)
-	require.NoError(t, err)
-	require.True(t, tree.Node.(*ast.CallNode).Fast, "method must be fast")
-
-	program, err := compiler.Compile(tree, funcConf)
-	require.NoError(t, err)
-
-	out, err := vm.Run(program, env)
-	require.NoError(t, err)
-
-	require.Equal(t, true, out)
-}
-
 func TestRun_InnerMethodWithError(t *testing.T) {
 	input := `InnerEnv.WillError("yes")`
 

From ed688360999a89ddbc50752a3524d08c6d490a9c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 29 Dec 2023 21:00:43 +0100
Subject: [PATCH 231/506] Rename func.go to lib.go

---
 builtin/{func.go => lib.go} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename builtin/{func.go => lib.go} (100%)

diff --git a/builtin/func.go b/builtin/lib.go
similarity index 100%
rename from builtin/func.go
rename to builtin/lib.go

From 5dcb233566c0c28a5059b968e013b602ffc29696 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 29 Dec 2023 21:04:25 +0100
Subject: [PATCH 232/506] Move ast.Function to builtin.Function

---
 ast/func.go          | 12 ------------
 builtin/builtin.go   | 12 ++++++++++--
 builtin/lib.go       |  5 ++---
 checker/checker.go   |  4 ++--
 compiler/compiler.go |  4 ++--
 conf/config.go       |  8 ++++----
 expr.go              |  3 ++-
 7 files changed, 22 insertions(+), 26 deletions(-)
 delete mode 100644 ast/func.go

diff --git a/ast/func.go b/ast/func.go
deleted file mode 100644
index a873c35e9..000000000
--- a/ast/func.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package ast
-
-import "reflect"
-
-type Function struct {
-	Name      string
-	Func      func(args ...any) (any, error)
-	Fast      func(arg any) any
-	Types     []reflect.Type
-	Validate  func(args []reflect.Type) (reflect.Type, error)
-	Predicate bool
-}
diff --git a/builtin/builtin.go b/builtin/builtin.go
index d76cc9d06..2417446da 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -9,10 +9,18 @@ import (
 	"strings"
 	"time"
 
-	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
+type Function struct {
+	Name      string
+	Func      func(args ...any) (any, error)
+	Fast      func(arg any) any
+	Types     []reflect.Type
+	Validate  func(args []reflect.Type) (reflect.Type, error)
+	Predicate bool
+}
+
 var (
 	Index map[string]int
 	Names []string
@@ -27,7 +35,7 @@ func init() {
 	}
 }
 
-var Builtins = []*ast.Function{
+var Builtins = []*Function{
 	{
 		Name:      "all",
 		Predicate: true,
diff --git a/builtin/lib.go b/builtin/lib.go
index 1c2546a2d..1deca3f99 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -6,7 +6,6 @@ import (
 	"reflect"
 	"strconv"
 
-	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
@@ -274,8 +273,8 @@ func Min(args ...any) (any, error) {
 	return min, nil
 }
 
-func bitFunc(name string, fn func(x, y int) (any, error)) *ast.Function {
-	return &ast.Function{
+func bitFunc(name string, fn func(x, y int) (any, error)) *Function {
+	return &Function{
 		Name: name,
 		Func: func(args ...any) (any, error) {
 			if len(args) != 2 {
diff --git a/checker/checker.go b/checker/checker.go
index 5afe18283..4dced34ea 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -71,7 +71,7 @@ type varScope struct {
 
 type info struct {
 	method bool
-	fn     *ast.Function
+	fn     *builtin.Function
 
 	// elem is element type of array or map.
 	// Arrays created with type []any, but
@@ -819,7 +819,7 @@ func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
 	return v.error(val, "type %v does not support indexing", t)
 }
 
-func (v *checker) checkFunction(f *ast.Function, node ast.Node, arguments []ast.Node) (reflect.Type, info) {
+func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) (reflect.Type, info) {
 	if f.Validate != nil {
 		args := make([]reflect.Type, len(arguments))
 		for i, arg := range arguments {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 50c4816b2..f4bb3bd5d 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -144,7 +144,7 @@ func (c *compiler) addVariable(name string) int {
 }
 
 // emitFunction adds builtin.Function.Func to the program.functions and emits call opcode.
-func (c *compiler) emitFunction(fn *ast.Function, argsLen int) {
+func (c *compiler) emitFunction(fn *builtin.Function, argsLen int) {
 	switch argsLen {
 	case 0:
 		c.emit(OpCall0, c.addFunction(fn))
@@ -161,7 +161,7 @@ func (c *compiler) emitFunction(fn *ast.Function, argsLen int) {
 }
 
 // addFunction adds builtin.Function.Func to the program.functions and returns its index.
-func (c *compiler) addFunction(fn *ast.Function) int {
+func (c *compiler) addFunction(fn *builtin.Function) int {
 	if fn == nil {
 		panic("function is nil")
 	}
diff --git a/conf/config.go b/conf/config.go
index 4de8ca448..48d491a96 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -21,8 +21,8 @@ type Config struct {
 	Strict      bool
 	ConstFns    map[string]reflect.Value
 	Visitors    []ast.Visitor
-	Functions   map[string]*ast.Function
-	Builtins    map[string]*ast.Function
+	Functions   map[string]*builtin.Function
+	Builtins    map[string]*builtin.Function
 	Disabled    map[string]bool // disabled builtins
 }
 
@@ -32,8 +32,8 @@ func CreateNew() *Config {
 		Optimize:  true,
 		Operators: make(map[string][]string),
 		ConstFns:  make(map[string]reflect.Value),
-		Functions: make(map[string]*ast.Function),
-		Builtins:  make(map[string]*ast.Function),
+		Functions: make(map[string]*builtin.Function),
+		Builtins:  make(map[string]*builtin.Function),
 		Disabled:  make(map[string]bool),
 	}
 	for _, f := range builtin.Builtins {
diff --git a/expr.go b/expr.go
index 07ef4b7b3..8569de8fb 100644
--- a/expr.go
+++ b/expr.go
@@ -6,6 +6,7 @@ import (
 	"reflect"
 
 	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/checker"
 	"github.com/expr-lang/expr/compiler"
 	"github.com/expr-lang/expr/conf"
@@ -123,7 +124,7 @@ func Function(name string, fn func(params ...any) (any, error), types ...any) Op
 			}
 			ts[i] = t
 		}
-		c.Functions[name] = &ast.Function{
+		c.Functions[name] = &builtin.Function{
 			Name:  name,
 			Func:  fn,
 			Types: ts,

From 7b890a13cc708ce5962a139edc4cca0000cacc87 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 29 Dec 2023 23:01:52 +0100
Subject: [PATCH 233/506] Update examples.txt

---
 testdata/examples.txt | 23365 +++++++++++++++++++++++-----------------
 1 file changed, 13497 insertions(+), 9868 deletions(-)

diff --git a/testdata/examples.txt b/testdata/examples.txt
index 2bb8ab7fb..9abe85327 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -1,18 +1,15 @@
-!!!true
-!!(f32 > f64)
-!!(half != greet)
-!!(nil == add)
-!!(ok or true)
+!!!false
+!!(1 <= f64)
+!!(1 > 0.5)
+!!(i64 != f64)
+!!all(array, ok)
 !!false
-!!not false
 !!ok
 !!true
 !("bar" != "bar")
 !("bar" != "foo")
 !("bar" != nil)
-!("bar" < "bar")
 !("bar" < "foo")
-!("bar" <= "bar")
 !("bar" <= "foo")
 !("bar" == "bar")
 !("bar" == "foo")
@@ -21,32 +18,32 @@
 !("bar" > "foo")
 !("bar" >= "bar")
 !("bar" >= "foo")
+!("bar" contains "bar")
 !("bar" contains "foo")
+!("bar" endsWith "bar")
+!("bar" endsWith "foo")
 !("bar" in foo)
 !("bar" matches "foo")
 !("bar" not contains "bar")
-!("bar" not contains "foo")
+!("bar" not endsWith "bar")
 !("bar" not endsWith "foo")
 !("bar" not in foo)
-!("bar" not matches "foo")
+!("bar" not matches "bar")
 !("bar" not startsWith "bar")
 !("bar" not startsWith "foo")
 !("bar" startsWith "bar")
 !("foo" != "bar")
-!("foo" != "foo")
 !("foo" != nil)
-!("foo" < "bar")
+!("foo" < "foo")
 !("foo" <= "bar")
 !("foo" <= "foo")
-!("foo" == "foo")
+!("foo" == "bar")
 !("foo" == nil)
 !("foo" > "bar")
 !("foo" > "foo")
 !("foo" >= "bar")
-!("foo" >= "foo")
 !("foo" contains "bar")
 !("foo" contains "foo")
-!("foo" endsWith "bar")
 !("foo" endsWith "foo")
 !("foo" in foo)
 !("foo" matches "bar")
@@ -54,14 +51,15 @@
 !("foo" not contains "bar")
 !("foo" not contains "foo")
 !("foo" not endsWith "bar")
-!("foo" not endsWith "foo")
-!("foo" not in foo)
 !("foo" not matches "bar")
 !("foo" not matches "foo")
 !("foo" not startsWith "bar")
 !("foo" not startsWith "foo")
 !("foo" startsWith "bar")
 !("foo" startsWith "foo")
+!(-f32 < f32)
+!(-i < i32)
+!(-i32 >= i)
 !(0.5 != 0.5)
 !(0.5 != 1)
 !(0.5 != f32)
@@ -70,7 +68,6 @@
 !(0.5 != i32)
 !(0.5 != i64)
 !(0.5 != nil)
-!(0.5 / i32 > i)
 !(0.5 < 0.5)
 !(0.5 < 1)
 !(0.5 < f32)
@@ -81,6 +78,7 @@
 !(0.5 <= 0.5)
 !(0.5 <= 1)
 !(0.5 <= f32)
+!(0.5 <= f64)
 !(0.5 <= i)
 !(0.5 <= i32)
 !(0.5 <= i64)
@@ -106,7 +104,8 @@
 !(0.5 >= i)
 !(0.5 >= i32)
 !(0.5 >= i64)
-!(0.5 ^ i64 < i64)
+!(0.5 in array)
+!(0.5 not in array)
 !(1 != 0.5)
 !(1 != 1)
 !(1 != f32)
@@ -115,6 +114,7 @@
 !(1 != i32)
 !(1 != i64)
 !(1 != nil)
+!(1 / i64 == i64)
 !(1 < 0.5)
 !(1 < 1)
 !(1 < f32)
@@ -139,6 +139,7 @@
 !(1 == nil)
 !(1 > 0.5)
 !(1 > 1)
+!(1 > f32)
 !(1 > f64)
 !(1 > i)
 !(1 > i32)
@@ -160,10 +161,12 @@
 !(add != score)
 !(add == add)
 !(add == div)
+!(add == greet)
 !(add == half)
 !(add == nil)
 !(add == score)
 !(array != array)
+!(array != list)
 !(array != nil)
 !(array == array)
 !(array == list)
@@ -178,15 +181,15 @@
 !(div == div)
 !(div == greet)
 !(div == half)
-!(div == nil)
 !(div == score)
 !(f32 != 0.5)
 !(f32 != 1)
 !(f32 != f32)
+!(f32 != f64)
+!(f32 != i)
 !(f32 != i32)
 !(f32 != i64)
 !(f32 != nil)
-!(f32 + i == 0.5 * i)
 !(f32 < 0.5)
 !(f32 < 1)
 !(f32 < f32)
@@ -198,7 +201,6 @@
 !(f32 <= 1)
 !(f32 <= f32)
 !(f32 <= f64)
-!(f32 <= i)
 !(f32 <= i32)
 !(f32 <= i64)
 !(f32 == 0.5)
@@ -219,39 +221,44 @@
 !(f32 >= 0.5)
 !(f32 >= 1)
 !(f32 >= f32)
-!(f32 >= f64)
 !(f32 >= i)
+!(f32 >= i32)
 !(f32 >= i64)
+!(f32 in array)
+!(f32 not in array)
 !(f64 != 0.5)
 !(f64 != 1)
 !(f64 != f32)
 !(f64 != f64)
+!(f64 != i)
 !(f64 != i32)
 !(f64 != i64)
 !(f64 != nil)
+!(f64 < 0.5 + 1)
 !(f64 < 0.5)
 !(f64 < 1)
-!(f64 < f32)
 !(f64 < f64)
 !(f64 < i)
 !(f64 < i32)
 !(f64 < i64)
+!(f64 < max(1))
 !(f64 <= 0.5)
 !(f64 <= 1)
-!(f64 <= f32)
-!(f64 <= f64)
-!(f64 <= i)
 !(f64 <= i32)
 !(f64 <= i64)
 !(f64 == 0.5)
 !(f64 == 1)
 !(f64 == f32)
+!(f64 == f64)
+!(f64 == i)
 !(f64 == i32)
 !(f64 == i64)
 !(f64 == nil)
 !(f64 > 0.5)
 !(f64 > 1)
+!(f64 > f32)
 !(f64 > f64)
+!(f64 > i)
 !(f64 > i32)
 !(f64 > i64)
 !(f64 >= 0.5)
@@ -261,18 +268,24 @@
 !(f64 >= i)
 !(f64 >= i32)
 !(f64 >= i64)
+!(f64 in array)
+!(f64 not in array)
 !(false != false)
 !(false != nil)
 !(false != ok)
 !(false != true)
 !(false && false)
 !(false && ok)
+!(false && true)
 !(false == false)
 !(false == nil)
 !(false == ok)
+!(false == true)
+!(false and false)
 !(false and ok)
+!(false and true)
+!(false or false)
 !(false or ok)
-!(false or true)
 !(false || false)
 !(false || ok)
 !(false || true)
@@ -280,15 +293,16 @@
 !(foo != nil)
 !(foo == foo)
 !(foo == nil)
+!(foo == reduce(list, #))
 !(foo in list)
 !(foo not in list)
+!(greet != add)
 !(greet != div)
 !(greet != greet)
 !(greet != half)
 !(greet != nil)
 !(greet != score)
 !(greet == add)
-!(greet == div)
 !(greet == greet)
 !(greet == half)
 !(greet == nil)
@@ -315,7 +329,6 @@
 !(i != nil)
 !(i < 0.5)
 !(i < 1)
-!(i < f32)
 !(i < f64)
 !(i < i)
 !(i < i32)
@@ -324,9 +337,7 @@
 !(i <= 1)
 !(i <= f32)
 !(i <= f64)
-!(i <= i)
 !(i <= i32)
-!(i <= i64)
 !(i == 0.5)
 !(i == 1)
 !(i == f32)
@@ -343,20 +354,23 @@
 !(i > i32)
 !(i > i64)
 !(i >= 0.5)
+!(i >= 1 * i64)
 !(i >= 1)
 !(i >= f32)
 !(i >= f64)
+!(i >= i)
 !(i >= i32)
 !(i >= i64)
 !(i in array)
+!(i not in array)
 !(i32 != 0.5)
 !(i32 != 1)
+!(i32 != f32)
 !(i32 != f64)
 !(i32 != i)
 !(i32 != i32)
 !(i32 != i64)
 !(i32 != nil)
-!(i32 * 0.5 != i32)
 !(i32 < 0.5)
 !(i32 < 1)
 !(i32 < f32)
@@ -373,6 +387,7 @@
 !(i32 <= i64)
 !(i32 == 0.5)
 !(i32 == 1)
+!(i32 == f32)
 !(i32 == f64)
 !(i32 == i)
 !(i32 == i32)
@@ -380,10 +395,10 @@
 !(i32 == nil)
 !(i32 > 0.5)
 !(i32 > 1)
+!(i32 > f32)
 !(i32 > f64)
 !(i32 > i)
 !(i32 > i32)
-!(i32 > i64)
 !(i32 >= 0.5)
 !(i32 >= 1)
 !(i32 >= f32)
@@ -399,12 +414,14 @@
 !(i64 != f64)
 !(i64 != i)
 !(i64 != i32)
+!(i64 != i64)
 !(i64 != nil)
 !(i64 < 0.5)
 !(i64 < 1)
 !(i64 < f32)
 !(i64 < f64)
 !(i64 < i)
+!(i64 < i32 + i64)
 !(i64 < i32)
 !(i64 < i64)
 !(i64 <= 0.5)
@@ -418,8 +435,8 @@
 !(i64 == 1)
 !(i64 == f32)
 !(i64 == f64)
-!(i64 == i)
 !(i64 == i32)
+!(i64 == i64)
 !(i64 == nil)
 !(i64 > 0.5)
 !(i64 > 1)
@@ -434,8 +451,9 @@
 !(i64 >= f64)
 !(i64 >= i)
 !(i64 >= i32)
+!(i64 >= i64)
 !(i64 in array)
-!(i64 not in array)
+!(len("bar") <= i)
 !(list != array)
 !(list != list)
 !(list != nil)
@@ -467,10 +485,12 @@
 !(nil == "foo")
 !(nil == 0.5)
 !(nil == 1)
+!(nil == add)
 !(nil == array)
 !(nil == div)
 !(nil == f32)
 !(nil == f64)
+!(nil == false)
 !(nil == foo)
 !(nil == greet)
 !(nil == half)
@@ -493,14 +513,17 @@
 !(ok && false)
 !(ok && ok)
 !(ok && true)
-!(ok == false)
 !(ok == nil)
 !(ok == ok)
+!(ok == true)
 !(ok and ok)
 !(ok and true)
+!(ok or false)
 !(ok or ok)
+!(ok or true)
 !(ok || false)
 !(ok || ok)
+!(ok || true)
 !(score != add)
 !(score != div)
 !(score != greet)
@@ -512,6 +535,7 @@
 !(score == greet)
 !(score == half)
 !(score == nil)
+!(score == score)
 !(true != false)
 !(true != nil)
 !(true != ok)
@@ -523,10 +547,11 @@
 !(true == nil)
 !(true == ok)
 !(true == true)
-!(true and false)
 !(true and ok)
 !(true and true)
+!(true or ok)
 !(true or true)
+!(true || false)
 !(true || ok)
 !(true || true)
 !all(array, false)
@@ -535,445 +560,498 @@
 !all(list, false)
 !all(list, ok)
 !all(list, true)
-!any(array, false)
+!any(array, i == #)
 !any(array, ok)
 !any(array, true)
-!any(list, # != #)
+!any(list, false)
 !any(list, ok)
-!false && ok
-!false ? "bar" : i
-!false ? "foo" : false
-!false ? 0.5 : "bar"
-!false ? 0.5 : 1
-!false ? 0.5 : div
-!false ? 0.5 : i64
-!false ? 1 : add
-!false ? 1 : true
-!false ? add : array
-!false ? add : nil
-!false ? array : array
-!false ? div : 0.5
-!false ? div : foo
-!false ? div : map(list, #)
-!false ? div : nil
-!false ? f32 : 0.5
-!false ? f32 : greet
-!false ? f64 : 1
-!false ? f64 : half
-!false ? false : f32
-!false ? false : false
-!false ? foo : 1
-!false ? foo : i64
-!false ? greet : array
-!false ? greet : i32
-!false ? half : nil
-!false ? half : ok
-!false ? i : foo
-!false ? i32 : "foo"
-!false ? i64 : f32
-!false ? i64 : nil
-!false ? list : list
-!false ? nil : 1
+!any(list, true)
+!false != not true
+!false != ok
+!false && 0.5 == 1
+!false == ok
+!false ? "foo" : 0.5
+!false ? "foo" : f32
+!false ? 0.5 : "foo"
+!false ? 0.5 : f32
+!false ? 1 : half
+!false ? 1 : i
+!false ? add : f32
+!false ? add : i64
+!false ? array : add
+!false ? array : ok
+!false ? div != half : map(list, i32)
+!false ? div : array
+!false ? div : greet
+!false ? div : half
+!false ? f32 : add
+!false ? f32 : false
+!false ? f64 : "foo"
+!false ? foo : "bar"
+!false ? half : 1
+!false ? half : add
+!false ? half : list
+!false ? half : true
+!false ? i : nil
+!false ? i32 : list
+!false ? i64 : foo
+!false ? i64 : i64
 !false ? nil : add
 !false ? nil : f64
 !false ? nil : foo
-!false ? ok : ok
-!false ? true : array
-!false and (true or false)
-!false and ok
-!false or 0.5 != 1
-!false || not false
-!hasSuffix("bar", "bar")
+!false ? nil : half
+!false ? ok : 1
+!false ? score : "bar"
+!false ? score : foo
+!false ? score : ok
+!false ? true : "foo"
+!false or 0.5 > i32
+!false or ok
+!false || ok
+!hasPrefix("foo", "foo")
+!none(array, # > #)
+!none(array, # >= #)
 !none(array, false)
-!none(array, true)
-!none(list, false)
+!none(array, ok)
 !none(list, ok)
 !none(list, true)
-!not (1 != i)
-!not (i64 != 0.5)
-!not any(list, ok)
+!not ("bar" == nil)
+!not (1 <= 1)
+!not (1 > 0.5)
+!not (greet != score)
+!not (greet == div)
+!not (greet == nil)
+!not (i32 == f64)
 !not false
+!not none(list, true)
 !not ok
 !not true
-!not true ? i64 : true
 !ok
+!ok != !true
 !ok != ok
-!ok && (ok || ok)
-!ok == !ok
+!ok && ok
 !ok == ok
-!ok ? "bar" : 0.5
-!ok ? "foo" : nil
-!ok ? 0.5 : "foo"
-!ok ? 1 : 0.5
-!ok ? 1 : 1
+!ok ? "bar" : "foo"
+!ok ? "bar" : foo
+!ok ? "foo" : 0.5
+!ok ? "foo" : list
+!ok ? 0.5 : 1
+!ok ? 0.5 : i
+!ok ? 1 : array
 !ok ? 1 : div
-!ok ? 1 : foo
-!ok ? 1 : greet
+!ok ? 1 : f64
+!ok ? 1 : list
 !ok ? 1 : ok
-!ok ? add : f32
-!ok ? add : false
-!ok ? add : i
-!ok ? add : score
-!ok ? f32 : "foo"
-!ok ? f32 : 1
-!ok ? f64 : i
-!ok ? false : "foo"
-!ok ? false : half
-!ok ? greet : "bar"
-!ok ? greet : add
-!ok ? greet : false
-!ok ? half : array
+!ok ? add : 0.5
+!ok ? array : div
+!ok ? array : f32
+!ok ? array : foo
+!ok ? array : i
+!ok ? array : i32
+!ok ? div : "foo"
+!ok ? div : 1
+!ok ? div : i
+!ok ? f32 : "bar"
+!ok ? f32 : add
+!ok ? f32 : false
+!ok ? f32 : greet
+!ok ? f64 : "bar"
+!ok ? f64 : "foo"
+!ok ? f64 : 0.5
+!ok ? f64 : half
+!ok ? f64 : score
+!ok ? false : ok
+!ok ? foo : "foo"
+!ok ? foo : f32
+!ok ? foo : false
+!ok ? foo : i32
+!ok ? greet : div
+!ok ? greet : list
+!ok ? greet : nil
+!ok ? half : f64
+!ok ? i : "bar"
+!ok ? i : array
+!ok ? i : div
 !ok ? i : foo
-!ok ? i : greet
-!ok ? i : true
-!ok ? i64 : list
-!ok ? list : "foo"
-!ok ? list : true
-!ok ? nil : i
-!ok ? nil : true
-!ok ? ok : 1
-!ok ? ok : i64
-!ok ? ok : score
-!ok ? score : array
-!ok ? score : i
-!ok ? true : greet
-!ok and i != f32
+!ok ? i32 : 0.5
+!ok ? i32 : f32
+!ok ? i32 : greet
+!ok ? i32 : nil
+!ok ? i64 : 0.5
+!ok ? i64 : 1
+!ok ? i64 : f32
+!ok ? i64 : true
+!ok ? list : f32
+!ok ? list : i
+!ok ? nil : 1
+!ok ? nil : array
+!ok ? ok : f32
+!ok ? ok : list
 !ok and ok
-!ok or none(array, ok)
+!ok or f32 < i64
+!ok or false or false
+!ok or ok
+!ok || ok
+!one(array, false)
 !one(array, ok)
 !one(array, true)
 !one(list, false)
 !one(list, ok)
 !one(list, true)
-!true != false ? ok : 0.5
-!true != nil == nil
-!true != ok
-!true && ok
-!true == ok
-!true ? "bar" : false
-!true ? "bar" : i
-!true ? "foo" : ok
-!true ? 0.5 : 1
-!true ? 0.5 : div
-!true ? 0.5 : i
-!true ? add : div
-!true ? add : greet
-!true ? array : foo
-!true ? array : i
-!true ? array : i64
-!true ? array : score
-!true ? div : f32
-!true ? div : ok
-!true ? f32 : 0.5
-!true ? f32 : add
-!true ? f32 : foo
-!true ? f32 : i32
-!true ? f64 : "bar"
+!reduce(array, false)
+!reduce(array, ok)
+!reduce(array, true)
+!reduce(list, # != #)
+!reduce(list, false)
+!reduce(list, ok)
+!reduce(list, true)
+!true != all(array, ok)
+!true ? "bar" : "foo"
+!true ? "bar" : true
+!true ? "foo" : "foo"
+!true ? "foo" : 0.5
+!true ? "foo" : i
+!true ? 1 : "foo"
+!true ? 1 : i64
+!true ? add : 0.5
+!true ? add : score
+!true ? array : f64
+!true ? array : list
+!true ? div : add
+!true ? f32 : false
 !true ? f64 : f64
-!true ? f64 : i32
 !true ? foo : 1
-!true ? greet : array
-!true ? greet : list
-!true ? half : add
-!true ? half : greet
-!true ? i32 : i64
-!true ? i64 : score
-!true ? list : div
+!true ? foo : array
+!true ? greet : ok
+!true ? greet : score
+!true ? greet : true
+!true ? half : f64
+!true ? i : 1
+!true ? i : add
+!true ? i : ok
+!true ? i32 : 1
+!true ? i64 : false
+!true ? i64 : i64
+!true ? i64 : list
+!true ? list : 0.5
+!true ? list : nil
 !true ? list : score
 !true ? nil : 0.5
-!true ? nil : f32
-!true ? nil : f64
-!true ? nil : foo
-!true ? nil : half
-!true ? nil : i
-!true ? ok : list
-!true ? score : array
-!true ? score : nil
-!true and ok
-!true or !false
-!true or nil != ok
+!true ? nil : false
+!true ? nil : ok
+!true ? ok : add
+!true ? ok : div
+!true ? score : false
+!true ? true : f32
+!true ? true : half
+!true and foo != nil
 !true || ok
+"bar" != "bar" || ok
 "bar" != foo.Bar
 "bar" != foo?.Bar
-"bar" != foo?.String()
-"bar" != nil and true ? i64 : 0.5
-"bar" + "foo" not endsWith greet("bar")
+"bar" + "bar" not in foo
 "bar" + foo.Bar
 "bar" + foo?.Bar
-"bar" + foo?.String()
 "bar" < foo.Bar
 "bar" < foo?.Bar
+"bar" < foo?.String()
 "bar" <= foo.Bar
 "bar" <= foo.String()
 "bar" <= foo?.Bar
 "bar" == foo.Bar
 "bar" == foo?.Bar
+"bar" == foo?.String()
+"bar" > "bar" or ok ? f32 : i64
 "bar" > foo.Bar
-"bar" > foo.String()
-"bar" > foo?.Bar
-"bar" contains "bar" == ok
-"bar" contains "foo" ? array : f64
+"bar" > foo?.String()
+"bar" >= foo.Bar
+"bar" >= foo.String()
+"bar" >= foo?.Bar
 "bar" contains foo.Bar
+"bar" contains foo.String()
 "bar" contains foo?.Bar
-"bar" contains foo?.String()
 "bar" endsWith foo.Bar
 "bar" endsWith foo?.Bar
 "bar" endsWith foo?.String()
-"bar" in foo || ok
-"bar" matches "bar" != ok
+"bar" matches "bar" and ok
 "bar" matches foo.Bar
+"bar" matches foo.String()
 "bar" matches foo?.Bar
+"bar" matches foo?.String()
 "bar" not contains foo.Bar
-"bar" not contains foo.String()
 "bar" not contains foo?.Bar
 "bar" not endsWith foo.Bar
 "bar" not endsWith foo?.Bar
 "bar" not endsWith foo?.String()
-"bar" not in list[i]
-"bar" not matches "foo" ? i32 < 0.5 : ok
 "bar" not matches foo.Bar
 "bar" not matches foo.String()
 "bar" not matches foo?.Bar
-"bar" not startsWith "foo" ? add : ok
+"bar" not matches foo?.String()
 "bar" not startsWith foo.Bar
 "bar" not startsWith foo?.Bar
+"bar" not startsWith foo?.String()
+"bar" startsWith "foo" or list == array
 "bar" startsWith foo.Bar
-"bar" startsWith foo?.Bar
-"foo" != "bar" != ok
+"bar" startsWith foo.String()
+"foo" != "foo" ? f64 : array
+"foo" != "foo" or ok
 "foo" != foo.Bar
+"foo" != foo.String()
 "foo" != foo?.Bar
 "foo" != foo?.String()
-"foo" + "foo" not in foo
+"foo" + "bar" not in foo
 "foo" + foo.Bar
-"foo" + foo.String()
 "foo" + foo?.Bar
 "foo" + foo?.String()
-"foo" < "bar" and i32 != 0.5
-"foo" < "foo" ? list : f32
+"foo" < "bar" and ok
 "foo" < foo.Bar
 "foo" < foo?.Bar
+"foo" < foo?.String()
 "foo" <= foo.Bar
 "foo" <= foo?.Bar
-"foo" == "foo" && i32 > 1
+"foo" == "bar" != ok
+"foo" == "bar" and ok
 "foo" == foo.Bar
-"foo" == foo.String()
+"foo" == foo?.Bar
 "foo" == foo?.String()
-"foo" == nil ? foo : f64
-"foo" > "bar" && ok
-"foo" > "foo" == not false
+"foo" > foo.Bar
+"foo" > foo.String()
 "foo" > foo?.Bar
-"foo" > foo?.String()
 "foo" >= foo.Bar
+"foo" >= foo.String()
 "foo" >= foo?.Bar
-"foo" contains foo.Bar
+"foo" >= foo?.String()
+"foo" contains "bar" == ok
 "foo" contains foo?.Bar
 "foo" endsWith foo.Bar
-"foo" endsWith foo.String()
 "foo" endsWith foo?.Bar
-"foo" endsWith foo?.String()
-"foo" in foo && nil == 1
-"foo" matches "bar" ? f64 > f64 : half
+"foo" matches "bar" ? add : div
+"foo" matches "foo" || true ? greet : "bar"
 "foo" matches foo.Bar
 "foo" matches foo.String()
 "foo" matches foo?.Bar
 "foo" not contains foo.Bar
 "foo" not contains foo?.Bar
+"foo" not contains foo?.String()
 "foo" not endsWith foo.Bar
 "foo" not endsWith foo?.Bar
-"foo" not endsWith foo?.String()
 "foo" not matches foo.Bar
-"foo" not matches foo.String()
 "foo" not matches foo?.Bar
+"foo" not matches foo?.String()
 "foo" not startsWith foo.Bar
+"foo" not startsWith foo?.Bar
 "foo" not startsWith foo?.String()
 "foo" startsWith foo.Bar
 "foo" startsWith foo?.Bar
-"foo" startsWith foo?.String()
-("bar" not endsWith "bar") and i64 < i32
-("bar" not endsWith "foo") == ok
-("bar" not in foo) == ok
-("foo" not matches "bar") and false ? f64 : array
-(0.5 * 0.5) ** f32
+("bar" not endsWith "bar") != ok
+("bar" not endsWith "foo") != ok
+("bar" not endsWith "foo") && false != nil
+("bar" not matches "foo") || reduce(list, ok)
+("foo" not matches "bar") == ok
 (0.5 * 0.5) ** i
-(0.5 * 0.5) ** i64
 (0.5 * 0.5) ^ f32
-(0.5 * 0.5) ^ i32
-(0.5 * f32) ** i
+(0.5 * 1) ** f64
+(0.5 * 1) ** i
+(0.5 * 1) ^ i32
 (0.5 * f64) ^ f32
-(0.5 * i32) ** f32
-(0.5 + 1) * i
-(0.5 + 1) ** i64
-(0.5 + 1) / i
+(0.5 * i) ^ i
+(0.5 + 0.5) * f32
+(0.5 + 0.5) ^ i32
+(0.5 + 1) ^ i
+(0.5 + f64) * f64
+(0.5 + f64) / i32
+(0.5 + i) ** i
+(0.5 + i) ^ i
+(0.5 + i64) ** f32
 (0.5 + i64) / f32
-(0.5 - 0.5) ^ half(f64)
-(0.5 - 1) * i64
-(0.5 - 1) ** i64
-(0.5 - f32) ** (0.5 * f64)
-(0.5 - f64) * f64
+(0.5 + i64) / i
+(0.5 - 0.5) * (i32 - 0.5)
+(0.5 - 0.5) * i64
+(0.5 - 0.5) ** f32
+(0.5 - 1) * i32
+(0.5 - 1) ** f64
+(0.5 - 1) ^ i64
+(0.5 - f32) ** i
+(0.5 - f64) * i
 (0.5 - f64) / f32
+(0.5 - f64) / f64
 (0.5 - i) ^ f32
-(0.5 - i32) ** i64
-(0.5 - i32) ^ f64
+(0.5 - i32) ** (i32 * 1)
+(0.5 - i32) / f64
+(0.5 - i32) ^ f32
+(0.5 - i64) * i
+(0.5 - i64) / f64
+(0.5 - i64) / i64
+(0.5 / 0.5) ** f32
+(0.5 / 0.5) ** i32
 (0.5 / 0.5) ^ f64
-(0.5 / f32) ** f32
-(0.5 / f32) ^ i32
-(0.5 / f64) ** i
-(0.5 / f64) ** i32
+(0.5 / 1) ^ f32
+(0.5 / i) ** f64
+(0.5 / i) ** i
 (0.5 / i32) ** i
-(0.5 / i64) ** f32
-(1 % i) ** f32
-(1 % i) ^ i
-(1 % i64) ** f32
-(1 * 1) ** f64
-(1 * 1) ^ i
-(1 * f32) ** f32
-(1 * i32) ** i
-(1 * i64) ** i32
-(1 + 0.5) * f64
-(1 + 0.5) ^ i32
-(1 + 1) / i32
-(1 + 1) ^ i
-(1 + f32) / f32 / i64
-(1 + f64) ** i64
-(1 + f64) / i32
-(1 + f64) ^ f64
-(1 + i32) / f32
-(1 + i64) / f64
-(1 - 0.5) / f64
-(1 - 0.5) ^ i32
-(1 - 1) * i
-(1 - 1) * i32
-(1 - 1) ** f32
-(1 - 1) / i
-(1 - f64) * 1 * i
-(1 - f64) ^ i32
-(1 - i) ** i
-(1 - i) / i64
-(1 - i32) ** i ^ 0.5
-(1 - i64) % i64
-(1 / 0.5) ^ f32
-(1 / 0.5) ^ f64
-(1 / 1) ** i32
-(1 / 1) ^ i32
-(1 / f64) ** f64
-(1 / i) ** i64
-(1 not in array) and none(list, true)
-(f32 * 1) ** f32
-(f32 * 1) ** i64
-(f32 * i) ^ i64
-(f32 * i32) ** i
-(f32 * i64) ** i64
-(f32 * i64) ^ i
-(f32 + 0.5) / 0.5 ** 0.5
-(f32 + 1) ** i
-(f32 + 1) / i
-(f32 + 1) / i64
-(f32 + i32) ** i64
-(f32 + i64) ** i32
-(f32 - 0.5) * f64
-(f32 - 0.5) * i
-(f32 - f32) ** f32
-(f32 - i) / f64
-(f32 - i) ^ i64
-(f32 - i64) * i64
-(f32 - i64) ** i64
-(f32 - i64) / i64
-(f32 / f64) ^ f32
-(f32 / f64) ^ i
-(f32 / i32) ^ i32
-(f64 * 0.5) ^ i
-(f64 * f64) ** i32
+(0.5 / i32) ^ f32
+(1 * 0.5) ** (f64 * 1)
+(1 * 0.5) ** i32
+(1 * 0.5) ^ f64
+(1 * 1) ^ -1
+(1 * 1) ^ f32
+(1 * f32) ^ i32
+(1 * i) ** i32
+(1 * i32) ^ i
+(1 * i64) ** i64
+(1 + 0.5) ** i
+(1 + 1) * i64
+(1 + 1) / i
+(1 + f32) ^ i
+(1 + f64) ^ i
+(1 + f64) ^ i32
+(1 + i) ** f32
+(1 + i) / f64
+(1 + i) ^ i64
+(1 + i32) * f64
+(1 + i32) ^ f64
+(1 - 0.5) * f32 ^ 1
+(1 - 0.5) * i64
+(1 - 0.5) / i
+(1 - 0.5) ^ min(f32)
+(1 - f32) * f32
+(1 - f64) ** f64
+(1 - i) * -i32
+(1 - i32) ^ f32
+(1 - i32) ^ i
+(1 - i64) ** f32
+(1 - i64) / f64
+(1 - i64) / i64
+(1 / 0.5) ** f32
+(1 / 0.5) ^ i32
+(1 / 1) ** (f64 * 0.5)
+(1 / 1) ^ ceil(i64)
+(1 / 1) ^ max(0.5)
+(1 / f32) ^ f32
+(1 / i) ^ f32
+(1 / i32) ^ i
+(1 / i64) ** i64
+(f32 * 0.5) ** f64
+(f32 * 0.5) ^ i32
+(f32 * f32) ^ -f32
+(f32 * f32) ^ i
+(f32 * i) ^ -1
+(f32 * i64) ** i
+(f32 + f64) * i
+(f32 + i) ^ f64
+(f32 - 0.5) / f64
+(f32 - 0.5) ^ f32
+(f32 - 1) / f64
+(f32 - 1) ^ f64
+(f32 - f32) / i64
+(f32 - i32) * i64
+(f32 / 0.5) ^ f32
+(f32 / i64) ^ f64
+(f64 * 0.5) ** f32
+(f64 * 0.5) ** i64
+(f64 * f32) ** f64
+(f64 * i64) ** f64
 (f64 * i64) ** i32
-(f64 + f32) ** i64
-(f64 + i32) * f32
-(f64 + i64) / i32
-(f64 - 0.5) * -i
-(f64 - 0.5) * i
-(f64 - 0.5) / f32
-(f64 - 0.5) / i64
-(f64 - 0.5) ^ i
-(f64 - 0.5) ^ i64
-(f64 - 1) * f32
-(f64 - f32) * i64
-(f64 - f64) / i32
-(f64 - i) * i32 ** 1
-(f64 - i64) / i64
-(f64 / 0.5) ** f64
-(f64 / i) ^ i64
-(false || ok) and ok
-(i % 1) ** -f32
-(i % 1) ** f64
-(i % i) ** f32
-(i * 1) ** i
-(i * f32) ** i32
-(i * f32) ^ f64
-(i * i) ^ count(array, true)
-(i + 0.5) ** i32
-(i + 0.5) ^ f32
-(i + 1) % i32
+(f64 + 0.5) * f32
+(f64 + 0.5) * i64
+(f64 + f32) ** get(array, i)
+(f64 + f32) ** i32
+(f64 + f64) * (i64 - i64)
+(f64 + f64) ^ f64
+(f64 + i) * (0.5 + i64)
+(f64 + i32) ^ i64
+(f64 + i64) ^ i
+(f64 - 0.5) ** f64
+(f64 - 1) ** i64
+(f64 - 1) ^ i32
+(f64 - f32) ** i
+(f64 - f32) ^ i64
+(f64 - i) * i32
+(f64 - i32) / i
+(f64 - i64) ** i
+(f64 - i64) / f32
+(f64 - i64) / f64
+(f64 / 1) ** i64
+(f64 / f32) ^ i
+(f64 / f64) ** i32
+(f64 / f64) ^ i32 ** 0.5
+(false || ok) == ok
+(i % i) ^ i
+(i % i32) ^ (1 - i32)
+(i % i64) ^ f64
+(i * 0.5) ** f32
+(i * 1) ^ f64
+(i * 1) ^ i
+(i * i64) ** f32
+(i + 0.5) ** half(f64)
+(i + 1) % i64
 (i + 1) / i64
-(i + f64) ^ (f32 * f64)
-(i + i) * -f64
-(i + i32) ^ i64
-(i - 0.5) / f32
-(i - 0.5) ^ f64
-(i - 1) ** i64
-(i - 1) / f32
-(i - 1) ^ f64
-(i - i64) ** f64
-(i - i64) ^ i
-(i / 0.5) ^ i32
-(i / 1) ** f64
-(i / 1) ** i64
-(i / i32) ^ f32
-(i < i32 ? nil : f64) ** f64
-(i32 * 1) ** f32
-(i32 * f32) ^ i64
-(i32 * i) ^ i
-(i32 * i32) ** f64
-(i32 + 0.5) / f64
-(i32 + 0.5) ^ i64
-(i32 + 1) * f64
-(i32 + 1) ** float(1)
-(i32 + 1) / i
-(i32 + 1) / i64
-(i32 + f32) ** f32
-(i32 + f64) ** i
-(i32 + i32) * i32
-(i32 + i32) / i64
-(i32 + i64) ^ i
-(i32 - 0.5) * i64
-(i32 - f32) * i32
-(i32 - i32) ** i
-(i32 - i32) ** i64
-(i32 / 0.5) ^ i32
-(i32 / i32) ^ f32
-(i32 / i32) ^ i
-(i64 * 0.5) ^ f32
-(i64 * 1) ** i64
-(i64 * 1) ^ f32
-(i64 * 1) ^ f64
-(i64 * f32) ** findIndex(list, ok)
-(i64 + 1) * i32
-(i64 + f32) ^ f64
-(i64 + f64) / 1 * 1
-(i64 + f64) ^ f64
-(i64 + i) ^ i64
-(i64 + i32) * f32
-(i64 - 0.5) * i64
-(i64 - 0.5) / i32
-(i64 - i) % i32
-(i64 - i32) / len(array)
-(i64 - i64) / i64
-(i64 / f64) ** f32
-(i64 / i32) ** f32
-(i64 / i32) ** i
-(i64 / i32) ^ -1
-(i64 not in array) && ok
-(ok && ok) == ok
-(ok or false) and ok
-(ok or ok) == not false
-(ok || true) && i32 >= f64
+(i + i) ^ i64
+(i + i32) * i64 ^ f64
+(i + i32) / i32
+(i + i32) ^ f32
+(i + i64) ^ i32
+(i - 0.5) / i64
+(i - 1) ^ i64
+(i / 0.5) ** f32
+(i / f32) ^ f64
+(i32 % 1) ** f32
+(i32 % i) ** f32
+(i32 % i32) ** i32
+(i32 % i32) ^ i32
+(i32 * 0.5) ^ f32
+(i32 * 1) ^ i32
+(i32 + 0.5) ** i64
+(i32 + f32) * i64
+(i32 + f64) / i
+(i32 + i) / i
+(i32 + i32) ^ i32
+(i32 - 0.5) * f64
+(i32 - 0.5) / i64
+(i32 - 1) ^ f64
+(i32 - f32) / i64
+(i32 - i) % i64
+(i32 - i) / f32
+(i32 - i32) ^ (i32 * i)
+(i32 - i64) * i32
+(i32 - i64) * i32 * i64
+(i32 / i) ** f32
+(i32 / i) ^ i64
+(i32 < f64 ? nil : i) .. i32
+(i32 not in array) and ok
+(i64 % i) ** f32
+(i64 * 0.5) ^ f64
+(i64 * f32) ^ i64
+(i64 * f64) ^ i32
+(i64 * i) ** score(1)
+(i64 * i64) ** i ** 0.5
+(i64 * i64) ^ i
+(i64 + 0.5) * f32
+(i64 + 0.5) ** i64
+(i64 + 1) % i
+(i64 + 1) ^ i
+(i64 + f32) * -i32
+(i64 + f32) ** i32
+(i64 + f32) / f64
+(i64 + f32) / i
+(i64 + f32) / i32
+(i64 + f64) * i32
+(i64 + i) % i64
+(i64 + i) / f64
+(i64 + i32) * i64
+(i64 + i64) / i64
+(i64 - 0.5) / f64
+(i64 - 0.5) ^ i64
+(i64 - 1) ^ i32
+(i64 - f32) ** f64
+(i64 - f32) ^ i64
+(i64 - i) ** i
+(i64 - i32) * i64
+(i64 / 1) ** f32
+(i64 / f64) ** i32
+(nil not in array) || ok
+(ok || true) && (ok or true)
+-((i64 + 1) % i32)
 -(0.5 * 0.5)
 -(0.5 * 1)
 -(0.5 * f32)
@@ -1003,7 +1081,6 @@
 -(0.5 - i32)
 -(0.5 - i64)
 -(0.5 / 0.5)
--(0.5 / 0.5) < i32
 -(0.5 / 1)
 -(0.5 / f32)
 -(0.5 / f64)
@@ -1024,6 +1101,7 @@
 -(1 * 0.5)
 -(1 * 1)
 -(1 * f32)
+-(1 * f64)
 -(1 * i)
 -(1 * i32)
 -(1 * i64)
@@ -1081,12 +1159,10 @@
 -(f32 + f32)
 -(f32 + f64)
 -(f32 + i)
--(f32 + i32)
 -(f32 + i64)
 -(f32 - 0.5)
 -(f32 - 1)
--(f32 - f64)
--(f32 - i - f32)
+-(f32 - f32)
 -(f32 - i)
 -(f32 - i32)
 -(f32 - i64)
@@ -1100,6 +1176,7 @@
 -(f32 ^ 0.5)
 -(f32 ^ 1)
 -(f32 ^ f32)
+-(f32 ^ f64)
 -(f32 ^ i)
 -(f32 ^ i32)
 -(f32 ^ i64)
@@ -1116,7 +1193,6 @@
 -(f64 ** f64)
 -(f64 ** i)
 -(f64 ** i32)
--(f64 ** i32) > i32
 -(f64 ** i64)
 -(f64 + 0.5)
 -(f64 + 1)
@@ -1129,14 +1205,12 @@
 -(f64 - f32)
 -(f64 - f64)
 -(f64 - i)
--(f64 - i32)
 -(f64 - i64)
 -(f64 / 0.5)
 -(f64 / 1)
 -(f64 / f32)
 -(f64 / f64)
 -(f64 / i)
--(f64 / i32)
 -(f64 / i64)
 -(f64 ^ 0.5)
 -(f64 ^ 1)
@@ -1149,7 +1223,6 @@
 -(i % i)
 -(i % i32)
 -(i % i64)
--(i % score(1))
 -(i * 0.5)
 -(i * 1)
 -(i * f32)
@@ -1157,37 +1230,38 @@
 -(i * i)
 -(i * i32)
 -(i * i64)
+-(i ** 0.5)
 -(i ** 1)
--(i ** f32)
 -(i ** f64)
 -(i ** i)
 -(i ** i32)
 -(i ** i64)
--(i ** int(i))
 -(i + 0.5)
 -(i + 1)
--(i + f32)
--(i + f64)
--(i + i)
+-(i + i32)
 -(i + i64)
 -(i - 0.5)
 -(i - 1)
 -(i - f32)
 -(i - f64)
+-(i - i ** 1)
 -(i - i)
 -(i - i32)
+-(i - i64)
 -(i / 0.5)
 -(i / 1)
 -(i / f32)
 -(i / f64)
 -(i / i)
 -(i / i32)
+-(i / i64)
 -(i ^ 0.5)
 -(i ^ 1)
 -(i ^ f32)
 -(i ^ f64)
 -(i ^ i)
--(i32 % 1 % i)
+-(i ^ i32)
+-(i ^ i64)
 -(i32 % 1)
 -(i32 % i)
 -(i32 % i32)
@@ -1202,11 +1276,11 @@
 -(i32 ** 0.5)
 -(i32 ** 1)
 -(i32 ** f32)
+-(i32 ** f64)
 -(i32 ** i)
 -(i32 ** i32)
 -(i32 ** i64)
 -(i32 + 0.5)
--(i32 + 1 ^ i64)
 -(i32 + 1)
 -(i32 + f32)
 -(i32 + f64)
@@ -1222,7 +1296,6 @@
 -(i32 - i64)
 -(i32 / 0.5)
 -(i32 / 1)
--(i32 / f32)
 -(i32 / f64)
 -(i32 / i)
 -(i32 / i32)
@@ -1232,6 +1305,8 @@
 -(i32 ^ f32)
 -(i32 ^ f64)
 -(i32 ^ i)
+-(i32 ^ i32)
+-(i32 ^ i64)
 -(i64 % 1)
 -(i64 % i)
 -(i64 % i32)
@@ -1254,17 +1329,16 @@
 -(i64 + 1)
 -(i64 + f32)
 -(i64 + f64)
--(i64 + i)
 -(i64 + i32)
 -(i64 + i64)
 -(i64 - 0.5)
 -(i64 - 1)
+-(i64 - f32)
 -(i64 - f64)
 -(i64 - i)
 -(i64 - i32)
 -(i64 - i64)
 -(i64 / 0.5)
--(i64 / 1 / 1)
 -(i64 / 1)
 -(i64 / f32)
 -(i64 / f64)
@@ -1278,248 +1352,285 @@
 -(i64 ^ i)
 -(i64 ^ i32)
 -(i64 ^ i64)
--(max(0.5) + i64)
---(1 * i64)
---(i64 * 1)
----1
----i
+-(max(f32) ^ i32)
+-(min(0.5) ^ i32)
+--(f64 ** 0.5)
+--(i64 ** i64)
 --0.5
 --1
---abs(f64)
+--ceil(1)
 --f32
 --f64
+--f64 ** i64
+--float(f64)
 --i
 --i32
 --i64
---max(0.5)
--0.5 != 1 ? array : f64
 -0.5 != f32
--0.5 != f64 ** 0.5
 -0.5 != i32
--0.5 != max(i64)
+-0.5 * 1 ** 1
+-0.5 * f32
 -0.5 * f64
--0.5 * i
 -0.5 * i32
 -0.5 * i64
--0.5 * len(array)
+-0.5 ** -1
+-0.5 ** ceil(i)
 -0.5 ** f32
+-0.5 ** f64
 -0.5 ** i
 -0.5 ** i32
 -0.5 ** i64
--0.5 + f32
 -0.5 + f64
--0.5 + f64 / f64
 -0.5 + i
 -0.5 + i32
--0.5 - -i32
--0.5 - 1 + 1
+-0.5 + i64
+-0.5 - abs(i)
 -0.5 - f32
 -0.5 - f64
 -0.5 - i
 -0.5 - i32
--0.5 - i32 * i
--0.5 / (f32 + 0.5)
--0.5 / -i32
+-0.5 - i64
 -0.5 / f32
--0.5 / f64
--0.5 / float(f64)
 -0.5 / i
--0.5 / i64
--0.5 / i64 ** 1
--0.5 < f32
--0.5 < f64
+-0.5 / i32
 -0.5 < i32
--0.5 < i32 ? false : "bar"
--0.5 < i32 ^ f64
--0.5 <= 1 == false
+-0.5 < i64
+-0.5 <= 0.5 + 0.5
 -0.5 <= f32
--0.5 <= f64
--0.5 <= f64 + f32
+-0.5 <= i
+-0.5 <= i32
 -0.5 <= i64
 -0.5 == f32
--0.5 == f64 / 0.5
+-0.5 == f64
 -0.5 == i
 -0.5 == i32
+-0.5 == i32 ^ i32
 -0.5 == i64
 -0.5 > f32
--0.5 > f64
--0.5 > i32
--0.5 > i64
+-0.5 > i
+-0.5 >= f32
+-0.5 >= f32 ? f32 : i32
 -0.5 >= f64
 -0.5 >= i
 -0.5 >= i32
 -0.5 >= i64
 -0.5 ^ f32
 -0.5 ^ f64
--0.5 ^ i
+-0.5 ^ float(f64)
 -0.5 ^ i32
 -0.5 ^ i64
+-0.5 in array
+-0.5 not in sort(array)
+-1 != -i
+-1 != f32
 -1 != f64
--1 != i
+-1 != i32
 -1 != i64
--1 != i64 * f32
+-1 % i
 -1 % i32
--1 % i64
--1 * 1 ** i64
+-1 * array[i]
 -1 * f32
+-1 * f64
+-1 * i
 -1 * i32
 -1 * i64
+-1 ** (f32 + f32)
+-1 ** (i + i64)
+-1 ** ceil(0.5)
 -1 ** f32
+-1 ** f64
 -1 ** i
--1 ** i64
--1 + 1 + 0.5
+-1 ** i64 ^ 1
+-1 + -i32
 -1 + f32
--1 + half(f64)
+-1 + f64
 -1 + i
+-1 + i32
 -1 + i64
--1 - f32
+-1 + reduce(array, #)
+-1 + reduce(list, f32)
+-1 - f64
 -1 - i
+-1 - i % i32
 -1 - i32
 -1 - i64
 -1 .. i
--1 .. i32
 -1 .. i64
--1 / 1 * 1
 -1 / f32
+-1 / f64
+-1 / i
 -1 / i32
--1 < 0.5 ^ i64
--1 < f32
--1 < f64 * 1
--1 < i32
+-1 < f64
+-1 < i
 -1 < i64
--1 <= f32
--1 <= f32 == true
+-1 <= -1
 -1 <= f64
+-1 <= i
 -1 <= i32
+-1 <= i64
 -1 == f32
 -1 == f64
--1 == nil != nil
--1 > -i32
+-1 == floor(f64)
+-1 == i
+-1 == i32
+-1 == i64
 -1 > f32
--1 > half(0.5)
 -1 > i
--1 > i32
 -1 > i64
--1 > i64 ? array : nil
--1 >= 0.5 * 0.5
--1 >= f32
+-1 >= f32 * f32
 -1 >= f64
 -1 >= i32
--1 >= i32 - 1
 -1 >= i64
 -1 ^ f32
 -1 ^ f64
+-1 ^ i32
 -1 ^ i64
 -1 in array
 -1 not in array
--abs(0.5 * f64)
 -abs(0.5)
 -abs(1)
--abs(1) .. i
 -abs(f32)
 -abs(f64)
 -abs(i)
 -abs(i32)
 -abs(i64)
--add(1, 1)
 -add(i, 1)
+-add(i, i)
 -array[1]
 -array[i32]
 -array[i64]
 -array[i]
+-bitand(i64, i32)
+-bitnand(1, i)
+-bitnot(1)
+-bitnot(i)
+-bitnot(i32)
+-bitnot(i64)
+-bitor(1, i64)
+-bitor(i, i32)
+-bitshl(i, 1)
+-bitshl(i, i32)
+-bitshl(i, i64)
+-bitshl(i64, i32)
+-bitshr(i, i)
+-bitshr(i64, i32)
+-bitushr(i, i32)
+-bitxor(1, 1)
+-bitxor(i, i32)
+-ceil(0.5)
+-ceil(1)
+-ceil(f32)
+-ceil(f64)
+-ceil(i)
+-ceil(i32)
+-ceil(i64)
 -count(array, false)
 -count(array, ok)
 -count(array, true)
 -count(list, ok)
 -count(list, true)
 -div(1, 1)
--div(1, i)
--div(i, i)
 -f32
--f32 != 1 / i
--f32 != f32
--f32 != f64
--f32 != i64
--f32 * 1 ** i32
--f32 * f32
+-f32 != i32
+-f32 * i64
+-f32 ** (i + 1)
 -f32 ** f32
--f32 ** f32 ** 1
+-f32 ** f64
+-f32 ** i
+-f32 ** i32
 -f32 ** i64
--f32 + f32
 -f32 + i32
--f32 + i64
--f32 - f32
--f32 - f64
 -f32 - i
--f32 - i32
--f32 - i64
+-f32 - round(i)
 -f32 / f32
--f32 / i32
--f32 / i64
+-f32 / f64
+-f32 / i
+-f32 < f32 ** 0.5
 -f32 < f64
+-f32 < i
 -f32 < i32
--f32 < i64
+-f32 <= f32
 -f32 <= i
 -f32 <= i32
+-f32 <= i64
 -f32 == f32
 -f32 == f64
--f32 == i
--f32 == i32
--f32 == i64
+-f32 > 0.5 ? f32 : "bar"
 -f32 > f32
 -f32 > f64
--f32 > i
--f32 > i64
--f32 >= 1 / f32
 -f32 >= f32
 -f32 >= f64
 -f32 >= i64
--f32 ^ f32
--f32 ^ f64
+-f32 ^ i
+-f32 ^ i32
 -f32 ^ i64
--f32 ^ min(f64)
+-f32 in array
+-f32 not in array
 -f64
+-f64 != f32
 -f64 != f64
 -f64 != i
--f64 != i64
+-f64 != i32
+-f64 * -1
+-f64 * -f64
+-f64 * f32
 -f64 * f64
+-f64 * i
+-f64 * i32
+-f64 * i64
+-f64 ** 0.5 ** f32
 -f64 ** f32
+-f64 ** i
 -f64 ** i32
--f64 ** i64
 -f64 + f32
--f64 + i32
 -f64 + i64
--f64 - 0.5 / i32
--f64 - f64
+-f64 - 0.5 / i64
+-f64 - f32
+-f64 - i
 -f64 - i32
+-f64 - i64
+-f64 - int(f64)
+-f64 / f32
 -f64 / f64
 -f64 / i
+-f64 / i32
 -f64 / i64
--f64 < f32
+-f64 < 0.5 ^ f32
+-f64 < f64
+-f64 < f64 ** 1
+-f64 < half(0.5)
+-f64 < half(f64)
 -f64 < i
+-f64 < i ^ f32
+-f64 < i32
+-f64 < i64
 -f64 <= f32
 -f64 <= f64
--f64 <= i32
--f64 == f32
+-f64 == f64
 -f64 == i
 -f64 == i32
+-f64 == i64
+-f64 > f32
+-f64 > f32 ? false : array
 -f64 > f64
 -f64 > i32
 -f64 > i64
+-f64 >= f32
+-f64 >= f32 / f64
 -f64 >= f64
--f64 >= f64 ^ 0.5
--f64 >= i
--f64 ^ 0.5 ** i64
+-f64 >= i32
 -f64 ^ f32
 -f64 ^ f64
--f64 ^ i
--f64 ^ i32
 -f64 ^ i64
+-f64 not in array
 -find(array, ok)
 -find(array, true)
+-findIndex(array, # <= #)
 -findIndex(array, ok)
 -findIndex(array, true)
 -findIndex(list, ok)
+-findIndex(list, true)
+-findLast(array, # <= #)
 -findLast(array, ok)
 -findLast(array, true)
 -findLastIndex(array, ok)
@@ -1527,847 +1638,971 @@
 -findLastIndex(list, ok)
 -findLastIndex(list, true)
 -first(array)
--float(-1)
+-float(0.5 ** 0.5)
+-float(0.5 ^ 0.5)
 -float(0.5)
 -float(1)
--float(f32 ** 0.5)
+-float(bitnot(i64))
 -float(f32)
 -float(f64)
 -float(i)
 -float(i32)
 -float(i64)
+-floor(0.5)
+-floor(1)
+-floor(f32)
+-floor(f64)
+-floor(i)
+-floor(i32)
+-floor(i64)
 -get(array, 1)
 -get(array, i)
 -get(array, i32)
 -get(array, i64)
+-half(-0.5)
 -half(-1)
 -half(0.5)
+-half(1)
+-half(f32 + i64)
 -half(f64)
+-half(median(array))
 -i
+-i != f32
 -i != f64
+-i != f64 ? foo : 1
+-i != i
+-i != i + f64
 -i != i32
--i != i32 * 1
 -i != i64
--i % i
 -i % i32
 -i % i64
--i * f32
+-i * abs(0.5)
 -i * f64
--i * i32
+-i * i
 -i * i64
+-i * reduce(array, 0.5)
 -i ** f32
 -i ** f64
--i ** i32
--i ** i64
+-i ** i
 -i + f32
--i + i
+-i + f64
 -i + i32
--i + i64
+-i + i64 * 1
 -i - f32
--i - f64
--i - i
 -i - i64
--i .. i32
--i / f64
--i / i
--i / i32
+-i .. i
+-i .. i64
+-i / f32
 -i / i64
 -i < f32
+-i < half(1)
+-i < i
 -i < i64
+-i <= 0.5 ? half : "bar"
+-i <= 1 - 0.5
 -i <= f32
+-i <= i
 -i <= i32
--i == -0.5
--i == 1 ** f64
--i == 1 + 0.5
+-i <= i64
+-i <= i64 ** 0.5
+-i == f32
+-i == f64
+-i == f64 ^ f32
+-i == i
+-i == i32
 -i > f32
 -i > i
 -i > i32
 -i >= f32
--i >= i32
--i ^ -i
+-i >= f64
+-i >= i
+-i >= i64
+-i >= score(1)
+-i ^ 0.5 ** 0.5
+-i ^ f32
+-i ^ f32 ^ 0.5
 -i ^ f64
--i ^ i32
+-i ^ i
+-i ^ i64
+-i in array
 -i not in array
 -i32
 -i32 != f32
--i32 != f64
 -i32 != i
+-i32 != i32 ** 1
 -i32 != i64
+-i32 % i
 -i32 % i32
 -i32 % i64
--i32 * f32
--i32 * f64
 -i32 * i
 -i32 * i32
+-i32 * i64
+-i32 ** f32
 -i32 ** f64
--i32 ** i32
 -i32 ** i64
--i32 + 1 + i
 -i32 + f32
--i32 + f64
 -i32 + i
 -i32 + i32
--i32 - i32
--i32 - i64
--i32 .. i
--i32 .. i64
--i32 / (i32 - f64)
--i32 / f64
--i32 / i
--i32 < 0.5 * 1
--i32 < f32
--i32 < f64 - f64
+-i32 - f32
+-i32 .. i32
+-i32 / i32
+-i32 / i64
+-i32 < i
 -i32 < i32
 -i32 < i64
--i32 <= 0.5 ? f64 : 1
--i32 <= f32
+-i32 < round(f64)
 -i32 <= f64
--i32 <= f64 + i
+-i32 <= i
+-i32 <= i32
+-i32 <= i64
+-i32 == 1 % i
 -i32 == f32
--i32 == i32
+-i32 == f64
+-i32 == i64
+-i32 == max(1)
+-i32 > f32
+-i32 > f64
 -i32 > i
+-i32 > i ** 0.5
 -i32 > i32
 -i32 > i64
--i32 >= f32
 -i32 >= f64
--i32 >= i64
--i32 ^ (i - 0.5)
--i32 ^ i
+-i32 >= i
+-i32 >= i == nil
+-i32 >= i32
+-i32 ^ f32
 -i32 ^ i32
 -i32 ^ i64
--i32 ^ i64 ** i32
+-i32 ^ score(1)
 -i32 in array
--i32 not in array
 -i64
--i64 != i
--i64 != i ? i : foo
+-i64 != f32
+-i64 != f64
+-i64 != i32
 -i64 != i64
--i64 % i
--i64 % i32
+-i64 != i64 ? score : foo
+-i64 * (1 + f64)
 -i64 * f32
--i64 * f64
 -i64 * i
 -i64 * i32
 -i64 * i64
--i64 ** f64
--i64 ** i64
--i64 + 0.5 * i32
--i64 + f64
+-i64 * indexOf("foo", "bar")
+-i64 ** i
+-i64 ** i32
+-i64 + f32
 -i64 + i
+-i64 + i32
+-i64 + i64
 -i64 - f32
--i64 - f64
+-i64 - i
 -i64 - i32
--i64 - i64
 -i64 .. i
 -i64 .. i32
--i64 / f32
--i64 / i
--i64 / i64
--i64 / i64 * f32
--i64 < -0.5
+-i64 .. i64
+-i64 / f64
+-i64 / i32
 -i64 < f32
 -i64 < f64
--i64 < i
+-i64 < half(f64)
 -i64 < i32
 -i64 < i64
+-i64 <= i
 -i64 <= i32
--i64 <= i64
+-i64 == 1 ^ i64
 -i64 == f32
+-i64 == f64
 -i64 == i
 -i64 == i32
--i64 == i64
 -i64 > f32
 -i64 > f64
+-i64 > i
 -i64 > i32
+-i64 >= f32
 -i64 >= i
 -i64 >= i32
--i64 >= i64
 -i64 ^ f64
+-i64 ^ float(i)
+-i64 ^ i
 -i64 ^ i32
 -i64 ^ i64
+-i64 in array
 -i64 not in array
--i64 not in sort(array)
 -int(0.5)
 -int(1)
 -int(f32)
 -int(f64)
 -int(i)
 -int(i32)
--int(i64 - i)
 -int(i64)
--int(int(1))
 -last(array)
 -len("bar")
 -len("foo")
--len([foo])
 -len(array)
--len(false ? greet : "foo")
 -len(list)
--max(0.5 * i)
 -max(0.5)
--max(0.5, 1)
+-max(0.5, 0.5, f64)
 -max(1)
 -max(f32)
--max(f32, 0.5, f32)
--max(f32, i64)
 -max(f64)
 -max(i)
--max(i, 1)
--max(i, i64)
+-max(i, 0.5)
+-max(i32 - 1)
 -max(i32)
--max(i32, 0.5)
+-max(i32, f32)
+-max(i64 * 0.5)
 -max(i64)
--max(score(1))
+-max(i64, f64)
+-max(i64, i)
+-mean(array)
+-median(array)
+-min(-1)
 -min(0.5)
--min(0.5, 1)
--min(0.5, i32)
 -min(1)
--min(1, f32)
+-min(1, 0.5)
 -min(f32)
--min(f32, 0.5)
+-min(f32, 1)
 -min(f64)
--min(f64, 0.5)
--min(f64, f32)
--min(f64, i64)
+-min(float(0.5))
 -min(i)
--min(i, i)
+-min(i, 1)
 -min(i32)
--min(i32, 1)
--min(i32, f64)
+-min(i32, 0.5)
 -min(i64)
--min(i64, f32)
--min(i64, f64)
+-min(i64, i, 0.5)
+-reduce(array, #)
+-reduce(array, -#)
+-reduce(array, 0.5)
+-reduce(array, 1)
+-reduce(array, 1) - f32
+-reduce(array, f64)
+-reduce(array, i)
+-reduce(array, i32)
+-reduce(array, i64)
+-reduce(list, 0.5)
+-reduce(list, 1)
+-reduce(list, f32)
+-reduce(list, f64)
+-reduce(list, i)
+-reduce(list, i32)
+-round(0.5)
+-round(1)
+-round(f32)
+-round(f64)
+-round(i)
+-round(i32)
+-round(i64)
 -score(1)
 -score(1, 1)
 -score(1, i)
 -score(i)
--score(i, 1)
--score(i32 * i)
-0.5 != 0.5 ? f64 : half
-0.5 != 0.5 ? i64 : f64
-0.5 != 0.5 ? list : array
-0.5 != 0.5 or ok
-0.5 != f32 || 0.5 > 0.5
-0.5 != i && i64 > 1
-0.5 != i64 != ok
-0.5 != i64 ? -f32 : add
-0.5 != nil or ok
-0.5 * 0.5 != i / 1
-0.5 * 0.5 * i
-0.5 * 0.5 * i32
-0.5 * 0.5 + i32
-0.5 * 0.5 - i
+-score(i32 + i)
+-score(int(i))
+-sum(array)
+-sum(i .. 1)
+0.5 != 0.5 == ok
+0.5 != f64 ? list : f32
+0.5 != f64 and !true
+0.5 != f64 and ok
+0.5 != i == ok
+0.5 != i32 && ok
+0.5 != i32 == ok
+0.5 != i32 ? ok : ok
+0.5 != i32 and 1 > f64
+0.5 != nil == ok
+0.5 * 0.5 * f64
+0.5 * 0.5 / f32
 0.5 * 0.5 / f64
-0.5 * 0.5 / i32
-0.5 * 0.5 < f32
-0.5 * 0.5 < i
-0.5 * 0.5 > i32
-0.5 * 1 + f32
-0.5 * 1 + half(f64)
-0.5 * 1 < f64
-0.5 * 1 > f64
+0.5 * 0.5 < f64
+0.5 * 0.5 >= i64
+0.5 * 1 * i64
+0.5 * 1 <= f32
 0.5 * 1 > i32
-0.5 * f32 / i64
+0.5 * 1 not in array
+0.5 * f32 * f32
+0.5 * f32 * i32
+0.5 * f32 + f32
+0.5 * f32 - f64
+0.5 * f32 / half(1)
 0.5 * f32 == i32
-0.5 * f64 * f64
-0.5 * f64 + i64
-0.5 * f64 > i
-0.5 * f64 >= i
-0.5 * f64 >= i64
-0.5 * i - i
-0.5 * i / i64
-0.5 * i / i64 ^ 0.5
-0.5 * i == f32
-0.5 * i32 < i32
-0.5 * i32 in [f64]
-0.5 * i64 != f32
-0.5 * i64 != i
-0.5 * i64 + f32
-0.5 * i64 <= i64
-0.5 ** 0.5 != i
-0.5 ** 0.5 ** f32
-0.5 ** 0.5 / f32
-0.5 ** 0.5 / i
-0.5 ** 0.5 < i / i32
-0.5 ** 0.5 == f32
-0.5 ** 0.5 == i32
-0.5 ** 1 + i64
-0.5 ** 1 / f32
-0.5 ** f32 < 1 / f64
-0.5 ** f32 < i
-0.5 ** f32 < i32
-0.5 ** f32 < min(i64)
-0.5 ** f32 == f64
-0.5 ** f32 ^ f32
-0.5 ** f32 ^ i64
-0.5 ** f64 * f32
-0.5 ** f64 + -i
-0.5 ** i * 0.5 ** i
-0.5 ** i < f32
-0.5 ** i <= i32
-0.5 ** i > f32
-0.5 ** i ^ f64
-0.5 ** i32 != f64
-0.5 ** i32 <= i32
-0.5 ** i32 ^ f32
-0.5 ** i64 != f32
-0.5 ** i64 - f32
-0.5 ** i64 - i64
-0.5 ** i64 ^ min(i)
-0.5 + 0.5 != i32
-0.5 + 0.5 - f32
-0.5 + 0.5 - i64
-0.5 + 0.5 < 1 ? f32 : score
-0.5 + 0.5 <= f32
-0.5 + 0.5 == f64
-0.5 + 0.5 > i64
-0.5 + 0.5 >= i64
-0.5 + 1 != i
-0.5 + 1 < f32
-0.5 + 1 >= i
-0.5 + f32 != i
-0.5 + f32 != i + i64
-0.5 + f32 >= i
-0.5 + f64 == i32
-0.5 + f64 > f64
-0.5 + i > f32
-0.5 + i32 + i64
-0.5 + i32 < f32
-0.5 + i64 + f64
-0.5 + i64 < f64
-0.5 + i64 <= 0.5 + 1
-0.5 + i64 == i32
-0.5 + i64 >= i64
-0.5 - 0.5 != i64
-0.5 - 0.5 + i32
-0.5 - 0.5 - f64
-0.5 - 0.5 < 0.5 * f32
-0.5 - 0.5 == f32
-0.5 - 1 != i ? "foo" : div
-0.5 - 1 + f32
-0.5 - 1 - f64
-0.5 - 1 <= i32
-0.5 - 1 <= i64
-0.5 - f32 + i
-0.5 - f64 <= i32
-0.5 - i - i32
-0.5 - i > f64
-0.5 - i > i
-0.5 - i32 + 0.5 ^ i
-0.5 - i32 + f32
-0.5 - i32 < i
-0.5 - i32 <= i64
-0.5 - i64 == f64
-0.5 - i64 > f32
-0.5 - i64 >= f64
-0.5 - i64 >= i
-0.5 / 0.5 != i32
-0.5 / 0.5 / i
-0.5 / 0.5 / i32
-0.5 / 0.5 < i
-0.5 / 0.5 == i
-0.5 / 0.5 >= i32
-0.5 / 0.5 >= min(i32)
-0.5 / 1 != i32 == nil
-0.5 / 1 - i
-0.5 / 1 < f32
-0.5 / 1 < i32
-0.5 / 1 == i64
-0.5 / 1 > 1 ** 0.5
-0.5 / f32 != i32
+0.5 * f32 > i
+0.5 * f64 != i64
+0.5 * f64 < i
+0.5 * f64 <= i
+0.5 * i + i
+0.5 * i + mean(array)
+0.5 * i - i32
+0.5 * i == 0.5 ? ok : ok
+0.5 * i32 / f32
+0.5 * i64 < f64
+0.5 * i64 == 1 ** i64
+0.5 ** 0.5 != i64
+0.5 ** 0.5 * max(1)
+0.5 ** 0.5 ** i64
+0.5 ** 0.5 + -f32
+0.5 ** 0.5 < f64
+0.5 ** 0.5 == i
+0.5 ** 0.5 ^ f32
+0.5 ** 0.5 not in array
+0.5 ** 1 != i
+0.5 ** 1 != i32
+0.5 ** 1 - f64
+0.5 ** 1 / f64
+0.5 ** 1 / i32
+0.5 ** 1 ^ i64
+0.5 ** f32 + f32 / i64
+0.5 ** f32 <= f32
+0.5 ** f32 ^ i
+0.5 ** f64 * f64
+0.5 ** f64 > f64 ? 1 : nil
+0.5 ** f64 >= i64
+0.5 ** i / i
+0.5 ** i > i
+0.5 ** i32 * i32
+0.5 ** i32 > f64
+0.5 ** i32 >= mean(array)
+0.5 + 0.5 != i
+0.5 + 0.5 == i32
+0.5 + 0.5 > f32
+0.5 + 1 != f64
+0.5 + 1 + i32
+0.5 + 1 - i32
+0.5 + 1 < float(1)
+0.5 + 1 == f32
+0.5 + f32 - i64
+0.5 + f32 <= ceil(f32)
+0.5 + f32 <= i32
+0.5 + f32 > f32
+0.5 + f64 != i64
+0.5 + f64 <= i32
+0.5 + f64 == 1 / 0.5
+0.5 + i + i
+0.5 + i > i64
+0.5 + i in array
+0.5 + i32 - i64
+0.5 + i32 <= f32
+0.5 + i64 - i
+0.5 + i64 > i64 * 0.5
+0.5 - 0.5 - i32
+0.5 - 0.5 >= f32
+0.5 - 0.5 >= i
+0.5 - 0.5 >= i32
+0.5 - 1 + i
+0.5 - 1 + i / i
+0.5 - 1 <= f64
+0.5 - f32 != i64
+0.5 - f32 >= i64
+0.5 - f64 - f32
+0.5 - f64 < i
+0.5 - f64 in array
+0.5 - i != i64
+0.5 - i + i
+0.5 - i > f32
+0.5 - i32 != f32
+0.5 - i64 + -f64
+0.5 - i64 == i
+0.5 - i64 not in array
+0.5 / 0.5 + i
+0.5 / 0.5 - i
+0.5 / 0.5 - i32
+0.5 / 0.5 - i64
+0.5 / 0.5 / half(0.5)
+0.5 / 0.5 < i32
+0.5 / 0.5 == i64
+0.5 / 0.5 >= f32
+0.5 / 0.5 >= f64
+0.5 / 1 * i
+0.5 / 1 / f64
+0.5 / 1 < f64
+0.5 / 1 == i
+0.5 / 1 > f32
+0.5 / 1 >= i32
+0.5 / 1 not in array
 0.5 / f32 * f64
-0.5 / f64 / i
-0.5 / f64 <= f64
-0.5 / f64 == i
-0.5 / f64 == i64
-0.5 / f64 >= f64 ^ 1
-0.5 / i < f64 ? i64 : i64
+0.5 / f64 + f64
+0.5 / f64 - i
+0.5 / f64 / f64
+0.5 / f64 < i
+0.5 / f64 == f32
+0.5 / i != i64
+0.5 / i * i64
+0.5 / i / i32
 0.5 / i <= i
-0.5 / i == i64 - f32
-0.5 / i32 + i32
-0.5 / i32 < f32
+0.5 / i32 + i64
+0.5 / i32 > i ^ i
+0.5 / i32 > i64
+0.5 / i32 >= f64
+0.5 / i64 != f64
+0.5 / i64 != i
+0.5 / i64 != min(f32)
 0.5 / i64 * i32
-0.5 < 0.5 == nil ? true : foo
-0.5 < 0.5 || ok
-0.5 < 1 and ok
-0.5 < 1 or fromJSON("foo")?.Bar
-0.5 < f32 ? map(list, i32) : i
-0.5 < f64 != false ? f32 : score
-0.5 < f64 ? list : greet
-0.5 < f64 || ok
-0.5 < i ? f64 : foo
-0.5 < i32 or i32 == 1
-0.5 < i64 or ok
-0.5 <= 0.5 and ok
-0.5 <= 1 ? half : greet
-0.5 <= array[i32]
-0.5 <= f32 or ok
-0.5 <= f64 and !true
-0.5 <= f64 or ok
-0.5 <= i == ok
-0.5 <= i and nil == list
-0.5 <= i32 and i < i64
-0.5 <= i64 && f64 >= f64
-0.5 == 0.5 ? score : i
-0.5 == 1 == ok
-0.5 == 1 == ok ? "foo" : div
-0.5 == 1 or ok
-0.5 == 1 || nil != score
-0.5 == f32 ? score : i32
-0.5 == f64 && ok
-0.5 == nil || div != score
+0.5 < 0.5 ? f32 : array
+0.5 < 0.5 ? foo : greet
+0.5 < 1 == ok
+0.5 < 1 || ok
+0.5 < f32 && ok
+0.5 < f32 || ok
+0.5 <= 0.5 ? half : trimPrefix(nil)
+0.5 <= f64 ? i : i64
+0.5 <= f64 || ok
+0.5 == 1 and ok
+0.5 == 1 || ok
+0.5 == array[ok ? 0.5 : score]
+0.5 == f32 and i64 == i32
+0.5 == f64 ? i : (false ? i : i64)
+0.5 == f64 and i64 == 0.5
+0.5 == i or ok
+0.5 == i32 and ok
+0.5 == i64 and ok
+0.5 == nil or "foo" endsWith "bar"
+0.5 == nil or ok
 0.5 == nil || ok
-0.5 > 1 == ok
-0.5 > 1 or ok
-0.5 > f32 or !true
-0.5 > f64 != ok
-0.5 >= 0.5 == ok
-0.5 >= 0.5 || ok
-0.5 >= 1 != ok
-0.5 >= 1 and ok
-0.5 >= i32 && i > f32
-0.5 >= i64 and ok
-0.5 ^ 0.5 != i32
-0.5 ^ 0.5 + i32
-0.5 ^ 0.5 / i
-0.5 ^ 0.5 < f64
-0.5 ^ 0.5 > i
-0.5 ^ 0.5 > i64
+0.5 > 0.5 == ok
+0.5 > array[i64]
+0.5 > f32 and ok
+0.5 > i && 0.5 < i64
+0.5 > i64 ? -i : array
+0.5 >= 0.5 ? array[i64] : f32
+0.5 >= 0.5 and ok
+0.5 >= i && 1 < 0.5
+0.5 >= i32 == ok
+0.5 >= i32 and ok
+0.5 ^ 0.5 == f64
 0.5 ^ 0.5 >= i32
-0.5 ^ 1 * f64
-0.5 ^ 1 * i
-0.5 ^ 1 + i64
-0.5 ^ 1 - -i
-0.5 ^ 1 / i
-0.5 ^ 1 == f32
-0.5 ^ 1 == i32
-0.5 ^ f32 + i32
+0.5 ^ 0.5 >= i64
+0.5 ^ 1 ** i64
+0.5 ^ 1 - f32
+0.5 ^ 1 < f32
+0.5 ^ 1 < i
+0.5 ^ 1 <= i32
+0.5 ^ 1 > f64 / 1
+0.5 ^ 1 >= i
+0.5 ^ f32 * i
+0.5 ^ f32 ** i64
 0.5 ^ f32 <= i32
-0.5 ^ f32 > f64 ? array : nil
-0.5 ^ f32 >= f64
-0.5 ^ f32 ^ i32
-0.5 ^ f64 - i32
-0.5 ^ f64 > f32
-0.5 ^ f64 >= f32
-0.5 ^ f64 >= f64
-0.5 ^ f64 >= i
-0.5 ^ f64 ^ i64
-0.5 ^ i == i64
-0.5 ^ i >= i32
-0.5 ^ i32 * i
-0.5 ^ i32 * score(i)
-0.5 ^ i32 / i
-0.5 ^ i32 == i
-0.5 ^ i64 < i
-0.5 ^ i64 <= f32
-0.5 ^ i64 == f64
-0.5 ^ i64 > f64
-0.5 ^ i64 > i
+0.5 ^ f32 > i64
+0.5 ^ f32 >= i
+0.5 ^ f64 - i64
+0.5 ^ f64 / f32
+0.5 ^ f64 < f32
+0.5 ^ f64 > i32
+0.5 ^ i != f64
+0.5 ^ i * reduce(array, i)
+0.5 ^ i ** floor(0.5)
+0.5 ^ i / (0.5 + i32)
+0.5 ^ i < -f64
+0.5 ^ i <= i32
+0.5 ^ i >= i64
+0.5 ^ i32 * reduce(list, f64)
+0.5 ^ i32 ** f32
+0.5 ^ i32 < f32 ? ok : i32
+0.5 ^ i32 == i64
+0.5 ^ i32 ^ f64
+0.5 ^ i32 in array
+0.5 ^ i64 * i
+0.5 ^ i64 ** i
+0.5 ^ i64 ** i64
 0.5 ^ i64 > i32
-0.5 ^ i64 >= f32
-1 != 1 != hasPrefix("bar", "bar")
-1 != array[i - 1]
-1 != f32 && i32 <= 0.5
-1 != f32 == ok
-1 != f32 ? i64 : foo
-1 != f32 and i in array
-1 != f64 != ok
-1 != i32 ? score : greet
-1 != i64 && ok
-1 != i64 ? f32 : greet
+0.5 in array != ok
+0.5 in array && ok
+1 != 0.5 != ok
+1 != 0.5 and 1 == 1
+1 != 1 && ok
+1 != 1 ? f64 : 0.5 > i
+1 != 1 ? list : score
+1 != f32 != ok
+1 != f32 ? ok : half
+1 != i or ok
+1 != i64 ? add : div
 1 != nil && ok
-1 != nil ? half : foo
-1 % 1 != f64
-1 % 1 * f32
-1 % 1 < f32
-1 % 1 > f32
-1 % 1 > i
-1 % 1 >= i64
-1 % i / i32
-1 % i < f64
+1 != nil == ok
+1 != nil or not false
+1 % 1 != i
+1 % 1 != i32
+1 % 1 % i
+1 % 1 / f32
+1 % 1 / i32
+1 % 1 < f64
+1 % 1 < i
+1 % 1 == f64
+1 % 1 == i ? nil : 0.5
+1 % 1 == i32
+1 % array[i32]
+1 % array[i]
+1 % i != -i64
+1 % i != 1 != nil
+1 % i - i64
 1 % i < i32
-1 % i == f32
-1 % i32 * i64
-1 % i32 < max(i64)
-1 % i64 != f32
-1 % i64 * f64
-1 % i64 + f32
-1 % i64 .. i64
-1 % i64 <= i64
+1 % i >= f64
+1 % i >= i
+1 % i not in array
+1 % i32 != i
+1 % i32 <= f32
+1 % i32 > i64
+1 % i32 >= f64
+1 % i64 - f32
+1 % i64 < score(i)
 1 % i64 > f32
-1 % i64 > i32
-1 * 0.5 + i
-1 * 0.5 - -i
-1 * 0.5 <= f32
-1 * 0.5 > f32
-1 * 1 % i
-1 * 1 + i32
-1 * 1 <= f64
-1 * array[i64]
-1 * f32 < i
-1 * f32 < i32
-1 * f32 <= i32
-1 * f64 * -i
-1 * f64 * f32
-1 * f64 + i
-1 * i % i
-1 * i + f32
-1 * i < int(1)
-1 * i <= 1 % 1
-1 * i > f32
+1 * 0.5 + f64
+1 * 0.5 + i32
+1 * 0.5 + round(f64)
+1 * 0.5 / i
+1 * 0.5 / i64
+1 * 0.5 < i64
+1 * 0.5 == f32
+1 * 0.5 >= f32
+1 * 1 - i32
+1 * 1 <= int(i)
+1 * 1 >= f32
+1 * f32 != f64 - 0.5
+1 * f32 <= reduce(array, #)
+1 * f32 >= f64
+1 * f64 * i64
+1 * f64 <= i64
+1 * f64 > i
+1 * f64 >= f64
+1 * i * f32
+1 * i - i32
+1 * i / f64
+1 * i < f32
+1 * i > i32
 1 * i not in array
-1 * i32 % i64
-1 * i32 * i32
-1 * i32 / i32
-1 * i32 > f32
-1 * i64 + f64
-1 * i64 == i32
-1 * i64 > i64
-1 ** 0.5 * f64
-1 ** 0.5 - i
-1 ** 0.5 > i32
+1 * i32 + i32
+1 * i32 - i
+1 * i32 < i
+1 * i64 * f32
+1 * i64 + i
+1 * i64 - f64
+1 * i64 / f64
+1 * i64 <= f64
+1 * i64 in array
+1 ** 0.5 * i
+1 ** 0.5 ** f32
+1 ** 0.5 ** f64
+1 ** 0.5 ** i64
+1 ** 0.5 - f32
+1 ** 0.5 - i32
+1 ** 0.5 - i64
+1 ** 0.5 < -f32
+1 ** 0.5 > i
+1 ** 0.5 > i64
 1 ** 0.5 ^ f64
-1 ** 1 != i
-1 ** 1 != i64
-1 ** 1 - i
-1 ** 1 / i64
-1 ** 1 < i64
-1 ** 1 == i32
+1 ** 1 ** f64
+1 ** 1 + f64
+1 ** 1 + i64
+1 ** 1 - round(0.5)
+1 ** 1 / f64
+1 ** 1 < f32
+1 ** 1 == 0.5 + i32
 1 ** 1 >= i
-1 ** f32 != i64
-1 ** f32 / i
-1 ** f64 != i64
-1 ** f64 ** i64
-1 ** f64 + i
-1 ** f64 / f32
-1 ** f64 < i
-1 ** i != i
-1 ** i ** i64
-1 ** i < f64
-1 ** i < i32
-1 ** i > f64
-1 ** i32 ** (1 / 1)
-1 ** i32 == i
-1 ** i32 > i
-1 ** i64 ** f64
-1 ** i64 - f64
-1 + 0.5 != i
-1 + 0.5 <= f64 / f32
-1 + 0.5 <= i32
-1 + 1 - i32
+1 ** 1 >= i32
+1 ** 1 ^ i
+1 ** 1 ^ i32
+1 ** 1 in array
+1 ** array[i32]
+1 ** f32 / i32
+1 ** f32 / i64
+1 ** f32 <= f32
+1 ** f32 <= i64
+1 ** f32 == i64 ? i32 : array
+1 ** f32 >= f32
+1 ** f32 >= i
+1 ** f32 ^ f32
+1 ** f32 ^ i64
+1 ** i + i32
+1 ** i >= i
+1 ** i32 != i32
+1 ** i32 + f32
+1 ** i32 + i64
+1 ** i64 <= f32
+1 ** i64 <= f64
+1 ** i64 <= i32
+1 ** i64 > f32
+1 + 0.5 != i32
+1 + 0.5 + i
+1 + 0.5 - i64
+1 + 0.5 < f32
+1 + 0.5 < i
+1 + 0.5 == f64
+1 + 0.5 == f64 != nil
+1 + 0.5 > i64
+1 + 0.5 not in array
+1 + 1 != 0.5 ? 0.5 : half
+1 + 1 - f32
+1 + 1 - i
 1 + 1 < i
-1 + 1 == f64
-1 + 1 == i64
-1 + 1 >= i64
-1 + f32 != i
-1 + f32 > i
-1 + f64 != f64
-1 + f64 - i
-1 + f64 >= i32
+1 + 1 == f64 * i64
+1 + 1 > f32
+1 + 1 >= half(0.5)
+1 + 1 >= i
+1 + f32 != i32
+1 + f32 < i32
+1 + f32 <= i
+1 + f32 > i64
+1 + f64 == i64
+1 + f64 >= f64
+1 + i .. i32
+1 + i <= ceil(f32)
 1 + i <= f64
-1 + i in map(list, i32)
-1 + i32 - i64
-1 + i32 < i
-1 + i64 >= f32
-1 - 0.5 != half(0.5)
+1 + i >= min(i64)
+1 + i32 != i32
+1 + i32 - f64
+1 + i32 < f32
+1 + i32 < i32
+1 + i32 <= f64
+1 + i32 > reduce(array, #)
+1 + i32 >= f64
+1 + i64 != i32
+1 + i64 != i64
+1 + i64 < i32
+1 + i64 <= i64
+1 - 0.5 != f32
 1 - 0.5 + i
-1 - 0.5 + i32
-1 - 0.5 - i64
-1 - 0.5 <= f64
-1 - 0.5 == i64
-1 - 1 .. i64
-1 - 1 < i64
+1 - 0.5 - f32
+1 - 0.5 <= i32
+1 - 0.5 <= i64
+1 - 1 < i64 ? 0.5 : "foo"
+1 - 1 <= i32 + i64
 1 - 1 == f64
-1 - 1 > -f32
-1 - f32 != i
-1 - f32 <= f64
-1 - f32 <= i32
-1 - f64 - f32
-1 - f64 - f64
-1 - f64 < i64
+1 - 1 > i32 / i32
+1 - f32 != f32
+1 - f32 <= i64
+1 - f64 != f32
+1 - f64 + f32
+1 - f64 + i - 0.5
 1 - f64 <= i
-1 - i .. i64
-1 - i < min(f64)
-1 - i32 < f64
-1 - i32 <= f64
-1 - i32 <= i32
-1 - i32 >= f64
-1 - i64 + i
-1 - i64 - f32
-1 .. 1 == list
-1 .. array[i]
-1 .. i == list
-1 .. i64 == list
-1 / 0.5 + f64
-1 / 0.5 - array[i64]
-1 / 0.5 < f64
-1 / 1 + -0.5
-1 / 1 + i32
-1 / 1 - -0.5
-1 / 1 / f64
-1 / 1 < f32
-1 / 1 <= f32
-1 / 1 <= i
-1 / 1 == f64
-1 / 1 == i
-1 / 1 == i32
-1 / 1 > f32
-1 / 1 > i64
-1 / f32 + -1
-1 / f64 * i
-1 / f64 * i32
-1 / f64 + i32
-1 / f64 / f32
-1 / f64 == f32
-1 / f64 == i
-1 / f64 > i
-1 / i * i
-1 / i < f64 ? ok : add
-1 / i32 <= f32
-1 / i32 == i
-1 / i32 == i64
-1 / i32 > i
-1 / i64 + i64
-1 / i64 == i64
-1 / i64 > i
-1 / i64 >= i32
-1 < array[i64]
-1 < f64 != ok
-1 < i32 and 1 == nil
-1 < i64 ? "foo" not endsWith "foo" : i
-1 <= 0.5 and i32 == 1
-1 <= 0.5 || ok
-1 <= 1 && greet != greet
-1 <= 1 and ok
-1 <= f32 != ok
-1 <= f32 == !ok
-1 <= f64 ? add : f64
-1 <= i64 or nil == f32
-1 == array[i]
-1 > 0.5 != ok
-1 > 1 and ok
-1 > 1 || ok
-1 > f32 and ok
-1 > f64 == ok
-1 > f64 and ok
-1 > i32 == ok
-1 > i64 || i32 < i
-1 >= 1 || ok
-1 >= i || ok
-1 >= i64 or nil in list
-1 ^ 0.5 - f32
-1 ^ 0.5 <= f32
-1 ^ 0.5 <= i64
-1 ^ 0.5 ^ i32
-1 ^ 1 - f64
-1 ^ 1 - i32
-1 ^ 1 - i64
-1 ^ 1 / f32
-1 ^ 1 < f32
-1 ^ 1 < i64 / f32
-1 ^ 1 <= 1 ** f64
-1 ^ 1 == f64
-1 ^ 1 >= f32
-1 ^ 1 >= i64
-1 ^ f32 == i64
-1 ^ f32 > max(f32)
-1 ^ f64 != i32
-1 ^ f64 * f32
-1 ^ f64 ** f64
-1 ^ i != findLast(array, false)
-1 ^ i != i
-1 ^ i * f64
-1 ^ i < i32
-1 ^ i <= f32
-1 ^ i == abs(1)
-1 ^ i32 + i
-1 ^ i32 < i
-1 ^ i32 < i64
+1 - f64 in array
+1 - f64 not in array
+1 - i > f64
+1 - i > i
+1 - i > i32
+1 - i >= i64
+1 - i not in array
+1 - i32 < i32
+1 - i32 < i64
+1 - i32 == i32
+1 - i64 <= i32
+1 .. i != list
+1 / 0.5 <= abs(f32)
+1 / 0.5 <= i32
+1 / 0.5 == f64
+1 / 0.5 > f32
+1 / 0.5 >= i
+1 / 0.5 >= i - i
+1 / 0.5 >= i32
+1 / 1 != i32
+1 / 1 * f32
+1 / 1 <= f64
+1 / 1 in array
+1 / f32 != f64
+1 / f32 / i64
+1 / f32 <= f32
+1 / f32 <= f64
+1 / f32 == i32
+1 / f32 == i32 / i
+1 / f32 > f32
+1 / f32 >= f64
+1 / f64 + f64
+1 / f64 < f32
+1 / f64 == f64
+1 / i * f32
+1 / i / f64
+1 / i < i
+1 / i == f64
+1 / i >= i32
+1 / i in map(list, 1)
+1 / i32 > f32
+1 / i32 >= i64
+1 / i64 * i
+1 / i64 > f32 / f64
+1 / i64 > f64
+1 / i64 >= f64
+1 < 1 == ok
+1 < 1 and half == div
+1 < 1 and ok
+1 < array[get(array, i32)]
+1 < array[i32]
+1 < f32 != not true
+1 < f64 || ok
+1 < i ? array : foo
+1 < i32 || 1 >= f32
+1 < i64 == ok
+1 < i64 ? ok : list
+1 <= 1 == ok
+1 <= 1 || add == add
+1 <= f32 && ok
+1 <= f64 || ok
+1 <= i32 ? foo : f32
+1 == 0.5 ? i32 : greet
+1 == 0.5 and ok
+1 == 1 || ok
+1 == f64 && 0.5 != nil
+1 == f64 || ok
+1 == i32 && ok
+1 == i32 == ok
+1 == i64 == ok
+1 == nil ? ok : half
+1 > 0.5 == ok
+1 > 1 || add != greet
+1 > array[i64]
+1 > f32 && ok
+1 > f32 == reduce(array, ok)
+1 > f64 != ok
+1 > i == ok
+1 > i64 or i != 1
+1 >= 1 != (nil not in list)
+1 >= f32 ? i64 : half
+1 >= f64 ? ok : half
+1 >= i and ok
+1 ^ 0.5 != f32
+1 ^ 0.5 != i
+1 ^ 0.5 ** f32
+1 ^ 0.5 ** i32
+1 ^ 0.5 - i32
+1 ^ 0.5 < i32
+1 ^ 0.5 <= f64
+1 ^ 0.5 == i
+1 ^ 0.5 ^ f32
+1 ^ 0.5 ^ i64
+1 ^ 1 != f64
+1 ^ 1 != i64
+1 ^ 1 ** i
+1 ^ 1 + f64
+1 ^ 1 / i
+1 ^ 1 < i
+1 ^ 1 < i64
+1 ^ 1 >= i
+1 ^ 1 >= i32
+1 ^ f32 < i32
+1 ^ f32 <= f64
+1 ^ f64 / f64
+1 ^ f64 == f32
+1 ^ f64 > f32
+1 ^ f64 >= 1 / f64
+1 ^ i != i * f32
+1 ^ i - i32
+1 ^ i < i
+1 ^ i32 * i32
+1 ^ i32 ** i64
+1 ^ i32 / i
 1 ^ i32 >= i32
-1 ^ i64 ** f64
-1 ^ i64 ** i32
-1 ^ i64 + i
-1 ^ i64 <= i
-1 ^ i64 <= i32
+1 ^ i32 >= i64
+1 ^ i64 * i64
+1 ^ i64 ** reduce(list, 1)
+1 ^ i64 - i64
+1 ^ i64 / f64
 1 ^ i64 > i
-1 ^ i64 >= i64
+1 ^ i64 >= i32 + i32
+1 in array ? f32 : foo
 [!false]
 [!ok]
-["foo" != nil]
-["foo" endsWith "bar"]
+[!true]
+["bar" + "foo"]
+["bar" < "bar"]
+["bar" not contains "bar"]
 [-0.5]
+[-1]
 [-f32]
 [-f64]
-[-i32]
-[-i64, add]
 [-i64]
-[0.5 * 1]
-[0.5 + 0.5]
-[0.5 / i]
-[0.5 <= f64]
-[0.5 <= i, -1]
-[0.5 >= i]
-[0.5 ^ 1]
+[0.5 != f32]
+[0.5 != i]
+[0.5 * 0.5]
+[0.5 * f32]
+[0.5 ** i]
+[0.5 - 0.5]
+[0.5 - i]
+[0.5 / i32]
+[0.5 <= i32, half]
+[0.5 > 1]
+[0.5 > f32]
+[0.5 > i64]
+[0.5 >= f64]
+[0.5 ^ 0.5]
 [1 != 1]
-[1 % 1, !true]
-[1 < 0.5]
+[1 * 0.5]
+[1 ** 0.5]
+[1 + i64, add]
+[1 == i64]
 [1 == i]
-[abs(0.5)]
-[add != div]
-[add == nil]
-[add, array]
+[[f32]]
+[add != nil]
+[add, add]
 [add, f32]
-[add, f64]
-[add, greet]
-[add, half]
-[add, i64]
-[add, score]
-[add, toJSON(array)]
+[add, i]
 [add]
-[array == list]
+[all(list, false)]
+[any(list, ok)]
+[array, add]
+[array, array]
 [array, f32]
-[array, f64]
 [array, greet]
-[array, half]
+[array, i64]
+[array, i]
 [array, list]
-[array, ok]
-[array, score]
-[array[1]]
-[array[i64]]
+[array, ok, add]
+[array, string(nil)]
 [array]
-[div == half]
-[div, f32]
-[div, greet]
-[div, map(list, half)]
-[div, ok]
-[div, score]
+[bitnot(1)]
+[ceil(i32)]
+[div(1, 1)]
+[div, add]
+[div, foo]
+[div, i32]
+[div, i64, array]
 [div]
-[f32 + 1]
-[f32 - 0.5]
-[f32 < i]
-[f32 ^ 0.5]
-[f32 ^ f64]
+[f32 * i]
+[f32 + f64]
+[f32 >= i]
 [f32, f64]
-[f32, half]
-[f32, max(f64)]
+[f32, foo, greet]
+[f32, greet]
+[f32, i32]
+[f32, list]
+[f32, ok]
+[f32, score]
 [f32]
-[f64 != 1]
-[f64 != i32]
-[f64 * f64]
+[f64 + f64]
+[f64 / f64]
+[f64 < 0.5]
 [f64 < f32]
-[f64 >= 1]
+[f64 < i64]
+[f64 <= 1]
+[f64 in array]
+[f64, add]
 [f64, f64]
-[f64, foo]
-[f64, i32]
+[f64, half]
 [f64, i64]
-[f64, list]
-[f64, score]
 [f64]
-[false ? f64 : f32]
-[findIndex(array, true)]
-[first(array)]
-[float(i64)]
+[f64] == array
+[find(array, true)]
+[findIndex(list, false)]
+[findLast(list, ok)]
+[float(0.5)]
+[float(1)]
 [foo, add]
-[foo, f32]
-[foo, foo]
+[foo, array]
+[foo, half]
 [foo, i]
-[foo, list]
+[foo, ok]
+[foo, reduce(array, #)]
+[foo.Bar]
 [foo.Qux]
-[foo.String(), greet]
-[foo.String()]
+[foo?.Bar, f32, f64]
+[foo?.Bar, i32]
 [foo?.Bar]
 [foo?.Qux]
+[foo?.String()]
 [foo]
+[greet != nil]
+[greet, array]
 [greet, div]
-[greet, f32 ^ 0.5]
-[greet, f32]
-[greet, f64]
+[greet, foo]
+[greet, greet]
 [greet, half]
-[greet, i32]
 [greet, i64]
 [greet, list]
 [greet]
+[greet] == list
+[groupBy(array, "bar")]
+[groupBy(array, #), half]
+[groupBy(array, #)]
+[groupBy(array, f64)]
+[groupBy(list, #)?.Qux]
+[half(0.5)]
+[half(f64)]
+[half(i64 ^ 1)]
+[half, array]
 [half, div]
-[half, foo]
-[half, greet]
+[half, f64]
+[half, i64 < f64]
+[half, list]
 [half]
 [i != i64]
-[i != i]
-[i - 1]
 [i .. 1]
-[i / 0.5]
-[i < f32]
-[i > f64]
-[i, add]
-[i, half]
-[i32 * 1]
-[i32 <= 0.5]
-[i32 == 0.5]
+[i / i]
+[i < i64, score]
+[i <= 0.5]
+[i == i32]
+[i >= i32]
+[i ^ 1]
+[i, array, list]
+[i, array]
+[i, greet("bar")]
+[i, greet]
+[i, i32]
+[i, i]
+[i, list]
+[i32 < i]
 [i32 > 1]
-[i32 > f32]
-[i32, i]
-[i32, score]
+[i32, -1]
+[i32, div]
+[i32, f64]
+[i32, i32]
+[i32, list]
+[i32, type(greet)]
 [i32]
+[i64 != f64]
+[i64 + 0.5]
 [i64 / f64]
-[i64 == i32]
+[i64 <= i64]
 [i64 >= 1]
-[i64 ^ i, i32]
-[i64, add]
+[i64 ^ 1]
 [i64, div]
 [i64, foo]
-[i64, i32]
-[i64, ok]
+[i64, half]
+[i64, score]
 [i64]
-[i64] == array
 [i]
-[int(1)]
-[len(array)]
-[list == list]
+[list != nil]
 [list, div]
-[list, f64]
+[list, f32]
+[list, greet]
+[list, half]
 [list, i]
+[list, ok]
 [list]
 [map(array, #)]
-[map(array, 1 >= i32)]
+[map(array, add)]
+[map(array, f64)]
 [map(array, foo)]
-[map(list, #)]
-[map(list, half)]
-[map(list, ok)]
 [max(1)]
-[max(i32)]
-[min(0.5)]
-[min(f64)]
-[min(i32)]
-[nil != ok, foo]
-[nil == 0.5]
-[nil not in list]
+[nil != 0.5]
 [not false]
-[not ok]
-[not true]
-[ok && ok]
+[ok ? 1 : greet]
 [ok, f32]
 [ok, half]
-[ok, score]
+[ok, i64]
+[ok, i]
+[ok, list, 0.5] == list
+[ok, ok]
 [ok]
-[score != add]
-[score(1)]
-[score(i)]
-[score, array, foo]
+[reduce(array, foo)]
+[reduce(list, #)]
+[reduce(list, div)]
+[score == nil]
+[score, div]
 [score, f32]
 [score, f64]
 [score, greet]
+[score, half]
+[score, one(array, # > i32)]
+[score, score]
 [score]
-[string(0.5), foo]
-[string(f64)]
-[string(i32)]
-[toJSON(1)]
-[toJSON(nil)]
-[type(0.5)]
+[string(0.5)]
+[string(1)]
+[string(foo)]
+[string(i)]
+[string(i64)]
+[toJSON(list)]
+[trimPrefix("bar")]
+[true ? add : f64]
+[true and ok]
+[true || ok]
 [type(1)]
 [type(add)]
-[type(false)]
-[type(i32)]
-[{"foo": foo}]
+[type(div)]
+[type(greet)]
+[type(nil)]
 abs(-0.5)
 abs(-1)
 abs(-f32)
@@ -2377,159 +2612,153 @@ abs(-i32)
 abs(-i64)
 abs(0.5 * 0.5)
 abs(0.5 * 1)
-abs(0.5 * f64)
-abs(0.5 * i32)
+abs(0.5 * i)
 abs(0.5 * i64)
 abs(0.5 ** 0.5)
 abs(0.5 ** 1)
-abs(0.5 ** f32)
-abs(0.5 ** f64)
-abs(0.5 ** i64)
+abs(0.5 ** i32)
 abs(0.5 + 0.5)
+abs(0.5 + 1)
 abs(0.5 + f32)
 abs(0.5 + i)
 abs(0.5 + i64)
 abs(0.5 - 0.5)
-abs(0.5 - f32)
+abs(0.5 - 1)
 abs(0.5 - i)
+abs(0.5 - i32)
 abs(0.5 - i64)
 abs(0.5 / 0.5)
 abs(0.5 / 1)
-abs(0.5 / f32)
 abs(0.5 / f64)
-abs(0.5 / i)
-abs(0.5 / i64)
 abs(0.5 ^ 0.5)
 abs(0.5 ^ 1)
-abs(0.5 ^ f64)
-abs(0.5 ^ i32)
-abs(0.5) * i
-abs(0.5) - i
-abs(0.5) - i64
-abs(0.5) / i32
-abs(0.5) < f32
-abs(0.5) == i32
-abs(0.5) > f32
-abs(0.5) >= f32
-abs(0.5) >= i
-abs(0.5) >= i32
-abs(0.5) ^ f64
-abs(1 % 1)
-abs(1 % i)
-abs(1 * 0.5)
-abs(1 * 1)
+abs(0.5 ^ f32)
+abs(0.5) - i32
+abs(0.5) / f32
+abs(0.5) < f64
+abs(0.5) < i32
+abs(0.5) <= i64
+abs(0.5) == -0.5
+abs(0.5) == half(1)
+abs(0.5) > i32
+abs(0.5) >= f64
+abs(0.5) ^ i64
+abs(0.5) not in array
 abs(1 * f32)
+abs(1 * f64)
+abs(1 * i32)
+abs(1 ** 0.5)
 abs(1 ** 1)
 abs(1 ** i)
 abs(1 + 1)
-abs(1 + f64)
+abs(1 + i)
+abs(1 + i64)
 abs(1 - 0.5)
-abs(1 - i)
-abs(1 - i32)
+abs(1 - 1)
+abs(1 - i64)
 abs(1 / 0.5)
 abs(1 / 1)
-abs(1 / f32)
-abs(1 / f64)
+abs(1 / i)
 abs(1 / i32)
-abs(1 / i64)
-abs(1 ^ 0.5)
-abs(1 ^ 1)
-abs(1 ^ f64)
-abs(1) * f64
-abs(1) * i
-abs(1) ** f64
-abs(1) + f64
-abs(1) + i
-abs(1) - f64
+abs(1 ^ f32)
+abs(1 ^ i)
+abs(1 ^ i32)
+abs(1) - i32
 abs(1) .. i
-abs(1) / f32
-abs(1) < f32
-abs(1) < i
-abs(1) == f64 ? 1 : foo
-abs(1) > i
-abs(1) ^ f32
-abs(1) ^ i32
+abs(1) / f64
+abs(1) / i64
+abs(1) < i64
+abs(1) <= i32
+abs(1) == i32
+abs(1) >= i
+abs(1) ^ f64
 abs(abs(0.5))
 abs(abs(1))
-abs(abs(abs(i)))
-abs(abs(f32))
 abs(abs(f64))
-abs(abs(i))
 abs(abs(i32))
 abs(abs(i64))
-abs(array[1])
-abs(array[i])
-abs(count(list, true))
+abs(add(i, 1))
+abs(bitand(i64, i32))
+abs(bitnand(i64, i))
+abs(bitnot(1))
+abs(bitnot(i))
+abs(bitnot(i32))
+abs(bitnot(i64))
+abs(bitushr(1, 1))
+abs(ceil(0.5))
+abs(ceil(1))
+abs(ceil(f32))
+abs(ceil(i))
+abs(ceil(i32))
+abs(ceil(i64))
+abs(count(array, ok))
+abs(count(array, true))
+abs(count(list, false))
+abs(div(i, i))
 abs(f32 * 0.5)
-abs(f32 * 1)
-abs(f32 * f64)
-abs(f32 ** 0.5)
 abs(f32 ** 1)
+abs(f32 ** f32)
 abs(f32 ** i32)
 abs(f32 + 0.5)
 abs(f32 + 1)
-abs(f32 + f32)
-abs(f32 + f64)
 abs(f32 + i)
 abs(f32 + i32)
 abs(f32 - 0.5)
 abs(f32 - 1)
-abs(f32 - f32)
+abs(f32 - i32)
+abs(f32 - i64)
+abs(f32 / 0.5)
 abs(f32 / 1)
 abs(f32 / f32)
 abs(f32 / f64)
 abs(f32 / i32)
-abs(f32 ^ 1)
-abs(f32 ^ f64)
-abs(f32 ^ i32)
+abs(f32 ^ i)
 abs(f32 ^ i64)
 abs(f32)
-abs(f32) != i64 / i64
-abs(f32) * i32
-abs(f32) + i32
-abs(f32) <= i64
-abs(f32) == i
-abs(f32) ^ f64
-abs(f64 * 1)
+abs(f32) ** f32
+abs(f32) ** i
+abs(f32) + i64
+abs(f32) - i32
+abs(f32) / f64
+abs(f32) < f64
+abs(f32) >= 0.5 / 1
+abs(f32) ^ f32
 abs(f64 * f32)
-abs(f64 * i32)
+abs(f64 * f64)
 abs(f64 ** 1)
-abs(f64 ** f32)
-abs(f64 ** i32)
 abs(f64 + 0.5)
 abs(f64 + 1)
-abs(f64 + i32)
-abs(f64 + i64)
-abs(f64 - 0.5)
+abs(f64 + f64)
 abs(f64 - 1)
 abs(f64 - f32)
-abs(f64 - i32)
 abs(f64 / 0.5)
+abs(f64 / 1)
 abs(f64 / f64)
 abs(f64 / i)
-abs(f64 / i64)
-abs(f64 ^ i32)
+abs(f64 ^ 0.5)
+abs(f64 ^ f32)
+abs(f64 ^ i)
+abs(f64 ^ i64)
 abs(f64)
-abs(f64) * i64
-abs(f64) - f32
-abs(f64) - i64 - i32
-abs(f64) / i
-abs(f64) / i64
-abs(f64) < f64
-abs(f64) <= abs(i32)
-abs(f64) <= i
-abs(f64) <= i32
-abs(f64) == i
-abs(false ? 1 : f32)
-abs(false ? f64 : 0.5)
-abs(false ? false : i64)
-abs(findIndex(array, # > i32))
-abs(findIndex(array, ok))
-abs(findIndex(array, true))
+abs(f64) + f32
+abs(f64) + f64
+abs(f64) + i32
+abs(f64) + i64 / i
+abs(f64) - i
+abs(f64) < i32
+abs(f64) <= f64
+abs(f64) > i64
+abs(f64) ^ f32
+abs(f64) ^ i64
+abs(f64) in array
+abs(false ? f32 : 1)
+abs(false ? half : 0.5)
+abs(false ? list : 1)
+abs(find(array, ok))
+abs(find(array, true))
+abs(findIndex(list, ok))
 abs(findIndex(list, true))
 abs(findLastIndex(array, ok))
-abs(findLastIndex(array, true))
-abs(findLastIndex(list, ok))
 abs(first(array))
 abs(float(0.5))
 abs(float(1))
@@ -2537,383 +2766,397 @@ abs(float(f32))
 abs(float(f64))
 abs(float(i))
 abs(float(i32))
-abs(float(i64))
+abs(floor(0.5))
+abs(floor(f32))
+abs(floor(i32))
+abs(get(array, 1))
+abs(get(array, i))
 abs(get(array, i32))
 abs(get(array, i64))
 abs(half(0.5))
+abs(half(1))
 abs(half(f64))
-abs(i % i64)
 abs(i * 1)
-abs(i * i)
-abs(i * i32)
-abs(i ** 0.5)
+abs(i * f32)
 abs(i ** 1)
+abs(i ** f32)
 abs(i ** i32)
-abs(i + 1)
-abs(i + i32)
+abs(i + 0.5)
+abs(i + f64)
 abs(i - 0.5)
 abs(i - 1)
-abs(i / 1)
+abs(i - f32)
+abs(i - f64)
+abs(i - i32)
+abs(i / 0.5)
+abs(i / f64)
+abs(i / i)
 abs(i / i32)
+abs(i / i64)
 abs(i ^ 0.5)
-abs(i ^ f32)
+abs(i ^ f64)
+abs(i ^ i)
 abs(i ^ i32)
+abs(i ^ i64)
 abs(i)
-abs(i) != float(0.5)
-abs(i) % i64
-abs(i) * f32
-abs(i) ** i
-abs(i) ** max(1)
-abs(i) / i64
-abs(i) <= i32
+abs(i) % i
+abs(i) * i32
+abs(i) ** f32
+abs(i) + f64
+abs(i) - f32
+abs(i) .. i
+abs(i) .. i32
+abs(i) / f32
+abs(i) < f64
 abs(i) <= i64
-abs(i) > f64
+abs(i) == 0.5 / i
+abs(i) > i64
+abs(i) ^ f64
+abs(i) ^ half(1)
+abs(i) ^ i
+abs(i) ^ i32
+abs(i32 % i32)
 abs(i32 % i64)
-abs(i32 * 0.5)
-abs(i32 * 1)
+abs(i32 * f64)
 abs(i32 * i32)
-abs(i32 * i64)
 abs(i32 ** 0.5)
 abs(i32 ** 1)
-abs(i32 ** f64)
-abs(i32 ** i)
-abs(i32 ** i64)
+abs(i32 ** i32)
 abs(i32 + 0.5)
+abs(i32 + 1)
 abs(i32 + f64)
+abs(i32 + i)
 abs(i32 + i32)
-abs(i32 - 1)
-abs(i32 - f32)
-abs(i32 - f64)
+abs(i32 - 0.5)
 abs(i32 - i64)
-abs(i32 / 1)
+abs(i32 / 0.5)
 abs(i32 / i)
-abs(i32 / i32)
-abs(i32 ^ 0.5)
-abs(i32 ^ 1)
-abs(i32 ^ i)
-abs(i32 ^ i64)
+abs(i32 / i64)
 abs(i32)
-abs(i32) % i32
-abs(i32) ** i64
-abs(i32) / -f32
-abs(i32) < f32
-abs(i32) > min(i64, f64, i32)
-abs(i32) ^ f64
-abs(i32) not in array
-abs(i64 % 1)
-abs(i64 % i32)
-abs(i64 * 1)
+abs(i32) != f64
+abs(i32) * f32
+abs(i32) * i
+abs(i32) ** i
+abs(i32) - i32
+abs(i32) / -1
+abs(i32) / i32 ** f64
+abs(i32) < i64 == false
+abs(i32) <= i
+abs(i32) <= i32
+abs(i32) == i32
+abs(i32) ^ i64
+abs(i32) in array
+abs(i64 * 0.5)
 abs(i64 * f32)
-abs(i64 * i)
 abs(i64 * i32)
-abs(i64 * i64)
 abs(i64 ** 0.5)
-abs(i64 ** 1)
+abs(i64 ** f64)
 abs(i64 ** i64)
 abs(i64 + 0.5)
 abs(i64 + 1)
+abs(i64 + f32)
+abs(i64 + f64)
 abs(i64 + i)
-abs(i64 + i32)
-abs(i64 + i64)
-abs(i64 - 1)
-abs(i64 - f64)
-abs(i64 - i32)
+abs(i64 - 0.5)
+abs(i64 - i)
+abs(i64 / f32)
 abs(i64 / i32)
-abs(i64 ^ i64)
+abs(i64 ^ f64)
+abs(i64 ^ i)
+abs(i64 ^ i32)
 abs(i64)
-abs(i64) != f64
-abs(i64) - f64
-abs(i64) - i64
-abs(i64) .. i64
-abs(i64) == f32
-abs(i64) == i
-abs(i64) == i32
-abs(i64) == nil ? i : f64
-abs(i64) > i64
-abs(i64) >= f64
-abs(i64) in array
+abs(i64) * i32
+abs(i64) ** i
+abs(i64) + f32
+abs(i64) / i
+abs(i64) > i32
+abs(i64) ^ i32
+abs(i64) not in array
 abs(int(0.5))
 abs(int(1))
-abs(int(f32))
-abs(int(f64))
 abs(int(i))
 abs(int(i32))
 abs(int(i64))
 abs(last(array))
-abs(len("bar"))
 abs(len("foo"))
-abs(len(array))
 abs(len(list))
 abs(max(0.5))
-abs(max(1))
-abs(max(1, 1))
-abs(max(1, i64, f64))
 abs(max(f32))
 abs(max(f64))
-abs(max(i))
 abs(max(i32))
 abs(max(i64))
+abs(mean(array))
+abs(median(array))
 abs(min(0.5))
-abs(min(0.5, 1))
 abs(min(1))
-abs(min(1, f32))
 abs(min(f32))
 abs(min(f64))
 abs(min(i))
 abs(min(i32))
-abs(min(i64))
 abs(ok ? 1 : "foo")
-abs(ok ? f32 : 1)
-abs(ok ? i : "bar")
+abs(ok ? f32 : 0.5)
+abs(ok ? f32 : nil)
+abs(ok ? f64 : ok)
+abs(ok ? i32 : foo)
+abs(reduce(array, #))
+abs(reduce(array, i))
+abs(reduce(list, 1))
+abs(reduce(list, i32))
+abs(round(0.5))
+abs(round(1))
+abs(round(f32))
+abs(round(i))
+abs(round(i64))
 abs(score(1))
 abs(score(i))
-abs(true ? f32 : "bar")
-abs(true ? f64 : i32)
+abs(sum(array))
+abs(true ? 1 : ok)
 add
 add != add
+add != add == nil
 add != div
-add != div ? foo : i64
-add != div and ok
+add != div != false
+add != div == true
 add != foo.Qux
 add != foo.String
 add != foo?.Qux
 add != foo?.String
 add != greet
-add != greet ? score : f32
+add != greet == ok
+add != greet ? array : 1
+add != greet ? greet : ok
 add != half
-add != half == nil
-add != half ? 0.5 : ok
-add != nil == nil
-add != nil ? "bar" : f32
-add != nil ? half : f32
+add != half == ok
+add != half || nil != add
+add != nil ? f64 : i64
+add != reduce(list, add)
+add != reduce(list, greet)
 add != score
 add == add
-add == add == ok
+add == add != nil
+add == add == nil
+add == add ? 1 : i64
 add == div
-add == div ? i32 : f64
-add == div or ok
+add == div ? f64 : list
 add == foo.Qux
 add == foo.String
 add == foo?.Qux
 add == foo?.String
 add == greet
-add == greet ? 1 : 1
 add == half
-add == nil && ok
-add == nil ? "foo" : list
-add == nil ? add : half
-add == nil ? add : score
-add == nil ? i32 : div
-add == nil ? score : i64
-add == nil || ok
+add == half != ok
+add == half ? nil : f32
+add == nil ? false : i32
+add == nil ? greet : i32
+add == nil ? nil : nil
+add == reduce(list, score)
 add == score
+add == score != ok
 add == score != true
-add == score and i32 >= 1
-add == score or 0.5 < 1
-add in [div]
-add not in sort(array)
-add(1, 1) ** i
-add(1, 1) ^ i
-add(1, i) .. i64
-add(i, 1 - i32)
-add(i, abs(i))
+add == score == true
+add == score or ok
+add in sort(array)
+add(1, i) < i
+add(i, 1) ** f32
 add(i, i)
-add(i, i64 % 1)
-add(i, min(i))
-add(min(1, 1), i32 * 1)
-add(score(i, i), i)
-all(1 .. i32, ok)
-all(array, !(# <= #))
-all(array, !false)
+add(i, i32 + 1)
+all(1 .. i64, ok)
+all(["bar"], # >= #)
+all(["foo"], # not matches #)
+all([false], # && false)
+all([false], #)
+all(array, !(# >= f64))
 all(array, !ok)
-all(array, !true or 0.5 < #)
-all(array, "bar" in foo)
-all(array, "bar" matches "bar")
+all(array, !true)
+all(array, "foo" < "bar")
 all(array, # != #)
 all(array, # != 1)
 all(array, # != f32)
 all(array, # != f64)
-all(array, # != i64)
+all(array, # != i32)
 all(array, # != nil)
-all(array, # + # >= 0.5 + i)
 all(array, # < #)
 all(array, # < 0.5)
 all(array, # < 1)
+all(array, # < f64)
+all(array, # < i)
+all(array, # < i64)
 all(array, # <= #)
 all(array, # <= 0.5)
-all(array, # <= f64)
 all(array, # <= i)
+all(array, # == # + #)
 all(array, # == #)
 all(array, # == 0.5)
+all(array, # == 1)
+all(array, # == f64)
+all(array, # == i)
 all(array, # == i32)
 all(array, # == i64)
-all(array, # == nil)
 all(array, # > #)
 all(array, # > 0.5)
 all(array, # > 1)
-all(array, # > f32)
 all(array, # > f64)
 all(array, # > i)
+all(array, # > i32)
 all(array, # > i64)
 all(array, # >= #)
 all(array, # >= 0.5)
+all(array, # >= f32)
 all(array, # >= f64)
-all(array, # >= i)
-all(array, # ^ # == i64)
+all(array, # >= i32)
+all(array, # >= i64)
 all(array, # in array)
-all(array, # not in array)
 all(array, 0.5 != #)
-all(array, 0.5 != f32)
-all(array, 0.5 + 0.5 >= #)
 all(array, 0.5 < #)
-all(array, 0.5 < 1)
-all(array, 0.5 < i64)
+all(array, 0.5 < f32)
 all(array, 0.5 <= #)
-all(array, 0.5 == #)
-all(array, 0.5 == f32)
-all(array, 0.5 > #)
-all(array, 0.5 > 1)
+all(array, 0.5 <= f32)
+all(array, 0.5 <= i)
+all(array, 0.5 > f32)
+all(array, 0.5 > f64)
+all(array, 0.5 > i32)
 all(array, 0.5 >= #)
+all(array, 0.5 >= 0.5)
+all(array, 0.5 in array)
 all(array, 1 != #)
-all(array, 1 != i)
-all(array, 1 != i64)
-all(array, 1 != nil)
+all(array, 1 != f32)
 all(array, 1 < #)
-all(array, 1 <= #)
+all(array, 1 < f32)
 all(array, 1 == #)
 all(array, 1 > #)
-all(array, 1 in array)
-all(array, all(array, add != score))
-all(array, all(array, false))
-all(array, all(list, false))
+all(array, 1 > i64)
+all(array, 1 >= #)
+all(array, 1 >= 1)
+all(array, 1 >= i64)
+all(array, f32 < #)
+all(array, f32 <= #)
+all(array, f32 <= f32)
+all(array, f32 > i)
 all(array, f32 >= #)
 all(array, f64 != #)
-all(array, f64 != i32)
-all(array, f64 < #)
 all(array, f64 <= #)
+all(array, f64 <= f32)
 all(array, f64 == #)
-all(array, f64 > #)
-all(array, false or ok)
-all(array, i != f32)
+all(array, f64 == 0.5)
+all(array, f64 == i64)
+all(array, f64 >= i64)
+all(array, false && true)
+all(array, false ? 1 : true)
+all(array, i != 0.5)
+all(array, i <= 0.5)
+all(array, i <= f32)
+all(array, i <= i32)
 all(array, i == #)
-all(array, i > #)
-all(array, i >= #)
+all(array, i32 != #)
 all(array, i32 != i64)
-all(array, i32 < #)
-all(array, i32 <= #)
-all(array, i32 <= i32)
-all(array, i32 > #)
-all(array, i32 >= 1 % #)
-all(array, i64 < #)
-all(array, i64 < 1)
-all(array, i64 < i64)
-all(array, i64 == #)
-all(array, i64 == 0.5)
+all(array, i32 < i)
+all(array, i32 >= #)
+all(array, i64 != #)
+all(array, i64 != i64)
+all(array, i64 == i32)
 all(array, i64 > #)
-all(array, list != list)
+all(array, i64 > 0.5)
+all(array, i64 >= #)
+all(array, nil != "bar")
 all(array, nil != #)
-all(array, nil != i)
+all(array, nil != list)
+all(array, nil != ok)
 all(array, nil == "foo")
-all(array, nil == div)
-all(array, nil in list)
-all(array, not (nil in array))
+all(array, nil == i32)
+all(array, nil == list)
+all(array, none(list, true))
 all(array, not false)
 all(array, not true)
 all(array, ok)
-all(array, one(array, ok))
-all(array, score == add)
-all(array, score(#) > f32)
-all(array, true || false)
-all(array, true) or ok
-all(false ? greet : "foo", # == i32)
-all(filter(array, ok), # < #)
+all(false ? add : "bar", ok)
 all(filter(array, true), ok)
-all(i32 .. 1, 0.5 < i32)
-all(i64 .. i64, # != #)
-all(list, !any(array, false))
+all(groupBy(array, #)?.f32, #)
+all(groupBy(array, f32).score, 0.5 in #?.f64)
+all(groupBy(array, foo)?.i64, none(.div, true == #))
+all(groupBy(list, #).i, #?.half() not in # + #)
+all(groupBy(list, #)?.add, #?.f64.i64(f32 startsWith #, div))
+all(i32 .. 1, ok)
 all(list, !false)
-all(list, !ok)
+all(list, "bar" in #)
 all(list, "bar" not in #)
-all(list, "foo" >= "foo")
+all(list, "foo" > "foo")
 all(list, # != #)
-all(list, # != foo)
+all(list, # != nil)
+all(list, # == # || f64 != i64)
 all(list, # == #)
 all(list, # == foo)
-all(list, 0.5 != f64)
-all(list, 0.5 != nil)
-all(list, 0.5 <= f64)
-all(list, 0.5 > 1)
-all(list, 1 != 0.5)
-all(list, 1 != i)
-all(list, 1 < f32)
-all(list, 1 < i)
-all(list, 1 <= 0.5)
-all(list, 1 == 1)
-all(list, 1 > f32)
-all(list, 1 >= i64)
-all(list, all(array, true))
-all(list, array != nil)
-all(list, div != div)
-all(list, f32 != 0.5)
-all(list, f32 == f64)
-all(list, f64 < 1)
-all(list, f64 <= 1)
-all(list, f64 <= i)
-all(list, f64 <= i32)
-all(list, f64 >= 1)
-all(list, false) or 0.5 <= 1
-all(list, foo != #)
-all(list, greet != half)
-all(list, greet == score)
-all(list, i <= i64)
-all(list, i32 != i64)
-all(list, i32 < i64)
+all(list, # in list)
+all(list, # not in list)
+all(list, 0.5 < f64)
+all(list, 0.5 < i64)
+all(list, 0.5 <= i64)
+all(list, 0.5 >= i)
+all(list, 0.5 >= i32)
+all(list, 1 != 1)
+all(list, 1 <= 1)
+all(list, 1 > i32)
+all(list, 1 >= f64)
+all(list, add == div)
+all(list, all(array, ok))
+all(list, div != nil)
+all(list, f64 != 0.5)
+all(list, f64 != f32)
+all(list, f64 < i32)
+all(list, f64 > i64)
+all(list, false ? i : true)
+all(list, greet == half)
+all(list, i < f32)
+all(list, i <= 1)
+all(list, i <= i32)
+all(list, i > f64)
+all(list, i > i32)
+all(list, i >= 1)
+all(list, i32 < 1)
 all(list, i32 <= 0.5)
-all(list, i32 <= f64)
-all(list, int(i32) != i32)
+all(list, i32 == f32)
+all(list, i64 != nil)
+all(list, i64 <= 0.5)
+all(list, i64 > 1)
 all(list, list != nil)
 all(list, nil != 1)
-all(list, nil != foo)
+all(list, nil != i64)
+all(list, nil != nil)
+all(list, nil != score)
 all(list, nil == #)
-all(list, nil == greet)
-all(list, nil in list)
-all(list, none(array, ok))
-all(list, not false)
-all(list, not ok)
+all(list, nil == score)
+all(list, nil in array)
+all(list, none(array, 1 > #))
 all(list, not true)
-all(list, ok and false)
 all(list, ok)
-all(list, ok) or ok
-all(list, true != false)
-all(list, true != true)
-all(list, true ? true : 1)
-all(list[i64:i32], !false)
-all(map(array, #), # != #)
-all(map(array, #), # != 0.5)
-all(map(array, #), # >= #)
-all(map(array, #), i64 == #)
-all(map(array, #), true or false)
-all(map(array, 1), ok)
-all(map(array, i), f64 > #)
-all(map(array, ok), #)
-all(map(list, "bar"), ok)
-all(map(list, #), "bar" not in #)
-all(map(list, #), f32 > 1)
-all(map(list, 1), ok)
-all(map(list, false), #)
-all(map(list, i64), # <= #)
+all(list, reduce(array, true))
+all(list, score != add)
+all(list, score != div)
+all(list, type(i) not endsWith .Bar)
+all(map(array, #), ok && false)
+all(map(array, #), ok)
+all(map(array, f32), !ok)
+all(map(array, false), #)
+all(map(array, score), # != #)
+all(map(array, score), ok)
+all(map(list, "bar" not in #), #)
+all(map(list, 0.5), 0.5 <= #)
+all(map(list, i), # == 0.5)
+all(map(list, list), 1 == 0.5)
 all(map(list, ok), #)
-all(map(list, true), # == #)
-all(map(list, true), #)
-all(map(list, true), ok)
-any([0.5, add, 0.5], # == #)
-any([1], i64 >= #)
-any(array, !false)
-any(array, "foo" <= "foo")
+all(reduce(array, array), # > #)
+all(reduce(array, list), ok)
+all(true ? list : false, not true)
+any(["bar"], # not endsWith #)
+any([foo], # != i64)
+any([greet], ok)
+any(array, !(i32 <= #))
+any(array, "foo" >= "foo")
+any(array, "foo" not endsWith "bar")
+any(array, # != # or # > #)
 any(array, # != #)
 any(array, # != 0.5)
-any(array, # != 1)
-any(array, # != i)
+any(array, # != f32)
+any(array, # != f64)
 any(array, # != i32)
 any(array, # != i64)
 any(array, # != nil)
@@ -2926,259 +3169,739 @@ any(array, # < i)
 any(array, # < i32)
 any(array, # <= #)
 any(array, # <= 0.5)
-any(array, # <= 1 ^ #)
 any(array, # <= 1)
+any(array, # <= f32)
 any(array, # <= i)
 any(array, # <= i32)
+any(array, # <= i64)
 any(array, # == #)
+any(array, # == 0.5)
 any(array, # == 1)
-any(array, # == f64)
-any(array, # == i)
 any(array, # == i32)
 any(array, # == i64)
-any(array, # == nil)
 any(array, # > #)
+any(array, # > 0.5)
 any(array, # > 1)
+any(array, # > f64)
 any(array, # > i32)
-any(array, # > i64)
 any(array, # >= #)
 any(array, # >= 0.5)
 any(array, # >= 1)
-any(array, # >= f64)
-any(array, # >= i)
+any(array, # >= f32)
 any(array, # >= i32)
+any(array, # >= i64)
 any(array, # in array)
-any(array, # not in array)
 any(array, 0.5 != #)
-any(array, 0.5 != f64)
-any(array, 0.5 != i)
-any(array, 0.5 < 0.5)
-any(array, 0.5 <= #)
 any(array, 0.5 == #)
-any(array, 0.5 == 0.5)
+any(array, 0.5 == i32)
 any(array, 0.5 > #)
-any(array, 0.5 > f32)
+any(array, 0.5 > f64)
+any(array, 0.5 >= #)
+any(array, 1 != i64)
 any(array, 1 < #)
-any(array, 1 <= i64)
+any(array, 1 < 0.5)
+any(array, 1 <= #)
 any(array, 1 == #)
-any(array, 1 > f64)
-any(array, 1 >= i)
-any(array, 1 >= i32)
-any(array, all(list, true))
-any(array, array == array)
-any(array, div != nil)
-any(array, f32 < #)
+any(array, 1 > #)
+any(array, 1 > 1)
+any(array, 1 >= #)
+any(array, 1 >= f64)
+any(array, add == greet)
+any(array, all(list, false))
+any(array, f32 < i)
 any(array, f32 > #)
+any(array, f32 > 0.5)
+any(array, f32 >= #)
 any(array, f64 != #)
-any(array, f64 != 1)
-any(array, f64 < #)
-any(array, f64 <= 0.5)
-any(array, f64 <= f32)
+any(array, f64 < i)
+any(array, f64 <= #)
 any(array, f64 == #)
 any(array, f64 > #)
 any(array, f64 > 0.5)
-any(array, f64 >= i64)
-any(array, false != nil)
-any(array, false) and f32 != f32
-any(array, greet != half)
-any(array, half != div)
-any(array, half != nil)
-any(array, i != 1)
-any(array, i < # ** #)
-any(array, i <= #)
-any(array, i == #)
-any(array, i == i)
+any(array, false && false)
+any(array, greet == greet)
+any(array, i != #)
+any(array, i < #)
 any(array, i > #)
 any(array, i >= #)
-any(array, i32 != #)
-any(array, i32 != i64)
-any(array, i32 <= #)
-any(array, i32 == #)
-any(array, i32 > #)
-any(array, i32 >= i64)
-any(array, i64 != #)
-any(array, i64 != i64)
-any(array, i64 <= 0.5)
-any(array, i64 == #)
-any(array, i64 > #)
-any(array, i64 > 1)
-any(array, i64 > f32)
-any(array, i64 >= i)
+any(array, i32 > i64)
+any(array, i64 < #)
+any(array, i64 == f64)
+any(array, i64 >= #)
 any(array, nil != #)
-any(array, nil != f64)
-any(array, nil != greet)
+any(array, nil != 1)
+any(array, nil != i)
+any(array, nil != ok)
+any(array, nil == "foo")
 any(array, nil == #)
 any(array, nil == 1)
-any(array, not ok)
-any(array, not true)
+any(array, ok != true)
 any(array, ok)
-any(array, one(list, false))
-any(array, true ? ok : f32)
-any(array, true) and ok
-any(filter(array, ok), ok)
-any(filter(list, false), ok)
-any(filter(list, true), # == #)
+any(array, one(array, # <= 0.5))
+any(array, one(array, ok))
+any(array, score != add)
+any(array, score == half)
+any(array, score == nil)
+any(groupBy(list, #)?.Bar, #)
+any(i32 .. i, half == half)
+any(list, !ok)
 any(list, !true)
-any(list, "bar" contains "foo")
-any(list, "bar" matches "foo")
+any(list, "bar" < "foo")
 any(list, "bar" not in #)
 any(list, "bar" not startsWith "foo")
+any(list, "foo" not in foo)
 any(list, # != #)
-any(list, # != foo)
-any(list, # != nil)
 any(list, # == #)
+any(list, # == foo)
 any(list, # == nil)
-any(list, # in list)
-any(list, # not in list)
+any(list, 0.5 != 1)
 any(list, 0.5 < 1)
-any(list, 0.5 <= f32)
-any(list, 0.5 == 0.5)
-any(list, 0.5 >= 0.5)
-any(list, 0.5 >= f32)
-any(list, 0.5 >= i64)
-any(list, 1 <= 0.5)
-any(list, 1 == f32)
-any(list, f32 != i)
-any(list, f32 == nil)
-any(list, f32 >= i)
-any(list, f64 <= 1)
-any(list, f64 > 0.5)
-any(list, false ? nil : false)
-any(list, foo == foo)
-any(list, greet == div)
-any(list, half != nil)
-any(list, i != 1)
-any(list, i < f32)
-any(list, i < f64)
+any(list, 0.5 < f64)
+any(list, 0.5 == i64)
+any(list, 1 >= f64)
+any(list, 1 >= i32)
+any(list, add == score)
+any(list, any(list, false))
+any(list, any(list, ok))
+any(list, array == nil)
+any(list, f32 < 1)
+any(list, f32 <= i64)
+any(list, f32 > 1)
+any(list, f32 > i64)
+any(list, f32 >= i32)
+any(list, f64 != i64)
+any(list, f64 >= 1)
+any(list, false) == (foo not in list)
+any(list, false) || false ? nil : add
 any(list, i > i64)
-any(list, i32 != i32)
-any(list, i32 < 0.5)
-any(list, i32 == f64)
-any(list, i64 < 1)
-any(list, i64 < f64)
-any(list, i64 < i64)
-any(list, i64 <= i32)
-any(list, i64 >= 1)
-any(list, i64 >= f32)
-any(list, list != nil)
-any(list, nil != #)
-any(list, nil != #?.String())
-any(list, nil != nil)
-any(list, nil == #)
-any(list, nil == 1)
-any(list, nil == i64)
+any(list, i >= 0.5)
+any(list, i32 != 0.5)
+any(list, i64 <= 1)
+any(list, i64 == 0.5)
+any(list, i64 == i)
+any(list, i64 >= i32)
+any(list, i64 not in array)
+any(list, nil == false)
 any(list, nil == nil)
-any(list, not false)
+any(list, none(array, false))
 any(list, not ok)
-any(list, ok and foo != #)
+any(list, ok || # == #)
 any(list, ok)
-any(list, ok) && i <= 1
-any(list, ok) ? array : foo
-any(list, true or ok)
-any(list, true) ? f64 : foo.Bar
-any(map(array, #), # == #)
+any(list, reduce(list, true))
+any(list, true ? false : f64)
+any(map(array, #), # >= #)
 any(map(array, #), ok)
-any(map(array, 0.5), # <= #)
-any(map(array, f64), # < #)
 any(map(array, false), #)
+any(map(array, ok), # and #)
 any(map(array, ok), #)
-any(map(list, #), i == f64)
-any(map(list, #), ok)
-any(map(list, 1), # != #)
-any(map(list, array), ok)
-any(map(list, foo), # != #)
-any(map(list, greet), # == #)
-any(ok ? "bar" : half, ok)
-any(splitAfter("bar", "foo"), # not startsWith #)
+any(map(list, #), nil == #)
+any(map(list, false), nil == i32)
+any(map(list, ok), #)
+any(ok ? "foo" : 1, ok)
+any(ok ? "foo" : f32, i > #)
+any(reduce(array, array), 1 == #)
 array
-array != [array]
 array != array
-array != filter(list, true)
+array != array ? 1 : false
+array != array ? score : i32
 array != list
-array != map(array, i)
-array != nil != ok
-array != nil ? 0.5 : i32
-array != nil ? true : nil
-array != nil or nil == f32
-array != nil || ok
-array != sort(array)
-array != {"bar": f32, "foo": 1}.ok
+array != list ? list : f64
+array != map(array, #)
+array != map(array, 1)
+array != map(list, #)
+array != map(list, true)
+array != nil ? add : 0.5
 array == array
-array == array ? "foo" : 0.5
+array == array ? half : false
 array == list
-array == list ? i : half
-array == map(array, #)
-array == map(array, add)
-array == nil != nil
-array == nil != true ? 0.5 : 0.5
-array == nil && (false || ok)
-array[-1]
+array == map(array, score)
+array == map(list, #)
+array == nil ? list : float(f32)
+array not in sort(array)
 array[-i32]
 array[-i64]
 array[-i]
-array[1 % 1]
-array[1 % i:i64]
-array[1] != f32
-array[1] != score(i)
-array[1] <= f64
-array[1] == f32
-array[1] == i64
-array[1] ^ 0.5 ^ f64
-array[1] ^ i32
-array[false ? half : 0.5]
-array[false ? i : i32]
-array[i - i64]
-array[i32:i32]
+array[1 % i64]
+array[1 + 1]
+array[1] * i32
+array[1] * i64
+array[1] - f64
+array[1] / i32
+array[1] == -i
+array[1] > i
+array[1] ^ i
+array[abs(1)]
+array[array[i32]]
+array[bitnot(1)]
+array[bitor(1, i)]
+array[count(list, ok)]
+array[get(array, 1)]
+array[i32 * 1]
+array[i32:i]
 array[i32]
+array[i32] != i
+array[i32] % i32
+array[i32] * f64
+array[i32] ** i32
+array[i32] + i64
 array[i32] - f64
-array[i32] .. i32
-array[i64 % 1]
-array[i64:i32]
-array[i64:i]
+array[i32] / f32
+array[i32] == i32
+array[i32] == i64
+array[i32] > f64
+array[i32] >= f32
+array[i64:i64]
 array[i64]
-array[i64] ** f32
-array[i64] / i
-array[i64] < i
-array[i64] == f64
-array[i64] > f32
-array[i64] >= -i64
+array[i64] .. i32
+array[i64] == floor(0.5)
+array[i64] == i
+array[i64] > half(f64)
+array[i64] ^ f64
+array[i:i32]
 array[i:i64]
-array[i:i]
 array[i]
-array[i] ** i64
+array[i] * f64
 array[i] + f32
-array[i] < i
-array[i] == min(i32, i)
-array[i] > i32
-array[int(1)]
-array[int(i32)]
-array[max(i64)]
-array[min(1)]
-array[min(i32)]
-array[min(i64)]
+array[i] - f32
+array[i] / f64
+array[i] < round(i)
+array[i] == i32
+array[i] > f64
+array[i] >= 0.5 ** i
+array[max(1)]
+array[reduce(list, 1)]
+array[score(1):i]
 array[score(1)]
 array[score(i)]
-count([list], false or ok)
+bitand(1 * i64, i)
+bitand(1, 1) != i
+bitand(1, i64) == f64
+bitand(i, i)
+bitand(i, i32)
+bitand(i, i64)
+bitand(i32, 1) != f32
+bitand(i32, i)
+bitand(i32, i) - i32
+bitand(i32, i32 * i)
+bitand(i32, i32)
+bitand(i32, i64)
+bitand(i64, 1) <= i32
+bitand(i64, i + i64)
+bitand(i64, i)
+bitand(i64, i) ^ f64
+bitand(i64, i32)
+bitand(i64, i64)
+bitand(int(i32), i64)
+bitnand(1, i64) != int(i64)
+bitnand(i, i)
+bitnand(i, i32 + i32)
+bitnand(i, i32)
+bitnand(i, i64)
+bitnand(i32, bitnot(1))
+bitnand(i32, i)
+bitnand(i32, i32)
+bitnand(i32, i64)
+bitnand(i64 + i, i32)
+bitnand(i64 + i64, i64)
+bitnand(i64, -1)
+bitnand(i64, 1) + i64 + 1
+bitnand(i64, i)
+bitnand(i64, i32)
+bitnand(i64, i32) > f64
+bitnand(i64, i64)
+bitnot(-1)
+bitnot(-i)
+bitnot(-i32)
+bitnot(-i64)
+bitnot(1 % 1)
+bitnot(1 % i32)
+bitnot(1 % i64)
+bitnot(1 * 1)
+bitnot(1 * i64)
+bitnot(1 + 1)
+bitnot(1 - i)
+bitnot(1 - i32)
+bitnot(1) * i % 1
+bitnot(1) ** f32
+bitnot(1) ** i
+bitnot(1) + i32
+bitnot(1) - i
+bitnot(1) - i32
+bitnot(1) / min(i)
+bitnot(1) < i32
+bitnot(1) < i64
+bitnot(1) == i32
+bitnot(1) > f64
+bitnot(1) >= i
+bitnot(1) >= i64
+bitnot(abs(1))
+bitnot(abs(i32))
+bitnot(abs(i64))
+bitnot(array[1])
+bitnot(array[i64])
+bitnot(array[i])
+bitnot(bitnot(i))
+bitnot(bitushr(1, 1))
+bitnot(bitushr(i32, 1))
+bitnot(bitxor(i, i64))
+bitnot(count(array, false))
+bitnot(findLast(array, ok))
+bitnot(first(array))
+bitnot(get(array, 1))
+bitnot(get(array, i))
+bitnot(i % i64)
+bitnot(i * i)
+bitnot(i * i32)
+bitnot(i + 1)
+bitnot(i - 1)
+bitnot(i - i64)
+bitnot(i)
+bitnot(i) % i32
+bitnot(i) * i
+bitnot(i) + f64
+bitnot(i) .. i64
+bitnot(i) == 1 - i
+bitnot(i) > i
+bitnot(i) >= i32
+bitnot(i) ^ f32
+bitnot(i) ^ f64
+bitnot(i) in array
+bitnot(i32 % 1)
+bitnot(i32 % i64)
+bitnot(i32 + i)
+bitnot(i32 + i32)
+bitnot(i32 - 1)
+bitnot(i32 - i32)
+bitnot(i32)
+bitnot(i32) != f64
+bitnot(i32) != i32
+bitnot(i32) * i
+bitnot(i32) * i64
+bitnot(i32) ** f32
+bitnot(i32) - i32
+bitnot(i32) / f64
+bitnot(i32) == i64
+bitnot(i32) > 1 != true
+bitnot(i32) >= f32
+bitnot(i64 % 1)
+bitnot(i64 % i)
+bitnot(i64 % i32)
+bitnot(i64 * 1)
+bitnot(i64 * i)
+bitnot(i64 * i32)
+bitnot(i64 * i64)
+bitnot(i64 - 1)
+bitnot(i64 - i)
+bitnot(i64 - i64)
+bitnot(i64)
+bitnot(i64) % i32
+bitnot(i64) * f32
+bitnot(i64) < f32
+bitnot(i64) > f64
+bitnot(i64) > i % i
+bitnot(i64) >= i32 ^ f32
+bitnot(i64) ^ f64
+bitnot(i64) not in array
+bitnot(int(f32))
+bitnot(int(f64))
+bitnot(int(i))
+bitnot(int(i32))
+bitnot(int(i64))
+bitnot(last(array))
+bitnot(len("bar"))
+bitnot(len("foo"))
+bitnot(len(list))
+bitnot(max(1))
+bitnot(max(1, i64))
+bitnot(max(i))
+bitnot(max(i32))
+bitnot(min(1))
+bitnot(min(i32))
+bitnot(min(i64))
+bitnot(ok ? 1 : array)
+bitnot(ok ? 1 : ok)
+bitnot(ok ? i : add)
+bitnot(reduce(array, #))
+bitnot(reduce(array, 1))
+bitnot(reduce(list, 1))
+bitnot(score(1))
+bitnot(score(i))
+bitnot(sum(array))
+bitor(1, 1) < i
+bitor(1, 1) == i
+bitor(1, i32) != i64
+bitor(i, -i64)
+bitor(i, i)
+bitor(i, i64)
+bitor(i32, i)
+bitor(i32, i32)
+bitor(i32, i64)
+bitor(i64 % 1, i32)
+bitor(i64, i)
+bitor(i64, i32)
+bitor(i64, i64)
+bitor(min(i64), i)
+bitor(score(i), i64)
+bitshl(bitnot(i), i)
+bitshl(i, i)
+bitshl(i, i32)
+bitshl(i, i64)
+bitshl(i32, i)
+bitshl(i32, i32)
+bitshl(i32, i64)
+bitshl(i64, i32)
+bitshl(i64, i64)
+bitshl(len(array), i)
+bitshl(score(i), i32)
+bitshr(i % 1, i32)
+bitshr(i, 1) - i64
+bitshr(i, i32)
+bitshr(i, i64)
+bitshr(i32, i)
+bitshr(i32, i) - f32
+bitshr(i32, i32)
+bitshr(i32, i64)
+bitshr(i64, i32)
+bitshr(i64, i64)
+bitushr(-i64, i64)
+bitushr(1 % i, i)
+bitushr(1, i) * i
+bitushr(abs(1), i32)
+bitushr(i, i)
+bitushr(i, i) % i64
+bitushr(i, i32)
+bitushr(i, i64)
+bitushr(i32, i)
+bitushr(i32, i32)
+bitushr(i32, i64)
+bitushr(i64, i)
+bitushr(i64, i32)
+bitushr(i64, i64)
+bitxor(-i, i64)
+bitxor(1, i) * i
+bitxor(bitnot(1), -i)
+bitxor(i, i32)
+bitxor(i, i64)
+bitxor(i32, 1) > i64
+bitxor(i32, i)
+bitxor(i32, i) ** f64
+bitxor(i32, i32)
+bitxor(i32, i64)
+bitxor(i32, i64) ** i32
+bitxor(i64, i)
+bitxor(i64, i32)
+bitxor(i64, i64)
+bitxor(score(1), i)
+ceil(-0.5)
+ceil(-1)
+ceil(-f32)
+ceil(-f64)
+ceil(-i)
+ceil(-i32)
+ceil(-i64)
+ceil(0.5 * 0.5)
+ceil(0.5 * 1)
+ceil(0.5 * f64)
+ceil(0.5 * i)
+ceil(0.5 ** 1)
+ceil(0.5 ** f64)
+ceil(0.5 ** i)
+ceil(0.5 + 0.5)
+ceil(0.5 + 1)
+ceil(0.5 + f32)
+ceil(0.5 + f64)
+ceil(0.5 + i)
+ceil(0.5 + i32)
+ceil(0.5 + i64)
+ceil(0.5 - 0.5)
+ceil(0.5 - f64)
+ceil(0.5 - i)
+ceil(0.5 / 0.5)
+ceil(0.5 / 1)
+ceil(0.5 / f32)
+ceil(0.5 / i)
+ceil(0.5 / i32)
+ceil(0.5 ^ 1)
+ceil(0.5 ^ f32)
+ceil(0.5 ^ i32)
+ceil(0.5 ^ i64)
+ceil(0.5) != 0.5 * 0.5
+ceil(0.5) != i
+ceil(0.5) != nil ? score : "foo"
+ceil(0.5) ** round(f32)
+ceil(0.5) - i
+ceil(0.5) < i
+ceil(0.5) == f32
+ceil(0.5) == i ? div : half
+ceil(0.5) == i64
+ceil(0.5) > f64
+ceil(0.5) >= i
+ceil(0.5) >= i64
+ceil(0.5) ^ i64
+ceil(1 % i64)
+ceil(1 * 0.5)
+ceil(1 * 1)
+ceil(1 ** 1)
+ceil(1 + 0.5)
+ceil(1 + 1)
+ceil(1 + f64)
+ceil(1 + i)
+ceil(1 - 0.5)
+ceil(1 - f64)
+ceil(1 / 0.5)
+ceil(1 / 1)
+ceil(1 / f64)
+ceil(1 / i64)
+ceil(1 ^ f64)
+ceil(1 ^ i)
+ceil(1 ^ i64)
+ceil(1) ** f32
+ceil(1) + i32
+ceil(1) / i
+ceil(1) < f32 ^ i
+ceil(1) <= f32
+ceil(1) <= i64
+ceil(1) == f32
+ceil(1) > f32
+ceil(1) >= f32
+ceil(1) >= i64 ** 0.5
+ceil(1) ^ i
+ceil(abs(0.5))
+ceil(abs(1))
+ceil(abs(f32))
+ceil(abs(f64))
+ceil(abs(i32))
+ceil(abs(i64))
+ceil(add(1, 1))
+ceil(array[1])
+ceil(array[i64])
+ceil(array[i])
+ceil(bitnot(1))
+ceil(bitnot(i))
+ceil(ceil(0.5))
+ceil(ceil(f64))
+ceil(ceil(i))
+ceil(ceil(i32))
+ceil(count(list, ok))
+ceil(f32 * 0.5)
+ceil(f32 * i)
+ceil(f32 * i32)
+ceil(f32 ** i)
+ceil(f32 ** i32)
+ceil(f32 + 1)
+ceil(f32 + i64)
+ceil(f32 - f32)
+ceil(f32 - i)
+ceil(f32 - i32)
+ceil(f32 - i64)
+ceil(f32 / 0.5)
+ceil(f32 / f64)
+ceil(f32 / i32)
+ceil(f32 ^ 0.5)
+ceil(f32 ^ 1)
+ceil(f32 ^ i64)
+ceil(f32)
+ceil(f32) != i64
+ceil(f32) * i64
+ceil(f32) ** -1
+ceil(f32) ** i
+ceil(f32) + i
+ceil(f32) + i64
+ceil(f32) - i32
+ceil(f32) / i64
+ceil(f32) < i
+ceil(f32) < i32
+ceil(f64 * 1)
+ceil(f64 * i)
+ceil(f64 ** i)
+ceil(f64 ** i64)
+ceil(f64 + 1)
+ceil(f64 + f32)
+ceil(f64 - 0.5)
+ceil(f64 - f32)
+ceil(f64 - f64)
+ceil(f64 - i32)
+ceil(f64 / 0.5)
+ceil(f64 / f64)
+ceil(f64 / i32)
+ceil(f64 / i64)
+ceil(f64 ^ 0.5)
+ceil(f64 ^ f32)
+ceil(f64 ^ f64)
+ceil(f64 ^ i32)
+ceil(f64 ^ i64)
+ceil(f64)
+ceil(f64) != i
+ceil(f64) != i64
+ceil(f64) * f32
+ceil(f64) ** f32
+ceil(f64) - i32
+ceil(f64) / f64
+ceil(f64) / i / i64
+ceil(f64) in array
+ceil(false ? add : 0.5)
+ceil(find(array, ok))
+ceil(findLast(array, true))
+ceil(findLastIndex(list, ok))
+ceil(findLastIndex(list, true))
+ceil(first(array))
+ceil(float(0.5))
+ceil(float(1))
+ceil(float(f64))
+ceil(float(i))
+ceil(float(i32))
+ceil(float(i64))
+ceil(floor(0.5))
+ceil(floor(1))
+ceil(floor(f64))
+ceil(floor(i))
+ceil(floor(i32))
+ceil(floor(i64))
+ceil(get(array, 1))
+ceil(get(array, i))
+ceil(half(0.5))
+ceil(half(1))
+ceil(half(f64))
+ceil(i % i)
+ceil(i * 0.5)
+ceil(i * i)
+ceil(i ** f64)
+ceil(i ** i)
+ceil(i + 0.5)
+ceil(i + 1)
+ceil(i + f32)
+ceil(i + i64)
+ceil(i - i)
+ceil(i / f32)
+ceil(i / i)
+ceil(i / i64)
+ceil(i ^ i)
+ceil(i ^ i32)
+ceil(i)
+ceil(i) != i32
+ceil(i) * f64
+ceil(i) * i64
+ceil(i) ** f64
+ceil(i) + i
+ceil(i) - f32
+ceil(i) / f32
+ceil(i) <= f64
+ceil(i) == i32
+ceil(i) > i64
+ceil(i32 * i)
+ceil(i32 * i32)
+ceil(i32 ** i32)
+ceil(i32 + 0.5)
+ceil(i32 + i32)
+ceil(i32 - 0.5)
+ceil(i32 - 1)
+ceil(i32 - i)
+ceil(i32 - i64)
+ceil(i32 / 0.5)
+ceil(i32 / f32)
+ceil(i32 / i)
+ceil(i32 / i32)
+ceil(i32 ^ 0.5)
+ceil(i32 ^ i64)
+ceil(i32)
+ceil(i32) * 1 ^ i32
+ceil(i32) * i32
+ceil(i32) ** max(i)
+ceil(i32) + f32
+ceil(i32) + i
+ceil(i32) + i32
+ceil(i32) <= i64
+ceil(i32) not in array
+ceil(i64 % 1)
+ceil(i64 % i32)
+ceil(i64 * f32)
+ceil(i64 * f64)
+ceil(i64 ** i32)
+ceil(i64 ** i64)
+ceil(i64 + 0.5)
+ceil(i64 + f64)
+ceil(i64 + i32)
+ceil(i64 - 0.5)
+ceil(i64 - f64)
+ceil(i64 / 0.5)
+ceil(i64 / 1)
+ceil(i64 / f64)
+ceil(i64 ^ 0.5)
+ceil(i64 ^ i)
+ceil(i64 ^ i32)
+ceil(i64 ^ i64)
+ceil(i64)
+ceil(i64) - -1
+ceil(i64) - f32
+ceil(i64) - i32
+ceil(i64) / (0.5 - f32)
+ceil(i64) >= f32
+ceil(i64) ^ i32
+ceil(int(0.5))
+ceil(int(f32))
+ceil(int(f64))
+ceil(int(i))
+ceil(int(i64))
+ceil(len("bar"))
+ceil(len(array))
+ceil(len(list))
+ceil(max(1, i))
+ceil(max(f32, 0.5))
+ceil(max(f64))
+ceil(max(i))
+ceil(mean(array))
+ceil(median(array))
+ceil(min(0.5, f32))
+ceil(min(1))
+ceil(min(f32))
+ceil(min(f64))
+ceil(min(i))
+ceil(min(i64))
+ceil(ok ? f32 : nil)
+ceil(ok ? i32 : "bar")
+ceil(ok ? i32 : i64)
+ceil(reduce(array, #))
+ceil(reduce(array, 0.5))
+ceil(reduce(list, 1))
+ceil(round(0.5))
+ceil(round(1))
+ceil(round(f32))
+ceil(round(f64))
+ceil(round(i))
+ceil(round(i32))
+ceil(round(i64))
+ceil(score(1))
+ceil(score(i))
+ceil(true ? 1 : half)
+ceil(true ? 1 : nil)
+ceil(true ? f64 : nil)
+count(["bar", score, i], 1 != #)
+count(["bar"], # startsWith #)
+count([0.5], ok)
+count([greet], ok)
+count([i32], f32 != #)
+count([list, 0.5], # not in list)
+count([nil], ok)
 count(array, !ok)
-count(array, "bar" != "bar")
+count(array, !true)
+count(array, "bar" <= "bar")
 count(array, "bar" not endsWith "bar")
+count(array, "foo" matches "foo")
 count(array, # != #)
-count(array, # != f32)
-count(array, # != i32)
+count(array, # != 0.5)
+count(array, # != i)
+count(array, # != i64)
+count(array, # != nil)
 count(array, # < #)
-count(array, # < 0.5)
-count(array, # < 1)
-count(array, # < f32)
-count(array, # < f64)
 count(array, # < i)
-count(array, # < i64)
+count(array, # < i32)
 count(array, # <= #)
 count(array, # <= 0.5)
-count(array, # <= f32)
-count(array, # <= f64)
+count(array, # <= 1)
 count(array, # <= i)
 count(array, # <= i32)
 count(array, # == #)
+count(array, # == 0.5)
 count(array, # == 1)
 count(array, # == f32)
 count(array, # == i)
@@ -3188,2512 +3911,2582 @@ count(array, # > #)
 count(array, # > 0.5)
 count(array, # > i)
 count(array, # > i64)
-count(array, # >= # / #)
 count(array, # >= #)
 count(array, # >= 0.5)
 count(array, # >= 1)
-count(array, # >= f64)
+count(array, # >= f32)
 count(array, # >= i)
-count(array, # >= i64)
+count(array, # in array)
+count(array, # not in array)
 count(array, 0.5 != #)
+count(array, 0.5 < #)
 count(array, 0.5 <= #)
+count(array, 0.5 <= f32)
+count(array, 0.5 <= f64)
 count(array, 0.5 == #)
+count(array, 0.5 == f32)
+count(array, 0.5 == i)
 count(array, 0.5 > #)
-count(array, 0.5 > 1)
-count(array, 0.5 >= #)
-count(array, 0.5 >= 0.5)
-count(array, 0.5 >= i)
 count(array, 1 != #)
+count(array, 1 != 0.5)
 count(array, 1 < #)
-count(array, 1 < 0.5)
-count(array, 1 < 1)
 count(array, 1 <= #)
-count(array, 1 > #)
+count(array, 1 == #)
 count(array, 1 >= #)
-count(array, add == half)
-count(array, f32 != i)
-count(array, f32 < # ? true : half)
-count(array, f32 < #)
-count(array, f32 < 0.5)
+count(array, any(array, true))
+count(array, div(#, 1) >= #)
 count(array, f32 <= #)
-count(array, f32 <= 1)
-count(array, f32 <= i)
 count(array, f32 == #)
-count(array, f32 == 1)
-count(array, f64 != #)
 count(array, f64 < #)
+count(array, f64 < f32)
 count(array, f64 <= #)
+count(array, f64 <= 1)
 count(array, f64 == #)
-count(array, f64 > #)
-count(array, false == true)
-count(array, false) != f64
-count(array, false) / i
-count(array, false) >= f32
+count(array, false) ** i32
+count(array, false) + f32
+count(array, false) - i64
+count(array, false) / f64
+count(array, false) > i64 * i64
+count(array, foo in list)
 count(array, foo not in list)
-count(array, greet != greet)
-count(array, greet == score)
-count(array, i != f32)
-count(array, i == nil)
-count(array, i > #)
+count(array, i != #)
+count(array, i < #)
+count(array, i < 0.5)
+count(array, i <= #)
+count(array, i == #)
+count(array, i > i64)
 count(array, i >= #)
-count(array, i32 != 1)
+count(array, i32 != #)
+count(array, i32 != i)
 count(array, i32 < #)
-count(array, i32 < 0.5)
+count(array, i32 < 1)
+count(array, i32 <= #)
+count(array, i32 <= f32)
 count(array, i32 == #)
-count(array, i32 > i)
+count(array, i32 == 0.5)
+count(array, i32 > #)
 count(array, i32 >= #)
-count(array, i32 >= 1)
-count(array, i64 != #)
+count(array, i32 >= f32)
+count(array, i32 >= i32)
+count(array, i64 != i32)
+count(array, i64 != i64)
 count(array, i64 < #)
-count(array, i64 <= 1)
-count(array, i64 <= f64)
+count(array, i64 <= #)
 count(array, i64 == #)
 count(array, i64 == i64)
 count(array, i64 > 1)
-count(array, i64 > f32)
-count(array, nil != #)
-count(array, nil == #)
-count(array, nil == foo)
-count(array, not ok)
+count(array, list != array)
+count(array, list != nil)
+count(array, nil != "foo")
+count(array, nil != f64)
+count(array, nil == 1)
+count(array, nil == list)
+count(array, nil == nil)
+count(array, none(array, false))
+count(array, not false)
+count(array, ok or false)
 count(array, ok)
-count(array, ok) + i64
-count(array, ok) - i64
-count(array, ok) .. i64
-count(array, one(array, false))
-count(array, true ? false : 0.5)
-count(array, true) != 1 ^ f32
-count(array, true) ** f32
-count(array, true) / int(0.5)
-count(array, true) >= f64 / 0.5
-count(filter(list, false), ok)
-count(i .. 1, # > #)
-count(i .. i32, # > #)
-count(i32 .. 1, # == #)
-count(i64 .. i, div == nil)
-count(i64 .. i, ok)
+count(array, ok) * i32
+count(array, ok) ^ i
+count(array, reduce(list, false))
+count(array, true == ok)
+count(array, true) / f64
+count(filter(list, true), ok)
+count(groupBy(array, #)?.String, #)
+count(groupBy(list, #).String, .div?.array)
+count(groupBy(list, #)?.list, #?.Qux)
+count(i .. 1, # == i)
+count(i .. i, ok)
+count(i32 .. i, # >= #)
+count(i64 .. 1, nil != f32)
 count(list, !false)
-count(list, !ok)
-count(list, "bar" == "bar")
-count(list, "bar" in #)
-count(list, "bar" matches "foo")
-count(list, "bar" not in #)
+count(list, !true)
+count(list, "bar" not matches "bar")
 count(list, "foo" in #)
-count(list, "foo" not in #)
 count(list, # != #)
-count(list, # != nil)
 count(list, # == #)
 count(list, # == nil)
-count(list, 0.5 == f32)
+count(list, # in list)
+count(list, 0.5 < f32)
+count(list, 0.5 <= 0.5)
+count(list, 0.5 <= i64)
 count(list, 0.5 > 0.5)
-count(list, 0.5 >= i32)
-count(list, 1 != 1)
-count(list, 1 != f32)
-count(list, 1 < 0.5)
-count(list, 1 <= i)
+count(list, 0.5 > 1)
+count(list, 0.5 > f32)
+count(list, 1 != i)
+count(list, 1 >= 0.5)
 count(list, 1 >= f32)
-count(list, 1 >= i32)
-count(list, all(list, true))
-count(list, f32 <= i32)
-count(list, f64 != i)
-count(list, false ? # : ok)
-count(list, false or ok)
-count(list, false || false)
-count(list, false) .. i32
-count(list, false) > i64
-count(list, foo != #)
-count(list, half == div)
-count(list, i == i64)
-count(list, i32 == i)
-count(list, i32 == i32)
-count(list, list == array)
+count(list, add != half)
+count(list, div == score)
+count(list, f32 == i64)
+count(list, f32 >= f32)
+count(list, false && false)
+count(list, false) + -1
+count(list, false) / f64
+count(list, false) > f32
+count(list, foo == #)
+count(list, greet != score)
+count(list, i != i64)
+count(list, i < 0.5)
+count(list, i <= i64)
+count(list, i > 1)
+count(list, i32 < f32)
+count(list, i32 < i64)
+count(list, i64 not in array)
 count(list, nil != #)
-count(list, nil != score)
-count(list, nil == #)
-count(list, nil == add)
-count(list, nil == true)
-count(list, none(list, ok))
+count(list, nil != false)
+count(list, nil == list)
 count(list, not false)
-count(list, not ok)
-count(list, not true)
-count(list, ok == nil)
 count(list, ok)
-count(list, ok) - i32
-count(list, ok) < f64
-count(list, ok) > -0.5
-count(list, ok) >= i
-count(list, true and ok)
-count(list, true) ** i64
-count(list, true) == f64
-count(list, true) ^ i64
-count(map(array, #), # != #)
-count(map(array, #), # > #)
-count(map(array, #), i == #)
+count(list, ok) % i64
+count(list, ok) / half(1)
+count(list, ok) / i
+count(list, ok) >= i32
+count(list, ok) ^ i
+count(list, ok) ^ i64
+count(list, true or ok)
+count(list, true || true)
+count(list, true) * f32
+count(list, true) == i
+count(map(array, #), # == i32)
+count(map(array, #), not true)
 count(map(array, #), ok)
-count(map(array, add), ok)
-count(map(array, div), ok)
-count(map(array, foo), ok)
-count(map(array, i32), 0.5 == f32)
-count(map(array, i32), 1 != #)
-count(map(array, i64), # == 0.5)
-count(map(array, true), #)
-count(map(list, #), "bar" in #)
-count(map(list, #), # == #)
-count(map(list, #), # == nil)
-count(map(list, 0.5), # != nil)
-count(map(list, f32), # <= #)
-count(map(list, true), #)
-count(sort(array), foo == #)
-count(sort(array), ok)
-date("bar", "bar")?.String
+count(map(array, false), #)
+count(map(array, i), ok)
+count(map(array, i32), 1 == #)
+count(map(array, i64), f64 != nil)
+count(map(array, ok), !#)
+count(map(list, 0.5), "bar" == "foo")
+count(map(list, div), ok)
+count(map(list, f32), # == #)
+count(map(list, greet), ok)
+count(map(list, i32), # != i64)
+count(map(list, ok), #)
+count(map(list, ok), 0.5 <= i64)
+count(ok ? array : i64, # > 0.5)
+count(sort(array), 1 <= #)
 div
 div != add
-div != add != ok
+div != add != nil
+div != add == ok
 div != div
-div != div ? score : 0.5
-div != div or half != greet
+div != div != ok
+div != div && ok
+div != div ? "bar" : "foo"
 div != foo.Qux
 div != foo.String
 div != foo?.Qux
+div != foo?.String
 div != greet
+div != greet != ok
+div != greet or ok
 div != half
-div != half ? f32 : ok
-div != half and !ok
-div != nil != ok
-div != nil ? array : add
-div != nil ? i : i64
+div != half != true
+div != half ? false : div
+div != half ? greet : true
+div != nil == ok
+div != nil || f32 < 0.5
+div != reduce(array, div)
 div != score
+div != score != true
 div == add
+div == add ? 1 : ok
 div == div
-div == div ? 0.5 : half
-div == div ? nil : i
-div == div || true ? f32 : add
 div == foo.Qux
 div == foo.String
 div == foo?.Qux
 div == foo?.String
 div == greet
-div == greet != ok
-div == greet || !false
+div == greet == nil
+div == greet ? 1 : 1
 div == half
-div == nil ? greet : foo
-div == nil ? half : half
-div == nil ? score : i64
-div == nil || ok
+div == half != false
+div == nil ? f32 : half
+div == nil ? false : 1
 div == score
-div == score == ok
-div == score ? true : "bar"
-div in map(list, add)
-div not in [add]
-div not in [half, f32, false]
-div not in map(array, div)
-div(-1, i)
-div(1, 1) > i64
-div(1, i) >= i64
-div(i, 1) / f32
-div(i, 1) == i
+div == score ? "bar" : true
+div == score or f32 != f64
+div(-i, array[i64])
+div(-i, i)
+div(1, i) + i
+div(findLast(array, true), i)
+div(i, -1)
 div(i, i)
+div(last(array), 1 * i32)
+div(score(1), bitnot(1))
 f32
-f32 != --f64
+f32 != -0.5
 f32 != -1
-f32 != 0.5 * f32
-f32 != 0.5 + i64
-f32 != 0.5 / i64
+f32 != -f32
+f32 != 0.5 != false
+f32 != 0.5 * 1
+f32 != 0.5 * i64
+f32 != 0.5 ** f32
+f32 != 0.5 + 1
+f32 != 0.5 - i64
+f32 != 0.5 / 0.5
+f32 != 0.5 / i32
 f32 != 0.5 == ok
-f32 != 0.5 ? array : ok
-f32 != 0.5 ? list : 1
-f32 != 0.5 ^ i32
-f32 != 1 % i32
-f32 != 1 * 1
-f32 != 1 * i64
-f32 != 1 ** 0.5
-f32 != 1 - i
-f32 != 1 ? "foo" : foo
-f32 != 1 ^ f32
-f32 != abs(i64)
+f32 != 0.5 == true
+f32 != 0.5 ? array : score
+f32 != 0.5 ? foo : f64
+f32 != 0.5 ? true : i32
+f32 != 0.5 ^ 1
+f32 != 0.5 ^ f32
+f32 != 1 && ok
+f32 != 1 * i
+f32 != 1 + i64
 f32 != f32
-f32 != f32 + f64
-f32 != f32 - f64
+f32 != f32 / 0.5
+f32 != f32 / f32
 f32 != f64
-f32 != f64 ** i32
-f32 != f64 + i32
-f32 != f64 - f32
-f32 != f64 ^ i32
-f32 != findIndex(list, ok)
-f32 != float(i)
+f32 != findLast(array, ok)
+f32 != findLastIndex(array, ok)
+f32 != floor(0.5)
+f32 != half(0.5)
 f32 != i
-f32 != i * i64
-f32 != i - f64
+f32 != i != true
+f32 != i % 1
+f32 != i % i
+f32 != i ** i64
+f32 != i / f64
 f32 != i32
+f32 != i32 % i
+f32 != i32 * i32
+f32 != i32 + 0.5
 f32 != i64
-f32 != i64 * 1
-f32 != i64 ? f64 : f32
+f32 != i64 != nil
+f32 != i64 != true
+f32 != i64 ? 0.5 : f64
+f32 != i64 ^ i32
+f32 != int(f32)
+f32 != int(i32)
 f32 != len(array)
-f32 != max(i)
-f32 != min(1)
-f32 != min(f64)
-f32 != nil ? half : greet
+f32 != nil ? true : score
+f32 != nil || ok
+f32 != round(i)
 f32 != score(1)
-f32 * (1 - f32)
-f32 * (i + 1)
-f32 * (i32 + f32)
-f32 * (i64 + f32)
-f32 * (i64 - i64)
+f32 != score(1, i)
+f32 * (0.5 + f64)
+f32 * (0.5 + i32)
+f32 * (0.5 - f32)
+f32 * (f64 + f64)
+f32 * (f64 + i64)
+f32 * (f64 - i)
 f32 * -0.5
-f32 * -f32
+f32 * -1
 f32 * -f64
-f32 * -i32
-f32 * 0.5 != f32
-f32 * 0.5 ** f32
-f32 * 0.5 - f32
-f32 * 0.5 < f64
-f32 * 0.5 < i32
-f32 * 0.5 <= f32
-f32 * 0.5 <= f32 ? "bar" : array
-f32 * 0.5 <= i64
+f32 * -i
+f32 * -i64
+f32 * -len(array)
+f32 * 0.5 * 0.5
+f32 * 0.5 * i
+f32 * 0.5 * i32
+f32 * 0.5 - i32
+f32 * 0.5 / i
+f32 * 0.5 <= i
+f32 * 0.5 ^ f32
+f32 * 0.5 not in array
 f32 * 1 != f32
-f32 * 1 * 1
-f32 * 1 ** f64
-f32 * 1 + i
-f32 * 1 - i
-f32 * 1 / i64
-f32 * 1 < f64
-f32 * 1 <= f32
-f32 * 1 >= i32
-f32 * array[i64]
-f32 * count(array, ok)
+f32 * 1 * f64
+f32 * 1 * i32
+f32 * 1 ** 0.5
+f32 * 1 + f64
+f32 * 1 < i64
+f32 * 1 >= i64
+f32 * 1 ^ i64
+f32 * ceil(i)
 f32 * f32
-f32 * f32 * i
-f32 * f32 ^ i64
+f32 * f32 * 0.5
+f32 * f32 < i32
+f32 * f32 <= i64
+f32 * f32 > f32 - 1
+f32 * f32 ^ 0.5
+f32 * f32 in array
 f32 * f64
-f32 * f64 * i64
-f32 * f64 + f32
-f32 * f64 - i
-f32 * f64 ^ f32
-f32 * findIndex(list, true)
-f32 * float(0.5)
+f32 * f64 + f64
+f32 * f64 + i32
+f32 * f64 / i64
+f32 * f64 >= 1 - i
+f32 * float(i)
+f32 * float(i32)
+f32 * floor(0.5)
+f32 * floor(i)
+f32 * half(0.5)
+f32 * half(1)
+f32 * half(f64)
 f32 * i
-f32 * i < f64
-f32 * i <= -i64
-f32 * i <= min(0.5, f64)
+f32 * i != i32
+f32 * i - i
+f32 * i / f64
+f32 * i == i64
 f32 * i32
-f32 * i32 ** 1
-f32 * i32 - i64
+f32 * i32 != max(i)
+f32 * i32 * i32
+f32 * i32 ** 0.5
+f32 * i32 >= i
 f32 * i64
-f32 * i64 ** 0.5
-f32 * i64 ** i64
-f32 * i64 < f64
-f32 * i64 < half(f64)
-f32 * i64 ^ i
-f32 * i64 ^ i64
-f32 * int(f64)
-f32 * max(f32)
-f32 * min(0.5)
-f32 * min(f64)
-f32 * score(1)
-f32 ** (0.5 + i)
-f32 ** (0.5 - 0.5)
-f32 ** (1 - i64)
-f32 ** (1 / 0.5)
-f32 ** (f32 * i)
-f32 ** (f32 + 0.5)
-f32 ** (f32 + i64)
-f32 ** (f32 - 1)
-f32 ** (f64 - i32)
-f32 ** (i32 * 1)
-f32 ** (i32 * i)
+f32 * i64 != f64
+f32 * i64 ** i
+f32 * int(i64)
+f32 * min(i64)
+f32 * reduce(array, 1)
+f32 * reduce(list, 1)
+f32 * round(f64)
+f32 ** (0.5 + 0.5)
+f32 ** (0.5 - 1)
+f32 ** (0.5 / f32)
+f32 ** (1 / f64)
+f32 ** (f32 - 0.5)
+f32 ** (f64 - i64)
+f32 ** (i % 1)
+f32 ** (i64 * i32)
+f32 ** (i64 + 0.5)
+f32 ** (i64 - 1)
 f32 ** -0.5
-f32 ** -1
+f32 ** -f32
 f32 ** -f64
 f32 ** -i
-f32 ** -i32
-f32 ** -i64
-f32 ** 0.5 >= i64
+f32 ** 0.5 != f32
+f32 ** 0.5 + f32
+f32 ** 0.5 >= -i64
+f32 ** 0.5 ^ (f32 / f64)
 f32 ** 0.5 ^ i64
-f32 ** 1 * f32
-f32 ** 1 ** 0.5
-f32 ** 1 / i32
-f32 ** 1 <= i
-f32 ** array[i64]
+f32 ** 1 + i64
+f32 ** 1 / i
+f32 ** 1 < f64
+f32 ** 1 < i64
+f32 ** 1 <= i64
+f32 ** ceil(i64)
 f32 ** f32
-f32 ** f32 * i ^ f64
-f32 ** f32 + f32
-f32 ** f32 - 0.5 + 1
-f32 ** f32 ^ 1
-f32 ** f32 ^ i
+f32 ** f32 * f32
+f32 ** f32 ** f32
+f32 ** f32 < f64
+f32 ** f32 ^ f32
+f32 ** f32 ^ f64
 f32 ** f64
-f32 ** f64 + i64
+f32 ** f64 ** 1
 f32 ** f64 <= f64
-f32 ** f64 >= f32
-f32 ** float(i64)
-f32 ** half(f64)
+f32 ** f64 >= i
+f32 ** float(f32)
+f32 ** float(f64)
+f32 ** half(0.5)
+f32 ** half(1)
 f32 ** i
-f32 ** i * f64
-f32 ** i / f64
-f32 ** i == score(i)
+f32 ** i != half(1)
+f32 ** i ** f64
+f32 ** i ** i32
+f32 ** i <= i64
 f32 ** i32
-f32 ** i32 ** i32
-f32 ** i32 >= i32
+f32 ** i32 / i32
+f32 ** i32 == f64
+f32 ** i32 ^ f32
 f32 ** i64
-f32 ** i64 * i32
-f32 ** i64 + i64
-f32 ** i64 / i64
-f32 ** int(0.5)
-f32 ** int(1)
+f32 ** i64 / f32
+f32 ** i64 == i32
+f32 ** i64 > i32
+f32 ** int(f64)
 f32 ** len("foo")
-f32 ** len(list)
 f32 ** max(f32)
-f32 ** max(f64)
-f32 ** max(i64)
+f32 ** max(i32)
+f32 ** median(array)
+f32 ** reduce(array, 0.5)
+f32 ** round(f64)
 f32 + -0.5
 f32 + -1
 f32 + -f32
 f32 + -i
-f32 + -i64
-f32 + 0.5 + 1
-f32 + 0.5 + f32
+f32 + 0.5 ** f32
+f32 + 0.5 + i32
+f32 + 0.5 - i
+f32 + 0.5 - i32
+f32 + 0.5 / f32
+f32 + 0.5 == i
+f32 + 0.5 > i64
+f32 + 0.5 ^ 0.5
 f32 + 1 * 0.5
-f32 + 1 * i32
-f32 + 1 ** f64
-f32 + 1 - f32
+f32 + 1 * 1
+f32 + 1 + i
+f32 + 1 - f64
 f32 + 1 - i64
-f32 + 1 < i32
-f32 + abs(0.5)
-f32 + abs(f32)
-f32 + count(array, true)
+f32 + 1 / f64
+f32 + 1 < f32
+f32 + 1 < i
+f32 + 1 >= ceil(0.5)
+f32 + bitnot(i64)
+f32 + ceil(-1)
+f32 + ceil(1)
+f32 + ceil(f32)
 f32 + f32
-f32 + f32 + i32
-f32 + f32 == 0.5 ^ i
+f32 + f32 * 0.5
+f32 + f32 ** i64
+f32 + f32 - i32
+f32 + f32 / 1
+f32 + f32 > i32
+f32 + f32 ^ 0.5
 f32 + f64
-f32 + f64 - 0.5
-f32 + f64 - f32
-f32 + f64 / f64
-f32 + f64 < f32
-f32 + f64 ^ f32
-f32 + find(array, ok)
-f32 + float(f64)
-f32 + half(0.5)
+f32 + f64 in array
+f32 + findIndex(array, true)
+f32 + first(array)
+f32 + float(i)
+f32 + floor(1)
+f32 + floor(i64)
+f32 + half(1)
+f32 + half(f64)
 f32 + i
-f32 + i != i
-f32 + i - i
-f32 + i ^ f64
+f32 + i != i64
+f32 + i + 1
+f32 + i + i
+f32 + i - i32
+f32 + i == f64
 f32 + i32
-f32 + i32 * 0.5
-f32 + i32 + 0.5
-f32 + i32 >= f32
+f32 + i32 != f32
+f32 + i32 % i
+f32 + i32 / f32
+f32 + i32 <= i
+f32 + i32 ^ 0.5
 f32 + i64
-f32 + i64 % 1
-f32 + i64 - 1
-f32 + i64 - f32
+f32 + i64 != f32
+f32 + i64 + 0.5
+f32 + i64 < f32
+f32 + i64 <= i32
+f32 + i64 >= i
+f32 + i64 >= i32
 f32 + int(1)
 f32 + int(f64)
-f32 + int(i32)
-f32 + len(array)
 f32 + max(0.5)
 f32 + max(f64)
-f32 + max(i64)
-f32 + min(1)
-f32 + min(f32)
-f32 + min(i32)
-f32 + min(i64, 1, 1)
+f32 + reduce(array, #)
+f32 + round(1)
+f32 + round(i32)
 f32 + score(1)
 f32 + score(i)
-f32 - -0.5
 f32 - -1
 f32 - -f64
 f32 - -i
-f32 - -i32
+f32 - 0.5 ** i64
+f32 - 0.5 + 0.5
 f32 - 0.5 + f64
-f32 - 0.5 - i32
 f32 - 0.5 - i64
-f32 - 0.5 <= f64
+f32 - 0.5 < i
+f32 - 0.5 <= i32
 f32 - 0.5 <= i64
-f32 - 0.5 >= i64
-f32 - 0.5 ^ f64
-f32 - 0.5 ^ i32
-f32 - 1 != i64
-f32 - 1 % 1
+f32 - 0.5 > f64
 f32 - 1 % i64
+f32 - 1 * i64
 f32 - 1 + 1
-f32 - 1 + i32 % i
-f32 - 1 - f32
+f32 - 1 / 0.5
+f32 - 1 < i32
+f32 - 1 <= i32
+f32 - 1 == f32
+f32 - 1 >= f64
 f32 - abs(i32)
-f32 - array[i]
+f32 - abs(i64)
+f32 - bitshl(i, i32)
+f32 - ceil(f64)
 f32 - f32
-f32 - f32 - f64
-f32 - f32 - i32
+f32 - f32 ** i32
+f32 - f32 + i
 f32 - f32 == i
-f32 - f32 == min(1)
-f32 - f32 >= i
 f32 - f64
-f32 - f64 * 1
-f32 - f64 ** i32
-f32 - f64 + f32
-f32 - f64 + i64
-f32 - f64 - f32
+f32 - f64 + f64
 f32 - f64 - i
 f32 - f64 <= f32
-f32 - f64 ^ 1
-f32 - float(0.5)
-f32 - float(1)
-f32 - float(i32)
-f32 - half(0.5)
 f32 - i
-f32 - i % 1
-f32 - i * f32
-f32 - i + i32 % 1
-f32 - i + i32 ** 0.5
-f32 - i - 0.5
+f32 - i >= f32
 f32 - i32
-f32 - i32 * 1
-f32 - i32 ** f32
-f32 - i32 ** i32
-f32 - i32 + 1
-f32 - i32 >= i
-f32 - i32 ^ i
+f32 - i32 * 0.5
+f32 - i32 * f64
+f32 - i32 ** 1
+f32 - i32 <= f32
+f32 - i32 <= i32
+f32 - i32 >= abs(0.5)
 f32 - i64
-f32 - i64 - 1
-f32 - i64 <= i32
-f32 - i64 ^ 1
-f32 - int(0.5)
-f32 - int(i64)
-f32 - len("bar")
-f32 - len(list)
-f32 - max(i32)
-f32 - min(1)
-f32 - min(i64)
+f32 - i64 ** 0.5
+f32 - len(array)
+f32 - max(1)
+f32 - min(0.5)
+f32 - min(0.5, 0.5)
+f32 - reduce(array, #)
+f32 - score(1)
 f32 - score(i)
-f32 / (0.5 + i64)
-f32 / (1 - i)
-f32 / (i64 - f64)
-f32 / -0.5
-f32 / -f32
+f32 / (0.5 - i32)
+f32 / (1 + i)
+f32 / (f64 - 0.5)
+f32 / (i - i32)
+f32 / (i32 + 1)
+f32 / -1
 f32 / -f64
-f32 / -i
-f32 / -i32
-f32 / 0.5 * 0.5
-f32 / 0.5 * i
-f32 / 0.5 - f64
-f32 / 0.5 - i
-f32 / 0.5 - i64
-f32 / 0.5 > f64
-f32 / 1 != f64
-f32 / 1 * i64
-f32 / 1 ** f32
-f32 / 1 - f64 - i64
+f32 / -i64
+f32 / 0.5 ** f64
+f32 / 0.5 / i
+f32 / 0.5 <= i64
+f32 / 0.5 ^ f64
+f32 / 1 * i32
+f32 / 1 <= f32
+f32 / 1 >= 0.5 ? f64 : foo
 f32 / 1 >= f32
-f32 / 1 ^ 0.5
-f32 / 1 ^ i
-f32 / abs(1)
-f32 / abs(f32)
+f32 / 1 >= i32
+f32 / array[1]
+f32 / array[i32]
+f32 / bitnot(i)
+f32 / ceil(1)
+f32 / ceil(f32)
+f32 / count(list, false)
 f32 / f32
-f32 / f32 / f32
-f32 / f32 < f32
+f32 / f32 / 0.5
+f32 / f32 ^ 1
 f32 / f64
-f32 / f64 ^ 0.5
+f32 / f64 * i32
+f32 / f64 + f32
+f32 / f64 - i32
+f32 / f64 / 1
+f32 / f64 / f64
+f32 / f64 / i64
+f32 / f64 < i
+f32 / float(1)
+f32 / float(i32)
 f32 / float(i64)
-f32 / get(array, 1)
+f32 / floor(i)
 f32 / half(0.5)
+f32 / half(1)
+f32 / half(f64)
 f32 / i
-f32 / i <= i64
+f32 / i * 0.5
+f32 / i / 0.5
+f32 / i <= i
+f32 / i == i32
+f32 / i > f64
 f32 / i32
-f32 / i32 != i
-f32 / i32 ** i
-f32 / i32 / f64
-f32 / i32 >= i
+f32 / i32 * 1
+f32 / i32 * f32
+f32 / i32 ** f32
+f32 / i32 + i
+f32 / i32 + i64
+f32 / i32 < f64 + 0.5
+f32 / i32 >= i32
 f32 / i64
-f32 / i64 * i64
-f32 / i64 > i32
-f32 / i64 ^ 1
-f32 / i64 ^ i
-f32 / int(f32)
-f32 / int(f64)
-f32 / int(i)
-f32 / int(i32)
-f32 / last(array)
+f32 / i64 - f64
+f32 / i64 ^ 0.5
+f32 / int(0.5)
+f32 / int(1 * i64)
 f32 / max(0.5)
-f32 / max(1)
-f32 / min(f32)
+f32 / min(i32)
+f32 / reduce(array, #)
+f32 / reduce(list, 1)
+f32 / score(i)
 f32 < -0.5
-f32 < -f32
 f32 < -f64
-f32 < -i32
+f32 < -i
 f32 < -i64
-f32 < 0.5 != true
-f32 < 0.5 ? array : array
-f32 < 0.5 ? false : score
-f32 < 0.5 ? i64 : i32
-f32 < 0.5 ? ok : f32
+f32 < 0.5 + 0.5
+f32 < 0.5 + 1
 f32 < 0.5 ^ f32
-f32 < 1 != ok
-f32 < 1 * f32
-f32 < 1 ** 1
-f32 < 1 ** i
-f32 < 1 - i
-f32 < 1 / 0.5
-f32 < 1 ? f32 : i64
-f32 < 1 ? foo : i
-f32 < 1 ? i64 : foo
-f32 < 1 || not ok
-f32 < abs(1)
-f32 < abs(i)
-f32 < array[i64]
-f32 < array[i]
-f32 < div(1, 1)
+f32 < 0.5 ^ i64
+f32 < 1 % 1
+f32 < 1 + f64
+f32 < 1 ? f64 : i
+f32 < 1 and ok
+f32 < abs(0.5)
+f32 < ceil(0.5)
+f32 < ceil(f64)
+f32 < count(array, ok)
+f32 < count(list, ok)
 f32 < f32
-f32 < f32 ** 1
-f32 < f32 ^ 0.5
+f32 < f32 / 1
+f32 < f32 ^ f64
 f32 < f64
-f32 < f64 != ok
-f32 < f64 / f64
-f32 < f64 == nil
-f32 < f64 == true
-f32 < f64 ? "foo" : half
-f32 < float(f32)
-f32 < float(i64)
-f32 < half(f64)
+f32 < f64 ** 1
+f32 < f64 + 0.5
+f32 < f64 + i
+f32 < f64 / i64
+f32 < f64 ? 0.5 : array
+f32 < f64 ? div : i32
+f32 < f64 and ok
+f32 < floor(0.5)
+f32 < floor(i)
+f32 < half(0.5)
+f32 < half(1)
 f32 < i
-f32 < i * 1
-f32 < i - i32
-f32 < i ? greet : "foo"
+f32 < i != ok
+f32 < i / 1
+f32 < i ? 1 : i
 f32 < i32
-f32 < i32 ** 0.5
+f32 < i32 ** i64
+f32 < i32 ? f64 : i
+f32 < i32 ? greet : i32
 f32 < i32 or ok
-f32 < i32 || ok
 f32 < i64
-f32 < i64 != nil
-f32 < i64 && ok
-f32 < i64 * i32
-f32 < i64 - f32
-f32 < int(f64)
-f32 < max(1)
-f32 < score(1)
-f32 < score(i)
+f32 < i64 - i32
+f32 < i64 / 0.5
+f32 < i64 ? foo : i32
+f32 < i64 ? foo?.Bar : div
+f32 < i64 ^ 0.5
+f32 < max(i)
+f32 < max(i32, 1)
+f32 < min(0.5)
+f32 < reduce(array, #)
+f32 < reduce(list, 1)
+f32 < round(i64)
 f32 <= -0.5
 f32 <= -1
-f32 <= -f32
 f32 <= -f64
-f32 <= -i
 f32 <= -i64
-f32 <= -min(i64)
+f32 <= 0.5 != true
 f32 <= 0.5 * 0.5
-f32 <= 0.5 ** i32
-f32 <= 0.5 - 1
-f32 <= 0.5 / 0.5
-f32 <= 0.5 == ok
-f32 <= 0.5 == true
-f32 <= 1 != nil
-f32 <= 1 % i
-f32 <= 1 * 0.5
-f32 <= 1 * i32
-f32 <= 1 == ok
-f32 <= abs(1)
+f32 <= 0.5 + i
+f32 <= 0.5 / i64
+f32 <= 0.5 ? i64 : i
+f32 <= 1 - 0.5
+f32 <= 1 == nil
+f32 <= 1 ? f64 : add
+f32 <= 1 ? i64 : i64 % 1
+f32 <= 1 ? list : div
+f32 <= 1 || ok
 f32 <= f32
-f32 <= f32 ** i64
-f32 <= f32 ? 0.5 : foo
+f32 <= f32 * 1
+f32 <= f32 + f64
+f32 <= f32 + i
+f32 <= f32 ? greet : half
 f32 <= f64
-f32 <= f64 ? ok : f64
-f32 <= f64 ^ f32
-f32 <= f64 and ok
-f32 <= findIndex(list, ok)
-f32 <= first(array)
+f32 <= findIndex(list, ok) * f64
+f32 <= float(1)
+f32 <= float(i)
+f32 <= float(i64)
+f32 <= float(toJSON(1))
+f32 <= floor(0.5)
 f32 <= half(0.5)
+f32 <= half(1)
+f32 <= half(f64)
 f32 <= i
-f32 <= i != nil
-f32 <= i % i64
-f32 <= i ** i32
-f32 <= i - 0.5
-f32 <= i / f32
-f32 <= i == ok
+f32 <= i == nil
+f32 <= i and i32 <= f32
 f32 <= i32
-f32 <= i32 * i64
 f32 <= i32 ** i32
-f32 <= i32 + i32
-f32 <= i32 - 1
+f32 <= i32 + 1
 f32 <= i32 / 1
-f32 <= i32 ? 0.5 : i32
-f32 <= i32 and ok
 f32 <= i64
-f32 <= i64 * i
-f32 <= i64 ? true : array
-f32 <= i64 or ok
-f32 <= int(0.5)
-f32 <= int(i)
-f32 <= len("foo")
-f32 <= max(f32)
-f32 <= max(i64)
-f32 <= min(i64, i32)
+f32 <= i64 ** i64
+f32 <= i64 - f32
+f32 <= i64 ? f64 : f64
+f32 <= i64 ^ i32
+f32 <= i64 || nil in array
+f32 <= last(array)
+f32 <= min(0.5)
+f32 <= min(1)
+f32 <= min(f64)
+f32 <= round(0.5)
 f32 <= score(1)
-f32 <= score(i)
-f32 == --f64
 f32 == -0.5
 f32 == -1
 f32 == -f32
 f32 == -i32
 f32 == -i64
-f32 == 0.5 && i32 == i32
-f32 == 0.5 * i32
-f32 == 0.5 ** 1
-f32 == 0.5 and ok
-f32 == 1 && ok ? add : f32
-f32 == 1 ^ i
-f32 == abs(1)
-f32 == array[1]
-f32 == count(array, ok)
+f32 == 0.5 != ok
+f32 == 0.5 * 0.5
+f32 == 0.5 * 1
+f32 == 0.5 ** i32
+f32 == 0.5 + 1
+f32 == 0.5 / i32
+f32 == 0.5 / i64
+f32 == 0.5 ? array : greet
+f32 == 0.5 ? true : score
+f32 == 0.5 ^ 0.5
+f32 == 0.5 || f64 >= 1
+f32 == 1 != nil
+f32 == 1 + f32
+f32 == 1 - 1
+f32 == 1 - i
+f32 == 1 == ok
+f32 == 1 ? foo : f32
+f32 == 1 ? ok : add != nil
+f32 == add(i, 1)
+f32 == array[i32]
+f32 == bitnot(i)
+f32 == ceil(1)
+f32 == ceil(i32)
+f32 == ceil(i64)
 f32 == f32
-f32 == f32 ** f32
-f32 == f32 - i32
-f32 == f32 ? 1 : greet
-f32 == f32 ? list : "bar"
+f32 == f32 ? f32 : list
+f32 == f32 and ok
 f32 == f64
-f32 == f64 - 1
-f32 == f64 - f64
-f32 == f64 ? ok : i64
-f32 == find(array, ok)
-f32 == findLast(array, ok)
-f32 == findLastIndex(list, true)
-f32 == get(array, 1)
+f32 == f64 + f64
+f32 == f64 ^ 1
+f32 == findLastIndex(array, ok)
+f32 == first(array)
+f32 == float(0.5)
+f32 == float(1)
+f32 == floor(f64)
+f32 == half(1)
+f32 == half(f64)
 f32 == i
-f32 == i * i64
-f32 == i + f64 + 0.5
-f32 == i - f64
-f32 == i - i32
-f32 == i / 0.5
-f32 == i ? "foo" : i64
-f32 == i ? i : 0.5
+f32 == i != nil
+f32 == i - 0.5
+f32 == i - i64
 f32 == i32
-f32 == i32 % 1
-f32 == i32 - 0.5
+f32 == i32 + i32
+f32 == i32 ? 0.5 : array
+f32 == i32 ? i64 : i64
+f32 == i32 ? true : half
+f32 == i32 ^ i32
+f32 == i32 or ok
 f32 == i64
-f32 == i64 % i
-f32 == i64 * 0.5
-f32 == int(1)
-f32 == max(0.5, 1)
-f32 == max(i)
+f32 == i64 * i64
+f32 == i64 + 0.5
+f32 == i64 - 0.5
+f32 == i64 - 1
+f32 == i64 ? div : 0.5
+f32 == last(array)
+f32 == max(f64)
 f32 == min(0.5)
-f32 == min(i64)
-f32 == nil ? "foo" : div
-f32 == nil ? i32 : greet
+f32 == min(f32)
+f32 == nil ? array : add
+f32 == nil ? i : div
+f32 == round(1)
 f32 == score(1)
+f32 == score(i)
+f32 > -(0.5 / 1)
 f32 > -0.5
-f32 > -f64
-f32 > -i
+f32 > -f32
 f32 > -i32
-f32 > -i64
-f32 > 0.5 != false
-f32 > 0.5 != ok
-f32 > 0.5 - 0.5
-f32 > 0.5 / 0.5
-f32 > 0.5 ? foo : f64
-f32 > 0.5 ? greet : half
-f32 > 1 % 1
-f32 > 1 ** 0.5
-f32 > 1 + f32
-f32 > 1 / i64
-f32 > 1 == true
-f32 > 1 ? nil : half
-f32 > 1 ^ i32
-f32 > array[i32]
+f32 > 0.5 / f32
+f32 > 0.5 / i32
+f32 > 0.5 == true ? i32 : array
+f32 > 0.5 ? half : false
+f32 > 0.5 ^ f64
+f32 > 1 ** i
+f32 > 1 ? 1 : false
+f32 > 1 ? list : "foo"
+f32 > abs(1)
+f32 > abs(f32)
+f32 > abs(f64)
+f32 > count(array, ok)
 f32 > f32
-f32 > f32 ** f32
-f32 > f32 - i
-f32 > f32 == true
+f32 > f32 + f32
+f32 > f32 - f32
+f32 > f32 == nil
 f32 > f64
-f32 > f64 - i32
-f32 > f64 / i64
-f32 > f64 ? array : false
-f32 > f64 ? true : array
-f32 > f64 or ok
+f32 > f64 * i
+f32 > f64 ** 0.5
+f32 > float(0.5)
+f32 > float(i32)
+f32 > floor(1)
+f32 > half(1)
+f32 > half(f64)
 f32 > i
-f32 > i * 0.5
-f32 > i + f32
+f32 > i != ok
+f32 > i * 1
+f32 > i ? array : 1
+f32 > i ? foo : list
 f32 > i32
-f32 > i32 != ok
-f32 > i32 * i
+f32 > i32 != nil
+f32 > i32 * f64
+f32 > i32 ? 0.5 : greet
+f32 > i32 and ok
 f32 > i64
-f32 > i64 ? 1 : f64
-f32 > i64 ? ok : greet
-f32 > int(0.5)
-f32 > int(f64)
-f32 > max(i32)
-f32 > max(i32, 1)
-f32 > min(f64)
-f32 > score(1)
-f32 > score(i)
+f32 > i64 % i64
+f32 > i64 ** i
+f32 > i64 + 0.5
+f32 > i64 - i64
+f32 > i64 ? i : 0.5
+f32 > mean(array)
+f32 > min(f32)
+f32 > min(i64)
+f32 > reduce(array, #)
+f32 > reduce(array, i64)
+f32 > reduce(list, f32)
+f32 > round(0.5)
+f32 > score(1, 1)
+f32 >= -0.5
+f32 >= -f32
 f32 >= -f64
-f32 >= -i
-f32 >= -i32
-f32 >= -i64
-f32 >= 0.5 ** f64
-f32 >= 0.5 - 0.5
-f32 >= 0.5 == ok
-f32 >= 1 != ok
-f32 >= 1 != true
-f32 >= 1 % 1
-f32 >= 1 % i
-f32 >= 1 - 1
-f32 >= 1 - i
-f32 >= 1 - i64
-f32 >= 1 ? "foo" endsWith "foo" : f64
-f32 >= abs(1)
+f32 >= 0.5 * f64
+f32 >= 0.5 / i64
+f32 >= 0.5 ? i64 : nil
+f32 >= 0.5 ^ i64
+f32 >= 1 == false
+f32 >= 1 == ok ? add : array
+f32 >= 1 ? i : 1
+f32 >= abs(0.5)
+f32 >= abs(f32)
+f32 >= abs(i)
+f32 >= array[1]
+f32 >= array[i32]
+f32 >= bitnot(i32)
+f32 >= count(list, false)
 f32 >= f32
 f32 >= f32 ** 1
-f32 >= f32 ** f32
-f32 >= f32 + i32
+f32 >= f32 - i64
+f32 >= f32 ? half : greet
+f32 >= f32 or nil != ok
 f32 >= f64
-f32 >= f64 + i32
-f32 >= first(array)
-f32 >= float(i32)
-f32 >= float(i64)
+f32 >= f64 && ok
+f32 >= f64 ** 0.5
+f32 >= f64 ** i32
+f32 >= f64 - f64
+f32 >= f64 / i64
+f32 >= f64 or ok
+f32 >= float(0.5)
 f32 >= half(f64)
 f32 >= i
-f32 >= i != true
-f32 >= i * 0.5
-f32 >= i ** 0.5
-f32 >= i ** i32
-f32 >= i + f64
-f32 >= i ? "bar" : nil
-f32 >= i ? ok : i
+f32 >= i - f32
+f32 >= i ? 1 : nil
+f32 >= i ^ i
 f32 >= i32
-f32 >= i32 * 0.5
-f32 >= i32 ? array : foo
-f32 >= i32 ^ i32
+f32 >= i32 % i
+f32 >= i32 - f32
+f32 >= i32 / i64
+f32 >= i32 ? f32 : 0.5
+f32 >= i32 or not ok
 f32 >= i64
-f32 >= i64 % i64
-f32 >= i64 ** 0.5
-f32 >= i64 ? 1 : i32
-f32 >= i64 ? i64 : add
-f32 >= i64 || ok
-f32 >= len("foo")
+f32 >= i64 * i32
+f32 >= i64 + f64
+f32 >= i64 / 1
+f32 >= len("bar")
 f32 >= max(i)
-f32 >= min(i)
+f32 >= max(i64)
+f32 >= reduce(array, #)
 f32 >= score(1)
-f32 ^ (1 * f32)
-f32 ^ (1 + 1)
-f32 ^ (1 - 0.5)
-f32 ^ (f32 * 0.5)
-f32 ^ (f32 / 1)
-f32 ^ (i + i)
-f32 ^ (i32 % 1)
-f32 ^ (i32 % i64)
-f32 ^ (i32 / 1)
-f32 ^ (i32 / f64)
+f32 >= sum(array)
+f32 ^ (0.5 * f64)
+f32 ^ (0.5 / 1)
+f32 ^ (0.5 / i)
+f32 ^ (1 * i)
+f32 ^ (1 + f64)
+f32 ^ (f32 * i64)
+f32 ^ (f64 * f64)
+f32 ^ (f64 - 1)
+f32 ^ (f64 / i)
+f32 ^ (i64 * f64)
+f32 ^ (i64 * i32)
+f32 ^ (i64 * i64)
+f32 ^ (i64 + i64)
 f32 ^ (i64 - f32)
 f32 ^ -0.5
 f32 ^ -1
-f32 ^ -f32
-f32 ^ -i
 f32 ^ -i32
-f32 ^ -i64
-f32 ^ 0.5 != i64
-f32 ^ 0.5 + f32
-f32 ^ 0.5 + i64
-f32 ^ 0.5 - f64
-f32 ^ 0.5 <= 0.5 ^ 0.5
-f32 ^ 0.5 ^ f32
-f32 ^ 1 - i
-f32 ^ 1 - i32
-f32 ^ 1 <= 1 * 1
-f32 ^ 1 <= i32
-f32 ^ 1 ^ 0.5
+f32 ^ 0.5 ** i32
+f32 ^ 0.5 - f32
+f32 ^ 0.5 - i32
+f32 ^ 0.5 == i64
+f32 ^ 0.5 ^ 0.5
+f32 ^ 1 != i64
+f32 ^ 1 / f32
+f32 ^ 1 >= -0.5
+f32 ^ abs(1)
+f32 ^ abs(f32)
+f32 ^ array[i64]
+f32 ^ array[i]
+f32 ^ bitnot(1)
+f32 ^ bitor(1, i32)
 f32 ^ f32
-f32 ^ f32 ** i
-f32 ^ f32 + f32
-f32 ^ f32 / f32
+f32 ^ f32 ^ 0.5
+f32 ^ f32 in array
 f32 ^ f64
-f32 ^ f64 < f64
-f32 ^ f64 < i64
-f32 ^ f64 <= f64
-f32 ^ f64 == f64
-f32 ^ f64 > i
+f32 ^ f64 ** f64
+f32 ^ f64 / 1 * 1
+f32 ^ f64 / f64
+f32 ^ f64 == i64
+f32 ^ f64 not in array
+f32 ^ floor(0.5)
+f32 ^ floor(1)
+f32 ^ half(1)
 f32 ^ half(f64)
 f32 ^ i
-f32 ^ i ** i32
+f32 ^ i - f64
+f32 ^ i <= i
+f32 ^ i >= f64
+f32 ^ i ^ f32
 f32 ^ i32
-f32 ^ i32 + f32
+f32 ^ i32 ** i64
 f32 ^ i64
-f32 ^ last(array)
-f32 ^ max(0.5)
-f32 ^ max(f32)
-f32 ^ max(i64)
+f32 ^ i64 ** 1
+f32 ^ i64 + i64
+f32 ^ i64 - f32
+f32 ^ i64 >= f64
+f32 ^ i64 ^ f32
+f32 ^ int(i32)
+f32 ^ len("foo")
+f32 ^ len(array)
 f32 ^ min(1)
-f32 ^ min(1, 1)
+f32 ^ min(f64)
+f32 ^ min(i)
+f32 ^ reduce(array, 1)
+f32 ^ round(i)
+f32 ^ round(i32)
 f32 ^ score(i)
-f32 in [false, list]
+f32 ^ score(reduce(array, #))
+f32 in [i]
 f32 in [nil]
-f32 not in sort(array)
+f32 in array
+f32 in array == nil
+f32 in array ? 1 : i
+f32 in array ? false : 0.5
+f32 in array ? nil : "bar"
+f32 in groupBy(array, #)
+f32 in groupBy(list, #)
+f32 in groupBy(list, ok)
+f32 in map(array, #)
+f32 not in [f32, "bar"]
+f32 not in array
+f32 not in array ? foo : i
+f32 not in array ? i32 : div
 f64
-f64 != -(0.5 ** 0.5)
+f64 != -0.5
 f64 != -1
-f64 != -f64
+f64 != -f32
 f64 != -i
-f64 != -i32
-f64 != 0.5 && ok
-f64 != 0.5 + 1
-f64 != 0.5 + f64
-f64 != 0.5 == nil
-f64 != 0.5 == true
-f64 != 0.5 ? false : array
-f64 != 0.5 and ok
-f64 != 1 ? list : false
-f64 != 1 ^ i64
-f64 != abs(f32)
-f64 != array[i64]
+f64 != -i64
+f64 != 0.5 != false
+f64 != 0.5 ** 1
+f64 != 0.5 ** f64
+f64 != 0.5 + f32
+f64 != 0.5 ^ 0.5
+f64 != 1 - 1
+f64 != 1 / 0.5
+f64 != 1 ? half : div
+f64 != 1 ^ i
+f64 != abs(i32)
+f64 != bitnot(i64)
+f64 != ceil(i)
 f64 != f32
-f64 != f32 * i32
+f64 != f32 != nil
+f64 != f32 + 0.5
+f64 != f32 + i32
+f64 != f32 - i32
+f64 != f32 ? array : nil
+f64 != f32 ? i32 : "bar"
+f64 != f32 ? ok : i
+f64 != f32 or greet == nil
 f64 != f64
 f64 != f64 * f32
-f64 != f64 ^ 1
-f64 != findLastIndex(list, ok)
+f64 != f64 ? f64 : true
 f64 != first(array)
-f64 != get(array, i32)
+f64 != floor(1)
 f64 != half(0.5)
-f64 != half(f64)
+f64 != half(1)
 f64 != i
-f64 != i && ok
-f64 != i + 1
+f64 != i * 0.5
+f64 != i / 1
+f64 != i / f32
+f64 != i ^ f64
 f64 != i32
-f64 != i32 + f64
-f64 != i32 ? "bar" : nil
-f64 != i32 ? add : 1
-f64 != i32 ^ 0.5
+f64 != i32 * f32
+f64 != i32 == ok
+f64 != i32 ? f64 : ok
+f64 != i32 ? foo : ok
+f64 != i32 ^ i32
 f64 != i64
-f64 != i64 ** 0.5
+f64 != i64 * f64
+f64 != i64 - i32
+f64 != i64 or ok
 f64 != int(i64)
-f64 != max(i64)
-f64 != min(1)
-f64 != min(i32)
-f64 != nil == ok
-f64 != score(1)
-f64 != score(i)
-f64 * (0.5 - f32)
-f64 * (0.5 - i64)
-f64 * (f32 + i32)
-f64 * (i32 - 0.5)
-f64 * (i64 - f64)
+f64 != min(f64)
+f64 != nil != ok
+f64 != nil && f64 > 0.5
+f64 != nil == true
+f64 != nil ? array : foo
+f64 != nil ? f64 : half
+f64 != nil ? i64 : 0.5
+f64 != nil ? nil : half
+f64 != round(1)
+f64 * (0.5 - 1)
+f64 * (i64 + 0.5)
 f64 * -1
 f64 * -f32
 f64 * -f64
-f64 * -i32
-f64 * -i64
-f64 * 0.5 * 0.5 ^ i64
+f64 * 0.5 * 1
+f64 * 0.5 * i64
+f64 * 0.5 ** 0.5
+f64 * 0.5 / 0.5
+f64 * 0.5 / f32
 f64 * 0.5 / i32
+f64 * 0.5 < f32
+f64 * 0.5 <= i
+f64 * 0.5 == f64
 f64 * 0.5 ^ 1
-f64 * 1 ** 0.5
-f64 * 1 + i64
-f64 * 1 / i32
-f64 * 1 < 0.5 * 0.5
-f64 * abs(i)
+f64 * 1 * f64
+f64 * 1 * i32
+f64 * 1 ** 1
+f64 * 1 + f64
+f64 * 1 - i32
+f64 * 1 <= 1 + 1
+f64 * 1 == i64
+f64 * 1 > f32
+f64 * 1 > f64
+f64 * 1 >= f64
+f64 * bitnot(i64)
+f64 * ceil(i)
+f64 * ceil(i64)
 f64 * f32
-f64 * f32 * f32
-f64 * f32 - f32
-f64 * f32 - f64
-f64 * f32 / f64
-f64 * f32 >= f64
+f64 * f32 != i
+f64 * f32 / i64
+f64 * f32 > f64
+f64 * f32 > i
 f64 * f64
-f64 * f64 / i
-f64 * f64 < f64
-f64 * f64 >= score(1)
-f64 * float(i)
+f64 * f64 * f64
+f64 * f64 / 1
+f64 * f64 <= f64
+f64 * f64 > f64
+f64 * f64 in array
+f64 * float(f32)
+f64 * floor(0.5)
+f64 * get(array, 1)
+f64 * half(f64)
 f64 * i
-f64 * i != i
-f64 * i * 0.5
-f64 * i * i
-f64 * i * i64
-f64 * i - f64
+f64 * i / f64
 f64 * i32
-f64 * i32 * 1
-f64 * i32 > f64
+f64 * i32 != i64 * f64
+f64 * i32 - i32
 f64 * i64
-f64 * i64 + f32
-f64 * i64 + i
-f64 * i64 - f32
+f64 * i64 ** i
+f64 * i64 == i
+f64 * i64 > i32
 f64 * i64 ^ i32
-f64 * int(0.5)
-f64 * int(f32)
-f64 * int(f64)
-f64 * last(array)
-f64 * len(list)
-f64 * max(i64)
-f64 * min(i32)
-f64 * score(1)
-f64 * score(i)
-f64 ** (0.5 * i32)
-f64 ** (0.5 + 1)
-f64 ** (0.5 + i)
-f64 ** (1 + 1)
-f64 ** (1 + f64)
-f64 ** (1 - 1)
-f64 ** (1 / i64)
-f64 ** (f32 * i)
-f64 ** (f64 + 0.5)
-f64 ** (f64 + f64)
-f64 ** (f64 + i)
-f64 ** (i % 1)
-f64 ** (i % i32)
-f64 ** (i32 * 1)
-f64 ** (i32 + 0.5)
-f64 ** (i32 - f32)
-f64 ** (i64 * 1)
+f64 * median(array)
+f64 * min(1)
+f64 * min(f64)
+f64 * min(i)
+f64 * round(1)
+f64 * round(i64)
+f64 ** (0.5 - i)
+f64 ** (0.5 / i64)
+f64 ** (1 * i)
+f64 ** (f64 * i32)
+f64 ** (f64 / 1)
+f64 ** (i * 1)
+f64 ** (i * i64)
+f64 ** (i32 * i)
+f64 ** (i32 + i32)
+f64 ** (i32 - f64)
+f64 ** (i32 / i64)
+f64 ** (i64 % 1)
 f64 ** (i64 + 0.5)
-f64 ** (i64 / i)
+f64 ** (i64 + i64)
+f64 ** (i64 - i32)
+f64 ** (i64 / 0.5)
 f64 ** -0.5
 f64 ** -1
-f64 ** -f32
-f64 ** -f64
 f64 ** -i
-f64 ** -i32
-f64 ** -i64
-f64 ** 0.5 ** i64
-f64 ** 0.5 <= 1 - 1
-f64 ** 1 ** 0.5 ** 0.5
-f64 ** 1 < 1 - i64
-f64 ** 1 == f64 + f32
-f64 ** 1 ^ i
-f64 ** 1 ^ i64
-f64 ** abs(1)
-f64 ** abs(f64)
+f64 ** 0.5 ** f32
+f64 ** 0.5 == i32
+f64 ** 1 + f64
+f64 ** 1 / i
+f64 ** 1 < f32
+f64 ** 1 > i32
+f64 ** 1 ^ f32
+f64 ** abs(i)
+f64 ** bitand(1, 1)
+f64 ** ceil(0.5)
+f64 ** ceil(f64)
 f64 ** f32
-f64 ** f32 ** 0.5
-f64 ** f32 == i64
+f64 ** f32 != f64
+f64 ** f32 ** f64
+f64 ** f32 > f64
 f64 ** f64
-f64 ** f64 != f32
-f64 ** f64 ** 0.5
-f64 ** f64 / f32
-f64 ** f64 < f64
-f64 ** f64 <= f64
-f64 ** f64 ^ f64
-f64 ** f64 ^ i32
-f64 ** float(i32)
-f64 ** get(array, i64)
+f64 ** f64 - f32
+f64 ** f64 / min(1)
+f64 ** f64 <= f32
+f64 ** f64 <= i64
+f64 ** f64 ^ 0.5
 f64 ** half(0.5)
 f64 ** i
-f64 ** i != i
-f64 ** i - i32
-f64 ** i / f32
-f64 ** i >= i32
-f64 ** i ^ i32
+f64 ** i * f64
+f64 ** i ** i
+f64 ** i + -i32
+f64 ** i + f32
 f64 ** i32
-f64 ** i32 != max(f64, 0.5)
-f64 ** i32 ** 1
-f64 ** i32 ^ 1
+f64 ** i32 != f64
+f64 ** i32 > f64
 f64 ** i64
-f64 ** i64 ** i64
-f64 ** i64 / f64
-f64 ** i64 ^ i
-f64 ** int(0.5)
-f64 ** int(1)
-f64 ** max(i32)
-f64 ** min(1)
+f64 ** i64 + f32
+f64 ** i64 <= f32
+f64 ** i64 not in map(array, 0.5)
+f64 ** last(array)
+f64 ** len("bar")
+f64 ** max(i)
 f64 ** min(f32)
-f64 ** score(1, 1)
+f64 ** reduce(array, #)
+f64 ** reduce(list, i32)
+f64 ** score(i)
 f64 + -0.5
+f64 + -1
 f64 + -f64
 f64 + -i
 f64 + -i32
-f64 + -i64
-f64 + 0.5 * 1
-f64 + 0.5 * i32
 f64 + 0.5 / f32
-f64 + 0.5 == i64
-f64 + 1 != f64
-f64 + 1 + f64
-f64 + 1 - 0.5
-f64 + 1 < i64
-f64 + 1 > 0.5 ? 1 : 0.5
-f64 + 1 > i64
-f64 + 1 >= f32
-f64 + abs(i)
-f64 + abs(i64)
-f64 + array[1]
-f64 + array[i64]
-f64 + count(array, ok)
+f64 + 0.5 < i32
+f64 + 0.5 <= f64
+f64 + 0.5 <= float(f32)
+f64 + 0.5 <= i
+f64 + 0.5 > f64
+f64 + 0.5 ^ i
+f64 + 0.5 ^ i64
+f64 + 1 % i
+f64 + 1 * 0.5
+f64 + 1 * 1
+f64 + 1 * f64
+f64 + 1 ** 0.5
+f64 + 1 + i32
+f64 + 1 / i64
+f64 + 1 ^ i
+f64 + 1 not in map(array, #)
+f64 + ceil(0.5)
+f64 + count(list, true)
 f64 + f32
-f64 + f32 * i32
-f64 + f32 - i64
+f64 + f32 == i != true
 f64 + f64
-f64 + f64 + i64
-f64 + f64 == i32
-f64 + f64 > i32
-f64 + f64 ^ 0.5
-f64 + float(i64)
+f64 + f64 < f32
+f64 + f64 <= i32
+f64 + f64 ^ i32
+f64 + float(f64)
+f64 + floor(f64)
+f64 + get(array, i32)
 f64 + half(0.5)
-f64 + half(f64)
+f64 + half(1)
 f64 + i
-f64 + i ** 0.5
-f64 + i + 1
+f64 + i + 0.5
 f64 + i / 0.5
+f64 + i / i32
+f64 + i > 0.5 != true
+f64 + i > f64
+f64 + i >= f64
 f64 + i32
-f64 + i32 ** i64
-f64 + i32 + i32
-f64 + i32 / 1
-f64 + i32 <= i
-f64 + i32 >= i64
+f64 + i32 != i64
+f64 + i32 % i32
+f64 + i32 ** 1
+f64 + i32 > i64
 f64 + i64
-f64 + i64 - f64
-f64 + i64 ^ f32
-f64 + int(0.5)
-f64 + int(i32)
-f64 + len(array)
-f64 + min(0.5, 0.5)
-f64 + min(f32)
-f64 + score(i)
+f64 + i64 + i64
+f64 + i64 / f64
+f64 + i64 > i32 / i
+f64 + i64 > i64
+f64 + i64 ^ i32
+f64 + reduce(array, #)
+f64 + reduce(list, f32)
+f64 + score(1)
 f64 - -0.5
 f64 - -1
 f64 - -f64
 f64 - -i
-f64 - -i32
 f64 - -i64
-f64 - 0.5 != f64
-f64 - 0.5 * 0.5
-f64 - 0.5 ** i
-f64 - 0.5 + f32
-f64 - 0.5 + i
-f64 - 0.5 + i32
-f64 - 0.5 >= -0.5
-f64 - 1 * f32
-f64 - 1 ** f32
-f64 - 1 ** i32
-f64 - 1 + 1
+f64 - 0.5 - 0.5
+f64 - 0.5 - 1
+f64 - 0.5 - i32
+f64 - 0.5 >= f64
+f64 - 0.5 ^ i64
+f64 - 1 * i32
+f64 - 1 + i64
 f64 - 1 - f64
-f64 - 1 / 0.5
+f64 - 1 / i64
 f64 - 1 < f32
-f64 - 1 ^ 0.5
-f64 - 1 ^ 1
-f64 - abs(0.5)
-f64 - abs(i)
-f64 - array[i64]
+f64 - 1 < f32 ? i64 : false
+f64 - 1 >= len(array)
+f64 - 1 ^ i64
 f64 - f32
-f64 - f32 * f64
-f64 - f32 + 1 + 0.5
-f64 - f32 - f64
+f64 - f32 != i64
+f64 - f32 + f32
 f64 - f32 < f64
-f64 - f32 >= i32
+f64 - f32 ^ f32
 f64 - f64
-f64 - f64 - 0.5
-f64 - f64 - i32
-f64 - f64 <= i
-f64 - f64 == f64
-f64 - f64 > f32
-f64 - f64 >= get(array, i64)
-f64 - get(array, i)
-f64 - half(0.5)
+f64 - f64 + -1
+f64 - f64 < f64
+f64 - float(f32)
+f64 - floor(1)
+f64 - half(1)
 f64 - i
-f64 - i % i32
+f64 - i + 0.5
 f64 - i + 1
-f64 - i / 1
-f64 - i < i32
-f64 - i < i64
-f64 - i == i
-f64 - i == i64
-f64 - i > f64
+f64 - i + i32
+f64 - i / i
+f64 - i ^ f32
 f64 - i32
-f64 - i32 + i
-f64 - i32 - i64
-f64 - i32 >= i32
+f64 - i32 / 0.5
+f64 - i32 >= i64
+f64 - i32 ^ 0.5
 f64 - i64
-f64 - i64 * 0.5
-f64 - i64 * 1
-f64 - i64 - f32
-f64 - int(0.5)
+f64 - i64 ** i32
+f64 - int(i)
 f64 - int(i32)
-f64 - max(1)
-f64 - min(1)
-f64 - min(i32, i64)
+f64 - reduce(array, -#)
+f64 - round(1)
 f64 - score(i)
-f64 / (0.5 + f32)
-f64 / (0.5 - 0.5)
-f64 / (0.5 - f64)
-f64 / (0.5 - i32)
-f64 / (1 + i32)
-f64 / (1 - 1)
-f64 / (i32 + f64)
-f64 / (i32 - 1)
-f64 / (i64 - i64)
+f64 / (0.5 - 1)
+f64 / (0.5 - i64)
+f64 / (f32 + 1)
+f64 / (i + 0.5)
+f64 / (i32 + i64)
 f64 / -0.5
 f64 / -1
-f64 / -f32
+f64 / -f64
 f64 / -i
 f64 / -i32
-f64 / 0.5 * i
-f64 / 0.5 ** 0.5
-f64 / 0.5 ** f64
-f64 / 0.5 / f64
-f64 / 0.5 / i64
-f64 / 0.5 > f64
-f64 / 0.5 ^ i
+f64 / -i64
+f64 / 0.5 != f64
+f64 / 0.5 * f32
+f64 / 0.5 + f64
+f64 / 0.5 / 1
+f64 / 0.5 < i32
+f64 / 0.5 == i32
+f64 / 0.5 >= i64
 f64 / 1 != i
-f64 / 1 * abs(i64)
-f64 / 1 * i
-f64 / 1 ** 0.5
-f64 / 1 ^ i64
-f64 / array[i32]
-f64 / array[i]
+f64 / 1 * i32
+f64 / 1 ** 1
+f64 / 1 / i
+f64 / 1 <= i64
+f64 / 1 ^ i
+f64 / abs(f64)
+f64 / array[1]
+f64 / array[i64]
+f64 / ceil(i32)
 f64 / f32
-f64 / f32 != f64
 f64 / f32 * i
-f64 / f32 > f64
-f64 / f32 ^ i32
-f64 / f32 in [f32]
+f64 / f32 * i64
+f64 / f32 / 0.5
+f64 / f32 == f32
+f64 / f32 ^ 0.5
 f64 / f64
-f64 / f64 != f32
-f64 / f64 * f32
-f64 / f64 - f32
-f64 / f64 - f64
-f64 / get(array, i64)
+f64 / f64 / 0.5
+f64 / f64 >= f64
+f64 / f64 >= i32
+f64 / f64 >= i64
+f64 / float(1)
+f64 / float(f64)
+f64 / floor(i64)
+f64 / get(array, 1)
+f64 / get(array, i32)
 f64 / half(0.5)
+f64 / half(1)
 f64 / i
-f64 / i * i32
+f64 / i != f64
 f64 / i ** 0.5
-f64 / i ** i32
-f64 / i + i64
-f64 / i < f64
-f64 / i > 1 ** 1
-f64 / i > f64
-f64 / i >= f64
+f64 / i ** f32
+f64 / i + i32
+f64 / i == i64
+f64 / i >= i
 f64 / i32
-f64 / i32 / i32
-f64 / i32 < f64
+f64 / i32 != 0.5 - i64
+f64 / i32 == f64 ** i
+f64 / i32 == i32
+f64 / i32 >= f32
 f64 / i64
-f64 / i64 * i64 ^ i
-f64 / i64 - f32
-f64 / i64 / 0.5
-f64 / i64 / i64
-f64 / i64 <= f64
-f64 / i64 > i
+f64 / i64 < f64
 f64 / int(f32)
-f64 / int(i64)
+f64 / last(array)
 f64 / max(i)
-f64 / min(0.5)
-f64 / score(i)
+f64 / reduce(array, #)
+f64 / reduce(array, f64)
+f64 / reduce(list, f32)
+f64 / round(1)
+f64 / round(i64)
+f64 / score(1)
 f64 < -0.5
-f64 < -1
 f64 < -i32
 f64 < -i64
-f64 < 0.5 ** f32
+f64 < 0.5 + i64
+f64 < 0.5 / 0.5
+f64 < 0.5 / i
 f64 < 0.5 == true
-f64 < 0.5 ? 0.5 : foo
-f64 < 0.5 ? 1 : array
-f64 < 0.5 ? greet : false
-f64 < 0.5 ^ 1
-f64 < 0.5 or ok
-f64 < 1 == not ok
-f64 < 1 ? 1 : half
-f64 < 1 ? 1 : i
-f64 < 1 ? ok : i
-f64 < 1 and nil == i32
+f64 < 0.5 ? f64 : array
+f64 < 1 % 1
+f64 < 1 * 0.5
+f64 < 1 ** i32
+f64 < 1 / f32
+f64 < 1 == false
+f64 < 1 ? i : "foo"
 f64 < abs(1)
-f64 < abs(i32)
-f64 < array[i32]
-f64 < count(list, true)
+f64 < abs(f32)
+f64 < array[i64]
+f64 < bitnot(1)
+f64 < ceil(f64)
+f64 < count(array, false)
 f64 < f32
-f64 < f32 * 0.5
-f64 < f32 * f64
-f64 < f32 ** i32
-f64 < f32 - 1
-f64 < f32 ? array : 0.5
+f64 < f32 * i
+f64 < f32 / i64
+f64 < f32 ^ 1
+f64 < f32 ^ f64
 f64 < f64
-f64 < f64 * f32
+f64 < f64 == ok
+f64 < floor(i64)
 f64 < get(array, i)
-f64 < half(0.5)
 f64 < i
-f64 < i - f64
-f64 < i == ok
-f64 < i ? false : nil
+f64 < i && "bar" < "bar"
+f64 < i && ok
+f64 < i ** i32
+f64 < i + 1
+f64 < i ? 0.5 : "bar"
+f64 < i ? div : nil
 f64 < i32
-f64 < i32 % i32
-f64 < i32 % i64
-f64 < i32 == ok
-f64 < i32 and ok
+f64 < i32 * f64
+f64 < i32 * i
+f64 < i32 ** f32
+f64 < i32 ** i64
+f64 < i32 + f32
+f64 < i32 + f64
+f64 < i32 + i64
+f64 < i32 ? false : ok
+f64 < i32 ? true : 1
+f64 < i32 ^ 1
+f64 < i32 ^ i32
 f64 < i64
-f64 < i64 * i
+f64 < i64 * f64
+f64 < i64 ^ i
 f64 < int(0.5)
-f64 < max(1, i64)
-f64 < min(1)
-f64 < min(f64)
-f64 < min(i64)
+f64 < max(1)
+f64 < max(f64, i32)
+f64 < min(0.5, i64)
+f64 < min(f32)
+f64 < min(f64, f32)
+f64 < min(i32)
+f64 < round(0.5)
+f64 < score(1)
 f64 <= -0.5
 f64 <= -1
-f64 <= -f32
 f64 <= -i
 f64 <= -i32
-f64 <= 0.5 != ok
-f64 <= 0.5 - 1
-f64 <= 0.5 / 0.5
-f64 <= 0.5 == true
-f64 <= 0.5 ? foo : list
-f64 <= 0.5 ? nil : add
-f64 <= 1 != true
-f64 <= 1 ** 0.5
+f64 <= 0.5 != false
+f64 <= 0.5 + 0.5
+f64 <= 0.5 / f32
+f64 <= 0.5 ? greet : f64
+f64 <= 0.5 ? score : array
+f64 <= 1 * i32
 f64 <= 1 + 0.5
-f64 <= 1 == false
-f64 <= 1 ? array : foo
-f64 <= 1 ^ i64
-f64 <= abs(f32)
+f64 <= 1 / i
+f64 <= 1 == nil
+f64 <= 1 ? "bar" : array
+f64 <= 1 ? half : list
+f64 <= 1 ^ f64
+f64 <= abs(0.5)
 f64 <= abs(i)
-f64 <= array[i]
+f64 <= array[i64]
+f64 <= ceil(i)
 f64 <= f32
-f64 <= f32 + f64
-f64 <= f32 - 0.5
-f64 <= f32 ? false : "foo"
-f64 <= f32 ? false : i
-f64 <= f32 ? i64 : false
+f64 <= f32 ** 0.5
+f64 <= f32 - i64
+f64 <= f32 ? f64 : div
+f64 <= f32 ^ f32
 f64 <= f64
+f64 <= f64 != ok
 f64 <= f64 + f64
-f64 <= f64 - 0.5
-f64 <= f64 - f64
-f64 <= f64 ^ 0.5
-f64 <= find(array, true)
-f64 <= float(f64)
+f64 <= f64 + i32
+f64 <= f64 - 1
+f64 <= f64 ^ i
+f64 <= float(i)
+f64 <= float(i64)
 f64 <= half(0.5)
+f64 <= half(1)
 f64 <= i
-f64 <= i * i32
-f64 <= i ? false : false
-f64 <= i ? foo : false
+f64 <= i * i64
+f64 <= i - 1
+f64 <= i - f32
+f64 <= i ^ f64
 f64 <= i32
-f64 <= i32 == true
-f64 <= i32 ? "bar" : nil
-f64 <= i32 ? add : ok
-f64 <= i32 ? i32 : false
+f64 <= i32 ** 1
+f64 <= i32 ? div : foo
+f64 <= i32 or all(list, ok)
 f64 <= i64
-f64 <= i64 % 1
-f64 <= i64 - f32
-f64 <= i64 - i64
-f64 <= i64 ^ 1
-f64 <= i64 and ok
-f64 <= int(1)
-f64 <= int(f64)
-f64 <= int(i)
-f64 <= max(f32)
-f64 <= min(0.5)
-f64 <= score(1)
+f64 <= i64 + 1
+f64 <= i64 - 0.5
+f64 <= int(f32)
+f64 <= max(i)
+f64 <= max(i64, i32)
+f64 <= min(i32)
+f64 <= min(i64)
+f64 <= reduce(array, #)
 f64 == -0.5
 f64 == -1
 f64 == -f32
 f64 == -f64
 f64 == -i
-f64 == -i32
-f64 == 0.5 != ok
+f64 == -i64
 f64 == 0.5 ** 0.5
-f64 == 0.5 ** i32
-f64 == 0.5 / i
-f64 == 0.5 / i32
-f64 == 0.5 ? i64 : div
-f64 == 1 * f64
-f64 == 1 == nil
-f64 == 1 ? false : "foo"
-f64 == abs(1)
-f64 == abs(i32)
-f64 == array[i32]
-f64 == array[i64]
+f64 == 0.5 - i
+f64 == 0.5 ? 0.5 : i64
+f64 == 0.5 ? 1 : 1
+f64 == 1 != ok
+f64 == 1 % 1
+f64 == 1 * i64
+f64 == 1 ** 0.5
+f64 == 1 == false
+f64 == abs(0.5)
+f64 == abs(i64)
+f64 == ceil(i)
 f64 == f32
-f64 == f32 + i64
-f64 == f32 - 1
-f64 == f32 / 0.5
+f64 == f32 && ok
+f64 == f32 + len(array)
+f64 == f32 ? 0.5 : i
+f64 == f32 ^ i32
 f64 == f64
-f64 == f64 ** i32
-f64 == f64 - 1
-f64 == f64 / 1
+f64 == f64 ** i
+f64 == f64 - f64
 f64 == float(0.5)
-f64 == float(i)
-f64 == get(array, i64)
+f64 == floor(0.5)
+f64 == half(0.5)
 f64 == half(f64)
 f64 == i
-f64 == i ** f32
-f64 == i + 0.5
-f64 == i / i32
-f64 == i ? false : f32
-f64 == i ^ f32
+f64 == i != false
+f64 == i * 1
+f64 == i ? i32 : score
 f64 == i32
-f64 == i32 * 1
-f64 == i32 + f64
-f64 == i32 / 1
-f64 == i32 ? greet : array
+f64 == i32 == ok ? 1 : list
+f64 == i32 == true
+f64 == i32 || ok
 f64 == i64
-f64 == i64 - f32
-f64 == i64 == true
-f64 == int(0.5)
+f64 == i64 / i
+f64 == i64 ? 1 : 0.5
+f64 == i64 ? greet : i32
 f64 == int(f32)
-f64 == min(0.5)
-f64 == min(i64)
-f64 == nil == ok
-f64 == nil ? i32 : div
-f64 == nil ? nil : 0.5
-f64 == score(1)
+f64 == max(0.5)
+f64 == max(i)
+f64 == min(i32)
+f64 == nil && ok
+f64 == nil ? 0.5 : add
+f64 == nil ? foo : "foo"
+f64 == reduce(list, i32)
+f64 == round(i)
+f64 == score(i, 1)
 f64 > -0.5
 f64 > -1
-f64 > -f32
 f64 > -f64
 f64 > -i
 f64 > -i32
-f64 > 0.5 - f64
-f64 > 0.5 / 0.5
-f64 > 0.5 ? 0.5 : nil
-f64 > 0.5 ? score(1, 1) : nil == nil
-f64 > 0.5 ^ 1
-f64 > 0.5 || ok
-f64 > 1 != ok
-f64 > 1 != true
-f64 > 1 % i
-f64 > 1 * 0.5
-f64 > 1 - 0.5
-f64 > 1 - i32
-f64 > 1 / 0.5
-f64 > 1 / f64
-f64 > 1 ? 0.5 : ok
-f64 > 1 ? false : true
-f64 > 1 ^ 1
-f64 > abs(0.5)
-f64 > abs(1)
-f64 > abs(i)
-f64 > abs(i32)
-f64 > count(array, true)
+f64 > 0.5 ** f32
+f64 > 0.5 / i
+f64 > 0.5 ^ i
+f64 > 0.5 or i <= 0.5
+f64 > 1 + f32
+f64 > 1 + i32
+f64 > 1 ? div : i32
+f64 > 1 ^ i32
+f64 > array[i64]
+f64 > ceil(0.5)
+f64 > ceil(1)
+f64 > ceil(f32)
 f64 > f32
-f64 > f32 - 0.5
+f64 > f32 / 1
 f64 > f64
-f64 > f64 ** 0.5
-f64 > f64 ? f64 : list
-f64 > f64 ^ 0.5
-f64 > findIndex(array, ok)
-f64 > float(1)
-f64 > float(f32)
+f64 > f64 - 0.5
+f64 > float(0.5 * i64)
+f64 > floor(f64)
+f64 > get(array, 1)
 f64 > half(0.5)
+f64 > half(1)
+f64 > half(f64)
 f64 > i
-f64 > i != ok
-f64 > i ** i32
-f64 > i - i32
+f64 > i - 0.5
 f64 > i32
-f64 > i32 ** f32
-f64 > i32 - f32
 f64 > i32 == ok
-f64 > i32 ? i : 0.5
+f64 > i32 ? f32 : array
+f64 > i32 ? list : half
+f64 > i32 ^ i32
+f64 > i32 ^ i64
 f64 > i64
-f64 > i64 ** i64
-f64 > int(0.5)
-f64 > int(i64)
+f64 > i64 - 1
+f64 > i64 ? array : half
+f64 > i64 ? list : div
+f64 > i64 || ok or ok
+f64 > int(f32)
+f64 > last(array)
 f64 > max(0.5)
-f64 > max(i64)
-f64 > min(1)
-f64 > min(f64)
-f64 > min(i)
-f64 > min(i32)
-f64 > score(i)
+f64 > max(0.5, i64)
+f64 > max(f32)
+f64 > median(array)
+f64 > min(f32)
 f64 >= -0.5
 f64 >= -1
-f64 >= -f64
-f64 >= -i32
 f64 >= -i64
-f64 >= 0.5 * 1
-f64 >= 0.5 ** 0.5
-f64 >= 0.5 ** i32
-f64 >= 0.5 + 0.5
-f64 >= 0.5 + i
-f64 >= 0.5 - i
-f64 >= 0.5 - i32
-f64 >= 0.5 ? nil : 0.5
-f64 >= 0.5 ^ 0.5
-f64 >= 1 * i
-f64 >= 1 - 0.5
-f64 >= 1 / i64
-f64 >= 1 == ok
-f64 >= 1 ^ 1
-f64 >= 1 || ok
-f64 >= abs(1)
-f64 >= abs(f32)
-f64 >= abs(f64)
-f64 >= count(list, true)
+f64 >= 0.5 + i32
+f64 >= 0.5 - 1
+f64 >= 0.5 - f32
+f64 >= 0.5 / i64
+f64 >= 0.5 ? list : i32
+f64 >= 0.5 ^ i64
+f64 >= array[1]
 f64 >= f32
-f64 >= f32 != true
-f64 >= f32 - f32
-f64 >= f32 ? true : nil
+f64 >= f32 - i32
+f64 >= f32 ^ 1
 f64 >= f64
-f64 >= f64 * 0.5
-f64 >= f64 ? nil : f64
-f64 >= f64 ? score : f32
-f64 >= half(f64)
+f64 >= f64 != nil
+f64 >= f64 != ok
+f64 >= findIndex(array, ok)
+f64 >= floor(f32)
+f64 >= floor(i)
+f64 >= half(0.5)
+f64 >= half(1)
 f64 >= i
-f64 >= i - 1
+f64 >= i * 0.5
+f64 >= i ** 0.5
+f64 >= i ** i32
+f64 >= i / i32
+f64 >= i ^ 1
 f64 >= i32
-f64 >= i32 != nil
-f64 >= i32 ** 0.5
-f64 >= i32 + f32
-f64 >= i32 + i64
-f64 >= i32 ^ f32
+f64 >= i32 - f64
+f64 >= i32 ? ok : add
+f64 >= i32 ^ 1
 f64 >= i64
-f64 >= i64 * 0.5
-f64 >= i64 * f64
-f64 >= i64 * i64
-f64 >= i64 ? list : i >= f32
-f64 >= i64 ? ok : true
-f64 >= i64 || ok
-f64 >= max(f64)
-f64 >= min(0.5)
-f64 >= score(1)
+f64 >= i64 + f64
+f64 >= i64 ? 0.5 : score
+f64 >= i64 ? 1 : f32
+f64 >= max(1)
+f64 >= median(array)
+f64 >= reduce(array, #)
+f64 >= reduce(array, i32)
 f64 >= score(i)
-f64 ^ (0.5 * 1)
-f64 ^ (0.5 * f32)
-f64 ^ (0.5 / i)
-f64 ^ (1 + i)
-f64 ^ (1 - f32)
-f64 ^ (1 / 0.5)
-f64 ^ (1 / i64)
-f64 ^ -1
-f64 ^ 0.5 != f32
-f64 ^ 0.5 * i64
-f64 ^ 0.5 + f64
-f64 ^ 0.5 < 0.5 ^ 0.5
-f64 ^ 0.5 <= i64
-f64 ^ 0.5 > i == nil
-f64 ^ 0.5 >= i32 / i64
-f64 ^ 1 != i
+f64 ^ (0.5 * i)
+f64 ^ (0.5 + 1)
+f64 ^ (1 * f64)
+f64 ^ (1 - 1)
+f64 ^ (f32 + 1)
+f64 ^ (f32 - 0.5)
+f64 ^ (f32 - i)
+f64 ^ (f32 / -f64)
+f64 ^ (i32 - 1)
+f64 ^ (i32 / f32)
+f64 ^ (i64 - 1)
+f64 ^ -0.5
+f64 ^ -i32
+f64 ^ 0.5 * f64
+f64 ^ 0.5 ** f32
+f64 ^ 0.5 ** i32
+f64 ^ 0.5 > ceil(f32)
+f64 ^ 0.5 > i
+f64 ^ 0.5 >= f64
+f64 ^ 0.5 >= i32
+f64 ^ 0.5 ^ i32
+f64 ^ 0.5 not in array
 f64 ^ 1 ** i
-f64 ^ 1 + i
-f64 ^ 1 / f32
-f64 ^ 1 / i64
-f64 ^ 1 <= i32
+f64 ^ 1 ** i64
 f64 ^ 1 ^ i
-f64 ^ abs(i32)
-f64 ^ count(array, true)
+f64 ^ abs(0.5)
+f64 ^ array[i64]
 f64 ^ f32
-f64 ^ f32 != i32
-f64 ^ f32 * f32
-f64 ^ f32 ** i
-f64 ^ f32 + f64
-f64 ^ f32 / i64
-f64 ^ f32 < i
-f64 ^ f32 >= i64
-f64 ^ f32 ^ i64
+f64 ^ f32 ** 1
+f64 ^ f32 < score(1)
+f64 ^ f32 >= i32
 f64 ^ f64
-f64 ^ f64 != f32
-f64 ^ f64 * i
-f64 ^ f64 + int(0.5)
-f64 ^ float(i64)
-f64 ^ half(0.5)
+f64 ^ f64 - -i
+f64 ^ f64 == i32
+f64 ^ f64 > f64
+f64 ^ f64 ^ i
+f64 ^ f64 ^ i64
+f64 ^ findIndex(array, true)
+f64 ^ float(abs(i))
+f64 ^ floor(f64)
+f64 ^ half(1)
 f64 ^ half(f64)
 f64 ^ i
-f64 ^ i ** i32
-f64 ^ i / i
-f64 ^ i <= f32
+f64 ^ i ** 1
+f64 ^ i + f32
+f64 ^ i + i32
+f64 ^ i <= i32
+f64 ^ i ^ i64
 f64 ^ i32
-f64 ^ i32 ** i
-f64 ^ i32 + f64
+f64 ^ i32 / f64
+f64 ^ i32 <= i32
 f64 ^ i32 >= i
-f64 ^ i32 ^ f64
 f64 ^ i64
-f64 ^ i64 + i64
-f64 ^ i64 - i
-f64 ^ i64 < i
-f64 ^ i64 >= i32
+f64 ^ i64 ** i64
+f64 ^ int(0.5)
 f64 ^ int(f64)
 f64 ^ last(array)
 f64 ^ len(list)
-f64 ^ max(0.5)
+f64 ^ min(1)
+f64 ^ reduce(array, #)
+f64 ^ round(i)
 f64 ^ score(1)
-false != true || 1 > f64
-false && ok or ok
-false ? "bar" : 0.5 == f32
-false ? "bar" : 1 != i
-false ? "bar" : foo.Qux
-false ? 0.5 : foo.Qux
-false ? 1 : half != div
-false ? 1 : true != ok
-false ? add : foo?.Bar
-false ? f32 : foo.Bar
-false ? f32 : foo?.String()
-false ? f32 : i .. i32
-false ? f64 : 0.5 >= f64
-false ? f64 : f32 / f32
-false ? false : 0.5 + i32
-false ? false : i64 >= i
-false ? foo : foo.Qux
-false ? greet : i64 != i
-false ? half : 0.5 > 1 + i64
-false ? half : f32 > min(0.5)
-false ? i : 1 != i
-false ? i32 : 1 >= f64
-false ? i64 : "foo" < toJSON(f64)
-false ? i64 : foo?.Qux
-false ? list : 1 < f32
-false ? list : f32 ** i32
-false ? list : foo.Bar
-false ? nil : 1 >= get(array, 1)
+f64 in array
+f64 in array != nil
+f64 in groupBy(list, i64)
+f64 not in array
+f64 not in array != ok
+f64 not in array != true
+f64 not in array == true
+f64 not in groupBy(array, #)
+f64 not in groupBy(array, bitnand(#, 1))
+f64 not in i .. i32
+f64 not in map(array, #)
+false != false ? foo : greet
+false && i not in array
+false && nil not in array
+false && nil not in list
+false == nil ? i32 : f64
+false == nil ? i32 : i32
+false ? "bar" : 0.5 - i
+false ? "foo" : f32 * i
+false ? "foo" : f32 / i32
+false ? "foo" : foo.Qux
+false ? add : 1 / i ^ 0.5
+false ? add : i64 - i
+false ? div : i64 ** i
+false ? f32 : foo.Qux
+false ? f32 : half != score
+false ? f64 : 0.5 != i32
+false ? f64 : 0.5 ** i32
+false ? f64 : 1 >= i
+false ? f64 : foo?.Qux
+false ? f64 : i ^ f32
+false ? false : foo?.Qux
+false ? foo : i32 - i
+false ? half : 0.5 == f32
+false ? half : i ^ i64
+false ? i : foo?.Qux
+false ? i : nil in list
+false ? i32 : 1 <= i32
+false ? i32 : foo.Qux
+false ? i64 : 1 <= f32
+false ? i64 : foo.Qux
+false ? i64 : i64 ** i64
+false ? list : list == list
 false ? nil : foo?.Qux
-false ? ok : foo.String
-false ? score : 0.5 == i
-false ? score : 1 / i64
-false ? score : f64 - -f32
-false ? true : 0.5 == f32
-false or ok ? string(1) : f64 == f32
-filter(1 .. 1, # == 0.5)
-filter(1 .. i64, ok)
-filter([div], any(array, true))
-filter([i32, i], # <= f64)
-filter(array, !false)
-filter(array, !ok)
-filter(array, "bar" == "bar")
-filter(array, "bar" matches "bar")
-filter(array, "foo" not matches "bar")
+false ? nil : i32 > i32
+false ? ok : foo.String()
+false ? ok : i64 < i64
+false and false || 0.5 > f32
+false or 1 not in array
+false or true or ok
+false or true || ok
+filter(1 .. 1, # > i)
+filter(1 .. i, i >= #)
+filter([0.5], # > 0.5)
+filter([nil], # != false)
+filter(array, !true)
+filter(array, "bar" != "foo")
+filter(array, "foo" == nil)
 filter(array, # != #)
+filter(array, # != f32)
 filter(array, # != f64)
 filter(array, # != i)
-filter(array, # != i32)
 filter(array, # != i64)
 filter(array, # < #)
-filter(array, # < 1)
-filter(array, # < f32)
 filter(array, # < f64)
-filter(array, # < i)
-filter(array, # < i32)
 filter(array, # <= #)
-filter(array, # <= 0.5)
 filter(array, # <= 1)
-filter(array, # <= f64)
+filter(array, # <= bitshr(#, #))
 filter(array, # <= i)
-filter(array, # <= i32)
+filter(array, # <= i64)
 filter(array, # == #)
-filter(array, # == 1)
+filter(array, # == 0.5)
 filter(array, # == f32)
 filter(array, # == f64)
 filter(array, # == i)
+filter(array, # == i32)
+filter(array, # == i64)
 filter(array, # == nil)
 filter(array, # > #)
+filter(array, # > 0.5)
 filter(array, # > 1)
 filter(array, # > i)
+filter(array, # > i32)
 filter(array, # >= #)
+filter(array, # >= 0.5)
 filter(array, # >= 1)
 filter(array, # >= f32)
-filter(array, # >= f64)
+filter(array, # >= i)
 filter(array, # >= i32)
-filter(array, # in array)
-filter(array, # not in array)
+filter(array, # >= i64)
 filter(array, 0.5 != #)
+filter(array, 0.5 != f64)
+filter(array, 0.5 != i)
 filter(array, 0.5 < #)
-filter(array, 0.5 < f32)
 filter(array, 0.5 < f64)
+filter(array, 0.5 < i32)
+filter(array, 0.5 <= #)
+filter(array, 0.5 <= i)
+filter(array, 0.5 <= i32)
 filter(array, 0.5 == #)
-filter(array, 0.5 > 0.5)
+filter(array, 0.5 == f64)
+filter(array, 0.5 > #)
 filter(array, 0.5 >= #)
 filter(array, 1 != #)
-filter(array, 1 != f32)
-filter(array, 1 < #)
-filter(array, 1 < f64)
-filter(array, 1 <= #)
+filter(array, 1 < i)
 filter(array, 1 == #)
-filter(array, 1 > #)
-filter(array, 1 > 0.5)
-filter(array, add == div)
-filter(array, all(list, ok))
+filter(array, 1 == 0.5)
+filter(array, 1 == i)
+filter(array, 1 > i)
+filter(array, 1 >= #)
+filter(array, add == add)
+filter(array, add == nil)
+filter(array, any(list, ok))
+filter(array, div != score)
 filter(array, f32 != #)
-filter(array, f32 < i32)
-filter(array, f32 <= f32)
+filter(array, f32 < #)
+filter(array, f32 <= #)
 filter(array, f32 == #)
-filter(array, f32 > 1)
+filter(array, f32 == i64)
+filter(array, f32 > #)
 filter(array, f32 >= #)
-filter(array, f64 != #)
-filter(array, f64 != 0.5)
+filter(array, f64 < #)
 filter(array, f64 <= #)
-filter(array, f64 == #)
-filter(array, f64 > #)
-filter(array, f64 >= 1)
-filter(array, foo == nil)
-filter(array, greet == add)
-filter(array, greet == half)
-filter(array, i <= 1)
-filter(array, i <= f64)
-filter(array, i == f32)
-filter(array, i >= 1)
-filter(array, i >= f64 != false)
-filter(array, i32 != #)
-filter(array, i32 <= #)
-filter(array, i32 == #)
-filter(array, i32 == 1)
-filter(array, i32 > # % #)
+filter(array, f64 == i32)
+filter(array, f64 >= #)
+filter(array, half != nil)
+filter(array, half == half)
+filter(array, half(1) >= # ^ i)
+filter(array, i != #)
+filter(array, i != f64)
+filter(array, i <= i32)
+filter(array, i == #)
+filter(array, i > #)
+filter(array, i > f32)
+filter(array, i32 != i64)
+filter(array, i32 < 0.5)
 filter(array, i32 > #)
-filter(array, i32 > 0.5)
-filter(array, i32 >= #)
-filter(array, i64 != #)
 filter(array, i64 < #)
-filter(array, i64 < 1)
 filter(array, i64 < i64)
-filter(array, i64 <= #)
-filter(array, i64 == 1)
+filter(array, i64 == #)
+filter(array, i64 == i32)
+filter(array, i64 >= #)
 filter(array, nil != #)
 filter(array, nil != greet)
 filter(array, nil == #)
-filter(array, nil == f32)
-filter(array, nil in list)
-filter(array, none(array, ok))
+filter(array, nil == 1)
+filter(array, nil == i32)
+filter(array, not false)
+filter(array, not ok)
+filter(array, not true)
+filter(array, ok && true)
 filter(array, ok)
-filter(array, score(#) != #)
-filter(array, true && ok)
-filter(array, true or false)
-filter(array, true)[i:i32]
-filter(filter(array, true), i >= f32)
-filter(filter(list, false), "bar" in #)
-filter(filter(list, ok), ok)
-filter(i .. 1, not ok)
-filter(i32 .. i32, nil == true)
-filter(i32 .. i64, ok)
-filter(list, !false)
+filter(array, ok)[i64]
+filter(array, score == nil)
+filter(array, true == true)
+filter(array, true and true)
+filter(false ? ok : array, # == nil)
+filter(filter(list, true), ok)
+filter(groupBy(array, #).greet, # matches #?.score)
+filter(groupBy(array, #)?.div, .Qux(#).array)
+filter(groupBy(array, f64)?.f32, #)
+filter(groupBy(list, #).f64, # not matches #?.foo)
+filter(groupBy(list, #)?.f64, .foo)
+filter(groupBy(list, 0.5)?.i, #)
+filter(i .. i64, ok)
 filter(list, !ok)
 filter(list, !true)
-filter(list, "bar" not in #)
+filter(list, "bar" < "foo")
 filter(list, "bar" not matches "foo")
-filter(list, "bar" startsWith "bar")
+filter(list, "foo" == "foo")
 filter(list, "foo" in #)
-filter(list, "foo" not in #)
+filter(list, "foo" not endsWith "bar")
+filter(list, "foo" startsWith "bar")
 filter(list, # != #)
 filter(list, # != foo)
 filter(list, # != nil)
 filter(list, # == #)
 filter(list, # == foo)
-filter(list, # == nil)
-filter(list, 0.5 != f64)
-filter(list, 0.5 != i)
-filter(list, 0.5 > f32)
-filter(list, 1 != 0.5)
-filter(list, 1 != i32)
-filter(list, 1 != nil)
-filter(list, 1 < 0.5)
+filter(list, # in list)
+filter(list, 0.5 < 1)
+filter(list, 0.5 <= 0.5)
+filter(list, 0.5 >= 1)
+filter(list, 0.5 >= i)
+filter(list, 0.5 >= i64)
 filter(list, 1 < 1)
-filter(list, all(array, false))
-filter(list, all(array, true))
-filter(list, div == half)
-filter(list, f32 < 0.5)
-filter(list, f32 <= f32)
-filter(list, f32 == i64)
-filter(list, f32 >= 1)
-filter(list, f64 >= 0.5)
-filter(list, false == ok)
-filter(list, foo != #)
+filter(list, 1 <= f32)
+filter(list, any(array, ok))
+filter(list, any(list, true))
+filter(list, div != div)
+filter(list, f32 <= 1)
+filter(list, f32 == f64)
+filter(list, f32 > i)
+filter(list, f64 <= 1)
+filter(list, f64 == 0.5)
+filter(list, false != false)
+filter(list, false or ok)
 filter(list, foo == #)
-filter(list, foo == foo)
-filter(list, foo in list)
-filter(list, greet != nil)
-filter(list, half != half)
-filter(list, i <= 0.5)
-filter(list, i <= i)
-filter(list, i == f32)
-filter(list, i == i32)
-filter(list, i == i64)
-filter(list, i >= i32)
-filter(list, i32 != 1)
-filter(list, i32 != nil)
-filter(list, i32 < i64)
-filter(list, i32 <= i32)
-filter(list, i32 == i)
-filter(list, i64 > f32)
-filter(list, nil != f64)
-filter(list, nil != score)
-filter(list, nil != true)
+filter(list, i < 0.5)
+filter(list, i < f32)
+filter(list, i >= 0.5)
+filter(list, i64 > 0.5)
+filter(list, nil != "foo")
+filter(list, nil != #)
+filter(list, nil != #?.Bar)
+filter(list, nil != add)
+filter(list, nil != greet)
+filter(list, nil != i64)
 filter(list, nil == #)
-filter(list, not ok)
-filter(list, ok or true)
-filter(list, ok || true)
+filter(list, nil == 0.5)
+filter(list, nil == f32)
+filter(list, nil == half)
+filter(list, nil == i32)
+filter(list, nil == score)
+filter(list, ok == nil)
+filter(list, ok and false)
 filter(list, ok)
-filter(list, true == nil)
-filter(map(array, "bar"), # >= #)
-filter(map(array, "foo"), ok)
-filter(map(array, #), # != 0.5)
-filter(map(array, #), ok)
-filter(map(array, 0.5 >= #), ok)
-filter(map(list, "bar"), i >= i)
-filter(map(list, "foo"), "bar" not matches #)
-filter(map(list, #), # != #)
+filter(list, ok)[i]
+filter(list, score == half)
+filter(list, true == ok)
+filter(list, true || true)
+filter(list, true) == list
+filter(map(array, #), # == 1)
+filter(map(array, #), # > #)
+filter(map(array, 1), ok)
+filter(map(array, greet), ok)
+filter(map(array, i32), ok)
+filter(map(array, i64), nil == div)
+filter(map(array, ok), true || ok)
+filter(map(array, score), # != nil)
+filter(map(list, #), # == #)
+filter(map(list, #), half != nil)
 filter(map(list, #), ok)
-filter(map(list, 1), f32 != #)
+filter(map(list, array), # == #)
+filter(map(list, f32), # == #)
+filter(map(list, f32), ok)
 filter(map(list, false), #)
-filter(sort(array), ok)
-filter(split("foo", "bar"), ok)
-find(1 .. 1, # <= #)
-find([nil], 0.5 == 0.5)
+filter(map(list, i32), i64 <= i32)
+filter(map(list, ok), #)
+filter(map(list, true), #)
+filter(ok ? "foo" : 0.5, # <= i64)
+filter(true ? list : score, # != #)
+find(1 .. i, ok)
 find([ok], #)
+find([score, score], # == #)
+find(array, !(# <= i32))
 find(array, !ok)
 find(array, !true)
-find(array, "bar" startsWith "foo")
+find(array, "bar" not startsWith "foo")
+find(array, "foo" not contains "bar")
 find(array, # != #)
-find(array, # != 0.5)
-find(array, # != f32)
+find(array, # != 1)
+find(array, # != i)
 find(array, # != i32)
-find(array, # - # != #)
+find(array, # != nil)
+find(array, # - i != #)
 find(array, # < #)
 find(array, # < 0.5)
 find(array, # < 1)
 find(array, # < f32)
-find(array, # < f64)
+find(array, # < i)
 find(array, # < i32)
+find(array, # < i64)
 find(array, # <= #)
 find(array, # <= 0.5)
 find(array, # <= 1)
-find(array, # <= f32)
-find(array, # <= i)
+find(array, # <= i32)
 find(array, # == #)
 find(array, # == 0.5)
 find(array, # == 1)
-find(array, # == f32)
-find(array, # == f64)
 find(array, # == i)
-find(array, # == i32)
+find(array, # == i64)
 find(array, # == nil)
 find(array, # > #)
-find(array, # > 0.5)
-find(array, # > i)
+find(array, # > 1)
+find(array, # > i32)
 find(array, # > i64)
 find(array, # >= #)
 find(array, # >= 1)
+find(array, # >= f64)
 find(array, # >= i)
-find(array, # >= i32)
-find(array, 0.5 < i64)
+find(array, # not in array)
+find(array, 0.5 != 1)
+find(array, 0.5 / i64 <= #)
+find(array, 0.5 < #)
+find(array, 0.5 < f64)
 find(array, 0.5 <= #)
-find(array, 0.5 == #)
-find(array, 0.5 > #)
-find(array, 0.5 > 1)
+find(array, 0.5 >= #)
+find(array, 0.5 >= 0.5)
+find(array, 0.5 >= f64)
+find(array, 1 != #)
+find(array, 1 < #)
+find(array, 1 < i32)
+find(array, 1 < i64)
 find(array, 1 <= #)
-find(array, 1 <= 0.5)
-find(array, 1 == f32)
-find(array, 1 == i64)
+find(array, 1 <= i)
+find(array, 1 == #)
 find(array, 1 > #)
-find(array, 1 > 0.5)
-find(array, 1 > i32)
-find(array, 1 > i64)
 find(array, 1 >= #)
-find(array, 1 >= i)
-find(array, add != div)
-find(array, add != nil)
-find(array, any(array, true))
-find(array, array == list)
+find(array, div != nil)
 find(array, div == half)
+find(array, f32 != #)
+find(array, f32 != f32)
+find(array, f32 < #)
 find(array, f32 <= #)
+find(array, f32 == #)
+find(array, f32 == i32)
 find(array, f32 > #)
-find(array, f32 > 0.5)
 find(array, f32 >= #)
-find(array, f32 >= 1)
 find(array, f64 != #)
-find(array, f64 != i32)
-find(array, f64 != nil)
 find(array, f64 < #)
-find(array, f64 == nil)
-find(array, f64 >= 0.5)
-find(array, false == false)
-find(array, false) != i32
-find(array, i < #)
+find(array, f64 < 1)
+find(array, f64 <= #)
+find(array, f64 == #)
+find(array, f64 == i64)
+find(array, false ? # : false)
+find(array, false) != f64
+find(array, floor(#) > #)
+find(array, greet != greet)
+find(array, half == score)
+find(array, i % # != f64)
+find(array, i < 0.5)
 find(array, i <= #)
-find(array, i == #)
-find(array, i > #)
+find(array, i > 0.5)
 find(array, i >= #)
-find(array, i >= i64)
+find(array, i >= 1)
 find(array, i32 != #)
-find(array, i32 != 1)
-find(array, i32 < #)
-find(array, i32 <= #)
-find(array, i32 <= f32)
-find(array, i32 <= f64)
+find(array, i32 != i32)
 find(array, i32 == #)
-find(array, i32 == 1)
-find(array, i32 == f64)
 find(array, i32 > #)
+find(array, i32 >= #)
 find(array, i64 != #)
+find(array, i64 != 1)
 find(array, i64 < #)
-find(array, nil != "bar")
-find(array, nil != #)
+find(array, i64 <= #)
+find(array, i64 == #)
+find(array, i64 > #)
+find(array, nil != nil)
 find(array, nil == #)
-find(array, nil not in array)
-find(array, not false)
-find(array, not true)
-find(array, ok && ok)
+find(array, nil == 0.5)
+find(array, nil == i32)
+find(array, none(array, true))
+find(array, not (# == #))
 find(array, ok == nil)
+find(array, ok and false)
 find(array, ok)
-find(array, ok) * f64
-find(array, ok) ** i64
-find(array, ok) ^ i32
-find(array, score(#) >= #)
-find(array, true) / get(array, i64)
-find(array, true) > i
-find(array, true) ^ i32
-find(filter(array, ok), # >= #)
-find(filter(array, true), # != #)
-find(i32 .. 1, # > 0.5)
-find(i64 .. 1, ok)
-find(list, !true)
-find(list, "bar" startsWith "foo")
-find(list, "foo" < "foo")
-find(list, "foo" in #)
-find(list, "foo" not in #)
+find(array, ok) % i32
+find(array, ok) ** i
+find(array, ok) >= i32
+find(array, true) > f64
+find(array, true) > i64
+find(filter(list, false), i64 not in array)
+find(groupBy(array, #).Qux, .String?.f32)
+find(groupBy(array, #).ok, first(#[1]))
+find(i .. i64, ok)
+find(i64 .. i32, # != #)
+find(list, !false)
+find(list, !ok)
+find(list, "bar" not in #)
+find(list, "foo" contains "foo")
 find(list, # != #)
+find(list, # != nil)
 find(list, # == #)
+find(list, # == foo)
 find(list, # == nil)
-find(list, # not in list)
-find(list, 0.5 < f64)
-find(list, 0.5 <= i64)
-find(list, 0.5 > i)
-find(list, 1 < 0.5)
-find(list, 1 <= 0.5)
+find(list, 0.5 != 1)
+find(list, 0.5 <= 0.5)
+find(list, 1 != 0.5)
+find(list, 1 < 1)
+find(list, 1 < i64)
+find(list, 1 == f64)
+find(list, 1 > 0.5)
 find(list, 1 > i)
-find(list, add == add)
-find(list, f32 != f32)
-find(list, f32 < f64)
-find(list, f32 <= f32)
+find(list, 1 > i64)
+find(list, f32 < 1)
+find(list, f32 <= 0.5)
 find(list, f32 <= i32)
-find(list, f32 == f32)
-find(list, f64 != f32)
-find(list, f64 <= i64)
-find(list, f64 >= f32)
+find(list, f32 == i64)
+find(list, f32 > f64)
+find(list, f32 not in array)
+find(list, f64 < f64)
+find(list, false && true)
 find(list, false)?.Bar
 find(list, foo != #)
 find(list, foo == #)
-find(list, i < 1)
-find(list, i >= f64)
-find(list, i32 <= f32)
-find(list, i64 != f64)
-find(list, i64 >= 0.5)
-find(list, list != array)
+find(list, greet != div)
+find(list, i != 1)
+find(list, i != f64)
+find(list, i != i32)
+find(list, i32 != 1)
+find(list, i32 != f64)
+find(list, i32 < i)
+find(list, i32 == i32)
 find(list, nil != #)
-find(list, nil != greet)
-find(list, nil != half)
 find(list, nil != ok)
-find(list, nil == #)
-find(list, nil == half)
-find(list, nil == score)
-find(list, nil not in array)
-find(list, nil not in list)
-find(list, not ok)
-find(list, ok or ok)
+find(list, nil == array)
+find(list, nil == div)
+find(list, not false)
+find(list, ok != false)
 find(list, ok)
-find(list, ok).Bar
-find(list, ok).Qux
 find(list, ok).String
+find(list, ok).String()
+find(list, ok)?.Bar
 find(list, ok)?.Qux
 find(list, ok)?.String
-find(list, score != add)
-find(list, score != greet)
+find(list, score == score)
+find(list, true != nil)
+find(list, true == true)
+find(list, true or false)
 find(list, true).Bar
 find(list, true).Qux
 find(list, true).String
 find(list, true)?.Bar
-find(list, true)?.Qux
 find(list, true)?.String
-find(list, true)?.String()
-find(map(array, #), # == #)
+find(map(array, #), # != f32)
+find(map(array, #), # <= 1)
+find(map(array, #), # == 0.5)
 find(map(array, #), ok)
-find(map(array, i), ok)
-find(map(array, true), #)
-find(map(list, "foo"), ok)
+find(map(array, false), #)
+find(map(array, foo), ok)
+find(map(array, ok), #)
 find(map(list, #), # != #)
-find(map(list, 0.5), # >= #)
-find(map(list, ok), ok)
+find(map(list, #), ok)
+find(map(list, 0.5), # != #)
+find(map(list, add), 0.5 >= i64)
+find(map(list, div), # == #)
+find(map(list, f32), # > 0.5)
+find(map(list, false), #)
+find(map(list, i), # == i64)
+find(map(list, ok), #)
 find(map(list, true), #)
-find(ok ? "bar" : 0.5, # != i32)
-find(sort(array), ok)
-find(true ? array : false, 0.5 > #)?.list
-findIndex(["bar"], ok)
-findIndex(["foo"], 0.5 > i64)
-findIndex(["foo"], ok)
-findIndex([1], # < #)
-findIndex([f64, greet], 1 > f64)
-findIndex([false], #)
-findIndex(array, !(# != #))
-findIndex(array, !(# == 1))
-findIndex(array, !false)
+find(ok ? "foo" : f64, f32 >= #)
 findIndex(array, !ok)
-findIndex(array, !true)
-findIndex(array, "bar" not endsWith "bar")
-findIndex(array, "bar" not startsWith "foo")
+findIndex(array, "bar" == "foo")
+findIndex(array, "foo" > "foo")
+findIndex(array, "foo" in foo)
 findIndex(array, # != #)
 findIndex(array, # != 0.5)
 findIndex(array, # != f32)
 findIndex(array, # != f64)
-findIndex(array, # != i32)
+findIndex(array, # != i)
 findIndex(array, # != i64)
 findIndex(array, # != nil)
-findIndex(array, # ** # > #)
 findIndex(array, # < #)
 findIndex(array, # < 1)
-findIndex(array, # < f64)
-findIndex(array, # < i)
 findIndex(array, # < i32)
-findIndex(array, # < i64)
 findIndex(array, # <= #)
+findIndex(array, # <= 0.5)
 findIndex(array, # <= 1)
-findIndex(array, # <= i)
-findIndex(array, # <= i32)
 findIndex(array, # == #)
+findIndex(array, # == 0.5)
 findIndex(array, # == 1)
-findIndex(array, # == f64)
 findIndex(array, # == i32)
+findIndex(array, # == nil)
 findIndex(array, # > #)
 findIndex(array, # > 0.5)
 findIndex(array, # > 1)
-findIndex(array, # > f32)
 findIndex(array, # > f64)
-findIndex(array, # > i64 - i)
+findIndex(array, # > i)
 findIndex(array, # > i64)
 findIndex(array, # >= #)
+findIndex(array, # >= 0.5)
 findIndex(array, # >= 1)
 findIndex(array, # >= f32)
+findIndex(array, # >= f64)
 findIndex(array, # >= i)
 findIndex(array, # >= i32)
-findIndex(array, # in array)
-findIndex(array, # not in array)
-findIndex(array, 0.5 < #)
-findIndex(array, 0.5 <= 1)
-findIndex(array, 0.5 <= f32)
+findIndex(array, # >= i64)
+findIndex(array, 0.5 != #)
+findIndex(array, 0.5 != 1)
+findIndex(array, 0.5 < 1)
+findIndex(array, 0.5 <= #)
 findIndex(array, 0.5 == #)
-findIndex(array, 0.5 > i64)
-findIndex(array, 0.5 >= #)
-findIndex(array, 0.5 >= i)
+findIndex(array, 0.5 == i64)
+findIndex(array, 0.5 > #)
+findIndex(array, 0.5 > 0.5)
+findIndex(array, 0.5 > i)
+findIndex(array, 0.5 > i32)
+findIndex(array, 0.5 >= 0.5)
+findIndex(array, 0.5 >= 1)
+findIndex(array, 0.5 not in array)
 findIndex(array, 1 != #)
+findIndex(array, 1 != i64)
+findIndex(array, 1 != nil)
 findIndex(array, 1 < #)
-findIndex(array, 1 < f32)
-findIndex(array, 1 < i64)
 findIndex(array, 1 <= #)
-findIndex(array, 1 == #)
 findIndex(array, 1 > #)
+findIndex(array, 1 > i)
 findIndex(array, 1 >= #)
-findIndex(array, add != half)
-findIndex(array, any(array, f32 < #))
-findIndex(array, f32 <= #)
+findIndex(array, add != div)
+findIndex(array, add != nil)
+findIndex(array, f32 != #)
+findIndex(array, f32 != 1)
+findIndex(array, f32 < #)
 findIndex(array, f32 == #)
-findIndex(array, f32 == nil)
-findIndex(array, f32 > #)
 findIndex(array, f32 >= #)
-findIndex(array, f64 <= #)
-findIndex(array, f64 <= i64)
-findIndex(array, f64 == #)
-findIndex(array, f64 > #)
+findIndex(array, f32 >= i32)
 findIndex(array, f64 >= #)
-findIndex(array, f64 >= 1)
-findIndex(array, half != greet)
-findIndex(array, i != #)
-findIndex(array, i < 0.5)
+findIndex(array, f64 >= i32)
+findIndex(array, false) == -f64
+findIndex(array, i != f64)
+findIndex(array, i < #)
+findIndex(array, i < i32)
 findIndex(array, i <= #)
-findIndex(array, i <= i32)
+findIndex(array, i <= 0.5)
 findIndex(array, i == #)
-findIndex(array, i == i)
-findIndex(array, i > #)
 findIndex(array, i >= i)
+findIndex(array, i >= i32)
 findIndex(array, i32 != #)
 findIndex(array, i32 < #)
-findIndex(array, i32 < f64)
-findIndex(array, i32 < i)
-findIndex(array, i32 <= #)
 findIndex(array, i32 == #)
-findIndex(array, i32 == nil)
-findIndex(array, i32 > #)
+findIndex(array, i32 > f32)
 findIndex(array, i64 != #)
-findIndex(array, i64 == #)
+findIndex(array, i64 != nil)
+findIndex(array, i64 < 0.5)
+findIndex(array, i64 <= #)
+findIndex(array, i64 <= i64)
 findIndex(array, i64 > #)
 findIndex(array, i64 >= #)
-findIndex(array, nil != #)
-findIndex(array, nil != 1)
-findIndex(array, nil != list)
-findIndex(array, nil == foo)
-findIndex(array, nil == i)
-findIndex(array, not ok)
+findIndex(array, i64 >= f64)
+findIndex(array, i64 >= i32)
+findIndex(array, nil != half)
+findIndex(array, nil != ok)
+findIndex(array, nil == #)
+findIndex(array, nil == 1)
+findIndex(array, nil == nil)
+findIndex(array, not false)
 findIndex(array, ok)
-findIndex(array, ok) * f64
-findIndex(array, ok) - i32
 findIndex(array, ok) / f64
-findIndex(array, ok) >= f64
+findIndex(array, ok) / i
+findIndex(array, ok) <= f32
+findIndex(array, one(list, false))
 findIndex(array, score == greet)
-findIndex(array, true or false)
-findIndex(false ? div : list, ok)
+findIndex(array, true) + f64
+findIndex(array, true) - f64
+findIndex(array, true) .. i
+findIndex(filter(array, false), # > 1)
+findIndex(filter(array, true), # not in array)
+findIndex(filter(list, false), 1 <= i64)
+findIndex(groupBy(array, #).f64, .Bar(half(add, half, div, greet, f64)))
+findIndex(groupBy(array, #)?.greet, .f64(foo(array, #), # != "bar"))
+findIndex(groupBy(array, false).String, #?.i64())
+findIndex(groupBy(array, foo).String, #)
+findIndex(groupBy(list, #).Qux, #)
+findIndex(groupBy(list, #)?.Qux, #)
+findIndex(groupBy(list, #)?.i64, #)
+findIndex(groupBy(list, true)?.list, get(false ? # : #, score(#, Bar, half, #)))
+findIndex(i32 .. 1, # >= #)
 findIndex(list, !false)
+findIndex(list, !ok)
 findIndex(list, !true)
-findIndex(list, "bar" == "bar")
-findIndex(list, "foo" != "bar")
-findIndex(list, "foo" contains "bar")
-findIndex(list, "foo" matches "bar")
+findIndex(list, "bar" > "foo")
+findIndex(list, "bar" in #)
+findIndex(list, "bar" not in #)
 findIndex(list, # != #)
-findIndex(list, # != foo)
 findIndex(list, # != nil)
 findIndex(list, # == #)
-findIndex(list, # == nil)
+findIndex(list, # == foo)
 findIndex(list, # in list)
-findIndex(list, 0.5 < i)
-findIndex(list, 0.5 <= f64)
-findIndex(list, 0.5 <= i64)
-findIndex(list, 0.5 > f64)
-findIndex(list, 0.5 >= f32)
-findIndex(list, 1 == nil)
-findIndex(list, array != list)
-findIndex(list, f32 < f64)
-findIndex(list, f64 <= f32)
-findIndex(list, f64 <= f64)
-findIndex(list, f64 == nil)
-findIndex(list, f64 > f64)
-findIndex(list, false && true)
+findIndex(list, #?.Bar not in #)
+findIndex(list, 0.5 != i)
+findIndex(list, 0.5 > 1)
+findIndex(list, 0.5 >= i)
+findIndex(list, 1 != i32)
+findIndex(list, 1 < f64)
+findIndex(list, 1 < i32)
+findIndex(list, 1 == f32)
+findIndex(list, 1 > 0.5)
+findIndex(list, 1 > i32)
+findIndex(list, 1 >= 1)
+findIndex(list, 1 >= i)
+findIndex(list, f32 != f32)
+findIndex(list, f32 != i)
+findIndex(list, f32 < i32)
+findIndex(list, f32 == bitshl(i, i64))
+findIndex(list, f32 > 1)
+findIndex(list, f64 != 0.5)
+findIndex(list, f64 < 1)
+findIndex(list, f64 < i)
+findIndex(list, f64 > 1)
+findIndex(list, f64 >= f64)
+findIndex(list, false != nil)
+findIndex(list, false || ok)
 findIndex(list, foo != #)
-findIndex(list, foo == #)
-findIndex(list, greet != half)
-findIndex(list, half == add)
-findIndex(list, i32 == i)
-findIndex(list, i32 > f64)
-findIndex(list, i32 >= i32)
-findIndex(list, i64 < 0.5)
-findIndex(list, i64 > f64)
-findIndex(list, nil != #)
-findIndex(list, nil != f64)
-findIndex(list, nil != false)
-findIndex(list, nil == #)
-findIndex(list, nil == 0.5)
-findIndex(list, nil == ok)
-findIndex(list, nil in list)
-findIndex(list, not false)
+findIndex(list, greet == nil)
+findIndex(list, i < 0.5)
+findIndex(list, i <= i32)
+findIndex(list, i32 == 1)
+findIndex(list, i32 >= i64)
+findIndex(list, i64 != f32)
+findIndex(list, nil != 0.5)
+findIndex(list, nil != f32)
+findIndex(list, nil != i64)
+findIndex(list, nil == "foo")
+findIndex(list, nil == f64)
 findIndex(list, not ok)
-findIndex(list, ok != ok)
-findIndex(list, ok or ok)
+findIndex(list, not true)
 findIndex(list, ok)
-findIndex(list, ok) + f32
-findIndex(list, ok) / i
-findIndex(list, ok) > i32
-findIndex(list, one(list, ok))
-findIndex(list, true ? true : true)
-findIndex(list, true) .. i
-findIndex(list, true) == 0.5 ^ i32
-findIndex(list, true) > i32 ** f32
-findIndex(list, true) not in array
-findIndex(map(array, #), # > #)
-findIndex(map(array, #), # >= f32)
-findIndex(map(array, 1), # != #)
-findIndex(map(array, add), i64 >= i64)
-findIndex(map(array, div), # == #)
-findIndex(map(array, false), #)
-findIndex(map(array, i64), ok)
-findIndex(map(list, #), !ok)
-findIndex(map(list, #), div == div)
-findIndex(map(list, #), ok)
-findIndex(map(list, f32), i32 == f64)
-findIndex(map(list, list), ok)
-findIndex(map(list, ok), # == ok)
-findIndex(sort(array), # < #)
-findIndex(true ? "bar" : i32, # < #)
-findIndex(true ? "bar" : true, ok)
-findLast([0.5], i64 != 0.5)
+findIndex(list, ok) * i
+findIndex(list, ok) ** i
+findIndex(list, ok) >= f64
+findIndex(list, ok) ^ i32
+findIndex(list, true ? ok : #)
+findIndex(list, true) % i64
+findIndex(map(array, #), # < #)
+findIndex(map(array, #), # >= #)
+findIndex(map(array, #), i > #)
+findIndex(map(array, f32), i32 == #)
+findIndex(map(array, i), # != #)
+findIndex(map(array, i), ok)
+findIndex(map(list, #), # != #)
+findIndex(map(list, #), # == #)
+findIndex(map(list, i64), # == 0.5)
+findIndex(map(list, i64), i64 < #)
+findIndex(map(list, true), #)
+findIndex(map(list, true), ok)
+findIndex(ok ? "foo" : greet, !ok)
+findIndex(ok ? "foo" : i, # == #)
+findIndex(sort(array), i32 == #)
+findIndex(true ? "foo" : ok, # == greet)
+findLast(1 .. i, # <= #)
+findLast(1 .. i32, 1 >= #)
+findLast(1 .. i64, ok)
+findLast([1, f64], half == add)
+findLast([false], #)
 findLast(array, !false)
-findLast(array, !true)
-findLast(array, "bar" > "bar")
-findLast(array, "foo" startsWith "foo")
+findLast(array, !ok)
+findLast(array, "foo" > "bar")
 findLast(array, # != #)
+findLast(array, # != 0.5)
+findLast(array, # != 1)
+findLast(array, # != f32)
 findLast(array, # != f64)
-findLast(array, # != nil)
+findLast(array, # != i)
 findLast(array, # < #)
 findLast(array, # < 0.5)
-findLast(array, # < 1)
 findLast(array, # < f32)
 findLast(array, # < f64)
-findLast(array, # < i)
+findLast(array, # < i + #)
 findLast(array, # <= #)
 findLast(array, # <= 0.5)
 findLast(array, # <= 1)
 findLast(array, # <= f32)
-findLast(array, # <= f64)
-findLast(array, # <= i)
 findLast(array, # <= i64)
 findLast(array, # == #)
 findLast(array, # == 0.5)
-findLast(array, # == f64)
-findLast(array, # == i64)
+findLast(array, # == nil)
 findLast(array, # > #)
 findLast(array, # > 0.5)
+findLast(array, # > 1)
 findLast(array, # > i)
 findLast(array, # > i32)
 findLast(array, # > i64)
 findLast(array, # >= #)
 findLast(array, # >= 0.5)
-findLast(array, # >= f64)
-findLast(array, # >= i)
+findLast(array, # >= 1)
+findLast(array, # >= f32)
 findLast(array, # >= i32)
-findLast(array, # not in array)
-findLast(array, 0.5 != #)
-findLast(array, 0.5 != 0.5)
-findLast(array, 0.5 != i)
-findLast(array, 0.5 < #)
-findLast(array, 0.5 < i64)
 findLast(array, 0.5 <= #)
-findLast(array, 0.5 == #)
-findLast(array, 0.5 > 0.5)
+findLast(array, 0.5 <= i64)
+findLast(array, 0.5 > #)
+findLast(array, 0.5 >= #)
 findLast(array, 0.5 >= 1)
-findLast(array, 0.5 >= f64)
 findLast(array, 1 != #)
-findLast(array, 1 != i64)
-findLast(array, 1 < #)
 findLast(array, 1 <= #)
-findLast(array, 1 <= 0.5)
-findLast(array, 1 <= f32)
 findLast(array, 1 == #)
-findLast(array, 1 == nil)
-findLast(array, 1 > #)
-findLast(array, 1 >= #)
-findLast(array, 1 >= 1)
-findLast(array, add != greet)
-findLast(array, array == array)
-findLast(array, div != score)
-findLast(array, f32 != nil)
-findLast(array, f32 < #)
 findLast(array, f32 >= #)
-findLast(array, f32 >= 1)
-findLast(array, f64 != i)
-findLast(array, f64 < i64)
-findLast(array, f64 >= #)
-findLast(array, foo != nil)
-findLast(array, half == nil)
-findLast(array, i != i32)
+findLast(array, f64 != #)
+findLast(array, f64 != nil)
+findLast(array, f64 <= #)
+findLast(array, f64 <= 1)
+findLast(array, f64 == #)
+findLast(array, f64 == nil)
+findLast(array, f64 >= 1)
+findLast(array, f64 >= i64)
+findLast(array, false != true)
+findLast(array, false or true)
+findLast(array, greet != nil)
 findLast(array, i < #)
-findLast(array, i <= #)
-findLast(array, i >= #)
-findLast(array, i32 != #)
-findLast(array, i32 <= f32)
-findLast(array, i32 == 1)
+findLast(array, i == i32)
+findLast(array, i > #)
+findLast(array, i >= 0.5)
+findLast(array, i32 < #)
+findLast(array, i32 == 0.5)
 findLast(array, i32 > #)
 findLast(array, i32 >= #)
-findLast(array, i32 >= 0.5)
+findLast(array, i32 >= i32)
 findLast(array, i64 != #)
-findLast(array, i64 != 1)
 findLast(array, i64 < #)
 findLast(array, i64 <= #)
-findLast(array, i64 <= 0.5)
 findLast(array, i64 == #)
-findLast(array, i64 == nil)
-findLast(array, i64 >= #)
-findLast(array, i64 >= i32)
-findLast(array, nil != #)
-findLast(array, nil != nil)
-findLast(array, nil == #)
-findLast(array, nil == nil)
+findLast(array, i64 > 0.5)
+findLast(array, list != nil)
+findLast(array, nil != array)
+findLast(array, not (array == array))
 findLast(array, not false)
-findLast(array, not true)
+findLast(array, not ok)
+findLast(array, ok and true)
 findLast(array, ok)
-findLast(array, ok) < f64
-findLast(array, true) + i
-findLast(array, true) + i32
-findLast(array, true) <= f64
-findLast(array, true) > i
-findLast(i .. 1, # > f32)
-findLast(i32 .. 1, # >= #)
-findLast(i32 .. i32, ok)
-findLast(i64 .. 1, f32 <= #)
-findLast(list, !true)
-findLast(list, "bar" in #)
-findLast(list, "bar" not contains "bar")
-findLast(list, "bar" not in #)
-findLast(list, "bar" not matches "bar")
-findLast(list, "foo" == "foo")
-findLast(list, "foo" > "foo")
+findLast(array, ok) == i64
+findLast(array, reduce(list, ok))
+findLast(array, score != div)
+findLast(array, score != nil)
+findLast(array, true) % i64
+findLast(groupBy(array, #).i32, #)
+findLast(groupBy(array, f64)?.score, #)
+findLast(groupBy(list, "bar").div, #?.f32?.half())
+findLast(groupBy(list, #)[ok], .ok)
+findLast(groupBy(list, 0.5)?.String, #?.half(Bar))
+findLast(groupBy(list, 0.5)?.f32, ok)
+findLast(groupBy(list, f64).foo, .f32(#, #)?.Qux(#?.i64(add, nil)))
+findLast(groupBy(list, f64)?.Bar, #)
+findLast(i .. 1, # < #)
+findLast(i .. i32, # != i64)
+findLast(i .. i32, ok)
+findLast(i32 .. i64, # >= i)
+findLast(i64 .. 1, # < #)
+findLast(list, !false)
+findLast(list, !ok)
 findLast(list, "foo" in #)
-findLast(list, "foo" not in #)
 findLast(list, # != #)
+findLast(list, # != nil)
 findLast(list, # == #)
 findLast(list, # == foo)
-findLast(list, # == nil)
+findLast(list, # in list)
 findLast(list, # not in list)
-findLast(list, 0.5 == nil)
-findLast(list, 0.5 > f32)
-findLast(list, 1 != 0.5)
-findLast(list, 1 != 1)
-findLast(list, 1 <= i)
-findLast(list, 1 > 1)
-findLast(list, 1 > i)
-findLast(list, 1 >= 0.5)
-findLast(list, 1 >= 1)
-findLast(list, add == nil)
-findLast(list, all(list, false))
-findLast(list, f32 < f64)
+findLast(list, 0.5 != i64)
+findLast(list, 0.5 <= 1)
+findLast(list, 0.5 == i64)
+findLast(list, 1 != f32)
+findLast(list, 1 != nil)
+findLast(list, 1 <= 1)
+findLast(list, 1 > f32)
+findLast(list, 1 >= f64)
+findLast(list, f32 != i)
+findLast(list, f32 > f32)
+findLast(list, f32 >= 1)
+findLast(list, f64 <= i)
+findLast(list, f64 in array)
 findLast(list, false)?.Bar
-findLast(list, foo != #)?.Bar
-findLast(list, foo == #)
-findLast(list, greet == half)
-findLast(list, i != 1)
-findLast(list, i != i64)
-findLast(list, i >= f32)
-findLast(list, i32 == 1)
-findLast(list, i64 <= 0.5)
-findLast(list, i64 <= i)
-findLast(list, i64 == i32)
-findLast(list, i64 > 0.5)
+findLast(list, foo != #)
+findLast(list, foo in list)
+findLast(list, i != i)
+findLast(list, i <= 1)
+findLast(list, i <= i)
+findLast(list, i == i32)
+findLast(list, i >= i)
+findLast(list, i32 != f32)
+findLast(list, i64 > f32)
 findLast(list, i64 > i)
-findLast(list, i64 >= i32)
-findLast(list, nil != "bar")
+findLast(list, i64 >= 1)
 findLast(list, nil != #)
-findLast(list, nil != add)
-findLast(list, nil != false)
-findLast(list, nil != foo)
-findLast(list, nil != nil)
-findLast(list, nil != ok)
-findLast(list, nil == #)
-findLast(list, nil == i32)
-findLast(list, nil == i64)
-findLast(list, nil == list)
-findLast(list, nil == nil)
-findLast(list, not ok)
-findLast(list, ok ? ok : nil)
+findLast(list, nil not in array)
+findLast(list, nil not in list)
+findLast(list, none(array, ok))
+findLast(list, not false)
+findLast(list, not true)
+findLast(list, ok or true)
 findLast(list, ok)
+findLast(list, ok) not in list
 findLast(list, ok).Bar
 findLast(list, ok).Qux
 findLast(list, ok).String
-findLast(list, ok).String()
 findLast(list, ok)?.Bar
 findLast(list, ok)?.Qux
 findLast(list, ok)?.String
-findLast(list, one(list, true))
-findLast(list, true != nil)
+findLast(list, true or ok)
 findLast(list, true).Bar
 findLast(list, true).Qux
 findLast(list, true).String
 findLast(list, true)?.Bar
 findLast(list, true)?.Qux
 findLast(list, true)?.String
-findLast(map(array, #), # > f32)
-findLast(map(array, #), # >= #)
+findLast(map(array, #), # < #)
+findLast(map(array, #), # < i32)
+findLast(map(array, #), # <= 1)
+findLast(map(array, #), # == f64)
+findLast(map(array, #), 0.5 != 0.5)
 findLast(map(array, #), i32 == #)
 findLast(map(array, #), ok)
-findLast(map(array, f64), # <= #)
-findLast(map(array, i), # <= #)
-findLast(map(array, ok), #)
-findLast(map(array, ok), not #)
-findLast(map(array, true), #)
-findLast(map(list, #), # != #)
-findLast(map(list, array), # == #)
-findLast(map(list, i), # >= #)
-findLast(map(list, list), ok)
-findLast(map(list, score), 0.5 > f32)
-findLast(ok ? array : div, # >= #)
-findLast(sort(array), # && false)
-findLastIndex([i32], # >= 0.5)
-findLastIndex(array, !false)
-findLastIndex(array, !ok)
-findLastIndex(array, !true)
-findLastIndex(array, "bar" != "bar")
+findLast(map(array, f64 * #), # + # > f32)
+findLast(map(array, score), ok)
+findLast(map(list, #), # == #)
+findLast(map(list, #), greet == nil)
+findLast(map(list, #), ok)
+findLast(map(list, ok), # ? # : #)
+findLastIndex(1 .. 1, i64 < #)
+findLastIndex([false], 0.5 == #)
+findLastIndex([i64, half], ok)
+findLastIndex(array, "bar" not matches "foo")
+findLastIndex(array, "bar" startsWith "foo")
+findLastIndex(array, "foo" == nil)
+findLastIndex(array, "foo" >= "foo")
+findLastIndex(array, "foo" contains "foo")
 findLastIndex(array, # != #)
-findLastIndex(array, # != 0.5)
+findLastIndex(array, # != 1)
+findLastIndex(array, # != f32)
+findLastIndex(array, # != f64)
+findLastIndex(array, # != i32)
 findLastIndex(array, # != i64)
 findLastIndex(array, # != nil)
-findLastIndex(array, # / f32 == #)
-findLastIndex(array, # < # ** i32)
 findLastIndex(array, # < #)
-findLastIndex(array, # < 0.5)
 findLastIndex(array, # < 1)
-findLastIndex(array, # < f32)
 findLastIndex(array, # < f64)
 findLastIndex(array, # < i)
 findLastIndex(array, # < i64)
 findLastIndex(array, # <= #)
 findLastIndex(array, # <= 0.5)
-findLastIndex(array, # <= 1)
-findLastIndex(array, # <= f32)
-findLastIndex(array, # <= f64)
-findLastIndex(array, # <= i)
-findLastIndex(array, # <= i32)
 findLastIndex(array, # <= i64)
 findLastIndex(array, # == #)
 findLastIndex(array, # == 0.5)
 findLastIndex(array, # == 1)
-findLastIndex(array, # == i32)
+findLastIndex(array, # == f64)
+findLastIndex(array, # == i64)
 findLastIndex(array, # == nil)
 findLastIndex(array, # > #)
 findLastIndex(array, # > 0.5)
-findLastIndex(array, # > 1)
+findLastIndex(array, # > f32)
+findLastIndex(array, # > f64)
 findLastIndex(array, # > i)
-findLastIndex(array, # > i64)
 findLastIndex(array, # >= #)
+findLastIndex(array, # >= 0.5)
 findLastIndex(array, # >= 1)
-findLastIndex(array, # >= f64)
-findLastIndex(array, # in array)
+findLastIndex(array, # >= f32)
+findLastIndex(array, # >= i32)
+findLastIndex(array, # ^ # >= #)
 findLastIndex(array, # not in array)
 findLastIndex(array, 0.5 != #)
-findLastIndex(array, 0.5 != 0.5)
+findLastIndex(array, 0.5 != i64)
 findLastIndex(array, 0.5 < #)
-findLastIndex(array, 0.5 < i)
+findLastIndex(array, 0.5 < i32)
 findLastIndex(array, 0.5 <= #)
-findLastIndex(array, 0.5 <= 0.5)
-findLastIndex(array, 0.5 == #)
 findLastIndex(array, 0.5 > #)
-findLastIndex(array, 0.5 > i)
-findLastIndex(array, 0.5 >= #)
-findLastIndex(array, 0.5 >= f32)
+findLastIndex(array, 0.5 >= 0.5)
+findLastIndex(array, 0.5 >= f64)
 findLastIndex(array, 1 != #)
-findLastIndex(array, 1 < #)
 findLastIndex(array, 1 <= #)
-findLastIndex(array, 1 <= i)
-findLastIndex(array, 1 <= i64)
 findLastIndex(array, 1 == #)
-findLastIndex(array, 1 > #)
-findLastIndex(array, 1 > 1)
-findLastIndex(array, 1 >= #)
-findLastIndex(array, 1 in array)
-findLastIndex(array, add != add)
-findLastIndex(array, any(list, false))
+findLastIndex(array, 1 == f64)
+findLastIndex(array, 1 >= i32)
+findLastIndex(array, array == nil)
 findLastIndex(array, f32 != #)
+findLastIndex(array, f32 != f32)
 findLastIndex(array, f32 < #)
-findLastIndex(array, f32 <= f64)
-findLastIndex(array, f32 == f64)
+findLastIndex(array, f32 == #)
+findLastIndex(array, f32 == nil)
 findLastIndex(array, f32 > #)
-findLastIndex(array, f32 >= f64)
 findLastIndex(array, f64 != #)
 findLastIndex(array, f64 < #)
+findLastIndex(array, f64 <= #)
+findLastIndex(array, f64 <= i32)
 findLastIndex(array, f64 == #)
-findLastIndex(array, f64 > i)
-findLastIndex(array, f64 >= #)
-findLastIndex(array, i == #)
-findLastIndex(array, i > #)
-findLastIndex(array, i > 1)
-findLastIndex(array, i >= #)
-findLastIndex(array, i32 != #)
-findLastIndex(array, i32 < #)
-findLastIndex(array, i32 <= 0.5)
-findLastIndex(array, i32 == #)
-findLastIndex(array, i32 == i32)
-findLastIndex(array, i32 > #)
-findLastIndex(array, i64 != #)
-findLastIndex(array, i64 != f32)
-findLastIndex(array, i64 >= #)
-findLastIndex(array, list != nil)
-findLastIndex(array, nil != "foo")
+findLastIndex(array, f64 == 0.5)
+findLastIndex(array, f64 > #)
+findLastIndex(array, false ? # : false)
+findLastIndex(array, foo != foo)
+findLastIndex(array, greet == greet)
+findLastIndex(array, half == greet)
+findLastIndex(array, i - # >= #)
+findLastIndex(array, i < #)
+findLastIndex(array, i <= #)
+findLastIndex(array, i > 0.5)
+findLastIndex(array, i32 <= #)
+findLastIndex(array, i32 <= 1)
+findLastIndex(array, i32 <= f32)
+findLastIndex(array, i32 > 0.5)
+findLastIndex(array, i32 >= #)
+findLastIndex(array, i64 <= # + #)
+findLastIndex(array, i64 > #)
+findLastIndex(array, min(1, #) <= i32 + #)
 findLastIndex(array, nil != #)
-findLastIndex(array, nil != 0.5)
-findLastIndex(array, nil != foo)
-findLastIndex(array, nil != nil)
+findLastIndex(array, nil != add)
+findLastIndex(array, nil != i32)
 findLastIndex(array, nil == #)
-findLastIndex(array, nil == i)
-findLastIndex(array, nil not in list)
-findLastIndex(array, none(array, true))
-findLastIndex(array, not (# != #))
-findLastIndex(array, not false)
+findLastIndex(array, not (i32 != 0.5))
+findLastIndex(array, not ok)
+findLastIndex(array, ok && true)
 findLastIndex(array, ok)
-findLastIndex(array, ok) * f64
-findLastIndex(array, ok) / i64
-findLastIndex(array, ok) <= i64
-findLastIndex(array, ok) ^ f32
-findLastIndex(array, true ? ok : 1)
+findLastIndex(array, ok) % i64
+findLastIndex(array, ok) + f64
+findLastIndex(array, one(list, ok))
+findLastIndex(array, score == nil)
+findLastIndex(array, true == false)
 findLastIndex(array, true) / f32
-findLastIndex(array, true) <= i64
-findLastIndex(array, true) > f64
-findLastIndex(false ? i : "bar", ok)
-findLastIndex(filter(list, true), ok)
-findLastIndex(i .. i32, # == 1)
-findLastIndex(i32 .. i, ok)
-findLastIndex(i32 .. i64, f64 == nil)
-findLastIndex(i64 .. 1, # != nil)
-findLastIndex(i64 .. 1, add == nil)
+findLastIndex(array, true) not in array
+findLastIndex(filter(array, false), ok)
+findLastIndex(groupBy(array, "foo")?.add, #[list])
+findLastIndex(groupBy(array, #)?.foo, #)
+findLastIndex(groupBy(array, #)?.i32, not #)
+findLastIndex(groupBy(array, #)?.score, #)
+findLastIndex(groupBy(list, #).ok, #)
+findLastIndex(groupBy(list, #)?.String, # + #.add)
+findLastIndex(groupBy(list, 0.5).Bar, #?.String endsWith .f32(list))
+findLastIndex(i32 .. i32, ok)
+findLastIndex(i64 .. 1, ok)
+findLastIndex(list, !(nil != #))
+findLastIndex(list, !false)
 findLastIndex(list, !ok)
 findLastIndex(list, !true)
 findLastIndex(list, "bar" in #)
-findLastIndex(list, "foo" matches "bar")
+findLastIndex(list, "bar" matches "foo")
+findLastIndex(list, "bar" not endsWith "foo")
+findLastIndex(list, "bar" not matches "bar")
+findLastIndex(list, "foo" <= "bar")
+findLastIndex(list, "foo" not in #)
 findLastIndex(list, # != #)
 findLastIndex(list, # != foo)
-findLastIndex(list, # != nil)
 findLastIndex(list, # == #)
+findLastIndex(list, # == foo)
 findLastIndex(list, # == nil)
 findLastIndex(list, # in list)
-findLastIndex(list, 0.5 != i)
-findLastIndex(list, 0.5 <= 0.5)
-findLastIndex(list, 0.5 <= f32)
-findLastIndex(list, 1 != 0.5)
-findLastIndex(list, 1 != f64)
-findLastIndex(list, 1 != i64)
-findLastIndex(list, 1 < i32)
-findLastIndex(list, 1 <= f32)
-findLastIndex(list, 1 <= i)
-findLastIndex(list, array != list)
+findLastIndex(list, # not in list)
+findLastIndex(list, 1 != f32)
+findLastIndex(list, 1 != nil)
+findLastIndex(list, 1 > 1)
+findLastIndex(list, 1 >= 0.5)
 findLastIndex(list, array != nil)
-findLastIndex(list, array == list)
-findLastIndex(list, div == add)
-findLastIndex(list, div == score)
-findLastIndex(list, f32 != 0.5)
-findLastIndex(list, f32 < f64)
-findLastIndex(list, f32 < i32)
-findLastIndex(list, f32 <= i64)
-findLastIndex(list, f32 == i32)
-findLastIndex(list, f32 > f32)
-findLastIndex(list, f64 <= 1)
-findLastIndex(list, f64 == f64)
-findLastIndex(list, false == false)
-findLastIndex(list, false and false)
-findLastIndex(list, false and ok)
-findLastIndex(list, false) != i
-findLastIndex(list, foo != #)
-findLastIndex(list, foo == foo)
-findLastIndex(list, greet != half)
-findLastIndex(list, greet == nil)
-findLastIndex(list, half != nil)
-findLastIndex(list, i < i64)
-findLastIndex(list, i <= i)
-findLastIndex(list, i32 != nil)
-findLastIndex(list, i32 < f64)
-findLastIndex(list, i32 <= i32)
-findLastIndex(list, i32 >= 0.5)
-findLastIndex(list, i32 >= i)
-findLastIndex(list, i64 < f64)
-findLastIndex(list, i64 == f32)
-findLastIndex(list, i64 >= i)
+findLastIndex(list, div != nil)
+findLastIndex(list, f32 != 1)
+findLastIndex(list, f32 != f64)
+findLastIndex(list, f64 > 0.5)
+findLastIndex(list, foo == #)
+findLastIndex(list, half != div)
+findLastIndex(list, half == greet)
+findLastIndex(list, half == score)
+findLastIndex(list, i <= 1)
+findLastIndex(list, i32 > 1)
+findLastIndex(list, i32 > f32)
+findLastIndex(list, i64 == i64)
+findLastIndex(list, i64 >= 0.5)
 findLastIndex(list, i64 not in array)
+findLastIndex(list, nil != "bar")
 findLastIndex(list, nil != #)
+findLastIndex(list, nil != f64)
 findLastIndex(list, nil == #)
-findLastIndex(list, none(array, ok))
-findLastIndex(list, not ok)
+findLastIndex(list, nil == 1)
+findLastIndex(list, nil == half)
+findLastIndex(list, not false)
 findLastIndex(list, not true)
-findLastIndex(list, ok != nil)
+findLastIndex(list, ok ? ok : 0.5)
+findLastIndex(list, ok and false)
 findLastIndex(list, ok)
-findLastIndex(list, ok) ** f32
-findLastIndex(list, ok) ** f64
-findLastIndex(list, ok) - i
-findLastIndex(list, ok) >= i64
-findLastIndex(list, true == nil)
-findLastIndex(list, true) ** i64
-findLastIndex(list, true) + i
-findLastIndex(list, true) .. i64
-findLastIndex(list, true) < i
-findLastIndex(list, true) > f32
-findLastIndex(list, true) >= f32
-findLastIndex(list, true) in array
-findLastIndex(map(array, "foo"), # == #)
-findLastIndex(map(array, #), i < #)
-findLastIndex(map(array, #), nil != half)
+findLastIndex(list, ok) != i64
+findLastIndex(list, ok) > f32
+findLastIndex(list, ok) > i64
+findLastIndex(list, one(array, true))
+findLastIndex(list, true && ok)
+findLastIndex(list, true) * i32
+findLastIndex(list, true) - i32
+findLastIndex(list, true) < i64
+findLastIndex(list, true) > i64
+findLastIndex(list, true) ^ f64
+findLastIndex(map(array, "bar"), # not endsWith #)
+findLastIndex(map(array, #), # < f64)
+findLastIndex(map(array, #), # <= #)
 findLastIndex(map(array, #), ok)
-findLastIndex(map(array, 0.5), ok)
-findLastIndex(map(array, array), 1 != i)
-findLastIndex(map(array, false), #)
-findLastIndex(map(array, true), #)
-findLastIndex(map(list, #), !ok)
-findLastIndex(map(list, #), 0.5 < f32)
-findLastIndex(map(list, 0.5), # <= #)
-findLastIndex(map(list, f32), # == #)
-findLastIndex(map(list, f32), # >= #)
-findLastIndex(map(list, f32), ok)
+findLastIndex(map(array, div), 0.5 <= 0.5)
+findLastIndex(map(array, f32), nil == nil)
+findLastIndex(map(array, list), ok)
+findLastIndex(map(array, ok), # and #)
+findLastIndex(map(list, "bar"), # >= #)
+findLastIndex(map(list, #), !true)
+findLastIndex(map(list, #), nil == 0.5)
 findLastIndex(map(list, false), #)
-findLastIndex(map(list, half), ok)
-findLastIndex(map(list, ok), # or #)
-findLastIndex(map(list, ok), #)
-findLastIndex(sort(array), ok)
-first(1 .. i)
-first(1 .. i32)
+findLastIndex(map(list, foo), ok)
+findLastIndex(map(list, i32), # >= #)
+findLastIndex(map(list, i64), ok)
+findLastIndex(ok ? "bar" : add, not false)
+findLastIndex(true ? "foo" : 1, # and false)
+first(1 .. 1)
+first(1 .. i64)
 first([f32])
-first([f64])
-first([false, list])
-first([i64, nil])
-first([list, i32])
-first([not false])
+first([foo])
+first([ok])
 first(array)
 first(array) * i
-first(array) ** i32
-first(array) ** i64
-first(array) + i32
-first(array) / 1 * 0.5
-first(array) <= i32
-first(array) <= i64
+first(array) * i64
+first(array) + f32
+first(array) <= i
+first(array) == f32
+first(array) == f64
 first(array) == i64
-first(array) > i32
+first(array) > 0.5 ** i
 first(array) > i64
-first(array) in array
-first(false ? f64 : true)
-first(false ? greet : i)
-first(filter(array, false))
-first(filter(list, ok))
-first(i .. 1)
+first(array) ^ f64
+first(array[1:1])
+first(false ? foo : 1)
+first(false ? greet : foo)
+first(get(groupBy(array, #), i))
+first(groupBy(array, #).greet)
+first(groupBy(list, #)?.div)
 first(i .. i)
-first(i .. i32)
-first(i32 .. 1)
-first(i32 .. i)
-first(i32 .. i64)
 first(i64 .. i32)
+first(i64 .. i64)
 first(list)
 first(list) not in list
 first(list).Bar
@@ -5704,44 +6497,33 @@ first(list)?.Bar
 first(list)?.Qux
 first(list)?.String
 first(list)?.String()
-first(map(array, "bar"))
 first(map(array, #))
 first(map(array, 0.5))
 first(map(array, 1))
 first(map(array, add))
-first(map(array, f32))
-first(map(array, f64))
-first(map(array, foo))
-first(map(array, greet))
+first(map(array, array))
+first(map(array, div))
 first(map(array, half))
 first(map(array, i))
-first(map(array, list))
+first(map(array, i32))
+first(map(array, i64))
 first(map(array, ok))
-first(map(array, score))
 first(map(list, #))
 first(map(list, 0.5))
-first(map(list, add))
-first(map(list, array))
-first(map(list, div))
 first(map(list, f32))
-first(map(list, f64))
-first(map(list, i32))
+first(map(list, greet))
+first(map(list, i))
 first(map(list, list))
 first(map(list, score))
-first(ok ? "bar" : 0.5)
-first(ok ? 1 : "foo")
-first(ok ? add : f32)
-first(ok ? array : "bar")
-first(ok ? list : nil)
-first(ok ? ok : array)
-first(ok ? ok : foo)
-first(ok ? ok : score)
+first(ok ? 0.5 : false)
+first(ok ? array : add)
+first(ok ? greet : i64)
+first(ok ? list : ok)
+first(reduce(list, array))
 first(sort(array))
-first(true ? 0.5 : i64)
-first(true ? add : ok)
-first(true ? array : false)
-first(true ? ok : div)
-float(-(1 / i32))
+first(true ? f32 : div)
+first(true ? greet : div)
+first(true ? score : div)
 float(-0.5)
 float(-1)
 float(-f32)
@@ -5750,184 +6532,149 @@ float(-i)
 float(-i32)
 float(-i64)
 float(0.5 * 0.5)
+float(0.5 * 1)
 float(0.5 * f32)
-float(0.5 * i)
-float(0.5 * i32)
 float(0.5 * i64)
 float(0.5 ** 0.5)
-float(0.5 ** 1)
 float(0.5 ** f32)
-float(0.5 ** i32)
 float(0.5 + 1)
-float(0.5 + f32)
-float(0.5 + i)
+float(0.5 + i32)
 float(0.5 + i64)
 float(0.5 - 0.5)
 float(0.5 - 1)
-float(0.5 - f32)
-float(0.5 - i)
-float(0.5 - i32)
 float(0.5 - i64)
 float(0.5 / 0.5)
-float(0.5 / 1)
-float(0.5 / f32)
-float(0.5 / f64)
-float(0.5 / i)
-float(0.5 ^ 0.5)
+float(0.5 / i32)
+float(0.5 / i64)
 float(0.5 ^ 1)
-float(0.5 ^ f64)
-float(0.5 ^ i32)
-float(0.5 ^ i64)
+float(0.5 ^ i)
+float(0.5) != f32
 float(0.5) != i32
-float(0.5) ** (1 % 1)
-float(0.5) + 0.5 - f64
-float(0.5) + f32
-float(0.5) + i32
-float(0.5) - -f32
-float(0.5) - f32
+float(0.5) * f32
+float(0.5) * i32
+float(0.5) * i64
+float(0.5) ** f64
+float(0.5) ** i
+float(0.5) ** i32
+float(0.5) - i
+float(0.5) - i64
 float(0.5) / f32
-float(0.5) < i32
-float(0.5) >= i32
-float(1 % 1)
-float(1 % i)
-float(1 % i32)
+float(0.5) / f64
+float(0.5) / i32
+float(0.5) == i32 * 0.5
+float(0.5) ^ i64
+float(0.5) in array
 float(1 % i64)
 float(1 * 0.5)
-float(1 * 1)
+float(1 * f32)
 float(1 * i)
-float(1 * i32)
 float(1 * i64)
 float(1 ** 0.5)
+float(1 ** 1)
+float(1 ** f64)
 float(1 ** i)
-float(1 + 0.5)
-float(1 + 1)
-float(1 + f32)
 float(1 + f64)
-float(1 + i)
+float(1 + i32)
 float(1 - 0.5)
-float(1 - 1)
-float(1 - f32)
-float(1 - i)
 float(1 / 0.5)
-float(1 / 1)
-float(1 / f64)
-float(1 / i)
-float(1 ^ 1)
-float(1 ^ f32)
 float(1 ^ f64)
-float(1 ^ i)
-float(1 ^ i32)
-float(1 ^ i64)
-float(1) != abs(f32)
-float(1) != {"foo": i32}?.add
+float(1) * f32
+float(1) * i64
+float(1) ** i
 float(1) ** i64
-float(1) - i64
-float(1) / i
-float(1) / i64
-float(1) < i32
+float(1) - f64
 float(1) <= i64
-float(1) == int(0.5)
-float(1) > i
-float(1) >= f32
-float(1) >= i - i
-float(abs(0.5))
-float(abs(1))
+float(1) == i64
+float(1) > -0.5
+float(1) > i64
+float(1) >= f64
+float(1) >= i
 float(abs(f32))
+float(abs(f64))
 float(abs(i))
 float(abs(i32))
-float(abs(i64))
-float(add(i, 1))
-float(array[1])
+float(add(1, 1))
 float(array[i32])
 float(array[i64])
 float(array[i])
-float(count(array, true))
-float(count(list, false) * (i - 1))
-float(count(list, false))
-float(div(1, i))
-float(div(i, 1))
-float(f32 * 0.5)
-float(f32 * f32)
+float(bitnot(1))
+float(bitnot(i))
+float(bitnot(i32))
+float(bitnot(i64))
+float(ceil(0.5))
+float(ceil(f32))
+float(ceil(f64))
+float(ceil(i32))
+float(ceil(i64))
+float(count(array, false))
+float(count(array, ok))
+float(count(list, i32 == 0.5))
+float(f32 * f64)
+float(f32 * i)
 float(f32 * i32)
-float(f32 * i64)
-float(f32 ** 0.5)
 float(f32 ** 1)
+float(f32 ** f32)
 float(f32 ** i)
 float(f32 ** i64)
 float(f32 + 0.5)
 float(f32 + 1)
-float(f32 + f32)
+float(f32 + f64)
 float(f32 + i32)
+float(f32 + i64)
 float(f32 - 0.5)
-float(f32 - 1)
 float(f32 - f64)
-float(f32 - i)
+float(f32 - i64)
 float(f32 / 0.5)
 float(f32 / 1)
-float(f32 / f32)
 float(f32 / i)
-float(f32 / i64)
 float(f32 ^ 0.5)
+float(f32 ^ 1)
 float(f32 ^ f32)
-float(f32 ^ f64)
-float(f32 ^ i64)
+float(f32 ^ i)
+float(f32 ^ i32)
 float(f32)
-float(f32) * f32
-float(f32) + f32
-float(f32) - f32
-float(f32) - f64
-float(f32) - i64
-float(f32) / f64
 float(f32) < i32
 float(f32) <= f32
-float(f32) >= f32
-float(f32) >= f32 ** f32
+float(f32) <= f64 / f32
+float(f32) <= i
+float(f32) > i
+float(f32) >= i64
 float(f32) ^ f64
-float(f32) ^ i32
+float(f32) ^ i64
 float(f64 * 0.5)
+float(f64 * 1)
 float(f64 * f32)
-float(f64 * i)
+float(f64 * f64)
 float(f64 * i32)
-float(f64 ** 1)
 float(f64 ** f32)
-float(f64 + 0.5)
 float(f64 + 1)
 float(f64 + i)
-float(f64 - 0.5)
+float(f64 + i32)
+float(f64 - 1)
 float(f64 - i)
-float(f64 - i32)
-float(f64 - i32) / i
-float(f64 / -i32)
+float(f64 / 0.5)
 float(f64 / 1)
-float(f64 / f32)
-float(f64 / i32)
-float(f64 ^ 0.5)
-float(f64 ^ 1)
+float(f64 / i64)
 float(f64 ^ f32)
-float(f64 ^ f64)
 float(f64)
-float(f64) != int(i32)
-float(f64) * i32
-float(f64) / f32
-float(f64) / f64
-float(f64) / i64
-float(f64) < i
-float(f64) < i32
-float(f64) <= f32
-float(f64) <= i64
-float(f64) == i32
-float(f64) > i32
-float(f64) >= f64
+float(f64) * f32
+float(f64) * i
+float(f64) / -i32
+float(f64) / i
+float(f64) == f64
+float(f64) > f64
+float(f64) > i64
+float(f64) >= f32
 float(f64) >= i
-float(f64) >= i32
-float(f64) ^ i
-float(false ? div : i32)
-float(false ? f32 : 0.5)
+float(f64) >= i64
+float(f64) ^ i64
+float(false ? f64 : 0.5)
+float(false ? half : f64)
+float(false ? list : f64)
 float(find(array, ok))
-float(find(array, true))
-float(findIndex(list, true))
-float(findLast(array, ok))
-float(findLast(array, true))
+float(findIndex(array, ok))
+float(findLastIndex(array, ok))
+float(findLastIndex(list, true))
 float(first(array))
 float(float(0.5))
 float(float(1))
@@ -5935,353 +6682,649 @@ float(float(f32))
 float(float(f64))
 float(float(i))
 float(float(i32))
-float(float(i64))
+float(floor(0.5))
+float(floor(1))
+float(floor(f32))
+float(floor(f64))
+float(floor(i32))
+float(floor(i64))
 float(get(array, 1))
 float(get(array, i))
-float(get(array, i64))
-float(half(-f64))
 float(half(0.5))
+float(half(1))
 float(half(f64))
-float(i % 1)
+float(i % i32)
 float(i * 0.5)
-float(i * 1)
 float(i * f64)
-float(i * i)
-float(i * i32 * i32)
-float(i * i32)
 float(i * i64)
-float(i ** 1)
-float(i ** f64)
+float(i ** f32)
 float(i ** i32)
 float(i + 0.5)
-float(i + f64)
+float(i + 1)
 float(i + i64)
-float(i - 0.5)
 float(i - 1)
-float(i - findIndex(array, true))
+float(i - f64)
+float(i / 0.5)
 float(i / 1)
-float(i / f64)
-float(i / i64)
-float(i ^ f32)
-float(i ^ f64)
-float(i ^ i64)
+float(i ^ 0.5)
+float(i ^ i32)
 float(i)
-float(i) != f32
-float(i) != i32
-float(i) != i64
-float(i) ** f32
-float(i) / i32
-float(i) < f32
-float(i) < i64
-float(i) <= f32
-float(i) == i32
+float(i) != 1 ? nil : foo
+float(i) != f64
+float(i) + f32
+float(i) + f64
+float(i) < i
+float(i) == f32
+float(i) == i
 float(i) > f64
-float(i) ^ f64
-float(i) ^ i64
-float(i32 % 1)
 float(i32 % i)
-float(i32 * 1)
-float(i32 * f32)
-float(i32 ** 0.5)
-float(i32 ** f64)
-float(i32 ** i32)
-float(i32 ** i64)
-float(i32 + 1)
-float(i32 + f32)
-float(i32 - 0.5)
-float(i32 - f64)
-float(i32 - i)
-float(i32 - i32)
-float(i32 / 0.5)
+float(i32 % i64)
+float(i32 * f64)
+float(i32 * i32)
+float(i32 ** 1)
+float(i32 + f64)
+float(i32 + i64)
 float(i32 / 1)
-float(i32 / 1) > f64
-float(i32 / i)
-float(i32 ^ 1)
+float(i32 / f32)
+float(i32 / i32)
 float(i32 ^ f64)
-float(i32 ^ i)
+float(i32 ^ i32)
 float(i32)
 float(i32) != f64
-float(i32) * i64
-float(i32) + i
-float(i32) + i64
-float(i32) - i64
-float(i32) / i
-float(i32) / i32
-float(i32) < -0.5
-float(i32) == f32
-float(i32) == i32
-float(i32) > f32
+float(i32) ** f32
+float(i32) ** i
 float(i32) > i32
-float(i32) >= f32
-float(i32) >= f64
-float(i32) ^ f32
-float(i32) ^ f64
-float(i32) ^ i32
-float(i64 % i)
-float(i64 % i32)
-float(i64 * 0.5)
-float(i64 * 1)
-float(i64 ** f64)
-float(i64 ** i64)
-float(i64 + 0.5)
-float(i64 + f64)
+float(i32) >= i
+float(i64 % i64)
+float(i64 * i64)
+float(i64 ** 1)
+float(i64 + f32)
+float(i64 + i)
+float(i64 - 0.5)
 float(i64 - 1)
 float(i64 - f32)
-float(i64 - f64)
-float(i64 - i32)
-float(i64 - i64)
-float(i64 / 0.5)
 float(i64 / 1)
-float(i64 / f32)
-float(i64 ^ f64)
+float(i64 ^ f32)
 float(i64)
-float(i64) ** i
+float(i64) != i
+float(i64) ** max(f64)
+float(i64) + i32
+float(i64) - 0.5 ^ f32
+float(i64) - f64
 float(i64) / i32
-float(i64) > f64 ^ f32
-float(i64) >= i
-float(i64) >= i64
+float(i64) < i32
+float(i64) == i
+float(i64) == i64
+float(i64) > i
+float(i64) ^ f32
 float(int(0.5))
 float(int(1))
 float(int(f32))
-float(int(f64))
 float(int(i))
 float(int(i32))
-float(int(i64))
+float(last(array))
 float(len("bar"))
-float(len("foo"))
 float(len(array))
 float(len(list))
 float(max(0.5))
-float(max(0.5, i32))
+float(max(0.5, i64))
 float(max(1))
-float(max(1, i))
-float(max(1, i64))
+float(max(1, 1))
+float(max(f32))
 float(max(f64))
 float(max(i))
 float(max(i32))
 float(max(i64))
-float(min(0.5))
+float(mean(array))
 float(min(1))
-float(min(f32))
 float(min(f64))
-float(min(i))
+float(min(f64, i64))
 float(min(i32))
 float(min(i64))
-float(ok ? f64 : half)
-float(ok ? i : greet)
+float(ok ? 0.5 : foo)
+float(ok ? 0.5 : list)
+float(reduce(array, #))
+float(reduce(array, 0.5))
+float(reduce(array, f64))
+float(reduce(array, i32))
+float(reduce(list, i64))
+float(round(0.5))
+float(round(1))
+float(round(i32))
+float(round(i64))
 float(score(1))
+float(score(1, 1))
 float(score(i))
-float(score(i, i)) <= f32
-float(score(score(i)))
 float(string(0.5))
 float(string(1))
-float(string(f32))
-float(string(f64))
+float(string(f64 - 0.5))
 float(string(i))
+float(string(i32))
 float(string(i64))
+float(sum(array))
 float(toJSON(0.5))
 float(toJSON(1))
 float(toJSON(f32))
 float(toJSON(f64))
-float(toJSON(i))
 float(toJSON(i32))
-float(true ? 1 : div)
-float(true ? 1 : i64)
-float(true ? f64 : div)
+float(toJSON(i64))
+float(true ? f32 : "foo")
+floor(-0.5)
+floor(-1)
+floor(-f32)
+floor(-f64)
+floor(-i)
+floor(-i32)
+floor(-i64)
+floor(0.5 * 0.5)
+floor(0.5 * 1)
+floor(0.5 * i32)
+floor(0.5 ** 1)
+floor(0.5 ** f64)
+floor(0.5 ** i)
+floor(0.5 + 1)
+floor(0.5 + f32)
+floor(0.5 + i)
+floor(0.5 + i32)
+floor(0.5 + i64)
+floor(0.5 - 1)
+floor(0.5 - f32)
+floor(0.5 - i)
+floor(0.5 / 0.5)
+floor(0.5 / 1)
+floor(0.5 / i32)
+floor(0.5 ^ 0.5)
+floor(0.5 ^ 1)
+floor(0.5 ^ f32)
+floor(0.5 ^ f64)
+floor(0.5 ^ i)
+floor(0.5) != i64
+floor(0.5) ** f32
+floor(0.5) - i
+floor(0.5) - i64
+floor(0.5) / i
+floor(0.5) <= i64
+floor(0.5) > i32
+floor(0.5) > i64 != ok
+floor(0.5) >= f32
+floor(0.5) ^ i
+floor(1 % 1)
+floor(1 % i)
+floor(1 * 0.5)
+floor(1 * 1)
+floor(1 ** 1)
+floor(1 ** f64)
+floor(1 ** i32)
+floor(1 + 0.5)
+floor(1 + 1)
+floor(1 + f32)
+floor(1 + f64)
+floor(1 + i32)
+floor(1 - 0.5)
+floor(1 - 1)
+floor(1 - i)
+floor(1 - i32)
+floor(1 - i64)
+floor(1 / 0.5)
+floor(1 / 1)
+floor(1 / i)
+floor(1 / i64)
+floor(1 ^ i)
+floor(1 ^ i32)
+floor(1 ^ i64)
+floor(1) * i64
+floor(1) - f32
+floor(1) - i
+floor(1) <= f32
+floor(1) >= half(0.5)
+floor(abs(0.5))
+floor(abs(1))
+floor(abs(f32))
+floor(abs(f64))
+floor(abs(i32))
+floor(abs(i64))
+floor(array[1])
+floor(array[i32])
+floor(array[i64])
+floor(array[i])
+floor(bitnot(1))
+floor(bitnot(i))
+floor(bitnot(i32))
+floor(bitnot(i64))
+floor(ceil(0.5))
+floor(ceil(1))
+floor(ceil(f64))
+floor(ceil(i))
+floor(ceil(i32))
+floor(ceil(i64))
+floor(count(array, false))
+floor(count(array, ok))
+floor(count(list, ok))
+floor(f32 ** 1)
+floor(f32 ** f64)
+floor(f32 ** i32)
+floor(f32 + f32)
+floor(f32 + i32)
+floor(f32 + i64)
+floor(f32 - 0.5)
+floor(f32 - f64)
+floor(f32 / 0.5)
+floor(f32 / f64)
+floor(f32 / i)
+floor(f32 / i32)
+floor(f32 / i64)
+floor(f32 ^ 0.5)
+floor(f32 ^ f64)
+floor(f32 ^ i)
+floor(f32)
+floor(f32) != -i32
+floor(f32) * i32
+floor(f32) + f32
+floor(f32) / f32
+floor(f32) / f64
+floor(f32) == i64
+floor(f32) > i32
+floor(f32) >= f32
+floor(f32) >= i
+floor(f32) ^ f32
+floor(f64 * f32)
+floor(f64 ** 0.5)
+floor(f64 ** 1)
+floor(f64 ** i32)
+floor(f64 + 0.5)
+floor(f64 + 1)
+floor(f64 + i32)
+floor(f64 - 0.5)
+floor(f64 - i32)
+floor(f64 / 0.5)
+floor(f64 / 1)
+floor(f64 / f32)
+floor(f64 / f64)
+floor(f64 / i)
+floor(f64 ^ 1)
+floor(f64)
+floor(f64) * i32
+floor(f64) ** f64
+floor(f64) / f32
+floor(f64) < i32
+floor(f64) <= f64
+floor(f64) <= i64
+floor(f64) == f64 ** i
+floor(f64) == i
+floor(f64) > i32
+floor(f64) >= 1 * 1
+floor(f64) >= f32
+floor(false ? div : 0.5)
+floor(find(array, true))
+floor(findIndex(array, ok))
+floor(findLastIndex(array, ok))
+floor(float(0.5))
+floor(float(1))
+floor(float(f64))
+floor(float(i32))
+floor(floor(0.5))
+floor(floor(1))
+floor(floor(f32))
+floor(floor(f64))
+floor(floor(i))
+floor(floor(i32))
+floor(floor(i64))
+floor(get(array, 1))
+floor(get(array, i))
+floor(get(array, i64))
+floor(half(0.5))
+floor(half(1))
+floor(half(f64))
+floor(i % 1)
+floor(i % i)
+floor(i % i32)
+floor(i % i64)
+floor(i * 1)
+floor(i * f64)
+floor(i ** 0.5)
+floor(i ** f32)
+floor(i ** i32)
+floor(i ** i64)
+floor(i + 0.5)
+floor(i + f64)
+floor(i - 0.5)
+floor(i - f32)
+floor(i - i32)
+floor(i / 0.5)
+floor(i / 1)
+floor(i / f64)
+floor(i ^ i32)
+floor(i)
+floor(i) != i
+floor(i) * f64
+floor(i) ^ i
+floor(i32 % i32)
+floor(i32 * 1)
+floor(i32 * f32)
+floor(i32 * f64)
+floor(i32 * i32)
+floor(i32 ** i)
+floor(i32 ** i64)
+floor(i32 + 0.5)
+floor(i32 + f64)
+floor(i32 - 1)
+floor(i32 - f32)
+floor(i32 - i)
+floor(i32 - i32)
+floor(i32 - i64)
+floor(i32 ^ 0.5)
+floor(i32 ^ 1)
+floor(i32 ^ f64)
+floor(i32 ^ i)
+floor(i32 ^ i32)
+floor(i32 ^ i64)
+floor(i32)
+floor(i32) != f32
+floor(i32) * f64
+floor(i32) * i
+floor(i32) * i64
+floor(i32) > i32
+floor(i32) > i64
+floor(i32) >= i32
+floor(i32) ^ i32
+floor(i64 % i)
+floor(i64 * 0.5)
+floor(i64 * f32)
+floor(i64 * i)
+floor(i64 ** 0.5)
+floor(i64 ** 1)
+floor(i64 ** i)
+floor(i64 ** i32)
+floor(i64 + 0.5)
+floor(i64 + f64)
+floor(i64 + i64)
+floor(i64 - f64)
+floor(i64 - i)
+floor(i64 / f32)
+floor(i64 ^ 0.5)
+floor(i64 ^ f32)
+floor(i64 ^ i64)
+floor(i64)
+floor(i64) * i64
+floor(i64) / (i64 - i)
+floor(i64) / f64
+floor(i64) / i32
+floor(i64) < f32
+floor(i64) <= i64
+floor(i64) ^ f32
+floor(int(0.5))
+floor(int(1))
+floor(int(i32))
+floor(int(i64))
+floor(len("foo"))
+floor(len(array))
+floor(len(list))
+floor(max(0.5))
+floor(max(1))
+floor(max(f32))
+floor(max(f64))
+floor(max(i32))
+floor(min(0.5))
+floor(min(f64) ^ i64)
+floor(min(i, i64))
+floor(min(i32))
+floor(ok ? 1 : 1)
+floor(ok ? f32 : "foo")
+floor(ok ? i64 : f64)
+floor(reduce(array, #))
+floor(reduce(array, i))
+floor(reduce(array, i64))
+floor(reduce(list, 1))
+floor(reduce(list, f32))
+floor(reduce(list, i64))
+floor(round(0.5))
+floor(round(f32))
+floor(round(f64))
+floor(round(i))
+floor(round(i32))
+floor(score(1))
+floor(score(1, 1))
+floor(score(i))
+floor(true ? 0.5 : false)
+floor(true ? 1 : true)
+floor(true ? f64 : 0.5)
+floor(true ? f64 : array)
 foo
-foo != first(list)
 foo != foo
-foo != foo ? 1 : 1
-foo != get(list, i)
-foo != last(list)
-foo != nil ? half : nil
+foo != nil != nil
+foo != reduce(list, #)
 foo == foo
-foo == foo ? i : score
-foo == last(list)
-foo == nil == nil
-foo == nil || ok
+foo == foo and 0.5 != f64
+foo == get(list, 1)
+foo == list[i]
+foo == nil ? i : i32
+foo == nil ? i64 : i
+foo == reduce(list, #)
 foo in filter(list, false)
+foo in groupBy(array, #)
+foo in groupBy(list, #)
 foo in list
-foo in list ? nil : i32
-foo in map(list, #)
+foo in list != ok
+foo not in groupBy(array, #)
+foo not in groupBy(array, f64).foo
+foo not in groupBy(list, #).i
+foo not in groupBy(list, f32)
+foo not in groupBy(list, ok)
 foo not in list
+foo not in list and ok
+foo not in list or false
+foo not in map(list, #)
 foo.Bar
-foo.Bar != string(i64)
-foo.Bar + type(greet)
-foo.Bar < toJSON(0.5)
-foo.Bar == type(0.5)
-foo.Bar not matches string(half)
-foo.Bar not startsWith foo.String()
+foo.Bar <= foo.Bar
+foo.Bar matches foo.Bar
+foo.Bar matches trimPrefix("foo")
 foo.Qux
-foo.Qux != add
+foo.Qux != greet
 foo.Qux != half
-foo.Qux != score
+foo.Qux == add
 foo.Qux == div
-foo.Qux == foo?.Qux
-foo.Qux(foo?.String())
-foo.Qux(greet("bar"))
-foo.Qux(toJSON(0.5))
+foo.Qux == greet
+foo.Qux == half
+foo.Qux == score
+foo.Qux("foo" + "foo")
+foo.Qux(foo.Bar)
+foo.Qux(foo.String())
+foo.Qux(greet("foo"))
+foo.Qux(string("foo"))
 foo.Qux(toJSON(i))
-foo.Qux(toJSON(nil))
-foo.Qux(trimSuffix("foo"))
 foo.Qux(type("bar"))
-foo.Qux(type(i))
+foo.Qux(type(f64))
+foo.Qux(type(half))
 foo.String
 foo.String != div
+foo.String != greet
+foo.String != half
 foo.String == add
-foo.String == greet
+foo.String == div
 foo.String == half
-foo.String == score
 foo.String()
+foo.String() != foo?.String()
+foo.String() in foo
+foo.String() not in foo
 foo?.Bar
-foo?.Bar + type(score)
+foo?.Bar != foo?.Bar
 foo?.Bar in foo
-foo?.Bar not endsWith "bar" ? score : array
+foo?.Bar matches toJSON(f64)
+foo?.Bar not endsWith foo.Bar
+foo?.Bar not endsWith toJSON(foo)
 foo?.Qux
-foo?.Qux != div
+foo?.Qux != add
 foo?.Qux != greet
 foo?.Qux != half
 foo?.Qux != score
 foo?.Qux == add
+foo?.Qux == div
 foo?.Qux == greet
 foo?.Qux == half
 foo?.Qux == score
 foo?.Qux(foo?.Bar)
-foo?.Qux(string(0.5))
-foo?.Qux(type(0.5))
+foo?.Qux(string(i32))
+foo?.Qux(toJSON(1))
+foo?.Qux(toJSON(i32))
 foo?.Qux(upper("bar"))
 foo?.String
-foo?.String != div
 foo?.String != greet
 foo?.String != half
-foo?.String != nil ? half : list
 foo?.String != score
-foo?.String == add
+foo?.String == greet
 foo?.String == half
+foo?.String == score
 foo?.String()
-foo?.String() + type(list)
-foo?.String() < string(i32)
-foo?.String() < toJSON(nil)
-foo?.String() matches toBase64("bar")
+foo?.String() contains string("foo")
 fromBase64(string(ok))
-fromBase64(string(true))
-fromBase64(toBase64("foo"))
-fromBase64(toBase64(toJSON(nil)))
-fromBase64(toJSON(nil))
-fromBase64(toJSON(ok))
-fromBase64(toJSON(true))
+fromBase64(toBase64("bar"))
+fromBase64(type(1 == 0.5))
 fromBase64(type(add))
 fromBase64(type(div))
 fromBase64(type(false))
 fromBase64(type(greet))
 fromBase64(type(half))
-fromBase64(type(nil == score))
 fromBase64(type(ok))
 fromBase64(type(score))
 fromBase64(type(true))
-fromJSON("foo") not in list && false
-fromJSON(string(0.5))
 fromJSON(string(1))
 fromJSON(string(f32))
 fromJSON(string(f64))
-fromJSON(string(false))
 fromJSON(string(i))
 fromJSON(string(i32))
 fromJSON(string(i64))
-fromJSON(string(i64)) ** f64
 fromJSON(string(ok))
 fromJSON(string(true))
-fromJSON(toJSON("foo"))
-fromJSON(toJSON(0.5 ** 0.5))
-fromJSON(toJSON(1))
-fromJSON(toJSON(abs(1)))
+fromJSON(toJSON("bar"))
+fromJSON(toJSON(0.5))
 fromJSON(toJSON(array))
-fromJSON(toJSON(f32))
 fromJSON(toJSON(f64))
+fromJSON(toJSON(false))
+fromJSON(toJSON(foo))
 fromJSON(toJSON(i))
 fromJSON(toJSON(i32))
-fromJSON(toJSON(i64))
 fromJSON(toJSON(list))
 fromJSON(toJSON(nil))
-fromJSON(toJSON(ok))
 fromJSON(toJSON(true))
-get(1 .. i32, i)
-get(1 .. i64, abs(1))
-get(1 .. i64, i)
-get(1 .. i64, i32)
-get(["bar"], i64)
-get([array], i)
-get([greet], i)
-get([nil, half], i)
-get([score, 0.5, score], i64)
+fromPairs(filter(array, false))
+fromPairs(filter(list, false))
+fromPairs(groupBy(array, #)?.String)
+get(["foo"], i32)
 get(array, -1)
-get(array, -i)
 get(array, -i32)
-get(array, 1 % 1)
-get(array, 1 % i64)
-get(array, 1 - 1)
-get(array, 1 - i)
-get(array, 1) * f64
+get(array, -i64)
+get(array, -score(1))
+get(array, 1 * 1)
+get(array, 1 * i)
+get(array, 1) ** f32
 get(array, 1) < f32
-get(array, 1) <= i32
-get(array, 1) > i
-get(array, 1) ^ f64
-get(array, 1) ^ i
-get(array, array[1])
-get(array, count(list, true))
-get(array, false ? div : false)
-get(array, first(array))
-get(array, i % i64)
-get(array, i * 1)
+get(array, 1) > i32
+get(array, 1) > i64
+get(array, bitnot(1))
+get(array, count(array, ok))
+get(array, false ? "foo" : 0.5)
 get(array, i)
-get(array, i) + i
-get(array, i) > i32
-get(array, i) ^ f32
-get(array, i32 * i64)
+get(array, i) != f32
+get(array, i) != i32
+get(array, i) * i32
+get(array, i) - i
+get(array, i) / i64
+get(array, i) > f64
+get(array, i) >= f64
+get(array, i) >= i64
+get(array, i) ^ half(0.5)
+get(array, i32 % i32)
 get(array, i32)
-get(array, i32) ** f32
-get(array, i32) == i32
-get(array, i32) > f64
+get(array, i32) / f64
+get(array, i32) < i
+get(array, i64 - 1)
 get(array, i64)
-get(array, i64) ** i
-get(array, i64) ** i64
-get(array, i64) .. i32
-get(array, i64) <= -i32
-get(array, i64) <= f64 / f32
-get(array, i64) <= i
-get(array, i64) == i64
-get(array, int(1))
-get(array, int(f32))
-get(array, int(f64))
-get(array, int(i32))
-get(array, len(array))
-get(array, max(1))
+get(array, i64) > f64
+get(array, last(array))
 get(array, min(i))
-get(array, min(i32))
+get(array, reduce(array, #))
+get(array, reduce(list, i64))
 get(array, score(1))
-get(array, true ? i : 1)
-get(false ? "bar" : f64, list)
-get(false ? "bar" : i32, greet)
-get(false ? "foo" : i, ok)
-get(false ? 0.5 : i64, true not in String)
-get(false ? 1 : greet, ok)
-get(false ? div : true, min("foo"))
-get(false ? greet : score, score)
-get(false ? half : list, i32)
-get(false ? list : 1, i32)
-get(false ? list : i64, i >= f64)
-get(false ? score : 0.5, add)
-get(false ? score : 0.5, half)
-get(false ? score : f64, half)
-get(filter(list, ok), i32)
-get(filter(list, ok), i64)
-get(i .. i, i)
-get(i32 .. 1, i)
+get(array, score(abs(1)))
+get(array, score(i))
+get(array, sum(array))
+get(false ? 0.5 : greet, list)
+get(false ? add : array, f64)
+get(false ? add : score, ok)
+get(false ? f64 : 1, ok)
+get(false ? f64 : score, add)
+get(false ? false : f32, i)
+get(false ? i32 : list, i64)
+get(false ? i32 : ok, now(div, array))
+get(false ? i64 : foo, Bar)
+get(false ? i64 : true, f64)
+get(false ? score : ok, trimSuffix("bar", "bar"))
+get(filter(list, true), i)
+get(groupBy(array, "bar"), add)
+get(groupBy(array, "bar"), i)
+get(groupBy(array, "bar"), ok)
+get(groupBy(array, "foo"), half)
+get(groupBy(array, #), add)
+get(groupBy(array, #), array)
+get(groupBy(array, #), f32)
+get(groupBy(array, #), f64)
+get(groupBy(array, #), foo)
+get(groupBy(array, #), greet)
+get(groupBy(array, #), half)
+get(groupBy(array, #), i)
+get(groupBy(array, #), i64 * 0.5)
+get(groupBy(array, #), i64)
+get(groupBy(array, #)?.String, i64)
+get(groupBy(array, 0.5), add)
+get(groupBy(array, 0.5), div)
+get(groupBy(array, 0.5), ok)
+get(groupBy(array, 1), add)
+get(groupBy(array, 1), f32)
+get(groupBy(array, f64), i64)
+get(groupBy(array, false), findIndex(array, ok))
+get(groupBy(array, i), ok)
+get(groupBy(array, i), score)
+get(groupBy(array, i64), add)
+get(groupBy(array, ok), add)
+get(groupBy(array, true), i32)
+get(groupBy(list, "bar"), i32)
+get(groupBy(list, "foo"), greet)
+get(groupBy(list, #), div)
+get(groupBy(list, #), f32 <= f64)
+get(groupBy(list, #), f32)
+get(groupBy(list, #), foo)
+get(groupBy(list, #), greet)
+get(groupBy(list, #), half)
+get(groupBy(list, #), i)
+get(groupBy(list, #), i32)
+get(groupBy(list, #), i64)
+get(groupBy(list, #), int(f32))
+get(groupBy(list, #), list)
+get(groupBy(list, #), reduce(array, foo))
+get(groupBy(list, #), score(1))
+get(groupBy(list, #), score)
+get(groupBy(list, 0.5), array)
+get(groupBy(list, 0.5), div)
+get(groupBy(list, 0.5), ok)
+get(groupBy(list, 1), i32)
+get(groupBy(list, f32), greet)
+get(groupBy(list, foo), add)
+get(groupBy(list, foo), i32)
+get(groupBy(list, ok), greet)
+get(groupBy(list, ok), list)
+get(i .. 1, 1 * 1)
+get(i .. i32, i)
+get(i32 .. i, i64)
 get(i64 .. 1, i32)
+get(i64 .. i, i32)
+get(i64 .. i64, i64)
+get(list, -1)
 get(list, -i)
-get(list, -i32)
 get(list, -i64)
-get(list, 1 * i)
+get(list, 1 * 1)
+get(list, 1 - 1)
+get(list, 1 - i)
+get(list, 1) != foo
 get(list, 1).Bar
 get(list, 1).Qux
 get(list, 1).String
@@ -6290,11 +7333,12 @@ get(list, 1)?.Bar
 get(list, 1)?.Qux
 get(list, 1)?.String
 get(list, 1)?.String()
-get(list, abs(i))
-get(list, abs(i32))
+get(list, bitshr(i, i32))
+get(list, first(array))
+get(list, get(array, 1))
+get(list, get(array, i64))
+get(list, i % 1)
 get(list, i)
-get(list, i) != foo
-get(list, i) == foo
 get(list, i).Bar
 get(list, i).Qux
 get(list, i).String
@@ -6302,129 +7346,153 @@ get(list, i)?.Bar
 get(list, i)?.Qux
 get(list, i)?.String
 get(list, i)?.String()
+get(list, i32 * i32)
+get(list, i32 - i32)
 get(list, i32)
 get(list, i32).Bar
 get(list, i32).Qux
 get(list, i32).String
-get(list, i32).String()
 get(list, i32)?.Bar
 get(list, i32)?.Qux
 get(list, i32)?.String
 get(list, i32)?.String()
-get(list, i64 * i32)
+get(list, i64 * 1)
+get(list, i64 * i)
+get(list, i64 - 1)
 get(list, i64)
 get(list, i64).Bar
 get(list, i64).Qux
 get(list, i64).String
-get(list, i64).String()
 get(list, i64)?.Bar
 get(list, i64)?.Qux
 get(list, i64)?.String
 get(list, i64)?.String()
-get(list, int(1) > 0.5 ? div : 0.5)
-get(list, int(i))
-get(list, int(i32))
-get(list, int(i64))
-get(list, last(array))
-get(list, max(1, i64, i64))
+get(list, int(1))
+get(list, max(i32))
 get(list, min(i32))
 get(list, min(i64))
+get(list, ok ? 0.5 : "foo")
+get(list, ok ? array : "foo")
+get(list, reduce(list, i64))
 get(list, score(1))
-get(list[i32:i], i64)
+get(list, score(i))
+get(list, true ? i : i32)
+get(list, {"foo": i32}?.i)
+get(list[i64:1], i)
 get(map(array, #), i)
+get(map(array, #), i32)
 get(map(array, #), i64)
-get(map(array, #), last(array))
-get(map(array, 0.5), i)
-get(map(array, 1), i)
-get(map(array, i32), i64)
-get(map(array, ok), i)
-get(map(array, ok), i64)
+get(map(array, add), i32)
+get(map(array, array), i)
+get(map(array, greet), i64)
+get(map(array, half), i64)
+get(map(list, "foo"), i64)
 get(map(list, #), i)
-get(map(list, #), i32)
 get(map(list, #), i64)
-get(map(list, 0.5), i64)
+get(map(list, 1), i32)
 get(map(list, array), i)
-get(map(list, div), i32)
 get(map(list, i32), i64)
-get(map(list, ok), i32)
-get(map(list, true), i64)
-get(ok ? 0.5 : add, f32)
-get(ok ? add : 0.5, ok)
-get(ok ? add : false, div)
-get(ok ? array : 0.5, Bar)
-get(ok ? array : i, add)
-get(ok ? div : foo, filter("bar", ok))
-get(ok ? greet : 0.5, foo in String)
-get(ok ? greet : f32, Bar)
-get(ok ? i : f64, greet)?.f64
-get(ok ? i32 : "foo", score)
-get(ok ? i32 : add, div)
-get(ok ? list : "foo", f32)
-get(ok ? ok : half, array)
-get(ok ? true : i32, f32)
+get(map(list, i64), i64)
+get(ok ? "bar" : false, array)
+get(ok ? 1 : "bar", f32)
+get(ok ? 1 : add, String)
+get(ok ? add : f32, array)
+get(ok ? array : i, Bar)
+get(ok ? f32 : list, get(half, nil))
+get(ok ? f64 : div, i64)
+get(ok ? f64 : list, half in Bar)?.array()
+get(ok ? false : list, f32 > i)
+get(ok ? foo : 0.5, div)
+get(ok ? greet : "bar", get(add, String))
+get(ok ? half : i32, i)
+get(ok ? half : ok, f64)
+get(ok ? i : 0.5, half)
+get(ok ? i : half, String)
+get(ok ? i32 : half, f64)
+get(ok ? i64 : foo, f32)
+get(ok ? list : "foo", add)
+get(ok ? list : i32, f32)
+get(ok ? ok : div, greet)
+get(ok ? score : 1, Qux?.i)
+get(ok ? score : f64, i)
+get(ok ? score : foo, String?.foo())
+get(ok ? score : i64, foo)
+get(reduce(list, array), i32)
 get(sort(array), i32)
-get(true ? 0.5 : score, foo)
-get(true ? 1 : f64, foo)
-get(true ? 1 : greet, greet)?.foo
-get(true ? 1 : score, String?.Qux())
-get(true ? add : score, i)
-get(true ? array : 1, half)
-get(true ? array : i64, ok)
-get(true ? div : foo, list)
-get(true ? f32 : 1, greet)
-get(true ? f64 : greet, String)
-get(true ? f64 : ok, Bar?.ok)
-get(true ? i : f64, add)
-get(true ? i64 : score, i)
-get(true ? list : ok, ok)
-get({"bar": i32}.i32, ok)
+get(sum(array), Qux)
+get(sum(array), String)
+get(sum(array), f32)
+get(sum(array), f64 == list)
+get(sum(array), greet)
+get(sum(array), i)
+get(take(list, i), i64)
+get(true ? "bar" : ok, score(i))
+get(true ? "foo" : half, list)
+get(true ? 0.5 : i32, array)
+get(true ? 1 : array, Bar)?.f64
+get(true ? f32 : 0.5, ok)
+get(true ? false : foo, i64 > 0.5)
+get(true ? greet : false, Bar)
+get(true ? greet : i32, score)
+get(true ? half : 0.5, Qux)
+get(true ? half : f32, greet)
+get(true ? half : list, add)
+get(true ? i64 : greet, i32)
+get(true ? score : true, half)?.half
+get(true ? true : add, Qux)
+get(true ? true : i, f64)
+get({"bar": true, "foo": greet}.i, String)
+get({"foo": foo, "bar": false}, type(i))
 greet
 greet != add
 greet != div
-greet != div != nil
+greet != div and ok
 greet != foo.Qux
 greet != foo.String
 greet != foo?.Qux
 greet != foo?.String
 greet != greet
-greet != greet != nil
-greet != greet or 0.5 == i
+greet != greet != ok
 greet != half
-greet != half ? 1 : ok
-greet != half ? array : 0.5
-greet != half ? false : f64
-greet != half ? greet : greet
-greet != nil ? i64 : 0.5
+greet != nil ? "bar" : add
+greet != nil ? 0.5 : false
+greet != nil ? list : false
 greet != score
+greet != score != false
+greet != score or ok
+greet != sum(array)
 greet == add
-greet == add == ok
-greet == add ? div == greet : i64
+greet == add ? i : list
+greet == add or ok
 greet == div
-greet == div ? add : i32
+greet == div || ok
 greet == foo.Qux
 greet == foo.String
 greet == foo?.Qux
 greet == foo?.String
 greet == greet
+greet == greet ? 0.5 : "bar"
+greet == greet and ok
 greet == half
-greet == nil != nil
-greet == nil && ok
+greet == half ? 1 : ok
 greet == nil == ok
+greet == nil ? i64 : ok
+greet == reduce(list, div)
+greet == reduce(list, half)
 greet == score
-greet in [nil]
+greet == score ? 1 : ok
+greet == score ? add : nil
+greet in groupBy(array, f64).f32
+greet in groupBy(list, #).score
+greet not in map(array, score)
+greet not in map(list, div)
+greet not in sort(array)
 greet("bar" + "bar")
-greet("bar" + "foo")
-greet("bar") != foo.String()
-greet("bar") != nil != false
-greet("bar") in foo
-greet("foo" + "bar")
 greet("foo" + "foo")
-greet("foo") >= string(foo)
-greet("foo") not contains "bar" ? array : half
-greet("foo") startsWith greet("bar")
-greet(false ? f32 : "foo")
-greet(false ? i : "bar")
+greet("foo") startsWith type(f64)
+greet(false ? i64 : "bar")
 greet(foo.Bar)
+greet(foo.Qux("foo"))
 greet(foo.String())
 greet(foo?.Bar)
 greet(foo?.String())
@@ -6432,14 +7500,20 @@ greet(greet("bar"))
 greet(greet("foo"))
 greet(lower("bar"))
 greet(lower("foo"))
-greet(ok ? "bar" : div)
+greet(ok ? "bar" : 1)
+greet(ok ? "bar" : i64)
+greet(ok ? "foo" : 0.5)
+greet(ok ? "foo" : div)
+greet(ok ? "foo" : true)
+greet(reduce(array, "bar"))
+greet(reduce(array, "foo"))
+greet(reduce(list, "foo"))
+greet(repeat("bar", 1))
+greet(repeat(foo?.String(), i32))
 greet(string("bar"))
 greet(string("foo"))
-greet(string(-i64))
-greet(string(0.5 == 1))
 greet(string(0.5))
 greet(string(1))
-greet(string([0.5]))
 greet(string(add))
 greet(string(array))
 greet(string(div))
@@ -6447,20 +7521,18 @@ greet(string(f32))
 greet(string(f64))
 greet(string(false))
 greet(string(foo))
-greet(string(foo?.Qux))
 greet(string(greet))
 greet(string(half))
 greet(string(i))
 greet(string(i32))
 greet(string(i64))
 greet(string(list))
-greet(string(nil != false))
 greet(string(nil))
 greet(string(ok))
 greet(string(score))
 greet(string(true))
 greet(toBase64("bar"))
-greet(toBase64("foo"))
+greet(toBase64(trimPrefix("bar")))
 greet(toJSON("bar"))
 greet(toJSON("foo"))
 greet(toJSON(0.5))
@@ -6476,27 +7548,26 @@ greet(toJSON(i64))
 greet(toJSON(list))
 greet(toJSON(nil))
 greet(toJSON(ok))
-greet(toJSON(string(array)))
 greet(toJSON(true))
 greet(trim("bar"))
 greet(trim("foo"))
-greet(trim(string(array)))
 greet(trimPrefix("bar"))
 greet(trimPrefix("foo"))
 greet(trimSuffix("bar"))
 greet(trimSuffix("foo"))
-greet(trimSuffix("foo", "foo"))
-greet(true ? "foo" : 0.5)
+greet(trimSuffix(foo.String()))
+greet(trimSuffix(foo?.Bar))
+greet(true ? "bar" : i64)
+greet(true ? "bar" : ok)
+greet(true ? "foo" : foo)
 greet(type("bar"))
 greet(type("foo"))
 greet(type(0.5))
 greet(type(1))
-greet(type(abs(f32)))
 greet(type(add))
 greet(type(array))
 greet(type(div))
 greet(type(f32))
-greet(type(f64 / i))
 greet(type(f64))
 greet(type(false))
 greet(type(foo))
@@ -6512,46 +7583,1583 @@ greet(type(score))
 greet(type(true))
 greet(upper("bar"))
 greet(upper("foo"))
+groupBy(1 .. 1, #).f64
+groupBy(1 .. i, #)
+groupBy(1 .. i, i32)?.score
+groupBy(1 .. i32, #)
+groupBy(1 .. i32, ok)
+groupBy(1 .. i64, i32)
+groupBy([0.5, f64], nil == "foo")
+groupBy([1], # <= #)
+groupBy([f32 ^ i64], #)
+groupBy([f32], f64)
+groupBy([f64], # >= f32)
+groupBy([half], f32)
+groupBy([i32], array[#])
+groupBy([nil], foo)
+groupBy([true], #)
+groupBy(array, !false)
+groupBy(array, !true)
+groupBy(array, "bar" in foo).String
+groupBy(array, "bar").Bar
+groupBy(array, "bar").Qux
+groupBy(array, "bar").String
+groupBy(array, "bar").add
+groupBy(array, "bar").array
+groupBy(array, "bar").div
+groupBy(array, "bar").f32
+groupBy(array, "bar").f64
+groupBy(array, "bar").foo
+groupBy(array, "bar").greet
+groupBy(array, "bar").half
+groupBy(array, "bar").i
+groupBy(array, "bar").i32
+groupBy(array, "bar").i64
+groupBy(array, "bar").list
+groupBy(array, "bar").ok
+groupBy(array, "bar").score
+groupBy(array, "bar")?.Bar
+groupBy(array, "bar")?.Qux
+groupBy(array, "bar")?.String
+groupBy(array, "bar")?.add
+groupBy(array, "bar")?.array
+groupBy(array, "bar")?.div
+groupBy(array, "bar")?.f32
+groupBy(array, "bar")?.f64
+groupBy(array, "bar")?.foo
+groupBy(array, "bar")?.greet
+groupBy(array, "bar")?.half
+groupBy(array, "bar")?.i
+groupBy(array, "bar")?.i64
+groupBy(array, "bar")?.list
+groupBy(array, "bar")?.ok
+groupBy(array, "bar")?.score
+groupBy(array, "bar")[f32 > f32]
+groupBy(array, "foo").Bar
+groupBy(array, "foo").Qux
+groupBy(array, "foo").String
+groupBy(array, "foo").add
+groupBy(array, "foo").array
+groupBy(array, "foo").div
+groupBy(array, "foo").f32
+groupBy(array, "foo").f64
+groupBy(array, "foo").foo
+groupBy(array, "foo").greet
+groupBy(array, "foo").half
+groupBy(array, "foo").i
+groupBy(array, "foo").i32
+groupBy(array, "foo").i64
+groupBy(array, "foo").list
+groupBy(array, "foo").ok
+groupBy(array, "foo").score
+groupBy(array, "foo")?.Bar
+groupBy(array, "foo")?.String
+groupBy(array, "foo")?.add
+groupBy(array, "foo")?.array
+groupBy(array, "foo")?.div
+groupBy(array, "foo")?.f32
+groupBy(array, "foo")?.f64
+groupBy(array, "foo")?.foo
+groupBy(array, "foo")?.greet
+groupBy(array, "foo")?.half
+groupBy(array, "foo")?.i
+groupBy(array, "foo")?.i32
+groupBy(array, "foo")?.i64
+groupBy(array, "foo")?.list
+groupBy(array, "foo")?.ok
+groupBy(array, "foo")?.score
+groupBy(array, # != #)
+groupBy(array, # != #).Qux
+groupBy(array, # != #)?.array
+groupBy(array, # != 0.5)
+groupBy(array, # != 1)
+groupBy(array, # != f32)
+groupBy(array, # != f64)
+groupBy(array, # != f64)?.String
+groupBy(array, # != i64)
+groupBy(array, # != nil)
+groupBy(array, # % #)
+groupBy(array, # % 1)
+groupBy(array, # % i32)
+groupBy(array, # * #)
+groupBy(array, # * #)?.Qux
+groupBy(array, # * 0.5)
+groupBy(array, # * 1)
+groupBy(array, # * i)
+groupBy(array, # * i32)
+groupBy(array, # * i64)
+groupBy(array, # ** #)
+groupBy(array, # ** #).add
+groupBy(array, # ** 0.5)
+groupBy(array, # ** 0.5)?.foo
+groupBy(array, # ** 0.5)?.greet
+groupBy(array, # ** 1)
+groupBy(array, # ** f64)
+groupBy(array, # ** i)
+groupBy(array, # ** i32)
+groupBy(array, # ** i64)
+groupBy(array, # + #)
+groupBy(array, # + 1)
+groupBy(array, # + f32)
+groupBy(array, # + i)
+groupBy(array, # - #)
+groupBy(array, # - 0.5)
+groupBy(array, # - 1)
+groupBy(array, # - f32)
+groupBy(array, # - f64)
+groupBy(array, # - i)
+groupBy(array, # - i32)
+groupBy(array, # / #)
+groupBy(array, # / 0.5)
+groupBy(array, # / 0.5)?.foo
+groupBy(array, # / 1)
+groupBy(array, # / i)
+groupBy(array, # / i32)
+groupBy(array, # / i64)
+groupBy(array, # < # || 0.5 > f64)
+groupBy(array, # < #)
+groupBy(array, # < 0.5)
+groupBy(array, # < 1)
+groupBy(array, # < i32)
+groupBy(array, # < i64)
+groupBy(array, # <= #)
+groupBy(array, # <= #)?.Bar
+groupBy(array, # <= #)?.Qux
+groupBy(array, # <= 0.5)
+groupBy(array, # <= 1)
+groupBy(array, # <= f32)
+groupBy(array, # <= f64)
+groupBy(array, # <= i)
+groupBy(array, # <= i64)
+groupBy(array, # == #)
+groupBy(array, # == #).String
+groupBy(array, # == #)?.half
+groupBy(array, # == 0.5)
+groupBy(array, # == 1)
+groupBy(array, # == f32)
+groupBy(array, # == f32).half
+groupBy(array, # == f64)
+groupBy(array, # == i)
+groupBy(array, # == i64)
+groupBy(array, # == nil)
+groupBy(array, # > #)
+groupBy(array, # > 0.5)
+groupBy(array, # > 1)
+groupBy(array, # > 1).Bar
+groupBy(array, # > i)?.i64
+groupBy(array, # > i64)
+groupBy(array, # >= #)
+groupBy(array, # >= f64)
+groupBy(array, # >= i)
+groupBy(array, # >= i32)
+groupBy(array, # >= i64)
+groupBy(array, # ^ #)
+groupBy(array, # ^ 0.5)
+groupBy(array, # ^ f32)
+groupBy(array, # ^ i)
+groupBy(array, # ^ i32)
+groupBy(array, # in array)
+groupBy(array, #)
+groupBy(array, #).Bar
+groupBy(array, #).Qux
+groupBy(array, #).String
+groupBy(array, #).add
+groupBy(array, #).array
+groupBy(array, #).div
+groupBy(array, #).f32
+groupBy(array, #).f64
+groupBy(array, #).foo
+groupBy(array, #).greet
+groupBy(array, #).half
+groupBy(array, #).i
+groupBy(array, #).i32
+groupBy(array, #).i64
+groupBy(array, #).list
+groupBy(array, #).ok
+groupBy(array, #).score
+groupBy(array, #)?.Bar
+groupBy(array, #)?.Qux
+groupBy(array, #)?.String
+groupBy(array, #)?.add
+groupBy(array, #)?.array
+groupBy(array, #)?.div
+groupBy(array, #)?.f32
+groupBy(array, #)?.f64
+groupBy(array, #)?.foo
+groupBy(array, #)?.greet
+groupBy(array, #)?.half
+groupBy(array, #)?.i
+groupBy(array, #)?.i32
+groupBy(array, #)?.i64
+groupBy(array, #)?.list
+groupBy(array, #)?.ok
+groupBy(array, #)?.score
+groupBy(array, #)[1 / i]
+groupBy(array, #)[f32]
+groupBy(array, #)[f64]
+groupBy(array, #)[foo]
+groupBy(array, #)[i32]
+groupBy(array, #)[i64]
+groupBy(array, #)[i]
+groupBy(array, #)[ok]
+groupBy(array, #)[reduce(list, #)]
+groupBy(array, -# * # * 0.5)
+groupBy(array, -#)
+groupBy(array, -#).Qux
+groupBy(array, -0.5)
+groupBy(array, -1)
+groupBy(array, -f32)
+groupBy(array, -i)?.score
+groupBy(array, -i32)
+groupBy(array, -i64)
+groupBy(array, 0.5 != #)
+groupBy(array, 0.5 * #)
+groupBy(array, 0.5 * 0.5)
+groupBy(array, 0.5 * f64)
+groupBy(array, 0.5 ** #)
+groupBy(array, 0.5 ** 1)
+groupBy(array, 0.5 ** i64)
+groupBy(array, 0.5 + #)?.score
+groupBy(array, 0.5 + f32)
+groupBy(array, 0.5 - 1)
+groupBy(array, 0.5 / #).array
+groupBy(array, 0.5 / f64)
+groupBy(array, 0.5 / i64)
+groupBy(array, 0.5 < 0.5)
+groupBy(array, 0.5 <= f32)
+groupBy(array, 0.5 == #)
+groupBy(array, 0.5 >= #)
+groupBy(array, 0.5 >= i32)
+groupBy(array, 0.5 >= i64)
+groupBy(array, 0.5 ^ f32)
+groupBy(array, 0.5 ^ i64)
+groupBy(array, 0.5).Bar
+groupBy(array, 0.5).Qux
+groupBy(array, 0.5).String
+groupBy(array, 0.5).add
+groupBy(array, 0.5).array
+groupBy(array, 0.5).div
+groupBy(array, 0.5).f32
+groupBy(array, 0.5).f64
+groupBy(array, 0.5).foo
+groupBy(array, 0.5).greet
+groupBy(array, 0.5).half
+groupBy(array, 0.5).i
+groupBy(array, 0.5).i32
+groupBy(array, 0.5).i64
+groupBy(array, 0.5).list
+groupBy(array, 0.5).ok
+groupBy(array, 0.5).score
+groupBy(array, 0.5)?.Bar
+groupBy(array, 0.5)?.Qux
+groupBy(array, 0.5)?.String
+groupBy(array, 0.5)?.add
+groupBy(array, 0.5)?.array
+groupBy(array, 0.5)?.div
+groupBy(array, 0.5)?.f32
+groupBy(array, 0.5)?.f64
+groupBy(array, 0.5)?.foo
+groupBy(array, 0.5)?.greet
+groupBy(array, 0.5)?.half
+groupBy(array, 0.5)?.i
+groupBy(array, 0.5)?.i32
+groupBy(array, 0.5)?.i64
+groupBy(array, 0.5)?.list
+groupBy(array, 0.5)?.ok
+groupBy(array, 0.5)?.score
+groupBy(array, 1 != #)?.String
+groupBy(array, 1 != 0.5)
+groupBy(array, 1 != f32)
+groupBy(array, 1 % #)
+groupBy(array, 1 % i)
+groupBy(array, 1 * 0.5)
+groupBy(array, 1 * i)
+groupBy(array, 1 + #)
+groupBy(array, 1 + 1)
+groupBy(array, 1 - #)
+groupBy(array, 1 - 1)
+groupBy(array, 1 / #)
+groupBy(array, 1 < #)
+groupBy(array, 1 < i32)?.array
+groupBy(array, 1 < i64)?.ok
+groupBy(array, 1 <= #)
+groupBy(array, 1 == #)
+groupBy(array, 1 == #).add
+groupBy(array, 1 == i32)
+groupBy(array, 1 == nil)
+groupBy(array, 1 > i)
+groupBy(array, 1 >= #)
+groupBy(array, 1 ^ #)
+groupBy(array, 1 not in array)
+groupBy(array, 1).Bar
+groupBy(array, 1).Qux
+groupBy(array, 1).String
+groupBy(array, 1).add
+groupBy(array, 1).array
+groupBy(array, 1).div
+groupBy(array, 1).f64
+groupBy(array, 1).foo
+groupBy(array, 1).greet
+groupBy(array, 1).half
+groupBy(array, 1).i
+groupBy(array, 1).i32
+groupBy(array, 1).i64
+groupBy(array, 1).list
+groupBy(array, 1).ok
+groupBy(array, 1).score
+groupBy(array, 1)?.Bar
+groupBy(array, 1)?.Qux
+groupBy(array, 1)?.String
+groupBy(array, 1)?.add
+groupBy(array, 1)?.array
+groupBy(array, 1)?.div
+groupBy(array, 1)?.f32
+groupBy(array, 1)?.f64
+groupBy(array, 1)?.foo
+groupBy(array, 1)?.greet
+groupBy(array, 1)?.half
+groupBy(array, 1)?.i
+groupBy(array, 1)?.i32
+groupBy(array, 1)?.i64
+groupBy(array, 1)?.list
+groupBy(array, 1)?.ok
+groupBy(array, 1)?.score
+groupBy(array, abs(#))
+groupBy(array, abs(0.5))
+groupBy(array, abs(1))
+groupBy(array, abs(f32))
+groupBy(array, abs(f64))
+groupBy(array, abs(i))
+groupBy(array, abs(i64))
+groupBy(array, add(#, #))
+groupBy(array, add(#, 1))?.i64
+groupBy(array, bitnand(1, #))
+groupBy(array, bitnot(#))
+groupBy(array, bitnot(1))
+groupBy(array, bitor(#, #))
+groupBy(array, bitor(1, #))
+groupBy(array, bitor(i32, #))
+groupBy(array, bitshl(1, #))
+groupBy(array, bitshr(i, #))
+groupBy(array, bitushr(#, #))
+groupBy(array, ceil(#))
+groupBy(array, ceil(i))
+groupBy(array, ceil(i32))
+groupBy(array, div != score)
+groupBy(array, div == half)
+groupBy(array, div(#, #))
+groupBy(array, f32 != #)
+groupBy(array, f32 ** 0.5)
+groupBy(array, f32 - #)
+groupBy(array, f32 - f64)
+groupBy(array, f32 / #)
+groupBy(array, f32 < #)
+groupBy(array, f32 <= #)
+groupBy(array, f32 == #)
+groupBy(array, f32 > 0.5)
+groupBy(array, f32 > i32)
+groupBy(array, f32 ^ i)
+groupBy(array, f32)
+groupBy(array, f32).Bar
+groupBy(array, f32).Qux
+groupBy(array, f32).String
+groupBy(array, f32).add
+groupBy(array, f32).array
+groupBy(array, f32).div
+groupBy(array, f32).f64
+groupBy(array, f32).greet
+groupBy(array, f32).half
+groupBy(array, f32).i
+groupBy(array, f32).i32
+groupBy(array, f32).i64
+groupBy(array, f32).list
+groupBy(array, f32).ok
+groupBy(array, f32).score
+groupBy(array, f32)?.Bar
+groupBy(array, f32)?.Qux
+groupBy(array, f32)?.String
+groupBy(array, f32)?.add
+groupBy(array, f32)?.array
+groupBy(array, f32)?.div
+groupBy(array, f32)?.f32
+groupBy(array, f32)?.f64
+groupBy(array, f32)?.greet
+groupBy(array, f32)?.half
+groupBy(array, f32)?.i32
+groupBy(array, f32)?.i64
+groupBy(array, f32)?.list
+groupBy(array, f32)?.ok
+groupBy(array, f32)?.score
+groupBy(array, f32)[foo]
+groupBy(array, f64 != #)
+groupBy(array, f64 != i64)
+groupBy(array, f64 ** #)
+groupBy(array, f64 - #)
+groupBy(array, f64 - #).i32
+groupBy(array, f64 < #)
+groupBy(array, f64 == #)
+groupBy(array, f64 > #)
+groupBy(array, f64 >= #)
+groupBy(array, f64 >= 0.5)
+groupBy(array, f64)
+groupBy(array, f64).Bar
+groupBy(array, f64).Qux
+groupBy(array, f64).String
+groupBy(array, f64).add
+groupBy(array, f64).array
+groupBy(array, f64).div
+groupBy(array, f64).f32
+groupBy(array, f64).f64
+groupBy(array, f64).foo
+groupBy(array, f64).greet
+groupBy(array, f64).half
+groupBy(array, f64).i
+groupBy(array, f64).i32
+groupBy(array, f64).i64
+groupBy(array, f64).list
+groupBy(array, f64).ok
+groupBy(array, f64).score
+groupBy(array, f64)?.Bar
+groupBy(array, f64)?.Qux
+groupBy(array, f64)?.String
+groupBy(array, f64)?.add
+groupBy(array, f64)?.array
+groupBy(array, f64)?.div
+groupBy(array, f64)?.f32
+groupBy(array, f64)?.f64
+groupBy(array, f64)?.foo
+groupBy(array, f64)?.greet
+groupBy(array, f64)?.half
+groupBy(array, f64)?.i
+groupBy(array, f64)?.i32
+groupBy(array, f64)?.i64
+groupBy(array, f64)?.list
+groupBy(array, f64)?.ok
+groupBy(array, f64)?.score
+groupBy(array, f64)[i32]
+groupBy(array, false ? # : #)
+groupBy(array, false || ok)
+groupBy(array, false).Bar
+groupBy(array, false).Qux
+groupBy(array, false).String
+groupBy(array, false).add
+groupBy(array, false).array
+groupBy(array, false).div
+groupBy(array, false).f32
+groupBy(array, false).f64
+groupBy(array, false).greet
+groupBy(array, false).half
+groupBy(array, false).i
+groupBy(array, false).i32
+groupBy(array, false).i64
+groupBy(array, false).list
+groupBy(array, false).ok
+groupBy(array, false).score
+groupBy(array, false)?.Bar
+groupBy(array, false)?.Qux
+groupBy(array, false)?.String
+groupBy(array, false)?.add
+groupBy(array, false)?.array
+groupBy(array, false)?.div
+groupBy(array, false)?.f32
+groupBy(array, false)?.f64
+groupBy(array, false)?.foo
+groupBy(array, false)?.greet
+groupBy(array, false)?.half
+groupBy(array, false)?.i
+groupBy(array, false)?.i32
+groupBy(array, false)?.i64
+groupBy(array, false)?.list
+groupBy(array, false)?.ok
+groupBy(array, false)?.score
+groupBy(array, findLastIndex(list, true))
+groupBy(array, float(#))
+groupBy(array, floor(#))
+groupBy(array, floor(i32))
+groupBy(array, foo)
+groupBy(array, foo).Bar
+groupBy(array, foo).Qux
+groupBy(array, foo).String
+groupBy(array, foo).add
+groupBy(array, foo).array
+groupBy(array, foo).div
+groupBy(array, foo).f32
+groupBy(array, foo).f64
+groupBy(array, foo).foo
+groupBy(array, foo).greet
+groupBy(array, foo).half
+groupBy(array, foo).i
+groupBy(array, foo).i32
+groupBy(array, foo).i64
+groupBy(array, foo).list
+groupBy(array, foo).ok
+groupBy(array, foo).score
+groupBy(array, foo)?.Bar
+groupBy(array, foo)?.Qux
+groupBy(array, foo)?.String
+groupBy(array, foo)?.add
+groupBy(array, foo)?.array
+groupBy(array, foo)?.div
+groupBy(array, foo)?.f32
+groupBy(array, foo)?.f64
+groupBy(array, foo)?.foo
+groupBy(array, foo)?.greet
+groupBy(array, foo)?.half
+groupBy(array, foo)?.i
+groupBy(array, foo)?.i32
+groupBy(array, foo)?.i64
+groupBy(array, foo)?.list
+groupBy(array, foo)?.ok
+groupBy(array, foo)?.score
+groupBy(array, foo.Bar)
+groupBy(array, foo?.Bar)
+groupBy(array, get(array, #))
+groupBy(array, get(list, #))
+groupBy(array, get(list, i32))
+groupBy(array, half != add)
+groupBy(array, half(1))
+groupBy(array, half(f64))
+groupBy(array, half(f64))?.i64
+groupBy(array, i != #)
+groupBy(array, i % #)
+groupBy(array, i * #)
+groupBy(array, i * #)?.f64
+groupBy(array, i ** #)
+groupBy(array, i + #)
+groupBy(array, i - f64).array
+groupBy(array, i / #)
+groupBy(array, i < #)
+groupBy(array, i <= #)
+groupBy(array, i <= f64)
+groupBy(array, i > i)
+groupBy(array, i ^ #)
+groupBy(array, i ^ 0.5)
+groupBy(array, i)
+groupBy(array, i).Bar
+groupBy(array, i).Qux
+groupBy(array, i).String
+groupBy(array, i).add
+groupBy(array, i).array
+groupBy(array, i).div
+groupBy(array, i).f32
+groupBy(array, i).f64
+groupBy(array, i).foo
+groupBy(array, i).greet
+groupBy(array, i).half
+groupBy(array, i).i
+groupBy(array, i).i32
+groupBy(array, i).i64
+groupBy(array, i).list
+groupBy(array, i).ok
+groupBy(array, i).score
+groupBy(array, i)?.Bar
+groupBy(array, i)?.String
+groupBy(array, i)?.add
+groupBy(array, i)?.array
+groupBy(array, i)?.div
+groupBy(array, i)?.f32
+groupBy(array, i)?.f64
+groupBy(array, i)?.foo
+groupBy(array, i)?.greet
+groupBy(array, i)?.half
+groupBy(array, i)?.i
+groupBy(array, i)?.i32
+groupBy(array, i)?.i64
+groupBy(array, i)?.list
+groupBy(array, i)?.ok
+groupBy(array, i)?.score
+groupBy(array, i)[f64]
+groupBy(array, i)[false ? i32 : ok]
+groupBy(array, i32 * f64)
+groupBy(array, i32 ** # <= i32)
+groupBy(array, i32 ** f64)
+groupBy(array, i32 ** i)
+groupBy(array, i32 ** i64)
+groupBy(array, i32 + #)
+groupBy(array, i32 - 1)?.foo
+groupBy(array, i32 - i64)
+groupBy(array, i32 / #)
+groupBy(array, i32 / f32)
+groupBy(array, i32 < #)
+groupBy(array, i32 < f64)
+groupBy(array, i32 <= 1)
+groupBy(array, i32 == #)
+groupBy(array, i32 == i)
+groupBy(array, i32 > #)
+groupBy(array, i32 >= #).Bar
+groupBy(array, i32 ^ #)
+groupBy(array, i32)
+groupBy(array, i32).Bar
+groupBy(array, i32).Qux
+groupBy(array, i32).String
+groupBy(array, i32).add
+groupBy(array, i32).array
+groupBy(array, i32).div
+groupBy(array, i32).f32
+groupBy(array, i32).f64
+groupBy(array, i32).greet
+groupBy(array, i32).half
+groupBy(array, i32).i
+groupBy(array, i32).i32
+groupBy(array, i32).i64
+groupBy(array, i32).list
+groupBy(array, i32).ok
+groupBy(array, i32).score
+groupBy(array, i32)?.Bar
+groupBy(array, i32)?.Qux
+groupBy(array, i32)?.String
+groupBy(array, i32)?.add
+groupBy(array, i32)?.array
+groupBy(array, i32)?.div
+groupBy(array, i32)?.f32
+groupBy(array, i32)?.f64
+groupBy(array, i32)?.foo
+groupBy(array, i32)?.greet
+groupBy(array, i32)?.half
+groupBy(array, i32)?.i
+groupBy(array, i32)?.i32
+groupBy(array, i32)?.i64
+groupBy(array, i32)?.list
+groupBy(array, i32)?.ok
+groupBy(array, i32)?.score
+groupBy(array, i32)[i]
+groupBy(array, i64 != i)
+groupBy(array, i64 % #)
+groupBy(array, i64 * f32)
+groupBy(array, i64 ** #)
+groupBy(array, i64 ** i)
+groupBy(array, i64 + #)
+groupBy(array, i64 - #)
+groupBy(array, i64 / #)?.Qux
+groupBy(array, i64 / 0.5)
+groupBy(array, i64 < #)
+groupBy(array, i64 <= #).foo
+groupBy(array, i64 >= #)
+groupBy(array, i64 ^ #)
+groupBy(array, i64)
+groupBy(array, i64).Bar
+groupBy(array, i64).Qux
+groupBy(array, i64).String
+groupBy(array, i64).add
+groupBy(array, i64).array
+groupBy(array, i64).div
+groupBy(array, i64).f32
+groupBy(array, i64).f64
+groupBy(array, i64).foo
+groupBy(array, i64).greet
+groupBy(array, i64).half
+groupBy(array, i64).i
+groupBy(array, i64).i32
+groupBy(array, i64).i64
+groupBy(array, i64).list
+groupBy(array, i64).ok
+groupBy(array, i64).score
+groupBy(array, i64)?.Bar
+groupBy(array, i64)?.Qux
+groupBy(array, i64)?.String
+groupBy(array, i64)?.add
+groupBy(array, i64)?.array
+groupBy(array, i64)?.div
+groupBy(array, i64)?.f32
+groupBy(array, i64)?.f64
+groupBy(array, i64)?.foo
+groupBy(array, i64)?.greet
+groupBy(array, i64)?.half
+groupBy(array, i64)?.i
+groupBy(array, i64)?.i32
+groupBy(array, i64)?.i64
+groupBy(array, i64)?.list
+groupBy(array, i64)?.ok
+groupBy(array, i64)?.score
+groupBy(array, int(f64)).i32
+groupBy(array, max(#))
+groupBy(array, max(#, #, #)).ok
+groupBy(array, max(0.5, #))
+groupBy(array, max(1))
+groupBy(array, max(f64))
+groupBy(array, min(#))
+groupBy(array, min(0.5))
+groupBy(array, min(f32))
+groupBy(array, min(i, #, i32))
+groupBy(array, nil != #)
+groupBy(array, nil != f64)
+groupBy(array, nil != foo)
+groupBy(array, nil != half)
+groupBy(array, nil == #)
+groupBy(array, nil == 0.5)
+groupBy(array, none(array, false))
+groupBy(array, none(array, ok))
+groupBy(array, not ok)?.Bar
+groupBy(array, not true)
+groupBy(array, ok == ok)
+groupBy(array, ok ? # : #)
+groupBy(array, ok)
+groupBy(array, ok).Bar
+groupBy(array, ok).Qux
+groupBy(array, ok).String
+groupBy(array, ok).add
+groupBy(array, ok).array
+groupBy(array, ok).div
+groupBy(array, ok).f32
+groupBy(array, ok).f64
+groupBy(array, ok).foo
+groupBy(array, ok).greet
+groupBy(array, ok).half
+groupBy(array, ok).i
+groupBy(array, ok).i32
+groupBy(array, ok).i64
+groupBy(array, ok).list
+groupBy(array, ok).ok
+groupBy(array, ok).score
+groupBy(array, ok)?.Bar
+groupBy(array, ok)?.Qux
+groupBy(array, ok)?.String
+groupBy(array, ok)?.array
+groupBy(array, ok)?.div
+groupBy(array, ok)?.f32
+groupBy(array, ok)?.f64
+groupBy(array, ok)?.foo
+groupBy(array, ok)?.greet
+groupBy(array, ok)?.half
+groupBy(array, ok)?.i32
+groupBy(array, ok)?.i64
+groupBy(array, ok)?.list
+groupBy(array, ok)?.ok
+groupBy(array, ok)?.score
+groupBy(array, one(array, ok))
+groupBy(array, reduce(array, #))
+groupBy(array, reduce(array, foo))
+groupBy(array, reduce(list, #))
+groupBy(array, round(#))
+groupBy(array, score == div)
+groupBy(array, score(#))
+groupBy(array, score(#, #))
+groupBy(array, score(#, #, #, 1))
+groupBy(array, score(#, 1)).list
+groupBy(array, score(1))
+groupBy(array, score(i))
+groupBy(array, string(#))
+groupBy(array, string(div))
+groupBy(array, string(i32))
+groupBy(array, toJSON("bar"))
+groupBy(array, toJSON(#))
+groupBy(array, toJSON(1 .. i))
+groupBy(array, toJSON(foo))
+groupBy(array, trimPrefix("foo"))
+groupBy(array, true == nil)
+groupBy(array, true ? # : #)
+groupBy(array, true ? # : 1)
+groupBy(array, true ? nil : "foo")
+groupBy(array, true).Bar
+groupBy(array, true).Qux
+groupBy(array, true).add
+groupBy(array, true).div
+groupBy(array, true).f64
+groupBy(array, true).foo
+groupBy(array, true).greet
+groupBy(array, true).half
+groupBy(array, true).i
+groupBy(array, true).i32
+groupBy(array, true).i64
+groupBy(array, true).list
+groupBy(array, true).ok
+groupBy(array, true).score
+groupBy(array, true)?.Bar
+groupBy(array, true)?.Qux
+groupBy(array, true)?.String
+groupBy(array, true)?.add
+groupBy(array, true)?.array
+groupBy(array, true)?.div
+groupBy(array, true)?.f32
+groupBy(array, true)?.f64
+groupBy(array, true)?.half
+groupBy(array, true)?.i
+groupBy(array, true)?.i32
+groupBy(array, true)?.i64
+groupBy(array, true)?.list
+groupBy(array, true)?.ok
+groupBy(array, true)?.score
+groupBy(array, true)[i32]
+groupBy(array, type(# <= #))
+groupBy(array, type(#)).i64
+groupBy(array, type(-f64))
+groupBy(array, type(f32))
+groupBy(false ? 0.5 : "bar", #)
+groupBy(filter(array, false), #)
+groupBy(filter(array, false), add)
+groupBy(filter(array, false), f32)
+groupBy(filter(array, false), nil == #)
+groupBy(filter(array, ok), half(1))
+groupBy(filter(array, true), #)
+groupBy(filter(array, true), f64)
+groupBy(filter(list, ok), #)
+groupBy(groupBy(array, "foo").list, #)
+groupBy(groupBy(array, #).i32, add)
+groupBy(groupBy(array, 0.5)?.div, get(.foo(add, false), none(#, foo)))
+groupBy(groupBy(array, f64)?.ok, .Bar()?.Bar)
+groupBy(groupBy(array, ok).Bar, #?.array not matches #)
+groupBy(groupBy(array, true).f64, #[#])
+groupBy(i .. 1, !ok)?.f64
+groupBy(i .. 1, # % #)
+groupBy(i .. i, i64)
+groupBy(i .. i32, #)
+groupBy(i .. i32, f64 * #)
+groupBy(i .. i64, f64)?.score
+groupBy(i .. i64, foo)
+groupBy(i .. len(array), #)
+groupBy(i32 .. 1, # - #)
+groupBy(i32 .. 1, #)?.f32
+groupBy(i32 .. i, #)
+groupBy(i32 .. i32, i)
+groupBy(i32 .. i32, i32)
+groupBy(i32 .. i32, i64)
+groupBy(i32 .. i32, list[i])
+groupBy(i32 .. i32, ok)
+groupBy(i32 .. i64, #)
+groupBy(i32 .. i64, get(array, #))
+groupBy(i64 .. 1, -0.5)
+groupBy(i64 .. 1, i)
+groupBy(i64 .. i, -#)
+groupBy(i64 .. i, i32)
+groupBy(i64 .. i32, i)
+groupBy(i64 .. i64, i32)
+groupBy(list, !("foo" in #))
+groupBy(list, !false)
+groupBy(list, !ok)
+groupBy(list, !true)
+groupBy(list, "bar" contains "foo")?.ok
+groupBy(list, "bar" endsWith "bar")
+groupBy(list, "bar" not in #)
+groupBy(list, "bar").Bar
+groupBy(list, "bar").Qux
+groupBy(list, "bar").String
+groupBy(list, "bar").add
+groupBy(list, "bar").array
+groupBy(list, "bar").div
+groupBy(list, "bar").f32
+groupBy(list, "bar").f64
+groupBy(list, "bar").foo
+groupBy(list, "bar").greet
+groupBy(list, "bar").i
+groupBy(list, "bar").i32
+groupBy(list, "bar").i64
+groupBy(list, "bar").list
+groupBy(list, "bar").ok
+groupBy(list, "bar").score
+groupBy(list, "bar")?.Bar
+groupBy(list, "bar")?.Qux
+groupBy(list, "bar")?.String
+groupBy(list, "bar")?.add
+groupBy(list, "bar")?.array
+groupBy(list, "bar")?.div
+groupBy(list, "bar")?.f32
+groupBy(list, "bar")?.f64
+groupBy(list, "bar")?.foo
+groupBy(list, "bar")?.greet
+groupBy(list, "bar")?.half
+groupBy(list, "bar")?.i
+groupBy(list, "bar")?.i32
+groupBy(list, "bar")?.i64
+groupBy(list, "bar")?.list
+groupBy(list, "bar")?.ok
+groupBy(list, "bar")?.score
+groupBy(list, "foo" not in #)?.foo
+groupBy(list, "foo").Bar
+groupBy(list, "foo").Qux
+groupBy(list, "foo").String
+groupBy(list, "foo").add
+groupBy(list, "foo").array
+groupBy(list, "foo").div
+groupBy(list, "foo").f32
+groupBy(list, "foo").f64
+groupBy(list, "foo").foo
+groupBy(list, "foo").greet
+groupBy(list, "foo").half
+groupBy(list, "foo").i
+groupBy(list, "foo").i32
+groupBy(list, "foo").i64
+groupBy(list, "foo").list
+groupBy(list, "foo").ok
+groupBy(list, "foo").score
+groupBy(list, "foo")?.Bar
+groupBy(list, "foo")?.Qux
+groupBy(list, "foo")?.String
+groupBy(list, "foo")?.add
+groupBy(list, "foo")?.array
+groupBy(list, "foo")?.div
+groupBy(list, "foo")?.f32
+groupBy(list, "foo")?.f64
+groupBy(list, "foo")?.foo
+groupBy(list, "foo")?.greet
+groupBy(list, "foo")?.half
+groupBy(list, "foo")?.i
+groupBy(list, "foo")?.i32
+groupBy(list, "foo")?.i64
+groupBy(list, "foo")?.list
+groupBy(list, "foo")?.ok
+groupBy(list, "foo")?.score
+groupBy(list, # != #)
+groupBy(list, # != foo)
+groupBy(list, # != foo)?.i
+groupBy(list, # != nil)
+groupBy(list, # == #)
+groupBy(list, # == #).div
+groupBy(list, # in list)
+groupBy(list, # not in list)
+groupBy(list, #)
+groupBy(list, #).Bar
+groupBy(list, #).Qux
+groupBy(list, #).String
+groupBy(list, #).add
+groupBy(list, #).array
+groupBy(list, #).div
+groupBy(list, #).f32
+groupBy(list, #).f64
+groupBy(list, #).foo
+groupBy(list, #).greet
+groupBy(list, #).half
+groupBy(list, #).i
+groupBy(list, #).i32
+groupBy(list, #).i64
+groupBy(list, #).list
+groupBy(list, #).ok
+groupBy(list, #).score
+groupBy(list, #)?.Bar
+groupBy(list, #)?.Qux
+groupBy(list, #)?.String
+groupBy(list, #)?.add
+groupBy(list, #)?.array
+groupBy(list, #)?.div
+groupBy(list, #)?.f32
+groupBy(list, #)?.f64
+groupBy(list, #)?.foo
+groupBy(list, #)?.greet
+groupBy(list, #)?.half
+groupBy(list, #)?.i
+groupBy(list, #)?.i32
+groupBy(list, #)?.i64
+groupBy(list, #)?.list
+groupBy(list, #)?.ok
+groupBy(list, #)?.score
+groupBy(list, #)[-i64]
+groupBy(list, #)[1 == i32]
+groupBy(list, #)[f32]
+groupBy(list, #)[foo]
+groupBy(list, #)[i == i64]
+groupBy(list, #)[i32]
+groupBy(list, #)[i64]
+groupBy(list, #)[ok]
+groupBy(list, #?.Bar)
+groupBy(list, #?.String())
+groupBy(list, #?.String())?.score
+groupBy(list, -0.5)
+groupBy(list, -1)
+groupBy(list, -f32)
+groupBy(list, -i)
+groupBy(list, .Bar)
+groupBy(list, .Bar).f32
+groupBy(list, .String())
+groupBy(list, .String())?.score
+groupBy(list, 0.5 != f32)
+groupBy(list, 0.5 != f64)
+groupBy(list, 0.5 * f32)
+groupBy(list, 0.5 ** i64)
+groupBy(list, 0.5 / i)
+groupBy(list, 0.5).Bar
+groupBy(list, 0.5).Qux
+groupBy(list, 0.5).String
+groupBy(list, 0.5).add
+groupBy(list, 0.5).array
+groupBy(list, 0.5).div
+groupBy(list, 0.5).f32
+groupBy(list, 0.5).f64
+groupBy(list, 0.5).greet
+groupBy(list, 0.5).half
+groupBy(list, 0.5).i
+groupBy(list, 0.5).i32
+groupBy(list, 0.5).i64
+groupBy(list, 0.5).list
+groupBy(list, 0.5).ok
+groupBy(list, 0.5).score
+groupBy(list, 0.5)?.Bar
+groupBy(list, 0.5)?.Qux
+groupBy(list, 0.5)?.String
+groupBy(list, 0.5)?.add
+groupBy(list, 0.5)?.array
+groupBy(list, 0.5)?.div
+groupBy(list, 0.5)?.f32
+groupBy(list, 0.5)?.f64
+groupBy(list, 0.5)?.foo
+groupBy(list, 0.5)?.greet
+groupBy(list, 0.5)?.half
+groupBy(list, 0.5)?.i
+groupBy(list, 0.5)?.i32
+groupBy(list, 0.5)?.i64
+groupBy(list, 0.5)?.list
+groupBy(list, 0.5)?.ok
+groupBy(list, 0.5)?.score
+groupBy(list, 1 * f64).f32
+groupBy(list, 1 + i)
+groupBy(list, 1 - 0.5)
+groupBy(list, 1 ^ 0.5)
+groupBy(list, 1 ^ 1)
+groupBy(list, 1 ^ i)
+groupBy(list, 1).Bar
+groupBy(list, 1).Qux
+groupBy(list, 1).String
+groupBy(list, 1).add
+groupBy(list, 1).array
+groupBy(list, 1).div
+groupBy(list, 1).f32
+groupBy(list, 1).f64
+groupBy(list, 1).foo
+groupBy(list, 1).greet
+groupBy(list, 1).half
+groupBy(list, 1).i
+groupBy(list, 1).i32
+groupBy(list, 1).i64
+groupBy(list, 1).list
+groupBy(list, 1).ok
+groupBy(list, 1).score
+groupBy(list, 1)?.Bar
+groupBy(list, 1)?.Qux
+groupBy(list, 1)?.String
+groupBy(list, 1)?.add
+groupBy(list, 1)?.array
+groupBy(list, 1)?.div
+groupBy(list, 1)?.f32
+groupBy(list, 1)?.f64
+groupBy(list, 1)?.foo
+groupBy(list, 1)?.greet
+groupBy(list, 1)?.half
+groupBy(list, 1)?.i
+groupBy(list, 1)?.i32
+groupBy(list, 1)?.i64
+groupBy(list, 1)?.list
+groupBy(list, 1)?.ok
+groupBy(list, 1)?.score
+groupBy(list, 1)[i]
+groupBy(list, 1)[reduce(list, "foo")]
+groupBy(list, abs(1))
+groupBy(list, abs(i))
+groupBy(list, abs(i64))
+groupBy(list, all(list, ok))
+groupBy(list, ceil(0.5))
+groupBy(list, ceil(f64))
+groupBy(list, f32 ** 0.5)
+groupBy(list, f32 ** 1)
+groupBy(list, f32 < f32)
+groupBy(list, f32 == i64)
+groupBy(list, f32 >= 1)
+groupBy(list, f32)
+groupBy(list, f32).Bar
+groupBy(list, f32).Qux
+groupBy(list, f32).String
+groupBy(list, f32).add
+groupBy(list, f32).array
+groupBy(list, f32).div
+groupBy(list, f32).f32
+groupBy(list, f32).f64
+groupBy(list, f32).foo
+groupBy(list, f32).half
+groupBy(list, f32).i
+groupBy(list, f32).i32
+groupBy(list, f32).i64
+groupBy(list, f32).list
+groupBy(list, f32).ok
+groupBy(list, f32)?.Bar
+groupBy(list, f32)?.Qux
+groupBy(list, f32)?.String
+groupBy(list, f32)?.add
+groupBy(list, f32)?.array
+groupBy(list, f32)?.div
+groupBy(list, f32)?.f32
+groupBy(list, f32)?.f64
+groupBy(list, f32)?.foo
+groupBy(list, f32)?.greet
+groupBy(list, f32)?.half
+groupBy(list, f32)?.i
+groupBy(list, f32)?.i32
+groupBy(list, f32)?.i64
+groupBy(list, f32)?.list
+groupBy(list, f32)?.ok
+groupBy(list, f32)?.score
+groupBy(list, f32)[add == nil]
+groupBy(list, f32)[toJSON(true)]
+groupBy(list, f64 * 0.5)
+groupBy(list, f64 * 1)
+groupBy(list, f64 - 1)
+groupBy(list, f64 < f64)
+groupBy(list, f64)
+groupBy(list, f64).Bar
+groupBy(list, f64).Qux
+groupBy(list, f64).String
+groupBy(list, f64).add
+groupBy(list, f64).array
+groupBy(list, f64).div
+groupBy(list, f64).f32
+groupBy(list, f64).f64
+groupBy(list, f64).foo
+groupBy(list, f64).greet
+groupBy(list, f64).half
+groupBy(list, f64).i
+groupBy(list, f64).i32
+groupBy(list, f64).i64
+groupBy(list, f64).list
+groupBy(list, f64).ok
+groupBy(list, f64).score
+groupBy(list, f64)?.Bar
+groupBy(list, f64)?.Qux
+groupBy(list, f64)?.String
+groupBy(list, f64)?.add
+groupBy(list, f64)?.array
+groupBy(list, f64)?.div
+groupBy(list, f64)?.f32
+groupBy(list, f64)?.f64
+groupBy(list, f64)?.foo
+groupBy(list, f64)?.greet
+groupBy(list, f64)?.half
+groupBy(list, f64)?.i
+groupBy(list, f64)?.i32
+groupBy(list, f64)?.i64
+groupBy(list, f64)?.list
+groupBy(list, f64)?.ok
+groupBy(list, f64)?.score
+groupBy(list, false == ok)
+groupBy(list, false ? score : #)
+groupBy(list, false).Bar
+groupBy(list, false).add
+groupBy(list, false).array
+groupBy(list, false).div
+groupBy(list, false).f32
+groupBy(list, false).foo
+groupBy(list, false).greet
+groupBy(list, false).half
+groupBy(list, false).i
+groupBy(list, false).i32
+groupBy(list, false).i64
+groupBy(list, false).list
+groupBy(list, false).ok
+groupBy(list, false)?.Bar
+groupBy(list, false)?.Qux
+groupBy(list, false)?.String
+groupBy(list, false)?.add
+groupBy(list, false)?.div
+groupBy(list, false)?.f32
+groupBy(list, false)?.f64
+groupBy(list, false)?.greet
+groupBy(list, false)?.half
+groupBy(list, false)?.i
+groupBy(list, false)?.i32
+groupBy(list, false)?.i64
+groupBy(list, false)?.list
+groupBy(list, false)?.ok
+groupBy(list, false)?.score
+groupBy(list, findLastIndex(array, ok))
+groupBy(list, findLastIndex(list, false))
+groupBy(list, first(array))
+groupBy(list, float(-1))
+groupBy(list, float(0.5))
+groupBy(list, floor(i))
+groupBy(list, floor(i64))
+groupBy(list, foo != #)
+groupBy(list, foo)
+groupBy(list, foo).Bar
+groupBy(list, foo).Qux
+groupBy(list, foo).String
+groupBy(list, foo).add
+groupBy(list, foo).array
+groupBy(list, foo).div
+groupBy(list, foo).f32
+groupBy(list, foo).f64
+groupBy(list, foo).foo
+groupBy(list, foo).greet
+groupBy(list, foo).half
+groupBy(list, foo).i
+groupBy(list, foo).i32
+groupBy(list, foo).i64
+groupBy(list, foo).list
+groupBy(list, foo).ok
+groupBy(list, foo).score
+groupBy(list, foo)?.Bar
+groupBy(list, foo)?.Qux
+groupBy(list, foo)?.String
+groupBy(list, foo)?.add
+groupBy(list, foo)?.array
+groupBy(list, foo)?.div
+groupBy(list, foo)?.f32
+groupBy(list, foo)?.f64
+groupBy(list, foo)?.foo
+groupBy(list, foo)?.half
+groupBy(list, foo)?.i
+groupBy(list, foo)?.i32
+groupBy(list, foo)?.i64
+groupBy(list, foo)?.list
+groupBy(list, foo)?.ok
+groupBy(list, foo)?.score
+groupBy(list, foo)[i32]
+groupBy(list, foo.Bar)
+groupBy(list, foo.String())
+groupBy(list, foo?.String())
+groupBy(list, greet != greet)
+groupBy(list, greet == add)
+groupBy(list, greet("bar"))
+groupBy(list, i * i)
+groupBy(list, i / f64)
+groupBy(list, i <= i)
+groupBy(list, i ^ i)
+groupBy(list, i)
+groupBy(list, i).Bar
+groupBy(list, i).Qux
+groupBy(list, i).String
+groupBy(list, i).add
+groupBy(list, i).array
+groupBy(list, i).div
+groupBy(list, i).f32
+groupBy(list, i).f64
+groupBy(list, i).foo
+groupBy(list, i).half
+groupBy(list, i).i
+groupBy(list, i).i32
+groupBy(list, i).i64
+groupBy(list, i).list
+groupBy(list, i).ok
+groupBy(list, i).score
+groupBy(list, i)?.Bar
+groupBy(list, i)?.Qux
+groupBy(list, i)?.String
+groupBy(list, i)?.add
+groupBy(list, i)?.array
+groupBy(list, i)?.div
+groupBy(list, i)?.f32
+groupBy(list, i)?.f64
+groupBy(list, i)?.foo
+groupBy(list, i)?.greet
+groupBy(list, i)?.half
+groupBy(list, i)?.i
+groupBy(list, i)?.i32
+groupBy(list, i)?.i64
+groupBy(list, i)?.list
+groupBy(list, i)?.ok
+groupBy(list, i)?.score
+groupBy(list, i32 != f32)?.foo
+groupBy(list, i32 * 0.5)
+groupBy(list, i32 ** 0.5)
+groupBy(list, i32 ** f32)
+groupBy(list, i32 > i)
+groupBy(list, i32 ^ i)
+groupBy(list, i32)
+groupBy(list, i32).Bar
+groupBy(list, i32).Qux
+groupBy(list, i32).add
+groupBy(list, i32).array
+groupBy(list, i32).div
+groupBy(list, i32).f32
+groupBy(list, i32).f64
+groupBy(list, i32).foo
+groupBy(list, i32).greet
+groupBy(list, i32).half
+groupBy(list, i32).i
+groupBy(list, i32).i32
+groupBy(list, i32).i64
+groupBy(list, i32).list
+groupBy(list, i32).ok
+groupBy(list, i32).score
+groupBy(list, i32)?.Bar
+groupBy(list, i32)?.Qux
+groupBy(list, i32)?.String
+groupBy(list, i32)?.add
+groupBy(list, i32)?.array
+groupBy(list, i32)?.div
+groupBy(list, i32)?.f32
+groupBy(list, i32)?.f64
+groupBy(list, i32)?.foo
+groupBy(list, i32)?.greet
+groupBy(list, i32)?.half
+groupBy(list, i32)?.i
+groupBy(list, i32)?.i32
+groupBy(list, i32)?.i64
+groupBy(list, i32)?.list
+groupBy(list, i32)?.ok
+groupBy(list, i32)?.score
+groupBy(list, i64 != i32)
+groupBy(list, i64 != nil)
+groupBy(list, i64 - 0.5)
+groupBy(list, i64 < 1)
+groupBy(list, i64 <= 1)
+groupBy(list, i64 == 1)
+groupBy(list, i64 == nil)
+groupBy(list, i64)
+groupBy(list, i64).Bar
+groupBy(list, i64).Qux
+groupBy(list, i64).String
+groupBy(list, i64).add
+groupBy(list, i64).array
+groupBy(list, i64).div
+groupBy(list, i64).f32
+groupBy(list, i64).f64
+groupBy(list, i64).foo
+groupBy(list, i64).greet
+groupBy(list, i64).half
+groupBy(list, i64).i
+groupBy(list, i64).i32
+groupBy(list, i64).list
+groupBy(list, i64).ok
+groupBy(list, i64).score
+groupBy(list, i64)?.Bar
+groupBy(list, i64)?.Qux
+groupBy(list, i64)?.String
+groupBy(list, i64)?.add
+groupBy(list, i64)?.array
+groupBy(list, i64)?.div
+groupBy(list, i64)?.f32
+groupBy(list, i64)?.f64
+groupBy(list, i64)?.foo
+groupBy(list, i64)?.greet
+groupBy(list, i64)?.half
+groupBy(list, i64)?.i
+groupBy(list, i64)?.i32
+groupBy(list, i64)?.i64
+groupBy(list, i64)?.list
+groupBy(list, i64)?.ok
+groupBy(list, i64)?.score
+groupBy(list, i64)[max(i)]
+groupBy(list, i64)[ok]
+groupBy(list, int(1))
+groupBy(list, list == array)
+groupBy(list, lower("foo"))
+groupBy(list, max(f64))
+groupBy(list, max(i))
+groupBy(list, nil != #)
+groupBy(list, nil != div)
+groupBy(list, nil != true)
+groupBy(list, nil == #)
+groupBy(list, nil == #).i
+groupBy(list, nil in list)
+groupBy(list, not false)
+groupBy(list, not ok)
+groupBy(list, ok != false)
+groupBy(list, ok ? # : true)
+groupBy(list, ok)
+groupBy(list, ok).Bar
+groupBy(list, ok).Qux
+groupBy(list, ok).String
+groupBy(list, ok).add
+groupBy(list, ok).array
+groupBy(list, ok).div
+groupBy(list, ok).f32
+groupBy(list, ok).f64
+groupBy(list, ok).foo
+groupBy(list, ok).greet
+groupBy(list, ok).half
+groupBy(list, ok).i
+groupBy(list, ok).i32
+groupBy(list, ok).i64
+groupBy(list, ok).list
+groupBy(list, ok).ok
+groupBy(list, ok).score
+groupBy(list, ok)?.Bar
+groupBy(list, ok)?.Qux
+groupBy(list, ok)?.String
+groupBy(list, ok)?.add
+groupBy(list, ok)?.array
+groupBy(list, ok)?.div
+groupBy(list, ok)?.f32
+groupBy(list, ok)?.f64
+groupBy(list, ok)?.foo
+groupBy(list, ok)?.greet
+groupBy(list, ok)?.half
+groupBy(list, ok)?.i
+groupBy(list, ok)?.i32
+groupBy(list, ok)?.i64
+groupBy(list, ok)?.list
+groupBy(list, ok)?.ok
+groupBy(list, ok)?.score
+groupBy(list, reduce(array, #))
+groupBy(list, reduce(list, #)).i32
+groupBy(list, reduce(list, f64))
+groupBy(list, reduce(list, i32))
+groupBy(list, reduce(map(list, i64), #))
+groupBy(list, round(0.5))
+groupBy(list, round(1))
+groupBy(list, round(f64))
+groupBy(list, score(1))
+groupBy(list, score(i))
+groupBy(list, string(#))
+groupBy(list, string(add))
+groupBy(list, string(half))
+groupBy(list, string(i32))
+groupBy(list, string(true))
+groupBy(list, toBase64("foo"))
+groupBy(list, toJSON(#))
+groupBy(list, toJSON(1))
+groupBy(list, toJSON(array))
+groupBy(list, toJSON(foo))
+groupBy(list, true && false)
+groupBy(list, true ? # : 1)
+groupBy(list, true ? 1 : #)
+groupBy(list, true).Qux
+groupBy(list, true).String
+groupBy(list, true).add
+groupBy(list, true).array
+groupBy(list, true).div
+groupBy(list, true).f32
+groupBy(list, true).f64
+groupBy(list, true).foo
+groupBy(list, true).greet
+groupBy(list, true).half
+groupBy(list, true).i
+groupBy(list, true).i32
+groupBy(list, true).i64
+groupBy(list, true).list
+groupBy(list, true).ok
+groupBy(list, true).score
+groupBy(list, true)?.Bar
+groupBy(list, true)?.Qux
+groupBy(list, true)?.String
+groupBy(list, true)?.add
+groupBy(list, true)?.array
+groupBy(list, true)?.div
+groupBy(list, true)?.f32
+groupBy(list, true)?.f64
+groupBy(list, true)?.foo
+groupBy(list, true)?.greet
+groupBy(list, true)?.half
+groupBy(list, true)?.i
+groupBy(list, true)?.i32
+groupBy(list, true)?.i64
+groupBy(list, true)?.list
+groupBy(list, true)?.ok
+groupBy(list, true)?.score
+groupBy(list, type("foo"))
+groupBy(list, type(#))
+groupBy(list, type(false))
+groupBy(list[i32:1], i64)
+groupBy(list[i32:i32], foo)
+groupBy(list[i64:1], i32)
+groupBy(list[i:1], f64)
+groupBy(map(array, #), # <= #)
+groupBy(map(array, #), # == #)
+groupBy(map(array, #), # >= #)
+groupBy(map(array, #), #)
+groupBy(map(array, #), 0.5 < 0.5)
+groupBy(map(array, #), foo)
+groupBy(map(array, #), i)
+groupBy(map(array, #), i64)
+groupBy(map(array, #), min(1))
+groupBy(map(array, #), ok)
+groupBy(map(array, 0.5), # != 0.5)
+groupBy(map(array, 0.5), # / #)
+groupBy(map(array, 0.5), #)
+groupBy(map(array, 0.5), f64)
+groupBy(map(array, 1), 0.5 / #)
+groupBy(map(array, 1), f64)
+groupBy(map(array, 1), max(#))
+groupBy(map(array, 1), ok)
+groupBy(map(array, div), div != #)
+groupBy(map(array, f32), # - 0.5)
+groupBy(map(array, f32), min(#))
+groupBy(map(array, f64), #)
+groupBy(map(array, false), f64)
+groupBy(map(array, false), i)
+groupBy(map(array, foo), #).add
+groupBy(map(array, foo), i)
+groupBy(map(array, foo), ok)
+groupBy(map(array, i), #)
+groupBy(map(array, i32), # % i)
+groupBy(map(array, i32), #)
+groupBy(map(array, ok), i64)
+groupBy(map(list, "bar"), #)
+groupBy(map(list, "foo"), #)
+groupBy(map(list, #), "bar" == "bar")
+groupBy(map(list, #), #)
+groupBy(map(list, #), #)?.array
+groupBy(map(list, #), f32)
+groupBy(map(list, #), f64)
+groupBy(map(list, #), i32)
+groupBy(map(list, #), i64)
+groupBy(map(list, #), ok)
+groupBy(map(list, 0.5), # * i64)
+groupBy(map(list, 0.5), # ** #)
+groupBy(map(list, 0.5), #)
+groupBy(map(list, 0.5), i32)
+groupBy(map(list, 1), #)
+groupBy(map(list, 1), get(list, #)).i64
+groupBy(map(list, 1), i64)
+groupBy(map(list, f32), # ** #).array
+groupBy(map(list, f64), #)
+groupBy(map(list, f64), #).half
+groupBy(map(list, f64), f32)
+groupBy(map(list, f64), i)
+groupBy(map(list, i), #)
+groupBy(map(list, i32), # == #)
+groupBy(map(list, i64), #)?.i32
+groupBy(map(list, i64), i)
+groupBy(map(list, list), foo)
+groupBy(map(list, ok), #)
+groupBy(ok ? "foo" : greet, # <= #)
+groupBy(reduce(array, # .. i64), add)
+groupBy(reduce(array, array), foo)
+groupBy(reduce(array, array), i)
+groupBy(reduce(list, array), # / #)
+groupBy(reduce(list, array), true ? true : nil)
+groupBy(sort(array), #)
+groupBy(sort(array), foo)
+groupBy(true ? "foo" : 1, # > 0.5)
+groupBy(true ? "foo" : 1, foo)
+groupBy(true ? "foo" : false, # / #)
+groupBy(true ? "foo" : score, #)
 half
 half != add
-half != add ? ok : half
+half != add ? add : array
+half != add ? true : 1
+half != add || ok
 half != div
-half != div == true
+half != div ? i32 : f64
+half != div ? nil : greet
 half != foo.Qux
 half != foo.String
 half != foo?.Qux
 half != foo?.String
 half != greet
+half != greet == ok
+half != greet ? score : true
 half != half
+half != half != nil
+half != half and "bar" in foo
+half != nil == false
+half != nil ? "bar" : div
+half != nil ? "bar" : false
+half != nil ? true : div
+half != reduce(list, half)
 half != score
+half != score && i32 > 1
 half == add
-half == add ? "bar" : half
+half == add == nil
+half == add ? list : add
+half == add or ok
 half == div
-half == div ? add : 0.5
-half == div and 1 >= 1
 half == foo.Qux
 half == foo.String
 half == foo?.Qux
 half == foo?.String
 half == greet
-half == greet == nil
-half == greet ? ok : foo
-half == greet || ok
+half == greet != ok
+half == greet ? half : div
+half == greet ? i64 : ok
+half == greet || true ? i : list
 half == half
-half == half && i >= 0.5
-half == half ? score : "bar"
-half == half and ok
-half == nil == true
-half == nil ? 1 : 0.5
-half == nil ? 1 : score
+half == nil && ok
+half == nil ? array : 0.5
+half == nil ? foo : false
 half == score
-half not in [list, i64, ok]
-half not in {"bar": list, "foo": 0.5}.ok
-half(-(f32 - 0.5))
-half(--1)
+half == score ? f32 : nil
+half == score ? foo : "bar"
+half(-(0.5 + 1))
+half(-(f64 + 1))
+half(-(i64 - 0.5))
 half(-0.5)
 half(-1)
-half(-f32 ^ i)
 half(-f64)
 half(0.5 * 0.5)
 half(0.5 * 1)
@@ -6567,9 +9175,11 @@ half(0.5 ** i)
 half(0.5 ** i32)
 half(0.5 ** i64)
 half(0.5 + 0.5)
+half(0.5 + 1 + i64)
 half(0.5 + 1)
 half(0.5 + f32)
 half(0.5 + f64)
+half(0.5 + i)
 half(0.5 + i32)
 half(0.5 + i64)
 half(0.5 - 0.5)
@@ -6584,7 +9194,6 @@ half(0.5 / 1)
 half(0.5 / f32)
 half(0.5 / f64)
 half(0.5 / i)
-half(0.5 / i32)
 half(0.5 / i64)
 half(0.5 ^ 0.5)
 half(0.5 ^ 1)
@@ -6593,38 +9202,49 @@ half(0.5 ^ f64)
 half(0.5 ^ i)
 half(0.5 ^ i32)
 half(0.5 ^ i64)
-half(0.5) != f32
+half(0.5) != -i64
+half(0.5) != 0.5 ^ i
+half(0.5) != i32
 half(0.5) != i64
 half(0.5) * f32
+half(0.5) * i
+half(0.5) * i32
+half(0.5) * i64
 half(0.5) ** f32
-half(0.5) ** f64
-half(0.5) + 1 * f64
+half(0.5) ** i
+half(0.5) ** i32
+half(0.5) ** i64
+half(0.5) ** max(1)
+half(0.5) + 1 / 1
+half(0.5) + f32
 half(0.5) + f64
 half(0.5) + i32
 half(0.5) + i64
-half(0.5) - f32
-half(0.5) - f64
-half(0.5) - i
-half(0.5) - i32
+half(0.5) - i64
+half(0.5) / -0.5
+half(0.5) / f64
 half(0.5) / i
-half(0.5) / i32
 half(0.5) / i64
-half(0.5) < i32
-half(0.5) <= i
-half(0.5) == f32 != true
-half(0.5) == i
-half(0.5) == i32
+half(0.5) < f64
+half(0.5) <= f32 ? f64 : 1
+half(0.5) <= f64
+half(0.5) <= i32
+half(0.5) <= i64 + i32
+half(0.5) <= int(0.5)
+half(0.5) == f32
+half(0.5) == i32 / i
 half(0.5) == i64
+half(0.5) > f32
+half(0.5) > f64
 half(0.5) > i
-half(0.5) > i32
 half(0.5) > i64
-half(0.5) >= f32
-half(0.5) >= f64
-half(0.5) >= i
 half(0.5) >= i32
-half(0.5) >= i64
-half(0.5) ^ (i32 - 1)
+half(0.5) ^ (1 * i32)
+half(0.5) ^ f32
+half(0.5) ^ f64
+half(0.5) ^ i
 half(0.5) ^ i32
+half(0.5) ^ i64
 half(1 * 0.5)
 half(1 * 1)
 half(1 * f32)
@@ -6666,22 +9286,77 @@ half(1 ^ f32)
 half(1 ^ f64)
 half(1 ^ i)
 half(1 ^ i32)
+half(1 ^ i64)
+half(1) != f32
+half(1) != f64
+half(1) != f64 ** f32
+half(1) != f64 ^ 0.5
+half(1) != i32
+half(1) != i64
+half(1) * i32 * i64
+half(1) ** (i64 * f32)
+half(1) ** f32
+half(1) ** i
+half(1) ** i32
+half(1) ** i64
+half(1) + f32
+half(1) + f32 / 0.5
+half(1) + i
+half(1) + i32
+half(1) + i64 + i32
+half(1) - f32
+half(1) - i < i64
+half(1) - i32
+half(1) - i64
+half(1) / -1
+half(1) / 0.5 / i
+half(1) / i
+half(1) / i32
+half(1) < f64
+half(1) < i
+half(1) < i64
+half(1) <= f32
+half(1) <= i32
+half(1) <= i64
+half(1) == -1
+half(1) == 1 ^ i64
+half(1) == f32
+half(1) == i32
+half(1) > i
+half(1) > i32
+half(1) > i64
+half(1) >= f32
+half(1) >= i
+half(1) >= i32
+half(1) >= i64
+half(1) >= max(1)
+half(1) >= mean(array)
+half(1) ^ f32
+half(1) ^ findIndex(list, true)
+half(1) ^ i64
+half(1) in array
+half(1) not in array
 half(abs(0.5))
 half(abs(f64))
-half(abs(f64)) - i
+half(ceil(0.5))
+half(ceil(1))
+half(ceil(f32))
+half(ceil(f64))
+half(ceil(i))
+half(ceil(i32))
+half(ceil(i64))
 half(f32 * 0.5)
 half(f32 * 1)
 half(f32 * f64)
 half(f32 * i)
 half(f32 * i32)
-half(f32 * i64)
 half(f32 ** 0.5)
 half(f32 ** f32)
 half(f32 ** f64)
+half(f32 ** i64)
 half(f32 + 0.5)
 half(f32 + 1)
 half(f32 + f64)
-half(f32 + i)
 half(f32 + i32)
 half(f32 + i64)
 half(f32 - 0.5)
@@ -6694,84 +9369,85 @@ half(f32 / 0.5)
 half(f32 / 1)
 half(f32 / f32)
 half(f32 / f64)
+half(f32 / i)
 half(f32 / i32)
 half(f32 / i64)
 half(f32 ^ 0.5)
+half(f32 ^ 1)
 half(f32 ^ f32)
 half(f32 ^ f64)
+half(f32 ^ i)
 half(f32 ^ i32)
 half(f32 ^ i64)
 half(f64 * 0.5)
-half(f64 * 1)
 half(f64 * f32)
+half(f64 * f64)
 half(f64 * i)
 half(f64 * i32)
+half(f64 * i64)
 half(f64 ** 0.5)
 half(f64 ** 1)
 half(f64 ** f32)
-half(f64 ** f64)
 half(f64 ** i)
 half(f64 ** i32)
+half(f64 + 0.5)
 half(f64 + 1)
-half(f64 + f32)
+half(f64 + f64)
 half(f64 + i)
-half(f64 + i32)
+half(f64 + i64)
 half(f64 - 0.5)
 half(f64 - 1)
 half(f64 - f32)
 half(f64 - f64)
 half(f64 - i)
-half(f64 - i32)
 half(f64 - i64)
+half(f64 / 0.5)
 half(f64 / 1)
 half(f64 / f32)
 half(f64 / f64)
+half(f64 / i)
 half(f64 / i32)
-half(f64 / i64)
 half(f64 ^ 0.5)
 half(f64 ^ 1)
 half(f64 ^ f32)
-half(f64 ^ i)
+half(f64 ^ f64)
 half(f64 ^ i32)
-half(f64 ^ i64)
 half(f64)
-half(f64) != f32
-half(f64) != f64
+half(f64) != f64 != false
+half(f64) != i32
 half(f64) != i64
-half(f64) * f32
-half(f64) * i64
-half(f64) ** (i32 * 0.5)
-half(f64) ** 0.5 ** i
 half(f64) ** f64
-half(f64) ** i64
-half(f64) + 1 + f64
-half(f64) + f64
-half(f64) + i
+half(f64) ** i
+half(f64) ** i32
 half(f64) + i32
 half(f64) + i64
 half(f64) - f64
 half(f64) - i32
-half(f64) / f32
 half(f64) / f64
 half(f64) / i32
-half(f64) / i64
-half(f64) < f64
 half(f64) < i
 half(f64) < i32
-half(f64) < i64
-half(f64) <= 0.5 + f64
-half(f64) <= f64
-half(f64) <= i64
+half(f64) <= f32
+half(f64) <= i32
+half(f64) == f32
+half(f64) == f64
+half(f64) == i
+half(f64) == i32
 half(f64) == i64
-half(f64) > abs(i)
-half(f64) > f32 * 0.5
-half(f64) > max(i64)
-half(f64) >= f32
+half(f64) > f32
+half(f64) > f64
+half(f64) > i
+half(f64) > i32
+half(f64) > i64
 half(f64) >= i
 half(f64) >= i64
-half(f64) ^ f32
-half(false ? 0.5 : 0.5)
-half(float(-f64))
+half(f64) ^ i
+half(f64) not in array
+half(false ? f64 : 0.5)
+half(false ? i32 : 0.5)
+half(false ? ok : 0.5)
+half(false ? score : 0.5)
+half(false ? true : f64)
 half(float(0.5))
 half(float(1))
 half(float(f32))
@@ -6779,37 +9455,43 @@ half(float(f64))
 half(float(i))
 half(float(i32))
 half(float(i64))
-half(greet == div ? "bar" : 0.5)
+half(floor(0.5))
+half(floor(1))
+half(floor(f32))
+half(floor(f64))
+half(floor(i))
+half(floor(i32))
+half(floor(i64))
 half(half(0.5))
+half(half(1))
+half(half(ceil(i)))
+half(half(f64 - 0.5))
 half(half(f64))
-half(half(i - 0.5))
 half(i * 0.5)
 half(i * 1)
-half(i * f32)
 half(i * f64)
 half(i ** 0.5)
 half(i ** 1)
 half(i ** f32)
 half(i ** f64)
 half(i ** i)
+half(i ** i32)
 half(i ** i64)
 half(i + 0.5)
 half(i + 1)
 half(i + f32)
 half(i + f64)
-half(i - 0.5)
 half(i - 1)
+half(i - f32)
 half(i - f64)
 half(i / 0.5)
 half(i / 1)
-half(i / f32)
 half(i / f64)
 half(i / i)
 half(i / i32)
-half(i / i64)
 half(i ^ 0.5)
 half(i ^ 1)
-half(i ^ f32)
+half(i ^ i)
 half(i ^ i32)
 half(i ^ i64)
 half(i32 * 0.5)
@@ -6818,2451 +9500,2668 @@ half(i32 * f32)
 half(i32 * f64)
 half(i32 ** 0.5)
 half(i32 ** 1)
-half(i32 ** f32)
 half(i32 ** f64)
 half(i32 ** i)
 half(i32 ** i32)
 half(i32 ** i64)
 half(i32 + 0.5)
 half(i32 + 1)
+half(i32 + f32)
 half(i32 + f64)
 half(i32 - 0.5)
 half(i32 - 1)
 half(i32 - f32)
-half(i32 - f64)
 half(i32 / 0.5)
 half(i32 / 1)
 half(i32 / f32)
 half(i32 / f64)
 half(i32 / i)
+half(i32 / i32 / f32 / f64)
 half(i32 / i32)
 half(i32 / i64)
 half(i32 ^ 0.5)
 half(i32 ^ 1)
 half(i32 ^ f32)
+half(i32 ^ f64)
 half(i32 ^ i)
 half(i32 ^ i32)
+half(i32 ^ i64 ^ i)
 half(i32 ^ i64)
+half(i64 != i ? true : 0.5)
 half(i64 * 0.5)
 half(i64 * 1)
 half(i64 * f64)
 half(i64 ** 0.5)
 half(i64 ** 1)
-half(i64 ** f32)
 half(i64 ** f64)
+half(i64 ** i)
+half(i64 ** i32)
 half(i64 ** i64)
 half(i64 + 0.5)
-half(i64 + 1)
 half(i64 + f32)
 half(i64 + f64)
 half(i64 - 0.5)
 half(i64 - 1)
 half(i64 - f32)
+half(i64 - f64)
 half(i64 / 0.5)
 half(i64 / 1)
 half(i64 / f32)
 half(i64 / f64)
 half(i64 / i)
 half(i64 / i32)
-half(i64 / i64)
 half(i64 ^ 0.5)
 half(i64 ^ 1)
 half(i64 ^ f32)
 half(i64 ^ f64)
+half(i64 ^ i)
 half(i64 ^ i32)
-half(i64 ^ i64)
 half(max(0.5))
-half(max(0.5, f32))
+half(max(0.5)) ** i
 half(max(f64))
+half(mean(array))
+half(median(array))
 half(min(0.5))
-half(min(0.5, 0.5))
-half(min(1, 0.5, 1))
+half(min(0.5, f32))
+half(min(0.5, i32))
 half(min(f64))
-half(ok ? 0.5 : f32)
-half(ok ? 0.5 : false)
-half(ok ? 0.5 : foo)
-half(true ? 0.5 : 0.5)
-hasPrefix("bar", "foo") != ok
-hasSuffix("foo", "foo") or 0.5 <= i
+half(min(i, 0.5))
+half(reduce(array, 0.5))
+half(reduce(array, f64))
+half(reduce(list, 0.5))
+half(reduce(list, f64))
+half(round(0.5))
+half(round(1))
+half(round(f32))
+half(round(f64))
+half(round(i))
+half(round(i32))
+half(round(i64))
+half(score(1) ^ i64)
+half(true ? 0.5 : i64)
+half(true ? f64 : nil)
 i
 i != -0.5
 i != -1
 i != -f32
 i != -f64
 i != -i
-i != -i64
-i != 0.5 / 0.5
-i != 0.5 == ok
-i != 0.5 ? 1 : array
-i != 0.5 ? i32 : 0.5
-i != 0.5 ? score : score
-i != 1 % i64
-i != 1 * i
-i != 1 + 1
-i != 1 - 0.5
-i != 1 - 1
-i != 1 - i64
-i != 1 == ok
-i != 1 ? ok : i64
-i != 1 or i64 != 1
+i != -i32
+i != 0.5 + 0.5
+i != 0.5 - 1
+i != 0.5 / 1
+i != 0.5 ? 1 : div
+i != 0.5 ? false : i32
+i != 0.5 ^ 0.5
+i != 0.5 ^ 1
+i != 0.5 ^ f32
+i != 1 != nil
+i != 1 / 1
+i != 1 ? f64 : score
+i != ceil(1)
+i != ceil(f32)
+i != ceil(i64)
 i != f32
-i != f32 + i
-i != f32 / 1
-i != f32 ? div : list
+i != f32 ** i64
+i != f32 + i64
+i != f32 == ok
 i != f64
-i != f64 * 0.5
-i != f64 + 1
-i != f64 / 0.5
-i != f64 ? 0.5 : nil
-i != f64 ? array : div
-i != f64 ? half : 1
-i != f64 || ok
-i != first(array)
-i != float(1)
-i != float(f32)
-i != float(f64)
+i != f64 + i32
+i != f64 == true
+i != f64 ^ f32
+i != f64 ^ i64
+i != float(0.5)
+i != float(i)
 i != half(0.5)
+i != half(f64)
 i != i
-i != i != nil
-i != i ^ f64
+i != i * 1
+i != i * i32
+i != i - i32
+i != i ? i : false
 i != i32
-i != i32 % i32
-i != i32 * f64
-i != i32 - i64
-i != i32 / i64
-i != i32 ? 1 : i
-i != i32 ? list : i
-i != i32 || half != nil
+i != i32 != nil ? greet : score
+i != i32 * 0.5
+i != i32 * f32
+i != i32 and ok
 i != i64
-i != i64 - f32
-i != i64 ? true : "foo"
-i != i64 ^ f64
+i != i64 ** i
+i != i64 ? add : i64
+i != i64 ? f32 : nil
+i != i64 ^ 1
 i != int(1)
-i != max(i32)
-i != min(1)
-i != nil != true
-i != nil ? ok : "bar"
+i != min(i64)
+i != nil != ok
+i != nil ? ok : f64
+i != reduce(array, #)
+i != reduce(array, 0.5)
+i != reduce(list, 1)
+i != round(f64)
+i != score(1)
 i != score(i)
+i != {"foo": score}?.f32
+i % (1 + i32)
+i % (i32 + i32)
+i % (i64 + 1)
 i % -1
 i % -i
 i % -i32
-i % -i64
-i % 1 != i64
-i % 1 .. i32
-i % 1 / i
+i % 1 % i32
+i % 1 % i64
+i % 1 * i32
+i % 1 + i64
+i % 1 .. i
+i % 1 / 0.5
+i % 1 / f32
+i % 1 <= i64
 i % 1 >= i
-i % 1 >= i32
-i % array[i]
-i % first(array)
-i % get(array, i64)
+i % abs(1)
+i % abs(i)
+i % array[1]
+i % array[i64]
 i % i
-i % i % i32
-i % i + i32
-i % i == i
-i % i in array
+i % i / i
 i % i32
+i % i32 != i32
+i % i32 * 1
+i % i32 * f64
 i % i32 / i32
-i % i32 <= f32
+i % i32 <= f64
 i % i64
-i % i64 != i
-i % int(i64)
-i % len(array)
-i % score(1)
+i % i64 != i ? f64 : list
+i % i64 <= i
+i % min(1)
+i % min(i64)
+i % reduce(array, #)
 i % score(i)
-i * (0.5 + 0.5)
-i * (f32 + f32)
-i * (i32 + 0.5)
-i * (i32 - f64)
-i * (i64 + 1)
-i * -1
-i * -f32
-i * -i
+i * (1 + 1)
+i * (f32 + 0.5)
+i * (f32 + 1)
+i * (f64 + i)
+i * (f64 - i32)
+i * -i32
 i * -i64
 i * 0.5 * f64
 i * 0.5 + i
-i * 0.5 - i
-i * 0.5 < i
-i * 0.5 <= i64 ** f64
-i * 1 % i
-i * 1 ** i32
-i * 1 / f64
-i * 1 / i64
-i * 1 <= f32
-i * abs(0.5)
-i * add(1, 1)
-i * array[i32]
+i * 0.5 / i
+i * 0.5 < i32
+i * 0.5 > i32 * f32
+i * 0.5 ^ 1
+i * 1 % i64
+i * 1 ** 1
+i * 1 < f64
+i * 1 < i32
+i * 1 == i32
+i * bitnand(i64, i64)
+i * bitnot(i64)
+i * ceil(1)
 i * f32
-i * f32 != f32
-i * f32 ** 0.5
-i * f32 >= f32
+i * f32 <= f64
+i * f32 ^ 0.5
+i * f32 ^ 1
 i * f32 ^ f32
 i * f64
-i * f64 * 1
-i * float(f64)
+i * f64 != i
+i * f64 * f32 > i
+i * f64 * i
+i * f64 ** i32
+i * float(f32)
+i * floor(f32)
+i * floor(i)
+i * floor(i32)
+i * floor(i64)
+i * half(0.5)
+i * half(1)
 i * half(f64)
 i * i
-i * i != i64
-i * i / f32
-i * i / f64
-i * i / i32
-i * i / i64
+i * i % i
+i * i * 0.5
+i * i * f32
+i * i ** 0.5
+i * i - f32
+i * i .. i
+i * i == f32
 i * i32
-i * i32 ** f64
-i * i32 ** i32
-i * i32 - i
-i * i32 / i32
-i * i32 <= i32
+i * i32 * i
+i * i32 .. i32
+i * i32 / min(1)
+i * i32 == f32
+i * i32 in array
 i * i64
-i * i64 % i32
-i * i64 * 0.5
-i * i64 + f32
-i * i64 >= i32
-i * i64 ^ i64
-i * int(f64)
-i * int(i)
-i * int(i64)
-i * max(0.5)
-i * min(i64)
+i * i64 < f64
+i * int(1)
+i * max(1)
+i * max(f64, f32)
+i * max(i)
+i * min(f64, i)
+i * reduce(array, #)
 i * score(1)
-i ** (0.5 + f64)
-i ** (0.5 + i64)
-i ** (1 * 1)
-i ** (1 - 0.5)
-i ** (i32 % i64)
-i ** (i32 - 1)
+i * score(i)
+i * sum(array)
+i ** (0.5 * f64)
+i ** (0.5 + 0.5)
+i ** (0.5 - 1)
+i ** (0.5 - f64)
+i ** (0.5 / i32)
+i ** (f32 + 0.5)
+i ** (f32 + f32)
+i ** (i * 0.5)
+i ** (i * 1)
+i ** (i + f64)
+i ** (i - i32 + i32)
+i ** (i32 - i64)
+i ** (i32 / 1)
+i ** (i64 - 0.5)
 i ** -0.5
-i ** -i
+i ** -1
+i ** -f32
 i ** -i32
 i ** -i64
-i ** 0.5 ** 0.5
-i ** 0.5 ** 1
+i ** 0.5 ** f32
+i ** 0.5 ** reduce(array, #)
+i ** 0.5 < bitnot(i64)
 i ** 0.5 < f32
-i ** 0.5 <= i64 ^ i32
-i ** 1 != f64
+i ** 0.5 < f64
+i ** 0.5 <= i64
+i ** 0.5 ^ i
+i ** 0.5 ^ i64
 i ** 1 ** 1
-i ** 1 ** f64
-i ** 1 ** i
-i ** 1 == f32
+i ** 1 / i
+i ** 1 < -f32
+i ** 1 >= f64
+i ** 1 ^ i
+i ** 1 ^ i32
+i ** abs(0.5)
+i ** array[i64]
+i ** bitnand(i32, 1)
+i ** bitshl(i64, i32)
+i ** ceil(1)
 i ** f32
-i ** f32 ** 0.5
-i ** f32 ** f64
-i ** f32 + f64
-i ** f32 <= f32
-i ** f32 <= i32 ? 1 : f32
-i ** f32 >= float(i64)
+i ** f32 * i32
+i ** f32 ** 1
+i ** f32 ^ f64
+i ** f32 ^ i64
 i ** f64
-i ** f64 != f64
-i ** f64 < 1 / 0.5
-i ** float(0.5)
-i ** float(f32)
-i ** float(i32)
+i ** f64 != i32
+i ** f64 ** f64
+i ** f64 > i64 ? 1 : ok
+i ** f64 >= i
+i ** first(array)
+i ** floor(f64)
+i ** half(1)
 i ** half(f64)
+i ** half(i + f32)
 i ** i
-i ** i + f64
-i ** i <= i
-i ** i ^ i
+i ** i != i == ok
+i ** i ^ 0.5
 i ** i32
-i ** i32 != i
-i ** i32 != i32
-i ** i32 + i32
+i ** i32 == f32
+i ** i32 > i64
 i ** i64
-i ** i64 ** 1
-i ** i64 ** f64
-i ** i64 ** i64
-i ** i64 - f64
+i ** i64 ** i
+i ** i64 < i
+i ** i64 == i32
 i ** i64 >= i
-i ** i64 >= i32
-i ** i64 ^ 1
-i ** int(1)
-i ** max(f32)
-i ** min(0.5, 1)
-i ** min(f32)
-i ** min(i)
+i ** i64 ^ i64
+i ** i64 not in array
+i ** len("foo")
+i ** len(array)
+i ** min(1)
 i ** min(i32)
+i ** reduce(array, #)
 i ** score(1)
+i ** score(i)
+i + -0.5
 i + -1
 i + -f32
 i + -f64
-i + -i
-i + 0.5 != i
-i + 0.5 ** i32
-i + 0.5 - i
-i + 0.5 < 1 + f32
-i + 0.5 <= i32
-i + 0.5 > f32
-i + 1 / array[i32]
+i + 0.5 ** 0.5
+i + 0.5 + i
+i + 0.5 / 1
+i + 1 + f32
 i + 1 / f32
-i + 1 <= f32
-i + 1 > i64
-i + 1 >= f64
-i + array[i32]
-i + count(list, false)
+i + 1 > f64
+i + 1 ^ 1
+i + 1 ^ f32
+i + abs(0.5)
+i + array[i64]
+i + array[i]
+i + count(list, true)
 i + f32
-i + f32 != f64
-i + f32 * i
 i + f32 ** i
+i + f32 / f64
+i + f32 / i32
+i + f32 < i64
 i + f64
-i + f64 <= i64
-i + f64 == f64
+i + f64 - i32
+i + f64 < i64
+i + f64 == i32
+i + f64 > f64
 i + float(0.5)
-i + float(f32)
-i + get(array, i64)
-i + half(0.5)
+i + float(i32)
+i + get(array, i)
+i + half(1)
 i + half(f64)
 i + i
-i + i + f32
-i + i - i32
+i + i * i64
+i + i ^ 1
 i + i32
-i + i32 != i64
-i + i32 - 0.5
+i + i32 .. -i64
 i + i32 .. i
-i + i32 > f32
+i + i32 <= f32
+i + i32 == i64
+i + i32 > min(i)
+i + i32 >= i32 == nil
+i + i32 in array
 i + i64
-i + i64 + f64
-i + i64 ^ 1
+i + i64 - f64
+i + i64 / 0.5
+i + i64 / f64
+i + i64 > f32
 i + int(f32)
-i + int(i64)
-i + last(array)
 i + len("bar")
-i + max(0.5)
-i + max(f32)
+i + reduce(array, #)
+i + reduce(array, f32)
+i + reduce(list, i32)
+i + score(i)
+i - -0.5
 i - -1
 i - -f32
-i - -i
+i - -f64
 i - -i64
-i - 0.5 * 0.5
-i - 0.5 * 1
-i - 0.5 / 1
-i - 1 * 1
-i - 1 * i32
-i - 1 - i
+i - 0.5 + i64
+i - 0.5 - 1
+i - 0.5 < f64
+i - 0.5 > i
+i - 0.5 not in array
+i - 1 + i
+i - 1 - i64
+i - 1 .. i64
+i - 1 < i32
+i - 1 <= f64
+i - 1 <= i
+i - 1 > 0.5 - 0.5
 i - 1 ^ 0.5
-i - 1 ^ i32
-i - abs(0.5)
-i - abs(f32)
-i - abs(i32)
+i - bitxor(i, i)
+i - ceil(f64)
 i - f32
-i - f32 * i32
-i - f32 ** 1
-i - f32 + f64
-i - f32 - 1
-i - f32 / 0.5
-i - f32 / f32
-i - f32 / i32
-i - f32 ^ i64
+i - f32 * f32
+i - f32 - i32
+i - f32 / i
+i - f32 ^ 0.5
 i - f64
-i - findIndex(list, ok)
-i - half(0.5)
+i - f64 + i32
+i - f64 + i32 - f64
+i - f64 / i32
+i - f64 ^ i64
+i - find(array, true)
+i - float(0.5)
+i - floor(1)
+i - half(f64)
 i - i
-i - i * 1
-i - i < i + f64
-i - i <= i
-i - i <= i32
-i - i >= f32
-i - i not in array
+i - i + f32
 i - i32
-i - i32 > len(array)
-i - i32 ^ 0.5
+i - i32 + 0.5
+i - i32 - f32
+i - i32 - i32
 i - i64
-i - i64 ** 1
-i - i64 + i32
-i - i64 - 1 / 1
-i - i64 - f64
-i - int(1)
-i - int(f32)
-i - int(i)
-i - last(array)
-i - max(0.5)
+i - i64 .. i32
+i - i64 / i
+i - i64 <= i32
+i - i64 ^ f32
+i - i64 ^ f64
+i - int(i32)
 i - max(i64)
-i - min(f32)
+i - median(array)
+i - round(i32)
 i - score(1)
-i - score(i)
+i .. -i
 i .. -i32
-i .. 1 % i32
-i .. 1 == array
+i .. -i64
 i .. abs(1)
-i .. abs(i32)
 i .. i
-i .. i % 1
 i .. i32
-i .. i32 == array
 i .. i64
-i .. i64 + i
-i .. i64 == list
-i .. int(i64)
-i .. last(array)
-i .. len(list)
-i .. min(1)
+i .. i64 * 1
+i .. i64 + 1
+i .. int(0.5)
+i .. max(1)
+i .. max(i)
+i .. min(i)
+i .. reduce(list, i64)
+i .. score(1)
 i .. score(i)
-i / (f32 + f64)
-i / (f64 + f32)
-i / (i32 + f32)
-i / -0.5
+i / (0.5 + 1)
+i / (0.5 + f64)
+i / (0.5 + i)
+i / (0.5 - f32)
+i / (i + f32)
 i / -1
+i / -f32
+i / -f64
 i / -i32
-i / -i64
-i / 0.5 * f32
+i / 0.5 * 1
 i / 0.5 * f64
-i / 0.5 ** f32
-i / 0.5 / i32
-i / 0.5 < i64
-i / 0.5 <= i64
-i / 0.5 == 0.5 - f64
-i / 0.5 >= i64
-i / 1 ** 1
-i / 1 / i64
-i / 1 == f64
-i / 1 ^ 1
-i / 1 ^ i64
-i / abs(i64)
+i / 0.5 / f64
+i / 0.5 == nil != false
+i / 0.5 >= f32
+i / 0.5 ^ i32
+i / 1 ** i32
+i / 1 <= i64
+i / 1 > i
+i / abs(i)
+i / bitnot(i64)
+i / count(array, false)
 i / f32
-i / f32 != f32
-i / f32 ** i64
-i / f32 / i
+i / f32 != i64 ? 1 : list
+i / f32 >= len(array)
 i / f64
-i / f64 * f32
-i / f64 - f32
-i / float(i32)
-i / half(0.5)
-i / half(f64)
+i / f64 * f64
+i / f64 ^ i32
+i / float(0.5)
+i / float(1)
+i / float(f64)
+i / floor(1)
+i / floor(i32)
 i / i
-i / i != i64
-i / i > i32
-i / i > i64
+i / i ** 1
+i / i / i
+i / i < i32
+i / i ^ 1
 i / i32
-i / i32 - i
-i / i32 / i
-i / i32 / i64
-i / i32 ^ f32
+i / i32 / 1
 i / i64
-i / i64 != i
-i / i64 ** f32
-i / i64 < i % 1
-i / i64 >= i32 ? div : div
-i / len("bar")
-i / len(list)
-i / max(1 / i)
-i / min(0.5)
-i / min(f64)
-i / min(i32)
+i / i64 * f32
+i / i64 / f64
+i / max(0.5)
+i / mean(array)
+i / min(f32)
+i / min(i64)
 i / score(1)
-i / score(i)
-i < -(f32 - 1)
-i < -1
-i < -f32
-i < -i
+i < -(f32 * 1)
+i < --f64
 i < -i32
-i < 0.5 != false
-i < 0.5 != ok
-i < 0.5 * i
-i < 0.5 + 0.5
+i < -i64
+i < 0.5 != nil
+i < 0.5 + f64
 i < 0.5 == ok
-i < 0.5 ? "bar" : "bar"
-i < 0.5 ? f32 : array
-i < 0.5 ? f32 : half
-i < 1 * 1
-i < 1 ** f32
-i < 1 == ok
-i < 1 ? false : nil
-i < abs(f64)
+i < 1 / 0.5
+i < 1 == nil
+i < 1 ? array : score
+i < 1 ^ i64
+i < abs(i32)
 i < f32
-i < f32 * i
-i < f32 ^ f32
+i < f32 && ok
+i < f32 * 0.5
+i < f32 * i64
+i < f32 ** i
+i < f32 ** i32
+i < f32 + 1
+i < f32 + array[i64]
+i < f32 / 0.5
+i < f32 ? "bar" : div
+i < f32 || ok
 i < f64
-i < f64 * f64
-i < findIndex(list, ok)
-i < half(f32 ^ i64)
+i < f64 - 1
+i < float(f64)
+i < floor(f32)
+i < half(0.5)
+i < half(1)
 i < half(f64)
 i < i
-i < i % 1
-i < i / 1
-i < i ? i32 : add
-i < i ^ 0.5
-i < i ^ i32
+i < i != true
+i < i ** 1
+i < i / i64
+i < i ? score : list
 i < i32
-i < i32 ** 0.5
-i < i32 - f32
-i < i32 == nil
+i < i32 * f32
+i < i32 + 1
 i < i64
-i < i64 && ok
-i < i64 - f64
-i < i64 - i32
-i < i64 ? nil : "foo"
-i < i64 ^ 0.5
-i < int(0.5)
-i < int(i64)
-i < len(array)
-i < len(list)
-i < min(i64)
-i < score(1)
-i < score(i)
-i <= -f32
+i < i64 ^ f32
+i < max(0.5)
+i < reduce(array, #)
+i <= -0.5
+i <= -1
+i <= -f64
 i <= -i
+i <= -i32
 i <= -i64
-i <= 0.5 ** 0.5
-i <= 0.5 ** f32
-i <= 0.5 == nil
-i <= 0.5 ? score : array
-i <= 1 != all(array, true)
+i <= 0.5 * f32
+i <= 0.5 + 0.5
+i <= 0.5 / 1
+i <= 0.5 / f64
+i <= 0.5 == ok
+i <= 0.5 ? i : ok
+i <= 0.5 ? nil : i32
+i <= 0.5 ^ f32
 i <= 1 != nil
-i <= 1 % i
-i <= 1 + 1
-i <= 1 - f64
-i <= 1 ? ok : 1
-i <= abs(1)
-i <= abs(i32)
-i <= add(1, 1)
+i <= 1 && ok
+i <= 1 * 0.5
+i <= 1 ** i
+i <= 1 + f64
+i <= 1 - f32
+i <= 1 ? 0.5 : f32
+i <= 1 ? 0.5 : list
+i <= 1 ? list : div
+i <= 1 ^ f32
+i <= abs(0.5)
+i <= ceil(1)
 i <= f32
-i <= f32 != nil
-i <= f32 * 0.5
-i <= f32 / f32
-i <= f32 ? ok : 1
-i <= f32 or ok
+i <= f32 - 0.5
+i <= f32 ? array : nil
 i <= f64
-i <= f64 * 1
-i <= f64 == nil
-i <= f64 ? foo : div
-i <= f64 or add == greet
-i <= float(f64)
-i <= float(i)
-i <= float(i32)
-i <= half(-1)
-i <= half(0.5)
+i <= float(0.5)
+i <= float(f32)
+i <= half(1)
+i <= half(f64)
 i <= i
-i <= i ** 1
-i <= i == true
+i <= i != nil
+i <= i * f32
+i <= i ** f64
+i <= i - 0.5
+i <= i - 1
+i <= i / i
+i <= i ^ 1
 i <= i32
-i <= i32 - f32
-i <= i32 - i64
+i <= i32 - f64
+i <= i32 - i
+i <= i32 == ok
+i <= i32 ? array : false
+i <= i32 ? greet : foo
+i <= i32 || false ? f32 : i32
 i <= i64
-i <= i64 % i32
-i <= i64 / 1
-i <= i64 ? ok : 1
-i <= int(1)
-i <= int(i32)
-i <= len("bar")
-i <= len(array)
-i <= max(i)
-i <= min(f32)
-i <= min(f64)
-i <= min(i)
-i <= min(i64)
-i == -0.5
-i == -1
+i <= i64 * i
+i <= i64 + f64
+i <= len(list)
+i <= max(0.5)
+i <= max(f32, i32)
+i <= round(f32)
+i <= round(i32)
+i <= score(1)
 i == -f32
 i == -f64
 i == -i
 i == -i32
 i == -i64
-i == 0.5 + f32
-i == 0.5 - i32
+i == 0.5 ** f64
 i == 0.5 == ok
-i == 0.5 ? false : true
-i == 0.5 ? list : i32
-i == 0.5 ^ 0.5
-i == 1 != true
-i == 1 % i
-i == 1 * f32
-i == 1 ** 1
-i == 1 ? foo : list
-i == 1 || ok
-i == abs(0.5)
-i == abs(1)
-i == div(1, i)
+i == 0.5 ? "foo" : f64
+i == 1 * 0.5
+i == 1 ** i64
+i == 1 / 0.5
+i == 1 / f32
+i == 1 ? f32 : 1
+i == 1 ? f64 : f64
+i == 1 ? greet : score
+i == abs(i64)
+i == bitnot(1)
 i == f32
-i == f32 * i64
+i == f32 + i
+i == f32 == nil
+i == f32 ? foo : foo
+i == f32 ^ i32
 i == f64
-i == f64 != nil
-i == f64 + i64
-i == f64 == ok
+i == f64 + i32
+i == f64 - i
+i == f64 ? i64 : div
+i == f64 ? score : foo
+i == f64 and ok
+i == findIndex(list, true)
+i == float(0.5)
+i == floor(f32)
+i == floor(i32)
+i == half(0.5)
+i == half(f64)
 i == i
-i == i - f64
-i == i / i32
-i == i ? ok : score
-i == i ^ i
+i == i + 0.5
+i == i - i32
+i == i == true
+i == i ? add : i32
+i == i ? i32 : add
+i == i and ok
 i == i32
-i == i32 ** f32
-i == i32 ** i
-i == i32 ? list : foo
+i == i32 * 0.5
+i == i32 ** 0.5
+i == i32 + 0.5
+i == i32 + i64
+i == i32 ^ f32
 i == i64
-i == i64 != ok
-i == i64 + i32
-i == i64 ? array : 0.5
-i == i64 ? score : 1
-i == i64 ^ f64
-i == int(f64)
-i == len(array)
-i == max(0.5)
-i == max(i64)
-i == min(i)
-i == nil ? false : 1
+i == i64 * 0.5
+i == i64 * f32
+i == i64 ** 0.5
+i == i64 == nil
+i == i64 == ok
+i == i64 ? list : div
+i == len("bar")
+i == nil ? 0.5 : div
+i == nil ? div : i32
+i == nil and add != nil
+i == reduce(array, #)
+i == reduce(array, 0.5)
 i == score(1)
-i > -i64
-i > 0.5 * f64
-i > 0.5 ** 0.5
-i > 0.5 / 0.5
-i > 0.5 / 1
-i > 0.5 == nil
-i > 0.5 ^ 0.5
-i > 1 ? greet : "bar"
-i > 1 ? greet : f64
-i > abs(i64)
-i > array[i]
+i == score(i)
+i > -f32
+i > -f64
+i > -i
+i > -i32
+i > 0.5 - 0.5
+i > 0.5 ^ i64
+i > 0.5 or ok
+i > 0.5 || ok
+i > 1 != ok
+i > 1 % i64
+i > 1 ** i32
+i > 1 == ok
+i > 1 ? greet : nil
+i > 1 ? score : 0.5
+i > 1 ? true : greet
+i > bitnot(1)
+i > bitor(1, i32)
+i > count(array, true)
 i > f32
+i > f32 ** i32
+i > f32 - f64
+i > f32 ^ 1
 i > f64
-i > f64 + 0.5
-i > float(1)
-i > half(f64)
+i > f64 != ok
+i > f64 * 1
+i > f64 * f32
+i > f64 ** i32
+i > f64 ? foo : array
+i > f64 ? greet : "bar"
+i > first(array)
+i > floor(f64)
 i > i
-i > i ** i32
-i > i ** i64
-i > i / i
-i > i or ok
+i > i % i32
+i > i ** i
+i > i + i
+i > i ? f32 : i32
 i > i32
-i > i32 ? 1 : true
-i > i32 ? foo : score
-i > i32 ^ i
+i > i32 * 1
+i > i32 * i32
+i > i32 + 1
+i > i32 == ok
 i > i64
-i > int(0.5)
-i > int(i)
-i > int(i32)
-i > max(f32)
-i > max(i)
-i > min(0.5)
-i > score(i)
-i > score(len(array))
+i > i64 && f32 < 0.5
+i > i64 + 0.5
+i > i64 - 0.5
+i > i64 - i
+i > int(f32)
+i > len("bar")
+i > reduce(list, i32)
 i >= -0.5
 i >= -1
+i >= -f32
+i >= -i
 i >= -i32
 i >= -i64
-i >= 0.5 ** f64
-i >= 0.5 + i32
-i >= 0.5 - 1
-i >= 0.5 == nil
-i >= 0.5 ? div : i
-i >= 0.5 ? score : f64
-i >= 1 / i
-i >= 1 ? nil : 0.5
-i >= abs(0.5)
-i >= abs(i64)
+i >= 0.5 / 1
+i >= 0.5 ? i64 : array
+i >= 0.5 ? nil : ok
+i >= 0.5 ^ i
+i >= 1 * i64
+i >= 1 + f32
+i >= 1 == nil
+i >= 1 ? f32 : nil
+i >= 1 ? ok : false
+i >= 1 ^ f64
+i >= bitnot(i)
 i >= f32
-i >= f32 ** f64
-i >= f32 - i
-i >= f32 ? "bar" : array
-i >= f32 ? score : half
+i >= f32 ? f32 : i
+i >= f32 ? true : list
 i >= f64
-i >= f64 * i32
-i >= f64 + i32
-i >= f64 - i
+i >= f64 * 0.5
+i >= f64 - 1
+i >= first(array)
+i >= float(0.5)
+i >= float(1)
+i >= get(array, i64)
+i >= half(f64)
 i >= i
-i >= i ** 0.5
-i >= i / 1
-i >= i / i
-i >= i == nil
-i >= i == ok
+i >= i * 1
+i >= i ** f32
+i >= i ? foo : div
 i >= i32
-i >= i32 ** 0.5
-i >= i32 - f64
-i >= i32 ? f64 : div
+i >= i32 ** i64
+i >= i32 ? f32 : div
+i >= i32 ^ 1
 i >= i64
-i >= i64 * i
-i >= i64 ^ 0.5
-i >= int(i32)
-i >= len("foo")
-i >= min(f32 ^ i64)
+i >= int(0.5)
+i >= min(0.5)
+i >= reduce(array, f64)
+i >= reduce(array, i)
+i >= reduce(list, 1)
+i >= round(1)
+i >= score(1)
 i >= score(i)
-i ^ (0.5 * 1)
-i ^ (0.5 - 0.5)
-i ^ (f32 * 1)
-i ^ (f32 * f32)
-i ^ (f32 * f64)
-i ^ (f32 / f64)
-i ^ (i * 1)
-i ^ (i - i64)
-i ^ (i32 % 1)
-i ^ (i32 + i)
-i ^ (i32 / 0.5)
-i ^ (i64 / 0.5)
-i ^ (i64 / 1)
-i ^ --f32
+i ^ (1 % i)
+i ^ (1 * f64)
+i ^ (1 - 0.5)
+i ^ (f32 - f64)
+i ^ (f64 - 1)
+i ^ (i + 0.5)
+i ^ (i + i64)
+i ^ (i - f32)
+i ^ (i32 * i32)
+i ^ (i32 + 1)
+i ^ (i32 / f32)
+i ^ (i32 / i)
+i ^ (i64 * 1)
 i ^ -1
+i ^ -f32
+i ^ -f64
 i ^ -i
-i ^ -i32
-i ^ -i64
-i ^ 0.5 != 1 + i
-i ^ 0.5 * f32
-i ^ 0.5 - i
-i ^ 0.5 / f64
-i ^ 0.5 <= f32
-i ^ 0.5 > i64
+i ^ 0.5 ** 0.5
+i ^ 0.5 + i32
+i ^ 0.5 < f64
+i ^ 0.5 < i
+i ^ 0.5 <= i64
+i ^ 0.5 > f64
+i ^ 0.5 >= f32
+i ^ 0.5 >= reduce(array, #)
 i ^ 0.5 ^ f32
-i ^ 1 != f32
-i ^ 1 * f32
-i ^ 1 ** i
-i ^ 1 - f32
-i ^ 1 / i32
-i ^ 1 ^ i64
-i ^ abs(1)
-i ^ abs(f32)
-i ^ abs(i64)
-i ^ add(1, 1)
-i ^ array[i]
+i ^ 0.5 ^ i64
+i ^ 1 * f64
+i ^ 1 / i
+i ^ 1 >= f32
+i ^ 1 ^ i
+i ^ 1 not in array
+i ^ bitnot(i64 + 1)
+i ^ bitnot(min(i))
+i ^ ceil(0.5)
 i ^ f32
-i ^ f32 != 1 - i
-i ^ f32 != i64 ? list : i32
-i ^ f32 + f64
-i ^ f32 / i
+i ^ f32 ** 1
 i ^ f32 < i
-i ^ f32 >= i32
+i ^ f32 <= -f32
 i ^ f64
-i ^ f64 * i
-i ^ f64 >= f64
-i ^ find(array, true)
-i ^ float(f64)
+i ^ f64 ** 0.5
+i ^ f64 - f64
+i ^ f64 / i32
+i ^ f64 <= f32
+i ^ f64 == i
+i ^ f64 > f32
+i ^ find(array, ok)
+i ^ floor(i32)
+i ^ half(0.5)
+i ^ half(1)
+i ^ half(f64)
 i ^ i
-i ^ i ** f64
-i ^ i + i32
-i ^ i >= f64
+i ^ i * i
+i ^ i * i64
+i ^ i ** i
+i ^ i / i
 i ^ i32
-i ^ i32 - f32
-i ^ i32 == i64 * i
-i ^ i32 >= f64
-i ^ i32 >= max(i64)
+i ^ i32 / f64
+i ^ i32 in array
 i ^ i64
-i ^ i64 * i64
-i ^ i64 ** i
-i ^ i64 == f32
-i ^ i64 >= i64 ^ f32
-i ^ i64 ^ f64
-i ^ int(f32)
-i ^ max(1)
-i ^ min(i32)
+i ^ i64 != f32 + 1
+i ^ i64 ** f32
+i ^ last(array)
+i ^ median(array)
+i ^ min(i32, 1)
+i ^ reduce(array, #)
+i ^ round(i32)
 i ^ score(1)
+i in 1 .. i
 i in array
-i in array == ok
-i in array ? f32 : greet
-i in array ? foo : false
-i in array || ok
+i in array != nil
+i in array ? nil : 1
+i in groupBy(list, #)
+i in groupBy(list, foo)
+i in map(array, #)
+i in map(array, i64)
+i not in 1 .. 1
 i not in array
-i not in array ? foo : list
-i not in array and true
+i not in groupBy(array, #)
+i not in groupBy(list, #)
 i not in i64 .. 1
+i not in i64 .. i64
 i not in map(array, #)
-i not in {"foo": 1}.div
+i not in map(list, i32)
 i32
 i32 != -0.5
 i32 != -1
 i32 != -f32
 i32 != -i
-i32 != 0.5 && nil == i64
+i32 != -i32
+i32 != -i64
+i32 != 0.5 - 0.5
+i32 != 0.5 - i32
+i32 != 0.5 / f32
+i32 != 0.5 ^ 0.5
+i32 != 0.5 ^ i64
+i32 != 0.5 || ok
+i32 != 1 % i64
 i32 != 1 && ok
-i32 != 1 * i64
-i32 != 1 + 1
-i32 != 1 / 1
-i32 != 1 ? 0.5 : greet
-i32 != 1 ? false : i64
-i32 != 1 ? greet : half
-i32 != 1 ? greet : ok
-i32 != abs(i64)
-i32 != array[i]
-i32 != count(array, ok)
+i32 != 1 * f32
+i32 != 1 ? "foo" : array
+i32 != 1 ? greet : "foo"
+i32 != array[i64]
+i32 != bitnot(i)
+i32 != bitnot(i64)
+i32 != ceil(1)
+i32 != ceil(f64)
+i32 != count(array, false)
 i32 != f32
-i32 != f32 && ok
-i32 != f32 / f64
-i32 != f32 ? f64 : i32
-i32 != f32 and ok
+i32 != f32 == true
+i32 != f32 ? false : 0.5
+i32 != f32 ? i : 0.5
 i32 != f64
-i32 != f64 == true
-i32 != findIndex(list, false)
-i32 != first(array)
-i32 != float(i)
-i32 != get(array, i64)
-i32 != half(f64)
+i32 != f64 ** i
+i32 != f64 - 1
+i32 != f64 ? 1 : add
+i32 != findLastIndex(array, false)
+i32 != get(array, 1)
+i32 != half(1)
 i32 != i
-i32 != i ** 1
-i32 != i ** f64
+i32 != i + 1
 i32 != i32
-i32 != i32 * 1
-i32 != i32 - 0.5
-i32 != i32 ? array : add
+i32 != i32 ** 0.5
+i32 != i32 + 0.5
+i32 != i32 ^ i64
 i32 != i64
-i32 != i64 % i32
-i32 != i64 * 0.5
-i32 != i64 ? div : nil
-i32 != i64 ? true : nil
-i32 != int(f32)
-i32 != max(1)
-i32 != max(f64, 0.5)
-i32 != min(1, 0.5, f64)
-i32 != min(i)
-i32 != nil ? half : 1
-i32 != nil ? list : half(nil)
-i32 % -i
+i32 != i64 * i64
+i32 != i64 / 0.5
+i32 != i64 / f32
+i32 != len(list)
+i32 != max(f64)
+i32 != min(1)
+i32 != min(i32)
+i32 != nil != false
+i32 != nil ? f64 : "foo"
+i32 != reduce(array, #)
+i32 != reduce(array, i)
+i32 != reduce(list, f32)
+i32 != round(1)
+i32 % -1
 i32 % -i32
-i32 % 1 != i64
-i32 % 1 % (i64 + i64)
-i32 % 1 % i64
-i32 % 1 * f64
-i32 % 1 + f64
+i32 % 1 % i32
+i32 % 1 * f32
+i32 % 1 * i
+i32 % 1 * i32
+i32 % 1 .. i
+i32 % 1 / 0.5
+i32 % 1 / i32
 i32 % 1 > i
-i32 % add(1, 1)
-i32 % count(list, ok)
+i32 % array[i64]
+i32 % get(array, 1)
 i32 % i
-i32 % i != f32
+i32 % i != i
+i32 % i < i
 i32 % i32
-i32 % i32 != i
-i32 % i32 * f32
-i32 % i32 * i
+i32 % i32 != f64
+i32 % i32 * i64
+i32 % i32 == i32
+i32 % i32 >= i64
 i32 % i64
-i32 % i64 != f32
-i32 % i64 / i32
-i32 % i64 == i
-i32 % i64 >= i64
-i32 % min(1, i64)
-i32 % min(i)
+i32 % i64 % i
+i32 % i64 * i64
+i32 % i64 + i
+i32 % i64 .. i
+i32 % i64 / i
+i32 % i64 == f64
+i32 % max(i32)
+i32 % reduce(array, #)
+i32 % score(1)
+i32 * (1 + f32)
+i32 * (1 + f64)
 i32 * (f32 + 1)
-i32 * (f32 + f32)
-i32 * (f32 + i)
-i32 * (f64 - f32)
-i32 * (i32 - 0.5)
+i32 * (f32 - i)
+i32 * (f64 + 0.5)
+i32 * (f64 + i)
+i32 * (i - f32)
+i32 * (i32 + i64)
+i32 * (i32 - 1)
 i32 * (i32 - f64)
-i32 * (i32 - i64)
+i32 * -0.5
+i32 * -1
 i32 * -f32
-i32 * -f64
-i32 * -i
-i32 * 0.5 ** 0.5
-i32 * 0.5 + f64
-i32 * 0.5 <= f32
-i32 * 1 % i64
-i32 * 1 * f32
-i32 * 1 * i32
-i32 * 1 < i
-i32 * array[i32]
-i32 * count(array, true)
+i32 * -i32
+i32 * -i64
+i32 * 0.5 * 0.5
+i32 * 0.5 / 0.5
+i32 * 0.5 / 1
+i32 * 0.5 / i32
+i32 * 0.5 == f64
+i32 * 0.5 == i64
+i32 * 0.5 ^ f64
+i32 * 0.5 ^ i32
+i32 * 1 * i
+i32 * 1 ** i64
+i32 * 1 + f64
+i32 * 1 - i64
+i32 * 1 > half(0.5)
+i32 * 1 ^ 1
+i32 * abs(i32)
+i32 * bitnot(i32)
+i32 * ceil(1)
 i32 * f32
-i32 * f32 != i
+i32 * f32 + f32
+i32 * f32 / i
+i32 * f32 <= f64
+i32 * f32 <= i32
+i32 * f32 ^ f32
 i32 * f64
-i32 * f64 * i
-i32 * f64 + f32
-i32 * f64 / i
-i32 * f64 > i32
+i32 * f64 * 1
+i32 * f64 >= f32
+i32 * first(array)
+i32 * float(f32)
+i32 * float(f64)
+i32 * floor(f64)
+i32 * half(0.5)
+i32 * half(1)
 i32 * i
-i32 * i != i32
-i32 * i * 0.5
-i32 * i .. i
-i32 * i / array[i32]
-i32 * i / i32
+i32 * i / -i
+i32 * i / f32
 i32 * i / i64
+i32 * i < f32
 i32 * i32
-i32 * i32 % i32
-i32 * i32 * 0.5
-i32 * i32 ** 1
-i32 * i32 - f32
-i32 * i32 == i32
+i32 * i32 != f64
+i32 * i32 % i64 / i
+i32 * i32 / i64
+i32 * i32 < i64
+i32 * i32 >= f32
 i32 * i64
 i32 * i64 % 1
-i32 * i64 .. i
-i32 * i64 / 1
-i32 * i64 / i32
-i32 * int(f32)
-i32 * max(f64)
+i32 * i64 % 1 % 1
+i32 * i64 ** i64
+i32 * i64 / f32
+i32 * i64 < i
+i32 * len("foo")
+i32 * max(i32)
 i32 * max(i64)
-i32 * min(1)
-i32 ** (0.5 * 0.5)
-i32 ** (0.5 + 0.5)
-i32 ** (0.5 + i32)
-i32 ** (0.5 / f64)
-i32 ** (f32 / i)
-i32 ** (f64 + 0.5)
-i32 ** (i + 1)
-i32 ** (i64 - i)
-i32 ** -1 ^ i32
-i32 ** -f32
-i32 ** -i32
+i32 * median(array)
+i32 * min(0.5)
+i32 * min(i)
+i32 * reduce(array, #)
+i32 * round(i)
+i32 * score(1)
+i32 * score(i)
+i32 ** (0.5 - i32)
+i32 ** (1 * i64)
+i32 ** (1 / 0.5)
+i32 ** (f32 * i64)
+i32 ** (i % i32)
+i32 ** (i - i)
+i32 ** (i - i32)
+i32 ** (i / 0.5)
+i32 ** (i32 / i64)
+i32 ** (i64 + 0.5)
+i32 ** (i64 - 1)
+i32 ** -1
+i32 ** -f64
+i32 ** -i
 i32 ** -i64
-i32 ** 0.5 / f32
-i32 ** 0.5 <= i32
+i32 ** 0.5 * i64
+i32 ** 0.5 - f64
+i32 ** 0.5 / reduce(array, #)
 i32 ** 0.5 ^ i
 i32 ** 1 ** i64
-i32 ** 1 + f64
-i32 ** 1 + i64
-i32 ** 1 - f32
-i32 ** 1 >= i64 * 0.5
-i32 ** 1 ^ f64
-i32 ** array[i]
+i32 ** 1 + f32
+i32 ** 1 / i64
+i32 ** 1 <= i
+i32 ** 1 ^ i64
+i32 ** 1 in array
+i32 ** array[1]
+i32 ** array[i64]
+i32 ** bitnot(i64)
+i32 ** ceil(1)
+i32 ** ceil(f64)
 i32 ** f32
-i32 ** f32 ** i
-i32 ** f32 == i64
+i32 ** f32 / score(1)
+i32 ** f32 < f32
+i32 ** f32 <= i
+i32 ** f32 == f32
 i32 ** f64
-i32 ** f64 != i64 ? i : half
-i32 ** f64 + f64
-i32 ** f64 >= i
-i32 ** f64 ^ f32
-i32 ** float(1)
-i32 ** float(f64)
+i32 ** f64 == f32
+i32 ** f64 > i
+i32 ** find(array, ok)
+i32 ** float(i32)
 i32 ** half(0.5)
+i32 ** half(1)
+i32 ** half(f64)
 i32 ** i
-i32 ** i ** 0.5
-i32 ** i ^ 0.5
+i32 ** i * f64
+i32 ** i ** i
+i32 ** i ^ i
 i32 ** i32
+i32 ** i32 ^ i64
 i32 ** i64
-i32 ** i64 != 0.5 == true
-i32 ** i64 - f64
-i32 ** i64 / f64
-i32 ** i64 / i
-i32 ** i64 > i
-i32 ** i64 ^ 1
-i32 ** i64 ^ i
-i32 ** int(0.5)
-i32 ** int(f64)
-i32 ** len(array)
-i32 ** min(f64)
-i32 ** min(i32)
-i32 ** score(1)
-i32 ** score(i)
+i32 ** int(1)
+i32 ** int(i32)
+i32 ** len("foo")
+i32 ** len(list)
+i32 ** max(f32, i32)
+i32 ** min(0.5)
+i32 ** min(i64)
+i32 ** reduce(array, 1)
+i32 ** reduce(array, i64)
+i32 ** reduce(list, i64)
+i32 ** round(i64)
+i32 ** sum(array)
 i32 + -0.5
 i32 + -1
-i32 + -f32
-i32 + -f64
 i32 + -i
 i32 + -i32
-i32 + 0.5 * 0.5
-i32 + 0.5 * i32
+i32 + -i64
+i32 + 0.5 != f32
+i32 + 0.5 != i32
+i32 + 0.5 * i
+i32 + 0.5 + 0.5
 i32 + 0.5 + 1
+i32 + 0.5 + f32
+i32 + 0.5 + f64
+i32 + 0.5 + i
 i32 + 0.5 + i64
-i32 + 0.5 - 0.5
-i32 + 0.5 - f32
-i32 + 0.5 <= i
-i32 + 0.5 > i % 1
-i32 + 0.5 >= i
-i32 + 1 / f64
-i32 + 1 < i32
-i32 + 1 ^ i
-i32 + 1 ^ i32
-i32 + abs(i32)
-i32 + count(array, false)
+i32 + 0.5 / i64
+i32 + 0.5 <= -f32
+i32 + 1 % 1
+i32 + 1 + i64
+i32 + 1 - f32
+i32 + 1 - i
+i32 + 1 - i64
+i32 + 1 / i
+i32 + 1 ^ f32
+i32 + abs(f32)
+i32 + array[i64]
+i32 + bitnot(i32)
+i32 + ceil(i)
 i32 + f32
+i32 + f32 / i
+i32 + f32 < i32
+i32 + f32 <= i64
 i32 + f64
 i32 + f64 * 1
-i32 + f64 * f64
-i32 + f64 ** 0.5
-i32 + f64 - f32 * 0.5
-i32 + f64 == i32
-i32 + f64 >= i
+i32 + f64 * i32
+i32 + f64 > i32
+i32 + f64 ^ 0.5
 i32 + f64 ^ i32
-i32 + find(array, ok)
+i32 + findIndex(list, true)
+i32 + floor(0.5)
+i32 + floor(f64)
 i32 + i
-i32 + i * 1
-i32 + i - f32
-i32 + i > half(f64)
-i32 + i >= -1
+i32 + i + f64
+i32 + i + i64
+i32 + i - 0.5
+i32 + i - i64
+i32 + i <= i32
+i32 + i > i64
 i32 + i32
-i32 + i32 ** 0.5
-i32 + i32 >= f32
-i32 + i32 ^ i64
+i32 + i32 + f64
+i32 + i32 <= i + i64
+i32 + i32 > i
+i32 + i32 > i32
 i32 + i64
-i32 + i64 + i64
-i32 + i64 / f64
-i32 + i64 <= f32
-i32 + i64 ^ f32
-i32 + i64 not in array
-i32 + int(f64)
-i32 + last(array)
-i32 + len("foo")
-i32 + len(list)
-i32 + min(0.5, i32)
-i32 + min(1, i)
-i32 + min(i)
-i32 + min(i, i32)
+i32 + i64 % i32
+i32 + i64 ** 1
+i32 + i64 - 0.5
+i32 + i64 - f32
+i32 + i64 / 0.5
+i32 + i64 ^ 1
+i32 + int(i64)
+i32 + len("bar")
+i32 + min(i32)
+i32 + reduce(array, #)
+i32 + round(f32)
+i32 + round(i32)
 i32 + score(i)
 i32 - -0.5
 i32 - -1
 i32 - -f32
-i32 - -i32
-i32 - -i64
-i32 - 0.5 * 0.5
-i32 - 0.5 * i64
-i32 - 0.5 + i
-i32 - 0.5 + i32
-i32 - 0.5 - f32
-i32 - 0.5 < i32
-i32 - 0.5 <= f64
-i32 - 1 != f32
-i32 - 1 * f32
-i32 - 1 ** i32
-i32 - 1 / 0.5
-i32 - 1 <= i64
-i32 - 1 not in array
-i32 - array[1]
+i32 - -i
+i32 - 0.5 * f32
+i32 - 0.5 + half(0.5)
+i32 - 0.5 - i32
+i32 - 0.5 <= f32
+i32 - 0.5 ^ 0.5
+i32 - 1 ** i
+i32 - 1 + 0.5
+i32 - 1 > -i64
+i32 - abs(i32)
+i32 - abs(i64)
+i32 - array[i]
+i32 - bitushr(i32, i64)
+i32 - div(1, i)
+i32 - div(i, i)
 i32 - f32
-i32 - f32 * f32
-i32 - f32 ** f64
-i32 - f32 + 0.5
-i32 - f32 / f64
+i32 - f32 * 0.5
+i32 - f32 + i32
+i32 - f32 - int(f64)
+i32 - f32 / i32
+i32 - f32 < i64
+i32 - f32 <= f32
+i32 - f32 <= i32
+i32 - f32 > i
+i32 - f32 >= f32
 i32 - f64
-i32 - f64 ** f64
-i32 - f64 + 0.5
-i32 - f64 - i64
-i32 - f64 / i64
-i32 - f64 < i64
-i32 - first(array)
-i32 - float(i)
-i32 - get(array, i64)
+i32 - f64 + f32
+i32 - float(0.5)
+i32 - float(1)
+i32 - float(f64)
+i32 - floor(1)
+i32 - floor(f64)
+i32 - get(array, i)
+i32 - half(0.5)
+i32 - half(f64)
 i32 - i
-i32 - i % i
-i32 - i + f32
-i32 - i - 1
-i32 - i / i
-i32 - i <= i64
-i32 - i == i
+i32 - i ** i64
+i32 - i + i32
+i32 - i / 0.5
+i32 - i == f32
 i32 - i > f64
-i32 - i >= f64
+i32 - i > i
+i32 - i >= i64
 i32 - i32
-i32 - i32 ** 0.5
-i32 - i32 <= i32 + i64
-i32 - i32 ^ 1
+i32 - i32 != i64
+i32 - i32 * 1
+i32 - i32 * i32
+i32 - i32 + 1
+i32 - i32 < i32
+i32 - i32 > i64
+i32 - i32 > i64 / i
 i32 - i64
-i32 - i64 % i
-i32 - i64 % i64
-i32 - i64 .. i
-i32 - i64 <= i
-i32 - i64 ^ 0.5
-i32 - i64 ^ f64
-i32 - int(1)
-i32 - int(f64)
-i32 - max(i64)
-i32 - max(i64, i)
-i32 - min(0.5)
-i32 - score(i)
-i32 .. -1
-i32 .. -i
-i32 .. -i32
+i32 - i64 != -f32
+i32 - i64 / 1
+i32 - i64 == f64
+i32 - len(array)
+i32 - len(list)
+i32 - max(f32)
+i32 - score(1)
 i32 .. -i64
-i32 .. 1 - 1
-i32 .. abs(i)
-i32 .. array[i32]
-i32 .. count(array, ok)
+i32 .. abs(i64)
+i32 .. bitnot(i64)
+i32 .. bitushr(i, 1)
+i32 .. count(array, true)
+i32 .. div(i, 1)
 i32 .. i
-i32 .. i - 1
 i32 .. i32
-i32 .. i32 != list
 i32 .. i64
-i32 .. i64 - i32
-i32 .. int(0.5)
-i32 .. len(list)
-i32 .. min(1)
-i32 .. min(1, 0.5)
-i32 .. min(i32)
-i32 .. min(i64)
+i32 .. int(f32)
+i32 .. len("foo")
+i32 .. max(1)
+i32 .. max(i32)
+i32 .. max(i32, 0.5)
 i32 .. score(i)
-i32 / (0.5 + i32)
-i32 / (1 + f32)
-i32 / (1 - f32)
-i32 / (1 - i)
-i32 / (f32 + i)
-i32 / (f32 - f64)
-i32 / (f64 + 0.5)
-i32 / (f64 - 1)
-i32 / (i32 - 1)
+i32 / (1 + 1)
+i32 / (1 + i64)
+i32 / (f64 - i64)
+i32 / (i32 + i64)
+i32 / (i64 + 0.5)
 i32 / -0.5
-i32 / -1
 i32 / -f32
 i32 / -i
 i32 / -i32
+i32 / -i64
 i32 / 0.5 * i
+i32 / 0.5 * i / 1
+i32 / 0.5 + i64
+i32 / 0.5 - i32
+i32 / 0.5 / i32
 i32 / 0.5 / i64
-i32 / 0.5 >= f64
-i32 / 1 != f64
-i32 / 1 < i32
+i32 / 0.5 >= i64
+i32 / 0.5 ^ 1
+i32 / 0.5 ^ f64
+i32 / 1 != i
+i32 / 1 * i64
+i32 / 1 ** 1
+i32 / 1 ^ 0.5
 i32 / abs(0.5)
+i32 / abs(1)
+i32 / abs(f64)
+i32 / abs(i32)
+i32 / array[1]
+i32 / ceil(i32)
 i32 / f32
+i32 / f32 ** 1
+i32 / f32 / i64
+i32 / f32 <= i32
+i32 / f32 <= i64
+i32 / f32 >= i32 == false
 i32 / f64
-i32 / f64 * i32
+i32 / f64 != f64
+i32 / f64 != i64
+i32 / f64 * 1
+i32 / f64 - i32
+i32 / f64 == i64
 i32 / f64 >= f32
-i32 / half(f64)
+i32 / find(array, ok)
+i32 / float(f32)
+i32 / floor(1)
+i32 / floor(f64)
+i32 / half(0.5)
 i32 / i
-i32 / i <= i
+i32 / i * i32
+i32 / i ^ i32
 i32 / i32
-i32 / i32 * 1
-i32 / i32 / f32 / f64
+i32 / i32 * f64
 i32 / i32 / i64
+i32 / i32 <= i64
 i32 / i64
-i32 / i64 != i64
-i32 / i64 * i
-i32 / i64 / i
-i32 / i64 == f32
-i32 / i64 == f64
-i32 / int(i)
-i32 / len("bar")
+i32 / i64 ** f32
+i32 / i64 ^ 0.5
+i32 / int(1)
 i32 / len("foo")
-i32 / max(i32)
+i32 / max(1)
+i32 / max(i)
 i32 / min(f32)
-i32 / min(f64)
-i32 / min(i)
-i32 / min(i32)
-i32 < -(i - f32)
-i32 < -0.5
+i32 / reduce(array, #)
+i32 / score(i)
 i32 < -f32
+i32 < -f64
 i32 < -i32
 i32 < 0.5 ** i32
+i32 < 0.5 - 1
 i32 < 0.5 - f32
-i32 < 0.5 ^ 1
-i32 < 1 % 1
-i32 < 1 ** 1
-i32 < 1 + 0.5
-i32 < 1 + 1
-i32 < 1 ? "foo" : i32
-i32 < 1 ? 1 : 0.5
-i32 < 1 ^ i32
-i32 < abs(i64)
-i32 < div(1, 1)
+i32 < 0.5 / 1
+i32 < 0.5 == nil
+i32 < 0.5 ? "foo" : half
+i32 < 0.5 ? foo : 1
+i32 < 0.5 or ok
+i32 < 0.5 || ok
+i32 < 1 * f32
+i32 < 1 + i64
+i32 < 1 / f32
+i32 < 1 ^ i
+i32 < abs(f64)
 i32 < f32
-i32 < f32 == nil
-i32 < f32 ? div : true
-i32 < f32 || i64 != f32
+i32 < f32 * i
+i32 < f32 - 0.5
+i32 < f32 - 1
 i32 < f64
-i32 < f64 != nil
-i32 < f64 != true
-i32 < f64 * f32
-i32 < f64 == nil
-i32 < f64 ? f32 : half
-i32 < f64 ? greet : false
-i32 < f64 ? list : i32
-i32 < f64 ^ f32
-i32 < f64 || 1 < 1
-i32 < float(i)
-i32 < float(i32)
-i32 < half(0.5)
+i32 < f64 * i64
+i32 < float(reduce(array, f32))
+i32 < get(array, i32)
+i32 < get(array, i64)
+i32 < half(1)
+i32 < half(f64)
 i32 < i
-i32 < i != true
-i32 < i ^ 0.5
+i32 < i ** i64
+i32 < i + 0.5
+i32 < i / i32
+i32 < i ? score : score
 i32 < i32
-i32 < i32 != ok
-i32 < i32 * f32
-i32 < i32 / i32
-i32 < i32 ? ok : 1
+i32 < i32 % i
+i32 < i32 ** 1
+i32 < i32 - f32
+i32 < i32 ^ i64
 i32 < i64
-i32 < i64 - 0.5
-i32 < i64 ^ f64
+i32 < i64 ** 0.5
+i32 < i64 + f32
+i32 < i64 / f64
 i32 < int(0.5)
-i32 < int(i32)
-i32 < int(i64)
-i32 < max(0.5)
-i32 < max(1)
-i32 < min(1, i32)
+i32 < last(array)
+i32 < min(1)
 i32 < min(f64)
-i32 < min(i)
-i32 < min(i64)
+i32 < min(i32)
 i32 < score(1)
+i32 < score(i)
 i32 <= -0.5
 i32 <= -f32
 i32 <= -i
 i32 <= -i32
-i32 <= 0.5 != nil
-i32 <= 0.5 != ok
-i32 <= 0.5 * 0.5
-i32 <= 0.5 * i
-i32 <= 0.5 + i64
-i32 <= 1 ? i : f32
-i32 <= 1 ? true : true
-i32 <= 1 or 0.5 == 0.5
-i32 <= abs(i32)
-i32 <= count(list, ok)
+i32 <= -i64
+i32 <= 0.5 - f64
+i32 <= 0.5 == nil
+i32 <= 0.5 ? i32 : greet
+i32 <= 0.5 ? i32 : half
+i32 <= 0.5 ^ i64
+i32 <= 0.5 and ok
+i32 <= 1 + i32
+i32 <= 1 + i64
+i32 <= 1 ^ 0.5
+i32 <= 1 and ok
+i32 <= 1 || i32 >= i32
+i32 <= abs(1)
 i32 <= f32
-i32 <= f32 * i64
-i32 <= f32 / 0.5
-i32 <= f32 ^ i64
+i32 <= f32 != ok
 i32 <= f64
+i32 <= f64 != ok
 i32 <= f64 * i
-i32 <= f64 ^ 1
-i32 <= float(i)
+i32 <= f64 == ok
+i32 <= f64 ^ f64
+i32 <= findIndex(array, true)
+i32 <= float(i32)
+i32 <= floor(0.5)
 i32 <= half(0.5)
+i32 <= half(1)
+i32 <= half(f64)
 i32 <= i
-i32 <= i % i64
+i32 <= i * 1
+i32 <= i * i64
+i32 <= i - 0.5
 i32 <= i32
-i32 <= i32 != nil
-i32 <= i32 % 1
-i32 <= i32 ** f64
+i32 <= i32 != true
 i32 <= i64
-i32 <= i64 != false
-i32 <= i64 != ok
-i32 <= i64 + f32
-i32 <= i64 ? div : nil
-i32 <= last(array)
-i32 <= len(array)
-i32 <= len(list)
-i32 <= max(f64)
-i32 <= min(i)
+i32 <= i64 / 1
+i32 <= len("foo")
+i32 <= max(i64)
+i32 <= mean(array)
+i32 <= round(0.5)
 i32 <= score(1)
 i32 <= score(i)
 i32 == -0.5
 i32 == -1
+i32 == -f32
 i32 == -f64
 i32 == -i
-i32 == -i64
-i32 == 0.5 / f64
-i32 == 0.5 ? half : array
-i32 == 0.5 ^ i
-i32 == 0.5 ^ i64
-i32 == 1 ** 1
-i32 == 1 ** i
-i32 == 1 || f32 < f64
+i32 == 0.5 != false
+i32 == 0.5 * f32
+i32 == 0.5 / 0.5
+i32 == 1 % 1
+i32 == 1 + f32
+i32 == 1 - i
+i32 == 1 ? div : div
+i32 == 1 ^ 0.5
+i32 == 1 ^ f64
+i32 == abs(f64)
+i32 == abs(i)
+i32 == bitnot(1)
+i32 == bitnot(i)
+i32 == ceil(1)
+i32 == count(list, ok)
 i32 == f32
-i32 == f32 ? f32 : nil
-i32 == f32 ? half : "bar"
-i32 == f32 ? score : false
-i32 == f32 or ok
+i32 == f32 * i32
+i32 == f32 ** 1
+i32 == f32 - f32
+i32 == f32 ? f64 : list
+i32 == f32 ? i64 : true
+i32 == f32 ? score : "bar"
 i32 == f64
-i32 == f64 != ok
-i32 == f64 * 0.5
-i32 == f64 ** f32
-i32 == f64 ** i64
-i32 == f64 ? add : half
-i32 == findLastIndex(array, ok)
-i32 == float(i)
-i32 == half(0.5)
+i32 == f64 ** 0.5
+i32 == find(array, 0.5 == i64)
+i32 == first(array)
+i32 == floor(f64)
+i32 == half(f64)
 i32 == i
-i32 == i % i64
-i32 == i ? "foo" : greet
-i32 == i ? type(false) : array
-i32 == i ^ f64
-i32 == i and ok
-i32 == i || ok
+i32 == i ** f64
+i32 == i ? half : 1
+i32 == i ? i : "bar"
 i32 == i32
-i32 == i32 ? add : add
-i32 == i32 ? f32 : f64
-i32 == i32 ^ 1
+i32 == i32 && i == i
+i32 == i32 - 1
+i32 == i32 - i64
 i32 == i64
-i32 == i64 + f32
-i32 == i64 ? foo : list
-i32 == len(list)
-i32 == max(0.5)
-i32 == min(f32)
-i32 == min(i32)
-i32 == nil ? f32 : add
-i32 == nil and ok
-i32 == {"foo": f32, "foo": list}?.String?.Qux
+i32 == i64 * f32
+i32 == i64 ? "foo" : 1
+i32 == i64 or ok
+i32 == int(f64)
+i32 == int(i)
+i32 == nil ? f32 : 0.5
+i32 == reduce(array, #)
+i32 == round(i32)
+i32 == round(i64)
+i32 == score(1)
 i32 > -0.5
-i32 > -1
-i32 > -f32
 i32 > -f64
-i32 > -i
 i32 > -i32
-i32 > -i64
-i32 > 0.5 != ok
 i32 > 0.5 != true
 i32 > 0.5 * f64
-i32 > 0.5 ** f32
+i32 > 0.5 ** 0.5
+i32 > 0.5 ** 1
 i32 > 0.5 ** i
-i32 > 0.5 + 0.5
-i32 > 0.5 + 1
-i32 > 0.5 - 1
-i32 > 0.5 / i64
-i32 > 0.5 == nil
-i32 > 0.5 ? greet : f32
-i32 > 0.5 ? ok : false
-i32 > 0.5 ^ f32
-i32 > 1 ** f64
-i32 > 1 - i
-i32 > 1 / 1
-i32 > 1 ? i : add
-i32 > 1 || ok
-i32 > abs(1)
-i32 > abs(f64)
-i32 > array[1]
-i32 > array[i32]
+i32 > 0.5 - i
+i32 > 0.5 / 1
+i32 > 0.5 == ok
+i32 > 0.5 ^ 1
+i32 > 0.5 || ok
+i32 > 1 * f64
+i32 > 1 * i32
+i32 > 1 + i64
+i32 > 1 ? f32 : f64
+i32 > 1 ? i : "bar"
+i32 > 1 ? i64 : div
+i32 > ceil(0.5)
+i32 > ceil(1)
+i32 > count(array, ok)
 i32 > f32
-i32 > f32 != ok
-i32 > f32 && "bar" == nil
 i32 > f32 * i64
-i32 > f32 ? "bar" : half
+i32 > f32 + 0.5
+i32 > f32 + 1
+i32 > f32 - f32
+i32 > f32 - i32
+i32 > f32 ^ 0.5
 i32 > f64
-i32 > f64 * 0.5
-i32 > f64 - 1
-i32 > f64 / 1
-i32 > f64 / i32
-i32 > f64 == nil
-i32 > f64 == ok
-i32 > f64 == true
-i32 > f64 ? 0.5 : add
-i32 > f64 ^ i64
-i32 > float(i)
-i32 > float(i32)
-i32 > half(0.5)
-i32 > half(f64)
+i32 > f64 ** i32
+i32 > f64 + f64
+i32 > get(array, i32)
+i32 > half(1)
+i32 > half(half(1))
 i32 > i
+i32 > i != ok
 i32 > i + f32
-i32 > i / f32
+i32 > i ? i : i
 i32 > i ^ i32
 i32 > i32
-i32 > i32 - 0.5
-i32 > i32 ? "bar" : div
-i32 > i32 ? array : 0.5
-i32 > i32 ? foo : 1
+i32 > i32 - i
+i32 > i32 == nil ? score : i
+i32 > i32 ? score : 1
+i32 > i32 ^ 1
+i32 > i32 ^ i32
 i32 > i64
+i32 > i64 != false
 i32 > i64 ** f32
-i32 > i64 + f64
-i32 > i64 - i
-i32 > i64 ? list : list
-i32 > int(i)
+i32 > i64 / 1
+i32 > i64 == ok
+i32 > i64 || ok
+i32 > int(1)
 i32 > int(i64)
-i32 > max(i)
-i32 > min(0.5)
-i32 > score(1)
-i32 >= -0.5
+i32 > min(i32)
+i32 > reduce(array, #)
+i32 > round(i64)
+i32 > score(i)
 i32 >= -1
+i32 >= -f32
+i32 >= -f64
 i32 >= -i
-i32 >= 0.5 ** 0.5
-i32 >= 0.5 ^ f32
-i32 >= 0.5 || ok
-i32 >= 1 && ok
-i32 >= abs(i)
-i32 >= abs(i64)
-i32 >= array[i]
+i32 >= -i64
+i32 >= 0.5 != not true
+i32 >= 0.5 == true
+i32 >= 0.5 ? 0.5 : half
+i32 >= 0.5 ^ 0.5
+i32 >= 0.5 ^ i32
+i32 >= 1 % i
+i32 >= 1 * 0.5
+i32 >= 1 * i32
+i32 >= 1 + i64
+i32 >= 1 - 1
+i32 >= 1 == ok
+i32 >= 1 ? 1 : false
+i32 >= 1 ? add : 1
+i32 >= abs(0.5)
+i32 >= abs(f32)
+i32 >= bitnot(1 + i)
+i32 >= bitnot(i64)
+i32 >= ceil(1)
+i32 >= ceil(f32)
+i32 >= count(list, true)
 i32 >= f32
-i32 >= f32 != true
-i32 >= f32 - 0.5
-i32 >= f32 ^ 0.5
+i32 >= f32 ** f32
+i32 >= f32 ^ 1
 i32 >= f64
-i32 >= f64 && nil == 0.5
-i32 >= f64 - f64
-i32 >= f64 / 1
-i32 >= f64 ? f32 : list
-i32 >= f64 ^ 1
-i32 >= float(1)
+i32 >= f64 != false
+i32 >= f64 ** f64
+i32 >= f64 / i64
+i32 >= f64 ? half : f64
+i32 >= f64 ^ f64
+i32 >= float(0.5)
+i32 >= floor(1)
+i32 >= floor(f32)
 i32 >= half(0.5)
-i32 >= half(f64)
 i32 >= i
+i32 >= i % 1
 i32 >= i % i64
-i32 >= i ** i32
-i32 >= i / i
-i32 >= i ? div : list
-i32 >= i ? foo : 0.5
+i32 >= i / i32
+i32 >= i / i64
+i32 >= i == ok
 i32 >= i32
+i32 >= i32 ** i32
 i32 >= i64
-i32 >= i64 != ok
-i32 >= i64 ** i64
-i32 >= i64 / i64
-i32 >= i64 ? list : greet
-i32 >= i64 ^ i32
+i32 >= i64 != false
+i32 >= i64 - i64
+i32 >= i64 / i32
+i32 >= i64 ? 0.5 : 0.5
+i32 >= i64 ? div : half
+i32 >= i64 ? half : i64
+i32 >= i64 and ok
 i32 >= int(i64)
 i32 >= last(array)
-i32 >= len(array)
 i32 >= min(i32)
+i32 >= reduce(array, #)
+i32 >= reduce(array, i64)
+i32 >= reduce(list, i32)
+i32 >= round(f32)
 i32 >= score(1)
-i32 >= score(i)
-i32 ^ (f32 + i64)
-i32 ^ (f64 + 0.5)
-i32 ^ (i - f64)
-i32 ^ (i32 + f32)
-i32 ^ (i64 % i)
-i32 ^ (i64 * 0.5)
-i32 ^ (i64 + f32)
-i32 ^ (i64 - f64)
-i32 ^ --0.5
+i32 ^ (0.5 + 1)
+i32 ^ (1 - i)
+i32 ^ (i + 1)
+i32 ^ (i / f64)
+i32 ^ (i32 + 0.5)
+i32 ^ (i32 - f32)
+i32 ^ (i64 + i)
 i32 ^ -0.5
+i32 ^ -1
 i32 ^ -f64
+i32 ^ -i
 i32 ^ -i32
-i32 ^ 0.5 ** i
-i32 ^ 0.5 + i32
-i32 ^ 0.5 - i
-i32 ^ 0.5 < i
+i32 ^ -i64
+i32 ^ 0.5 != f32
+i32 ^ 0.5 != f64
+i32 ^ 0.5 * i
+i32 ^ 0.5 ** i64
+i32 ^ 0.5 - f32
+i32 ^ 0.5 / i32
 i32 ^ 0.5 == i64
-i32 ^ abs(1)
+i32 ^ 0.5 >= f64
+i32 ^ 1 ** i32
+i32 ^ 1 + i32
+i32 ^ 1 - f64
+i32 ^ 1 < f64
+i32 ^ 1 ^ (1 + i64)
+i32 ^ 1 ^ f32
+i32 ^ array[i64]
 i32 ^ f32
-i32 ^ f32 * i64
-i32 ^ f32 ** 0.5
-i32 ^ f32 ** i
-i32 ^ f32 < 0.5 * i
-i32 ^ f32 ^ i
+i32 ^ f32 / bitnot(1)
+i32 ^ f32 >= max(f64)
 i32 ^ f64
-i32 ^ f64 ^ 1
-i32 ^ float(f32)
-i32 ^ half(0.5)
-i32 ^ half(f64)
+i32 ^ f64 + i
+i32 ^ find(array, true)
+i32 ^ first(array)
+i32 ^ float(i64)
 i32 ^ i
-i32 ^ i + i32
-i32 ^ i - f32
+i32 ^ i * f64
+i32 ^ i + i64
 i32 ^ i <= f32
-i32 ^ i ^ 1
 i32 ^ i32
-i32 ^ i32 ** f32
-i32 ^ i32 ** f64
-i32 ^ i32 + i32
-i32 ^ i32 + i64
-i32 ^ i32 <= i64
+i32 ^ i32 * f64
+i32 ^ i32 ** i
 i32 ^ i64
-i32 ^ i64 - f32
-i32 ^ max(0.5)
-i32 ^ max(1)
-i32 ^ max(i)
-i32 ^ min(f32)
-i32 ^ score(1)
+i32 ^ i64 == f64
+i32 ^ i64 > -f64
+i32 ^ len(list)
+i32 ^ mean(array)
+i32 ^ min(i)
+i32 ^ reduce(array, #)
+i32 ^ reduce(list, 1)
+i32 in [0.5]
 i32 in array
+i32 in array || ok
+i32 in groupBy(array, #)
+i32 in groupBy(array, f32)
+i32 in groupBy(list, #)
+i32 in groupBy(list, #?.Bar)
+i32 in groupBy(list, foo).i
+i32 in i32 .. 1
+i32 in i32 .. i64
 i32 in map(array, #)
+i32 in map(list, 0.5)
+i32 in map(list, i32)
+i32 not in 1 .. i
 i32 not in array
-i32 not in array ? score : score
-i32 not in map(array, #)
-i32 not in map(array, 1)
+i32 not in array ? array : array
+i32 not in filter(array, ok)
+i32 not in groupBy(list, #)
 i64
-i64 != -0.5
 i64 != -1
-i64 != -f32
-i64 != -f64
 i64 != -i
-i64 != 0.5 != nil
-i64 != 0.5 != ok
-i64 != 0.5 != true
-i64 != 0.5 * 1
-i64 != 0.5 ? false : i64
-i64 != 0.5 ^ 1
-i64 != 0.5 and f64 == 1
-i64 != 1 || f64 < i
-i64 != 1 || ok
+i64 != -i64
+i64 != 0.5 && ok
+i64 != 0.5 * 0.5
+i64 != 0.5 * i
+i64 != 0.5 + 0.5
+i64 != 0.5 + i
+i64 != 0.5 - 0.5
+i64 != 0.5 / i64
+i64 != 0.5 ? i : 1
+i64 != 0.5 ^ i32
+i64 != 1 * f64
+i64 != 1 - 1
 i64 != abs(f64)
+i64 != array[i64]
+i64 != bitnot(i32)
 i64 != f32
-i64 != f32 + f32
-i64 != f32 / f32
-i64 != f32 ? div : 1
-i64 != f32 ? f64 : i64
-i64 != f32 ^ i
+i64 != f32 + i64
 i64 != f64
-i64 != f64 != false
-i64 != f64 - i32
-i64 != f64 / i32
-i64 != f64 / i64
-i64 != f64 ? 0.5 : score
-i64 != f64 ? i64 : true
-i64 != findLast(array, false)
-i64 != first(array)
-i64 != float(i32)
-i64 != get(array, i64)
+i64 != f64 * 1
+i64 != f64 == true
+i64 != f64 or i64 <= f32
+i64 != findIndex(array, ok)
+i64 != float(1)
+i64 != floor(i)
+i64 != get(array, i)
 i64 != half(0.5)
-i64 != half(f64)
+i64 != half(1)
 i64 != i
-i64 != i == nil
-i64 != i ? array : f32
-i64 != i and ok
+i64 != i % 1
+i64 != i + 1
+i64 != i / 0.5
+i64 != i ? f32 : true
 i64 != i32
-i64 != i32 ? 1 : f32
+i64 != i32 ? 0.5 : nil
+i64 != i32 ? f64 : greet
+i64 != i32 ^ i
+i64 != i32 || ok
 i64 != i64
-i64 != i64 ? true : score
-i64 != last(array)
-i64 != len("foo")
-i64 != min(0.5)
+i64 != i64 - 0.5
+i64 != len("bar")
+i64 != len(list)
+i64 != max(0.5)
+i64 != min(1)
+i64 != min(1, f32)
 i64 != min(f32)
-i64 != min(f64)
-i64 != min(i64)
-i64 != nil && ok
+i64 != min(i)
+i64 != nil != ok
+i64 != nil ? div : 1
+i64 != nil ? greet : i
+i64 != nil ? i : i
+i64 != nil ? i64 : false
 i64 != score(1)
-i64 % -1
+i64 != score(i)
 i64 % -i
-i64 % -i32
-i64 % 1 * i32
-i64 % 1 .. i
-i64 % 1 / 0.5
-i64 % 1 / f64
+i64 % 1 % 1
+i64 % 1 * i
 i64 % 1 < i32
-i64 % 1 <= -i32
-i64 % 1 == 0.5 + 0.5
-i64 % 1 not in array
-i64 % abs(i64)
-i64 % array[1]
-i64 % find(array, true)
-i64 % first(array)
+i64 % 1 >= f64
+i64 % 1 >= i32
+i64 % abs(i32)
+i64 % array[i32]
 i64 % i
-i64 % i .. i32
-i64 % i not in array
+i64 % i * i
+i64 % i >= i
 i64 % i32
-i64 % i32 != f64
-i64 % i32 * f32
-i64 % i32 == i
-i64 % i32 > f64 ^ i32
+i64 % i32 / f64
+i64 % i32 <= f64
 i64 % i64
-i64 % i64 * 1
-i64 % i64 * f32
-i64 % i64 + -i64
-i64 % max(i32)
-i64 % min(i)
+i64 % i64 % 1
+i64 % i64 .. i64
+i64 % i64 == i64
+i64 % int(i32)
+i64 % len("bar")
+i64 % max(i)
+i64 % min(1)
 i64 % score(1)
-i64 * (0.5 + i64)
-i64 * (0.5 - 1)
-i64 * (1 + 1)
+i64 * (0.5 + f64)
+i64 * (1 - i64)
+i64 * (f32 - f32)
 i64 * (f64 + f32)
-i64 * (f64 - i)
-i64 * (i - 1)
-i64 * (i64 + 0.5)
-i64 * --f64
+i64 * (i + 0.5)
+i64 * (i + f64)
+i64 * (i32 + f64)
 i64 * -0.5
 i64 * -1
 i64 * -f32
-i64 * -f64
-i64 * 0.5 != f64
+i64 * -i32
 i64 * 0.5 * i32
+i64 * 0.5 ** 0.5
 i64 * 0.5 - f32
-i64 * 0.5 < f32
-i64 * 0.5 == min(i64)
+i64 * 0.5 / 1
 i64 * 0.5 >= f32
-i64 * 0.5 ^ i
-i64 * 1 * 1
+i64 * 1 % 1
+i64 * 1 * 0.5
+i64 * 1 * f64
+i64 * 1 ** 1
+i64 * 1 - i64
 i64 * 1 .. i32
-i64 * 1 <= i64
-i64 * 1 == i32
-i64 * 1 >= i32
-i64 * array[i32]
+i64 * 1 / i64
+i64 * 1 <= f64
+i64 * 1 == 0.5 != true
+i64 * 1 == f32
+i64 * 1 > 1 - i64
+i64 * 1 > f64
+i64 * 1 ^ i32
+i64 * add(1, 1)
+i64 * ceil(1)
+i64 * ceil(i)
+i64 * ceil(i64)
+i64 * count(array, false)
 i64 * f32
-i64 * f32 - f32
-i64 * f32 / f64
-i64 * f32 >= i64
-i64 * f32 ^ i
-i64 * f32 ^ i32
+i64 * f32 * f32
+i64 * f32 ** 1
+i64 * f32 / f32
+i64 * f32 / i
+i64 * f32 / i32
+i64 * f32 not in array
 i64 * f64
-i64 * f64 * i32
-i64 * f64 ^ f64
+i64 * f64 + i32
+i64 * f64 - f64
+i64 * f64 / f64
+i64 * f64 < f64
+i64 * f64 > f64
+i64 * f64 ^ i32
+i64 * findIndex(array, ok)
+i64 * float(i)
 i64 * float(i64)
-i64 * get(array, i64)
-i64 * half(f64)
+i64 * half(0.5)
 i64 * i
-i64 * i * i64
-i64 * i == i32
-i64 * i ^ i64
+i64 * i - -f64
+i64 * i <= f64
 i64 * i32
-i64 * i32 ** f32
-i64 * i32 >= f64
-i64 * i32 >= i64
-i64 * i32 ^ 1
+i64 * i32 != i32
+i64 * i32 * 1
+i64 * i32 * i
+i64 * i32 / 0.5
+i64 * i32 ^ i
 i64 * i64
-i64 * i64 ** 1
-i64 * i64 ** f32
-i64 * i64 - f64
-i64 * i64 in array
+i64 * i64 % i64
+i64 * i64 * i64
+i64 * i64 ** i
+i64 * i64 / f32
+i64 * i64 > i32
 i64 * int(1)
-i64 * min(f32, 0.5)
+i64 * int(i)
+i64 * max(1)
+i64 * max(i64)
+i64 * min(1)
+i64 * min(i32)
+i64 * reduce(array, #)
+i64 * reduce(list, 0.5)
+i64 * reduce(list, 1)
+i64 * round(i)
 i64 * score(1)
-i64 ** (0.5 * i64)
-i64 ** (0.5 + 1)
-i64 ** (1 % i)
-i64 ** (f64 / i)
-i64 ** (i * 0.5)
-i64 ** (i - i)
-i64 ** (i32 + i)
+i64 ** (0.5 + 0.5)
+i64 ** (0.5 / 1)
+i64 ** (1 % 1)
+i64 ** (1 * 1)
+i64 ** (1 - f32)
+i64 ** (f32 + 1)
+i64 ** (f32 / 0.5)
+i64 ** (f64 - 0.5)
+i64 ** (i * i64)
+i64 ** (i / 1)
+i64 ** (i64 % i)
+i64 ** (i64 / i)
+i64 ** -0.5
 i64 ** -1
-i64 ** -i
-i64 ** -i32
-i64 ** 0.5 * f64
-i64 ** 0.5 + f32
-i64 ** 0.5 + f32 - 1
-i64 ** 0.5 - i
-i64 ** 0.5 ^ 1
-i64 ** 0.5 ^ f32
-i64 ** 1 != i
-i64 ** 1 ** f32
-i64 ** 1 ** float(1)
-i64 ** 1 / f64
-i64 ** 1 / i
-i64 ** 1 == i64
-i64 ** 1 ^ i64
-i64 ** abs(f32)
-i64 ** abs(i64)
+i64 ** -f32
+i64 ** 0.5 != i32
+i64 ** 0.5 <= f32
+i64 ** 0.5 <= i
+i64 ** 1 + i32
+i64 ** 1 - f32
+i64 ** 1 / i64
+i64 ** 1 >= f32
+i64 ** bitnot(i32)
+i64 ** ceil(i32)
+i64 ** count(array, false)
 i64 ** f32
-i64 ** f32 != f64
-i64 ** f32 != i64
-i64 ** f32 ** i32
-i64 ** f32 / i64 / 1
-i64 ** f32 <= i64
-i64 ** f32 > f32
+i64 ** f32 * min(0.5)
 i64 ** f64
-i64 ** f64 / i
-i64 ** f64 <= f32
-i64 ** f64 > f64
-i64 ** f64 >= f64
-i64 ** f64 >= i32
-i64 ** float(1)
-i64 ** half(0.5)
+i64 ** f64 ** f64
+i64 ** f64 not in array
+i64 ** f64 not in array ? f32 : greet
+i64 ** floor(f32)
+i64 ** half(1)
 i64 ** i
+i64 ** i != f32
+i64 ** i * f32
+i64 ** i <= -i
+i64 ** i == f64
+i64 ** i ^ f32
 i64 ** i32
-i64 ** i32 != f32
-i64 ** i32 <= f64
-i64 ** i32 <= min(0.5)
+i64 ** i32 != i64
+i64 ** i32 * i ^ i
+i64 ** i32 not in array
 i64 ** i64
-i64 ** i64 / f64
-i64 ** i64 >= f64
-i64 ** int(0.5)
-i64 ** int(f64)
-i64 ** len("foo")
+i64 ** i64 - i64
+i64 ** i64 in array
+i64 ** max(1)
 i64 ** min(0.5)
-i64 ** score(1)
-i64 + -(f32 / i)
-i64 + -0.5
-i64 + -f32
-i64 + -f64
+i64 ** min(1)
+i64 ** min(i32, 1)
+i64 ** reduce(array, #)
+i64 + -1
 i64 + -i
 i64 + -i64
-i64 + 0.5 * i
-i64 + 0.5 ** 1
-i64 + 0.5 + 1
+i64 + 0.5 ** f32
 i64 + 0.5 + i32
-i64 + 1 % i
-i64 + 1 ** i
-i64 + 1 + i32
-i64 + 1 - f64
-i64 + 1 - i32
-i64 + 1 .. i
-i64 + 1 < i32
-i64 + 1 < i64
-i64 + 1 <= i
-i64 + 1 == i
-i64 + abs(1)
+i64 + 0.5 + i64
+i64 + 0.5 - f64
+i64 + 0.5 <= bitnand(1, 1)
+i64 + 0.5 <= f64
+i64 + 0.5 == f32
+i64 + 1 != f64
+i64 + 1 % i64
+i64 + 1 + f64
+i64 + 1 <= f32
+i64 + array[i64]
+i64 + array[i]
 i64 + f32
-i64 + f32 ** 1
-i64 + f32 >= f64
+i64 + f32 * f64
+i64 + f32 / i64
 i64 + f64
-i64 + f64 != f32
-i64 + f64 + i
-i64 + f64 <= f32
-i64 + f64 == i32
-i64 + findIndex(list, ok)
-i64 + first(array)
-i64 + get(array, i32)
+i64 + f64 * 0.5
+i64 + f64 ** 0.5
+i64 + f64 > f32
+i64 + float(f32)
+i64 + float(i32)
 i64 + half(0.5)
-i64 + half(f64)
 i64 + i
-i64 + i + i
-i64 + i - f64
-i64 + i / 1
+i64 + i % 1
+i64 + i * 0.5
+i64 + i + f32
+i64 + i - i32
+i64 + i / i32
+i64 + i == 0.5 - i32
+i64 + i ^ f32
+i64 + i ^ f64
 i64 + i32
-i64 + i32 * 1
-i64 + i32 * i
-i64 + i32 < f64
-i64 + i32 >= f32
-i64 + i32 in array
+i64 + i32 % i64
+i64 + i32 - 0.5
+i64 + i32 == f64
 i64 + i64
-i64 + i64 % i64
-i64 + i64 ** f32
-i64 + i64 + 0.5
-i64 + i64 - int(f64)
-i64 + i64 ^ i
-i64 + max(f32)
-i64 + min(0.5)
-i64 + min(1)
-i64 + min(f32)
-i64 + min(i32)
+i64 + i64 - 0.5
+i64 + reduce(array, #)
 i64 + score(i)
 i64 - -1
 i64 - -f32
 i64 - -i32
 i64 - -i64
-i64 - 0.5 != i32
-i64 - 0.5 * 1
 i64 - 0.5 + f32
-i64 - 0.5 + f64
-i64 - 0.5 / f64
-i64 - 0.5 == -0.5
-i64 - 0.5 ^ i32
-i64 - 1 - 0.5
-i64 - 1 - f32
-i64 - 1 - i32
+i64 - 0.5 / i64
+i64 - 0.5 <= i
+i64 - 0.5 ^ f32
+i64 - 1 ** 1
+i64 - 1 < i
 i64 - 1 == i32
-i64 - 1 >= f64
+i64 - 1 > f32
 i64 - 1 >= i
-i64 - abs(1)
-i64 - abs(i32)
-i64 - array[i64]
+i64 - 1 not in array
+i64 - ceil(1)
 i64 - f32
-i64 - f32 != score(i)
-i64 - f32 * i32
+i64 - f32 != f32
 i64 - f32 - 1
-i64 - f32 <= f64
-i64 - f32 ^ f32
+i64 - f32 - i
+i64 - f32 / 1
+i64 - f32 < i64
+i64 - f32 >= f64
 i64 - f64
-i64 - f64 ** 0.5
+i64 - f64 != i
+i64 - f64 ** f32
+i64 - f64 ** i32
+i64 - f64 + f32
+i64 - f64 + i32
+i64 - f64 >= f64
 i64 - float(0.5)
-i64 - float(f32)
-i64 - float(i)
+i64 - half(1)
+i64 - half(f64)
 i64 - i
-i64 - i != i32
-i64 - i * i64
-i64 - i + i32
-i64 - i - i64
-i64 - i > f64 - 0.5
-i64 - i >= i
+i64 - i * 1
+i64 - i + i64
+i64 - i - 1
+i64 - i .. i64
+i64 - i < i32
+i64 - i > 1 - 0.5
+i64 - i >= f64
 i64 - i ^ i64
+i64 - i not in array
 i64 - i32
-i64 - i32 % i32
-i64 - i32 + i32
-i64 - i32 <= i
+i64 - i32 - i64
+i64 - i32 .. i64
+i64 - i32 > i
+i64 - i32 >= i
 i64 - i64
-i64 - i64 + i32
-i64 - i64 .. i64
-i64 - i64 / i32
-i64 - max(f64)
-i64 - min(1, 0.5)
+i64 - i64 > f32
+i64 - int(i)
+i64 - len("foo")
+i64 - max(0.5)
+i64 - min(f32)
+i64 - min(f64)
+i64 - min(i)
+i64 - reduce(array, #)
+i64 - reduce(array, i64)
+i64 - round(1)
 i64 - score(1)
+i64 - score(i)
 i64 .. -1
+i64 .. -i
+i64 .. -i32
 i64 .. -i64
-i64 .. 1 == list
-i64 .. findIndex(list, ok)
+i64 .. 1 * i64
+i64 .. 1 - 1
+i64 .. 1 - i
+i64 .. 1 - i64
+i64 .. abs(i)
+i64 .. bitnot(i32)
+i64 .. count(array, false)
 i64 .. get(array, 1)
 i64 .. i
+i64 .. i * i
+i64 .. i + 1
+i64 .. i == list
 i64 .. i32
-i64 .. i32 * i
+i64 .. i32 * 1
 i64 .. i64
-i64 .. i64 + 1
+i64 .. i64 * i32
+i64 .. i64 + i
+i64 .. i64 - i
+i64 .. int(0.5)
 i64 .. int(f32)
-i64 .. int(i32)
-i64 .. last(array)
-i64 .. len(list)
+i64 .. int(i64)
+i64 .. min(i32)
+i64 .. min(i64, 0.5)
+i64 .. reduce(array, #)
 i64 .. score(1)
-i64 / (0.5 + f64)
-i64 / (1 - 0.5)
-i64 / (i32 - 1)
+i64 / (f32 + i64)
+i64 / (f32 - i)
+i64 / (i + 1)
+i64 / (i32 + 0.5)
+i64 / (i64 - i)
 i64 / -0.5
 i64 / -1
 i64 / -f32
 i64 / -f64
 i64 / -i
-i64 / -i64
-i64 / 0.5 < f64
-i64 / 0.5 == f32
-i64 / 0.5 ^ f64
-i64 / 1 ** 1
-i64 / 1 - f32
-i64 / 1 - min(0.5)
-i64 / 1 / 0.5
-i64 / abs(i64)
-i64 / array[i]
+i64 / 0.5 * f64
+i64 / 0.5 - i64
+i64 / 0.5 / i
+i64 / 0.5 == i
+i64 / 1 ** i64
+i64 / 1 / i32
+i64 / 1 / i64
+i64 / 1 < i
+i64 / 1 == f32
+i64 / ceil(i)
 i64 / f32
-i64 / f32 ** i
-i64 / f32 <= i
+i64 / f32 - i
+i64 / f32 / i64
+i64 / f32 > i
+i64 / f32 ^ 1
+i64 / f32 ^ i
 i64 / f64
-i64 / f64 * 1
-i64 / f64 ** 0.5
-i64 / f64 ** f64
-i64 / f64 + i32
-i64 / f64 <= f32
-i64 / f64 <= i64
-i64 / float(f32)
-i64 / float(f64)
-i64 / float(i)
-i64 / float(i64)
-i64 / half(0.5)
-i64 / half(f64)
+i64 / f64 * i64
+i64 / f64 - min(i64)
+i64 / f64 / f32
+i64 / f64 / i * 0.5
+i64 / f64 / i32
+i64 / f64 in array
+i64 / float(1)
+i64 / get(array, i32)
+i64 / half(1)
 i64 / i
-i64 / i != i64
-i64 / i * 0.5
-i64 / i * f32
-i64 / i - i32
-i64 / i ^ i64
+i64 / i * i64
+i64 / i - f64
 i64 / i32
-i64 / i32 * i
+i64 / i32 != f32
+i64 / i32 * f64
+i64 / i32 == f64
+i64 / i32 > 1 + 1
+i64 / i32 >= f32
+i64 / i32 >= f64
+i64 / i32 ^ f32
 i64 / i64
-i64 / i64 ** f32
-i64 / i64 - f64
-i64 / i64 / i64
-i64 / i64 < f32
-i64 / int(0.5)
-i64 / min(f32)
+i64 / i64 + f64
+i64 / i64 < i32
+i64 / i64 <= f32
+i64 / i64 == i32
+i64 / int(1)
+i64 / len(list)
+i64 / max(1)
+i64 / reduce(array, #)
+i64 / reduce(array, 1)
+i64 / round(0.5)
+i64 / round(i)
 i64 / score(1)
+i64 / score(i)
+i64 < -0.5
 i64 < -1
+i64 < -f32
+i64 < -f64
+i64 < -i
 i64 < -i32
 i64 < -i64
-i64 < 1 != true
-i64 < 1 * f64
+i64 < 0.5 * 0.5
+i64 < 0.5 + i
+i64 < 0.5 - 1
+i64 < 0.5 / 0.5
+i64 < 0.5 / 1
+i64 < 0.5 == ok
+i64 < 0.5 || false ? 1 : nil
+i64 < 1 * i32
+i64 < 1 ** 0.5
+i64 < 1 + 0.5
 i64 < 1 + i64
-i64 < 1 / i32
-i64 < 1 ? half : ok
-i64 < 1 ^ f64
-i64 < abs(f32)
-i64 < array[1]
+i64 < 1 / f32
+i64 < ceil(i64)
 i64 < f32
-i64 < f32 * i32
-i64 < f32 ? "bar" : ok
-i64 < f32 ^ 0.5
+i64 < f32 * 0.5
+i64 < f32 - i64
+i64 < f32 ^ f32
 i64 < f64
-i64 < f64 + f64
-i64 < f64 - f32
-i64 < f64 - i
-i64 < f64 ? i64 : score
-i64 < f64 or ok
-i64 < float(f64)
-i64 < half(0.5)
+i64 < f64 && ok
+i64 < f64 - f64
+i64 < f64 ? score : add
+i64 < float(0.5)
+i64 < float(i32)
+i64 < floor(0.5)
+i64 < floor(i32)
+i64 < half(1)
 i64 < i
-i64 < i != false
+i64 < i % i64
+i64 < i ^ 0.5
+i64 < i || ok
 i64 < i32
-i64 < i32 * 1
-i64 < i32 + i64
-i64 < i32 - 0.5
-i64 < i32 - f32
-i64 < i32 ? greet : 1
-i64 < i32 ? nil : array
-i64 < i32 ? true : "bar"
+i64 < i32 + 1
+i64 < i32 + i32
+i64 < i32 / f32
+i64 < i32 ? foo : i
 i64 < i64
-i64 < i64 + 1
-i64 < i64 ? f32 : foo
-i64 < i64 ? half : i
-i64 < int(i64)
-i64 < max(0.5)
-i64 < min(0.5)
-i64 < min(i)
-i64 < score(1)
-i64 < score(1) * i64
+i64 < i64 != nil
+i64 < i64 * 1
+i64 < i64 * i64
+i64 < i64 / f32
+i64 < i64 / i
+i64 < i64 ^ 1
+i64 < i64 ^ i
+i64 < int(f64)
+i64 < len("bar")
+i64 < len("foo")
+i64 <= -0.5
 i64 <= -1
 i64 <= -f32
-i64 <= -i
-i64 <= -i32
+i64 <= -f64
 i64 <= -i64
-i64 <= 0.5 != true
-i64 <= 0.5 + i
-i64 <= 0.5 - 1
-i64 <= 0.5 == nil
-i64 <= 0.5 ? 0.5 : "foo"
-i64 <= 1 != true
-i64 <= 1 ** f64
+i64 <= 0.5 && ok
+i64 <= 0.5 * 0.5
+i64 <= 0.5 + 1
+i64 <= 0.5 ? i : i32
+i64 <= 1 ** i32
+i64 <= 1 + 1
+i64 <= 1 - 0.5
+i64 <= 1 - 1
+i64 <= 1 / 1
 i64 <= 1 == ok
-i64 <= 1 ? array : ok
-i64 <= 1 and ok
-i64 <= array[i32]
+i64 <= 1 ? add : div
+i64 <= 1 ? f32 : greet
+i64 <= 1 ? i64 : true
+i64 <= 1 ^ 1
+i64 <= array[i64]
+i64 <= array[i]
+i64 <= bitnot(1)
 i64 <= f32
-i64 <= f32 && ok
-i64 <= f32 + 1
-i64 <= f32 / f32
-i64 <= f32 ^ i32
+i64 <= f32 ** i
+i64 <= f32 ** i64
+i64 <= f32 == ok
 i64 <= f64
 i64 <= f64 + 1
-i64 <= f64 - f32
-i64 <= half(0.5)
+i64 <= f64 + f32
+i64 <= f64 / 1
+i64 <= f64 ? nil : i32
+i64 <= float(1)
+i64 <= floor(i)
+i64 <= floor(i32)
+i64 <= half(min(0.5, 1, i64))
 i64 <= i
-i64 <= i != true
 i64 <= i * 1
-i64 <= i + 1
-i64 <= i / i64
-i64 <= i ? i32 : list
-i64 <= i ^ 0.5
+i64 <= i * f32
+i64 <= i ** i32
+i64 <= i ? greet : add
 i64 <= i32
-i64 <= i32 && ok
-i64 <= i32 ? f64 : i < 1
+i64 <= i32 ** i32
+i64 <= i32 ? list : half
+i64 <= i32 ^ -1
 i64 <= i64
-i64 <= i64 - 0.5
-i64 <= i64 ? greet : div
-i64 <= int(i64)
-i64 <= last(array)
+i64 <= i64 * i
+i64 <= len(list)
+i64 <= max(f32)
 i64 <= min(0.5)
-i64 <= min(f64)
-i64 <= score(1)
-i64 <= score(i)
-i64 == -0.5
+i64 <= min(i32)
+i64 <= reduce(array, i32)
+i64 <= reduce(list, i64)
+i64 <= round(0.5)
 i64 == -1
+i64 == -f32
 i64 == -f64
 i64 == -i
+i64 == -i32
+i64 == 0.5 * 1
+i64 == 0.5 - f64
 i64 == 0.5 == ok
-i64 == 0.5 ? 1 : list
-i64 == 0.5 ? div : i64
-i64 == 0.5 ? foo : f32
-i64 == 0.5 ^ 0.5
-i64 == 0.5 ^ i
-i64 == 1 % i64
-i64 == 1 && ok
+i64 == 0.5 ? 0.5 : f64
 i64 == 1 ** f64
-i64 == 1 + f32
-i64 == 1 - f64
-i64 == abs(0.5)
-i64 == abs(i32)
-i64 == count(array, true)
-i64 == count(list, true)
+i64 == 1 + 0.5
+i64 == 1 / i
+i64 == 1 == ok
+i64 == 1 ? "foo" : i
+i64 == array[1]
+i64 == bitnot(i64)
+i64 == ceil(i64)
 i64 == f32
+i64 == f32 != true
+i64 == f32 + i
+i64 == f32 - f32
+i64 == f32 == ok
 i64 == f64
-i64 == f64 != ok
-i64 == f64 != true
-i64 == f64 - i
-i64 == f64 ? f64 : add
-i64 == findIndex(array, false)
+i64 == f64 * f64
+i64 == f64 ? 1 : nil
+i64 == f64 ^ 0.5
+i64 == f64 ^ f32
+i64 == f64 and not true
+i64 == findIndex(list, f64 <= f64)
+i64 == floor(0.5)
+i64 == get(array, 1)
+i64 == half(1)
 i64 == i
-i64 == i * f32
-i64 == i == false
-i64 == i == ok
-i64 == i ^ 1
+i64 == i != nil
+i64 == i + i32
+i64 == i ? i64 : foo
 i64 == i32
-i64 == i32 ** 0.5
-i64 == i32 / f64
 i64 == i64
-i64 == i64 ^ 0.5
+i64 == i64 * f32
+i64 == i64 / i64
+i64 == i64 ? add : 0.5
+i64 == i64 ? add : greet
+i64 == int(0.5)
 i64 == int(1)
-i64 == int(f32)
-i64 == last(array)
-i64 == max(0.5)
-i64 == nil ? true : ok
+i64 == int(i)
+i64 == len("foo")
+i64 == nil != nil
+i64 == reduce(array, #)
 i64 == score(1)
-i64 == score(i)
 i64 > -0.5
-i64 > -1
 i64 > -f32
 i64 > -f64
-i64 > -i
-i64 > -i32
-i64 > -i64
-i64 > 0.5 * 1
-i64 > 0.5 ** 0.5
-i64 > 0.5 == true
-i64 > 0.5 ? f64 : greet
-i64 > 0.5 ? foo : add
-i64 > 1 ** 0.5
-i64 > 1 - 0.5
-i64 > 1 ? false : array
-i64 > 1 ? half : i64
-i64 > abs(1)
-i64 > abs(f64)
-i64 > array[i64]
+i64 > 0.5 + f32
+i64 > 0.5 - f64
+i64 > 0.5 - i32
+i64 > 0.5 ? array : 1
+i64 > 0.5 ? f32 : nil
+i64 > 0.5 ? ok : nil
+i64 > 0.5 ? score : foo
+i64 > 0.5 or ok
+i64 > 1 != true
+i64 > 1 ** 1
+i64 > 1 == false
+i64 > 1 ? nil : 1
+i64 > 1 ^ f32
+i64 > 1 ^ i32
 i64 > f32
-i64 > f32 - 1
-i64 > f32 ? div : false
+i64 > f32 * 0.5
+i64 > f32 + f64
+i64 > f32 / f32
+i64 > f32 ? "foo" : greet
+i64 > f32 ? 1 : i32
 i64 > f64
-i64 > f64 == nil
-i64 > f64 and 1 > i64
+i64 > f64 * i
+i64 > f64 - 0.5
+i64 > f64 - f32
 i64 > first(array)
-i64 > float(f32)
-i64 > half(f64)
+i64 > half(0.5)
 i64 > i
-i64 > i % i32
-i64 > i * f64
-i64 > i ** 1
-i64 > i + i
-i64 > i + i32
-i64 > i ^ i32
+i64 > i != nil
+i64 > i == true
 i64 > i32
-i64 > i32 && ok
-i64 > i32 ** 0.5
-i64 > i32 ** i
+i64 > i32 ? div : f32
+i64 > i32 ^ f32
 i64 > i64
-i64 > i64 % i32
-i64 > i64 - i64
-i64 > int(f32)
-i64 > int(i32)
-i64 > int(i64)
+i64 > i64 - i
+i64 > i64 - i32
+i64 > i64 / f64
+i64 > i64 == false
+i64 > len(list)
+i64 > max(0.5)
+i64 > min(1)
+i64 > min(i32)
+i64 > reduce(array, #)
+i64 > reduce(array, 1)
+i64 > round(0.5)
+i64 > round(i32)
 i64 > score(i)
 i64 >= -0.5
 i64 >= -1
-i64 >= -f64
 i64 >= -i
-i64 >= 0.5 * f64
-i64 >= 0.5 ** f32
-i64 >= 0.5 + f32
+i64 >= -i64
+i64 >= 0.5 / i
 i64 >= 0.5 == nil
-i64 >= 0.5 == true
-i64 >= 0.5 ? array : array
-i64 >= 0.5 ? i32 : nil
-i64 >= 0.5 ^ 0.5
-i64 >= 0.5 and f32 != nil
-i64 >= 1 + f64
-i64 >= 1 + i32
-i64 >= 1 ? i : false
-i64 >= 1 ? i : string(array)
-i64 >= 1 ? true : i
+i64 >= 0.5 ? 0.5 : f64
+i64 >= 0.5 ^ i
+i64 >= 1 % i64
+i64 >= 1 * f64
+i64 >= 1 * i64
+i64 >= abs(i64)
+i64 >= array[i32]
+i64 >= bitnot(1)
 i64 >= f32
-i64 >= f32 * f32
-i64 >= f32 ** f64
-i64 >= f32 ** i32
-i64 >= f32 / f64
+i64 >= f32 + f32
+i64 >= f32 - f32
+i64 >= f32 ? array : i
+i64 >= f32 ? f32 : i32
+i64 >= f32 ? list : f32
 i64 >= f64
-i64 >= f64 + i
-i64 >= f64 / i64
-i64 >= f64 == ok
-i64 >= f64 and ok
-i64 >= find(array, ok)
+i64 >= f64 + 0.5
+i64 >= first(array)
+i64 >= float(0.5)
 i64 >= float(f32)
-i64 >= float(i)
-i64 >= float(i32)
+i64 >= floor(1)
+i64 >= floor(i64)
 i64 >= half(0.5)
+i64 >= half(half(f64))
 i64 >= i
-i64 >= i and ok
+i64 >= i / 0.5
+i64 >= i ? true : i32
 i64 >= i32
-i64 >= i32 % i64
+i64 >= i32 * i
+i64 >= i32 / f32
+i64 >= i32 == false
+i64 >= i32 || f64 == 1
 i64 >= i64
-i64 >= i64 % i
-i64 >= i64 && i64 > f32
-i64 >= i64 / i32
-i64 >= i64 == nil
-i64 >= i64 in {"foo": f64}.half
-i64 >= max(f64)
+i64 >= i64 + 1
+i64 >= i64 ? foo : foo
+i64 >= i64 or ok
+i64 >= int(f64)
+i64 >= last(array)
 i64 >= max(i64)
-i64 >= min(f32)
+i64 >= min(1)
+i64 >= min(f64)
+i64 >= round(1)
+i64 >= round(i)
 i64 >= score(1)
-i64 ^ (0.5 + 1)
-i64 ^ (0.5 / i32)
-i64 ^ (1 * f32)
-i64 ^ (1 / i)
-i64 ^ (1 / i64)
-i64 ^ (f32 + f32)
-i64 ^ (f32 - f32)
-i64 ^ (f64 * f32)
-i64 ^ (i % i32)
-i64 ^ (i - 0.5)
-i64 ^ (i32 - f32)
-i64 ^ (i64 + i32)
-i64 ^ (i64 / f64)
+i64 ^ (0.5 * i32)
+i64 ^ (0.5 / i64)
+i64 ^ (1 * f64)
+i64 ^ (1 - i)
+i64 ^ (f32 / 1)
+i64 ^ (i % i)
+i64 ^ (i32 * f64)
+i64 ^ (i32 - f64)
+i64 ^ (i64 + 0.5)
+i64 ^ (i64 + 1)
+i64 ^ (i64 - f32)
 i64 ^ -0.5
-i64 ^ -i32
-i64 ^ 0.5 ** f32
-i64 ^ 0.5 <= i
-i64 ^ 0.5 >= f32
-i64 ^ 0.5 >= f64
-i64 ^ 0.5 >= i64
-i64 ^ 0.5 ^ 0.5
-i64 ^ 1 != i
-i64 ^ 1 != i32
+i64 ^ -1
+i64 ^ -f32
+i64 ^ -i64
+i64 ^ 0.5 != i64
+i64 ^ 0.5 ** 0.5
+i64 ^ 0.5 / f32
+i64 ^ 0.5 <= i64
+i64 ^ 0.5 == i
+i64 ^ 0.5 ^ f32
+i64 ^ 0.5 ^ i64
+i64 ^ 1 * i64
+i64 ^ 1 * round(0.5)
+i64 ^ 1 ** f64
 i64 ^ 1 ** i32
-i64 ^ 1 + f32
-i64 ^ 1 < f32
-i64 ^ 1 <= i
+i64 ^ 1 - f32
+i64 ^ 1 < f64
+i64 ^ 1 >= f32
+i64 ^ 1 >= half(1)
+i64 ^ 1 ^ f32
+i64 ^ 1 ^ i32
 i64 ^ abs(1)
-i64 ^ abs(i)
-i64 ^ array[i64]
+i64 ^ array[i]
 i64 ^ f32
-i64 ^ f32 - f32
+i64 ^ f32 * i32
+i64 ^ f32 ** f64
+i64 ^ f32 - f64
+i64 ^ f32 / i - i32
+i64 ^ f32 < f32
+i64 ^ f32 <= i64
+i64 ^ f32 ^ 1
 i64 ^ f64
-i64 ^ f64 * i32
-i64 ^ f64 ** i
-i64 ^ f64 + f32
-i64 ^ f64 < f32
-i64 ^ f64 == i64
-i64 ^ f64 > 1 + i64
+i64 ^ f64 * i
+i64 ^ f64 ** 1
+i64 ^ f64 > i64
 i64 ^ f64 ^ f32
-i64 ^ get(array, i)
-i64 ^ half(f64)
+i64 ^ float(i32)
+i64 ^ floor(i32)
+i64 ^ floor(i64)
+i64 ^ half(0.5)
+i64 ^ half(1)
 i64 ^ i
-i64 ^ i ** f32
-i64 ^ i ** i64
+i64 ^ i * i
+i64 ^ i ** i32
+i64 ^ i + i % 1
+i64 ^ i + i64
+i64 ^ i - f32 ^ 1
+i64 ^ i - f64
+i64 ^ i / i
+i64 ^ i < f32
+i64 ^ i ^ i32
 i64 ^ i32
-i64 ^ i32 != f32
-i64 ^ i32 != i32
-i64 ^ i32 ** i
-i64 ^ i32 + f32
-i64 ^ i32 + f64
-i64 ^ i32 / f32
+i64 ^ i32 * i
+i64 ^ i32 + i32
+i64 ^ i32 + i64
 i64 ^ i64
-i64 ^ i64 * f64
 i64 ^ i64 * i64
-i64 ^ i64 ** f64
-i64 ^ i64 ^ f32
-i64 ^ i64 ^ f64
-i64 ^ i64 ^ i
-i64 ^ int(i64)
-i64 ^ last(array)
-i64 ^ len(array)
+i64 ^ i64 + i
+i64 ^ i64 == i64
+i64 ^ i64 ^ 1
+i64 ^ i64 in array
+i64 ^ int(1)
 i64 ^ max(0.5)
-i64 ^ max(1)
-i64 ^ max(f32)
+i64 ^ reduce(array, #)
+i64 ^ round(i64)
 i64 ^ score(1)
-i64 ^ score(1, 1)
-i64 ^ score(i)
 i64 in array
-i64 in array == nil
-i64 in array ? false : greet
+i64 in array == ok
+i64 in groupBy(array, 0.5)
+i64 in groupBy(array, foo)
+i64 in groupBy(list, "bar")
+i64 in groupBy(list, i)
+i64 in i64 .. i32
 i64 in map(array, #)
+i64 in map(list, 1)
+i64 in map(list, i)
+i64 not in 1 .. i
 i64 not in array
-indexOf("bar", "bar") + i64
-indexOf(foo.Bar, string(i32))
-int(-(i * 0.5))
+i64 not in array ? f32 : i32
+i64 not in array ? ok : f32
+i64 not in map(array, #)
+i64 not in map(list, 0.5)
 int(-0.5)
 int(-1)
-int(-abs(f64))
 int(-f32)
 int(-f64)
 int(-i)
 int(-i32)
-int(-i32) != i
 int(-i64)
 int(0.5 * 0.5)
-int(0.5 * 1)
 int(0.5 * f32)
-int(0.5 * i)
+int(0.5 * f64)
 int(0.5 * i32)
-int(0.5 * i64)
 int(0.5 ** 0.5)
 int(0.5 ** 1)
 int(0.5 ** f32)
 int(0.5 ** f64)
-int(0.5 ** i64)
-int(0.5 + f32)
+int(0.5 ** i32)
+int(0.5 + 0.5)
+int(0.5 + 1)
 int(0.5 + f64)
-int(0.5 + i)
 int(0.5 + i32)
-int(0.5 - 0.5)
+int(0.5 + i64)
 int(0.5 - f32)
+int(0.5 - i)
 int(0.5 - i32)
-int(0.5 / 0.5)
-int(0.5 / 1)
-int(0.5 / f32)
-int(0.5 / f64)
-int(0.5 / i32)
+int(0.5 - i64)
+int(0.5 / i)
 int(0.5 / i64)
-int(0.5 ^ 0.5)
-int(0.5 ^ 1)
-int(0.5 ^ f32)
 int(0.5 ^ i)
-int(0.5) ** i64
-int(0.5) ** int(i64)
-int(0.5) + f32
-int(0.5) + f64
-int(0.5) + i64
-int(0.5) - i
-int(0.5) - i64
-int(0.5) .. i32
-int(0.5) < int(f64)
+int(0.5 ^ i64)
+int(0.5) * -i
+int(0.5) ** f64
+int(0.5) ** i32
+int(0.5) + i
+int(0.5) / i32
+int(0.5) < 0.5 * f64
+int(0.5) <= i
+int(0.5) <= i32
 int(0.5) == f32
-int(0.5) == i
-int(0.5) > -1
-int(0.5) >= i - i64
+int(0.5) > -i64
+int(0.5) > i
+int(0.5) >= f32
+int(0.5) >= i32
+int(0.5) >= max(0.5)
 int(0.5) ^ i32
-int(0.5) ^ i64
-int(0.5) in array
-int(0.5) not in array
-int(1 % 1)
 int(1 % i)
-int(1 % i32)
-int(1 * 0.5)
 int(1 * f32)
-int(1 * f64)
 int(1 * i)
-int(1 * i64)
-int(1 ** 0.5)
-int(1 ** 1)
-int(1 ** f32)
-int(1 ** i32)
-int(1 ** i64)
-int(1 + 0.5)
+int(1 * i32)
+int(1 ** i)
 int(1 + 1)
+int(1 + f32)
 int(1 + f64)
-int(1 + i)
+int(1 + i32)
 int(1 - 0.5)
-int(1 - 1)
+int(1 - f32)
+int(1 - f64)
+int(1 - i32)
 int(1 - i64)
+int(1 / 0.5)
 int(1 / 1)
-int(1 / f64)
-int(1 / i32)
-int(1 / i64)
 int(1 ^ 0.5)
-int(1 ^ 1)
-int(1 ^ i32)
 int(1 ^ i64)
-int(1) * f64
-int(1) * i
+int(1) != i64
 int(1) ** f32
-int(1) ** i64
-int(1) + 0.5 + 1
+int(1) ** i32
+int(1) + f32
 int(1) + i64
-int(1) - f64
-int(1) - i64
-int(1) .. i
-int(1) / f32
-int(1) / i
+int(1) + reduce(array, #)
+int(1) - i
 int(1) < f64
-int(1) <= f32
-int(1) <= f64
-int(1) == i
-int(1) == i64
-int(1) > f64
-int(1) > float(1)
-int(1) > i32
-int(1) >= f32
-int(1) >= f64
-int(1) >= half(0.5)
-int(1) ^ f32
+int(1) < i64 * 0.5
+int(1) == i32
 int(1) ^ f64
-int(1) ^ i
-int(1) ^ i32
-int(1) in array
 int(abs(0.5))
-int(abs(f32))
+int(abs(1))
 int(abs(f64))
 int(abs(i))
 int(abs(i32))
 int(abs(i64))
-int(array[1])
-int(array[i32])
+int(add(1, 1))
 int(array[i64])
-int(count(list, ok))
-int(div(1, i))
-int(f32 * f32)
-int(f32 * i64)
+int(bitnot(1))
+int(bitnot(i32))
+int(bitnot(i64))
+int(bitshl(1, i))
+int(bitxor(1, i32) + i)
+int(bitxor(i32, i))
+int(ceil(0.5))
+int(ceil(1))
+int(ceil(f32))
+int(ceil(half(1)))
+int(ceil(i))
+int(ceil(i32))
+int(count(array, ok))
+int(count(list, false))
+int(f32 * 1)
+int(f32 * i)
 int(f32 ** 0.5)
-int(f32 ** f64)
-int(f32 ** i32)
+int(f32 ** i64)
 int(f32 + f32)
-int(f32 + i64)
 int(f32 - 0.5)
-int(f32 - f32)
-int(f32 - i)
+int(f32 - i64)
+int(f32 / 0.5)
+int(f32 / 1)
 int(f32 / f64)
-int(f32 ^ 1)
+int(f32 / i32)
+int(f32 / i64)
 int(f32 ^ f32)
-int(f32 ^ i)
-int(f32 ^ i64)
+int(f32 ^ i32)
 int(f32)
-int(f32) != f32
-int(f32) % i
-int(f32) * f64
-int(f32) .. i32
-int(f32) / f32
-int(f32) / i
-int(f32) == 0.5 != nil
-int(f32) == i
-int(f32) > i
-int(f32) >= i32
-int(f32) ^ i64
-int(f32) in array
+int(f32) != i
+int(f32) != i64
+int(f32) ** f64
+int(f32) + i32
+int(f32) - f32
+int(f32) < i
+int(f32) <= i32
+int(f32) == i ? list : add
 int(f64 * 0.5)
-int(f64 * 1)
-int(f64 * f32)
-int(f64 * f64)
-int(f64 * i32)
-int(f64 * i64)
-int(f64 ** 0.5)
 int(f64 ** 1)
-int(f64 ** f32)
 int(f64 ** i)
 int(f64 ** i32)
-int(f64 ** i64)
-int(f64 + f32)
-int(f64 + i64)
+int(f64 + 0.5)
+int(f64 + 1)
+int(f64 + i)
 int(f64 - 0.5)
-int(f64 - 1)
-int(f64 - f64)
-int(f64 / 1)
-int(f64 / i)
+int(f64 - f32)
+int(f64 / 0.5)
+int(f64 / i64)
 int(f64 ^ 0.5)
 int(f64 ^ 1)
-int(f64 ^ f32)
+int(f64 ^ f64)
+int(f64 ^ i64)
 int(f64)
-int(f64) != i32
-int(f64) * i32
-int(f64) ** i64
-int(f64) - i
+int(f64) % i64
+int(f64) * f64
+int(f64) + f64
 int(f64) < i32
-int(f64) <= i32
-int(f64) == float(i32)
-int(f64) ^ i32
-int(f64) ^ i64
-int(f64) not in array
-int(false ? add : 0.5)
-int(false ? f32 : 0.5)
-int(false ? f64 : i32)
-int(find(array, true))
-int(findIndex(array, ok))
-int(findIndex(array, true))
-int(findIndex(list, # == foo))
+int(f64) == f32
+int(f64) == f64
+int(f64) > i
+int(f64) > i64
+int(false ? 0.5 : 0.5)
+int(false ? i : 0.5)
 int(findIndex(list, ok))
-int(findLastIndex(array, ok))
-int(findLastIndex(array, true))
-int(findLastIndex(list, true))
+int(findLastIndex(list, ok))
 int(first(array))
 int(float(0.5))
 int(float(1))
 int(float(f32))
-int(float(f64) ** i64)
 int(float(f64))
-int(float(i))
+int(float(i32 ** i))
 int(float(i32))
-int(float(i64))
-int(get(array, 1))
+int(floor(f64))
+int(floor(i))
+int(floor(i32))
 int(get(array, i64))
 int(half(0.5))
-int(half(1 / f32))
+int(half(1))
 int(half(f64))
 int(i % 1)
+int(i % i32)
 int(i % i64)
 int(i * 0.5)
 int(i * 1)
-int(i * f32)
 int(i * f64)
-int(i ** 0.5)
 int(i ** f32)
 int(i ** f64)
 int(i ** i64)
-int(i + 0.5)
 int(i + f32)
-int(i + i32)
-int(i + i64)
-int(i - f64)
+int(i + f64)
+int(i + i)
+int(i - 0.5)
+int(i - f32)
+int(i - i32)
 int(i - i64)
-int(i / 1) <= i32
-int(i / f64)
+int(i / 0.5)
+int(i / 1)
 int(i / i)
-int(i ^ f32)
-int(i ^ f64)
-int(i ^ i)
+int(i / i32)
+int(i ^ 0.5)
+int(i ^ 1)
 int(i ^ i32)
 int(i)
-int(i) != i
-int(i) + f32
-int(i) + i32
-int(i) - i32
+int(i) != i32
+int(i) * f64
+int(i) * i64
+int(i) - i
 int(i) .. i64
-int(i) / i
-int(i) < f32
-int(i) < f64
-int(i) <= f64
-int(i) == f32
-int(i) > i32
-int(i) > i64
-int(i) > int(i)
-int(i) >= i
-int(i) ^ i64
-int(i32 % i64)
 int(i32 * 0.5)
 int(i32 * 1)
-int(i32 * f64)
-int(i32 ** i)
+int(i32 * i64)
+int(i32 ** 0.5)
+int(i32 ** 1)
 int(i32 + 0.5)
 int(i32 + 1)
-int(i32 + f32)
-int(i32 - 0.5)
+int(i32 + f64)
+int(i32 + i64)
 int(i32 - 1)
-int(i32 - f64)
 int(i32 - i)
-int(i32 - i64)
 int(i32 / 0.5)
+int(i32 / 1)
 int(i32 / f64)
 int(i32 ^ 0.5)
-int(i32 ^ f32)
 int(i32 ^ f64)
-int(i32 ^ i)
-int(i32 ^ i64)
+int(i32 ^ i32)
 int(i32)
 int(i32) != f32
-int(i32) % i64
-int(i32) ** -0.5
-int(i32) + i
-int(i32) - f32
-int(i32) .. i32
+int(i32) - i
+int(i32) / f32
 int(i32) / i
-int(i32) / i32
+int(i32) / i64
 int(i32) < i64
-int(i32) <= f32
-int(i32) == -i32
-int(i32) == f64
-int(i32) > f64
-int(i64 % i32)
-int(i64 * f32)
-int(i64 * f64)
-int(i64 * i)
-int(i64 ** i)
-int(i64 + 1)
+int(i32) > half(0.5)
+int(i64 * 1)
+int(i64 ** 0.5)
+int(i64 ** f64)
+int(i64 ** i64)
 int(i64 + i)
-int(i64 + i64)
+int(i64 + i32)
+int(i64 - 0.5)
 int(i64 - f32)
-int(i64 - f64)
-int(i64 - i32)
-int(i64 / f32)
-int(i64 / f64)
-int(i64 / i)
-int(i64 / i64)
-int(i64 ^ 0.5)
+int(i64 - i)
+int(i64 - i64)
+int(i64 / 1)
 int(i64 ^ f64)
 int(i64 ^ i32)
 int(i64 ^ i64)
 int(i64)
-int(i64) != f64
-int(i64) != i
-int(i64) != nil ? 1 : half
-int(i64) % i
-int(i64) % i32
-int(i64) ** f64
-int(i64) - i32
+int(i64) != i64
+int(i64) - i64
 int(i64) .. i32
+int(i64) / i
 int(i64) <= i
-int(i64) <= i64
-int(i64) == min(i)
-int(i64) > f64
-int(i64) > i32
-int(i64) >= f64
-int(i64) ^ f32
-int(i64) ^ i32
-int(i64) in array
-int(i64) not in array
+int(i64) == f32
+int(i64) > i64
+int(i64) ^ i
 int(int(0.5))
 int(int(1))
-int(int(f32))
 int(int(f64))
-int(int(i32))
-int(int(i64))
-int(last(array))
 int(len("bar"))
 int(len(array))
-int(len(list))
 int(max(0.5))
+int(max(0.5, i64))
 int(max(1))
+int(max(f32))
 int(max(f64))
 int(max(i))
 int(max(i64))
+int(mean(array))
 int(min(0.5))
 int(min(1))
+int(min(1, i64))
 int(min(f32))
-int(min(f32, i32))
-int(min(f64))
-int(min(f64, 1))
 int(min(i))
 int(min(i32))
 int(min(i64))
-int(min(i64, 1))
-int(ok ? 0.5 : i64)
-int(ok ? 1 : div)
-int(ok ? i32 : add)
+int(ok ? i : div)
+int(ok ? i : i64)
+int(ok ? i64 : list)
+int(reduce(array, #))
+int(reduce(array, f32))
+int(reduce(array, i32))
+int(reduce(list, 0.5))
+int(reduce(list, 1))
+int(reduce(list, i64))
+int(round(0.5))
+int(round(1))
+int(round(f32))
+int(round(f64))
+int(round(i))
 int(score(1))
+int(score(1, i))
 int(score(i))
 int(string(1))
 int(string(i))
 int(string(i32))
 int(string(i64))
-int(toJSON(1))
+int(sum(array))
 int(toJSON(i))
 int(toJSON(i32))
 int(toJSON(i64))
-int(true ? f64 : 0.5)
-int(true ? f64 : 1)
-join(["bar"])
-join(map(array, "bar"))
+int(true ? 1 : foo)
+int(true ? f64 : greet)
 join(map(array, "foo"))
-join(map(list, "bar"))
-keys({"bar": i64})
-keys({"foo": 0.5})
-keys({"foo": f32})
-keys({"foo": i})
-last(1 .. i32)
+join(map(list, "foo"))
+keys(groupBy(array, "foo"))
+keys(groupBy(array, # ** 0.5))
+keys(groupBy(array, #))
+keys(groupBy(array, f32 != f64))
+keys(groupBy(array, foo))
+keys(groupBy(array, i32))
+keys(groupBy(array, ok))
+keys(groupBy(list, "bar"))
+keys(groupBy(list, #))
+keys(groupBy(list, false))
+keys(groupBy(list, i32))
+keys({"bar": 1})
+keys({"bar": array, "foo": "bar"})
+keys({"bar": f32})
+keys({"foo": array, "bar": f64})
+keys({"foo": array})
+last(1 .. 1)
+last(1 .. i)
 last([0.5])
-last([array])
-last([f64])
-last([half, i32])
+last([f32, list])
+last([list, list])
 last(array)
-last(array) != f32
-last(array) != i32
-last(array) % i32
-last(array) * i32
-last(array) + f32
-last(array) + i
+last(array) != int(i64)
+last(array) + f64
 last(array) - f32
 last(array) - i64
-last(array) - score(i)
-last(array) .. max(i)
-last(array) / f64
-last(array) > f64
-last(array) > max(1)
-last(array) >= f32
+last(array) .. i32
+last(array) / f32
+last(array) <= i32
+last(array) == f32
+last(array) > f32 * i64
 last(array) >= f64
-last(false ? 0.5 : greet)
-last(false ? div : 1)
-last(false ? f32 : 1)
-last(false ? list : 1)?.add
-last(false ? list : add)
+last(false ? "foo" : true)
+last(false ? 0.5 : "bar")
+last(false ? 1 : foo)?.div
+last(false ? div : score)
+last(false ? f64 : false)
 last(filter(array, false))
 last(filter(array, ok))
 last(filter(list, true))
-last(i .. i32)
-last(i32 .. i32)
+last(groupBy(array, foo).Qux)
+last(groupBy(array, i32).Qux)
+last(groupBy(list, #).list)
+last(groupBy(list, #)?.Qux)
+last(groupBy(list, #)?.ok)
+last(i32 .. 1)
 last(i32 .. i64)
-last(i64 .. i)
+last(i64 .. 1)
 last(list)
-last(list) == foo
-last(list) not in list
 last(list).Bar
 last(list).Qux
 last(list).String
@@ -9271,181 +12170,156 @@ last(list)?.Bar
 last(list)?.Qux
 last(list)?.String
 last(list)?.String()
-last(map(array, "bar"))
+last(list[1:i64])
 last(map(array, #))
+last(map(array, 1))
 last(map(array, array))
-last(map(array, i64))
-last(map(list, "bar"))
+last(map(array, foo))
+last(map(array, i))
 last(map(list, "foo"))
 last(map(list, #))
-last(map(list, 0.5))
-last(map(list, add))
-last(map(list, f32))
-last(map(list, foo))
-last(map(list, i))
+last(map(list, 1))
+last(map(list, false))
+last(map(list, half))
 last(map(list, i32))
-last(map(list, true))
-last(ok ? 0.5 : score)
-last(ok ? array : false)
-last(ok ? foo : add != half)
-last(ok ? nil : list)
-last(ok ? ok : i32)
-last(true ? 1 : list)?.String
-last(true ? foo : half)
-last(true ? half : 1)
-last(true ? i32 : ok)
-last(true ? i64 : 1)
-last(true ? ok : f64)
-lastIndexOf("bar", "foo") < f32 ^ f64
-len("bar" + "foo")
-len("bar") != f32
-len("bar") % score(i)
-len("bar") * i32
-len("bar") ** f64
-len("bar") ** i32
-len("bar") <= i64
-len("bar") > i32
-len("bar") >= 0.5 ^ 0.5
-len("bar") >= f32
-len("bar") >= f64
-len("foo" + foo.Bar)
-len("foo") * i32
-len("foo") * i64
+last(map(list, i64))
+last(map(list, ok))
+last(ok ? "bar" : true)
+last(ok ? "foo" : f64)
+last(ok ? 0.5 : "foo")
+last(ok ? 0.5 : list)
+last(ok ? 1 : add)
+last(ok ? 1 : half)
+last(ok ? array : array)
+last(ok ? array : ok)
+last(ok ? f32 : 0.5)
+last(ok ? greet : 1)
+last(ok ? i32 : array)
+last(ok ? i64 : add)
+last(ok ? ok : 0.5)
+last(reduce(array, list))
+last(reduce(list, array))
+last(sort(array))
+last(sum(array))
+last(true ? "bar" : half)
+last(true ? add : list)
+last(true ? foo : 1)
+last(true ? greet : true)
+last(true ? ok : 1)
+len("bar") ** i64
+len("bar") + i64 - i64
+len("bar") / i64
+len("bar") >= i
+len("bar") in array
+len("foo") ** i32
+len("foo") ** i64
 len("foo") - i
-len("foo") .. i
-len("foo") < f32
-len("foo") <= f32
-len("foo") <= f64
-len("foo") == i
-len("foo") == i32
-len("foo") == i64
-len("foo") > f64
-len("foo") not in array
-len([f64])
-len([false, add, half])
-len([false, foo, false])
-len([false])
+len("foo") - i32
+len("foo") >= i
+len(1 .. 1)
+len([f32])
+len([foo])
+len([half])
 len(array)
-len(array) != i
-len(array) != i32
-len(array) * i
-len(array) ** i
-len(array) .. 1 - 1
-len(array) / f32
-len(array) < f32
-len(array) <= i
-len(array) >= f32
+len(array) != f32
+len(array) + i64
+len(array) < f64
+len(array) <= i32
+len(array) == f32
 len(array) >= f64
-len(array) >= i64
-len(false ? 1 : list)
-len(false ? nil : "foo")
+len(array) ^ i32
+len(array) not in array
+len(filter(list, false))
+len(filter(list, ok))
 len(foo.Bar)
 len(foo.String())
 len(foo?.Bar)
+len(foo?.Qux("bar"))
 len(foo?.String())
 len(greet("bar"))
 len(greet("foo"))
-len(i .. 1)
-len(i32 .. 1)
-len(i32 .. i)
-len(i32 .. i32)
-len(i32 .. i64)
+len(groupBy(array, #))
+len(groupBy(array, 0.5))
+len(groupBy(array, f32))
+len(groupBy(array, false))
+len(groupBy(array, i64))
+len(groupBy(array, true))
+len(groupBy(list, #))
+len(groupBy(list, #).ok)
+len(groupBy(list, 0.5))
+len(groupBy(list, false))
+len(groupBy(list, foo).list)
+len(groupBy(list, i32))
+len(groupBy(list, i64))
 len(i64 .. 1)
 len(i64 .. i)
 len(list)
-len(list) != i64
-len(list) * f32
-len(list) ** i
-len(list) / f64
-len(list) <= f64
-len(list) == f32
-len(list) == i
+len(list) % i32
+len(list) % i64
+len(list) .. i64
+len(list) / i32
+len(list) <= i
 len(list) > i
-len(list) > i64 - i
-len(list) >= i
-len(list) not in map(array, #)
+len(list) ^ f64
+len(list[1:i])
+len(lower("bar"))
 len(lower("foo"))
-len(lower(toBase64("foo")))
-len(lower(type(list)))
 len(map(array, "bar"))
 len(map(array, #))
-len(map(array, 0.5))
-len(map(array, array))
-len(map(array, f64))
-len(map(array, foo))
-len(map(array, half))
+len(map(array, add))
+len(map(array, f32))
+len(map(array, greet))
 len(map(array, i))
-len(map(array, i64))
-len(map(array, list))
-len(map(array, ok))
+len(map(array, list)[i64])
 len(map(array, score))
-len(map(list, "bar"))
-len(map(list, "foo"))
 len(map(list, #))
-len(map(list, 0.5))
 len(map(list, 1))
+len(map(list, f32))
 len(map(list, f64))
-len(map(list, false))
-len(map(list, greet))
-len(map(list, half))
-len(map(list, i))
-len(map(list, score))
+len(map(list, foo))
+len(map(list, i64))
+len(map(list, ok))
 len(map(list, true))
+len(ok ? list : score)
 len(sort(array))
 len(string("bar"))
 len(string("foo"))
 len(string(0.5))
 len(string(1))
 len(string(add))
-len(string(array))
-len(string(div))
-len(string(f32))
 len(string(f64))
 len(string(foo))
-len(string(greet))
 len(string(half))
+len(string(i))
 len(string(i32))
 len(string(i64))
 len(string(list))
 len(string(nil))
-len(string(ok))
 len(string(score))
-len(string(true))
+len(string(string(list)))
 len(toJSON("bar"))
 len(toJSON("foo"))
 len(toJSON(0.5))
-len(toJSON(1 <= i32))
 len(toJSON(1))
 len(toJSON(array))
 len(toJSON(f32))
-len(toJSON(f64))
 len(toJSON(false))
-len(toJSON(foo))
-len(toJSON(foo.Bar))
 len(toJSON(i))
 len(toJSON(i32))
-len(toJSON(i64))
 len(toJSON(list))
 len(toJSON(nil))
 len(toJSON(ok))
 len(toJSON(true))
-len(trim("bar"))
 len(trim("foo"))
-len(trimPrefix("bar"))
 len(trimPrefix("foo"))
 len(trimSuffix("bar"))
-len(trimSuffix("foo"))
+len(type("foo"))
 len(type(0.5))
 len(type(1))
+len(type(add))
 len(type(array))
 len(type(div))
-len(type(f32))
-len(type(f64))
-len(type(false))
-len(type(foo))
-len(type(greet))
 len(type(half))
-len(type(half)) > f32
 len(type(i))
 len(type(i32))
 len(type(i64))
@@ -9455,46 +12329,48 @@ len(type(ok))
 len(type(score))
 len(upper("bar"))
 len(upper("foo"))
-len({"bar": 1})
-len({"bar": add})
-len({"bar": f64, "bar": i})
-len({"bar": greet, "bar": greet})
-len({"foo": "foo"})
+len({"bar": array})
+len({"bar": f64})
+len({"bar": score})
+len({"foo": 1})
+len({"foo": add, "foo": "foo"})
+len({"foo": i64})
 list
+list != 1 .. 1
+list != ["foo"]
+list != [i, 0.5]
+list != [i]
 list != array
-list != array == ok
-list != array ? 0.5 : "bar"
-list != filter(list, true)
+list != filter(array, ok)
+list != filter(array, true)
 list != list
+list != list ? 0.5 : div
+list != list ? half : div
 list != map(array, #)
-list != map(array, 1)
-list != map(array, div)
-list != map(list, #)
-list != map(list, div)
-list != map(list, list)
-list == [add]
+list != map(list, 1)
+list != map(list, i64)
+list != nil && i32 <= 1
+list != nil ? false : 1
+list != nil ? i : 1
+list != sort(array)
+list == [div, nil]
+list == [i]
 list == array
-list == array ? div : i
+list == array == nil
 list == list
-list == list == nil
-list == list ? f64 : array
-list == list or add != nil
-list == map(list, f32)
-list == map(list, i64)
-list == nil == nil
-list == nil == ok
-list == nil or i == 0.5
-list == sort(array)
-list == {"bar": half, "foo": "foo"}?.i32
+list == list != false
+list == list ? i32 : i
+list == map(list, #)
+list == nil && ok
+list == nil ? nil : "foo"
+list == nil or f64 == f64
+list not in groupBy(list, #).i
 list[-1]
 list[-i32]
 list[-i64]
-list[-i64].String
 list[-i]
-list[-i].String
-list[1 % i32]
-list[1 * i64]
-list[1:i] == list
+list[1 - 1]
+list[1] not in list
 list[1].Bar
 list[1].Qux
 list[1].String
@@ -9503,35 +12379,35 @@ list[1]?.Bar
 list[1]?.Qux
 list[1]?.String
 list[1]?.String()
-list[false ? add : 1]
-list[false ? nil : i]
-list[false ? true : f64]
-list[findIndex(list, ok)]
-list[i * i32]
+list[bitnot(i)]
+list[bitshr(i32, i32)]
+list[findIndex(array, true)]
+list[first(array)]
+list[i * i64]
 list[i32:i32]
-list[i32:i64]
 list[i32:i]
 list[i32]
+list[i32] in list
 list[i32].Bar
 list[i32].Qux
 list[i32].String
-list[i32].String()
 list[i32]?.Bar
 list[i32]?.Qux
 list[i32]?.String
-list[i64 % 1]
-list[i64:i32]
+list[i32]?.String()
+list[i64:i32 - i]
 list[i64:i64]
-list[i64:i]
 list[i64]
+list[i64] in list
 list[i64].Bar
 list[i64].Qux
 list[i64].String
-list[i64].String()
 list[i64]?.Bar
 list[i64]?.Qux
 list[i64]?.String
-list[i:false ? false : i64]
+list[i:i32]
+list[i:i64]
+list[i:i64] == nil != nil
 list[i:i]
 list[i]
 list[i].Bar
@@ -9540,17 +12416,22 @@ list[i].String
 list[i].String()
 list[i]?.Bar
 list[i]?.Qux
+list[i]?.String
 list[i]?.String()
-list[int(0.5)]
+list[int(f32)]
 list[int(f64)]
 list[int(i)]
-list[max(i)]
+list[int(i64)]
+list[max(i64, 1)]
 list[min(i)]
-list[ok ? f32 : add]
+list[min(i32)]
+list[ok ? 1 : half]
 list[score(1)]
 list[score(i)]
-list[true ? f64 : true]
 lower("bar" + "bar")
+lower("bar") == trimSuffix("bar")
+lower("foo" + "bar")
+lower(false ? foo : "bar")
 lower(foo.Bar)
 lower(foo.String())
 lower(foo?.Bar)
@@ -9558,107 +12439,89 @@ lower(foo?.String())
 lower(greet("bar"))
 lower(greet("foo"))
 lower(lower("bar"))
-lower(lower(trimSuffix("bar")))
-lower(string("bar"))
+lower(lower("foo"))
+lower(reduce(array, "bar"))
+lower(reduce(list, "bar"))
 lower(string("foo"))
 lower(string(0.5))
 lower(string(add))
-lower(string(array))
-lower(string(div))
 lower(string(f32))
 lower(string(f64))
-lower(string(false))
 lower(string(foo))
 lower(string(greet))
-lower(string(half))
 lower(string(i))
 lower(string(i32))
 lower(string(i64))
 lower(string(list))
 lower(string(nil))
-lower(string(ok))
 lower(string(score))
-lower(string(true))
-lower(toBase64("bar" + "bar"))
-lower(toBase64("bar"))
 lower(toBase64("foo"))
+lower(toBase64(string(i)))
 lower(toJSON("bar"))
 lower(toJSON("foo"))
 lower(toJSON(0.5))
 lower(toJSON(1))
-lower(toJSON(array))
-lower(toJSON(f32))
 lower(toJSON(f64))
-lower(toJSON(false))
 lower(toJSON(foo))
-lower(toJSON(i))
-lower(toJSON(i32))
-lower(toJSON(i64))
 lower(toJSON(list))
 lower(toJSON(nil))
 lower(toJSON(ok))
 lower(toJSON(true))
+lower(trim("bar"))
 lower(trim("foo"))
 lower(trimPrefix("bar"))
+lower(trimPrefix("foo"))
 lower(trimSuffix("bar"))
-lower(trimSuffix("foo"))
-lower(trimSuffix(foo?.String()))
 lower(type("bar"))
 lower(type("foo"))
-lower(type(0.5 * i64))
 lower(type(0.5))
 lower(type(1))
-lower(type(array))
+lower(type(add))
 lower(type(div))
 lower(type(f32))
-lower(type(f64))
-lower(type(false))
-lower(type(foo))
-lower(type(greet))
 lower(type(half))
 lower(type(i))
+lower(type(i32))
 lower(type(i64))
-lower(type(nil))
+lower(type(list))
 lower(type(ok))
-lower(type(score))
 lower(type(true))
 lower(upper("bar"))
 lower(upper("foo"))
-map(1 .. 1, # .. #)
-map(1 .. 1, # == f64)
-map(1 .. i, #)
+map(1 .. 1, f32)
+map(1 .. 1, foo)
+map(1 .. 1, score)
 map(1 .. i, foo)
-map(1 .. i, greet)
 map(1 .. i32, #)
-map(1 .. i32, ok)
-map(1 .. i64, f64 ^ 1)
-map(1 .. i64, foo)
-map(1 .. i64, list)
-map(["bar"], # == #)
-map(["foo"], #)
-map([1, i], #)
-map([add], foo)
-map([f32], f64)
-map([false], score)
-map([greet, i32], #)
-map([greet], #)
+map(1 .. i32, 0.5 / f64)
+map(1 .. i32, div)
+map(1 .. i32, reduce(array, #))
+map(1 .. i64, # ^ #)
+map(1 .. i64, #)
+map(1 .. i64, half)
+map(1 .. i64, i32)
+map([1], get(#, 1))
+map([f64], half)
+map([false], ok)
 map([half], #)
+map([i * i32], score)
+map([i32, foo, score], #)
 map([i32], foo)
-map([i64], #)
-map([i], max(#))
-map([list, nil], i64)
-map([list], #)
-map([nil], #?.div(#))
-map([score, "bar"], #)
-map([score], #)
-map([score], array)
-map(array, !false)
-map(array, !true)
-map(array, "bar" != "foo")
-map(array, "bar" contains "foo")
-map(array, "bar")[i64]
-map(array, # != # ? # : array)
+map([i32], greet)
+map([i32], half)
+map([list, 1, foo], i32)
+map([nil], #?.f32(ok, #, false))
+map([nil], foo)
+map([score, "bar"], f32)
+map([true, i32, 1], #)
+map(array, !(# == #))
+map(array, !(nil in list))
+map(array, !ok)
+map(array, "bar" in foo)
+map(array, "foo" not endsWith "bar")
+map(array, "foo") == array
 map(array, # != #)
+map(array, # != 0.5)
 map(array, # != 1)
 map(array, # != f64)
 map(array, # != i32)
@@ -9666,1223 +12529,1153 @@ map(array, # != nil)
 map(array, # % #)
 map(array, # % 1)
 map(array, # % i)
-map(array, # % i32)
 map(array, # % i64)
 map(array, # * #)
 map(array, # * 0.5)
+map(array, # * 1)
+map(array, # * f32)
 map(array, # * f64)
-map(array, # * i32)
-map(array, # * i64)
+map(array, # * i)
 map(array, # ** #)
-map(array, # ** 0.5)
+map(array, # ** 1)
+map(array, # ** f32)
 map(array, # ** i)
-map(array, # ** i32)
 map(array, # ** i64)
 map(array, # + #)
 map(array, # + 0.5)
 map(array, # + 1)
-map(array, # + f64)
+map(array, # + f32)
 map(array, # + i)
 map(array, # + i32)
-map(array, # + i64)
 map(array, # - #)
 map(array, # - 0.5)
 map(array, # - 1)
 map(array, # - f32)
+map(array, # - f64)
 map(array, # - i)
 map(array, # - i32)
 map(array, # .. #)
 map(array, # .. 1)
-map(array, # .. i)
-map(array, # .. i32)
-map(array, # .. i64)
 map(array, # / #)
 map(array, # / 0.5)
+map(array, # / 1)
+map(array, # / f32)
 map(array, # / f64)
 map(array, # / i)
-map(array, # / i32)
 map(array, # / i64)
 map(array, # < #)
-map(array, # < 0.5)
 map(array, # < 1)
 map(array, # < f32)
-map(array, # < f64)
+map(array, # < i32)
+map(array, # < i64)
 map(array, # <= #)
-map(array, # <= 1)
-map(array, # <= i64)
+map(array, # <= f32)
+map(array, # <= i)
+map(array, # <= i32)
 map(array, # == #)
-map(array, # == 1)
-map(array, # == i64)
+map(array, # == f32)
+map(array, # == f64)
+map(array, # == nil)
 map(array, # > #)
+map(array, # > 0.5)
 map(array, # > 1)
 map(array, # > f32)
-map(array, # > i32)
-map(array, # > i64)
+map(array, # > f64)
 map(array, # >= #)
-map(array, # >= 0.5)
 map(array, # >= 1)
-map(array, # >= f64)
-map(array, # >= i)
+map(array, # >= f32)
 map(array, # >= i32)
+map(array, # >= i64)
 map(array, # ^ #)
 map(array, # ^ 0.5)
+map(array, # ^ 1)
 map(array, # ^ i)
 map(array, # ^ i32)
-map(array, # ^ i64)
-map(array, # in array)
+map(array, # not in array)
 map(array, #)
 map(array, #) != array
 map(array, #) != list
-map(array, #) != nil == nil
+map(array, #) == array
+map(array, #) == list
 map(array, #)[i64]
 map(array, #)[i]
 map(array, -#)
-map(array, -(# ** f64))
+map(array, --#)
 map(array, -0.5)
 map(array, -1)
 map(array, -f64)
 map(array, -i)
+map(array, -i32)
 map(array, -i64)
 map(array, 0.5 != #)
 map(array, 0.5 != 0.5)
-map(array, 0.5 != i32)
 map(array, 0.5 * #)
-map(array, 0.5 ** #)
+map(array, 0.5 * f64)
+map(array, 0.5 ** f32)
+map(array, 0.5 ** i64)
 map(array, 0.5 + #)
+map(array, 0.5 + 1)
 map(array, 0.5 - #)
-map(array, 0.5 / #)
+map(array, 0.5 - 0.5)
+map(array, 0.5 / i)
 map(array, 0.5 < #)
-map(array, 0.5 < 1)
-map(array, 0.5 <= f32)
-map(array, 0.5 == #)
-map(array, 0.5 == i32)
+map(array, 0.5 < i32)
 map(array, 0.5 > #)
+map(array, 0.5 > i64)
+map(array, 0.5 >= #)
 map(array, 0.5 ^ #)
+map(array, 0.5)[i]
 map(array, 1 != #)
-map(array, 1 != 1)
 map(array, 1 != f32)
 map(array, 1 % #)
-map(array, 1 % i)
-map(array, 1 * #)
-map(array, 1 * f32)
 map(array, 1 ** #)
-map(array, 1 ** 1)
-map(array, 1 ** i32)
+map(array, 1 ** i)
+map(array, 1 ** i64)
 map(array, 1 + #)
+map(array, 1 + f64)
+map(array, 1 - #)
 map(array, 1 .. #)
 map(array, 1 / #)
-map(array, 1 / 1)
-map(array, 1 < 0.5)
+map(array, 1 / i32)
+map(array, 1 < #)
 map(array, 1 <= #)
+map(array, 1 <= 1)
+map(array, 1 <= f32)
 map(array, 1 == #)
-map(array, 1 == nil)
-map(array, 1 >= #)
-map(array, 1 >= f64)
 map(array, 1 ^ #)
-map(array, 1 ^ 1)
-map(array, 1 in array)
-map(array, 1)[i64]
-map(array, 1)[i]
-map(array, [array])
-map(array, [i32, foo])
 map(array, abs(#))
-map(array, abs(0.5))
+map(array, abs(i64))
+map(array, add == greet)
+map(array, add == nil)
 map(array, add(#, #))
 map(array, add(#, i))
-map(array, add(1, #))
 map(array, add)
-map(array, add) != list
-map(array, all(array, true))
-map(array, array != nil)
 map(array, array)
-map(array, array) == array
+map(array, array)[bitnot(i32)]
+map(array, array)[i64]
 map(array, array[#:#])
-map(array, array[1])
+map(array, bitand(#, 1))
+map(array, bitnand(#, 1))
+map(array, bitnot(#))
+map(array, bitnot(1))
+map(array, bitshl(#, #))
+map(array, bitshr(#, #))
+map(array, bitshr(#, i64))
+map(array, bitushr(1, #))
+map(array, ceil(#))
+map(array, ceil(0.5))
+map(array, ceil(f32))
 map(array, div(#, #))
 map(array, div)
+map(array, f32 * #)
+map(array, f32 * f64)
 map(array, f32 ** #)
-map(array, f32 ** f64)
 map(array, f32 + #)
-map(array, f32 - f64)
 map(array, f32 / #)
 map(array, f32 < #)
-map(array, f32 <= #)
-map(array, f32 <= 1)
 map(array, f32 == #)
 map(array, f32 > #)
+map(array, f32 >= #)
+map(array, f32 >= i)
+map(array, f32 ^ #)
 map(array, f32)
+map(array, f32)[min(i32)]
 map(array, f64 != #)
 map(array, f64 != 0.5)
-map(array, f64 * 1)
+map(array, f64 * #)
 map(array, f64 ** #)
-map(array, f64 - #)
-map(array, f64 / 1)
-map(array, f64 <= f64)
-map(array, f64 > #)
+map(array, f64 ** 0.5)
+map(array, f64 / #)
+map(array, f64 < #)
+map(array, f64 < f64)
+map(array, f64 <= #)
+map(array, f64 == #)
+map(array, f64 >= #)
+map(array, f64 >= i32)
+map(array, f64 ^ #)
 map(array, f64)
-map(array, f64) != list
-map(array, f64) == i .. 1
-map(array, false ? "foo" : #)
-map(array, false ? 0.5 : #)
-map(array, false)[i]
-map(array, findLast(array, true))
-map(array, float(# * f64))
+map(array, false && false)
+map(array, false ? # : f64)
+map(array, false ? greet : i)
+map(array, false)[i32]
+map(array, find(array, true))
+map(array, findIndex(list, ok))
+map(array, float(# + #))
 map(array, float(#))
-map(array, float(1))
-map(array, float(i64))
+map(array, floor(#))
+map(array, foo == foo)
 map(array, foo)
 map(array, foo.Bar)
 map(array, foo.Qux)
 map(array, foo.String())
 map(array, foo.String)
-map(array, foo?.Qux)
+map(array, foo?.Bar)
 map(array, foo?.String)
 map(array, get(array, #))
-map(array, get(list, #))
-map(array, greet != half)
 map(array, greet("bar"))
 map(array, greet("foo"))
 map(array, greet)
-map(array, greet) == list
+map(array, groupBy(array, #))
+map(array, groupBy(array, f32))
+map(array, groupBy(list, #))
+map(array, groupBy(list, f64))
+map(array, groupBy(list, i))
+map(array, half != half)
+map(array, half != nil)
 map(array, half(0.5))
+map(array, half(1))
+map(array, half(f64))
+map(array, half(i - 0.5))
 map(array, half)
-map(array, i != #)
-map(array, i != f64)
-map(array, i % i)
-map(array, i * 0.5)
-map(array, i ** #)
-map(array, i ** 0.5)
-map(array, i .. #)
-map(array, i / #)
+map(array, i % #)
+map(array, i + #)
+map(array, i - i32)
+map(array, i / 0.5)
+map(array, i <= #)
+map(array, i <= f32)
+map(array, i <= f64)
 map(array, i == #)
-map(array, i > #)
-map(array, i >= f64)
-map(array, i ^ #)
+map(array, i == f64)
+map(array, i > i32)
+map(array, i >= #)
 map(array, i)
-map(array, i)[i64]
-map(array, i32 % #)
-map(array, i32 % i)
+map(array, i)[i]
 map(array, i32 * #)
-map(array, i32 + 0.5)
-map(array, i32 + i64)
-map(array, i32 - #)
-map(array, i32 / #)
-map(array, i32 < 0.5)
+map(array, i32 ** #)
+map(array, i32 ** f64)
+map(array, i32 / f32)
+map(array, i32 < #)
+map(array, i32 < f64)
 map(array, i32 == #)
-map(array, i32 == 0.5)
-map(array, i32 == nil)
+map(array, i32 == 1)
 map(array, i32 > #)
-map(array, i32 >= f32)
 map(array, i32 ^ #)
+map(array, i32 not in array)
 map(array, i32)
+map(array, i32) == array
+map(array, i32) == list
 map(array, i64 != #)
+map(array, i64 % #)
 map(array, i64 * #)
-map(array, i64 ** #)
-map(array, i64 + #)
+map(array, i64 * 0.5)
+map(array, i64 + 0.5)
 map(array, i64 - #)
 map(array, i64 .. #)
-map(array, i64 / #)
-map(array, i64 <= 1)
-map(array, i64 == #)
-map(array, i64 == f64)
+map(array, i64 < #)
+map(array, i64 <= #)
+map(array, i64 <= f64)
+map(array, i64 <= i64)
 map(array, i64 > #)
-map(array, i64 >= i64)
-map(array, i64 ^ #)
-map(array, i64 ^ i32)
 map(array, i64)
-map(array, i64)[i32]
 map(array, int(#))
 map(array, int(0.5))
-map(array, int(f64))
-map(array, last(array))
-map(array, len(array))
+map(array, len("foo"))
+map(array, list != array)
 map(array, list)
-map(array, map(array, #))
-map(array, map(array, true))
-map(array, map(list, #))
-map(array, map(list, f64))
+map(array, map(array, f64))
+map(array, map(list, greet))
 map(array, max(#))
-map(array, max(#, #, #))
-map(array, max(0.5))
-map(array, max(0.5, #))
-map(array, max(i64, #, i))
-map(array, min(# ^ #))
-map(array, min(#))
-map(array, min(#, #, #, #))
-map(array, min(#, 1))
-map(array, min(#, 1, #))
-map(array, min(#, 1, f64))
-map(array, min(#, f32))
-map(array, min(#, f64))
-map(array, nil != #)
+map(array, max(f32, 1))
+map(array, max(f64))
+map(array, mean(array))
+map(array, min(#, #))
 map(array, nil == #)
-map(array, nil == half)
-map(array, not (# < 1))
-map(array, not false)
+map(array, nil == ok)
+map(array, nil not in list)
+map(array, not ok)
 map(array, not true)
-map(array, ok ? # : i64)
-map(array, ok ? f32 : div)
 map(array, ok || ok)
 map(array, ok)
-map(array, one(array, ok))
-map(array, one(array, true))
-map(array, score != nil)
+map(array, ok)[i64]
+map(array, reduce(array, "bar"))
+map(array, reduce(array, #))
+map(array, reduce(list, add))
+map(array, reduce(list, half))
+map(array, round(#))
 map(array, score(#))
 map(array, score(#, #))
-map(array, score(#, #, 1))
 map(array, score(1))
 map(array, score)
-map(array, sort(array))
-map(array, string("bar"))
-map(array, string(# ** f64))
-map(array, string(#))
-map(array, string(array))
+map(array, string(add))
 map(array, string(foo))
-map(array, string(list))
-map(array, string(score))
+map(array, string(i64))
+map(array, take(array, #))
+map(array, toBase64("foo"))
 map(array, toJSON(#))
-map(array, toJSON(array))
-map(array, toJSON(ok))
-map(array, true ? # : #)
-map(array, true ? f32 : i)
-map(array, true ? nil : #)
-map(array, true)[i]
+map(array, toJSON(foo))
+map(array, toJSON(list))
+map(array, true != nil)
+map(array, true ? 0.5 : #)
+map(array, true ? 0.5 : 1)
+map(array, true ? f32 : div)
+map(array, true ? i : true)
 map(array, type(#))
-map(array, type(half))
-map(array, type(i))
-map(array, upper("foo"))
-map(array[i64:1], array)
-map(array[i64:i64], #)
-map(array[i:1], i > #)
-map(false ? 0.5 : "bar", greet)
-map(false ? 1 : list, half)
-map(false ? array : "foo", i64 / 1)
-map(false ? true : array, #)
+map(array, type(f32))
+map(array[1:i32], list)
+map(false ? i32 : list, ok)
 map(filter(array, false), foo)
-map(filter(array, ok), # <= #)
-map(filter(array, ok), #)
-map(filter(array, ok), i32 + #)
-map(filter(array, ok), score)
-map(filter(array, true), f64)
-map(filter(array, true), i)
+map(filter(array, ok), 1 * #)
+map(filter(list, # != #), #)
 map(filter(list, false), #)
-map(filter(list, true), score)
-map(i .. 1, # > #)
-map(i .. 1, -i64)
-map(i .. 1, f64)
-map(i .. i32, #)
-map(i .. i32, score)
-map(i .. i64, #)
-map(i .. i64, f64)
-map(i .. i64, score)
-map(i32 .. 1, #)
-map(i32 .. 1, list)
-map(i32 .. i, add)
-map(i32 .. i, half)
-map(i32 .. i32, #)
-map(i32 .. i32, greet)
-map(i32 .. i64, abs(#))
-map(i32 .. i64, f64)
-map(i64 .. i, #)
-map(i64 .. i, i)
+map(filter(list, ok), #)
+map(filter(list, ok), i)
+map(filter(list, true), i64)
+map(groupBy(array, #).String, i32)
+map(groupBy(array, #).greet, foo.Qux(.f32))
+map(groupBy(array, #).greet, score)
+map(groupBy(array, #).score, #?.list())
+map(groupBy(array, 0.5)?.i64, .Qux())
+map(groupBy(array, f64)?.array, first(.div()))
+map(groupBy(list, i32).i, #)
+map(i .. 1, -#)
+map(i .. 1, 0.5 ^ #)
+map(i .. 1, f32)
+map(i .. 1, i)
+map(i .. i, add(#, #))
+map(i .. i, div)
+map(i .. i, i32)
+map(i .. i32, half)
+map(i .. i64, min(#, #, #))
+map(i32 .. 1, half)
+map(i32 .. i, f32)
+map(i32 .. i32, array)
+map(i32 .. i64, div)
+map(i32 .. i64, list)
+map(i64 .. 1, #)
+map(i64 .. 1, 1 ^ #)
+map(i64 .. 1, array)
+map(i64 .. 1, f32)
+map(i64 .. 1, f64)
 map(i64 .. i32, #)
+map(i64 .. i64, # - #)
+map(i64 .. i64, #)
 map(list, !false)
-map(list, !true)
-map(list, "bar" in #)
-map(list, "bar" not in #)
+map(list, !ok)
+map(list, "bar" not matches "foo")
 map(list, "bar") != list
-map(list, "foo" + "foo")
-map(list, "foo" in #)
-map(list, "foo" not matches "bar")
-map(list, "foo") == list
+map(list, "bar")[i64]
+map(list, "foo" not in foo)
+map(list, "foo" not matches #.Bar)
 map(list, # != #)
-map(list, # != foo)
 map(list, # != nil)
 map(list, # == #)
-map(list, # == foo)
-map(list, # not in list)
+map(list, # in list)
 map(list, #)
-map(list, #) == array
+map(list, #) != array
 map(list, #) == list
-map(list, #)[i32]
 map(list, #)[i64]
 map(list, #)[i]
 map(list, #?.Bar)
-map(list, #?.Qux("bar"))
 map(list, #?.Qux)
 map(list, #?.String())
 map(list, #?.String)
 map(list, -0.5)
-map(list, -1)
-map(list, -f64)
+map(list, -f32)
 map(list, -i)
-map(list, .Bar not in # != true)
+map(list, -i32)
 map(list, .Bar)
 map(list, .Qux)
 map(list, .String())
 map(list, .String)
-map(list, 0.5 - i64)
-map(list, 0.5 < f32)
-map(list, 0.5 <= f32)
-map(list, 0.5 <= i64)
-map(list, 0.5 >= 1)
-map(list, 0.5 ^ 1)
-map(list, 1 + i)
-map(list, 1 - f64)
-map(list, 1 .. 1)
-map(list, 1 .. i64)
-map(list, 1 / 1)
-map(list, 1 / f32)
-map(list, 1 < i32)
-map(list, 1 > i32)
-map(list, 1 >= f64)
-map(list, [1])
-map(list, [false])
-map(list, abs(0.5))
-map(list, abs(1))
+map(list, 0.5 != 0.5)
+map(list, 0.5 != i64)
+map(list, 0.5 + i64)
+map(list, 0.5 - 0.5)
+map(list, 0.5 <= 0.5)
+map(list, 0.5 == i32)
+map(list, 0.5 in array)
+map(list, 0.5) != array
+map(list, 0.5) == array
+map(list, 1 % i)
+map(list, 1 ** 0.5)
+map(list, 1 ** f32)
+map(list, 1 + 1)
+map(list, 1 / f64)
+map(list, 1 / i64)
+map(list, 1 < 0.5)
+map(list, 1 <= i32)
+map(list, 1 ^ i32)
+map(list, [#])
+map(list, [foo, 0.5, #])
+map(list, [score])
+map(list, abs(f32))
+map(list, add == score)
 map(list, add)
 map(list, array)
-map(list, div != greet)
-map(list, div == div)
+map(list, ceil(0.5))
+map(list, count(array, true))
 map(list, div)
-map(list, div) != list
-map(list, f32 != f32)
-map(list, f32 ** f32)
-map(list, f32 / i32)
-map(list, f32 < 0.5)
-map(list, f32 <= 1)
+map(list, f32 != i32)
+map(list, f32 ** 1)
+map(list, f32 + i64)
+map(list, f32 < f32)
+map(list, f32 == 0.5)
+map(list, f32 > i64)
+map(list, f32 >= i)
+map(list, f32 >= i32)
+map(list, f32 ^ i)
 map(list, f32)
-map(list, f64 * 0.5)
-map(list, f64 * f32)
-map(list, f64 ** i32)
-map(list, f64 + 1)
-map(list, f64 + i32)
-map(list, f64 - 0.5)
-map(list, f64 < f64)
-map(list, f64 ^ i64)
+map(list, f64 < 0.5)
+map(list, f64 < f32)
+map(list, f64 <= 1)
+map(list, f64 > 1)
+map(list, f64 >= 0.5)
+map(list, f64 >= f32)
 map(list, f64)
-map(list, f64) != list
-map(list, false ? # : nil)
-map(list, false ? f32 : #)
-map(list, false ? f32 : foo)
-map(list, false and true)
-map(list, filter(list, false))
-map(list, first(list))
-map(list, float(0.5))
-map(list, float(1))
-map(list, float(f32))
-map(list, float(i64))
+map(list, f64)[i]
+map(list, false ? # : list)
+map(list, false) != array
+map(list, float(f64))
+map(list, float(i))
+map(list, float(i32))
 map(list, foo == #)
 map(list, foo)
-map(list, foo.Bar)
-map(list, foo.String)
-map(list, foo?.String())
+map(list, foo.Qux)
+map(list, foo.String())
 map(list, foo?.String)
-map(list, greet == greet)
-map(list, greet("foo"))
 map(list, greet)
-map(list, greet) != array ? 0.5 : 1
-map(list, half != score)
+map(list, groupBy(array, #))
+map(list, groupBy(array, i))
+map(list, groupBy(list, #))
+map(list, half == greet)
 map(list, half(0.5))
+map(list, half(f64))
 map(list, half)
-map(list, i * 1)
-map(list, i * i64)
-map(list, i + i)
-map(list, i >= f64)
-map(list, i >= i64)
-map(list, i ^ f32)
-map(list, i ^ i64)
+map(list, i ** 1)
+map(list, i + i64)
+map(list, i .. i)
+map(list, i < 0.5)
+map(list, i == 1)
 map(list, i)
-map(list, i32 * f32)
-map(list, i32 == i64)
-map(list, i32 == nil)
-map(list, i32 > i)
-map(list, i32 ^ 0.5)
+map(list, i)[i64]
+map(list, i32 % i64)
+map(list, i32 ** 0.5)
+map(list, i32 + f32)
+map(list, i32 - i32)
+map(list, i32 / f64)
+map(list, i32 < 1)
+map(list, i32 < i32)
+map(list, i32 <= 1)
+map(list, i32 >= 1)
 map(list, i32)
-map(list, i64 == 1)
-map(list, i64 == f32)
-map(list, i64 ^ (i + i32))
+map(list, i64 * i)
+map(list, i64 + i64)
+map(list, i64 <= i64)
+map(list, i64 == nil)
 map(list, i64)
-map(list, int(1))
-map(list, len(array))
+map(list, i64)[i64]
+map(list, i64)[i]
+map(list, last(array))
 map(list, list)
-map(list, map(array, score))
-map(list, map(list, #))
-map(list, min(i64))
+map(list, list)[i]
+map(list, map(array, #))
+map(list, map(array, 1))
+map(list, map(array, div))
+map(list, map(array, i64))
+map(list, map(list, "foo"))
+map(list, max(f32))
+map(list, min(0.5))
+map(list, min(f64))
 map(list, nil != #)
-map(list, nil != 1)
-map(list, nil != array)
-map(list, nil != i)
-map(list, nil != nil)
+map(list, nil != i64)
 map(list, nil == #)
-map(list, nil == div)
-map(list, nil == foo)
-map(list, nil == i32)
-map(list, nil not in array)
-map(list, not false)
+map(list, nil == ok)
+map(list, nil not in list)
+map(list, none(array, true))
 map(list, not ok)
-map(list, not true)
-map(list, ok ? i64 : i64)
+map(list, ok ? # : #)
+map(list, ok || ok)
 map(list, ok)
-map(list, ok) != array
-map(list, score != greet)
-map(list, score(i))
+map(list, reduce(array, half))
+map(list, reduce(list, foo))
+map(list, reduce(list, half))
+map(list, score != add)
+map(list, score(1))
 map(list, score)
+map(list, score)[i64]
 map(list, string(#))
-map(list, string(foo))
-map(list, string(nil))
-map(list, toBase64("foo"))
+map(list, string(1))
+map(list, string(add))
+map(list, string(i32))
 map(list, toJSON(#))
-map(list, toJSON(1))
-map(list, toJSON(foo))
-map(list, toJSON(i))
-map(list, trimPrefix("bar"))
-map(list, trimSuffix("foo"))
-map(list, true ? false : score)
-map(list, true ? nil : #)
+map(list, toJSON([#]))
+map(list, toJSON(false))
+map(list, toJSON(ok))
+map(list, true ? i : f32)
+map(list, true ? i32 : #)
+map(list, true ? list : div)
 map(list, true)[i32]
+map(list, type("bar"))
 map(list, type(#))
-map(list, type(greet))
-map(list, type(half))
-map(list, type(i))
-map(list, type(i64))
-map(list[i:i], i)
-map(map(array, "bar"), #)
-map(map(array, # >= #), add)
-map(map(array, #), # < #)
-map(map(array, #), # ^ i32)
+map(list, type(i32))
+map(list, type(true))
+map(list[i64:i32], greet)
+map(map(array, #), # - i32)
+map(map(array, #), # == #)
+map(map(array, #), # >= #)
 map(map(array, #), #)
 map(map(array, #), add)
-map(map(array, #), div)
-map(map(array, #), f32)
-map(map(array, #), f64)
+map(map(array, #), bitand(#, #))
 map(map(array, #), foo)
-map(map(array, #), foo.Qux)
 map(map(array, #), greet)
 map(map(array, #), half)
+map(map(array, #), i % i64)
 map(map(array, #), i)
+map(map(array, #), i32)
 map(map(array, #), i64)
-map(map(array, #), int(#))
-map(map(array, #), nil != half)
-map(map(array, #), score(i))
-map(map(array, #), score)
-map(map(array, 0.5), # != #)
+map(map(array, #), list)
 map(map(array, 0.5), #)
-map(map(array, 0.5), -1)
-map(map(array, 0.5), list)
-map(map(array, 1), #)
-map(map(array, 1), ok)
-map(map(array, 1), score)
-map(map(array, add), #)
-map(map(array, add), list)
-map(map(array, array), add)
-map(map(array, array), f64)
+map(map(array, 0.5), ok)
+map(map(array, 1), greet)
+map(map(array, array), i32 ^ i32)
+map(map(array, array), i64)
+map(map(array, array), reduce(#, array))
+map(map(array, div), i)
+map(map(array, div), list)
 map(map(array, f32), #)
-map(map(array, f64), add)
-map(map(array, f64), nil == nil)
-map(map(array, foo), #)
-map(map(array, foo), f64)
-map(map(array, foo), greet)
-map(map(array, half), div)
+map(map(array, f32), array)
+map(map(array, f32), f64)
+map(map(array, f64), # > #)
+map(map(array, f64), f64)
+map(map(array, f64), greet)
+map(map(array, foo), div)
+map(map(array, greet), foo)
+map(map(array, greet), list)
+map(map(array, half), array)
+map(map(array, i), #)
+map(map(array, i32), #)
+map(map(array, i64), array)
 map(map(array, i64), f64)
-map(map(array, list), #)
-map(map(array, true), #)
-map(map(array, true), div)
-map(map(array, true), foo)
-map(map(list, "foo"), add)
-map(map(list, "foo"), div)
-map(map(list, "foo"), i32)
-map(map(list, #), "bar" + "foo")
+map(map(array, list), foo)
+map(map(array, ok), !#)
+map(map(array, ok), -f32)
+map(map(array, true), # != nil)
+map(map(array, true), i64)
 map(map(list, #), # != #)
 map(map(list, #), #)
-map(map(list, #), array)
+map(map(list, #), #?.Qux)
+map(map(list, #), .Bar)
 map(map(list, #), div)
 map(map(list, #), f32)
 map(map(list, #), f64)
 map(map(list, #), greet)
-map(map(list, #), i)
-map(map(list, #), i32)
-map(map(list, #), i64 < i32)
-map(map(list, #), i64)
-map(map(list, #), nil != i)
+map(map(list, #), half)
+map(map(list, #), list)
 map(map(list, #), ok)
 map(map(list, #), score)
-map(map(list, 0.5), # / #)
 map(map(list, 0.5), #)
-map(map(list, 0.5), greet)
-map(map(list, 0.5), list)
-map(map(list, 0.5), score)
-map(map(list, 1), # <= #)
-map(map(list, 1), foo)
-map(map(list, add), [#, #])
-map(map(list, add), f64)
-map(map(list, f32), #)
-map(map(list, f32), greet)
-map(map(list, f32), true ? "foo" : "foo")
-map(map(list, f64), #)
-map(map(list, false), array)
-map(map(list, false), f64)
-map(map(list, false), i32)
-map(map(list, false), list)
+map(map(list, 0.5), div)
+map(map(list, 1), # * #)
+map(map(list, 1), f32)
+map(map(list, add), #)
+map(map(list, add), i)
+map(map(list, array), f64)
+map(map(list, array), findIndex(#, ok))
+map(map(list, f64), f32)
+map(map(list, f64), i32)
+map(map(list, false), 0.5 / f64)
 map(map(list, foo), #)
-map(map(list, foo), ok)
-map(map(list, greet), "bar" != "foo")
-map(map(list, greet), # == #)
-map(map(list, greet), #)
-map(map(list, greet), ["foo", 1])
-map(map(list, greet), half)
-map(map(list, half), #)
-map(map(list, i), i32)
-map(map(list, i32), half)
-map(map(list, i32), list)
+map(map(list, foo), list)
+map(map(list, greet), "bar" <= "foo")
+map(map(list, i64), # >= f64)
 map(map(list, i64), #)
-map(map(list, i64), array)
-map(map(list, i64), div)
-map(map(list, i64), f64)
-map(map(list, i64), list)
+map(map(list, i64), i64)
 map(map(list, list), #)
-map(map(list, list), div)
-map(map(list, list), i)
-map(map(list, ok), #)
-map(map(list, score), #)
-map(map(list, score), ok)
-map(map(list, true), #)
-map(ok ? "foo" : 0.5, #)
-map(ok ? "foo" : greet, f32)
-map(ok ? array : "bar", ok)
-map(ok ? array : foo, # / 1)
-map(sort(array), # > #)
-map(sort(array), i32 > #)
-map(true ? "bar" : true, #)
-map(true ? "foo" : add, i64)
-map(true ? array : f64, #)
-map(true ? array : true, #)
-max(--1)
+map(map(list, ok), f64 > i64)
+map(map(list, ok), foo)
+map(map(list, true), f64)
+map(map(list, true), list)
+map(ok ? "bar" : i64, ok)
+map(ok ? "bar" : ok, i64)
+map(ok ? "bar" : score, 1 .. #)
+map(ok ? array : foo, foo)
+map(ok ? array : i64, list)
+map(ok ? list : i64, #)
+map(ok ? list : list, add)
+map(reduce(array, array), # <= #)
+map(reduce(array, array), #)
+map(reduce(list, array), -i32)
+map(reduce(list, array), foo)
+map(reduce(list, array), half)
+map(reduce(list, list), #)
+map(sort(array), # / 0.5)
+map(sort(array), #)
+map(sort(array), greet)
+map(split("foo", "bar"), #)
+map(true ? "foo" : 0.5, # * #)
+map(true ? array : "foo", f32 + #)
+map(true ? list : greet, greet)
+map(true ? list : list, #)
 max(-0.5)
 max(-1)
-max(-1, i)
-max(-count(list, false), i64)
 max(-f32)
 max(-f64)
+max(-findIndex(array, ok))
 max(-i)
-max(-i, i32, i)
+max(-i, f32)
 max(-i32)
 max(-i64)
-max(-i64, 0.5 / f64)
-max(0.5 * 0.5)
-max(0.5 * f64)
+max(-reduce(array, #))
+max(0.5 * f32)
 max(0.5 * i)
-max(0.5 * i, i32)
-max(0.5 * i32)
+max(0.5 * i64)
 max(0.5 ** 0.5)
 max(0.5 ** 1)
 max(0.5 ** f32)
-max(0.5 ** f64)
+max(0.5 ** f64 ^ reduce(array, f64))
 max(0.5 ** i)
-max(0.5 ** i64)
-max(0.5 + 0.5)
+max(0.5 ** i32)
 max(0.5 + 1)
-max(0.5 + i)
-max(0.5 + i32)
-max(0.5 + i64)
 max(0.5 - 0.5)
-max(0.5 - 1)
-max(0.5 - i)
-max(0.5 - i32)
-max(0.5 - i64)
+max(0.5 - f32)
+max(0.5 - f64)
 max(0.5 / 0.5)
-max(0.5 / f32)
+max(0.5 / 1)
 max(0.5 / f64)
-max(0.5 / f64, f64)
-max(0.5 / i)
+max(0.5 / i32)
 max(0.5 / i64)
 max(0.5 ^ 0.5)
 max(0.5 ^ 1)
-max(0.5 ^ f32)
 max(0.5 ^ i)
 max(0.5 ^ i32)
 max(0.5 ^ i64)
-max(0.5) != i == ok
-max(0.5) * f32
-max(0.5) * f64
+max(0.5) != f32
+max(0.5) != i
+max(0.5) + f64
 max(0.5) + i
-max(0.5) - f32
-max(0.5) - f64
-max(0.5) < f64
-max(0.5) <= 0.5 - 0.5
-max(0.5) <= f64
-max(0.5) == f32
-max(0.5) == i64
-max(0.5) > f32
-max(0.5) >= i32
-max(0.5) ^ i32
-max(0.5, 1) <= i32
+max(0.5) - i32
+max(0.5) / i64
+max(0.5) <= i
+max(0.5) > f64
+max(0.5) > i
+max(0.5) > i64
+max(0.5) >= i64
+max(0.5, 0.5) != i
+max(0.5, i) ** i32
 max(1 % 1)
-max(1 % i)
-max(1 % i32)
 max(1 % i64)
 max(1 * 0.5)
 max(1 * 1)
+max(1 * f64)
+max(1 * i32)
 max(1 ** 0.5)
 max(1 ** 1)
-max(1 ** f64)
+max(1 ** f32)
 max(1 ** i64)
-max(1 + f32, f64)
+max(1 + f32)
 max(1 + i64)
-max(1 - 1)
-max(1 - i32)
-max(1 - i64)
-max(1 / 0.5)
+max(1 - f32)
+max(1 - f64)
 max(1 / 1)
 max(1 / f32)
+max(1 / f32, i64)
 max(1 / f64)
+max(1 / i)
+max(1 / i32)
+max(1 / i64)
+max(1 ^ 0.5)
 max(1 ^ 1)
+max(1 ^ f32)
+max(1 ^ f64)
 max(1 ^ i32)
-max(1) != i
-max(1) * i
+max(1 ^ i64)
+max(1) != 1 ? foo : "bar"
+max(1) + f32
 max(1) - f64
-max(1) - i64
-max(1) .. i32
+max(1) .. i
 max(1) / i
-max(1) / i64
-max(1) <= f32
-max(1) <= i
-max(1) <= i32
-max(1) <= i64
-max(1) == f32
-max(1) > f32
+max(1) == i64
 max(1) > f64
-max(1) > i
-max(1) > i64
-max(1, i32, f32) != i64
+max(1) > i32
+max(1, i) not in array
 max(abs(0.5))
 max(abs(1))
 max(abs(f32))
 max(abs(f64))
 max(abs(i))
 max(abs(i32))
-max(abs(i64))
+max(add(1, i))
 max(array[1])
 max(array[i64])
-max(array[i])
-max(count(array, false))
-max(count(list, false))
-max(div(1, 1))
-max(f32 * 0.5)
+max(bitnand(i32, 1))
+max(bitnot(1))
+max(bitnot(i))
+max(bitnot(i64))
+max(bitshr(1, i32))
+max(bitxor(1, 1))
+max(ceil(0.5), f64 / i64)
+max(ceil(f32))
+max(ceil(i32))
 max(f32 * 1)
-max(f32 * f32)
-max(f32 * i32)
-max(f32 ** 0.5)
+max(f32 * f64)
+max(f32 * i64)
 max(f32 ** 1)
-max(f32 ** i32)
-max(f32 ** i64)
+max(f32 ** f64)
 max(f32 + 1)
 max(f32 + f64)
+max(f32 + i)
 max(f32 + i64)
-max(f32 - f64)
-max(f32 - i)
-max(f32 - i32)
+max(f32 - 1)
+max(f32 - i64)
 max(f32 / 0.5)
 max(f32 / f32)
-max(f32 ^ 0.5)
 max(f32 ^ 1)
 max(f32 ^ f32)
-max(f32 ^ i32)
+max(f32 ^ f64)
 max(f32 ^ i64)
 max(f32)
-max(f32) != -i32
-max(f32) != i32
-max(f32) + i64
-max(f32) - f32
-max(f32) <= i
-max(f32) <= max(f64)
-max(f32) >= i64
+max(f32) * i64
+max(f32) ** i
+max(f32) + f32
+max(f32) + f64
+max(f32) - f64
+max(f32) / i32
+max(f32) < i
+max(f32) == i
 max(f32) ^ f32
-max(f32) ^ i32
-max(f32, -f32)
-max(f32, 1) > i32
 max(f32, f32)
 max(f32, f64)
+max(f32, f64) in array
 max(f32, i)
 max(f32, i32)
+max(f32, i32) ** i64
 max(f32, i64)
-max(f32, min(i))
-max(f64 * 0.5)
+max(f64 * 1)
 max(f64 * f64)
-max(f64 * i, f32)
-max(f64 * i32)
-max(f64 ** 1)
+max(f64 ** 0.5)
+max(f64 ** f64)
 max(f64 ** i)
-max(f64 ** i64)
-max(f64 + 0.5)
-max(f64 - i32)
-max(f64 - i64)
-max(f64 / 0.5)
-max(f64 / f32)
-max(f64 / i32)
+max(f64 + 1)
+max(f64 + f32)
+max(f64 + f64)
+max(f64 - 0.5)
+max(f64 - i)
 max(f64 ^ 0.5)
-max(f64 ^ i32)
-max(f64 ^ i64)
+max(f64 ^ 1)
+max(f64 ^ f32)
+max(f64 ^ f64)
 max(f64)
-max(f64) != i
-max(f64) + f32
-max(f64) + i64
-max(f64) - f32
-max(f64) / f32
-max(f64) / i32
-max(f64) == f64
-max(f64) == i32
-max(f64) > f32
-max(f64) > f64
-max(f64) > i64
-max(f64) ^ 1 ^ i64
-max(f64) ^ i
-max(f64) ^ min(i32, 1)
-max(f64, -1)
-max(f64, 0.5 ** i64)
-max(f64, 1) <= f64
-max(f64, 1) == i32
+max(f64) != f64
+max(f64) < i32
+max(f64) <= f32
+max(f64) == f32
+max(f64) == i
+max(f64) == round(i)
+max(f64) ^ f32
+max(f64) ^ i64
 max(f64, f32)
-max(f64, f32, i32)
-max(f64, f32, i64)
+max(f64, f32) <= int(f64)
 max(f64, f64)
-max(f64, f64, score(1))
-max(f64, float(i))
-max(f64, half(f64))
 max(f64, i)
+max(f64, i) - 1 ^ i
+max(f64, i) < i
+max(f64, i) > f64
 max(f64, i32)
 max(f64, i64)
-max(false ? 1 : 0.5)
-max(false ? 1 : nil)
-max(false ? add : ok)
-max(false ? half : list)
-max(false ? i : nil)
-max(false ? i32 : score)
-max(false ? true : 1)
-max(find(array, ok))
-max(find(array, true))
-max(findIndex(array, ok))
-max(findIndex(array, true))
+max(f64, i64) ^ f32
+max(false ? 0.5 : array)
+max(false ? add : f64)
+max(false ? div : half)
+max(false ? div : i64)
+max(false ? ok : 0.5)
+max(find(array, false))
+max(findIndex(list, false))
 max(findIndex(list, ok))
-max(findIndex(list, true))
 max(findLast(array, false))
-max(findLast(array, true))
-max(findLastIndex(array, false))
-max(findLastIndex(list, true))
-max(first(array))
 max(float(0.5))
 max(float(1))
-max(float(f32))
-max(float(f64))
-max(float(i))
+max(float(1), i)
+max(float(i32))
 max(float(i64))
-max(float(i64), f64)
+max(float(score(i)))
+max(floor(0.5))
+max(floor(1))
+max(floor(f32))
+max(floor(i))
+max(floor(i32))
+max(floor(len(array)))
 max(get(array, 1))
 max(get(array, i))
 max(get(array, i32))
 max(get(array, i64))
-max(half(-0.5))
 max(half(0.5))
+max(half(1))
+max(half(1), i64)
 max(half(f64))
-max(i % i)
-max(i % i32)
-max(i % i64)
+max(i % 1)
 max(i * 0.5)
-max(i * 1)
 max(i * f32)
-max(i * i32)
-max(i ** 0.5)
-max(i ** 1)
+max(i * i)
+max(i * i64)
 max(i ** f64)
-max(i ** i)
-max(i ** i64)
-max(i + 0.5)
+max(i ** score(1))
 max(i + 1)
-max(i + f32)
-max(i + f64)
-max(i + i)
 max(i - 1)
-max(i - i32)
-max(i - i32, f32)
+max(i - i)
 max(i - i64)
-max(i / 0.5)
-max(i / f32)
-max(i / i32, f64)
-max(i ^ 0.5)
-max(i ^ 1)
-max(i ^ f32)
 max(i ^ f64)
 max(i)
-max(i) != f64
-max(i) ** f64
-max(i) + f32
-max(i) + i64
-max(i) - f32
-max(i) - f64
-max(i) - i32
-max(i) - i64
-max(i) / f64
-max(i) >= i64
-max(i) ^ (i * i)
-max(i) ^ f32
-max(i, -f32)
+max(i) != i32
+max(i) != i64
+max(i) % (i64 + i)
+max(i) % array[i32]
+max(i) ** (1 / i32)
+max(i) + f64
+max(i) - i
+max(i) / f32
+max(i) / i
+max(i) < 0.5 - f64
+max(i) < f32
+max(i) < i32
+max(i) <= f64
+max(i) == f64
+max(i) >= i
 max(i, f32)
-max(i, f32, f32)
 max(i, f64)
 max(i, i)
 max(i, i32)
 max(i, i64)
-max(i, i64, i64)
+max(i, i64, i32)
 max(i32 % 1)
-max(i32 % i32)
 max(i32 * 0.5)
 max(i32 * 1)
 max(i32 * f32)
+max(i32 * i)
 max(i32 * i64)
-max(i32 + 0.5, f64)
-max(i32 + f64)
-max(i32 + i)
-max(i32 + i32)
+max(i32 ** f32)
+max(i32 ** i)
+max(i32 ** i32)
+max(i32 + 0.5)
+max(i32 + i64)
+max(i32 - 0.5)
+max(i32 - 1)
+max(i32 - f64)
 max(i32 - i)
-max(i32 - i64)
-max(i32 / f32)
-max(i32 / f64)
-max(i32 / i64)
-max(i32 ^ 0.5)
-max(i32 ^ 1)
-max(i32 ^ f32)
+max(i32 / 1)
 max(i32 ^ i)
-max(i32 ^ i32)
+max(i32 ^ i, f32)
 max(i32)
-max(i32) != min(i64)
-max(i32) - f32
-max(i32) - i64
+max(i32) * i32
 max(i32) / f32
-max(i32) >= i32
-max(i32) ^ i64
-max(i32, 1) == i32
-max(i32, abs(f64))
+max(i32) / i
+max(i32) <= f32
+max(i32) ^ f32
+max(i32) in array
 max(i32, f32)
-max(i32, f32) != i32
 max(i32, f64)
-max(i32, f64) - f32
 max(i32, i)
-max(i32, i, i)
 max(i32, i32)
-max(i32, i32, i)
 max(i32, i64)
 max(i64 % i)
-max(i64 % i32)
 max(i64 * 0.5)
-max(i64 * 1)
-max(i64 * f32)
-max(i64 * i32)
-max(i64 ** 1)
+max(i64 * i64)
+max(i64 ** 0.5)
+max(i64 ** f32)
 max(i64 ** i64)
-max(i64 + 0.5)
-max(i64 + f32)
-max(i64 + i32)
+max(i64 + i)
+max(i64 + i64)
 max(i64 - 0.5)
 max(i64 - 1)
-max(i64 - f32)
 max(i64 - f64)
-max(i64 - i)
-max(i64 / 1)
 max(i64 / f64)
-max(i64 / i)
+max(i64 / i32)
 max(i64 / i64)
 max(i64 ^ 0.5)
 max(i64 ^ 1)
 max(i64 ^ i)
-max(i64 ^ i64)
 max(i64)
-max(i64) != f32
-max(i64) != i32
-max(i64) * i32
-max(i64) * i64
-max(i64) ** i64
-max(i64) + f32
-max(i64) + i64
-max(i64) / f32
-max(i64) / i
-max(i64) / i64
+max(i64) ** (1 + 1)
+max(i64) ** f32
+max(i64) + i32
+max(i64) - i32
+max(i64) - i64
+max(i64) .. i32
 max(i64) < f32
-max(i64) < i64
-max(i64) <= i
-max(i64) == f32
-max(i64) == f64
-max(i64) >= i32
-max(i64) ^ (i64 / f32)
-max(i64) in array
-max(i64, 1) * i32
+max(i64) >= f32
+max(i64) ^ i
+max(i64, 0.5 + 1)
+max(i64, 0.5, i64) ** i32
 max(i64, f32)
 max(i64, f64)
+max(i64, half(1))
 max(i64, i)
+max(i64, i) + i32
 max(i64, i32)
+max(i64, i32) == f64
 max(i64, i64)
 max(int(0.5))
-max(int(1))
 max(int(f32))
-max(int(f64))
-max(int(i))
 max(int(i32))
 max(int(i64))
-max(last(array))
-max(len("bar"))
 max(len("foo"))
 max(len(array))
 max(len(list))
-max(len(list), 0.5 - i)
 max(max(0.5))
-max(max(0.5, 0.5))
+max(max(0.5, f64))
 max(max(1))
-max(max(f32))
-max(max(f64))
 max(max(i))
 max(max(i32))
 max(max(i64))
-max(min(0.5))
-max(min(0.5, i))
+max(mean(array))
+max(median(array))
+max(min(0.5, 0.5))
 max(min(1))
-max(min(1, i64, 1))
-max(min(f32))
-max(min(f64))
-max(min(f64, i64))
+max(min(1, f64))
+max(min(f32, i64, i32))
 max(min(i))
 max(min(i32))
-max(min(i32, i))
-max(ok ? 1 : foo)
+max(ok ? "foo" : f64)
+max(ok ? 0.5 : i64)
 max(ok ? 1 : i)
-max(ok ? 1 : i32)
-max(ok ? div : foo)
-max(ok ? div : i64)
-max(ok ? i : true)
-max(ok ? ok : i64)
-max(ok ? true : 0.5)
+max(ok ? array : true)
+max(ok ? foo : greet)
+max(ok ? half : f32)
+max(ok ? half : list)
+max(ok ? i : 1)
+max(ok ? i : nil)
+max(reduce(array, # % #))
+max(reduce(array, #))
+max(reduce(array, 1))
+max(reduce(array, f32))
+max(reduce(array, f64))
+max(reduce(list, 0.5))
+max(reduce(list, f32), i64)
+max(reduce(list, i64))
+max(round(1))
+max(round(f32))
+max(round(f64))
+max(round(i))
+max(round(i32))
 max(score(1))
-max(score(1), i64)
-max(score(i))
-max(score(i, i))
-max(true ? 0.5 : half)
-max(true ? 1 : i64)
-max(true ? add : list)
-max(true ? foo : add)
-max(true ? foo : f32)
-max(true ? i : ok)
-max(true ? i64 : "bar")
-min(-(0.5 + i))
-min(-(f32 + i64))
+max(score(i), i)
+max(true ? f32 : f32)
+max(true ? foo : array)
+max(true ? greet : 1)
+max({"bar": list}.String)
+max({"foo": array}?.f32)
+max({"foo": half}?.f32)
+mean(1 .. 1)
+mean(1 .. i)
+mean([f64, 0.5])
+mean([i])
+mean(array)
+mean(array) * i
+mean(array) + i
+mean(array) - min(i)
+mean(array) / i
+mean(array) / i64
+mean(array) < f32
+mean(array) < f64
+mean(array) <= i64
+mean(array) > f32
+mean(array) >= f32
+mean(array) >= i64
+mean(array) ^ i
+mean(array) ^ i32
+mean(filter(array, true))
+mean(groupBy(array, #)?.half)
+mean(groupBy(array, i64).score)
+mean(i .. 1)
+mean(i .. i)
+mean(map(array, #))
+mean(map(array, -#))
+mean(map(array, f32))
+mean(map(array, i))
+mean(map(array, i32))
+mean(map(list, 1))
+mean(map(list, f32))
+mean(map(list, i))
+mean(map(list, i32))
+mean(sort(array))
+median(1 .. i)
+median(array)
+median(array) != f32
+median(array) * 1 * f32
+median(array) * i32
+median(array) ** i64
+median(array) + f32
+median(array) >= i32
+median(array) ^ i32
+median(array) ^ i64
+median(array) not in array
+median(array[1:1])
+median(filter(array, ok))
+median(groupBy(list, #).i32)
+median(i .. i)
+median(i .. i64)
+median(i64 .. i64)
+median(map(array, #))
+median(map(array, 1))
+median(map(list, 0.5))
+median(map(list, f32))
+median(map(list, i32))
+median(reduce(array, array))
+median(reduce(list, array))
+median(sort(array))
 min(-0.5)
 min(-0.5, i)
 min(-1)
-min(-1, i)
-min(-1, i64)
 min(-f32)
-min(-f32, i64)
 min(-f64)
-min(-f64, i32)
+min(-half(0.5))
 min(-i)
 min(-i32)
 min(-i64)
 min(0.5 * 0.5)
 min(0.5 * 1)
+min(0.5 * f32, i32 ** i32)
 min(0.5 * f64)
 min(0.5 * i32)
-min(0.5 ** 0.5)
-min(0.5 ** f64)
+min(0.5 * i64)
+min(0.5 ** i)
 min(0.5 ** i64)
-min(0.5 + 1)
-min(0.5 + f32)
 min(0.5 + f64)
 min(0.5 + i)
+min(0.5 + i32)
 min(0.5 - 0.5)
 min(0.5 - 1)
+min(0.5 - f32)
 min(0.5 - f64)
 min(0.5 - i)
 min(0.5 / 0.5)
-min(0.5 / f64)
-min(0.5 ^ 1)
+min(0.5 / i64)
+min(0.5 / i64, i64)
+min(0.5 ^ 0.5)
 min(0.5 ^ f32)
 min(0.5 ^ i)
-min(0.5) != i32
-min(0.5) * 0.5 ** i64
+min(0.5 ^ i32)
+min(0.5) != i64
+min(0.5) * i32
+min(0.5) ** f64
 min(0.5) ** i
-min(0.5) + i
-min(0.5) + i32
-min(0.5) + i64
-min(0.5) < f32
-min(0.5) <= i ? f32 : 1
-min(0.5) <= i64
-min(0.5) == i - 0.5
-min(0.5) > i64
-min(0.5) >= i
-min(0.5, 0.5) == f32
-min(0.5, 1) >= i64
-min(0.5, i) == i64
-min(0.5, i32, f32) + f32
+min(0.5) + f64 ^ i64
+min(0.5) - f32
+min(0.5) - f64
+min(0.5) / i32
+min(0.5) < i32
+min(0.5) == f32 / f32
+min(0.5) == i
+min(0.5) >= i64
+min(0.5) ^ (f32 - i64)
+min(0.5, 0.5) < f32 + f64
+min(1 % 1)
+min(1 % i)
 min(1 % i32)
 min(1 % i64)
 min(1 * 0.5)
 min(1 * 1)
+min(1 * f32)
 min(1 * i)
 min(1 * i32)
-min(1 * i64)
-min(1 ** 0.5)
-min(1 ** f32)
-min(1 ** f64)
-min(1 ** i32)
+min(1 ** i)
 min(1 + 0.5)
 min(1 + 1)
 min(1 + f32)
-min(1 + i32)
 min(1 + i64)
 min(1 - 1)
 min(1 - f64)
 min(1 - i)
 min(1 - i32)
-min(1 / 1)
+min(1 - i64)
+min(1 / 0.5)
+min(1 / f32)
 min(1 / i)
 min(1 / i32)
-min(1 / i32, f64)
 min(1 / i64)
+min(1 ^ 0.5)
 min(1 ^ 1)
 min(1 ^ f32)
-min(1 ^ f64)
-min(1) != 1 ? list : f64
+min(1 ^ i)
+min(1 ^ i32)
+min(1 ^ i64)
 min(1) != i
-min(1) % i64
-min(1) * -0.5
-min(1) * 1 ** 1
-min(1) - i64 ^ 0.5
-min(1) .. i
-min(1) .. i64
-min(1) / f64
-min(1) / i
-min(1) < i
-min(1) == f64
-min(1) == i32
+min(1) - i
+min(1) .. i32
+min(1) <= f32
+min(1) <= f64
+min(1) > i64
+min(1) >= i
 min(1) >= i64
-min(1) ^ f32
+min(1) ^ f64
 min(abs(0.5))
 min(abs(1))
 min(abs(f32))
 min(abs(f64))
-min(abs(i * 1))
 min(abs(i))
 min(abs(i32))
-min(abs(i64))
-min(abs(i64), f64)
-min(add(1, i))
-min(add(i, i))
 min(array[1])
+min(array[i32])
 min(array[i])
+min(bitnand(1, i32))
+min(bitnot(1))
+min(bitnot(i))
+min(bitnot(i32))
+min(bitnot(i32), i64)
+min(bitnot(i64))
+min(ceil(0.5))
+min(ceil(1))
+min(ceil(f32))
+min(ceil(f64))
+min(ceil(i))
 min(count(array, false))
-min(count(array, ok))
-min(count(array, true))
 min(count(list, ok))
 min(f32 * 1)
-min(f32 * f32)
-min(f32 * i32)
-min(f32 ** i32)
-min(f32 ** i64)
-min(f32 ** i64, f32)
-min(f32 + f64)
-min(f32 + i)
-min(f32 + i32)
-min(f32 + i64)
-min(f32 - f32)
+min(f32 * i64)
+min(f32 ** 0.5)
+min(f32 - 0.5)
+min(f32 - 1)
+min(f32 - f64)
 min(f32 - i)
-min(f32 - i32)
 min(f32 - i64)
-min(f32 / 0.5)
-min(f32 / f64)
-min(f32 / i)
-min(f32 / i32)
+min(f32 / 1)
 min(f32 / i64)
-min(f32 ^ 1)
-min(f32 ^ f32)
-min(f32 ^ i)
 min(f32 ^ i32)
 min(f32)
-min(f32) * f32
-min(f32) * f64
-min(f32) + i
-min(f32) + i32
-min(f32) + i64
-min(f32) - f32
-min(f32) < i64
+min(f32) * i64
+min(f32) / f64
+min(f32) / i32
 min(f32) == i
-min(f32) == i32 * i32
-min(f32) == i64
-min(f32) > i32
-min(f32) ^ f64
-min(f32, 0.5 ^ 0.5)
-min(f32, 0.5) <= i64
+min(f32) >= f64
+min(f32, -0.5)
+min(f32, ceil(1))
 min(f32, f32)
 min(f32, f64)
-min(f32, f64) >= i
-min(f32, get(array, i64))
 min(f32, i)
 min(f32, i32)
 min(f32, i64)
-min(f32, len(array))
-min(f32, len(list))
-min(f64 * 0.5)
 min(f64 * 1)
 min(f64 * f64)
-min(f64 * i)
-min(f64 * i32)
-min(f64 ** 1)
+min(f64 ** f32)
 min(f64 ** f64)
-min(f64 ** i)
-min(f64 ** i32)
-min(f64 ** i64)
-min(f64 + 1)
-min(f64 + i)
+min(f64 + 0.5)
+min(f64 + f32)
 min(f64 + i64)
-min(f64 - 0.5)
+min(f64 - 1)
 min(f64 - i)
 min(f64 - i32)
-min(f64 - i64)
-min(f64 / 1)
+min(f64 / 0.5)
 min(f64 / f32)
 min(f64 / i)
-min(f64 / i32)
 min(f64 / i64)
-min(f64 ^ 0.5)
-min(f64 ^ f64)
-min(f64 ^ i32)
+min(f64 ^ 1)
 min(f64)
-min(f64) + f64
-min(f64) + i32
-min(f64) + i64
-min(f64) / f32
-min(f64) ^ 1 ^ 1
-min(f64) ^ i32
-min(f64) ^ i64
-min(f64, 0.5 ** 1)
-min(f64, 0.5, i) <= f64
-min(f64, 1 ** i)
-min(f64, 1) < i64
+min(f64) * f64
+min(f64) * i32
+min(f64) / i
+min(f64) >= f64
+min(f64, 0.5 ** i64)
+min(f64, 0.5) == f64
 min(f64, f32)
 min(f64, f64)
-min(f64, f64, i64)
 min(f64, i)
 min(f64, i32)
 min(f64, i64)
-min(false ? 1 : add)
-min(false ? f64 : false)
-min(false ? f64 : score)
-min(false ? foo : 1)
-min(false ? greet : i)
-min(false ? i32 : "foo")
-min(false ? i32 : i64)
-min(false ? true : 0.5)
+min(false ? foo : i32)
+min(false ? greet : f32)
 min(find(array, false))
 min(find(array, ok))
-min(findIndex(list, ok))
-min(findLast(array, true))
-min(findLastIndex(array, false))
+min(findIndex(array, false))
+min(findLastIndex(array, i32 > #))
 min(findLastIndex(array, ok))
 min(findLastIndex(array, true))
 min(findLastIndex(list, ok))
@@ -10892,220 +13685,188 @@ min(float(1))
 min(float(f32))
 min(float(f64))
 min(float(i))
-min(float(i32))
-min(float(i64))
-min(get(array, i))
-min(get(array, i64))
-min(half(0.5 ^ i32))
+min(float(i64), i)
+min(floor(0.5))
+min(floor(1))
+min(floor(f32))
+min(floor(i))
+min(floor(i32))
+min(floor(i64))
 min(half(0.5))
-min(half(0.5), f32)
+min(half(1))
+min(half(1), -1)
+min(half(f64 - 0.5))
 min(half(f64))
 min(i % 1)
-min(i % i32)
 min(i % i64)
-min(i * 0.5)
-min(i * 1)
 min(i * i)
-min(i * i64)
 min(i ** 0.5)
-min(i ** f32)
-min(i ** f64)
 min(i ** i)
-min(i ** i64)
-min(i + 0.5)
-min(i + f32)
-min(i + f64)
-min(i + i)
+min(i + 1)
 min(i - 0.5)
-min(i - 1)
-min(i - i)
-min(i / 0.5)
-min(i / i64)
-min(i / i64, i)
-min(i ^ 0.5)
-min(i ^ i, i32)
+min(i - f64)
+min(i - i32)
+min(i / 1) + f64
+min(i / f64)
+min(i ^ f32)
+min(i ^ f64)
+min(i ^ i)
 min(i)
-min(i) != i32
-min(i) % i
 min(i) * f32
-min(i) ** i
-min(i) .. i
+min(i) ** i64
 min(i) / f64
-min(i) < f32
-min(i) <= i64
+min(i) / i
+min(i) < f64
+min(i) < i32
+min(i) >= i32
+min(i) ^ f32
 min(i, f32)
+min(i, f32, i) + i32
 min(i, f64)
 min(i, i)
-min(i, i32 - i)
 min(i, i32)
-min(i, i64 * f32)
 min(i, i64)
-min(i32 % i)
-min(i32 * 1)
-min(i32 * f64)
-min(i32 * i32)
-min(i32 ** 1 ^ i64)
-min(i32 ** f32)
-min(i32 ** i)
-min(i32 ** i64)
-min(i32 + 0.5)
-min(i32 + 1)
-min(i32 + f32)
+min(i, last(array))
+min(i32 % 1)
+min(i32 * f32)
+min(i32 * i)
+min(i32 ** 0.5)
+min(i32 ** i32)
+min(i32 + i32)
+min(i32 + i64)
 min(i32 - 0.5)
-min(i32 - 1)
-min(i32 - i32)
-min(i32 / 1)
-min(i32 / i)
-min(i32 / i64)
-min(i32 / i64, score(1))
-min(i32 ^ 1)
+min(i32 - i64)
+min(i32 / 0.5)
+min(i32 / f64)
+min(i32 ^ 0.5)
+min(i32 ^ f32)
 min(i32 ^ f64)
-min(i32 ^ i)
 min(i32 ^ i64)
 min(i32)
-min(i32) != i64
-min(i32) + f32
-min(i32) - i64
-min(i32) / f32
-min(i32) < i32
-min(i32) == f32
-min(i32) == i32
-min(i32) >= i32
-min(i32) ^ f64
-min(i32, 0.5) .. i32
+min(i32) - i
+min(i32) .. i32
+min(i32) / i
+min(i32) < i
+min(i32) <= f32
+min(i32) <= i
+min(i32) > f32
+min(i32) > i64 + f64
+min(i32) >= i
+min(i32) ^ f32
+min(i32) ^ i64
 min(i32, f32)
+min(i32, f64 * 0.5)
 min(i32, f64)
 min(i32, i)
 min(i32, i32)
-min(i32, i32, i)
 min(i32, i64)
-min(i32, i64) .. i
-min(i32, i64) <= f64
-min(i32, min(i))
-min(i64 % i32)
-min(i64 * 1, f32)
-min(i64 * f64)
+min(i64 % 1)
+min(i64 * 0.5)
+min(i64 * 1)
+min(i64 * bitnot(i64))
+min(i64 * i)
 min(i64 * i32)
+min(i64 * i64)
 min(i64 ** 0.5)
-min(i64 ** 1)
+min(i64 ** f64)
 min(i64 ** i)
-min(i64 + 0.5)
-min(i64 + 1)
+min(i64 ** i32)
 min(i64 + f32)
-min(i64 + i)
-min(i64 + i32)
-min(i64 - 0.5)
-min(i64 - f32)
 min(i64 - f64)
-min(i64 - i)
-min(i64 - i64)
-min(i64 / 0.5)
-min(i64 / f64)
+min(i64 - i32)
+min(i64 / 1)
+min(i64 / f32)
 min(i64 / i)
+min(i64 / i32)
 min(i64 / i64)
+min(i64 ^ 0.5)
 min(i64 ^ 1)
+min(i64 ^ f64)
 min(i64 ^ i32)
-min(i64 ^ i64)
 min(i64)
-min(i64) != i64
-min(i64) % i32
-min(i64) ** -1
-min(i64) ** -f64
-min(i64) ** i
-min(i64) + i32
-min(i64) .. i
-min(i64) .. i64
-min(i64) <= f32
-min(i64) == i
-min(i64) ^ f32
-min(i64) ^ f64
-min(i64) in array
-min(i64, 1 ** 0.5)
-min(i64, 1) <= f64
+min(i64) / f32
+min(i64) < i32
+min(i64) >= f64
+min(i64) not in array
 min(i64, f32)
 min(i64, f64)
-min(i64, f64) != f64
-min(i64, f64) * i32
-min(i64, f64, i32)
 min(i64, i)
 min(i64, i32)
-min(i64, i32, i)
 min(i64, i64)
-min(i64, i64, f32)
+min(i64, i64) < i64
 min(int(0.5))
 min(int(1))
 min(int(f32))
 min(int(f64))
 min(int(i))
+min(int(i32))
 min(int(i64))
+min(last(1 .. 1))
 min(last(array))
-min(len("bar"))
-min(len("foo"))
 min(len(array))
 min(len(list))
-min(len(list), f64)
 min(max(0.5))
-min(max(1))
 min(max(1, 0.5))
-min(max(1, f32))
-min(max(1, i32))
 min(max(f32))
 min(max(f64))
-min(max(i), i64)
-min(max(i32))
-min(min(0.5))
-min(min(0.5, 1))
+min(max(i))
+min(max(i64, 1))
+min(mean(array))
 min(min(1))
-min(min(f32))
-min(min(f32, i, i32))
-min(min(f64))
+min(min(1, 1, 1))
+min(min(1, i, f32))
 min(min(i))
 min(min(i32))
-min(min(i64))
-min(ok ? add : 0.5)
-min(ok ? f32 : "foo")
-min(ok ? f64 : true)
-min(ok ? foo : 1)
-min(ok ? true : 1)
+min(min(reduce(list, f32)))
+min(ok ? array : false)
+min(ok ? f64 : i)
+min(ok ? half : ok)
+min(ok ? i : f32)
+min(ok ? list : score)
+min(ok ? true : div)
+min(reduce(array, #))
+min(reduce(array, 0.5))
+min(reduce(array, 1))
+min(reduce(list, 1))
+min(round(0.5))
+min(round(1))
+min(round(f32))
+min(round(i32))
+min(round(i64))
 min(score(1))
 min(score(i))
-min(true ? 0.5 : ok)
-min(true ? 1 : greet)
-min(true ? add : greet)
-min(true ? f32 : i)
-min(true ? foo : 0.5)
-min(true ? foo : half)
-min(true ? i : 1)
-min(true ? i32 : score)
-nil != "bar" ? i64 : 0.5 - i
-nil != 0.5 && 0.5 != f32
-nil != 1 && ok
-nil != 1 or any(list, false)
-nil != 1 || ok
-nil != f32 || ok
-nil != f64 && ok
-nil != f64 or ok
-nil != f64 || array != array
-nil != false and not true
-nil != false and ok
-nil != false || ok
-nil != foo == ok
-nil != foo || ok
+min(sum(array))
+min(true ? i : "foo")
+min(true ? i : i32)
+min(true ? i64 : "foo")
+nil != array != nil ? add : half
+nil != array && ok
+nil != div == reduce(array, ok)
+nil != f64 || ok || false
+nil != false && ok
+nil != false or i == nil
+nil != foo and ok
 nil != foo.Bar
 nil != foo.Qux
 nil != foo.String
+nil != foo.String()
 nil != foo?.Bar
 nil != foo?.Qux
 nil != foo?.String
-nil != greet ? half : half
-nil != greet or f32 < i
-nil != i32 or f32 >= 1
-nil != i64 or i >= 1
-nil != ok == not true
-nil != true == ok
-nil == 1 != nil ? "bar" : i32
-nil == add == ("bar" not endsWith "foo")
-nil == f32 && i64 < f64
+nil != foo?.String()
+nil != nil ? score : div
+nil != true || i < 1
+nil == "foo" != ok
+nil == "foo" && 0.5 < f64
+nil == 0.5 and reduce(list, true)
+nil == add && 0.5 >= 0.5
+nil == add || f32 >= i64
+nil == array and ok
+nil == array or ok
+nil == array[i64]
+nil == div ? f64 : ok
+nil == false && nil != true
+nil == false ? i64 : toBase64("bar")
 nil == foo.Bar
 nil == foo.Qux
 nil == foo.String
@@ -11113,28 +13874,30 @@ nil == foo.String()
 nil == foo?.Bar
 nil == foo?.Qux
 nil == foo?.String
-nil == foo?.String()
-nil == i64 ? add : add
-nil == nil == ok
-nil == true ? i64 ^ f32 : foo
-nil == true || ok
-nil in array || ok
-nil in array[i32:i64]
-nil in list and ok
-none(array, !ok)
+nil == greet ? i : greet("bar")
+nil == list || f32 == i
+nil == list[i32]
+nil == nil and ok
+nil in array || score == nil
+nil in list != not false
+none(1 .. i, # < #)
+none(1 .. i32, # <= #)
+none([foo, list, 1 >= i], ok)
+none([greet], ok)
+none([true], #)
+none(array, !(i32 != i32))
+none(array, !false)
 none(array, !true)
-none(array, "bar" == "bar")
+none(array, "bar" endsWith "foo")
 none(array, # != #)
+none(array, # != 0.5)
 none(array, # != 1)
 none(array, # != f32)
 none(array, # != f64)
-none(array, # != i32)
-none(array, # != i64)
+none(array, # != i)
 none(array, # < #)
 none(array, # < 0.5)
-none(array, # < 1)
 none(array, # < f32)
-none(array, # < i)
 none(array, # < i32)
 none(array, # < i64)
 none(array, # <= #)
@@ -11143,155 +13906,170 @@ none(array, # <= 1)
 none(array, # <= f32)
 none(array, # <= i)
 none(array, # <= i32)
+none(array, # <= i64)
 none(array, # == #)
 none(array, # == 0.5)
-none(array, # == 1)
-none(array, # == i)
+none(array, # == f32)
+none(array, # == i32)
+none(array, # == i64)
 none(array, # == nil)
 none(array, # > #)
 none(array, # > 0.5)
-none(array, # > f32)
-none(array, # > f64)
 none(array, # > i)
-none(array, # > i32)
 none(array, # >= #)
 none(array, # >= 0.5)
 none(array, # >= 1)
 none(array, # >= f32)
 none(array, # >= f64)
+none(array, # >= i32)
+none(array, # >= i64)
 none(array, # in array)
-none(array, # not in array)
 none(array, 0.5 != #)
-none(array, 0.5 != f32)
+none(array, 0.5 != 1)
 none(array, 0.5 < #)
-none(array, 0.5 <= 0.5)
+none(array, 0.5 < i64)
+none(array, 0.5 <= #)
 none(array, 0.5 <= 1)
-none(array, 0.5 <= i)
-none(array, 0.5 > #)
+none(array, 0.5 <= f64)
+none(array, 0.5 == #)
+none(array, 0.5 > 0.5)
+none(array, 0.5 > 1)
+none(array, 0.5 > f32)
 none(array, 0.5 >= #)
-none(array, 1 != #)
+none(array, 0.5 >= 1)
 none(array, 1 < #)
-none(array, 1 < 0.5)
-none(array, 1 < i)
-none(array, 1 < i64)
-none(array, 1 <= 1)
-none(array, 1 == #)
-none(array, 1 == f64)
+none(array, 1 <= #)
+none(array, 1 == 1)
 none(array, 1 > #)
-none(array, 1 > f64)
-none(array, 1 >= i)
-none(array, add != greet)
-none(array, all(array, true))
-none(array, div == greet)
+none(array, any(array, true))
 none(array, f32 != #)
-none(array, f32 != nil)
-none(array, f32 <= #)
+none(array, f32 < 0.5)
+none(array, f32 < 1)
+none(array, f32 == 1)
+none(array, f32 > #)
 none(array, f32 >= #)
-none(array, f64 != #)
+none(array, f32 >= 1)
+none(array, f32 >= f32)
+none(array, f64 != 1)
 none(array, f64 == #)
-none(array, f64 >= 0.5)
-none(array, half != nil)
+none(array, f64 > #)
+none(array, f64 >= #)
+none(array, greet != div)
+none(array, greet != half)
+none(array, i != #)
 none(array, i < #)
-none(array, i < 1)
+none(array, i < f64)
 none(array, i <= #)
-none(array, i == i64)
-none(array, i not in array)
+none(array, i > #)
+none(array, i >= #)
+none(array, i >= 0.5)
+none(array, i >= i32)
 none(array, i32 != #)
-none(array, i32 != f64)
+none(array, i32 != i)
 none(array, i32 != nil)
 none(array, i32 < #)
 none(array, i32 > #)
-none(array, i32 >= #)
-none(array, i64 < #)
-none(array, i64 < f64)
+none(array, i64 != #)
+none(array, i64 != 0.5)
+none(array, i64 > i64)
 none(array, i64 >= #)
-none(array, nil != 0.5)
-none(array, nil != div)
+none(array, nil != "bar")
+none(array, nil != #)
+none(array, nil != false)
+none(array, nil != greet)
 none(array, nil == #)
 none(array, nil == 1)
-none(array, nil == div)
-none(array, none(array, !true))
-none(array, not ok)
-none(array, ok == nil)
+none(array, nil == f32)
+none(array, nil == greet)
+none(array, nil == half)
+none(array, not (# == #))
+none(array, not (# >= 1))
+none(array, not false)
 none(array, ok)
-none(array, ok) != ok
-none(array, ok) ? f32 : !ok
-none(array, score == nil)
-none(array, score == score)
-none(array, true ? ok : f64)
-none(array, true or true)
-none(i64 .. i32, # > #)
-none(list, "bar" not in #)
+none(array, reduce(array, true))
+none(filter(array, # >= f64), ok)
+none(groupBy(array, #).f64, # or #.Bar)
+none(groupBy(array, #)?.array, fromJSON(#))
+none(groupBy(array, #)?.f32, #)
+none(groupBy(array, #)?.greet, #)
+none(groupBy(list, #).div, ok)
+none(groupBy(list, #).greet, #)
+none(groupBy(list, 0.5).i, ok)
+none(i .. i, ok)
+none(i .. i32, # <= #)
+none(list, !false)
+none(list, !ok)
+none(list, "bar" contains "bar")
 none(list, # != #)
 none(list, # != foo)
 none(list, # != nil)
 none(list, # == #)
-none(list, # == nil)
-none(list, 0.5 != i)
-none(list, 0.5 <= 1)
-none(list, 0.5 <= f64)
-none(list, 0.5 == nil)
-none(list, 1 < i32)
+none(list, # == foo)
+none(list, # in list)
+none(list, # not in list)
+none(list, (0.5 not in array) || ok)
+none(list, 0.5 != i32)
+none(list, 0.5 > f64)
+none(list, 0.5 > i)
+none(list, 1 != i64)
+none(list, 1 != nil)
 none(list, 1 == f32)
-none(list, any(list, ok))
-none(list, array == nil)
-none(list, f32 > i)
-none(list, f64 == i32)
-none(list, false && false)
-none(list, false) or f64 >= i64
+none(list, 1 > 0.5)
+none(list, all(array, ok))
+none(list, div == #?.Qux)
+none(list, f32 != 1 ** f64)
+none(list, f32 >= 0.5)
+none(list, f32 in array)
+none(list, f32 not in array)
+none(list, f64 <= i32)
+none(list, f64 >= 1)
+none(list, false) ? ok : half
+none(list, false) || ok
 none(list, foo != #)
-none(list, foo == #)
-none(list, greet != add)
-none(list, greet != half)
-none(list, i <= i64)
-none(list, i >= 1)
-none(list, i >= f64)
-none(list, i not in array)
-none(list, i32 != nil)
-none(list, i32 == f64)
-none(list, i32 == nil)
-none(list, i32 >= 1)
-none(list, i32 >= f32)
-none(list, i64 < f64)
-none(list, i64 <= f64)
-none(list, i64 > f64)
+none(list, foo == foo)
+none(list, i != i)
+none(list, i != i64)
+none(list, i >= f32)
+none(list, i32 == f32)
+none(list, i32 > 1)
+none(list, i32 > i64)
+none(list, i32 not in array)
+none(list, i64 != 0.5)
 none(list, i64 > i64)
-none(list, nil != array)
-none(list, nil != true)
-none(list, nil == foo)
+none(list, nil != #)
+none(list, nil != greet)
+none(list, nil != i64)
+none(list, nil == #)
+none(list, nil == list)
 none(list, not false)
-none(list, not ok)
 none(list, ok)
-none(list, one(array, false))
-none(list, score != nil)
-none(list, score == add)
+none(list, one(array, true))
 none(list, true && ok)
-none(list, true == ok)
-none(list, true) ? div : array
-none(map(array, "bar"), # not endsWith #)
-none(map(array, "foo"), # not endsWith #)
+none(list, true) and ok
 none(map(array, #), ok)
-none(map(array, 0.5), # == #)
-none(map(array, 1), # >= #)
-none(map(array, half), # == #)
-none(map(array, ok), #)
-none(map(list, "bar"), # not startsWith #)
-none(map(list, "bar"), # startsWith #)
-none(map(list, #), # != #)
+none(map(array, div), # != #)
+none(map(array, f64 == #), ok)
+none(map(list, "bar"), # endsWith #)
+none(map(list, #), nil == list)
 none(map(list, #), ok)
-none(map(list, i32), f64 > #)
-none(map(list, true), # != #)
-none(ok ? "bar" : ok, # >= f64)
-not !("foo" not matches "foo")
-not !(0.5 > 1)
-not !(f64 >= i32)
-not !(false && ok)
-not !(i >= i32)
+none(map(list, 1), i > #)
+none(map(list, ok), # ? true : #)
+none(map(list, ok), #)
+none(map(list, score), ok)
+none(sort(filter(array, false)), #?.div > greet(#))
+not !(0.5 != i64)
+not !(i < 1)
+not !(i >= 0.5)
+not !(i32 != i32)
+not !(nil != false)
 not !false
+not !not false
 not !ok
 not !true
+not ("bar" != "bar")
 not ("bar" != "foo")
 not ("bar" != nil)
+not ("bar" < "bar")
 not ("bar" < "foo")
 not ("bar" <= "bar")
 not ("bar" <= "foo")
@@ -11308,6 +14086,7 @@ not ("bar" endsWith "bar")
 not ("bar" endsWith "foo")
 not ("bar" in foo)
 not ("bar" matches "bar")
+not ("bar" matches "foo")
 not ("bar" not contains "bar")
 not ("bar" not contains "foo")
 not ("bar" not endsWith "bar")
@@ -11315,6 +14094,8 @@ not ("bar" not endsWith "foo")
 not ("bar" not in foo)
 not ("bar" not matches "bar")
 not ("bar" not matches "foo")
+not ("bar" not startsWith "bar")
+not ("bar" not startsWith "foo")
 not ("bar" startsWith "bar")
 not ("bar" startsWith "foo")
 not ("foo" != "bar")
@@ -11329,7 +14110,9 @@ not ("foo" == "foo")
 not ("foo" == nil)
 not ("foo" > "bar")
 not ("foo" > "foo")
+not ("foo" >= "bar")
 not ("foo" >= "foo")
+not ("foo" contains "bar")
 not ("foo" contains "foo")
 not ("foo" endsWith "bar")
 not ("foo" endsWith "foo")
@@ -11341,13 +14124,13 @@ not ("foo" not contains "foo")
 not ("foo" not endsWith "bar")
 not ("foo" not endsWith "foo")
 not ("foo" not in foo)
-not ("foo" not matches "bar")
 not ("foo" not matches "foo")
-not ("foo" not startsWith "bar")
 not ("foo" not startsWith "foo")
+not ("foo" startsWith "bar")
 not ("foo" startsWith "foo")
 not (0.5 != 0.5)
 not (0.5 != 1)
+not (0.5 != f32)
 not (0.5 != f64)
 not (0.5 != i)
 not (0.5 != i32)
@@ -11371,6 +14154,7 @@ not (0.5 == 0.5)
 not (0.5 == 1)
 not (0.5 == f32)
 not (0.5 == f64)
+not (0.5 == i && i32 != i32)
 not (0.5 == i)
 not (0.5 == i32)
 not (0.5 == i64)
@@ -11389,6 +14173,8 @@ not (0.5 >= f64)
 not (0.5 >= i)
 not (0.5 >= i32)
 not (0.5 >= i64)
+not (0.5 in array)
+not (0.5 not in array)
 not (1 != 0.5)
 not (1 != 1)
 not (1 != f32)
@@ -11397,7 +14183,6 @@ not (1 != i)
 not (1 != i32)
 not (1 != i64)
 not (1 != nil)
-not (1 + i > 0.5 ** i32)
 not (1 < 0.5)
 not (1 < 1)
 not (1 < f32)
@@ -11417,6 +14202,7 @@ not (1 == 1)
 not (1 == f32)
 not (1 == f64)
 not (1 == i)
+not (1 == i32)
 not (1 == i64)
 not (1 == nil)
 not (1 > 0.5)
@@ -11433,17 +14219,13 @@ not (1 >= f64)
 not (1 >= i)
 not (1 >= i32)
 not (1 >= i64)
-not (1 ^ f32 != i64)
 not (1 in array)
 not (1 not in array)
-not (abs(i) <= i)
 not (add != add)
-not (add != div)
 not (add != greet)
 not (add != half)
 not (add != nil)
 not (add != score)
-not (add == add)
 not (add == div)
 not (add == greet)
 not (add == half)
@@ -11455,8 +14237,10 @@ not (array != nil)
 not (array == array)
 not (array == list)
 not (array == nil)
+not (array[i32] > i64)
 not (div != add)
 not (div != div)
+not (div != foo?.Qux)
 not (div != greet)
 not (div != half)
 not (div != nil)
@@ -11477,7 +14261,6 @@ not (f32 != i64)
 not (f32 != nil)
 not (f32 < 0.5)
 not (f32 < 1)
-not (f32 < abs(0.5))
 not (f32 < f32)
 not (f32 < f64)
 not (f32 < i)
@@ -11485,7 +14268,6 @@ not (f32 < i32)
 not (f32 < i64)
 not (f32 <= 0.5)
 not (f32 <= 1)
-not (f32 <= f32)
 not (f32 <= f64)
 not (f32 <= i)
 not (f32 <= i32)
@@ -11494,6 +14276,7 @@ not (f32 == 0.5)
 not (f32 == 1)
 not (f32 == f32)
 not (f32 == f64)
+not (f32 == i)
 not (f32 == i32)
 not (f32 == i64)
 not (f32 == nil)
@@ -11501,15 +14284,19 @@ not (f32 > 0.5)
 not (f32 > 1)
 not (f32 > f32)
 not (f32 > f64)
+not (f32 > i)
 not (f32 > i32)
+not (f32 > i64)
 not (f32 >= 0.5)
 not (f32 >= 1)
 not (f32 >= f32)
 not (f32 >= f64)
 not (f32 >= i)
+not (f32 >= i32)
 not (f32 >= i64)
+not (f32 in array)
+not (f32 not in array)
 not (f64 != 0.5)
-not (f64 != 1 * 0.5)
 not (f64 != 1)
 not (f64 != f32)
 not (f64 != f64)
@@ -11521,28 +14308,29 @@ not (f64 < 0.5)
 not (f64 < 1)
 not (f64 < f32)
 not (f64 < f64)
-not (f64 < i)
 not (f64 < i32)
 not (f64 < i64)
+not (f64 <= -0.5)
 not (f64 <= 0.5)
 not (f64 <= 1)
 not (f64 <= f32)
 not (f64 <= f64)
+not (f64 <= i)
 not (f64 <= i32)
 not (f64 <= i64)
 not (f64 == 0.5)
 not (f64 == 1)
-not (f64 == f32)
 not (f64 == f64)
 not (f64 == i)
 not (f64 == i32)
-not (f64 == i64 - f32)
+not (f64 == i64)
 not (f64 == nil)
 not (f64 > 0.5)
 not (f64 > 1)
 not (f64 > f32)
 not (f64 > f64)
 not (f64 > i)
+not (f64 > i32)
 not (f64 > i64)
 not (f64 >= 0.5)
 not (f64 >= 1)
@@ -11551,16 +14339,18 @@ not (f64 >= f64)
 not (f64 >= i)
 not (f64 >= i32)
 not (f64 >= i64)
+not (f64 in array)
+not (f64 not in array)
 not (false != false)
 not (false != nil)
 not (false != ok)
 not (false != true)
+not (false && false)
 not (false && ok)
-not (false && true)
-not (false == false)
 not (false == nil)
-not (false == true)
+not (false == ok)
 not (false and false)
+not (false and ok)
 not (false and true)
 not (false or false)
 not (false or ok)
@@ -11568,6 +14358,7 @@ not (false or true)
 not (false || false)
 not (false || ok)
 not (false || true)
+not (findIndex(list, ok) != i ^ f64)
 not (foo != foo)
 not (foo != nil)
 not (foo == foo)
@@ -11589,10 +14380,12 @@ not (greet == score)
 not (half != add)
 not (half != div)
 not (half != greet)
+not (half != half)
 not (half != nil)
 not (half != score)
 not (half == add)
 not (half == div)
+not (half == foo?.String)
 not (half == greet)
 not (half == half)
 not (half == nil)
@@ -11616,27 +14409,31 @@ not (i <= 0.5)
 not (i <= 1)
 not (i <= f32)
 not (i <= f64)
+not (i <= i)
 not (i <= i32)
 not (i <= i64)
 not (i == 0.5)
 not (i == 1)
+not (i == ceil(f64))
 not (i == f32)
 not (i == f64)
 not (i == i)
 not (i == i32)
+not (i == i64)
 not (i == nil)
 not (i > 0.5)
 not (i > 1)
 not (i > f32)
 not (i > f64)
 not (i > i)
+not (i > i32)
 not (i > i64)
 not (i >= 0.5)
 not (i >= 1)
-not (i >= div(1, 1))
 not (i >= f32)
 not (i >= f64)
 not (i >= i)
+not (i >= i32)
 not (i >= i64)
 not (i in array)
 not (i not in array)
@@ -11645,10 +14442,13 @@ not (i32 != 1)
 not (i32 != f32)
 not (i32 != f64)
 not (i32 != i)
+not (i32 != i32)
 not (i32 != i64)
 not (i32 != nil)
 not (i32 < 0.5)
 not (i32 < 1)
+not (i32 < f32 ** 0.5)
+not (i32 < f32)
 not (i32 < f64)
 not (i32 < i)
 not (i32 < i32)
@@ -11660,6 +14460,7 @@ not (i32 <= f64)
 not (i32 <= i)
 not (i32 <= i32)
 not (i32 <= i64)
+not (i32 == -i)
 not (i32 == 0.5)
 not (i32 == 1)
 not (i32 == f32)
@@ -11683,6 +14484,7 @@ not (i32 >= i)
 not (i32 >= i32)
 not (i32 >= i64)
 not (i32 in array)
+not (i32 not in array)
 not (i64 != 0.5)
 not (i64 != 1)
 not (i64 != f32)
@@ -11698,12 +14500,12 @@ not (i64 < f64)
 not (i64 < i)
 not (i64 < i32)
 not (i64 < i64)
-not (i64 < int(f64))
 not (i64 <= 0.5)
 not (i64 <= 1)
 not (i64 <= f32)
 not (i64 <= f64)
 not (i64 <= i)
+not (i64 <= i32)
 not (i64 <= i64)
 not (i64 == 0.5)
 not (i64 == 1)
@@ -11715,6 +14517,7 @@ not (i64 == i64)
 not (i64 == nil)
 not (i64 > 0.5)
 not (i64 > 1)
+not (i64 > f32)
 not (i64 > f64)
 not (i64 > i)
 not (i64 > i32)
@@ -11725,8 +14528,7 @@ not (i64 >= f32)
 not (i64 >= f64)
 not (i64 >= i)
 not (i64 >= i32)
-not (i64 >= max(i))
-not (i64 in array)
+not (i64 >= i64)
 not (i64 not in array)
 not (list != array)
 not (list != list)
@@ -11745,7 +14547,6 @@ not (nil != f32)
 not (nil != f64)
 not (nil != false)
 not (nil != foo)
-not (nil != greet)
 not (nil != half)
 not (nil != i)
 not (nil != i32)
@@ -11780,7 +14581,6 @@ not (nil in array)
 not (nil in list)
 not (nil not in array)
 not (nil not in list)
-not (ok != false)
 not (ok != nil)
 not (ok != ok)
 not (ok != true)
@@ -11815,8 +14615,9 @@ not (true != false)
 not (true != nil)
 not (true != ok)
 not (true != true)
-not (true && ok)
+not (true && false)
 not (true && true)
+not (true == false)
 not (true == nil)
 not (true == ok)
 not (true == true)
@@ -11825,707 +14626,1795 @@ not (true and ok)
 not (true and true)
 not (true or false)
 not (true or ok)
+not (true or true)
 not (true || false)
+not (true || ok)
+not (true || true)
+not all(array, false)
 not all(array, ok)
 not all(array, true)
-not all(list, false)
+not all(list, nil == #)
 not all(list, ok)
 not all(list, true)
 not any(array, false)
 not any(array, ok)
 not any(array, true)
-not any(list, # != #)
 not any(list, false)
 not any(list, ok)
 not any(list, true)
+not false && nil == f64
 not false && ok
-not false && ok ? list : array
-not false ? "bar" : 0.5
-not false ? "bar" : foo
-not false ? "foo" : 0.5
-not false ? 0.5 : greet
-not false ? 1 : div
-not false ? 1 : i32
-not false ? add : i
-not false ? array : "foo"
-not false ? array : array
-not false ? array : greet
-not false ? array : ok
-not false ? div : greet
-not false ? foo : 1
-not false ? foo : array
-not false ? greet : ok
-not false ? half : 0.5
-not false ? half : i32
-not false ? i : i64
-not false ? i : score
-not false ? i32 : 0.5
-not false ? i32 : add
-not false ? i32 : f32
-not false ? i32 : true
+not false == ok
+not false ? "foo" : "foo"
+not false ? 0.5 : "foo"
+not false ? 0.5 : array
+not false ? 0.5 : div
+not false ? 0.5 : foo
+not false ? 0.5 : i64
+not false ? 0.5 : nil
+not false ? 1 : 0.5
+not false ? add : array
+not false ? array : 0.5
+not false ? array : 1
+not false ? array : f64
+not false ? array : i
+not false ? array : true
+not false ? div : 0.5
+not false ? div : f64
+not false ? f32 : 0.5
+not false ? f32 : 1
+not false ? f32 : i
+not false ? f32 : nil
+not false ? f32 : score
+not false ? f64 : "foo"
+not false ? f64 : f64
+not false ? false : half
+not false ? false : list
+not false ? foo : f64
+not false ? greet : 1
+not false ? i : "bar"
+not false ? i : 1
+not false ? i : array
+not false ? i : i
+not false ? i32 : greet
 not false ? i64 : list
-not false ? list : i32
-not false ? nil : greet
-not false ? nil : i32
-not false ? nil : nil
-not false ? ok : "bar"
+not false ? list : i
+not false ? list : true
+not false ? nil : f32
+not false ? nil : half
+not false ? nil : ok
 not false ? ok : 1
-not false ? ok : list
-not false ? score : "foo"
-not false ? score : array
-not false ? score : score
-not false ? score : true
-not false ? true : 0.5
-not false ? true : 1
+not false ? score : ok
+not false ? true : f64
 not false ? true : nil
-not false or "foo" > "bar"
-not none(array, # == #)
+not false or false == false
+not false or ok
+not false || ok
+not none(array, # > f32)
 not none(array, false)
 not none(array, ok)
 not none(array, true)
 not none(list, false)
 not none(list, ok)
 not none(list, true)
-not not ("bar" >= "foo")
-not not (1 < i)
-not not (add == nil)
-not not (half == nil)
+not not (f64 <= 1)
+not not (i32 < i64)
+not not (i64 >= f64)
+not not (nil != greet)
+not not (ok or ok)
 not not false
 not not ok
 not not true
 not ok
+not ok != ok
+not ok && 1 > 0.5
 not ok && ok
-not ok == ok
-not ok ? "bar" : 1
-not ok ? "bar" : f32
-not ok ? 0.5 + f64 : half
-not ok ? 0.5 : "foo"
+not ok ? "bar" : list
+not ok ? "foo" : 0.5
+not ok ? "foo" : 1
+not ok ? 0.5 : "bar"
 not ok ? 0.5 : 0.5
-not ok ? 0.5 : div
-not ok ? 0.5 : f32
-not ok ? 0.5 : greet
-not ok ? 1 : 1
-not ok ? add : 0.5
-not ok ? array : f64
-not ok ? array : true
-not ok ? div : 1
-not ok ? div : add
-not ok ? f32 : div
-not ok ? f64 : 1
+not ok ? 0.5 : i
+not ok ? 1 : f64
+not ok ? 1 : nil
+not ok ? add : array
+not ok ? add : groupBy(array, #)
+not ok ? array : 1
+not ok ? array : f32
+not ok ? div : f64
+not ok ? f32 : f32
+not ok ? f64 : f64
 not ok ? f64 : half
-not ok ? false : f32
-not ok ? false : i
-not ok ? false : true
-not ok ? foo : add
-not ok ? foo : false
-not ok ? foo : i64
-not ok ? greet : add
-not ok ? half : true
-not ok ? i : div
-not ok ? i : true
-not ok ? i32 : nil
-not ok ? i64 : add
+not ok ? foo : foo
+not ok ? greet : 0.5
+not ok ? half : half
+not ok ? i : 1
+not ok ? i : add
+not ok ? i32 : 1
+not ok ? i32 : i
+not ok ? i64 : f32
+not ok ? i64 : f64
+not ok ? nil : "bar"
 not ok ? nil : 0.5
-not ok ? nil : div
 not ok ? nil : foo
-not ok ? nil : half
+not ok ? nil : greet
 not ok ? nil : i
-not ok ? score : div
-not ok ? score : i
-not ok ? score : true
-not ok ? true : f32
-not ok ? true : false
-not ok ? true : score
-not ok and not ok
+not ok ? ok : false
+not ok ? ok : list
+not ok ? score : "foo"
+not ok ? score : score
+not ok ? true : 1
+not ok ? true : div
+not ok ? true : half
+not ok ? true : i64
+not ok ? true : nil
+not ok and "foo" == "foo"
+not ok and i32 > 0.5
+not ok and ok
+not ok or 1 != i
 not ok or ok
-not ok or one(array, true)
+not ok || array == list
 not ok || ok
-not ok || true ? 0.5 : 1
-not one(array, # > f32)
 not one(array, false)
 not one(array, ok)
 not one(array, true)
 not one(list, false)
 not one(list, ok)
 not one(list, true)
-not true && i32 <= i32
-not true ? "foo" : i
-not true ? 1 : i64
-not true ? add : add
-not true ? add : foo
-not true ? array : 1
-not true ? array : add
-not true ? array : array
-not true ? array : i32
-not true ? array : i64
-not true ? div : nil
-not true ? f64 : i64
-not true ? foo : foo
-not true ? greet : "bar"
-not true ? greet : add
-not true ? greet : foo
-not true ? greet : i32
+not reduce(array, false)
+not reduce(array, ok)
+not reduce(array, true)
+not reduce(list, false)
+not reduce(list, ok)
+not reduce(list, true)
+not true != ok
+not true && ok
+not true == ok
+not true ? "bar" : array
+not true ? "bar" : i32
+not true ? "foo" : f32
+not true ? "foo" : f64
+not true ? 0.5 : foo
+not true ? 0.5 : greet
+not true ? 0.5 : i
+not true ? 0.5 : i64
+not true ? 1 : f32
+not true ? add : i32
+not true ? add : ok
+not true ? array : nil
+not true ? f32 : 0.5
+not true ? f32 : div
+not true ? f64 : 1
+not true ? f64 : array
+not true ? foo : greet
+not true ? foo : ok
+not true ? greet : 1
+not true ? greet : i64
+not true ? greet : list
+not true ? greet : true
 not true ? half : half
-not true ? i : 1
-not true ? i : i
-not true ? i32 : 0.5
-not true ? i64 : 1
+not true ? i : f64
+not true ? i64 : "foo"
+not true ? i64 : array
+not true ? i64 : i64
 not true ? list : "bar"
-not true ? list : 0.5
-not true ? list : 1
-not true ? list : array
-not true ? list : type(add)
-not true ? nil : list
-not true ? score : 1
-not true ? score : list
-not true ? score : true
+not true ? list : f64
+not true ? list : foo
+not true ? nil : div
+not true ? ok : nil
+not true ? score : f32
+not true ? score : score
+not true ? true : 1
+not true and ok ? i : half
 not true || ok
 ok
 ok != !ok
-ok != !true
+ok != (0.5 not in array)
 ok != false != ok
-ok != false ? 1 : i
+ok != false ? f32 : list
 ok != nil == nil
-ok != none(list, ok)
-ok != not !ok
+ok != nil ? f32 : greet
+ok != nil ? nil : array
 ok != not ok
 ok != ok
-ok != ok || ok
-ok && !ok ? f32 : 0.5
-ok && !true
-ok && "bar" >= "bar"
-ok && "foo" <= "bar"
-ok && 0.5 != nil
-ok && 0.5 == 0.5
-ok && 0.5 >= f32
-ok && 1 != f64
+ok != ok ? false : "bar"
+ok != sum(array)
+ok && !false
+ok && !ok
+ok && "foo" matches "bar"
+ok && ("bar" not endsWith "bar")
+ok && (false || ok)
+ok && (ok or false)
+ok && (true || true)
+ok && 0.5 < 1
+ok && 0.5 < f64
+ok && 0.5 <= 1
+ok && 0.5 == nil
+ok && 0.5 > i64
+ok && 1 != 0.5
 ok && 1 != i32
-ok && 1 < 1
-ok && 1 <= 0.5
-ok && 1 == f64
-ok && 1 >= f32
-ok && div == half
-ok && f32 != 0.5
-ok && f32 < 0.5
-ok && f32 == f32
-ok && f32 == i64
-ok && f64 < 1
-ok && f64 < i32
-ok && f64 == i32
-ok && f64 >= i32
-ok && false == false
-ok && i != i
-ok && i32 != 0.5
-ok && i32 < f32
-ok && i32 <= i64
-ok && i32 == 1
-ok && i32 >= 1
-ok && i64 < i32
-ok && i64 <= i32
-ok && i64 > 1
-ok && list != array
-ok && nil != f64
-ok && nil == add
-ok && nil == i32
-ok && nil == true
+ok && 1 <= 1
+ok && 1 <= f64
+ok && 1 == 0.5
+ok && 1 == nil
+ok && 1 >= f64
+ok && add != greet
+ok && f32 != i
+ok && f32 >= i64
+ok && f64 <= 0.5
+ok && false != ok
+ok && false ? i : list
+ok && false ? ok : ok
+ok && i < 0.5
+ok && i < i64
+ok && i == 0.5
+ok && i > f64
+ok && i32 > 0.5
+ok && i32 >= i64
+ok && i64 != i
+ok && i64 == 0.5
+ok && nil != 0.5
+ok && nil != 1
+ok && nil == ok
+ok && not false
+ok && not true
 ok && ok
-ok && score != add
-ok && true != ok
-ok && true == nil
+ok && ok ? nil : div
+ok && ok and false
+ok && true != false
+ok && true && 1 >= i64
 ok == !false
-ok == !ok
-ok == (false or true)
-ok == (ok and ok)
-ok == any(list, ok)
-ok == false == nil
-ok == nil ? false : add
-ok == nil ? score : array
+ok == !true
+ok == ("bar" not endsWith "foo")
+ok == (0.5 not in array)
+ok == (false and ok)
+ok == (i32 not in array)
+ok == (nil not in list)
+ok == false ? f64 : 1
+ok == false ? score : 1
+ok == nil ? i64 : add
+ok == nil ? nil : f64
+ok == none(array, true)
 ok == not false
-ok == not true
 ok == ok
-ok ? "bar" : i == f32
-ok ? "bar" : i32 < i32
-ok ? "foo" : foo.String
-ok ? -0.5 : foo
-ok ? -f32 : i64 + 1
-ok ? -f64 : score
-ok ? -i64 : ok
-ok ? 0.5 * array[i64] : greet
-ok ? 0.5 : f64 < i64
-ok ? 0.5 : half != add
-ok ? 0.5 : i .. i
-ok ? 0.5 < i32 : score
-ok ? 0.5 == 0.5 : half
-ok ? 1 : 1 + i64 + i32
+ok == ok != false
+ok == true && ok
+ok ? "bar" : f64 <= f32
+ok ? "foo" : foo.Bar
+ok ? -0.5 : add
+ok ? -f64 : list
+ok ? -i32 : i
+ok ? 0.5 / 0.5 : f64
+ok ? 0.5 : i32 >= i64
+ok ? 0.5 > 1 : 0.5 * i64
+ok ? 1 + i : i32
+ok ? 1 / i64 : greet
 ok ? 1 : foo.Bar
-ok ? 1 : foo.String
+ok ? 1 : foo?.Qux
+ok ? 1 : score != greet
+ok ? abs(i64) : i64
+ok ? add : abs(f32)
 ok ? add : add
 ok ? add : array
-ok ? add : div
-ok ? add : f32
+ok ? add : f64
+ok ? add : foo
+ok ? add : foo?.String
 ok ? add : greet
+ok ? add : half
 ok ? add : i
-ok ? add : i32
 ok ? add : i64
 ok ? add : list
 ok ? add : ok
-ok ? array : div
-ok ? array : f64
-ok ? array : float(i32)
+ok ? array : array
+ok ? array : f32
+ok ? array : f64 + f64
 ok ? array : foo
-ok ? array : foo?.Bar
+ok ? array : foo.String
+ok ? array : foo?.String
+ok ? array : greet
+ok ? array : greet(nil)
+ok ? array : i
 ok ? array : i32
-ok ? array : i64
 ok ? array : list
-ok ? array : ok in map(array, ok)
+ok ? array : ok
+ok ? array : score
+ok ? div : add
+ok ? div : array
 ok ? div : div
-ok ? div : f32
 ok ? div : f64
-ok ? div : foo?.String
+ok ? div : foo
+ok ? div : foo.Bar
 ok ? div : greet
 ok ? div : half
-ok ? div : half(1)
-ok ? div : i32
-ok ? div : i64
-ok ? div : list
-ok ? div : list == array
+ok ? div : i32 > reduce(array, #)
+ok ? div : nil == true
+ok ? div : ok
 ok ? div : score
-ok ? div : score(i)
+ok ? f32 != i32 : f32
+ok ? f32 ** i64 : score
+ok ? f32 : "foo" endsWith lower(nil)
+ok ? f32 : -0.5
 ok ? f32 : add
 ok ? f32 : array
 ok ? f32 : div
 ok ? f32 : f32
 ok ? f32 : f64
 ok ? f32 : foo
-ok ? f32 : foo?.Bar
 ok ? f32 : half
-ok ? f32 : i != i64
 ok ? f32 : i32
+ok ? f32 : i64
+ok ? f32 : ok
+ok ? f32 : score
+ok ? f64 : add
 ok ? f64 : array
+ok ? f64 : div
+ok ? f64 : f64 - f64
+ok ? f64 : false != true
+ok ? f64 : foo
+ok ? f64 : foo.String
 ok ? f64 : greet
-ok ? f64 : half
-ok ? f64 : i64
+ok ? f64 : i32
+ok ? f64 : i32 % i32
+ok ? f64 : i32 >= -i64
+ok ? f64 : ok
 ok ? f64 : score
-ok ? false : foo?.String()
-ok ? foo : add
+ok ? false : foo.Bar
+ok ? foo : div
+ok ? foo : f32
 ok ? foo : foo
-ok ? foo : foo?.Bar
 ok ? foo : greet
-ok ? foo : i
-ok ? foo : i == i32
+ok ? foo : half
 ok ? foo : i32
+ok ? foo : i32 > i32
 ok ? foo : i64
-ok ? foo : i64 ^ f32
 ok ? foo : list
-ok ? get(array, i32) : ok
+ok ? foo : ok
+ok ? foo : score
+ok ? foo.Qux : ok
+ok ? greet : 0.5 > i
+ok ? greet : 1 <= 0.5
 ok ? greet : add
 ok ? greet : div
-ok ? greet : f64 == i64
-ok ? greet : greet
+ok ? greet : f32
+ok ? greet : f64
+ok ? greet : foo
 ok ? greet : half
-ok ? greet : i / i32
-ok ? greet : i32
-ok ? greet : i64 % i64
+ok ? greet : i64
 ok ? greet : list
-ok ? greet : type(f64)
-ok ? half : 0.5 ^ i32
+ok ? greet : map(list, i)
+ok ? greet : ok
+ok ? greet : score
 ok ? half : add
-ok ? half : array
-ok ? half : div
-ok ? half : f32 == f64
+ok ? half : f32
 ok ? half : f64
-ok ? half : f64 <= i
 ok ? half : foo
-ok ? half : foo?.Bar
+ok ? half : foo?.Qux
 ok ? half : greet
 ok ? half : half
-ok ? half : i
-ok ? half : i32
 ok ? half : list
+ok ? half : nil in list
 ok ? half : ok
-ok ? half : type(add)
-ok ? i : -i32
-ok ? i : 0.5 * i64
-ok ? i : 1 ** f64
+ok ? half : reduce(list, "bar")
+ok ? half : string(array)
+ok ? half(1) : add
+ok ? i : 1 / i64
+ok ? i : add
 ok ? i : array
-ok ? i : div
-ok ? i : f32
-ok ? i : f64
-ok ? i : foo.Bar
+ok ? i : f32 <= 0.5
+ok ? i : foo
+ok ? i : half
 ok ? i : i
 ok ? i : i32
+ok ? i : i64
+ok ? i : list
 ok ? i : ok
 ok ? i : score
-ok ? i32 + f32 : half
-ok ? i32 : -i32
-ok ? i32 : 1 not in array
+ok ? i32 : 1 - f64
 ok ? i32 : add
-ok ? i32 : array
+ok ? i32 : div
 ok ? i32 : f32
+ok ? i32 : f32 + 0.5
+ok ? i32 : f64
+ok ? i32 : foo
 ok ? i32 : foo.Qux
-ok ? i32 : foo?.Qux
-ok ? i32 : half
+ok ? i32 : greet
 ok ? i32 : i
 ok ? i32 : i32
+ok ? i32 : i32 + i32
 ok ? i32 : list
 ok ? i32 : ok
-ok ? i32 >= f64 : f32
-ok ? i64 : array
+ok ? i32 : score
+ok ? i64 : (ok ? list : half)
 ok ? i64 : div
 ok ? i64 : f32
-ok ? i64 : f64
+ok ? i64 : foo
+ok ? i64 : foo.String
 ok ? i64 : half
+ok ? i64 : i
 ok ? i64 : i32
 ok ? i64 : i64
+ok ? i64 : list
 ok ? i64 : ok
-ok ? int(1) : div
-ok ? list : -1
+ok ? i64 ^ f32 : foo
+ok ? list : 0.5 * f64
 ok ? list : add
 ok ? list : array
 ok ? list : div
+ok ? list : div(i64, 1)
 ok ? list : f32
-ok ? list : i32
+ok ? list : foo.String
+ok ? list : greet
+ok ? list : half
+ok ? list : i
+ok ? list : i - f32
 ok ? list : i64
 ok ? list : list
-ok ? list : nil in array
-ok ? list : ok
+ok ? list : list != array
+ok ? list : not ok
 ok ? list : score
-ok ? lower("foo") : f32
-ok ? map(array, #) : duration("foo")
-ok ? map(list, #) : score
-ok ? min(f32) : score
-ok ? min(i) : score
+ok ? map(list, #) : add
+ok ? nil : 0.5 <= f64
+ok ? nil : foo.Qux
 ok ? nil : foo?.Bar
-ok ? ok : -f32
-ok ? ok : 0.5 + i
+ok ? not false : i32
+ok ? ok : 0.5 ** i32
+ok ? ok : add
 ok ? ok : array
-ok ? ok : f64
+ok ? ok : div
+ok ? ok : f32
+ok ? ok : f64 ** int(f64)
 ok ? ok : foo
+ok ? ok : foo.String
 ok ? ok : greet
+ok ? ok : half
+ok ? ok : i32
 ok ? ok : i64
 ok ? ok : list
-ok ? ok : score
-ok ? score : add
-ok ? score : array
+ok ? ok : ok
+ok ? reduce(array, false) : score
+ok ? reduce(list, #) : list
+ok ? score : 1 == i32
+ok ? score : div
 ok ? score : f32
-ok ? score : foo.String
-ok ? score : foo?.String
+ok ? score : f64
 ok ? score : greet
 ok ? score : half
 ok ? score : i
 ok ? score : i32
-ok ? score : list
-ok ? score : nil != div
-ok ? score : ok
+ok ? score : min(i64)
 ok ? score : score
-ok ? string(half) : array
-ok ? toJSON("foo") : i32
-ok ? true : foo?.Qux
+ok ? score : true == nil
+ok ? toJSON(i64) : div
 ok and !ok
-ok and "bar" not endsWith foo?.Bar
-ok and "foo" endsWith "foo"
-ok and 0.5 <= f32
-ok and 0.5 > f64
-ok and 0.5 >= f64
-ok and 1 != 1
-ok and 1 != nil
+ok and "bar" < "foo"
+ok and ("foo" not contains "bar")
 ok and 1 < i64
 ok and 1 == 1
-ok and add == add
-ok and any(list, false)
+ok and 1 == i64
+ok and add == nil
+ok and div == half
+ok and f32 != 1
 ok and f32 >= 1
-ok and f64 != i
-ok and f64 != nil
-ok and f64 > 1
-ok and false != true
-ok and i > i32
-ok and i >= f64
-ok and i >= i64
-ok and i32 != nil
-ok and i32 == 0.5
-ok and i32 >= f64
-ok and i64 != nil
-ok and i64 <= i
+ok and greet != div
+ok and greet == greet
+ok and i == 0.5
+ok and i32 < f32
+ok and i32 <= i64
+ok and i32 > i32
+ok and i64 < i32
+ok and i64 <= i64
 ok and i64 > 1
-ok and list == list
-ok and nil != i
-ok and nil != true
-ok and none(list, ok)
+ok and i64 >= i
+ok and i64 in array
+ok and list != nil
+ok and nil == array
+ok and nil == nil
+ok and nil in array
+ok and nil in list
+ok and nil not in array
 ok and not ok
 ok and not true
 ok and ok
-ok not in sort(array)
-ok or !false
+ok and ok && ok
+ok and true ? f64 : add
+ok and true ? greet : i
+ok in groupBy(array, "bar")
+ok in groupBy(list, #)
+ok in groupBy(list, i32)
+ok in {"bar": true}?.greet
+ok not in groupBy(array, # != i32)
+ok not in groupBy(array, 0.5)
+ok not in groupBy(array, f64)
+ok not in groupBy(list, #)?.f64
+ok not in groupBy(list, f64)?.Bar
 ok or !ok
 ok or !true
-ok or "bar" < "bar"
-ok or "foo" != nil
-ok or 0.5 != i32
-ok or 0.5 != i64
-ok or 0.5 <= 0.5
-ok or 0.5 == 1
-ok or 0.5 >= i
-ok or 1 != i32
-ok or 1 >= 0.5
-ok or f64 < f32
-ok or f64 < i64
-ok or fromJSON("bar")
-ok or greet != add
-ok or half == nil
-ok or half == score
-ok or i != 0.5
+ok or "bar" endsWith "foo"
+ok or 0.5 != f32
+ok or 0.5 != nil
+ok or 0.5 == i
+ok or 1 != f32
+ok or 1 <= 1
+ok or 1 <= i
+ok or div != half
+ok or div != nil
+ok or div != score
+ok or f32 != f32
+ok or f32 == 0.5
+ok or f32 == f32
+ok or f64 <= 1
+ok or false ? ok : 1
+ok or false and false
+ok or foo != foo
+ok or fromJSON(nil)?.ok
+ok or half != add
+ok or half == div
 ok or i < 1
-ok or i32 < 0.5
-ok or i32 == f64
-ok or i32 > 0.5
-ok or i64 != f32
-ok or i64 == 1
-ok or list == array
-ok or nil != 0.5
+ok or i == 0.5
+ok or i == f32
+ok or i32 < 1
+ok or i32 > f64
+ok or i64 != i32
+ok or i64 > i64
+ok or i64 >= 0.5
+ok or i64 not in array
+ok or nil != "foo"
+ok or nil != f64
+ok or nil != foo
+ok or nil != greet
+ok or nil != ok
+ok or nil == div
 ok or not false
 ok or not ok
-ok or not true
 ok or ok
-ok or ok || false
-ok or one(array, true)
-ok || "bar" not contains string(true)
-ok || 0.5 < i32
-ok || 0.5 <= 0.5
-ok || 0.5 == i64
-ok || 1 != 0.5
-ok || 1 != 1
+ok or ok == true
+ok or true || true
+ok or {"foo": false}.String
+ok || !ok
+ok || (nil not in list)
+ok || 0.5 < f32
+ok || 0.5 > 0.5
+ok || 0.5 > 1
+ok || 0.5 >= f64
 ok || 1 != nil
-ok || 1 < 0.5
-ok || 1 <= 1
-ok || add != score
-ok || all(array, ok)
-ok || div == nil
-ok || f32 <= 0.5
-ok || f32 <= 1
-ok || f32 > i64
-ok || f32 >= f64
-ok || false && ok
-ok || i != f64
-ok || i <= 0.5
-ok || i32 != 0.5
-ok || i32 < 0.5
-ok || i32 > 1
-ok || i64 > 0.5
+ok || 1 < i32
+ok || 1 == i
+ok || f32 >= 1
+ok || f64 < 1
+ok || f64 == i
+ok || f64 > f64
+ok || f64 >= i64
+ok || false ? half : i64
+ok || foo == foo
+ok || greet == half
+ok || i == i
+ok || i32 < f32
+ok || i32 <= 0.5
+ok || i32 == i
+ok || i32 > 0.5
+ok || i32 >= i32
+ok || i64 != i32
+ok || i64 == 0.5
+ok || list == list
+ok || nil == 0.5
+ok || nil == array
+ok || nil == nil
+ok || nil not in array
+ok || not false
+ok || not ok
 ok || ok
-ok || score != score
-ok || toJSON(f64) > trimSuffix("bar")
-one([1], ok)
-one([i32], i32 >= #)
-one([score, greet], # == #)
-one([score], ok)
-one(array, "bar" matches "foo")
-one(array, "bar" not in foo)
-one(array, "foo" != "foo")
-one(array, "foo" > "foo")
+ok || ok ? f64 : i64
+ok || ok ? ok : score
+ok || ok or ok
+ok || reduce(array, false)
+ok || true ? add : ok
+one(1 .. i64, ok)
+one([div], nil == i32)
+one([false], i64 != i32)
+one(array, !(# <= 0.5))
+one(array, !false)
+one(array, !ok)
+one(array, !true)
+one(array, "bar" matches "bar")
 one(array, # != #)
 one(array, # != 0.5)
+one(array, # != 1)
+one(array, # != f32)
 one(array, # != f64)
+one(array, # != i)
 one(array, # != i32)
 one(array, # != nil)
-one(array, # % # <= #)
+one(array, # / i >= f64)
 one(array, # < #)
 one(array, # < 0.5)
 one(array, # < 1)
 one(array, # < f32)
-one(array, # < f64)
-one(array, # < i)
-one(array, # < i32)
+one(array, # < i64)
 one(array, # <= #)
+one(array, # <= 0.5)
+one(array, # <= 1)
 one(array, # <= f32)
 one(array, # <= f64)
-one(array, # <= i)
 one(array, # <= i32)
 one(array, # == #)
 one(array, # == 0.5)
 one(array, # == 1)
-one(array, # == f64)
-one(array, # == i)
-one(array, # == i32)
-one(array, # == i64)
+one(array, # == nil)
 one(array, # > #)
+one(array, # > f32)
 one(array, # > f64)
 one(array, # > i32)
-one(array, # > i64)
 one(array, # >= #)
 one(array, # >= 0.5)
 one(array, # >= 1)
-one(array, # >= f32)
-one(array, # >= i)
-one(array, # >= i32)
-one(array, # in array)
+one(array, # >= f64)
 one(array, 0.5 != #)
+one(array, 0.5 != i64)
 one(array, 0.5 < #)
+one(array, 0.5 < 0.5)
 one(array, 0.5 <= #)
 one(array, 0.5 == #)
+one(array, 0.5 == 0.5)
 one(array, 0.5 > #)
-one(array, 0.5 > f32)
+one(array, 0.5 > 1)
 one(array, 0.5 >= #)
 one(array, 1 != #)
-one(array, 1 < 0.5)
-one(array, 1 < i)
+one(array, 1 != i64)
+one(array, 1 != nil)
+one(array, 1 < #)
+one(array, 1 < f64)
 one(array, 1 <= #)
-one(array, 1 <= 0.5)
-one(array, 1 == #)
-one(array, 1 == i32)
-one(array, 1 > #)
+one(array, 1 > 0.5)
 one(array, 1 >= #)
-one(array, 1 >= f32)
-one(array, f32 < 1)
+one(array, add == div)
+one(array, all(array, true))
+one(array, div != score)
 one(array, f32 <= #)
-one(array, f32 <= i64)
-one(array, f32 == #)
-one(array, f32 == 0.5)
-one(array, f32 == 1)
+one(array, f32 <= 0.5)
 one(array, f32 >= #)
-one(array, f64 != #)
-one(array, f64 != 1)
-one(array, f64 != i)
-one(array, f64 != nil)
+one(array, f64 < #)
 one(array, f64 == #)
-one(array, f64 > #)
-one(array, false == nil)
-one(array, greet == score)
-one(array, i != 0.5)
-one(array, i < i32)
-one(array, i <= #)
-one(array, i == #)
+one(array, f64 >= #)
+one(array, f64 >= 1)
+one(array, f64 >= i32)
+one(array, f64 in array)
+one(array, false || true)
+one(array, i < #)
+one(array, i > 0.5)
 one(array, i > f64)
-one(array, i >= #)
-one(array, i >= f32)
 one(array, i32 != #)
+one(array, i32 < #)
 one(array, i32 <= #)
-one(array, i32 == #)
-one(array, i32 == i)
 one(array, i32 > #)
-one(array, i64 <= #)
+one(array, i32 >= #)
+one(array, i64 != #)
+one(array, i64 < #)
 one(array, i64 == #)
-one(array, i64 > #)
-one(array, i64 > 1)
+one(array, i64 == f32)
+one(array, i64 >= #)
+one(array, i64 >= f64)
+one(array, list != array)
 one(array, nil != #)
-one(array, nil != foo)
-one(array, nil == i64)
+one(array, nil != i64)
 one(array, not ok)
-one(array, not true)
-one(array, ok && true)
 one(array, ok)
-one(array, one(array, false))
+one(array, one(list, false))
+one(array, score != add)
 one(array, score != greet)
 one(array, score == div)
-one(array, true || ok)
-one(array, true || true)
-one(filter(list, true), ok)
-one(i32 .. i32, ok)
-one(i32 .. i64, # >= #)
+one(array, true != false)
+one(array, true == nil)
+one(array, true) ? greet : add
+one(array, true) or 1 != nil
+one(false ? greet : "bar", f64 != #)
+one(groupBy(array, 0.5)?.String, #)
+one(groupBy(array, f64).array, .i(nil).ok)
+one(groupBy(list, ok).foo, .add?.array)
+one(groupBy(list, ok)?.score, .i64())
+one(i32 .. 1, # == #)
+one(i32 .. i32, not ok)
+one(i64 .. 1, # >= 1)
+one(i64 .. i32, # != #)
+one(i64 .. i32, # >= #)
+one(list, !(i64 != 1))
+one(list, !false)
 one(list, !ok)
-one(list, !true)
-one(list, "bar" not in #)
-one(list, "foo" != "bar")
-one(list, "foo" < "foo")
+one(list, "foo" < "bar")
+one(list, "foo" not endsWith "bar")
 one(list, "foo" not in #)
+one(list, "foo" startsWith "bar")
 one(list, # != #)
-one(list, # != nil)
+one(list, # != foo)
 one(list, # == #)
-one(list, # == foo)
-one(list, # == nil)
 one(list, # in list)
-one(list, 0.5 != f32)
-one(list, 0.5 > 0.5)
-one(list, 1 < 1)
-one(list, any(array, true))
-one(list, any(list, ok))
+one(list, # not in list)
+one(list, 0.5 < 1)
+one(list, 0.5 <= 0.5)
+one(list, 0.5 == f64)
+one(list, 1 > i)
+one(list, add != nil)
+one(list, all(array, true))
 one(list, any(list, true))
-one(list, f32 == 0.5)
-one(list, f32 == f64)
-one(list, f32 > f32)
-one(list, f64 != nil)
-one(list, f64 == f32)
-one(list, f64 >= 0.5)
+one(list, div != nil)
+one(list, f32 == nil)
+one(list, f32 > i)
+one(list, f32 >= 1)
 one(list, f64 >= 1)
+one(list, false == nil)
+one(list, foo != #)
+one(list, foo != nil)
 one(list, foo == #)
-one(list, greet != nil)
-one(list, greet == score)
-one(list, half != add)
-one(list, i != nil)
-one(list, i == i64)
-one(list, i64 != f32)
-one(list, i64 < 1)
-one(list, i64 <= 0.5)
-one(list, i64 > 0.5)
-one(list, i64 > 1)
-one(list, list != nil)
-one(list, nil != nil)
-one(list, nil != score)
+one(list, greet == nil)
+one(list, half == nil)
+one(list, i <= i64)
+one(list, i > f64)
+one(list, i > i32)
+one(list, i32 != f32)
+one(list, i64 == 1)
+one(list, nil != #)
+one(list, nil != half)
 one(list, nil == #)
-one(list, none(array, ok))
-one(list, none(list, ok))
-one(list, not false)
-one(list, not ok)
-one(list, not true)
+one(list, nil == f64)
+one(list, ok or true)
 one(list, ok)
-one(list, ok) and ok
-one(list, one(list, ok))
-one(list, score == half)
-one(list, true) && ok ? i : i64
-one(map(array, "foo"), # matches #)
+one(list, ok) or 0.5 == nil
+one(list, score != nil)
+one(list, true == nil)
+one(list[i64:i32], i != i)
+one(map(array, "bar"), not false)
 one(map(array, #), # != #)
-one(map(array, #), # < #)
-one(map(array, #), # <= #)
-one(map(array, #), # > #)
-one(map(array, #), # > 1)
-one(map(array, #), f64 <= 0.5)
-one(map(array, #), ok)
-one(map(array, div), # == nil)
-one(map(array, i64), ok)
+one(map(array, #), # >= #)
+one(map(array, #), i32 == #)
+one(map(array, 1), ok)
+one(map(array, div), # == #)
+one(map(array, f64), # < 0.5)
+one(map(array, false), #)
+one(map(array, i), ok)
+one(map(array, list), ok)
 one(map(array, true), #)
-one(map(list, "bar"), ok)
-one(map(list, #), nil != #)
-one(map(list, 1), # < 0.5)
-one(map(list, f64), # <= #)
-one(map(list, false), #)
-one(map(list, i), ok)
-one(map(list, list), ok)
 one(map(list, ok), #)
-repeat(toJSON(nil), i)
+one(map(list, score), # != #)
+one(ok ? "foo" : false, # > #)
+one(reduce(array, array), ok)
+one(true ? array : 1, # <= #)
+reduce(1 .. 1, #)
+reduce(1 .. 1, f32 >= i)
+reduce(1 .. i64, array)
+reduce(1 .. i64, greet)
+reduce(1 .. i64, half)
+reduce(["foo"], f32)
+reduce([0.5], f64)
+reduce([1], .Qux)
+reduce([div, "foo"], i32)
+reduce([div], # >= 0.5)
+reduce([div], list == #)
+reduce([f32, f64], f32)
+reduce([f32], .f64)
+reduce([f64], # or #)
+reduce([f64], .greet)
+reduce([false], # ** #)
+reduce([foo], ok)
+reduce([greet], # % 1)
+reduce([i32], list)
+reduce([i64, half], "bar" not startsWith "foo")
+reduce([i], # < #)
+reduce([i], #[array])
+reduce([i], ok)
+reduce([list], # - #)
+reduce([list], # or #)
+reduce([list], f64)
+reduce([nil], # in array)
+reduce([ok], #?.half)
+reduce([true], #?.score())
+reduce([true], 0.5 > #)
+reduce(array, !false)
+reduce(array, "foo" endsWith "foo")
+reduce(array, "foo") not in foo
+reduce(array, # != #)
+reduce(array, # != 1)
+reduce(array, # != i32)
+reduce(array, # != nil)
+reduce(array, # % #)
+reduce(array, # % i64)
+reduce(array, # * #)
+reduce(array, # * 0.5)
+reduce(array, # * 1)
+reduce(array, # * f32)
+reduce(array, # * i)
+reduce(array, # * i32)
+reduce(array, # * i64)
+reduce(array, # ** #)
+reduce(array, # ** f32)
+reduce(array, # ** i32)
+reduce(array, # + #)
+reduce(array, # + 0.5)
+reduce(array, # + 1)
+reduce(array, # + i)
+reduce(array, # + i64)
+reduce(array, # - #)
+reduce(array, # - 0.5)
+reduce(array, # - 1)
+reduce(array, # - i)
+reduce(array, # - i32)
+reduce(array, # - i64)
+reduce(array, # .. #)
+reduce(array, # .. i32)
+reduce(array, # / #)
+reduce(array, # / 0.5)
+reduce(array, # / 1)
+reduce(array, # / f32)
+reduce(array, # / i32)
+reduce(array, # < #)
+reduce(array, # < 0.5)
+reduce(array, # < 1)
+reduce(array, # < i32)
+reduce(array, # <= #)
+reduce(array, # <= 0.5)
+reduce(array, # <= f32)
+reduce(array, # <= i32)
+reduce(array, # == #)
+reduce(array, # == 0.5)
+reduce(array, # == 1)
+reduce(array, # == f32)
+reduce(array, # == i32)
+reduce(array, # == i64)
+reduce(array, # == nil)
+reduce(array, # > #)
+reduce(array, # > 1)
+reduce(array, # > f64)
+reduce(array, # > i)
+reduce(array, # >= #)
+reduce(array, # >= f32)
+reduce(array, # >= f64)
+reduce(array, # >= i32)
+reduce(array, # >= i64)
+reduce(array, # ^ #)
+reduce(array, # ^ 0.5)
+reduce(array, # ^ f32)
+reduce(array, # ^ f64)
+reduce(array, # ^ i64)
+reduce(array, # in array)
+reduce(array, # not in array)
+reduce(array, #)
+reduce(array, #) != 0.5 == true
+reduce(array, #) != 0.5 ? ok : nil
+reduce(array, #) != f32
+reduce(array, #) != i32
+reduce(array, #) != i64
+reduce(array, #) % i
+reduce(array, #) % i32
+reduce(array, #) % i64
+reduce(array, #) * i
+reduce(array, #) * i32
+reduce(array, #) * len("foo")
+reduce(array, #) ** f64
+reduce(array, #) ** min(1, i32)
+reduce(array, #) + i
+reduce(array, #) + i64
+reduce(array, #) + reduce(array, #)
+reduce(array, #) - f64
+reduce(array, #) - i
+reduce(array, #) - max(f32)
+reduce(array, #) .. i
+reduce(array, #) .. i32
+reduce(array, #) .. i64
+reduce(array, #) / f32
+reduce(array, #) / f64
+reduce(array, #) / i32
+reduce(array, #) / i64
+reduce(array, #) < f32
+reduce(array, #) < f32 / 0.5
+reduce(array, #) < f64
+reduce(array, #) < i
+reduce(array, #) <= -1
+reduce(array, #) <= f32
+reduce(array, #) <= f64
+reduce(array, #) <= f64 * 0.5
+reduce(array, #) <= i
+reduce(array, #) == f64
+reduce(array, #) == i64
+reduce(array, #) > i32
+reduce(array, #) >= f32
+reduce(array, #) >= f64
+reduce(array, #) >= i32
+reduce(array, #) >= i64
+reduce(array, #) ^ f32 ** 0.5
+reduce(array, #) ^ i32
+reduce(array, #) not in array
+reduce(array, #) not in map(array, #)
+reduce(array, (0.5 + #) * f32)
+reduce(array, -#)
+reduce(array, -(# - #))
+reduce(array, -0.5)
+reduce(array, -1)
+reduce(array, -f32)
+reduce(array, -f64)
+reduce(array, -i)
+reduce(array, -i32)
+reduce(array, -i64)
+reduce(array, 0.5 != #)
+reduce(array, 0.5 != 0.5)
+reduce(array, 0.5 * #)
+reduce(array, 0.5 ** #)
+reduce(array, 0.5 ** 1)
+reduce(array, 0.5 + #)
+reduce(array, 0.5 - #)
+reduce(array, 0.5 - i64)
+reduce(array, 0.5 / #)
+reduce(array, 0.5 / f32)
+reduce(array, 0.5 < #)
+reduce(array, 0.5 < 1)
+reduce(array, 0.5 <= #)
+reduce(array, 0.5 <= 1)
+reduce(array, 0.5 == #)
+reduce(array, 0.5 == f64)
+reduce(array, 0.5 == i64)
+reduce(array, 0.5 > #)
+reduce(array, 0.5 > 0.5)
+reduce(array, 0.5 >= 0.5)
+reduce(array, 0.5 >= 1)
+reduce(array, 0.5 ^ #)
+reduce(array, 0.5 ^ 0.5)
+reduce(array, 0.5) * f32
+reduce(array, 0.5) - i
+reduce(array, 0.5) > i64 ? 1 : 0.5
+reduce(array, 1 != #)
+reduce(array, 1 * f64)
+reduce(array, 1 ** #)
+reduce(array, 1 + #)
+reduce(array, 1 - #)
+reduce(array, 1 - 1)
+reduce(array, 1 / i32)
+reduce(array, 1 < #)
+reduce(array, 1 >= #)
+reduce(array, 1 ^ #)
+reduce(array, 1 ^ 0.5)
+reduce(array, 1 ^ i32)
+reduce(array, 1) % i32
+reduce(array, 1) ** f32
+reduce(array, 1) + f64
+reduce(array, 1) / f64
+reduce(array, 1) / i32
+reduce(array, 1) <= i32
+reduce(array, 1) ^ i
+reduce(array, 1) not in array
+reduce(array, [#])
+reduce(array, abs(#))
+reduce(array, abs(f64))
+reduce(array, abs(i64))
+reduce(array, add(#, #))
+reduce(array, add)
+reduce(array, all(list, ok))
+reduce(array, array)
+reduce(array, array)[i32]
+reduce(array, array[#:#])
+reduce(array, array[i64:#])
+reduce(array, bitand(i32, i32))
+reduce(array, bitnot(#))
+reduce(array, bitor(#, #))
+reduce(array, bitshr(#, #))
+reduce(array, bitushr(#, #))
+reduce(array, ceil(#))
+reduce(array, div(#, #))
+reduce(array, div)
+reduce(array, f32 ** #)
+reduce(array, f32 + #)
+reduce(array, f32 / #)
+reduce(array, f32 <= #)
+reduce(array, f32 == #)
+reduce(array, f32 == i)
+reduce(array, f32 >= #)
+reduce(array, f32 >= 0.5)
+reduce(array, f32 ^ #)
+reduce(array, f32 ^ f32)
+reduce(array, f32 ^ i32)
+reduce(array, f32)
+reduce(array, f32) ** (0.5 * f64)
+reduce(array, f32) <= f32
+reduce(array, f32) not in array
+reduce(array, f64 ** #)
+reduce(array, f64 + #)
+reduce(array, f64 + i32)
+reduce(array, f64 - #)
+reduce(array, f64 / 1)
+reduce(array, f64 < #)
+reduce(array, f64 == #)
+reduce(array, f64 ^ 1)
+reduce(array, f64)
+reduce(array, f64) != i32
+reduce(array, f64) * i
+reduce(array, f64) / f64
+reduce(array, f64) <= f32
+reduce(array, f64) <= first(array)
+reduce(array, f64) == i
+reduce(array, f64) >= i
+reduce(array, f64) ^ f64
+reduce(array, false ? f64 : #)
+reduce(array, false ? score : #)
+reduce(array, false) ? i64 : f32
+reduce(array, false) || ok
+reduce(array, findLastIndex(list, false))
+reduce(array, findLastIndex(list, reduce(array, true)))
+reduce(array, float(#))
+reduce(array, floor(i64))
+reduce(array, foo)
+reduce(array, foo).Bar
+reduce(array, foo).Qux
+reduce(array, foo).String
+reduce(array, foo).String()
+reduce(array, foo)?.Bar
+reduce(array, foo)?.Qux
+reduce(array, foo)?.String
+reduce(array, foo)?.String()
+reduce(array, foo.Bar)
+reduce(array, foo.String)
+reduce(array, foo?.String())
+reduce(array, foo?.String)
+reduce(array, get(array, 1))
+reduce(array, get(list, #))
+reduce(array, greet("bar"))
+reduce(array, greet)
+reduce(array, greet) != score != nil
+reduce(array, groupBy(array, #))
+reduce(array, groupBy(list, #))
+reduce(array, groupBy(list, #)?.f32)
+reduce(array, half(1))
+reduce(array, half)
+reduce(array, i != #)
+reduce(array, i % #)
+reduce(array, i * #)
+reduce(array, i ** f64)
+reduce(array, i + 0.5)
+reduce(array, i - #)
+reduce(array, i / #)
+reduce(array, i <= #)
+reduce(array, i <= i64)
+reduce(array, i > i32)
+reduce(array, i ^ #)
+reduce(array, i)
+reduce(array, i) % i32
+reduce(array, i) + i32
+reduce(array, i) - f32
+reduce(array, i) == 0.5 ** 1
+reduce(array, i32 != #)
+reduce(array, i32 != i32)
+reduce(array, i32 + 0.5)
+reduce(array, i32 - #)
+reduce(array, i32 .. #)
+reduce(array, i32 < #)
+reduce(array, i32 < 1)
+reduce(array, i32 > #)
+reduce(array, i32 >= #)
+reduce(array, i32)
+reduce(array, i32) * 1 * 0.5
+reduce(array, i64 != #)
+reduce(array, i64 % i)
+reduce(array, i64 % i32)
+reduce(array, i64 * #)
+reduce(array, i64 + i32)
+reduce(array, i64 - #)
+reduce(array, i64 .. #)
+reduce(array, i64 .. 1)
+reduce(array, i64 / f64)
+reduce(array, i64 <= #)
+reduce(array, i64 == 1)
+reduce(array, i64 == nil)
+reduce(array, i64 ^ #)
+reduce(array, i64 ^ f64)
+reduce(array, i64)
+reduce(array, i64) + i
+reduce(array, i64) / f64
+reduce(array, i64) < i
+reduce(array, i64) == f32
+reduce(array, int(f64))
+reduce(array, len(array))
+reduce(array, list)
+reduce(array, list) != map(list, half)
+reduce(array, map(array, div))
+reduce(array, map(array, score))
+reduce(array, map(list, 1))
+reduce(array, max(#, #, #))
+reduce(array, max(0.5))
+reduce(array, min(#))
+reduce(array, min(#, #, 0.5))
+reduce(array, min(0.5))
+reduce(array, min(1, 1))
+reduce(array, nil != "bar")
+reduce(array, nil != #)
+reduce(array, nil != 1)
+reduce(array, not ok)
+reduce(array, ok ? "foo" : "bar")
+reduce(array, ok ? # : array)
+reduce(array, ok ? # : i)
+reduce(array, ok || true)
+reduce(array, ok)
+reduce(array, ok) and ok
+reduce(array, reduce(array, 1))
+reduce(array, reduce(list, 0.5))
+reduce(array, round(0.5))
+reduce(array, score(#))
+reduce(array, score(1, #))
+reduce(array, score)
+reduce(array, string(0.5))
+reduce(array, string(1))
+reduce(array, string(foo))
+reduce(array, string(i32))
+reduce(array, toJSON(i))
+reduce(array, trimPrefix("bar"))
+reduce(array, true && true)
+reduce(array, true ? add : #)
+reduce(array, true) != ok
+reduce(array, true) and ok
+reduce(array, type(#))
+reduce(array, type(1))
+reduce(array, type(add))
+reduce(array, type(greet))
+reduce(array, type(score))
+reduce(array, upper("bar"))
+reduce(false ? 0.5 : "bar", # and false)
+reduce(false ? i32 : array, toJSON(#))
+reduce(false ? nil : list, #)
+reduce(filter(array, ok), foo)
+reduce(filter(list, ok), foo.Bar)
+reduce(filter(list, true), i)
+reduce(i .. 1, f64)
+reduce(i .. 1, score)
+reduce(i .. i, #)
+reduce(i .. i, foo)
+reduce(i .. i32, add)
+reduce(i32 .. 1, #)
+reduce(i32 .. 1, foo)
+reduce(i32 .. i, 0.5 - #)
+reduce(i32 .. i32, i64)
+reduce(i32 .. i64, abs(f64))
+reduce(i64 .. 1, -#)
+reduce(i64 .. i, #)
+reduce(i64 .. i, -0.5)
+reduce(i64 .. i, false ? "bar" : #)
+reduce(i64 .. i, i)
+reduce(i64 .. i, ok)
+reduce(i64 .. i, round(i32))
+reduce(i64 .. i64, i64)
+reduce(list, !true)
+reduce(list, "bar" <= "bar")
+reduce(list, "bar" in #)
+reduce(list, "foo" not in #)
+reduce(list, # != #)
+reduce(list, # != foo)
+reduce(list, # != nil)
+reduce(list, # == #)
+reduce(list, # == foo)
+reduce(list, # == nil)
+reduce(list, # in list)
+reduce(list, # not in list)
+reduce(list, #)
+reduce(list, #) != foo
+reduce(list, #) not in groupBy(array, i)
+reduce(list, #) not in list
+reduce(list, #).Bar
+reduce(list, #).Qux
+reduce(list, #).String
+reduce(list, #).String()
+reduce(list, #)?.Bar
+reduce(list, #)?.Qux
+reduce(list, #)?.String
+reduce(list, #)?.String()
+reduce(list, #?.Bar not in # ? # : #)
+reduce(list, #?.Bar)
+reduce(list, #?.Qux("foo"))
+reduce(list, #?.Qux)
+reduce(list, #?.String())
+reduce(list, #?.String)
+reduce(list, -0.5)
+reduce(list, -f64)
+reduce(list, -i)
+reduce(list, -i32)
+reduce(list, .Bar)
+reduce(list, .Qux)
+reduce(list, .String())
+reduce(list, .String)
+reduce(list, 0.5 != f64)
+reduce(list, 0.5 != nil)
+reduce(list, 0.5 == i64)
+reduce(list, 0.5 >= 0.5)
+reduce(list, 0.5) != i
+reduce(list, 0.5) / i64
+reduce(list, 0.5) < f32
+reduce(list, 0.5) < i
+reduce(list, 0.5) < i32
+reduce(list, 0.5) < i64
+reduce(list, 0.5) <= f32
+reduce(list, 0.5) >= f64
+reduce(list, 0.5) >= i64
+reduce(list, 1 != nil)
+reduce(list, 1 + f64)
+reduce(list, 1 - 0.5)
+reduce(list, 1 / 0.5)
+reduce(list, 1 < f64)
+reduce(list, 1 <= 1)
+reduce(list, 1 == 0.5)
+reduce(list, 1 == nil)
+reduce(list, 1 ^ 1)
+reduce(list, 1) * f64
+reduce(list, 1) + f32
+reduce(list, 1) - i
+reduce(list, add)
+reduce(list, add) != div
+reduce(list, add) in map(array, greet)
+reduce(list, array != array)
+reduce(list, array)
+reduce(list, div == greet)
+reduce(list, div)
+reduce(list, f32 / 0.5)
+reduce(list, f32 < i32)
+reduce(list, f32 <= f32)
+reduce(list, f32)
+reduce(list, f32) == f32
+reduce(list, f64 != nil)
+reduce(list, f64 + 0.5)
+reduce(list, f64 + 1)
+reduce(list, f64 / i32)
+reduce(list, f64 <= i32)
+reduce(list, f64 == f32)
+reduce(list, f64 > f32)
+reduce(list, f64 >= 0.5)
+reduce(list, f64)
+reduce(list, f64) * i64
+reduce(list, false == false)
+reduce(list, false ? "foo" : list)
+reduce(list, false ? # : #)
+reduce(list, false || true)
+reduce(list, filter(list, ok))
+reduce(list, findIndex(array, true))
+reduce(list, findLastIndex(list, false))
+reduce(list, float(i))
+reduce(list, floor(0.5))
+reduce(list, foo != #)
+reduce(list, foo)
+reduce(list, foo) == foo
+reduce(list, foo).Bar
+reduce(list, foo).Qux
+reduce(list, foo).String
+reduce(list, foo).String()
+reduce(list, foo)?.Bar
+reduce(list, foo)?.Qux
+reduce(list, foo)?.String
+reduce(list, foo)?.String()
+reduce(list, foo.Bar)
+reduce(list, foo.String)
+reduce(list, foo?.Bar)
+reduce(list, foo?.Qux)
+reduce(list, foo?.String)
+reduce(list, get(list, i))
+reduce(list, greet != nil)
+reduce(list, greet("bar"))
+reduce(list, greet)
+reduce(list, groupBy(array, 1))
+reduce(list, groupBy(list, "bar"))
+reduce(list, groupBy(list, #))
+reduce(list, half(1))
+reduce(list, half)
+reduce(list, i * i64)
+reduce(list, i + 1)
+reduce(list, i - f64)
+reduce(list, i .. 1)
+reduce(list, i == 0.5)
+reduce(list, i > i64)
+reduce(list, i >= 0.5)
+reduce(list, i)
+reduce(list, i) * i64
+reduce(list, i) .. 1 % 1
+reduce(list, i) .. i
+reduce(list, i) / f64
+reduce(list, i) / i32
+reduce(list, i) < f32
+reduce(list, i) == f32
+reduce(list, i) > f32
+reduce(list, i) ^ f32
+reduce(list, i32 != nil)
+reduce(list, i32 - i32)
+reduce(list, i32 .. 1)
+reduce(list, i32 / 0.5)
+reduce(list, i32 < i)
+reduce(list, i32 <= i)
+reduce(list, i32 == f64)
+reduce(list, i32 >= f32)
+reduce(list, i32)
+reduce(list, i32) != f64
+reduce(list, i32) % i
+reduce(list, i32) - f32
+reduce(list, i32) >= i
+reduce(list, i64 .. 1)
+reduce(list, i64 < i64)
+reduce(list, i64 > i64)
+reduce(list, i64 >= 0.5)
+reduce(list, i64)
+reduce(list, i64) * f64
+reduce(list, i64) ** i32
+reduce(list, i64) <= i64
+reduce(list, int(i64))
+reduce(list, len(array))
+reduce(list, list != nil)
+reduce(list, list == nil)
+reduce(list, list)
+reduce(list, map(array, "bar"))
+reduce(list, map(array, #))
+reduce(list, map(list, 1))
+reduce(list, max(0.5))
+reduce(list, max(f32))
+reduce(list, min(0.5))
+reduce(list, min(1))
+reduce(list, min(f32))
+reduce(list, nil != #)
+reduce(list, nil != add)
+reduce(list, nil != half)
+reduce(list, nil == #)
+reduce(list, not (half != score))
+reduce(list, not false)
+reduce(list, not ok)
+reduce(list, not true)
+reduce(list, ok ? # : #)
+reduce(list, ok ? # : score)
+reduce(list, ok ? greet : add)
+reduce(list, ok ? score : #)
+reduce(list, ok)
+reduce(list, reduce(array, ok))
+reduce(list, reduce(array, score))
+reduce(list, reduce(list, #))
+reduce(list, reduce(list, 1))
+reduce(list, reduce(list, add))
+reduce(list, reduce(list, i32))
+reduce(list, score != half)
+reduce(list, score(i))
+reduce(list, score)
+reduce(list, string(greet))
+reduce(list, toBase64("bar"))
+reduce(list, toBase64("foo"))
+reduce(list, toJSON(array))
+reduce(list, toJSON(list))
+reduce(list, toJSON(nil))
+reduce(list, true == nil)
+reduce(list, true ? foo : f64)
+reduce(list, type(#))
+reduce(map(array, "bar"), # not endsWith #)
+reduce(map(array, "bar"), add)
+reduce(map(array, "foo"), half(f64))
+reduce(map(array, #), # != i)
+reduce(map(array, #), # .. #)
+reduce(map(array, #), #)
+reduce(map(array, #), abs(#))
+reduce(map(array, #), i)
+reduce(map(array, #), i32 * #)
+reduce(map(array, #), not ok)
+reduce(map(array, 0.5), add)
+reduce(map(array, 0.5), div)
+reduce(map(array, 0.5), f32)
+reduce(map(array, 1), # ^ 0.5)
+reduce(map(array, 1), #)
+reduce(map(array, 1), foo)
+reduce(map(array, add), #)
+reduce(map(array, add), f32)
+reduce(map(array, add), list)
+reduce(map(array, array), f64)
+reduce(map(array, div), #)
+reduce(map(array, div), div)
+reduce(map(array, div), i32 * i)
+reduce(map(array, f32), f32)
+reduce(map(array, f32), i)
+reduce(map(array, f32), i32)
+reduce(map(array, f64), #)
+reduce(map(array, f64), f32 < #)
+reduce(map(array, false), # and true)
+reduce(map(array, false), f32)
+reduce(map(array, foo), # == nil)
+reduce(map(array, i), # / 1)
+reduce(map(array, i), #)
+reduce(map(array, i), add)
+reduce(map(array, i), f64 + 1)
+reduce(map(array, i32), array)
+reduce(map(array, i32), list)
+reduce(map(array, i64), # <= #)
+reduce(map(array, i64), #)
+reduce(map(array, list), filter(#, false))
+reduce(map(array, ok), i)
+reduce(map(array, score), i32)
+reduce(map(list, "bar"), #)
+reduce(map(list, "foo"), #)
+reduce(map(list, #), #)
+reduce(map(list, #), .Qux)
+reduce(map(list, #), add)
+reduce(map(list, #), array)
+reduce(map(list, #), f32)
+reduce(map(list, #), f64)
+reduce(map(list, #), half)
+reduce(map(list, #), i64)
+reduce(map(list, #), ok)
+reduce(map(list, 0.5), #)
+reduce(map(list, 0.5), foo)
+reduce(map(list, 1), # > #)
+reduce(map(list, 1), #)
+reduce(map(list, 1), list)
+reduce(map(list, array), div)
+reduce(map(list, div), add)
+reduce(map(list, f64), #)
+reduce(map(list, f64), ok)
+reduce(map(list, false), div)
+reduce(map(list, greet), #)
+reduce(map(list, i), #)
+reduce(map(list, i), [i32])
+reduce(map(list, i), f32)
+reduce(map(list, i), score(#))
+reduce(map(list, i32), #)
+reduce(map(list, i32), foo)
+reduce(map(list, i64), #)
+reduce(map(list, i64), i32)
+reduce(map(list, list), ok)
+reduce(map(list, score), #)
+reduce(map(list, score), f64)
+reduce(map(list, true), #)
+reduce(map(list, true), add)
+reduce(map(list, true), half)
+reduce(ok ? "bar" : i32, #)
+reduce(ok ? "foo" : list, #)
+reduce(ok ? array : half, f32)
+reduce(ok ? list : i, #)
+reduce(reduce(array, array), f64 != #)
+reduce(reduce(array, list), get(array, i32))
+reduce(reduce(list, array), f64)
+reduce(sort(array), #)
+reduce(sort(array), foo)
+reduce(sort(array), greet)
+reduce(sort(array), ok)
+reduce(true ? array : 1, array)
+reduce(true ? array : array, #)
+repeat(type(ok), i)
+round(-0.5)
+round(-1)
+round(-f32)
+round(-f64)
+round(-i)
+round(-i32)
+round(-i64)
+round(0.5 * 1)
+round(0.5 * f64)
+round(0.5 * i32)
+round(0.5 ** 0.5)
+round(0.5 ** 1)
+round(0.5 ** i)
+round(0.5 ** i32)
+round(0.5 ** i64)
+round(0.5 + 1)
+round(0.5 + f64)
+round(0.5 + i)
+round(0.5 + i32)
+round(0.5 - 0.5)
+round(0.5 - 1)
+round(0.5 - i32)
+round(0.5 / 0.5)
+round(0.5 / 1)
+round(0.5 / f64)
+round(0.5 / i32)
+round(0.5 ^ f64)
+round(0.5 ^ i)
+round(0.5 ^ i64)
+round(0.5) * f32
+round(0.5) ** i32
+round(0.5) + -f32
+round(0.5) - i64 ^ i
+round(0.5) < f64
+round(0.5) <= i64
+round(0.5) == i32
+round(0.5) == i64
+round(0.5) == max(i, i64)
+round(0.5) > -1
+round(0.5) > i
+round(0.5) >= i
+round(0.5) in array
+round(1 % i)
+round(1 % i64)
+round(1 * 0.5)
+round(1 * f32)
+round(1 * i64)
+round(1 ** 0.5)
+round(1 ** 1)
+round(1 ** f32)
+round(1 ** f64)
+round(1 ** i)
+round(1 + 0.5)
+round(1 + 1)
+round(1 + i64)
+round(1 - 0.5)
+round(1 - 1)
+round(1 - i)
+round(1 - i32)
+round(1 - i64)
+round(1 / 0.5)
+round(1 / 1)
+round(1 / f32)
+round(1 / i)
+round(1 / i64)
+round(1 ^ 0.5)
+round(1 ^ 1)
+round(1 ^ f32)
+round(1 ^ i)
+round(1 ^ i64)
+round(1) != ceil(i32)
+round(1) * i32
+round(1) + i64
+round(1) - i64
+round(1) / i32
+round(1) / i64
+round(1) < i64
+round(1) <= i
+round(1) == i
+round(1) >= f64
+round(1) >= i32
+round(1) >= i64
+round(1) ^ f64
+round(1) not in array
+round(abs(0.5))
+round(abs(1))
+round(abs(f64))
+round(abs(i))
+round(abs(i64))
+round(add(1, i))
+round(array[1])
+round(array[i32])
+round(array[i64])
+round(bitnot(i))
+round(bitnot(i32))
+round(bitnot(i64))
+round(ceil(1))
+round(ceil(f64))
+round(ceil(i32))
+round(ceil(i64))
+round(count(list, true))
+round(div(1, 1))
+round(f32 * 0.5)
+round(f32 * 1)
+round(f32 * f64)
+round(f32 * i32 ^ f32)
+round(f32 * i64)
+round(f32 ** 0.5)
+round(f32 ** 1)
+round(f32 + f64)
+round(f32 + i32)
+round(f32 - 0.5)
+round(f32 - i)
+round(f32 / i32)
+round(f32 ^ 0.5)
+round(f32 ^ f32)
+round(f32 ^ i)
+round(f32 ^ i64)
+round(f32)
+round(f32) * i32
+round(f32) - i32
+round(f32) / f32
+round(f32) == i32
+round(f64 * 0.5)
+round(f64 * i)
+round(f64 ** 0.5)
+round(f64 ** 1)
+round(f64 ** f32)
+round(f64 ** i)
+round(f64 + f64)
+round(f64 + i)
+round(f64 + i32)
+round(f64 - 0.5)
+round(f64 - 1)
+round(f64 - i32)
+round(f64 / f64)
+round(f64 / i)
+round(f64 / i32)
+round(f64 / i64)
+round(f64 ^ 1)
+round(f64 ^ f64)
+round(f64)
+round(f64) * f32
+round(f64) ** i32
+round(f64) + f64
+round(f64) <= f64
+round(f64) > i
+round(f64) > i32
+round(f64) >= i64
+round(f64) not in array
+round(false ? f32 : f64)
+round(false ? f64 : 1)
+round(false ? nil : 1)
+round(findIndex(array, # <= #))
+round(findIndex(list, ok))
+round(findLast(array, ok))
+round(findLast(array, true))
+round(findLastIndex(array, ok))
+round(findLastIndex(list, ok))
+round(float(0.5))
+round(float(1))
+round(float(f32))
+round(float(i))
+round(floor(0.5))
+round(floor(1))
+round(floor(f64))
+round(floor(i32))
+round(floor(i64))
+round(get(array, i))
+round(get(array, i32))
+round(get(array, i64))
+round(half(-1))
+round(half(0.5))
+round(half(1))
+round(half(f64))
+round(i % i32)
+round(i % i64)
+round(i * 1)
+round(i * f64)
+round(i * i32)
+round(i ** 1)
+round(i ** i64)
+round(i + 0.5)
+round(i + 1)
+round(i + f64)
+round(i + i)
+round(i + i32)
+round(i + i64)
+round(i - i)
+round(i - i32)
+round(i / 1)
+round(i / i)
+round(i / i64)
+round(i ^ 0.5) > f32
+round(i ^ 1)
+round(i ^ f32)
+round(i)
+round(i) * f32
+round(i) * i
+round(i) / f64
+round(i) < i
+round(i) < i32
+round(i) > i
+round(i) > i64 != ok
+round(i) >= f32
+round(i) >= i64
+round(i) ^ i32
+round(i32 % 1)
+round(i32 * 1)
+round(i32 ** 1)
+round(i32 ** f32)
+round(i32 ** f64)
+round(i32 + 0.5)
+round(i32 + 1)
+round(i32 + i32)
+round(i32 - 1)
+round(i32 - f32)
+round(i32 - f64)
+round(i32 / 0.5)
+round(i32 / 1)
+round(i32 ^ f64)
+round(i32)
+round(i32) != i
+round(i32) * f32
+round(i32) ** f64
+round(i32) - i
+round(i32) < i32
+round(i32) <= ceil(1)
+round(i32) <= f64
+round(i32) <= i64
+round(i32) >= f64
+round(i32) >= i32
+round(i32) ^ f64
+round(i64 % i)
+round(i64 % i32)
+round(i64 * 0.5)
+round(i64 * i)
+round(i64 ** 1)
+round(i64 ** f64)
+round(i64 ** i64)
+round(i64 + f32)
+round(i64 - 0.5)
+round(i64 - 1)
+round(i64 - i)
+round(i64 / 0.5)
+round(i64 / 1)
+round(i64 ^ 1)
+round(i64 ^ i32)
+round(i64 ^ i64)
+round(i64)
+round(i64) != f64
+round(i64) * i64
+round(i64) ** i32
+round(i64) - bitnot(1)
+round(i64) - f32
+round(i64) < f64
+round(i64) ^ f64
+round(int(0.5))
+round(int(1))
+round(int(f32))
+round(int(f64))
+round(int(i))
+round(int(i32))
+round(int(i64))
+round(last(array))
+round(len("bar"))
+round(len("foo"))
+round(len(array))
+round(len(list))
+round(max(0.5))
+round(max(1))
+round(max(i))
+round(max(i32))
+round(max(i64))
+round(max(i64, f32))
+round(mean(array))
+round(median(array))
+round(min(0.5))
+round(min(1))
+round(min(f32))
+round(min(f64))
+round(min(i32))
+round(min(i64))
+round(reduce(array, #))
+round(reduce(array, 0.5))
+round(reduce(array, 1))
+round(reduce(array, i64))
+round(reduce(list, 0.5))
+round(reduce(list, f32))
+round(round(0.5))
+round(round(1))
+round(round(f32))
+round(round(f64))
+round(round(i))
+round(round(i32))
+round(round(i64))
+round(score(1))
+round(score(i))
+round(sum(array))
+round(true ? i : ok)
 score
 score != add
-score != add != true
-score != add ? i64 : "foo"
+score != add == ok
+score != add ? 0.5 : div
 score != div
-score != div ? i : f32
-score != div and ok
 score != foo.Qux
 score != foo.String
 score != foo?.Qux
 score != foo?.String
 score != greet
-score != greet ? score : array
+score != greet ? add : i64
+score != greet ? div : i
 score != half
+score != half || ok
+score != nil != ok
+score != nil ? half : f64
+score != nil or i32 > 0.5
+score != nil || ok
 score != score
-score != score ? 1 : i
+score != score != ok
+score != score ? i32 : i32
 score == add
-score == add == false
-score == add ? f64 : not false
 score == div
-score == div || foo == foo
+score == div != nil
+score == div == ok
 score == foo.Qux
 score == foo.String
 score == foo?.Qux
 score == foo?.String
 score == greet
-score == greet ? half : f64
-score == greet and ok
+score == greet != ok
 score == half
+score == half ? 1 : add
+score == half ? half : f64
+score == nil != nil
+score == nil && ok
+score == nil ? 0.5 : "bar"
+score == reduce(array, half)
 score == score
-score == score ? 0.5 : foo
-score == score ? nil : i32
-score == score or ok
-score == {"bar": 0.5}.f32
+score == score == true
+score == score ? 0.5 : score
+score in groupBy(list, #)?.array
+score in map(list, add)
+score in sort(array)
 score(-1)
+score(-1, i)
+score(-get(array, i))
 score(-i)
 score(-i, i)
 score(1 % 1)
@@ -12533,7 +16422,6 @@ score(1 % i)
 score(1 % i32)
 score(1 % i64)
 score(1 * 1)
-score(1 * 1, i)
 score(1 * i)
 score(1 * i32)
 score(1 * i64)
@@ -12544,73 +16432,81 @@ score(1 + i64)
 score(1 - 1)
 score(1 - i)
 score(1 - i32)
-score(1 - i64)
-score(1) != -0.5
-score(1) != f32
-score(1) != float(f64)
+score(1) != -f32
 score(1) != i
-score(1) % i32
+score(1) != i32
+score(1) % -1
+score(1) % i
+score(1) % i64
 score(1) * f32
-score(1) * f64
+score(1) * i
 score(1) * i64
-score(1) ** -1
-score(1) ** f32
-score(1) ** i64
-score(1) + f32
+score(1) ** i32
 score(1) + f64
+score(1) + i32
 score(1) - f32
 score(1) - i
+score(1) - i32
+score(1) - int(0.5)
+score(1) .. i
+score(1) .. i32
 score(1) .. i64
-score(1) / f64
-score(1) / i
+score(1) .. score(1)
+score(1) / f32
 score(1) / i32
-score(1) / i64
+score(1) < i
 score(1) < i32
 score(1) < i64
-score(1) <= i32
+score(1) < i64 - 0.5
+score(1) <= 0.5 * 1
+score(1) <= i
 score(1) <= i64
-score(1) == 1 ^ 1
-score(1) == f64
-score(1) == i ** f64
 score(1) == i32
 score(1) == i64
+score(1) > bitshr(i64, 1)
+score(1) > f32
 score(1) > i64
+score(1) >= 0.5 + f64
 score(1) >= f32
-score(1) >= f64
 score(1) >= i
-score(1) >= i32
-score(1) >= i64
-score(1) ^ f32
+score(1) >= sum(array)
 score(1) ^ f64
 score(1) ^ i
+score(1) ^ i32
 score(1) in array
-score(1, i) > f32
+score(1) not in groupBy(list, false)
+score(1, 1) < i
+score(1, i) < f64
+score(1, i) ^ f32
 score(abs(1))
 score(abs(i))
-score(add(1, 1))
 score(add(1, i))
 score(array[1])
-score(array[i32])
 score(array[i64])
 score(array[i])
-score(count(array, f64 < 1))
+score(bitnand(1, i64))
+score(bitnand(i64, i32))
+score(bitnot(1))
+score(bitnot(i))
+score(bitnot(i32))
+score(bitnot(i64))
+score(bitshl(i32, i))
+score(bitshr(1, i64))
+score(bitshr(i32, i64))
+score(bitushr(1, i))
 score(count(array, false))
 score(count(array, ok))
 score(count(array, true))
-score(count(list, false))
 score(count(list, ok))
-score(count(list, true))
-score(div(1, 1))
-score(div(i, 1))
-score(false ? true : i)
+score(false ? f64 : 1)
+score(false ? foo : 1)
+score(find(array, i != #))
 score(find(array, ok))
+score(find(array, true))
 score(findIndex(array, ok))
 score(findIndex(array, true))
-score(findIndex(list, ok))
 score(findIndex(list, true))
-score(findLast(array, 0.5 != #))
-score(findLast(array, ok))
-score(findLastIndex(array, ok))
+score(findLast(array, true))
 score(findLastIndex(array, true))
 score(findLastIndex(list, ok))
 score(findLastIndex(list, true))
@@ -12619,76 +16515,95 @@ score(get(array, 1))
 score(get(array, i))
 score(get(array, i32))
 score(get(array, i64))
+score(i % 1)
 score(i % i)
-score(i % i32)
+score(i % i64)
+score(i * 1 * i)
 score(i * 1)
+score(i * i)
 score(i * i32)
 score(i * i64)
 score(i + 1)
 score(i + i)
 score(i + i32)
-score(i + i64)
 score(i - 1)
 score(i - i)
 score(i - i32)
-score(i - i64)
 score(i)
-score(i) != 1 == true
-score(i) != float(i32)
-score(i) != i
-score(i) != i32
-score(i) % i32 % i64
-score(i) % i64
-score(i) * f64
+score(i) != f32
+score(i) != f64
+score(i) % i
+score(i) % i * f64
+score(i) * f32
 score(i) * i32
-score(i) * i64
-score(i) ** f64
+score(i) ** (0.5 / 0.5)
+score(i) ** -0.5
 score(i) ** i32
-score(i) + f32
-score(i) + i
-score(i) + i32
-score(i) + i64
-score(i) - f32
-score(i) - i
+score(i) ** i64
+score(i) + f64
+score(i) - f64
 score(i) - i32
-score(i) / f32
-score(i) / i
+score(i) / i64
+score(i) < 1 != ok
 score(i) < f32
+score(i) < f64 / 0.5
 score(i) < i32
-score(i) <= f32 - f32
+score(i) < i64
+score(i) <= 0.5 / f32
+score(i) <= f32
+score(i) <= f64
+score(i) <= i
+score(i) <= i32
 score(i) == f32
-score(i) == i32
-score(i) == i64
+score(i) > f32
+score(i) > i
+score(i) > i64
 score(i) >= f32
-score(i) ^ f64
-score(i) ^ i
-score(i, i + i)
+score(i) >= f64
+score(i) >= i
+score(i) >= i32
+score(i) >= i64
+score(i) ^ f32
+score(i) ^ i32
+score(i) ^ i64
+score(i) ^ score(1)
+score(i, 1) + -1
+score(i, 1) .. i64
+score(i, 1) <= f32
 score(i, i)
-score(i, i) >= i
-score(i, int(i64))
-score(i, score(i)) - i32
+score(i, i) ** f32
+score(i32 % 1)
 score(i32 % i)
-score(i32 % i64)
+score(i32 % i32)
 score(i32 * 1)
 score(i32 * i)
+score(i32 * i32)
+score(i32 * i64)
+score(i32 + 1)
 score(i32 + i)
+score(i32 + i32)
 score(i32 + i64)
 score(i32 - 1)
 score(i32 - i)
+score(i32 - i32)
+score(i32 - i64)
 score(i64 % 1)
 score(i64 % i)
+score(i64 % i32)
+score(i64 % i64)
 score(i64 * 1)
-score(i64 * i)
 score(i64 * i32)
+score(i64 * i64)
 score(i64 + 1)
+score(i64 + i)
+score(i64 + i32)
 score(i64 - 1)
-score(i64 - i)
-score(i64 - i32)
+score(i64 - i64)
 score(int(0.5))
 score(int(1))
-score(int(f32 * i))
 score(int(f32))
 score(int(f64))
+score(int(float(0.5)))
 score(int(i))
 score(int(i32))
 score(int(i64))
@@ -12696,72 +16611,74 @@ score(last(array))
 score(len("bar"))
 score(len("foo"))
 score(len(array))
-score(len(i32 .. i64))
 score(len(list))
 score(max(1))
-score(max(1, 1))
+score(max(1, i32, 0.5))
 score(max(i))
-score(max(i, 1))
+score(max(i, i32))
 score(min(1))
-score(min(1, i64))
 score(min(i))
+score(min(i, i32))
+score(ok ? 1 : "bar")
+score(ok ? 1 : list)
+score(reduce(array, #))
+score(reduce(array, i))
+score(reduce(list, 1))
+score(reduce(list, i))
 score(score(1))
-score(score(1, 1))
 score(score(i))
-score(score(i32 % 1))
-score(true ? 1 : true)
-score(true ? i : i64)
+score(score(i32 + i))
+score(sum(array))
 sort(1 .. 1)
-sort(1 .. i64)
-sort([0.5])
-sort([1])
-sort([i32])
+sort(1 .. i)
+sort([add])
+sort([greet])
+sort([half])
 sort([i64])
-sort([nil])
+sort([list])
 sort(array)
-sort(array) != list
-sort(false ? i64 : array)
-sort(filter(array, false))
-sort(filter(array, true))
-sort(filter(list, false))
-sort(i .. 1)
+sort(array) == array
+sort(false ? greet : array)
+sort(groupBy(list, #)?.foo)
+sort(groupBy(list, i32).half)
+sort(i .. i32)
 sort(i .. i64)
 sort(i32 .. 1)
-sort(i32 .. i32)
+sort(i64 .. 1)
 sort(map(array, "bar"))
 sort(map(array, "foo"))
 sort(map(array, #))
 sort(map(array, 1))
-sort(map(array, i32))
-sort(map(list, "foo")) != list
-sort(map(list, i))
-sort(sort(array))
-string(!(i <= f32))
+sort(map(array, f64))
+sort(map(array, i))
+sort(map(array, i64))
+sort(reduce(array, array))
+sortBy(array, string(true))
+string(!!false)
 string(!false)
 string(!ok)
 string(!true)
-string("bar" != "bar")
-string("bar" < "bar")
+string("bar" != nil)
+string("bar" <= "bar")
 string("bar" == "bar")
-string("bar" > "bar")
-string("bar" contains "foo")
-string("bar" endsWith "bar")
+string("bar" > "foo")
+string("bar" >= "bar")
 string("bar" not endsWith "bar")
-string("bar" not matches "foo")
+string("bar" not matches "bar")
 string("bar" not startsWith "foo")
-string("bar" startsWith "bar")
-string("bar") >= type(score)
-string("bar") endsWith "foo" + "foo"
-string("bar") in foo
+string("bar" startsWith "foo")
+string("bar") > type(i64)
+string("bar") >= toJSON("bar")
 string("foo" != nil)
-string("foo" <= "foo")
-string("foo" >= "bar")
-string("foo" matches "foo")
-string("foo" not endsWith "foo")
+string("foo" == "foo")
+string("foo" == nil)
+string("foo" > "bar")
+string("foo" in foo)
+string("foo" matches "bar")
+string("foo" not contains "bar")
+string("foo" not contains "foo")
 string("foo" not in foo)
-string("foo" not matches "foo")
-string("foo" startsWith "bar")
-string(-(0.5 + f64))
+string(--i)
 string(-0.5)
 string(-1)
 string(-f32)
@@ -12770,292 +16687,251 @@ string(-i)
 string(-i32)
 string(-i64)
 string(0.5 != 0.5)
-string(0.5 != 1)
-string(0.5 != f32)
 string(0.5 != f64)
 string(0.5 != i)
-string(0.5 != nil)
+string(0.5 != i32)
 string(0.5 * 0.5)
-string(0.5 * f32)
 string(0.5 * i)
 string(0.5 * i32)
-string(0.5 ** 0.5)
-string(0.5 ** 1)
+string(0.5 ** f32)
 string(0.5 ** i32)
-string(0.5 ** i64)
-string(0.5 + 0.5)
-string(0.5 + 1)
-string(0.5 + f32)
 string(0.5 + f64)
+string(0.5 + i)
 string(0.5 + i64)
-string(0.5 - 0.5)
-string(0.5 - 1)
+string(0.5 - f32)
+string(0.5 - f64)
 string(0.5 / 0.5)
-string(0.5 / f64)
+string(0.5 / 1)
+string(0.5 / f32)
 string(0.5 / i)
+string(0.5 < 0.5)
 string(0.5 < 1)
-string(0.5 < f32)
-string(0.5 < i)
-string(0.5 < i32)
+string(0.5 < i64)
+string(0.5 <= 0.5)
 string(0.5 <= f64)
 string(0.5 <= i)
-string(0.5 <= i64)
+string(0.5 <= i32)
 string(0.5 == 0.5)
 string(0.5 == 1)
-string(0.5 == f32)
-string(0.5 == f64)
-string(0.5 == i)
-string(0.5 == i32)
 string(0.5 == i64)
 string(0.5 == nil)
 string(0.5 > 0.5)
 string(0.5 > 1)
+string(0.5 > i)
 string(0.5 > i64)
 string(0.5 >= 0.5)
 string(0.5 >= 1)
 string(0.5 >= f32)
-string(0.5 >= f64)
-string(0.5 >= i)
 string(0.5 >= i32)
-string(0.5 ^ 0.5)
-string(0.5 ^ 1)
+string(0.5 >= i64)
 string(0.5 ^ f32)
 string(0.5 ^ i)
 string(0.5 ^ i32)
-string(0.5) not endsWith type(1)
+string(0.5 ^ i64)
+string(0.5 in array)
+string(0.5 not in array)
+string(1 != 0.5)
 string(1 != 1)
-string(1 != f32)
-string(1 != f64)
 string(1 != i)
-string(1 != i32)
+string(1 != i64)
 string(1 != nil)
 string(1 % 1)
 string(1 % i)
 string(1 % i32)
-string(1 % i64)
-string(1 * 1)
-string(1 * i)
-string(1 * i64)
+string(1 * 0.5)
+string(1 * f32)
+string(1 * f64)
 string(1 ** 0.5)
 string(1 ** 1)
-string(1 ** f64)
 string(1 ** i)
-string(1 ** i32)
+string(1 ** i64)
 string(1 + 0.5)
-string(1 + f32)
+string(1 + 1)
 string(1 + f64)
-string(1 + i64)
+string(1 - 0.5)
 string(1 - f32)
-string(1 - i)
+string(1 - i32)
 string(1 - i64)
 string(1 .. 1)
-string(1 .. i)
 string(1 .. i32)
+string(1 .. i64)
 string(1 / 0.5)
-string(1 / 1)
-string(1 / f32)
+string(1 / f64)
 string(1 / i)
-string(1 < i)
-string(1 < i32)
-string(1 < i64)
-string(1 <= 0.5)
+string(1 / i32)
+string(1 / i64)
+string(1 < 0.5)
 string(1 <= 1)
 string(1 <= f32)
-string(1 <= f64)
+string(1 <= i)
 string(1 <= i32)
-string(1 == 0.5)
+string(1 <= i64)
 string(1 == 1)
-string(1 == f64)
-string(1 == i)
-string(1 == i64)
-string(1 == nil)
+string(1 == f32)
+string(1 == i32)
+string(1 > 0.5)
 string(1 > 1)
-string(1 > f32)
-string(1 >= 0.5)
-string(1 >= 1)
+string(1 > i64)
 string(1 >= f32)
-string(1 >= f64)
 string(1 >= i)
-string(1 >= i32)
-string(1 >= i64)
+string(1 ^ 0.5)
 string(1 ^ 1)
 string(1 ^ f32)
 string(1 ^ f64)
-string(1 ^ i)
-string(1 ^ i32)
 string(1 ^ i64)
-string(1 in array)
 string(1 not in array)
-string(1)[i64:i64]
-string([0.5, f32])
-string([add])
-string([f32])
-string([greet])
-string([i32, half])
-string([i32])
-string([i])
-string([ok])
+string([0.5])
+string([div])
+string([f64])
+string([list])
 string([score])
+string([true])
 string(abs(0.5))
 string(abs(1))
 string(abs(f32))
-string(abs(f64))
-string(abs(half(0.5)))
 string(abs(i))
-string(abs(i64))
+string(abs(i32))
 string(add != add)
-string(add != half)
-string(add != nil)
+string(add != div)
 string(add != score)
+string(add == div)
 string(add == greet)
+string(add == nil)
+string(add == score)
 string(add)
-string(add) contains type(list)
-string(add) not in foo
-string(all(array, false))
+string(add) in foo ? i64 : i32
+string(add) not endsWith foo.Bar
+string(all(array, ok))
 string(all(array, true))
-string(any(array, false))
-string(any(list, true))
+string(any(array, ok))
+string(any(list, false))
+string(any(list, ok))
 string(array != array)
-string(array == nil)
+string(array != nil)
 string(array)
-string(array) not in foo
-string(array[1:i])
-string(array[1])
-string(array[i64])
-string(count(array, # <= #))
-string(count(array, ok))
+string(array[i32])
+string(bitnot(1))
+string(bitnot(i32))
+string(bitnot(i64))
+string(ceil(0.5))
+string(ceil(1))
+string(ceil(f32))
+string(ceil(f64))
+string(ceil(i))
+string(ceil(i64))
+string(div != div)
 string(div != greet)
 string(div != nil)
-string(div == nil)
-string(div == score)
+string(div != score)
+string(div == add)
+string(div == div)
+string(div == greet)
 string(div)
 string(f32 != 0.5)
-string(f32 != 1)
-string(f32 != f32)
 string(f32 != f64)
+string(f32 != i)
 string(f32 != nil)
 string(f32 * 0.5)
+string(f32 * 1)
 string(f32 * f64)
 string(f32 * i)
 string(f32 * i32)
 string(f32 ** 1)
-string(f32 ** i64)
-string(f32 + 1)
+string(f32 ** f64)
 string(f32 + f32)
-string(f32 - i)
-string(f32 / 1)
-string(f32 / i)
+string(f32 + f64)
+string(f32 + i32)
+string(f32 + i64)
+string(f32 - 0.5)
+string(f32 - 1)
+string(f32 - i64)
+string(f32 / 0.5)
+string(f32 / f64)
 string(f32 / i64)
-string(f32 < 0.5)
-string(f32 < f64)
-string(f32 < i32)
-string(f32 <= 0.5)
-string(f32 <= 1)
-string(f32 <= f32)
+string(f32 < f32)
 string(f32 <= i)
 string(f32 <= i32)
 string(f32 == 0.5)
-string(f32 == 1)
-string(f32 == i64)
-string(f32 == nil)
-string(f32 > 1)
-string(f32 > f32)
+string(f32 == i)
+string(f32 > 0.5)
 string(f32 > f64)
-string(f32 > i)
-string(f32 > i32)
-string(f32 >= 0.5)
-string(f32 >= f32)
-string(f32 >= f64)
-string(f32 >= i32)
-string(f32 ^ 1)
-string(f32 ^ f32)
-string(f32 ^ f64)
-string(f32 ^ i)
-string(f32 ^ i64)
 string(f32)
-string(f32) matches trim("bar")
+string(f32) in foo
 string(f64 != 1)
-string(f64 != f32)
+string(f64 != i)
+string(f64 != nil)
 string(f64 * 0.5)
-string(f64 * 1)
-string(f64 * f32)
-string(f64 * f64)
 string(f64 * i)
+string(f64 * i32)
+string(f64 * i64)
 string(f64 ** 0.5)
-string(f64 ** 1)
 string(f64 ** f64)
-string(f64 ** i32)
+string(f64 ** i)
 string(f64 + 0.5)
 string(f64 + 1)
 string(f64 + f32)
-string(f64 + i)
-string(f64 + i32)
-string(f64 + i64)
 string(f64 - 0.5)
-string(f64 - f64)
-string(f64 - i32)
+string(f64 - 1)
+string(f64 - i)
 string(f64 / 0.5)
-string(f64 / f64)
-string(f64 / i64)
-string(f64 < 1)
-string(f64 < f64)
-string(f64 < i32)
+string(f64 < f32)
+string(f64 < i)
+string(f64 <= 1)
+string(f64 <= f32)
 string(f64 <= f64)
-string(f64 <= i)
-string(f64 == 0.5)
 string(f64 == 1)
 string(f64 == f32)
-string(f64 == f64)
 string(f64 == i)
-string(f64 == i32)
 string(f64 == i64)
-string(f64 > 0.5)
 string(f64 > 1)
-string(f64 > f32)
-string(f64 > f64)
-string(f64 > i64)
-string(f64 >= 1)
 string(f64 >= f32)
 string(f64 >= i)
-string(f64 >= i64)
 string(f64 ^ 0.5)
+string(f64 ^ f32)
 string(f64 ^ i)
-string(f64 ^ i32)
-string(f64 ^ i64)
+string(f64 in array)
+string(f64 not in array)
 string(f64)
-string(false && false)
-string(false ? 0.5 : i32)
-string(false ? 1 : "bar")
-string(false ? 1 : f32)
-string(false ? 1 : score)
-string(false ? div : "foo")
-string(false ? f32 : foo)
-string(false and true)
-string(false) <= foo.Bar
-string(false) > string(add)
-string(filter(list, ok))
+string(false != nil)
+string(false != ok)
+string(false != true)
+string(false ? array : 0.5)
+string(false ? f64 : i32)
+string(false ? false : i)
+string(false ? greet : f64)
+string(false ? half : "bar")
+string(false ? half : i)
+string(false ? i : i)
+string(false ? nil : nil)
+string(false and ok)
+string(false) endsWith toBase64("foo")
+string(filter(array, false))
+string(filter(array, ok))
+string(filter(array, true))
+string(filter(list, false))
 string(find(array, ok))
+string(find(array, true))
+string(find(list, ok))
 string(findIndex(array, true))
-string(findIndex(list, ok))
-string(findLast(array, # >= #))
 string(findLast(array, false))
 string(findLast(array, ok))
-string(findLast(list, ok))
-string(findLastIndex(array, not false))
+string(findLast(array, true))
 string(findLastIndex(array, ok))
-string(findLastIndex(array, true))
-string(findLastIndex(list, false))
-string(findLastIndex(list, ok))
-string(findLastIndex(list, true))
 string(first(array))
 string(first(list))
 string(float(0.5))
 string(float(1))
-string(float(f32))
 string(float(f64))
 string(float(i))
 string(float(i64))
-string(foo != nil)
+string(floor(0.5))
+string(floor(f32))
+string(floor(f64))
+string(floor(i))
+string(floor(i32))
+string(floor(i64))
+string(foo == foo)
+string(foo == nil)
 string(foo not in list)
 string(foo)
 string(foo.Bar)
@@ -13066,367 +16942,338 @@ string(foo?.Bar)
 string(foo?.Qux)
 string(foo?.String())
 string(foo?.String)
-string(get(array, 1))
 string(get(array, i))
-string(get(list, i))
+string(get(array, i64))
+string(get(list, 1))
+string(get(list, i32))
 string(get(list, i64))
 string(greet != add)
-string(greet != greet)
 string(greet != nil)
-string(greet != score)
-string(greet == add)
 string(greet == greet)
-string(greet == half)
 string(greet == nil)
 string(greet == score)
 string(greet("bar"))
 string(greet("foo"))
 string(greet)
-string(greet)[i64:i]
-string(half != add)
-string(half != div)
-string(half != half)
-string(half == greet)
+string(greet) == nil ? 0.5 : i
+string(groupBy(array, #))
+string(groupBy(array, 1))
+string(groupBy(array, f32))
+string(groupBy(array, false))
+string(groupBy(array, i32))
+string(groupBy(list, #))
+string(groupBy(list, 0.5))
+string(groupBy(list, 1))
+string(groupBy(list, f64))
+string(groupBy(list, false))
+string(groupBy(list, i))
+string(half != nil)
+string(half != score)
 string(half == nil)
-string(half == score)
-string(half(-1))
+string(half == sum(array))
 string(half(0.5))
+string(half(1))
 string(half(f64))
 string(half)
-string(half) > toJSON(nil)
-string(half) not endsWith type("foo")
-string(i != 0.5)
-string(i != f32)
-string(i != f64)
+string(i != 1)
+string(i != i64)
 string(i % 1)
 string(i % i32)
-string(i * i32)
-string(i * i64)
-string(i ** 1)
+string(i % i64)
+string(i * 1)
+string(i * f64)
 string(i ** f32)
-string(i + 1)
+string(i ** f64)
+string(i ** i64)
+string(i + 0.5)
 string(i + i)
-string(i + i32)
-string(i + i64)
 string(i - f32)
-string(i - i64)
 string(i .. 1)
 string(i .. i)
-string(i .. i64)
+string(i .. i32)
 string(i / 1)
 string(i / f32)
-string(i / i)
+string(i / f64)
 string(i / i32)
 string(i / i64)
+string(i < 0.5)
 string(i < 1)
-string(i < f32)
 string(i < i32)
-string(i <= 0.5)
-string(i <= 1)
-string(i == 0.5)
-string(i == f32)
-string(i == i32)
+string(i <= f32)
+string(i <= i)
+string(i == 1)
+string(i == i)
 string(i > 0.5)
 string(i > 1)
-string(i > f64)
-string(i > i64)
-string(i >= 1)
-string(i >= f64)
-string(i ^ 0.5)
+string(i > f32)
+string(i >= 0.5)
+string(i >= i64)
 string(i ^ 1)
+string(i ^ f32)
 string(i ^ i)
-string(i in array)
-string(i not in array)
+string(i ^ i64)
 string(i)
+string(i) in foo
+string(i32 != 0.5)
+string(i32 != 1)
 string(i32 != f64)
-string(i32 != i)
+string(i32 != i32)
 string(i32 != nil)
-string(i32 * 0.5)
+string(i32 % 1)
+string(i32 % i)
+string(i32 % i64)
 string(i32 * 1)
 string(i32 * f32)
 string(i32 * f64)
-string(i32 * i64)
+string(i32 * i)
 string(i32 ** 0.5)
 string(i32 ** f64)
-string(i32 ** i)
-string(i32 + f64)
-string(i32 + i32)
+string(i32 + 0.5)
+string(i32 - 0.5)
+string(i32 - 1)
 string(i32 - f32)
 string(i32 - f64)
+string(i32 - i32)
+string(i32 - i64)
 string(i32 .. 1)
-string(i32 .. i32)
-string(i32 .. i64)
+string(i32 .. i)
 string(i32 / 0.5)
-string(i32 / i64)
-string(i32 < 0.5)
-string(i32 < f32)
-string(i32 < i)
-string(i32 < i32)
+string(i32 < 1)
+string(i32 < f64)
 string(i32 < i64)
-string(i32 <= f64)
-string(i32 <= i64)
-string(i32 == 1)
 string(i32 == f32)
-string(i32 == f64)
-string(i32 == i)
+string(i32 == i64)
 string(i32 == nil)
 string(i32 > 1)
-string(i32 > f64)
+string(i32 > i)
 string(i32 >= 0.5)
 string(i32 >= 1)
-string(i32 >= f64)
 string(i32 >= i)
-string(i32 >= i64)
-string(i32 ^ 1)
+string(i32 ^ f32)
 string(i32 ^ f64)
 string(i32 ^ i32)
-string(i32 ^ i64)
 string(i32 in array)
 string(i32 not in array)
 string(i32)
-string(i32) == type("bar")
-string(i64 != 0.5)
+string(i32) not startsWith trimSuffix("foo")
 string(i64 != 1)
 string(i64 != i)
 string(i64 != i32)
 string(i64 != i64)
-string(i64 != nil)
-string(i64 % 1)
-string(i64 % i64)
+string(i64 % i32)
 string(i64 * 1)
 string(i64 * f32)
-string(i64 * i32)
-string(i64 * i64)
+string(i64 * i)
 string(i64 ** 0.5)
-string(i64 ** f32)
-string(i64 ** i)
-string(i64 ** i32)
-string(i64 + 0.5)
-string(i64 + f32)
-string(i64 + f64)
-string(i64 + i)
-string(i64 + i32)
-string(i64 - f32)
+string(i64 + i64)
 string(i64 - i)
-string(i64 / 0.5)
-string(i64 / 1)
-string(i64 / f32)
+string(i64 - i32)
+string(i64 - i64)
+string(i64 .. 1)
+string(i64 .. i)
+string(i64 .. i32)
 string(i64 / f64)
 string(i64 / i)
 string(i64 / i64)
-string(i64 < 1)
-string(i64 <= 0.5)
-string(i64 <= f32)
-string(i64 <= i)
-string(i64 <= i32)
+string(i64 < 0.5)
+string(i64 < i)
 string(i64 <= i64)
-string(i64 == 1)
+string(i64 == 0.5)
 string(i64 == i)
-string(i64 == i32)
-string(i64 == nil)
-string(i64 > 1)
-string(i64 > f32)
-string(i64 > f64)
-string(i64 > i)
-string(i64 > i32)
+string(i64 > 0.5)
 string(i64 > i64)
-string(i64 >= f64)
-string(i64 >= i64)
+string(i64 >= 0.5)
+string(i64 >= 1)
 string(i64 ^ 0.5)
 string(i64 ^ f64)
-string(i64 ^ i)
 string(i64 in array)
 string(i64)
-string(i64) >= foo.Bar
+string(i64) matches greet("bar")
 string(i64) not in foo
 string(int(0.5))
 string(int(1))
-string(int(f32 - i))
-string(int(f32))
-string(int(f64))
-string(int(i))
 string(int(i32))
 string(int(i64))
 string(last(array))
-string(last(list))
+string(last(list).String())
+string(len("bar"))
 string(len(array))
 string(len(list))
-string(len(string("foo")))
+string(list != nil)
 string(list == array)
 string(list == list)
 string(list == nil)
 string(list)
-string(list) != toJSON(i64)
 string(list[1])
+string(list[i32])
 string(list[i64])
-string(list[i64].String)
-string(lower("bar"))
-string(lower("foo"))
-string(map(array, "bar"))
+string(list[i])
 string(map(array, #))
 string(map(array, 0.5))
-string(map(array, 1))
-string(map(array, array))
+string(map(array, add))
 string(map(array, div))
-string(map(array, greet))
 string(map(array, i))
 string(map(array, i32))
-string(map(array, ok))
 string(map(array, true))
 string(map(list, "bar"))
 string(map(list, "foo"))
 string(map(list, #))
 string(map(list, 0.5))
 string(map(list, 1))
-string(map(list, add))
-string(map(list, f32))
-string(map(list, f64))
-string(map(list, false))
-string(map(list, greet))
+string(map(list, array))
+string(map(list, half))
+string(map(list, i32))
 string(map(list, i64))
-string(map(list, list))
 string(max(0.5))
+string(max(0.5, f32))
 string(max(1))
-string(max(1, 0.5))
-string(max(1, f32))
 string(max(f32))
 string(max(f64))
 string(max(i))
-string(max(i32))
-string(max(i32, 1, i64))
 string(max(i64))
+string(mean(array))
 string(min(0.5))
-string(min(0.5, f64, f32))
-string(min(1))
 string(min(f32))
-string(min(f64))
 string(min(i))
 string(min(i32))
-string(min(i32, i64))
 string(min(i64))
-string(nil != "foo")
-string(nil != 0.5)
-string(nil != 1)
-string(nil != array)
+string(nil != "bar")
 string(nil != div)
-string(nil != f64)
 string(nil != false)
 string(nil != greet)
+string(nil != half)
 string(nil != i)
-string(nil != i64)
-string(nil != nil)
-string(nil != score)
-string(nil == "foo")
+string(nil != ok)
+string(nil == "bar")
+string(nil == 0.5)
 string(nil == 1)
-string(nil == add)
-string(nil == f32)
-string(nil == f64)
-string(nil == false)
+string(nil == div)
+string(nil == foo)
 string(nil == list)
+string(nil == nil)
 string(nil == ok)
-string(nil == true)
-string(nil in array)
+string(nil == score)
 string(nil in list)
-string(nil) > string(1)
-string(nil) >= string(greet)
-string(nil) in foo
+string(nil not in list)
+string(nil) <= list[i].Bar
 string(none(array, ok))
-string(none(list, true))
+string(none(list, false))
+string(none(list, ok))
+string(not !false)
+string(not (i64 == 0.5))
 string(not false)
 string(not ok)
 string(not true)
-string(ok && false)
-string(ok && ok)
-string(ok == nil)
-string(ok == true)
-string(ok ? 0.5 : "foo")
+string(ok != nil)
+string(ok != true)
+string(ok ? 0.5 : nil)
 string(ok ? 0.5 : true)
-string(ok ? true : i32)
+string(ok ? 1 : array)
+string(ok ? 1 : f32)
+string(ok ? array : add)
+string(ok ? div : array)
+string(ok ? half : score)
+string(ok ? i : 1)
+string(ok ? nil : half)
+string(ok ? nil : list)
 string(ok or false)
-string(ok or ok)
-string(ok || ok)
+string(ok || false)
 string(ok)
-string(one(array, false))
-string(one(array, ok))
 string(one(array, true))
 string(one(list, true))
+string(reduce(array, #))
+string(reduce(array, 0.5))
+string(reduce(array, 1))
+string(reduce(array, f64))
+string(reduce(array, greet))
+string(reduce(array, half))
+string(reduce(array, i64))
+string(reduce(array, list))
+string(reduce(array, score))
+string(reduce(list, "bar"))
+string(reduce(list, #))
+string(reduce(list, 1))
+string(reduce(list, add))
+string(reduce(list, div))
+string(reduce(list, foo))
+string(reduce(list, i))
+string(reduce(list, i64))
+string(reduce(list, list))
+string(round(0.5))
+string(round(1))
+string(round(ceil(i32)))
+string(round(f64))
+string(round(i64))
+string(score != div)
+string(score != greet)
+string(score != half)
 string(score != nil)
-string(score == div)
+string(score == greet)
 string(score == nil)
+string(score(1 % 1))
 string(score(1))
 string(score(i))
-string(score(score(i)))
 string(score)
-string(score) < string(ok)
-string(score) not in foo
 string(sort(array))
+string(sortBy(array, "foo"))
 string(string("bar"))
 string(string("foo"))
 string(string(0.5))
 string(string(1))
-string(string(add))
 string(string(array))
 string(string(div))
+string(string(f32))
 string(string(f64))
 string(string(false))
-string(string(foo))
 string(string(greet))
 string(string(half))
 string(string(i))
-string(string(i32))
 string(string(i64))
-string(string(list))
 string(string(nil))
 string(string(ok))
 string(string(score))
-string(string(true))
+string(sum(array))
+string(toBase64("foo"))
 string(toJSON("bar"))
-string(toJSON("foo"))
 string(toJSON(0.5))
 string(toJSON(1))
 string(toJSON(array))
 string(toJSON(f32))
 string(toJSON(f64))
 string(toJSON(false))
-string(toJSON(foo))
 string(toJSON(i))
+string(toJSON(i32))
 string(toJSON(i64))
 string(toJSON(list))
 string(toJSON(nil))
 string(toJSON(ok))
 string(toJSON(true))
-string(trim("foo"))
-string(trim(toJSON(0.5)))
-string(trimPrefix("bar"))
+string(trim("bar"))
+string(trim(type(nil)))
 string(trimPrefix("foo"))
-string(trimPrefix(type(f32)))
-string(trimSuffix("bar"))
-string(true != true)
+string(trimSuffix("foo"))
+string(true != false)
+string(true && ok)
 string(true == nil)
-string(true == ok)
-string(true ? 1 : true)
-string(true ? array : f32)
-string(true ? div : i64)
-string(true ? i32 : "foo")
-string(true ? i32 : greet)
-string(true ? score : 0.5)
-string(true ? true : i32)
+string(true ? 0.5 : true)
+string(true ? f64 : score)
+string(true ? false : nil)
+string(true ? greet : i)
+string(true ? list : ok)
 string(true and false)
-string(true or true)
-string(true || false)
-string(true) endsWith string(i64)
-string(true) not in foo
+string(true or false)
+string(true or ok)
+string(true || true)
+string(type("bar"))
 string(type("foo"))
+string(type(-i64))
 string(type(0.5))
-string(type(1 < f64))
 string(type(1))
-string(type(add))
 string(type(array))
-string(type(div))
 string(type(f32))
 string(type(f64))
-string(type(false))
 string(type(foo))
+string(type(greet))
 string(type(half))
 string(type(i))
 string(type(i32))
@@ -13434,116 +17281,136 @@ string(type(i64))
 string(type(list))
 string(type(nil))
 string(type(ok))
-string(type(score(1)))
 string(type(score))
-string(type(true))
-string(type(type(false)))
-string(upper("bar"))
 string(upper("foo"))
-string({"bar": 0.5})
-string({"bar": i32, "foo": i64})
-string({"foo": f64})
-string({"foo": true})
+string({"bar": "foo", "foo": half})
+string({"bar": f32, "foo": i32})
+string({"bar": f32})
+string({"bar": true})
+string({"foo": add})
+string({"foo": array, "foo": list})
+sum(1 .. 1)
+sum(1 .. i)
+sum(1 .. i32)
+sum(1 .. i64)
+sum([0.5])
+sum([f32])
+sum(array)
+sum(array) != f32
+sum(array) != half
+sum(array) != ok
+sum(array) % i
+sum(array) % i64
+sum(array) - f32
+sum(array) / -f64
+sum(array) < i
+sum(array) == div
+sum(array) == i64 - i
+sum(array) ^ f64
+sum(array) not in array
+sum(array) not in list
+sum(filter(array, ok))
+sum(groupBy(array, i32).String)
+sum(groupBy(list, #)?.greet)
+sum(i32 .. 1)
+sum(i64 .. i32)
+sum(i64 .. i64)
+sum(list[i:1])
+sum(map(array, #))
+sum(map(array, f32))
+sum(map(list, 0.5))
+sum(map(list, f32))
+sum(map(list, i32))
+sum(ok ? array : i64)
+sum(reduce(array, array))
+sum(reduce(list, array))
+sum(sort(array))
+sum(true ? array : i32)
+take(array, i)
+take(array, i32)
+take(array, i64)
+take(list, i)
+take(list, i32)
+take(list, i64)
+take(map(array, #), i)
+toBase64("bar" + "bar")
+toBase64("bar" + "foo")
+toBase64("bar") startsWith type(score)
+toBase64("foo" + "bar")
 toBase64(foo.Bar)
 toBase64(foo.String())
 toBase64(foo?.Bar)
 toBase64(foo?.String())
 toBase64(greet("bar"))
 toBase64(greet("foo"))
-toBase64(greet(string(array)))
 toBase64(lower("bar"))
 toBase64(lower("foo"))
-toBase64(lower(type(i32)))
-toBase64(ok ? "foo" : 1)
-toBase64(ok ? "foo" : foo)
-toBase64(string("bar"))
+toBase64(ok ? "bar" : f64)
+toBase64(reduce(list, "bar"))
 toBase64(string("foo"))
 toBase64(string(0.5))
 toBase64(string(1))
+toBase64(string(add))
 toBase64(string(array))
-toBase64(string(f32 <= i32))
 toBase64(string(f32))
 toBase64(string(f64))
-toBase64(string(false))
 toBase64(string(foo))
 toBase64(string(greet))
 toBase64(string(half))
 toBase64(string(i))
-toBase64(string(i32))
-toBase64(string(i64))
 toBase64(string(list))
-toBase64(string(nil))
 toBase64(string(ok))
-toBase64(string(score))
-toBase64(string(true))
 toBase64(toBase64("bar"))
-toBase64(toBase64("foo"))
 toBase64(toJSON("bar"))
-toBase64(toJSON("foo"))
 toBase64(toJSON(0.5))
 toBase64(toJSON(1))
-toBase64(toJSON(array))
 toBase64(toJSON(f32))
 toBase64(toJSON(f64))
-toBase64(toJSON(false))
 toBase64(toJSON(foo))
-toBase64(toJSON(i))
-toBase64(toJSON(i32))
 toBase64(toJSON(i64))
 toBase64(toJSON(list))
 toBase64(toJSON(nil))
 toBase64(toJSON(ok))
 toBase64(toJSON(true))
 toBase64(trim("bar"))
-toBase64(trim("foo"))
 toBase64(trimPrefix("foo"))
-toBase64(trimSuffix("bar"))
 toBase64(trimSuffix("foo"))
-toBase64(true ? "bar" : ok)
-toBase64(type("bar"))
-toBase64(type("foo"))
 toBase64(type(0.5))
 toBase64(type(1))
 toBase64(type(add))
-toBase64(type(array))
 toBase64(type(div))
 toBase64(type(f32))
 toBase64(type(f64))
 toBase64(type(false))
 toBase64(type(foo))
-toBase64(type(get(array, i)))
 toBase64(type(greet))
+toBase64(type(half))
 toBase64(type(i))
 toBase64(type(i32))
 toBase64(type(i64))
 toBase64(type(list))
-toBase64(type(ok))
-toBase64(type(true))
-toBase64(upper("bar"))
+toBase64(type(nil))
+toBase64(type(score))
 toBase64(upper("foo"))
-toBase64(upper(foo.Bar))
 toJSON(!false)
 toJSON(!ok)
 toJSON(!true)
-toJSON("bar" != "foo")
-toJSON("bar" + "bar")
-toJSON("bar" + "foo")
-toJSON("bar" <= "foo")
-toJSON("bar" >= "foo")
-toJSON("bar" contains "bar")
-toJSON("bar" matches "bar")
+toJSON("bar" < "foo")
+toJSON("bar" >= "bar")
+toJSON("bar" endsWith "bar")
+toJSON("bar" matches "foo")
+toJSON("bar" not in foo)
 toJSON("bar" not matches "bar")
-toJSON("bar" not matches "foo")
+toJSON("bar" not startsWith "foo")
+toJSON("bar" startsWith "bar")
+toJSON("bar") not in foo
 toJSON("foo" != "bar")
-toJSON("foo" + "bar")
-toJSON("foo" <= "bar")
-toJSON("foo" == nil)
-toJSON("foo" contains "bar")
-toJSON("foo" matches "foo")
-toJSON("foo" not in foo)
-toJSON("foo" not matches "bar")
-toJSON("foo") > foo?.Bar
-toJSON("foo") not in foo
+toJSON("foo" != "foo")
+toJSON("foo" < "foo")
+toJSON("foo" == "bar")
+toJSON("foo" > "foo")
+toJSON("foo" >= "foo")
+toJSON("foo" startsWith "bar")
 toJSON(-0.5)
 toJSON(-1)
 toJSON(-f32)
@@ -13551,133 +17418,104 @@ toJSON(-f64)
 toJSON(-i)
 toJSON(-i32)
 toJSON(-i64)
-toJSON(0.5 != 0.5)
 toJSON(0.5 != 1)
-toJSON(0.5 != f32)
 toJSON(0.5 != f64)
-toJSON(0.5 != i)
-toJSON(0.5 != i32)
-toJSON(0.5 * 0.5)
+toJSON(0.5 != nil)
 toJSON(0.5 * i)
 toJSON(0.5 * i32)
+toJSON(0.5 * i64)
+toJSON(0.5 ** 0.5)
+toJSON(0.5 ** 1)
+toJSON(0.5 ** f32)
 toJSON(0.5 ** f64)
 toJSON(0.5 ** i)
-toJSON(0.5 ** i64)
+toJSON(0.5 ** i32)
 toJSON(0.5 + 0.5)
+toJSON(0.5 + 1)
 toJSON(0.5 + f32)
 toJSON(0.5 - 0.5)
 toJSON(0.5 - 1)
 toJSON(0.5 - f32)
 toJSON(0.5 - f64)
-toJSON(0.5 / 0.5)
+toJSON(0.5 - i)
+toJSON(0.5 - i32)
 toJSON(0.5 / 1)
 toJSON(0.5 / f32)
 toJSON(0.5 / f64)
-toJSON(0.5 / i)
 toJSON(0.5 / i32)
-toJSON(0.5 / i64)
-toJSON(0.5 < 0.5)
 toJSON(0.5 < 1)
 toJSON(0.5 < f32)
+toJSON(0.5 < f64)
 toJSON(0.5 < i)
+toJSON(0.5 <= 0.5)
 toJSON(0.5 <= 1)
 toJSON(0.5 <= f32)
-toJSON(0.5 <= f64)
-toJSON(0.5 <= i)
+toJSON(0.5 <= i64)
 toJSON(0.5 == 0.5)
-toJSON(0.5 == 1)
-toJSON(0.5 == f32)
+toJSON(0.5 == f64)
 toJSON(0.5 == i)
+toJSON(0.5 == i32)
 toJSON(0.5 == i64)
-toJSON(0.5 > 1)
-toJSON(0.5 > f32)
-toJSON(0.5 > f64)
-toJSON(0.5 > i32)
 toJSON(0.5 >= 0.5)
 toJSON(0.5 >= 1)
 toJSON(0.5 >= f32)
-toJSON(0.5 >= f64)
-toJSON(0.5 >= i)
-toJSON(0.5 >= i32)
-toJSON(0.5 >= i64)
-toJSON(0.5 ^ 0.5)
-toJSON(0.5 ^ 1)
 toJSON(0.5 ^ f32)
-toJSON(0.5 ^ f64)
-toJSON(0.5 ^ i)
 toJSON(0.5 ^ i32)
 toJSON(0.5 ^ i64)
-toJSON(0.5) contains "bar" ? "bar" : array
+toJSON(0.5) not in foo
 toJSON(1 != 0.5)
 toJSON(1 != f32)
 toJSON(1 != nil)
 toJSON(1 % 1)
+toJSON(1 % i)
 toJSON(1 % i32)
-toJSON(1 * 0.5)
-toJSON(1 * f32)
 toJSON(1 * f64)
 toJSON(1 * i32)
 toJSON(1 * i64)
 toJSON(1 ** 0.5)
 toJSON(1 ** 1)
-toJSON(1 ** f32)
-toJSON(1 ** f64)
-toJSON(1 ** i >= f64)
 toJSON(1 ** i32)
 toJSON(1 + 0.5)
-toJSON(1 + f32)
+toJSON(1 + 1)
 toJSON(1 + f64)
-toJSON(1 + i64)
-toJSON(1 - 0.5)
-toJSON(1 - 1)
-toJSON(1 - f32)
-toJSON(1 - f64)
+toJSON(1 + i)
+toJSON(1 + i32)
+toJSON(1 - i)
 toJSON(1 - i32)
-toJSON(1 .. 1)
-toJSON(1 .. i)
+toJSON(1 .. i32)
 toJSON(1 .. i64)
-toJSON(1 / 0.5)
 toJSON(1 / 1)
-toJSON(1 / f32)
-toJSON(1 / i32)
+toJSON(1 / f64)
+toJSON(1 / i64)
 toJSON(1 < 0.5)
 toJSON(1 < 1)
-toJSON(1 < f32)
 toJSON(1 < f64)
 toJSON(1 < i)
 toJSON(1 <= 0.5)
-toJSON(1 <= 1)
-toJSON(1 <= i)
-toJSON(1 <= i32)
-toJSON(1 <= i64)
+toJSON(1 <= f32)
+toJSON(1 <= f64)
 toJSON(1 == 0.5)
-toJSON(1 == f32)
+toJSON(1 == 1)
+toJSON(1 == f64)
 toJSON(1 == i)
 toJSON(1 == i32)
-toJSON(1 == i64)
 toJSON(1 == nil)
-toJSON(1 > 0.5)
-toJSON(1 > f64)
+toJSON(1 > f32)
 toJSON(1 > i)
-toJSON(1 > i32)
-toJSON(1 > i64)
-toJSON(1 >= 0.5)
 toJSON(1 >= 1)
 toJSON(1 >= f32)
 toJSON(1 >= i32)
-toJSON(1 ^ 0.5)
 toJSON(1 ^ 1)
 toJSON(1 ^ f32)
-toJSON(1 ^ f64)
 toJSON(1 ^ i32)
 toJSON(1 ^ i64)
-toJSON(1 in array)
-toJSON(1) == nil == true
-toJSON(1) in foo
-toJSON(1) not in foo
-toJSON(1) startsWith foo.String()
-toJSON([1])
-toJSON([i64])
+toJSON(1) > reduce(list, "bar")
+toJSON(1) not contains string(true)
+toJSON([f64])
+toJSON([false])
+toJSON([foo])
+toJSON([nil])
+toJSON([true])
 toJSON(abs(0.5))
 toJSON(abs(1))
 toJSON(abs(f32))
@@ -13685,143 +17523,96 @@ toJSON(abs(f64))
 toJSON(abs(i))
 toJSON(abs(i32))
 toJSON(abs(i64))
-toJSON(add != nil)
-toJSON(add != score)
-toJSON(add == div)
-toJSON(add == half)
-toJSON(add == nil)
+toJSON(add != greet)
+toJSON(add != half)
+toJSON(add == add)
 toJSON(add == score)
-toJSON(all(list, false))
-toJSON(all(list, ok))
-toJSON(all(list, true))
 toJSON(any(array, false))
-toJSON(any(array, true))
-toJSON(array != array)
-toJSON(array != nil)
+toJSON(array == array)
+toJSON(array == list)
+toJSON(array == nil)
 toJSON(array)
-toJSON(array) != toJSON(ok)
-toJSON(array) > "bar" != false
-toJSON(array) endsWith greet("foo")
-toJSON(array) endsWith string(i32)
-toJSON(array) in foo
-toJSON(array) not startsWith greet("foo")
-toJSON(array[1:1])
-toJSON(array[i32])
+toJSON(array[1:i64])
+toJSON(array[1])
 toJSON(array[i])
-toJSON(count(array, false))
+toJSON(bitnot(1))
+toJSON(bitnot(i))
+toJSON(bitnot(i32))
+toJSON(bitnot(i64))
+toJSON(bitshl(i, i32))
+toJSON(ceil(1))
+toJSON(ceil(f64))
+toJSON(ceil(i))
+toJSON(ceil(i32))
+toJSON(ceil(i64))
 toJSON(count(array, ok))
 toJSON(div != div)
-toJSON(div != greet)
 toJSON(div != score)
 toJSON(div == div)
-toJSON(div == half)
-toJSON(div == nil)
-toJSON(div == score)
-toJSON(f32 != 1)
-toJSON(f32 * 0.5)
-toJSON(f32 * 1)
+toJSON(f32 != 0.5)
+toJSON(f32 != 1 || ok)
+toJSON(f32 != f32)
+toJSON(f32 != i32)
 toJSON(f32 * f32)
-toJSON(f32 * f64)
-toJSON(f32 * i32)
-toJSON(f32 ** f32)
+toJSON(f32 ** 0.5)
+toJSON(f32 ** 1)
+toJSON(f32 ** f64)
 toJSON(f32 ** i32)
-toJSON(f32 ** i64)
-toJSON(f32 + 1)
-toJSON(f32 + i)
-toJSON(f32 + i32)
+toJSON(f32 + 0.5)
+toJSON(f32 + f32)
+toJSON(f32 - 0.5)
+toJSON(f32 - f32)
 toJSON(f32 - f64)
-toJSON(f32 - i32)
-toJSON(f32 / 0.5)
-toJSON(f32 / 1)
+toJSON(f32 - i64)
 toJSON(f32 < 0.5)
-toJSON(f32 < f32)
-toJSON(f32 < f64)
-toJSON(f32 <= f32)
-toJSON(f32 == 1)
+toJSON(f32 < i)
+toJSON(f32 < i64)
+toJSON(f32 <= 0.5)
+toJSON(f32 <= 1)
+toJSON(f32 <= i64)
 toJSON(f32 == f64)
 toJSON(f32 == i)
 toJSON(f32 == nil)
-toJSON(f32 > 0.5)
-toJSON(f32 > f64)
 toJSON(f32 > i)
-toJSON(f32 >= 1)
-toJSON(f32 >= f32)
-toJSON(f32 ^ 0.5)
-toJSON(f32 ^ 1)
-toJSON(f32 ^ f64)
-toJSON(f32 ^ i)
+toJSON(f32 > i32)
+toJSON(f32 >= 0.5)
 toJSON(f32 ^ i64)
 toJSON(f32)
-toJSON(f64 != 1)
+toJSON(f32) in foo
+toJSON(f64 != 0.5)
 toJSON(f64 != f32)
-toJSON(f64 != f64)
 toJSON(f64 != i)
-toJSON(f64 != i32 / i32)
 toJSON(f64 != i32)
 toJSON(f64 != nil)
-toJSON(f64 * 0.5)
+toJSON(f64 * 1)
 toJSON(f64 * f64)
-toJSON(f64 * i)
 toJSON(f64 * i64)
 toJSON(f64 ** 0.5)
 toJSON(f64 ** f32)
-toJSON(f64 ** i)
-toJSON(f64 ** i64)
-toJSON(f64 + 1)
+toJSON(f64 + 0.5)
 toJSON(f64 + f32)
-toJSON(f64 + i)
 toJSON(f64 + i32)
-toJSON(f64 - 1)
 toJSON(f64 - f64)
 toJSON(f64 - i)
-toJSON(f64 - i32)
-toJSON(f64 / 0.5)
-toJSON(f64 / f32)
-toJSON(f64 / i32)
-toJSON(f64 < 1)
-toJSON(f64 < f32)
-toJSON(f64 < i32)
-toJSON(f64 < i64)
+toJSON(f64 - i64)
+toJSON(f64 / 1)
+toJSON(f64 < f64)
 toJSON(f64 <= 0.5)
-toJSON(f64 <= 1)
-toJSON(f64 <= i32)
-toJSON(f64 == 1)
-toJSON(f64 == i64)
-toJSON(f64 == nil)
-toJSON(f64 > 1)
-toJSON(f64 > f64)
-toJSON(f64 >= 0.5)
-toJSON(f64 >= i64)
-toJSON(f64 ^ 1)
-toJSON(f64 ^ f64)
-toJSON(f64 ^ i)
+toJSON(f64 == f64)
+toJSON(f64 >= 1)
+toJSON(f64 >= f64)
+toJSON(f64 ^ f32)
 toJSON(f64)
-toJSON(false != nil)
-toJSON(false && false)
-toJSON(false == false)
-toJSON(false ? 0.5 : nil)
-toJSON(false ? 1 : f32)
-toJSON(false ? f32 : list)
-toJSON(false ? false : i32)
-toJSON(false ? greet : 1)
-toJSON(false ? greet : i32)
-toJSON(false ? nil : f64)
-toJSON(false and ok)
-toJSON(false and true)
-toJSON(filter(array, ok))
-toJSON(filter(list, false))
+toJSON(false != ok)
+toJSON(false ? 0.5 : "foo")
+toJSON(false ? add : f64)
+toJSON(false ? array : 1)
+toJSON(false ? false : foo)
+toJSON(false ? nil : ok)
+toJSON(false ? ok : i32)
 toJSON(filter(list, true))
-toJSON(find(array, false))
-toJSON(find(array, ok))
-toJSON(findIndex(array, ok))
-toJSON(findIndex(array, true))
-toJSON(findIndex(list, ok))
-toJSON(findIndex(list, true))
-toJSON(findLast(array, false))
-toJSON(findLast(list, true))
-toJSON(findLastIndex(array, true))
-toJSON(findLastIndex(list, false))
-toJSON(findLastIndex(list, ok))
+toJSON(find(list, ok))
+toJSON(findIndex(map(array, list), ok))
 toJSON(first(array))
 toJSON(first(list))
 toJSON(float(0.5))
@@ -13829,297 +17620,279 @@ toJSON(float(1))
 toJSON(float(f32))
 toJSON(float(f64))
 toJSON(float(i))
-toJSON(float(i32))
 toJSON(float(i64))
-toJSON(foo != foo)
+toJSON(floor(0.5))
+toJSON(floor(f64))
+toJSON(floor(i))
+toJSON(floor(i32))
 toJSON(foo != nil)
-toJSON(foo == foo)
-toJSON(foo == nil)
 toJSON(foo in list)
 toJSON(foo)
 toJSON(foo.Bar)
 toJSON(foo.String())
 toJSON(foo?.Bar)
 toJSON(foo?.String())
-toJSON(get(array, 1))
+toJSON(get(array, i32))
 toJSON(get(array, i64))
 toJSON(get(list, 1))
 toJSON(get(list, i))
+toJSON(get(list, i32))
 toJSON(get(list, i64))
-toJSON(greet != div)
-toJSON(greet != greet)
-toJSON(greet != half)
-toJSON(greet == add)
+toJSON(greet != nil)
+toJSON(greet != score)
 toJSON(greet == div)
 toJSON(greet == greet)
 toJSON(greet == half)
+toJSON(greet == nil)
+toJSON(greet == score)
 toJSON(greet("bar"))
 toJSON(greet("foo"))
-toJSON(half != greet)
-toJSON(half != nil)
-toJSON(half != score)
-toJSON(half == add)
-toJSON(half == div)
-toJSON(half == greet)
-toJSON(half == nil)
-toJSON(half == score)
+toJSON(groupBy(array, #)?.div)
+toJSON(groupBy(array, ok)?.foo)
+toJSON(groupBy(list, #)?.foo)
 toJSON(half(0.5))
+toJSON(half(1))
 toJSON(half(f64))
+toJSON(i != 0.5)
 toJSON(i != 1)
-toJSON(i != f32)
-toJSON(i != i)
-toJSON(i != i32)
-toJSON(i % 1)
-toJSON(i % i64)
+toJSON(i % i)
+toJSON(i % i32)
 toJSON(i * 0.5)
 toJSON(i * 1)
 toJSON(i * f32)
+toJSON(i * i)
 toJSON(i * i32)
-toJSON(i ** 0.5)
 toJSON(i ** f32)
-toJSON(i ** i32)
+toJSON(i ** i)
 toJSON(i + 0.5)
 toJSON(i + 1)
-toJSON(i + f32)
-toJSON(i + f64)
 toJSON(i + i)
 toJSON(i - 1)
-toJSON(i .. 1)
+toJSON(i - f32)
 toJSON(i .. i)
-toJSON(i / f32)
+toJSON(i .. i32)
+toJSON(i / i64)
+toJSON(i < f32)
+toJSON(i < f64)
+toJSON(i < i)
 toJSON(i < i32)
-toJSON(i < i64)
 toJSON(i <= 1)
 toJSON(i <= f32)
 toJSON(i <= f64)
 toJSON(i <= i)
 toJSON(i <= i32)
+toJSON(i <= i64)
+toJSON(i == 0.5)
+toJSON(i == 1)
 toJSON(i == i32)
-toJSON(i == i64)
 toJSON(i == nil)
 toJSON(i > 0.5)
-toJSON(i > 1)
-toJSON(i > f32)
-toJSON(i >= 0.5)
-toJSON(i >= 1)
-toJSON(i >= f32)
-toJSON(i >= i)
-toJSON(i ^ 1)
-toJSON(i ^ f64)
+toJSON(i > i)
+toJSON(i > i32)
+toJSON(i > i64)
+toJSON(i >= f64)
+toJSON(i >= i32)
+toJSON(i ^ i64)
+toJSON(i not in array)
 toJSON(i)
-toJSON(i) != string(1)
-toJSON(i32 != f32)
+toJSON(i) matches string("bar")
 toJSON(i32 != i)
+toJSON(i32 != i64)
 toJSON(i32 % 1)
-toJSON(i32 % i64)
+toJSON(i32 * 0.5)
 toJSON(i32 * i)
+toJSON(i32 * i32)
 toJSON(i32 * i64)
+toJSON(i32 ** f64)
 toJSON(i32 ** i64)
+toJSON(i32 + 0.5)
+toJSON(i32 + 1)
 toJSON(i32 + f64)
-toJSON(i32 + i)
-toJSON(i32 + i32)
-toJSON(i32 + i64)
-toJSON(i32 - 0.5)
-toJSON(i32 - 1)
-toJSON(i32 - f32)
-toJSON(i32 - f64)
-toJSON(i32 - i)
 toJSON(i32 .. i)
 toJSON(i32 .. i64)
 toJSON(i32 / 0.5)
 toJSON(i32 / f32)
-toJSON(i32 / i)
+toJSON(i32 / f64)
 toJSON(i32 / i64)
 toJSON(i32 < 0.5)
-toJSON(i32 < f32)
+toJSON(i32 < 1)
+toJSON(i32 < i)
+toJSON(i32 < i32)
 toJSON(i32 <= 0.5)
-toJSON(i32 <= i32)
-toJSON(i32 == 1)
-toJSON(i32 == f32)
-toJSON(i32 == i)
-toJSON(i32 == nil ? i32 : i32)
-toJSON(i32 == nil)
-toJSON(i32 > 0.5)
 toJSON(i32 > f64)
 toJSON(i32 > i)
-toJSON(i32 >= 0.5)
-toJSON(i32 >= 1)
-toJSON(i32 >= f32)
+toJSON(i32 > i32)
 toJSON(i32 >= f64)
-toJSON(i32 >= i)
-toJSON(i32 ^ 1)
+toJSON(i32 ^ 0.5)
+toJSON(i32 ^ f32)
 toJSON(i32 ^ f64)
-toJSON(i32 ^ i)
+toJSON(i32 ^ i32)
 toJSON(i32 in array)
 toJSON(i32 not in array)
 toJSON(i32)
-toJSON(i32) < string(i64)
-toJSON(i64 != 0.5)
+toJSON(i32) contains foo.Bar
 toJSON(i64 != 1)
-toJSON(i64 != f32)
 toJSON(i64 != i)
 toJSON(i64 != i32)
-toJSON(i64 != nil)
-toJSON(i64 % 1)
-toJSON(i64 % i)
 toJSON(i64 % i32)
-toJSON(i64 % i64)
-toJSON(i64 * i)
-toJSON(i64 + 0.5)
-toJSON(i64 + i)
-toJSON(i64 + i64)
-toJSON(i64 - 0.5)
-toJSON(i64 - 1)
-toJSON(i64 - i64)
+toJSON(i64 * 0.5)
+toJSON(i64 * f64)
+toJSON(i64 ** f64)
+toJSON(i64 ** i)
+toJSON(i64 ** i32)
+toJSON(i64 + 1)
+toJSON(i64 - i32)
 toJSON(i64 .. 1)
-toJSON(i64 / 1)
-toJSON(i64 / f32)
+toJSON(i64 .. i32)
+toJSON(i64 / f64)
 toJSON(i64 / i)
 toJSON(i64 / i64)
-toJSON(i64 < 0.5)
+toJSON(i64 < 1)
+toJSON(i64 < f64)
 toJSON(i64 < i32)
-toJSON(i64 <= 0.5)
 toJSON(i64 <= 1)
-toJSON(i64 <= f32)
 toJSON(i64 <= i64)
 toJSON(i64 == 0.5)
-toJSON(i64 == 1)
-toJSON(i64 == i32)
-toJSON(i64 == nil)
-toJSON(i64 > f32)
+toJSON(i64 > 0.5)
+toJSON(i64 > 1)
 toJSON(i64 > i)
-toJSON(i64 >= 0.5)
+toJSON(i64 > i32)
+toJSON(i64 > i64)
 toJSON(i64 >= 1)
+toJSON(i64 >= i)
 toJSON(i64 >= i64)
-toJSON(i64 ^ i)
+toJSON(i64 ^ 0.5)
+toJSON(i64 ^ f32)
+toJSON(i64 ^ i32)
+toJSON(i64 in array)
 toJSON(i64)
 toJSON(int(0.5))
 toJSON(int(1))
-toJSON(int(f32))
-toJSON(int(f64))
 toJSON(int(i))
 toJSON(int(i32))
-toJSON(last(list))
+toJSON(int(i64))
 toJSON(len("bar"))
-toJSON(len("foo"))
 toJSON(len(array))
+toJSON(len(greet("foo")))
 toJSON(len(list))
-toJSON(list != list)
-toJSON(list == nil)
+toJSON(list != array)
+toJSON(list != nil)
+toJSON(list == array)
+toJSON(list == list)
 toJSON(list)
-toJSON(list) <= foo?.Bar
 toJSON(list[1])
-toJSON(list[i32])
-toJSON(list[i64:1])
-toJSON(list[i64])
-toJSON(list[i])
 toJSON(lower("bar"))
-toJSON(lower("foo"))
 toJSON(map(array, #))
-toJSON(map(array, 0.5))
-toJSON(map(array, 1))
+toJSON(map(array, -#))
+toJSON(map(array, array))
 toJSON(map(array, false))
 toJSON(map(array, i))
-toJSON(map(array, i32))
+toJSON(map(array, i64))
 toJSON(map(array, list))
-toJSON(map(array, true))
-toJSON(map(list, "foo"))
 toJSON(map(list, #))
+toJSON(map(list, 0.5))
 toJSON(map(list, 1))
-toJSON(map(list, f32))
-toJSON(map(list, f64))
+toJSON(map(list, foo))
+toJSON(map(list, i32))
+toJSON(map(list, i64))
 toJSON(map(list, list))
-toJSON(max(0.5))
+toJSON(map(list, ok))
 toJSON(max(1))
 toJSON(max(f32))
 toJSON(max(f64))
-toJSON(max(i))
 toJSON(max(i32))
-toJSON(max(i64))
+toJSON(mean(array))
+toJSON(median(array))
 toJSON(min(0.5))
-toJSON(min(0.5, f32))
 toJSON(min(1))
-toJSON(min(1, 1))
 toJSON(min(f32))
 toJSON(min(f64))
+toJSON(min(f64, f64))
 toJSON(min(i))
-toJSON(min(i32) / f32)
 toJSON(min(i32))
 toJSON(min(i64))
-toJSON(nil != "bar")
-toJSON(nil != "foo")
 toJSON(nil != 0.5)
+toJSON(nil != 1)
 toJSON(nil != add)
+toJSON(nil != array)
 toJSON(nil != f32)
-toJSON(nil != f64)
+toJSON(nil != false)
 toJSON(nil != foo)
-toJSON(nil != i32)
-toJSON(nil != list)
-toJSON(nil != nil)
-toJSON(nil != score)
-toJSON(nil != true)
+toJSON(nil != greet)
+toJSON(nil != half)
 toJSON(nil == 0.5)
 toJSON(nil == 1)
-toJSON(nil == add)
 toJSON(nil == div)
-toJSON(nil == f32)
 toJSON(nil == f64)
-toJSON(nil == false)
-toJSON(nil == foo)
+toJSON(nil == half)
 toJSON(nil == i)
 toJSON(nil == i64)
 toJSON(nil == list)
+toJSON(nil == nil)
 toJSON(nil == ok)
-toJSON(nil == score)
-toJSON(nil == true)
 toJSON(nil in array)
-toJSON(nil not in array)
-toJSON(nil not in list)
-toJSON(nil) + string("bar")
-toJSON(nil) == toJSON(1)
-toJSON(nil) == type(nil)
-toJSON(nil) in foo
+toJSON(nil) + foo.Bar
+toJSON(none(array, ok))
 toJSON(none(array, true))
-toJSON(none(list, true))
+toJSON(none(list, false))
+toJSON(none(list, ok))
 toJSON(not ("foo" not in foo))
+toJSON(not (f32 != 1))
 toJSON(not false)
 toJSON(not ok)
 toJSON(not true)
 toJSON(ok != false)
-toJSON(ok != nil)
-toJSON(ok != ok)
-toJSON(ok && true)
+toJSON(ok && false)
+toJSON(ok && ok)
 toJSON(ok == nil)
 toJSON(ok == ok)
-toJSON(ok ? 1 : half)
-toJSON(ok ? f32 : div)
-toJSON(ok ? false : i32)
-toJSON(ok ? nil : f32)
+toJSON(ok ? "foo" : f32)
+toJSON(ok ? 0.5 : f32)
+toJSON(ok ? f64 : 0.5)
+toJSON(ok ? i : false)
+toJSON(ok ? nil : i)
+toJSON(ok ? nil : true)
+toJSON(ok ? true : greet)
+toJSON(ok and ok)
 toJSON(ok or true)
-toJSON(ok || ok)
 toJSON(ok)
-toJSON(one(array, i32 < #))
+toJSON(one(array, false))
+toJSON(one(array, true))
+toJSON(reduce(array, #))
+toJSON(reduce(array, 0.5))
+toJSON(reduce(array, array))
+toJSON(reduce(array, foo))
+toJSON(reduce(array, i64))
+toJSON(reduce(array, list))
+toJSON(reduce(array, score(i32 * i64)))
+toJSON(reduce(list, #))
+toJSON(reduce(list, 1))
+toJSON(reduce(list, f32))
+toJSON(reduce(list, false))
+toJSON(reduce(list, i))
+toJSON(reduce(list, i32))
+toJSON(reduce(list, list))
+toJSON(reduce(list, ok))
+toJSON(reduce(list, true))
+toJSON(round(1))
+toJSON(round(f64))
+toJSON(round(i32))
+toJSON(score != add)
 toJSON(score != div)
-toJSON(score != greet)
-toJSON(score != nil)
 toJSON(score != score)
-toJSON(score == add)
-toJSON(score == div)
-toJSON(score == nil)
+toJSON(score == half)
 toJSON(score(1))
+toJSON(score(1, 1))
 toJSON(score(i))
-toJSON(score(i, i))
+toJSON(sort(array))
 toJSON(string("bar"))
-toJSON(string("foo"))
 toJSON(string(0.5))
 toJSON(string(1))
 toJSON(string(array))
-toJSON(string(div))
 toJSON(string(f32))
 toJSON(string(f64))
 toJSON(string(false))
 toJSON(string(foo))
-toJSON(string(greet))
 toJSON(string(half))
 toJSON(string(i))
 toJSON(string(i32))
@@ -14128,11 +17901,11 @@ toJSON(string(list))
 toJSON(string(nil))
 toJSON(string(ok))
 toJSON(string(score))
+toJSON(string(true))
+toJSON(sum(array))
+toJSON(take(array, i32))
 toJSON(toBase64("bar"))
-toJSON(toBase64("foo"))
 toJSON(toJSON("bar"))
-toJSON(toJSON("foo"))
-toJSON(toJSON(1))
 toJSON(toJSON(array))
 toJSON(toJSON(f32))
 toJSON(toJSON(f64))
@@ -14144,50 +17917,58 @@ toJSON(toJSON(i64))
 toJSON(toJSON(list))
 toJSON(toJSON(nil))
 toJSON(toJSON(ok))
-toJSON(toJSON(true))
 toJSON(trim("bar"))
-toJSON(trim("foo"))
 toJSON(trimPrefix("foo"))
-toJSON(trimSuffix("foo"))
-toJSON(true && true)
-toJSON(true ? array : nil)
-toJSON(true ? i32 : div)
-toJSON(true ? list : true)
-toJSON(true ? nil : array)
-toJSON(true ? ok : list)
-toJSON(true ? true : f64)
-toJSON(true and ok)
+toJSON(trimSuffix("bar"))
+toJSON(true != true)
+toJSON(true && ok)
+toJSON(true == ok)
+toJSON(true ? "bar" : "bar")
+toJSON(true ? nil : score)
+toJSON(true and false)
+toJSON(true and true)
 toJSON(true) in foo
-toJSON(type("bar"))
 toJSON(type("foo"))
-toJSON(type(0.5))
-toJSON(type(1))
 toJSON(type(add))
 toJSON(type(array))
 toJSON(type(f32))
 toJSON(type(f64))
 toJSON(type(false))
 toJSON(type(foo))
-toJSON(type(greet))
-toJSON(type(half))
 toJSON(type(i))
 toJSON(type(i32))
 toJSON(type(i64))
 toJSON(type(list))
-toJSON(type(nil))
 toJSON(type(ok))
 toJSON(type(score))
 toJSON(type(true))
 toJSON(upper("bar"))
-toJSON(upper("foo"))
-toJSON({"bar": 0.5, "bar": array})
-toJSON({"foo": "foo"})
-toJSON({"foo": 0.5})
+toJSON({"bar": 1, "bar": array})
+toJSON({"bar": 1})
+toJSON({"bar": f64})
+toJSON({"bar": list})
+toJSON({"foo": i})
 toJSON({"foo": nil})
-toJSON({"foo": ok, "bar": 0.5})
-trim("bar") in foo
-trim("foo" + "foo")
-trim(false ? greet : "bar")
+toPairs(groupBy(array, # / #))
+toPairs(groupBy(array, #))
+toPairs(groupBy(array, 0.5))
+toPairs(groupBy(array, 1))
+toPairs(groupBy(array, false))
+toPairs(groupBy(array, foo))
+toPairs(groupBy(array, i))
+toPairs(groupBy(array, i32))
+toPairs(groupBy(array, ok))
+toPairs(groupBy(array, true))
+toPairs(groupBy(list, #))
+toPairs(groupBy(list, 1))
+toPairs(groupBy(list, f32))
+toPairs(groupBy(list, i))
+toPairs(groupBy(list, ok))
+toPairs({"bar": f32})
+toPairs({"foo": i32, "bar": score})
+toPairs({"foo": nil})
+trim("bar") not in foo
+trim(false ? "bar" : "bar")
 trim(foo.Bar)
 trim(foo.String())
 trim(foo?.Bar)
@@ -14195,84 +17976,58 @@ trim(foo?.String())
 trim(greet("bar"))
 trim(greet("foo"))
 trim(lower("bar"))
-trim(lower(toJSON(0.5)))
-trim(ok ? "bar" : i32)
-trim(string("foo"))
+trim(lower("foo"))
+trim(reduce(list, "bar"))
+trim(string("bar"))
+trim(string(-f64))
 trim(string(0.5))
 trim(string(1))
 trim(string(add))
-trim(string(div))
+trim(string(array))
 trim(string(f32))
-trim(string(f64))
-trim(string(false))
 trim(string(foo))
-trim(string(greet))
-trim(string(half))
-trim(string(i))
-trim(string(i32))
 trim(string(i64))
 trim(string(list))
 trim(string(nil))
-trim(string(ok))
-trim(string(score))
-trim(string(true))
-trim(toBase64("bar"))
-trim(toBase64("foo"))
-trim(toJSON("foo"))
-trim(toJSON(0.5))
+trim(toJSON("bar"))
 trim(toJSON(1))
-trim(toJSON(array))
 trim(toJSON(f32))
-trim(toJSON(f64))
 trim(toJSON(false))
 trim(toJSON(foo))
-trim(toJSON(i))
 trim(toJSON(i32))
 trim(toJSON(i64))
-trim(toJSON(list))
-trim(toJSON(nil))
 trim(toJSON(ok))
 trim(toJSON(true))
 trim(trim("bar"))
-trim(trimPrefix("bar"))
 trim(trimPrefix("foo"))
-trim(trimPrefix(string(i)))
 trim(trimSuffix("bar"))
-trim(trimSuffix("foo"))
+trim(true ? "foo" : greet)
+trim(type("bar"))
 trim(type("foo"))
 trim(type(0.5))
 trim(type(1))
 trim(type(add))
-trim(type(array))
 trim(type(div))
 trim(type(f32))
 trim(type(f64))
-trim(type(false))
-trim(type(foo))
 trim(type(greet))
-trim(type(half))
 trim(type(i))
-trim(type(i32))
-trim(type(i64))
 trim(type(list))
-trim(type(nil != list))
 trim(type(nil))
 trim(type(ok))
 trim(type(score))
-trim(type(toJSON(1)))
 trim(type(true))
-trim(upper("bar"))
-trimPrefix("foo" + "foo")
+trimPrefix("bar" + "foo")
+trimPrefix("foo" + "bar")
+trimPrefix(false ? 1 : "bar")
 trimPrefix(foo.Bar)
 trimPrefix(foo.String())
 trimPrefix(foo?.Bar)
 trimPrefix(foo?.String())
 trimPrefix(greet("bar"))
 trimPrefix(greet("foo"))
-trimPrefix(greet(foo.String()))
+trimPrefix(greet(type(0.5)))
 trimPrefix(lower("bar"))
-trimPrefix(lower("foo"))
-trimPrefix(ok ? "bar" : i64)
 trimPrefix(string("foo"))
 trimPrefix(string(0.5))
 trimPrefix(string(1))
@@ -14280,50 +18035,35 @@ trimPrefix(string(add))
 trimPrefix(string(array))
 trimPrefix(string(div))
 trimPrefix(string(f32))
+trimPrefix(string(f64))
 trimPrefix(string(foo))
 trimPrefix(string(greet))
 trimPrefix(string(half))
 trimPrefix(string(i))
 trimPrefix(string(i32))
 trimPrefix(string(i64))
-trimPrefix(string(list))
 trimPrefix(string(nil))
-trimPrefix(string(ok))
 trimPrefix(string(score))
+trimPrefix(string(true))
+trimPrefix(string({"bar": greet}))
 trimPrefix(toBase64("bar"))
-trimPrefix(toBase64("foo"))
-trimPrefix(toJSON("bar"))
 trimPrefix(toJSON("foo"))
-trimPrefix(toJSON(0.5))
 trimPrefix(toJSON(1))
 trimPrefix(toJSON(array))
 trimPrefix(toJSON(f32))
-trimPrefix(toJSON(f64))
-trimPrefix(toJSON(false))
 trimPrefix(toJSON(foo))
-trimPrefix(toJSON(i))
 trimPrefix(toJSON(i32))
 trimPrefix(toJSON(i64))
+trimPrefix(toJSON(list))
 trimPrefix(toJSON(nil))
 trimPrefix(toJSON(true))
-trimPrefix(trim("bar"))
-trimPrefix(trim("foo"))
-trimPrefix(trimPrefix("bar"))
 trimPrefix(trimPrefix("foo"))
-trimPrefix(trimSuffix("bar"))
-trimPrefix(trimSuffix("foo"))
 trimPrefix(type("bar"))
-trimPrefix(type(0.5 == 0.5))
 trimPrefix(type(0.5))
-trimPrefix(type(1 == f64))
 trimPrefix(type(1))
-trimPrefix(type(add))
 trimPrefix(type(array))
-trimPrefix(type(div))
 trimPrefix(type(f32))
 trimPrefix(type(f64))
-trimPrefix(type(false))
-trimPrefix(type(foo))
 trimPrefix(type(greet))
 trimPrefix(type(half))
 trimPrefix(type(i))
@@ -14332,142 +18072,127 @@ trimPrefix(type(i64))
 trimPrefix(type(list))
 trimPrefix(type(nil))
 trimPrefix(type(ok))
-trimPrefix(type(score))
+trimPrefix(type(true))
+trimPrefix(upper("bar"))
 trimPrefix(upper("foo"))
-trimSuffix("bar" + "bar")
-trimSuffix("foo") <= trimPrefix("foo")
+trimSuffix("bar" + "foo")
+trimSuffix("bar") not contains reduce(list, "bar")
+trimSuffix("foo" + "bar")
+trimSuffix(false ? i64 : "foo")
 trimSuffix(foo.Bar)
 trimSuffix(foo.String())
 trimSuffix(foo?.Bar)
-trimSuffix(foo?.Qux("bar"))
 trimSuffix(foo?.String())
 trimSuffix(greet("bar"))
 trimSuffix(greet("foo"))
-trimSuffix(greet(toJSON(i64)))
 trimSuffix(lower("bar"))
-trimSuffix(lower("foo"))
-trimSuffix(repeat("foo", i))
+trimSuffix(reduce(array, "foo"))
+trimSuffix(reduce(list, #)?.Bar)
 trimSuffix(string("bar"))
+trimSuffix(string("foo"))
 trimSuffix(string(0.5))
-trimSuffix(string(1))
 trimSuffix(string(add))
 trimSuffix(string(array))
-trimSuffix(string(f32))
+trimSuffix(string(div))
 trimSuffix(string(f64))
 trimSuffix(string(false))
 trimSuffix(string(foo))
-trimSuffix(string(greet))
 trimSuffix(string(half))
 trimSuffix(string(i))
 trimSuffix(string(i32))
 trimSuffix(string(i64))
 trimSuffix(string(list))
 trimSuffix(string(nil))
-trimSuffix(string(score))
-trimSuffix(string(type("foo")))
+trimSuffix(string(ok))
+trimSuffix(string(true))
 trimSuffix(toBase64("bar"))
-trimSuffix(toJSON("bar"))
-trimSuffix(toJSON(0.5))
+trimSuffix(toBase64("foo"))
+trimSuffix(toJSON(1 > f64))
 trimSuffix(toJSON(1))
-trimSuffix(toJSON(array))
+trimSuffix(toJSON(f32))
 trimSuffix(toJSON(f64))
 trimSuffix(toJSON(false))
-trimSuffix(toJSON(first(array)))
 trimSuffix(toJSON(foo))
 trimSuffix(toJSON(i))
 trimSuffix(toJSON(i32))
 trimSuffix(toJSON(i64))
 trimSuffix(toJSON(list))
 trimSuffix(toJSON(nil))
-trimSuffix(toJSON(ok))
+trimSuffix(toJSON(true))
 trimSuffix(trim("bar"))
 trimSuffix(trim("foo"))
 trimSuffix(trimPrefix("bar"))
 trimSuffix(trimPrefix("foo"))
-trimSuffix(trimSuffix("foo"))
-trimSuffix(type("bar"))
-trimSuffix(type("foo"))
-trimSuffix(type(0.5))
+trimSuffix(trimSuffix("bar"))
 trimSuffix(type(1))
 trimSuffix(type(add))
 trimSuffix(type(array))
 trimSuffix(type(div))
 trimSuffix(type(f32))
-trimSuffix(type(f64))
-trimSuffix(type(false))
 trimSuffix(type(foo))
+trimSuffix(type(greet))
 trimSuffix(type(half))
-trimSuffix(type(i))
 trimSuffix(type(i32))
-trimSuffix(type(i64))
 trimSuffix(type(list))
 trimSuffix(type(nil))
 trimSuffix(type(ok))
-trimSuffix(type(true))
-trimSuffix(upper("bar"))
 trimSuffix(upper("foo"))
-true != nil || true != nil
-true == nil && ok
-true ? "bar" : 0.5 ^ i
-true ? "bar" : 1 <= 1 / 1
-true ? "bar" : i != i32
-true ? "foo" : foo?.Bar
-true ? 0.5 : foo.Qux
-true ? 1 : f64 + f32
-true ? 1 : nil == array
-true ? array : foo.Qux
+true != nil || true == true
+true != ok != ok
+true == ok == ok
+true ? 0.5 : i <= f32
+true ? 1 : foo?.Bar
+true ? 1 : ok or i64 == 0.5
+true ? add : foo?.Bar
+true ? array : 0.5 >= i32
 true ? array : foo.String
-true ? array : i32 / i32
-true ? array : nil != map(list, #)
-true ? array : nil != ok
-true ? f32 : f64 == i32
-true ? f64 : foo?.String
-true ? greet : 0.5 == i
-true ? i : 0.5 + i64
-true ? i : 0.5 >= i64
-true ? i32 : foo.Bar
-true ? i64 : foo.Bar
-true ? list : f64 / f64
-true ? nil : 0.5 != i32
-true ? nil : foo.Qux
+true ? array : foo?.Bar
+true ? array : foo?.String
+true ? array : i32 ** f64
+true ? div : i64 ** 1 ^ i32
+true ? false : 0.5 > i
+true ? false : foo.Qux
+true ? foo : 0.5 + -1
+true ? foo : foo.Bar
+true ? foo : i64 / f32
+true ? greet : foo.Bar
+true ? greet : ok == ok
+true ? half : 0.5 / i32
+true ? half : foo.String
+true ? i : 1 * i64
+true ? i : greet == half
+true ? i32 : i32 - f32
+true ? i32 : i32 >= f32
+true ? i64 : f64 != i
+true ? list : div != greet
+true ? list : f32 != i
 true ? nil : foo.String
-true ? nil : i32 .. i
-true ? nil : i64 ** -i
-true ? ok : f32 / f32
-true ? ok : f64 + f64
-true ? score : foo.Qux
-true ? true : f32 >= i64
-true ? true : foo?.String
-true and ok and ok
-true || 1 not in array
+true ? nil : foo?.String
+true ? nil : i32 != f64 + 1
+true ? ok : foo.Qux
+true ? ok : foo?.String
+true ? score : ok or f64 < f32
+true and nil not in list
+true and ok or ok
+true and true || ok
+true or 0.5 not in array
+true || f32 not in groupBy(list, #)
+true || false ? half : half
 type(!false)
 type(!ok)
 type(!true)
-type("bar" != nil)
-type("bar" + "foo")
-type("bar" < "bar")
+type("bar" != "bar")
+type("bar" < "foo")
 type("bar" <= "bar")
-type("bar" <= "foo")
-type("bar" == nil)
-type("bar" > "foo")
-type("bar" endsWith "foo")
-type("bar" matches "bar")
-type("bar" matches "foo")
-type("bar" not contains "bar")
-type("bar" not endsWith "bar")
+type("bar" == "foo")
+type("bar" >= "bar")
 type("bar" not endsWith "foo")
-type("bar" startsWith "foo")
-type("bar") == string(array)
-type("foo" != "bar")
-type("foo" == "foo")
-type("foo" > "bar")
-type("foo" contains "foo")
-type("foo" endsWith "foo")
-type("foo" in foo)
-type("foo" not endsWith "bar")
-type("foo" not endsWith "foo")
-type("foo" startsWith "foo")
-type("foo" startsWith foo.Bar)
+type("bar" startsWith "bar")
+type("bar") startsWith greet("bar")
+type("foo" != nil)
+type("foo" + "bar")
+type("foo" not startsWith "bar")
+type("foo") not in foo
 type(-0.5)
 type(-1)
 type(-f32)
@@ -14475,288 +18200,234 @@ type(-f64)
 type(-i)
 type(-i32)
 type(-i64)
-type(0.5 != 0.5)
-type(0.5 != 1)
-type(0.5 != i)
+type(-int(f64))
+type(0.5 != f64)
 type(0.5 != i32)
 type(0.5 != nil)
 type(0.5 * 0.5)
-type(0.5 * 1)
-type(0.5 * i)
-type(0.5 * i32)
+type(0.5 * f32)
+type(0.5 * f64)
 type(0.5 * i64)
 type(0.5 ** 0.5)
 type(0.5 ** 1)
 type(0.5 ** f32)
+type(0.5 ** f64)
 type(0.5 ** i)
 type(0.5 ** i32)
-type(0.5 ** i64)
+type(0.5 + 0.5)
+type(0.5 + 1)
 type(0.5 + f32)
-type(0.5 + i32)
+type(0.5 + f64)
+type(0.5 + i)
 type(0.5 + i64)
-type(0.5 - 0.5)
-type(0.5 - i)
-type(0.5 / 0.5)
+type(0.5 - 1)
+type(0.5 - f64)
+type(0.5 - i32)
 type(0.5 / 1)
-type(0.5 / f64)
+type(0.5 / f32)
 type(0.5 / i)
+type(0.5 / i32)
+type(0.5 / i64)
 type(0.5 < 1)
-type(0.5 < f64)
-type(0.5 < i)
+type(0.5 < f32)
+type(0.5 < i32)
 type(0.5 < i64)
 type(0.5 <= 1)
 type(0.5 <= f32)
-type(0.5 <= i)
 type(0.5 <= i64)
-type(0.5 == 1)
-type(0.5 == i)
-type(0.5 == nil)
+type(0.5 == 0.5)
+type(0.5 == f32)
+type(0.5 == f64)
+type(0.5 == i32)
 type(0.5 > 0.5)
-type(0.5 > 1)
-type(0.5 > f64)
+type(0.5 > f32)
 type(0.5 > i)
+type(0.5 > i32)
+type(0.5 > i64)
 type(0.5 >= 0.5)
-type(0.5 >= 1)
-type(0.5 >= f64)
 type(0.5 >= i)
 type(0.5 >= i32)
 type(0.5 ^ 0.5)
-type(0.5 ^ 1)
-type(0.5 ^ f32)
-type(0.5 ^ f64)
 type(0.5 ^ i)
-type(0.5) not contains trimPrefix("bar")
-type(0.5) not in foo
-type(0.5) startsWith "bar" == nil
-type(0.5)[i32:i64]
-type(1 != 0.5)
-type(1 != 1)
-type(1 != f32)
+type(0.5 ^ i32)
+type(0.5 ^ i64)
+type(0.5 not in array)
+type(0.5) in foo
 type(1 != i32)
 type(1 != nil)
 type(1 % 1)
 type(1 % i)
-type(1 % i32)
-type(1 % i64)
-type(1 * 1)
+type(1 * 0.5)
 type(1 * f32)
 type(1 * i)
-type(1 * i64)
+type(1 * i32)
 type(1 ** 0.5)
-type(1 ** 1)
 type(1 ** f64)
-type(1 ** i32)
+type(1 ** i)
 type(1 ** i64)
 type(1 + 0.5)
+type(1 + 1)
 type(1 + f32)
-type(1 + f64)
 type(1 + i64)
 type(1 - 0.5)
 type(1 - 1)
-type(1 - f64)
-type(1 - i32)
+type(1 - i64)
 type(1 .. 1)
-type(1 .. i)
 type(1 .. i64)
-type(1 / 1)
-type(1 / f32)
 type(1 / f64)
-type(1 < 1)
-type(1 < f32)
-type(1 < i)
-type(1 <= f32)
+type(1 / i)
+type(1 < i32)
+type(1 < i64)
+type(1 <= 0.5)
+type(1 <= 1)
 type(1 <= f64)
-type(1 <= i32)
-type(1 <= i64)
-type(1 == 1)
+type(1 <= i)
+type(1 == f32)
+type(1 == f64)
 type(1 == i)
+type(1 == i32)
 type(1 == i64)
-type(1 == nil)
-type(1 > 0.5)
-type(1 > 1)
-type(1 > f32)
-type(1 > f64)
+type(1 > i)
 type(1 >= 0.5)
-type(1 >= 1)
-type(1 >= f64)
 type(1 >= i)
-type(1 >= i32)
 type(1 >= i64)
-type(1 ^ 0.5)
-type(1 ^ f32)
+type(1 ^ 1)
+type(1 ^ i)
 type(1 ^ i64)
-type(1 in array)
-type(1 not in array)
-type(1) != toJSON(0.5)
-type(1) == nil ? 1 : f64
-type(1) endsWith greet("foo")
-type(1) in foo
-type(1) in foo != true
-type(1) not contains type(nil)
-type(1) not endsWith toJSON(ok)
-type([half, 1])
-type([nil])
+type(1) endsWith foo.Bar
+type(1) in reduce(list, #)
+type(1) not endsWith "bar" ? i64 : nil
+type(1) not startsWith string(0.5)
+type([div])
+type([f32])
 type(abs(0.5))
-type(abs(1))
+type(abs(f32))
 type(abs(f64))
 type(abs(i))
 type(abs(i32))
 type(abs(i64))
-type(add != add)
 type(add != greet)
 type(add != half)
-type(add == half)
-type(add == nil)
-type(add(1, 1))
 type(add)
-type(add) in foo
-type(all(array, true))
-type(all(list, false))
+type(all(array, ok))
+type(all(list, ok))
+type(all(list, true))
 type(any(array, false))
-type(any(list, true))
+type(any(array, ok))
+type(any(list, false))
+type(array != list)
+type(array != nil)
 type(array == array)
-type(array == list)
 type(array)
-type(array) in foo
-type(array) not in foo
+type(array) >= trimPrefix("foo")
 type(array[1])
 type(array[i32])
 type(array[i])
-type(count(list, ok))
-type(count(list, true))
+type(bitand(1, i))
+type(bitnot(i))
+type(bitnot(i32))
+type(bitnot(i64))
+type(bitxor(i64, 1))
+type(ceil(0.5))
+type(ceil(f32))
+type(ceil(f64))
+type(ceil(i64))
+type(count(array, true))
 type(div != div)
 type(div != half)
-type(div != nil)
-type(div == add)
-type(div == greet)
-type(div == half)
+type(div == div)
 type(div)
-type(div) not in foo
 type(f32 != 0.5)
 type(f32 != 1)
-type(f32 != f32)
-type(f32 != i32)
-type(f32 * 0.5)
 type(f32 * 1)
-type(f32 * f32)
-type(f32 * f64)
 type(f32 * i)
-type(f32 * i64)
-type(f32 ** 0.5)
-type(f32 ** 1)
+type(f32 * i32)
 type(f32 ** f32)
-type(f32 ** i)
-type(f32 ** i32)
-type(f32 + 0.5)
 type(f32 + 1)
-type(f32 + f64)
 type(f32 + i)
-type(f32 + i64)
-type(f32 - 0.5)
-type(f32 - 1)
 type(f32 - f32)
-type(f32 - i)
 type(f32 - i32)
-type(f32 - i64)
+type(f32 / 1)
+type(f32 / f32)
 type(f32 < 1)
-type(f32 < f64)
-type(f32 < i32)
-type(f32 <= 0.5)
-type(f32 <= 1)
-type(f32 <= i64)
+type(f32 < f32)
+type(f32 <= f64)
 type(f32 == 0.5)
-type(f32 == 1)
+type(f32 == f64)
+type(f32 == i)
 type(f32 == i32)
+type(f32 == i64)
 type(f32 > 1)
-type(f32 > f32)
-type(f32 > f64)
-type(f32 >= 0.5)
-type(f32 ^ 0.5)
-type(f32 ^ f32)
-type(f32 ^ f64)
-type(f32 ^ i32)
+type(f32 >= f32)
+type(f32 >= i)
+type(f32 >= i32)
 type(f32 ^ i64)
+type(f32 not in array)
 type(f32)
-type(f64 != f64)
-type(f64 != i64)
+type(f64 != 0.5)
+type(f64 != i)
 type(f64 * 0.5)
 type(f64 * 1)
-type(f64 * i32)
-type(f64 * i64)
-type(f64 ** 0.5)
+type(f64 * f32)
 type(f64 ** 1)
-type(f64 ** f32)
-type(f64 ** i)
-type(f64 ** i32)
-type(f64 + 0.5)
-type(f64 + f64)
-type(f64 + i)
+type(f64 + f32)
+type(f64 + i32)
 type(f64 - 0.5)
-type(f64 - f32)
+type(f64 - 1)
 type(f64 - f64)
 type(f64 - i)
 type(f64 / 1)
-type(f64 / i)
+type(f64 / f32)
+type(f64 / i64)
 type(f64 < 0.5)
-type(f64 < 1)
+type(f64 < f32)
 type(f64 < f64)
+type(f64 < i32)
 type(f64 < i64)
 type(f64 <= 0.5)
-type(f64 <= i)
-type(f64 <= i32)
-type(f64 == 1)
-type(f64 == f64)
+type(f64 <= f64)
+type(f64 <= i64)
+type(f64 == 0.5)
+type(f64 == f32)
+type(f64 == i64)
 type(f64 == nil)
-type(f64 > 1)
-type(f64 > f64)
 type(f64 > i)
 type(f64 > i32)
 type(f64 >= 0.5)
-type(f64 >= 1)
-type(f64 ^ 1)
-type(f64 ^ f64)
-type(f64 ^ i)
-type(f64 ^ i32)
-type(f64 ^ i64)
+type(f64 >= i)
+type(f64 ^ 0.5)
+type(f64 not in array)
 type(f64)
 type(false != nil)
+type(false != ok)
 type(false && true)
-type(false == ok)
-type(false ? add : div)
-type(false ? half : i)
-type(false ? half : i32)
-type(false ? i32 : 1)
-type(false ? i32 : true)
-type(false ? list : "foo")
-type(false || ok)
-type(false) not contains toJSON(i)
-type(filter(array, true))
-type(filter(list, false))
-type(find([f64], "foo" == nil))
+type(false ? "bar" : score)
+type(false ? div : f64)
+type(false ? half : greet)
+type(false ? true : foo)
+type(false || true)
+type(false) startsWith "bar" ? ok : f32
 type(find(array, false))
-type(find(list, false))
-type(findIndex(array, false))
-type(findIndex(list, ok))
-type(findIndex(list, true))
+type(find(array, true))
+type(find(list, true))
+type(findIndex(array, ok))
 type(findLast(array, false))
 type(findLast(array, ok))
-type(findLast(list, false))
-type(findLastIndex(array, ok))
-type(findLastIndex(array, true))
+type(findLastIndex(array, false))
+type(findLastIndex(list, false))
 type(findLastIndex(list, ok))
-type(first(array))
+type(findLastIndex(list, true))
 type(first(list))
-type(float(0.5))
-type(float(1))
 type(float(f32))
-type(float(f64))
-type(float(i))
 type(float(i32))
-type(float(i64))
+type(floor(0.5))
+type(floor(1))
+type(floor(f64))
+type(floor(i64))
 type(foo != foo)
+type(foo != nil)
 type(foo in list)
 type(foo)
-type(foo) in foo
 type(foo.Bar)
 type(foo.Qux)
 type(foo.String())
@@ -14766,182 +18437,147 @@ type(foo?.Qux)
 type(foo?.String())
 type(foo?.String)
 type(get(array, 1))
-type(get(array, i))
-type(get(array, i32))
+type(get(array, i64))
 type(get(list, 1))
+type(get(list, i))
 type(get(list, i32))
+type(get(list, i64))
 type(greet != div)
-type(greet != half)
-type(greet != score)
 type(greet == div)
-type(greet == greet)
-type(greet == half)
 type(greet("bar"))
 type(greet("foo"))
-type(greet(lower("foo")))
 type(greet)
-type(greet) not in foo
-type(half != add)
-type(half != nil)
-type(half == add)
-type(half == div)
+type(groupBy(array, #))
+type(groupBy(array, #).score)
+type(groupBy(array, 0.5))
+type(groupBy(array, false)?.add)
+type(groupBy(array, i))
+type(groupBy(array, i32))
+type(groupBy(array, i64))
+type(groupBy(list, "bar"))
+type(groupBy(list, #))
+type(groupBy(list, #)?.Bar)
+type(groupBy(list, 1))
+type(groupBy(list, i64))
+type(groupBy(list, true))
+type(half != div)
+type(half != greet)
+type(half != score)
 type(half(0.5))
+type(half(1))
 type(half(f64))
 type(half)
-type(half) endsWith toJSON(1)
-type(i != 0.5)
-type(i != 1)
-type(i != f32)
-type(i != i64)
+type(half) not in foo
 type(i % 1)
+type(i % i32)
 type(i * 0.5)
-type(i * i64)
-type(i ** 0.5)
-type(i ** 1)
+type(i * i32)
 type(i ** f32)
 type(i ** f64)
 type(i ** i)
-type(i ** i32)
-type(i + 1)
-type(i + i)
 type(i + i32)
-type(i .. i64)
+type(i - 0.5)
+type(i - 1)
+type(i - i)
+type(i - i64)
+type(i .. i)
 type(i / 0.5)
-type(i / 1)
-type(i < f32)
-type(i < i64)
-type(i == f32)
-type(i == i32)
-type(i == i64)
-type(i > f64)
-type(i >= 1)
-type(i >= f32)
-type(i >= f64)
-type(i ^ 0.5)
+type(i / i32)
+type(i < 0.5)
+type(i < 1)
+type(i <= 0.5)
+type(i <= 1)
+type(i == 1)
+type(i > 0.5)
+type(i > 1)
+type(i > f32)
+type(i > i64)
+type(i >= i32)
 type(i ^ 1)
-type(i ^ f32)
-type(i ^ f64)
+type(i ^ i)
+type(i ^ i32)
 type(i ^ i64)
-type(i not in array)
 type(i)
-type(i) not endsWith greet("foo")
-type(i32 != 0.5)
+type(i) + foo.Bar
 type(i32 != 1)
-type(i32 != nil)
-type(i32 % 1)
-type(i32 % i64)
+type(i32 != f64)
 type(i32 * 0.5)
-type(i32 * 1)
-type(i32 * i32)
-type(i32 * i64)
-type(i32 ** f32)
+type(i32 * i)
+type(i32 ** 0.5)
 type(i32 ** f64)
 type(i32 ** i)
 type(i32 + 1)
-type(i32 + f32)
-type(i32 + f64)
-type(i32 + i)
-type(i32 + i32)
-type(i32 + i64)
-type(i32 - f32)
-type(i32 - i32)
-type(i32 .. 1)
-type(i32 .. i)
+type(i32 - 1)
+type(i32 .. i32)
+type(i32 / 0.5)
 type(i32 / f64)
-type(i32 / i32)
-type(i32 < 1)
-type(i32 < f32)
-type(i32 < i)
-type(i32 < i64)
+type(i32 < 0.5)
+type(i32 <= 0.5)
 type(i32 <= f64)
 type(i32 <= i32)
-type(i32 <= i64)
-type(i32 == 0.5)
 type(i32 == 1)
-type(i32 == f32)
-type(i32 == f64)
-type(i32 == i)
-type(i32 == i64)
+type(i32 == nil)
 type(i32 > 0.5)
-type(i32 > 1)
 type(i32 > f64)
-type(i32 > i32)
+type(i32 > i64)
 type(i32 >= 1)
 type(i32 >= f32)
-type(i32 >= i)
-type(i32 >= i32)
-type(i32 ^ 0.5)
+type(i32 >= i64)
+type(i32 ^ 1)
+type(i32 ^ f32)
+type(i32 ^ f64)
 type(i32 ^ i)
-type(i32 ^ i32)
-type(i32 ^ i64)
-type(i32 in array)
+type(i32 not in array)
 type(i32)
-type(i32) startsWith greet("foo")
+type(i32) in foo
+type(i32) not matches trim("foo")
 type(i64 != 1)
-type(i64 != array[i32])
-type(i64 != f32)
-type(i64 != i)
-type(i64 != nil)
-type(i64 % i)
-type(i64 % i64)
-type(i64 * 0.5)
+type(i64 != f64)
+type(i64 % 1)
 type(i64 * f32)
-type(i64 * f64)
 type(i64 * i64)
-type(i64 ** 1)
+type(i64 ** 0.5)
+type(i64 ** f64)
+type(i64 ** i32)
 type(i64 + 0.5)
-type(i64 + f64)
-type(i64 + i)
+type(i64 + 1)
 type(i64 + i64)
 type(i64 - 0.5)
-type(i64 .. 1)
+type(i64 - f32)
+type(i64 - f64)
+type(i64 - i32)
 type(i64 .. i32)
-type(i64 .. i64)
 type(i64 / 0.5)
-type(i64 / 1)
-type(i64 / i)
+type(i64 / f32)
 type(i64 / i64)
-type(i64 < 1)
+type(i64 < 0.5)
+type(i64 < f32)
 type(i64 < f64)
 type(i64 < i)
 type(i64 < i64)
+type(i64 <= 0.5)
 type(i64 <= 1)
 type(i64 <= f32)
-type(i64 <= i64)
-type(i64 == i32)
-type(i64 == nil)
-type(i64 > f64)
-type(i64 >= 0.5)
-type(i64 >= f32)
-type(i64 >= i)
-type(i64 >= i64)
-type(i64 ^ 0.5)
-type(i64 ^ 1)
-type(i64 ^ f32)
+type(i64 <= i)
+type(i64 == 1)
+type(i64 == f64)
+type(i64 > i64)
+type(i64 >= 1)
 type(i64 ^ f64)
 type(i64 ^ i)
-type(i64 ^ i32)
-type(i64 in array)
 type(i64 not in array)
 type(i64)
-type(i64) != foo?.Bar
-type(i64) contains string(foo) ? i : array
-type(i64) not in foo
-type(i64) not startsWith lower("foo")
 type(int(0.5))
-type(int(1))
 type(int(f32))
 type(int(f64))
 type(int(i))
 type(int(i32))
-type(int(i64) <= f32)
 type(int(i64))
 type(last(array))
 type(last(list))
-type(len("bar"))
-type(len("foo"))
 type(len(array))
 type(len(list))
+type(list != nil)
 type(list == array)
 type(list == nil)
 type(list)
@@ -14949,1423 +18585,1416 @@ type(list[1])
 type(list[i32])
 type(list[i64])
 type(list[i])
-type(lower("bar"))
-type(lower("foo"))
-type(lower(string(nil)))
+type(map(array, "bar"))
 type(map(array, "foo"))
 type(map(array, #))
-type(map(array, 0.5))
-type(map(array, add))
-type(map(array, array))
-type(map(array, false))
+type(map(array, 1))
+type(map(array, div))
+type(map(array, f32))
 type(map(array, foo))
-type(map(array, half))
-type(map(array, i))
-type(map(array, i64))
+type(map(array, greet))
 type(map(array, ok))
-type(map(i .. i32, i64))
+type(map(array, true))
+type(map(list, "bar"))
 type(map(list, #))
-type(map(list, 0.5))
-type(map(list, 1))
 type(map(list, array))
-type(map(list, f32))
-type(map(list, f64))
-type(map(list, foo))
 type(map(list, greet))
-type(map(list, i))
+type(map(list, i64))
 type(map(list, list))
 type(map(list, ok))
 type(max(0.5))
+type(max(0.5, f64))
 type(max(1))
-type(max(f32))
-type(max(f32, i32))
+type(max(1, i32))
 type(max(f64))
-type(max(f64, 0.5))
-type(max(i))
-type(max(i32))
-type(max(i32, i64))
 type(max(i64))
-type(min(0.5))
+type(median(array))
 type(min(1))
-type(min(1, 0.5))
-type(min(1, 1, f32))
 type(min(f32))
-type(min(f64))
 type(min(i))
-type(min(i, 1))
 type(min(i32))
-type(min(i32, 0.5))
 type(min(i64))
-type(nil != "bar")
+type(nil != "foo")
 type(nil != 0.5)
 type(nil != 1)
-type(nil != div)
-type(nil != f64)
-type(nil != false)
-type(nil != foo)
 type(nil != greet)
+type(nil != half)
 type(nil != i32)
+type(nil != i64)
 type(nil != nil)
-type(nil != ok)
-type(nil == "bar")
+type(nil != score)
 type(nil == "foo")
-type(nil == 0.5)
-type(nil == 1)
-type(nil == add)
 type(nil == array)
 type(nil == f32)
-type(nil == f64)
-type(nil == i)
-type(nil == i32)
+type(nil == false)
+type(nil == foo)
+type(nil == greet)
 type(nil == nil)
-type(nil == ok)
 type(nil == score)
-type(nil == true)
 type(nil in array)
+type(nil in list)
 type(nil not in array)
-type(nil) != type(1)
-type(none(array, ok))
-type(none(array, true))
+type(nil not in list)
 type(none(list, ok))
 type(none(list, true))
+type(not (f64 <= i))
 type(not false)
 type(not ok)
 type(not true)
+type(ok != false)
 type(ok != nil)
-type(ok == false)
-type(ok ? 0.5 : i32)
-type(ok ? 0.5 : list)
-type(ok ? 1 : f32)
-type(ok ? add : "bar")
-type(ok ? false : i64)
-type(ok ? foo : false)
-type(ok ? half : half)
-type(ok ? i32 : f64)
-type(ok ? i64 : "bar")
-type(ok ? list : "foo")
-type(ok ? ok : half)
-type(ok ? true : false)
+type(ok != true)
+type(ok && false)
+type(ok == nil)
+type(ok ? "bar" : half)
+type(ok ? 1 : "bar")
+type(ok ? array : i64)
+type(ok ? array : score)
+type(ok ? i : "bar")
+type(ok ? i : nil)
+type(ok ? nil : 0.5)
+type(ok ? nil : div)
 type(ok and ok)
-type(ok and true)
 type(ok or false)
-type(ok or true)
-type(ok || true)
+type(ok || false)
 type(ok)
-type(ok) in foo
-type(ok) not matches string(i64)
-type(ok) not startsWith lower("bar")
-type(score != div)
-type(score != greet)
-type(score != half)
-type(score != nil)
-type(score == add)
-type(score == foo.String)
+type(one(array, false))
+type(one(array, true))
+type(one(list, false))
+type(one(list, true))
+type(reduce(array, "bar"))
+type(reduce(array, #))
+type(reduce(array, 1))
+type(reduce(array, foo))
+type(reduce(array, greet))
+type(reduce(array, i))
+type(reduce(array, ok))
+type(reduce(list, "foo"))
+type(reduce(list, #))
+type(reduce(list, array))
+type(reduce(list, i64))
+type(reduce(list, ok))
+type(round(0.5))
+type(round(1))
+type(round(f64))
+type(round(i))
+type(round(i64))
+type(score != score)
+type(score == div)
 type(score == greet)
-type(score == half)
 type(score == nil)
-type(score == score)
 type(score(1))
+type(score(1, 1))
 type(score(i))
-type(score(i, 1))
 type(score)
-type(score) < foo?.Bar
-type(score) > string(score)
-type(score) in foo
-type(score) not contains type(1)
 type(sort(array))
-type(string("bar"))
-type(string("foo"))
 type(string(0.5))
 type(string(1))
 type(string(add))
-type(string(array))
 type(string(div))
+type(string(f32))
 type(string(f64))
 type(string(false))
-type(string(foo))
 type(string(greet))
-type(string(half))
-type(string(i <= i32))
-type(string(i))
+type(string(i32))
 type(string(i64))
 type(string(list))
 type(string(nil))
 type(string(ok))
 type(string(score))
-type(toBase64("foo"))
+type(toBase64("bar"))
 type(toJSON("bar"))
 type(toJSON("foo"))
-type(toJSON(0.5 < i))
 type(toJSON(0.5))
 type(toJSON(1))
 type(toJSON(array))
-type(toJSON(f32))
-type(toJSON(f64))
 type(toJSON(false))
-type(toJSON(foo))
+type(toJSON(i))
 type(toJSON(i32))
 type(toJSON(i64))
 type(toJSON(list))
 type(toJSON(nil))
-type(toJSON(ok))
-type(toJSON(true))
-type(trim("bar"))
 type(trim("foo"))
-type(trimPrefix("foo"))
-type(trimPrefix(toJSON(true)))
-type(trimSuffix("bar"))
+type(trimPrefix("bar"))
+type(true != nil)
 type(true == false)
 type(true == nil)
-type(true ? "bar" : 0.5)
-type(true ? div : 0.5)
-type(true ? f64 : array)
-type(true ? foo : foo)
-type(true ? foo : true)
-type(true ? greet : "foo")
-type(true ? list : ok)
-type(true ? nil : list)
-type(true ? nil : ok)
-type(true ? true : 1)
+type(true ? array : false)
+type(true ? array : half)
+type(true ? div : add)
+type(true ? f64 : i32)
+type(true ? ok : 1)
+type(true and false)
 type(true and true)
-type(true) endsWith toBase64("foo")
-type(type("bar"))
-type(type("foo"))
+type(true or true)
+type(true || ok)
+type(true || true)
+type(true) in foo
+type(true) matches string(list)
 type(type(0.5))
 type(type(1))
 type(type(add))
-type(type(array))
 type(type(div))
-type(type(f32))
-type(type(f64))
-type(type(false))
 type(type(foo))
+type(type(greet))
 type(type(half))
 type(type(i))
 type(type(i32))
 type(type(i64))
-type(type(list))
 type(type(nil))
 type(type(ok))
-type(type(score))
 type(type(true))
-type(upper("bar"))
 type(upper("foo"))
-type({"bar": 0.5})
 type({"bar": 1})
-type({"bar": greet})
-type({"foo": 0.5, "bar": foo})
-type({"foo": div})
-type({"foo": i64})
-type({"foo": nil})
-upper("bar" + "foo")
-upper("bar") <= type(nil)
-upper("bar") contains lower("foo")
-upper("foo" + "bar")
-upper(false ? 0.5 : "foo")
+type({"bar": array})
+type({"foo": "foo"})
+type({"foo": f64})
+type({"foo": false, "foo": foo}.Bar)
+upper("bar") not in foo
+upper("foo" + "foo")
+upper("foo") == toJSON("bar")
 upper(foo.Bar)
 upper(foo.String())
 upper(foo?.Bar)
 upper(foo?.String())
+upper(greet("bar"))
 upper(greet("foo"))
-upper(greet(string(ok)))
+upper(last(list).Bar)
 upper(lower("bar"))
-upper(ok ? "bar" : i)
-upper(string("bar"))
+upper(lower("foo"))
+upper(reduce(list, #)?.Bar)
 upper(string("foo"))
 upper(string(0.5))
 upper(string(1))
+upper(string(add))
 upper(string(array))
-upper(string(div))
 upper(string(f32))
-upper(string(f64))
-upper(string(foo))
-upper(string(greet))
-upper(string(half))
-upper(string(i))
 upper(string(i32))
 upper(string(i64))
 upper(string(list))
 upper(string(nil))
-upper(string(ok))
 upper(string(score))
-upper(string(string(0.5)))
 upper(string(true))
+upper(toBase64("bar"))
 upper(toBase64("foo"))
 upper(toJSON("foo"))
-upper(toJSON(0.5))
 upper(toJSON(1))
-upper(toJSON(array))
 upper(toJSON(f32))
-upper(toJSON(f64))
 upper(toJSON(false))
 upper(toJSON(foo))
 upper(toJSON(i))
 upper(toJSON(i32))
-upper(toJSON(i64))
 upper(toJSON(list))
 upper(toJSON(nil))
-upper(toJSON(ok))
 upper(toJSON(true))
 upper(trim("bar"))
-upper(trim("bar", "bar"))
 upper(trim("foo"))
-upper(trimPrefix("bar"))
-upper(trimPrefix("foo"))
 upper(trimSuffix("bar"))
 upper(trimSuffix("foo"))
-upper(true ? "bar" : f32)
-upper(true ? "foo" : i32)
 upper(type("bar"))
 upper(type("foo"))
-upper(type(0.5))
-upper(type(1))
-upper(type(add))
+upper(type(array))
 upper(type(div))
 upper(type(f32))
-upper(type(f64))
-upper(type(false))
-upper(type(foo))
+upper(type(foo.Bar))
 upper(type(greet))
-upper(type(half))
 upper(type(i))
-upper(type(i64))
+upper(type(i32))
 upper(type(list))
 upper(type(nil))
+upper(type(ok))
 upper(type(score))
 upper(type(true))
-upper(upper("bar"))
-values({"bar": f32})
-values({"bar": greet})
-values({"bar": i64})
-values({"foo": 1})
-values({"foo": div})
-values({"foo": false})
-values({"foo": foo, "foo": ok})
-values({"foo": list, "bar": 1})
-{"bar": !false}
-{"bar": !true}
-{"bar": "bar", "foo": nil}?.String
-{"bar": "bar", "foo": score}.i
-{"bar": "bar", "foo": true}?.i?.foo
-{"bar": "bar"}.add
+upper(upper("foo"))
+values(groupBy(array, "bar"))
+values(groupBy(array, "foo"))
+values(groupBy(array, #))
+values(groupBy(array, 0.5))
+values(groupBy(array, 1))
+values(groupBy(array, foo))
+values(groupBy(array, i))
+values(groupBy(list, #))
+values(groupBy(list, 1))
+values(groupBy(list, i))
+values(groupBy(list, i32))
+values(groupBy(list, true))
+values({"bar": "bar"})
+values({"bar": array})
+values({"foo": add, "bar": div})
+values({"foo": ok})
+{"bar": "bar" <= "foo"}
+{"bar": "bar", "bar": half}.add
+{"bar": "bar", "bar": i}.Qux
+{"bar": "bar", "bar": i}.String
+{"bar": "bar", "foo": 0.5}.i64
+{"bar": "bar", "foo": i64}?.Qux
+{"bar": "bar", "foo": score}.f32
+{"bar": "bar"}.String?.foo
 {"bar": "bar"}.array
-{"bar": "bar"}.f32
 {"bar": "bar"}.f64
+{"bar": "bar"}.greet
 {"bar": "bar"}.list
 {"bar": "bar"}.ok
-{"bar": "bar"}?.Bar
-{"bar": "bar"}?.greet
+{"bar": "bar"}?.Qux
+{"bar": "bar"}?.array
 {"bar": "bar"}?.half
-{"bar": "bar"}?.i
-{"bar": "foo", "foo": 0.5}.add
-{"bar": "foo", "foo": 1}.String?.ok
-{"bar": "foo", "foo": greet}.half
-{"bar": "foo", "foo": ok, "bar": f64}?.Bar
-{"bar": "foo", "foo": ok}.Qux
-{"bar": "foo", "foo": true}.ok
-{"bar": "foo"}.Qux
-{"bar": "foo"}.String
-{"bar": "foo"}.add
-{"bar": "foo"}.array
-{"bar": "foo"}.div
+{"bar": "bar"}?.list
+{"bar": "foo", "bar": div}.half
+{"bar": "foo", "foo": f32}.String
+{"bar": "foo", "foo": i64}.ok?.f64
+{"bar": "foo", "foo": ok}?.i64
+{"bar": "foo"}.Bar
 {"bar": "foo"}.f32
+{"bar": "foo"}.foo
+{"bar": "foo"}.half
 {"bar": "foo"}.i
 {"bar": "foo"}.i64
-{"bar": "foo"}.score
-{"bar": "foo"}?.Qux
-{"bar": "foo"}?.Qux?.score
 {"bar": "foo"}?.String
-{"bar": "foo"}?.div
+{"bar": "foo"}?.f32
 {"bar": "foo"}?.foo
+{"bar": "foo"}?.greet
+{"bar": "foo"}?.i
 {"bar": "foo"}?.i32
-{"bar": "foo"}?.i64
+{"bar": "foo"}?.i?.String()
+{"bar": "foo"}?.list
+{"bar": "foo"}?.ok
 {"bar": -0.5}
-{"bar": -1}
-{"bar": -1}?.array
 {"bar": -f32}
-{"bar": 0.5 * f64}
-{"bar": 0.5 + 1}
-{"bar": 0.5 - i32}
-{"bar": 0.5 - i64}
-{"bar": 0.5 < i64}
-{"bar": 0.5 == nil}
-{"bar": 0.5 > 1}.Qux
-{"bar": 0.5, "bar": "bar"}.ok
-{"bar": 0.5, "bar": 0.5}.f32
-{"bar": 0.5, "bar": 1}?.half
-{"bar": 0.5, "foo": array}?.ok
-{"bar": 0.5, "foo": i32, "bar": add}?.Bar
-{"bar": 0.5}.Bar
+{"bar": -f64}
+{"bar": -i32}
+{"bar": 0.5 != nil}
+{"bar": 0.5 * 1}.foo
+{"bar": 0.5, "bar": 0.5}.half
+{"bar": 0.5, "bar": add, "foo": i32}.list
+{"bar": 0.5, "bar": i}?.add
+{"bar": 0.5, "bar": list}?.div
+{"bar": 0.5, "bar": nil, "bar": nil}.i32
+{"bar": 0.5, "bar": ok, "foo": 1}?.String
+{"bar": 0.5, "bar": true}.score
+{"bar": 0.5, "foo": 0.5}?.f32
+{"bar": 0.5, "foo": array}?.list
+{"bar": 0.5, "foo": f32}.i32?.Bar
+{"bar": 0.5, "foo": ok}?.array
 {"bar": 0.5}.Qux
 {"bar": 0.5}.String
 {"bar": 0.5}.add
-{"bar": 0.5}.div
-{"bar": 0.5}.div?.array.foo
+{"bar": 0.5}.array
 {"bar": 0.5}.f32
 {"bar": 0.5}.f64
-{"bar": 0.5}.foo
-{"bar": 0.5}.greet
+{"bar": 0.5}.half
+{"bar": 0.5}.i
 {"bar": 0.5}.i32
+{"bar": 0.5}.i64
 {"bar": 0.5}.ok
-{"bar": 0.5}.score
 {"bar": 0.5}?.Bar
+{"bar": 0.5}?.Qux
 {"bar": 0.5}?.String
-{"bar": 0.5}?.add
-{"bar": 0.5}?.array
 {"bar": 0.5}?.div
-{"bar": 0.5}?.f32
 {"bar": 0.5}?.foo
-{"bar": 0.5}?.greet?.i32
+{"bar": 0.5}?.greet
 {"bar": 0.5}?.half
 {"bar": 0.5}?.i
 {"bar": 0.5}?.i32
-{"bar": 0.5}?.i32?.i32
 {"bar": 0.5}?.i64
-{"bar": 1 * i32}
+{"bar": 0.5}?.list
+{"bar": 0.5}?.score
 {"bar": 1 * i}
-{"bar": 1 + i32}
-{"bar": 1 - f32}
+{"bar": 1 ** 0.5}
 {"bar": 1 / 0.5}
-{"bar": 1 < f32}
-{"bar": 1 <= 1}
-{"bar": 1, "bar": "bar"}.i32
-{"bar": 1, "bar": array}?.f32
-{"bar": 1, "bar": false}.array
-{"bar": 1, "bar": greet, "foo": "bar"}?.i64
-{"bar": 1, "bar": i64}?.array
-{"bar": 1, "foo": 0.5}?.String
-{"bar": 1, "foo": add, "foo": f32}?.i
-{"bar": 1, "foo": foo}.div
-{"bar": 1, "foo": i64}.i64
-{"bar": 1}.Bar
-{"bar": 1}.Qux
+{"bar": 1 / f32}
+{"bar": 1 ^ 1}
+{"bar": 1, "bar": add, "foo": "bar"}?.add
+{"bar": 1, "bar": add}.div
+{"bar": 1, "bar": f32}?.Bar
+{"bar": 1, "bar": f64, "foo": array}.ok
+{"bar": 1, "foo": "bar"}.half
+{"bar": 1, "foo": array, "bar": score}?.i
+{"bar": 1, "foo": i}?.list
+{"bar": 1, "foo": i}?.ok
+{"bar": 1, "foo": ok}?.f32
+{"bar": 1, "foo": score}.f64
 {"bar": 1}.String
 {"bar": 1}.add
-{"bar": 1}.div
-{"bar": 1}.f64
+{"bar": 1}.f32
+{"bar": 1}.foo
 {"bar": 1}.greet
 {"bar": 1}.half
 {"bar": 1}.i
-{"bar": 1}.ok
-{"bar": 1}?.Bar
+{"bar": 1}.i32
+{"bar": 1}.list
+{"bar": 1}.score
+{"bar": 1}?.Qux
 {"bar": 1}?.add
-{"bar": 1}?.add?.i32
-{"bar": 1}?.div?.list
+{"bar": 1}?.div
 {"bar": 1}?.f32
 {"bar": 1}?.f64
 {"bar": 1}?.i
 {"bar": 1}?.i32
+{"bar": 1}?.i64
+{"bar": 1}?.list
 {"bar": 1}?.ok
-{"bar": ["bar", score]}
-{"bar": add, "bar": "foo"}.String?.array
-{"bar": add, "bar": 1}?.i64
-{"bar": add, "bar": div}?.f32
-{"bar": add, "bar": foo}
-{"bar": add, "bar": list}.Bar
-{"bar": add, "bar": score}.f64?.f64
-{"bar": add, "foo": "foo"}.i64
-{"bar": add, "foo": f64}?.score
-{"bar": add, "foo": i32}?.half
-{"bar": add, "foo": ok}
-{"bar": add, "foo": score}
+{"bar": add, "bar": half}.div
+{"bar": add, "bar": i, "bar": ok}?.foo
+{"bar": add, "bar": list}
+{"bar": add, "bar": ok, "foo": 1}?.ok
+{"bar": add, "foo": "foo"}?.f64
 {"bar": add}
 {"bar": add}.Qux
 {"bar": add}.String
-{"bar": add}.f64
-{"bar": add}.foo
-{"bar": add}.greet
-{"bar": add}.i32
-{"bar": add}.list
+{"bar": add}.add
+{"bar": add}.array
+{"bar": add}.div
+{"bar": add}.half
+{"bar": add}?.Qux
 {"bar": add}?.String
 {"bar": add}?.add
+{"bar": add}?.array
 {"bar": add}?.div
-{"bar": add}?.i
-{"bar": add}?.i64
-{"bar": add}?.score
-{"bar": any(array, false)}
-{"bar": any(list, ok)}
-{"bar": array, "bar": f64}
-{"bar": array, "bar": false, "bar": i}?.Qux
-{"bar": array, "bar": false}.Qux
-{"bar": array, "bar": half}.i32
-{"bar": array, "bar": i64}.i64
-{"bar": array, "bar": score}
-{"bar": array, "foo": "foo"}?.array
-{"bar": array, "foo": add == add}
-{"bar": array, "foo": count(list, true)}.add
+{"bar": add}?.f64
+{"bar": add}?.f64 != half
+{"bar": add}?.half
+{"bar": add}?.ok
+{"bar": add}?.score?.div
+{"bar": array, "bar": "bar"}?.i
+{"bar": array, "bar": array}?.foo
+{"bar": array, "bar": f32}
+{"bar": array, "bar": nil}.i64
+{"bar": array, "foo": f32}?.String
+{"bar": array, "foo": f64}
+{"bar": array, "foo": half}?.add
+{"bar": array, "foo": i32}
+{"bar": array, "foo": score}
 {"bar": array}
 {"bar": array}.Bar
-{"bar": array}.Qux
-{"bar": array}.String
-{"bar": array}.add
-{"bar": array}.f32
-{"bar": array}.half?.foo
+{"bar": array}.div
+{"bar": array}.div?.Qux
+{"bar": array}.greet
 {"bar": array}.i
 {"bar": array}.i64
-{"bar": array}?.Bar
+{"bar": array}.list
+{"bar": array}.score
+{"bar": array}?.add?.ok
 {"bar": array}?.div
+{"bar": array}?.f64
 {"bar": array}?.greet
 {"bar": array}?.half
-{"bar": array}?.i32
 {"bar": array}?.i64
 {"bar": array}?.ok
-{"bar": div != greet}
-{"bar": div, "bar": "bar", "bar": foo}.greet
-{"bar": div, "bar": "bar", "foo": 1}?.div
-{"bar": div, "bar": greet}?.i32
-{"bar": div, "bar": i32}?.array
-{"bar": div, "foo": div}?.list
-{"bar": div, "foo": greet, "foo": 1}?.score?.Qux
-{"bar": div, "foo": i}?.i
-{"bar": div, "foo": list}.f64
-{"bar": div, "foo": ok}?.i64
+{"bar": div, "bar": array, "bar": 0.5}.i64
+{"bar": div, "bar": div}?.f32
+{"bar": div, "bar": foo}.foo
+{"bar": div, "bar": ok}
+{"bar": div, "foo": 1, "bar": ok}.Qux
+{"bar": div, "foo": false}?.String
+{"bar": div, "foo": foo, "foo": score}.Bar
+{"bar": div, "foo": greet}.i
+{"bar": div, "foo": greet}?.ok
 {"bar": div, "foo": score}
 {"bar": div}
-{"bar": div}.add
-{"bar": div}.div
+{"bar": div}.array
 {"bar": div}.f32
-{"bar": div}.f32?.score
-{"bar": div}.half
-{"bar": div}.i32
-{"bar": div}.i64
-{"bar": div}.score
-{"bar": div}?.div
-{"bar": div}?.div?.f32
-{"bar": div}?.foo
+{"bar": div}.f64
+{"bar": div}.i64?.Qux
+{"bar": div}.list
+{"bar": div}.ok
+{"bar": div}?.Bar
+{"bar": div}?.array
+{"bar": div}?.f64
+{"bar": div}?.greet
 {"bar": div}?.half
-{"bar": div}?.i
-{"bar": div}?.i64
 {"bar": div}?.list
 {"bar": div}?.ok
-{"bar": f32 ** 1}
-{"bar": f32 - i32}
-{"bar": f32, "bar": true, "bar": list}?.Bar
-{"bar": f32, "foo": i32}
-{"bar": f32, "foo": ok, "foo": f32}.half
-{"bar": f32, "foo": score}?.greet
+{"bar": div}?.score
+{"bar": f32 ** i}
+{"bar": f32 - 0.5}
+{"bar": f32 >= 0.5}
+{"bar": f32 ^ 1}
+{"bar": f32, "bar": "foo"}.add
+{"bar": f32, "bar": false}?.Bar
+{"bar": f32, "bar": true}?.String
+{"bar": f32, "foo": add, "foo": false}?.String
+{"bar": f32, "foo": f32}.ok
+{"bar": f32, "foo": f64}
+{"bar": f32, "foo": half, "foo": ok}
+{"bar": f32, "foo": half}
+{"bar": f32, "foo": list}?.f32
+{"bar": f32, "foo": nil}?.f64?.foo
 {"bar": f32}
-{"bar": f32}.Bar
-{"bar": f32}.Qux?.i64
-{"bar": f32}.String
-{"bar": f32}.add
-{"bar": f32}.half
-{"bar": f32}.list
-{"bar": f32}?.String?.score
+{"bar": f32}.Qux
+{"bar": f32}.div
+{"bar": f32}.f64
+{"bar": f32}.greet
+{"bar": f32}.i
+{"bar": f32}.i32
+{"bar": f32}.i64
+{"bar": f32}?.Bar
+{"bar": f32}?.String
+{"bar": f32}?.array
 {"bar": f32}?.f64
-{"bar": f32}?.foo
-{"bar": f32}?.i32
-{"bar": f32}?.i64
+{"bar": f32}?.half
 {"bar": f32}?.list
-{"bar": f32}?.score
-{"bar": f64, "bar": 0.5}.div
-{"bar": f64, "bar": i}
-{"bar": f64, "bar": nil}?.f64
-{"bar": f64, "foo": "foo"}?.half
-{"bar": f64, "foo": 0.5, "bar": foo}?.half
-{"bar": f64, "foo": f64}.foo
-{"bar": f64, "foo": i32}
+{"bar": f64 + 1}
+{"bar": f64 == i32}
+{"bar": f64 > 0.5}
+{"bar": f64 ^ i32}
+{"bar": f64, "bar": "bar"}.i
+{"bar": f64, "bar": foo}?.i
+{"bar": f64, "bar": i64}?.i64
+{"bar": f64, "bar": i}.f64
+{"bar": f64, "bar": true}?.i
+{"bar": f64, "foo": 0.5, "foo": score}.ok
+{"bar": f64, "foo": 1}.f32
+{"bar": f64, "foo": f64}?.score
+{"bar": f64, "foo": i}?.Qux?.f64
 {"bar": f64}
-{"bar": f64}.String
-{"bar": f64}.div?.String()
-{"bar": f64}.f32
+{"bar": f64}.array
+{"bar": f64}.f32?.Bar
 {"bar": f64}.f64
-{"bar": f64}.f64?.list
-{"bar": f64}.greet
-{"bar": f64}.half
+{"bar": f64}.foo
 {"bar": f64}.i
+{"bar": f64}.i32
 {"bar": f64}.ok
 {"bar": f64}?.Bar
-{"bar": f64}?.Qux
-{"bar": f64}?.f64
-{"bar": f64}?.half
-{"bar": f64}?.i32
+{"bar": f64}?.Bar?.Qux
+{"bar": f64}?.add
+{"bar": f64}?.div
+{"bar": f64}?.f32
+{"bar": f64}?.foo
+{"bar": f64}?.i
 {"bar": f64}?.i64
-{"bar": f64}?.score
-{"bar": false, "bar": 0.5, "bar": foo}.add
-{"bar": false, "foo": greet, "foo": i64}.div
-{"bar": false}.add
-{"bar": false}.div
+{"bar": f64}?.list
+{"bar": f64}?.ok
+{"bar": false, "bar": array}?.list
+{"bar": false, "bar": i32}?.div
+{"bar": false, "bar": i}?.i64
+{"bar": false, "bar": nil}.ok
+{"bar": false}.Bar
+{"bar": false}.Qux
+{"bar": false}.array
+{"bar": false}.f32
 {"bar": false}.f64
-{"bar": false}.foo
-{"bar": false}.greet
 {"bar": false}.half
+{"bar": false}.i
 {"bar": false}.i32
-{"bar": false}.list
 {"bar": false}.ok
 {"bar": false}.score
+{"bar": false}?.Bar
 {"bar": false}?.array
-{"bar": false}?.greet
-{"bar": false}?.i32
-{"bar": false}?.ok?.Qux?.score()
-{"bar": false}?.score
-{"bar": first(list)}
-{"bar": float(f32)}
-{"bar": foo, "bar": 0.5}.div
-{"bar": foo, "bar": div}.array
-{"bar": foo, "bar": half}
-{"bar": foo, "bar": list}.f32
-{"bar": foo, "foo": greet}?.div
-{"bar": foo, "foo": i32}.score
-{"bar": foo, "foo": true}?.f32
+{"bar": false}?.div
+{"bar": false}?.foo
+{"bar": false}?.half
+{"bar": false}?.i
+{"bar": false}?.list
+{"bar": false}?.ok
+{"bar": filter(list, ok)}
+{"bar": float(0.5)}
+{"bar": floor(0.5)}.score
+{"bar": floor(i32)}
+{"bar": foo != nil, "foo": array}
+{"bar": foo, "bar": "foo", "bar": score}?.score
+{"bar": foo, "bar": 1, "bar": score}?.ok
+{"bar": foo, "bar": greet}
+{"bar": foo, "bar": i}?.i
+{"bar": foo, "bar": score}?.ok
+{"bar": foo, "foo": 0.5, "foo": ok}?.half
+{"bar": foo, "foo": 0.5}.score
+{"bar": foo, "foo": 1, "foo": i}?.add
+{"bar": foo, "foo": f64}
+{"bar": foo, "foo": f64}.Bar
 {"bar": foo.Bar}
 {"bar": foo.String()}
-{"bar": foo?.Qux}?.foo
+{"bar": foo?.Qux, "bar": f32}
 {"bar": foo?.String}
 {"bar": foo}
-{"bar": foo}.Qux
-{"bar": foo}.String
+{"bar": foo}.Bar
 {"bar": foo}.array
-{"bar": foo}.div
-{"bar": foo}.f64
+{"bar": foo}.f32
 {"bar": foo}.half
-{"bar": foo}.half?.list(i32).array
 {"bar": foo}.i
 {"bar": foo}.list
 {"bar": foo}.ok
-{"bar": foo}?.div
-{"bar": foo}?.f64
+{"bar": foo}?.Bar
+{"bar": foo}?.add
 {"bar": foo}?.greet
 {"bar": foo}?.i
+{"bar": foo}?.i32
 {"bar": foo}?.i64
 {"bar": foo}?.list
-{"bar": greet, "bar": foo}
-{"bar": greet, "bar": nil}.f64
-{"bar": greet, "foo": foo}
+{"bar": foo}?.ok
+{"bar": foo}?.score
+{"bar": get(list, i32)}
+{"bar": greet("foo")}
+{"bar": greet, "bar": 0.5}.i32
+{"bar": greet, "bar": 1}.Bar
+{"bar": greet, "bar": f32}.Bar
+{"bar": greet, "bar": i32}
+{"bar": greet, "bar": not ok}
+{"bar": greet, "foo": "bar"}.ok
+{"bar": greet, "foo": f64}
+{"bar": greet, "foo": false, "bar": ok}.i32
+{"bar": greet, "foo": i32}
 {"bar": greet}
-{"bar": greet}.Qux
-{"bar": greet}.add
+{"bar": greet}.Bar
 {"bar": greet}.array
-{"bar": greet}.div
-{"bar": greet}.foo
-{"bar": greet}.i
-{"bar": greet}.i32
-{"bar": greet}.ok
-{"bar": greet}.score
-{"bar": greet}?.Bar
-{"bar": greet}?.String
-{"bar": greet}?.add
+{"bar": greet}.f32
+{"bar": greet}.greet
+{"bar": greet}.half
+{"bar": greet}.list
+{"bar": greet}?.Qux
+{"bar": greet}?.div
 {"bar": greet}?.f32
-{"bar": greet}?.foo?.foo
+{"bar": greet}?.f64
+{"bar": greet}?.greet
 {"bar": greet}?.half
-{"bar": greet}?.i
-{"bar": greet}?.list
+{"bar": greet}?.i32
 {"bar": greet}?.ok
-{"bar": half(0.5), "bar": ok}
-{"bar": half(0.5)}
-{"bar": half(0.5)}?.array
-{"bar": half, "bar": "foo", "bar": ok}?.String
-{"bar": half, "bar": array}?.div?.i32
-{"bar": half, "bar": div}
-{"bar": half, "bar": f32}
-{"bar": half, "bar": greet}?.i64
+{"bar": greet}?.score
+{"bar": groupBy(array, f32)}
+{"bar": half == nil}
+{"bar": half(f64)}
+{"bar": half, "bar": add, "bar": f64}?.i32
+{"bar": half, "bar": foo}
 {"bar": half, "bar": list}
-{"bar": half, "bar": score, "bar": i == f32}
 {"bar": half, "bar": score}
-{"bar": half, "foo": array}
-{"bar": half, "foo": f64 == i64}
-{"bar": half, "foo": greet}
-{"bar": half, "foo": i64}.array
-{"bar": half, "foo": list}?.list?.ok
+{"bar": half, "foo": 1}?.i64
+{"bar": half, "foo": list}
+{"bar": half, "foo": ok, "bar": i}
+{"bar": half, "foo": ok}.Qux
+{"bar": half, "foo": true}?.String
 {"bar": half}
+{"bar": half}.Bar?.i
+{"bar": half}.Qux
 {"bar": half}.String
-{"bar": half}.String?.score
+{"bar": half}.div?.i
+{"bar": half}.f32
+{"bar": half}.foo
 {"bar": half}.half
 {"bar": half}.i32
-{"bar": half}.i64
-{"bar": half}.ok
-{"bar": half}.score
-{"bar": half}?.Qux
-{"bar": half}?.Qux?.f32
-{"bar": half}?.div
+{"bar": half}.list
+{"bar": half}.list?.String()
+{"bar": half}?.Bar
+{"bar": half}?.String
+{"bar": half}?.array
 {"bar": half}?.f32
-{"bar": half}?.foo?.f32()
-{"bar": half}?.half
-{"bar": half}?.half?.f32
-{"bar": half}?.i
-{"bar": i ** 0.5}
-{"bar": i + i64}
-{"bar": i .. i32}
-{"bar": i .. i}
-{"bar": i > i32}
-{"bar": i >= 0.5, "bar": array}
-{"bar": i >= i}
-{"bar": i, "bar": 0.5}?.Qux
-{"bar": i, "bar": foo}.foo
-{"bar": i, "bar": nil}?.f32
-{"bar": i, "foo": 1 >= f64}
-{"bar": i, "foo": array}.array
-{"bar": i, "foo": f64}.i64
-{"bar": i, "foo": greet}?.foo
-{"bar": i32 + 0.5}
-{"bar": i32 < i32}
-{"bar": i32 <= f64}
-{"bar": i32, "bar": "foo"}?.half
-{"bar": i32, "foo": f64}?.foo
-{"bar": i32, "foo": foo, "foo": i32}?.i32?.String()
-{"bar": i32, "foo": i64, "bar": true}?.i64
-{"bar": i32, "foo": i64}.half
-{"bar": i32, "foo": list}
-{"bar": i32, "foo": score, "foo": 1}.array
-{"bar": i32, "foo": score, "foo": greet}.add
-{"bar": i32, "foo": score, "foo": ok}.foo
+{"bar": half}?.greet
+{"bar": half}?.i32
+{"bar": half}?.list
+{"bar": i % i32}
+{"bar": i ** f64}
+{"bar": i < 1}?.half
+{"bar": i, "bar": 1}.add
+{"bar": i, "bar": 1}?.i64
+{"bar": i, "bar": array}?.half
+{"bar": i, "bar": div}.ok
+{"bar": i, "bar": f64, "bar": "foo"}?.foo
+{"bar": i, "bar": f64, "bar": nil}.i32
+{"bar": i, "bar": score}
+{"bar": i, "foo": half}
+{"bar": i, "foo": i32}?.score
+{"bar": i, "foo": nil}?.String
+{"bar": i32 ^ 0.5}
+{"bar": i32 ^ f64}
+{"bar": i32, "bar": list}
+{"bar": i32, "foo": "bar"}.i64
+{"bar": i32, "foo": array}.div
+{"bar": i32, "foo": f64, "foo": add}.f64
+{"bar": i32, "foo": foo}?.add
+{"bar": i32, "foo": ok}.ok
 {"bar": i32}
-{"bar": i32}.Bar
+{"bar": i32}.Qux
+{"bar": i32}.f64
 {"bar": i32}.i
-{"bar": i32}.i64
+{"bar": i32}.i32
 {"bar": i32}.list
-{"bar": i32}.score?.f32
-{"bar": i32}?.String
+{"bar": i32}.ok
+{"bar": i32}.score
+{"bar": i32}?.Qux
+{"bar": i32}?.add
+{"bar": i32}?.array
 {"bar": i32}?.div
 {"bar": i32}?.f32
-{"bar": i32}?.foo
-{"bar": i32}?.greet
-{"bar": i32}?.half
-{"bar": i32}?.i
-{"bar": i32}?.list?.list
+{"bar": i32}?.i32
+{"bar": i32}?.list
 {"bar": i32}?.ok
-{"bar": i32}?.score
-{"bar": i64 != f32, "bar": score}
-{"bar": i64 ** f64}
-{"bar": i64 / f64}
-{"bar": i64, "bar": "bar", "foo": i64}.array
-{"bar": i64, "bar": foo}.list
-{"bar": i64, "bar": greet, "foo": score}.array
-{"bar": i64, "bar": half}?.f64
-{"bar": i64, "bar": i64}?.Qux?.array()
-{"bar": i64, "bar": list}
-{"bar": i64, "foo": "foo"}.Bar
-{"bar": i64, "foo": 0.5, "foo": list}.i64
-{"bar": i64, "foo": f32, "foo": nil}.i32
-{"bar": i64, "foo": f32}?.half
-{"bar": i64, "foo": i, "foo": greet}.array
-{"bar": i64, "foo": nil}.add
-{"bar": i64, "foo": nil}?.Qux
+{"bar": i64 + 1}
+{"bar": i64 <= 0.5}
+{"bar": i64 == 0.5}
+{"bar": i64 in array}
+{"bar": i64, "bar": !ok}
+{"bar": i64, "bar": 0.5}.f32
+{"bar": i64, "bar": greet}.array
+{"bar": i64, "bar": score}.ok
+{"bar": i64, "foo": nil}?.i32
+{"bar": i64, "foo": ok}
+{"bar": i64, "foo": ok}?.f32
 {"bar": i64}
-{"bar": i64}.add
-{"bar": i64}.array
+{"bar": i64}.array?.Bar
 {"bar": i64}.div
-{"bar": i64}.div?.i64
 {"bar": i64}.f32
-{"bar": i64}.foo
-{"bar": i64}.greet
-{"bar": i64}.i64
+{"bar": i64}.f64
+{"bar": i64}.i
 {"bar": i64}.list
 {"bar": i64}.ok
-{"bar": i64}?.Qux
-{"bar": i64}?.String
-{"bar": i64}?.array
-{"bar": i64}?.array?.foo
+{"bar": i64}.score
 {"bar": i64}?.div
 {"bar": i64}?.f32
-{"bar": i64}?.i64
+{"bar": i64}?.f64
+{"bar": i64}?.half
+{"bar": i64}?.i
+{"bar": i64}?.i32
+{"bar": i64}?.i?.ok
 {"bar": i64}?.list
-{"bar": i64}?.ok
-{"bar": i64}?.score
+{"bar": int(f64)}
 {"bar": i}
-{"bar": i}.Bar
-{"bar": i}.String
+{"bar": i}.add
 {"bar": i}.array
-{"bar": i}.div
+{"bar": i}.div?.Qux.div
 {"bar": i}.f64
-{"bar": i}.foo
-{"bar": i}.greet
 {"bar": i}.half
 {"bar": i}.i
-{"bar": i}.i32
 {"bar": i}.i64
-{"bar": i}.list?.list
-{"bar": i}?.Qux
+{"bar": i}.list
 {"bar": i}?.String
-{"bar": i}?.add
+{"bar": i}?.array
+{"bar": i}?.f64
 {"bar": i}?.foo
 {"bar": i}?.greet
-{"bar": i}?.list
-{"bar": list, "bar": 1}?.f64
-{"bar": list, "bar": div}
-{"bar": list, "bar": f32, "bar": i64}.Bar
-{"bar": list, "bar": f32, "bar": ok}.add
-{"bar": list, "bar": f64}.foo
-{"bar": list, "bar": false, "bar": 1}?.f32
-{"bar": list, "bar": i32}.half
-{"bar": list, "bar": ok}
-{"bar": list, "foo": div, "foo": ok}?.i64
-{"bar": list, "foo": f64, "foo": list}.half
-{"bar": list, "foo": half}?.Qux
-{"bar": list, "foo": i}
-{"bar": list, "foo": list}
-{"bar": list, "foo": ok, "foo": f64}?.half
+{"bar": i}?.i
+{"bar": i}?.i32
+{"bar": i}?.i64
+{"bar": i}?.score
+{"bar": list == nil}
+{"bar": list, "bar": half}?.Bar
+{"bar": list, "bar": score}
+{"bar": list, "foo": "foo"}.String
+{"bar": list, "foo": 1, "foo": nil}.score
+{"bar": list, "foo": 1, "foo": score}?.array
+{"bar": list, "foo": array}?.i64
+{"bar": list, "foo": f64}.div?.Qux
+{"bar": list, "foo": f64}.list
+{"bar": list, "foo": half}?.f32
+{"bar": list, "foo": i64}?.array
+{"bar": list, "foo": nil}.i64
+{"bar": list[i32:i32]}
 {"bar": list}
-{"bar": list}.Bar
+{"bar": list}.String
 {"bar": list}.add
-{"bar": list}.f32
+{"bar": list}.array
+{"bar": list}.array?.i64
 {"bar": list}.f64
 {"bar": list}.greet
-{"bar": list}.score
+{"bar": list}.i
+{"bar": list}.list
+{"bar": list}?.Bar
+{"bar": list}?.Qux
 {"bar": list}?.add
-{"bar": list}?.add?.array
 {"bar": list}?.div
-{"bar": list}?.half
-{"bar": list}?.i32
-{"bar": list}?.list
+{"bar": list}?.f64
+{"bar": list}?.i64
 {"bar": list}?.score
-{"bar": map(list, i32)}
-{"bar": min(0.5)}
-{"bar": min(f32)}
+{"bar": lower("bar")}
+{"bar": map(array, #)}
+{"bar": map(array, i)}
+{"bar": map(list, #)}
 {"bar": nil != "bar"}
-{"bar": nil != false}
-{"bar": nil == "foo"}
-{"bar": nil == 1}
-{"bar": nil == f64}
-{"bar": nil, "bar": div}.f32
-{"bar": nil, "bar": greet, "foo": "bar"}?.i64
-{"bar": nil, "bar": greet}.score
-{"bar": nil, "bar": i}.f64
-{"bar": nil, "foo": 0.5}?.array
-{"bar": nil, "foo": f64}?.add
-{"bar": nil, "foo": half}?.foo
-{"bar": nil}.String
+{"bar": nil != nil}
+{"bar": nil == 0.5}
+{"bar": nil == nil}
+{"bar": nil, "bar": "bar"}?.i32
+{"bar": nil, "bar": add, "bar": i}.add
+{"bar": nil, "bar": foo}?.list
+{"bar": nil, "foo": "foo"}.f64
+{"bar": nil, "foo": 1, "foo": add}.ok
+{"bar": nil, "foo": foo}?.add
+{"bar": nil, "foo": i}?.f64
+{"bar": nil, "foo": list}?.f32
+{"bar": nil}.Bar
 {"bar": nil}.add
-{"bar": nil}.array
+{"bar": nil}.div
 {"bar": nil}.f32
 {"bar": nil}.foo
+{"bar": nil}.greet
 {"bar": nil}.half
-{"bar": nil}?.Bar
+{"bar": nil}.i
+{"bar": nil}.i32
+{"bar": nil}.i32?.greet
+{"bar": nil}.i64
+{"bar": nil}.i?.f64
+{"bar": nil}.list
+{"bar": nil}.ok
+{"bar": nil}?.Qux
+{"bar": nil}?.String
 {"bar": nil}?.add
-{"bar": nil}?.array
+{"bar": nil}?.div
 {"bar": nil}?.f32
 {"bar": nil}?.f64
-{"bar": nil}?.foo
-{"bar": nil}?.foo?.i32
-{"bar": nil}?.greet
 {"bar": nil}?.half
+{"bar": nil}?.i
 {"bar": nil}?.i32
-{"bar": nil}?.i64
 {"bar": nil}?.list
 {"bar": nil}?.ok
-{"bar": ok or ok}
-{"bar": ok || ok}
-{"bar": ok, "bar": list}
-{"bar": ok, "bar": nil == half}.f64
-{"bar": ok, "foo": div, "bar": "bar"}.Qux
-{"bar": ok, "foo": i32, "bar": 1}.score
+{"bar": none(list, ok)}
+{"bar": not true}
+{"bar": ok ? "bar" : i}
+{"bar": ok ? i32 : "foo"}
+{"bar": ok ? nil : greet}
+{"bar": ok, "bar": 1, "foo": f64}.half
+{"bar": ok, "bar": array}
+{"bar": ok, "bar": i64, "foo": 1}?.Qux
+{"bar": ok, "bar": i}
+{"bar": ok, "bar": list}?.div
+{"bar": ok, "bar": ok}.f32
+{"bar": ok, "foo": 0.5}?.score
+{"bar": ok, "foo": 1}.i
+{"bar": ok, "foo": greet}
+{"bar": ok, "foo": half}
+{"bar": ok, "foo": list}
+{"bar": ok, "foo": list}?.f64
+{"bar": ok, "foo": nil}?.i32
+{"bar": ok, "foo": ok}.div
 {"bar": ok}
-{"bar": ok}.String
-{"bar": ok}.add
-{"bar": ok}.array
-{"bar": ok}.i
+{"bar": ok}.Bar
+{"bar": ok}.div
+{"bar": ok}.f32
+{"bar": ok}.greet
+{"bar": ok}.i32
 {"bar": ok}.i64
+{"bar": ok}.list
 {"bar": ok}.ok
+{"bar": ok}.score
 {"bar": ok}?.Qux
-{"bar": ok}?.array
-{"bar": ok}?.f64
-{"bar": ok}?.foo
-{"bar": ok}?.greet
-{"bar": ok}?.i
+{"bar": ok}?.add
+{"bar": ok}?.f32
 {"bar": ok}?.i32
 {"bar": ok}?.i64
-{"bar": score != score}
-{"bar": score, "bar": 0.5}?.Bar
-{"bar": score, "bar": div}
-{"bar": score, "bar": foo}
-{"bar": score, "bar": i64}.div
-{"bar": score, "bar": i}
-{"bar": score, "foo": greet}
+{"bar": ok}?.list
+{"bar": ok}?.score
+{"bar": one(list, false)}
+{"bar": reduce(array, i)}.i64
+{"bar": reduce(list, half)}
+{"bar": score != add}
+{"bar": score(i)}
+{"bar": score, "bar": "bar", "bar": "foo"}?.f32
+{"bar": score, "bar": add}.String
+{"bar": score, "bar": i64}.f32
+{"bar": score, "bar": nil}.i
+{"bar": score, "foo": div}
+{"bar": score, "foo": foo}.i
+{"bar": score, "foo": half, "foo": i}?.array
+{"bar": score, "foo": half}
+{"bar": score, "foo": score}?.greet
 {"bar": score}
-{"bar": score}.Bar
 {"bar": score}.add
 {"bar": score}.array
 {"bar": score}.div
 {"bar": score}.f64
-{"bar": score}.i32
-{"bar": score}.i64
+{"bar": score}.foo
+{"bar": score}.half
 {"bar": score}.list
-{"bar": score}.ok
-{"bar": score}.score
+{"bar": score}?.String
+{"bar": score}?.array
 {"bar": score}?.f32
-{"bar": score}?.f64
+{"bar": score}?.foo
+{"bar": score}?.half
+{"bar": score}?.i
 {"bar": score}?.i32
 {"bar": score}?.list
 {"bar": score}?.score
-{"bar": string(array)}
-{"bar": toJSON(array)}
-{"bar": toJSON(i)}.i64?.i64
-{"bar": toJSON(i32)}
-{"bar": true, "bar": false}.Bar
-{"bar": true, "bar": foo}?.String
-{"bar": true, "foo": 0.5}?.i
-{"bar": true, "foo": div}.score
-{"bar": true, "foo": foo}.div
+{"bar": string(0.5)}
+{"bar": string(i64)}
+{"bar": string(ok)}
+{"bar": toJSON(list)}
+{"bar": true == false}
+{"bar": true, "bar": f64}?.score
+{"bar": true, "bar": i32}.array
+{"bar": true, "foo": nil}?.f32
 {"bar": true}.Bar
-{"bar": true}.Qux?.greet()
-{"bar": true}.f32
-{"bar": true}.f64
+{"bar": true}.Qux
+{"bar": true}.String
+{"bar": true}.div
 {"bar": true}.half
-{"bar": true}.i
-{"bar": true}.list?.String()
-{"bar": true}.score
+{"bar": true}.i32
 {"bar": true}?.Bar
+{"bar": true}?.add
+{"bar": true}?.array
+{"bar": true}?.div
+{"bar": true}?.half
+{"bar": true}?.i32
 {"bar": true}?.i64
-{"bar": true}?.list
-{"bar": type(f64)}
-{"bar": type(greet)}
-{"bar": {"foo": "bar", "bar": "bar", "bar": nil}}
-{"foo": "bar", "bar": i32}.half
-{"foo": "bar", "bar": nil}?.add?.i64
+{"bar": type(greet)}.Bar
+{"bar": type(half)}
+{"bar": type(score)}
+{"foo": !ok}
+{"foo": "bar" < "bar"}
+{"foo": "bar" > "bar"}
+{"foo": "bar", "bar": list}.div
+{"foo": "bar", "bar": nil}.f64
+{"foo": "bar", "foo": 0.5}?.add
+{"foo": "bar", "foo": 0.5}?.list
+{"foo": "bar", "foo": array}?.f64?.list()
+{"foo": "bar", "foo": list}.list
 {"foo": "bar"}.Bar
 {"foo": "bar"}.Qux
 {"foo": "bar"}.String
-{"foo": "bar"}.array
-{"foo": "bar"}.f64
+{"foo": "bar"}.foo
 {"foo": "bar"}.half
 {"foo": "bar"}.i
 {"foo": "bar"}.i64
-{"foo": "bar"}.list
-{"foo": "bar"}.ok
+{"foo": "bar"}?.Bar
+{"foo": "bar"}?.String
 {"foo": "bar"}?.add
-{"foo": "bar"}?.div?.ok
+{"foo": "bar"}?.array
+{"foo": "bar"}?.div
+{"foo": "bar"}?.f32
 {"foo": "bar"}?.f64
 {"foo": "bar"}?.foo
 {"foo": "bar"}?.half
-{"foo": "foo" != "bar"}
-{"foo": "foo", "bar": nil}?.String
-{"foo": "foo", "foo": add, "foo": "foo"}?.i
-{"foo": "foo", "foo": div}.i64
-{"foo": "foo", "foo": greet}.array
-{"foo": "foo", "foo": i, "bar": greet}?.score
-{"foo": "foo", "foo": i32, "bar": f32}.greet
-{"foo": "foo", "foo": i}?.foo
-{"foo": "foo", "foo": list}.f32
-{"foo": "foo"}.Bar
-{"foo": "foo"}.array
+{"foo": "bar"}?.i32
+{"foo": "bar"}?.score
+{"foo": "foo" <= "foo"}
+{"foo": "foo" endsWith "foo"}
+{"foo": "foo", "bar": false}.greet
+{"foo": "foo", "bar": half}?.String
+{"foo": "foo", "bar": list, "bar": div}?.String
+{"foo": "foo", "foo": add}?.f32
+{"foo": "foo"}.Qux
+{"foo": "foo"}.div
 {"foo": "foo"}.f32
-{"foo": "foo"}.foo
-{"foo": "foo"}.greet
-{"foo": "foo"}.i64
-{"foo": "foo"}?.Bar
-{"foo": "foo"}?.add
+{"foo": "foo"}.i
+{"foo": "foo"}.i32
+{"foo": "foo"}.list
 {"foo": "foo"}?.div
-{"foo": "foo"}?.greet
-{"foo": "foo"}?.half
+{"foo": "foo"}?.f32
+{"foo": "foo"}?.foo
+{"foo": "foo"}?.i
+{"foo": "foo"}?.i32
 {"foo": "foo"}?.score
+{"foo": -0.5}
 {"foo": -1}
+{"foo": -f64}
 {"foo": -i64}
-{"foo": -i}
-{"foo": 0.5 ** i64}
-{"foo": 0.5 - 0.5}
+{"foo": 0.5 != 0.5}
+{"foo": 0.5 ** f64}
+{"foo": 0.5 < i64}.div
 {"foo": 0.5 <= 0.5}
-{"foo": 0.5 > i64}
-{"foo": 0.5, "bar": 1}.half
-{"foo": 0.5, "bar": add}.Bar
-{"foo": 0.5, "bar": div}.array
-{"foo": 0.5, "bar": i32}?.String
-{"foo": 0.5, "bar": score, "foo": score}.half
-{"foo": 0.5, "foo": 1, "foo": list}.div
-{"foo": 0.5, "foo": nil}?.div
-{"foo": 0.5, "foo": nil}?.i64
-{"foo": 0.5}.Bar
-{"foo": 0.5}.Qux
+{"foo": 0.5, "bar": 0.5}.String
+{"foo": 0.5, "bar": 0.5}.foo
+{"foo": 0.5, "bar": 0.5}?.score
+{"foo": 0.5, "bar": 1}?.div
+{"foo": 0.5, "bar": i64}.i32
+{"foo": 0.5, "bar": list}?.i64
+{"foo": 0.5, "foo": 1}.Qux
+{"foo": 0.5, "foo": array}.i64
+{"foo": 0.5, "foo": f64}.i
+{"foo": 0.5, "foo": false, "bar": list}.add
+{"foo": 0.5, "foo": greet}.i32
+{"foo": 0.5, "foo": score}.foo
+{"foo": 0.5}.Qux?.half
+{"foo": 0.5}.String
+{"foo": 0.5}.add
 {"foo": 0.5}.array
+{"foo": 0.5}.div
 {"foo": 0.5}.f32
-{"foo": 0.5}.f64
-{"foo": 0.5}.greet
 {"foo": 0.5}.half
-{"foo": 0.5}.i
 {"foo": 0.5}.i64
 {"foo": 0.5}.list
-{"foo": 0.5}.ok
-{"foo": 0.5}?.Bar?.i
+{"foo": 0.5}.score
+{"foo": 0.5}?.Bar
 {"foo": 0.5}?.String
-{"foo": 0.5}?.add
-{"foo": 0.5}?.array
-{"foo": 0.5}?.array?.score
-{"foo": 0.5}?.foo
-{"foo": 0.5}?.greet
+{"foo": 0.5}?.div
+{"foo": 0.5}?.f32
+{"foo": 0.5}?.f64
 {"foo": 0.5}?.half
-{"foo": 0.5}?.i64
+{"foo": 0.5}?.i
+{"foo": 0.5}?.list
 {"foo": 0.5}?.ok
-{"foo": 1 + 0.5}
-{"foo": 1 / 0.5}
 {"foo": 1 / i64}
-{"foo": 1 < i32}?.i64
-{"foo": 1 not in array}
-{"foo": 1, "bar": 0.5}.array
-{"foo": 1, "bar": div}.f32
-{"foo": 1, "bar": f32}.Qux?.half?.list
-{"foo": 1, "bar": i64, "foo": 0.5}.list
-{"foo": 1, "bar": i64}?.ok
-{"foo": 1, "bar": score}.foo
-{"foo": 1, "foo": 0.5}.f32
-{"foo": 1, "foo": array}?.array
-{"foo": 1, "foo": ok}.add
-{"foo": 1, "foo": true}?.Qux
+{"foo": 1 == f32}
+{"foo": 1, "bar": nil}?.add
+{"foo": 1, "bar": score}.greet
+{"foo": 1, "foo": 1}.f64
+{"foo": 1, "foo": f64}.i
+{"foo": 1, "foo": false}?.f32
+{"foo": 1, "foo": half}?.f32
+{"foo": 1, "foo": ok}.Bar
+{"foo": 1, "foo": ok}.f32
+{"foo": 1, "foo": ok}.i32
+{"foo": 1, "foo": score}.half
+{"foo": 1}.Bar
 {"foo": 1}.add
+{"foo": 1}.div
 {"foo": 1}.f32
+{"foo": 1}.f64
 {"foo": 1}.foo
 {"foo": 1}.greet
 {"foo": 1}.half
+{"foo": 1}.i
 {"foo": 1}.i64
 {"foo": 1}.list
-{"foo": 1}.ok
-{"foo": 1}?.Bar
+{"foo": 1}?.String
 {"foo": 1}?.add
-{"foo": 1}?.div
-{"foo": 1}?.f32
-{"foo": 1}?.foo
+{"foo": 1}?.f64
 {"foo": 1}?.greet
 {"foo": 1}?.half
-{"foo": 1}?.i
-{"foo": 1}?.i32
-{"foo": 1}?.score
-{"foo": abs(0.5)}
-{"foo": add, "bar": 0.5}.i
-{"foo": add, "bar": nil}.score
-{"foo": add, "bar": ok}
-{"foo": add, "bar": score}.half
-{"foo": add, "foo": "bar"}?.String
-{"foo": add, "foo": half, "foo": div}?.greet
-{"foo": add, "foo": i32}.foo
-{"foo": add, "foo": nil}?.list
+{"foo": 1}?.list
+{"foo": 1}?.ok
+{"foo": abs(i64)}
+{"foo": add, "bar": half}
+{"foo": add, "bar": nil}.i
+{"foo": add, "bar": nil}?.i
+{"foo": add, "bar": ok, "foo": array}?.i32
+{"foo": add, "foo": 1, "bar": i32}.add
+{"foo": add, "foo": array}?.f32
+{"foo": add, "foo": foo}?.i64
+{"foo": add, "foo": half}
+{"foo": add, "foo": score, "bar": i32}.list
 {"foo": add}
-{"foo": add}.Bar
+{"foo": add}.array
 {"foo": add}.div
+{"foo": add}.f32
 {"foo": add}.foo
 {"foo": add}.half
 {"foo": add}.i
-{"foo": add}.i64
+{"foo": add}.i32
+{"foo": add}.i?.score
 {"foo": add}.list
-{"foo": add}.ok
+{"foo": add}?.Bar
+{"foo": add}?.Qux
 {"foo": add}?.String
-{"foo": add}?.array
 {"foo": add}?.div
+{"foo": add}?.f32
+{"foo": add}?.foo
 {"foo": add}?.greet
 {"foo": add}?.half
-{"foo": add}?.i32
-{"foo": add}?.ok
-{"foo": array, "bar": "foo"}?.f32
-{"foo": array, "bar": f64}
-{"foo": array, "bar": greet}
-{"foo": array, "bar": list}?.f32
-{"foo": array, "bar": ok}
-{"foo": array, "foo": add}
-{"foo": array, "foo": greet}
-{"foo": array, "foo": true}?.i
+{"foo": add}?.i
+{"foo": add}?.i64
+{"foo": add}?.score
+{"foo": array, "bar": "bar"}.add
+{"foo": array, "bar": 0.5}?.div
+{"foo": array, "bar": add}.ok
+{"foo": array, "bar": array}.f32
+{"foo": array, "bar": i64}?.add
+{"foo": array, "bar": list}
+{"foo": array, "bar": nil}.half
+{"foo": array, "bar": ok, "bar": i}
+{"foo": array, "foo": "foo"}.array
+{"foo": array, "foo": array}
+{"foo": array, "foo": f32, "foo": half}.ok
+{"foo": array, "foo": f64}
+{"foo": array, "foo": list}
 {"foo": array}
+{"foo": array}.Bar
 {"foo": array}.Qux
-{"foo": array}.Qux?.String
-{"foo": array}.String
-{"foo": array}.f64
+{"foo": array}.f32
+{"foo": array}.foo
 {"foo": array}.greet
+{"foo": array}.i
 {"foo": array}.i32
-{"foo": array}.ok
-{"foo": array}?.Bar
-{"foo": array}?.String
+{"foo": array}.i64
+{"foo": array}.score
+{"foo": array}?.Qux
 {"foo": array}?.add
 {"foo": array}?.array
-{"foo": array}?.div
-{"foo": array}?.f64
-{"foo": array}?.half
+{"foo": array}?.greet
+{"foo": array}?.i64?.add
+{"foo": array}?.list
 {"foo": array}?.ok
-{"foo": div, "bar": 1}?.add
-{"foo": div, "bar": add}
-{"foo": div, "bar": div}
-{"foo": div, "bar": half}.half
-{"foo": div, "bar": list, "bar": 0.5}?.Qux
-{"foo": div, "foo": array}.Bar
-{"foo": div, "foo": true}?.Qux
+{"foo": div, "bar": "foo"}.array
+{"foo": div, "bar": array}
+{"foo": div, "bar": foo, "foo": true}?.i64
+{"foo": div, "bar": half}
+{"foo": div, "bar": i64}
+{"foo": div, "foo": array}
+{"foo": div, "foo": f32}
+{"foo": div, "foo": greet}?.i64
 {"foo": div}
 {"foo": div}.Qux
 {"foo": div}.array
 {"foo": div}.div
-{"foo": div}.foo
-{"foo": div}.greet
+{"foo": div}.f32
+{"foo": div}.greet?.i
+{"foo": div}.i32
+{"foo": div}.i64
 {"foo": div}?.Bar
 {"foo": div}?.Qux
 {"foo": div}?.String
-{"foo": div}?.add
-{"foo": div}?.f64
+{"foo": div}?.div
+{"foo": div}?.greet
 {"foo": div}?.half
-{"foo": div}?.i
+{"foo": div}?.i32
 {"foo": div}?.i64
 {"foo": div}?.list
-{"foo": div}?.ok
-{"foo": f32 != i}
-{"foo": f32 - f32}
-{"foo": f32 == 0.5}
-{"foo": f32, "bar": "bar"}?.String
-{"foo": f32, "bar": 0.5}.f32
-{"foo": f32, "bar": i32}
-{"foo": f32, "bar": list}
-{"foo": f32, "foo": 1, "foo": i32}?.i32
-{"foo": f32, "foo": div}
-{"foo": f32, "foo": i}
-{"foo": f32, "foo": ok}?.i
-{"foo": f32, "foo": type("bar")}
+{"foo": div}?.score
+{"foo": f32 > 1}
+{"foo": f32 >= 1}
+{"foo": f32, "bar": 0.5}.list
+{"foo": f32, "bar": div}
+{"foo": f32, "bar": f32}
+{"foo": f32, "bar": f64}
+{"foo": f32, "bar": greet}.greet
+{"foo": f32, "bar": half}
+{"foo": f32, "bar": ok}?.add
+{"foo": f32, "bar": score}?.i64
+{"foo": f32, "foo": "foo"}.ok
+{"foo": f32, "foo": add}?.half?.f64()
+{"foo": f32, "foo": foo}?.half
 {"foo": f32}
-{"foo": f32}.String
+{"foo": f32}.Qux
 {"foo": f32}.add
-{"foo": f32}.array
 {"foo": f32}.f32
 {"foo": f32}.foo
 {"foo": f32}.greet
 {"foo": f32}.half
 {"foo": f32}.i
 {"foo": f32}.i32
+{"foo": f32}.i64
 {"foo": f32}.list
+{"foo": f32}.score?.greet
 {"foo": f32}?.Bar
-{"foo": f32}?.Qux
-{"foo": f32}?.add
-{"foo": f32}?.f32
-{"foo": f32}?.f64
-{"foo": f32}?.half
-{"foo": f32}?.i32
-{"foo": f32}?.score
-{"foo": f64 * i}
-{"foo": f64 / 1}
-{"foo": f64 == 0.5}
-{"foo": f64 >= 1}
-{"foo": f64 ^ f32}
-{"foo": f64, "bar": "foo"}.Qux
-{"foo": f64, "bar": "foo"}.add
-{"foo": f64, "bar": 0.5}.div
-{"foo": f64, "bar": div}
-{"foo": f64, "bar": greet}
-{"foo": f64, "bar": half}?.list
-{"foo": f64, "bar": ok}.half
-{"foo": f64, "foo": foo, "bar": greet}.String
-{"foo": f64, "foo": foo, "foo": "foo"}.Bar
-{"foo": f64, "foo": greet}
-{"foo": f64, "foo": ok, "foo": i64}?.f64
+{"foo": f32}?.String
+{"foo": f32}?.array
+{"foo": f32}?.f64?.i
+{"foo": f32}?.i
+{"foo": f32}?.ok
+{"foo": f64 < f64}
+{"foo": f64 > f32}
+{"foo": f64 >= 0.5}
+{"foo": f64 >= f32}
+{"foo": f64 in array}
+{"foo": f64, "bar": 0.5}.greet
+{"foo": f64, "bar": add, "foo": greet}.Bar
+{"foo": f64, "bar": list}.i64
+{"foo": f64, "bar": sum(array)}
+{"foo": f64, "bar": true}?.greet
+{"foo": f64, "foo": list, "foo": i}?.add
 {"foo": f64}
+{"foo": f64}.Bar
 {"foo": f64}.Qux
-{"foo": f64}.String?.f32
-{"foo": f64}.String?.i64
-{"foo": f64}.add
-{"foo": f64}.array
+{"foo": f64}.div
+{"foo": f64}.f32
 {"foo": f64}.f64
-{"foo": f64}.foo
 {"foo": f64}.greet
-{"foo": f64}.i
+{"foo": f64}.i32
 {"foo": f64}.list
-{"foo": f64}?.Bar
+{"foo": f64}.ok
 {"foo": f64}?.String
-{"foo": f64}?.div
 {"foo": f64}?.f32
 {"foo": f64}?.f64
 {"foo": f64}?.foo
 {"foo": f64}?.greet
-{"foo": f64}?.i
+{"foo": f64}?.i32
+{"foo": f64}?.i64
 {"foo": f64}?.ok
-{"foo": false, "foo": greet}?.add
-{"foo": false, "foo": ok}.score
-{"foo": false}.Bar
+{"foo": f64}?.ok?.ok
+{"foo": f64}?.score
+{"foo": false or false}.array
+{"foo": false, "bar": 0.5, "foo": add}.score
+{"foo": false, "foo": foo, "bar": half}.array
+{"foo": false, "foo": score, "foo": nil}?.div
+{"foo": false, "foo": true}?.i32
 {"foo": false}.array
-{"foo": false}.div
-{"foo": false}.half
 {"foo": false}.i
-{"foo": false}?.array
+{"foo": false}.ok
 {"foo": false}?.f32
 {"foo": false}?.f64
-{"foo": false}?.foo
-{"foo": false}?.i64
 {"foo": false}?.list
-{"foo": foo, "bar": add, "foo": foo}.Bar
-{"foo": foo, "bar": ok, "foo": array}.String
-{"foo": foo, "foo": foo}
-{"foo": foo, "foo": list, "foo": greet}.i
-{"foo": foo, "foo": nil}?.f32
-{"foo": foo, "foo": true}?.array
+{"foo": foo == nil}
+{"foo": foo, "bar": div}
+{"foo": foo, "bar": foo}
+{"foo": foo, "bar": ok}.i32
+{"foo": foo, "bar": {"foo": 1}}
+{"foo": foo, "foo": add}
+{"foo": foo, "foo": half}
+{"foo": foo, "foo": i}
+{"foo": foo, "foo": ok}
+{"foo": foo, "foo": score, "foo": f64}.i
+{"foo": foo.Bar}
+{"foo": foo.String, "bar": foo}
+{"foo": foo.String}
+{"foo": foo?.Bar}
 {"foo": foo?.Qux}
+{"foo": foo?.String()}
+{"foo": foo?.String}
 {"foo": foo}
-{"foo": foo}.div
-{"foo": foo}.f64
+{"foo": foo}.Bar?.Bar
+{"foo": foo}.Qux
+{"foo": foo}.String
+{"foo": foo}.String?.String
+{"foo": foo}.f32
 {"foo": foo}.greet
-{"foo": foo}.list
-{"foo": foo}.ok
-{"foo": foo}.score
-{"foo": foo}?.String
+{"foo": foo}.half
+{"foo": foo}.i64
+{"foo": foo}?.Qux
+{"foo": foo}?.add
 {"foo": foo}?.array
-{"foo": foo}?.div
-{"foo": foo}?.f32
-{"foo": foo}?.foo
+{"foo": foo}?.array?.Bar
+{"foo": foo}?.f64
 {"foo": foo}?.greet
-{"foo": foo}?.half
+{"foo": foo}?.i32
 {"foo": foo}?.list
 {"foo": foo}?.ok
-{"foo": get(array, i32)}?.i64
-{"foo": greet, "bar": 0.5, "bar": "foo"}?.half
-{"foo": greet, "bar": 0.5}.Bar
-{"foo": greet, "bar": f64}
-{"foo": greet, "bar": f64}.list
-{"foo": greet, "bar": i, "foo": foo}?.f32
-{"foo": greet, "foo": "bar", "foo": score}.i
-{"foo": greet, "foo": f32}
+{"foo": greet("foo")}
+{"foo": greet, "bar": "bar"}?.i32
+{"foo": greet, "bar": i64}
+{"foo": greet, "bar": i}.list
+{"foo": greet, "foo": add}.String
+{"foo": greet, "foo": nil}?.add
 {"foo": greet}
+{"foo": greet}.Bar
 {"foo": greet}.Qux
 {"foo": greet}.String
 {"foo": greet}.add
 {"foo": greet}.array
-{"foo": greet}.f32?.greet
-{"foo": greet}.half?.greet
+{"foo": greet}.f32
+{"foo": greet}.i
+{"foo": greet}.i32
 {"foo": greet}.i64
-{"foo": greet}.list
+{"foo": greet}.i64?.greet
 {"foo": greet}.ok
-{"foo": greet}?.add
+{"foo": greet}.score
+{"foo": greet}?.Qux
 {"foo": greet}?.array
+{"foo": greet}?.div
 {"foo": greet}?.f32
-{"foo": greet}?.half
+{"foo": greet}?.f64
 {"foo": greet}?.i32
 {"foo": greet}?.i64
 {"foo": greet}?.list
+{"foo": greet}?.ok
 {"foo": greet}?.score
-{"foo": half(0.5)}
-{"foo": half(f64)}
-{"foo": half, "bar": 1}?.half
-{"foo": half, "bar": add}?.foo
-{"foo": half, "bar": f32}.i32
-{"foo": half, "bar": foo}
-{"foo": half, "bar": half}
-{"foo": half, "bar": i64, "bar": i32}.foo
-{"foo": half, "bar": i64}
-{"foo": half, "bar": nil}?.ok
-{"foo": half, "foo": 1}?.ok
-{"foo": half, "foo": div}
-{"foo": half, "foo": greet, "bar": f32}?.add
-{"foo": half, "foo": true}.f64
+{"foo": groupBy(array, 1)}
+{"foo": groupBy(list, #)}
+{"foo": half, "bar": "foo"}?.half
+{"foo": half, "bar": add, "foo": true}?.array
+{"foo": half, "bar": array}.half
+{"foo": half, "bar": greet}?.half
+{"foo": half, "bar": half}?.i
+{"foo": half, "bar": list, "foo": 1}?.f64
+{"foo": half, "bar": list}
+{"foo": half, "bar": true}?.Qux
+{"foo": half, "foo": 1}?.i32
+{"foo": half, "foo": div, "foo": array}?.i32
+{"foo": half, "foo": f64}
+{"foo": half, "foo": list, "foo": half}.half
+{"foo": half, "foo": score, "foo": list}.String
 {"foo": half}
 {"foo": half}.Bar
 {"foo": half}.String
+{"foo": half}.add
 {"foo": half}.div
-{"foo": half}.f64
-{"foo": half}.greet
+{"foo": half}.f32
+{"foo": half}.foo
 {"foo": half}.half
 {"foo": half}.i
-{"foo": half}.i32
+{"foo": half}.i64
 {"foo": half}.ok
+{"foo": half}.score
 {"foo": half}?.Bar
 {"foo": half}?.Qux
-{"foo": half}?.add
-{"foo": half}?.f64
+{"foo": half}?.String
+{"foo": half}?.div
+{"foo": half}?.f32
 {"foo": half}?.foo
-{"foo": half}?.greet
-{"foo": half}?.half
-{"foo": half}?.list
+{"foo": half}?.i32
+{"foo": half}?.i64
 {"foo": half}?.score
-{"foo": hasPrefix("bar", "foo")}
-{"foo": i < f64}
-{"foo": i > 0.5}
-{"foo": i, "bar": score}
-{"foo": i, "foo": i}.i64
-{"foo": i, "foo": ok}
-{"foo": i, "foo": ok}?.ok
-{"foo": i32, "bar": 0.5, "foo": array}.Bar
-{"foo": i32, "bar": i32}.i64
-{"foo": i32, "bar": nil}?.i64
-{"foo": i32, "foo": 0.5}.i
-{"foo": i32, "foo": add}
-{"foo": i32, "foo": div, "foo": nil}.Bar
-{"foo": i32, "foo": foo}
-{"foo": i32, "foo": greet}?.foo
-{"foo": i32, "foo": i32}?.score
-{"foo": i32, "foo": ok, "bar": true}.f32
-{"foo": i32, "foo": ok}?.i32
+{"foo": i != 1}
+{"foo": i - f64}
+{"foo": i / 1}
+{"foo": i ^ 1}
+{"foo": i, "bar": 0.5}?.half
+{"foo": i, "bar": f32}
+{"foo": i, "bar": foo}
+{"foo": i, "bar": list}.foo
+{"foo": i, "foo": "bar"}?.div?.f32
+{"foo": i, "foo": 1}.list
+{"foo": i, "foo": 1}?.list
+{"foo": i, "foo": add}
+{"foo": i, "foo": array, "bar": 0.5}?.f32
+{"foo": i, "foo": half}?.list
+{"foo": i, "foo": score}
+{"foo": i, "foo": score}?.f32
+{"foo": i32 != i}
+{"foo": i32 * 0.5}
+{"foo": i32 + 1}
+{"foo": i32 - f32}.foo
+{"foo": i32 - f64}
+{"foo": i32 / 1}
+{"foo": i32 < 1}
+{"foo": i32, "bar": 0.5, "bar": foo}.i64
+{"foo": i32, "bar": foo}?.score
+{"foo": i32, "bar": nil}?.ok
+{"foo": i32, "foo": false, "bar": f32}?.foo
+{"foo": i32, "foo": greet}?.greet
 {"foo": i32}
-{"foo": i32}.Bar
-{"foo": i32}.Qux
-{"foo": i32}.i64
-{"foo": i32}.list
+{"foo": i32}.i
 {"foo": i32}.ok
-{"foo": i32}.score
 {"foo": i32}?.Bar
-{"foo": i32}?.Qux
+{"foo": i32}?.String
 {"foo": i32}?.add
-{"foo": i32}?.div
 {"foo": i32}?.f32
-{"foo": i32}?.greet
-{"foo": i32}?.half
+{"foo": i32}?.f64
 {"foo": i32}?.i
+{"foo": i32}?.i32
 {"foo": i32}?.i64
+{"foo": i32}?.list
 {"foo": i32}?.score
-{"foo": i64 * f64, "foo": i64}
-{"foo": i64 <= 0.5}
-{"foo": i64 ^ i32}
-{"foo": i64, "bar": "bar"}.Qux
-{"foo": i64, "bar": array}.add
-{"foo": i64, "bar": div}
-{"foo": i64, "bar": f64, "bar": greet}.f32
-{"foo": i64, "bar": list}
-{"foo": i64, "foo": 0.5, "bar": 0.5}.half
-{"foo": i64, "foo": div}
-{"foo": i64, "foo": i32}
+{"foo": i64 % 1}
+{"foo": i64 * f32}
+{"foo": i64 .. i64}
+{"foo": i64, "bar": array}
+{"foo": i64, "foo": array}.f32
+{"foo": i64, "foo": f32}
+{"foo": i64, "foo": i32}?.foo
+{"foo": i64, "foo": i64, "bar": f64}.foo
+{"foo": i64, "foo": i64}
+{"foo": i64, "foo": i64}.greet
+{"foo": i64, "foo": i64}?.foo
 {"foo": i64}
-{"foo": i64}.Qux
-{"foo": i64}.add
+{"foo": i64}.Bar
 {"foo": i64}.array
+{"foo": i64}.div
+{"foo": i64}.foo
+{"foo": i64}.greet
+{"foo": i64}.half
+{"foo": i64}.i
+{"foo": i64}.i32
+{"foo": i64}.list
 {"foo": i64}?.Qux
-{"foo": i64}?.String
+{"foo": i64}?.add
+{"foo": i64}?.array
 {"foo": i64}?.f32
-{"foo": i64}?.foo
-{"foo": i64}?.greet
+{"foo": i64}?.f64
+{"foo": i64}?.half
 {"foo": i64}?.i32
-{"foo": i64}?.list
-{"foo": i64}?.score
+{"foo": i64}?.i32?.f32
+{"foo": i64}?.i64
+{"foo": i64}?.score?.list
+{"foo": int(i)}
+{"foo": int(i32)}
+{"foo": int(i64)}
 {"foo": i}
 {"foo": i}.Bar
 {"foo": i}.String
-{"foo": i}.div
-{"foo": i}.foo
+{"foo": i}.add
+{"foo": i}.array
+{"foo": i}.f64
 {"foo": i}.greet
-{"foo": i}.i32?.add
+{"foo": i}.i
 {"foo": i}.ok
-{"foo": i}.score
-{"foo": i}?.Bar
-{"foo": i}?.array
 {"foo": i}?.div
-{"foo": i}?.f64
-{"foo": i}?.foo
-{"foo": i}?.half
+{"foo": i}?.greet
+{"foo": i}?.i
+{"foo": i}?.i32
 {"foo": i}?.i64
 {"foo": i}?.score
-{"foo": list == list}.f32
-{"foo": list, "bar": f32, "foo": i32}.i32
-{"foo": list, "bar": foo}?.list
-{"foo": list, "bar": i64}
-{"foo": list, "bar": score}
-{"foo": list, "foo": score}
+{"foo": last(list)}
+{"foo": len(list)}
+{"foo": list, "bar": add}
+{"foo": list, "bar": all(list, false)}
+{"foo": list, "bar": array}
+{"foo": list, "bar": f32}.f64
+{"foo": list, "bar": half}
+{"foo": list, "bar": i32, "bar": score}.array
+{"foo": list, "bar": true}?.foo
 {"foo": list}
-{"foo": list}.Bar
+{"foo": list}.Qux
 {"foo": list}.String
 {"foo": list}.add
 {"foo": list}.div
-{"foo": list}.foo
+{"foo": list}.f32
+{"foo": list}.greet
 {"foo": list}.half
+{"foo": list}.i
 {"foo": list}.i32
-{"foo": list}.score
-{"foo": list}?.add
+{"foo": list}?.String
 {"foo": list}?.div
+{"foo": list}?.f32
+{"foo": list}?.foo
 {"foo": list}?.i
+{"foo": list}?.i32
 {"foo": list}?.i64
 {"foo": list}?.ok
+{"foo": list}?.score
 {"foo": map(array, #)}
-{"foo": map(array, 0.5)}
-{"foo": map(array, foo)}
-{"foo": map(array, ok), "bar": i32}
-{"foo": map(list, 0.5)}
-{"foo": map(list, score)}
-{"foo": min(0.5)}
-{"foo": min(1)}?.f32
-{"foo": nil == 0.5}
-{"foo": nil, "bar": 0.5}.score
-{"foo": nil, "bar": add}?.array
-{"foo": nil, "bar": div}.Bar
-{"foo": nil, "bar": f64, "foo": div}.i32
-{"foo": nil, "bar": greet}?.add
-{"foo": nil, "bar": i64}?.i64
-{"foo": nil, "bar": list}?.i32
-{"foo": nil, "foo": "foo"}.add
-{"foo": nil, "foo": 1}.score
-{"foo": nil, "foo": false}?.add
-{"foo": nil, "foo": i64}.add
-{"foo": nil}.Bar
-{"foo": nil}.Qux
-{"foo": nil}.String
-{"foo": nil}.array
+{"foo": map(array, i64)}
+{"foo": nil, "bar": 0.5}.ok
+{"foo": nil, "bar": add, "bar": f32}?.list
+{"foo": nil, "bar": div, "bar": 1}.i64
+{"foo": nil, "bar": f32}.score
+{"foo": nil, "bar": foo}?.String
+{"foo": nil, "bar": score}?.ok?.div
+{"foo": nil, "foo": "foo"}.Bar
+{"foo": nil, "foo": greet}.String
+{"foo": nil, "foo": half}.f64
+{"foo": nil, "foo": i64, "bar": f64}?.list
+{"foo": nil, "foo": i}.div
+{"foo": nil, "foo": list}.add
+{"foo": nil, "foo": list}?.array
+{"foo": nil, "foo": nil}.ok
+{"foo": nil}.array?.half()
 {"foo": nil}.div
 {"foo": nil}.f32
 {"foo": nil}.f64
-{"foo": nil}.greet?.i()
-{"foo": nil}.greet?.i32
 {"foo": nil}.half
 {"foo": nil}.i
-{"foo": nil}.i64
+{"foo": nil}.i32
+{"foo": nil}.i64?.Bar()
 {"foo": nil}.list
+{"foo": nil}.ok
+{"foo": nil}.score
 {"foo": nil}?.Bar
-{"foo": nil}?.Qux
-{"foo": nil}?.String
+{"foo": nil}?.Bar?.score
+{"foo": nil}?.add
 {"foo": nil}?.array
-{"foo": nil}?.div
-{"foo": nil}?.f32?.ok
-{"foo": nil}?.greet
+{"foo": nil}?.f64
+{"foo": nil}?.foo
+{"foo": nil}?.half
 {"foo": nil}?.i32
-{"foo": nil}?.i?.half
+{"foo": nil}?.i64
 {"foo": nil}?.list
-{"foo": nil}?.list?.greet()
-{"foo": nil}?.score
-{"foo": not false}
-{"foo": not ok}
-{"foo": ok && ok}
-{"foo": ok == nil}
-{"foo": ok ? true : div}
+{"foo": ok == false}
+{"foo": ok, "bar": "foo"}?.i64
+{"foo": ok, "bar": add}.String
 {"foo": ok, "bar": f32}
-{"foo": ok, "bar": i, "foo": greet}.i32
-{"foo": ok, "bar": i32}
-{"foo": ok, "foo": 0.5}?.array
-{"foo": ok, "foo": 1}.Qux
-{"foo": ok, "foo": half, "bar": div}.score
-{"foo": ok, "foo": i64}
-{"foo": ok, "foo": i64}.i
-{"foo": ok, "foo": nil}?.add
+{"foo": ok, "foo": half}.ok
+{"foo": ok, "foo": list}
 {"foo": ok}
 {"foo": ok}.Bar
-{"foo": ok}.add
+{"foo": ok}.Bar?.i
+{"foo": ok}.String
+{"foo": ok}.array
 {"foo": ok}.div
 {"foo": ok}.f64
-{"foo": ok}.greet
-{"foo": ok}.i
-{"foo": ok}.score
+{"foo": ok}.foo
+{"foo": ok}.i32
+{"foo": ok}.i64
+{"foo": ok}.ok
 {"foo": ok}?.Qux
 {"foo": ok}?.String
-{"foo": ok}?.div
+{"foo": ok}?.String?.Bar
+{"foo": ok}?.array
 {"foo": ok}?.f32
+{"foo": ok}?.foo
 {"foo": ok}?.greet
-{"foo": ok}?.half?.half
+{"foo": ok}?.half
 {"foo": ok}?.i32
 {"foo": ok}?.i64
 {"foo": ok}?.list
-{"foo": score(1)}
-{"foo": score, "bar": 0.5}.list
-{"foo": score, "bar": 1 ^ 1}
-{"foo": score, "bar": i32}
-{"foo": score, "bar": i64}
-{"foo": score, "foo": 0.5}.add
-{"foo": score, "foo": 1}?.div
-{"foo": score, "foo": add, "bar": ok}
-{"foo": score, "foo": f32, "bar": false}.div
-{"foo": score, "foo": f32}?.i32
-{"foo": score, "foo": i}?.f32
-{"foo": score}
-{"foo": score}.Bar
-{"foo": score}.array
-{"foo": score}.list
-{"foo": score}?.Bar
-{"foo": score}?.String
-{"foo": score}?.add
-{"foo": score}?.f32
-{"foo": score}?.greet
-{"foo": score}?.half
-{"foo": score}?.i
-{"foo": score}?.list
-{"foo": score}?.score
-{"foo": string(i32)}
-{"foo": string(list)}
-{"foo": toBase64("bar")}
-{"foo": toJSON(f32)}
-{"foo": toJSON(i64)}?.i32
-{"foo": toJSON(nil)}
-{"foo": true, "bar": false}?.array
-{"foo": true, "bar": nil}?.div
-{"foo": true, "bar": true}.f64
-{"foo": true, "foo": array, "bar": i32}?.ok
-{"foo": true, "foo": i32}.i64
-{"foo": true, "foo": ok, "foo": add}.foo
-{"foo": true}.String
-{"foo": true}.f32
-{"foo": true}.foo
-{"foo": true}.i
-{"foo": true}.i64
-{"foo": true}?.String
-{"foo": true}?.greet
-{"foo": true}?.i32
-{"foo": type(1)}
-{"foo": type(list)}
-{"foo": type(nil)}
-{"foo": type(ok)}
+{"foo": reduce(array, "foo")}
+{"foo": reduce(array, #)}
+{"foo": reduce(list, #).String()}
+{"foo": reduce(list, #)}
+{"foo": reduce(list, #)}?.list
+{"foo": score, "bar": add}.add
+{"foo": score, "bar": div}
+{"foo": score, "bar": f64}
+{"foo": score, "bar": false}?.array
+{"foo": score, "bar": false}?.i
+{"foo": score, "bar": true}.div?.i
+{"foo": score, "foo": 0.5}?.String
+{"foo": score, "foo": 1}.array
+{"foo": score, "foo": add}
+{"foo": score, "foo": array}.array
+{"foo": score, "foo": f32}
+{"foo": score, "foo": greet}

From dd925fd96f531a15ef9e0abddfc81fe532a67156 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 30 Dec 2023 12:49:43 +0100
Subject: [PATCH 234/506] Add mem grow to builtin (#505)

* Add mem grow to builtin

* Add OpValidateArgs opcode
---
 builtin/builtin.go      | 24 ++++++++++++++----------
 builtin/builtin_test.go | 23 ++++++++++++++++++++---
 compiler/compiler.go    | 26 ++++++++++++++++----------
 vm/opcodes.go           |  1 +
 vm/program.go           |  5 ++++-
 vm/vm.go                |  8 ++++++++
 6 files changed, 63 insertions(+), 24 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 2417446da..cd943bd0b 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -13,12 +13,13 @@ import (
 )
 
 type Function struct {
-	Name      string
-	Func      func(args ...any) (any, error)
-	Fast      func(arg any) any
-	Types     []reflect.Type
-	Validate  func(args []reflect.Type) (reflect.Type, error)
-	Predicate bool
+	Name         string
+	Func         func(args ...any) (any, error)
+	Fast         func(arg any) any
+	ValidateArgs func(args ...any) (any, error)
+	Types        []reflect.Type
+	Validate     func(args []reflect.Type) (reflect.Type, error)
+	Predicate    bool
 }
 
 var (
@@ -325,12 +326,15 @@ var Builtins = []*Function{
 	},
 	{
 		Name: "repeat",
-		Func: func(args ...any) (any, error) {
+		ValidateArgs: func(args ...any) (any, error) {
 			n := runtime.ToInt(args[1])
-			if n > 1e6 {
-				panic("memory budget exceeded")
+			if n < 0 {
+				panic(fmt.Errorf("invalid argument for repeat (expected positive integer, got %d)", n))
 			}
-			return strings.Repeat(args[0].(string), n), nil
+			return uint(n), nil
+		},
+		Func: func(args ...any) (any, error) {
+			return strings.Repeat(args[0].(string), runtime.ToInt(args[1])), nil
 		},
 		Types: types(strings.Repeat),
 	},
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index a861d0faa..23273a246 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -260,9 +260,26 @@ func TestBuiltin_memory_limits(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
-			_, err := expr.Eval(test.input, nil)
-			assert.Error(t, err)
-			assert.Contains(t, err.Error(), "memory budget exceeded")
+			timeout := make(chan bool, 1)
+			go func() {
+				time.Sleep(time.Second)
+				timeout <- true
+			}()
+
+			done := make(chan bool, 1)
+			go func() {
+				_, err := expr.Eval(test.input, nil)
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), "memory budget exceeded")
+				done <- true
+			}()
+
+			select {
+			case <-done:
+				// Success.
+			case <-timeout:
+				t.Fatal("timeout")
+			}
 		})
 	}
 }
diff --git a/compiler/compiler.go b/compiler/compiler.go
index f4bb3bd5d..1f1c00c92 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -147,31 +147,31 @@ func (c *compiler) addVariable(name string) int {
 func (c *compiler) emitFunction(fn *builtin.Function, argsLen int) {
 	switch argsLen {
 	case 0:
-		c.emit(OpCall0, c.addFunction(fn))
+		c.emit(OpCall0, c.addFunction(fn.Name, fn.Func))
 	case 1:
-		c.emit(OpCall1, c.addFunction(fn))
+		c.emit(OpCall1, c.addFunction(fn.Name, fn.Func))
 	case 2:
-		c.emit(OpCall2, c.addFunction(fn))
+		c.emit(OpCall2, c.addFunction(fn.Name, fn.Func))
 	case 3:
-		c.emit(OpCall3, c.addFunction(fn))
+		c.emit(OpCall3, c.addFunction(fn.Name, fn.Func))
 	default:
-		c.emit(OpLoadFunc, c.addFunction(fn))
+		c.emit(OpLoadFunc, c.addFunction(fn.Name, fn.Func))
 		c.emit(OpCallN, argsLen)
 	}
 }
 
 // addFunction adds builtin.Function.Func to the program.functions and returns its index.
-func (c *compiler) addFunction(fn *builtin.Function) int {
+func (c *compiler) addFunction(name string, fn Function) int {
 	if fn == nil {
 		panic("function is nil")
 	}
-	if p, ok := c.functionsIndex[fn.Name]; ok {
+	if p, ok := c.functionsIndex[name]; ok {
 		return p
 	}
 	p := len(c.functions)
-	c.functions = append(c.functions, fn.Func)
-	c.functionsIndex[fn.Name] = p
-	c.debugInfo[fmt.Sprintf("func_%d", p)] = fn.Name
+	c.functions = append(c.functions, fn)
+	c.functionsIndex[name] = p
+	c.debugInfo[fmt.Sprintf("func_%d", p)] = name
 	return p
 }
 
@@ -904,6 +904,12 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		for _, arg := range node.Arguments {
 			c.compile(arg)
 		}
+
+		if f.ValidateArgs != nil {
+			c.emit(OpLoadFunc, c.addFunction("$_validate_args_"+f.Name, f.ValidateArgs))
+			c.emit(OpValidateArgs, len(node.Arguments))
+		}
+
 		if f.Fast != nil {
 			c.emit(OpCallBuiltin1, id)
 		} else if f.Func != nil {
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 1106cd3f0..57b840507 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -60,6 +60,7 @@ const (
 	OpCallFast
 	OpCallTyped
 	OpCallBuiltin1
+	OpValidateArgs
 	OpArray
 	OpMap
 	OpLen
diff --git a/vm/program.go b/vm/program.go
index 27b8f6098..085b18a7f 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -137,7 +137,7 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 			constant("OpLoadMethod")
 
 		case OpLoadFunc:
-			argument("OpLoadFunc")
+			argumentWithInfo("OpLoadFunc", "func")
 
 		case OpLoadEnv:
 			code("OpLoadEnv")
@@ -278,6 +278,9 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 		case OpCallBuiltin1:
 			builtinArg("OpCallBuiltin1")
 
+		case OpValidateArgs:
+			argument("OpValidateArgs")
+
 		case OpArray:
 			code("OpArray")
 
diff --git a/vm/vm.go b/vm/vm.go
index 20e1594fd..fa2c75899 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -397,6 +397,14 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpCallBuiltin1:
 			vm.push(builtin.Builtins[arg].Fast(vm.pop()))
 
+		case OpValidateArgs:
+			fn := vm.pop().(Function)
+			mem, err := fn(vm.stack[len(vm.stack)-arg:]...)
+			if err != nil {
+				panic(err)
+			}
+			vm.memGrow(mem.(uint))
+
 		case OpArray:
 			size := vm.pop().(int)
 			vm.memGrow(uint(size))

From 09c0b343284ec523131e39ddebcd6c85c3db444b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 5 Jan 2024 22:36:41 +0100
Subject: [PATCH 235/506] Add heading ids

---
 docs/language-definition.md | 132 ++++++++++++++++++------------------
 1 file changed, 66 insertions(+), 66 deletions(-)

diff --git a/docs/language-definition.md b/docs/language-definition.md
index d205edc6e..7574ff2f9 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -298,7 +298,7 @@ filter(tweets, len(.Content) > 240)
 
 ## String Functions
 
-### trim(str[, chars])
+### trim(str[, chars]) {#trim}
 
 Removes white spaces from both ends of a string `str`.
 If the optional `chars` argument is given, it is a string specifying the set of characters to be removed.
@@ -308,7 +308,7 @@ trim("  Hello  ") == "Hello"
 trim("__Hello__", "_") == "Hello"
 ```
 
-### trimPrefix(str, prefix)
+### trimPrefix(str, prefix) {#trimPrefix}
 
 Removes the specified prefix from the string `str` if it starts with that prefix.
 
@@ -316,7 +316,7 @@ Removes the specified prefix from the string `str` if it starts with that prefix
 trimPrefix("HelloWorld", "Hello") == "World"
 ```
 
-### trimSuffix(str, suffix)
+### trimSuffix(str, suffix) {#trimSuffix}
 
 Removes the specified suffix from the string `str` if it ends with that suffix.
 
@@ -324,7 +324,7 @@ Removes the specified suffix from the string `str` if it ends with that suffix.
 trimSuffix("HelloWorld", "World") == "Hello"
 ```
 
-### upper(str)
+### upper(str) {#upper}
 
 Converts all the characters in string `str` to uppercase.
 
@@ -332,7 +332,7 @@ Converts all the characters in string `str` to uppercase.
 upper("hello") == "HELLO"
 ```
 
-### lower(str)
+### lower(str) {#lower}
 
 Converts all the characters in string `str` to lowercase.
 
@@ -340,7 +340,7 @@ Converts all the characters in string `str` to lowercase.
 lower("HELLO") == "hello"
 ```
 
-### split(str, delimiter[, n])
+### split(str, delimiter[, n]) {#split}
 
 Splits the string `str` at each instance of the delimiter and returns an array of substrings.
 
@@ -349,7 +349,7 @@ split("apple,orange,grape", ",") == ["apple", "orange", "grape"]
 split("apple,orange,grape", ",", 2) == ["apple", "orange,grape"]
 ```
 
-### splitAfter(str, delimiter[, n])
+### splitAfter(str, delimiter[, n]) {#splitAfter}
 
 Splits the string `str` after each instance of the delimiter.
 
@@ -358,7 +358,7 @@ splitAfter("apple,orange,grape", ",") == ["apple,", "orange,", "grape"]
 splitAfter("apple,orange,grape", ",", 2) == ["apple,", "orange,grape"]
 ```
 
-### replace(str, old, new)
+### replace(str, old, new) {#replace}
 
 Replaces all occurrences of `old` in string `str` with `new`.
 
@@ -366,7 +366,7 @@ Replaces all occurrences of `old` in string `str` with `new`.
 replace("Hello World", "World", "Universe") == "Hello Universe"
 ```
 
-### repeat(str, n)
+### repeat(str, n) {#repeat}
 
 Repeats the string `str` `n` times.
 
@@ -374,7 +374,7 @@ Repeats the string `str` `n` times.
 repeat("Hi", 3) == "HiHiHi"
 ```
 
-### indexOf(str, substring)
+### indexOf(str, substring) {#indexOf}
 
 Returns the index of the first occurrence of the substring in string `str` or -1 if not found.
 
@@ -382,7 +382,7 @@ Returns the index of the first occurrence of the substring in string `str` or -1
 indexOf("apple pie", "pie") == 6
 ```
 
-### lastIndexOf(str, substring)
+### lastIndexOf(str, substring) {#lastIndexOf}
 
 Returns the index of the last occurrence of the substring in string `str` or -1 if not found.
 
@@ -390,7 +390,7 @@ Returns the index of the last occurrence of the substring in string `str` or -1
 lastIndexOf("apple pie apple", "apple") == 10
 ```
 
-### hasPrefix(str, prefix)
+### hasPrefix(str, prefix) {#hasPrefix}
 
 Returns `true` if string `str` starts with the given prefix.
 
@@ -398,7 +398,7 @@ Returns `true` if string `str` starts with the given prefix.
 hasPrefix("HelloWorld", "Hello") == true
 ```
 
-### hasSuffix(str, suffix)
+### hasSuffix(str, suffix) {#hasSuffix}
 
 Returns `true` if string `str` ends with the given suffix.
 
@@ -427,7 +427,7 @@ And it is possible to compare dates:
 createdAt > now() - duration("1h")
 ```
 
-### now()
+### now() {#now}
 
 Returns the current date as a [time.Time](https://pkg.go.dev/time#Time) value.
 
@@ -435,7 +435,7 @@ Returns the current date as a [time.Time](https://pkg.go.dev/time#Time) value.
 now().Year() == 2024
 ```
 
-### duration(str)
+### duration(str) {#duration}
 
 Returns [time.Duration](https://pkg.go.dev/time#Duration) value of the given string `str`.
 
@@ -445,7 +445,7 @@ Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
 duration("1h").Seconds() == 3600
 ```
 
-### date(str[, format[, timezone]])
+### date(str[, format[, timezone]]) {#date}
 
 Converts the given string `str` into a date representation.
 
@@ -474,7 +474,7 @@ date("2023-08-14 00:00:00", "2006-01-02 15:04:05", "Europe/Zurich")
 
 ## Number Functions
 
-### max(n1, n2)
+### max(n1, n2) {#max}
 
 Returns the maximum of the two numbers `n1` and `n2`.
 
@@ -482,7 +482,7 @@ Returns the maximum of the two numbers `n1` and `n2`.
 max(5, 7) == 7
 ```
 
-### min(n1, n2)
+### min(n1, n2) {#min}
 
 Returns the minimum of the two numbers `n1` and `n2`.
 
@@ -490,7 +490,7 @@ Returns the minimum of the two numbers `n1` and `n2`.
 min(5, 7) == 5
 ```
 
-### abs(n)
+### abs(n) {#abs}
 
 Returns the absolute value of a number.
 
@@ -498,7 +498,7 @@ Returns the absolute value of a number.
 abs(-5) == 5
 ```
 
-### ceil(n)
+### ceil(n) {#ceil}
 
 Returns the least integer value greater than or equal to x.
 
@@ -506,7 +506,7 @@ Returns the least integer value greater than or equal to x.
 ceil(1.5) == 2.0
 ```
 
-### floor(n)
+### floor(n) {#floor}
 
 Returns the greatest integer value less than or equal to x.
 
@@ -514,7 +514,7 @@ Returns the greatest integer value less than or equal to x.
 floor(1.5) == 1.0
 ```
 
-### round(n)
+### round(n) {#round}
 
 Returns the nearest integer, rounding half away from zero.
 
@@ -524,7 +524,7 @@ round(1.5) == 2.0
 
 ## Array Functions
 
-### all(array, predicate)
+### all(array, predicate) {#all}
 
 Returns **true** if all elements satisfies the [predicate](#predicate).
 If the array is empty, returns **true**.
@@ -533,7 +533,7 @@ If the array is empty, returns **true**.
 all(tweets, {.Size < 280})
 ```
 
-### any(array, predicate)
+### any(array, predicate) {#any}
 
 Returns **true** if any elements satisfies the [predicate](#predicate).
 If the array is empty, returns **false**.
@@ -542,7 +542,7 @@ If the array is empty, returns **false**.
 any(tweets, {.Size > 280})
 ```
 
-### one(array, predicate)
+### one(array, predicate) {#one}
 
 Returns **true** if _exactly one_ element satisfies the [predicate](#predicate).
 If the array is empty, returns **false**.
@@ -551,7 +551,7 @@ If the array is empty, returns **false**.
 one(participants, {.Winner})
 ```
 
-### none(array, predicate)
+### none(array, predicate) {#none}
 
 Returns **true** if _all elements does not_ satisfy the [predicate](#predicate).
 If the array is empty, returns **true**.
@@ -560,7 +560,7 @@ If the array is empty, returns **true**.
 none(tweets, {.Size > 280})
 ```
 
-### map(array, predicate)
+### map(array, predicate) {#map}
 
 Returns new array by applying the [predicate](#predicate) to each element of
 the array.
@@ -569,7 +569,7 @@ the array.
 map(tweets, {.Size})
 ```
 
-### filter(array, predicate)
+### filter(array, predicate) {#filter}
 
 Returns new array by filtering elements of the array by [predicate](#predicate).
 
@@ -577,7 +577,7 @@ Returns new array by filtering elements of the array by [predicate](#predicate).
 filter(users, .Name startsWith "J")
 ```
 
-### find(array, predicate)
+### find(array, predicate) {#find}
 
 Finds the first element in an array that satisfies the [predicate](#predicate).
 
@@ -585,7 +585,7 @@ Finds the first element in an array that satisfies the [predicate](#predicate).
 find([1, 2, 3, 4], # > 2) == 3
 ```
 
-### findIndex(array, predicate)
+### findIndex(array, predicate) {#findIndex}
 
 Finds the index of the first element in an array that satisfies the [predicate](#predicate).
 
@@ -593,7 +593,7 @@ Finds the index of the first element in an array that satisfies the [predicate](
 findIndex([1, 2, 3, 4], # > 2) == 2
 ```
 
-### findLast(array, predicate)
+### findLast(array, predicate) {#findLast}
 
 Finds the last element in an array that satisfies the [predicate](#predicate).
 
@@ -601,7 +601,7 @@ Finds the last element in an array that satisfies the [predicate](#predicate).
 findLast([1, 2, 3, 4], # > 2) == 4
 ```
 
-### findLastIndex(array, predicate)
+### findLastIndex(array, predicate) {#findLastIndex}
 
 Finds the index of the last element in an array that satisfies the [predicate](#predicate).
 
@@ -609,7 +609,7 @@ Finds the index of the last element in an array that satisfies the [predicate](#
 findLastIndex([1, 2, 3, 4], # > 2) == 3
 ```
 
-### groupBy(array, predicate)
+### groupBy(array, predicate) {#groupBy}
 
 Groups the elements of an array by the result of the [predicate](#predicate).
 
@@ -617,7 +617,7 @@ Groups the elements of an array by the result of the [predicate](#predicate).
 groupBy(users, .Age)
 ```
 
-### count(array, predicate)
+### count(array, predicate) {#count}
 
 Returns the number of elements what satisfies the [predicate](#predicate).
 
@@ -627,7 +627,7 @@ Equivalent to:
 len(filter(array, predicate))
 ```
 
-### join(array[, delimiter])
+### join(array[, delimiter]) {#join}
 
 Joins an array of strings into a single string with the given delimiter.
 If no delimiter is given, an empty string is used.
@@ -637,7 +637,7 @@ join(["apple", "orange", "grape"], ",") == "apple,orange,grape"
 join(["apple", "orange", "grape"]) == "appleorangegrape"
 ```
 
-### reduce(array, predicate[, initialValue])
+### reduce(array, predicate[, initialValue]) {#reduce}
 
 Applies a predicate to each element in the array, reducing the array to a single value.
 Optional `initialValue` argument can be used to specify the initial value of the accumulator.
@@ -654,7 +654,7 @@ reduce(1..9, #acc + #)
 reduce(1..9, #acc + #, 0)
 ```
 
-### sum(array)
+### sum(array) {#sum}
 
 Returns the sum of all numbers in the array.
 
@@ -662,7 +662,7 @@ Returns the sum of all numbers in the array.
 sum([1, 2, 3]) == 6
 ```
 
-### mean(array)
+### mean(array) {#mean}
 
 Returns the average of all numbers in the array.
 
@@ -670,7 +670,7 @@ Returns the average of all numbers in the array.
 mean([1, 2, 3]) == 2.0
 ```
 
-### median(array)
+### median(array) {#median}
 
 Returns the median of all numbers in the array.
 
@@ -678,7 +678,7 @@ Returns the median of all numbers in the array.
 median([1, 2, 3]) == 2.0
 ```
 
-### first(array)
+### first(array) {#first}
 
 Returns the first element from an array. If the array is empty, returns `nil`.
 
@@ -686,7 +686,7 @@ Returns the first element from an array. If the array is empty, returns `nil`.
 first([1, 2, 3]) == 1
 ```
 
-### last(array)
+### last(array) {#last}
 
 Returns the last element from an array. If the array is empty, returns `nil`.
 
@@ -694,7 +694,7 @@ Returns the last element from an array. If the array is empty, returns `nil`.
 last([1, 2, 3]) == 3
 ```
 
-### take(array, n)
+### take(array, n) {#take}
 
 Returns the first `n` elements from an array. If the array has fewer than `n` elements, returns the whole array.
 
@@ -702,7 +702,7 @@ Returns the first `n` elements from an array. If the array has fewer than `n` el
 take([1, 2, 3, 4], 2) == [1, 2]
 ```
 
-### sort(array[, order])
+### sort(array[, order]) {#sort}
 
 Sorts an array in ascending order. Optional `order` argument can be used to specify the order of sorting: `asc`
 or `desc`.
@@ -712,7 +712,7 @@ sort([3, 1, 4]) == [1, 3, 4]
 sort([3, 1, 4], "desc") == [4, 3, 1]
 ```
 
-### sortBy(array, key[, order])
+### sortBy(array, key[, order]) {#sortBy}
 
 Sorts an array of maps by a specific key in ascending order. Optional `order` argument can be used to specify the order
 of sorting: `asc` or `desc`.
@@ -724,7 +724,7 @@ sortBy(users, "Age", "desc")
 
 ## Map Functions
 
-### keys(map)
+### keys(map) {#keys}
 
 Returns an array containing the keys of the map.
 
@@ -732,7 +732,7 @@ Returns an array containing the keys of the map.
 keys({"name": "John", "age": 30}) == ["name", "age"]
 ```
 
-### values(map)
+### values(map) {#values}
 
 Returns an array containing the values of the map.
 
@@ -742,7 +742,7 @@ values({"name": "John", "age": 30}) == ["John", 30]
 
 ## Type Conversion Functions
 
-### type(v)
+### type(v) {#type}
 
 Returns the type of the given value `v`.
 
@@ -765,7 +765,7 @@ type("hello") == "string"
 type(now()) == "time.Time"
 ```
 
-### int(v)
+### int(v) {#int}
 
 Returns the integer value of a number or a string.
 
@@ -773,7 +773,7 @@ Returns the integer value of a number or a string.
 int("123") == 123
 ```
 
-### float(v)
+### float(v) {#float}
 
 Returns the float value of a number or a string.
 
@@ -781,7 +781,7 @@ Returns the float value of a number or a string.
 float("123.45") == 123.45
 ```
 
-### string(v)
+### string(v) {#string}
 
 Converts the given value `v` into a string representation.
 
@@ -789,7 +789,7 @@ Converts the given value `v` into a string representation.
 string(123) == "123"
 ```
 
-### toJSON(v)
+### toJSON(v) {#toJSON}
 
 Converts the given value `v` to its JSON string representation.
 
@@ -797,7 +797,7 @@ Converts the given value `v` to its JSON string representation.
 toJSON({"name": "John", "age": 30})
 ```
 
-### fromJSON(v)
+### fromJSON(v) {#fromJSON}
 
 Parses the given JSON string `v` and returns the corresponding value.
 
@@ -805,7 +805,7 @@ Parses the given JSON string `v` and returns the corresponding value.
 fromJSON('{"name": "John", "age": 30}')
 ```
 
-### toBase64(v)
+### toBase64(v) {#toBase64}
 
 Encodes the string `v` into Base64 format.
 
@@ -813,7 +813,7 @@ Encodes the string `v` into Base64 format.
 toBase64("Hello World") == "SGVsbG8gV29ybGQ="
 ```
 
-### fromBase64(v)
+### fromBase64(v) {#fromBase64}
 
 Decodes the Base64 encoded string `v` back to its original form.
 
@@ -821,7 +821,7 @@ Decodes the Base64 encoded string `v` back to its original form.
 fromBase64("SGVsbG8gV29ybGQ=") == "Hello World"
 ```
 
-### toPairs(map)
+### toPairs(map) {#toPairs}
 
 Converts a map to an array of key-value pairs.
 
@@ -829,7 +829,7 @@ Converts a map to an array of key-value pairs.
 toPairs({"name": "John", "age": 30}) == [["name", "John"], ["age", 30]]
 ```
 
-### fromPairs(array)
+### fromPairs(array) {#fromPairs}
 
 Converts an array of key-value pairs to a map.
 
@@ -839,7 +839,7 @@ fromPairs([["name", "John"], ["age", 30]]) == {"name": "John", "age": 30}
 
 ## Miscellaneous Functions
 
-### len(v)
+### len(v) {#len}
 
 Returns the length of an array, a map or a string.
 
@@ -849,7 +849,7 @@ len({"name": "John", "age": 30}) == 2
 len("Hello") == 5
 ```
 
-### get(v, index)
+### get(v, index) {#get}
 
 Retrieves the element at the specified index from an array or map `v`. If the index is out of range, returns `nil`.
 Or the key does not exist, returns `nil`.
@@ -861,7 +861,7 @@ get({"name": "John", "age": 30}, "name") == "John"
 
 ## Bitwise Functions
 
-### bitand(int, int)
+### bitand(int, int) {#bitand}
 
 Returns the values resulting from the bitwise AND operation.
 
@@ -869,7 +869,7 @@ Returns the values resulting from the bitwise AND operation.
 bitand(0b1010, 0b1100) == 0b1000
 ```
 
-### bitor(int, int)
+### bitor(int, int) {#bitor}
 
 Returns the values resulting from the bitwise OR operation.
 
@@ -877,7 +877,7 @@ Returns the values resulting from the bitwise OR operation.
 bitor(0b1010, 0b1100) == 0b1110
 ```
 
-### bitxor(int, int)
+### bitxor(int, int) {#bitxor}
 
 Returns the values resulting from the bitwise XOR operation.
 
@@ -885,7 +885,7 @@ Returns the values resulting from the bitwise XOR operation.
 bitxor(0b1010, 0b1100) == 0b110
 ```
 
-### bitnand(int, int)
+### bitnand(int, int) {#bitnand}
 
 Returns the values resulting from the bitwise AND NOT operation.
 
@@ -893,7 +893,7 @@ Returns the values resulting from the bitwise AND NOT operation.
 bitnand(0b1010, 0b1100) == 0b10
 ```
 
-### bitnot(int)
+### bitnot(int) {#bitnot}
 
 Returns the values resulting from the bitwise NOT operation.
 
@@ -901,7 +901,7 @@ Returns the values resulting from the bitwise NOT operation.
 bitnot(0b1010) == -0b1011
 ```
 
-### bitshl(int, int)
+### bitshl(int, int) {#bitshl}
 
 Returns the values resulting from the Left Shift operation.
 
@@ -909,7 +909,7 @@ Returns the values resulting from the Left Shift operation.
 bitshl(0b101101, 2) == 0b10110100
 ```
 
-### bitshr(int, int)
+### bitshr(int, int) {#bitshr}
 
 Returns the values resulting from the Right Shift operation.
 
@@ -917,7 +917,7 @@ Returns the values resulting from the Right Shift operation.
 bitshr(0b101101, 2) == 0b1011
 ```
 
-### bitushr(int, int)
+### bitushr(int, int) {#bitushr}
 
 Returns the values resulting from the unsigned Right Shift operation.
 

From f631fd2c26c46dd10b9e3d494dfa703a4a6d7b1f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 6 Jan 2024 20:08:05 +0100
Subject: [PATCH 236/506] Add info about nested predicates

---
 docs/language-definition.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/docs/language-definition.md b/docs/language-definition.md
index 7574ff2f9..3b72c0832 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -296,6 +296,17 @@ Braces `{` `}` can be omitted:
 filter(tweets, len(.Content) > 240)
 ```
 
+:::tip
+In nested predicates, to access the outer variable, use [variables](#variables).
+
+```expr
+filter(posts, {
+    let post = #; 
+    any(.Comments, .Author == post.Author)
+}) 
+```
+:::
+
 ## String Functions
 
 ### trim(str[, chars]) {#trim}

From bca1aaa9022bea221de7431fc7709fe3afd77463 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 12 Jan 2024 21:58:13 +0100
Subject: [PATCH 237/506] Add [generated] tags to files (#518)

---
 vm/func_types/main.go                         |  4 +-
 vm/{generated.go => func_types[generated].go} | 80 +++++++++----------
 vm/runtime/helpers/main.go                    |  4 -
 .../{generated.go => helpers[generated].go}   |  2 +-
 vm/runtime/runtime.go                         |  2 +-
 vm/vm.go                                      |  2 +-
 6 files changed, 45 insertions(+), 49 deletions(-)
 rename vm/{generated.go => func_types[generated].go} (73%)
 rename vm/runtime/{generated.go => helpers[generated].go} (99%)

diff --git a/vm/func_types/main.go b/vm/func_types/main.go
index 6262261ef..286a1f053 100644
--- a/vm/func_types/main.go
+++ b/vm/func_types/main.go
@@ -127,11 +127,11 @@ import (
 	"time"
 )
 
-var FuncTypes = []interface{}{
+var FuncTypes = []any{
 	{{ .Index }}
 }
 
-func (vm *VM) call(fn interface{}, kind int) interface{} {
+func (vm *VM) call(fn any, kind int) any {
 	switch kind {
 	{{ .Code }}
 	}
diff --git a/vm/generated.go b/vm/func_types[generated].go
similarity index 73%
rename from vm/generated.go
rename to vm/func_types[generated].go
index 1a0b36571..1375f22f2 100644
--- a/vm/generated.go
+++ b/vm/func_types[generated].go
@@ -13,14 +13,14 @@ var FuncTypes = []any{
 	3:  new(func() time.Time),
 	4:  new(func() time.Weekday),
 	5:  new(func() []uint8),
-	6:  new(func() []any),
+	6:  new(func() []interface{}),
 	7:  new(func() bool),
 	8:  new(func() uint8),
 	9:  new(func() float64),
 	10: new(func() int),
 	11: new(func() int64),
-	12: new(func() any),
-	13: new(func() map[string]any),
+	12: new(func() interface{}),
+	13: new(func() map[string]interface{}),
 	14: new(func() int32),
 	15: new(func() string),
 	16: new(func() uint),
@@ -29,7 +29,7 @@ var FuncTypes = []any{
 	19: new(func(time.Duration) time.Time),
 	20: new(func(time.Time) time.Duration),
 	21: new(func(time.Time) bool),
-	22: new(func([]any, string) string),
+	22: new(func([]interface{}, string) string),
 	23: new(func([]string, string) string),
 	24: new(func(bool) bool),
 	25: new(func(bool) float64),
@@ -56,20 +56,20 @@ var FuncTypes = []any{
 	46: new(func(string, int32) int),
 	47: new(func(string, string) bool),
 	48: new(func(string, string) string),
-	49: new(func(any) bool),
-	50: new(func(any) float64),
-	51: new(func(any) int),
-	52: new(func(any) string),
-	53: new(func(any) any),
-	54: new(func(any) []any),
-	55: new(func(any) map[string]any),
-	56: new(func([]any) any),
-	57: new(func([]any) []any),
-	58: new(func([]any) map[string]any),
-	59: new(func(any, any) bool),
-	60: new(func(any, any) string),
-	61: new(func(any, any) any),
-	62: new(func(any, any) []any),
+	49: new(func(interface{}) bool),
+	50: new(func(interface{}) float64),
+	51: new(func(interface{}) int),
+	52: new(func(interface{}) string),
+	53: new(func(interface{}) interface{}),
+	54: new(func(interface{}) []interface{}),
+	55: new(func(interface{}) map[string]interface{}),
+	56: new(func([]interface{}) interface{}),
+	57: new(func([]interface{}) []interface{}),
+	58: new(func([]interface{}) map[string]interface{}),
+	59: new(func(interface{}, interface{}) bool),
+	60: new(func(interface{}, interface{}) string),
+	61: new(func(interface{}, interface{}) interface{}),
+	62: new(func(interface{}, interface{}) []interface{}),
 }
 
 func (vm *VM) call(fn any, kind int) any {
@@ -85,7 +85,7 @@ func (vm *VM) call(fn any, kind int) any {
 	case 5:
 		return fn.(func() []uint8)()
 	case 6:
-		return fn.(func() []any)()
+		return fn.(func() []interface{})()
 	case 7:
 		return fn.(func() bool)()
 	case 8:
@@ -97,9 +97,9 @@ func (vm *VM) call(fn any, kind int) any {
 	case 11:
 		return fn.(func() int64)()
 	case 12:
-		return fn.(func() any)()
+		return fn.(func() interface{})()
 	case 13:
-		return fn.(func() map[string]any)()
+		return fn.(func() map[string]interface{})()
 	case 14:
 		return fn.(func() int32)()
 	case 15:
@@ -122,8 +122,8 @@ func (vm *VM) call(fn any, kind int) any {
 		return fn.(func(time.Time) bool)(arg1)
 	case 22:
 		arg2 := vm.pop().(string)
-		arg1 := vm.pop().([]any)
-		return fn.(func([]any, string) string)(arg1, arg2)
+		arg1 := vm.pop().([]interface{})
+		return fn.(func([]interface{}, string) string)(arg1, arg2)
 	case 23:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().([]string)
@@ -212,50 +212,50 @@ func (vm *VM) call(fn any, kind int) any {
 		return fn.(func(string, string) string)(arg1, arg2)
 	case 49:
 		arg1 := vm.pop()
-		return fn.(func(any) bool)(arg1)
+		return fn.(func(interface{}) bool)(arg1)
 	case 50:
 		arg1 := vm.pop()
-		return fn.(func(any) float64)(arg1)
+		return fn.(func(interface{}) float64)(arg1)
 	case 51:
 		arg1 := vm.pop()
-		return fn.(func(any) int)(arg1)
+		return fn.(func(interface{}) int)(arg1)
 	case 52:
 		arg1 := vm.pop()
-		return fn.(func(any) string)(arg1)
+		return fn.(func(interface{}) string)(arg1)
 	case 53:
 		arg1 := vm.pop()
-		return fn.(func(any) any)(arg1)
+		return fn.(func(interface{}) interface{})(arg1)
 	case 54:
 		arg1 := vm.pop()
-		return fn.(func(any) []any)(arg1)
+		return fn.(func(interface{}) []interface{})(arg1)
 	case 55:
 		arg1 := vm.pop()
-		return fn.(func(any) map[string]any)(arg1)
+		return fn.(func(interface{}) map[string]interface{})(arg1)
 	case 56:
-		arg1 := vm.pop().([]any)
-		return fn.(func([]any) any)(arg1)
+		arg1 := vm.pop().([]interface{})
+		return fn.(func([]interface{}) interface{})(arg1)
 	case 57:
-		arg1 := vm.pop().([]any)
-		return fn.(func([]any) []any)(arg1)
+		arg1 := vm.pop().([]interface{})
+		return fn.(func([]interface{}) []interface{})(arg1)
 	case 58:
-		arg1 := vm.pop().([]any)
-		return fn.(func([]any) map[string]any)(arg1)
+		arg1 := vm.pop().([]interface{})
+		return fn.(func([]interface{}) map[string]interface{})(arg1)
 	case 59:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
-		return fn.(func(any, any) bool)(arg1, arg2)
+		return fn.(func(interface{}, interface{}) bool)(arg1, arg2)
 	case 60:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
-		return fn.(func(any, any) string)(arg1, arg2)
+		return fn.(func(interface{}, interface{}) string)(arg1, arg2)
 	case 61:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
-		return fn.(func(any, any) any)(arg1, arg2)
+		return fn.(func(interface{}, interface{}) interface{})(arg1, arg2)
 	case 62:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
-		return fn.(func(any, any) []any)(arg1, arg2)
+		return fn.(func(interface{}, interface{}) []interface{})(arg1, arg2)
 
 	}
 	panic(fmt.Sprintf("unknown function kind (%v)", kind))
diff --git a/vm/runtime/helpers/main.go b/vm/runtime/helpers/main.go
index 66eb68dba..b3f598a43 100644
--- a/vm/runtime/helpers/main.go
+++ b/vm/runtime/helpers/main.go
@@ -93,10 +93,6 @@ func isFloat(t string) bool {
 	return strings.HasPrefix(t, "float")
 }
 
-func isInt(t string) bool {
-	return strings.HasPrefix(t, "int")
-}
-
 func isDuration(t string) bool {
 	return t == "time.Duration"
 }
diff --git a/vm/runtime/generated.go b/vm/runtime/helpers[generated].go
similarity index 99%
rename from vm/runtime/generated.go
rename to vm/runtime/helpers[generated].go
index a5b92f477..720feb455 100644
--- a/vm/runtime/generated.go
+++ b/vm/runtime/helpers[generated].go
@@ -3372,4 +3372,4 @@ func Modulo(a, b interface{}) int {
 		}
 	}
 	panic(fmt.Sprintf("invalid operation: %T %% %T", a, b))
-}
\ No newline at end of file
+}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 406f85096..09c58bdf7 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -1,6 +1,6 @@
 package runtime
 
-//go:generate sh -c "go run ./helpers > ./generated.go"
+//go:generate sh -c "go run ./helpers > ./helpers[generated].go"
 
 import (
 	"fmt"
diff --git a/vm/vm.go b/vm/vm.go
index fa2c75899..4c2ff04fa 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -1,6 +1,6 @@
 package vm
 
-//go:generate sh -c "go run ./func_types > ./generated.go"
+//go:generate sh -c "go run ./func_types > ./func_types[generated].go"
 
 import (
 	"fmt"

From 1b3c10c0ef680ae4e6b6b3558308b233958b07f2 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 12 Jan 2024 22:03:10 +0100
Subject: [PATCH 238/506] Simplify abs

---
 builtin/lib.go | 50 +++++++++++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/builtin/lib.go b/builtin/lib.go
index 1deca3f99..228a74893 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -62,76 +62,76 @@ func Type(arg any) any {
 }
 
 func Abs(x any) any {
-	switch x.(type) {
+	switch x := x.(type) {
 	case float32:
-		if x.(float32) < 0 {
-			return -x.(float32)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case float64:
-		if x.(float64) < 0 {
-			return -x.(float64)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case int:
-		if x.(int) < 0 {
-			return -x.(int)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case int8:
-		if x.(int8) < 0 {
-			return -x.(int8)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case int16:
-		if x.(int16) < 0 {
-			return -x.(int16)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case int32:
-		if x.(int32) < 0 {
-			return -x.(int32)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case int64:
-		if x.(int64) < 0 {
-			return -x.(int64)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case uint:
-		if x.(uint) < 0 {
-			return -x.(uint)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case uint8:
-		if x.(uint8) < 0 {
-			return -x.(uint8)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case uint16:
-		if x.(uint16) < 0 {
-			return -x.(uint16)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case uint32:
-		if x.(uint32) < 0 {
-			return -x.(uint32)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}
 	case uint64:
-		if x.(uint64) < 0 {
-			return -x.(uint64)
+		if x < 0 {
+			return -x
 		} else {
 			return x
 		}

From db94b967cddea3fbac812c76218b6797bd328f90 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 13 Jan 2024 13:14:38 +0100
Subject: [PATCH 239/506] Add build tag: expr_debug (#521)

---
 .github/workflows/test.yml |  11 ++++
 debug/debugger.go          |  10 ++--
 vm/debug.go                |   5 ++
 vm/debug_off.go            |   5 ++
 vm/debug_test.go           |  40 +++++++++++++++
 vm/utils.go                |  11 ++++
 vm/vm.go                   | 100 ++++++++++++++++---------------------
 vm/vm_test.go              |  27 ----------
 8 files changed, 123 insertions(+), 86 deletions(-)
 create mode 100644 vm/debug.go
 create mode 100644 vm/debug_off.go
 create mode 100644 vm/debug_test.go
 create mode 100644 vm/utils.go

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 8a8b87873..2fa55aae8 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -20,3 +20,14 @@ jobs:
           go-version: ${{ matrix.go-version }}
       - name: Test
         run: go test ./...
+
+  debug:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Go 1.18
+        uses: actions/setup-go@v4
+        with:
+          go-version: 1.18
+      - name: Test
+        run: go test -tags=expr_debug -run=TestDebugger -v ./vm
diff --git a/debug/debugger.go b/debug/debugger.go
index a870973ca..6f341e30e 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -7,9 +7,10 @@ import (
 	"strings"
 	"time"
 
-	. "github.com/expr-lang/expr/vm"
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
+
+	. "github.com/expr-lang/expr/vm"
 )
 
 func StartDebugger(program *Program, env any) {
@@ -112,14 +113,17 @@ func StartDebugger(program *Program, env any) {
 			}
 
 			stack.Clear()
-			for i, value := range vm.Stack() {
+			for i, value := range vm.Stack {
 				stack.SetCellSimple(i, 0, fmt.Sprintf("% *d: ", 2, i))
 				stack.SetCellSimple(i, 1, fmt.Sprintf("%#v", value))
 			}
 			stack.ScrollToEnd()
 
 			scope.Clear()
-			s := vm.Scope()
+			var s *Scope
+			if len(vm.Scopes) > 0 {
+				s = vm.Scopes[len(vm.Scopes)-1]
+			}
 			if s != nil {
 				type pair struct {
 					key   string
diff --git a/vm/debug.go b/vm/debug.go
new file mode 100644
index 000000000..ab95bf9a0
--- /dev/null
+++ b/vm/debug.go
@@ -0,0 +1,5 @@
+//go:build expr_debug
+
+package vm
+
+const debug = true
diff --git a/vm/debug_off.go b/vm/debug_off.go
new file mode 100644
index 000000000..e0f2955a1
--- /dev/null
+++ b/vm/debug_off.go
@@ -0,0 +1,5 @@
+//go:build !expr_debug
+
+package vm
+
+const debug = false
diff --git a/vm/debug_test.go b/vm/debug_test.go
new file mode 100644
index 000000000..576960f06
--- /dev/null
+++ b/vm/debug_test.go
@@ -0,0 +1,40 @@
+//go:build expr_debug
+
+package vm_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr/compiler"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/vm"
+)
+
+func TestDebugger(t *testing.T) {
+	input := `[1, 2]`
+
+	node, err := parser.Parse(input)
+	require.NoError(t, err)
+
+	program, err := compiler.Compile(node, nil)
+	require.NoError(t, err)
+
+	debug := vm.Debug()
+	go func() {
+		debug.Step()
+		debug.Step()
+		debug.Step()
+		debug.Step()
+	}()
+	go func() {
+		for range debug.Position() {
+		}
+	}()
+
+	_, err = debug.Run(program, nil)
+	require.NoError(t, err)
+	require.Len(t, debug.Stack, 0)
+	require.Nil(t, debug.Scopes)
+}
diff --git a/vm/utils.go b/vm/utils.go
new file mode 100644
index 000000000..f9ec81a8c
--- /dev/null
+++ b/vm/utils.go
@@ -0,0 +1,11 @@
+package vm
+
+import (
+	"reflect"
+)
+
+type Function = func(params ...any) (any, error)
+
+var MemoryBudget uint = 1e6
+
+var errorType = reflect.TypeOf((*error)(nil)).Elem()
diff --git a/vm/vm.go b/vm/vm.go
index 4c2ff04fa..5ae4d0687 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -13,11 +13,6 @@ import (
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
-var MemoryBudget uint = 1e6
-var errorType = reflect.TypeOf((*error)(nil)).Elem()
-
-type Function = func(params ...any) (any, error)
-
 func Run(program *Program, env any) (any, error) {
 	if program == nil {
 		return nil, fmt.Errorf("program is nil")
@@ -27,15 +22,24 @@ func Run(program *Program, env any) (any, error) {
 	return vm.Run(program, env)
 }
 
+func Debug() *VM {
+	vm := &VM{
+		debug: true,
+		step:  make(chan struct{}, 0),
+		curr:  make(chan int, 0),
+	}
+	return vm
+}
+
 type VM struct {
-	stack        []any
+	Stack        []any
+	Scopes       []*Scope
 	ip           int
-	scopes       []*Scope
+	memory       uint
+	memoryBudget uint
 	debug        bool
 	step         chan struct{}
 	curr         chan int
-	memory       uint
-	memoryBudget uint
 }
 
 type Scope struct {
@@ -47,15 +51,6 @@ type Scope struct {
 	Acc     any
 }
 
-func Debug() *VM {
-	vm := &VM{
-		debug: true,
-		step:  make(chan struct{}, 0),
-		curr:  make(chan int, 0),
-	}
-	return vm
-}
-
 func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -74,14 +69,14 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		}
 	}()
 
-	if vm.stack == nil {
-		vm.stack = make([]any, 0, 2)
+	if vm.Stack == nil {
+		vm.Stack = make([]any, 0, 2)
 	} else {
-		vm.stack = vm.stack[0:0]
+		vm.Stack = vm.Stack[0:0]
 	}
 
-	if vm.scopes != nil {
-		vm.scopes = vm.scopes[0:0]
+	if vm.Scopes != nil {
+		vm.Scopes = vm.Scopes[0:0]
 	}
 
 	vm.memoryBudget = MemoryBudget
@@ -89,7 +84,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 	vm.ip = 0
 
 	for vm.ip < len(program.Bytecode) {
-		if vm.debug {
+		if debug && vm.debug {
 			<-vm.step
 		}
 
@@ -204,7 +199,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			}
 
 		case OpJumpIfEnd:
-			scope := vm.Scope()
+			scope := vm.scope()
 			if scope.Index >= scope.Len {
 				vm.ip += arg
 			}
@@ -399,7 +394,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 
 		case OpValidateArgs:
 			fn := vm.pop().(Function)
-			mem, err := fn(vm.stack[len(vm.stack)-arg:]...)
+			mem, err := fn(vm.Stack[len(vm.Stack)-arg:]...)
 			if err != nil {
 				panic(err)
 			}
@@ -443,49 +438,49 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.push(runtime.Deref(a))
 
 		case OpIncrementIndex:
-			vm.Scope().Index++
+			vm.scope().Index++
 
 		case OpDecrementIndex:
-			scope := vm.Scope()
+			scope := vm.scope()
 			scope.Index--
 
 		case OpIncrementCount:
-			scope := vm.Scope()
+			scope := vm.scope()
 			scope.Count++
 
 		case OpGetIndex:
-			vm.push(vm.Scope().Index)
+			vm.push(vm.scope().Index)
 
 		case OpSetIndex:
-			scope := vm.Scope()
+			scope := vm.scope()
 			scope.Index = vm.pop().(int)
 
 		case OpGetCount:
-			scope := vm.Scope()
+			scope := vm.scope()
 			vm.push(scope.Count)
 
 		case OpGetLen:
-			scope := vm.Scope()
+			scope := vm.scope()
 			vm.push(scope.Len)
 
 		case OpGetGroupBy:
-			vm.push(vm.Scope().GroupBy)
+			vm.push(vm.scope().GroupBy)
 
 		case OpGetAcc:
-			vm.push(vm.Scope().Acc)
+			vm.push(vm.scope().Acc)
 
 		case OpSetAcc:
-			vm.Scope().Acc = vm.pop()
+			vm.scope().Acc = vm.pop()
 
 		case OpPointer:
-			scope := vm.Scope()
+			scope := vm.scope()
 			vm.push(scope.Array.Index(scope.Index).Interface())
 
 		case OpThrow:
 			panic(vm.pop().(error))
 
 		case OpGroupBy:
-			scope := vm.Scope()
+			scope := vm.scope()
 			if scope.GroupBy == nil {
 				scope.GroupBy = make(map[any][]any)
 			}
@@ -496,29 +491,29 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpBegin:
 			a := vm.pop()
 			array := reflect.ValueOf(a)
-			vm.scopes = append(vm.scopes, &Scope{
+			vm.Scopes = append(vm.Scopes, &Scope{
 				Array: array,
 				Len:   array.Len(),
 			})
 
 		case OpEnd:
-			vm.scopes = vm.scopes[:len(vm.scopes)-1]
+			vm.Scopes = vm.Scopes[:len(vm.Scopes)-1]
 
 		default:
 			panic(fmt.Sprintf("unknown bytecode %#x", op))
 		}
 
-		if vm.debug {
+		if debug && vm.debug {
 			vm.curr <- vm.ip
 		}
 	}
 
-	if vm.debug {
+	if debug && vm.debug {
 		close(vm.curr)
 		close(vm.step)
 	}
 
-	if len(vm.stack) > 0 {
+	if len(vm.Stack) > 0 {
 		return vm.pop(), nil
 	}
 
@@ -526,16 +521,16 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 }
 
 func (vm *VM) push(value any) {
-	vm.stack = append(vm.stack, value)
+	vm.Stack = append(vm.Stack, value)
 }
 
 func (vm *VM) current() any {
-	return vm.stack[len(vm.stack)-1]
+	return vm.Stack[len(vm.Stack)-1]
 }
 
 func (vm *VM) pop() any {
-	value := vm.stack[len(vm.stack)-1]
-	vm.stack = vm.stack[:len(vm.stack)-1]
+	value := vm.Stack[len(vm.Stack)-1]
+	vm.Stack = vm.Stack[:len(vm.Stack)-1]
 	return value
 }
 
@@ -546,15 +541,8 @@ func (vm *VM) memGrow(size uint) {
 	}
 }
 
-func (vm *VM) Stack() []any {
-	return vm.stack
-}
-
-func (vm *VM) Scope() *Scope {
-	if len(vm.scopes) > 0 {
-		return vm.scopes[len(vm.scopes)-1]
-	}
-	return nil
+func (vm *VM) scope() *Scope {
+	return vm.Scopes[len(vm.Scopes)-1]
 }
 
 func (vm *VM) Step() {
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 0cbbb8998..17768c148 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -20,33 +20,6 @@ func TestRun_NilProgram(t *testing.T) {
 	require.Error(t, err)
 }
 
-func TestRun_Debugger(t *testing.T) {
-	input := `[1, 2]`
-
-	node, err := parser.Parse(input)
-	require.NoError(t, err)
-
-	program, err := compiler.Compile(node, nil)
-	require.NoError(t, err)
-
-	debug := vm.Debug()
-	go func() {
-		debug.Step()
-		debug.Step()
-		debug.Step()
-		debug.Step()
-	}()
-	go func() {
-		for range debug.Position() {
-		}
-	}()
-
-	_, err = debug.Run(program, nil)
-	require.NoError(t, err)
-	require.Len(t, debug.Stack(), 0)
-	require.Nil(t, debug.Scope())
-}
-
 func TestRun_ReuseVM(t *testing.T) {
 	node, err := parser.Parse(`map(1..2, {#})`)
 	require.NoError(t, err)

From b2f6fb83b7e749d225dfea77a56acf8624cccbf1 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 13 Jan 2024 15:56:49 +0100
Subject: [PATCH 240/506] Allow to override builtins (#522)

* Allow to override builtins

* Add :: syntax to access builtin in case of override
---
 builtin/builtin_test.go    | 84 ++++++++++++++++++++++++++------------
 checker/checker.go         | 24 ++++++-----
 conf/config.go             | 22 ++++------
 parser/lexer/lexer_test.go |  8 ++++
 parser/lexer/state.go      |  5 ++-
 parser/parser.go           | 21 +++++++---
 parser/parser_test.go      | 23 +++++++++++
 7 files changed, 130 insertions(+), 57 deletions(-)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 23273a246..0cdf9515d 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -284,37 +284,71 @@ func TestBuiltin_memory_limits(t *testing.T) {
 	}
 }
 
-func TestBuiltin_disallow_builtins_override(t *testing.T) {
-	t.Run("via env", func(t *testing.T) {
-		env := map[string]any{
-			"len": func() int { return 42 },
-			"repeat": func(a string) string {
-				return a
-			},
+func TestBuiltin_allow_builtins_override(t *testing.T) {
+	t.Run("via env var", func(t *testing.T) {
+		for _, name := range builtin.Names {
+			t.Run(name, func(t *testing.T) {
+				env := map[string]any{
+					name: "hello world",
+				}
+				program, err := expr.Compile(name, expr.Env(env))
+				require.NoError(t, err)
+
+				out, err := expr.Run(program, env)
+				require.NoError(t, err)
+				assert.Equal(t, "hello world", out)
+			})
+		}
+	})
+	t.Run("via env func", func(t *testing.T) {
+		for _, name := range builtin.Names {
+			t.Run(name, func(t *testing.T) {
+				env := map[string]any{
+					name: func() int { return 1 },
+				}
+				program, err := expr.Compile(fmt.Sprintf("%s()", name), expr.Env(env))
+				require.NoError(t, err)
+
+				out, err := expr.Run(program, env)
+				require.NoError(t, err)
+				assert.Equal(t, 1, out)
+			})
 		}
-		assert.Panics(t, func() {
-			_, _ = expr.Compile(`string(len("foo")) + repeat("0", 2)`, expr.Env(env))
-		})
 	})
 	t.Run("via expr.Function", func(t *testing.T) {
-		length := expr.Function("len",
-			func(params ...any) (any, error) {
-				return 42, nil
-			},
-			new(func() int),
-		)
-		repeat := expr.Function("repeat",
-			func(params ...any) (any, error) {
-				return params[0], nil
-			},
-			new(func(string) string),
-		)
-		assert.Panics(t, func() {
-			_, _ = expr.Compile(`string(len("foo")) + repeat("0", 2)`, length, repeat)
-		})
+		for _, name := range builtin.Names {
+			t.Run(name, func(t *testing.T) {
+				fn := expr.Function(name,
+					func(params ...any) (any, error) {
+						return 42, nil
+					},
+					new(func() int),
+				)
+				program, err := expr.Compile(fmt.Sprintf("%s()", name), fn)
+				require.NoError(t, err)
+
+				out, err := expr.Run(program, nil)
+				require.NoError(t, err)
+				assert.Equal(t, 42, out)
+			})
+		}
 	})
 }
 
+func TestBuiltin_override_and_still_accessible(t *testing.T) {
+	env := map[string]any{
+		"len": func() int { return 42 },
+		"all": []int{1, 2, 3},
+	}
+
+	program, err := expr.Compile(`::all(all, #>0) && len() == 42 && ::len(all) == 3`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, true, out)
+}
+
 func TestBuiltin_DisableBuiltin(t *testing.T) {
 	t.Run("via env", func(t *testing.T) {
 		for _, b := range builtin.Builtins {
diff --git a/checker/checker.go b/checker/checker.go
index 4dced34ea..5dd722fee 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -156,24 +156,25 @@ func (v *checker) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 	if node.Value == "$env" {
 		return mapType, info{}
 	}
-	if fn, ok := v.config.Builtins[node.Value]; ok {
-		return functionType, info{fn: fn}
-	}
-	if fn, ok := v.config.Functions[node.Value]; ok {
-		return functionType, info{fn: fn}
-	}
-	return v.env(node, node.Value, true)
+	return v.ident(node, node.Value, true, true)
 }
 
-// env method returns type of environment variable. env only lookups for
-// environment variables, no builtins, no custom functions.
-func (v *checker) env(node ast.Node, name string, strict bool) (reflect.Type, info) {
+// ident method returns type of environment variable, builtin or function.
+func (v *checker) ident(node ast.Node, name string, strict, builtins bool) (reflect.Type, info) {
 	if t, ok := v.config.Types[name]; ok {
 		if t.Ambiguous {
 			return v.error(node, "ambiguous identifier %v", name)
 		}
 		return t.Type, info{method: t.Method}
 	}
+	if builtins {
+		if fn, ok := v.config.Functions[name]; ok {
+			return functionType, info{fn: fn}
+		}
+		if fn, ok := v.config.Builtins[name]; ok {
+			return functionType, info{fn: fn}
+		}
+	}
 	if v.config.Strict && strict {
 		return v.error(node, "unknown name %v", name)
 	}
@@ -433,6 +434,7 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 	base, _ := v.visit(node.Node)
 	prop, _ := v.visit(node.Property)
 
+	// $env variable
 	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "$env" {
 		if name, ok := node.Property.(*ast.StringNode); ok {
 			strict := v.config.Strict
@@ -443,7 +445,7 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 				// should throw error if field is not found & v.config.Strict.
 				strict = false
 			}
-			return v.env(node, name.Value, strict)
+			return v.ident(node, name.Value, strict, false /* no builtins and no functions */)
 		}
 		return anyType, info{}
 	}
diff --git a/conf/config.go b/conf/config.go
index 48d491a96..baf5dee05 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -98,20 +98,14 @@ func (c *Config) Check() {
 			}
 		}
 	}
-	for fnName, t := range c.Types {
-		if kind(t.Type) == reflect.Func {
-			for _, b := range c.Builtins {
-				if b.Name == fnName {
-					panic(fmt.Errorf(`cannot override builtin %s(): use expr.DisableBuiltin("%s") to override`, b.Name, b.Name))
-				}
-			}
-		}
+}
+
+func (c *Config) IsOverridden(name string) bool {
+	if _, ok := c.Functions[name]; ok {
+		return true
 	}
-	for _, f := range c.Functions {
-		for _, b := range c.Builtins {
-			if b.Name == f.Name {
-				panic(fmt.Errorf(`cannot override builtin %s(); use expr.DisableBuiltin("%s") to override`, f.Name, f.Name))
-			}
-		}
+	if _, ok := c.Types[name]; ok {
+		return true
 	}
+	return false
 }
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index feecf045d..442fd4dbd 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -225,6 +225,14 @@ func TestLex(t *testing.T) {
 				{Kind: EOF},
 			},
 		},
+		{
+			`: ::`,
+			[]Token{
+				{Kind: Operator, Value: ":"},
+				{Kind: Operator, Value: "::"},
+				{Kind: EOF},
+			},
+		},
 	}
 
 	for _, test := range tests {
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index 9999fd3c5..72f02bf4e 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -37,11 +37,14 @@ func root(l *lexer) stateFn {
 	case r == '|':
 		l.accept("|")
 		l.emit(Operator)
+	case r == ':':
+		l.accept(":")
+		l.emit(Operator)
 	case strings.ContainsRune("([{", r):
 		l.emit(Bracket)
 	case strings.ContainsRune(")]}", r):
 		l.emit(Bracket)
-	case strings.ContainsRune(",:;%+-^", r): // single rune operator
+	case strings.ContainsRune(",;%+-^", r): // single rune operator
 		l.emit(Operator)
 	case strings.ContainsRune("&!=*<>", r): // possible double rune operator
 		l.accept("&=*")
diff --git a/parser/parser.go b/parser/parser.go
index 5f29279bc..1ce1cda0e 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -275,6 +275,13 @@ func (p *parser) parsePrimary() Node {
 		}
 	}
 
+	if token.Is(Operator, "::") {
+		p.next()
+		token = p.current
+		p.expect(Identifier)
+		return p.parsePostfixExpression(p.parseCall(token, false))
+	}
+
 	return p.parseSecondary()
 }
 
@@ -300,7 +307,7 @@ func (p *parser) parseSecondary() Node {
 			node.SetLocation(token.Location)
 			return node
 		default:
-			node = p.parseCall(token)
+			node = p.parseCall(token, true)
 		}
 
 	case Number:
@@ -379,15 +386,17 @@ func (p *parser) toFloatNode(number float64) Node {
 	return &FloatNode{Value: number}
 }
 
-func (p *parser) parseCall(token Token) Node {
+func (p *parser) parseCall(token Token, checkOverrides bool) Node {
 	var node Node
 	if p.current.Is(Bracket, "(") {
 		var arguments []Node
 
-		if b, ok := predicates[token.Value]; ok {
-			p.expect(Bracket, "(")
+		isOverridden := p.config.IsOverridden(token.Value)
+		isOverridden = isOverridden && checkOverrides
 
-			// TODO: Refactor parser to use builtin.Builtins instead of predicates map.
+		// TODO: Refactor parser to use builtin.Builtins instead of predicates map.
+		if b, ok := predicates[token.Value]; ok && !isOverridden {
+			p.expect(Bracket, "(")
 
 			if b.arity == 1 {
 				arguments = make([]Node, 1)
@@ -417,7 +426,7 @@ func (p *parser) parseCall(token Token) Node {
 				Arguments: arguments,
 			}
 			node.SetLocation(token.Location)
-		} else if _, ok := builtin.Index[token.Value]; ok && !p.config.Disabled[token.Value] {
+		} else if _, ok := builtin.Index[token.Value]; ok && !p.config.Disabled[token.Value] && !isOverridden {
 			node = &BuiltinNode{
 				Name:      token.Value,
 				Arguments: p.parseArguments(),
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 453fe91ac..0e7a23837 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -498,6 +498,29 @@ world`},
 				},
 			},
 		},
+		{
+			`::split("a,b,c", ",")`,
+			&BuiltinNode{
+				Name: "split",
+				Arguments: []Node{
+					&StringNode{Value: "a,b,c"},
+					&StringNode{Value: ","},
+				},
+			},
+		},
+		{
+			`::split("a,b,c", ",")[0]`,
+			&MemberNode{
+				Node: &BuiltinNode{
+					Name: "split",
+					Arguments: []Node{
+						&StringNode{Value: "a,b,c"},
+						&StringNode{Value: ","},
+					},
+				},
+				Property: &IntegerNode{Value: 0},
+			},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {

From 523a091bcc4439823dfc22fefb7a22d34bec72a9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 13 Jan 2024 20:41:14 +0100
Subject: [PATCH 241/506] Fix race cond in variabels (#523)

* Add race cond test

* Move variables array to vm

* Resize vars array for different programs
---
 .github/workflows/test.yml | 11 +++++++++++
 compiler/compiler.go       |  9 ++++-----
 expr_test.go               | 20 ++++++++++++++++++++
 vm/program.go              |  4 ++--
 vm/vm.go                   |  9 ++++++---
 vm/vm_test.go              | 23 +++++++++++++++++++++++
 6 files changed, 66 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 2fa55aae8..087bbc7c4 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -31,3 +31,14 @@ jobs:
           go-version: 1.18
       - name: Test
         run: go test -tags=expr_debug -run=TestDebugger -v ./vm
+
+  race:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Go 1.21
+        uses: actions/setup-go@v4
+        with:
+          go-version: 1.21
+      - name: Test
+        run: go test -race .
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 1f1c00c92..d4ed3c8c4 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -64,7 +64,7 @@ type compiler struct {
 	config         *conf.Config
 	locations      []file.Location
 	bytecode       []Opcode
-	variables      []any
+	variables      int
 	scopes         []scope
 	constants      []any
 	constantsIndex map[any]int
@@ -137,10 +137,9 @@ func (c *compiler) addConstant(constant any) int {
 }
 
 func (c *compiler) addVariable(name string) int {
-	c.variables = append(c.variables, nil)
-	p := len(c.variables) - 1
-	c.debugInfo[fmt.Sprintf("var_%d", p)] = name
-	return p
+	c.variables++
+	c.debugInfo[fmt.Sprintf("var_%d", c.variables-1)] = name
+	return c.variables - 1
 }
 
 // emitFunction adds builtin.Function.Func to the program.functions and emits call opcode.
diff --git a/expr_test.go b/expr_test.go
index 9d588f122..66ef11ce7 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"reflect"
+	"sync"
 	"testing"
 	"time"
 
@@ -2383,3 +2384,22 @@ func TestIssue474(t *testing.T) {
 		})
 	}
 }
+
+func TestRaceCondition_variables(t *testing.T) {
+	program, err := expr.Compile(`let foo = 1; foo + 1`, expr.Env(mock.Env{}))
+	require.NoError(t, err)
+
+	var wg sync.WaitGroup
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			out, err := expr.Run(program, mock.Env{})
+			require.NoError(t, err)
+			require.Equal(t, 2, out)
+		}()
+	}
+
+	wg.Wait()
+}
diff --git a/vm/program.go b/vm/program.go
index 085b18a7f..07ecec1c8 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -22,7 +22,7 @@ type Program struct {
 
 	source    *file.Source
 	locations []file.Location
-	variables []any
+	variables int
 	functions []Function
 	debugInfo map[string]string
 }
@@ -31,7 +31,7 @@ type Program struct {
 func NewProgram(
 	source *file.Source,
 	locations []file.Location,
-	variables []any,
+	variables int,
 	constants []any,
 	bytecode []Opcode,
 	arguments []int,
diff --git a/vm/vm.go b/vm/vm.go
index 5ae4d0687..0bde66634 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -34,6 +34,7 @@ func Debug() *VM {
 type VM struct {
 	Stack        []any
 	Scopes       []*Scope
+	Variables    []any
 	ip           int
 	memory       uint
 	memoryBudget uint
@@ -74,10 +75,12 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 	} else {
 		vm.Stack = vm.Stack[0:0]
 	}
-
 	if vm.Scopes != nil {
 		vm.Scopes = vm.Scopes[0:0]
 	}
+	if len(vm.Variables) < program.variables {
+		vm.Variables = make([]any, program.variables)
+	}
 
 	vm.memoryBudget = MemoryBudget
 	vm.memory = 0
@@ -107,10 +110,10 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.pop()
 
 		case OpStore:
-			program.variables[arg] = vm.pop()
+			vm.Variables[arg] = vm.pop()
 
 		case OpLoadVar:
-			vm.push(program.variables[arg])
+			vm.push(vm.Variables[arg])
 
 		case OpLoadConst:
 			vm.push(runtime.Fetch(env, program.Constants[arg]))
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 17768c148..2628b961d 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 
+	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/checker"
 	"github.com/expr-lang/expr/compiler"
 	"github.com/expr-lang/expr/conf"
@@ -34,6 +35,28 @@ func TestRun_ReuseVM(t *testing.T) {
 	require.NoError(t, err)
 }
 
+func TestRun_ReuseVM_for_different_variables(t *testing.T) {
+	v := vm.VM{}
+
+	program, err := expr.Compile(`let a = 1; a + 1`)
+	require.NoError(t, err)
+	out, err := v.Run(program, nil)
+	require.NoError(t, err)
+	require.Equal(t, 2, out)
+
+	program, err = expr.Compile(`let a = 2; a + 1`)
+	require.NoError(t, err)
+	out, err = v.Run(program, nil)
+	require.NoError(t, err)
+	require.Equal(t, 3, out)
+
+	program, err = expr.Compile(`let a = 2; let b = 2; a + b`)
+	require.NoError(t, err)
+	out, err = v.Run(program, nil)
+	require.NoError(t, err)
+	require.Equal(t, 4, out)
+}
+
 func TestRun_Cast(t *testing.T) {
 	input := `1`
 

From e213a6616920398b6716fad8c64cc2cf2963df97 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 14 Jan 2024 17:27:22 +0100
Subject: [PATCH 242/506] Fix context patcher (#526)

---
 builtin/builtin.go           | 10 ----------
 builtin/function.go          | 22 ++++++++++++++++++++++
 checker/checker.go           |  6 +++---
 checker/checker_test.go      |  2 +-
 checker/types.go             |  1 -
 patcher/with_context_test.go | 31 +++++++++++++++++++++++++++++++
 6 files changed, 57 insertions(+), 15 deletions(-)
 create mode 100644 builtin/function.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index cd943bd0b..14fc8a4b7 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -12,16 +12,6 @@ import (
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
-type Function struct {
-	Name         string
-	Func         func(args ...any) (any, error)
-	Fast         func(arg any) any
-	ValidateArgs func(args ...any) (any, error)
-	Types        []reflect.Type
-	Validate     func(args []reflect.Type) (reflect.Type, error)
-	Predicate    bool
-}
-
 var (
 	Index map[string]int
 	Names []string
diff --git a/builtin/function.go b/builtin/function.go
new file mode 100644
index 000000000..e6d882340
--- /dev/null
+++ b/builtin/function.go
@@ -0,0 +1,22 @@
+package builtin
+
+import (
+	"reflect"
+)
+
+type Function struct {
+	Name         string
+	Func         func(args ...any) (any, error)
+	Fast         func(arg any) any
+	ValidateArgs func(args ...any) (any, error)
+	Types        []reflect.Type
+	Validate     func(args []reflect.Type) (reflect.Type, error)
+	Predicate    bool
+}
+
+func (f *Function) Type() reflect.Type {
+	if len(f.Types) > 0 {
+		return f.Types[0]
+	}
+	return reflect.TypeOf(f.Func)
+}
diff --git a/checker/checker.go b/checker/checker.go
index 5dd722fee..0b5a0227a 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -169,10 +169,10 @@ func (v *checker) ident(node ast.Node, name string, strict, builtins bool) (refl
 	}
 	if builtins {
 		if fn, ok := v.config.Functions[name]; ok {
-			return functionType, info{fn: fn}
+			return fn.Type(), info{fn: fn}
 		}
 		if fn, ok := v.config.Builtins[name]; ok {
-			return functionType, info{fn: fn}
+			return fn.Type(), info{fn: fn}
 		}
 	}
 	if v.config.Strict && strict {
@@ -833,7 +833,7 @@ func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []
 		}
 		return t, info{}
 	} else if len(f.Types) == 0 {
-		t, err := v.checkArguments(f.Name, functionType, false, arguments, node)
+		t, err := v.checkArguments(f.Name, f.Type(), false, arguments, node)
 		if err != nil {
 			if v.err == nil {
 				v.err = err
diff --git a/checker/checker_test.go b/checker/checker_test.go
index d03e3a8ee..35daeda45 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -994,7 +994,7 @@ func TestCheck_builtin_without_call(t *testing.T) {
 		err   string
 	}{
 		{`len + 1`, "invalid operation: + (mismatched types func(...interface {}) (interface {}, error) and int) (1:5)\n | len + 1\n | ....^"},
-		{`string.A`, "type func(...interface {}) (interface {}, error)[string] is undefined (1:8)\n | string.A\n | .......^"},
+		{`string.A`, "type func(interface {}) string[string] is undefined (1:8)\n | string.A\n | .......^"},
 	}
 
 	for _, test := range tests {
diff --git a/checker/types.go b/checker/types.go
index 662139c37..8c0805049 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -18,7 +18,6 @@ var (
 	anyType      = reflect.TypeOf(new(any)).Elem()
 	timeType     = reflect.TypeOf(time.Time{})
 	durationType = reflect.TypeOf(time.Duration(0))
-	functionType = reflect.TypeOf(new(func(...any) (any, error))).Elem()
 )
 
 func combined(a, b reflect.Type) reflect.Type {
diff --git a/patcher/with_context_test.go b/patcher/with_context_test.go
index 0d0917afe..4c2bd048f 100644
--- a/patcher/with_context_test.go
+++ b/patcher/with_context_test.go
@@ -30,3 +30,34 @@ func TestWithContext(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, 42, output)
 }
+
+func TestWithContext_with_env_Function(t *testing.T) {
+	env := map[string]any{
+		"ctx": context.TODO(),
+	}
+
+	fn := expr.Function("fn",
+		func(params ...any) (any, error) {
+			ctx := params[0].(context.Context)
+			a := params[1].(int)
+
+			return ctx.Value("value").(int) + a, nil
+		},
+		new(func(context.Context, int) int),
+	)
+
+	program, err := expr.Compile(
+		`fn(40)`,
+		expr.Env(env),
+		expr.WithContext("ctx"),
+		fn,
+	)
+	require.NoError(t, err)
+
+	ctx := context.WithValue(context.Background(), "value", 2)
+	env["ctx"] = ctx
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 42, output)
+}

From 6691bc8124ff555dbaf8001aa5cc6ded37f87a67 Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Tue, 16 Jan 2024 14:10:36 +0530
Subject: [PATCH 243/506] Support Valuer Patching for MemberNode (#525)

---
 patcher/value/value.go | 35 ++++++++++++++---------------------
 1 file changed, 14 insertions(+), 21 deletions(-)

diff --git a/patcher/value/value.go b/patcher/value/value.go
index 5af784844..59351be6b 100644
--- a/patcher/value/value.go
+++ b/patcher/value/value.go
@@ -22,13 +22,10 @@ import (
 // contain metadata such as column type and if a value is specifically a NULL value.
 //
 // Use it directly as an Option to expr.Compile()
-var ValueGetter = func() expr.Option {
-	vPatcher := patcher{}
-	return func(c *conf.Config) {
-		c.Visitors = append(c.Visitors, vPatcher)
-		getValueFunc(c)
-	}
-}()
+var ValueGetter = expr.Option(func(c *conf.Config) {
+	c.Visitors = append(c.Visitors, patcher{})
+	getValueFunc(c)
+})
 
 // A AnyValuer provides a generic function for a custom type to return standard go values.
 // It allows for returning a `nil` value but does not provide any type checking at expression compile.
@@ -136,21 +133,17 @@ var supportedInterfaces = []reflect.Type{
 type patcher struct{}
 
 func (patcher) Visit(node *ast.Node) {
-	id, ok := (*node).(*ast.IdentifierNode)
-	if !ok {
-		return
-	}
-
-	nodeType := id.Type()
-
-	for _, t := range supportedInterfaces {
-		if nodeType.Implements(t) {
-			callnode := &ast.CallNode{
-				Callee:    &ast.IdentifierNode{Value: "$patcher_value_getter"},
-				Arguments: []ast.Node{id},
+	switch id := (*node).(type) {
+	case *ast.IdentifierNode, *ast.MemberNode:
+		nodeType := id.Type()
+		for _, t := range supportedInterfaces {
+			if nodeType.Implements(t) {
+				ast.Patch(node, &ast.CallNode{
+					Callee:    &ast.IdentifierNode{Value: "$patcher_value_getter"},
+					Arguments: []ast.Node{id},
+				})
+				return
 			}
-
-			ast.Patch(node, callnode)
 		}
 	}
 }

From 98d79a97c7b0c33468d5be7f99227adfcd741e9b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 16 Jan 2024 10:27:10 +0100
Subject: [PATCH 244/506] Fix type any type propagation with patcher
 relationship

---
 checker/checker.go           | 15 ++++++++++++-
 patcher/with_context_test.go | 43 ++++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+), 1 deletion(-)

diff --git a/checker/checker.go b/checker/checker.go
index 0b5a0227a..fa7325ed3 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -539,9 +539,22 @@ func (v *checker) SliceNode(node *ast.SliceNode) (reflect.Type, info) {
 
 func (v *checker) CallNode(node *ast.CallNode) (reflect.Type, info) {
 	t, i := v.functionReturnType(node)
-	if node.Type() != nil {
+
+	// Check if type was set on node (for example, by patcher)
+	// and use node type instead of function return type.
+	//
+	// If node type is anyType, then we should use function
+	// return type. For example, on error we return anyType
+	// for a call `errCall().Method()` and method will be
+	// evaluated on `anyType.Method()`, so return type will
+	// be anyType `anyType.Method(): anyType`. Patcher can
+	// fix `errCall()` to return proper type, so on second
+	// checker pass we should replace anyType on method node
+	// with new correct function return type.
+	if node.Type() != nil && node.Type() != anyType {
 		return node.Type(), i
 	}
+
 	return t, i
 }
 
diff --git a/patcher/with_context_test.go b/patcher/with_context_test.go
index 4c2bd048f..310cbc06a 100644
--- a/patcher/with_context_test.go
+++ b/patcher/with_context_test.go
@@ -61,3 +61,46 @@ func TestWithContext_with_env_Function(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, 42, output)
 }
+
+type TestFoo struct {
+	contextValue int
+}
+
+func (f *TestFoo) GetValue(a int) int64 {
+	return int64(f.contextValue + a)
+}
+
+func TestWithContext_with_env_method_chain(t *testing.T) {
+	env := map[string]any{
+		"ctx": context.TODO(),
+	}
+
+	fn := expr.Function("fn",
+		func(params ...any) (any, error) {
+			ctx := params[0].(context.Context)
+
+			contextValue := ctx.Value("value").(int)
+
+			return &TestFoo{
+				contextValue: contextValue,
+			}, nil
+		},
+		new(func(context.Context) *TestFoo),
+	)
+
+	program, err := expr.Compile(
+		`fn().GetValue(40)`,
+		expr.Env(env),
+		expr.WithContext("ctx"),
+		fn,
+		expr.AsInt64(),
+	)
+	require.NoError(t, err)
+
+	ctx := context.WithValue(context.Background(), "value", 2)
+	env["ctx"] = ctx
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, int64(42), output)
+}

From 7ba66ee25c6e58f989263a23b6ad55bfa631e66b Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Tue, 16 Jan 2024 17:17:46 +0530
Subject: [PATCH 245/506] Remove parents field for optimization (#527)

---
 ast/node.go           |  1 +
 checker/checker.go    | 15 +++++----------
 parser/parser.go      |  1 +
 parser/parser_test.go |  6 ++++--
 4 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index 68c9e7bef..03e8cf622 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -133,6 +133,7 @@ type MemberNode struct {
 	Node     Node // Node of the member access. Like "foo" in "foo.bar".
 	Property Node // Property of the member access. For property access it is a StringNode.
 	Optional bool // If true then the member access is optional. Like "foo?.bar".
+	Method   bool
 }
 
 // SliceNode represents access to a slice of an array.
diff --git a/checker/checker.go b/checker/checker.go
index fa7325ed3..56784752e 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -54,7 +54,6 @@ type checker struct {
 	config          *conf.Config
 	predicateScopes []predicateScope
 	varScopes       []varScope
-	parents         []ast.Node
 	err             *file.Error
 }
 
@@ -83,7 +82,6 @@ type info struct {
 func (v *checker) visit(node ast.Node) (reflect.Type, info) {
 	var t reflect.Type
 	var i info
-	v.parents = append(v.parents, node)
 	switch n := node.(type) {
 	case *ast.NilNode:
 		t, i = v.NilNode(n)
@@ -130,7 +128,6 @@ func (v *checker) visit(node ast.Node) (reflect.Type, info) {
 	default:
 		panic(fmt.Sprintf("undefined node type (%T)", node))
 	}
-	v.parents = v.parents[:len(v.parents)-1]
 	node.SetType(t)
 	return t, i
 }
@@ -431,9 +428,6 @@ func (v *checker) ChainNode(node *ast.ChainNode) (reflect.Type, info) {
 }
 
 func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
-	base, _ := v.visit(node.Node)
-	prop, _ := v.visit(node.Property)
-
 	// $env variable
 	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "$env" {
 		if name, ok := node.Property.(*ast.StringNode); ok {
@@ -450,6 +444,9 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 		return anyType, info{}
 	}
 
+	base, _ := v.visit(node.Node)
+	prop, _ := v.visit(node.Property)
+
 	if name, ok := node.Property.(*ast.StringNode); ok {
 		if base == nil {
 			return v.error(node, "type %v has no field %v", base, name.Value)
@@ -498,10 +495,8 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 			if field, ok := fetchField(base, propertyName); ok {
 				return field.Type, info{}
 			}
-			if len(v.parents) > 1 {
-				if _, ok := v.parents[len(v.parents)-2].(*ast.CallNode); ok {
-					return v.error(node, "type %v has no method %v", base, propertyName)
-				}
+			if node.Method {
+				return v.error(node, "type %v has no method %v", base, propertyName)
 			}
 			return v.error(node, "type %v has no field %v", base, propertyName)
 		}
diff --git a/parser/parser.go b/parser/parser.go
index 1ce1cda0e..caab130db 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -572,6 +572,7 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 			memberNode.SetLocation(propertyToken.Location)
 
 			if p.current.Is(Bracket, "(") {
+				memberNode.Method = true
 				node = &CallNode{
 					Callee:    memberNode,
 					Arguments: p.parseArguments(),
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 0e7a23837..362c41fec 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -178,13 +178,13 @@ world`},
 		{
 			"foo.bar()",
 			&CallNode{Callee: &MemberNode{Node: &IdentifierNode{Value: "foo"},
-				Property: &StringNode{Value: "bar"}},
+				Property: &StringNode{Value: "bar"}, Method: true},
 				Arguments: []Node{}},
 		},
 		{
 			`foo.bar("arg1", 2, true)`,
 			&CallNode{Callee: &MemberNode{Node: &IdentifierNode{Value: "foo"},
-				Property: &StringNode{Value: "bar"}},
+				Property: &StringNode{Value: "bar"}, Method: true},
 				Arguments: []Node{&StringNode{Value: "arg1"},
 					&IntegerNode{Value: 2},
 					&BoolNode{Value: true}}},
@@ -220,12 +220,14 @@ world`},
 									Property: &StringNode{
 										Value: "b",
 									},
+									Method: true,
 								},
 								Arguments: []Node{},
 							},
 							Property: &StringNode{
 								Value: "c",
 							},
+							Method: true,
 						},
 						Arguments: []Node{},
 					},

From 7cd9fa622743e25ef6fbae26f1b3a6235c90de53 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 17 Jan 2024 20:01:34 +0100
Subject: [PATCH 246/506] Add ast tree to program (#528)

* Add pro holder

* explain
---
 .gitignore           |  1 +
 compiler/compiler.go |  1 +
 vm/program.go        | 19 ++++++++++++++-----
 3 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/.gitignore b/.gitignore
index b089dce8a..da1a8182f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@
 *.out
 *.html
 custom_tests.json
+pro/
diff --git a/compiler/compiler.go b/compiler/compiler.go
index d4ed3c8c4..ac11805e0 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -49,6 +49,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 
 	program = NewProgram(
 		tree.Source,
+		tree.Node,
 		c.locations,
 		c.variables,
 		c.constants,
diff --git a/vm/program.go b/vm/program.go
index 07ecec1c8..041cab51d 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -9,6 +9,7 @@ import (
 	"strings"
 	"text/tabwriter"
 
+	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/vm/runtime"
@@ -21,6 +22,7 @@ type Program struct {
 	Constants []any
 
 	source    *file.Source
+	node      ast.Node
 	locations []file.Location
 	variables int
 	functions []Function
@@ -30,6 +32,7 @@ type Program struct {
 // NewProgram returns a new Program. It's used by the compiler.
 func NewProgram(
 	source *file.Source,
+	node ast.Node,
 	locations []file.Location,
 	variables int,
 	constants []any,
@@ -40,6 +43,7 @@ func NewProgram(
 ) *Program {
 	return &Program{
 		source:    source,
+		node:      node,
 		locations: locations,
 		variables: variables,
 		Constants: constants,
@@ -50,6 +54,16 @@ func NewProgram(
 	}
 }
 
+// Source returns origin file.Source.
+func (program *Program) Source() *file.Source {
+	return program.source
+}
+
+// Node returns origin ast.Node.
+func (program *Program) Node() ast.Node {
+	return program.node
+}
+
 // Disassemble returns opcodes as a string.
 func (program *Program) Disassemble() string {
 	var buf bytes.Buffer
@@ -346,8 +360,3 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 		}
 	}
 }
-
-// Source returns origin file.Source.
-func (program *Program) Source() *file.Source {
-	return program.source
-}

From 71bc9f986c4e439802acf999726445f6204e9ddd Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 17 Jan 2024 23:21:11 +0100
Subject: [PATCH 247/506] Improve ast printing for boolean operators

---
 ast/print.go                | 34 ++++++++++++++++++++++++++++++----
 ast/print_test.go           |  4 ++--
 parser/operator/operator.go |  4 ++++
 3 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/ast/print.go b/ast/print.go
index 9a7d12391..7ecb1c04c 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -58,17 +58,43 @@ func (n *UnaryNode) String() string {
 }
 
 func (n *BinaryNode) String() string {
+	if n.Operator == ".." {
+		return fmt.Sprintf("%s..%s", n.Left, n.Right)
+	}
+
 	var lhs, rhs string
+	var lwrap, rwrap bool
 
 	lb, ok := n.Left.(*BinaryNode)
-	if ok && (operator.Less(lb.Operator, n.Operator) || lb.Operator == "??") {
+	if ok {
+		if operator.Less(lb.Operator, n.Operator) {
+			lwrap = true
+		}
+		if lb.Operator == "??" {
+			lwrap = true
+		}
+		if operator.IsBoolean(lb.Operator) && n.Operator != lb.Operator {
+			lwrap = true
+		}
+	}
+
+	rb, ok := n.Right.(*BinaryNode)
+	if ok {
+		if operator.Less(rb.Operator, n.Operator) {
+			rwrap = true
+		}
+		if operator.IsBoolean(rb.Operator) && n.Operator != rb.Operator {
+			rwrap = true
+		}
+	}
+
+	if lwrap {
 		lhs = fmt.Sprintf("(%s)", n.Left.String())
 	} else {
 		lhs = n.Left.String()
 	}
 
-	rb, ok := n.Right.(*BinaryNode)
-	if ok && operator.Less(rb.Operator, n.Operator) {
+	if rwrap {
 		rhs = fmt.Sprintf("(%s)", n.Right.String())
 	} else {
 		rhs = n.Right.String()
@@ -132,7 +158,7 @@ func (n *ClosureNode) String() string {
 }
 
 func (n *PointerNode) String() string {
-	return "#"
+	return fmt.Sprintf("#%s", n.Name)
 }
 
 func (n *VariableDeclaratorNode) String() string {
diff --git a/ast/print_test.go b/ast/print_test.go
index 12ae6f741..2ecff147c 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -42,8 +42,8 @@ func TestPrint(t *testing.T) {
 		{`a not in b`, `not (a in b)`},
 		{`a and b`, `a and b`},
 		{`a or b`, `a or b`},
-		{`a or b and c`, `a or b and c`},
-		{`a or (b and c)`, `a or b and c`},
+		{`a or b and c`, `a or (b and c)`},
+		{`a or (b and c)`, `a or (b and c)`},
 		{`(a or b) and c`, `(a or b) and c`},
 		{`a ? b : c`, `a ? b : c`},
 		{`a ? b : c ? d : e`, `a ? b : (c ? d : e)`},
diff --git a/parser/operator/operator.go b/parser/operator/operator.go
index 455c06f17..8d804c7b3 100644
--- a/parser/operator/operator.go
+++ b/parser/operator/operator.go
@@ -16,6 +16,10 @@ func Less(a, b string) bool {
 	return Binary[a].Precedence < Binary[b].Precedence
 }
 
+func IsBoolean(op string) bool {
+	return op == "and" || op == "or" || op == "&&" || op == "||"
+}
+
 var Unary = map[string]Operator{
 	"not": {50, Left},
 	"!":   {50, Left},

From cda16c21633e49505535aa4c0b70d39fd9640a21 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 18 Jan 2024 07:52:06 +0100
Subject: [PATCH 248/506] Fix type checker to visit all arguments of func even
 in args count mismatch

---
 checker/checker.go           | 16 +++++++++++++---
 checker/checker_test.go      |  8 ++++----
 patcher/with_context.go      |  6 ++++--
 patcher/with_context_test.go | 24 ++++++++++++++++++++++++
 4 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 56784752e..3dc4e95ad 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -906,28 +906,38 @@ func (v *checker) checkArguments(
 		fnInOffset = 1
 	}
 
+	var err *file.Error
 	if fn.IsVariadic() {
 		if len(arguments) < fnNumIn-1 {
-			return anyType, &file.Error{
+			err = &file.Error{
 				Location: node.Location(),
 				Message:  fmt.Sprintf("not enough arguments to call %v", name),
 			}
 		}
 	} else {
 		if len(arguments) > fnNumIn {
-			return anyType, &file.Error{
+			err = &file.Error{
 				Location: node.Location(),
 				Message:  fmt.Sprintf("too many arguments to call %v", name),
 			}
 		}
 		if len(arguments) < fnNumIn {
-			return anyType, &file.Error{
+			err = &file.Error{
 				Location: node.Location(),
 				Message:  fmt.Sprintf("not enough arguments to call %v", name),
 			}
 		}
 	}
 
+	if err != nil {
+		// If we have an error, we should still visit all arguments to
+		// type check them, as a patch can fix the error later.
+		for _, arg := range arguments {
+			_, _ = v.visit(arg)
+		}
+		return fn.Out(0), err
+	}
+
 	for i, arg := range arguments {
 		t, _ := v.visit(arg)
 
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 35daeda45..2bf5ec864 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -170,9 +170,9 @@ type mock.Foo has no field bar (1:4)
  | Foo['bar']
  | ...^
 
-Foo.Method(Not)
+Foo.Method(42)
 too many arguments to call Method (1:5)
- | Foo.Method(Not)
+ | Foo.Method(42)
  | ....^
 
 Foo.Bar()
@@ -210,9 +210,9 @@ array elements can only be selected using an integer (got string) (1:12)
  | ArrayOfFoo.Not
  | ...........^
 
-FuncParam(Not)
+FuncParam(true)
 not enough arguments to call FuncParam (1:1)
- | FuncParam(Not)
+ | FuncParam(true)
  | ^
 
 MapOfFoo['str'].Not
diff --git a/patcher/with_context.go b/patcher/with_context.go
index 85f095d5d..55b604261 100644
--- a/patcher/with_context.go
+++ b/patcher/with_context.go
@@ -13,10 +13,12 @@ type WithContext struct {
 
 // Visit adds WithContext.Name argument to all functions calls with a context.Context argument.
 func (w WithContext) Visit(node *ast.Node) {
-	switch (*node).(type) {
+	switch call := (*node).(type) {
 	case *ast.CallNode:
-		call := (*node).(*ast.CallNode)
 		fn := call.Callee.Type()
+		if fn == nil {
+			return
+		}
 		if fn.Kind() != reflect.Func {
 			return
 		}
diff --git a/patcher/with_context_test.go b/patcher/with_context_test.go
index 310cbc06a..afad4e6f0 100644
--- a/patcher/with_context_test.go
+++ b/patcher/with_context_test.go
@@ -104,3 +104,27 @@ func TestWithContext_with_env_method_chain(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, int64(42), output)
 }
+
+func TestWithContext_issue529(t *testing.T) {
+	env := map[string]any{
+		"ctx": context.Background(),
+		"foo": func(ctx context.Context, n int) int {
+			if ctx == nil {
+				panic("wanted a context")
+			}
+			return n + 1
+		},
+	}
+	options := []expr.Option{
+		expr.Env(env),
+		expr.WithContext("ctx"),
+	}
+
+	code := "foo(0) | foo()"
+	program, err := expr.Compile(code, options...)
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 2, out)
+}

From 44dfabc57310d2ab9a6dd7a4799039bfc50df556 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 21 Jan 2024 11:55:30 +0100
Subject: [PATCH 249/506] Make AsAny the new default

---
 expr.go      | 15 +++++++++++++++
 expr_test.go | 11 +++++++++++
 2 files changed, 26 insertions(+)

diff --git a/expr.go b/expr.go
index 8569de8fb..f32df1d3c 100644
--- a/expr.go
+++ b/expr.go
@@ -65,6 +65,7 @@ func AsAny() Option {
 func AsKind(kind reflect.Kind) Option {
 	return func(c *conf.Config) {
 		c.Expect = kind
+		c.ExpectAny = true
 	}
 }
 
@@ -72,6 +73,7 @@ func AsKind(kind reflect.Kind) Option {
 func AsBool() Option {
 	return func(c *conf.Config) {
 		c.Expect = reflect.Bool
+		c.ExpectAny = true
 	}
 }
 
@@ -79,6 +81,7 @@ func AsBool() Option {
 func AsInt() Option {
 	return func(c *conf.Config) {
 		c.Expect = reflect.Int
+		c.ExpectAny = true
 	}
 }
 
@@ -86,6 +89,7 @@ func AsInt() Option {
 func AsInt64() Option {
 	return func(c *conf.Config) {
 		c.Expect = reflect.Int64
+		c.ExpectAny = true
 	}
 }
 
@@ -93,6 +97,17 @@ func AsInt64() Option {
 func AsFloat64() Option {
 	return func(c *conf.Config) {
 		c.Expect = reflect.Float64
+		c.ExpectAny = true
+	}
+}
+
+// WarnOnAny tells the compiler to warn if expression return any type.
+func WarnOnAny() Option {
+	return func(c *conf.Config) {
+		if c.Expect == reflect.Invalid {
+			panic("WarnOnAny() works only with combination with AsInt(), AsBool(), etc. options")
+		}
+		c.ExpectAny = false
 	}
 }
 
diff --git a/expr_test.go b/expr_test.go
index 66ef11ce7..fb805c762 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -257,6 +257,17 @@ func ExampleAsFloat64_error() {
 	// Output: expected float64, but got bool
 }
 
+func ExampleWarnOnAny() {
+	// Arrays always have []any type. The expression return type is any.
+	// AsInt() instructs compiler to expect int or any, and cast to int,
+	// if possible. WarnOnAny() instructs to return an error on any type.
+	_, err := expr.Compile(`[42, true, "yes"][0]`, expr.AsInt(), expr.WarnOnAny())
+
+	fmt.Printf("%v", err)
+
+	// Output: expected int, but got interface {}
+}
+
 func ExampleOperator() {
 	code := `
 		Now() > CreatedAt &&

From 564b637c224da220c648e399669cb8c4e87d73fa Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 24 Jan 2024 23:49:57 +0100
Subject: [PATCH 250/506] Fix pipeline and call parsing

---
 builtin/builtin_test.go |  18 +++
 parser/parser.go        | 235 +++++++++++++++++-----------------------
 2 files changed, 118 insertions(+), 135 deletions(-)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 0cdf9515d..e302d719d 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -327,6 +327,24 @@ func TestBuiltin_allow_builtins_override(t *testing.T) {
 				program, err := expr.Compile(fmt.Sprintf("%s()", name), fn)
 				require.NoError(t, err)
 
+				out, err := expr.Run(program, nil)
+				require.NoError(t, err)
+				assert.Equal(t, 42, out)
+			})
+		}
+	})
+	t.Run("via expr.Function as pipe", func(t *testing.T) {
+		for _, name := range builtin.Names {
+			t.Run(name, func(t *testing.T) {
+				fn := expr.Function(name,
+					func(params ...any) (any, error) {
+						return 42, nil
+					},
+					new(func(s string) int),
+				)
+				program, err := expr.Compile(fmt.Sprintf("'str' | %s()", name), fn)
+				require.NoError(t, err)
+
 				out, err := expr.Run(program, nil)
 				require.NoError(t, err)
 				assert.Equal(t, 42, out)
diff --git a/parser/parser.go b/parser/parser.go
index caab130db..07c1be547 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -15,22 +15,31 @@ import (
 	"github.com/expr-lang/expr/parser/utils"
 )
 
+type arg byte
+
+const (
+	expr arg = 1 << iota
+	closure
+)
+
+const optional arg = 1 << 7
+
 var predicates = map[string]struct {
-	arity int
+	args []arg
 }{
-	"all":           {2},
-	"none":          {2},
-	"any":           {2},
-	"one":           {2},
-	"filter":        {2},
-	"map":           {2},
-	"count":         {2},
-	"find":          {2},
-	"findIndex":     {2},
-	"findLast":      {2},
-	"findLastIndex": {2},
-	"groupBy":       {2},
-	"reduce":        {3},
+	"all":           {[]arg{expr, closure}},
+	"none":          {[]arg{expr, closure}},
+	"any":           {[]arg{expr, closure}},
+	"one":           {[]arg{expr, closure}},
+	"filter":        {[]arg{expr, closure}},
+	"map":           {[]arg{expr, closure}},
+	"count":         {[]arg{expr, closure}},
+	"find":          {[]arg{expr, closure}},
+	"findIndex":     {[]arg{expr, closure}},
+	"findLast":      {[]arg{expr, closure}},
+	"findLastIndex": {[]arg{expr, closure}},
+	"groupBy":       {[]arg{expr, closure}},
+	"reduce":        {[]arg{expr, closure, expr | optional}},
 }
 
 type parser struct {
@@ -143,7 +152,9 @@ func (p *parser) parseExpression(precedence int) Node {
 				p.next()
 
 				if opToken.Value == "|" {
-					nodeLeft = p.parsePipe(nodeLeft)
+					identToken := p.current
+					p.expect(Identifier)
+					nodeLeft = p.parseCall(identToken, []Node{nodeLeft}, true)
 					goto next
 				}
 
@@ -279,7 +290,7 @@ func (p *parser) parsePrimary() Node {
 		p.next()
 		token = p.current
 		p.expect(Identifier)
-		return p.parsePostfixExpression(p.parseCall(token, false))
+		return p.parsePostfixExpression(p.parseCall(token, []Node{}, false))
 	}
 
 	return p.parseSecondary()
@@ -307,7 +318,12 @@ func (p *parser) parseSecondary() Node {
 			node.SetLocation(token.Location)
 			return node
 		default:
-			node = p.parseCall(token, true)
+			if p.current.Is(Bracket, "(") {
+				node = p.parseCall(token, []Node{}, true)
+			} else {
+				node = &IdentifierNode{Value: token.Value}
+				node.SetLocation(token.Location)
+			}
 		}
 
 	case Number:
@@ -386,68 +402,86 @@ func (p *parser) toFloatNode(number float64) Node {
 	return &FloatNode{Value: number}
 }
 
-func (p *parser) parseCall(token Token, checkOverrides bool) Node {
+func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) Node {
 	var node Node
-	if p.current.Is(Bracket, "(") {
-		var arguments []Node
-
-		isOverridden := p.config.IsOverridden(token.Value)
-		isOverridden = isOverridden && checkOverrides
-
-		// TODO: Refactor parser to use builtin.Builtins instead of predicates map.
-		if b, ok := predicates[token.Value]; ok && !isOverridden {
-			p.expect(Bracket, "(")
-
-			if b.arity == 1 {
-				arguments = make([]Node, 1)
-				arguments[0] = p.parseExpression(0)
-			} else if b.arity == 2 {
-				arguments = make([]Node, 2)
-				arguments[0] = p.parseExpression(0)
-				p.expect(Operator, ",")
-				arguments[1] = p.parseClosure()
-			}
 
-			if token.Value == "reduce" {
-				arguments = make([]Node, 2)
-				arguments[0] = p.parseExpression(0)
-				p.expect(Operator, ",")
-				arguments[1] = p.parseClosure()
-				if p.current.Is(Operator, ",") {
-					p.next()
-					arguments = append(arguments, p.parseExpression(0))
-				}
-			}
+	isOverridden := p.config.IsOverridden(token.Value)
+	isOverridden = isOverridden && checkOverrides
+
+	if b, ok := predicates[token.Value]; ok && !isOverridden {
+		p.expect(Bracket, "(")
 
-			p.expect(Bracket, ")")
+		// In case of the pipe operator, the first argument is the left-hand side
+		// of the operator, so we do not parse it as an argument inside brackets.
+		args := b.args[len(arguments):]
 
-			node = &BuiltinNode{
-				Name:      token.Value,
-				Arguments: arguments,
+		for i, arg := range args {
+			if arg&optional == optional {
+				if p.current.Is(Bracket, ")") {
+					break
+				}
+			} else {
+				if p.current.Is(Bracket, ")") {
+					p.error("expected at least %d arguments", len(args))
+				}
 			}
-			node.SetLocation(token.Location)
-		} else if _, ok := builtin.Index[token.Value]; ok && !p.config.Disabled[token.Value] && !isOverridden {
-			node = &BuiltinNode{
-				Name:      token.Value,
-				Arguments: p.parseArguments(),
+
+			if i > 0 {
+				p.expect(Operator, ",")
 			}
-			node.SetLocation(token.Location)
-		} else {
-			callee := &IdentifierNode{Value: token.Value}
-			callee.SetLocation(token.Location)
-			node = &CallNode{
-				Callee:    callee,
-				Arguments: p.parseArguments(),
+			var node Node
+			switch {
+			case arg&expr == expr:
+				node = p.parseExpression(0)
+			case arg&closure == closure:
+				node = p.parseClosure()
 			}
-			node.SetLocation(token.Location)
+			arguments = append(arguments, node)
+		}
+
+		p.expect(Bracket, ")")
+
+		node = &BuiltinNode{
+			Name:      token.Value,
+			Arguments: arguments,
+		}
+		node.SetLocation(token.Location)
+	} else if _, ok := builtin.Index[token.Value]; ok && !p.config.Disabled[token.Value] && !isOverridden {
+		node = &BuiltinNode{
+			Name:      token.Value,
+			Arguments: p.parseArguments(arguments),
 		}
+		node.SetLocation(token.Location)
 	} else {
-		node = &IdentifierNode{Value: token.Value}
+		callee := &IdentifierNode{Value: token.Value}
+		callee.SetLocation(token.Location)
+		node = &CallNode{
+			Callee:    callee,
+			Arguments: p.parseArguments(arguments),
+		}
 		node.SetLocation(token.Location)
 	}
 	return node
 }
 
+func (p *parser) parseArguments(arguments []Node) []Node {
+	// If pipe operator is used, the first argument is the left-hand side
+	// of the operator, so we do not parse it as an argument inside brackets.
+	offset := len(arguments)
+
+	p.expect(Bracket, "(")
+	for !p.current.Is(Bracket, ")") && p.err == nil {
+		if len(arguments) > offset {
+			p.expect(Operator, ",")
+		}
+		node := p.parseExpression(0)
+		arguments = append(arguments, node)
+	}
+	p.expect(Bracket, ")")
+
+	return arguments
+}
+
 func (p *parser) parseClosure() Node {
 	startToken := p.current
 	expectClosingBracket := false
@@ -575,7 +609,7 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 				memberNode.Method = true
 				node = &CallNode{
 					Callee:    memberNode,
-					Arguments: p.parseArguments(),
+					Arguments: p.parseArguments([]Node{}),
 				}
 				node.SetLocation(propertyToken.Location)
 			} else {
@@ -641,72 +675,3 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 	}
 	return node
 }
-
-func (p *parser) parsePipe(node Node) Node {
-	identifier := p.current
-	p.expect(Identifier)
-
-	arguments := []Node{node}
-
-	if b, ok := predicates[identifier.Value]; ok {
-		p.expect(Bracket, "(")
-
-		// TODO: Refactor parser to use builtin.Builtins instead of predicates map.
-
-		if b.arity == 2 {
-			arguments = append(arguments, p.parseClosure())
-		}
-
-		if identifier.Value == "reduce" {
-			arguments = append(arguments, p.parseClosure())
-			if p.current.Is(Operator, ",") {
-				p.next()
-				arguments = append(arguments, p.parseExpression(0))
-			}
-		}
-
-		p.expect(Bracket, ")")
-
-		node = &BuiltinNode{
-			Name:      identifier.Value,
-			Arguments: arguments,
-		}
-		node.SetLocation(identifier.Location)
-	} else if _, ok := builtin.Index[identifier.Value]; ok {
-		arguments = append(arguments, p.parseArguments()...)
-
-		node = &BuiltinNode{
-			Name:      identifier.Value,
-			Arguments: arguments,
-		}
-		node.SetLocation(identifier.Location)
-	} else {
-		callee := &IdentifierNode{Value: identifier.Value}
-		callee.SetLocation(identifier.Location)
-
-		arguments = append(arguments, p.parseArguments()...)
-
-		node = &CallNode{
-			Callee:    callee,
-			Arguments: arguments,
-		}
-		node.SetLocation(identifier.Location)
-	}
-
-	return node
-}
-
-func (p *parser) parseArguments() []Node {
-	p.expect(Bracket, "(")
-	nodes := make([]Node, 0)
-	for !p.current.Is(Bracket, ")") && p.err == nil {
-		if len(nodes) > 0 {
-			p.expect(Operator, ",")
-		}
-		node := p.parseExpression(0)
-		nodes = append(nodes, node)
-	}
-	p.expect(Bracket, ")")
-
-	return nodes
-}

From 1c8c9e6c307c5110ece4d539f2c3a7121ef3aa0c Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Thu, 1 Feb 2024 00:07:26 +0700
Subject: [PATCH 251/506] Fix string literal slicing error (#543)

---
 expr_test.go          | 4 ++++
 parser/parser.go      | 3 +--
 parser/parser_test.go | 8 ++++++++
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index fb805c762..1c01b74bb 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1180,6 +1180,10 @@ func TestExpr(t *testing.T) {
 			`bitushr(-100, 5)`,
 			576460752303423484,
 		},
+		{
+			`"hello"[1:3]`,
+			"el",
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/parser/parser.go b/parser/parser.go
index 07c1be547..54ba07a59 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -369,9 +369,8 @@ func (p *parser) parseSecondary() Node {
 		return node
 	case String:
 		p.next()
-		node := &StringNode{Value: token.Value}
+		node = &StringNode{Value: token.Value}
 		node.SetLocation(token.Location)
-		return node
 
 	default:
 		if token.Is(Bracket, "[") {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 362c41fec..a6062eae1 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -523,6 +523,14 @@ world`},
 				Property: &IntegerNode{Value: 0},
 			},
 		},
+		{
+			`"hello"[1:3]`,
+			&SliceNode{
+				Node: &StringNode{Value: "hello"},
+				From: &IntegerNode{Value: 1},
+				To:   &IntegerNode{Value: 3},
+			},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {

From 89478f3e4cad773adf03ab7947fd4b2531d18838 Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Sat, 3 Feb 2024 01:37:21 +0700
Subject: [PATCH 252/506] Optimize jump opcodes (#545)

---
 compiler/compiler.go      |  16 ++++
 compiler/compiler_test.go | 172 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 188 insertions(+)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index ac11805e0..5c7f3603f 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -45,6 +45,9 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		case reflect.Float64:
 			c.emit(OpCast, 2)
 		}
+		if c.config.Optimize {
+			c.optimize()
+		}
 	}
 
 	program = NewProgram(
@@ -1050,6 +1053,19 @@ func (c *compiler) derefInNeeded(node ast.Node) {
 	}
 }
 
+func (c *compiler) optimize() {
+	for i, op := range c.bytecode {
+		switch op {
+		case OpJumpIfTrue, OpJumpIfFalse, OpJumpIfNil, OpJumpIfNotNil:
+			target := i + c.arguments[i] + 1
+			for target < len(c.bytecode) && c.bytecode[target] == op {
+				target += c.arguments[target] + 1
+			}
+			c.arguments[i] = target - i - 1
+		}
+	}
+}
+
 func kind(node ast.Node) reflect.Kind {
 	t := node.Type()
 	if t == nil {
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index ed11a9dd7..b7bbfcfb4 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -384,3 +384,175 @@ func TestCompile_OpCallFast(t *testing.T) {
 	require.Equal(t, vm.OpCallFast, program.Bytecode[4])
 	require.Equal(t, 3, program.Arguments[4])
 }
+
+func TestCompile_optimizes_jumps(t *testing.T) {
+	env := map[string]any{
+		"a": true,
+		"b": true,
+		"c": true,
+		"d": true,
+	}
+	type op struct {
+		Bytecode vm.Opcode
+		Arg      int
+	}
+	tests := []struct {
+		code string
+		want []op
+	}{
+		{
+			`let foo = true; let bar = false; let baz = true; foo || bar || baz`,
+			[]op{
+				{vm.OpTrue, 0},
+				{vm.OpStore, 0},
+				{vm.OpFalse, 0},
+				{vm.OpStore, 1},
+				{vm.OpTrue, 0},
+				{vm.OpStore, 2},
+				{vm.OpLoadVar, 0},
+				{vm.OpJumpIfTrue, 5},
+				{vm.OpPop, 0},
+				{vm.OpLoadVar, 1},
+				{vm.OpJumpIfTrue, 2},
+				{vm.OpPop, 0},
+				{vm.OpLoadVar, 2},
+			},
+		},
+		{
+			`a && b && c`,
+			[]op{
+				{vm.OpLoadFast, 0},
+				{vm.OpJumpIfFalse, 5},
+				{vm.OpPop, 0},
+				{vm.OpLoadFast, 1},
+				{vm.OpJumpIfFalse, 2},
+				{vm.OpPop, 0},
+				{vm.OpLoadFast, 2},
+			},
+		},
+		{
+			`a && b || c && d`,
+			[]op{
+				{vm.OpLoadFast, 0},
+				{vm.OpJumpIfFalse, 2},
+				{vm.OpPop, 0},
+				{vm.OpLoadFast, 1},
+				{vm.OpJumpIfTrue, 5},
+				{vm.OpPop, 0},
+				{vm.OpLoadFast, 2},
+				{vm.OpJumpIfFalse, 2},
+				{vm.OpPop, 0},
+				{vm.OpLoadFast, 3},
+			},
+		},
+		{
+			`filter([1, 2, 3, 4, 5], # > 3 && # != 4 && # != 5)`,
+			[]op{
+				{vm.OpPush, 0},
+				{vm.OpBegin, 0},
+				{vm.OpJumpIfEnd, 26},
+				{vm.OpPointer, 0},
+				{vm.OpDeref, 0},
+				{vm.OpPush, 1},
+				{vm.OpMore, 0},
+				{vm.OpJumpIfFalse, 18},
+				{vm.OpPop, 0},
+				{vm.OpPointer, 0},
+				{vm.OpDeref, 0},
+				{vm.OpPush, 2},
+				{vm.OpEqual, 0},
+				{vm.OpNot, 0},
+				{vm.OpJumpIfFalse, 11},
+				{vm.OpPop, 0},
+				{vm.OpPointer, 0},
+				{vm.OpDeref, 0},
+				{vm.OpPush, 3},
+				{vm.OpEqual, 0},
+				{vm.OpNot, 0},
+				{vm.OpJumpIfFalse, 4},
+				{vm.OpPop, 0},
+				{vm.OpIncrementCount, 0},
+				{vm.OpPointer, 0},
+				{vm.OpJump, 1},
+				{vm.OpPop, 0},
+				{vm.OpIncrementIndex, 0},
+				{vm.OpJumpBackward, 27},
+				{vm.OpGetCount, 0},
+				{vm.OpEnd, 0},
+				{vm.OpArray, 0},
+			},
+		},
+		{
+			`let foo = true; let bar = false; let baz = true; foo && bar || baz`,
+			[]op{
+				{vm.OpTrue, 0},
+				{vm.OpStore, 0},
+				{vm.OpFalse, 0},
+				{vm.OpStore, 1},
+				{vm.OpTrue, 0},
+				{vm.OpStore, 2},
+				{vm.OpLoadVar, 0},
+				{vm.OpJumpIfFalse, 2},
+				{vm.OpPop, 0},
+				{vm.OpLoadVar, 1},
+				{vm.OpJumpIfTrue, 2},
+				{vm.OpPop, 0},
+				{vm.OpLoadVar, 2},
+			},
+		},
+		{
+			`true ?? nil ?? nil ?? nil`,
+			[]op{
+				{vm.OpTrue, 0},
+				{vm.OpJumpIfNotNil, 8},
+				{vm.OpPop, 0},
+				{vm.OpNil, 0},
+				{vm.OpJumpIfNotNil, 5},
+				{vm.OpPop, 0},
+				{vm.OpNil, 0},
+				{vm.OpJumpIfNotNil, 2},
+				{vm.OpPop, 0},
+				{vm.OpNil, 0},
+			},
+		},
+		{
+			`let m = {"a": {"b": {"c": 1}}}; m?.a?.b?.c`,
+			[]op{
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpPush, 2},
+				{vm.OpPush, 3},
+				{vm.OpPush, 3},
+				{vm.OpMap, 0},
+				{vm.OpPush, 3},
+				{vm.OpMap, 0},
+				{vm.OpPush, 3},
+				{vm.OpMap, 0},
+				{vm.OpStore, 0},
+				{vm.OpLoadVar, 0},
+				{vm.OpJumpIfNil, 8},
+				{vm.OpPush, 0},
+				{vm.OpFetch, 0},
+				{vm.OpJumpIfNil, 5},
+				{vm.OpPush, 1},
+				{vm.OpFetch, 0},
+				{vm.OpJumpIfNil, 2},
+				{vm.OpPush, 2},
+				{vm.OpFetch, 0},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.code, func(t *testing.T) {
+			program, err := expr.Compile(test.code, expr.Env(env))
+			require.NoError(t, err)
+
+			require.Equal(t, len(test.want), len(program.Bytecode))
+			for i, op := range test.want {
+				require.Equal(t, op.Bytecode, program.Bytecode[i])
+				require.Equalf(t, op.Arg, program.Arguments[i], "at %d", i)
+			}
+		})
+	}
+}

From c7658ac65da183e42d5d4046ede18edef735d60d Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Thu, 8 Feb 2024 18:20:20 +0700
Subject: [PATCH 253/506] Add optional array access like `foo?.[42]` (#550)

---
 expr_test.go          | 22 ++++++++++++++++++++++
 parser/parser.go      | 10 ++++++++++
 parser/parser_test.go | 13 +++++++++++++
 3 files changed, 45 insertions(+)

diff --git a/expr_test.go b/expr_test.go
index 1c01b74bb..52aff7fd1 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1184,6 +1184,18 @@ func TestExpr(t *testing.T) {
 			`"hello"[1:3]`,
 			"el",
 		},
+		{
+			`[1, 2, 3]?.[0]`,
+			1,
+		},
+		{
+			`[[1, 2], 3, 4]?.[0]?.[1]`,
+			2,
+		},
+		{
+			`[nil, 3, 4]?.[0]?.[1]`,
+			nil,
+		},
 	}
 
 	for _, tt := range tests {
@@ -1281,6 +1293,16 @@ func TestExpr_optional_chaining_nested_chains(t *testing.T) {
 	assert.Equal(t, "baz", got)
 }
 
+func TestExpr_optional_chaining_array(t *testing.T) {
+	env := map[string]any{}
+	program, err := expr.Compile("foo?.[1]?.[2]?.[3]", expr.Env(env), expr.AllowUndefinedVariables())
+	require.NoError(t, err)
+
+	got, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, nil, got)
+}
+
 func TestExpr_eval_with_env(t *testing.T) {
 	_, err := expr.Eval("true", expr.Env(map[string]any{}))
 	assert.Error(t, err)
diff --git a/parser/parser.go b/parser/parser.go
index 54ba07a59..bc620ac68 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -575,10 +575,16 @@ end:
 func (p *parser) parsePostfixExpression(node Node) Node {
 	postfixToken := p.current
 	for (postfixToken.Is(Operator) || postfixToken.Is(Bracket)) && p.err == nil {
+		optional := postfixToken.Value == "?."
+	parseToken:
 		if postfixToken.Value == "." || postfixToken.Value == "?." {
 			p.next()
 
 			propertyToken := p.current
+			if optional && propertyToken.Is(Bracket, "[") {
+				postfixToken = propertyToken
+				goto parseToken
+			}
 			p.next()
 
 			if propertyToken.Kind != Identifier &&
@@ -662,8 +668,12 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 					node = &MemberNode{
 						Node:     node,
 						Property: from,
+						Optional: optional,
 					}
 					node.SetLocation(postfixToken.Location)
+					if optional {
+						node = &ChainNode{Node: node}
+					}
 					p.expect(Bracket, "]")
 				}
 			}
diff --git a/parser/parser_test.go b/parser/parser_test.go
index a6062eae1..b633bd52e 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -747,6 +747,19 @@ func TestParse_optional_chaining(t *testing.T) {
 				},
 			},
 		},
+		{
+			"foo.bar?.[0]",
+			&ChainNode{
+				Node: &MemberNode{
+					Node: &MemberNode{
+						Node:     &IdentifierNode{Value: "foo"},
+						Property: &StringNode{Value: "bar"},
+					},
+					Property: &IntegerNode{Value: 0},
+					Optional: true,
+				},
+			},
+		},
 	}
 	for _, test := range parseTests {
 		actual, err := parser.Parse(test.input)

From 013c32fe5294be0394deb11d0ee97bdb2c7c51fa Mon Sep 17 00:00:00 2001
From: Vladimir Fetisov <vladimir.fetisov@pm.me>
Date: Thu, 8 Feb 2024 21:07:58 +0100
Subject: [PATCH 254/506] Fix operator overloading (#554)

---
 conf/operators.go |  3 ++-
 expr_test.go      | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/conf/operators.go b/conf/operators.go
index ca6606274..ced209fdc 100644
--- a/conf/operators.go
+++ b/conf/operators.go
@@ -48,12 +48,13 @@ func (p *OperatorPatcher) Visit(node *ast.Node) {
 	leftType := binaryNode.Left.Type()
 	rightType := binaryNode.Right.Type()
 
-	_, fn, ok := FindSuitableOperatorOverload(fns, p.Types, leftType, rightType)
+	ret, fn, ok := FindSuitableOperatorOverload(fns, p.Types, leftType, rightType)
 	if ok {
 		newNode := &ast.CallNode{
 			Callee:    &ast.IdentifierNode{Value: fn},
 			Arguments: []ast.Node{binaryNode.Left, binaryNode.Right},
 		}
+		newNode.SetType(ret)
 		ast.Patch(node, newNode)
 	}
 }
diff --git a/expr_test.go b/expr_test.go
index 52aff7fd1..7c20e4899 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -311,6 +311,47 @@ func ExampleOperator() {
 	// Output: true
 }
 
+func ExampleOperator_Decimal() {
+	type Decimal struct{ N float64 }
+	code := `A + B - C`
+
+	type Env struct {
+		A, B, C   Decimal
+		Sub       func(a, b Decimal) Decimal
+		Add       func(a, b Decimal) Decimal
+	}
+
+	options := []expr.Option{
+		expr.Env(Env{}),
+		expr.Operator("+", "Add"),
+		expr.Operator("-", "Sub"),
+	}
+
+	program, err := expr.Compile(code, options...)
+	if err != nil {
+		fmt.Printf("Compile error: %v", err)
+		return
+	}
+
+	env := Env{
+		A: Decimal{3},
+		B: Decimal{2},
+		C: Decimal{1},
+		Sub: func(a, b Decimal) Decimal { return Decimal{a.N - b.N} },
+		Add: func(a, b Decimal) Decimal { return Decimal{a.N + b.N}  },
+	}
+
+	output, err := expr.Run(program, env)
+	if err != nil {
+		fmt.Printf("%v", err)
+		return
+	}
+
+	fmt.Printf("%v", output)
+
+	// Output: {4}
+}
+
 func fib(n int) int {
 	if n <= 1 {
 		return n

From 83b8df3a4a5324b174e552c5139bf1a352866b7c Mon Sep 17 00:00:00 2001
From: Yuriy Panarin <tduble94@gmail.com>
Date: Sun, 11 Feb 2024 22:21:49 +0100
Subject: [PATCH 255/506] code(builtin) - add reverse function (#553)

* code(builtin) - add reverse function

* docs(language-definition.md) - add reverse function
---
 builtin/builtin.go          | 34 ++++++++++++++++++++++++++++++++++
 builtin/builtin_test.go     | 32 ++++++++++++++++++++++++++++++++
 docs/language-definition.md |  9 +++++++++
 3 files changed, 75 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 14fc8a4b7..beeb94e91 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -868,6 +868,40 @@ var Builtins = []*Function{
 			return anyType, fmt.Errorf("cannot transform %s from pairs", args[0])
 		},
 	},
+	{
+		Name: "reverse",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+
+			v := reflect.ValueOf(args[0])
+			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+				return nil, fmt.Errorf("cannot reverse %s", v.Kind())
+			}
+
+			size := v.Len()
+			arr := make([]any, size)
+
+			for i := 0; i < size; i++ {
+				arr[i] = v.Index(size - i - 1).Interface()
+			}
+
+			return arr, nil
+
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+				return arrayType, nil
+			default:
+				return anyType, fmt.Errorf("cannot reverse %s", args[0])
+			}
+		},
+	},
 	{
 		Name: "sort",
 		Func: func(args ...any) (any, error) {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index e302d719d..d6b967d13 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -483,6 +483,38 @@ func TestBuiltin_type(t *testing.T) {
 	}
 }
 
+func TestBuiltin_reverse(t *testing.T) {
+	env := map[string]any{
+		"ArrayOfString": []string{"foo", "bar", "baz"},
+		"ArrayOfInt":    []int{2, 1, 3},
+		"ArrayOfFloat":  []float64{3.0, 2.0, 1.0},
+		"ArrayOfFoo":    []mock.Foo{{Value: "c"}, {Value: "a"}, {Value: "b"}},
+	}
+	tests := []struct {
+		input string
+		want  any
+	}{
+		{`reverse([])`, []any{}},
+		{`reverse(ArrayOfInt)`, []any{3, 1, 2}},
+		{`reverse(ArrayOfFloat)`, []any{1.0, 2.0, 3.0}},
+		{`reverse(ArrayOfFoo)`, []any{mock.Foo{Value: "b"}, mock.Foo{Value: "a"}, mock.Foo{Value: "c"}}},
+		{`reverse([[1,2], [2,2]])`, []any{[]any{2, 2}, []any{1, 2}}},
+		{`reverse(reverse([[1,2], [2,2]]))`, []any{[]any{1, 2}, []any{2, 2}}},
+		{`reverse([{"test": true}, {id:4}, {name: "value"}])`, []any{map[string]any{"name": "value"}, map[string]any{"id": 4}, map[string]any{"test": true}}},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			program, err := expr.Compile(test.input, expr.Env(env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, env)
+			require.NoError(t, err)
+			assert.Equal(t, test.want, out)
+		})
+	}
+}
+
 func TestBuiltin_sort(t *testing.T) {
 	env := map[string]any{
 		"ArrayOfString": []string{"foo", "bar", "baz"},
diff --git a/docs/language-definition.md b/docs/language-definition.md
index 3b72c0832..e5267f9a8 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -713,6 +713,15 @@ Returns the first `n` elements from an array. If the array has fewer than `n` el
 take([1, 2, 3, 4], 2) == [1, 2]
 ```
 
+### reverse(array) {#reverse}
+
+Return new reversed copy of the array.
+
+```expr
+reverse([3, 1, 4]) == [4, 1, 3]
+reverse(reverse([3, 1, 4])) == [3, 1, 4]
+```
+
 ### sort(array[, order]) {#sort}
 
 Sorts an array in ascending order. Optional `order` argument can be used to specify the order of sorting: `asc`

From 3c03e5965172519f7bc12100db6607d6a9fae031 Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Mon, 12 Feb 2024 04:23:48 +0700
Subject: [PATCH 256/506] Optimize boolean operations between all, any, one,
 none functions (#555)

---
 optimizer/optimizer.go             |   1 +
 optimizer/optimizer_test.go        | 122 +++++++++++++++++++++++++++++
 optimizer/predicate_combination.go |  51 ++++++++++++
 3 files changed, 174 insertions(+)
 create mode 100644 optimizer/predicate_combination.go

diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index a9c0fa3d3..6d1fb0b54 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -36,5 +36,6 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &filterLen{})
 	Walk(node, &filterLast{})
 	Walk(node, &filterFirst{})
+	Walk(node, &predicateCombination{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index e45de763b..703bd1ceb 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -1,6 +1,7 @@
 package optimizer_test
 
 import (
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -339,3 +340,124 @@ func TestOptimize_filter_map_first(t *testing.T) {
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
+
+func TestOptimize_predicate_combination(t *testing.T) {
+	tests := []struct {
+		op     string
+		fn     string
+		wantOp string
+	}{
+		{"and", "all", "and"},
+		{"&&", "all", "&&"},
+		{"or", "all", "or"},
+		{"||", "all", "||"},
+		{"and", "any", "and"},
+		{"&&", "any", "&&"},
+		{"or", "any", "or"},
+		{"||", "any", "||"},
+		{"and", "none", "or"},
+		{"&&", "none", "||"},
+		{"and", "one", "or"},
+		{"&&", "one", "||"},
+	}
+
+	for _, tt := range tests {
+		rule := fmt.Sprintf(`%s(users, .Age > 18 and .Name != "Bob") %s %s(users, .Age < 30)`, tt.fn, tt.op, tt.fn)
+		t.Run(rule, func(t *testing.T) {
+			tree, err := parser.Parse(rule)
+			require.NoError(t, err)
+
+			err = optimizer.Optimize(&tree.Node, nil)
+			require.NoError(t, err)
+
+			expected := &ast.BuiltinNode{
+				Name: tt.fn,
+				Arguments: []ast.Node{
+					&ast.IdentifierNode{Value: "users"},
+					&ast.ClosureNode{
+						Node: &ast.BinaryNode{
+							Operator: tt.wantOp,
+							Left: &ast.BinaryNode{
+								Operator: "and",
+								Left: &ast.BinaryNode{
+									Operator: ">",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Age"},
+									},
+									Right: &ast.IntegerNode{Value: 18},
+								},
+								Right: &ast.BinaryNode{
+									Operator: "!=",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Name"},
+									},
+									Right: &ast.StringNode{Value: "Bob"},
+								},
+							},
+							Right: &ast.BinaryNode{
+								Operator: "<",
+								Left: &ast.MemberNode{
+									Node:     &ast.PointerNode{},
+									Property: &ast.StringNode{Value: "Age"},
+								},
+								Right: &ast.IntegerNode{Value: 30},
+							},
+						},
+					},
+				},
+			}
+			assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+		})
+	}
+}
+
+func TestOptimize_predicate_combination_nested(t *testing.T) {
+	tree, err := parser.Parse(`any(users, {all(.Friends, {.Age == 18 })}) && any(users, {all(.Friends, {.Name != "Bob" })})`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "any",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BuiltinNode{
+					Name: "all",
+					Arguments: []ast.Node{
+						&ast.MemberNode{
+							Node:     &ast.PointerNode{},
+							Property: &ast.StringNode{Value: "Friends"},
+						},
+						&ast.ClosureNode{
+							Node: &ast.BinaryNode{
+								Operator: "&&",
+								Left: &ast.BinaryNode{
+									Operator: "==",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Age"},
+									},
+									Right: &ast.IntegerNode{Value: 18},
+								},
+								Right: &ast.BinaryNode{
+									Operator: "!=",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Name"},
+									},
+									Right: &ast.StringNode{Value: "Bob"},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
diff --git a/optimizer/predicate_combination.go b/optimizer/predicate_combination.go
new file mode 100644
index 000000000..2733781df
--- /dev/null
+++ b/optimizer/predicate_combination.go
@@ -0,0 +1,51 @@
+package optimizer
+
+import (
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/parser/operator"
+)
+
+type predicateCombination struct{}
+
+func (v *predicateCombination) Visit(node *Node) {
+	if op, ok := (*node).(*BinaryNode); ok && operator.IsBoolean(op.Operator) {
+		if left, ok := op.Left.(*BuiltinNode); ok {
+			if combinedOp, ok := combinedOperator(left.Name, op.Operator); ok {
+				if right, ok := op.Right.(*BuiltinNode); ok && right.Name == left.Name {
+					if left.Arguments[0].Type() == right.Arguments[0].Type() && left.Arguments[0].String() == right.Arguments[0].String() {
+						closure := &ClosureNode{
+							Node: &BinaryNode{
+								Operator: combinedOp,
+								Left:     left.Arguments[1].(*ClosureNode).Node,
+								Right:    right.Arguments[1].(*ClosureNode).Node,
+							},
+						}
+						v.Visit(&closure.Node)
+						Patch(node, &BuiltinNode{
+							Name: left.Name,
+							Arguments: []Node{
+								left.Arguments[0],
+								closure,
+							},
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func combinedOperator(fn, op string) (string, bool) {
+	switch fn {
+	case "all", "any":
+		return op, true
+	case "one", "none":
+		switch op {
+		case "and":
+			return "or", true
+		case "&&":
+			return "||", true
+		}
+	}
+	return "", false
+}

From 4354d88e824e96163f86f9af03f70682dc978cce Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 11 Feb 2024 22:48:38 +0100
Subject: [PATCH 257/506] Code style

---
 builtin/lib.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/builtin/lib.go b/builtin/lib.go
index 228a74893..4671c93b0 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -57,8 +57,9 @@ func Type(arg any) any {
 		return "func"
 	case reflect.Struct:
 		return "struct"
+	default:
+		return "unknown"
 	}
-	return "unknown"
 }
 
 func Abs(x any) any {

From 894cea150a6adc0f3cb95b9328ee0e1785886615 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 11 Feb 2024 22:49:25 +0100
Subject: [PATCH 258/506] Move bitFunc to utils.go

---
 builtin/lib.go   | 21 ---------------------
 builtin/utils.go | 21 +++++++++++++++++++++
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/builtin/lib.go b/builtin/lib.go
index 4671c93b0..00b4c9210 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -273,24 +273,3 @@ func Min(args ...any) (any, error) {
 	}
 	return min, nil
 }
-
-func bitFunc(name string, fn func(x, y int) (any, error)) *Function {
-	return &Function{
-		Name: name,
-		Func: func(args ...any) (any, error) {
-			if len(args) != 2 {
-				return nil, fmt.Errorf("invalid number of arguments for %s (expected 2, got %d)", name, len(args))
-			}
-			x, err := toInt(args[0])
-			if err != nil {
-				return nil, fmt.Errorf("%v to call %s", err, name)
-			}
-			y, err := toInt(args[1])
-			if err != nil {
-				return nil, fmt.Errorf("%v to call %s", err, name)
-			}
-			return fn(x, y)
-		},
-		Types: types(new(func(int, int) int)),
-	}
-}
diff --git a/builtin/utils.go b/builtin/utils.go
index f831e95b6..70b612b04 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -90,3 +90,24 @@ func toInt(val any) (int, error) {
 		return 0, fmt.Errorf("cannot use %T as argument (type int)", val)
 	}
 }
+
+func bitFunc(name string, fn func(x, y int) (any, error)) *Function {
+	return &Function{
+		Name: name,
+		Func: func(args ...any) (any, error) {
+			if len(args) != 2 {
+				return nil, fmt.Errorf("invalid number of arguments for %s (expected 2, got %d)", name, len(args))
+			}
+			x, err := toInt(args[0])
+			if err != nil {
+				return nil, fmt.Errorf("%v to call %s", err, name)
+			}
+			y, err := toInt(args[1])
+			if err != nil {
+				return nil, fmt.Errorf("%v to call %s", err, name)
+			}
+			return fn(x, y)
+		},
+		Types: types(new(func(int, int) int)),
+	}
+}

From e53cefe2ef29c793f3867e4568e1c81dc76a50ad Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 11 Feb 2024 22:58:31 +0100
Subject: [PATCH 259/506] Add program.Locations()

---
 vm/program.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/vm/program.go b/vm/program.go
index 041cab51d..e410bef65 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -64,6 +64,11 @@ func (program *Program) Node() ast.Node {
 	return program.node
 }
 
+// Locations returns a slice of bytecode's locations.
+func (program *Program) Locations() []file.Location {
+	return program.locations
+}
+
 // Disassemble returns opcodes as a string.
 func (program *Program) Disassemble() string {
 	var buf bytes.Buffer

From 84ac0b84b58fc608ffe9648c8b76debdbdc382ba Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 11 Feb 2024 23:25:04 +0100
Subject: [PATCH 260/506] Add OpCallSafe

---
 builtin/builtin.go   | 13 +++++++------
 builtin/function.go  | 14 +++++++-------
 compiler/compiler.go | 10 ++++------
 vm/opcodes.go        |  2 +-
 vm/program.go        |  6 +++---
 vm/utils.go          |  6 +++++-
 vm/vm.go             | 22 ++++++++++++++--------
 7 files changed, 41 insertions(+), 32 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index beeb94e91..f7b7bdeb1 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -316,15 +316,16 @@ var Builtins = []*Function{
 	},
 	{
 		Name: "repeat",
-		ValidateArgs: func(args ...any) (any, error) {
+		Safe: func(args ...any) (any, uint, error) {
+			s := args[0].(string)
 			n := runtime.ToInt(args[1])
 			if n < 0 {
-				panic(fmt.Errorf("invalid argument for repeat (expected positive integer, got %d)", n))
+				return nil, 0, fmt.Errorf("invalid argument for repeat (expected positive integer, got %d)", n)
 			}
-			return uint(n), nil
-		},
-		Func: func(args ...any) (any, error) {
-			return strings.Repeat(args[0].(string), runtime.ToInt(args[1])), nil
+			if n > 1e6 {
+				return nil, 0, fmt.Errorf("memory budget exceeded")
+			}
+			return strings.Repeat(s, n), uint(len(s) * n), nil
 		},
 		Types: types(strings.Repeat),
 	},
diff --git a/builtin/function.go b/builtin/function.go
index e6d882340..d4d78b1ce 100644
--- a/builtin/function.go
+++ b/builtin/function.go
@@ -5,13 +5,13 @@ import (
 )
 
 type Function struct {
-	Name         string
-	Func         func(args ...any) (any, error)
-	Fast         func(arg any) any
-	ValidateArgs func(args ...any) (any, error)
-	Types        []reflect.Type
-	Validate     func(args []reflect.Type) (reflect.Type, error)
-	Predicate    bool
+	Name      string
+	Fast      func(arg any) any
+	Func      func(args ...any) (any, error)
+	Safe      func(args ...any) (any, uint, error)
+	Types     []reflect.Type
+	Validate  func(args []reflect.Type) (reflect.Type, error)
+	Predicate bool
 }
 
 func (f *Function) Type() reflect.Type {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 5c7f3603f..252699859 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -116,7 +116,7 @@ func (c *compiler) addConstant(constant any) int {
 	indexable := true
 	hash := constant
 	switch reflect.TypeOf(constant).Kind() {
-	case reflect.Slice, reflect.Map, reflect.Struct:
+	case reflect.Slice, reflect.Map, reflect.Struct, reflect.Func:
 		indexable = false
 	}
 	if field, ok := constant.(*runtime.Field); ok {
@@ -908,13 +908,11 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 			c.compile(arg)
 		}
 
-		if f.ValidateArgs != nil {
-			c.emit(OpLoadFunc, c.addFunction("$_validate_args_"+f.Name, f.ValidateArgs))
-			c.emit(OpValidateArgs, len(node.Arguments))
-		}
-
 		if f.Fast != nil {
 			c.emit(OpCallBuiltin1, id)
+		} else if f.Safe != nil {
+			c.emit(OpPush, c.addConstant(f.Safe))
+			c.emit(OpCallSafe, len(node.Arguments))
 		} else if f.Func != nil {
 			c.emitFunction(f, len(node.Arguments))
 		}
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 57b840507..dc3c97d0c 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -58,9 +58,9 @@ const (
 	OpCall3
 	OpCallN
 	OpCallFast
+	OpCallSafe
 	OpCallTyped
 	OpCallBuiltin1
-	OpValidateArgs
 	OpArray
 	OpMap
 	OpLen
diff --git a/vm/program.go b/vm/program.go
index e410bef65..fa9fefd8f 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -290,6 +290,9 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 		case OpCallFast:
 			argument("OpCallFast")
 
+		case OpCallSafe:
+			argument("OpCallSafe")
+
 		case OpCallTyped:
 			signature := reflect.TypeOf(FuncTypes[arg]).Elem().String()
 			_, _ = fmt.Fprintf(w, "%v\t%v\t<%v>\t%v\n", pp, "OpCallTyped", arg, signature)
@@ -297,9 +300,6 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 		case OpCallBuiltin1:
 			builtinArg("OpCallBuiltin1")
 
-		case OpValidateArgs:
-			argument("OpValidateArgs")
-
 		case OpArray:
 			code("OpArray")
 
diff --git a/vm/utils.go b/vm/utils.go
index f9ec81a8c..dc7f56944 100644
--- a/vm/utils.go
+++ b/vm/utils.go
@@ -4,8 +4,12 @@ import (
 	"reflect"
 )
 
-type Function = func(params ...any) (any, error)
+type (
+	Function     = func(params ...any) (any, error)
+	SafeFunction = func(params ...any) (any, uint, error)
+)
 
+// MemoryBudget represents an upper limit of memory usage.
 var MemoryBudget uint = 1e6
 
 var errorType = reflect.TypeOf((*error)(nil)).Elem()
diff --git a/vm/vm.go b/vm/vm.go
index 0bde66634..f3dc4ab15 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -389,20 +389,26 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			}
 			vm.push(fn(in...))
 
+		case OpCallSafe:
+			fn := vm.pop().(SafeFunction)
+			size := arg
+			in := make([]any, size)
+			for i := int(size) - 1; i >= 0; i-- {
+				in[i] = vm.pop()
+			}
+			out, mem, err := fn(in...)
+			if err != nil {
+				panic(err)
+			}
+			vm.memGrow(mem)
+			vm.push(out)
+
 		case OpCallTyped:
 			vm.push(vm.call(vm.pop(), arg))
 
 		case OpCallBuiltin1:
 			vm.push(builtin.Builtins[arg].Fast(vm.pop()))
 
-		case OpValidateArgs:
-			fn := vm.pop().(Function)
-			mem, err := fn(vm.Stack[len(vm.Stack)-arg:]...)
-			if err != nil {
-				panic(err)
-			}
-			vm.memGrow(mem.(uint))
-
 		case OpArray:
 			size := vm.pop().(int)
 			vm.memGrow(uint(size))

From ffaec9e78a6e4cbd418620588567695eaad2925c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 12 Feb 2024 22:09:41 +0100
Subject: [PATCH 261/506] Fix ast printing of ?.[

---
 ast/print.go      | 2 +-
 ast/print_test.go | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/ast/print.go b/ast/print.go
index 7ecb1c04c..fa593ae28 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -112,7 +112,7 @@ func (n *MemberNode) String() string {
 		if str, ok := n.Property.(*StringNode); ok && utils.IsValidIdentifier(str.Value) {
 			return fmt.Sprintf("%s?.%s", n.Node.String(), str.Value)
 		} else {
-			return fmt.Sprintf("get(%s, %s)", n.Node.String(), n.Property.String())
+			return fmt.Sprintf("%s?.[%s]", n.Node.String(), n.Property.String())
 		}
 	}
 	if str, ok := n.Property.(*StringNode); ok && utils.IsValidIdentifier(str.Value) {
diff --git a/ast/print_test.go b/ast/print_test.go
index 2ecff147c..16d64357b 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -28,6 +28,8 @@ func TestPrint(t *testing.T) {
 		{`a["the b"]`, `a["the b"]`},
 		{`a.b[0]`, `a.b[0]`},
 		{`a?.b`, `a?.b`},
+		{`x[0][1]`, `x[0][1]`},
+		{`x?.[0]?.[1]`, `x?.[0]?.[1]`},
 		{`-a`, `-a`},
 		{`!a`, `!a`},
 		{`not a`, `not a`},
@@ -88,7 +90,7 @@ func TestPrint_MemberNode(t *testing.T) {
 		Property: &ast.StringNode{Value: "b c"},
 		Optional: true,
 	}
-	require.Equal(t, `get(a, "b c")`, node.String())
+	require.Equal(t, `a?.["b c"]`, node.String())
 }
 
 func TestPrint_ConstantNode(t *testing.T) {

From 0bc9d995efba166c17f20b0fc6bd6b7d28632b7f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 12 Feb 2024 22:58:19 +0100
Subject: [PATCH 262/506] Update SECURITY.md

---
 SECURITY.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/SECURITY.md b/SECURITY.md
index 6e343ee36..8d692a398 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -11,11 +11,11 @@ unless this is not possible or feasible with a reasonable effort.
 
 | Version | Supported          |
 |---------|--------------------|
+| 1.16    | :white_check_mark: |
 | 1.15    | :white_check_mark: |
 | 1.14    | :white_check_mark: |
 | 1.13    | :white_check_mark: |
-| 1.12    | :white_check_mark: |
-| < 1.12  | :x:                |
+| < 1.13  | :x:                |
 
 ## Reporting a Vulnerability
 

From 36f9adb32bf638876b4d3f4f45449b33799f3510 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 15 Feb 2024 19:53:35 +0100
Subject: [PATCH 263/506] Refactor groupBy and sortBy (#562)

* Rearrange opcodes

* Refactor groupBy

* Fix tests

* Super opcodes for GroupBy

* Refactor sortBy builtin

* Fix sortBy bench
---
 bench_test.go           |   2 +-
 builtin/builtin.go      | 137 ++++++++++++++--------------------------
 builtin/builtin_test.go |  18 +++++-
 builtin/sort.go         |  96 ----------------------------
 checker/checker.go      |  26 +++++++-
 checker/checker_test.go |  10 ---
 compiler/compiler.go    |  22 ++++++-
 debug/debugger.go       |   3 -
 parser/parser.go        |   1 +
 vm/opcodes.go           |   8 ++-
 vm/program.go           |  22 ++++---
 vm/runtime/sort.go      |  45 +++++++++++++
 vm/utils.go             |  18 +++++-
 vm/vm.go                |  67 ++++++++++++++------
 14 files changed, 237 insertions(+), 238 deletions(-)
 delete mode 100644 builtin/sort.go
 create mode 100644 vm/runtime/sort.go

diff --git a/bench_test.go b/bench_test.go
index 601be77a2..ebeed5d18 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -486,7 +486,7 @@ func Benchmark_sortBy(b *testing.B) {
 		env["arr"].([]Foo)[i] = Foo{Value: v.(int)}
 	}
 
-	program, err := expr.Compile(`sortBy(arr, "Value")`, expr.Env(env))
+	program, err := expr.Compile(`sortBy(arr, .Value)`, expr.Env(env))
 	require.NoError(b, err)
 
 	var out any
diff --git a/builtin/builtin.go b/builtin/builtin.go
index f7b7bdeb1..70a8c09c7 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -87,6 +87,11 @@ var Builtins = []*Function{
 		Predicate: true,
 		Types:     types(new(func([]any, func(any) any) map[any][]any)),
 	},
+	{
+		Name:      "sortBy",
+		Predicate: true,
+		Types:     types(new(func([]any, func(any) bool, string) []any)),
+	},
 	{
 		Name:      "reduce",
 		Predicate: true,
@@ -905,109 +910,65 @@ var Builtins = []*Function{
 	},
 	{
 		Name: "sort",
-		Func: func(args ...any) (any, error) {
+		Safe: func(args ...any) (any, uint, error) {
 			if len(args) != 1 && len(args) != 2 {
-				return nil, fmt.Errorf("invalid number of arguments (expected 1 or 2, got %d)", len(args))
+				return nil, 0, fmt.Errorf("invalid number of arguments (expected 1 or 2, got %d)", len(args))
 			}
 
-			v := reflect.ValueOf(args[0])
-			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
-				return nil, fmt.Errorf("cannot sort %s", v.Kind())
-			}
+			var array []any
 
-			orderBy := OrderBy{}
-			if len(args) == 2 {
-				dir, err := ascOrDesc(args[1])
-				if err != nil {
-					return nil, err
+			switch in := args[0].(type) {
+			case []any:
+				array = make([]any, len(in))
+				copy(array, in)
+			case []int:
+				array = make([]any, len(in))
+				for i, v := range in {
+					array[i] = v
+				}
+			case []float64:
+				array = make([]any, len(in))
+				for i, v := range in {
+					array[i] = v
+				}
+			case []string:
+				array = make([]any, len(in))
+				for i, v := range in {
+					array[i] = v
 				}
-				orderBy.Desc = dir
 			}
 
-			sortable, err := copyArray(v, orderBy)
-			if err != nil {
-				return nil, err
-			}
-			sort.Sort(sortable)
-			return sortable.Array, nil
-		},
-		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 && len(args) != 2 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1 or 2, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Interface, reflect.Slice, reflect.Array:
-			default:
-				return anyType, fmt.Errorf("cannot sort %s", args[0])
-			}
+			var desc bool
 			if len(args) == 2 {
-				switch kind(args[1]) {
-				case reflect.String, reflect.Interface:
+				switch args[1].(string) {
+				case "asc":
+					desc = false
+				case "desc":
+					desc = true
 				default:
-					return anyType, fmt.Errorf("invalid argument for sort (expected string, got %s)", args[1])
+					return nil, 0, fmt.Errorf("invalid order %s, expected asc or desc", args[1])
 				}
 			}
-			return arrayType, nil
-		},
-	},
-	{
-		Name: "sortBy",
-		Func: func(args ...any) (any, error) {
-			if len(args) != 2 && len(args) != 3 {
-				return nil, fmt.Errorf("invalid number of arguments (expected 2 or 3, got %d)", len(args))
-			}
 
-			v := reflect.ValueOf(args[0])
-			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
-				return nil, fmt.Errorf("cannot sort %s", v.Kind())
-			}
-
-			orderBy := OrderBy{}
-
-			field, ok := args[1].(string)
-			if !ok {
-				return nil, fmt.Errorf("invalid argument for sort (expected string, got %s)", reflect.TypeOf(args[1]))
-			}
-			orderBy.Field = field
-
-			if len(args) == 3 {
-				dir, err := ascOrDesc(args[2])
-				if err != nil {
-					return nil, err
-				}
-				orderBy.Desc = dir
-			}
-
-			sortable, err := copyArray(v, orderBy)
-			if err != nil {
-				return nil, err
+			sortable := &runtime.Sort{
+				Desc:  desc,
+				Array: array,
 			}
 			sort.Sort(sortable)
-			return sortable.Array, nil
-		},
-		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 2 && len(args) != 3 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 2 or 3, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Interface, reflect.Slice, reflect.Array:
-			default:
-				return anyType, fmt.Errorf("cannot sort %s", args[0])
-			}
-			switch kind(args[1]) {
-			case reflect.String, reflect.Interface:
-			default:
-				return anyType, fmt.Errorf("invalid argument for sort (expected string, got %s)", args[1])
-			}
-			if len(args) == 3 {
-				switch kind(args[2]) {
-				case reflect.String, reflect.Interface:
-				default:
-					return anyType, fmt.Errorf("invalid argument for sort (expected string, got %s)", args[1])
-				}
-			}
-			return arrayType, nil
+
+			return sortable.Array, uint(len(array)), nil
 		},
+		Types: types(
+			new(func([]any, string) []any),
+			new(func([]int, string) []any),
+			new(func([]float64, string) []any),
+			new(func([]string, string) []any),
+
+			new(func([]any) []any),
+			new(func([]float64) []any),
+			new(func([]string) []any),
+			new(func([]int) []any),
+		),
 	},
 	bitFunc("bitand", func(x, y int) (any, error) {
 		return x & y, nil
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index d6b967d13..87e2a7c9d 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -530,8 +530,8 @@ func TestBuiltin_sort(t *testing.T) {
 		{`sort(ArrayOfInt)`, []any{1, 2, 3}},
 		{`sort(ArrayOfFloat)`, []any{1.0, 2.0, 3.0}},
 		{`sort(ArrayOfInt, 'desc')`, []any{3, 2, 1}},
-		{`sortBy(ArrayOfFoo, 'Value')`, []any{mock.Foo{Value: "a"}, mock.Foo{Value: "b"}, mock.Foo{Value: "c"}}},
-		{`sortBy([{id: "a"}, {id: "b"}], "id", "desc")`, []any{map[string]any{"id": "b"}, map[string]any{"id": "a"}}},
+		{`sortBy(ArrayOfFoo, .Value)`, []any{mock.Foo{Value: "a"}, mock.Foo{Value: "b"}, mock.Foo{Value: "c"}}},
+		{`sortBy([{id: "a"}, {id: "b"}], .id, "desc")`, []any{map[string]any{"id": "b"}, map[string]any{"id": "a"}}},
 	}
 
 	for _, test := range tests {
@@ -546,6 +546,20 @@ func TestBuiltin_sort(t *testing.T) {
 	}
 }
 
+func TestBuiltin_sort_i64(t *testing.T) {
+	env := map[string]any{
+		"array": []int{1, 2, 3},
+		"i64":   int64(1),
+	}
+
+	program, err := expr.Compile(`sort(map(array, i64))`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, []any{int64(1), int64(1), int64(1)}, out)
+}
+
 func TestBuiltin_bitOpsFunc(t *testing.T) {
 	tests := []struct {
 		input string
diff --git a/builtin/sort.go b/builtin/sort.go
deleted file mode 100644
index 9b9ddc165..000000000
--- a/builtin/sort.go
+++ /dev/null
@@ -1,96 +0,0 @@
-package builtin
-
-import (
-	"fmt"
-	"reflect"
-)
-
-type Sortable struct {
-	Array  []any
-	Values []reflect.Value
-	OrderBy
-}
-
-type OrderBy struct {
-	Field string
-	Desc  bool
-}
-
-func (s *Sortable) Len() int {
-	return len(s.Array)
-}
-
-func (s *Sortable) Swap(i, j int) {
-	s.Array[i], s.Array[j] = s.Array[j], s.Array[i]
-	s.Values[i], s.Values[j] = s.Values[j], s.Values[i]
-}
-
-func (s *Sortable) Less(i, j int) bool {
-	a, b := s.Values[i], s.Values[j]
-	switch a.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		if s.Desc {
-			return a.Int() > b.Int()
-		}
-		return a.Int() < b.Int()
-	case reflect.Float64, reflect.Float32:
-		if s.Desc {
-			return a.Float() > b.Float()
-		}
-		return a.Float() < b.Float()
-	case reflect.String:
-		if s.Desc {
-			return a.String() > b.String()
-		}
-		return a.String() < b.String()
-	default:
-		panic(fmt.Sprintf("sort: unsupported type %s", a.Kind()))
-	}
-}
-
-func copyArray(v reflect.Value, orderBy OrderBy) (*Sortable, error) {
-	s := &Sortable{
-		Array:   make([]any, v.Len()),
-		Values:  make([]reflect.Value, v.Len()),
-		OrderBy: orderBy,
-	}
-	var prev reflect.Value
-	for i := 0; i < s.Len(); i++ {
-		elem := deref(v.Index(i))
-		var value reflect.Value
-		switch elem.Kind() {
-		case reflect.Struct:
-			value = elem.FieldByName(s.Field)
-		case reflect.Map:
-			value = elem.MapIndex(reflect.ValueOf(s.Field))
-		default:
-			value = elem
-		}
-		value = deref(value)
-
-		s.Array[i] = elem.Interface()
-		s.Values[i] = value
-
-		if i == 0 {
-			prev = value
-		} else if value.Type() != prev.Type() {
-			return nil, fmt.Errorf("cannot sort array of different types (%s and %s)", value.Type(), prev.Type())
-		}
-	}
-	return s, nil
-}
-
-func ascOrDesc(arg any) (bool, error) {
-	dir, ok := arg.(string)
-	if !ok {
-		return false, fmt.Errorf("invalid argument for sort (expected string, got %s)", reflect.TypeOf(arg))
-	}
-	switch dir {
-	case "desc":
-		return true, nil
-	case "asc":
-		return false, nil
-	default:
-		return false, fmt.Errorf(`invalid argument for sort (expected "asc" or "desc", got %q)`, dir)
-	}
-}
diff --git a/checker/checker.go b/checker/checker.go
index 3dc4e95ad..11e4eee3c 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -633,7 +633,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			if isAny(collection) {
 				return arrayType, info{}
 			}
-			return reflect.SliceOf(collection.Elem()), info{}
+			return arrayType, info{}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
@@ -651,7 +651,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			closure.NumOut() == 1 &&
 			closure.NumIn() == 1 && isAny(closure.In(0)) {
 
-			return reflect.SliceOf(closure.Out(0)), info{}
+			return arrayType, info{}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
@@ -739,6 +739,28 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
+	case "sortBy":
+		collection, _ := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isAny(collection) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		}
+
+		v.begin(collection)
+		closure, _ := v.visit(node.Arguments[1])
+		v.end()
+
+		if len(node.Arguments) == 3 {
+			_, _ = v.visit(node.Arguments[2])
+		}
+
+		if isFunc(closure) &&
+			closure.NumOut() == 1 &&
+			closure.NumIn() == 1 && isAny(closure.In(0)) {
+
+			return reflect.TypeOf([]any{}), info{}
+		}
+		return v.error(node.Arguments[1], "predicate should has one input and one output param")
+
 	case "reduce":
 		collection, _ := v.visit(node.Arguments[0])
 		if !isArray(collection) && !isAny(collection) {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 2bf5ec864..bab9a0a67 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -400,11 +400,6 @@ invalid operation: < (mismatched types mock.Bar and int) (1:29)
  | all(ArrayOfFoo, {#.Method() < 0})
  | ............................^
 
-map(Any, {0})[0] + "str"
-invalid operation: + (mismatched types int and string) (1:18)
- | map(Any, {0})[0] + "str"
- | .................^
-
 Variadic()
 not enough arguments to call Variadic (1:1)
  | Variadic()
@@ -445,11 +440,6 @@ builtin map takes only array (got int) (1:5)
  | map(1, {2})
  | ....^
 
-map(filter(ArrayOfFoo, {true}), {.Not})
-type mock.Foo has no field Not (1:35)
- | map(filter(ArrayOfFoo, {true}), {.Not})
- | ..................................^
-
 ArrayOfFoo[Foo]
 array elements can only be selected using an integer (got mock.Foo) (1:12)
  | ArrayOfFoo[Foo]
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 252699859..a4f189e6b 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -873,11 +873,31 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 	case "groupBy":
 		c.compile(node.Arguments[0])
 		c.emit(OpBegin)
+		c.emit(OpCreate, 1)
+		c.emit(OpSetAcc)
 		c.emitLoop(func() {
 			c.compile(node.Arguments[1])
 			c.emit(OpGroupBy)
 		})
-		c.emit(OpGetGroupBy)
+		c.emit(OpGetAcc)
+		c.emit(OpEnd)
+		return
+
+	case "sortBy":
+		c.compile(node.Arguments[0])
+		c.emit(OpBegin)
+		if len(node.Arguments) == 3 {
+			c.compile(node.Arguments[2])
+		} else {
+			c.emit(OpPush, c.addConstant("asc"))
+		}
+		c.emit(OpCreate, 2)
+		c.emit(OpSetAcc)
+		c.emitLoop(func() {
+			c.compile(node.Arguments[1])
+			c.emit(OpSortBy)
+		})
+		c.emit(OpSort)
 		c.emit(OpEnd)
 		return
 
diff --git a/debug/debugger.go b/debug/debugger.go
index 6f341e30e..5676fc1b9 100644
--- a/debug/debugger.go
+++ b/debug/debugger.go
@@ -134,9 +134,6 @@ func StartDebugger(program *Program, env any) {
 				keys = append(keys, pair{"Index", s.Index})
 				keys = append(keys, pair{"Len", s.Len})
 				keys = append(keys, pair{"Count", s.Count})
-				if s.GroupBy != nil {
-					keys = append(keys, pair{"GroupBy", s.GroupBy})
-				}
 				if s.Acc != nil {
 					keys = append(keys, pair{"Acc", s.Acc})
 				}
diff --git a/parser/parser.go b/parser/parser.go
index bc620ac68..1eabdebe2 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -39,6 +39,7 @@ var predicates = map[string]struct {
 	"findLast":      {[]arg{expr, closure}},
 	"findLastIndex": {[]arg{expr, closure}},
 	"groupBy":       {[]arg{expr, closure}},
+	"sortBy":        {[]arg{expr, closure, expr | optional}},
 	"reduce":        {[]arg{expr, closure, expr | optional}},
 }
 
diff --git a/vm/opcodes.go b/vm/opcodes.go
index dc3c97d0c..0417dab61 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -70,15 +70,17 @@ const (
 	OpDecrementIndex
 	OpIncrementCount
 	OpGetIndex
-	OpSetIndex
 	OpGetCount
 	OpGetLen
-	OpGetGroupBy
 	OpGetAcc
+	OpSetAcc
+	OpSetIndex
 	OpPointer
 	OpThrow
+	OpCreate
 	OpGroupBy
-	OpSetAcc
+	OpSortBy
+	OpSort
 	OpBegin
 	OpEnd // This opcode must be at the end of this list.
 )
diff --git a/vm/program.go b/vm/program.go
index fa9fefd8f..4a878267b 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -327,32 +327,38 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 		case OpGetIndex:
 			code("OpGetIndex")
 
-		case OpSetIndex:
-			code("OpSetIndex")
-
 		case OpGetCount:
 			code("OpGetCount")
 
 		case OpGetLen:
 			code("OpGetLen")
 
-		case OpGetGroupBy:
-			code("OpGetGroupBy")
-
 		case OpGetAcc:
 			code("OpGetAcc")
 
+		case OpSetAcc:
+			code("OpSetAcc")
+
+		case OpSetIndex:
+			code("OpSetIndex")
+
 		case OpPointer:
 			code("OpPointer")
 
 		case OpThrow:
 			code("OpThrow")
 
+		case OpCreate:
+			argument("OpCreate")
+
 		case OpGroupBy:
 			code("OpGroupBy")
 
-		case OpSetAcc:
-			code("OpSetAcc")
+		case OpSortBy:
+			code("OpSortBy")
+
+		case OpSort:
+			code("OpSort")
 
 		case OpBegin:
 			code("OpBegin")
diff --git a/vm/runtime/sort.go b/vm/runtime/sort.go
new file mode 100644
index 000000000..fb1f340d7
--- /dev/null
+++ b/vm/runtime/sort.go
@@ -0,0 +1,45 @@
+package runtime
+
+type SortBy struct {
+	Desc   bool
+	Array  []any
+	Values []any
+}
+
+func (s *SortBy) Len() int {
+	return len(s.Array)
+}
+
+func (s *SortBy) Swap(i, j int) {
+	s.Array[i], s.Array[j] = s.Array[j], s.Array[i]
+	s.Values[i], s.Values[j] = s.Values[j], s.Values[i]
+}
+
+func (s *SortBy) Less(i, j int) bool {
+	a, b := s.Values[i], s.Values[j]
+	if s.Desc {
+		return Less(b, a)
+	}
+	return Less(a, b)
+}
+
+type Sort struct {
+	Desc  bool
+	Array []any
+}
+
+func (s *Sort) Len() int {
+	return len(s.Array)
+}
+
+func (s *Sort) Swap(i, j int) {
+	s.Array[i], s.Array[j] = s.Array[j], s.Array[i]
+}
+
+func (s *Sort) Less(i, j int) bool {
+	a, b := s.Array[i], s.Array[j]
+	if s.Desc {
+		return Less(b, a)
+	}
+	return Less(a, b)
+}
diff --git a/vm/utils.go b/vm/utils.go
index dc7f56944..d7db2a52a 100644
--- a/vm/utils.go
+++ b/vm/utils.go
@@ -9,7 +9,19 @@ type (
 	SafeFunction = func(params ...any) (any, uint, error)
 )
 
-// MemoryBudget represents an upper limit of memory usage.
-var MemoryBudget uint = 1e6
+var (
+	// MemoryBudget represents an upper limit of memory usage.
+	MemoryBudget uint = 1e6
 
-var errorType = reflect.TypeOf((*error)(nil)).Elem()
+	errorType = reflect.TypeOf((*error)(nil)).Elem()
+)
+
+type Scope struct {
+	Array reflect.Value
+	Index int
+	Len   int
+	Count int
+	Acc   any
+}
+
+type groupBy = map[any][]any
diff --git a/vm/vm.go b/vm/vm.go
index f3dc4ab15..56d5fc2ee 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"reflect"
 	"regexp"
+	"sort"
 	"strings"
 
 	"github.com/expr-lang/expr/builtin"
@@ -43,15 +44,6 @@ type VM struct {
 	curr         chan int
 }
 
-type Scope struct {
-	Array   reflect.Value
-	Index   int
-	Len     int
-	Count   int
-	GroupBy map[any][]any
-	Acc     any
-}
-
 func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -460,10 +452,6 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpGetIndex:
 			vm.push(vm.scope().Index)
 
-		case OpSetIndex:
-			scope := vm.scope()
-			scope.Index = vm.pop().(int)
-
 		case OpGetCount:
 			scope := vm.scope()
 			vm.push(scope.Count)
@@ -472,15 +460,16 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			scope := vm.scope()
 			vm.push(scope.Len)
 
-		case OpGetGroupBy:
-			vm.push(vm.scope().GroupBy)
-
 		case OpGetAcc:
 			vm.push(vm.scope().Acc)
 
 		case OpSetAcc:
 			vm.scope().Acc = vm.pop()
 
+		case OpSetIndex:
+			scope := vm.scope()
+			scope.Index = vm.pop().(int)
+
 		case OpPointer:
 			scope := vm.scope()
 			vm.push(scope.Array.Index(scope.Index).Interface())
@@ -488,14 +477,50 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpThrow:
 			panic(vm.pop().(error))
 
+		case OpCreate:
+			switch arg {
+			case 1:
+				vm.push(make(groupBy))
+			case 2:
+				scope := vm.scope()
+				var desc bool
+				switch vm.pop().(string) {
+				case "asc":
+					desc = false
+				case "desc":
+					desc = true
+				default:
+					panic("unknown order, use asc or desc")
+				}
+				vm.push(&runtime.SortBy{
+					Desc:   desc,
+					Array:  make([]any, 0, scope.Len),
+					Values: make([]any, 0, scope.Len),
+				})
+			default:
+				panic(fmt.Sprintf("unknown OpCreate argument %v", arg))
+			}
+
 		case OpGroupBy:
 			scope := vm.scope()
-			if scope.GroupBy == nil {
-				scope.GroupBy = make(map[any][]any)
-			}
-			it := scope.Array.Index(scope.Index).Interface()
 			key := vm.pop()
-			scope.GroupBy[key] = append(scope.GroupBy[key], it)
+			item := scope.Array.Index(scope.Index).Interface()
+			scope.Acc.(groupBy)[key] = append(scope.Acc.(groupBy)[key], item)
+
+		case OpSortBy:
+			scope := vm.scope()
+			value := vm.pop()
+			item := scope.Array.Index(scope.Index).Interface()
+			sortable := scope.Acc.(*runtime.SortBy)
+			sortable.Array = append(sortable.Array, item)
+			sortable.Values = append(sortable.Values, value)
+
+		case OpSort:
+			scope := vm.scope()
+			sortable := scope.Acc.(*runtime.SortBy)
+			sort.Sort(sortable)
+			vm.memGrow(uint(scope.Len))
+			vm.push(sortable.Array)
 
 		case OpBegin:
 			a := vm.pop()

From b9f96a0fd1bb029f28b04557707980526101974d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 16 Feb 2024 22:32:35 +0100
Subject: [PATCH 264/506] Add concat() builtin (#565)

* Add concat() builtin

* Use pkg deref in builtin

* Use pkg deref in checker

* Use pkg deref in types_table.go

* Use pkg deref in docgen.go

* Use pkg deref in vm
---
 builtin/builtin.go           |  54 +++++++++++++++--
 builtin/builtin_test.go      |  12 ++--
 builtin/utils.go             |  29 ---------
 checker/checker.go           |   8 +--
 checker/types.go             |  19 ------
 conf/types_table.go          |  21 +------
 docgen/docgen.go             |  15 +----
 expr_test.go                 |  29 +++------
 internal/deref/deref.go      |  47 +++++++++++++++
 internal/deref/deref_test.go | 111 +++++++++++++++++++++++++++++++++++
 test/deref/deref_test.go     |  16 +++++
 vm/runtime/runtime.go        |  40 ++-----------
 vm/vm.go                     |   3 +-
 13 files changed, 255 insertions(+), 149 deletions(-)
 create mode 100644 internal/deref/deref.go
 create mode 100644 internal/deref/deref_test.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 70a8c09c7..4aad6aa9c 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -9,6 +9,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/expr-lang/expr/internal/deref"
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
@@ -440,7 +441,7 @@ var Builtins = []*Function{
 			sum := int64(0)
 			i := 0
 			for ; i < v.Len(); i++ {
-				it := deref(v.Index(i))
+				it := deref.Value(v.Index(i))
 				if it.CanInt() {
 					sum += it.Int()
 				} else if it.CanFloat() {
@@ -453,7 +454,7 @@ var Builtins = []*Function{
 		float:
 			fSum := float64(sum)
 			for ; i < v.Len(); i++ {
-				it := deref(v.Index(i))
+				it := deref.Value(v.Index(i))
 				if it.CanInt() {
 					fSum += float64(it.Int())
 				} else if it.CanFloat() {
@@ -492,7 +493,7 @@ var Builtins = []*Function{
 			sum := float64(0)
 			i := 0
 			for ; i < v.Len(); i++ {
-				it := deref(v.Index(i))
+				it := deref.Value(v.Index(i))
 				if it.CanInt() {
 					sum += float64(it.Int())
 				} else if it.CanFloat() {
@@ -530,7 +531,7 @@ var Builtins = []*Function{
 			}
 			s := make([]float64, v.Len())
 			for i := 0; i < v.Len(); i++ {
-				it := deref(v.Index(i))
+				it := deref.Value(v.Index(i))
 				if it.CanInt() {
 					s[i] = float64(it.Int())
 				} else if it.CanFloat() {
@@ -850,7 +851,7 @@ var Builtins = []*Function{
 			}
 			out := reflect.MakeMap(mapType)
 			for i := 0; i < v.Len(); i++ {
-				pair := deref(v.Index(i))
+				pair := deref.Value(v.Index(i))
 				if pair.Kind() != reflect.Array && pair.Kind() != reflect.Slice {
 					return nil, fmt.Errorf("invalid pair %v", pair)
 				}
@@ -908,6 +909,49 @@ var Builtins = []*Function{
 			}
 		},
 	},
+	{
+		Name: "concat",
+		Safe: func(args ...any) (any, uint, error) {
+			if len(args) == 0 {
+				return nil, 0, fmt.Errorf("invalid number of arguments (expected at least 1, got 0)")
+			}
+
+			var size uint
+			var arr []any
+
+			for _, arg := range args {
+				v := reflect.ValueOf(deref.Deref(arg))
+
+				if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+					return nil, 0, fmt.Errorf("cannot concat %s", v.Kind())
+				}
+
+				size += uint(v.Len())
+
+				for i := 0; i < v.Len(); i++ {
+					item := v.Index(i)
+					arr = append(arr, item.Interface())
+				}
+			}
+
+			return arr, size, nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) == 0 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected at least 1, got 0)")
+			}
+
+			for _, arg := range args {
+				switch kind(deref.Type(arg)) {
+				case reflect.Interface, reflect.Slice, reflect.Array:
+				default:
+					return anyType, fmt.Errorf("cannot concat %s", arg)
+				}
+			}
+
+			return arrayType, nil
+		},
+	},
 	{
 		Name: "sort",
 		Safe: func(args ...any) (any, uint, error) {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 87e2a7c9d..3a2850071 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -19,11 +19,13 @@ import (
 )
 
 func TestBuiltin(t *testing.T) {
+	ArrayWithNil := []any{42}
 	env := map[string]any{
-		"ArrayOfString": []string{"foo", "bar", "baz"},
-		"ArrayOfInt":    []int{1, 2, 3},
-		"ArrayOfAny":    []any{1, "2", true},
-		"ArrayOfFoo":    []mock.Foo{{Value: "a"}, {Value: "b"}, {Value: "c"}},
+		"ArrayOfString":   []string{"foo", "bar", "baz"},
+		"ArrayOfInt":      []int{1, 2, 3},
+		"ArrayOfAny":      []any{1, "2", true},
+		"ArrayOfFoo":      []mock.Foo{{Value: "a"}, {Value: "b"}, {Value: "c"}},
+		"PtrArrayWithNil": &ArrayWithNil,
 	}
 
 	var tests = []struct {
@@ -130,6 +132,8 @@ func TestBuiltin(t *testing.T) {
 		{`reduce(1..9, # + #acc)`, 45},
 		{`reduce([.5, 1.5, 2.5], # + #acc, 0)`, 4.5},
 		{`reduce([], 5, 0)`, 0},
+		{`concat(ArrayOfString, ArrayOfInt)`, []any{"foo", "bar", "baz", 1, 2, 3}},
+		{`concat(PtrArrayWithNil, [nil])`, []any{42, nil}},
 	}
 
 	for _, test := range tests {
diff --git a/builtin/utils.go b/builtin/utils.go
index 70b612b04..7d3b6ee8e 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -35,35 +35,6 @@ func types(types ...any) []reflect.Type {
 	return ts
 }
 
-func deref(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Interface {
-		if v.IsNil() {
-			return v
-		}
-		v = v.Elem()
-	}
-
-loop:
-	for v.Kind() == reflect.Ptr {
-		if v.IsNil() {
-			return v
-		}
-		indirect := reflect.Indirect(v)
-		switch indirect.Kind() {
-		case reflect.Struct, reflect.Map, reflect.Array, reflect.Slice:
-			break loop
-		default:
-			v = v.Elem()
-		}
-	}
-
-	if v.IsValid() {
-		return v
-	}
-
-	panic(fmt.Sprintf("cannot deref %s", v))
-}
-
 func toInt(val any) (int, error) {
 	switch v := val.(type) {
 	case int:
diff --git a/checker/checker.go b/checker/checker.go
index 11e4eee3c..c845dd78a 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -9,6 +9,7 @@ import (
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/internal/deref"
 	"github.com/expr-lang/expr/parser"
 )
 
@@ -203,8 +204,7 @@ func (v *checker) ConstantNode(node *ast.ConstantNode) (reflect.Type, info) {
 
 func (v *checker) UnaryNode(node *ast.UnaryNode) (reflect.Type, info) {
 	t, _ := v.visit(node.Node)
-
-	t = deref(t)
+	t = deref.Type(t)
 
 	switch node.Operator {
 
@@ -235,8 +235,8 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 	l, _ := v.visit(node.Left)
 	r, ri := v.visit(node.Right)
 
-	l = deref(l)
-	r = deref(r)
+	l = deref.Type(l)
+	r = deref.Type(r)
 
 	// check operator overloading
 	if fns, ok := v.config.Operators[node.Operator]; ok {
diff --git a/checker/types.go b/checker/types.go
index 8c0805049..d10736a77 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -205,25 +205,6 @@ func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
 	return reflect.StructField{}, false
 }
 
-func deref(t reflect.Type) reflect.Type {
-	if t == nil {
-		return nil
-	}
-	if t.Kind() == reflect.Interface {
-		return t
-	}
-	for t != nil && t.Kind() == reflect.Ptr {
-		e := t.Elem()
-		switch e.Kind() {
-		case reflect.Struct, reflect.Map, reflect.Array, reflect.Slice:
-			return t
-		default:
-			t = e
-		}
-	}
-	return t
-}
-
 func kind(t reflect.Type) reflect.Kind {
 	if t == nil {
 		return reflect.Invalid
diff --git a/conf/types_table.go b/conf/types_table.go
index 8ebb76c35..738eee840 100644
--- a/conf/types_table.go
+++ b/conf/types_table.go
@@ -2,6 +2,8 @@ package conf
 
 import (
 	"reflect"
+
+	"github.com/expr-lang/expr/internal/deref"
 )
 
 type Tag struct {
@@ -77,7 +79,7 @@ func CreateTypesTable(i any) TypesTable {
 
 func FieldsFromStruct(t reflect.Type) TypesTable {
 	types := make(TypesTable)
-	t = dereference(t)
+	t = deref.Type(t)
 	if t == nil {
 		return types
 	}
@@ -111,23 +113,6 @@ func FieldsFromStruct(t reflect.Type) TypesTable {
 	return types
 }
 
-func dereference(t reflect.Type) reflect.Type {
-	if t == nil {
-		return nil
-	}
-	if t.Kind() == reflect.Ptr {
-		t = dereference(t.Elem())
-	}
-	return t
-}
-
-func kind(t reflect.Type) reflect.Kind {
-	if t == nil {
-		return reflect.Invalid
-	}
-	return t.Kind()
-}
-
 func FieldName(field reflect.StructField) string {
 	if taggedName := field.Tag.Get("expr"); taggedName != "" {
 		return taggedName
diff --git a/docgen/docgen.go b/docgen/docgen.go
index e9a542b8c..aed0f48f0 100644
--- a/docgen/docgen.go
+++ b/docgen/docgen.go
@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/internal/deref"
 )
 
 // Kind can be any of array, map, struct, func, string, int, float, bool or any.
@@ -80,7 +81,7 @@ func CreateDoc(i any) *Context {
 	c := &Context{
 		Variables: make(map[Identifier]*Type),
 		Types:     make(map[TypeName]*Type),
-		PkgPath:   dereference(reflect.TypeOf(i)).PkgPath(),
+		PkgPath:   deref.Type(reflect.TypeOf(i)).PkgPath(),
 	}
 
 	for name, t := range conf.CreateTypesTable(i) {
@@ -134,7 +135,7 @@ func (c *Context) use(t reflect.Type, ops ...option) *Type {
 		methods = append(methods, m)
 	}
 
-	t = dereference(t)
+	t = deref.Type(t)
 
 	// Only named types will have methods defined on them.
 	// It maybe not even struct, but we gonna call then
@@ -253,13 +254,3 @@ func isPrivate(s string) bool {
 func isProtobuf(s string) bool {
 	return strings.HasPrefix(s, "XXX_")
 }
-
-func dereference(t reflect.Type) reflect.Type {
-	if t == nil {
-		return nil
-	}
-	if t.Kind() == reflect.Ptr {
-		t = dereference(t.Elem())
-	}
-	return t
-}
diff --git a/expr_test.go b/expr_test.go
index 7c20e4899..ed08cae53 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -316,9 +316,9 @@ func ExampleOperator_Decimal() {
 	code := `A + B - C`
 
 	type Env struct {
-		A, B, C   Decimal
-		Sub       func(a, b Decimal) Decimal
-		Add       func(a, b Decimal) Decimal
+		A, B, C Decimal
+		Sub     func(a, b Decimal) Decimal
+		Add     func(a, b Decimal) Decimal
 	}
 
 	options := []expr.Option{
@@ -334,11 +334,11 @@ func ExampleOperator_Decimal() {
 	}
 
 	env := Env{
-		A: Decimal{3},
-		B: Decimal{2},
-		C: Decimal{1},
+		A:   Decimal{3},
+		B:   Decimal{2},
+		C:   Decimal{1},
 		Sub: func(a, b Decimal) Decimal { return Decimal{a.N - b.N} },
-		Add: func(a, b Decimal) Decimal { return Decimal{a.N + b.N}  },
+		Add: func(a, b Decimal) Decimal { return Decimal{a.N + b.N} },
 	}
 
 	output, err := expr.Run(program, env)
@@ -1358,21 +1358,6 @@ func TestExpr_fetch_from_func(t *testing.T) {
 	assert.Contains(t, err.Error(), "cannot fetch Value from func()")
 }
 
-func TestExpr_fetch_from_interface(t *testing.T) {
-	type FooBar struct {
-		Value string
-	}
-	foobar := &FooBar{"waldo"}
-	var foobarAny any = foobar
-	var foobarPtrAny any = &foobarAny
-
-	res, err := expr.Eval("foo.Value", map[string]any{
-		"foo": foobarPtrAny,
-	})
-	assert.NoError(t, err)
-	assert.Equal(t, "waldo", res)
-}
-
 func TestExpr_map_default_values(t *testing.T) {
 	env := map[string]any{
 		"foo": map[string]string{},
diff --git a/internal/deref/deref.go b/internal/deref/deref.go
new file mode 100644
index 000000000..acdc89811
--- /dev/null
+++ b/internal/deref/deref.go
@@ -0,0 +1,47 @@
+package deref
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func Deref(p any) any {
+	if p == nil {
+		return nil
+	}
+
+	v := reflect.ValueOf(p)
+
+	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
+		if v.IsNil() {
+			return nil
+		}
+		v = v.Elem()
+	}
+
+	if v.IsValid() {
+		return v.Interface()
+	}
+
+	panic(fmt.Sprintf("cannot dereference %v", p))
+}
+
+func Type(t reflect.Type) reflect.Type {
+	if t == nil {
+		return nil
+	}
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	return t
+}
+
+func Value(v reflect.Value) reflect.Value {
+	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
+		if v.IsNil() {
+			return v
+		}
+		v = v.Elem()
+	}
+	return v
+}
diff --git a/internal/deref/deref_test.go b/internal/deref/deref_test.go
new file mode 100644
index 000000000..554455f6d
--- /dev/null
+++ b/internal/deref/deref_test.go
@@ -0,0 +1,111 @@
+package deref_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/expr-lang/expr/internal/deref"
+)
+
+func TestDeref(t *testing.T) {
+	a := uint(42)
+	b := &a
+	c := &b
+	d := &c
+
+	got := deref.Deref(d)
+	assert.Equal(t, uint(42), got)
+}
+
+func TestDeref_mix_ptr_with_interface(t *testing.T) {
+	a := uint(42)
+	var b any = &a
+	var c any = &b
+	d := &c
+
+	got := deref.Deref(d)
+	assert.Equal(t, uint(42), got)
+}
+
+func TestDeref_nil(t *testing.T) {
+	var a *int
+	assert.Nil(t, deref.Deref(a))
+	assert.Nil(t, deref.Deref(nil))
+}
+
+func TestType(t *testing.T) {
+	a := uint(42)
+	b := &a
+	c := &b
+	d := &c
+
+	dt := deref.Type(reflect.TypeOf(d))
+	assert.Equal(t, reflect.Uint, dt.Kind())
+}
+
+func TestType_two_ptr_with_interface(t *testing.T) {
+	a := uint(42)
+	var b any = &a
+
+	dt := deref.Type(reflect.TypeOf(b))
+	assert.Equal(t, reflect.Uint, dt.Kind())
+
+}
+
+func TestType_three_ptr_with_interface(t *testing.T) {
+	a := uint(42)
+	var b any = &a
+	var c any = &b
+
+	dt := deref.Type(reflect.TypeOf(c))
+	assert.Equal(t, reflect.Interface, dt.Kind())
+}
+
+func TestType_nil(t *testing.T) {
+	assert.Nil(t, deref.Type(nil))
+}
+
+func TestValue(t *testing.T) {
+	a := uint(42)
+	b := &a
+	c := &b
+	d := &c
+
+	got := deref.Value(reflect.ValueOf(d))
+	assert.Equal(t, uint(42), got.Interface())
+}
+
+func TestValue_two_ptr_with_interface(t *testing.T) {
+	a := uint(42)
+	var b any = &a
+
+	got := deref.Value(reflect.ValueOf(b))
+	assert.Equal(t, uint(42), got.Interface())
+}
+
+func TestValue_three_ptr_with_interface(t *testing.T) {
+	a := uint(42)
+	var b any = &a
+	c := &b
+
+	got := deref.Value(reflect.ValueOf(c))
+	assert.Equal(t, uint(42), got.Interface())
+}
+
+func TestValue_nil(t *testing.T) {
+	got := deref.Value(reflect.ValueOf(nil))
+	assert.False(t, got.IsValid())
+}
+
+func TestValue_nil_in_chain(t *testing.T) {
+	var a any = nil
+	var b any = &a
+	c := &b
+
+	got := deref.Value(reflect.ValueOf(c))
+	assert.True(t, got.IsValid())
+	assert.True(t, got.IsNil())
+	assert.Nil(t, got.Interface())
+}
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 684794a01..2911e8e26 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/expr-lang/expr"
@@ -237,3 +238,18 @@ func TestDeref_сommutative(t *testing.T) {
 		})
 	}
 }
+
+func TestDeref_fetch_from_interface_mix_pointer(t *testing.T) {
+	type FooBar struct {
+		Value string
+	}
+	foobar := &FooBar{"waldo"}
+	var foobarAny any = foobar
+	var foobarPtrAny any = &foobarAny
+
+	res, err := expr.Eval("foo.Value", map[string]any{
+		"foo": foobarPtrAny,
+	})
+	assert.NoError(t, err)
+	assert.Equal(t, "waldo", res)
+}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 09c58bdf7..d54152117 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -6,20 +6,13 @@ import (
 	"fmt"
 	"math"
 	"reflect"
-)
 
-func deref(kind reflect.Kind, value reflect.Value) (reflect.Kind, reflect.Value) {
-	for kind == reflect.Ptr || kind == reflect.Interface {
-		value = value.Elem()
-		kind = value.Kind()
-	}
-	return kind, value
-}
+	"github.com/expr-lang/expr/internal/deref"
+)
 
 func Fetch(from, i any) any {
 	v := reflect.ValueOf(from)
-	kind := v.Kind()
-	if kind == reflect.Invalid {
+	if v.Kind() == reflect.Invalid {
 		panic(fmt.Sprintf("cannot fetch %v from %T", i, from))
 	}
 
@@ -37,11 +30,9 @@ func Fetch(from, i any) any {
 	// a value, when they are accessed through a pointer we don't want to
 	// copy them to a value.
 	// De-reference everything if necessary (interface and pointers)
-	kind, v = deref(kind, v)
+	v = deref.Value(v)
 
-	// TODO: We can create separate opcodes for each of the cases below to make
-	// the little bit faster.
-	switch kind {
+	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.String:
 		index := ToInt(i)
 		if index < 0 {
@@ -144,27 +135,6 @@ func FetchMethod(from any, method *Method) any {
 	panic(fmt.Sprintf("cannot fetch %v from %T", method.Name, from))
 }
 
-func Deref(i any) any {
-	if i == nil {
-		return nil
-	}
-
-	v := reflect.ValueOf(i)
-
-	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
-		if v.IsNil() {
-			return nil
-		}
-		v = v.Elem()
-	}
-
-	if v.IsValid() {
-		return v.Interface()
-	}
-
-	panic(fmt.Sprintf("cannot dereference %v", i))
-}
-
 func Slice(array, from, to any) any {
 	v := reflect.ValueOf(array)
 
diff --git a/vm/vm.go b/vm/vm.go
index 56d5fc2ee..1e85893b0 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/internal/deref"
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
@@ -436,7 +437,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 
 		case OpDeref:
 			a := vm.pop()
-			vm.push(runtime.Deref(a))
+			vm.push(deref.Deref(a))
 
 		case OpIncrementIndex:
 			vm.scope().Index++

From 694aab2ba48069d54c74f811f3caf7f3fa1eac41 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 16 Feb 2024 23:01:03 +0100
Subject: [PATCH 265/506] Update real_world example

---
 .gitignore                            |   1 +
 test/real_world/README.md             | 119 --------------------------
 test/real_world/real_docs/generate.go |  14 ---
 test/real_world/real_world.go         | 116 -------------------------
 4 files changed, 1 insertion(+), 249 deletions(-)
 delete mode 100644 test/real_world/README.md
 delete mode 100644 test/real_world/real_docs/generate.go
 delete mode 100644 test/real_world/real_world.go

diff --git a/.gitignore b/.gitignore
index da1a8182f..9d3410bdf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,4 @@
 *.html
 custom_tests.json
 pro/
+test/avs/
diff --git a/test/real_world/README.md b/test/real_world/README.md
deleted file mode 100644
index ba79e808d..000000000
--- a/test/real_world/README.md
+++ /dev/null
@@ -1,119 +0,0 @@
-### Variables
-| Name | Type |
-|------|------|
-| AppVersion | `string` |
-| CleanMarker | `string` |
-| CountryCode | `string` |
-| CurrencyCode | `string` |
-| DestinationCountry | `string` |
-| Features | [UserAgentFeatures](#UserAgentFeatures) |
-| GateID | `int` |
-| InitializedAt | `int` |
-| IsAffiliate | `bool` |
-| IsDesktop | `bool` |
-| IsMobile | `bool` |
-| IsOpenJaw | `bool` |
-| KnowEnglish | `bool` |
-| Locale | `string` |
-| Marker | `string` |
-| Market | `string` |
-| OriginCountry | `string` |
-| Os | `string` |
-| OsVersion | `string` |
-| Passengers | [Passengers](#Passengers) |
-| Random | `float` |
-| ReferrerHost | `string` |
-| SearchDepth | `int` |
-| SearchParamsEnv | [SearchParamsEnv](#SearchParamsEnv) |
-| Segments | array([RouteSegment](#RouteSegment)) |
-| TravelPayoutsAPI | `bool` |
-| TripClass | `string` |
-| UserAgentDevice | `string` |
-| UserAgentType | `string` |
-| UserIP | `string` |
-| false | `bool` |
-| true | `bool` |
-
-### Functions
-| Name | Return type |
-|------|-------------|
-| all(array(`any`), `func`) | `bool` |
-| any(array(`any`), `func`) | `bool` |
-| count(array(`any`), `func`) | `int` |
-| filter(array(`any`), `func`) | array(`any`) |
-| len(array(`any`)) | `int` |
-| map(array(`any`), `func`) | array(`any`) |
-| none(array(`any`), `func`) | `bool` |
-| one(array(`any`), `func`) | `bool` |
-
-### Types
-#### DirectFlightsDays
-| Field | Type |
-|---|---|
-| Days | `string` |
-| Start | `string` |
-
-#### Passengers
-| Field | Type |
-|---|---|
-| Adults | `int` |
-| Children | `int` |
-| Infants | `int` |
-
-#### RouteSegment
-| Field | Type |
-|---|---|
-| Date | `string` |
-| Destination | `string` |
-| DestinationCountry | `string` |
-| DestinationName | `string` |
-| DirectFlightsDays | [DirectFlightsDays](#DirectFlightsDays) |
-| Origin | `string` |
-| OriginCountry | `string` |
-| OriginName | `string` |
-| TranslatedDestination | `string` |
-| TranslatedOrigin | `string` |
-| UserDestination | `string` |
-| UserOrigin | `string` |
-
-#### SearchParamsEnv
-| Field | Type |
-|---|---|
-| AppVersion | `string` |
-| CleanMarker | `string` |
-| CountryCode | `string` |
-| CurrencyCode | `string` |
-| DestinationCountry | `string` |
-| Features | [UserAgentFeatures](#UserAgentFeatures) |
-| GateID | `int` |
-| InitializedAt | `int` |
-| IsAffiliate | `bool` |
-| IsDesktop | `bool` |
-| IsMobile | `bool` |
-| IsOpenJaw | `bool` |
-| KnowEnglish | `bool` |
-| Locale | `string` |
-| Marker | `string` |
-| Market | `string` |
-| OriginCountry | `string` |
-| Os | `string` |
-| OsVersion | `string` |
-| Passengers | [Passengers](#Passengers) |
-| Random | `float` |
-| ReferrerHost | `string` |
-| SearchDepth | `int` |
-| Segments | array([RouteSegment](#RouteSegment)) |
-| TravelPayoutsAPI | `bool` |
-| TripClass | `string` |
-| UserAgentDevice | `string` |
-| UserAgentType | `string` |
-| UserIP | `string` |
-
-#### UserAgentFeatures
-| Field | Type |
-|---|---|
-| Assisted | `bool` |
-| TopPlacement | `bool` |
-| TourTickets | `bool` |
-
-
diff --git a/test/real_world/real_docs/generate.go b/test/real_world/real_docs/generate.go
deleted file mode 100644
index 51030e2c5..000000000
--- a/test/real_world/real_docs/generate.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"github.com/expr-lang/expr/docgen"
-	"github.com/expr-lang/expr/test/real_world"
-)
-
-func main() {
-	doc := docgen.CreateDoc(real_world.NewEnv())
-
-	fmt.Println(doc.Markdown())
-}
diff --git a/test/real_world/real_world.go b/test/real_world/real_world.go
deleted file mode 100644
index 445e0a4ce..000000000
--- a/test/real_world/real_world.go
+++ /dev/null
@@ -1,116 +0,0 @@
-package real_world
-
-//go:generate sh -c "go run ./real_docs/generate.go > README.md"
-
-type DirectFlightsDays struct {
-	Start string
-	Days  string
-}
-
-type RouteSegment struct {
-	Origin                string
-	OriginName            string
-	Destination           string
-	DestinationName       string
-	Date                  string
-	OriginCountry         string
-	DestinationCountry    string
-	TranslatedOrigin      string
-	TranslatedDestination string
-	UserOrigin            string
-	UserDestination       string
-	DirectFlightsDays     *DirectFlightsDays
-}
-
-type Passengers struct {
-	Adults   uint32
-	Children uint32
-	Infants  uint32
-}
-
-type UserAgentFeatures struct {
-	Assisted     bool
-	TopPlacement bool
-	TourTickets  bool
-}
-
-type SearchParamsEnv struct {
-	Segments           []*RouteSegment
-	OriginCountry      string
-	DestinationCountry string
-	SearchDepth        int
-	Passengers         *Passengers
-	TripClass          string
-	UserIP             string
-	KnowEnglish        bool
-	Market             string
-	Marker             string
-	CleanMarker        string
-	Locale             string
-	ReferrerHost       string
-	CountryCode        string
-	CurrencyCode       string
-	IsOpenJaw          bool
-	Os                 string
-	OsVersion          string
-	AppVersion         string
-	IsAffiliate        bool
-	InitializedAt      int64
-	Random             float32
-	TravelPayoutsAPI   bool
-	Features           *UserAgentFeatures
-	GateID             int32
-	UserAgentDevice    string
-	UserAgentType      string
-	IsDesktop          bool
-	IsMobile           bool
-}
-
-type Env struct {
-	SearchParamsEnv
-}
-
-func NewEnv() Env {
-	return Env{
-		SearchParamsEnv: SearchParamsEnv{
-			Segments: []*RouteSegment{
-				{
-					Origin:      "VOG",
-					Destination: "SHJ",
-				},
-				{
-					Origin:      "SHJ",
-					Destination: "VOG",
-				},
-			},
-			OriginCountry:      "RU",
-			DestinationCountry: "RU",
-			SearchDepth:        44,
-			Passengers:         &Passengers{1, 0, 0},
-			TripClass:          "Y",
-			UserIP:             "::1",
-			KnowEnglish:        true,
-			Market:             "ru",
-			Marker:             "123456.direct",
-			CleanMarker:        "123456",
-			Locale:             "ru",
-			ReferrerHost:       "www.aviasales.ru",
-			CountryCode:        "",
-			CurrencyCode:       "usd",
-			IsOpenJaw:          false,
-			Os:                 "",
-			OsVersion:          "",
-			AppVersion:         "",
-			IsAffiliate:        true,
-			InitializedAt:      1570788719,
-			Random:             0.13497187,
-			TravelPayoutsAPI:   false,
-			Features:           &UserAgentFeatures{},
-			GateID:             421,
-			UserAgentDevice:    "DESKTOP",
-			UserAgentType:      "WEB",
-			IsDesktop:          true,
-			IsMobile:           false,
-		},
-	}
-}

From c330a39253d4ba18f04c1123910cc50bbaafb3e0 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 16 Feb 2024 23:32:07 +0100
Subject: [PATCH 266/506] Sort func_types

---
 vm/func_types/main.go       |  34 ++---
 vm/func_types[generated].go | 266 +++++++++++++++++++-----------------
 2 files changed, 155 insertions(+), 145 deletions(-)

diff --git a/vm/func_types/main.go b/vm/func_types/main.go
index 286a1f053..fe9802aae 100644
--- a/vm/func_types/main.go
+++ b/vm/func_types/main.go
@@ -17,14 +17,14 @@ var types = []any{
 	new(func() Month),
 	new(func() Time),
 	new(func() Weekday),
-	new(func() []byte),
 	new(func() []any),
+	new(func() []byte),
+	new(func() any),
 	new(func() bool),
 	new(func() byte),
 	new(func() float64),
 	new(func() int),
 	new(func() int64),
-	new(func() any),
 	new(func() map[string]any),
 	new(func() rune),
 	new(func() string),
@@ -34,8 +34,22 @@ var types = []any{
 	new(func(Duration) Time),
 	new(func(Time) Duration),
 	new(func(Time) bool),
+	new(func([]any) []any),
+	new(func([]any) any),
+	new(func([]any) map[string]any),
 	new(func([]any, string) string),
 	new(func([]string, string) string),
+	new(func(any) []any),
+	new(func(any) any),
+	new(func(any) bool),
+	new(func(any) float64),
+	new(func(any) int),
+	new(func(any) map[string]any),
+	new(func(any) string),
+	new(func(any, any) []any),
+	new(func(any, any) any),
+	new(func(any, any) bool),
+	new(func(any, any) string),
 	new(func(bool) bool),
 	new(func(bool) float64),
 	new(func(bool) int),
@@ -50,9 +64,11 @@ var types = []any{
 	new(func(int) string),
 	new(func(int, int) int),
 	new(func(int, int) string),
+	new(func(int32) float64),
 	new(func(int64) Time),
 	new(func(string) []string),
 	new(func(string) bool),
+	new(func(string) bool),
 	new(func(string) float64),
 	new(func(string) int),
 	new(func(string) string),
@@ -61,20 +77,6 @@ var types = []any{
 	new(func(string, rune) int),
 	new(func(string, string) bool),
 	new(func(string, string) string),
-	new(func(any) bool),
-	new(func(any) float64),
-	new(func(any) int),
-	new(func(any) string),
-	new(func(any) any),
-	new(func(any) []any),
-	new(func(any) map[string]any),
-	new(func([]any) any),
-	new(func([]any) []any),
-	new(func([]any) map[string]any),
-	new(func(any, any) bool),
-	new(func(any, any) string),
-	new(func(any, any) any),
-	new(func(any, any) []any),
 }
 
 func main() {
diff --git a/vm/func_types[generated].go b/vm/func_types[generated].go
index 1375f22f2..7cb9c8c60 100644
--- a/vm/func_types[generated].go
+++ b/vm/func_types[generated].go
@@ -12,14 +12,14 @@ var FuncTypes = []any{
 	2:  new(func() time.Month),
 	3:  new(func() time.Time),
 	4:  new(func() time.Weekday),
-	5:  new(func() []uint8),
-	6:  new(func() []interface{}),
-	7:  new(func() bool),
-	8:  new(func() uint8),
-	9:  new(func() float64),
-	10: new(func() int),
-	11: new(func() int64),
-	12: new(func() interface{}),
+	5:  new(func() []interface{}),
+	6:  new(func() []uint8),
+	7:  new(func() interface{}),
+	8:  new(func() bool),
+	9:  new(func() uint8),
+	10: new(func() float64),
+	11: new(func() int),
+	12: new(func() int64),
 	13: new(func() map[string]interface{}),
 	14: new(func() int32),
 	15: new(func() string),
@@ -29,47 +29,49 @@ var FuncTypes = []any{
 	19: new(func(time.Duration) time.Time),
 	20: new(func(time.Time) time.Duration),
 	21: new(func(time.Time) bool),
-	22: new(func([]interface{}, string) string),
-	23: new(func([]string, string) string),
-	24: new(func(bool) bool),
-	25: new(func(bool) float64),
-	26: new(func(bool) int),
-	27: new(func(bool) string),
-	28: new(func(float64) bool),
-	29: new(func(float64) float64),
-	30: new(func(float64) int),
-	31: new(func(float64) string),
-	32: new(func(int) bool),
-	33: new(func(int) float64),
-	34: new(func(int) int),
-	35: new(func(int) string),
-	36: new(func(int, int) int),
-	37: new(func(int, int) string),
-	38: new(func(int64) time.Time),
-	39: new(func(string) []string),
-	40: new(func(string) bool),
-	41: new(func(string) float64),
-	42: new(func(string) int),
-	43: new(func(string) string),
-	44: new(func(string, uint8) int),
-	45: new(func(string, int) int),
-	46: new(func(string, int32) int),
-	47: new(func(string, string) bool),
-	48: new(func(string, string) string),
-	49: new(func(interface{}) bool),
-	50: new(func(interface{}) float64),
-	51: new(func(interface{}) int),
-	52: new(func(interface{}) string),
-	53: new(func(interface{}) interface{}),
-	54: new(func(interface{}) []interface{}),
-	55: new(func(interface{}) map[string]interface{}),
-	56: new(func([]interface{}) interface{}),
-	57: new(func([]interface{}) []interface{}),
-	58: new(func([]interface{}) map[string]interface{}),
-	59: new(func(interface{}, interface{}) bool),
-	60: new(func(interface{}, interface{}) string),
-	61: new(func(interface{}, interface{}) interface{}),
-	62: new(func(interface{}, interface{}) []interface{}),
+	22: new(func([]interface{}) []interface{}),
+	23: new(func([]interface{}) interface{}),
+	24: new(func([]interface{}) map[string]interface{}),
+	25: new(func([]interface{}, string) string),
+	26: new(func([]string, string) string),
+	27: new(func(interface{}) []interface{}),
+	28: new(func(interface{}) interface{}),
+	29: new(func(interface{}) bool),
+	30: new(func(interface{}) float64),
+	31: new(func(interface{}) int),
+	32: new(func(interface{}) map[string]interface{}),
+	33: new(func(interface{}) string),
+	34: new(func(interface{}, interface{}) []interface{}),
+	35: new(func(interface{}, interface{}) interface{}),
+	36: new(func(interface{}, interface{}) bool),
+	37: new(func(interface{}, interface{}) string),
+	38: new(func(bool) bool),
+	39: new(func(bool) float64),
+	40: new(func(bool) int),
+	41: new(func(bool) string),
+	42: new(func(float64) bool),
+	43: new(func(float64) float64),
+	44: new(func(float64) int),
+	45: new(func(float64) string),
+	46: new(func(int) bool),
+	47: new(func(int) float64),
+	48: new(func(int) int),
+	49: new(func(int) string),
+	50: new(func(int, int) int),
+	51: new(func(int, int) string),
+	52: new(func(int32) float64),
+	53: new(func(int64) time.Time),
+	54: new(func(string) []string),
+	55: new(func(string) bool),
+	56: new(func(string) bool),
+	57: new(func(string) float64),
+	58: new(func(string) int),
+	59: new(func(string) string),
+	60: new(func(string, uint8) int),
+	61: new(func(string, int) int),
+	62: new(func(string, int32) int),
+	63: new(func(string, string) bool),
+	64: new(func(string, string) string),
 }
 
 func (vm *VM) call(fn any, kind int) any {
@@ -83,21 +85,21 @@ func (vm *VM) call(fn any, kind int) any {
 	case 4:
 		return fn.(func() time.Weekday)()
 	case 5:
-		return fn.(func() []uint8)()
-	case 6:
 		return fn.(func() []interface{})()
+	case 6:
+		return fn.(func() []uint8)()
 	case 7:
-		return fn.(func() bool)()
+		return fn.(func() interface{})()
 	case 8:
-		return fn.(func() uint8)()
+		return fn.(func() bool)()
 	case 9:
-		return fn.(func() float64)()
+		return fn.(func() uint8)()
 	case 10:
-		return fn.(func() int)()
+		return fn.(func() float64)()
 	case 11:
-		return fn.(func() int64)()
+		return fn.(func() int)()
 	case 12:
-		return fn.(func() interface{})()
+		return fn.(func() int64)()
 	case 13:
 		return fn.(func() map[string]interface{})()
 	case 14:
@@ -121,141 +123,147 @@ func (vm *VM) call(fn any, kind int) any {
 		arg1 := vm.pop().(time.Time)
 		return fn.(func(time.Time) bool)(arg1)
 	case 22:
+		arg1 := vm.pop().([]interface{})
+		return fn.(func([]interface{}) []interface{})(arg1)
+	case 23:
+		arg1 := vm.pop().([]interface{})
+		return fn.(func([]interface{}) interface{})(arg1)
+	case 24:
+		arg1 := vm.pop().([]interface{})
+		return fn.(func([]interface{}) map[string]interface{})(arg1)
+	case 25:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().([]interface{})
 		return fn.(func([]interface{}, string) string)(arg1, arg2)
-	case 23:
+	case 26:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().([]string)
 		return fn.(func([]string, string) string)(arg1, arg2)
-	case 24:
+	case 27:
+		arg1 := vm.pop()
+		return fn.(func(interface{}) []interface{})(arg1)
+	case 28:
+		arg1 := vm.pop()
+		return fn.(func(interface{}) interface{})(arg1)
+	case 29:
+		arg1 := vm.pop()
+		return fn.(func(interface{}) bool)(arg1)
+	case 30:
+		arg1 := vm.pop()
+		return fn.(func(interface{}) float64)(arg1)
+	case 31:
+		arg1 := vm.pop()
+		return fn.(func(interface{}) int)(arg1)
+	case 32:
+		arg1 := vm.pop()
+		return fn.(func(interface{}) map[string]interface{})(arg1)
+	case 33:
+		arg1 := vm.pop()
+		return fn.(func(interface{}) string)(arg1)
+	case 34:
+		arg2 := vm.pop()
+		arg1 := vm.pop()
+		return fn.(func(interface{}, interface{}) []interface{})(arg1, arg2)
+	case 35:
+		arg2 := vm.pop()
+		arg1 := vm.pop()
+		return fn.(func(interface{}, interface{}) interface{})(arg1, arg2)
+	case 36:
+		arg2 := vm.pop()
+		arg1 := vm.pop()
+		return fn.(func(interface{}, interface{}) bool)(arg1, arg2)
+	case 37:
+		arg2 := vm.pop()
+		arg1 := vm.pop()
+		return fn.(func(interface{}, interface{}) string)(arg1, arg2)
+	case 38:
 		arg1 := vm.pop().(bool)
 		return fn.(func(bool) bool)(arg1)
-	case 25:
+	case 39:
 		arg1 := vm.pop().(bool)
 		return fn.(func(bool) float64)(arg1)
-	case 26:
+	case 40:
 		arg1 := vm.pop().(bool)
 		return fn.(func(bool) int)(arg1)
-	case 27:
+	case 41:
 		arg1 := vm.pop().(bool)
 		return fn.(func(bool) string)(arg1)
-	case 28:
+	case 42:
 		arg1 := vm.pop().(float64)
 		return fn.(func(float64) bool)(arg1)
-	case 29:
+	case 43:
 		arg1 := vm.pop().(float64)
 		return fn.(func(float64) float64)(arg1)
-	case 30:
+	case 44:
 		arg1 := vm.pop().(float64)
 		return fn.(func(float64) int)(arg1)
-	case 31:
+	case 45:
 		arg1 := vm.pop().(float64)
 		return fn.(func(float64) string)(arg1)
-	case 32:
+	case 46:
 		arg1 := vm.pop().(int)
 		return fn.(func(int) bool)(arg1)
-	case 33:
+	case 47:
 		arg1 := vm.pop().(int)
 		return fn.(func(int) float64)(arg1)
-	case 34:
+	case 48:
 		arg1 := vm.pop().(int)
 		return fn.(func(int) int)(arg1)
-	case 35:
+	case 49:
 		arg1 := vm.pop().(int)
 		return fn.(func(int) string)(arg1)
-	case 36:
+	case 50:
 		arg2 := vm.pop().(int)
 		arg1 := vm.pop().(int)
 		return fn.(func(int, int) int)(arg1, arg2)
-	case 37:
+	case 51:
 		arg2 := vm.pop().(int)
 		arg1 := vm.pop().(int)
 		return fn.(func(int, int) string)(arg1, arg2)
-	case 38:
+	case 52:
+		arg1 := vm.pop().(int32)
+		return fn.(func(int32) float64)(arg1)
+	case 53:
 		arg1 := vm.pop().(int64)
 		return fn.(func(int64) time.Time)(arg1)
-	case 39:
+	case 54:
 		arg1 := vm.pop().(string)
 		return fn.(func(string) []string)(arg1)
-	case 40:
+	case 55:
 		arg1 := vm.pop().(string)
 		return fn.(func(string) bool)(arg1)
-	case 41:
+	case 56:
+		arg1 := vm.pop().(string)
+		return fn.(func(string) bool)(arg1)
+	case 57:
 		arg1 := vm.pop().(string)
 		return fn.(func(string) float64)(arg1)
-	case 42:
+	case 58:
 		arg1 := vm.pop().(string)
 		return fn.(func(string) int)(arg1)
-	case 43:
+	case 59:
 		arg1 := vm.pop().(string)
 		return fn.(func(string) string)(arg1)
-	case 44:
+	case 60:
 		arg2 := vm.pop().(uint8)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, uint8) int)(arg1, arg2)
-	case 45:
+	case 61:
 		arg2 := vm.pop().(int)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, int) int)(arg1, arg2)
-	case 46:
+	case 62:
 		arg2 := vm.pop().(int32)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, int32) int)(arg1, arg2)
-	case 47:
+	case 63:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, string) bool)(arg1, arg2)
-	case 48:
+	case 64:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, string) string)(arg1, arg2)
-	case 49:
-		arg1 := vm.pop()
-		return fn.(func(interface{}) bool)(arg1)
-	case 50:
-		arg1 := vm.pop()
-		return fn.(func(interface{}) float64)(arg1)
-	case 51:
-		arg1 := vm.pop()
-		return fn.(func(interface{}) int)(arg1)
-	case 52:
-		arg1 := vm.pop()
-		return fn.(func(interface{}) string)(arg1)
-	case 53:
-		arg1 := vm.pop()
-		return fn.(func(interface{}) interface{})(arg1)
-	case 54:
-		arg1 := vm.pop()
-		return fn.(func(interface{}) []interface{})(arg1)
-	case 55:
-		arg1 := vm.pop()
-		return fn.(func(interface{}) map[string]interface{})(arg1)
-	case 56:
-		arg1 := vm.pop().([]interface{})
-		return fn.(func([]interface{}) interface{})(arg1)
-	case 57:
-		arg1 := vm.pop().([]interface{})
-		return fn.(func([]interface{}) []interface{})(arg1)
-	case 58:
-		arg1 := vm.pop().([]interface{})
-		return fn.(func([]interface{}) map[string]interface{})(arg1)
-	case 59:
-		arg2 := vm.pop()
-		arg1 := vm.pop()
-		return fn.(func(interface{}, interface{}) bool)(arg1, arg2)
-	case 60:
-		arg2 := vm.pop()
-		arg1 := vm.pop()
-		return fn.(func(interface{}, interface{}) string)(arg1, arg2)
-	case 61:
-		arg2 := vm.pop()
-		arg1 := vm.pop()
-		return fn.(func(interface{}, interface{}) interface{})(arg1, arg2)
-	case 62:
-		arg2 := vm.pop()
-		arg1 := vm.pop()
-		return fn.(func(interface{}, interface{}) []interface{})(arg1, arg2)
 
 	}
 	panic(fmt.Sprintf("unknown function kind (%v)", kind))

From ed89647e7829c81a73cc75f2d8ed39e3f833b51d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 16 Feb 2024 23:40:23 +0100
Subject: [PATCH 267/506] Add more func_types

---
 vm/func_types/main.go       |  28 +++-
 vm/func_types[generated].go | 318 ++++++++++++++++++++++++------------
 2 files changed, 236 insertions(+), 110 deletions(-)

diff --git a/vm/func_types/main.go b/vm/func_types/main.go
index fe9802aae..cb4debd3a 100644
--- a/vm/func_types/main.go
+++ b/vm/func_types/main.go
@@ -22,14 +22,21 @@ var types = []any{
 	new(func() any),
 	new(func() bool),
 	new(func() byte),
+	new(func() float32),
 	new(func() float64),
 	new(func() int),
+	new(func() int16),
+	new(func() int32),
 	new(func() int64),
+	new(func() int8),
 	new(func() map[string]any),
 	new(func() rune),
 	new(func() string),
 	new(func() uint),
+	new(func() uint16),
+	new(func() uint32),
 	new(func() uint64),
+	new(func() uint8),
 	new(func(Duration) Duration),
 	new(func(Duration) Time),
 	new(func(Time) Duration),
@@ -38,6 +45,7 @@ var types = []any{
 	new(func([]any) any),
 	new(func([]any) map[string]any),
 	new(func([]any, string) string),
+	new(func([]byte) string),
 	new(func([]string, string) string),
 	new(func(any) []any),
 	new(func(any) any),
@@ -54,21 +62,31 @@ var types = []any{
 	new(func(bool) float64),
 	new(func(bool) int),
 	new(func(bool) string),
+	new(func(bool, bool) bool),
+	new(func(float32) float64),
 	new(func(float64) bool),
+	new(func(float64) float32),
 	new(func(float64) float64),
 	new(func(float64) int),
 	new(func(float64) string),
+	new(func(float64, float64) bool),
 	new(func(int) bool),
 	new(func(int) float64),
 	new(func(int) int),
 	new(func(int) string),
+	new(func(int, int) bool),
 	new(func(int, int) int),
 	new(func(int, int) string),
+	new(func(int16) int32),
 	new(func(int32) float64),
+	new(func(int32) int),
+	new(func(int32) int64),
 	new(func(int64) Time),
+	new(func(int8) int),
+	new(func(int8) int16),
+	new(func(string) []byte),
 	new(func(string) []string),
 	new(func(string) bool),
-	new(func(string) bool),
 	new(func(string) float64),
 	new(func(string) int),
 	new(func(string) string),
@@ -77,6 +95,14 @@ var types = []any{
 	new(func(string, rune) int),
 	new(func(string, string) bool),
 	new(func(string, string) string),
+	new(func(uint) float64),
+	new(func(uint) int),
+	new(func(uint) uint),
+	new(func(uint16) uint),
+	new(func(uint32) uint64),
+	new(func(uint64) float64),
+	new(func(uint64) int64),
+	new(func(uint8) byte),
 }
 
 func main() {
diff --git a/vm/func_types[generated].go b/vm/func_types[generated].go
index 7cb9c8c60..610b41520 100644
--- a/vm/func_types[generated].go
+++ b/vm/func_types[generated].go
@@ -17,61 +17,87 @@ var FuncTypes = []any{
 	7:  new(func() interface{}),
 	8:  new(func() bool),
 	9:  new(func() uint8),
-	10: new(func() float64),
-	11: new(func() int),
-	12: new(func() int64),
-	13: new(func() map[string]interface{}),
+	10: new(func() float32),
+	11: new(func() float64),
+	12: new(func() int),
+	13: new(func() int16),
 	14: new(func() int32),
-	15: new(func() string),
-	16: new(func() uint),
-	17: new(func() uint64),
-	18: new(func(time.Duration) time.Duration),
-	19: new(func(time.Duration) time.Time),
-	20: new(func(time.Time) time.Duration),
-	21: new(func(time.Time) bool),
-	22: new(func([]interface{}) []interface{}),
-	23: new(func([]interface{}) interface{}),
-	24: new(func([]interface{}) map[string]interface{}),
-	25: new(func([]interface{}, string) string),
-	26: new(func([]string, string) string),
-	27: new(func(interface{}) []interface{}),
-	28: new(func(interface{}) interface{}),
-	29: new(func(interface{}) bool),
-	30: new(func(interface{}) float64),
-	31: new(func(interface{}) int),
-	32: new(func(interface{}) map[string]interface{}),
-	33: new(func(interface{}) string),
-	34: new(func(interface{}, interface{}) []interface{}),
-	35: new(func(interface{}, interface{}) interface{}),
-	36: new(func(interface{}, interface{}) bool),
-	37: new(func(interface{}, interface{}) string),
-	38: new(func(bool) bool),
-	39: new(func(bool) float64),
-	40: new(func(bool) int),
-	41: new(func(bool) string),
-	42: new(func(float64) bool),
-	43: new(func(float64) float64),
-	44: new(func(float64) int),
-	45: new(func(float64) string),
-	46: new(func(int) bool),
-	47: new(func(int) float64),
-	48: new(func(int) int),
-	49: new(func(int) string),
-	50: new(func(int, int) int),
-	51: new(func(int, int) string),
-	52: new(func(int32) float64),
-	53: new(func(int64) time.Time),
-	54: new(func(string) []string),
-	55: new(func(string) bool),
-	56: new(func(string) bool),
-	57: new(func(string) float64),
-	58: new(func(string) int),
-	59: new(func(string) string),
-	60: new(func(string, uint8) int),
-	61: new(func(string, int) int),
-	62: new(func(string, int32) int),
-	63: new(func(string, string) bool),
-	64: new(func(string, string) string),
+	15: new(func() int64),
+	16: new(func() int8),
+	17: new(func() map[string]interface{}),
+	18: new(func() int32),
+	19: new(func() string),
+	20: new(func() uint),
+	21: new(func() uint16),
+	22: new(func() uint32),
+	23: new(func() uint64),
+	24: new(func() uint8),
+	25: new(func(time.Duration) time.Duration),
+	26: new(func(time.Duration) time.Time),
+	27: new(func(time.Time) time.Duration),
+	28: new(func(time.Time) bool),
+	29: new(func([]interface{}) []interface{}),
+	30: new(func([]interface{}) interface{}),
+	31: new(func([]interface{}) map[string]interface{}),
+	32: new(func([]interface{}, string) string),
+	33: new(func([]uint8) string),
+	34: new(func([]string, string) string),
+	35: new(func(interface{}) []interface{}),
+	36: new(func(interface{}) interface{}),
+	37: new(func(interface{}) bool),
+	38: new(func(interface{}) float64),
+	39: new(func(interface{}) int),
+	40: new(func(interface{}) map[string]interface{}),
+	41: new(func(interface{}) string),
+	42: new(func(interface{}, interface{}) []interface{}),
+	43: new(func(interface{}, interface{}) interface{}),
+	44: new(func(interface{}, interface{}) bool),
+	45: new(func(interface{}, interface{}) string),
+	46: new(func(bool) bool),
+	47: new(func(bool) float64),
+	48: new(func(bool) int),
+	49: new(func(bool) string),
+	50: new(func(bool, bool) bool),
+	51: new(func(float32) float64),
+	52: new(func(float64) bool),
+	53: new(func(float64) float32),
+	54: new(func(float64) float64),
+	55: new(func(float64) int),
+	56: new(func(float64) string),
+	57: new(func(float64, float64) bool),
+	58: new(func(int) bool),
+	59: new(func(int) float64),
+	60: new(func(int) int),
+	61: new(func(int) string),
+	62: new(func(int, int) bool),
+	63: new(func(int, int) int),
+	64: new(func(int, int) string),
+	65: new(func(int16) int32),
+	66: new(func(int32) float64),
+	67: new(func(int32) int),
+	68: new(func(int32) int64),
+	69: new(func(int64) time.Time),
+	70: new(func(int8) int),
+	71: new(func(int8) int16),
+	72: new(func(string) []uint8),
+	73: new(func(string) []string),
+	74: new(func(string) bool),
+	75: new(func(string) float64),
+	76: new(func(string) int),
+	77: new(func(string) string),
+	78: new(func(string, uint8) int),
+	79: new(func(string, int) int),
+	80: new(func(string, int32) int),
+	81: new(func(string, string) bool),
+	82: new(func(string, string) string),
+	83: new(func(uint) float64),
+	84: new(func(uint) int),
+	85: new(func(uint) uint),
+	86: new(func(uint16) uint),
+	87: new(func(uint32) uint64),
+	88: new(func(uint64) float64),
+	89: new(func(uint64) int64),
+	90: new(func(uint8) uint8),
 }
 
 func (vm *VM) call(fn any, kind int) any {
@@ -95,175 +121,249 @@ func (vm *VM) call(fn any, kind int) any {
 	case 9:
 		return fn.(func() uint8)()
 	case 10:
-		return fn.(func() float64)()
+		return fn.(func() float32)()
 	case 11:
-		return fn.(func() int)()
+		return fn.(func() float64)()
 	case 12:
-		return fn.(func() int64)()
+		return fn.(func() int)()
 	case 13:
-		return fn.(func() map[string]interface{})()
+		return fn.(func() int16)()
 	case 14:
 		return fn.(func() int32)()
 	case 15:
-		return fn.(func() string)()
+		return fn.(func() int64)()
 	case 16:
-		return fn.(func() uint)()
+		return fn.(func() int8)()
 	case 17:
-		return fn.(func() uint64)()
+		return fn.(func() map[string]interface{})()
 	case 18:
+		return fn.(func() int32)()
+	case 19:
+		return fn.(func() string)()
+	case 20:
+		return fn.(func() uint)()
+	case 21:
+		return fn.(func() uint16)()
+	case 22:
+		return fn.(func() uint32)()
+	case 23:
+		return fn.(func() uint64)()
+	case 24:
+		return fn.(func() uint8)()
+	case 25:
 		arg1 := vm.pop().(time.Duration)
 		return fn.(func(time.Duration) time.Duration)(arg1)
-	case 19:
+	case 26:
 		arg1 := vm.pop().(time.Duration)
 		return fn.(func(time.Duration) time.Time)(arg1)
-	case 20:
+	case 27:
 		arg1 := vm.pop().(time.Time)
 		return fn.(func(time.Time) time.Duration)(arg1)
-	case 21:
+	case 28:
 		arg1 := vm.pop().(time.Time)
 		return fn.(func(time.Time) bool)(arg1)
-	case 22:
+	case 29:
 		arg1 := vm.pop().([]interface{})
 		return fn.(func([]interface{}) []interface{})(arg1)
-	case 23:
+	case 30:
 		arg1 := vm.pop().([]interface{})
 		return fn.(func([]interface{}) interface{})(arg1)
-	case 24:
+	case 31:
 		arg1 := vm.pop().([]interface{})
 		return fn.(func([]interface{}) map[string]interface{})(arg1)
-	case 25:
+	case 32:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().([]interface{})
 		return fn.(func([]interface{}, string) string)(arg1, arg2)
-	case 26:
+	case 33:
+		arg1 := vm.pop().([]uint8)
+		return fn.(func([]uint8) string)(arg1)
+	case 34:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().([]string)
 		return fn.(func([]string, string) string)(arg1, arg2)
-	case 27:
+	case 35:
 		arg1 := vm.pop()
 		return fn.(func(interface{}) []interface{})(arg1)
-	case 28:
+	case 36:
 		arg1 := vm.pop()
 		return fn.(func(interface{}) interface{})(arg1)
-	case 29:
+	case 37:
 		arg1 := vm.pop()
 		return fn.(func(interface{}) bool)(arg1)
-	case 30:
+	case 38:
 		arg1 := vm.pop()
 		return fn.(func(interface{}) float64)(arg1)
-	case 31:
+	case 39:
 		arg1 := vm.pop()
 		return fn.(func(interface{}) int)(arg1)
-	case 32:
+	case 40:
 		arg1 := vm.pop()
 		return fn.(func(interface{}) map[string]interface{})(arg1)
-	case 33:
+	case 41:
 		arg1 := vm.pop()
 		return fn.(func(interface{}) string)(arg1)
-	case 34:
+	case 42:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
 		return fn.(func(interface{}, interface{}) []interface{})(arg1, arg2)
-	case 35:
+	case 43:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
 		return fn.(func(interface{}, interface{}) interface{})(arg1, arg2)
-	case 36:
+	case 44:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
 		return fn.(func(interface{}, interface{}) bool)(arg1, arg2)
-	case 37:
+	case 45:
 		arg2 := vm.pop()
 		arg1 := vm.pop()
 		return fn.(func(interface{}, interface{}) string)(arg1, arg2)
-	case 38:
+	case 46:
 		arg1 := vm.pop().(bool)
 		return fn.(func(bool) bool)(arg1)
-	case 39:
+	case 47:
 		arg1 := vm.pop().(bool)
 		return fn.(func(bool) float64)(arg1)
-	case 40:
+	case 48:
 		arg1 := vm.pop().(bool)
 		return fn.(func(bool) int)(arg1)
-	case 41:
+	case 49:
 		arg1 := vm.pop().(bool)
 		return fn.(func(bool) string)(arg1)
-	case 42:
+	case 50:
+		arg2 := vm.pop().(bool)
+		arg1 := vm.pop().(bool)
+		return fn.(func(bool, bool) bool)(arg1, arg2)
+	case 51:
+		arg1 := vm.pop().(float32)
+		return fn.(func(float32) float64)(arg1)
+	case 52:
 		arg1 := vm.pop().(float64)
 		return fn.(func(float64) bool)(arg1)
-	case 43:
+	case 53:
+		arg1 := vm.pop().(float64)
+		return fn.(func(float64) float32)(arg1)
+	case 54:
 		arg1 := vm.pop().(float64)
 		return fn.(func(float64) float64)(arg1)
-	case 44:
+	case 55:
 		arg1 := vm.pop().(float64)
 		return fn.(func(float64) int)(arg1)
-	case 45:
+	case 56:
 		arg1 := vm.pop().(float64)
 		return fn.(func(float64) string)(arg1)
-	case 46:
+	case 57:
+		arg2 := vm.pop().(float64)
+		arg1 := vm.pop().(float64)
+		return fn.(func(float64, float64) bool)(arg1, arg2)
+	case 58:
 		arg1 := vm.pop().(int)
 		return fn.(func(int) bool)(arg1)
-	case 47:
+	case 59:
 		arg1 := vm.pop().(int)
 		return fn.(func(int) float64)(arg1)
-	case 48:
+	case 60:
 		arg1 := vm.pop().(int)
 		return fn.(func(int) int)(arg1)
-	case 49:
+	case 61:
 		arg1 := vm.pop().(int)
 		return fn.(func(int) string)(arg1)
-	case 50:
+	case 62:
+		arg2 := vm.pop().(int)
+		arg1 := vm.pop().(int)
+		return fn.(func(int, int) bool)(arg1, arg2)
+	case 63:
 		arg2 := vm.pop().(int)
 		arg1 := vm.pop().(int)
 		return fn.(func(int, int) int)(arg1, arg2)
-	case 51:
+	case 64:
 		arg2 := vm.pop().(int)
 		arg1 := vm.pop().(int)
 		return fn.(func(int, int) string)(arg1, arg2)
-	case 52:
+	case 65:
+		arg1 := vm.pop().(int16)
+		return fn.(func(int16) int32)(arg1)
+	case 66:
 		arg1 := vm.pop().(int32)
 		return fn.(func(int32) float64)(arg1)
-	case 53:
+	case 67:
+		arg1 := vm.pop().(int32)
+		return fn.(func(int32) int)(arg1)
+	case 68:
+		arg1 := vm.pop().(int32)
+		return fn.(func(int32) int64)(arg1)
+	case 69:
 		arg1 := vm.pop().(int64)
 		return fn.(func(int64) time.Time)(arg1)
-	case 54:
+	case 70:
+		arg1 := vm.pop().(int8)
+		return fn.(func(int8) int)(arg1)
+	case 71:
+		arg1 := vm.pop().(int8)
+		return fn.(func(int8) int16)(arg1)
+	case 72:
 		arg1 := vm.pop().(string)
-		return fn.(func(string) []string)(arg1)
-	case 55:
+		return fn.(func(string) []uint8)(arg1)
+	case 73:
 		arg1 := vm.pop().(string)
-		return fn.(func(string) bool)(arg1)
-	case 56:
+		return fn.(func(string) []string)(arg1)
+	case 74:
 		arg1 := vm.pop().(string)
 		return fn.(func(string) bool)(arg1)
-	case 57:
+	case 75:
 		arg1 := vm.pop().(string)
 		return fn.(func(string) float64)(arg1)
-	case 58:
+	case 76:
 		arg1 := vm.pop().(string)
 		return fn.(func(string) int)(arg1)
-	case 59:
+	case 77:
 		arg1 := vm.pop().(string)
 		return fn.(func(string) string)(arg1)
-	case 60:
+	case 78:
 		arg2 := vm.pop().(uint8)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, uint8) int)(arg1, arg2)
-	case 61:
+	case 79:
 		arg2 := vm.pop().(int)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, int) int)(arg1, arg2)
-	case 62:
+	case 80:
 		arg2 := vm.pop().(int32)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, int32) int)(arg1, arg2)
-	case 63:
+	case 81:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, string) bool)(arg1, arg2)
-	case 64:
+	case 82:
 		arg2 := vm.pop().(string)
 		arg1 := vm.pop().(string)
 		return fn.(func(string, string) string)(arg1, arg2)
+	case 83:
+		arg1 := vm.pop().(uint)
+		return fn.(func(uint) float64)(arg1)
+	case 84:
+		arg1 := vm.pop().(uint)
+		return fn.(func(uint) int)(arg1)
+	case 85:
+		arg1 := vm.pop().(uint)
+		return fn.(func(uint) uint)(arg1)
+	case 86:
+		arg1 := vm.pop().(uint16)
+		return fn.(func(uint16) uint)(arg1)
+	case 87:
+		arg1 := vm.pop().(uint32)
+		return fn.(func(uint32) uint64)(arg1)
+	case 88:
+		arg1 := vm.pop().(uint64)
+		return fn.(func(uint64) float64)(arg1)
+	case 89:
+		arg1 := vm.pop().(uint64)
+		return fn.(func(uint64) int64)(arg1)
+	case 90:
+		arg1 := vm.pop().(uint8)
+		return fn.(func(uint8) uint8)(arg1)
 
 	}
 	panic(fmt.Sprintf("unknown function kind (%v)", kind))

From 1719809852028076d69912155b00c9dd80818a2a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 17 Feb 2024 11:15:54 +0100
Subject: [PATCH 268/506] Fix tests

---
 checker/info_test.go      | 7 ++++---
 compiler/compiler_test.go | 6 +++---
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/checker/info_test.go b/checker/info_test.go
index c91a55ad6..6b0a042c2 100644
--- a/checker/info_test.go
+++ b/checker/info_test.go
@@ -3,6 +3,7 @@ package checker_test
 import (
 	"reflect"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 
@@ -11,12 +12,12 @@ import (
 )
 
 func TestTypedFuncIndex(t *testing.T) {
-	fn := func([]any, string) string {
-		return "foo"
+	fn := func() time.Duration {
+		return 1 * time.Second
 	}
 	index, ok := checker.TypedFuncIndex(reflect.TypeOf(fn), false)
 	require.True(t, ok)
-	require.Equal(t, 22, index)
+	require.Equal(t, 1, index)
 }
 
 func TestTypedFuncIndex_excludes_named_functions(t *testing.T) {
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index b7bbfcfb4..741142a77 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -319,7 +319,7 @@ func TestCompile(t *testing.T) {
 					vm.OpMethod,
 					vm.OpCallTyped,
 				},
-				Arguments: []int{0, 0, 1, 10},
+				Arguments: []int{0, 0, 1, 12},
 			},
 		},
 	}
@@ -358,7 +358,7 @@ func TestCompile_FuncTypes(t *testing.T) {
 	program, err := expr.Compile("fn([1, 2], 'bar')", expr.Env(env))
 	require.NoError(t, err)
 	require.Equal(t, vm.OpCallTyped, program.Bytecode[3])
-	require.Equal(t, 22, program.Arguments[3])
+	require.Equal(t, 32, program.Arguments[3])
 }
 
 func TestCompile_FuncTypes_with_Method(t *testing.T) {
@@ -366,7 +366,7 @@ func TestCompile_FuncTypes_with_Method(t *testing.T) {
 	program, err := expr.Compile("FuncTyped('bar')", expr.Env(env))
 	require.NoError(t, err)
 	require.Equal(t, vm.OpCallTyped, program.Bytecode[2])
-	require.Equal(t, 42, program.Arguments[2])
+	require.Equal(t, 76, program.Arguments[2])
 }
 
 func TestCompile_FuncTypes_excludes_named_functions(t *testing.T) {

From 4cac5f684e8898516dba520a1e9941f1cb34161f Mon Sep 17 00:00:00 2001
From: Nikolay Matrosov <nikolay.matrosov@gmail.com>
Date: Sat, 17 Feb 2024 14:33:07 +0100
Subject: [PATCH 269/506] feat: Operator overload from Function (#408)

* feat: rewritten Operator overload from Function

* fix: add test
---
 checker/checker.go             |   2 +-
 conf/config.go                 |  38 ++++++--
 conf/operators.go              |  55 +++++++++--
 expr.go                        |   1 +
 test/operator/operator_test.go | 167 +++++++++++++++++++++++++++++++++
 5 files changed, 246 insertions(+), 17 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index c845dd78a..b8808441f 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -240,7 +240,7 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 
 	// check operator overloading
 	if fns, ok := v.config.Operators[node.Operator]; ok {
-		t, _, ok := conf.FindSuitableOperatorOverload(fns, v.config.Types, l, r)
+		t, _, ok := conf.FindSuitableOperatorOverload(fns, v.config.Types, v.config.Functions, l, r)
 		if ok {
 			return t, info{}
 		}
diff --git a/conf/config.go b/conf/config.go
index baf5dee05..f34dd0348 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -9,6 +9,8 @@ import (
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
+type FunctionTable map[string]*builtin.Function
+
 type Config struct {
 	Env         any
 	Types       TypesTable
@@ -85,21 +87,43 @@ func (c *Config) ConstExpr(name string) {
 func (c *Config) Check() {
 	for operator, fns := range c.Operators {
 		for _, fn := range fns {
-			fnType, ok := c.Types[fn]
-			if !ok || fnType.Type.Kind() != reflect.Func {
+			fnType, foundType := c.Types[fn]
+			fnFunc, foundFunc := c.Functions[fn]
+			if !foundFunc && (!foundType || fnType.Type.Kind() != reflect.Func) {
 				panic(fmt.Errorf("function %s for %s operator does not exist in the environment", fn, operator))
 			}
-			requiredNumIn := 2
-			if fnType.Method {
-				requiredNumIn = 3 // As first argument of method is receiver.
+
+			if foundType {
+				checkType(fnType, fn, operator)
 			}
-			if fnType.Type.NumIn() != requiredNumIn || fnType.Type.NumOut() != 1 {
-				panic(fmt.Errorf("function %s for %s operator does not have a correct signature", fn, operator))
+			if foundFunc {
+				checkFunc(fnFunc, fn, operator)
 			}
 		}
 	}
 }
 
+func checkType(fnType Tag, fn string, operator string) {
+	requiredNumIn := 2
+	if fnType.Method {
+		requiredNumIn = 3 // As first argument of method is receiver.
+	}
+	if fnType.Type.NumIn() != requiredNumIn || fnType.Type.NumOut() != 1 {
+		panic(fmt.Errorf("function %s for %s operator does not have a correct signature", fn, operator))
+	}
+}
+
+func checkFunc(fn *builtin.Function, name string, operator string) {
+	if len(fn.Types) == 0 {
+		panic(fmt.Errorf("function %s for %s operator misses types", name, operator))
+	}
+	for _, t := range fn.Types {
+		if t.NumIn() != 2 || t.NumOut() != 1 {
+			panic(fmt.Errorf("function %s for %s operator does not have a correct signature", name, operator))
+		}
+	}
+}
+
 func (c *Config) IsOverridden(name string) bool {
 	if _, ok := c.Functions[name]; ok {
 		return true
diff --git a/conf/operators.go b/conf/operators.go
index ced209fdc..646153cb3 100644
--- a/conf/operators.go
+++ b/conf/operators.go
@@ -10,28 +10,65 @@ import (
 // Functions should be provided in the environment to allow operator overloading.
 type OperatorsTable map[string][]string
 
-func FindSuitableOperatorOverload(fns []string, types TypesTable, l, r reflect.Type) (reflect.Type, string, bool) {
+func FindSuitableOperatorOverload(fns []string, types TypesTable, funcs FunctionTable, l, r reflect.Type) (reflect.Type, string, bool) {
+	t, fn, ok := FindSuitableOperatorOverloadInFunctions(fns, funcs, l, r)
+	if !ok {
+		t, fn, ok = FindSuitableOperatorOverloadInTypes(fns, types, l, r)
+	}
+	return t, fn, ok
+}
+
+func FindSuitableOperatorOverloadInTypes(fns []string, types TypesTable, l, r reflect.Type) (reflect.Type, string, bool) {
 	for _, fn := range fns {
-		fnType := types[fn]
+		fnType, ok := types[fn]
+		if !ok {
+			continue
+		}
 		firstInIndex := 0
 		if fnType.Method {
 			firstInIndex = 1 // As first argument to method is receiver.
 		}
-		firstArgType := fnType.Type.In(firstInIndex)
-		secondArgType := fnType.Type.In(firstInIndex + 1)
+		ret, done := checkTypeSuits(fnType.Type, l, r, firstInIndex)
+		if done {
+			return ret, fn, true
+		}
+	}
+	return nil, "", false
+}
 
-		firstArgumentFit := l == firstArgType || (firstArgType.Kind() == reflect.Interface && (l == nil || l.Implements(firstArgType)))
-		secondArgumentFit := r == secondArgType || (secondArgType.Kind() == reflect.Interface && (r == nil || r.Implements(secondArgType)))
-		if firstArgumentFit && secondArgumentFit {
-			return fnType.Type.Out(0), fn, true
+func FindSuitableOperatorOverloadInFunctions(fns []string, funcs FunctionTable, l, r reflect.Type) (reflect.Type, string, bool) {
+	for _, fn := range fns {
+		fnType, ok := funcs[fn]
+		if !ok {
+			continue
+		}
+		firstInIndex := 0
+		for _, overload := range fnType.Types {
+			ret, done := checkTypeSuits(overload, l, r, firstInIndex)
+			if done {
+				return ret, fn, true
+			}
 		}
 	}
 	return nil, "", false
 }
 
+func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex int) (reflect.Type, bool) {
+	firstArgType := t.In(firstInIndex)
+	secondArgType := t.In(firstInIndex + 1)
+
+	firstArgumentFit := l == firstArgType || (firstArgType.Kind() == reflect.Interface && (l == nil || l.Implements(firstArgType)))
+	secondArgumentFit := r == secondArgType || (secondArgType.Kind() == reflect.Interface && (r == nil || r.Implements(secondArgType)))
+	if firstArgumentFit && secondArgumentFit {
+		return t.Out(0), true
+	}
+	return nil, false
+}
+
 type OperatorPatcher struct {
 	Operators OperatorsTable
 	Types     TypesTable
+	Functions FunctionTable
 }
 
 func (p *OperatorPatcher) Visit(node *ast.Node) {
@@ -48,7 +85,7 @@ func (p *OperatorPatcher) Visit(node *ast.Node) {
 	leftType := binaryNode.Left.Type()
 	rightType := binaryNode.Right.Type()
 
-	ret, fn, ok := FindSuitableOperatorOverload(fns, p.Types, leftType, rightType)
+	ret, fn, ok := FindSuitableOperatorOverload(fns, p.Types, p.Functions, leftType, rightType)
 	if ok {
 		newNode := &ast.CallNode{
 			Callee:    &ast.IdentifierNode{Value: fn},
diff --git a/expr.go b/expr.go
index f32df1d3c..e43abaafd 100644
--- a/expr.go
+++ b/expr.go
@@ -192,6 +192,7 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 		config.Visitors = append(config.Visitors, &conf.OperatorPatcher{
 			Operators: config.Operators,
 			Types:     config.Types,
+			Functions: config.Functions,
 		})
 	}
 
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index af50a24eb..59bc73f2b 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -1,6 +1,7 @@
 package operator_test
 
 import (
+	"fmt"
 	"testing"
 	"time"
 
@@ -55,3 +56,169 @@ func TestOperator_interface(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, output)
 }
+
+type Value struct {
+	Int int
+}
+
+func TestOperator_Function(t *testing.T) {
+	env := map[string]interface{}{
+		"foo": Value{1},
+		"bar": Value{2},
+	}
+
+	tests := []struct {
+		input string
+		want  int
+	}{
+		{
+			input: `foo + bar`,
+			want:  3,
+		},
+		{
+			input: `2 + 4`,
+			want:  6,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(fmt.Sprintf(`opertor function helper test %s`, tt.input), func(t *testing.T) {
+			program, err := expr.Compile(
+				tt.input,
+				expr.Env(env),
+				expr.Operator("+", "Add", "AddInt"),
+				expr.Function("Add", func(args ...interface{}) (interface{}, error) {
+					return args[0].(Value).Int + args[1].(Value).Int, nil
+				},
+					new(func(_ Value, __ Value) int),
+				),
+				expr.Function("AddInt", func(args ...interface{}) (interface{}, error) {
+					return args[0].(int) + args[1].(int), nil
+				},
+					new(func(_ int, __ int) int),
+				),
+			)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, env)
+			require.NoError(t, err)
+			require.Equal(t, tt.want, output)
+		})
+	}
+
+}
+
+func TestOperator_Function_WithTypes(t *testing.T) {
+	env := map[string]interface{}{
+		"foo": Value{1},
+		"bar": Value{2},
+	}
+
+	require.PanicsWithError(t, `function Add for + operator misses types`, func() {
+		_, _ = expr.Compile(
+			`foo + bar`,
+			expr.Env(env),
+			expr.Operator("+", "Add", "AddInt"),
+			expr.Function("Add", func(args ...interface{}) (interface{}, error) {
+				return args[0].(Value).Int + args[1].(Value).Int, nil
+			}),
+		)
+	})
+
+	require.PanicsWithError(t, `function Add for + operator does not have a correct signature`, func() {
+		_, _ = expr.Compile(
+			`foo + bar`,
+			expr.Env(env),
+			expr.Operator("+", "Add", "AddInt"),
+			expr.Function("Add", func(args ...interface{}) (interface{}, error) {
+				return args[0].(Value).Int + args[1].(Value).Int, nil
+			},
+				new(func(_ Value) int),
+			),
+		)
+	})
+
+}
+
+func TestOperator_FunctionOverTypesPrecedence(t *testing.T) {
+	env := struct {
+		Add func(a, b int) int
+	}{
+		Add: func(a, b int) int {
+			return a + b
+		},
+	}
+
+	program, err := expr.Compile(
+		`1 + 2`,
+		expr.Env(env),
+		expr.Operator("+", "Add"),
+		expr.Function("Add", func(args ...interface{}) (interface{}, error) {
+			// Wierd function that returns 100 + a + b in testing purposes.
+			return args[0].(int) + args[1].(int) + 100, nil
+		},
+			new(func(_ int, __ int) int),
+		),
+	)
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 103, output)
+}
+
+func TestOperator_CanBeDefinedEitherInTypesOrInFunctions(t *testing.T) {
+	env := struct {
+		Add func(a, b int) int
+	}{
+		Add: func(a, b int) int {
+			return a + b
+		},
+	}
+
+	program, err := expr.Compile(
+		`1 + 2`,
+		expr.Env(env),
+		expr.Operator("+", "Add", "AddValues"),
+		expr.Function("AddValues", func(args ...interface{}) (interface{}, error) {
+			return args[0].(Value).Int + args[1].(Value).Int, nil
+		},
+			new(func(_ Value, __ Value) int),
+		),
+	)
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 3, output)
+}
+
+func TestOperator_Polymorphic(t *testing.T) {
+	env := struct {
+		Add func(a, b int) int
+		Foo Value
+		Bar Value
+	}{
+		Add: func(a, b int) int {
+			return a + b
+		},
+		Foo: Value{1},
+		Bar: Value{2},
+	}
+
+	program, err := expr.Compile(
+		`1 + 2 + (Foo + Bar)`,
+		expr.Env(env),
+		expr.Operator("+", "Add", "AddValues"),
+		expr.Function("AddValues", func(args ...interface{}) (interface{}, error) {
+			return args[0].(Value).Int + args[1].(Value).Int, nil
+		},
+			new(func(_ Value, __ Value) int),
+		),
+	)
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 6, output)
+}

From 9569d4b3d96dde0b3fc30cf8f19683424b3f201c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 17 Feb 2024 19:04:31 +0100
Subject: [PATCH 270/506] Update doc

---
 docs/language-definition.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/docs/language-definition.md b/docs/language-definition.md
index e5267f9a8..a4e1a7cb0 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -638,6 +638,14 @@ Equivalent to:
 len(filter(array, predicate))
 ```
 
+### concat(array1, array2[, ...]) {#concat}
+
+Concatenates two or more arrays.
+
+```expr
+concat([1, 2], [3, 4]) == [1, 2, 3, 4]
+```
+
 ### join(array[, delimiter]) {#join}
 
 Joins an array of strings into a single string with the given delimiter.

From 8ecb18a3c8184b591e89f1bd69cf7fd66ec30d61 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 17 Feb 2024 19:17:27 +0100
Subject: [PATCH 271/506] Move operator override patcher to correct pkg

---
 conf/config.go               |  4 ++++
 conf/operators.go            | 37 ------------------------------------
 conf/types_table.go          |  4 ++--
 expr.go                      |  2 +-
 patcher/operator_override.go | 37 ++++++++++++++++++++++++++++++++++++
 5 files changed, 44 insertions(+), 40 deletions(-)
 create mode 100644 patcher/operator_override.go

diff --git a/conf/config.go b/conf/config.go
index f34dd0348..a2f571efb 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -11,6 +11,10 @@ import (
 
 type FunctionTable map[string]*builtin.Function
 
+// OperatorsTable maps binary operators to corresponding list of functions.
+// Functions should be provided in the environment to allow operator overloading.
+type OperatorsTable map[string][]string
+
 type Config struct {
 	Env         any
 	Types       TypesTable
diff --git a/conf/operators.go b/conf/operators.go
index 646153cb3..90cbf4fea 100644
--- a/conf/operators.go
+++ b/conf/operators.go
@@ -2,14 +2,8 @@ package conf
 
 import (
 	"reflect"
-
-	"github.com/expr-lang/expr/ast"
 )
 
-// OperatorsTable maps binary operators to corresponding list of functions.
-// Functions should be provided in the environment to allow operator overloading.
-type OperatorsTable map[string][]string
-
 func FindSuitableOperatorOverload(fns []string, types TypesTable, funcs FunctionTable, l, r reflect.Type) (reflect.Type, string, bool) {
 	t, fn, ok := FindSuitableOperatorOverloadInFunctions(fns, funcs, l, r)
 	if !ok {
@@ -64,34 +58,3 @@ func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex
 	}
 	return nil, false
 }
-
-type OperatorPatcher struct {
-	Operators OperatorsTable
-	Types     TypesTable
-	Functions FunctionTable
-}
-
-func (p *OperatorPatcher) Visit(node *ast.Node) {
-	binaryNode, ok := (*node).(*ast.BinaryNode)
-	if !ok {
-		return
-	}
-
-	fns, ok := p.Operators[binaryNode.Operator]
-	if !ok {
-		return
-	}
-
-	leftType := binaryNode.Left.Type()
-	rightType := binaryNode.Right.Type()
-
-	ret, fn, ok := FindSuitableOperatorOverload(fns, p.Types, p.Functions, leftType, rightType)
-	if ok {
-		newNode := &ast.CallNode{
-			Callee:    &ast.IdentifierNode{Value: fn},
-			Arguments: []ast.Node{binaryNode.Left, binaryNode.Right},
-		}
-		newNode.SetType(ret)
-		ast.Patch(node, newNode)
-	}
-}
diff --git a/conf/types_table.go b/conf/types_table.go
index 738eee840..a42a42874 100644
--- a/conf/types_table.go
+++ b/conf/types_table.go
@@ -6,6 +6,8 @@ import (
 	"github.com/expr-lang/expr/internal/deref"
 )
 
+type TypesTable map[string]Tag
+
 type Tag struct {
 	Type        reflect.Type
 	Ambiguous   bool
@@ -14,8 +16,6 @@ type Tag struct {
 	MethodIndex int
 }
 
-type TypesTable map[string]Tag
-
 // CreateTypesTable creates types table for type checks during parsing.
 // If struct is passed, all fields will be treated as variables,
 // as well as all fields of embedded structs and struct itself.
diff --git a/expr.go b/expr.go
index e43abaafd..2802b4d1b 100644
--- a/expr.go
+++ b/expr.go
@@ -189,7 +189,7 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 	config.Check()
 
 	if len(config.Operators) > 0 {
-		config.Visitors = append(config.Visitors, &conf.OperatorPatcher{
+		config.Visitors = append(config.Visitors, &patcher.Operator{
 			Operators: config.Operators,
 			Types:     config.Types,
 			Functions: config.Functions,
diff --git a/patcher/operator_override.go b/patcher/operator_override.go
new file mode 100644
index 000000000..e84331bc3
--- /dev/null
+++ b/patcher/operator_override.go
@@ -0,0 +1,37 @@
+package patcher
+
+import (
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/conf"
+)
+
+type Operator struct {
+	Operators conf.OperatorsTable
+	Types     conf.TypesTable
+	Functions conf.FunctionTable
+}
+
+func (p *Operator) Visit(node *ast.Node) {
+	binaryNode, ok := (*node).(*ast.BinaryNode)
+	if !ok {
+		return
+	}
+
+	fns, ok := p.Operators[binaryNode.Operator]
+	if !ok {
+		return
+	}
+
+	leftType := binaryNode.Left.Type()
+	rightType := binaryNode.Right.Type()
+
+	ret, fn, ok := conf.FindSuitableOperatorOverload(fns, p.Types, p.Functions, leftType, rightType)
+	if ok {
+		newNode := &ast.CallNode{
+			Callee:    &ast.IdentifierNode{Value: fn},
+			Arguments: []ast.Node{binaryNode.Left, binaryNode.Right},
+		}
+		newNode.SetType(ret)
+		ast.Patch(node, newNode)
+	}
+}

From 95084fb18e9d09dc3f06449f8298674e10331767 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 17 Feb 2024 19:20:53 +0100
Subject: [PATCH 272/506] Remove redundant operator override check

---
 checker/checker.go      |  8 --------
 checker/checker_test.go | 24 ------------------------
 2 files changed, 32 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index b8808441f..b46178d43 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -238,14 +238,6 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 	l = deref.Type(l)
 	r = deref.Type(r)
 
-	// check operator overloading
-	if fns, ok := v.config.Operators[node.Operator]; ok {
-		t, _, ok := conf.FindSuitableOperatorOverload(fns, v.config.Types, v.config.Functions, l, r)
-		if ok {
-			return t, info{}
-		}
-	}
-
 	switch node.Operator {
 	case "==", "!=":
 		if isComparable(l, r) {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index bab9a0a67..d6a84abc5 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -714,30 +714,6 @@ func TestCheck_AllowUndefinedVariables_OptionalChaining(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-func TestCheck_OperatorOverload(t *testing.T) {
-	type Date struct{}
-	env := map[string]any{
-		"a": Date{},
-		"b": Date{},
-		"add": func(a, b Date) bool {
-			return true
-		},
-	}
-	tree, err := parser.Parse(`a + b`)
-	require.NoError(t, err)
-
-	config := conf.New(env)
-	expr.AsBool()(config)
-
-	_, err = checker.Check(tree, config)
-	require.Error(t, err)
-	require.Contains(t, err.Error(), "invalid operation: + (mismatched types checker_test.Date and checker_test.Date)")
-
-	expr.Operator("+", "add")(config)
-	_, err = checker.Check(tree, config)
-	require.NoError(t, err)
-}
-
 func TestCheck_PointerNode(t *testing.T) {
 	_, err := checker.Check(&parser.Tree{Node: &ast.PointerNode{}}, nil)
 	assert.Error(t, err)

From 62cdd42240f5f9ad243ca8b09e9253c59eef12bf Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 17 Feb 2024 19:56:28 +0100
Subject: [PATCH 273/506] Refactor operator override to be purely patcher pkg

---
 conf/config.go                 |  56 +++-------------
 conf/functions.go              |   1 -
 conf/operators.go              |  60 -----------------
 expr.go                        |  16 ++---
 patcher/operator_override.go   | 114 ++++++++++++++++++++++++++++++---
 test/operator/operator_test.go |   6 --
 6 files changed, 122 insertions(+), 131 deletions(-)
 delete mode 100644 conf/functions.go
 delete mode 100644 conf/operators.go

diff --git a/conf/config.go b/conf/config.go
index a2f571efb..e543732ce 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -9,26 +9,21 @@ import (
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
-type FunctionTable map[string]*builtin.Function
-
-// OperatorsTable maps binary operators to corresponding list of functions.
-// Functions should be provided in the environment to allow operator overloading.
-type OperatorsTable map[string][]string
+type FunctionsTable map[string]*builtin.Function
 
 type Config struct {
 	Env         any
 	Types       TypesTable
 	MapEnv      bool
 	DefaultType reflect.Type
-	Operators   OperatorsTable
 	Expect      reflect.Kind
 	ExpectAny   bool
 	Optimize    bool
 	Strict      bool
 	ConstFns    map[string]reflect.Value
 	Visitors    []ast.Visitor
-	Functions   map[string]*builtin.Function
-	Builtins    map[string]*builtin.Function
+	Functions   FunctionsTable
+	Builtins    FunctionsTable
 	Disabled    map[string]bool // disabled builtins
 }
 
@@ -36,7 +31,6 @@ type Config struct {
 func CreateNew() *Config {
 	c := &Config{
 		Optimize:  true,
-		Operators: make(map[string][]string),
 		ConstFns:  make(map[string]reflect.Value),
 		Functions: make(map[string]*builtin.Function),
 		Builtins:  make(map[string]*builtin.Function),
@@ -73,10 +67,6 @@ func (c *Config) WithEnv(env any) {
 	c.Strict = true
 }
 
-func (c *Config) Operator(operator string, fns ...string) {
-	c.Operators[operator] = append(c.Operators[operator], fns...)
-}
-
 func (c *Config) ConstExpr(name string) {
 	if c.Env == nil {
 		panic("no environment is specified for ConstExpr()")
@@ -88,42 +78,14 @@ func (c *Config) ConstExpr(name string) {
 	c.ConstFns[name] = fn
 }
 
-func (c *Config) Check() {
-	for operator, fns := range c.Operators {
-		for _, fn := range fns {
-			fnType, foundType := c.Types[fn]
-			fnFunc, foundFunc := c.Functions[fn]
-			if !foundFunc && (!foundType || fnType.Type.Kind() != reflect.Func) {
-				panic(fmt.Errorf("function %s for %s operator does not exist in the environment", fn, operator))
-			}
-
-			if foundType {
-				checkType(fnType, fn, operator)
-			}
-			if foundFunc {
-				checkFunc(fnFunc, fn, operator)
-			}
-		}
-	}
+type Checker interface {
+	Check()
 }
 
-func checkType(fnType Tag, fn string, operator string) {
-	requiredNumIn := 2
-	if fnType.Method {
-		requiredNumIn = 3 // As first argument of method is receiver.
-	}
-	if fnType.Type.NumIn() != requiredNumIn || fnType.Type.NumOut() != 1 {
-		panic(fmt.Errorf("function %s for %s operator does not have a correct signature", fn, operator))
-	}
-}
-
-func checkFunc(fn *builtin.Function, name string, operator string) {
-	if len(fn.Types) == 0 {
-		panic(fmt.Errorf("function %s for %s operator misses types", name, operator))
-	}
-	for _, t := range fn.Types {
-		if t.NumIn() != 2 || t.NumOut() != 1 {
-			panic(fmt.Errorf("function %s for %s operator does not have a correct signature", name, operator))
+func (c *Config) Check() {
+	for _, v := range c.Visitors {
+		if c, ok := v.(Checker); ok {
+			c.Check()
 		}
 	}
 }
diff --git a/conf/functions.go b/conf/functions.go
deleted file mode 100644
index 8f52a9557..000000000
--- a/conf/functions.go
+++ /dev/null
@@ -1 +0,0 @@
-package conf
diff --git a/conf/operators.go b/conf/operators.go
deleted file mode 100644
index 90cbf4fea..000000000
--- a/conf/operators.go
+++ /dev/null
@@ -1,60 +0,0 @@
-package conf
-
-import (
-	"reflect"
-)
-
-func FindSuitableOperatorOverload(fns []string, types TypesTable, funcs FunctionTable, l, r reflect.Type) (reflect.Type, string, bool) {
-	t, fn, ok := FindSuitableOperatorOverloadInFunctions(fns, funcs, l, r)
-	if !ok {
-		t, fn, ok = FindSuitableOperatorOverloadInTypes(fns, types, l, r)
-	}
-	return t, fn, ok
-}
-
-func FindSuitableOperatorOverloadInTypes(fns []string, types TypesTable, l, r reflect.Type) (reflect.Type, string, bool) {
-	for _, fn := range fns {
-		fnType, ok := types[fn]
-		if !ok {
-			continue
-		}
-		firstInIndex := 0
-		if fnType.Method {
-			firstInIndex = 1 // As first argument to method is receiver.
-		}
-		ret, done := checkTypeSuits(fnType.Type, l, r, firstInIndex)
-		if done {
-			return ret, fn, true
-		}
-	}
-	return nil, "", false
-}
-
-func FindSuitableOperatorOverloadInFunctions(fns []string, funcs FunctionTable, l, r reflect.Type) (reflect.Type, string, bool) {
-	for _, fn := range fns {
-		fnType, ok := funcs[fn]
-		if !ok {
-			continue
-		}
-		firstInIndex := 0
-		for _, overload := range fnType.Types {
-			ret, done := checkTypeSuits(overload, l, r, firstInIndex)
-			if done {
-				return ret, fn, true
-			}
-		}
-	}
-	return nil, "", false
-}
-
-func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex int) (reflect.Type, bool) {
-	firstArgType := t.In(firstInIndex)
-	secondArgType := t.In(firstInIndex + 1)
-
-	firstArgumentFit := l == firstArgType || (firstArgType.Kind() == reflect.Interface && (l == nil || l.Implements(firstArgType)))
-	secondArgumentFit := r == secondArgType || (secondArgType.Kind() == reflect.Interface && (r == nil || r.Implements(secondArgType)))
-	if firstArgumentFit && secondArgumentFit {
-		return t.Out(0), true
-	}
-	return nil, false
-}
diff --git a/expr.go b/expr.go
index 2802b4d1b..7d76a80ba 100644
--- a/expr.go
+++ b/expr.go
@@ -42,7 +42,13 @@ func AllowUndefinedVariables() Option {
 // Operator allows to replace a binary operator with a function.
 func Operator(operator string, fn ...string) Option {
 	return func(c *conf.Config) {
-		c.Operator(operator, fn...)
+		p := &patcher.OperatorOverride{
+			Operator:  operator,
+			Overrides: fn,
+			Types:     c.Types,
+			Functions: c.Functions,
+		}
+		c.Visitors = append(c.Visitors, p)
 	}
 }
 
@@ -188,14 +194,6 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 	}
 	config.Check()
 
-	if len(config.Operators) > 0 {
-		config.Visitors = append(config.Visitors, &patcher.Operator{
-			Operators: config.Operators,
-			Types:     config.Types,
-			Functions: config.Functions,
-		})
-	}
-
 	tree, err := parser.ParseWithConfig(input, config)
 	if err != nil {
 		return nil, err
diff --git a/patcher/operator_override.go b/patcher/operator_override.go
index e84331bc3..38b3558bd 100644
--- a/patcher/operator_override.go
+++ b/patcher/operator_override.go
@@ -1,31 +1,35 @@
 package patcher
 
 import (
+	"fmt"
+	"reflect"
+
 	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/conf"
 )
 
-type Operator struct {
-	Operators conf.OperatorsTable
-	Types     conf.TypesTable
-	Functions conf.FunctionTable
+type OperatorOverride struct {
+	Operator  string              // Operator token to override.
+	Overrides []string            // List of function names to override operator with.
+	Types     conf.TypesTable     // Env types.
+	Functions conf.FunctionsTable // Env functions.
 }
 
-func (p *Operator) Visit(node *ast.Node) {
+func (p *OperatorOverride) Visit(node *ast.Node) {
 	binaryNode, ok := (*node).(*ast.BinaryNode)
 	if !ok {
 		return
 	}
 
-	fns, ok := p.Operators[binaryNode.Operator]
-	if !ok {
+	if binaryNode.Operator != p.Operator {
 		return
 	}
 
 	leftType := binaryNode.Left.Type()
 	rightType := binaryNode.Right.Type()
 
-	ret, fn, ok := conf.FindSuitableOperatorOverload(fns, p.Types, p.Functions, leftType, rightType)
+	ret, fn, ok := p.FindSuitableOperatorOverload(leftType, rightType)
 	if ok {
 		newNode := &ast.CallNode{
 			Callee:    &ast.IdentifierNode{Value: fn},
@@ -35,3 +39,97 @@ func (p *Operator) Visit(node *ast.Node) {
 		ast.Patch(node, newNode)
 	}
 }
+
+func (p *OperatorOverride) FindSuitableOperatorOverload(l, r reflect.Type) (reflect.Type, string, bool) {
+	t, fn, ok := p.findSuitableOperatorOverloadInFunctions(l, r)
+	if !ok {
+		t, fn, ok = p.findSuitableOperatorOverloadInTypes(l, r)
+	}
+	return t, fn, ok
+}
+
+func (p *OperatorOverride) findSuitableOperatorOverloadInTypes(l, r reflect.Type) (reflect.Type, string, bool) {
+	for _, fn := range p.Overrides {
+		fnType, ok := p.Types[fn]
+		if !ok {
+			continue
+		}
+		firstInIndex := 0
+		if fnType.Method {
+			firstInIndex = 1 // As first argument to method is receiver.
+		}
+		ret, done := checkTypeSuits(fnType.Type, l, r, firstInIndex)
+		if done {
+			return ret, fn, true
+		}
+	}
+	return nil, "", false
+}
+
+func (p *OperatorOverride) findSuitableOperatorOverloadInFunctions(l, r reflect.Type) (reflect.Type, string, bool) {
+	for _, fn := range p.Overrides {
+		fnType, ok := p.Functions[fn]
+		if !ok {
+			continue
+		}
+		firstInIndex := 0
+		for _, overload := range fnType.Types {
+			ret, done := checkTypeSuits(overload, l, r, firstInIndex)
+			if done {
+				return ret, fn, true
+			}
+		}
+	}
+	return nil, "", false
+}
+
+func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex int) (reflect.Type, bool) {
+	firstArgType := t.In(firstInIndex)
+	secondArgType := t.In(firstInIndex + 1)
+
+	firstArgumentFit := l == firstArgType || (firstArgType.Kind() == reflect.Interface && (l == nil || l.Implements(firstArgType)))
+	secondArgumentFit := r == secondArgType || (secondArgType.Kind() == reflect.Interface && (r == nil || r.Implements(secondArgType)))
+	if firstArgumentFit && secondArgumentFit {
+		return t.Out(0), true
+	}
+	return nil, false
+}
+
+func (p *OperatorOverride) Check() {
+	for _, fn := range p.Overrides {
+		fnType, foundType := p.Types[fn]
+		fnFunc, foundFunc := p.Functions[fn]
+		if !foundFunc && (!foundType || fnType.Type.Kind() != reflect.Func) {
+			panic(fmt.Errorf("function %s for %s operator does not exist in the environment", fn, p.Operator))
+		}
+
+		if foundType {
+			checkType(fnType, fn, p.Operator)
+		}
+
+		if foundFunc {
+			checkFunc(fnFunc, fn, p.Operator)
+		}
+	}
+}
+
+func checkType(fnType conf.Tag, fn string, operator string) {
+	requiredNumIn := 2
+	if fnType.Method {
+		requiredNumIn = 3 // As first argument of method is receiver.
+	}
+	if fnType.Type.NumIn() != requiredNumIn || fnType.Type.NumOut() != 1 {
+		panic(fmt.Errorf("function %s for %s operator does not have a correct signature", fn, operator))
+	}
+}
+
+func checkFunc(fn *builtin.Function, name string, operator string) {
+	if len(fn.Types) == 0 {
+		panic(fmt.Errorf("function %s for %s operator misses types", name, operator))
+	}
+	for _, t := range fn.Types {
+		if t.NumIn() != 2 || t.NumOut() != 1 {
+			panic(fmt.Errorf("function %s for %s operator does not have a correct signature", name, operator))
+		}
+	}
+}
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index 59bc73f2b..e17c5fd66 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -26,12 +26,6 @@ func TestOperator_struct(t *testing.T) {
 	require.Equal(t, true, output)
 }
 
-func TestOperator_options_another_order(t *testing.T) {
-	code := `Time == "2017-10-23"`
-	_, err := expr.Compile(code, expr.Operator("==", "TimeEqualString"), expr.Env(mock.Env{}))
-	require.NoError(t, err)
-}
-
 func TestOperator_no_env(t *testing.T) {
 	code := `Time == "2017-10-23"`
 	require.Panics(t, func() {

From 3da85278439a5e8ef5dc0d73f321f76742e2cecc Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 18 Feb 2024 00:15:39 +0100
Subject: [PATCH 274/506] Fix operator overloading recursive

Fixes #548
---
 expr.go                                   | 23 +++++--
 patcher/operator_override.go              |  6 ++
 test/operator/issues584/issues584_test.go | 73 +++++++++++++++++++++++
 test/operator/operator_test.go            | 37 ++++++++++++
 4 files changed, 134 insertions(+), 5 deletions(-)
 create mode 100644 test/operator/issues584/issues584_test.go

diff --git a/expr.go b/expr.go
index 7d76a80ba..d9f7c0dc3 100644
--- a/expr.go
+++ b/expr.go
@@ -200,11 +200,24 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 	}
 
 	if len(config.Visitors) > 0 {
-		for _, v := range config.Visitors {
-			// We need to perform types check, because some visitors may rely on
-			// types information available in the tree.
-			_, _ = checker.Check(tree, config)
-			ast.Walk(&tree.Node, v)
+		for i := 0; i < 1000; i++ {
+			more := false
+			for _, v := range config.Visitors {
+				// We need to perform types check, because some visitors may rely on
+				// types information available in the tree.
+				_, _ = checker.Check(tree, config)
+
+				ast.Walk(&tree.Node, v)
+
+				if v, ok := v.(interface {
+					ShouldRepeat() bool
+				}); ok {
+					more = more || v.ShouldRepeat()
+				}
+			}
+			if !more {
+				break
+			}
 		}
 	}
 	_, err = checker.Check(tree, config)
diff --git a/patcher/operator_override.go b/patcher/operator_override.go
index 38b3558bd..96e6894cc 100644
--- a/patcher/operator_override.go
+++ b/patcher/operator_override.go
@@ -14,6 +14,7 @@ type OperatorOverride struct {
 	Overrides []string            // List of function names to override operator with.
 	Types     conf.TypesTable     // Env types.
 	Functions conf.FunctionsTable // Env functions.
+	applied   bool                // Flag to indicate if any override was applied.
 }
 
 func (p *OperatorOverride) Visit(node *ast.Node) {
@@ -37,9 +38,14 @@ func (p *OperatorOverride) Visit(node *ast.Node) {
 		}
 		newNode.SetType(ret)
 		ast.Patch(node, newNode)
+		p.applied = true
 	}
 }
 
+func (p *OperatorOverride) ShouldRepeat() bool {
+	return p.applied
+}
+
 func (p *OperatorOverride) FindSuitableOperatorOverload(l, r reflect.Type) (reflect.Type, string, bool) {
 	t, fn, ok := p.findSuitableOperatorOverloadInFunctions(l, r)
 	if !ok {
diff --git a/test/operator/issues584/issues584_test.go b/test/operator/issues584/issues584_test.go
new file mode 100644
index 000000000..13c9c66f3
--- /dev/null
+++ b/test/operator/issues584/issues584_test.go
@@ -0,0 +1,73 @@
+package issues584_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/expr-lang/expr"
+)
+
+type Env struct{}
+
+type Program struct {
+}
+
+func (p *Program) Foo() Value {
+	return func(e *Env) float64 {
+		return 5
+	}
+}
+
+func (p *Program) Bar() Value {
+	return func(e *Env) float64 {
+		return 100
+	}
+}
+
+func (p *Program) AndCondition(a, b Condition) Conditions {
+	return Conditions{a, b}
+}
+
+func (p *Program) AndConditions(a Conditions, b Condition) Conditions {
+	return append(a, b)
+}
+
+func (p *Program) ValueGreaterThan_float(v Value, i float64) Condition {
+	return func(e *Env) bool {
+		realized := v(e)
+		return realized > i
+	}
+}
+
+func (p *Program) ValueLessThan_float(v Value, i float64) Condition {
+	return func(e *Env) bool {
+		realized := v(e)
+		return realized < i
+	}
+}
+
+type Condition func(e *Env) bool
+type Conditions []Condition
+
+type Value func(e *Env) float64
+
+func TestIssue584(t *testing.T) {
+	code := `Foo() > 1.5 and Bar() < 200.0`
+
+	p := &Program{}
+
+	opt := []expr.Option{
+		expr.Env(p),
+		expr.Operator("and", "AndCondition", "AndConditions"),
+		expr.Operator(">", "ValueGreaterThan_float"),
+		expr.Operator("<", "ValueLessThan_float"),
+	}
+
+	program, err := expr.Compile(code, opt...)
+	assert.Nil(t, err)
+
+	state, err := expr.Run(program, p)
+	assert.Nil(t, err)
+	assert.NotNil(t, state)
+}
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index e17c5fd66..99817effb 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -216,3 +216,40 @@ func TestOperator_Polymorphic(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, 6, output)
 }
+
+func TestOperator_recursive_apply(t *testing.T) {
+	type Decimal struct {
+		Int int
+	}
+
+	env := map[string]any{
+		"add": func(a, b Decimal) Decimal {
+			return Decimal{
+				Int: a.Int + b.Int,
+			}
+		},
+		"addInt": func(a Decimal, b int) Decimal {
+			return Decimal{
+				Int: a.Int + b,
+			}
+		},
+		"a": Decimal{1},
+		"b": Decimal{2},
+		"c": Decimal{3},
+		"d": Decimal{4},
+		"e": Decimal{5},
+	}
+
+	program, err := expr.Compile(
+		`a + b + 100 + c + d + e`,
+		expr.Env(env),
+		expr.Operator("+", "add"),
+		expr.Operator("+", "addInt"),
+	)
+	require.NoError(t, err)
+	require.Equal(t, `add(add(add(addInt(add(a, b), 100), c), d), e)`, program.Node().String())
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 115, output.(Decimal).Int)
+}

From 323873a0f4b71f3d799a1626ba07f148bcb140cd Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 18 Feb 2024 09:45:39 +0100
Subject: [PATCH 275/506] Add quotes to error message

---
 patcher/operator_override.go   | 4 ++--
 test/operator/operator_test.go | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/patcher/operator_override.go b/patcher/operator_override.go
index 96e6894cc..428454f5b 100644
--- a/patcher/operator_override.go
+++ b/patcher/operator_override.go
@@ -131,11 +131,11 @@ func checkType(fnType conf.Tag, fn string, operator string) {
 
 func checkFunc(fn *builtin.Function, name string, operator string) {
 	if len(fn.Types) == 0 {
-		panic(fmt.Errorf("function %s for %s operator misses types", name, operator))
+		panic(fmt.Errorf("function %q for %q operator misses types", name, operator))
 	}
 	for _, t := range fn.Types {
 		if t.NumIn() != 2 || t.NumOut() != 1 {
-			panic(fmt.Errorf("function %s for %s operator does not have a correct signature", name, operator))
+			panic(fmt.Errorf("function %q for %q operator does not have a correct signature", name, operator))
 		}
 	}
 }
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index 99817effb..a19c191dc 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/expr-lang/expr"
@@ -108,7 +109,7 @@ func TestOperator_Function_WithTypes(t *testing.T) {
 		"bar": Value{2},
 	}
 
-	require.PanicsWithError(t, `function Add for + operator misses types`, func() {
+	assert.PanicsWithError(t, `function "Add" for "+" operator misses types`, func() {
 		_, _ = expr.Compile(
 			`foo + bar`,
 			expr.Env(env),
@@ -119,7 +120,7 @@ func TestOperator_Function_WithTypes(t *testing.T) {
 		)
 	})
 
-	require.PanicsWithError(t, `function Add for + operator does not have a correct signature`, func() {
+	assert.PanicsWithError(t, `function "Add" for "+" operator does not have a correct signature`, func() {
 		_, _ = expr.Compile(
 			`foo + bar`,
 			expr.Env(env),
@@ -131,7 +132,6 @@ func TestOperator_Function_WithTypes(t *testing.T) {
 			),
 		)
 	})
-
 }
 
 func TestOperator_FunctionOverTypesPrecedence(t *testing.T) {

From 3196510a3db4568803e37d1447832c16a40821a4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 18 Feb 2024 09:55:10 +0100
Subject: [PATCH 276/506] Fix naming

---
 expr.go                      |  4 ++--
 patcher/operator_override.go | 26 +++++++++++++-------------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/expr.go b/expr.go
index d9f7c0dc3..ba786c017 100644
--- a/expr.go
+++ b/expr.go
@@ -42,9 +42,9 @@ func AllowUndefinedVariables() Option {
 // Operator allows to replace a binary operator with a function.
 func Operator(operator string, fn ...string) Option {
 	return func(c *conf.Config) {
-		p := &patcher.OperatorOverride{
+		p := &patcher.OperatorOverloading{
 			Operator:  operator,
-			Overrides: fn,
+			Overloads: fn,
 			Types:     c.Types,
 			Functions: c.Functions,
 		}
diff --git a/patcher/operator_override.go b/patcher/operator_override.go
index 428454f5b..551fe09bb 100644
--- a/patcher/operator_override.go
+++ b/patcher/operator_override.go
@@ -9,15 +9,15 @@ import (
 	"github.com/expr-lang/expr/conf"
 )
 
-type OperatorOverride struct {
-	Operator  string              // Operator token to override.
-	Overrides []string            // List of function names to override operator with.
+type OperatorOverloading struct {
+	Operator  string              // Operator token to overload.
+	Overloads []string            // List of function names to replace operator with.
 	Types     conf.TypesTable     // Env types.
 	Functions conf.FunctionsTable // Env functions.
-	applied   bool                // Flag to indicate if any override was applied.
+	applied   bool                // Flag to indicate if any changes were made to the tree.
 }
 
-func (p *OperatorOverride) Visit(node *ast.Node) {
+func (p *OperatorOverloading) Visit(node *ast.Node) {
 	binaryNode, ok := (*node).(*ast.BinaryNode)
 	if !ok {
 		return
@@ -42,11 +42,11 @@ func (p *OperatorOverride) Visit(node *ast.Node) {
 	}
 }
 
-func (p *OperatorOverride) ShouldRepeat() bool {
+func (p *OperatorOverloading) ShouldRepeat() bool {
 	return p.applied
 }
 
-func (p *OperatorOverride) FindSuitableOperatorOverload(l, r reflect.Type) (reflect.Type, string, bool) {
+func (p *OperatorOverloading) FindSuitableOperatorOverload(l, r reflect.Type) (reflect.Type, string, bool) {
 	t, fn, ok := p.findSuitableOperatorOverloadInFunctions(l, r)
 	if !ok {
 		t, fn, ok = p.findSuitableOperatorOverloadInTypes(l, r)
@@ -54,8 +54,8 @@ func (p *OperatorOverride) FindSuitableOperatorOverload(l, r reflect.Type) (refl
 	return t, fn, ok
 }
 
-func (p *OperatorOverride) findSuitableOperatorOverloadInTypes(l, r reflect.Type) (reflect.Type, string, bool) {
-	for _, fn := range p.Overrides {
+func (p *OperatorOverloading) findSuitableOperatorOverloadInTypes(l, r reflect.Type) (reflect.Type, string, bool) {
+	for _, fn := range p.Overloads {
 		fnType, ok := p.Types[fn]
 		if !ok {
 			continue
@@ -72,8 +72,8 @@ func (p *OperatorOverride) findSuitableOperatorOverloadInTypes(l, r reflect.Type
 	return nil, "", false
 }
 
-func (p *OperatorOverride) findSuitableOperatorOverloadInFunctions(l, r reflect.Type) (reflect.Type, string, bool) {
-	for _, fn := range p.Overrides {
+func (p *OperatorOverloading) findSuitableOperatorOverloadInFunctions(l, r reflect.Type) (reflect.Type, string, bool) {
+	for _, fn := range p.Overloads {
 		fnType, ok := p.Functions[fn]
 		if !ok {
 			continue
@@ -101,8 +101,8 @@ func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex
 	return nil, false
 }
 
-func (p *OperatorOverride) Check() {
-	for _, fn := range p.Overrides {
+func (p *OperatorOverloading) Check() {
+	for _, fn := range p.Overloads {
 		fnType, foundType := p.Types[fn]
 		fnFunc, foundFunc := p.Functions[fn]
 		if !foundFunc && (!foundType || fnType.Type.Kind() != reflect.Func) {

From 6cc56e7068129ed927c1f7eeca7d780f66f04a92 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 21 Feb 2024 00:07:51 +0100
Subject: [PATCH 277/506] Remove redundant checks

---
 vm/runtime/runtime.go | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index d54152117..7da1320de 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -80,11 +80,9 @@ type Field struct {
 
 func FetchField(from any, field *Field) any {
 	v := reflect.ValueOf(from)
-	kind := v.Kind()
-	if kind != reflect.Invalid {
-		if kind == reflect.Ptr {
-			v = reflect.Indirect(v)
-		}
+	if v.Kind() != reflect.Invalid {
+		v = reflect.Indirect(v)
+
 		// We can use v.FieldByIndex here, but it will panic if the field
 		// is not exists. And we need to recover() to generate a more
 		// user-friendly error message.

From ae180c8f7deaab0ce41bbea10dccc1d17737abe2 Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Sun, 25 Feb 2024 01:42:51 +0530
Subject: [PATCH 278/506] Enhanced min and max built-in functions to Support
 Arrays of Integers and Floats (#576)

* Enhanced min and max built-in functions to Support Arrays of Integers and Floats

* Enhanced min and max built-in functions to Support Arrays of Integers and Floats
---
 builtin/builtin.go      | 51 ++++++++++++++++++++++++++---------------
 builtin/builtin_test.go |  8 +++++++
 builtin/lib.go          | 45 +++++++++++++++++++++++++++---------
 expr_test.go            | 16 +++++++++++++
 testdata/examples.txt   |  2 +-
 5 files changed, 92 insertions(+), 30 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 4aad6aa9c..fc48e111a 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -394,38 +394,53 @@ var Builtins = []*Function{
 		Name: "max",
 		Func: Max,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) == 0 {
+			switch len(args) {
+			case 0:
 				return anyType, fmt.Errorf("not enough arguments to call max")
-			}
-			for _, arg := range args {
-				switch kind(arg) {
-				case reflect.Interface:
+			case 1:
+				if kindName := kind(args[0]); kindName == reflect.Array || kindName == reflect.Slice {
 					return anyType, nil
-				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
-				default:
-					return anyType, fmt.Errorf("invalid argument for max (type %s)", arg)
 				}
+				fallthrough
+			default:
+				for _, arg := range args {
+					switch kind(arg) {
+					case reflect.Interface, reflect.Array, reflect.Slice:
+						return anyType, nil
+					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
+					default:
+						return anyType, fmt.Errorf("invalid argument for max (type %s)", arg)
+					}
+				}
+				return args[0], nil
 			}
-			return args[0], nil
 		},
 	},
 	{
 		Name: "min",
 		Func: Min,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) == 0 {
+			switch len(args) {
+			case 0:
 				return anyType, fmt.Errorf("not enough arguments to call min")
-			}
-			for _, arg := range args {
-				switch kind(arg) {
-				case reflect.Interface:
+			case 1:
+				if kindName := kind(args[0]); kindName == reflect.Array || kindName == reflect.Slice {
 					return anyType, nil
-				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
-				default:
-					return anyType, fmt.Errorf("invalid argument for min (type %s)", arg)
 				}
+				fallthrough
+			default:
+				for _, arg := range args {
+					switch kind(arg) {
+					case reflect.Interface, reflect.Array, reflect.Slice:
+						return anyType, nil
+					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
+					default:
+						return anyType, fmt.Errorf("invalid argument for min (type %s)", arg)
+					}
+				}
+				return args[0], nil
+
 			}
-			return args[0], nil
 		},
 	},
 	{
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 3a2850071..bc1a2e149 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -77,8 +77,14 @@ func TestBuiltin(t *testing.T) {
 		{`hasSuffix("foo,bar,baz", "baz")`, true},
 		{`max(1, 2, 3)`, 3},
 		{`max(1.5, 2.5, 3.5)`, 3.5},
+		{`max([1, 2, 3])`, 3},
+		{`max([1.5, 2.5, 3.5])`, 3.5},
+		{`max([1, 2, 4, 10], 20, [29, 23, -19])`, 29},
+		{`min([1, 2, 4, 10], 20, [29, 23, -19])`, -19},
 		{`min(1, 2, 3)`, 1},
 		{`min(1.5, 2.5, 3.5)`, 1.5},
+		{`min([1, 2, 3])`, 1},
+		{`min([1.5, 2.5, 3.5])`, 1.5},
 		{`sum(1..9)`, 45},
 		{`sum([.5, 1.5, 2.5])`, 4.5},
 		{`sum([])`, 0},
@@ -197,8 +203,10 @@ func TestBuiltin_errors(t *testing.T) {
 		{`trim()`, `not enough arguments to call trim`},
 		{`max()`, `not enough arguments to call max`},
 		{`max(1, "2")`, `invalid argument for max (type string)`},
+		{`max([1, "2"])`, `invalid argument for max (type string)`},
 		{`min()`, `not enough arguments to call min`},
 		{`min(1, "2")`, `invalid argument for min (type string)`},
+		{`min([1, "2"])`, `invalid argument for min (type string)`},
 		{`duration("error")`, `invalid duration`},
 		{`date("error")`, `invalid date`},
 		{`get()`, `invalid number of arguments (expected 2, got 0)`},
diff --git a/builtin/lib.go b/builtin/lib.go
index 00b4c9210..b08c2ed2b 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -255,21 +255,44 @@ func String(arg any) any {
 }
 
 func Max(args ...any) (any, error) {
-	var max any
-	for _, arg := range args {
-		if max == nil || runtime.Less(max, arg) {
-			max = arg
-		}
-	}
-	return max, nil
+	return minMaxFunc("max", runtime.Less, args)
 }
 
 func Min(args ...any) (any, error) {
-	var min any
+	return minMaxFunc("min", runtime.More, args)
+}
+
+func minMaxFunc(name string, fn func(any, any) bool, args []any) (any, error) {
+	var val any
 	for _, arg := range args {
-		if min == nil || runtime.More(min, arg) {
-			min = arg
+		switch v := arg.(type) {
+		case []float32, []float64, []uint, []uint8, []uint16, []uint32, []uint64, []int, []int8, []int16, []int32, []int64:
+			rv := reflect.ValueOf(v)
+			if rv.Len() == 0 {
+				return nil, fmt.Errorf("not enough arguments to call %s", name)
+			}
+			arg = rv.Index(0).Interface()
+			for i := 1; i < rv.Len(); i++ {
+				elem := rv.Index(i).Interface()
+				if fn(arg, elem) {
+					arg = elem
+				}
+			}
+		case []any:
+			var err error
+			if arg, err = minMaxFunc(name, fn, v); err != nil {
+				return nil, err
+			}
+		case float32, float64, uint, uint8, uint16, uint32, uint64, int, int8, int16, int32, int64:
+		default:
+			if len(args) == 1 {
+				return arg, nil
+			}
+			return nil, fmt.Errorf("invalid argument for %s (type %T)", name, v)
+		}
+		if val == nil || fn(val, arg) {
+			val = arg
 		}
 	}
-	return min, nil
+	return val, nil
 }
diff --git a/expr_test.go b/expr_test.go
index ed08cae53..74975362b 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -853,6 +853,22 @@ func TestExpr(t *testing.T) {
 			`len({a: 1, b: 2, c: 2})`,
 			3,
 		},
+		{
+			`max([1, 2, 3])`,
+			3,
+		},
+		{
+			`max(1, 2, 3)`,
+			3,
+		},
+		{
+			`min([1, 2, 3])`,
+			1,
+		},
+		{
+			`min(1, 2, 3)`,
+			1,
+		},
 		{
 			`{foo: 0, bar: 1}`,
 			map[string]any{"foo": 0, "bar": 1},
diff --git a/testdata/examples.txt b/testdata/examples.txt
index 9abe85327..712aa91c0 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -13822,7 +13822,7 @@ min(ok ? array : false)
 min(ok ? f64 : i)
 min(ok ? half : ok)
 min(ok ? i : f32)
-min(ok ? list : score)
+min(ok ? array : score)
 min(ok ? true : div)
 min(reduce(array, #))
 min(reduce(array, 0.5))

From 2347a4e3f2ca6349d3154c135a090a6834023b22 Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Tue, 27 Feb 2024 20:23:49 +0700
Subject: [PATCH 279/506] Support chzained comparisonc`1 < 2 < 3` (#581)

---
 expr_test.go                | 20 +++++++++++++
 parser/operator/operator.go |  4 +++
 parser/parser.go            | 36 ++++++++++++++++++++++
 parser/parser_test.go       | 60 +++++++++++++++++++++++++++++++++++++
 4 files changed, 120 insertions(+)

diff --git a/expr_test.go b/expr_test.go
index 74975362b..9d9d88af9 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1253,6 +1253,26 @@ func TestExpr(t *testing.T) {
 			`[nil, 3, 4]?.[0]?.[1]`,
 			nil,
 		},
+		{
+			`1 > 2 < 3`,
+			false,
+		},
+		{
+			`1 < 2 < 3`,
+			true,
+		},
+		{
+			`1 < 2 < 3 > 4`,
+			false,
+		},
+		{
+			`1 < 2 < 3 > 2`,
+			true,
+		},
+		{
+			`1 < 2 < 3 == true`,
+			true,
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/parser/operator/operator.go b/parser/operator/operator.go
index 8d804c7b3..411a0e2bc 100644
--- a/parser/operator/operator.go
+++ b/parser/operator/operator.go
@@ -54,3 +54,7 @@ var Binary = map[string]Operator{
 	"^":          {100, Right},
 	"??":         {500, Left},
 }
+
+func IsComparison(op string) bool {
+	return op == "<" || op == ">" || op == ">=" || op == "<="
+}
diff --git a/parser/parser.go b/parser/parser.go
index 1eabdebe2..9114bc0c9 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -164,6 +164,11 @@ func (p *parser) parseExpression(precedence int) Node {
 					break
 				}
 
+				if operator.IsComparison(opToken.Value) {
+					nodeLeft = p.parseComparison(nodeLeft, opToken, op.Precedence)
+					goto next
+				}
+
 				var nodeRight Node
 				if op.Associativity == operator.Left {
 					nodeRight = p.parseExpression(op.Precedence + 1)
@@ -685,3 +690,34 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 	}
 	return node
 }
+
+func (p *parser) parseComparison(left Node, token Token, precedence int) Node {
+	var rootNode Node
+	for {
+		comparator := p.parseExpression(precedence + 1)
+		cmpNode := &BinaryNode{
+			Operator: token.Value,
+			Left:     left,
+			Right:    comparator,
+		}
+		cmpNode.SetLocation(token.Location)
+		if rootNode == nil {
+			rootNode = cmpNode
+		} else {
+			rootNode = &BinaryNode{
+				Operator: "&&",
+				Left:     rootNode,
+				Right:    cmpNode,
+			}
+			rootNode.SetLocation(token.Location)
+		}
+
+		left = comparator
+		token = p.current
+		if !(token.Is(Operator) && operator.IsComparison(token.Value) && p.err == nil) {
+			break
+		}
+		p.next()
+	}
+	return rootNode
+}
diff --git a/parser/parser_test.go b/parser/parser_test.go
index b633bd52e..9225e1028 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -531,6 +531,66 @@ world`},
 				To:   &IntegerNode{Value: 3},
 			},
 		},
+		{
+			`1 < 2 > 3`,
+			&BinaryNode{
+				Operator: "&&",
+				Left: &BinaryNode{
+					Operator: "<",
+					Left:     &IntegerNode{Value: 1},
+					Right:    &IntegerNode{Value: 2},
+				},
+				Right: &BinaryNode{
+					Operator: ">",
+					Left:     &IntegerNode{Value: 2},
+					Right:    &IntegerNode{Value: 3},
+				},
+			},
+		},
+		{
+			`1 < 2 < 3 < 4`,
+			&BinaryNode{
+				Operator: "&&",
+				Left: &BinaryNode{
+					Operator: "&&",
+					Left: &BinaryNode{
+						Operator: "<",
+						Left:     &IntegerNode{Value: 1},
+						Right:    &IntegerNode{Value: 2},
+					},
+					Right: &BinaryNode{
+						Operator: "<",
+						Left:     &IntegerNode{Value: 2},
+						Right:    &IntegerNode{Value: 3},
+					},
+				},
+				Right: &BinaryNode{
+					Operator: "<",
+					Left:     &IntegerNode{Value: 3},
+					Right:    &IntegerNode{Value: 4},
+				},
+			},
+		},
+		{
+			`1 < 2 < 3 == true`,
+			&BinaryNode{
+				Operator: "==",
+				Left: &BinaryNode{
+					Operator: "&&",
+					Left: &BinaryNode{
+						Operator: "<",
+						Left:     &IntegerNode{Value: 1},
+						Right:    &IntegerNode{Value: 2},
+					},
+					Right: &BinaryNode{
+						Operator: "<",
+						Left:     &IntegerNode{Value: 2},
+						Right:    &IntegerNode{Value: 3},
+					},
+				},
+				Right: &BoolNode{Value: true},
+			},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {

From f1b68c877d52fe7e5ca985055e113c9a519bb57c Mon Sep 17 00:00:00 2001
From: bizy <bizywiz@gmail.com>
Date: Wed, 28 Feb 2024 00:30:33 +0700
Subject: [PATCH 280/506] Compare `any` arrays

---
 expr_test.go                     |  26 +++
 vm/runtime/helpers/main.go       |  46 +++++
 vm/runtime/helpers[generated].go | 343 +++++++++++++++++++++++++++++++
 3 files changed, 415 insertions(+)

diff --git a/expr_test.go b/expr_test.go
index 74975362b..ea9213be2 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2482,3 +2482,29 @@ func TestRaceCondition_variables(t *testing.T) {
 
 	wg.Wait()
 }
+
+func TestArrayComparison(t *testing.T) {
+	tests := []struct {
+		env  any
+		code string
+	}{
+		{[]string{"A", "B"}, "foo == ['A', 'B']"},
+		{[]int{1, 2}, "foo == [1, 2]"},
+		{[]uint8{1, 2}, "foo == [1, 2]"},
+		{[]float64{1.1, 2.2}, "foo == [1.1, 2.2]"},
+		{[]any{"A", 1, 1.1, true}, "foo == ['A', 1, 1.1, true]"},
+		{[]string{"A", "B"}, "foo != [1, 2]"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			env := map[string]any{"foo": tt.env}
+			program, err := expr.Compile(tt.code, expr.Env(env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, env)
+			require.NoError(t, err)
+			require.Equal(t, true, out)
+		})
+	}
+}
diff --git a/vm/runtime/helpers/main.go b/vm/runtime/helpers/main.go
index b3f598a43..54a4fc235 100644
--- a/vm/runtime/helpers/main.go
+++ b/vm/runtime/helpers/main.go
@@ -19,6 +19,7 @@ func main() {
 				"cases_with_duration": func(op string) string {
 					return cases(op, uints, ints, floats, []string{"time.Duration"})
 				},
+				"array_equal_cases": func() string { return arrayEqualCases([]string{"string"}, uints, ints, floats) },
 			}).
 			Parse(helpers),
 	).Execute(&b, nil)
@@ -89,6 +90,45 @@ func cases(op string, xs ...[]string) string {
 	return strings.TrimRight(out, "\n")
 }
 
+func arrayEqualCases(xs ...[]string) string {
+	var types []string
+	for _, x := range xs {
+		types = append(types, x...)
+	}
+
+	_, _ = fmt.Fprintf(os.Stderr, "Generating array equal cases for %v\n", types)
+
+	var out string
+	echo := func(s string, xs ...any) {
+		out += fmt.Sprintf(s, xs...) + "\n"
+	}
+	echo(`case []any:`)
+	echo(`switch y := b.(type) {`)
+	for _, a := range append(types, "any") {
+		echo(`case []%v:`, a)
+		echo(`if len(x) != len(y) { return false }`)
+		echo(`for i := range x {`)
+		echo(`if !Equal(x[i], y[i]) { return false }`)
+		echo(`}`)
+		echo("return true")
+	}
+	echo(`}`)
+	for _, a := range types {
+		echo(`case []%v:`, a)
+		echo(`switch y := b.(type) {`)
+		echo(`case []any:`)
+		echo(`return Equal(y, x)`)
+		echo(`case []%v:`, a)
+		echo(`if len(x) != len(y) { return false }`)
+		echo(`for i := range x {`)
+		echo(`if x[i] != y[i] { return false }`)
+		echo(`}`)
+		echo("return true")
+		echo(`}`)
+	}
+	return strings.TrimRight(out, "\n")
+}
+
 func isFloat(t string) bool {
 	return strings.HasPrefix(t, "float")
 }
@@ -110,6 +150,7 @@ import (
 func Equal(a, b interface{}) bool {
 	switch x := a.(type) {
 	{{ cases "==" }}
+	{{ array_equal_cases }}
 	case string:
 		switch y := b.(type) {
 		case string:
@@ -125,6 +166,11 @@ func Equal(a, b interface{}) bool {
 		case time.Duration:
 			return x == y
 		}
+	case bool:
+		switch y := b.(type) {
+		case bool:
+			return x == y
+		}
 	}
 	if IsNil(a) && IsNil(b) {
 		return true
diff --git a/vm/runtime/helpers[generated].go b/vm/runtime/helpers[generated].go
index 720feb455..d950f1111 100644
--- a/vm/runtime/helpers[generated].go
+++ b/vm/runtime/helpers[generated].go
@@ -334,6 +334,344 @@ func Equal(a, b interface{}) bool {
 		case float64:
 			return float64(x) == float64(y)
 		}
+	case []any:
+		switch y := b.(type) {
+		case []string:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []uint:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []uint8:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []uint16:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []uint32:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []uint64:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []int:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []int8:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []int16:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []int32:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []int64:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []float32:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []float64:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		case []any:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if !Equal(x[i], y[i]) {
+					return false
+				}
+			}
+			return true
+		}
+	case []string:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []string:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []uint:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []uint:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []uint8:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []uint8:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []uint16:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []uint16:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []uint32:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []uint32:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []uint64:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []uint64:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []int:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []int:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []int8:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []int8:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []int16:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []int16:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []int32:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []int32:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []int64:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []int64:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []float32:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []float32:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
+	case []float64:
+		switch y := b.(type) {
+		case []any:
+			return Equal(y, x)
+		case []float64:
+			if len(x) != len(y) {
+				return false
+			}
+			for i := range x {
+				if x[i] != y[i] {
+					return false
+				}
+			}
+			return true
+		}
 	case string:
 		switch y := b.(type) {
 		case string:
@@ -349,6 +687,11 @@ func Equal(a, b interface{}) bool {
 		case time.Duration:
 			return x == y
 		}
+	case bool:
+		switch y := b.(type) {
+		case bool:
+			return x == y
+		}
 	}
 	if IsNil(a) && IsNil(b) {
 		return true

From 7795708ed42d7787f2adc172fdcfe43fd7afcda6 Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Wed, 28 Feb 2024 16:39:01 +0700
Subject: [PATCH 281/506] Equal bools without `reflect.DeepEqual` (#585)

---
 vm/runtime/helpers/main.go       | 5 +++++
 vm/runtime/helpers[generated].go | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/vm/runtime/helpers/main.go b/vm/runtime/helpers/main.go
index b3f598a43..d3b647c4a 100644
--- a/vm/runtime/helpers/main.go
+++ b/vm/runtime/helpers/main.go
@@ -125,6 +125,11 @@ func Equal(a, b interface{}) bool {
 		case time.Duration:
 			return x == y
 		}
+	case bool:
+		switch y := b.(type) {
+		case bool:
+			return x == y
+		}
 	}
 	if IsNil(a) && IsNil(b) {
 		return true
diff --git a/vm/runtime/helpers[generated].go b/vm/runtime/helpers[generated].go
index 720feb455..3529fdd58 100644
--- a/vm/runtime/helpers[generated].go
+++ b/vm/runtime/helpers[generated].go
@@ -349,6 +349,11 @@ func Equal(a, b interface{}) bool {
 		case time.Duration:
 			return x == y
 		}
+	case bool:
+		switch y := b.(type) {
+		case bool:
+			return x == y
+		}
 	}
 	if IsNil(a) && IsNil(b) {
 		return true

From adb139a4fd62f8bcebab9ba9c7d4d7d6e61e13ca Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 29 Feb 2024 20:51:34 +0100
Subject: [PATCH 282/506] Add spans

---
 compiler/compiler.go | 29 +++++++++++++++++++++++++++++
 conf/config.go       |  1 +
 vm/opcodes.go        |  2 ++
 vm/program.go        |  9 +++++++++
 vm/utils.go          | 13 +++++++++++++
 vm/vm.go             |  9 +++++++++
 6 files changed, 63 insertions(+)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index a4f189e6b..808b53c9b 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -50,6 +50,11 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		}
 	}
 
+	var span *Span
+	if len(c.spans) > 0 {
+		span = c.spans[0]
+	}
+
 	program = NewProgram(
 		tree.Source,
 		tree.Node,
@@ -60,6 +65,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		c.arguments,
 		c.functions,
 		c.debugInfo,
+		span,
 	)
 	return
 }
@@ -76,6 +82,7 @@ type compiler struct {
 	functionsIndex map[string]int
 	debugInfo      map[string]string
 	nodes          []ast.Node
+	spans          []*Span
 	chains         [][]int
 	arguments      []int
 }
@@ -193,6 +200,28 @@ func (c *compiler) compile(node ast.Node) {
 		c.nodes = c.nodes[:len(c.nodes)-1]
 	}()
 
+	if c.config != nil && c.config.Profile {
+		span := &Span{
+			Name:       reflect.TypeOf(node).String(),
+			Expression: node.String(),
+		}
+		if len(c.spans) > 0 {
+			prev := c.spans[len(c.spans)-1]
+			prev.Children = append(prev.Children, span)
+		}
+		c.spans = append(c.spans, span)
+		defer func() {
+			if len(c.spans) > 1 {
+				c.spans = c.spans[:len(c.spans)-1]
+			}
+		}()
+
+		c.emit(OpProfileStart, c.addConstant(span))
+		defer func() {
+			c.emit(OpProfileEnd, c.addConstant(span))
+		}()
+	}
+
 	switch n := node.(type) {
 	case *ast.NilNode:
 		c.NilNode(n)
diff --git a/conf/config.go b/conf/config.go
index e543732ce..799898109 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -20,6 +20,7 @@ type Config struct {
 	ExpectAny   bool
 	Optimize    bool
 	Strict      bool
+	Profile     bool
 	ConstFns    map[string]reflect.Value
 	Visitors    []ast.Visitor
 	Functions   FunctionsTable
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 0417dab61..84d751d6b 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -81,6 +81,8 @@ const (
 	OpGroupBy
 	OpSortBy
 	OpSort
+	OpProfileStart
+	OpProfileEnd
 	OpBegin
 	OpEnd // This opcode must be at the end of this list.
 )
diff --git a/vm/program.go b/vm/program.go
index 4a878267b..989546744 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -27,6 +27,7 @@ type Program struct {
 	variables int
 	functions []Function
 	debugInfo map[string]string
+	span      *Span
 }
 
 // NewProgram returns a new Program. It's used by the compiler.
@@ -40,6 +41,7 @@ func NewProgram(
 	arguments []int,
 	functions []Function,
 	debugInfo map[string]string,
+	span *Span,
 ) *Program {
 	return &Program{
 		source:    source,
@@ -51,6 +53,7 @@ func NewProgram(
 		Arguments: arguments,
 		functions: functions,
 		debugInfo: debugInfo,
+		span:      span,
 	}
 }
 
@@ -360,6 +363,12 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 		case OpSort:
 			code("OpSort")
 
+		case OpProfileStart:
+			code("OpProfileStart")
+
+		case OpProfileEnd:
+			code("OpProfileEnd")
+
 		case OpBegin:
 			code("OpBegin")
 
diff --git a/vm/utils.go b/vm/utils.go
index d7db2a52a..fc2f5e7b8 100644
--- a/vm/utils.go
+++ b/vm/utils.go
@@ -2,6 +2,7 @@ package vm
 
 import (
 	"reflect"
+	"time"
 )
 
 type (
@@ -25,3 +26,15 @@ type Scope struct {
 }
 
 type groupBy = map[any][]any
+
+type Span struct {
+	Name       string  `json:"name"`
+	Expression string  `json:"expression"`
+	Duration   int64   `json:"duration"`
+	Children   []*Span `json:"children"`
+	start      time.Time
+}
+
+func GetSpan(program *Program) *Span {
+	return program.span
+}
diff --git a/vm/vm.go b/vm/vm.go
index 1e85893b0..7e933ce74 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"time"
 
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/file"
@@ -523,6 +524,14 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.memGrow(uint(scope.Len))
 			vm.push(sortable.Array)
 
+		case OpProfileStart:
+			span := program.Constants[arg].(*Span)
+			span.start = time.Now()
+
+		case OpProfileEnd:
+			span := program.Constants[arg].(*Span)
+			span.Duration += time.Since(span.start).Nanoseconds()
+
 		case OpBegin:
 			a := vm.pop()
 			array := reflect.ValueOf(a)

From 4cdfd385dd0407717198c893913df744c5d1a744 Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Sun, 3 Mar 2024 21:14:32 +0530
Subject: [PATCH 283/506] Enable Support for Arrays in Sum, Mean, and Median
 Functions (#580)

---
 builtin/builtin.go      | 201 ++++++----------------------------------
 builtin/builtin_test.go |  13 +++
 builtin/lib.go          | 154 ++++++++++++++++++++++++------
 builtin/validation.go   |  38 ++++++++
 4 files changed, 206 insertions(+), 200 deletions(-)
 create mode 100644 builtin/validation.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index fc48e111a..7bf377df2 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -135,42 +135,21 @@ var Builtins = []*Function{
 		Name: "ceil",
 		Fast: Ceil,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
-				return floatType, nil
-			}
-			return anyType, fmt.Errorf("invalid argument for ceil (type %s)", args[0])
+			return validateRoundFunc("ceil", args)
 		},
 	},
 	{
 		Name: "floor",
 		Fast: Floor,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
-				return floatType, nil
-			}
-			return anyType, fmt.Errorf("invalid argument for floor (type %s)", args[0])
+			return validateRoundFunc("floor", args)
 		},
 	},
 	{
 		Name: "round",
 		Fast: Round,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
-				return floatType, nil
-			}
-			return anyType, fmt.Errorf("invalid argument for floor (type %s)", args[0])
+			return validateRoundFunc("round", args)
 		},
 	},
 	{
@@ -392,185 +371,63 @@ var Builtins = []*Function{
 	},
 	{
 		Name: "max",
-		Func: Max,
+		Func: func(args ...any) (any, error) {
+			return minMax("max", runtime.Less, args...)
+		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			switch len(args) {
-			case 0:
-				return anyType, fmt.Errorf("not enough arguments to call max")
-			case 1:
-				if kindName := kind(args[0]); kindName == reflect.Array || kindName == reflect.Slice {
-					return anyType, nil
-				}
-				fallthrough
-			default:
-				for _, arg := range args {
-					switch kind(arg) {
-					case reflect.Interface, reflect.Array, reflect.Slice:
-						return anyType, nil
-					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
-					default:
-						return anyType, fmt.Errorf("invalid argument for max (type %s)", arg)
-					}
-				}
-				return args[0], nil
-			}
+			return validateAggregateFunc("max", args)
 		},
 	},
 	{
 		Name: "min",
-		Func: Min,
+		Func: func(args ...any) (any, error) {
+			return minMax("min", runtime.More, args...)
+		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			switch len(args) {
-			case 0:
-				return anyType, fmt.Errorf("not enough arguments to call min")
-			case 1:
-				if kindName := kind(args[0]); kindName == reflect.Array || kindName == reflect.Slice {
-					return anyType, nil
-				}
-				fallthrough
-			default:
-				for _, arg := range args {
-					switch kind(arg) {
-					case reflect.Interface, reflect.Array, reflect.Slice:
-						return anyType, nil
-					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
-					default:
-						return anyType, fmt.Errorf("invalid argument for min (type %s)", arg)
-					}
-				}
-				return args[0], nil
-
-			}
+			return validateAggregateFunc("min", args)
 		},
 	},
 	{
 		Name: "sum",
-		Func: func(args ...any) (any, error) {
-			if len(args) != 1 {
-				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			v := reflect.ValueOf(args[0])
-			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
-				return nil, fmt.Errorf("cannot sum %s", v.Kind())
-			}
-			sum := int64(0)
-			i := 0
-			for ; i < v.Len(); i++ {
-				it := deref.Value(v.Index(i))
-				if it.CanInt() {
-					sum += it.Int()
-				} else if it.CanFloat() {
-					goto float
-				} else {
-					return nil, fmt.Errorf("cannot sum %s", it.Kind())
-				}
-			}
-			return int(sum), nil
-		float:
-			fSum := float64(sum)
-			for ; i < v.Len(); i++ {
-				it := deref.Value(v.Index(i))
-				if it.CanInt() {
-					fSum += float64(it.Int())
-				} else if it.CanFloat() {
-					fSum += it.Float()
-				} else {
-					return nil, fmt.Errorf("cannot sum %s", it.Kind())
-				}
-			}
-			return fSum, nil
-		},
+		Func: sum,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Interface, reflect.Slice, reflect.Array:
-			default:
-				return anyType, fmt.Errorf("cannot sum %s", args[0])
-			}
-			return anyType, nil
+			return validateAggregateFunc("sum", args)
 		},
 	},
 	{
 		Name: "mean",
 		Func: func(args ...any) (any, error) {
-			if len(args) != 1 {
-				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			v := reflect.ValueOf(args[0])
-			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
-				return nil, fmt.Errorf("cannot mean %s", v.Kind())
+			count, sum, err := mean(args...)
+			if err != nil {
+				return nil, err
 			}
-			if v.Len() == 0 {
+			if count == 0 {
 				return 0.0, nil
 			}
-			sum := float64(0)
-			i := 0
-			for ; i < v.Len(); i++ {
-				it := deref.Value(v.Index(i))
-				if it.CanInt() {
-					sum += float64(it.Int())
-				} else if it.CanFloat() {
-					sum += it.Float()
-				} else {
-					return nil, fmt.Errorf("cannot mean %s", it.Kind())
-				}
-			}
-			return sum / float64(i), nil
+			return sum / float64(count), nil
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Interface, reflect.Slice, reflect.Array:
-			default:
-				return anyType, fmt.Errorf("cannot avg %s", args[0])
-			}
-			return floatType, nil
+			return validateAggregateFunc("mean", args)
 		},
 	},
 	{
 		Name: "median",
 		Func: func(args ...any) (any, error) {
-			if len(args) != 1 {
-				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			v := reflect.ValueOf(args[0])
-			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
-				return nil, fmt.Errorf("cannot median %s", v.Kind())
-			}
-			if v.Len() == 0 {
-				return 0.0, nil
+			values, err := median(args...)
+			if err != nil {
+				return nil, err
 			}
-			s := make([]float64, v.Len())
-			for i := 0; i < v.Len(); i++ {
-				it := deref.Value(v.Index(i))
-				if it.CanInt() {
-					s[i] = float64(it.Int())
-				} else if it.CanFloat() {
-					s[i] = it.Float()
-				} else {
-					return nil, fmt.Errorf("cannot median %s", it.Kind())
+			if n := len(values); n > 0 {
+				sort.Float64s(values)
+				if n%2 == 1 {
+					return values[n/2], nil
 				}
+				return (values[n/2-1] + values[n/2]) / 2, nil
 			}
-			sort.Float64s(s)
-			if len(s)%2 == 0 {
-				return (s[len(s)/2-1] + s[len(s)/2]) / 2, nil
-			}
-			return s[len(s)/2], nil
+			return 0.0, nil
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Interface, reflect.Slice, reflect.Array:
-			default:
-				return anyType, fmt.Errorf("cannot median %s", args[0])
-			}
-			return floatType, nil
+			return validateAggregateFunc("median", args)
 		},
 	},
 	{
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index bc1a2e149..aa324c9be 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -85,19 +85,29 @@ func TestBuiltin(t *testing.T) {
 		{`min(1.5, 2.5, 3.5)`, 1.5},
 		{`min([1, 2, 3])`, 1},
 		{`min([1.5, 2.5, 3.5])`, 1.5},
+		{`min(-1, [1.5, 2.5, 3.5])`, -1},
 		{`sum(1..9)`, 45},
 		{`sum([.5, 1.5, 2.5])`, 4.5},
 		{`sum([])`, 0},
 		{`sum([1, 2, 3.0, 4])`, 10.0},
+		{`sum(10, [1, 2, 3], 1..9)`, 61},
+		{`sum(-10, [1, 2, 3, 4])`, 0},
+		{`sum(-10.9, [1, 2, 3, 4, 9])`, 8.1},
 		{`mean(1..9)`, 5.0},
 		{`mean([.5, 1.5, 2.5])`, 1.5},
 		{`mean([])`, 0.0},
 		{`mean([1, 2, 3.0, 4])`, 2.5},
+		{`mean(10, [1, 2, 3], 1..9)`, 4.6923076923076925},
+		{`mean(-10, [1, 2, 3, 4])`, 0.0},
+		{`mean(10.9, 1..9)`, 5.59},
 		{`median(1..9)`, 5.0},
 		{`median([.5, 1.5, 2.5])`, 1.5},
 		{`median([])`, 0.0},
 		{`median([1, 2, 3])`, 2.0},
 		{`median([1, 2, 3, 4])`, 2.5},
+		{`median(10, [1, 2, 3], 1..9)`, 4.0},
+		{`median(-10, [1, 2, 3, 4])`, 2.0},
+		{`median(1..5, 4.9)`, 3.5},
 		{`toJSON({foo: 1, bar: 2})`, "{\n  \"bar\": 2,\n  \"foo\": 1\n}"},
 		{`fromJSON("[1, 2, 3]")`, []any{1.0, 2.0, 3.0}},
 		{`toBase64("hello")`, "aGVsbG8="},
@@ -207,6 +217,9 @@ func TestBuiltin_errors(t *testing.T) {
 		{`min()`, `not enough arguments to call min`},
 		{`min(1, "2")`, `invalid argument for min (type string)`},
 		{`min([1, "2"])`, `invalid argument for min (type string)`},
+		{`median(1..9, "t")`, "invalid argument for median (type string)"},
+		{`mean("s", 1..9)`, "invalid argument for mean (type string)"},
+		{`sum("s", "h")`, "invalid argument for sum (type string)"},
 		{`duration("error")`, `invalid duration`},
 		{`date("error")`, `invalid date`},
 		{`get()`, `invalid number of arguments (expected 2, got 0)`},
diff --git a/builtin/lib.go b/builtin/lib.go
index b08c2ed2b..9ff9478aa 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -6,7 +6,7 @@ import (
 	"reflect"
 	"strconv"
 
-	"github.com/expr-lang/expr/vm/runtime"
+	"github.com/expr-lang/expr/internal/deref"
 )
 
 func Len(x any) any {
@@ -254,45 +254,143 @@ func String(arg any) any {
 	return fmt.Sprintf("%v", arg)
 }
 
-func Max(args ...any) (any, error) {
-	return minMaxFunc("max", runtime.Less, args)
-}
+func sum(args ...any) (any, error) {
+	var total int
+	var fTotal float64
+
+	for _, arg := range args {
+		rv := reflect.ValueOf(deref.Deref(arg))
 
-func Min(args ...any) (any, error) {
-	return minMaxFunc("min", runtime.More, args)
+		switch rv.Kind() {
+		case reflect.Array, reflect.Slice:
+			size := rv.Len()
+			for i := 0; i < size; i++ {
+				elemSum, err := sum(rv.Index(i).Interface())
+				if err != nil {
+					return nil, err
+				}
+				switch elemSum := elemSum.(type) {
+				case int:
+					total += elemSum
+				case float64:
+					fTotal += elemSum
+				}
+			}
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			total += int(rv.Int())
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			total += int(rv.Uint())
+		case reflect.Float32, reflect.Float64:
+			fTotal += rv.Float()
+		default:
+			return nil, fmt.Errorf("invalid argument for sum (type %T)", arg)
+		}
+	}
+
+	if fTotal != 0.0 {
+		return fTotal + float64(total), nil
+	}
+	return total, nil
 }
 
-func minMaxFunc(name string, fn func(any, any) bool, args []any) (any, error) {
+func minMax(name string, fn func(any, any) bool, args ...any) (any, error) {
 	var val any
 	for _, arg := range args {
-		switch v := arg.(type) {
-		case []float32, []float64, []uint, []uint8, []uint16, []uint32, []uint64, []int, []int8, []int16, []int32, []int64:
-			rv := reflect.ValueOf(v)
-			if rv.Len() == 0 {
-				return nil, fmt.Errorf("not enough arguments to call %s", name)
-			}
-			arg = rv.Index(0).Interface()
-			for i := 1; i < rv.Len(); i++ {
-				elem := rv.Index(i).Interface()
-				if fn(arg, elem) {
-					arg = elem
+		rv := reflect.ValueOf(deref.Deref(arg))
+		switch rv.Kind() {
+		case reflect.Array, reflect.Slice:
+			size := rv.Len()
+			for i := 0; i < size; i++ {
+				elemVal, err := minMax(name, fn, rv.Index(i).Interface())
+				if err != nil {
+					return nil, err
+				}
+				switch elemVal.(type) {
+				case int, int8, int16, int32, int64,
+					uint, uint8, uint16, uint32, uint64,
+					float32, float64:
+					if elemVal != nil && (val == nil || fn(val, elemVal)) {
+						val = elemVal
+					}
+				default:
+					return nil, fmt.Errorf("invalid argument for %s (type %T)", name, elemVal)
 				}
+
 			}
-		case []any:
-			var err error
-			if arg, err = minMaxFunc(name, fn, v); err != nil {
-				return nil, err
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+			reflect.Float32, reflect.Float64:
+			elemVal := rv.Interface()
+			if val == nil || fn(val, elemVal) {
+				val = elemVal
 			}
-		case float32, float64, uint, uint8, uint16, uint32, uint64, int, int8, int16, int32, int64:
 		default:
 			if len(args) == 1 {
-				return arg, nil
+				return args[0], nil
 			}
-			return nil, fmt.Errorf("invalid argument for %s (type %T)", name, v)
-		}
-		if val == nil || fn(val, arg) {
-			val = arg
+			return nil, fmt.Errorf("invalid argument for %s (type %T)", name, arg)
 		}
 	}
 	return val, nil
 }
+
+func mean(args ...any) (int, float64, error) {
+	var total float64
+	var count int
+
+	for _, arg := range args {
+		rv := reflect.ValueOf(deref.Deref(arg))
+		switch rv.Kind() {
+		case reflect.Array, reflect.Slice:
+			size := rv.Len()
+			for i := 0; i < size; i++ {
+				elemCount, elemSum, err := mean(rv.Index(i).Interface())
+				if err != nil {
+					return 0, 0, err
+				}
+				total += elemSum
+				count += elemCount
+			}
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			total += float64(rv.Int())
+			count++
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			total += float64(rv.Uint())
+			count++
+		case reflect.Float32, reflect.Float64:
+			total += rv.Float()
+			count++
+		default:
+			return 0, 0, fmt.Errorf("invalid argument for mean (type %T)", arg)
+		}
+	}
+	return count, total, nil
+}
+
+func median(args ...any) ([]float64, error) {
+	var values []float64
+
+	for _, arg := range args {
+		rv := reflect.ValueOf(deref.Deref(arg))
+		switch rv.Kind() {
+		case reflect.Array, reflect.Slice:
+			size := rv.Len()
+			for i := 0; i < size; i++ {
+				elems, err := median(rv.Index(i).Interface())
+				if err != nil {
+					return nil, err
+				}
+				values = append(values, elems...)
+			}
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			values = append(values, float64(rv.Int()))
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			values = append(values, float64(rv.Uint()))
+		case reflect.Float32, reflect.Float64:
+			values = append(values, rv.Float())
+		default:
+			return nil, fmt.Errorf("invalid argument for median (type %T)", arg)
+		}
+	}
+	return values, nil
+}
diff --git a/builtin/validation.go b/builtin/validation.go
new file mode 100644
index 000000000..057f247e9
--- /dev/null
+++ b/builtin/validation.go
@@ -0,0 +1,38 @@
+package builtin
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/expr-lang/expr/internal/deref"
+)
+
+func validateAggregateFunc(name string, args []reflect.Type) (reflect.Type, error) {
+	switch len(args) {
+	case 0:
+		return anyType, fmt.Errorf("not enough arguments to call %s", name)
+	default:
+		for _, arg := range args {
+			switch kind(deref.Type(arg)) {
+			case reflect.Interface, reflect.Array, reflect.Slice:
+				return anyType, nil
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
+			default:
+				return anyType, fmt.Errorf("invalid argument for %s (type %s)", name, arg)
+			}
+		}
+		return args[0], nil
+	}
+}
+
+func validateRoundFunc(name string, args []reflect.Type) (reflect.Type, error) {
+	if len(args) != 1 {
+		return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+	}
+	switch kind(args[0]) {
+	case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
+		return floatType, nil
+	default:
+		return anyType, fmt.Errorf("invalid argument for %s (type %s)", name, args[0])
+	}
+}

From 85b178c3dfa2ded602d1319f13729f5c5041345a Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Mon, 4 Mar 2024 19:10:33 +0530
Subject: [PATCH 284/506] Fix `-1 not in []` expressions (#590)

---
 compiler/compiler_test.go   | 33 +++++++++++++
 expr_test.go                |  8 +++
 parser/operator/operator.go |  9 ++++
 parser/parser.go            | 99 ++++++++++++++++++++-----------------
 parser/parser_test.go       | 61 +++++++++++++++++++++++
 5 files changed, 164 insertions(+), 46 deletions(-)

diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index 741142a77..fbd83ec86 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -541,6 +541,39 @@ func TestCompile_optimizes_jumps(t *testing.T) {
 				{vm.OpFetch, 0},
 			},
 		},
+		{
+			`-1 not in [1, 2, 5]`,
+			[]op{
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpIn, 0},
+				{vm.OpNot, 0},
+			},
+		},
+		{
+			`1 + 8 not in [1, 2, 5]`,
+			[]op{
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpIn, 0},
+				{vm.OpNot, 0},
+			},
+		},
+		{
+			`true ? false : 8 not in [1, 2, 5]`,
+			[]op{
+				{vm.OpTrue, 0},
+				{vm.OpJumpIfFalse, 3},
+				{vm.OpPop, 0},
+				{vm.OpFalse, 0},
+				{vm.OpJump, 5},
+				{vm.OpPop, 0},
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpIn, 0},
+				{vm.OpNot, 0},
+			},
+		},
 	}
 
 	for _, test := range tests {
diff --git a/expr_test.go b/expr_test.go
index 9d9d88af9..92343e22e 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -785,6 +785,10 @@ func TestExpr(t *testing.T) {
 			`Two not    in 0..1`,
 			true,
 		},
+		{
+			`-1 not in [1]`,
+			true,
+		},
 		{
 			`Int32 in [10, 20]`,
 			false,
@@ -797,6 +801,10 @@ func TestExpr(t *testing.T) {
 			`String matches ("^" + String + "$")`,
 			true,
 		},
+		{
+			`'foo' + 'bar' not matches 'foobar'`,
+			false,
+		},
 		{
 			`"foobar" contains "bar"`,
 			true,
diff --git a/parser/operator/operator.go b/parser/operator/operator.go
index 411a0e2bc..4eeaf80ed 100644
--- a/parser/operator/operator.go
+++ b/parser/operator/operator.go
@@ -20,6 +20,15 @@ func IsBoolean(op string) bool {
 	return op == "and" || op == "or" || op == "&&" || op == "||"
 }
 
+func AllowedNegateSuffix(op string) bool {
+	switch op {
+	case "contains", "matches", "startsWith", "endsWith", "in":
+		return true
+	default:
+		return false
+	}
+}
+
 var Unary = map[string]Operator{
 	"not": {50, Left},
 	"!":   {50, Left},
diff --git a/parser/parser.go b/parser/parser.go
index 9114bc0c9..9cb79cbbb 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -126,10 +126,8 @@ func (p *parser) expect(kind Kind, values ...string) {
 // parse functions
 
 func (p *parser) parseExpression(precedence int) Node {
-	if precedence == 0 {
-		if p.current.Is(Operator, "let") {
-			return p.parseVariableDeclaration()
-		}
+	if precedence == 0 && p.current.Is(Operator, "let") {
+		return p.parseVariableDeclaration()
 	}
 
 	nodeLeft := p.parsePrimary()
@@ -137,62 +135,71 @@ func (p *parser) parseExpression(precedence int) Node {
 	prevOperator := ""
 	opToken := p.current
 	for opToken.Is(Operator) && p.err == nil {
-		negate := false
+		negate := opToken.Is(Operator, "not")
 		var notToken Token
 
 		// Handle "not *" operator, like "not in" or "not contains".
-		if opToken.Is(Operator, "not") {
+		if negate {
+			currentPos := p.pos
 			p.next()
-			notToken = p.current
-			negate = true
-			opToken = p.current
+			if operator.AllowedNegateSuffix(p.current.Value) {
+				if op, ok := operator.Binary[p.current.Value]; ok && op.Precedence >= precedence {
+					notToken = p.current
+					opToken = p.current
+				} else {
+					p.pos = currentPos
+					p.current = opToken
+					break
+				}
+			} else {
+				p.error("unexpected token %v", p.current)
+				break
+			}
 		}
 
-		if op, ok := operator.Binary[opToken.Value]; ok {
-			if op.Precedence >= precedence {
-				p.next()
+		if op, ok := operator.Binary[opToken.Value]; ok && op.Precedence >= precedence {
+			p.next()
 
-				if opToken.Value == "|" {
-					identToken := p.current
-					p.expect(Identifier)
-					nodeLeft = p.parseCall(identToken, []Node{nodeLeft}, true)
-					goto next
-				}
+			if opToken.Value == "|" {
+				identToken := p.current
+				p.expect(Identifier)
+				nodeLeft = p.parseCall(identToken, []Node{nodeLeft}, true)
+				goto next
+			}
 
-				if prevOperator == "??" && opToken.Value != "??" && !opToken.Is(Bracket, "(") {
-					p.errorAt(opToken, "Operator (%v) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses.", opToken.Value)
-					break
-				}
+			if prevOperator == "??" && opToken.Value != "??" && !opToken.Is(Bracket, "(") {
+				p.errorAt(opToken, "Operator (%v) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses.", opToken.Value)
+				break
+			}
 
-				if operator.IsComparison(opToken.Value) {
-					nodeLeft = p.parseComparison(nodeLeft, opToken, op.Precedence)
-					goto next
-				}
+			if operator.IsComparison(opToken.Value) {
+				nodeLeft = p.parseComparison(nodeLeft, opToken, op.Precedence)
+				goto next
+			}
 
-				var nodeRight Node
-				if op.Associativity == operator.Left {
-					nodeRight = p.parseExpression(op.Precedence + 1)
-				} else {
-					nodeRight = p.parseExpression(op.Precedence)
-				}
+			var nodeRight Node
+			if op.Associativity == operator.Left {
+				nodeRight = p.parseExpression(op.Precedence + 1)
+			} else {
+				nodeRight = p.parseExpression(op.Precedence)
+			}
 
-				nodeLeft = &BinaryNode{
-					Operator: opToken.Value,
-					Left:     nodeLeft,
-					Right:    nodeRight,
-				}
-				nodeLeft.SetLocation(opToken.Location)
+			nodeLeft = &BinaryNode{
+				Operator: opToken.Value,
+				Left:     nodeLeft,
+				Right:    nodeRight,
+			}
+			nodeLeft.SetLocation(opToken.Location)
 
-				if negate {
-					nodeLeft = &UnaryNode{
-						Operator: "not",
-						Node:     nodeLeft,
-					}
-					nodeLeft.SetLocation(notToken.Location)
+			if negate {
+				nodeLeft = &UnaryNode{
+					Operator: "not",
+					Node:     nodeLeft,
 				}
-
-				goto next
+				nodeLeft.SetLocation(notToken.Location)
 			}
+
+			goto next
 		}
 		break
 
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 9225e1028..2a30787a0 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -365,6 +365,62 @@ world`},
 			&UnaryNode{Operator: "not",
 				Node: &IdentifierNode{Value: "in_var"}},
 		},
+		{
+			"-1 not in [1, 2, 3, 4]",
+			&UnaryNode{Operator: "not",
+				Node: &BinaryNode{Operator: "in",
+					Left: &UnaryNode{Operator: "-", Node: &IntegerNode{Value: 1}},
+					Right: &ArrayNode{Nodes: []Node{
+						&IntegerNode{Value: 1},
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3},
+						&IntegerNode{Value: 4},
+					}}}},
+		},
+		{
+			"1*8 not in [1, 2, 3, 4]",
+			&UnaryNode{Operator: "not",
+				Node: &BinaryNode{Operator: "in",
+					Left: &BinaryNode{Operator: "*",
+						Left:  &IntegerNode{Value: 1},
+						Right: &IntegerNode{Value: 8},
+					},
+					Right: &ArrayNode{Nodes: []Node{
+						&IntegerNode{Value: 1},
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3},
+						&IntegerNode{Value: 4},
+					}}}},
+		},
+		{
+			"2==2 ? false : 3 not in [1, 2, 5]",
+			&ConditionalNode{
+				Cond: &BinaryNode{
+					Operator: "==",
+					Left:     &IntegerNode{Value: 2},
+					Right:    &IntegerNode{Value: 2},
+				},
+				Exp1: &BoolNode{Value: false},
+				Exp2: &UnaryNode{
+					Operator: "not",
+					Node: &BinaryNode{
+						Operator: "in",
+						Left:     &IntegerNode{Value: 3},
+						Right: &ArrayNode{Nodes: []Node{
+							&IntegerNode{Value: 1},
+							&IntegerNode{Value: 2},
+							&IntegerNode{Value: 5},
+						}}}}},
+		},
+		{
+			"'foo' + 'bar' not matches 'foobar'",
+			&UnaryNode{Operator: "not",
+				Node: &BinaryNode{Operator: "matches",
+					Left: &BinaryNode{Operator: "+",
+						Left:  &StringNode{Value: "foo"},
+						Right: &StringNode{Value: "bar"}},
+					Right: &StringNode{Value: "foobar"}}},
+		},
 		{
 			"all(Tickets, #)",
 			&BuiltinNode{
@@ -706,6 +762,11 @@ invalid float literal: strconv.ParseFloat: parsing "0o1E+1": invalid syntax (1:6
 invalid float literal: strconv.ParseFloat: parsing "1E": invalid syntax (1:2)
  | 1E
  | .^
+
+1 not == [1, 2, 5]
+unexpected token Operator("==") (1:7)
+ | 1 not == [1, 2, 5]
+ | ......^
 `
 
 func TestParse_error(t *testing.T) {

From ef57900b163f64429fa82a542fe5662e3b41ef1e Mon Sep 17 00:00:00 2001
From: bizy <bizywiz@gmail.com>
Date: Tue, 5 Mar 2024 01:11:10 +0700
Subject: [PATCH 285/506] Add bench and tests for `runtime.Equal`

---
 vm/runtime/helpers_test.go | 57 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 vm/runtime/helpers_test.go

diff --git a/vm/runtime/helpers_test.go b/vm/runtime/helpers_test.go
new file mode 100644
index 000000000..42a0aece0
--- /dev/null
+++ b/vm/runtime/helpers_test.go
@@ -0,0 +1,57 @@
+package runtime_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr/vm/runtime"
+	"github.com/stretchr/testify/assert"
+)
+
+var tests = []struct {
+	name string
+	a, b any
+	want bool
+}{
+	{"int == int", 42, 42, true},
+	{"int != int", 42, 33, false},
+	{"int == int8", 42, int8(42), true},
+	{"int == int16", 42, int16(42), true},
+	{"int == int32", 42, int32(42), true},
+	{"int == int64", 42, int64(42), true},
+	{"float == float", 42.0, 42.0, true},
+	{"float != float", 42.0, 33.0, false},
+	{"float == int", 42.0, 42, true},
+	{"float != int", 42.0, 33, false},
+	{"string == string", "foo", "foo", true},
+	{"string != string", "foo", "bar", false},
+	{"bool == bool", true, true, true},
+	{"bool != bool", true, false, false},
+	{"[]any == []int", []any{1, 2, 3}, []int{1, 2, 3}, true},
+	{"[]any != []int", []any{1, 2, 3}, []int{1, 2, 99}, false},
+	{"deep []any == []any", []any{[]int{1}, 2, []any{"3"}}, []any{[]any{1}, 2, []string{"3"}}, true},
+	{"deep []any != []any", []any{[]int{1}, 2, []any{"3", "42"}}, []any{[]any{1}, 2, []string{"3"}}, false},
+	{"map[string]any == map[string]any", map[string]any{"a": 1}, map[string]any{"a": 1}, true},
+	{"map[string]any != map[string]any", map[string]any{"a": 1}, map[string]any{"a": 1, "b": 2}, false},
+}
+
+func TestEqual(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := runtime.Equal(tt.a, tt.b)
+			assert.Equal(t, tt.want, got, "Equal(%v, %v) = %v; want %v", tt.a, tt.b, got, tt.want)
+			got = runtime.Equal(tt.b, tt.a)
+			assert.Equal(t, tt.want, got, "Equal(%v, %v) = %v; want %v", tt.b, tt.a, got, tt.want)
+		})
+	}
+
+}
+
+func BenchmarkEqual(b *testing.B) {
+	for _, tt := range tests {
+		b.Run(tt.name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				runtime.Equal(tt.a, tt.b)
+			}
+		})
+	}
+}

From cfe9787745e1aed0d3967047389e5d8462eba450 Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Sun, 17 Mar 2024 14:51:53 +0700
Subject: [PATCH 286/506] `expr.Operator` passes before `expr.Env` caused error
 (#606)

---
 checker/checker_test.go |  2 +-
 conf/config.go          |  6 +++++-
 expr_test.go            | 14 ++++++++++++++
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/checker/checker_test.go b/checker/checker_test.go
index d6a84abc5..29c50807e 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -632,7 +632,7 @@ func TestCheck_TaggedFieldName(t *testing.T) {
 	tree, err := parser.Parse(`foo.bar`)
 	require.NoError(t, err)
 
-	config := &conf.Config{}
+	config := conf.CreateNew()
 	expr.Env(struct {
 		x struct {
 			y bool `expr:"bar"`
diff --git a/conf/config.go b/conf/config.go
index 799898109..01a407a10 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -32,6 +32,7 @@ type Config struct {
 func CreateNew() *Config {
 	c := &Config{
 		Optimize:  true,
+		Types:     make(TypesTable),
 		ConstFns:  make(map[string]reflect.Value),
 		Functions: make(map[string]*builtin.Function),
 		Builtins:  make(map[string]*builtin.Function),
@@ -62,7 +63,10 @@ func (c *Config) WithEnv(env any) {
 	}
 
 	c.Env = env
-	c.Types = CreateTypesTable(env)
+	types := CreateTypesTable(env)
+	for name, t := range types {
+		c.Types[name] = t
+	}
 	c.MapEnv = mapEnv
 	c.DefaultType = mapValueType
 	c.Strict = true
diff --git a/expr_test.go b/expr_test.go
index 92343e22e..5128ea51d 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2510,3 +2510,17 @@ func TestRaceCondition_variables(t *testing.T) {
 
 	wg.Wait()
 }
+
+func TestOperatorDependsOnEnv(t *testing.T) {
+	env := map[string]any{
+		"plus": func(a, b int) int {
+			return 42
+		},
+	}
+	program, err := expr.Compile(`1 + 2`, expr.Operator("+", "plus"), expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, 42, out)
+}

From 3452f5be95fd5845fa45c77b8ebaaee6a3e6b586 Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Thu, 21 Mar 2024 02:06:04 +0700
Subject: [PATCH 287/506] builtin `int` unwraps underlying int value (#611)

---
 builtin/builtin_test.go | 14 ++++++++++++++
 builtin/lib.go          |  4 ++++
 2 files changed, 18 insertions(+)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index aa324c9be..7f5045f41 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -612,3 +612,17 @@ func TestBuiltin_bitOpsFunc(t *testing.T) {
 		})
 	}
 }
+
+type customInt int
+
+func Test_int_unwraps_underlying_value(t *testing.T) {
+	env := map[string]any{
+		"customInt": customInt(42),
+	}
+	program, err := expr.Compile(`int(customInt) == 42`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, true, out)
+}
diff --git a/builtin/lib.go b/builtin/lib.go
index 9ff9478aa..e3a6c0aef 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -209,6 +209,10 @@ func Int(x any) any {
 		}
 		return i
 	default:
+		val := reflect.ValueOf(x)
+		if val.CanConvert(integerType) {
+			return val.Convert(integerType).Interface()
+		}
 		panic(fmt.Sprintf("invalid operation: int(%T)", x))
 	}
 }

From d5231073da6742e42f5c026eb49c0d493da1274c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 27 Mar 2024 09:26:56 +0100
Subject: [PATCH 288/506] Better map ast printing

---
 ast/print.go      | 8 +++++++-
 ast/print_test.go | 5 +++--
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/ast/print.go b/ast/print.go
index fa593ae28..063e9eb27 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -202,5 +202,11 @@ func (n *MapNode) String() string {
 }
 
 func (n *PairNode) String() string {
-	return fmt.Sprintf("%s: %s", n.Key.String(), n.Value.String())
+	if str, ok := n.Key.(*StringNode); ok {
+		if utils.IsValidIdentifier(str.Value) {
+			return fmt.Sprintf("%s: %s", str.Value, n.Value.String())
+		}
+		return fmt.Sprintf("%q: %s", str.String(), n.Value.String())
+	}
+	return fmt.Sprintf("(%s): %s", n.Key.String(), n.Value.String())
 }
diff --git a/ast/print_test.go b/ast/print_test.go
index 16d64357b..d9e55c2ea 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -55,8 +55,8 @@ func TestPrint(t *testing.T) {
 		{`func(a)`, `func(a)`},
 		{`func(a, b)`, `func(a, b)`},
 		{`{}`, `{}`},
-		{`{a: b}`, `{"a": b}`},
-		{`{a: b, c: d}`, `{"a": b, "c": d}`},
+		{`{a: b}`, `{a: b}`},
+		{`{a: b, c: d}`, `{a: b, c: d}`},
 		{`[]`, `[]`},
 		{`[a]`, `[a]`},
 		{`[a, b]`, `[a, b]`},
@@ -71,6 +71,7 @@ func TestPrint(t *testing.T) {
 		{`a[1:]`, `a[1:]`},
 		{`a[:]`, `a[:]`},
 		{`(nil ?? 1) > 0`, `(nil ?? 1) > 0`},
+		{`{("a" + "b"): 42}`, `{("a" + "b"): 42}`},
 	}
 
 	for _, tt := range tests {

From 7772ea0fee5c9b153439a0ad5ee2e2b1a764f453 Mon Sep 17 00:00:00 2001
From: zhuliquan <zlqlovecode@foxmail.com>
Date: Thu, 28 Mar 2024 21:37:51 +0800
Subject: [PATCH 289/506] feat: extract code for compiling equal operator
 (#614)

---
 compiler/compiler.go | 48 ++++++++++++++++++++++----------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 808b53c9b..a38d977d5 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -395,34 +395,12 @@ func (c *compiler) UnaryNode(node *ast.UnaryNode) {
 }
 
 func (c *compiler) BinaryNode(node *ast.BinaryNode) {
-	l := kind(node.Left)
-	r := kind(node.Right)
-
-	leftIsSimple := isSimpleType(node.Left)
-	rightIsSimple := isSimpleType(node.Right)
-	leftAndRightAreSimple := leftIsSimple && rightIsSimple
-
 	switch node.Operator {
 	case "==":
-		c.compile(node.Left)
-		c.derefInNeeded(node.Left)
-		c.compile(node.Right)
-		c.derefInNeeded(node.Right)
-
-		if l == r && l == reflect.Int && leftAndRightAreSimple {
-			c.emit(OpEqualInt)
-		} else if l == r && l == reflect.String && leftAndRightAreSimple {
-			c.emit(OpEqualString)
-		} else {
-			c.emit(OpEqual)
-		}
+		c.equalBinaryNode(node)
 
 	case "!=":
-		c.compile(node.Left)
-		c.derefInNeeded(node.Left)
-		c.compile(node.Right)
-		c.derefInNeeded(node.Right)
-		c.emit(OpEqual)
+		c.equalBinaryNode(node)
 		c.emit(OpNot)
 
 	case "or", "||":
@@ -580,6 +558,28 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 	}
 }
 
+func (c *compiler) equalBinaryNode(node *ast.BinaryNode) {
+	l := kind(node.Left)
+	r := kind(node.Right)
+
+	leftIsSimple := isSimpleType(node.Left)
+	rightIsSimple := isSimpleType(node.Right)
+	leftAndRightAreSimple := leftIsSimple && rightIsSimple
+
+	c.compile(node.Left)
+	c.derefInNeeded(node.Left)
+	c.compile(node.Right)
+	c.derefInNeeded(node.Right)
+
+	if l == r && l == reflect.Int && leftAndRightAreSimple {
+		c.emit(OpEqualInt)
+	} else if l == r && l == reflect.String && leftAndRightAreSimple {
+		c.emit(OpEqualString)
+	} else {
+		c.emit(OpEqual)
+	}
+}
+
 func isSimpleType(node ast.Node) bool {
 	if node == nil {
 		return false

From 852d47f3ecc7802acb7fbe1fc91a56b26df30999 Mon Sep 17 00:00:00 2001
From: Richard Wooding <richard.wooding@gmail.com>
Date: Mon, 8 Apr 2024 09:00:54 +0200
Subject: [PATCH 290/506] Update README.md (#619)

Add SPAN Digital as an user of expr
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index bd34c7d24..1475fe2f5 100644
--- a/README.md
+++ b/README.md
@@ -162,6 +162,7 @@ func main() {
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
+* [SPAN Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From 0b2a08654939f5529f9186d8893307aa0c3d1178 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 9 Apr 2024 09:47:41 +0200
Subject: [PATCH 291/506] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1475fe2f5..1a2d7dc83 100644
--- a/README.md
+++ b/README.md
@@ -162,7 +162,7 @@ func main() {
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
-* [SPAN Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products
+* [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From d9b1093c6e483aabd3194bfed9d4816656e3872b Mon Sep 17 00:00:00 2001
From: needsure <166317845+needsure@users.noreply.github.com>
Date: Tue, 9 Apr 2024 19:13:55 +0800
Subject: [PATCH 292/506] chore: fix some typos in conments (#622)

Signed-off-by: needsure <qinzhipeng@outlook.com>
---
 patcher/value/value.go         | 4 ++--
 test/operator/operator_test.go | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/patcher/value/value.go b/patcher/value/value.go
index 59351be6b..28f52be27 100644
--- a/patcher/value/value.go
+++ b/patcher/value/value.go
@@ -13,9 +13,9 @@ import (
 // ValueGetter is a Patcher that allows custom types to be represented as standard go values for use with expr.
 // It also adds the `$patcher_value_getter` function to the program for efficiently calling matching interfaces.
 //
-// The purpose of this Patcher is to make it seemless to use custom types in expressions without the need to
+// The purpose of this Patcher is to make it seamless to use custom types in expressions without the need to
 // first convert them to standard go values. It may also facilitate using already existing structs or maps as
-// environments when they contain compatabile types.
+// environments when they contain compatible types.
 //
 // An example usage may be modeling a database record with columns that have varying data types and constraints.
 // In such an example you may have custom types that, beyond storing a simple value, such as an integer, may
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index a19c191dc..b49d91cc6 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -77,7 +77,7 @@ func TestOperator_Function(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(fmt.Sprintf(`opertor function helper test %s`, tt.input), func(t *testing.T) {
+		t.Run(fmt.Sprintf(`operator function helper test %s`, tt.input), func(t *testing.T) {
 			program, err := expr.Compile(
 				tt.input,
 				expr.Env(env),

From e7e72b9a06044715e23f9ae9175b5141fff178bc Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 10 Apr 2024 10:58:17 +0200
Subject: [PATCH 293/506] Revert "Optimize boolean operations between all, any,
 one, none functions (#555)" (#625)

This reverts commit 3c03e5965172519f7bc12100db6607d6a9fae031.
---
 optimizer/optimizer.go             |   1 -
 optimizer/optimizer_test.go        | 122 -----------------------------
 optimizer/predicate_combination.go |  51 ------------
 3 files changed, 174 deletions(-)
 delete mode 100644 optimizer/predicate_combination.go

diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index 6d1fb0b54..a9c0fa3d3 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -36,6 +36,5 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &filterLen{})
 	Walk(node, &filterLast{})
 	Walk(node, &filterFirst{})
-	Walk(node, &predicateCombination{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 703bd1ceb..e45de763b 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -1,7 +1,6 @@
 package optimizer_test
 
 import (
-	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -340,124 +339,3 @@ func TestOptimize_filter_map_first(t *testing.T) {
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
-
-func TestOptimize_predicate_combination(t *testing.T) {
-	tests := []struct {
-		op     string
-		fn     string
-		wantOp string
-	}{
-		{"and", "all", "and"},
-		{"&&", "all", "&&"},
-		{"or", "all", "or"},
-		{"||", "all", "||"},
-		{"and", "any", "and"},
-		{"&&", "any", "&&"},
-		{"or", "any", "or"},
-		{"||", "any", "||"},
-		{"and", "none", "or"},
-		{"&&", "none", "||"},
-		{"and", "one", "or"},
-		{"&&", "one", "||"},
-	}
-
-	for _, tt := range tests {
-		rule := fmt.Sprintf(`%s(users, .Age > 18 and .Name != "Bob") %s %s(users, .Age < 30)`, tt.fn, tt.op, tt.fn)
-		t.Run(rule, func(t *testing.T) {
-			tree, err := parser.Parse(rule)
-			require.NoError(t, err)
-
-			err = optimizer.Optimize(&tree.Node, nil)
-			require.NoError(t, err)
-
-			expected := &ast.BuiltinNode{
-				Name: tt.fn,
-				Arguments: []ast.Node{
-					&ast.IdentifierNode{Value: "users"},
-					&ast.ClosureNode{
-						Node: &ast.BinaryNode{
-							Operator: tt.wantOp,
-							Left: &ast.BinaryNode{
-								Operator: "and",
-								Left: &ast.BinaryNode{
-									Operator: ">",
-									Left: &ast.MemberNode{
-										Node:     &ast.PointerNode{},
-										Property: &ast.StringNode{Value: "Age"},
-									},
-									Right: &ast.IntegerNode{Value: 18},
-								},
-								Right: &ast.BinaryNode{
-									Operator: "!=",
-									Left: &ast.MemberNode{
-										Node:     &ast.PointerNode{},
-										Property: &ast.StringNode{Value: "Name"},
-									},
-									Right: &ast.StringNode{Value: "Bob"},
-								},
-							},
-							Right: &ast.BinaryNode{
-								Operator: "<",
-								Left: &ast.MemberNode{
-									Node:     &ast.PointerNode{},
-									Property: &ast.StringNode{Value: "Age"},
-								},
-								Right: &ast.IntegerNode{Value: 30},
-							},
-						},
-					},
-				},
-			}
-			assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
-		})
-	}
-}
-
-func TestOptimize_predicate_combination_nested(t *testing.T) {
-	tree, err := parser.Parse(`any(users, {all(.Friends, {.Age == 18 })}) && any(users, {all(.Friends, {.Name != "Bob" })})`)
-	require.NoError(t, err)
-
-	err = optimizer.Optimize(&tree.Node, nil)
-	require.NoError(t, err)
-
-	expected := &ast.BuiltinNode{
-		Name: "any",
-		Arguments: []ast.Node{
-			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
-				Node: &ast.BuiltinNode{
-					Name: "all",
-					Arguments: []ast.Node{
-						&ast.MemberNode{
-							Node:     &ast.PointerNode{},
-							Property: &ast.StringNode{Value: "Friends"},
-						},
-						&ast.ClosureNode{
-							Node: &ast.BinaryNode{
-								Operator: "&&",
-								Left: &ast.BinaryNode{
-									Operator: "==",
-									Left: &ast.MemberNode{
-										Node:     &ast.PointerNode{},
-										Property: &ast.StringNode{Value: "Age"},
-									},
-									Right: &ast.IntegerNode{Value: 18},
-								},
-								Right: &ast.BinaryNode{
-									Operator: "!=",
-									Left: &ast.MemberNode{
-										Node:     &ast.PointerNode{},
-										Property: &ast.StringNode{Value: "Name"},
-									},
-									Right: &ast.StringNode{Value: "Bob"},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	}
-
-	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
-}
diff --git a/optimizer/predicate_combination.go b/optimizer/predicate_combination.go
deleted file mode 100644
index 2733781df..000000000
--- a/optimizer/predicate_combination.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package optimizer
-
-import (
-	. "github.com/expr-lang/expr/ast"
-	"github.com/expr-lang/expr/parser/operator"
-)
-
-type predicateCombination struct{}
-
-func (v *predicateCombination) Visit(node *Node) {
-	if op, ok := (*node).(*BinaryNode); ok && operator.IsBoolean(op.Operator) {
-		if left, ok := op.Left.(*BuiltinNode); ok {
-			if combinedOp, ok := combinedOperator(left.Name, op.Operator); ok {
-				if right, ok := op.Right.(*BuiltinNode); ok && right.Name == left.Name {
-					if left.Arguments[0].Type() == right.Arguments[0].Type() && left.Arguments[0].String() == right.Arguments[0].String() {
-						closure := &ClosureNode{
-							Node: &BinaryNode{
-								Operator: combinedOp,
-								Left:     left.Arguments[1].(*ClosureNode).Node,
-								Right:    right.Arguments[1].(*ClosureNode).Node,
-							},
-						}
-						v.Visit(&closure.Node)
-						Patch(node, &BuiltinNode{
-							Name: left.Name,
-							Arguments: []Node{
-								left.Arguments[0],
-								closure,
-							},
-						})
-					}
-				}
-			}
-		}
-	}
-}
-
-func combinedOperator(fn, op string) (string, bool) {
-	switch fn {
-	case "all", "any":
-		return op, true
-	case "one", "none":
-		switch op {
-		case "and":
-			return "or", true
-		case "&&":
-			return "||", true
-		}
-	}
-	return "", false
-}

From 2aee5239cd553541258fba3b0785b2ede585aede Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Fri, 12 Apr 2024 23:49:41 +0700
Subject: [PATCH 294/506] Optimize boolean operations between all, any, none
 functions (#626)

---
 expr_test.go                       | 189 +++++++++++++++++++++++++++++
 optimizer/optimizer.go             |   1 +
 optimizer/optimizer_test.go        | 116 ++++++++++++++++++
 optimizer/predicate_combination.go |  61 ++++++++++
 4 files changed, 367 insertions(+)
 create mode 100644 optimizer/predicate_combination.go

diff --git a/expr_test.go b/expr_test.go
index 5128ea51d..db2541306 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -901,18 +901,147 @@ func TestExpr(t *testing.T) {
 			`all(1..3, {# > 0})`,
 			true,
 		},
+		{
+			`all(1..3, {# > 0}) && all(1..3, {# < 4})`,
+			true,
+		},
+		{
+			`all(1..3, {# > 2}) && all(1..3, {# < 4})`,
+			false,
+		},
+		{
+			`all(1..3, {# > 0}) && all(1..3, {# < 2})`,
+			false,
+		},
+		{
+			`all(1..3, {# > 2}) && all(1..3, {# < 2})`,
+			false,
+		},
+		{
+			`all(1..3, {# > 0}) || all(1..3, {# < 4})`,
+			true,
+		},
+		{
+			`all(1..3, {# > 0}) || all(1..3, {# != 2})`,
+			true,
+		},
+		{
+			`all(1..3, {# != 3}) || all(1..3, {# < 4})`,
+			true,
+		},
+		{
+			`all(1..3, {# != 3}) || all(1..3, {# != 2})`,
+			false,
+		},
 		{
 			`none(1..3, {# == 0})`,
 			true,
 		},
+		{
+			`none(1..3, {# == 0}) && none(1..3, {# == 4})`,
+			true,
+		},
+		{
+			`none(1..3, {# == 0}) && none(1..3, {# == 3})`,
+			false,
+		},
+		{
+			`none(1..3, {# == 1}) && none(1..3, {# == 4})`,
+			false,
+		},
+		{
+			`none(1..3, {# == 1}) && none(1..3, {# == 3})`,
+			false,
+		},
+		{
+			`none(1..3, {# == 0}) || none(1..3, {# == 4})`,
+			true,
+		},
+		{
+			`none(1..3, {# == 0}) || none(1..3, {# == 3})`,
+			true,
+		},
+		{
+			`none(1..3, {# == 1}) || none(1..3, {# == 4})`,
+			true,
+		},
+		{
+			`none(1..3, {# == 1}) || none(1..3, {# == 3})`,
+			false,
+		},
 		{
 			`any([1,1,0,1], {# == 0})`,
 			true,
 		},
+		{
+			`any(1..3, {# == 1}) && any(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`any(1..3, {# == 0}) && any(1..3, {# == 2})`,
+			false,
+		},
+		{
+			`any(1..3, {# == 1}) && any(1..3, {# == 4})`,
+			false,
+		},
+		{
+			`any(1..3, {# == 0}) && any(1..3, {# == 4})`,
+			false,
+		},
+		{
+			`any(1..3, {# == 1}) || any(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`any(1..3, {# == 0}) || any(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`any(1..3, {# == 1}) || any(1..3, {# == 4})`,
+			true,
+		},
+		{
+			`any(1..3, {# == 0}) || any(1..3, {# == 4})`,
+			false,
+		},
 		{
 			`one([1,1,0,1], {# == 0}) and not one([1,0,0,1], {# == 0})`,
 			true,
 		},
+		{
+			`one(1..3, {# == 1}) and one(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`one(1..3, {# == 1 || # == 2}) and one(1..3, {# == 2})`,
+			false,
+		},
+		{
+			`one(1..3, {# == 1}) and one(1..3, {# == 2 || # == 3})`,
+			false,
+		},
+		{
+			`one(1..3, {# == 1 || # == 2}) and one(1..3, {# == 2 || # == 3})`,
+			false,
+		},
+		{
+			`one(1..3, {# == 1}) or one(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`one(1..3, {# == 1 || # == 2}) or one(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`one(1..3, {# == 1}) or one(1..3, {# == 2 || # == 3})`,
+			true,
+		},
+		{
+			`one(1..3, {# == 1 || # == 2}) or one(1..3, {# == 2 || # == 3})`,
+			false,
+		},
+
 		{
 			`count(1..30, {# % 3 == 0})`,
 			10,
@@ -2524,3 +2653,63 @@ func TestOperatorDependsOnEnv(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, 42, out)
 }
+
+func TestIssue624(t *testing.T) {
+	type tag struct {
+		Name string
+	}
+
+	type item struct {
+		Tags []tag
+	}
+
+	i := item{
+		Tags: []tag{
+			{Name: "one"},
+			{Name: "two"},
+		},
+	}
+
+	rule := `[
+true && true, 
+one(Tags, .Name in ["one"]), 
+one(Tags, .Name in ["two"]), 
+one(Tags, .Name in ["one"]) && one(Tags, .Name in ["two"])
+]`
+	resp, err := expr.Eval(rule, i)
+	require.NoError(t, err)
+	require.Equal(t, []interface{}{true, true, true, true}, resp)
+}
+
+func TestPredicateCombination(t *testing.T) {
+	tests := []struct {
+		code1 string
+		code2 string
+	}{
+		{"all(1..3, {# > 0}) && all(1..3, {# < 4})", "all(1..3, {# > 0 && # < 4})"},
+		{"all(1..3, {# > 1}) && all(1..3, {# < 4})", "all(1..3, {# > 1 && # < 4})"},
+		{"all(1..3, {# > 0}) && all(1..3, {# < 2})", "all(1..3, {# > 0 && # < 2})"},
+		{"all(1..3, {# > 1}) && all(1..3, {# < 2})", "all(1..3, {# > 1 && # < 2})"},
+
+		{"any(1..3, {# > 0}) || any(1..3, {# < 4})", "any(1..3, {# > 0 || # < 4})"},
+		{"any(1..3, {# > 1}) || any(1..3, {# < 4})", "any(1..3, {# > 1 || # < 4})"},
+		{"any(1..3, {# > 0}) || any(1..3, {# < 2})", "any(1..3, {# > 0 || # < 2})"},
+		{"any(1..3, {# > 1}) || any(1..3, {# < 2})", "any(1..3, {# > 1 || # < 2})"},
+
+		{"none(1..3, {# > 0}) && none(1..3, {# < 4})", "none(1..3, {# > 0 || # < 4})"},
+		{"none(1..3, {# > 1}) && none(1..3, {# < 4})", "none(1..3, {# > 1 || # < 4})"},
+		{"none(1..3, {# > 0}) && none(1..3, {# < 2})", "none(1..3, {# > 0 || # < 2})"},
+		{"none(1..3, {# > 1}) && none(1..3, {# < 2})", "none(1..3, {# > 1 || # < 2})"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.code1, func(t *testing.T) {
+			out1, err := expr.Eval(tt.code1, nil)
+			require.NoError(t, err)
+
+			out2, err := expr.Eval(tt.code2, nil)
+			require.NoError(t, err)
+
+			require.Equal(t, out1, out2)
+		})
+	}
+}
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index a9c0fa3d3..6d1fb0b54 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -36,5 +36,6 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &filterLen{})
 	Walk(node, &filterLast{})
 	Walk(node, &filterFirst{})
+	Walk(node, &predicateCombination{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index e45de763b..316b17182 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -1,6 +1,7 @@
 package optimizer_test
 
 import (
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -339,3 +340,118 @@ func TestOptimize_filter_map_first(t *testing.T) {
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
+
+func TestOptimize_predicate_combination(t *testing.T) {
+	tests := []struct {
+		op     string
+		fn     string
+		wantOp string
+	}{
+		{"and", "all", "and"},
+		{"&&", "all", "&&"},
+		{"or", "any", "or"},
+		{"||", "any", "||"},
+		{"and", "none", "or"},
+		{"&&", "none", "||"},
+	}
+
+	for _, tt := range tests {
+		rule := fmt.Sprintf(`%s(users, .Age > 18 and .Name != "Bob") %s %s(users, .Age < 30)`, tt.fn, tt.op, tt.fn)
+		t.Run(rule, func(t *testing.T) {
+			tree, err := parser.Parse(rule)
+			require.NoError(t, err)
+
+			err = optimizer.Optimize(&tree.Node, nil)
+			require.NoError(t, err)
+
+			expected := &ast.BuiltinNode{
+				Name: tt.fn,
+				Arguments: []ast.Node{
+					&ast.IdentifierNode{Value: "users"},
+					&ast.ClosureNode{
+						Node: &ast.BinaryNode{
+							Operator: tt.wantOp,
+							Left: &ast.BinaryNode{
+								Operator: "and",
+								Left: &ast.BinaryNode{
+									Operator: ">",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Age"},
+									},
+									Right: &ast.IntegerNode{Value: 18},
+								},
+								Right: &ast.BinaryNode{
+									Operator: "!=",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Name"},
+									},
+									Right: &ast.StringNode{Value: "Bob"},
+								},
+							},
+							Right: &ast.BinaryNode{
+								Operator: "<",
+								Left: &ast.MemberNode{
+									Node:     &ast.PointerNode{},
+									Property: &ast.StringNode{Value: "Age"},
+								},
+								Right: &ast.IntegerNode{Value: 30},
+							},
+						},
+					},
+				},
+			}
+			assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+		})
+	}
+}
+
+func TestOptimize_predicate_combination_nested(t *testing.T) {
+	tree, err := parser.Parse(`all(users, {all(.Friends, {.Age == 18 })}) && all(users, {all(.Friends, {.Name != "Bob" })})`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "all",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BuiltinNode{
+					Name: "all",
+					Arguments: []ast.Node{
+						&ast.MemberNode{
+							Node:     &ast.PointerNode{},
+							Property: &ast.StringNode{Value: "Friends"},
+						},
+						&ast.ClosureNode{
+							Node: &ast.BinaryNode{
+								Operator: "&&",
+								Left: &ast.BinaryNode{
+									Operator: "==",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Age"},
+									},
+									Right: &ast.IntegerNode{Value: 18},
+								},
+								Right: &ast.BinaryNode{
+									Operator: "!=",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Name"},
+									},
+									Right: &ast.StringNode{Value: "Bob"},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
diff --git a/optimizer/predicate_combination.go b/optimizer/predicate_combination.go
new file mode 100644
index 000000000..6e8a7f7cf
--- /dev/null
+++ b/optimizer/predicate_combination.go
@@ -0,0 +1,61 @@
+package optimizer
+
+import (
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/parser/operator"
+)
+
+/*
+predicateCombination is a visitor that combines multiple predicate calls into a single call.
+For example, the following expression:
+
+	all(x, x > 1) && all(x, x < 10) -> all(x, x > 1 && x < 10)
+	any(x, x > 1) || any(x, x < 10) -> any(x, x > 1 || x < 10)
+	none(x, x > 1) && none(x, x < 10) -> none(x, x > 1 || x < 10)
+*/
+type predicateCombination struct{}
+
+func (v *predicateCombination) Visit(node *Node) {
+	if op, ok := (*node).(*BinaryNode); ok && operator.IsBoolean(op.Operator) {
+		if left, ok := op.Left.(*BuiltinNode); ok {
+			if combinedOp, ok := combinedOperator(left.Name, op.Operator); ok {
+				if right, ok := op.Right.(*BuiltinNode); ok && right.Name == left.Name {
+					if left.Arguments[0].Type() == right.Arguments[0].Type() && left.Arguments[0].String() == right.Arguments[0].String() {
+						closure := &ClosureNode{
+							Node: &BinaryNode{
+								Operator: combinedOp,
+								Left:     left.Arguments[1].(*ClosureNode).Node,
+								Right:    right.Arguments[1].(*ClosureNode).Node,
+							},
+						}
+						v.Visit(&closure.Node)
+						Patch(node, &BuiltinNode{
+							Name: left.Name,
+							Arguments: []Node{
+								left.Arguments[0],
+								closure,
+							},
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func combinedOperator(fn, op string) (string, bool) {
+	switch {
+	case fn == "all" && (op == "and" || op == "&&"):
+		return op, true
+	case fn == "any" && (op == "or" || op == "||"):
+		return op, true
+	case fn == "none" && (op == "and" || op == "&&"):
+		switch op {
+		case "and":
+			return "or", true
+		case "&&":
+			return "||", true
+		}
+	}
+	return "", false
+}

From c0ad2d4f82606e5bebe18cc8c99c27d501fdf0ea Mon Sep 17 00:00:00 2001
From: Daenney <daenney@users.noreply.github.com>
Date: Fri, 12 Apr 2024 22:54:01 +0200
Subject: [PATCH 295/506] Make WithContext work for methods on env struct
 (#602)

This makes the WithContext patcher work when passing in a struct for an
env that has methods that take a context.

This is a bit fiddly because we can't quite detect the difference of
function vs. method on a struct, so we have to check both the first and
the second param. Since it's highly unusual to pass the context as
anything other than the first parameter, this should work out just fine
in practice.

Fixes #600.
---
 patcher/with_context.go      | 15 +++++++++++----
 patcher/with_context_test.go | 24 ++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/patcher/with_context.go b/patcher/with_context.go
index 55b604261..f9861a2c2 100644
--- a/patcher/with_context.go
+++ b/patcher/with_context.go
@@ -22,11 +22,18 @@ func (w WithContext) Visit(node *ast.Node) {
 		if fn.Kind() != reflect.Func {
 			return
 		}
-		if fn.NumIn() == 0 {
-			return
-		}
-		if fn.In(0).String() != "context.Context" {
+		switch fn.NumIn() {
+		case 0:
 			return
+		case 1:
+			if fn.In(0).String() != "context.Context" {
+				return
+			}
+		default:
+			if fn.In(0).String() != "context.Context" &&
+				fn.In(1).String() != "context.Context" {
+				return
+			}
 		}
 		ast.Patch(node, &ast.CallNode{
 			Callee: call.Callee,
diff --git a/patcher/with_context_test.go b/patcher/with_context_test.go
index afad4e6f0..5ce64191f 100644
--- a/patcher/with_context_test.go
+++ b/patcher/with_context_test.go
@@ -62,6 +62,30 @@ func TestWithContext_with_env_Function(t *testing.T) {
 	require.Equal(t, 42, output)
 }
 
+type testEnvContext struct {
+	Context context.Context `expr:"ctx"`
+}
+
+func (testEnvContext) Fn(ctx context.Context, a int) int {
+	return ctx.Value("value").(int) + a
+}
+
+func TestWithContext_env_struct(t *testing.T) {
+	withContext := patcher.WithContext{Name: "ctx"}
+
+	program, err := expr.Compile(`Fn(40)`, expr.Env(testEnvContext{}), expr.Patch(withContext))
+	require.NoError(t, err)
+
+	ctx := context.WithValue(context.Background(), "value", 2)
+	env := testEnvContext{
+		Context: ctx,
+	}
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 42, output)
+}
+
 type TestFoo struct {
 	contextValue int
 }

From eb8fb13de1f73785d40d97b1dab8be2f7063b7ff Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Tue, 27 Feb 2024 20:23:49 +0700
Subject: [PATCH 296/506] Support chzained comparisonc`1 < 2 < 3` (#581)

---
 expr_test.go                | 20 +++++++++++++
 parser/operator/operator.go |  4 +++
 parser/parser.go            | 36 ++++++++++++++++++++++
 parser/parser_test.go       | 60 +++++++++++++++++++++++++++++++++++++
 4 files changed, 120 insertions(+)

diff --git a/expr_test.go b/expr_test.go
index ea9213be2..a4321c575 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1253,6 +1253,26 @@ func TestExpr(t *testing.T) {
 			`[nil, 3, 4]?.[0]?.[1]`,
 			nil,
 		},
+		{
+			`1 > 2 < 3`,
+			false,
+		},
+		{
+			`1 < 2 < 3`,
+			true,
+		},
+		{
+			`1 < 2 < 3 > 4`,
+			false,
+		},
+		{
+			`1 < 2 < 3 > 2`,
+			true,
+		},
+		{
+			`1 < 2 < 3 == true`,
+			true,
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/parser/operator/operator.go b/parser/operator/operator.go
index 8d804c7b3..411a0e2bc 100644
--- a/parser/operator/operator.go
+++ b/parser/operator/operator.go
@@ -54,3 +54,7 @@ var Binary = map[string]Operator{
 	"^":          {100, Right},
 	"??":         {500, Left},
 }
+
+func IsComparison(op string) bool {
+	return op == "<" || op == ">" || op == ">=" || op == "<="
+}
diff --git a/parser/parser.go b/parser/parser.go
index 1eabdebe2..9114bc0c9 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -164,6 +164,11 @@ func (p *parser) parseExpression(precedence int) Node {
 					break
 				}
 
+				if operator.IsComparison(opToken.Value) {
+					nodeLeft = p.parseComparison(nodeLeft, opToken, op.Precedence)
+					goto next
+				}
+
 				var nodeRight Node
 				if op.Associativity == operator.Left {
 					nodeRight = p.parseExpression(op.Precedence + 1)
@@ -685,3 +690,34 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 	}
 	return node
 }
+
+func (p *parser) parseComparison(left Node, token Token, precedence int) Node {
+	var rootNode Node
+	for {
+		comparator := p.parseExpression(precedence + 1)
+		cmpNode := &BinaryNode{
+			Operator: token.Value,
+			Left:     left,
+			Right:    comparator,
+		}
+		cmpNode.SetLocation(token.Location)
+		if rootNode == nil {
+			rootNode = cmpNode
+		} else {
+			rootNode = &BinaryNode{
+				Operator: "&&",
+				Left:     rootNode,
+				Right:    cmpNode,
+			}
+			rootNode.SetLocation(token.Location)
+		}
+
+		left = comparator
+		token = p.current
+		if !(token.Is(Operator) && operator.IsComparison(token.Value) && p.err == nil) {
+			break
+		}
+		p.next()
+	}
+	return rootNode
+}
diff --git a/parser/parser_test.go b/parser/parser_test.go
index b633bd52e..9225e1028 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -531,6 +531,66 @@ world`},
 				To:   &IntegerNode{Value: 3},
 			},
 		},
+		{
+			`1 < 2 > 3`,
+			&BinaryNode{
+				Operator: "&&",
+				Left: &BinaryNode{
+					Operator: "<",
+					Left:     &IntegerNode{Value: 1},
+					Right:    &IntegerNode{Value: 2},
+				},
+				Right: &BinaryNode{
+					Operator: ">",
+					Left:     &IntegerNode{Value: 2},
+					Right:    &IntegerNode{Value: 3},
+				},
+			},
+		},
+		{
+			`1 < 2 < 3 < 4`,
+			&BinaryNode{
+				Operator: "&&",
+				Left: &BinaryNode{
+					Operator: "&&",
+					Left: &BinaryNode{
+						Operator: "<",
+						Left:     &IntegerNode{Value: 1},
+						Right:    &IntegerNode{Value: 2},
+					},
+					Right: &BinaryNode{
+						Operator: "<",
+						Left:     &IntegerNode{Value: 2},
+						Right:    &IntegerNode{Value: 3},
+					},
+				},
+				Right: &BinaryNode{
+					Operator: "<",
+					Left:     &IntegerNode{Value: 3},
+					Right:    &IntegerNode{Value: 4},
+				},
+			},
+		},
+		{
+			`1 < 2 < 3 == true`,
+			&BinaryNode{
+				Operator: "==",
+				Left: &BinaryNode{
+					Operator: "&&",
+					Left: &BinaryNode{
+						Operator: "<",
+						Left:     &IntegerNode{Value: 1},
+						Right:    &IntegerNode{Value: 2},
+					},
+					Right: &BinaryNode{
+						Operator: "<",
+						Left:     &IntegerNode{Value: 2},
+						Right:    &IntegerNode{Value: 3},
+					},
+				},
+				Right: &BoolNode{Value: true},
+			},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {

From 355fb28bafa40cbf11ea3cee95bb102c1a8ac64d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 29 Feb 2024 20:51:34 +0100
Subject: [PATCH 297/506] Add spans

---
 compiler/compiler.go | 29 +++++++++++++++++++++++++++++
 conf/config.go       |  1 +
 vm/opcodes.go        |  2 ++
 vm/program.go        |  9 +++++++++
 vm/utils.go          | 13 +++++++++++++
 vm/vm.go             |  9 +++++++++
 6 files changed, 63 insertions(+)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index a4f189e6b..808b53c9b 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -50,6 +50,11 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		}
 	}
 
+	var span *Span
+	if len(c.spans) > 0 {
+		span = c.spans[0]
+	}
+
 	program = NewProgram(
 		tree.Source,
 		tree.Node,
@@ -60,6 +65,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		c.arguments,
 		c.functions,
 		c.debugInfo,
+		span,
 	)
 	return
 }
@@ -76,6 +82,7 @@ type compiler struct {
 	functionsIndex map[string]int
 	debugInfo      map[string]string
 	nodes          []ast.Node
+	spans          []*Span
 	chains         [][]int
 	arguments      []int
 }
@@ -193,6 +200,28 @@ func (c *compiler) compile(node ast.Node) {
 		c.nodes = c.nodes[:len(c.nodes)-1]
 	}()
 
+	if c.config != nil && c.config.Profile {
+		span := &Span{
+			Name:       reflect.TypeOf(node).String(),
+			Expression: node.String(),
+		}
+		if len(c.spans) > 0 {
+			prev := c.spans[len(c.spans)-1]
+			prev.Children = append(prev.Children, span)
+		}
+		c.spans = append(c.spans, span)
+		defer func() {
+			if len(c.spans) > 1 {
+				c.spans = c.spans[:len(c.spans)-1]
+			}
+		}()
+
+		c.emit(OpProfileStart, c.addConstant(span))
+		defer func() {
+			c.emit(OpProfileEnd, c.addConstant(span))
+		}()
+	}
+
 	switch n := node.(type) {
 	case *ast.NilNode:
 		c.NilNode(n)
diff --git a/conf/config.go b/conf/config.go
index e543732ce..799898109 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -20,6 +20,7 @@ type Config struct {
 	ExpectAny   bool
 	Optimize    bool
 	Strict      bool
+	Profile     bool
 	ConstFns    map[string]reflect.Value
 	Visitors    []ast.Visitor
 	Functions   FunctionsTable
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 0417dab61..84d751d6b 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -81,6 +81,8 @@ const (
 	OpGroupBy
 	OpSortBy
 	OpSort
+	OpProfileStart
+	OpProfileEnd
 	OpBegin
 	OpEnd // This opcode must be at the end of this list.
 )
diff --git a/vm/program.go b/vm/program.go
index 4a878267b..989546744 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -27,6 +27,7 @@ type Program struct {
 	variables int
 	functions []Function
 	debugInfo map[string]string
+	span      *Span
 }
 
 // NewProgram returns a new Program. It's used by the compiler.
@@ -40,6 +41,7 @@ func NewProgram(
 	arguments []int,
 	functions []Function,
 	debugInfo map[string]string,
+	span *Span,
 ) *Program {
 	return &Program{
 		source:    source,
@@ -51,6 +53,7 @@ func NewProgram(
 		Arguments: arguments,
 		functions: functions,
 		debugInfo: debugInfo,
+		span:      span,
 	}
 }
 
@@ -360,6 +363,12 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 		case OpSort:
 			code("OpSort")
 
+		case OpProfileStart:
+			code("OpProfileStart")
+
+		case OpProfileEnd:
+			code("OpProfileEnd")
+
 		case OpBegin:
 			code("OpBegin")
 
diff --git a/vm/utils.go b/vm/utils.go
index d7db2a52a..fc2f5e7b8 100644
--- a/vm/utils.go
+++ b/vm/utils.go
@@ -2,6 +2,7 @@ package vm
 
 import (
 	"reflect"
+	"time"
 )
 
 type (
@@ -25,3 +26,15 @@ type Scope struct {
 }
 
 type groupBy = map[any][]any
+
+type Span struct {
+	Name       string  `json:"name"`
+	Expression string  `json:"expression"`
+	Duration   int64   `json:"duration"`
+	Children   []*Span `json:"children"`
+	start      time.Time
+}
+
+func GetSpan(program *Program) *Span {
+	return program.span
+}
diff --git a/vm/vm.go b/vm/vm.go
index 1e85893b0..7e933ce74 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"time"
 
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/file"
@@ -523,6 +524,14 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.memGrow(uint(scope.Len))
 			vm.push(sortable.Array)
 
+		case OpProfileStart:
+			span := program.Constants[arg].(*Span)
+			span.start = time.Now()
+
+		case OpProfileEnd:
+			span := program.Constants[arg].(*Span)
+			span.Duration += time.Since(span.start).Nanoseconds()
+
 		case OpBegin:
 			a := vm.pop()
 			array := reflect.ValueOf(a)

From ded019d21ec180b7018641732617c59e8932da32 Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Sun, 3 Mar 2024 21:14:32 +0530
Subject: [PATCH 298/506] Enable Support for Arrays in Sum, Mean, and Median
 Functions (#580)

---
 builtin/builtin.go      | 201 ++++++----------------------------------
 builtin/builtin_test.go |  13 +++
 builtin/lib.go          | 154 ++++++++++++++++++++++++------
 builtin/validation.go   |  38 ++++++++
 4 files changed, 206 insertions(+), 200 deletions(-)
 create mode 100644 builtin/validation.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index fc48e111a..7bf377df2 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -135,42 +135,21 @@ var Builtins = []*Function{
 		Name: "ceil",
 		Fast: Ceil,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
-				return floatType, nil
-			}
-			return anyType, fmt.Errorf("invalid argument for ceil (type %s)", args[0])
+			return validateRoundFunc("ceil", args)
 		},
 	},
 	{
 		Name: "floor",
 		Fast: Floor,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
-				return floatType, nil
-			}
-			return anyType, fmt.Errorf("invalid argument for floor (type %s)", args[0])
+			return validateRoundFunc("floor", args)
 		},
 	},
 	{
 		Name: "round",
 		Fast: Round,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
-				return floatType, nil
-			}
-			return anyType, fmt.Errorf("invalid argument for floor (type %s)", args[0])
+			return validateRoundFunc("round", args)
 		},
 	},
 	{
@@ -392,185 +371,63 @@ var Builtins = []*Function{
 	},
 	{
 		Name: "max",
-		Func: Max,
+		Func: func(args ...any) (any, error) {
+			return minMax("max", runtime.Less, args...)
+		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			switch len(args) {
-			case 0:
-				return anyType, fmt.Errorf("not enough arguments to call max")
-			case 1:
-				if kindName := kind(args[0]); kindName == reflect.Array || kindName == reflect.Slice {
-					return anyType, nil
-				}
-				fallthrough
-			default:
-				for _, arg := range args {
-					switch kind(arg) {
-					case reflect.Interface, reflect.Array, reflect.Slice:
-						return anyType, nil
-					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
-					default:
-						return anyType, fmt.Errorf("invalid argument for max (type %s)", arg)
-					}
-				}
-				return args[0], nil
-			}
+			return validateAggregateFunc("max", args)
 		},
 	},
 	{
 		Name: "min",
-		Func: Min,
+		Func: func(args ...any) (any, error) {
+			return minMax("min", runtime.More, args...)
+		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			switch len(args) {
-			case 0:
-				return anyType, fmt.Errorf("not enough arguments to call min")
-			case 1:
-				if kindName := kind(args[0]); kindName == reflect.Array || kindName == reflect.Slice {
-					return anyType, nil
-				}
-				fallthrough
-			default:
-				for _, arg := range args {
-					switch kind(arg) {
-					case reflect.Interface, reflect.Array, reflect.Slice:
-						return anyType, nil
-					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
-					default:
-						return anyType, fmt.Errorf("invalid argument for min (type %s)", arg)
-					}
-				}
-				return args[0], nil
-
-			}
+			return validateAggregateFunc("min", args)
 		},
 	},
 	{
 		Name: "sum",
-		Func: func(args ...any) (any, error) {
-			if len(args) != 1 {
-				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			v := reflect.ValueOf(args[0])
-			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
-				return nil, fmt.Errorf("cannot sum %s", v.Kind())
-			}
-			sum := int64(0)
-			i := 0
-			for ; i < v.Len(); i++ {
-				it := deref.Value(v.Index(i))
-				if it.CanInt() {
-					sum += it.Int()
-				} else if it.CanFloat() {
-					goto float
-				} else {
-					return nil, fmt.Errorf("cannot sum %s", it.Kind())
-				}
-			}
-			return int(sum), nil
-		float:
-			fSum := float64(sum)
-			for ; i < v.Len(); i++ {
-				it := deref.Value(v.Index(i))
-				if it.CanInt() {
-					fSum += float64(it.Int())
-				} else if it.CanFloat() {
-					fSum += it.Float()
-				} else {
-					return nil, fmt.Errorf("cannot sum %s", it.Kind())
-				}
-			}
-			return fSum, nil
-		},
+		Func: sum,
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Interface, reflect.Slice, reflect.Array:
-			default:
-				return anyType, fmt.Errorf("cannot sum %s", args[0])
-			}
-			return anyType, nil
+			return validateAggregateFunc("sum", args)
 		},
 	},
 	{
 		Name: "mean",
 		Func: func(args ...any) (any, error) {
-			if len(args) != 1 {
-				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			v := reflect.ValueOf(args[0])
-			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
-				return nil, fmt.Errorf("cannot mean %s", v.Kind())
+			count, sum, err := mean(args...)
+			if err != nil {
+				return nil, err
 			}
-			if v.Len() == 0 {
+			if count == 0 {
 				return 0.0, nil
 			}
-			sum := float64(0)
-			i := 0
-			for ; i < v.Len(); i++ {
-				it := deref.Value(v.Index(i))
-				if it.CanInt() {
-					sum += float64(it.Int())
-				} else if it.CanFloat() {
-					sum += it.Float()
-				} else {
-					return nil, fmt.Errorf("cannot mean %s", it.Kind())
-				}
-			}
-			return sum / float64(i), nil
+			return sum / float64(count), nil
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Interface, reflect.Slice, reflect.Array:
-			default:
-				return anyType, fmt.Errorf("cannot avg %s", args[0])
-			}
-			return floatType, nil
+			return validateAggregateFunc("mean", args)
 		},
 	},
 	{
 		Name: "median",
 		Func: func(args ...any) (any, error) {
-			if len(args) != 1 {
-				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			v := reflect.ValueOf(args[0])
-			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
-				return nil, fmt.Errorf("cannot median %s", v.Kind())
-			}
-			if v.Len() == 0 {
-				return 0.0, nil
+			values, err := median(args...)
+			if err != nil {
+				return nil, err
 			}
-			s := make([]float64, v.Len())
-			for i := 0; i < v.Len(); i++ {
-				it := deref.Value(v.Index(i))
-				if it.CanInt() {
-					s[i] = float64(it.Int())
-				} else if it.CanFloat() {
-					s[i] = it.Float()
-				} else {
-					return nil, fmt.Errorf("cannot median %s", it.Kind())
+			if n := len(values); n > 0 {
+				sort.Float64s(values)
+				if n%2 == 1 {
+					return values[n/2], nil
 				}
+				return (values[n/2-1] + values[n/2]) / 2, nil
 			}
-			sort.Float64s(s)
-			if len(s)%2 == 0 {
-				return (s[len(s)/2-1] + s[len(s)/2]) / 2, nil
-			}
-			return s[len(s)/2], nil
+			return 0.0, nil
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			if len(args) != 1 {
-				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
-			}
-			switch kind(args[0]) {
-			case reflect.Interface, reflect.Slice, reflect.Array:
-			default:
-				return anyType, fmt.Errorf("cannot median %s", args[0])
-			}
-			return floatType, nil
+			return validateAggregateFunc("median", args)
 		},
 	},
 	{
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index bc1a2e149..aa324c9be 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -85,19 +85,29 @@ func TestBuiltin(t *testing.T) {
 		{`min(1.5, 2.5, 3.5)`, 1.5},
 		{`min([1, 2, 3])`, 1},
 		{`min([1.5, 2.5, 3.5])`, 1.5},
+		{`min(-1, [1.5, 2.5, 3.5])`, -1},
 		{`sum(1..9)`, 45},
 		{`sum([.5, 1.5, 2.5])`, 4.5},
 		{`sum([])`, 0},
 		{`sum([1, 2, 3.0, 4])`, 10.0},
+		{`sum(10, [1, 2, 3], 1..9)`, 61},
+		{`sum(-10, [1, 2, 3, 4])`, 0},
+		{`sum(-10.9, [1, 2, 3, 4, 9])`, 8.1},
 		{`mean(1..9)`, 5.0},
 		{`mean([.5, 1.5, 2.5])`, 1.5},
 		{`mean([])`, 0.0},
 		{`mean([1, 2, 3.0, 4])`, 2.5},
+		{`mean(10, [1, 2, 3], 1..9)`, 4.6923076923076925},
+		{`mean(-10, [1, 2, 3, 4])`, 0.0},
+		{`mean(10.9, 1..9)`, 5.59},
 		{`median(1..9)`, 5.0},
 		{`median([.5, 1.5, 2.5])`, 1.5},
 		{`median([])`, 0.0},
 		{`median([1, 2, 3])`, 2.0},
 		{`median([1, 2, 3, 4])`, 2.5},
+		{`median(10, [1, 2, 3], 1..9)`, 4.0},
+		{`median(-10, [1, 2, 3, 4])`, 2.0},
+		{`median(1..5, 4.9)`, 3.5},
 		{`toJSON({foo: 1, bar: 2})`, "{\n  \"bar\": 2,\n  \"foo\": 1\n}"},
 		{`fromJSON("[1, 2, 3]")`, []any{1.0, 2.0, 3.0}},
 		{`toBase64("hello")`, "aGVsbG8="},
@@ -207,6 +217,9 @@ func TestBuiltin_errors(t *testing.T) {
 		{`min()`, `not enough arguments to call min`},
 		{`min(1, "2")`, `invalid argument for min (type string)`},
 		{`min([1, "2"])`, `invalid argument for min (type string)`},
+		{`median(1..9, "t")`, "invalid argument for median (type string)"},
+		{`mean("s", 1..9)`, "invalid argument for mean (type string)"},
+		{`sum("s", "h")`, "invalid argument for sum (type string)"},
 		{`duration("error")`, `invalid duration`},
 		{`date("error")`, `invalid date`},
 		{`get()`, `invalid number of arguments (expected 2, got 0)`},
diff --git a/builtin/lib.go b/builtin/lib.go
index b08c2ed2b..9ff9478aa 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -6,7 +6,7 @@ import (
 	"reflect"
 	"strconv"
 
-	"github.com/expr-lang/expr/vm/runtime"
+	"github.com/expr-lang/expr/internal/deref"
 )
 
 func Len(x any) any {
@@ -254,45 +254,143 @@ func String(arg any) any {
 	return fmt.Sprintf("%v", arg)
 }
 
-func Max(args ...any) (any, error) {
-	return minMaxFunc("max", runtime.Less, args)
-}
+func sum(args ...any) (any, error) {
+	var total int
+	var fTotal float64
+
+	for _, arg := range args {
+		rv := reflect.ValueOf(deref.Deref(arg))
 
-func Min(args ...any) (any, error) {
-	return minMaxFunc("min", runtime.More, args)
+		switch rv.Kind() {
+		case reflect.Array, reflect.Slice:
+			size := rv.Len()
+			for i := 0; i < size; i++ {
+				elemSum, err := sum(rv.Index(i).Interface())
+				if err != nil {
+					return nil, err
+				}
+				switch elemSum := elemSum.(type) {
+				case int:
+					total += elemSum
+				case float64:
+					fTotal += elemSum
+				}
+			}
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			total += int(rv.Int())
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			total += int(rv.Uint())
+		case reflect.Float32, reflect.Float64:
+			fTotal += rv.Float()
+		default:
+			return nil, fmt.Errorf("invalid argument for sum (type %T)", arg)
+		}
+	}
+
+	if fTotal != 0.0 {
+		return fTotal + float64(total), nil
+	}
+	return total, nil
 }
 
-func minMaxFunc(name string, fn func(any, any) bool, args []any) (any, error) {
+func minMax(name string, fn func(any, any) bool, args ...any) (any, error) {
 	var val any
 	for _, arg := range args {
-		switch v := arg.(type) {
-		case []float32, []float64, []uint, []uint8, []uint16, []uint32, []uint64, []int, []int8, []int16, []int32, []int64:
-			rv := reflect.ValueOf(v)
-			if rv.Len() == 0 {
-				return nil, fmt.Errorf("not enough arguments to call %s", name)
-			}
-			arg = rv.Index(0).Interface()
-			for i := 1; i < rv.Len(); i++ {
-				elem := rv.Index(i).Interface()
-				if fn(arg, elem) {
-					arg = elem
+		rv := reflect.ValueOf(deref.Deref(arg))
+		switch rv.Kind() {
+		case reflect.Array, reflect.Slice:
+			size := rv.Len()
+			for i := 0; i < size; i++ {
+				elemVal, err := minMax(name, fn, rv.Index(i).Interface())
+				if err != nil {
+					return nil, err
+				}
+				switch elemVal.(type) {
+				case int, int8, int16, int32, int64,
+					uint, uint8, uint16, uint32, uint64,
+					float32, float64:
+					if elemVal != nil && (val == nil || fn(val, elemVal)) {
+						val = elemVal
+					}
+				default:
+					return nil, fmt.Errorf("invalid argument for %s (type %T)", name, elemVal)
 				}
+
 			}
-		case []any:
-			var err error
-			if arg, err = minMaxFunc(name, fn, v); err != nil {
-				return nil, err
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+			reflect.Float32, reflect.Float64:
+			elemVal := rv.Interface()
+			if val == nil || fn(val, elemVal) {
+				val = elemVal
 			}
-		case float32, float64, uint, uint8, uint16, uint32, uint64, int, int8, int16, int32, int64:
 		default:
 			if len(args) == 1 {
-				return arg, nil
+				return args[0], nil
 			}
-			return nil, fmt.Errorf("invalid argument for %s (type %T)", name, v)
-		}
-		if val == nil || fn(val, arg) {
-			val = arg
+			return nil, fmt.Errorf("invalid argument for %s (type %T)", name, arg)
 		}
 	}
 	return val, nil
 }
+
+func mean(args ...any) (int, float64, error) {
+	var total float64
+	var count int
+
+	for _, arg := range args {
+		rv := reflect.ValueOf(deref.Deref(arg))
+		switch rv.Kind() {
+		case reflect.Array, reflect.Slice:
+			size := rv.Len()
+			for i := 0; i < size; i++ {
+				elemCount, elemSum, err := mean(rv.Index(i).Interface())
+				if err != nil {
+					return 0, 0, err
+				}
+				total += elemSum
+				count += elemCount
+			}
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			total += float64(rv.Int())
+			count++
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			total += float64(rv.Uint())
+			count++
+		case reflect.Float32, reflect.Float64:
+			total += rv.Float()
+			count++
+		default:
+			return 0, 0, fmt.Errorf("invalid argument for mean (type %T)", arg)
+		}
+	}
+	return count, total, nil
+}
+
+func median(args ...any) ([]float64, error) {
+	var values []float64
+
+	for _, arg := range args {
+		rv := reflect.ValueOf(deref.Deref(arg))
+		switch rv.Kind() {
+		case reflect.Array, reflect.Slice:
+			size := rv.Len()
+			for i := 0; i < size; i++ {
+				elems, err := median(rv.Index(i).Interface())
+				if err != nil {
+					return nil, err
+				}
+				values = append(values, elems...)
+			}
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			values = append(values, float64(rv.Int()))
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			values = append(values, float64(rv.Uint()))
+		case reflect.Float32, reflect.Float64:
+			values = append(values, rv.Float())
+		default:
+			return nil, fmt.Errorf("invalid argument for median (type %T)", arg)
+		}
+	}
+	return values, nil
+}
diff --git a/builtin/validation.go b/builtin/validation.go
new file mode 100644
index 000000000..057f247e9
--- /dev/null
+++ b/builtin/validation.go
@@ -0,0 +1,38 @@
+package builtin
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/expr-lang/expr/internal/deref"
+)
+
+func validateAggregateFunc(name string, args []reflect.Type) (reflect.Type, error) {
+	switch len(args) {
+	case 0:
+		return anyType, fmt.Errorf("not enough arguments to call %s", name)
+	default:
+		for _, arg := range args {
+			switch kind(deref.Type(arg)) {
+			case reflect.Interface, reflect.Array, reflect.Slice:
+				return anyType, nil
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
+			default:
+				return anyType, fmt.Errorf("invalid argument for %s (type %s)", name, arg)
+			}
+		}
+		return args[0], nil
+	}
+}
+
+func validateRoundFunc(name string, args []reflect.Type) (reflect.Type, error) {
+	if len(args) != 1 {
+		return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+	}
+	switch kind(args[0]) {
+	case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
+		return floatType, nil
+	default:
+		return anyType, fmt.Errorf("invalid argument for %s (type %s)", name, args[0])
+	}
+}

From 0e9136ef319565b80ca63ef4b35780d329d0dfff Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Mon, 4 Mar 2024 19:10:33 +0530
Subject: [PATCH 299/506] Fix `-1 not in []` expressions (#590)

---
 compiler/compiler_test.go   | 33 +++++++++++++
 expr_test.go                |  8 +++
 parser/operator/operator.go |  9 ++++
 parser/parser.go            | 99 ++++++++++++++++++++-----------------
 parser/parser_test.go       | 61 +++++++++++++++++++++++
 5 files changed, 164 insertions(+), 46 deletions(-)

diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index 741142a77..fbd83ec86 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -541,6 +541,39 @@ func TestCompile_optimizes_jumps(t *testing.T) {
 				{vm.OpFetch, 0},
 			},
 		},
+		{
+			`-1 not in [1, 2, 5]`,
+			[]op{
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpIn, 0},
+				{vm.OpNot, 0},
+			},
+		},
+		{
+			`1 + 8 not in [1, 2, 5]`,
+			[]op{
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpIn, 0},
+				{vm.OpNot, 0},
+			},
+		},
+		{
+			`true ? false : 8 not in [1, 2, 5]`,
+			[]op{
+				{vm.OpTrue, 0},
+				{vm.OpJumpIfFalse, 3},
+				{vm.OpPop, 0},
+				{vm.OpFalse, 0},
+				{vm.OpJump, 5},
+				{vm.OpPop, 0},
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpIn, 0},
+				{vm.OpNot, 0},
+			},
+		},
 	}
 
 	for _, test := range tests {
diff --git a/expr_test.go b/expr_test.go
index a4321c575..46cb8fe89 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -785,6 +785,10 @@ func TestExpr(t *testing.T) {
 			`Two not    in 0..1`,
 			true,
 		},
+		{
+			`-1 not in [1]`,
+			true,
+		},
 		{
 			`Int32 in [10, 20]`,
 			false,
@@ -797,6 +801,10 @@ func TestExpr(t *testing.T) {
 			`String matches ("^" + String + "$")`,
 			true,
 		},
+		{
+			`'foo' + 'bar' not matches 'foobar'`,
+			false,
+		},
 		{
 			`"foobar" contains "bar"`,
 			true,
diff --git a/parser/operator/operator.go b/parser/operator/operator.go
index 411a0e2bc..4eeaf80ed 100644
--- a/parser/operator/operator.go
+++ b/parser/operator/operator.go
@@ -20,6 +20,15 @@ func IsBoolean(op string) bool {
 	return op == "and" || op == "or" || op == "&&" || op == "||"
 }
 
+func AllowedNegateSuffix(op string) bool {
+	switch op {
+	case "contains", "matches", "startsWith", "endsWith", "in":
+		return true
+	default:
+		return false
+	}
+}
+
 var Unary = map[string]Operator{
 	"not": {50, Left},
 	"!":   {50, Left},
diff --git a/parser/parser.go b/parser/parser.go
index 9114bc0c9..9cb79cbbb 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -126,10 +126,8 @@ func (p *parser) expect(kind Kind, values ...string) {
 // parse functions
 
 func (p *parser) parseExpression(precedence int) Node {
-	if precedence == 0 {
-		if p.current.Is(Operator, "let") {
-			return p.parseVariableDeclaration()
-		}
+	if precedence == 0 && p.current.Is(Operator, "let") {
+		return p.parseVariableDeclaration()
 	}
 
 	nodeLeft := p.parsePrimary()
@@ -137,62 +135,71 @@ func (p *parser) parseExpression(precedence int) Node {
 	prevOperator := ""
 	opToken := p.current
 	for opToken.Is(Operator) && p.err == nil {
-		negate := false
+		negate := opToken.Is(Operator, "not")
 		var notToken Token
 
 		// Handle "not *" operator, like "not in" or "not contains".
-		if opToken.Is(Operator, "not") {
+		if negate {
+			currentPos := p.pos
 			p.next()
-			notToken = p.current
-			negate = true
-			opToken = p.current
+			if operator.AllowedNegateSuffix(p.current.Value) {
+				if op, ok := operator.Binary[p.current.Value]; ok && op.Precedence >= precedence {
+					notToken = p.current
+					opToken = p.current
+				} else {
+					p.pos = currentPos
+					p.current = opToken
+					break
+				}
+			} else {
+				p.error("unexpected token %v", p.current)
+				break
+			}
 		}
 
-		if op, ok := operator.Binary[opToken.Value]; ok {
-			if op.Precedence >= precedence {
-				p.next()
+		if op, ok := operator.Binary[opToken.Value]; ok && op.Precedence >= precedence {
+			p.next()
 
-				if opToken.Value == "|" {
-					identToken := p.current
-					p.expect(Identifier)
-					nodeLeft = p.parseCall(identToken, []Node{nodeLeft}, true)
-					goto next
-				}
+			if opToken.Value == "|" {
+				identToken := p.current
+				p.expect(Identifier)
+				nodeLeft = p.parseCall(identToken, []Node{nodeLeft}, true)
+				goto next
+			}
 
-				if prevOperator == "??" && opToken.Value != "??" && !opToken.Is(Bracket, "(") {
-					p.errorAt(opToken, "Operator (%v) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses.", opToken.Value)
-					break
-				}
+			if prevOperator == "??" && opToken.Value != "??" && !opToken.Is(Bracket, "(") {
+				p.errorAt(opToken, "Operator (%v) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses.", opToken.Value)
+				break
+			}
 
-				if operator.IsComparison(opToken.Value) {
-					nodeLeft = p.parseComparison(nodeLeft, opToken, op.Precedence)
-					goto next
-				}
+			if operator.IsComparison(opToken.Value) {
+				nodeLeft = p.parseComparison(nodeLeft, opToken, op.Precedence)
+				goto next
+			}
 
-				var nodeRight Node
-				if op.Associativity == operator.Left {
-					nodeRight = p.parseExpression(op.Precedence + 1)
-				} else {
-					nodeRight = p.parseExpression(op.Precedence)
-				}
+			var nodeRight Node
+			if op.Associativity == operator.Left {
+				nodeRight = p.parseExpression(op.Precedence + 1)
+			} else {
+				nodeRight = p.parseExpression(op.Precedence)
+			}
 
-				nodeLeft = &BinaryNode{
-					Operator: opToken.Value,
-					Left:     nodeLeft,
-					Right:    nodeRight,
-				}
-				nodeLeft.SetLocation(opToken.Location)
+			nodeLeft = &BinaryNode{
+				Operator: opToken.Value,
+				Left:     nodeLeft,
+				Right:    nodeRight,
+			}
+			nodeLeft.SetLocation(opToken.Location)
 
-				if negate {
-					nodeLeft = &UnaryNode{
-						Operator: "not",
-						Node:     nodeLeft,
-					}
-					nodeLeft.SetLocation(notToken.Location)
+			if negate {
+				nodeLeft = &UnaryNode{
+					Operator: "not",
+					Node:     nodeLeft,
 				}
-
-				goto next
+				nodeLeft.SetLocation(notToken.Location)
 			}
+
+			goto next
 		}
 		break
 
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 9225e1028..2a30787a0 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -365,6 +365,62 @@ world`},
 			&UnaryNode{Operator: "not",
 				Node: &IdentifierNode{Value: "in_var"}},
 		},
+		{
+			"-1 not in [1, 2, 3, 4]",
+			&UnaryNode{Operator: "not",
+				Node: &BinaryNode{Operator: "in",
+					Left: &UnaryNode{Operator: "-", Node: &IntegerNode{Value: 1}},
+					Right: &ArrayNode{Nodes: []Node{
+						&IntegerNode{Value: 1},
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3},
+						&IntegerNode{Value: 4},
+					}}}},
+		},
+		{
+			"1*8 not in [1, 2, 3, 4]",
+			&UnaryNode{Operator: "not",
+				Node: &BinaryNode{Operator: "in",
+					Left: &BinaryNode{Operator: "*",
+						Left:  &IntegerNode{Value: 1},
+						Right: &IntegerNode{Value: 8},
+					},
+					Right: &ArrayNode{Nodes: []Node{
+						&IntegerNode{Value: 1},
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3},
+						&IntegerNode{Value: 4},
+					}}}},
+		},
+		{
+			"2==2 ? false : 3 not in [1, 2, 5]",
+			&ConditionalNode{
+				Cond: &BinaryNode{
+					Operator: "==",
+					Left:     &IntegerNode{Value: 2},
+					Right:    &IntegerNode{Value: 2},
+				},
+				Exp1: &BoolNode{Value: false},
+				Exp2: &UnaryNode{
+					Operator: "not",
+					Node: &BinaryNode{
+						Operator: "in",
+						Left:     &IntegerNode{Value: 3},
+						Right: &ArrayNode{Nodes: []Node{
+							&IntegerNode{Value: 1},
+							&IntegerNode{Value: 2},
+							&IntegerNode{Value: 5},
+						}}}}},
+		},
+		{
+			"'foo' + 'bar' not matches 'foobar'",
+			&UnaryNode{Operator: "not",
+				Node: &BinaryNode{Operator: "matches",
+					Left: &BinaryNode{Operator: "+",
+						Left:  &StringNode{Value: "foo"},
+						Right: &StringNode{Value: "bar"}},
+					Right: &StringNode{Value: "foobar"}}},
+		},
 		{
 			"all(Tickets, #)",
 			&BuiltinNode{
@@ -706,6 +762,11 @@ invalid float literal: strconv.ParseFloat: parsing "0o1E+1": invalid syntax (1:6
 invalid float literal: strconv.ParseFloat: parsing "1E": invalid syntax (1:2)
  | 1E
  | .^
+
+1 not == [1, 2, 5]
+unexpected token Operator("==") (1:7)
+ | 1 not == [1, 2, 5]
+ | ......^
 `
 
 func TestParse_error(t *testing.T) {

From 5708180cb26fa2e6d25be8d1a59e40ab5dc8dd3e Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Sun, 17 Mar 2024 14:51:53 +0700
Subject: [PATCH 300/506] `expr.Operator` passes before `expr.Env` caused error
 (#606)

---
 checker/checker_test.go |  2 +-
 conf/config.go          |  6 +++++-
 expr_test.go            | 14 ++++++++++++++
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/checker/checker_test.go b/checker/checker_test.go
index d6a84abc5..29c50807e 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -632,7 +632,7 @@ func TestCheck_TaggedFieldName(t *testing.T) {
 	tree, err := parser.Parse(`foo.bar`)
 	require.NoError(t, err)
 
-	config := &conf.Config{}
+	config := conf.CreateNew()
 	expr.Env(struct {
 		x struct {
 			y bool `expr:"bar"`
diff --git a/conf/config.go b/conf/config.go
index 799898109..01a407a10 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -32,6 +32,7 @@ type Config struct {
 func CreateNew() *Config {
 	c := &Config{
 		Optimize:  true,
+		Types:     make(TypesTable),
 		ConstFns:  make(map[string]reflect.Value),
 		Functions: make(map[string]*builtin.Function),
 		Builtins:  make(map[string]*builtin.Function),
@@ -62,7 +63,10 @@ func (c *Config) WithEnv(env any) {
 	}
 
 	c.Env = env
-	c.Types = CreateTypesTable(env)
+	types := CreateTypesTable(env)
+	for name, t := range types {
+		c.Types[name] = t
+	}
 	c.MapEnv = mapEnv
 	c.DefaultType = mapValueType
 	c.Strict = true
diff --git a/expr_test.go b/expr_test.go
index 46cb8fe89..790fdd5d9 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2511,6 +2511,20 @@ func TestRaceCondition_variables(t *testing.T) {
 	wg.Wait()
 }
 
+func TestOperatorDependsOnEnv(t *testing.T) {
+	env := map[string]any{
+		"plus": func(a, b int) int {
+			return 42
+		},
+	}
+	program, err := expr.Compile(`1 + 2`, expr.Operator("+", "plus"), expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, 42, out)
+}
+
 func TestArrayComparison(t *testing.T) {
 	tests := []struct {
 		env  any

From 9748859e10fef2bd8a6c3e07bfb54b95ac81631b Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Thu, 21 Mar 2024 02:06:04 +0700
Subject: [PATCH 301/506] builtin `int` unwraps underlying int value (#611)

---
 builtin/builtin_test.go | 14 ++++++++++++++
 builtin/lib.go          |  4 ++++
 2 files changed, 18 insertions(+)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index aa324c9be..7f5045f41 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -612,3 +612,17 @@ func TestBuiltin_bitOpsFunc(t *testing.T) {
 		})
 	}
 }
+
+type customInt int
+
+func Test_int_unwraps_underlying_value(t *testing.T) {
+	env := map[string]any{
+		"customInt": customInt(42),
+	}
+	program, err := expr.Compile(`int(customInt) == 42`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, true, out)
+}
diff --git a/builtin/lib.go b/builtin/lib.go
index 9ff9478aa..e3a6c0aef 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -209,6 +209,10 @@ func Int(x any) any {
 		}
 		return i
 	default:
+		val := reflect.ValueOf(x)
+		if val.CanConvert(integerType) {
+			return val.Convert(integerType).Interface()
+		}
 		panic(fmt.Sprintf("invalid operation: int(%T)", x))
 	}
 }

From fcebdadc96f31afb134e2f31d056418e5a5a0f74 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 27 Mar 2024 09:26:56 +0100
Subject: [PATCH 302/506] Better map ast printing

---
 ast/print.go      | 8 +++++++-
 ast/print_test.go | 5 +++--
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/ast/print.go b/ast/print.go
index fa593ae28..063e9eb27 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -202,5 +202,11 @@ func (n *MapNode) String() string {
 }
 
 func (n *PairNode) String() string {
-	return fmt.Sprintf("%s: %s", n.Key.String(), n.Value.String())
+	if str, ok := n.Key.(*StringNode); ok {
+		if utils.IsValidIdentifier(str.Value) {
+			return fmt.Sprintf("%s: %s", str.Value, n.Value.String())
+		}
+		return fmt.Sprintf("%q: %s", str.String(), n.Value.String())
+	}
+	return fmt.Sprintf("(%s): %s", n.Key.String(), n.Value.String())
 }
diff --git a/ast/print_test.go b/ast/print_test.go
index 16d64357b..d9e55c2ea 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -55,8 +55,8 @@ func TestPrint(t *testing.T) {
 		{`func(a)`, `func(a)`},
 		{`func(a, b)`, `func(a, b)`},
 		{`{}`, `{}`},
-		{`{a: b}`, `{"a": b}`},
-		{`{a: b, c: d}`, `{"a": b, "c": d}`},
+		{`{a: b}`, `{a: b}`},
+		{`{a: b, c: d}`, `{a: b, c: d}`},
 		{`[]`, `[]`},
 		{`[a]`, `[a]`},
 		{`[a, b]`, `[a, b]`},
@@ -71,6 +71,7 @@ func TestPrint(t *testing.T) {
 		{`a[1:]`, `a[1:]`},
 		{`a[:]`, `a[:]`},
 		{`(nil ?? 1) > 0`, `(nil ?? 1) > 0`},
+		{`{("a" + "b"): 42}`, `{("a" + "b"): 42}`},
 	}
 
 	for _, tt := range tests {

From 51156fa1ff9782b0318c0c38b1c4ff0e0a651f5b Mon Sep 17 00:00:00 2001
From: zhuliquan <zlqlovecode@foxmail.com>
Date: Thu, 28 Mar 2024 21:37:51 +0800
Subject: [PATCH 303/506] feat: extract code for compiling equal operator
 (#614)

---
 compiler/compiler.go | 48 ++++++++++++++++++++++----------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 808b53c9b..a38d977d5 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -395,34 +395,12 @@ func (c *compiler) UnaryNode(node *ast.UnaryNode) {
 }
 
 func (c *compiler) BinaryNode(node *ast.BinaryNode) {
-	l := kind(node.Left)
-	r := kind(node.Right)
-
-	leftIsSimple := isSimpleType(node.Left)
-	rightIsSimple := isSimpleType(node.Right)
-	leftAndRightAreSimple := leftIsSimple && rightIsSimple
-
 	switch node.Operator {
 	case "==":
-		c.compile(node.Left)
-		c.derefInNeeded(node.Left)
-		c.compile(node.Right)
-		c.derefInNeeded(node.Right)
-
-		if l == r && l == reflect.Int && leftAndRightAreSimple {
-			c.emit(OpEqualInt)
-		} else if l == r && l == reflect.String && leftAndRightAreSimple {
-			c.emit(OpEqualString)
-		} else {
-			c.emit(OpEqual)
-		}
+		c.equalBinaryNode(node)
 
 	case "!=":
-		c.compile(node.Left)
-		c.derefInNeeded(node.Left)
-		c.compile(node.Right)
-		c.derefInNeeded(node.Right)
-		c.emit(OpEqual)
+		c.equalBinaryNode(node)
 		c.emit(OpNot)
 
 	case "or", "||":
@@ -580,6 +558,28 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 	}
 }
 
+func (c *compiler) equalBinaryNode(node *ast.BinaryNode) {
+	l := kind(node.Left)
+	r := kind(node.Right)
+
+	leftIsSimple := isSimpleType(node.Left)
+	rightIsSimple := isSimpleType(node.Right)
+	leftAndRightAreSimple := leftIsSimple && rightIsSimple
+
+	c.compile(node.Left)
+	c.derefInNeeded(node.Left)
+	c.compile(node.Right)
+	c.derefInNeeded(node.Right)
+
+	if l == r && l == reflect.Int && leftAndRightAreSimple {
+		c.emit(OpEqualInt)
+	} else if l == r && l == reflect.String && leftAndRightAreSimple {
+		c.emit(OpEqualString)
+	} else {
+		c.emit(OpEqual)
+	}
+}
+
 func isSimpleType(node ast.Node) bool {
 	if node == nil {
 		return false

From 32579115c7bdf1eaa416d1b9531dd8cea4a55a64 Mon Sep 17 00:00:00 2001
From: Richard Wooding <richard.wooding@gmail.com>
Date: Mon, 8 Apr 2024 09:00:54 +0200
Subject: [PATCH 304/506] Update README.md (#619)

Add SPAN Digital as an user of expr
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index bd34c7d24..1475fe2f5 100644
--- a/README.md
+++ b/README.md
@@ -162,6 +162,7 @@ func main() {
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
+* [SPAN Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From e4f0e78896f5e5b99c567b83a546fabaeef9abf3 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 9 Apr 2024 09:47:41 +0200
Subject: [PATCH 305/506] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1475fe2f5..1a2d7dc83 100644
--- a/README.md
+++ b/README.md
@@ -162,7 +162,7 @@ func main() {
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
-* [SPAN Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products
+* [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From 4454efff153c868f9bbe3fdea362b39023298eb9 Mon Sep 17 00:00:00 2001
From: needsure <166317845+needsure@users.noreply.github.com>
Date: Tue, 9 Apr 2024 19:13:55 +0800
Subject: [PATCH 306/506] chore: fix some typos in conments (#622)

Signed-off-by: needsure <qinzhipeng@outlook.com>
---
 patcher/value/value.go         | 4 ++--
 test/operator/operator_test.go | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/patcher/value/value.go b/patcher/value/value.go
index 59351be6b..28f52be27 100644
--- a/patcher/value/value.go
+++ b/patcher/value/value.go
@@ -13,9 +13,9 @@ import (
 // ValueGetter is a Patcher that allows custom types to be represented as standard go values for use with expr.
 // It also adds the `$patcher_value_getter` function to the program for efficiently calling matching interfaces.
 //
-// The purpose of this Patcher is to make it seemless to use custom types in expressions without the need to
+// The purpose of this Patcher is to make it seamless to use custom types in expressions without the need to
 // first convert them to standard go values. It may also facilitate using already existing structs or maps as
-// environments when they contain compatabile types.
+// environments when they contain compatible types.
 //
 // An example usage may be modeling a database record with columns that have varying data types and constraints.
 // In such an example you may have custom types that, beyond storing a simple value, such as an integer, may
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index a19c191dc..b49d91cc6 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -77,7 +77,7 @@ func TestOperator_Function(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		t.Run(fmt.Sprintf(`opertor function helper test %s`, tt.input), func(t *testing.T) {
+		t.Run(fmt.Sprintf(`operator function helper test %s`, tt.input), func(t *testing.T) {
 			program, err := expr.Compile(
 				tt.input,
 				expr.Env(env),

From 582fb32d9214f6ef7a4dfcf754cb466787e15a7c Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 10 Apr 2024 10:58:17 +0200
Subject: [PATCH 307/506] Revert "Optimize boolean operations between all, any,
 one, none functions (#555)" (#625)

This reverts commit 3c03e5965172519f7bc12100db6607d6a9fae031.
---
 optimizer/optimizer.go             |   1 -
 optimizer/optimizer_test.go        | 122 -----------------------------
 optimizer/predicate_combination.go |  51 ------------
 3 files changed, 174 deletions(-)
 delete mode 100644 optimizer/predicate_combination.go

diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index 6d1fb0b54..a9c0fa3d3 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -36,6 +36,5 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &filterLen{})
 	Walk(node, &filterLast{})
 	Walk(node, &filterFirst{})
-	Walk(node, &predicateCombination{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 703bd1ceb..e45de763b 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -1,7 +1,6 @@
 package optimizer_test
 
 import (
-	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -340,124 +339,3 @@ func TestOptimize_filter_map_first(t *testing.T) {
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
-
-func TestOptimize_predicate_combination(t *testing.T) {
-	tests := []struct {
-		op     string
-		fn     string
-		wantOp string
-	}{
-		{"and", "all", "and"},
-		{"&&", "all", "&&"},
-		{"or", "all", "or"},
-		{"||", "all", "||"},
-		{"and", "any", "and"},
-		{"&&", "any", "&&"},
-		{"or", "any", "or"},
-		{"||", "any", "||"},
-		{"and", "none", "or"},
-		{"&&", "none", "||"},
-		{"and", "one", "or"},
-		{"&&", "one", "||"},
-	}
-
-	for _, tt := range tests {
-		rule := fmt.Sprintf(`%s(users, .Age > 18 and .Name != "Bob") %s %s(users, .Age < 30)`, tt.fn, tt.op, tt.fn)
-		t.Run(rule, func(t *testing.T) {
-			tree, err := parser.Parse(rule)
-			require.NoError(t, err)
-
-			err = optimizer.Optimize(&tree.Node, nil)
-			require.NoError(t, err)
-
-			expected := &ast.BuiltinNode{
-				Name: tt.fn,
-				Arguments: []ast.Node{
-					&ast.IdentifierNode{Value: "users"},
-					&ast.ClosureNode{
-						Node: &ast.BinaryNode{
-							Operator: tt.wantOp,
-							Left: &ast.BinaryNode{
-								Operator: "and",
-								Left: &ast.BinaryNode{
-									Operator: ">",
-									Left: &ast.MemberNode{
-										Node:     &ast.PointerNode{},
-										Property: &ast.StringNode{Value: "Age"},
-									},
-									Right: &ast.IntegerNode{Value: 18},
-								},
-								Right: &ast.BinaryNode{
-									Operator: "!=",
-									Left: &ast.MemberNode{
-										Node:     &ast.PointerNode{},
-										Property: &ast.StringNode{Value: "Name"},
-									},
-									Right: &ast.StringNode{Value: "Bob"},
-								},
-							},
-							Right: &ast.BinaryNode{
-								Operator: "<",
-								Left: &ast.MemberNode{
-									Node:     &ast.PointerNode{},
-									Property: &ast.StringNode{Value: "Age"},
-								},
-								Right: &ast.IntegerNode{Value: 30},
-							},
-						},
-					},
-				},
-			}
-			assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
-		})
-	}
-}
-
-func TestOptimize_predicate_combination_nested(t *testing.T) {
-	tree, err := parser.Parse(`any(users, {all(.Friends, {.Age == 18 })}) && any(users, {all(.Friends, {.Name != "Bob" })})`)
-	require.NoError(t, err)
-
-	err = optimizer.Optimize(&tree.Node, nil)
-	require.NoError(t, err)
-
-	expected := &ast.BuiltinNode{
-		Name: "any",
-		Arguments: []ast.Node{
-			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
-				Node: &ast.BuiltinNode{
-					Name: "all",
-					Arguments: []ast.Node{
-						&ast.MemberNode{
-							Node:     &ast.PointerNode{},
-							Property: &ast.StringNode{Value: "Friends"},
-						},
-						&ast.ClosureNode{
-							Node: &ast.BinaryNode{
-								Operator: "&&",
-								Left: &ast.BinaryNode{
-									Operator: "==",
-									Left: &ast.MemberNode{
-										Node:     &ast.PointerNode{},
-										Property: &ast.StringNode{Value: "Age"},
-									},
-									Right: &ast.IntegerNode{Value: 18},
-								},
-								Right: &ast.BinaryNode{
-									Operator: "!=",
-									Left: &ast.MemberNode{
-										Node:     &ast.PointerNode{},
-										Property: &ast.StringNode{Value: "Name"},
-									},
-									Right: &ast.StringNode{Value: "Bob"},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	}
-
-	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
-}
diff --git a/optimizer/predicate_combination.go b/optimizer/predicate_combination.go
deleted file mode 100644
index 2733781df..000000000
--- a/optimizer/predicate_combination.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package optimizer
-
-import (
-	. "github.com/expr-lang/expr/ast"
-	"github.com/expr-lang/expr/parser/operator"
-)
-
-type predicateCombination struct{}
-
-func (v *predicateCombination) Visit(node *Node) {
-	if op, ok := (*node).(*BinaryNode); ok && operator.IsBoolean(op.Operator) {
-		if left, ok := op.Left.(*BuiltinNode); ok {
-			if combinedOp, ok := combinedOperator(left.Name, op.Operator); ok {
-				if right, ok := op.Right.(*BuiltinNode); ok && right.Name == left.Name {
-					if left.Arguments[0].Type() == right.Arguments[0].Type() && left.Arguments[0].String() == right.Arguments[0].String() {
-						closure := &ClosureNode{
-							Node: &BinaryNode{
-								Operator: combinedOp,
-								Left:     left.Arguments[1].(*ClosureNode).Node,
-								Right:    right.Arguments[1].(*ClosureNode).Node,
-							},
-						}
-						v.Visit(&closure.Node)
-						Patch(node, &BuiltinNode{
-							Name: left.Name,
-							Arguments: []Node{
-								left.Arguments[0],
-								closure,
-							},
-						})
-					}
-				}
-			}
-		}
-	}
-}
-
-func combinedOperator(fn, op string) (string, bool) {
-	switch fn {
-	case "all", "any":
-		return op, true
-	case "one", "none":
-		switch op {
-		case "and":
-			return "or", true
-		case "&&":
-			return "||", true
-		}
-	}
-	return "", false
-}

From 55dc4e80bc10639d13f4739ea8a767edb8b357f4 Mon Sep 17 00:00:00 2001
From: Sergey <bizywiz@gmail.com>
Date: Fri, 12 Apr 2024 23:49:41 +0700
Subject: [PATCH 308/506] Optimize boolean operations between all, any, none
 functions (#626)

---
 expr_test.go                       | 189 +++++++++++++++++++++++++++++
 optimizer/optimizer.go             |   1 +
 optimizer/optimizer_test.go        | 116 ++++++++++++++++++
 optimizer/predicate_combination.go |  61 ++++++++++
 4 files changed, 367 insertions(+)
 create mode 100644 optimizer/predicate_combination.go

diff --git a/expr_test.go b/expr_test.go
index 790fdd5d9..ac8eecf48 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -901,18 +901,147 @@ func TestExpr(t *testing.T) {
 			`all(1..3, {# > 0})`,
 			true,
 		},
+		{
+			`all(1..3, {# > 0}) && all(1..3, {# < 4})`,
+			true,
+		},
+		{
+			`all(1..3, {# > 2}) && all(1..3, {# < 4})`,
+			false,
+		},
+		{
+			`all(1..3, {# > 0}) && all(1..3, {# < 2})`,
+			false,
+		},
+		{
+			`all(1..3, {# > 2}) && all(1..3, {# < 2})`,
+			false,
+		},
+		{
+			`all(1..3, {# > 0}) || all(1..3, {# < 4})`,
+			true,
+		},
+		{
+			`all(1..3, {# > 0}) || all(1..3, {# != 2})`,
+			true,
+		},
+		{
+			`all(1..3, {# != 3}) || all(1..3, {# < 4})`,
+			true,
+		},
+		{
+			`all(1..3, {# != 3}) || all(1..3, {# != 2})`,
+			false,
+		},
 		{
 			`none(1..3, {# == 0})`,
 			true,
 		},
+		{
+			`none(1..3, {# == 0}) && none(1..3, {# == 4})`,
+			true,
+		},
+		{
+			`none(1..3, {# == 0}) && none(1..3, {# == 3})`,
+			false,
+		},
+		{
+			`none(1..3, {# == 1}) && none(1..3, {# == 4})`,
+			false,
+		},
+		{
+			`none(1..3, {# == 1}) && none(1..3, {# == 3})`,
+			false,
+		},
+		{
+			`none(1..3, {# == 0}) || none(1..3, {# == 4})`,
+			true,
+		},
+		{
+			`none(1..3, {# == 0}) || none(1..3, {# == 3})`,
+			true,
+		},
+		{
+			`none(1..3, {# == 1}) || none(1..3, {# == 4})`,
+			true,
+		},
+		{
+			`none(1..3, {# == 1}) || none(1..3, {# == 3})`,
+			false,
+		},
 		{
 			`any([1,1,0,1], {# == 0})`,
 			true,
 		},
+		{
+			`any(1..3, {# == 1}) && any(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`any(1..3, {# == 0}) && any(1..3, {# == 2})`,
+			false,
+		},
+		{
+			`any(1..3, {# == 1}) && any(1..3, {# == 4})`,
+			false,
+		},
+		{
+			`any(1..3, {# == 0}) && any(1..3, {# == 4})`,
+			false,
+		},
+		{
+			`any(1..3, {# == 1}) || any(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`any(1..3, {# == 0}) || any(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`any(1..3, {# == 1}) || any(1..3, {# == 4})`,
+			true,
+		},
+		{
+			`any(1..3, {# == 0}) || any(1..3, {# == 4})`,
+			false,
+		},
 		{
 			`one([1,1,0,1], {# == 0}) and not one([1,0,0,1], {# == 0})`,
 			true,
 		},
+		{
+			`one(1..3, {# == 1}) and one(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`one(1..3, {# == 1 || # == 2}) and one(1..3, {# == 2})`,
+			false,
+		},
+		{
+			`one(1..3, {# == 1}) and one(1..3, {# == 2 || # == 3})`,
+			false,
+		},
+		{
+			`one(1..3, {# == 1 || # == 2}) and one(1..3, {# == 2 || # == 3})`,
+			false,
+		},
+		{
+			`one(1..3, {# == 1}) or one(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`one(1..3, {# == 1 || # == 2}) or one(1..3, {# == 2})`,
+			true,
+		},
+		{
+			`one(1..3, {# == 1}) or one(1..3, {# == 2 || # == 3})`,
+			true,
+		},
+		{
+			`one(1..3, {# == 1 || # == 2}) or one(1..3, {# == 2 || # == 3})`,
+			false,
+		},
+
 		{
 			`count(1..30, {# % 3 == 0})`,
 			10,
@@ -2525,6 +2654,66 @@ func TestOperatorDependsOnEnv(t *testing.T) {
 	assert.Equal(t, 42, out)
 }
 
+func TestIssue624(t *testing.T) {
+	type tag struct {
+		Name string
+	}
+
+	type item struct {
+		Tags []tag
+	}
+
+	i := item{
+		Tags: []tag{
+			{Name: "one"},
+			{Name: "two"},
+		},
+	}
+
+	rule := `[
+true && true, 
+one(Tags, .Name in ["one"]), 
+one(Tags, .Name in ["two"]), 
+one(Tags, .Name in ["one"]) && one(Tags, .Name in ["two"])
+]`
+	resp, err := expr.Eval(rule, i)
+	require.NoError(t, err)
+	require.Equal(t, []interface{}{true, true, true, true}, resp)
+}
+
+func TestPredicateCombination(t *testing.T) {
+	tests := []struct {
+		code1 string
+		code2 string
+	}{
+		{"all(1..3, {# > 0}) && all(1..3, {# < 4})", "all(1..3, {# > 0 && # < 4})"},
+		{"all(1..3, {# > 1}) && all(1..3, {# < 4})", "all(1..3, {# > 1 && # < 4})"},
+		{"all(1..3, {# > 0}) && all(1..3, {# < 2})", "all(1..3, {# > 0 && # < 2})"},
+		{"all(1..3, {# > 1}) && all(1..3, {# < 2})", "all(1..3, {# > 1 && # < 2})"},
+
+		{"any(1..3, {# > 0}) || any(1..3, {# < 4})", "any(1..3, {# > 0 || # < 4})"},
+		{"any(1..3, {# > 1}) || any(1..3, {# < 4})", "any(1..3, {# > 1 || # < 4})"},
+		{"any(1..3, {# > 0}) || any(1..3, {# < 2})", "any(1..3, {# > 0 || # < 2})"},
+		{"any(1..3, {# > 1}) || any(1..3, {# < 2})", "any(1..3, {# > 1 || # < 2})"},
+
+		{"none(1..3, {# > 0}) && none(1..3, {# < 4})", "none(1..3, {# > 0 || # < 4})"},
+		{"none(1..3, {# > 1}) && none(1..3, {# < 4})", "none(1..3, {# > 1 || # < 4})"},
+		{"none(1..3, {# > 0}) && none(1..3, {# < 2})", "none(1..3, {# > 0 || # < 2})"},
+		{"none(1..3, {# > 1}) && none(1..3, {# < 2})", "none(1..3, {# > 1 || # < 2})"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.code1, func(t *testing.T) {
+			out1, err := expr.Eval(tt.code1, nil)
+			require.NoError(t, err)
+
+			out2, err := expr.Eval(tt.code2, nil)
+			require.NoError(t, err)
+
+			require.Equal(t, out1, out2)
+		})
+	}
+}
+
 func TestArrayComparison(t *testing.T) {
 	tests := []struct {
 		env  any
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index a9c0fa3d3..6d1fb0b54 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -36,5 +36,6 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &filterLen{})
 	Walk(node, &filterLast{})
 	Walk(node, &filterFirst{})
+	Walk(node, &predicateCombination{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index e45de763b..316b17182 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -1,6 +1,7 @@
 package optimizer_test
 
 import (
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -339,3 +340,118 @@ func TestOptimize_filter_map_first(t *testing.T) {
 
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
+
+func TestOptimize_predicate_combination(t *testing.T) {
+	tests := []struct {
+		op     string
+		fn     string
+		wantOp string
+	}{
+		{"and", "all", "and"},
+		{"&&", "all", "&&"},
+		{"or", "any", "or"},
+		{"||", "any", "||"},
+		{"and", "none", "or"},
+		{"&&", "none", "||"},
+	}
+
+	for _, tt := range tests {
+		rule := fmt.Sprintf(`%s(users, .Age > 18 and .Name != "Bob") %s %s(users, .Age < 30)`, tt.fn, tt.op, tt.fn)
+		t.Run(rule, func(t *testing.T) {
+			tree, err := parser.Parse(rule)
+			require.NoError(t, err)
+
+			err = optimizer.Optimize(&tree.Node, nil)
+			require.NoError(t, err)
+
+			expected := &ast.BuiltinNode{
+				Name: tt.fn,
+				Arguments: []ast.Node{
+					&ast.IdentifierNode{Value: "users"},
+					&ast.ClosureNode{
+						Node: &ast.BinaryNode{
+							Operator: tt.wantOp,
+							Left: &ast.BinaryNode{
+								Operator: "and",
+								Left: &ast.BinaryNode{
+									Operator: ">",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Age"},
+									},
+									Right: &ast.IntegerNode{Value: 18},
+								},
+								Right: &ast.BinaryNode{
+									Operator: "!=",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Name"},
+									},
+									Right: &ast.StringNode{Value: "Bob"},
+								},
+							},
+							Right: &ast.BinaryNode{
+								Operator: "<",
+								Left: &ast.MemberNode{
+									Node:     &ast.PointerNode{},
+									Property: &ast.StringNode{Value: "Age"},
+								},
+								Right: &ast.IntegerNode{Value: 30},
+							},
+						},
+					},
+				},
+			}
+			assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+		})
+	}
+}
+
+func TestOptimize_predicate_combination_nested(t *testing.T) {
+	tree, err := parser.Parse(`all(users, {all(.Friends, {.Age == 18 })}) && all(users, {all(.Friends, {.Name != "Bob" })})`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "all",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.BuiltinNode{
+					Name: "all",
+					Arguments: []ast.Node{
+						&ast.MemberNode{
+							Node:     &ast.PointerNode{},
+							Property: &ast.StringNode{Value: "Friends"},
+						},
+						&ast.ClosureNode{
+							Node: &ast.BinaryNode{
+								Operator: "&&",
+								Left: &ast.BinaryNode{
+									Operator: "==",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Age"},
+									},
+									Right: &ast.IntegerNode{Value: 18},
+								},
+								Right: &ast.BinaryNode{
+									Operator: "!=",
+									Left: &ast.MemberNode{
+										Node:     &ast.PointerNode{},
+										Property: &ast.StringNode{Value: "Name"},
+									},
+									Right: &ast.StringNode{Value: "Bob"},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
diff --git a/optimizer/predicate_combination.go b/optimizer/predicate_combination.go
new file mode 100644
index 000000000..6e8a7f7cf
--- /dev/null
+++ b/optimizer/predicate_combination.go
@@ -0,0 +1,61 @@
+package optimizer
+
+import (
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/parser/operator"
+)
+
+/*
+predicateCombination is a visitor that combines multiple predicate calls into a single call.
+For example, the following expression:
+
+	all(x, x > 1) && all(x, x < 10) -> all(x, x > 1 && x < 10)
+	any(x, x > 1) || any(x, x < 10) -> any(x, x > 1 || x < 10)
+	none(x, x > 1) && none(x, x < 10) -> none(x, x > 1 || x < 10)
+*/
+type predicateCombination struct{}
+
+func (v *predicateCombination) Visit(node *Node) {
+	if op, ok := (*node).(*BinaryNode); ok && operator.IsBoolean(op.Operator) {
+		if left, ok := op.Left.(*BuiltinNode); ok {
+			if combinedOp, ok := combinedOperator(left.Name, op.Operator); ok {
+				if right, ok := op.Right.(*BuiltinNode); ok && right.Name == left.Name {
+					if left.Arguments[0].Type() == right.Arguments[0].Type() && left.Arguments[0].String() == right.Arguments[0].String() {
+						closure := &ClosureNode{
+							Node: &BinaryNode{
+								Operator: combinedOp,
+								Left:     left.Arguments[1].(*ClosureNode).Node,
+								Right:    right.Arguments[1].(*ClosureNode).Node,
+							},
+						}
+						v.Visit(&closure.Node)
+						Patch(node, &BuiltinNode{
+							Name: left.Name,
+							Arguments: []Node{
+								left.Arguments[0],
+								closure,
+							},
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func combinedOperator(fn, op string) (string, bool) {
+	switch {
+	case fn == "all" && (op == "and" || op == "&&"):
+		return op, true
+	case fn == "any" && (op == "or" || op == "||"):
+		return op, true
+	case fn == "none" && (op == "and" || op == "&&"):
+		switch op {
+		case "and":
+			return "or", true
+		case "&&":
+			return "||", true
+		}
+	}
+	return "", false
+}

From 524efca4b271a8ac6d62f6271c885f4e3e91002a Mon Sep 17 00:00:00 2001
From: Daenney <daenney@users.noreply.github.com>
Date: Fri, 12 Apr 2024 22:54:01 +0200
Subject: [PATCH 309/506] Make WithContext work for methods on env struct
 (#602)

This makes the WithContext patcher work when passing in a struct for an
env that has methods that take a context.

This is a bit fiddly because we can't quite detect the difference of
function vs. method on a struct, so we have to check both the first and
the second param. Since it's highly unusual to pass the context as
anything other than the first parameter, this should work out just fine
in practice.

Fixes #600.
---
 patcher/with_context.go      | 15 +++++++++++----
 patcher/with_context_test.go | 24 ++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/patcher/with_context.go b/patcher/with_context.go
index 55b604261..f9861a2c2 100644
--- a/patcher/with_context.go
+++ b/patcher/with_context.go
@@ -22,11 +22,18 @@ func (w WithContext) Visit(node *ast.Node) {
 		if fn.Kind() != reflect.Func {
 			return
 		}
-		if fn.NumIn() == 0 {
-			return
-		}
-		if fn.In(0).String() != "context.Context" {
+		switch fn.NumIn() {
+		case 0:
 			return
+		case 1:
+			if fn.In(0).String() != "context.Context" {
+				return
+			}
+		default:
+			if fn.In(0).String() != "context.Context" &&
+				fn.In(1).String() != "context.Context" {
+				return
+			}
 		}
 		ast.Patch(node, &ast.CallNode{
 			Callee: call.Callee,
diff --git a/patcher/with_context_test.go b/patcher/with_context_test.go
index afad4e6f0..5ce64191f 100644
--- a/patcher/with_context_test.go
+++ b/patcher/with_context_test.go
@@ -62,6 +62,30 @@ func TestWithContext_with_env_Function(t *testing.T) {
 	require.Equal(t, 42, output)
 }
 
+type testEnvContext struct {
+	Context context.Context `expr:"ctx"`
+}
+
+func (testEnvContext) Fn(ctx context.Context, a int) int {
+	return ctx.Value("value").(int) + a
+}
+
+func TestWithContext_env_struct(t *testing.T) {
+	withContext := patcher.WithContext{Name: "ctx"}
+
+	program, err := expr.Compile(`Fn(40)`, expr.Env(testEnvContext{}), expr.Patch(withContext))
+	require.NoError(t, err)
+
+	ctx := context.WithValue(context.Background(), "value", 2)
+	env := testEnvContext{
+		Context: ctx,
+	}
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 42, output)
+}
+
 type TestFoo struct {
 	contextValue int
 }

From 38f949658f8e27c1e9367487b4769b51128c36e9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 13 Apr 2024 15:37:02 +0200
Subject: [PATCH 310/506] Add predicate to sum() builtin (#592)

* Add predicate to sum() builtin

* go mod tidy
---
 builtin/builtin.go        | 12 +++++-------
 builtin/builtin_test.go   |  4 ----
 builtin/lib.go            | 39 ---------------------------------------
 checker/checker.go        | 23 +++++++++++++++++++++++
 compiler/compiler.go      | 19 +++++++++++++++++++
 parser/parser.go          |  1 +
 test/fuzz/fuzz_corpus.txt |  1 -
 testdata/examples.txt     | 14 --------------
 8 files changed, 48 insertions(+), 65 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 7bf377df2..efc01fc2f 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -83,6 +83,11 @@ var Builtins = []*Function{
 		Predicate: true,
 		Types:     types(new(func([]any, func(any) bool) int)),
 	},
+	{
+		Name:      "sum",
+		Predicate: true,
+		Types:     types(new(func([]any, func(any) bool) int)),
+	},
 	{
 		Name:      "groupBy",
 		Predicate: true,
@@ -387,13 +392,6 @@ var Builtins = []*Function{
 			return validateAggregateFunc("min", args)
 		},
 	},
-	{
-		Name: "sum",
-		Func: sum,
-		Validate: func(args []reflect.Type) (reflect.Type, error) {
-			return validateAggregateFunc("sum", args)
-		},
-	},
 	{
 		Name: "mean",
 		Func: func(args ...any) (any, error) {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 7f5045f41..307d4a86a 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -90,9 +90,6 @@ func TestBuiltin(t *testing.T) {
 		{`sum([.5, 1.5, 2.5])`, 4.5},
 		{`sum([])`, 0},
 		{`sum([1, 2, 3.0, 4])`, 10.0},
-		{`sum(10, [1, 2, 3], 1..9)`, 61},
-		{`sum(-10, [1, 2, 3, 4])`, 0},
-		{`sum(-10.9, [1, 2, 3, 4, 9])`, 8.1},
 		{`mean(1..9)`, 5.0},
 		{`mean([.5, 1.5, 2.5])`, 1.5},
 		{`mean([])`, 0.0},
@@ -219,7 +216,6 @@ func TestBuiltin_errors(t *testing.T) {
 		{`min([1, "2"])`, `invalid argument for min (type string)`},
 		{`median(1..9, "t")`, "invalid argument for median (type string)"},
 		{`mean("s", 1..9)`, "invalid argument for mean (type string)"},
-		{`sum("s", "h")`, "invalid argument for sum (type string)"},
 		{`duration("error")`, `invalid duration`},
 		{`date("error")`, `invalid date`},
 		{`get()`, `invalid number of arguments (expected 2, got 0)`},
diff --git a/builtin/lib.go b/builtin/lib.go
index e3a6c0aef..e3cd61b96 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -258,45 +258,6 @@ func String(arg any) any {
 	return fmt.Sprintf("%v", arg)
 }
 
-func sum(args ...any) (any, error) {
-	var total int
-	var fTotal float64
-
-	for _, arg := range args {
-		rv := reflect.ValueOf(deref.Deref(arg))
-
-		switch rv.Kind() {
-		case reflect.Array, reflect.Slice:
-			size := rv.Len()
-			for i := 0; i < size; i++ {
-				elemSum, err := sum(rv.Index(i).Interface())
-				if err != nil {
-					return nil, err
-				}
-				switch elemSum := elemSum.(type) {
-				case int:
-					total += elemSum
-				case float64:
-					fTotal += elemSum
-				}
-			}
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			total += int(rv.Int())
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			total += int(rv.Uint())
-		case reflect.Float32, reflect.Float64:
-			fTotal += rv.Float()
-		default:
-			return nil, fmt.Errorf("invalid argument for sum (type %T)", arg)
-		}
-	}
-
-	if fTotal != 0.0 {
-		return fTotal + float64(total), nil
-	}
-	return total, nil
-}
-
 func minMax(name string, fn func(any, any) bool, args ...any) (any, error) {
 	var val any
 	for _, arg := range args {
diff --git a/checker/checker.go b/checker/checker.go
index b46178d43..a6daa27b9 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -668,6 +668,29 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
+	case "sum":
+		collection, _ := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isAny(collection) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		}
+
+		if len(node.Arguments) == 2 {
+			v.begin(collection)
+			closure, _ := v.visit(node.Arguments[1])
+			v.end()
+
+			if isFunc(closure) &&
+				closure.NumOut() == 1 &&
+				closure.NumIn() == 1 && isAny(closure.In(0)) {
+				return closure.Out(0), info{}
+			}
+		} else {
+			if isAny(collection) {
+				return anyType, info{}
+			}
+			return collection.Elem(), info{}
+		}
+
 	case "find", "findLast":
 		collection, _ := v.visit(node.Arguments[0])
 		if !isArray(collection) && !isAny(collection) {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index a38d977d5..07bc58b87 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -809,6 +809,25 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.emit(OpEnd)
 		return
 
+	case "sum":
+		c.compile(node.Arguments[0])
+		c.emit(OpBegin)
+		c.emit(OpInt, 0)
+		c.emit(OpSetAcc)
+		c.emitLoop(func() {
+			if len(node.Arguments) == 2 {
+				c.compile(node.Arguments[1])
+			} else {
+				c.emit(OpPointer)
+			}
+			c.emit(OpGetAcc)
+			c.emit(OpAdd)
+			c.emit(OpSetAcc)
+		})
+		c.emit(OpGetAcc)
+		c.emit(OpEnd)
+		return
+
 	case "find":
 		c.compile(node.Arguments[0])
 		c.emit(OpBegin)
diff --git a/parser/parser.go b/parser/parser.go
index 9cb79cbbb..641369b1a 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -34,6 +34,7 @@ var predicates = map[string]struct {
 	"filter":        {[]arg{expr, closure}},
 	"map":           {[]arg{expr, closure}},
 	"count":         {[]arg{expr, closure}},
+	"sum":           {[]arg{expr, closure | optional}},
 	"find":          {[]arg{expr, closure}},
 	"findIndex":     {[]arg{expr, closure}},
 	"findLast":      {[]arg{expr, closure}},
diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
index 2bb8ab7fb..166548632 100644
--- a/test/fuzz/fuzz_corpus.txt
+++ b/test/fuzz/fuzz_corpus.txt
@@ -10455,7 +10455,6 @@ max(f64, i64)
 max(false ? 1 : 0.5)
 max(false ? 1 : nil)
 max(false ? add : ok)
-max(false ? half : list)
 max(false ? i : nil)
 max(false ? i32 : score)
 max(false ? true : 1)
diff --git a/testdata/examples.txt b/testdata/examples.txt
index 712aa91c0..5b9d2cdde 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -7419,12 +7419,6 @@ get(ok ? score : foo, String?.foo())
 get(ok ? score : i64, foo)
 get(reduce(list, array), i32)
 get(sort(array), i32)
-get(sum(array), Qux)
-get(sum(array), String)
-get(sum(array), f32)
-get(sum(array), f64 == list)
-get(sum(array), greet)
-get(sum(array), i)
 get(take(list, i), i64)
 get(true ? "bar" : ok, score(i))
 get(true ? "foo" : half, list)
@@ -7460,7 +7454,6 @@ greet != nil ? list : false
 greet != score
 greet != score != false
 greet != score or ok
-greet != sum(array)
 greet == add
 greet == add ? i : list
 greet == add or ok
@@ -12200,7 +12193,6 @@ last(ok ? ok : 0.5)
 last(reduce(array, list))
 last(reduce(list, array))
 last(sort(array))
-last(sum(array))
 last(true ? "bar" : half)
 last(true ? add : list)
 last(true ? foo : 1)
@@ -14818,7 +14810,6 @@ ok != nil ? nil : array
 ok != not ok
 ok != ok
 ok != ok ? false : "bar"
-ok != sum(array)
 ok && !false
 ok && !ok
 ok && "foo" matches "bar"
@@ -16970,7 +16961,6 @@ string(groupBy(list, i))
 string(half != nil)
 string(half != score)
 string(half == nil)
-string(half == sum(array))
 string(half(0.5))
 string(half(1))
 string(half(f64))
@@ -17297,18 +17287,14 @@ sum([0.5])
 sum([f32])
 sum(array)
 sum(array) != f32
-sum(array) != half
-sum(array) != ok
 sum(array) % i
 sum(array) % i64
 sum(array) - f32
 sum(array) / -f64
 sum(array) < i
-sum(array) == div
 sum(array) == i64 - i
 sum(array) ^ f64
 sum(array) not in array
-sum(array) not in list
 sum(filter(array, ok))
 sum(groupBy(array, i32).String)
 sum(groupBy(list, #)?.greet)

From edb1b5aa991fa78f420099f2bebc86de56c56900 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 13 Apr 2024 22:50:11 +0200
Subject: [PATCH 311/506] Add sum(map()) optimization

---
 optimizer/optimizer.go    |  1 +
 optimizer/sum_map.go      | 25 +++++++++++++++++++++++++
 optimizer/sum_map_test.go | 35 +++++++++++++++++++++++++++++++++++
 test/fuzz/fuzz_corpus.txt |  1 -
 4 files changed, 61 insertions(+), 1 deletion(-)
 create mode 100644 optimizer/sum_map.go
 create mode 100644 optimizer/sum_map_test.go

diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index 6d1fb0b54..edb9c14f6 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -37,5 +37,6 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &filterLast{})
 	Walk(node, &filterFirst{})
 	Walk(node, &predicateCombination{})
+	Walk(node, &sumMap{})
 	return nil
 }
diff --git a/optimizer/sum_map.go b/optimizer/sum_map.go
new file mode 100644
index 000000000..a41a53732
--- /dev/null
+++ b/optimizer/sum_map.go
@@ -0,0 +1,25 @@
+package optimizer
+
+import (
+	. "github.com/expr-lang/expr/ast"
+)
+
+type sumMap struct{}
+
+func (*sumMap) Visit(node *Node) {
+	if sumBuiltin, ok := (*node).(*BuiltinNode); ok &&
+		sumBuiltin.Name == "sum" &&
+		len(sumBuiltin.Arguments) == 1 {
+		if mapBuiltin, ok := sumBuiltin.Arguments[0].(*BuiltinNode); ok &&
+			mapBuiltin.Name == "map" &&
+			len(mapBuiltin.Arguments) == 2 {
+			Patch(node, &BuiltinNode{
+				Name: "sum",
+				Arguments: []Node{
+					mapBuiltin.Arguments[0],
+					mapBuiltin.Arguments[1],
+				},
+			})
+		}
+	}
+}
diff --git a/optimizer/sum_map_test.go b/optimizer/sum_map_test.go
new file mode 100644
index 000000000..0ce3203e2
--- /dev/null
+++ b/optimizer/sum_map_test.go
@@ -0,0 +1,35 @@
+package optimizer_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
+)
+
+func TestOptimize_sum_map(t *testing.T) {
+	tree, err := parser.Parse(`sum(map(users, {.Age}))`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "sum",
+		Arguments: []ast.Node{
+			&ast.IdentifierNode{Value: "users"},
+			&ast.ClosureNode{
+				Node: &ast.MemberNode{
+					Node:     &ast.PointerNode{},
+					Property: &ast.StringNode{Value: "Age"},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
index 166548632..7b0174923 100644
--- a/test/fuzz/fuzz_corpus.txt
+++ b/test/fuzz/fuzz_corpus.txt
@@ -5608,7 +5608,6 @@ findLastIndex(list, f64 == f64)
 findLastIndex(list, false == false)
 findLastIndex(list, false and false)
 findLastIndex(list, false and ok)
-findLastIndex(list, false) != i
 findLastIndex(list, foo != #)
 findLastIndex(list, foo == foo)
 findLastIndex(list, greet != half)

From c2b609e99b5c2229c0954beaf0eba1ed6fa50e94 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 13 Apr 2024 23:16:08 +0200
Subject: [PATCH 312/506] Add sum([]) optimization

---
 expr_test.go                | 141 ------------------------------------
 optimizer/optimizer.go      |   1 +
 optimizer/optimizer_test.go |  73 +++++++++++++++++++
 optimizer/sum_array.go      |  37 ++++++++++
 optimizer/sum_array_test.go |  73 +++++++++++++++++++
 5 files changed, 184 insertions(+), 141 deletions(-)
 create mode 100644 optimizer/sum_array.go
 create mode 100644 optimizer/sum_array_test.go

diff --git a/expr_test.go b/expr_test.go
index ac8eecf48..38b97eaa0 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -901,147 +901,6 @@ func TestExpr(t *testing.T) {
 			`all(1..3, {# > 0})`,
 			true,
 		},
-		{
-			`all(1..3, {# > 0}) && all(1..3, {# < 4})`,
-			true,
-		},
-		{
-			`all(1..3, {# > 2}) && all(1..3, {# < 4})`,
-			false,
-		},
-		{
-			`all(1..3, {# > 0}) && all(1..3, {# < 2})`,
-			false,
-		},
-		{
-			`all(1..3, {# > 2}) && all(1..3, {# < 2})`,
-			false,
-		},
-		{
-			`all(1..3, {# > 0}) || all(1..3, {# < 4})`,
-			true,
-		},
-		{
-			`all(1..3, {# > 0}) || all(1..3, {# != 2})`,
-			true,
-		},
-		{
-			`all(1..3, {# != 3}) || all(1..3, {# < 4})`,
-			true,
-		},
-		{
-			`all(1..3, {# != 3}) || all(1..3, {# != 2})`,
-			false,
-		},
-		{
-			`none(1..3, {# == 0})`,
-			true,
-		},
-		{
-			`none(1..3, {# == 0}) && none(1..3, {# == 4})`,
-			true,
-		},
-		{
-			`none(1..3, {# == 0}) && none(1..3, {# == 3})`,
-			false,
-		},
-		{
-			`none(1..3, {# == 1}) && none(1..3, {# == 4})`,
-			false,
-		},
-		{
-			`none(1..3, {# == 1}) && none(1..3, {# == 3})`,
-			false,
-		},
-		{
-			`none(1..3, {# == 0}) || none(1..3, {# == 4})`,
-			true,
-		},
-		{
-			`none(1..3, {# == 0}) || none(1..3, {# == 3})`,
-			true,
-		},
-		{
-			`none(1..3, {# == 1}) || none(1..3, {# == 4})`,
-			true,
-		},
-		{
-			`none(1..3, {# == 1}) || none(1..3, {# == 3})`,
-			false,
-		},
-		{
-			`any([1,1,0,1], {# == 0})`,
-			true,
-		},
-		{
-			`any(1..3, {# == 1}) && any(1..3, {# == 2})`,
-			true,
-		},
-		{
-			`any(1..3, {# == 0}) && any(1..3, {# == 2})`,
-			false,
-		},
-		{
-			`any(1..3, {# == 1}) && any(1..3, {# == 4})`,
-			false,
-		},
-		{
-			`any(1..3, {# == 0}) && any(1..3, {# == 4})`,
-			false,
-		},
-		{
-			`any(1..3, {# == 1}) || any(1..3, {# == 2})`,
-			true,
-		},
-		{
-			`any(1..3, {# == 0}) || any(1..3, {# == 2})`,
-			true,
-		},
-		{
-			`any(1..3, {# == 1}) || any(1..3, {# == 4})`,
-			true,
-		},
-		{
-			`any(1..3, {# == 0}) || any(1..3, {# == 4})`,
-			false,
-		},
-		{
-			`one([1,1,0,1], {# == 0}) and not one([1,0,0,1], {# == 0})`,
-			true,
-		},
-		{
-			`one(1..3, {# == 1}) and one(1..3, {# == 2})`,
-			true,
-		},
-		{
-			`one(1..3, {# == 1 || # == 2}) and one(1..3, {# == 2})`,
-			false,
-		},
-		{
-			`one(1..3, {# == 1}) and one(1..3, {# == 2 || # == 3})`,
-			false,
-		},
-		{
-			`one(1..3, {# == 1 || # == 2}) and one(1..3, {# == 2 || # == 3})`,
-			false,
-		},
-		{
-			`one(1..3, {# == 1}) or one(1..3, {# == 2})`,
-			true,
-		},
-		{
-			`one(1..3, {# == 1 || # == 2}) or one(1..3, {# == 2})`,
-			true,
-		},
-		{
-			`one(1..3, {# == 1}) or one(1..3, {# == 2 || # == 3})`,
-			true,
-		},
-		{
-			`one(1..3, {# == 1 || # == 2}) or one(1..3, {# == 2 || # == 3})`,
-			false,
-		},
-
 		{
 			`count(1..30, {# % 3 == 0})`,
 			10,
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index edb9c14f6..4ceb3fa43 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -37,6 +37,7 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &filterLast{})
 	Walk(node, &filterFirst{})
 	Walk(node, &predicateCombination{})
+	Walk(node, &sumArray{})
 	Walk(node, &sumMap{})
 	return nil
 }
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 316b17182..e59d2c65d 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -17,6 +17,79 @@ import (
 	"github.com/expr-lang/expr/parser"
 )
 
+func TestOptimize(t *testing.T) {
+	env := map[string]any{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	tests := []struct {
+		expr string
+		want any
+	}{
+		{`1 + 2`, 3},
+		{`sum([])`, 0},
+		{`sum([a])`, 1},
+		{`sum([a, b])`, 3},
+		{`sum([a, b, c])`, 6},
+		{`sum([a, b, c, 4])`, 10},
+		{`all(1..3, {# > 0}) && all(1..3, {# < 4})`, true},
+		{`all(1..3, {# > 2}) && all(1..3, {# < 4})`, false},
+		{`all(1..3, {# > 0}) && all(1..3, {# < 2})`, false},
+		{`all(1..3, {# > 2}) && all(1..3, {# < 2})`, false},
+		{`all(1..3, {# > 0}) || all(1..3, {# < 4})`, true},
+		{`all(1..3, {# > 0}) || all(1..3, {# != 2})`, true},
+		{`all(1..3, {# != 3}) || all(1..3, {# < 4})`, true},
+		{`all(1..3, {# != 3}) || all(1..3, {# != 2})`, false},
+		{`none(1..3, {# == 0})`, true},
+		{`none(1..3, {# == 0}) && none(1..3, {# == 4})`, true},
+		{`none(1..3, {# == 0}) && none(1..3, {# == 3})`, false},
+		{`none(1..3, {# == 1}) && none(1..3, {# == 4})`, false},
+		{`none(1..3, {# == 1}) && none(1..3, {# == 3})`, false},
+		{`none(1..3, {# == 0}) || none(1..3, {# == 4})`, true},
+		{`none(1..3, {# == 0}) || none(1..3, {# == 3})`, true},
+		{`none(1..3, {# == 1}) || none(1..3, {# == 4})`, true},
+		{`none(1..3, {# == 1}) || none(1..3, {# == 3})`, false},
+		{`any([1, 1, 0, 1], {# == 0})`, true},
+		{`any(1..3, {# == 1}) && any(1..3, {# == 2})`, true},
+		{`any(1..3, {# == 0}) && any(1..3, {# == 2})`, false},
+		{`any(1..3, {# == 1}) && any(1..3, {# == 4})`, false},
+		{`any(1..3, {# == 0}) && any(1..3, {# == 4})`, false},
+		{`any(1..3, {# == 1}) || any(1..3, {# == 2})`, true},
+		{`any(1..3, {# == 0}) || any(1..3, {# == 2})`, true},
+		{`any(1..3, {# == 1}) || any(1..3, {# == 4})`, true},
+		{`any(1..3, {# == 0}) || any(1..3, {# == 4})`, false},
+		{`one([1, 1, 0, 1], {# == 0}) and not one([1, 0, 0, 1], {# == 0})`, true},
+		{`one(1..3, {# == 1}) and one(1..3, {# == 2})`, true},
+		{`one(1..3, {# == 1 || # == 2}) and one(1..3, {# == 2})`, false},
+		{`one(1..3, {# == 1}) and one(1..3, {# == 2 || # == 3})`, false},
+		{`one(1..3, {# == 1 || # == 2}) and one(1..3, {# == 2 || # == 3})`, false},
+		{`one(1..3, {# == 1}) or one(1..3, {# == 2})`, true},
+		{`one(1..3, {# == 1 || # == 2}) or one(1..3, {# == 2})`, true},
+		{`one(1..3, {# == 1}) or one(1..3, {# == 2 || # == 3})`, true},
+		{`one(1..3, {# == 1 || # == 2}) or one(1..3, {# == 2 || # == 3})`, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr, expr.Env(env))
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, env)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+
+			unoptimizedProgram, err := expr.Compile(tt.expr, expr.Env(env), expr.Optimize(false))
+			require.NoError(t, err)
+
+			unoptimizedOutput, err := expr.Run(unoptimizedProgram, env)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, unoptimizedOutput)
+		})
+	}
+}
+
 func TestOptimize_constant_folding(t *testing.T) {
 	tree, err := parser.Parse(`[1,2,3][5*5-25]`)
 	require.NoError(t, err)
diff --git a/optimizer/sum_array.go b/optimizer/sum_array.go
new file mode 100644
index 000000000..0a05d1f2e
--- /dev/null
+++ b/optimizer/sum_array.go
@@ -0,0 +1,37 @@
+package optimizer
+
+import (
+	"fmt"
+
+	. "github.com/expr-lang/expr/ast"
+)
+
+type sumArray struct{}
+
+func (*sumArray) Visit(node *Node) {
+	if sumBuiltin, ok := (*node).(*BuiltinNode); ok &&
+		sumBuiltin.Name == "sum" &&
+		len(sumBuiltin.Arguments) == 1 {
+		if array, ok := sumBuiltin.Arguments[0].(*ArrayNode); ok &&
+			len(array.Nodes) >= 2 {
+			Patch(node, sumArrayFold(array))
+		}
+	}
+}
+
+func sumArrayFold(array *ArrayNode) *BinaryNode {
+	if len(array.Nodes) > 2 {
+		return &BinaryNode{
+			Operator: "+",
+			Left:     array.Nodes[0],
+			Right:    sumArrayFold(&ArrayNode{Nodes: array.Nodes[1:]}),
+		}
+	} else if len(array.Nodes) == 2 {
+		return &BinaryNode{
+			Operator: "+",
+			Left:     array.Nodes[0],
+			Right:    array.Nodes[1],
+		}
+	}
+	panic(fmt.Errorf("sumArrayFold: invalid array length %d", len(array.Nodes)))
+}
diff --git a/optimizer/sum_array_test.go b/optimizer/sum_array_test.go
new file mode 100644
index 000000000..e3dc83414
--- /dev/null
+++ b/optimizer/sum_array_test.go
@@ -0,0 +1,73 @@
+package optimizer_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/vm"
+)
+
+func BenchmarkSumArray(b *testing.B) {
+	env := map[string]any{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+	}
+
+	program, err := expr.Compile(`sum([a, b, c, d])`, expr.Env(env))
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.Equal(b, 10, out)
+
+}
+
+func TestOptimize_sum_array(t *testing.T) {
+	tree, err := parser.Parse(`sum([a, b])`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BinaryNode{
+		Operator: "+",
+		Left:     &ast.IdentifierNode{Value: "a"},
+		Right:    &ast.IdentifierNode{Value: "b"},
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_sum_array_3(t *testing.T) {
+	tree, err := parser.Parse(`sum([a, b, c])`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BinaryNode{
+		Operator: "+",
+		Left:     &ast.IdentifierNode{Value: "a"},
+		Right: &ast.BinaryNode{
+			Operator: "+",
+			Left:     &ast.IdentifierNode{Value: "b"},
+			Right:    &ast.IdentifierNode{Value: "c"},
+		},
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}

From d236dcd5aebd19a53492aa8d4fbbca41aac171c8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 13 Apr 2024 23:18:59 +0200
Subject: [PATCH 313/506] Code style

---
 optimizer/sum_array_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/optimizer/sum_array_test.go b/optimizer/sum_array_test.go
index e3dc83414..09286c22b 100644
--- a/optimizer/sum_array_test.go
+++ b/optimizer/sum_array_test.go
@@ -33,7 +33,6 @@ func BenchmarkSumArray(b *testing.B) {
 
 	require.NoError(b, err)
 	require.Equal(b, 10, out)
-
 }
 
 func TestOptimize_sum_array(t *testing.T) {

From 725b7021c9f69b7aa6d37cd9502cab3d0ca2ab9d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 13 Apr 2024 23:38:35 +0200
Subject: [PATCH 314/506] Make count() predicate optional

---
 checker/checker.go          |  4 ++++
 compiler/compiler.go        |  6 +++++-
 docs/language-definition.md | 31 ++++++++++++++++++++++++++++---
 expr_test.go                |  4 ++++
 parser/parser.go            |  2 +-
 5 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index a6daa27b9..ecf7a04d6 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -653,6 +653,10 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
+		if len(node.Arguments) == 1 {
+			return integerType, info{}
+		}
+
 		v.begin(collection)
 		closure, _ := v.visit(node.Arguments[1])
 		v.end()
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 07bc58b87..05a92f2fd 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -800,7 +800,11 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.compile(node.Arguments[0])
 		c.emit(OpBegin)
 		c.emitLoop(func() {
-			c.compile(node.Arguments[1])
+			if len(node.Arguments) == 2 {
+				c.compile(node.Arguments[1])
+			} else {
+				c.emit(OpPointer)
+			}
 			c.emitCond(func() {
 				c.emit(OpIncrementCount)
 			})
diff --git a/docs/language-definition.md b/docs/language-definition.md
index a4e1a7cb0..0bc2bd0d2 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -628,14 +628,24 @@ Groups the elements of an array by the result of the [predicate](#predicate).
 groupBy(users, .Age)
 ```
 
-### count(array, predicate) {#count}
+### count(array[, predicate]) {#count}
 
 Returns the number of elements what satisfies the [predicate](#predicate).
 
+```expr
+count(users, .Age > 18)
+```
+
 Equivalent to:
 
 ```expr
-len(filter(array, predicate))
+len(filter(users, .Age > 18))
+```
+
+If the predicate is not given, returns the number of `true` elements in the array.
+
+```expr
+count([true, false, true]) == 2
 ```
 
 ### concat(array1, array2[, ...]) {#concat}
@@ -673,7 +683,7 @@ reduce(1..9, #acc + #)
 reduce(1..9, #acc + #, 0)
 ```
 
-### sum(array) {#sum}
+### sum(array[, predicate]) {#sum}
 
 Returns the sum of all numbers in the array.
 
@@ -681,6 +691,21 @@ Returns the sum of all numbers in the array.
 sum([1, 2, 3]) == 6
 ```
 
+If the optional `predicate` argument is given, it is a predicate that is applied on each element 
+of the array before summing.
+
+```expr
+sum(accounts, .Balance)
+```
+
+Equivalent to:
+
+```expr
+reduce(accounts, #acc + .Balance, 0)
+// or
+sum(map(accounts, .Balance))
+```
+
 ### mean(array) {#mean}
 
 Returns the average of all numbers in the array.
diff --git a/expr_test.go b/expr_test.go
index 38b97eaa0..23f4c496f 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -905,6 +905,10 @@ func TestExpr(t *testing.T) {
 			`count(1..30, {# % 3 == 0})`,
 			10,
 		},
+		{
+			`count([true, true, false])`,
+			2,
+		},
 		{
 			`"a" < "b"`,
 			true,
diff --git a/parser/parser.go b/parser/parser.go
index 641369b1a..6d96561ad 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -33,7 +33,7 @@ var predicates = map[string]struct {
 	"one":           {[]arg{expr, closure}},
 	"filter":        {[]arg{expr, closure}},
 	"map":           {[]arg{expr, closure}},
-	"count":         {[]arg{expr, closure}},
+	"count":         {[]arg{expr, closure | optional}},
 	"sum":           {[]arg{expr, closure | optional}},
 	"find":          {[]arg{expr, closure}},
 	"findIndex":     {[]arg{expr, closure}},

From b2a0c2aa070afd14706d9e200fb9c54e4e0578e5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 13 Apr 2024 23:50:53 +0200
Subject: [PATCH 315/506] Add more optimizer tests

---
 optimizer/optimizer_test.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index e59d2c65d..3c7947c09 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -34,6 +34,8 @@ func TestOptimize(t *testing.T) {
 		{`sum([a, b])`, 3},
 		{`sum([a, b, c])`, 6},
 		{`sum([a, b, c, 4])`, 10},
+		{`sum(1..10, # * 1000)`, 55000},
+		{`sum(map(1..10, # * 1000), # / 1000)`, float64(55)},
 		{`all(1..3, {# > 0}) && all(1..3, {# < 4})`, true},
 		{`all(1..3, {# > 2}) && all(1..3, {# < 4})`, false},
 		{`all(1..3, {# > 0}) && all(1..3, {# < 2})`, false},

From e6e376a17c1d38b24244697bdbfc9e8def035be3 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 14 Apr 2024 08:56:31 +0200
Subject: [PATCH 316/506] Update sortBy docs

---
 docs/language-definition.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/docs/language-definition.md b/docs/language-definition.md
index 0bc2bd0d2..8e22d3b65 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -305,6 +305,7 @@ filter(posts, {
     any(.Comments, .Author == post.Author)
 }) 
 ```
+
 :::
 
 ## String Functions
@@ -691,7 +692,7 @@ Returns the sum of all numbers in the array.
 sum([1, 2, 3]) == 6
 ```
 
-If the optional `predicate` argument is given, it is a predicate that is applied on each element 
+If the optional `predicate` argument is given, it is a predicate that is applied on each element
 of the array before summing.
 
 ```expr
@@ -765,14 +766,14 @@ sort([3, 1, 4]) == [1, 3, 4]
 sort([3, 1, 4], "desc") == [4, 3, 1]
 ```
 
-### sortBy(array, key[, order]) {#sortBy}
+### sortBy(array[, predicate, order]) {#sortBy}
 
-Sorts an array of maps by a specific key in ascending order. Optional `order` argument can be used to specify the order
+Sorts an array by the result of the [predicate](#predicate). Optional `order` argument can be used to specify the order
 of sorting: `asc` or `desc`.
 
 ```expr
-sortBy(users, "Age")
-sortBy(users, "Age", "desc")
+sortBy(users, .Age)
+sortBy(users, .Age, "desc")
 ```
 
 ## Map Functions

From 5804ccb7188e1082fad1815c19d0d01cb876ee15 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 16 Apr 2024 23:11:01 +0200
Subject: [PATCH 317/506] Return proper nil from optional chain

Fixes #570
---
 compiler/compiler.go      |  23 ++-
 compiler/compiler_test.go | 353 +++++++++++++++++++++-----------------
 expr_test.go              |  17 ++
 testdata/examples.txt     |  37 +---
 4 files changed, 235 insertions(+), 195 deletions(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 05a92f2fd..1aa5ce188 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -92,6 +92,13 @@ type scope struct {
 	index        int
 }
 
+func (c *compiler) nodeParent() ast.Node {
+	if len(c.nodes) > 1 {
+		return c.nodes[len(c.nodes)-2]
+	}
+	return nil
+}
+
 func (c *compiler) emitLocation(loc file.Location, op Opcode, arg int) int {
 	c.bytecode = append(c.bytecode, op)
 	current := len(c.bytecode)
@@ -594,9 +601,21 @@ func isSimpleType(node ast.Node) bool {
 func (c *compiler) ChainNode(node *ast.ChainNode) {
 	c.chains = append(c.chains, []int{})
 	c.compile(node.Node)
-	// Chain activate (got nit somewhere)
 	for _, ph := range c.chains[len(c.chains)-1] {
-		c.patchJump(ph)
+		c.patchJump(ph) // If chain activated jump here (got nit somewhere).
+	}
+	parent := c.nodeParent()
+	if binary, ok := parent.(*ast.BinaryNode); ok && binary.Operator == "??" {
+		// If chain is used in nil coalescing operator, we can omit
+		// nil push at the end of the chain. The ?? operator will
+		// handle it.
+	} else {
+		// We need to put the nil on the stack, otherwise "typed"
+		// nil will be used as a result of the chain.
+		j := c.emit(OpJumpIfNotNil, placeholder)
+		c.emit(OpPop)
+		c.emit(OpNil)
+		c.patchJump(j)
 	}
 	c.chains = c.chains[:len(c.chains)-1]
 }
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index fbd83ec86..6fe58e930 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -198,8 +198,11 @@ func TestCompile(t *testing.T) {
 					vm.OpLoadField,
 					vm.OpJumpIfNil,
 					vm.OpFetchField,
+					vm.OpJumpIfNotNil,
+					vm.OpPop,
+					vm.OpNil,
 				},
-				Arguments: []int{0, 1, 1},
+				Arguments: []int{0, 1, 1, 2, 0, 0},
 			},
 		},
 		{
@@ -219,8 +222,60 @@ func TestCompile(t *testing.T) {
 					vm.OpLoadField,
 					vm.OpJumpIfNil,
 					vm.OpFetchField,
+					vm.OpJumpIfNotNil,
+					vm.OpPop,
+					vm.OpNil,
+				},
+				Arguments: []int{0, 1, 1, 2, 0, 0},
+			},
+		},
+		{
+			`A?.B`,
+			vm.Program{
+				Constants: []any{
+					&runtime.Field{
+						Index: []int{0},
+						Path:  []string{"A"},
+					},
+					&runtime.Field{
+						Index: []int{1},
+						Path:  []string{"B"},
+					},
+				},
+				Bytecode: []vm.Opcode{
+					vm.OpLoadField,
+					vm.OpJumpIfNil,
+					vm.OpFetchField,
+					vm.OpJumpIfNotNil,
+					vm.OpPop,
+					vm.OpNil,
 				},
-				Arguments: []int{0, 1, 1},
+				Arguments: []int{0, 1, 1, 2, 0, 0},
+			},
+		},
+		{
+			`A?.B ?? 42`,
+			vm.Program{
+				Constants: []any{
+					&runtime.Field{
+						Index: []int{0},
+						Path:  []string{"A"},
+					},
+					&runtime.Field{
+						Index: []int{1},
+						Path:  []string{"B"},
+					},
+					42,
+				},
+				Bytecode: []vm.Opcode{
+					vm.OpLoadField,
+					vm.OpJumpIfNil,
+					vm.OpFetchField,
+					vm.OpJumpIfNotNil,
+					vm.OpPop,
+					vm.OpPush,
+				},
+				Arguments: []int{0, 1, 1, 2, 0, 2},
 			},
 		},
 		{
@@ -392,187 +447,176 @@ func TestCompile_optimizes_jumps(t *testing.T) {
 		"c": true,
 		"d": true,
 	}
-	type op struct {
-		Bytecode vm.Opcode
-		Arg      int
-	}
 	tests := []struct {
 		code string
-		want []op
+		want string
 	}{
 		{
 			`let foo = true; let bar = false; let baz = true; foo || bar || baz`,
-			[]op{
-				{vm.OpTrue, 0},
-				{vm.OpStore, 0},
-				{vm.OpFalse, 0},
-				{vm.OpStore, 1},
-				{vm.OpTrue, 0},
-				{vm.OpStore, 2},
-				{vm.OpLoadVar, 0},
-				{vm.OpJumpIfTrue, 5},
-				{vm.OpPop, 0},
-				{vm.OpLoadVar, 1},
-				{vm.OpJumpIfTrue, 2},
-				{vm.OpPop, 0},
-				{vm.OpLoadVar, 2},
-			},
+			`0   OpTrue
+1   OpStore  <0>  foo
+2   OpFalse
+3   OpStore  <1>  bar
+4   OpTrue
+5   OpStore       <2>  baz
+6   OpLoadVar     <0>  foo
+7   OpJumpIfTrue  <5>  (13)
+8   OpPop
+9   OpLoadVar     <1>  bar
+10  OpJumpIfTrue  <2>  (13)
+11  OpPop
+12  OpLoadVar  <2>  baz
+`,
 		},
 		{
 			`a && b && c`,
-			[]op{
-				{vm.OpLoadFast, 0},
-				{vm.OpJumpIfFalse, 5},
-				{vm.OpPop, 0},
-				{vm.OpLoadFast, 1},
-				{vm.OpJumpIfFalse, 2},
-				{vm.OpPop, 0},
-				{vm.OpLoadFast, 2},
-			},
+			`0  OpLoadFast     <0>  a
+1  OpJumpIfFalse  <5>  (7)
+2  OpPop
+3  OpLoadFast     <1>  b
+4  OpJumpIfFalse  <2>  (7)
+5  OpPop
+6  OpLoadFast  <2>  c
+`,
 		},
 		{
 			`a && b || c && d`,
-			[]op{
-				{vm.OpLoadFast, 0},
-				{vm.OpJumpIfFalse, 2},
-				{vm.OpPop, 0},
-				{vm.OpLoadFast, 1},
-				{vm.OpJumpIfTrue, 5},
-				{vm.OpPop, 0},
-				{vm.OpLoadFast, 2},
-				{vm.OpJumpIfFalse, 2},
-				{vm.OpPop, 0},
-				{vm.OpLoadFast, 3},
-			},
+			`0  OpLoadFast     <0>  a
+1  OpJumpIfFalse  <2>  (4)
+2  OpPop
+3  OpLoadFast    <1>  b
+4  OpJumpIfTrue  <5>  (10)
+5  OpPop
+6  OpLoadFast     <2>  c
+7  OpJumpIfFalse  <2>  (10)
+8  OpPop
+9  OpLoadFast  <3>  d
+`,
 		},
 		{
 			`filter([1, 2, 3, 4, 5], # > 3 && # != 4 && # != 5)`,
-			[]op{
-				{vm.OpPush, 0},
-				{vm.OpBegin, 0},
-				{vm.OpJumpIfEnd, 26},
-				{vm.OpPointer, 0},
-				{vm.OpDeref, 0},
-				{vm.OpPush, 1},
-				{vm.OpMore, 0},
-				{vm.OpJumpIfFalse, 18},
-				{vm.OpPop, 0},
-				{vm.OpPointer, 0},
-				{vm.OpDeref, 0},
-				{vm.OpPush, 2},
-				{vm.OpEqual, 0},
-				{vm.OpNot, 0},
-				{vm.OpJumpIfFalse, 11},
-				{vm.OpPop, 0},
-				{vm.OpPointer, 0},
-				{vm.OpDeref, 0},
-				{vm.OpPush, 3},
-				{vm.OpEqual, 0},
-				{vm.OpNot, 0},
-				{vm.OpJumpIfFalse, 4},
-				{vm.OpPop, 0},
-				{vm.OpIncrementCount, 0},
-				{vm.OpPointer, 0},
-				{vm.OpJump, 1},
-				{vm.OpPop, 0},
-				{vm.OpIncrementIndex, 0},
-				{vm.OpJumpBackward, 27},
-				{vm.OpGetCount, 0},
-				{vm.OpEnd, 0},
-				{vm.OpArray, 0},
-			},
+			`0   OpPush  <0>  [1 2 3 4 5]
+1   OpBegin
+2   OpJumpIfEnd  <26>  (29)
+3   OpPointer
+4   OpDeref
+5   OpPush  <1>  3
+6   OpMore
+7   OpJumpIfFalse  <18>  (26)
+8   OpPop
+9   OpPointer
+10  OpDeref
+11  OpPush  <2>  4
+12  OpEqual
+13  OpNot
+14  OpJumpIfFalse  <11>  (26)
+15  OpPop
+16  OpPointer
+17  OpDeref
+18  OpPush  <3>  5
+19  OpEqual
+20  OpNot
+21  OpJumpIfFalse  <4>  (26)
+22  OpPop
+23  OpIncrementCount
+24  OpPointer
+25  OpJump  <1>  (27)
+26  OpPop
+27  OpIncrementIndex
+28  OpJumpBackward  <27>  (2)
+29  OpGetCount
+30  OpEnd
+31  OpArray
+`,
 		},
 		{
 			`let foo = true; let bar = false; let baz = true; foo && bar || baz`,
-			[]op{
-				{vm.OpTrue, 0},
-				{vm.OpStore, 0},
-				{vm.OpFalse, 0},
-				{vm.OpStore, 1},
-				{vm.OpTrue, 0},
-				{vm.OpStore, 2},
-				{vm.OpLoadVar, 0},
-				{vm.OpJumpIfFalse, 2},
-				{vm.OpPop, 0},
-				{vm.OpLoadVar, 1},
-				{vm.OpJumpIfTrue, 2},
-				{vm.OpPop, 0},
-				{vm.OpLoadVar, 2},
-			},
+			`0   OpTrue
+1   OpStore  <0>  foo
+2   OpFalse
+3   OpStore  <1>  bar
+4   OpTrue
+5   OpStore        <2>  baz
+6   OpLoadVar      <0>  foo
+7   OpJumpIfFalse  <2>  (10)
+8   OpPop
+9   OpLoadVar     <1>  bar
+10  OpJumpIfTrue  <2>  (13)
+11  OpPop
+12  OpLoadVar  <2>  baz
+`,
 		},
 		{
 			`true ?? nil ?? nil ?? nil`,
-			[]op{
-				{vm.OpTrue, 0},
-				{vm.OpJumpIfNotNil, 8},
-				{vm.OpPop, 0},
-				{vm.OpNil, 0},
-				{vm.OpJumpIfNotNil, 5},
-				{vm.OpPop, 0},
-				{vm.OpNil, 0},
-				{vm.OpJumpIfNotNil, 2},
-				{vm.OpPop, 0},
-				{vm.OpNil, 0},
-			},
+			`0  OpTrue
+1  OpJumpIfNotNil  <8>  (10)
+2  OpPop
+3  OpNil
+4  OpJumpIfNotNil  <5>  (10)
+5  OpPop
+6  OpNil
+7  OpJumpIfNotNil  <2>  (10)
+8  OpPop
+9  OpNil
+`,
 		},
 		{
 			`let m = {"a": {"b": {"c": 1}}}; m?.a?.b?.c`,
-			[]op{
-				{vm.OpPush, 0},
-				{vm.OpPush, 1},
-				{vm.OpPush, 2},
-				{vm.OpPush, 3},
-				{vm.OpPush, 3},
-				{vm.OpMap, 0},
-				{vm.OpPush, 3},
-				{vm.OpMap, 0},
-				{vm.OpPush, 3},
-				{vm.OpMap, 0},
-				{vm.OpStore, 0},
-				{vm.OpLoadVar, 0},
-				{vm.OpJumpIfNil, 8},
-				{vm.OpPush, 0},
-				{vm.OpFetch, 0},
-				{vm.OpJumpIfNil, 5},
-				{vm.OpPush, 1},
-				{vm.OpFetch, 0},
-				{vm.OpJumpIfNil, 2},
-				{vm.OpPush, 2},
-				{vm.OpFetch, 0},
-			},
+			`0   OpPush  <0>  a
+1   OpPush  <1>  b
+2   OpPush  <2>  c
+3   OpPush  <3>  1
+4   OpPush  <3>  1
+5   OpMap
+6   OpPush  <3>  1
+7   OpMap
+8   OpPush  <3>  1
+9   OpMap
+10  OpStore      <0>  m
+11  OpLoadVar    <0>  m
+12  OpJumpIfNil  <8>  (21)
+13  OpPush       <0>  a
+14  OpFetch
+15  OpJumpIfNil  <5>  (21)
+16  OpPush       <1>  b
+17  OpFetch
+18  OpJumpIfNil  <2>  (21)
+19  OpPush       <2>  c
+20  OpFetch
+21  OpJumpIfNotNil  <2>  (24)
+22  OpPop
+23  OpNil
+`,
 		},
 		{
 			`-1 not in [1, 2, 5]`,
-			[]op{
-				{vm.OpPush, 0},
-				{vm.OpPush, 1},
-				{vm.OpIn, 0},
-				{vm.OpNot, 0},
-			},
+			`0  OpPush  <0>  -1
+1  OpPush  <1>  map[1:{} 2:{} 5:{}]
+2  OpIn
+3  OpNot
+`,
 		},
 		{
 			`1 + 8 not in [1, 2, 5]`,
-			[]op{
-				{vm.OpPush, 0},
-				{vm.OpPush, 1},
-				{vm.OpIn, 0},
-				{vm.OpNot, 0},
-			},
+			`0  OpPush  <0>  9
+1  OpPush  <1>  map[1:{} 2:{} 5:{}]
+2  OpIn
+3  OpNot
+`,
 		},
 		{
 			`true ? false : 8 not in [1, 2, 5]`,
-			[]op{
-				{vm.OpTrue, 0},
-				{vm.OpJumpIfFalse, 3},
-				{vm.OpPop, 0},
-				{vm.OpFalse, 0},
-				{vm.OpJump, 5},
-				{vm.OpPop, 0},
-				{vm.OpPush, 0},
-				{vm.OpPush, 1},
-				{vm.OpIn, 0},
-				{vm.OpNot, 0},
-			},
+			`0  OpTrue
+1  OpJumpIfFalse  <3>  (5)
+2  OpPop
+3  OpFalse
+4  OpJump  <5>  (10)
+5  OpPop
+6  OpPush  <0>  8
+7  OpPush  <1>  map[1:{} 2:{} 5:{}]
+8  OpIn
+9  OpNot
+`,
 		},
 	}
 
@@ -580,12 +624,7 @@ func TestCompile_optimizes_jumps(t *testing.T) {
 		t.Run(test.code, func(t *testing.T) {
 			program, err := expr.Compile(test.code, expr.Env(env))
 			require.NoError(t, err)
-
-			require.Equal(t, len(test.want), len(program.Bytecode))
-			for i, op := range test.want {
-				require.Equal(t, op.Bytecode, program.Bytecode[i])
-				require.Equalf(t, op.Arg, program.Arguments[i], "at %d", i)
-			}
+			require.Equal(t, test.want, program.Disassemble())
 		})
 	}
 }
diff --git a/expr_test.go b/expr_test.go
index 23f4c496f..df4eba505 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2602,3 +2602,20 @@ func TestArrayComparison(t *testing.T) {
 		})
 	}
 }
+
+func TestIssue_570(t *testing.T) {
+	type Student struct {
+		Name string
+	}
+
+	env := map[string]any{
+		"student": (*Student)(nil),
+	}
+
+	program, err := expr.Compile("student?.Name", expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.IsType(t, nil, out)
+}
diff --git a/testdata/examples.txt b/testdata/examples.txt
index 5b9d2cdde..b02094a7c 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -3070,11 +3070,8 @@ all(array, not true)
 all(array, ok)
 all(false ? add : "bar", ok)
 all(filter(array, true), ok)
-all(groupBy(array, #)?.f32, #)
 all(groupBy(array, f32).score, 0.5 in #?.f64)
-all(groupBy(array, foo)?.i64, none(.div, true == #))
 all(groupBy(list, #).i, #?.half() not in # + #)
-all(groupBy(list, #)?.add, #?.f64.i64(f32 startsWith #, div))
 all(i32 .. 1, ok)
 all(list, !false)
 all(list, "bar" in #)
@@ -3242,7 +3239,6 @@ any(array, one(array, ok))
 any(array, score != add)
 any(array, score == half)
 any(array, score == nil)
-any(groupBy(list, #)?.Bar, #)
 any(i32 .. i, half == half)
 any(list, !ok)
 any(list, !true)
@@ -3992,9 +3988,7 @@ count(array, reduce(list, false))
 count(array, true == ok)
 count(array, true) / f64
 count(filter(list, true), ok)
-count(groupBy(array, #)?.String, #)
 count(groupBy(list, #).String, .div?.array)
-count(groupBy(list, #)?.list, #?.Qux)
 count(i .. 1, # == i)
 count(i .. i, ok)
 count(i32 .. i, # >= #)
@@ -5652,12 +5646,7 @@ filter(array, true == true)
 filter(array, true and true)
 filter(false ? ok : array, # == nil)
 filter(filter(list, true), ok)
-filter(groupBy(array, #).greet, # matches #?.score)
-filter(groupBy(array, #)?.div, .Qux(#).array)
-filter(groupBy(array, f64)?.f32, #)
 filter(groupBy(list, #).f64, # not matches #?.foo)
-filter(groupBy(list, #)?.f64, .foo)
-filter(groupBy(list, 0.5)?.i, #)
 filter(i .. i64, ok)
 filter(list, !ok)
 filter(list, !true)
@@ -6033,13 +6022,9 @@ findIndex(filter(array, false), # > 1)
 findIndex(filter(array, true), # not in array)
 findIndex(filter(list, false), 1 <= i64)
 findIndex(groupBy(array, #).f64, .Bar(half(add, half, div, greet, f64)))
-findIndex(groupBy(array, #)?.greet, .f64(foo(array, #), # != "bar"))
 findIndex(groupBy(array, false).String, #?.i64())
 findIndex(groupBy(array, foo).String, #)
 findIndex(groupBy(list, #).Qux, #)
-findIndex(groupBy(list, #)?.Qux, #)
-findIndex(groupBy(list, #)?.i64, #)
-findIndex(groupBy(list, true)?.list, get(false ? # : #, score(#, Bar, half, #)))
 findIndex(i32 .. 1, # >= #)
 findIndex(list, !false)
 findIndex(list, !ok)
@@ -6198,13 +6183,9 @@ findLast(array, score != div)
 findLast(array, score != nil)
 findLast(array, true) % i64
 findLast(groupBy(array, #).i32, #)
-findLast(groupBy(array, f64)?.score, #)
 findLast(groupBy(list, "bar").div, #?.f32?.half())
 findLast(groupBy(list, #)[ok], .ok)
-findLast(groupBy(list, 0.5)?.String, #?.half(Bar))
-findLast(groupBy(list, 0.5)?.f32, ok)
 findLast(groupBy(list, f64).foo, .f32(#, #)?.Qux(#?.i64(add, nil)))
-findLast(groupBy(list, f64)?.Bar, #)
 findLast(i .. 1, # < #)
 findLast(i .. i32, # != i64)
 findLast(i .. i32, ok)
@@ -6379,12 +6360,7 @@ findLastIndex(array, true == false)
 findLastIndex(array, true) / f32
 findLastIndex(array, true) not in array
 findLastIndex(filter(array, false), ok)
-findLastIndex(groupBy(array, "foo")?.add, #[list])
-findLastIndex(groupBy(array, #)?.foo, #)
-findLastIndex(groupBy(array, #)?.i32, not #)
-findLastIndex(groupBy(array, #)?.score, #)
 findLastIndex(groupBy(list, #).ok, #)
-findLastIndex(groupBy(list, #)?.String, # + #.add)
 findLastIndex(groupBy(list, 0.5).Bar, #?.String endsWith .f32(list))
 findLastIndex(i32 .. i32, ok)
 findLastIndex(i64 .. 1, ok)
@@ -7208,7 +7184,7 @@ fromJSON(toJSON(nil))
 fromJSON(toJSON(true))
 fromPairs(filter(array, false))
 fromPairs(filter(list, false))
-fromPairs(groupBy(array, #)?.String)
+fromPairs(groupBy(array, #).String)
 get(["foo"], i32)
 get(array, -1)
 get(array, -i32)
@@ -8388,8 +8364,6 @@ groupBy(filter(array, true), f64)
 groupBy(filter(list, ok), #)
 groupBy(groupBy(array, "foo").list, #)
 groupBy(groupBy(array, #).i32, add)
-groupBy(groupBy(array, 0.5)?.div, get(.foo(add, false), none(#, foo)))
-groupBy(groupBy(array, f64)?.ok, .Bar()?.Bar)
 groupBy(groupBy(array, ok).Bar, #?.array not matches #)
 groupBy(groupBy(array, true).f64, #[#])
 groupBy(i .. 1, !ok)?.f64
@@ -12816,8 +12790,6 @@ map(groupBy(array, #).String, i32)
 map(groupBy(array, #).greet, foo.Qux(.f32))
 map(groupBy(array, #).greet, score)
 map(groupBy(array, #).score, #?.list())
-map(groupBy(array, 0.5)?.i64, .Qux())
-map(groupBy(array, f64)?.array, first(.div()))
 map(groupBy(list, i32).i, #)
 map(i .. 1, -#)
 map(i .. 1, 0.5 ^ #)
@@ -13465,7 +13437,6 @@ mean(array) >= i64
 mean(array) ^ i
 mean(array) ^ i32
 mean(filter(array, true))
-mean(groupBy(array, #)?.half)
 mean(groupBy(array, i64).score)
 mean(i .. 1)
 mean(i .. i)
@@ -13981,9 +13952,6 @@ none(array, ok)
 none(array, reduce(array, true))
 none(filter(array, # >= f64), ok)
 none(groupBy(array, #).f64, # or #.Bar)
-none(groupBy(array, #)?.array, fromJSON(#))
-none(groupBy(array, #)?.f32, #)
-none(groupBy(array, #)?.greet, #)
 none(groupBy(list, #).div, ok)
 none(groupBy(list, #).greet, #)
 none(groupBy(list, 0.5).i, ok)
@@ -15298,10 +15266,8 @@ one(array, true == nil)
 one(array, true) ? greet : add
 one(array, true) or 1 != nil
 one(false ? greet : "bar", f64 != #)
-one(groupBy(array, 0.5)?.String, #)
 one(groupBy(array, f64).array, .i(nil).ok)
 one(groupBy(list, ok).foo, .add?.array)
-one(groupBy(list, ok)?.score, .i64())
 one(i32 .. 1, # == #)
 one(i32 .. i32, not ok)
 one(i64 .. 1, # >= 1)
@@ -17297,7 +17263,6 @@ sum(array) ^ f64
 sum(array) not in array
 sum(filter(array, ok))
 sum(groupBy(array, i32).String)
-sum(groupBy(list, #)?.greet)
 sum(i32 .. 1)
 sum(i64 .. i32)
 sum(i64 .. i64)

From 61573950f69c945c0607828ea8fd01fff95dc54b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 16 Apr 2024 23:23:12 +0200
Subject: [PATCH 318/506] Fix printing on conditional/binary nodes

Fixes #613
---
 ast/print.go      | 27 ++++++++++++++++++---------
 ast/print_test.go |  1 +
 expr_test.go      |  9 +++++++++
 3 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/ast/print.go b/ast/print.go
index 063e9eb27..394e0c1ad 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -65,8 +65,7 @@ func (n *BinaryNode) String() string {
 	var lhs, rhs string
 	var lwrap, rwrap bool
 
-	lb, ok := n.Left.(*BinaryNode)
-	if ok {
+	if lb, ok := n.Left.(*BinaryNode); ok {
 		if operator.Less(lb.Operator, n.Operator) {
 			lwrap = true
 		}
@@ -77,9 +76,7 @@ func (n *BinaryNode) String() string {
 			lwrap = true
 		}
 	}
-
-	rb, ok := n.Right.(*BinaryNode)
-	if ok {
+	if rb, ok := n.Right.(*BinaryNode); ok {
 		if operator.Less(rb.Operator, n.Operator) {
 			rwrap = true
 		}
@@ -88,6 +85,13 @@ func (n *BinaryNode) String() string {
 		}
 	}
 
+	if _, ok := n.Left.(*ConditionalNode); ok {
+		lwrap = true
+	}
+	if _, ok := n.Right.(*ConditionalNode); ok {
+		rwrap = true
+	}
+
 	if lwrap {
 		lhs = fmt.Sprintf("(%s)", n.Left.String())
 	} else {
@@ -108,20 +112,25 @@ func (n *ChainNode) String() string {
 }
 
 func (n *MemberNode) String() string {
+	node := n.Node.String()
+	if _, ok := n.Node.(*BinaryNode); ok {
+		node = fmt.Sprintf("(%s)", node)
+	}
+
 	if n.Optional {
 		if str, ok := n.Property.(*StringNode); ok && utils.IsValidIdentifier(str.Value) {
-			return fmt.Sprintf("%s?.%s", n.Node.String(), str.Value)
+			return fmt.Sprintf("%s?.%s", node, str.Value)
 		} else {
-			return fmt.Sprintf("%s?.[%s]", n.Node.String(), n.Property.String())
+			return fmt.Sprintf("%s?.[%s]", node, n.Property.String())
 		}
 	}
 	if str, ok := n.Property.(*StringNode); ok && utils.IsValidIdentifier(str.Value) {
 		if _, ok := n.Node.(*PointerNode); ok {
 			return fmt.Sprintf(".%s", str.Value)
 		}
-		return fmt.Sprintf("%s.%s", n.Node.String(), str.Value)
+		return fmt.Sprintf("%s.%s", node, str.Value)
 	}
-	return fmt.Sprintf("%s[%s]", n.Node.String(), n.Property.String())
+	return fmt.Sprintf("%s[%s]", node, n.Property.String())
 }
 
 func (n *SliceNode) String() string {
diff --git a/ast/print_test.go b/ast/print_test.go
index d9e55c2ea..373030a4f 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -72,6 +72,7 @@ func TestPrint(t *testing.T) {
 		{`a[:]`, `a[:]`},
 		{`(nil ?? 1) > 0`, `(nil ?? 1) > 0`},
 		{`{("a" + "b"): 42}`, `{("a" + "b"): 42}`},
+		{`(One == 1 ? true : false) && Two == 2`, `(One == 1 ? true : false) && Two == 2`},
 	}
 
 	for _, tt := range tests {
diff --git a/expr_test.go b/expr_test.go
index df4eba505..4b4e2edf1 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1298,6 +1298,15 @@ func TestExpr(t *testing.T) {
 				require.NoError(t, err, "eval")
 				assert.Equal(t, tt.want, got, "eval")
 			}
+			{
+				program, err := expr.Compile(tt.code, expr.Env(mock.Env{}), expr.Optimize(false))
+				require.NoError(t, err)
+
+				code := program.Node().String()
+				got, err := expr.Eval(code, env)
+				require.NoError(t, err, code)
+				assert.Equal(t, tt.want, got, code)
+			}
 		})
 	}
 }

From ae2a9dfc6feec03664657729ffd7a79b91528fbf Mon Sep 17 00:00:00 2001
From: gnolizuh <huzilong_007@163.com>
Date: Mon, 22 Apr 2024 18:05:36 +0800
Subject: [PATCH 319/506] New usage case: xiaohongshu.com (#631)

add company usecase of xiaohongshu.com

Signed-off-by: gnolizuh <huzilong@xiaohongshu.com>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 1a2d7dc83..5a587162c 100644
--- a/README.md
+++ b/README.md
@@ -163,6 +163,7 @@ func main() {
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
 * [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products.
+* [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From e6dfb719a733a1751b0d4dc3ec21d93bacdff3e0 Mon Sep 17 00:00:00 2001
From: "Christian G. Warden" <cwarden@xerus.org>
Date: Wed, 24 Apr 2024 07:08:49 -0500
Subject: [PATCH 320/506] Preserve The Specified Timezone In Parse (#633)

* Preserve The Specified Timezone In Parse

When parsing a string into a Time using the optional timezone
parameter, set the location of the Time to the timezone's location so
that Format uses that timezone.

* Add More Tests for Preserving Timezone

Add test when timezone is used to parse a date-time.

Add test when timezone is irrelevant because it's a date.
---
 builtin/builtin.go      | 1 +
 builtin/builtin_test.go | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index efc01fc2f..1199f59c5 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -502,6 +502,7 @@ var Builtins = []*Function{
 				if err != nil {
 					return nil, err
 				}
+				t = t.In(tz)
 				return t, nil
 			}
 
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 307d4a86a..dca4bccfb 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -113,6 +113,9 @@ func TestBuiltin(t *testing.T) {
 		{`duration("1h")`, time.Hour},
 		{`date("2006-01-02T15:04:05Z")`, time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
 		{`date("2006.01.02", "2006.01.02")`, time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC)},
+		{`date("2023-04-23T00:30:00.000+0100", "2006-01-02T15:04:05-0700", "America/Chicago").Format("2006-01-02")`, "2023-04-22"},
+		{`date("2023-04-23T00:30:00", "2006-01-02T15:04:05", "America/Chicago").Format("2006-01-02")`, "2023-04-23"},
+		{`date("2023-04-23", "2006-01-02", "America/Chicago").Format("2006-01-02")`, "2023-04-23"},
 		{`first(ArrayOfString)`, "foo"},
 		{`first(ArrayOfInt)`, 1},
 		{`first(ArrayOfAny)`, 1},

From 9207e712c128c85065a419dd6c7b01656ef63758 Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Wed, 8 May 2024 00:37:12 +0530
Subject: [PATCH 321/506] Resolve double-escaping issue with pair node key
 (#640)

* Resolve double-escaping issue with pair node key

* Resolve double-escaping issue with pair node key

* Added test cases for pair node key
---
 ast/print.go      | 2 +-
 ast/print_test.go | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/ast/print.go b/ast/print.go
index 394e0c1ad..6a7d698a9 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -215,7 +215,7 @@ func (n *PairNode) String() string {
 		if utils.IsValidIdentifier(str.Value) {
 			return fmt.Sprintf("%s: %s", str.Value, n.Value.String())
 		}
-		return fmt.Sprintf("%q: %s", str.String(), n.Value.String())
+		return fmt.Sprintf("%s: %s", str.String(), n.Value.String())
 	}
 	return fmt.Sprintf("(%s): %s", n.Key.String(), n.Value.String())
 }
diff --git a/ast/print_test.go b/ast/print_test.go
index 373030a4f..4ad49714c 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -57,6 +57,10 @@ func TestPrint(t *testing.T) {
 		{`{}`, `{}`},
 		{`{a: b}`, `{a: b}`},
 		{`{a: b, c: d}`, `{a: b, c: d}`},
+		{`{"a": b, 'c': d}`, `{a: b, c: d}`},
+		{`{"a": b, c: d}`, `{a: b, c: d}`},
+		{`{"a": b, 8: 8}`, `{a: b, "8": 8}`},
+		{`{"9": 9, '8': 8, "foo": d}`, `{"9": 9, "8": 8, foo: d}`},
 		{`[]`, `[]`},
 		{`[a]`, `[a]`},
 		{`[a, b]`, `[a, b]`},

From 1f31cc5a5e412d6444fc95a2aa414a8e2d2f3f8d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 7 May 2024 21:36:22 +0200
Subject: [PATCH 322/506] Add timezone() builtin

---
 builtin/builtin.go          | 11 +++++++++++
 builtin/builtin_test.go     |  2 ++
 docs/language-definition.md | 32 ++++++++++++++++++++++++++++++++
 3 files changed, 45 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 1199f59c5..4995e75c7 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -529,6 +529,17 @@ var Builtins = []*Function{
 			new(func(string, string, string) time.Time),
 		),
 	},
+	{
+		Name: "timezone",
+		Func: func(args ...any) (any, error) {
+			tz, err := time.LoadLocation(args[0].(string))
+			if err != nil {
+				return nil, err
+			}
+			return tz, nil
+		},
+		Types: types(time.LoadLocation),
+	},
 	{
 		Name: "first",
 		Func: func(args ...any) (any, error) {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index dca4bccfb..fc2395f7c 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -116,6 +116,8 @@ func TestBuiltin(t *testing.T) {
 		{`date("2023-04-23T00:30:00.000+0100", "2006-01-02T15:04:05-0700", "America/Chicago").Format("2006-01-02")`, "2023-04-22"},
 		{`date("2023-04-23T00:30:00", "2006-01-02T15:04:05", "America/Chicago").Format("2006-01-02")`, "2023-04-23"},
 		{`date("2023-04-23", "2006-01-02", "America/Chicago").Format("2006-01-02")`, "2023-04-23"},
+		{`timezone("UTC").String()`, "UTC"},
+		{`timezone("Europe/Moscow").String()`, "Europe/Moscow"},
 		{`first(ArrayOfString)`, "foo"},
 		{`first(ArrayOfInt)`, 1},
 		{`first(ArrayOfAny)`, 1},
diff --git a/docs/language-definition.md b/docs/language-definition.md
index 8e22d3b65..251f84552 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -484,6 +484,38 @@ date("2023-08-14T00:00:00Z")
 date("2023-08-14 00:00:00", "2006-01-02 15:04:05", "Europe/Zurich")
 ```
 
+Available methods on the date:
+
+- `Year()` - returns the year
+- `Month()` - returns the month (starting from 1)
+- `Day()` - returns the day of the month
+- `Hour()` - returns the hour
+- `Minute()` - returns the minute
+- `Second()` - returns the second
+- `Weekday()` - returns the day of the week
+- `YearDay()` - returns the day of the year
+- and [more](https://pkg.go.dev/time#Time).
+
+```expr
+date("2023-08-14").Year() == 2023
+```
+
+### timezone(str) {#timezone}
+
+Returns the timezone of the given string `str`. List of available timezones can be
+found [here](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).
+
+```expr
+timezone("Europe/Zurich")
+timezone("UTC")
+```
+
+To convert a date to a different timezone, use the [`In()`](https://pkg.go.dev/time#Time.In) method:
+
+```expr
+date("2023-08-14 00:00:00").In(timezone("Europe/Zurich"))
+```
+
 ## Number Functions
 
 ### max(n1, n2) {#max}

From 5b538a702257cf354bf175eb9f2f3905bb8bf118 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 7 May 2024 23:19:39 +0200
Subject: [PATCH 323/506] Add default timezone option expr.Timezone()

---
 builtin/builtin.go            | 60 +++++++++++++++++++++++++++++------
 builtin/builtin_test.go       |  1 +
 builtin/utils.go              | 13 +++++---
 expr.go                       | 12 +++++++
 expr_test.go                  | 17 ++++++++++
 patcher/with_timezone.go      | 25 +++++++++++++++
 patcher/with_timezone_test.go | 28 ++++++++++++++++
 testdata/examples.txt         |  1 -
 8 files changed, 141 insertions(+), 16 deletions(-)
 create mode 100644 patcher/with_timezone.go
 create mode 100644 patcher/with_timezone_test.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 4995e75c7..38a6f2f3f 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -472,9 +472,27 @@ var Builtins = []*Function{
 	{
 		Name: "now",
 		Func: func(args ...any) (any, error) {
-			return time.Now(), nil
+			if len(args) == 0 {
+				return time.Now(), nil
+			}
+			if len(args) == 1 {
+				if tz, ok := args[0].(*time.Location); ok {
+					return time.Now().In(tz), nil
+				}
+			}
+			return nil, fmt.Errorf("invalid number of arguments (expected 0, got %d)", len(args))
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) == 0 {
+				return timeType, nil
+			}
+			if len(args) == 1 {
+				if args[0].AssignableTo(locationType) {
+					return timeType, nil
+				}
+			}
+			return anyType, fmt.Errorf("invalid number of arguments (expected 0, got %d)", len(args))
 		},
-		Types: types(new(func() time.Time)),
 	},
 	{
 		Name: "duration",
@@ -486,9 +504,17 @@ var Builtins = []*Function{
 	{
 		Name: "date",
 		Func: func(args ...any) (any, error) {
+			tz, ok := args[0].(*time.Location)
+			if ok {
+				args = args[1:]
+			}
+
 			date := args[0].(string)
 			if len(args) == 2 {
 				layout := args[1].(string)
+				if tz != nil {
+					return time.ParseInLocation(layout, date, tz)
+				}
 				return time.Parse(layout, date)
 			}
 			if len(args) == 3 {
@@ -516,18 +542,32 @@ var Builtins = []*Function{
 				time.RFC1123,
 			}
 			for _, layout := range layouts {
-				t, err := time.Parse(layout, date)
-				if err == nil {
-					return t, nil
+				if tz == nil {
+					t, err := time.Parse(layout, date)
+					if err == nil {
+						return t, nil
+					}
+				} else {
+					t, err := time.ParseInLocation(layout, date, tz)
+					if err == nil {
+						return t, nil
+					}
 				}
 			}
 			return nil, fmt.Errorf("invalid date %s", date)
 		},
-		Types: types(
-			new(func(string) time.Time),
-			new(func(string, string) time.Time),
-			new(func(string, string, string) time.Time),
-		),
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) < 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected at least 1, got %d)", len(args))
+			}
+			if args[0].AssignableTo(locationType) {
+				args = args[1:]
+			}
+			if len(args) > 3 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected at most 3, got %d)", len(args))
+			}
+			return timeType, nil
+		},
 	},
 	{
 		Name: "timezone",
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index fc2395f7c..09a13b9f8 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -170,6 +170,7 @@ func TestBuiltin_works_with_any(t *testing.T) {
 	config := map[string]struct {
 		arity int
 	}{
+		"now":    {0},
 		"get":    {2},
 		"take":   {2},
 		"sortBy": {2},
diff --git a/builtin/utils.go b/builtin/utils.go
index 7d3b6ee8e..29a95731a 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -3,14 +3,17 @@ package builtin
 import (
 	"fmt"
 	"reflect"
+	"time"
 )
 
 var (
-	anyType     = reflect.TypeOf(new(any)).Elem()
-	integerType = reflect.TypeOf(0)
-	floatType   = reflect.TypeOf(float64(0))
-	arrayType   = reflect.TypeOf([]any{})
-	mapType     = reflect.TypeOf(map[any]any{})
+	anyType      = reflect.TypeOf(new(any)).Elem()
+	integerType  = reflect.TypeOf(0)
+	floatType    = reflect.TypeOf(float64(0))
+	arrayType    = reflect.TypeOf([]any{})
+	mapType      = reflect.TypeOf(map[any]any{})
+	timeType     = reflect.TypeOf(new(time.Time)).Elem()
+	locationType = reflect.TypeOf(new(time.Location))
 )
 
 func kind(t reflect.Type) reflect.Kind {
diff --git a/expr.go b/expr.go
index ba786c017..83e0a167e 100644
--- a/expr.go
+++ b/expr.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"time"
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
@@ -183,6 +184,17 @@ func WithContext(name string) Option {
 	})
 }
 
+// Timezone sets default timezone for date() and now() builtin functions.
+func Timezone(name string) Option {
+	tz, err := time.LoadLocation(name)
+	if err != nil {
+		panic(err)
+	}
+	return Patch(patcher.WithTimezone{
+		Location: tz,
+	})
+}
+
 // Compile parses and compiles given input expression to bytecode program.
 func Compile(input string, ops ...Option) (*vm.Program, error) {
 	config := conf.CreateNew()
diff --git a/expr_test.go b/expr_test.go
index 4b4e2edf1..889d82b32 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -584,6 +584,23 @@ func ExampleWithContext() {
 	// Output: 42
 }
 
+func ExampleWithTimezone() {
+	program, err := expr.Compile(`now().Location().String()`, expr.Timezone("Asia/Kamchatka"))
+	if err != nil {
+		fmt.Printf("%v", err)
+		return
+	}
+
+	output, err := expr.Run(program, nil)
+	if err != nil {
+		fmt.Printf("%v", err)
+		return
+	}
+
+	fmt.Printf("%v", output)
+	// Output: Asia/Kamchatka
+}
+
 func TestExpr_readme_example(t *testing.T) {
 	env := map[string]any{
 		"greet":   "Hello, %v!",
diff --git a/patcher/with_timezone.go b/patcher/with_timezone.go
new file mode 100644
index 000000000..83eb28e95
--- /dev/null
+++ b/patcher/with_timezone.go
@@ -0,0 +1,25 @@
+package patcher
+
+import (
+	"time"
+
+	"github.com/expr-lang/expr/ast"
+)
+
+// WithTimezone passes Location to date() and now() functions.
+type WithTimezone struct {
+	Location *time.Location
+}
+
+func (t WithTimezone) Visit(node *ast.Node) {
+	if btin, ok := (*node).(*ast.BuiltinNode); ok {
+		switch btin.Name {
+		case "date", "now":
+			loc := &ast.ConstantNode{Value: t.Location}
+			ast.Patch(node, &ast.BuiltinNode{
+				Name:      btin.Name,
+				Arguments: append([]ast.Node{loc}, btin.Arguments...),
+			})
+		}
+	}
+}
diff --git a/patcher/with_timezone_test.go b/patcher/with_timezone_test.go
new file mode 100644
index 000000000..2cd099f20
--- /dev/null
+++ b/patcher/with_timezone_test.go
@@ -0,0 +1,28 @@
+package patcher_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/expr-lang/expr"
+)
+
+func TestWithTimezone_date(t *testing.T) {
+	program, err := expr.Compile(`date("2024-05-07 23:00:00")`, expr.Timezone("Europe/Zurich"))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, nil)
+	require.NoError(t, err)
+	require.Equal(t, "2024-05-07T23:00:00+02:00", out.(time.Time).Format(time.RFC3339))
+}
+
+func TestWithTimezone_now(t *testing.T) {
+	program, err := expr.Compile(`now()`, expr.Timezone("Asia/Kamchatka"))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, nil)
+	require.NoError(t, err)
+	require.Equal(t, "Asia/Kamchatka", out.(time.Time).Location().String())
+}
diff --git a/testdata/examples.txt b/testdata/examples.txt
index b02094a7c..9c18442e4 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -7231,7 +7231,6 @@ get(false ? f64 : 1, ok)
 get(false ? f64 : score, add)
 get(false ? false : f32, i)
 get(false ? i32 : list, i64)
-get(false ? i32 : ok, now(div, array))
 get(false ? i64 : foo, Bar)
 get(false ? i64 : true, f64)
 get(false ? score : ok, trimSuffix("bar", "bar"))

From 9a4b529a9d84664b70e6c28ec882acfe90b8fa21 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 8 May 2024 00:24:35 +0200
Subject: [PATCH 324/506] Vendor testify (#642)

---
 ast/print_test.go                             |    4 +-
 ast/visitor_test.go                           |    3 +-
 bench_test.go                                 |    2 +-
 builtin/builtin_test.go                       |    4 +-
 checker/checker_test.go                       |    4 +-
 checker/info_test.go                          |    2 +-
 compiler/compiler_test.go                     |    4 +-
 debug/go.sum                                  |    4 -
 docgen/docgen_test.go                         |    5 +-
 expr_test.go                                  |    4 +-
 file/source_test.go                           |    2 +-
 go.mod                                        |    8 -
 go.sum                                        |   10 -
 internal/deref/deref_test.go                  |    2 +-
 internal/difflib/difflib.go                   |  775 ++++
 internal/difflib/difflib_test.go              |  426 +++
 internal/spew/bypass.go                       |  146 +
 internal/spew/bypasssafe.go                   |   39 +
 internal/spew/common.go                       |  341 ++
 internal/spew/common_test.go                  |  298 ++
 internal/spew/config.go                       |  306 ++
 internal/spew/doc.go                          |  217 ++
 internal/spew/dump.go                         |  509 +++
 internal/spew/dump_test.go                    | 1042 ++++++
 internal/spew/dumpcgo_test.go                 |  102 +
 internal/spew/dumpnocgo_test.go               |   27 +
 internal/spew/example_test.go                 |  226 ++
 internal/spew/format.go                       |  419 +++
 internal/spew/format_test.go                  | 1558 ++++++++
 internal/spew/internal_test.go                |   84 +
 internal/spew/internalunsafe_test.go          |  102 +
 internal/spew/spew.go                         |  148 +
 internal/spew/spew_test.go                    |  320 ++
 internal/spew/testdata/dumpcgo.go             |   83 +
 internal/testify/assert/assertion_compare.go  |  489 +++
 .../testify/assert/assertion_compare_test.go  |  472 +++
 internal/testify/assert/assertion_format.go   |  807 +++++
 .../testify/assert/assertion_format.go.tmpl   |    5 +
 internal/testify/assert/assertion_forward.go  | 1605 +++++++++
 .../testify/assert/assertion_forward.go.tmpl  |    5 +
 internal/testify/assert/assertion_order.go    |   81 +
 .../testify/assert/assertion_order_test.go    |  203 ++
 internal/testify/assert/assertions.go         | 2091 +++++++++++
 internal/testify/assert/assertions_test.go    | 3155 +++++++++++++++++
 internal/testify/assert/doc.go                |   46 +
 internal/testify/assert/errors.go             |   10 +
 internal/testify/assert/forward_assertions.go |   16 +
 .../testify/assert/forward_assertions_test.go |  654 ++++
 internal/testify/assert/http_assertions.go    |  165 +
 .../testify/assert/http_assertions_test.go    |  214 ++
 .../assert/internal/unsafetests/doc.go        |    4 +
 .../internal/unsafetests/unsafetests_test.go  |   34 +
 internal/testify/require/doc.go               |   29 +
 .../testify/require/forward_requirements.go   |   16 +
 .../require/forward_requirements_test.go      |  397 +++
 internal/testify/require/require.go           | 2039 +++++++++++
 internal/testify/require/require.go.tmpl      |    6 +
 internal/testify/require/require_forward.go   | 1607 +++++++++
 .../testify/require/require_forward.go.tmpl   |    5 +
 internal/testify/require/requirements.go      |   29 +
 internal/testify/require/requirements_test.go |  578 +++
 optimizer/optimizer_test.go                   |    4 +-
 optimizer/sum_array_test.go                   |    4 +-
 optimizer/sum_map_test.go                     |    4 +-
 parser/lexer/lexer_test.go                    |    4 +-
 parser/parser_test.go                         |    4 +-
 patcher/value/bench_test.go                   |    2 +-
 patcher/value/value_test.go                   |    2 +-
 patcher/with_context_test.go                  |    2 +-
 patcher/with_timezone_test.go                 |    2 +-
 repl/go.mod                                   |    2 +-
 repl/go.sum                                   |    4 -
 test/coredns/coredns_test.go                  |    3 +-
 test/crowdsec/crowdsec_test.go                |    3 +-
 test/deref/deref_test.go                      |    4 +-
 test/gen/gen_test.go                          |    3 +-
 .../interface_method/interface_method_test.go |    4 +-
 test/operator/issues584/issues584_test.go     |    2 +-
 test/operator/operator_test.go                |    4 +-
 test/patch/change_ident_test.go               |    2 +-
 test/patch/patch_test.go                      |    3 +-
 test/patch/set_type/set_type_test.go          |    2 +-
 test/pipes/pipes_test.go                      |    3 +-
 test/time/time_test.go                        |    3 +-
 vm/debug_test.go                              |    2 +-
 vm/runtime/helpers_test.go                    |    3 +-
 vm/vm_test.go                                 |    2 +-
 87 files changed, 21989 insertions(+), 76 deletions(-)
 delete mode 100644 go.sum
 create mode 100644 internal/difflib/difflib.go
 create mode 100644 internal/difflib/difflib_test.go
 create mode 100644 internal/spew/bypass.go
 create mode 100644 internal/spew/bypasssafe.go
 create mode 100644 internal/spew/common.go
 create mode 100644 internal/spew/common_test.go
 create mode 100644 internal/spew/config.go
 create mode 100644 internal/spew/doc.go
 create mode 100644 internal/spew/dump.go
 create mode 100644 internal/spew/dump_test.go
 create mode 100644 internal/spew/dumpcgo_test.go
 create mode 100644 internal/spew/dumpnocgo_test.go
 create mode 100644 internal/spew/example_test.go
 create mode 100644 internal/spew/format.go
 create mode 100644 internal/spew/format_test.go
 create mode 100644 internal/spew/internal_test.go
 create mode 100644 internal/spew/internalunsafe_test.go
 create mode 100644 internal/spew/spew.go
 create mode 100644 internal/spew/spew_test.go
 create mode 100644 internal/spew/testdata/dumpcgo.go
 create mode 100644 internal/testify/assert/assertion_compare.go
 create mode 100644 internal/testify/assert/assertion_compare_test.go
 create mode 100644 internal/testify/assert/assertion_format.go
 create mode 100644 internal/testify/assert/assertion_format.go.tmpl
 create mode 100644 internal/testify/assert/assertion_forward.go
 create mode 100644 internal/testify/assert/assertion_forward.go.tmpl
 create mode 100644 internal/testify/assert/assertion_order.go
 create mode 100644 internal/testify/assert/assertion_order_test.go
 create mode 100644 internal/testify/assert/assertions.go
 create mode 100644 internal/testify/assert/assertions_test.go
 create mode 100644 internal/testify/assert/doc.go
 create mode 100644 internal/testify/assert/errors.go
 create mode 100644 internal/testify/assert/forward_assertions.go
 create mode 100644 internal/testify/assert/forward_assertions_test.go
 create mode 100644 internal/testify/assert/http_assertions.go
 create mode 100644 internal/testify/assert/http_assertions_test.go
 create mode 100644 internal/testify/assert/internal/unsafetests/doc.go
 create mode 100644 internal/testify/assert/internal/unsafetests/unsafetests_test.go
 create mode 100644 internal/testify/require/doc.go
 create mode 100644 internal/testify/require/forward_requirements.go
 create mode 100644 internal/testify/require/forward_requirements_test.go
 create mode 100644 internal/testify/require/require.go
 create mode 100644 internal/testify/require/require.go.tmpl
 create mode 100644 internal/testify/require/require_forward.go
 create mode 100644 internal/testify/require/require_forward.go.tmpl
 create mode 100644 internal/testify/require/requirements.go
 create mode 100644 internal/testify/require/requirements_test.go

diff --git a/ast/print_test.go b/ast/print_test.go
index 4ad49714c..51edd63f5 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -3,8 +3,8 @@ package ast_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/parser"
diff --git a/ast/visitor_test.go b/ast/visitor_test.go
index af0a17b22..4fd8d825c 100644
--- a/ast/visitor_test.go
+++ b/ast/visitor_test.go
@@ -3,8 +3,9 @@ package ast_test
 import (
 	"testing"
 
+	"github.com/expr-lang/expr/internal/testify/assert"
+
 	"github.com/expr-lang/expr/ast"
-	"github.com/stretchr/testify/assert"
 )
 
 type visitor struct {
diff --git a/bench_test.go b/bench_test.go
index ebeed5d18..de159bed9 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -3,7 +3,7 @@ package expr_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/vm"
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 09a13b9f8..334910afb 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -7,8 +7,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/builtin"
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 29c50807e..1509045e3 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -7,8 +7,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
diff --git a/checker/info_test.go b/checker/info_test.go
index 6b0a042c2..d10476b52 100644
--- a/checker/info_test.go
+++ b/checker/info_test.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr/checker"
 	"github.com/expr-lang/expr/test/mock"
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index 6fe58e930..eb7f3d323 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -4,8 +4,8 @@ import (
 	"math"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/test/mock"
diff --git a/debug/go.sum b/debug/go.sum
index 1078cbe99..01470e9e4 100644
--- a/debug/go.sum
+++ b/debug/go.sum
@@ -1,4 +1,3 @@
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
 github.com/gdamore/tcell/v2 v2.6.0 h1:OKbluoP9VYmJwZwq/iLb4BxwKcwGthaa1YNBJIyCySg=
@@ -8,14 +7,12 @@ github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i
 github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
 github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703 h1:ZyM/+FYnpbZsFWuCohniM56kRoHRB4r5EuIzXEYkpxo=
 github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703/go.mod h1:nVwGv4MP47T0jvlk7KuTTjjuSmrGO4JF0iaiNt4bufE=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
@@ -48,4 +45,3 @@ golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/docgen/docgen_test.go b/docgen/docgen_test.go
index 3ffb64ff8..26cf4f7a9 100644
--- a/docgen/docgen_test.go
+++ b/docgen/docgen_test.go
@@ -5,9 +5,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
+
 	. "github.com/expr-lang/expr/docgen"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 type Tweet struct {
diff --git a/expr_test.go b/expr_test.go
index 889d82b32..2c8ab461c 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -10,8 +10,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
diff --git a/file/source_test.go b/file/source_test.go
index 929ea4870..d380c22d0 100644
--- a/file/source_test.go
+++ b/file/source_test.go
@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/assert"
 )
 
 const (
diff --git a/go.mod b/go.mod
index 0d2d47190..348e7cfd6 100644
--- a/go.mod
+++ b/go.mod
@@ -1,11 +1,3 @@
 module github.com/expr-lang/expr
 
 go 1.18
-
-require github.com/stretchr/testify v1.8.4
-
-require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)
diff --git a/go.sum b/go.sum
deleted file mode 100644
index fa4b6e682..000000000
--- a/go.sum
+++ /dev/null
@@ -1,10 +0,0 @@
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/internal/deref/deref_test.go b/internal/deref/deref_test.go
index 554455f6d..5f812bee5 100644
--- a/internal/deref/deref_test.go
+++ b/internal/deref/deref_test.go
@@ -4,7 +4,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/assert"
 
 	"github.com/expr-lang/expr/internal/deref"
 )
diff --git a/internal/difflib/difflib.go b/internal/difflib/difflib.go
new file mode 100644
index 000000000..2a73737af
--- /dev/null
+++ b/internal/difflib/difflib.go
@@ -0,0 +1,775 @@
+// Package difflib is a partial port of Python difflib module.
+//
+// It provides tools to compare sequences of strings and generate textual diffs.
+//
+// The following class and functions have been ported:
+//
+// - SequenceMatcher
+//
+// - unified_diff
+//
+// - context_diff
+//
+// Getting unified diffs was the main goal of the port. Keep in mind this code
+// is mostly suitable to output text differences in a human friendly way, there
+// are no guarantees generated diffs are consumable by patch(1).
+package difflib
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+)
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func calculateRatio(matches, length int) float64 {
+	if length > 0 {
+		return 2.0 * float64(matches) / float64(length)
+	}
+	return 1.0
+}
+
+type Match struct {
+	A    int
+	B    int
+	Size int
+}
+
+type OpCode struct {
+	Tag byte
+	I1  int
+	I2  int
+	J1  int
+	J2  int
+}
+
+// SequenceMatcher compares sequence of strings. The basic
+// algorithm predates, and is a little fancier than, an algorithm
+// published in the late 1980's by Ratcliff and Obershelp under the
+// hyperbolic name "gestalt pattern matching".  The basic idea is to find
+// the longest contiguous matching subsequence that contains no "junk"
+// elements (R-O doesn't address junk).  The same idea is then applied
+// recursively to the pieces of the sequences to the left and to the right
+// of the matching subsequence.  This does not yield minimal edit
+// sequences, but does tend to yield matches that "look right" to people.
+//
+// SequenceMatcher tries to compute a "human-friendly diff" between two
+// sequences.  Unlike e.g. UNIX(tm) diff, the fundamental notion is the
+// longest *contiguous* & junk-free matching subsequence.  That's what
+// catches peoples' eyes.  The Windows(tm) windiff has another interesting
+// notion, pairing up elements that appear uniquely in each sequence.
+// That, and the method here, appear to yield more intuitive difference
+// reports than does diff.  This method appears to be the least vulnerable
+// to synching up on blocks of "junk lines", though (like blank lines in
+// ordinary text files, or maybe "<P>" lines in HTML files).  That may be
+// because this is the only method of the 3 that has a *concept* of
+// "junk" <wink>.
+//
+// Timing:  Basic R-O is cubic time worst case and quadratic time expected
+// case.  SequenceMatcher is quadratic time for the worst case and has
+// expected-case behavior dependent in a complicated way on how many
+// elements the sequences have in common; best case time is linear.
+type SequenceMatcher struct {
+	a              []string
+	b              []string
+	b2j            map[string][]int
+	IsJunk         func(string) bool
+	autoJunk       bool
+	bJunk          map[string]struct{}
+	matchingBlocks []Match
+	fullBCount     map[string]int
+	bPopular       map[string]struct{}
+	opCodes        []OpCode
+}
+
+func NewMatcher(a, b []string) *SequenceMatcher {
+	m := SequenceMatcher{autoJunk: true}
+	m.SetSeqs(a, b)
+	return &m
+}
+
+func NewMatcherWithJunk(a, b []string, autoJunk bool,
+	isJunk func(string) bool) *SequenceMatcher {
+
+	m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
+	m.SetSeqs(a, b)
+	return &m
+}
+
+// Set two sequences to be compared.
+func (m *SequenceMatcher) SetSeqs(a, b []string) {
+	m.SetSeq1(a)
+	m.SetSeq2(b)
+}
+
+// Set the first sequence to be compared. The second sequence to be compared is
+// not changed.
+//
+// SequenceMatcher computes and caches detailed information about the second
+// sequence, so if you want to compare one sequence S against many sequences,
+// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
+// sequences.
+//
+// See also SetSeqs() and SetSeq2().
+func (m *SequenceMatcher) SetSeq1(a []string) {
+	if &a == &m.a {
+		return
+	}
+	m.a = a
+	m.matchingBlocks = nil
+	m.opCodes = nil
+}
+
+// Set the second sequence to be compared. The first sequence to be compared is
+// not changed.
+func (m *SequenceMatcher) SetSeq2(b []string) {
+	if &b == &m.b {
+		return
+	}
+	m.b = b
+	m.matchingBlocks = nil
+	m.opCodes = nil
+	m.fullBCount = nil
+	m.chainB()
+}
+
+func (m *SequenceMatcher) chainB() {
+	// Populate line -> index mapping
+	b2j := map[string][]int{}
+	for i, s := range m.b {
+		indices := b2j[s]
+		indices = append(indices, i)
+		b2j[s] = indices
+	}
+
+	// Purge junk elements
+	m.bJunk = map[string]struct{}{}
+	if m.IsJunk != nil {
+		junk := m.bJunk
+		for s, _ := range b2j {
+			if m.IsJunk(s) {
+				junk[s] = struct{}{}
+			}
+		}
+		for s, _ := range junk {
+			delete(b2j, s)
+		}
+	}
+
+	// Purge remaining popular elements
+	popular := map[string]struct{}{}
+	n := len(m.b)
+	if m.autoJunk && n >= 200 {
+		ntest := n/100 + 1
+		for s, indices := range b2j {
+			if len(indices) > ntest {
+				popular[s] = struct{}{}
+			}
+		}
+		for s, _ := range popular {
+			delete(b2j, s)
+		}
+	}
+	m.bPopular = popular
+	m.b2j = b2j
+}
+
+func (m *SequenceMatcher) isBJunk(s string) bool {
+	_, ok := m.bJunk[s]
+	return ok
+}
+
+// Find longest matching block in a[alo:ahi] and b[blo:bhi].
+//
+// If IsJunk is not defined:
+//
+// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
+//
+//	alo <= i <= i+k <= ahi
+//	blo <= j <= j+k <= bhi
+//
+// and for all (i',j',k') meeting those conditions,
+//
+//	k >= k'
+//	i <= i'
+//	and if i == i', j <= j'
+//
+// In other words, of all maximal matching blocks, return one that
+// starts earliest in a, and of all those maximal matching blocks that
+// start earliest in a, return the one that starts earliest in b.
+//
+// If IsJunk is defined, first the longest matching block is
+// determined as above, but with the additional restriction that no
+// junk element appears in the block.  Then that block is extended as
+// far as possible by matching (only) junk elements on both sides.  So
+// the resulting block never matches on junk except as identical junk
+// happens to be adjacent to an "interesting" match.
+//
+// If no blocks match, return (alo, blo, 0).
+func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {
+	// CAUTION:  stripping common prefix or suffix would be incorrect.
+	// E.g.,
+	//    ab
+	//    acab
+	// Longest matching block is "ab", but if common prefix is
+	// stripped, it's "a" (tied with "b").  UNIX(tm) diff does so
+	// strip, so ends up claiming that ab is changed to acab by
+	// inserting "ca" in the middle.  That's minimal but unintuitive:
+	// "it's obvious" that someone inserted "ac" at the front.
+	// Windiff ends up at the same place as diff, but by pairing up
+	// the unique 'b's and then matching the first two 'a's.
+	besti, bestj, bestsize := alo, blo, 0
+
+	// find longest junk-free match
+	// during an iteration of the loop, j2len[j] = length of longest
+	// junk-free match ending with a[i-1] and b[j]
+	j2len := map[int]int{}
+	for i := alo; i != ahi; i++ {
+		// look at all instances of a[i] in b; note that because
+		// b2j has no junk keys, the loop is skipped if a[i] is junk
+		newj2len := map[int]int{}
+		for _, j := range m.b2j[m.a[i]] {
+			// a[i] matches b[j]
+			if j < blo {
+				continue
+			}
+			if j >= bhi {
+				break
+			}
+			k := j2len[j-1] + 1
+			newj2len[j] = k
+			if k > bestsize {
+				besti, bestj, bestsize = i-k+1, j-k+1, k
+			}
+		}
+		j2len = newj2len
+	}
+
+	// Extend the best by non-junk elements on each end.  In particular,
+	// "popular" non-junk elements aren't in b2j, which greatly speeds
+	// the inner loop above, but also means "the best" match so far
+	// doesn't contain any junk *or* popular non-junk elements.
+	for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&
+		m.a[besti-1] == m.b[bestj-1] {
+		besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
+	}
+	for besti+bestsize < ahi && bestj+bestsize < bhi &&
+		!m.isBJunk(m.b[bestj+bestsize]) &&
+		m.a[besti+bestsize] == m.b[bestj+bestsize] {
+		bestsize += 1
+	}
+
+	// Now that we have a wholly interesting match (albeit possibly
+	// empty!), we may as well suck up the matching junk on each
+	// side of it too.  Can't think of a good reason not to, and it
+	// saves post-processing the (possibly considerable) expense of
+	// figuring out what to do with it.  In the case of an empty
+	// interesting match, this is clearly the right thing to do,
+	// because no other kind of match is possible in the regions.
+	for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&
+		m.a[besti-1] == m.b[bestj-1] {
+		besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
+	}
+	for besti+bestsize < ahi && bestj+bestsize < bhi &&
+		m.isBJunk(m.b[bestj+bestsize]) &&
+		m.a[besti+bestsize] == m.b[bestj+bestsize] {
+		bestsize += 1
+	}
+
+	return Match{A: besti, B: bestj, Size: bestsize}
+}
+
+// Return list of triples describing matching subsequences.
+//
+// Each triple is of the form (i, j, n), and means that
+// a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in
+// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
+// adjacent triples in the list, and the second is not the last triple in the
+// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
+// adjacent equal blocks.
+//
+// The last triple is a dummy, (len(a), len(b), 0), and is the only
+// triple with n==0.
+func (m *SequenceMatcher) GetMatchingBlocks() []Match {
+	if m.matchingBlocks != nil {
+		return m.matchingBlocks
+	}
+
+	var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match
+	matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {
+		match := m.findLongestMatch(alo, ahi, blo, bhi)
+		i, j, k := match.A, match.B, match.Size
+		if match.Size > 0 {
+			if alo < i && blo < j {
+				matched = matchBlocks(alo, i, blo, j, matched)
+			}
+			matched = append(matched, match)
+			if i+k < ahi && j+k < bhi {
+				matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
+			}
+		}
+		return matched
+	}
+	matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)
+
+	// It's possible that we have adjacent equal blocks in the
+	// matching_blocks list now.
+	nonAdjacent := []Match{}
+	i1, j1, k1 := 0, 0, 0
+	for _, b := range matched {
+		// Is this block adjacent to i1, j1, k1?
+		i2, j2, k2 := b.A, b.B, b.Size
+		if i1+k1 == i2 && j1+k1 == j2 {
+			// Yes, so collapse them -- this just increases the length of
+			// the first block by the length of the second, and the first
+			// block so lengthened remains the block to compare against.
+			k1 += k2
+		} else {
+			// Not adjacent.  Remember the first block (k1==0 means it's
+			// the dummy we started with), and make the second block the
+			// new block to compare against.
+			if k1 > 0 {
+				nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
+			}
+			i1, j1, k1 = i2, j2, k2
+		}
+	}
+	if k1 > 0 {
+		nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
+	}
+
+	nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})
+	m.matchingBlocks = nonAdjacent
+	return m.matchingBlocks
+}
+
+// Return list of 5-tuples describing how to turn a into b.
+//
+// Each tuple is of the form (tag, i1, i2, j1, j2).  The first tuple
+// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
+// tuple preceding it, and likewise for j1 == the previous j2.
+//
+// The tags are characters, with these meanings:
+//
+// 'r' (replace):  a[i1:i2] should be replaced by b[j1:j2]
+//
+// 'd' (delete):   a[i1:i2] should be deleted, j1==j2 in this case.
+//
+// 'i' (insert):   b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
+//
+// 'e' (equal):    a[i1:i2] == b[j1:j2]
+func (m *SequenceMatcher) GetOpCodes() []OpCode {
+	if m.opCodes != nil {
+		return m.opCodes
+	}
+	i, j := 0, 0
+	matching := m.GetMatchingBlocks()
+	opCodes := make([]OpCode, 0, len(matching))
+	for _, m := range matching {
+		//  invariant:  we've pumped out correct diffs to change
+		//  a[:i] into b[:j], and the next matching block is
+		//  a[ai:ai+size] == b[bj:bj+size]. So we need to pump
+		//  out a diff to change a[i:ai] into b[j:bj], pump out
+		//  the matching block, and move (i,j) beyond the match
+		ai, bj, size := m.A, m.B, m.Size
+		tag := byte(0)
+		if i < ai && j < bj {
+			tag = 'r'
+		} else if i < ai {
+			tag = 'd'
+		} else if j < bj {
+			tag = 'i'
+		}
+		if tag > 0 {
+			opCodes = append(opCodes, OpCode{tag, i, ai, j, bj})
+		}
+		i, j = ai+size, bj+size
+		// the list of matching blocks is terminated by a
+		// sentinel with size 0
+		if size > 0 {
+			opCodes = append(opCodes, OpCode{'e', ai, i, bj, j})
+		}
+	}
+	m.opCodes = opCodes
+	return m.opCodes
+}
+
+// Isolate change clusters by eliminating ranges with no changes.
+//
+// Return a generator of groups with up to n lines of context.
+// Each group is in the same format as returned by GetOpCodes().
+func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
+	if n < 0 {
+		n = 3
+	}
+	codes := m.GetOpCodes()
+	if len(codes) == 0 {
+		codes = []OpCode{OpCode{'e', 0, 1, 0, 1}}
+	}
+	// Fixup leading and trailing groups if they show no changes.
+	if codes[0].Tag == 'e' {
+		c := codes[0]
+		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
+		codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}
+	}
+	if codes[len(codes)-1].Tag == 'e' {
+		c := codes[len(codes)-1]
+		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
+		codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}
+	}
+	nn := n + n
+	groups := [][]OpCode{}
+	group := []OpCode{}
+	for _, c := range codes {
+		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
+		// End the current group and start a new one whenever
+		// there is a large range with no changes.
+		if c.Tag == 'e' && i2-i1 > nn {
+			group = append(group, OpCode{c.Tag, i1, min(i2, i1+n),
+				j1, min(j2, j1+n)})
+			groups = append(groups, group)
+			group = []OpCode{}
+			i1, j1 = max(i1, i2-n), max(j1, j2-n)
+		}
+		group = append(group, OpCode{c.Tag, i1, i2, j1, j2})
+	}
+	if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {
+		groups = append(groups, group)
+	}
+	return groups
+}
+
+// Return a measure of the sequences' similarity (float in [0,1]).
+//
+// Where T is the total number of elements in both sequences, and
+// M is the number of matches, this is 2.0*M / T.
+// Note that this is 1 if the sequences are identical, and 0 if
+// they have nothing in common.
+//
+// .Ratio() is expensive to compute if you haven't already computed
+// .GetMatchingBlocks() or .GetOpCodes(), in which case you may
+// want to try .QuickRatio() or .RealQuickRation() first to get an
+// upper bound.
+func (m *SequenceMatcher) Ratio() float64 {
+	matches := 0
+	for _, m := range m.GetMatchingBlocks() {
+		matches += m.Size
+	}
+	return calculateRatio(matches, len(m.a)+len(m.b))
+}
+
+// Return an upper bound on ratio() relatively quickly.
+//
+// This isn't defined beyond that it is an upper bound on .Ratio(), and
+// is faster to compute.
+func (m *SequenceMatcher) QuickRatio() float64 {
+	// viewing a and b as multisets, set matches to the cardinality
+	// of their intersection; this counts the number of matches
+	// without regard to order, so is clearly an upper bound
+	if m.fullBCount == nil {
+		m.fullBCount = map[string]int{}
+		for _, s := range m.b {
+			m.fullBCount[s] = m.fullBCount[s] + 1
+		}
+	}
+
+	// avail[x] is the number of times x appears in 'b' less the
+	// number of times we've seen it in 'a' so far ... kinda
+	avail := map[string]int{}
+	matches := 0
+	for _, s := range m.a {
+		n, ok := avail[s]
+		if !ok {
+			n = m.fullBCount[s]
+		}
+		avail[s] = n - 1
+		if n > 0 {
+			matches += 1
+		}
+	}
+	return calculateRatio(matches, len(m.a)+len(m.b))
+}
+
+// Return an upper bound on ratio() very quickly.
+//
+// This isn't defined beyond that it is an upper bound on .Ratio(), and
+// is faster to compute than either .Ratio() or .QuickRatio().
+func (m *SequenceMatcher) RealQuickRatio() float64 {
+	la, lb := len(m.a), len(m.b)
+	return calculateRatio(min(la, lb), la+lb)
+}
+
+// Convert range to the "ed" format
+func formatRangeUnified(start, stop int) string {
+	// Per the diff spec at http://www.unix.org/single_unix_specification/
+	beginning := start + 1 // lines start numbering with one
+	length := stop - start
+	if length == 1 {
+		return fmt.Sprintf("%d", beginning)
+	}
+	if length == 0 {
+		beginning -= 1 // empty ranges begin at line just before the range
+	}
+	return fmt.Sprintf("%d,%d", beginning, length)
+}
+
+// Unified diff parameters
+type UnifiedDiff struct {
+	A        []string // First sequence lines
+	FromFile string   // First file name
+	FromDate string   // First file time
+	B        []string // Second sequence lines
+	ToFile   string   // Second file name
+	ToDate   string   // Second file time
+	Eol      string   // Headers end of line, defaults to LF
+	Context  int      // Number of context lines
+}
+
+// Compare two sequences of lines; generate the delta as a unified diff.
+//
+// Unified diffs are a compact way of showing line changes and a few
+// lines of context.  The number of context lines is set by 'n' which
+// defaults to three.
+//
+// By default, the diff control lines (those with ---, +++, or @@) are
+// created with a trailing newline.  This is helpful so that inputs
+// created from file.readlines() result in diffs that are suitable for
+// file.writelines() since both the inputs and outputs have trailing
+// newlines.
+//
+// For inputs that do not have trailing newlines, set the lineterm
+// argument to "" so that the output will be uniformly newline free.
+//
+// The unidiff format normally has a header for filenames and modification
+// times.  Any or all of these may be specified using strings for
+// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
+// The modification times are normally expressed in the ISO 8601 format.
+func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {
+	buf := bufio.NewWriter(writer)
+	defer buf.Flush()
+	wf := func(format string, args ...interface{}) error {
+		_, err := buf.WriteString(fmt.Sprintf(format, args...))
+		return err
+	}
+	ws := func(s string) error {
+		_, err := buf.WriteString(s)
+		return err
+	}
+
+	if len(diff.Eol) == 0 {
+		diff.Eol = "\n"
+	}
+
+	started := false
+	m := NewMatcher(diff.A, diff.B)
+	for _, g := range m.GetGroupedOpCodes(diff.Context) {
+		if !started {
+			started = true
+			fromDate := ""
+			if len(diff.FromDate) > 0 {
+				fromDate = "\t" + diff.FromDate
+			}
+			toDate := ""
+			if len(diff.ToDate) > 0 {
+				toDate = "\t" + diff.ToDate
+			}
+			if diff.FromFile != "" || diff.ToFile != "" {
+				err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol)
+				if err != nil {
+					return err
+				}
+				err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		first, last := g[0], g[len(g)-1]
+		range1 := formatRangeUnified(first.I1, last.I2)
+		range2 := formatRangeUnified(first.J1, last.J2)
+		if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil {
+			return err
+		}
+		for _, c := range g {
+			i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
+			if c.Tag == 'e' {
+				for _, line := range diff.A[i1:i2] {
+					if err := ws(" " + line); err != nil {
+						return err
+					}
+				}
+				continue
+			}
+			if c.Tag == 'r' || c.Tag == 'd' {
+				for _, line := range diff.A[i1:i2] {
+					if err := ws("-" + line); err != nil {
+						return err
+					}
+				}
+			}
+			if c.Tag == 'r' || c.Tag == 'i' {
+				for _, line := range diff.B[j1:j2] {
+					if err := ws("+" + line); err != nil {
+						return err
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// Like WriteUnifiedDiff but returns the diff a string.
+func GetUnifiedDiffString(diff UnifiedDiff) (string, error) {
+	w := &bytes.Buffer{}
+	err := WriteUnifiedDiff(w, diff)
+	return string(w.Bytes()), err
+}
+
+// Convert range to the "ed" format.
+func formatRangeContext(start, stop int) string {
+	// Per the diff spec at http://www.unix.org/single_unix_specification/
+	beginning := start + 1 // lines start numbering with one
+	length := stop - start
+	if length == 0 {
+		beginning -= 1 // empty ranges begin at line just before the range
+	}
+	if length <= 1 {
+		return fmt.Sprintf("%d", beginning)
+	}
+	return fmt.Sprintf("%d,%d", beginning, beginning+length-1)
+}
+
+type ContextDiff UnifiedDiff
+
+// Compare two sequences of lines; generate the delta as a context diff.
+//
+// Context diffs are a compact way of showing line changes and a few
+// lines of context. The number of context lines is set by diff.Context
+// which defaults to three.
+//
+// By default, the diff control lines (those with *** or ---) are
+// created with a trailing newline.
+//
+// For inputs that do not have trailing newlines, set the diff.Eol
+// argument to "" so that the output will be uniformly newline free.
+//
+// The context diff format normally has a header for filenames and
+// modification times.  Any or all of these may be specified using
+// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.
+// The modification times are normally expressed in the ISO 8601 format.
+// If not specified, the strings default to blanks.
+func WriteContextDiff(writer io.Writer, diff ContextDiff) error {
+	buf := bufio.NewWriter(writer)
+	defer buf.Flush()
+	var diffErr error
+	wf := func(format string, args ...interface{}) {
+		_, err := buf.WriteString(fmt.Sprintf(format, args...))
+		if diffErr == nil && err != nil {
+			diffErr = err
+		}
+	}
+	ws := func(s string) {
+		_, err := buf.WriteString(s)
+		if diffErr == nil && err != nil {
+			diffErr = err
+		}
+	}
+
+	if len(diff.Eol) == 0 {
+		diff.Eol = "\n"
+	}
+
+	prefix := map[byte]string{
+		'i': "+ ",
+		'd': "- ",
+		'r': "! ",
+		'e': "  ",
+	}
+
+	started := false
+	m := NewMatcher(diff.A, diff.B)
+	for _, g := range m.GetGroupedOpCodes(diff.Context) {
+		if !started {
+			started = true
+			fromDate := ""
+			if len(diff.FromDate) > 0 {
+				fromDate = "\t" + diff.FromDate
+			}
+			toDate := ""
+			if len(diff.ToDate) > 0 {
+				toDate = "\t" + diff.ToDate
+			}
+			if diff.FromFile != "" || diff.ToFile != "" {
+				wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol)
+				wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol)
+			}
+		}
+
+		first, last := g[0], g[len(g)-1]
+		ws("***************" + diff.Eol)
+
+		range1 := formatRangeContext(first.I1, last.I2)
+		wf("*** %s ****%s", range1, diff.Eol)
+		for _, c := range g {
+			if c.Tag == 'r' || c.Tag == 'd' {
+				for _, cc := range g {
+					if cc.Tag == 'i' {
+						continue
+					}
+					for _, line := range diff.A[cc.I1:cc.I2] {
+						ws(prefix[cc.Tag] + line)
+					}
+				}
+				break
+			}
+		}
+
+		range2 := formatRangeContext(first.J1, last.J2)
+		wf("--- %s ----%s", range2, diff.Eol)
+		for _, c := range g {
+			if c.Tag == 'r' || c.Tag == 'i' {
+				for _, cc := range g {
+					if cc.Tag == 'd' {
+						continue
+					}
+					for _, line := range diff.B[cc.J1:cc.J2] {
+						ws(prefix[cc.Tag] + line)
+					}
+				}
+				break
+			}
+		}
+	}
+	return diffErr
+}
+
+// Like WriteContextDiff but returns the diff a string.
+func GetContextDiffString(diff ContextDiff) (string, error) {
+	w := &bytes.Buffer{}
+	err := WriteContextDiff(w, diff)
+	return string(w.Bytes()), err
+}
+
+// Split a string on "\n" while preserving them. The output can be used
+// as input for UnifiedDiff and ContextDiff structures.
+func SplitLines(s string) []string {
+	lines := strings.SplitAfter(s, "\n")
+	lines[len(lines)-1] += "\n"
+	return lines
+}
diff --git a/internal/difflib/difflib_test.go b/internal/difflib/difflib_test.go
new file mode 100644
index 000000000..d72511962
--- /dev/null
+++ b/internal/difflib/difflib_test.go
@@ -0,0 +1,426 @@
+package difflib
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func assertAlmostEqual(t *testing.T, a, b float64, places int) {
+	if math.Abs(a-b) > math.Pow10(-places) {
+		t.Errorf("%.7f != %.7f", a, b)
+	}
+}
+
+func assertEqual(t *testing.T, a, b interface{}) {
+	if !reflect.DeepEqual(a, b) {
+		t.Errorf("%v != %v", a, b)
+	}
+}
+
+func splitChars(s string) []string {
+	chars := make([]string, 0, len(s))
+	// Assume ASCII inputs
+	for i := 0; i != len(s); i++ {
+		chars = append(chars, string(s[i]))
+	}
+	return chars
+}
+
+func TestSequenceMatcherRatio(t *testing.T) {
+	s := NewMatcher(splitChars("abcd"), splitChars("bcde"))
+	assertEqual(t, s.Ratio(), 0.75)
+	assertEqual(t, s.QuickRatio(), 0.75)
+	assertEqual(t, s.RealQuickRatio(), 1.0)
+}
+
+func TestGetOptCodes(t *testing.T) {
+	a := "qabxcd"
+	b := "abycdf"
+	s := NewMatcher(splitChars(a), splitChars(b))
+	w := &bytes.Buffer{}
+	for _, op := range s.GetOpCodes() {
+		fmt.Fprintf(w, "%s a[%d:%d], (%s) b[%d:%d] (%s)\n", string(op.Tag),
+			op.I1, op.I2, a[op.I1:op.I2], op.J1, op.J2, b[op.J1:op.J2])
+	}
+	result := string(w.Bytes())
+	expected := `d a[0:1], (q) b[0:0] ()
+e a[1:3], (ab) b[0:2] (ab)
+r a[3:4], (x) b[2:3] (y)
+e a[4:6], (cd) b[3:5] (cd)
+i a[6:6], () b[5:6] (f)
+`
+	if expected != result {
+		t.Errorf("unexpected op codes: \n%s", result)
+	}
+}
+
+func TestGroupedOpCodes(t *testing.T) {
+	a := []string{}
+	for i := 0; i != 39; i++ {
+		a = append(a, fmt.Sprintf("%02d", i))
+	}
+	b := []string{}
+	b = append(b, a[:8]...)
+	b = append(b, " i")
+	b = append(b, a[8:19]...)
+	b = append(b, " x")
+	b = append(b, a[20:22]...)
+	b = append(b, a[27:34]...)
+	b = append(b, " y")
+	b = append(b, a[35:]...)
+	s := NewMatcher(a, b)
+	w := &bytes.Buffer{}
+	for _, g := range s.GetGroupedOpCodes(-1) {
+		fmt.Fprintf(w, "group\n")
+		for _, op := range g {
+			fmt.Fprintf(w, "  %s, %d, %d, %d, %d\n", string(op.Tag),
+				op.I1, op.I2, op.J1, op.J2)
+		}
+	}
+	result := string(w.Bytes())
+	expected := `group
+  e, 5, 8, 5, 8
+  i, 8, 8, 8, 9
+  e, 8, 11, 9, 12
+group
+  e, 16, 19, 17, 20
+  r, 19, 20, 20, 21
+  e, 20, 22, 21, 23
+  d, 22, 27, 23, 23
+  e, 27, 30, 23, 26
+group
+  e, 31, 34, 27, 30
+  r, 34, 35, 30, 31
+  e, 35, 38, 31, 34
+`
+	if expected != result {
+		t.Errorf("unexpected op codes: \n%s", result)
+	}
+}
+
+func ExampleGetUnifiedDiffCode() {
+	a := `one
+two
+three
+four
+fmt.Printf("%s,%T",a,b)`
+	b := `zero
+one
+three
+four`
+	diff := UnifiedDiff{
+		A:        SplitLines(a),
+		B:        SplitLines(b),
+		FromFile: "Original",
+		FromDate: "2005-01-26 23:30:50",
+		ToFile:   "Current",
+		ToDate:   "2010-04-02 10:20:52",
+		Context:  3,
+	}
+	result, _ := GetUnifiedDiffString(diff)
+	fmt.Println(strings.Replace(result, "\t", " ", -1))
+	// Output:
+	// --- Original 2005-01-26 23:30:50
+	// +++ Current 2010-04-02 10:20:52
+	// @@ -1,5 +1,4 @@
+	// +zero
+	//  one
+	// -two
+	//  three
+	//  four
+	// -fmt.Printf("%s,%T",a,b)
+}
+
+func ExampleGetContextDiffCode() {
+	a := `one
+two
+three
+four
+fmt.Printf("%s,%T",a,b)`
+	b := `zero
+one
+tree
+four`
+	diff := ContextDiff{
+		A:        SplitLines(a),
+		B:        SplitLines(b),
+		FromFile: "Original",
+		ToFile:   "Current",
+		Context:  3,
+		Eol:      "\n",
+	}
+	result, _ := GetContextDiffString(diff)
+	fmt.Print(strings.Replace(result, "\t", " ", -1))
+	// Output:
+	// *** Original
+	// --- Current
+	// ***************
+	// *** 1,5 ****
+	//   one
+	// ! two
+	// ! three
+	//   four
+	// - fmt.Printf("%s,%T",a,b)
+	// --- 1,4 ----
+	// + zero
+	//   one
+	// ! tree
+	//   four
+}
+
+func ExampleGetContextDiffString() {
+	a := `one
+two
+three
+four`
+	b := `zero
+one
+tree
+four`
+	diff := ContextDiff{
+		A:        SplitLines(a),
+		B:        SplitLines(b),
+		FromFile: "Original",
+		ToFile:   "Current",
+		Context:  3,
+		Eol:      "\n",
+	}
+	result, _ := GetContextDiffString(diff)
+	fmt.Printf(strings.Replace(result, "\t", " ", -1))
+	// Output:
+	// *** Original
+	// --- Current
+	// ***************
+	// *** 1,4 ****
+	//   one
+	// ! two
+	// ! three
+	//   four
+	// --- 1,4 ----
+	// + zero
+	//   one
+	// ! tree
+	//   four
+}
+
+func rep(s string, count int) string {
+	return strings.Repeat(s, count)
+}
+
+func TestWithAsciiOneInsert(t *testing.T) {
+	sm := NewMatcher(splitChars(rep("b", 100)),
+		splitChars("a"+rep("b", 100)))
+	assertAlmostEqual(t, sm.Ratio(), 0.995, 3)
+	assertEqual(t, sm.GetOpCodes(),
+		[]OpCode{{'i', 0, 0, 0, 1}, {'e', 0, 100, 1, 101}})
+	assertEqual(t, len(sm.bPopular), 0)
+
+	sm = NewMatcher(splitChars(rep("b", 100)),
+		splitChars(rep("b", 50)+"a"+rep("b", 50)))
+	assertAlmostEqual(t, sm.Ratio(), 0.995, 3)
+	assertEqual(t, sm.GetOpCodes(),
+		[]OpCode{{'e', 0, 50, 0, 50}, {'i', 50, 50, 50, 51}, {'e', 50, 100, 51, 101}})
+	assertEqual(t, len(sm.bPopular), 0)
+}
+
+func TestWithAsciiOnDelete(t *testing.T) {
+	sm := NewMatcher(splitChars(rep("a", 40)+"c"+rep("b", 40)),
+		splitChars(rep("a", 40)+rep("b", 40)))
+	assertAlmostEqual(t, sm.Ratio(), 0.994, 3)
+	assertEqual(t, sm.GetOpCodes(),
+		[]OpCode{{'e', 0, 40, 0, 40}, {'d', 40, 41, 40, 40}, {'e', 41, 81, 40, 80}})
+}
+
+func TestWithAsciiBJunk(t *testing.T) {
+	isJunk := func(s string) bool {
+		return s == " "
+	}
+	sm := NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)),
+		splitChars(rep("a", 44)+rep("b", 40)), true, isJunk)
+	assertEqual(t, sm.bJunk, map[string]struct{}{})
+
+	sm = NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)),
+		splitChars(rep("a", 44)+rep("b", 40)+rep(" ", 20)), false, isJunk)
+	assertEqual(t, sm.bJunk, map[string]struct{}{" ": struct{}{}})
+
+	isJunk = func(s string) bool {
+		return s == " " || s == "b"
+	}
+	sm = NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)),
+		splitChars(rep("a", 44)+rep("b", 40)+rep(" ", 20)), false, isJunk)
+	assertEqual(t, sm.bJunk, map[string]struct{}{" ": struct{}{}, "b": struct{}{}})
+}
+
+func TestSFBugsRatioForNullSeqn(t *testing.T) {
+	sm := NewMatcher(nil, nil)
+	assertEqual(t, sm.Ratio(), 1.0)
+	assertEqual(t, sm.QuickRatio(), 1.0)
+	assertEqual(t, sm.RealQuickRatio(), 1.0)
+}
+
+func TestSFBugsComparingEmptyLists(t *testing.T) {
+	groups := NewMatcher(nil, nil).GetGroupedOpCodes(-1)
+	assertEqual(t, len(groups), 0)
+	diff := UnifiedDiff{
+		FromFile: "Original",
+		ToFile:   "Current",
+		Context:  3,
+	}
+	result, err := GetUnifiedDiffString(diff)
+	assertEqual(t, err, nil)
+	assertEqual(t, result, "")
+}
+
+func TestOutputFormatRangeFormatUnified(t *testing.T) {
+	// Per the diff spec at http://www.unix.org/single_unix_specification/
+	//
+	// Each <range> field shall be of the form:
+	//   %1d", <beginning line number>  if the range contains exactly one line,
+	// and:
+	//  "%1d,%1d", <beginning line number>, <number of lines> otherwise.
+	// If a range is empty, its beginning line number shall be the number of
+	// the line just before the range, or 0 if the empty range starts the file.
+	fm := formatRangeUnified
+	assertEqual(t, fm(3, 3), "3,0")
+	assertEqual(t, fm(3, 4), "4")
+	assertEqual(t, fm(3, 5), "4,2")
+	assertEqual(t, fm(3, 6), "4,3")
+	assertEqual(t, fm(0, 0), "0,0")
+}
+
+func TestOutputFormatRangeFormatContext(t *testing.T) {
+	// Per the diff spec at http://www.unix.org/single_unix_specification/
+	//
+	// The range of lines in file1 shall be written in the following format
+	// if the range contains two or more lines:
+	//     "*** %d,%d ****\n", <beginning line number>, <ending line number>
+	// and the following format otherwise:
+	//     "*** %d ****\n", <ending line number>
+	// The ending line number of an empty range shall be the number of the preceding line,
+	// or 0 if the range is at the start of the file.
+	//
+	// Next, the range of lines in file2 shall be written in the following format
+	// if the range contains two or more lines:
+	//     "--- %d,%d ----\n", <beginning line number>, <ending line number>
+	// and the following format otherwise:
+	//     "--- %d ----\n", <ending line number>
+	fm := formatRangeContext
+	assertEqual(t, fm(3, 3), "3")
+	assertEqual(t, fm(3, 4), "4")
+	assertEqual(t, fm(3, 5), "4,5")
+	assertEqual(t, fm(3, 6), "4,6")
+	assertEqual(t, fm(0, 0), "0")
+}
+
+func TestOutputFormatTabDelimiter(t *testing.T) {
+	diff := UnifiedDiff{
+		A:        splitChars("one"),
+		B:        splitChars("two"),
+		FromFile: "Original",
+		FromDate: "2005-01-26 23:30:50",
+		ToFile:   "Current",
+		ToDate:   "2010-04-12 10:20:52",
+		Eol:      "\n",
+	}
+	ud, err := GetUnifiedDiffString(diff)
+	assertEqual(t, err, nil)
+	assertEqual(t, SplitLines(ud)[:2], []string{
+		"--- Original\t2005-01-26 23:30:50\n",
+		"+++ Current\t2010-04-12 10:20:52\n",
+	})
+	cd, err := GetContextDiffString(ContextDiff(diff))
+	assertEqual(t, err, nil)
+	assertEqual(t, SplitLines(cd)[:2], []string{
+		"*** Original\t2005-01-26 23:30:50\n",
+		"--- Current\t2010-04-12 10:20:52\n",
+	})
+}
+
+func TestOutputFormatNoTrailingTabOnEmptyFiledate(t *testing.T) {
+	diff := UnifiedDiff{
+		A:        splitChars("one"),
+		B:        splitChars("two"),
+		FromFile: "Original",
+		ToFile:   "Current",
+		Eol:      "\n",
+	}
+	ud, err := GetUnifiedDiffString(diff)
+	assertEqual(t, err, nil)
+	assertEqual(t, SplitLines(ud)[:2], []string{"--- Original\n", "+++ Current\n"})
+
+	cd, err := GetContextDiffString(ContextDiff(diff))
+	assertEqual(t, err, nil)
+	assertEqual(t, SplitLines(cd)[:2], []string{"*** Original\n", "--- Current\n"})
+}
+
+func TestOmitFilenames(t *testing.T) {
+	diff := UnifiedDiff{
+		A:   SplitLines("o\nn\ne\n"),
+		B:   SplitLines("t\nw\no\n"),
+		Eol: "\n",
+	}
+	ud, err := GetUnifiedDiffString(diff)
+	assertEqual(t, err, nil)
+	assertEqual(t, SplitLines(ud), []string{
+		"@@ -0,0 +1,2 @@\n",
+		"+t\n",
+		"+w\n",
+		"@@ -2,2 +3,0 @@\n",
+		"-n\n",
+		"-e\n",
+		"\n",
+	})
+
+	cd, err := GetContextDiffString(ContextDiff(diff))
+	assertEqual(t, err, nil)
+	assertEqual(t, SplitLines(cd), []string{
+		"***************\n",
+		"*** 0 ****\n",
+		"--- 1,2 ----\n",
+		"+ t\n",
+		"+ w\n",
+		"***************\n",
+		"*** 2,3 ****\n",
+		"- n\n",
+		"- e\n",
+		"--- 3 ----\n",
+		"\n",
+	})
+}
+
+func TestSplitLines(t *testing.T) {
+	allTests := []struct {
+		input string
+		want  []string
+	}{
+		{"foo", []string{"foo\n"}},
+		{"foo\nbar", []string{"foo\n", "bar\n"}},
+		{"foo\nbar\n", []string{"foo\n", "bar\n", "\n"}},
+	}
+	for _, test := range allTests {
+		assertEqual(t, SplitLines(test.input), test.want)
+	}
+}
+
+func benchmarkSplitLines(b *testing.B, count int) {
+	str := strings.Repeat("foo\n", count)
+
+	b.ResetTimer()
+
+	n := 0
+	for i := 0; i < b.N; i++ {
+		n += len(SplitLines(str))
+	}
+}
+
+func BenchmarkSplitLines100(b *testing.B) {
+	benchmarkSplitLines(b, 100)
+}
+
+func BenchmarkSplitLines10000(b *testing.B) {
+	benchmarkSplitLines(b, 10000)
+}
diff --git a/internal/spew/bypass.go b/internal/spew/bypass.go
new file mode 100644
index 000000000..70ddeaad3
--- /dev/null
+++ b/internal/spew/bypass.go
@@ -0,0 +1,146 @@
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is not running on Google App Engine, compiled by GopherJS, and
+// "-tags safe" is not added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// Go versions prior to 1.4 are disabled because they use a different layout
+// for interfaces which make the implementation of unsafeReflectValue more complex.
+//go:build !js && !appengine && !safe && !disableunsafe && go1.4
+// +build !js,!appengine,!safe,!disableunsafe,go1.4
+
+package spew
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = false
+
+	// ptrSize is the size of a pointer on the current arch.
+	ptrSize = unsafe.Sizeof((*byte)(nil))
+)
+
+type flag uintptr
+
+var (
+	// flagRO indicates whether the value field of a reflect.Value
+	// is read-only.
+	flagRO flag
+
+	// flagAddr indicates whether the address of the reflect.Value's
+	// value may be taken.
+	flagAddr flag
+)
+
+// flagKindMask holds the bits that make up the kind
+// part of the flags field. In all the supported versions,
+// it is in the lower 5 bits.
+const flagKindMask = flag(0x1f)
+
+// Different versions of Go have used different
+// bit layouts for the flags type. This table
+// records the known combinations.
+var okFlags = []struct {
+	ro, addr flag
+}{{
+	// From Go 1.4 to 1.5
+	ro:   1 << 5,
+	addr: 1 << 7,
+}, {
+	// Up to Go tip.
+	ro:   1<<5 | 1<<6,
+	addr: 1 << 8,
+}}
+
+var flagValOffset = func() uintptr {
+	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
+	if !ok {
+		panic("reflect.Value has no flag field")
+	}
+	return field.Offset
+}()
+
+// flagField returns a pointer to the flag field of a reflect.Value.
+func flagField(v *reflect.Value) *flag {
+	return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset))
+}
+
+// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
+// the typical safety restrictions preventing access to unaddressable and
+// unexported data.  It works by digging the raw pointer to the underlying
+// value out of the protected value and generating a new unprotected (unsafe)
+// reflect.Value to it.
+//
+// This allows us to check for implementations of the Stringer and error
+// interfaces to be used for pretty printing ordinarily unaddressable and
+// inaccessible values such as unexported struct fields.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	if !v.IsValid() || (v.CanInterface() && v.CanAddr()) {
+		return v
+	}
+	flagFieldPtr := flagField(&v)
+	*flagFieldPtr &^= flagRO
+	*flagFieldPtr |= flagAddr
+	return v
+}
+
+// Sanity checks against future reflect package changes
+// to the type or semantics of the Value.flag field.
+func init() {
+	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
+	if !ok {
+		panic("reflect.Value has no flag field")
+	}
+	if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() {
+		panic("reflect.Value flag field has changed kind")
+	}
+	type t0 int
+	var t struct {
+		A t0
+		// t0 will have flagEmbedRO set.
+		t0
+		// a will have flagStickyRO set
+		a t0
+	}
+	vA := reflect.ValueOf(t).FieldByName("A")
+	va := reflect.ValueOf(t).FieldByName("a")
+	vt0 := reflect.ValueOf(t).FieldByName("t0")
+
+	// Infer flagRO from the difference between the flags
+	// for the (otherwise identical) fields in t.
+	flagPublic := *flagField(&vA)
+	flagWithRO := *flagField(&va) | *flagField(&vt0)
+	flagRO = flagPublic ^ flagWithRO
+
+	// Infer flagAddr from the difference between a value
+	// taken from a pointer and not.
+	vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A")
+	flagNoPtr := *flagField(&vA)
+	flagPtr := *flagField(&vPtrA)
+	flagAddr = flagNoPtr ^ flagPtr
+
+	// Check that the inferred flags tally with one of the known versions.
+	for _, f := range okFlags {
+		if flagRO == f.ro && flagAddr == f.addr {
+			return
+		}
+	}
+	panic("reflect.Value read-only flag has changed semantics")
+}
diff --git a/internal/spew/bypasssafe.go b/internal/spew/bypasssafe.go
new file mode 100644
index 000000000..5e2d890d6
--- /dev/null
+++ b/internal/spew/bypasssafe.go
@@ -0,0 +1,39 @@
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is running on Google App Engine, compiled by GopherJS, or
+// "-tags safe" is added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+//go:build js || appengine || safe || disableunsafe || !go1.4
+// +build js appengine safe disableunsafe !go1.4
+
+package spew
+
+import "reflect"
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = true
+)
+
+// unsafeReflectValue typically converts the passed reflect.Value into a one
+// that bypasses the typical safety restrictions preventing access to
+// unaddressable and unexported data.  However, doing this relies on access to
+// the unsafe package.  This is a stub version which simply returns the passed
+// reflect.Value when the unsafe package is not available.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	return v
+}
diff --git a/internal/spew/common.go b/internal/spew/common.go
new file mode 100644
index 000000000..1be8ce945
--- /dev/null
+++ b/internal/spew/common.go
@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strconv"
+)
+
+// Some constants in the form of bytes to avoid string overhead.  This mirrors
+// the technique used in the fmt package.
+var (
+	panicBytes            = []byte("(PANIC=")
+	plusBytes             = []byte("+")
+	iBytes                = []byte("i")
+	trueBytes             = []byte("true")
+	falseBytes            = []byte("false")
+	interfaceBytes        = []byte("(interface {})")
+	commaNewlineBytes     = []byte(",\n")
+	newlineBytes          = []byte("\n")
+	openBraceBytes        = []byte("{")
+	openBraceNewlineBytes = []byte("{\n")
+	closeBraceBytes       = []byte("}")
+	asteriskBytes         = []byte("*")
+	colonBytes            = []byte(":")
+	colonSpaceBytes       = []byte(": ")
+	openParenBytes        = []byte("(")
+	closeParenBytes       = []byte(")")
+	spaceBytes            = []byte(" ")
+	pointerChainBytes     = []byte("->")
+	nilAngleBytes         = []byte("<nil>")
+	maxNewlineBytes       = []byte("<max depth reached>\n")
+	maxShortBytes         = []byte("<max>")
+	circularBytes         = []byte("<already shown>")
+	circularShortBytes    = []byte("<shown>")
+	invalidAngleBytes     = []byte("<invalid>")
+	openBracketBytes      = []byte("[")
+	closeBracketBytes     = []byte("]")
+	percentBytes          = []byte("%")
+	precisionBytes        = []byte(".")
+	openAngleBytes        = []byte("<")
+	closeAngleBytes       = []byte(">")
+	openMapBytes          = []byte("map[")
+	closeMapBytes         = []byte("]")
+	lenEqualsBytes        = []byte("len=")
+	capEqualsBytes        = []byte("cap=")
+)
+
+// hexDigits is used to map a decimal value to a hex digit.
+var hexDigits = "0123456789abcdef"
+
+// catchPanic handles any panics that might occur during the handleMethods
+// calls.
+func catchPanic(w io.Writer, v reflect.Value) {
+	if err := recover(); err != nil {
+		w.Write(panicBytes)
+		fmt.Fprintf(w, "%v", err)
+		w.Write(closeParenBytes)
+	}
+}
+
+// handleMethods attempts to call the Error and String methods on the underlying
+// type the passed reflect.Value represents and outputes the result to Writer w.
+//
+// It handles panics in any called methods by catching and displaying the error
+// as the formatted value.
+func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
+	// We need an interface to check if the type implements the error or
+	// Stringer interface.  However, the reflect package won't give us an
+	// interface on certain things like unexported struct fields in order
+	// to enforce visibility rules.  We use unsafe, when it's available,
+	// to bypass these restrictions since this package does not mutate the
+	// values.
+	if !v.CanInterface() {
+		if UnsafeDisabled {
+			return false
+		}
+
+		v = unsafeReflectValue(v)
+	}
+
+	// Choose whether or not to do error and Stringer interface lookups against
+	// the base type or a pointer to the base type depending on settings.
+	// Technically calling one of these methods with a pointer receiver can
+	// mutate the value, however, types which choose to satisify an error or
+	// Stringer interface with a pointer receiver should not be mutating their
+	// state inside these interface methods.
+	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
+		v = unsafeReflectValue(v)
+	}
+	if v.CanAddr() {
+		v = v.Addr()
+	}
+
+	// Is it an error or Stringer?
+	switch iface := v.Interface().(type) {
+	case error:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.Error()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+
+		w.Write([]byte(iface.Error()))
+		return true
+
+	case fmt.Stringer:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.String()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+		w.Write([]byte(iface.String()))
+		return true
+	}
+	return false
+}
+
+// printBool outputs a boolean value as true or false to Writer w.
+func printBool(w io.Writer, val bool) {
+	if val {
+		w.Write(trueBytes)
+	} else {
+		w.Write(falseBytes)
+	}
+}
+
+// printInt outputs a signed integer value to Writer w.
+func printInt(w io.Writer, val int64, base int) {
+	w.Write([]byte(strconv.FormatInt(val, base)))
+}
+
+// printUint outputs an unsigned integer value to Writer w.
+func printUint(w io.Writer, val uint64, base int) {
+	w.Write([]byte(strconv.FormatUint(val, base)))
+}
+
+// printFloat outputs a floating point value using the specified precision,
+// which is expected to be 32 or 64bit, to Writer w.
+func printFloat(w io.Writer, val float64, precision int) {
+	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
+}
+
+// printComplex outputs a complex value using the specified float precision
+// for the real and imaginary parts to Writer w.
+func printComplex(w io.Writer, c complex128, floatPrecision int) {
+	r := real(c)
+	w.Write(openParenBytes)
+	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
+	i := imag(c)
+	if i >= 0 {
+		w.Write(plusBytes)
+	}
+	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
+	w.Write(iBytes)
+	w.Write(closeParenBytes)
+}
+
+// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
+// prefix to Writer w.
+func printHexPtr(w io.Writer, p uintptr) {
+	// Null pointer.
+	num := uint64(p)
+	if num == 0 {
+		w.Write(nilAngleBytes)
+		return
+	}
+
+	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
+	buf := make([]byte, 18)
+
+	// It's simpler to construct the hex string right to left.
+	base := uint64(16)
+	i := len(buf) - 1
+	for num >= base {
+		buf[i] = hexDigits[num%base]
+		num /= base
+		i--
+	}
+	buf[i] = hexDigits[num]
+
+	// Add '0x' prefix.
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+
+	// Strip unused leading bytes.
+	buf = buf[i:]
+	w.Write(buf)
+}
+
+// valuesSorter implements sort.Interface to allow a slice of reflect.Value
+// elements to be sorted.
+type valuesSorter struct {
+	values  []reflect.Value
+	strings []string // either nil or same len and values
+	cs      *ConfigState
+}
+
+// newValuesSorter initializes a valuesSorter instance, which holds a set of
+// surrogate keys on which the data should be sorted.  It uses flags in
+// ConfigState to decide if and how to populate those surrogate keys.
+func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
+	vs := &valuesSorter{values: values, cs: cs}
+	if canSortSimply(vs.values[0].Kind()) {
+		return vs
+	}
+	if !cs.DisableMethods {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			b := bytes.Buffer{}
+			if !handleMethods(cs, &b, vs.values[i]) {
+				vs.strings = nil
+				break
+			}
+			vs.strings[i] = b.String()
+		}
+	}
+	if vs.strings == nil && cs.SpewKeys {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
+		}
+	}
+	return vs
+}
+
+// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
+// directly, or whether it should be considered for sorting by surrogate keys
+// (if the ConfigState allows it).
+func canSortSimply(kind reflect.Kind) bool {
+	// This switch parallels valueSortLess, except for the default case.
+	switch kind {
+	case reflect.Bool:
+		return true
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return true
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return true
+	case reflect.Float32, reflect.Float64:
+		return true
+	case reflect.String:
+		return true
+	case reflect.Uintptr:
+		return true
+	case reflect.Array:
+		return true
+	}
+	return false
+}
+
+// Len returns the number of values in the slice.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Len() int {
+	return len(s.values)
+}
+
+// Swap swaps the values at the passed indices.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Swap(i, j int) {
+	s.values[i], s.values[j] = s.values[j], s.values[i]
+	if s.strings != nil {
+		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
+	}
+}
+
+// valueSortLess returns whether the first value should sort before the second
+// value.  It is used by valueSorter.Less as part of the sort.Interface
+// implementation.
+func valueSortLess(a, b reflect.Value) bool {
+	switch a.Kind() {
+	case reflect.Bool:
+		return !a.Bool() && b.Bool()
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return a.Int() < b.Int()
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return a.Uint() < b.Uint()
+	case reflect.Float32, reflect.Float64:
+		return a.Float() < b.Float()
+	case reflect.String:
+		return a.String() < b.String()
+	case reflect.Uintptr:
+		return a.Uint() < b.Uint()
+	case reflect.Array:
+		// Compare the contents of both arrays.
+		l := a.Len()
+		for i := 0; i < l; i++ {
+			av := a.Index(i)
+			bv := b.Index(i)
+			if av.Interface() == bv.Interface() {
+				continue
+			}
+			return valueSortLess(av, bv)
+		}
+	}
+	return a.String() < b.String()
+}
+
+// Less returns whether the value at index i should sort before the
+// value at index j.  It is part of the sort.Interface implementation.
+func (s *valuesSorter) Less(i, j int) bool {
+	if s.strings == nil {
+		return valueSortLess(s.values[i], s.values[j])
+	}
+	return s.strings[i] < s.strings[j]
+}
+
+// sortValues is a sort function that handles both native types and any type that
+// can be converted to error or Stringer.  Other inputs are sorted according to
+// their Value.String() value to ensure display stability.
+func sortValues(values []reflect.Value, cs *ConfigState) {
+	if len(values) == 0 {
+		return
+	}
+	sort.Sort(newValuesSorter(values, cs))
+}
diff --git a/internal/spew/common_test.go b/internal/spew/common_test.go
new file mode 100644
index 000000000..a312057e1
--- /dev/null
+++ b/internal/spew/common_test.go
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew_test
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/expr-lang/expr/internal/spew"
+)
+
+// custom type to test Stinger interface on non-pointer receiver.
+type stringer string
+
+// String implements the Stringer interface for testing invocation of custom
+// stringers on types with non-pointer receivers.
+func (s stringer) String() string {
+	return "stringer " + string(s)
+}
+
+// custom type to test Stinger interface on pointer receiver.
+type pstringer string
+
+// String implements the Stringer interface for testing invocation of custom
+// stringers on types with only pointer receivers.
+func (s *pstringer) String() string {
+	return "stringer " + string(*s)
+}
+
+// xref1 and xref2 are cross referencing structs for testing circular reference
+// detection.
+type xref1 struct {
+	ps2 *xref2
+}
+type xref2 struct {
+	ps1 *xref1
+}
+
+// indirCir1, indirCir2, and indirCir3 are used to generate an indirect circular
+// reference for testing detection.
+type indirCir1 struct {
+	ps2 *indirCir2
+}
+type indirCir2 struct {
+	ps3 *indirCir3
+}
+type indirCir3 struct {
+	ps1 *indirCir1
+}
+
+// embed is used to test embedded structures.
+type embed struct {
+	a string
+}
+
+// embedwrap is used to test embedded structures.
+type embedwrap struct {
+	*embed
+	e *embed
+}
+
+// panicer is used to intentionally cause a panic for testing spew properly
+// handles them
+type panicer int
+
+func (p panicer) String() string {
+	panic("test panic")
+}
+
+// customError is used to test custom error interface invocation.
+type customError int
+
+func (e customError) Error() string {
+	return fmt.Sprintf("error: %d", int(e))
+}
+
+// stringizeWants converts a slice of wanted test output into a format suitable
+// for a test error message.
+func stringizeWants(wants []string) string {
+	s := ""
+	for i, want := range wants {
+		if i > 0 {
+			s += fmt.Sprintf("want%d: %s", i+1, want)
+		} else {
+			s += "want: " + want
+		}
+	}
+	return s
+}
+
+// testFailed returns whether or not a test failed by checking if the result
+// of the test is in the slice of wanted strings.
+func testFailed(result string, wants []string) bool {
+	for _, want := range wants {
+		if result == want {
+			return false
+		}
+	}
+	return true
+}
+
+type sortableStruct struct {
+	x int
+}
+
+func (ss sortableStruct) String() string {
+	return fmt.Sprintf("ss.%d", ss.x)
+}
+
+type unsortableStruct struct {
+	x int
+}
+
+type sortTestCase struct {
+	input    []reflect.Value
+	expected []reflect.Value
+}
+
+func helpTestSortValues(tests []sortTestCase, cs *spew.ConfigState, t *testing.T) {
+	getInterfaces := func(values []reflect.Value) []interface{} {
+		interfaces := []interface{}{}
+		for _, v := range values {
+			interfaces = append(interfaces, v.Interface())
+		}
+		return interfaces
+	}
+
+	for _, test := range tests {
+		spew.SortValues(test.input, cs)
+		// reflect.DeepEqual cannot really make sense of reflect.Value,
+		// probably because of all the pointer tricks. For instance,
+		// v(2.0) != v(2.0) on a 32-bits system. Turn them into interface{}
+		// instead.
+		input := getInterfaces(test.input)
+		expected := getInterfaces(test.expected)
+		if !reflect.DeepEqual(input, expected) {
+			t.Errorf("Sort mismatch:\n %v != %v", input, expected)
+		}
+	}
+}
+
+// TestSortValues ensures the sort functionality for relect.Value based sorting
+// works as intended.
+func TestSortValues(t *testing.T) {
+	v := reflect.ValueOf
+
+	a := v("a")
+	b := v("b")
+	c := v("c")
+	embedA := v(embed{"a"})
+	embedB := v(embed{"b"})
+	embedC := v(embed{"c"})
+	tests := []sortTestCase{
+		// No values.
+		{
+			[]reflect.Value{},
+			[]reflect.Value{},
+		},
+		// Bools.
+		{
+			[]reflect.Value{v(false), v(true), v(false)},
+			[]reflect.Value{v(false), v(false), v(true)},
+		},
+		// Ints.
+		{
+			[]reflect.Value{v(2), v(1), v(3)},
+			[]reflect.Value{v(1), v(2), v(3)},
+		},
+		// Uints.
+		{
+			[]reflect.Value{v(uint8(2)), v(uint8(1)), v(uint8(3))},
+			[]reflect.Value{v(uint8(1)), v(uint8(2)), v(uint8(3))},
+		},
+		// Floats.
+		{
+			[]reflect.Value{v(2.0), v(1.0), v(3.0)},
+			[]reflect.Value{v(1.0), v(2.0), v(3.0)},
+		},
+		// Strings.
+		{
+			[]reflect.Value{b, a, c},
+			[]reflect.Value{a, b, c},
+		},
+		// Array
+		{
+			[]reflect.Value{v([3]int{3, 2, 1}), v([3]int{1, 3, 2}), v([3]int{1, 2, 3})},
+			[]reflect.Value{v([3]int{1, 2, 3}), v([3]int{1, 3, 2}), v([3]int{3, 2, 1})},
+		},
+		// Uintptrs.
+		{
+			[]reflect.Value{v(uintptr(2)), v(uintptr(1)), v(uintptr(3))},
+			[]reflect.Value{v(uintptr(1)), v(uintptr(2)), v(uintptr(3))},
+		},
+		// SortableStructs.
+		{
+			// Note: not sorted - DisableMethods is set.
+			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
+			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
+		},
+		// UnsortableStructs.
+		{
+			// Note: not sorted - SpewKeys is false.
+			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
+			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
+		},
+		// Invalid.
+		{
+			[]reflect.Value{embedB, embedA, embedC},
+			[]reflect.Value{embedB, embedA, embedC},
+		},
+	}
+	cs := spew.ConfigState{DisableMethods: true, SpewKeys: false}
+	helpTestSortValues(tests, &cs, t)
+}
+
+// TestSortValuesWithMethods ensures the sort functionality for relect.Value
+// based sorting works as intended when using string methods.
+func TestSortValuesWithMethods(t *testing.T) {
+	v := reflect.ValueOf
+
+	a := v("a")
+	b := v("b")
+	c := v("c")
+	tests := []sortTestCase{
+		// Ints.
+		{
+			[]reflect.Value{v(2), v(1), v(3)},
+			[]reflect.Value{v(1), v(2), v(3)},
+		},
+		// Strings.
+		{
+			[]reflect.Value{b, a, c},
+			[]reflect.Value{a, b, c},
+		},
+		// SortableStructs.
+		{
+			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
+			[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
+		},
+		// UnsortableStructs.
+		{
+			// Note: not sorted - SpewKeys is false.
+			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
+			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
+		},
+	}
+	cs := spew.ConfigState{DisableMethods: false, SpewKeys: false}
+	helpTestSortValues(tests, &cs, t)
+}
+
+// TestSortValuesWithSpew ensures the sort functionality for relect.Value
+// based sorting works as intended when using spew to stringify keys.
+func TestSortValuesWithSpew(t *testing.T) {
+	v := reflect.ValueOf
+
+	a := v("a")
+	b := v("b")
+	c := v("c")
+	tests := []sortTestCase{
+		// Ints.
+		{
+			[]reflect.Value{v(2), v(1), v(3)},
+			[]reflect.Value{v(1), v(2), v(3)},
+		},
+		// Strings.
+		{
+			[]reflect.Value{b, a, c},
+			[]reflect.Value{a, b, c},
+		},
+		// SortableStructs.
+		{
+			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
+			[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
+		},
+		// UnsortableStructs.
+		{
+			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
+			[]reflect.Value{v(unsortableStruct{1}), v(unsortableStruct{2}), v(unsortableStruct{3})},
+		},
+	}
+	cs := spew.ConfigState{DisableMethods: true, SpewKeys: true}
+	helpTestSortValues(tests, &cs, t)
+}
diff --git a/internal/spew/config.go b/internal/spew/config.go
new file mode 100644
index 000000000..161895fc6
--- /dev/null
+++ b/internal/spew/config.go
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+)
+
+// ConfigState houses the configuration options used by spew to format and
+// display values.  There is a global instance, Config, that is used to control
+// all top-level Formatter and Dump functionality.  Each ConfigState instance
+// provides methods equivalent to the top-level functions.
+//
+// The zero value for ConfigState provides no indentation.  You would typically
+// want to set it to a space or a tab.
+//
+// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
+// with default settings.  See the documentation of NewDefaultConfig for default
+// values.
+type ConfigState struct {
+	// Indent specifies the string to use for each indentation level.  The
+	// global config instance that all top-level functions use set this to a
+	// single space by default.  If you would like more indentation, you might
+	// set this to a tab with "\t" or perhaps two spaces with "  ".
+	Indent string
+
+	// MaxDepth controls the maximum number of levels to descend into nested
+	// data structures.  The default, 0, means there is no limit.
+	//
+	// NOTE: Circular data structures are properly detected, so it is not
+	// necessary to set this value unless you specifically want to limit deeply
+	// nested data structures.
+	MaxDepth int
+
+	// DisableMethods specifies whether or not error and Stringer interfaces are
+	// invoked for types that implement them.
+	DisableMethods bool
+
+	// DisablePointerMethods specifies whether or not to check for and invoke
+	// error and Stringer interfaces on types which only accept a pointer
+	// receiver when the current type is not a pointer.
+	//
+	// NOTE: This might be an unsafe action since calling one of these methods
+	// with a pointer receiver could technically mutate the value, however,
+	// in practice, types which choose to satisify an error or Stringer
+	// interface with a pointer receiver should not be mutating their state
+	// inside these interface methods.  As a result, this option relies on
+	// access to the unsafe package, so it will not have any effect when
+	// running in environments without access to the unsafe package such as
+	// Google App Engine or with the "safe" build tag specified.
+	DisablePointerMethods bool
+
+	// DisablePointerAddresses specifies whether to disable the printing of
+	// pointer addresses. This is useful when diffing data structures in tests.
+	DisablePointerAddresses bool
+
+	// DisableCapacities specifies whether to disable the printing of capacities
+	// for arrays, slices, maps and channels. This is useful when diffing
+	// data structures in tests.
+	DisableCapacities bool
+
+	// ContinueOnMethod specifies whether or not recursion should continue once
+	// a custom error or Stringer interface is invoked.  The default, false,
+	// means it will print the results of invoking the custom error or Stringer
+	// interface and return immediately instead of continuing to recurse into
+	// the internals of the data type.
+	//
+	// NOTE: This flag does not have any effect if method invocation is disabled
+	// via the DisableMethods or DisablePointerMethods options.
+	ContinueOnMethod bool
+
+	// SortKeys specifies map keys should be sorted before being printed. Use
+	// this to have a more deterministic, diffable output.  Note that only
+	// native types (bool, int, uint, floats, uintptr and string) and types
+	// that support the error or Stringer interfaces (if methods are
+	// enabled) are supported, with other types sorted according to the
+	// reflect.Value.String() output which guarantees display stability.
+	SortKeys bool
+
+	// SpewKeys specifies that, as a last resort attempt, map keys should
+	// be spewed to strings and sorted by those strings.  This is only
+	// considered if SortKeys is true.
+	SpewKeys bool
+}
+
+// Config is the active configuration of the top-level functions.
+// The configuration can be changed by modifying the contents of spew.Config.
+var Config = ConfigState{Indent: " "}
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the formatted string as a value that satisfies error.  See NewFormatter
+// for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, c.convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, c.convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, c.convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a Formatter interface returned by c.NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, c.convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(c.convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, c.convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(c.convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprint(a ...interface{}) string {
+	return fmt.Sprint(c.convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, c.convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a Formatter interface returned by c.NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(c.convertArgs(a)...)
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+c.Printf, c.Println, or c.Printf.
+*/
+func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(c, v)
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
+	fdump(c, w, a...)
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+  - Pointers are dereferenced and followed
+  - Circular data structures are detected and handled properly
+  - Custom Stringer/error interfaces are optionally invoked, including
+    on unexported types
+  - Custom types which only implement the Stringer/error interfaces via
+    a pointer receiver are optionally invoked when passing non-pointer
+    variables
+  - Byte arrays and slices are dumped like the hexdump -C command which
+    includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by modifying the public members
+of c.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func (c *ConfigState) Dump(a ...interface{}) {
+	fdump(c, os.Stdout, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func (c *ConfigState) Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(c, &buf, a...)
+	return buf.String()
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a spew Formatter interface using
+// the ConfigState associated with s.
+func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = newFormatter(c, arg)
+	}
+	return formatters
+}
+
+// NewDefaultConfig returns a ConfigState with the following default settings.
+//
+//	Indent: " "
+//	MaxDepth: 0
+//	DisableMethods: false
+//	DisablePointerMethods: false
+//	ContinueOnMethod: false
+//	SortKeys: false
+func NewDefaultConfig() *ConfigState {
+	return &ConfigState{Indent: " "}
+}
diff --git a/internal/spew/doc.go b/internal/spew/doc.go
new file mode 100644
index 000000000..722e9aa79
--- /dev/null
+++ b/internal/spew/doc.go
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+Package spew implements a deep pretty printer for Go data structures to aid in
+debugging.
+
+A quick overview of the additional features spew provides over the built-in
+printing facilities for Go data types are as follows:
+
+  - Pointers are dereferenced and followed
+  - Circular data structures are detected and handled properly
+  - Custom Stringer/error interfaces are optionally invoked, including
+    on unexported types
+  - Custom types which only implement the Stringer/error interfaces via
+    a pointer receiver are optionally invoked when passing non-pointer
+    variables
+  - Byte arrays and slices are dumped like the hexdump -C command which
+    includes offsets, byte values in hex, and ASCII output (only when using
+    Dump style)
+
+There are two different approaches spew allows for dumping Go data structures:
+
+  - Dump style which prints with newlines, customizable indentation,
+    and additional debug information such as types and all pointer addresses
+    used to indirect to the final value
+  - A custom Formatter interface that integrates cleanly with the standard fmt
+    package and replaces %v, %+v, %#v, and %#+v to provide inline printing
+    similar to the default %v while providing the additional functionality
+    outlined above and passing unsupported format verbs such as %x and %q
+    along to fmt
+
+# Quick Start
+
+This section demonstrates how to quickly get started with spew.  See the
+sections below for further details on formatting and configuration options.
+
+To dump a variable with full newlines, indentation, type, and pointer
+information use Dump, Fdump, or Sdump:
+
+	spew.Dump(myVar1, myVar2, ...)
+	spew.Fdump(someWriter, myVar1, myVar2, ...)
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Alternatively, if you would prefer to use format strings with a compacted inline
+printing style, use the convenience wrappers Printf, Fprintf, etc with
+%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
+%#+v (adds types and pointer addresses):
+
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+# Configuration Options
+
+Configuration of spew is handled by fields in the ConfigState type.  For
+convenience, all of the top-level functions use a global state available
+via the spew.Config global.
+
+It is also possible to create a ConfigState instance that provides methods
+equivalent to the top-level functions.  This allows concurrent configuration
+options.  See the ConfigState documentation for more details.
+
+The following configuration options are available:
+
+  - Indent
+    String to use for each indentation level for Dump functions.
+    It is a single space by default.  A popular alternative is "\t".
+
+  - MaxDepth
+    Maximum number of levels to descend into nested data structures.
+    There is no limit by default.
+
+  - DisableMethods
+    Disables invocation of error and Stringer interface methods.
+    Method invocation is enabled by default.
+
+  - DisablePointerMethods
+    Disables invocation of error and Stringer interface methods on types
+    which only accept pointer receivers from non-pointer variables.
+    Pointer method invocation is enabled by default.
+
+  - DisablePointerAddresses
+    DisablePointerAddresses specifies whether to disable the printing of
+    pointer addresses. This is useful when diffing data structures in tests.
+
+  - DisableCapacities
+    DisableCapacities specifies whether to disable the printing of
+    capacities for arrays, slices, maps and channels. This is useful when
+    diffing data structures in tests.
+
+  - ContinueOnMethod
+    Enables recursion into types after invoking error and Stringer interface
+    methods. Recursion after method invocation is disabled by default.
+
+  - SortKeys
+    Specifies map keys should be sorted before being printed. Use
+    this to have a more deterministic, diffable output.  Note that
+    only native types (bool, int, uint, floats, uintptr and string)
+    and types which implement error or Stringer interfaces are
+    supported with other types sorted according to the
+    reflect.Value.String() output which guarantees display
+    stability.  Natural map order is used by default.
+
+  - SpewKeys
+    Specifies that, as a last resort attempt, map keys should be
+    spewed to strings and sorted by those strings.  This is only
+    considered if SortKeys is true.
+
+# Dump Usage
+
+Simply call spew.Dump with a list of variables you want to dump:
+
+	spew.Dump(myVar1, myVar2, ...)
+
+You may also call spew.Fdump if you would prefer to output to an arbitrary
+io.Writer.  For example, to dump to standard error:
+
+	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
+
+A third option is to call spew.Sdump to get the formatted output as a string:
+
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+# Sample Dump Output
+
+See the Dump example for details on the setup of the types and variables being
+shown here.
+
+	(main.Foo) {
+	 unexportedField: (*main.Bar)(0xf84002e210)({
+	  flag: (main.Flag) flagTwo,
+	  data: (uintptr) <nil>
+	 }),
+	 ExportedField: (map[interface {}]interface {}) (len=1) {
+	  (string) (len=3) "one": (bool) true
+	 }
+	}
+
+Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
+command as shown.
+
+	([]uint8) (len=32 cap=32) {
+	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
+	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
+	 00000020  31 32                                             |12|
+	}
+
+# Custom Formatter
+
+Spew provides a custom formatter that implements the fmt.Formatter interface
+so that it integrates cleanly with standard fmt package printing functions. The
+formatter is useful for inline printing of smaller data types similar to the
+standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+# Custom Formatter Usage
+
+The simplest way to make use of the spew custom formatter is to call one of the
+convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
+functions have syntax you are most likely already familiar with:
+
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Println(myVar, myVar2)
+	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+See the Index for the full list convenience functions.
+
+# Sample Formatter Output
+
+Double pointer to a uint8:
+
+	  %v: <**>5
+	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
+	 %#v: (**uint8)5
+	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
+
+Pointer to circular struct with a uint8 field and a pointer to itself:
+
+	  %v: <*>{1 <*><shown>}
+	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
+	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
+	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
+
+See the Printf example for details on the setup of variables being shown
+here.
+
+# Errors
+
+Since it is possible for custom Stringer/error interfaces to panic, spew
+detects them and handles them internally by printing the panic information
+inline with the output.  Since spew is intended to provide deep pretty printing
+capabilities on structures, it intentionally does not return any errors.
+*/
+package spew
diff --git a/internal/spew/dump.go b/internal/spew/dump.go
new file mode 100644
index 000000000..8323041a4
--- /dev/null
+++ b/internal/spew/dump.go
@@ -0,0 +1,509 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	// uint8Type is a reflect.Type representing a uint8.  It is used to
+	// convert cgo types to uint8 slices for hexdumping.
+	uint8Type = reflect.TypeOf(uint8(0))
+
+	// cCharRE is a regular expression that matches a cgo char.
+	// It is used to detect character arrays to hexdump them.
+	cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`)
+
+	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
+	// char.  It is used to detect unsigned character arrays to hexdump
+	// them.
+	cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`)
+
+	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
+	// It is used to detect uint8_t arrays to hexdump them.
+	cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`)
+)
+
+// dumpState contains information about the state of a dump operation.
+type dumpState struct {
+	w                io.Writer
+	depth            int
+	pointers         map[uintptr]int
+	ignoreNextType   bool
+	ignoreNextIndent bool
+	cs               *ConfigState
+}
+
+// indent performs indentation according to the depth level and cs.Indent
+// option.
+func (d *dumpState) indent() {
+	if d.ignoreNextIndent {
+		d.ignoreNextIndent = false
+		return
+	}
+	d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface && !v.IsNil() {
+		v = v.Elem()
+	}
+	return v
+}
+
+// dumpPtr handles formatting of pointers by indirecting them as necessary.
+func (d *dumpState) dumpPtr(v reflect.Value) {
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range d.pointers {
+		if depth >= d.depth {
+			delete(d.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by dereferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		d.pointers[addr] = d.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type information.
+	d.w.Write(openParenBytes)
+	d.w.Write(bytes.Repeat(asteriskBytes, indirects))
+	d.w.Write([]byte(ve.Type().String()))
+	d.w.Write(closeParenBytes)
+
+	// Display pointer information.
+	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
+		d.w.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				d.w.Write(pointerChainBytes)
+			}
+			printHexPtr(d.w, addr)
+		}
+		d.w.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	d.w.Write(openParenBytes)
+	switch {
+	case nilFound:
+		d.w.Write(nilAngleBytes)
+
+	case cycleFound:
+		d.w.Write(circularBytes)
+
+	default:
+		d.ignoreNextType = true
+		d.dump(ve)
+	}
+	d.w.Write(closeParenBytes)
+}
+
+// dumpSlice handles formatting of arrays and slices.  Byte (uint8 under
+// reflection) arrays and slices are dumped in hexdump -C fashion.
+func (d *dumpState) dumpSlice(v reflect.Value) {
+	// Determine whether this type should be hex dumped or not.  Also,
+	// for types which should be hexdumped, try to use the underlying data
+	// first, then fall back to trying to convert them to a uint8 slice.
+	var buf []uint8
+	doConvert := false
+	doHexDump := false
+	numEntries := v.Len()
+	if numEntries > 0 {
+		vt := v.Index(0).Type()
+		vts := vt.String()
+		switch {
+		// C types that need to be converted.
+		case cCharRE.MatchString(vts):
+			fallthrough
+		case cUnsignedCharRE.MatchString(vts):
+			fallthrough
+		case cUint8tCharRE.MatchString(vts):
+			doConvert = true
+
+		// Try to use existing uint8 slices and fall back to converting
+		// and copying if that fails.
+		case vt.Kind() == reflect.Uint8:
+			// We need an addressable interface to convert the type
+			// to a byte slice.  However, the reflect package won't
+			// give us an interface on certain things like
+			// unexported struct fields in order to enforce
+			// visibility rules.  We use unsafe, when available, to
+			// bypass these restrictions since this package does not
+			// mutate the values.
+			vs := v
+			if !vs.CanInterface() || !vs.CanAddr() {
+				vs = unsafeReflectValue(vs)
+			}
+			if !UnsafeDisabled {
+				vs = vs.Slice(0, numEntries)
+
+				// Use the existing uint8 slice if it can be
+				// type asserted.
+				iface := vs.Interface()
+				if slice, ok := iface.([]uint8); ok {
+					buf = slice
+					doHexDump = true
+					break
+				}
+			}
+
+			// The underlying data needs to be converted if it can't
+			// be type asserted to a uint8 slice.
+			doConvert = true
+		}
+
+		// Copy and convert the underlying type if needed.
+		if doConvert && vt.ConvertibleTo(uint8Type) {
+			// Convert and copy each element into a uint8 byte
+			// slice.
+			buf = make([]uint8, numEntries)
+			for i := 0; i < numEntries; i++ {
+				vv := v.Index(i)
+				buf[i] = uint8(vv.Convert(uint8Type).Uint())
+			}
+			doHexDump = true
+		}
+	}
+
+	// Hexdump the entire slice as needed.
+	if doHexDump {
+		indent := strings.Repeat(d.cs.Indent, d.depth)
+		str := indent + hex.Dump(buf)
+		str = strings.Replace(str, "\n", "\n"+indent, -1)
+		str = strings.TrimRight(str, d.cs.Indent)
+		d.w.Write([]byte(str))
+		return
+	}
+
+	// Recursively call dump for each item.
+	for i := 0; i < numEntries; i++ {
+		d.dump(d.unpackValue(v.Index(i)))
+		if i < (numEntries - 1) {
+			d.w.Write(commaNewlineBytes)
+		} else {
+			d.w.Write(newlineBytes)
+		}
+	}
+}
+
+// dump is the main workhorse for dumping a value.  It uses the passed reflect
+// value to figure out what kind of object we are dealing with and formats it
+// appropriately.  It is a recursive function, however circular data structures
+// are detected and handled properly.
+func (d *dumpState) dump(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		d.w.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		d.indent()
+		d.dumpPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !d.ignoreNextType {
+		d.indent()
+		d.w.Write(openParenBytes)
+		d.w.Write([]byte(v.Type().String()))
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+	d.ignoreNextType = false
+
+	// Display length and capacity if the built-in len and cap functions
+	// work with the value's kind and the len/cap itself is non-zero.
+	valueLen, valueCap := 0, 0
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Chan:
+		valueLen, valueCap = v.Len(), v.Cap()
+	case reflect.Map, reflect.String:
+		valueLen = v.Len()
+	}
+	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
+		d.w.Write(openParenBytes)
+		if valueLen != 0 {
+			d.w.Write(lenEqualsBytes)
+			printInt(d.w, int64(valueLen), 10)
+		}
+		if !d.cs.DisableCapacities && valueCap != 0 {
+			if valueLen != 0 {
+				d.w.Write(spaceBytes)
+			}
+			d.w.Write(capEqualsBytes)
+			printInt(d.w, int64(valueCap), 10)
+		}
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+
+	// Call Stringer/error interfaces if they exist and the handle methods flag
+	// is enabled
+	if !d.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(d.cs, d.w, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(d.w, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(d.w, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(d.w, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(d.w, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(d.w, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(d.w, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(d.w, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			d.dumpSlice(v)
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.String:
+		d.w.Write([]byte(strconv.Quote(v.String())))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			numEntries := v.Len()
+			keys := v.MapKeys()
+			if d.cs.SortKeys {
+				sortValues(keys, d.cs)
+			}
+			for i, key := range keys {
+				d.dump(d.unpackValue(key))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.MapIndex(key)))
+				if i < (numEntries - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Struct:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			vt := v.Type()
+			numFields := v.NumField()
+			for i := 0; i < numFields; i++ {
+				d.indent()
+				vtf := vt.Field(i)
+				d.w.Write([]byte(vtf.Name))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.Field(i)))
+				if i < (numFields - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(d.w, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(d.w, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it in case any new
+	// types are added.
+	default:
+		if v.CanInterface() {
+			fmt.Fprintf(d.w, "%v", v.Interface())
+		} else {
+			fmt.Fprintf(d.w, "%v", v.String())
+		}
+	}
+}
+
+// fdump is a helper function to consolidate the logic from the various public
+// methods which take varying writers and config states.
+func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
+	for _, arg := range a {
+		if arg == nil {
+			w.Write(interfaceBytes)
+			w.Write(spaceBytes)
+			w.Write(nilAngleBytes)
+			w.Write(newlineBytes)
+			continue
+		}
+
+		d := dumpState{w: w, cs: cs}
+		d.pointers = make(map[uintptr]int)
+		d.dump(reflect.ValueOf(arg))
+		d.w.Write(newlineBytes)
+	}
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func Fdump(w io.Writer, a ...interface{}) {
+	fdump(&Config, w, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(&Config, &buf, a...)
+	return buf.String()
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+  - Pointers are dereferenced and followed
+  - Circular data structures are detected and handled properly
+  - Custom Stringer/error interfaces are optionally invoked, including
+    on unexported types
+  - Custom types which only implement the Stringer/error interfaces via
+    a pointer receiver are optionally invoked when passing non-pointer
+    variables
+  - Byte arrays and slices are dumped like the hexdump -C command which
+    includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by an exported package global,
+spew.Config.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func Dump(a ...interface{}) {
+	fdump(&Config, os.Stdout, a...)
+}
diff --git a/internal/spew/dump_test.go b/internal/spew/dump_test.go
new file mode 100644
index 000000000..b7e3b8f64
--- /dev/null
+++ b/internal/spew/dump_test.go
@@ -0,0 +1,1042 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+Test Summary:
+NOTE: For each test, a nil pointer, a single pointer and double pointer to the
+base test element are also tested to ensure proper indirection across all types.
+
+- Max int8, int16, int32, int64, int
+- Max uint8, uint16, uint32, uint64, uint
+- Boolean true and false
+- Standard complex64 and complex128
+- Array containing standard ints
+- Array containing type with custom formatter on pointer receiver only
+- Array containing interfaces
+- Array containing bytes
+- Slice containing standard float32 values
+- Slice containing type with custom formatter on pointer receiver only
+- Slice containing interfaces
+- Slice containing bytes
+- Nil slice
+- Standard string
+- Nil interface
+- Sub-interface
+- Map with string keys and int vals
+- Map with custom formatter type on pointer receiver only keys and vals
+- Map with interface keys and values
+- Map with nil interface value
+- Struct with primitives
+- Struct that contains another struct
+- Struct that contains custom type with Stringer pointer interface via both
+  exported and unexported fields
+- Struct that contains embedded struct and field to same struct
+- Uintptr to 0 (null pointer)
+- Uintptr address of real variable
+- Unsafe.Pointer to 0 (null pointer)
+- Unsafe.Pointer to address of real variable
+- Nil channel
+- Standard int channel
+- Function with no params and no returns
+- Function with param and no returns
+- Function with multiple params and multiple returns
+- Struct that is circular through self referencing
+- Structs that are circular through cross referencing
+- Structs that are indirectly circular
+- Type that panics in its Stringer interface
+*/
+
+package spew_test
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+	"unsafe"
+
+	"github.com/expr-lang/expr/internal/spew"
+)
+
+// dumpTest is used to describe a test to be performed against the Dump method.
+type dumpTest struct {
+	in    interface{}
+	wants []string
+}
+
+// dumpTests houses all of the tests to be performed against the Dump method.
+var dumpTests = make([]dumpTest, 0)
+
+// addDumpTest is a helper method to append the passed input and desired result
+// to dumpTests
+func addDumpTest(in interface{}, wants ...string) {
+	test := dumpTest{in, wants}
+	dumpTests = append(dumpTests, test)
+}
+
+func addIntDumpTests() {
+	// Max int8.
+	v := int8(127)
+	nv := (*int8)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "int8"
+	vs := "127"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Max int16.
+	v2 := int16(32767)
+	nv2 := (*int16)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "int16"
+	v2s := "32767"
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+	addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+
+	// Max int32.
+	v3 := int32(2147483647)
+	nv3 := (*int32)(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "int32"
+	v3s := "2147483647"
+	addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+	addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+	addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+	addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+
+	// Max int64.
+	v4 := int64(9223372036854775807)
+	nv4 := (*int64)(nil)
+	pv4 := &v4
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "int64"
+	v4s := "9223372036854775807"
+	addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+	addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+	addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+	addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+
+	// Max int.
+	v5 := int(2147483647)
+	nv5 := (*int)(nil)
+	pv5 := &v5
+	v5Addr := fmt.Sprintf("%p", pv5)
+	pv5Addr := fmt.Sprintf("%p", &pv5)
+	v5t := "int"
+	v5s := "2147483647"
+	addDumpTest(v5, "("+v5t+") "+v5s+"\n")
+	addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
+	addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
+	addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
+}
+
+func addUintDumpTests() {
+	// Max uint8.
+	v := uint8(255)
+	nv := (*uint8)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "uint8"
+	vs := "255"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Max uint16.
+	v2 := uint16(65535)
+	nv2 := (*uint16)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "uint16"
+	v2s := "65535"
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+	addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+
+	// Max uint32.
+	v3 := uint32(4294967295)
+	nv3 := (*uint32)(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "uint32"
+	v3s := "4294967295"
+	addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+	addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+	addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+	addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+
+	// Max uint64.
+	v4 := uint64(18446744073709551615)
+	nv4 := (*uint64)(nil)
+	pv4 := &v4
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "uint64"
+	v4s := "18446744073709551615"
+	addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+	addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+	addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+	addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+
+	// Max uint.
+	v5 := uint(4294967295)
+	nv5 := (*uint)(nil)
+	pv5 := &v5
+	v5Addr := fmt.Sprintf("%p", pv5)
+	pv5Addr := fmt.Sprintf("%p", &pv5)
+	v5t := "uint"
+	v5s := "4294967295"
+	addDumpTest(v5, "("+v5t+") "+v5s+"\n")
+	addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
+	addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
+	addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
+}
+
+func addBoolDumpTests() {
+	// Boolean true.
+	v := bool(true)
+	nv := (*bool)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "bool"
+	vs := "true"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Boolean false.
+	v2 := bool(false)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "bool"
+	v2s := "false"
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+}
+
+func addFloatDumpTests() {
+	// Standard float32.
+	v := float32(3.1415)
+	nv := (*float32)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "float32"
+	vs := "3.1415"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Standard float64.
+	v2 := float64(3.1415926)
+	nv2 := (*float64)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "float64"
+	v2s := "3.1415926"
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+	addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+}
+
+func addComplexDumpTests() {
+	// Standard complex64.
+	v := complex(float32(6), -2)
+	nv := (*complex64)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "complex64"
+	vs := "(6-2i)"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Standard complex128.
+	v2 := complex(float64(-6), 2)
+	nv2 := (*complex128)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "complex128"
+	v2s := "(-6+2i)"
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+	addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+}
+
+func addArrayDumpTests() {
+	// Array containing standard ints.
+	v := [3]int{1, 2, 3}
+	vLen := fmt.Sprintf("%d", len(v))
+	vCap := fmt.Sprintf("%d", cap(v))
+	nv := (*[3]int)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "int"
+	vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 1,\n (" +
+		vt + ") 2,\n (" + vt + ") 3\n}"
+	addDumpTest(v, "([3]"+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*[3]"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**[3]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*[3]"+vt+")(<nil>)\n")
+
+	// Array containing type with custom formatter on pointer receiver only.
+	v2i0 := pstringer("1")
+	v2i1 := pstringer("2")
+	v2i2 := pstringer("3")
+	v2 := [3]pstringer{v2i0, v2i1, v2i2}
+	v2i0Len := fmt.Sprintf("%d", len(v2i0))
+	v2i1Len := fmt.Sprintf("%d", len(v2i1))
+	v2i2Len := fmt.Sprintf("%d", len(v2i2))
+	v2Len := fmt.Sprintf("%d", len(v2))
+	v2Cap := fmt.Sprintf("%d", cap(v2))
+	nv2 := (*[3]pstringer)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "spew_test.pstringer"
+	v2sp := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t +
+		") (len=" + v2i0Len + ") stringer 1,\n (" + v2t +
+		") (len=" + v2i1Len + ") stringer 2,\n (" + v2t +
+		") (len=" + v2i2Len + ") " + "stringer 3\n}"
+	v2s := v2sp
+	if spew.UnsafeDisabled {
+		v2s = "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t +
+			") (len=" + v2i0Len + ") \"1\",\n (" + v2t + ") (len=" +
+			v2i1Len + ") \"2\",\n (" + v2t + ") (len=" + v2i2Len +
+			") " + "\"3\"\n}"
+	}
+	addDumpTest(v2, "([3]"+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*[3]"+v2t+")("+v2Addr+")("+v2sp+")\n")
+	addDumpTest(&pv2, "(**[3]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2sp+")\n")
+	addDumpTest(nv2, "(*[3]"+v2t+")(<nil>)\n")
+
+	// Array containing interfaces.
+	v3i0 := "one"
+	v3 := [3]interface{}{v3i0, int(2), uint(3)}
+	v3i0Len := fmt.Sprintf("%d", len(v3i0))
+	v3Len := fmt.Sprintf("%d", len(v3))
+	v3Cap := fmt.Sprintf("%d", cap(v3))
+	nv3 := (*[3]interface{})(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "[3]interface {}"
+	v3t2 := "string"
+	v3t3 := "int"
+	v3t4 := "uint"
+	v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
+		"(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
+		v3t4 + ") 3\n}"
+	addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+	addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+	addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+	addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+
+	// Array containing bytes.
+	v4 := [34]byte{
+		0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+		0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+		0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+		0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
+		0x31, 0x32,
+	}
+	v4Len := fmt.Sprintf("%d", len(v4))
+	v4Cap := fmt.Sprintf("%d", cap(v4))
+	nv4 := (*[34]byte)(nil)
+	pv4 := &v4
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "[34]uint8"
+	v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
+		"{\n 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20" +
+		"  |............... |\n" +
+		" 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30" +
+		"  |!\"#$%&'()*+,-./0|\n" +
+		" 00000020  31 32                                           " +
+		"  |12|\n}"
+	addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+	addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+	addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+	addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+}
+
+func addSliceDumpTests() {
+	// Slice containing standard float32 values.
+	v := []float32{3.14, 6.28, 12.56}
+	vLen := fmt.Sprintf("%d", len(v))
+	vCap := fmt.Sprintf("%d", cap(v))
+	nv := (*[]float32)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "float32"
+	vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 3.14,\n (" +
+		vt + ") 6.28,\n (" + vt + ") 12.56\n}"
+	addDumpTest(v, "([]"+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*[]"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**[]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*[]"+vt+")(<nil>)\n")
+
+	// Slice containing type with custom formatter on pointer receiver only.
+	v2i0 := pstringer("1")
+	v2i1 := pstringer("2")
+	v2i2 := pstringer("3")
+	v2 := []pstringer{v2i0, v2i1, v2i2}
+	v2i0Len := fmt.Sprintf("%d", len(v2i0))
+	v2i1Len := fmt.Sprintf("%d", len(v2i1))
+	v2i2Len := fmt.Sprintf("%d", len(v2i2))
+	v2Len := fmt.Sprintf("%d", len(v2))
+	v2Cap := fmt.Sprintf("%d", cap(v2))
+	nv2 := (*[]pstringer)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "spew_test.pstringer"
+	v2s := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t + ") (len=" +
+		v2i0Len + ") stringer 1,\n (" + v2t + ") (len=" + v2i1Len +
+		") stringer 2,\n (" + v2t + ") (len=" + v2i2Len + ") " +
+		"stringer 3\n}"
+	addDumpTest(v2, "([]"+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*[]"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**[]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+	addDumpTest(nv2, "(*[]"+v2t+")(<nil>)\n")
+
+	// Slice containing interfaces.
+	v3i0 := "one"
+	v3 := []interface{}{v3i0, int(2), uint(3), nil}
+	v3i0Len := fmt.Sprintf("%d", len(v3i0))
+	v3Len := fmt.Sprintf("%d", len(v3))
+	v3Cap := fmt.Sprintf("%d", cap(v3))
+	nv3 := (*[]interface{})(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "[]interface {}"
+	v3t2 := "string"
+	v3t3 := "int"
+	v3t4 := "uint"
+	v3t5 := "interface {}"
+	v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
+		"(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
+		v3t4 + ") 3,\n (" + v3t5 + ") <nil>\n}"
+	addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+	addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+	addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+	addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+
+	// Slice containing bytes.
+	v4 := []byte{
+		0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+		0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+		0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+		0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
+		0x31, 0x32,
+	}
+	v4Len := fmt.Sprintf("%d", len(v4))
+	v4Cap := fmt.Sprintf("%d", cap(v4))
+	nv4 := (*[]byte)(nil)
+	pv4 := &v4
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "[]uint8"
+	v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
+		"{\n 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20" +
+		"  |............... |\n" +
+		" 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30" +
+		"  |!\"#$%&'()*+,-./0|\n" +
+		" 00000020  31 32                                           " +
+		"  |12|\n}"
+	addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+	addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+	addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+	addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+
+	// Nil slice.
+	v5 := []int(nil)
+	nv5 := (*[]int)(nil)
+	pv5 := &v5
+	v5Addr := fmt.Sprintf("%p", pv5)
+	pv5Addr := fmt.Sprintf("%p", &pv5)
+	v5t := "[]int"
+	v5s := "<nil>"
+	addDumpTest(v5, "("+v5t+") "+v5s+"\n")
+	addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
+	addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
+	addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
+}
+
+func addStringDumpTests() {
+	// Standard string.
+	v := "test"
+	vLen := fmt.Sprintf("%d", len(v))
+	nv := (*string)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "string"
+	vs := "(len=" + vLen + ") \"test\""
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+}
+
+func addInterfaceDumpTests() {
+	// Nil interface.
+	var v interface{}
+	nv := (*interface{})(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "interface {}"
+	vs := "<nil>"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Sub-interface.
+	v2 := interface{}(uint16(65535))
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "uint16"
+	v2s := "65535"
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+}
+
+func addMapDumpTests() {
+	// Map with string keys and int vals.
+	k := "one"
+	kk := "two"
+	m := map[string]int{k: 1, kk: 2}
+	klen := fmt.Sprintf("%d", len(k)) // not kLen to shut golint up
+	kkLen := fmt.Sprintf("%d", len(kk))
+	mLen := fmt.Sprintf("%d", len(m))
+	nilMap := map[string]int(nil)
+	nm := (*map[string]int)(nil)
+	pm := &m
+	mAddr := fmt.Sprintf("%p", pm)
+	pmAddr := fmt.Sprintf("%p", &pm)
+	mt := "map[string]int"
+	mt1 := "string"
+	mt2 := "int"
+	ms := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + klen + ") " +
+		"\"one\": (" + mt2 + ") 1,\n (" + mt1 + ") (len=" + kkLen +
+		") \"two\": (" + mt2 + ") 2\n}"
+	ms2 := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + kkLen + ") " +
+		"\"two\": (" + mt2 + ") 2,\n (" + mt1 + ") (len=" + klen +
+		") \"one\": (" + mt2 + ") 1\n}"
+	addDumpTest(m, "("+mt+") "+ms+"\n", "("+mt+") "+ms2+"\n")
+	addDumpTest(pm, "(*"+mt+")("+mAddr+")("+ms+")\n",
+		"(*"+mt+")("+mAddr+")("+ms2+")\n")
+	addDumpTest(&pm, "(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms+")\n",
+		"(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms2+")\n")
+	addDumpTest(nm, "(*"+mt+")(<nil>)\n")
+	addDumpTest(nilMap, "("+mt+") <nil>\n")
+
+	// Map with custom formatter type on pointer receiver only keys and vals.
+	k2 := pstringer("one")
+	v2 := pstringer("1")
+	m2 := map[pstringer]pstringer{k2: v2}
+	k2Len := fmt.Sprintf("%d", len(k2))
+	v2Len := fmt.Sprintf("%d", len(v2))
+	m2Len := fmt.Sprintf("%d", len(m2))
+	nilMap2 := map[pstringer]pstringer(nil)
+	nm2 := (*map[pstringer]pstringer)(nil)
+	pm2 := &m2
+	m2Addr := fmt.Sprintf("%p", pm2)
+	pm2Addr := fmt.Sprintf("%p", &pm2)
+	m2t := "map[spew_test.pstringer]spew_test.pstringer"
+	m2t1 := "spew_test.pstringer"
+	m2t2 := "spew_test.pstringer"
+	m2s := "(len=" + m2Len + ") {\n (" + m2t1 + ") (len=" + k2Len + ") " +
+		"stringer one: (" + m2t2 + ") (len=" + v2Len + ") stringer 1\n}"
+	if spew.UnsafeDisabled {
+		m2s = "(len=" + m2Len + ") {\n (" + m2t1 + ") (len=" + k2Len +
+			") " + "\"one\": (" + m2t2 + ") (len=" + v2Len +
+			") \"1\"\n}"
+	}
+	addDumpTest(m2, "("+m2t+") "+m2s+"\n")
+	addDumpTest(pm2, "(*"+m2t+")("+m2Addr+")("+m2s+")\n")
+	addDumpTest(&pm2, "(**"+m2t+")("+pm2Addr+"->"+m2Addr+")("+m2s+")\n")
+	addDumpTest(nm2, "(*"+m2t+")(<nil>)\n")
+	addDumpTest(nilMap2, "("+m2t+") <nil>\n")
+
+	// Map with interface keys and values.
+	k3 := "one"
+	k3Len := fmt.Sprintf("%d", len(k3))
+	m3 := map[interface{}]interface{}{k3: 1}
+	m3Len := fmt.Sprintf("%d", len(m3))
+	nilMap3 := map[interface{}]interface{}(nil)
+	nm3 := (*map[interface{}]interface{})(nil)
+	pm3 := &m3
+	m3Addr := fmt.Sprintf("%p", pm3)
+	pm3Addr := fmt.Sprintf("%p", &pm3)
+	m3t := "map[interface {}]interface {}"
+	m3t1 := "string"
+	m3t2 := "int"
+	m3s := "(len=" + m3Len + ") {\n (" + m3t1 + ") (len=" + k3Len + ") " +
+		"\"one\": (" + m3t2 + ") 1\n}"
+	addDumpTest(m3, "("+m3t+") "+m3s+"\n")
+	addDumpTest(pm3, "(*"+m3t+")("+m3Addr+")("+m3s+")\n")
+	addDumpTest(&pm3, "(**"+m3t+")("+pm3Addr+"->"+m3Addr+")("+m3s+")\n")
+	addDumpTest(nm3, "(*"+m3t+")(<nil>)\n")
+	addDumpTest(nilMap3, "("+m3t+") <nil>\n")
+
+	// Map with nil interface value.
+	k4 := "nil"
+	k4Len := fmt.Sprintf("%d", len(k4))
+	m4 := map[string]interface{}{k4: nil}
+	m4Len := fmt.Sprintf("%d", len(m4))
+	nilMap4 := map[string]interface{}(nil)
+	nm4 := (*map[string]interface{})(nil)
+	pm4 := &m4
+	m4Addr := fmt.Sprintf("%p", pm4)
+	pm4Addr := fmt.Sprintf("%p", &pm4)
+	m4t := "map[string]interface {}"
+	m4t1 := "string"
+	m4t2 := "interface {}"
+	m4s := "(len=" + m4Len + ") {\n (" + m4t1 + ") (len=" + k4Len + ")" +
+		" \"nil\": (" + m4t2 + ") <nil>\n}"
+	addDumpTest(m4, "("+m4t+") "+m4s+"\n")
+	addDumpTest(pm4, "(*"+m4t+")("+m4Addr+")("+m4s+")\n")
+	addDumpTest(&pm4, "(**"+m4t+")("+pm4Addr+"->"+m4Addr+")("+m4s+")\n")
+	addDumpTest(nm4, "(*"+m4t+")(<nil>)\n")
+	addDumpTest(nilMap4, "("+m4t+") <nil>\n")
+}
+
+func addStructDumpTests() {
+	// Struct with primitives.
+	type s1 struct {
+		a int8
+		b uint8
+	}
+	v := s1{127, 255}
+	nv := (*s1)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "spew_test.s1"
+	vt2 := "int8"
+	vt3 := "uint8"
+	vs := "{\n a: (" + vt2 + ") 127,\n b: (" + vt3 + ") 255\n}"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Struct that contains another struct.
+	type s2 struct {
+		s1 s1
+		b  bool
+	}
+	v2 := s2{s1{127, 255}, true}
+	nv2 := (*s2)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "spew_test.s2"
+	v2t2 := "spew_test.s1"
+	v2t3 := "int8"
+	v2t4 := "uint8"
+	v2t5 := "bool"
+	v2s := "{\n s1: (" + v2t2 + ") {\n  a: (" + v2t3 + ") 127,\n  b: (" +
+		v2t4 + ") 255\n },\n b: (" + v2t5 + ") true\n}"
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+	addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+
+	// Struct that contains custom type with Stringer pointer interface via both
+	// exported and unexported fields.
+	type s3 struct {
+		s pstringer
+		S pstringer
+	}
+	v3 := s3{"test", "test2"}
+	nv3 := (*s3)(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "spew_test.s3"
+	v3t2 := "spew_test.pstringer"
+	v3s := "{\n s: (" + v3t2 + ") (len=4) stringer test,\n S: (" + v3t2 +
+		") (len=5) stringer test2\n}"
+	v3sp := v3s
+	if spew.UnsafeDisabled {
+		v3s = "{\n s: (" + v3t2 + ") (len=4) \"test\",\n S: (" +
+			v3t2 + ") (len=5) \"test2\"\n}"
+		v3sp = "{\n s: (" + v3t2 + ") (len=4) \"test\",\n S: (" +
+			v3t2 + ") (len=5) stringer test2\n}"
+	}
+	addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+	addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3sp+")\n")
+	addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3sp+")\n")
+	addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+
+	// Struct that contains embedded struct and field to same struct.
+	e := embed{"embedstr"}
+	eLen := fmt.Sprintf("%d", len("embedstr"))
+	v4 := embedwrap{embed: &e, e: &e}
+	nv4 := (*embedwrap)(nil)
+	pv4 := &v4
+	eAddr := fmt.Sprintf("%p", &e)
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "spew_test.embedwrap"
+	v4t2 := "spew_test.embed"
+	v4t3 := "string"
+	v4s := "{\n embed: (*" + v4t2 + ")(" + eAddr + ")({\n  a: (" + v4t3 +
+		") (len=" + eLen + ") \"embedstr\"\n }),\n e: (*" + v4t2 +
+		")(" + eAddr + ")({\n  a: (" + v4t3 + ") (len=" + eLen + ")" +
+		" \"embedstr\"\n })\n}"
+	addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+	addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+	addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+	addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+}
+
+func addUintptrDumpTests() {
+	// Null pointer.
+	v := uintptr(0)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "uintptr"
+	vs := "<nil>"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+
+	// Address of real variable.
+	i := 1
+	v2 := uintptr(unsafe.Pointer(&i))
+	nv2 := (*uintptr)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "uintptr"
+	v2s := fmt.Sprintf("%p", &i)
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+	addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+}
+
+func addUnsafePointerDumpTests() {
+	// Null pointer.
+	v := unsafe.Pointer(nil)
+	nv := (*unsafe.Pointer)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "unsafe.Pointer"
+	vs := "<nil>"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Address of real variable.
+	i := 1
+	v2 := unsafe.Pointer(&i)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "unsafe.Pointer"
+	v2s := fmt.Sprintf("%p", &i)
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+}
+
+func addChanDumpTests() {
+	// Nil channel.
+	var v chan int
+	pv := &v
+	nv := (*chan int)(nil)
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "chan int"
+	vs := "<nil>"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Real channel.
+	v2 := make(chan int)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "chan int"
+	v2s := fmt.Sprintf("%p", v2)
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+}
+
+func addFuncDumpTests() {
+	// Function with no params and no returns.
+	v := addIntDumpTests
+	nv := (*func())(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "func()"
+	vs := fmt.Sprintf("%p", v)
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+
+	// Function with param and no returns.
+	v2 := TestDump
+	nv2 := (*func(*testing.T))(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "func(*testing.T)"
+	v2s := fmt.Sprintf("%p", v2)
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+	addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+
+	// Function with multiple params and multiple returns.
+	var v3 = func(i int, s string) (b bool, err error) {
+		return true, nil
+	}
+	nv3 := (*func(int, string) (bool, error))(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "func(int, string) (bool, error)"
+	v3s := fmt.Sprintf("%p", v3)
+	addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+	addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+	addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+	addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+}
+
+func addCircularDumpTests() {
+	// Struct that is circular through self referencing.
+	type circular struct {
+		c *circular
+	}
+	v := circular{nil}
+	v.c = &v
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "spew_test.circular"
+	vs := "{\n c: (*" + vt + ")(" + vAddr + ")({\n  c: (*" + vt + ")(" +
+		vAddr + ")(<already shown>)\n })\n}"
+	vs2 := "{\n c: (*" + vt + ")(" + vAddr + ")(<already shown>)\n}"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs2+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs2+")\n")
+
+	// Structs that are circular through cross referencing.
+	v2 := xref1{nil}
+	ts2 := xref2{&v2}
+	v2.ps2 = &ts2
+	pv2 := &v2
+	ts2Addr := fmt.Sprintf("%p", &ts2)
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "spew_test.xref1"
+	v2t2 := "spew_test.xref2"
+	v2s := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n  ps1: (*" + v2t +
+		")(" + v2Addr + ")({\n   ps2: (*" + v2t2 + ")(" + ts2Addr +
+		")(<already shown>)\n  })\n })\n}"
+	v2s2 := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n  ps1: (*" + v2t +
+		")(" + v2Addr + ")(<already shown>)\n })\n}"
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+	addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s2+")\n")
+	addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s2+")\n")
+
+	// Structs that are indirectly circular.
+	v3 := indirCir1{nil}
+	tic2 := indirCir2{nil}
+	tic3 := indirCir3{&v3}
+	tic2.ps3 = &tic3
+	v3.ps2 = &tic2
+	pv3 := &v3
+	tic2Addr := fmt.Sprintf("%p", &tic2)
+	tic3Addr := fmt.Sprintf("%p", &tic3)
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "spew_test.indirCir1"
+	v3t2 := "spew_test.indirCir2"
+	v3t3 := "spew_test.indirCir3"
+	v3s := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n  ps3: (*" + v3t3 +
+		")(" + tic3Addr + ")({\n   ps1: (*" + v3t + ")(" + v3Addr +
+		")({\n    ps2: (*" + v3t2 + ")(" + tic2Addr +
+		")(<already shown>)\n   })\n  })\n })\n}"
+	v3s2 := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n  ps3: (*" + v3t3 +
+		")(" + tic3Addr + ")({\n   ps1: (*" + v3t + ")(" + v3Addr +
+		")(<already shown>)\n  })\n })\n}"
+	addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+	addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s2+")\n")
+	addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s2+")\n")
+}
+
+func addPanicDumpTests() {
+	// Type that panics in its Stringer interface.
+	v := panicer(127)
+	nv := (*panicer)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "spew_test.panicer"
+	vs := "(PANIC=test panic)127"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+}
+
+func addErrorDumpTests() {
+	// Type that has a custom Error interface.
+	v := customError(127)
+	nv := (*customError)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "spew_test.customError"
+	vs := "error: 127"
+	addDumpTest(v, "("+vt+") "+vs+"\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+	addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+}
+
+// TestDump executes all of the tests described by dumpTests.
+func TestDump(t *testing.T) {
+	// Setup tests.
+	addIntDumpTests()
+	addUintDumpTests()
+	addBoolDumpTests()
+	addFloatDumpTests()
+	addComplexDumpTests()
+	addArrayDumpTests()
+	addSliceDumpTests()
+	addStringDumpTests()
+	addInterfaceDumpTests()
+	addMapDumpTests()
+	addStructDumpTests()
+	addUintptrDumpTests()
+	addUnsafePointerDumpTests()
+	addChanDumpTests()
+	addFuncDumpTests()
+	addCircularDumpTests()
+	addPanicDumpTests()
+	addErrorDumpTests()
+	addCgoDumpTests()
+
+	t.Logf("Running %d tests", len(dumpTests))
+	for i, test := range dumpTests {
+		buf := new(bytes.Buffer)
+		spew.Fdump(buf, test.in)
+		s := buf.String()
+		if testFailed(s, test.wants) {
+			t.Errorf("Dump #%d\n got: %s %s", i, s, stringizeWants(test.wants))
+			continue
+		}
+	}
+}
+
+func TestDumpSortedKeys(t *testing.T) {
+	cfg := spew.ConfigState{SortKeys: true}
+	s := cfg.Sdump(map[int]string{1: "1", 3: "3", 2: "2"})
+	expected := "(map[int]string) (len=3) {\n(int) 1: (string) (len=1) " +
+		"\"1\",\n(int) 2: (string) (len=1) \"2\",\n(int) 3: (string) " +
+		"(len=1) \"3\"\n" +
+		"}\n"
+	if s != expected {
+		t.Errorf("Sorted keys mismatch:\n  %v %v", s, expected)
+	}
+
+	s = cfg.Sdump(map[stringer]int{"1": 1, "3": 3, "2": 2})
+	expected = "(map[spew_test.stringer]int) (len=3) {\n" +
+		"(spew_test.stringer) (len=1) stringer 1: (int) 1,\n" +
+		"(spew_test.stringer) (len=1) stringer 2: (int) 2,\n" +
+		"(spew_test.stringer) (len=1) stringer 3: (int) 3\n" +
+		"}\n"
+	if s != expected {
+		t.Errorf("Sorted keys mismatch:\n  %v %v", s, expected)
+	}
+
+	s = cfg.Sdump(map[pstringer]int{pstringer("1"): 1, pstringer("3"): 3, pstringer("2"): 2})
+	expected = "(map[spew_test.pstringer]int) (len=3) {\n" +
+		"(spew_test.pstringer) (len=1) stringer 1: (int) 1,\n" +
+		"(spew_test.pstringer) (len=1) stringer 2: (int) 2,\n" +
+		"(spew_test.pstringer) (len=1) stringer 3: (int) 3\n" +
+		"}\n"
+	if spew.UnsafeDisabled {
+		expected = "(map[spew_test.pstringer]int) (len=3) {\n" +
+			"(spew_test.pstringer) (len=1) \"1\": (int) 1,\n" +
+			"(spew_test.pstringer) (len=1) \"2\": (int) 2,\n" +
+			"(spew_test.pstringer) (len=1) \"3\": (int) 3\n" +
+			"}\n"
+	}
+	if s != expected {
+		t.Errorf("Sorted keys mismatch:\n  %v %v", s, expected)
+	}
+
+	s = cfg.Sdump(map[customError]int{customError(1): 1, customError(3): 3, customError(2): 2})
+	expected = "(map[spew_test.customError]int) (len=3) {\n" +
+		"(spew_test.customError) error: 1: (int) 1,\n" +
+		"(spew_test.customError) error: 2: (int) 2,\n" +
+		"(spew_test.customError) error: 3: (int) 3\n" +
+		"}\n"
+	if s != expected {
+		t.Errorf("Sorted keys mismatch:\n  %v %v", s, expected)
+	}
+
+}
diff --git a/internal/spew/dumpcgo_test.go b/internal/spew/dumpcgo_test.go
new file mode 100644
index 000000000..1bf71fafb
--- /dev/null
+++ b/internal/spew/dumpcgo_test.go
@@ -0,0 +1,102 @@
+// Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when both cgo is supported and "-tags testcgo" is added to the go test
+// command line.  This means the cgo tests are only added (and hence run) when
+// specifially requested.  This configuration is used because spew itself
+// does not require cgo to run even though it does handle certain cgo types
+// specially.  Rather than forcing all clients to require cgo and an external
+// C compiler just to run the tests, this scheme makes them optional.
+//go:build cgo && testcgo
+// +build cgo,testcgo
+
+package spew_test
+
+import (
+	"fmt"
+
+	"github.com/expr-lang/expr/internal/spew/testdata"
+)
+
+func addCgoDumpTests() {
+	// C char pointer.
+	v := testdata.GetCgoCharPointer()
+	nv := testdata.GetCgoNullCharPointer()
+	pv := &v
+	vcAddr := fmt.Sprintf("%p", v)
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "*testdata._Ctype_char"
+	vs := "116"
+	addDumpTest(v, "("+vt+")("+vcAddr+")("+vs+")\n")
+	addDumpTest(pv, "(*"+vt+")("+vAddr+"->"+vcAddr+")("+vs+")\n")
+	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+"->"+vcAddr+")("+vs+")\n")
+	addDumpTest(nv, "("+vt+")(<nil>)\n")
+
+	// C char array.
+	v2, v2l, v2c := testdata.GetCgoCharArray()
+	v2Len := fmt.Sprintf("%d", v2l)
+	v2Cap := fmt.Sprintf("%d", v2c)
+	v2t := "[6]testdata._Ctype_char"
+	v2s := "(len=" + v2Len + " cap=" + v2Cap + ") " +
+		"{\n 00000000  74 65 73 74 32 00                               " +
+		"  |test2.|\n}"
+	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+
+	// C unsigned char array.
+	v3, v3l, v3c := testdata.GetCgoUnsignedCharArray()
+	v3Len := fmt.Sprintf("%d", v3l)
+	v3Cap := fmt.Sprintf("%d", v3c)
+	v3t := "[6]testdata._Ctype_unsignedchar"
+	v3t2 := "[6]testdata._Ctype_uchar"
+	v3s := "(len=" + v3Len + " cap=" + v3Cap + ") " +
+		"{\n 00000000  74 65 73 74 33 00                               " +
+		"  |test3.|\n}"
+	addDumpTest(v3, "("+v3t+") "+v3s+"\n", "("+v3t2+") "+v3s+"\n")
+
+	// C signed char array.
+	v4, v4l, v4c := testdata.GetCgoSignedCharArray()
+	v4Len := fmt.Sprintf("%d", v4l)
+	v4Cap := fmt.Sprintf("%d", v4c)
+	v4t := "[6]testdata._Ctype_schar"
+	v4t2 := "testdata._Ctype_schar"
+	v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
+		"{\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 101,\n (" + v4t2 +
+		") 115,\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 52,\n (" + v4t2 +
+		") 0\n}"
+	addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+
+	// C uint8_t array.
+	v5, v5l, v5c := testdata.GetCgoUint8tArray()
+	v5Len := fmt.Sprintf("%d", v5l)
+	v5Cap := fmt.Sprintf("%d", v5c)
+	v5t := "[6]testdata._Ctype_uint8_t"
+	v5t2 := "[6]testdata._Ctype_uchar"
+	v5s := "(len=" + v5Len + " cap=" + v5Cap + ") " +
+		"{\n 00000000  74 65 73 74 35 00                               " +
+		"  |test5.|\n}"
+	addDumpTest(v5, "("+v5t+") "+v5s+"\n", "("+v5t2+") "+v5s+"\n")
+
+	// C typedefed unsigned char array.
+	v6, v6l, v6c := testdata.GetCgoTypdefedUnsignedCharArray()
+	v6Len := fmt.Sprintf("%d", v6l)
+	v6Cap := fmt.Sprintf("%d", v6c)
+	v6t := "[6]testdata._Ctype_custom_uchar_t"
+	v6t2 := "[6]testdata._Ctype_uchar"
+	v6s := "(len=" + v6Len + " cap=" + v6Cap + ") " +
+		"{\n 00000000  74 65 73 74 36 00                               " +
+		"  |test6.|\n}"
+	addDumpTest(v6, "("+v6t+") "+v6s+"\n", "("+v6t2+") "+v6s+"\n")
+}
diff --git a/internal/spew/dumpnocgo_test.go b/internal/spew/dumpnocgo_test.go
new file mode 100644
index 000000000..9498d98a7
--- /dev/null
+++ b/internal/spew/dumpnocgo_test.go
@@ -0,0 +1,27 @@
+// Copyright (c) 2013 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when either cgo is not supported or "-tags testcgo" is not added to the go
+// test command line.  This file intentionally does not setup any cgo tests in
+// this scenario.
+//go:build !cgo || !testcgo
+// +build !cgo !testcgo
+
+package spew_test
+
+func addCgoDumpTests() {
+	// Don't add any tests for cgo since this file is only compiled when
+	// there should not be any cgo tests.
+}
diff --git a/internal/spew/example_test.go b/internal/spew/example_test.go
new file mode 100644
index 000000000..f5d659b23
--- /dev/null
+++ b/internal/spew/example_test.go
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew_test
+
+import (
+	"fmt"
+
+	"github.com/expr-lang/expr/internal/spew"
+)
+
+type Flag int
+
+const (
+	flagOne Flag = iota
+	flagTwo
+)
+
+var flagStrings = map[Flag]string{
+	flagOne: "flagOne",
+	flagTwo: "flagTwo",
+}
+
+func (f Flag) String() string {
+	if s, ok := flagStrings[f]; ok {
+		return s
+	}
+	return fmt.Sprintf("Unknown flag (%d)", int(f))
+}
+
+type Bar struct {
+	data uintptr
+}
+
+type Foo struct {
+	unexportedField Bar
+	ExportedField   map[interface{}]interface{}
+}
+
+// This example demonstrates how to use Dump to dump variables to stdout.
+func ExampleDump() {
+	// The following package level declarations are assumed for this example:
+	/*
+		type Flag int
+
+		const (
+			flagOne Flag = iota
+			flagTwo
+		)
+
+		var flagStrings = map[Flag]string{
+			flagOne: "flagOne",
+			flagTwo: "flagTwo",
+		}
+
+		func (f Flag) String() string {
+			if s, ok := flagStrings[f]; ok {
+				return s
+			}
+			return fmt.Sprintf("Unknown flag (%d)", int(f))
+		}
+
+		type Bar struct {
+			data uintptr
+		}
+
+		type Foo struct {
+			unexportedField Bar
+			ExportedField   map[interface{}]interface{}
+		}
+	*/
+
+	// Setup some sample data structures for the example.
+	bar := Bar{uintptr(0)}
+	s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
+	f := Flag(5)
+	b := []byte{
+		0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+		0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+		0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+		0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
+		0x31, 0x32,
+	}
+
+	// Dump!
+	spew.Dump(s1, f, b)
+
+	// Output:
+	// (spew_test.Foo) {
+	//  unexportedField: (spew_test.Bar) {
+	//   data: (uintptr) <nil>
+	//  },
+	//  ExportedField: (map[interface {}]interface {}) (len=1) {
+	//   (string) (len=3) "one": (bool) true
+	//  }
+	// }
+	// (spew_test.Flag) Unknown flag (5)
+	// ([]uint8) (len=34 cap=34) {
+	//  00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
+	//  00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
+	//  00000020  31 32                                             |12|
+	// }
+	//
+}
+
+// This example demonstrates how to use Printf to display a variable with a
+// format string and inline formatting.
+func ExamplePrintf() {
+	// Create a double pointer to a uint 8.
+	ui8 := uint8(5)
+	pui8 := &ui8
+	ppui8 := &pui8
+
+	// Create a circular data type.
+	type circular struct {
+		ui8 uint8
+		c   *circular
+	}
+	c := circular{ui8: 1}
+	c.c = &c
+
+	// Print!
+	spew.Printf("ppui8: %v\n", ppui8)
+	spew.Printf("circular: %v\n", c)
+
+	// Output:
+	// ppui8: <**>5
+	// circular: {1 <*>{1 <*><shown>}}
+}
+
+// This example demonstrates how to use a ConfigState.
+func ExampleConfigState() {
+	// Modify the indent level of the ConfigState only.  The global
+	// configuration is not modified.
+	scs := spew.ConfigState{Indent: "\t"}
+
+	// Output using the ConfigState instance.
+	v := map[string]int{"one": 1}
+	scs.Printf("v: %v\n", v)
+	scs.Dump(v)
+
+	// Output:
+	// v: map[one:1]
+	// (map[string]int) (len=1) {
+	// 	(string) (len=3) "one": (int) 1
+	// }
+}
+
+// This example demonstrates how to use ConfigState.Dump to dump variables to
+// stdout
+func ExampleConfigState_Dump() {
+	// See the top-level Dump example for details on the types used in this
+	// example.
+
+	// Create two ConfigState instances with different indentation.
+	scs := spew.ConfigState{Indent: "\t"}
+	scs2 := spew.ConfigState{Indent: " "}
+
+	// Setup some sample data structures for the example.
+	bar := Bar{uintptr(0)}
+	s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
+
+	// Dump using the ConfigState instances.
+	scs.Dump(s1)
+	scs2.Dump(s1)
+
+	// Output:
+	// (spew_test.Foo) {
+	// 	unexportedField: (spew_test.Bar) {
+	// 		data: (uintptr) <nil>
+	// 	},
+	// 	ExportedField: (map[interface {}]interface {}) (len=1) {
+	//		(string) (len=3) "one": (bool) true
+	// 	}
+	// }
+	// (spew_test.Foo) {
+	//  unexportedField: (spew_test.Bar) {
+	//   data: (uintptr) <nil>
+	//  },
+	//  ExportedField: (map[interface {}]interface {}) (len=1) {
+	//   (string) (len=3) "one": (bool) true
+	//  }
+	// }
+	//
+}
+
+// This example demonstrates how to use ConfigState.Printf to display a variable
+// with a format string and inline formatting.
+func ExampleConfigState_Printf() {
+	// See the top-level Dump example for details on the types used in this
+	// example.
+
+	// Create two ConfigState instances and modify the method handling of the
+	// first ConfigState only.
+	scs := spew.NewDefaultConfig()
+	scs2 := spew.NewDefaultConfig()
+	scs.DisableMethods = true
+
+	// Alternatively
+	// scs := spew.ConfigState{Indent: " ", DisableMethods: true}
+	// scs2 := spew.ConfigState{Indent: " "}
+
+	// This is of type Flag which implements a Stringer and has raw value 1.
+	f := flagTwo
+
+	// Dump using the ConfigState instances.
+	scs.Printf("f: %v\n", f)
+	scs2.Printf("f: %v\n", f)
+
+	// Output:
+	// f: 1
+	// f: flagTwo
+}
diff --git a/internal/spew/format.go b/internal/spew/format.go
new file mode 100644
index 000000000..b04edb7d7
--- /dev/null
+++ b/internal/spew/format.go
@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// supportedFlags is a list of all the character flags supported by fmt package.
+const supportedFlags = "0-+# "
+
+// formatState implements the fmt.Formatter interface and contains information
+// about the state of a formatting operation.  The NewFormatter function can
+// be used to get a new Formatter which can be used directly as arguments
+// in standard fmt package printing calls.
+type formatState struct {
+	value          interface{}
+	fs             fmt.State
+	depth          int
+	pointers       map[uintptr]int
+	ignoreNextType bool
+	cs             *ConfigState
+}
+
+// buildDefaultFormat recreates the original format string without precision
+// and width information to pass in to fmt.Sprintf in the case of an
+// unrecognized type.  Unless new types are added to the language, this
+// function won't ever be called.
+func (f *formatState) buildDefaultFormat() (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	buf.WriteRune('v')
+
+	format = buf.String()
+	return format
+}
+
+// constructOrigFormat recreates the original format string including precision
+// and width information to pass along to the standard fmt package.  This allows
+// automatic deferral of all format strings this package doesn't support.
+func (f *formatState) constructOrigFormat(verb rune) (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	if width, ok := f.fs.Width(); ok {
+		buf.WriteString(strconv.Itoa(width))
+	}
+
+	if precision, ok := f.fs.Precision(); ok {
+		buf.Write(precisionBytes)
+		buf.WriteString(strconv.Itoa(precision))
+	}
+
+	buf.WriteRune(verb)
+
+	format = buf.String()
+	return format
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible and
+// ensures that types for values which have been unpacked from an interface
+// are displayed when the show types flag is also set.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface {
+		f.ignoreNextType = false
+		if !v.IsNil() {
+			v = v.Elem()
+		}
+	}
+	return v
+}
+
+// formatPtr handles formatting of pointers by indirecting them as necessary.
+func (f *formatState) formatPtr(v reflect.Value) {
+	// Display nil if top level pointer is nil.
+	showTypes := f.fs.Flag('#')
+	if v.IsNil() && (!showTypes || f.ignoreNextType) {
+		f.fs.Write(nilAngleBytes)
+		return
+	}
+
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range f.pointers {
+		if depth >= f.depth {
+			delete(f.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to possibly show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by derferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		f.pointers[addr] = f.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type or indirection level depending on flags.
+	if showTypes && !f.ignoreNextType {
+		f.fs.Write(openParenBytes)
+		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
+		f.fs.Write([]byte(ve.Type().String()))
+		f.fs.Write(closeParenBytes)
+	} else {
+		if nilFound || cycleFound {
+			indirects += strings.Count(ve.Type().String(), "*")
+		}
+		f.fs.Write(openAngleBytes)
+		f.fs.Write([]byte(strings.Repeat("*", indirects)))
+		f.fs.Write(closeAngleBytes)
+	}
+
+	// Display pointer information depending on flags.
+	if f.fs.Flag('+') && (len(pointerChain) > 0) {
+		f.fs.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				f.fs.Write(pointerChainBytes)
+			}
+			printHexPtr(f.fs, addr)
+		}
+		f.fs.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	switch {
+	case nilFound:
+		f.fs.Write(nilAngleBytes)
+
+	case cycleFound:
+		f.fs.Write(circularShortBytes)
+
+	default:
+		f.ignoreNextType = true
+		f.format(ve)
+	}
+}
+
+// format is the main workhorse for providing the Formatter interface.  It
+// uses the passed reflect value to figure out what kind of object we are
+// dealing with and formats it appropriately.  It is a recursive function,
+// however circular data structures are detected and handled properly.
+func (f *formatState) format(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		f.fs.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		f.formatPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !f.ignoreNextType && f.fs.Flag('#') {
+		f.fs.Write(openParenBytes)
+		f.fs.Write([]byte(v.Type().String()))
+		f.fs.Write(closeParenBytes)
+	}
+	f.ignoreNextType = false
+
+	// Call Stringer/error interfaces if they exist and the handle methods
+	// flag is enabled.
+	if !f.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(f.cs, f.fs, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(f.fs, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(f.fs, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(f.fs, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(f.fs, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(f.fs, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(f.fs, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(f.fs, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		f.fs.Write(openBracketBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			numEntries := v.Len()
+			for i := 0; i < numEntries; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.Index(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBracketBytes)
+
+	case reflect.String:
+		f.fs.Write([]byte(v.String()))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+
+		f.fs.Write(openMapBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			keys := v.MapKeys()
+			if f.cs.SortKeys {
+				sortValues(keys, f.cs)
+			}
+			for i, key := range keys {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(key))
+				f.fs.Write(colonBytes)
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.MapIndex(key)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeMapBytes)
+
+	case reflect.Struct:
+		numFields := v.NumField()
+		f.fs.Write(openBraceBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			vt := v.Type()
+			for i := 0; i < numFields; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				vtf := vt.Field(i)
+				if f.fs.Flag('+') || f.fs.Flag('#') {
+					f.fs.Write([]byte(vtf.Name))
+					f.fs.Write(colonBytes)
+				}
+				f.format(f.unpackValue(v.Field(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(f.fs, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(f.fs, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it if any get added.
+	default:
+		format := f.buildDefaultFormat()
+		if v.CanInterface() {
+			fmt.Fprintf(f.fs, format, v.Interface())
+		} else {
+			fmt.Fprintf(f.fs, format, v.String())
+		}
+	}
+}
+
+// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
+// details.
+func (f *formatState) Format(fs fmt.State, verb rune) {
+	f.fs = fs
+
+	// Use standard formatting for verbs that are not v.
+	if verb != 'v' {
+		format := f.constructOrigFormat(verb)
+		fmt.Fprintf(fs, format, f.value)
+		return
+	}
+
+	if f.value == nil {
+		if fs.Flag('#') {
+			fs.Write(interfaceBytes)
+		}
+		fs.Write(nilAngleBytes)
+		return
+	}
+
+	f.format(reflect.ValueOf(f.value))
+}
+
+// newFormatter is a helper function to consolidate the logic from the various
+// public methods which take varying config states.
+func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
+	fs := &formatState{value: v, cs: cs}
+	fs.pointers = make(map[uintptr]int)
+	return fs
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+Printf, Println, or Fprintf.
+*/
+func NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(&Config, v)
+}
diff --git a/internal/spew/format_test.go b/internal/spew/format_test.go
new file mode 100644
index 000000000..11c9c4cd6
--- /dev/null
+++ b/internal/spew/format_test.go
@@ -0,0 +1,1558 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+Test Summary:
+NOTE: For each test, a nil pointer, a single pointer and double pointer to the
+base test element are also tested to ensure proper indirection across all types.
+
+- Max int8, int16, int32, int64, int
+- Max uint8, uint16, uint32, uint64, uint
+- Boolean true and false
+- Standard complex64 and complex128
+- Array containing standard ints
+- Array containing type with custom formatter on pointer receiver only
+- Array containing interfaces
+- Slice containing standard float32 values
+- Slice containing type with custom formatter on pointer receiver only
+- Slice containing interfaces
+- Nil slice
+- Standard string
+- Nil interface
+- Sub-interface
+- Map with string keys and int vals
+- Map with custom formatter type on pointer receiver only keys and vals
+- Map with interface keys and values
+- Map with nil interface value
+- Struct with primitives
+- Struct that contains another struct
+- Struct that contains custom type with Stringer pointer interface via both
+  exported and unexported fields
+- Struct that contains embedded struct and field to same struct
+- Uintptr to 0 (null pointer)
+- Uintptr address of real variable
+- Unsafe.Pointer to 0 (null pointer)
+- Unsafe.Pointer to address of real variable
+- Nil channel
+- Standard int channel
+- Function with no params and no returns
+- Function with param and no returns
+- Function with multiple params and multiple returns
+- Struct that is circular through self referencing
+- Structs that are circular through cross referencing
+- Structs that are indirectly circular
+- Type that panics in its Stringer interface
+- Type that has a custom Error interface
+- %x passthrough with uint
+- %#x passthrough with uint
+- %f passthrough with precision
+- %f passthrough with width and precision
+- %d passthrough with width
+- %q passthrough with string
+*/
+
+package spew_test
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+	"unsafe"
+
+	"github.com/expr-lang/expr/internal/spew"
+)
+
+// formatterTest is used to describe a test to be performed against NewFormatter.
+type formatterTest struct {
+	format string
+	in     interface{}
+	wants  []string
+}
+
+// formatterTests houses all of the tests to be performed against NewFormatter.
+var formatterTests = make([]formatterTest, 0)
+
+// addFormatterTest is a helper method to append the passed input and desired
+// result to formatterTests.
+func addFormatterTest(format string, in interface{}, wants ...string) {
+	test := formatterTest{format, in, wants}
+	formatterTests = append(formatterTests, test)
+}
+
+func addIntFormatterTests() {
+	// Max int8.
+	v := int8(127)
+	nv := (*int8)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "int8"
+	vs := "127"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Max int16.
+	v2 := int16(32767)
+	nv2 := (*int16)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "int16"
+	v2s := "32767"
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%v", nv2, "<nil>")
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+
+	// Max int32.
+	v3 := int32(2147483647)
+	nv3 := (*int32)(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "int32"
+	v3s := "2147483647"
+	addFormatterTest("%v", v3, v3s)
+	addFormatterTest("%v", pv3, "<*>"+v3s)
+	addFormatterTest("%v", &pv3, "<**>"+v3s)
+	addFormatterTest("%v", nv3, "<nil>")
+	addFormatterTest("%+v", v3, v3s)
+	addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+	addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
+	addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
+	addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
+	addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+	addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
+	addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
+	addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
+	addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+
+	// Max int64.
+	v4 := int64(9223372036854775807)
+	nv4 := (*int64)(nil)
+	pv4 := &v4
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "int64"
+	v4s := "9223372036854775807"
+	addFormatterTest("%v", v4, v4s)
+	addFormatterTest("%v", pv4, "<*>"+v4s)
+	addFormatterTest("%v", &pv4, "<**>"+v4s)
+	addFormatterTest("%v", nv4, "<nil>")
+	addFormatterTest("%+v", v4, v4s)
+	addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
+	addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
+	addFormatterTest("%+v", nv4, "<nil>")
+	addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
+	addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
+	addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
+	addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+	addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
+	addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
+	addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
+	addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+
+	// Max int.
+	v5 := int(2147483647)
+	nv5 := (*int)(nil)
+	pv5 := &v5
+	v5Addr := fmt.Sprintf("%p", pv5)
+	pv5Addr := fmt.Sprintf("%p", &pv5)
+	v5t := "int"
+	v5s := "2147483647"
+	addFormatterTest("%v", v5, v5s)
+	addFormatterTest("%v", pv5, "<*>"+v5s)
+	addFormatterTest("%v", &pv5, "<**>"+v5s)
+	addFormatterTest("%v", nv5, "<nil>")
+	addFormatterTest("%+v", v5, v5s)
+	addFormatterTest("%+v", pv5, "<*>("+v5Addr+")"+v5s)
+	addFormatterTest("%+v", &pv5, "<**>("+pv5Addr+"->"+v5Addr+")"+v5s)
+	addFormatterTest("%+v", nv5, "<nil>")
+	addFormatterTest("%#v", v5, "("+v5t+")"+v5s)
+	addFormatterTest("%#v", pv5, "(*"+v5t+")"+v5s)
+	addFormatterTest("%#v", &pv5, "(**"+v5t+")"+v5s)
+	addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
+	addFormatterTest("%#+v", v5, "("+v5t+")"+v5s)
+	addFormatterTest("%#+v", pv5, "(*"+v5t+")("+v5Addr+")"+v5s)
+	addFormatterTest("%#+v", &pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")"+v5s)
+	addFormatterTest("%#+v", nv5, "(*"+v5t+")"+"<nil>")
+}
+
+func addUintFormatterTests() {
+	// Max uint8.
+	v := uint8(255)
+	nv := (*uint8)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "uint8"
+	vs := "255"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Max uint16.
+	v2 := uint16(65535)
+	nv2 := (*uint16)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "uint16"
+	v2s := "65535"
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%v", nv2, "<nil>")
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+
+	// Max uint32.
+	v3 := uint32(4294967295)
+	nv3 := (*uint32)(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "uint32"
+	v3s := "4294967295"
+	addFormatterTest("%v", v3, v3s)
+	addFormatterTest("%v", pv3, "<*>"+v3s)
+	addFormatterTest("%v", &pv3, "<**>"+v3s)
+	addFormatterTest("%v", nv3, "<nil>")
+	addFormatterTest("%+v", v3, v3s)
+	addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+	addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
+	addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
+	addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
+	addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+	addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
+	addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
+	addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
+	addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+
+	// Max uint64.
+	v4 := uint64(18446744073709551615)
+	nv4 := (*uint64)(nil)
+	pv4 := &v4
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "uint64"
+	v4s := "18446744073709551615"
+	addFormatterTest("%v", v4, v4s)
+	addFormatterTest("%v", pv4, "<*>"+v4s)
+	addFormatterTest("%v", &pv4, "<**>"+v4s)
+	addFormatterTest("%v", nv4, "<nil>")
+	addFormatterTest("%+v", v4, v4s)
+	addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
+	addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
+	addFormatterTest("%+v", nv4, "<nil>")
+	addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
+	addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
+	addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
+	addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+	addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
+	addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
+	addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
+	addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+
+	// Max uint.
+	v5 := uint(4294967295)
+	nv5 := (*uint)(nil)
+	pv5 := &v5
+	v5Addr := fmt.Sprintf("%p", pv5)
+	pv5Addr := fmt.Sprintf("%p", &pv5)
+	v5t := "uint"
+	v5s := "4294967295"
+	addFormatterTest("%v", v5, v5s)
+	addFormatterTest("%v", pv5, "<*>"+v5s)
+	addFormatterTest("%v", &pv5, "<**>"+v5s)
+	addFormatterTest("%v", nv5, "<nil>")
+	addFormatterTest("%+v", v5, v5s)
+	addFormatterTest("%+v", pv5, "<*>("+v5Addr+")"+v5s)
+	addFormatterTest("%+v", &pv5, "<**>("+pv5Addr+"->"+v5Addr+")"+v5s)
+	addFormatterTest("%+v", nv5, "<nil>")
+	addFormatterTest("%#v", v5, "("+v5t+")"+v5s)
+	addFormatterTest("%#v", pv5, "(*"+v5t+")"+v5s)
+	addFormatterTest("%#v", &pv5, "(**"+v5t+")"+v5s)
+	addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
+	addFormatterTest("%#+v", v5, "("+v5t+")"+v5s)
+	addFormatterTest("%#+v", pv5, "(*"+v5t+")("+v5Addr+")"+v5s)
+	addFormatterTest("%#+v", &pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")"+v5s)
+	addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
+}
+
+func addBoolFormatterTests() {
+	// Boolean true.
+	v := bool(true)
+	nv := (*bool)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "bool"
+	vs := "true"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Boolean false.
+	v2 := bool(false)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "bool"
+	v2s := "false"
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+}
+
+func addFloatFormatterTests() {
+	// Standard float32.
+	v := float32(3.1415)
+	nv := (*float32)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "float32"
+	vs := "3.1415"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Standard float64.
+	v2 := float64(3.1415926)
+	nv2 := (*float64)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "float64"
+	v2s := "3.1415926"
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+}
+
+func addComplexFormatterTests() {
+	// Standard complex64.
+	v := complex(float32(6), -2)
+	nv := (*complex64)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "complex64"
+	vs := "(6-2i)"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Standard complex128.
+	v2 := complex(float64(-6), 2)
+	nv2 := (*complex128)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "complex128"
+	v2s := "(-6+2i)"
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+}
+
+func addArrayFormatterTests() {
+	// Array containing standard ints.
+	v := [3]int{1, 2, 3}
+	nv := (*[3]int)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "[3]int"
+	vs := "[1 2 3]"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Array containing type with custom formatter on pointer receiver only.
+	v2 := [3]pstringer{"1", "2", "3"}
+	nv2 := (*[3]pstringer)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "[3]spew_test.pstringer"
+	v2sp := "[stringer 1 stringer 2 stringer 3]"
+	v2s := v2sp
+	if spew.UnsafeDisabled {
+		v2s = "[1 2 3]"
+	}
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2sp)
+	addFormatterTest("%v", &pv2, "<**>"+v2sp)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2sp)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2sp)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2sp)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2sp)
+	addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2sp)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2sp)
+	addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+
+	// Array containing interfaces.
+	v3 := [3]interface{}{"one", int(2), uint(3)}
+	nv3 := (*[3]interface{})(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "[3]interface {}"
+	v3t2 := "string"
+	v3t3 := "int"
+	v3t4 := "uint"
+	v3s := "[one 2 3]"
+	v3s2 := "[(" + v3t2 + ")one (" + v3t3 + ")2 (" + v3t4 + ")3]"
+	addFormatterTest("%v", v3, v3s)
+	addFormatterTest("%v", pv3, "<*>"+v3s)
+	addFormatterTest("%v", &pv3, "<**>"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%+v", v3, v3s)
+	addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+	addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
+	addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
+	addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
+	addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+	addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
+	addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
+	addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
+	addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+}
+
+func addSliceFormatterTests() {
+	// Slice containing standard float32 values.
+	v := []float32{3.14, 6.28, 12.56}
+	nv := (*[]float32)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "[]float32"
+	vs := "[3.14 6.28 12.56]"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Slice containing type with custom formatter on pointer receiver only.
+	v2 := []pstringer{"1", "2", "3"}
+	nv2 := (*[]pstringer)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "[]spew_test.pstringer"
+	v2s := "[stringer 1 stringer 2 stringer 3]"
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+
+	// Slice containing interfaces.
+	v3 := []interface{}{"one", int(2), uint(3), nil}
+	nv3 := (*[]interface{})(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "[]interface {}"
+	v3t2 := "string"
+	v3t3 := "int"
+	v3t4 := "uint"
+	v3t5 := "interface {}"
+	v3s := "[one 2 3 <nil>]"
+	v3s2 := "[(" + v3t2 + ")one (" + v3t3 + ")2 (" + v3t4 + ")3 (" + v3t5 +
+		")<nil>]"
+	addFormatterTest("%v", v3, v3s)
+	addFormatterTest("%v", pv3, "<*>"+v3s)
+	addFormatterTest("%v", &pv3, "<**>"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%+v", v3, v3s)
+	addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+	addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
+	addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
+	addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
+	addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+	addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
+	addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
+	addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
+	addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+
+	// Nil slice.
+	var v4 []int
+	nv4 := (*[]int)(nil)
+	pv4 := &v4
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "[]int"
+	v4s := "<nil>"
+	addFormatterTest("%v", v4, v4s)
+	addFormatterTest("%v", pv4, "<*>"+v4s)
+	addFormatterTest("%v", &pv4, "<**>"+v4s)
+	addFormatterTest("%+v", nv4, "<nil>")
+	addFormatterTest("%+v", v4, v4s)
+	addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
+	addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
+	addFormatterTest("%+v", nv4, "<nil>")
+	addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
+	addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
+	addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
+	addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+	addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
+	addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
+	addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
+	addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+}
+
+func addStringFormatterTests() {
+	// Standard string.
+	v := "test"
+	nv := (*string)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "string"
+	vs := "test"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+}
+
+func addInterfaceFormatterTests() {
+	// Nil interface.
+	var v interface{}
+	nv := (*interface{})(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "interface {}"
+	vs := "<nil>"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Sub-interface.
+	v2 := interface{}(uint16(65535))
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "uint16"
+	v2s := "65535"
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+}
+
+func addMapFormatterTests() {
+	// Map with string keys and int vals.
+	v := map[string]int{"one": 1, "two": 2}
+	nilMap := map[string]int(nil)
+	nv := (*map[string]int)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "map[string]int"
+	vs := "map[one:1 two:2]"
+	vs2 := "map[two:2 one:1]"
+	addFormatterTest("%v", v, vs, vs2)
+	addFormatterTest("%v", pv, "<*>"+vs, "<*>"+vs2)
+	addFormatterTest("%v", &pv, "<**>"+vs, "<**>"+vs2)
+	addFormatterTest("%+v", nilMap, "<nil>")
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs, vs2)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs, "<*>("+vAddr+")"+vs2)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs,
+		"<**>("+pvAddr+"->"+vAddr+")"+vs2)
+	addFormatterTest("%+v", nilMap, "<nil>")
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs, "("+vt+")"+vs2)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs, "(*"+vt+")"+vs2)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs, "(**"+vt+")"+vs2)
+	addFormatterTest("%#v", nilMap, "("+vt+")"+"<nil>")
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs, "("+vt+")"+vs2)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs,
+		"(*"+vt+")("+vAddr+")"+vs2)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs,
+		"(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs2)
+	addFormatterTest("%#+v", nilMap, "("+vt+")"+"<nil>")
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Map with custom formatter type on pointer receiver only keys and vals.
+	v2 := map[pstringer]pstringer{"one": "1"}
+	nv2 := (*map[pstringer]pstringer)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "map[spew_test.pstringer]spew_test.pstringer"
+	v2s := "map[stringer one:stringer 1]"
+	if spew.UnsafeDisabled {
+		v2s = "map[one:1]"
+	}
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+
+	// Map with interface keys and values.
+	v3 := map[interface{}]interface{}{"one": 1}
+	nv3 := (*map[interface{}]interface{})(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "map[interface {}]interface {}"
+	v3t1 := "string"
+	v3t2 := "int"
+	v3s := "map[one:1]"
+	v3s2 := "map[(" + v3t1 + ")one:(" + v3t2 + ")1]"
+	addFormatterTest("%v", v3, v3s)
+	addFormatterTest("%v", pv3, "<*>"+v3s)
+	addFormatterTest("%v", &pv3, "<**>"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%+v", v3, v3s)
+	addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+	addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
+	addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
+	addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
+	addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+	addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
+	addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
+	addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
+	addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+
+	// Map with nil interface value
+	v4 := map[string]interface{}{"nil": nil}
+	nv4 := (*map[string]interface{})(nil)
+	pv4 := &v4
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "map[string]interface {}"
+	v4t1 := "interface {}"
+	v4s := "map[nil:<nil>]"
+	v4s2 := "map[nil:(" + v4t1 + ")<nil>]"
+	addFormatterTest("%v", v4, v4s)
+	addFormatterTest("%v", pv4, "<*>"+v4s)
+	addFormatterTest("%v", &pv4, "<**>"+v4s)
+	addFormatterTest("%+v", nv4, "<nil>")
+	addFormatterTest("%+v", v4, v4s)
+	addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
+	addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
+	addFormatterTest("%+v", nv4, "<nil>")
+	addFormatterTest("%#v", v4, "("+v4t+")"+v4s2)
+	addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s2)
+	addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s2)
+	addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+	addFormatterTest("%#+v", v4, "("+v4t+")"+v4s2)
+	addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s2)
+	addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s2)
+	addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+}
+
+func addStructFormatterTests() {
+	// Struct with primitives.
+	type s1 struct {
+		a int8
+		b uint8
+	}
+	v := s1{127, 255}
+	nv := (*s1)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "spew_test.s1"
+	vt2 := "int8"
+	vt3 := "uint8"
+	vs := "{127 255}"
+	vs2 := "{a:127 b:255}"
+	vs3 := "{a:(" + vt2 + ")127 b:(" + vt3 + ")255}"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs2)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs2)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs2)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs3)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs3)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs3)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs3)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs3)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs3)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Struct that contains another struct.
+	type s2 struct {
+		s1 s1
+		b  bool
+	}
+	v2 := s2{s1{127, 255}, true}
+	nv2 := (*s2)(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "spew_test.s2"
+	v2t2 := "spew_test.s1"
+	v2t3 := "int8"
+	v2t4 := "uint8"
+	v2t5 := "bool"
+	v2s := "{{127 255} true}"
+	v2s2 := "{s1:{a:127 b:255} b:true}"
+	v2s3 := "{s1:(" + v2t2 + "){a:(" + v2t3 + ")127 b:(" + v2t4 + ")255} b:(" +
+		v2t5 + ")true}"
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%+v", v2, v2s2)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s2)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s2)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s3)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s3)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s3)
+	addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s3)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s3)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s3)
+	addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+
+	// Struct that contains custom type with Stringer pointer interface via both
+	// exported and unexported fields.
+	type s3 struct {
+		s pstringer
+		S pstringer
+	}
+	v3 := s3{"test", "test2"}
+	nv3 := (*s3)(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "spew_test.s3"
+	v3t2 := "spew_test.pstringer"
+	v3s := "{stringer test stringer test2}"
+	v3sp := v3s
+	v3s2 := "{s:stringer test S:stringer test2}"
+	v3s2p := v3s2
+	v3s3 := "{s:(" + v3t2 + ")stringer test S:(" + v3t2 + ")stringer test2}"
+	v3s3p := v3s3
+	if spew.UnsafeDisabled {
+		v3s = "{test test2}"
+		v3sp = "{test stringer test2}"
+		v3s2 = "{s:test S:test2}"
+		v3s2p = "{s:test S:stringer test2}"
+		v3s3 = "{s:(" + v3t2 + ")test S:(" + v3t2 + ")test2}"
+		v3s3p = "{s:(" + v3t2 + ")test S:(" + v3t2 + ")stringer test2}"
+	}
+	addFormatterTest("%v", v3, v3s)
+	addFormatterTest("%v", pv3, "<*>"+v3sp)
+	addFormatterTest("%v", &pv3, "<**>"+v3sp)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%+v", v3, v3s2)
+	addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s2p)
+	addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s2p)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%#v", v3, "("+v3t+")"+v3s3)
+	addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s3p)
+	addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s3p)
+	addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+	addFormatterTest("%#+v", v3, "("+v3t+")"+v3s3)
+	addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s3p)
+	addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s3p)
+	addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+
+	// Struct that contains embedded struct and field to same struct.
+	e := embed{"embedstr"}
+	v4 := embedwrap{embed: &e, e: &e}
+	nv4 := (*embedwrap)(nil)
+	pv4 := &v4
+	eAddr := fmt.Sprintf("%p", &e)
+	v4Addr := fmt.Sprintf("%p", pv4)
+	pv4Addr := fmt.Sprintf("%p", &pv4)
+	v4t := "spew_test.embedwrap"
+	v4t2 := "spew_test.embed"
+	v4t3 := "string"
+	v4s := "{<*>{embedstr} <*>{embedstr}}"
+	v4s2 := "{embed:<*>(" + eAddr + "){a:embedstr} e:<*>(" + eAddr +
+		"){a:embedstr}}"
+	v4s3 := "{embed:(*" + v4t2 + "){a:(" + v4t3 + ")embedstr} e:(*" + v4t2 +
+		"){a:(" + v4t3 + ")embedstr}}"
+	v4s4 := "{embed:(*" + v4t2 + ")(" + eAddr + "){a:(" + v4t3 +
+		")embedstr} e:(*" + v4t2 + ")(" + eAddr + "){a:(" + v4t3 + ")embedstr}}"
+	addFormatterTest("%v", v4, v4s)
+	addFormatterTest("%v", pv4, "<*>"+v4s)
+	addFormatterTest("%v", &pv4, "<**>"+v4s)
+	addFormatterTest("%+v", nv4, "<nil>")
+	addFormatterTest("%+v", v4, v4s2)
+	addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s2)
+	addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s2)
+	addFormatterTest("%+v", nv4, "<nil>")
+	addFormatterTest("%#v", v4, "("+v4t+")"+v4s3)
+	addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s3)
+	addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s3)
+	addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+	addFormatterTest("%#+v", v4, "("+v4t+")"+v4s4)
+	addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s4)
+	addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s4)
+	addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+}
+
+func addUintptrFormatterTests() {
+	// Null pointer.
+	v := uintptr(0)
+	nv := (*uintptr)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "uintptr"
+	vs := "<nil>"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Address of real variable.
+	i := 1
+	v2 := uintptr(unsafe.Pointer(&i))
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "uintptr"
+	v2s := fmt.Sprintf("%p", &i)
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+}
+
+func addUnsafePointerFormatterTests() {
+	// Null pointer.
+	v := unsafe.Pointer(nil)
+	nv := (*unsafe.Pointer)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "unsafe.Pointer"
+	vs := "<nil>"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Address of real variable.
+	i := 1
+	v2 := unsafe.Pointer(&i)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "unsafe.Pointer"
+	v2s := fmt.Sprintf("%p", &i)
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+}
+
+func addChanFormatterTests() {
+	// Nil channel.
+	var v chan int
+	pv := &v
+	nv := (*chan int)(nil)
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "chan int"
+	vs := "<nil>"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Real channel.
+	v2 := make(chan int)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "chan int"
+	v2s := fmt.Sprintf("%p", v2)
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+}
+
+func addFuncFormatterTests() {
+	// Function with no params and no returns.
+	v := addIntFormatterTests
+	nv := (*func())(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "func()"
+	vs := fmt.Sprintf("%p", v)
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+
+	// Function with param and no returns.
+	v2 := TestFormatter
+	nv2 := (*func(*testing.T))(nil)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "func(*testing.T)"
+	v2s := fmt.Sprintf("%p", v2)
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s)
+	addFormatterTest("%v", &pv2, "<**>"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%+v", v2, v2s)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%+v", nv2, "<nil>")
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+	addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+	addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+
+	// Function with multiple params and multiple returns.
+	var v3 = func(i int, s string) (b bool, err error) {
+		return true, nil
+	}
+	nv3 := (*func(int, string) (bool, error))(nil)
+	pv3 := &v3
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "func(int, string) (bool, error)"
+	v3s := fmt.Sprintf("%p", v3)
+	addFormatterTest("%v", v3, v3s)
+	addFormatterTest("%v", pv3, "<*>"+v3s)
+	addFormatterTest("%v", &pv3, "<**>"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%+v", v3, v3s)
+	addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+	addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+	addFormatterTest("%+v", nv3, "<nil>")
+	addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
+	addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
+	addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
+	addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+	addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
+	addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
+	addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
+	addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+}
+
+func addCircularFormatterTests() {
+	// Struct that is circular through self referencing.
+	type circular struct {
+		c *circular
+	}
+	v := circular{nil}
+	v.c = &v
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "spew_test.circular"
+	vs := "{<*>{<*><shown>}}"
+	vs2 := "{<*><shown>}"
+	vs3 := "{c:<*>(" + vAddr + "){c:<*>(" + vAddr + ")<shown>}}"
+	vs4 := "{c:<*>(" + vAddr + ")<shown>}"
+	vs5 := "{c:(*" + vt + "){c:(*" + vt + ")<shown>}}"
+	vs6 := "{c:(*" + vt + ")<shown>}"
+	vs7 := "{c:(*" + vt + ")(" + vAddr + "){c:(*" + vt + ")(" + vAddr +
+		")<shown>}}"
+	vs8 := "{c:(*" + vt + ")(" + vAddr + ")<shown>}"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs2)
+	addFormatterTest("%v", &pv, "<**>"+vs2)
+	addFormatterTest("%+v", v, vs3)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs4)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs4)
+	addFormatterTest("%#v", v, "("+vt+")"+vs5)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs6)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs6)
+	addFormatterTest("%#+v", v, "("+vt+")"+vs7)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs8)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs8)
+
+	// Structs that are circular through cross referencing.
+	v2 := xref1{nil}
+	ts2 := xref2{&v2}
+	v2.ps2 = &ts2
+	pv2 := &v2
+	ts2Addr := fmt.Sprintf("%p", &ts2)
+	v2Addr := fmt.Sprintf("%p", pv2)
+	pv2Addr := fmt.Sprintf("%p", &pv2)
+	v2t := "spew_test.xref1"
+	v2t2 := "spew_test.xref2"
+	v2s := "{<*>{<*>{<*><shown>}}}"
+	v2s2 := "{<*>{<*><shown>}}"
+	v2s3 := "{ps2:<*>(" + ts2Addr + "){ps1:<*>(" + v2Addr + "){ps2:<*>(" +
+		ts2Addr + ")<shown>}}}"
+	v2s4 := "{ps2:<*>(" + ts2Addr + "){ps1:<*>(" + v2Addr + ")<shown>}}"
+	v2s5 := "{ps2:(*" + v2t2 + "){ps1:(*" + v2t + "){ps2:(*" + v2t2 +
+		")<shown>}}}"
+	v2s6 := "{ps2:(*" + v2t2 + "){ps1:(*" + v2t + ")<shown>}}"
+	v2s7 := "{ps2:(*" + v2t2 + ")(" + ts2Addr + "){ps1:(*" + v2t +
+		")(" + v2Addr + "){ps2:(*" + v2t2 + ")(" + ts2Addr +
+		")<shown>}}}"
+	v2s8 := "{ps2:(*" + v2t2 + ")(" + ts2Addr + "){ps1:(*" + v2t +
+		")(" + v2Addr + ")<shown>}}"
+	addFormatterTest("%v", v2, v2s)
+	addFormatterTest("%v", pv2, "<*>"+v2s2)
+	addFormatterTest("%v", &pv2, "<**>"+v2s2)
+	addFormatterTest("%+v", v2, v2s3)
+	addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s4)
+	addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s4)
+	addFormatterTest("%#v", v2, "("+v2t+")"+v2s5)
+	addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s6)
+	addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s6)
+	addFormatterTest("%#+v", v2, "("+v2t+")"+v2s7)
+	addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s8)
+	addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s8)
+
+	// Structs that are indirectly circular.
+	v3 := indirCir1{nil}
+	tic2 := indirCir2{nil}
+	tic3 := indirCir3{&v3}
+	tic2.ps3 = &tic3
+	v3.ps2 = &tic2
+	pv3 := &v3
+	tic2Addr := fmt.Sprintf("%p", &tic2)
+	tic3Addr := fmt.Sprintf("%p", &tic3)
+	v3Addr := fmt.Sprintf("%p", pv3)
+	pv3Addr := fmt.Sprintf("%p", &pv3)
+	v3t := "spew_test.indirCir1"
+	v3t2 := "spew_test.indirCir2"
+	v3t3 := "spew_test.indirCir3"
+	v3s := "{<*>{<*>{<*>{<*><shown>}}}}"
+	v3s2 := "{<*>{<*>{<*><shown>}}}"
+	v3s3 := "{ps2:<*>(" + tic2Addr + "){ps3:<*>(" + tic3Addr + "){ps1:<*>(" +
+		v3Addr + "){ps2:<*>(" + tic2Addr + ")<shown>}}}}"
+	v3s4 := "{ps2:<*>(" + tic2Addr + "){ps3:<*>(" + tic3Addr + "){ps1:<*>(" +
+		v3Addr + ")<shown>}}}"
+	v3s5 := "{ps2:(*" + v3t2 + "){ps3:(*" + v3t3 + "){ps1:(*" + v3t +
+		"){ps2:(*" + v3t2 + ")<shown>}}}}"
+	v3s6 := "{ps2:(*" + v3t2 + "){ps3:(*" + v3t3 + "){ps1:(*" + v3t +
+		")<shown>}}}"
+	v3s7 := "{ps2:(*" + v3t2 + ")(" + tic2Addr + "){ps3:(*" + v3t3 + ")(" +
+		tic3Addr + "){ps1:(*" + v3t + ")(" + v3Addr + "){ps2:(*" + v3t2 +
+		")(" + tic2Addr + ")<shown>}}}}"
+	v3s8 := "{ps2:(*" + v3t2 + ")(" + tic2Addr + "){ps3:(*" + v3t3 + ")(" +
+		tic3Addr + "){ps1:(*" + v3t + ")(" + v3Addr + ")<shown>}}}"
+	addFormatterTest("%v", v3, v3s)
+	addFormatterTest("%v", pv3, "<*>"+v3s2)
+	addFormatterTest("%v", &pv3, "<**>"+v3s2)
+	addFormatterTest("%+v", v3, v3s3)
+	addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s4)
+	addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s4)
+	addFormatterTest("%#v", v3, "("+v3t+")"+v3s5)
+	addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s6)
+	addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s6)
+	addFormatterTest("%#+v", v3, "("+v3t+")"+v3s7)
+	addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s8)
+	addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s8)
+}
+
+func addPanicFormatterTests() {
+	// Type that panics in its Stringer interface.
+	v := panicer(127)
+	nv := (*panicer)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "spew_test.panicer"
+	vs := "(PANIC=test panic)127"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+}
+
+func addErrorFormatterTests() {
+	// Type that has a custom Error interface.
+	v := customError(127)
+	nv := (*customError)(nil)
+	pv := &v
+	vAddr := fmt.Sprintf("%p", pv)
+	pvAddr := fmt.Sprintf("%p", &pv)
+	vt := "spew_test.customError"
+	vs := "error: 127"
+	addFormatterTest("%v", v, vs)
+	addFormatterTest("%v", pv, "<*>"+vs)
+	addFormatterTest("%v", &pv, "<**>"+vs)
+	addFormatterTest("%v", nv, "<nil>")
+	addFormatterTest("%+v", v, vs)
+	addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+	addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%+v", nv, "<nil>")
+	addFormatterTest("%#v", v, "("+vt+")"+vs)
+	addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+	addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+	addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+	addFormatterTest("%#+v", v, "("+vt+")"+vs)
+	addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+	addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+	addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+}
+
+func addPassthroughFormatterTests() {
+	// %x passthrough with uint.
+	v := uint(4294967295)
+	pv := &v
+	vAddr := fmt.Sprintf("%x", pv)
+	pvAddr := fmt.Sprintf("%x", &pv)
+	vs := "ffffffff"
+	addFormatterTest("%x", v, vs)
+	addFormatterTest("%x", pv, vAddr)
+	addFormatterTest("%x", &pv, pvAddr)
+
+	// %#x passthrough with uint.
+	v2 := int(2147483647)
+	pv2 := &v2
+	v2Addr := fmt.Sprintf("%#x", pv2)
+	pv2Addr := fmt.Sprintf("%#x", &pv2)
+	v2s := "0x7fffffff"
+	addFormatterTest("%#x", v2, v2s)
+	addFormatterTest("%#x", pv2, v2Addr)
+	addFormatterTest("%#x", &pv2, pv2Addr)
+
+	// %f passthrough with precision.
+	addFormatterTest("%.2f", 3.1415, "3.14")
+	addFormatterTest("%.3f", 3.1415, "3.142")
+	addFormatterTest("%.4f", 3.1415, "3.1415")
+
+	// %f passthrough with width and precision.
+	addFormatterTest("%5.2f", 3.1415, " 3.14")
+	addFormatterTest("%6.3f", 3.1415, " 3.142")
+	addFormatterTest("%7.4f", 3.1415, " 3.1415")
+
+	// %d passthrough with width.
+	addFormatterTest("%3d", 127, "127")
+	addFormatterTest("%4d", 127, " 127")
+	addFormatterTest("%5d", 127, "  127")
+
+	// %q passthrough with string.
+	addFormatterTest("%q", "test", "\"test\"")
+}
+
+// TestFormatter executes all of the tests described by formatterTests.
+func TestFormatter(t *testing.T) {
+	// Setup tests.
+	addIntFormatterTests()
+	addUintFormatterTests()
+	addBoolFormatterTests()
+	addFloatFormatterTests()
+	addComplexFormatterTests()
+	addArrayFormatterTests()
+	addSliceFormatterTests()
+	addStringFormatterTests()
+	addInterfaceFormatterTests()
+	addMapFormatterTests()
+	addStructFormatterTests()
+	addUintptrFormatterTests()
+	addUnsafePointerFormatterTests()
+	addChanFormatterTests()
+	addFuncFormatterTests()
+	addCircularFormatterTests()
+	addPanicFormatterTests()
+	addErrorFormatterTests()
+	addPassthroughFormatterTests()
+
+	t.Logf("Running %d tests", len(formatterTests))
+	for i, test := range formatterTests {
+		buf := new(bytes.Buffer)
+		spew.Fprintf(buf, test.format, test.in)
+		s := buf.String()
+		if testFailed(s, test.wants) {
+			t.Errorf("Formatter #%d format: %s got: %s %s", i, test.format, s,
+				stringizeWants(test.wants))
+			continue
+		}
+	}
+}
+
+type testStruct struct {
+	x int
+}
+
+func (ts testStruct) String() string {
+	return fmt.Sprintf("ts.%d", ts.x)
+}
+
+type testStructP struct {
+	x int
+}
+
+func (ts *testStructP) String() string {
+	return fmt.Sprintf("ts.%d", ts.x)
+}
+
+func TestPrintSortedKeys(t *testing.T) {
+	cfg := spew.ConfigState{SortKeys: true}
+	s := cfg.Sprint(map[int]string{1: "1", 3: "3", 2: "2"})
+	expected := "map[1:1 2:2 3:3]"
+	if s != expected {
+		t.Errorf("Sorted keys mismatch 1:\n  %v %v", s, expected)
+	}
+
+	s = cfg.Sprint(map[stringer]int{"1": 1, "3": 3, "2": 2})
+	expected = "map[stringer 1:1 stringer 2:2 stringer 3:3]"
+	if s != expected {
+		t.Errorf("Sorted keys mismatch 2:\n  %v %v", s, expected)
+	}
+
+	s = cfg.Sprint(map[pstringer]int{pstringer("1"): 1, pstringer("3"): 3, pstringer("2"): 2})
+	expected = "map[stringer 1:1 stringer 2:2 stringer 3:3]"
+	if spew.UnsafeDisabled {
+		expected = "map[1:1 2:2 3:3]"
+	}
+	if s != expected {
+		t.Errorf("Sorted keys mismatch 3:\n  %v %v", s, expected)
+	}
+
+	s = cfg.Sprint(map[testStruct]int{{1}: 1, {3}: 3, {2}: 2})
+	expected = "map[ts.1:1 ts.2:2 ts.3:3]"
+	if s != expected {
+		t.Errorf("Sorted keys mismatch 4:\n  %v %v", s, expected)
+	}
+
+	if !spew.UnsafeDisabled {
+		s = cfg.Sprint(map[testStructP]int{{1}: 1, {3}: 3, {2}: 2})
+		expected = "map[ts.1:1 ts.2:2 ts.3:3]"
+		if s != expected {
+			t.Errorf("Sorted keys mismatch 5:\n  %v %v", s, expected)
+		}
+	}
+
+	s = cfg.Sprint(map[customError]int{customError(1): 1, customError(3): 3, customError(2): 2})
+	expected = "map[error: 1:1 error: 2:2 error: 3:3]"
+	if s != expected {
+		t.Errorf("Sorted keys mismatch 6:\n  %v %v", s, expected)
+	}
+}
diff --git a/internal/spew/internal_test.go b/internal/spew/internal_test.go
new file mode 100644
index 000000000..e312b4fad
--- /dev/null
+++ b/internal/spew/internal_test.go
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+This test file is part of the spew package rather than than the spew_test
+package because it needs access to internals to properly test certain cases
+which are not possible via the public interface since they should never happen.
+*/
+
+package spew
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+)
+
+// dummyFmtState implements a fake fmt.State to use for testing invalid
+// reflect.Value handling.  This is necessary because the fmt package catches
+// invalid values before invoking the formatter on them.
+type dummyFmtState struct {
+	bytes.Buffer
+}
+
+func (dfs *dummyFmtState) Flag(f int) bool {
+	return f == int('+')
+}
+
+func (dfs *dummyFmtState) Precision() (int, bool) {
+	return 0, false
+}
+
+func (dfs *dummyFmtState) Width() (int, bool) {
+	return 0, false
+}
+
+// TestInvalidReflectValue ensures the dump and formatter code handles an
+// invalid reflect value properly.  This needs access to internal state since it
+// should never happen in real code and therefore can't be tested via the public
+// API.
+func TestInvalidReflectValue(t *testing.T) {
+	i := 1
+
+	// Dump invalid reflect value.
+	v := new(reflect.Value)
+	buf := new(bytes.Buffer)
+	d := dumpState{w: buf, cs: &Config}
+	d.dump(*v)
+	s := buf.String()
+	want := "<invalid>"
+	if s != want {
+		t.Errorf("InvalidReflectValue #%d\n got: %s want: %s", i, s, want)
+	}
+	i++
+
+	// Formatter invalid reflect value.
+	buf2 := new(dummyFmtState)
+	f := formatState{value: *v, cs: &Config, fs: buf2}
+	f.format(*v)
+	s = buf2.String()
+	want = "<invalid>"
+	if s != want {
+		t.Errorf("InvalidReflectValue #%d got: %s want: %s", i, s, want)
+	}
+}
+
+// SortValues makes the internal sortValues function available to the test
+// package.
+func SortValues(values []reflect.Value, cs *ConfigState) {
+	sortValues(values, cs)
+}
diff --git a/internal/spew/internalunsafe_test.go b/internal/spew/internalunsafe_test.go
new file mode 100644
index 000000000..2b547c41c
--- /dev/null
+++ b/internal/spew/internalunsafe_test.go
@@ -0,0 +1,102 @@
+// Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is not running on Google App Engine, compiled by GopherJS, and
+// "-tags safe" is not added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+//go:build !js && !appengine && !safe && !disableunsafe && go1.4
+// +build !js,!appengine,!safe,!disableunsafe,go1.4
+
+/*
+This test file is part of the spew package rather than than the spew_test
+package because it needs access to internals to properly test certain cases
+which are not possible via the public interface since they should never happen.
+*/
+
+package spew
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+)
+
+// changeKind uses unsafe to intentionally change the kind of a reflect.Value to
+// the maximum kind value which does not exist.  This is needed to test the
+// fallback code which punts to the standard fmt library for new types that
+// might get added to the language.
+func changeKind(v *reflect.Value, readOnly bool) {
+	flags := flagField(v)
+	if readOnly {
+		*flags |= flagRO
+	} else {
+		*flags &^= flagRO
+	}
+	*flags |= flagKindMask
+}
+
+// TestAddedReflectValue tests functionaly of the dump and formatter code which
+// falls back to the standard fmt library for new types that might get added to
+// the language.
+func TestAddedReflectValue(t *testing.T) {
+	i := 1
+
+	// Dump using a reflect.Value that is exported.
+	v := reflect.ValueOf(int8(5))
+	changeKind(&v, false)
+	buf := new(bytes.Buffer)
+	d := dumpState{w: buf, cs: &Config}
+	d.dump(v)
+	s := buf.String()
+	want := "(int8) 5"
+	if s != want {
+		t.Errorf("TestAddedReflectValue #%d\n got: %s want: %s", i, s, want)
+	}
+	i++
+
+	// Dump using a reflect.Value that is not exported.
+	changeKind(&v, true)
+	buf.Reset()
+	d.dump(v)
+	s = buf.String()
+	want = "(int8) <int8 Value>"
+	if s != want {
+		t.Errorf("TestAddedReflectValue #%d\n got: %s want: %s", i, s, want)
+	}
+	i++
+
+	// Formatter using a reflect.Value that is exported.
+	changeKind(&v, false)
+	buf2 := new(dummyFmtState)
+	f := formatState{value: v, cs: &Config, fs: buf2}
+	f.format(v)
+	s = buf2.String()
+	want = "5"
+	if s != want {
+		t.Errorf("TestAddedReflectValue #%d got: %s want: %s", i, s, want)
+	}
+	i++
+
+	// Formatter using a reflect.Value that is not exported.
+	changeKind(&v, true)
+	buf2.Reset()
+	f = formatState{value: v, cs: &Config, fs: buf2}
+	f.format(v)
+	s = buf2.String()
+	want = "<int8 Value>"
+	if s != want {
+		t.Errorf("TestAddedReflectValue #%d got: %s want: %s", i, s, want)
+	}
+}
diff --git a/internal/spew/spew.go b/internal/spew/spew.go
new file mode 100644
index 000000000..32c0e3388
--- /dev/null
+++ b/internal/spew/spew.go
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"fmt"
+	"io"
+)
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the formatted string as a value that satisfies error.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a default Formatter interface returned by NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
+func Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
+func Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprint(a ...interface{}) string {
+	return fmt.Sprint(convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(convertArgs(a)...)
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a default spew Formatter interface.
+func convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = NewFormatter(arg)
+	}
+	return formatters
+}
diff --git a/internal/spew/spew_test.go b/internal/spew/spew_test.go
new file mode 100644
index 000000000..55b7897e2
--- /dev/null
+++ b/internal/spew/spew_test.go
@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew_test
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/expr-lang/expr/internal/spew"
+)
+
+// spewFunc is used to identify which public function of the spew package or
+// ConfigState a test applies to.
+type spewFunc int
+
+const (
+	fCSFdump spewFunc = iota
+	fCSFprint
+	fCSFprintf
+	fCSFprintln
+	fCSPrint
+	fCSPrintln
+	fCSSdump
+	fCSSprint
+	fCSSprintf
+	fCSSprintln
+	fCSErrorf
+	fCSNewFormatter
+	fErrorf
+	fFprint
+	fFprintln
+	fPrint
+	fPrintln
+	fSdump
+	fSprint
+	fSprintf
+	fSprintln
+)
+
+// Map of spewFunc values to names for pretty printing.
+var spewFuncStrings = map[spewFunc]string{
+	fCSFdump:        "ConfigState.Fdump",
+	fCSFprint:       "ConfigState.Fprint",
+	fCSFprintf:      "ConfigState.Fprintf",
+	fCSFprintln:     "ConfigState.Fprintln",
+	fCSSdump:        "ConfigState.Sdump",
+	fCSPrint:        "ConfigState.Print",
+	fCSPrintln:      "ConfigState.Println",
+	fCSSprint:       "ConfigState.Sprint",
+	fCSSprintf:      "ConfigState.Sprintf",
+	fCSSprintln:     "ConfigState.Sprintln",
+	fCSErrorf:       "ConfigState.Errorf",
+	fCSNewFormatter: "ConfigState.NewFormatter",
+	fErrorf:         "spew.Errorf",
+	fFprint:         "spew.Fprint",
+	fFprintln:       "spew.Fprintln",
+	fPrint:          "spew.Print",
+	fPrintln:        "spew.Println",
+	fSdump:          "spew.Sdump",
+	fSprint:         "spew.Sprint",
+	fSprintf:        "spew.Sprintf",
+	fSprintln:       "spew.Sprintln",
+}
+
+func (f spewFunc) String() string {
+	if s, ok := spewFuncStrings[f]; ok {
+		return s
+	}
+	return fmt.Sprintf("Unknown spewFunc (%d)", int(f))
+}
+
+// spewTest is used to describe a test to be performed against the public
+// functions of the spew package or ConfigState.
+type spewTest struct {
+	cs     *spew.ConfigState
+	f      spewFunc
+	format string
+	in     interface{}
+	want   string
+}
+
+// spewTests houses the tests to be performed against the public functions of
+// the spew package and ConfigState.
+//
+// These tests are only intended to ensure the public functions are exercised
+// and are intentionally not exhaustive of types.  The exhaustive type
+// tests are handled in the dump and format tests.
+var spewTests []spewTest
+
+// redirStdout is a helper function to return the standard output from f as a
+// byte slice.
+func redirStdout(f func()) ([]byte, error) {
+	tempFile, err := ioutil.TempFile("", "ss-test")
+	if err != nil {
+		return nil, err
+	}
+	fileName := tempFile.Name()
+	defer os.Remove(fileName) // Ignore error
+
+	origStdout := os.Stdout
+	os.Stdout = tempFile
+	f()
+	os.Stdout = origStdout
+	tempFile.Close()
+
+	return ioutil.ReadFile(fileName)
+}
+
+func initSpewTests() {
+	// Config states with various settings.
+	scsDefault := spew.NewDefaultConfig()
+	scsNoMethods := &spew.ConfigState{Indent: " ", DisableMethods: true}
+	scsNoPmethods := &spew.ConfigState{Indent: " ", DisablePointerMethods: true}
+	scsMaxDepth := &spew.ConfigState{Indent: " ", MaxDepth: 1}
+	scsContinue := &spew.ConfigState{Indent: " ", ContinueOnMethod: true}
+	scsNoPtrAddr := &spew.ConfigState{DisablePointerAddresses: true}
+	scsNoCap := &spew.ConfigState{DisableCapacities: true}
+
+	// Variables for tests on types which implement Stringer interface with and
+	// without a pointer receiver.
+	ts := stringer("test")
+	tps := pstringer("test")
+
+	type ptrTester struct {
+		s *struct{}
+	}
+	tptr := &ptrTester{s: &struct{}{}}
+
+	// depthTester is used to test max depth handling for structs, array, slices
+	// and maps.
+	type depthTester struct {
+		ic    indirCir1
+		arr   [1]string
+		slice []string
+		m     map[string]int
+	}
+	dt := depthTester{indirCir1{nil}, [1]string{"arr"}, []string{"slice"},
+		map[string]int{"one": 1}}
+
+	// Variable for tests on types which implement error interface.
+	te := customError(10)
+
+	spewTests = []spewTest{
+		{scsDefault, fCSFdump, "", int8(127), "(int8) 127\n"},
+		{scsDefault, fCSFprint, "", int16(32767), "32767"},
+		{scsDefault, fCSFprintf, "%v", int32(2147483647), "2147483647"},
+		{scsDefault, fCSFprintln, "", int(2147483647), "2147483647\n"},
+		{scsDefault, fCSPrint, "", int64(9223372036854775807), "9223372036854775807"},
+		{scsDefault, fCSPrintln, "", uint8(255), "255\n"},
+		{scsDefault, fCSSdump, "", uint8(64), "(uint8) 64\n"},
+		{scsDefault, fCSSprint, "", complex(1, 2), "(1+2i)"},
+		{scsDefault, fCSSprintf, "%v", complex(float32(3), 4), "(3+4i)"},
+		{scsDefault, fCSSprintln, "", complex(float64(5), 6), "(5+6i)\n"},
+		{scsDefault, fCSErrorf, "%#v", uint16(65535), "(uint16)65535"},
+		{scsDefault, fCSNewFormatter, "%v", uint32(4294967295), "4294967295"},
+		{scsDefault, fErrorf, "%v", uint64(18446744073709551615), "18446744073709551615"},
+		{scsDefault, fFprint, "", float32(3.14), "3.14"},
+		{scsDefault, fFprintln, "", float64(6.28), "6.28\n"},
+		{scsDefault, fPrint, "", true, "true"},
+		{scsDefault, fPrintln, "", false, "false\n"},
+		{scsDefault, fSdump, "", complex(-10, -20), "(complex128) (-10-20i)\n"},
+		{scsDefault, fSprint, "", complex(-1, -2), "(-1-2i)"},
+		{scsDefault, fSprintf, "%v", complex(float32(-3), -4), "(-3-4i)"},
+		{scsDefault, fSprintln, "", complex(float64(-5), -6), "(-5-6i)\n"},
+		{scsNoMethods, fCSFprint, "", ts, "test"},
+		{scsNoMethods, fCSFprint, "", &ts, "<*>test"},
+		{scsNoMethods, fCSFprint, "", tps, "test"},
+		{scsNoMethods, fCSFprint, "", &tps, "<*>test"},
+		{scsNoPmethods, fCSFprint, "", ts, "stringer test"},
+		{scsNoPmethods, fCSFprint, "", &ts, "<*>stringer test"},
+		{scsNoPmethods, fCSFprint, "", tps, "test"},
+		{scsNoPmethods, fCSFprint, "", &tps, "<*>stringer test"},
+		{scsMaxDepth, fCSFprint, "", dt, "{{<max>} [<max>] [<max>] map[<max>]}"},
+		{scsMaxDepth, fCSFdump, "", dt, "(spew_test.depthTester) {\n" +
+			" ic: (spew_test.indirCir1) {\n  <max depth reached>\n },\n" +
+			" arr: ([1]string) (len=1 cap=1) {\n  <max depth reached>\n },\n" +
+			" slice: ([]string) (len=1 cap=1) {\n  <max depth reached>\n },\n" +
+			" m: (map[string]int) (len=1) {\n  <max depth reached>\n }\n}\n"},
+		{scsContinue, fCSFprint, "", ts, "(stringer test) test"},
+		{scsContinue, fCSFdump, "", ts, "(spew_test.stringer) " +
+			"(len=4) (stringer test) \"test\"\n"},
+		{scsContinue, fCSFprint, "", te, "(error: 10) 10"},
+		{scsContinue, fCSFdump, "", te, "(spew_test.customError) " +
+			"(error: 10) 10\n"},
+		{scsNoPtrAddr, fCSFprint, "", tptr, "<*>{<*>{}}"},
+		{scsNoPtrAddr, fCSSdump, "", tptr, "(*spew_test.ptrTester)({\ns: (*struct {})({\n})\n})\n"},
+		{scsNoCap, fCSSdump, "", make([]string, 0, 10), "([]string) {\n}\n"},
+		{scsNoCap, fCSSdump, "", make([]string, 1, 10), "([]string) (len=1) {\n(string) \"\"\n}\n"},
+	}
+}
+
+// TestSpew executes all of the tests described by spewTests.
+func TestSpew(t *testing.T) {
+	initSpewTests()
+
+	t.Logf("Running %d tests", len(spewTests))
+	for i, test := range spewTests {
+		buf := new(bytes.Buffer)
+		switch test.f {
+		case fCSFdump:
+			test.cs.Fdump(buf, test.in)
+
+		case fCSFprint:
+			test.cs.Fprint(buf, test.in)
+
+		case fCSFprintf:
+			test.cs.Fprintf(buf, test.format, test.in)
+
+		case fCSFprintln:
+			test.cs.Fprintln(buf, test.in)
+
+		case fCSPrint:
+			b, err := redirStdout(func() { test.cs.Print(test.in) })
+			if err != nil {
+				t.Errorf("%v #%d %v", test.f, i, err)
+				continue
+			}
+			buf.Write(b)
+
+		case fCSPrintln:
+			b, err := redirStdout(func() { test.cs.Println(test.in) })
+			if err != nil {
+				t.Errorf("%v #%d %v", test.f, i, err)
+				continue
+			}
+			buf.Write(b)
+
+		case fCSSdump:
+			str := test.cs.Sdump(test.in)
+			buf.WriteString(str)
+
+		case fCSSprint:
+			str := test.cs.Sprint(test.in)
+			buf.WriteString(str)
+
+		case fCSSprintf:
+			str := test.cs.Sprintf(test.format, test.in)
+			buf.WriteString(str)
+
+		case fCSSprintln:
+			str := test.cs.Sprintln(test.in)
+			buf.WriteString(str)
+
+		case fCSErrorf:
+			err := test.cs.Errorf(test.format, test.in)
+			buf.WriteString(err.Error())
+
+		case fCSNewFormatter:
+			fmt.Fprintf(buf, test.format, test.cs.NewFormatter(test.in))
+
+		case fErrorf:
+			err := spew.Errorf(test.format, test.in)
+			buf.WriteString(err.Error())
+
+		case fFprint:
+			spew.Fprint(buf, test.in)
+
+		case fFprintln:
+			spew.Fprintln(buf, test.in)
+
+		case fPrint:
+			b, err := redirStdout(func() { spew.Print(test.in) })
+			if err != nil {
+				t.Errorf("%v #%d %v", test.f, i, err)
+				continue
+			}
+			buf.Write(b)
+
+		case fPrintln:
+			b, err := redirStdout(func() { spew.Println(test.in) })
+			if err != nil {
+				t.Errorf("%v #%d %v", test.f, i, err)
+				continue
+			}
+			buf.Write(b)
+
+		case fSdump:
+			str := spew.Sdump(test.in)
+			buf.WriteString(str)
+
+		case fSprint:
+			str := spew.Sprint(test.in)
+			buf.WriteString(str)
+
+		case fSprintf:
+			str := spew.Sprintf(test.format, test.in)
+			buf.WriteString(str)
+
+		case fSprintln:
+			str := spew.Sprintln(test.in)
+			buf.WriteString(str)
+
+		default:
+			t.Errorf("%v #%d unrecognized function", test.f, i)
+			continue
+		}
+		s := buf.String()
+		if test.want != s {
+			t.Errorf("ConfigState #%d\n got: %s want: %s", i, s, test.want)
+			continue
+		}
+	}
+}
diff --git a/internal/spew/testdata/dumpcgo.go b/internal/spew/testdata/dumpcgo.go
new file mode 100644
index 000000000..368ead024
--- /dev/null
+++ b/internal/spew/testdata/dumpcgo.go
@@ -0,0 +1,83 @@
+// Copyright (c) 2013 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when both cgo is supported and "-tags testcgo" is added to the go test
+// command line.  This code should really only be in the dumpcgo_test.go file,
+// but unfortunately Go will not allow cgo in test files, so this is a
+// workaround to allow cgo types to be tested.  This configuration is used
+// because spew itself does not require cgo to run even though it does handle
+// certain cgo types specially.  Rather than forcing all clients to require cgo
+// and an external C compiler just to run the tests, this scheme makes them
+// optional.
+//go:build cgo && testcgo
+// +build cgo,testcgo
+
+package testdata
+
+/*
+#include <stdint.h>
+typedef unsigned char custom_uchar_t;
+
+char            *ncp = 0;
+char            *cp = "test";
+char             ca[6] = {'t', 'e', 's', 't', '2', '\0'};
+unsigned char    uca[6] = {'t', 'e', 's', 't', '3', '\0'};
+signed char      sca[6] = {'t', 'e', 's', 't', '4', '\0'};
+uint8_t          ui8ta[6] = {'t', 'e', 's', 't', '5', '\0'};
+custom_uchar_t   tuca[6] = {'t', 'e', 's', 't', '6', '\0'};
+*/
+import "C"
+
+// GetCgoNullCharPointer returns a null char pointer via cgo.  This is only
+// used for tests.
+func GetCgoNullCharPointer() interface{} {
+	return C.ncp
+}
+
+// GetCgoCharPointer returns a char pointer via cgo.  This is only used for
+// tests.
+func GetCgoCharPointer() interface{} {
+	return C.cp
+}
+
+// GetCgoCharArray returns a char array via cgo and the array's len and cap.
+// This is only used for tests.
+func GetCgoCharArray() (interface{}, int, int) {
+	return C.ca, len(C.ca), cap(C.ca)
+}
+
+// GetCgoUnsignedCharArray returns an unsigned char array via cgo and the
+// array's len and cap.  This is only used for tests.
+func GetCgoUnsignedCharArray() (interface{}, int, int) {
+	return C.uca, len(C.uca), cap(C.uca)
+}
+
+// GetCgoSignedCharArray returns a signed char array via cgo and the array's len
+// and cap.  This is only used for tests.
+func GetCgoSignedCharArray() (interface{}, int, int) {
+	return C.sca, len(C.sca), cap(C.sca)
+}
+
+// GetCgoUint8tArray returns a uint8_t array via cgo and the array's len and
+// cap.  This is only used for tests.
+func GetCgoUint8tArray() (interface{}, int, int) {
+	return C.ui8ta, len(C.ui8ta), cap(C.ui8ta)
+}
+
+// GetCgoTypdefedUnsignedCharArray returns a typedefed unsigned char array via
+// cgo and the array's len and cap.  This is only used for tests.
+func GetCgoTypdefedUnsignedCharArray() (interface{}, int, int) {
+	return C.tuca, len(C.tuca), cap(C.tuca)
+}
diff --git a/internal/testify/assert/assertion_compare.go b/internal/testify/assert/assertion_compare.go
new file mode 100644
index 000000000..7e19eba09
--- /dev/null
+++ b/internal/testify/assert/assertion_compare.go
@@ -0,0 +1,489 @@
+package assert
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"time"
+)
+
+// Deprecated: CompareType has only ever been for internal use and has accidentally been published since v1.6.0. Do not use it.
+type CompareType = compareResult
+
+type compareResult int
+
+const (
+	compareLess compareResult = iota - 1
+	compareEqual
+	compareGreater
+)
+
+var (
+	intType   = reflect.TypeOf(int(1))
+	int8Type  = reflect.TypeOf(int8(1))
+	int16Type = reflect.TypeOf(int16(1))
+	int32Type = reflect.TypeOf(int32(1))
+	int64Type = reflect.TypeOf(int64(1))
+
+	uintType   = reflect.TypeOf(uint(1))
+	uint8Type  = reflect.TypeOf(uint8(1))
+	uint16Type = reflect.TypeOf(uint16(1))
+	uint32Type = reflect.TypeOf(uint32(1))
+	uint64Type = reflect.TypeOf(uint64(1))
+
+	uintptrType = reflect.TypeOf(uintptr(1))
+
+	float32Type = reflect.TypeOf(float32(1))
+	float64Type = reflect.TypeOf(float64(1))
+
+	stringType = reflect.TypeOf("")
+
+	timeType  = reflect.TypeOf(time.Time{})
+	bytesType = reflect.TypeOf([]byte{})
+)
+
+func compare(obj1, obj2 interface{}, kind reflect.Kind) (compareResult, bool) {
+	obj1Value := reflect.ValueOf(obj1)
+	obj2Value := reflect.ValueOf(obj2)
+
+	// throughout this switch we try and avoid calling .Convert() if possible,
+	// as this has a pretty big performance impact
+	switch kind {
+	case reflect.Int:
+		{
+			intobj1, ok := obj1.(int)
+			if !ok {
+				intobj1 = obj1Value.Convert(intType).Interface().(int)
+			}
+			intobj2, ok := obj2.(int)
+			if !ok {
+				intobj2 = obj2Value.Convert(intType).Interface().(int)
+			}
+			if intobj1 > intobj2 {
+				return compareGreater, true
+			}
+			if intobj1 == intobj2 {
+				return compareEqual, true
+			}
+			if intobj1 < intobj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Int8:
+		{
+			int8obj1, ok := obj1.(int8)
+			if !ok {
+				int8obj1 = obj1Value.Convert(int8Type).Interface().(int8)
+			}
+			int8obj2, ok := obj2.(int8)
+			if !ok {
+				int8obj2 = obj2Value.Convert(int8Type).Interface().(int8)
+			}
+			if int8obj1 > int8obj2 {
+				return compareGreater, true
+			}
+			if int8obj1 == int8obj2 {
+				return compareEqual, true
+			}
+			if int8obj1 < int8obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Int16:
+		{
+			int16obj1, ok := obj1.(int16)
+			if !ok {
+				int16obj1 = obj1Value.Convert(int16Type).Interface().(int16)
+			}
+			int16obj2, ok := obj2.(int16)
+			if !ok {
+				int16obj2 = obj2Value.Convert(int16Type).Interface().(int16)
+			}
+			if int16obj1 > int16obj2 {
+				return compareGreater, true
+			}
+			if int16obj1 == int16obj2 {
+				return compareEqual, true
+			}
+			if int16obj1 < int16obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Int32:
+		{
+			int32obj1, ok := obj1.(int32)
+			if !ok {
+				int32obj1 = obj1Value.Convert(int32Type).Interface().(int32)
+			}
+			int32obj2, ok := obj2.(int32)
+			if !ok {
+				int32obj2 = obj2Value.Convert(int32Type).Interface().(int32)
+			}
+			if int32obj1 > int32obj2 {
+				return compareGreater, true
+			}
+			if int32obj1 == int32obj2 {
+				return compareEqual, true
+			}
+			if int32obj1 < int32obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Int64:
+		{
+			int64obj1, ok := obj1.(int64)
+			if !ok {
+				int64obj1 = obj1Value.Convert(int64Type).Interface().(int64)
+			}
+			int64obj2, ok := obj2.(int64)
+			if !ok {
+				int64obj2 = obj2Value.Convert(int64Type).Interface().(int64)
+			}
+			if int64obj1 > int64obj2 {
+				return compareGreater, true
+			}
+			if int64obj1 == int64obj2 {
+				return compareEqual, true
+			}
+			if int64obj1 < int64obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Uint:
+		{
+			uintobj1, ok := obj1.(uint)
+			if !ok {
+				uintobj1 = obj1Value.Convert(uintType).Interface().(uint)
+			}
+			uintobj2, ok := obj2.(uint)
+			if !ok {
+				uintobj2 = obj2Value.Convert(uintType).Interface().(uint)
+			}
+			if uintobj1 > uintobj2 {
+				return compareGreater, true
+			}
+			if uintobj1 == uintobj2 {
+				return compareEqual, true
+			}
+			if uintobj1 < uintobj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Uint8:
+		{
+			uint8obj1, ok := obj1.(uint8)
+			if !ok {
+				uint8obj1 = obj1Value.Convert(uint8Type).Interface().(uint8)
+			}
+			uint8obj2, ok := obj2.(uint8)
+			if !ok {
+				uint8obj2 = obj2Value.Convert(uint8Type).Interface().(uint8)
+			}
+			if uint8obj1 > uint8obj2 {
+				return compareGreater, true
+			}
+			if uint8obj1 == uint8obj2 {
+				return compareEqual, true
+			}
+			if uint8obj1 < uint8obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Uint16:
+		{
+			uint16obj1, ok := obj1.(uint16)
+			if !ok {
+				uint16obj1 = obj1Value.Convert(uint16Type).Interface().(uint16)
+			}
+			uint16obj2, ok := obj2.(uint16)
+			if !ok {
+				uint16obj2 = obj2Value.Convert(uint16Type).Interface().(uint16)
+			}
+			if uint16obj1 > uint16obj2 {
+				return compareGreater, true
+			}
+			if uint16obj1 == uint16obj2 {
+				return compareEqual, true
+			}
+			if uint16obj1 < uint16obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Uint32:
+		{
+			uint32obj1, ok := obj1.(uint32)
+			if !ok {
+				uint32obj1 = obj1Value.Convert(uint32Type).Interface().(uint32)
+			}
+			uint32obj2, ok := obj2.(uint32)
+			if !ok {
+				uint32obj2 = obj2Value.Convert(uint32Type).Interface().(uint32)
+			}
+			if uint32obj1 > uint32obj2 {
+				return compareGreater, true
+			}
+			if uint32obj1 == uint32obj2 {
+				return compareEqual, true
+			}
+			if uint32obj1 < uint32obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Uint64:
+		{
+			uint64obj1, ok := obj1.(uint64)
+			if !ok {
+				uint64obj1 = obj1Value.Convert(uint64Type).Interface().(uint64)
+			}
+			uint64obj2, ok := obj2.(uint64)
+			if !ok {
+				uint64obj2 = obj2Value.Convert(uint64Type).Interface().(uint64)
+			}
+			if uint64obj1 > uint64obj2 {
+				return compareGreater, true
+			}
+			if uint64obj1 == uint64obj2 {
+				return compareEqual, true
+			}
+			if uint64obj1 < uint64obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Float32:
+		{
+			float32obj1, ok := obj1.(float32)
+			if !ok {
+				float32obj1 = obj1Value.Convert(float32Type).Interface().(float32)
+			}
+			float32obj2, ok := obj2.(float32)
+			if !ok {
+				float32obj2 = obj2Value.Convert(float32Type).Interface().(float32)
+			}
+			if float32obj1 > float32obj2 {
+				return compareGreater, true
+			}
+			if float32obj1 == float32obj2 {
+				return compareEqual, true
+			}
+			if float32obj1 < float32obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.Float64:
+		{
+			float64obj1, ok := obj1.(float64)
+			if !ok {
+				float64obj1 = obj1Value.Convert(float64Type).Interface().(float64)
+			}
+			float64obj2, ok := obj2.(float64)
+			if !ok {
+				float64obj2 = obj2Value.Convert(float64Type).Interface().(float64)
+			}
+			if float64obj1 > float64obj2 {
+				return compareGreater, true
+			}
+			if float64obj1 == float64obj2 {
+				return compareEqual, true
+			}
+			if float64obj1 < float64obj2 {
+				return compareLess, true
+			}
+		}
+	case reflect.String:
+		{
+			stringobj1, ok := obj1.(string)
+			if !ok {
+				stringobj1 = obj1Value.Convert(stringType).Interface().(string)
+			}
+			stringobj2, ok := obj2.(string)
+			if !ok {
+				stringobj2 = obj2Value.Convert(stringType).Interface().(string)
+			}
+			if stringobj1 > stringobj2 {
+				return compareGreater, true
+			}
+			if stringobj1 == stringobj2 {
+				return compareEqual, true
+			}
+			if stringobj1 < stringobj2 {
+				return compareLess, true
+			}
+		}
+	// Check for known struct types we can check for compare results.
+	case reflect.Struct:
+		{
+			// All structs enter here. We're not interested in most types.
+			if !obj1Value.CanConvert(timeType) {
+				break
+			}
+
+			// time.Time can be compared!
+			timeObj1, ok := obj1.(time.Time)
+			if !ok {
+				timeObj1 = obj1Value.Convert(timeType).Interface().(time.Time)
+			}
+
+			timeObj2, ok := obj2.(time.Time)
+			if !ok {
+				timeObj2 = obj2Value.Convert(timeType).Interface().(time.Time)
+			}
+
+			if timeObj1.Before(timeObj2) {
+				return compareLess, true
+			}
+			if timeObj1.Equal(timeObj2) {
+				return compareEqual, true
+			}
+			return compareGreater, true
+		}
+	case reflect.Slice:
+		{
+			// We only care about the []byte type.
+			if !obj1Value.CanConvert(bytesType) {
+				break
+			}
+
+			// []byte can be compared!
+			bytesObj1, ok := obj1.([]byte)
+			if !ok {
+				bytesObj1 = obj1Value.Convert(bytesType).Interface().([]byte)
+
+			}
+			bytesObj2, ok := obj2.([]byte)
+			if !ok {
+				bytesObj2 = obj2Value.Convert(bytesType).Interface().([]byte)
+			}
+
+			return compareResult(bytes.Compare(bytesObj1, bytesObj2)), true
+		}
+	case reflect.Uintptr:
+		{
+			uintptrObj1, ok := obj1.(uintptr)
+			if !ok {
+				uintptrObj1 = obj1Value.Convert(uintptrType).Interface().(uintptr)
+			}
+			uintptrObj2, ok := obj2.(uintptr)
+			if !ok {
+				uintptrObj2 = obj2Value.Convert(uintptrType).Interface().(uintptr)
+			}
+			if uintptrObj1 > uintptrObj2 {
+				return compareGreater, true
+			}
+			if uintptrObj1 == uintptrObj2 {
+				return compareEqual, true
+			}
+			if uintptrObj1 < uintptrObj2 {
+				return compareLess, true
+			}
+		}
+	}
+
+	return compareEqual, false
+}
+
+// Greater asserts that the first element is greater than the second
+//
+//	assert.Greater(t, 2, 1)
+//	assert.Greater(t, float64(2), float64(1))
+//	assert.Greater(t, "b", "a")
+func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return compareTwoValues(t, e1, e2, []compareResult{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
+}
+
+// GreaterOrEqual asserts that the first element is greater than or equal to the second
+//
+//	assert.GreaterOrEqual(t, 2, 1)
+//	assert.GreaterOrEqual(t, 2, 2)
+//	assert.GreaterOrEqual(t, "b", "a")
+//	assert.GreaterOrEqual(t, "b", "b")
+func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return compareTwoValues(t, e1, e2, []compareResult{compareGreater, compareEqual}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
+}
+
+// Less asserts that the first element is less than the second
+//
+//	assert.Less(t, 1, 2)
+//	assert.Less(t, float64(1), float64(2))
+//	assert.Less(t, "a", "b")
+func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return compareTwoValues(t, e1, e2, []compareResult{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
+}
+
+// LessOrEqual asserts that the first element is less than or equal to the second
+//
+//	assert.LessOrEqual(t, 1, 2)
+//	assert.LessOrEqual(t, 2, 2)
+//	assert.LessOrEqual(t, "a", "b")
+//	assert.LessOrEqual(t, "b", "b")
+func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return compareTwoValues(t, e1, e2, []compareResult{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
+}
+
+// Positive asserts that the specified element is positive
+//
+//	assert.Positive(t, 1)
+//	assert.Positive(t, 1.23)
+func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	zero := reflect.Zero(reflect.TypeOf(e))
+	return compareTwoValues(t, e, zero.Interface(), []compareResult{compareGreater}, "\"%v\" is not positive", msgAndArgs...)
+}
+
+// Negative asserts that the specified element is negative
+//
+//	assert.Negative(t, -1)
+//	assert.Negative(t, -1.23)
+func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	zero := reflect.Zero(reflect.TypeOf(e))
+	return compareTwoValues(t, e, zero.Interface(), []compareResult{compareLess}, "\"%v\" is not negative", msgAndArgs...)
+}
+
+func compareTwoValues(t TestingT, e1 interface{}, e2 interface{}, allowedComparesResults []compareResult, failMessage string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	e1Kind := reflect.ValueOf(e1).Kind()
+	e2Kind := reflect.ValueOf(e2).Kind()
+	if e1Kind != e2Kind {
+		return Fail(t, "Elements should be the same type", msgAndArgs...)
+	}
+
+	compareResult, isComparable := compare(e1, e2, e1Kind)
+	if !isComparable {
+		return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...)
+	}
+
+	if !containsValue(allowedComparesResults, compareResult) {
+		return Fail(t, fmt.Sprintf(failMessage, e1, e2), msgAndArgs...)
+	}
+
+	return true
+}
+
+func containsValue(values []compareResult, value compareResult) bool {
+	for _, v := range values {
+		if v == value {
+			return true
+		}
+	}
+
+	return false
+}
diff --git a/internal/testify/assert/assertion_compare_test.go b/internal/testify/assert/assertion_compare_test.go
new file mode 100644
index 000000000..bac3d7463
--- /dev/null
+++ b/internal/testify/assert/assertion_compare_test.go
@@ -0,0 +1,472 @@
+package assert
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"runtime"
+	"testing"
+	"time"
+)
+
+func TestCompare(t *testing.T) {
+	type customString string
+	type customInt int
+	type customInt8 int8
+	type customInt16 int16
+	type customInt32 int32
+	type customInt64 int64
+	type customUInt uint
+	type customUInt8 uint8
+	type customUInt16 uint16
+	type customUInt32 uint32
+	type customUInt64 uint64
+	type customFloat32 float32
+	type customFloat64 float64
+	type customUintptr uintptr
+	type customTime time.Time
+	type customBytes []byte
+	for _, currCase := range []struct {
+		less    interface{}
+		greater interface{}
+		cType   string
+	}{
+		{less: customString("a"), greater: customString("b"), cType: "string"},
+		{less: "a", greater: "b", cType: "string"},
+		{less: customInt(1), greater: customInt(2), cType: "int"},
+		{less: int(1), greater: int(2), cType: "int"},
+		{less: customInt8(1), greater: customInt8(2), cType: "int8"},
+		{less: int8(1), greater: int8(2), cType: "int8"},
+		{less: customInt16(1), greater: customInt16(2), cType: "int16"},
+		{less: int16(1), greater: int16(2), cType: "int16"},
+		{less: customInt32(1), greater: customInt32(2), cType: "int32"},
+		{less: int32(1), greater: int32(2), cType: "int32"},
+		{less: customInt64(1), greater: customInt64(2), cType: "int64"},
+		{less: int64(1), greater: int64(2), cType: "int64"},
+		{less: customUInt(1), greater: customUInt(2), cType: "uint"},
+		{less: uint8(1), greater: uint8(2), cType: "uint8"},
+		{less: customUInt8(1), greater: customUInt8(2), cType: "uint8"},
+		{less: uint16(1), greater: uint16(2), cType: "uint16"},
+		{less: customUInt16(1), greater: customUInt16(2), cType: "uint16"},
+		{less: uint32(1), greater: uint32(2), cType: "uint32"},
+		{less: customUInt32(1), greater: customUInt32(2), cType: "uint32"},
+		{less: uint64(1), greater: uint64(2), cType: "uint64"},
+		{less: customUInt64(1), greater: customUInt64(2), cType: "uint64"},
+		{less: float32(1.23), greater: float32(2.34), cType: "float32"},
+		{less: customFloat32(1.23), greater: customFloat32(2.23), cType: "float32"},
+		{less: float64(1.23), greater: float64(2.34), cType: "float64"},
+		{less: customFloat64(1.23), greater: customFloat64(2.34), cType: "float64"},
+		{less: uintptr(1), greater: uintptr(2), cType: "uintptr"},
+		{less: customUintptr(1), greater: customUintptr(2), cType: "uint64"},
+		{less: time.Now(), greater: time.Now().Add(time.Hour), cType: "time.Time"},
+		{less: time.Date(2024, 0, 0, 0, 0, 0, 0, time.Local), greater: time.Date(2263, 0, 0, 0, 0, 0, 0, time.Local), cType: "time.Time"},
+		{less: customTime(time.Now()), greater: customTime(time.Now().Add(time.Hour)), cType: "time.Time"},
+		{less: []byte{1, 1}, greater: []byte{1, 2}, cType: "[]byte"},
+		{less: customBytes([]byte{1, 1}), greater: customBytes([]byte{1, 2}), cType: "[]byte"},
+	} {
+		resLess, isComparable := compare(currCase.less, currCase.greater, reflect.ValueOf(currCase.less).Kind())
+		if !isComparable {
+			t.Error("object should be comparable for type " + currCase.cType)
+		}
+
+		if resLess != compareLess {
+			t.Errorf("object less (%v) should be less than greater (%v) for type "+currCase.cType,
+				currCase.less, currCase.greater)
+		}
+
+		resGreater, isComparable := compare(currCase.greater, currCase.less, reflect.ValueOf(currCase.less).Kind())
+		if !isComparable {
+			t.Error("object are comparable for type " + currCase.cType)
+		}
+
+		if resGreater != compareGreater {
+			t.Errorf("object greater should be greater than less for type " + currCase.cType)
+		}
+
+		resEqual, isComparable := compare(currCase.less, currCase.less, reflect.ValueOf(currCase.less).Kind())
+		if !isComparable {
+			t.Error("object are comparable for type " + currCase.cType)
+		}
+
+		if resEqual != 0 {
+			t.Errorf("objects should be equal for type " + currCase.cType)
+		}
+	}
+}
+
+type outputT struct {
+	buf     *bytes.Buffer
+	helpers map[string]struct{}
+}
+
+// Implements TestingT
+func (t *outputT) Errorf(format string, args ...interface{}) {
+	s := fmt.Sprintf(format, args...)
+	t.buf.WriteString(s)
+}
+
+func (t *outputT) Helper() {
+	if t.helpers == nil {
+		t.helpers = make(map[string]struct{})
+	}
+	t.helpers[callerName(1)] = struct{}{}
+}
+
+// callerName gives the function name (qualified with a package path)
+// for the caller after skip frames (where 0 means the current function).
+func callerName(skip int) string {
+	// Make room for the skip PC.
+	var pc [1]uintptr
+	n := runtime.Callers(skip+2, pc[:]) // skip + runtime.Callers + callerName
+	if n == 0 {
+		panic("testing: zero callers found")
+	}
+	frames := runtime.CallersFrames(pc[:n])
+	frame, _ := frames.Next()
+	return frame.Function
+}
+
+func TestGreater(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !Greater(mockT, 2, 1) {
+		t.Error("Greater should return true")
+	}
+
+	if Greater(mockT, 1, 1) {
+		t.Error("Greater should return false")
+	}
+
+	if Greater(mockT, 1, 2) {
+		t.Error("Greater should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		less    interface{}
+		greater interface{}
+		msg     string
+	}{
+		{less: "a", greater: "b", msg: `"a" is not greater than "b"`},
+		{less: int(1), greater: int(2), msg: `"1" is not greater than "2"`},
+		{less: int8(1), greater: int8(2), msg: `"1" is not greater than "2"`},
+		{less: int16(1), greater: int16(2), msg: `"1" is not greater than "2"`},
+		{less: int32(1), greater: int32(2), msg: `"1" is not greater than "2"`},
+		{less: int64(1), greater: int64(2), msg: `"1" is not greater than "2"`},
+		{less: uint8(1), greater: uint8(2), msg: `"1" is not greater than "2"`},
+		{less: uint16(1), greater: uint16(2), msg: `"1" is not greater than "2"`},
+		{less: uint32(1), greater: uint32(2), msg: `"1" is not greater than "2"`},
+		{less: uint64(1), greater: uint64(2), msg: `"1" is not greater than "2"`},
+		{less: float32(1.23), greater: float32(2.34), msg: `"1.23" is not greater than "2.34"`},
+		{less: float64(1.23), greater: float64(2.34), msg: `"1.23" is not greater than "2.34"`},
+		{less: uintptr(1), greater: uintptr(2), msg: `"1" is not greater than "2"`},
+		{less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 00:00:00 +0000 UTC" is not greater than "0001-01-01 01:00:00 +0000 UTC"`},
+		{less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 1]" is not greater than "[1 2]"`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, Greater(out, currCase.less, currCase.greater))
+		Contains(t, out.buf.String(), currCase.msg)
+		Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.Greater")
+	}
+}
+
+func TestGreaterOrEqual(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !GreaterOrEqual(mockT, 2, 1) {
+		t.Error("GreaterOrEqual should return true")
+	}
+
+	if !GreaterOrEqual(mockT, 1, 1) {
+		t.Error("GreaterOrEqual should return true")
+	}
+
+	if GreaterOrEqual(mockT, 1, 2) {
+		t.Error("GreaterOrEqual should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		less    interface{}
+		greater interface{}
+		msg     string
+	}{
+		{less: "a", greater: "b", msg: `"a" is not greater than or equal to "b"`},
+		{less: int(1), greater: int(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: int8(1), greater: int8(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: int16(1), greater: int16(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: int32(1), greater: int32(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: int64(1), greater: int64(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: uint8(1), greater: uint8(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: uint16(1), greater: uint16(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: uint32(1), greater: uint32(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: uint64(1), greater: uint64(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: float32(1.23), greater: float32(2.34), msg: `"1.23" is not greater than or equal to "2.34"`},
+		{less: float64(1.23), greater: float64(2.34), msg: `"1.23" is not greater than or equal to "2.34"`},
+		{less: uintptr(1), greater: uintptr(2), msg: `"1" is not greater than or equal to "2"`},
+		{less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 00:00:00 +0000 UTC" is not greater than or equal to "0001-01-01 01:00:00 +0000 UTC"`},
+		{less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 1]" is not greater than or equal to "[1 2]"`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, GreaterOrEqual(out, currCase.less, currCase.greater))
+		Contains(t, out.buf.String(), currCase.msg)
+		Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.GreaterOrEqual")
+	}
+}
+
+func TestLess(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !Less(mockT, 1, 2) {
+		t.Error("Less should return true")
+	}
+
+	if Less(mockT, 1, 1) {
+		t.Error("Less should return false")
+	}
+
+	if Less(mockT, 2, 1) {
+		t.Error("Less should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		less    interface{}
+		greater interface{}
+		msg     string
+	}{
+		{less: "a", greater: "b", msg: `"b" is not less than "a"`},
+		{less: int(1), greater: int(2), msg: `"2" is not less than "1"`},
+		{less: int8(1), greater: int8(2), msg: `"2" is not less than "1"`},
+		{less: int16(1), greater: int16(2), msg: `"2" is not less than "1"`},
+		{less: int32(1), greater: int32(2), msg: `"2" is not less than "1"`},
+		{less: int64(1), greater: int64(2), msg: `"2" is not less than "1"`},
+		{less: uint8(1), greater: uint8(2), msg: `"2" is not less than "1"`},
+		{less: uint16(1), greater: uint16(2), msg: `"2" is not less than "1"`},
+		{less: uint32(1), greater: uint32(2), msg: `"2" is not less than "1"`},
+		{less: uint64(1), greater: uint64(2), msg: `"2" is not less than "1"`},
+		{less: float32(1.23), greater: float32(2.34), msg: `"2.34" is not less than "1.23"`},
+		{less: float64(1.23), greater: float64(2.34), msg: `"2.34" is not less than "1.23"`},
+		{less: uintptr(1), greater: uintptr(2), msg: `"2" is not less than "1"`},
+		{less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 01:00:00 +0000 UTC" is not less than "0001-01-01 00:00:00 +0000 UTC"`},
+		{less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 2]" is not less than "[1 1]"`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, Less(out, currCase.greater, currCase.less))
+		Contains(t, out.buf.String(), currCase.msg)
+		Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.Less")
+	}
+}
+
+func TestLessOrEqual(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !LessOrEqual(mockT, 1, 2) {
+		t.Error("LessOrEqual should return true")
+	}
+
+	if !LessOrEqual(mockT, 1, 1) {
+		t.Error("LessOrEqual should return true")
+	}
+
+	if LessOrEqual(mockT, 2, 1) {
+		t.Error("LessOrEqual should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		less    interface{}
+		greater interface{}
+		msg     string
+	}{
+		{less: "a", greater: "b", msg: `"b" is not less than or equal to "a"`},
+		{less: int(1), greater: int(2), msg: `"2" is not less than or equal to "1"`},
+		{less: int8(1), greater: int8(2), msg: `"2" is not less than or equal to "1"`},
+		{less: int16(1), greater: int16(2), msg: `"2" is not less than or equal to "1"`},
+		{less: int32(1), greater: int32(2), msg: `"2" is not less than or equal to "1"`},
+		{less: int64(1), greater: int64(2), msg: `"2" is not less than or equal to "1"`},
+		{less: uint8(1), greater: uint8(2), msg: `"2" is not less than or equal to "1"`},
+		{less: uint16(1), greater: uint16(2), msg: `"2" is not less than or equal to "1"`},
+		{less: uint32(1), greater: uint32(2), msg: `"2" is not less than or equal to "1"`},
+		{less: uint64(1), greater: uint64(2), msg: `"2" is not less than or equal to "1"`},
+		{less: float32(1.23), greater: float32(2.34), msg: `"2.34" is not less than or equal to "1.23"`},
+		{less: float64(1.23), greater: float64(2.34), msg: `"2.34" is not less than or equal to "1.23"`},
+		{less: uintptr(1), greater: uintptr(2), msg: `"2" is not less than or equal to "1"`},
+		{less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 01:00:00 +0000 UTC" is not less than or equal to "0001-01-01 00:00:00 +0000 UTC"`},
+		{less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 2]" is not less than or equal to "[1 1]"`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, LessOrEqual(out, currCase.greater, currCase.less))
+		Contains(t, out.buf.String(), currCase.msg)
+		Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.LessOrEqual")
+	}
+}
+
+func TestPositive(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !Positive(mockT, 1) {
+		t.Error("Positive should return true")
+	}
+
+	if !Positive(mockT, 1.23) {
+		t.Error("Positive should return true")
+	}
+
+	if Positive(mockT, -1) {
+		t.Error("Positive should return false")
+	}
+
+	if Positive(mockT, -1.23) {
+		t.Error("Positive should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		e   interface{}
+		msg string
+	}{
+		{e: int(-1), msg: `"-1" is not positive`},
+		{e: int8(-1), msg: `"-1" is not positive`},
+		{e: int16(-1), msg: `"-1" is not positive`},
+		{e: int32(-1), msg: `"-1" is not positive`},
+		{e: int64(-1), msg: `"-1" is not positive`},
+		{e: float32(-1.23), msg: `"-1.23" is not positive`},
+		{e: float64(-1.23), msg: `"-1.23" is not positive`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, Positive(out, currCase.e))
+		Contains(t, out.buf.String(), currCase.msg)
+		Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.Positive")
+	}
+}
+
+func TestNegative(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !Negative(mockT, -1) {
+		t.Error("Negative should return true")
+	}
+
+	if !Negative(mockT, -1.23) {
+		t.Error("Negative should return true")
+	}
+
+	if Negative(mockT, 1) {
+		t.Error("Negative should return false")
+	}
+
+	if Negative(mockT, 1.23) {
+		t.Error("Negative should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		e   interface{}
+		msg string
+	}{
+		{e: int(1), msg: `"1" is not negative`},
+		{e: int8(1), msg: `"1" is not negative`},
+		{e: int16(1), msg: `"1" is not negative`},
+		{e: int32(1), msg: `"1" is not negative`},
+		{e: int64(1), msg: `"1" is not negative`},
+		{e: float32(1.23), msg: `"1.23" is not negative`},
+		{e: float64(1.23), msg: `"1.23" is not negative`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, Negative(out, currCase.e))
+		Contains(t, out.buf.String(), currCase.msg)
+		Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.Negative")
+	}
+}
+
+func Test_compareTwoValuesDifferentValuesTypes(t *testing.T) {
+	mockT := new(testing.T)
+
+	for _, currCase := range []struct {
+		v1            interface{}
+		v2            interface{}
+		compareResult bool
+	}{
+		{v1: 123, v2: "abc"},
+		{v1: "abc", v2: 123456},
+		{v1: float64(12), v2: "123"},
+		{v1: "float(12)", v2: float64(1)},
+	} {
+		result := compareTwoValues(mockT, currCase.v1, currCase.v2, []compareResult{compareLess, compareEqual, compareGreater}, "testFailMessage")
+		False(t, result)
+	}
+}
+
+func Test_compareTwoValuesNotComparableValues(t *testing.T) {
+	mockT := new(testing.T)
+
+	type CompareStruct struct {
+	}
+
+	for _, currCase := range []struct {
+		v1 interface{}
+		v2 interface{}
+	}{
+		{v1: CompareStruct{}, v2: CompareStruct{}},
+		{v1: map[string]int{}, v2: map[string]int{}},
+		{v1: make([]int, 5), v2: make([]int, 5)},
+	} {
+		result := compareTwoValues(mockT, currCase.v1, currCase.v2, []compareResult{compareLess, compareEqual, compareGreater}, "testFailMessage")
+		False(t, result)
+	}
+}
+
+func Test_compareTwoValuesCorrectCompareResult(t *testing.T) {
+	mockT := new(testing.T)
+
+	for _, currCase := range []struct {
+		v1             interface{}
+		v2             interface{}
+		allowedResults []compareResult
+	}{
+		{v1: 1, v2: 2, allowedResults: []compareResult{compareLess}},
+		{v1: 1, v2: 2, allowedResults: []compareResult{compareLess, compareEqual}},
+		{v1: 2, v2: 2, allowedResults: []compareResult{compareGreater, compareEqual}},
+		{v1: 2, v2: 2, allowedResults: []compareResult{compareEqual}},
+		{v1: 2, v2: 1, allowedResults: []compareResult{compareEqual, compareGreater}},
+		{v1: 2, v2: 1, allowedResults: []compareResult{compareGreater}},
+	} {
+		result := compareTwoValues(mockT, currCase.v1, currCase.v2, currCase.allowedResults, "testFailMessage")
+		True(t, result)
+	}
+}
+
+func Test_containsValue(t *testing.T) {
+	for _, currCase := range []struct {
+		values []compareResult
+		value  compareResult
+		result bool
+	}{
+		{values: []compareResult{compareGreater}, value: compareGreater, result: true},
+		{values: []compareResult{compareGreater, compareLess}, value: compareGreater, result: true},
+		{values: []compareResult{compareGreater, compareLess}, value: compareLess, result: true},
+		{values: []compareResult{compareGreater, compareLess}, value: compareEqual, result: false},
+	} {
+		result := containsValue(currCase.values, currCase.value)
+		Equal(t, currCase.result, result)
+	}
+}
+
+func TestComparingMsgAndArgsForwarding(t *testing.T) {
+	msgAndArgs := []interface{}{"format %s %x", "this", 0xc001}
+	expectedOutput := "format this c001\n"
+	funcs := []func(t TestingT){
+		func(t TestingT) { Greater(t, 1, 2, msgAndArgs...) },
+		func(t TestingT) { GreaterOrEqual(t, 1, 2, msgAndArgs...) },
+		func(t TestingT) { Less(t, 2, 1, msgAndArgs...) },
+		func(t TestingT) { LessOrEqual(t, 2, 1, msgAndArgs...) },
+		func(t TestingT) { Positive(t, 0, msgAndArgs...) },
+		func(t TestingT) { Negative(t, 0, msgAndArgs...) },
+	}
+	for _, f := range funcs {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		f(out)
+		Contains(t, out.buf.String(), expectedOutput)
+	}
+}
diff --git a/internal/testify/assert/assertion_format.go b/internal/testify/assert/assertion_format.go
new file mode 100644
index 000000000..dcc01f098
--- /dev/null
+++ b/internal/testify/assert/assertion_format.go
@@ -0,0 +1,807 @@
+// Code generated with github.com/expr-lang/expr/internal/_codegen; DO NOT EDIT.
+
+package assert
+
+import (
+	http "net/http"
+	url "net/url"
+	time "time"
+)
+
+// Conditionf uses a Comparison to assert a complex condition.
+func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Condition(t, comp, append([]interface{}{msg}, args...)...)
+}
+
+// Containsf asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//	assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
+//	assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
+//	assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
+func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Contains(t, s, contains, append([]interface{}{msg}, args...)...)
+}
+
+// DirExistsf checks whether a directory exists in the given path. It also fails
+// if the path is a file rather a directory or there is an error checking whether it exists.
+func DirExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return DirExists(t, path, append([]interface{}{msg}, args...)...)
+}
+
+// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
+// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
+// the number of appearances of each of them in both lists should match.
+//
+// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
+func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return ElementsMatch(t, listA, listB, append([]interface{}{msg}, args...)...)
+}
+
+// Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	assert.Emptyf(t, obj, "error message %s", "formatted")
+func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Empty(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// Equalf asserts that two objects are equal.
+//
+//	assert.Equalf(t, 123, 123, "error message %s", "formatted")
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Equal(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//	actualObj, err := SomeFunction()
+//	assert.EqualErrorf(t, err,  expectedErrorString, "error message %s", "formatted")
+func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...)
+}
+
+// EqualExportedValuesf asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+//	 type S struct {
+//		Exported     	int
+//		notExported   	int
+//	 }
+//	 assert.EqualExportedValuesf(t, S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
+//	 assert.EqualExportedValuesf(t, S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
+func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return EqualExportedValues(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// EqualValuesf asserts that two objects are equal or convertible to the same types
+// and equal.
+//
+//	assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
+func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// Errorf asserts that a function returned an error (i.e. not `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if assert.Errorf(t, err, "error message %s", "formatted") {
+//		   assert.Equal(t, expectedErrorf, err)
+//	  }
+func Errorf(t TestingT, err error, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Error(t, err, append([]interface{}{msg}, args...)...)
+}
+
+// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
+// This is a wrapper for errors.As.
+func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return ErrorAs(t, err, target, append([]interface{}{msg}, args...)...)
+}
+
+// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
+// and that the error contains the specified substring.
+//
+//	actualObj, err := SomeFunction()
+//	assert.ErrorContainsf(t, err,  expectedErrorSubString, "error message %s", "formatted")
+func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return ErrorContains(t, theError, contains, append([]interface{}{msg}, args...)...)
+}
+
+// ErrorIsf asserts that at least one of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return ErrorIs(t, err, target, append([]interface{}{msg}, args...)...)
+}
+
+// Eventuallyf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick.
+//
+//	assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Eventually(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
+}
+
+// EventuallyWithTf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+//	externalValue := false
+//	go func() {
+//		time.Sleep(8*time.Second)
+//		externalValue = true
+//	}()
+//	assert.EventuallyWithTf(t, func(c *assert.CollectT, "error message %s", "formatted") {
+//		// add assertions as needed; any assertion failure will fail the current tick
+//		assert.True(c, externalValue, "expected 'externalValue' to be true")
+//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+func EventuallyWithTf(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return EventuallyWithT(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
+}
+
+// Exactlyf asserts that two objects are equal in value and type.
+//
+//	assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
+func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Exactly(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// Failf reports a failure through
+func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Fail(t, failureMessage, append([]interface{}{msg}, args...)...)
+}
+
+// FailNowf fails test
+func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return FailNow(t, failureMessage, append([]interface{}{msg}, args...)...)
+}
+
+// Falsef asserts that the specified value is false.
+//
+//	assert.Falsef(t, myBool, "error message %s", "formatted")
+func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return False(t, value, append([]interface{}{msg}, args...)...)
+}
+
+// FileExistsf checks whether a file exists in the given path. It also fails if
+// the path points to a directory or there is an error when trying to check the file.
+func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return FileExists(t, path, append([]interface{}{msg}, args...)...)
+}
+
+// Greaterf asserts that the first element is greater than the second
+//
+//	assert.Greaterf(t, 2, 1, "error message %s", "formatted")
+//	assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
+//	assert.Greaterf(t, "b", "a", "error message %s", "formatted")
+func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Greater(t, e1, e2, append([]interface{}{msg}, args...)...)
+}
+
+// GreaterOrEqualf asserts that the first element is greater than or equal to the second
+//
+//	assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
+//	assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
+//	assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
+//	assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
+func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return GreaterOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...)
+}
+
+// HTTPBodyContainsf asserts that a specified handler returns a
+// body that contains a string.
+//
+//	assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPBodyContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...)
+}
+
+// HTTPBodyNotContainsf asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//	assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPBodyNotContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...)
+}
+
+// HTTPErrorf asserts that a specified handler returns an error status code.
+//
+//	assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPError(t, handler, method, url, values, append([]interface{}{msg}, args...)...)
+}
+
+// HTTPRedirectf asserts that a specified handler returns a redirect status code.
+//
+//	assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPRedirect(t, handler, method, url, values, append([]interface{}{msg}, args...)...)
+}
+
+// HTTPStatusCodef asserts that a specified handler returns a specified status code.
+//
+//	assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPStatusCode(t, handler, method, url, values, statuscode, append([]interface{}{msg}, args...)...)
+}
+
+// HTTPSuccessf asserts that a specified handler returns a success status code.
+//
+//	assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPSuccess(t, handler, method, url, values, append([]interface{}{msg}, args...)...)
+}
+
+// Implementsf asserts that an object is implemented by the specified interface.
+//
+//	assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Implements(t, interfaceObject, object, append([]interface{}{msg}, args...)...)
+}
+
+// InDeltaf asserts that the two numerals are within delta of each other.
+//
+//	assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
+func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return InDelta(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
+}
+
+// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
+func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return InDeltaMapValues(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
+}
+
+// InDeltaSlicef is the same as InDelta, except it compares two slices.
+func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return InDeltaSlice(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
+}
+
+// InEpsilonf asserts that expected and actual have a relative error less than epsilon
+func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return InEpsilon(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
+}
+
+// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
+func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return InEpsilonSlice(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
+}
+
+// IsDecreasingf asserts that the collection is decreasing
+//
+//	assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
+//	assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
+//	assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsDecreasing(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// IsIncreasingf asserts that the collection is increasing
+//
+//	assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
+//	assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
+//	assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsIncreasing(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// IsNonDecreasingf asserts that the collection is not decreasing
+//
+//	assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
+//	assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
+//	assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsNonDecreasing(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// IsNonIncreasingf asserts that the collection is not increasing
+//
+//	assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
+//	assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
+//	assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsNonIncreasing(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// IsTypef asserts that the specified objects are of the same type.
+func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsType(t, expectedType, object, append([]interface{}{msg}, args...)...)
+}
+
+// JSONEqf asserts that two JSON strings are equivalent.
+//
+//	assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// Lenf asserts that the specified object has specific length.
+// Lenf also fails if the object has a type that len() not accept.
+//
+//	assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
+func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Len(t, object, length, append([]interface{}{msg}, args...)...)
+}
+
+// Lessf asserts that the first element is less than the second
+//
+//	assert.Lessf(t, 1, 2, "error message %s", "formatted")
+//	assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
+//	assert.Lessf(t, "a", "b", "error message %s", "formatted")
+func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Less(t, e1, e2, append([]interface{}{msg}, args...)...)
+}
+
+// LessOrEqualf asserts that the first element is less than or equal to the second
+//
+//	assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
+//	assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
+//	assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
+//	assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
+func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return LessOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...)
+}
+
+// Negativef asserts that the specified element is negative
+//
+//	assert.Negativef(t, -1, "error message %s", "formatted")
+//	assert.Negativef(t, -1.23, "error message %s", "formatted")
+func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Negative(t, e, append([]interface{}{msg}, args...)...)
+}
+
+// Neverf asserts that the given condition doesn't satisfy in waitFor time,
+// periodically checking the target function each tick.
+//
+//	assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Never(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
+}
+
+// Nilf asserts that the specified object is nil.
+//
+//	assert.Nilf(t, err, "error message %s", "formatted")
+func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Nil(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// NoDirExistsf checks whether a directory does not exist in the given path.
+// It fails if the path points to an existing _directory_ only.
+func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NoDirExists(t, path, append([]interface{}{msg}, args...)...)
+}
+
+// NoErrorf asserts that a function returned no error (i.e. `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if assert.NoErrorf(t, err, "error message %s", "formatted") {
+//		   assert.Equal(t, expectedObj, actualObj)
+//	  }
+func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NoError(t, err, append([]interface{}{msg}, args...)...)
+}
+
+// NoFileExistsf checks whether a file does not exist in a given path. It fails
+// if the path points to an existing _file_ only.
+func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NoFileExists(t, path, append([]interface{}{msg}, args...)...)
+}
+
+// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//	assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
+//	assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
+//	assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
+func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotContains(t, s, contains, append([]interface{}{msg}, args...)...)
+}
+
+// NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
+//	  assert.Equal(t, "two", obj[1])
+//	}
+func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotEmpty(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// NotEqualf asserts that the specified values are NOT equal.
+//
+//	assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotEqual(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
+//
+//	assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
+func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotEqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// NotErrorIsf asserts that at none of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotErrorIs(t, err, target, append([]interface{}{msg}, args...)...)
+}
+
+// NotImplementsf asserts that an object does not implement the specified interface.
+//
+//	assert.NotImplementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func NotImplementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotImplements(t, interfaceObject, object, append([]interface{}{msg}, args...)...)
+}
+
+// NotNilf asserts that the specified object is not nil.
+//
+//	assert.NotNilf(t, err, "error message %s", "formatted")
+func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotNil(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//	assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
+func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotPanics(t, f, append([]interface{}{msg}, args...)...)
+}
+
+// NotRegexpf asserts that a specified regexp does not match a string.
+//
+//	assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
+//	assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
+func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotRegexp(t, rx, str, append([]interface{}{msg}, args...)...)
+}
+
+// NotSamef asserts that two pointers do not reference the same object.
+//
+//	assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotSame(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
+//
+//	assert.NotSubsetf(t, [1, 3, 4], [1, 2], "error message %s", "formatted")
+//	assert.NotSubsetf(t, {"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
+func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotSubset(t, list, subset, append([]interface{}{msg}, args...)...)
+}
+
+// NotZerof asserts that i is not the zero value for its type.
+func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotZero(t, i, append([]interface{}{msg}, args...)...)
+}
+
+// Panicsf asserts that the code inside the specified PanicTestFunc panics.
+//
+//	assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
+func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Panics(t, f, append([]interface{}{msg}, args...)...)
+}
+
+// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
+// panics, and that the recovered panic value is an error that satisfies the
+// EqualError comparison.
+//
+//	assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return PanicsWithError(t, errString, f, append([]interface{}{msg}, args...)...)
+}
+
+// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//	assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return PanicsWithValue(t, expected, f, append([]interface{}{msg}, args...)...)
+}
+
+// Positivef asserts that the specified element is positive
+//
+//	assert.Positivef(t, 1, "error message %s", "formatted")
+//	assert.Positivef(t, 1.23, "error message %s", "formatted")
+func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Positive(t, e, append([]interface{}{msg}, args...)...)
+}
+
+// Regexpf asserts that a specified regexp matches a string.
+//
+//	assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
+//	assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
+func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Regexp(t, rx, str, append([]interface{}{msg}, args...)...)
+}
+
+// Samef asserts that two pointers reference the same object.
+//
+//	assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func Samef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Same(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// Subsetf asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
+//
+//	assert.Subsetf(t, [1, 2, 3], [1, 2], "error message %s", "formatted")
+//	assert.Subsetf(t, {"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
+func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Subset(t, list, subset, append([]interface{}{msg}, args...)...)
+}
+
+// Truef asserts that the specified value is true.
+//
+//	assert.Truef(t, myBool, "error message %s", "formatted")
+func Truef(t TestingT, value bool, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return True(t, value, append([]interface{}{msg}, args...)...)
+}
+
+// WithinDurationf asserts that the two times are within duration delta of each other.
+//
+//	assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
+}
+
+// WithinRangef asserts that a time is within a time range (inclusive).
+//
+//	assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
+func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return WithinRange(t, actual, start, end, append([]interface{}{msg}, args...)...)
+}
+
+// Zerof asserts that i is the zero value for its type.
+func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Zero(t, i, append([]interface{}{msg}, args...)...)
+}
diff --git a/internal/testify/assert/assertion_format.go.tmpl b/internal/testify/assert/assertion_format.go.tmpl
new file mode 100644
index 000000000..d2bb0b817
--- /dev/null
+++ b/internal/testify/assert/assertion_format.go.tmpl
@@ -0,0 +1,5 @@
+{{.CommentFormat}}
+func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool {
+	if h, ok := t.(tHelper); ok { h.Helper() }
+	return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}})
+}
diff --git a/internal/testify/assert/assertion_forward.go b/internal/testify/assert/assertion_forward.go
new file mode 100644
index 000000000..c498c9d43
--- /dev/null
+++ b/internal/testify/assert/assertion_forward.go
@@ -0,0 +1,1605 @@
+// Code generated with github.com/expr-lang/expr/internal/_codegen; DO NOT EDIT.
+
+package assert
+
+import (
+	http "net/http"
+	url "net/url"
+	time "time"
+)
+
+// Condition uses a Comparison to assert a complex condition.
+func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Condition(a.t, comp, msgAndArgs...)
+}
+
+// Conditionf uses a Comparison to assert a complex condition.
+func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Conditionf(a.t, comp, msg, args...)
+}
+
+// Contains asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//	a.Contains("Hello World", "World")
+//	a.Contains(["Hello", "World"], "World")
+//	a.Contains({"Hello": "World"}, "Hello")
+func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Contains(a.t, s, contains, msgAndArgs...)
+}
+
+// Containsf asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//	a.Containsf("Hello World", "World", "error message %s", "formatted")
+//	a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
+//	a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
+func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Containsf(a.t, s, contains, msg, args...)
+}
+
+// DirExists checks whether a directory exists in the given path. It also fails
+// if the path is a file rather a directory or there is an error checking whether it exists.
+func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return DirExists(a.t, path, msgAndArgs...)
+}
+
+// DirExistsf checks whether a directory exists in the given path. It also fails
+// if the path is a file rather a directory or there is an error checking whether it exists.
+func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return DirExistsf(a.t, path, msg, args...)
+}
+
+// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
+// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
+// the number of appearances of each of them in both lists should match.
+//
+// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2])
+func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return ElementsMatch(a.t, listA, listB, msgAndArgs...)
+}
+
+// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
+// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
+// the number of appearances of each of them in both lists should match.
+//
+// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
+func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return ElementsMatchf(a.t, listA, listB, msg, args...)
+}
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	a.Empty(obj)
+func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Empty(a.t, object, msgAndArgs...)
+}
+
+// Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	a.Emptyf(obj, "error message %s", "formatted")
+func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Emptyf(a.t, object, msg, args...)
+}
+
+// Equal asserts that two objects are equal.
+//
+//	a.Equal(123, 123)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Equal(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//	actualObj, err := SomeFunction()
+//	a.EqualError(err,  expectedErrorString)
+func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return EqualError(a.t, theError, errString, msgAndArgs...)
+}
+
+// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//	actualObj, err := SomeFunction()
+//	a.EqualErrorf(err,  expectedErrorString, "error message %s", "formatted")
+func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return EqualErrorf(a.t, theError, errString, msg, args...)
+}
+
+// EqualExportedValues asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+//	 type S struct {
+//		Exported     	int
+//		notExported   	int
+//	 }
+//	 a.EqualExportedValues(S{1, 2}, S{1, 3}) => true
+//	 a.EqualExportedValues(S{1, 2}, S{2, 3}) => false
+func (a *Assertions) EqualExportedValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return EqualExportedValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualExportedValuesf asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+//	 type S struct {
+//		Exported     	int
+//		notExported   	int
+//	 }
+//	 a.EqualExportedValuesf(S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
+//	 a.EqualExportedValuesf(S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
+func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return EqualExportedValuesf(a.t, expected, actual, msg, args...)
+}
+
+// EqualValues asserts that two objects are equal or convertible to the same types
+// and equal.
+//
+//	a.EqualValues(uint32(123), int32(123))
+func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return EqualValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualValuesf asserts that two objects are equal or convertible to the same types
+// and equal.
+//
+//	a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
+func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return EqualValuesf(a.t, expected, actual, msg, args...)
+}
+
+// Equalf asserts that two objects are equal.
+//
+//	a.Equalf(123, 123, "error message %s", "formatted")
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Equalf(a.t, expected, actual, msg, args...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if a.Error(err) {
+//		   assert.Equal(t, expectedError, err)
+//	  }
+func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Error(a.t, err, msgAndArgs...)
+}
+
+// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
+// This is a wrapper for errors.As.
+func (a *Assertions) ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return ErrorAs(a.t, err, target, msgAndArgs...)
+}
+
+// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
+// This is a wrapper for errors.As.
+func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return ErrorAsf(a.t, err, target, msg, args...)
+}
+
+// ErrorContains asserts that a function returned an error (i.e. not `nil`)
+// and that the error contains the specified substring.
+//
+//	actualObj, err := SomeFunction()
+//	a.ErrorContains(err,  expectedErrorSubString)
+func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return ErrorContains(a.t, theError, contains, msgAndArgs...)
+}
+
+// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
+// and that the error contains the specified substring.
+//
+//	actualObj, err := SomeFunction()
+//	a.ErrorContainsf(err,  expectedErrorSubString, "error message %s", "formatted")
+func (a *Assertions) ErrorContainsf(theError error, contains string, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return ErrorContainsf(a.t, theError, contains, msg, args...)
+}
+
+// ErrorIs asserts that at least one of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func (a *Assertions) ErrorIs(err error, target error, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return ErrorIs(a.t, err, target, msgAndArgs...)
+}
+
+// ErrorIsf asserts that at least one of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return ErrorIsf(a.t, err, target, msg, args...)
+}
+
+// Errorf asserts that a function returned an error (i.e. not `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if a.Errorf(err, "error message %s", "formatted") {
+//		   assert.Equal(t, expectedErrorf, err)
+//	  }
+func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Errorf(a.t, err, msg, args...)
+}
+
+// Eventually asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick.
+//
+//	a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
+func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
+}
+
+// EventuallyWithT asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+//	externalValue := false
+//	go func() {
+//		time.Sleep(8*time.Second)
+//		externalValue = true
+//	}()
+//	a.EventuallyWithT(func(c *assert.CollectT) {
+//		// add assertions as needed; any assertion failure will fail the current tick
+//		assert.True(c, externalValue, "expected 'externalValue' to be true")
+//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+func (a *Assertions) EventuallyWithT(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return EventuallyWithT(a.t, condition, waitFor, tick, msgAndArgs...)
+}
+
+// EventuallyWithTf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+//	externalValue := false
+//	go func() {
+//		time.Sleep(8*time.Second)
+//		externalValue = true
+//	}()
+//	a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
+//		// add assertions as needed; any assertion failure will fail the current tick
+//		assert.True(c, externalValue, "expected 'externalValue' to be true")
+//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+func (a *Assertions) EventuallyWithTf(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return EventuallyWithTf(a.t, condition, waitFor, tick, msg, args...)
+}
+
+// Eventuallyf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick.
+//
+//	a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Eventuallyf(a.t, condition, waitFor, tick, msg, args...)
+}
+
+// Exactly asserts that two objects are equal in value and type.
+//
+//	a.Exactly(int32(123), int64(123))
+func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Exactly(a.t, expected, actual, msgAndArgs...)
+}
+
+// Exactlyf asserts that two objects are equal in value and type.
+//
+//	a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
+func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Exactlyf(a.t, expected, actual, msg, args...)
+}
+
+// Fail reports a failure through
+func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Fail(a.t, failureMessage, msgAndArgs...)
+}
+
+// FailNow fails test
+func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return FailNow(a.t, failureMessage, msgAndArgs...)
+}
+
+// FailNowf fails test
+func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return FailNowf(a.t, failureMessage, msg, args...)
+}
+
+// Failf reports a failure through
+func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Failf(a.t, failureMessage, msg, args...)
+}
+
+// False asserts that the specified value is false.
+//
+//	a.False(myBool)
+func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return False(a.t, value, msgAndArgs...)
+}
+
+// Falsef asserts that the specified value is false.
+//
+//	a.Falsef(myBool, "error message %s", "formatted")
+func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Falsef(a.t, value, msg, args...)
+}
+
+// FileExists checks whether a file exists in the given path. It also fails if
+// the path points to a directory or there is an error when trying to check the file.
+func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return FileExists(a.t, path, msgAndArgs...)
+}
+
+// FileExistsf checks whether a file exists in the given path. It also fails if
+// the path points to a directory or there is an error when trying to check the file.
+func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return FileExistsf(a.t, path, msg, args...)
+}
+
+// Greater asserts that the first element is greater than the second
+//
+//	a.Greater(2, 1)
+//	a.Greater(float64(2), float64(1))
+//	a.Greater("b", "a")
+func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Greater(a.t, e1, e2, msgAndArgs...)
+}
+
+// GreaterOrEqual asserts that the first element is greater than or equal to the second
+//
+//	a.GreaterOrEqual(2, 1)
+//	a.GreaterOrEqual(2, 2)
+//	a.GreaterOrEqual("b", "a")
+//	a.GreaterOrEqual("b", "b")
+func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return GreaterOrEqual(a.t, e1, e2, msgAndArgs...)
+}
+
+// GreaterOrEqualf asserts that the first element is greater than or equal to the second
+//
+//	a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
+//	a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
+//	a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
+//	a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
+func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return GreaterOrEqualf(a.t, e1, e2, msg, args...)
+}
+
+// Greaterf asserts that the first element is greater than the second
+//
+//	a.Greaterf(2, 1, "error message %s", "formatted")
+//	a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
+//	a.Greaterf("b", "a", "error message %s", "formatted")
+func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Greaterf(a.t, e1, e2, msg, args...)
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//	a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...)
+}
+
+// HTTPBodyContainsf asserts that a specified handler returns a
+// body that contains a string.
+//
+//	a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...)
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//	a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...)
+}
+
+// HTTPBodyNotContainsf asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//	a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...)
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//	a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPError(a.t, handler, method, url, values, msgAndArgs...)
+}
+
+// HTTPErrorf asserts that a specified handler returns an error status code.
+//
+//	a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPErrorf(a.t, handler, method, url, values, msg, args...)
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//	a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...)
+}
+
+// HTTPRedirectf asserts that a specified handler returns a redirect status code.
+//
+//	a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPRedirectf(a.t, handler, method, url, values, msg, args...)
+}
+
+// HTTPStatusCode asserts that a specified handler returns a specified status code.
+//
+//	a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPStatusCode(a.t, handler, method, url, values, statuscode, msgAndArgs...)
+}
+
+// HTTPStatusCodef asserts that a specified handler returns a specified status code.
+//
+//	a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPStatusCodef(a.t, handler, method, url, values, statuscode, msg, args...)
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//	a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...)
+}
+
+// HTTPSuccessf asserts that a specified handler returns a success status code.
+//
+//	a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return HTTPSuccessf(a.t, handler, method, url, values, msg, args...)
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+//	a.Implements((*MyInterface)(nil), new(MyObject))
+func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Implements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// Implementsf asserts that an object is implemented by the specified interface.
+//
+//	a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Implementsf(a.t, interfaceObject, object, msg, args...)
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+//	a.InDelta(math.Pi, 22/7.0, 0.01)
+func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InDelta(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
+func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
+func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...)
+}
+
+// InDeltaSlice is the same as InDelta, except it compares two slices.
+func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDeltaSlicef is the same as InDelta, except it compares two slices.
+func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InDeltaSlicef(a.t, expected, actual, delta, msg, args...)
+}
+
+// InDeltaf asserts that the two numerals are within delta of each other.
+//
+//	a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
+func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InDeltaf(a.t, expected, actual, delta, msg, args...)
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
+func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
+func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...)
+}
+
+// InEpsilonf asserts that expected and actual have a relative error less than epsilon
+func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return InEpsilonf(a.t, expected, actual, epsilon, msg, args...)
+}
+
+// IsDecreasing asserts that the collection is decreasing
+//
+//	a.IsDecreasing([]int{2, 1, 0})
+//	a.IsDecreasing([]float{2, 1})
+//	a.IsDecreasing([]string{"b", "a"})
+func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsDecreasing(a.t, object, msgAndArgs...)
+}
+
+// IsDecreasingf asserts that the collection is decreasing
+//
+//	a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
+//	a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
+//	a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
+func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsDecreasingf(a.t, object, msg, args...)
+}
+
+// IsIncreasing asserts that the collection is increasing
+//
+//	a.IsIncreasing([]int{1, 2, 3})
+//	a.IsIncreasing([]float{1, 2})
+//	a.IsIncreasing([]string{"a", "b"})
+func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsIncreasing(a.t, object, msgAndArgs...)
+}
+
+// IsIncreasingf asserts that the collection is increasing
+//
+//	a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
+//	a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
+//	a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
+func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsIncreasingf(a.t, object, msg, args...)
+}
+
+// IsNonDecreasing asserts that the collection is not decreasing
+//
+//	a.IsNonDecreasing([]int{1, 1, 2})
+//	a.IsNonDecreasing([]float{1, 2})
+//	a.IsNonDecreasing([]string{"a", "b"})
+func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsNonDecreasing(a.t, object, msgAndArgs...)
+}
+
+// IsNonDecreasingf asserts that the collection is not decreasing
+//
+//	a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
+//	a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
+//	a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
+func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsNonDecreasingf(a.t, object, msg, args...)
+}
+
+// IsNonIncreasing asserts that the collection is not increasing
+//
+//	a.IsNonIncreasing([]int{2, 1, 1})
+//	a.IsNonIncreasing([]float{2, 1})
+//	a.IsNonIncreasing([]string{"b", "a"})
+func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsNonIncreasing(a.t, object, msgAndArgs...)
+}
+
+// IsNonIncreasingf asserts that the collection is not increasing
+//
+//	a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
+//	a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
+//	a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
+func (a *Assertions) IsNonIncreasingf(object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsNonIncreasingf(a.t, object, msg, args...)
+}
+
+// IsType asserts that the specified objects are of the same type.
+func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsType(a.t, expectedType, object, msgAndArgs...)
+}
+
+// IsTypef asserts that the specified objects are of the same type.
+func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return IsTypef(a.t, expectedType, object, msg, args...)
+}
+
+// JSONEq asserts that two JSON strings are equivalent.
+//
+//	a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return JSONEq(a.t, expected, actual, msgAndArgs...)
+}
+
+// JSONEqf asserts that two JSON strings are equivalent.
+//
+//	a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return JSONEqf(a.t, expected, actual, msg, args...)
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+//	a.Len(mySlice, 3)
+func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Len(a.t, object, length, msgAndArgs...)
+}
+
+// Lenf asserts that the specified object has specific length.
+// Lenf also fails if the object has a type that len() not accept.
+//
+//	a.Lenf(mySlice, 3, "error message %s", "formatted")
+func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Lenf(a.t, object, length, msg, args...)
+}
+
+// Less asserts that the first element is less than the second
+//
+//	a.Less(1, 2)
+//	a.Less(float64(1), float64(2))
+//	a.Less("a", "b")
+func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Less(a.t, e1, e2, msgAndArgs...)
+}
+
+// LessOrEqual asserts that the first element is less than or equal to the second
+//
+//	a.LessOrEqual(1, 2)
+//	a.LessOrEqual(2, 2)
+//	a.LessOrEqual("a", "b")
+//	a.LessOrEqual("b", "b")
+func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return LessOrEqual(a.t, e1, e2, msgAndArgs...)
+}
+
+// LessOrEqualf asserts that the first element is less than or equal to the second
+//
+//	a.LessOrEqualf(1, 2, "error message %s", "formatted")
+//	a.LessOrEqualf(2, 2, "error message %s", "formatted")
+//	a.LessOrEqualf("a", "b", "error message %s", "formatted")
+//	a.LessOrEqualf("b", "b", "error message %s", "formatted")
+func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return LessOrEqualf(a.t, e1, e2, msg, args...)
+}
+
+// Lessf asserts that the first element is less than the second
+//
+//	a.Lessf(1, 2, "error message %s", "formatted")
+//	a.Lessf(float64(1), float64(2), "error message %s", "formatted")
+//	a.Lessf("a", "b", "error message %s", "formatted")
+func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Lessf(a.t, e1, e2, msg, args...)
+}
+
+// Negative asserts that the specified element is negative
+//
+//	a.Negative(-1)
+//	a.Negative(-1.23)
+func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Negative(a.t, e, msgAndArgs...)
+}
+
+// Negativef asserts that the specified element is negative
+//
+//	a.Negativef(-1, "error message %s", "formatted")
+//	a.Negativef(-1.23, "error message %s", "formatted")
+func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Negativef(a.t, e, msg, args...)
+}
+
+// Never asserts that the given condition doesn't satisfy in waitFor time,
+// periodically checking the target function each tick.
+//
+//	a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
+func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Never(a.t, condition, waitFor, tick, msgAndArgs...)
+}
+
+// Neverf asserts that the given condition doesn't satisfy in waitFor time,
+// periodically checking the target function each tick.
+//
+//	a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Neverf(a.t, condition, waitFor, tick, msg, args...)
+}
+
+// Nil asserts that the specified object is nil.
+//
+//	a.Nil(err)
+func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Nil(a.t, object, msgAndArgs...)
+}
+
+// Nilf asserts that the specified object is nil.
+//
+//	a.Nilf(err, "error message %s", "formatted")
+func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Nilf(a.t, object, msg, args...)
+}
+
+// NoDirExists checks whether a directory does not exist in the given path.
+// It fails if the path points to an existing _directory_ only.
+func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NoDirExists(a.t, path, msgAndArgs...)
+}
+
+// NoDirExistsf checks whether a directory does not exist in the given path.
+// It fails if the path points to an existing _directory_ only.
+func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NoDirExistsf(a.t, path, msg, args...)
+}
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if a.NoError(err) {
+//		   assert.Equal(t, expectedObj, actualObj)
+//	  }
+func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NoError(a.t, err, msgAndArgs...)
+}
+
+// NoErrorf asserts that a function returned no error (i.e. `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if a.NoErrorf(err, "error message %s", "formatted") {
+//		   assert.Equal(t, expectedObj, actualObj)
+//	  }
+func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NoErrorf(a.t, err, msg, args...)
+}
+
+// NoFileExists checks whether a file does not exist in a given path. It fails
+// if the path points to an existing _file_ only.
+func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NoFileExists(a.t, path, msgAndArgs...)
+}
+
+// NoFileExistsf checks whether a file does not exist in a given path. It fails
+// if the path points to an existing _file_ only.
+func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NoFileExistsf(a.t, path, msg, args...)
+}
+
+// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//	a.NotContains("Hello World", "Earth")
+//	a.NotContains(["Hello", "World"], "Earth")
+//	a.NotContains({"Hello": "World"}, "Earth")
+func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotContains(a.t, s, contains, msgAndArgs...)
+}
+
+// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//	a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
+//	a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
+//	a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
+func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotContainsf(a.t, s, contains, msg, args...)
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	if a.NotEmpty(obj) {
+//	  assert.Equal(t, "two", obj[1])
+//	}
+func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotEmpty(a.t, object, msgAndArgs...)
+}
+
+// NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	if a.NotEmptyf(obj, "error message %s", "formatted") {
+//	  assert.Equal(t, "two", obj[1])
+//	}
+func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotEmptyf(a.t, object, msg, args...)
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//	a.NotEqual(obj1, obj2)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotEqual(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotEqualValues asserts that two objects are not equal even when converted to the same type
+//
+//	a.NotEqualValues(obj1, obj2)
+func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotEqualValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
+//
+//	a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
+func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotEqualValuesf(a.t, expected, actual, msg, args...)
+}
+
+// NotEqualf asserts that the specified values are NOT equal.
+//
+//	a.NotEqualf(obj1, obj2, "error message %s", "formatted")
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotEqualf(a.t, expected, actual, msg, args...)
+}
+
+// NotErrorIs asserts that at none of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotErrorIs(a.t, err, target, msgAndArgs...)
+}
+
+// NotErrorIsf asserts that at none of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotErrorIsf(a.t, err, target, msg, args...)
+}
+
+// NotImplements asserts that an object does not implement the specified interface.
+//
+//	a.NotImplements((*MyInterface)(nil), new(MyObject))
+func (a *Assertions) NotImplements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotImplements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// NotImplementsf asserts that an object does not implement the specified interface.
+//
+//	a.NotImplementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func (a *Assertions) NotImplementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotImplementsf(a.t, interfaceObject, object, msg, args...)
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+//	a.NotNil(err)
+func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotNil(a.t, object, msgAndArgs...)
+}
+
+// NotNilf asserts that the specified object is not nil.
+//
+//	a.NotNilf(err, "error message %s", "formatted")
+func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotNilf(a.t, object, msg, args...)
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//	a.NotPanics(func(){ RemainCalm() })
+func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotPanics(a.t, f, msgAndArgs...)
+}
+
+// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//	a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
+func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotPanicsf(a.t, f, msg, args...)
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+//	a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
+//	a.NotRegexp("^start", "it's not starting")
+func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotRegexp(a.t, rx, str, msgAndArgs...)
+}
+
+// NotRegexpf asserts that a specified regexp does not match a string.
+//
+//	a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
+//	a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
+func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotRegexpf(a.t, rx, str, msg, args...)
+}
+
+// NotSame asserts that two pointers do not reference the same object.
+//
+//	a.NotSame(ptr1, ptr2)
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotSame(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotSamef asserts that two pointers do not reference the same object.
+//
+//	a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotSamef(a.t, expected, actual, msg, args...)
+}
+
+// NotSubset asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
+//
+//	a.NotSubset([1, 3, 4], [1, 2])
+//	a.NotSubset({"x": 1, "y": 2}, {"z": 3})
+func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotSubset(a.t, list, subset, msgAndArgs...)
+}
+
+// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
+//
+//	a.NotSubsetf([1, 3, 4], [1, 2], "error message %s", "formatted")
+//	a.NotSubsetf({"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
+func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotSubsetf(a.t, list, subset, msg, args...)
+}
+
+// NotZero asserts that i is not the zero value for its type.
+func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotZero(a.t, i, msgAndArgs...)
+}
+
+// NotZerof asserts that i is not the zero value for its type.
+func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotZerof(a.t, i, msg, args...)
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+//	a.Panics(func(){ GoCrazy() })
+func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Panics(a.t, f, msgAndArgs...)
+}
+
+// PanicsWithError asserts that the code inside the specified PanicTestFunc
+// panics, and that the recovered panic value is an error that satisfies the
+// EqualError comparison.
+//
+//	a.PanicsWithError("crazy error", func(){ GoCrazy() })
+func (a *Assertions) PanicsWithError(errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return PanicsWithError(a.t, errString, f, msgAndArgs...)
+}
+
+// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
+// panics, and that the recovered panic value is an error that satisfies the
+// EqualError comparison.
+//
+//	a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+func (a *Assertions) PanicsWithErrorf(errString string, f PanicTestFunc, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return PanicsWithErrorf(a.t, errString, f, msg, args...)
+}
+
+// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//	a.PanicsWithValue("crazy error", func(){ GoCrazy() })
+func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return PanicsWithValue(a.t, expected, f, msgAndArgs...)
+}
+
+// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//	a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return PanicsWithValuef(a.t, expected, f, msg, args...)
+}
+
+// Panicsf asserts that the code inside the specified PanicTestFunc panics.
+//
+//	a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
+func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Panicsf(a.t, f, msg, args...)
+}
+
+// Positive asserts that the specified element is positive
+//
+//	a.Positive(1)
+//	a.Positive(1.23)
+func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Positive(a.t, e, msgAndArgs...)
+}
+
+// Positivef asserts that the specified element is positive
+//
+//	a.Positivef(1, "error message %s", "formatted")
+//	a.Positivef(1.23, "error message %s", "formatted")
+func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Positivef(a.t, e, msg, args...)
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+//	a.Regexp(regexp.MustCompile("start"), "it's starting")
+//	a.Regexp("start...$", "it's not starting")
+func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Regexp(a.t, rx, str, msgAndArgs...)
+}
+
+// Regexpf asserts that a specified regexp matches a string.
+//
+//	a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
+//	a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
+func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Regexpf(a.t, rx, str, msg, args...)
+}
+
+// Same asserts that two pointers reference the same object.
+//
+//	a.Same(ptr1, ptr2)
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Same(a.t, expected, actual, msgAndArgs...)
+}
+
+// Samef asserts that two pointers reference the same object.
+//
+//	a.Samef(ptr1, ptr2, "error message %s", "formatted")
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Samef(a.t, expected, actual, msg, args...)
+}
+
+// Subset asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
+//
+//	a.Subset([1, 2, 3], [1, 2])
+//	a.Subset({"x": 1, "y": 2}, {"x": 1})
+func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Subset(a.t, list, subset, msgAndArgs...)
+}
+
+// Subsetf asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
+//
+//	a.Subsetf([1, 2, 3], [1, 2], "error message %s", "formatted")
+//	a.Subsetf({"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
+func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Subsetf(a.t, list, subset, msg, args...)
+}
+
+// True asserts that the specified value is true.
+//
+//	a.True(myBool)
+func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return True(a.t, value, msgAndArgs...)
+}
+
+// Truef asserts that the specified value is true.
+//
+//	a.Truef(myBool, "error message %s", "formatted")
+func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Truef(a.t, value, msg, args...)
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+//	a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
+func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// WithinDurationf asserts that the two times are within duration delta of each other.
+//
+//	a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return WithinDurationf(a.t, expected, actual, delta, msg, args...)
+}
+
+// WithinRange asserts that a time is within a time range (inclusive).
+//
+//	a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
+func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return WithinRange(a.t, actual, start, end, msgAndArgs...)
+}
+
+// WithinRangef asserts that a time is within a time range (inclusive).
+//
+//	a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
+func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return WithinRangef(a.t, actual, start, end, msg, args...)
+}
+
+// Zero asserts that i is the zero value for its type.
+func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Zero(a.t, i, msgAndArgs...)
+}
+
+// Zerof asserts that i is the zero value for its type.
+func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return Zerof(a.t, i, msg, args...)
+}
diff --git a/internal/testify/assert/assertion_forward.go.tmpl b/internal/testify/assert/assertion_forward.go.tmpl
new file mode 100644
index 000000000..188bb9e17
--- /dev/null
+++ b/internal/testify/assert/assertion_forward.go.tmpl
@@ -0,0 +1,5 @@
+{{.CommentWithoutT "a"}}
+func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool {
+	if h, ok := a.t.(tHelper); ok { h.Helper() }
+	return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
+}
diff --git a/internal/testify/assert/assertion_order.go b/internal/testify/assert/assertion_order.go
new file mode 100644
index 000000000..1d2f71824
--- /dev/null
+++ b/internal/testify/assert/assertion_order.go
@@ -0,0 +1,81 @@
+package assert
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// isOrdered checks that collection contains orderable elements.
+func isOrdered(t TestingT, object interface{}, allowedComparesResults []compareResult, failMessage string, msgAndArgs ...interface{}) bool {
+	objKind := reflect.TypeOf(object).Kind()
+	if objKind != reflect.Slice && objKind != reflect.Array {
+		return false
+	}
+
+	objValue := reflect.ValueOf(object)
+	objLen := objValue.Len()
+
+	if objLen <= 1 {
+		return true
+	}
+
+	value := objValue.Index(0)
+	valueInterface := value.Interface()
+	firstValueKind := value.Kind()
+
+	for i := 1; i < objLen; i++ {
+		prevValue := value
+		prevValueInterface := valueInterface
+
+		value = objValue.Index(i)
+		valueInterface = value.Interface()
+
+		compareResult, isComparable := compare(prevValueInterface, valueInterface, firstValueKind)
+
+		if !isComparable {
+			return Fail(t, fmt.Sprintf("Can not compare type \"%s\" and \"%s\"", reflect.TypeOf(value), reflect.TypeOf(prevValue)), msgAndArgs...)
+		}
+
+		if !containsValue(allowedComparesResults, compareResult) {
+			return Fail(t, fmt.Sprintf(failMessage, prevValue, value), msgAndArgs...)
+		}
+	}
+
+	return true
+}
+
+// IsIncreasing asserts that the collection is increasing
+//
+//	assert.IsIncreasing(t, []int{1, 2, 3})
+//	assert.IsIncreasing(t, []float{1, 2})
+//	assert.IsIncreasing(t, []string{"a", "b"})
+func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	return isOrdered(t, object, []compareResult{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
+}
+
+// IsNonIncreasing asserts that the collection is not increasing
+//
+//	assert.IsNonIncreasing(t, []int{2, 1, 1})
+//	assert.IsNonIncreasing(t, []float{2, 1})
+//	assert.IsNonIncreasing(t, []string{"b", "a"})
+func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	return isOrdered(t, object, []compareResult{compareEqual, compareGreater}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
+}
+
+// IsDecreasing asserts that the collection is decreasing
+//
+//	assert.IsDecreasing(t, []int{2, 1, 0})
+//	assert.IsDecreasing(t, []float{2, 1})
+//	assert.IsDecreasing(t, []string{"b", "a"})
+func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	return isOrdered(t, object, []compareResult{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
+}
+
+// IsNonDecreasing asserts that the collection is not decreasing
+//
+//	assert.IsNonDecreasing(t, []int{1, 1, 2})
+//	assert.IsNonDecreasing(t, []float{1, 2})
+//	assert.IsNonDecreasing(t, []string{"a", "b"})
+func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	return isOrdered(t, object, []compareResult{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
+}
diff --git a/internal/testify/assert/assertion_order_test.go b/internal/testify/assert/assertion_order_test.go
new file mode 100644
index 000000000..eefe06127
--- /dev/null
+++ b/internal/testify/assert/assertion_order_test.go
@@ -0,0 +1,203 @@
+package assert
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestIsIncreasing(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !IsIncreasing(mockT, []int{1, 2}) {
+		t.Error("IsIncreasing should return true")
+	}
+
+	if !IsIncreasing(mockT, []int{1, 2, 3, 4, 5}) {
+		t.Error("IsIncreasing should return true")
+	}
+
+	if IsIncreasing(mockT, []int{1, 1}) {
+		t.Error("IsIncreasing should return false")
+	}
+
+	if IsIncreasing(mockT, []int{2, 1}) {
+		t.Error("IsIncreasing should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		collection interface{}
+		msg        string
+	}{
+		{collection: []string{"b", "a"}, msg: `"b" is not less than "a"`},
+		{collection: []int{2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []int{2, 1, 3, 4, 5, 6, 7}, msg: `"2" is not less than "1"`},
+		{collection: []int{-1, 0, 2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []int8{2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []int16{2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []int32{2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []int64{2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []uint8{2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []uint16{2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []uint32{2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []uint64{2, 1}, msg: `"2" is not less than "1"`},
+		{collection: []float32{2.34, 1.23}, msg: `"2.34" is not less than "1.23"`},
+		{collection: []float64{2.34, 1.23}, msg: `"2.34" is not less than "1.23"`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, IsIncreasing(out, currCase.collection))
+		Contains(t, out.buf.String(), currCase.msg)
+	}
+}
+
+func TestIsNonIncreasing(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !IsNonIncreasing(mockT, []int{2, 1}) {
+		t.Error("IsNonIncreasing should return true")
+	}
+
+	if !IsNonIncreasing(mockT, []int{5, 4, 4, 3, 2, 1}) {
+		t.Error("IsNonIncreasing should return true")
+	}
+
+	if !IsNonIncreasing(mockT, []int{1, 1}) {
+		t.Error("IsNonIncreasing should return true")
+	}
+
+	if IsNonIncreasing(mockT, []int{1, 2}) {
+		t.Error("IsNonIncreasing should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		collection interface{}
+		msg        string
+	}{
+		{collection: []string{"a", "b"}, msg: `"a" is not greater than or equal to "b"`},
+		{collection: []int{1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []int{1, 2, 7, 6, 5, 4, 3}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []int{5, 4, 3, 1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []int8{1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []int16{1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []int32{1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []int64{1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []uint8{1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []uint16{1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []uint32{1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []uint64{1, 2}, msg: `"1" is not greater than or equal to "2"`},
+		{collection: []float32{1.23, 2.34}, msg: `"1.23" is not greater than or equal to "2.34"`},
+		{collection: []float64{1.23, 2.34}, msg: `"1.23" is not greater than or equal to "2.34"`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, IsNonIncreasing(out, currCase.collection))
+		Contains(t, out.buf.String(), currCase.msg)
+	}
+}
+
+func TestIsDecreasing(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !IsDecreasing(mockT, []int{2, 1}) {
+		t.Error("IsDecreasing should return true")
+	}
+
+	if !IsDecreasing(mockT, []int{5, 4, 3, 2, 1}) {
+		t.Error("IsDecreasing should return true")
+	}
+
+	if IsDecreasing(mockT, []int{1, 1}) {
+		t.Error("IsDecreasing should return false")
+	}
+
+	if IsDecreasing(mockT, []int{1, 2}) {
+		t.Error("IsDecreasing should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		collection interface{}
+		msg        string
+	}{
+		{collection: []string{"a", "b"}, msg: `"a" is not greater than "b"`},
+		{collection: []int{1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []int{1, 2, 7, 6, 5, 4, 3}, msg: `"1" is not greater than "2"`},
+		{collection: []int{5, 4, 3, 1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []int8{1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []int16{1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []int32{1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []int64{1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []uint8{1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []uint16{1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []uint32{1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []uint64{1, 2}, msg: `"1" is not greater than "2"`},
+		{collection: []float32{1.23, 2.34}, msg: `"1.23" is not greater than "2.34"`},
+		{collection: []float64{1.23, 2.34}, msg: `"1.23" is not greater than "2.34"`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, IsDecreasing(out, currCase.collection))
+		Contains(t, out.buf.String(), currCase.msg)
+	}
+}
+
+func TestIsNonDecreasing(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !IsNonDecreasing(mockT, []int{1, 2}) {
+		t.Error("IsNonDecreasing should return true")
+	}
+
+	if !IsNonDecreasing(mockT, []int{1, 1, 2, 3, 4, 5}) {
+		t.Error("IsNonDecreasing should return true")
+	}
+
+	if !IsNonDecreasing(mockT, []int{1, 1}) {
+		t.Error("IsNonDecreasing should return false")
+	}
+
+	if IsNonDecreasing(mockT, []int{2, 1}) {
+		t.Error("IsNonDecreasing should return false")
+	}
+
+	// Check error report
+	for _, currCase := range []struct {
+		collection interface{}
+		msg        string
+	}{
+		{collection: []string{"b", "a"}, msg: `"b" is not less than or equal to "a"`},
+		{collection: []int{2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []int{2, 1, 3, 4, 5, 6, 7}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []int{-1, 0, 2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []int8{2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []int16{2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []int32{2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []int64{2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []uint8{2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []uint16{2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []uint32{2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []uint64{2, 1}, msg: `"2" is not less than or equal to "1"`},
+		{collection: []float32{2.34, 1.23}, msg: `"2.34" is not less than or equal to "1.23"`},
+		{collection: []float64{2.34, 1.23}, msg: `"2.34" is not less than or equal to "1.23"`},
+	} {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		False(t, IsNonDecreasing(out, currCase.collection))
+		Contains(t, out.buf.String(), currCase.msg)
+	}
+}
+
+func TestOrderingMsgAndArgsForwarding(t *testing.T) {
+	msgAndArgs := []interface{}{"format %s %x", "this", 0xc001}
+	expectedOutput := "format this c001\n"
+	collection := []int{1, 2, 1}
+	funcs := []func(t TestingT){
+		func(t TestingT) { IsIncreasing(t, collection, msgAndArgs...) },
+		func(t TestingT) { IsNonIncreasing(t, collection, msgAndArgs...) },
+		func(t TestingT) { IsDecreasing(t, collection, msgAndArgs...) },
+		func(t TestingT) { IsNonDecreasing(t, collection, msgAndArgs...) },
+	}
+	for _, f := range funcs {
+		out := &outputT{buf: bytes.NewBuffer(nil)}
+		f(out)
+		Contains(t, out.buf.String(), expectedOutput)
+	}
+}
diff --git a/internal/testify/assert/assertions.go b/internal/testify/assert/assertions.go
new file mode 100644
index 000000000..64ab7e6b9
--- /dev/null
+++ b/internal/testify/assert/assertions.go
@@ -0,0 +1,2091 @@
+package assert
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math"
+	"os"
+	"reflect"
+	"regexp"
+	"runtime"
+	"runtime/debug"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/expr-lang/expr/internal/spew"
+
+	"github.com/expr-lang/expr/internal/difflib"
+)
+
+//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_format.go.tmpl"
+
+// TestingT is an interface wrapper around *testing.T
+type TestingT interface {
+	Errorf(format string, args ...interface{})
+}
+
+// ComparisonAssertionFunc is a common function prototype when comparing two values.  Can be useful
+// for table driven tests.
+type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) bool
+
+// ValueAssertionFunc is a common function prototype when validating a single value.  Can be useful
+// for table driven tests.
+type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) bool
+
+// BoolAssertionFunc is a common function prototype when validating a bool value.  Can be useful
+// for table driven tests.
+type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool
+
+// ErrorAssertionFunc is a common function prototype when validating an error value.  Can be useful
+// for table driven tests.
+type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool
+
+// PanicAssertionFunc is a common function prototype when validating a panic value.  Can be useful
+// for table driven tests.
+type PanicAssertionFunc = func(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool
+
+// Comparison is a custom function that returns true on success and false on failure
+type Comparison func() (success bool)
+
+/*
+	Helper functions
+*/
+
+// ObjectsAreEqual determines if two objects are considered equal.
+//
+// This function does no assertion of any kind.
+func ObjectsAreEqual(expected, actual interface{}) bool {
+	if expected == nil || actual == nil {
+		return expected == actual
+	}
+
+	exp, ok := expected.([]byte)
+	if !ok {
+		return reflect.DeepEqual(expected, actual)
+	}
+
+	act, ok := actual.([]byte)
+	if !ok {
+		return false
+	}
+	if exp == nil || act == nil {
+		return exp == nil && act == nil
+	}
+	return bytes.Equal(exp, act)
+}
+
+// copyExportedFields iterates downward through nested data structures and creates a copy
+// that only contains the exported struct fields.
+func copyExportedFields(expected interface{}) interface{} {
+	if isNil(expected) {
+		return expected
+	}
+
+	expectedType := reflect.TypeOf(expected)
+	expectedKind := expectedType.Kind()
+	expectedValue := reflect.ValueOf(expected)
+
+	switch expectedKind {
+	case reflect.Struct:
+		result := reflect.New(expectedType).Elem()
+		for i := 0; i < expectedType.NumField(); i++ {
+			field := expectedType.Field(i)
+			isExported := field.IsExported()
+			if isExported {
+				fieldValue := expectedValue.Field(i)
+				if isNil(fieldValue) || isNil(fieldValue.Interface()) {
+					continue
+				}
+				newValue := copyExportedFields(fieldValue.Interface())
+				result.Field(i).Set(reflect.ValueOf(newValue))
+			}
+		}
+		return result.Interface()
+
+	case reflect.Ptr:
+		result := reflect.New(expectedType.Elem())
+		unexportedRemoved := copyExportedFields(expectedValue.Elem().Interface())
+		result.Elem().Set(reflect.ValueOf(unexportedRemoved))
+		return result.Interface()
+
+	case reflect.Array, reflect.Slice:
+		var result reflect.Value
+		if expectedKind == reflect.Array {
+			result = reflect.New(reflect.ArrayOf(expectedValue.Len(), expectedType.Elem())).Elem()
+		} else {
+			result = reflect.MakeSlice(expectedType, expectedValue.Len(), expectedValue.Len())
+		}
+		for i := 0; i < expectedValue.Len(); i++ {
+			index := expectedValue.Index(i)
+			if isNil(index) {
+				continue
+			}
+			unexportedRemoved := copyExportedFields(index.Interface())
+			result.Index(i).Set(reflect.ValueOf(unexportedRemoved))
+		}
+		return result.Interface()
+
+	case reflect.Map:
+		result := reflect.MakeMap(expectedType)
+		for _, k := range expectedValue.MapKeys() {
+			index := expectedValue.MapIndex(k)
+			unexportedRemoved := copyExportedFields(index.Interface())
+			result.SetMapIndex(k, reflect.ValueOf(unexportedRemoved))
+		}
+		return result.Interface()
+
+	default:
+		return expected
+	}
+}
+
+// ObjectsExportedFieldsAreEqual determines if the exported (public) fields of two objects are
+// considered equal. This comparison of only exported fields is applied recursively to nested data
+// structures.
+//
+// This function does no assertion of any kind.
+//
+// Deprecated: Use [EqualExportedValues] instead.
+func ObjectsExportedFieldsAreEqual(expected, actual interface{}) bool {
+	expectedCleaned := copyExportedFields(expected)
+	actualCleaned := copyExportedFields(actual)
+	return ObjectsAreEqualValues(expectedCleaned, actualCleaned)
+}
+
+// ObjectsAreEqualValues gets whether two objects are equal, or if their
+// values are equal.
+func ObjectsAreEqualValues(expected, actual interface{}) bool {
+	if ObjectsAreEqual(expected, actual) {
+		return true
+	}
+
+	expectedValue := reflect.ValueOf(expected)
+	actualValue := reflect.ValueOf(actual)
+	if !expectedValue.IsValid() || !actualValue.IsValid() {
+		return false
+	}
+
+	expectedType := expectedValue.Type()
+	actualType := actualValue.Type()
+	if !expectedType.ConvertibleTo(actualType) {
+		return false
+	}
+
+	if !isNumericType(expectedType) || !isNumericType(actualType) {
+		// Attempt comparison after type conversion
+		return reflect.DeepEqual(
+			expectedValue.Convert(actualType).Interface(), actual,
+		)
+	}
+
+	// If BOTH values are numeric, there are chances of false positives due
+	// to overflow or underflow. So, we need to make sure to always convert
+	// the smaller type to a larger type before comparing.
+	if expectedType.Size() >= actualType.Size() {
+		return actualValue.Convert(expectedType).Interface() == expected
+	}
+
+	return expectedValue.Convert(actualType).Interface() == actual
+}
+
+// isNumericType returns true if the type is one of:
+// int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64,
+// float32, float64, complex64, complex128
+func isNumericType(t reflect.Type) bool {
+	return t.Kind() >= reflect.Int && t.Kind() <= reflect.Complex128
+}
+
+/* CallerInfo is necessary because the assert functions use the testing object
+internally, causing it to print the file:line of the assert method, rather than where
+the problem actually occurred in calling code.*/
+
+// CallerInfo returns an array of strings containing the file and line number
+// of each stack frame leading from the current test to the assert call that
+// failed.
+func CallerInfo() []string {
+
+	var pc uintptr
+	var ok bool
+	var file string
+	var line int
+	var name string
+
+	callers := []string{}
+	for i := 0; ; i++ {
+		pc, file, line, ok = runtime.Caller(i)
+		if !ok {
+			// The breaks below failed to terminate the loop, and we ran off the
+			// end of the call stack.
+			break
+		}
+
+		// This is a huge edge case, but it will panic if this is the case, see #180
+		if file == "<autogenerated>" {
+			break
+		}
+
+		f := runtime.FuncForPC(pc)
+		if f == nil {
+			break
+		}
+		name = f.Name()
+
+		// testing.tRunner is the standard library function that calls
+		// tests. Subtests are called directly by tRunner, without going through
+		// the Test/Benchmark/Example function that contains the t.Run calls, so
+		// with subtests we should break when we hit tRunner, without adding it
+		// to the list of callers.
+		if name == "testing.tRunner" {
+			break
+		}
+
+		parts := strings.Split(file, "/")
+		if len(parts) > 1 {
+			filename := parts[len(parts)-1]
+			dir := parts[len(parts)-2]
+			if (dir != "assert" && dir != "mock" && dir != "require") || filename == "mock_test.go" {
+				callers = append(callers, fmt.Sprintf("%s:%d", file, line))
+			}
+		}
+
+		// Drop the package
+		segments := strings.Split(name, ".")
+		name = segments[len(segments)-1]
+		if isTest(name, "Test") ||
+			isTest(name, "Benchmark") ||
+			isTest(name, "Example") {
+			break
+		}
+	}
+
+	return callers
+}
+
+// Stolen from the `go test` tool.
+// isTest tells whether name looks like a test (or benchmark, according to prefix).
+// It is a Test (say) if there is a character after Test that is not a lower-case letter.
+// We don't want TesticularCancer.
+func isTest(name, prefix string) bool {
+	if !strings.HasPrefix(name, prefix) {
+		return false
+	}
+	if len(name) == len(prefix) { // "Test" is ok
+		return true
+	}
+	r, _ := utf8.DecodeRuneInString(name[len(prefix):])
+	return !unicode.IsLower(r)
+}
+
+func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
+	if len(msgAndArgs) == 0 || msgAndArgs == nil {
+		return ""
+	}
+	if len(msgAndArgs) == 1 {
+		msg := msgAndArgs[0]
+		if msgAsStr, ok := msg.(string); ok {
+			return msgAsStr
+		}
+		return fmt.Sprintf("%+v", msg)
+	}
+	if len(msgAndArgs) > 1 {
+		return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
+	}
+	return ""
+}
+
+// Aligns the provided message so that all lines after the first line start at the same location as the first line.
+// Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab).
+// The longestLabelLen parameter specifies the length of the longest label in the output (required because this is the
+// basis on which the alignment occurs).
+func indentMessageLines(message string, longestLabelLen int) string {
+	outBuf := new(bytes.Buffer)
+
+	for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {
+		// no need to align first line because it starts at the correct location (after the label)
+		if i != 0 {
+			// append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab
+			outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t")
+		}
+		outBuf.WriteString(scanner.Text())
+	}
+
+	return outBuf.String()
+}
+
+type failNower interface {
+	FailNow()
+}
+
+// FailNow fails test
+func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	Fail(t, failureMessage, msgAndArgs...)
+
+	// We cannot extend TestingT with FailNow() and
+	// maintain backwards compatibility, so we fallback
+	// to panicking when FailNow is not available in
+	// TestingT.
+	// See issue #263
+
+	if t, ok := t.(failNower); ok {
+		t.FailNow()
+	} else {
+		panic("test failed and t is missing `FailNow()`")
+	}
+	return false
+}
+
+// Fail reports a failure through
+func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	content := []labeledContent{
+		{"Error Trace", strings.Join(CallerInfo(), "\n\t\t\t")},
+		{"Error", failureMessage},
+	}
+
+	// Add test name if the Go version supports it
+	if n, ok := t.(interface {
+		Name() string
+	}); ok {
+		content = append(content, labeledContent{"Test", n.Name()})
+	}
+
+	message := messageFromMsgAndArgs(msgAndArgs...)
+	if len(message) > 0 {
+		content = append(content, labeledContent{"Messages", message})
+	}
+
+	t.Errorf("\n%s", ""+labeledOutput(content...))
+
+	return false
+}
+
+type labeledContent struct {
+	label   string
+	content string
+}
+
+// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner:
+//
+//	\t{{label}}:{{align_spaces}}\t{{content}}\n
+//
+// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label.
+// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this
+// alignment is achieved, "\t{{content}}\n" is added for the output.
+//
+// If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line.
+func labeledOutput(content ...labeledContent) string {
+	longestLabel := 0
+	for _, v := range content {
+		if len(v.label) > longestLabel {
+			longestLabel = len(v.label)
+		}
+	}
+	var output string
+	for _, v := range content {
+		output += "\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n"
+	}
+	return output
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+//	assert.Implements(t, (*MyInterface)(nil), new(MyObject))
+func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	interfaceType := reflect.TypeOf(interfaceObject).Elem()
+
+	if object == nil {
+		return Fail(t, fmt.Sprintf("Cannot check if nil implements %v", interfaceType), msgAndArgs...)
+	}
+	if !reflect.TypeOf(object).Implements(interfaceType) {
+		return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...)
+	}
+
+	return true
+}
+
+// NotImplements asserts that an object does not implement the specified interface.
+//
+//	assert.NotImplements(t, (*MyInterface)(nil), new(MyObject))
+func NotImplements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	interfaceType := reflect.TypeOf(interfaceObject).Elem()
+
+	if object == nil {
+		return Fail(t, fmt.Sprintf("Cannot check if nil does not implement %v", interfaceType), msgAndArgs...)
+	}
+	if reflect.TypeOf(object).Implements(interfaceType) {
+		return Fail(t, fmt.Sprintf("%T implements %v", object, interfaceType), msgAndArgs...)
+	}
+
+	return true
+}
+
+// IsType asserts that the specified objects are of the same type.
+func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) {
+		return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...)
+	}
+
+	return true
+}
+
+// Equal asserts that two objects are equal.
+//
+//	assert.Equal(t, 123, 123)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if err := validateEqualArgs(expected, actual); err != nil {
+		return Fail(t, fmt.Sprintf("Invalid operation: %#v == %#v (%s)",
+			expected, actual, err), msgAndArgs...)
+	}
+
+	if !ObjectsAreEqual(expected, actual) {
+		diff := diff(expected, actual)
+		expected, actual = formatUnequalValues(expected, actual)
+		return Fail(t, fmt.Sprintf("Not equal: \n"+
+			"expected: %s\n"+
+			"actual  : %s%s", expected, actual, diff), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// validateEqualArgs checks whether provided arguments can be safely used in the
+// Equal/NotEqual functions.
+func validateEqualArgs(expected, actual interface{}) error {
+	if expected == nil && actual == nil {
+		return nil
+	}
+
+	if isFunction(expected) || isFunction(actual) {
+		return errors.New("cannot take func type as argument")
+	}
+	return nil
+}
+
+// Same asserts that two pointers reference the same object.
+//
+//	assert.Same(t, ptr1, ptr2)
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	if !samePointers(expected, actual) {
+		return Fail(t, fmt.Sprintf("Not same: \n"+
+			"expected: %p %#v\n"+
+			"actual  : %p %#v", expected, expected, actual, actual), msgAndArgs...)
+	}
+
+	return true
+}
+
+// NotSame asserts that two pointers do not reference the same object.
+//
+//	assert.NotSame(t, ptr1, ptr2)
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func NotSame(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	if samePointers(expected, actual) {
+		return Fail(t, fmt.Sprintf(
+			"Expected and actual point to the same object: %p %#v",
+			expected, expected), msgAndArgs...)
+	}
+	return true
+}
+
+// samePointers compares two generic interface objects and returns whether
+// they point to the same object
+func samePointers(first, second interface{}) bool {
+	firstPtr, secondPtr := reflect.ValueOf(first), reflect.ValueOf(second)
+	if firstPtr.Kind() != reflect.Ptr || secondPtr.Kind() != reflect.Ptr {
+		return false
+	}
+
+	firstType, secondType := reflect.TypeOf(first), reflect.TypeOf(second)
+	if firstType != secondType {
+		return false
+	}
+
+	// compare pointer addresses
+	return first == second
+}
+
+// formatUnequalValues takes two values of arbitrary types and returns string
+// representations appropriate to be presented to the user.
+//
+// If the values are not of like type, the returned strings will be prefixed
+// with the type name, and the value will be enclosed in parentheses similar
+// to a type conversion in the Go grammar.
+func formatUnequalValues(expected, actual interface{}) (e string, a string) {
+	if reflect.TypeOf(expected) != reflect.TypeOf(actual) {
+		return fmt.Sprintf("%T(%s)", expected, truncatingFormat(expected)),
+			fmt.Sprintf("%T(%s)", actual, truncatingFormat(actual))
+	}
+	switch expected.(type) {
+	case time.Duration:
+		return fmt.Sprintf("%v", expected), fmt.Sprintf("%v", actual)
+	}
+	return truncatingFormat(expected), truncatingFormat(actual)
+}
+
+// truncatingFormat formats the data and truncates it if it's too long.
+//
+// This helps keep formatted error messages lines from exceeding the
+// bufio.MaxScanTokenSize max line length that the go testing framework imposes.
+func truncatingFormat(data interface{}) string {
+	value := fmt.Sprintf("%#v", data)
+	max := bufio.MaxScanTokenSize - 100 // Give us some space the type info too if needed.
+	if len(value) > max {
+		value = value[0:max] + "<... truncated>"
+	}
+	return value
+}
+
+// EqualValues asserts that two objects are equal or convertible to the same types
+// and equal.
+//
+//	assert.EqualValues(t, uint32(123), int32(123))
+func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	if !ObjectsAreEqualValues(expected, actual) {
+		diff := diff(expected, actual)
+		expected, actual = formatUnequalValues(expected, actual)
+		return Fail(t, fmt.Sprintf("Not equal: \n"+
+			"expected: %s\n"+
+			"actual  : %s%s", expected, actual, diff), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// EqualExportedValues asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+//	 type S struct {
+//		Exported     	int
+//		notExported   	int
+//	 }
+//	 assert.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true
+//	 assert.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false
+func EqualExportedValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	aType := reflect.TypeOf(expected)
+	bType := reflect.TypeOf(actual)
+
+	if aType != bType {
+		return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...)
+	}
+
+	if aType.Kind() == reflect.Ptr {
+		aType = aType.Elem()
+	}
+	if bType.Kind() == reflect.Ptr {
+		bType = bType.Elem()
+	}
+
+	if aType.Kind() != reflect.Struct {
+		return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", aType.Kind(), reflect.Struct), msgAndArgs...)
+	}
+
+	if bType.Kind() != reflect.Struct {
+		return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", bType.Kind(), reflect.Struct), msgAndArgs...)
+	}
+
+	expected = copyExportedFields(expected)
+	actual = copyExportedFields(actual)
+
+	if !ObjectsAreEqualValues(expected, actual) {
+		diff := diff(expected, actual)
+		expected, actual = formatUnequalValues(expected, actual)
+		return Fail(t, fmt.Sprintf("Not equal (comparing only exported fields): \n"+
+			"expected: %s\n"+
+			"actual  : %s%s", expected, actual, diff), msgAndArgs...)
+	}
+
+	return true
+}
+
+// Exactly asserts that two objects are equal in value and type.
+//
+//	assert.Exactly(t, int32(123), int64(123))
+func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	aType := reflect.TypeOf(expected)
+	bType := reflect.TypeOf(actual)
+
+	if aType != bType {
+		return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...)
+	}
+
+	return Equal(t, expected, actual, msgAndArgs...)
+
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+//	assert.NotNil(t, err)
+func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	if !isNil(object) {
+		return true
+	}
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Fail(t, "Expected value not to be nil.", msgAndArgs...)
+}
+
+// isNil checks if a specified object is nil or not, without Failing.
+func isNil(object interface{}) bool {
+	if object == nil {
+		return true
+	}
+
+	value := reflect.ValueOf(object)
+	switch value.Kind() {
+	case
+		reflect.Chan, reflect.Func,
+		reflect.Interface, reflect.Map,
+		reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
+
+		return value.IsNil()
+	}
+
+	return false
+}
+
+// Nil asserts that the specified object is nil.
+//
+//	assert.Nil(t, err)
+func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	if isNil(object) {
+		return true
+	}
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...)
+}
+
+// isEmpty gets whether the specified object is considered empty or not.
+func isEmpty(object interface{}) bool {
+
+	// get nil case out of the way
+	if object == nil {
+		return true
+	}
+
+	objValue := reflect.ValueOf(object)
+
+	switch objValue.Kind() {
+	// collection types are empty when they have no element
+	case reflect.Chan, reflect.Map, reflect.Slice:
+		return objValue.Len() == 0
+	// pointers are empty if nil or if the value they point to is empty
+	case reflect.Ptr:
+		if objValue.IsNil() {
+			return true
+		}
+		deref := objValue.Elem().Interface()
+		return isEmpty(deref)
+	// for all other types, compare against the zero value
+	// array types are empty when they match their zero-initialized state
+	default:
+		zero := reflect.Zero(objValue.Type())
+		return reflect.DeepEqual(object, zero.Interface())
+	}
+}
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	assert.Empty(t, obj)
+func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	pass := isEmpty(object)
+	if !pass {
+		if h, ok := t.(tHelper); ok {
+			h.Helper()
+		}
+		Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...)
+	}
+
+	return pass
+
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	if assert.NotEmpty(t, obj) {
+//	  assert.Equal(t, "two", obj[1])
+//	}
+func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	pass := !isEmpty(object)
+	if !pass {
+		if h, ok := t.(tHelper); ok {
+			h.Helper()
+		}
+		Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...)
+	}
+
+	return pass
+
+}
+
+// getLen tries to get the length of an object.
+// It returns (0, false) if impossible.
+func getLen(x interface{}) (length int, ok bool) {
+	v := reflect.ValueOf(x)
+	defer func() {
+		ok = recover() == nil
+	}()
+	return v.Len(), true
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+//	assert.Len(t, mySlice, 3)
+func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	l, ok := getLen(object)
+	if !ok {
+		return Fail(t, fmt.Sprintf("\"%v\" could not be applied builtin len()", object), msgAndArgs...)
+	}
+
+	if l != length {
+		return Fail(t, fmt.Sprintf("\"%v\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
+	}
+	return true
+}
+
+// True asserts that the specified value is true.
+//
+//	assert.True(t, myBool)
+func True(t TestingT, value bool, msgAndArgs ...interface{}) bool {
+	if !value {
+		if h, ok := t.(tHelper); ok {
+			h.Helper()
+		}
+		return Fail(t, "Should be true", msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// False asserts that the specified value is false.
+//
+//	assert.False(t, myBool)
+func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
+	if value {
+		if h, ok := t.(tHelper); ok {
+			h.Helper()
+		}
+		return Fail(t, "Should be false", msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//	assert.NotEqual(t, obj1, obj2)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if err := validateEqualArgs(expected, actual); err != nil {
+		return Fail(t, fmt.Sprintf("Invalid operation: %#v != %#v (%s)",
+			expected, actual, err), msgAndArgs...)
+	}
+
+	if ObjectsAreEqual(expected, actual) {
+		return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// NotEqualValues asserts that two objects are not equal even when converted to the same type
+//
+//	assert.NotEqualValues(t, obj1, obj2)
+func NotEqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	if ObjectsAreEqualValues(expected, actual) {
+		return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...)
+	}
+
+	return true
+}
+
+// containsElement try loop over the list check if the list includes the element.
+// return (false, false) if impossible.
+// return (true, false) if element was not found.
+// return (true, true) if element was found.
+func containsElement(list interface{}, element interface{}) (ok, found bool) {
+
+	listValue := reflect.ValueOf(list)
+	listType := reflect.TypeOf(list)
+	if listType == nil {
+		return false, false
+	}
+	listKind := listType.Kind()
+	defer func() {
+		if e := recover(); e != nil {
+			ok = false
+			found = false
+		}
+	}()
+
+	if listKind == reflect.String {
+		elementValue := reflect.ValueOf(element)
+		return true, strings.Contains(listValue.String(), elementValue.String())
+	}
+
+	if listKind == reflect.Map {
+		mapKeys := listValue.MapKeys()
+		for i := 0; i < len(mapKeys); i++ {
+			if ObjectsAreEqual(mapKeys[i].Interface(), element) {
+				return true, true
+			}
+		}
+		return true, false
+	}
+
+	for i := 0; i < listValue.Len(); i++ {
+		if ObjectsAreEqual(listValue.Index(i).Interface(), element) {
+			return true, true
+		}
+	}
+	return true, false
+
+}
+
+// Contains asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//	assert.Contains(t, "Hello World", "World")
+//	assert.Contains(t, ["Hello", "World"], "World")
+//	assert.Contains(t, {"Hello": "World"}, "Hello")
+func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	ok, found := containsElement(s, contains)
+	if !ok {
+		return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", s), msgAndArgs...)
+	}
+	if !found {
+		return Fail(t, fmt.Sprintf("%#v does not contain %#v", s, contains), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//	assert.NotContains(t, "Hello World", "Earth")
+//	assert.NotContains(t, ["Hello", "World"], "Earth")
+//	assert.NotContains(t, {"Hello": "World"}, "Earth")
+func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	ok, found := containsElement(s, contains)
+	if !ok {
+		return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", s), msgAndArgs...)
+	}
+	if found {
+		return Fail(t, fmt.Sprintf("%#v should not contain %#v", s, contains), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// Subset asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
+//
+//	assert.Subset(t, [1, 2, 3], [1, 2])
+//	assert.Subset(t, {"x": 1, "y": 2}, {"x": 1})
+func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if subset == nil {
+		return true // we consider nil to be equal to the nil set
+	}
+
+	listKind := reflect.TypeOf(list).Kind()
+	if listKind != reflect.Array && listKind != reflect.Slice && listKind != reflect.Map {
+		return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...)
+	}
+
+	subsetKind := reflect.TypeOf(subset).Kind()
+	if subsetKind != reflect.Array && subsetKind != reflect.Slice && listKind != reflect.Map {
+		return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...)
+	}
+
+	if subsetKind == reflect.Map && listKind == reflect.Map {
+		subsetMap := reflect.ValueOf(subset)
+		actualMap := reflect.ValueOf(list)
+
+		for _, k := range subsetMap.MapKeys() {
+			ev := subsetMap.MapIndex(k)
+			av := actualMap.MapIndex(k)
+
+			if !av.IsValid() {
+				return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, subset), msgAndArgs...)
+			}
+			if !ObjectsAreEqual(ev.Interface(), av.Interface()) {
+				return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, subset), msgAndArgs...)
+			}
+		}
+
+		return true
+	}
+
+	subsetList := reflect.ValueOf(subset)
+	for i := 0; i < subsetList.Len(); i++ {
+		element := subsetList.Index(i).Interface()
+		ok, found := containsElement(list, element)
+		if !ok {
+			return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", list), msgAndArgs...)
+		}
+		if !found {
+			return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, element), msgAndArgs...)
+		}
+	}
+
+	return true
+}
+
+// NotSubset asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
+//
+//	assert.NotSubset(t, [1, 3, 4], [1, 2])
+//	assert.NotSubset(t, {"x": 1, "y": 2}, {"z": 3})
+func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if subset == nil {
+		return Fail(t, "nil is the empty set which is a subset of every set", msgAndArgs...)
+	}
+
+	listKind := reflect.TypeOf(list).Kind()
+	if listKind != reflect.Array && listKind != reflect.Slice && listKind != reflect.Map {
+		return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...)
+	}
+
+	subsetKind := reflect.TypeOf(subset).Kind()
+	if subsetKind != reflect.Array && subsetKind != reflect.Slice && listKind != reflect.Map {
+		return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...)
+	}
+
+	if subsetKind == reflect.Map && listKind == reflect.Map {
+		subsetMap := reflect.ValueOf(subset)
+		actualMap := reflect.ValueOf(list)
+
+		for _, k := range subsetMap.MapKeys() {
+			ev := subsetMap.MapIndex(k)
+			av := actualMap.MapIndex(k)
+
+			if !av.IsValid() {
+				return true
+			}
+			if !ObjectsAreEqual(ev.Interface(), av.Interface()) {
+				return true
+			}
+		}
+
+		return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...)
+	}
+
+	subsetList := reflect.ValueOf(subset)
+	for i := 0; i < subsetList.Len(); i++ {
+		element := subsetList.Index(i).Interface()
+		ok, found := containsElement(list, element)
+		if !ok {
+			return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...)
+		}
+		if !found {
+			return true
+		}
+	}
+
+	return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...)
+}
+
+// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
+// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
+// the number of appearances of each of them in both lists should match.
+//
+// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])
+func ElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if isEmpty(listA) && isEmpty(listB) {
+		return true
+	}
+
+	if !isList(t, listA, msgAndArgs...) || !isList(t, listB, msgAndArgs...) {
+		return false
+	}
+
+	extraA, extraB := diffLists(listA, listB)
+
+	if len(extraA) == 0 && len(extraB) == 0 {
+		return true
+	}
+
+	return Fail(t, formatListDiff(listA, listB, extraA, extraB), msgAndArgs...)
+}
+
+// isList checks that the provided value is array or slice.
+func isList(t TestingT, list interface{}, msgAndArgs ...interface{}) (ok bool) {
+	kind := reflect.TypeOf(list).Kind()
+	if kind != reflect.Array && kind != reflect.Slice {
+		return Fail(t, fmt.Sprintf("%q has an unsupported type %s, expecting array or slice", list, kind),
+			msgAndArgs...)
+	}
+	return true
+}
+
+// diffLists diffs two arrays/slices and returns slices of elements that are only in A and only in B.
+// If some element is present multiple times, each instance is counted separately (e.g. if something is 2x in A and
+// 5x in B, it will be 0x in extraA and 3x in extraB). The order of items in both lists is ignored.
+func diffLists(listA, listB interface{}) (extraA, extraB []interface{}) {
+	aValue := reflect.ValueOf(listA)
+	bValue := reflect.ValueOf(listB)
+
+	aLen := aValue.Len()
+	bLen := bValue.Len()
+
+	// Mark indexes in bValue that we already used
+	visited := make([]bool, bLen)
+	for i := 0; i < aLen; i++ {
+		element := aValue.Index(i).Interface()
+		found := false
+		for j := 0; j < bLen; j++ {
+			if visited[j] {
+				continue
+			}
+			if ObjectsAreEqual(bValue.Index(j).Interface(), element) {
+				visited[j] = true
+				found = true
+				break
+			}
+		}
+		if !found {
+			extraA = append(extraA, element)
+		}
+	}
+
+	for j := 0; j < bLen; j++ {
+		if visited[j] {
+			continue
+		}
+		extraB = append(extraB, bValue.Index(j).Interface())
+	}
+
+	return
+}
+
+func formatListDiff(listA, listB interface{}, extraA, extraB []interface{}) string {
+	var msg bytes.Buffer
+
+	msg.WriteString("elements differ")
+	if len(extraA) > 0 {
+		msg.WriteString("\n\nextra elements in list A:\n")
+		msg.WriteString(spewConfig.Sdump(extraA))
+	}
+	if len(extraB) > 0 {
+		msg.WriteString("\n\nextra elements in list B:\n")
+		msg.WriteString(spewConfig.Sdump(extraB))
+	}
+	msg.WriteString("\n\nlistA:\n")
+	msg.WriteString(spewConfig.Sdump(listA))
+	msg.WriteString("\n\nlistB:\n")
+	msg.WriteString(spewConfig.Sdump(listB))
+
+	return msg.String()
+}
+
+// Condition uses a Comparison to assert a complex condition.
+func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	result := comp()
+	if !result {
+		Fail(t, "Condition failed!", msgAndArgs...)
+	}
+	return result
+}
+
+// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics
+// methods, and represents a simple func that takes no arguments, and returns nothing.
+type PanicTestFunc func()
+
+// didPanic returns true if the function passed to it panics. Otherwise, it returns false.
+func didPanic(f PanicTestFunc) (didPanic bool, message interface{}, stack string) {
+	didPanic = true
+
+	defer func() {
+		message = recover()
+		if didPanic {
+			stack = string(debug.Stack())
+		}
+	}()
+
+	// call the target function
+	f()
+	didPanic = false
+
+	return
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+//	assert.Panics(t, func(){ GoCrazy() })
+func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	if funcDidPanic, panicValue, _ := didPanic(f); !funcDidPanic {
+		return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
+	}
+
+	return true
+}
+
+// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//	assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
+func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	funcDidPanic, panicValue, panickedStack := didPanic(f)
+	if !funcDidPanic {
+		return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
+	}
+	if panicValue != expected {
+		return Fail(t, fmt.Sprintf("func %#v should panic with value:\t%#v\n\tPanic value:\t%#v\n\tPanic stack:\t%s", f, expected, panicValue, panickedStack), msgAndArgs...)
+	}
+
+	return true
+}
+
+// PanicsWithError asserts that the code inside the specified PanicTestFunc
+// panics, and that the recovered panic value is an error that satisfies the
+// EqualError comparison.
+//
+//	assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
+func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	funcDidPanic, panicValue, panickedStack := didPanic(f)
+	if !funcDidPanic {
+		return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
+	}
+	panicErr, ok := panicValue.(error)
+	if !ok || panicErr.Error() != errString {
+		return Fail(t, fmt.Sprintf("func %#v should panic with error message:\t%#v\n\tPanic value:\t%#v\n\tPanic stack:\t%s", f, errString, panicValue, panickedStack), msgAndArgs...)
+	}
+
+	return true
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//	assert.NotPanics(t, func(){ RemainCalm() })
+func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	if funcDidPanic, panicValue, panickedStack := didPanic(f); funcDidPanic {
+		return Fail(t, fmt.Sprintf("func %#v should not panic\n\tPanic value:\t%v\n\tPanic stack:\t%s", f, panicValue, panickedStack), msgAndArgs...)
+	}
+
+	return true
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+//	assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
+func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	dt := expected.Sub(actual)
+	if dt < -delta || dt > delta {
+		return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
+	}
+
+	return true
+}
+
+// WithinRange asserts that a time is within a time range (inclusive).
+//
+//	assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
+func WithinRange(t TestingT, actual, start, end time.Time, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	if end.Before(start) {
+		return Fail(t, "Start should be before end", msgAndArgs...)
+	}
+
+	if actual.Before(start) {
+		return Fail(t, fmt.Sprintf("Time %v expected to be in time range %v to %v, but is before the range", actual, start, end), msgAndArgs...)
+	} else if actual.After(end) {
+		return Fail(t, fmt.Sprintf("Time %v expected to be in time range %v to %v, but is after the range", actual, start, end), msgAndArgs...)
+	}
+
+	return true
+}
+
+func toFloat(x interface{}) (float64, bool) {
+	var xf float64
+	xok := true
+
+	switch xn := x.(type) {
+	case uint:
+		xf = float64(xn)
+	case uint8:
+		xf = float64(xn)
+	case uint16:
+		xf = float64(xn)
+	case uint32:
+		xf = float64(xn)
+	case uint64:
+		xf = float64(xn)
+	case int:
+		xf = float64(xn)
+	case int8:
+		xf = float64(xn)
+	case int16:
+		xf = float64(xn)
+	case int32:
+		xf = float64(xn)
+	case int64:
+		xf = float64(xn)
+	case float32:
+		xf = float64(xn)
+	case float64:
+		xf = xn
+	case time.Duration:
+		xf = float64(xn)
+	default:
+		xok = false
+	}
+
+	return xf, xok
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+//	assert.InDelta(t, math.Pi, 22/7.0, 0.01)
+func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	af, aok := toFloat(expected)
+	bf, bok := toFloat(actual)
+
+	if !aok || !bok {
+		return Fail(t, "Parameters must be numerical", msgAndArgs...)
+	}
+
+	if math.IsNaN(af) && math.IsNaN(bf) {
+		return true
+	}
+
+	if math.IsNaN(af) {
+		return Fail(t, "Expected must not be NaN", msgAndArgs...)
+	}
+
+	if math.IsNaN(bf) {
+		return Fail(t, fmt.Sprintf("Expected %v with delta %v, but was NaN", expected, delta), msgAndArgs...)
+	}
+
+	dt := af - bf
+	if dt < -delta || dt > delta {
+		return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
+	}
+
+	return true
+}
+
+// InDeltaSlice is the same as InDelta, except it compares two slices.
+func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if expected == nil || actual == nil ||
+		reflect.TypeOf(actual).Kind() != reflect.Slice ||
+		reflect.TypeOf(expected).Kind() != reflect.Slice {
+		return Fail(t, "Parameters must be slice", msgAndArgs...)
+	}
+
+	actualSlice := reflect.ValueOf(actual)
+	expectedSlice := reflect.ValueOf(expected)
+
+	for i := 0; i < actualSlice.Len(); i++ {
+		result := InDelta(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta, msgAndArgs...)
+		if !result {
+			return result
+		}
+	}
+
+	return true
+}
+
+// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
+func InDeltaMapValues(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if expected == nil || actual == nil ||
+		reflect.TypeOf(actual).Kind() != reflect.Map ||
+		reflect.TypeOf(expected).Kind() != reflect.Map {
+		return Fail(t, "Arguments must be maps", msgAndArgs...)
+	}
+
+	expectedMap := reflect.ValueOf(expected)
+	actualMap := reflect.ValueOf(actual)
+
+	if expectedMap.Len() != actualMap.Len() {
+		return Fail(t, "Arguments must have the same number of keys", msgAndArgs...)
+	}
+
+	for _, k := range expectedMap.MapKeys() {
+		ev := expectedMap.MapIndex(k)
+		av := actualMap.MapIndex(k)
+
+		if !ev.IsValid() {
+			return Fail(t, fmt.Sprintf("missing key %q in expected map", k), msgAndArgs...)
+		}
+
+		if !av.IsValid() {
+			return Fail(t, fmt.Sprintf("missing key %q in actual map", k), msgAndArgs...)
+		}
+
+		if !InDelta(
+			t,
+			ev.Interface(),
+			av.Interface(),
+			delta,
+			msgAndArgs...,
+		) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func calcRelativeError(expected, actual interface{}) (float64, error) {
+	af, aok := toFloat(expected)
+	bf, bok := toFloat(actual)
+	if !aok || !bok {
+		return 0, fmt.Errorf("Parameters must be numerical")
+	}
+	if math.IsNaN(af) && math.IsNaN(bf) {
+		return 0, nil
+	}
+	if math.IsNaN(af) {
+		return 0, errors.New("expected value must not be NaN")
+	}
+	if af == 0 {
+		return 0, fmt.Errorf("expected value must have a value other than zero to calculate the relative error")
+	}
+	if math.IsNaN(bf) {
+		return 0, errors.New("actual value must not be NaN")
+	}
+
+	return math.Abs(af-bf) / math.Abs(af), nil
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if math.IsNaN(epsilon) {
+		return Fail(t, "epsilon must not be NaN", msgAndArgs...)
+	}
+	actualEpsilon, err := calcRelativeError(expected, actual)
+	if err != nil {
+		return Fail(t, err.Error(), msgAndArgs...)
+	}
+	if actualEpsilon > epsilon {
+		return Fail(t, fmt.Sprintf("Relative error is too high: %#v (expected)\n"+
+			"        < %#v (actual)", epsilon, actualEpsilon), msgAndArgs...)
+	}
+
+	return true
+}
+
+// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
+func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	if expected == nil || actual == nil {
+		return Fail(t, "Parameters must be slice", msgAndArgs...)
+	}
+
+	expectedSlice := reflect.ValueOf(expected)
+	actualSlice := reflect.ValueOf(actual)
+
+	if expectedSlice.Type().Kind() != reflect.Slice {
+		return Fail(t, "Expected value must be slice", msgAndArgs...)
+	}
+
+	expectedLen := expectedSlice.Len()
+	if !IsType(t, expected, actual) || !Len(t, actual, expectedLen) {
+		return false
+	}
+
+	for i := 0; i < expectedLen; i++ {
+		if !InEpsilon(t, expectedSlice.Index(i).Interface(), actualSlice.Index(i).Interface(), epsilon, "at index %d", i) {
+			return false
+		}
+	}
+
+	return true
+}
+
+/*
+	Errors
+*/
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if assert.NoError(t, err) {
+//		   assert.Equal(t, expectedObj, actualObj)
+//	  }
+func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
+	if err != nil {
+		if h, ok := t.(tHelper); ok {
+			h.Helper()
+		}
+		return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...)
+	}
+
+	return true
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if assert.Error(t, err) {
+//		   assert.Equal(t, expectedError, err)
+//	  }
+func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
+	if err == nil {
+		if h, ok := t.(tHelper); ok {
+			h.Helper()
+		}
+		return Fail(t, "An error is expected but got nil.", msgAndArgs...)
+	}
+
+	return true
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//	actualObj, err := SomeFunction()
+//	assert.EqualError(t, err,  expectedErrorString)
+func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if !Error(t, theError, msgAndArgs...) {
+		return false
+	}
+	expected := errString
+	actual := theError.Error()
+	// don't need to use deep equals here, we know they are both strings
+	if expected != actual {
+		return Fail(t, fmt.Sprintf("Error message not equal:\n"+
+			"expected: %q\n"+
+			"actual  : %q", expected, actual), msgAndArgs...)
+	}
+	return true
+}
+
+// ErrorContains asserts that a function returned an error (i.e. not `nil`)
+// and that the error contains the specified substring.
+//
+//	actualObj, err := SomeFunction()
+//	assert.ErrorContains(t, err,  expectedErrorSubString)
+func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if !Error(t, theError, msgAndArgs...) {
+		return false
+	}
+
+	actual := theError.Error()
+	if !strings.Contains(actual, contains) {
+		return Fail(t, fmt.Sprintf("Error %#v does not contain %#v", actual, contains), msgAndArgs...)
+	}
+
+	return true
+}
+
+// matchRegexp return true if a specified regexp matches a string.
+func matchRegexp(rx interface{}, str interface{}) bool {
+
+	var r *regexp.Regexp
+	if rr, ok := rx.(*regexp.Regexp); ok {
+		r = rr
+	} else {
+		r = regexp.MustCompile(fmt.Sprint(rx))
+	}
+
+	return (r.FindStringIndex(fmt.Sprint(str)) != nil)
+
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+//	assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+//	assert.Regexp(t, "start...$", "it's not starting")
+func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	match := matchRegexp(rx, str)
+
+	if !match {
+		Fail(t, fmt.Sprintf("Expect \"%v\" to match \"%v\"", str, rx), msgAndArgs...)
+	}
+
+	return match
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+//	assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+//	assert.NotRegexp(t, "^start", "it's not starting")
+func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	match := matchRegexp(rx, str)
+
+	if match {
+		Fail(t, fmt.Sprintf("Expect \"%v\" to NOT match \"%v\"", str, rx), msgAndArgs...)
+	}
+
+	return !match
+
+}
+
+// Zero asserts that i is the zero value for its type.
+func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) {
+		return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...)
+	}
+	return true
+}
+
+// NotZero asserts that i is not the zero value for its type.
+func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if i == nil || reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) {
+		return Fail(t, fmt.Sprintf("Should not be zero, but was %v", i), msgAndArgs...)
+	}
+	return true
+}
+
+// FileExists checks whether a file exists in the given path. It also fails if
+// the path points to a directory or there is an error when trying to check the file.
+func FileExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	info, err := os.Lstat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...)
+		}
+		return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...)
+	}
+	if info.IsDir() {
+		return Fail(t, fmt.Sprintf("%q is a directory", path), msgAndArgs...)
+	}
+	return true
+}
+
+// NoFileExists checks whether a file does not exist in a given path. It fails
+// if the path points to an existing _file_ only.
+func NoFileExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	info, err := os.Lstat(path)
+	if err != nil {
+		return true
+	}
+	if info.IsDir() {
+		return true
+	}
+	return Fail(t, fmt.Sprintf("file %q exists", path), msgAndArgs...)
+}
+
+// DirExists checks whether a directory exists in the given path. It also fails
+// if the path is a file rather a directory or there is an error checking whether it exists.
+func DirExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	info, err := os.Lstat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...)
+		}
+		return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...)
+	}
+	if !info.IsDir() {
+		return Fail(t, fmt.Sprintf("%q is a file", path), msgAndArgs...)
+	}
+	return true
+}
+
+// NoDirExists checks whether a directory does not exist in the given path.
+// It fails if the path points to an existing _directory_ only.
+func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	info, err := os.Lstat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return true
+		}
+		return true
+	}
+	if !info.IsDir() {
+		return true
+	}
+	return Fail(t, fmt.Sprintf("directory %q exists", path), msgAndArgs...)
+}
+
+// JSONEq asserts that two JSON strings are equivalent.
+//
+//	assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	var expectedJSONAsInterface, actualJSONAsInterface interface{}
+
+	if err := json.Unmarshal([]byte(expected), &expectedJSONAsInterface); err != nil {
+		return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid json.\nJSON parsing error: '%s'", expected, err.Error()), msgAndArgs...)
+	}
+
+	if err := json.Unmarshal([]byte(actual), &actualJSONAsInterface); err != nil {
+		return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid json.\nJSON parsing error: '%s'", actual, err.Error()), msgAndArgs...)
+	}
+
+	return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...)
+}
+
+func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) {
+	t := reflect.TypeOf(v)
+	k := t.Kind()
+
+	if k == reflect.Ptr {
+		t = t.Elem()
+		k = t.Kind()
+	}
+	return t, k
+}
+
+// diff returns a diff of both values as long as both are of the same type and
+// are a struct, map, slice, array or string. Otherwise it returns an empty string.
+func diff(expected interface{}, actual interface{}) string {
+	if expected == nil || actual == nil {
+		return ""
+	}
+
+	et, ek := typeAndKind(expected)
+	at, _ := typeAndKind(actual)
+
+	if et != at {
+		return ""
+	}
+
+	if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array && ek != reflect.String {
+		return ""
+	}
+
+	var e, a string
+
+	switch et {
+	case reflect.TypeOf(""):
+		e = reflect.ValueOf(expected).String()
+		a = reflect.ValueOf(actual).String()
+	case reflect.TypeOf(time.Time{}):
+		e = spewConfigStringerEnabled.Sdump(expected)
+		a = spewConfigStringerEnabled.Sdump(actual)
+	default:
+		e = spewConfig.Sdump(expected)
+		a = spewConfig.Sdump(actual)
+	}
+
+	diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
+		A:        difflib.SplitLines(e),
+		B:        difflib.SplitLines(a),
+		FromFile: "Expected",
+		FromDate: "",
+		ToFile:   "Actual",
+		ToDate:   "",
+		Context:  1,
+	})
+
+	return "\n\nDiff:\n" + diff
+}
+
+func isFunction(arg interface{}) bool {
+	if arg == nil {
+		return false
+	}
+	return reflect.TypeOf(arg).Kind() == reflect.Func
+}
+
+var spewConfig = spew.ConfigState{
+	Indent:                  " ",
+	DisablePointerAddresses: true,
+	DisableCapacities:       true,
+	SortKeys:                true,
+	DisableMethods:          true,
+	MaxDepth:                10,
+}
+
+var spewConfigStringerEnabled = spew.ConfigState{
+	Indent:                  " ",
+	DisablePointerAddresses: true,
+	DisableCapacities:       true,
+	SortKeys:                true,
+	MaxDepth:                10,
+}
+
+type tHelper = interface {
+	Helper()
+}
+
+// Eventually asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick.
+//
+//	assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
+func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	ch := make(chan bool, 1)
+
+	timer := time.NewTimer(waitFor)
+	defer timer.Stop()
+
+	ticker := time.NewTicker(tick)
+	defer ticker.Stop()
+
+	for tick := ticker.C; ; {
+		select {
+		case <-timer.C:
+			return Fail(t, "Condition never satisfied", msgAndArgs...)
+		case <-tick:
+			tick = nil
+			go func() { ch <- condition() }()
+		case v := <-ch:
+			if v {
+				return true
+			}
+			tick = ticker.C
+		}
+	}
+}
+
+// CollectT implements the TestingT interface and collects all errors.
+type CollectT struct {
+	errors []error
+}
+
+// Errorf collects the error.
+func (c *CollectT) Errorf(format string, args ...interface{}) {
+	c.errors = append(c.errors, fmt.Errorf(format, args...))
+}
+
+// FailNow panics.
+func (*CollectT) FailNow() {
+	panic("Assertion failed")
+}
+
+// Deprecated: That was a method for internal usage that should not have been published. Now just panics.
+func (*CollectT) Reset() {
+	panic("Reset() is deprecated")
+}
+
+// Deprecated: That was a method for internal usage that should not have been published. Now just panics.
+func (*CollectT) Copy(TestingT) {
+	panic("Copy() is deprecated")
+}
+
+// EventuallyWithT asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+//	externalValue := false
+//	go func() {
+//		time.Sleep(8*time.Second)
+//		externalValue = true
+//	}()
+//	assert.EventuallyWithT(t, func(c *assert.CollectT) {
+//		// add assertions as needed; any assertion failure will fail the current tick
+//		assert.True(c, externalValue, "expected 'externalValue' to be true")
+//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	var lastFinishedTickErrs []error
+	ch := make(chan []error, 1)
+
+	timer := time.NewTimer(waitFor)
+	defer timer.Stop()
+
+	ticker := time.NewTicker(tick)
+	defer ticker.Stop()
+
+	for tick := ticker.C; ; {
+		select {
+		case <-timer.C:
+			for _, err := range lastFinishedTickErrs {
+				t.Errorf("%v", err)
+			}
+			return Fail(t, "Condition never satisfied", msgAndArgs...)
+		case <-tick:
+			tick = nil
+			go func() {
+				collect := new(CollectT)
+				defer func() {
+					ch <- collect.errors
+				}()
+				condition(collect)
+			}()
+		case errs := <-ch:
+			if len(errs) == 0 {
+				return true
+			}
+			// Keep the errors from the last ended condition, so that they can be copied to t if timeout is reached.
+			lastFinishedTickErrs = errs
+			tick = ticker.C
+		}
+	}
+}
+
+// Never asserts that the given condition doesn't satisfy in waitFor time,
+// periodically checking the target function each tick.
+//
+//	assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
+func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	ch := make(chan bool, 1)
+
+	timer := time.NewTimer(waitFor)
+	defer timer.Stop()
+
+	ticker := time.NewTicker(tick)
+	defer ticker.Stop()
+
+	for tick := ticker.C; ; {
+		select {
+		case <-timer.C:
+			return true
+		case <-tick:
+			tick = nil
+			go func() { ch <- condition() }()
+		case v := <-ch:
+			if v {
+				return Fail(t, "Condition satisfied", msgAndArgs...)
+			}
+			tick = ticker.C
+		}
+	}
+}
+
+// ErrorIs asserts that at least one of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func ErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if errors.Is(err, target) {
+		return true
+	}
+
+	var expectedText string
+	if target != nil {
+		expectedText = target.Error()
+	}
+
+	chain := buildErrorChainString(err)
+
+	return Fail(t, fmt.Sprintf("Target error should be in err chain:\n"+
+		"expected: %q\n"+
+		"in chain: %s", expectedText, chain,
+	), msgAndArgs...)
+}
+
+// NotErrorIs asserts that at none of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func NotErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if !errors.Is(err, target) {
+		return true
+	}
+
+	var expectedText string
+	if target != nil {
+		expectedText = target.Error()
+	}
+
+	chain := buildErrorChainString(err)
+
+	return Fail(t, fmt.Sprintf("Target error should not be in err chain:\n"+
+		"found: %q\n"+
+		"in chain: %s", expectedText, chain,
+	), msgAndArgs...)
+}
+
+// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
+// This is a wrapper for errors.As.
+func ErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if errors.As(err, target) {
+		return true
+	}
+
+	chain := buildErrorChainString(err)
+
+	return Fail(t, fmt.Sprintf("Should be in error chain:\n"+
+		"expected: %q\n"+
+		"in chain: %s", target, chain,
+	), msgAndArgs...)
+}
+
+func buildErrorChainString(err error) string {
+	if err == nil {
+		return ""
+	}
+
+	e := errors.Unwrap(err)
+	chain := fmt.Sprintf("%q", err.Error())
+	for e != nil {
+		chain += fmt.Sprintf("\n\t%q", e.Error())
+		e = errors.Unwrap(e)
+	}
+	return chain
+}
diff --git a/internal/testify/assert/assertions_test.go b/internal/testify/assert/assertions_test.go
new file mode 100644
index 000000000..fa004a0a3
--- /dev/null
+++ b/internal/testify/assert/assertions_test.go
@@ -0,0 +1,3155 @@
+package assert
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+var (
+	i     interface{}
+	zeros = []interface{}{
+		false,
+		byte(0),
+		complex64(0),
+		complex128(0),
+		float32(0),
+		float64(0),
+		int(0),
+		int8(0),
+		int16(0),
+		int32(0),
+		int64(0),
+		rune(0),
+		uint(0),
+		uint8(0),
+		uint16(0),
+		uint32(0),
+		uint64(0),
+		uintptr(0),
+		"",
+		[0]interface{}{},
+		[]interface{}(nil),
+		struct{ x int }{},
+		(*interface{})(nil),
+		(func())(nil),
+		nil,
+		interface{}(nil),
+		map[interface{}]interface{}(nil),
+		(chan interface{})(nil),
+		(<-chan interface{})(nil),
+		(chan<- interface{})(nil),
+	}
+	nonZeros = []interface{}{
+		true,
+		byte(1),
+		complex64(1),
+		complex128(1),
+		float32(1),
+		float64(1),
+		int(1),
+		int8(1),
+		int16(1),
+		int32(1),
+		int64(1),
+		rune(1),
+		uint(1),
+		uint8(1),
+		uint16(1),
+		uint32(1),
+		uint64(1),
+		uintptr(1),
+		"s",
+		[1]interface{}{1},
+		[]interface{}{},
+		struct{ x int }{1},
+		(&i),
+		(func() {}),
+		interface{}(1),
+		map[interface{}]interface{}{},
+		(make(chan interface{})),
+		(<-chan interface{})(make(chan interface{})),
+		(chan<- interface{})(make(chan interface{})),
+	}
+)
+
+// AssertionTesterInterface defines an interface to be used for testing assertion methods
+type AssertionTesterInterface interface {
+	TestMethod()
+}
+
+// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface
+type AssertionTesterConformingObject struct {
+}
+
+func (a *AssertionTesterConformingObject) TestMethod() {
+}
+
+// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface
+type AssertionTesterNonConformingObject struct {
+}
+
+func TestObjectsAreEqual(t *testing.T) {
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+	}{
+		// cases that are expected to be equal
+		{"Hello World", "Hello World", true},
+		{123, 123, true},
+		{123.5, 123.5, true},
+		{[]byte("Hello World"), []byte("Hello World"), true},
+		{nil, nil, true},
+
+		// cases that are expected not to be equal
+		{map[int]int{5: 10}, map[int]int{10: 20}, false},
+		{'x', "x", false},
+		{"x", 'x', false},
+		{0, 0.1, false},
+		{0.1, 0, false},
+		{time.Now, time.Now, false},
+		{func() {}, func() {}, false},
+		{uint32(10), int32(10), false},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("ObjectsAreEqual(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := ObjectsAreEqual(c.expected, c.actual)
+
+			if res != c.result {
+				t.Errorf("ObjectsAreEqual(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
+			}
+
+		})
+	}
+}
+
+func TestObjectsAreEqualValues(t *testing.T) {
+	now := time.Now()
+
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+	}{
+		{uint32(10), int32(10), true},
+		{0, nil, false},
+		{nil, 0, false},
+		{now, now.In(time.Local), false}, // should not be time zone independent
+		{int(270), int8(14), false},      // should handle overflow/underflow
+		{int8(14), int(270), false},
+		{[]int{270, 270}, []int8{14, 14}, false},
+		{complex128(1e+100 + 1e+100i), complex64(complex(math.Inf(0), math.Inf(0))), false},
+		{complex64(complex(math.Inf(0), math.Inf(0))), complex128(1e+100 + 1e+100i), false},
+		{complex128(1e+100 + 1e+100i), 270, false},
+		{270, complex128(1e+100 + 1e+100i), false},
+		{complex128(1e+100 + 1e+100i), 3.14, false},
+		{3.14, complex128(1e+100 + 1e+100i), false},
+		{complex128(1e+10 + 1e+10i), complex64(1e+10 + 1e+10i), true},
+		{complex64(1e+10 + 1e+10i), complex128(1e+10 + 1e+10i), true},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("ObjectsAreEqualValues(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := ObjectsAreEqualValues(c.expected, c.actual)
+
+			if res != c.result {
+				t.Errorf("ObjectsAreEqualValues(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
+			}
+		})
+	}
+}
+
+type Nested struct {
+	Exported    interface{}
+	notExported interface{}
+}
+
+type S struct {
+	Exported1    interface{}
+	Exported2    Nested
+	notExported1 interface{}
+	notExported2 Nested
+}
+
+type S2 struct {
+	foo interface{}
+}
+
+type S3 struct {
+	Exported1 *Nested
+	Exported2 *Nested
+}
+
+type S4 struct {
+	Exported1 []*Nested
+}
+
+type S5 struct {
+	Exported Nested
+}
+
+type S6 struct {
+	Exported   string
+	unexported string
+}
+
+func TestObjectsExportedFieldsAreEqual(t *testing.T) {
+
+	intValue := 1
+
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+	}{
+		{S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, 3}, 4, Nested{5, 6}}, true},
+		{S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, 3}, "a", Nested{5, 6}}, true},
+		{S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, 3}, 4, Nested{5, "a"}}, true},
+		{S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, 3}, 4, Nested{"a", "a"}}, true},
+		{S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, "a"}, 4, Nested{5, 6}}, true},
+		{S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{"a", Nested{2, 3}, 4, Nested{5, 6}}, false},
+		{S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{"a", 3}, 4, Nested{5, 6}}, false},
+		{S{1, Nested{2, 3}, 4, Nested{5, 6}}, S2{1}, false},
+		{1, S{1, Nested{2, 3}, 4, Nested{5, 6}}, false},
+
+		{S3{&Nested{1, 2}, &Nested{3, 4}}, S3{&Nested{1, 2}, &Nested{3, 4}}, true},
+		{S3{nil, &Nested{3, 4}}, S3{nil, &Nested{3, 4}}, true},
+		{S3{&Nested{1, 2}, &Nested{3, 4}}, S3{&Nested{1, 2}, &Nested{3, "b"}}, true},
+		{S3{&Nested{1, 2}, &Nested{3, 4}}, S3{&Nested{1, "a"}, &Nested{3, "b"}}, true},
+		{S3{&Nested{1, 2}, &Nested{3, 4}}, S3{&Nested{"a", 2}, &Nested{3, 4}}, false},
+		{S3{&Nested{1, 2}, &Nested{3, 4}}, S3{}, false},
+		{S3{}, S3{}, true},
+
+		{S4{[]*Nested{{1, 2}}}, S4{[]*Nested{{1, 2}}}, true},
+		{S4{[]*Nested{{1, 2}}}, S4{[]*Nested{{1, 3}}}, true},
+		{S4{[]*Nested{{1, 2}, {3, 4}}}, S4{[]*Nested{{1, "a"}, {3, "b"}}}, true},
+		{S4{[]*Nested{{1, 2}, {3, 4}}}, S4{[]*Nested{{1, "a"}, {2, "b"}}}, false},
+
+		{Nested{&intValue, 2}, Nested{&intValue, 2}, true},
+		{Nested{&Nested{1, 2}, 3}, Nested{&Nested{1, "b"}, 3}, true},
+		{Nested{&Nested{1, 2}, 3}, Nested{nil, 3}, false},
+
+		{
+			Nested{map[interface{}]*Nested{nil: nil}, 2},
+			Nested{map[interface{}]*Nested{nil: nil}, 2},
+			true,
+		},
+		{
+			Nested{map[interface{}]*Nested{"a": nil}, 2},
+			Nested{map[interface{}]*Nested{"a": nil}, 2},
+			true,
+		},
+		{
+			Nested{map[interface{}]*Nested{"a": nil}, 2},
+			Nested{map[interface{}]*Nested{"a": {1, 2}}, 2},
+			false,
+		},
+		{
+			Nested{map[interface{}]Nested{"a": {1, 2}, "b": {3, 4}}, 2},
+			Nested{map[interface{}]Nested{"a": {1, 5}, "b": {3, 7}}, 2},
+			true,
+		},
+		{
+			Nested{map[interface{}]Nested{"a": {1, 2}, "b": {3, 4}}, 2},
+			Nested{map[interface{}]Nested{"a": {2, 2}, "b": {3, 4}}, 2},
+			false,
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("ObjectsExportedFieldsAreEqual(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := ObjectsExportedFieldsAreEqual(c.expected, c.actual)
+
+			if res != c.result {
+				t.Errorf("ObjectsExportedFieldsAreEqual(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
+			}
+
+		})
+	}
+}
+
+func TestCopyExportedFields(t *testing.T) {
+	intValue := 1
+
+	cases := []struct {
+		input    interface{}
+		expected interface{}
+	}{
+		{
+			input:    Nested{"a", "b"},
+			expected: Nested{"a", nil},
+		},
+		{
+			input:    Nested{&intValue, 2},
+			expected: Nested{&intValue, nil},
+		},
+		{
+			input:    Nested{nil, 3},
+			expected: Nested{nil, nil},
+		},
+		{
+			input:    S{1, Nested{2, 3}, 4, Nested{5, 6}},
+			expected: S{1, Nested{2, nil}, nil, Nested{}},
+		},
+		{
+			input:    S3{},
+			expected: S3{},
+		},
+		{
+			input:    S3{&Nested{1, 2}, &Nested{3, 4}},
+			expected: S3{&Nested{1, nil}, &Nested{3, nil}},
+		},
+		{
+			input:    S3{Exported1: &Nested{"a", "b"}},
+			expected: S3{Exported1: &Nested{"a", nil}},
+		},
+		{
+			input: S4{[]*Nested{
+				nil,
+				{1, 2},
+			}},
+			expected: S4{[]*Nested{
+				nil,
+				{1, nil},
+			}},
+		},
+		{
+			input: S4{[]*Nested{
+				{1, 2}},
+			},
+			expected: S4{[]*Nested{
+				{1, nil}},
+			},
+		},
+		{
+			input: S4{[]*Nested{
+				{1, 2},
+				{3, 4},
+			}},
+			expected: S4{[]*Nested{
+				{1, nil},
+				{3, nil},
+			}},
+		},
+		{
+			input:    S5{Exported: Nested{"a", "b"}},
+			expected: S5{Exported: Nested{"a", nil}},
+		},
+		{
+			input:    S6{"a", "b"},
+			expected: S6{"a", ""},
+		},
+	}
+
+	for _, c := range cases {
+		t.Run("", func(t *testing.T) {
+			output := copyExportedFields(c.input)
+			if !ObjectsAreEqualValues(c.expected, output) {
+				t.Errorf("%#v, %#v should be equal", c.expected, output)
+			}
+		})
+	}
+}
+
+func TestEqualExportedValues(t *testing.T) {
+	cases := []struct {
+		value1        interface{}
+		value2        interface{}
+		expectedEqual bool
+		expectedFail  string
+	}{
+		{
+			value1:        S{1, Nested{2, 3}, 4, Nested{5, 6}},
+			value2:        S{1, Nested{2, nil}, nil, Nested{}},
+			expectedEqual: true,
+		},
+		{
+			value1:        S{1, Nested{2, 3}, 4, Nested{5, 6}},
+			value2:        S{1, Nested{1, nil}, nil, Nested{}},
+			expectedEqual: false,
+			expectedFail: `
+	            	Diff:
+	            	--- Expected
+	            	+++ Actual
+	            	@@ -3,3 +3,3 @@
+	            	  Exported2: (assert.Nested) {
+	            	-  Exported: (int) 2,
+	            	+  Exported: (int) 1,
+	            	   notExported: (interface {}) <nil>`,
+		},
+		{
+			value1:        S3{&Nested{1, 2}, &Nested{3, 4}},
+			value2:        S3{&Nested{"a", 2}, &Nested{3, 4}},
+			expectedEqual: false,
+			expectedFail: `
+	            	Diff:
+	            	--- Expected
+	            	+++ Actual
+	            	@@ -2,3 +2,3 @@
+	            	  Exported1: (*assert.Nested)({
+	            	-  Exported: (int) 1,
+	            	+  Exported: (string) (len=1) "a",
+	            	   notExported: (interface {}) <nil>`,
+		},
+		{
+			value1: S4{[]*Nested{
+				{1, 2},
+				{3, 4},
+			}},
+			value2: S4{[]*Nested{
+				{1, "a"},
+				{2, "b"},
+			}},
+			expectedEqual: false,
+			expectedFail: `
+	            	Diff:
+	            	--- Expected
+	            	+++ Actual
+	            	@@ -7,3 +7,3 @@
+	            	   (*assert.Nested)({
+	            	-   Exported: (int) 3,
+	            	+   Exported: (int) 2,
+	            	    notExported: (interface {}) <nil>`,
+		},
+		{
+			value1:        S{[2]int{1, 2}, Nested{2, 3}, 4, Nested{5, 6}},
+			value2:        S{[2]int{1, 2}, Nested{2, nil}, nil, Nested{}},
+			expectedEqual: true,
+		},
+		{
+			value1:        &S{1, Nested{2, 3}, 4, Nested{5, 6}},
+			value2:        &S{1, Nested{2, nil}, nil, Nested{}},
+			expectedEqual: true,
+		},
+		{
+			value1:        &S{1, Nested{2, 3}, 4, Nested{5, 6}},
+			value2:        &S{1, Nested{1, nil}, nil, Nested{}},
+			expectedEqual: false,
+			expectedFail: `
+	            	Diff:
+	            	--- Expected
+	            	+++ Actual
+	            	@@ -3,3 +3,3 @@
+	            	  Exported2: (assert.Nested) {
+	            	-  Exported: (int) 2,
+	            	+  Exported: (int) 1,
+	            	   notExported: (interface {}) <nil>`,
+		},
+	}
+
+	for _, c := range cases {
+		t.Run("", func(t *testing.T) {
+			mockT := new(mockTestingT)
+
+			actual := EqualExportedValues(mockT, c.value1, c.value2)
+			if actual != c.expectedEqual {
+				t.Errorf("Expected EqualExportedValues to be %t, but was %t", c.expectedEqual, actual)
+			}
+
+			actualFail := mockT.errorString()
+			if !strings.Contains(actualFail, c.expectedFail) {
+				t.Errorf("Contains failure should include %q but was %q", c.expectedFail, actualFail)
+			}
+		})
+	}
+
+}
+
+func TestImplements(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
+		t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface")
+	}
+	if Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
+		t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface")
+	}
+	if Implements(mockT, (*AssertionTesterInterface)(nil), nil) {
+		t.Error("Implements method should return false: nil does not implement AssertionTesterInterface")
+	}
+
+}
+
+func TestNotImplements(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !NotImplements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
+		t.Error("NotImplements method should return true: AssertionTesterNonConformingObject does not implement AssertionTesterInterface")
+	}
+	if NotImplements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
+		t.Error("NotImplements method should return false: AssertionTesterConformingObject implements AssertionTesterInterface")
+	}
+	if NotImplements(mockT, (*AssertionTesterInterface)(nil), nil) {
+		t.Error("NotImplements method should return false: nil can't be checked to be implementing AssertionTesterInterface or not")
+	}
+
+}
+
+func TestIsType(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
+		t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject")
+	}
+	if IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) {
+		t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject")
+	}
+
+}
+
+func TestEqual(t *testing.T) {
+	type myType string
+
+	mockT := new(testing.T)
+	var m map[string]interface{}
+
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+		remark   string
+	}{
+		{"Hello World", "Hello World", true, ""},
+		{123, 123, true, ""},
+		{123.5, 123.5, true, ""},
+		{[]byte("Hello World"), []byte("Hello World"), true, ""},
+		{nil, nil, true, ""},
+		{int32(123), int32(123), true, ""},
+		{uint64(123), uint64(123), true, ""},
+		{myType("1"), myType("1"), true, ""},
+		{&struct{}{}, &struct{}{}, true, "pointer equality is based on equality of underlying value"},
+
+		// Not expected to be equal
+		{m["bar"], "something", false, ""},
+		{myType("1"), myType("2"), false, ""},
+
+		// A case that might be confusing, especially with numeric literals
+		{10, uint(10), false, ""},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("Equal(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := Equal(mockT, c.expected, c.actual)
+
+			if res != c.result {
+				t.Errorf("Equal(%#v, %#v) should return %#v: %s", c.expected, c.actual, c.result, c.remark)
+			}
+		})
+	}
+}
+
+func ptr(i int) *int {
+	return &i
+}
+
+func TestSame(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if Same(mockT, ptr(1), ptr(1)) {
+		t.Error("Same should return false")
+	}
+	if Same(mockT, 1, 1) {
+		t.Error("Same should return false")
+	}
+	p := ptr(2)
+	if Same(mockT, p, *p) {
+		t.Error("Same should return false")
+	}
+	if !Same(mockT, p, p) {
+		t.Error("Same should return true")
+	}
+}
+
+func TestNotSame(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !NotSame(mockT, ptr(1), ptr(1)) {
+		t.Error("NotSame should return true; different pointers")
+	}
+	if !NotSame(mockT, 1, 1) {
+		t.Error("NotSame should return true; constant inputs")
+	}
+	p := ptr(2)
+	if !NotSame(mockT, p, *p) {
+		t.Error("NotSame should return true; mixed-type inputs")
+	}
+	if NotSame(mockT, p, p) {
+		t.Error("NotSame should return false")
+	}
+}
+
+func Test_samePointers(t *testing.T) {
+	p := ptr(2)
+
+	type args struct {
+		first  interface{}
+		second interface{}
+	}
+	tests := []struct {
+		name      string
+		args      args
+		assertion BoolAssertionFunc
+	}{
+		{
+			name:      "1 != 2",
+			args:      args{first: 1, second: 2},
+			assertion: False,
+		},
+		{
+			name:      "1 != 1 (not same ptr)",
+			args:      args{first: 1, second: 1},
+			assertion: False,
+		},
+		{
+			name:      "ptr(1) == ptr(1)",
+			args:      args{first: p, second: p},
+			assertion: True,
+		},
+		{
+			name:      "int(1) != float32(1)",
+			args:      args{first: int(1), second: float32(1)},
+			assertion: False,
+		},
+		{
+			name:      "array != slice",
+			args:      args{first: [2]int{1, 2}, second: []int{1, 2}},
+			assertion: False,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, samePointers(tt.args.first, tt.args.second))
+		})
+	}
+}
+
+// bufferT implements TestingT. Its implementation of Errorf writes the output that would be produced by
+// testing.T.Errorf to an internal bytes.Buffer.
+type bufferT struct {
+	buf bytes.Buffer
+}
+
+func (t *bufferT) Errorf(format string, args ...interface{}) {
+	// implementation of decorate is copied from testing.T
+	decorate := func(s string) string {
+		_, file, line, ok := runtime.Caller(3) // decorate + log + public function.
+		if ok {
+			// Truncate file name at last file name separator.
+			if index := strings.LastIndex(file, "/"); index >= 0 {
+				file = file[index+1:]
+			} else if index = strings.LastIndex(file, "\\"); index >= 0 {
+				file = file[index+1:]
+			}
+		} else {
+			file = "???"
+			line = 1
+		}
+		buf := new(bytes.Buffer)
+		// Every line is indented at least one tab.
+		buf.WriteByte('\t')
+		fmt.Fprintf(buf, "%s:%d: ", file, line)
+		lines := strings.Split(s, "\n")
+		if l := len(lines); l > 1 && lines[l-1] == "" {
+			lines = lines[:l-1]
+		}
+		for i, line := range lines {
+			if i > 0 {
+				// Second and subsequent lines are indented an extra tab.
+				buf.WriteString("\n\t\t")
+			}
+			buf.WriteString(line)
+		}
+		buf.WriteByte('\n')
+		return buf.String()
+	}
+	t.buf.WriteString(decorate(fmt.Sprintf(format, args...)))
+}
+
+func TestStringEqual(t *testing.T) {
+	for i, currCase := range []struct {
+		equalWant  string
+		equalGot   string
+		msgAndArgs []interface{}
+		want       string
+	}{
+		{equalWant: "hi, \nmy name is", equalGot: "what,\nmy name is", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"hi, \\\\nmy name is\"\n\\s+actual\\s+: \"what,\\\\nmy name is\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1,2 \\+1,2 @@\n\\s+-hi, \n\\s+\\+what,\n\\s+my name is"},
+	} {
+		mockT := &bufferT{}
+		Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...)
+		Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i)
+	}
+}
+
+func TestEqualFormatting(t *testing.T) {
+	for i, currCase := range []struct {
+		equalWant  string
+		equalGot   string
+		msgAndArgs []interface{}
+		want       string
+	}{
+		{equalWant: "want", equalGot: "got", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n"},
+		{equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{"hello, %v!", "world"}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+hello, world!\n"},
+		{equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{123}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+123\n"},
+		{equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{struct{ a string }{"hello"}}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+{a:hello}\n"},
+	} {
+		mockT := &bufferT{}
+		Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...)
+		Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i)
+	}
+}
+
+func TestFormatUnequalValues(t *testing.T) {
+	expected, actual := formatUnequalValues("foo", "bar")
+	Equal(t, `"foo"`, expected, "value should not include type")
+	Equal(t, `"bar"`, actual, "value should not include type")
+
+	expected, actual = formatUnequalValues(123, 123)
+	Equal(t, `123`, expected, "value should not include type")
+	Equal(t, `123`, actual, "value should not include type")
+
+	expected, actual = formatUnequalValues(int64(123), int32(123))
+	Equal(t, `int64(123)`, expected, "value should include type")
+	Equal(t, `int32(123)`, actual, "value should include type")
+
+	expected, actual = formatUnequalValues(int64(123), nil)
+	Equal(t, `int64(123)`, expected, "value should include type")
+	Equal(t, `<nil>(<nil>)`, actual, "value should include type")
+
+	type testStructType struct {
+		Val string
+	}
+
+	expected, actual = formatUnequalValues(&testStructType{Val: "test"}, &testStructType{Val: "test"})
+	Equal(t, `&assert.testStructType{Val:"test"}`, expected, "value should not include type annotation")
+	Equal(t, `&assert.testStructType{Val:"test"}`, actual, "value should not include type annotation")
+}
+
+func TestNotNil(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !NotNil(mockT, new(AssertionTesterConformingObject)) {
+		t.Error("NotNil should return true: object is not nil")
+	}
+	if NotNil(mockT, nil) {
+		t.Error("NotNil should return false: object is nil")
+	}
+	if NotNil(mockT, (*struct{})(nil)) {
+		t.Error("NotNil should return false: object is (*struct{})(nil)")
+	}
+
+}
+
+func TestNil(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !Nil(mockT, nil) {
+		t.Error("Nil should return true: object is nil")
+	}
+	if !Nil(mockT, (*struct{})(nil)) {
+		t.Error("Nil should return true: object is (*struct{})(nil)")
+	}
+	if Nil(mockT, new(AssertionTesterConformingObject)) {
+		t.Error("Nil should return false: object is not nil")
+	}
+
+}
+
+func TestTrue(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !True(mockT, true) {
+		t.Error("True should return true")
+	}
+	if True(mockT, false) {
+		t.Error("True should return false")
+	}
+
+}
+
+func TestFalse(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !False(mockT, false) {
+		t.Error("False should return true")
+	}
+	if False(mockT, true) {
+		t.Error("False should return false")
+	}
+
+}
+
+func TestExactly(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	a := float32(1)
+	b := float64(1)
+	c := float32(1)
+	d := float32(2)
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+	}{
+		{a, b, false},
+		{a, d, false},
+		{a, c, true},
+		{nil, a, false},
+		{a, nil, false},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("Exactly(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := Exactly(mockT, c.expected, c.actual)
+
+			if res != c.result {
+				t.Errorf("Exactly(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
+			}
+		})
+	}
+}
+
+func TestNotEqual(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+	}{
+		// cases that are expected not to match
+		{"Hello World", "Hello World!", true},
+		{123, 1234, true},
+		{123.5, 123.55, true},
+		{[]byte("Hello World"), []byte("Hello World!"), true},
+		{nil, new(AssertionTesterConformingObject), true},
+
+		// cases that are expected to match
+		{nil, nil, false},
+		{"Hello World", "Hello World", false},
+		{123, 123, false},
+		{123.5, 123.5, false},
+		{[]byte("Hello World"), []byte("Hello World"), false},
+		{new(AssertionTesterConformingObject), new(AssertionTesterConformingObject), false},
+		{&struct{}{}, &struct{}{}, false},
+		{func() int { return 23 }, func() int { return 24 }, false},
+		// A case that might be confusing, especially with numeric literals
+		{int(10), uint(10), true},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("NotEqual(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := NotEqual(mockT, c.expected, c.actual)
+
+			if res != c.result {
+				t.Errorf("NotEqual(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
+			}
+		})
+	}
+}
+
+func TestNotEqualValues(t *testing.T) {
+	mockT := new(testing.T)
+
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+	}{
+		// cases that are expected not to match
+		{"Hello World", "Hello World!", true},
+		{123, 1234, true},
+		{123.5, 123.55, true},
+		{[]byte("Hello World"), []byte("Hello World!"), true},
+		{nil, new(AssertionTesterConformingObject), true},
+
+		// cases that are expected to match
+		{nil, nil, false},
+		{"Hello World", "Hello World", false},
+		{123, 123, false},
+		{123.5, 123.5, false},
+		{[]byte("Hello World"), []byte("Hello World"), false},
+		{new(AssertionTesterConformingObject), new(AssertionTesterConformingObject), false},
+		{&struct{}{}, &struct{}{}, false},
+
+		// Different behavior from NotEqual()
+		{func() int { return 23 }, func() int { return 24 }, true},
+		{int(10), int(11), true},
+		{int(10), uint(10), false},
+
+		{struct{}{}, struct{}{}, false},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("NotEqualValues(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := NotEqualValues(mockT, c.expected, c.actual)
+
+			if res != c.result {
+				t.Errorf("NotEqualValues(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
+			}
+		})
+	}
+}
+
+func TestContainsNotContains(t *testing.T) {
+
+	type A struct {
+		Name, Value string
+	}
+	list := []string{"Foo", "Bar"}
+
+	complexList := []*A{
+		{"b", "c"},
+		{"d", "e"},
+		{"g", "h"},
+		{"j", "k"},
+	}
+	simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
+	var zeroMap map[interface{}]interface{}
+
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+	}{
+		{"Hello World", "Hello", true},
+		{"Hello World", "Salut", false},
+		{list, "Bar", true},
+		{list, "Salut", false},
+		{complexList, &A{"g", "h"}, true},
+		{complexList, &A{"g", "e"}, false},
+		{simpleMap, "Foo", true},
+		{simpleMap, "Bar", false},
+		{zeroMap, "Bar", false},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("Contains(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			mockT := new(testing.T)
+			res := Contains(mockT, c.expected, c.actual)
+
+			if res != c.result {
+				if res {
+					t.Errorf("Contains(%#v, %#v) should return true:\n\t%#v contains %#v", c.expected, c.actual, c.expected, c.actual)
+				} else {
+					t.Errorf("Contains(%#v, %#v) should return false:\n\t%#v does not contain %#v", c.expected, c.actual, c.expected, c.actual)
+				}
+			}
+		})
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("NotContains(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			mockT := new(testing.T)
+			res := NotContains(mockT, c.expected, c.actual)
+
+			// NotContains should be inverse of Contains. If it's not, something is wrong
+			if res == Contains(mockT, c.expected, c.actual) {
+				if res {
+					t.Errorf("NotContains(%#v, %#v) should return true:\n\t%#v does not contains %#v", c.expected, c.actual, c.expected, c.actual)
+				} else {
+					t.Errorf("NotContains(%#v, %#v) should return false:\n\t%#v contains %#v", c.expected, c.actual, c.expected, c.actual)
+				}
+			}
+		})
+	}
+}
+
+func TestContainsNotContainsFailMessage(t *testing.T) {
+	mockT := new(mockTestingT)
+
+	type nonContainer struct {
+		Value string
+	}
+
+	cases := []struct {
+		assertion func(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool
+		container interface{}
+		instance  interface{}
+		expected  string
+	}{
+		{
+			assertion: Contains,
+			container: "Hello World",
+			instance:  errors.New("Hello"),
+			expected:  "\"Hello World\" does not contain &errors.errorString{s:\"Hello\"}",
+		},
+		{
+			assertion: Contains,
+			container: map[string]int{"one": 1},
+			instance:  "two",
+			expected:  "map[string]int{\"one\":1} does not contain \"two\"\n",
+		},
+		{
+			assertion: NotContains,
+			container: map[string]int{"one": 1},
+			instance:  "one",
+			expected:  "map[string]int{\"one\":1} should not contain \"one\"",
+		},
+		{
+			assertion: Contains,
+			container: nonContainer{Value: "Hello"},
+			instance:  "Hello",
+			expected:  "assert.nonContainer{Value:\"Hello\"} could not be applied builtin len()\n",
+		},
+		{
+			assertion: NotContains,
+			container: nonContainer{Value: "Hello"},
+			instance:  "Hello",
+			expected:  "assert.nonContainer{Value:\"Hello\"} could not be applied builtin len()\n",
+		},
+	}
+	for _, c := range cases {
+		name := filepath.Base(runtime.FuncForPC(reflect.ValueOf(c.assertion).Pointer()).Name())
+		t.Run(fmt.Sprintf("%v(%T, %T)", name, c.container, c.instance), func(t *testing.T) {
+			c.assertion(mockT, c.container, c.instance)
+			actualFail := mockT.errorString()
+			if !strings.Contains(actualFail, c.expected) {
+				t.Errorf("Contains failure should include %q but was %q", c.expected, actualFail)
+			}
+		})
+	}
+}
+
+func TestContainsNotContainsOnNilValue(t *testing.T) {
+	mockT := new(mockTestingT)
+
+	Contains(mockT, nil, "key")
+	expectedFail := "<nil> could not be applied builtin len()"
+	actualFail := mockT.errorString()
+	if !strings.Contains(actualFail, expectedFail) {
+		t.Errorf("Contains failure should include %q but was %q", expectedFail, actualFail)
+	}
+
+	NotContains(mockT, nil, "key")
+	if !strings.Contains(actualFail, expectedFail) {
+		t.Errorf("Contains failure should include %q but was %q", expectedFail, actualFail)
+	}
+}
+
+func TestSubsetNotSubset(t *testing.T) {
+	cases := []struct {
+		list    interface{}
+		subset  interface{}
+		result  bool
+		message string
+	}{
+		// cases that are expected to contain
+		{[]int{1, 2, 3}, nil, true, `nil is the empty set which is a subset of every set`},
+		{[]int{1, 2, 3}, []int{}, true, `[] is a subset of ['\x01' '\x02' '\x03']`},
+		{[]int{1, 2, 3}, []int{1, 2}, true, `['\x01' '\x02'] is a subset of ['\x01' '\x02' '\x03']`},
+		{[]int{1, 2, 3}, []int{1, 2, 3}, true, `['\x01' '\x02' '\x03'] is a subset of ['\x01' '\x02' '\x03']`},
+		{[]string{"hello", "world"}, []string{"hello"}, true, `["hello"] is a subset of ["hello" "world"]`},
+		{map[string]string{
+			"a": "x",
+			"c": "z",
+			"b": "y",
+		}, map[string]string{
+			"a": "x",
+			"b": "y",
+		}, true, `map["a":"x" "b":"y"] is a subset of map["a":"x" "b":"y" "c":"z"]`},
+
+		// cases that are expected not to contain
+		{[]string{"hello", "world"}, []string{"hello", "testify"}, false, `[]string{"hello", "world"} does not contain "testify"`},
+		{[]int{1, 2, 3}, []int{4, 5}, false, `[]int{1, 2, 3} does not contain 4`},
+		{[]int{1, 2, 3}, []int{1, 5}, false, `[]int{1, 2, 3} does not contain 5`},
+		{map[string]string{
+			"a": "x",
+			"c": "z",
+			"b": "y",
+		}, map[string]string{
+			"a": "x",
+			"b": "z",
+		}, false, `map[string]string{"a":"x", "b":"y", "c":"z"} does not contain map[string]string{"a":"x", "b":"z"}`},
+		{map[string]string{
+			"a": "x",
+			"b": "y",
+		}, map[string]string{
+			"a": "x",
+			"b": "y",
+			"c": "z",
+		}, false, `map[string]string{"a":"x", "b":"y"} does not contain map[string]string{"a":"x", "b":"y", "c":"z"}`},
+	}
+
+	for _, c := range cases {
+		t.Run("SubSet: "+c.message, func(t *testing.T) {
+
+			mockT := new(mockTestingT)
+			res := Subset(mockT, c.list, c.subset)
+
+			if res != c.result {
+				t.Errorf("Subset should return %t: %s", c.result, c.message)
+			}
+			if !c.result {
+				expectedFail := c.message
+				actualFail := mockT.errorString()
+				if !strings.Contains(actualFail, expectedFail) {
+					t.Log(actualFail)
+					t.Errorf("Subset failure should contain %q but was %q", expectedFail, actualFail)
+				}
+			}
+		})
+	}
+	for _, c := range cases {
+		t.Run("NotSubSet: "+c.message, func(t *testing.T) {
+			mockT := new(mockTestingT)
+			res := NotSubset(mockT, c.list, c.subset)
+
+			// NotSubset should match the inverse of Subset. If it doesn't, something is wrong
+			if res == Subset(mockT, c.list, c.subset) {
+				t.Errorf("NotSubset should return %t: %s", !c.result, c.message)
+			}
+			if c.result {
+				expectedFail := c.message
+				actualFail := mockT.errorString()
+				if !strings.Contains(actualFail, expectedFail) {
+					t.Log(actualFail)
+					t.Errorf("NotSubset failure should contain %q but was %q", expectedFail, actualFail)
+				}
+			}
+		})
+	}
+}
+
+func TestNotSubsetNil(t *testing.T) {
+	mockT := new(testing.T)
+	NotSubset(mockT, []string{"foo"}, nil)
+	if !mockT.Failed() {
+		t.Error("NotSubset on nil set should have failed the test")
+	}
+}
+
+func Test_containsElement(t *testing.T) {
+
+	list1 := []string{"Foo", "Bar"}
+	list2 := []int{1, 2}
+	simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
+
+	ok, found := containsElement("Hello World", "World")
+	True(t, ok)
+	True(t, found)
+
+	ok, found = containsElement(list1, "Foo")
+	True(t, ok)
+	True(t, found)
+
+	ok, found = containsElement(list1, "Bar")
+	True(t, ok)
+	True(t, found)
+
+	ok, found = containsElement(list2, 1)
+	True(t, ok)
+	True(t, found)
+
+	ok, found = containsElement(list2, 2)
+	True(t, ok)
+	True(t, found)
+
+	ok, found = containsElement(list1, "Foo!")
+	True(t, ok)
+	False(t, found)
+
+	ok, found = containsElement(list2, 3)
+	True(t, ok)
+	False(t, found)
+
+	ok, found = containsElement(list2, "1")
+	True(t, ok)
+	False(t, found)
+
+	ok, found = containsElement(simpleMap, "Foo")
+	True(t, ok)
+	True(t, found)
+
+	ok, found = containsElement(simpleMap, "Bar")
+	True(t, ok)
+	False(t, found)
+
+	ok, found = containsElement(1433, "1")
+	False(t, ok)
+	False(t, found)
+}
+
+func TestElementsMatch(t *testing.T) {
+	mockT := new(testing.T)
+
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+	}{
+		// matching
+		{nil, nil, true},
+
+		{nil, nil, true},
+		{[]int{}, []int{}, true},
+		{[]int{1}, []int{1}, true},
+		{[]int{1, 1}, []int{1, 1}, true},
+		{[]int{1, 2}, []int{1, 2}, true},
+		{[]int{1, 2}, []int{2, 1}, true},
+		{[2]int{1, 2}, [2]int{2, 1}, true},
+		{[]string{"hello", "world"}, []string{"world", "hello"}, true},
+		{[]string{"hello", "hello"}, []string{"hello", "hello"}, true},
+		{[]string{"hello", "hello", "world"}, []string{"hello", "world", "hello"}, true},
+		{[3]string{"hello", "hello", "world"}, [3]string{"hello", "world", "hello"}, true},
+		{[]int{}, nil, true},
+
+		// not matching
+		{[]int{1}, []int{1, 1}, false},
+		{[]int{1, 2}, []int{2, 2}, false},
+		{[]string{"hello", "hello"}, []string{"hello"}, false},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("ElementsMatch(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := ElementsMatch(mockT, c.actual, c.expected)
+
+			if res != c.result {
+				t.Errorf("ElementsMatch(%#v, %#v) should return %v", c.actual, c.expected, c.result)
+			}
+		})
+	}
+}
+
+func TestDiffLists(t *testing.T) {
+	tests := []struct {
+		name   string
+		listA  interface{}
+		listB  interface{}
+		extraA []interface{}
+		extraB []interface{}
+	}{
+		{
+			name:   "equal empty",
+			listA:  []string{},
+			listB:  []string{},
+			extraA: nil,
+			extraB: nil,
+		},
+		{
+			name:   "equal same order",
+			listA:  []string{"hello", "world"},
+			listB:  []string{"hello", "world"},
+			extraA: nil,
+			extraB: nil,
+		},
+		{
+			name:   "equal different order",
+			listA:  []string{"hello", "world"},
+			listB:  []string{"world", "hello"},
+			extraA: nil,
+			extraB: nil,
+		},
+		{
+			name:   "extra A",
+			listA:  []string{"hello", "hello", "world"},
+			listB:  []string{"hello", "world"},
+			extraA: []interface{}{"hello"},
+			extraB: nil,
+		},
+		{
+			name:   "extra A twice",
+			listA:  []string{"hello", "hello", "hello", "world"},
+			listB:  []string{"hello", "world"},
+			extraA: []interface{}{"hello", "hello"},
+			extraB: nil,
+		},
+		{
+			name:   "extra B",
+			listA:  []string{"hello", "world"},
+			listB:  []string{"hello", "hello", "world"},
+			extraA: nil,
+			extraB: []interface{}{"hello"},
+		},
+		{
+			name:   "extra B twice",
+			listA:  []string{"hello", "world"},
+			listB:  []string{"hello", "hello", "world", "hello"},
+			extraA: nil,
+			extraB: []interface{}{"hello", "hello"},
+		},
+		{
+			name:   "integers 1",
+			listA:  []int{1, 2, 3, 4, 5},
+			listB:  []int{5, 4, 3, 2, 1},
+			extraA: nil,
+			extraB: nil,
+		},
+		{
+			name:   "integers 2",
+			listA:  []int{1, 2, 1, 2, 1},
+			listB:  []int{2, 1, 2, 1, 2},
+			extraA: []interface{}{1},
+			extraB: []interface{}{2},
+		},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			actualExtraA, actualExtraB := diffLists(test.listA, test.listB)
+			Equal(t, test.extraA, actualExtraA, "extra A does not match for listA=%v listB=%v",
+				test.listA, test.listB)
+			Equal(t, test.extraB, actualExtraB, "extra B does not match for listA=%v listB=%v",
+				test.listA, test.listB)
+		})
+	}
+}
+
+func TestCondition(t *testing.T) {
+	mockT := new(testing.T)
+
+	if !Condition(mockT, func() bool { return true }, "Truth") {
+		t.Error("Condition should return true")
+	}
+
+	if Condition(mockT, func() bool { return false }, "Lie") {
+		t.Error("Condition should return false")
+	}
+
+}
+
+func TestDidPanic(t *testing.T) {
+
+	const panicMsg = "Panic!"
+
+	if funcDidPanic, msg, _ := didPanic(func() {
+		panic(panicMsg)
+	}); !funcDidPanic || msg != panicMsg {
+		t.Error("didPanic should return true, panicMsg")
+	}
+
+	if funcDidPanic, msg, _ := didPanic(func() {
+		panic(nil)
+	}); !funcDidPanic || msg != nil {
+		t.Error("didPanic should return true, nil")
+	}
+
+	if funcDidPanic, _, _ := didPanic(func() {
+	}); funcDidPanic {
+		t.Error("didPanic should return false")
+	}
+
+}
+
+func TestPanics(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !Panics(mockT, func() {
+		panic("Panic!")
+	}) {
+		t.Error("Panics should return true")
+	}
+
+	if Panics(mockT, func() {
+	}) {
+		t.Error("Panics should return false")
+	}
+
+}
+
+func TestPanicsWithValue(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !PanicsWithValue(mockT, "Panic!", func() {
+		panic("Panic!")
+	}) {
+		t.Error("PanicsWithValue should return true")
+	}
+
+	if !PanicsWithValue(mockT, nil, func() {
+		panic(nil)
+	}) {
+		t.Error("PanicsWithValue should return true")
+	}
+
+	if PanicsWithValue(mockT, "Panic!", func() {
+	}) {
+		t.Error("PanicsWithValue should return false")
+	}
+
+	if PanicsWithValue(mockT, "at the disco", func() {
+		panic("Panic!")
+	}) {
+		t.Error("PanicsWithValue should return false")
+	}
+}
+
+func TestPanicsWithError(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !PanicsWithError(mockT, "panic", func() {
+		panic(errors.New("panic"))
+	}) {
+		t.Error("PanicsWithError should return true")
+	}
+
+	if PanicsWithError(mockT, "Panic!", func() {
+	}) {
+		t.Error("PanicsWithError should return false")
+	}
+
+	if PanicsWithError(mockT, "at the disco", func() {
+		panic(errors.New("panic"))
+	}) {
+		t.Error("PanicsWithError should return false")
+	}
+
+	if PanicsWithError(mockT, "Panic!", func() {
+		panic("panic")
+	}) {
+		t.Error("PanicsWithError should return false")
+	}
+}
+
+func TestNotPanics(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	if !NotPanics(mockT, func() {
+	}) {
+		t.Error("NotPanics should return true")
+	}
+
+	if NotPanics(mockT, func() {
+		panic("Panic!")
+	}) {
+		t.Error("NotPanics should return false")
+	}
+
+}
+
+func TestNoError(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	// start with a nil error
+	var err error
+
+	True(t, NoError(mockT, err), "NoError should return True for nil arg")
+
+	// now set an error
+	err = errors.New("some error")
+
+	False(t, NoError(mockT, err), "NoError with error should return False")
+
+	// returning an empty error interface
+	err = func() error {
+		var err *customError
+		return err
+	}()
+
+	if err == nil { // err is not nil here!
+		t.Errorf("Error should be nil due to empty interface: %s", err)
+	}
+
+	False(t, NoError(mockT, err), "NoError should fail with empty error interface")
+}
+
+type customError struct{}
+
+func (*customError) Error() string { return "fail" }
+
+func TestError(t *testing.T) {
+
+	mockT := new(testing.T)
+
+	// start with a nil error
+	var err error
+
+	False(t, Error(mockT, err), "Error should return False for nil arg")
+
+	// now set an error
+	err = errors.New("some error")
+
+	True(t, Error(mockT, err), "Error with error should return True")
+
+	// go vet check
+	True(t, Errorf(mockT, err, "example with %s", "formatted message"), "Errorf with error should return True")
+
+	// returning an empty error interface
+	err = func() error {
+		var err *customError
+		return err
+	}()
+
+	if err == nil { // err is not nil here!
+		t.Errorf("Error should be nil due to empty interface: %s", err)
+	}
+
+	True(t, Error(mockT, err), "Error should pass with empty error interface")
+}
+
+func TestEqualError(t *testing.T) {
+	mockT := new(testing.T)
+
+	// start with a nil error
+	var err error
+	False(t, EqualError(mockT, err, ""),
+		"EqualError should return false for nil arg")
+
+	// now set an error
+	err = errors.New("some error")
+	False(t, EqualError(mockT, err, "Not some error"),
+		"EqualError should return false for different error string")
+	True(t, EqualError(mockT, err, "some error"),
+		"EqualError should return true")
+}
+
+func TestErrorContains(t *testing.T) {
+	mockT := new(testing.T)
+
+	// start with a nil error
+	var err error
+	False(t, ErrorContains(mockT, err, ""),
+		"ErrorContains should return false for nil arg")
+
+	// now set an error
+	err = errors.New("some error: another error")
+	False(t, ErrorContains(mockT, err, "bad error"),
+		"ErrorContains should return false for different error string")
+	True(t, ErrorContains(mockT, err, "some error"),
+		"ErrorContains should return true")
+	True(t, ErrorContains(mockT, err, "another error"),
+		"ErrorContains should return true")
+}
+
+func Test_isEmpty(t *testing.T) {
+
+	chWithValue := make(chan struct{}, 1)
+	chWithValue <- struct{}{}
+
+	True(t, isEmpty(""))
+	True(t, isEmpty(nil))
+	True(t, isEmpty([]string{}))
+	True(t, isEmpty(0))
+	True(t, isEmpty(int32(0)))
+	True(t, isEmpty(int64(0)))
+	True(t, isEmpty(false))
+	True(t, isEmpty(map[string]string{}))
+	True(t, isEmpty(new(time.Time)))
+	True(t, isEmpty(time.Time{}))
+	True(t, isEmpty(make(chan struct{})))
+	True(t, isEmpty([1]int{}))
+	False(t, isEmpty("something"))
+	False(t, isEmpty(errors.New("something")))
+	False(t, isEmpty([]string{"something"}))
+	False(t, isEmpty(1))
+	False(t, isEmpty(true))
+	False(t, isEmpty(map[string]string{"Hello": "World"}))
+	False(t, isEmpty(chWithValue))
+	False(t, isEmpty([1]int{42}))
+}
+
+func TestEmpty(t *testing.T) {
+
+	mockT := new(testing.T)
+	chWithValue := make(chan struct{}, 1)
+	chWithValue <- struct{}{}
+	var tiP *time.Time
+	var tiNP time.Time
+	var s *string
+	var f *os.File
+	sP := &s
+	x := 1
+	xP := &x
+
+	type TString string
+	type TStruct struct {
+		x int
+	}
+
+	True(t, Empty(mockT, ""), "Empty string is empty")
+	True(t, Empty(mockT, nil), "Nil is empty")
+	True(t, Empty(mockT, []string{}), "Empty string array is empty")
+	True(t, Empty(mockT, 0), "Zero int value is empty")
+	True(t, Empty(mockT, false), "False value is empty")
+	True(t, Empty(mockT, make(chan struct{})), "Channel without values is empty")
+	True(t, Empty(mockT, s), "Nil string pointer is empty")
+	True(t, Empty(mockT, f), "Nil os.File pointer is empty")
+	True(t, Empty(mockT, tiP), "Nil time.Time pointer is empty")
+	True(t, Empty(mockT, tiNP), "time.Time is empty")
+	True(t, Empty(mockT, TStruct{}), "struct with zero values is empty")
+	True(t, Empty(mockT, TString("")), "empty aliased string is empty")
+	True(t, Empty(mockT, sP), "ptr to nil value is empty")
+	True(t, Empty(mockT, [1]int{}), "array is state")
+
+	False(t, Empty(mockT, "something"), "Non Empty string is not empty")
+	False(t, Empty(mockT, errors.New("something")), "Non nil object is not empty")
+	False(t, Empty(mockT, []string{"something"}), "Non empty string array is not empty")
+	False(t, Empty(mockT, 1), "Non-zero int value is not empty")
+	False(t, Empty(mockT, true), "True value is not empty")
+	False(t, Empty(mockT, chWithValue), "Channel with values is not empty")
+	False(t, Empty(mockT, TStruct{x: 1}), "struct with initialized values is empty")
+	False(t, Empty(mockT, TString("abc")), "non-empty aliased string is empty")
+	False(t, Empty(mockT, xP), "ptr to non-nil value is not empty")
+	False(t, Empty(mockT, [1]int{42}), "array is not state")
+}
+
+func TestNotEmpty(t *testing.T) {
+
+	mockT := new(testing.T)
+	chWithValue := make(chan struct{}, 1)
+	chWithValue <- struct{}{}
+
+	False(t, NotEmpty(mockT, ""), "Empty string is empty")
+	False(t, NotEmpty(mockT, nil), "Nil is empty")
+	False(t, NotEmpty(mockT, []string{}), "Empty string array is empty")
+	False(t, NotEmpty(mockT, 0), "Zero int value is empty")
+	False(t, NotEmpty(mockT, false), "False value is empty")
+	False(t, NotEmpty(mockT, make(chan struct{})), "Channel without values is empty")
+	False(t, NotEmpty(mockT, [1]int{}), "array is state")
+
+	True(t, NotEmpty(mockT, "something"), "Non Empty string is not empty")
+	True(t, NotEmpty(mockT, errors.New("something")), "Non nil object is not empty")
+	True(t, NotEmpty(mockT, []string{"something"}), "Non empty string array is not empty")
+	True(t, NotEmpty(mockT, 1), "Non-zero int value is not empty")
+	True(t, NotEmpty(mockT, true), "True value is not empty")
+	True(t, NotEmpty(mockT, chWithValue), "Channel with values is not empty")
+	True(t, NotEmpty(mockT, [1]int{42}), "array is not state")
+}
+
+func Test_getLen(t *testing.T) {
+	falseCases := []interface{}{
+		nil,
+		0,
+		true,
+		false,
+		'A',
+		struct{}{},
+	}
+	for _, v := range falseCases {
+		l, ok := getLen(v)
+		False(t, ok, "Expected getLen fail to get length of %#v", v)
+		Equal(t, 0, l, "getLen should return 0 for %#v", v)
+	}
+
+	ch := make(chan int, 5)
+	ch <- 1
+	ch <- 2
+	ch <- 3
+	trueCases := []struct {
+		v interface{}
+		l int
+	}{
+		{[]int{1, 2, 3}, 3},
+		{[...]int{1, 2, 3}, 3},
+		{"ABC", 3},
+		{map[int]int{1: 2, 2: 4, 3: 6}, 3},
+		{ch, 3},
+
+		{[]int{}, 0},
+		{map[int]int{}, 0},
+		{make(chan int), 0},
+
+		{[]int(nil), 0},
+		{map[int]int(nil), 0},
+		{(chan int)(nil), 0},
+	}
+
+	for _, c := range trueCases {
+		l, ok := getLen(c.v)
+		True(t, ok, "Expected getLen success to get length of %#v", c.v)
+		Equal(t, c.l, l)
+	}
+}
+
+func TestLen(t *testing.T) {
+	mockT := new(testing.T)
+
+	False(t, Len(mockT, nil, 0), "nil does not have length")
+	False(t, Len(mockT, 0, 0), "int does not have length")
+	False(t, Len(mockT, true, 0), "true does not have length")
+	False(t, Len(mockT, false, 0), "false does not have length")
+	False(t, Len(mockT, 'A', 0), "Rune does not have length")
+	False(t, Len(mockT, struct{}{}, 0), "Struct does not have length")
+
+	ch := make(chan int, 5)
+	ch <- 1
+	ch <- 2
+	ch <- 3
+
+	cases := []struct {
+		v               interface{}
+		l               int
+		expected1234567 string // message when expecting 1234567 items
+	}{
+		{[]int{1, 2, 3}, 3, `"[1 2 3]" should have 1234567 item(s), but has 3`},
+		{[...]int{1, 2, 3}, 3, `"[1 2 3]" should have 1234567 item(s), but has 3`},
+		{"ABC", 3, `"ABC" should have 1234567 item(s), but has 3`},
+		{map[int]int{1: 2, 2: 4, 3: 6}, 3, `"map[1:2 2:4 3:6]" should have 1234567 item(s), but has 3`},
+		{ch, 3, ""},
+
+		{[]int{}, 0, `"[]" should have 1234567 item(s), but has 0`},
+		{map[int]int{}, 0, `"map[]" should have 1234567 item(s), but has 0`},
+		{make(chan int), 0, ""},
+
+		{[]int(nil), 0, `"[]" should have 1234567 item(s), but has 0`},
+		{map[int]int(nil), 0, `"map[]" should have 1234567 item(s), but has 0`},
+		{(chan int)(nil), 0, `"<nil>" should have 1234567 item(s), but has 0`},
+	}
+
+	for _, c := range cases {
+		True(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l)
+		False(t, Len(mockT, c.v, c.l+1), "%#v have %d items", c.v, c.l)
+		if c.expected1234567 != "" {
+			msgMock := new(mockTestingT)
+			Len(msgMock, c.v, 1234567)
+			Contains(t, msgMock.errorString(), c.expected1234567)
+		}
+	}
+}
+
+func TestWithinDuration(t *testing.T) {
+
+	mockT := new(testing.T)
+	a := time.Now()
+	b := a.Add(10 * time.Second)
+
+	True(t, WithinDuration(mockT, a, b, 10*time.Second), "A 10s difference is within a 10s time difference")
+	True(t, WithinDuration(mockT, b, a, 10*time.Second), "A 10s difference is within a 10s time difference")
+
+	False(t, WithinDuration(mockT, a, b, 9*time.Second), "A 10s difference is not within a 9s time difference")
+	False(t, WithinDuration(mockT, b, a, 9*time.Second), "A 10s difference is not within a 9s time difference")
+
+	False(t, WithinDuration(mockT, a, b, -9*time.Second), "A 10s difference is not within a 9s time difference")
+	False(t, WithinDuration(mockT, b, a, -9*time.Second), "A 10s difference is not within a 9s time difference")
+
+	False(t, WithinDuration(mockT, a, b, -11*time.Second), "A 10s difference is not within a 9s time difference")
+	False(t, WithinDuration(mockT, b, a, -11*time.Second), "A 10s difference is not within a 9s time difference")
+}
+
+func TestWithinRange(t *testing.T) {
+
+	mockT := new(testing.T)
+	n := time.Now()
+	s := n.Add(-time.Second)
+	e := n.Add(time.Second)
+
+	True(t, WithinRange(mockT, n, n, n), "Exact same actual, start, and end values return true")
+
+	True(t, WithinRange(mockT, n, s, e), "Time in range is within the time range")
+	True(t, WithinRange(mockT, s, s, e), "The start time is within the time range")
+	True(t, WithinRange(mockT, e, s, e), "The end time is within the time range")
+
+	False(t, WithinRange(mockT, s.Add(-time.Nanosecond), s, e, "Just before the start time is not within the time range"))
+	False(t, WithinRange(mockT, e.Add(time.Nanosecond), s, e, "Just after the end time is not within the time range"))
+
+	False(t, WithinRange(mockT, n, e, s, "Just after the end time is not within the time range"))
+}
+
+func TestInDelta(t *testing.T) {
+	mockT := new(testing.T)
+
+	True(t, InDelta(mockT, 1.001, 1, 0.01), "|1.001 - 1| <= 0.01")
+	True(t, InDelta(mockT, 1, 1.001, 0.01), "|1 - 1.001| <= 0.01")
+	True(t, InDelta(mockT, 1, 2, 1), "|1 - 2| <= 1")
+	False(t, InDelta(mockT, 1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail")
+	False(t, InDelta(mockT, 2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail")
+	False(t, InDelta(mockT, "", nil, 1), "Expected non numerals to fail")
+	False(t, InDelta(mockT, 42, math.NaN(), 0.01), "Expected NaN for actual to fail")
+	False(t, InDelta(mockT, math.NaN(), 42, 0.01), "Expected NaN for expected to fail")
+	True(t, InDelta(mockT, math.NaN(), math.NaN(), 0.01), "Expected NaN for both to pass")
+
+	cases := []struct {
+		a, b  interface{}
+		delta float64
+	}{
+		{uint(2), uint(1), 1},
+		{uint8(2), uint8(1), 1},
+		{uint16(2), uint16(1), 1},
+		{uint32(2), uint32(1), 1},
+		{uint64(2), uint64(1), 1},
+
+		{int(2), int(1), 1},
+		{int8(2), int8(1), 1},
+		{int16(2), int16(1), 1},
+		{int32(2), int32(1), 1},
+		{int64(2), int64(1), 1},
+
+		{float32(2), float32(1), 1},
+		{float64(2), float64(1), 1},
+	}
+
+	for _, tc := range cases {
+		True(t, InDelta(mockT, tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta)
+	}
+}
+
+func TestInDeltaSlice(t *testing.T) {
+	mockT := new(testing.T)
+
+	True(t, InDeltaSlice(mockT,
+		[]float64{1.001, math.NaN(), 0.999},
+		[]float64{1, math.NaN(), 1},
+		0.1), "{1.001, NaN, 0.009} is element-wise close to {1, NaN, 1} in delta=0.1")
+
+	True(t, InDeltaSlice(mockT,
+		[]float64{1, math.NaN(), 2},
+		[]float64{0, math.NaN(), 3},
+		1), "{1, NaN, 2} is element-wise close to {0, NaN, 3} in delta=1")
+
+	False(t, InDeltaSlice(mockT,
+		[]float64{1, math.NaN(), 2},
+		[]float64{0, math.NaN(), 3},
+		0.1), "{1, NaN, 2} is not element-wise close to {0, NaN, 3} in delta=0.1")
+
+	False(t, InDeltaSlice(mockT, "", nil, 1), "Expected non numeral slices to fail")
+}
+
+func TestInDeltaMapValues(t *testing.T) {
+	mockT := new(testing.T)
+
+	for _, tc := range []struct {
+		title  string
+		expect interface{}
+		actual interface{}
+		f      func(TestingT, bool, ...interface{}) bool
+		delta  float64
+	}{
+		{
+			title: "Within delta",
+			expect: map[string]float64{
+				"foo": 1.0,
+				"bar": 2.0,
+				"baz": math.NaN(),
+			},
+			actual: map[string]float64{
+				"foo": 1.01,
+				"bar": 1.99,
+				"baz": math.NaN(),
+			},
+			delta: 0.1,
+			f:     True,
+		},
+		{
+			title: "Within delta",
+			expect: map[int]float64{
+				1: 1.0,
+				2: 2.0,
+			},
+			actual: map[int]float64{
+				1: 1.0,
+				2: 1.99,
+			},
+			delta: 0.1,
+			f:     True,
+		},
+		{
+			title: "Different number of keys",
+			expect: map[int]float64{
+				1: 1.0,
+				2: 2.0,
+			},
+			actual: map[int]float64{
+				1: 1.0,
+			},
+			delta: 0.1,
+			f:     False,
+		},
+		{
+			title: "Within delta with zero value",
+			expect: map[string]float64{
+				"zero": 0,
+			},
+			actual: map[string]float64{
+				"zero": 0,
+			},
+			delta: 0.1,
+			f:     True,
+		},
+		{
+			title: "With missing key with zero value",
+			expect: map[string]float64{
+				"zero": 0,
+				"foo":  0,
+			},
+			actual: map[string]float64{
+				"zero": 0,
+				"bar":  0,
+			},
+			f: False,
+		},
+	} {
+		tc.f(t, InDeltaMapValues(mockT, tc.expect, tc.actual, tc.delta), tc.title+"\n"+diff(tc.expect, tc.actual))
+	}
+}
+
+func TestInEpsilon(t *testing.T) {
+	mockT := new(testing.T)
+
+	cases := []struct {
+		a, b    interface{}
+		epsilon float64
+	}{
+		{uint8(2), uint16(2), .001},
+		{2.1, 2.2, 0.1},
+		{2.2, 2.1, 0.1},
+		{-2.1, -2.2, 0.1},
+		{-2.2, -2.1, 0.1},
+		{uint64(100), uint8(101), 0.01},
+		{0.1, -0.1, 2},
+		{0.1, 0, 2},
+		{math.NaN(), math.NaN(), 1},
+		{time.Second, time.Second + time.Millisecond, 0.002},
+	}
+
+	for _, tc := range cases {
+		True(t, InEpsilon(t, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon), "test: %q", tc)
+	}
+
+	cases = []struct {
+		a, b    interface{}
+		epsilon float64
+	}{
+		{uint8(2), int16(-2), .001},
+		{uint64(100), uint8(102), 0.01},
+		{2.1, 2.2, 0.001},
+		{2.2, 2.1, 0.001},
+		{2.1, -2.2, 1},
+		{2.1, "bla-bla", 0},
+		{0.1, -0.1, 1.99},
+		{0, 0.1, 2}, // expected must be different to zero
+		{time.Second, time.Second + 10*time.Millisecond, 0.002},
+		{math.NaN(), 0, 1},
+		{0, math.NaN(), 1},
+		{0, 0, math.NaN()},
+	}
+
+	for _, tc := range cases {
+		False(t, InEpsilon(mockT, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
+	}
+
+}
+
+func TestInEpsilonSlice(t *testing.T) {
+	mockT := new(testing.T)
+
+	True(t, InEpsilonSlice(mockT,
+		[]float64{2.2, math.NaN(), 2.0},
+		[]float64{2.1, math.NaN(), 2.1},
+		0.06), "{2.2, NaN, 2.0} is element-wise close to {2.1, NaN, 2.1} in epsilon=0.06")
+
+	False(t, InEpsilonSlice(mockT,
+		[]float64{2.2, 2.0},
+		[]float64{2.1, 2.1},
+		0.04), "{2.2, 2.0} is not element-wise close to {2.1, 2.1} in epsilon=0.04")
+
+	False(t, InEpsilonSlice(mockT, "", nil, 1), "Expected non numeral slices to fail")
+}
+
+func TestRegexp(t *testing.T) {
+	mockT := new(testing.T)
+
+	cases := []struct {
+		rx, str string
+	}{
+		{"^start", "start of the line"},
+		{"end$", "in the end"},
+		{"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
+	}
+
+	for _, tc := range cases {
+		True(t, Regexp(mockT, tc.rx, tc.str))
+		True(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
+		False(t, NotRegexp(mockT, tc.rx, tc.str))
+		False(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
+	}
+
+	cases = []struct {
+		rx, str string
+	}{
+		{"^asdfastart", "Not the start of the line"},
+		{"end$", "in the end."},
+		{"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"},
+	}
+
+	for _, tc := range cases {
+		False(t, Regexp(mockT, tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
+		False(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
+		True(t, NotRegexp(mockT, tc.rx, tc.str))
+		True(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
+	}
+}
+
+func testAutogeneratedFunction() {
+	defer func() {
+		if err := recover(); err == nil {
+			panic("did not panic")
+		}
+		CallerInfo()
+	}()
+	t := struct {
+		io.Closer
+	}{}
+	c := t
+	c.Close()
+}
+
+func TestCallerInfoWithAutogeneratedFunctions(t *testing.T) {
+	NotPanics(t, func() {
+		testAutogeneratedFunction()
+	})
+}
+
+func TestZero(t *testing.T) {
+	mockT := new(testing.T)
+
+	for _, test := range zeros {
+		True(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
+	}
+
+	for _, test := range nonZeros {
+		False(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
+	}
+}
+
+func TestNotZero(t *testing.T) {
+	mockT := new(testing.T)
+
+	for _, test := range zeros {
+		False(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
+	}
+
+	for _, test := range nonZeros {
+		True(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
+	}
+}
+
+func TestFileExists(t *testing.T) {
+	mockT := new(testing.T)
+	True(t, FileExists(mockT, "assertions.go"))
+
+	mockT = new(testing.T)
+	False(t, FileExists(mockT, "random_file"))
+
+	mockT = new(testing.T)
+	False(t, FileExists(mockT, "../_codegen"))
+
+	var tempFiles []string
+
+	link, err := getTempSymlinkPath("assertions.go")
+	if err != nil {
+		t.Fatal("could not create temp symlink, err:", err)
+	}
+	tempFiles = append(tempFiles, link)
+	mockT = new(testing.T)
+	True(t, FileExists(mockT, link))
+
+	link, err = getTempSymlinkPath("non_existent_file")
+	if err != nil {
+		t.Fatal("could not create temp symlink, err:", err)
+	}
+	tempFiles = append(tempFiles, link)
+	mockT = new(testing.T)
+	True(t, FileExists(mockT, link))
+
+	errs := cleanUpTempFiles(tempFiles)
+	if len(errs) > 0 {
+		t.Fatal("could not clean up temporary files")
+	}
+}
+
+func TestNoFileExists(t *testing.T) {
+	mockT := new(testing.T)
+	False(t, NoFileExists(mockT, "assertions.go"))
+
+	mockT = new(testing.T)
+	True(t, NoFileExists(mockT, "non_existent_file"))
+
+	mockT = new(testing.T)
+	True(t, NoFileExists(mockT, "../_codegen"))
+
+	var tempFiles []string
+
+	link, err := getTempSymlinkPath("assertions.go")
+	if err != nil {
+		t.Fatal("could not create temp symlink, err:", err)
+	}
+	tempFiles = append(tempFiles, link)
+	mockT = new(testing.T)
+	False(t, NoFileExists(mockT, link))
+
+	link, err = getTempSymlinkPath("non_existent_file")
+	if err != nil {
+		t.Fatal("could not create temp symlink, err:", err)
+	}
+	tempFiles = append(tempFiles, link)
+	mockT = new(testing.T)
+	False(t, NoFileExists(mockT, link))
+
+	errs := cleanUpTempFiles(tempFiles)
+	if len(errs) > 0 {
+		t.Fatal("could not clean up temporary files")
+	}
+}
+
+func getTempSymlinkPath(file string) (string, error) {
+	link := file + "_symlink"
+	err := os.Symlink(file, link)
+	return link, err
+}
+
+func cleanUpTempFiles(paths []string) []error {
+	var res []error
+	for _, path := range paths {
+		err := os.Remove(path)
+		if err != nil {
+			res = append(res, err)
+		}
+	}
+	return res
+}
+
+func TestDirExists(t *testing.T) {
+	mockT := new(testing.T)
+	False(t, DirExists(mockT, "assertions.go"))
+
+	mockT = new(testing.T)
+	False(t, DirExists(mockT, "non_existent_dir"))
+
+	mockT = new(testing.T)
+	True(t, DirExists(mockT, "../assert"))
+
+	var tempFiles []string
+
+	link, err := getTempSymlinkPath("assertions.go")
+	if err != nil {
+		t.Fatal("could not create temp symlink, err:", err)
+	}
+	tempFiles = append(tempFiles, link)
+	mockT = new(testing.T)
+	False(t, DirExists(mockT, link))
+
+	link, err = getTempSymlinkPath("non_existent_dir")
+	if err != nil {
+		t.Fatal("could not create temp symlink, err:", err)
+	}
+	tempFiles = append(tempFiles, link)
+	mockT = new(testing.T)
+	False(t, DirExists(mockT, link))
+
+	errs := cleanUpTempFiles(tempFiles)
+	if len(errs) > 0 {
+		t.Fatal("could not clean up temporary files")
+	}
+}
+
+func TestNoDirExists(t *testing.T) {
+	mockT := new(testing.T)
+	True(t, NoDirExists(mockT, "assertions.go"))
+
+	mockT = new(testing.T)
+	True(t, NoDirExists(mockT, "non_existent_dir"))
+
+	mockT = new(testing.T)
+	False(t, NoDirExists(mockT, "../assert"))
+
+	var tempFiles []string
+
+	link, err := getTempSymlinkPath("assertions.go")
+	if err != nil {
+		t.Fatal("could not create temp symlink, err:", err)
+	}
+	tempFiles = append(tempFiles, link)
+	mockT = new(testing.T)
+	True(t, NoDirExists(mockT, link))
+
+	link, err = getTempSymlinkPath("non_existent_dir")
+	if err != nil {
+		t.Fatal("could not create temp symlink, err:", err)
+	}
+	tempFiles = append(tempFiles, link)
+	mockT = new(testing.T)
+	True(t, NoDirExists(mockT, link))
+
+	errs := cleanUpTempFiles(tempFiles)
+	if len(errs) > 0 {
+		t.Fatal("could not clean up temporary files")
+	}
+}
+
+func TestJSONEq_EqualSONString(t *testing.T) {
+	mockT := new(testing.T)
+	True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`))
+}
+
+func TestJSONEq_EquivalentButNotEqual(t *testing.T) {
+	mockT := new(testing.T)
+	True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
+}
+
+func TestJSONEq_HashOfArraysAndHashes(t *testing.T) {
+	mockT := new(testing.T)
+	True(t, JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
+		"{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}"))
+}
+
+func TestJSONEq_Array(t *testing.T) {
+	mockT := new(testing.T)
+	True(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`))
+}
+
+func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) {
+	mockT := new(testing.T)
+	False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`))
+}
+
+func TestJSONEq_HashesNotEquivalent(t *testing.T) {
+	mockT := new(testing.T)
+	False(t, JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
+}
+
+func TestJSONEq_ActualIsNotJSON(t *testing.T) {
+	mockT := new(testing.T)
+	False(t, JSONEq(mockT, `{"foo": "bar"}`, "Not JSON"))
+}
+
+func TestJSONEq_ExpectedIsNotJSON(t *testing.T) {
+	mockT := new(testing.T)
+	False(t, JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`))
+}
+
+func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) {
+	mockT := new(testing.T)
+	False(t, JSONEq(mockT, "Not JSON", "Not JSON"))
+}
+
+func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) {
+	mockT := new(testing.T)
+	False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`))
+}
+
+type diffTestingStruct struct {
+	A string
+	B int
+}
+
+func (d *diffTestingStruct) String() string {
+	return d.A
+}
+
+func TestDiff(t *testing.T) {
+	expected := `
+
+Diff:
+--- Expected
++++ Actual
+@@ -1,3 +1,3 @@
+ (struct { foo string }) {
+- foo: (string) (len=5) "hello"
++ foo: (string) (len=3) "bar"
+ }
+`
+	actual := diff(
+		struct{ foo string }{"hello"},
+		struct{ foo string }{"bar"},
+	)
+	Equal(t, expected, actual)
+
+	expected = `
+
+Diff:
+--- Expected
++++ Actual
+@@ -2,5 +2,5 @@
+  (int) 1,
+- (int) 2,
+  (int) 3,
+- (int) 4
++ (int) 5,
++ (int) 7
+ }
+`
+	actual = diff(
+		[]int{1, 2, 3, 4},
+		[]int{1, 3, 5, 7},
+	)
+	Equal(t, expected, actual)
+
+	expected = `
+
+Diff:
+--- Expected
++++ Actual
+@@ -2,4 +2,4 @@
+  (int) 1,
+- (int) 2,
+- (int) 3
++ (int) 3,
++ (int) 5
+ }
+`
+	actual = diff(
+		[]int{1, 2, 3, 4}[0:3],
+		[]int{1, 3, 5, 7}[0:3],
+	)
+	Equal(t, expected, actual)
+
+	expected = `
+
+Diff:
+--- Expected
++++ Actual
+@@ -1,6 +1,6 @@
+ (map[string]int) (len=4) {
+- (string) (len=4) "four": (int) 4,
++ (string) (len=4) "five": (int) 5,
+  (string) (len=3) "one": (int) 1,
+- (string) (len=5) "three": (int) 3,
+- (string) (len=3) "two": (int) 2
++ (string) (len=5) "seven": (int) 7,
++ (string) (len=5) "three": (int) 3
+ }
+`
+
+	actual = diff(
+		map[string]int{"one": 1, "two": 2, "three": 3, "four": 4},
+		map[string]int{"one": 1, "three": 3, "five": 5, "seven": 7},
+	)
+	Equal(t, expected, actual)
+
+	expected = `
+
+Diff:
+--- Expected
++++ Actual
+@@ -1,3 +1,3 @@
+ (*errors.errorString)({
+- s: (string) (len=19) "some expected error"
++ s: (string) (len=12) "actual error"
+ })
+`
+
+	actual = diff(
+		errors.New("some expected error"),
+		errors.New("actual error"),
+	)
+	Equal(t, expected, actual)
+
+	expected = `
+
+Diff:
+--- Expected
++++ Actual
+@@ -2,3 +2,3 @@
+  A: (string) (len=11) "some string",
+- B: (int) 10
++ B: (int) 15
+ }
+`
+
+	actual = diff(
+		diffTestingStruct{A: "some string", B: 10},
+		diffTestingStruct{A: "some string", B: 15},
+	)
+	Equal(t, expected, actual)
+
+	expected = `
+
+Diff:
+--- Expected
++++ Actual
+@@ -1,2 +1,2 @@
+-(time.Time) 2020-09-24 00:00:00 +0000 UTC
++(time.Time) 2020-09-25 00:00:00 +0000 UTC
+ 
+`
+
+	actual = diff(
+		time.Date(2020, 9, 24, 0, 0, 0, 0, time.UTC),
+		time.Date(2020, 9, 25, 0, 0, 0, 0, time.UTC),
+	)
+	Equal(t, expected, actual)
+}
+
+func TestTimeEqualityErrorFormatting(t *testing.T) {
+	mockT := new(mockTestingT)
+
+	Equal(mockT, time.Second*2, time.Millisecond)
+
+	expectedErr := "\\s+Error Trace:\\s+Error:\\s+Not equal:\\s+\n\\s+expected: 2s\n\\s+actual\\s+: 1ms\n"
+	Regexp(t, regexp.MustCompile(expectedErr), mockT.errorString())
+}
+
+func TestDiffEmptyCases(t *testing.T) {
+	Equal(t, "", diff(nil, nil))
+	Equal(t, "", diff(struct{ foo string }{}, nil))
+	Equal(t, "", diff(nil, struct{ foo string }{}))
+	Equal(t, "", diff(1, 2))
+	Equal(t, "", diff(1, 2))
+	Equal(t, "", diff([]int{1}, []bool{true}))
+}
+
+// Ensure there are no data races
+func TestDiffRace(t *testing.T) {
+	t.Parallel()
+
+	expected := map[string]string{
+		"a": "A",
+		"b": "B",
+		"c": "C",
+	}
+
+	actual := map[string]string{
+		"d": "D",
+		"e": "E",
+		"f": "F",
+	}
+
+	// run diffs in parallel simulating tests with t.Parallel()
+	numRoutines := 10
+	rChans := make([]chan string, numRoutines)
+	for idx := range rChans {
+		rChans[idx] = make(chan string)
+		go func(ch chan string) {
+			defer close(ch)
+			ch <- diff(expected, actual)
+		}(rChans[idx])
+	}
+
+	for _, ch := range rChans {
+		for msg := range ch {
+			NotZero(t, msg) // dummy assert
+		}
+	}
+}
+
+type mockTestingT struct {
+	errorFmt string
+	args     []interface{}
+}
+
+func (m *mockTestingT) errorString() string {
+	return fmt.Sprintf(m.errorFmt, m.args...)
+}
+
+func (m *mockTestingT) Errorf(format string, args ...interface{}) {
+	m.errorFmt = format
+	m.args = args
+}
+
+func (m *mockTestingT) Failed() bool {
+	return m.errorFmt != ""
+}
+
+func TestFailNowWithPlainTestingT(t *testing.T) {
+	mockT := &mockTestingT{}
+
+	Panics(t, func() {
+		FailNow(mockT, "failed")
+	}, "should panic since mockT is missing FailNow()")
+}
+
+type mockFailNowTestingT struct {
+}
+
+func (m *mockFailNowTestingT) Errorf(format string, args ...interface{}) {}
+
+func (m *mockFailNowTestingT) FailNow() {}
+
+func TestFailNowWithFullTestingT(t *testing.T) {
+	mockT := &mockFailNowTestingT{}
+
+	NotPanics(t, func() {
+		FailNow(mockT, "failed")
+	}, "should call mockT.FailNow() rather than panicking")
+}
+
+func TestBytesEqual(t *testing.T) {
+	var cases = []struct {
+		a, b []byte
+	}{
+		{make([]byte, 2), make([]byte, 2)},
+		{make([]byte, 2), make([]byte, 2, 3)},
+		{nil, make([]byte, 0)},
+	}
+	for i, c := range cases {
+		Equal(t, reflect.DeepEqual(c.a, c.b), ObjectsAreEqual(c.a, c.b), "case %d failed", i+1)
+	}
+}
+
+func BenchmarkBytesEqual(b *testing.B) {
+	const size = 1024 * 8
+	s := make([]byte, size)
+	for i := range s {
+		s[i] = byte(i % 255)
+	}
+	s2 := make([]byte, size)
+	copy(s2, s)
+
+	mockT := &mockFailNowTestingT{}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		Equal(mockT, s, s2)
+	}
+}
+
+func BenchmarkNotNil(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NotNil(b, b)
+	}
+}
+
+func ExampleComparisonAssertionFunc() {
+	t := &testing.T{} // provided by test
+
+	adder := func(x, y int) int {
+		return x + y
+	}
+
+	type args struct {
+		x int
+		y int
+	}
+
+	tests := []struct {
+		name      string
+		args      args
+		expect    int
+		assertion ComparisonAssertionFunc
+	}{
+		{"2+2=4", args{2, 2}, 4, Equal},
+		{"2+2!=5", args{2, 2}, 5, NotEqual},
+		{"2+3==5", args{2, 3}, 5, Exactly},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y))
+		})
+	}
+}
+
+func TestComparisonAssertionFunc(t *testing.T) {
+	type iface interface {
+		Name() string
+	}
+
+	tests := []struct {
+		name      string
+		expect    interface{}
+		got       interface{}
+		assertion ComparisonAssertionFunc
+	}{
+		{"implements", (*iface)(nil), t, Implements},
+		{"isType", (*testing.T)(nil), t, IsType},
+		{"equal", t, t, Equal},
+		{"equalValues", t, t, EqualValues},
+		{"notEqualValues", t, nil, NotEqualValues},
+		{"exactly", t, t, Exactly},
+		{"notEqual", t, nil, NotEqual},
+		{"notContains", []int{1, 2, 3}, 4, NotContains},
+		{"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset},
+		{"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset},
+		{"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch},
+		{"regexp", "^t.*y$", "testify", Regexp},
+		{"notRegexp", "^t.*y$", "Testify", NotRegexp},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.expect, tt.got)
+		})
+	}
+}
+
+func ExampleValueAssertionFunc() {
+	t := &testing.T{} // provided by test
+
+	dumbParse := func(input string) interface{} {
+		var x interface{}
+		_ = json.Unmarshal([]byte(input), &x)
+		return x
+	}
+
+	tests := []struct {
+		name      string
+		arg       string
+		assertion ValueAssertionFunc
+	}{
+		{"true is not nil", "true", NotNil},
+		{"empty string is nil", "", Nil},
+		{"zero is not nil", "0", NotNil},
+		{"zero is zero", "0", Zero},
+		{"false is zero", "false", Zero},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, dumbParse(tt.arg))
+		})
+	}
+}
+
+func TestValueAssertionFunc(t *testing.T) {
+	tests := []struct {
+		name      string
+		value     interface{}
+		assertion ValueAssertionFunc
+	}{
+		{"notNil", true, NotNil},
+		{"nil", nil, Nil},
+		{"empty", []int{}, Empty},
+		{"notEmpty", []int{1}, NotEmpty},
+		{"zero", false, Zero},
+		{"notZero", 42, NotZero},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.value)
+		})
+	}
+}
+
+func ExampleBoolAssertionFunc() {
+	t := &testing.T{} // provided by test
+
+	isOkay := func(x int) bool {
+		return x >= 42
+	}
+
+	tests := []struct {
+		name      string
+		arg       int
+		assertion BoolAssertionFunc
+	}{
+		{"-1 is bad", -1, False},
+		{"42 is good", 42, True},
+		{"41 is bad", 41, False},
+		{"45 is cool", 45, True},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, isOkay(tt.arg))
+		})
+	}
+}
+
+func TestBoolAssertionFunc(t *testing.T) {
+	tests := []struct {
+		name      string
+		value     bool
+		assertion BoolAssertionFunc
+	}{
+		{"true", true, True},
+		{"false", false, False},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.value)
+		})
+	}
+}
+
+func ExampleErrorAssertionFunc() {
+	t := &testing.T{} // provided by test
+
+	dumbParseNum := func(input string, v interface{}) error {
+		return json.Unmarshal([]byte(input), v)
+	}
+
+	tests := []struct {
+		name      string
+		arg       string
+		assertion ErrorAssertionFunc
+	}{
+		{"1.2 is number", "1.2", NoError},
+		{"1.2.3 not number", "1.2.3", Error},
+		{"true is not number", "true", Error},
+		{"3 is number", "3", NoError},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var x float64
+			tt.assertion(t, dumbParseNum(tt.arg, &x))
+		})
+	}
+}
+
+func TestErrorAssertionFunc(t *testing.T) {
+	tests := []struct {
+		name      string
+		err       error
+		assertion ErrorAssertionFunc
+	}{
+		{"noError", nil, NoError},
+		{"error", errors.New("whoops"), Error},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.err)
+		})
+	}
+}
+
+func ExamplePanicAssertionFunc() {
+	t := &testing.T{} // provided by test
+
+	tests := []struct {
+		name      string
+		panicFn   PanicTestFunc
+		assertion PanicAssertionFunc
+	}{
+		{"with panic", func() { panic(nil) }, Panics},
+		{"without panic", func() {}, NotPanics},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.panicFn)
+		})
+	}
+}
+
+func TestPanicAssertionFunc(t *testing.T) {
+	tests := []struct {
+		name      string
+		panicFn   PanicTestFunc
+		assertion PanicAssertionFunc
+	}{
+		{"not panic", func() {}, NotPanics},
+		{"panic", func() { panic(nil) }, Panics},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.panicFn)
+		})
+	}
+}
+
+func TestEventuallyFalse(t *testing.T) {
+	mockT := new(testing.T)
+
+	condition := func() bool {
+		return false
+	}
+
+	False(t, Eventually(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
+}
+
+func TestEventuallyTrue(t *testing.T) {
+	state := 0
+	condition := func() bool {
+		defer func() {
+			state += 1
+		}()
+		return state == 2
+	}
+
+	True(t, Eventually(t, condition, 100*time.Millisecond, 20*time.Millisecond))
+}
+
+// errorsCapturingT is a mock implementation of TestingT that captures errors reported with Errorf.
+type errorsCapturingT struct {
+	errors []error
+}
+
+func (t *errorsCapturingT) Errorf(format string, args ...interface{}) {
+	t.errors = append(t.errors, fmt.Errorf(format, args...))
+}
+
+func (t *errorsCapturingT) Helper() {}
+
+func TestEventuallyWithTFalse(t *testing.T) {
+	mockT := new(errorsCapturingT)
+
+	condition := func(collect *CollectT) {
+		Fail(collect, "condition fixed failure")
+	}
+
+	False(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
+	Len(t, mockT.errors, 2)
+}
+
+func TestEventuallyWithTTrue(t *testing.T) {
+	mockT := new(errorsCapturingT)
+
+	state := 0
+	condition := func(collect *CollectT) {
+		defer func() {
+			state += 1
+		}()
+		True(collect, state == 2)
+	}
+
+	True(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
+	Len(t, mockT.errors, 0)
+}
+
+func TestEventuallyWithT_ConcurrencySafe(t *testing.T) {
+	mockT := new(errorsCapturingT)
+
+	condition := func(collect *CollectT) {
+		Fail(collect, "condition fixed failure")
+	}
+
+	// To trigger race conditions, we run EventuallyWithT with a nanosecond tick.
+	False(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, time.Nanosecond))
+	Len(t, mockT.errors, 2)
+}
+
+func TestEventuallyWithT_ReturnsTheLatestFinishedConditionErrors(t *testing.T) {
+	// We'll use a channel to control whether a condition should sleep or not.
+	mustSleep := make(chan bool, 2)
+	mustSleep <- false
+	mustSleep <- true
+	close(mustSleep)
+
+	condition := func(collect *CollectT) {
+		if <-mustSleep {
+			// Sleep to ensure that the second condition runs longer than timeout.
+			time.Sleep(time.Second)
+			return
+		}
+
+		// The first condition will fail. We expect to get this error as a result.
+		Fail(collect, "condition fixed failure")
+	}
+
+	mockT := new(errorsCapturingT)
+	False(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
+	Len(t, mockT.errors, 2)
+}
+
+func TestNeverFalse(t *testing.T) {
+	condition := func() bool {
+		return false
+	}
+
+	True(t, Never(t, condition, 100*time.Millisecond, 20*time.Millisecond))
+}
+
+// TestNeverTrue checks Never with a condition that returns true on second call.
+func TestNeverTrue(t *testing.T) {
+	mockT := new(testing.T)
+
+	// A list of values returned by condition.
+	// Channel protects against concurrent access.
+	returns := make(chan bool, 2)
+	returns <- false
+	returns <- true
+	defer close(returns)
+
+	// Will return true on second call.
+	condition := func() bool {
+		return <-returns
+	}
+
+	False(t, Never(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
+}
+
+// Check that a long running condition doesn't block Eventually.
+// See issue 805 (and its long tail of following issues)
+func TestEventuallyTimeout(t *testing.T) {
+	mockT := new(testing.T)
+
+	NotPanics(t, func() {
+		done, done2 := make(chan struct{}), make(chan struct{})
+
+		// A condition function that returns after the Eventually timeout
+		condition := func() bool {
+			// Wait until Eventually times out and terminates
+			<-done
+			close(done2)
+			return true
+		}
+
+		False(t, Eventually(mockT, condition, time.Millisecond, time.Microsecond))
+
+		close(done)
+		<-done2
+	})
+}
+
+func Test_validateEqualArgs(t *testing.T) {
+	if validateEqualArgs(func() {}, func() {}) == nil {
+		t.Error("non-nil functions should error")
+	}
+
+	if validateEqualArgs(func() {}, func() {}) == nil {
+		t.Error("non-nil functions should error")
+	}
+
+	if validateEqualArgs(nil, nil) != nil {
+		t.Error("nil functions are equal")
+	}
+}
+
+func Test_truncatingFormat(t *testing.T) {
+
+	original := strings.Repeat("a", bufio.MaxScanTokenSize-102)
+	result := truncatingFormat(original)
+	Equal(t, fmt.Sprintf("%#v", original), result, "string should not be truncated")
+
+	original = original + "x"
+	result = truncatingFormat(original)
+	NotEqual(t, fmt.Sprintf("%#v", original), result, "string should have been truncated.")
+
+	if !strings.HasSuffix(result, "<... truncated>") {
+		t.Error("truncated string should have <... truncated> suffix")
+	}
+}
+
+// parseLabeledOutput does the inverse of labeledOutput - it takes a formatted
+// output string and turns it back into a slice of labeledContent.
+func parseLabeledOutput(output string) []labeledContent {
+	labelPattern := regexp.MustCompile(`^\t([^\t]*): *\t(.*)$`)
+	contentPattern := regexp.MustCompile(`^\t *\t(.*)$`)
+	var contents []labeledContent
+	lines := strings.Split(output, "\n")
+	i := -1
+	for _, line := range lines {
+		if line == "" {
+			// skip blank lines
+			continue
+		}
+		matches := labelPattern.FindStringSubmatch(line)
+		if len(matches) == 3 {
+			// a label
+			contents = append(contents, labeledContent{
+				label:   matches[1],
+				content: matches[2] + "\n",
+			})
+			i++
+			continue
+		}
+		matches = contentPattern.FindStringSubmatch(line)
+		if len(matches) == 2 {
+			// just content
+			if i >= 0 {
+				contents[i].content += matches[1] + "\n"
+				continue
+			}
+		}
+		// Couldn't parse output
+		return nil
+	}
+	return contents
+}
+
+type captureTestingT struct {
+	msg string
+}
+
+func (ctt *captureTestingT) Errorf(format string, args ...interface{}) {
+	ctt.msg = fmt.Sprintf(format, args...)
+}
+
+func (ctt *captureTestingT) checkResultAndErrMsg(t *testing.T, expectedRes, res bool, expectedErrMsg string) {
+	t.Helper()
+	if res != expectedRes {
+		t.Errorf("Should return %t", expectedRes)
+		return
+	}
+	contents := parseLabeledOutput(ctt.msg)
+	if res == true {
+		if contents != nil {
+			t.Errorf("Should not log an error")
+		}
+		return
+	}
+	if contents == nil {
+		t.Errorf("Should log an error. Log output: %v", ctt.msg)
+		return
+	}
+	for _, content := range contents {
+		if content.label == "Error" {
+			if expectedErrMsg == content.content {
+				return
+			}
+			t.Errorf("Logged Error: %v", content.content)
+		}
+	}
+	t.Errorf("Should log Error: %v", expectedErrMsg)
+}
+
+func TestErrorIs(t *testing.T) {
+	tests := []struct {
+		err          error
+		target       error
+		result       bool
+		resultErrMsg string
+	}{
+		{
+			err:    io.EOF,
+			target: io.EOF,
+			result: true,
+		},
+		{
+			err:    fmt.Errorf("wrap: %w", io.EOF),
+			target: io.EOF,
+			result: true,
+		},
+		{
+			err:    io.EOF,
+			target: io.ErrClosedPipe,
+			result: false,
+			resultErrMsg: "" +
+				"Target error should be in err chain:\n" +
+				"expected: \"io: read/write on closed pipe\"\n" +
+				"in chain: \"EOF\"\n",
+		},
+		{
+			err:    nil,
+			target: io.EOF,
+			result: false,
+			resultErrMsg: "" +
+				"Target error should be in err chain:\n" +
+				"expected: \"EOF\"\n" +
+				"in chain: \n",
+		},
+		{
+			err:    io.EOF,
+			target: nil,
+			result: false,
+			resultErrMsg: "" +
+				"Target error should be in err chain:\n" +
+				"expected: \"\"\n" +
+				"in chain: \"EOF\"\n",
+		},
+		{
+			err:    nil,
+			target: nil,
+			result: true,
+		},
+		{
+			err:    fmt.Errorf("abc: %w", errors.New("def")),
+			target: io.EOF,
+			result: false,
+			resultErrMsg: "" +
+				"Target error should be in err chain:\n" +
+				"expected: \"EOF\"\n" +
+				"in chain: \"abc: def\"\n" +
+				"\t\"def\"\n",
+		},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(fmt.Sprintf("ErrorIs(%#v,%#v)", tt.err, tt.target), func(t *testing.T) {
+			mockT := new(captureTestingT)
+			res := ErrorIs(mockT, tt.err, tt.target)
+			mockT.checkResultAndErrMsg(t, tt.result, res, tt.resultErrMsg)
+		})
+	}
+}
+
+func TestNotErrorIs(t *testing.T) {
+	tests := []struct {
+		err          error
+		target       error
+		result       bool
+		resultErrMsg string
+	}{
+		{
+			err:    io.EOF,
+			target: io.EOF,
+			result: false,
+			resultErrMsg: "" +
+				"Target error should not be in err chain:\n" +
+				"found: \"EOF\"\n" +
+				"in chain: \"EOF\"\n",
+		},
+		{
+			err:    fmt.Errorf("wrap: %w", io.EOF),
+			target: io.EOF,
+			result: false,
+			resultErrMsg: "" +
+				"Target error should not be in err chain:\n" +
+				"found: \"EOF\"\n" +
+				"in chain: \"wrap: EOF\"\n" +
+				"\t\"EOF\"\n",
+		},
+		{
+			err:    io.EOF,
+			target: io.ErrClosedPipe,
+			result: true,
+		},
+		{
+			err:    nil,
+			target: io.EOF,
+			result: true,
+		},
+		{
+			err:    io.EOF,
+			target: nil,
+			result: true,
+		},
+		{
+			err:    nil,
+			target: nil,
+			result: false,
+			resultErrMsg: "" +
+				"Target error should not be in err chain:\n" +
+				"found: \"\"\n" +
+				"in chain: \n",
+		},
+		{
+			err:    fmt.Errorf("abc: %w", errors.New("def")),
+			target: io.EOF,
+			result: true,
+		},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(fmt.Sprintf("NotErrorIs(%#v,%#v)", tt.err, tt.target), func(t *testing.T) {
+			mockT := new(captureTestingT)
+			res := NotErrorIs(mockT, tt.err, tt.target)
+			mockT.checkResultAndErrMsg(t, tt.result, res, tt.resultErrMsg)
+		})
+	}
+}
+
+func TestErrorAs(t *testing.T) {
+	mockT := new(testing.T)
+	tests := []struct {
+		err    error
+		result bool
+	}{
+		{fmt.Errorf("wrap: %w", &customError{}), true},
+		{io.EOF, false},
+		{nil, false},
+	}
+	for _, tt := range tests {
+		tt := tt
+		var target *customError
+		t.Run(fmt.Sprintf("ErrorAs(%#v,%#v)", tt.err, target), func(t *testing.T) {
+			res := ErrorAs(mockT, tt.err, &target)
+			if res != tt.result {
+				t.Errorf("ErrorAs(%#v,%#v) should return %t)", tt.err, target, tt.result)
+			}
+		})
+	}
+}
diff --git a/internal/testify/assert/doc.go b/internal/testify/assert/doc.go
new file mode 100644
index 000000000..78eba795c
--- /dev/null
+++ b/internal/testify/assert/doc.go
@@ -0,0 +1,46 @@
+// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
+//
+// # Example Usage
+//
+// The following is a complete example using assert in a standard test function:
+//
+//	import (
+//	  "testing"
+//	  "github.com/expr-lang/expr/internal/testify/assert"
+//	)
+//
+//	func TestSomething(t *testing.T) {
+//
+//	  var a string = "Hello"
+//	  var b string = "Hello"
+//
+//	  assert.Equal(t, a, b, "The two words should be the same.")
+//
+//	}
+//
+// if you assert many times, use the format below:
+//
+//	import (
+//	  "testing"
+//	  "github.com/expr-lang/expr/internal/testify/assert"
+//	)
+//
+//	func TestSomething(t *testing.T) {
+//	  assert := assert.New(t)
+//
+//	  var a string = "Hello"
+//	  var b string = "Hello"
+//
+//	  assert.Equal(a, b, "The two words should be the same.")
+//	}
+//
+// # Assertions
+//
+// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
+// All assertion functions take, as the first argument, the `*testing.T` object provided by the
+// testing framework. This allows the assertion funcs to write the failings and other details to
+// the correct place.
+//
+// Every assertion function also takes an optional string message as the final argument,
+// allowing custom error messages to be appended to the message the assertion method outputs.
+package assert
diff --git a/internal/testify/assert/errors.go b/internal/testify/assert/errors.go
new file mode 100644
index 000000000..ac9dc9d1d
--- /dev/null
+++ b/internal/testify/assert/errors.go
@@ -0,0 +1,10 @@
+package assert
+
+import (
+	"errors"
+)
+
+// AnError is an error instance useful for testing.  If the code does not care
+// about error specifics, and only needs to return the error for example, this
+// error should be used to make the test code more readable.
+var AnError = errors.New("assert.AnError general error for testing")
diff --git a/internal/testify/assert/forward_assertions.go b/internal/testify/assert/forward_assertions.go
new file mode 100644
index 000000000..df189d234
--- /dev/null
+++ b/internal/testify/assert/forward_assertions.go
@@ -0,0 +1,16 @@
+package assert
+
+// Assertions provides assertion methods around the
+// TestingT interface.
+type Assertions struct {
+	t TestingT
+}
+
+// New makes a new Assertions object for the specified TestingT.
+func New(t TestingT) *Assertions {
+	return &Assertions{
+		t: t,
+	}
+}
+
+//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs"
diff --git a/internal/testify/assert/forward_assertions_test.go b/internal/testify/assert/forward_assertions_test.go
new file mode 100644
index 000000000..c1567a631
--- /dev/null
+++ b/internal/testify/assert/forward_assertions_test.go
@@ -0,0 +1,654 @@
+package assert
+
+import (
+	"errors"
+	"regexp"
+	"testing"
+	"time"
+)
+
+func TestImplementsWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	if !assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
+		t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface")
+	}
+	if assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
+		t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface")
+	}
+}
+
+func TestIsTypeWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	if !assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
+		t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject")
+	}
+	if assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) {
+		t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject")
+	}
+
+}
+
+func TestEqualWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	if !assert.Equal("Hello World", "Hello World") {
+		t.Error("Equal should return true")
+	}
+	if !assert.Equal(123, 123) {
+		t.Error("Equal should return true")
+	}
+	if !assert.Equal(123.5, 123.5) {
+		t.Error("Equal should return true")
+	}
+	if !assert.Equal([]byte("Hello World"), []byte("Hello World")) {
+		t.Error("Equal should return true")
+	}
+	if !assert.Equal(nil, nil) {
+		t.Error("Equal should return true")
+	}
+}
+
+func TestEqualValuesWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	if !assert.EqualValues(uint32(10), int32(10)) {
+		t.Error("EqualValues should return true")
+	}
+}
+
+func TestNotNilWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	if !assert.NotNil(new(AssertionTesterConformingObject)) {
+		t.Error("NotNil should return true: object is not nil")
+	}
+	if assert.NotNil(nil) {
+		t.Error("NotNil should return false: object is nil")
+	}
+
+}
+
+func TestNilWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	if !assert.Nil(nil) {
+		t.Error("Nil should return true: object is nil")
+	}
+	if assert.Nil(new(AssertionTesterConformingObject)) {
+		t.Error("Nil should return false: object is not nil")
+	}
+
+}
+
+func TestTrueWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	if !assert.True(true) {
+		t.Error("True should return true")
+	}
+	if assert.True(false) {
+		t.Error("True should return false")
+	}
+
+}
+
+func TestFalseWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	if !assert.False(false) {
+		t.Error("False should return true")
+	}
+	if assert.False(true) {
+		t.Error("False should return false")
+	}
+
+}
+
+func TestExactlyWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	a := float32(1)
+	b := float64(1)
+	c := float32(1)
+	d := float32(2)
+
+	if assert.Exactly(a, b) {
+		t.Error("Exactly should return false")
+	}
+	if assert.Exactly(a, d) {
+		t.Error("Exactly should return false")
+	}
+	if !assert.Exactly(a, c) {
+		t.Error("Exactly should return true")
+	}
+
+	if assert.Exactly(nil, a) {
+		t.Error("Exactly should return false")
+	}
+	if assert.Exactly(a, nil) {
+		t.Error("Exactly should return false")
+	}
+
+}
+
+func TestNotEqualWrapper(t *testing.T) {
+
+	assert := New(new(testing.T))
+
+	if !assert.NotEqual("Hello World", "Hello World!") {
+		t.Error("NotEqual should return true")
+	}
+	if !assert.NotEqual(123, 1234) {
+		t.Error("NotEqual should return true")
+	}
+	if !assert.NotEqual(123.5, 123.55) {
+		t.Error("NotEqual should return true")
+	}
+	if !assert.NotEqual([]byte("Hello World"), []byte("Hello World!")) {
+		t.Error("NotEqual should return true")
+	}
+	if !assert.NotEqual(nil, new(AssertionTesterConformingObject)) {
+		t.Error("NotEqual should return true")
+	}
+}
+
+func TestNotEqualValuesWrapper(t *testing.T) {
+
+	assert := New(new(testing.T))
+
+	if !assert.NotEqualValues("Hello World", "Hello World!") {
+		t.Error("NotEqualValues should return true")
+	}
+	if !assert.NotEqualValues(123, 1234) {
+		t.Error("NotEqualValues should return true")
+	}
+	if !assert.NotEqualValues(123.5, 123.55) {
+		t.Error("NotEqualValues should return true")
+	}
+	if !assert.NotEqualValues([]byte("Hello World"), []byte("Hello World!")) {
+		t.Error("NotEqualValues should return true")
+	}
+	if !assert.NotEqualValues(nil, new(AssertionTesterConformingObject)) {
+		t.Error("NotEqualValues should return true")
+	}
+	if assert.NotEqualValues(10, uint(10)) {
+		t.Error("NotEqualValues should return false")
+	}
+}
+
+func TestContainsWrapper(t *testing.T) {
+
+	assert := New(new(testing.T))
+	list := []string{"Foo", "Bar"}
+
+	if !assert.Contains("Hello World", "Hello") {
+		t.Error("Contains should return true: \"Hello World\" contains \"Hello\"")
+	}
+	if assert.Contains("Hello World", "Salut") {
+		t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"")
+	}
+
+	if !assert.Contains(list, "Foo") {
+		t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
+	}
+	if assert.Contains(list, "Salut") {
+		t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"")
+	}
+
+}
+
+func TestNotContainsWrapper(t *testing.T) {
+
+	assert := New(new(testing.T))
+	list := []string{"Foo", "Bar"}
+
+	if !assert.NotContains("Hello World", "Hello!") {
+		t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"")
+	}
+	if assert.NotContains("Hello World", "Hello") {
+		t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"")
+	}
+
+	if !assert.NotContains(list, "Foo!") {
+		t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"")
+	}
+	if assert.NotContains(list, "Foo") {
+		t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
+	}
+
+}
+
+func TestConditionWrapper(t *testing.T) {
+
+	assert := New(new(testing.T))
+
+	if !assert.Condition(func() bool { return true }, "Truth") {
+		t.Error("Condition should return true")
+	}
+
+	if assert.Condition(func() bool { return false }, "Lie") {
+		t.Error("Condition should return false")
+	}
+
+}
+
+func TestDidPanicWrapper(t *testing.T) {
+
+	if funcDidPanic, _, _ := didPanic(func() {
+		panic("Panic!")
+	}); !funcDidPanic {
+		t.Error("didPanic should return true")
+	}
+
+	if funcDidPanic, _, _ := didPanic(func() {
+	}); funcDidPanic {
+		t.Error("didPanic should return false")
+	}
+
+}
+
+func TestPanicsWrapper(t *testing.T) {
+
+	assert := New(new(testing.T))
+
+	if !assert.Panics(func() {
+		panic("Panic!")
+	}) {
+		t.Error("Panics should return true")
+	}
+
+	if assert.Panics(func() {
+	}) {
+		t.Error("Panics should return false")
+	}
+
+}
+
+func TestNotPanicsWrapper(t *testing.T) {
+
+	assert := New(new(testing.T))
+
+	if !assert.NotPanics(func() {
+	}) {
+		t.Error("NotPanics should return true")
+	}
+
+	if assert.NotPanics(func() {
+		panic("Panic!")
+	}) {
+		t.Error("NotPanics should return false")
+	}
+
+}
+
+func TestNoErrorWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	// start with a nil error
+	var err error
+
+	assert.True(mockAssert.NoError(err), "NoError should return True for nil arg")
+
+	// now set an error
+	err = errors.New("Some error")
+
+	assert.False(mockAssert.NoError(err), "NoError with error should return False")
+
+}
+
+func TestErrorWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	// start with a nil error
+	var err error
+
+	assert.False(mockAssert.Error(err), "Error should return False for nil arg")
+
+	// now set an error
+	err = errors.New("Some error")
+
+	assert.True(mockAssert.Error(err), "Error with error should return True")
+
+}
+
+func TestErrorContainsWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	// start with a nil error
+	var err error
+	assert.False(mockAssert.ErrorContains(err, ""),
+		"ErrorContains should return false for nil arg")
+
+	// now set an error
+	err = errors.New("some error: another error")
+	assert.False(mockAssert.ErrorContains(err, "different error"),
+		"ErrorContains should return false for different error string")
+	assert.True(mockAssert.ErrorContains(err, "some error"),
+		"ErrorContains should return true")
+	assert.True(mockAssert.ErrorContains(err, "another error"),
+		"ErrorContains should return true")
+}
+
+func TestEqualErrorWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	// start with a nil error
+	var err error
+	assert.False(mockAssert.EqualError(err, ""),
+		"EqualError should return false for nil arg")
+
+	// now set an error
+	err = errors.New("some error")
+	assert.False(mockAssert.EqualError(err, "Not some error"),
+		"EqualError should return false for different error string")
+	assert.True(mockAssert.EqualError(err, "some error"),
+		"EqualError should return true")
+}
+
+func TestEmptyWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	assert.True(mockAssert.Empty(""), "Empty string is empty")
+	assert.True(mockAssert.Empty(nil), "Nil is empty")
+	assert.True(mockAssert.Empty([]string{}), "Empty string array is empty")
+	assert.True(mockAssert.Empty(0), "Zero int value is empty")
+	assert.True(mockAssert.Empty(false), "False value is empty")
+
+	assert.False(mockAssert.Empty("something"), "Non Empty string is not empty")
+	assert.False(mockAssert.Empty(errors.New("something")), "Non nil object is not empty")
+	assert.False(mockAssert.Empty([]string{"something"}), "Non empty string array is not empty")
+	assert.False(mockAssert.Empty(1), "Non-zero int value is not empty")
+	assert.False(mockAssert.Empty(true), "True value is not empty")
+
+}
+
+func TestNotEmptyWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	assert.False(mockAssert.NotEmpty(""), "Empty string is empty")
+	assert.False(mockAssert.NotEmpty(nil), "Nil is empty")
+	assert.False(mockAssert.NotEmpty([]string{}), "Empty string array is empty")
+	assert.False(mockAssert.NotEmpty(0), "Zero int value is empty")
+	assert.False(mockAssert.NotEmpty(false), "False value is empty")
+
+	assert.True(mockAssert.NotEmpty("something"), "Non Empty string is not empty")
+	assert.True(mockAssert.NotEmpty(errors.New("something")), "Non nil object is not empty")
+	assert.True(mockAssert.NotEmpty([]string{"something"}), "Non empty string array is not empty")
+	assert.True(mockAssert.NotEmpty(1), "Non-zero int value is not empty")
+	assert.True(mockAssert.NotEmpty(true), "True value is not empty")
+
+}
+
+func TestLenWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	assert.False(mockAssert.Len(nil, 0), "nil does not have length")
+	assert.False(mockAssert.Len(0, 0), "int does not have length")
+	assert.False(mockAssert.Len(true, 0), "true does not have length")
+	assert.False(mockAssert.Len(false, 0), "false does not have length")
+	assert.False(mockAssert.Len('A', 0), "Rune does not have length")
+	assert.False(mockAssert.Len(struct{}{}, 0), "Struct does not have length")
+
+	ch := make(chan int, 5)
+	ch <- 1
+	ch <- 2
+	ch <- 3
+
+	cases := []struct {
+		v interface{}
+		l int
+	}{
+		{[]int{1, 2, 3}, 3},
+		{[...]int{1, 2, 3}, 3},
+		{"ABC", 3},
+		{map[int]int{1: 2, 2: 4, 3: 6}, 3},
+		{ch, 3},
+
+		{[]int{}, 0},
+		{map[int]int{}, 0},
+		{make(chan int), 0},
+
+		{[]int(nil), 0},
+		{map[int]int(nil), 0},
+		{(chan int)(nil), 0},
+	}
+
+	for _, c := range cases {
+		assert.True(mockAssert.Len(c.v, c.l), "%#v have %d items", c.v, c.l)
+	}
+}
+
+func TestWithinDurationWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+	a := time.Now()
+	b := a.Add(10 * time.Second)
+
+	assert.True(mockAssert.WithinDuration(a, b, 10*time.Second), "A 10s difference is within a 10s time difference")
+	assert.True(mockAssert.WithinDuration(b, a, 10*time.Second), "A 10s difference is within a 10s time difference")
+
+	assert.False(mockAssert.WithinDuration(a, b, 9*time.Second), "A 10s difference is not within a 9s time difference")
+	assert.False(mockAssert.WithinDuration(b, a, 9*time.Second), "A 10s difference is not within a 9s time difference")
+
+	assert.False(mockAssert.WithinDuration(a, b, -9*time.Second), "A 10s difference is not within a 9s time difference")
+	assert.False(mockAssert.WithinDuration(b, a, -9*time.Second), "A 10s difference is not within a 9s time difference")
+
+	assert.False(mockAssert.WithinDuration(a, b, -11*time.Second), "A 10s difference is not within a 9s time difference")
+	assert.False(mockAssert.WithinDuration(b, a, -11*time.Second), "A 10s difference is not within a 9s time difference")
+}
+
+func TestInDeltaWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	True(t, assert.InDelta(1.001, 1, 0.01), "|1.001 - 1| <= 0.01")
+	True(t, assert.InDelta(1, 1.001, 0.01), "|1 - 1.001| <= 0.01")
+	True(t, assert.InDelta(1, 2, 1), "|1 - 2| <= 1")
+	False(t, assert.InDelta(1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail")
+	False(t, assert.InDelta(2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail")
+	False(t, assert.InDelta("", nil, 1), "Expected non numerals to fail")
+
+	cases := []struct {
+		a, b  interface{}
+		delta float64
+	}{
+		{uint8(2), uint8(1), 1},
+		{uint16(2), uint16(1), 1},
+		{uint32(2), uint32(1), 1},
+		{uint64(2), uint64(1), 1},
+
+		{int(2), int(1), 1},
+		{int8(2), int8(1), 1},
+		{int16(2), int16(1), 1},
+		{int32(2), int32(1), 1},
+		{int64(2), int64(1), 1},
+
+		{float32(2), float32(1), 1},
+		{float64(2), float64(1), 1},
+	}
+
+	for _, tc := range cases {
+		True(t, assert.InDelta(tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta)
+	}
+}
+
+func TestInEpsilonWrapper(t *testing.T) {
+	assert := New(new(testing.T))
+
+	cases := []struct {
+		a, b    interface{}
+		epsilon float64
+	}{
+		{uint8(2), uint16(2), .001},
+		{2.1, 2.2, 0.1},
+		{2.2, 2.1, 0.1},
+		{-2.1, -2.2, 0.1},
+		{-2.2, -2.1, 0.1},
+		{uint64(100), uint8(101), 0.01},
+		{0.1, -0.1, 2},
+	}
+
+	for _, tc := range cases {
+		True(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
+	}
+
+	cases = []struct {
+		a, b    interface{}
+		epsilon float64
+	}{
+		{uint8(2), int16(-2), .001},
+		{uint64(100), uint8(102), 0.01},
+		{2.1, 2.2, 0.001},
+		{2.2, 2.1, 0.001},
+		{2.1, -2.2, 1},
+		{2.1, "bla-bla", 0},
+		{0.1, -0.1, 1.99},
+	}
+
+	for _, tc := range cases {
+		False(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
+	}
+}
+
+func TestRegexpWrapper(t *testing.T) {
+
+	assert := New(new(testing.T))
+
+	cases := []struct {
+		rx, str string
+	}{
+		{"^start", "start of the line"},
+		{"end$", "in the end"},
+		{"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
+	}
+
+	for _, tc := range cases {
+		True(t, assert.Regexp(tc.rx, tc.str))
+		True(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str))
+		False(t, assert.NotRegexp(tc.rx, tc.str))
+		False(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str))
+	}
+
+	cases = []struct {
+		rx, str string
+	}{
+		{"^asdfastart", "Not the start of the line"},
+		{"end$", "in the end."},
+		{"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"},
+	}
+
+	for _, tc := range cases {
+		False(t, assert.Regexp(tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
+		False(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str))
+		True(t, assert.NotRegexp(tc.rx, tc.str))
+		True(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str))
+	}
+}
+
+func TestZeroWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	for _, test := range zeros {
+		assert.True(mockAssert.Zero(test), "Zero should return true for %v", test)
+	}
+
+	for _, test := range nonZeros {
+		assert.False(mockAssert.Zero(test), "Zero should return false for %v", test)
+	}
+}
+
+func TestNotZeroWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	for _, test := range zeros {
+		assert.False(mockAssert.NotZero(test), "Zero should return true for %v", test)
+	}
+
+	for _, test := range nonZeros {
+		assert.True(mockAssert.NotZero(test), "Zero should return false for %v", test)
+	}
+}
+
+func TestJSONEqWrapper_EqualSONString(t *testing.T) {
+	assert := New(new(testing.T))
+	if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) {
+		t.Error("JSONEq should return true")
+	}
+
+}
+
+func TestJSONEqWrapper_EquivalentButNotEqual(t *testing.T) {
+	assert := New(new(testing.T))
+	if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) {
+		t.Error("JSONEq should return true")
+	}
+
+}
+
+func TestJSONEqWrapper_HashOfArraysAndHashes(t *testing.T) {
+	assert := New(new(testing.T))
+	if !assert.JSONEq("{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
+		"{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}") {
+		t.Error("JSONEq should return true")
+	}
+}
+
+func TestJSONEqWrapper_Array(t *testing.T) {
+	assert := New(new(testing.T))
+	if !assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) {
+		t.Error("JSONEq should return true")
+	}
+
+}
+
+func TestJSONEqWrapper_HashAndArrayNotEquivalent(t *testing.T) {
+	assert := New(new(testing.T))
+	if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) {
+		t.Error("JSONEq should return false")
+	}
+}
+
+func TestJSONEqWrapper_HashesNotEquivalent(t *testing.T) {
+	assert := New(new(testing.T))
+	if assert.JSONEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) {
+		t.Error("JSONEq should return false")
+	}
+}
+
+func TestJSONEqWrapper_ActualIsNotJSON(t *testing.T) {
+	assert := New(new(testing.T))
+	if assert.JSONEq(`{"foo": "bar"}`, "Not JSON") {
+		t.Error("JSONEq should return false")
+	}
+}
+
+func TestJSONEqWrapper_ExpectedIsNotJSON(t *testing.T) {
+	assert := New(new(testing.T))
+	if assert.JSONEq("Not JSON", `{"foo": "bar", "hello": "world"}`) {
+		t.Error("JSONEq should return false")
+	}
+}
+
+func TestJSONEqWrapper_ExpectedAndActualNotJSON(t *testing.T) {
+	assert := New(new(testing.T))
+	if assert.JSONEq("Not JSON", "Not JSON") {
+		t.Error("JSONEq should return false")
+	}
+}
+
+func TestJSONEqWrapper_ArraysOfDifferentOrder(t *testing.T) {
+	assert := New(new(testing.T))
+	if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) {
+		t.Error("JSONEq should return false")
+	}
+}
diff --git a/internal/testify/assert/http_assertions.go b/internal/testify/assert/http_assertions.go
new file mode 100644
index 000000000..861ed4b7c
--- /dev/null
+++ b/internal/testify/assert/http_assertions.go
@@ -0,0 +1,165 @@
+package assert
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+)
+
+// httpCode is a helper that returns HTTP code of the response. It returns -1 and
+// an error if building a new request fails.
+func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) {
+	w := httptest.NewRecorder()
+	req, err := http.NewRequest(method, url, http.NoBody)
+	if err != nil {
+		return -1, err
+	}
+	req.URL.RawQuery = values.Encode()
+	handler(w, req)
+	return w.Code, nil
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//	assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	code, err := httpCode(handler, method, url, values)
+	if err != nil {
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
+	}
+
+	isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent
+	if !isSuccessCode {
+		Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
+	}
+
+	return isSuccessCode
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//	assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	code, err := httpCode(handler, method, url, values)
+	if err != nil {
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
+	}
+
+	isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
+	if !isRedirectCode {
+		Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
+	}
+
+	return isRedirectCode
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//	assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	code, err := httpCode(handler, method, url, values)
+	if err != nil {
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
+	}
+
+	isErrorCode := code >= http.StatusBadRequest
+	if !isErrorCode {
+		Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
+	}
+
+	return isErrorCode
+}
+
+// HTTPStatusCode asserts that a specified handler returns a specified status code.
+//
+//	assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	code, err := httpCode(handler, method, url, values)
+	if err != nil {
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
+	}
+
+	successful := code == statuscode
+	if !successful {
+		Fail(t, fmt.Sprintf("Expected HTTP status code %d for %q but received %d", statuscode, url+"?"+values.Encode(), code), msgAndArgs...)
+	}
+
+	return successful
+}
+
+// HTTPBody is a helper that returns HTTP body of the response. It returns
+// empty string if building a new request fails.
+func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string {
+	w := httptest.NewRecorder()
+	if len(values) > 0 {
+		url += "?" + values.Encode()
+	}
+	req, err := http.NewRequest(method, url, http.NoBody)
+	if err != nil {
+		return ""
+	}
+	handler(w, req)
+	return w.Body.String()
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//	assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	body := HTTPBody(handler, method, url, values)
+
+	contains := strings.Contains(body, fmt.Sprint(str))
+	if !contains {
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...)
+	}
+
+	return contains
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//	assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	body := HTTPBody(handler, method, url, values)
+
+	contains := strings.Contains(body, fmt.Sprint(str))
+	if contains {
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...)
+	}
+
+	return !contains
+}
diff --git a/internal/testify/assert/http_assertions_test.go b/internal/testify/assert/http_assertions_test.go
new file mode 100644
index 000000000..dd84f02f1
--- /dev/null
+++ b/internal/testify/assert/http_assertions_test.go
@@ -0,0 +1,214 @@
+package assert
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"testing"
+)
+
+func httpOK(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusOK)
+}
+
+func httpReadBody(w http.ResponseWriter, r *http.Request) {
+	_, _ = io.Copy(io.Discard, r.Body)
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write([]byte("hello"))
+}
+
+func httpRedirect(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusTemporaryRedirect)
+}
+
+func httpError(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusInternalServerError)
+}
+
+func httpStatusCode(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusSwitchingProtocols)
+}
+
+func TestHTTPSuccess(t *testing.T) {
+	assert := New(t)
+
+	mockT1 := new(testing.T)
+	assert.Equal(HTTPSuccess(mockT1, httpOK, "GET", "/", nil), true)
+	assert.False(mockT1.Failed())
+
+	mockT2 := new(testing.T)
+	assert.Equal(HTTPSuccess(mockT2, httpRedirect, "GET", "/", nil), false)
+	assert.True(mockT2.Failed())
+
+	mockT3 := new(mockTestingT)
+	assert.Equal(HTTPSuccess(
+		mockT3, httpError, "GET", "/", nil,
+		"was not expecting a failure here",
+	), false)
+	assert.True(mockT3.Failed())
+	assert.Contains(mockT3.errorString(), "was not expecting a failure here")
+
+	mockT4 := new(testing.T)
+	assert.Equal(HTTPSuccess(mockT4, httpStatusCode, "GET", "/", nil), false)
+	assert.True(mockT4.Failed())
+
+	mockT5 := new(testing.T)
+	assert.Equal(HTTPSuccess(mockT5, httpReadBody, "POST", "/", nil), true)
+	assert.False(mockT5.Failed())
+}
+
+func TestHTTPRedirect(t *testing.T) {
+	assert := New(t)
+
+	mockT1 := new(mockTestingT)
+	assert.Equal(HTTPRedirect(
+		mockT1, httpOK, "GET", "/", nil,
+		"was expecting a 3xx status code. Got 200.",
+	), false)
+	assert.True(mockT1.Failed())
+	assert.Contains(mockT1.errorString(), "was expecting a 3xx status code. Got 200.")
+
+	mockT2 := new(testing.T)
+	assert.Equal(HTTPRedirect(mockT2, httpRedirect, "GET", "/", nil), true)
+	assert.False(mockT2.Failed())
+
+	mockT3 := new(testing.T)
+	assert.Equal(HTTPRedirect(mockT3, httpError, "GET", "/", nil), false)
+	assert.True(mockT3.Failed())
+
+	mockT4 := new(testing.T)
+	assert.Equal(HTTPRedirect(mockT4, httpStatusCode, "GET", "/", nil), false)
+	assert.True(mockT4.Failed())
+}
+
+func TestHTTPError(t *testing.T) {
+	assert := New(t)
+
+	mockT1 := new(testing.T)
+	assert.Equal(HTTPError(mockT1, httpOK, "GET", "/", nil), false)
+	assert.True(mockT1.Failed())
+
+	mockT2 := new(mockTestingT)
+	assert.Equal(HTTPError(
+		mockT2, httpRedirect, "GET", "/", nil,
+		"Expected this request to error out. But it didn't",
+	), false)
+	assert.True(mockT2.Failed())
+	assert.Contains(mockT2.errorString(), "Expected this request to error out. But it didn't")
+
+	mockT3 := new(testing.T)
+	assert.Equal(HTTPError(mockT3, httpError, "GET", "/", nil), true)
+	assert.False(mockT3.Failed())
+
+	mockT4 := new(testing.T)
+	assert.Equal(HTTPError(mockT4, httpStatusCode, "GET", "/", nil), false)
+	assert.True(mockT4.Failed())
+}
+
+func TestHTTPStatusCode(t *testing.T) {
+	assert := New(t)
+
+	mockT1 := new(testing.T)
+	assert.Equal(HTTPStatusCode(mockT1, httpOK, "GET", "/", nil, http.StatusSwitchingProtocols), false)
+	assert.True(mockT1.Failed())
+
+	mockT2 := new(testing.T)
+	assert.Equal(HTTPStatusCode(mockT2, httpRedirect, "GET", "/", nil, http.StatusSwitchingProtocols), false)
+	assert.True(mockT2.Failed())
+
+	mockT3 := new(mockTestingT)
+	assert.Equal(HTTPStatusCode(
+		mockT3, httpError, "GET", "/", nil, http.StatusSwitchingProtocols,
+		"Expected the status code to be %d", http.StatusSwitchingProtocols,
+	), false)
+	assert.True(mockT3.Failed())
+	assert.Contains(mockT3.errorString(), "Expected the status code to be 101")
+
+	mockT4 := new(testing.T)
+	assert.Equal(HTTPStatusCode(mockT4, httpStatusCode, "GET", "/", nil, http.StatusSwitchingProtocols), true)
+	assert.False(mockT4.Failed())
+}
+
+func TestHTTPStatusesWrapper(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	assert.Equal(mockAssert.HTTPSuccess(httpOK, "GET", "/", nil), true)
+	assert.Equal(mockAssert.HTTPSuccess(httpRedirect, "GET", "/", nil), false)
+	assert.Equal(mockAssert.HTTPSuccess(httpError, "GET", "/", nil), false)
+
+	assert.Equal(mockAssert.HTTPRedirect(httpOK, "GET", "/", nil), false)
+	assert.Equal(mockAssert.HTTPRedirect(httpRedirect, "GET", "/", nil), true)
+	assert.Equal(mockAssert.HTTPRedirect(httpError, "GET", "/", nil), false)
+
+	assert.Equal(mockAssert.HTTPError(httpOK, "GET", "/", nil), false)
+	assert.Equal(mockAssert.HTTPError(httpRedirect, "GET", "/", nil), false)
+	assert.Equal(mockAssert.HTTPError(httpError, "GET", "/", nil), true)
+}
+
+func httpHelloName(w http.ResponseWriter, r *http.Request) {
+	name := r.FormValue("name")
+	_, _ = fmt.Fprintf(w, "Hello, %s!", name)
+}
+
+func TestHTTPRequestWithNoParams(t *testing.T) {
+	var got *http.Request
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		got = r
+		w.WriteHeader(http.StatusOK)
+	}
+
+	True(t, HTTPSuccess(t, handler, "GET", "/url", nil))
+
+	Empty(t, got.URL.Query())
+	Equal(t, "/url", got.URL.RequestURI())
+}
+
+func TestHTTPRequestWithParams(t *testing.T) {
+	var got *http.Request
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		got = r
+		w.WriteHeader(http.StatusOK)
+	}
+	params := url.Values{}
+	params.Add("id", "12345")
+
+	True(t, HTTPSuccess(t, handler, "GET", "/url", params))
+
+	Equal(t, url.Values{"id": []string{"12345"}}, got.URL.Query())
+	Equal(t, "/url?id=12345", got.URL.String())
+	Equal(t, "/url?id=12345", got.URL.RequestURI())
+}
+
+func TestHttpBody(t *testing.T) {
+	assert := New(t)
+	mockT := new(mockTestingT)
+
+	assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
+	assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
+	assert.False(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
+
+	assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
+	assert.False(HTTPBodyNotContains(
+		mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World",
+		"Expected the request body to not contain 'World'. But it did.",
+	))
+	assert.True(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
+	assert.Contains(mockT.errorString(), "Expected the request body to not contain 'World'. But it did.")
+
+	assert.True(HTTPBodyContains(mockT, httpReadBody, "GET", "/", nil, "hello"))
+}
+
+func TestHttpBodyWrappers(t *testing.T) {
+	assert := New(t)
+	mockAssert := New(new(testing.T))
+
+	assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
+	assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
+	assert.False(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
+
+	assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
+	assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
+	assert.True(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
+}
diff --git a/internal/testify/assert/internal/unsafetests/doc.go b/internal/testify/assert/internal/unsafetests/doc.go
new file mode 100644
index 000000000..08172d511
--- /dev/null
+++ b/internal/testify/assert/internal/unsafetests/doc.go
@@ -0,0 +1,4 @@
+// This package exists just to isolate tests that reference the [unsafe] package.
+//
+// The tests in this package are totally safe.
+package unsafetests
diff --git a/internal/testify/assert/internal/unsafetests/unsafetests_test.go b/internal/testify/assert/internal/unsafetests/unsafetests_test.go
new file mode 100644
index 000000000..47b66500f
--- /dev/null
+++ b/internal/testify/assert/internal/unsafetests/unsafetests_test.go
@@ -0,0 +1,34 @@
+package unsafetests_test
+
+import (
+	"fmt"
+	"testing"
+	"unsafe"
+
+	"github.com/expr-lang/expr/internal/testify/assert"
+)
+
+type ignoreTestingT struct{}
+
+var _ assert.TestingT = ignoreTestingT{}
+
+func (ignoreTestingT) Helper() {}
+
+func (ignoreTestingT) Errorf(format string, args ...interface{}) {
+	// Run the formatting, but ignore the result
+	msg := fmt.Sprintf(format, args...)
+	_ = msg
+}
+
+func TestUnsafePointers(t *testing.T) {
+	var ignore ignoreTestingT
+
+	assert.True(t, assert.Nil(t, unsafe.Pointer(nil), "unsafe.Pointer(nil) is nil"))
+	assert.False(t, assert.NotNil(ignore, unsafe.Pointer(nil), "unsafe.Pointer(nil) is nil"))
+
+	assert.True(t, assert.Nil(t, unsafe.Pointer((*int)(nil)), "unsafe.Pointer((*int)(nil)) is nil"))
+	assert.False(t, assert.NotNil(ignore, unsafe.Pointer((*int)(nil)), "unsafe.Pointer((*int)(nil)) is nil"))
+
+	assert.False(t, assert.Nil(ignore, unsafe.Pointer(new(int)), "unsafe.Pointer(new(int)) is NOT nil"))
+	assert.True(t, assert.NotNil(t, unsafe.Pointer(new(int)), "unsafe.Pointer(new(int)) is NOT nil"))
+}
diff --git a/internal/testify/require/doc.go b/internal/testify/require/doc.go
new file mode 100644
index 000000000..a3a9ccc19
--- /dev/null
+++ b/internal/testify/require/doc.go
@@ -0,0 +1,29 @@
+// Package require implements the same assertions as the `assert` package but
+// stops test execution when a test fails.
+//
+// # Example Usage
+//
+// The following is a complete example using require in a standard test function:
+//
+//	import (
+//	  "testing"
+//	  "github.com/expr-lang/expr/internal/testify/require"
+//	)
+//
+//	func TestSomething(t *testing.T) {
+//
+//	  var a string = "Hello"
+//	  var b string = "Hello"
+//
+//	  require.Equal(t, a, b, "The two words should be the same.")
+//
+//	}
+//
+// # Assertions
+//
+// The `require` package have same global functions as in the `assert` package,
+// but instead of returning a boolean result they call `t.FailNow()`.
+//
+// Every assertion function also takes an optional string message as the final argument,
+// allowing custom error messages to be appended to the message the assertion method outputs.
+package require
diff --git a/internal/testify/require/forward_requirements.go b/internal/testify/require/forward_requirements.go
new file mode 100644
index 000000000..1dcb2338c
--- /dev/null
+++ b/internal/testify/require/forward_requirements.go
@@ -0,0 +1,16 @@
+package require
+
+// Assertions provides assertion methods around the
+// TestingT interface.
+type Assertions struct {
+	t TestingT
+}
+
+// New makes a new Assertions object for the specified TestingT.
+func New(t TestingT) *Assertions {
+	return &Assertions{
+		t: t,
+	}
+}
+
+//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require_forward.go.tmpl -include-format-funcs"
diff --git a/internal/testify/require/forward_requirements_test.go b/internal/testify/require/forward_requirements_test.go
new file mode 100644
index 000000000..818ecec6d
--- /dev/null
+++ b/internal/testify/require/forward_requirements_test.go
@@ -0,0 +1,397 @@
+package require
+
+import (
+	"errors"
+	"testing"
+	"time"
+)
+
+func TestImplementsWrapper(t *testing.T) {
+	require := New(t)
+
+	require.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject))
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject))
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestIsTypeWrapper(t *testing.T) {
+	require := New(t)
+	require.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject))
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject))
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestEqualWrapper(t *testing.T) {
+	require := New(t)
+	require.Equal(1, 1)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.Equal(1, 2)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotEqualWrapper(t *testing.T) {
+	require := New(t)
+	require.NotEqual(1, 2)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.NotEqual(2, 2)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestExactlyWrapper(t *testing.T) {
+	require := New(t)
+
+	a := float32(1)
+	b := float32(1)
+	c := float64(1)
+
+	require.Exactly(a, b)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.Exactly(a, c)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotNilWrapper(t *testing.T) {
+	require := New(t)
+	require.NotNil(t, new(AssertionTesterConformingObject))
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.NotNil(nil)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNilWrapper(t *testing.T) {
+	require := New(t)
+	require.Nil(nil)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.Nil(new(AssertionTesterConformingObject))
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestTrueWrapper(t *testing.T) {
+	require := New(t)
+	require.True(true)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.True(false)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestFalseWrapper(t *testing.T) {
+	require := New(t)
+	require.False(false)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.False(true)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestContainsWrapper(t *testing.T) {
+	require := New(t)
+	require.Contains("Hello World", "Hello")
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.Contains("Hello World", "Salut")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotContainsWrapper(t *testing.T) {
+	require := New(t)
+	require.NotContains("Hello World", "Hello!")
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.NotContains("Hello World", "Hello")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestPanicsWrapper(t *testing.T) {
+	require := New(t)
+	require.Panics(func() {
+		panic("Panic!")
+	})
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.Panics(func() {})
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotPanicsWrapper(t *testing.T) {
+	require := New(t)
+	require.NotPanics(func() {})
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.NotPanics(func() {
+		panic("Panic!")
+	})
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNoErrorWrapper(t *testing.T) {
+	require := New(t)
+	require.NoError(nil)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.NoError(errors.New("some error"))
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestErrorWrapper(t *testing.T) {
+	require := New(t)
+	require.Error(errors.New("some error"))
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.Error(nil)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestErrorContainsWrapper(t *testing.T) {
+	require := New(t)
+	require.ErrorContains(errors.New("some error: another error"), "some error")
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.ErrorContains(errors.New("some error: another error"), "different error")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestEqualErrorWrapper(t *testing.T) {
+	require := New(t)
+	require.EqualError(errors.New("some error"), "some error")
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.EqualError(errors.New("some error"), "Not some error")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestEmptyWrapper(t *testing.T) {
+	require := New(t)
+	require.Empty("")
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.Empty("x")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotEmptyWrapper(t *testing.T) {
+	require := New(t)
+	require.NotEmpty("x")
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.NotEmpty("")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestWithinDurationWrapper(t *testing.T) {
+	require := New(t)
+	a := time.Now()
+	b := a.Add(10 * time.Second)
+
+	require.WithinDuration(a, b, 15*time.Second)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.WithinDuration(a, b, 5*time.Second)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestInDeltaWrapper(t *testing.T) {
+	require := New(t)
+	require.InDelta(1.001, 1, 0.01)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.InDelta(1, 2, 0.5)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestZeroWrapper(t *testing.T) {
+	require := New(t)
+	require.Zero(0)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.Zero(1)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotZeroWrapper(t *testing.T) {
+	require := New(t)
+	require.NotZero(1)
+
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+	mockRequire.NotZero(0)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEqWrapper_EqualSONString(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)
+	if mockT.Failed {
+		t.Error("Check should pass")
+	}
+}
+
+func TestJSONEqWrapper_EquivalentButNotEqual(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+	if mockT.Failed {
+		t.Error("Check should pass")
+	}
+}
+
+func TestJSONEqWrapper_HashOfArraysAndHashes(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq("{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
+		"{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}")
+	if mockT.Failed {
+		t.Error("Check should pass")
+	}
+}
+
+func TestJSONEqWrapper_Array(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)
+	if mockT.Failed {
+		t.Error("Check should pass")
+	}
+}
+
+func TestJSONEqWrapper_HashAndArrayNotEquivalent(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEqWrapper_HashesNotEquivalent(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEqWrapper_ActualIsNotJSON(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq(`{"foo": "bar"}`, "Not JSON")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEqWrapper_ExpectedIsNotJSON(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq("Not JSON", `{"foo": "bar", "hello": "world"}`)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEqWrapper_ExpectedAndActualNotJSON(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq("Not JSON", "Not JSON")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEqWrapper_ArraysOfDifferentOrder(t *testing.T) {
+	mockT := new(MockT)
+	mockRequire := New(mockT)
+
+	mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
diff --git a/internal/testify/require/require.go b/internal/testify/require/require.go
new file mode 100644
index 000000000..fb036865f
--- /dev/null
+++ b/internal/testify/require/require.go
@@ -0,0 +1,2039 @@
+// Code generated with github.com/expr-lang/expr/internal/_codegen; DO NOT EDIT.
+
+package require
+
+import (
+	http "net/http"
+	url "net/url"
+	time "time"
+
+	assert "github.com/expr-lang/expr/internal/testify/assert"
+)
+
+// Condition uses a Comparison to assert a complex condition.
+func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Condition(t, comp, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Conditionf uses a Comparison to assert a complex condition.
+func Conditionf(t TestingT, comp assert.Comparison, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Conditionf(t, comp, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Contains asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//	assert.Contains(t, "Hello World", "World")
+//	assert.Contains(t, ["Hello", "World"], "World")
+//	assert.Contains(t, {"Hello": "World"}, "Hello")
+func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Contains(t, s, contains, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Containsf asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//	assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
+//	assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
+//	assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
+func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Containsf(t, s, contains, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// DirExists checks whether a directory exists in the given path. It also fails
+// if the path is a file rather a directory or there is an error checking whether it exists.
+func DirExists(t TestingT, path string, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.DirExists(t, path, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// DirExistsf checks whether a directory exists in the given path. It also fails
+// if the path is a file rather a directory or there is an error checking whether it exists.
+func DirExistsf(t TestingT, path string, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.DirExistsf(t, path, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
+// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
+// the number of appearances of each of them in both lists should match.
+//
+// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])
+func ElementsMatch(t TestingT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.ElementsMatch(t, listA, listB, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
+// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
+// the number of appearances of each of them in both lists should match.
+//
+// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
+func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.ElementsMatchf(t, listA, listB, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	assert.Empty(t, obj)
+func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Empty(t, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	assert.Emptyf(t, obj, "error message %s", "formatted")
+func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Emptyf(t, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Equal asserts that two objects are equal.
+//
+//	assert.Equal(t, 123, 123)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Equal(t, expected, actual, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//	actualObj, err := SomeFunction()
+//	assert.EqualError(t, err,  expectedErrorString)
+func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.EqualError(t, theError, errString, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//	actualObj, err := SomeFunction()
+//	assert.EqualErrorf(t, err,  expectedErrorString, "error message %s", "formatted")
+func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.EqualErrorf(t, theError, errString, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// EqualExportedValues asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+//	 type S struct {
+//		Exported     	int
+//		notExported   	int
+//	 }
+//	 assert.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true
+//	 assert.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false
+func EqualExportedValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.EqualExportedValues(t, expected, actual, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// EqualExportedValuesf asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+//	 type S struct {
+//		Exported     	int
+//		notExported   	int
+//	 }
+//	 assert.EqualExportedValuesf(t, S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
+//	 assert.EqualExportedValuesf(t, S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
+func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.EqualExportedValuesf(t, expected, actual, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// EqualValues asserts that two objects are equal or convertible to the same types
+// and equal.
+//
+//	assert.EqualValues(t, uint32(123), int32(123))
+func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.EqualValues(t, expected, actual, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// EqualValuesf asserts that two objects are equal or convertible to the same types
+// and equal.
+//
+//	assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
+func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.EqualValuesf(t, expected, actual, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Equalf asserts that two objects are equal.
+//
+//	assert.Equalf(t, 123, 123, "error message %s", "formatted")
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Equalf(t, expected, actual, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if assert.Error(t, err) {
+//		   assert.Equal(t, expectedError, err)
+//	  }
+func Error(t TestingT, err error, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Error(t, err, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
+// This is a wrapper for errors.As.
+func ErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.ErrorAs(t, err, target, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
+// This is a wrapper for errors.As.
+func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.ErrorAsf(t, err, target, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// ErrorContains asserts that a function returned an error (i.e. not `nil`)
+// and that the error contains the specified substring.
+//
+//	actualObj, err := SomeFunction()
+//	assert.ErrorContains(t, err,  expectedErrorSubString)
+func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.ErrorContains(t, theError, contains, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
+// and that the error contains the specified substring.
+//
+//	actualObj, err := SomeFunction()
+//	assert.ErrorContainsf(t, err,  expectedErrorSubString, "error message %s", "formatted")
+func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.ErrorContainsf(t, theError, contains, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// ErrorIs asserts that at least one of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func ErrorIs(t TestingT, err error, target error, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.ErrorIs(t, err, target, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// ErrorIsf asserts that at least one of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.ErrorIsf(t, err, target, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Errorf asserts that a function returned an error (i.e. not `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if assert.Errorf(t, err, "error message %s", "formatted") {
+//		   assert.Equal(t, expectedErrorf, err)
+//	  }
+func Errorf(t TestingT, err error, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Errorf(t, err, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Eventually asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick.
+//
+//	assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
+func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Eventually(t, condition, waitFor, tick, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// EventuallyWithT asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+//	externalValue := false
+//	go func() {
+//		time.Sleep(8*time.Second)
+//		externalValue = true
+//	}()
+//	assert.EventuallyWithT(t, func(c *assert.CollectT) {
+//		// add assertions as needed; any assertion failure will fail the current tick
+//		assert.True(c, externalValue, "expected 'externalValue' to be true")
+//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+func EventuallyWithT(t TestingT, condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.EventuallyWithT(t, condition, waitFor, tick, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// EventuallyWithTf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+//	externalValue := false
+//	go func() {
+//		time.Sleep(8*time.Second)
+//		externalValue = true
+//	}()
+//	assert.EventuallyWithTf(t, func(c *assert.CollectT, "error message %s", "formatted") {
+//		// add assertions as needed; any assertion failure will fail the current tick
+//		assert.True(c, externalValue, "expected 'externalValue' to be true")
+//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+func EventuallyWithTf(t TestingT, condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.EventuallyWithTf(t, condition, waitFor, tick, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Eventuallyf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick.
+//
+//	assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Eventuallyf(t, condition, waitFor, tick, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Exactly asserts that two objects are equal in value and type.
+//
+//	assert.Exactly(t, int32(123), int64(123))
+func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Exactly(t, expected, actual, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Exactlyf asserts that two objects are equal in value and type.
+//
+//	assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
+func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Exactlyf(t, expected, actual, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Fail reports a failure through
+func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Fail(t, failureMessage, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// FailNow fails test
+func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.FailNow(t, failureMessage, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// FailNowf fails test
+func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.FailNowf(t, failureMessage, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Failf reports a failure through
+func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Failf(t, failureMessage, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// False asserts that the specified value is false.
+//
+//	assert.False(t, myBool)
+func False(t TestingT, value bool, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.False(t, value, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Falsef asserts that the specified value is false.
+//
+//	assert.Falsef(t, myBool, "error message %s", "formatted")
+func Falsef(t TestingT, value bool, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Falsef(t, value, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// FileExists checks whether a file exists in the given path. It also fails if
+// the path points to a directory or there is an error when trying to check the file.
+func FileExists(t TestingT, path string, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.FileExists(t, path, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// FileExistsf checks whether a file exists in the given path. It also fails if
+// the path points to a directory or there is an error when trying to check the file.
+func FileExistsf(t TestingT, path string, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.FileExistsf(t, path, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Greater asserts that the first element is greater than the second
+//
+//	assert.Greater(t, 2, 1)
+//	assert.Greater(t, float64(2), float64(1))
+//	assert.Greater(t, "b", "a")
+func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Greater(t, e1, e2, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// GreaterOrEqual asserts that the first element is greater than or equal to the second
+//
+//	assert.GreaterOrEqual(t, 2, 1)
+//	assert.GreaterOrEqual(t, 2, 2)
+//	assert.GreaterOrEqual(t, "b", "a")
+//	assert.GreaterOrEqual(t, "b", "b")
+func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.GreaterOrEqual(t, e1, e2, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// GreaterOrEqualf asserts that the first element is greater than or equal to the second
+//
+//	assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
+//	assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
+//	assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
+//	assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
+func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.GreaterOrEqualf(t, e1, e2, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Greaterf asserts that the first element is greater than the second
+//
+//	assert.Greaterf(t, 2, 1, "error message %s", "formatted")
+//	assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
+//	assert.Greaterf(t, "b", "a", "error message %s", "formatted")
+func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Greaterf(t, e1, e2, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//	assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPBodyContains(t, handler, method, url, values, str, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPBodyContainsf asserts that a specified handler returns a
+// body that contains a string.
+//
+//	assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPBodyContainsf(t, handler, method, url, values, str, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//	assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPBodyNotContains(t, handler, method, url, values, str, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPBodyNotContainsf asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//	assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPBodyNotContainsf(t, handler, method, url, values, str, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//	assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPError(t, handler, method, url, values, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPErrorf asserts that a specified handler returns an error status code.
+//
+//	assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPErrorf(t, handler, method, url, values, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//	assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPRedirect(t, handler, method, url, values, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPRedirectf asserts that a specified handler returns a redirect status code.
+//
+//	assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPRedirectf(t, handler, method, url, values, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPStatusCode asserts that a specified handler returns a specified status code.
+//
+//	assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPStatusCode(t, handler, method, url, values, statuscode, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPStatusCodef asserts that a specified handler returns a specified status code.
+//
+//	assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPStatusCodef(t, handler, method, url, values, statuscode, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//	assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPSuccess(t, handler, method, url, values, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// HTTPSuccessf asserts that a specified handler returns a success status code.
+//
+//	assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.HTTPSuccessf(t, handler, method, url, values, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+//	assert.Implements(t, (*MyInterface)(nil), new(MyObject))
+func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Implements(t, interfaceObject, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Implementsf asserts that an object is implemented by the specified interface.
+//
+//	assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Implementsf(t, interfaceObject, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+//	assert.InDelta(t, math.Pi, 22/7.0, 0.01)
+func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InDelta(t, expected, actual, delta, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
+func InDeltaMapValues(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InDeltaMapValues(t, expected, actual, delta, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
+func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InDeltaMapValuesf(t, expected, actual, delta, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InDeltaSlice is the same as InDelta, except it compares two slices.
+func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InDeltaSlice(t, expected, actual, delta, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InDeltaSlicef is the same as InDelta, except it compares two slices.
+func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InDeltaSlicef(t, expected, actual, delta, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InDeltaf asserts that the two numerals are within delta of each other.
+//
+//	assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
+func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InDeltaf(t, expected, actual, delta, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InEpsilon(t, expected, actual, epsilon, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
+func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InEpsilonSlice(t, expected, actual, epsilon, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
+func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InEpsilonSlicef(t, expected, actual, epsilon, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// InEpsilonf asserts that expected and actual have a relative error less than epsilon
+func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.InEpsilonf(t, expected, actual, epsilon, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsDecreasing asserts that the collection is decreasing
+//
+//	assert.IsDecreasing(t, []int{2, 1, 0})
+//	assert.IsDecreasing(t, []float{2, 1})
+//	assert.IsDecreasing(t, []string{"b", "a"})
+func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsDecreasing(t, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsDecreasingf asserts that the collection is decreasing
+//
+//	assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
+//	assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
+//	assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsDecreasingf(t, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsIncreasing asserts that the collection is increasing
+//
+//	assert.IsIncreasing(t, []int{1, 2, 3})
+//	assert.IsIncreasing(t, []float{1, 2})
+//	assert.IsIncreasing(t, []string{"a", "b"})
+func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsIncreasing(t, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsIncreasingf asserts that the collection is increasing
+//
+//	assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
+//	assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
+//	assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsIncreasingf(t, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsNonDecreasing asserts that the collection is not decreasing
+//
+//	assert.IsNonDecreasing(t, []int{1, 1, 2})
+//	assert.IsNonDecreasing(t, []float{1, 2})
+//	assert.IsNonDecreasing(t, []string{"a", "b"})
+func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsNonDecreasing(t, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsNonDecreasingf asserts that the collection is not decreasing
+//
+//	assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
+//	assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
+//	assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsNonDecreasingf(t, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsNonIncreasing asserts that the collection is not increasing
+//
+//	assert.IsNonIncreasing(t, []int{2, 1, 1})
+//	assert.IsNonIncreasing(t, []float{2, 1})
+//	assert.IsNonIncreasing(t, []string{"b", "a"})
+func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsNonIncreasing(t, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsNonIncreasingf asserts that the collection is not increasing
+//
+//	assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
+//	assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
+//	assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsNonIncreasingf(t, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsType asserts that the specified objects are of the same type.
+func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsType(t, expectedType, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// IsTypef asserts that the specified objects are of the same type.
+func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.IsTypef(t, expectedType, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// JSONEq asserts that two JSON strings are equivalent.
+//
+//	assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.JSONEq(t, expected, actual, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// JSONEqf asserts that two JSON strings are equivalent.
+//
+//	assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.JSONEqf(t, expected, actual, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+//	assert.Len(t, mySlice, 3)
+func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Len(t, object, length, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Lenf asserts that the specified object has specific length.
+// Lenf also fails if the object has a type that len() not accept.
+//
+//	assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
+func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Lenf(t, object, length, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Less asserts that the first element is less than the second
+//
+//	assert.Less(t, 1, 2)
+//	assert.Less(t, float64(1), float64(2))
+//	assert.Less(t, "a", "b")
+func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Less(t, e1, e2, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// LessOrEqual asserts that the first element is less than or equal to the second
+//
+//	assert.LessOrEqual(t, 1, 2)
+//	assert.LessOrEqual(t, 2, 2)
+//	assert.LessOrEqual(t, "a", "b")
+//	assert.LessOrEqual(t, "b", "b")
+func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.LessOrEqual(t, e1, e2, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// LessOrEqualf asserts that the first element is less than or equal to the second
+//
+//	assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
+//	assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
+//	assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
+//	assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
+func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.LessOrEqualf(t, e1, e2, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Lessf asserts that the first element is less than the second
+//
+//	assert.Lessf(t, 1, 2, "error message %s", "formatted")
+//	assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
+//	assert.Lessf(t, "a", "b", "error message %s", "formatted")
+func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Lessf(t, e1, e2, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Negative asserts that the specified element is negative
+//
+//	assert.Negative(t, -1)
+//	assert.Negative(t, -1.23)
+func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Negative(t, e, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Negativef asserts that the specified element is negative
+//
+//	assert.Negativef(t, -1, "error message %s", "formatted")
+//	assert.Negativef(t, -1.23, "error message %s", "formatted")
+func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Negativef(t, e, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Never asserts that the given condition doesn't satisfy in waitFor time,
+// periodically checking the target function each tick.
+//
+//	assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
+func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Never(t, condition, waitFor, tick, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Neverf asserts that the given condition doesn't satisfy in waitFor time,
+// periodically checking the target function each tick.
+//
+//	assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Neverf(t, condition, waitFor, tick, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Nil asserts that the specified object is nil.
+//
+//	assert.Nil(t, err)
+func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Nil(t, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Nilf asserts that the specified object is nil.
+//
+//	assert.Nilf(t, err, "error message %s", "formatted")
+func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Nilf(t, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NoDirExists checks whether a directory does not exist in the given path.
+// It fails if the path points to an existing _directory_ only.
+func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NoDirExists(t, path, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NoDirExistsf checks whether a directory does not exist in the given path.
+// It fails if the path points to an existing _directory_ only.
+func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NoDirExistsf(t, path, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if assert.NoError(t, err) {
+//		   assert.Equal(t, expectedObj, actualObj)
+//	  }
+func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NoError(t, err, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NoErrorf asserts that a function returned no error (i.e. `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if assert.NoErrorf(t, err, "error message %s", "formatted") {
+//		   assert.Equal(t, expectedObj, actualObj)
+//	  }
+func NoErrorf(t TestingT, err error, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NoErrorf(t, err, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NoFileExists checks whether a file does not exist in a given path. It fails
+// if the path points to an existing _file_ only.
+func NoFileExists(t TestingT, path string, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NoFileExists(t, path, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NoFileExistsf checks whether a file does not exist in a given path. It fails
+// if the path points to an existing _file_ only.
+func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NoFileExistsf(t, path, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//	assert.NotContains(t, "Hello World", "Earth")
+//	assert.NotContains(t, ["Hello", "World"], "Earth")
+//	assert.NotContains(t, {"Hello": "World"}, "Earth")
+func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotContains(t, s, contains, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//	assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
+//	assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
+//	assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
+func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotContainsf(t, s, contains, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	if assert.NotEmpty(t, obj) {
+//	  assert.Equal(t, "two", obj[1])
+//	}
+func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotEmpty(t, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
+//	  assert.Equal(t, "two", obj[1])
+//	}
+func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotEmptyf(t, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//	assert.NotEqual(t, obj1, obj2)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotEqual(t, expected, actual, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotEqualValues asserts that two objects are not equal even when converted to the same type
+//
+//	assert.NotEqualValues(t, obj1, obj2)
+func NotEqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotEqualValues(t, expected, actual, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
+//
+//	assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
+func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotEqualValuesf(t, expected, actual, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotEqualf asserts that the specified values are NOT equal.
+//
+//	assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotEqualf(t, expected, actual, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotErrorIs asserts that at none of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func NotErrorIs(t TestingT, err error, target error, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotErrorIs(t, err, target, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotErrorIsf asserts that at none of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotErrorIsf(t, err, target, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotImplements asserts that an object does not implement the specified interface.
+//
+//	assert.NotImplements(t, (*MyInterface)(nil), new(MyObject))
+func NotImplements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotImplements(t, interfaceObject, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotImplementsf asserts that an object does not implement the specified interface.
+//
+//	assert.NotImplementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func NotImplementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotImplementsf(t, interfaceObject, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+//	assert.NotNil(t, err)
+func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotNil(t, object, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotNilf asserts that the specified object is not nil.
+//
+//	assert.NotNilf(t, err, "error message %s", "formatted")
+func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotNilf(t, object, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//	assert.NotPanics(t, func(){ RemainCalm() })
+func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotPanics(t, f, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//	assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
+func NotPanicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotPanicsf(t, f, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+//	assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+//	assert.NotRegexp(t, "^start", "it's not starting")
+func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotRegexp(t, rx, str, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotRegexpf asserts that a specified regexp does not match a string.
+//
+//	assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
+//	assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
+func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotRegexpf(t, rx, str, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotSame asserts that two pointers do not reference the same object.
+//
+//	assert.NotSame(t, ptr1, ptr2)
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func NotSame(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotSame(t, expected, actual, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotSamef asserts that two pointers do not reference the same object.
+//
+//	assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotSamef(t, expected, actual, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotSubset asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
+//
+//	assert.NotSubset(t, [1, 3, 4], [1, 2])
+//	assert.NotSubset(t, {"x": 1, "y": 2}, {"z": 3})
+func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotSubset(t, list, subset, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
+//
+//	assert.NotSubsetf(t, [1, 3, 4], [1, 2], "error message %s", "formatted")
+//	assert.NotSubsetf(t, {"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
+func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotSubsetf(t, list, subset, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotZero asserts that i is not the zero value for its type.
+func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotZero(t, i, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// NotZerof asserts that i is not the zero value for its type.
+func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.NotZerof(t, i, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+//	assert.Panics(t, func(){ GoCrazy() })
+func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Panics(t, f, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// PanicsWithError asserts that the code inside the specified PanicTestFunc
+// panics, and that the recovered panic value is an error that satisfies the
+// EqualError comparison.
+//
+//	assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
+func PanicsWithError(t TestingT, errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.PanicsWithError(t, errString, f, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
+// panics, and that the recovered panic value is an error that satisfies the
+// EqualError comparison.
+//
+//	assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+func PanicsWithErrorf(t TestingT, errString string, f assert.PanicTestFunc, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.PanicsWithErrorf(t, errString, f, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//	assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
+func PanicsWithValue(t TestingT, expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.PanicsWithValue(t, expected, f, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//	assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+func PanicsWithValuef(t TestingT, expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.PanicsWithValuef(t, expected, f, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Panicsf asserts that the code inside the specified PanicTestFunc panics.
+//
+//	assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
+func Panicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Panicsf(t, f, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Positive asserts that the specified element is positive
+//
+//	assert.Positive(t, 1)
+//	assert.Positive(t, 1.23)
+func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Positive(t, e, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Positivef asserts that the specified element is positive
+//
+//	assert.Positivef(t, 1, "error message %s", "formatted")
+//	assert.Positivef(t, 1.23, "error message %s", "formatted")
+func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Positivef(t, e, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+//	assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+//	assert.Regexp(t, "start...$", "it's not starting")
+func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Regexp(t, rx, str, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Regexpf asserts that a specified regexp matches a string.
+//
+//	assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
+//	assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
+func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Regexpf(t, rx, str, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Same asserts that two pointers reference the same object.
+//
+//	assert.Same(t, ptr1, ptr2)
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func Same(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Same(t, expected, actual, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Samef asserts that two pointers reference the same object.
+//
+//	assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func Samef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Samef(t, expected, actual, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Subset asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
+//
+//	assert.Subset(t, [1, 2, 3], [1, 2])
+//	assert.Subset(t, {"x": 1, "y": 2}, {"x": 1})
+func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Subset(t, list, subset, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Subsetf asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
+//
+//	assert.Subsetf(t, [1, 2, 3], [1, 2], "error message %s", "formatted")
+//	assert.Subsetf(t, {"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
+func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Subsetf(t, list, subset, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// True asserts that the specified value is true.
+//
+//	assert.True(t, myBool)
+func True(t TestingT, value bool, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.True(t, value, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Truef asserts that the specified value is true.
+//
+//	assert.Truef(t, myBool, "error message %s", "formatted")
+func Truef(t TestingT, value bool, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Truef(t, value, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+//	assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
+func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.WithinDuration(t, expected, actual, delta, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// WithinDurationf asserts that the two times are within duration delta of each other.
+//
+//	assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.WithinDurationf(t, expected, actual, delta, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// WithinRange asserts that a time is within a time range (inclusive).
+//
+//	assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
+func WithinRange(t TestingT, actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.WithinRange(t, actual, start, end, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// WithinRangef asserts that a time is within a time range (inclusive).
+//
+//	assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
+func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.WithinRangef(t, actual, start, end, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Zero asserts that i is the zero value for its type.
+func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Zero(t, i, msgAndArgs...) {
+		return
+	}
+	t.FailNow()
+}
+
+// Zerof asserts that i is the zero value for its type.
+func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	if assert.Zerof(t, i, msg, args...) {
+		return
+	}
+	t.FailNow()
+}
diff --git a/internal/testify/require/require.go.tmpl b/internal/testify/require/require.go.tmpl
new file mode 100644
index 000000000..55e42ddeb
--- /dev/null
+++ b/internal/testify/require/require.go.tmpl
@@ -0,0 +1,6 @@
+{{.Comment}}
+func {{.DocInfo.Name}}(t TestingT, {{.Params}}) {
+	if h, ok := t.(tHelper); ok { h.Helper() }
+	if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return }
+	t.FailNow()
+}
diff --git a/internal/testify/require/require_forward.go b/internal/testify/require/require_forward.go
new file mode 100644
index 000000000..4cf7154f6
--- /dev/null
+++ b/internal/testify/require/require_forward.go
@@ -0,0 +1,1607 @@
+// Code generated with github.com/expr-lang/expr/internal/_codegen; DO NOT EDIT.
+
+package require
+
+import (
+	http "net/http"
+	url "net/url"
+	time "time"
+
+	assert "github.com/expr-lang/expr/internal/testify/assert"
+)
+
+// Condition uses a Comparison to assert a complex condition.
+func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Condition(a.t, comp, msgAndArgs...)
+}
+
+// Conditionf uses a Comparison to assert a complex condition.
+func (a *Assertions) Conditionf(comp assert.Comparison, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Conditionf(a.t, comp, msg, args...)
+}
+
+// Contains asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//	a.Contains("Hello World", "World")
+//	a.Contains(["Hello", "World"], "World")
+//	a.Contains({"Hello": "World"}, "Hello")
+func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Contains(a.t, s, contains, msgAndArgs...)
+}
+
+// Containsf asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//	a.Containsf("Hello World", "World", "error message %s", "formatted")
+//	a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
+//	a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
+func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Containsf(a.t, s, contains, msg, args...)
+}
+
+// DirExists checks whether a directory exists in the given path. It also fails
+// if the path is a file rather a directory or there is an error checking whether it exists.
+func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	DirExists(a.t, path, msgAndArgs...)
+}
+
+// DirExistsf checks whether a directory exists in the given path. It also fails
+// if the path is a file rather a directory or there is an error checking whether it exists.
+func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	DirExistsf(a.t, path, msg, args...)
+}
+
+// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
+// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
+// the number of appearances of each of them in both lists should match.
+//
+// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2])
+func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	ElementsMatch(a.t, listA, listB, msgAndArgs...)
+}
+
+// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
+// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
+// the number of appearances of each of them in both lists should match.
+//
+// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
+func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	ElementsMatchf(a.t, listA, listB, msg, args...)
+}
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	a.Empty(obj)
+func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Empty(a.t, object, msgAndArgs...)
+}
+
+// Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	a.Emptyf(obj, "error message %s", "formatted")
+func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Emptyf(a.t, object, msg, args...)
+}
+
+// Equal asserts that two objects are equal.
+//
+//	a.Equal(123, 123)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Equal(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//	actualObj, err := SomeFunction()
+//	a.EqualError(err,  expectedErrorString)
+func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	EqualError(a.t, theError, errString, msgAndArgs...)
+}
+
+// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//	actualObj, err := SomeFunction()
+//	a.EqualErrorf(err,  expectedErrorString, "error message %s", "formatted")
+func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	EqualErrorf(a.t, theError, errString, msg, args...)
+}
+
+// EqualExportedValues asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+//	 type S struct {
+//		Exported     	int
+//		notExported   	int
+//	 }
+//	 a.EqualExportedValues(S{1, 2}, S{1, 3}) => true
+//	 a.EqualExportedValues(S{1, 2}, S{2, 3}) => false
+func (a *Assertions) EqualExportedValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	EqualExportedValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualExportedValuesf asserts that the types of two objects are equal and their public
+// fields are also equal. This is useful for comparing structs that have private fields
+// that could potentially differ.
+//
+//	 type S struct {
+//		Exported     	int
+//		notExported   	int
+//	 }
+//	 a.EqualExportedValuesf(S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
+//	 a.EqualExportedValuesf(S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
+func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	EqualExportedValuesf(a.t, expected, actual, msg, args...)
+}
+
+// EqualValues asserts that two objects are equal or convertible to the same types
+// and equal.
+//
+//	a.EqualValues(uint32(123), int32(123))
+func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	EqualValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualValuesf asserts that two objects are equal or convertible to the same types
+// and equal.
+//
+//	a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
+func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	EqualValuesf(a.t, expected, actual, msg, args...)
+}
+
+// Equalf asserts that two objects are equal.
+//
+//	a.Equalf(123, 123, "error message %s", "formatted")
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Equalf(a.t, expected, actual, msg, args...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if a.Error(err) {
+//		   assert.Equal(t, expectedError, err)
+//	  }
+func (a *Assertions) Error(err error, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Error(a.t, err, msgAndArgs...)
+}
+
+// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
+// This is a wrapper for errors.As.
+func (a *Assertions) ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	ErrorAs(a.t, err, target, msgAndArgs...)
+}
+
+// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
+// This is a wrapper for errors.As.
+func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	ErrorAsf(a.t, err, target, msg, args...)
+}
+
+// ErrorContains asserts that a function returned an error (i.e. not `nil`)
+// and that the error contains the specified substring.
+//
+//	actualObj, err := SomeFunction()
+//	a.ErrorContains(err,  expectedErrorSubString)
+func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	ErrorContains(a.t, theError, contains, msgAndArgs...)
+}
+
+// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
+// and that the error contains the specified substring.
+//
+//	actualObj, err := SomeFunction()
+//	a.ErrorContainsf(err,  expectedErrorSubString, "error message %s", "formatted")
+func (a *Assertions) ErrorContainsf(theError error, contains string, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	ErrorContainsf(a.t, theError, contains, msg, args...)
+}
+
+// ErrorIs asserts that at least one of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func (a *Assertions) ErrorIs(err error, target error, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	ErrorIs(a.t, err, target, msgAndArgs...)
+}
+
+// ErrorIsf asserts that at least one of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	ErrorIsf(a.t, err, target, msg, args...)
+}
+
+// Errorf asserts that a function returned an error (i.e. not `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if a.Errorf(err, "error message %s", "formatted") {
+//		   assert.Equal(t, expectedErrorf, err)
+//	  }
+func (a *Assertions) Errorf(err error, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Errorf(a.t, err, msg, args...)
+}
+
+// Eventually asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick.
+//
+//	a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
+func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
+}
+
+// EventuallyWithT asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+//	externalValue := false
+//	go func() {
+//		time.Sleep(8*time.Second)
+//		externalValue = true
+//	}()
+//	a.EventuallyWithT(func(c *assert.CollectT) {
+//		// add assertions as needed; any assertion failure will fail the current tick
+//		assert.True(c, externalValue, "expected 'externalValue' to be true")
+//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+func (a *Assertions) EventuallyWithT(condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	EventuallyWithT(a.t, condition, waitFor, tick, msgAndArgs...)
+}
+
+// EventuallyWithTf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick. In contrast to Eventually,
+// it supplies a CollectT to the condition function, so that the condition
+// function can use the CollectT to call other assertions.
+// The condition is considered "met" if no errors are raised in a tick.
+// The supplied CollectT collects all errors from one tick (if there are any).
+// If the condition is not met before waitFor, the collected errors of
+// the last tick are copied to t.
+//
+//	externalValue := false
+//	go func() {
+//		time.Sleep(8*time.Second)
+//		externalValue = true
+//	}()
+//	a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
+//		// add assertions as needed; any assertion failure will fail the current tick
+//		assert.True(c, externalValue, "expected 'externalValue' to be true")
+//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+func (a *Assertions) EventuallyWithTf(condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	EventuallyWithTf(a.t, condition, waitFor, tick, msg, args...)
+}
+
+// Eventuallyf asserts that given condition will be met in waitFor time,
+// periodically checking target function each tick.
+//
+//	a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Eventuallyf(a.t, condition, waitFor, tick, msg, args...)
+}
+
+// Exactly asserts that two objects are equal in value and type.
+//
+//	a.Exactly(int32(123), int64(123))
+func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Exactly(a.t, expected, actual, msgAndArgs...)
+}
+
+// Exactlyf asserts that two objects are equal in value and type.
+//
+//	a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
+func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Exactlyf(a.t, expected, actual, msg, args...)
+}
+
+// Fail reports a failure through
+func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Fail(a.t, failureMessage, msgAndArgs...)
+}
+
+// FailNow fails test
+func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	FailNow(a.t, failureMessage, msgAndArgs...)
+}
+
+// FailNowf fails test
+func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	FailNowf(a.t, failureMessage, msg, args...)
+}
+
+// Failf reports a failure through
+func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Failf(a.t, failureMessage, msg, args...)
+}
+
+// False asserts that the specified value is false.
+//
+//	a.False(myBool)
+func (a *Assertions) False(value bool, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	False(a.t, value, msgAndArgs...)
+}
+
+// Falsef asserts that the specified value is false.
+//
+//	a.Falsef(myBool, "error message %s", "formatted")
+func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Falsef(a.t, value, msg, args...)
+}
+
+// FileExists checks whether a file exists in the given path. It also fails if
+// the path points to a directory or there is an error when trying to check the file.
+func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	FileExists(a.t, path, msgAndArgs...)
+}
+
+// FileExistsf checks whether a file exists in the given path. It also fails if
+// the path points to a directory or there is an error when trying to check the file.
+func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	FileExistsf(a.t, path, msg, args...)
+}
+
+// Greater asserts that the first element is greater than the second
+//
+//	a.Greater(2, 1)
+//	a.Greater(float64(2), float64(1))
+//	a.Greater("b", "a")
+func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Greater(a.t, e1, e2, msgAndArgs...)
+}
+
+// GreaterOrEqual asserts that the first element is greater than or equal to the second
+//
+//	a.GreaterOrEqual(2, 1)
+//	a.GreaterOrEqual(2, 2)
+//	a.GreaterOrEqual("b", "a")
+//	a.GreaterOrEqual("b", "b")
+func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	GreaterOrEqual(a.t, e1, e2, msgAndArgs...)
+}
+
+// GreaterOrEqualf asserts that the first element is greater than or equal to the second
+//
+//	a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
+//	a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
+//	a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
+//	a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
+func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	GreaterOrEqualf(a.t, e1, e2, msg, args...)
+}
+
+// Greaterf asserts that the first element is greater than the second
+//
+//	a.Greaterf(2, 1, "error message %s", "formatted")
+//	a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
+//	a.Greaterf("b", "a", "error message %s", "formatted")
+func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Greaterf(a.t, e1, e2, msg, args...)
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//	a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...)
+}
+
+// HTTPBodyContainsf asserts that a specified handler returns a
+// body that contains a string.
+//
+//	a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...)
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//	a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...)
+}
+
+// HTTPBodyNotContainsf asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//	a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...)
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//	a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPError(a.t, handler, method, url, values, msgAndArgs...)
+}
+
+// HTTPErrorf asserts that a specified handler returns an error status code.
+//
+//	a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPErrorf(a.t, handler, method, url, values, msg, args...)
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//	a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...)
+}
+
+// HTTPRedirectf asserts that a specified handler returns a redirect status code.
+//
+//	a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPRedirectf(a.t, handler, method, url, values, msg, args...)
+}
+
+// HTTPStatusCode asserts that a specified handler returns a specified status code.
+//
+//	a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPStatusCode(a.t, handler, method, url, values, statuscode, msgAndArgs...)
+}
+
+// HTTPStatusCodef asserts that a specified handler returns a specified status code.
+//
+//	a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPStatusCodef(a.t, handler, method, url, values, statuscode, msg, args...)
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//	a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...)
+}
+
+// HTTPSuccessf asserts that a specified handler returns a success status code.
+//
+//	a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	HTTPSuccessf(a.t, handler, method, url, values, msg, args...)
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+//	a.Implements((*MyInterface)(nil), new(MyObject))
+func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Implements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// Implementsf asserts that an object is implemented by the specified interface.
+//
+//	a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Implementsf(a.t, interfaceObject, object, msg, args...)
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+//	a.InDelta(math.Pi, 22/7.0, 0.01)
+func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InDelta(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
+func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
+func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...)
+}
+
+// InDeltaSlice is the same as InDelta, except it compares two slices.
+func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDeltaSlicef is the same as InDelta, except it compares two slices.
+func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InDeltaSlicef(a.t, expected, actual, delta, msg, args...)
+}
+
+// InDeltaf asserts that the two numerals are within delta of each other.
+//
+//	a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
+func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InDeltaf(a.t, expected, actual, delta, msg, args...)
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
+func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
+func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...)
+}
+
+// InEpsilonf asserts that expected and actual have a relative error less than epsilon
+func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	InEpsilonf(a.t, expected, actual, epsilon, msg, args...)
+}
+
+// IsDecreasing asserts that the collection is decreasing
+//
+//	a.IsDecreasing([]int{2, 1, 0})
+//	a.IsDecreasing([]float{2, 1})
+//	a.IsDecreasing([]string{"b", "a"})
+func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsDecreasing(a.t, object, msgAndArgs...)
+}
+
+// IsDecreasingf asserts that the collection is decreasing
+//
+//	a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
+//	a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
+//	a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
+func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsDecreasingf(a.t, object, msg, args...)
+}
+
+// IsIncreasing asserts that the collection is increasing
+//
+//	a.IsIncreasing([]int{1, 2, 3})
+//	a.IsIncreasing([]float{1, 2})
+//	a.IsIncreasing([]string{"a", "b"})
+func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsIncreasing(a.t, object, msgAndArgs...)
+}
+
+// IsIncreasingf asserts that the collection is increasing
+//
+//	a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
+//	a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
+//	a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
+func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsIncreasingf(a.t, object, msg, args...)
+}
+
+// IsNonDecreasing asserts that the collection is not decreasing
+//
+//	a.IsNonDecreasing([]int{1, 1, 2})
+//	a.IsNonDecreasing([]float{1, 2})
+//	a.IsNonDecreasing([]string{"a", "b"})
+func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsNonDecreasing(a.t, object, msgAndArgs...)
+}
+
+// IsNonDecreasingf asserts that the collection is not decreasing
+//
+//	a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
+//	a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
+//	a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
+func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsNonDecreasingf(a.t, object, msg, args...)
+}
+
+// IsNonIncreasing asserts that the collection is not increasing
+//
+//	a.IsNonIncreasing([]int{2, 1, 1})
+//	a.IsNonIncreasing([]float{2, 1})
+//	a.IsNonIncreasing([]string{"b", "a"})
+func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsNonIncreasing(a.t, object, msgAndArgs...)
+}
+
+// IsNonIncreasingf asserts that the collection is not increasing
+//
+//	a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
+//	a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
+//	a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
+func (a *Assertions) IsNonIncreasingf(object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsNonIncreasingf(a.t, object, msg, args...)
+}
+
+// IsType asserts that the specified objects are of the same type.
+func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsType(a.t, expectedType, object, msgAndArgs...)
+}
+
+// IsTypef asserts that the specified objects are of the same type.
+func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	IsTypef(a.t, expectedType, object, msg, args...)
+}
+
+// JSONEq asserts that two JSON strings are equivalent.
+//
+//	a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	JSONEq(a.t, expected, actual, msgAndArgs...)
+}
+
+// JSONEqf asserts that two JSON strings are equivalent.
+//
+//	a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	JSONEqf(a.t, expected, actual, msg, args...)
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+//	a.Len(mySlice, 3)
+func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Len(a.t, object, length, msgAndArgs...)
+}
+
+// Lenf asserts that the specified object has specific length.
+// Lenf also fails if the object has a type that len() not accept.
+//
+//	a.Lenf(mySlice, 3, "error message %s", "formatted")
+func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Lenf(a.t, object, length, msg, args...)
+}
+
+// Less asserts that the first element is less than the second
+//
+//	a.Less(1, 2)
+//	a.Less(float64(1), float64(2))
+//	a.Less("a", "b")
+func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Less(a.t, e1, e2, msgAndArgs...)
+}
+
+// LessOrEqual asserts that the first element is less than or equal to the second
+//
+//	a.LessOrEqual(1, 2)
+//	a.LessOrEqual(2, 2)
+//	a.LessOrEqual("a", "b")
+//	a.LessOrEqual("b", "b")
+func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	LessOrEqual(a.t, e1, e2, msgAndArgs...)
+}
+
+// LessOrEqualf asserts that the first element is less than or equal to the second
+//
+//	a.LessOrEqualf(1, 2, "error message %s", "formatted")
+//	a.LessOrEqualf(2, 2, "error message %s", "formatted")
+//	a.LessOrEqualf("a", "b", "error message %s", "formatted")
+//	a.LessOrEqualf("b", "b", "error message %s", "formatted")
+func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	LessOrEqualf(a.t, e1, e2, msg, args...)
+}
+
+// Lessf asserts that the first element is less than the second
+//
+//	a.Lessf(1, 2, "error message %s", "formatted")
+//	a.Lessf(float64(1), float64(2), "error message %s", "formatted")
+//	a.Lessf("a", "b", "error message %s", "formatted")
+func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Lessf(a.t, e1, e2, msg, args...)
+}
+
+// Negative asserts that the specified element is negative
+//
+//	a.Negative(-1)
+//	a.Negative(-1.23)
+func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Negative(a.t, e, msgAndArgs...)
+}
+
+// Negativef asserts that the specified element is negative
+//
+//	a.Negativef(-1, "error message %s", "formatted")
+//	a.Negativef(-1.23, "error message %s", "formatted")
+func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Negativef(a.t, e, msg, args...)
+}
+
+// Never asserts that the given condition doesn't satisfy in waitFor time,
+// periodically checking the target function each tick.
+//
+//	a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
+func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Never(a.t, condition, waitFor, tick, msgAndArgs...)
+}
+
+// Neverf asserts that the given condition doesn't satisfy in waitFor time,
+// periodically checking the target function each tick.
+//
+//	a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Neverf(a.t, condition, waitFor, tick, msg, args...)
+}
+
+// Nil asserts that the specified object is nil.
+//
+//	a.Nil(err)
+func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Nil(a.t, object, msgAndArgs...)
+}
+
+// Nilf asserts that the specified object is nil.
+//
+//	a.Nilf(err, "error message %s", "formatted")
+func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Nilf(a.t, object, msg, args...)
+}
+
+// NoDirExists checks whether a directory does not exist in the given path.
+// It fails if the path points to an existing _directory_ only.
+func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NoDirExists(a.t, path, msgAndArgs...)
+}
+
+// NoDirExistsf checks whether a directory does not exist in the given path.
+// It fails if the path points to an existing _directory_ only.
+func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NoDirExistsf(a.t, path, msg, args...)
+}
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if a.NoError(err) {
+//		   assert.Equal(t, expectedObj, actualObj)
+//	  }
+func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NoError(a.t, err, msgAndArgs...)
+}
+
+// NoErrorf asserts that a function returned no error (i.e. `nil`).
+//
+//	  actualObj, err := SomeFunction()
+//	  if a.NoErrorf(err, "error message %s", "formatted") {
+//		   assert.Equal(t, expectedObj, actualObj)
+//	  }
+func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NoErrorf(a.t, err, msg, args...)
+}
+
+// NoFileExists checks whether a file does not exist in a given path. It fails
+// if the path points to an existing _file_ only.
+func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NoFileExists(a.t, path, msgAndArgs...)
+}
+
+// NoFileExistsf checks whether a file does not exist in a given path. It fails
+// if the path points to an existing _file_ only.
+func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NoFileExistsf(a.t, path, msg, args...)
+}
+
+// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//	a.NotContains("Hello World", "Earth")
+//	a.NotContains(["Hello", "World"], "Earth")
+//	a.NotContains({"Hello": "World"}, "Earth")
+func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotContains(a.t, s, contains, msgAndArgs...)
+}
+
+// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//	a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
+//	a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
+//	a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
+func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotContainsf(a.t, s, contains, msg, args...)
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	if a.NotEmpty(obj) {
+//	  assert.Equal(t, "two", obj[1])
+//	}
+func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotEmpty(a.t, object, msgAndArgs...)
+}
+
+// NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	if a.NotEmptyf(obj, "error message %s", "formatted") {
+//	  assert.Equal(t, "two", obj[1])
+//	}
+func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotEmptyf(a.t, object, msg, args...)
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//	a.NotEqual(obj1, obj2)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotEqual(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotEqualValues asserts that two objects are not equal even when converted to the same type
+//
+//	a.NotEqualValues(obj1, obj2)
+func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotEqualValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
+//
+//	a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
+func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotEqualValuesf(a.t, expected, actual, msg, args...)
+}
+
+// NotEqualf asserts that the specified values are NOT equal.
+//
+//	a.NotEqualf(obj1, obj2, "error message %s", "formatted")
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotEqualf(a.t, expected, actual, msg, args...)
+}
+
+// NotErrorIs asserts that at none of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotErrorIs(a.t, err, target, msgAndArgs...)
+}
+
+// NotErrorIsf asserts that at none of the errors in err's chain matches target.
+// This is a wrapper for errors.Is.
+func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotErrorIsf(a.t, err, target, msg, args...)
+}
+
+// NotImplements asserts that an object does not implement the specified interface.
+//
+//	a.NotImplements((*MyInterface)(nil), new(MyObject))
+func (a *Assertions) NotImplements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotImplements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// NotImplementsf asserts that an object does not implement the specified interface.
+//
+//	a.NotImplementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func (a *Assertions) NotImplementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotImplementsf(a.t, interfaceObject, object, msg, args...)
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+//	a.NotNil(err)
+func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotNil(a.t, object, msgAndArgs...)
+}
+
+// NotNilf asserts that the specified object is not nil.
+//
+//	a.NotNilf(err, "error message %s", "formatted")
+func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotNilf(a.t, object, msg, args...)
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//	a.NotPanics(func(){ RemainCalm() })
+func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotPanics(a.t, f, msgAndArgs...)
+}
+
+// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//	a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
+func (a *Assertions) NotPanicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotPanicsf(a.t, f, msg, args...)
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+//	a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
+//	a.NotRegexp("^start", "it's not starting")
+func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotRegexp(a.t, rx, str, msgAndArgs...)
+}
+
+// NotRegexpf asserts that a specified regexp does not match a string.
+//
+//	a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
+//	a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
+func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotRegexpf(a.t, rx, str, msg, args...)
+}
+
+// NotSame asserts that two pointers do not reference the same object.
+//
+//	a.NotSame(ptr1, ptr2)
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotSame(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotSamef asserts that two pointers do not reference the same object.
+//
+//	a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotSamef(a.t, expected, actual, msg, args...)
+}
+
+// NotSubset asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
+//
+//	a.NotSubset([1, 3, 4], [1, 2])
+//	a.NotSubset({"x": 1, "y": 2}, {"z": 3})
+func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotSubset(a.t, list, subset, msgAndArgs...)
+}
+
+// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
+//
+//	a.NotSubsetf([1, 3, 4], [1, 2], "error message %s", "formatted")
+//	a.NotSubsetf({"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
+func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotSubsetf(a.t, list, subset, msg, args...)
+}
+
+// NotZero asserts that i is not the zero value for its type.
+func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotZero(a.t, i, msgAndArgs...)
+}
+
+// NotZerof asserts that i is not the zero value for its type.
+func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	NotZerof(a.t, i, msg, args...)
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+//	a.Panics(func(){ GoCrazy() })
+func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Panics(a.t, f, msgAndArgs...)
+}
+
+// PanicsWithError asserts that the code inside the specified PanicTestFunc
+// panics, and that the recovered panic value is an error that satisfies the
+// EqualError comparison.
+//
+//	a.PanicsWithError("crazy error", func(){ GoCrazy() })
+func (a *Assertions) PanicsWithError(errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	PanicsWithError(a.t, errString, f, msgAndArgs...)
+}
+
+// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
+// panics, and that the recovered panic value is an error that satisfies the
+// EqualError comparison.
+//
+//	a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+func (a *Assertions) PanicsWithErrorf(errString string, f assert.PanicTestFunc, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	PanicsWithErrorf(a.t, errString, f, msg, args...)
+}
+
+// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//	a.PanicsWithValue("crazy error", func(){ GoCrazy() })
+func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	PanicsWithValue(a.t, expected, f, msgAndArgs...)
+}
+
+// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//	a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+func (a *Assertions) PanicsWithValuef(expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	PanicsWithValuef(a.t, expected, f, msg, args...)
+}
+
+// Panicsf asserts that the code inside the specified PanicTestFunc panics.
+//
+//	a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
+func (a *Assertions) Panicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Panicsf(a.t, f, msg, args...)
+}
+
+// Positive asserts that the specified element is positive
+//
+//	a.Positive(1)
+//	a.Positive(1.23)
+func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Positive(a.t, e, msgAndArgs...)
+}
+
+// Positivef asserts that the specified element is positive
+//
+//	a.Positivef(1, "error message %s", "formatted")
+//	a.Positivef(1.23, "error message %s", "formatted")
+func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Positivef(a.t, e, msg, args...)
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+//	a.Regexp(regexp.MustCompile("start"), "it's starting")
+//	a.Regexp("start...$", "it's not starting")
+func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Regexp(a.t, rx, str, msgAndArgs...)
+}
+
+// Regexpf asserts that a specified regexp matches a string.
+//
+//	a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
+//	a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
+func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Regexpf(a.t, rx, str, msg, args...)
+}
+
+// Same asserts that two pointers reference the same object.
+//
+//	a.Same(ptr1, ptr2)
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Same(a.t, expected, actual, msgAndArgs...)
+}
+
+// Samef asserts that two pointers reference the same object.
+//
+//	a.Samef(ptr1, ptr2, "error message %s", "formatted")
+//
+// Both arguments must be pointer variables. Pointer variable sameness is
+// determined based on the equality of both type and value.
+func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Samef(a.t, expected, actual, msg, args...)
+}
+
+// Subset asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
+//
+//	a.Subset([1, 2, 3], [1, 2])
+//	a.Subset({"x": 1, "y": 2}, {"x": 1})
+func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Subset(a.t, list, subset, msgAndArgs...)
+}
+
+// Subsetf asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
+//
+//	a.Subsetf([1, 2, 3], [1, 2], "error message %s", "formatted")
+//	a.Subsetf({"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
+func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Subsetf(a.t, list, subset, msg, args...)
+}
+
+// True asserts that the specified value is true.
+//
+//	a.True(myBool)
+func (a *Assertions) True(value bool, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	True(a.t, value, msgAndArgs...)
+}
+
+// Truef asserts that the specified value is true.
+//
+//	a.Truef(myBool, "error message %s", "formatted")
+func (a *Assertions) Truef(value bool, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Truef(a.t, value, msg, args...)
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+//	a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
+func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// WithinDurationf asserts that the two times are within duration delta of each other.
+//
+//	a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	WithinDurationf(a.t, expected, actual, delta, msg, args...)
+}
+
+// WithinRange asserts that a time is within a time range (inclusive).
+//
+//	a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
+func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	WithinRange(a.t, actual, start, end, msgAndArgs...)
+}
+
+// WithinRangef asserts that a time is within a time range (inclusive).
+//
+//	a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
+func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	WithinRangef(a.t, actual, start, end, msg, args...)
+}
+
+// Zero asserts that i is the zero value for its type.
+func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Zero(a.t, i, msgAndArgs...)
+}
+
+// Zerof asserts that i is the zero value for its type.
+func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	Zerof(a.t, i, msg, args...)
+}
diff --git a/internal/testify/require/require_forward.go.tmpl b/internal/testify/require/require_forward.go.tmpl
new file mode 100644
index 000000000..54124df1d
--- /dev/null
+++ b/internal/testify/require/require_forward.go.tmpl
@@ -0,0 +1,5 @@
+{{.CommentWithoutT "a"}}
+func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) {
+	if h, ok := a.t.(tHelper); ok { h.Helper() }
+	{{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
+}
diff --git a/internal/testify/require/requirements.go b/internal/testify/require/requirements.go
new file mode 100644
index 000000000..6b7ce929e
--- /dev/null
+++ b/internal/testify/require/requirements.go
@@ -0,0 +1,29 @@
+package require
+
+// TestingT is an interface wrapper around *testing.T
+type TestingT interface {
+	Errorf(format string, args ...interface{})
+	FailNow()
+}
+
+type tHelper = interface {
+	Helper()
+}
+
+// ComparisonAssertionFunc is a common function prototype when comparing two values.  Can be useful
+// for table driven tests.
+type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{})
+
+// ValueAssertionFunc is a common function prototype when validating a single value.  Can be useful
+// for table driven tests.
+type ValueAssertionFunc func(TestingT, interface{}, ...interface{})
+
+// BoolAssertionFunc is a common function prototype when validating a bool value.  Can be useful
+// for table driven tests.
+type BoolAssertionFunc func(TestingT, bool, ...interface{})
+
+// ErrorAssertionFunc is a common function prototype when validating an error value.  Can be useful
+// for table driven tests.
+type ErrorAssertionFunc func(TestingT, error, ...interface{})
+
+//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require.go.tmpl -include-format-funcs"
diff --git a/internal/testify/require/requirements_test.go b/internal/testify/require/requirements_test.go
new file mode 100644
index 000000000..1f6eff463
--- /dev/null
+++ b/internal/testify/require/requirements_test.go
@@ -0,0 +1,578 @@
+package require
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+	"time"
+)
+
+// AssertionTesterInterface defines an interface to be used for testing assertion methods
+type AssertionTesterInterface interface {
+	TestMethod()
+}
+
+// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface
+type AssertionTesterConformingObject struct {
+}
+
+func (a *AssertionTesterConformingObject) TestMethod() {
+}
+
+// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface
+type AssertionTesterNonConformingObject struct {
+}
+
+type MockT struct {
+	Failed bool
+}
+
+func (t *MockT) FailNow() {
+	t.Failed = true
+}
+
+func (t *MockT) Errorf(format string, args ...interface{}) {
+	_, _ = format, args
+}
+
+func TestImplements(t *testing.T) {
+
+	Implements(t, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject))
+
+	mockT := new(MockT)
+	Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject))
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestIsType(t *testing.T) {
+
+	IsType(t, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject))
+
+	mockT := new(MockT)
+	IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject))
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestEqual(t *testing.T) {
+
+	Equal(t, 1, 1)
+
+	mockT := new(MockT)
+	Equal(mockT, 1, 2)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+
+}
+
+func TestNotEqual(t *testing.T) {
+
+	NotEqual(t, 1, 2)
+	mockT := new(MockT)
+	NotEqual(mockT, 2, 2)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestExactly(t *testing.T) {
+
+	a := float32(1)
+	b := float32(1)
+	c := float64(1)
+
+	Exactly(t, a, b)
+
+	mockT := new(MockT)
+	Exactly(mockT, a, c)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotNil(t *testing.T) {
+
+	NotNil(t, new(AssertionTesterConformingObject))
+
+	mockT := new(MockT)
+	NotNil(mockT, nil)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNil(t *testing.T) {
+
+	Nil(t, nil)
+
+	mockT := new(MockT)
+	Nil(mockT, new(AssertionTesterConformingObject))
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestTrue(t *testing.T) {
+
+	True(t, true)
+
+	mockT := new(MockT)
+	True(mockT, false)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestFalse(t *testing.T) {
+
+	False(t, false)
+
+	mockT := new(MockT)
+	False(mockT, true)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestContains(t *testing.T) {
+
+	Contains(t, "Hello World", "Hello")
+
+	mockT := new(MockT)
+	Contains(mockT, "Hello World", "Salut")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotContains(t *testing.T) {
+
+	NotContains(t, "Hello World", "Hello!")
+
+	mockT := new(MockT)
+	NotContains(mockT, "Hello World", "Hello")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestPanics(t *testing.T) {
+
+	Panics(t, func() {
+		panic("Panic!")
+	})
+
+	mockT := new(MockT)
+	Panics(mockT, func() {})
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotPanics(t *testing.T) {
+
+	NotPanics(t, func() {})
+
+	mockT := new(MockT)
+	NotPanics(mockT, func() {
+		panic("Panic!")
+	})
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNoError(t *testing.T) {
+
+	NoError(t, nil)
+
+	mockT := new(MockT)
+	NoError(mockT, errors.New("some error"))
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestError(t *testing.T) {
+
+	Error(t, errors.New("some error"))
+
+	mockT := new(MockT)
+	Error(mockT, nil)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestErrorContains(t *testing.T) {
+
+	ErrorContains(t, errors.New("some error: another error"), "some error")
+
+	mockT := new(MockT)
+	ErrorContains(mockT, errors.New("some error"), "different error")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestEqualError(t *testing.T) {
+
+	EqualError(t, errors.New("some error"), "some error")
+
+	mockT := new(MockT)
+	EqualError(mockT, errors.New("some error"), "Not some error")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestEmpty(t *testing.T) {
+
+	Empty(t, "")
+
+	mockT := new(MockT)
+	Empty(mockT, "x")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotEmpty(t *testing.T) {
+
+	NotEmpty(t, "x")
+
+	mockT := new(MockT)
+	NotEmpty(mockT, "")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestWithinDuration(t *testing.T) {
+
+	a := time.Now()
+	b := a.Add(10 * time.Second)
+
+	WithinDuration(t, a, b, 15*time.Second)
+
+	mockT := new(MockT)
+	WithinDuration(mockT, a, b, 5*time.Second)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestInDelta(t *testing.T) {
+
+	InDelta(t, 1.001, 1, 0.01)
+
+	mockT := new(MockT)
+	InDelta(mockT, 1, 2, 0.5)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestZero(t *testing.T) {
+
+	Zero(t, "")
+
+	mockT := new(MockT)
+	Zero(mockT, "x")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestNotZero(t *testing.T) {
+
+	NotZero(t, "x")
+
+	mockT := new(MockT)
+	NotZero(mockT, "")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEq_EqualSONString(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)
+	if mockT.Failed {
+		t.Error("Check should pass")
+	}
+}
+
+func TestJSONEq_EquivalentButNotEqual(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+	if mockT.Failed {
+		t.Error("Check should pass")
+	}
+}
+
+func TestJSONEq_HashOfArraysAndHashes(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
+		"{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}")
+	if mockT.Failed {
+		t.Error("Check should pass")
+	}
+}
+
+func TestJSONEq_Array(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)
+	if mockT.Failed {
+		t.Error("Check should pass")
+	}
+}
+
+func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEq_HashesNotEquivalent(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEq_ActualIsNotJSON(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, `{"foo": "bar"}`, "Not JSON")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEq_ExpectedIsNotJSON(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, "Not JSON", "Not JSON")
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) {
+	mockT := new(MockT)
+	JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)
+	if !mockT.Failed {
+		t.Error("Check should fail")
+	}
+}
+
+func ExampleComparisonAssertionFunc() {
+	t := &testing.T{} // provided by test
+
+	adder := func(x, y int) int {
+		return x + y
+	}
+
+	type args struct {
+		x int
+		y int
+	}
+
+	tests := []struct {
+		name      string
+		args      args
+		expect    int
+		assertion ComparisonAssertionFunc
+	}{
+		{"2+2=4", args{2, 2}, 4, Equal},
+		{"2+2!=5", args{2, 2}, 5, NotEqual},
+		{"2+3==5", args{2, 3}, 5, Exactly},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y))
+		})
+	}
+}
+
+func TestComparisonAssertionFunc(t *testing.T) {
+	type iface interface {
+		Name() string
+	}
+
+	tests := []struct {
+		name      string
+		expect    interface{}
+		got       interface{}
+		assertion ComparisonAssertionFunc
+	}{
+		{"implements", (*iface)(nil), t, Implements},
+		{"isType", (*testing.T)(nil), t, IsType},
+		{"equal", t, t, Equal},
+		{"equalValues", t, t, EqualValues},
+		{"exactly", t, t, Exactly},
+		{"notEqual", t, nil, NotEqual},
+		{"NotEqualValues", t, nil, NotEqualValues},
+		{"notContains", []int{1, 2, 3}, 4, NotContains},
+		{"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset},
+		{"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset},
+		{"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch},
+		{"regexp", "^t.*y$", "testify", Regexp},
+		{"notRegexp", "^t.*y$", "Testify", NotRegexp},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.expect, tt.got)
+		})
+	}
+}
+
+func ExampleValueAssertionFunc() {
+	t := &testing.T{} // provided by test
+
+	dumbParse := func(input string) interface{} {
+		var x interface{}
+		json.Unmarshal([]byte(input), &x)
+		return x
+	}
+
+	tests := []struct {
+		name      string
+		arg       string
+		assertion ValueAssertionFunc
+	}{
+		{"true is not nil", "true", NotNil},
+		{"empty string is nil", "", Nil},
+		{"zero is not nil", "0", NotNil},
+		{"zero is zero", "0", Zero},
+		{"false is zero", "false", Zero},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, dumbParse(tt.arg))
+		})
+	}
+}
+
+func TestValueAssertionFunc(t *testing.T) {
+	tests := []struct {
+		name      string
+		value     interface{}
+		assertion ValueAssertionFunc
+	}{
+		{"notNil", true, NotNil},
+		{"nil", nil, Nil},
+		{"empty", []int{}, Empty},
+		{"notEmpty", []int{1}, NotEmpty},
+		{"zero", false, Zero},
+		{"notZero", 42, NotZero},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.value)
+		})
+	}
+}
+
+func ExampleBoolAssertionFunc() {
+	t := &testing.T{} // provided by test
+
+	isOkay := func(x int) bool {
+		return x >= 42
+	}
+
+	tests := []struct {
+		name      string
+		arg       int
+		assertion BoolAssertionFunc
+	}{
+		{"-1 is bad", -1, False},
+		{"42 is good", 42, True},
+		{"41 is bad", 41, False},
+		{"45 is cool", 45, True},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, isOkay(tt.arg))
+		})
+	}
+}
+
+func TestBoolAssertionFunc(t *testing.T) {
+	tests := []struct {
+		name      string
+		value     bool
+		assertion BoolAssertionFunc
+	}{
+		{"true", true, True},
+		{"false", false, False},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.value)
+		})
+	}
+}
+
+func ExampleErrorAssertionFunc() {
+	t := &testing.T{} // provided by test
+
+	dumbParseNum := func(input string, v interface{}) error {
+		return json.Unmarshal([]byte(input), v)
+	}
+
+	tests := []struct {
+		name      string
+		arg       string
+		assertion ErrorAssertionFunc
+	}{
+		{"1.2 is number", "1.2", NoError},
+		{"1.2.3 not number", "1.2.3", Error},
+		{"true is not number", "true", Error},
+		{"3 is number", "3", NoError},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var x float64
+			tt.assertion(t, dumbParseNum(tt.arg, &x))
+		})
+	}
+}
+
+func TestErrorAssertionFunc(t *testing.T) {
+	tests := []struct {
+		name      string
+		err       error
+		assertion ErrorAssertionFunc
+	}{
+		{"noError", nil, NoError},
+		{"error", errors.New("whoops"), Error},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.assertion(t, tt.err)
+		})
+	}
+}
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 3c7947c09..0ff4b4901 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -6,8 +6,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
diff --git a/optimizer/sum_array_test.go b/optimizer/sum_array_test.go
index 09286c22b..6ff93e350 100644
--- a/optimizer/sum_array_test.go
+++ b/optimizer/sum_array_test.go
@@ -3,8 +3,8 @@ package optimizer_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
diff --git a/optimizer/sum_map_test.go b/optimizer/sum_map_test.go
index 0ce3203e2..96bdcfd35 100644
--- a/optimizer/sum_map_test.go
+++ b/optimizer/sum_map_test.go
@@ -3,8 +3,8 @@ package optimizer_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/optimizer"
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index 442fd4dbd..f30d3ba11 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -5,8 +5,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr/file"
 	. "github.com/expr-lang/expr/parser/lexer"
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 2a30787a0..bb0fc078b 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -5,8 +5,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	. "github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/parser"
diff --git a/patcher/value/bench_test.go b/patcher/value/bench_test.go
index d6a1aae89..f72ed53e0 100644
--- a/patcher/value/bench_test.go
+++ b/patcher/value/bench_test.go
@@ -3,7 +3,7 @@ package value
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/vm"
diff --git a/patcher/value/value_test.go b/patcher/value/value_test.go
index 1b6c5527a..30c8a56ad 100644
--- a/patcher/value/value_test.go
+++ b/patcher/value/value_test.go
@@ -3,7 +3,7 @@ package value
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/vm"
diff --git a/patcher/with_context_test.go b/patcher/with_context_test.go
index 5ce64191f..278705334 100644
--- a/patcher/with_context_test.go
+++ b/patcher/with_context_test.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/patcher"
diff --git a/patcher/with_timezone_test.go b/patcher/with_timezone_test.go
index 2cd099f20..a1adf9bc9 100644
--- a/patcher/with_timezone_test.go
+++ b/patcher/with_timezone_test.go
@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 )
diff --git a/repl/go.mod b/repl/go.mod
index b96e6a3be..cdd4f1b7c 100644
--- a/repl/go.mod
+++ b/repl/go.mod
@@ -3,9 +3,9 @@ module github.com/expr-lang/expr/repl
 go 1.20
 
 require (
+	github.com/bettercap/readline v0.0.0-20210228151553-655e48bcb7bf
 	github.com/expr-lang/expr v1.13.0
 	github.com/expr-lang/expr/debug v0.0.0
-	github.com/bettercap/readline v0.0.0-20210228151553-655e48bcb7bf
 )
 
 require (
diff --git a/repl/go.sum b/repl/go.sum
index b584a8acf..824246de9 100644
--- a/repl/go.sum
+++ b/repl/go.sum
@@ -4,7 +4,6 @@ github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
 github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
 github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=
 github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
 github.com/gdamore/tcell/v2 v2.6.0 h1:OKbluoP9VYmJwZwq/iLb4BxwKcwGthaa1YNBJIyCySg=
@@ -14,14 +13,12 @@ github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i
 github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
 github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703 h1:ZyM/+FYnpbZsFWuCohniM56kRoHRB4r5EuIzXEYkpxo=
 github.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703/go.mod h1:nVwGv4MP47T0jvlk7KuTTjjuSmrGO4JF0iaiNt4bufE=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
@@ -54,4 +51,3 @@ golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/test/coredns/coredns_test.go b/test/coredns/coredns_test.go
index 97eb3768f..980a25e77 100644
--- a/test/coredns/coredns_test.go
+++ b/test/coredns/coredns_test.go
@@ -4,9 +4,10 @@ import (
 	"context"
 	"testing"
 
+	"github.com/expr-lang/expr/internal/testify/assert"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/test/coredns"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestCoreDNS(t *testing.T) {
diff --git a/test/crowdsec/crowdsec_test.go b/test/crowdsec/crowdsec_test.go
index 2ac25871c..0ddb54102 100644
--- a/test/crowdsec/crowdsec_test.go
+++ b/test/crowdsec/crowdsec_test.go
@@ -5,9 +5,10 @@ import (
 	"os"
 	"testing"
 
+	"github.com/expr-lang/expr/internal/testify/require"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/test/crowdsec"
-	"github.com/stretchr/testify/require"
 )
 
 func TestCrowdsec(t *testing.T) {
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 2911e8e26..0b228ca16 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -4,8 +4,8 @@ import (
 	"context"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 )
diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go
index 424974de8..6ac07c4f8 100644
--- a/test/gen/gen_test.go
+++ b/test/gen/gen_test.go
@@ -5,8 +5,9 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/expr-lang/expr/internal/testify/require"
+
 	"github.com/expr-lang/expr"
-	"github.com/stretchr/testify/require"
 )
 
 func TestGenerated(t *testing.T) {
diff --git a/test/interface_method/interface_method_test.go b/test/interface_method/interface_method_test.go
index 51057f7a8..716b390e7 100644
--- a/test/interface_method/interface_method_test.go
+++ b/test/interface_method/interface_method_test.go
@@ -3,8 +3,8 @@ package interface_method_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 )
diff --git a/test/operator/issues584/issues584_test.go b/test/operator/issues584/issues584_test.go
index 13c9c66f3..5ceb2d50c 100644
--- a/test/operator/issues584/issues584_test.go
+++ b/test/operator/issues584/issues584_test.go
@@ -3,7 +3,7 @@ package issues584_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/assert"
 
 	"github.com/expr-lang/expr"
 )
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index b49d91cc6..2ebb176f8 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/test/mock"
diff --git a/test/patch/change_ident_test.go b/test/patch/change_ident_test.go
index 4d23b134a..663ccefab 100644
--- a/test/patch/change_ident_test.go
+++ b/test/patch/change_ident_test.go
@@ -3,7 +3,7 @@ package patch_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
diff --git a/test/patch/patch_test.go b/test/patch/patch_test.go
index 612a63e84..facae7255 100644
--- a/test/patch/patch_test.go
+++ b/test/patch/patch_test.go
@@ -3,10 +3,11 @@ package patch_test
 import (
 	"testing"
 
+	"github.com/expr-lang/expr/internal/testify/require"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/test/mock"
-	"github.com/stretchr/testify/require"
 )
 
 type lengthPatcher struct{}
diff --git a/test/patch/set_type/set_type_test.go b/test/patch/set_type/set_type_test.go
index 673698afb..b9c831b0d 100644
--- a/test/patch/set_type/set_type_test.go
+++ b/test/patch/set_type/set_type_test.go
@@ -4,7 +4,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
diff --git a/test/pipes/pipes_test.go b/test/pipes/pipes_test.go
index da894d507..6c38ba1c0 100644
--- a/test/pipes/pipes_test.go
+++ b/test/pipes/pipes_test.go
@@ -4,8 +4,9 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/expr-lang/expr/internal/testify/require"
+
 	"github.com/expr-lang/expr"
-	"github.com/stretchr/testify/require"
 )
 
 func TestPipes(t *testing.T) {
diff --git a/test/time/time_test.go b/test/time/time_test.go
index 3eeef4a0d..d010679a8 100644
--- a/test/time/time_test.go
+++ b/test/time/time_test.go
@@ -5,13 +5,14 @@ import (
 	"testing"
 	"time"
 
+	"github.com/expr-lang/expr/internal/testify/require"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/checker"
 	"github.com/expr-lang/expr/compiler"
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/parser"
 	"github.com/expr-lang/expr/vm"
-	"github.com/stretchr/testify/require"
 )
 
 func TestTime(t *testing.T) {
diff --git a/vm/debug_test.go b/vm/debug_test.go
index 576960f06..7360e5833 100644
--- a/vm/debug_test.go
+++ b/vm/debug_test.go
@@ -5,7 +5,7 @@ package vm_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr/compiler"
 	"github.com/expr-lang/expr/parser"
diff --git a/vm/runtime/helpers_test.go b/vm/runtime/helpers_test.go
index 42a0aece0..b0ef5340f 100644
--- a/vm/runtime/helpers_test.go
+++ b/vm/runtime/helpers_test.go
@@ -3,8 +3,9 @@ package runtime_test
 import (
 	"testing"
 
+	"github.com/expr-lang/expr/internal/testify/assert"
+
 	"github.com/expr-lang/expr/vm/runtime"
-	"github.com/stretchr/testify/assert"
 )
 
 var tests = []struct {
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 2628b961d..3ed57d75b 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -6,7 +6,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/checker"

From bd688c314e97ecb0586f6783e0bcfde2037d68e8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 8 May 2024 00:25:05 +0200
Subject: [PATCH 325/506] Add go 1.22 to tests

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 087bbc7c4..dc197eb1f 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.19', '1.20', '1.21' ]
+        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22' ]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Go ${{ matrix.go-version }}

From 83d67e7fe596a34802d8b98804030aac50de5a0a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 8 May 2024 10:04:54 +0200
Subject: [PATCH 326/506] Remove implicit date's timezone set on parse

---
 builtin/builtin.go      | 1 -
 builtin/builtin_test.go | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 38a6f2f3f..9687d7e59 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -528,7 +528,6 @@ var Builtins = []*Function{
 				if err != nil {
 					return nil, err
 				}
-				t = t.In(tz)
 				return t, nil
 			}
 
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 334910afb..b7579153c 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -113,7 +113,7 @@ func TestBuiltin(t *testing.T) {
 		{`duration("1h")`, time.Hour},
 		{`date("2006-01-02T15:04:05Z")`, time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)},
 		{`date("2006.01.02", "2006.01.02")`, time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC)},
-		{`date("2023-04-23T00:30:00.000+0100", "2006-01-02T15:04:05-0700", "America/Chicago").Format("2006-01-02")`, "2023-04-22"},
+		{`date("2023-04-23T00:30:00.000+0100", "2006-01-02T15:04:05-0700", "America/Chicago").Format("2006-01-02")`, "2023-04-23"},
 		{`date("2023-04-23T00:30:00", "2006-01-02T15:04:05", "America/Chicago").Format("2006-01-02")`, "2023-04-23"},
 		{`date("2023-04-23", "2006-01-02", "America/Chicago").Format("2006-01-02")`, "2023-04-23"},
 		{`timezone("UTC").String()`, "UTC"},

From 6171d560d7faf0513a2547542d92a9781a594100 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 8 May 2024 22:20:37 +0200
Subject: [PATCH 327/506] Update docs

---
 docs/configuration.md        | 201 ++++++++++++++++-------------------
 docs/environment.md          |  95 +++++++++++++++++
 docs/functions.md            |  86 +++++++++++++++
 docs/getting-started.md      |  90 +++++++++-------
 docs/images/debug.gif        | Bin 3546095 -> 0 bytes
 docs/images/logo-small.png   | Bin 86921 -> 0 bytes
 docs/images/logo.png         | Bin 395487 -> 0 bytes
 docs/internals.md            |  61 -----------
 docs/language-definition.md  |   2 +-
 docs/operator-overloading.md |  52 ---------
 docs/patch.md                | 125 ++++++++++++++++++++++
 docs/tips.md                 |  38 -------
 docs/visitor-and-patch.md    |  98 -----------------
 docs/visitor.md              |  49 +++++++++
 14 files changed, 495 insertions(+), 402 deletions(-)
 create mode 100644 docs/environment.md
 create mode 100644 docs/functions.md
 delete mode 100644 docs/images/debug.gif
 delete mode 100644 docs/images/logo-small.png
 delete mode 100644 docs/images/logo.png
 delete mode 100644 docs/internals.md
 delete mode 100644 docs/operator-overloading.md
 create mode 100644 docs/patch.md
 delete mode 100644 docs/tips.md
 delete mode 100644 docs/visitor-and-patch.md
 create mode 100644 docs/visitor.md

diff --git a/docs/configuration.md b/docs/configuration.md
index a427515e9..511ebd48b 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -1,156 +1,135 @@
 # Configuration
 
-Expr can be configured with options. For example, you can pass the environment with variables and functions.
+## Return type
 
-## AllowUndefinedVariables()
+Usually, the return type of expression is anything. But we can instruct type checker to verify the return type of the
+expression.
+For example, in filter expressions, we expect the return type to be a boolean.
 
-This option allows undefined variables in the expression. By default, Expr will return an error 
-if the expression contains undefined variables.
+```go 
+program, err := expr.Compile(code, expr.AsBool())
+if err != nil {
+panic(err)
+}
 
-```go
-program, err := expr.Compile(`foo + bar`, expr.AllowUndefinedVariables())
-```
+output, err := expr.Run(program, env)
+if err != nil {
+panic(err)
+}
 
-## AsBool()
+ok := output.(bool) // It is safe to assert the output to bool, if the expression is type checked as bool.
+```
 
-This option forces the expression to return a boolean value. If the expression returns a non-boolean value,
-Expr will return an error.
+If `code` variable for example returns a string, the compiler will return an error.
 
-```go
-program, err := expr.Compile(`Title contains "Hello"`, expr.AsBool())
-```
+Expr has a few options to specify the return type:
 
-## AsFloat64()
+- [expr.AsBool()](https://pkg.go.dev/github.com/expr-lang/expr#AsBool) - expects the return type to be a bool.
+- [expr.AsInt()](https://pkg.go.dev/github.com/expr-lang/expr#AsInt) - expects the return type to be an int (float64,
+  uint, int32, and other will be cast to int).
+- [expr.AsInt64()](https://pkg.go.dev/github.com/expr-lang/expr#AsInt64) - expects the return type to be an int64 (
+  float64, uint, int32, and other will be cast to int64).
+- [expr.AsFloat64()](https://pkg.go.dev/github.com/expr-lang/expr#AsFloat64) - expects the return type to be a float64 (
+  float32 will be cast to float64).
+- [expr.AsAny()](https://pkg.go.dev/github.com/expr-lang/expr#AsAny) - expects the return type to be anything.
+- [expr.AsKind(reflect.Kind)](https://pkg.go.dev/github.com/expr-lang/expr#AsKind) - expects the return type to be a
+  specific kind.
 
-This option forces the expression to return a float64 value. If the expression returns a non-float64 value,
-Expr will return an error.
+:::tip Warn on any
+By default, type checker will accept any type, even if the return type is specified. Consider following examples:
 
-```go
-program, err := expr.Compile(`42`, expr.AsFloat64())
+```expr
+let arr = [1, 2, 3]; arr[0]
 ```
 
-:::note
-If the expression returns integer value, Expr will convert it to float64.
-:::
-
-## AsInt()
+The return type of the expression is `any`. Arrays created in Expr are of type `[]any`. The type checker will not return
+an error if the return type is specified as `expr.AsInt()`. The output of the expression is `1`, which is an int, but the
+type checker will not return an error.
 
-This option forces the expression to return an int value. If the expression returns a non-int value,
-Expr will return an error.
+But we can instruct the type checker to warn us if the return type is `any`. Use [`expr.WarnOnAny()`](https://pkg.go.dev/github.com/expr-lang/expr#WarnOnAny) to enable this behavior.
 
 ```go
-program, err := expr.Compile(`42`, expr.AsInt())
+program, err := expr.Compile(code, expr.AsInt(), expr.WarnOnAny())
 ```
 
-:::note
-If the expression returns a float value, Expr truncates it to int.
-:::
-
-## AsInt64()
+The type checker will return an error if the return type is `any`. We need to modify the expression to return a specific
+type.
 
-Same as `AsInt()` but returns an int64 value.
-
-```go
-program, err := expr.Compile(`42`, expr.AsInt64())
+```expr
+let arr = [1, 2, 3]; int(arr[0])
 ```
+:::
 
-## AsKind()
 
-This option forces the expression to return a value of the specified kind. 
-If the expression returns a value of a different kind, Expr will return an error.
+## WithContext
 
-```go
-program, err := expr.Compile(`42`, expr.AsKind(reflect.String))
-```
+Although the compiled program is guaranteed to be terminated, some user defined functions may not be. For example, if a
+user defined function calls a remote service, we may want to pass a context to the function.
 
-## ConstExpr()
+This is possible via the [`WithContext`](https://pkg.go.dev/github.com/expr-lang/expr#WithContext) option.
 
-This option tells Expr to treat specified functions as constant expressions. 
-If all arguments of the function are constants, Expr will replace the function call with the result 
-during the compile step.
+This option will modify function calls to include the context as the first argument (only if the function signature
+accepts a context).
 
-```go
-program, err := expr.Compile(`fib(42)`, expr.ConstExpr("fib"))
+```expr
+customFunc(42)
+// will be transformed to
+customFunc(ctx, 42)
 ```
 
-[ConstExpr Example](https://pkg.go.dev/github.com/expr-lang/expr?tab=doc#ConstExpr)
-
-## Env()
-
-This option passes the environment with variables and functions to the expression.
+Function `expr.WithContext()` takes the name of context variable. The context variable must be defined in the environment.
 
 ```go
-program, err := expr.Compile(`foo + bar`, expr.Env(Env{}))
+env := map[string]any{
+    "ctx": context.Background(),
+}
+
+program, err := expr.Compile(code, expr.Env(env), expr.WithContext("ctx"))
 ```
 
-## Function()
+## ConstExpr
 
-This option adds a function to the expression.
+For some user defined functions, we may want to evaluate the expression at compile time. This is possible via the
+[`ConstExpr`](https://pkg.go.dev/github.com/expr-lang/expr#ConstExpr) option. 
 
 ```go
-	atoi := expr.Function(
-		"atoi",
-		func(params ...any) (any, error) {
-			return strconv.Atoi(params[0].(string))
-		},
-	)
-
-	program, err := expr.Compile(`atoi("42")`, atoi)
+func fib(n int) int {
+    if n <= 1 {
+        return n
+    }
+    return fib(n-1) + fib(n-2)
+}
+
+env := map[string]any{
+    "fib": fib,
+}
+
+program, err := expr.Compile(`fib(10)`, expr.Env(env), expr.ConstExpr("fib"))
 ```
 
-Expr sees the `atoi` function as a function with a variadic number of arguments of type `any` and returns a value of type `any`. But, we can specify the types of arguments and the return value by adding the correct function
-signature or multiple signatures.
+If all arguments of the function are constants, the function will be evaluated at compile time. The result of the function
+will be used as a constant in the expression.
 
-```go
-	atoi := expr.Function(
-		"atoi",
-		func(params ...any) (any, error) {
-			return strconv.Atoi(params[0].(string))
-		},
-		new(func(string) int),
-	)
+```expr
+fib(10)    // will be transformed to 55 during the compilation
+fib(12+12) // will be transformed to 267914296 during the compilation
+fib(x)     // will **not** be transformed and will be evaluated at runtime
 ```
 
-Or we can simply reuse the `strconv.Atoi` function.
-
-```go
-	atoi := expr.Function(
-		"atoi",
-		func(params ...any) (any, error) {
-			return strconv.Atoi(params[0].(string))
-		},
-		strconv.Atoi,
-	)
-```
+## Options
 
-Here is another example with a few function signatures:
+Compiler options can be defined as an array:
 
 ```go
-	toInt := expr.Function(
-		"toInt",
-		func(params ...any) (any, error) {
-			switch params[0].(type) {
-			case float64:
-				return int(params[0].(float64)), nil
-			case string:
-				return strconv.Atoi(params[0].(string))
-			}
-			return nil, fmt.Errorf("invalid type")
-		},
-		new(func(float64) int),
-		new(func(string) int),
-	)
+options := []expr.Option{
+    expr.Env(Env{})
+    expr.AsInt(),
+    expr.WarnOnAny(),
+    expr.WithContext("ctx"),
+    expr.ConstExpr("fib"),
+}
+
+program, err := expr.Compile(code, options...)
 ```
 
-
-## Operator()
-
-This options defines an [operator overloading](operator-overloading).
-
-## Optimize()
-
-This option enables [optimizations](internals.md). By default, Expr will optimize the expression.
-
-## Patch()
-
-This option allows you to [patch the expression](visitor-and-patch) before compilation.
+Full list of available options can be found in the [pkg.go.dev](https://pkg.go.dev/github.com/expr-lang/expr#Option) documentation.
diff --git a/docs/environment.md b/docs/environment.md
new file mode 100644
index 000000000..2ae2f0af6
--- /dev/null
+++ b/docs/environment.md
@@ -0,0 +1,95 @@
+# Environment
+
+The environment is a map or a struct that contains the variables and functions that the expression can access.
+
+## Struct as Environment
+
+Let's consider the following example:
+
+```go
+type Env struct {
+    UpdatedAt time.Time
+    Posts     []Post
+    Map       map[string]string `expr:"tags"`
+}
+```
+
+The `Env` struct contains 3 variables that the expression can access: `UpdatedAt`, `Posts`, and `tags`.
+
+:::info
+The `expr` tag is used to rename the `Map` field to `tags` variable in the expression.
+:::
+
+The `Env` struct can also contain methods. The methods defined on the struct become functions that the expression can
+call.
+
+```go
+func (Env) Format(t time.Time) string {
+    return t.Format(time.RFC822)
+}
+```
+
+:::tip
+Methods defined on embedded structs are also accessible.
+```go
+type Env struct {
+    Helpers
+}
+
+type Helpers struct{}
+
+func (Helpers) Format(t time.Time) string {
+    return t.Format(time.RFC822)
+}
+```
+:::
+
+We can use an empty struct `Env{}` to with [expr.Env](https://pkg.go.dev/github.com/expr-lang/expr#Env) to create an environment. Expr will use reflection to find 
+the fields and methods of the struct.
+
+```go
+program, err := expr.Compile(code, expr.Env(Env{}))
+```
+
+Compiler will type check the expression against the environment. After the compilation, we can run the program with the environment.
+You should use the same type of environment that you passed to the `expr.Env` function.
+
+```go
+output, err := expr.Run(program, Env{
+    UpdatedAt: time.Now(),
+    Posts:     []Post{{Title: "Hello, World!"}},
+    Map:       map[string]string{"tag1": "value1"},
+})
+```
+
+## Map as Environment
+
+You can also use a map as an environment.
+
+```go
+env := map[string]any{
+    "UpdatedAt": time.Time{},
+    "Posts":     []Post{},
+    "tags":      map[string]string{},
+    "sprintf":   fmt.Sprintf,
+}
+
+program, err := expr.Compile(code, expr.Env(env))
+```
+
+A map defines variables and functions that the expression can access. The key is the variable name, and the type
+is the value's type.
+
+```go
+env := map[string]any{
+    "object": map[string]any{
+        "field": 42,
+    }, 
+}
+```
+
+Expr will infer the type of the `object` variable as `map[string]any`.
+
+By default, Expr will return an error if unknown variables are used in the expression.
+
+You can disable this behavior by passing [`AllowUndefinedVariables`](https://pkg.go.dev/github.com/expr-lang/expr#AllowUndefinedVariables) option to the compiler.
diff --git a/docs/functions.md b/docs/functions.md
new file mode 100644
index 000000000..03b5b9641
--- /dev/null
+++ b/docs/functions.md
@@ -0,0 +1,86 @@
+# Functions
+
+Expr comes with a set of [builtin](language-definition.md) functions, but you can also define your own functions.
+
+The easiest way to define a custom function is to add it to the environment.
+
+```go
+env := map[string]any{
+    "add": func(a, b int) int {
+        return a + b
+    },
+}
+```
+
+Or you can use functions defined on a struct:
+
+```go
+type Env struct{}
+
+func (Env) Add(a, b int) int {
+    return a + b
+}
+```
+
+:::info
+If functions are marked with [`ConstExpr`](./configuration.md#constexpr) option, they will be evaluated at compile time.
+:::
+
+The best way to define a function from a performance perspective is to use a [`Function`](https://pkg.go.dev/github.com/expr-lang/expr#Function) option.
+
+```go
+atoi := expr.Function(
+    "atoi",
+    func(params ...any) (any, error) {
+        return strconv.Atoi(params[0].(string))
+    },
+)
+
+program, err := expr.Compile(`atoi("42")`, atoi)
+```
+
+Type checker sees the `atoi` function as a function with a variadic number of arguments of type `any`, and returns 
+a value of type `any`. But, we can specify the types of arguments and the return value by adding the correct function 
+signature or multiple signatures.
+
+```go
+atoi := expr.Function(
+    "atoi",
+    func(params ...any) (any, error) {
+        return strconv.Atoi(params[0].(string))
+    },
+    new(func(string) int),
+)
+```
+
+Or we can simply reuse the strconv.Atoi function as a type:
+
+```go
+atoi := expr.Function(
+    "atoi",
+    func(params ...any) (any, error) {
+        return strconv.Atoi(params[0].(string))
+    },
+    // highlight-next-line
+    strconv.Atoi,
+)
+```
+
+It is possible to define multiple signatures for a function:
+
+```go
+toInt := expr.Function(
+    "toInt",
+    func(params ...any) (any, error) {
+        switch params[0].(type) {
+        case float64:
+            return int(params[0].(float64)), nil
+        case string:
+            return strconv.Atoi(params[0].(string))
+        }
+        return nil, fmt.Errorf("invalid type")
+    },
+    new(func(float64) int),
+    new(func(string) int),
+)
+```
diff --git a/docs/getting-started.md b/docs/getting-started.md
index b6b0e4da9..8ee14fd49 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -26,20 +26,24 @@ fmt.Print(output) // 4
 ```
 
 Expr compiles the expression `2 + 2` into a bytecode program. Then we run
-the program and get the output. The output is `4` as expected.
+the program and get the output.
+
+:::tip
+In performance-critical applications, you can reuse the compiled program. Compiled programs are safe for concurrent use.
+**Compile once** and run **multiple** times.
+:::
+
+The `expr.Compile` function returns a `*vm.Program` and an error. The `expr.Run` function takes a program and an
+environment. The environment is a map of variables that can be used in the expression. In this example, we use `nil` as
+an environment because we don't need any variables.
 
-The `expr.Compile` function returns a `*vm.Program` and an error. The program
-can be reused between runs. The `expr.Run` function takes a program and an
-environment. The environment is a map of variables that can be used in the
-expression. In this example, we use `nil` as an environment because we don't
-need any variables.
 
 Now let's pass some variables to the expression:
 
 ```go
 env := map[string]any{
     "foo": 100,
-	"bar": 200,
+    "bar": 200,
 }
 
 program, err := expr.Compile(`foo + bar`, expr.Env(env))
@@ -56,7 +60,9 @@ fmt.Print(output) // 300
 ```
 
 Why do we need to pass the environment to the `expr.Compile` function? Expr can be used as a type-safe language. 
-Expr can infer the type of the expression and check it against the environment. Here is an example:
+Expr can infer the type of the expression and check it against the environment. 
+
+Here is an example:
 
 ```go
 env := map[string]any{
@@ -70,73 +76,75 @@ if err != nil {
 }
 ```
 
-Expr can work with any Go types. Here is an example:
+Expr can work with any Go types:
 
 ```go
 env := map[string]any{
-	"greet":   "Hello, %v!",
-	"names":   []string{"world", "you"},
-	"sprintf": fmt.Sprintf,
+    "greet":   "Hello, %v!",
+    "names":   []string{"world", "you"},
+    "sprintf": fmt.Sprintf,
 }
 
 code := `sprintf(greet, names[0])`
 
 program, err := expr.Compile(code, expr.Env(env))
 if err != nil {
-	panic(err)
+    panic(err)
 }
 
 output, err := expr.Run(program, env)
 if err != nil {
-	panic(err)
+    panic(err)
 }
 
 fmt.Print(output) // Hello, world!
 ```
 
 Also, Expr can use a struct as an environment. Methods defined on the struct become functions.
-The struct fields can be renamed with the `expr` tag. Here is an example:
+The struct fields can be renamed with the `expr` tag. 
+
+Here is an example:
 
 ```go
 type Env struct {
-	Posts []Post `expr:"posts"`
+    Posts []Post `expr:"posts"`
 }
 
 func (Env) Format(t time.Time) string { 
-	return t.Format(time.RFC822) 
+    return t.Format(time.RFC822) 
 }
 
 type Post struct {
-	Body string
-	Date time.Time
+    Body string
+    Date time.Time
 }
 
 func main() {
-	code := `map(posts, Format(.Date) + ": " + .Body)`
-	
-	program, err := expr.Compile(code, expr.Env(Env{}))
-	if err != nil {
-		panic(err)
-	}
-
-	env := Env{
-		Posts: []Post{
-			{"Oh My God!", time.Now()}, 
-			{"How you doin?", time.Now()}, 
-			{"Could I be wearing any more clothes?", time.Now()},
-		},
-	}
-
-	output, err := expr.Run(program, env)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Print(output)
+    code := `map(posts, Format(.Date) + ": " + .Body)`
+    
+    program, err := expr.Compile(code, expr.Env(Env{}))
+    if err != nil {
+        panic(err)
+    }
+
+    env := Env{
+        Posts: []Post{
+            {"Oh My God!", time.Now()}, 
+            {"How you doin?", time.Now()}, 
+            {"Could I be wearing any more clothes?", time.Now()},
+        },
+    }
+
+    output, err := expr.Run(program, env)
+    if err != nil {
+        panic(err)
+    }
+
+    fmt.Print(output)
 }
 ```
 
-The compiled program can be reused between runs. Here is an example:
+The compiled program can be reused between runs.
 
 ```go
 type Env struct {
diff --git a/docs/images/debug.gif b/docs/images/debug.gif
deleted file mode 100644
index 90a6ec2e6c9d0d708ccf2d069934fce9b8775550..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3546095
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%0D?b
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%0DLa%j3+{5`lGLxO(%g`K5t@>w
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%0AvKY)75H!)DfUJo)kGD+$*X6j~15`xa;A=
zp(xvg5onWw^h=CzN6m8ANXgY|U@1wt!)|9iOs+mI_2}nE4UDOpQ{bR&t=o&cVKI!p
zXRjnH%tRf^S8@fFE>Cb$`z52ME!AYG$|vV*0yyC1W07_qRll?RGsF}kDcj(WZ_fUB
z^WQs0jcQ5l>I?01X7*-q70@kMPd+lrbGo(f>8neahG3!}>_|N%VsAMmG7X7S=?uSG
z8=seL|2nCqLfwFIxdI84ea(|kHmVbI_z&1YQBe-L?FH)~5^-C3!X&j03g{vtw!)d)
zxt5)b%V~-~o5Yl13hdMf0e(^r%Wz9Y6hsId5iIPp+Q8*C=P6+AKBYUjhU59-2~khf
zQ4x(dmHE!jH2X!%0)n6hlU!_dt3)$6h?D~15I`fDG9zncK_8VP*Vl#%TK+41vSp3F
zdoLJZE@Eg9fRA7d=ESZ`6sUjD0`(FrA?<m<{eIe~A}K37hPXXxNLO}8*bK=X);}qL
z_S=S2q8AJNwV%qxd-7N-FsuAWMruIuro9QI4w*8a<_e+@Ug2y&5A+5TI_lu#uvEho
z|9T<!YY@M`BoVLn4f!t7$JdnCt&e;!Dtqwjs2ArV&f9283SdF^6UppAU;(QhG1##Z
zQg~)3&F_$>v$=W0y_5lw;|E(@^yfwSNl*UlcFtZ7jYF2s%VR)2sd<r>*uUg~%b{)u
zQa%h8QGFGF@)5Y1{(3=JYlz(7M{k9<TLp>e0m5&h!yv~JOX(~MHf(r3+;|dN?$07!
zemrbYiNENsosK52D?6MBb7#+L$sO2!zn?}tSOM0GJWIAZq7ag02qVc9OJ1{3XGmNU
zAJX@fdThlz)(PFK>P6Ufo7uO66PCReDtlwxgT`lD{d-5q<s=8)6~pqQkQn>YLrc~>
zI3d~hi(2!suRcucpi@@JcDrkzsYM{i(SHKxL<Rc;FUYg?kHx6kt}*ZEivZF$bsOAk
zA%1TE6%N+n6}pj+uPNvpd=gXIQDs*6OS>*Fd9xmoY4pzGZ{~v(2<03sLK<l9EecH6
zQ<#;Kmyp$!6gc}+?naY0z;7-yPL12QRxxaD$7CJ7q6#F$vL2|Hz-N~9<jRAb01}O$
z`85Zfqg*Cll4HX#@<|2PE_@ZCWHQGcNRb?S*!6bg3Y3ogHDYfZyYHg-hqOKTYd?~I
z3iFDH(_iIH-oR5$F9kuh%DLkp`gtCRtP+m&_E8?bLR2diU(ZAQ`Dw4gpGQA&nWF8+
z`W_tiwe#&%77hRO#S3>3-l^b<MrSdpp|-}1%bz7XWmuP|f#LJNw16+YmH3-f%rhuw
zXtyU02+b&svnjfTr<GgSeQ-U&8H_sEma4E^YSX#GQVmReW1p(?q0slw>D1SOX^YZf
z#!o9K-3X?%-yQhSdwFs2p-`X*bXefMz=MzoYu(5fMiKfe*he>xn-4WTQFExh1ZsMs
z)yHA_wL)aVsqf65FEH(rZeGE3;LIqNtT=Twxh(?1q&*C-0=aWb8bko7T{5LSD93u6
zaA`I-7<G^*@S=G)>pIj!=a1`v$2P%MuBWiAa;HvA1_?;Kx>%qBqe{Vr(#a4Si^`T%
zd=fq)r#$^lAZ6eD@@^4vlmk0!X^je9z*~aj^j=R@y!-d(_OUjG__=aB((~9rV&7%-
ztt<V{jz(OySg6fA%{eONjU9LA6?!tFL4Zqg^UHEuj46Sc7beEvlJCh$@2pqeRTju|
zvd1zJkdd=osNXBb%|OnTM^)6Zucv7aDXlwNS{Q2LUz0*p^wsETK*q_*UO&2bS!=ne
z-oL_Jx-WkKn?kd{CX$*^Yf*&{nIRTJt(XZr&~Loc+piaI_Scm}@nnY_)Zfi(zt3zW
zr-Zuq)5czy20uP2H~G3R?uuKwevCnq-lHK><8_fzNRaH}Ce-##h2EY>d31ib!=4wd
z$iAVF9y+Pp3?sr#K}d<(sn8?|)9=*O(-gNB?ys&Yuwz$3YDLMZ+VrJ7^Oj(_G3zWn
z$}xNhz3S{^c=meK^o``85X$RVbL(6=H-0|19bA|?E=@SIUQn}RzTHRGUSwH>CX!^n
z?-#79&#*M=!&R*~NhTD+_Ih#~-7KA@KKE8zSqXjQpr0>%ht=7(2r2?>(<U(LBe1ur
z4n-o1k`}RF3)Ciqyc<C1hZM9)sHb%6jzcTNWeswz&X5<tRb3HK(*}d~3Zpe!$Tt@?
z+xtYj7msa_Wxy~fzY>~(h1NDdZLZ@r)isL8HueQcd<SWeY}CNt<wj^?Z`Bbu)`Z&F
z?;=CWvnPk&E<=lBJ9>j~!DP|yRFMm`n)X=KTr0|KKYF+KRa0F{eyn}pBx+q7^E(!^
z)r$GIh5_kdp>bHjHY{o#i_^i0#o;8|a5C#SvW|#ioQO)Bh(@7FgAzu}4YY?MDi|#K
zX-&j74u4&M{}xSjE&S^mhi|PH@th)7(+JMBLXT1{mekE2Qp%-W+#1Ky>#ji^bqE=4
z#uLFtu++-dkk{!k(z>l`hRBJ?&uZ-044zPGfk|9bZY-fIPU^vu&mS7$0!^bg4%ZrT
zTAhr)!1dT5kM*Y35Wh;CiBqGF2@CYfhz864U`zduld})Dt<#ZwGopPHklL-2yxk`%
zhLqBpP^0P$*wvAL7Ro7}q`a%^>BZXkuF8H#|2Gn+U|1{8hTw`UrLq~QzcI&q*Azsj
z&0x3G=5d5An4jTFbx;xI_=b`IhkyY&wojQfj>vte7u~h8u&c`rxBLmA$S#~9$`^H5
z6{<BTNqw6nic(Z1ME10KP*QA3zNu2uwJH^92^+OPZj$A`TPj-A8TM=t`_g6--6cM?
zC>aRIcC>4LD<XXduK*~U3nFA*!vbM4)yl3fYJ;oM6LfZ{=!B8G4%egO+_W)vLsRh-
zC5MA}MMa}&qV3Ug{>>)G?Ego_-aQGiPL;XLy5p(&U%;Bia*=FBzxW<K!>u;5kK0M&
zDfN<dtsSmpiI5_&pb!*Bq7KTreNd@!pQskmz2;$9aY`xy2iOhCP3oE)TNTr;#W{#F
zolimG!Py%O#QikVSDlHKcH^NA<Edi&)k4w_ZgO+IRsr@Pt5x<(>R<ncf0SabY=`lN
zp4q=s_^{)0jklx)sPfmqN#KQw&pJ)uAiLN$+4^e+Cpy%Eep+b6izF;cOxg;q0mZwF
zeaX6{tL-W&dRY%SC|)=%Ye;}>7vHqdVk_~C+qhvBffu>OAa9UmKR}7+o|z1YXu9|5
z3kJ(=)S{cAvOYg$)^%hbQ_3TMIZCb*h*nV>wFK>_CNcT8_;w{uWOyeT`}Y9(8<t4k
zP+b*~s?~Q9)j=X@qC_$_s5LCIUwoF1`rIU1;py@_{(z##;O4IbATM1nZ8yO#Hx-d)
z<glAqf_sJz8q5%vH1JSN@KEXU(D?14V{p(Q;h=HXL9^cnEe$+v6FeOg8dW>b*l0{G
zMGMb!(6a~BOteHg|38rRrh+P;X!Yz;3r_Hk`t7~n!1s~>u4R#!>ouGEJ7Y~02wEg^
z$OpLKuRPKT(ZN)`ZddL+U3}oXTwiTfk5!hmrRUH`v-D-Z+hG4eFW(mzjnzXxK!WA`
z`?hscyY8Pb;ewBukQE1)(iX<WZys3bSt{SP#QvcxiWsP>!v5a13KD!7H1nG_Tt}D-
z)=1}SfP?HiIq|zoLQ2n7R{#xNn$6%+@!e>yFIk#ei^`^=FOv;>tVDLL(9;WA-&Ivd
z0Fm~CYC)wr$6nqf{Rw-t<g>(e6kej_*ZMDcsxOfKjQ&(}vI_a=Y}t204N*((>=p6_
zb6e{pd5e)9;^ExWYCAX=VK5*9((vt*3-D530yOj&b$%{kFMy<Ok_l*X&i@R1h6gX6
zA+8)jLeo6*xgO(U6Rv}>jylvX*A5)Cv~Yk#TqN9NNLAK~^OH41viRS0@mH>G`v0BU
zd&cJu2bax|D&dNFJH$!O#PxS4-0HK!TB4cnZ);MJFJq*g8H!(j2OMcq6b5g8u&p5G
z2rFfhls*V?$Vv-Q6AwwIe?S-8t%OT!v-lu+^`dKW_%>lL5Q$K}kVkTGIs51~^4R2I
z_DNdfUd5X;33F#u)9s>qXgHDm+S*Fk_))p}4t4WCa#k<NnVDCE7R9tx04jI;f`-gn
z*q-b&IldF8s1Xwlz}60JZnO{O8!Qt~#;03KDK(0w(+Ex9lMXJYS@aNi%(Qb|)Br$0
zLg~AlNqaJlpeD3QRyq-R|LLJWw2JZ8xFT`&($jLLwMw^p^<I)u*i@t|MOH~5VnC^Z
zI2u4?kc~#tw4El#RpKh;vxN^Rw9q0gg9${6^q;T>b-R?@CBYD*ysO~uX%0F&{3L|}
zO!t}(ahJZ&EH&w<zxpHh_NDWjDiA<3XFiq-cFbR>wRcH8ssG6W*5|kCoTZ#&EEEx!
z#uc#W`($H8&MuTOx*|CljF|>d(+j8iobz1nD1FdzW5Iw6HzX)rTnR%_i7ayWgu1V4
zVDh*~=@ra(^r2l)?ZT(;l#u{U^#HT*vr@Twe;B3J0>shxM4o0Dsf9a3?Zf#}Wbb>C
zh$jLkR!bfnQXq+3Z3zlacl}R4BxQT%oGF()a^udtGX85Xnczu!bu?yoR1T~L>~w`n
ze7$gsoN}oip}csi^8+!w&06;m31Fx|Sfp%HY)^u8pJm-JL+a+QOFDNcY)>hYwNN@p
z%(9Y0K}sq6MpT@Z5aqs57e6VtgtbxL^K(zNOg7p#`1Q{4L(XaL=P0>}TKg;V*iuV)
z#eULVUu{7!y6@^EMBm@+z4cXhl>j;_=7ZpoU-?f;j=$;NBQ~P}=f9|PQIYCE16eED
zXH>TFv!Rl7EP7)4tK6$O;~;HxIXDjrF5Ux1s_yy3Lj<qx)S|2Z-uj|WSR(oTT`>K_
zKycke<7W&kCY7^m-}JhGB^Bht8Hk$;#RGq7<-z}h^hZF-r5RUqgYmm`DLOb^yyf)<
zXnp`S|JF~PSu1T=>v@xo&7~N@gDcy(Z|8s7ohrfl9mbA~|JqoT`Ad45Ybgb6U#pLm
zMdY9V60VvsT4mC$DqBWs+KZ0&{J6v|IuFu-rOGUc8I-z4eW<nGH0E}{U{CK;*Z-uo
z#87#jOR}0Y%%A#NJ>kd<k*!>lb2@wH(H-SKSH62In=Lfmz1~N%m_i{$l)D#!y><_G
z7iEnwBEG4v`NPWTC&W%;C!Rmqg7v7QX;Qq%0`d}#DVXX{>N_1@aw%`=k$tW7C{!v^
zy!X+TFqSWq*J1z@(2;l>KA!y*;P;t;LQ3pDbKqiy!Yd@qF7UL^3WX(ORwjpT?2P{Z
ztizrAV-I%5xTfQSN#l?2k3ZQNpE7;&BI(K8{U>jBo-8I|i;Gof7r>Y};=VZJWNG~J
zP6>uA=B@*{uBY5cLjy9C|L&?*m+tgEQ(KFpOo%FGbw7R9L-;Ksd22aZCD><mM_$_a
z`{rfx;a@}vEJfu=o`#KdzYd}3lZl81L7FCVc@Wp!8ljRJxTvX!O9BexDXwBxmS3K$
zJ&3mYXJS$mu)N%CnHstr^PDH?;VdZdDno{uaeDfO{1odXg~$*`)CwVM3Eh?i5i=03
zR=lW|Fk72l_Dl5W$wt4)m$y<a{E9S_lkX;-d3D%l&w9(VEB(RTPSM+o*_9u(KGde`
zTFr*$w~p$As**eY=&4of;BV_cMWwx4mkI7#KEk6(5ot4zz&PnXTrVAIXP%Nx{|j3p
znkxXx5a7A3X@0FlBQm{OFD3rpOyK9Y>veCmcCQ_@)#3{6YgbL=)x8%8sD`GI>|wy9
zLZ4gOq16%XI%dD>Th-sDjq0+IHy^GZI3&cUPqYt;wzoX@PgaDb9z(RRA?qbJ$T7P`
z8w#zaBO}_fzZ7TQEb?l_D$kXF;WKq8`;!|+CKG?;kX#{li_itNh1*=>mt$uEQcP+9
z>2Hfnz>1MrM>I`;E#=eV)91@u0lw=xV}ITnQ_bb>H@p$t=*pkd8(9t#0M0Ef?)&~p
z_QXSpH&tziqs~}7N+wU=o)I@;%FY?<Eaa&IMj>Z|j``=zo4>XEEOYXZl=_$9zKt^$
z^*JOIMd1CdDssD-sbKp#{orS&At~+Z88Tqmk8l52;8tbyeq4(GbNyY(salDTbVN4C
zS`KV;J!Fl>zyiToG9wTSnf>sTK+muV{&zTxU1fQI(fLnrb|MG>Y=H2cp2FomK*m1R
zG)wo&=tcFzcawM#>_w|WB<+=_amUJ&D%11)guQ;#WUWmO(JWj4+VmCYOD6x$ehYk<
zw5|zbb-$0;Zv*3f>mYJ2T1NA-#Xuy!Q4B~5B!Z<#)m_Q!`i&ZO8=8JV*p={qW2a68
zK0MDun+qGYEe+;M?Yn?9ZeMxqP_VUqX71esnzw@J27Ke>p0t-c(E5naa>i+17Y@CL
zv7TGR6T@zns1)li7wJdresi(8y|y@zBW00qdgmmYhE9mYk7&K`5BEaD9EV(q17?Ez
z1JUO9H`iCjE?E?qKluCm>+5?d7>kEHTfe@%epF!bX!qaF_BIa_L<gfCf*3GaR#2*t
z=15Q)+8n{7rHi;a&@#jWSTrUvW`ve0djS#5qU1XSXDL;)g0od`js)juJ{+mRhtIl0
zGgBR3&bSyi#>=?vi+nEcytmIGv``B?>3DcIS`;1xC<J3E(h-AFCu|Q%Ryb&RRTSI#
zzw8t(gC!d)Iy_8PXe^ApX-olHFF!|1J~9ho>qbPpKT>UTcF)`qt@n}&9P7S@vKlG(
zuyEjc#U15K`R0{0v4jk32k9{a<Z+<ic-ow)SK=>x%mdWL!=*}H3aX{oUcnAl>VSqL
zo0abfMcnAt^|dM9Vh6hsV4pT5C;^U&iq&U^e#yI~nU}V>B-Q=;TJyx}UVTtTZT#$w
zS20mM65u!gvp_ct7mQWnn0PrK;~_=o%S$JxGsRet4wON6w9UZ1^@+o`G-MMz2PpRx
zLYy@_Ln{#)jhFAS$!)oRRBvp4fT)&=uAcsI?fT2^b^F%SR~0+S_iS{U$zK`{I(eNO
zJ2|EU2A=o~PFlX+N4q>$g8#ac=3=_t+aGJZjp!I}1@($j{j5a4U9_a0;9p0@zF&3$
z23JJs<Ss|tgvC4|T{)2I7xl3tH0Q=l?Td^&iP^B*H$J{Lg$jCfYfU{_ZXa1n5_zl1
zL-m{&p3`}H6!z_zLxsz4Mup0d|8x7}%R$Tvz2~iB(?%e=IQ@Mz)W=2-R;!n*-I@G`
zH)IY97Zt&!29-K~!AChC8<5S5JX~gQ!)f~~a%Ok6jB?d^W5lQ`qH#&JgP8bpqGrY?
zvUyc+yvyYqU!{)LPyPKsr>gj$sXs%+XMTYvZw_!K-%qK+3{DN&4ME%zfMG)DNWj=v
zy@J4(cQvYbbBanC6eO_h-J92dVw_$)*d=as<36JK1X$rv-9|T6PeynTE~y%B;VYf5
zkSfc$<7}=Qr`qVODGllYn}J&^bqWRa^0h}4z-)BVlS#RJ-w}n~LUcj2Jn&;O)sBe+
zViIl84WAH_?K3$#IzK|k1q9bLVb@b!_|t7QQL*!T8uDKZ1#6P!JI6m>!Sm1sCrHut
zQriv8^G%v~?xqtUvWhoKgi65fc$$~@;A$=VHEo&-r~iOZ0^%Y7p9};d*9*7KE}yR3
zwwKFZ%LZ2J9VMMBXP^I(vGbZNj+Q!FSM=Lazz`c_*d_(?QfWXxEZX-xxE^M)HRS)f
zNC)Wg1jJ#$5&AKyZ^5Ign#H;9>2;C3*mrhH@D`spXkc<)#(pgp=bWS<>4-!FU+I!j
z5P<T$ym2G=sA&PnzUq*Fn8a}SnC64xJ!<_+u1*O<s?`u@Rm){fp5SBy-jecVv&51~
z0OSob)aN=vfIkd3fUcFz(GN5~=U)DRWR=i3=^&%&VbN*Y&r`cQB1_p3X@W0pl-^W7
z3jXg;m2m#?w5eB*6YNwJDq>KjDs2G=j!I5)gu3=M--9&)*xV<zwJNl=OpCtS+@s3Y
zk{^3>FSE3*gD&REAF`dZT8S+T|D~D<nv`|~u!w}(WmicxFS8pT?*$iS<s6r(Fb^qe
zFM@u^=~iDpa;0hL5Y+IjzjQMV^Sb!fdjY%$JCz*3>TC?9ocEJ=R%;K-qJCeNpl>ux
z8s!lBqPc~?SP=4%j#<k!7b#Q*^c5t*>5kX)m}5T=f)4vt`Mve_<J4)q4qDplcG|n=
z=8i)wE@ytF8X|i6lKtV`si{VmrmW8hzk}6sPb7>gQO6sdx9Hh-rSdCS;alQmi_uAw
z8xb4F?2m`tdlj*-msxhJyZFVxIiYt;pn@~WPr`z>4hNn&nVUGO(aJzs<=hPqmFsMB
zKbYQ)q$X%E7f0+hM#OIm1(x49b2nA%XKkL5(UMvOe~u^AuIcyi$+_05_s%DL3@<XD
zkW8u+nHolxQWB$wp83TAC%!yel1&_WeB5;pDGp)$4_1?YWe@O*ulxO)5f5PWula6x
zd#L<S+F8+!VNV~aPp=pW)%<xjF<ZpZA>)$Ts~c`7qdyppoi#qPJEB|Jh8l0__faQy
zwA&f1QiUsx%>S`09u{HZXF+xb|FYh~P@f$3GJEC789dE^DVCelxo4NZcV4wXeRj(^
z_q;)~>)L_5&z{%My=aN)x*mx7vWQ(2ibq)M%spd;NK;<k|K7Fmk&c?kNW=d#8&%S$
z<N-T%zIF`wktEc&@Ul#-7DQ03(<8U|Ylzt3hsP`7^50@}UK{z9&zq^oL2WvrY!}O5
zKxrx~nC)F_<7h2kYVtkl%Rb$#-rPO<Mc2NWE56RxchIJavJU?^zlhv(K>eW=f4jHm
z&3ioudCek=yl^hAe{D#o^UgEt=T?$~o3`p!v~|DURPi>thy&3*$I_^q@CrLrCzb#6
z@;e2BhagAn;SxrZqXs}RR9)&Ry&^WFg&1Ks*ueMCCKBGu!0s^bCT-!;rTgz!1>c@{
zgg(vArJPUg5mso}C{S|0ujz*!@=0fut7>-;?y^T@LYBTKNY_hL=BO(<?JY=Rp%p?c
ze;IJd7rB|q>p{FGi<?|1K%mH0kbMre|HCA**W{)r`@Wg{EeQN26!je8+S|5xotgAq
zetHxB(jXN(9@>ovy(YJOqTrN@g0<>yVy4$a5yaJ=*Wv525T}2enYv93WaZ&Z`yOMA
zVR)#<dheY7<v0<hogVOD7XB;_vzxr1M#$KPo0a1BrS#A~^0zoCHa|Q~qahI`W4TJ}
zMb?H=D=t5J59#}-h#(klh(FlHFuJf04?@Qx>>!RjPJ|=FW<6G-uL!f80R3;xZ3T;7
z#-fQIQMPL~Agr()Nc})P?j<R4&PQC%U3hC!9F9o)s|4+IM+=qVA^+jL)(wC)gKh~C
zX^=OFgd|SE64p~;Q|E4-aT8p}p+PtuM8?twghZiZpHCc!3J)N=+G+><BBk&H@ctZ=
z-}TVIQyC3ym|6QoHKXM1*mQS9W=kn7hr?I=4A!Y9oC}X{(_wL~h{agRDMdtc|NoT)
zV^KI9z@y^Cr&uR8Q(m%R;cT(}Mi#`y^th3%mY42)Tk2CRZo3uH(usFS5AP2~l_7w7
z4(`7NhpjbUI<GWshK=$352tLTo^3Ba*ND^DWL7EX)}KBu$3>r?JZ?)qS0aj8o)lg`
zDAgF`eW?RgLJg@4!_H$7ecDnacl`=R!j(c#Vw(_8JFlOWUndUFWUIunb93Awr^4Y$
zcGS6A*aaMVJBaydq~Ko@p4N&gT?n$J3YS^B@3Po}lK9xz%vY_*k85IYN%2CCg<=t+
zL3C7Jljd8uVDV3da#^CW3y3zVaP3+KDXU23T9Ml0B8^W)T7tzoD#dz^#Rd_@d$TB!
zBzRe(Na$qYmo_+iA;F-O<grlvqe(ujL)7Mzyi->3RyUT$Mt)^We#OQ*9z=eN4gb;0
zlk@|foQXv}2}0HbFdGK8LfHkCDt_qB#Upq2^o5A-;_-)mmAI+Eb$;Q33-#|dnZQ7(
zvpsmcf%=>%I#L_|Al&~>7s-R<N?I?o0fib~DYwN{B&fuAv=VnY!pE_&94zvD5O(+%
z<|P&$+3P&@0>4ZUY-|<&5-VxGDH`@kC!>p0=UCYofo(D_`}1DC^AJAnXvNY?1g0yQ
zG-dFWbQE&UG4V0py#zB&hQ4N-Il=I(J5H#Rmz}!BwQcZvOnFzy%TwM4>ywgu3gP8(
zM1T#;PnSHqfOmY4Sv?uIt9_X-`<-Qr@?}4R2Hc&~sQF1`7a+(vS!xr@L-hBe`si?n
zPjagfL|9ujY!UN)>sW?uM6Aj_-o?NT+n_*v^^_8nFe}W8iz)(=!pPp3-<bY6yn8$*
zR#d1r)0&4BPNO0JHsQD&KjM@{h`ab-35miElG0xc_l#I`SDiI3#OPp!(#sI4_`z5^
zr}IB+Cre=xWWicGYKw}Q#>T$?h=~Aze1JGimz)^Dugx8PPB*V2<2tFLb3-Pe1(<IK
z`Y!$CD{aU9vtlnvC{AsnAh=P{uJO;QMpqr5h=EY)W}j1o9511$RJy@JBW`OU+oV!I
zs1+R`3Y$B4*=h0eg*a$IF(#e@HO32r;w_xw&%B1JGK+YHdCG!tG2neK$>cM=veKsN
z?-AFj@IBm;pjpGNE)TXzOeWPBsRU<HrFJJ_rnfORZb%Or{3yNpM+Ek95Xx&2^L9ZE
zSZkCcU**z{eiTJ|52;%J!X*7t15vLDf^T@&JH9w~!(}n-@xkao@t~6tEt92iR(BP^
zR^e$E!P*c3am36uvBBBPM;PH#K%OnVxv<109fU&t#>{AQrV9&a*JRlET-Zh|kD3W$
zw+e6LW4!kk-)Wav3HjH2B9v<U>zK{%n()On+^2=J$`XLlrOMhZ=}mFb#b(^kdK8i`
z(oGsv#G#-dz&gE@V&sbS5G<!*O{9QYI#1F(>Q->NPx6&pfn)o$_r-Yisu1|L)EcHU
z7C|_V2%{lGSMjykA|A2mf(G14I>V{NkWVRxzjpUv7e4I4k;X{J&*ONlQ6TJXJ|^l)
z2{lj(jkNAIzKSec&w$-EX1hVxVkOI#G*;Iz-+;V`yT<FC#D|;Ej{xx%pdEmRYjv^?
zjP)cMq#kG@RlT-{)k5p`-+d_L6B+MAyYBk%(4D__2oD@Olmv~Y>;H5sz1w;W6a=li
zedxeq9m^xZ@-JMhG%s5h`My<f?<r{M8Do%kPg<KeIf^t@f&|<i1TgacL>|t2sqA_#
zgaGp#-j4L3C+}i0-#8}u2wtt%d%j0`=+jzpqf|}AhLFb@eGk2>qa55ir<>EpfpdHG
z<L;q~U<=G%pL@Og7n_c4cq^*Ai1a^tFyxSZ8?)8h1)78v7n^}%(en54Yz0QY7%<B5
zn|Fivu`xLWAd^&8xgxd>2(hNlJ>p0N)2<^oLRS;}8=LU0gLYcB{$rHGYSPE083FmR
z2&ntslM9Iag@hs;EP)O?%&$o1bH;1%lM6xNy1pn6$g$iZzKQC0?0x`pgrPo?<~))S
zJ(8KrKj=qt#z*qLjuapt7pgxlc7A*@`f*vbTm%Vz<%?pp8$4o-?q><BF)d3;B1g~z
z>_Pl95)sJZL0ei*KW-c4-(BTn$I4ATlh&c5r0l>#bO#a02||6NpZ?e?<VD@TKQ8!z
zwpc(MW*$4Lg=@i{g!TiNxqkFe(4fWQX|=oVwYR0;%p=~JKI&2T1hDWQm6u?dBEt(q
z4wmOTHgJ6ln8)6x1(hV9wUo~uPZOl^x9F1TbeCQ2)MCr0f09IiZy0c%B=q>iYSQg5
zLhztT!~*~UBMS}#2tO?Bk{kc3q0yCFw@61Eo>ZvEIz1y^*Jyi$rbt;M;m1h^ukG-q
zY_lsBW-pB-RjWh{t4>F<pJB{A1-_VRSUv@5BR1znr#gH1<JnW$s*UR8l?BYV-mtD%
zp5!V5e@ispW5Lr!M)E+Fi2oC4z&A{g#&g~;gEgRBm3wn~6+h+KzU>JqIE6|KLG%To
zW+#O`z<bNF!h&Up2fe7LY+<>!IGHoZHc?VCU<<2-c@>)Nz0KB&#$Gx%1|uVSVo|d}
z$m*c8oAonEPsE4}!A|O&Em9aXgXp9pyn+yet*AaXIEgl+0)m&Cxki+|1ldBGi>tle
zs#T^C&3b63H=>G%(OoE!lO$vx_2N$w@`^lCQ4MMe7vZ`&7ylG~!qL>?fAaS}WxSFL
zyFCe8ME*W=k-GTkyEyVmZ?WU4*xxhy8!qn}r!+n9RKav^oN7)uRw?<jmuEA9db3M<
z^W1Fa+ws`7H?M&~ShIj&Bgyq7w+2R2nIYX>R%mdIgLX$=Fc_67oGd$1>-V21P!)^&
z+RLB&F5VBuuKpAo)0PlA27Svm8=R~R;MVO<2?a6&B+4+4*Tgj6;=9>qUr5OEAYpnq
zR=FCZI<XY6xK#IXGB>CGW6tUASd@GhrcQq8Q1yGIw+npGLt;HS&mqUw**Jtd&-%+H
zTB0*2HIGw;JA<yTyR9l*Gw=yY55-D{l5o+-vHRjN_n1pP;X-AMydbt&-Y2;SbV=`C
zsNZ8$AYBrE2Y-@n_9J%8YIxP_Mku}dtX;#qrN5ZnD#;34NGO+Q6(6$-Twd+u1cc=K
zo;Ff%qrx)*951LGgoRa6h5K63fjCS=(xB}cbdcU1<1Ur(L{DGIFokY#eNE=X1}0Eh
z-;oHElX4Q4#OPF5q#JB`@*9slAi)P)7cezDvo7o6+pTYj<Zn-Y;ab^d8}{$z3cnxo
zO?*8({^Q*1&X^zpm--M7>)qIkiezX{tYq5Cb&4fiJWdjH8yoyD?Z;`HT_jfG8>Yg`
zo5x|cOlkh;eOmJKG7luIA1}Fl6j8peRCY%4*Cx(l1w)hr=%n)?x6j0>cl#ZjpZU;<
zv~}<;|8RP^s3hP|H+Vg~XUizgIZob-dK7C*%_H!x8!u&pCO>?eVPW;$m1)qqVvICD
zX+c06mdlm1vsc+-jca0s3;5AB%zxO?`Zck`1@J%};+EzwpO`Ad2WI2LX`34V&*n>x
z%bvDXQukId{Vsju&kVM(7BVzR_4vS?eKQBzjjvRBsVt)2oFi$}NM12Rg1+HfVkNKL
zz>R#yoRR_leZcrHR@%D2y%?X}?`2u>JktY%?%l>%2?73=twH7bAK93&3tzKUP@lhB
z*!G?>`@F~drEyGg^s5kT%|(&v^O!xxB)?X@BNN0=Y|I+=i5<gbJN6-o%O*WNHz%Kb
zL@)iJx%F1>kLYl0?<VeP;O>2l8xz3p?()vc3-r3&1J*_$*zRT$pfL*hBjh%<WSc8#
z5Ys}q?kx?F$y3|IH-blez=y;@K}}wRVKP_nwO&&dgK@n0<H(X9a{H*Dh6Ur(dCTq%
zju$nL-t8>w4FRzbqCFj-UgUU;{QJ4uGI3G2IGT$mL@8-7_6h|3+^cnfbi$t(alPkB
zO<PXe?u~op8}CK|%{H`>|LhuVAWKZ^*!=8z$Vj2$fyVm;z8%V27_65Fde@Y_x;rI&
zMx**^Y@jM!n;7)QAYL3(RWi+d`!MCQz`%7x*jwA0wIyHEvVx@{ck}<=U;6Ka+`AW3
zf@OzRMc;f%S$%GE;^4%V#e3elr^0f)q(r*c!lRC#-A`9ur3`9Lzsj7fJ3fE;zxC3$
z?|3PI06vxq7S_j7Da~$b9cOjh5JZOV&*7S2alad7N!nJ!I6##`QP?+)8>vYyS!bi}
zg0YB8h9)h_H+}PU6|drMUt6Jq=SX1#DMPgSM}{Sguz|C!Z3tW0L!A!Up-MYp{CnZ8
z;mYim^*!Y|&Rdz%xmMC`{AmXMl(X)b{!eFpwGfp&fJ9b6=FZ0sh}xr7`YklkpBiuu
zYm=$+1|JDFT{!?ypKscute$7{m9F<>_v6A(Q{W4yAC-r8@vPTcYn^PR!ZYGMJ@y;?
z_VhgHmEh%lIN`UKZ^*?2Z=PRN*KcqCQ!f&H0?z;b?GuzHcG@>M$Ka1|XtCGnL&q*9
z{5cd}fAO?m<n^vUe$gE-P9KiB_xsP`*nY7y{wK!_{_~H2=5^-C>DLMW9Z6iiIAdYB
zG;1Ya`uV|`fD7Bd{|k(^fGn4vwhM(9<-qJ%*VBCD`zxbhTa&hQweHQ}T%G_Gt*H|{
zNXge3U0ohsh@B7xd`A<HmL5J`(MlO|cb70630EjLRn0#8q4LDUopvM0v_b<W(C}|~
z!{O5k^rV*2@J~RClO&+xog;AHwaL{u;^w_S#DEj0uLsMY*vYyoL;;g3mmaTRm5a0H
zywB&@<u2M)IC;kCiCY6kp#)yc1#a56t{Lxp;kin?=i-K>!n(32E)>@FQ#4a|<Q|h%
zgEvO^o1gvMtVOZzM5=ix#YgYzC{;|Ksqd$h8qM52Ij2+kDsKMNOqH|2z@^X<{yIb^
zF<s!}o0@lNat{+Z{{(}=0sJk8od0sU?`2jcu8nPFH`NZE6@8I!-mq>hV)551>uqxK
zpVwuY>}0SJy#6VeZgDT?vH&W4z5V8cI(OC{g6DSXPru^3+0J#5@r4zyb|v<`igpR}
zI~54kNVFV~w$j{c%8*9mq*7Wf)4+=y_!Re|ocqvmP%L(9+Pm<WkrpO`Lo)(nF9EZP
zKzAZd6YPe@6h5Ua3)k_s1~QG1O72<vpF7Bw9Ly=Uq3Gqu)+I*j7^v(DL|$LFf$SSb
zuQ$Q>ZY>0SZq@0|o~6hkwgPR9;QNFo^0Q7g$ip6!%95c$!lHi%Wz^cWC|{@K9sz!~
z9ErWP&dR_d0WL537^SwdrpYfk3-m8H&%Ss-)vhIEk6Fb&6?VF8t#Gf{_jQb4x-L-P
z$x;z;6CJ%goWi+|*y}WXC%54yp{D_36<p?sK(Cjb+YZ&qo9jA?fME9Mq-SHhbH~*?
zC{LnAj~bRr_S~6FdPH)UF$|UnaXYD%saI$COyahL?7^xpp_1gwqWRi*25M~<MF3L~
zPkRqm|H{oY+ryKG8YK=97~1J1Bo1L1{}Hpq7?y2*2@fF%nh%nWYP?j&PaegW#WX1H
zGyCgK7ps+2&9>+2J`=3Ui{Go-jBvUksedO|85m5YNkFY+84K9UOX;qQqnQuMM0A6-
z;^%uL@RRHndAZUamN>i8b3fZd*VZA8Fla>Go1ZEjvI95NcE?5R)Jyb)4w`>hrRI5H
z^NZCY55K9r$yOi0F-e}aBMYoMFAbcdsSw#;ck#dDY>H1PM$=GH1Y=q6ww$BtO1L@S
z5xbW+`b#c_YMeh5vWxGy^gcSwZ2Qn8)4Q`?@py#GdB5k4-d)#^9*;UQHmg6mct8>t
zOdp}bd4^_<-80i*>Ci8Pz5Fcz|DM!XfpZt_q(cnz8ELUuQS&o)WzG=KA(Q9D`Hr5U
zVzaHVGY?+BvGarhfwO~VLk^f2PMi+6L0l>tm;YlWM0(mYS37B%WwQy{@530rARF>7
zWx?msw4!!C3!B*y5GrQ47_hqovK@7>tP{tL*rl~$B1z&|&qkpIb|sh-svpGs$q?Bd
zk^1W^kjy;EHVdbuCGc=L6#$kjq8DM>Ms*S?*leZJ!dyAttO9S==4j__2b*Xzx)_n+
znYUi>68j<VMWy>5uv6wSdYF3lHAu_?2R0x2pK3%nged#$eM*w?xb87MI`$97Kb*Hx
zBwKXATv@TAYA57Q!Hp4}ox-}aU6!Q9{m!JG_6$nw(K|5RP7CafkB0VsCQ4_Aqjfg+
z=Pc*}_k2-Te-^TeThBBesoJnb;&P+H>m^v6SB}zn7Dc^IVxG=?-oSy{Bm1R>du@&u
z99>FQ_tl9V88%Z5ezVVqhI`z~+*`uP(J-tNZ{^skQ}b|+&i7uu${#GeTK45g%5Tbm
zVRzJST$tlkDcuPv67D7^;N)Fp)U2?*SkgDbx8sk|_FvtknPlX{achEroLypu2y)%u
zhEOFBF1xUZlzq@|9g3Z@t&ICYJ5IBY2*^!kx)%oOTf2*YvUR@W5%Y5G<29bqdaHl6
zQyk`cCq)*1XXHil&*4t8HCsF5;!+$cjdwz7EK5K~F(l*U!ZF!nv?xGfvADtH>QfCd
z%sy{WjwmcBMSsZUSSil*9E>AGyL3%+)*Y9&=Zj=d9P#KZweIw6DxSMAbRJC4N-4Jg
zAg(j`C<liO$;D{}pE!^-j;`)p_FpgNTX>w1!jyRTOI=upmvj?JfCG}jsSfi4Ow7od
z{^&N2?WarEpy#^lNg(C^Ikh7=;#7S_)n;b0GiU>yLAI83_11xGAg{R&;lOjc_I-Cx
z<{{G5mS@XUAXX#5$6dMmfl0r~X^5Lcsc7cHn8ozkST&?qvb>wuh<~V^JN-`pZ(U-g
z<KQx8K5#;;C&^ad`qaDTL&0)k7{G()1~VWDRGc*p!NKM^u>IGOdx3)Uo6z`sh^X02
z=oCWZQ2qR8i?z*1fOO_+t2rhfxsNT37ocBRho^6`DTqsn4r$!V+@5QE=}cbbRYTJx
z>^K;3#1>F{Se&&?DM9*;aM(aw>O}3H;#1X0vrRP192Ljj7qQIpX_&oRAHZU!P#@-m
zLvEI5CU>yN##U>bK8$of*FoTYliG_-xGTS34Jgozlz-eKQ#;#!ytj#x*dE1E_h@2i
zwy=(7-_Lfq8_4E(>vkuT;PzHFC$Rm2+;oBXz8AcvR0mS#8k_m3otZRyFNbAOLru@o
zR$QeH*m>C4DOex$6rzyoVWRi=eCU#zR3aN}-hY4WutMWjF?&r<st<7h37n7ze_PKC
z7#BRUppc_2*uGCN1TU`7%GB6W;}O!8a4ff8*77r!;btGD9}%;b8ER@9YnmGh6qp%h
z%^|dN!t)EhG;NG2M2zH)))G}J;EBS3GtMGEn>jv<-qOkU?nk)R!~cpH&<cx^l!w7_
zX-Tti>U9ypah8@c+UObU2m$q1$Ub)<+Zu~Fp)8PQbT5%EN>LWL$$_3~Miu~Bn7H(b
z!~#qNlo6hR(MkU+OfN^!eVf24JZjq|h*cGJPYxC`4+!y%&pK8+?bA>S0b&*8)QHp>
zRc6MmL0+)I{6~-XAk;dU`qVVjX&8f^X&viih0v+p5u_@Q){i@M+Xw+H!6$Th$XI5i
z=cSn~_<qu((eS*P-r6MJPD*Ur#7N%60%q?*L3VH684liZyopTA(7BuWAr=+F(7H*i
zZ>`S_*~~xf>u_=a;k<*cP%GFRbsh=r{V)OtNAG_b`UonCiaU78kh+hOjYihCrZ{A3
zY+y|t;5j3iYajrBjU^UQ7-Dm!Pq0}s>)LS+B*cBRbbsq(Dx{m$V>ZA#%DQ&7GP6{a
zm4A)(z6G}$?Xto17XgAq9SG_6ItNny^Ry;K?LUe-m<k$VOCAxm_@<uC_Hd&^nr$pT
zX9{f6D_}`aQ==n!kjV}I$-|N@#i4G9yvYW(jF6&@-~%_L*HBGSHS(Jq@`f7*<&Kka
z7twGRHFL+ixQiWe7eDSUk?c-*fANn#Te~%F9}Q{zT%0fOU5L&#icNQzOw|CU&!?Bj
zp{B`s>6AS8iE~ia9cEPGwDOxL0En)EV1DSicEU8b_im{jo0&)`Owi8QQb(r$%rsdP
zqLD7@xg1RKJ*f1pMLkMp#JUXxqMJ0-IJ6^F9*<skyB?)-Cs&)fpqJ~rCTKY;P(z1$
z7(Y+pIXt(`dp5BFIokA`|0Dd$)TCgW)|s~ar22w!_j(62RES>}wO^ZQ*#p+?O@9~k
zU~t4Tg`L*CkvZ!udgzMR%^okuF7?x<FkQcCKr$!!<KSE^!Bjd|x~nw*l~$w^(yAAw
z(F(3fe5s%HGNt@w<hK`3M4Iz1kATSyDIW)aI$rYM(L+68S#Lt4dze9M_sPu=zs)pN
zYC2yVj!=FGEbw(c=DoJ`cw(us0C3$Qjc$-@xS8prK``z`sDwj~7{Nj&p?<TJvsZl1
z56&#zn?3h{f6XGqy6BsIq|%m?@wy*j&4QLW&1O`2#XL~oI4GdK!PNbYaT|lj^Af9o
zO+{k_lV((#NPyL#m>Q|iayB!}p!6jK^XkT}Y-NET3;fKq_=Z%LZKTOStm+nm9+1d{
ztbh;S9S`+?_0<zSpm12n%DFX9YZY-RxEB?55xjX0bK?f<=8d^BgO-}+)aMnMOarV2
zr!a{QRa34pEMb=m(YeCVRY$mQA{6Itf!T6R31^-u=>a&hH(RSyx8Ns4OFuIHX9B*v
zPp10Xjj+MWzcS-D_fECmyFtK>{ezGHcAP`0je8xr8GeM8_y)l0$9J*pmS5a|uP$WU
z=GN*40s#hV=o$jt`?|Ez8tX=Qrr#RNw>(dS%1Ri~(4}W4u`&gCSK6{!nR87;t-_pS
z`ZFy6(|{~}%r#$I%RSB(sL#p$#qQ+;gh>uV4P$vfpJa~j1pY+P-LOI5PNKtR-|gOD
z?RlLUcAUBP=GoG3bqR2~U>4K(-a+eHq3@DV3F8?&uFe!&;De=jFJzm$NmW=r%O)Hk
zh_K8)j_T8Ii3z+}2WR+h&S~VPrDY)R(fK6`7We9LO||JMzB=+378TyglDiR<n+W6H
zyq6?_8l!xnKP`bmnaSmF-N~`{@1>0i?a7;#&2bi4sic3~ndX~UI!Y*4o@7?5r&4AQ
zYEz!vloubpo9c(fMD_Lz_N0EGYs24Wwq0D#X$o1QhR*V`6fAe)R^I;B-H5O?LD?wi
zYGSYY|Do#M|C#&)|M6d&nPF^mKHHp+ne#EW8Ai_MoSIW8gd|BZ=6srC&gY^~b1J1*
zF~=k!l~6eqmCC75vak31`}yJX`2+UbcDr^xpO44=@uYQ&LLJL`0LIHpt<xXEq)eVW
zNo_;!3RPy@X1UuuocbyQqf{;x!DDf*F>*1L@T-_Br<zVllZ4{$l9jS%t!Ilr<;-T@
z?@UMTvibe!ETF@9ci7IO!Kk_do8KxE?Xod?_Ij<34GqKup^Bm_8illm!#`~H73G`L
zn%yYk@7Anf9|7cd6Ww|^ag*JbGZ7iOh+AM=Ki)Z<NRK~CyY^%40u{PB$-01k8~VAG
zhHhwkzxb(bC<w^gVg>H>u)VNyPnfhoWUwdn@d4=J+9*``Hd`~Xr0_8qZIDI|hwCq9
zUe11UiHS^yasY)N(yNBk%YLVob0=5)$j^d7B=BjD@xh}8FUQHwBQi+$z7(l2YKn~E
zoo8p<YefjScKw?vUA{9w^B2A0W%9Yl@v&*fLKP>msg7JF<XBd0bER5(CNO*N*(|uA
zl#PUiSViaVKQvL9NMDA9X7!y<dH?OnhqR~nVWC3Obk}neQb|wWQ`y9k(w2T<o7|Mz
zTL=ovQ7PL8Sg+n9;;zESmCV4V+b;n7PZf{SDm4U9Up}%+rx}%JH>E4a#A+nak%6Dn
zKfFnw*AaSuRMfYa8Sid4`a#8S#|$e$<L<SNAsLm7CO3<7HEN`@Kd+Nu1y0DVI=*@o
z#e^a5X_TmVZp34u33uSi?$CuEwy<;-(q_iO*YMoh3pwsTe_#K(|NBYSKDcIfZuLI7
z&H$;3qgo^Ho~$Kjm6mEXC*w#L5MTHV_rW-04s9IOC~?y-B$+fx{qG6xOK`FQ`o}Ob
zl4k_w3FNJCL<j`6k|MYX=Ocv^T8^>j-c7a`+z;W8TXj4Q(d(uXi0wR$6tCD6^JWW-
zU6kyZD7gz!@(EE2c~OcrQA+os-oI<Z>c1WYAQt<c*$?|Yh`iXm5aoNd-@l&F+Pgc*
ziL~0k8zcmE+D~c>=kWFr9%IaDJ>20?+xbQ5q4uV;DbvXAX0w`|tQOukfu>^Smro~u
zB2;TWiLUO*&QZ}U9RZ8bg-I${Ki5hq<&0k4wb>#2^SfS|dBwLU|5mj-uPKZbM9VH~
z?mbWA7euOTu?e;(&1|umn$-8(?`8|{V81xdZz*bA{`LNgf~k8jOI><A`sTkk64te>
zhQW_a6Inm!Cj~Y@gOYWIbMut2RKM9&UwU$m!5eR#8)UHaZ)+8`WxH<mM~bJEjVxMn
zNPAawV}6%uY6%rY=v`(uUy}9<BLG0mCR?G5$e!qu_G4IF1gcjr^+gwqLfu{Ux-n<u
zVvbnKb{kG?Q}q+9SO3_SWf2|!w#rv3Da>BU21+aFO*``_^;50?$Ly3dOh(pTY%dVZ
z=7mi;(`-0%uyejAxFYm2$3H=5rp3jd3YQ*SzVh*1W6e~7U42aw-F6o1QA1nL2b=s&
zt3byltJP55Ds<;NR%hw}I(1#WAoofus7A0>tUmTt>`;H~AjoRqS!_#QoNR$OUQae?
z|7^+S+(25Y+b1ZeWm*E3QxN1@*v$2El#Q)xfE!=y*ELU=+R=ZoFPt(kclu3i(7m6o
zm;bvby`4Y5K*swbXm~rXdzbQ)O!hNje`%u~sC)*(QnYtAHM%|}a#`2!=Z*U&Uvk|f
zefMHt4{uvYUX#nL(pgCRb^b@+%QV-~<8RG!0x`b)O#EI%oN^+Bo9T==2P8ksL-^c5
zG?~ODTo8=0TfLblZ4?yu`^KF>m+J<9knS>TtIW%0^|5aw%n|{d3{Vxz>|#a2031LV
z`+dNP&0Nw+7#4!Ukl#K&$|ee&g)2tMJS&j1tGB)#CHuVO#2M&5te}yQEqs2svdq5D
zqKe%l(@PI2H&t(*CuMUdTJhB_+ZsZS(j}$WckDr=vb_uL=88b(Y*$>z+o$nT|0QuD
zf7D>_`HmKU66kArON;o;IysD-f9mH*cr*6)hurK_KZJDkAO7=}UB2S-)}pnWZj3zT
zw82b$^|gs=lVonyIIS<!E+88FqMEC1T|@Fg*6hXOGyI)x2y^@Q%a8rpL&KCmj7|ID
zAYo-6_`~)U+p@NS^4xHjbw;_+ZU3j?-nV|&>0XPHTz4`!*#7*o!S3GmYo`o^)%A5$
z9=Ro6E#eIFa`}D6{McL?<?mBJWZmTU0d2gpFpuYVB9gi`G~L~@hDNGW%!VwMY=oC@
zAk(t12)U+}xWv|F$k&(FXDWNlniF%K*Q$bh_IY2%U@Y^kLz$ueBWg_dLX=c@#!Rjv
z=JbjkR;O$mp^pz^6VFmU%QkaacS7J(DE@TW=~zcw;ajEt1*dP7Nf*1%T|;N?vPuNl
z>l6q?&!R|T9(*^K%2aY=-}uRflsH#j<?(2)OOq;ZuFqm>%r!UU5kzh`7CL&|zIns1
z{PwMisJYusHAy0Oni~o{?%ZywFTZoArDN_+%RPojOKaz}M@!p-<?@!hz1wpw_nv}9
zTj>Klo~`X8QWYB+!TIuLLNPQ<O^4mk6imi5bc!SsPFqb^&nR;K-u*7zu<hYm$)7Rp
zx9*)MdcPTHh@iZV3#J#gVx?E;sa;nao%%PR>{7k#nmnkD!yQ{o;IA~cf1Mzv-t_$N
zVl9a|sUZT)L+Brk16?rFdBeY~Qq}*8?>MVSvK5Ss+@m?$8jt66ZJVe*RcW6vwELQ&
z@mzs-S7UDD^RwWbfYldLZlj=#rx@`S1mQ8q^h9_sQ*p;xrgw-k99}|mPL;l$-_>p6
zo$#V_?!5AyvSeZ59rXvA92t)4O!BMqg$MSU6DEp=W+Y=~aOBWpYLATGQYtf9Z$8h|
zNA9w)__q3q#($1`mJSzq{YjGI+nhRYAs5rL|F1A@dQqGDf`Zet`9i7saWu$l#qN!5
z_tr}z;qH|@F^oPBr|OurqvPfPoBiQdzSEhLnKaf~C}Y73@38}_UHL$YhG<$FfCe?K
z5BkwnG^}KnSd{sv4Qcq0<Qj_|DWGy?%Vdm{<v6oH?{s%E+b^I|@c5+9yw#z-L#sgs
zN+bh(qquLr*yObgl<Phr?@JEToO8wA#@J`-<mz`hX}294b6kFY^y7N|adi*#!(q_`
zJ^w_WX|QgLKiunavTjzN^Uv#-OKo7sH|eKSp%v>y-uLqUAb_=kzyfIZeez$~_c^Y=
zXL;;@7w_KpQ%Ubk>2GD>g0m+xmVHyQEBzyOf+ZAwqw=z|>s9(kM+Fbt^UjmUD2XfC
z+P{~w<)t+8Ki@v?0kLpZrhk?uBZqSj@tH3{i5JD-IEnpN92Knu?W?0OuS3*5z<OD7
zjT5ICTbQQR7p1z6uK#Joo0EWb$bYmD7%Zll8$aFvpY8PXUG3vKbV$MuFTTG9CbM@Q
z;*ER%rpbJMfCx^f!kF8pLPrv%h<EPi5|gd7wYO1tpL)$IzuUGlv7H%JFrvQ^d*X@M
z!Utc8Hfl>C)`U%TfkE?GKJCM_6C#}r5!oztuusFHsxHKrB$gXrD;3OY97`qcv)Cnf
zNOhjuZ+}Yu6wVZ8m)c|u0qF0NgX}o5FHQv#&}OHkU26>D^i;+2jDqCDG_&yKN|LL*
z%u9vmq9%lA@#|S!hy7<s++Xr^Xa%)$2Pu-Ex!Y+mpGzK&E4uZT^8k%?{&ZM=0AYv2
zs}H1_GizaN{)hkHs(-7a(4hP2j9L#!9|wKWPK!WzI$per;7=ZrIGSejUk!64+M5c`
zOqvECC+g0jnL);Pr)GKMv^&dK`*yW_#iwNi#Ajn2&BbmY^%kadF3+3+mVvyM_gIMt
zSjI<=b3ArlVG<t?M^xm^GDR6Ny2|{gh!=vLUP#?&iNKzcPE{0{&kPWM!DS^ef#Qj)
z<ORZeQgt8HK@X_XlCdYBDU43pgp!jS%QrtR8be`&S`8KE)+erA_;dPI=<$S4B2{`D
zZBl^5a9si*LL>&O(c%)Pxi5<pkJm>wQ#}SxH8w>#bcxenZ$RV&HqCHj36ZQfC?%nu
zaVm6~w?S`6$wxiQb7NU>KyO&1I&$^1eu45N23{M<<uVIoEG3OytO^-aPYe}2idy10
ztWtGi)<fh(Ov{W~`ck!<Lq91=a{<xKFGd*nOq>fVd_#jee`lQ!_I}H$T%W2%SI_K_
zfJ(%uWMH9h(~0o#JnIAdqQCJHL7S;EM}5kebv%!2w!BhQI!W#cME06+;60ANd?*H%
zbd08|T>ti+<kK!nSoGCx4T&l~3_bTH*iZPGefOP*>OD5;o05C<L4KrfH!!;N%+|L<
zUZJZDshT2iz`~DSo_gUQy^H;y16(V|jJ$q4mt+Oe>5cOZCx6ds??;}-%e3_R6bKJ$
zinXzhCoMY|ENfyjb_`zKcG;8@S>5!ux8zNKA6f@vgk=_Xe*Y<cxd_QWpJHwt!|bnX
ze5ka>jgz<cODB7oivFkf#YTj}8F<{5X>a~a<#yl<<VzO6IAN`+d@23xV>jBhax3X`
zpsY`_%XYe_f1IRu<R++8wg#4z+`FJ#_u$##M}oz;-7Dl^1Qkv`z`}vnP4$F`ex+CE
zwQL#zdhUCBp$pPU0_GwG34_iYGcc`ME1Of+mot?9<9wzOD^{qa=Px9AV5V7LEo*T`
z(a8Sm#N^-bVt80`8>i&ZA|yXw3g>5{U&A4`|LVNnsk$W)c|?gk<w=nn)MF}Gs3%RK
z?p>4xzUi5(nUl7wm>!7<z4u+P>Tuun`@-bh?D=57u<_l;zpsD17Nn>5!IqiW$ld!8
zDhQC%V;5*h*9?{mM(6!i`vxSxqX!6MiS*0I9CO?Hti~o00*UfRFLMJrj6Rw}!iZI2
zFCSXH?OPK}w%+rmWxYkznXdsEdw(q8fnasLAba!Nq7)Ma>#Og_w~JXfeeERU$CXIK
z%JFasKKuuI@_W`kjVmmsGRd2Cka>W0dEJLGODh!Qnfm@hNUWJn6%_^@!lu-geLn;D
z8M5G`gb$jEEK>R414cy1NflGMjo}6Rq56NO4PgZ`8|LUiCjelCJ16m#4t=6R+#*;^
z8<S0Bl5I$H?;|Jws*VxJ{C+CLGu`ibqB8Ej7ZmhMgLhz@Yg3rgMJZEoClo+HFItih
zO#w5rmG8+@TD*$zTyZZ^33#sjD&Abii4<T1E$CkyOp0G;(66Om#B*Fn+WRG%(MEkb
z{#9BQmDMarRCX^ZNSR%VO*ZLcAw3koOad8%R=Z<AnlyTT;L0{pVOXm$!qE(?urub1
zcp|k%3<)>yqTosC^S&IHsJ?!qAO8fJ|GT-QSt6?F*x*P`aixAR|Hm%&gJm2|HYR-t
z2u>A^hXWesTJhN;=`W9V?SLW{AfkUHHaU6Iekc(w?~yq_?i@5zR86JAuKT^d>7&iF
z>VU)xH=7T)`iiI|9iTu`@lHlwlgRC1ERuotl3`-3T>&GO3xfoH5?*C9HB!hHSWT7|
zV|WBWPQoFEM5;UlJheI8c#ZwYCX>I9N2Ib|s}`hU)8I5ZsCwE|q_$rG$5vv*_ThEF
zE&c$f4(h%;;h8r3shg%l8w1D;*23==Bo!y1htiH39eF&!SOQZ51`T8e78{}Am&O+d
zP4(ML^rB!ld+aT>CZYqD7XyfzmE_dQ4_*>JFoRFz4&r7lpA0LYJUSdsA5ah<HqV4y
zIId98DLOQ9oi31ha6k0Uu=Xfk+8Hi7ZuWT-stX|$x(mt$vfZSvkoE_DRHouWi%rJQ
zeE32vo~aOt!}xCB^19_CCI(JW{lN4EK9k}p;;Z;4_%xAOyb!&bM5Bn~ZpkmN(09F@
z*L^OWTZ@Sbx*WH5IVmXi7&0vgx>CM&r9LR`&RSeY(A7t4R~bR^V{7r#@>fgn;#z!`
zp%l@@wIE29a}QqHzOrc}D4`(j0le99kRnY?5(ot)bJSf3cfM9WONeC{Zlsz-u!s#7
zicT{005?6cdUq<m_ZY;rGV7&erj`4Qqz6ayQC|0WI$_~f#@RQbF)8&zz>G`2{TX03
z>9o%c6AXIbyO(`>y+f^Vb04?mBujn?^xvel(;#8#d;j9@y4PxTZgnZY5K#}wcxVQZ
z!9tX&EDBwC)F{Qq(t+t>UG?GQoMY%xQ>kM49mNWBHsRyEf*vc6h@HrWdE7~9$EYvq
zTXj#VpoCSh>H0JCYA2UX5vy?tN0_HqZf1iV2S%upUo4lj;8RypDlj>~gj2U!adGUz
zfC34iG3<1P7%%EAsT1o(+?FJ~^g2UbDEY)BL-F4rW|5&TX6iB#Y!g0q$7k9X`A$2+
zRC5Mgc9tkjPu(uH{m+Hbb;9m`wet)=%XfFMy~^MYGH**|$*4`VIn!MWo~u4dxzwMW
z%QYrg>La#sE9op`GauqUBb>A`qP8k8IOuG?k^I&hq~)A#xq155sB#i~%^8w>I(_ii
zSz)=9jro$nw2}yQN+Ajt4Ukj@&LpM?sIah}p6tFflTfdmz63(tvN!Is<2HD$HuKR*
z#RCxXbq8<?kC7^m8A`8j^69x4Jg&Yp<lIlpQ-_%91vm+6$Tm8&P2Pc$Pp62M4jHT`
zO`J1@emKwb#ZK7cnUahH&wCr9JrdE+b%M_hfTR452FGu;X7sz5Q>#k^pl%z<TD2Pz
zuH!51&x9i(+yWrsK2zhtf#ct%g7CB`2!Lupf<Lng>5(d?C0@C#HOz#WFSd1@rJf)Y
zJ3a+MuG~EfH@%@)N(`W4v4et}Y-pPkxvSsj%iX0m`4XJ7YoV_t4hFQ{K^j(ODh40z
zE)_6M9y6@zjPTw5VF+LpiYFz0#3>}3tR{<)A?L*!3STSN!yp6ecjte2jEtLN$6doY
zsE7T$xr})edh+g%z>y7*!!646?-CmW>5Y0J(ba*)Y{q~qe41~#+1r%gI{2sDV!j7s
zWS0^EV~h|P{P35t{Wd^wnEqk1`ocuPSFdvGG4n$dFo1SWWYrQ{)TZ5zZ#*_4)4v%c
zd42}@^MMRY8+E7de!G=oGW|0{mE}U05-`I%`wud^X}d>nb4L2g_3_#-mY6K|^KjId
zP?N+1sE8oqn6q#F9~RYFB26j#SG97ZJ7d!ul&J(o@quJphq$~=zx<%Of;gDy?61a^
z&M4xbiGnjB2l=YZo2y~=Mf<=HgHauLt^f%nEHtODqW0cL&2baMC9F|>Y>;|+O2a2G
z@pcM<RPjv<=rq1sI8|hFfIju%7Hr!Xx&2bS!vSZGRv9=MF!(Ay+_DeESWT9?%sMjY
z9ODzAxDuIqjaO$JGO$=%jZ&<1O!>*Jgo5Om5C^Q`#U?%dyChR{YQF(-P!HKJuraKM
zrSel*E;wJ9JIxV#Xo_9C<(D{Q58%XvM7|wC4swZ<+tBDhXb9L@OXU2C8g~S1qP#Pn
zpKor|CI<sc!a%?{(=XT?X6lgLV{Oy9-SPA!80FRP^F9m+r7-JWu*e93^>G^%=bOYs
zO3S;I)L<B=4#(6g3yxC@?`ejDo9c%q9e7i2J0^b<;L#xooQ)LxgCtmSCYemtSw1n9
zbOr$%6m{ztCUYGp3x(uHhmFVz7xp>R?@apHmRFn|<Wj$2K1ji<oXx?WR!e-fT9s|m
zIIKV%<a#ln>Z1KBZl@s|8G75^#VG|fG|+5L<VhG&eSe%SuQ~_0K}AxeUb5Ix5EB#k
z91Go5;C5GC+I^8ZLtUSgTv%&!sS+tv(M{IDxVQ7}{ThoyCxcDJaEwK&3$WpEI@VOO
zm0(Qzty;6#AlBViVs_qc2(!P%Ige5xLEZI|LDSmI?;_;mD_>N0(zp>a&fB~|>UVm6
zKPEIu8Vx3hWYaP*AB5#4W+@Rk3(*<Sui}ctj9ZO5VU5VIz7Z6$)qcs*{si?Qi)N72
zD#dVK^5==m*DeZi&0oHLrnF@Ja)M{+nLn2k?PlfJV=1Eh6zSL`<^3eh*yLmF+BBAG
zQEFh@s1@}yBeeZ?S2wj+-ZhwD1h@5ki1!d<6nmFVc%+oF0%fe54v)i|<CW5$$^&$;
z<>PNS`=~%C8l!IhoJWIj0Y|t`Pj+4qDtcQF#yIBTWUzxDV5SF$jKT+qJW)kx@BYQy
zG0v};{2F=G8(Co@RTT?)jJLbE*x{g{&qP%ml-(evrj7l1Cv&5v>D71B6T&{gW8Rh{
zQ-*A}6Yg{9uR6HqIn@6#ZcXLjGM7#ej^~$j6<AK}pKBt&EFV3HGZ+XLOBRbJ8WsIG
zkYL31UU9ChP!YIDp!V}KN;cXdzy^VXHKlyZ{mPlRE1xO&zLzHCKw#rVf4HeM{fa}S
zsGig%Z+D6=+*W;q@uH6J6dh0OVmVRDP>W#E4b{Ij$o}>9qc|lwiqLnZwC-~<1HO${
zQ2vAYhb&|Y<uv4(6^>v&n-rUUS>wc~<_m_gCz4!Chen(kYjld3SdyGVo8@Ocm(96L
zP~4jh7BtCKID4|F9%8ySz*MXB{N%^cDYNlkVUXx-mLiSyLL#Tlj7y&_Yim+F1L8(h
zd2a>aH2X?)^cbn~E9V>^3}-cI6b&hn&1l@AR)+)UE9U>RRca~^Amk?#Qj%NFrt;$$
zdeOYvqq<G*6&L1=u0S0Oksz+^A!9xbOMqw4;}WWTFd^2vvWa?84?--x+eEfRy8U-K
z_l~xgXVpKJnoObyk?4n4N*e7T@y(pvkFIfQvRN?miMPsttj;H|DQbA_i6yC@C7##?
zi>Iqgv=-=Y@4E)bn3vpV)~TV%tP*0$22Fz(AR_@{1mfnUro}T_N>47kf+>S6>27e@
zgp*4=B(3Ow*p>Utk!V?fTy1$SWxbs^2G6Cef4bB0Pv*&!SVmHvH`mF*t9*HbC*h{o
zU0FqqydywwEJ_)$_meuif34t_vj39vAy*sdmv-{xh1T6<#0Vj2L?JPPycPlNWoU5|
zFQp}K4NwIPV!%UFJb*7Dg;Q83dLQXW%-~fd6oG4DiJ7AMF~`~608+lRWr@}mo<OT&
z<<s}04|vX6muZH)>AJ!jWLsr;<@fFZZ?JuxX@-Dy9AAjz%~NGMm;UgbbH43#+qFB6
z|GaCP=fjv^fA~Y)+x?%FXkQfw^XNYR?*65}0^wc{FMfH`eO2&+&wp1Be*gL_7(wn&
zW*5|n7mD;7%3=y5N|J_ci|d5d1Ta=juiAa@gL8_e6?lRzBF9~!5vVCOdrn2&$Lp!w
zqS+#XjI#sS!n@`nB7498U6n-vRddJT)(f6uK-Xn(pZ|A{=<^Mwy}L3e|7fpQ3F+(v
zE%dYl9*rR{xxHrxwHBZLl;TK)wVr?3s8?i{uo49X_}t{&M2MyUScrj>z&WBw?9on;
zxDz)4hL3&XKiN;EAN-K;9R+d+xKB310C%BtY1v<+l<M<SGTT+^URkSzlqUQ>ke3t=
zQ8`<8=A2BEkU!&!Y@%9dYvgeJXxTbv2)#XZ_zbnawNv=CmjY6>sZyaqZ{k26NNC=Y
z!DwVJF}G{{1-_;{2hI^mM$}1_>0up~(N&SSV6TxJ#IJ>&0j1>wc`*WMM;;)hFNWx2
z(UigbO#z-CW(BJeGCaQ7yk{Ns`8t;E!k@UqvVYe4Y89BVEu~i`M6;jMm%6|CQcqbZ
z?h@g&G8o4dlYR9T*Jp@gI3ZBr&R{A2E_$Hg%F#R)@XIlass34NHkxxb`@990arg0v
zkzTM2YaO;{Ms~W~E1+FZjCH(OmUvdC5u+QBO~qh#GRzvIen;{s2<E)Ac#-hcbN!46
z>jzS1Ab57I{2h-*iut)=#X`)hM%Y<jQ!x&6^Bn#HDG`yHrIOVG)>q5b2}SMMNP_wo
zCcER@^45qo)gXfvv5%CZ3Rr-V{|^Kk@JmL(Fq1SW6rLK{U;uEd|3FspkF6LQ3303#
zq9v95^1Tbx<pe#@r-S|Wgrw?G{&$zomU+B!4bJL$=y0n**^K8z{?Bu}Ynds>or%pH
z?k`bQSPvT*Di8`<6iJ|ZlT4_t|K#UWqYv(0Okt2l^oZ8R;=dl(mbD8ROtLRlVdKib
zOU*JJ+&HHF)xVd<_psL<d#?^UKq$4%p#X@^87hnCNwRRFYG|AUOqG%&gw6$1<w|{%
z^tDOCTbF`4!{H~UD^ez&rF|4zs#KRq8J#U46|>1HW?woIW{&VFn!T+_IBFTyJlmB9
z^fa3lP5Hdwn-(F>DvEJmLD!0HrxhuxToRsH^xQzIuBfP(btdOsKl?@wpi2W?lL%Bq
zV-7F~!)yWw!eRTJ%SaB)i~?I-C57hd{X+7zCpV!;9rOFpG_=mqMTmh*#U^4fX7m!1
z$>TGL+7-#CPNX}oE)_*>rh>J|RGsNGq-yC)$>F{sE@nHdP-Q?bkxp#o16w4F=I8Q(
zOvjp+Xs!+uQE*DKW@~=#&qfv`hj0J}QASF$ACNrQpMff#w(P{g$!d_yp=sHZ?;W53
z^N+VWa38MEXNeryXB&=wElVWfIlu4cAslv?ci%u3k=^#G*}14Jk3lH}to<!5V1|v_
znq)qq-~}AH3{%%zuCa$ea-x=K4wEo{{5IQw)wIHI5RO;-QH^dD-$b%Qqt(G8H!-tM
z21>Yl{b1637nzhEJF$Z)UN4nBc=z(|F=X)Zz|L4>>K<x1kFv3u#(`jcoX~?k38E#_
zf}x4N5cEkNjy?sE%&Zgdp^mum@(4bj^q;h|7_#B=<*$jfu>BQrM4Yd{yWfZhira=e
zNT}GOohqY7Q1jCM$T#z()Uuog4q~bQGMMa~fYt_1d4DD<ZHfC6Aha7!qk=}DEMMA$
z<Ss6R_UMnxO8RTewS8{c!*{L^n6_qId!-HvNe+$3BZ%}*Kq4#Jtryr0F9ID;c093f
zFedd|wjNq&{TRs<$v>+z(<x!jx6LLprHLWTS*T`4u)6E)a_sC|sPg$`$LsN8zGa;y
zz=E-%lggM!agsR^3I#zk&4P6f!`U(*cHF{m$>Tv&>6pKH9}G04-Y&3-OG%}$5>`37
z)7?$$4d186DoeJ+ev5h7QWO|J!uR}O!Q{R=U!ZWZ4u=aSY<QKCb;NKPeg_7oFHVUL
zC+P>5TkyLoO!LbPHZq0I6N(h>r!4mCshuKe1V1u!(Wb(Rkzc8;{V4!xNiR{vLQltt
zJA772hPN7Xm4We-wpCyz@zf1orhOY33wez(+Z;AoT+;pWqGy=Pp(V0+-d~c<%<bFa
zg=_cKrOW;_a%lfC`%Wiu#yq1){Drk*fxZ-B?>d-}Q>gMSzT9g?dx_nLY{$!mY{I^-
zrCK5%2@AgvESN@a4MG@Ddw^7g_zB0%ja0m78Y+Sfh@9d$HdLrwp@-nfr2Ei15H-ig
zTBeHZ*JLQ$0S9RePBZC|&U**`b_svv{%%?fh>WQx)M6AqY+I<NlDHG#EXHT_MlPd8
zj+ZrXoWoP#Yw98Zdw-Hn*}koyX=ZmSB(`sf!_#z?Tp3J#PW#*P#fCS^ggV%73*zWg
zyZ_GdhQez-C#HA0v+_2pvAIkOs-18reT;Sq@hgA6Ql|Nf_s^12HOX395+59&7q1X3
zA4Y;oX*ohd#@CT5kA_W_x6+Jb%gh_b*@`*;B3>T(6_5QL`Cou_1}5IjjpLuOPqmpz
z=Q)QS$XBgEXr*0{JU?6!`~}5M$ZjA_IF0_vb%1J*UlsbaPTgq5!9*-sFeUHVjDFkK
z7z>%sOV^158kn0lZr-m%Lx!`DfTe<#{`g54AZ)Og<%&}WyzB#wJ3?Z*TEr_xY=yJG
zdtdI&gYfEAve6gD3ymV!CFX+J>hAlp&OP=cs2^5c)%~GF9d{GDmnvSDO+wtm1PFEW
zH#6H##W|+(&0>1>A`ORE^EC8g34@$C4LLr9;U!f}HSp4Cd#frYYc&s`LkRGX_9-g-
zgS_h0$m36>(4@B5)$e2WmbgMkH*X{Sp6t|_<Vs6Z;eR-n-#`5LFK<%ny4f6?s!S)Z
z_V^Xi+!p__cndb)h#kSd=(hr&+YyR<AVKD4uyR;5*XF}#WIjL14tC6XqWN|JrVCy0
zAscg-EPRewz1)X7OV#CJh%Q1>kju#Xn7~XK34$-ioFcXe5#_V~YV9BPg91CW!k{sd
z&NS(m5Xt%z7%dFI>u1jMOn4&AJiC7%OlDg-Uh_7;x?Lyy7{Oi`A;nlk8ZbdT+`b-h
z1Wsr_N({r53UmIt$RWvg5gmw;Aqr0SagDvi_{qu6)pFO<r0?Unw*lmG-yGlZjWh`H
z*+y{^Xl<l4>HIIWT1^M@*CUvlNU#HD866-*<SM42L{X~ILw!0h?y)*%AFG@Zg(XBr
zJbVCUIK}&H`N_T_JZ4Ga$%=^IGU13K=GxC~GR1#JT{$|1|BxLnfDz!}kW*L^1Y@{;
zrvww!m5y7BliWgCQ$l$t;X()D8~MT&Q^GYUkp>5mrhJi>DUo|9(M|`^2M*ZjMDDvU
zRWzCc%oX;82x7evDRi3X+jdi1Y2HO&^B)w^g+$hi^*mr^faU+fsr(MhCA;7vM~0tR
zs<!Qb_N`p+SqDr)GR%X5S;qg1k*cr_6@#N>%}Hw0?Op_ebhkN<G$wZOrL<sy41Y4L
zK2!{hcj_VX=tRj$sNNwg36kU`9j#^WvZ*1bWlg|E;3!N)2b!%zCQU<qdC?FTu>l(r
zh*y)x4oe2FaM1hpRHkJnrcMwG6i+3IJySRF8|KX5QDI-<kYZ0ZkOtm_$V+^exD^1N
z50*MMRI{P~$536S%X4YSpJ$`kgXP&Z#)H?;ry<yZX)M!^EySGrP+H>8mRx0lzCpj<
zsEU*fRR9aaEK{ltcx3jLmF);(51Cltv4$hzq6~sp`<E2rD8Oc+Lta8v^2eHp4_#2S
zzIbL;L{1K<wuzhg<n^Z>>kGy>73%Rf@aw46$ALA}HiVw6z~l+{W@J#);o>um#$#KF
zGwRZIPI9dsdQUa6B1?9_E%TV4+8HE~V6`lPDU7{>q|oHaBZ}_zPTli6O5Y;oj!;H>
zooWlXuETyl><`0*ba}aHy<<J~K0xGa%#*lvinOAMXx98CMF;{*AMl#)CH4RI<;O}f
z<JXK>7XL?2oqaW7ufU@&C+SMZQZ%G_JLJ5yOoNI}K!1vBENeAtNUB&%^#;iQBi(yr
z%`q*HJL1HQ)6|HCa*w|inpf<qZVZa>Z2vpzCx#GIb#0_FffTXr;}V}`{Ip*puSp=m
zq-w_c9YZwNpSLR!#=T@$-)T`(pd}9m_+*5R5!GOd{hK<Xd7)-Pmnw<Z(BDtFbK4qG
ztfGLiSq4dj5PM_6I&3_rgr!&_v65dCy`vq?zYv^~U&&H=989}a$V(CetCBw`U2$N+
zLthDl0;zBqCV(gkUW%j_SgtW#i+5$U9G$OTQt1OwSUeA$qSQce3#D+)0%F%-=GR`I
zuDPUqoy()C*kc6D)57oB>7pD?B6hv@e9Eu1j7Ey_dOh#fV*vx00|+Y=00AnBfH=?!
z#<2h}Ccpv{BhhPd+R<G?UZeE7fi$GF1_TF5BqlkoCTh553)E$Ci|Z$8@o<k8DscH^
z6w;Q)O5{PKt?sL|<B=Oh4=qx@O_i3T0{2G1b5vOosZhy#tn2oxCi@1fDy#0VW{Ty@
zpZ?x>Ss~h@pEcWmHb+IL(j{2{)%+~<-GgclSBKvhB;O_sfl2MZ-+ZU1hu)uivBw!|
zrE{P0{)I00OWa`Q1C5yYb{L>Y_N(Hg*;VwJhQCkc=^6DfoM2A2-O<?e@J@J|D^hLK
zd%Wx2bMf2oi?1L15{?#A>QrCln=JO_oGyOYIlHws%H)}0JzSvsfAC`kSj6Lc(mh+f
znFBFiZ-1or<T8KXxR=|vJ6iMLDG6n3kO2DOJuegSdIy;N#E--7vjUa45qO}D@kpKj
z^cAGJ!V;CwH5h|8o8;}&OB&6$_AW%q4+-Y$Nj-A~I|i2VfuCVAqz7hyoyv$t9^Y8~
zr8Xe(XCh>Cqzg;e(=qbJop!zg<pf*#2moiHdFh=Lt-u<(8BpX_JeBMHqNm*nxD_F5
zjU71DI4cddjDn**sO^?Upp8N({+yBjTZ2%q=C$hh-(S{hK%*F>0)KvFWl^V#Od)P-
zzmV)=z#k2ZNK@e(iOdz^8;-oEqCH{K>($(B8z%MuZhG_R;vM3#!H3o^K{3^72|Id&
zUS<p-y>$E=vA6KrKB)2reel+C8|kkK3l5bOG4wI?xsTkWVJsJwT{WhewGTtb@g!pC
z@T3vV=QEg;6LT|+dbzHdNLHzlV5e-6^C;@5D^Y~X=5|$RX2p0eg_@-?v<p5Z!&+rJ
zOK?;vfNOtHNIrE75&~+_9SH!tbb(YV*xXvMyOGA2Q`B_IIxX_ujmAUXJP*#ceTkqe
z0=q*7F)kh(6GnR*J1G;u<!rHU$1x$nK{F9t!x;Nuu1VK|$GAx~*A7Bw4;KC6&XGG$
zpP~J|v0$+RM-QY7WA{&<<^W6@js{2W*)_pKmTWFFBb<=>%u;61<cTd%(-O{iLGa@}
zM^LSq{>Vx9$>p3gkU--IWrJ@)QS@OaGtluStjS9HMxM#tqtHKJnwunCB(`Q!=A^pY
zye=5N<|wiS+FN0XQE`I)Z>N(Fe&-c!><g@E*Fe!W`1ILdD7+*`j9?%5SE-#EnU;TY
zng!qKqCb3CFk$?GFF>XM(%$d$|F8ANaR#L5D*WiM^$s>?P29VtIr#J=>HvJTwV#F!
z8^X<xe#9-)v(Hy1D}P%zHLc!4#KA2t360l6bxBCq<~7NOcV09LeNvzRiQ=I2a`v5i
zE&w*5JCV*31=PV4RyicV&n%?C^pr~xsb(x?MJCK>9VBtmPk2Nfs_KX591B&77^xdq
zw(gd08M=V3;duRy+of*>%?|g(ke#<XbYAce>IXiCVR9SVQ%aXjURpx&)O4}Xo-|CU
z-o#zK(GlZ64(?f{Y;McDc~*nAXV0`$@r4UwA*_j_fP%R(7@39*9TIYc4VxsP0KOjs
zd@Ns5C^KZWc-2*e7pmyRSB;Z*?V+MfGTR=QoPAd&)R#5H)Ej1cKWQ>hG7+6DGKS5K
z-$yDjN*lFfoM{0^{$*$i(Hq>4l%oGnO`fO+b?N}9b-Z0j=!DlTtK{tQ^9j~X25;Hx
zbYRnxx7JysVqmH_)n8B*8d>q~BqpRqJNY=7%8m9~&wKh<8t|*+NgNXfFg*Eaik__+
zyVL`BcRYt%bJFL=2t>l7U(J<yPbM6Eb1irP)ln|+A-52L)=3c<q1?ig|5%^3TFqgS
z*9oO8Su0*B=}ijMbTvZEzGJ7EWb@T|ozU@ow*JJYWP$M#*Ip@X0h&E2z=sL~PRxGd
zFq;g(W+pORk<`M%t{Xc7(`k>^wSYJ0W$@eN8%Qpq@T%s=d;vdJQnqyL3}6bhqRS$w
z$zn^`jmwn<87$|PPO*f9+BopA-?e{*(U|{i@->ha#t6auontd7wwjwRca<WaXF~;p
zpI-~bIE=FcD04vqz}!bVxF$JqUgU=lf!5j?bPNyy%cAhr#m_3tBL#V;60D0NDm~JX
zr`3^0v!9wo!NsO9%G;G}0{U{+SLf-;N0ITq4iL;wlktiIyqE<qBICFM>&u!NKPvf4
zJ6&!!cJAoU-qYRKvm+`i*6$K!JyZ&ky}@!RKdD%F{M7&%mcG|&p`SP$_lM+eCK4X;
zgR1IPKACL0Ae}$2v@r|5;nwNJK`<(OeUU>yJi|B}3E}>`o{ek1h!`W8RsUUQ8G(TV
z*lz`Jjy@VTohg9+mbu}(K05MUfG3AzV*9E4#J0iD-+8uPzMgGPZN4+L*`|;o4!&JB
zshEO=E2|hL@&nfA_0bk*A~=W>qOFk9Kbh*j7$n{?1s0i3WM3ppafOWD!<GMC=rMbX
z_8{9Ei$%hQ#L^@xxqy$^l;D1jMxhmeb^2VCm>?S(>FLY1(3qI!ukcWDVNx0cRX<Od
z!MnB}v9(<e`<A8RU(Wf=Ol=)Um0IkNh~^zu0(%c6P<sX&Oe;&8Y{Ixj3LI*<`jpV8
zij6lK3Kwuo(l>!Y7onFS$MexYfA_nbfI(U-R~viS3i9FuPNCI`s>zMgwEI6;hP)iM
za8XlZ(P9H91o_hQe-wQ8U-%@he>W?i1<TRDYD)X7C+8$^o)+saqtVJ|eIFBbFQIXu
zuZ_86W!xd2^A@^D*@ca0cWviIc%4T32B#^uyx6I($%WB{Dsk(+oD&pQE-^uv?h|sf
zqD%vBo}Qe_P7?P57C8=TM{d0Emx$$q;pPD96g$K$h<A{?p+y+q6OosYeHP<U`+S{_
zNizr1iddG+<0BN1L>imHckEZ3_15jR(3Lss{vWtW-+ZqXE^%~-xwWQvqW_`1$$-6<
z)}xg?zuL#zx3(XyTfEf7qQSiRdV`grohdk6Jt}rjP-2u^Rs{{j3=Nox&P1@jZw4W%
zZ8HSc$!WO3{###;cei;YR5aEPB`1TUg}A3O%pr`MERo65M))rpDiCf?jRWRaOS_}(
ziW)^S@BTr{G&Gv-ELs~erf_tWcQHQj-~P*|M_i6Zoj*P*k&*DWPDJ$--;N9St-g5X
zgGBiHMISdWE)u^l4c3MAI7MN9M7KcoP{c|DBatxOw-hP8BpLT4x!5Fy(j=vxB$e5u
z6Z=V6p=1rcWG(k(o!Df((qx04WYu+ObRTpf#yMRk?vXVAT)nD-I@LasYC4>38!M56
z=86{tzL7ab_f(gCIS6>s(%OLKDfkeQqhFWbYT#l+RH~>Z?*ks*z|vF$bzVE6v`1T^
z5MOwu8FUy+8i}~th4O3T<8BY4K3~2Fb4@R5;(O#ol~;Fh$WK>hN~h6+MT^Ps<OtRP
zGJ7`<(1C$<HAsvl`gHbNg3#=@YB}w85X;4SweDf(W;5}nd>8gp6;PfT7gJk=GLHA(
z>r2(3M6SAv@b0&12M%gxbgr1KD|U6%hBUHWKeb;EGqIofP%p=6NjEkPHim@(5nM-`
z8H)Uwz_x768iHdLS&ih3v4>=k;R{%}PXX`!;Opo1`MO|fERo9R6_8u*$oqPEdqP<s
zXVupO^Jd&>P9Sy>9`4F+shLg0RfQZUjFqZ3l7A18ghUPTavodZoA$Q3qv;Jd(w`})
ziVviLxAM>Ur5jNSI28>${Jmrj(xLi=)*!YCGS?mx1$+T?_uNqn`x!_@{>oK^VY?s`
zi};TXMV3Y$>www3fG9hyt0%joRO{b<o^%nfqdv`3xJc`u*vcX5qrkDzXxrh>#eI;S
zim}?G3%JqJ{-T|Q6p`ly0FMZf;gte;%K~Ea4JnQE(xDshNUEHc%Q&ng{ebVxB0C)m
z|AN*F;LS35n6fAY9CKQ2D~J!ZiCh#@=BBsi3gSvZvABP9y<pb;_B_MDa!yL>pY*(=
z($bEHe99MDyZiWOY6W3$Xo%Y-E=y?z7%oe8l$Zc8HHnA%@z^w1q>;j|hlol(!zL<L
zSp}!7=~v8_@wCT!F#$wLU8)tdsE8TDU*E$~MTe~jqJRkdC|Ro=d)9+s!h`k7#t>2O
z+r`uC<=gLyL1k4(A<85n;5k{)3|$bSSV-<KdBKhf;0KQ0s()<f0@bFo$dyhA*FHj3
z3HjB5@um8{1x(?3!Te&^K3$p{vhZEas&KBtlI&n0AuK?`B_q$+t>*Ua;?~pU_~sfN
zjbf=k4cuFtZ2%PC&&quRQBQ&lG(zLpxXz)i8MBT`mX!*-oW8ZtZmi{cB2;d$fVzHj
zQc6=Q1C<h+N4|6XC~d^W86K~P#_Mt$5;)%X7d;OYGG(vu(MPhGA^E9ngr!U!gRsP}
z4bLNMAfO8OjHZ*fo6j-lnnm@I!$>Huk-aSd9n)V(cHjgpR-MSW#_eDP_7!|voAco9
z?X+hXZ{5kJ@#H|4(yt2V%m!6e&oxWUL1{F0T5a5&l}nFk&~UQ3UU}AC5<kVNW%!Q4
zkg4v-qt<b&urF_0Cq>%+xfspJw!MjK`zFJdfK8p9Yy0r0ZBgXzvccU|kGr4a?yi^L
z{rc$c#@yW>A}VH+P!shQa2;y|z$-QgeJE0}&B5mgVw34-b;I%GvM2!GVBk~qpH@jX
zBSpY<BAHNO%v&LJxj`2lA#D-H_1p@XW$ify%b@eu!&D|99a6n?X}u2jZr+D<<oEn0
zLl#aZy~)TT<~?&u!FG$I4-fmhjQBbtZ}1Ia#3^Qy)xi{GA3?%Ak<il^WQ#?t^|FjT
z4{#so93pTYU{hYFc3C~|YAZy1dB|5x7L2HcUXoSu|BDE`df)tf(sUi=Aysm$w!Vp%
zletJ=)rB8^;-f?anUQt+rym^ASra^)!cHZnPeb8&;rB9_R3!XuE!Te$8Ub@K7ESnn
zNX`N*5+4cc#$h)S+duC)|E=w@1+g8_w4K+zpuP{s5+Amc-HzJ~bR^7-{yzfMB!KHW
z-`msD3&<eva`slt!`kiJAb41JB0HG!=+0G>oR}Wbby%Sm_q`rg&0F^;n=M}qo{n)s
zVwkV%9zJW*GK`zyG_ZGI4V6YdorM3;LB=HOx((_+U4&2KJ9p1N9mRKUiR#7qYo{tB
zS8B_^bx)?Jp8Qn)k82e7)}H%GKli^5<Ov-|o@sW(V-9*meJwk{>&1Pgo%{Zbdcqds
zTLk<+dutERF!)B_U!ecKuRL?HzaL;McSm?m;Z7SOby}6)(gwhw0S)T`5Woid9RS9|
zJbft~)=AMa$XR=7C<gr!ckf{xtKJNEhXYh$mz!fL;W=H}iPz)<4=@{nkI8yqWMMI~
zHP}7H;k+BNRN;MuLlFJ?V?AS|#ef(UWO%C*S?q~j)A`G<tK519#n<JQ2Dv?%D1?D5
z{G&NnN~`FHTVao0DKZy@o(*w(p;d=zZY9FN4nS3jY8O5gmaYQNw6^U6ohpalu0D*C
zR7RFeGFa-cOqxljN_cB!UzM1PMiIj9zT)57j#TR;O$_U1WF-s83C92I5r+K<3U&de
zdt}e<*oSs)Qg970JfgubD0F^OjvI{^8-okH-Ee@kzX12^PV2Z=4oyIOS<gpKNNOX$
zs?_%3ZBE|&Z^$c2N|;+YNHuR`{1Kj`ut;?(iOq9~{R*AGs8)51d@6v>-(IWwXmQ{Z
z+vH6ney)FrA{-LsJ#cjhxz>pk|2K7+p8>+TF_B!3NdKsJFQsQQ!A#8M|I(msrrc|R
znDj+ax+XFU5KBiB&&u)^)#*k7Vh^Qw!vOhU>o}b-A)>dpaf%sVD6)p<F&-j@$YgUl
ziJXa0=)>D-s3yHV4LN>s-FU9%dR{bqGi;*o^b}bT<|}y96pG*jJ|O|0l+0guE}!zh
z9^CdO70(v)&kxasxT=ceFim@~It%ulJ)b;#seSgJK$M8v8}a5)UmWUqGlIl(9@KZf
zE5-t~4c|v`x}aIF|3;ihy|jT3$yAT-h{~)+!sf_EOGaUps>qt}W}Tq<Lf4Q{JVJ3u
z*TV)m`X7>^IzJ>%yBjGs+VW1U=dHT#MKFr{r{R3Fx{xCCv1m9g?CuWtf6gzP+qt85
z5f&&x{Z$Rf?t72VeQ(7PF?H{|D4ZAz#xpv9hr_hY$>Zw#$NuCGhbJvO@rY5<dwB4<
zzl|DJZfHuUFfRi-w|QxH5^7k-DhWovwZD8RUtajE(J__kE45^lHb+^x(p|UIw}cQ6
zzx>x;Gp@-FuD){V;+YdameilbJgZxjhOy;Nvgank*tr$XklC)_dX71{=QnPZ2eX}9
zTzw5)CD^V$>|d=s;B)_hd`K3&^=*Z0e7Bg+uP6HXY;M~`EqsB_uXyou`1Ll=NU=|g
z{ug}K#vgIqM{;IhD`P&aT|Zh&lvqzPUZ?u3r(R!AXI8Ig+KNV?+0Fs^&u`<yCt*cb
zdG0>qn;4ZB@<3LcKt(RX@@rW=$x`9CE4gHNu`RMj;%mbR_C2>c=f~?@LMiWDQ^u*V
zV=Ut>?c3W#fm9T9xh}`Wl0QhL=HF;otderFL5-nytAGY?YM-D-X@Ms@kH}|4(PvRF
z*%~vP;T@Me5dq*`xM{}NM#qyxn$0O3pB%IuVdF3Kbb<Y)K7XTEX@>_=;dH^?L~T_Z
z21ra}0cESRw+Ny*Ju$F<+Xy;9RPKEHEus`aVqt1XWb;qHxF1}>>_x#DrL>F>O=0`T
z;D*L_0G9yq7ox1M!4WiZPro_MU_(`{Se=>Qz@q`1*%tfI!#iTT!v%VAgk}pNANLj&
z0swZU1});^4(_LDDR6oscT1`#3ykMDHL&Su%pYMdxRF!4n>!^g^5ysS^rlQcw*(2*
zPQ;r{#sBnCffta}%`gv~yY$&x_=Dd}<X&L_tZ1#y{v+jjXIxi@!jJ*~jcvrHtY@tP
zZ`vm3Yy?;T@p~sj%yAO-C;~oQ%h{Fa2)2ZzC322L!1E4fw%#@D2v@W{Yi5?#q+9*L
zKINP3Q7#Pmk^B^yX^7C6;x;is4)+qfHtkvJPL;)qL?NkK@ApL0X&@x`w;!VEXtunY
zcbri_y~_(G_>7*~pDF2Q-O?n1n2THjk(VYT!XpdX1uty<3*X|xZ;D#oYaM&|MxQ@e
zadX4uH=>U9xjkH9it}ZkwV$&fu%yz5O9FMNC=1}M?ge>p2>fr7C5>OzXRy>^#XML1
z<aLO!<0`2@)~1?R=J<)E_oDgcjvye8PHH*)Cp{YGkY6nFX<=Lo2>?<MQ`Y?(+;5ai
zK{!?bZC3j<dVpHR*_R`Q@@1J9<`g*5*PBL6GnUbq*_iBNdDY?KITPmfC~&_1=JS%p
z`R=n<p*^4NgdMWtKSixxZ7-zzZh}=_ox-XuWkoQ3hAU6+oSmpTnE*YBoO+UQ01YoR
zMb13E#>y1_3s38ouR}4}!b1ef-sO}4v5{V>K$pa86Rp--B`-yX%vriA6f5OK|8yQj
zfi8*2`k1=;&Qlu_zYO-i8a)rcmo1@mP&@+`D=aYnI<m3d#u_a5r1tVpp`i+dD(?8N
z3LVFS*!aR}?<WkcN;oW&&!yZUHE^36Ey*QTkhWBEE40eKJu-@jyNPzy+F(fxJER10
z-p@QptEewxM@wqMGG!BExRaGM9#1H>+#8I0+%ob_hJ~m1iBeL_GifLAVmScqY(9~v
z(o&!ha&-DEsTuC{O-c<V(`l{wlBj7@(Arxs@aBi7TJI8g^VYz$0s95?DUWXrXgn=*
zHS@~R?IA<|-=|M76QjV1Ip{CTS2|4OUJuyzGVc~fqph^7?n#|`msR-GwoZjno{)Q6
z<5lj_tI_i1uRDBiEG=9*T|F-hX}=v`mts^TEGnKO0bj>Qj@__7@(NOH+Yospjyt9U
z_8XIv1>LzBs6=c;K`z>JI4-J9C2K+1TJ9qwcR{U&=t#<32;&*+g!uD3&l~Pi5IONS
z&`lxon~R$pg-xz!(d(&ba9R9OhMjAeR(77|yWe#-(?si2#E#EL`Vds3>(oT<bV<WN
z7a8W5T>V9&qsz*EAgeU+o6OaNPdn}@=jy#5G<=?^2;;PTlhyjHNjT-~{pLWqFrA)|
zrkd0^O_h5JYfQ=367lq$tH6r7CV~mt`lu6;X|5nuJvEs#bC`d&8T;m8h?vy<zK}{v
zEArF`TJdlDnXAQ(p_YAR8}lC%KiMc_MT(6o8=k7pb)34W%y_UM(=cpw@rCZ1LaAF{
z={jfVp1wZdnUo=2Z+wRvZ84FV-q7U-QI|oQLPGq}4Lfxy>B?kbQaNzHcCF?LTAf;%
zviB~nKKh*4Cq%gQynOZClX>U$Z=i*r({_?P#b-C4ATB+zIi*D4(wJHNToW{-urj>;
zY>o7#Ln?~D;#YF-b@ZR--vrkndN{Di#+9*t=%vy26bjiNy)!w9Yh6N40BCIl<Nu@S
zPQ#)6A8>&`#tdU0``Bke_I(+$kFh5t#**wiAxTAM!`SyV`Ps8&DI%#bc9JAXDug7J
ztwJ)#|2pTqofq@!xvu$spSkbPosx8tlMM{^({F-r*y$|+1s;o%(hQ!-su3nhK>7-D
zZ(7g=1k^p(4^PVbCc^QWUvT1a(<M)<6j`N}EbQX6WyVDA<=ZvNB)!kN8jjw^>=%sW
zoL;4Ns<|5Pda+M)m?qx8QK3rhdpc=B)P^9>8CVGd+8CJZ-}xlrSQO-RAXDSdw3#Tv
zOZX$;nelOhCbzrOTXus>Zw2jx^!cs6rT_JUd9dU(EahRIOcRO@rJ&l)CGNPGBL)vg
zRx}#q=s`bI@0t3^>C=)d0zo$d6h;MMIV|S;%d8Bu=}R(yAbRu5Yyv@8F+9GNwVk1;
z%=oPZ0n_3$7hIBCQgtcTLPx$~rt~d+&|m9fl|<OOm1CMh3i64LZB*gwvN4T&rR71n
z*Xmy1{Ym+<o-OcF{q(1QuO`6Y*W>f<ht&V*;6NjYt{q8Wwt^WKXu{uPm!vgY$(0yr
zDy3_m>NHy=I2356*<+s><ES27!3g<pn8||gRrMKMkd-PLa&FMaYdn$`U}Opl#aGvL
z2(c*c8jBVDp1o)I3o5Th<r7HkR~L;NHB2(j#UG=!jS_<$t6jkb8CY191yhLhvXG9&
z05=WsLK(FT)y<{|yvYl8eUmyfi;+_F?H=pW-7CcEZNTWPED9$`TIcUKt^A#!J;VjD
zalSvVM8TvftX&1$(aha}Fs1Xe+ozwZOs>nuri!`t>@iy%2-kx~?M$yR%;}y$nv8{1
z;jZ)Cqu+O@Vy9JCfv(u&2kM~>^4vGNt9&X_5qp76rp=K9L`(s~i@?J4F9)YHO_Mko
z^#yn$dBX^=JKqi|$?d_o=4Lk}>VKujn(c9!?2lwLKR!Juq4R4u*Wpjw-ZS4{%1Gq*
z5&Y(P?kWh8GSfk34+~7baJA?XNN_&2xtqnIXIH3a;f=B!s!_^+qc6e^%)|JYiH!m1
zy>2(ir+qkN)Yqnhfq25XR?Pk$=cqDv%@38j4OZ0u$+C(Y)=m3o?lbbGFMflBc$&?E
zv(wCCU^dd-uAr*n>5SB01zw_ucxL04>1S&UheOW8QT+=lG6}_1f^gqRNQ(E&6A$Kr
z_n7qPIeWfnFhU42_9}DO+hna!+CRK|ggl-zs_^ICOMizb11D~Nx3)Ulu8h%GmUand
z)SFRV5Fq5rs7E@Ozv&eF6*FL*84;)}nrzRwcbosUVbQ`Y^UY+#nEXPNCs~u-blom0
z#Gx{jY#%Yl0eA}%Aj}mUb9t58$B`Rpjzp2@^<jS7r=k7{b+LciGgSn%Y#L+>+hIY`
z#=#6<m5ZgXxQ<SbgDTPz7C*ZPvM>cj6FFw~d*1y_>awEz%d%bEg)PR*1#}RSG(1;~
zi!HFi>HGlQO$4o^ld8s=vyx&I$arR$!w4ZT%vox|z%`QX00<jjlBHCNY3G>s;tY0k
zW@8aM2c7`ahmsbBR*mMM)~2-OyAKWc?}1a2n;Z;M*VcUO{!$-^EG;`~v4deJr>#^;
z)2KRaF|;WmaU5#G<%WoqI@7dwu32x<vw4V*ju@es=)uAP5+6NK-PlHzb1l4jcpw%Q
z%ZzeNP@sLiK62K$j{vnXU4gY}<o)ZxGM%j<z64uhQCps~z1kmlK>J@lOBo)@Mdj@l
zjU2B}m)w}T{><}WKW+nOcyp%c<NiJK_|1#YZ_agn{MDKqzs1oE(aEkXVfu!ZES!@4
zwn@Lr7G96#KiRdo%aVT3RTOWUf=CW4mIgipxVIW)7Fn0i!Y^dZWGeD<`8CHwN0sl1
z1bTH55745w@MFF;SLA=4NvP&&rOI;B1?8WYX)I@dvh?*RPY8d4+N&tcKak#*&tr&w
zp56$Gifyr+CfyRDet4fglLNjm4T<Sy@m5dyAtHL)H8BF3sD(H9wJDHKC?d-CGxpZw
z5E&&i-9-4=Dd52^l`Pae(@e#q+<8M1MuL$0pMpusXAwBU)HrQMK7r5))Pr7+c0p&e
z(LogEpiEmTL=Vqqa*FTGr<tiFg)Alc)k7@0Gk-7=uyCeuXp$bH@A_sQ07KDlsH#6x
zEem!qw9u`J*r}9xAewN4_Df_SSvV<foB6Q}iF%lfo@GZ&Bo{9~PB_SmK1jy5<@<~#
zN3ant1L!h!E@$;5ZQ5f^J{hGpk=hF^zuI~MxDlX(6Vs4%bRVjgeKt6dZ!0@wkY4Y<
zlZ+E#wL&yL@-|6;b6qH5_VZyzr=?M1;aUr&*QOKiO(&TmyLpe8gDaAXxBKJO(oibG
z32hJFlLReDsKC;6Of(OAIVY$Jm-&EkrXoohP6N;x8w=_1)fD*yRG`YxmlVhz0L)LP
z3a}I0sY6tq*88l4<j2CdQ%|X=*1#p&L^t0@H1%gCUrIi%7Kx+(M$}%NtoQ3qxz#4V
zCQO-<x$E1;^g~#y8bt6C?FUrMQsKzY+)3OHD7U}NkB>$Ggye1E)XTBiA@!gpHx}iT
zsvzO<Q9D#+FPm3CHe<2g`=BDuj_EwUxQg7ra#J?QPAjo*gk;2jpGpm|s7~lhvcO0(
z4=^o@P_MWQ#0NLVbu-C(mM+uIq}LQ+)rNY?svmbuoV1;(o0S3DNcvO-v`<E}uSvl-
z3J&PakJBI#IKpDtQ1z4uJEf2%P`wPs-5PVdky7443LKY8C@rg9tdx`+k>oCVu{V)^
z)1quKxh#DI$Tm)sA!&*9uaBqx%qAJ(nHqSjoO~?lW7(OVHD}Z+lH+8OCwi?d$J1?c
z3c90l3mtluK{any>ybptonqc8jL_xg+_sQbWlVDMbW$Z1s-DJJ5Q%_><X0MXC$J{n
z!Dx#_jr!)&Cf?nVYkw)s!}D!XMlBGmLZzC@l*gzHVw<^FXl(#B*>Hm#0aUZwk49}!
zRDekw8?ekmFngFEhMtOz>W;6!`@Z4s)%WS2t0z8^NAZ?8z`>qgR?o`<M8SuFiexhj
zY~IFH1UtbQ(egF$Kc7`oCdKmNK5~^zH~Do&!UK^txfZT#qv82%GvJZ&Y==GuD|meU
zcTs5c0i)}y^e}Sr6%^HPzSOdY(Q7`Lo_>}RHeafdnrzpWq4*W@6O%)pJ>zCASHY&t
zC&u-}_tp6J>mOdWik&jD1V+<Srj0;OQh=${lQsHYzRxD>0hC#WV$wJpLrU*HnRd0r
z5zGIk?%RaD=9}2huP$7?7|ZtG#cOZ;U)MSpym6_0<J$SgZRm~rn>Ux%-gx}FIK%iN
zc^ZU)HV}~@^9Zno#T@qnRCK1>r=l|xGv|BBiKN@lkzW^kcrm?)&$TV-5fZA^1{t@h
zj_e}~USe@Oa5B2Y6p9~9gKGZ0)t`=$h&5`;qP|@#ah@6*&4ZbkoGaa2oJ(6_W9I;9
zlaNy<Z(@P{0t;Y*;nCX|%a{hyzp<q!%tNBzGylOCC3`;U*rTRCO-g%#AARj~{`>hL
zwR2ZR@u?3omFr9AWI%iPC$<Depn~i#!*OSpJya#bi(2A|XwSkV$IUyB94DvWD$xi8
zYamjp^cU*6=L=MfN|qlshP_K8<$xcO^d+fU-7NMq?8zC-9r>V`Vtf`NIbmBh4a1ax
zF$>U7=?rtbVfAkRb*22+`{w&Hrk)uyc2sJ+Udjh%r5EWT0D7C1^89I*O+Do7b|#jZ
zXc0?|noqtA6NdLQ?FLa?Rqo@V>ZEy!YXzgc5yf{p$-82l)V3HOM!{#lA|WWQeH3zg
zhRbn3w)D(T7JPghj{dAbM&+P83Jxh#v7ya_Aji!9Ve{;+W!@@C*>)pWJR4kRSiJqt
zrM7fTTdK?*W-s8A*K}*zQ<f*Upt0M`u6U-kRAvuR=p%U-5=IrZJMV>tzmYUX?BvAE
zU}+2<sliM$8{~=uX5f&s&DZVa_B*0Xp**~&a%jY2lJz3R)hUOP=(Y4bK8x4~ZYoZ$
zYJhf}s}Ave5+`$qL|8~BkXItBi3mz!jtcMbhxaR4^m7ec?7;T|l>|5j#Q<>LWQxAT
za$yXXKmb4gz#O`r9O7xSd5z6Sf%Q>^8+u36m72Jdo{X<ZRMes*Q_E5<I%h`VN`0-S
z3RKzKRJw0>O13Ceip-odQ((){YS-zN?m(_&V^#zRCApyf45(&?nZCeEzR@CnsU^U!
zIHXS?M22)fdU7#6Z|>66!t^4)6x8{!hGg_UE|4ZF&C!>)noPYL7g4QZ)T7A*U;LFW
z*6fo$<B|YP@_o^Gnj$qn$Rk!H-YG`N{bReplGrs=VP%&j6~00W9P1=}%6wYcmEm^n
zmEfKtbboE0c%Yj==<{u%{z_~C2#I$*J&66Ew#R3jGV9O$bt}TAVrk%O(a?Sx`+rgp
zY^=^r*xiISCfSHpVyt>=M<(Ao=XX0~Eo2rzlm?4JI~2J|u!Xp#9KIH+9wH+!8$@Sr
zA9;Ca`6a<Ns=VG4?h*=jF{iu_*<jUJQi^I*EF5CLzyOhjwyl-&c;6OxM^JSMh|zSm
zo^$M-v2N{sMas9Sj#tGJw+jTsp&BjJpyn}VmJg06jw01Q8B;Rn@Wlo({WC^}xJ~v!
zO^9JsOS;P{s_hPhjokU-+|R%dNAsNJWyx~W;x?Si34st&8+dO1tz8S%0Q2RAB>dtJ
zcBiD^RI9qj2J_!AkN#(JVzy}h^X>nV?ILo$3VE1Ill7qB%aNS7z0UerFlw|--v<az
z-6>8MY*>px(zIa6{1)2ulji|RYt%0RpDYsh?CpH$usk)SuVVfMzYOaa`X!dR=jHW3
z?Fvi8sJ#sCOzREhFPI&+%W+PRD`#>diU+s5g=eVDcXOcH*}5Wr)5(a^=f8}(A3aaJ
zPp$g*J|9iR;^8;5zq_SKPM@`>F#Jdj&Rs7~F4oa{+s&f)f_=UbtU~nYkOgVZ!NS_e
zo>ViMeLM5lHW_JFJqx7-!g%uZIx}%y<ylJnG*hes74nDq849Wt3;UV&S^ipZZ|TpJ
zo00-+A&iHhvk0=u3*JLdMqN1g{R*_B6QbqGh+#@`M`WO^caY9f`?VUm^_0XNMN~kP
zqsc~21e0H}ct^-j>8@P{t4=g?O5)>`D3w?8%zF%}WTU>wY&?YS23(@C?`a0?X<gsb
zPTs>5?djax)9u<zBiWwPoSLKdnnYXeKycRA1`OU&ah`;e>Lf*gePGe{O8eL>is|#c
z@L(Q%H&Y;x{XdiwQ+Z7VBJq}eScDQO%JO)Ko60DIZDR`A@GUTkNQj^;MrmJQZ{v#p
zg-^(K`7b*3h$}X|M7inI(^<{O_t-9d$k`4-KXJZ|A}jBflv5KExheX1xS|Af;!TKX
zPE0VJIpou?keh6Z7A^gAygqP>Jc7}NPyw7;uOQZwH}8FB<Y6!G8OJiO@x0GpQa*(`
zH4eH`5sVh~yYWB&B+z4`atD8)!kak>GhbJxisAJ0grC_2+q+gj;&h+Hw=q3(iz+~X
zXQn|m6YW_C2MN%_kh2Hjr7cBlgckmhND*k?>-5%Fl+nD-%i9~C-SUM&U<q}mOWh{2
zx?uMWMe|9HLd{<xCSX6P<<MbTyUU-f&qHrJy<Mqut(xMkOMmj;)^!~wN2)+x<0Y+$
z-~yIpFY^?8t=}dPAc*|q@`jgEg((T~NWMOhWYi?=e-N!!ka<3Zyo5-C$zE_Nw>eRu
zz@hzLjzV2O#X~7#PJ4y1DN400*Ut;Q(PJ%hXEnLWns`vt*qzE!UJ3b|+6GU9?I5p5
z-JHg!56>43-8*C6$1*A9`9mm!WRx*q%t4PE;P{X|3v6>RU3{dY%BftHN1Sf`LgkEf
zvptNtSHAQ2rA**_);*1-{m6|4c+4Tu4#pIu4kh-L&|wL}IpX@cyr(^Y_D%uhsV1Z?
z+|K=osvc2uKFakUuoJX-{Y(HN!vla?Wah82smStF06+~O16s1W4=^-aHV5vYhSP=R
zhYyQdUz-2|ir?9$?^)oC8BTCLYRad{&tXt(9$tx{n#>*qp$4>jS>%f(^C$-I%gog9
z-~V^EZvU%U$lo&K`@z5D=9*o*qP}nblAmw$Zom2W%S#2<1cu{8Hlx#ZxfIjj0kqnq
zs<MYAA5)t*zFr3O1im$M_?cHp(bH@nL!gYs0>HCJCr`gMsi?V6T-Q!`diqZFOZux5
zMYgabjm_Cc=ZE3(&c&Lc?f2W?|M@BW=rZdyCj~Jh)&LCs_YF|6s(rtyfXID4ip5G}
zY7FqU=7I_yr@6n|-&D^lgMGWA=@8Ph;QGw}^V^44exB&Z9TZNwer0>xGAOV8a{0N)
zmuBfdF0)LYukibmuHmD|91Wht_Ds{y;5LZoXR0p_6VQ2q+yBoH|K*T!VqK|54KWs#
zD%;qNq9QG8ER7uiK_it`!t%7>2#_QeAhvcP9gzg~rXs>DYCH@&V3807f@U{FpJ9?Q
z1-a_z=m31R&={9kTvabSPiIx#7rUa6d66RQTi^e}@MXPyl5o9cVn(TR@r^U(H#Q#!
z*vH`t@qqJwt)Ib1&)1iL)llvQk`O=IUUa9%&q*)BVs-+zHMz<q#E@Q9XnHc~vvijA
zP&OyIbSI@iHsEpT9P(bq`srKSg`4s%j~_6J1KC@7S$;3ro$U>V7vZkLrl<R6TH+jC
z8Nwzm%kT9U1{ubz#%2OV&c!$9W)=DbOSiN*`KgsXd=xJ<8Z;Fb^q#slepdPEFVq_^
zUwAurinL>0<>t-HOI{;_LPGBv%z|e7nf!n29;*y;TkEL~@w>&T4hx0!s*Z@=I#wM;
zrs=7TN!^K48<%bBRhytIJ~>vKRGrXMf1&w4PJK$}Td(>{{lCZR)5dK28n197@ftHL
zwT<?^L8D#)Epaavy=E@Di3zl}<FOh3xVXyn!bi1e%fM2+<ekv+P`|~A-rLtT7bD%)
zmJxW@elO7t_x&u{O8wMVhP39pSKc3#%W1EqaPjj9eu>=|iQv4uC#4iYcx9o?5-FW5
znaS?+UO5M2GP1DTslR?@N%ooUH$i@~Qw8c*Pp)FU)}+wo<l<}4H!hZ!9wy&sYsH|%
z4=*@y%UJfq^;|1bbpwo$yS2zwHFFF8B)*3kD%YU=1T1NZbVs!uMv^O0D*rgW{hjs?
zclIQom(}z7lg=zdx}K~3e}p?9?maP#JyQ_|UV`gJz0ni?B_e*&7hkmVdKsUj{KsA;
z=*5A9#N_WRp>|_bwhH9JiWi4@@ed`WF(nMTqZJBXy7V@d$#b?kd*Ppt*gzjeQEgwZ
zOL5R|wGjbJVPfgrAVE`hm}gHAr?#3EYN-D-IX3#F%Ys7iw`AwW&ldutm585IGOim@
zG&wI7t3dXIy@qON_I{RFo(7%PfO1wLo;P_8%@sBxpil_H_T=j5{)xT*ZwMjr?=%jl
zQriX8D+1Yw)$`-|JwI!0+|?b>($}S%k99yix~v2#QB|m3g_OXbND6bcU<n>#MBqm*
zX&upc=>`H=MK65m_xixIgaY=Al4HNAfl8(5_#ml|M&zFEX{-_-IOoI%%1V!X_7Jjk
zg=cvz2~?4uut-K0E>_|sZ#=jHdRV5##-!C!X&c&1Q&{L`irJ0S<FxFTIH~{OAJz3F
z4Hh9?pNazxMpGZoGmzpB#Tuh;s9i37Sc#dSgl)hHzU=q7>TgaN+8vq$;2D^p*YYP(
zo}AF!D2dtmO1pV!?v1-P*Er*YCXclL17^)pNtiV4(YEH8V@7f4lQe<pY$lsx2yc)D
z`QMSH8DZC+byX!zeKR6a%?9+}zxRIQ4w}ZrQJu9bY9gz4kc@&pwD>-JO2!18F2F;-
ziXqASYCb2QbL?D}UhF|*p1#KBLuy-#w&XmqOvdKNKH?Yaq1=r|1!t$QnU(!hHB+R9
zl+{*j{KH%~V4BGfVdbbW+3X+QWv7;_)mF#ha-_17t)T(pp+IT3W{YyNXNjEQ7{&0b
zP47SKKI(e*PceclzqriP)jh1Q6qVPsxTe<icq(2gx?29jSBI{ixu;4o-+yVnu|TrN
zAZV9Ua-VHW<I2p0S|?Vf7ZgJ)xpTU|<3zpK*E~(1W_z~YI!!u!er9ra&hCrm$t{kI
zOer<@gCV_X9<D1g(deYlwf2*-%H+8T82$SlXOfqI1>Z}FkWMJ~ym3i-;JgG~RBIyn
zkDL1^_f>1X$86X~sy5*l`_-NY@|r2IjHQigp%wH~Gi6KU)!;N2+Z`)~P+qFu{5n5e
z*4*GAHb;`~Gj`6YJyQRFOUTs|6Vt=4!Y-cc$25_&Zjz{hMK|b(agy@{W(L!B!x&1b
z@A81pU*cD8F&$8dG@|jVIxv|Z&!XagkNn4&;kO3zl%`L&;!_D}0tNw@58^)rXnK2a
z>a5z_dQ%{)XOa<FJR(my$Q5WYdRkL<B+=mUt19mnHP>b#q34k0&BrMA1lY7=sm`GC
zj1aq%(;!dB2ALnmogQY#_}`VFR@LsxbgQ_R70zpR<an_FT{4t=98Na{O!xUgPbGn!
z3l-?o1o$=QBh+f)=wqJ@cg@p+?;=4sT|R?z=2rn{Kio|BggeXY_$+)fhpN(@*m7C4
z5V<y=tWs!fW6D5a|I&@_^&g~3oZm$mu4+(>9m~<z*H~X1xG9$}>!qmRE~)iW$Lw38
zZiqOuD%2!{&ecO$4$%^=uvu9K-gm)PV7>s$5qa14%!l<HN<58Jb=%T&ifv>6D+8aM
zdO&s0Eqos{{Hs)%H-<muuf`qNu!`i6cPX|Ds?3BNeYyhE#E)rxHZryNpTC%WB-S~9
zOToJnQr^PI!Nx*6`<t6f-l7Gu*LPNi@3~YK*avwT^HGy-CwF!)Tvz6%;&N)SNtDjH
z#P2iz$gUOK*IPZA*azCaxLR-vUfR>GM2(SMTwk?aEcWB#xe*L#=%yqD$^tJi*5a9^
zNfF0BIow-!zjysZvOKKcY7ly{aPFl$U=b+phslsy>w{<6ol?wGaU+U5wT2bpu*)bn
zK)mJVptu%*a_a6es-3aS3>o>aNNl8Gbo8$I&A|VzG8joV4@y^<y=5RMl|i)fxq+?H
zJMV;KiXr0jE@H(vR|wGX71THT+J!>HWFuIjXdm1~goqzPEi=k4ehO$dOY!}WLHw;r
zo8{T&vY_qZ>*-iaV8o=?_FTQK1`>2dgA~>_v${_QDYvs|M~iPne!RDX4_;2$xNH9P
zO-0nxA$|O%U=5q(K0AZO7jC^C2HOz+cA`tYIKK|r1#Ve&jOAvSR2Dri<|`5yNe#q(
zDpSob!Ak^t{wJX3`rw#RA)6(@qF>(87KiYv3>E*m#;Bk$i0B*0VK+a$TJvjI8o;UN
zwrI*Q9^}9Nh(4OQim3#g77$iO|BBCiJevyZztcQsXoM|2$O)<#(d=V+#<3E?U{npZ
z0Q1AO${@O)v<r6=kroJ1%9!2(xN49=uQ(CsXoZWba5{u&PGOBTB;GFb%s;J|UtUhh
z9%w2<w?~?#bdP%<t|+@&0U98k4>;}(x=By$pzf&8WffC#%v8}dZQ^miCSb<D><v(`
z2EHqLH(C8H!CIcAbqL~MzaaQmacbaz{<8_gK-)kKn#%W*vq`>Yp$sTblF_O$KlEL^
z3_F6rU>3n3zGU3r`)=M6EP^1}knlklA^Ryc=Xd8$j1#~7leGUa*C~Z#6sUDrDa4_0
z{7O=eF$Ea$AtzkzMGq+_|5~STDd(74=i5^Fq*}Z|Iy}8LD5YPdnPHI1;Fgpmq&I->
z7!f%QM9B<^F7}IrQiK+3h4dh9k80sEAl0}5+}4`d{u=Js&*j7q7dN1&XW~)1HZ5bK
zWrOwe#{!P)vKAD0F@tJ1oooOm=)!10(d%OFb$&c`_+sM#tHCoB>ly&|QdA-;*3>t1
zL~#qN4^M>anP_!0_7s!lEGUBDKG8)G29}38Fm`CG6Kd{PD8>R?jQ+xBqF65(DBQ!f
z)uHhIvK_UizGU-#MwP`n-=lQ7vd>~U{y=fRhUeg|Bqle50UZ<#ui_8DXgZuD5#fob
zvcwxb!wSdbv!W1{G92R}Io=AaymilTgC>T6xJ?mt>v8(N<X|ls%^p^Y)1dJDJr@LH
zEK}bZ8?r%JqV8n>jT3e`c4k$8mi8>rovBZj-CS$3UnH7ry8p#Lx=zS_0PTMI<Okp}
z_e^252zUCx85mao7@L3aC8B=g=AwxKU%kCMNR4mc>TMI!8rHXwq!UL<{m7smJE(|A
z6zV0Ojbl-tG>-fcSUg39XE&5snIiFDix7+<9)lt_w4$1g)ZaEY=g8iLez;<?VK>>8
zsjq~IfEhh=dyY){cqVr9OSsh_@dS%JI74_aLU0YT=WB#-+^Y*76fJ|OTWs7qp=m4y
zn3ZiB)&v7J0e}r-l^TueI;c?*T(N5-2Q9n$sLu3&7`9C^oir{!#!`}o!eZ*$KxcAv
z*S&N@fYAXdun}_91bNV}p+Xa*GAR3EtF4-ZX8p8aG*N_fZjvRSHxLoph|>cptI%m_
zuHSHcCf)vwYWbkvxw;}J(?=gks7aE->YDKAfTF^tLXAo9RLE10rjX!}Cm^i04Y}Qw
zf?5Qr#npw2Lpo#D6-~e1@t{a-pK+L7GpwhH*vSVlH3{W!8SLLfsgMh8X@(mOl>+Of
zC$!Mta#J;DUf!0!?Ll(s3n^)#7#eL|lBqN8rqyWOH(Vrnqh$RZ?$`L&HA{y9nD2_C
zji$4-2d=?51kFVu_!fyA)|;B?1Xih0bloSL9)B@3twU)v7(l-o4obZ`V)QB{8uopE
z_v6a~6G7*gQALH;L<qkB<KD{6Ep*vNwLe7&v1w@0V4ojk5Zc%zu(?`JPh4XH-2BO;
z^+wzQ(cqMeJ8FK>QEwV&sXZA8Ob!(F_Pbeu)#6xazw2|tzZ=3DbO*!R7Vc&8U{&9c
z%~}RaKmp(U$r!*a4i)s6o0h%V7*<S6Ys4B5u((zKaZYJv0^`!$x<UO0I&MsVQ0n)T
z39zWt#MCEtOpcxl{^fDyxA>-tDpt!e2xoC+9L1<oOg<4G5?yMI{&C7g8BaO<G<0va
zFE%!`yJv=x53$9z`%_*hZJ5m~=ojDLoSF1*foQfU*Oev;6&n*tG~r^1N(9quCPIx;
zeWjIRK(4=5x}0Z+tScYrU2fg!=LWO2LdW68t6yBY$u$q?a^AyAjg8+7o4<?3rJRjZ
z@*e;0ew)Q$avhRZ=dwY|I-=d08sL!#;&nFNJHqPEuAPC^n=XZE$utW~;KEQFhQ721
z9^i)IFZO%`F7@kX>6<P~J2-0irvKoXGDvUC_GH`oCAon!rs0z}8R)4DYV%AU3&X76
zemwl$VhWDzbfs)(23t<{3$r%}0p#WIFt)XD0RC-pJ-}>^aVz!SitU5nOh&S?lo=1o
z^QfPC`wGfijF?FVRlhC6vId1)YNw6bqRIMfS6MYo!`k|Kt?-aAW<B8cnBMG8&H@wS
za)Y_(1G8-Zzrm&gT#(7z1EVOlNopg!{t9o`Lzij#7f@P%-4Xfdx6Ex_MRvi!YVjcd
z1(lXkq6?z!_HM*|*TIM*a%yg)gbYY!pRBKXkIVc%4)Jv%SB}|dONXTXY7UD$PuAU6
zTJiXn^82AYSNL*WIFGXo)5s5zGZ43r0}^f&8+5w^@coN7#pZ1=j}K+z(SB1oB&$(<
zvb*`AL8BqH|4g9ovD%j5>I1w*o2exHR@AQk`*0wdR=<7^-fXN|@L;)A#jH6ZuqWy<
zgz#LrNg~ctNgeyI<>%)>%7HGMgiq7A6Gl0U*0UO|63xFZxKZ5RsxAMZN$q_t8YSVj
zO#qrkNGjIAX75adx+Cnn0bvhk`siH1_6r_5Zfu>=k@wm}+e0`tK)=`+Su+&+;GSPH
zj_nTQR%-vx-+N+P{v3JID$(l^ZT`k-#zc=!c;J<5sbRRXg3RHai+_y`(|4N76HR?6
ziyi|h>tQ%(N7JIQXkJ^SGdN1Vt6C|-thdz=_Eog(;^$pyH-kNc{WX!Y0-b#ghm9S>
z*-l)u_VJIeW>7VIzNiM$qZc(_8J*8WtdrlK{LoOopYyT5Xz`(tp4_b#<7NL}PP|y>
z_htd5yR3pT-mR*2sj5$&DT6-|!$vnn_<o#9ZUNV?;tsxvbcY!1(~!ygKIeZ$@X1g|
z8cov=A_kS0*RfugPw%WT+U(}UWVww8^g5j_+D|5e>=*1+`9#Jq*lU@c=7_dimrZp-
ze(U>cBs^qS251kC`hT9#^aC2>NxO1ahecG#sJ7Z$r9-93_t^d#BPGw2p}&S*=n7B%
zbJEf;Iyt~7znNpOAu`#Irjo-}f23^E&@v`MbXu+Lj|dx@*OXtiL%ZS~oW8|=%fi7*
z=G7|Yo7Ly9E~{<hFy9Tgn_>la>|tcNW`;X?-(>?jk%FN6uY0t3aV49y;EA5Pxt{x1
zc16HvF|m<t%=LH6HxO5JCa7NwHn1d1uy`v`*YRhi@L4>ciE%epTk^3Jx=s$}`<jF`
zV83EuaZu&dom>3?r}5V-btnA=J@WMNaBE=vtF$S~*J38X>uTO$N(n7!tnd9vW4@=F
zrM}Vo_KB(JjVw1)VXoJD2SGPNDA6Cu7++c~iB>NC<%x34sU8znuV5Ca*WHy}@Nsvz
zXmhlMcy@lcMgG>fO_b{fV-D#D)s3QqKa1}rdRl{rvt-`2;Is~ivd{1JTHhC1!UmC>
z4B;VM*5GRbpjiK4?leYa$#x;Vy-zdkPkzwCINKWjGU_`9Ah)oF#frH{jQ*Ql`Oo^r
zuc*!aA<uD{`!XF~v_5o+#v+d!GkGBpXNoI~+*IVJjgdK)hOA^h#IfIoezHH_>>|59
z+KB3zcs?ntvWwo*4Kbr{NUcT(@`19WPNe_#3(sHo&V7ahz9<rIo7G&!^%6G(hr||%
zo0k*6h3Ggm6D5}7>|sY|6nee~B#vL*+hPX3v8h1rHUBvO?5a-KhgQzSa!7vBfK!=?
zmT8v``}5r*8;~1&gn##T{;rGh4P5AR2bCu}6$3v5=vP$@As0^+;$kkkgOodZkIdhS
z1_u56^8DndA^ne`5g3Na_B19lb4xpRXM16jxsYc0m>h3hnxLxxY<G^2d6tB65}!`4
zuVvmD`#Q(Rxqj9~%3j0yI(h!*?r2A@&pyrzIRBp^k%?b7f5Qk91p=}i@`EniJ6~y5
zp!*Af3VGY+%0}p<=k=M*tQ`Io^t>yp2-tX|<|pT6R011@3(gjWUwWc+?%%|pE1&w}
zhrz#R+@|Mea-VW0od%O4eMYj7h8|K{#cksSyeu8Qq0{_o#p@}GK5E7D7IiWAdA}(}
zg}iO`8fmfIysURRW+9V!N26=m^Cm|LU)kxVv+Vodxj9eEZe0EH5@}n`Owi@tWNf0n
zk<#J_N;s)!M9ggb_uR~qLG&o`yK5WviT=<7v{a62IBj7o>Dhk?33P+Kab|9vsqu3a
zAD2j!@`M2$%eGrEcEA4;K$cd;PoYOcti<`lGll+8QgSBULgCdQuYIWk(0;t^pMwJP
zaAo?}Tbe6G19Y7RjqPT6Qfb2ayVHHp8RA+&G#G?K#2#~RNQ8`Xe-q+sXr39DmvB%6
zo({7DZ9q7-rj__8hjEy;-}9Z-XTLNmEoRh;QBiG)1yL>!+K8|=1x;7ojVm2=m^Nln
z<R-|?)YD++yCZY?_MZV#g<jLLSIRL|nTC#p+;-{m-Ch<nL2vk`pSF|J7MgG!EbLd|
zKJHUJ?GkkVmnQg@n-n3wxBr|rytUp>A!MH|s9R|-h3O@r@U<yRoe}0cVX?~&2nRZs
zz&PC=f1h(}9AtZ`3*aY4QX^W~2++BuvHY5I&Zm398qi%|1wCk^&k*t(B@xlTp}O^+
z$U;{tzPEB4VkBZzYgAm}x68nLZY54iCWopnveBEs+3=g6NE<U3AzLcFTP+1VKbI%8
zq^P<RTV&1<t}coNnMbk&`!okaOJ^jsoj4GM-!!<bi}G@8U4ybiS)?;-kFsz4hX=E+
z^Q%PtT`6uS$qLjkM_#l-!2VzE(^{C5ekjGR8SEl-_ebHWGW$egz^wU(3Gb+|B6a_a
z#FaK;fI`$GL>MmmGAAPQyo-Wzc^IST18d@XKP{wJ=Vx!Y)|tf+ai8Guq*mgtDpPu1
za69kvigz@lh|-^TW*O>d+4X@?rv4XupNP&!Y^G|FHCcWv-e{h42vyUmJJ0BSv`l5z
zn<EmJW&^RQk>sBr|NgwS*~Y&;ru^x+q<H_&@vnDRE=%rw$hv%TcqX?x>&@4fm+Aiw
ze}1CV8Q?|?oY|*p?b4~-Zv;`wCUR_v|1le2vWVU?b*3_k0bRMn{1n}cQ#YxR#*I0h
zSG_z9V)?w(cOnK7nF~Z}#ROy^cg(aMtIdWiKuIBZ8tfTK%px!+OE-tg@d(OXw5!S)
zSG$@F8RO8~<>vYjVG8FBrW7yKnVg)f(_4#lP<8jeYn=YoU6a>Rw6rE=tHv4u8?;b3
zVK~FHY@)y@d){C_F?U<kRPXZvv+iPXj&pu8ELMi=O-KE6z{MZ_yp2A2BR5J!sf=vR
z@xIL50Zy=$OeZsqLlsXqDtJmrqIXZ@4jZ05@$)FDr#hoyGt*F=8xH8gd27+xHbE;%
zhlClgG9idVy3)~S)=)kc2T(RkB1Huq<inpb%-^C#^%GL(7M#*TQFkMZSwB@Gl)spZ
zygz8eQ>W7mj~u{(8I-7UJ1Ua0Jm9gNLeA_<R7-uuhPV4>1Q`9_JSH>;!NOY{DwibU
zu!eP(vL8p~8gra(JPKyQM^S;NW?LVK(j{aesn+u<djRDFdPPDfEob=1<RK#F%?C$!
zvusEgZoBJIL>pnF${jR`HRuq2$}iWZ@fE`A@I@gV&&Ph9!HBIHIcg|;4G}V%ll6*S
z@@lawXS-ddBrrc@gg4D1x}&2eB0ghK&T~XczZnhu%BW^3-OKU5P)c>f@h&QxC9InJ
zC}`N@s3JvCELt)WJ|V5In~jQ=I^Rqk(gE+**BJR&uc-_xXRpozlLZPR8$%e@BV7pt
zW?*`L;+4$+Q-3F;VBG;kyGj_a;X}iB=9AUgy;&DHvGC#fiOXPb$d#>Hc*8QA<j*6+
z3s4FUWI1ev@X|oxy>X-H6w$%llt9i^R<9stp=N9nXa8q~*7+GVfSK?(ic#^^2Uel!
zs%Kh1xb^35aKh=!r}uEl9(r41JU0(LBf;?kazN%KrW*mfKwT3&?Vx#d<hs+tvN)nJ
z6lq~TAc@I{<EQ7ei<)ZXwFi01<%oMmCv8O+B?Sa-^^^HLM>#iHz$#B!`{vejB#6^h
zQL3zNyhT?lfnyFS-CJLk{exj4tDo;f$0iIu8g~IQWaa<QI5cAiPM%0#JBD0D6;Da@
zM}Q?Ct#espykSztpABb6y8)XjJ)(smV%&#Cb`cG9BcSldIkM3QXrU*>YSFg`*6Y(I
z3Z}L!CC)V*=72gd1CKBf-VwX0V2_v+@fS>a?RWAI4hSikV4}NfKb>G72FzMJdk7Nj
zZR$D82Wb@D9A+ZjhJ+Z08nuq9An``lf|cw*19wN6jpv4fTsuh8XhJG@=?Y@5ThZiq
zb{0##I^Z;K%|km)v8JO%mn%BzKmW1bbjK<?L78r~kut93n~QvxWjP&{n5jws23vEX
z#Da6FyVL4GJ<sTU#y$_)5f&a1M7vjh<IQ@_@`cX_B-LLQP`@p#LJNvYU~$jZiY;vi
z?<5(zW`u(TkQ^kkm*ExOm4tM>WQ2^WdpsohDTXm-W}Z#NjE^7-A+Q&)0y@BU;!}!`
ztm{&eM-s+$1L`jk--om+bPz2{ZAMs!?;1U`%VcSvLG&Dq=wt3j(buX3qY)<D+k~2g
zVr{zF=Le=Yv?Lwd*~u{S##!XXZ}#><6IPsO^zFZV?QxhDm^mL*-*Yfi`UVQNuz{+2
zRjYI~oFwAC^Y;sjee%^?|ML%qhSDOSviyTHbEm0VweGX+gEUyhOCQAVflN`$(<E(R
z$->^qk2uqI>sM{^#c{PMPhr2)ZA+((o`I8Zcv{ft1aoOGTz0gmk4e>ow}q$pT1c7$
zqUu_0s9GpYw$L}^){T+k#*e?I|5cCeb<tsd|K7(<l9k<=4E|*z@Bi?E?@sv*(zpq}
z&mBT+`sC8UB#sVZW1I2F5oO#7EV4?_JN8m-tmq#ki2y{c>B@@PFdgqE#Po75T^Gc?
zFKq{^5G!m#6nYh#C}|j+Q}Fdi*z{-NeMRI>fz&hXoW>p?;-Tlt2q%br6T#KpfS(1p
z+WfDM_Hov*BWqf&b`UtX5U>@*Z(S4zPd}$A1UlBn{$iW`l?un32#$Ac93QqhmQ^^{
zA~?Ucaem+C+)?5B6~T4b#`SNT>%3WL*#L(qami!F*?;9&+=QD0^-hVzofVdPx|hfh
zdD{ai-{zg%Hc(|z#o1PcXhCjB50r=wG-@fMA6ZLl1tM*7N;H&TnPu^}20im^uWuRW
zlUKd%KaKcJ8nGBCgWDl?D{CZC)a@(C(J^lI6;?0MXkp518{<3Fz%e~;vLcRoy`@E1
zOj_{W2yecZP(D($$jkS*|E>j!8*YO@G4LRk4<uKnML`1RU!fk*N>!AQtE!iF?IBzs
z!FKG2efwAJ0}_wh<07QYfX@;O6_S&(5)0``3ZVSaETm*kQhEeRMpYWIgDh^Z(ApJ(
za7%K~gt=D`Y!Bkplw~<9l_Q7}+TPrQRVJHkJs<>z(+l3cET|Fi>Ga$bu?$Z~ik&Qr
zO;_<VWD3x^`vw99*v2I;<ed4YD)r7noZb$;lPfD#C4LylpJOjy)DYQizQQ!nXq$U#
zq;kw7ms3-aha{M{WP8krb*|T&6))3p8fz@maUobSH;0Gbs)VlP7CGmz+01Pw>fZrU
z=V`E4QRhMBze*9liWGk+iRMM|daF(F#6~a;g9zfQOETslF?uEU0D^rK!JZu;lD#QW
zPZTa4d|Qu&JJpD#BjLg|VrqU8wEAatJc#Qw?IIqz!(H77X-f3NAJ4Y5Gjh>xk@7<`
ztdD1Oenv|3ugI$N#zrKL>@x7lIY<iUDl^gEf<Z~YNpC@(zD7+@1uNgaB`wKZWv;zr
z);;YmdxNg_<Bt!Ny=+y_r|0qUesLc&h}=MP4;=SOhhk=gL|z%{K$Y%i8@29*d#rOk
zV-$9XlJwktU6*e2h_VGj2!f3KfxfptkQ~E9CG^y&J++rIA?vdJQQ{+NI_+d!D-Bn`
zbH^iEt{@lHuq$^@9ohV_(UVX1d6YT2<0_1)W4)67$Lq6)E3nih)|!fU!&k5KsQ`Eu
z+nNf|lVvz;7=D;rnEle|h$p6WKlyaxOeoss%brc^j$w7XFw3c5F(A2j!A1mi4l6Hm
zc1%is&q69+w|-4Ri$UM$f~4sM=?@l~&rK2aNfV|+5`o6<5y;G_J-aksjV`u3>?)Yr
z*Zdp>X2utB8MDBPKnoF)LZZ5S^;I+bYuZhF7a1-F-K@4>V2DuJLkmB6@#C~~DPtDP
zZkt^db`#67fy`gJU<l4ffI3htdA4X-Av%B4x$`z64Eu<D`}1O`cXJxXpE`^WJL*OA
zvk=ivdD8Ab`XvCL3@a2?o^nCxjh}euc_&HH!OyI=;W8KYwXbT(9`cZi9WJtwa6b8R
zwKMX``<`x^=daF65&15XJ0ucjFTZ$m6{t9S;x&IVi>?9SK}Z<8F^nAv8=iLNuDjOZ
zDD%gQ?}#8`!Yn?}q0(vZ%F&Sm;#K|UV8rpz=2O1Wjly+tJ|!k~RUwpfLX7|Se3vH=
zy`}g{W@Wq$PyZXQPAmQ<;hk+i<mbWQ$yX{5toP4E<Y~XVCd-=<3gN-r$P-|&mA?=v
zQPk-8LLk`i;?!Va_@0J$*6T2x4HJ5az?EnvK)BKpR|Ty}MBKKvR=6(+17AcmL8(h7
z2LmEU2)8+;OJ0mYd$oT8FH1GQYd8P7YlV^{v#cSfu?>x@6VW`{56=B`jD|eCk`NI3
zYgGP^mcT0lr$7{<T@7V)(fgJl`gReT>l%+=5qkU)I#V!aPsKeUK$R$HT;R+_){go9
z8<nelb0;F`skz%j9@q9F&j0pq4PB2L>xz5vC+?MY{G03X@4DhY{D}`3(47IuOI^2F
z%w*NPsHcu2VOTQShdYMZN^I^n3toom8OMqeAI_E>Ub|oD<;8{}kx9_ZYo|CPXSqBe
z*`JVB!J5>n#cE2zb<2DVO`_*BTK{tnMl(~Au2U|>o@p_PfZ9k~hfC&r!~4`FQjK}k
z83aI;P@q_(f}!&?ew`4@ebbm~Z|(CV2!0bOpw-Ro-M<7S!GetyJuqoP1484U;j4h<
ziq|l_7#bTaVvr~nUM(|*1a32Ql}WCQR)#IcT9-GR-_?u~h9v(Zz6SyK9c<GWN)WqC
z7d$s5fcXSQFB3DQkTjTU)X~4&SIAX*Gitk6`Uaxh%VeDRXwEAF1aJzhu7OFg-=rSU
zVLlrx5mL2m3j*YR1%O*#Cgm}I?T1k-<Oc)*qX~)N!@|od7hH*@Y8J&+azc7n5cTQ3
zb~j2G{#+=}a-l2DpaCQQVFuulQGT%!&r2_5L`u&*Q5hMcp@}{}?Hx0Z><>(L1`o9D
zF0Ty$cS*z&`*$1%FD2ZYtT_*RVkUJ<jTIa$^j5mZfIe1s3KS%K7V0Vs483FmCHsUh
z{i`(b^lDl?%+Dh#3pYCOPDy&(3F-Col`BaMf6*Fj=^t0Fv=TOAKyXDjyw!6-?0TA1
z8MDeIK9JMRzOgAbMN!{lxNGk18@?^!N!2|LOi6oK|3(WqdLiK`#AT3;aDV-LoD9Em
zlqe`Upx|q5i<cZlc=vh<<uWwC^)ji7xWmmTk~h$NzkpMEFk_66`@1riv4SgVp5Ex1
zc795Nu4T+dU4of5Wa6rLhDq;t2P9?(Dj1Cf%hWRYZwa&lb^@(CJyh{Y>W4v6>d&LZ
z>$1m5fi#O1p<SdW6vg=)WLj5}QL8EIyDr$+`7-K2V$Ms6?$uOqQ+b2<Nd49+?j>*#
ziuh4^%?g!Sz)(CL4CehIA^ppQp~61*mU-t=)$`B7YT3%Zeu(Z0Jz>qR%XrrRt2~x{
zk(Pd40W;wkv_nRDnM651dG}s=;4M<lOF6Uh=~ofI?R{jKu~4^{@-#!&x4+L_yl)D5
zD@Uk&2afwLn%ole<_|>*@bve<^aiBj24s5&6psf~^=O)LwAapTt9{R_2e{LT=jpxI
z4Z+&zib&z-*U%1Sv`7=q-%s>Lk$g;e^kigmsWJQjKJ*@$$^OO;n2Ei^i&~w#nY=g@
zW&$%PX7Fi~#C+?#6NetmoEY!a!8@aEwNZ^_s0X5BLEhG{EO{OQ+?%Ts*(s8@`FYH|
z;4{}G5TfW&fG3}kbeC+VjneVqmRJ^u4S6*YRK@+<n>W=*|6Hl$`nVPdt1P~Yw(2$1
zib1)$qc6RE>4OUUO=KIOu}Yg}PA`Tm51gJCA|NC-;YxV7v5*2o@zKIdJ?p$)lz>{Q
z04I`P3@H$LDE$}-XYbWX)stt~5_mp&`R5MijaK$i!Hl0b95a>d>1#soRgvWUXEQG;
z@u-J=RTn5U_H5~^V<8<kd#Ql>glfWLQi(Z_Ym_R{b8W}M58EfkMBH_X&VAUoDHeR^
zJm7ImgbgIV9sfLu1EtrI*>2M$Zg-v+#$Adu&g49dgpjnt)C1k);p|_CA^{?(5#btQ
zX*t$Y2>y~yOZWRR|NWVd*9JII!@~7nU`xKrrk5l!^5SLhgm-OO-Tfqd)q!W83M~wZ
z2uqRe<dG^R?cVU{>&$xE7$6({uPt~Yqib9wJ`l3=%F;uc+V^%JrBEjM$$G^ZeMTIC
zG&5S2_>JJ0MsNs&v$ZrN1Zeh`Rnisimu^g~(2142e<fP<wdgTjO^w&D9NNdE#BUCX
z0IB^Yd&WY#UM6$5B{3mfoW^h`X^H6j(3z+=^<3J%(ob%rA4k&`BEB8_GmC)h1b!1=
zbIUoK58NowDpl@^W{@~DP|LbYfK5SiShqjv>n{z0Ow%eX;grR=|3n%++2idI_>_y&
zkkwcRgo447<<XX%@))<r=9l<&GcGy0(WTit@?KXCE3ZsLlEn26F<P#*WTkS*0R9%c
zS8pcI*j+?0Qo@3+>3X&=uW$o-!T8(1qZ=UL*@*<;eUU%}vkB`_RhIj_8P*x#fg_&`
zgBXBg)}>ZXV?Z<|R0tDZQ4qoS{^FL*_fKjlQ3<Ab`ua<JKb}4(+nb_(Z|bhz^_b{)
z>h&fSj4n|c^Sevut3(*u_*gX?XB!-wT%V?DHqG64f5N2r8ammB+XMA}UU{?B2JFvv
z2d#epWI$v9IO5*kV<qShcR*xvm5iR*Cv<bCYr_b9z}#;yboF{_K5_m;Rnj8lzp;+8
zhjL7It5-M1?#e4E@ho+CldFvx`8n=HZ#{3ae*Y}vY}bzuy|?~^N=1sEO$ZhH@GKN|
zr?9FVI`u?wNuq~X%|2BvK=^>Ie#LaM_h(YdrUV?cu%Gd)!v3D(e}x`g|H=N%1b?Q7
z>i!ph^zZoZUpiNXQ{CvV^9J-9pSNL8`83XB`Ynj`1tVO#1E(?FlWghT&z_&99pBuU
zX<ezq`@w)N!|P=w$USRiz|T~FC#3PN|DAL#agEO*_rK%qLM!^AzS$<6mXZMu-9#!n
zyN?@50P2Yr;@(2}W<cmMf6?V%Vi$djx`y7qiTB8~^e^!*mz5Nn4>X}zXncQ&ERCA7
z47eNfF(sg!xpU`|-doItsq4#eH35}L;;DgEsY<06;BR4pO9so?{eiWG9;rcfrAKpS
zl5MjymJ)X|t%4is%2R_I8(YSMn_8Z+hBQBzvI@EX=woU~OV5w-kk)4>tf6fKoYtZ3
zkXqyjKTEAW)7_&tYgEyvY9XPWbLA`xg5xz<x~FcgWXzDtHheTw6-RLrmV)T3r^{Z}
zkmbu@a7<dfznuB^{Nrtpi7U_P46u=CrV_Pj{trTu=lH{71nwDsu0URNP#(%}>i=|U
z>-@k;_@wGhpo~}S|Ajhp9hNjBI!<G?49x?M&TLF}V=~Vx(1Mos8D=GZkE_bE#uX-T
z&Ld_Lr{DPMT`o-Lq=R?Zs1v4bJLw*_k!9`VxXv|br+?O?#TKi0EyCizj7LsM{SOz7
z<KdWx!c<&<c@Wz=))mNxcUu5L3zZAVHW~eFzBEZ}hW7Z<iUnog$;(3ZJ^O|0%~$BW
z*YzML7j7(+Cw%1P{tJe&n>*p{=`hJp+-lkCN(tte06gQ`*ycNkk@c;i<7z+PNw+&p
zf93G%q$>P1*}S>&FYPAKV!e8PtK$6mf5xHdoGG$%U|5#sFl0J4<%QNtl$vy|_jTY;
zN6ZU@!wLbs!u>Jd;)20Wa+>V(2pUIF0q$l-!04J#JL@OIVQ0kNKgResA)bu%r3Za{
zs}e814qb2VgXBegX8Tl9vZb=ZCo789mF&6nV*v~#?S~^C;o<WY0Vx2iQf-x50QpDk
zk2&xmi$zy(-Akrg{6h;wV<_iNDw(|CGQh~Fx!DZRwGZ(Wnvt;vx{VuvLFFsx=F1|W
zrDvB1k(!33MefnY*&g)O&w8y6RTHHLgEA)(nSnIgkheYGXHzbLPm$or7-KLtj#;2K
zg?ImCC;d?gOh(SeMqQ<j!@QeW`aK^0BbZ0t;E0w*pT_~<uUsZGk@;p=a>_2TkQjlK
zV3>wT+X@k`#trgGr&9RbPV4!;Ifxy33&9|tQ^xaiKD}Z%f8%2IWa#?E*2S_@Y<D7I
zJ~w}Mv6$D~9431}lXwKwPQZ4uz2-B$5H{3v#ab|3#IW)n3xLdT=UQ<L@Lm<7-tb;K
z_kU<Q({QN%|NkGe55vq@$3C{QH-yF#vteu@l%yJ4+0t0k;$t>rY#B>ZQPxtakV2{K
zMp8&csjShCR7B?I`@gRLopa~hIXB+tI@ftUpRdOw6(5YB3O#5k?z<f-a`aUgn{!Yr
zhbD=tmC@HIHcJw@t<|$JvL*-@o|%v!><r`Ydm5|@Ngs+piqAu?IocO}y3R9Az{{kC
zJ4#5tU?@|x-{Zl+I72qs>$*~xHQ$G)g|$$W<+;TotyJ<i;fiU*0K*<4X%RZ87L12f
z&AAgIs2SNp1Zi_KCq(iULjq74VmsT-OZ1#5nzWl2q_dxu!`>Q)r`$Plo`L9+ITjd;
z*J;gK3v}|zm!X|+2)Mz1^Y>LVKe7IiHbub|S9&6}0v}y7+1(SX_jZDFYBe@jKEHk-
zHM&zqY3v|?VM|XjW;DMM(%fn%bNS?-nwEurVd#u~J)iIGEx#tKi@@IH4whquI33m_
zR{8-Anp8p^6+cx*XGk|SKe%}-@pjg`uaU<ejEleBI{sMd{X*vP))|xAC!S}$U%r0)
z;n$<LPkoU3u=3>iqve~oQxZG*M9dR>Oc_|Uc8`hyuU#fI`P!VwtNLaayLta8MMrxQ
zw#@`5EBzmn_an=yh&73`S(mXzyhcQ{QSW{sI40P3rX6}Z9lW@}*BjcC7OcM<(dnhQ
zha+K2I}NWq&=I?w@D;5Qf{Orz)T2@znQZ?B{KxwPR_+!;pFQRH$E48Ss=?xc^ZI%I
z8EF}yJh<G$DF?q>pUJK3XhPNr(GepGeZ5@DN?49<7j=>hgR;qiY*bNQMcj*F#0AqS
z$vDv^@|nq8h2Q=1vh_}C!xPdOgh9i+m0e=B!G%)XU-(ew7JBu+*iY_vlp}ijdiUmO
z-zF+k?m$6TTO}JFRK~bVPS?07MrfT=+Lwlb4R<J@8Y9JBHd?J4>9^TCKUaRT)bMda
zoDQ(YbSHgOk|lSY6msT|HqKe5uRyJCVOiAXtw2$kqh>8jz=-CmxQFC&bK0fDe6=lr
zTZQWX>MJasf=~9{k-S`6Lyb_LK|iePnW38rI0<WS+lvj!HrTBH&^%1ziiU1*{bwqQ
ztNK_-JoK+VhqwMfcLS5$uwxIjabv1-tzsY;&wj;hY&EiZ54V|byORJ5!HsA35|T8s
zoiLC}sJ3X^1$9>3S1PVwA7LjF)A{k?t29mZm%1oj0h`1v{&3@o!iCuL2bt&bd+W+D
z=ZKgf%nO>cCZcJ9F5L3!ws{YokC`T?1A{?xJH@Nd(+(2qj81&r`sbWVpjC!<ppNEp
z8Gm_V0u@Eakeh}mbjZ(4BW54=!+CtHDOhr<YFgo@KRot=PhNj&ukxrFa#NzyP&_fE
z-nFkQYx~{IA6;h)dVV?&5xHNkLM!F&;@}A&%wKTc`(=4G5i?vO>b*2%i&7=bQnw--
zU~UN0YxhnLDGG+zwfME-xrlu(n4`t57LhgO89fru*lk*h-8<Y&<~6gf#gwaClDWYh
z3o_c?So}})&pOYtHu268GfeCfv@2HnSC4)>L)&oy`UM{l#L&L_Q6bg~zX-sgi%^NW
z)PLu^f7GEDSvJS^VtVS(@lDnR1k9T{w3b<F_aF2RX6m0g=7)1u=}fa#FR3^t;>9HT
z{4eMwK*}y1yUYlzmH-%luPhcQ*n`!Pk5gEbKe3>Gb3z`hh1sZsn>Tu2w7?Mb$pZw;
z2_Y<sE(_XjXs-x7C_qDgt2fLlRN}D*_F@9&(Ko#?EpYzWBzn*p^Pp01Bz>2JP)b}D
z<qnCn^WS*_V{li9yO-dlFr>1Vlp(=V-$hi3Ym*+WGL;QRiGi35wn`BLpDNtJW#IGc
zaIVhcJ!#Ya&){}>=9uf2hV=~mOaWRc76F?|FV)($wr~Voo+(~{Lnk+{CWg4<s}r12
zR>D2zZlmx_A$?~k(`@Z7^lbt*csJxE6urGk!BNk*VNY5{5~gfHJsFTsTu`rU!`}Vv
z=Th#`g_W7E%Uu&m*K9W|Vwrs^Gp@u(me!-*CY%CKp4pg)U7AO~Ts%FRERgrn@c$KC
zdL`$G4s>||y)4|Zmx&ewDHUXl#~-C##X4Gx=qfGfgUY=yHew40;W3QZ5{D>{m02Zh
zH#f(abV}QT*k|JqT{Fz?g|KQf{3_!J+^j%c=Lv}|5EJ}}RDlE@zC6g;=_B68^Am_M
z1*)so$W`<|7;r;zr+Js21OsZxlc7c^ly+kwg=hc?kj|o;dSM?Vq)Cf*M<?V})12N~
zVMgwu6BnYZwV^sm+E6+DAAqoA2rj#b+IIKc1|jR_PxV7H7ExH>5K~6hJMWh~@W&!y
zLwGKD)tV>V9^?gyUPxHPD?T2SWYpmT8Fp22jN5qg-PShm@!Bn$1W*e^#WG!jl(DDH
zd38{|z8U?Pp@RjH*8udXI$R0^^_ggx)r{`L0Di0xyA!JO4DEh^7y%$DzvyeilKvBf
zTv>GLAbgVPYU;mjOWN)Zmy(LA3r;?e@OkuN8Fgp~83PwPy=O^#Dgo2X;Gq0~VYYP0
zii;@(eqkE@v&>pj1@76KqEU>~DwlG+OSnr_3)8~J5Dg<(+c$(VKNi$KO;}dv!9KO6
z#F=4KGtE+#*b)np<8ZXe_6vKvog}=<Kd{TiWo7@y%x<UWbMnv^KH51t|Bp5byQkn-
zCgs!Ql;f3{l?UH_1i#GUgC}9RajtLiM*))T-3c9tndIFtJTA^K#w+TouM9FtHL?!1
zegwbBOq1}sBII0w)}wR`auUjtt`^H`$OE-?=xJxnq5Ias*Q=a6v4v9zK86Dw`hSd4
zCL#hj7f=t~44H%zh!d;?cpfYfK=|wyV**+5<hpD0p)_hcOhCGEodStvUH@`UbvFr~
zSOzoMdgH-K48seaY^ZSa@Ab2iH}?kR54qkPx_>lk-_0?@BFeR!?+lApCvQ#~-kNs3
zH5++rF7wu>>$ko<x%KVytskEcM3CUpCuNshZ^vt!EnL5yS%G^K%!cL55d4W7C-+K3
zsWN~VKH+9SUi{kUI{xqtp(`c<TMt`AKR%}jI)}{oq&)q*PV>}Oz)MTakct6dX9lJE
z=Sy^>8uTAzSJziw!juLqM&hIH#8+5|>-M?k-LXA&wA#!`T!wVayS*c-u_hSzgLK<b
z*m!ihfMkS&W@g;Ylgsgv;^Lusm15}*fS6&X<C>>4AJ-W2R<q07hQ@^6kObb!Z;g1n
zt5nNGOxU+|vVMnzTrcUuPdt+mjQPE294gh^Is~gN+*vofmG#H*WaUnYlhQf(dnJqP
zHT<2M?Q&<^wO#|#rrWP<&yuI?yTg{ce@_Boy1i;>NDbL>dN&TZR3{7!3cOG!Zx@@k
zfuTAweS^;9MlU>YDlfXPdjIhk1<wdPEfnEg2;2Tiz3Y_5)B9}j5VFp@g|p}<rA>wm
z)u}E<zLsiz`#>Ry>6}sSESz{Ki<NQ;imfiMKYdY7>(A9@IiPy2X+K4NvH#((Qwm<X
zN_SN_rM$;$7{8kOYbv7(d0FC<Qm5p0GkyPT>Y5#$Oy*Rei!Hy6+IN#7yQ;E2D0`ZO
zw*T^mDx>aFvNUZZ0Ij{AG?w$imj}z(4!NftK3ZO@7`}p;pBSI8O|26kbh3JtLkiKm
z*BXgI4`Tg^0FZ*JeRzc|?>ye&Rx6iI@(E-5d~Mt5J>A7XcE^-?En)&ouuYvL1b3mE
zhd)Xrcl?a)ptskzKENjScO5+~2arf~N%UYIx?G5hMWN#Z@kyvVh&*)F2{~k~N};ID
zx&fQ}wk@VsL@dV%f8{Ap-96)u7C!xNz9~Sqy=I5R{^}Q4Q0$47@}7jZI*%TRs_nWS
zK?7m+xCm0<H9PSZ^w+p6#{CUT_juO*P2+|^QEkmn`>({^JodJ~{j?$9_-S|a)86c-
zeYH>fpFSP<`t&(!;Ip4os~KZpN?DL?w0{DYh&k_%g`dG71L~k>@JOXsa+{z??`sMl
z)SgYFf`;6;-eyR@CO!Wd`26I&0#FBSuM3tnLpQrA7@jtYAxTX$>63$nd%eRh&Tz?!
z@{Vn(sM8Ae9}&_fp$n(C^hRK|fR2}#b-?S<?*hZlkI7xmGr9-ZwNJ<Twr7d)h*J#w
zdY_!@-uruphPSD|z?p2lREFC55ViB0(gy2f$>PrUb%+43@LRKPx%%?u(MGixnX*Bc
zBOb1oaMn*tjQpSlk62JId@8red+ZHY*moc<@EiKz%@?6djR1kN!FU$YZn1_rJ7|lk
zt|_&X=x<tT%(T4n;IMW811fr@$y<2M{)cWadKG!IgJ_3o9=yLl7VCw4vb8;;#Z6x7
zxU}>im9r$NR4?eKd(y)~fkYcL#|yQ17@3=5@GTDqag@BSF0a$nrgsFB!$iGqlOFJr
zs(*o~CrLee$c1<#A9;*F_K^DQ{^m-~n{8X(N}L-FqqInr!FGR@4j^3j%R_Kt<7JnW
zPwhYvr{hVl6O|4WC$$u`4_0lZW5O`{T_aVMvhNNtPsB3cS#NS2F-bgUn<IN!kRa&*
z*ggnWEE8a;B<y}KtdNDqeppSp{aju5n=jP4x~ZyFq3Dl#X9V<T`-!3U6bX_>IsRnb
zf~3V?G(w*bnM4neuo5_+?vHv8OG^FKj;i5ZyGhzBPLlzXFj#}keT-yBnRL(?vIB35
zjKSO>&Cnj%%El_2nw~QMK5^V!C%JL+NWYF))MW?b7yjs2HhX^)a#y!<w$#fYonX_l
z=qK6@U@Y1vtXDEp=(Yo+CU22xpc7S(9%jxSB-^jy+h9S`tAnqRW~eQ)G8a|m?40JV
z;%1-4$+PM_hT7hgwqw1TJw_&F)x5{HE@A>il`id)AG8dCg~K1VXM%@Nvi0x?mKYX6
zn9#p&;KH_iEu3tUY}rsl*=Ax47T?3`B{!q&;iAvty3aQ^KIa_VdXp^slLQ<3Hgr`Y
zQ*Sr&plx*hX31+9ep3r^*MhamI6MauN_Kznax$!xIR4rT`s|tVAfEObzjNauS|SE>
zX7DPqR2{PGyU29w*StGW$)^z#nlz!5tX7n9{ina=iiL1_OhhjYUmUfLal{1t6Xi}1
zI#}$2Tu73R{5}%l4Jjl{48}{}wZRNAX5bPC4TINEtwmY#;zoG&-}ib~gK%HVjIU2-
z(8w~oEW*mXGx<UJ84Uc`Hx-KWS%vZhqkPe}Mf9&q!`&oU_%C<qzz=(|VnkX19^!*x
z+s{KJ;8XS^ka}s4Z9h*8%kJvJsAbLG(*Qt)=*a)hZ7|UjPquC_3Fb6XOzFvkcRNOk
zus1+J?C`P39|~)-aE-osaQm0OfG8#(^WSZ3m}Z0DCYyEPZncC|Gvir~5WR*e$jm#n
z21sR+5zIgIRg%<EZCClBZyJU1l^4;;W?`qx^NK6<`1sB5Hlq3Q@If=wY#q`&9$MRi
zE=By<RGvW=^;a=yUfEi!1Ey}<ngnSrKX(fa&%DU!FOBsbE|+F&W7~UV6>Km#6+p#i
zM``a)+s_N9FXN`2Dxk^et&xVXZ|c_*x%bLZgYkQmz?fu^7^Q~$cKI>)IYJ{;fC;kY
zT*5tjkd9F&XDeIA%#03AI}5cO&*<(Oo^dHO@VgZ{HazPlWG+GdeIc7eO@hP6rKTT;
z9;L30T6TnQ_iQN>&zo#A5~QuN-;Q7)n3zK*9AXwj%}=JrGrBn8j9$O@ey?nY7iV84
zhpP_WUL-{%{Qh;>oU@q!X5e@pWAB5YF_|raqYFV@84BBETp(>B+F5t;Pau6m8b&JW
zV7kv%OmQ~t(M0`Ey*U?4!4m86c)-kIAWtbiuV5~>#4ya~cGA1Ie~wMGr=hnV9AAl@
z={vja$ouit`1zq~&#MRD{Z0HjcK6ua`*&-{7bd%Nw;mF|Uq7+@>E-PsAKw2vwX!(-
z{OX|(8!79nzkbYp_#jRN!17EINXlY?1d$8<RR4l-(m2Ol#TR3%JzAq9ZLnp8*}1f*
zz2^d&3dz$4ZsA~;*rR5Ljby6#cU?%@P)3yc#YHVTsoji+Y2~c9f6ffI$nWV<J1^Cv
znR6zO**cJ!(D2Bk$i>Okpk>je0HCjaQX#&XI9%p;DR5VQ2r#6b?J=dSpYs!_b8#nr
z;O3MC|Hsh*;?^U!X0z)g870KLi`#)9m`c^aD9F!Z=Z<44BH`r(WEr~bq%vLF61>uT
z#xecH=SFR&vLHtf8Ltb3WqyJd(GeZGMI-@T7ZAr>>Z`uCH^igrT);8uGH++5OXABt
zs_d|{7gf}FMea6<MYgaoDp(`6qYsnMMJS7umC>A;eG?VxHF+r;?jr<~)}i_SLlXb0
z&!^!d|6D$<E=f8F3_He^Z%enH7lupVdNmW<Et_pFHfm4ZJUxZ0QMmj>pHl<mFJ=^S
zPu(#%6L!n`NLk|Fwoim`m|<`6q2aNs48VR@q;eEU)EM@FQPgrRA565K1xC`QF9Ek)
zaKKUVHQkV^@~j-PgKexa>!3^nM@rDVI)!&DIB0y2iW`={Xrr<HtAg&ip<sOK<LsOg
z?stji0^ogL2IAhoSX-d^gYx`Y_S20-oH!uW16EG9^7(i<`Pr+Ji!=5LGnZ0JR()}0
z0C9_Es%dTEVi!}gQZ9hEulH*5jQ&~Un$cAbK4i&T>1y2R3jf-~I1v7K>R~iPJ=^!l
z!#Va8Lh@os$BF^&S;4k5WP=W}T~2tAwFt{g(&`Wb>ukppouEfZCEfD8qXYw1Pj$P^
zOGRSb_3L=;hF_%-4h>6S;^k*;Yei;4AecPA>pOIC2Qr@K_0inIeFdUFH%bBA%dhQ0
z3QeeP{y>M;ofn^U(X$sISzdP=fYBMXRZ#$<;MWaoQ5{DW)uv0}oZ~?8=<UkG)*Dz|
z<VT^|naz6HMBc^CAM(wyKScZnR$-!kMo%#3+Cws@7T<!h6t1>&Jx83HQt8(XJUS{A
zwF(OK8#s8sryodF<pzOjp;(vD>7W?%+*H66xI7H9<$!JjzCk7nA}`fLOV{jOC$&F`
z@b2@3f+L{<)cgw4`eX8glyz;RoWFiwbzRy4HFH1`*`^&fL+7k(0f#0_H9htz0z$1*
zo07L^?H5u!waT+;k}O5fG1;J64$686bg+zX`gFDvo6gjr%-1WhUoK?@Up!}8)YpF=
zQBVv=wwWO*yr|G0nl~9AO&<2i+MpnEEH%3FD+&3>kO?)P)sL>x^jv0WJbu!@G$?LS
zj#EV~l9=%6FB2ElN>(gfo<X(U{957Zv3SiO9VfC&8tYAR8qqyU%Gc?#6iTvp`%E*q
zG(V8EhIE%^x7TdY$rG4V23019h_HRQnCsuXbYWXgL>nw_cWPBa^;pOp=^kDu#CV{R
zs)r;agXL^C*WqP!B3;KP5T2+zsBCYrMjK`@`*ftv))~6rzE11`pj%oeDstbzXJfaO
z(91`{qV{KvWQQ@q`k(Z#?f-UiFH{1mH7f!i{P%Y+=w^pvy+3aXIOX59Wlw!pSagW`
zn!m_tPeVa<bePGheNR8rj8tQ(#CMIQ_B75lm^S#L`KdRrTBlTA*Y!m1d+^4`lA<z_
zKV;)xo+hSzhRBUYAKjjb&Ai<Zs=7gNVqf<{*?x||?Ij(JN8dp;hR$d<vH}wJ&5=7o
zzio9vI(zQr<fO`TNxSR#pn@e-r_J7nA&WfoqH@%V>9q020uA{81IS`H<+Cep21=5>
zG6=QB$abDZH8q3Hp_E!|y2bK>CT{<+v>=eztJN;)$8Vwm4p#oFa?kER3~%hc$pY~e
zNb8h>P`+m|H?go#k!+Bjc62<StlqJ;B2teFtB~R)A18=@I&=L$qbm}$6_XL#TH&$R
z_sEuGdzxW8ioCOqNz>XTh+Txu4DQhq91YJ41%?Mda1k>-QC1myz-2JoI5D>+h7Z}f
z5!>GBZ>Wh;hk8M<tc12@pK~Efz<-kk*>#B4&4J&6sUi4=d&hGyn}4GG>0$SDUB+%;
z+s>Imd7!Ob`4t^b8J0kFVOA|>{`J}wM==6uZmn-{0#(*MnFA~e?#)6^1iv2>=>^tG
z9(isUpaOjUH;scMeXf*#!%FVn0hBQdJuqf+oN%fPW*`QjtFer5I{Mc8-HiPqtf_{q
z;1=L)B?vfJ)=U82jP~~amP1{ZpOpHt(reW*A-CUt|Afq&r<!q+IeM8ra&<VTvVY`U
z;>>S7iCuilWeOp!K?kUR|FjkkYCD0L-bImayM2@_JaudKy?CV7$Nnpc&xIsUY)`H7
z=*i1HQ79qIc`~RFsihN1AJ==6mSs_FD~v<iqyowO6Pv)5=a1GjNAdY4OIq9hb%FGa
z2hw%X5`}vPOFp79Arz~{8%OL-c-zu?SNNzayNo*;J%*BNwRB>Rw&fzu>VG8HwnI(i
zlyvG@W~s(Q!UV!`d3Zf<^vESb%zCBzkxD#&ZI9{KhOn;lTSbml>VWlNh-O+(hCHYq
zWoygC8})2<)7ih)=aV0xq)D5r&JMlkaWjQ|Ow6gL?nXpeb;_}f>(*1EpqUw|ITGTg
z=2#hVaQYql&;ki@$n_tceeY2#X!rZYu5pKp+b_HkYmnlXvi7hfwg&p&OV4;NyYokh
z<5+gD=3mCy%XLwkZeqygO*gT!wa&GWdi$398_ic!!Yd3{2(pro*<hBZ6yV{nUG)Wd
ztPPed%!{SpZZc{(^5$YnpGNYE>|9g@R{*!A%38iP=QKaspo5*3(i4)?xpcS%vyEMl
z0fa+#NC7eJ_t*qjnmMYLmHvcV6UHhzJpr@9@Kc0an^<blO*G@YPQ*&OY<|VbpXeRQ
zW>CZQmQFIel9V03$+gO+vMx;lT&czS>`~69fr~hC52D2()@38)sXNE1_M1CX>r@ho
zMpmP3wxy|dG@3ijF_7jIO>;g?ql>d?F0DrSZv_@*V41+$tblAMBJ52+Vn-dyv>DV7
z;Lp*UV=mBE7ciKJZj2VzU<DL5(bRH*_h<W!P-{p;8{a!wuA7yfA}Y)-D;alzlnGmk
zgpc?8b}x-$mHQBy5!J-H9oZzsZfy?1-zco6t24Pip+m4&RAlxOzUL(Jhqcn-Y_vyN
zzJUv@<!|~OZdGa>bO!)-o=<b|@3{ivB@=Fk%oDokT&HGoP7UNT3v9W7JQ1IvGt!%Y
z%H8BuU1s9wB!mXlHo>mek0b~e6&!VU{D9zbM>*On=cMBGgs17h>+FE>^aD77=oGwr
zvZdRGcbH@u<z-bX*3NdSfo{?P{pk?bNXhff=@%!OhRhu*|0=k52xL@U&nDz<F}riT
zMp3oz8t{N)IMLI6AC@}mbk_)VTUQXq%8t4YI)a1sCM&gd*2JUwn-VaG&HHPjb4zXO
z`N{$-K$1>?MlGZ#H^VYxjU&CR8q87dI9O0|`sr}ktzg&wcp=}esjt>;9Z`G*t4bmY
z5)lTxnr*#LuH@2CqGrmK3B-=C2=i>whj@Cwac(&hQpV($lQ&ZZs11QPw3<$EuhkZu
z51D9frxz{dYn~Z($sssg_j0m1J+R_`K|A?cGV9Vn9hhHZ0O;dWMdsZnQMZ??yOOi<
z2L0LM@d}DIwaNWKVZyFIgPEWw>3{zgTC7OE7|q-UWS;Y_mE3)=yDp<R)}5s$01|~7
zwbs=<*WWxe?30##hv-kc8v1F5;V3+n*wXd4;zzXf3pM%c{+`QUy_(zx*ODuVDuVKB
z#g|99FN6=<?TlGZ`tI(|o~r7rVD11p4$fxVU>~Bjiw#rDZiP*m>n`%I#er=z)3xl3
zjp$qp5?3Q1X2BT7m}CtQ5K-a7CjR-n2UnWxqzgj_)N^u~l7L(I6Au+cG7GMUO6$Im
zm9w&`ug!L<hn3+3hefTWm6=a0hQJEX2nTYlgn3R24{L>*{4#jGzj5;zB9&O!A!cR2
zczTKc&5PprVB1-t+rJm91fOgSosQ?}LTQ&?c$W&?J$Cx}diePr@Y{3LZ*Pj9e~#b2
zQon$ke)}K#1rGQfc<0wU46>%1b+>spFu6|p6=K|A*Cry5@G4sXb{0T3p?OE%5xT<Z
z2UBFMlbuuXoA5%9LIn4f3J)J9)xmwZ&O-eUkw-}TrIxKNz{aZ!&_C0IY!Cr)mD?V^
z`iOzxbrC+{&l)fqt=_JE%X@N|JA+1YeXl>7uox{AsDD+pb9f6b8`bFYa!NTMV^C9{
zBIKEnAo3CqI|Xg-LW7o)-GxGphm*PFvd!4aEqy1_oCRSh)NwcAcw(Y}mRQ-??>`&P
zJ3q>^=QNlbp#YG_h~3k(Wof4oWB&&8Q|kCiYtFlWNmCY(CUu}Pflp`Mp39DBzKx~d
zg8)YQ=aNWc^$bJfPXg)+G`gA3Sm~+_ha4cnLI%^eR!V9UA%R4G2*P5t|Mdz95=Jci
z;qGxM8(LPCMx7WWm8SQGZyK@GAMSL{7WsBTEywUJ*VY53ff8*wFZ2^y1LOKGeT9o<
zB>>^}A;7_up~L~o+0CHvx?8m>eut{ixPf;aBA4iRn2I!D;?ECm&NxWgCJ27!VndPJ
z{YLI)%aw@(&(&oHM-+RDc`1FJ?Lx4w!I&=uu!36ni<6;e<9!T-n##UUbJ+(1BH<wj
zn4O!aZy_3n9avJ!-i6`It-_ahZojI03kyF0w?+<q8vk@uW)~8OBIHm7dF++#mC}-)
zi1#LfyhPR|?M)noX!C6c86XN$nEa=trb~Uuq6<wo-ZXQ*>G&k(^2+%@S-|k}^B&$o
z`*+5yuBxl2->csn0_~ib#e>2~2$_550Frix0L&{UQ3kl&Wa#1GH10eY80BxuUtlVT
z#VNiBH+9;J`+}i&n%te_ms@Q;Zf^Q=l;DwFJN|<1K}n<%&W1c22*mG^xv0-~?}LZ=
z`)WyzUM3!hbG?x|4?ZLhxh&ur6{iE@g#x^BQ0Z#Af);{zRC4y^fzn3r<9g39G4E&f
z20afx`*;>pJA8fO;q<Kk1w#>-BFc_~JpSe=I9zX#u>jvvkYhs>c+n?%bP)TdU;yEg
z=26W475GD~5D-7N(~{wPefNgR1gt*9^_?O3R#!7^_M_;<JBh|(1td{8F$)Dk*3)Tt
zqq2YLRKlynQotAEN$THp#=MSYS^AZn_c2>?JE{Uc>1BDA`v5P!XKKA!-^e~Yy`p1e
zE=sa8Q7k{w{!*{0RR8^OY2Q=<?C?oGm&rxQw-M%_I%sh&FQvzdkVc5~^uh5{ifD^n
zpK=97(rMFm?$3&0jGyj~?c$yDv-(^o`lKUc=6HC22j<dgeHfX*BM~6vaIoz^WB{IH
zB)pVDtTYimI>CZa@$hIPB~n42_X_to%E|3YAM0SQwinpkiz_+>v()E0Y{@D&*cSc2
z?%Zq+>6Q24gX~)YB~EAdkn&>*b&(A<c?t%R!&4J2&1@nW;8efI?nw2j_9n@u7sI*!
z``{k)f0E1i^ypOK{(CjMpZ&*gF%F4{8Mw&*Xz@O3k^uc;V_5{tC^>uUw6NuB+tqv@
zuwp$YO#j@eLB1_S@&)D6<psXIf7)rUmb#B4zrz)?3ERdCd@j~xRe8Y<seMs(8t5w&
zYVP?qEd=c#L7c@b2yx-XB#M!P%NYjxtZKLiC}Yp&^>cw2a~Au$8HbDOj<vKN`u_gd
zj)s_xjbnP|#{kWRhQY%i2d3pmSI8kI>=+ZC%0%Qck(Zg0XuM@x*UkGJV%x$u0>g?0
zdHx<PJ;y9&f%{iLCUx0EDj806*kO}JInP*U|3%3|85ak6$t<a3Ozw^#@P5IE(>S>0
zb`(Lhg^KfwpE+<PG2q`q?3}UyuNfDZul}}5sbF-1mxA2-wA66h8<nP5vnPmT1Xt8d
z&laWI5VMK;N?Sg9sXiCQeM2t{AuLien9Fbqt~X8>c}zFU_W4il=+A9?GqlU*Vlh0=
z0_=Wq0zPgYvYAuZwCPAme`aH5eD-AYjuY!XqJ6@bopYDj#R)}qkWIUxB_QcaK(fDj
zoWuW0B_#T4CKOG)Pi6X;lVtZ3)vIM#F7FO{1bvS^fCTRu+rSkb_>p)P!{bhX3`Ey3
zKcvI{zz-i!+IJ|U;a&O*-o%}^0>b_y9nA$PqyQgN5ETQ%e1g(|`LFVdenASSoOl6r
z*v$30f6P1D^S=xE+>|z}s)Q$wbXep9EUYcfZ9k-Jxlc(`KqszT&W2ttQQ!=MoN=&Y
zMA*kIh?KcMdvE_fJE53Lgjr9NCf8ie9^|O3!F}9=J@Ue1^EfAt3K+P{33<0D;<W+H
zNMZ8b+${6e-1zx?;vs8E{$bG+do+ztM0`?3+zv&AY8F>I3+U3^-BF0(i<OOqugm9>
z&x*hgNsX!gl}yv~#uQX~U%I1uSgW#L5+lvOuH3j?*~40yRB!+gRwfep2Z2K4$GLJ)
zp#C+qI!wxHA^k=t)Mo`6!#d!u&u7d#Pj?}F7^l0VOUwKTMhmbqeg1)orj&5+o3D|3
z5Z6vYEdhqv5qy3JeR<y*k&#zHlD>iYATgP!`e-t-+vOr#)DY#R2aIa;+wUF4+!l>J
zdHr3GS<;(J*nIdNE-w9EG{FcB5P;0$)%E)Mh|^0MmDYv;-YH7lX0r4uqq6%Qu);mR
z@cY{;oJ}wNi(<Vp!0o$`eqe9VmfqX}!@|^+|AO?gNbiobRur}Z?HuUM*{H+JAizib
z`=OhU*BF%)I#Q^7?wES#84U*x${<d+FMo??h5NNQz5XK8Lmk=54Fj#I8}7dvR=4Gm
z12#7Hy#O(4+=XCpxQZ(;oaG`0LCg{QEC;vU-&Z>=<$=6laWj^tgjZ&9>OqZ0*OQJu
zx!H(-y>sQ6bRM?(7ZGo9yu2~B-`;9zE>}Z?`{O_DSLZz?-}Ri)q@FQ8VLsa@|MMmY
z-~Ebu47z<5d|i)(9mvZ~8V<ZSQIjI^8E3qH+vie>c*|LF5r{Nq|2#CX)4axr)cU07
zK+!YE@r3U$b8nJVj@VjQ5~OZ^i~ktwY5z7I6@V-~7D$Yn6s6nV`fumj@9!UOIE<eW
z4Qr2T#2|%R-an2#gox`d42gp*<i?@YmqxUq5^V(z0^NDEk%V#DCYif?v5)}0>pgC}
zz!qVEHRyyU%gtIzS*!J*#S_ZV%1dw6^no7Xj*Vo+iZixLqm{W|hrop~5Tu-nvcycI
zrzY@u4=t1lsmtA}-k#?Pyvc*HET9c!=kVtk8qCHsPp(aA&lM$>;<z33dF~IFAt|yO
ztSlfR&ukAyZEdD<AQ5S{>}Y*&Y&g$UJnl1kF-vUzrlvAiB_RYT4aBx-tye1mI~=4b
z^sA*EurZPtHGS=xEEM?YP*3;n+Q0Yu`CNxpVjP|52_@wge3hSf!M_>hDOUBe722*|
z;s5nFn`SK?!lti7u8>pq6*#F>VtE6ei@3Px8aA)zneXn2*r%4A6&G*a|Dx!JytUXR
z_s0GPrtng0^LL+;8i{eE+h&k<vs`j{d%UkHbgbx^8I+H0EBw<FA|3nHDanX@??CO3
zkluB<H@2tkX>;Tk|0)N&)g5?C_A#;+nXRiMjc8~27lC&MtU4*4Y=@zc{)63$RR#XS
z`k?*64*w_^Z1jrDONY_M`U{Hk-f1~%IpWbOC%|vLLT(33DBCu;<Mv&HTabSi_d*2W
z7yWIo5E`EzNX1$_AF??cA~cvDzw4nF3f5?zu;*_UPx90_k>r7Q*K`2JNFH2C{TdsN
zYcZqo)icq%_7)hpUV*A7L1f|gBCGQR>e9#G-~V#EQ{%zcJ1-7C_|`Oi>B090Ki@z2
z@ffVxy3i?isCBVd=W^>(|Mm~9Kc7=IA1=S}IrQ+?>yXP2f4`0Y@bJ$EuI8ha>4HNW
zb-T-goE7kv5o*&PHUF&6p@N<X*8vNe#~W?0j}7iFZS35#G3uly$QMKfcB&xUCoHc(
zl+E>-7=6jX4Mkb};6s{eTs<D@SXC&!M@--~U&Lb>u{lR(uI*~yN4FJuDeku8X^A-~
zwM$dT^|3zubpy?5f<Vpo8&m6Br6wj_w?k)GCVjU+l3YR)8ZK;A<KYCGn^+kwwH2A|
zm>$I@Q9+8<EVqn`UF{Mn+znjdXe<Y*^a;9lbnG(NPw({vG16X!>T3o`k#LtPvKrb<
zG<MaZB1xQ1^Y@-6fBHYr6+cml6mw=z@h+fBxYcBQTJs50R_nR|$r+5&$UTi>gP8c-
zO%!I&1mE1yj4pX?NoCyM$pk;S={s*IGBBS$nBeTR<4LFyU{g74F^Ua(l~J4*cz8l~
zv0xA~A^D8WKblE~*SA&%iFYI3+GEUw-VIP!na;8p5mV;BYIkJ=_cs*CK4Dd2E&h9S
zFn00J1FB;6f8^R1Yl7mdDdyYDETlSZ{)R}tZXK3Ml6qyYB7r~oscJ{g{A|dSS9g{E
zon2Ad0<%q@3Sg`c#56ktugayo5LDIo{sVNklf#9#5{h+chkq1Ol($P-T&*v-=l}#E
zulomS$;5g9{Q73Eg($6FdU?oF@dd5?!}97<{KJnXa#KofAY=x5+gDnswNSj$m7zJz
z*<??hJy%j~4n$3;EfyXENOI8NNbPy=-ZSb5V2>AA9W{wO2I-fd$j(svFCQtZSf%XH
z$GtnuG^z&xS8=g8olsWgMD)#TC_3P3cEZ~Kjl|C@C1FMp$N2o@l@K*Qe1~Uci;CrV
zr&T$kCqd27fm1hSV3y)8U0p>x1!Jk3ech{&_!E^Mq$9iH>ldCcHU8oEoh#WTC||dz
zcZoZ7EFKDJI>~Z?3n|#Je<gz<QI>T%TIakv3Sj*7zLvQ`yCpAsMIQ1q_vgfMwee=1
zy@s(yUH)9DQ(BzVAF_;J&ql6T4$Oy!pL_>Le|dZyS>!ORGoI+%Zt=D*N3r5YPRh#k
z*@W27Q%RyNG44Cu?(ds2=Zpwn))Fx${~^Xd^IlC#B$!905ptFFP@83I(W`Lh`1(8x
z%pq=ZdmU0m{IOr&a^AR4Xi&?>(RvOA-j%5g6ULOt!ApZGjSuvM2<wK%o_{oLlztzV
z`*vO5ZIpHa669k~3UZ+i>S!9@aU{$LCwG=iZ^|O>xSfp3CgCU;J_4eOSV~WC3qfap
z;+j1T9EnTdB=Yd0qD-4>{C#YU`WK4?Bjorvc}M!lznd5L59pje3@YE%MN<G1a)JCE
z`~9kVDPU60pFQ$N+qLOtl2aLs0qUM$9lCj>I=WPW?mckj$(_WC8XLXh!J9v8IXac(
zqYrGxh1ig&AO4sC`6D)KW!-;4jO^rB132v%)Er_-$iRil&)_40x<wbaqui<`nju*R
zD_$s^)zN?)@j{<J`QW6Lb1zALNB3JWZU1|2g#^A+%SIxDs@8`;MC{rsW_*WDH|j)_
zAR3R#7EMH2XqJH62?pZNzZln%t0g`^^*;aDn%z7_(`G0uX1P*l=O@=gHZLxIU%pD+
z`FZzco0m6Ye%%P!`6b|k&Fcr>f6Z63Wv)&$Mtfz5@PaBt93ssulbq$z#6z6fL?O(Z
z?i#E1mJ}d*wh%=<+KuHh5%WtFU|Vwf@eai^`kk*&)t+~6>$Lha!B@@JPur%?)hT!B
z)onF_+Cr?CWkTKlSz%9V!IkAHg>N5b2SB6B4vL%<GF0gI&`IBGEE?;auG%)Ny%!f$
zxiAEd?|%<9a?~g)qs%<AqS=i8Kd|}@gdw>^lk}E;`L9H?Q}6nsRL_o$`?PQ<bqdRG
zz-Y<LS%@6wq35fKQ{hsTZt$$wrpr$s;nSC#t@*LpOo%gX{7`B(Pf>r+a=pv+t7uPj
zKuIEPt2M&~1y!r<ymf%ORi1`ZqbjU&&5db<kvDY%hXB?DZ?zL~5=2?2*^D1psaL=b
zcG_oC@feX0ofC<A;xNilWwCXZJ2aE`V^6bni4<L5pAeL{8jYiaqJ~4j*kLwVo_r~d
z`k!E&>c!Q;OzILjS|wf9GvM#-a2cfJ^1#Kis;8}N8n&$6mggki-o}mxD0af92w9r0
z8WkT+#)VU2XTaAd$~Bg>QrFALb>yUfoi>{i-25WPf8h2!vcf6~7#(()=s163KfL@E
zsvi2rQFNTZ)3E_jS?!*!6gOd~1Ik&TpSJgF_HPB=UOdb=69R<yI?%zB>|swD*gBz1
z;4bw3*NIQ=A~2s&FcOyQygow3t^@70gVJ(A3@oeLmXWnD=Pd^6Rga}@8R4i~^lEic
zbRmFNR|kHgeY-K3_?crh!YPQRm<+NN@D%fKs#zVoQ;T!7?Hy&5EP}Z9mO$wiAXEKL
z!ZO8}-a$cS;uL8L#uRgZ?hbvhX?6uUTtX~&veRr`)jb@hje6}cuhWrH<$|ZM%eYdr
z&$TSTczL$vI#*q`3#0JF-Z<Eq$@hRs+VWufRw28rxgKg<wJLDzIvha29y$8(uPN{U
zsuo+qAlGpn20Nf9(k>%9Uy$Bf4(2$lOWS$ry~EJ#3T2nZc%HHl-StsVBA0;ZBoOj|
zjZTA;JjHPlPh!))ngcSY?NZBWOGB!^gKmEW!8L-#E@vHp{Qz!DuoK>8)Y0DEvB?7i
zI$8Ds%F+=%Atv(<UwM_p!WFGok!B^d?7JO!BOVlvfj`%wtJBhgl6ezq^{CT<83M@b
z-Iy5cU^$wRd|IpA+47lUCYEL&2>t*eSr|jKd3+@mnz?W$0X3s!*R_o$p&U4uD&H0R
zk7_MXCDc;wXXs>BITZ$|2Kw2Kf(#(w9e{^IGS%`EhdIlow$rwcI%#&jacGtOZ-e{a
z8@|d(o?p;eXML<?SE#;er)6O$wXRbGM^iHn=YH?x{s*yG2k)$V77p_@8u13A5oC8q
z7d;p`nbVV4vE^?kN&>j;TfLcPTVdJ>c4^x~MV<i1e1+?s;%mPEQ3}`aNtue<)WwZ$
zF~MI`$IuKeOgQLgrvHWBOLja6BN^VRAa`AsImt7?OOtsLiER*FT|Cfs-XZ*Q@dg)E
zWMIPS663q}(g9YOwul!*mA?=cJo3pow8IktN{9LCY`S!KPEp?~A9hm?4Y)r{tgw1>
zSZ?+Td0lD;Kr(A~Qsa>=725MBRd3HwbD%8H26*o4w8L^GdAXfh7)JIw^4N}7F%GwN
zmvR0DqrTUmHj{hDxuh<S-gUBajf672_h}<frL8jsnYM-JbP02#UfZ#uh^Cu>l1u4w
z+cHn#wQm{Z5Ef<}gkiAY8~6B5O-T?9JDT%f1GN^i$2jfvdKYJX+OrFk8CYeqv&X06
z)%x9VpjEOS%CZ7Tdu+f!INJm0c>K4M-;A`Jm-bV0Y%dLShIDvZM8i71DEP9)3UrBI
zF6`RCVDg~;+3%b8^nz!)@$9gIk6hLT-hmY=VNg9`Pnr$_)PLVtx2;xB^pzeu<lz3*
ztnZUEUBYxB*ctL|Fo~yg@^i~0Y{E0CjR{IG%TYztuQXbabTA@>p_9t2l(&l{>vFHS
z8wx;e=hr(G=;YTBuKa@J0a?hSS+JwooC9%=Vi#avWk~j#vq#NPX2{`Q9I`$)*_3u7
ziKajUS&wH~toJH}4%-*QPZX!`DARWhhjfq+g(p*I-)KC^-byERP?rtX@HOs9G@|af
zbMdX7g`>TVMZ=GVf*w&L!h2F?xU4?co8EK<mVdcj4}5HYKZq{&PWl>!$j(-Ixee2<
zINGI%`$_=X(!bu6Pv%#@GYC+mbuAeiTnKiiAy%;vjdjS`fQXA$Z#^;NR}yZyL%^V*
z&Xy{!M|h_t6T7B8xHgrxeuj5(gZe>v_&EpSsDH&7SO`|^+Olx%ONY16pE`};9#umo
zd<64e^&Ma5rr0>i^pV3+p;+c&0iSHhIa-ed15EbOK=PFhDnVZ2cJgic#v<yO$ZLvS
z*S>eYyO2Rjf~b$eii%%QXL86ERrF@^af<=d(D}PVnhiyv&ib(fDG;TnPg-iV-1B25
z%ehaJY1qK}I#URLn45?v$i5ReL~|4|?bYj@&g6cvLo!tvV5uU`t?qPEF$QZF_9)nK
zJ#;%Fi^uF{$ap}J%m|Z|s`Wsm5!9lAW*5R~vg!)WC9Oo!-|c(=NTsShIQZD}rJ>*E
zT?!(}o1>Y#2EmStIc8N7D$(-|$sMV5w$?ht0>i_P@|!VaY+;uC0|@f$HH)A@(~FQV
zY2PXS?7L;{Infz+pQaINL0_WDcm9EG4YqH$y>kKv;90mJek{Vf;{okpZ?h&)BWc%0
z-7?$RVd<plkF;fWJ}oPjyV)^TmiFoQVf*a5qzgxfqd!v?T-1p}`A1{yXAS`)H>Kyk
zy*KT8k^j_2m%CZH#9hhmVP+r2j3v;SVxSRr>s6Oia%j979a}Z}-*w|ZTiiv;5PirI
zvc(a=LVqW(({gY!rTepM)3RGSwN`}}^rmP0@Et@u$mLVl&JobLjKlm3Mh~l9$jRWB
zx16x<ss~5g^9^dTYp5+lT(6RIAPrbYI2BKT7Fk{^k>{x+_^*t+6d}l;W<15VT8F^S
zmv*#D1;|Bwk24f_JNnwQwNpc(>;3Y;hr@$V>k+$oSY~hz<1#N8*+)qL1=n46z)Wu+
z_b?M$gnAZ-ZiiqS4`+W}R%Np%=^U+*i!oJX9TG?@Iy{s~#*-*IZHZ;063XMa&Q&3E
z45V7e9&_QV)IM_+$Y>xyVl@ntT-C1q^>?LEVv||9Jv@%y#@0#T=-@#vUozsUO$kao
zRfhAj!RN#Af1Fvfk|uJhh{KnQ<3qARRxJPJccI7c?4To*-kQqc)+tV!mqVBz>`TA~
zB}u1#{-LPBlHu~ox*(Hv=}>=;sfd|sluYg-<HP4T)MTF93eP7wZU0JINHRZag&&`s
zerjbooUPXE^~Lwx;!{uimvXL!M0X3d<`m*0z*1v!&-zB_Hxu2~RY8_qvuqIV>U_>?
znI@<Yr?ksQ(NPsC%A)4t2b<p$7Xw(9E`0F5+udi7=&tiHccQGT|EgPbOFlJMzOd8J
zr9%-9>K`SD_v?r07I&EX;#FU0UX=E{*Jtf^T9upAbrLGKjlIcerGzgWJ1h&aq*_0o
z$&il*Q*U=?YUW;lNXz0Ps{XY6Z0n$oHYzkbU9p2bTII$wavb~#^kj<hC|h2)!%&(!
zvQnC7guWpj55K0I*DwD@&*$DMdT`%Zq{VEN&T|6GpWK-Fa5Aa<Lnl6sbCiDL)NRS2
z4sPj%fKIdLM<Z6_&4$mt#aVq8>QoEwI@q#ATW+g9uV3xFV&XVAM!RqWdUcy6=Nb57
z62$+_Maz}o>jc3O6Lhd6tW>GX{lM?i&ijwS*3ELc>O8)s*EcPQS2!d-MAR2dd+}hF
z+bDpDZ_A5ZBFO<GDmM}zEHT!a6I;lH`|{UStZeSLd7`oN;l1*`2Xt2g^s8x0@H1ck
zIB#l+%YL=5P%Brz6QHf%a0Q`N<7Rp-a0$7lU#)#oo@VoI_WIPVqp-8vTOWEjTR@I0
z{**LUg3$K8%1JrB5Warh@tnw^CA0L+U8?QyUNqoK*1%A_x;Y-rr|xriZ?&KlxRhN4
zno9;d8CzQ}b*?=7Q26kRSLyS=rbDZPl@EW0pH5cP3$<7uz4QEyIsN2HU&h6hO6T#D
zg({+RDH%73_Imcezn<1z=dB&J@dH+W!rDkZ3S<-<QSDv1wsTNN=grW49CGJm`hUxX
zWU)@53}8(0Xytm?@=N4TVRO19;ceS^Y?Tp^OF8&D!+Pd*;k{FrcDg*6<8CZ(&)Apv
z@4HU!pEKa@7hD~+hb}d?k8>gYkO8|132(KH#V+xhL@RXiL4nqZhjR`q4xYmx8Y_VX
z$RnAUAWE8)vXz~`5y{Q~D&cN1Ptbah3jg`9(@HSauB~7Y(3LD3=6cp>-#t5j*^iFr
zOhfVm!-qch=Mg=$bzAOCxR+Bi6fIB6N9?Y4J8zYE-#1g0b_U;`x0>+DHue5UW8Sb3
z0RaAeMV9+5YDepKy*#sXO))00CH~W^yQh?H^z2Dq{rziAiOFc^B9*Mx6)!pXr;C+$
zB(3A(Li-8~&b{2P9DjJ=qV@6L>nEy9>=~qURw*ipkuPuTYfAd3k`z65C*t+J6xHJ~
z?;f1^^ZTD_GIO#sLuto<YA51m``z|mlj||*v<UOP!%nCnVyzN~Palwk=T~kE=;%Fx
zI%s#o`Q!PfZM&S`_5hRaj&NoeuJz2<Y=xH3=Zj8HD92!<-mG5LN!W9ZVi5Fu^(vO8
zu|8`C*D74llzjIVL!^A%7p~BBOK?~#0%vSel=?>56qmXYi|q+1JUQz~Sx7c3>J4A+
zbyBll&uiKgYNczq-J*wf1M@^dA@>%$QaWa1?1;jP@Ug9zCUvc07?X}s-Ae{9=;9~&
zXQsR=bzC)!eqP@G0wTL>Ty{((*MzqYKgSgz%Ss6vaj|MI7^`!oGrZVXVHM;=o|M7*
zBHXrD@z>QMXPq25pE1z7v(yh$mAc&1p!r$6Wye>M%wrU`M<x0snO2^s*6w&d_#|6T
zmghvNDhkaEa&DVpl7%@{6Qj-}z^jP(@_kVcEnjm98G0CP*-vQ~kHnF~-$dRXNP5dF
zxvTIRP+?cQroqbf3b<!HlJ@;JFMVwpw9#@^vi`f&ME5rQm;h5>a$>RDb}?TYw~CSE
zBY2GqPUWf1LoY7~3M_8rrK}?@3=B$?KbA2rjA@sr2k9nHarx`j=L@zS6t{$NwppEL
zC~ejF*zM-`8$Jct!K{Himn-MyUpk#22ur`8CY;&x8(EgEt%Af~4%LX3y}ipSIQ^{u
zv!Ert@D-C@9Q*etWk4w2H&=YHr#-)!Sk&@S4f6UE*fiWmd+l7pGpG5IGa7+CD$Qug
z(@#<nJM4gm;>owi1e48km!o90XWCse-v?UR9Be%-rHyi_?Kx=Gz{yf*S)Fp+{o}rN
zf0BqOKqY}#&RM`g>+tjA;5O?p-mUXHS!5~o@4^c^uTS6H8~F7fegdmK*L|w)#ora6
z=1=cmpw2;bqC4fBJu4LBNI#!CwOIP|_r4q2=MDa~G*^;%pAf8&rA2YN?SBWFzMv}t
zpt}@*qU|7nssy7~i4&ZCdfDCSXE@ahWKlNBE0=4;^w?;~qpeGzs$zdUMQ!vBP&iHY
zkpi|X)ywcUIW@zPlVl39gIl<Ok1gH}0%KqhXlDvJG)JCKM*lZZseA#!av0wfixWE>
zA7I|eD#f33iPpvZ)dt~<!Z!hrotn*q!DhNinEwGD1KfwYGj*VW&GhK7)nJ?)rDsCA
zPZ@cQ(&_s<*G@Y$*B-26`q|&<{X>0>gdi<z0#9?UxS~y4;o=(sK(JnkC{FfrenvL;
zQPT}bvJL<~1M+ruHF77C2X$E$*^l!k$#p=cDekzqggLTgaDBa3S9Z!(4)#4&N@5E&
zq0epk-#7e;c|pc!rwV6#Ig5ylXRn`00MrrGp2z#OwHESQ0b^~g_$9b@{v3J_1aEv5
z)z+0Tj}9u61CEMz|2`w<km_G<JZm>c-W5Ur_K&J0Q+|-7RN={6-kvNW<Y)0`(M*b5
zMG3NxtX7}57a&Qgj5%+Y*`1a!{>(Os&8;cH?v6;{Nhi#Uwuh&m$@%(8N*&otZp2r=
z)pM4d7xg;#R}81tSpcET2>ag&82LznmUEcElWph=QTT;VB@Gq^;=FGh-XfiW=lWyn
zAOBLXQZluH0fL2R07ib>^M!QnYA;BDxLH3pVDyl^TC9L6O4on|rDxe;1uJU2oX6N6
zL%~&OShIeyXWk8m`N+MT*}J*n2Sh^MFLf=ie%&(V)Gi?IoxAa0lKCe?XB(^hT&Lu#
zDARSgO@lluzGf5aw=zh^B-sAu83Ab5^z4nvt)BQQ?*9>Wr{Pfc;orco8Dkd4YzAYW
z8Qa+ReH#qMQXxClj3rAdB&jT8AKMsPq0LrN5<)5!vL%)67E-shwA+#*^SJ-d@qeB-
z^Xhst$8o**UFYxoe!e2djz@mB%a8PzlhOIx?Gvr-@lIyJDlz)F1@01;sZ;YHWxM}G
z^(C&2S*T18-?upFF#$1Bkn~w^L6a%qpQPMs??h&*!Gz;8#He0^Q%{DJ#435xb53k+
z4oajqP0vvmg7Q@|;$8$yiv13J`u8U+f^Rl2X|Kmwv~R^)YNr;yZAkKqbDbLSoA2wH
z<6)NS==DIOJbge=i&1MMBhiY{p9LXJec<9>xln1bej&~Z?NFWEMaiN*W&1w1hRHls
z*iwAZ^=PhwjJ%xk5%Cv37o2o2bmehsQoDRb*Gr%K7jxQcrOr~;%co|J7T5o`tqa+n
z@eeWmSN!$aiS?_$XF@D_;={?J8x@E{p*FG-BTgeJQf<>1Lp5c}O+>VTUw6?mlAmH3
zyH832l%*cgg)Ly&(3Qh;X<BJxSD~%7VpU<+HsnXx7oHgu>Z4p%M*K&KSDKw&pWowl
zNxUJX=|#Q6FG#0N`gZ6wmzZA&y04%R<YB->V!!^uo05Ek9J+Tv2wDV<aFM5&V)wo&
zf-J8FyiY9fnVS-ACCX1V8N?6^OE3rhdtwea(UV?*GnM~AP`v9Z_9w0hr+c512h}3#
zwNoOyxLt%+^FA5@EPSB{92UOYuNtIN7)?1g1$0Id$Lme61(_%b*gxoi9paBR3&;5y
z(T+_WL<Az|1%euT%>3~mZuWH9mPZ<TPHf@A9{J5ozuFurdyh-tx5L0p?&|b3bC2GW
z$7yEsNgNJBT;sMPIYhoT5chOaM1tIfNWszTW!$)XQo}iM<%$|r)<WWDp$Bz(d}2!T
z_hbBL+mY@69QupPcwMs+ug#xQi>(cmzuarYM389L(^X@Feq`Kl=UG!;*S&ysVrpK+
z&glxBp_)bs1_@C`XeBjm*Z#4^Yvf4zk87mgzB=`PA%k3-dfRDR?;edpX0HD*823sv
zhZGrw4CG$8DsaH5_xfY*8^g43q$78&%k#GH3Y#jkU7+-aIrOcfE1xDU93;V7`Hg!D
zv20DKTBubLP0bWIzSSS$B@f$?OxT{?_sKc`bp|tu-AR5@CD%q>8_kp1W#0Jn?O(mu
zN@}!6iOE)q0fKHv9Z}tqePE!TD1pxiSA&xzRu%;slpMQBF5g#B2jtyXM*X!$IRQ$w
zbFzvjput>)h6?d)rrNnV@yUJ(oRVxgh!@{T09U}%c-&XGfE8c$CAiCLvr4;-bR46H
z2LPzcT@s^Rw$OQX)_2+B+IJW*eoI06aHYru^G@PzqS2u2Fq4o5lAfqz0-g2KU4#_o
z4e&7l)VK|aT81}$x`5&}zqT0t@ri3aJ(&MlBM-|%Z{Nx%8CVfANX{3m{wiv}z50^W
zkT0-0gpx^<AS`20kg(Y6@4-~bMe0T(%4&E2(oBG$XOQ&pEU~-7Wxh)wyTXyPBB0n!
zcy&}wYL3{FtOu|}$>cR_)SRdDT-AuFfCki7b9Lp_XHTuww0WiMmDR7$<XtcdElnhW
ze(@De3E=?grn{2%BQGy>*?zBVWkBTFyjejrkZ4A7%TBV)JPUU*WplS{^SwH-#*j1n
zLcG-@y9oeoB;dW3;3zn*&srQjE7P|~6s?}IX!>0L3iqyId*aI<>oo;1cdB9^>FP`Q
z%#=?=?5}bS%mHh>cmU)g348Cy7eW)x6({or31pL;)=09&bN6?Xh2qFSLxre8iUinA
zdFQxn;xUPLRnFj9G>+`LYlUlI$m~{%MpmWu%`en{C6;4lH1ed5+<_h(9z~@{9cffQ
zZOd<e0LrtW#DQU_xlpeLseiGg`Z;)I^F|E@s*l!8YJS<%EwIVLY}ShZniIH@hfqh#
zjNerr7)IXI1gK0o6r5Db>zB2gW9@*1TPTU`$?$jzP>v<R>!h=fD<0HQN?6<M_+jwi
zhunjFg_A`J+GC%lyQ9fbxG~LX-)0&fX2d^C^ollkE2JWFYN%zkdX%Jy2@t=ks9jd|
zW48gMAP-Q4fEyoVQ6SIVx%Vnns2huXOS55IN1@!%_J&oSH+LJQEAXvIBQVPH+bMyP
zs*UJI&9jYCXkF5<wn^EF<@UXK;Gju=uI||JJJt{r^xpr0NaHpr(B?zM93cZT2XZuP
zdNy^3Br%|Z>|A-Q6)s0!5jdy#hr{_3->i6GO-^}CDb(H2p&8o*R!m+u?y9nvoL8(q
zs9-f}a8lDjmKQTLP=W1aka2UMx6IJQN|6dY&^}8rAQSXjC^b}-y#LiY=X0tzD@Cmv
zv*|&CPYPwo$(Z+0t2L&YMYyb8CAxhsEakeWG)H~a&2lPg?!%fo;=8KAx{1)Z0-Gu{
zNENDqNQ|?PL1+Onyj<0=2LHN5?Sg<tKowqOO<-NTZ2Z+`mei&Suw03q0V7{SC1;s(
zeRGJZZZr4?qJI#AkBD;S9@!zuNFab%kR6~pU!e%tS&=?iNx1i5Y@6)zW9;p5SUGp>
zw`#-u6g)1sjoAB{tT$a%QeQ(NjcTKF)_pRIG5cCyc~-U!Eu(9q7``Kf8s2TSY^ogA
zI+C?aoau}<2$LKqy541on~-H&NGPefu)dml%pL;D5ZSD}_1#SZds_0NjtipLf^=8q
z@2EPggre8=z<?apzC5cKu0U;5F&0RmZ~}B=)kTV3r#xPC#;DMQ6y5?jojH@yPNyQU
z{eyhL6##wV7-_l!6_2_)%tC!Xrcqv`h#L7bUZTy_FbZ}zY>M?gQ*`u^ftJfe574R>
z-hJ%F=CP=;p85&3@rj7H7c{k6d)zOmADuY<WmCQLpA+kzCx2Zyxjk``CmPA;6$!f-
zDflLG&+&M-DX>gLvhctt3l%P+Q*RT3dlPM#hH9*Q(w&SSUlT0mb)`QUDjf_E#(^b$
zdnHC)C=Edtnr}{*q+)XEB=0VDHWBqik+e%XG#KC|2Ms+sKY7?IuE0hxV^Jm-f-PK3
zRRm{5bP08K?%lSjz9gf_U0CFbYzh-6#dPp|b0AYJJ~MDXxMDx5n*kO8zAwtc>#W~g
zs2}`<Nx>^*Ys7yMGt%N5)JVy1u7NAsk=0|5D}im`q*;kdQK*#wvXanZMR2oSM^%c3
zr%Q)B2sXTt<bZ@RWK=+<=zbv*g(Mo=pJ-3e!zs!tlGW;Gttk9}O!|?##3L&c%A?@K
z;26oBuHU!-nME|HuJTE!>iGexEi)~63CP{-3c~WbY+I5o9VWAs0`Vr+7`6HRLur3U
zU*hXQ-ghgpMxv^es@uDy4eOLl%%a3RJ9z8^akB6DiSVBtb5_|_VtU;z)G){QB;@2Q
zb(-|#>SVrZp!wf9iT2L&d5|5vE9f1@>-ibu5^MGF_RlhFUXL5#xB*FtK1O5L0XES-
zKo@ZCvelDEnxsfzz#%(K$(o?cyQL+{HUje@NzJgZ&Y~j$$tYyyt+k&y{99J=xL%dA
z@ZoIt`g`%yck?f4%k%|^V;0fG66E_Ex4;!Qa<vZlPL<20vMti+7b*|!R0@4%F#<^H
zT<v#5DH&*T;%|B(2}dfAlK$ROicOL0=cUBpkXAueLNdd$gOvq$r>=pjiP-=KTv@2$
zATUaeBn%L9+sdDVbG7rOg=^370pw{AFhF%T_*#GBqXi{Ic7P<+N0OpWO9ojB5u6ev
zK3(&AsKwbp{Vs!Ve$33O5YX!row*2~HGE4f>_L(3Cz9cdzzoLv>eeE$Jvl@IRfp)4
zY+zl#_UD)~r%Ekcjd2!z7;G948gcfwY`cS(ya}m%r0T(J*tr`wP*tt5$#iNFDWy^_
z1|(@Rf2Oj$;Rjhr6lB7#xXt?K464hvW6!Yf6w)Khd=*h`AqtIl;vS;*e(U&HH}k*W
zM0dyTR^Hvsc0pNVWYVO8p=5YAfaY{X4+Ur4u88#yiuvN(x-?(ppVJb33`;G!zPs0C
zm>j)E!oLEu4W7f371OdoN_z%lVVVk-ECU&X<U_5#&#8vMQSXyo8jLU({B}LxK75@b
z@+zlUdhMTG_K{^$>gyEiVptQ(I_HtQ`b<e+4N%uk!ib{Jpu6!I5W6<3eP4SkaaAIR
z(}M55efk{S>;BbJkt}4Ahe5v8)H^M4)|sI_-|!9S;`w#Y(K3`~x>Mm1n*Pt;!om$_
zo@GH#So-(;OC|yU={JNQ3V;ALWk4EWgU$E=I1k{1BLUXlV2Do`$2_Q%SDc2CbG%G%
zs_M<bfQ$=MSF5^GWleo|yfKvnMHD69y)jNuPoc&^0f_iI`DM9$@aLK5_inzvMokrv
zc5DfC1#AJj)vfU*^09Bb2-^Ky*{)f|jXuI#5v6sSR!x6Z?Fv4P)`XC*9xpE@`re~!
zH|#s_p#+#rLo;-jaNqsP5<{LytCb!fOHTfxa(Jk{X`!Dh=huN43(`u$=Ks@i&L_M(
zDwK6%J)}Nj=`sR+RWZ(2-|nAUg@f{Xn)50}#erwizLo1cj6Xn=534_FUtJg|QvLDV
zpwmCOkOLaU9X)84947JW&&9i=wMUl0UwMKsceSakjB9ecm(Df#6o+0E?9llxYwqNQ
zYZa!49QFPA2%AxQeiciraH~U5{!Kv|EYGIejL2icyWx8Dz>7>pu1LUd;qn93B?dlp
z%@TaU36^*ZgUs7ncuwWQTLjN3X2%HA<ezv}TR*m1UdX3HKQT_7AQ1o!a8sr98Mam7
zYs(z}mg4`<68e4c_#c)q(4Kb8ffkfv=SHjWjk497WPW=L!>b<%*LJ~zyHaHi5tQ5C
z9}Qmp{n5=@G<>;|Eh8f7ocC3@(}*QnGDoGwjgm<QpvIh#UApZ7D^P@Rr*^+Q4K0J|
zx)6S>`?sjF)zhCmql35W`Xq#JQxWU0%{{R(>C|18$L)H#(Q@D5UORz<RYL|}zTOMc
zDRGf{;eU!l{jxDP8T*U)pJ6x~=8BDAOrSJw>~sqmrUmeg==xjryk{kfmtAe)liqT%
z=I{Hh`1s`aw_}v;9bq=rt;ai3YNW08QpN7otjNc~KLx+_5<)s=Pa>q}%czs%bCWf%
zO8(^Q-tFDWS8vM@s8;}C<}{4&e=s7Q#P#K#%9DELJH{!-NygkZ{zbFTc@trkMp}va
zjJ{!(B9F_q5jMR2kHW3m)d~MI?+7e#`Upb3yI#)4OiH`$oy7~fZhrL)m*gcmzqIZo
z1$X#z0(eN}wd{8eegcUqIEK4=@=|6_&WG8bD2;<6&v)+STW*W&EOuqx{9WFgqa;f0
zWZ(SU{-);Qi9h4FWVQ?NbSNN{vH$+oYu(t-1ZoaAY=Lb>Ywy_i13ZH3H0eBYD1Q7B
zf99p}XMZEq0@PoJtJYdLXd}(RFUN8f)gQY4Tr~;*RxoT~dF1D(<(qdcE?t(KR0I|e
z-849JCuklnjyh6YEW*u|8!j3L_^fA6U!CP=Sni}8yfv-VWU9P!sywx#6IZ2)Fwmg5
z5xZp}B(5*s*`IOVd%5ptCuDzQ)EB2pfkzX%Qa_=<^S#+peJ7#t`YS~h@ScvS{U9k9
zOsc|Rt#|?29Zb-z(2wUGINarX**%|+-d#iNwIgwo{GCFEY!Lqp2HYEuaXshiUrFeP
z%NswIPjZ7FFzJRDe_OO6t~U=9Urxmvv799NkW>)JC5Ny12RrwethDrpn^umrsPDoT
z#pT?I_K_b&(v2(gAYnH~^f8Q}p&G^18nYsJph%DrTeLX2?64LTD0(<@EL$7p5)V?&
zTprgwCq|p>nU_6!N+g(ju~ja1ZEv4>KPvfNz51ZMP!?PPz!ad9da7fuw2X+I&Qkk#
zC@AN}bdACN2NmZ<mVGzi{rY?0Z!f;9_}7-#HBQ%+qz*p+!Y?*5Ijf?+U-^>XkI#_*
z>hi2v?_Q*BIR>565$nEEZ%tgH_wyv0?#4U1?c2uJo|95(XGO195%PvMTA+FR|I0VS
zmz1OChQgmfv6CzIU#Gjo(jpWHTH3vq1EAiC+7r5cGqp|iZ6hA$t4eoP{A5~gj1|?c
zoj3gYDQn>3$PE(@ofDC1N_zt(9kUjVbbOZRGGkAStc)%A8WQLjI-X(|O^Gss$V+uK
zR;RgK0bU;IY4|h#aQbJ1&$DAuvC!g~<)3$1k5zs69+f8V_B5vLs}ImOe%X6CJ<Bw#
zK2XWYXVj;qx%6fIQNtHgug-1Ws}Q;qYVR~XTE5v*yYEi8*Nf?ihnua9dFo7MV~hc>
zhbh?n^3I7fFNCk7AjtmE%&|$VT%UU=@s(DF!t&tT4<`5P@^Z4ILRBy?nyR!Hv)DSF
ze`da)yLf42=Q3|=0;;1&CY%k;<qcyIZvF>|oUMlVkAm;*1ZZNZcLdMQDsb)Swz?Za
zjVzB+-IGT51Pb-Dc{K%hPl!KL_<w_fs&;K12!PVg1$Mw57;T6Khnah5xJno?wb#P_
zpMwZ4;Nvvq=5$|G8D5ZmN@R;NItXhW`-#z9fg_M+{u5Mr+4q1Ckc)km+*55SnQdpP
zep4x#TbX@8rBtWXbV1|1vCovdO^%{=Hn5l~GfvS6+_4u@m5k%b1T7!JmXmB^kT!%l
z?dBJ_(GLJ6kod6bvUUoVlSFh8oCz)1Th-+3xBc{j%W08P7G+WK_1T=k=rVB|nb;j`
zv6VPEMH#oW)DP9-Pr=l%j)MNT`%;K!#qY|kR|;uCPRg!H@}Ef|aW%IBWfzKD8Z(cZ
zz2CDtt_<3%FGj*+TIdcr;&;b5S8QA#^VLg#fMWOqa*`Lxz!DX%{G&iRxwHEUILz+m
z8aE?W%*3pR^Q#e2l&SV6MY$l(E&hCbCnGIH_KMbXk?^tp<a(3*$z>1V;X71X@q+Ai
z3HX&;L#XHb%1k8+@Ar}ZO6m-p5F}2eIG&RF2DtD6S-fSuSvL`b2_%!W7oqAGFYnzk
zXd=~d@2Qc@(2unnvU3Fc;nY_`5+`<+4<+W{PdMi*gJuPOZDqa^xp$<&%z+Ko?xlVv
zig?0UEClv_;-ZUIA&e@t(b-DH-3h6A^!J6apWV%s6|7AQ{pD#Nt=JDEb%NK`C74dI
zqr@d061ejNXxKWZ`8+>g_1kApMW@~>SssZ;urY;#_JjeE&vBFG|5~D`ly)1Gazv%U
z1{*@^o1^HeJ|G<1lUXsPsONcA=$VRU>MqeZ?&};WL96dQ<-pEN#+g?k!VOdtkOluG
zvm;rXFzlIvRX&Mo+h9tEdXzHPwda-WdSf5Ya#9=PbUIw-<qoVP=k@NJ55n5M-gee&
zP5uVEH1{MK`r|0&bXB#5ycSUy$3<(Zi}83xbkCCWqCvX3!S9D*&l=GW#uFA9#ypmg
z=9@%`N#8DcY|t#6!+<ZfNF8^94K7-96)>SxSd0xM>w*|&&yi!n<l2)B;!>@meE6)O
zlU&5S8~^<vLnEU!S}1;xT{=EYUS|otT#4Mppk_SM+>Fv$Rumi-`X(~!HwHCjpMH2N
zUAlmA96;P<2wtgBXOw1yw`W95W}Mi{h$Li28)e3LXU4{5#=-s6TU5sH>F?Q5nVk}w
zH}{>N^cs2QkXf4fWjztxB;d<iWlyZI^EwHaW;G^>La$c@*)I5%ir5zZ!!R<wk|JMS
z%l@+9M-j%VyG3S4$u!+V!}Re#u`<*J_a~>l6BXo5$Kr2<nv5uDls6)u6LY&mgLsXI
z+z}>73vtB-xz3PvT^0@-hF5Bvi2cm50-2;&<vljCGqx4|J?wdh0IV~_ucR2;GcC>p
zJ1dVSvzIyV=!{~BzHVVI2!o!VKeEk$BP#hhTFCd2NO3qebJ)I@8(2Afq!kcs!3bs%
zmHw|)cce<FTT4+~#MRVF%!Hr?3APi#d%?S@o&yEZBKe<B*<cEwKQO>tMdX4v2V8)>
z(jBdB0~O$vU|!DR+=fFCBZZ(yAsG?i1y{G)DxjG!F^uo9{j#v;cxKAhLD#T|UQfM8
zrG|%S<O9!hC{y|~1Z)+K!x>?&68U|JNd8m)AQyfI1JQ@nM37b%xH9)kB=YgBrN?G;
zH!IQ9K`el2ya(RRScP2LD9HtxWT%#*+>JzOgk)W9rKu9g1vZ~+B<LgIBM7}QtUL<r
z^UVxouG@_doA#y)8930k+%cmo=(RVJ)gxrBgOGrNpi610fhGIQQ`8=m3Hv$dJyEt$
zQ7%)#7xH1@Cl`@so??TcdoK%m+Y_>O5uM}$4X5rw=!PJS%{p)#L^N9)!%sA#DZGQk
zfC6-a9OiK&+PKc4r;ZRZs+r7p?LvrVyc>~LRnYyw+8tr<Ac|hfC{xdbKdo@vWvKua
zN)B13b6`N=pP&zWH5$LMZWHCcx)N37sF^c)%5?lx%)SJsS|_5)`@unyfQn@KHC6X(
zt0ibnuz1h|O?IcWF8K7k70M>0`n?MzS{R_|VG^p9jxmL99;F{K6h)BE!_!<RDA}SO
z*RVm>xYbhHbm{N(sz1v5FeYQAGuYNjROhS#j}Zhgf?C4N!m2MEkCfg9N#1^dti_V`
zFIEynE`OTL%pqGiE;_}ks1}D^50F=KT+JO^uKGpMu)l})bA{+etK{$yfIkt_k`)>f
zXf^i<866<QJaa(&ch(eK2?)sJJd<H87$=^~e)3#*>La?P@!CQ=IurxT!Jw{Godyx%
zoNg403bAFu`nC20)I{DaA{j`9rD1S?&=Xu}C=d+>-Q<gM5~kbvo~^R(QfaT_cm*n&
zc<4HN+`68c2LT0N;Ck3;*CLog?Y5XpqQEZ~$=_Tj_0K^I8>q8Ict4U1Zx}hBQdeSp
zzO}COW?HGDm0$5j4lDKA`*5E&2TY9cMaAm`zP;y%1-*vFZfG6WX%Q-BX~~P-NOmDD
z51SH6N&62LgPB6RoyYi^1bD2bpc*sIs*}v1?O?#2PTqJiBFEx;0mYUJ&0)X{$}rK@
zP%sv?JsfLm?QJS4Zc>_BfN(M14rVqAT^Lrir3zjNa6C=F<7#>&az%c%Lg)nx#lIkw
zuacQN)v5!9DwkBeU%3_q&kr{ZjGX-ss;dM7V(1O0-ri5#zR!|uPcdyz^J~vI-_E|&
zPHnCUc7fU1n>hLUW+2KkHx6W9DiA!6xw?W<pGVICuv9kXUG@W)Fm`m#zJzlRT79ws
zKoC2EG9A>v{BWPsi<-#RQdh^YTQBz6iU6LG(sNXJ6xET(IwNr~XJ5&~p@N*lH8<1S
zADwa(izLdlWS{!Ia{Q3+gXx+_S9~8O1Uwk#UFvvT$!~ZA`Pc@2MTh&m>py-^{V1Y0
z@O}mrBGo6<#e%(BZ`_}L{rY)tnyu=i;+rn`C;NVu0ze#(fsApnRlP42?1I8HA-4l$
zQ0MYp4Cw51FOP=>KZ-2HFB_#>b-r!MDNcd4k}xx*i_b}QHOYeTjnL}k?g^q$DJjV#
ztK)PD!<JM+&h<Kyg>N#tSb3Y^=5lm9(*Foi<jrt6kBE5rxsYl5AnBi$+{(x1$irj0
z!da2%u{Lz6R!_cd2(J+~SPospHuJ5b?>sY{h1$L3^ENtvX)iE1T_Y30MIX=+=vuLh
zDwDFMCi+b5Phn<($LzO)(jzx&PV-v3ysr<$M0gpJ&+w=MztY90Go)-;;#8%W%R@pQ
z0AS^Q%67bR--egTj(6OjfpZ>;U$heQRaJPHyaEz`RZ7b#P^>O<fRO8OaHqvX&GXid
zd+mtxGkZwK2Xv&WB)|>aC7wMfKG>KNS6BU%JM%PJYUsdHU36innlHZx6+S7qcW#D*
zS5XNo&(AZEXGxdNxgSWBcZCaPi)|3@=e$gdD*+cImx79U)Y}8D%6!`BcU6f8b{MkE
zQ+?U5V_Wa!C+lzS+?_oir=%uxYw$Y96;cg!QF4>PP32D;MXf|mWL<9CR&C6mdyGDG
z>9yeAl`#C$ESx=@{;mef=5b-y#Psn|gUXM`%-)Sz{2il8k6W9M(+-W>C5+Rrj5|Ia
zcYZg%|L?f6!yuvwr|v2hG>q9_Hpn^6A4P>V&j?30dLF6ZKc>JTkL=ajWznz`9Ic69
zp?{>pOXKFm&ujOaf`B8#f^llbzdALfE?-XWg|@kb9w<aFRNS{rzQ7xXvt449N6y+-
zPUe1_j68Hl&`Gk5`9`Pfl~N(5dlrqnAy=N@Dqm8u%SFHXDttFmIc}J2ehzof8-M$+
z-W~OXl0$byXtJBhvVXc{^X88DvEhCgSfQ4Husc$05_|8w*9|J_iq_+pVPxUhaVisW
z00#?Sk(bQDjg=1l!%KKK^%wm%;q9kdvKkJ!%E0w{<mXfh%INRwpGEihs$KpEdL`hQ
zB?+$H&F@y>mfSA&=No$G+rNv))55HjnmRP+-GaZV8|Os&(4!LGVC+E*csC~NF$>O4
zMKodHG%oyc=iag6c*tBna28nx43!nbX0SaLO#Aqm!K3>WJW~{Wbuc-@T*0~t1QucP
zirdu4%^J?<5x8XlR*R#~V@&X$czCr%^;$gU=_px06rVG!yyOCNQHJex%zXtCyCXxo
zS3=z|NLe{dmy6lYRl&5grpE*TCNZvA7%+XlH&EkW8de??#JkNR2MNfR+y<S1=}9?^
zwX*3J&m6O`lEAjWMC~RV|1Oot`H=j6(Na5m&!-5j)N*=7@Nz*Nutqnr=mo>)C`0|&
zHwd>bR6Rz}0}m8CW4zq8UNnlV1@a&FK|W#_Y*%!@g$NypzMAW*aW7Nj^Jr|T3$knP
z7$c6oQStT6QKXL|xqVmu;rqeICq8{I%duZTJKWRTcS<?00J>a3T3q=TGz@K_3Sy+t
zUlQ-{#PNqqgn+2fMHo8P8lty^{uK!aSOL^9fznk$C<uBW`tDnI<du1(Rvm#mtUSIC
zD;$nZHb8}_u2hHv(ER%8_XEek#)US<d{M@nRsP;#b$;Qy*sC)c8?cit0^o&*JRYM0
z(=q8#`DBo2%%VcWU7!mq4Kw4cfj|G)6{O8Z8{$bd1>e6GuA_Km>)Va%=DhWh>DAg9
z$%#~RUWIu%(dNDIy;JX$drxClg;E=|5pKyG5cSnApbN}eUhu`iCrtA)Oz#&(h~`;%
zn{E`4-tDh8efj1Fegv-4Tg&JAEB7k;?8%?z%xmH;R=%C~_xUF63h*8b!NOCO@b0zM
zrm(s^72YtyAxiymq^76Kq;*KOwHPY)iA7oD3hjv4&a-ph@KlUzop2NEw~N;D_eZs|
zs9UnA`qx|OBDkg~^^aQ9-{6)rtEy1!zf-|v-rrD&_Tp}1)}LK;Hwp{o^@YDywF|?b
z)%}*ZO*ZB&4Pfn6><IL9e!$ERbg<)&_OU{ZIr^SkJ$Mawj3o4O0|S66=#5G1H4rXY
z3%Cq`F6*m-slKeF2rxjo|HI3MBX#=kqfC1uD@}UeRa%+blH&#SLr=c`JbC2WMg8M4
zi|~*m7RMF$64J42PJKyjE{VvngP+`P?7L!-F5&Un{g%faUw(i^x4Gj3(sM3iJA2Z8
z@AQsE>j&5SMs-+M{mPg00`Bho4HOx1xt;M^qOZ^`&GT8NSU>;p&l2{VjN~<b28=C#
zHSo>&;l3H}+jmxJCTALo9t1W;RXl-EqL&-~<&5t7I29=#w~08zTM+-_Oo;*dd1Seo
z2%n9}`QAKP`>RsNy4gbx2LAsv`aetpt?73g`)@rwwrnIbuX0`JaRP6CL=bbAbos3G
z`rlNs%!LQQV>-u-5H-GiW&PIOZAW8}hrmbKU1YI?`8>yJ<;s<ysyex2gXcACGbqJ~
zu7ugSP|LEl)sxpwL*<)j!Ut&Dy&0k}vTg4eg)eDvCY}d2&7V74FBc<);M$swK6r60
zq1dM&?<%-m@R9)-*?B1`AZnzq!CCy{HRAocGzXEQw?mGaKh`)#v~a<-Yq8G8VP%>Z
z=R&XQyimI-r}DHX+R5}skM05U1K}rXisp?VIQyBw1|tpBry3rXzEUcrpubF5Y~cVv
zHOH*o1@W}FyIC&R+|t8I(Bvyzo?~}se*B<|S8%I`*O7F6PoI$Mt)6}-d-c5zomp!2
zI+Db1;LXfbX!8!tw>9tyz8Ku*6LKxxz&GsX^)}yQcY6)|j^AHu^E>&J-_Sp*U*W$0
zsn@oKhfcp)sx>ZYi>&6TK#Ivo(*cU!t?j|nsVIY%%PJ__`;*-TbV7g!gAO+!Fk@vW
zifnD_AM_QANk*q$h}sDoxE8so#er)iuD&)n*;bfs8zotg@hoFPduhBDz6Qh5>hU)`
z%8&Pn2VCQ0EtQ9?>1!-k8iQHLKqHeIH5uV`uWHVIrJ#7M<NF6g4s#NJXX;<yLEaZD
z&Q(si<vl1UpTBlE?B~~{(ZkyxGx?r3eqCJFc>NuKgne`hCh##zBCW$x;l|#Qx$Slm
zYex%I7g;^?9M0;;fxDW}`?x^pgA}CGv>*$4i`=Ax(yMQ&@fiK9Eq(gIn|ENk>K(eq
zCNb>f0G_X|ZjEqedy$@(p(ceA`+}Jh*viQM4U@dFX>M4Wfvn8t{%UETH~;L@x-0v&
zHR;fyKrQ)m?W@=!6gC)&n3YJ{z2LT#@n@E>Z{FY!>}-Sk;oP;`n$1`*)T&^FzZ@Zx
z>I1MD2;Ysa|FVJxwM;zce}lo5_rpF_@krg593=%txv^U|C`ILNa%=%Ia4|)6kAdft
zhFc-rv;duW21IGH0N>D<u8E|QLzz!G1hVLrP&VAkt6MnZhksW4i}O2C=|z)s;;$;E
zJu280%2jC+yii}(<uQzglp=5fdl1-6Mw#gK7{|c-v}%R(nLXNsoMZG?&TE2qm_f4L
zjDt37bIrq7Y;1TgcE8K{F9K<)sV)z!b+bpfhs_q;{bu_}>vKY!AP84nB1nl>t0;iQ
z6_qarX?MOU0KZfK3N8mFsC}ZHN@q&*2${-jv4zJw`X#)Y6f{o%Mx$bTb&>?RUTtn^
zN8S4^5JS15w-)o`JLUxjc`>xpPlB!kJvh9SQ@^Tj6X#J}it15Xp>8df6{|-REZfNZ
zZ~FB}4eT2knW4|Zvtod5qoEd@Nd^fSGmtJf)>3HlGG<s)x#dc2*bPgFqf2TVQ?}#_
zn^<3r@crYwZx={YIC=)B^gFf4^LHrSeh~X%XY>r{a}hp+SrLlq3abLKBnAp9qlojy
zkqoDj_pX9%Jzz7x(2pj=!(1&RicAY1kO0;~FD8@Cg~Zd7Ys6TZa0jDTDml&)Re6fI
z5D{oJbT1nFqzF1I^`kNzpf;iTABZ$~Tvv@jjw4%}TS>^l{!MUWZo-hwG3i5I2J21O
zeI1#hSu1utqt1gOy*d+3MT6Pfvu~>FBkv@5aIb}m@<EwfsevFOe~9v#ng$3F{ZE+f
zvDcr`Tx_xwJ(^~tI8tzQMgiUAV3XXvSg#oe7L9JfnJ?O0KEAaeomXC`%GY=>Y0&^E
z+Ojt>vOe@B!0Qnx^!q7e+`Ei{IgO{tcjtRDCQnzAWOfPt9kglN`F61<YpsR8`__83
zKHq^ig%0S~YxT{|+M{MFFbahsxgQ?5k}kx(mc6XY{zacBizh>!vMTgrS-9ex2@?qo
zKx=&cDI>3y1L`ILx%;wpo=HtL=9uCF@jRPeDQ1-4C0Cj9j&ACU;FAxpRvvcHvld?}
z*h?Aml*>uHYB5`jHOs<|AWo=fnNVF?2_(Ki6noS5@Q7{Ua<lKlcz(Pm&LQVB<GL&1
zgRG32uC?=aeq?U-tJ5E#-^>3gsmFIYti;v$t}qmwW8}r5$LS@rxj5VEpy6GLo;^za
zkg4~li;H?u+%b;|!vtliXLB0{sT*O4WNcheg}udKvhuiD{|iH*PNTt7m_n`mqH=56
zS<J}I-oJcit}pw~`Q;TkJD&0Vl|{FKI}Ob({*k5muUkz2@nl|0o2En=v;>b%0A@Cd
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%0A*?Qqm)Ey`@tS*lYcO1dQc)`=F
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%0D^{04H7pANW
zUx$(F=vJ9-gy=X~++8qNxGokRDpj#46%G;0oQs&I8GyN@hZGI%c;#ul=6a;~sT<FN
zYvDDYWF?VWDCRfC8ZDP4^Ki*w`FM5j8u-F;oU}b6oljBLWhxh8C35T6*mP-rmvoPd
zc&-L&N)VM>FJ6bwm~z5IvJ?)hDs5xsT0&%W49lQiMs79hk3kwyr}T{_PAV=4j%($!
zroQDu&aG408yesM7PWox;{AQv9&swR!ddoR7^IEnDi>pc6@%2wL+Sf`3X#Z#7${MO
z7h8q0lkg{b6^ZEXsFfCbUVDqSe^Ow(8UMNYed=7-7umSDb9IUjgDp<hm5mOoNYi|z
z=Y3GvuXCQ5RW5PGQ}n5$=IbhYnZ3x6E_p#x7x~j#Zip%Cbu!2p2xFyhUpKo1IrqD(
z)x=1}&+tD`uShtVNYIcECyRtS4;4oZ0{m3r@Lq-WTHa!?t*^03nfkXu`nNiGK=q2J
z?1JV!;~%UlWQY2#-3c=pgzm;$ps<SzSdB|Hju|u*v^qqHw(0zl5L}I@!$>PHhIHxx
z>s@Hk>bUkWi=uiT5Vl>JDKq0G>)(U;EFvOmFVCxbi}Fy9qQ7g#itvJjZ6PJoMzcSs
z45SW!4jmQeXae`OUVc8V@|!jx?u{}3)CuVpnb!9YUsRG5m+@*naH$K^*zL11j9Hjp
zoOJgJd;j#?=dDCZZxJG<l+a~wYg!%`Q=Rxhb9ALe5AdNp6;*rlST*#>n#y#pNIL=d
z<F*KsD6Adt)It!IC+z!4MohbZA#`F<_lE=&ZUlyc1EsoE6m_*cKtHzU@fmy55Duhs
zc2p%J%Gh^Q@Pg5kVAD@SqU)(@c4Uzi3^LmjGsqQ{KZE<1P}Y#Be)><Mo*o7Ou$vG;
zC?EjnY5__>AlL#7!1(|eu4vB*0st}~8!*VJCNYGhtjc^)Y&A1U!^qje)>^xCV6rfO
z1Fa4)_o5TYzLS(;mbU+JnZxaCV^>Y%KF<!_zCK=wXMD4e6q#wDXK;Kyho}4+stQZ3
z6pnv($}gSXk&+lT)=bsunG*^<vC=rE3e*AkrjA;_+orEtT%6jP-aJV9@%hcj-COUT
z9PCm5@n^iUjo!2^HzjXWyg+}?LuD_=UbPNMH9YiCe5|Tn+r+)1ZdAYCb)v?&>FC(~
zJ6~RMLe4-W_rH5`fuD=k4c5k6QM%Iqf!=C{@26e1{YN}=P_gTt^6i+*<t0;3l3&iX
z&+nmL9=jVqk;o5ilCVhny!@=`*!bf|TfO|M%ZA&tTMucqUw$K{xs_xc-%Yg=e64q4
z$@z2n?++cMz`e5Y@0mr%Xep0=iqmC}H_WFiCN@l9M<C*W@jbM<pq4-{<DGy1=AJ%0
zd%D9ODBj&r^cPSB39Ex0TI~&{l4_Cra*^tRQt6Vn$8d?<1om0w|E4mc2L!9qGX=Io
z>|7QteXj(Zo`+o{#FgBA5$E=;NSbD9`)TPawO{Mw(U-gomE?>;cR^<|&{vrve%3=4
zyBkgy)7!tBH!y*G3r1Or`zDU+^O0mR<&CwolVuVFg9iLluh%MhMy--S1SHaNlKEGO
zDeqk3$M?B%qv3Sqmz$kSjXH!Eg{G)ekKg<rH_74sKSbS&JJbIkH}H?0oj2#RInR0I
zoWo{wNC;8RIpvfzg(zhwGv_&#6y}g~g;W&fOgfEJ>Z?KuMInWf-TPhlb=~)$u<P1B
z?|okH=j-u=dK>aEyf>zQ7Y-9q%MfHvU|E7RAfJ7QmZSZMH25rsFT#{#`ojB<(ADFY
zx^?k4W{)@mdEVu`|G9e-A9{70130}g8!bQX18}{yKAG34G8cO#>q)@lxIe|=dnlD*
zBf8}oRyEVH4pR%PZ5QZ6>Lah<E}`jezybo&(!$T5+iG`&G~o`+q<Q+5+TNI9HSJ$)
z=!ns~=d#8jN}n_dR{#214HY+*z|?%6q?PDC_WgFQ$<~A`1NXnu=ls!y!3v3!5YCEW
z0)$lAb>Er(6Cc9RYQx@zvai}D)!{WfmaVvc$ejI|2SR4Z$|twym|6zK{eNp<Ibk!K
zJJ`??_*$-%Sm?^y$W61_HoJEgMIKd`PO7B>ox8W)$C^hv4fHZ3W%~?>GF~!z!A&mp
zgMxnBGcD3O2D@uRq90o({}xH#NqBRoC`&CO@$IipF~!@WXQTc29$R$1brhBnH~^Q{
z|NGQ+`_Z>B>Q&rg9Ez;n<sepaC1~${<PWM~;>CZ%Tf7VFZ(-LC-kg)y-F~cGaNt$_
z>p9VYM!Lwl?-U+G;0gQ$qgoH<@mze7Z{zo<!-8e25}!nghzOag`Rw}NuR7kZ$D!|l
z*g{dxgBBXADlr~UALl12isQ8uxJZUScL10FE%%u(h%#skV&|>JKm++29c&|E_x_^X
z1XqyG`ygH!i3?yQkIk&&g)f9hKJ9KV=8g%!85=PhuNR1RCdl>7iN=nhgpWRUFkHgX
zRcBTFxhW3eNCbf$I;i|}jDYT`#yUdTGM|89X^GPa3Xk-XUzvr|>X8+EtuCWDCKgdE
zc&iO!ns-q6TZBd-e}zDFeC~C<sMO0Iflj`6`}0&lINZmOW#tLd$951~?_$#8rSNsw
zGl;!5r6)Wq@*52|WRBeM^gMatwrbya+kJoyKDg*XJG#{H3>eZsM*rq%Ht75$`Toxe
zlXb{v+oNUp=^N-R83rGX$`wo>`s8CHClvbs-lvCD_$Tu}ApZA04LiVlpDvk$r+~xD
z9aM%G$oaaYh8)R^;K$8UHz%XkT$@~ux)j5bYEYCAEsse*mf@_*IcEi?)KW+$ZU`@^
zj92bo;vk&so*9f-=gIkvPt{xfYVycy_HJ-_)$ISP+4ouVk$dB>Zl3$q5+dB<JL>Yf
zqx@HEv|Ee+oAK9o@Bg|%%4-Q+ba`|C-LIP|&su`F#@{^r;~)?{U35&V!@JsIKqkxA
zSt0v=hQ5iaSp2MjCH&yqcFj8RH!~xix`Oru-%oP&q#zF_Z&|V@T%{i)q>l8I2_<Ee
zs(fyZyDb3Ba3$*$1B&&5F|urAjS=San3K7nnBWXVRkRCL=keV9zb}z@1W-b7mH9Ry
z3M>0IHF|WhgzpKvgzubS7BO_5%oy;UzjOc0&2vq1nct>b@O+r-aoXjgvAJsI8N-4q
zakUw`(~+0$udJMd3;F2Jd{Q3o5>SCqv)=M>z27F&g6HR%zMO#pCN2hew^op<UZ=<d
z)|y?cbaUOy>Qqi#kLG_mUuq9FA7+ECKx-n~R^~B}Ru9}_zZEiu%?dojjQF2Ru<TlS
zadC67K4lV9Xz;mn*n`oa_{FpPf<!|%Mg@J=CcD@T5iWxYWIQL2?l*4fO1dd_a;@g+
zmj*8hZu#KsM({@}CtUB!so3@rTfHN8m|uQD?zRP%KNdgj-r3>kxIt``&Q!Qsm}`ic
z#XNTx%S-pZ9MwN)k`WC(=)T`|kSTI!|0_~~218Zm{ez9XGl#n>$)j>R(_wSlXEp!D
z{B-3(gspj>!#)4{UwY!<8qLSfq1-$=p!WIk!Mf08lhN3yqKA#;Ph79a?EQInLT}Zo
z8L2%3yy_m^x9Pr66BV`F@+!S03BQr~FfQ!x`?$b)Q|BUoz9#d@(*{07on9f~v*x9}
zYI#2l#<f!9(-<?4;g~u!l)(9vb6bNdH_nE|4><`(AQuk>=P70%>mU2<UF=%AV)*F#
z@+^k?;}{KUTyVmw<TmEdHJrfV1LswUa{G9xXpOV;QCrWSswk$6XBt@ZYQztM-oo{9
zY5{I~FmrO>KA?QU2J#8<{y2o+asm@ybN(MG)PksmPGHW2y)AVPT6ZgQ(>#&>Z<SPV
z;?^hkt^2j5rO7WId>B3Vy!Y?FAN~#+v+zUP1M+)o%tJl%(l540_V2B;3VIf_4yFEz
z<r7KVHftz)2J6@=IBQM;t1I+p=;kVkz+#4sVuO(r#UD2FaTh*E9a1!#1~K2u!|ORo
zh-(F^k1YAXe8QAl<<?iyoDW^|KX<BR|4Vv2H=3v#H&{jO3s-)ujM%(>=)$}6%4Xf@
zr(B#sae-B%p3vB*_|8;nArKLkVbUbI;@)DR%1%dreR0+?*a%}Sp(zDRIJPemxw|Mz
zpH1Hb$RF>KTS5gsarj99kT`3(0~qt+<o&|rN6AV1RnAv(%tsc}I)Q|28s%Om<*S)^
zDOsMxhIJY7!wO+}STwYq%H>cE$H-P?yqiWCJpsE<T37%?#}}G$XA{-0Co2`kDJ8lw
zKPmQ^(7CV0c;Vsz4~WS<l+Tjr(Xx#F+Zk#7C%k6U|IR8}P6~ORwGJvY+u`s#*CS&>
z5&b0LcN{@km_zIYqKhpw$PsKu^Y<JT9QP1fAz#Qo49O%j_>l33UW<{qEYU4A^4pr|
z)mMl+fS~jxU)VacPzEUO@(Yp4K8J?{u+ioSdjO5Ir=YmA(E@cyFOO4IYC@!H=r|F{
z4bc}P2=kX{Y-U<CQBM6aNBPVO4Wf~cI6{F~gP-0(Fwfjk8Q^hOZjEnV3Lo%-EWeTD
zI2B^9HY(nDPqdQlK0n9!+b7Zj2tGvtP6<dJ*Y~+i@*7L^9s-!?5*g(PqEw~E;fn8>
z)aRq(WmusBtY~{=9-><=U|sYD;ILDDoV_USxRlsf2MwbHfIMM-n<BVZ0-$!GkM)?>
z_BzuXG!Y=XM_WjN3gZ^VpMJ^Zmo2`aB6N@_T)wE`!0lsxEE9Kn#Xm9yKN!IPsW@}V
z+FFAmfo+;2ZKC(egn0Z~oQIqCY37Nd;^db}R(GR}yGzgE1?i!}=6=X+DT&psi~VZ+
zrK+l6RMMUYzZXk%k1SY2v41V5?{10g`k9kSlN%V5+#M+;zm@!YSi9^c(gLPvH%DP=
zBkNeAd}!X;tIeI|PYsbT0hGpZ1w2A9zljX;blGKEd`T$dTNZD->p;0uZcBloh$6)j
z0T4=@%UH1=l@9Iq=fkS$>{HW7L}bhrYPFxAQGu7v`-3K6Iz>fJw~H9<k+}7uX4#7U
zp&mPJ@VqhIZOPO7`x)`k$oMv*6wR%IyDl1wgLk1SBS<2pULt&b(1VFN{vip6uULfC
z6c0L!f7Yz{lPW%glcC`d+?}c<Hu4C`DN$WGp#;{}B;INv1pHykZRNLnK)u-H#rb1<
zEYW-t0;i7L<Y@VsT%oXqGw|U9huJY?7`&V<I4)iqDXgvI`q#2nsonZ@1CotBldp~B
zLM7%>4!(aG5YI~MS{HH35Cn(Hf154gwwZqNO<E^=RA*VR(K<=uJbGTDO;fM&Ky7d{
zir09t$kD3c<Wz+pva5#OH9AE1)ByTmxi#2n4o}2|KK9VwBMF~I8vaF=dWCq<`-LeS
z`9-w#aUC5H-ZENF;t6-n61#Jqr6V3$BL}QOlUZ<M7i4S*Jd~Ui5dxRnvI`e$s`GEI
zKiAyI%i7;>ZhhB$^G|b|TuX;lOQ(O!-E%En<t_K`xAeSgxp)s6?*acyx7*4R&v`5!
z&p~Jst^0IZQ~D{<3BG52TSZaud?der8}yBw-@~s-@i@Ux*h6zHI248YAFvhTXpMqZ
znIfX^iMwH}Kg!({*mpB%?m$>g(CTcmhUY2ycmD6cCf(%_tpA8!w$G1kGTWaezA6dW
zrk?ik79Z2H20y6nKiwAS=^N`Q^0!T7)JnWPM4l&Y-3<-kyL$Tn3tBjtPQc!uB{F{&
zI>r5iI_^h$^s+|LD1D%~L-)T9!@r_NIl=a4#CWt;1gA)!a!KV9ETjFjR?g`QwXipo
z@-ry2d!g=Mo5huu#4LZK)GV%_=hr-Po^`Q5&<v0G5DB%hy5rp<rZoYldm3sLBIusx
zM@YAo61?wrBQw_or%A&7edlZ@5%)<#BW%G=UiV2Nq6@1X^ohQ#frT31OFH4wd{%gd
zBXoxplot{zm5gZg;;%U$+W4Rq)DO+`5Sn2NT|#;(Trx$!zDU}iSbFZ*-!{L{Hmgq|
z0{M?g4j80u3^E#T9(m^ABW!CRvi`u?96OkBzyl=6(WLvlJbPLk@VFp59SWY%?dC?r
zpM?>-A$4=Iz;O?euBkYyJ3=q<5uvFMc&J15yyznwGVi`9g%rF;g0?iuL|W<|LIFHi
z>lRX<k5wBRZnVb|f%r9s#$H<u5$X@AMGxOQW&bE6;Sqig=F%)!jTU+b^j54LU+a4a
zY3FTB9nZFxd5NmZ2o>rA!no|K8z;_=c8OY;BlAh}j{qS5w`kC}JNMQpziva{-4Tgt
zlZpUDcaWkyc=JPh6bu5C%?S&j3|%3xqn@2KLbL(`YuPi1?{7G{Z>V7hIY^eDTZ4j(
z1nz}iGovY*$DM5&J~&toTb~vE)OK%of2$n|POs*Vz6{S;7Z4c~$ly-Efi_`2K-BoY
zWT7}P&Z>?@qcEvnR444&G-2|!GP;pyKl;2NUxhHA@(Qx~8IDJ8)%-7U=Q~PT#Q!A;
zyTWz4CIky-5%7Kdg~%jInxbfn!6mZ%g|-MP((WipS=1PLv=#X^K<ZTl)8dLZnDFFo
zoHWP7oJ$gZGpy_X7?~d;zmB^J_VoW8@UTPZ>?MyHvxCUol19Oo%4Xvi>2uK!)i8Tx
zxRED310_IB3I<op&j3KEhYZsg2|n+SlP-KP`8<35d5|ZhWLBZ%jBvawGQAr~#);mm
zzW;@e<03^q;U?Ap>3>^Eiol8f<=8&g5;}-_nKAurn%mcJ%LjLG%?Gd-xGaRlB;sxY
z;)za4vWK>>D|`xW5W7a&-EJq`p47jPA*0vC)41T5L=Cq*qW?R$WStLf7w#^bOm>yo
z?Fo|rO`Lyn+gxSL33HOz7rKWO7CCINHw#<6H`v=E^9h%oVI%^P6QScB*k&gAo+YmT
ziANTSCCpCrnjq_4ks+jGdu@4;bwNbL#W2OQ>gA#gG=hOdRP>(Ts^Pz@(u11_-tiEs
z6n;nbFyq5fI&qMrz<w(QAOI(Ni2r{+*M0%Fpuzm~KH+Y<#t0<sUdP*te{ZW5B?di2
zt|DQ_@Q8a8d9%5~vWt&E3BqqsqIC8QmD_fnOj7*8fwSA;BeTv|@=l{VkUuyF3{^N{
z|HN01T7rxe6Oj1aFNZqb2=+QlWwe{t;_NewL`#3?w3)t=@Av?l_<-|#oPiSUs?c~~
zjx2Swyj-FY*NlBr_d+pQl#Y6`e3G;jgk0uCB=)QAu&6eCcc2N1Gv8o-?X~~0VUeNG
zCvC(nwr~Pcjmv_8`jy|z{SPhOA@?mAH}mbAhj`B85)l89u4~uyLFR-$3(`^EN$<h)
zwaCB$s<4;*d@?-Up5h4$J)Dd^@Mi*+)Yd6j4ogCo8cdw=9EP4|!PD7V`>SD07CZ#_
za&d2wth7Y6U7`msF)l7Kxs^-V50`R3EamSlv6PmJY?n)(d!7E^-S#TkDZs0=@@xx7
zB4<pZc|;{N&Z0Y6YA+1QDgRm#e3r2PV#&*=ipCi_O}9@R?Vgk(bxeLuy2t;7CG=?T
z+YDJg{ejAejY;c8@mDz!Q{Uoyl+HHSV0Lih3a6Kev~MG$%W{RwFGS9A+NJImi<Uf-
z_Mb%z&I*stX4`D2;f>Yv0cl&1y1l(RA+C3RZfYMYx`n!+nrZMp{wzR-t<8$gwYA-n
zggM@HP;VDxeytY#xW)%)SD9bcpNoMweUsw;NOXc6suX?OB7KDI>fbK-KJoap81QaV
z{sYKBt7_vtb#nMjg)KMqncS%q(GAh}Z>4$6v4RjRKSo#puXDHW%!Jvdz?9u?tl_t#
zKhw1kg((j&s6aE@Mais$<46^y2ceP0qS3VxqusxPj(yefEB{$L@A~7c7eHK}{UmwX
zf3r?zhb?t@%d+~V{h33SNd>drr>D&twxSA7+VqIBXSdAe?mqOKTnL$*<2V6qo0&5Q
zKkkdpKbBOe{4;d_;deV*$xcpdeJ9C$z&NB=yz`r6B7Vi<kAUYN8TzJ3#eVv&ooY=e
zFKIc5`<<!+y`Cs49<OQP1#uZ7PEY-PbZa4-_5-K#yX{BPgJ0=ad!#9|Wh($8h5{eO
z;Q-)3QKyvYme2(*^<OcadC5Bwx8?t%eD{MpT*#~`bUOcGg0kWhSMa)P(%{(Eg6lIc
z?Md(5fUQ3g6K4SwZWc#{3M&!IJm%~f!iu(Z8P9oQwxoXWP?_f^$9zSbix63_1)S>1
zT__2H(?FG~DTA=4@$5$@OChQQ$s1LV(pO#Y45b<ahpK=;C7bcn*IfXYLV>vPlCi_h
zJ~x7g%YD8bxf#@Z5!&MEQcg@BkeRX{b!S`nbDEETGg}F~pS1d6`0CLg!4EI|+k-0j
zu7wO_2rD~Y^IZ=c$y2mrDEMtejF;*k8@cB9GxB+bO*%}`e=~aWx?7cFh5xVE*EfP5
zF%$!S$GyA5J^68@B48{2L+=GHOet`iG(ViD>{NNJR>CB?nP>pQjT5aZ@`Z0pB5F$<
z3-9mGR!hmbYV|_Rg%7D{Q*(^1dcS&bBt$bPZ_=B1%eL3^^S^&Tzt>e%L<@*&Us`MX
zA_u)8>rmGS*@(bHZyjh8r<KoX6T(3pdpQ9uSC2Br<aE<e(B5g<r3B+mt!p;uu<YEU
zll-&FaS#`xJ--dA5fw9Q`M4^{wNRIQZLix&##pn+rI}kvKW*mwdq=B^^3HFgaZ|2o
zLs=&WrEN!HtalvL`N>zzKDM!wc`YoLf3XyJh$()y?{UnMU`$(k{rIuH=IhUm7u!Eo
zFU?yla;vHv=ZpX^h|QTn;GFhtM;#4ebn%I$rqhb%>XU~aVVpEf@950$Xerpw`_?-;
zv%L6)oY4spTCR3sE@)mzoLE*tzv3f8ZN-&dH535Rw4$T)B3|QFRTq_m_WU)jdAvj0
z=SQW~eAY0Xe!G0dY+EoyvXY8|1tp538pXn4-Bh82U*@zA@?7c2hU6(Gruq7qzG(<$
ze@?B7SKa;-RWWxY_5pk^AqRS?$m${%ZD!3_jJEVt>r&46+r>izQ)?YpGV7v~s!sft
zALAi;sTdhUVQuH^=;pL9J^wbqDIrzqm99DG_dGSNa=86NeSu)+XjM4utGbl+t_Gbe
z<pe^~FX4VikH}iJwq?lsw<7wAeOEB5sPHb?kv!f5WSK?VnB^Cx4a^>RPS5s@xEzuD
zIOEb$e!0aeabeXORQSy~ULguhIa+YI+mm;P+3}U8by%q=U<`XiZfquX_hfdRX3|{N
zN1%ka;+U9h51CCrs2m-`p^Vs^9c91OB8M&Ew8&?lPkM#TaVgusd{b;SmE+T1L|sjV
z3^>YC_6pSjQg{LbokG_@pv+=48w*1lo5adP82n$}TJ~<rRO@#c-F7)8V5Oy8DEQ~|
zQ{zx2gsj+cts1vcoj^>Wt-us3%46AKQsqr8h|Ii;YfJt^fiw&x;1PRsTqQo=k<Sn@
z9Yi)37`e^<?%g#oFdcesKYyRC+<M7%L|sf-m=h4KB8iPr10t;Wtz9JQVtNS}F5A)4
zebR>7_e}Y;8q?U=WGH<}-)~ZYATx%9VTI}tI~#B-hKf+)?x$2p*6RVpJfr#sL7I(Z
zn0?nm>T_NwkMw1rxb29RG+wQA3POhAC`>OqfeGGlRI3L`T38IqEzcgX0zCImqKuVC
z1^QNeNA2B{H?WflvZWWN_rXn9Le=U#^@s?vZ~_<@UV3l5K+?o3d{XY`RN{6i2$4Ir
zj^Zu8co9#*<0;EB?Trq48)#%czL^&_awxr)0Hw%;E1%&iAjWvYzQJcTX@smpDaleR
zy|Got3w_wOrhSY7sd16Aa>m?TeAFOJOv`RAGV6;%YEMTfFX*ax=Pn+gN+lY)9e~&v
zOOVqd=C!Xzl)q#b4aN)CWddtHzyeOIfiFa64~eplokCM)!!R4NOz~=87H%zq0`8ZW
zO!b0O;s%v}V8pIGw_pt@=A%iokFDu^nS$%;qA|Ewi#?Qe^KO{d8*BkVr@uH#X-FWJ
zO;fR+%M&}9f2EQ<j168CJ=f!n)_Xi-he>#?`HI6nmGLdGj?Fmlp)K+0sgs&>mhPus
za4M+KUWb3f<fxRI@(bR6*7Ouy+d}fPWiE`1_w}s3{Gm7vx<e@aZHcs6t(9`<qDpkO
zjp;u9q<ja>G}@rJQ5H^J1;>P3ZmVvmke{SSi3xaxd0s!k5>}m?fh+z#Vt-`%RwU46
z&)&d0Qx_USc6>8%2W2>2N8a4`<HNOp*2Dq5IQf-C4h@7eJite;X%Z%zF|oP8E)@|l
z{a6b7wICFjRpet<;Q-5mMi}loJZ9PMsT^7N>kV|u^npoOk<dOV^*p$Wy+%p7$_bJR
z;I#%n#9P`GK2;|FFzJ9srNDfq2UV+>h*)O!y-M>aE?S<`v34E1-x+!9hR(zI{G^p4
zRq_c%AM&hOqj#NGy%yjTQaqN;MfPOJmMHOI;s81yVBoPV;K1_3o>L$nnTn_V2Yj*9
zi)7iR#N2+`>UD9@N#hobEyC1enu)7s;PhyR|E}r$OOBN^=BO!uZfhgXTq$rAmbS6o
z%;Z0WQABzjpj#JHH6me>n=8|kmy;jc?j{H~0=URM9Kq|f4>p}`R-6*{<J$8Cv6CSt
zKtDj1O0LP+ardihBWDx9Y)8uO8#JF1$yL}DX}O}_!ADX&6k%^MxPBX*Fgum^F2KD!
zSVJbMc1#+Ug<ON-lCEhwd$%I>>pS9grZ8HXD%ml~_vF<!pZwo>=(b;-K@7n-Oe;gx
zna1l=Q)&3Lp2@YP*PiuYd?=CpTfnh0yZi`2lZy@IaU6ffVlji7(?ot#7G><pv(YOb
z?}?f^J@4FPLR3Z)G<8wx>7y8$9Cl~$bmF|;5j3&1PKEXKJ6P#_nY(hX%E`;o;gJ+9
z9W8`HJg}^j_5L%6k3$JrT1Sa4BAs_HP6%MxnSytpj#`|Bk#Rydq9-K}56<)^-_?SM
z%a-$E4O5YY3wX~p4rAtCD0Ht!^&TG?{x8j0b1NQ?-jGC{|8bC&&IykVFQ1nf)kcQM
z*YzRZIxPGbnp;uAmq)l(i7P6sP9X{Wht!#{-sl&vzaQaXy!x0R)GnTkEI?1z!+Rn2
z!qNopM)`Etmc>E`Z)2$T&4SnZ<hzGyU%nxIYG&a2f8@nX+suIfwy*KwxABV;c$qIN
zRR%y?M(PUfqo%2L7i^>8gb;P2xVfrAQyH-GUOo(+pxSNV&r$<JW#h)-Cz)U;cF|uM
z#HqC^g|Bx`%9QWRf~Tr7J<)J(KMZ;%>m<|8(CA?%rv3u@K4rG&lDuI!RwZgl4B2Ue
zC<1+nWo!{1RKz@#iF<&xpu3algf{6q4i!&=IAL*5T4*NG{IsqLDj*i*3^p%&*bq&#
z8tZ3HgDl6uI3{>i7h#5jSeIEo#L?P|U^S{tLkoy2iEcOhfEo>U9;3_e;<;2N?JBBB
z%cMf3q~EHOFaTT*6_>HVWEywFcmnvLkUpIQ@RIw31R`+=TT{fFKu%|zpXDbFGSyTv
zeWnM9Lqo2cf}|_0Gki1$CNyXe;j*29YqNJF4tw_qT5i(}yoQg`hkZ+i{pyDOJBI^?
zh6AUDgBFH^H;0cwMnWV;Le(8H+Eh(f+F`ws<DCZAoxxUY({~dH-sI$rywG|_w(5$s
z)k^1rAlab})-4F|h!!M`O_=WXM3y2Splnkaq1cRr5hJO@JVOtLun;-13_|uBy-YT_
zl)zk`m(BKgz(6|7r16V+jY#|*y%@o4&k<opI~!V!J-PCTOR<3Mp{dx$2EYTBZke5s
z-IEYaIA`*B0#_n;rN(Er;BGeJ%n7kf@`00Sh!Z7`<-@ZsbLx7j*lP=p8EcQPPN_GR
z9jIl}!x40S1lSEggCX=3b^|4mpO+p#h{!mWQjs>zE?#h%0ImRSP;&t6w3N~KL|yEw
zbQXUpFSMyvJl1}2EZan)+hpu+?pS8$6Gk+TCty-kncioV&+KGIqv7e>&gBsPzzz6b
z7btEzt7v6>Y)Hs?mOpU1rMi=ubpF6+!Ljs-$MG~&+z=u*5OHtvDINXnrTTbp2b2;`
z3qHX(@U=L6?O-8LcOI((nyKaeGDEsxCzqhyU^%8+W5z8!J%Yms!ww13oGVM7E^Z3^
z>2G?{+9}bDpqC(4TAwU$I4!1)Q9BW<kZ}g;5PfNMBf{N59O2Yflz_f|0_!><!9T2i
z*?pQnrx0{S8xe|BL03apJE|}6V(;pl?lG*d8dcYKz*6YYy?2f=CeBae5M`|+D!Y&2
z&mKSD9LY?~cK^m9$=e_4X4p<uN*f_IEg3EZ0o*uz^#LQTD|5N+(5fHQH$<n%%kF~<
zJN$&Zq&`RaeYRPMxHA@dVl6YJiy^Bz@SqNn8Ns|uM_`U0q*z~3`sJQMn#^E%F<9fS
zU%j$T&{|#+YA6HRY-d58z@MHrZul&J@dT)FK#YQ+DGX@Op_pkQ(gwbnI#)#C&`G=Z
z0=Q}ZPqj7nwd$PRr-IP&E3Q+ne>j=04|OlJ*F1IKxyC7*;#?bQry_4*ry>4GSaL{l
zip6c!HU_XXCMk(H&Vs$#SF5p1```!t$0|;5lZWnREl+2FHoZ0>Q^#xsvYW(q$D5O8
zUy*)JFnyog^B!aPJ~7mP)*I+dYdiQY@yLlJW^W=h*6m2&=_jtS0@{7hN{hShv_szx
z91fC0MqzsZ7Q}%cl72-!y^SAT4NFguO~<hKpsz0`@$bhJ`uf)SufxYebr0AeUi7%z
zIXtULn{xc@@frO1d73YmLGq;sDORapzwY;hGzJH1OeAgyG^asbqv;CjP~CQLWk1+#
zuF!hnO2}Adnr~gt=9{bkm?mw-hO-43Ked-Zk`Fr(YeYm0)H#d%nnv!VIQvhj`}d^T
zRsVBWJLsR~IUTkEmwqyR=7xZ&DT3%BVJpXUAS=$T!wWq5wY#cBH$9#Yy}dV#Q1$H{
zUMSGvbiRgo5~1T+if%*d0~MS9Au>1;FC8a4eedP*W}=Uuc~8NsZ)*GpPqTjVR^cts
z_bg{wF$!B9%@(`JciBK3ap1%)i59mm)1d5-wzO&Ro&`k5bMoEt>n5KU-}Hidt>3M*
zzNh;<&~tFp%qZkWd=6?1ayCLSe73J`$@QiqWp!~nCTp;C7R&^v)4PiJQ^x_OrFNS^
z+DvHWm~7uqcwj8p-y$n%tjKL(>ZQ-eEDK2G8tlaxFexkZc9$=`*SC6QL}-{(9+&ma
zCXnOl>#P`9J;UKX`}ia->ofv5hsZnuut^9L51GRtxvJWbi7X)=zwBp-sswrB7+xi5
zjWnN*x4%q7nbGJzT4wcQIHJ?*<7&`-iD2e6=B(Sa*hMed=X2BV-GwUWW=qR{XfVUj
z;JqcfTDJ9;Y*vC|#amf~8SmsAU?iXrHe$>R97c+b_hsujgXgcmYopG!;rbM3>3QC{
z&_HhXY=HCesmsxy$gRE>U*?D0j;TKNuprUhNf07yuy-4@e~hN@VM1z$nuUP<uLjBe
zo_Dx7W)cl?MnnGlnVsG#;BqsxNngn|n0eiY*$^az?l*Om`kd<=?qePPcx=$~$mg}G
zBR(ZZ9%E}ff<OB)5SbT-*}1tE2uNz(=iuL;kHNl#NPP*_{1RsNCEW2##E~z@Bfmt#
zge_QL)7i)CWkTlBkU8%o-+K_sl{|F$OHFT3rc9qRhpIm-X<qi;ZSROk`RiPn#nZM?
zQ7|uMzPBpcMG}66-}p0++h=2)ky`=b1=IT7YT@pR<5a1TR|^8?lo01X%meYvLuVk|
zuELH>*2hT~!nJ-QvXWI%g^Qr;<5VmR+>v3VffyxZFMfrbgz@`N!+~aJX@zRq%B#rt
zp~qfjv)uK;*~`ghOy3Z3d`e+D8CrSqb9rP;`F8|+4_+N9?zgwJ*hxQ|CGCo^c_9cK
zLBKttX{s!+W^6|x3tTxyAO45%-Oe0-@G;YXc_%qM_j+~{L)y44*3xDg6v;gM3vP)<
zrMLCnNj{P5IFrLU@zA}kaqm?E2=mEPvDi|;Vy(!r|8+h)BdyE4UO37nAgc4fFVE@)
zha;U|xFhVB6!qJv0<d>v$RYO+h{-+pOUIK#u*nP~+>2HnoOQOvEWewDFW1G2eyopi
z0>L0e^ViRc1X;ksInb6X*`*ecKnq5AiekdkkCi<hjFaEw_eEExeR_}|p2t2JFCRxw
zd8Qek*;`-t$^HB1hvmuD8Fsv$D+J>t3)Uk{c1iiMUHRir{7pw({O7ynr|O`4f;`_8
zni5M(NA&)bvV42#sgMAf#Idd10bQBS<OB1Uy05y5!32&3cVvkeSk#6J1E;V83shKf
zz6z^iIes<fnS0c!J26<FcVFTR<hcmM<u$n%?`a(BaSW_>DI*Farc+z>-$4B?KjXN}
z>&r?Aji}SQ38yK@1m|vL-#?j8?qjc8)hZt<R?#wsFS=Mn!(z#G+yr8Kd<pgYdgdFk
ztoA*4kgk2|pUgyZhO8z37E8qJP^Qs<)lq-Nf)70*)9m4vicDzS#b?tM3*P@K2Hk=Z
zdmbW;&3_i-GEKA)w}TNG53!nG&xAUcRAft4BFK>}MyC?f^CSOZr(f<Lvkr;=0<iq)
zYt<Bz)+4DiA(F2z{m0l>obUZ#cLRCl0xM4PJ?NM}9IOs5%;uS4H!qN2x=fK*#_NEG
z*U2SSVCmA6OY4=XbJBrFx?Ep;a#@&haCWO_2Hk3cjV{YyilH)Z0?gkr$8N-RsLYE%
zpFG#p$%3cBt)n-JqHooo69u0CZJ<Om3N+dSxf6y!hOZ2RYrK(}>dUT|Y4|`rk;_?4
zpIvp3Mm!KChhEi7UjhSd+9|AC^%&T`a)ED;;jj7)Gx-b$FKj-#?%jW}ef4hYki$|g
zDTR4CCHrH%Q&f1R^-hTv2>Z5aU_G-04RZ0-seG5!lKLm1RXZJ*niGr7s}Uoqfz2jj
z81Tt|&IX2-K8C+!N}H%kKM=xp2lv|OADVP1NV;4WebP$*Ut4|b(b<6IODVIXk1w7-
zp1Uk1x_h`aDE{Jl9{MltZRYLt{)?&pJ?3{@@0S8&Ro5ODr~>Uzr7_P%f$>8(PRJpm
zLW&ztKn?pz?di`o{o2#XnN4WWL7D6mU7!^hzs2P<+;_av-WV$iTRR<*VZRPPxF#KN
z`a0I5q%Hp0SyqL`NPI?c_)e!c>DS1<z3(o0*>4K|fp2;^K&R)G^)R0b;NmMAmoMEF
zCa*PI$esBE;IQd!FjcbpSkym|<QDgD=JL|*3jp&>0O<eLA5#USjpLTqRPYwu->Cv*
z4!WPX15)=wuszA?naGU5<891}^qn3)_HCmwd(%x&UwDdfC;`wq6P%dx^3(GSyt2|%
zDl5d3>2mp85A%%Q!*nl@#PC>2gL@{k=B8JfF>sLj`S(As?R|aI9o}c-|Gg;<87~#A
zZkoFDL-}#bxvh=WZ(D}5eN?!(LEJWWo;#E+y)S;n7t0I4l7h9jekkC}xN9l7t_w!}
z7JGX!HCD1wSJU}wR5Uj9$adzZLk{LBM8022Al_|Ma^kpHP*-IfFRiSZJkO{s*4>)9
zZ?QgRDXZ$FbH#H0Geq~;U0d0<-;C3HJH?J`cOL-{`Sbra<b)*s{ys-gKDKB5J^dR$
zOwL9w2*u{NKvSS{DQGIcP8XU6hy4_gL0m|9O2k6h!gvNE%o#0r8s?8mX!L%{P!yPi
z;h#ZRqWZ)@K0*AKllT{QKXG9QOV8EYhwPVIEyk5+;yMpmJHJn?J8gq9pR#wiyy8>r
zr~;YtbiV0R>fj;vJA@9n`c@ZmeL|bw_z6Dq{gh`Z)+y?>xbX5IJ{&fyc`d3UMlIi}
zqZ?^<_A@w~MiH>WRA<PY!_;Jb|NO~idP)MY1UEGxQw4g}(7^4&2Dvz{gt&iU$sci1
z1@B+;%J>zTS~*$1+yRdD#O|3GVC?O9V2a@I8_ta<bFnS<y}@tZCUuL9G@9p&NoZeq
zDAIB?;iC~Gs)4W3CAfvi`t;$3z{wWDHb}+&Cc8I(UN+k^SeFmUWZ(a5(6c_i->{d`
z+~r|ALUd-CiR;%D6|fH!!Uz}rWytc=NRtV(SO_LV^2tn6fms5s1Jw^Gthgz+EQq(2
zx$BIod%1)qMR-MKy)7x>I_k@Igl_4S{CMbXb6~^E%S^%uFA<>NGt&R6qr-k~WnbrG
zKB9HPur!y@W`B(ME2h^c;DYIEzZ0wR@`cf-)uyH#aulP7i-bQ)r%bPB5Kc}};uB-0
z`bXY^Dy4kyiO2@{zBwi@W)_xue!)z31SNfQ`aB%h<#o5w`|In%gSM8RO9L*Zh8lz`
z?L1@LiSs#D=vw#m%k`@lt-dz3RL;I{IjX-M(st~Q>%RZC563^a`R(EUAH9Er&y7DC
zY&rAg@ZR-F;_|eL_0MPfxz?KqD`}fwf>(;3=;nEQ+HAc)&$Zc}%dxZF`Fu6q_Rn(5
zBip~L54g6w>rd?L{{8wd-ENP&^X-ux_upTx9RN<THN(v#LEZ=j^c>SL8c#`xc2+AY
zlxC=tD8h+DV9~~Y;nP?kvyWkllOZGh)g-{6K~qo&qQ;0<ah&44ErJq`>(Mb9=sKu|
zOpv~#2T|HVND|_=3lzS$(HyN+xkrrTJX2$F2_eOr*It$R?uJ{;3KEQW3HOJ3sMhp8
zaBA2D>o<E)C1`V0dXPC}+L3Uv-Xjl7HOf6Ugi;5MhiKWpk?}|Jr;(YN`FjaM!@jCI
z2_6J*%mmBC1Vj?hUa%9nGG^x0QM7W^sa>e9$u-5vDu*)M+Sf3Yj;mGJn^p~j;FS!V
z=aOMFIXeIPUARa6J1*T7Qr6z{teX{X^p^0vvVNL@begr79bSU!srDm@Q>wDVA)|u*
zXPL(#s=ySoE{wM}ng<C{Ec6~zjYj48_k~dfCp67_uk;6W+^%>o|5;_hBjbg{5~WT>
z%H~Wx^i*A@*NlfVs&%f)&CfIKjm7n_y4l>&h<e!~fj+$X9ib|{&T7#lEysOd@0)+c
z0KA$;@uO4x<XD3!4l>8+;+)zkOoWW5->A_!qkP-^7jn~jNX=|iZpzA_tlU3skE>DH
z6vmM9V>CyzsirHlhl+l}0r|*`=h1OtCU0=kn3&@pbXDgg;=($<gZHge+wdZp9QuU!
zh7<?KeJ+lDkUcQnZ$^~?>+x4}tUZWG=>cro8wGW0YoX|stUGOt_kj^1M&;=r3elcV
z7kuhS1;A{WO4a;G6en~l!=s%&w;!V;te%&i_N%Sl=Hx<d(QAMLE70h5QJOZ%%3$SR
zkLVI)Bf_N7j2HD}8<y$0?00iwTS<l843}0kyYA0tWOHbS{aRmrdiI#|fQPgEJZgNM
zVulaaH%J+5X{6QlEAM!ek<<K8kGj->Tl|3RIHCz~URCbrCrfoz7d@o@xWzA~7dosv
z%O{VK?q!2f+2qW`+%J+liMckJcqZPp44I$Clrk$4by84OXx@R_fQIrXQdE)Le{y+I
z-AAD&bt=NUb&fd`eed}4Ud!n-bSP(9!$;~!4!GPAsjrvH;4m+zq+S;TnWFsgnd?E7
zxDP?|sK5`W4JAAtcBlwQ1TH{RMuYb@j$QokcBpTEaY5){5X?$W$-qG{U=wb(z(H&@
zssKLQ!}VQ!%)s$C=PNz-b;CT_$5}0%A+{zpx5OC#V+bi_<2@oZFzcySm58>%4DlPw
zZfC6UFTa^I67;`9dy}W?ZB3iOQD3}o-+y)Up@88r{cnCR@4vqL(Dde+8{dL{-hcCO
z&$NxEzY;3`V0uKVMS|02eWSY{^(Df2@}cy}LAGAmTJv32!Hw0kZuR2O_uLUH{HH7l
z|4(vX47Qy4ihY>YPtFgV!-kIhUY@fQ{P5qytp@-rAfpo;U%>NvvR&^yT9Z_@s0|)-
zu_?QH{67z&QS+fWALuHBhD_MjQHQC+opAOt3n-X6+DN`H@zVR2FTuUlpSpt`%0Hvh
zEo+D+qF&dW?tzW7MYwpxz*^zBC)H$UfhZIAB4-I}XI0%vDoDqu;r5FHny^H<#Xp})
z1t>(lBPq;K(kE%<4W<goXe=@AGCCldZq!ws>*D%Ycpef1pz%3A(*Y?5p#@rtH@y2F
zKX`xP@)4~&FTaO;?p;fAvYJOh@*YUgM2@F9eIIAA?nYcW#Kn$yawWw?tuR9Zt)U2^
z$7I=e?inKQdNbKzGNKgwJJlVZTNM0cP4-1)-K)DcPshEDuMH_BW^rw(D_BwQRq*$M
zb)i=`+*v1)5hhb?82&DT{0+ud96>meTFZ{zpPyG;_JiPcjO3D8D#Gh)aBJh<{kQLk
z99}uv9rNcqDir!5&c*av(wgY*Kf$kg=j9v+k7wc+W?rI*D2%H&uL(C~%tD>6wk9aE
z;selKgrNlcH2k?uUqFW79ZfSQ4&UC%p9mfID-$XzLtokq9&bdiYAbMiXDR9+o6TYu
zQqh!y<Ayf;=RcZ0hFDZeuxCBDp$q47va@#yN}axP5Ux{|51-vhm*bW%K0?`{E7>32
zUP#J4zwKMyIW+pdA1y;=$jyMS((SR^S?i{bo*tDR7$LJbQT%4e{w1O%gj_ZOa;tLz
zwjUE49qmvM`LfFwG19-7xqWNAX47Y$GVDv!uGf46RPPI|(^WJ?#*FJSwTTRaT-eWU
zWz+)O3Hz}SMVGk&MlFaa=@5?#JLzT+Epi8SAF7%o=jZh*>=q=q(D`!D<#&ZY%w2Qq
zG;ul|;q}+2#>fh`e|ONzo6kLNFlcsqU3fM~g6)8L+6M)cp3jY~vs_)-4!eiHJ<gKa
z%&DS-ISwzr**IFg%e|zafLEBY5(pYlRI@ST!mb7qPD8+{Y|8stbSg#}V5&wXi379K
z7lQZ>Li?@*IKLHw;*9d_+!ecB(CM8)Q`;BPkxt)oh1<&%u<>>6Qvo*l5n;QBZOK##
zXNn4kV8ZV#*@%~ovsZ26lbtOyb%)wd+5eKH7px3oHu2wV#+8u}>lF%qlVZd^s_Hsq
zS4c7cOw+)=5OA*v4+&7ORO>WV#a?)>8n1DrNZl9aIE5OrmMGB{;x)?AGp6&6h=P(g
z!1yVa{Zm?M=U^1jcMjUe6MoK>cqZq$R6zUC#9?dFhaYt_k5}g(*uWp~1t;oh+Ioii
zx@$g|0G(O|>-VWdd*t|!jM;5+sfXJJY;%=R9v^K<u18x5_De$;7NPGS*o^odJCkAA
zKM+Kh`a!yW$02;cFJr&0s;95UnO3#qQVqxS{Iw)lkAwvxj39CxO7OBU(8i}a+aH)J
z>OOXLbLm*v(tAUf`UFNpiZRS5zah19F>Flv+)b_XQX|EkT4^H<$EK^&UN>C$pmp&}
z!^Q7f>AxG&_q52B4Ki`>$goC=f1d12znr(biuHh^9$kjGv|ZM(Fhh~WIMQ9B8D>L_
z(@TuxCCcvxnHjv<_Fxbbti$Zj5E#=y63tu(O^^hg*67fPK|AE2eHkU2`a)p_WU(1)
z%cLoz8TnF8*;3K@-?`BQnWjQUW4e^RjmeN6dN~{*{4C6|=%Iur((KS+y35km+JKmT
zuHDigP0o=~uU#qzVP0%1zu8ng-(b-?ro|gnchOv~X-E6U0D<<}0L`j#=-TV0JQ!IT
zNi3um=#&j=J?&>2(_Cf-Lb1z*22DlAkn3NguYGS&ZFJPe3~A)T4277be+ZOvO5S(c
zB{A6Lb4~W0+FL!#3c0X-3XbJ4pw(db#+R@4<BNK2yg31VKTD@ZXGm>kSPjyrHABrf
z(yZ6nXpaFIyMisyU_<MH>~|QWGQ0`|XNII@P!C;iZd7)q>$o--9nraJ+(b~<xfvUK
zYkaX1!UeFqG~2}J@`=W9-xxdevKGtf-hG<gjD5M-pj`ybe$D<mhG-)Z-E#k{((6H1
zenEEmVDwYIFtRrD;W8mwuWY2{Lgj#?gneN!Xd`5$@+KlLl3+Uv#y1jxr_{o8G3Ll2
z`Aq`QHK@<F2NDV95xNZvgE`HPH@sF%W`-L@#tQH2jxm-L8y(G-qE&=+`vjbuq%g)D
zott8i{toT@$U(B^2_RAbCRO|L0IXBB)smMm-WxPQBW{_krmNCiHo=u%F8Au=0PLX2
z6u~=@cB!22>G*&>XN4RV_XI?%)ohkQ$Jwgu_kLN~MuM;Q=u@#bW|S~SQ-je{T=2d$
zP#in1G<bOxJD8o_-{#V6pSDWQ=BxYTWM)l$`#X-%7q>k#5ba8PDCIm8`JMMo`QW0{
zu(Ya|HlU`rR1G7~j>OIVUYUfEEg_R8dYEPykgr4k%6OqQld&<dOb)sEV`TYVIc-a4
z<dqd&rZ4XI2Yd;2^@bG4c$080tyyMDZz#K84?<o&_d=e-v|Nhbp*sFx{7AQ@#xC4?
zCH1Z7`SP!u6w5|ObG_B3=M>wNmK^^dEiPZ%E*|RrLQ`)1Mj;#WeO&B;^~oz3;xQoG
zZGz28eE8b8t5TQ&mpGN(C1}7cixLo^3&Q)}{8t~d_x;osY1t0Ag_7n{D|K#^=abSa
zbvNI|+c8gqJ`w80=sH5Do>O@eSR8<B-M<9hy4VIi^{p`S#};{z&_w_YVb_g~(w`3~
ze_0t4L3}sU8x<qI9&j|<#`pT)R4s}2{72h=jY@Z?*&zw#Rz};TgrC}wosI8e57sY+
z#pT#G3Ys%zxBKP#bP2hQ$`aHidyLjWW9`cw+EpFft?PS@#ya;pbRQY(jdtk0FxG$5
zq5sj?V6nsChq2*ShatCPd-sb}7rxgUuZHnZ4?&VPGSp-U2!jkGwcEzveWtq1TYUqj
zxWU}+_ZFNGi-msj)PSiq4X@|4&zB%-;2_6(lGgXpM*_d!o9lV3^(U^^$@JrGit_=}
z-dcMLcLHbdjpc}G+X1x2uo9haiiJvhfDvv)KXu{C3JD@_YP>OQZ*Jl@d)x722;R6X
zHjvM~&EA4+FE2q+*p@I8V7mE5v~Pk^qi20OM-7HP+AGlP66XmlK6O2<V`H0++)lCr
z!AX+uMBagr<hNlV1n)kYl*I6UqJ#a9jH@Nk;#PrkMkC(fJ4g08s^&U+W89J>y?Cd_
zGs=hym!L|7scbt5<asL*b5uA3V1uE1E7^*FXlA(AP9foX94a5QR%?i==!{pbdyhr#
zBcuru=r8?@c@Uoc{gZbh?1oM*WopL_S$-Ij-sX<j(gVVUI$iW=?m`4*&CY@$>S38d
z+s;b-)SO`mzv7su?C>CV%oA%Jg1a$Bv=}T?57#pRD-X~@b%_30qS1`Q=ib`PJ0Bv<
z@7W{Y*+T4jSKYj{n0-I&s^y5^3!0RxLO_6^nbebp5N6U?XR^h>K)gT@il~Jc#P)$>
zGT_!iC8n&w=$^~=+ne^C{i`hVbk?Y^)x9&dXMr9wt$%~LviyBlM#-2v<}(>;dILe|
z%Q0}Ap6@W)=!j>;FZaHFi<1ZUPYqZMQ(vh-$fe%KlbRRrfR7mykL(+2ULl+|9~7Oa
zAs@WEvomN>;^$5Mwd*%#TJn}W?XCNi8)AYPwDYAIZxaOC2`RcmDd#i8S^^`c6NArG
zr|Qwd&waETJ8r;oO0*wO!_pO8E$}S7H|a~>!Mpor91Jlm<G3MpA_(1@A+yReVEa4u
zM{rjMnvq1?5KxA<MXW9{C?@4ZRN{{d0%pGaUg{>Nv{H;+Oz^D(LAZS1h(v+~!CUCK
zt}8w2mZise@c!CtI|v-*x@Ai4G&E+oWelin9=7e0EvB8-xoOUj$T=kXB+0isSrvMM
zX?Eu6*28WSn`^Zf_d#TKXr@Ts74)6PgLknkB%*zg9!~IM@!90o*DWc9V@#jfj1z_b
zT!WC^#dx3MwcYz6Z}AuSR<6Jqrvvup;A}3h4#3TJ+Z^AMLf|;qPD6u<4;lkNsfbh{
zdgKlCQ~0z527)tO0Nap<iW*oayq-x%zs|r#1RdVl+!>5m7DnY>x^(r*R#stn9>eDR
zlQMH+dYk|mu^VwBUo*t4uJ9g%#LPrES7i!yH+WcY_AAo|kE&S#xemrGid-6B-SUu*
zD<s#MPo=EK6C!Pf{wIm^H{P?CX~gU6DOy<+O{o1#(jitg4n6F*_V~}GfM#-@nSH%+
z(~eHP?V1LdNOt!P+7)iaw8B$Eik$lJg)?D=Q^fYM>~w2d;#2eeF9^6NndwgngvOjy
z2c>u5J7u^5GYu}>a_`9~!r27!XEEhkHh{Z!J6JLBGE9|7+Em%EZUHRd6~!Pnu2XKL
zbIN8x_H`B;A%w3+bk6OIgsC?UNA?cg{+K|DsHWo;*FF&>YCnv*p^5C^lq!QpynNc{
zU<-HK5UcgGcAM(qx<ZVl6>$8yM>~R|?O@pIw8-~skN)lx-3G%-v|s#v^XSJIUfKE4
zvA{#Wqcw35qy;MkPlKa0y}MYUgiKKt#}bReFozszqsXbQ!f>YoWjsT|vMAy}v6g4O
zcX!e8gO?3MM@lS<Bi*i=Cw!UeE{-}>Wk-QYTJfI8wN8baKKDyv4mTXCb}Y3jjrD0c
z+8+7peku3F(Obv*8It>xF}w-rQzi8QO`M#z+XM(b2Afpr5Png=ihvi@8v6ekF`CB6
z*3i=afs)m?<HJV_RDMD{AY=)kz16c=msEHs89Z^L`Lx*6I{-uT=!a`Yrg;CISqIIs
zKOQD=wR&eH?*2HYM(jzKrC&Du(Eq+SohxW?HTBHm3!8F>{n1r8T`+BDU&@MlxZC8j
zn-4J+A+70ESHXzlICjUH{IP#Ooe%}PzOd1MgtOSa-9LNZY3_Y|{CaKZS6vp1RcRpB
z{0&ugOBhmrV7jjBu4`DU_$$o$oI5kHn&VZ1SHS9(X*`FdOvJncGHfx0D-@$mMyu!1
z0=c_zM_J*OiBV-0UB`#%pf3BHJx9bH*?89?HFCN!3SqsjlbwV1-Af(q_SxNmm!IBE
z5WSHHDJ&4w-d!KPnK{0>_|)VL#Ot}`a;HEc^k36Wrm9?=8#)jYrmJoWqpFcFSj&zX
zkAupdB12pI>!pdB@=RkVl4pHca7Y%>WgOY0aV2b;@~oS1iC-Ov-Ls73rSzvW`+?UJ
z32cYxtm{&~Li;ehf#dPk=b>5pcN-1gtv6irVD{Yf+yF(_-A{O~bD%BVL>6PMDkl^<
zX7G=n5kTo&t7oTo?M%t7!mLj9oft?vq^5mM){z}j{x%Gqk{S2~eQs44ICdeAt3N$U
zI~fZbw(a;gN*JH_<t281`Zb6moy7F2-1U6)f&8DLnWerGLSzZ;>eLQ}aFBD9@)>#I
zl#1|kvRZ&x)$Mv8N4J5xvXJ?=qq6iYgLg~i=m~deRXzT`D&0EudDbazf4xYr<7u(+
zsGm9=UCCoercg47?34opqoS|e2Ft*LC}`ADc^e;D1JH+>xVe_r?2LY_<r58DE1XJM
ztRi&+=yBlp%D!CpXjG&kWxkN+!V(hhE1nAeN9*^wnI={M@EE)bLmg91<+ARp4SC2X
zQXT@aAX1XXiH(@ZwfCt%DrzDZ1V>QL`6`oQPG#4;1Ohv0ku$ka?jMl@6ipScSO15l
zd+}%Tj~hRJjoF5=17?ofoC%GbQ_V4_9CJQx4uvQrsff)mr_3>@<XBG0Ii-V1juDct
zq;f2sof47#cHj5!Z`k9p>$={b&-?kJ0ui%l<)7=&n_)>dx(WYs+<zS3DmCHv33SWp
zzwmJ(%lA61cR|2xFLfXK$=n_O`P0aWN<x-Efbg3-ZX@$QS+>hm-P~0qkhk6nFe?nA
zB^c`Gw@Y0+(&VR+v->2hF^h*=;y)rmCu9W?<|T`Tf`DuL3yqD(f+Ki}JOE6^JySga
zl+z~k5LW`m@U)_L1U@GRJej;WpQ#@K>iO$7`QTY9GtF7mLm}pMSNsn}DFqGTO2Oyl
z6&ixTWDHtjHKFn>LqN(@<|Od62hZjq@z3EMLnmJoTp~V4KWtmXf%FxF+$-HnP>|KZ
z7f<82WK8VD*$@H*WNAF71f1JHsakCh_J9Qhc?_nU*jQkg&=V~{<<Q%M+Xy?bvBU;1
z@HfEee<x)h)}Y!!sgUEh`r@X`<==6M*--ABbpQrk5)GpSosyTtU+B+?ieGugQ^N=Z
zB|JBT(PUzX3ZmQ#rwqC_vxq_Jz+^^>w&qN!J$@ONOiG2`t?Q<Y<(6HJkU>eVXI;rK
z$1BS+PNbo9a+|5T^Wu|{)0G08D@77vGZ~mXBe{68iC`uZQBl8^PKe+}D!#M3h`xl3
zCw`F|*_jspR^*s}euZi%%aD-Ft~JS9P~fB`r8at!5^F&SGTFgskPNkI%BwZg{_4Qa
zE<RnOo?mzB(pRSnapyYQ{Cek(ug)#S&iBseH+cX4>dF##X}OW#7^wZteWKW<qbdJh
z*rjitvc_UMeN^(X;NU=&jn^r2Z%o2}fAf7p!w@Bxj%-j)&RK8)c7@~O3XjeGb^DNV
zm%?P`QwIYEz;2`Gr&R#vbBQ)y(;N$y&(6{*APv+*6W(-I@0)q1!h@RbFKFxNP~-Fv
zaPg}&fq)=W;)Xr?m4OVpmzhPxgLw4~5r^FlG4jze_lFJsbiV00Z@*E5fNvn~%UvNy
z!q!QQ)!!ubf3Pd}OMHGW_7$wp-whO!5XDLRU5&W-nUKuN^qr?##jhr5cXE&rN9Jj(
zH=2XT4yTZVMits-L)J*;-9Ef_JF?E@DUpND^ywSbg$z<QA<gm;fRz>dRQ;UPG@ib{
zaNjOAQ|)t5gPQ0sM+c4b8u|OC6scb`G9k=Ya^?}4vEzxHt5uCrpSte>p-YzDl@RUr
z=f|nz#>aoa%oRg4Zd?mL#VRS9TzUGvkK4g@Xx4+6HBovd8BEjVs~^kV)=0~Vy{WtK
z+wF_J7B5w4>I{e|6EQ#T8Z_3`E%mLT)A;2>TKNM93C#Usf>f}Cpfaw5`J6DjiZDtA
zTUvIabJ>)1YE+vfmzdd2$@TfSSS%q=o>5r!$;;Km&1Wrt>mK1&${zcTjCM9DTh_d!
z*oWGsUGp4rf*T*Q)fI*dXx6B7KExClaWf<|X=L)s_y{f(zYA7KJoJEBpjI8MUuxb;
zTD6u|aCO4}De?jevhTo7+<fE@Inwa(aR^|0;lumw2lSe7%GHEbzCSwy3MYFjeNdGX
zk;>j0?H!g|g?>g?l%lRwo$5ES{?f4;xOG=AZ#_Qiai@|9gRtzs%!~?qYGgC=i2wU}
z>Q;sItC%14&ZF~S|Iz7|^V(-DrMI>;4S@xi32KH|8k0b2ceXbX(;>)eGYJtg>gF2f
z)~&|Z&WJ@bjm7aT-Z!3M-|6;aGdv%8U?u1s#+R>MO2@y7k+WvwC9S^`;UV@BYFGN+
z<vb)!G6kb~<;?DXD2U=We8P2T2A}fmPvb}F-Dg}Rex=cY?N5z<!5<D|BO`ndOT$b9
z1x*D;NWO-Jr9YS#_M66SyNx`at%9t|wu|KxWhE)Fpy}n8>`D`<Df{RnOV<dnCdT5q
z+p#Ow{g3l+ZEsZI;)=Eo2scC@ZnfNwv;7!*pYY$oAC_;<bywW<f-ZY^;`a65_iz9E
zahbihfQ#RKb^GA=1GdA@w`fjOx%SZgKmS1X4K5%FnHqo>DIspu^^`37lXZQSD#09;
zJ+2NYH`n*CdhHXwnKwjj{KPe@VYjK#ZnB?Mn!z<zLIngdwj+_}^$Jd>LN2m)6-nV=
zB%_TN#xoXhHnOs1ufTE5^$cKf!^q9luX}MBf5RwAi);OQGjC1WYBWo(k_bdA5$Irv
ztK<Lcs!<&I)P%?cWEvTDl`2tg^nG;@mCTa30TL=*6Ub5#XqS_ev6u5>N`CLbFOsox
ziU22^1Vmub&7M}lcsjLz&`4h$SquK<xy&m_a43{!3?;A0HI`3p@#eye(PsjSKV)PX
zP%UOCBIJrpF47pda%y<!LbN@;zDFXa3L8b0!UP~?*D?2$4r>uxZMcAOK&q!ka<N(<
zaz%2VAnixR<V_$sESn#9=yD}|@RJmK3<8Aq<5pR>zT4t$Dy$1+;r6EBhzLoOK}{}@
zSt*69%7pJJ8EX$VBN^chmibm3wEvbHxKR5iKjF-wz!=C3(h@uf`G8qQ43oe1Q*a+L
zCB+=Cr}ao25Tqx84ddR_ujToV`kXdoctz?R7LC!3Dfrd_oC<+~UPpm?_@a5G4VtYt
zjCRC1__|^@x&~@wJW<_)!O({=^3cni6I%sfBOH$&6jH5{+^(4OshM}AOZHMEds)g)
zKnj7aDyjVi^9yRjp>m;_c^ia?momJcgFLUwLlTuz_Nk7I>$pz-=`I#-dq8C+^75wz
z+;_7H`nl)TgmeSbD)zSJ5(hDyQWr0i+u7H^Ve5Wykwp)v(&lH?37bJ2V{ADQBlt=#
zN?vfI7o~0!J6<XBs9I#a7dZ*xI9ix`5+B#H*fI_FAt+e=2mq$)&VZ1Na@g8D)<Z+{
zN}DZ^AQ<x;?UN-J9WK?hP{l<)rSM!}l^VH9)#DIi;mNumjE+duOkD^4fDK;%S)qRD
zjxH<L7MQ<O$+K%g%jT1jlB8&laUmWJ25%S*0|^4cAr|8G9su53^<pcmS2)W0cqhfY
z_aZ4ip!4)1zhH$>G8B<u`FlJF8ExnJv`28Gyy;BUZcqT~JGm6rZgOnP#7N83EXvff
z-SpI!DceEI%sI-;z1_@v%Z#FB9vEdFEIc|$meCzM2~?rJj?2&W=*n;jE+^O{{rKm~
z1p{hj&<mo*A@~eoOIa?VNS1ks))Qn!3-%Bv?krJLj?D?geV||)=l>QU0a`lVm}+yR
zSEzYPyx0hP11XEFu>Si?{v~$-N0_Z9NcRLv*?<b?5-|O&^4<j-SsA!b1?n=<9(u`w
z?+qT#5^rP)^KnUdX=3%-t-{h5e-4z?Tk?h9#g|tYJ$QxTS^R3#8>aIMr{pYqM*+vs
zQZNOd6*k^<3@DyCrRe%bLsmv`RtdMw5?|DKYZy@+;~W}kZ^maV)KsDVhbjeja$=uL
zw>}_X=`4?X9efYvfJTscXsYum<K|>2dU**uB`lj(VU4E<Cs$nC28C$)*|IBay}7Il
zg9xfDEM$Ri5D@xQVI8CbxDg~t6#{7_!O{wA<QQQRpHxbD4K5%HU??KdmT;(7bt8Tj
zh}o}@T6OkVNE4QsB=Pjd&lr{0s^UoB<S;M7@#@a9k$A1F9(BKvZIGYuqV}4F%wu`n
zT<~4YGD?CgW&?B!(>t&~7~t3^zLA&(ujDHym`%e1w9~CWvDP_c52Jc>cF}j`xqZ@z
z>Q3H!z5d1O=g1(?41|gSDiFmLVyp9f;ZzAfP>3M`^H?2~L6u-9Qw<$PaGY6}WQ8@D
zimxt5MJ-@6j6^3p@c>1%mLicx5$4kcmM_(E5nRy}ksy!&7akrdPj&@mi-RLXZbnc~
z;Z>-ZgK|D30o!RLZkmY~1c}~Qz)rHf6^un!g$Y4FakN%KY><?uHsQLi63R%d5S)hO
zf@|J$t)0HFCxTkWN5q(;>zA%p8Wr2T=~k(dI#>wwQ~>-Is2LR8WDRzkBB5?7p*igo
zq=6|0#m_JF%_^MXk%4X+m2)NVe;;h${>+Dc-EQ^8Idu!UP1W59#w7?`Ye~9supm9w
zAAjNZ_3h8NL{|0B6w@Yr$f<M}DK4~n=neQHKYPO;#|S5sE#&@9AlT@cITm{AD-nQ&
zUb@cJ_aUCFBnb@VCNfwC`oMWPF)E2)ZD%TYs9$r5Yf*T(tDRfAwjcK>RX(Lpe6Zq^
ztw{LZf1ZGqL#fg6Nh(6bG?pu2*kF5@)6+P!5?K|9o0J2MaQ=SGE%vFzO_IC#a{50)
zMiM0hDuZIxh|Q&>mUc;H5U>_sd_=hfi>cz`D5=(zA6s2>ST4AIUj~Nevz(aoN8Scw
zEWROU9MN?z`BL%5AD?OgxI&6Vf2x{8W#IG6_(!l@oy4P)qGrWLf<Mn9)9xk(W$VIC
z_-7Y#!L+xF1nB~oWEX;2Da-vd^bC6uZ?{PB;PLwtTA;omr^aI}zW6%IK0vxN!Ryl5
zqNM&J*Ry!0rpyl+VH<f5M^lNyri^zF2{}vGJ6V=++FRmV0vExoSc|YFM%ae=iqcoj
zi|zsCe3RvZaF$RXG=}GsJuTemJD%*hD%a~D3YAH9O-%iD8Mi#oKdcSVS-9^jQjfqQ
z+<4LDrAw3fA&acRP8M#yqN#Ua%3gr5+<}=~mR_XSJR}sSfKj282L%~-!v2PVjUPDP
zL~ohk^FVoizin}g{3HS<neh4(A?e|ccupQcslxhzOnCIS;i$fU+ym>a@8xgP?vp+T
zswW<CtWKIXZMUg3>2Zx^pDpTlQ;7Qm5(g6aWBd`|J07P7tYLm4G0*K!UqT2PVd3gH
z+Bd$hj@+BBw4aybQH#zOv~zfR(c25snhUrxN?|&y8c%IyvszEW+qma(cU`1!$=`T;
zFXLo@3`cJ+=rnX(7QY%rFxA1Wi4k7<<6@5zqWXhTT!M~$O>YhE5l2*C%HtZ#<wRAa
z#?IX0>UnexrFI~aI#P&tyOY|Gzp=a&YUN?+Hc0~;zkvL_z<raiySn5%>3H!OeA>y_
z#jrKFu@5WIjc4)1he(k*1*s-I#MgJYpPu-Qy)5sy_}+3&USma(T>=A;S)h2qhHy<F
zA3`O%&w!xw_&HmIb|usG-tBAm&ZKL$FXUFwBe8VdY12yqoB4;h&4y1Esd@@_elJJ@
z0gJ1+a`UR#UEJgud@ljVDd>fN(jR^C{D2zuZLgF&VR0K28mw!kxzM}88l;u#uHsQ^
zC;7|0hD8J7nK`*UGMR8s{M5YuWfz$Okl6<se3gP5V;SSPko#hU?~<>6&*32+1Y$+G
zlVsDU*Yh@2d~2&0+DS#Ttmn_C8T%B<$JM}R0G69nG51N7LFQjJ@wNI}4GO?(Rakc(
z@?Lr;_^2;qnRJ|}51-~dWkL~;z~bbMNGaC!#eiuxNII>2{!w+h&wHHT`~UV-femhf
zTc?k+|Gwnwt*~C(A~fM|oIHGVCtK#}d~e1yzWJYq^<1uqpZA8*UBP4bLJ8Q#d9}ag
zQ`-bmXG3fwsfr7K)RHEULqI8*@OACtkSr4$S?Ry?h@4W3{l5b|o`dN<o@x7{y(EDU
z*8Dg%XD(TKYW^f45=T1AuO2FmXCbHb%synm#z8mN%V9lZFj2a_4af|9y(G~EpD@tH
zov`%#%aX})Ds&My@fshgi!)z9bWsweWUxMjvS;Nn+Y6PRLuYwdNG=u<44M<`6|?Va
z<E{KsBmK4JKqH;}b*kq^*}@mUd^~ue*XHNk$gtz@FTOmz;xh^Y$3vvby8@3-%d)?6
z+$+$9PL>7O569w>o=kdtG%E~!(sHVs`!i_H*Wgz(HS8+k*9-yr&!~K=9JOhSpV0#f
z6|KSC?|w81J#Kj-e|v*R1yyt_VdK2?-#fi1<24s32U)=lQpw^S+}`nR0u3=YAIZ1T
zCE|QfC8#7Vp8heU;(j++I)nOf7XQ|F@8>a@@BFlUUmLLx*%Dt#mNrYG?Hm}NEWJU{
zzJ#{Fex<mXddB(X^-lyzTE+cFvRKTLbUQ&14>C(m6DY3OU#O5}<7pt8O#*db<6j%5
zhf~&wgjDX{y#JbXXk`0e_gytXxx`>d@;lda<%8KQ)lZw#XPuu$$$EB%vOAG7rv7Bp
zko4ejIqRE-Q1!%^(UnuVdY8}irfQ83s!U=GzVT|;Pt~1n@OYA@-7tO6tNZFdKApyy
zmVlAsW9gV5qNYWXzaRFtSv&_Kf$EjIB&O_1sVm8KiRLPtkt!rT_Osp1VjaiM&N^9Q
z2+H8n43e;?*E+40FLiPfJY?_N8a&OJZVK4G)jRdC<<Ldl&hKyA&%Jw^dGx{0_m8jb
z>5TmJZTQ%io*v~SSa~A!PVd!O^9u_G+Wifl&u$#+-u^MyeT~ic3fK5+c_8PD*{hEy
zLMbhExCdXYcXzkGy?d5*;@S0fR?08-D<N!V56#jocdJr3flqyqoG5r4#wNH%ZaFy7
zF+L1RviSKyN{aM#m>)ythJ|0MLK(v^O{HnjFJ1j9%s)eO%)&oY=L5t4hQZH4|E%K&
zumGm9pgtNEI+bni|4`(NXm-DVIX3TRhp@bzqt%yy0*~|h?+7z)oATFulQqX>rrTwO
z3>r>5nC4z~K;O}R1@|8oH4E3z7Y5qhT}rP0{c^`5zMrS(b`m7*Y-O6d#~YQe#|*|#
zynqYC?FNtvp2UMLEnBjTMqN-|;wk-t+R8`ZntYqG;h=`5r{W39NM50r#AoBPgQOfu
zZU%-DihgwhR83uVe*!-}r1Y%3&0bIThkIjg3YSMgMe-w#GdFF_&p!9yL&%p^!#g=&
zbBHB^=rH&EzptxBW=cN=162x-RB8jf_3u0H`27ugcCc+Rd}2M6Uqqd|MdMw|u98@f
zIa^gGhtQkwmS09T*w|Xi6(5<Q^TJ*cT`qItoLcH!q_s=u##d!@d!nD`Dk<f_`r@dz
z!QWSe$kUYj)|uahdi1{3O90)cu11Ozk|46*gYWVjk@ss?J>qB>(e8DjUi0j+_LSWM
zj~UXjta|Ny3Us_}H01uR%0_PY_EWOd{+5^8pJCm$xc1+XsPg~5=h~snEQEohjeU`0
zq-uDdZS|hlkulOF>}%_Y=7omVA=UqM!d`~P3tr6_6^WZA4P`{J8Lzo1PSCL8R%^QO
zK<%F?k@cO|f?`S8C`m&P0I&m)^5`DSH*j<F%Ycz<+x5e@Px;N3n&7Vfp1!G+lpQHq
znc6mZU&itO($|<5M_fZ=e{mSrO?Y1>DIVKC{HYmBPZ7@ib>u2A00A^Zc;*B1CEQc(
zqf2gjU!cOjk3a3-M4V@)SvvM4T`kv;IHe!v^lHZ&P>3idVHJP`y-ayv?FN81m8&YT
z&i9y>YaL?x%Kj}58=mfw{JLf&b2RVIPr0_xI5}zFM2kbS#>t_Xy)u{Poq#oRwykhQ
z#6gAdMsamd_EvKMbZ#z8^TBgsn!|}D@t4|oKOQVQSxxM&rGKc;A612#F<kn*tBh?T
zY@UZ~$gND%<x0rJ-WZpkG;tuD-R#v+iOk+nHWuH{Mr?0IoN*)#Sfv$aWn=jSArbxM
z)fA-8>S5qMGSzthKRM!Y>wHDy^03yyLAT)zgNLg;QVe^rVe>Ms2A)84F-m3y8Hs(}
z{V4ITMY$#ThuGKDB;hm?|Ez#qQZHa4;nz}kDM%svv_bx+vDWje5w^)~s(1CTUF?rt
zmUZJ!?Z-eOb+6Kw#Mg-yddspU{_p+Mxv9?$;hM<Ao~4i^p=pZ^3N)GJn9H*z$uKxc
zoZVV06~3nwcIE-=8vJ=CC?WYOJ>{iekOEr=lQGa`-U|tf6=sG7ImW=nfiQsPrDy6a
zX4a?eLU1g_{HU`V`Tw^Q$ukj>3%n;evB}PbyVgDSDTd*!bQa4@VkSJPi8nd_#E*K{
zXI9dEeO!$JY7Op$soQP!m+pnu*v0J3Om_`mYI>Gxf?u=z@A215_hWxF__FzCI1_+o
zx>_Rzkv`L>65Wy!*69Ca#U9GJvxvzZZD%}xQya<>xKwLw2ad_t)8ayV&KS$eEI_It
zK)YH5U4wD5CdtFBJzMEV(EGKSxikx_=C1xDr%N!J9Q!nJ{);<#JxjPU%-4VS&V?>9
z5#4c_NbdEMdfRJtaoOioY}lJnIV3@qqNRNIoxE}Q2Wo9&a838eW0}M#eoj72*{FfX
zFLb^cX?I#(t$pz1+H!{(hi8d=maS%IyqI%khQL6+&vo{rWRsSSV(tTeCL%L;A~|=1
z86iO~_<aPgXZ6i>we=+Pj-;sADLyViYssl9-pERM3_ECGvyi`F<=>q<_U>kS#uE^k
z!38nyiWiw@gYqp(6$BCMDe_Z{C5L<#>d{i_)%%qJ@x-@ug`b*qAP}AlM|Pb}<u-+V
z9&R1?!<l*&mB9A%M-CL)oIvhJu5x{@L(1fObkU69AQ3Lzowmr%;WGBb=M&eiOu*9|
zWu~~t8#{LnMcUi370PbDH`(Ws_z%`k=*85?sQQTx5zW<uK)l_=A!L_cvc_b#SK!m4
zl7;VU`M0h)xd^mQ6CVdl-ftIq@`CTxc&3#E7cr}sQ!)8s;whUEA#h%`3R5TjKS2}z
z(9bRM1wEY)+D@ep3--15&nIiDP(A|f3%FnWJ*_39t1(L_?I^@iJ#)n_%WFK(_SX7V
zKB&Sg-Ihhm-n_<iEp$<1o^$rijkU;WkJ&QK<Dkw9FT@(FAs@eZ6m;*%X^3iOo=f7-
z9)TKp`jP6rD#TtiTOa0}75l;rfpwr#JA4vun#8S48X33+HBRncS;h^MXNDD5P85z@
z`|?NZrQJRo#8BKzeDO~0NJgL<+8%b8(?NM*ptJJp*!#D*RctbG90l+We|z#%$DCLi
z=zoP`)gSpvdAia|-f8I8!sgd&Vwc1I+*>GAsgUm0xLxzQZgocfeAmE<=?Z>(n2AKZ
z<e&mwBZI8w-`&t-_$hrttNI*O;;sfn9l1%o({SC$EF8RX9R!@hn)3PBq!-Ed&PTk9
zkt*Xe;aj34$t1k`>^kmLC@Ky7H_)yC5F<;p4?dl{H+}Ke>*Z&P2LJlOGo!XIy@pP^
z{QK@{X6J}CKiY63u2-T9g&Z>5Iq8=fr&o3E#o+QWs3srdv<l$6Hn8M^NZ6x7Otl0J
ztB?nHc5tghFgrZ>k}mQJUe#F`m|sF%1Auo(;8!`1jV2rwAUcc${t(5Ns6Hbiwr_c2
zmR|U`-nmS3Jy-9dlS-F=Sw&N>Jq)bz-;EG3^gnk9CNlO09bPWIiHC<1Eo9fjM~GUD
z<<j4JAg3nbU$ddXq@<%M(I7_Bwo$-=EN^Bx97Et`0<c!rg@aFLIHj4QEvT#ptXG!T
zm55;5^C$bk6)B?P(QsKxz*<kZsA3$q5vgc}lIIlhOP3_L9np|?jUFSSRe<=9%;O%w
zpr1VZ3ef6J6v*xonx4P-Wf2BJA+97aScLH5?4-MTxDP_gOf*m*bj|fFjT^+~>!m?u
zCkzgVd>yNZLcDyaoDl`DYOa8WycWE<u03`naah)3Dlw+N<MMKT#<k0rUHnXr4+`a%
zC%W`Fsp*klY%AwCU(E6o@ES*-YPn(vf=y&2Qkg1_2{!-Z&LOkb2L&XP(*D#+2?;6w
zAR}iI1fJm~9w?$FQ(z?7^8oXZzP|>W%y-=p%HI+m31|WO$Pf}j>(2!b;UnepK@f#V
z+-1sMQbY#qh)>>G2P4Q96R|?N@pd3QUXLtod7UHDO|VX=q2f0`qr*vQ<s@=-O8Aaa
z-g3odXkkK2OTtZ^#8A8{R_?Oh0wQc2$#LoED2U27!nlg3caeR})&9z`w$7EahkMS@
zv`)*-Cea@16r?|(J?e~ctT5_uyR2P%K@CKQYa2%(rE=uZmJB5_N$_q3|3!V|v-$XY
zNAgmKqzZC*NwRva1fKmfa4H!_Bg3c(L{Ruy{6u)Hu)qtUlr1DLohYb~jfiHU_lSIP
zJp#uRBd%j}Fn_Y86wgY1As3oNWOrEM^hHb}it?`%MT(WUusmcm;49<2l<{ynfXd}2
z13jt#0TQl&>DhL~CJELf2II#7@y*CJ4sALC?eDpn7F_m9Ud0XrsGf0mtum-ijEY$E
zZNMVxK|ps;8V6|X<&vlxM{kY`NBp6UFbcF7>;SrZLH~~NN3C+F#mtLW%AHX962i({
ze=q;-&y<NU;6@=t^^v`n*fD+N=4CO7(+0h-^|+~8CWVNv5lNqUs~%I7m`IxQWz3B!
zw0=uGXdYrjL33QY*~>g5WaKUrbpz0nG6IK+0!l4>d*Oz2f3A<8&9TidQFSVrPbn#p
z%@uVK!Ooy3BjS+S<i;qDbcb*j;uE{8ctRIx=BmWX5xTKi3F2&ml7wgM@fyQ-9~oV4
zH!7&@<%vmv#%QC9D1jUhE^6G-lVXzkw>IKTfg7sMnR@sPszRpafB3ruBs4$)E0*TS
zu&<2^sXv}`=71|wzu@}aul1&m?7DwBb>12c_d^;^XdVf@nB(OT^x$j5iAalQDvi&r
z8efDo4x}{>)i;g|H;#U7e8qQfLggO+V#XE=!VHJKuD=)6!56W3?;%<uiinP&6?(Ls
z3G2M~<&lfs0{SkMd>N$iL*=|X)oZw>>5qp?aWj0V`Tky7IJ=p*)xn)L56hW{<<7&B
z(?tGh-`@G!e8vo%>lfK-WJu_z=~#(qVJ;&^TF7QF?iT(wipK7EGF}YGwC7L6^Ca8D
zXYug4FK1Hh|JOC{IU|+c=A92w78Wd%mq7ZrsAGY5^N1!L^d?cX#YA98Sb4j+&F+wO
z0*xwks1?+VxB)-{nCy;M0irozVcXq{0QtH^G@O&17vS#*K5FhjBj2*W>EqCnC8KJk
zbQn7rXx1bBAzVz0&w|rj^LNe&In?D>tw<fWj55dMiwNDRiu<08NYqCT<OoJb7;G|&
zK=ZK|j&_yo9lkC{?CZ@4Lfuae=W#}+iltD=9sv@`#h~U2ZX;Up$iudGYBvDX!5MO(
zgS*v|X~Lkig)WjXAqbElMOrR08ilbI-6IkPALbEj<JbuXM#S3p6^+_YMEiFL8e@E9
zCLpHmEiVr})e%bh^q}FaMyq^!<g<p9pAf(c(8|}nDrxZa_ugSsd&pfQek$MnUT%Im
z5eC@6cB0r%Dl4C4$QqU*VY&oE+jGwl-&Ft-6hq-vzATDyO55$>Ymik=cI4khUOuCQ
zUhhc_;%6zADgoi4iX}0Z*IN|or9lnG2S~VME1x?rL%1lKia(T^*n6T;3FR#H!d;2O
z=o<0$S;E~|^?j!dUF*K~IY_#;sJw6vb$J-_!oBf@=gSw~-(UE``zfmZ{x<!Aq5b_1
zkW1t&cuuzxS1zR`&TXRK3pH@|rEA%m;N1npT)8;I6q_0@Fb#MHQ!=4jm&q6FTqAB$
zA_k)$yZ&iI%48p9R4W!(M72=6ikE6A)DrjXA<v1S8>Ox;NYw=rECQghdmgknV8dhB
z;+sId-+H+MS7vK0El>QBe)LGCq3iw`zH4a6U@kx7G<ZH=C@~guu~g>CSCLEKCB|Nk
zgw^m&RKSzgd#{O0BvRm!M>}O4c-z;Y&SZ^uc!AFO(RtM|7HRC0s!}Gg@PCZk`K#$9
z{(nLmEhIhp*1^ZKh9?WlyA|q@#T8zg=iEd`FNz2h1;C@2dTYp+1<pKor~>Teo>U?D
z=}n#0tAe}X6V9?|FJzwV`pFk$RDy!iQPD}+UNbU^K}8R9uCkoAVkFN@LXWw|5E0BA
z#Jq}xX>;;HGv7eCcyF@KGRfdz9G=TvU@qWjd5fAb*z|=QothXPmS8hWWTUC!;xide
zlO>qt{DKP45%zw8&Zz6P$mf7Iy!Bgc;w~a|?MNhy0oV(Ez6b+I3d7d_^$H>07XQZ$
zIu4qLpQk^`e{g$`JX!qE_T0YxZ7-D~!vRP@$(J+JSG7665`x)^@QM=!kosehJYS5w
z6E!%`j@UdTuu9IT`GL55YnGczU0bu|)=)N5&SoQpLH3W?;W6{4r*BD(Kf#DZ>6Yie
zcQxyQeBDA+HOKGabvsyNCs@eW4<<a_d{sH-mz1U%(>xpt{1OL})X-yO<hdC>{)ou=
z)1^#z5*<B)QGMP2#1%-GsJ6#4M+8DMMW}J`Y9im*9%9~vjivHFgc!`T?dP3)Z+*2y
z1}mat!o{aaV3khe?%(eUUYz4Ol^J}o!bbIDh&<07mf%br6;i>|n*C05y(-1+KZD0=
zYS-gH_U=?EAR4cluZtW9P>;x{&A$YhFLyDqj68uHQ^6Owr><%$mh=hlDk_H3th`VT
zcX|qM?nJPb-@-nevvHhFth;=1q4c*7a!MOX#XndjEemRm+zPv?{lY(<FVI5Jt@<XS
z%$~=Y1ltO4YoYRz{9y^bd>9AbjU2rvq&shKA(DMGJ;Sp%k>WOC9coko1(54}dre+!
ziDJ?9^|;kX%AdoMc(XJS!!MYvAfX;bmHGvQsW}^Levkjbr?24m@4hEIIUqVFhl}s7
zjeFnX+)VO57L)Pp>B|1zmk1I52$=l=iND1VBXN&D-FngHAF2ab2If_#jynizAh8vw
z-lb(<GP0-JQ~KuUxZ$#!VX0bM{fpzS0pYL`lDo}sx%}b20Ubwm3O{mU;A3Q9V8p`r
zgJ!Ev1Rl1=gOD2;hns#A?>@gKa9>uXOpy3(O(<UW4wL`>IPAFfy2Pt>sbA|j#0KH;
zhOFI&{DqAwFDTp>H~t1TG{2;X*i<ut>Qd~U&2<M?@W$=JpD|Ac`-n7y5#NM2O-`Wc
z<L6~t_;Rme7S+*~uNn@#W-nQ7DaP~EoMIyi!g*2?6hI{C-#8KfL%d~Vc!mBuj|!{c
zahUD#-wN?35AeOrX65er-!2-;i;jg~9iDU<{yAs2{x2zra0ICki}|EW<YrypU26gE
z@Z2E6KZL`J#<f`hzlSKWCCSfG^$&l9wUc1ZJ+1HX@Ri{|oOKV;g*E^Xy<5?2ofUd2
z2R^tp4ut31G!*4V3q+<*$Qrc|;HN4DFI4${w+?7Y;^NiF{t#reV^+@7OGes+@Z`I~
zyOA}9Y9fX9a267=@frOqN9bt>@;u-EcU!1I7mq0!c6bGm8ZT<`M=)3%m<(U!)-ZS$
zE=Fcriuj0FuA)sx0!;zr%mF)z-+p}Fh|Vjb9xyY$V8TGj+g7_xEShDAX`f%7nOHi>
zB$(ZhbDvzc%u^<~SZ-gq{VW=^{cq&YVdOA{_p`ocZ6hA988V!~-+ZI8BX$(cH+Of0
zd_Q*ev~7*Yo3GA|?j7e>X5V~sZKg<BiJ8ChO}H|u^>6btB(Q}RgZ#JQ`kyW9GHB-K
zu@bvs(_nUi{M@Gt5~#%X12K_zGwc3?+46RGyxwlCFij6&lj!p4moj?Xef&~D_J|Lt
zahaca!Amc4!6(H;bz=7TS!*`y)Z@bnXXaT+2t}W{orvYrAOO!*KKL;Hvt#cqXb<^u
z{2bp^{+{>vi{FH*con|0U(K-G(sS>h{rKVEwVm~qYn<wF+NG0PzBMn!eq8_zf?Dt3
z@BU;xFW<9jQ&WB)bEvi;_Ik+$W4=S}YsT;+rplS7gKmP^vHPia+a7SODGKPJ#RhK2
zTPQ0ri)TP`fbyE&C-F3{Hib+r3wU|+Cfq7ZLm*vi!$L0i^kkRw0dIL}RM7BURDPt@
zs<=8I7dfwZd+4mRV(Mc}AO`s;^G<x8iUl6ZUH;;M{8HXUTZ3=yud7_#rbcdG+9*^h
zOk5N@E2`FeZY(ciXZ8*{88{Ur_7rkxP&{5zjiZ4MKD_8;d-V6#Yxt5L7=3avCd1@t
zZ@5xvY&-XFXE*=+OD=2=6Fz?l>qaF8%)@Q2#)X_H67A-vo8+$$)9$WttN8J5rCU%{
zezZqO`kt`_rtRNAiB|pZZO`!MB9~S4BvX?x_WP2Ty`$e<`r{q5lz-Xh>bH(RKCzo`
zF8f~J`~Al^fg2M;rt$0Skm*7P1(|xC_O&q0N!YKh<1!lg(+rX6m?d%v_flbWYakSz
zSg(|Pi#99vi7%h{@KZ6UL|H+YXvpR0lKYlo9ax~hy?fRc#58fDyK#V15bA3G$=s_E
zLzYDl$0}JJf3vH1)Y<OhK~3F0t+2}di6j9{ab9z8r?FOr8(NPqqH4%)d40m(Gn9$$
z%=5|GKjNp)m%Ly<c!G%y=f5&MP)D!Ehe&DiRo0Y8I!692`&+H#S5hSYvG%L0h_B7X
z7u%_&;gi<!S=}-9_Ao@}b&7iC6~2wnJ-Lh9P(whRl0Izf$Kt+h9JCPppLxc^<dVP;
zs+=Jnq!)laKh`Pum|k3>XEOb7w+27cR`Wh;?YU?Z-&L-im8XC(oSah(euyZJ^VmDP
zb0^p;d}N!Op;@q(#oOb&`6Wr4hcH@vK*<OI*CVtd$9{8-lVn?d;b=;*{c+P1>w)%(
z*$#=h3L0tWmJ_9?@a{nIGC~_5#|)51ROVf7uFMRGvkRdk-_6spXps7>5<}vrgRpmk
zF?Mzh!rmOK6b-RoQneadFe-Md7P1}X1k@@{cy$@6o<XTn8MmVZTeBR%cx?GD&7l*O
zT!e4Bp2yuIGS-F&5)O#Z=kK}VRnrYD_a6W9&L3!YV8+{2;tjVd<4XOR!}@E+{`)6U
z!#i0=?l`39R?E2vw%m-JG8Rl>rk$8U!aD&#eYcrgY{suHr%w$SYKBBVs;UR(nEE_#
zDMs_*1y^9)f{4&DqXP<m;<9mkcUnb3?O8edvKp+G@{01IU7MgXIfQq8Qh`i`=*2g5
ztKIPTgsn-wylV3Vt?YggtF~us@I3aO=HQY3)JzLWN51&J<ga{OHoWp1R9*u|)poXJ
z?hmO-h53v#Mgp@ar`ACV&s$^f>lEJFU0KdJ-x&Lk!rLVhAacu%-dEs+bQkZ#vga3?
zR8WFX-DItS8FQ%#r@UWohXKuFXwx?B2_S=}hCLQ!7iWc19$&(3S$r1xxsLFVl)0|G
zeg=rSn44RjocU)DVZihd*B|%C0gtnUIjxe4pU;KA>{TTKYkIuLh}pl5avUe7ru<%l
z>rd32^A>G|V>llJ$wZV~wf&v=9XY_2F?Td75Dfrdqo<#H1A_}$6t~a(pUDoEzcwd;
zKBL<BfI4d&EWxd3i}MAtl6^2N!$NQ4k~_|w^OgXNyW}J(N?a1d!ddKM-ix>)fFwc^
z10sq|`Rc^xC-5<uoG2C|4hEg}%Fnf}9p-BpP0<QEJ-z3A<Q}}*KPPe_2mH4{ffW~a
z<(db$hM^R2^$Yk<b>*|is|W!l%TVvqF3G;fi>hyFP+bcTX25q{Y2(pzMjjy<lF89h
z9U7lBvhyGfR$Ee`mIJY)*C-qnl|Lus)bW^ElS*v0WU$3q%QXA+_`IRiRsJ5$8?!0~
zFn^pLUk{-(;&kH+Sz!pT&0%zK`$aFi+t!gLmCZVw8PUV?k>FBU__`_`Nf4~gNtAiO
zm241oj^N2Okp@sHXo*}FUvOw?wN0S>UH4I8&Fa6?`)Bm{+3G1TGA`cw@x86XV|VP@
zrz1TU@6M8-9^;7$Q56DlL8gix6X|E7s-*q}S)BBk%(ms0Ds*AWv=c@sWqe|*<txl_
zF_)lmNsBp>in<r|ba(a3I;rfh&UPNtk}a=9^I8P8YB-BuZglNgkakq#V)NF&UiF_;
z?W^I>%eKBO-EGIiW2OS6Ud%_C(<??zr@;By54TT<Xa9%~y*9m6#>jgT!#q@vCLCA~
z8KQb+erINji$#RrZ9-zhb`!;)e;7P8W6b!Tw0&s9hw<zmD7+I^I>&z#2FU!e)=glc
zp6qaQrWhHdPy)P|0sZ6H%AnD?QJ#$Fa>fpe*^@gm?EU>b+dotR-DcLa-7XGXqambM
zOHt_Fwi*_V+>Bq2{R~$$Ftyl5crnGEL0Ts9j*EHmTKO$d{p1r?;!OijxeGcu8jn62
z))`s>3k|M!t-pSWp1?U|SG+dyehm5J@zP|WPPI{jSb|RVvg@t|z2K4cNIW@l1*&06
zY^uog!B=JhgQftN1Kn(kCNWMbjccE0P-2#_h2w2We~G!iJP86bMMK_tTq&{p%}VU9
z86&Rj^mF9r*z)-XBfj{ZKAfCT2Qkh_5S4xoQjY4t(uLs;@Gw}_p9FT5vHkt4UJnj_
zyuNu0TXZoga1-5j12&;YJcnkU{i?px!M2s;Ak9_Fj@Vu-BtK~DT_UVX%XEC|aB0Q8
z9W)jGMbFQuc;X5ll^%Zxc6L4;J<Cwxs8qX2X9m&W-K3(y2UV5|Pnjo}8z}=Cj6jvT
zUcKb(;esp7#FqxoF0Da-`=9v3p8)pifm9zC4dtFr06UfE#dJabbZ6<gC7)A*-Xy0S
zBRAwW(;^E~ugv2xx%6TshPpB=`Wsl0lH#1e(=e>8CT6UN%0N1{sI1-at1Y2f7ztcS
zDlR<y{w*}HHnqi=*RwG75;EDQCn;P{MsW_RlxJKFll`{~O>$C<-l)1elyWWsQf$vB
zx6fJW)fKfdO#<jdBS!oh{T2I>To?;tprqDk%pEnJ8>vTM3*z=*@C>J=T&&>nm_MYZ
zlpDRq1eCb*vb$*(!tv$Mr;)uMElmF7O(2ppuN=woC8r<Sp)uDX#2~3WW@2#y^vlIU
zCpzya<;9z?84?Bz0j=gxR;>&Y_H&J+A7(qKnwjmJ(@EgQ2@?Y%xN0Xwt2XQZ=*T>=
zOqHs`$~!a)wmcq4`o*LLq8~&4roTEu;CY)BUw-T2_?>6XU;|Z{<!+*;J-4P?scg1}
zqDFGjPJ0plaLyXISg$8>=W%@PLm(!pNRRnXAC?v+Le(q1JChQ{?C;?|S!e@0I>S$O
zs(4ylCz-?L#nwv?0!UfpMuYL>L-41c)^K5kM>wFQVo?K7h>9l*4_M{;IA%@)s=P0u
zy4}dcb6|{R=FA4vEruUMm8aWV#gnbfV~5>(NjH~C&-Gw0khyK?mXDUp)TymNOaTXb
zi!+d;F`&1<!(f%!-RJ7SmJbcDm8=|Po}`z?g-hukQ7K|%{>KowFlfa;L~m4vrf4J;
zGr@U5sj-8{6Y)vKZZC^DD|cFqfK`*RD@>TiP`v%aN8pn(u<QdT*3GVNrA^-WRk6O-
zJ^;^%UCmgjHK4%;Xuv~nkbXRg?z#{4-Z`E)F8Fx2u_q5<GS9yXPoQ9Xa@~@+tQoJ_
zYtT<#ww(#K2iA{hwcNyr5xg>kP+<^nF*ZxLoS5TQTUWSn4O@rI&8a=A*3x7?d)KEF
zIvJG?3<^NfAWsU50i{8oAf3b=k*hmp&t5YR?Px<PvZH2FxD0rw>(rCN6N|{>G)8h!
zVX-MHnFiyI4Cl?86X>D~CF<EvKDHAzq<1TG1L53xsZeKBa`8JF_;1P&qg1!rBs~Ce
zQVHi8e8X@z#U)74WF`v;zY8#uRG3`U*ORqVJpFz|qe5OW0!^kFH9N)hA!lzYaZ$)9
zZOv4bd87F7WP@fd&2sQ|ECjRQcsLNH_5vdGGLf{F{3O9{%N~(fIH|%GNI3MyK@<#J
zw$g~%sfe9vQRMw!p>nm08s3vz-g2oc`Ok1l>me>(rQ6FYw{P$Rx-oBPg{hZ=o)G9Z
zpty2}p5kkO(1a#h(=DY)FD0fhH8R0IkIcO~SS&|><7X!1@uW~eY#^GPFBZnZIUAhs
zrGiGF?)j%5v>}A0RBVD2PpT$6rq?g}Wk>at7xg9<oHk~00Xj;`7*?`QA(q`+p}D7O
z>L6@of!0=nh7q6vr+9VkAu)pmF+s;Co)<jnaW&;@el!j_3e<R43!e@_-%sa1@K29L
zs)omP@2z4iu;A8q`IAA1O)dV*+o74Pf=?!JSmdK>6mA1H7W{ZB=WuhPA@V3+CPT}O
zemYx7KM0&&*O^z#Z7|qPUwwPqnNfDhJ-x^MmXv$rlMKz0w#FYG_nl$&Uk6P7dbIxb
zsQ&(6>nYDh0nd&w&j)dyU74N_Z+Skt=h^+l^YN(XllPua%>)5^ZhbeUCG1Ogv3F08
zd9A<_1DYi|u|;_aHAeVn-!m9B=^~Sr%6+3=IY{wJ4MrTkHn*$LHmI%q1;dL+WU@wO
z)cZY?$#n`<q614bgF*hO_R|LG8n@<Bdc5q1yf^&4=YPOdg89_M40C5{;u89vf{ior
zUQ<7sbohO~XnRjh<d2x~I_*MFVeh$n2&xCs{pKNo>}GnMmZ%Ay_BpleSGHICy<Ejd
zAHHPzrZQ<bw4xg6^=o-vr=gVX%A;GL1kHI?gjX_~oC|&=XrScNGHP!irrDYA3yX%S
z<<jkYAgG+=m5KKmNLGB%<5xM#YHNo#dy;<pjr9_<pJqca*}@<1=^6y9e#|6``M~)2
zfCj(JqCsVWe%NwSUxx~VI13dWwN|WX`LqWe-_MS<ux-&+f0>cnJlZB!wwSo4fO!k`
zU~-$r9KNfanmz&E{(a)fOrjPkQ47!b6H*8CBxOw|#ba-M3~N56e5Xz7h)MzF(hyYg
zZ#p{izig!Uq&6&%GJQx3fBkXRtDVf%-ycu0huWTDTaT74IClGf!)MEB^P=FuT+Nt_
zUOF{Kz}}@3r-7I&vMYToEn1d4a!dL{W&o^-HuDgQc}?3G>RHO?U6IdV4-K^3D~3#}
zKkJrWs>y{u#krPI0Ho@y(Z>?F_mdf)q#5b>TJ9guRi6|o^9Z%=%~IeCvrd>X{{mlQ
zn7$^H>z#3Wam1%sC5RD`P9lPh!e_;XQZBD1ssIVch{-vAx#L}kcE|Zd^1SFL#Ww<H
z#R|9}nJLkX+x_j{PiOc);AviEDcAJUwVJ9NF=`)9t>_0Y)M>54o^okB7}w4*Ybh?)
z$~1?VuA-jgNP&bNz1xtGq}T-iPwbT@+lYYkkl?5CG|jaqw|=C3vgbA(OpH3tn3FHi
zSP8y!KIHE8kXlY|tt_OzDWu_PNaI+@y$>NxKSS;xgft7DYx$`>lyv71gWH<Jlv*VJ
z1al<6{KMm1j@eHQq|d!}=Lv02e*EFw6Nt$=h1-*)EH9bzYdtM!&n1gFXpTH7C$Kv8
zKDb*QEBsqNzV?p5>=1nr8gh_kdgU;4O?QS*Pcdy_P@(jcTXFy?Y-;+3V84tLKE*bH
zn-jU!UKnk%NHhmJvYNru3~ue()C4moPxALkbF4#%fXnOhy5~oeN|8q4Xmuv-k<!uc
zUSAg>w`WV7)-^tDIox!{pD$;7&;!aL7wjQk;q*y2x?LlWoBd;S_Z|79q~C%GPn{Y@
zMjrbQ(!c2!#5Uhpz4)Cy`0*P?QcEc}+<tcQii{doO0U^JXNIR%19labb#C=ppxgP%
znAJ9>FaYB|ILct}snTyW_Jt&?6&Cu3tbo`>U;?dR82V)dAIFuTmt%`L!mFc~9^J#^
zw8L|LKAGJ^_k$(-T}r<GIFE4Rgug{EzJ*JDj;FsIeG9WHVz;)^{M|NuZH=JTwF5od
zb#|=)W}(OLi9O=tb7S2tx%G}Rg`6G{PVzK`b6!tC?kjpt8*6n4BR!R~*iUN<ilRSC
zj2{N)gnOJ%Ti-L{t6>w*z<TrIVp5`1VJt4biUbRv{)=ikTzP5GEWS;8Y6ZMK*|^TD
z&+2gJIOJq)rX*hmD@bO4aoBDD*4iMyz=g~x#|Rt5?fn^OY<1-8Is^i9>G-2{po7Z-
zn-Wo-Tx?nWZZK2qChgcD=ji}8@W`C5wRsDJ?wvkl_v#XT9TJ}aeG}}v21?Lc?TSdy
zj1=YVmjMUHq{hQ!=PWlv%Ib7tpct|D{);!hHR?M4***cyEp-bJ5O1Qnm9PBRP9ava
z=PyWGML{$^9d0)E+*tsWn7=f9XwV(7U9H>B5!J|iBRoADw>x?~)ej4`-{JZ^?{E)w
zL~0@1c)ccuO{C{2(npiC<C!RN2dC=jOG%$&t{43%?xE8@;8{0{-OWOC$b{*blpXyT
z9$RttURJFxL+-T3enjfw;J#m+)pwkvOi*H5I9-wN$}tTXW<4~Q1U5dk7fs|5h5~|{
zP{ERv_E!a`UJS*L7MK|^oCWt-*^6fv&)1K088jzyoc<E+eUVMe)0Xb^gaFq4*pX+k
zFJHxuevBRa75j=EJC2B(z{O1-j(dF~ZYtjM#9;<QW3G-#BPz**FNo@vbL${e^*9{!
z3{8#X!E-BP?&H4?S@e%~|3a=L-E2v|NiDi5R#qB;F5|tLg6C4-;UQA8W7Z&QxSQt8
z<Ro@r`XwSy$qPmRjlLndIHbhh)IGRB&1=wwRaa)evoBspbQI8BiU*(ifStl4#1m%z
z9R7HM+RufzsSPJQPi_H2hGo~BpQm9C`@LL6R`$gUYt!J$k#a*h3U-w?b&>KT1?s-N
z8Oj$GM$^mk)ST{IEb5FuFytYw98T!a3x2%2ce4IWuQ}|A+9MfgPF>Q#ez1T2rG^o!
zeuy{0KiJ1nQ%!a^BeDOkeAA(czfL35YVRLK|5_YvxP18I(<2}YkiA@m2K9V3XZ|`C
z3V860guO^YPQ37AH}8&m>AD%2sPUqvB9qF`j*1$wg-*?CeVcCbeSSmjnvRJKa9);e
zC}*!(77w}(f-#dD?F>EQPd$yf^ezlAMb94J;(ymcPAOAtH*LrgF=cf+wAF-L%lgmd
zIg8trG&NO+cy#XSA}B}WBQY5F_CrN2UhVk62i})ICW+!Nf1oP*81Mf0?_)ej&e+<S
zUkq)n2z#OH3;cfnpezMP!&Wk6A7R{3ES_@6QFi!6Gaz?aC;<;Ml0_Qb2r_dAR>xUL
zDHfcw47CpD4j|g{00~4c<t=Lw-u$*K;)t*o(vUYhVvOXhBFmGiX=MEB#6nk;*^w9c
zsgWZd83UsQI#;=C@=njj$QwJ@x(6PQhBPOYfLUTBjRwvkaXPFh^$ZZgZr!b^$}$$O
ztIk!pQWEA!-b5UeYN9d40ll0ljpLVw^DwEqxvvhXD=ahYV7tpD<uEGE-r#<FtDrH7
zpk>>5pl33A;s?GuspJ5gIC9id&A84oT+jcMfn^Oh%+*Y5Nyy+iEOD&j$$|LyX5QUm
z;pSen1kgDf`Atn1)ZT({;p1I&QW#q-x&L%;!}GsXg-PQ>WDq#f9_73G=oA*TUzP3x
z)Ee35FRfw$$(E_bZ$~@Gk|TsTbhn^5D`|a<>4J|EG}^R>3?E;|YYmflpleAd_Pk!-
zH)j9_OdY9^j$zVhvxi%$^8LAu5#Bo0+ml2nKI*usY=D+=75kHu2Qc#e$g5m~M5)dh
z|EwQ#Veval2(2^Rq$5DVia*p}>%RaAY;X0C*N(8aon99^d6+2|?v-ON0SDiy%)W#9
zoy8NzkZ~KwE7cAUD^{8B$3@F}(A9QZeJyWv4j#V_0-nc8^ekrDZNwNi$W9q7SKTZ_
ze*Fc(pLCqYn?j791V}$#doE;Gk_u$xzA_Ay#PJ(v!s&AZp!SWmXOZFlvhpzA=y7c}
zA0|Ow<6uGFIFYD2bZd`Pg+%$@52`9N5xGAu(g8Qkba8#TX{W{~CW|}CPs*Ex-nx%s
z#{Im8<`@qokV3T>*B2AOM}s;3=5V6;93C1tS!yB24iw6dwDm+TW<_;boLRh9_!c=?
zHj=TXGD|MGNLr9slB*U>k>Kf)>_;jut4S^)E0GVWtpXU91Un(+YS5%aJlU8qWO3_$
z><m*yXF1iuW>7dn6gav=zx-`2<-j1Q|45}qrpWHil3A9*+7|@?T;!v%jY=RHzBFA%
zGj0O@MIZ$*D!S1PDBZ~VQU{L_h{zRvGuRQY6`?@eAE0yDr_kWUY|Mn5iGur(^-pf*
zE6#iXW^AEdshM97FAMugRsH!ELX38VRN^;p$WGtW=M@V)ZhuDN@e21*UP|HxI0JcB
zvPmHAoSWJ8h$B+<6MX3Bl1|I>x&M!)`~Ii;jsFM!I@2+ZbL?XuGutsk;tZP#S&5L5
zY?2Y>9OvK|>6jtO9+i<%M&sC03L#0dlQ)GHlJoWXe7^s{>z8wTo!50euj_Gt_+w?c
zSnu}DFXmr1O}5y$!~Uq+xJeiYman>lV5fB)Qn-KAYnJR3*R%i(cyhP2<sc_s4V}#e
zI8e0GmBdb6pm6FH)bji#duFF$+v2Uf(0dtf!0&BiWoFOuRU2%C$WF>p<2LHTI#mNl
zdg{>%=0Yrhr`F7JRDa%*$invN1@Tw>y4osbH~cl`qQSc&?&WIsF?gxG)!PbbojM8d
zkt$9g(JCoLUt>~2$0^D61^nXESaV`49MEIFmi$33yt@e8^4OD=2*V0#DKDnFjL1k@
zmaT483s?mePf9M~+)qV~ola=&#TY4)P^yXj$-BRtDdG=_TnjnzDmHc5cUdaF|G+62
zos0L_FH;TJW8T)&&uSDpB90=bnY7Ug;n^#_IzL;HI!rCGz1@4JW(4j%FYol;D+71n
z7c+*wg$hGorsyutBPj7sk6VN35y}y;h5gs<Lykj2P|b|ti^scWR))_C5ovmW1vhkZ
zSP)HNx6qSDA%2F4tOJNVH5z9OvsdVJ58PzbnHo$skv}R>e>+}<yy|IV1GSk?o-W4*
zeo~`~Zp^chc1hV73r*>u1y1jydaxTWHH#i0?>&UHi%MvuS_fU^{2YW`YwArszp*IP
z>rzrV+OKRTx+J=!H)t@YaVu_PNfM$zM3m6XN)K9=k<ou?bwM+Sb!TJw7)gKFUeJzn
zTV`IH*`k(zjU6jCCQ}Ipj!NVGto<?8*=xM=egh-9AH`N2J$psMOInKWHX{OCE3DRB
zk_5mNc~+x)!o9eDq2`Qi8%3)UU^Edo&r@-gzjstozr@dUr?J4+6}NO%t0re7qY~FA
z$+~ixnAyEr1f|~K5N0DQo31i4zF~hnP1ME^k#6^wLla0^^AkaJ?$HL*mQ#J2*>)Qj
zuTZhl8GRbyM@cw;X^H2Sz18037S^;yp|2Q3AuqTf;1YD~XYL21rUkg}e1n5BNOISr
z+`ORa@5i2!Cs_%1(d}MGA8gDp_JV3o;vU4*c_`PoVVL#gY`W~!Pg%CF(ho}CRQrs~
zKTq%b8XPW_aQ-AsVMtA>9P1kZi}~Zf7|t4dXfx5neQfxYigXr3Nkv+CYAabYY^)u?
zx^g5dB<m)7rKkk%f9m^>iZ_q|bn%;#Di>aM>C`i98jIs{{VWC^a7RX|SAMm7q4z#E
z-fuxgS?s@H$BY4u?c2btKH@9w3<3m1?NSAUT5O!ac&Mq;vV?-jCk<%&jA6`CvQS<^
zcIJl7xjhJ8+49GH$FZ0;$=SKN$+l&4jP=k73DcY34Ze66e+^dA{tTk`YBtz$e{PZq
zKmWBKpBa5KewM^xkG5CIjLrb&Gm)grDXJDcTp_G5(#b-rA)V3%Q6Jrj^###6WkiJI
z8VoNCt&=^K7;-(-`?}QB+r!^lb9>(*=iaw&_SK<ylxdzzuUsv!GC^1J5^8^MhO<OJ
z<<Ke;6xMd$3X2m}q%f}|bC%ubEcf~Z;z5sMAef`o=s(lEb0$S6=YdX<Gz;wRxzbF^
z87!Kn)%sCC7<|+nbOLQ+2%I|AbiqjBsMrZ{95?W|pEw~f(8W&?9U41%KwNA6xb+pB
zHh<UX>b=UFBiXyj561{12ouy{|3v*5)6la@@pF~CC;wc*2iY;>K1kd3yALcuYO?)i
zWiuY2SAwO8*_Yx`6Zfuc<#+f~Wr{7rGPqe+WNF@OX`k#QKH~13!CI;V%z-_s-K2^5
z{vC+DJ8XPm$+wJOx;(Xz{$Lqmt5+uRQg8wX`){*X*^?;4=<ez$y$8c<F86jp%>+!q
z`ad(Y;|XEQZb#&&5t?(t@za(Mm@xZN5DFvI-g4@@Gb%+>%XX@Qk(Ku^N^?{s>#*4~
zNs>BqfD-l0{ESVL<mKQGt@GfJ2?EQfzX3_qtULwKdJd(m7y5dPUoWisGQ5#V#%qZ6
zU5M0Z|I%g2o>);SgOV3W?~~aW&!2Cv)}=oUe>*GyGT7)9JH2Q;OC`46X+-p<(kOi!
zRIVLwpq-HM8vW)UNkf}Qb%Vs}jQI?ACv?_MsaN;DGU1ITEF|K*)D6TZx64m9`y}&#
zy!t;u;VHO>M2y~`p#PFFu2d^z$*>%uOLvrjCi2ReeiG=_i|G+EG{20oeMqU$Gn*?C
zxFszN;o%3(wF;c&Ds8xY?~uTTwa2<VUUo5?zI~4P`>w=ETCYwY6;Fc*JuDF;h!YXW
zoFGKu{F~a*!BZ>L^(txN!;768OK!X<;nxfL_*42%Q+^qGO}Tp*>sEK0$e*)cjp{d-
z`XEI#g#7EX(hzew6}Dh#JD2G1J>yRm4>J>%0^2I}o!CIy?UHc(nWK^UhlJ8CJeSYY
zH#I>?Qau$bcZ))$i&?>ke!e1Ke0)8KOo~ioq71g@QUJ`${`M@iLU0r$fdGp&aTL|d
zZVwS;Oo(E@f~5Qx>!9WE@=Mq5f4SCtDX#NNT+gNW;V<#ym#)uzxxRSm#`>2VJC_pn
zza)VD$sB8BUVn<n8b#Vaaq(E+5J>fcXLQJsR@kd3MGH4g6bz!sSb&ii(svZsQUcCl
zWFfPA&=U$5-k(d8a-r%J5W~k!c#f)vbW_jhCGPD}aqXu4l(kGv*xB$r;s)tgm;}I}
zJcKbdg2bIoQt?VADrg#Z<EX7o>TJ98E!VF$79i(6s#+@nqe8^hUU-iLI~JyEBFdeP
zEJFMxz@~t8y^?ZfO^~zjL*DpTYrTG>-O<<xaYcTb&hD@VzSbR`i1()mpog877e7pX
zEl-33eU^r$uZyF^r4=CiZdBufy7V3snLe;;<oZ>-XYwpOg+H^8hd&%X82m;?C8?@h
zbNzuUji0|#`ZC4Q$mh$sUSn+CgU2QfbGcejccOo{CO^az$6*NaCdvk~S;-#@5O3@W
zXqE4~WJy%;BpHn!&9@S(;peX`XB3WC*hD7cxO&g2l2%fES3meUGz9uJE45k$K6UEL
z*cie)<c4N|pIUu*v4$#L5A3^3*RdH<SNrUld~4L}Q;WfWJFx%Msw<xoA6mrQ*l$2o
zhd?Z8TRzdqk`HbH)rbFCx}<3z^lE0<8a4|<{p6SQONW0K8Jcapx&WPjnKc`my7)<~
zVLia|`P!3ny++uxmg|d_@cP@h|2&l*ywg#6tyFJ{cBzM(S75!~UwznhXsTk`J0x$}
zm=|PPyWW+ZKLuVKPYX76=#KA`Nb?7s)J}$Rq`#1_vk|++)a{L3SGiHV{O;t#l51<z
zJM~Y-?16bSkIhDE)Z9cwU}4h6kkfqOjo>!W`RGUgE&NvPYxV|cB>Cp<yw{NUaCe?s
zkZ>*Kjv-YfxBKE0boZx<F8P}PHn97U@n4Zovq)vh>2K3kpq+lwiRm%pEvxsA{f*2t
zma)wlH4s^UuTQJ^VRcmSGRK7_tB}p%2ZahIMh-oHK5;Ta*d>0grRtI1Dv%~7H#aiB
zpo~<ypR4}N+_YXbyH2@RIo>bz9D49vX0<Hz-%O*K?B>7q?}yKomv+9hrb4PgTflpD
zXWlK4Oc+>s3#=6eIk5#Hg+Z;ijyBXVs_^i1Wu=(3=&rNj<$7x-=-PFPVCn6(lV>z-
zYy0Uq_7jQh=W##5fcV7SmB$LsWWpOvkGI-|?D3wG%JEdOqi9I4LYTBQ!b`?x{Io%l
ztWqD(v2D)J>Qer6Vy);|PsUk7NZ(kf-td|*h)kEK4L+v9>X-QR-x7B@+!diLVZKCR
zQux0Ml*Uo2oZAtZnZ7>>g=gL4U3KL-J}_R(gJs&}ZLG)S_w62##A-o=ptr<If=sJx
z6q+WjwIf;)D!ps+U8!Wuk+0V+^vC@^DZkv8wRSZJ5baz@^?sw}M7nVp2+iJT(Ym8t
zGqU9x@%eXHfC_@RWoc9J&2^LX{acPFCJ{GuP900^E}_fJCu;JO)R~E|<Rqmhh?@LV
z#P4Qd%Wf$Zh(ud3t^_Kk!cTlil0Mca9TT9+ByyzxIF;AJ`FUrY146ig1ls9mnnESC
zGUTBpGnSxB2aY&Ijv&C>JD=(4LcOnHBNRQ_AguPUyl->e8>dZWQQ^$00gji43@w{T
z)4?ChnP8Ix>jieGVXw*Ba&MA$V3?bQQ4>VDFEJm=oCENG4@mlACKeJ%U~S1jjHE6L
z=euLqwS8JDA;{8`r~xINm;P*y!in$p=>&mzFkr(1>y@d#>j%Bh!d3*BHYad!;U*Hm
zgxrbm)6^c`#L^bsspkN^QI@92*ys~`)w6E(W+!w2=WhO&)+JI<f`8~Km4ahI9>4)1
z!y(-0A2r+)exi8M6FNFJJ7-9qo$<TE_BD$?{>q+a((I}Z$hsRhO0s`V(%Nb<4y!d{
z0|XP?|C`Msx}+PsBtG2l)pkwuo#$RXI7`$+k*+XU4JRYphiOBLzb-*=JO>nP(@PdU
z+i7jPKDkv+krsYHIu_X{OTMK^vp@Q$72hlCMO<ZjbiP5P?flQ6v!Z`MLfx0|_S)sp
zoIJi03p@aA&Ofp}3)sY)&0z6Giuf~Yv0ZrPMa1jAHX)C>iDC6qvsbSjYkJ@?>I7W*
zuGHrX19t9O)c=Esj)Dk=r0+55>k~E^k#`>L4)|U{R|Wsx8>d~;+C8l9zJA6mqYvUS
zX0mqBi$nKdm-VFLol;n&O#uSaAqMcLxUG<Gif|A|dp$FBzQc)UHYAiBK_U*^_O_&z
z(r$|>+K?-0Wi%%JOi0Z#Nk8b0*oOjvS6QqQe%izCZvGm5Lr+^{DH^`Ack^Fw4`BMX
z5AvNB&6bq-aJmZbf79vbMt;0(0jZH8-)FE)3G0Q5BKkbO%6@Jle3FCdwt{BVmKHpF
zqxbvb9J<x}j>M22``T^cSa7Wzt)mp>Y@6D_f4uxmh?p3d+((IHNns`k5==Q#El7e)
z*v+Pho9rl2S{};8H7oyZ){1L6@wbH(*J}N@^=w?*`M+)6agPK4KE4w7B<}B%cQpP|
zig<=QF^D2MK@jlQR~uKeX{TIi81Jb0>rPYew(^$_i?Zq?$l!Yf8EmqZy6qmt!I8w0
zsuA7UYhmpm)eK1O9!YNl)Nt$Q{dYOq;N1ZY_9;}1_Z)wE#xTC%cQwmkFzqQszZ!}s
zfu(n8WX^;BXF4SE)v)<n;);ESD&l9Elu&e3?3|L-&!*HXqpy$A@Y9CwkzZ1CNk$Jz
zZ)^HU2P6|4lUG;V1uV|%p^0l;Fj>PvB^pVg6~r^t?RQ9JRO|&%cbu)_b26<JqyN26
zxo*$6K6K)nwLwq8$xsVslH1VZ2@f&ym)<!VC3K?{bw5Rfzpw1UW2-CmX}6(fzxP7V
z7A<^-EdFPjcf-s-W5Afp;4|AD!P#Ep_)q}dV;htO{Y|j9l{^(`5r3Q(X`6Bt2c>SM
zBowa&W58-ZKRp&`KU&zc3O@{dJv;7%2Jz$$>V)-bPV}T25No0WG`&mYa4%}CjHR+t
zVoS|seG%8E*}j~2yXhb+?)m0~N`_xJrE!^R+1uwC>guUtS;R@pDTtGKIR>2Tp5(~;
zWOeBufZy}54F&f#0ua{bU!hP>AP~k{354T0$g~B_>Vs(&slqErVWphxEvuG`khqiY
zveCX)dCKP=NAB_Z*%WGBo@$NdyL9^QiP+yi_xSv6%Sfr?ty)J3_XN;y9T5be!~>WX
zDQ-GC_!d_cm6t<-0MAb6`YGg3ZAJi)u$IhD5+a``dO<!4a|*su2I}m}tortED>yzN
z^L2Lo3B9Xk+rw&&wQjeZZi->$*SQJkM`%>B%;2Lvr|LA^zGtgR$BSGIn0#>VNz^})
zsGzB84sNmhCWHz73B*KZCo8Nt`EI0;WqXzQMQwEN(~m-Lt+E_JVi(u}rV9|tEB=qO
z6#3fR^@5DZixScHpkMYOUw+)|wCi<4pLhNEWy4n^ec?Hm*d(ri@_g&ky}*eR=x(Th
z8>1U89v@a^vSz77PS%VKX!OYKtWJA|$dReD`8^(3YM2|4)CV}(1)zY(?DKbXf~eNg
zz6Tx0kkar(*Z{@sU`!oh_YMbepQXyw#nLDhRsITBQu8XOykyG!vWI1EswiHw9#VUD
z!2254FUI0i*7>HPkn72HbOUnd;^j3F<zY@<Wj&4^pZkm8roM7xX%T;Px@^bA5+Hz}
z*tH2(_;SyCyh2Vgri7^ec4tUzeI$O-ZBv-4)F+>v_b|Lx&Riw!7%F$VuC}~N?Yh8}
zi|^e$r-^*aVgA}k%XQOQCA+|P&m*BW4-&MuA2kAaI}TJW{64A9ZVQ9p%gv^w({Z`w
zau#lfm%kW1?>qHq>W-3~5}=%X>L%T4%W7CMu-(G4=$JE@R+7w1u;fU{=C~wA2CWXH
zMIenZ3p4@2E0b66mxhW`TNM(yuI(sZngbM&A$qfsq&}=kglH`fmD_SCmsUE-4d`?2
zv-%Bn)?&Za84C^6Ev9!g#p)=6&&hwjZf|zfR_&1JJ$apJ#opQ;azkXjwyLD4_WD7G
ze7|QdQHBhh9e;I>i9h&4<SM&JQuJqXGli>W7~ZA+a1NQfRRbVAXH`$u8b@gMHMS2;
zbvG0XDz~<9I`hm-8IK_Qi00;8Ce~ch-Dy9GX#oFR{Nv5Z6p_|=d=`;|q>}%$i^9d;
zhbB0M=HpKM(MZ1f9#W=BzW=)p1}J-8w)m#XQFV-$IPl?8X?)L4NUl-)Ilf<3H5|<G
zw{434zotBlg9{=I*ejxmBH8j)c8!W8<bUwa>e5)mm=XE}e7^!4^Lw`z<t@fy6|)Zi
zu@VRcVUvd0)CZJ|UdKCSuP!g*&@pnATH$22PNn5rF*rq_D@?#Wqbyew>d9|Sd2hH5
zQ){`Ip0MO;d15Ll&xffj@e@1LYHP0^BV3<&hw|QdItzU!$WLO=g5x&eVj?5KlS(Xu
z5vN*Ft`1(<kNyZN4tv3#N`f40+ZC8)8ZE;-MFW600{LZ6<Nam0GjRyPRNU>vm<rT`
z=@fxuj$-@q-%ORyvE5CJpa+Y|OKl^Ptco60A2r1=#59(T=m=s2hF5gbYEf44oTYVx
zELX}JRF<2NoJT$tR>R}e?9c-<oL}Hv7O^-IMv`sip~y)8UTd>R*2{N61nyYCL~NXo
zUl$9`d(6LzOFd`fEx}j#(qUDz@Po}IBfg@s+*R$mbEg6?@ZI?^v8vng;Z*1izTyS`
zFM2P}oxW1SclWEq7lRKUPDelIE7{KdV)*sknYcN=dwUa?SmSs$;W}C_2d9D_f!&Jy
ze1``A^o1zAkEQ#7CEy)w$7i>WnH){kFq5@9W)$4d=?HH^;k#mo9lN{??K4QnuU04%
znp3T;#QfPYIA4!2t-e0HV%hsl<bA7_>k)3MK3{E9uZc*%4ick~??lUjc<gb$m=|a>
zTzNnd)iE@CT=bl+f`I*vQ;n5T%jfJ~x;mBd2Qom|Ui%=ayss>NrLYrsC-GSrhcbTt
zaLsOI;>e8ii<xDP!y)r!um<C_zltxS&RgBP0%p$DD>}&VA>MDI`?&Oq4l|Qv#?O9u
z<rmeGak4z5LCfi$gL;+Dg9$6!uE`hA1s`i(zGIvzl@bZXO8f&cm9irc1}+4*W+||6
zNP2dPY^Bf~;pNH1+}T{5b3yDscEv7U=Q?0gee&jJRL7lcLz@9<f#&=CB>@&8deUu8
zb&1}373mUirXt9**M7z;y(WSxx>^_ttXrpf&c8RjZPTdGHRBGEbdj$wwFOppa%<K{
zPrTex3<Ma>2?$xh%T_`sa+yw<mhSTU5eDE7_@B$$vAXV;DJPzLy=Z0wj}?3bbxqrP
zObP<4L(V0+Ii95rFE63iWT+f}hD_IImxPeob)uQYJ~uzvF{@2)TAp`XfpmFESZO3B
zTY0+!PcJIY&W8s8SVe@ooMeYoPf%Vt(md$uh(TmapsJ#~rpNo?*wqkCj^-ul7-h-R
zXY0e~<nAcXQWclc1?A7|XmkfD-sL7bp>ph=x%stmR&6Vetyr&VU3elPIK}t~$Dw;x
zNC{iB^N2;Gem#Q&;o&yKYxgS%Ps6ZOekUMgvk|CtWbz5Fq>|h>@>XAooEJzY7}jNL
zV?z^~6noUbc$A2da1|sgQ8c#(8T8lp<EORN*4#5BU+;T&s&4!klyAk;NH*{=&}hH<
zygbZs_P1oC?JX>0kQ<LKL&WGMQvlnH@R&u;7aD!|2|<7=<F>%nD9cDp7kOGPy2MpQ
zi&)|rOSY-8czJfixbzY17f@OO=`b(b@#^=MtrXwea!3bnMRX3$o`@T|?7X>lxzSH-
z?GFuBe*DTU5^@>iVRJ#FG^Ui}!6@ZpX&+v#Gk4@Em0$LLCxk`$rNL6K?Rp&3PrdN_
zS|W(2fI*XLqG#hU<$O00CS*Pbnzl+0x0h|I;2N2Yz+9MQU+DS_3XSTOyifoF0aANV
z7#sirDhhx&kP9}100<TULGZ`Oaf_=$_>|m+n#y`p&@xtBcql+l#b^c04n3-1rb&>}
z#4MXDU*;&Bz3=w2x$4!;prE9`w{NZL8A6<O`li-=0o;2q27F|p=cdc0O8<J<TE{Fm
zFH^f})pmdKflEukr+wbrFA^ZEy;siWr7g*a0ecxO>SXzJ0abYzp7!9=%`nyR$+#zt
zpI?w6oZLZaZpZY1HSNDo-sUq;y~;Mtd>#Dxg-swVO7p&h)p!M!bS0ldr}gW*+OrQX
zh)0LsX?$fgEbfvaFLo~i>?T+ceSfh1!QaQL&yKfmFAe1=3)N`@V}{yS4b%-r(Wl&P
zLcjme#;u!{yNV%MKcZCl#!}6M<SJHA39FgED!i6pFcW?7clXDCLR@(3j>aeYPlNz}
z=F%Cx65rpq<RM=jg#fS0ACt6^>Gx=$i(bV@`g?O38(Kd(xj>iA_b;~s@Mrm=o|>BW
z>FzD_nV;2KefJV?5A#eqt|QR$%E0rNERX0Rbd+1I`k)7SoV`TBKJyo4bvf6;>9Q}-
zzqV>40BNgs0`Ai3cR~vE>A8xX|D@5FJ*el12?OEtirVj<>P+{G@c&X0|69KR7wk&4
zrJAxwyfuDfl6Mzh5*c*?7=|{Xus*eR1A3r`T6Ut~l^?G%()Jaz%I8Lot=H97UlUOE
zU>|1iYxT2o;2wn?lOOTl*L2I0_q6xWK>DfLn=;tCYhIzByL~sBU+bQ*m)C)nCM9L!
z;8uYCb8VS|VmTkvJ9`;?-1-Z2(aeGuuArBC`I9C{%o}-=BD?7*(eKZ8SCwr=why%4
z2(>6K-!$F|)1NQs(pWwPaPm0^nJ{_EUmKZbW`8F~QZP-=#iHW_)H8mK6%*}W|9Fdg
zleC{5HLF4UbW$%Xxg;0F9Lv|;%b!^slK8XHk~bT#gODPj+y|*XbOFu*n~@mJG20p`
zTdd9_2;DA5j4#)uKLau>G%aDjthK+oG8<-GQy-POpw0g_I&v*J^-baAgqrujmS1>{
z{3Vvbm<DL#=NqH3-*!=TckAnS7ypF6LmLS39DS5C<A?Y~^EdbNiuggE9MyawXJ4Ao
zJ(u1#Y!;M%X^!=Kz58F&_v7lGW>r~qaj&3Cn0OSFcd%6Aj>r+?AryMBJ#?(`VCVJm
z?*~6d&DH<?oNx~P_iOr6<G<gt(cl05nNLwa++DsMdbqb%(|EYQ@t`wF^lBJ;!E4Ic
z*h`JxY2G0Vdu`rSR_3&z=bX@sWVG!KVZu?2;>al;3zRYshlo!zTWr?KdF%u4!Ot$j
zT{FCiY%?SefXo)?wnUr4^sk>@Wals0IwH8Uh(%=`PcIWhaPejANm5zb^p%vZU28U$
zu|htY+lP+jN<nCp3u!);7Vqp%#`7)^g&sfT87HSSOnGt47k-ocgN6(1T9{=|Bx*n&
zy*AtkyDg1K)it%CKeN^38W`=%+#9kd-mv3~;P1sO#Fzrl$>xUHBxw%@T=yY?@6E53
zj9?zR$OjByF&CbVQM3|!0}@QIt?;dEstB3MdjgOjp7mtMD?%8lfk(lE|H4SZmp)`U
z(q#C9v58_O+XAlB{nDOfsO<ffTaLqiN#a>l8LSl7BLu0SLzphG-;ZpPgK~Ks1;S;d
zUK5Ur>sg+59zm(r?mIh@&$$5oD;=*cXxbq+(66*+nsOcE<uE<WV@7;ZEQS@v8|{px
z%B_~&(U8z^*|deI3Jv$!*HJV^c71DSwoxZ}ISQo+G+#tF`Z!LWms85e=%Q41#71vc
zbm}<i5072)!`7;bv=O6*ZmqKiG7>07N8Hg~G24_X@8ex-D+w-6`?;X(zsNDOxPW3_
zmKTf(6PNM_NfJh-(Q*FCT5F!L^I=p$Cj|M}MXwZT*&fU+CRwx^OeWD+&<&y%63-L)
zl4uLciIEmOf{)UDFfu}|^s~f)?ORwi8sa8yK&SmthAUZH>b!-@@m#x9z5L2rKyTeR
zyAwSUp(~w&ARABdz<t^KN`BP7OZKDQO;DI<_=@I~PPY2!!3w7|Y3}=G&e_>fETkSk
z+Ipk0v(SEV*;^Ef1azex`7EK>l1E`?cc9=~{!@XEiR_Lt$pmB({%C%WNIuT?5|b^$
z5WQV#*$a>0KBKWL6y3sgnvDoQJ+mn}yya*gV$BDVr@iR7JEWx|)1#kF#L{=gNmh_l
z=f^jt67(E`0<67~_@!K)Stt$^xLN^CGC*sXZGM=O`TC(P_K^AJM4Bu*;NTc=i3iOy
zyN+sqV<uem*XzO~;Ws!Mh0BZl{%m4WrWXPt&I)rQG8Ny*NCb#?0!g^mM;BB}pA@va
zY#R$^Wpk#>^>S`E8#7gSaAIj9$VWBFzZY(rm2$GU-!vuD4zsxNdNdL5M}A3)DzMxY
z8IiRat2%}IgVKPr(!jKN_{U~0{Z?!A;O^k*B}G>g3j*in=*S!GeH1ZQ9!RN8(!^ZJ
zaG8)6j78HeI6F|ibvg1Q?TL8aXBQ|1{8iw~&{Gj(47*XE8tTtM8@ur@Opr+8)q^Xg
zlDvqbp)jek_KJ{zMF;5T<B~H?--t@x1ts4KdtLyqbkMa6Y4fc!8(ZddQwP!FZ5$AR
z^*MWV4_87&0XVw;p=R<b`Ayre`uj*c_W7a*W%gG}my$K`c;Qww(3oi@f$&1!LF>i)
zO7tLXiT=B{3@aCwv<PfgJ>ul>7tSj3tU(L8=Zot}E(ByGj&|(nHtEfcZoVdrS<pYi
ztwfYbOYUw|us0zm@TddI<fWsA3a6VQ@<}@=1`a&8%`vhdoXR;g*DmTyD|&6AIITk)
z25+$y`JbQ6s59kh2)oSV-tFU2boIzuB>!G?#X_FT=t?LvVg_!@tEjP${qTxR=6b#*
zy#32)G5>6N6Y&{WN00CiieGY{lmSsv=}EdzlJDQ7(gD0xCn<y9`+(X9+J*5v#^$R6
z<P?ST+v9L>bF4!*LHlvI8`~l3-VeP-j&7<8E{owKdrr#655c3Pk;8tD$_Zlhd_A;l
zSieOTHJ5z3dbM@q$VQjR-A!ZNO^_2R`a+uWs@6ADd4L`<IR1lE4svqGj$3V%3+Gt-
zQXNnAakVw){#okp!VB~OfSaeVvn}*Q-qm{MjfE!E$EM4o{pjmV%q8;+GX3b{fpb@x
zn8@frZYkK2OVikjvP`<bbDMX^JmL2jQDv6|v9X}NQO#?n>N9wajT-bTPhovMbpB}Y
z))U)qyfae@bNjYn1cCby#}&B^`?4kQO%UiFmAt5-YUmSs2yj|tv3qn&hiAocb;lV+
zhcR!XBd~&Fo?%y#6{(Ic=t^|>mX&?(wVvuQMGYE@%x0>Gj&X4o-G*I)^Td_G8(VeM
z*iK6iqGKMTt_jk7Se3|6f{0`+A{mXiQ6Lb^;G&1|m|~In;fVaJ$m74*u5XdG?cDZk
z$qs)|K|&$t{&0Gg!rN^5*2r+M9W1|@U5CIPfQK_lQGP=9EB)y6o|^vy-7wX(HI5eG
zs6ktJK<TAkTkgAz6Ha)9wiFU<7xfoF#mx&}_vE^w$IEC(<>{s7xj3)HWF7@RFk@W#
z+iYB3oZVQqCr{XZ`(Ai4%0V1}W#yxo)o4nXLe?U^r7xLtjJw2K;0UJLDn)ME%6{~O
zS!{Fg5#2LM7g?p(&STLH$GEI9fU>-+u?gyi9v9`00GNjXHV@<6jzd1;EPBUX{RQRQ
z<bz<{b^|fE_;^u`CeDxrc4KYS-j+bB9xtK}%^?h!<a!tC@=PtDHW(*3woQMQ=1h=p
z@b>sk1E`A{+%FW+K7g!_AESkz!u5z7v%(vIkN#-u%KnHeh3FQE<?4ldbOJzsJIdY`
z+P;PQYj!y*61gOY#`39N?#qtE^EFqZU2%f<^3cvrTsoBC@Oeaj76H6~jQ-&T4nJaW
z6gGKLWu@o}Ja;q|*=Nq{-+>P32>a@LyeN^U;xTGT4_%#7@WYd9;|tfL%UlkHX!}w3
zJ>aZgZ1Jfw7<C?ziBtX!f?u644xhxvS-30a!$a^PDW=ND#*TCmTd^Y>hxNZW&b|&h
zh>VCCrPos6CypUSY64Qo?3r6^AC9Ag0ro<GJ*Bjeorld>$8|on7+NH@?U4Kl!nT4d
zU^C+_K^JLfasP8F<xdl9K4#?A#QA4SAX$Oe!-V?*vqZq4yq4$8L%fk^6XFqBSeC&4
z0*&}$S*|G}60yZb)UD7fsxauRFr29{+ONQiR1ys;O<XI@u2ouGlQW&adl_Bf)N^-|
zsxfIPCMaDcnp63y1u?ai3nFtr2)pNM$8O(h@fOEbjV(X6eOW9=^%zBO!pjR~qM5l<
z?XrGS<%ptb%2x*k6=`uFrt*TK)nl`H>sx{-R#j5=HJ|y|2U%#uc{IET=aG;m;OWO+
zw#E4<4~44c^%hdUa=)gKU+(u<-A{^Mnw60PACOchaAE~z5e}Qi3O=SwJFlw@H8Z5V
zs!H!as4+0g<N=C%1cakd8!3h7<$3Pda=IlUUX~*Jnecrb_0z)!r5fh)JW7Uqa*aC*
zhVLHCEg^z6xl3nw>pS`HVg<znc;G}%K6&)Er+bn?LycyYEJ3+?B{W3|YZ2Z!S9CJG
ziR*n+>DxAw9ud7$5y-tT)Vm^duAts~ybFktTxC#m@?E_V;nBY$Bkg>vX=aR@UBg&3
zmxos|DodHtd&aF)@tL%D3#iIh>+b1=W?}22pNhSeh2`3?<@+8W<XO!%j?cB!Ek$j6
z?J>_0exmHPMD%!T#JuZImsM*88ih&0E|gu3>aH<e<`P%r0ZL8tj-mY*QCjwQ_pYh`
z9Om~GZTl>vwZK6AXcO@K%~3FlAae59Z+ZE)pWVYld-$&38rKl~$X|K?@#ibb3~9l&
z!TaTMjc>A)R|T$f%9!R;8wEI9PD!=U{yS-vuDaHQYGHo@!ao$VgGx?uJojY>m&t!1
z9w)~ooO#t+`1fQ_6Gv6sHN%c9=dSjco;Fv0E{{?8!)!$#wEp&e^_Yw8{&#90{daN&
z4g5rNzsGqj0M}t3l`*0`C52`_1o3+Y?XSn5QCJ^&t2>{5;&WiP<LV6*x{&2Mq{$<r
zZ#9EP3`aaD`1`CgphH!o_UO`U<|un68FBT2*tQR65EJedYxnmKQ`86BRLbObJI}Vy
z<b7?cJjLXT@AlzmqmZjHv)vL0-B__6X~P~_w;uWU9);o_rCF6QEL#9m3JR@;&Ge{?
zVdnnImha!oM6<g#!7{PzH#>T|DW;*XOqo;@V}9;Bvr-d7wAqG`KcsfB%lzU3Li=|J
z@u`SUK6-$GeH>;9@ydpF_P2L5If2^V@7J;OaOy}Q;%xZ@i~H|;v9tJX3m9(4g@K1?
z?$S}XDVFUL<uuf45HN*DtDs|x?NO{Nyh%mqY^-3!Jn68hC?Z3Qxf=Y5z|Y}Wta<IF
zgLM5_0wTW*_IU?Y;P!H$Tl(;WNb(O9(xCkQ2LHbb&OuMEPQ2q&4TA(*7#+=ZME|_t
z06Jg4dd~H_M;K@gde#0E(dx<3Z_ksA=G2^kvlwnXv6R{j5u_l1$bM<M4J&9y8Ko3|
zoE@?0hAAp2A|b#RY|^VR%OCx3z7?ZG)8BA(`?*{cPWC)!rom@b4SQ8;{%nhjt#~96
z#5RIQ@{U(6nOE7Py`wKN5cQ*`iQLG4yeL)IuVl^QN*@#8wCN&h1dC*OHcQ?NlTpon
zF5oSy%C)(n*SLVv(?XB1bYH@si52U*e*_wB?JkZp+lhJaz>nUYk`jLt7CC^6hIrW@
z7jP|Opj>?dcVNzE#3#+fodCvhr1!N|J@m-@W6k(?54K^YXwF`;&mj)w!6wvAj^MW}
z^9i2vub;Bvp=`}x6S5QKF?Tt%)d%6(Sz)>H?)oOcbgKXRm{ZVm<vy9eQRhi;9m2rH
zU@<GH*o<v?TSBCkBP{4zaURk#bcZ+e4=P|#xOFPS{x;T>aeXsy#^liqXe%m@=Fg>t
z9{+{fndZpQc$0Hi#E%GFcjhr6cgjV>h63|nh|j8fv0e0HhwxtJ8T3gvM2|nycr6aR
z5f{o@6$4AfAF@1=CRnMmPakvds^;#Y?6I(&C#Ww?u$H9{tL}V$HoSCOJ_7=OZtI07
zzn`!_`h3#m^SU<rb^QbcgnaKMJZ(DH?WOzZS?Q)q5<V6O9iDfdpKq5EoWTHIP28r5
z3|ijp-xU7X4)i4qU|hc-_D!9=JI?F_l_OK6dyB(!Yb5J2iV08MBWGqSAa46JG>n$c
zIxj_c@}A$a`T?*f<GJ4nSYEx2dS)w$9Dj4BLCaJEFfUn->Rkp?kej@N>J1{c+R^Tc
z=;fxiQ*~0EUd@BTt8=(jknO4s!S7->ckB`h?)d4?{@BpduIk+ENHtf8NZua0*rP;5
z_6}-*g<AsKWsVD$L9eZ)ep^)bf}Oy0&Y;;CwtT`r$!+rr$Z_4fr;T$%gpcZC3o~2U
zAEgO8uHEm3XO*&B7}Xi9uQ!Dtnh$yB^q;;v#oJNR=uwQ?e!1S0sg%XU!1OnU=8he)
zK3vE0XeAq?7vyf|a_91IPMwzfKh|d^c607<b6(=xqS3eI3*T06d|P{CWWt1x>3=@f
z13yST8HTg*D24SdU%6SD%BAr=)AswHl5gVWRc`B52!2;C9u9o4NGmWYaRo7U)b?<N
zH);=clX*Fs4HfbV&F8V5&oc%ziXEl@W3Ra)?YP?Si<t~o?efB({D&G0;cX;0%(4Ep
z^9oIK@%%W%BeYoC`%>(K0K(O_C7a{1cGj8REzZ3O1iPe2YZEFoPMwTK{c#MI_hP?L
z1Mg}_UnUc{yna1P`Ncv<8lI8<u6yC=<m-~CWRvaqe!1W1mZZ7|Zz5LkceDZAnCHrO
z)K!msZ)54df&ib0RcKd7loz7M6FEJ~$$nZgll(t|-7|nQ-kG0n%lXolOJ8(yHv;jh
z$@r7$FF7x*cQ9FS-|K2PXSy-ETpeBc`H%QGB3P=S=9fT<=PkR30`{X*96VeX%VCkx
z@n<yVz}qOLM)mjeJBr(*bs}6NO>J^dlsA=%-!vVJeBb}G-T0nqSvVe{%ew0EvGiwj
zc*EO%jz?Sb$Rg=ZJMP#V?%fSBg&(N@!nmF>)y_1kXF&JWDeV1duI(liu%N=kC&G{t
zCIz+&#AKwn5e;LvXp$zNdZDktZpkc@8};wUpHS>$1L&zFF8xuD=1if+KF-n1*Lckh
zF!LSn{3O#?AHwx_aAdx%5ajtU?!Eoj@r?HeirzE0nHRoxN4jp2<9|*K?$6A)-lgU@
zUHyC5pQFV<i0Y?kCu!XYoqSJC*nzpo!SFml6ZoK)4>%7*dHjas^51@BdV^Nm^lg+S
z4LkF6?Ek*seQ*R4sU*O~U4QzIm!$##7Upc>4?9zlEMTv&W+}~rl)>>(TOc97a`s0G
z=kctI1h(??`i4_4qN?u7L~{Ikpnd;sy~kjQdzbIC_$nxwGiQEoVtzyrbTYt$Y%m9!
z*Z8P->x1RDyv_4A11c(iI)A5r4$%(Otaw#)9m;_tz=V972yMxt3c`$s81>@-xPA3r
zyu!go1t6%Xz{5cA4M{qI^^ng2S{g*w%NAOSEXa;%YF=9_x_@6JdijyLWWDtFE}#;B
z>|P`yLY=IA@bVIFbiVzSuoQ$Le=lLWw0HQDKhaz^0=(NZ90ngx6wOlj8?O9X`$wAA
z+i{xKY5gxM76pz&_*0y|#C6|Nw`*loy7ZRCvC6x|xB=EZ;9^!e!j;Htkse<Vxy%SN
z;UG)=oMwNSgKzC_)i*eQAAD1Ld}}~5;It{^S$%EGs>40Asy3(d_f8yp7uLX|UaSru
z#*yO}$F}bIKSm=nV-e$9)p`fALk}ZG{vOK!3{!ur1cHIBsdS>EZbQOrO`0+!{rbD}
zSKs^oxj)6RQ-d))I?t$#OJ1<m)@`+mlpPv!Fq2Ja%BtXDOdv|rJa8*;wEZEW=2My>
zfn7HJpD^u#uiBK|#aqU3ed*(3+m+**+#E}c(<1CX!{f|a8I+ovgay)&x%CaJxnUvm
zg^>U^@Gnb|@AR*@WoB@>>b76!<(hlR1_5<7)t#(>2aN*;f%Q*TI|CbEz)u7{8kFw}
zYI$pRBDn3nUsv#x&&el3Izq2fxpmbZUiC4_Usuz4svhz7%a?2udKmLny2aLZ=bf%_
z3DGS02r#AL>ojV3<QA0~JX%u_5xq7-oH%_#;pcl#vFq(Ggm^y@zu2T~bx)YrAfi5;
zKPG;4mc98?_-BEQA6RcU7_#;k$8ZfMT{fq<414d`jne0Txq)jhDxCfId#zeZw$~vq
zE=X^>Z{GO3GYDZt|7v^CS3qdM_GbG+6gaf?#ZpZ$LQ)jj`m}sLN0Q%rgZF(6#3s^B
zldz>?P;v+s>4r7A_6I*}icVx-zPmp4q<a(U&BCroBc)#x5zpOdf~+k10tas;mG(VM
zJC2)^N4hs<G%WnVm6Am;T95npmO*Fjxyx3O^jS2N7o_n1|7rvmh~-*PwM?&!NbCx+
z<^xeCqZ{e#(Bl|VYN{e4WneLSQNTnG%YAjQlS8EMs%lWFX!Kz2gj{8&&QovDWG%zc
zj}c`At@OtdP+OiTZF*C-)K4O#`>1BnNz>YJ4JUilt0V#uevhBuHqk7GoQ2p8M6cl=
z#&KO#r;m;X4VxQ@3qs@PWDqLuu_s@QM8sP!ED$2Tq6Ny|CUJa~%MK8>xOfeAH0ClZ
z12Zx|A$Vj>4nFE0^701QlI(0*gpu@vF>Y_Dx6LNryAXbn%WV{40;)B!m?k7^_w`C{
zSwLVs^e3Fv;p7Mh?~^Na23%1-QCj@sCj0F@91RVn9O0fC0!0EQewx6{mIuPzr6&vV
zpJWb(t_#LxiW?AJW&rAi)0kVFH!otl+ed}?t2)A6Ek);=#^)sTjQYkRu4&1=#YavL
zdvuP)=}uVeb4fd-{ESS}Rz=uvP7f#Pw#j&GK~<9NOcO?z&Q%Iu<YAK@NtjN=b|CQj
z_u2B|Di?H0x<>Epgx%N9U>A>hK)jDj<<wg}eJj{)337z7>zp3F6|;f>oi7+oK~G_S
zv??2ac6oo&VDgdh_D7aLK$%oPZgpAO!AH*~J6K{&o4&n*x!?Z4(-*0)RG#jMitg)V
z#(x@Re5sH%t$OmzWqc}M*R9I9?tRZEj@&w}+$tRPznMY7XqkHD#N&q`6v<Wo!I+5+
z;i5(d;POhc6~nDoK!PeNtV=Fn*kZb0-HdNrkbuP6e3iBsedc8GfWL3ynzP>9b@#1j
z7@mis$n?SA&D+ltOe?Paz3c`)L(4bRzh%NA^t^`SV^Ni+Heg16!a>i8fYQMPHQC$`
zYy9D$QE)9h`&QT}SM8+eH|~_ZXQ((#a!=kuT3&?b-0B2V@w5fb{plc|(DWdeWv##v
zNaNBzl@8)2Yu{uMy1zC+`ku0zhcqyhl;QJ2plNf<^}zQ@drLyXX}87xc6mG>zfzjM
za<^dHZ1rZ7ej{JFmiH#z@3-#n!D!tfbypsHAZ!66vV--nw1w&9dht1x(?o{mbGrE}
zLfaTk{P){$+5M!5hJWw@4#~bT8wB<1xa1s@R#XT;=K61xA(t8OkxetNx_h!j{Y8%T
zTL16%Ms3N4J9oT=U%B=hSFNdqreC_KzHG7E4KEt->KFz*G4J{uEWq_XE4D&F1)lv{
z9pufr7w5Aa>E?{~D)<D~qS}vw<;~@z#wcFx(!WnH75+&7oLE%&Tt~L$`ohW37@?1!
z*$B3T44!0`P+S$FTLvKuId%6!`xlcAB`^;SWEuL?OW?1|AYT<OP5m6dXu<BwYv=`u
z7Y8H*mE<xz_rQ0PJb5e4!EL8*{S7F7t|@)&#@^?M2J1Z5$It&iz!Vb^TFT~t5Lp|A
z(`cDUI<vR2bH_Zb?>sZ=dFJFooI!kq`v~NB?6k4p(yveUGE;nUGX%3=zb^li4sni~
zeKz^uW7hA1hxu`H!7Epv{rU7gfh~R>W_*+~nA=J@>O2y75i@XnZu@i>Sp1>DF}$Ai
zC&zbSu{Gw#pjOEnpK-%4qC~c!-CmUiEUdU``xcw^P2}Tt2e$#9f;Y+%K+4gvjM+lV
z`$5(PQcDU#YHiz+QM_jUaceNUCO<u`Ojgph;n_kjQ{MM!)}9dL<qz@lr0|0!iTrl3
z^h{Y9eaHV-{jDO!fiZSHD4Ba?l;K?A5rd}>S`BWM?0@)vWA_W`kc%fPup4QCV8`z8
zET1)cc$v!3>)7La+JPYZV^eB8=`d~m6gsSBD0Kpx82(l8)ez0K3Gzpe=0c~j-A^>N
zfCp~DeVMRZBJ5K+V3Gnn7z001Dq@HcLPX-bPtg1TnluKjYl#q_Ws`8DdyX=`>mikK
zoC))Zqx1Y5*KRJ3D)4`WF%;-=Owr{#<>_T9hKwTB0%n5$3km+G?>cyru)QpX9w`|E
zQ|6(4r_e5T+<&XbYbJGTpa40U#(o}~<T(!y3Co*IPe0OwknHU>vG5igUK{%K>$x0L
zBHipD#oUK(0Hg-ag8>{g8q7`vkViet8}^(lV{q+6!ufV-1i^@5+a~RDGBdI0A|myY
zf}TajiOI3zb;t>}u6{Rdgd&4sX~|)+pMnQ&N)M4J=d(D&sg(8<kC=SfbI;;q`Yuef
z-H8$L!f^(mPrB!JF@=c&I|B*8Af1uuRgl6cP4OLqGCVuqV*3F)E)n0a9Fd$p1~;Ei
z=Oh?imPWYlvK_lpWWL81h%gVI?H^6ejBXiZ*jl71fbj?@>u8eh+QjQM!C`qmH_<cI
z{y~Wn9U6f*yNu)N_I#E&Is~|i*z67@`B=2&n2a@R6quM7@|RAm@jepimnnNdsipc_
z_N#J|2^R1K+g#h}`^z~Ei9sUTM-v4`XW_vKM6AV3)^I|p)j>Ac9CMqrmmxi0D^%AY
z6=%l(SM+#$y0YPmL_Mk7HbqG<Q%*Knb$69SJe2EfwNA4*B2K8Yc-aIxTL#z7?t&CU
z1axJ%mZFdx&J_HnbUPtN2pVribrT6eq!O^uH_J9_UDj<aU?)p~%Q%4+*Q}9^*OSnZ
zBwP|jFGZ%i*_7Nd?2>dQEj4T?<%4HVR68f~>nqk1S$cku$Y;{POT?)T2+W2eYojEz
zBqoHsT#|${O8g(1s%uywv2qz1+ys$(_z=L;#?P`>T0EmP!4nXzl=f4uuV1gW6u4QQ
zZu^gxi$&xPVMh9%GZ<%5=u{FJYTn*Ez6(Bqg;=?Xsg^<v(NMki#68;RJ)Xz+7P=5^
zqdhWRoRhXs4;qobY@bzhp#;Ww<i>b)#`sLf_#MXte8&W@jtM1=r86Ii)FqlBMlJkl
zpb-hDD^PESBE5D@bY#q~a7^f$1gyIa<BQN?KzzzL<*(WwCL&E{bsB4v0-61jm*IiC
z#z_{Cjb0NYktS)3aYqncy}khVi-&dHKn-fopxWE#TEb6**rW8y>k(9aQ}z?}W#4Sg
zzVh4*bh(AcmYl?;2YVsZO5s5m#`ShhnoB|SSXl&9FV)t;O#HTaQqJ8aL=^}6%*}Tc
z231O{-f23`?&fI=O~;fNq^bgcRy+9N$23rQ(~FnH1kbvZwdd{@bnmSc<w`A0GHt(*
z?w-fjmpyqWy#i{dBFpKhh|x?KP5NKuCi!_Ehd(U!a{W|b9^KpjjdZPj12egc$(|U)
zrc9Vf(MyRRb)e#sj~**sMUT4fZ1A-s&0-w-;k_*qpnhP}ndBe~xX>+VjHYa$DbZ(y
z!xc$3!61lu_K~kNmdg-z0S9#@6WTDE?l={XNqBbv%>^Ojsz;-4(OjA!iWW3gk>pqv
zdZrHDv^43xHiATlz42n`X*JE(jmABYD6N0e6@lH$KK49YJVBi9keV_@L>R`vFEP6_
zJzZ;HoDQOFXWKb5XE_KfsT5oZ&8<3t4*P?H+doi!v=0-^rg~zM>8UARVIMuo-5^S(
zsTd*(`_T_A6x05cQaTZ*3Xib7Z~e6i`c?HN@OZMU<3qFlV4nWaGerUE;(o`O&$}t}
zW8h1w^kBV-Os3n&id)Kb!F2@G@ka_95}9(BO|=$m+vnKRWIjeP{qSMZ0Q~AkN5L8g
z`7}D2<wZ_e$01^BF@Xxbs)`72RXXfoG7$k~03DnDQ}uYKKSiZ}?phnj84%T?$`qlU
zN3&IMzQ#yCp^DJjPU#&%Yzcgh$9nt-Ml`i*0z<SH80QGbj2B@vQ(QXNBls<!T(-sD
zV~d<|Z901NBv(vxRBaM8Gbu+Eaa<qqOeg)>82IysP$JGVMqCKZLH5H4K4{Cl(Vr&M
z)+SCuxh$6TSD6Sl)X)5!OGHDJzh*CK*Co0@LlA6;Il6FiLD(2W)Q=vu!!`v59M8HW
z_osm_!>(<m_#-fZ(>Z~)gK?3sQ-~E~S?4&x03%7ATAG<jc+WsDx-kX|p7pV)4C-MO
zyD~v<6EpL0sN&bP;|8k+YNu7WI%P_J&G8Bg{f{=Z#+yL?P`kBs9q=I-c_)X#Th@{Q
z$K<X8nuWjoE40H|`ulb!&A0{bcVLm|(rka_7V}?Qp%VA8F)2v*`JU3(iS2q?DhPYH
zp7MuQCybEzzX^%69K-)`=hl5cDxofv@UD-oV7SS9qiE%1Xv_3;Eq*oL*3T~lv66Vk
zbUQ_3F9XD$L<%!H**&QgHNX%M_r5C5x$Q`)Y!TB(EdJt593ox|6JF6li2q~@#3mBY
zIm7pA9<0svYr00?k$V2)i?5C!4GT#x6i@|H<J{Az+^Mt+YsqLhE6~%y%s1t*AD;X>
zEkf=Hm|#<`<2aq4=tj}DJK1RepJ*KN-Z#2)8BU2^7x7HMdTS^}dBQXL6y2n6fMYJJ
z&o^yuU#{zlPV;|?`O0gw+Qitc=ZT|<3oVPa7VA~=^y<Tuni~k~0<_%oG!O_Ty$1Ue
zOalro0=wC4f5FSl#f7!$@)7xj`JR6qOVk*)gn|ajC=INQC^V(xYcY}S9vkyZOZycE
z`%kym8u!QV$6k3?VMad*;!0HD**)nu^B-ccdgCaiY&AivUzvH>?z6Vw!?loav<vwp
zhA6|VT(^L0+EUfg*%R#}*U3o}SX!q%0@4kia&mV%Ok&||sjls8bVY;2(uv8CO)4|F
z-Tw<9Tz#j9!~O4y(kYF#>OywkphPSb$(~Z^35l6bi3O;MyReou`<p`{yh|b9;h|3A
z+_IUIlmAj|F{O%Asa((5wK{s<mzpvPQlJJ%Jpf%$@TLyWzWj`Rx0r2Mp8k!Lx~GUB
z4LyI!$yguZ@X^sa@%PKeb3w6PAv8wfb=lWZ(<!Gl5NCFd%sdD5Ew-aPS9!!O-#2Xa
z&(r*e*ld~<|HbB57;PF9=;ceJK4qMaLg)fR)Y1P((!KaI{r>+0f9+s~vCVN9wwYrN
zb3Wv-*)WIXlq7OK)Z01bkeF?lL(U1QOcGKdNl`hIkW|u1NRd=XA+n#(@B2TzZr62t
zUC+n!{?N^d*N2Ca2a2!G1axQQn!s^JLXjFA(vc@dO8zMsky4Oa$)jA&RDbEiZ}%-e
zj(L*Fvp0rE|H};hPe2!WLGQ82i{k~PI*9(F^Gk~AOFGLG&R$93+@It#2xE;o!H<p?
z7zKHlY-9`W71+n$d;WcesS2^JD{0W+sFR_zsqdv_>-Lti4}A{haM&@&yU6Na=s)+L
zzQqX+gU$cqKV1;50M>AqGIPGoiMGqE7q0QVda9?GWwG)ri<Iu2kZv>67%)+F?C_u9
z&_5yZe?l|=gkAV^{Q930p%rH>Gz{zZl&`q|Hcs;=UiNH)o!Go+-ITF<b@oslbFZ21
zbf|}rH2c$&3%@lufvA)5gYmElA*~hSm^|Fh7)IXP$De`*yvdv$+h9i(%+a$p27aaO
zoqwb5n_0dn_llC=sMlqR@bAO?hE<#Suk*CSGR63%((hik!NhDpx6a3lpmsAY#@Ua{
zL;(&fxIM%BN#?0VNa;f21g;BM@qGCqf-o~%7&dy@HtDuAD}GZexACJK;Yt%mh(*h(
zxtDaCVfi}_O5eN#H0|MYYc+zy@%R6>3<|abbL@Ya{m$?r-R*n%*?wIaBllt9<h#BP
zVM+XU(~Rv$gV~P8`96w8!E4(+NR694OT>)L{ZGWcCIt3o?lgS6Sf(I~e<G1Ib^ciM
z`p`nMfQ(2}Wo94}XgMs9_;u&SLA=a9PN7;k)mZvv=D(>6|K42x_x9eucZ2`lzy8Pj
zu<&ns<KIXA-5IHr7W4_gk7dkp<!|noJ?QizjZfp6G|4#QOP$-3lo!1ryIY7N%MV;8
z<`8Qrb14XwG`d@ky`-6NsQ)8AuV~T`$FhOLbf6o)8a%l9yO2UKK8*q~`@IZs2tW-~
zHEadf!xog%4PRWr_i;p3TpPny2?Mz@MzPC_tBOMf1luC_vZ0TUlX+lokn{M(#|eix
zPyk?Xo)+PG>n&{&n0g9-#2nFUrFN8SeM&cCX<hAQo$Gbin<sv&_maNtp3}RlO)g{}
zTKu=I#K$Nlg!TrUOSpEp=R6<ZEjc(Y+=prKy6yY74egmOCcl_gXY?COUMfR_Zzc3v
zRYhO1jn7ltd>LXd{J1n?vVOAtjBTOl-SRv7OO+Le??it8Yp^_}D0g#*kL<=sO@e&i
zj{h<9`0Q2BK{X6=%p35{Tf1rZ+Hbm}A=vG9<Ui9t%dXG+ei=n72bO9fm7I<^jN#+5
z-ZaYZJ}acu@Z}VhT0VI6XXo$6ub+>3<@OKh6C7P%JFoyQu}++<IbmHSn_M9*)@2by
zj(_bEXZIR=Qugl#o`cUeu6Ca-$rQ~#mrl*_K00zQ-Ew!QS{it&Z}Z};!8IF&JkW}<
zToy&pgji@TNz65vA|5}mU)`T|?#McnoPSIsYoOfUx=fU8kr-s`oXHcmRw*b9u1Hj_
zm^xDA>A?496Dbdqc6AQP0FB#5KC3+RHn~<ONGAWdps6Z1-AT!ZQl5MWdX(*qal%+P
zfer$zjAj{NalS2A&b0=VrRBT!sxniiC0MngzTrUwtu8&(+R0i!&^wUtRF4dBye7~&
zKzv{$(3SB;T=ho3%$acRX@QbA=H{@f^mDM!fp+Il+jkG>ey>?SX!Z^ftX?J~Pt<Dp
zTyZ9nbDdj@0)mX^IQXXzLyE=YUUCQO`JZQMJ^uH1Te}M+WJc=dlT9Y|2<+=5^$PFb
zA@!jh%yjxCjwb62NdMQVGbndvM`sA1W2XCrSK$)tu5z_gx0@HxK2q>B!1L~aTogn6
z*JGWhhzaZkv)GnrCyDED-E7sDzn+1hqq;9r%JBm)4t~@f)#tA-8rApw@6vC@16j>5
z?alSlgXSL+pufi!s&CRKubKTr>!_PobL_i_^J5mjRmC?fPrm-3KjZn;n{LThj|KF0
z`#wL@JQgZ;_$>%^=in=e+1wwmhcN7s&)Cr-Pkai|(7|eMCos?I%C^|w#k3A5iMRii
ziFpIgQtJYGL-UtA-tdwq++Tw@S2@z=9cNKGJhRBHcZCW^;nVL3Vs~vXtQ!vQ9l=H8
zviVb$1;2TIxBq?neDJ)P{oSXHcPIg<-fQEIt3?-|FU9BOTJoN{y}W<FVcqbY$xb(7
z_jnB|%j8JFk`x;97m~K?T(w206SIb@DBayJ{Tt!RVUFYzKMIlgB`|k?m*W$kKJ}vr
zQgXwCAee0WMT`YL$BHwH?phqsHw`PWMM1Dbo0qD@yK{w|J}JDo<74}U+{Ub<ChzY|
z*QkP1SgI~jps;`)Vx4tiW4GKc$yQCovtaCDcg{?LwA+Kz5BBHkgq*~|bY9NpCv~~R
zb_+2+pw=GgjEP`IRN?mT{R<3+R%xjk?uI+vCi<t@(r4B`&59nmOjYhH<V&01WA#Ks
z)(4P}w+F{;JPRV1sR}0(WZnAw@}|dGaW6Y)7OJf`dDBqxNzf+S+g&H;&F4?z$@3C=
z@+w12##N)f8Edg$F}4(mRnEctQ0%utr2UDO3dj5GxdeR1_pQKCQ?Xu6=QROv#(Ypf
z0u}#w)2e)QR<dI~bAQO}*wOHD1T$_>M$mO2wY|4;PL*z+`=`Ud0j!kh&9c~axlb{V
zWVopj3~s7DFIX1C9)u7?pL=jTb*Uxw`cwfaamFW~adyU?OA3#w1(!yviw{zLJ_@#&
zpAu(FtEu(vy`REjmRYqdUFxfFwe!c96|2R})osI<kbY)!qC=ip&kXA<qM?5BQGUMa
zfu}RWOG3{q^?qE7J}odVtflkL?X#t7RvR;cw@Ul`e6Y&9l+Lx`tENBv&$f?S)O?6!
z<gPiS=<1pcR5`1J<-FB&4QMM;|5>9#O}GC+va+n3k8gNyD=(1K_pkzj-Lu1e{|i-K
zk}gz#QKo#%?IPN*X>S}m;%oQ^14MV-IX9*#z;nESJedtjbq`kH`}h2A*{Sbocl9ob
zXulRtWw$w-I@Gva3OM}A^|0a<X8}<mtI`d*NwxnB;4YuR27Ws%c}24~*rcnI4gY#W
z8b)kG^oDX$-}fTxm=#hCueX_!cOUGYANoA-mK^oSKkg&($zcTHnTAERJkPW7X-Hbp
zk#<LPjZl}qa&n8%y{OYqtON0)4I=e_LDIaxvJp-n$?uNWwBH(j`gL}9UmzQ6m=PGR
zAj^vp$T$2PV?H{d?&fM)H`<;3tIHN>^qgmMUdpX@geTuQlifVa(%4%0S`NEWkV-%F
z;LL$<xxL8+QKxUplX5>Q4jmEotAkqeoCkG%zGTKN^_DJ}#Td4zW<>6=dUxE?zdFAZ
zzI|DM!)HfIfAC)XnzHhPfImMIqs~m%H&W17!WzzsG22Yub5S~4@X;OAr+0=mXX1wz
zuDab^I&|m3E7?_MxP_0-k&XwGZI29YoxJ(Y=huVRk9G~3SencJVjWWh7KSawH^T!R
z(h$diBL4w4TEv?67XBPelyTvE+|EUFs(5hhd=)I?fBm8fxi+G!LI-g*?-y#}%CXNm
z`Wmu<oTdSTwTN@T{I<s#HJklA&H3>N$OlKA1M=&aemcLO$M@I^TAQW){Lk~MbdNFZ
zhHEj3R>ht^o7Hdm7F}pVzq&u`NTyn=AIfMv02?Wic|lz?<8Tc`>9s2Ssn0R_GL=5m
zWYa*Y2vfLZUJ>J87vJxw<G@<(#qbsOJVJwo&+DaYovW*|&yFe0WZdxj$UF^XG~aw*
zM_lwiELn!Kx}2Qbq1`%VYetyJITHEwD_=9;heKBR#s`QZOHT$Z8bR3|3lBS!k$`lr
zOLriSCic3_HhO9nR&y|1LRBDx#3SWz(Zu`Kcuh9gmow*>We<sT&|b70l+}lY%%PhP
zTICiM1XMvquVMzwp(%XXUDG%$FLUr6I48AJkx)t+z}+Il97iBZ!K(0mJ)mquaf-+o
zS)i0qlyP&jS9)28zJA^J-!~q_ft4_rRl+SW)K}E`4!8I$XCoMCJ&02d$V>+_lw$Rj
zwD~BhIt5uY=XcKGK2{u`_Y!^YKeL=2p&%HLxZJyOmrrvZa?O)Qs_Cm#r3KCRHqvR^
zpQ$emX#6QNJABi|JCILmGzl^_+Kjp<1$-Xu?UkU(6KzQ1G?@_yuD|l@s@>iIS4Y2+
ziU4Z@Rtox5y>VW*#0=P|ujfail}4OB0Ru5YP-QXD@6W3a7=!KMJz;c;;$n{uhNU%b
z#l}E!%V2|Ws!s0SvQO7fK3`n44WSXNSw#WZAkDs>UwmEajo`Rkf9cEqG9F;f9f}0b
ziWJV$pJKk9?a{$fP1*0Q7p(?0X$n<PH99nLv)2@Ri5fm<85aQHn7Z(OgH6_7O(>==
z(=z!e!Z3H@GlVddCW*5L=vGlsD+-OO@!3Yv{ZflKd+4~_6rQHD+-um^Yahnab$2F;
zgZA%GHS{6A-4HqPK6W3(NA;M+yaEsnG8*dNWA-WD-CB*%4{3Y@%{~-tk3}+H#4-<(
zyfSAwlOZ{NVYpCnl8@gM)@33t7qEN?+`<-GlX!mwN-VH8*65R}nXwSJr2!nvnJg+T
zDB5|R;>i*;gyIVN`N!sZJdXtuVMZF@qm5Pp;}@l1T{^@J+!F2V42{xyOjn*wD&fD@
zUT!%L-ir@YJRv+j00HZg%nOA5rRtC~^~7nW2o`AvW`u!iwqFSy2b=U2VZXp08uVE7
z(G>x*$qqyV7aTyN0`qB>B~*Z(rbo1KclvDU9!x3d&C+M-qpnbvYb;w?I#5=YxG$}X
zqUTH<{Rc4xm{wiE0V8x8Bh8-POEs>|Rqa!6BT(tAt|vlv%Dj=8!b{#$KBPLfIHTJX
z3K+4|?Ah5)xpu33eoiO2_WCUB{D1|*$`QsAcmK3k2Z9cx6stN-@!6Ug2hK>pcQow{
z1Q;*4fmpb=S$lW=kk9}hAWLR;^;eVWREs)={dIk2;oW<GxqEQmNlCWOJe6EZjp~C8
zq%-*>`(Ax#8G2{$j)v0qUM(VfBjo*}ooi`OtLUbSRL%zrc$k%QudQKU#XRe3vU1N}
zNk<Ju4#QNL3RZ)WVJX&bUs!S_AQ5@*6LEtm)2CLrI;=*fCFwG0vzOfovCp+~nzsrF
z!hioQXx~S@1ZCXoV&#a_++raIa>4e-%x_z~%X2TSa^LsjiRtHJsd1(Jgej&ad)ROj
zQgFiGM}{W&m&$f#21v4XHz8({(4j1ES~5truZPq%XBHhq(fDkD!P1<;_B(0R@%l^h
zw2(Z4y(5!NaC|K=XORE_`mCZfdMd#Tvt7tORN%2NAzh0;T`MXOO^I9vW$sc%JQVfe
zGwSQGSdNdyayK5{YhJ_N%OoQwdnjht9m>?DYd%m42D$$rII~Qp<zDlk9!oQ7u{b1v
z%)GG+X_R5>U>hiid6zN12j{PSkm!3SH&64XXhH|!Fkt9=uR-`b+K8{k-imhIw|ly5
z+gmtl7bTjuR3+nh;BDXHXC6z!-Rd@!Y+C27O0-eJzR%ZJaI)xg`cgH##TtHCM}h)o
zn-C4u?EAf}?O%xST%X+zRSU|HYosN-uQ~CcPq&Z$Qvy0DK?`7j(Q_dCzrE@lAJYPs
z<veBJZ|^`)(1q#GmhH+`Y)U|oFEAtL?*T<8^jda7@*1-&y?cMS(3IxYs2I%&!@etq
zP&L7&4#|-+fMGb#vZU{cFGH5z3rV{W%p>KD%5?F%K5e)kRh();T#nu8{qc`^9Y!{I
z!~|tfEy5s16ABsQkTaJ9G)9R7x1gr#A1vlU8FfC<LCo_ME2re{3(qNpmGhD~rae4z
zU^jx&t`bDxLFMXbB32n61%s_MSjP$S=F7b%P&I47DoqP2UGrnf6v}G&X60vPPYZjc
zi~yRt8>YP_y!~3kx=q;L6T4LoQ#9<d2HKE4HOk4^WaV^*<^H8=5Yv^b*#9YCJ1_;Z
zcdo@YvKc3=DY;b2GRU5--a5)vOt!Z04h0$^_FYu8H|58_-dpV3mbtfgV$&~7H(G^L
z0?MKQPl|CByTYSSqU3W_w5mN;-Z~j{B>Wo%+6%Fyy{x`beq!l|Xs#xdibc^B+CN+L
zSy9^ertl1jq3;%Pk#<cK-RS9~Neh-ZCg|383u0q!PXsz>=6b0$rjDZ7sBW52IrW^!
zl8L)G{)2^!Oe-0I5HUR-u5>0EWcpHBUcCEy`<J)%ARt`ep5OejBtJ^)m3uIT7!M-u
zuzC#tmfVwW<sM*>+oKT8qS(+#o#2!disKLJ;t3W^kco#f@o+G7KU=R38mJ7#El}~u
zSp2X5GnyzS7JEh$<sF`lE3j^jTj@evk}>+|?CK*EX1{aH&$LUyt}n~7lVv!xXc<m*
z82M5-qWS7Gp+`MDdw#%dhT=4@8Y2lcbe6-)?onZvE$6Suyu?PM7O-<rt*XBL;+cFr
z*5gxPdvb{OW{|Fm%^sOLMqn3S9x|gre647s%_@dn)PMqN!4j|XV67f4nXsQTM;W?v
z6kV$}qL<wjMJWJnfb>-%xpS+p%rMk^fGmrOrc_d8=7sD$*DP<<Y8m!v&r|n$+0Evu
z5_Hh?Ecio!58&5}BmQ{*e8P+kiIQPU(4LxyQL$vEJybzfAF>|<HCv1Tc0gxeHIT6^
z`{j2P%e|@96#LD04jVR(&*Bb9(Tta=E$TE<?m46NZuR-zTV%F$l!FBZk^%#8`-1Gl
zPtnBZNAZ203m-fn`;OdTYs=6imX(qu<GPbUgdnEkdiQEx4z^S1zD2qus;8q#*LJ8*
ztBxW|?{@8!r@p4#G^C-Ygk-Dg^7MbwT0ud9Ja)Ph&bo<046_oKHM9-)4RD6UGWI^{
zYnDyD3UBW=9}3*($My+hXI2SfORh}@P`?JVRl*@hmU~UZb;G6hWXaFg`lqe?ZZs57
zw8tU#epFk|nsFmDR5HH#iDASIP3xBmHy9MfF0k^RBD8Mh9ca|@grdOy9UJ(E1{X>i
zyqEmU=<MrzXFnRHEZj@^X_UHgFE!qA$YZ4Ue*A%{pylsFsaK!kRRvfVS`FA%zRt|J
zeNXfdEH&?Vy4g&_OKW<ZT<h`nOqI?13CFZ~RJS(k#lQ2$i?j62tmc<N^uB$q_l>QF
z+Bp{;G()CIJ62zW1CMsaDCPEO*9}^j@#g7fw#`)^gwOQ7Qic{O(uzMCw~XL&H>^ee
zQk^_OhD2D-V0+pf!KOZAW~ldhhx^SVzGeyWha7R<^VIX>>z1S?Y8Y7aWw!*bM<<M`
zGb2<IMW1UCtoClT#U)1M3}4B2cq{RsTq<Wlj)@(i6&>q8e<MSMnDN7qojcK^a#+xI
zxLs2=d-*K;tm?gi{>y3mHmYxDPkdf7%)RE@)o)%oY_LqVps!oGf8zR31z`;4v74`z
zwu+3>i?09eg8FEyuzVf=9+ijKn<>$}{VbxVC2MLgZo{jv{TCF38mQI`vHcH7hO$+e
z%9un8_>V(ftGe`Fvvru!{733MZ{4Cy&U>e~{llN5@_%zq8o7tH-@EvfaV6Nt>yLX)
zLZTVum5KLi#JAGT-iVC9!Q1=O_Vb<F*#9`8z3|;%_pX?Ii+4MyPy<+3cs%R^BfYwK
z=Qbp%$+ExL&FsO@ra=wuifej{w$U}5k!SAZxMG{+xb24UZMPM(r&n_%FV@HLj4xCs
z2Y*@LH)5U8#g}=}?2*d-N0xk#`5!jVTWODj_6SA!<zY(=^K7F51{Dg3Um-ClvVF|C
zMu_y@)~RD>L+8WZ;<~Y;XYY3=Tg<ccb_w4up8@**Hc@F#3bg5X`?bG+bGH9pPldKm
zoxM-m&U#Pn-s;yMgq*b8AEV66Fx+FB0HJZQ?1k;lujrgl3Jw^om5RO<4rhMKT~VtQ
zB)fhJq?PjZ^`n%bI)QhOeh6is{`u(V#V0YmM=MfxSSUCHX}PBIcum{#m(k;2mX_<b
zkJk_K?z^8o-JYg6G}qiN+nz$h>Vt{l-IB&u#F{@eW2Vkf(+Sq&O%`w7CDonC?D>Fw
zB)u4h0%>@&E|2fp6oAN{LL?3xVDUkS?(GHs)J%l`zcU*J0oFNEIw3FHb-1!#pLX^-
zB(>km=Si}%*lc<YDUUW~XO^XN?eTfd&@V6V7l$6aVwnb$Ff9qQapmpxRbD4u(Mh)k
z=mP7l^yeATqDgxbGv2Vrjn=j9JEo<}y<YV5)t5r~!y0SS)`(|MwRk@|Mf<SJ+IKJ9
z_i-wSU(&2>p`oCgjkl>(o$c2AYW4RHxGSo%ph85Z##?_cFv_NU^On$ZmnFnrPOst9
zFB&oqqj{Mg89+-{-~9J5Pp%?9>f__I4a48s@~>}RgwXi>G>$(?b=@6sd25$=#A|zw
z?{%b$@I(k%z~pso|9$SvEbpB5<4b4HZ2X*+z06-VLrLcoOON~UbJ*7euUDVXWr}R^
zUHp$}!rp7o_6)iZl=~!oujxe>dLb~^&Q^Kz?KefD8{@>MD~X~f1{F*s3DxMpTeBhM
zUaF2mg`QztbYX@DkLxlhbNs#wSJPwOrrf^4l};1gQ_!qM%EKp~sIW{=DA4A{s~-Rl
z1OqRn4(KS=6SkQUwVPD|aKOLFYw?15%6u(8O1y<o(OMxUWdE@pV_R>`cu-v)AiDHf
zTJvSN$jxQZ7TC??M}ex9)>0ArfbJOgmqKur!_Yx81XVJ=pCWwdrL(XDTrEoG2+0H}
zMGK%DXf1>XPnVCvOV|^M*Uoo<SBPAKjCCl+e|&3jl+8xh%LOtM*YCLSLp*AZ?Z$q(
zoI3fOPu#yXO^<tkEv<Yxwe)z{`RHCvo0?SPS9^ij-0shp3MA7er_Zc@CW*VfK+Kf+
z$_e1E_yW9fB3?~b)8RpK-M155O^c)a!oxjfs`5t;+trotg8jyh+Llbfa@n`2`X5_r
zFgEpJ?%!{quf;YGRh+GCuEQ+!Y!SFFC4$Oa?VUFZ6~$RvZx<f}O;*CDh}FJ#sbrdB
zM@$0_?6Hej`t~>#JmSSQ+bjH(nAiO?SQ7zGSa<=rTX;yP{;;ERIm&zaN?+Q8jM2w4
z@Z<9SO-W&6v1$QIHK(SW>&gq(=)J49&zp~~JyE+-zwcAFpS52Ukf7{rC*z{5W`_e2
zM|AR!4i#P7r6&{syM^<DqW{@Vl_hs-E?h~K06!fYKD(rG<-Z`|Woc@2Rv-R9%(Wr(
z!W{2OAh!$=F{Uun{LJFa=+af>Sn@5nEq7>An4Fw`{Mxh0rd7|nJYYwfFTY8Lq9q*&
zfm3T<iTCvDeUEp|>XgtX(dzoH5(0&_NHm%GBsgx7D?Xq~6I9%?H6BQ#AYxezV10)F
zd%DTzut0@fRVJx1?VPyRRk^Wlm|@+urmx;=c+Qk9kX%w=)Aa*oh+wE?yJx!bkwxsb
z(yd;Sk;{w%#h@x%i{WPSI6YVz{hpsAse7lwCq3z2z)(kCKTRi3#}}Z_S!PHwe(=ql
zIJ_crq;1k*9?B5*XAM}L_>ylpgb#mSbr6H=y#|C)hzlJ|BP&-U-D)E7yDZPKM^rQu
z9>Bu0{)1zN@S;A(^HP*E9|;uc;f*N*Cf4tT{20E;Q-8p?eABgjm{5Bbqln5tvGL%-
zb|5)a;VzsZK@eqxLH&e&ZStEFD4ZDmP&Lr_xP{Gg{>YbhCF0LvuF=OGyiHp)dR1*z
zdR82)RIOzY{?i7-Rj@q185w#xKfYBO-UgjP($fazt6uO2I=58(TUYUGLW?Gid`bdU
z!3K39faky1yujIFs<8xrLgPN&Rrq@?tLlQ_?%N0uhHq;}Cm&|<?TR2s!1}edYYXve
zH9DLKQF~xLl@{l-?95S_G{{e86JwQre?7<wKsb!{V*Gk0VtA@?`K9NrBPBo#*|%>h
zBkJ&Ohdnb+u5r&98xz!G6`7>UJIMc^2Ap|y@ScBt)8+FTnNtIIE5!28>eNVQxMo-l
zNO+k3jtiY9%PTWvJiC|Xg)+O?io4_8>EpI~%d=qll|AvKl`9f7BTpSCXBr|r_Wxfa
zBR?IMF3jO*gt}bxdUdPx?#)x*|MQnU`ev-O?e5+05iu8!e)v&(@8R$7QE9T?vmzJT
z`wf1?6khcHtaai3=&2tkxw1ZAoi03RzWK^&3do|mUuYJHpa(vFXAU}ap>vtS7JM!X
zNaW2K#gTss9@>0TUJ~9mAU*uK1oAXJx*xyUAC(Bg^02)n&)h4QMhSw$1=w3B>Ls`r
zPd(fx{=;X|5xx~^^-9W5_?L}+@1}KtnYZ@GO;t=@0j&#*e=}f=P<+Jt9<#eo9Nm(D
zzi@IWSN4Iw9M9T9Y)mIi*;pbwcY|=rMeRSG_kLI6?sdre>lVgiKR-fTH{SZE<Da~4
znyFtc$tqytv$?|lBW`%Wn5J3cf;g?Q>PO004bYJqUK&TK8am~r+%$V@D5ZAF^^e{W
zSTfwyQMtEUfL#P?5>EBwRR8i6Mc0spGs43T9kj{I7m~AA<v}}NOZ?2=f9b1bzNx*x
zSXnbR=5u!w5y%4|(#I~TsjcYYU$=kKlGQ^@@os*?JjB=nDVc#5LLC)nZM-V&E`@g&
z5b%X|bX`WVg4?r_=&Z3ir8efd)Gh%){4c*@j~)9^8}*Rmt++tU#R7xuwFhaS+by#`
zr37*R{LHDotv`j$=ofbQaVJjOFK*80dVs=LI2m1Kj`V@~8LUn@=5AfY@*b6c&=+y+
z`*dlw+A~ROz}3JHwS%O3a|J!fQz7CH&mmrbk3P|9e=G*hX^r^u;l%rq>xzis1B#<P
zG8>7`$|4f0ThwPaYy|Nlmp`W7$?3m4G#DB##yF%NRJ<~U82E2F1l@A<aa!}QXWi3c
zj$)K|8=j$IHJbDG+VtlGD_)^LT8I~jH9X-r`1ru2NM)DpJ0BSJiBq7DVrn)13fol%
zQJzIeO_dM+Z?#~lw|_~iB|Y`=Ke>5Xp*rr$gfz($xwBwUo#R_Y7fc{+T7H?kSkTKv
zvBJ#p#CLyw^qAufzaPTgDo0uG{<8?=CH#q=4!Z1yS?|A1cmJhxi%kv`dc5l5C0=dv
zTlb&wqhv`ZDN*DXzWwUrcth#Ck-=S#?>9fE4(Sw$mM4n`Mm@sQm>2)$A0Q4Zbk9ty
zL$j1RmDsXr7$^1BAD@^}g+;lWe|rW;v_aAY1j1iT29L^JGGgWt0vz!}RU&mu8<k7n
z#G4@ID-a3^Y8?%=Yl0qFfx3|Rc!#3-jx_Q4tnm4hV8PL_<4v%L6<7?3|J1nAaFvMo
z)4Qr;M#d<`4AQp;S}GY$U_Amn9`yj|5}T$FchY3R3)&n%rs(Xs;c9?I&||PRbe~OV
z9YBPFd&h+rv>acKGznZ10)q1JZ}Cez)h9)*r1PRR)<&lKZow(Nzf=jxRgJ|5QHmkq
z{XN?LLs8A5g~At}3brU>;dqfB>OerBc8D$U3q`PGM4hSq^K`(6WW^7pYO$!XjmnYt
zN%=w%S__gw64E;No941b36)@6$Sz^EfFP9rePXi-@h>{Nvl?;6<yUEwl!OkZ_a}bm
zn?$h?(28T0aB&4%0FUG^meYe73dLyM6b+k2HUMa*zidsnq({2!Lo~Mkxuj$tuBHkd
z2cpKMNrFSrVcp_hwKxP`(iAV@gZ|+BT<BlSIn~B-7zudYG$OL5)D<mZ&@@7h8M2Cy
z+YrIW=Sj1K)T_Hqa??ay1>}3G@Mo(9+n};>OLAJ@v1@pYSHB4ux4#OkbjVdrbZ!k`
z2u%m$`_zH#*^H6Ee)-RyP&69(9F?j043n>0qNS=9rn)hrdeBPXTr?`n8F{`?K)9Ju
zH9=tISgbIr95oeWC_;nPmv{Un^6=q*XDoEpbSt=(%1nzPP>TM5rW#eSO;s*K>HPZ|
z;aj${JP#cd4ctUW<24U_kom8t2!gM0B*XM@=odO5QN@8Ve4m4&{2E^U4qm-Q!rWzF
z>bKaHD78Nn*`H0Sad@?<Ds<$~1(~bZB7%I|f4+Uy`@D;dML>WRUPG1ov6A9Zst9!U
ztAV>vc~_;2o*8}rR+l|7SNdX<bP)A(+5VB%*z$<Uc{j!A5q#qWq3u^kijL|17Z`K5
zdk6yh$83^SfWp$COs3Vrz6HTWJdkozXT47WtPH5)0m2||N$(YhA-W5an-ZC-(8dGl
zvXV8NsVBIhE|UONUB$Iw_n7a>VpbpNn}iaQffYh_N#}yIIFF?JJI`F$O=IxRJzh3L
zc+FpJYR^Y$(U#1>LaMy~_}c-1lKH~nY_i8OU4_eB)6?QWhzj7Thp%LwEV>%9%RS|V
z2mYiTEc$gAR)`r5Lg%|qE$;QJN86XXsT&1IKh?0$(ZT2)biA>?@!%KjNpUoti;J60
zY6lU86p49h;x-_sUCKueuGmlw5Gy_?{Q|d)3lE~=ca@x8g{ACt%W%488bNAYM{%QK
zyyAKBBWPN;^X5(~LdTt^H>Z0PO;dY8vvqfRrQcRFqc!EPD+-Q))oWL0e_ZQ61nM%#
zr_XgV4L8#KhUbk@{%Y%*08GO8h=5GVoIVePZm0$uXdftdH37No@HlH~opEZALdPq*
zry7eDD_=Q26g$xW%l$tgpcE_{ITpGD5*{WXYzWwrS)U8D<>3%uJ*ar(oF$Jk^Kt>V
zsR|6Mr6vSh2oq34{BlWmJ$7B(OvFIXP%kFOaN0NZ6byBw)(DfMZbt6zQhx}4o%Hs3
zct?EmG~)_3Fi>+Zf(F21MLlLEEQz9O(ISY_nQqlHaUpUxCT%#21&}Br4NLo#5iKEG
z0g-%wbkI}s%AXwQYCW>`H0-9quM$_?BjLxdo>q4dJDxS6CQaB!F}z3OR(;_{R@G`h
z`V{cM!EvYi<R5(?ZuZ5lzAxmwZU7xWMXB5AHe9-@@(YjPX^gny-CPw*bhRX-g$lmV
z&%2txB*@&+Q4$N3dc7f|uGi6aF92j$aZWNjQq?(DdTrTdZX!9!?pvNZ*6QBjr+tF(
z1^HG%(MoD$9yPR1+wtn%5oMBT`b6A)ap`7vd%X?&`j_=B#pi+NPqJ4~r{YiFyz8YB
ze{ZO3I=b%aj)=QMiJRKf7S$ffl4?P>`DnGGGbaOFH7CzpvX5o;M5Om5U$_7>xsCS<
zR8U?e+$~jEBb|+i*1N!!79UlZN|Q_%I-A&&`t>lZ-W9({lpD%zPdTgtGiLB55K>j8
zj&ad%^V8JYnVOqS9b=Y30?VYGWxmOx7_-kQA72}E=Uu5m7x{P764EIUV6jVEjDU6Q
zX2<vVi3XIVfY4!^gc<yn=Vm5_h0-{TXWrF7gyTK@Gxu2?+!W+oYS+F+KDgK|dJBiX
zoG!9s^%_hTHS5OE+46$osuNY{ilwa41PxINF<A*85G1t&cGkF8491~KHgmrxkh%!w
zmkIckOpUnFpkvAa9Awhkh0f@f&BKe$AOI9svWSaef+RaR@_}4QKT0~J3LTb)Y5+#s
zD46+gdDiy{MW5yW*w91m`v<^z+Y!V~LlYqDR@g0gBWQOw^U_dew4~MZyjcy!-sd(Z
zWeNe})69K1kf!`_{?XWit|bL_w?D5DIGE!vl@Od+M9oPYeO+2EgEx^6tHlE%YPV*k
zJE>)(iTFiaR2u`10Lc>qWuAbYiF0N=icBNXggmbhDS;@Rb5U!a{Br1vV=P`H3ojmF
zH1vZxmdL#^lVV>d_sCWIuT>5=N*?Qf<mU+mAPw=d3Xu{ar~1kFi~k)uZ0ZXqk!X!?
zjZpa8>bAzsk}@rG%aGrxl|~FGysy$W=0l>m#WqY$z>na(l(YsiCGdZ#(XuOTNQ*my
zcfA$tnRhe5t1N2<2~BfO{;EJ|Qr#`v=NX_-*DqK~P|)S<6*Xcx3`FFjuvkE`vmww5
zuY41XCqy-T|2yOQ70X*nQ1q0(y}}R7^c_XGnu7g)fUAB?)D~ffs{T=o#h8D7nATF1
z0oU6X+f0B769uT1py5~fc7ex_{M5z<eKw~mD>CueD17CQA;P=d7k<p>Fts`Vh&dDd
z1Rx?hTT>R1cY!Gf;MG@VFcU+yyWL{Z+ToE$@G?U(*wBc#k$7Ck-S5VMRdgz}7M*lh
zHSWOe%1<&iaA0a5el3kQqP`D9kiX@x@E3DS*xJ>#BmPg?-D|R(i*fi#Jd*CNnjGRY
z=Z`&|)&}Yl|00&s1`2^x2}T+K?I4sZxb~=$ZruISvo`pQPbU|)b3e_XREZ*gk~Co2
z=w(Lg&s+p=87JI8*t>^wwUYaPDk0jsMYA*EVR+*Evi=CH*UU`D3`KVCl}RV%e3aSH
zm3g5Z(QBRD+;p=im!QCmpG_D@yvFv)wdCRY&f%Lo!_8(-?<POJpWN^UC(=`f9|E4N
zUPBV`<<j|gvi(N(cRnsERD4vdQg!EPPBpG;2IEL0PH{zVkVi{`F=KfeB>%9+S(#m;
zxXl-p%kS{-unC;1XA!sMfQLfGxkn93U#MRi%K`)QT|HNS`i0miiv>9E5Hd8B_D1(A
z)3U!9_JVs;2l_u1=7vMFgldS-3syBeWmF+9O?apZ&BPBMz!MwsA``&D_zn$aZ&62z
z6mJSogkDsU{Gb5&Z;HpA$~VUs`7Do*Pso~gVkBR)2!7yOkJp3bG#msy0u_e2FCjDX
z*){MsyxM%Uiii1Vs=eTt`O@a~52*oTN-LxNa;h^#d1X($_<27LPMA(3wjb9RmoPat
zpm4fQEC7Ujkb|0EweYC1J_Z$azSTS$j%mkFJw6*NI^9;-ry!rALeO<rl476_)ATOA
zl@6ats}`L5C50WRQ|>l_a`#1!n*1o%sJm7t5g^W(F5ksVu6)C|dgD_-VXF=F)=^A>
zsr<y+^^{!&sQ(t@k3#lk6@r$-!r_FRjqT)k)00vQsnz?zexf$BGHYq_b$A=z$}@$R
z0DzrMO1{szNtmOYrTy)#4NE%%@MYXo0$M(MJW!fHkS<d<o8<cU%9_Qi?P*^cc*Q6W
zAv;MEdL1n^@qLhhii86a;0iDf6Ilm;<mb?aM-)|G8)SOTm;<-Sb$@2_vb$yi(w<d<
zU2d94-HJqQeN|A#<99@VJ7oX9`}a2l_a~GG^csv^)IFYW)M58gMa17{jVn1ngCYzn
zOyQJ@s6K1mB12@Na;1i{nRKJS_fEHLj{ty3#fx6iZ3>_PnE@aInGpfneIts&9cIMA
zWlfX!K*PQ)@qJ#MaGj|=FFl)YC^U0qzz^eKK?LKJ?6Uw5dm67^6hBg`cD$l9OYi#F
zC9^YscLen7#<?cH=C|+NE+qqnf~MI@P0t@EKL)U-Z?hMBkAbf{oj+||C7$7omKW+0
zW{3mN{v`HG3XsuhQ((Uv%oV@=H<P!Wa!<7ub~PO41^?dH#PPa+0)Ok0>}pIPJ6Fll
zCfDT7m(j}oXTI#4`1n{8esA;F##7hcxWk-W(K;EOC%_F;P5T#nxG2ynBeN%{D;L_&
z8b-DbC;<TTG1|&!!z9VcL6)yYgmfY>yifnoWZb6QoFn1>!;4XB<`4h=UVhgRubMt>
zndFK(c7G#(5`WJYc~kR?2d*sU6f#IeB26R;{)B?`I$tlr8`2eq`Pl>3FF!wbefa(N
zu}skN#z9IZ96DnOK2cj1%<lyA4Mu8y@z2#AqX(Xo&{UL>caRokSQgMh`C-GV@zy51
z&Op8p;uZv;0R>`RB=Ff75!<&ltsce0{m=b;p7M=*+dq3#Ctm;-mL?b4DraF5Ki{WG
zSL(i+uchi0W`$l(`jLgf)6>Ol(BWNTWHUb^+g%srPI0yH7TzojjunVIz)f98k6D0Y
z#2DheB`@qSd$Umvd1CxkVUT^ykV>c^UjYKhb^5IuujbWWmKI=6Ka!2K`t#rQ;x_y6
z<^h?bG(Gcy7b3R2ID)gxVtC2e{z-1(o1(ak4W6Jayt{YQ@-4ikj=VZFh?bw%v0W$|
z3{bv#YEp}>8M5%<$g%j6Q-e{J?`qd0yTHh0dB979<!rGPF2#`jgp&v`X%DUyH+wX#
zKCZiw+$Sv8v+VXY^IiDfn26gb!O-We&+Xd>s-%*90ps@teZSxAs}Df>G%7t)|5LFq
zM+bQz?m6`u%?8NBto7T)kmop9d8Ui43}D%sj!gta2S=l1zDuDG+J1kN=rt>J`t6C^
zqo?0RJ{FFDAN%Y;{D;#Y&&5wC{Tz+|n8FiIm|-HF5@s_L@)G8<wZ{@Z<ynd(&KDhY
zO8i{vo0s^dB5Evg;c}`-f=pak^GVr5XFl+xrQ;ks-4Y6~7Op!-lSlg{oO=rwmh)bw
z>|cCz<NBo3aO0;#rp549j=^_w?wGnq)yM~_j`zI^=I>|Diw)%chew#%-gHAOnG1+{
z5^P6pl(%^L0lSuqJQ2&#fZpYCb@0Qe$yX_MF0aRg`R*W3c=svibufo%Eb@t_Cn~q6
z;P{oM!j@Kk2AEBU{9EmU4@9vpg2*O<0YXNMZuG-V7MT!}OAf~)Dmb>B#*A`nI1$U4
zvciI+bwBPX21(q{{nT;?8Qz{IJUg8EFU3{hUKd3;(&X})+~!^maaF+~oWOsZgQ1H<
zrKF@`wlJ6Lj~1<PibX>@J33l9y!O19`IW)_Jvh`+P6(DP&}Y-;%syArY#!?PiMqUq
zG+RRFuwM#ZpQf1RV2MD)(1;eah{LJ7hT(N(1YrX>e%@5shh%7uE+~gA?vH*r1JfVi
zpfrsGFw@2`<&{bPduF;ocr^Fu@`{-8d|)65H!UnD%JKGw$PNH}`KY2N2Tr%(%j@{G
z(6Jm(eI?*rT|chIj}s6^#XO_Im9{rfK5G*f(ltVzjYV@yy+LQtF*FM>NksE_2KEDu
zj?KX5p4tqQ?^#?RL0_nyGp1o+gh9)cSp-yG03SrpwED-@=%DnZfnzdalGlsXjj8sa
zO>4a(7D{cWho^~@$gz>PcTU?I_dZ;$ZHKl9r(z-5@XE}WKgyq-{o{t=(Kt3HOD+W!
zC+kd)_wL903;wsMDE}I$BhNME{)bTmmZw-DjVs-$BZ`u)jLXF7EL07AUIVm9<4iRR
zdO8a2hpX|Y?xJ5MqfWR?M?2`mb?4O^pNhO~EZA1lf(*u9vnp#&KRSueb(|q!r**$s
zj5kcycZTfQtbRaVA=2p$U%*y7Oux3e@pf$Kogk%#<18=-MY)dWtw8n9QKd}7U_cnX
zfIJ)n*Swo1*~~a%7C_0FS)&WFPw-1u>{)et#cRl4{N@Qk9wOyd`j1g`Or9&{!M^~-
z!@NzaJDs46bM8_)vBrXCDQc(*)N6$S33_Zk?ZNrB5}LLg9DL{`H#LD(*m-jzisg_K
zc=>dfIi>GtAcdbwUQiGd>QxTIBTi$L<XwB;NM(Q~0R~gobu%PDM$F+YW>JFg`SYh>
z$i=~saP?GGmdp?-?`&gfq=HbP&ifYAdoLTbFPCLYDu_N!#k$~bN9W{CxE%SoOuaKz
zCa4Y>&pAu#yEa2?I)5gB|5FJckhl0e|NIM4wHYh@=R+foOI5<39L1DEiJVvuLKf;0
z9miO7QGy1Ha|HVY3j`*t&lMwm`oA;Jp@a|b%p*PhYBAMmpQv-o`6m3hySwdoc*(L>
zPxJ>~j)J-UmLbVUQltM4*NoZ8<hA729;nCNaUTorDa=m@8nAY4>UV#yA*K4~r)~|3
zZhq?J+jl<#J4NmzU5C(lF>J`2X?Wm!-L$3D5|)0gaW;`uoLk>?2VY}6d^>;6i+I#f
zy8PNxOI>1t*F5WxUqev+$8%zY`A_=7^*t6l%|pO@J89V?e!iWog1LECoSI3XaVeNY
z!yQ!CUC->9-O5+l&z9Yt(*B5ud7g=6RdbG5=i!)~b3-V6&J?FdZrD2QrN8{|bH`6Y
zMRN}Bg|}C3CEB%ILf%jhrG0}`q>tl29oZ%YN0#S!we3fCz8@Br_;9G4$K%4%Dtlef
zZ~BuR8}IGY&{japJ++v_hutKT6s`+iKU(>`Ago<!2`QFwO87z0$*UKQw*8DI?nV6S
zq|T$NS8b$2+Abz^xnORfB+zXIh@}u^$-5lL0W4l&w7N#3`Z%9Gf-(n~LB1R+usULx
zzreAjp(6eHaU5r;8J3k9_bojv#SQAuv6(wt&n(=T%{BE*LzK|B^k`x^V}n-uRf7W-
zzfkZfjO~lvghU`f<ixOShFRI`j^Ao`wo<zw^0H5DRU`LbiS|~Mj}*vs{wLaU%DcBs
z!OI@~o}4dWM4uGC`k4HFO=SJS`6;9{U+RzU*e&41Nh<8yjN}5Dmog!Fs=OPvFe4GA
zgo-R+JTFZJHw#{UCDJqyv@nTU8i-s`No_uT_Vsniu-6jnEB4^kGd_5ke$;+Qk^kf@
z+^bqNVa8du5E%vr!V7Gw(}W{%2WNGCQT~FXchT?20tr`PpR1hbn-~?du;H0d2R<jW
zI%i7`%DN!oI#>8~6<VUk{pZQFxR)qH4%x(*`TCw@J4k>%69xzI|DU<1T_^1u4L=DN
zNGPDAx?yo7c!Q0!uOELRS*ErPetIP%QIY=~O29`<?i88-+&YRKws$&kPM3+LVmQYa
zv#!9ixvJS$>Dkx9vafTp>+7;_3}xS3%)SlJX;$Us+@a^(4a>R5$+=&b(=n9uFwFP_
zjz4pg(50IDC@gny$`nAso;112c8mB*0#Dmz$KdDAqG6NK!Yq{7(9pT7a3B^?5{bcp
zfIN|A<flcc7?Q*#K=H$3-W63o=Q-qqahQJ-yu0e;>XhPoSpH_2bSzG$oMHHrUXZAQ
z*(RTXgPiM1_LYP9>9Yb_t_5O8PHsyecPCNPP3|7!M93Sd7@SN65PiR!@0>H@eHEf~
zM)aURoE8o5?Go;0@UPWG@g|7>v7^Uq3irP;a&6Mlcu^=kTfFZo#*2|;^{epPRDrMy
z%%)mR`lQ|g55$v|l61n+jyb({u(?7T@4VU9^Jj`-c!B_zA-qLKPOJp_e?<l!DGfbx
z?ks4pB%>g%$i5;N(LSyLBE{;Y?+Gfx*ff$sqPCHM*nO8W->kAkMflIY6mTK(c5@kT
zysYSR0baE55fk+W4fNood{G4aiy$yw;3Ngbe;r$<rqNYxexao7<`JVzKkPPHD3$>i
zm_tSY7pw6XTTL`~yI^IYB2bk;RITM`7y3*AEUW-lE8vDr6Y|ovQGkX-i^?m0ExeU=
zDYBS<XRjf!%9=L=e<w|7ZNhwf6I=n(ylx_$cnB5sS@KJW9o$9e)b;cF_bYO_m*<Kv
zZPy!eSCMDwrgeBxa3LM`f~UBDKuW^!0&p0*UK)-x6?q-#JAgYlZd<8uNA?@gHhpqM
z&P)GLS8OM(YK<a<lL0nn47|p1)FG*MG2p`el6Nb}_f=P77YyXfD%M&{9Pn!LOIMFy
zMJQa4Qe?VN*N~ovZK4wOjn<Kb`&_wGGN<;;=EGcF+Y3_m#h<vAmc!SepH#N?2zDGF
zOBDDOt$Ixq@Heex2h?(0phhLge%$|P-aVj~Y<wKQCUTY`b;b{IoOpiE3SIxICt9Aq
z|LwIb8ImjGw8JZr3eoUO0nCxLl3V?9z*Z>M1>rU4Rjq^Ez{#{(UmL@pWZvf<eXE__
z&@c!F4p)V47x0krAqq)<(C1O7X?Q;Wub15low9TUKcgb13YhA@gpR!s+`?UYEUIsn
zb>+rVWB-I`aFu>0j-%@W^Rc<9Qw`%3@Mi{yW~$k}+id(Kn4MvNYoQ_jdiJev74hc7
zw|@SOd<VY$%l`K76Sp_AZ*Mi+-X6aFZ|OEqu<3FkEEXlHO;D+KGw>?pW}f7WA(^&7
z4EDS`XVx*ybNG{$Xe;i1QHN%b1L;ydg8oJFYji|wn($<Fi&{?086`d6aUnsL_y+l^
zl};SH7uJT0cGD5@To5yugu_ld8_k;kkrKBMYTa3AZj|9ar-ovmcSbg&?PqHbO-lF^
z&jeo(Ggjjn2bR`v;jUT6P^9OPrKixy-d4YFWR!lJ-98ck=<ygr(E#k+xX>vN=*1?)
zlY)DRPt^`&O9R$aL!!V{hN*n5*xS8SHCf~mV}IN@f?gP9?k`}A=06cFZWktcd>q~=
zCSJUaJb&hXxGd?T^!?rHtMY|NttF|zb!4!9QDFMs-T|x{U1ouY%Xag*M$4ROmEYs}
z?ss%lZ);V8k!Ob*O%+jtB?VqOHru3Fj-d5xM*EX}2-SCXy<p(BIDD@Z;@UdmHbJVP
z&wj8#K)>E7kt9K#6pIFKfGJM+yYMGu;pr+wd-Ua`Cr9rBLee>?!h*+5D~}6H>~Fl}
z*_Y3tmW4ci?(6Kcf>sncU7d?MoDE}(inw-hsd(yy^0jyZ|G!q*9rnQ<QmiY^nfFN<
zAlu4cbH-NZio8ON`aO!j%I8S8CU@6iB@m;|xgHzNVxqw7D(Aa7s81`-11=r@(JVOa
zhEcMmX=hh|53GXeKIyDF8GX6T4*IT&<RjKgb0OMNkj>7}Az6W+(!h?62iV`ky<hO5
z1mR&V)=i2K9W3m7FI4g{qNB-6<BZXGwD{8-65%t*Zy7?hD?;z9j(`~d)A{B@nZo{p
zxw!`i7$-*k`KF`A6CKUAy9N(pNvSA;o219Be(k$BnM=T}vlQqAK?X$TiDb?wcUTKK
zVvyZ@-e$3UEg|0X6j+B#CwBq4K_Y}0XtRF{&4XY+Y5hsPVZ0ec!fUAloXoXt)N|ml
zI36LZBZ4#Vp~wPHc92h(pFmmg=NW#PO@1eE(#$5Ev95}g=jHuf4uwe-4^HcVR``Fm
z3Ld)}W~(0lO;4%}#|X6w4XT0#lWifMMoWRh138!ohPb;+vxvX2w-LIQA^x+=bf*o;
z@EeDlkAHF`owykEcQP20uEZ~e^iaITvk{9c2;o}|<m1Q6nhL~DqE3B5Hm{P#q74qs
zC{GsE7cz}naWcXmr1NvgZ)f19^}1HesPr%1X4@irJlU2r?<(PdMp&1ERX^X)^`Jb4
zxNJtn3c~zQ6CGMe_()VM{(Tn=3jb<y>LH`VW5sE!DtxFmd^Wl}3KB89JYMe4SFo3A
zrwC8Ky|BG9B+|^kH6z*i-)qy3aOCi7FLTl_kMoyeWwvSySDg87%Nia{irzv=hJQhh
z2pkZ)Ctf%o&Al$fFAHo3$2frA#T3J|^hI7RNwcdE8-I|+dv^`u75F*q&_4|%xA0EH
z8(MM1_Bg)-H+n`*QbR?F^EYbf2KM?K@;6>eMh7|fsam-XbA1i@SQ^+i(h%0M*<hS9
z*l+ZZA^z;2bRDZJg@}?kaKmlR0|r7rSV1m7d~Y4dgP)D}j%<=zDbNQ{GR*}IobH6Y
z3!(+%xQg?lAJ&kKRhW!uOx55a>v7lo9nu3oc{mzw>z{O~I;qjfNPGjyBEz+Q%td{d
z>L=|HyZY8$@jM_2&efePfE^#t9N0jv`oT#~aNnbIyy!XCf;o`<-mxOg2SP5y4ixhN
zEx(avD`T9(lyC8=XNY_edpC<kDj3B7YaI0@{n*KejSf13b)`s+*ADT;cYfHlo{d2q
zTNP=N`6&L+<Mv+$()jQcXhB0N&M8HMR^{SvfP`tFXrvDNt9Q??w!qO18y(`Oal>i9
z7tK^r7M$x~ZgMk8{-i5g>aK8$myyOXUSH@9365X#K1WaCW`xwCj$eMSCSXr&R8KVI
zE%sMq!WT34%}tkg^CeEf&tRq;xG+ZDJAiDESkUqH9Qt?xJloUBi_Cu-1&?W3w($Qx
zwfpV*scXU(KNfBorkg%o9Q#2%*`WF1$Et<Cnc~mikv})`es10Rxjpvt-;bX>krf@c
z<!^iU4odXMrMo`m#*t+HFaM9Jdk<&&|Np@M+R-q~`OM6rInP-UvzhbxOvth3RC7p_
zGTYdkM+m8$LQ*01)){lALMoNYDTh)~5{3PIzQ5lezrVL@*R|_<?fKg4ak$;J#p2nk
zNA@*j6mN5kGD?V7#C2UlaqaLr-y4d+6yhhQaAn*I8o0)<bwFl)EY`AUIO`>10;Tdj
zhVRoA(E~7Er6r*g%mb#kf0=(;w{ZVj@j+bcuk_J5)OKs!`@8e1<1H-6C!tW}f0d$b
zC@y-gA~hoHw;JuY6<731HFBgH8U7R*wJ20psQ`Qy$fdv%s9uI|ZB0QxGCg_waR^^L
zyo|aCs?IhO=9LxZAy><%{`|9t+M@sXeYma8WK+ngQ6aEINN7NFgLD^Czs5*>0m8|G
zUyCv*VgVGGZTGg(+%{MGFBkVWTk+&92&3Mp@anga^bOsH{Fup9#8axk8x*otOSBBn
ze=g+zRAszC(L-2%2of80<8+<waE3$lSf43q{Ol(!@v_X^R{o(7<b6E<(ZzpVx;wpB
zPkvI|;T+u&(Ay7z-u<8mWaIho6gai9ue{Vny}JF^th+Lr?K|z(`UQkyfw`+h+XHw&
z9oXOW6pi(JkiMRE5czsJ1PGPX-D^%j;qRa8DGM6q`GKiO<o?`!|HrjLEMG73dA<M3
zMdzx6@oIr7D3Qm&?3pi*Qm^^9(H~!l8t=@!<WQ#ZI0&k)A8p^PbTP;%bxeJ-Y<u6H
zh{7K0OrI8%A<5v?J!|7XKfiY5&G(>3slUH}es8iLJZ}xyb#E44k$ZajZr;Bo-A^|(
zsUTGRhAuvQbPwDCyLRxy4WF<3bFT~W)1>t0O)&Clw-L|ue#&Fn$Jq6_X&DeF{+RZM
z?j)+((rdqZ|L`OZqsH-U(fab_<lbG2tw(KNR(SH2eV+%$T{^ed5hXUsH5HBDSb25(
z_@|HO{$`p-$wQ5{4m$(UgCu$8phcBmbm;2k0C3)CHgJy|CvUh9ZC*Y%*M<Rr=Lg9O
z8F*gw6}pYPdO7|7;w!%!j5lPW{G+Y{KgVqf7?Vdxs>g4c4wj#5IJ8_<ibDb=2;I4L
zMa7H-998;PRDVA}nOv7D9X&*@IJda6Y^`-?GQm;jeigFSa%Y{VQWrGkfx|I`f1y1_
zk@(i|-d}dDz|Yo}Qr)81*g}&b-Y!L3!Ak48V>Tno0@mY%Mn|m!|9V9I6r%I4m`+=t
zluiGbp-By`G$UK$VY^HJxytezQtfRHBRrjTzj)mQ7Nnk4a_NJ9*ClQC10#Kd&)&^G
z0Q3(XzoJk5;8D}PFr%jBV6M?qp5A(p)d*<$uLy<k_}h!{S<x0T>a5P<%QtRKjK29z
zbzaU1(5ma7n7&oMbTz<G-=?MI$z!|yn5H@3;4|O){!||e_@Yep^~!++WyvOQg-)yF
zMszr1k*ibsps`59DD8qo^W109YkKA?%C!akHZ^R$Ae~~Qk{*}$cvZ#m#bX54Ndy0O
zOarZvwXsG<isl!u8v<o94gqR4yGnmCb)f=X1^s04xVu$%UZ07%bys%vdUAP=&__`o
z`su2&5Sf<p^ag^2nsopnA~tu=s<kJL@>`|>xKjM!EBAfBLUcVqwbA{a?sOmVSuS(*
zp_;<)0^ayOp|HRK`jt@oi=|NTPU0BxjYsR*uuGz?2JTPoex<32IXz2*j$Fv^-?%nb
zVflXf*VQst%jJv0Ur~>5=Lxm<xF!ugaW3eujmKRcchS82r(&}%Sb1?b-hzs&=Gy+H
zgEPJ>CT%I~rER=i;-?zw&@&0)chg{!raI9PS2M&NM9RA1sg~6F)w*EN)~8L2_QIo7
zM<t$Zh~rEfPx(f-l)UHB!1LpLxGo0&fGL7CaVIl%Tv>#HzvS?<s1!N@RZ-95MF<%5
zh%C-CWXAh*_I$167TuUzR!)GS`y*}p+_Wj+71y%9<C5|-Ix#4l=qr=RPMJIz`6#jC
z3wVZibW~Zf&VN!c9{gA?v`%w=O6*Lso<({GBw!CqJk?}(;o8uCAiaBd_`4KgqM@2%
z=vtWKZj*&+Rjcs&dyf&H`r=c5))}dGLk`R1$imJVYst4+GJz5WX~<T}=KVqJpl})a
z@V7#P_$-IjzJcF?q0*Z1?s9VD#hWnI3r5}bYT>mGKGB@g*2zK10R237xMw*P5_WOF
z6YYfW5l-zaKB0CY>kt4&>VW{sH7ZjV>v|v-4>e}mUoghcnKN0}&c1Ww(O+1sT4~AF
z_QUj@?DxF#tN!?5;sM@L70#7^3&$;Yx!W&(Yt>1=CyyR-<8@=GdDZYoF0;I7f@V0c
zTG4A{64#C|=usG3;xpOy@LzX!mRG&9YLvb68IO_%uWOo-QI0`>J<9vN8Vs&QImhK(
zH2?M`>>P-pj7)f08R3+S5^WaGI5Roj0+xO47wuWmJgDW}bNz)>mim(ri$`J&+IIQb
z57;oh+k%-l!oTGj*eHvpPyMv+Hoa)m@9vT-oS{>$5BI;UJ{kDUOU>-%jiB9VNoOr(
zX_~l}iI0b#_R2Gnnk|_1Phr6iy=0w$-LGnoD}9HCttrQD#2#M~k#cO)R^)#v!rGZ_
z&=l)e{4Dn+a5>;@ZM3N4%?~$LhZp?0(_eaHvy`EZ$=#}fA2<|H%4f^i3)ulvp;#u1
zq@v@INmAj+d~}2BxQGKc9lB9{WBs^Q>Z|{>*RD<0vi)@1{nz+(+ShUlZF?N<-G0t^
zwEisaT-3xn!!b3vXQRbYOi`+fVHOGqVOo;i)$V2FA&MUk9-d}g566GSYzz{`*S}0$
z?E8J|-nEyPwkkc}c{Fk4K31?Sr)Sxz3r{yA+rR_&1a^v&9Ur^#w%#f#JZopg_cR;U
zYKqV_CO636Lz8fw-2xo(Ma&y&RwTvu<A?7O*O$dlro7^h%pbitj6bWJdSoZ^(rPUA
zGESpx>dd?D-W5f*N^6F5SqLAD`$h4dDS`>1UZ?vJlqQN5$X}~wFVQ4|k7=|qbzi?h
z^1mBnNF?cX?<|++X`?jb`=^ezh(y|jEAY(1&6GrPYi8`UNfcu4_x0RN|A3(f6j6Fz
z%dI*G|2tKOb&p3qHu;nDru~7QZv8oD=k5(HOjKuF)OdNNcIWjjp0cmU_Vlg{m53aA
zN9iSuGOow@<w$V-2CmA=hgH5yR_n94TtPsF)h&AUJ=;6=FetDhtt5->SG#TzoRMwA
z&UkdSELQ(#O&Q~Vp_!)jhV9uO(#1GwcL!}_9yoofeB%5BWg^jcBQ{u<<9hEq{7%H9
zS)r7so3~?vE@Xb@I~-VjOOX4Ew%G?S$}`F&+)BFZrPcZP`_sRvw^<e&Iej-n`TyM*
zmHYEMWD({xa^lfp!zZ@!rXy0JS}MqYZwH!Ae#;V#<~Rk&>u7IU$@^b0T6K95J7Hv@
zoqhH3>y^(c<LS-}V;R$1#HTMRZcK&7?l&n?5eyR?q&+N;BYKp5qhy2hD|hPA`&_kk
zcl(xK19ku2pEzWavvlIbwTB<>Sl;a|6@6dZst{qLebCMf&98|qJ)gBbBibW=UO3D1
zz{-`UD`l5|f61NyNRd#y)gN^`RpP&H{e1L)Wt5uJPp(KVhD~J2)7FJrlrTSJQhC&M
z!UWQx91jDq;yg%Ta`55m`e`l~_niJ@KSTU!-_ti9%i%v^X3Mg3`=GA;8X94WTe%~x
zsLB1)@NBy-H`UV;tc8b|<DpJ?SRj6%XyQr3Bl7UPRd~J@JpUs+auhExjTc<S3+>=h
zNGsuu8=LP+ajkT-0K9JwRC@|+%VK!s^4j9yFS4`6W4k5ux`op^d|R_(wyYGPJzt|s
zv=LdU()p=fa`pPqnAWV}mE0vr36Y$ahb>4R6s%woY|9DhO+E6^JM-mA`CCjs)3Ufu
zq}w~5s_o0^t@7m<2sw&Z@Mo@{AFtIEy|lBY#qUvh6KCHaG2iL2{RNH0_C{i@<H&gv
zW5u59S)~0nb1s!}z?@ZBblob2IqH_x+jStFO*fR1sX#;QLK@3wtX-ibtDW`^eros>
zM!r|%5I<F>ikDoWQjUR@wZi+$IZx1xvN5nGHn(%FFCDN6b?TFNd7mgH5I9pTR!OSZ
zl1hN&5w~EmomnBK(3I=YfGxTPo)Izyk7D)FXJ|H9_z5?-V~9yA0U9aA06O96W7bbm
zPn^T^T{^D%RcD^FMpd*9OpMq@bm%(r14d}clUQXfdj=hgs9-~weq!0xEKd*+>c^YE
zm1(q46f%_~ey|w8(i5<fJ#P=hZ1Dsy@N4^J-Al>+3duc?n_U_^bWO_c-*CAGHZPUC
zT%+xuXF0^<=SQ47Q#)dML+v2T4G{E8fq9IxJu(W8v9r=sc-~M2-jbQ`W)7s*+iosH
zL#5y;Tg>7P`vT94`betV*j=rm!lJ<Jy-oyhJ#&}L1goQ<?rgx1CyXD^$7QF4h_G1*
zC@-u90SNJCquhCqv>aHm8`^Azt13DEXCRG7T_EG6^XxB_uk)0;>qUu~m|02fC*xTj
zl&aS&rB_3LDwU5<(GBr*LpQOTRkor<!)+y_M`bTjnnd)mgLfBrBmIjUD7y7saKAfH
zi52>+2xEkD3z#W7juos@x=1{va{iG0K!i}t6tled+0lO@c2fB+xVBO55utcxTA-8w
znJ$_>Xl%u)1-c;lD1~&pVW9O&1(sHRUAj`5=R{X?>N^L~Y<Sy-%jx;-#t<G^X}qXE
ziS~<G;D#V?U!vPFM8oX<-AASeDpjJfe7_s}4TT38Dv&snuBqC4T~6BL_kj?3SrF1F
z>Onc`2{3hKbo+u-UR^n$kd9Jdh>ZPfeYUTjZf-OG@ZQ$WfCW<MTVzHWS#C@E@t-0v
z!PL=im?r>D)1<;i*zkc+Ts{CTO<`Irvkv3n?4m}D8)TpPYfOO~VIhuZM$dI+8NYg}
z6sLz-u5rd1YOhEojb$ZtDPPQh2#!BgJ;X9)F-OUHSndPFPCc&{p=ZMXS*kwFaCrX<
z2!S&TmPb8t{Plnz^wVVVMjmf6neh=qHJ6&CSM&6M026GU`1ShPcg}ZnvfZ&vVh`Ls
zr_l*3>Bh&{q+}829NfG~5}!r1@eC)ohQla_57Y*HdBYzL#B2-v&<$ce2#Im_p$PcK
z%ljs1`z9XtO>*`<737;7=X?5`Z%V#z>Sf<EH+|1O_Dy^CCd=M({yLrhK#1~Cz?jN#
z4r-c<DYUVJlg$yPZVkF);K*XV$EJGczA0Y|)5wd{$PHmx2WC@nnZP3fTqisR2h|)A
z2*8dq2xUapKHr+zenco`kY_(zAe5YK!^O)<Oz>;m@YB`T9ARa5@BxHQ+kC%FapeNj
zkRru|4(d(*OBW6^z*O8=Bi(JEToCGCt}VBdN=Gvq4vsu#X<z+N<BV?UcF2m{=5g)>
z_gC{ccG9dndw^>C&q@9X%pDNY|H0aWN*ET;ViFH!i9{3{lA)as5HZ_KQ#X1kS>j2`
z?e<qSR}=50QR&uhy}5`Nz*OeLXSoW83acI7J)H4q_G<Fpze2IhR4)^4b)oc`{h!wb
z+HUU2OVe@=56y>}W%h5w%x}||b2iwuq<UT=3f}M~GZO~bcEKXCS;17;(zMDxMHYeG
zuM7Ksig}oNh!Kf?-M?Wu&GmzxZ-M!(6^?=d(=NqKKc4<m((e<c{gfXDaz5~RxEoS=
z(h)r6sI2r(rX~oGjY7sb3r+m3d0b3e(j4wbWF3P5+HO4~>`F}6lj@r{7cM!sTzmMQ
zJ&@}Me<y=HE(Pz}f6o;7XN=+cNXREW!++k2-Ac4Lw$g-5W*Pc*H<i)Eo|<MsM#he8
z%DezVczjqeeqP{f9sA@qGXa;?&j*ZJJve2W6})WmVLtdw&+}kqK__fh2#e=?{cT^z
z5Y72|P57AP$C^B8gF`j+{?06IG?+Mc6yz!7zs+=Nn$~174Ka{zG$bK|XP<la?aYe|
z;R67*6FAZ5+{bWzoao`5`;pfgMY;o$t%cqyjlG`~7?Cv@bToY9JTDKHu<B%{Q{W-j
z!F9Zaucdr`Qz2z*P!$2HrC+u;TWkMjV~);K(wV8-fE#2Kr|v@x6@|C3;p@9<>VEm*
z`0zP=neff*h$oLX@{hW2Vusk@4i-<?Ln(DB_?fZ1R5IL|oaehbJ5COWcN9-YKwk-a
zrnf@X$q$Y_Le$T|?-O{^?XoI4JwvkhPl_PXafL%`9w>zeE#7)>c8^ayUgXOu9G>D4
zSa-&3L99Y@0?64PzlN4dx%%CiO>d&tbkWO}8GJ<X{4whgHF_B}b9N#V{Z?PgXAwpi
z`opzD1jJ`~_uh@y^sY!g#`IC_-ZD*LjiL66F?QL?E`??iK|dFINL#l@e=}uNp3%`O
zPe6d;cY;Y2#OCma#%l-O%aH$!E!Yc2W`2*56pRkle~^xUu+?UmqPgH(5Gm<-)S*ry
z%8%E0>$<BdWU<o~*a8=3X1{UE4%eAJcjgl6lu)(wcpDLMxBeL56?^ZyGGKQg9ZNKG
zq+6#%0B*wj{B@@F(tm0UD|{S*b?vxRzJew=KuTbGoF+QV)V9v`g;jzd?qe&x<G{oB
z&C@B(;3+41VIADsik@FkPTS*&!IxMysF9BR_w(T+(!*8xzv@oqpQL%I36z#JE>#0!
z!D{McJ>UaO$7-vCcvH|f13PB`J7zeU*Mjz<iN*W|9nz^g@UMhd*+b~g+vnABaNvX1
zHfizUm7}ZuHO6B|Teoq5oOws1=|ZrOafooflz>DSBo5~gi$3<o4L-8Q6U(OCkdcnf
zG^mWg2>=?n@NR?{6RHthlR2=#zFfS)bbf;Sapd*Tku~>^EBm}Aku~)Xf4c&p9~y+b
zRh2dBg5ajYo^;TAKWL7?oAq8-X!0cJ{7BH{Cg6k;^%N8JbrTIN6AfJxjgBT7pG-7K
zPc*%%u8xP8&D?IF&=0jHZiZMsr9f=`{21@R=5G>pDy)#db4|$%JMI)sn+&x}Ar0jx
zI>D(fodmtNSq^%lCe@korWbeP4*y0&6y+HG9D$cXP0l=5U0;Y}&=+6+&c!mI*42a!
z2-*G*KQP9bIJ*FlB`eCAtmdzphu%Uy<(7yCGlpLQz-HjAx5a9%U+1hjnfJloQ;)~L
zdz-*E0z3pisb^H^{eVmgBGY*4rR!y(-=;GwA0-8^<TeFi;}4upv_vHRDAuPyJyvt=
z$a$uCdVed_<ydH}D^l?}Q$-Lm5^`7blBbCLNr2x#{l|Osb!^rTWr82Cb|)>|+6<z&
z^?nTO=>xA;f<8l6hCzUrP=7NEMB|n0=tuprlP#pF%m^+nE3g`7*MuQ<Wg_S--@<jr
zdyOT>g)n4jcqjaXUseDWY7)=TpB}hBa;I_0w)twGjY(Eg3*$;TlG<x~&`sV=@J!(+
zelj^bteQ?r<*~?7)L~z7Nc~J_M^@OeF2xl!&9HJQIptF2`(Z_3agN=~$LFK}Nz8`M
zZNZRFSt+=x3y+YhMMl%c*K)}zC9Ld=?AUwz&3dUEkw<sie(;->^DIjtNIg#TTNi@K
z%kNo`XKu$oP=;S1@;l!M+WllM_!T_4&(iR!3!%1%C3mC{zP#h{oTJbij_?GH?dMl6
z(x(`=7ua;4%ideVw<Bbqk#pa47QG!qzNfCSxx)Wm91!#j$)@8U)c;$Q$cAHB{?phL
zw1N(7*4R)gk0%?YiKTgyi&Sga55mq<DI2;}W1I(gjIVmXkiTCy#imVBl=^Zcbi+oQ
z;*|#qWaS;C8*nnhg=$8|9_9Sh9*n5?p^kem{DF%+p$=MQKaO_l^4Y2*`+w#>1>Rr|
zF{av;MlQHqCFE<I(s<SEb35!=^QmaenLYU4$VGLGaM@Gv)<d6bu`h3me@=VWD}f&Z
zQunrFNWQZgkIn+I{A(^FgraFbjbEpAorC;n;?MJ^Uu%CJ27sNO8~0*A=TN{qmkz8N
ze7JY9Zudw(JF$19<;kt^mmSi}=20h@Tz;zH&(94P{Z9+(q?xYI^%wH{Cho84yLFc@
zIaU~!^~CrTyWB!9eX?*Bxd3nN_*F>Eq$fK((AULl=k$Y9!u`L0YP*E^)tyWJ^^dr)
z=iDz+c4~%qY0O}3m+q{xs~zcV(V<uG<qVj%dzz<i9DtdD(1UUT{NDyp8Qdbj+Ux_h
z<#VKww8-Je2WjF{k)>Y8VZ^5bk^{b#YsvmV^-LzS5Hy+b2AhIq@REk0T>`?PGbG0&
zojWg|=U>}>eI!Vu*f0B-kG0zL$x;SgGWa#64HYy|pDYYe$3%TFV)pK0uJa7~k|}7a
zv$8NYUb?B8E)syXUER6kA}-2}<5WqI*jBE<=lX-8sXcwdJ_peHnTSMIXT6*9sC+wH
zonM?+5lF!O$@PdHyW?tZ7kM0;P_#%~@wk|L@2XgamU0x(IHw}&EYY2@Y*Fpy1vPPQ
zjuIv9WJce(`zGvCT;#v{yS_m8OeP%Y#xfT2seC+dEW?XVNz0~Kc?JN_XI^E=DXWXw
z93tgIs1hleoC)!dX}?_x??%7(#~rP>^qJzcEy1jxYT^Z=o4uh~guUf3;bU^I<5ek3
z(G~kclyz15q-h2$N6bTtAatHDs*bIcA%z)yw#fJ22aEohmPB+cb`p8|E)W9K3MGkl
zNqij_<yG1*EV^0najzMSVb4(@LFa|_VdE@~Bi95@n=C#0MNul<AG5U=tz{cl9ZGSQ
zjt*=aGlD!L+P%w|5~hl!QxGo{1b>Gj`;yMv-kUEZUcso5U^rK^V<KjPpHtMmRO91g
zNADB*uwp#swe#XHj)PVS_X*#m=)TgRJda7=y-`j>>9=DCBNjZqMJ+Bq<R7RftoQnh
zDV(~gzSCCyR%gdjR)1lL@N2<S?9h>%ytN;n=!)mPJ4X3FSaf*Rj2VZz_kK9kdo5J>
z^n%7h|3`10)_fV0ptjLh+hk?If)JM-78*IW%8@<i*Jtrj@@DH}>$C&BPNZquDq`%s
zf*hZtIU!!1X~>0G4O8vSyC!Nru*hNyc$6_tuL5O{%hIn>vK^$bT<~+Kh&8D)cHOm)
zfeikXE{^1*yKLjh4CIr#|Ao6`<&S1&9oVk<L%RbzxUk==Xch9A&O~4y@CJFvDNB!#
z`weR2HA5YhW#2FNoAkJ+d9{SeeI*Z=&FK|(zjeL4u{>Z2)@Rd@$|#<wK_W)KC?`-w
zS$1X6mY`o;T&1F_88ze>rhlPwTIGP*%8)Bfzr@oXB990!!tDy$76jH}kE{&m8>)z|
zg*-ppIh*wpy<ce@Q`Nl*Dw(CuVza0rlBuP3t07CJ!-0zg))-%I?|dA{uaC56^<Z{d
z6W}In&wBT=?1oJ9D(1vgg~N;r@Y6Bq;t*c-PJ_Io2xX}sfzWuLC3%Zr5+=9)wambZ
ztLvAhgM3Ov_gMF0@0nW_nZ07<6fwZdgH)Q0JTAtKa(52yR^0CLLyNUv58Vy-`I{X=
z!Cx#a49HOx7^f*`&E|)9vUB&F@8S|g$e0wObSH&@4rMtV3N~!YufJ$npu|jqq7^JE
z7JUV+cr@({gQ`O>UiBkD^;aEJo&nJYXO#|RPSbCkTn+uxt1)>;MqfyEnwPwMot;c*
zv@gKj@V0n)IaB2h-^UOay`+pLpuS!?7VBUZYn2m1q05T=4A<Yzemy{F7eDIG9Rx`d
z_};{grW}kWdtXXuPOnl0LOW%Q%zIt}Q$5Z6zvtzY_};$3v<s`YymQe4Vb02jiQb<@
z8JWmZUGQsa%|io<-)*uEA7m?^0KV$t4`|~Zatoa@v`-1FWTnpZiB)Xp9MJ?*eX$Gv
zQ(l9{s+Ec>;;M?d&k(|_9LYG-+QODnC+{0ENAYTOvl}Uh(w|Bn^R|c$C2frsk_j+@
z?{v9TJ|^vPTX5c(p~%7%Z(@Dhq~)GhEbNIc^T(86`Xi32K(~#bMx=1g2j!E<T_#cc
zr`AbqNvU-AIJ$VYu$F;gd&TApo2|~9^bg6r5`iZslZy<!;^L8q)or-@=j0hQZ-qj|
ziQQX12FsflEG<8_%knN3I+HUHOl(azxH|Xfv?E^%J{ssU`<RZTqv&h{rO9fP6^<!S
z-S+_3D0y{B^-}X|4A&4JG4ei|JiVY_H*S}mp>nD$bmg1-W>KMt22|!q(-K@=uIvwP
z;UcJ$CmF(?&X)_Pe;Z^nH_>+I3vQ0LmtnLF$qi>aY?TJOuD$}ZE#{g+5Bz7~sT&ZU
z6OTA4Te4=Sb27H!G@EwoM6Zbd@whm38c4XD%}|=NEy78GTQgE{ISR#Dq$wq&>-hg$
z!)w}NZ#^=8{59^!*?F^1e?OW${rBxhI>dYitZ3TJe}cP4S2myJJ8H_2{l3N|?%TOn
zJJW~Vm=*%j9C|JBK(St40HRjIn+#Qv6VA4wKF^zQ?$vD>Fim&}6-;o0l&WJA&3vJv
z_sNX^)Srxwq|C{utn--6jLnOH&_ZuIvy95FgwLhat~g%&Yh>&$j4=$K+DmyMUf-6~
zkbe2RtUZ0>kWJG_*PP54`ZO@{WK+FN6?q%~#S##ZCi-z?dIRi~>-97rwQ$55pe>(H
zN^W(B&ueZYvL2k<a{x>mFyGw5a_Ui2nPT)@nSo(kPmlbIAM=&`E3m|VcVu|pe8o}V
z@bb{Ou#Ow?;xunub@9abWrQh^v6lATV2*9dtqw>3YlYu|%b1PTS7L&_SxhkS1xR`I
z(k%6f+O3Qa=UT(>7o5B%?jR*dpx(l=*~yW^V7M(FERte>zOR!heyCnCa1WI=bmux-
zqhw50?fDzuE5g|um!{FCu=a!g)vcKlW0x&^-xJU?-?Y%S0A8jA5^M^QjU7TGK77kV
zk^E?S$R2SvNUdeSa?~Xy1&zp=@hzz)bYzTg5zRKHH_sKnK=GGAyBtd1C-Poi9(Op7
z?r~wrwliQVe!XA5K~6dK9bABXyUwzf<GjKR&=1cpwaMFvf#MeEMw4=Z{*d-I#YPp_
z{RJW_0NR-sO7a33QU(kLL$Fa++$t>5zSkMR+TR~?^oaXFNFr#3*m+8Uwbv%mV_@`#
zm4P8dJ`kisA!;q;ALymY+gbg8N~%*<`D~w3tH(a|OQLrBc1qj$UD1)F>n(%PKG1_Z
z^tb-j$~)2~hD2?Y5{Y7^ECw;b(p5V@c?H^FunNH;RfMhDrEMZE!TS2XgUZN|QljZ2
z_kB>hW$a8xtIfa;5$OTV3#>Z;ziNpl$kIFvofPG(h(H%{{xU)@=(&-&)$87#^HLlO
zbI1QVsH_s>JXE4J0YE!wF~$g85cwH#AT1m~5ftx=U0Nj?4tnAcAwWy81v(Vf=EUrh
zB9(Bs7Pwggl)jM(CzW)kp%MLoBq^sE({k|lbMNgN7A!XuY|M$98=$Esdk;UzIX`F$
zo=~+~Mp{*I4S`neKp52U1GC-c(=LEDGsn)xT+G`#mQ~UUTbazm;oq$|Ndzp=4n8O_
zViVn4XNf`mN)dDN?T9nG#D&am-(|2gqx(p0ofyjdfBb0`$8zT)0aZ=v>~?9P>o90I
zGKU1GO0<r?p6y}o5>I>g=~Hace&ArO>hSN72!{rHYPZYiGtwx@&}E+Rf8?o84Fo+^
zMJ{fL3S$^<aV!G;+)sEM4Ri)r(2Hy1f;|kgumREM^RM<<Q@1I!9EWSk9ytmFn#dWY
zZUxpmGnP`|3^{@}mgpx()S3h<YA}S`gDpDW8OAdWHnQ~=AfXxzkrOH*@jRM7y;zEE
zB&q&`dnTT&0z?qRbQoz@Nayy5;sL$iKa|?ofsAG%NGW{Far9mJ<4ifSjrB2$QKi^u
z56m<tBHmVBKl0@0@UJ$yrJcQ}7{_ul&u*12*Anaw>e}ar&BXe!hJ8MNIikC8|G#uK
z9d~pZY1qB@KyBpULZM|Bry*Z3xM5BMGvYf+#I*>LB0gBITFF#f$&~Q&xszl}Kbzvc
zBP8kwZr3gSqEdi5d$%56)N`lQW5P6o7LsW498z$;n_JPK9^9gCv(fGA1ZG5w$S!bP
z@(8vG1D}m*#Qf|RL!Vhb3is@tH;3aNQ9y~SR>Ew@_&v`1byy-hizv2WRqUlm;h`Nn
z?l(pgGanYmW}ew0-cq+VFJ7uAFOcx`#vqQC2DCOM;+K1-0nS#pq)LCaSH&8Pp88_B
zK~OQJ-P(iPZeFzM@U);blf=56&)1Ol{Zb0kDA2mYMbl;rsW}y;c3D-uB-3~?QuNk<
zo?%~>!{_TXG9brx+sU;gcV{<i`t}fxq=+9jg&rAfQp+jI--8tB^akt^u^tThnanut
zUP{*2V0}&1lA&*bbXT#AJKE(}C>+O12G_(+Xahj@M_*pssJHQ=mG^j5L_>u`w9HrM
zh?irBpGUQw&{T6qo8iT+V>vF!D>-)EE}eXi(~;UGOu1=#It*ArK!CJvm%t3MDp>s!
z+BpUU$oEPtRwC_K`Dxt{c2OZ29zO{Kx(kkz${THfk;4pFTZ?OFSSD_D;$1r=F%V+h
z_43^pkN2<Tr<0**3Ug%p3f1CkPE-A-2MeSSf}i>Fh=<2!2!}nWXk2U8Kv@n>i_{D3
zm#pUaGRVLVSU46G91D8X&}7+5@Fate+=Ht<UnZ^Hc&foD;9DgO?!Vfwe^y^{V`wxV
zcl2WPPF^PL^yIITj{^X=OlF>dxNV<i#m;XrJkcvYYJ1Qp=2sZQh&;I`eM_ay2}mJ`
zdx4aCbL=V*vMNMOD?`kV<AUySUUfF#=vFk>K0P{bA@;3ykKRP%uiqp54;N)?A4<6-
z-UN~+gA<)-G9}&5qQ9^tLj5AX?bD`J|L2S{;(2bXTid8Xq?@`k1&9Y@X%B)xN)+2D
z81QkCW42-ScQr#V(BB)+R+|a_exEW^$uL;$ZS$}e-nlK)ij@86?DmM(k6)mChwMT*
zLdP3Xx$-0gp^6>x+ht+_+iM;%W4RiXJ=2ZfXGELGdx2J-j|d)>^LO?iP5$N*9^Jr=
zD*D!Daw|q5FOc-F5s{JV)?WgkUH85(N6DM@7FbGE1oOQ(gS8H;clo&kd65E^bzQc!
zQ}?#c>Q0Wo8L|R7!N_Ze9IE7#I{kd*`$$R{#HSd-KGANHq#vBtPGWaMuiO&#_0VeJ
z$&7F6lVA!G15)f?5>PkNUuEDHIPN<Hi)Aoi?rh<eAvV=xIRmz&^|^#_h#Cyv@n#RT
z_@Zf!s5e7mm1E(hNAl~|AM*gLdR%%#{w=;Ggp9ek`I(D-BIFScrUdYRet8}hY7rX@
z;Az(mXNG@oCq?uux%avxm5ih9_VrK{4}d>=1uwd9NM;Z$3N<{71>$JR=pMdi1XszF
zri`<>$*_`V<(jOQ|GWNwUZ`KJX(UYK_qrzqB(a+zw^K=K0$~=c2;sTVIhc{kb=&`m
zp<t-Ncb7j&{{>mgwPstkLP%zY49u{>WpTMtp1EU*ktsdKz4nmVK#!A}=3B&t%i_`-
zG+z}&yvj$*JdVaAH6P92mbl;H8T&XWEfYSlkAvFQoccX%r8t%p^!0b}uTw|={XPmw
z4&mPn5ls%2-3(Q}celw(-TD2XdGHUp%U3&jBN}7Fh#o{T!MyyANoPh{5kl21Pv<ZP
zSKi|vLuvte=tpHHNsGF41yYKxMhb}l<QP&_c%&lFF8PCLbw=c1Iak45_JkveGBOo?
zo!4|ISyen^G>?w1_XL~>u@6aYF#P|dQ0OO%wAJVfVllguJ`sL5&3#FX(+Qr%55yF$
zYRZyM!tQSoJ^eu0+r*O(`{cnQ2{EJ?XW__8e^mUtjl!J<VboVeh;hR^9`6QB_Bo&b
zKNs56eI|11M&_`&Z(rgoxx0Z-=6}iQW+Lv=ul`}Zb2?8Sk!!aUJ7Lp=)i#VbpTWj+
zHx)_V7HwHlR>n%dSuDrmfc0OrM!U8TbVeZk+WHbfYRMuH(hlo7#wXaK<nc_{ma?6K
zeGIQ3(#xsuoRQ=B8g|&EIa`blNj!43kb`nH-u^+SCdIdGm!6!!gh-0*LGqFJ30ic+
zQAi?%=n&JJ74mC2BkQtJL5%DD<B~kloNd*+pyX}3dde%`QQnJ87w(5uCu!u}O1^+;
zM=$CB3P{PNZ?<YZCz2L9=Y<VU*K1_Eoz~p9X}7j*#JaOue*cG!bof9y{nd{pI*@YV
zklJ;!8Oq9E43zy1!mhNtXbA%rczh*6dG1bkD-16co}oP2zU}M54$9Ht5?lV+w$&W;
zBHLZM%jlN46#e3oQq<Nv9OB+lk?tLzk9ieKZhz1IFonwG{hty_aNk!#OQ4bIXB2pM
z@{gST(Ro%ib!eS@@BD|<q9ducZZEim1$C8XuM|##T(>du_aQx1bJcEIeL3%8DX*Lv
znq@B}{w%}ic)RiH+p8TCXD<nxdcWs%z8<jkxED%Lkps^+BWq^}vaJ~^f6&im&ta}F
zgB5otEGIk+c3%>UeG-i(J<nnKtkC7juVQvzC!TwAcJ~ea+*I!F)P-|ziH{`)L7&f=
zO4nzMzP}_pmJy4}xgAbQ)wPymPfNsR41Ml+E6bFdYze0Il%cG|#UQ^sI5^bq)88N7
zlvmEchC5CRrzffe<H4AjzOsLZ<DosV9t?GCrWpAU$((ZyB6rG{p{H^%0sA+LV@&D=
zCqfAdxB>Z-=Z|}J`~Kyqkh{6%r3HlY9$!DATzxmGn9%Lr!&{uOzxe;3a?o8Nlk=L^
zDl;UxYOC&#=i{{qugEkH=xcvFQ2Xvff=X|_mfWt>P2}6h1QhLAFbH+bGF~g+a-W{|
z>VD-nB>s;`z6L@=7?$QBgoI%VDwL4PFKwK(g$lFI7FG8NY|5>c$rT5Q`FChmv;}sc
zg;m1T@rs%tT3p?+5fz70R=^X(W#M|eVvxwVJ`4b?s<XmQVWt*8nbW@Q487eFi}t$i
zdEMvk8SxmOOwP}3Wz4m@5@35TuEN>}Wkvpn*h{PzKM{C8v4&79i4GKg0J=vpD}Qlm
zECIyO{`cRHqZTPNF0ZaZXL-oJOPX6`q++~Z(VgAf7NA`7*Q4!^vc5elb1M4P4gcf6
zH(n?zRRh><y7qDL*!+SWm?`|Mcg!p&Tb40D8t`DhYw=BcLW^pd!~s`-)k>0EU4GuQ
z8^e@0j{OdL!js}cd4Nj-?c962<a)`<s?|XJzjVd)^SiR&&<&d~D)HUH)vI`#RSQe^
zHE+lz9EwAJicn4C6K<d4!^<`<^XUM`Z=v_+NWsd>a_x&&DuCN&c4M{31p*Wh_eWAW
z$1I>-<$%qOwjz-);MmpF=5qERCf{8DMr7>6<2LViq*bK8S&s||>WA>dhqUhO><@`%
z+4C5mnXBf;Tmn9h(^%D6_Y2SoA&DwY_Ivh?Xp`LxQQ+W8#F&#|M(uNhgRytA(E5X4
zNF&zbL0;}aPN?41w32ldYWfr_v&9DSR~6qL5GppgV+fha2@t6}c1v?{yHTPwr%Sk%
zHvE>SvcO5ExY|GFoHrjP%gc!BW7gw7K&!NBDFlM;V@KUCpOXl9MQslgA~d6EWx(eB
z9+7WgyCsf$2vPlAf-3~=T%EJFsF<>m!!I<2tH@_XOd-)`K~x9q(P|bB`w>|D{pKUE
zC(tE0g$No@^m=wqYL2BX^ZUcervj)p2O*^<sa|lA)Iu{>Py;}7uls3QqYN_N974!&
z^{66e$F-CyqKxf615WBq1)LDUnF>yl5`P~%-$G^~iJw;gpSL01Nt$*GyL9!m4?*T@
z_JrzNK9e^W90jLpm9WUqYd3!>22EHmhujtBGozAe8t?DLBl&uV(#N{BzCPJ?Dao_x
z0yKrsJbF*74n#P>sT#GTJmXJQeU~r#z<H?r3T-7Zx!x<;40gQEsO{@>rk_g}M&V|c
z!=9A<HBair9JZ6?53P{<GyOaKnsf4*x<=vRms^J}pGG+F2z)rz=xH5`mL2H0pRA6!
zmz=QCh@|}`oj$q>9=rJO`{|W@bb3pn&OaJ5L;EVOBwg|Rs|02F$CfAHT>=jyow@WM
zTmO>bO8p2TcP1e-lC7iojzw2SU4YXV%8GZT{H*{~K}bH*0IuQ)mYl-V(?EKY>z@$z
zEOGTNkZ=JDD)%}Wh3N%}6pXp??!JcGMSw+^l#uBEjb4r}Y8>7P{UaEb%jwF<viF)3
zshF~++hO#ED05=h{YaX$Sm|d|@YvV0Pc+X9=Y@)eGj^2BlBPoQqP*s1-XbJDmgmIt
z(IK)cezs;Gg$q+B=M}c6Y%TYM*%@LBXkLFiqJl_Kw$}niTDnMcObN+jW+!}R@F}}Z
ziOEbNBJWc&r7-L0eAE7ZRJ*-x($5R|UY~21_r<eJy4dw23?n#$E0xsJ!<WdA(DpIx
zBicb^>pF9A`lX2W*zbCetr2?MaYXnYq~b=&u_8qLMf!ez?6}sTp2u+=Kd+nFp{7|E
zYLAsh_NfK$v0#MuUw7$M7f>sKONJ}zO4<=i{}-1%TvuZ!r;Iv+psURlmCIY?N#ulL
z&~r);)8*zhO7Td!Nou)0T16n=PJy8ES12c-<BHNNSInL;;L2`M`6SBsfKMO!9*GHS
zTN4!Z4ZTEWa}+<fIG{uBWMaCqN>H=cEz|hCiWFX1wBhq4KAvio&TmHBOxwzS5C4B{
z0&IX)*90OE8!q*jm8sGxQyqY<lUj9a5D^;BTjcu9*Z5`-Exuc^PwmwCgUHs}Ay&D5
zDj222n=!!mO5b{gWTQfeV`U3fDxK0DvXNlzyJ0J*ZoPu;X)2dE@1y<#isuuoyRzPp
zl3x{kjqf>XR<{!5Pb)VzFR-$U_I)4F`_ad!4xf9&fl#IgLJN*`_J?eC7aX2y6jhBJ
z&<I&K3O%+cU8=z(zZSkR>b9i#)zn6}zh+E5nWwg~yBEjMD@?=l{I}BQ`eG+uKnLhT
zty4sl^hLdBA#}mM@t&}ER&ZKLhWt6cu0{um$6>AN*QVA^0uccU2P%CUn~M4^BW?uq
z3)%8*e&LI{>s>v{2o>!>*-#;<Lg{-AT%lNh*q31U>lq=+z-r2EKY}4f{W)F0aQ<^%
z72?fWL%+;FU?wwrT1Fj7ROeO?=zp0PGC^DOb)pBSvLJl`6qELB-Bz`JOgxZr()o(J
z;QYjIXF(I;o*UWl%-rc?QQ|cSDuN*axaB&mw4>LT7o+X04w-fG0V(L*13&Q+4nTl(
zoBpI_7-+f1sy}-sDBtM$*JF-9`i@>d;(AaemEBb2YRbZ{V36&IDfAqwbz960-g5<D
zJX7o$L;~-+Fg$hJ9nBS#Ox+J(Tkxgm0_=+BrV|^}a@>j&4>?lh-bO~-2qfW0*+Z0q
zV!<qamUNLsr@M!O$@sv9zY^`Yhw@7ewJ^x#X13*=@Zr#wo^#eyG%?6p?wom@Nm~<5
zEG+cWa&V32Hl<g|l!!XBGjf`{W{vJ}_b|{K=Zms~$n4LRMpawQT`n7`yr~!8TPnNY
z_SS#2tNteGQ4DSaF<^8|Oz@4yr2(d%=bd^dRC^0Chr6bGEq1Rk1;saE4~1oDm6WG%
zk#$SdP-loAlX6;njA42wzO2Qui*-6pW5?i4ZR7CbsG5*(r9@>x4t#8{XLcIFP~VFe
zR7=L3jAyO{Bj;6u&E$UwWpk9mq<D@<FKHLxp|96}!ORxA8xihwdHB|8I=fpin&SOY
z{l`}-04QxkVQ>HhXsHA8KnvI$0wA~m1c3yo2mpYH@;Q0h)Nq(6Wrr#|cMRG#K_hy4
zu&r*O5KYXHvv02-x`6d;4jgK~HgZuLBnCp0)SMY$P@pti_mgFEf6gdFnksS+m})sJ
zd+f`IeJnRe__D*R*&6bcjrWJ)yEoq44&mg;kE~Z)-QkH3&R%p25XV^4xA|v&91TjJ
zA1j|;d?EGrsXRyJ;SFT#EQckk89drK{|p0)eqMrMPd-h1Gt)7<soSMdrF)jQ#qf*d
zgY<tr6%38L@nQJ&wD12;kKX<EzBBRb$6eu@_=LT8nZkZC-%ZDK=;M7+ux880D%*cQ
zYbSdLkw5Q<H#~p*@XwE#Yzwa7*g)el5Ix7cbDY_<oK^xO{Jf6^)B=)KAf{0MVw>0A
zQXZqmoDRv4j!Z34J797wd4`U%!OmvDu89LG$-)@6!R5D~6`h8+A(aQD;avrm9rYw@
zJubOU_~^i78A?I)UQ&Lt(PGnlfjRBkRs7A-*KW#}RSjg-zr!d(5#XRZt`_WTzg)F0
zfMz63xTiW_7`>?8bSgaHKaVbtD2rOGkh$#5#y_5lgh_sbc0H3!zWm37g|Lrz3VM#{
zbpg~DRZ4Tk<CNK!Wl%iSYoS_tBLDqCjg|Tmho+-xAjG^UFt9N1Dj!vTF#;H|Gk6g@
z%~o<d1nR9l8t3Q3P4WUB42t1(w_7~bZ3TuqzuxYGkCazZ1faP=1*3QQg|nt$j)BZ~
zzh4*xAUBTZ91{pwwN8smlo0ONsk_lCV&(At{&K^SSJ(JL^^aJ9s_u}0hEa*3rkfFS
ztY(OKw??Un{2d{aK~ir(X~(K);{(3z6-^GxR!h&e_t0c)5C}~h!>Q6b<*XmP(?`j#
zcWi|n%~23@1m+!LzxUz>v=Ut|9Il6%H5t*}#8(y|LJc~Pd6EdtyhMMgg+K{SQi}i-
zuMN`Diob2(8+YmfIWpf<H&Nb`jXSlXFMcI}pOJ6*YeAT0G9ltnl!OrPNEli1$*_@$
zN|_fjN~z;^FTA4ioL>xQ4EXkUF86M}I2i4u`mQ*Wzr*49*S7imDlW_o+2c->8;)$s
zu(+f|yLjSnL2olcMmFEUOi<QqcFxsY{IA5@ki@v~0bQ<NU6Iiq)bpV_*KoM?z-jxl
zZ_te<KOR*i8G`NQSm!c$q>aq_zyF#({bTpf3{!V+YvJO_z3t`3+k1ak|NF7`Z*BiG
zb~fIe<nC@Q-RAD?{Q1G<0?2BB$F2)3<95uO#*$s`%A%z<3Kdre+v|MB7ka6mWsTG1
z2Hm;=6^e?~q#Ys=Qvs=5)4Xmlf|pSeNEywHY-oDzg^SORLDWn4Az)H2n9HpCR)U~?
z=rFhA7&~WDkd>uGle-7H4dg+@-v6Dwhiy2NVJCdRL(cAt%OI(Fia~RVzCfhSnNDI=
z<nlG`U!s5Z8SgoxL-O9k28hBq1vQkj6HC2(!RFA3-U4VvI4{KCbZnz7mzBgTtSv@$
zkP1inqUoxON~rT0O*+N6Or5=r!jaN?W~_N_rHDrxL+dBHz)Cfw8IVhNBJeZaTmhAo
zVL?Jfu8XLua*X}3hT6}IIim{lrJ}&Z{Uyae%WsU2h1(akxMLK(1|{X^Y}t8kTDj%<
zYCc%@(bn}!k%|Vxn0Dd#%^Q_nPD}Q&zItsn$7A<Wl&n|_g*I;WXlpV<?^ZWAKXMW*
z(!_YLlqF0JS;(k7p33@m=K8SP+(Z<qUQPI#y2Ayz5yf93cH%RtMmaW<EdEzv#2?w#
zS-0#jV^xP>FZ@OA#*~5Cl<+Z~`40CjYt$)dm+oep!j=ATtgW7nzKBSn1$M!<L9G5J
z;$Q~@>)k;2VtHH+u&ba&NL|tJ5uW>1nCD^CES7!DV|)eGcK%hFy7O1-_A->IDMzM-
z4}S=-62Cv_$rn~RApU(NE8-SWvKp0T{HRThsLGHrsb98F+~!m*Pp}KMrIekw{ra0v
z)GH|!SsEsx9H3n~(lxOJBN31B;MXODN1r2J4Zq7C)l*^(h65eK@4~ri27vF{h()z~
z5oXFj@jh0?<Fx@Vt#et<<MEK`KdGzD6AXs2@Zf&M)MxppaFs$EC$?!lbGJh|i9akV
z$)4ZGvtLhXX?HR4$jC>QoV(J|HK<lrw?_IHk#=#%R=>r)9Y_f`{lnlKUs6JvqE%|L
z#4GR#O1=w|E;Xv+E0~+6ZxNykbt3onsnn?A$jQ$NU)&Xbp&ta~<o#6g9aUv2<;`wB
zC`a3!3Mjn=7{N=|gDw{J2Wt|Zzb)4m89&Tt+>ApN-Gv;~GydT*;9zB1@Mg#@=%+t%
zFi^d)UaEbRsc$|jI^{2Uldn(5XhieFm!7F%-4ox=9?rRd2^8ci_ylDK?zQE(Xki4(
zPo1>VsHuGMmm?EM&8=xrX5V*qCt-E;tPCG5_ZbJY@x`r1Y6ge^exX7PbVBE5+q}`m
z%<-C}q^!pBS;L3r6u$f~`t>nKu=I*+MZCTG%Na7B=mqReVTAUf)30&2eTU);_J@e4
zz1I0IRB2h=4g4eQ8yO??Ojz$m%DJFe&$^9XtJo%Snal#;i@moB#P6OR@~<%+laWP8
zcf4Fwdp6#F@O|o&R*iG^bLb~$Ia&wxRKB$H@eMr0Oa*H;ImY<M-1%?V=`TsM%S}{A
zuFjx0EnDmz^tN%dHQ)b55rjk$7PekjzI4_8*@k04E>+HO^TJavIo(;hRdW3v#=vfH
z43Pyv3wNBbwQ<%Ve6F4ToFw;S<U(#N{Z84%1c5G#M;QVshzL3TG+tnEGelXiUuV7g
zRL~lF8IU59+E5q6WsiJ0>u8v(k!&*YIp|(->zqkCA8=SE<HFrf1~cJTlRmyb5pYuW
za_;kdA!bBO9?r{5m9)QM@oa~UkqeXkg9x&i6Xr{BnD_Ax>$6~=J!Yk!Iy(0K5hXuv
zaAVjsL3QOcVQiiG8~#LV(&%yG$ne(Fr=0@qL8yvg#?sBPhsyt7(m?g$$v<;Cjg8{8
zKSg#RK^A4dtb>ofuy%O*yUW=}w@?22Zo5463!=ic7hKu>nQpngHh<o3^5ov;>4Bv`
zviIzwf9(BTQv0|0;_2R>7u>yn`=_uJ6>Lg{`cdI2R75#-*~0-<1W!Vp;*-kQG&#$=
z4jXP2tiB-F2h)ahAE}r*Eh0txLQe(@^HePzPcjytU)z@>V3;l1FHR!hCI}AYKLNlC
z#`x25;>}iqr2t<)+EEcqw>Gu>tA^^VCV02eSgNR@+Jmor86Hg*bG_0(s$pvbbkLeA
zWZWog646<W<c#sRp?Sffu5>gET&xZ+Mls#^hux4*QT#P*RKN^^Gb1oS<@KCmKBbYF
zBIY>>Fzb5^5G56C#gnMV$I}42!Zk#3QJPr^$o)U;C59*uyugsB<PRJwf-QJy3VGf%
z=a{}XXbf%v;%xxT*C_&<^_h>v0dkl0`q)`uO_l2=xUWz=n6tk#k&&&6;^1VzQjm{v
zf);h|A91pMt@an!bLyq?4|({507P<|pp>%qm1-IY5PCSqZz>90LYdrL^B-~3*2EkL
zvX#vCfZEOqP})v%sRDpRGJiPVsaa<b3T`pZnAj>T>j{*mhqvK*vRVc26v3^>kJnt#
z(>X1++69BmN-~TBJM>YtMS_STBo`+X49EUMJC0DK)7{|Fc=&v)P!fc##jE5U!80Mk
ze|#39KoHYh&VRuDDOB#J<pJn+vQbbH4itjTx)!5FM^&48_5T#QJe7Y5tL-*X>>;hB
zDyGpi9%Qf%vzT?!t=XSmfU&4D>#al(#f?;i%5*R4EJL{^MnuerY8s#(u=9LTssHeT
zvpB(7>cutF((}>^8U*MSeaU0)uzxc`e48RpDa2$YWhS5k$>2%s76`H>TX&sE2$Af;
zq2k>1`8fi6YpnExmDGyEauq^nDWXiA?AWqMb9d%ShD<$?htCSWG$#ESNVpFN9!eYt
z#K~T%hgAs|gWLGIcp*bV<?wacy3dYGH_4A~a9{>*Dk=mtlrv3H^=^{$AuwM+cY6lG
z<e~&ih(e|QW}zlJ2Yw1&K_T9uwfU71ce(|scqoa=GY~=?xqmfVi5`d$TB97P0ce=n
zQr=ksi*>C|{6TP=;Lwa{Gc5*Vn*g@Ln7+>09xDOi_<ke^{h~-~4qe4)NHi`OdW;=_
zSP7L=&#Pys)=E{Ziya8)DoTnMNWiQ71I(T%n;+9Vs3|4=$Ww9}_5bj6FaAvb|Nr=(
zJD54o`OG$_IX1_f!kF_Rr-UMBb4UnDWVT@lQ%>nL=R+za32Dxf3aOA@IVY)*<dpsP
z{(df(-+%DDT(;--xIFH+`}GFz-QZiLTQAa$Kh1f`%~S>U#PSxvCM@6|_e8_}*fW&8
zJ}n}G{Mf^Ucp-w-ImBuw@0!o#R0u!plOIRAC$!aBG$EiSmeXYJqlXDU-%JztDsWrC
zp!Vw83A<H<U$oxHJ6q1ZTI#;B*D4~KB`GzVvEG*3S%&q6-u1;v^`&L?WgYdmXX@|n
z*YC+)e5i=Z^W&x>#LF*fRB)PChDz4J8#-Moz?+;OoGm^&-`5S|$ukrBBnCX4;qKii
zrT+DasUR$&?|&%qZo}m^HAo7H0mm8;kNHcE;hgWK2iDL9mg(1Jwj(?PlLYZBzxd(n
zBuQlvfJHH^b#Sk(p^wJy9~+mTVLAJv`HmQ2$~YK}u0j`4`|2Gg7%zE4Bz?I|G6V)Z
zndgf#6M_o!ZQ^3&+63<JKd2AKJy?@?<lWRYo(x7cn%WAvYVzq9s4<CdkpJJ(G7D!x
zTBc#wKw})CyLI`@B)HN_UB*Vs|7<N}{ZV)$G7Z0Loe=potRUF6vWj45)5@%AepnF1
zQ4UL8;6bbk@Vt^Aj216;hv}3eUJ;c~BXaNxh=2+F8>CaCzdT)#uT@;l^?R~C+f|j!
zEbzDRGu}@F{@}>&wa%}^AP0z3(L%qS&tUmm00vu+pXf8i+j0Kf?M>J}<(OOIx`PPr
zhVeq3SAxtY?zTSBi2$AnXVLo}%4tTzOv5JHlK^Fpc!RW>)J{opBSef>rn~=xO=qnG
zKOPM+aqninB73FoY{a8Fo}gzDPS!RbXnYm=HqM%oA^L@TW1)pwojpqzU7om38_A@+
zdU`Pj7sHh7d=uUZ2Ei}#^FZwc9uydFZlC~UHnWL6Ec$pu8gI0V*dER5L2pC|is#M&
z!NN;a)?W2lyQ;0KjKV4Z*VE3Yp4xL5UvN5TUFeiNV~1$a<a^!U1a4-}L~<9D@UfqQ
zrlKY37TP+VS)GdZ$NhN@#+0TZ!c#=$Cv<GDYma*K(-$xg1GQkY({Z1(l}*v9f`?am
z)@7MykI$sFgA3sCJ${y0Q6{a#)tGnInGI-*uoMCAcp8mwys&}Vr7I@%vMMY~Qure6
z2iH2bYEse+`{(%kEg9nLO@XJzn@Y|3_M#13{V?|A2JOu@{#w|v<+%OkF2ltxm!4uF
zrk%$8Edk9H>wx0elOB$u-v>X(1hCI5Kl2c_lL8W)MN4Yk;#}CnN?c6C*-|_j|9yI<
z1RH#S9>l5ke4lKc`tax)jQXm!u{g46xa|Z$r!fI8y;%XMC13a)ESI5oKu?OR9!Oz5
zcN6>I9QsHA*u!$BHtDFG6;!*%!;*kbBV^w~uS+jurd0b?H{Fe-LY+S(J~|%U+11<-
zVOg%52OSc)WsI0YTHt|4ziAFuDhTfa#BZYKdbA&VkI2;>ZvFX@Z(hpGeSy>Nmrkm-
z3g&v7OTHx@GynkmMho0RR01l^+k<3Fb%R!JJh_+7lWc?NFC0oSbN)US!m0yPDzD^r
zSa`7ym*1nae&~aJtKRgBod0hmXkl&W+x_uWT-ck2|Dj(&HxZm1Mo}SJ0*cxWKEh2A
z0%vkl?EaYq5qZj-)jSXh2Z$ID_073llk>#*k8|A1exmbpr;eTmM7%cfkLJ0aDKSs$
z`Nv*;>9fgs1V@uI*Bw81$nKT2=Tp}{Pv!laqDfC*KQUeCGySe^kh2`dr=P2yVN#nj
zjwpU#td25sG%us;UtWi;A4&_J>AQO0wP=0lC-+ok%GD80;6g28!?~L8`gjj|rl{uC
zyhvE>sZWAiZ!9-l7m@H-M!`W-8b3OOA@E5a_t5kZ@!|aJP%d74laJ1Hwv8_+)tH`M
zLeBzRv-3htGbeJ%L2L(2eATLOR>2Z6Ci8M4_e~li*Np3?BJvZGJ01~?%GDVEGt)S8
z*7B>>V;-OHucx_Zm5!phV~M$&b3%cv<y6FJNVzr`B**90E<bqHv#;X2s7v_M<Ue|N
z9;c!OPT(@q{=*^P4I>ecXakpKuEnivXB6Vhgu+<()4Rttb2tU-o-TxJO~VR4fl=Jh
zSHb}80h6BZ2ORrAi^{x?$pO0^CAj`e((v&av^~Exx9M)s443Ut&TXCf?kaWwz`vY@
zsp`LjH1nNRmaraiH{;cY@d~m?Xx@i*=Qqla{5S)IfUM~GJ50~Iiy&FRtngDy#NxzY
zcS@uDLz|ZMuSVBTj6{n!gmT?+De(7ao2xHLtS_1OyBA@Ac)r&+jQTvZ)^}=tt@P-t
zx0IB3ywHK!M_&+7B3EWz6=l#9_3+BuZ(GaR`2QZik&DAebl(uXwa0h$wXiEv?=P~x
z<ocTSc(ILRr0|tSi*ezUyX$kfSJ$eJTPL#}l*_QLrxJtEL^HwNFpJ!u@qR;E(f*g9
zGG30|0t4zlt9+j3w#tB5XB!6*06X@<!FJa0?5&G}&&7`ek2KOmS5TYYM;a)38)(yp
z>vtSqThp)ZP)<`j(NE4CA(F;@g1{1MO<)i!`ooetaTCD|*mPopQHdM{j4M<W8_PEe
z>NvY-wW(#gjX$?-mAY+nZ`<z0w!@cgC+4=Z>>pRtKkm%@fEt|ClCUcRmS6_U{CM%4
ztoE5XSiCb8!_PkPnC%QQ1^j`(I%!oUZHGqRnRwiE%9LMT46vVMEmv=0{vTyTI^x?L
zE3wE~$1cKJvAmb&`R1G0G0p8q00&EBEb8RP6SXBI_GDc5N>cx>u~q+gh`6F7{QD;&
zL>B1kOE;)q5pd(WazgU=ScW`5*JFP8Wvt|*IsRpus;d71lX%d<xBu<4XQR-`M?&@r
z`og)u9TsdP?jOO?tP~{|ZO*55AHiEb2D4*sbH}F*DDZP6uw)}Y(X0vn;HG1$sG}pZ
zqm`3~%kJ9KLO>Zq{!#n8W6gA7_V3^xG?1pwFe9;XiGYv;bLJU5(k2u!mj!&bFnhz^
z(?>T4GAUdC-o-9gqVg1!lc365vbHzWeYz>)ZYvIDy66Av4-*6cGyrDof4#u<7C5!V
zMkskVcPy2O__OWR^i?zUQ-Xkc;;Lv{L=W#Dc|w+ltSa??17cO+BydJTe6glcptsKM
z$HMx%$;nYY<_b^b*OPgZPd~P+-)GCBS9-Qe$axd$H-m;+k%Dntr=to;DNM9*^672D
zM785Rt2-Sib7hyz<=@s-@%-ts%%@bVLVjs!3fniRWbw~)UH%NRE*ca0WkLn|>W5(4
zH9wO?koOIPzrPk^gE>#7W)276-qF{7q@$|W^if-#E%nE{yD|E>h^^n}b;RCuryPQs
zhB6-+k>1!JBmS9z9K*4R1~uW>6#^oZ>R?;)81sh}RrO;(CjyL9w=OSdlce@)=`}DF
zgitDL{8{Aj!E5|R8Xy)*r{6Az)u*-2DFUhg>v9B+yq0>PIRwQzUz>~nfBWNR2L1oq
zAFH$p!fMTGigl@+OPUzum#_vKxsO4Q9glx$3~QqRtLlK!T;&QEz#C@WZD!?0zAXR|
z``QA`QL9;TurKur<DR@6eyp%RuCEqL;bvq%c_SVxgJ+cj5ffn&)%|_~`@Q#49;Q9k
zQO+3GkU-l+;5*METS8<*kt!>d(cQ>XoqjO8`1c<9mU>>nxm}zpZ7}be`YTp{H0y9S
z5Q|b_GCG}Je>fgu)wG3aF6!{ujL8S6$RTU%gfhxNT3MJ%zRu70e0PG2_7&<P%H(+R
zYF7ARyqOi#TPTk*?@S)j>c1i1Wajv#b2-Nb^#jX1D=!WPSiM$~4GuaS@}H=pktKJx
z%7X^c*Y>QD-woTA>P$I1c4Tcos3-x1RR=1ZI9+goUUYiWv&OTv)5`7LT`z+b8?lxZ
zrb(vM9_FqwC)#kW@&?Q(vUw;W;lrKADKbrkN>?DJ;N^d)_>^70tklr!6HyD8^8opz
zwT+m<JK>X-y&=^bwe``1Udb_0w`Fcs+8w5M>7Z4{Pg+E@V{OVP;$Vu*4*_L(%z(J{
zzs=#(q0j&58Tdx%ktY0`HOBR2*iF&}Bw9uQPp&yF3y|4QSsReP(me(7g%#N-{fF=V
zWDV1m?#1e#cFbmN)TZ2f&N&kQF@0{e>=&u*mrK&0kD;czee7k?NE?r{13R7QWGf@b
zD-(LMk9)MlbwZ#-pS?<+?*fGy61{~fljV^=$Trxrh2xWnnaCK#ol!Umt04?!a+9_)
z!J@rp4BQw+314nW)I+TDP`GmeiwFT!N5ZU?&Lak!RLDDO%2MB@IPdfXKmR*8ZcSjf
zo(*X9>nDuXg}zuVT?a=$1{i^S55AE#bxM2F2y${6a0&_vvf}(NSZsL}FQ#P)|6$X|
z`leWkPXbSYvvP93krc5WLT1__O3uUGM&#+RrMZY}N`^&{yQd~1wkgnZn?U&&i`I_w
ztMq~RzjT_TE2NGFy1(ZzlQIjFOYQITgP_i$e|wat^(X?XrKeCs<tR;E1?39cjEn_T
z2S>ug;sr?o^{|(`q^5~uP35JiqGzM;UvngVo#4fdZL<HDWkq3QdRfbLY1bMDeU;m0
z@By=o2Gnw(WO$RG{#F6rK$)UjiL{<<O5?D-8!ZWd#|*75QqSv$1#iL!%**(7gAsW9
zPax+38{xORqc?8yr4t6rs-I5u{NJ3M;abL8%oe0Y<7I$Bn$9E$;fI9-?L>BC;6Cb2
zI9w7jK0zgga>WiqkPCi2Wy6Ivx@_Uj>4xqVBJb<0EyG=lI^1jY-q)W@4|lINJk{Xw
zzTxyhxW|)@Qx6l~-#^C|;W=RF(Ng@rG1M}``+bK;Tig2w7t+5w%MK&d8EL$5a~|<k
zT1J`8aJ?nLLVAMXcC#H+b+#RBb8=dx&k)?4og2XnI;maz|Hj}{8Og}<dudC7Qo&tc
zL=$52i^j>4aw#uwm$EkZXSa&(*GV~0HVdre7v%a3KSVNJK7F$L@U#+TE|!Nw1p6rf
z&&<4WTQ0qwHvTk=1#TRvIbSM9{;J);16-cV$s1k0=814SHQKUIDgxYfg!pyg{VhSW
ze!1`=+8rSW%{(Ut2#90kd*dr>qLBeyF{OA+BByq212)Mvw_g+7oQ@@sypxM;73Lu9
zx(p@Xq3au_n8^7*2~&#q33fWe^Z5&F54@lTegJ3qYZNZrM@eS*v)#hSI^IC!$LqF8
zQcF4-Ixz5HqS-lVJzw_9)bKF_yf(n(C+<r@5}PF9Y~u=LK2W4=RbY9zpn&2{&;_I`
z7LR>cp6i>OjRc0FYG4<N<u*xjtUUy1oum3EE{c`H8?L%Zv6TNs8Hm@A=|~{WYR+7|
zZ`D#QL64^M=-KNF-656J>mmArGh<YbI6#6w$5MiVc*6Kye#lM0$xcsdJ%eR63zVlt
z`uArpL^)<}^Tlq&s5@u%VJRRv5(mV7xY;S;hM-TvzeQ2TA$!f?4PO79ujQU{?u`bn
zY@t*7zzYIwCt-=l-!LCZGSpKq;)x2S-a>lMC8$5=QAJAz6?a#*J!yXM!|h`yy747{
zawWPp%}gEW(2sU%+>m0v=r`w#z25KA<xw#YqYEkouqO0ryg#n>W<jS}Jw0A*7Z|l-
z9Y}8z;`w2HwMB_#Vta=T<Vk8_rC5(=Cf^-F-5YM9E1UIu7_XnPrLUxT#no6Jv;T#P
zA&PpV$|f-FdacH|Qn$I4wKPrS<tbW3Bt?(|-?)qnj*&#<$Iatsa2aWZX@p+{zFe3&
zp9P{^(2$d;T(*^yMwyp;ue*fm*Fi*%rRh8%jA$W*YPR`RFp-ybP0xNu^_w0R6TeK%
zJ(nh)J%S9W9I+d3c*niD7^LTTb?bJaAP`Q#J^6d1SJYP<;~eS6dG<{#vg9%6+;gzW
zRg3><#1nBOHKv78Dosv2w)SLj#{XghFryYdv2nje+4ZqD&7Jv9K>os0NOQjl)d2DR
zm+wJx>ecO9Q<^@(I>g_(sLANX)tsu1cF7;MpGqV5zpD&*#cu?-)$9a_f0<Fb4$n5D
zBFx~~c4qX{RX&Amjl|Wqn&He<EqRUt@L9O#I1N0-NGB1CdIg0-AA{lR4AQRIcZM0y
z?Ji*BMCz`fCn0+v;DzXIc=#@R3fatoapTyT@`HIX<tDZtQ?L>gR%(gcbr)_#6Exn1
zi-U+?=|(7SqUwfHEI~?n8wQuJ5^+@uZ_Y8^r52+!Zc4%x<KUWS;TnhR$E4uFKp!v+
zVeV34%5;4YsmGuY{?|xTXG|a#5GfVlVcog^8_sNn01fa=(Ra6IH!{%$H1sC>FufqP
zz2?3cJZgh|jf}zD_0j2-x5tc932Y<=xdzj<N!7kY#%HYdpS-5!q6QBqWXo)`t5x=S
zMZ(AK*Ia$cUIdZo9m#qp2@fOky|JNQy_u;pH2_3Ib^%3zP?73Pc65;;ZM698vL^xR
zA+d@g=9wu-lTJD$IIetsD)a7qHzAU`<RwGi9ZW^sV~P!tRv`zgR^C<Cs_mjWb9!NB
z<SRFY?OKh^#h^ra=t@ftUc42EhK}3byG!iySmm%tOurhD?McYnPJ%IaZRy&dFgPM#
z0xQ{p0UPUQfaT=<J=3vsS?YCNimhA)y9jH2%4q$d=g4qIoh>=~WirwBW)*wgeL2l<
zI!RSS&RJz|yt4pIe{2i?EkPcS`N4=Os~^#thB1&NF{+P1QCc)4e2<!zn29^no8o7y
z%t>_dym_UR{YR;_#+rB%JTrn`98Eu7%}D>}nHjVTZ($KaLGW%JYR9#*&e2zmyNb_+
z?7WkW$YZn!Wn<TUb|?N^-(9%39lN!@_FV=fgp0G_Cchp-vip-ZK#<vcCHd**BkviQ
zj(k;)4mAJ?39IB#x5=PyWJb`)-qY+i#2quI96QQh_cuE-XLW9-&4INIM*AX_Y{Qi%
zcS#njP-`O8c*?j01nAMpxafNA1F+FBL`FMH#}jJgEEht8SSLE+v7-~tkj>GoKT>Zq
zhS_$f9xqnC-KR9z?NT!yzx}s#vN9GHJeQGgmbtzD7Od+WQZ`!LIS2_JgPkZp)s*gO
zLvf57<9ss4H895gevD^%jQ7tNAKN%Wc${BhT;ROQRiomi*50%!7E9HgiF}piJpKU%
zfoqRTp5nA<VktLl*_<*F?HNe638dp_T^|MYJR<~~;Q~MwW2sqNE~Kdp*)+IG6&#cP
zI_2_n##H7dv5cwSacn$?7V+kCbW6vs40(#38Q6YD0f#x~LRL#r^o{Edfa{Ytw6aUz
zH5ZT?ruhh^PMX4#*<zGSQ=Nb1;E01vKLpGw*xk#W6A&v-r9$1N*u*%13&RtnL=keS
zYhd(5`s$?kr@AH=_XsLP*XF5?^rXifxa%-HqK-dB4(|EBH!@P=_#a;7T^zHHD#rFA
zfWT7?c;t@rC5+j7kLB6Nz7I)<<DD~b0AOTX;<P1V+jY->GqVl}_LF=@B~S{MGD2*)
zmH+Xh^(p>yFn^5PDZ6^O|C38kWFwa+opl9bH`!<H$d|`x4`M!~o~ORO)w8O}_QMQn
zfPHR!DjV&2{R&kBfY$-Lf?4nk=EH0GZ!si8$BeqHOq0@rWd~*92Z~`*(^HS7F%g2c
z#QdyW7-ipsm_9wxYEkFr&NH83={fE@>CuKEN!?_}2E&i<!Z94_%6sL$((s7rN;%TK
zEN^N{jJK2eshF&Z#Pc_hTkPGjlp6gEdTC2(`m|3W&RZJp+{7p8@5Z&x_JfeC>h~@=
zF~f1-b+4Dp*AXf}gHono-!-WLpDph(PLVb~8C#C))la3;z*x9WR8yxL^bGM1CR~B4
zf>E~Epsa*tN4@+|V*`s2E3)H;+>3*!ZRYqz_oS6hq%zX$#?pftPTMBQR{yq5dhW1W
z>7&Py(aCcoxrwX==Vbo5GV75pb4JQzt&oJ2c+u%MMVO(hV*aBNVL8uXER6qaU&g|N
z^pxlaQ-bfm{*yj;=<9p?=70Kw$FtaWJt^13iY<uwbZ+0%>8Go5PS^f{{hOXm^-Omn
zQ0(eoWMaT}7(CB2SjoP7qi5L@srM02r0@SR&0x5W2j6%(PKzVtJ7XAs<3A)woVj}N
zNrS|*nS0~OYj)mlH?hw$N-r~i)w`{~&io;L&gBHwPyIvw4?leaC?!@ia2Jka%#{|+
zf@Uy!(E`^er~3^wO}Ecg_t8_4wcxyLNbzYGT@BS!9VMg*k9sidP)dC`FM&QLBl7P5
z<gAs;FkM<DGp#AzZ%P?hg%p0u+-}KP{-^E4>IBoTbToUZ>L<6x=`mN%_G7>;w1LYU
z=5<~DEdFO{VA$tmn+%6<qRr67kfKg+w1Q2+&C9#j_P$$i*gdTI>>fO(a9>J*Q^l_i
zaSVD_)q-*w9u@3Ty>Q$XlKnd~o|s9uVVArUgnLc-hpA27z0s;bz05MbS{dG@d`{}~
z>2tLYyX<~%-abdW;W77VqJI9#)Vp*Wr}J-cL1E<0sl1D0%RapS9b;iz(G-*20R4IJ
z?R|)W*@MEhFPYIF#Vr;BmB9wlQ0qjO*qyJL;4k8CQ>luCid$c^2+NM@tLep!QEk-o
zA*)oqC(J9|6H`U2IfJX$KCI@htmf^k=EJ_xM7|X$e*5!@L$_V^JrdH>aj#zeTgg?L
z1vTT<LOmtA>CG1GIQ7;s+USpV_9$S!wA8;;G5kH8JmU7mJmE_kG4t>3z_eApdy~c0
z=~<uD*Y2C-?#$!?`fg#3cViGxgTy7Ey{QvuJK8^H+tf}XJ}(s`G-iAscXlVNisPl>
z1_aLTar=KAT>L66>2%I2NA;4t@4X(`7M>YqG!oB4F4d{blsN$zUZSHI55Mb;45D~s
zVg!r9ieO}Domm1H6i+x5Z38`iCF6|2al^-t9kA;ki?b^2*GSPBbbXk?SZ(64Q>XI{
zW-M~Jb4ND-E#@N#(=8y)>QeoP9h;1{3^?TVBqEgj<J(n&Ve<fK7^3c#hkCZ&*-pC4
z`Y&wiwVC?)czG=?vHkxER_W_-;PnHO%4vZJ1n$BvHK2X+TB6t5%CF4m;+xCve}!T2
zHyr5FU>;Pa>?=cWOs4Br#~>C8w3A%KJH1elfC*#hR>2iwAv(A7nIs&$3*Z0wOW+cm
z=PvG-52ZD3<(U|d;T|bqqc)XRu=zR?1tps5XP;`KqxRWn<@Ejfv=`hmt^rUj4RXwI
z<`bPw#bdAU(mg5&<koF=H_uOL#7UcAF2ms$sm|B#uf7PmNnu5k(>%49sbU@0X9u5b
zj=+M>C}sZMcoOw6;|}_5rt<e5hm@G<dXmg+rfg7d+e+yZMVl9UnNDW#IQ){s9{epQ
zyK>O&s%yU$^Us~Sh0qDh^c?Yg+KlRKay9D$w;}Nj4{~0?fQc~t-MW`k%X;>=w@+Uf
z5PHNlj@o>J$Uvc-Z)3gyv<$wxxwCiJ(`h%{1Y{}EmDj^~G$YGX4>GTKI(uH&QkfcJ
z9cjYbt>4%@b%Ot~pl^(0hwl@i=~DF51XgoA++r6Gv=66Z+tD=BQ0y&t(#JG7C4a-_
zJHi&7vGc9Xk8=IObu6P1MNQfD?nKtc6YWT)cFF{Z>wncLbP=ZhRFLYcE`8vv(>FE?
zMXJkGUb2mS)a+k@zfk`Mk<@k(G?C3!Mj)w)4g7-Rr4BqUvE)@NWM;D<#Zwc#G3u9n
zQ*TTXU3cA+I78BR<e7#+xc6wsz}SsC8+}SlH<t#hriS{)?2dTh;G04)%XcC_tMaGX
zknw(RtCS8}jvqX>K4?9C@Feu0?b5;1%!BrlgJ-n|9ZwHBhptr5fRERa6Mudh^OZgx
z4Ye@1uTS4skIu0f3nNEE1BYX`j1K$H9d@0TW$8^`6|bY6pJ~4vk63l-9puoW|H6qS
z-3B;=RU6)fp1L{glS+i*yW;EhjWP)TKJsNx)h2(#tuTwkL(cr>^RMX{*H<{X`|0)_
z4sSoZ3iP|(v9~w%&-q35rLrCtlc^9&{mMsKy>~Qw>CP#5rZWM8rjg@IOmXeibc|+t
zMwUK-)3Gk}mZyX$Oy&2ZYT?Q(8+bNLaH7vWCjnHgykRJYfHkX1JzAi<5WXS%sRBx_
zjf73~;5CWkvFodwa>F#V^>wwdtsvG7YgHXb(<3jO8(V$u!6okH0e$9Hyf+6BiuXQP
z0I7%TRMy|oIlmxZ`0HM=>PepSah#{tOdG79#{O9QqdL_TFcc1DMOuj_pre=EM4M?O
z@bOTYOLgeW3kO1~4F1ah-L3Mcc?OL?WCjh!j+3C{h=+lL6aTJQ?`RD_C4)yF<g~ng
zahdJY-i^R97d7vCep{%zArSViH1yrW^9OoAXJM!8K#btC#N-(8wud-T!mTO#=*Mp;
zV;2YX?))>_y`SBqK8sG$CMe7}tr*RJ)8OOZb1XbvCagO3{iX={L;qK@cudLx@N4nb
zuU|}4B4{Gv!^NFHt~4(w%&f%g+(251Vu)}80>f7Q+fMbn(2}j)PPz6q?CRlTA6zeH
zGEcLI^82I_c;SPW=PkIlgE3QW5uInS)-IQi+>;-`zPHpyU0`L?7@91mUht%ebgN~~
zclxHASn)uhC2(J8a#Wa2{PD?4Opt!d4Lv_0c_Eh**LBY&1$aHq*A5>sP`VSpVub`=
zu<Ch*1s9Y>$yef8U^;8F)jIycM$t0q3be@)__ZNwMw3@re0w5H3~C>oaFuP*bMEu1
za(#7KQn<~)K+8K_523Gu7gnFoypMf-;wb?rUJ_);x{9?<n_fSQ@>cIox_Pp6S^iRp
z$x^wuP*TK)ziLn3dq*^Q6$wqQ`KDI9_aX^K{h2f6zia6qpD5)%M5>%~kygx6)D8gr
zG5A-w_NK%iw)AX;+}uM>V{8vo7zaDCSJ*djpGPvxt-wcf+U){6swMvnyKc(|lqkEO
z9Y5Rqp0k%?o&V<G!pF4Tdzk2E)&yGpm9aJ}okK3^n3tGTZ_kLbtn=lO=(ma=lM<>m
zJwJ?E^75}Di$;56gq(1v6UimPx)+x&cvgh})1C59t>U?u0S%xcL+(og{NaV=u;Wa#
zN|<=~T)6v#!P|Edkdcw!T-8CIJz>B&v}wSYIrcw|$hqY0Ly&XZTNXz2yZv#1{p8N4
zn72NcJU=X5eErEM{HozvKt5UYJKGOQK>4UW?=<d63cZQn8vx~-KR*!UlVbZ}en1#h
z^Rxmgn;woC15Zo$am@!m4}P2jjV9e5i+J&m@rh#n+53PXMpQJCmX|^LgsBu@;T<tN
zDWB^6*M(mh7v<|QWAx4M)ZpR2g-Z9EI9b=y$zP28_PZyp4gKrWW=lpwxpr!|qCtF#
zyXFyVX0SWbP@Xt~1=Ir5%YVIzqG*ibbgSzXZfQ!_NJeo7V*11<npn|96z|2lKIyHd
zOp`+tf{f`$2{co!jL`x&>iQK{oVg`p(1Ly70gP)iHKeppdUQ-yGrB<aLOTVGP8?9X
zo}S}oY$IAw4%faL#9NX`5&5E@sWRcBcCnpJe^rjxR1D7@vQa4(#ZL?aT2v#32X#0>
z!=^IJA_sNWpkJj!LqA;9QYQoON2__(A`|lci6e4Cn?in*&4s@616x6&K+0@6GDOG%
z#p2DGrgz6N7ipiBe7)@Tt_O)Qqpd+MUU#OOU9)|z!9@o)`7Um>$aimBqYmjbuhNz>
zYnOBb6HRu_*);JU{vZH&2D?bDy>aGdAP_6=WK~gcNA8)W3GwBL$nYDtMyELRU&PvG
z9d7dEdxol8#&WEU&htz@qv#5T3u(XEl>N^bu9^ICw37Z?Q1~XnCRzFIk8iHrPvch4
z`-;B_EUrRuj#rrX){PaF1r;REW~%U3!1o((RKV&9mYle2KoCSs#d1+Dv4=YVun>XY
zsTLE8;R-?o-k=!|EBq5{Gv9Y9!~V&Z6;8VrMudoW?S|rHVz|7n#pnL)>i2wS=ix<U
zzDMRGtxl^a(F~Rr>(_SK4Iv{F&qJ1qLa^*Oo)*}p-9D-6I$p(2*KuMjzu5atAAOzx
zShU|LlDTRnTZ=OeN^pOq`@7O$gXHv(nkEYKmp0+Pp1Z7Bd2_)g_?L_XQMXR6s6~C)
znG4JvB47Nd`?HOEtqbCv1VwyulWfVH_o9!M8$Me<4~!yDU#bfbS-}h|pH-d>7C0ph
z0y1$45<ol>BK9$T4J}%4py@z1?Ef($x!=rpX%;NZScQdf#c~87DrNTC&*NNs&Q+in
zV}`NtU?z^+cUD*S{6BSy#g<*buv0rseAP4&1*0@vZw2iVG;W2#dOHGnm}is8MpyT&
z!wubY0;a-_-`01&Tc!_8uFD;>RB5|&)Yt2K8R{E_o1i*Cs)Vyx;y{}1sk!vR$M3E4
z<<yq*@kL^jH(`p;i3_R3#r%7ToStR3^1mjuASPYdj6!41Y6r;yl7D*Bdgk##n5bK9
z{7Y`{Bu}k=7#$&V=ag=Ou8j*^mIX4XDhUgD$AvB_r6=}Den94>Bwj+lx)V!zoygVY
zw^#Icn;k0?!(n)^n49jb=4-AtVUNKVIO~Mf576_0C2atk5OBUg(=xZC<*~)X>6$B}
zp%0UjaMOuRxa?%YQ<W;22Rd;7+RPHKz>XQQ%~+hF^r;wNES?+6Ja)RQlkZuBsPM^`
zXrX@_g(o*O0qcPumj*U6YKPIyUDR6Dzm5NSO{@#fT~zYai1FEU2;@QB986VO$h>O2
zT+0Tc8!-4cspL;wAG+J|OOE-$6I(@$Vc0P4>giPC*{-h+x_Qs^-BOJgO7m^%aZysl
zbav$6C1<!MT|YDTm0+d+mA=8(xK~;tVDWzpdu86JAnGV;CiaBQ@k3D5HMf80yw~iq
ze>wQgu3j$n<^TQeuL1kohDi30e?yXY&(n_6w1Lq$juOpjo|Pr9?`54GvZLa~_HS^q
z2ZZ0anJcR=OsYS?<_AoFj{j`X_C>oetx@P>m!G`2{{Bd;&6a6+=--8~*eVF!Ms8~5
z2w&_#KK@{hDe|J#3g`jV7`$H6$BWVjUBUT(lb7Ci3kOgug<9S5-yqEVNHfFc`~RxZ
z#>{ndGcW1dy9Qdom)(YwTE=`|2=4!W#1C}vj<OkSWPS&kw0A=8P)*^N?*(j}G~QAE
zZKl8TNA1)DM``rW_Ey_f2kA@BlHb|c=O#dOAZk+CnAarotcm-~w#(<mC%nG5Kib5M
zzdBKLx(oE=&IeO{FQBVu)89dF$}4W%3)r^Mo9%h^1F~8m;2URws_NA$cL_~#y!t*5
z*Cl-#(;FUNY7``jPcAbb_Bg@#0Fj}nU<AL%^>wP#1y-0D-H!bdvuU!WAjWyRY$J%_
zKOwOTT6O8~=I0j@0hgCkOh2dfsF#c1MM>1mj~<pu?3|M9MoA5pOT9r!e<+v!4<)lw
zF7p#5yHhTEghIk9ki2M=NCiq{K%^Zf?e`LIY|ZsKyLr+oCc0nVslSnmSCHseC{DjF
zwP5!Qq~7TCi((<OF`(+%r(1<qX{eBkvlOEToSl1l+Qz1RHrHls;k>+!)foDi1oYTQ
zfb}7ol$bMy&!m`9ut^oV(<J;@-;7S*jxaR7pVYq&9he<aGvtn=K^teSlzgF$l*(h_
zi+0iYg17*Ey=#i*3!keh)m7w#o6Yr!=8{6pG%0<E@0>l5NYdI~)Y`7pQ-fzlvyH{&
zv`44oJ_Ojt*=tl-TFJ|6v^c6;EonH7y>X}_*#sT4!fW-)N&5%l>Ux}}*yYi~j=N;Z
zG0uzJRW}mZY+z=`V;7H4SSiNh9b$tVNr6swc!!onJ#&g-(vtOEd)zk2mj-r_k#q3i
z(~zoiq2(wFQQnraiRzeZMw7KXNfwGWa#DS|(H7d1VENlQUUAE(GpYl*E8DS4mI+H(
zZ+XjrAXfnem+&gfUU__5<(Vkx87urb(&9NM=oy(x*DZN0XRuKEqUdD53Ac4Wlqk_;
z0VI+|y5yW3xJi+6Kw(-7c1&xRnQaHPSSo#M?9L5PS9XdNN$w6I#eq0lpnUI2xFOo%
zZlHmc!|{=oi2bSv0rm@43s#Y6=i(qMc&&m!Xk61u%#nP6ipx`*G;IuYWG<NO4$^}%
zjE8ZWGHhdY)i?rfc9*O<2M&WW(2Od{^%28Wa}1oUmuNw*3I!TNuXHP&gJ<K~6g2l2
zju}?@yjk{u5y*2&R{Kgsm8CO^L0;QmSE3PC&=9gn$hpW`e+j}xMSgi+3)WoyoDR3{
zPYX=flFKBgy~<ZiJN^L55Op8YMGOtDlQlL%fJg_RALHP$a6yC9=x50AWQctYKEjYY
zf4}DZJ|-e$!9ai+MoYk)51^b^35^?-*SAwX=^7T{-S6m&5wNwvu4f7BP&L3L(_IT4
z{Z$vUYIhMihr>RZDv(4K=sg|c&<pZqSwsw+zf|Cc-`6`}f~&cFszjZ}QGM`EZJvaR
zf5_6={fct#@UyN2ON3lHnqcW&=dYro^`Y92x1m^NykQ-34`W;4{Mwk-6PTBy>l=o%
zsR2wp0I|%!K7F2LiaG$j(J;#>do91aAtEF!_UCHUQiG99|M3q&kId_feDTg2^^QM-
z3V*6-nTHkagw)CuD6HF-ASwe7EtH&VgDdctj>7DQ-<VSR^h@tQi?tBGZOQKpe&3jG
zdbUsWkO}2){hr;F*EJELxv=2x8d`Q$m97<@<`fhMSE)*h=((y|43?`7hf=nbYWA0V
zBr2;tz9UehCb#=UHZYBm>_%}}F(PbPTMe=1oLRGVa!wUO&|a<CKBv;&lYVlqI@X8k
z)@V@yCl$Y6c({0DWHoXJ^U@Cb#xNo#K(1+~>doD7IV~k8z4`%x@z;laGuR-~64|uX
z`f4m&nT+DdE~L|eHeO~a6*;Rblwn7GH5Hq2=_q1UMd9pD1YMxfdqjc#b8x>RhGe`>
zHeCDc5njG?zQ(Y+-)a5bK4N+aGE>Sk)5rr5MobyKEi#t;SX<2vo*AMuP<7Iz%R;u1
z`CUfL!c3$GTiB;a0Rd-0C@j0~VgG6r*rDQ~y>s8&8o8H0)kaLdy%qS@JP~5M6WMI|
z<I#eKRcnwlr)sn}e)vC)A1W7?wi<gyH26S6q(q<ErrgL#^F9eSpw#Nu<Qvl^c7AU8
zg#XCv!^*(fZ1euU!THgX`m}wgUz5CQpJ0uLM@r>u_s8%-zIto@KY#sRt0m0@1ANCU
z!C2D%ug^j1+q^DjGX0BHWE`XCp&DsICS9m8A7|`@T_400TI?P|^!&gvQoVY!d>8v6
z7%_GZ>pXjU)3Kd(F0SwT`$06rM+GYn3-%*hK15yTJ;r@3jPKWi(+VM9K=Yvv^B0)C
z;3>YYrlab=igXF2xlAbsJ~~ZmsYiAgl(11N9M~*!iSkwlJ)4IYyNDMrNeAES2X6IC
zC^bt~t_yJdvf=(N`LWqb%SDomm-(c*on0re*N~4@msM(}@V202wa`i}=wn)P$6MrB
zUD(zw@+Vugd~s4^Jyl|r5`M93Hfd5slBN(u9Rapw$vkGg%D=)cdul1!Lsdgttc7||
zaEqsgYLb&U38@Q8Q@v)+TinfQ>W#zyu0dpknuQ4FWk`Fwjv)Ri9L|rd>t~^UDP7U*
zv99%FUFrp#dz#kR&|iT}UBBPD5v!I>X@HYb6z~}P3#!TIh|RP%X=PrtCgRj?Lv9N7
zqt5=;%{0fUk#t)v66t*^k(!~{Ow&U!Zg-1oo`he5bTZ^s@laz*nmyP|RfeK@c)?bP
zj5vZANK!N~{RZ59nu!oy63+U?ealFYN&v)nl@v8cLKw#3hFe?5x2+gG@8ti}ZI3FB
zi@S<HukyrJiOTCs?~BH;hHMr}toi>KNarU+yF0v>1@a8zw1oQQ+pC0<aV#@Te%($}
z>XFNEn!J85_V(!Mcerzn4*HC(>=m+(ey=?7i5wx_s<6+5{`-6>*o~dfU3<v=Al{AL
z%+LOhRUyvE*;-reqQg1`3+=-mng_kBlb3=Z2{^Gxrg`o<1ZJ_K?L1_-o9p_B_O=z|
zdyTW)-3E}~c9#p%93-1cLFT~&C=C9O8T8rNZ5##U+eNaO>}L&8!r2`ns&=gA7EPTY
zV<P=3yL}OU6ztqUh#5t9E<L3%f%Cb1#S*y~{>EgzuMTdG+l_N+rM&L$`zyh&I7X80
z8bL8gfns1aZm^7TpVnlW&?-q!h-+`moFx#VrO0|hkfbxC?l%3MOXNzk{_LL+T@Q-f
z97#*a;uynR-mIU+AfAg@K+8jP6Ukb0;0vM@5&DzkQWlC*mX}g5;al6S&W@VWEzGUo
znpSaGt=gN=c5ul(hR)Ve5l=ZbD?|#J5Z}7kxHoN51RG;N=hH$pk)d(^O=QzC^L7?c
z2Mwb6LH1$?bM^66?t5ChPR8<2aI<Z!VUj$&FP=%(CQ`BT2s<Vu`Xoi<?Cb5@kvLkP
zDI*TQPHG*uxbREod(d$^p}hioXa$q3at^AqVgbhWUu5>7l4C4&dQEo8+uggRA^9}E
zz5A2l_hj)hac$pkE1f>ZX_o)zq*=6@P}XLowWhm>OX*v0tejEuTU~68jv3|JjV;`$
z{eAO9Tz~vAB1jzBc|(*^S3=f2G&dx2;8)`_*#XI23zJreMrrS{=)RZUX~&H%HP?F$
zvFy1Ol)8h<_^M8;WKf$dGYc=z21NBe6U9rZ_32JsG-)JzJM?Q~cr8<tIO6TE>O*iA
z+c-FRPQtQMfbD!=Rgkv<sWns2#yVb~>@>%QJZpErfcP$1prxFieT76<u!=I-)YTxq
zV&w3#-kIIDR@?KqF7xo;*41W|Xltna+(3i{MR{%@j@0AEIIxXwy(Qa)6MNnh0Y%LX
zWDj*BLjK%5$){)BiuVJ@b0u?p9$_Amb=?)mG|U$g&nf8qb=j>77P1(&NxLuG?-&gM
zg!&%#<HU^9HEnue7os2jvN*Fk<R;aAMm`aL*yA*8m4D^;Vk3{<A;d_nQxln!aWN53
z95jh;zbT17{)-7gPCANT>+7z>e@s1bz<omP3{)O#jf5*o4)>r4=K98YIhi=6F%tH0
zH&@aGANSXSkiszz_D%jrZ^JF@l9ji6vFV35n6`y-HvO{D0YMy12f`njW)6_zob5^l
z{|#ZFKW}y6p<v&$S8=14)!Ijd-FrmrL3>(p6YpN(HlB6JLUmg5^z=#XT^80ix@>p5
zKbDx7LFvoC?&+$75Q^^Yh;n68te6!ykb`_mb&ckyD7x_C+yrnLLI&4^Y;P#J)VM#p
z9&BH7%zv=ZKrpB#nT?MXPGvI#f|*+n%n9Gm0T*;|KcRFtyROs$gov#uvbZ-8)DFV5
zon(pu8V5%{$^z@>nt=7AC$3_V=epCW41w$^7J*LXdI3Bb!SYSnau)qCYG|76KF8Xv
zmtfyf)Ww1tXGf1~NIi=#?BmZ06AZ<_fw@_MC5D6an=Iwa@|5^b`q<m}4;7!dm2m#k
z)0nTkw83xf$KW6YXzcf$7YSt$p&k*xFCw3MufUKCZ|`B}zJsUiY(k&t0lg#Ov8}iF
zihsR_Fn+VE`tx647ONWLkDU9>po>^;i;YwLdq<wOaK0urSHkVo1dc2k11`aax^O7Y
zt@q#2raGEa-60G?($V}TL2smC#J9|YYy?TLamN8+ugLKMQGa|xNyk2rr!)y>(rf9I
zZmv05t;jPfh6aoodzK&Hq(Q_EE34cO*!s4XbL$~(p`_)_eyu4*4b)KbG)hap!j#xy
zU*5Gd9f2~8N`j%Z#z5J()8D-Oip{8UhUc}l;%rJ%fA+|=iT|zFM4R(ChUKK}JgceF
zIee*PVm$sbw1HZ&mwER~!20C7lQ^DJ?#1o60vgUqp(>A^V{M5O;PrYS{b|y9g=YL9
zF~b-y;2m|>7<`$p+$3}Ft0=k+c_HU_1_xc=pFxllS^EIe0@TNBAc9+1Te(~T{*GVw
z4n@G^7u42aC0A=+j!a|67<`>=U{?xvdB7lO`6-$gHT)U?Kg*If12bvh{6MMn`pH!1
z^PVhyFG1}6DSPi4jR~=lYEeTf2Am)F#xYhn;)!zx{h0U~xg*5t{Pc2(f8H}a`IK3u
z@)Qp)`gI^`<fcJ+`1ih$gm#>&Y}6K>P*fohFmx+LZKgq010j&3_W0UEuDaxP8+g|(
zvHSO@DXT3x<y~7Y7t7BQCk*cdGC0XiO(`ZdKQ7HwXqLM$-h|%mXd=J#Y5FuMUf%Nr
z_UUT@;+e8^gz!H0Uh?e@Wr?p~ed~A853|13MC+fzTubOJoZf!ta?<AySTIRcnnER}
z-~I5dnayBk4Ew_;wVmVnT+ktoAZhflRgq{K1DeZDUcG!uG&PQCn@|7t1f^f@SM%kc
zY$1OO*-%exVc~A7c|l#!)?trTp4G6M1u7~bQwfD{D*yR8!NhgA5K{XkBsBeT$@7o?
z3dDy-w%YK3+(gup7^rIq%V5g|_AA9`Ia0Xdazmad8d*As-;L5wLlaqaGqoQzLBFLA
z1q<XxpTl<(*|k=KQ05){7GtCwy}Ef$HCKqtdbNQ1SPyR+wGXFJ2saw$i4Q`4Hl^bp
zQYiC?I|MxPdJW>Zey`xViUoeok7uZQj2x`9C_Y{~Si=1^fm=CmW|A<-O0FRH#$cEL
zt?YgNC8;RtqAW<<1{dzEjKt-5!@l8IM*-!7Ri>bW{Ape{tY$$`>ym=z-tBoJ{>1vr
zDp(&4?%f4bEFH7VHo0kc>f!YwG)Fmp0RjK=<a+Uw)@AjWoAy3Gua`XEUOtv4?%>aR
zqjW%LMYG_hL$Jn;o3G<mw9CaE!<=rEy}wo<xe9c9Xr-4T@guo~<`#v~zi;U!SL=>@
zy|S{gII-lFsXY1^Vd1$bQ3L0V!p>uo^eV;5;pj+`;GJ{kO7zIvFQYk=-ri_(p|c0q
z;ogb6c*LGW4N^tLuYn2yDY8;K&TIaNKTouGC4-@(1Q%TuC=?M;P^f-sXQbkC^J<I0
zpjf}~uwT|?M87wQFw~jc^72!u0`NbDfH{RjaG==Ady)y}!PlKvtE%c96jt3s%TC$1
z=m0^}nWbPqPP%iTl%#O&`R+JADPey}zvelIVJ`>C5$Nr?LwBFI^{1YL1?~^Y4Ri6A
zU&8@&5=YJ%=H~-NQsIRuM+B&?F+Z1)5Q=|rZV)>=HU`+7dfXdCa8KuSnKS;AaQa7M
znCUCIdX=h%iqGF8-VvN^R;eK_(;T`-J>zdiR_ynN(O-^G@auF1kvGn8<5B3lYB9lT
zEtJyf8-h*`?-rtzctWpKeV_O`DAe{@R}Pq)<BlM%%YJK;iKe(s_5IY-%g)UcYTV4f
zyd5n+fEzZgbIF?%7kv&_s5{G*&6J$rjDPI>02OMH<F}Jk(h~{=9tl<OXs2s;59vpo
zpU5s#4T_VM6xT36>`_%8%?_J*a$bb|%oWt>j*cm^@j2f*`?{mON7qD-zk80ulY7y1
zd-$aJ`<$s6gs%99Xgdl<Szzy99}eDQ2^@mDnL8z=u<qQj8|d4#v%07{p1Rzg!y(m4
zFlrK0$`f<{6W8yZ?&}4x6l*ja%Z8QU<Y2{3XPrfu6a5`&-z<Z;38H5%z4g~?WsiaK
z-N8<}d>3wsq;{~@_es|jKn$b03fi&Pm7GVx>S=q%!Jjd^jP>P~aN*fOi$_UhaW%V(
z7r#4lvzt9oQSQCX|IACCd0wt#_Rf9VA2SuEs+2)^S`5##SK+}W<D3^I=Gge|uT8g~
zRsd-Clt45N)AJ(tk9@EimJcLP)fQWO`wrK?^?4us=u_Ma0-M-YfBOA6;e>DuSz?Zz
zN0;Vb)%s1{*KL2nfQjY~uS-8OmIj-{9G~lykE4fae_T<4J~9s2?R|8HkZ{4+%8j2}
zZ%LFGgDemNbv-g&(+<L1k(@;Jw3_RrXI|lLU+${fdn&!Q?E3f5%5sRo8v~i`*^T3<
zsPZaBGw;W#w=d}hdBi2ylSC-QWeM^RLPF~6P~xv8J<oF&AHDq+|L}~|n)&gAoEad?
z!3>-p=AN%HF_)oY)6aY&l^Pz|o09O{LQwt8%)u9s>~4CO%SQU~!|8DWdf&0Tn~lYN
zvPaX2FHhdxDtdajta<P9>kD^(-}!s^6(^fCo_}|{`b7}`jB}<A-4o?agh<ndaq-#|
zo=926wNr1CO50gd+FY-25?|)K&Hw%~E>SidFRWU6F4p?thEy79I(k#RKG($AWv;7B
zV)aK5!B788$(eKYfiCX7W)A)CVH5P9t>VvW=Wq#bJ4$V3{(E^`=kS5RowIm(*?7Rv
z;U`+KDN>=^0qr+0>-)2$$@<En|9=4s!oy^Qcc1LsYA|w4R-R_8GIrFZDv*alv>~~5
z%43HKsfHk4fXK@%D`%ysnZDpX<FpPB^F;(nWDB))^(6%747GJuQ~{~YneiMh#9iHx
zB}Kyx#s={bV$OK<3^K70H{(Y>YbdW6asd@EFB>vYT1xW|LL&;R;j4>rj4|0ZGj10R
zjv`toH9&TTs9U(AH(V{a>cq*75_^b~Oak#6-sis?DVBs1k@rXOmWvdYi%t0-X4mt4
z!79!nWq*QDA3$$Kdijb#2sTZW7Kn8j3l}LDZ3jtIu%q;v1x+=DtTj<;{DSPw`~kR4
zArc}SB#2nxm(v6kU9u;~Iv<YkPgXag1GrZD;TPn9bJx^JLlFy>T*aIL0_L1`<wSw#
zQfBhFEKyUjfgwJ)B3hOfE<h6JqQ;jkiQYzC5r~$0wdo^(ka{wNW;I#x$eSb3l24l@
zFE#f7NZ#UkiIFseDStlsUdJPpa0CSQS{b#vq2>V+fz`bP&z&177bAg;<b%W*0n&Np
zqJ#6WbX(cIW{o4w<99)7=vee`oH=LZ`JDneezd}c0EL)nd1kr%$9Z`Oz#A9j3ML|=
zNQFOR-unfkn$mdDU=<nHzd>Y9Sx!`|+0~ge?xYItm33)ea6vIBi(X-dOhY#Hc(+7z
zrF}E~FBlV3DU5}yGSlLBGiCa#1Y5DF4=w6nw1Ckq*@s)c69OpW5EuV~5_1l<b9G`2
zKyvG)iBSCCfRQqzP!y#nqz;6Q2;@C*Ab|aZ7phH<aL&bK=`Ky+S`TL1wY$|8DYRJv
ze}|ne4;8tn*EBDyuZ_Bf!wOV5t>oM9fHbu;|3wOFp82iIkJe+C<0Ya^b^>KLj$w;<
z<Pa5a1Okv?KqpoXIO!;m4Gu(*{0_?nsu=2b)lg;CW@d`wLJL5xODUFwEWM%E_D;4#
z5S48y#Y_tp=;d6fwp|iLtv>dftUdvmJ0aK`aG0ipA&C`euP&eru|1locY1zUv`vqC
zhm~1!zu*>t!ho=5H@KtB&&Q=H<SI*HhV-`P6g6~Eg*}SQGZR>|3hd7yl-0JZUF$Iy
z9bkV!wgShw(BH>d__+`?f&lZ}CP{TO*g{F1a$x@K0Dd8JTMM=2SROvo5PFGdTqw^n
z*_0VArB{1p=N$Bo7Hw6*8tek{ycDG1f<2qOgCJUhnT9z;@h231&Yp`0f3@54=cBgT
z@S{<py*!Z_tE;2dlSB-J_+ofY%3BNQUXX=ZaLv`~T;P-5K}8eDyo_FF-B8(me$*PJ
zVpU$&SQw@DM;7};Lr)kr0>fZ*oq8O^JaADoOJm5Klbr$}zv3Ucs4=LB^0h$*mUCA5
zdCO=4#hIZ~)orUd?dxl@#wbK9PMZAk6!Rv5Yp2CBH1P6=YM=iUyq1F<6e?^-Tf-+6
zWb@+Bd|I`DgGIdF5AGMp=qrWx_DFtaL&1kE!XSHM3)&C{&jKovu^>I1ZW`laoGK3(
zqhgLwGW~G&lzJ(>+KUXd?*)h`B0>84ykcXz<!N_IIZ{C1V1TBFNfb%uzi=P%b@A()
z-C!U#{JnJxyGz)Bx)?YZAo8^Se>C0uKhuBsKk(OVc3{}%G;-LSaz39@X=4sKgpgy*
zG3OAX$ZX7<&q68ZR1!t$Y|ez750U0jsnlCiQP_8%@Avz;-S!9Ur|bE8UeD{gKk%1Z
zs`+Y6dHtuQn|+eXz==(3XFKqy9-hEtL_qs3Y9#I4_@{I8=cL;ZSAsxtjWdbnsYX?g
z)Xg0o22H(fMTS|OXd@;XRqY?}k#_?ppm`2IMb02lksDR->A_*Ie}}oOg%@Qju($Q)
zqCu+ST4CH5BZF%&5nUjJL6oql{B@#O$Fjm0C|vYnw2})xf{Gg=+ACkYaKt4z3@?JI
zwmy0>=H%lT+dnZ52C>c;W8EIdp8XT+V-WYBGynP{`pZ)}i&bdc@UxXpv<#8=QRl_|
zAiM+<8|Q+*^yebY07G|)a|y3p@wv35bb|{(uYVSAUcPic#V%MDxgOji#i#$Wu<YZY
z_|`dv{DQNMG5Ac@tq0qe227L2yAxd0oQ~@R_hjOKgTjJM4S!Y(R;lRsoR3OG)V4vR
z{A5HTOi;gB3Y@sFGkSO-!w&HsX{oX+-NTqLo?Dtew+@!Gly%~%M67vyDtlSi1z`f*
zM=1^HltGsz<8E05Q;qhC{1X%pEES0Zg$K{kqp&pYpG^ZY(w&(?7@gqeEaF!gXjYCw
zSiaBY452Sw;{1>lA1bQTgjZ%&y7P`)%Z_wgM-0VqnDjN_ASL?@Q~IM%(U!W>k<>-X
zD(VX8ki-WRJnXPIQ8br{jY$!aAmSM;)Qt`7#Il-8$M@4pEvHE@@@x3kc=2zm>CRdr
zK`Dif5qOCNDV$qjKX$k-^pS}&eoGX+)_JTVo+pKi@@LrSiwyn>h!bS!AZ%jNOt292
z)${+>v!z?0j8tkPi)B9$y@CI|!W#zsI+P-YPfZ{mee#R}aL&IJ@rISXQI(u>sESDS
zvTv;{7a`3|MTmM>lDsTTPyjX?$vY~NbRrhjPGAsDzGZT%`bkZ-&cukTu#AEWwSuWW
zSQb<L+Wdx882%B{hEQGNk)HftyJA^c{Ug?`89ZMp6}fg;>QYcJkKTzB7c`|*fHtPr
z9sRWj>T_XABd(<E?>bcm{J=|q<1S*MK~e+tJQG#?NT#4F6_-7yzk-W5>bdcga?Fd^
z$kihq;(urlBvtystEEOGA+YX_FR$a>9FLPXok`+=d;PD7VN_SV{@rFugIK66{?ibq
zvqoUW4Am)vX=a@d!Fy43j{Gf1zB_YnL-}ji?W=5;9`WDHW$i}m`CutszafC7xP{;M
zH#K@OLLM~zh^gTpkQLgX98)D$ZS={MHHHY99K~#Ys%yE!mu03cPdjk`&y#QUL8ILs
zNU5L;ckT850UrIJ5goCD68|K91|O`jpnwoQm?FnvMZU%i*8MS(KK-=q$akK<=s>e9
zKA9il#{a6eR;6`Q+9c*Vb+;;}S9+0bwNDhkB!iqu!42_Tpp5ebDOfvLUu|+XXsKu`
z@R+AA3wHu~FUd=cArUH`KfXplLVq%(7QQ7bok>I?@tiPjRE$1w#vaFD@$g4V*WrOj
z1dER#3^GNcvoElYdd_@Vz%`w6xVe;_Nq)ciP5K6NDdejD&Qp~H#g{JO%BL`EYup!B
zOpA)pMzYPaSWO_a`tS-_k4sT1|Gp^o+@(2u?H<Td0)zipJ-Sp~-IQG_K?U`r4739-
z9dP$`Z*;tqVHm37KQggKefo7Q`o6Ft6>qdyrN<0BWIn{>`Aw<~&yQPHI1L9FU*!G~
z6eoypwlYh#K|bAmM&aFJa0~jAW5aK87+p}eiW>eUfYxTB|FWD(^7IXIDN5#-+(iSf
zs?fW<1)?veXxKfQ<I^RPfb)xKv8ENz<1^1fTLWIqgzwKp9iNR&noW2yo3uZha(s@N
z%@IZatVh_Fi^YcgS9sfIj$OGgH*`Pz#(ka@GamDNuNTz`7rMn;QWowp1zlG%M5)l5
zFBU~t48;_U0K!=`m(=ew1_wSaj=qT}_->B8o0VV20z_W;!-CU|@Jx!7f+=c^aE2}8
zBF{vtPPoc2(Qs#ZXjziO{*uzm*Kiwb1q#5eNRQ6Dx0x1^(~NoS<=s10Y>nkcGkkv%
zgYHorEIm57$bwHf?-UCtt2^kR6x5wgRHo0N)D&Mi89lS7@HWEoi)CyZAAW^$Tm*Do
z+2^|5m09UK=-*6ni`QZUtJpQ*=*lv0&CyQ>-MMKzxAQ<zpM3O+WRU6sm)0El0}m6@
z!Kc{7L#{`^cpR5z|3N$a^pQlG9p0)c(7p5dTjia2F7<;H)aV_(Ti?YGK6DVfc%CmS
zWcr9IL`fT6LV;OI3*<9z@sZz_X25QWN(!8>{>!P=_XEL3A331xPFy_SkQWVJTKkAp
zGnB^-bg~qlSHSz|hghF%VeFsImo$$uHNh5IZ^F<A=7F&v<H|EXqPsqFD;viUEnlw9
zlU5G@2BCKDA@#K*i(ywf1N%~M&X(u^$C~&K6q*9%;xWr#i7NSKS2n=pLsc~Roj6IB
zG(MAd43MF`N(TQti2wk~waXkb;v^PV(~}{j;{KeWRoj;%arDw2T)S?dK+d}2ScZ1}
zP>HI?(?mAnq2Dn8RJ{NCF%Lz^gUuCRE2dL(3Sj)+m)+hZbCO0f<+%x=-bbs%?yWsL
z@<07fw{A31(QL%Hc5`tZnW=y8ZF|_l(<EMl=EWyrMTqR3QSWE>(dFM43QH}!Od$dw
zlth#V;3w#}?=d@m?bS_&66SVSIExVB(m1h?G-_KPud}{p%;&=M6!<JN@$a0i4B!Jg
zC^*T>!q?oT*R6eD*e3V5@4k(l`t_gGjrT$zh|V3}YYskU_8zZtk3akUZSk46(4$Nn
z6SX0k-<gWL-nT~6SN3&ooZ+p|Era`774=#9CimemQAjb16wh9MoY8XBupV0P^fmp{
zspIV26Clf#vuPq;3?I691a|xgXiRWa?*~a}R21!u89(tOd*_Yu-9|GHvwz6R*%PPu
z%&dV;H=zXvIw#s0*c}$^G|qnl%F7KSK^UpKJxrhC)2B`bl$^<g@R=P5UGN~0I!*FO
z>@h!H@9^N?ZxTSRt9F{{^8Q07*2p9)vxaP)aeYOe$w?W(R+%wv7k;atYPwX2q(pA~
z$^brq6E2BmkTHY!;Ih&MH?iF_l4ikjz7|+Uu2snGh8vk7RtQOjVlt|pC$#CosMXhM
zyLWej?>+rK6ng(9^>?62^Mk*kt$k8iVGr=jcfuZy8uNy?O`Nh0Z=dnX3V-xA;x#+`
z@zNFEh>n$9>xd^GZ)8P0{W9?ZDhZFZDiDc|c@h!q(cxer{OkMc`zLcO!EXqlCcjJ(
zr@>ZRV{{HUvwXkn15|C*QqkV<^0DlwKJ2dv8MD3^qpHfykmqOAjyve)Ny^>79wpz0
zjOG?A9o88OcOL%yM$WxW6kV)(x82IHx{a7B@rG2q`o`-1QKwtXwjfI&YeSHtP^pdW
z)UbxdhLS=^Q^Pa9*N%pfo+7vPRM8;1y)ciR-Xm)!&$I=pAztL-(%WbrA-Vf$g6N!s
zP3P1|P|LlGR*4op+&4fyDHm4??XICDMqP_W37-K>!C^F-iUNx5Rr@(G;a|2h+UMUS
zZ)?LV{(BKT)^#}&u-g)V9$a!_bTFmUYr^sLSeczJX$P9PH6-;r?QjdSh@ZGk;HOj#
z_SU+QXo?yW*W7qHL&D9`b_e$prDM_tp9nZ-=j|%4CIHr@|DkWSl45d%vnJo1xYr1F
zhMeC6O9^l+_1^?|(uW{vmvw0i47CPW(}-!lP{nOK-Of;@g_w~=LR|%)@SduJ`@<cN
zbf5}uF(T9Ils$kZ&BHP9P-k>XYHD<sNtWSZnRwLDVl=#mxL+eo-sBU_9Tzm<rXX_^
zeE|%*Ar7a`Xv<>YxqRS6&(?IOjg?~U#{%ccV5#F`=^`>+JP39HO%hXMA!`Ef$*5=e
z{`aFs^2l2DHJcu6P3C~|HWnST2jT=oLUE4%bw`!8O~WZ91)Pu4oBuThSuJLx`T1EJ
zb%#$NhU_z=i|bVDmFzNxobE)IG=<fxcq3lB4n>!?HPx$~&v@<mCE8`_VYUd1kgn5Z
z<|>V+%1VF`{#_|@9I_ox@U`(*{%LjJ_hieJvdYlh^H=AGgw&ewe73Dj5lWV&aUavH
zZI0`D`O1`bOF>&U<AZ|Q#9K>NtAKQZ{|%S<^yBq0FKzD0RSC@V6ORnqp1a2rgZ^wo
ziuNf;oWiTk;NW=bv}v;9KzccnBGSb1V3Gc8QPG6l@0!}V$xR<+rTIQv-qLL<li8MK
z%QggsxffKN(X5`lG$1-OUXvU%7O}bxkpKwkE!>?V!AyD=o%xvTDX(urlrkSJ$V<Mo
zA${nDrMP$sw2<t4_fW_!H;X`wr<<Ox=@W+gxuHov#9b@|&$yyKL1z@h)P(s6$F_w5
zr4}0Q?7NR<13v`Ldahv)#>{O{cU_f6#;kRnN^F*gM7s4qJ&39=J%vI~-NiP`cqXFV
zn~8e2&E!zT99xADpL8meg=%H=kT|SjvbKfHY0hO}^l_DYCsm}?vL^!ElHoqa<Y8FS
z^)t0zWvrDp<uJIb6ipcJ<P{@jHnPc0xL+dWH0j>s5wi2~qT-*I?DZeqgWpP>SQ<6S
zf|D8cN6d-&P<Mac3xE5ycQ0uNB-UdqIOyJ-WfpmSx)l^Dd?QY4-VkYu{kqxDnGRU?
zA=}m+_JE!On`Z?~O-uh!d`CKMHIad=)f6f(Gid(VU2*4&vtfOejncD0uaGnSMrPUi
z?8Aq||8sgdv}LQ4J&|sM4e+-+;_f@WGIe9Eo5uyW>Qp~g;kx+^3t~YNL7FoSwu+V*
zEi0fy0<f`(m)Z@Ymw`21Yu8rAmDHrn`mE4~&*@4Se2=qgRAq0a@WaCip|_y>OBYXS
zKd1kWsLg0n0|+(xDCjnu_x4tUFKJDzHs_?-lW{>yN}TlE*m}x-0qe;@cWWap%w~b$
zDbOn`($*L|Wnuvd-t!YvAAW6%K?CYds|vMgVP=I|`QJXrQo2aCc@F7^!en~-2pLMv
z=T+8zlzf|?PTg*w%CC#W+6dOP-#MS^BNT#dn$#eMt1kXT63>D&S~I*<IS^=4{I1d@
zAK~KVLxAxuQB|O&&-nWIC<Cc4-H<<^o*k{kNm!JL>OkD=X5}S8z(+qPsYGCoFFmp%
zrODV;H!N-Z=c)8|Vd->;W_~%6>e_{-=EK#XzI-%i1w~;#Za)Nu6P{sO8)>fBDw2(Y
zv1xT$fla=O?5x!wNN4v2-no<C%uzSh!aj?jTTfhpWu@%R8l5<G>9NmB*GSyuh@;Im
z3&$P(O3%HHYXAIc(Chlgn49P|tte$BB+>3tV#-p}ZhC1-VRmAC`T6)IZ*=w#0b{$=
z^D{vgCWEx+Tx>{pb|bMjR0?6WBvU>1045IpCCKEe-12wf^CXDmd(yL|@yBQHE<O~_
z&i9qA8xP&k3!*{)<ad+wp_+<yob~dKgms=F33c4*^n|9jeSLI&6RgMRM+x&;YK^7W
z_dl0FR>m@YkKlUHF2Q8r&{1u5V|RsXlj5d_ZmAb1Ki0c^IV_`mk@MQObtOtrv^Hqt
zBc^dWl1X3-d~tzziX2ihlLSyuM*VrEPlxt@p9c&DD9)ETEdgOI*Lyg0slA<$R+R8K
ztXdc+@h9;8uPccL(ef54y7=f$vq;&x=%%a5a~MaNb%9EvVEGRL8Ub#im@3FkuI7yB
zcP4_)`6Qs=T)HS^Lrh;jGzbMPo8bYE^LYEfD`v?EG+&EDng<{R5=43fp$9C1uLKPb
zi?lPY=vjN0*%HYGXmU`L+p$u=h(BS5aUMt0Ll3Gi9obQ_tM)&bQKHD6J6t4ik}7iL
zV!~-ce6oL_5tpG?Ly(jV`Ujw4#)57~3jY8y|8ApN$F)Yrl%mY-{^1;iQ=EzQc9<wO
z+=VC*4)@C|70IIqWs77yH%#cC&I&SPjA2xf+5&W1hM*Rz0xOi@gwQr4TR1`n8t8Ay
zFuMz}=>^#boBYWPSh*?cKOHn_EJ++9^im)7uZr)LBf6?V?42drlYq)*N}kYX94<(I
zz;u(Sca%sAkDtuzc2)cM>yqk#NTUVXn+)@BIiVkPS(pip(S-NRN+cS%KI(*qjfLS0
zc+Cr3mWcV`%T$Fw`QC9DKBfF<QOyuXOi840P-&r7xk0%BX0!^q7%99?&e9$%I#DF5
zDu!{<LVd_Tbv(FORS=d!D8RMyJhJ!v8(Zw4RN{ED#5uUcC8Nacc8SLzyX5TWlIPly
z31^IyE#xD{;EYa<DDp}77VcaeBElZcu`h$%&>>=ou+OEDyCo|t$}N$6V>k~s_4sk3
zCe%+pw^g>^7d}Jg<Lk!&>jF6@C@t;i7e!?lP<i2Jf#N4um%5ZTu&!N9t%tJcJ_6+s
zM!0oH#UDs82Nfx!d0p`E%aOtarKk)ibnC9bL$_;{yK2of+^jho!3Uuss8dGJVQ(rr
zbMdl)yk2eif119R+cAX%RCGS{w*zMZ199{Sezv^wpylk#dA0IrWE@PR>5uMiWT=w~
zZ%({w-I&Zw{^|SWm{hWmJ6V`Lc0(fNCcEn9bK;E;2q43rjfxZYFNxA;qoS&!;ICRP
zGs#$@0(VXoZ$BCNl)#%yK&Ml9`y-L#7s_8y;X^IQWy~s-$DwS3oY9Jaf(S5e=GnGs
zBive}CXUxMs+!wE`Dli%l6h*(3X^^s)ZmeIV(3?qE*$K#N+0bbhjsz@s;6b{1gi=M
z+*GXQeq9v|8smL47A8DxH%dl(ysh_sT5vQ(EgkRs4+THg=$#INjS%=)4F2n2@oF6Y
zGr)U)OdJI8+_z|G((;kwRGb=74w|{lx;{d!2_HvvX(IidazotJPj^;7EkP(bNxpOt
zN|1qd?TC1gCBCAf{PX30j1d|>ATRb}<7e4$wHiJ$MR)VI>eQxy+Z~aTTTZ3!>cN^a
zt7OjQjn@4|*&E<#)kLlnP(M*H$qyn4V}kc7MwAtSSV8nA#jt{&VR}`-TM*6o+<1^*
z6UIz>8KO>m%R5+ybkRZ-0PwR##>aj5{>))Y33^GJLVBV=K_oZnH1Fot9W=;ko1wcq
zrRvHf3N>h4H&Ty3jFL5%nO&3DfC`Mg6}d4c_<C76mVl}z!;bp|qnQC-B2Wn0&U(6W
zXshu&nqKmyg~jQUQ22C1`8LQxvlPBpl)~3lnzsf;GO9GcKE}C3!Jnal24MjIRS-mg
zxwJ-kfirW<R6Fk66`BszvSzCnIX5+NCA--3gChB{uSHbEfpLQH8v-f<2Rn}ELoe52
zsE0iWs9ZnpWlfZ<yQ<n(kxzHpSE3X4J|*j-k@o?paT*C!MT)6*Y9l~g#;*U{eB^;r
z_z58B1b$+n`*@K+?Iz67t-k*>gd-7$03mOxpaDR0s88ga{Zsqh$BPd*0lxN4%L2PN
zbAKUVP17tI4f`vn`D4@jla}vBC-xxnP%TA4M1=lkSEZrlx$K$R5H!6aO1Jf^nw?hg
zBvfD0?^GY*ZuK&BE>auR!WS~8bf$$kSj`uu8H^N1zljoD8iU=<7f5zjEhp4x!7GB7
zk#R1~bI;TW`fPL<3Q-aHB$#|Z=m&Q^8Rm^T5^fJ$5<>^u!^Y)1#hRFhhMAHZOlf2n
zUbRcsrb|Ao>u`3LQd5`8aF^OfmodpQ7zb;)=60@MV?y8Wtq|sgzwPCnF3pdJTFHD<
zok8AJ$Z<cR&o~4x5>sLS&@SxZk8WM5TNtN3v}^|E%wBi>4+UDjd$+PsRLf~WA0Gc_
z7)T&mR|dT!s(#tk?bgFQ-GJ`M#Va13;^r~@+iS@tKQcQ27<ml-f{Y8s!wNafHCgBt
z3X#iF-{|cbmkHEmU|{X4{s^zH0sS@0$}#m~_Q9s?PN#d?{c2jqsv^mO$c|%)nB#Gd
z#@E?{wFQT&N(96XJ7GW}n>ZUqQK9k&hxSgQIo>70AKu%-*F{c!fah@A5BpdMq%aL4
zmhrOYb#QF-qjSCIN*p^ZBYjR5e)=_ZZ;$)8Fc17K`QMlV+K0Q_Xh;pOnz}47nT1+l
z3E+%;f0BKT(Cxm3?txeR{<`+Jo3xfXhlh&x?>8mwDh^%SP6zJ~ydUO-6d_&4VbnwD
zFtSiSnMYVyV5YM=L`%plN=R1s%53BdD{jE%7q*LnSR-lOwxBVC23x6x&uj+21Pp4b
zNf>?`+xYYHDFIUY(LR}gVqwu>eD8lSK+mY!1ph|nGIovE5WvA)e(>ANsCoiyAwomC
z+r6O&zTqJSaiZhXKORr-bxh7yL*FSz09F1b@<)lnyfKmRuaUxc|6Q?MIOIfp`LBwX
zFwVQ%B7T~6<X_8++Xi*q2|;gFCk+{g@Vi+xUj{<kv+|Q>s+Xe&Qb`Az7ibh%tT1oa
z3LN4v7rZ=5|Dn9~oUeq)o0o#B_$`pMcID3X@TQIFnSPPqmNQsl=id5I$yxFF$FGc2
zpwaYc7?axt?G^%>u&h>EyA}-#l`ylH`a?Ek$9ZbR+sg+l7bfO2M51p6=f7FZdKoUx
zY`Of@AnfJisE5x5mSnj@utOmZZ!gHc*=LFZR1{@PpriYZW+FQ5n2NU~Th!pum{Cl6
z==0IFk>1bKGm<1ht;YgMfY6J@@u87JS*9<0H@$j%Bu<Z+{)>#w6`ceRsARtrk<}TI
z6<aE}$C?*XJ^MNhv%>dy8TtY&AT*5GB1->Gk-q5szLEAmB~5449_C^XEkeEb8(Hu!
zV=-3xY@0Df!ed0bt=;JK+uwa^#^Q;l5!FiQ2ADw2oJ=hs%W!%ba(&sZKz0)ZgrgqW
zxxaMHo*S1?G1`w>`j+2(?vr}>iaWn*l_Xjm3pf)RV)X>B-4S7qO_)_GpqUC0E6P#Y
zhfS8DLo9}fLW0|sp=XuK32=ti^5-M+tQ-6n13rDaxcCXQ$%&O=!&~l&tbI76>6#x)
zfL(ghz4%-sW^}aU%9j`4zrNz%V5)C)pW5h+*yzvQ7;N5nJ-RXSeZ%R<%Eg|qq4=w$
zqv)tHczz3ac*4ndIfHM!&|3BS*P-b9sMEOE?|A3svuny(349l6Lv_boM^(^vs{%Fp
z<&WPjux^YPfhzcoV?U^%T?!sJL4YPDbbr-5q67bKJ~hWjC<S$i%}Tp(ytEg=BDHXL
z1vi0Mh@lqb5N_)=%k>~~%1I7BXn`84`W)l{&1F><<i`f#E<Bd($DT*;HuS?00Ot!_
z`m<S7p}>^=%}IXIE6^$zTve#Uq@gz&YGv0w|Nfb&-kXbT3;9bmYj@Vvm*H*Zp^V6M
z17+-yiqwYDg(aPt1t+(tPun0?EgPtln7X}E58W6GXn$sT=GmsYgTw6)fw+s@BlgHA
zDGim_?75r~9W^iT;jiKU#ZrKvgO<7;Ic^)GK(wYmaa)0>Ym09meGPZ}J2UirSY8=@
z?9BHoniBtoOQWkRoq;MuJ6_^(q3kZelOs*Kjycqi^41+m@fR=c6y8Jh@5tPk#Lb><
zx`}3f5?I9<M=B42Hen%fKEtq0L`sc^-4MAWG|=KhBC~tOWoG=%n#=dy*9V+B!dox~
zA0i7C0tiZ{LA<s=faYXe-JjWgO!3wB0Ra?H$A;jr0HJ_t1`*L^*bfl_q_m7&<7PE8
z1F09WHaEU%k&idam2;a|J6Wvc-0VL;@!@qLCo%G$MgGT;NFc_XXY+g!v64jQmv^69
zA1~%?+D{?~il?cz8J7PZBZGPxNiESaPfMz&?i=yO<up#KIJE^&HwP@td|N2&YVx@j
zdhhJZ<hhpp2Loz^qnsR{8)+VMo67|=2a<=b$F;O4jpF#_%35m!a&l_j_l#WezGKy9
zc?xGM{OzrE?)!5`zPYJY6=?gWA<0R}@m|QF`CajtP{+JZgTkCIN1NPkwU=m|TUtEQ
z&n*AFUmK)pYv+37=J`*j@);G{Aszd)1~xrgyj>9F`ud{UUdfm1M~7w`mkyYJi=O@W
z>HYgx)(=kq?9Xgn!&wSGfd4yB?6&;;S%Dg8L^8NlmoX+ic;kz5$6|*S>dCFlg?u8$
zTDSG+FWlg#8z?YE_9h_i@E=KhVZy&QxdBXioL*7RuMwcm13b)O?0qpFQN~y@#jnL|
zog7c}!&oW16<RetrkYq;^S3r_S!;F+U9i!<=JDXE_N3DVTm6L?9YdvCi5E^8eQo<W
z`r%j+XQlt&_D?&)J(9Y;39sI^JxS0x#=-nh?6!lYY)Q;%E0y-`(>6NOF^;E>{@Ql5
zpPu01({}gIx9)fp*@Jcz@B<ejPAb>ru#G0F!erH0RkAH5bp*Mxo7kaPmm&^$QlM?(
z{M(LXBrY!la9B7g?5xtqnKsA+8t!S!4@iUj@wasz!8dm6-OBiP4@+;8Y6EV@o4fZk
zOMnUIgt-vD-6G{zBwzx?os9bH67Azx-%HHyU#vB)V+IQ4G`r2-^e#O6d&S7*b7L8!
zxy4>KWXslC#X{F8(5}#bVW*)ydTK|W6!i3zuIoX<xjORR{JK9i+Gn>R@rx!RH#Vr|
zQ^l!E2MG;TygaLA*NVpn1b+uv!T7Tu#uXJyr0<%Qk)M0X)i^}=^l=8ic~~F9vUYqi
z7BcgPDZXQ#2$?+kU{v9$%<@mt>`U?CC*LK_VRK3oSz=0seq8f1NZS=Ya-d`1XGo|~
zh1+at;aEKEeqf7w<JN2NK;i`|knyR%*U)!W?D<TvY3SQY&)%B}T~@gg$x8?tZWN3?
zr{=Vpp!THH{#_$>k#}hKCV^a<(B^s&d`@na3rnve8imjlZl8>%D+ITESpS#Y^=kiS
zP`p60tW0C|?ee!@MJJ1s<<19H8#gSNc@OUUdCX%bybq$(iqSG6w9amwQlE60b(2Hw
zgaL&RB1{D*BNn40LELV5Wxh6m5)X!`7i(pE^_XD95hV5I6h1$SZz{-M^cjyf!*yx}
zb&tV)X&}G*JvSiIK(=Hf?8>@?F>-<}a1vT%oHv5N0n?9=)QTODah=w36$K`nZ>w;}
zI<n;$og6*}RjB!WH6T5xFIVUSGA}VjGCreZe`BZamn0XhFQvx@PDGuX@>j@5m0Zof
zs9lVZ)!4=j=rw5<SwRR<Z7o*B6(8JFy*%7t)kze%iu=5(ZMf;*-k2-q`DOclfsCsD
zr#P)jb4XR*!H$UN-g2IDqIR)b?V#e|k38?}`vC@bv-jeIbqY|2fn3VC;d7^awaxF+
zHG&x*w_0WMNks}%ssrK157Lv!>$$68m|53;J`3^(;dmlV$X5&qV5Kp_7lw}V?}+6K
zfi*x3n3pTN|43Yre>{jmhyDC>(#OUEi%jT?8FI)bH_1vbDKgX=9`gJ6bBQjGiSb?V
zH?&v;N6K4U82h3reyk5-pqB0v1H^p#!D=<SGKe_Dd>Y^>8^tZwXO=gf6}6!&Cy-%!
z>NOD+w*k6|tQ-}x*y2v!SQVGaxa~-sd74K6N8XS-=ORktDV_JHfp*eDUPc~2Pw`QB
zRh3U)2|yMH-&YuAn7#(8k;$AhW7m>H-L&KaYks)lf3RcgL}O+<RpB+uS?i!${|Jj)
zDvCTHVy~oglJ!9<iLX<~{VIRMSt91Z^|tTbiMf6ee+ixHe)v(J<5U7wVb0JGxO4FZ
zJAa*YR`)YPf1UE2iux_~@!tS0D7rRr!oNe}$43ioq98He`6;`+M1sFHBXY;l53vse
zvb7|Q>U@k|u*UtHFRB#?`9(y*yJIpr0a|;qSP(o2_$WqU-#*=Z;OTPAs_$NM3yqh1
zSKSQELb$}$(I0hMAN$ggm6Y1ehgelnJ769OgT!}2lp=|vDOWGL`%3?^?K|;toC!R)
zPL_7C#Of1yeTKD?qc?dj-o_gikbKXM|6}At4d)wB<#Ni(A`1SkUUS*j2JV-glnt8T
z1@^|JTNLZg^B=)*tWg&VK+)W5weNMH;Yr)D07Mpyw6{`v0F()BEem*RvPtJdWK~_n
z3Wu)6+{YDZMjhV6=fv)rVn;S%@{7oGM{bqkUe$RMn+OFlJAO@&+hSV8ExZ!T<lOii
zk6Ms#j&!<zQt>awEjB15Pj^-}s%kJPXD{T_btPc_SGtfk^L?~yDT8e(<F0TaKVBkI
z?ynFOcuB}tv8-<T$+xb8)qbA{|3Kp=_B=hf3VUu(#sAQa%=lSgor{V%%eHhU{-s<E
z-=hhA2}rluq<l*bdWKtk^x1gsDO#KLp^kez&7MfDbNeZ%QdTyaV>i*CM0zX>VW%^X
zoA5PVk`ws)0Mewkbe$NmBjutA(HL)k0qkjcbXE=~n$;LQitypgf2~J*fg>L#31rmF
z;ov``&kas}e<aM!q!rGZ3sR!wN=oB@o;WxJl)SIwpMHrD<@lmEdH<6>6TpxNd|*#)
z!_RfRXe)+eUQSox=hh5=pUnPRl*@QmA7J<EG~oea-OKZPJM&unAL37yHovnur6xu@
z!H;WGRe*whi{YP7^3tMxj5aeg9)epgQ0wST&}nJOXn(#*+kP<!zWYdY%oLESB`xhY
z_jC%?W$<RqYv1fri^cWb<S=8PlKnjWCvho9@jx0n(-q%_#e9Q9B|)whq@jwu<8?iy
z-#!ogC=w{dofD2EmtFp4QJdvG=E@V#*gkPxlHxT6(KqX48%-A!(gSc@c$dwl6NZN{
zW>8soopF=bOyqlwHs<7kt3`PEV*y<T&5YHUjH^+Jf0!7VYMPIzMQ1AGu*lnB6&%=#
z@er`A|EhQ>xhlQtA-$KXRDpU3-cE;jc9vGB-`bJ?sRECyLfF9};aCM#k2FmNLk)ZP
z@+!0f3o&64rGzR9T<Nh6hB;%*<V~iO90b=!)wKlc!sR)Zr$U%80e;K;p|R>QWClWY
zR#xD3#f#Xo+zTzY<A_-oYBeI@ZAmO>=R#Sc;v<dDEPoIEzdXRqe0o(i{Kb=Q$A2cC
zRV~RJShF+htuOe^>iwjx#x6X=eO+VdZ5n5$unZVTjn#T`!e5doN1}GzzPtd3_*KS}
z1$xm4YIS;KnKBig&iD0d)V~4;p$yZq+?Yl+I@yfGxr70v8HeLkfEHKA?=@`V6PD#y
zb`3U|?h6>uIQxJeZQ7(P-2rv4E$Aa&gk>AI%oz1DTml&5PTskBEx0^sj85pp=!KTY
zW7EA{`KV)5%(Hrq(1~&<Q6s?tl=N#1SOqVI&{2<5=IY;qRZK!EaC&-G88$)v7q`>n
zulMtd3%GY=KloBl=)9>_r@X|Y?ylQa|74&5*XF1roqMbyYx|+!kPaQkC9s#SB4K{j
zKTA_H)ix+qK^X(&_ggZ+D{K>9bvVQ_2qL7D;cY4y*P*FTrr94t=(T{4t}=|OX!H2Y
z`Y@|P9QbH_Um*o-!NEZZ5bYq-QXEb7Z~8f0dvzpuU<VdcR(>_?wKda1S@y90`pd*I
zx_x|xLnl4*^y|hL>sNKfHG9U<Tr}^UYflpq8T08EaNKwHto!|oFP1&{EJGtzrCCNJ
ztjD+uF58Tz78}A-LpE&2C2S{DZ6}Y}PTAN_d)m%~+0G`~&Sl%qU$=c*eAG}gKaIls
zT+H^kQWaGbBmX4tZH#TqJmVB9(>x!#dOIUlGwrVjuT2X*v~2W$WYDUYZ$Z2@JNf5$
zC`2)S)aTJ<lC2Bd58lD`DwY%aJa@8oJ*{Gl5gFh2Zd+(sjz<oU{F~3H&c6F2arhSk
z+JYD(G2qskbYcgWc4ulr6(Z{-Z&4OU08Oizf3dn#yt($KumkhKhfiQP|G?9>*{xM<
zTwurjDw)Kyg=rd^gW6{Eyk9KdSIu1Nv1b|zGXL36J+Hj>^VITy)cGlm_A-s+xlGhn
z`o)@R?@oFsoNi>);@SdMvV{1t=sxS#v=00G9b*RLg?!xk{0`-FDE=HQTC>+-vgc+Z
zNB3+zF*=5{462VL^KLzbCGw<w4ysY7p=Wl}5|xHrgHFa*(cUk<@pxi)^oc`ROZINt
zc%{=+JzINn!t>@e7Tv50ev3j2tfGH6g@y4<cznr}p>!m)Z~+~!0ZW)`JohVJfHP0!
zu-A6=OH(VONMm{oU0$Sp?}10!)ckO-bOve;ivb7_KRHHtKDb4d=Z}yo(81;BdbQ*&
z*9(tyT|>BbRcXBCBT7YX;5hZG*aWLbz+%MKt+r@4hL^QAJ=;XpZ3J^T&mUC?*m#Bp
zkmibo#*}3wFlcAAGC!S!hUQD0->J;_neNhwIa8Kl3{WDAdw_woCO^KWb%*alcKV-B
zue7?xrrBn>rb$#Qe(RueRt7_>97<egQt^%cya4)Nx^d@WVp*=GB9%gg(&NR(*?3I!
z3%lP=f~4@Qy~VjXUH<c~qNn#y$y6!Eug})R-*8?}H7C&ch?@GQH;l?M>;a%R!<vfI
zxKxGI+UHRnan{Fstb9gQm)N>Z(hZ8JVoHnvO2G}u%z$aTG)u^HO9(y~VpK>CyxR+m
zL7U)jTjQOM9hrS(IolRsJ5L4|nDlNuq1GC~8ssyte^x}}srqGzQ{9=rFM#Ro_o%o5
zPQBnGE@-`*KFW0E(VFi~vhjdJD<KqPTv^iGV{$yVraeQ$kY160qCN7>WyQtCHU)Pa
zRi&{!X{U_xH%-%?=8j!zmvCzFpAxTJ(DZS_1n?eDI6Kn=tt?OHW>+Gdjyhwup<$Ht
z3S7EI%ou>3*py=!!XM>UWW=K+6Q>vnowWC3b9Wi<^~F5cdOQNZyrvUpo-nf#H0h}E
z>%Jo}zs^(bK|S$}Z!QgMViA;ZdvK=WkZ&)YxXIIXys$b((1i0y&_V{Ak7)cqvy*H=
zC(|s)AeNe`A+fyQ*BBa|;G;WS8W}cc?P>b?)S(fz>9aoa-`~`vK9|4Zt9StK$o5rk
z_7&NK9e(7icE<O}IvBC!tI6-DCFQ5B?x$nyr+dmz&&y9g!p~r4MJ{4Qg#q>*x1Fk-
zHn)V5$nT0NV9Ur<jWOy8{nrNi#R>t8CcatM7N{0GbR?+&@q8dXjp(vB2T$vqxfy`?
z9s=>@ZZI(ydNj`PMe)4HLi~iprl;Ee95cuHXSGQ3%DAe<XnK^8wUcqFnp?2$e`^Gy
zW6KZmmf%$HRjR23X5*WUBQE_lh%z~!&RSkt9M01XN)6HTEX6%d=CHs6`d<1%lENN*
zd;=97T(jY?H%T|Gc=$YyuN0wD%UN7X9rdQ)15Y5vTL%~!jgJhjU6Zk#8SlA9E9*#v
z2Q;D>W|q*9O=v)8TCE4feE{z|x5|~7n%>Oq+8E>-|H>{p)n}9LXK6{NfRD*B2(tc{
zeit1pq$y*CE``IA71Qk-GisAYf|Sz3*)liSt%#W~3Z-sPP0957T>=$O`~EDWw3zE0
z@Pr&h|9w381aUHT9_n+ZFt9VrcntC+$zdA8i9pN}Ch_Rwm~oxljyv2DSa};t<8;9b
zEn1@w3hK9ci`>q2zB9`=e@x=Y>04)n9N~BWNU8w1y4!y9QBtgl#QSrOeQo*oc%S*v
zSvfJ^;bvRuQFARXf3I<(xSw}Ef8ix0Lk54HNR8Y<=Qz-=A=3YXKVMNl_gDyuReIk(
z=Xq?8y9oLqF=#NS^JY>!?2!{)0+jkwkygdkG#V(hM&Xv9lt_j{Ih6JLUoh)Ph>Vl1
zBQ5-q{r5l9&@=P!JB%>QQ+a;2KV#t7VC<2PE8hk8vEg6r&yy1Ez>XsxcQZc4@TyQ!
zm&FW1c6<wSvUBHXiDkJ8?Nm#t^hg}%w`q9%yqOk%#vn`u4wbJw6$aN$9;3^j9npn9
ziUNFRPDz>A(_h56QYjlh#r})-W7uCh&wakQ&k~GTw8+WlXKtPwk9m{i>Kb|~E2Rux
zU~IF{_YK&gUVEyUJC>H*kzVET!)!3ks|w6<$-mcT{I`l3ly#obHIdsR#$CzaWS-jt
zD>8<V4-@b^Ep!DTiOmsdQ-TQ&33*OVmz;m;M=+B=T&y;nPVUYM+A%rwq99rG{HV=l
z4kMjk1M$8$>!N1gA@(ez4N^&EnI>QAb=bU>xN|KD_uWW9s1Ys4`3F8IF;o;p&~al*
zLOzF(ZXzwa*}E90_y$0AU9<f3<7`D>+x_XM8Q~qnHUh<(hLA=+$O_L(gBdQP78-#;
ztBc9dwS+V*#-2-#3(AWNz8M#CKQ8oDT-ckq@b_^M|HYkW$3+TUjFP^nb*gZ9VC{P(
zt$CY){wR1M8DXlI5qB;l{_w>EGR-jP3#shX=e0kfJEihJFQ%L@YHXz4{_-a@{}j<S
z!|E%BAhuBLdagQqb*<X@@_YV!0L?G*b2%Ai!UHtV!{G|>{}kZQ83S#Et7kk#bMz5C
z31-*oeyCMCl(Vl2e>;xo4ag9CvGb{8&@}*l2FF-PxesvLk8VK%T%iH3e*-kJ?x%T2
z|E8VDg;-Kj8}u_4s6|dNLHDE&&&DS*-d}14F5ftpD}$9v9^=->(ahoWV>q}>Cd@kg
z;(uQd2KKx$<2qOEwc_$Vn#?biHvSny?LD}kQ#hD@|KLf2W$uPg*^}1JHdhFh)tW;|
zb>*<Q|3iDzy)CyIH6fl9*|7(@8TIieg7-3Sy0ZRyf8&5Ze{y4g^JLw0o_@d81>?)i
zgq_x4<Xb@eHC%G+X_OVHm^p9EyiLx4reB%v755#Wg-V@ZxYX^MqJNj>3y|LJjsRCy
zxH}@*!f_k3UltDMD3j~FJK)dUq^WbT^FgUsO1LU&VK&rD)Sy&NI9MAF7F&W=Hb5y=
zA~?!}6o9kec23o`1Na7oat?jYnJ9$!9d3-0?a!4uK}9NI{Cl%x?IKifV`{7baS!(x
zF$Wp53I&Ii;oBDuzqw(Y%*Cf1qv%i*a==}t`^DY((iDz}{G}n?m)x%_Qmuz79<C8b
z^X)x8|K$}Glu72z|L=Vr<1JVAh0j4%`kLVOJ{?7F0=hh@KAun2b<O+bS(wG5$J*-q
zyi5>qYIv6H*HfzDH`<h-^Jz5YH@D%{sP~O2XQsxq)&@O*WVTJf-l_)B*3A&*W5?WE
zP^E-}4(6$4Dug3fx&NzAfva>rOVM&WwW0d%mhA$~&-|0+q--2xE;R6_`jun5TOZ%t
zJhuHN_N99?e|6}Hg730S6ZApg5%tdJ+7(P_q$S$LvYPY4TbE`ljN+c<_x}Ki6ehVd
zP3L_wtFQW)=ZigZOUe&V#arZ=1>!S`g3D?$RUXW(SSB>J+o?g#wiZ0)kMz46yNvBD
zC|r}*w#O;$1|rQ{Auar9pT#t^I{%0q+Fb96t5@uG=Rb?Z1_4u&)|x3U^<{pAZh?XR
zO@H2qpu(5)PQ0>wggtvt4Ju~9Zu4U$gZUny-9bXMf;0R>TBz&b+eAAcfi2v3Iv_Bl
z&&PW*$#sR0=Sy0#zD#_3`_@frW|7eLo~d1i%i_<xGa|&|AYisbcl`JP_K8>o2)TQ@
zz(N5*xxvRBX?A5~-XE1)Ez|HJkQCPOu6Q{?w84Bx#^YZ5Z03{f(0HuBWvKl;CR@T8
zXz4#<i5GK-W_O-`9{_};p^HFu&Pa07$WFe{X9&SvdXeCSPb##^yyrr%R6Ohpzv&#=
z0KdrH`V8!+Si=<cyZ$2}l_7izYu4i6b1bf2m{RkQo4}Wc78a){xVVd~nYVDa@ZDqe
zZoM%Am(a(LO&Ip5mU)IOPL9n;UY9TN5DDG5XrN>pGw$ek_Lrp@TX)j^*tg-|c89@Y
zI>Mx%SVxjS(5YoFTj8z%x2QtOjhuKP)Hh^Y!%cvg>|dJfSANlVvZemas+?hWshDxF
zxwKb>AtRUPRL5G8<M*%Hs1HSX^4O#(xI*rp5BG$cekEEwrfuB8tT_E`q07_*sb?Ed
zN0K>^i{0woc=mJY*?+IV($6=$1-+mD=$F0ueCxH&`{zI3m`cCco^<qn@oU!a=8NA8
z7v8`4^PVRCa%Z*3`{nMZ+M6%`e!cq2$Rc>G`tZM>litaV46>i?!9R~l9slx9Kh-}h
z`XQ(&mS4>zIlV<1d}zHhuZb(b8R4|#UR@ABtl}mV+;>U+Pp1Htou5)i7}C6g&n6dd
zo*~&!8FJy%{cX%JSC_4Ywg2SB4``$sE&A*p=nIqwDe=ET^b!VG6)YS-kTEuL0_f>J
zY|?tUp`-db|3&WPwQgDp>h&z@aGDPzKv^i&Qh|(S$f(wcE>h^~13~7xcM5V~Tm;$3
z>TI8F84>L;lIr&&w8<2gpo4@Q-c*<gj1yx<WvDvt7m!Elx}|@NRR%B!kmhh%DK<I1
zet^>i)zwxV5rZG$0<0K&e#M|MlPmTJP0hc4DOj=e6Yg#U9xD@OvXBu%$1;QQ0j~iT
zdwmaOP?wx7Bj&eUO2pNbCUY`uKqxGLBb5eyq*bur?ARXRYR^q<f%4ZW&lBLSr6V7-
zE58h*lsswZWVuyqkyM7Jxr-2RY*0GFvggtb|NQ+OniL(^H7kWdQ+RZN%Fao`$0x|+
z!mH8%FG1UL@>YuCs`Tc-veD5m4g&4V$FBi1#s?w==0VY_;MP=-0JM5Pj9Ao}$p|`V
z)d#|IC84)JzvUulB&`>FfygjXf`4|>+F^c2B{%F|YaTgK_s;1T!xz2AU#E2VNPX4n
z)yT(Ce7zLBMj~@iKhF#W_Vn;%9u0LDl}$_B0gLK`R!QKN>|aQPNb|`Br+;5uswMaV
zz8^3$*>!>w^`W%ba?3ub0clsZa%#7Q&GN!+^JWazN&M?*dPd$BusUWg#!9u6>f?-B
zRjo>o?Wlx$JS+0kQUU(3(6dYUTLWt}-qHl?(22E*LJ(Pk9VBa!dY5<hcE7Yp9bD&Y
z#RJ)9i@@ee_1NQ_E=wIqcP<ifyNQWO-Rq8{;la+&TeJPIUzGG~<pnr1vtBVhFE;C4
zfpyJN`@&_<9;T&qS6N=Avq2{pouPgO4;x_N3qdU*!1Lt>+n^M9`aqU4w<DrXqD#SX
zI~|u{Z*?}Y|HzFn*?7-r?v9V$=yZ6x%V+dLil?mY6$#CpTPn8gdx5wyS4Th*T^h_U
zC#@hktWzPA)(`(7?Y5wCjxBk{*3k;tS~lr+tUIf~v?)z$<(}46_9bKq^a++%8?O32
zW$5zofc6cizKcO(H-W_rk>)JR>n_@yh^-dA*?d#k9&Kqxq|fp8FWS}r#G$4!HRy9r
zbA&p8bMG+0&@FT668iNSJ|w<4IIUN+Fsrq$d8|e%c3Qbr1W{l#eW$rpr<j@3Ugh`t
z?hU<rgKZ+S#kBJFCB6GDZ9E=5TxgZAdaYUE8-B7!=ZC!XA71;manAJU+ld?c?H6aO
zbApKc{_%_L5<bYoUs9uvpPc({B#F6jB70on&TlZ<CnvP?-@DE4zQEdMNL{|H(CMF<
zhnFOQP+e23n3NUzEt5SKczi@(-s|1C$%Dwg!do$ie4UrczvY#}KL>kHbWE1^egA9g
zAp5Ve1gCu!?bz0)NUq~C4^j{s;fl9Htj4XL5;A<Gr4X$w<7y>EE3z7Cb<pltwGQ-(
zVI)1jl8)>{T$7ShD(=2rIL9T!TCOO?H(;AndKBqCACr)W6#XfwO_e_*gXWL8lT9)n
zDu1g#cQRD&g8t>VpPO}`rN^&I***Ph+1mKfrxEQmPx6=0Dlx@Fv%8Q$;?F3D;hjWB
z#izO>7pM_G=Z?viUp@LXBjVlb{*yn`SD*cr+39w5K#2G%-3jjV9c%jMCxt41ePU5x
zP+hkMyJ%0BuL0jMWwTbW{p;LnM$9I22t}l|iUWOJdFG1TMs>5yHDkj6Ty0B|MVy~m
zH*Ai}VE6osfB*Ok*+8(`=eg|1SH@j~c9(vnNuZ<0xVq`B0?7j;9y7SC#fzGF2KJ;e
zLlh_`9@!Dqea8!UGDG&EuX}0M@w4s_ijD-o{+_8;&!kQ-SaO{^5VW)w+%wF_-vE((
zQ$k(?rHxmz+A|<LA+TF9sk{vf>jSKR1$K}G;p=MD>+vQ>#(U(}p)&~j%%GGg1bjNX
zKx7edkHs~c=uBF-4ON7gYNlJqP&rgknre6J-0-EnYq}kDn7n6P_VS+(k}<9pV!7{I
z_j=~FM%W7}J%3{}raG2;nLhvKS-TXftCQKiIVQoiTNLQTW1YUaL9yRVkJT0Hxq?W=
zea0IjqPR5Olc23{rf0Xg)%=UBv2?vPQys%>?%XuF?Oy#ga7#Qcv(8r-QTZfR3Slw|
zyR#6gM;{x%s#XY5eVMvKCe=&OHSX}Qf2jWBL=>M&2?4T0cO=neX2w0Vh~lDvpvv>_
zP)<nF%>Sn*iKaa;KoKl*n`pLXbF@ktJuvbi^`z)f32D9SgrVTSfW_|E#oj3C-{s!j
z4zOHZ+YDm$zh&8;%J<e`H;F=PZ5!`2>3OU&q0ntJtvV-TMN`q+O#G={DG4fDv&_wS
zjY(K{%FZ{-6;1(_@}-ZN$V9Jrxpo`tp00Jp>2LIUO?4SRmr4p}@T|xnzQ{b0lpNbl
z)!?dMHoUGWRcXOmL^dq0EBWsPA%Jzpx(!Kq4TRVAeX1+7F}Os444yz*pkr(ev%#)Z
zc>^a<(GKmpTdG<e<_n0ROPD<IG<5_^vt6?puJjgHs3S(7{JrmI)pT}>;(ZGEh*kHr
z9Kf3!-i(8MJS)R@NL_v>d&vV;%6rAp2)<^w=iNQl9W;%+{>wjU-&|ACye4d=Gv0TG
z!Qg(I<uhesJXKfU>&s}tg+T!a^ZCyBG<b6j;!5i25ST_EjyF?^9eL%WpSu6w)|B$I
z-A9H<a>ISf&*xBmH;8-7Cx9HKc5}(jdh4c)6FuC3E77one&mL?QAmd8O7<u&(95Vn
z@{9a<%O{Bn(q$<d->!E7Gk)hAq%8(~l0Vi*Mc8%pFuk@@Kv2TdVxlaC=&edU^8);p
z&m2ubA8$-Kq{|g5aRvaW?i`6S|Fsmh+e3(GWYep-$9z#;=iel!pPwR*8Xz<V`dnWN
z?UD(fxein3KQDq@Amyt6CGqK3L{cI7Mx!ujaDb;v_}`BOD~Bnk>;?y<hFobk+PcEB
z!ACow$M-NR5UYwcsQx+vz0D#FcQ-*g4RX13w_ti<7`BHwn6%Ta&qpd43n(0xH7S(#
zkuonWt3DzA`W@PAG0Hop5R&vIc<H(%N?!TK_gh8Lc5|DUWGomxFeqdeVg#5J<t`)^
z1RF8}HFBwXIo$g22`@;uE5%V7*_|Ba>zz8`T4n|SBO1r(+`WG5;f%cR3a8DHn*5Rt
zh_pO?o1r8rcm;gC-d9!TUF4Y?wb5@xaV83eCeohFv<{GrA(vbyC`vs$`3^{CE#<6#
zs@A9lI==hF=FDO+J?Tb|*b2V9<8Jr6<v7fjog-f#6oB-DOv2oVqsN?K)O<Vj;g9cB
z9<(zr^>phQ(m;Pr4L7mRwC$fm={+K0t!YGdc6CU9Sb4s2evTCK@tLp(?L@gw6SWu<
zX`JW4osFRfVI0ErbywK%(8lmY*vQ+BkwS5FU5Z4iq;*|NvL`Rjkcu*X^Jb;#jxbYH
z5&SCK%xGYY;7Js@<Uj9}6=GsH)z$6Z0-lx%ukK}DtHz9YGOq=u>Sl{I4t)5Tt)};v
zHXj#$wSD$Hi%Wt+l-=&4i=@2&(5=@=JY+MKpOiUm^alPd{Qc5N`b)JOH(AUNKc)8W
z=XLW}Qmx(^2^`t!Ugalo0t?m@zEj=}n#Zzyt5jF<nVS3E(z*XvSUlFp5f=4K`u>+l
z?DFhf=RT8y7wXnWg1?B{v89`O6K|&|+~eMiQ;$V6_qoAlt|>B4AWl1AJTg^htx7Kw
zRyyQnMsj-kohoVqIX;j&0>62Foc4=PK&}b)>r~ZwpYvO%L=R<i%au_t_R{oN-;eED
z-27k){rfI{(^^%CUSK11XxRKHi_0YnY(S!O_YLSBqqz<Q|7h!S-T2Q*aq`5T#@?w}
z=_c5#|3lJUzcu;4e*?eP8*FU!=rOtnQUbyl9m?qLkW@faP?1sF=uSaEI#du;KvX(Z
z6tF;fE2*fclnRLK%jdq2<N5=x-(Kf&#^c%l#b9UQiYtge5~D@sYP3WEYlRg8#?`?_
zI~*xWq|+W>M?c{bVa55IJA;=BH&9kL44O!YPCnxBc;d`}_?4FiO^KwVuz6vK$7@hM
zM)mai(?q|cD;Osr#ZCVp3Aa}v%f-L^@9n0xs-1C%f%PV9gKINpF_C|iV)882fSmMo
z5Ax#&m^0Q2P-MimM{fB-(d-z+7rLhQpfM?9GJGgwI_Z*Nj)-nj*g6Hk4_?}d66)j=
z+{iy;0_AT@RraBbULPu-vd&_TG5u7HgH>hRK$4k8qjt&NY(G4wRyI@ATr;DA(m|I}
zHR(=1$Ms}uGX2^tMd};e1?VSr!T+8@0PAS3*UnzUq#M0ZaoM4NF!BrP5Av(kP5kyH
z0I8_jsq)uR@B7di9H40@@wF$rD7x})u<PLzRy2k`q$J7=xLRI-3De+bC!>L`ppzU}
z-3Qy`{&Sj>$By5ADSA2id-s4*fAaU8q%aQ?77vGWT-}J?iXoxmTLth$o0df28vy@H
zt~j%usH29pkNJR14$JJI{NV*iKB=;nnpk6j_5YcgUI#<R9VFx0C>$I`TI)l`HSct3
zbeGH@1}|i{7S!8DhTL}5tvj7~kAjARz_^Y94%Vplfk2$Op~+;kNKDbi`eT~rxa-{&
z8oLk&!(pDNyPM$}+;JL?_xXT2LkTiiJb=19mFQK%d+7>DG#3=LmC84jC<3Jj?|j@j
z(2#`Q^Ax-J*Ze}Dkxjnag`i{D;m`}GvDmRo7lJc>2Nzrjx%NAx_Cjdu@6gT*oxfm0
z!=RkN6rrgB=d*O4lthtSLkcUPlh205nG34FtH}cb@WMkzZ3tZ#e+l#C*O+0QQi}g$
z4*r8Aryf(iSfht<m^TNO)4@;`>Zpr0dckpV?1`aAYpU3<cGJl3gS&9o>aTO<b{37*
z9UM74r5dJs$uZv6&L<<|oKfD$5`#6cP_Cf_)W{4@mckDaJU{|26sKZOAA)zX(jf0R
z=wHyV>MrE$_u7WhY`Jc_#;~E_${5@R!?>(XdtlD_%tRl@KV+Th{!`U&m%BT}*f`JL
z2HE=4JTdZSa_q>{n|xW>o!zC{t2Z(Q4D5sf+*@t8(VB%_`rjeVl~wTru%?F*N!{Do
z1+27_$V;G*!XX;ub3nKuO9DUi!*Nj2?zzz8338pG(>`RM4GtU_s<<To%pY9F_!V2(
zmtc)$hQXq<Q1L174+?k(v$XRssfH!N_zV9}Bre?n)GVCNSDN+NFzH4LWSk2|tA-$g
zpd!_{$HPOUYAVSg7C;)+2|k$%Ehfe0ny&C)DS@4}nUrix{cZ>eZiD?Gj`BK0aU}6S
zEt@IL3s%&l^L@Uh8n8eP_ld9E$29l0Xn~o|`+)~tcBE8$a?;8E#A7ZHq<?7brBpt^
zLBEeOE8uk|R<1gHB)o1&p=(g**=Xs}edTWQF(lMjwx)V<@aQ3Q={QCGJEXnzL$wXD
zAWH4)G9txLSW216WiUW?>cPY1%RpxH?<55Jh1`<^hz4~ioM-q!r&4wBpL-c*w<_3M
zwlaP3s$!p#HOE0{4mi-1D3dj!t<5Ps3?6B;Q-a1T2F&v54eL}VTBR7C8#a;{{ci9K
z;?kcbaVph4A<_Q7()Eh329n>Oha2HDN30O0t|JidU#UL`51%WZIFn;1p?ujNN6Ms|
zxI_Eh*AY|f|8#LDrm@0Ls~DG{WtaQM$nA;7R}y9V2T8fX<dMXCpNEZUhF0H3Su-i=
zk57vdOcY{9KJE^QmcG8UaK@ds;quQ&w9fErCw_MHIp>nM@oMs!+YEQCX~;ox`&q^(
z1^&@Eeb(CLE8&TH@`l@y+AocL^y9&gVq=Rl@pL)e!88v;B?3%?e0A|4^<hm*j-2Ui
z;WK|1u;T&9bZ5d~oT~910(sML@$w4jMhkT0lwuo<<;7?5qQK{h?c;C(`W2SJfngdj
zTz!Ql2{ZqrQd|hI=d3RCk=gD6vn`5f9|f{*hDqj0G(cvf5&0~N)#JDVEsGRf@5StK
z1zDFJ3whHO$9?)#rP9Q~_Mfxt006qTyZy&X79d(=#Igf9<EM%!CCaaU+564-A9g8O
zTS8w^^d!GQH?%C*x)XX8rBj1<yt|{KSED<Lyk|cY7GK%7zL+{L+gZF*3~hfF?r@vJ
zg3z|oPOlB>=)*d<%@m>me^xJewxKMb4fys>lzr-a$fv<p*ZUX#30?@FyIDW=*UV;d
zP~p$vv^>}@AYd3|+6(v6>+g<d)g2VutykGE^(zrW-^=ztHhTPG_1o&}J<1uD=yOe*
z?WwIq1|Oe0e*8SAJ!oqcgjEA>tTJ=8+@6b8en>A!z8)_sPa*#4yCEf!Kff(q_wo6)
z+(9;_KHSh;@m@$<4qBC+tA3uXpDh|pHoN=U?&*42!d3^x*!Rd3mFEQc_=^Ygof~b_
zEF_-3nbVZM&Y$pGPGLw=Jn6GcV2pwc?c$G63{C&eW$8L`h|iEru-duNMoln*HCE+I
z-(RYz()rsaA#NfuNj#dgpH!9l-pBny?^i%pZo+SrOeS%bCQ}vLk6b8m>ZdZ<UxJbF
zd(M%G5){@}-l;lAj}%y)p-*B{8SuLq1}Nxb2!gk(jh`IP<J%vyiTzD&!um_TJ9f|G
zz*?FnPrxkbzNJu3_XMuz5;5kpY}I86;HFe#7Y}O<TG(OQ=N$b(+n+T|u&gu%sD3?8
zJPBEFV6%zxEcx%kf3G{4)PHG>BHcQ!vLX@>2jJIJN2kH}+@}Xdhg0==xUysU%4M!6
z>|+So4E`-SQSDG+8Nibs5H4=BUoKNsH5FHKR~@_~Q+aX21fmJdn6t)+RmNHJex3W}
z{Mo5qn`1!<3j()Wf!TwvlRDg9-M(oSUgcjJDo0U(61`SMY>*FpOe{YWC2=p%!mTlH
zo&YA~oRe;ld6hHYZR)^(-&Ue7XE5%!_JN{cs_?JF0eC@UJ-8o}sU$CxHA}YhFT3E;
zcj4Ojo8K=ZG|b)TT8uSZkk~y)?x!j*w?HY{IR}MnkKWJx7W(zdF+oQ|O*m>eSH&_E
zl5Y*xuG^TqM}~5n3s2M%3kof3ImjGRC_s6m-{`_(ky{$ZxYXNIrhW<8&w2bgw<Vj-
zS1ROqMq$+lNz&Kxf08W?N5L7(%?V<MyQ@`Ihx?~>pC2Cl`pBwc9sWDJuOPAi5kR?+
zA)>fM)sUhTu30idAD6`GP?=>XX~^z{OBQ&w06#u!h`owS5$9P%TDVZSuj5kX92VJJ
zXDR%TaCFteMKq^uq52faN6O+P5b0t7njuN?%-8s82bJ<-IGGj>H9U{1(KBdCk%A32
z?n;+l+2<;HBH@l+gS^TG0UeT_=xnZuSPF4?AY5{9Or9@#RDCovYm1u`0dX;Gidc^`
z?eZ7db}=<bB1x{gWGl@BaI>8yY>QxkIJV4u&m=f`V3X*@XI@F_{hDz;<GtANIYWR<
z)a?#lW)e2JZQ(v9+kY2fn=Xx&$PT7bV!ep2E6WPWw<!K|yhd_l8|(SOEF3?RBtc)y
z^52;xW;Klv>U@}f!AAHoc?+rJi6`BzcJjFgNQlAANI~$q%zHeIP>@fdw`UETrdo!<
z^RiRUZcJnVO~9g@vn*nF86V+R`kN2(6ieJJ61M*+dv~R8934}Eil{CH11NhJf3LT}
z!)M=-a14sNDA!3l-ioapzqKS0_JQZd6(&_-<RRC_T50JM6O+YC)Ed?A1Onfk?5cx0
ze`6rUW}z#$Di&-6l)f;y+L22N$P%>Od*;KG;IwYGH}47v6#L0<Rp#ZGv|r|;xaNb@
zt~WHuSZ;AHN!DlM1*z`s8VS52!!uboC64WFyu0`*?QtqCFZ-H0)~n;4GvZy1N{4xt
z1RogHe`u^u5pOdfhlm3^--6Vhj-A!-e3eQ<o&qXs5g_?%ll#0~DC;5e?@gGq###Q_
zU-sKz!h?kMCCUR%-s5W&_p>|$?rd)3-J_rEBJMe~boqt^r&*DSDVe7u+6MIxd^45>
zQzf5198U!{a9?)L$%WrRa(>`>ty4dfjJz2dnc@CnUuwwY@&?=G!$gstPeu>Le1DoN
zI6!A-YK>l|QIq(%xZoiH84vGXlli41^r)PF;J5CuO`k2izhl|W!#y%ac%7a*njFT@
zHLMTr=QuhhM8;~v-|N*12t5qRku^gvz#aQkUx=y>s5XcJ*YiYT`)i|XHl7?SKDT^%
z%52P#_Zj7fDt5nL&TvuiEmd-EWuqgyUYXaaAkZUlH!;QRv{8^&XCLlT`0=I&T!rgB
z!?aYgI^NrNSvyqSYD=@d$a}Lb<EF>y*Qt`2EE-f?Eu2&DTiJ_Pd5R#PFGK&n$&+!b
zu1bObf-l0LfcPF11_wZZqAVZ+q=EGy0FnhjkizEe3uKL$F1*Khd(997Cjmba1Zl$=
z_+z2-;~lkQIRvA0VT(I;69uyNEgmSl^oCgQ_7P<iO(+cmp+T}>a=J;LZo(U3%ff1#
z>m~*Ao=>`(Up7*Uz&?REuhN>R->@l%JU^3afN3o9Ks9`%J>X@F=hJ&P-`@vkOtF(r
z<yHiMWqf&On@>~a$nk^m-%1)62AJFmUeB~UDgYK4B`GoWW@?P3hFag}t$RBf@UWbh
zt+(sT%O?BNg?@n_9|eNakzCzrF_zk(-*JMmua-_JWz*wyi$fawO}mhest)1T+I1i-
zOXm~n!N9jyonarJKa4Or%{mZa6?7_-`&9f~M-$uRF1`KcJF~|w_Gs=!#8M7t#h=~%
zHP(MOcf4p&zTkyK;%1?l9xE6&M`YaW^3tzF2b7vP#TL9U7+Jsb+yJCb#Ay;VV<(Sc
zG&^0-DjtPFdn=F1E@!Hik36}Oi`o{jDh;{7X96w*&#8bD^K5`O$gV8%p^F-4+9Fc2
z+@)fA&GocXQ1fc>(E{1Hp45+R8!7XS6nEgdxpNBn$qF1P5L&2u3Rs2FvdF#ow^sUV
z;X(MbqfyPA7n1lw*J@6Jrr@QZ(iy8*kYxV#6mXQrJMvGm=Enxm3Iu=keXI#oiS^2L
zHOPgyKSgV~_w{S5I4^5D2x#32U}t`qrO#Xf?eO{nPQqm`v=?)^IXV`ZCVr~?Gk0us
z74m<}w4n#gzu%n=3c~?q_l#0pOy+xD@M-)S&(#7|XUOM*7EV7i<{hCl7B-jHD;es3
zX#M$!VX0c8LGzSB2Naf-y+6bLg{%KW?6A`;Q`pqm3YhY8ZXla&TFE{ZzGz+BTj>Gn
z7biKki3SYe)R<3F>cpu8p*s+Bn^@sw`v-^kWg*V3^7P`%y^o&EO&MGc-<h6w1mB2*
zeD8eXC6q4k>%rSBHL8B*n>d-ytJ9RIF6haO2;Tr!`p#T%3H+%CWZM5}okEBBr-mI)
z)NQ$QXL?Ucfn8ZgVo+__7WVi~e$d%__J^gR?=rRY@&6wNQf_^1FPJtP<!BhF`(y8O
zHA8uSt*+$E{+Fi4Tl-(z?*G{T);^~EcfITFnZMt=Ki~TMqwmj;zd!pCDhC_G{AUj~
zT|>pq2COVN=^_D8VV9}DXBJIG97}o3Byz($OeFHA3iBjJC8KA4=f%EwxH~RklOp_H
z*n(d+^0qOQ|1s^jx88?WA8j8UL_?HD7qQZ*{#Z$rX)Ga;xq(JY82gMFs0DJt_LCDi
z!oC0c1mVOTPg}qy%zneSG7|J^75SH)m5T3)>1Imu`LP*`4)3sK6-tPmmq(#l;zoj@
z8?lZAh5_q96{VDGP3ZGWW6s=VDvX1;8VHlB2Q^uDcp|(37ZYvDH2qH{3Gm{!kR0Sj
zsHcos2*@Q%l$zzM?$>6XKB(E`6L0t}Y(}`?k5bl2MH;v&03*9&mGHoOmp#`AVB0)%
zWQVwthp!RcoLz#oXm0+bBeorh?Sa~*N|c358Sk5kX>ALnTXUu`9y}MnnwS*^UB(p<
zlca*D|95|ae_u@xgm0bjk2DepP<vGmone44kt8E_$Mm2x90@ySmRY1xjqZ+2H?kig
zn+a3uI&PWdLb<juFRj!oK=V3OD}`8mQj`1i%!=zQes9C<QaVtIiHMeppGWAd(O4bT
zQ{wm`^D%=ZRWuFmp9YF07+zJS0EPZygS3;@3#vG^ie)j|zYMjy`}H4?DeULi$ihvH
zc?#;ac<`5zV>}c}vqo?=q+`@-yT&{z#lPX$&1MtT{h2I|;W}9i&C>Pj^MyE~UWzum
zl;$t%qF`U)#fdQm<2Sr!h0HTBw7e`^X|{8hpUAc$9-s&U3EIhm-t08KZcb7Eg(Z<~
zSL2$iJlBF~P5jQ*X+l42<vnQ>{5z^Mpedf|OESL!bv5y27aHG#p1&CpALfy9$wHTz
zCg_cK)%6l&mIGwWO6(VH+;qXwyn*j7?W=BR;yV}N8x>P-2tg<p{UU2!Le#1I`EjUP
zj=m*a8ia?LCX45)?D~soEzhLZk<gi@$;eba3kgzr2E)Z)?0KxYswPji3evcHk8lRa
z%<y>P6)mvcW2VQ})NJ@Fh3JDD#la})Ri!gxO;9^g@+-E>H;H;kN$}#qBC`)yC$K$X
zB*=H=r9STy1u1mDMhnpY{@H2KLG7268=Kf+<rUL<zacX201G>|E5@Pu6PqzmePzW+
z;K3e)>AJ;#Jklt%aHBx=Fsd`t)z2tlZIYlVnf6VON3c(P5Gl20*W7WRYLZ)$a&uw2
zTyLm;mN`smGki(c_A}ZXhZvSVvzKYz&3Bqjjy5g2rV#s^Wzbvtf}o%_BELUItVUu*
zuR1U`Tq4?7RD6pfF;)C<*@Y>J(291Kt>0S~?5Y2DSt07>N!O#JlRQ&~02q16=hc-y
z)tDPOch`>DYl?u(5f&C(X1z=l=>$r$_mB%PW}-OxkE}B<cG|g>T7EwH2w?UJ#w9ON
zbWax1ATl~#ZZ3{{y0N35J*Ty<4CSycwl-u&d_98zxL{Y_UA9lXab=~LxHZXWQXHgj
z5aN!_{W24h=5jOiW_Ui<R*v!D&D>LeX0YyO(Yd_v#gHRqNL1M__@D33)UWT~mq<b=
z+^QuP=Fdsp?oXu)bzsYOzdYWfnb^QV8OEByejt`?9B`wfjPXg;AGB+fywHK@-x<Ke
zKj&)-1~AEZ3ho3;%ZhHBead5mEv3Inoo#S6tk4j1hHqR$P#sG-==-dkx%Vtgly>d2
z@X}!IlZ9DZ@+Eb@*OEQl=^Y&#3C1%9k-!f<ABt_>8xgxt$GNM&#}_9G{~Fvh?x>-p
z*WNi?E|9kvZCF|iNjP1uA0&cYk$J)K_~mKQL>txFRGA-%)yvpmnY2N*bfXk_zf4^B
z8hx$C9OxGB`EF+vGnj`hJa&yxOF$H>`pV+GZW<o<m^hL`otsA_c;F#)tJ6}ce9I11
z-EU9WbPW8R#M-b$l2aszAOx!;fITlcg(a~?q9nygVa@|ky!IGOZ$Z3M*cU?lkkd4r
zdMN3hYa|MAGJ<l94|h(-gSBZ;7aBa4hAgGAb<@zZG>%;w4xh-Soyg;o$QPT4FHIEe
zP86O^6b;sO0}!aF1Q|nk4E1=IJ@g1Z2w6xVfDlV#FlWM5K{}qahEy|87Mqo45HPbo
z8qfjwy-0fwHICSYBpDFk-Om1pps~}BS^cb&;e)v*CB4?pmMP6O*e;%xixeVyrFEpT
zrc%ATlNnradmhnFHCzuh*17X6_|N&=4rvG{`Y+9?`Q_OH8BxhiHuF@(qIh81BIA&Z
zq^)6-g6ZyH<mQ6iKFbgn`w|ri05Lw!d+k<=;?93@9L#oD6bV(+Z>tNx+`x?*!y(;q
zaFs+`StM5xK{~P;?stPfeKVbf%jj%kCf#A%=EP9C=-;-uBS>QXO<Zi9VW|=(4p7}8
zlGqO^uEc5!6P)Pndi?Yn)}54fNX_bPl44AuX*5aJ26Gy8j<%+5)WKc}4!y61OH9Ei
zMT^+^AO|8b@21%6OmJlYdm<HjR42{@7)+ze{X5ugX|Bjz>>mP7EZ-P1eWWL#ho;y&
z$QhvaoPWDHppdipFFAl*E)0~%Wszs{2H8R8g&896QsYrQxiMQ<j=3!NXv`rsQ}+&x
z!ivc-5_e8srZ{pTh6w1@MBhQGi<Kmd&lopIW`J;Rk8?fEwgV5zPU5z(=OlFOEA&%o
zoZAA%<rj8D8h7doI>yNG<Q~?>wHPv8<n0<hc{dAYNdD?q<RSn(t}aq@m3>9ZHWe3f
z<_k9Vg<<QhI|wiV36u~Qw+b(i<01~~=V%4kIp9ZUlpN_j=sKoS6s>G^im*;28*i4Z
zQqcqL9HKI~<R0<TGVFQhGUdDFH|5IfLdw^`2$&hJAjLFpPhK6Bna=I-0_SPLgs-*B
ztwtgTyH9>zz;0Hb>>{)0)xmgPa|HNs22$gGR^$8~opx{**>NfiQrs-7-^OT~ZMy@l
z$ZPIv!M`|N`7k;b0&+ZDxLyfVfqbru6kqp|!=?YhzQ6-dHn1CHhX-@=Y9`sw;J{#{
ztJ_ql+%&g0U<2k9Sl!KzvUQ8E=56gS)Y!pdUWR$d;!fGcz2kykBeM_obNIY*kT)c*
zw-=4JW0O|Hj&{!el5c>>wN?QrEjCpZ9h_>5aum%rnFl@wqr=|GKMc9bW5~Yki@~`0
z%8Cn~r<!cn1O`P})&+3p1H?)V+~OMcii8h~Y7h9pteaKrXzUNy!Z*9jAk!Y-1l%-W
ziq;m5(8PwuKMhdvMo0&GaoV+=B&JbX$GlU5{L0<;2m6XujdPSHnENW=?@F3=_$L>t
z)<sIX%HS~D*y{`2$_UwzUX?C{he94gDBmAagKqp%9v6VC3B@(-V_Tj`-_$W;;V^bb
z*8j#CdP|)~$kpI}!pef@#ZU3lss!IC`@N~^m`_++qTpRPF<Ju`y^5{7dvRh-74#Kr
z+sL)}1$&c(izSJDLpee$aBID|MV(s}p|_xhnC&Qq!~X2Y>9Pnn-0e#>gL_2ABDd8a
ztced^N*(J+4m(rLOO?YZ{=tU!b3cNIZ;q>&&^Z3$uE-f8{J=%Jcd^BCIL`Mt@i3g=
zU##$DTTv@qJjot^`L??sjGYemlEVbI`}naqixmnwQ>X~ZUCyQ=<7^WDe80f%92<`>
z^0p7B%nr7L3bVtp!*)!-d_Zrm_B$fFwf(sJRMp>fuACL@-U5<A4PlY7Uu@4}67Rt`
z@A~TA+wr{zRXx9*n6IoL8}}wakJm!0zLaC8Tp^L0|1yS;oj4w%dZu49^Ry`6B0S3_
zh<jLpBd{d&hEk;kb}<r@CB)(0!_`f*|CWmuvLki$;%eP-mEY{DgnFS-$ks8_^Q}^q
z8%5Wayyh3^^!x4_9Wn(a9N9EJ&qTx)r{fc{RCqNeCK(g4!3|KuyU6PAw$R?L=v&_$
zCUBxT(ukLLvByT8e7kV-PjPN6>O-R#%<Ox@vEQ~4zk2th#cQ8%c}F5E7m&F$1oW#}
zI2n=b(+1syUC2f7^NR!$HD|$yY}{ie>7hmqyu5&mt?xKGkKHdi_p2^#s7{;D1tpYJ
z%^e=EsMf=^hJMnI5lZ4f_6>Y!&^9tk6jBpgCB#VU(L}-%TYcC&a*-eR2em7Pboz$$
z=7;nThRDLh6un_%;o-{wDjGN^Vg$eGGF%eyKLqQQQy6+0HSWgsTE-XTgRX7AN?cTq
zA5*cTq9?nsKS^lUwc&9ixURIcpxy}iU8g809L~vcho9>yvHu+r=0UfgqCO7Q(@Wmq
z$aT)_+r<tL&}poS@ifAih`3jt51S}hAn6yUk8tFl=<zo=MCd{h3m8ij)~lN$ya5~q
z^`10bx+GM<)h}((cwdr59TezL6g_9ZP9@dlV^g@Fj3gtUEO=R!yBxNk+PI@FXXs&L
z3MDRKi8H8<T!euivWx124LLSHg?<wwcH9WcAfe|8Xo{J-UAffXUs~Wi_;$OT-{{k^
zg4?-FTP6X4X&GzlBTaL%sTPJ>Ulv#Gy*{w;q>q>6p3JYui;c%Att*6k5K()5(E@>&
z*7fuT^l*&6qZK^l_sh=$VJar=CEK~~0dM=f674R0f}7pp=*6+oiWDpd<=zl5N5%T@
z5=(d1miOU;S~f{+3@2L2KRuM(1dF<l*QjwQcu={-?cDCaw_(!cRC=vO>|2_Q0qC40
zQ98d}dULzuWz7?TlM<{0tQ`Os8^rjwi+}n0^6|0hij=GL1ys0(SRILHsR;cB;67Zy
zT(ggxe9tSXgzK)c9-s;NW{R<B?A|r(Nr*@a=cvaGvKy!Qo)01rCu*MlrhoZ4+!xQ1
zsx>kkJI0G~#*t1=z8JbEFqLcj7C;S}5;t7j?rta|MZ(RsC3L%x7>WmjARQAn*I)bQ
z2T1Y*%{HWMn$^x$IfV@NQ30yo)^_;6o8mPgqXPa0k6xPK<7BV5)3*LP4q6IcWaV+N
zak4EAX!VKcksm4v)M7T(-%CzEiML=p2)rB}iQS`yi^3wVyq3k;qXq2Q_o%8uwZra%
zy(*4bqwV6IwjUmfw81w8!uy@e(zwR;a5L`;X#t$x)Cv~W#4t}3AV<1o9@E+8o&A0+
za%k4w4z>|_-6PKSd*l#XwysGvJaW+K1y1H-IQzg<0x*TB?7^lrarIxoqC`mAzEcV0
z%NVX=<NGLI0B|NF!HJBxd5w0ZoS7R_9!ax%G=3*4<?qy8)ib&cga@yJWnk*qFT$c!
z`L}_;#MZaiY(8N(sNomx(K8Wptf2n@>e4$Ak<vb?kp9-gc8-mW|4y>>KHV!oy%@8v
zd_7uu!+JDwL|RpK6F1aaUOG=jxW^tFk}<$=VXMiE^55(ar`aYxnf;8HjQ|{N&vB&P
zS{vMkF>_JbQwWkipDz_LA+iSQhwcACL`SyIpHwm-AhH*bit^vMub6w>Tzw|`-3|Pi
zPx1Sk>rx`?>u(=@R|kKdKm5KR`eRA|$BNgFPgj4eUH|d*kQUINbnRlYcQtH@zd$@6
zy`qlWQ2v=s{`u{?AOnXn2tMxJE@OKRJKz7IW&0<{n~PnCeve-4n1^lF!(l!mu_~Yb
zc?tSXRiRJuE&9dAK(w~*#<X;9UbD*-H)PWBOgPA~Tni_kz%*oC->e^C3e*o!JB%yV
z((=h=VBeZ%|814jZNjEMsTtlJiVK-ScAVL%sMt}@5oDk-t5cgt1EKkD-1!C_d+%Se
zSgs_Ts0TGTGLF;tC)VG<*j4P;k$3lW%JuU}z9grcXw`IZA2*%wKT2)aT(A_!o=AqK
z0l6=zo?!yQLp1`7rQeY+N~Aytk+ED-$j$c-?Cp_1uZrxcO#BST3O>T{zINk?)W$_q
z3yT=OhH~iF>4is@+W<+9dcGvaUu`qd@%$y(s*haGU-l;>ZPYEqPz==vV!*)E-^$y9
zr6>5DeaZrb*h2(Sengy|1TISsx8BdzL3<E|xg)^3i+&695V#{QvL*f(m`=?<&`3np
z%`w?8A0YDoo-%|cKayMN&x+Wna1_J7Xg--20|Pi!$hvCA;9OsR;Ce9t8vnO_@h6pb
ziuFN5ef8(Z+jO6;f1PirE9Uu9C$Afq*{xa@E8O0*e`DA1ESOb1Ib3G{`PB6j@rO`B
zhc)UAldST(-#=$<uLJ2<<SzXD_$cAJv5v-XtUD)QR{`HGQ0bSKBl^O28I8WjTe1ZG
zp4`7xbEla$-XwQSS=s(ke1Y=!%QJ3|f)X)erWG!mexq6Ok21f^N&<i}Ff|R|6sw~b
zmV~xi_iWWAfWROeN|t6|g&F&IPV-Ls0PvHg{^3o<?Y4jq(&AdhL7jghmqxP0%tT+6
z&n$aBcIwbL?+)CuOAq<wCeq&&5Bi$v@b|X;(7C-!WnEjUAG;%020O53x^c^^G=BH@
z{Fe`}9{&5s()y~ktXOMZ7kN1GIUP{c9j%JA)T!$-F|`cPFc!RIUQ%$hk1qtoaYuHP
zpV@CW=C(18di=P&^^|1D)@Gw(W76K~>;D-i87ck~%!ey!zIn%xD2UnnEPB_@INW3u
zu7I|XsY+3^tZE@kWT|V{jasUw<CTlumT(xZONWaM#{jQsChskDNPW%esdSTcV(_L6
zO~m`<R2^C0&rCyZL;I7UT*8eROU1h@T&#|TwvPN7L$OqKJ4qwM$QH|HwE%5Hh|6ce
z7~}FLak+QZh?}vNyt07yr#)s%&O(||-PUv6kV2>JveWWCl9OpOPAdOo?1wj6yDYqN
zOf=^{=ndSQGo*hrY0I06g5GUiH#e(`CrTt?A|i(xFkz65PgO2<YO8nO-)lCWD=vNg
zY;L$Xt;G1^&k-%}_#W-L0#m}k&~!dPP0luaB#X+_*;+_yROjlDK*!58bo*tfjB5L5
zX?^PU&oO`>4>&p$=?N&XF+Cnw<Q&u!SmI4T9#nR^p(p6t+0o;tD=&WPIbD?i*9op+
zNcRTU<|toc*ZSJDRL3XuQrWg)K5~UMSa>(=8K=LzqFi>u{n^1h^98)T?&ofbPQ=K3
zbzsGN;dy__C+Ln(g7%{tnVG!^agut2PsdsS_{+TqY9mY^nT`D59R!y#fh$OMdcW8v
z;^|(?$c*>rj@n~tnVetnw{gj}>NXWR?mwmzZ%B#7o`NrIPj%Y2RXnszPi-M@Revq2
zxpCn~^kSKtR0Z`Nfs%b%{e~0(Ktp7_0*!SQ-vH`0ndJN~gnV(ryW;|vzBJpkq0Pog
za$L+MGUUda6gH*5U`At=ibjKc8`2&;&M1GI9p~oLrX^Zftt{I$Yt~{J#0K57kprz`
z#Px5aDqJykF;u-a_w~ME?atAT%3laTEZkHa-<>2y2b)XVMKis9mIVipug%ljnVynE
z_?~Lm>1P2*58)yF7ivYB?3gNNK2BO1ohjjGm?1?ZUM7lDghB(#F6=^5F*Wlm8`6)D
ze*LQFiVr?vF!k+<gp=Sw1{`8^52&~$>BVV!@#?RP28{srKtT(Ay;nGeSH^BqAkpu7
z#iO_JLC1+9rW-ovQiFJg<Q~S-`>7=Z6uZyi&0*s&dE`t_eXT=I(vUZ$`Dt89c`8v&
z+`rKmd8z7>BDaG_ZnaS=2X`SNL%7k#4LofeGmIaI&E@aZew<yzrFsoFN?P*e{&8I8
zYAp8+zQ?=I9-W^lr?Bz{NjM(NJL8-BF5HA9ox}+sT>R2EvXS%PMmE%~2HCpceT)YR
zOvOPovSqV0`>DmBJWX;7c3e0qU~=%*$no7dPQrs5`REIus&IWl#^<-#nI5&-E<9P)
z4R5U<jT=go;r)OuAkV2Snin?*0UEYB5-}3MJUL5^m=Awfu}Wmmm*&!f16h29Do{aN
zkWxW@?owffPEoL(`_jWJ9z$$wMPTvid!x-2%Auh4VY9>bUc)QKT+XFtK&Wc|r5g>x
zmOZxLygv7lo$UNQZSDNJx$=!a1WP8VTNvG*acY)(eOs>C*rY0y>uF(hQM}=*fqLRJ
zI1x;YE%j!J5Y*BoeElRRV&ymo0Zz9}cK(m&q&3X;-qZ{Rs1|*hR%?;d@;h_3D~Ri+
z981SNFZX|)JF_9Xt;tkDX^thHv<o;xUSsRKoDOM=hk``cXb_phVbA2oD{>B0=T)Qb
z<f-_z0x{Z?_WP34tzU0hxo@RQ;suY}Sz2np;=Z~g5A}l>S1)RvCf8w{Gfj;KbF+1_
zAb=aqT$_3h#vym+uGlwsCWp~A&WRjJbB(XQX3+~<PA-yVbBzB-&j;_C8~0}jc5h;X
zn--NBa{uXPb}VurmdrrFs(vU4Pym$0_Wq-|eBne<GHZ1Y&IN{;P9x5Ahu$nWVDnOC
z!I#vSrNh!rL%vk4(lGTsws;I6_2<$Aqv6y9-|yD<OZ5U9Fd7eL8d)yRHDuq?a|$D8
zYP1Aknd(sDrq8nShxyzK0V868$bQ+cG1uatjnAG7eTw~cKImu{d(wKsEAqoSI@r>_
z^mx2V!+_rV2%y#Rfm^t!Qhj-UU5%tYif%q1nboWwAQU<~$y+R5d?i?dBfC1iIStp-
z99xTRogKTS!#$pry8o)~N5;9#UpeEk&RNfEC82rf>62$Kl{TJevFN5D^sX2Vf`W}i
z#;4r!suMXPsHjw>l8D--2k(B;FZQjTID6^s`wxFcFFyM9@a)w;??1BOvHdXpNLCX6
z`~t!(c98c`Bwed7@P8qL(BD3D(hW-{z7R>#lWIh=$I^Dlu&O2pk2ZOb)1y0SVs5r9
zOm{vYynQ6mLnC{~E1&O8F8xLtm>%Xbg!2eu1M`}zl_Clf)Xg~bTHJYjuN;L8?wYrl
za79!;xZ>Yq-dXuCFXyLmDUR4fd7Zp84bU7i+HQK-02g28uMSFj7(5TtcPw-!r{H2~
z<2`-mCtFn_g)3=8f#fo*J6Z_v)(*RvP77>kpKe)6xi{;2<4r+5`$p1P^Tn(Jx@q-*
zY*96v@GEkWg|^T{yv&^K`|7-)A=hJ|_N0{rzZ3r4#q)ZbA8H)wKY%WlzH1_FoG-mS
zsOPTmFL8D+=Z#0$*z}dCTTkwIzPHXR#1rvvr%YAar0<(9Py~k7OcW(m&jZ3Y_@2nZ
zb&JpJs$5<-pVYGE<;z2d#Tp58M-HD6RCSV;zVRS`!9XPuCS8upn*y8R;b*ns)-JNQ
z#`7)*GmnDvv|TEdb@dCxlavUEESKY?rW?`t)EVT1p>ATXAYQJTv#T59YhIZBULucB
z&|FJz6DqB>)XknIce(WRucgl5(=N9cm$+cAMYaQx*TjWUm&KFA1=5TuUGkCe5;mH5
zFkHD*I;^LgeFqQ3!du1*=)v%oH3;twju}-ENVyK!kKss5W%UT9K94Opy4&|d!h2#3
z<vbYvYpGGWLXVd4-<d-yXtZWi!G-qJW6SU}<~-K@_3bUK6g8N~4I}^RbO5LXnvzb)
z!#&L_fXIx~Pu0|4QHs+#6JqH?iO{TB7!Zs}z$<>7K|1=~2ByHV8;GRpOf_@iVlYj!
z14Sn!X)nW*%}0QKdK5eGFhhDY|3n}vOPif$Z+!H|=_yJ|zvAN9GE{$Z#HZsKO8rdw
zF6<Q&(s48rOSvf|Y*LU`3sl1sZ6P}B2qgeGxr_XwD;3pSM_+@qxTH2;g0=J~6Z`3a
z58}T&!=Kn_0Zp8m?Zuxgc$L2?XC+Fs#E!9ker4BMsJgtH>VhKNCd*p&=B@iwUkPTY
z&t_d4XBY&lsVxk74%DT2m=)G==ay<yw-`Q=P;(#iH<3`o;M)l#T|@ztsf~FDK$%TY
zIUKtO9#xXm3@qFZz?a<hH(h>OTHXb}RAG`#Oxo`~DuPm)qZ_IR<y1nU%!P^?Fzu~C
zr_Kb!SfHL*F;Os(Vp%tqH^nY?P?QsE_{dzfwOih97pdzaqPL5*8BeBHr{pnFmx;+a
zOzylX*jtpzqfpa;o~H@1V^7u5x0{m82@LN%c*=w%;KNlQn{@Sn`JJ7nK<kf>#Qu)V
zQRA6-+4{7=FgcKjINMtB?E##{-wP*fAtJizUX(VMd0k?xaDq$9o-33|PN9Yr(EF2h
z1Wb?9gu_CT1LZpvUzPrM!1!Q2){n0@G^cB^r~YB%xGa#S**=mmn}Sd%;IAXKJ)6v{
zX}V(G{CczTcKcXDzgffX%`1fJ_c4%`NIG8{yhRqDPe?u|n-vWJ%GGRV7r2!09rek5
z*>f+teHAhT*dp`6S~&Iy!sA>?)XM`zqhuO!HWjEw+(q8TMLa%03!Ir^8WNzQtJ6AU
z%##i%6F*QbOcynok<Bp8Vy4RHCb>*8wVDZsQ7J~+x%BFz1{OnSGle{k&gyP9{`Mqe
zdOBglR`PpqfC8NrwUMGi0L$Tu_tXl?eR$M?G5RiFs&>k;f7zdF()GoYh(KZ3Eb-!y
zZLX?LJ`M4TtfuCn$J5!FgG;lDNsetA2CCC9wqJiCn0DTro<kP1k<GG9V+^>ozVDOI
zio-cCKDGbO{x_I$rD?cOXL6vO$3M@(M)!_ZIP>y2@2P=nf+t=HpGZ4LLMlhI3r$#G
zr_LO?qHZYQ>_l&52cMG9`0H-?ar39~yPR?h$gBlA*{AwkDe2_XQco^a7QuOl3=MDM
zo{UA<xzs<YE_vTx5{K_nl|US`D2bheTQ*g^6?`+7u34}P)*Xi|CQEBD@hoAKT6=QP
zi8PK$JWI(PtyB%s!$GyFxEqn_>Mkiv+sTuHv-!N*z3Ov?tM`)}=ZarzS)H3JeR$uY
zXs-P3+_jOpiq~_Mt8>?X%~iqPRr9(PQp<H>M=o=Ylti`G6bXbHp_zU{sxO(5F3;#2
zA_eX6Q1p?nMKfF=?(S(8r71PUml<23J16y^oM}0wwj@2&xy_q&yo_%I8-v%qMTmMw
zNubXJ{U`$IghWt-lZm;I(>~Yf8_+=N{L!aUS^r3OK#`3t+fG2$)9In-oeDwwhW2@-
zr`dnS(L+LM{xr@k4+-na`uKyiI$rmay|&MI1<Ja#8+nPRx2h9-)JZzftVmlBg`MSp
z?I~MCir)e}usvn6(gi^Fge}m6nqVUGWz$Q#vl;@0mFSIm)VIo6mDsHK_Ul%5$-|rU
zw6J3k%&irL<l)xB!14EqD7XbLN=Q|JYvklt5rO^lg8BbY2PP;vz)C!=UA~_#*mHxM
z!mf7UhDk;G_ovFU(ZC)k?o}R7B+PdTe!0c#`+&{gf2Ff*?|1WrRZpNw-Z4ZsJsz^B
zKK&1MXAUtiT&Fe9@Y+wBnJp}e%s66u!s0x02HfAQ`iNe?#{nCuTJs&XGHj&ik~a_u
zOn8KG8$H)#OD;2EHd(zXA5r$8$fq_A3BMDyG^>Q0{O3#h?Q?#|MTp0R^>Yr9p_3Ll
z%ZMXD-YKPn>^zfK#3lt^7Xv`>Zc!Kw%83#1gEXoh;>$%=IHej5MQ3#6?DEY`HfK$F
zN7Ke5ZW3eP{^?(dTA*hTTZq*uke;kC(&VcG51jN0hd#;vw`GKS;QM!sb5xfCyy^vN
zuDCuM-&K$N(rnKgvuP&R$S&|^B(O>p$hf;|e`~hxM9>YuL__CxSGP7k?U<29x{GaF
z!R{OV`k>VO9BtVmLD90#4AL>vPZ>2<iRT+`Xn$6Il6hr;gjsHv0MXQUkuKHmYneq?
zWa)g%q!0F4S7I6ZO<-Ua;!n0M#?zx`p=mu}N-$xzrt-4#X;$Xk*#5(lIj;%xD@Fye
z41$Sx!Ynk31I=^kX#&lZ7&{-=&Cr?fD`KYU3Ki&BsARwNu(%%V^<{qP!HKHzFM#%1
zzB$5lG7q7@@`$A2be^}lHrrMf(N)bB-mX}zof1LKX=Wm*K6-f}t=E(T(ykoQm)^Ip
zr+qoW@stWN9*2;|QOdc=db^P03jqU$r*Hkh=LOwt$FMzU`1bJAw@1IfJ%+FM^Q{j^
zuMcXj51FnHJFSldt&d&^Pwz?6-tFG2_E^pZ9|vImvT(QE-m1uy%J~Tqz3lPp>-mI;
ztw5BLe3B844hcM7)pGQfLkjiUPPM0Q$A!zv^;){-u*!a95!)f*?eN7>`l<2I+9~Lg
z=#SOsf!1~GPFcs~+UcuKXXG4?3`;9OIr~2+Y+V@ghbivonY6D!vJ2s@TNu-bdS=z@
z1>zojV-FeQlA7UnH-3ZRO|F_h#pzLP$fP}3tVZ9gbm(giua>0;O{2e^K@v9^=kRp@
z4f;6{1X|@*Je$-T^)>-#ytHsu%wd4_V<Twq=PPNj_QGwTn-Ny}qN6)Y{1q}-PvvG9
z^6y&8z!WkD7x52{`=5hUn~Z<i_hBtvg$XswP068+Djj1xo(qMh+#)t6qiS!(dDuep
z;AW*ziHj-hp{RRPXO<SC#1PS$Yf*RhHd)Qct)ko{wO~X`FkA~?lFvi;!PC7<w}pyR
z`~j#EGWjHq8Bfy4qb4gKFwV!Sim-AO-A*jxvtOqp654a#1*RjT)C<fNLHuc?DQ4?x
z+FR!Ioi{g3F24BlifL<u0+^WRD{Ol%umof)IA6@`GGBf>Jd4C<%)&yV)AODnc9*k$
zTtXD^p{%Q6LtVv2w4*UA)CCXKi=_uPLFA@j5lyLgrl4+3$qM8Y|0%j3HTe;nIQyVk
z-|~z6(#3e{Xh9_OrvlxJmTFE&+uDt`Ei(vhH#m?;gIM?b6NdUsuX&o`yv0yn{JVwS
zxd~)O)V7V?E+e*kx-ser>xy<v-fq%)va*Lk9!nm<A(?$Ue#Z(*Q~KVv-owH3S~{FY
zw(CXxX~rZ}!!B{A#kPwYvlkf=q|I@3HwMOo3vPF9BVl1De<}$)go!zi#Au~?#y+*1
zh&fCzac77r&F&_QN4Zt(w-}@i*k=WWJ~E<xo4~g$Z!xlz)AU@HQU-TDKKs}G+(oC0
z1}i3or@_7hm1=Tyu}+7(CK-d@hUwk(w@85dLiXZ5f)Xo8Uw_&>^*}%qOCmtV#8v^9
zztN;4&V~`c`xMyN$|o2X3?HFUsm44gg$=mmM;L0JAyiy(_hV$9Pkh;K(oJ?$f$W6s
zfAH5Ooq^qO7Ah-4pPY7j7jbFfT^B3IE{5KHcz!P~rXLwsl2eucxqc>+epJAcbDPII
zOb$06E9J8PN0PU^ANQM*Qt}q*??ZIc<~phJMZ&PaI~*CIcF9I1&Fs{6-Z(RBjhR#W
zuZDDW1;GSH4*s2Uk^%-(*!a1Kr6Il)d+0w{X{q&MO#(N|w-ur)E}fLDpRX9QCHbUK
z-uX`Wmo2GhrD~^V+CmB%+OL4xLVDu3X*__*2b6W`5AU{W<k7W<lRCMAw09^_z@^yl
zc!32j1=HG{X$hfVB#ai^Qd4chbGTPx!!fMF`rT9cjSou+XU)c21S?kEPyM|0FKISN
zd6A`!E1HBEo1QF-+IzEy&OLY9hIyQ|8Gs5oL&!It9Y0<tC;Z=)RxbJ%W2;%6-pz%p
z&z9fVt<Lve-2U<XuhzzbatP<TV&752Y7>m#7Nk`gxJ_{K{cSt~41h^y_%sqpBdvoz
z>~(&sXf^GgNE4>S${q)ZC<v!R9}Yd>;#B9+98IF}{Mk*;pu9d_k2}s<+p;|-7*dxd
zu_bPNJy~c~V&vp-RPh`|Q1E{KQP`mq*Ohi$%mT%3fr3+)oG{Fl8=KIU$kKQhE0N6>
zsOAW`Rg^57*(o}s=^$ZVE6(R4ojLX+E^vT9#?yA#(e>ZUCvHesXU-`Lcq-D9l@i-b
z6+4$zn(MJQY$xPdAY1oLKT*!%xqhl)08DbZ?l)G$2kJB8u$RfraeNUi`23{qnN<nn
z^sC)=l4nwbW=fm>6-XI3DgEITJ+}y#Y^q7uk#AOO;Cx}Qd_~o>8OeEs<qTTi&o;O>
z%nyh(dGULZfZ&?EoW)c`jzPP&bBdO5Pq~NbVHbiko;BM@#X}!%*><)`rXW0JiR#Y{
z9+Vm*E1+3Pxmt(g&F`C=Z|(a7-&^))2+)vdyDMIv%f-BsQnj{^aUn#zR+!Kg(je-O
znzLA-fFi=v{1WeTgFz^-Y0^nvsc-!Dp5i9HPLJ&Bq|PLoIOU)I=Ra=7ig?KT)+3B!
zJm&C%U<}telP7`qHI#=UO5Vb%pBnsGsDD5BSG{6|V(|y`lJD>Oxk-!A`b8W4*<4AO
z&R(67ojPmkrSo9mwRp{UkD?^F#FM*Dnu~CKXrikze1b=g35qWXYaTu;Fe6NG#r#KN
z9Sl~Qy3;<}Tv$OtOocl7dpQJ<A&I7frNJo{N4$0>wd<vH%148@lsXfA7u{&&2y{9*
z1V9PC?5TQ{1+nxt5vJr$f}m==x-@_}rt0vv>$kxf1?>GR<0?PznaL|b-kJ66P!OCZ
z3whahk*H3~)f4hYQxoj}Kw-y1S|98G{a%~0X13XH<uCSEZ!F7+1&Wj~$!mR;iqi$Z
ztcxE{XGfOVkq&+9+v}voE|@b(_mXh;36i=fxtIFSQ*zZO(8Qi5cF&oPx`Y(pQ<vX4
z0NJ)B7bDYrQ34|l-Re0#)CTE|Waa^w+<{NRrOMj6>I^pK#;;0<$!3o7;i5S@QkMlc
zOD(m>O>bVP9*KAABl11{q?B6ifAtsz63R1}r80h!ZG!gN;GQqTJ2EJk)ei%1<zg>+
zfPmhOu_UHr9s;EzK2XY}9NIntW<gHjG$j9z%^Yg3F?(hruja}WGAmO`e7*^%$Cbo<
z6j3LlYR8o8*T{=-7?gImHs}9!KQF5~S!z<2W8Drp&I0EB@m0yA^8akn;v9K|r{hFY
zvfMLYry%x3nlbPSDC}NHM0=H2xh>T5dUP3LoJkh0=_}kC3pE#1rokfXIHq=Fuy}}h
ziijmsQ;oVQHih#%+KgeII$8&RXU!B6UQBykv?vkTKI$-&2lwOZs)nCviX4Awm~!hj
zW{qI3-vwg3mYGz*(q;(ZTc)$3yK1GUEfw_2HAzs2<6oTMNu~>jeUp8ia=e^%r@5lb
z@T+iNbEuNO3Ago{pQOe=IcoByc5NsnopM6nuAt>rz1rR8Q}OZ+weqi<?e4ZXJ(PFq
zY<Yb%`fjV&KY5oS`8OT;ciX<6gNV#7m}F<OCfelEg4D%l-tYvz^gZ+No0X7wmNhXz
zq(N3Dn`EdF=20s!f=tyqU!c<bDeR_NBKD};oBJ!4^G^PVLXfVG`QzakQyIvj!Jw_h
ze@(EK7Xfa8r`UOd*;XZ594&+VpH5lg{c+BOWT{V4$EcoCKt3r|xq3V2{3=}ErhffW
zx{&J%Ww?9N^NfF>f@k*c;y^O^>4`fIDG^htCHiFw_RfEw&G)~)C4bZ~Xl(ULR+cU6
zyEz^w{Uyh=ZkW5H-H4OR7kvgjgxLsP_p9uk2hiPW&rkliBl|ZG@-g%whp4pVTFub&
zH%LYPON$QBJg%F=g92=cV@$92Zleu<q*)Q35tOf%i`+xM2b9l<30L@Heh4(@kbBb&
zDkNZG2mYdOjZtyZ=2_9y;UOf56w{dQvq*T`p>kD?&oSsR5NwpJHTc8rmQQ9+SMU&W
z6G6Q6D!X0y_$?6dGs<02;wYbT(&ZpY#z!@?_J}sx=(0Uq;EQo+ZmpM@STT5>iUaR0
z=UV7T2Q<1Z2*741vqzUgZ&TUtQy~sjm_qfdnOt)162LT-dG8Q}DE!ydC3zwGto6S&
z$4+ej_&!2UR<HKMtsC4K_%%y_T$q{^DC*d~p6AN@TI%U|Pn-Vlx#4dWfm0@L)CRY#
z(x<-UiVE1i*FKh>^XyYY&}Gy2rYy~FtMkDMl1)Wg^xIYk*DT8OSH+DatP+)4gMImR
zrxzbx9Jo5oMuMiY%Re(adoI9t=h5AlkCDlOp*7qw)rRk%IGv9*SzrIJkpCke_VwGP
z6wIUSBcz0Ww!o26NS=XU?}u*H^kfD2K*sJgJ<@)b;2)5Rmq7pNvsD7)zA;)Q6F}8Z
zHQ<R$jMK*^<$q{KItXpoKQ*WPFAS9!h4gsJlM@m-lu-WOr{UbgZyvAHzw{~p?qE39
z1Q_VPyW7GWQUCD!8AglnVeahxmk)njc&z(j`_`X_+Yf(UW$7+JRCXP&`AVgV=}|ax
zc1IwmIWEQ~<IVlxV+x|1*^Dc#tl{do|AMb>S2~XiD{nFfGp=%E-fqE*=3y>M4hy$1
z`}n~mhC6LYc@M`B16S?8zJK_uPAwTPpTNDqZLphXgH&zULYi2^@Qt@yw#Ab&m$&_j
zkkex#V6lIx)(H+(FHU|QO1P5pj3SY`k!%{Yd8Ne*ERaeX64bAG5A=b=TS#Lvp9pka
zk_52VZSsFK-T6OMZ~Qm#GmJ6T8T(jgvG4o7&5W^y>`Ov3mh6Qjp_s+KuStusB*~u8
zCJd5NNRoVHr&1x6Epz*R@B97(&g1&!JkB}Sxn8g5d;a0)gTc>-?<?!!mFEP{Y$*=N
zjtxpY1^N2)?*|EKq6lae!rJvY^Bv@pI}z|fS)`r;k}BE42n(S!j6KQ&MBf;c!Xqk0
zm*>pt`@gi&zi?Q8-D1&(A8)fL;JkVHB;r?)g}yzj`cooYxF0UeT;Nlq@ov*$kY4HG
zeiiU%t_mD_wqIUwPGZ@@6h$*SWbibg+)XKFyHtamGrQNxhO|Kh?`=^CR*W-UG=)*(
z;H3YQD9*yF9RdE9J1-T3!XJ`=$py(YODTR<PN~Y(OsaW`1%3mC->lj!M7xfHv;(Pz
z5vj(zeY--Rbx;HWh?HCyMt;>VDg&o*L^X7y8!fZSuwZ;?mU62MWER<Q!&VLgpws+;
z4va><1%O?YP;k*xAfW9BVcr-IMG6%~&<p&`6(^<XL{sOyt<4YCIUyZYe+JNCEGYU*
zVQ2;+1k>7i`9oH8S&jM48bs|9GC|rPkI0tCl-7cSp;v2+JTTfP-4Fj`(d=fpy=F-E
z(h+c0Uwc;bKmVCSma#E4=Ot>4Q7Ekq3zehl?ZP=Tc(q|*Ekb7=c|vCEGDwSC8vmMn
zS|R{wB%5zA{`_8YPyMV4Cn&_t*&k8yS@a(tWgH+cMCb6knE~G-=U0WQ@g>sQjU@cM
z1pvtELV69p)|mUutH1}u`(@l!=@JPfbdNNCxz^+8mPZz==TRDR(`HMPRi*Q`oj01W
zjL|?;;^~XBwRcWFr6XmQ)fZ(vhH6h@7(T#f@iA6qmdahw90>vt_Zj$of?h-A>K@J<
z8+5#=y5I`lOYSU&rVUBahcHtDk1X6Ey*ls#RXXvEw-9&x9SsPe(QWwyO`mU)!!P@X
z?+;0iv9b5`$sPHBTe0x*Slk+vB`mM%3rn4UV<|2N-oG;xS-0xOM^$PhuU_vnJ+j!j
z$Z96caw$fh@aI;nOYo-en%$ov(XWi{QfYh=De{OB^i>80=}r8)e7Wu}wKW(YNTm+5
z#Co`k&ruBmSraLYh4*u}Q8ZP^Trxx<G0P&rV@Tm-s!_?Zc_S{eGstVPI$UgdVT%Gz
z9i*kDrpkeTW#)qZ+;wwcpdo;!lRQ2oICWz@=IB<I8X-Hc^1RoY$Bu=LS-%g0sDEf7
z)PEPTyioA9HgBKFnm<R*|G~%<uC^+X$#QuwVbU+J@;T#AK&jt7OyHO3r(|R!Xmf91
zi+r#A@f`u9`I6?)Gkz4aLuyHTsGF&R=tL+^lT|yG)wiBeJaVs6YwiX=&5*uWDg1Tu
zUcc&VJg1majb1~InNqD)L+weWJ01;p{FLg>DxK;hODMS7Kf+1VK2itC(gccd1X<b!
zZ>36;Mo{b3!1pSY8X6kvu9o^$6`YA4zOP1*A9m0f>^ILj<t9qe^<v2H5m@#ZUqcA-
z3Ix6mi`J`zcD3-v$p+6zVZ0j~Ug8^Ghh1~L-)tA|TG&@MKB&2Db<7Az*|R;l?!==?
zczi@fH8Q`Mciev%Rw_F=6-nwp{Ot-fvK)tAG@y;Wa{aHGU@C`<VcqwrrxvLS7Uyj6
z3AKHzSg<ITatTcv*r!T3HJTIqpJlmUM1vI%sj%zUHOBE~o9?cq8)jat-8aL7;4Ho&
zAbKOW-Pnftbc9f<iq}JtX3)kVUwIqo<^QuIo?2(=P}C%-n(Hj81{8cNyP5<;QzErh
zPY9#Hu<@aqV<Unjh7KRHzK|nG53s1#e}A9?{)nM{^uGS~tUK+CQ(-yfG>RgzJKQxs
z9HcOyp2RB>;e1nOKq&SUp7zactNisoO<09m492RPupZYtxJPf|P0lT!Y<@AyRCVve
zX*;pzR#9_75vfrOjQ!0V8jEEutIE^<58z$`C?kE(!YJ?sza;dyp=91c)daH+s;Ib;
zo2EIf<)I9XUWWN$(b{97awjJsf{~Fz`R-7lnKB}r^U-KtOf=BN#OGbuu}TJheFiR4
z`aW-@UB%6rVXo7h1Gw$$w4AyEQW)shSkC!8Z7o!blSEMDefV(&ECth6z*CmM&}?&)
z(T9E1#rRY*3Ouk%)w;~qdhYvXT4b&bV|%3KbZKhsXsWIX?b@#6!fJ->v?J1_IE@V}
z<I~6ezF%9^g5w&iyNN(|)_qsabGgUt7Ez5oy)=jq*WOE=Rq$$GW-`{MGvp&uU#faa
zh7c5{$yQ$YfO`e5G_sY=i<pm;{*yvmQ#R8YKVhs}@oc?X_NjWABBgiUjE>u2)(IE|
zg0%f0y8d+-bdZ$|OB~B#smc+vDc?5}I(Ymuy7wm{yOhG#D>Sxg==MFfm5dRE<w>O7
zy=6VOOBEkJUV;@*12utr4Zzq-yA}#eTLUK=oB4Z@cNviEEp(#0##0uA%uA8_F|(aA
zRj`Ew*b+ImX{IunJD{!#?-P>QFpJt2hOe4nDd+-*@5ztO%M67>kp8SJue>{7eP4jj
zgf@04gpC~*zz7JLQ4W9q0T>!WgAHYzfgK0nHN(W7IZ!ieBSA0F8)DSkp2LTLjeT0o
z-SX(Esh^W7Hr3oS8jGwtRHJC4gq@Ry;qHfW1TzFfCHR}q?wNd1YRhVd__`%Nf+`l6
zDWoB;8fqbd?RVoA1R^*d@AN6fkGcj?zK`zIg44A(owm$kJ=$<GAuQUik`@1#p(=P#
ze+<w}_cb7_j@6hNSunGq^w}33ch86JXLLP+A9|eE^}O`ZGg;Rw{h?RB?x|}JPgUxA
z-_`ZXx00;IiE{~vV=4Gg;8@iP`^n#ZQ#P@x<-X4enET)hhFZ_=T@+TO=tig-HR7jM
zGUSLBP-U8KJl?)mooFZFtN7nI&c_zcoUIT1b2+~AOl27(S}!F3PX?c!FxySMgoPh-
z2%EGHJ~d|Nra^3(B|e#b`SDNRqTW5a1a;vzu?Bp;IQ1O6c+_1)QI(#sZNDZ!5vKLY
zMQ}QO&XBO7NOQCL9^z#TSS0N`7wf>|WKUlQ;RICyyPc-odQG3wQ{hdQnlt0FN-q`C
zx-Q@7{HoNouXEoq^~8gxFRZ!<{lXnle;-D_bsXs%aP1m7<LE(IdgUh%CKn%9W(=;L
z;Uj~4(V1BzwU$Y20NU+;(J82fWTT}H8m}s2q1nn9Nl0}H>ART7&<vzp7yzk^^<xOG
zvQL}w^;>~e`YH9(K~IFo3z?V3x6<<Uubp*0QFPZUbKzA{{-xA2&eGFw4LahYcDh=9
z#iu-mP3qH~Ogi--SmR-KfCkEyC1}T|N{q2Kg7Gmj{qw|(^AAQSj>1t)&nU)?SHE|o
zm4#EKy~h{rXz3DqmIjppdnNfNBvcr>D$YP7<6X|kudJ7sLmaq$E#^YlJA+=BH!?JL
z@Cs`MLc_M28+e}aYv&(X8W-TivEjxYpv31>jmkIh!(Gr1my(eGHNP{ueEmaES6uO5
zgJ5~W<zi@odcu93Z16?!y^u$<KA!{y%BN7A0P3B&57m_wo02#vFL@G3A)hR_W(x)D
z15pz4(<Aqc{T@7_FEJmHVMa7&XZ2lzZ}Pyi`vm#}<5vrRlBNH;DL-*|1c?|<o1Gg@
z>nfkxut@xJLD{zN(Hjf#63hLB)M+C~AZ^>o;DwM6KYoL?lh^oO;UAySxDv*t{L`I|
z-IrRQ>$ZPO7)if`uYX!p+1YzzH0B;OJ148G^2NhQ>g*W4ws_D&mNn45b=EDzYPVAF
zQJ*P_U>NH`|8TiAQZoA6<)D9t(QA9p8H677fe#<zdT$K$u$G4mAB>8>P6+3`lWv<3
z>adKVjpd(Onf#{x1>emA(04!61xKoebH(gMO&Y^qceM=%+^DGf*tzg{0Da58^{@$P
zXeVK2Thiv!_p~^Gd3C1iL=Q9DTqZgXdtj|?oz=t<q+r#!Y$r}1F^;z+HoiLJ**9Yk
z*GK%mCGh>W`R*<KZX!FP`U7G5t#Mn^Ku_@im5~^<b+r07?sPPdeYk<Q!lA2-?VH?F
zXJ{VBccARU-6x`>jR$<b>nwU>mJj|UTu|-ttun!@>|N(O$gu4pUlBiayxN}3q_mlz
znrCijkNk}=#)der{yftHu=B~ebr+B<(m6mOxMIjV^W^f0+P0Xe(?9@#<<Ar%`U1cP
zG=Z~rbn$r{fdxGBH(wG3xNJ&1iEHJ<MY{BNNGm9!`3eBxG(v@2s4JksC#Cy%a@n=k
z11A+BMr10zPe1d}Ur4+&+_TmBu2yVVr_yAb?YrBh#@EjIKDo5D`u@qa^JktXgMONd
zr1*7*Z}Fxb@E;GtB!SNUFy1}?xs^K2BB&fA05k#LSp>Is&ad{xPyHEuV#G=6xm;rR
znEdzpr~~#0^&<1}sS_@WK$gz(YjJ}$+JL_GzuZH){uRcJzo|!0yKKJ>-mkp#L)<v7
z>BHp<j&I77F8^8^zw7z@_CI_G=RYCorH9Y(Kwp$}M5soJZgO9%mMjos->`VCtQ$lt
zNgl(ED7X$?e_a`=#DOhOX7K_md$4Q<U$1ZU&QRsMqcpDEMqeBmxVvFd*z<HmX^W01
ztq#9m?ZLD!v=X*`-Oz(1bGr<qGX*DjtWBbq3$(I)poR-qFJy2VPdH_F{ZIZf2bs$V
zH(KZqpBVa{M}1?fJ(zv+weH7=ccc0XIlr0<mK%$o3H|ea^~Q8><K0_x(8c;!SdQOC
z_B}l+ZsV4sk(17dD@krHbvfJ0&9<7OZtonHRPx?A;&|LAoo!X$Pr5ogxW9Kl75V<X
zCn?u`>Qrdc`>E5>qwXJkFMogk;S8C_!^`(!0hQbSAcN3F>WZq#Q%cMAn6Y1(J}Z|z
z1hSlnJk*r)(hm_$M<pL}1m}m2JLo%ImoW~hOa{ja-bl{k=oB8YVO)|jp8WpdjKO_W
z`mAjS(?CXwQWjKl`aIe9|K~5E+Z&&=HKk(sUg|6~@r_(9yyh4Cp5Ayp$NA)CQ!kYn
z{GifVmZp~{{rgyz@gdQHRv0nORk3qr_t^Mp!o2eZq;3wmeBuF0!LPI`Z@-1Ky~Qp!
zUpxF^1@mrCzHBY;Wx9CN)yw)-@f0qiUqDgjMrHi|ZfSP3jh)xmCtJ<oI?2#`Sw+z+
zAw{=<kirJPNZyzwsiIhrB_i_asjN?B^;K!~;zZSI(d^w<pMJeXwlDdH^#Jn)ahp7~
z!^dqCR9OdTvrN2J%uwOl{r;Pm>TG!@&Q|utm--_ns%`mpmI`4+QOXZoqiiySsknVy
zYd4ZmG~lhUMr^ck5@SxoM^-AQE}M>3hSMGV{w-x^rgtQjYz4~cWtCL_E`%G&rF?Wq
zSpDyMD<6mBD3|ybt`ya6w6^acMd!ox@IGqSP<ew4cSo_PDqLXu!t=(TeXC5b*@||8
zwsd)Fp2a>Z4Gt+Ic$T(iupR?xZ=>ZT4^YU$tQ6j_k_6tJ>Cf(0rBksgR4GK(ho@gt
z;och-<Sq=W>9#Yk+HgTuyf&u{v^`4>l!7he=oNWG7LP=&=(}Z7VVX<N&dCO*KJI^O
zzUgFXSe?V23oy>}I}gM~G}#zuzCiB7^Wt(<0fvILyuE*F&x(cEHBqK0KCBSy+ZKpS
zgVNAo(o2Ikg~bz#V=2cchE|&yHZ8+%ar1q-$tX48CDz6y$)>=eZW9&xy0rWDha$PS
zqH8@9{`j%2bR1u(Xtsd3B&{v~79vtS+t|izk&lyRQ-k6l4gQRMn49zuruS^8uB8@W
zCm3M(qcr9!dY#gB2w_&hG(}<?$S??8yYah29&CEi@yZX^E3u1f=AeWw5~PIA_Wi>h
z?h2<=wUR2Hi|ZC>G3U&aCDlR?*DW<GoO93Vgas7}@<}W}Z88KCiH2EtvFIF&Nw!*y
z?7cb@F@(r7o0Hlr>m76pu5cS_9kzY&B)PaCh*(4Ab!OFP{^iqZrE#D)Z5({_9y{DQ
z5oWZv!xf*vDc?Bf=I#6C6HaGZCY+c7ck5$t^;NTl`z(opKU!K)+F)TJcU(BCZt#Ao
z_UL>p<Z5iR<`=Vkw>RdZ*We!BP(h%ggO5XePa!alqA3tQwj!}t-hj{9$`4YrMu&!g
z#kO5OzA|bscHHK=P(3L>dA79mnUa+q3z2QAJ-88+VZC45%iHnhc#7JXrA6KX%;UD8
z#<PFl?^@9m#5m#}HAxC%Hdnk9$6RebgnYp8@<Wpx^aLKZvPSdrW!os!O4$D9#rtLR
zXz5l9x6&<D_}dB`CMmogSb|oEGxvU>{yl}<L3sf@GsByRaa#M%73`pOTT7Dj{>RW(
zypy<?u41qvw6oztG8?3-BtQ_s8D1DB4g^WmB9>-2PH^g%erRu3;+wI|UDV(vl@Jp9
zkK@H*A}O7n%NCsE<JeeR&f1`KRNTK8rv<c3k{c(Rk2WFnS{B6OzP5@QOJV7Ki5lhb
zM~MdBBPF((q%*opzE_3`z)_pmkdd&KM>mVfw(iFRa%3{}V@^oA0AO1J(c0xqIbuoS
z5Pd6+EVs)z$GpVzctu)_ldlOs?=+wzMT2X%fh#>e-F~kY_b#qk>8`nC%9>2zr2k0~
zVb;w>yMrY%>gdJvA&6uB2dntn4Znr6vEBEXri0z?xD(=Y;zRKR6yZTV8ovJH674A!
zwU?nTGKCXM_~VU!iL%+@t<FjAwctu>|B`Ty;8R>~IU4}F;Pb|zRN+Q~cUZ~=gO20;
zokZYchxT(Svww4fmY2j{?568_tv#j<^JV}F=ZE`ai+7}G_t<f{+QQYJl1w5+em3yq
zd3y>B3gmK0n=i~L<9FHb%fIFJbiH>yYkR%Kr~kd;Bl1VdrqO@awJ&=MWF^p0&vZ<;
z>b(JMbM&{bY{VR|s!yjaYOCjYyPBbyL*^y_xh20ALf5rs{FnCzjy|xs*ov~TWy;j-
z#9nXydN%moU{iJU1MM$8a~IzQm^DUsk1``eu5MS@k}{IUm$;5P)Bb_;;GS=O80N2T
z#ArSFNS7NBOU>Ig_bV(IUS-7R``Jj%3H>i#|5H(rGVU6dpx(2>8`^zAjeFnzg|BxX
zQCV+#Mt8w)Ns}O^tWcX`lzfwW9SD(BgS(_(hCfpolGV4Ni1P}yX#+3)pbxg>!_FTD
zOt4q|!5=qSPkYJqq<a6o++$wd$w;kRa7?^#szuG=b?w}h*>uGp7O>=j4?it4oW3*0
zJ|X$n=I0hh$*WbI#Afq9phZD^mp2Hl0t(y>?|@gss<Ts}LBK1jftC7-&3QETe4i5c
z>Ivn4b+T&08bC9#b1I+_->1k-IT^`9l-fqY>sl^N@dE2ZhzWqFAElgAEd;F=%ISw=
z)X}%!h@C6Qzp8>bK5!ZilFS<%j)1d^EQ)!v^!@?=7Z$j2IAT4~Y&oLN<tXzAtKs!{
z>9yc}Td{1xI>t{HqL2m{J%g4Quu}f<+ILRQFonUBw2n%GY9ii7a`TLLDk8rU(Mnur
zb~VtvB)Rn}j%Q8pY|gzaTig-mwl^D9=9T3hge!*yOV!)i++08^p{-7Ah~gPDMg;K<
z6yk{d6^}0+T9NdUk=aB^4zXPo^#7)U|5)B6`v)iP7L4{8$IOw?-Mtt@o#PZ`ulIai
zeBj{*>kkw~G<WTQsp0I^EbY|O%R7vExM9&(<gb0K8bC;z%lNJcGS4*q(<Vk_?hX&I
zBKBxNJm`cJI)dJ?CG~sp1(Bq#M3Mu(-)M#-*<93Pm7(AJMN7!yXIUf>ZN<mQ3pBra
zc_i}ZqW4jigx<Yt_A(g5cC|$me0W^VqfdDL8zbRmhmn@7dyMR<c3IzTS(27qP>ft?
zyIkaUwH|z88Ow97T^_`*Ok5D7liI{^V!T6`sXoEQQTglbS!qimmON;q;CZ7q#is4}
zIy_g%IHRneKZgWwPT|%dNkJ*L&D$y;<Rkd+Ly6XXZkotE9@Q28SpKSy8idYa7IZ8b
zrFKq@`OhV+A2l=7Cs>=^ugA)tWwUn_qgiD&{09y9_|C`xcq_<a-sw1itf{LVAOW(t
z3Ig7!j8?Po3Hpm?MQA%~`%cUghj5*0s+~O>Tv)Vl8mMKp@0^RaK6OxZ?v9An2~mk~
zehgY$Xpu9lZy{FOkQ%f<v~t;qpee+nG{4YN^1vw4643|}Z+|B?z2Msn5|`LSnbq<%
zJupcO0-b8Q+f0{W0pef(G7Y_BH|03lAdT<?aZ_r3@?w_fAD9Q+QSo~KhE-qO?h|h%
z=|O1uhZk_3cZ^Xa<ThD}`}=hkfE%%cKgDJ#OyR-c1W<kOeSQneSb}W_!C{BMbk?zS
zkF`A2Vd=YLNz$<jinR*uu!`KV`m}6?pg<?Ey!P$AbUy1>4~+f$#OnK$v*x)<sxHpS
zN@h@;Vq9#RTooZzzTT?9BG9t46iT-jz2jzRNacD%)>(H|hAbhYK)lD-Cy)(TE%~2M
z8lA~T*+eO(t)>k3gN<cvmfQ@h?uW@xRblwj?(fE0QI24cNY6Wj$-;eZA=YP_Ck|re
zo)a1P1-0Nn<Pob(BewIY+x=Z_^h^-siT#Fum`ixO=-F!6>UU%Vm1mBP-=5Td(js^t
zoWzSqX!Hs9qs^7ZSFCv5L;2swlA)MisH0xYxq6GEK7m~Vuf#V=X4#5jUC3Tf<9CRi
zSFj7u+yZi*M@Ll60FKu3N$2GyNuH(1e;+vYcj2UE<kpGo6^#Aq(3n*UuJ%wBh&l&<
z!>R9&mWh>{`cvz7M6zp8ar|9-i>1gfz@?y5@yrG<&&(ZfPzu-C#qQ-=sMUs4yR-?a
zP~5zL6r_b9{`_4X`3L`|?a#ui+7zFthjj+a$lW`tWh_<YcnixZIqd~s@WW$84Y|0A
zve5=2+)qX=2Ct2DD2%<E*9<;0QE3HNXGN(!Tkx6%bmptjO9W2n0P<!PZ!?`+4&>QI
zQ7zhXy;UY%6)-n4DPwY8Z@WPE4;Yw9F|FjV82;5)GR4AtS0?+aTANh^-Ovj>kQdnL
zu+6FFDOq@-;xE;pE*cESM0B1vE;5|#e}E#xxjkC1*6^<P@+h<^DPD@T?TU5y8|$op
z(f!iJQ(YH*|6U~N#|2%A3+;+ij_UvF9Q&SCp~Lyo8cm#<dLAUrD+c24Byx$N`LUj8
zi9W<*M|8%A_(IRik@}`17==o-u^+i<Dl740L&#eyw0mB}kBVCC6R-cJCU?oRt{*<d
zc{CxS?xs0Ke}xQ#p);^uY0>Ca&ncC~tM|K1T3MAu?1qK?<+4Uh0J^jw2Fa}e@X`do
zFZL&}0mJi%e4NV`MtDvZt^wN?u9n!wv3#tjGR>z^tmP(nf38k`J%@gQ5|U^MDeW34
z`mpcRJLwlsNqo&%-oW?DW#>-zH+q6`e^v0JolfeQg|B117(Z?FNH1T<A5_^ia*>|-
zZz0ol+9YQodBiO~fPJ(~#56@6nbv7Mmc4)VZ&dK$*KM-c`YK{xP+jRevSXg}EJkgm
zI`5}Je%G$aSAKuCk_}#*R*Iu3eifOf7n6(WMj%eZ7DR~Z2wt4E3R!r+w}(O!uU`ma
z1uo~3#Y?LACnMb9IMM36O$FtSTh%;Aq+K%x^5i?djNEBqL$r@*S?Zz=(?Eme7ZRfF
zq#mU>NsQ{oVc$`8{(>aeiRE8V2xeMU_#z2GH$=p|#tScsOuU%?gF}?4BH=o~Fwy=$
zE72qo_xc5-)~?g<Ma~LzX2OE#WSe<)IG(Tn*21aViPud!d5@oz<Z64))l{ivV#X^A
zuJs}0_JYs}IB~1fFj_hj3(}uh5b`ETy5N;D%c!Su&4E^2KI4cel1Q7fhnr}mXn?@E
z*H@~~Req|`MtjYTH5wJLQnx{Z8_uck>0NU{67VX+d6aM%`P^KUFwIEVBa90hAc<85
z`sXEG0;B;TewD2AFcoI3g53SZWp?hm-yNu&UEarCb*VRZlEFM)?<g!CXK{<LC|0py
zwImS0O(Xm8vhaL*S;%~)c3e)gI6hLF9z(uKg+8A0xXg~OAfvWX(i17Pj!AcbC|`iE
zx!rtc)X4NUNiG4$FNPD9vEWCM4fLh)t5w_t*kQZ{Z}&p70*+VUC(G}Pa!2!q5RzO5
z<%X%_WCrRAQ268IJ@<2%Tg)~yvA4I?#Z7IX)vAkzd>DSHzrbwX@_@hk`)(!5^amC|
zP^JGYzM5Bsq8l>S)oedGJb3yATH;NjMEAl8cUi(AX&_}_FE7!w)z$dn14#gC!iO)N
zsrs~9u9+4pF?UB_@CWktYh(C=FPv-;wubZwYxq@lp`TC+4fRM1XiR%zI+D;s2AdY{
zp?;8Zg*}>?&lW{(0;F@Qn-yEErh73l;sELma<;H_FtG)_y99~$c#JQl*0vi;%nk(v
zzZ#R7nD-@uWXG3;CIr!9ApB2WgJ}&UaX}73#^?tl^Rxkl_Hld6644kax`>=7!4hg<
zIaT{^snAI}_i-hOj^i1|`i5qIo<6ir_Ni-K)V(7Nu)IL(pqs~8wGm+PglyCzzs!6J
zYz?Fd*Wrc7K8n0w+b<q47<u0BQ5a&t-KGj%)@WKE>I41z26SkcwkqWU22M2a>2#Z1
z&Hgd9Q1Mw8HoS*i2VDSqd7jQBE=vIO8n5hNXe+WrH-|X1(S14&ebndhp89&5t%qsp
zn|jfW1oAcQ1o$*awcGRLml&R}09-{7(+$8j>9Ly>9yn>X()7RgSN{9>?7#p1{kLE`
zw{m6f%d@%f|K_$#KmP*r45O}o20K0l-+AA!DD2OLANl-^%7Y@mT&{-BU~dsTx#m-N
zS4Gup0X_=ou>gKiu}96QPgtT)Wkr&2!`S%!kl3;wh6a+72$#%SxXGmGZ_t<9`UFzC
z(5t0tdVM{27DTTuls(6+@h!q_EZ$@XX7X++3-^gRt@)0TguHWk;&mSnp{2jDaQlPW
z61Gsaw`oUrzltovYeC}6!sy!8u&cP`&sT&hT+NHtImK+z_2g%4(+U!xYGyue-nO*#
zUSq;g>hVkNn*E7af-HQyF%Dj5llvBPH_ehtPFGz>Qkw^ALjQ@u6@i$AEjB)MKYeZP
zG}@$U3yP8Kee<74t=3f>g1#qm;xQv+lxI4n0L(NgTjG)--<-459`dGMNQnPK;y0>7
z_)(>l{EVlsum2@Iub>I{o>IdsAXrFT{aArnd88UI-UyVqPQ0+)SKP<KGe?rEsM={e
zbMOf12|`PCD>5FLJz$a~XQRLWBT4B^>>n;jatnLvi<u7mAOige00ZI_Gs(~ZQc^j%
z_(|oh<<BoesCx$@^;JU@E|3f%R&#WyP{!_D&hM66FVh%myc5jn)#~<Awp+d>a;br@
zleJkJA0u*aKEKV8>GWher*7ho{SBiloVpE@_uTG#KNEXD`8?hdumO!dBvxKw#t8)q
zw9K0udkMt-^RA_j_@A-k&(ejyeGn9vwLamY{G-l0wh?urt_dMdWpwsL?wqeg=baH>
zaM5e@RI!D!t~^c~Mby8v<o);R?$A8l3&i^{tF*$t(VN8CuXS-u>+EPT_gRWi{cyG4
zEd2{UzP_y8f8)=c$S~y?@!WV!OLeBgXY<&=6CR&0J-eul1vUON?%d)s{+>SbI2mT%
zbGWzj?JaZfr_(|zm=(Lf21D!qb1g707}j^PX1jBdn;^~ciwV=)*%j#3edV+4C=2v1
z!Bk%XP@+kUpqoALOQ!s_<wG_sO?b{JWXyaPAv36c08T-taH9Ep%`t2#P}93OyodA=
zXx$d@*<ErJ0(F-!S!xRt-k3k11}_@xNU<$idTXuNm>uQRj0@xcv9ddi-n5dkJ?mE@
zhyTE>J0W$jyOeV!;m6D1%Bx2l>$qAtA|-CtV9^<92}!pC3fSm5aovOL*F1@#r|i9C
zglcYGFfF=sOVy?I!kBI#1nz*#9h6QL?k|wd!2u?&PKJZv2Pc6!L?G9xZ_r{6wFM^y
z%fthf)nQZS7&XLbuQe_wu485kX2@o0QP$MG`hXeUL_d1)T6eFPQQq=mN9#?u&LH18
z!@{-)=~mN67iLeK*?sU<S8nvQI)3t|HNVcQW<*FI1ep`npIqcZ&jZQ0j;RBFTd61J
zQb6<S(CrV-CP&c8&o;RWqU?E0pgPB#0c^gp+>>DeM84fDD<&{|wHM4MLP$=^Y^n@x
zKG_(H0*RSE0qbf|gfl!JREy4x``c?jpbgw*C7OBKEW(<ae84)HT4Fl9DLeL4wkOzd
zF?@Q;)wL5R>Q*v%BzZm_+MiVBi7AwmU1;jM8Jkz~(vqT(6Tg_H{>H%8QgA#?B0Ylt
zByOH<Q;9qzNU#<Q{Ehj1nt1vB8}nGjXG~|!z(MC5UqIkrjvAoW3l)l)Kk#KXxuG8d
z%(e{t;d&1)kj7T$;+J0*_{mQC0i7WtZ_%%or1HcIZ<Rq+nbZ7$9<$XV2{*LyE)rM^
z2@V9xHY~m}n6Dpr;X2|UyC80iVO}Sk&W(3ko!qo9wz(-M4a2-*>iA3T<SZMPhumaE
zLi?aI@;He^%lvLoiYK6O<rx5=0WcTXlolWr4*#mdQf0FB8oA7uX6`?T4&$yxd2d<2
zj7VcA98zqLdM$w3f_z|p5ygN45LV&?4U=VQ4VEz!zhH{((-wiFf}z*6aqeU%mW(3=
zCSb_wPO{7($|J)Lm{@>iFh#+_%-so>+7vFj1Wj0^4FZHxDvKg%dCb-&t5t$v?!W@3
zxQLF1WeyW6YF$bjZkpE?aLlpMCG53R;|whBjrYk))xDdvF%Y`1zO&8=Dk$Fw`J46l
z>2d8EHQX>y$#_>T3&Yh8;LgUF{9UQxB$A}6I^J=(|G^o5+GSUCdyyA)$O`K?OjqUM
zzqef)fE2TXigqx>sOxy&lN{+kxhWj1bA@uuk1rN<_}?T;L`gGU=B>7)#OxGeZtpY(
zgN?QN$?-p>JT+)}hYKBr913Q;8_*PrrbUsCRe=33_IEyB17(90w9BRy%|?fhEjq@k
zjw9tQCxxBUfrDutA60<EZo}*{6oCw-Vd2Ma>0bUBTo(>P06gaqP||dUy^uA<-@QOD
zO6#11^UwfG3gl#wMTz~wCv&~3!dj2)d&v^BR(d3Z#ITF^eU5colP=hTFZx_S3Et>t
zfYt7CHr`ir#@xSZ#PNr;$G`!*BI(jda>t@-S%$r?=Wk&n!jKq<&dA*s1hj6}c%V#k
zb;{CjzN<%HIV!iujYU^<M39R&lvPf_?@texFi>l(zW8oz*||`%c;RJU*Q}JhE6WWf
zcQZX*%SvEZbP4`@t>10<5v@Vws`~?~&C#E0vd`q$aK_tM=c^!qcVbkiWfc0^YH?Z+
z3Zv%9Y^^XS#`ULRZQ_(CSpXlXMKXAaE0SJgJ~b{Wv&h90?KRMPM82U6KK_AVK+{Sj
zz$k8gzVQuIp<yhCdbJJ@0l}8HzQEW{`R*-JWp(VB!;bbv2q0c*M_7MecKmS)czEIj
ztu0F^5^d?B1l9M!XW$0P;TP#I)3>8f(w^=jwSH*ka`~s~)Pi`_iy&e&2`wtHcrw7G
zxww)$=#G!HR*$rxPI=k%$J<MWD>k`F`(x5^Q2}QU=7*O0#S4>Y?I_QB=Z&+MOkb_k
z@Scs}KE><Lqmnp|`eu_BxA-dU0=xlLq%+#q>yrJtEJCC(IttK=7W>Gtl`!+=7qjx2
z`zTH3=jp9hh`!yTS_17jo{h3I=)e2=JUPoJM%vD3F|oj{GHs#}!gl9;<SA-Om1N+{
zizUfC5kw?a1u<f+d2@hIH)jg9?8I8pRs=a8_fq`KyrV5*)KqnrDz*AP)%^8@7W}(~
z_;Jyk_o85a^bVzjZJZ+ZFPg^?yXpmrrfPXfro=<l0W#4AA?!l)2W;Xix-+ESM-|$4
z7>fdwuBXxh=2H`R>2qZ+sE+pOE0!-~Tj#chw0nwF{%A(2&Fxxhog7rV_(c|irs&E^
zY?Qy6eM!<F$cynw<PID2N2B(Vy5Ue89n4jas#~hly^voC?J|DORLOqk{4d%hnfG0E
z_MM8wSc+yUcig6y>->DiNdp$X)=o~*ieLG`>*Gr2S|O*#wrZ}wy7D8oMLr$BUczUU
z8gTJ5RD3L6ERsf1s_7lN)#>`XNBQbjjweE?Qp@PBM*Fo~b134fW`3`0(8z%SyJCmm
z-dOh4ou8qib2t1WCogP#%$2wJql6Q(Tlc5ewmkcO9#(1qrZm_;N^m7y^O)sI-W^cy
z*~-s9Tvkrrdwss=S0(J<x?S@AWJ}NQmi&Jk;mHTHKYRYB!mj<)2k-Wn+w3-(UEaF?
zxjUnENO#V0`tPNFB2VL(ZUrgFnftFPr<j>p8y+V}gYQkkLG_our884b-x0dy4?k!%
zWDD@_66W<w7Ya{J{BlXCxGR>8M21$88?U9H5x8AG?tUkVY&jGn9eQlVJ!$0?aW(_G
z30>D5*+YcbN)y;YmK<a%hb+ZB-iF$*Q~{<Wuo&&p^<7$du1yKA1t$`^$*#Do(LwyK
zUNme*D(5c&`St{MY2zchPQe1~iv|B}I9D8sEtAMStHB)^g*VMeoGPQbw^8-F6GA-F
z<w{c%>kYUvpfU7VPcJ0>0xVRBGZ2TB!5O!W1%d!roGToOxaeq;>K1*q&|0)&5`GPl
znzWwD{!2h^33klF^|33QDOa%ERR2X}lj}o=k$CWYOrWEm?~(zP5lr22rc!n@pJf=(
z>B2=jDR3_Z!)UglD6tMN{_nqFCe>_8AZY?3vt%v#mI3nQdiKX@1Hg$b)QSDrdvo=-
zSMq|tB=X!`hRp#9;#IQD`4CV6mq9xs$us-uaQp=WTta>BLA{1+yyS8~{w5!p&d;;q
z!EcFG8jFH|Aj@&$QY96VR_@BfU*-#4)_`=wpA^BG5DG<|ocbRWblT9MsDyDLU}sb4
zQ8%@_K7XgJNSLFTyiJ}#$rX3YTZa_OXewo4luK)P%xRgtwz+(vx!dGi&CC)uRv?0|
z^7wtB0e?Yzwd_YQa8&?!v6ak;OBqOK=Kmf~w&f^G^gjmJE`Y|^YaYTr3M$YHQr&Ho
zp2HzwPF#QCK-9I&$jgaklxx3nS4m&4{UY;-Xu^I0(pTLy>btX*$>+l~VX`ZHPi*o#
z*{`##m+J0byS67aysP?4!<YRSjjJOo<BVy-XvbPbkC3by_S6K?QfD%`oa2Va*8c<4
zAfb+`HC$n15WVZ!Z5%iIUdDF>xb}zMd|{h#DgEZFmp2*rJV!ZhjVoS=8Dl??zx5&W
z*2jCdKE1s4-<MmTIc_f~-d?i3y%KtRE%SEP-_pTBNWqv%|0T9)Ec+5cC<@@n+hp^O
zstmUl$SvSLc|qt;X661D=;3wd?U$FJ(?lLlB@<4g`1Wm~HX@H!NyQHkWZxg^v@6xI
z8T#-Aq?2wxQwUpvliUgob5o#!g`qki*k_uMd_}ct9Q{=~5>YKI+s_BngzEDH9%B_J
ztE?-c(tm>VyG5*(u90-Dgv10<?-yWUwgN#^-pIaM+I+2(QO%346gdO#=R`{2u8<EZ
zWCqP<cv&bqO6*o|#aS_-UrXK(gE^PSI70F4;q9<lfy5a;_At8S+gib6ku5q{Na;5$
zapvx+hNROWDXLv?mUMKtC^DuX>iI|Eh-IsRE`e80LKFbygJQGazRkwCcQk*Go>l)+
zp4P%4+$JLz=v?&!#AGjA;K04)vm`?MTj|eIpbKm!ug1Ar;T%vh^kD(_>+vcEyW<{Q
z$`!<Z04IPnv=0^8vJ1E;=Xpj_xO!dT*;uXzATA*6Sovsr2yiWNaw&!!`?yfXJkJYy
z6#IDNTd}6QSxLLm&=@B+_HMY)5^M#|3G^5K(zIcsYRwRtt*p{)eB9_I42Py{#P1j-
zYd6MSwiQ6$9nJQ}iO}+n+sgx<BP_c^gkNC6RAj-Ih%xj2a1s!Yn8*-)($+WDw$pHj
zh8O-c20boPkJ2Tt&^ZFVks%eZFz?J?`o@iLF3}enY*hutf!xodJXW;1OXJj*u;v5o
zJTqHN(q<n-bc(l|$oagN2bRsz<r0>05ndOie5?TvjVZ!H*yiYxgY%R^T$;|eq+<UX
z7=w=;uTDTYiu|c@K;L5)a6F1<3mxYT#KMEuGE9DP3i9iL#t^Rkddw)Et)P2@!P;+9
zB7Q|bihs;EPH%^?pqAifby0lp!H^l8SNyjmmt(;IWmw^4m>MG)MweY6`dy!IunZMy
zdklN<IQF;|d>?Lr?y&z)+t_WT^S>DGpT+SKkITE{xtr}Ox5goEf4Cr7!FyvF992RG
zo4nD%ZU+D~kPZndP<z1k<n;&Yh@DP=Aa@?XG5!r!cFYlqAX!hh+R9lT*6A!4GM~F(
zuXWRPSoCGr3#{0kYx`eVr-dTJDd?GbsI3Ql!s+ob{bSEUV&^+2o=*GuD#;`MiDlH2
zO095xe(Fzj2O-<2CQAAQr;F(X$K@#L;sTEmtXZa|u<Si9&+x>;N$ZcsNDqL+!#I4B
zc#Cb}c!C~0u>cmx*WiJwUV`&3!+E_VcoFvfL+OQpMv%BD_w?pfx~BFKo#z88w9x3D
z+<WKjD7YfjNpg@glfoXTDIKzphoIdeX^Ek|woAQ<NqDG965mfRcx`w)bR4p9wu5~O
zqk1^_&J!G3Ksu<)>^Xo1>mmE?p4PLn<G_OxW75Z_E3QO8GxgLSk*RuyF4^_O`>yk|
znh#usptD!-F<bk^pT&DXn{4koOnIufm{BlU@0V|`aXrJbPrmng>z*w=>3K9?<2NhJ
zYRs)I7hsN8J}=8=iM0mN@&47MkyySRxCr_WOxnX=M6<27E5J-HKt}>OsKHA|owyUt
zH&WhrMJDi)VEJhh)U2+SOqbliO1-|wee(M27y3i)ox@V670nMUBD{s>l+D;c?7zko
zAEfE96>{Ar!N1V44+~8s{|m+2C!iC;mHtVM-<SM3-`Jf4Kc^q=P#310bG~Lwaj)QV
z`}?t%m$;o{U<`OGXCHEA|Iv0I#3T#;UgyaSR{z}eIjcdL=}l(TQGu8{O4Ee}O4Yj4
zwHB=;GPO;HlCMjDcd~(Op%D|qw9Hy&YlM!Q9-^J6Rb+Bl1d<+gflMsUp&1aJ*e}D)
zpjD7~03vwZD-KnESkD$qWGBPftxSYM3!skIK3s45cw_YAt?wTzd1k6qXKEZ~?nKVq
z&7HZ|G;@D+rs?}k3(u#v|B`w|gwAQi&FqrbyE5-9ej2(4-TZrXC7Q?9MdKnc+sl*b
z(Dvx9^>zJ_Y$)G#qutqO4oOrNB}gHR0aa+5gs)d*D&wBL`EbpXl*$oZBGFw(wfir|
znj*J8H^-x}zR&enw6S2mO=Y5pXRG&>{(t(=>n77hq^Ha|#$6$wz6$mwox{^9y~fsR
zSCYQu3O#ZV;5VD^x?5issuA=0ycp=1u&w$Zuy&JcxDlR~!u5j4?X_fO8lQc<)4y`}
zQi+n#ziZS?j`_@qQX#d3sa$BWY9Yh|x**Fo7r=cr&UC9_)}ug)eJiv+6n=6pzT<?D
zu-8?whEMo=OTu%6<#*7jS@}#XIu{NhVIid6b3iK(JB~*fqA0<qd^E;81m`Zba3kd`
z#ra(}<V9Lktc?DpM+*Z#1Qi;y{xj(#&j}EUH-%<eVSz5--eTB{h7X_-&8e9iZn<(3
zdg`xNX40cCS8gXAL)l?i_W5bm-O>d^76(WhlShQa^^b3&h7Hh;hDD3ue@3lwl%{vq
z&ke~g{n{#`UriDl=1eWJqe_XUJAotXV%Zi<r+e+#woH`JY&Ej$0_-p&yO@%$iZ$O$
zE`G>4wT+|TY%z{|XRh*rJ4&0>;F%QuN9~wWKe)vt??1kc-v-zH)Gj6TXg)LhaWObG
z=Lf8%LB4V1dG$L}aJAyE8veuL&@fc{R)NCe(NeYN)=t$lGcW15UR{3UD*~;Y@ZyKl
z&JRZycvm8uIzQ0umoL^<TKo4KX8EU>`K5r&7EmjD_HPx4fZYL>i%f)4h){AXX6}Mf
zv@_QpT>p&_P&39p+gr0+w#AA2v?#^A@Sj=92ZdZ6^CXZ1jCKk>8TI4LoCb%nqV!v2
zqvq+Ff>ycezKe5<W2V=?hOX_;2^$RmW~Apxj$Q{pmp2raJ^*q+^uA{(qsFnzywT6t
z7I?0-a$>K1kskm4RWVb$MR4iX-|oL`=_$uwAnewW8d3Fpr$XT&*o%9S{OXl^_uuX}
z{oHSX9ki(*Ja9aCc>bU(|KL%}!IQTK&wd^}haDyxRgQ`Lm(qS)c588L^rv#wzD;DS
zobzGdbN2#4KtBdHI}b@<0mPa&%AWIo`TqA=@b5&e-zGK-^URv?glorCHME7AqWbT&
zC3x@=>Rb0(KnM3*7;?`~XcPtqftkEAUSsn(8V4(YV!@*O(g4JXKm(0MLM9JVY{0;I
z-m-v~%_YZ6qjoq~(Y-nF<HU+xxn|It+EedV9d7Dm9*=KQ`=9YmvMWhmvS)gdw>s!D
zBW+MX5x8xo>hG#FS*LNY;pqvXhRH%#*5l^M_WfzH?~B_!iDjYQEiUbE?wtPc!}sas
z-#>B%=FcdQ1Hm&BH-<kyXJpJxjD{3eyXPkgm|eZhSG7`#Li)e4;YYt5EV9g(^PSlV
z9k*=WebuFsQi5eMPJLsvaZIP~WmSO-I6UZ>?1X4)U3k;^`ToprF}n}>)PfiZgJLrZ
z!pd`&(D(g>0+ku^=Qg!jC8pC;pLUj-giFevS3DnXEcNI7j7=KZgDoY?IzC~#PO=C_
zVOh9T3edrDW2?MamW(wnW(=lUGPyHz4H-Afl>&`9+8eyiIOLeWm1?j9A4mo#yg*|*
zHmwH8M+<VmCl&)4RbXiA#f?IvZ`?2PbY=>)kf!}1HkraoE;h2%<;a&%`S1<Y*y{?H
zDkX;#E+bjoJKJ^|48aF?>bJW!kmRFN;NB-JeUT-Be>i~rj*&i|dqK?{!0iu!!V7is
z_Uwa4!C<Ak<-{qD6l;U{{<Bqgp|}zLU&n2SrtT4!Z%@qbZ*#g7zIoy{*`PGqF<C;e
zR4{Gsb<KEBX`X0#%G3;h_}jzBwx+(6amc?q@;D0jI+x%wAlnoTuX#}b7;(@gWs83Y
zpTZdJ-Ic_!gvdIn>Z!;9=h}IcQgB)>tH}7rzuT+}ryTCTD4vdV(Y~apyrqfBkC<qT
zH=NMFgZzDP4Ml|Yt9a4`JmN{^x5Jk4WI5lT%`w}e@+qo|9H^TeZ*UEKWQCw$)qG~C
zjFR0S(u*qVj|={&0O5=EEkNsWis5)r<XIW-asTWQSH=UKXO)_g>#j9S0dGd`$!BjT
z?Lc)G-&Y6Rir4ZKok|FA7J&5TUUt!05gB0dk~wi>*&s)lT(OmXR^UIWmst&nudUaM
z*3&pg1K7nNK1^ZXU-EE(xW$#1cs*-_sQRDe7a4h>;E6f3`OJ27$31Su+$(qg+0R94
z-+V5}J<<CYJIPVvKkHu0FTDB0{*i;Iqy2Tw%1Dv+U)O5-vcfK%Y8hd5I01FBT20;V
zRTWbl;{e1QgT6nT-1isCN8P<ObanFX-Qch=tw-$0`Noy(nVwT`9j{#Z^Qnak2>A?h
z%Ci1-`J-ASUgcAZwaAGn0~uX;YbNoerB+Oa;L5p^n2N%p`e?*ylpG(+h6`Z$S5zLv
z5mV7NyMht8uY4s>_IC6v)EwGBW~+FbldtN)XBUrnTnja6gZ!o~i1baSa@%YTX%#In
zF3v-^xwgER>PD%hcLfX0&s0%w-sCI4fXE8I((Q0=icC0?7&mp7F8>q1`otkf)BKhZ
z^#0Iv(Z8I0<uEtz{T<gH#E^5|1qo>WVH<}kd;u;dUFfSsE*G~X#2u~YWybOq@n2jo
zu+1748Y_WWOJF1v_t{O`g$lz_tH{PNo8`O?T%nho-Azq?g-^OhFR(8!oEDP}(d*)S
zivX8M=G=U)WMl2Kx}92LQ%KzvOi5~7R7<T+7ktXkUfVtD2-;;!s%AF<UN)R(J!P#`
zfGNK}s{rhvsC70%4OI_=vMW#2=%+(Y*74=IHF3(<Q|kCno@%-ECN|rorOqyC^;c|b
zH#_bJ)0yjOtc@soyzm#$o0~jVZF2%&kLU5?Q_XpW{7_&aeU1T<<y#0k(nw=Bebf&W
zx!CM@`}F8#7;@wDlpik7;<W|rB<|_dG(Qb0+qvv|Q;VBBqn9SbU6}Ulrt_`qOBsTb
z#B`0?V$`Ev2l4s=xztu?xrsy$cLuxiO@m?u@6k}tXZ!9iYvJfp?1*M>!Zq%x+B3mH
z;ivyIa<3O25FMF^xQrDty7W@->wFCN`?v4e+s}ozF|;>a7xb#`Xl>{sL<C5Fd#@rE
zDAbu@iD};SdVSX8!Ht!OVAF$BV`&~8HL{VR4vF5Absi7z2StYa9(Yd=d30uc7xr^r
zgE9k9{+&-&z6XF%>5n;S5>==$2NO+rI2emaS5Pzg6x}pu<@xx$5V(TVKkMn?D5}os
ztNli8{g*V)r~0LM!x*_tRn+3OnBG@iEI_6+cTMF%x5~+3fa6o1=ktS9l5|0PCfNXw
zdivzmXC1i$zuJ1A!=NZClQa9%tUBOPAkgt+yXi96i$DPsMZ}!B&nYnYQKl%hyyzUi
zvHnw_R$f(q99Ja&0AHI1O)9-FmnbpSXS~`*PHTf9p4BOJe<}0j=6*06>xv566~L9X
z4Ju=6uCaW4L2fF%@yVnOHN9)Cxky`yAFFy1Aon2Dgp9!32lAu+TYNPn05vd^Rr5)7
zhVa<|XCJS4KIEf?2RVG)dB58P`VkP5qlF4eghldH!4L`Vd)CH!MlBATrHhKqSi@Mt
z*?6&~>K(A~vG2My>#>#33#!8nz=5E#AvmbF^9)8G86yq77Oh<ZL`Wkgiep=@<O*OE
zmNfP<*mK5`NMzbDt{^1u(@|Tx4js)SVPV~wcMYb?EhGGvB^0QQ4xuXSBi~I9npYf#
z$KDl}8{CaGD_Lkv4*WFC@{xh2Md!~hlT@TFMs6j1DKH<5Kt*J;yEeALR6pz^r^lRB
z|By%*t$h~7@8PAOBsL)86Ve0w$3)J*JbBq)1+#B$Fhq(ezEH!-B-!wNg5b-A_+-T9
zPwH56@MkBdTv{|<GsFv)=B*Ab53^QTo5jndMy7-(I##h(#L2;RH)W<++J+i=`h)&*
z)(Y>X98a%%bHOIVrd$%4A;~M9o4WZ1d2wuB*d?}&<JaSFb9II|LDeYoywBR1wZxWJ
ztzi#>b|v|nUwvM$g6Qk?i+70{queIbl>j1aXe<pYR+8_0i0*b*8}4hvL3Ag(&icwh
zRi)-GP1+@#W+K>)2?Urm*i`QGL|{g%b09{-6ZLC-&HSba;35zxHQDQgJ1bR<=UD!s
z|Mv3NTaITp_+=zh3a;4a#NWMq+^w}&?pJv8Z1ac8@|WzdOoqmG+h4$-<}=gaHnzus
zNbbNO*REduC#u4xkHYsxVTH)Y#3o^witaDesb|$I$QrzFa&Q_80SjpLLL9u%%DslS
zLa|&=dx21@U}k!FR9Xx+Cu*97TLQ;Fo2@Y>ko+k<YPf|z0w?mC0|=qoq@;SU)6C*=
z60dQRvpA^@9P$u%JO=|Ufyb!erA_)p>{$)r&nPxjEvzIqil%3A?>P$~-)KhW;J;>2
zb%TEIoJD_2QI@(>T5NrFZ0|#$n}WCCjMGRvy3chYUNE9HEf@iD-KE^<eSGJYGT_8G
z6UNZL$>IK}p$<XN04oC-)X&lx>rW_4pOB%<dX}e92;Vp|8Nsg8nz_PS^fZP*%@|Pg
zQC9B5|AP-&Y$yR4)zMT|jS!k&)KdVJI@=8~2%(C8OmBO@CC!;~0+D(KoBrwlkaXYi
zRR8fFz`xGM!8ztJJNDKwv*Iiq8JT5gW`vHBByt9h?HI{Q$H*wvQ7Y}jL9#+irLrnX
z{Ui+~=eqa)cm6!*kMsC`Kkv``^?c2l*G=-zKhpOfg9r3D(1#uB*3_zLEr(m%y&?LP
zHPL=cMDiLd4Z+L<be`7_0Bi7aF39LR%eA$@t(AClWGLaOHJx^+ZmnOa{9)|I1$pN)
z%w=%va&E^?IF}$|(<`bz0vDr0T4zjmpfH=YLJ}=E&Zo?Q0*hONMe(3cIx<}sK_s2L
z1PsguF>q!2VfKtewreG=OZeO^ZPKcK(#pl3I{8%^gBd}))Yz4wY=r(?FI_-`m{lSS
zNyV(LqO<6SbW780Yz{!(%L>mA{|$#CX~8unbPl}Sqen^|kuhm}W8qPYbUwuS2B)E*
zqC)9lq3%d*XDLP0Q)#qzOxJ=fMZx7R6~d38a0z`SCOV)Z5!!BbC>=>Vi9da0W(UD6
zgcU%q=GVf)!RT0c5YH%a4)$x#MDI>sG^Kp$$i)LZ7g?9``(*v-Oy`SD?MZ6mH^wg7
zQ_5kg`Pr72A@w*T4l2>oeCM|{A)Q!kMucUtHi%a4*-`#mHi4SY>dBQUEN&Hb+Na8J
zQf1xT$1N#xqc*v{ZWSH$8r6x_Jh0IJ1foy&d*H`ml02%?1yV3GAzH*R>$(dwYiktn
zgT>asca9W&YzAKgacyDetgqL<m3v>O%;_Z@5CPPQ_FR+4(#98m#P7co`e^S!-A;-2
zk5BGb`oV6mZiu0A*)#}W7;v&I4#t8=_+s&U<J70E(K;sYkiZ!!#C&o7;f}otREVnc
z?F2yghVkST1}>XBic<E>)|vWcJebwTkz!OZnkFw3nKtD(BfL~F!k%u)G6ZPLMUY?d
zxvo^mYdywarTneCBKowPq_sV9m}a%~s;-Es=o9*`yb@g*f;Ugh;9k)x{n1xv(XKyj
zU%jRqy!KmJDP*s~0|BoA4<x`Xx!hCKgcJh=9#uz>fc0d}ysaeB1BM0P&!t%39qk1s
zJ+FYKsZR|RtSs)~H5j_eVgbnR^(Qy?<-P9h%bmQGO@$bSvR+f`)jAld!|?RwCk>e4
zuN9!uPuFnEC|*HffiB3BT{+Tn4xnCX2Rd$nF9s$k(&u~+L7z7)+Z!qD`kj8k_Smy)
zCOQ1Iyu@U13?1ILoXf}QtM#gaKu$@ioldnZTSU&FRQ|}$1uO>cL1U{;wnY!ix@#6B
zfPJsL8jJ`<gjp5~Wu5b~9=%F-DGzVGrg5+V1jMX~rsu;OXIOLk%wyb(U>o>}Ck{N@
zvZ$(kX=`~|G1zNf=ziC7yU^Mgfu`t<&I4REe>$F3>Gty1E${F23n|m6=4UgP)fjq|
z-s~EdD;8lfJaknaUfeGlw8mnPo;{<NCvd@6oi79bJG;EakAZtrB#*4I>ZMx&>cmYo
zMyDp?;%Vn<%TB*}4*P0nZHDIg!OnI-kAls?St6`sAQX-~XcJ_MW%eo{cKlTvM2@A-
zRimqcnbxxdGGbG+dNEsplVZVB%E8ly!B6%EKXnU!799LMA^1gB@JvbY%d^3+E(O27
zWN(oVMw=n_aF`c&VhISa4Hlf}b~<U$zy#21&Ib>?VHn2bP^iqnun-D0Wcl>l*P84+
zfEmF-4TQ2-@sL;njfL`ud;5uuxe1s2$>mxVr?2JhR#NrN>eADJ1w9)I3nkXEuZcN8
z29~b{%panx9m)pgR>j!w7=esXD8vS_$Mulkz6l0<fR3#n%S3d740J6m4frL}_X_-Y
zC3ug<>~tuoJ2VF|pN$Ed#m$3d**lw^*^^KUEYlGI%UX1Zz~ty-!7ep$v?}v=LZR>X
zJcnM;&wYVg8?5%R{&ACBJ~z*j!j#*DKj<l-;EOHs-~mpR(93Zxt$c%@EW@u0a<V9)
zQC7Y$!b%h%(dJmoie3)+ZL8->e$PIrU_|<}l$vv2a~{;PcY=~2r$6w+@@#8I1VJmZ
zRbaVfYA2>r02g_S2u7is&WnQTBMe`TC(v~1mN|!bc}Ea=q)<s0POcpnL`LK#aPlaF
zHIBGE)I|upRbBK49OMGVIwCJs35$(!qrb6qmGbSEp+}Y}UKj`ii1O5mVl3zQP3|Ld
zpm%a03fIaN|K^5#h|KvNMdz@?PAyG!fEs`2{^*FJ(;$rqc<O{mD(V`8!`x9QO^R7z
zH6KF(+c3mak;X_H^bQEAc1RgvV#yLe{9qxs$$8R@PJ?A%bE)fP9Hw3g`8`MPWk3S$
zTQT`rcFTu2b0z~Gbjsr$;y!}grYB<ReD-6;{f{SMwgqi5MY7S;9!zOLZH{MeUM2?~
zhj6i^!j4ej=-T^tCqeQPtb@G_!z4)O>ggC6ga>BjU`*~Y6#C8Qf>$Z9g=;t)5^@K!
zJ#JaNceLFXUmX8;GTRb15bAh)Eg}J#=iZT<wA>EluVhnLotIahOC!!}<hS|YlWdT2
z>DZs&CtumDnxBsaB~=3XY7Ep%`tOO?b1$fek>(zANghZ#jp@h!jPA^xD9u%T35xND
zn^E&|%j#zhYEMiWdd%6*jh3|kWi(7xW{SXObr`$-SlKgqI9`eQM4{zyNjkoP&Ld4v
z+)8o%qPN(~)<Q(&`_t!4T5BMu-mr@1<8N)VjsppkrN)B-EfhrIMgW^hqN-%~zS_M8
z@#92CdCuORdCOAH*H@8DynhB5W<rR<Ve72DD5C-HsB`b<8&<`(lpVRW)#0h;cFFTu
zOvnJn{x&9;Pm5tp9?kaP06Iqm?)$Q1JmK(oghGB0?xtq-+}d`<{4FtB0K(wXvoE(8
z0mEW(yrRp%WgA@;ig8{x_sb<N#B3AH@c59;Gq?HVSHuYoa_gH#m;@K*mOT=CYXxbY
zT)V|B$qMZQfc0$DIvoRP#T0&oJ;~Jhlv^JeIA^{5^_#SWl*wf4o531F?t>y7#vqfG
z_O*YwV=4DD8dojnfkIr0w8=)?7g!;5F;6Q5Hdc-wVP~Iex^&!2?d|f!McnbrBPfS^
z%tbLezysLp_Z>~p5AOhzcQnNpEe<MYbZCg(0%acYyzZAb3mbRQeUi-<?fMN@F;?(8
z8vy{d*^_N*L_|&;_KGzm`$=0kYJTR?O(q^PJGtb@D^V00l06O1V1Jzo^nUXBcH8U^
zpI?%$0u~<x9DX@jQ^yter+)4^Gdcz@J(ABFXT^WZzvz&B4(ZgM@%qHx{6oX?H@@rX
zV&C<<^CdD_PVGf@mc`K?dKP%3#;<(?)C=)XFYmTw@iE6fyuNc{*8<f^jEES*>3}Te
zD$_B|hhm_(d=Vp$&zWrM?R01m4SYdRlhz_ybaevGFJ};zJ#KYE0WL$lB#%C$oI@GU
zqOta}i|lYPo1u2ecPvf^$ZC|e(j}V8D~a+OHlsm+!l^7kr|Gd+vjokxkY&Hjr1nag
z9(r==^X-QJCL0Cmm^8&p=TQ&*jGNxVkMdxoJLJ(zMcV{;yvH1=8e!Rs%C3QzY@WBQ
zu^!O*O1DhS!Hu;0?tgcu(+qIj`R^RZ7pGc2yh8yu*{$NUw)oEj7EeK4a^N}B=?O>f
z(<zw)p_!>oCn3)nPBtRD-5-S9mWt2`x{LUF%(8a(2$<<8lEJRO(*0$224+6VrVg`Y
zo$@`g@N7OzcU*f9rP@ZI3x7W@YVMck>LMbX#&o?cwS3$pQ$NLeCi?aEjg`pUEb1y9
zf65^6)T~n|fI`x!k;^VL2J|(41oFv4fhoR=Sgez@AWN>nT8(%|h1Xfrc(xE8R6>Oz
zwI3GB?9dpgHagT_touZ@+!FJCY)scv<g9gEAztaxj)Q6~c1&S)2R47w=6;S?qIXR1
z*@XjF!pAQh(|>U}<N-rWKh5Cf)x(dQ-7cmXzP^$8uD?Y8xY3*2Y5y&ZUp&71-ThMn
zkhnoQZoWTHLfyS9-FR`RbQh`A;DpKhk?P$M6I~}vKTb5-GsO)v%sx%Gy=iM|aZsZ@
zy||xWYIyQz0N{0BM-cdH_qzwFl}ZaCa<rRAFNa?CH;q&TzI>QCck=QH@dZ6*Qk%`z
z!K{l)*#Z-^5KqZ^bNz!NSVwN|oZ+5Or5}I1asU4O{BJQO_xsUv+JHm+IXMmu{1f^p
zqn8pH3Ls#p#`K`U`LkLJxlWv1x$qg;JwkWCE0AZmp3G+ooQ38S&l<q1NM14X!??Ff
zOktXknb#=R3*%L6(LdwaOw#xR#}=Rr&oq@g)qUI#^a1z*8AYq5GJ98Re}~G&*k^B!
zi(7m`$$v_Z_Ap&cSbS_ev=uRFYdP-JlztFK)vShE<+q+aKJ?ttP6!`fXuds=;-(J&
z_Wa{Hx_I58x_<(pSPz-E(musTtF5&<7O}FaVrH=x5h(UK7}kNUUs~AS*?tN}sq2sW
z=nP!=!;d4py>;6+N61yDozSMUS(F~O>g+~{l8r3bVY7kQhTBFqjrFj5&X5aFyiUri
z{ayXJ-yjvEHftXnbSDsaomTY4(|@r1uy#|m0?#CN+cQrgvRDeZcm~E9O}__WPh>V<
z!0^~fAlrrFXKD@9h_tQ6V1w^gk~DiZt}D_&+|joCU~P|o7_g@E>Fn?wA>R)ce$(q^
z)Uk<=N!O<BE^^0A<*H#v|JFzY1i@-}3PDSVd(9}Y&lA<63!@J1jjfQHu$(vhBIa>M
zb}<6DE?9aZen(KQu-5J{t#o513te7TCGOi@W`Co~@LM{$_1=w3(Dx%zgxTMV;|=1c
zW0BR}9a~okX%Z@5m=WrY>A{ayZ#>Lob?u2U;ai2EmdxUO$vd5H2x|GAEs}(aq^B~@
z@NdkU<>&B+!WR~<@ZUaHeS5+i1|)K&@U~$PVAKBkyT-p?cQR5>?D;4Y%6d*mUjz0p
zgeQ(AOVb}3zd(L2dj}J`Z*u0{uD9#;-Ia$<`2)7sRBYE~O@nm4pBE$nU*K!^4|pxJ
zzKq8v?&9fue!r;leP;aLwx>BW)a}S67c}_Jko9*0j^Wo`Vv3ZscJ1n5z?$H&oq?74
zn&5Ec+fTVY3z3CMW?f;gIb_22fCjT`Vb_lU+21-#>=<Vp%et$uLjfdATr<*$jTw+&
z4p*BQ^ou*@INwogzO76&E(90WN?(j|c$I!R^x&+ToO49)y<^73;RD5=hhm0In~h82
zg47jXFAweMH!e+XP*?sO^Uy}kT`YNqNbb?8#?3S#4}4RPzcH6*?MK&3qLMXwxKJlb
zznE!Kjxoyfw1dTZc{y7{<?;86kz7*bs>h^$S5k?0o#bh>`de9sG5)_XlE0^FL+mWR
zD5=;$=>&UZx59^fl9?;UM3-o@-NfsJ@XzozSU8*5#)WdQ+9e%|DegTges6KQ;5BX7
zPBNAqLS*WKO-l@~o_{b|BCgjxSAzY?Q}i2aRr<?5?el!IEbac2+7IPKvwuxR7CB+)
zKB^L6+f>XnTI9T9`(3(vb>C3~qG<BYDX4V5EI|$G-X7*)iJ!_-8}5^T+vMP*F@>{g
zZ3<H^7M8~n@-Eao-KFE(X*X)xk%bgfYh*q*));!!HKPXn<!bb8Euzd+j|9ZcxV3YL
zi1^q(k-Nq@0gZpkI^3_fEzx~!@5)Om2Dm#Tr$=@_C;0@xc+IauYu}%ummGmCqF7+O
zCTNYNhgHM8W;=SE8O(K*W-5+w$-*{I;Qz7J^b&qQv=x~aueEDMzgQGFn#MI@6$Tly
zwf7oGdgU)4$5qRc4TlebZD#smq1`27yoi^r&puF^vhK|(#69fHn>|4i4ei>emd6yg
zHsF#|cb>14O?Sd}fS8L&8t&&3`%t<R@I-j%PNHntW>u5Y^VBoX%)UdVzec2ZOzqT|
zd$L1p`6QQDyN(`E1dh~rGsT5jR*Og2t6#MPN2!Pt<BGt>g<sdNI>!PUXp#6OrpmMj
z`|<^9r+Kb~egMA7eqBgZKUEhfjqxLR`Jp1DHKh0LgByehwE;AS`_dfOzHa9lS%xgC
zC_*!)Ht`&&jv^B=e*U)>U~jufa!sf_i^!M4VMwrwVCFxP-~c^RLry(+`*adNZfhoc
z&W{I{9B3^5%+B1}T||5Bq*IrES|aZF{zd#i`W&h#psQE;dU}ch_9pbwC3UeeRj_U9
z@m$96_g&v;K|1SG(E=GVW^9vK$Guq_w(6u15<74z*&2Ohsijj&9(JQYtip4(y|#FQ
z)pA{l6ZMrPn~cv%`ZtvqBSdtb;;DWE09crgbGYD0Wx)G^2HVz8GJfH?1AjbFA~p=G
zs^6?L^|$|TU^<VWoiVL+%?{#UBr~IMg<9ourv7Rd*Tij}VzvIWwRyF1=|<;xCH!Bx
znLF&yLp=xcFDKaZ1yYb2rQYuLtf!|#KMXp`f<pzu%kr<W48Q#vBFUwhwh@jFYlpwi
z)VF;JI6U@(R&kKi{oqK@bJgcNqZ`!)#M^<0Gdmu_VE41HK)GtJN<fKy#+dehT}77;
zc6u|DJyDUtoi7sgVhGdzY-`HcDgEcUqat1q&42t@uU+sxw_W62%vKe$VJ>JL!lCkD
z^=N3pP=zK4k+B-x1FH0TdhWx|3lC;(eKFX7;l)4G;Q)DcC+n&`Y|h+BQQsy!DOR3-
z4Jg^UGygn%zx3%MO+K<d_npGwVSHIu1G6krc)+B(TEg2F@}w>ep|lgE8x};YC+%XJ
z+^uw1!@Ea7jq6WLS@$9L=wxmFzLri6KF$>MgsmF7oU^wqAZF3KySDKe^=XQ=p}ipn
zYze&5WXKAGR<9#{V<YAKz}7Q~eAFFbxO^)w&+ai;<I;)fzMCM?pk6w;WTx_Jyc9o+
z=Pi;meAqj7ULzewYqbip+aQ8vAXwx>n~grlRl2dk)2JAJB8Gv*5V5YDsi;9*6<=#@
zLMH#69inLX%g%I_t`Hv#1o0CGz^XoTP?fnv9W2-y`};Jj)Y;Xx2fVRGx`YyP|IOE$
ze04xW#yW<X(FOM%hbsl0u^;0fQx4eq02L~{3FS>^J)TP^ij4F3>ImQQgc+Tm9KH)a
z*b~AZ0KalLM`E8H9(bIQ?;#LT_Ll9JlrvEjtAGPR^tLY~J4jFiudmUd-!j3$Xz5kP
zD%eItq-Tkah5>tX>J>Gfor>r0$B->oNrsSu4!jGxm}s>sVbSFiMV_<zRQ4c#P&FQW
z)bC*7-W=1_G7}8hc1iAJccAvEaGh6SDP{%Oe-$%g%3qJ=%3>Kr%YK!Z*J8)WSQ^Cb
z|0p=Q;xg9`A+@DG6D_3NFhOODu0);nag8wl(0riN{cmoB)pYq4dYRRQ7NwoTwe>se
z{s@Jp2;1q1y{{JcE=1U^EZVI{*#B9y2SwsVS|iBnfo!^`EA;U=49%r``n~by2{~rc
zWkYk)ryR)E{Q~lVB|L0MFO+GX8A)M8s#Q2lZV>He$M*8xc-Pd%?gSB~y$Kw?UTTXs
z0(`@a*gG>DG`nQKq;X?a!)ZO264o&AwBKKv;1varo38^#Abx|e4Z?u&-9^{CL_P|n
zV&-ZwHR$_?bRhA($M&F>0m-B)%0C%=Bc|V9W1l6qUv_}5QA|AUQ0p}WnHk8_Py%CP
z2$*=HbYqdXAL!_S5aJ(L^x0tOHYsc!7G9`%Xws|dJy@n<a1s~tFsCfweGai7HgEO>
zOU}ibA>}CaD(dr~{5E@bTddvTLy_SGOn)MEmtRdF0Xc3L`EsR4yw0+2mkeDM0jB%}
z3F--=S_4EZilDXu+GERnEKlB9*EOah53g47a0o@8C|6#eifm4zUn{{9WTZnf-T)bx
z1radX$$Hu;*3m#~bh1%&iXAz<H2Q=^kUFnF&2j)c*`J!&o^m4k$XDp4CZXXRKB*8|
z`j2FVJJd5w$00~M<NQitQnfPyhbQBzPylCgcTAnJJQ+iC#+0f=O$MmrA6o+I-peyM
zX)?}?`C+hT&)u;3V=<=1W5#b{O6{~u^1@c2K<g$y76usUx)j}yDHiDn$rM4ihTCOE
z`v=jr^V|)jh1g`!hF?&C3|YHX*oI3qXyBjHIM5LKFvEapzU)r$qYL(|IU27r5?8^_
z?nBuFeI`NRv@X)Fn1uuBvkV3P?pD6t@HGGZ!Md*`X&9|3T(ntl<y<w1Bd*uV>zfWb
z=lf&60+e?}ISNQ6J}HNyTZOFikyc8?+#VsrNum`{c;T?DZ*bqS>wFg|Anze!+XX|D
zpKJ|3yIs8V4m)DMfx)ch)de_Ka$aSGl9b6azIPeN4fsd!0rQt?>}SDC>7T9~2;&D`
zZ1492Y(G~x>$72alXQ5DY>o*cfEF8fD7_SGP-5!yaZ|caPMSZBDJew0wb$_N+v;oF
z0X}%3qs8J`zcn(fb8deHW2-{ti%E8qPa^a8VNyYc2)@8N)Wvp~kVYIl&m~P@NOr?s
z98D1|d>4UjkkJ?qq#Fzu#uHjc5wc{=DlG5Dk<hyZ(vt^mm*st`mrhUi5l_IGLbSsc
zE`TeM4*_+V7i$g(i#(D8d<eq#_=*`$cG%^J%yQ{DMg<-mCnhOZ>I;x-OSVam+%6ID
zhOa0t@tgda>Pv*XMfQ;X-gJ1>+xSE5;k+-T!cVXLa2_&MPwYag5}uxaA~dWM>Y@w?
ztAx5t>{WVzO)Q{1OSE-+V(Vr}ONh*LD{u|8rFMDWeQm#$N6-N`DUg@kb5@80%hidu
zn-d93LPseinc`TprAwhX@REM!T+#<Ws+J(@O9)f?lD+HeYX(xKR+OWgOwCU#_I`Da
zQym5gL$=lW^>KqH=)kEk(d)$j$OggWm@5QJqg&zUj?WSKONYPy$xT4Ai&onF&C1Pc
z+zNg>nT#_#q{ntO8un0L*>edEmW_m%a-%K&-q6s)J?Eq`2d#4wy(fi^4oJvz_=&4=
z0Fq0NTqBX!>|LqQk9_Fs(^d`!f7hYF-70(AF`2r-dVdWK&YR)_r{1gm*_eJaD9_Z=
zwP2tgmbCoK;t&A>I!f8!;rIB5XCAH#B#&ds@)oiaa%F4W?6#&~<dzmHy(32&lPO8L
zzDXie;HC4N<8xeL0hD@6+o~EW_=#UN=kUjaN)vj7_DT=PUycQMeQ~#DALgG)MRVGf
z#&l*~?U0kUVM8_3B+IJ0_9O?Rrw6T-z&9Z1&yEmH`yBQEBs5&El9WI<=IZ5lN*#2Z
zuWrWsH!PJk^OLRem5V!eKxiq`CGd98+El@w7||ZHH^RB|7Lj^Ucv8*SKI6$a>5CVu
zLU%CTI{T+>hAEn4+%>Xg68|^fSUV*_c0krgUPm-f;T%*>iKvZ2t8hOjcL*sX88d^<
zo=ZZpD`W)?hGasXq9sFns{%WvrQ)aV+aY9kF2`tXXn$-9{>;O^f294w8w49CQv>FM
zA453x4HDlGVc0Q3NEJBL59!Si4aijvDXC5;H=LNMl%fqvWvX-ihVvPRcTEoRdmVO>
ziB)>8HrvX<!yDk1RPVbWy|a?Z4b#cxP_5-uQ)!Y8jqcV$ewRNkcPS=F=f{V)X1;et
zH*5#&=al_7h@N>&b2(pkkCK_x%bq7a&JhO=+8;ZB@gb`EK>qMQmE?}^W9Yhye3>L)
zyASbViCIq{^WQQu%J%gCuii5Ya|77$TN~ZmK|#lZZy-}#Zj%qP+}vIax!OY_|6cb+
zxoZpfGZoOhKj3PO@0?Vk!5kqEy`uyt@91jgRKAJdfu&dpK&c-`CE=F(8n&9f_fG{G
znuok&Um3qHNI2<wmW%5#IEH%S5%t}pbN0Z>S&puR(>am#z0L&dn4*tLBs=L4kCoEG
zph9B}X38h`eqkiIbAyINhLqlP1z*kB?ePLrobjUP=ma7|eUA^OR60mxZ*R3f{!nxg
zOPcq>cBi{yN!*ZJbYd?@v1dP<4l4iT_7ej!_h43-Jxh>V>Y2Nq_=0^6h%gKI%{2Rw
z`{MYAR?1y^KN$T}NbpdG^T;m88|`uPv=PgAm7gcw$5~>g+*ThAAJM29CWgVMAqTHx
zLJ3v*pI0q2&K*A{{^+3SLVk2^!xp^?&zvZLZu}#e_>rVDNT}Qj`WcTZLuo)-EJBzx
zwJaj&=DHDjw7&(UU!Q6G4g6wK+Z?AV9FHNZSh*i<S8c2M?gsoY_?l-HL@yjjKNs>V
zFMq_eLCS*M-w`BYL2WRM96xzyaiezR$cm5D7wLBJjW%zUp8V^L#|P`ljN|c)xwV_e
zyNKEb#K)x%&+HPfD?U-_!;tyQG^f&gHpbsU-1E<vG<tX*J>Dy}*~OCk+puchx${~~
zqu6u}y(=8_6@;|-;0&oHN<ob!yIImyl~+RgDOII}hEmYf@qWZ6X*sZE?tGiR)n}Z=
zwFrlFs%rk=qpM7Z>~|h#*-U#RsWP+AD*a(ikw~@Au2B=GD=GWudae8vA5p*mXfTBf
z9?OfLC1V<&u=%4W9nA;qdEVu4>vYi*B18OL8+6UDL&dS7+7PsA=)1@A>}MM6^I(S)
ziv^Vrj%Q?BPu$!i1pfJ8b!%ups@|2-aOl?St#Crlk;{GjJX_AK=f=ucoUC;-390)B
z{#ukDwLGkqHFW%6x6{mX(SN>MswF^%zmleHW(g@ZWaLSoo3(=8c8KlFeqfs)FAvcV
zeJgg%==QIB<%j+>4D6W{41@pun>klIC5V4+L-yoZ&m<BoKt!d;1Q(s{9{k+~Co=aj
z8Kt)Uk$GylXnVQx)TjFGPc5fbE^e<}JN5a__GkX7)yL4Gi%|JVLTG8ZVkkr|NJ!u~
zXIP>HE|<;uY6JT3@BP*KTqnlTI!ohhp~K{A|K4SZy;PE$`=}}fY_VGBV|Hf07U<|q
z7l}t|b|nAW)Bj6A`mO%J52Z=|O=@p5yLwl32?|CmIAi>L__p0X>6(6^oCkhF2wA0H
z62XMrE8CmuIqmcKTq)fHJ?ZEO#}Y-Ww2j~BNJ_c7bG6wCNll8|XhnDABg1zO+;p9d
z)G*>x)s~e+XU~|`cjk4Z0$F8YowxV1jmyxNTBS=B&R6QR#pbjvJjwQKSNQQqCf=_*
z;!(AsC;*@VXpvz_#Pen&1`DV1y<IFZ<R0eWjs;NCU>`*Wo6mZ+s=g`B75r0nzbls<
z`KVI&V4E;rgr)`&{`dN3k;yVpfV(kReIkW0md6Nw@?3Q46{9v3s&}<RZcj|IXk3!n
z*lT0gYRz47Fdf?UY&TZ_qvK_Bx3iB5TU>w^9Wa=dK1-6op0!T;w)p7G9($ilt7iXg
z<z6JdJPahK=?uwh#Rt<)^#7JPLiQ*ORq&$JJYD+xQ7(FG{qtGIFeSP#ug+@!l_L=K
z3nI~Zs>^2%_v#Gy=WYA9H6!;RIeZD-pz=Z4;2xy;7%+4ATxNgeSYa~gcXXp)rXHoD
z22mKhi&67A2b*?)uGs`Q>UJod4-fcImpP}}A#$`z&rvR|`p<uZ+zx-ign{eVdhK(<
z{GiHli#O7umwJGXT#ox>GZHYH^yexKf@0L~q-+&v%LX9LH2}lQ@vP$OBca-~<2~4A
zZ1ystr!xDM>ag^KQ>r?}H616e>4?HdUFy)z!Ka@c2)^EdkOvn$s`WFiM_${VSD>rq
z;Zxb)gUMQH8TLhHMmgCcthKdphA-jMK(+r$naNXZL_^m4$!8kxYnY>TSq<~mv&rM<
zJtoxdZfZB0Emav_-2ggBifDCJ%B8lR0@J<D+rn5>F8h1CBx88f$&JxP5o<)Kk3Hn2
z>^1Sd6613kvsi4dC2H<ey{<vSBwaU;46J^o6**43J#=6kzzQ_a0n7T7m)Ur6?8tuI
z+Y2g>hlQgXsHc8vEtD85d=I?V<@{v1?d++5R?B<e;40^S5Bg3p`u*d)dR9ePYUJ&b
zGHm@8A!j-}y(M2U`!4;DdZFh%%-7prZYW+mv2E2I738T;Q8;hGUzJmN=RI7a_RvtL
zPWhRi#kmlJSMPUaRNb>tKl(%Dc+%KjK~T8b2!gjO0EE}S_b9wmQ`}0q>Eo`%H7G~s
zL4fBdDiWN2_@Ungwwi2q+V17K>)MiJ-84Y88DU$B7D>^crhrR2&l4gt)JCq(D6HHB
zl(*LW&oi+u0Y(|SmtWj!djxD5^owPr6+3OGBa+oS&)fbj{&;pR`F@PF*KO9@_3le|
z=;7Jq>0QmkS9|_xx@MxQutl%dt~lPkXi`y6u~rhg0-%H>KIu^G+@XL)j5={927Gs?
zdi+W7fb{9OVGEu4Tke*w<ZTSuzwJ6!a;G|wVDNY||9dVewI9vq@mux6iPp#kQRz*F
z^7`7|^42i)&PEXG){Mh$3q$Nq>VFdgg#ki<fi9p7<b!O%073wO5lR#;2d@SIn4n>9
z6Q6}rhXG5J(t#q3Y256vXK0;?GO19>`D*K<N*(VDL65GUAI)Pmhbj85p)8K<NeK}B
z;f2+V7fQ5KJiJom94{#R5j0XYcRFls{a-|M7v;%CziV-CMy_9cQ5jaT`S;^~|32Ss
zq*kzk!Iznvi<4EeA0E%VxTA1|tUmhUT#sHlSX9Nemm7A8w&48c*MEKlZvhA)YO(ra
z$<gJcaF^MN-0keY{in$nHrB$t1na@fCwYp?zHJesjc#{tg!TwHr}a--@N9F1B-J7n
zdAq3klz)$uonKr|xVyA<T~wX>d?xAfwIlB)?)~MHMnO;k=Xo!7CEW`GVuN^b`^Pt@
zMRPQcc>=CItK8k7Ig|lq#kree@-)2#X;g|N2gu|}UmM4zrQh_~<rOPSQ~1{UbAOIx
z+VVULd+M0jQAm>vPc_+x?m--o-^139L`woT+mjV2fGqvJ%wpvWQI@a)IK41_xZxn7
zqIv=1Tnw^$B1dy})O}y&lNjlC0z#;MjDKwgnms8ryBGqzSgkDc{j?<|n!WmRumm69
z`b^xYZL42w&${aM8S}@qpRT7huJ>aoC9T!Sh*sdja&xhkRkOc;sRP^o5l+T6NyIs6
z%x?lQ;0{<^XqPS%!pDlD`{s3)0;?f-h}V*tV8nBGq<^1-%{KKr)L(XF<?|Juf@5O@
z1l_kITg0dZ0GmA6VPKSEDiJZuR`swJ8o0U(D7`0-R|LKP?xG~Ls*UpcyKLgId$UVw
z)uEpv!!zFe?d_x>bN}Lh_qR-b#1Q)5Ad2vB@2AElW$tYm#GiYmGuzPtnshz%%F-kV
zNKIf~!1rt|CO#1BBUY<Ne37K7Mv5WVM+|OuO`RSP?+H1%Qt<O}jiLX{KCMze8xQo%
zWvlPTf2l1f-~ir4Ji^NpJap@b7<tt0OK%WL%T<svAuCkV@27EqWq4yoAbYYU;|1=B
z!~Qe3d)aqxAjwX7t(P%?>d0!PtQ+Qqz`?^nr7SD?P(H#8S;^48oX+Kg#@^v$TXV<H
zSefddBQy(FhG3RjKYSSj_jT_FS}Pnq3^#rD-jH3TJuk-lwpL2mp4pxF_lxs^ou0Ya
z^hF8tyDee9M)xKOWORCK<#T<*x4mlAnct@SRp{w_xz532aG|GzQpNLgSvK0Jxm{&%
zM*T|Bs$+gD3tzYYO6E0(Juj9g9_|$)%i_&~n7SXv;w6XmHqO|mrK<yPlZ$=chP4fE
z2<_D5VV+4I%sWPbDi==GDa<|W6Mr=%b@Y>{Kg@Wyv+$A%p9^{)z!1$IAo&VO<x3A#
zR42^L%L%x7cog~`>IPq$*PUlC5Z6Kt59lSu=Zha2>VrvGe=C?3=Brvy<>M($X~#D~
zD#IuqBZe-Xh9E1+!W`(6O=vdup!|#BA&cAJN~pyxN*^f?tzUgBO&@Df`8E8|?$5U}
z+KwRtcOE7xth4i7Th-(q4Le$|m$QpoHMCz+bUA(Ew5FwfGd;vM%YICOA4O@hH`mZi
zO)}B)(TyADA2})XE4;wv5`anJXPXg<aq;gd2R26h7MAtMF>h>SC6QP0Aao>p$hqO8
zZLm?rPK?xJ>}iV$qlX_ov5EjVR_utHi@NV)UJ%3kYVb>R<1tfVZL3;0vPiRX7QHIt
z0=tQdQWGDo*>7XBE|^Gfyrdho{F10fsJ7(L4KA4oBg1<4li~^#7I_u;Lj2`S4L#tg
zF#fMXT{+8f0~5R@qT1S=t4|p`rR5)W()y97y&6$o!=OH+hgz1c!`I89h-wAYm7f{v
zF}M&=s2)xbZB`>%f>nu%+r|<(b0cc-u*1lx8<QoSEQijkdi&uod+A)bLa{DPc@j-K
zo<lz$m^IA3zgeL#)+*2Oek@bxS^RT@7-kZv4P?W3_uNzW3K5S4Z0bDmc^RgnI?FoK
zW9^r3D{^t~%N$%@c~jKPmkW>UqkIMO+zF8z-8nh(gc*o@o0$4#P8J27ikN=f9C`Tp
zj8i*C(koBUWy1aHuPf_)WVrvf9(n^8W@jSg|JG#Zvei59i09SjdrRMY<syc^cUcD?
zR@hS>temg#)%dmtglR0aHhrv2KX=t6*WNnkbK<Cj>Fbqh?Cp}>6GJwXcSaEgcnHlX
zZrJY+>@?Y}uiT7t+W)ugi+IZUmBUi5?+As}*h_&<TE^A(CKi^Ke^1~JgnusnRVvGc
z-7@6Oq|7_~IdC-Ad;ja|l=+XFKQ$FozWPMTzG=01f`uA=!xnJzOgj3^Cq2OO7WurV
zw1vVv&coHz)e9;D%RNM`b(aHiV$Xj67WwWQ8}j#$+ve5d_g#n7b%~S@q**8I^hJeJ
zwV9sG-#d_wx9nOOXflj;top*U+*QUI#lx0y;iqUYGBpNWMqi59)l;*UYu?AsMr4ev
zo;Zt-k3-$t_C0_7^zQt>L6jUyw-nnFVqrBd^Z2sH!&dj}7Y>fE9Jur68MpL$SG3#b
zfY*PX_fA~De0==#&KG&X6TiV_xviGR2#Ke1xo5LGWnkBG#F|28Q?F0wNAPZ8sk9vR
zUMe(!ugW`NWYIDcT12I3nJ?nKLM2p7YHbsBLwobgk$q9su9qem_40S#j7L}TB6j^Y
zqTJn{$|qBD^Y`|pJ{UA?3aY_nZx1^ui%aI!=-wPMEGGq+cm{)iol#d)Y@5sX_(l&>
z(nkw4FA_q~>b7i6S)re+59J#*yo+0;r~sg>RbAHWrlI2h{qV^{>tBHM{!tTkW9OLe
z$UaT2<@n%z3JQJU3?GIu)dL)%H6?vd@9YPk^?1c0knSv5-Fjp%&gJRwa$ZoH2F?4;
z%vkBq>{FVk$d^R)aPpT%1I(%~=uJk@eTiu0W_d=Qe?nmMkh|pos;@WCBE!>?W)6}Y
z!8q;?R~5eUvt4#X2WA6^zdOcQT`M>`w%|XVAHZwwC|INJsPttgyP}l^`TY0Nr4Co%
zp+Azotltrm&{2yg6gX%PM;K2?b|hz3d+BHmRDM!Xi<zfEHl6xL{;oysua6r2bw(h3
z#&}WBG6I9xbTI8*)9i%(xKJ-P@w!DsX~LxbH$58`VX=>W-6&IoijsHQllguj-Snym
zmy?_c2C~;B-g_YX=8R_K06rG=nToteQx43F{nxMc6u0}(FUcAlvL7e0$q6BSJf=Gw
zr9VvXS~>yA&%WO*Em%W-J{=TyGcBS?*t8A0LkmZ;QBhde006kewjbr<tQhzXkZ?uH
zftL$OJbK)J&3cx<v(;3Urq?7kBae%o*86hC|L1Z4h?!FpTFeqPWD7}b<fmyD^l<SR
zg|m|fK~wPJZjt|fiWJk~4uJG34+;*Gd&@yR;`zh_N<Apx_YmVE+(2H?mQnvflB*f`
z;AZS@jMo`N_$l9l_4$KWS$QQy(TFgygmmBCA0!oiNhn1JSKwvoyq&^k+0$5PAVU=5
zNq3Y2Mk<kqB$GFO9mihF^czOwmV(x!^QxqR(?04snP&e7&qIGN=Je|LNy$6-#nLoA
zUC^|@bHWW2(^jm^A0ef5tV|;tZbv{JHqMX4%Dgf`-R4H#z3HXDm`$ybeC-u=g@2$V
zJy!G^!{jOBn|VnI113)tKSa&0$qfQ-NGEZbB94&ZC5a-MZxLQLABc9+L8Y^0XYr6^
zwkvN6Cf{rwy=+o;tU`C*HZaCNWH{4o$ZO9~@t{m1<d%-5pi1H-Eui;&n7A%0b5JFb
zhnYa(r+Ap17%!9n`-qZ%4*)?t%-c|zfH{R$Rv0PTyil&dpwC%J>!jyFRM?4Fo@)3?
zSjL`PI<q)gCLWRSvicYYbpU01UtR1@CCrp1*=dPPe0hfa6B&UP^~FNFakAOrUSkUg
zR%jxKAkjfoca%fC;>oF<iJrz7q}0M<JkA`iJtOig$f~tAkmftu8!y@&JweHhwbC37
zN3C&CoXHrS_mU3ns&pMxB9QurkNJ<|*o(*Sq<J1;WuAl7H`Qgnc|@(DswnNdyKBwo
z*CnpKl=RU;6;C1mdtTO%9;8R19lllP<As9?lEgd0X^D=+-KtSwW7&KCuvekPnMoM0
z37YGt^a2ady(;0R0ewKj&7u(OByq&g+`r+CpRI_eSn8vba!WUj&j=sF)%t#I_cax6
z%o?D>zCqL2@Qj<pxKMZ)iUB6T(m0LnR@MJCNBI%T^!u871}kM1T9{@LCIKy{a+)ma
zT25;CTEA+^$f>qdXeC;=k^@>DGg>Kit^01by1qIRI0rk%wJ2U_7Mg>Vc$_Hw-s)K=
znKXwe=RgDJ5Eblw^52~OG9-iloDVD9=Vq;#h!<T%5$9>8qQU?eEM`0`DQ}KAen4_U
z_ISbfwxkiclnhDBC5ggXS9wp!nn2^Ywx?@;2BPp)TX&dfXIPAYs?n>dV$u_$H<kXw
zQPTFr(SnFhSW~AaTGUGwaS|)@EEWBpEAc)>^1>g9u9XW_3W{AQan2;n0SlkN$rey5
z130#kNl^YUdg4WrhH>_N9m_kfE<Ugh<nNQbv@DU#hDCOJ%M)O1T%1<YrI)ua-HKCK
zKM(6vjn#M9{V}af?_0u~{J=-nE|B5W(b}WI<j4v~$s8UgAQY-CgZcMILZHBXABUlw
zMrGk-<xZmtaI#+W5?-&QmewT_;3b{OhzB&W7bqmlBgktKahr-9;)wRJvHr&py?Bk-
zg^mL$5x^Q=2rtrDfOZj>OMt%lKs^&)@WjSFL_H)!$PPYPH|0rzK9rMfL6e9<p4dpJ
zaKN!^Rz;WK`ij6B6n$MH4g!SHPA-Ouc+Gd78!`Cs$Q{5@{lAM!jY1dXfxomYfC`-i
z8V>4OtV#oZ`luw_6<8B=)I;I;`S?CAMuBk+l%!c?90&<Z%&G4Md&1sR6TQ9#f#z@0
ziVpf7QSh46*q%HGFW>(cg{Y=>xrU)H__Yi1qy%hn?wZJm6wvK&bap}FlLy`Hli^C`
zwVnKavubiU-=jWI=>eOmI}h{f7Qc-W>F0<^%?MXQC4yp57jgcT=hY)T6?~m#hiIa`
z>k>c9Z@m_H(*NQ@!St*AdSR(S>9v)TwwqAjYvQq3R3x|I8x<-vXE1?1Kg5=pVad0C
zH{(bGzw|6FYTTd3pYMVzY~4it`HkZ9F!Q0(LO2mllWTgtf-da-W7Vt|xb9e##5PV`
zugXJji4E#w9;$(tm%D@dL<Ya%Ut@VKoha)C!^7ngUa%CS&nD4NER?${bcNs%#u9z(
zOxRR~IDJQ;j~d6xp5)ZVh9>H@_gxpV{7V%p{D3T;5-p!YjBqt8QNm>(BsqT=)i`St
zeH4RjUrvR7Uz51ba~@i|0rC_V@{sXr$!GAja86pj)SJ77#BxrG5nND8&rzkchE&0d
zF3qvmCrGiSUUqmN>N)AK{f>!Pn*{1Etcqw@(LzamlxPZtBcLRQb*(Uz{4)h0Y4J`N
zQ(gF&*w0aqy`GS&(8QxjVv@F~p<WaXFTqJ_bC{EeK#MPijtv!Sml-HV;wAoa%^^BS
zOXKmDUlK29VvR2KiJwbgVN@a1z7@K>fQrb+%5bMtl#=nOTupK-Yy-<<s6)q<fIuns
zi4{pY7ioT4;%elub}x!LX}!rChjfd*x;gf0N>)IF;|);dLH*M8_Hr&Lm+ST`1W5LR
zL?Wu<lqxE?UUsG%THZuIfD%uxI0|n`eD_iEy9}Jy&<COqK!spv!Fvf&1Jncjm=tUB
zhH>rY|C0v5)0G<s>$sW+Bl|Z!kc7QY8Gw<{n)N1LluU){nT7@eW8VScJiK_|!i^XG
z1}$swS?q2hZHrdWQ=;2b7h~jmuJF?&XbzyTYo|_&CPq5^0F)%wiI&LWK4)+eyK5x=
zn}pN4;X`;m+XRe44C+4)>d9%3%2}zlBahCb;n8lg-#k+95oLWmm7Wu&vWz9BJPs5{
zwO3ZlZZ3`(HX)CqC3v>7=L}FMzsb&-W>p&;$C(WL!pVByoylpMftHIq@txVBTA3Ho
z-(2iF3FJgTdh?pZYYyyd7<3e8{fi@(gx@7VJpcr2!JRv%0-!jfW?5-v4K7!B|4)*|
z74z!Gd_&!V%p-I3_sjRsZmzv<LAig-6Pp#8edXz!Lx2QC!tc0F9Yf`eoq-*jB!9g&
z?bZiPX2Y}DYWhvEd^Q|F&MCc}SJ|G&sw}A4Eog)+Xq{TnX<X2|zhLlo!DxHoU=lQm
z9iQlQcdv1FiFwmCNTs#-VjCf`xG3@5T@h=~rR~p>-z<)fZ#n^;?gp4}|3?k9)y3Q?
zB7`g}`9kBu*{p33QR#YFo#Hr4cPG$xfJJPm$%zj>?wB^bxMh2a)HMmao5G`P<gv#6
zN5i|(%0SA@QeV>Jq>Uw=ChAOYNY4EaxdPAN2)TP^{@MG=B^+ln>sL`?{~Y7Kwwtif
zdrOy@gt9M9{o~2i*gUU2_aq&hCPkZ|r8wkUDstHc1tMZ$3@q0U3r)tB(oCC1b~lPI
zt4=v|Twfx{`!yt94&W*Z*qOK-*r>dCc#&lM3uj?8Y-U=H`b@q3kEYglDnYU`>$b^h
z_hPy4X>B(ay<-*!w`BnAuz;8SmjE$tkhrxWnS_$ha<_5_h0YvA-dQu=R@4^4X&+10
zUKd&e9n~HwK7AklRZS%JT+P>41m*-MrgPza=3D8`;YVMhMIye5B7|UGO*<vHSixM%
z@ees&wo3mU3^g0s9dTb;Lgd?Z0eZI(z7X2Ci$Rr0eZFSUR|3ut7y%S$xX37+_<{y>
zE?jGIJxauLYJq6f|1jTx$#bPQo9tF>t|2AVpu9p8zp-KGJDIY9U;o4Es!8t>Ha0%$
zX^iMLzH;rStao;Y@K+J}lt)=V0?LKglS|e#p{0NVXKn2Wyy_;DyDTfdL>rr@+EQA~
z{1?q0&i__eFnia*KxY3^ZaSO3AG2#qVv)_(&q3V>OZcvRk>4YG<y5iAybW{a5Hfd9
zhG}221i-bI&HTP@!2Ihi+f=_F({oiKi^lu>ZAfN#WAFTTTnFm*n#3>Oq<>yOGs!wi
zIJ~)1qE+p;_kW*_!hYNn*kg`tN*sN8<`~NO`GN$ly-xodTfjRrzw3bz3gNXgs=%c`
zWQV`JwpT<bdagzK_4kuN(vF}JEd&B~(ph0ZuBez@4#snVTqt80GEkGG)}JSg)_RIr
zUwD|O=GI8A^?JXr+A#Qjj=cAWvD$f^AuyF)N^tc8q=m4#9|kO8f-ir6P0sK=H!D8W
zpGiI27vT)P`#PF>Xx9a2LD;d|KbrP)BAMb2MHb7CuScb{l`PBZ1l>ON<?Ueo!T;V?
z&+0Uvd_8msaME};9aSl_z&nI;E4ii+8mP(4=Zc-0nRrSX-G+%jRVr@@yMJCkjr?Wu
zvQueW@Pj<%z@PC?5(JMIPM-`6uOp}RD_L~pmY&5Y^-!eUXDuCW5M%9GD#3qJSDsxu
z^sq7bZ`#*4_p;%;LblS^-;bYjIv4UU<L8$*4_LbnZD;=Z@#WpabB6?{w*UPTz;SpX
zxCR#wmLTH@P`OAh0lq5-M-<j><q`{8@%&P~SNfuw*49>sF@d01=R!v{tEuwl=GXlt
z))oyNgL3;#MzzVOgfxxbVAmgsS<i%iZgNeH)esXc%i&h0ZGVfem-+04kT`O=X}ZpH
zdVLtX|3d3}ovuxJNA2U9pnamTcUP15g_-PQI`27tVnQrnXmjiw^=CT8-MY3%>M`3+
zZSiy}=r>%EDLG#uaM_QHBP*mMencyKmzpkL&HjqcLu%}CL&*+;@E4TbKL6<~&+h-z
zUehyd5>wOSo@KtvSM|@JZgQcqR>MKiZ?)%sj~*?H#&WwqJROR;_`ZY1u6roXtZ)!{
zc9;axD^00bXVp1?vG09}Ex~%Ukgntr4i!ASq>$kr{7}sOoievD9fV-9Evw}b70&<w
zEJ;yPm2zP%Q8jjmZRw#yR@kd*joH1MYHBzb<HI}3mhyl`^7hpGTfY6m=f%{P(hp+;
zkbf+f%3ZcUMwS2`Ol7Tev5Q<^n22LdLyG$VXJ4`Wl8A{xEo;(KEV)Hq>$N91r2SuD
zc@?MM@`513%U>+?kw0q%rAB6}MXK#7EhIOGd@sm7pZwD*&Ej>d$707}ox+pnZkbnv
z%X?fAp2m7_*WPSaU<y5B=eOp6c*<xzY-?}$b<;_ngOEo^-LW>&QOPbn(NXEQ7FvP|
zP!h(Y0zfZY<fE6l{j!NM-D<%8@a~p;a`F6O%pRKP97;=~R;P@<#?~pOr(NpEcSv&{
zstJmjl2aR=tIE%JEWVXj9~D=y-DG(Aqhsy9LRzOr?jKCdwSq~3)4yU`*~T8W$Is|S
z1I<6foKiuobu(@{Oj1o@5B@J6tUJg7Ti=(=dzSh|xibR+M1)mGEb(^_4nMRglm+5-
z_yU~@1Z^yQen*vv2n$ImoX1Y*hj}deOz!L*Gs=xalr<BiUxN08$`~FcFDY%tC|+v*
zae*hFgM2|eZPFkm1yF@dHq#}^4e1wjLYCwyeNO^Zh=n5tPHM`Gf!pyW<@R{@qY!dL
z<|?j?zVkRfF7NhXE6FGgLX*|-JZ%A*yU@quyD`5xJ$y^A&Gu+fVydc=Ge1hq5y<ip
z3R3G@Lpv}79T^7f?6`5vvN;i$eh<ze>{a87gaI*jAj=4^icHwRSz0%!8^Jcq9L6Fm
zT~`LliJ!`X;vh(N3(O&LNW<eq3z|$rC^dwYq#}31`W*=Kt@5(`^HX(S1e<{e){T*O
zdj_!qrW7<xMs!^{Qg;@>8(+POv?9Bpd{u*#!E+KqaZSoOg~Knl(H0KRiSkZXjs|h)
zB3sN-{C!Cm;6RdIbWmT=U+R0(b6K+ESv@&v`N2-aL;dX4MFo>`(4OyTu}GB(Uv<M+
zM^KU;&P_v_t5)T0`B2{HJxNi!fudR3+<)ZfhHU}INpb(_f;*u`KwZ5qu(E8zTtWkI
zQJPZ5bt?eL-*qJ8sr}_hRM1$ZSmD+iGRT;%2jit@r+O<RuZm^gWqO^=^dq-vqb-q<
zD*ZH44XlD?wqdR$z_VOWl~*0%>8LS(IE6WQ70{_sY6m>P0%hd9@X_8!S%=mj26;mG
z?8%lcSlBMjOzVL4j(HV|umi67hohGjiXp`Aw^Z%7N)2C=2YxfW|6p_bhD?De8bTi-
z<3Mg@7q|C+B4u1J3y_`{@tPz$UqPJ?zz<+H^E(KqD4xt9^nn?j*Q7{`ftauln%$Pq
z%)_<O8y`sbv>q+nrG=xfau<AFW(~_!oGuHMeD8A+n?UPhUiqm?mIJ>Wx-Y#$h3C0+
zru8HOJp@SNHUkkDIxX9{QWgfxDGT*B5t6MW_&<%hB;`Nbk61e|IY1;_ug;Px&@Vib
z<JHI=1BdJ*#Ef{)O$CUDmJFrH#IBo~*2={)UV=X;jR!9@sxSyM!-@wZANWm&x(sYb
z<k3Ir9=t<uOUIsj=3b8n>mD7Hym(=*Dndq;>v|fz7v%98K(rK4ZV}OpZ)Ks<O{JI8
z5kP!J=oNZGmXq^k!hV^B{~_tj!=d`$|9@sN27?*vG?tlRFxKqZnFV9t5=mw3L~n$U
zGG>MuYxb?hzO;}^k|bM}Qc02|AxWh|5+(EV`Tnl!{C%!-UFUUP=f3aP^Z9s^@BYBY
z83~?KQR}eM2srxJwNk{|ZqGcZi2XRnbWs@p?DBhyp#F5Iz2LM|<VrvGNbaz19{B4X
zAG^_S&>-G-Pqx1D1{=z7-(Bdb`yvnZo>_cl46Ds)gyGP@7`U*lm2PS&C<OxnZV*>{
zmd34olwI`U=hOb&;Z(aGgA;l@9g%yxtR%Bcn(Smy6R=ZL8(wdxo$e*ZUH*$5po~Z}
zjKz3qP4uJKvnzvOQ&iaZ+KPMW9kH=xqOLTOVEXDt?echfAWng3od<IlaeH=t@Pp`C
zILBYBOw{z#CieNaNcdN|J%WY;7G%ZW3UTE#D58rySF<t0j3rCl>j=Yaw}Z<l0dlsY
z&jHS`=y^Aofmt&8<1!S|Y{m7k>&IEY=QrEL6<MHJvzjjkogs8M39WzxT>e_jJd3{z
zF;jeM^%$${pXE24I(o)xK{(|_rX!3Y<T)~A(<^MeSFo;)Wkdr@(Jl`)6N!m5L9;f}
zcBJ>b<_+!tfVpaldFSK4Bih{b*8@*QDT~+*;OI5nXXQuyxEV3Jj&(d}Bp%IU*#$MN
zg&3k4fyv79Uoo>3v-yU^#Q>bpe**Va#zg|Zhiw);=i<u-L|`@p?i*+egO(Xbu7Cge
zT{M41PDie|<?O$kAV4z{uI7_ht`*+%!|>egfuI>hK&lQxUu{Zy%YPJLXqIu#<}nqP
zueKDFbGA4q(CoM9(h8Hz=~|XYbSZa?85UE??O+B)30}yA*jfoHCc^(iE9~J#A{iG$
zGdQl?JzF6M-<LidAV4nU#tmmgPF2fQWae!(o;5P9XQ+<orE8u_$Byy`EL+G&S0{H|
z_+3k$g0m>gP?{0D_NI^~8fqH_l^A$nLW8_wa3}NN3Gh1oJyMQXf0khrL`y$IGmm8k
zu#LQHxPB074~x?;qCck*HmuIwVp4jbwp$RzGh9Ok+i{Gn!{!>%F4FS*)!GIG^Y_KD
zjEsmJuX`}97y*~4UJpCYjm`m&wmg!58&`;Rw1bms)lt$a5#!BgNquyLjVwoLsX<xR
zT)xN?0`^;JR>KrueH;FKmL;((AaF1^b})oJ7+N$KRyP>lHh5xSFk)gba&hqF#^8U5
z^9qc9eWJ~u;Yuhzquft;(kSCpQAXV2fha<ibt`Oz!trz+I4M)&R%Ou91f}3h{)Z}Q
zwJu+-04HAPPRzi#(Zb)L%KV1!<=KL-KHwOo^ZMbefKbJtvdYdWA`Qb&OCI9W%bVcV
zmTDvPB{Kdd4!v+4$q2kiGfKCbVrq}Edq^ZJE+<rg5r8zfzpUf{Pdg4&C8HH9dNAx2
z<UK~l%$8j~?QvO@{cNfom~4o_G=u_Dxpnq!IN6khEcG6kGRm$j%9c+@t(0M_mz;BF
z<?+=(*}Y|IxZEBLuoYU<FBc7W4%eTV(iN|(&z@rY_{mXeut*}zkZ98wk++v^R@u}3
zfZe?0I()ack~@QXTxW1SjMfn$Yuj-z+9>;c2P|cd_QWCUhFP|=pV+xhxItZ--ecK|
z_I4%Ip~8a>oP?2S$14*}^0Tr|ywa6n*4WeejnUKhN>3~gAlD0{1O=tnNAA{T_&(++
zb*3kGaAGcU`F9?kU}V1^uVb&+LZXF?Djr(}*uN-y95e3tpNVs&58+x*`nG~|8qukx
zOXw9_GiQgR+QprG!nr)pywddSkB0MS31lf-@$C$}eE?f)GSZgpazc>hRK-X4<8S10
z((<$XjbS6~tYhx5u+VPK6>4TvZE_UWXq#U#`Z-`U46%Fuswv;|<ufZiA=$|1GMB~%
z=i#b7X{kU<T$f9HUDo+U@er#A*#N`#^ZtkBjWygM7H$OMHr6%wl)v~{92;J!KQ3>r
z*nr?9mz81!8kV6is+a3|UOj9ZBe&iwiZO~8lW|O0IicaA7t)V}*UV(i9*m|BIGXak
z1a*$5taH?H!Y>_%6fdbjo8h96n>Uy7l*0$pjh=w+jgKRpUqrd8?NQid501yU9C*vY
zvEial9&O7{)&}5~LVy)Z(?Od%NPIq$?dF*Cc)H`&5py`nyx&*YQ(r9Ib1O$ky*tH7
zN_|;fe-)OJ2h(3xpBTMs^UEna)IH=c)37S7*PCB=SYUs%I~e3;t68}x@6)5^aL`^X
z@7I2j7h~W+5}b1aelbehz;#uUrLEOj^^7|Kmzu~-Zerb=a<f#*V+MJ~`98O3e#P?k
z{<PtBI_Tn~R4&hd^$=@slc-QpuEux3-T%Is$VL-tr}!h`>`A1vz@vkA30_694m%?g
zMdl9si>C%tA-2m<TPyZ~Un1o<`3(IazbMa3(u|(U3Ys^+scVKCbQ#viO*ifd#@W+X
z>V2}&bq&qa*I!NVae=Ie!_9neTP5G#RC;^M;O%Yew{4zp?*zSVk9&J74Pxxdx?7Z=
zOcgy43I*Bcb$r8?6MJc6Oif~$a98d_;hEmEZ_8XE#@^#op+yP>MR&&wbp$wO+Rp1%
z`&Sh6hW=#_=Lj4>#kTelUjdH3aGEKBvjY7%&;2;xQ?tCv3aD#h<Dcuf+OSV~4jByd
zns*{TQykv5OrGFI@u}zx?<hgi6r{1o=d1Q?iq)}?=I@I0SULFp-t|KDH?8VuG7bQy
zx|b~s?gsqQqJT6*BG@=8y|<%wgOPT_2>D$Yqq{Ym3O`<&2UX5z8LsimUeEpei?fq<
zbJ<Bib*juNoTcr}_6v3HScL{f&Fx)nKlwes9$?K~;c_nkp|IIkB0j_XIY;u$pKyeN
z1;|Ev>Qk@3YR~U6H6(WV#iaalw2Q$-IfCo_eQEG(st#kiaM$b{$`)TlN4lR8bXEs-
z)Cd+ZmiFTFIHe~ozz7D6&p?e^rP4ACw>ZM#9G>|_8!LaMVE@YMG|Q&{qiy7+^Jawi
z5KA9)Ek5Wkq4qm3C@EjEu1XVaoAVA;)tL0x%B2^EPA0S-kv;<pi7IJBa#NPoGT@3y
zFP`o9yL)y^qZ<ipI>SA#t*bSq-^^`NXQXqtj=}^KaajVI-sy)wr-fMQIoULE|5W>V
zr^~6;c;$X<B`O?Jz9H}4D7}>bP)y0gCdhL)pox9)Sf*B{_U)8mhc<3`%4+&uCM&oq
zJ-E+U)l^n&o&UR9jw?Dlmcd8T;mW3JMmY1I?38j-U>dA(W`)uphMPk&mcq_ioM;eI
z^(LnfL+D1II7C0?Fj!dBan^E3%GM`Fdx-MLr?XOsy&9L}edV8AaOv1_o*kSoVwgWE
z5BAys?mZn?-o(6lk+V3i()2c+dP0)5+Br4FJmbSJL15Wt@N>YeKvep#POY8s^uC{d
zNUgkli_C)Vth8xPg`xCH0kMwDKPQkTY7yS!7T$2EsTTJI=m<M?&wv#Q)0JD~8VZo2
z1o^IBX-?u=&!tCgwU=AnIGaZzL({y`FutpmYSXuYDBY=^E+B!g0I8KSmkDL@3qQ&5
zuhJ2H%(?e8W7Iltf9Th{!3BwBi{*aT9-f2u&gu`Z@{bDu_P}*cYsBc}N?O*+V0{ED
zv=Oea(Aade<xs}f48KnvgvvP4*(GGPiiq`a0mg3BdIz(t_VYU9DX&}E*Owu8kx&+w
z{rL}P$ww%FL1Zlt5PXH+^UXp=zMY-=)@JqH{|wRV8GmM)o8n*m4=v`@$jPtaCs|Rj
z#<BZ{j53D~Mdl2%Lg{KWE5XtBtfC7Xdwqn$@U4Pd2A$oyZ@jw!;8HqcFMFNObdUGq
zmvePh=;|8BG#q{ezRWlOBZa{qRxH5xoB!|~8b%0kzY0f{!bN_swoJ82|KvY`V+MDA
z|7|0n8&!BWvpu3)h=%5tnDqNd_NE{+o!@d!O)=RYv#1^SE+=wrqB1GOmK311(r8h>
z2GWSTSgCFF;#8jeC%3ZD^>Pt_??Cvc;0u{$`WegXJPz=4g_-X0g0F7u2-+n>jVs7I
z1K0GHZm1EG^XCAfZGZ1Eoz3`Jt9Perg*A4Y`x9Ww(U4Q84zb{@I5Z-@UwcDuuLa`t
zmia@sf2P1=JN-6_&TXXTbps5<$rA@WR3eo@akS$HxU`#}6l08r_M*4%a=ZyS&mi{;
z1wOs4ICq9m8_3+>lzDclsZ9vzJYq^3i+kB2<AY<WhrU0%+NtSXn#h1saQsak*)_6h
zmUHPBgn}Rf>BkQ=(Qgb_S8Zx^Z$?;Vx@=cZY*r^TeotK6j1$drxl*)u+I!eipheH#
zi4IAa;v{<8fOq%}(lhiK$1>0oE4r4c$J}`)I+;3&A+NbCh49)0^uYAH?)p`JC)C$L
zSW6~0FF0oFry^%i*p24T|Nd`6YP(J*E;?hGujF*1)<kz$68T(X{+V1(eAJzksyU!T
zDuv-y?ziDo2IuWq1_1Fa?tNZXF)2g%0Qw1MkC8!CQP0~0%JD~XA+#t#X-`eoYPyAY
zT5{DNuv-N_ypPEdYO&4yAFlWSx9H``jGi-@d4C;1XKvp0{}_{b?9+B(2YAIiGr208
z+f<ce)n3McG&a>|>{0K=*eBl8zixreT3P$6?2R@iqYSuvJUtxhANb17lLPEgj?kE`
z(CZs;!RH*3MshI`qHV^$p&7uV&i$PJeV%5NIr#J6Jhmz*6xP1C*(mOQ47n(0&!GhG
zE`O5n7*6vFWxp@kU3tCx?bGh}-@8Bfd8^XAHI)=?MX(``B7bRo!w;fqCQulg5uTR2
zUoz*{bGXq~>HaZhN(N*W#I+eg@)1L|0a;pZcc>eB2!{g1MBT54t|<&=V-CcuEUzgJ
z=PB40XoRg39v5Mx51$A@zPqXh6Q$oi^t0iPtC|7xUhq>SLjkA*rVi&HvPj@#i3HiV
z!5=j`rNN@YCBN8QamlF(Od?|1-KfIHBLBEeb*JPYzX`1hse2@BFE|~|H0+sfdpIok
z?(whvb3IIcajl50)ki!(sq>P;t&fjCN_m7Bvb$#IKQPD$_;>2Cq*d^kn8E%>W);Jq
z#;T1k%ja|`GPFk!YNsxB{u;>rKc&42<Dqws&Uqom$+%Zud}pPztq<uhy&iA$xN-7d
zQk>lo5GHV2^;oYypVL1foW@k^@lP^tyQMc?9vt@#`vy7gdF>_Zkm}%T!CU*|B|%~?
z7QDJR1micKBqK%cu)CjZxCBk$Ftz>#4YTd}Yt9n2Bn~LKFTZ}x1XUy`WU5}}Uee|h
zb{|s%jp|(tO&^(mZdqQG?&H_G^HU_H{BWR;^>F^dfXws%AWp`+6H<GA)OZ3d(U&%V
z-jZWg^w#>|p8%ym9%opZk*{8ns9X_tb+0qwyXl5h<qas-FuhSQPU>Y1gGqO5v_iJi
z1Kh2ugSm4xjyex|#O&N0@$L?~k6H^49&{A`{F+M%V^?0{qbDIV2<xx?>^U0ZG+<)q
z)M(?MI~6Ed(4zQ+i5#X4u6c6;EJTv*z4@F2x-M=dducOlvSLK-zQ%2?!T6+6j=9wT
z)U$34e$jJHb|i8V2JzqgA8|yuSlGN1$w+Fz>7KPWq?~kVP5RQgu{ZZWlm%W1etT+r
z`s+9Mze{Jv4V>4nVcYlF&5vqZ^SvCEf*mdVZu!K!ZB^UTTy`xFIPh0z7@w8B2NU!?
z<(&9+gN{t(^}<@66d^oG&Y4THC-R<dxAxm>5c#d_0WwLv$MPfkr-KP7;brJxpZrUQ
z=*@kEtJi{Fys4~*MPF5I^7WFt8tkpoQD|_@JuZ6k`U4-N@*^nZvYt}-Q7IctZt{WI
z#KuHg2Or&o|H&83;`0c@g{FXTzN4UHrhyVvm?@}d4-Eg<)6p2{-|2U9%ae%B`2h5Y
z^_bR?Z1a0)4I)bAjeHu|0)C~L=1BMN`fG(!SC(F^G((V1z>~2f(+}f@S`Ms_sP8|D
zzO<JEXA<^E(e`e{a5PtWUZTh)J8k~n`OAV*8$+CT()xe)f`d|>fR*IlBAsmwxgH(e
zb~;j%S5T<@sy^nY(&o+O0US?w%-d7I)B3tiPa!Q8vmri5qCKj(xn@h89JbZ_;*M->
zZgzh17YC;d7mw0F(ngr+NP=!B5XI7cTXQr(*-if7J}9#1CR^hByr}QR2J{7runE|;
zV+mR%XQnWV3OcQwT%K-IbwzrmgRMPd780kHLF+B5Hhq0|AYMA(=27tJ8=CfR>|irR
zjLt%3)I^Aj5}2{MOYbRvwGs?MTOR>J^4{;%iYMZx3ADQGvl=;w$is9}EDE?1i99U1
z;gcqX*0*&QV-{0o_|?M<iX(zNCG&9+CZWg^EB*T_y5M|zK_mLNZWZHZE+G>G_;~My
zL;SbPl;|gmYM-0s`+PhMJuC*2rG}1RuOo%!$NP*c%7<`~fM{OB@{JF@W5<D?{+`~a
z^UwBbYgdmbeCdD}%<dy#B%cKD`&InxZO5%k-yJWf*D-RF3EvnMc96hU{OwE0E-nXI
z{TxSQyD(&qa4c?Gk4uKdc5q~Ytv*hhG@#k$8dGfYwn-}VE<9K`RrXRqqkhMWOGeh7
zzdSzDY<%*Cf?HV_$137`)tBWBcIaz3*1e+C+G7#~=?7I1R3?KHYh`211~J-qbr56(
z^9md30$e7wdDE)l+d>T0J9(lhi~T4L+_qyGR6P8zUp#fpCULR2Pv;O%FLi>da572Y
zb?d9pY^S;)`>Tv}{kmS6-747e7eKM{tvJQTQ|hRmP~mR(leRaGe4>Y`y&0+bEDNf#
zHEN+(MkUXmdaLL|s_DJiD>0Af3m1B^NzZ2X(B=76k!JGlY~PMXGZ1Y^XId;BU_ZyL
z;p)#0!0d{<^=oAb!cz+6b}o@(N+vglEfH>wy9v-DL4|r!Mf9EKW?hS-e_9DH?7m(}
zNF$$d`W!gwJl&gKsRrt~AR^ZCATL9Bx(aPLJx0_dvJUL_q|0L5<PD%zf*V12+=2wv
zC+2o$z?XMl>b$$c`^I~x2zLLeE}WOP?#RkdtA4~?I*-)zzR0up4N360?*GHMPyCoB
z#kwzw>#VPUboW*Y%escup1_OxwsJA6KssJB6%kMCmldMe<++v)=Q$oKY+O2;Nsw+(
zJE~K1`+AV5O7xSL87J)FZ-e$1-Wv@(cB@=eJgD%x@zay%^b*WrA^pAygqX{Emw(PY
zYx{if`MF)aDv0JXNxX9`-9o=cym{GLuk%IjIsH0C&Chloo#Q3l8-8^RnCWm};K?ZJ
z4Q<UYZV&H?e_Q=wDDPi}INq=Fy7dh$S;EQvW#^=KI$t;>uVipvLzu+KP@oM{qJFA#
zYOo|ivPWEmT!gT_te!0^3lgBO+Mx3o&|fxv`<~0*e>>~UtG#NcQ>2Zi<=ZO@9@!<q
zucomrvUd!-KIE8b&V0Z=MhfDi*aH25>Hi%zkt6tniYN${%)>2Vgm7wB09sMb(qvc)
zL*D~S*NS;ZQ(C41khC#>$$*jr!<1c2Xk9%z)^FJ~{#sx)uEr{T4r{ne&&F%5S9#uK
z8XtF90rEgWjd$*HmyzdFW<FShtk`GN)Yj|u9%#pxaXJxo(Mqhr_x_pB_C`O#{4lF5
z&oDPs4hr!tF}<cs2c|Wfs^|x+5;OAW-#3mFP3eJLb$Vzzn?t_bzS#fz6U?gfb@LU4
z)*DuZO^?skN&>bLR2d4)YIj9X@HbHzIKDb$!BakzxAl)AGfQ;c3qt?%B8!09;3ioh
zy~@u0v~hF=TTSxlLaapv;3F|p>IePzi()O{X^)%yRt2n8tE1<fu-66Jjh&DGQH6ig
z9Ei;Pl4QrT+PP}OPh@WI^~tp_L1kx6Gu=i0$PrRjiGrqxgKt0gKXLN?H)Iqwva|j2
zA?`^}zAB+cNH*xw7iw$gxxjbf``D+hLr{4~0AEj1TL$W=KrXxA$O;FIVeQ-@J=pFy
zn{oLUIk#T_-sB+3BZA@++WVeQzNyuvRg${Pu9R(ilzIhZt})&j;cOEM@^LzDG>7K@
zUN!uUW$EY`%*e8=>iuE|1q#vtc`69ZV@MTos7FDadCsIA@Y3ge>mBfaJADSLHiGL_
z(wVXcI{1k*W%w~jy@ZWq6KP*WAG-;(FAw*d&q{~Ob)6uiB&p*o{lpE>fmOMi|58(X
z`sKMaEE@6`YNddt3FVWT7g<Wlcmi{#TXMiG>Vj&rtXE)m2ixIeB+C-r9~L#(I)kzv
zg`lG^sIZ@yMZB_vzR=sIm?6CZ1UYq-_0(EHOI~JCXWU{843~nr{F@2$lt=#pXSDWN
zcuSQt_A1X_wY>+B8X)HNZ~WV{QNGo#vtFLBc<{02fc%B*I50t$`Jri#z$=0oOFb6^
zmBE4KV<!&`)|%P#S3c#{n$LcSLx@^@SG2skuX01t3buHBrrb)ZjwDYYE7y^=2o%FQ
ziUomcLm*`Kn!DFgk1djBdNJO0vl4xZGrc5kDy^b?-)OH~8OV#fNV~dttBGKJi(r%f
z+F_Pt*pp>c1-2C%RFa??I`-=$DQZ=L_JRGD$bM2;DjFVCQoN|iV38JCMq9nkI3-Wz
zAm^)go`-@QuX^JrDAuEWo-mlUD<XG`Wz<Eok7ZfnD74(gk~OCFGKAK^cIXUrn5;i?
zQYj&WwHMU{5SgYD1HNK|-mo5}BCvK7>kPNwRVoNbAdy__ORq4Ellx@3y>i+V(hSo+
zu-;RPmldK=e~ekGuxg`<9&m;MzEXqUe^}NPAh+)jpUZ5YTlJ)#z>23NQmFFLTZEG>
z8Ao@QLZ20(N69|yKoV5>giQm<jO=4Z29o<UFD`~WCWlM06>$Cf42bS(pCVkzO^mfq
zf(!&gbS^GlunPj3$RWx>q-14lb_0nPeCS!@naNLXK1ydhRjhj&17Se2$S2c}80{UF
z#Y_XbEzOcx@0T598MUag3QO!{S<WyW#QH4*S)@Jni!9aLJ1}y(q2(1Tsi4jnnRD_g
z`^c{Hv4!BQrH@%Lf!W}usLm#9!A3^Axcy~vYF-FX*6S=q%M=;(UShciQ!M6q6jBof
z7$tk&3OXP$AhSUMI{G!M$UrRR0HZPTBgLhJ|G$%mJ)I#ht~b!x$|<`|=e{(aeH;?l
z^7&k5@P+iCT;^-JRU1QG5Z<+kt<`u!3aUHD4fd%^>uz)lhFFtB0134mCNXe}5+1&s
zkyLJv2?87;m%uhhyH&DbA&q~QGN*%TW4<&7hhK7+((SOdgf2bbCgy)%(x0HD#zK55
zK!uO{NLH%WUxEw3{XzB(=+ID$vd`Xop(L3gow`T*J1TT&Q-xanA&ajUyRW#yh!?=i
zDaXEE@!zMD5Clv>^r%gih%i<`y`?tg4oo=&Gf>@4(BnE7nlX>q@WP7Rp@ju+H0OqI
zEi^SOeQYXFi%|%5e%$nMdf9&cYx}v<%YT+NCAf5nC5_}h#p}HRHp+$1$SuLD7b^On
zJ3$`x1q0q+f-Byr5Y_KU*|c50{@4e4d#Uka%k@JhC;Hr_x+21XvVKcPH9DC8QYNUd
z<peO3>ZNe?s1#Ut0}{AbBvP+%r9yz2Yb6gr=8F+`6jq$M;k9DdudJ(2`bSRsd>b8~
zxMRUg^;?PAB|gz@sBZy13y)|kSxgNNO-x^jjA^(Td^mN9lF=UF*VWv<-u&d&^^|b+
zcCnLF;|E*#dSo20)6~EgTNHEc(0dldW9y4||B&zuR^*7L4wpw!#nq#UWKv#O2@KHf
zAPkZtORjvhlwf}C{_ZDYlO3*UgIihIY<w-R<)jl#YW?(d_Jn2fr+ye<(Q!p>>QD@m
zVli=z+sU$!ZN$3PrDryJg1?m*2N|4v{!S2fvE}pQL(sWym5T0_+YMK~pDTTXVVhEK
zT)|j(p9}p6{!$yv!b%W7tC5{Drz|`ARkIiMw;(zlbw85IeZsw;VFp)bn;tHlY*3Cm
zqP4p1J}FD=Q%bHYFH6N<2W`(T$@yvBn_YqxmWMcVMr){d(p#Uj{|CJh)%;OQ=w*fA
zejfxY??QL0@ZHv@v#lcMeI9>r73FCo`EMdcbx_hbQCOain95BtnRH@gs?0>{PP3h)
zK9fvkDmG0wAoCQ_l;!9F39mKD`){Jp77%jQ#5i8!y?q8&tV@0~MnxYj*%bK>FZ+o;
z1A;`DKFeVAvQ1sDa>WH3Sx3}G%-uLPwqFOQem*0uyoW6wXt2JI_4?o#l7)t1J)q{e
z89!gj5h(N03dzU2-zExVFu_ihMO*vf1?%07trTf_w^V;X)V>Ozi+VJ9kgBHRRcx&r
z6qGK7^i1?61+<cl7-SiVR9PcPF0sn5C`UHjX8&sXQrv*iPQR8fH0c-CARk01s-+$L
zX`muXC@d;d$}=RnrLC=>mg^7W6ZZ8h!gTO#^(0`1$-|520aFPs@yvknV!wtATgSUr
zOUBxg_w(IYj$2u@EwRnS<&eT0x4*qKK$41`gO4H8^%NIkiarkP5iv$}g3(}2ZFy>5
zzvVKyysC8X;8$^g+%m>2ab>FvFy&|@1;-if4w7|QtO7sKQbx8$lQnvLDySR_-IxGh
z5Be340|py`X{6?CmTEE=cr+w^@TY~}O~0sH|0LN<?Dfch6pcKt&I)TB^=RuK`P>*N
z3F>BsfFwa7cBN0l1SUvz$2IgR27UdSQdITlF*<c=v0=jAs&YmD6jdIeZ0@|VdRyq>
zGO3HE;mm3*eS1r21AT$j^g!N*St#jNbnIUOF4l4I?6!!Jc!pwZ(=K@sh-YdeAZ8cE
zt$QG{M<B*?+=FsZBM+*KpIw+V6}LJ_P!l2v+OW(wOX}N?0F2z>7d#s2B@H6iNHwp0
zVrkT;Q1?j6hb2J}_SCfg7nN%+84JR*TgqZhCzve*WXJPjFi+~Aun*Kb{fFG3i5^s|
zAN_uRXML$_6%!xm0}?SFB{SQU9Z-)Vj6rQoM;@b`ar$jn<fMM_nEpno!SaLwV6~{N
z7gj11x~jjwINe@c)S7|HnAgkA27g;ihe<)X9#o-S)>1wxbyecF?4640DMm`EUY+%R
zB3n0km_TI;8}K-(z7)yD_2W^uR2T1_@$1vsVHrrIp2iM@M~h_a{8D<y5tZ{-%P%-8
zL;aIe8c=6_9nCKBV(Uo^W1&{+Xzn4bA^TKX!H=!eiT%nYN>Q{TCED$v$`8kjoQSgI
z!%L8qe^u!!RmJ>0_LQNMuRW>RMka1-<4XyoF+&ADEB%)c=(l+5InaOJ5ESy2g`Pt+
z_LcG5!~~F_b1N%8p#NAN$ef@!wEEm{;&#W#BV%jh(??3=q}Z}E5TQr5q}Pu;ps_-q
z(GI=8EzzDNHpOBmo-}jX+KP2%nVEb*h@p3raHTWz*FDQUknJ42FJJu44ups#?O%kL
zxALb$c!2RRos<kRu}U{=g1Oun42AFgWBc7NBv?0HIwiqYo};-uOt6N6Wosz~l6QO`
z42mWGJ&n&&b~U(E<!SN%S#zOX%K!bcSUldenglpHnr-xAt^Rg~x~r=|_BHiNN4!=;
z!!;0mc*G8Ik3rYf6(mjl^N);fB56*@m`q(d{)6?TKiS%^e<P@~0$wTt8`N^x3A|#%
z6gowc;E%%n=%;U3vcYtE0?<YNYv+tEi4P7n|8JD$Mup1KgcDYLLo*ysI*7=A7&c2z
zp3KTR;l{?V+E_IC-l9%jJZ){_VeWL8j{sx^)9$z2vo#mC(O-lpZ}8uFdg?VFPw2oz
zs`eslNr$iP8rJk;j_V@HxCv|S{iotu<?B1=|470O(Q?-8b3RlNYpbHbnXPF0LHdO5
zg2yD=?qz=^4Lt$EAW}RE-7ph-F(Zd<n=WZJkz}a<Z1#>#E^hw_d00_*T)m7+K-0dS
zc(`>zpyB+0u0BiU&mNP1ck8ZYW)zQh{kX|g>fhIvnZqQkQ3|b$tkng!(!VOk@FTJK
zQOXB9^5_(fDBh;XDBs^YOIjy*q9Z@R_B@u9E@4~{XjiD>)^PA%L6Ae~e)?dMabd92
zg#*z`6ZZ;3Tq-S7VUi|Ap>DOd`O2Q1MPVL|F4Z>0CdJ{N*Sv1R0D!?8o@7&}ChQcg
zRlNYAH&!M^uT=hTNSi3bPp=K+igl)`zeXKxPXX~8!mIulJm-J7Hojy|;l#IH6!mU6
z&R+X97_AUdw)&{wT59|;zsu?)%8S+<uxiBnhc;Xv9vQy>co+Nn(f(bP`?3GMcfT7i
z*LJ?DnAy97HyfO)JMPqbSGN&;mVQ0u+c{fA;pltIl*d-x>(21=zrEo@|0t!dU6$)h
zw}(noiu6iP@z(kB$cBu%07e@;K>RJ32B|k%{mQ=Gw{?x%JGP0BvPc6mR4P+^Oko5E
zt!zq;kSd9oV}qb_`%}!I(S4GKH?E+6DBNe>Z0QoTLNj4Jl3nh1-D)?*+fvMrm8X5E
zp~c^;R6m*KLDzDHRCm@wnz<DlpGJs{8tzXtkCUO6DO`21ezQCRkY-L<35X!f->l&J
z5U4>+L=uT=!j$dh>pJF_5vWZKw`)Mh+q``KlxdOmBQFRnz^F*k-+||zT^I6`lMwP@
zmw1P#^6h6UH*dH<?9g~MQP3SaR2f6g80}z=f~!yqgZEC=8Fik?y~e7851O)=_!^vM
z7m0g;nc2Ej^|g(ei^H70^rJ$_vY@Y=4i{`F*A%Rf8VnM<CG{3)`?xuA>czLFa-qLt
z1V#!5fy)hQG3Hdo{h<l;CQF#DR5`=_ImO;9JYhx=vkKoN8*t7}h2ei^@0I~c`&0n1
z^r+G7*7ej_CC5ww<;!O;+Pz*Zv}F>Ek8)cHKuU}Da^A3DUqfzD{7&N#Mxe8=J$@Kj
zf`|t*Y_ou4_|WoNNYCaJfWt3iblaFpfPz4#h!5TCqEuH&%{ISp(TJ9eqQUI8imWCu
z%*N>m3D%1Hun%*p5*A$xpHc+=C_ePWwEe-FfqRsJ_-^8G8Ao6|>aw9>ZGC8<!O683
zw8OWQD}zVB&z#~`tZAWbamLEJ4zeRClm2H2+<alwKU=RBfeOMct1`%9kV9R^kRvNo
zVD9s;f){_f;zQq0Pi}R^+hJ~6^3EUo!|DtBM*gb!w{eQ^w#cUii1^}Yl^gf|JzO8}
zGvWNSF!+YIE|;}uNRQ3PyZ2Nq=w`sE*RAx$&mi;zKfezczJbB|o$5U}t|Bn@*hlx+
z=GB75h>-E}!+;b$kJ^PmdH6rt=AP1kzG=cma)<K#?sSGaH6{A7jsbMy1IISl$w2>H
ziOIs;kEwx9e?vX!2ry@-=sIpZL0V?nDlY`dMtl_jjKQmEJ8YJQ&m8O=?WbYRx3L4I
zr!tm|q$xU=HH@G)+1JpD*`9fHbstxon55{c?+6x>)uf2GZyQJ%APZVoS;yEnr0x7~
z47e&!S_Wa_2}65hKprf+^`*wgwb28fRus(moN$UOq%ah{*Di$!JL*Pe*Dtyc&eUUf
zr?TYddl00)e4{DVz-SPo->ijGnbOn0|DF-eM1SMFHnc}v|BRPeQP73$9Dx+yK!<BF
z<qnjlfs{@}t?JD;HO<Bg*q=?=UpqaJDH5z4A{`Qq?2~B?tu=ku3tNOQ*f6&sGBKe8
zPbQEIwVeg8833v}Q7eh<4X^56qngqup2^k+?h}wZVu&}X4w`-}oV!ZJKWWveU{s4F
z&XLIz41R45HX<HwRjyFsUffbtuNn8*fsXMge^%6BaObmAbcM&I??sK~zdpO9Vh&b|
z6gOELd~xIDR~)R@D!$?r_r;@<>CTo&7mn7J_89PL-zF7bvw4HjXj#in00D@hp4`(@
zs5^xTeK@|hK?9&YpV@GtKz-%Q(KF14HV=dk#V~3}>ubG**<W$n@L8L!l9pgC@f$hs
z?4sK9a-)3aHQ09NEn|COy7~&}ucjHYvM2$1g6-Zkjyj7x;T3yjEHyVS(m9)M?s<6v
z1sdjP-BR`}h_X4rp89fr=cDn?gOUydJL+jI31DAXz4uyE_HAc!ZMmK5A=f94fQSy_
z<PKQ$H>3xfM9+ytuq1?jy_j@`y<2E`twisbFmgmGGY_W9-_Hm^S$r7Hjewz~b*bls
zq<KI9L9uj==Kp*F?p>i-a^|zY#u<E9!5;1nsr7T{+WJ0*UG@TIyNcfcSM8Gz4e8{J
z`2g)}E#F;Pn2~J^K=^b%9$G7Y2hI6GxMJ|-dV42obIq<}ALBUCb97Z<_}CA{w?H=e
zq3nF*iR2S#Ci*+M5XUtH`{^XU6BdEx2MxA0z0h>p7z&aXz%0z4k3Lu(WN!L|FY<_x
zv20&Pm~KYwgMft=B;gUS)tZ!iScKW64CGGzB>AY1DZ3C4Wf}ggRaws#`lTS2;|hx=
zfCQ`-=acSCWmgKG726eCd^oBjYuLU0i6)|`8&UKnN}#~fBX!^Soh6!)SjAW=FO7xJ
zo@RQrBb8>0*aL|cw9FHBc|WH#fhSzC9G@eD5+)|5Iqkph7$~SjjDFUU?t>Yg!>9cj
zuO)eP3|SIF3RHM3B)`rK{f@#tS_RlLvFYL=rp(e|2>R{6rQv<_L3D_y)`^!J93KZ}
zh^pL?p2L*vdiXf!JJ(?7c?}`YzBn}HKVJn-#k}1R6^=+#L|FSlA{TVr3lEZngQlR|
z2`gB`1Jj3h;8p|>BX?4xU&NgTAw->^u!fTy5XvS)`MV9?_cVZ_vofD{P@<l3DlN*r
zhg$CUTS*8_B_LnhV`MkgnN=RsB8~0;dEfs~cSG*bcFweUC_kWSrq9D}`~9(7KszDA
z{v|#rd(STvj5g3vEZ}i%GuJfb-bsaJWrdiI$0e&^@_SLa+H8$T_jq=MwP0)$3uCdJ
z@Z$XCjrs%sKD$*Wy}EJvSM%wAU+LI0Z=PS?ymR;8x9G|<?|xkVZ6+0MKWxPjBN5g^
zygJvi{?k3sl_uns;7}^M2R#TJ!96)m{aN|`Z$yj#+jpM~4Zj~Q=u4(c|8A8x?{G^~
zb~!kTj5ec8Sr$`hiU!y2xhjf9<C|rm@~F<I|9<|!Zo2#(<Z??MVIy*<>HwM6?{#I0
z=*?7&p-Z9!`KK~+n}}5Fn?p~3K4Dg4KHHCd_5nBEpCJN<KA}K)0%Jw`^nC@rd`DNk
zcj@AeWI^3fY##{KjuTPFORPUd@6H!XEG$nyE9Yt}<Z7#`LC<V)6xFH?=B$K$`X7t<
zQ^#=l%d6O$C_yjndM++uJ@uds^W1EZ{n)i=F)n^W<ONZHFqx;CyNInxm2G;Y2<|m)
zuYzZ5DtsTqu1AU9*S;{V3B=D6GOLgfKUT!>al{8}#1QDiBP4Sk(^l;)q9E>vM`rq=
zl2T==@XH8_kSrbDHILS&Yp-X$N09GI?Z1|^fUF>$-sEuBK|?n6I83#Np*2dB%#A>K
zfKeC58MMCn3-Ri#%foetR7BFNPwvp=*?0^Gzr#!V=rwJJwqmId(+^w(Rkx<YhkNM9
z22ES8w20(XeXko5^lv#=lV(;U*ph}jSG~`|J{<X_8UdEy`(VH7pdC~n^&yq&dIX`(
z7q*BG33$uaMguU;-2_CLqD%UL<W?yLB9t*f<}qd4%C2gIOp^2z$g=PGvPr<Qy_lPr
zgJf!7)<Lj%1*)`V1bbW!Bnee&2MbU3n?CLx=%^7k{3u(aB^631Hrffzkp`#Wz+)WY
zeQG3tGY2!|5vg$bnAy&NVE~8FqJmGYXgnKRF%<n!@$q*;pPbi1;;NhSVKrnrabw`Q
zcDEn8;49WD6;<DZ`qeDz6Cf$SD9Q6-MS<sJ*A;g(=vZ#Uo7E4Zk8w+bbZl93FV1bP
zZpCSxf0FGlb)+u^;i~C%6<%>-iz@8%1$fe_DApwg7$KkR;a$5Rr#BJEu39m;zs!Zy
z`0IX-x#Ji*0c#b|G7)XiALBKlP8@Yt>QmM<7O%;yYF|%nKByom+%L5nAft8-&R8uL
zOOw#5`(y$U)fzB<LdT{f@T0<%VZ7`hUiR5bnOi8X>$rKqH-cAmRwh$PFXU8#M}0fF
zaIX5_VBVc5O>Azky3yDf*<ptrI;trE)%C$+oFZMqk=f~$nRP9gToYEGSUA*3%+ymF
z)3x+?ti3dkg{v#c2cF~Ak-8DA%C4}EnJR;e^Q4+;16@b$Gjv^Hf9c&+`A&yg-xs>S
zH1SeTh}wFmcKNCJO!(uupit5fHOGVY2=ygP#`(5nXRTysAF@ChxLj@OUoBXNlTvQM
zwdV(QEsQ~{4W>XyZWVlW4t;Dy_T`%Ti<`n{`UFkv3hU+z#u@R>3K3KR;TA!=M{q!7
zR80Olp>7VN9VpjA`n1|VFgzf<JbzNH*lNZvF#B^jP05U-;Wnb8`<*Ty@m1%|^FvkQ
zcy~9V6^IfmaHc_3Nq@*Qpum+52c{V~Oz-qWv$Phpdb}6KE>vH&y49tKHOmv8x)L07
z2iMYMmspJBIg*}iX;3@eHTVN4=byWz)QBU$9FZ1OQXVzUdwJ->7a@^qaT>oUP2f;d
zrU(r5Q*c3O1t$vg^c25_8}~!4_?2a@{*zz0I~wQb#g=P?91$?2UlX=a0h_#Yr{fQ4
zYiKJd?DyAfKj0g!Aok1OxIMspGk|0mXdNGD*B<D!8R+FII1K1FDhQCsTF@HhnK=Vx
zu*f2=U(8=<rb>iBR8Uq!o$ECgB8Mc#UtKQ5Y2&47(4bl{YW8t6xQelG73CR(ou#9b
zO7_Za(V43ZGW~A&fcWJ}Oa%$u<f4eIHuaWLzOGmxTZ5{@KkW*Tb4)FoVMq;vs{49x
z^SC$E`{pG3z88Nt{BJ1wKYkV*(Tlm>E0F+`$x}z~6o-{FXImO^o7E+CR)<BvnCZB?
zbyX<eU*tJW!ejQUjb{=j{=w^@kRYbi&JTPN$Wm~DT;OE#E7vw32`n%aAbxw3N(p#h
z{OwQVsL~8670R54cnh5>{8E@8Eppo#%_JqIkx(DTFlJDH*8`oynX$ND(~4C^?G|(=
zM9hYc{tj~V4^|xC#7=H1v7skq`^2*8$QA}dn=aqEXO?70_JJg(tKf@OGB0xcUjnHY
zQ-wo^Qb67e0i$;?(1|X}zJu3<$+m;DzY{s&ss+3!{WEqdH5`n4w`>27_m~iABTZQ6
zydn_df8u@h{DU`pp9PckZw>FQd9QW+Arx77wf4~b`BUq?7~M@=GTKsDS@$~LJQx37
zutu;7L@A-M@)u}J)&3BiD3ya7XB<49{$KCr*to_U6TH-lrV%1lD*Oa86omX!wXY&o
zqy>=fz)SfLiu+f866-~G(9v_M!0_uVp=MJkeHlZN&h16Vl5#}B$oN!Ddo|joIuBBH
zma`ujA1xU=FWB$rv2|MV5Xeo$IA8i+JG@3LbYAo-fMU{R>gJyZ!lZNO(c`Iy<!iFr
z$<h;t@PzMJ5tzbcA9fOt5VTKA+Ac+r_U)Nwy7v4g0D?yx$6BOiW-((>B$25>bERs7
zO*M?fxB*o&1qYc8H<nsbY0s@kZ_;JpRGIE2><)ntfLETM@A3AIUZt=h455}#Jl^JB
zY%D&^CQfe!xmj({5rz#vaUn<rXq&@+pAX$Kj@4PL<kLfAz9bPA1#1%UN^F08b+?EB
zz8h!0NkYhw$9M3@x0D0yF%;TIy-f~X7>xWP#J#eQm>VejFI7g0?s%xzbQ}O2-^A|V
zi+)55jU!HR8|=ae39S)r1rYhzr`Y7rM1ckD^;D62ML2L`<=LQ%$VdCS6y++`EG`GL
z9|R08rOT>4DuDPMs#(1JcpiIw$$AHm;oVB`++bb**Lyt;)I6eJT``}y=ymmNFPaH@
zz4#hGSGBJRzcNNTeel%{&QpBP965Vgy{6x%>%*=4^&*mFOb_+gDGZVE`)I+n`QeY`
zIsmbfF4MM-W#&#fZ(&6o1ZC6D-?E`JwV~H*_btvP!FprS%i289{x-n0pf*gKAn!bU
zT8Y?Xx8#|P$KqgK3ImCsigAHPnmyDC0Wv1<SCm$ueEZxPV@~I#-p-r%aeXgWClw?F
zm0EPDG6$cfE0PaL#K^dQ#d$|!4Q2Lf3J!)W2u|)1?X!?v$X=%-U1W$rmEd@l2%=Z~
z@?hx*AEg^<xl)B__kO2+GMl$|Dv`SPqEg{tUy*Jg8Dxdt0UhBkV&R%V@(4DjIQf*O
zJo2Q>4oJS`i}mGTiO&8aRL$8Fc>C{ohnRV62R^<Nf{Fm$c3l}_&5Q^w+;S`z1FHeE
zp>aYrk%|jKR(Pp&e8neFeg7ZKt#&-I+H|)Hj~>QO`QlABa7pEYiaRP(`-^_3k^`y@
z(6Lx12$)>JLLER3F&Ezl-xc<cK6eIN1p+#%3^uFa$saq84&lg$g)W(5H|LP-`I&Y4
z*%m*lcplDQ$luYcQj{EbwD{K3Q0#ZS`0o6^>E2e1pqTSNtozZP-7XyTROb67&o3r#
zY_{S|zYB(gC_H_yH`<Gs>@_@~hTS#AUsnuoe22?Ch)>$fOEtTpe8qdcS5OUKJ)Rob
zJ&6s}yK;h>qR0n0`bN9%JQ}h7-o=Xa^F;#;{p$_51?~*6y-#SNW4E_-rN{Jp3;t%;
zo0>rU^xaGD7jW*bWUtg$<EbJ)ar6J^^G+(wPxSG9J*MND32vbZolJNay|e>1*Frz5
zR3kQ*jQ5pa5?^>Gtnj@5pNgy$(1zd3F%}fTmp0Uu5Z|=dI|^#C57hM>b3ZDQ{ON8a
z6sTLqwpa;nsiNx`q3s9NyKD`9+`}!;Klu9<n`Z)u?LL4oW;a3EK`@GLb@w`G{%W_u
zG7iOSwH122yYh0k(%b;QY{e5K3lHw5tF~*G^xlCm5X*Gzv-x9qu%WOS9{qmpXC5AH
zhSvsJ;*vkHz`)epjCQSH%&CaBo@3L!OT1IhkptLqVW4WcwHuHtP<(Xrqcqn~Xm#~b
zfGofbgl1&pnBT7n^oex#a~FF|4c|WKq&(RK?Bv@EUQME|t2j(no6c3kN1IJ$mAC)V
zw{P&UO}|K|CQaK$1^cQ^XG;7*bAn$w{qk6IY70VNzP=Gv*uDRxJgOUay%!58U`qk0
z5XOwFUEP<4kTFSy>(mTnNT~aCadm13b7Ug<vJ{o9Dq}#Kj})4|9`6nWUEfjQZ51d|
z3`fL3L<MV~?vy=UR)-YsSf%CsI%-j>YRZBRbgcY6T~BLG=>@k6t*U2N`1}S}IZ&de
zER(`#^w&54dw&%;vi$D?{|NHlrN5gf0`p{uo|*Ny)wuO)p1lFc@tcIbYsKSW=!JT|
z>CMQQdtu+i%t~*R_Qk5%{+qWsAV1)DqelX?`q6v(DyZ#>K4I7uH<h4Z@>YOY{WZBY
z=%unZRd}Dl%&xhIN4hqdbh30LS;V|^<MYI|BM;BXU3hr+=MJi^A<YjH%iC#IFB4gb
zGvk4~UT)^jwW|a0?)78HW6_Zywi_Sv7~lio98*9&r^b#XOq5Q<i<EG9PK*a;%c7=(
zMYb?fcpZhF2*uyJl++RN+gTO_y?s;#8h7icqj-te<utSy^_e9@NnbGSC-tXGvS_`y
zmBp+d%MVzLaC>hgSAfp<lT1&|E0C9(P$V^I9G=DV=ihWLnK~;FT;`u^7hJA;bZf%-
zCz?Vf0c|?Yq`wzyXX6Is2At3bB<r%>Kv5nX?QP(fgGDFM`p9hiAU;hKH0SSm2KtZn
z6n6$T=HR3DRNPtH;!fMB$L~;aeuC+%5gWagP(jfY(9YU(^L=8mqt261KRcfoBs<++
zjj5(~rD3=Bn9<*fTdvw+NiT=gwt;PA0PJHxcG$0bB@GSF?b~?S_EvK2<~nGkjFs~A
zWf?BXlh}S<FSuLizpnLX4nL^JaRnKQXMI!0oMMa?hFko@N${RHc?lc2P+&}%Oa*%8
zNI$k}voMj#CT=ouqn)m(*oj`7e%-K99qTYggquu$sMzaX-TD{xmJ>awqq3Qv-Zl?R
zevF=aZoxyek*>9i#lD!l=ay@~>lYwsdpY96q{UZaNbIXa$8+K)N&O#0HGEPcQTrZ@
z-Ig<y4g3Av=vp!;{_V+!!l!3Y!kVYw!BbzrHOiv&?e>437EYLBiXOWmdzL{;SjgP}
zEa5}0rAXppfs1qE$CBf@iAxp#Jxly_IYlICx#qlc(&vWCTwc<bt2dsROj29jYyo%b
zOwzaZ_qk^Zr@U|9e{-Kh9#fcXt1a-lcF=90v<SU1s@;&BpZtB?#pUeVYpzCNI?!sO
zR&$%z&@|~omD}0vrONlWRn-K<N3|cezK4?vWFcHBdW4vZkCsPim_>2+y3qQHqU^GI
z6-X4_@bxK+jtuZ7$-{J*@BmZRmRROaua&xAt=S@_ir*4W&dyuFu9dwD3;xs~E(VoW
zqxYBo2_XZB6DUwe2A<t}{}@iezoN=ou7$x32(3kjbC1E#bE%(?{=jnbD3Ul@9?bAM
z>hG%UMU7=q1UVainJ9`6JRrFfaf2>in|4Z2OjMkw6rB^{d+85+y(m(jNovgK*KLW;
z#WmN8`aPa7cZM@gtSDkf{z{s9@44M!3<>CAN!c4Zxox!CoTBTC%N0@pKZ>nnKw$bI
zm^miN=S`#o%OrAd%AGz+(*K5|To{g$Oki_PknEvHI*UZJ566^t)m@Z0roy3wG8rVF
zCo6qp0zU8nIhPEMtc~g=$8Q1q#><90I`XS6(Ls`x>(iFur;7U|>ZDDpefB@ka2~X~
znL4`&gYF~VNAUp|1xTeb#P1^DRAZjX_1<gi1%5+&Fer~oOK8b6wwgo~14_`z8XIGx
z)#b;soq0a_Hwtq4v~H@?B6q86uC?{?xR2Lgl3g;#+jXL{koVK=uOk7X6k*@D)X#DD
zsxN!mIO%*h>n)MdRX`6jH&o|{{rSv^8^0c5x3#}G0dwN2Rf@ppCSt7L)<ITJFY&wD
zFo8GUcde^W<=$gQ_ve|Dmp|4>$KuGSRiG}Vi_E-+gABA)A%1MsT&^2kFi}J^Lgw_O
z+=*b#u9vSe1R#h=uC>%_w_9!Y@wWnF!YtPFEt%8+q0)U0MhyR=s8(UqifzS%m0!e-
zh+lkHT|ZoP#1KrE3vRVFYsR?>D5lH=pbam5iWgis?@w(v$*Wm5#l}k;hJGOJp|n{Y
zu-Zuge6PK^C9YaLof2DvO68R`%gD|P*vi%*ZWl|VzvOXJ;oq<wp%9s6kJ+z}Pj{DH
zn6g{WdcPB%d-Bh>8!3uI1~>kl?tv=%%7S&K!RiUUh?A`>EMgw+kkBX5(weqEdmeEj
zp}#yUG_G4{Vmz`}IIf9Yevq5@#<&l?hY3BkFvg`t(1mgsY#F1`PO9$*%;eOX)s6X#
z`?MD)o|j$ntfZvNi!OB7K7(sqC72u-BikQF49O1+jI*^PJbz3roa%!MP>UL^j1Ikn
zzdVQxw_anX2m#a!qbQ@cA@QaM2PND(P(F*bwCZctK8qVtrrZ&>fU%SD`pw*z7AjIM
z0#y0Sy03K`PiFM`Rr2a14^z@3Qz;*BG9fo=ZJb&+&KN(XY3#npebKBSTOA5PEv{yN
z8v{RKn8W)Y&%wPWlN9rbF0x5{u6B*iXV*fPi8=Y2s&j8l!gq?vw<<oJ<=VtHnpb1S
z6*LncX{SHO4>-3)rCmakr<y$G>@DBD{I)WH-PkVZ(e2Hn?0{un!_!Md+}YME3i}3!
z`809!$^aTHJ){i_NtSqY>StVxYqB@Coi*|mnF`O*9yI8<ne78y#N~4NG|jpxu}Ato
z5O_wKWJe@MW-o`ZiH(AcrQb!?$?+@w{`@SPYlH}W1A<dZ2kC<Mtu`F=g@8*Qj=1|{
zAF&U$qaWw<bT$8z7!WjLHj}cQLZ2Ea6>PhHhy#$~$%eOalmCyVdyi-O|NqDT95ch%
z=6p7D$T4%wDQ0t+Lphd1Ds#w$LXsk88|FO65H-h;$~j8qu$*Zm2^A$#6y;Tv?Cbsc
zU4H*Q|9w24&&%`qc--#S8~dcb=rKk_ndY%Ks{JM&mFhw9U--w_^0l{+sGIrUuI10A
z9+7r^abcGm0s7DGqSc0+Yt`cvCW>HsW-|S!q?~c)7O!cFVrD(=Efz#d)umXC(e$sr
zzM)A8*sCbf=~|NKc>RBb2caBw6ET4KamAL}*!QbL2a>sdKl#H>zhr0etYvJ&?>Uh3
zdY-ARm25@cSpX}tlldU}!{XiZ5`hA&Q-gigh?FaYd43x&M~l*49YFE`imroipW;qo
zjLjYMw!61djmbpW1T0O5&>W&bCj^Ls8&inqO(K;x97GjUxN(bTzX|?6FTRl*ILU-W
z`$2DE;y7#r5(0j5+q$dof*+c9K9_IM265Fz{@!NDT^IQ{0GMBtzj`Ba!A0TfWq8Oz
zTi8dXDqiQ3p8^|^g2(Nm=XK$IF426wN?kV)jZJc27jaq5a#tA;_qrH&v82Y<@FTta
zR#OQtnna$U__CNVXGJ~+L*}(&@Ly~&GKkM?i#OH?YNp8NiGhR2T0G4O8xny1CD`rC
zU>mn!`52QsMrx_QRbFh0?$88t8HkyP1c4=JYA)~BLhTT=t!J@m;&Y7K4Y(&W=2@YA
zm)NyeNZxs?>$<P7Ab|f<GYaO$`$?C-9mxUW^xYG2V4{nB8$wsB;Cv~GQsmAj@6WRr
zENAV)2VO?aFwdO%5AHxhkQc>w$su4x9`9}V5=Lm2p0(gdFZMF^;sxehY;4H*C;H}Q
zNrJP8nCewc9uR@PDN0}T2VrfTJP^p=>Fc~e)TZb&#L@Fu_*6`AgsRDbjJN9|<lA$J
zh~_yk?p#G8-&>KPAl|zz@T}BBoTjVqjE@2Ug99X$*n&|*I^S$52V`iNi#!`}o^X*5
zM`0$h2x5;S2qOfz$uGGmcrFS$QPQhZO%|xUH7Rlyz1YY_aoZCJ``9CfI9<Li0ijt}
zS#LA>C2LR<@6`hM?@yd_cMAEOx1wfpQwA_H%}A*8s^p+vl5-JUuS5-mh38_SAN`~f
z`lJqY!|OeQAzXB1;pIZA_ETa}ORQYKi%>c9&`B&*L)RX%M1ReYRoN8@IZ&?IGD#@X
zgFNxgCSJu!-T`KTM~Ep24}WWgm`0Uo@=)Fq<jzMs+gl+b0l2%H`~i0NI3n$qr@TqN
zQpGC#CsVRs+{QfC#FK{Dz-F>@VM4<2ZHzjtM6&DEi5;5CQeZTuQf;1?Tp402(Gnf{
zBT6?=<2R#hvf1*kE8@bUTT!#%`9%@WCYWt5y!r#w86<A)f(q%?x{ES|An72I38om4
zmLiwh#1U*vwH*ycj5D-HuvxpU(b3K2vGzi5D1vQ6<+VR~QptSTo4k#DI;F)3Uovm(
zCQk<MB^mAl5E&B9h6rvQFKYXrdPfF?U-m-iew9)qRY$*6S@Ks~X;kAKs%_3!+of0A
zH&i>0R3H0N?aW`}s!`+aPy=tS^y-H&A}(&_1^vuRM{Z^O`w%3FtlBrJMNZb7@VT%u
zRJ(OaF1pE#mni6Nk8DFRPL?JUOOSI%bktT5uOM~Xzi*3y>TFByRDlT{9pUG%nNCEc
z<$r)*A<1O`=^m6Q(XBuzZ`D&ZksuA7qpJvWHN8p)#{O_1&geYzk0-D0wM-w=(k2dU
z7;(2bU6j+rH>-H=uZvjTA~b&y%6IZk+yRcbdn4}4oh`RUm{sEq|3nJ?&aWFd&?=ES
zr<3ueVS0vY%{+QKRW7YbE)icK5_!IF_s;4{eH?#-@3oqWKQ%%x@57O`{I0e24w+x0
z?^Wd2wfwXJH3`&|BK?ctVjlRPgd7kC>gET1&J^rJojPq|mg*uf;sRSoh5zST$3BT4
zh1~n*Rkt(KEEO8;^|=YwcM0v7#ro1b<A9V24IP|AXgo%+8%U%(K?^YtZne67Kq@S`
z@a(4}3;w_pFV$kaBDxIWkNq8{u?XgDkY#-YEYCgUO9oQEy>0}xeZE=n1}FW*%?M|i
zh%=8{g3pJB_}o`(2nx(-7}4lB5|`-xAH_<T7ko;t>kHHm3yJxwelB12H6XarE7_W#
zc<&1A3F6SEU-P2m(F->p^h7q>(mF#`@6Fkf79im{qn%ernu`UHi*<;MzjqGLcNu)W
z9d)WTW}u^__4p8%Td0}byV6q|xp5dTdC&>)Ii<^b)$|w}@W(mTs+G1Uf7?86wwA=S
z_siH+K5Sq)cB`&F9x*FBCEzvw_r4&qJ6Ptv?#=rz&UK&jxph45(akDcQqPH72Mu<2
zwLv}hAU~rNz2hFA&S~kw!y<fQ99&UfJN4u0DA%5)oPV@m-=#F#75}A)hsbGFQ|)0s
zMx-`4PW-tuoQ{BL)lFygyf-s}d4Sy{;2}*<ra^5f5j-dSct%blFltP&Zs=zaAe#r%
zEUf>}^}LB=LwQ^18`CH7g6<a??c;yD&xRtV|LdDJME;VFcs+{vtWj&dmp^^;iRilH
zktL{=aG+7BT-T!q2BAhVc8H<8^HM+HwEsLFH3g?SniV)U<z+Ot^f!t)-8+=gndH!;
zD8S@Zd`@b-gWS4-*z1bi>)~n)sy=n^-zZBArt8KFS5&ll`{!PWrUIxb;Yy_N=Vs0Q
z9#O<g$S$=E9nwGfIF=oH|7>~(UW+wq)*k$&-m$y8WW6=uE7nvCc{`KSeQe-SqfdX5
ztjQq*IERsVIpwZ~tCd^)^FwB#^+pKJqTn55e2D8a1I<?HySUx+_u|)|g@z4`XU1rJ
z?NJ&XxVA6?i64LAGx%%1r^&pxZO_=6p})_}xGyUQ0BucJD0Op!hVj9WV4D988M1`t
zm-vzvrIkPQ`O5V73iJcx!xrnqo62lG!_j9lBR74z4KmwF(xbX#?8b%mw~iBEta-si
zzF1i~H^76G;=J3G{N<+TLF~KbrOm+*b2h1yJFa=Mp=;DMr|9umx&SlY;bnC7xSkxn
z|NP6MzX*iWOUBJ-Rho~aj+*G&<;Xb60a)k_sM14Imwg1xt&Jld$#ufAQ|>@_{&GpE
zC$53n*l)5hT%X>3Qgg;7j$Qeve@3(Nq|cKF@fU=V571Jt&z*J_yf<C=adH~eN_c_@
z^y6Kres)xFI$~yAGIGFbeGrkGJhk<bt^4M>_F2M$t>0bbz4LE=zMAd!cr(C1UVi#?
z^O&P;JhJxKTu0&b-Ho{ig7eMV^R36`+r#G{X3ckPoON@7Tm~v12`<=j>)u*a+V2sx
z+qn!2aGdcIsh3^o6$H4>A?|If+)?oYF<~F~7UshdCmEJYSZL%T6Vwzb%nL+&$^YDR
zoEU%muso$0tO8;PygChDc?{Pcc(-wE-e*yKgsu8Fy<!H$(H+=C^<!!au>y%MJlJ-@
zsYNwI+9H28w3odIKc1Dv6yUid(6-6SzzQJk5h)0PiQ4zB(t>70STw_K6Y>76C(mh$
zVER;0Y>{0rBkl@6P)z(7r56tB;d$<w=5|MvgSh~1jFIvF;GE9;R#AO-v3Ax9-1Gr{
zmnpr^=0#eAmlto2W9-f9J~@tl;!-g?yarz*U%i+r8qTn}k3%H6$b)VzANNUs5EuQp
zfJd96VOX1(V)Isaq48)a0GR6t9u!%NCRwb4dnp_K?gJ=gaFVKxJTOl7ekS*sPzwFc
zwEs)y+kMg!S()#-Sazf&BzGC^EDMZMg`UW84&6D9Xn3bOzX;##@dhu&xeVr@>=A*R
z$v1>*!Xmsm82;YHL(UUnV4{G_EA78cns<_<UT>VUSqw4UUjL@H@%j2_-pEjbC*t82
zJP~n#*NdO|{MG3ZY`&KOVhX&oqRuvpgCbzn82+QX@X%h2VU&{Idf!fV9wLCZH5Ad%
ze06;ZK7$3zMrnTfR(-lp=!pvRs;3;*HBAFVO?V0?+I1ynZ^codW?SDto8NQJAg+h1
zZPjfaFNHh)#GY7!{}quVF3K%2VfxQtWzFyy9w4{idurKFBmZ^~iucoGvBg8V0VyD9
z6ScZIe&}rV^IZ5X7oHPX=){|kuaY=?F^X%T9)4$6zUgdrg_|EsCYy6X5>ZwXMXrch
zhU(P#w!@<%Ya2?^bh&IKJoQlUKFZ7c{<na8zaJrLbv~f<KEPE1pr3N#+V6hZ^8?K;
zsS&h^ncuR-&9L`XF=sDmwKGRut+B<4jVBQr&1kJV{)n?pB3@-X4*Wo11oY-2l+MsM
zyEL@$n62E8=wJ#DUH{XiFfKJ2`WN%=5qz&C3^~e%wd^bR=Imj@kr5B!YmAa%_+G<X
zL@h($0UL^g{(JM_-~5YzZ@>S058q$X*?)79=Q4Tc@=NG2;8DA0a{S&w7N3RPlijr3
z7q;Sk9GQi>AXmC*HVGhJBybe@UD%6OG(ItD+6|pE2l>u)t!l5y4>p-nh8MKdkXY6M
zZWhrdDO^p+L)rTqtm%GmDAo;{sP=xja;(hc^0zSp>78XFR^a}J`X;YlrhVGV|ElN!
zz%}D|%_EFPZXM9%&|Yu&^<<v+m1|E%+P`?Wg}k~SG%vnVSi7xt+J5?QkA*2IRjgon
zc-Hyasi@kJ0#&m8!?b|(vRJo~V}tVc=ou-KYX7kk!;34KCP)|OGm1Pr4+S<RuPSlx
z@k`g$y`E^+E_$;2Uuf{WXVCYRxAPA#`t0t9fJ}51%%6Zh92H`(p0&X7wi`>YY<Q_A
z)6c62AhduwN(Sk9!$JNR`H_-ELN@r<%^DFeCurJU%s-GrwNFV$tLqXI{|Wi8E788i
zg;;<^JR*8;(sn=J(r9@^F-UxBEMWL5Z)@;2#*|-4j#lcrfe96E(IkgbG)N`)Jmv>(
z2V{fz>#i>QA+%d;tNA*Bo(~Uf6e>oxp2?ot(>(%e)=(Rgxf%V#9%A?A^KGn?bohwz
z#GK|WbQ{9fm<Vg>lbK3?6I8wpo6{s;&Rz?W{lwo_UF`Sa&7jl`{=Sv2#9v)2B^Ec6
zTI%wrq?_2;vVULbaaH&ibXh4CMo+z4-Ql(Ag;@#Jtu~lykgt5>bCA|H)k|(W%g?2B
z8)%dYF%TVAgNk!pZe(hdCKe?*3<GDtBYE<_VX0F$$xfp~>9N&AMyI+ev%E-Eh2r-#
zI_C#(#~c>K8ozGv$$xQuC9)c&UeG0g(3@7{p15pls!F~(hoKh%46255=ntev4e)Eh
zPJ()E_;Y;-(QTRyNPKwR@XvJW!BdJ-QLKNqg>=d-=1PdI2y>yc31yBThU3kc*HZhW
z{=G4(ywj<#Rs<aHb}02tj-I?7PA~qgV4yxRG~1qTknybI;QNt;y7=>INbPl_H2T5B
zAQ#z(zjWx-r~9_mFV1i^QC`Il@THbTu!K^f-rUSrD6+!&;ZierX!Hwbfy$uUA~#PO
zJ9o%yH%)Rl(j9-;``bo)5e~_RKa?d-Og5{*1k(?C;h5<BF(uHD9vLHW{$oY{aNp&U
z;IjrROs`m5Sw*IZ;~eQsR>Cios^`OhG4>gfM{axOow|>5{HgBBPyXK9&&=0?`ON}t
zb=_y^<|Cfg32PR0Me#p6%D;EqKR*48D!$?z0aEY(7r*`4Q7N|#Ni@9WX8G%ops}#j
zAvHICe%gr`U>BMb;LEMCj><a3RUt@i!w2jCO*Nciq|}SCqU+q{zKuln4nBbx;f2{e
zxkWOsViDeJN<==9*7VN>N^&<w?3AWjRB66c0XeB;s~@^KkGID}plPYVlCE%W0qGQn
z1mRq2JfhQGo)fWBH6jc;Vr*@~k0t-S$#*aId21V59qVl;ADvR<SJ#Nzk{mpYCTSQe
z2FVnv5yaeVq%Qz{W~-9JC!-5Rr^Hy&`<n-@@fJL)OedtZY6R8(<Mxb{UJUM<oVeWX
zP#J3p!H8h3#3&{I_of05Riw(nTD#-TzsE6_$17s{j=I&l6*>y^8)*@fRVLADwcbJ6
z;a44f(NH0GN~%#&uFz5}{%V)<Io+(QP7U!^GN)kaM=a8uNVe{!FImuoG^KzK84aIa
zK6m8F?y-mz_p*=5!6xHZk4M+KmwycmHha5!Ja)kS*3arg=5G+Zy=pYr3z~4y9}a@g
zaV6^Zf68iyo4HZ~+LYAS$zsR`7g!8XBiG-Fn~bHTQ4OjjD*!yiu&;{m!;cE&b8#Di
zYi@2_SfM0qsOFFgi)#Kc(__sC*H@8J?D1XU^4%KIMacccA<-KA6My95GW>K?5-bZk
zV8rd0&h%0e3fW8<A#B++Y`Y5AvU$u(yCm<^ri)y{7d`I&$=O4mxVJVh*CUKhu5DBb
zZ|n3hF>lDf|Muf~o7sVaDWj6EjqRd{Pj7txdSth&ieCv#w-Xbk@G`q~1%JAfSY~^Q
zecuVNp4dtiFhi0*h9@K1Bwy!A6Ej020;Jl>tnuSl=){Ps`f6IErLv<phv|E=`Ej_9
z*lKg>jaVHZACZmX=gPVcYi=_*U1DYHx&V;X#1EO+stNwcSeB<bUi*`(o2OW&{=5p#
zQ2u6_DFZD32<hq$`p%k;sQ>??qJGJ^#Kmc(Mt-hk(E(~qGSaa4H)yVEjrEEDqy~kN
zWxn;Qo+jfY=Qan%&shte2iv&hupT5(r`~fqJXtUKt)pHfF|JQzB;7UoB-m|P7^mTT
zW3M!U`w@?>W2;b8Pn>|`zs)5eD2axOv0F6#Gzuv|;ZVYII%o33<vs2JJ^9GOn#**l
zPgUYk#w_=}-V{G*jpU1FZYlDV9l(o{nu#R<-Ocvk91f|MCy6^`MKRNqYM|DEAspTZ
zRjOu`jGbGlDil0cZ%%%A-X#qja$jBcb0Y*uMI6_haC5i#gqIeXiv(&z8CQ<NffvPj
z5lu+G%?&=8Y;C%B3-7QO_K!(@<+i2Pb&@as04g2|20EH5&U*RVPL{LP5-t~6+^-bL
zSPTXb@r;*>n;L~syOBoS{xiEDqjl~wm6FQ~qDBACcB%f(s>bFdvbo*<7d9nD(%pC$
z5jpAu1&<Ck^W>M+w>9Xp38%V>2#SbN>~Ht3(U*@yzNc@lyj0|OyQook>Vtrft;=Bn
z01rOs`Xbx86jZco7JO9rPF6X`9se48e@%e%*`=gSNx08=Ph3WL+K4A^g^(TBjZ##&
zI(%sV(tAXu^AZ$~oF$jVlC6erI6!~~#7g{ho5tzU)F6IzPwZX=e5u$CxOF5mDjE#~
zns9fjBR9W3k<Lqa$9v`0zHB}B>2EFS6y`xPH92pk6-40fo!Sy&R&xvbnVUcarXCmc
zRz<;LN}|~JT1L}fy?h%J_?{acn+Q$#b~8s1Xk*@`EGsGW=+R{sJ-$R4#A%$M4)zyw
zlY`pK3ZkL;z^5l!y!iu)6@EhFA12aO?o4f8cc}PclDNmRwmF%NVPOPuG-H=3+ZGUB
zF7qrydq@#ZrgK*__^z)ho!$F*h?BTGo|v$G=j^|)!HIw0auRk1&+h-cllX5VF>&wn
zS<c_jiJX6ldj?GEjtL!2;{N*cX*-JBw9_I6M}5}EcZ8{YxRcAFL7yiLYggREzh^0s
zN6~RfQ4`6I#<l=n;LxEW3O4n`W>@PD<$wZptKz-jXBhJ%FJ-aBAKO#1lb1-MStEoD
z@Cf;BE7Wq&e3FH#8NCKtMKex$+>m(`StW(MFIEM)^oXmJsCwS7w<MP5c)fP<TBe3C
zRA-wP2jG<!<XL}sPepKJB4}rJs1!Oa07}z_avvk<L&nl<Bu%YnDaOU%chru=rlV1M
z9oKsxNBp=i#AYLIra5qmg^gXP>WWqqm=v5Zov@c`-^eoXEuY-s^=;yp_s+M%3Y><f
z<5ATVV@RSOCJN1)7@K;mC7DU6DusfXvlKMIpZXQ%NwcA`Z4wu4&hA;W>dUT3Vyl)U
zEChh7CK;z=v#rUJQBwM0#*%al&94&zHiZ+0!CrNFHmf`r$Plt_+FD(9Ko5A&tK6bk
z*vFqbT#}bp&u2W8x{%RAp1SSZ2?@hMT!xIPi?$cnc_<jVQ(bbL79CGdwhhhpkp!zp
zz{3$K2UKTbu}SjK;Pt)K1nYqs*AhQ=x+c@Aa+2T9uP`zeX944nYT~X*J2-btxxATb
zCITUHBvVlNl(8xCi7ol4oz$}tDO9Ljn?3J2VdRZ%DZ*j_B_gFDNvyPvE7&XlEC~{(
zB(d%wRY9g>0#u2e(hoiy$qH<eFo8HZrAzYxrET_Q)5GPkmV=Mp#%YJ#>6=D=VgyX`
z(JzXRqDO-|A*`s5qXdD2FzD6d``o$UC1d*ixEsJK&5@XTg3J@$Ss<-J?-R}LrOB(;
zaa}CV^IvUnJSbqUF7`xZ_g>1r?gCjdE^KW|R`=#54uO54yt<WR*PEQi;<LwnD==X;
zU%yCv7)=c&r+h|;4w_GVEEwxHSHN}_+|;Be&MKyYM-qlJ+OX6+Kzfvy%?qg<5l#kg
zSS63okg@h^XAFv3r^e0YV_Rpeac!vcg(>n)d=<t|?0k;~YnO-Fd2nN^T?D8@rUE7i
zp;)L|ua|R}z08hmmz(-1RZ_priQiA1a#S(j2=(Hz*^BMW<J(p=x4)@gOl~|jKXIoT
zGYj@XK)Bqp*USXqvXCV|u}$o)szm~eKA7m0ERXO02qIr1w^4v1NuDQ`YTSk>?wDRV
z;z3lnIFF|+uTzuXIaa8_9I7DLe85?LL>?#2r+(ILk@}i^9WcmRCLmQ5&5Cm|U~=SE
z>LehnF8LgwL)u8Wrff)f8let4@L7h>9!SSZ=B{n0I<V6#7BF?3Cd%D4<F6jM;loGz
z)%$Is>GzSQiC!`dYAMWFWty5tV&_AE;9*qhLTz#>oll`M?|u=THd3iD03Hxq7*m}$
zY(ZpVNNd9?Ts_v-vt8QBz?zEUS!&`Y^l~q4(&%cb*JG<zOQ122MO%<EEn5)BS2vx2
z2Z?IDy%?S)2CbEl@)<iEaBPO^H}f^~u*gyRcMbPmJ?Q%6E&uWp!e~nTEQ4A{30-Op
zR^+<0#d|!o5-n8}PgejUY*tL@_qI}PBy%mcQ-1>F+6c|SB}if&2Hq!!CzQ}+A$5)E
zCz?9ffpi;VdYTHfhV>Gtqu%ahhilTO(@rFkyy7`W6)ugZ_R|iYVJr2KoI9i&4G~8H
z<H!ArBV2gTBgMkOo3}{C!iLZ^^hPPQ#P(VbcW7I==8*Vx#T(JHsT&RaLsJIHq`5?l
z1C>6P*i&D-T85Ey(6cd9o{|U3d85bQyfUGk)8GaoxVh3(g^(#HB+byXT!P+NtpM<&
zN!f1aAz})B>ZKHZwH%0r6s9F>FeqNo^x)aTis@u4e!!|YZ(s4?ErSX;U490d{!*Qb
z2u+u&O4mS`Bu1o|HgV}O!RF6>Mcyt<2x=Vd9X5x8FBT(9+PkQXg_BI*(O2{RQif9p
zTlcX|@lc)#*#AMXq}GVpk$MItl(U+Dxf2q-YPw|(JHq5$qVxU=*FO>qJ@^wD2LY@<
z$?6(V^{#@rowWG6iC2o$%f)$@n({9`S8wy<9@v^048w5$I{8PA|8rPsgxZ9X2L0Mm
z`hVf?e<z<|?LymC1h4hfQ8wQm9G%nyK+@JobOa4QCuZ*Az#QVeqz*Oms+H<ZA<@!D
z?3>VARR&z?;Y{$hD>Z5s9fe(Ni{K7gHD=Ozjh-xNPc7}S8G@4#GpN31SRqayD%xkm
z$R#E+iE!I8ItE6N1iRMg{~t{Y)|;KFKTxY90th|a=d7VdOsZAHQ_2pP*%0-Nros&^
zih&pSn4Y2u2~6fp^|sY<o6as#fk3O1P^|4z;p|6?!ykVK*c{(qX0@2Q$bVwtgxxHH
zDjg&}&IFyj5agK<<dq%deJjZ4e$c6>LB25ph778etvoRM>C7$Bt>Ga5`+~p$J-eyF
z^i$i%p5yXa(JoIvCJlD3O+#v&3wxJa=s-W^u3n@^zuwv2Fk5z95>f6~8Fu`0A%lX&
zH5fsuHqey*J$glSaBNX<Tk%sTQuUmd^5y;DtcZ$4SExFI^l)yjvaa=d&v6=rlzK*B
z;6q<_T|=x|SLm&DtzF(@q@rmpdZ->4P1b%hHJ81}6q0_MdOTP?w&_eKjN`kOSf{Ry
zeS3wq8qRrR=FtFs6k`5q@wof>0rjZmf{srHoudC^QJFd+<U(iDFV(fFH63;3O}UA)
z!8N^fiRR;>3`im9Xo9>4?8oPdr$JVJVwC0zY10Q|V4Z&(q|&AyHcBC5aVQb>`i!?c
zP4e97qlhQ+UwsBzn6v*Uk#4pa^|VkBVSTES_J`BQCu!Nw&rd~olhwxxl=Ehh0?#Hs
znX4HlaFbo4X%h+A;0&mjx6a^UdeqE7*Eb15y>v1@SpA3mn|JHp@7h6HV)K3BDrpKK
z<@^l;LbhK>K*Xz({|t<h%3=No(~28D_bIoBo>16a(N#RF35d12Z>=t*^|F(h3`z;-
zu1rH(NjF3RC#3K*=9|w+Nd5*gwdy6{_dT(*kulTRI<%Vg4LN>G@Z&cqnk)spyI8%3
zdU*1?yZEDcD6bxaQbm=h!AI}}N5n!UYGgi#t3#|XG%N;eMG8xYelKF)m^J$BI+Alp
zFT%TstE&5P4B>uEGF@!&ap={phT=(T@#_rCg%%*<(@fSm`#dhYNS6*>ySJ(FepT6>
z6tv}!w#7RiVSVY$lC#Eqj;&!)>awYmxlhHTJZIANpn#n*`19j*y$BlScK{fak+BkG
z^g?dWZ^J0(k{Yt~e9<K{Plg@e53~0_Cqm^cIG3>SXe)(ioK7^}GTPcX+J^J`;&T-D
z*U_}O<{C{pH)xvAm|3mE=5pX4&LGhO2}5O_(RM@I$IfoIdGUlbrFfjZd;&i9dWS0s
z^dN2#QX!Nf->PENlzd*`NhJGTDSb*_*|kzREoJjW8Su*%@$0?OfAtX%-A9p$UIq<p
zHf@KOlX<%OUa>@nif?R;OdkBETE9LxeQBCrYaCjJxMC3at6`QFL`b=k_<N-OODnV`
zVyEAjL37=-2=h%VJ)`1|N<B{I2AEXAxPj6p@DiQd5FvzKf%eVz7rVqV!gdm4V`Faf
z2ZG2|L%agj{N&x#vzcL@vM00Y+a9<g68K3e0?b_GQlDj<U4Y%-{N^pbv6~4$J8TT2
zO!FK~<s-jIEqL-{lmT^G9!gf{!XqFj?1qpaz=@uWMNzCVgTX^QYfPc9hzko=1?Y%|
z6Fa-fvnnTvA`IAV8v^9~CM2jQ`I9jG2PTI`r){a_JW5Tr9=aB@e9ct<2W4@v>@`!u
zmU|h>tG@Z7l5ntB`TGHbyL`LB?5_R65W{UJy59~uL&d@FUuyR*qs9ZR@S4&`<7U06
zzpF*}Bc)i~vOV|b-rae0(GmLJtr4c*)fdiEcF9|Y_W%5Z;{Rg#&=IfVS1p<kr7=W=
zuF;dxq%;EIFyyJ|aJ5r#K(d!#*>!>@+K}$6o@*o{vc$pUtIhLzT9*AgsJ#8ld)gS$
z;78TH!0U@iKD!8UEzLJglc8aFOzZ6ffCu3}6UaNBVXqGw=%slGbrFjFDMAXkOtnb#
z^K@|?|FODArNL}@OUfRU3?=8abM1Y#7RD0Ntf!bif4@-Z!YgyPRoL7udlqXNFsUcH
z=+F&p3@I!3e^W5m2GJRgvELEo<Dhpc1}Z;2ahTnG?@;v^t>?KaAW{5Uql0~mkm7Kg
zitgOAAmQY3*+G@BGxyK-KN37}9hUl1;7a0JJlI@-^6lTHj!x)kU*<DWY8l)8BaoT(
zufHfFifp;d)rc1Ssww~ClM5O~4yn+il85Rz>iUP@KVm)A$rDeRIv5`><a?-F{M}QQ
zKJ&vcgEX@E*nmIu`{VMsE8pM0dq#!pBy=yfy7lqUZ>(q``&I0xCdIL;)ijly-Td!e
z8`ULAv)p?5Dz~ykN^pS3<hv7ky2dXpcL`RvVuL615RvP0Gnv#~lgdTh)HIK)(*6$q
z0KtFq(vOO8n61pv>65JTE3jW895hG@16hNDke)#3oIl&>*MT=m;+vH0QTw~+KA0Vg
z2@wN6FTc#d+52pru=q&BA2;@`JQUzx5aeIsZYF<@NBJXWSIp246F6=$VcuqE;UwSU
zQUs4$Qz`c6lCEP?`$$DcKt1ls!I~VYfjZohdF*p{U@`SwoR*y4OLRULV<?_(ZZl!|
zNH*3Tc(-#&t>P(&Ve9%ao_M>8j;tKB(97yWoQ^S^woO+zq%}0$6+YG2Jeb{HEc$a#
zKQq|!k=>ir-5n9dfZjd*oR&-;V9+yq?vS8ESZ4>^vno=Ce3-Lv3Eh(JErnIEmcHUe
z<3FgDxA>#J?Hdid?kbcYW!QG%@pp7tQ=dRwN`Yl_@v9<Y^YoN2j=}y3Kk^H-neNo+
za*m+McT~w;3wcr!=mbOw8iR#AKg7()U=)x1pl|=CoeVDqs%Y`ocaV6{Iq%SDBa42i
z4@)8)lMXR1L>TEk4}h|19H<<2j5Fr@bKK;sY{zUs94{cpNBr^eN%E($dBfHCcIR6!
zI;@;=TeGJ<9{yBj1>!cn%!3L&|J1S7B0u-9TfEK9LRMerynOgBS?=ee<@eQ4cDKNA
z$nLWvKJRL+HYKw=KV%-c_2|ppE7K{KAY;lB@k#tEl&O(wTb|q+rZY#ctF`wcFxysv
zK)%}(ajZ8lbwg3-J^HTMEDW_VoK|I1hNcBO0vzz8VMC$7&$`vcP=3Q_irZ7I@1On^
zvid3`ks3V(RgSfO!pH&YtOildU*NFIL);QGDY*v9eL}?8vo;?-%V@KEg_7v_{Q(M=
zM-M}lUO@4ht@gqx91IODtH|d_>JzENBy0F83Y=Q)ljy^w=#?o7hLZYaK44N!7Zl-f
ztNjXGx^$c@8ks?2DWP@K9DLCt`Gtp5M3Z1MA(h1oSl%dC-3;6K=Z5!*S%<GRXBeSz
zV(Govw6*}ryr~bd(u#ty-G_m%2Q=*)lARpoqJrSAU2-*0oNQi|eZ|R12R(=gh)%iw
zS4LTB_yb>%7G5gPH^u1Ohctl1qZLV@HV`I<-h1>(Qaib%w0a)`2asm#A7xFGmS@(|
zRQn4IT+&SLNJ067!sIuu!IWG?Mcacjk7QMCPr8-hF?<rBo_?o^!W8#E{ij*cj;!^M
zdWM^H49CWcbvTch>C3LP;A;kJ|MBB-38zYfmAFjC)98NHm&!AjYLE1K-?nD=iGFvb
zEBX@)L%5<9x7_>PIu+~f<82UpNh$KrD38geu0Eh1FQ89xvM($tSU_qfl&1JJo^jt-
z-jJ}2<0ofI>nZLUd+0v(hqhZeR3XY$<Kk&qiEO+OpZ9a8rnJW+y8&YQa*p<ki?GmY
zCB-#>MS!`}5-Scmudt~D>-yQdV=Sp@O!|o<)hF(Mfi}23e>X74v<q*ttJqh2>2hay
zv>>T6qSwz2`ILP#oR(yNI8>9MMx}T1_??aN$|TaH$>$n%i&86Lg)PZYV0lRYRtRU^
z99yXLL`uAwPj{d`+M_F8(m!!@cF<h(`D>!>I$W7z%WC=rZ!;ef3M@|3an=+@$M=df
zN!ps8!{rzU>SOTN?DkV!U**zA6gqEO15>@ibz^~D<ENpKVjr|_4O^+skl<2Jg>~jT
ze%L)Ov6D&=&3It&!Ri@+y|u5aw;5v{4s_zQ(RNvjd7t>>?>?W)Y@R9wVg1-HbkU)q
zJm7mkPnF_FmtXVmCseDYu9dykln>P1N%*0a%NSPur7!FlrY7f!!rkA~MZqps*Q%)Z
zRV?NbdNJ-sgZ2ZF-bM}F8!rdqjvkb^ACXB`Rsy8k@ymTJLWyBw&u>>Fk8loxp86Z`
zlA@cZeA;RQvo>4wy01n0Au8<LqicmA-i?b-Givqb580m?sK&8i#JslziL;<rg);Ve
zaXZx342?9=#hsk@f}ae(H{r^4g_}pb6g5_RzI!brx=5MIu<pNuCvxKgyxVymRX2nH
zvT|gSvh~!1#|=2Hq`a?EP3*8RF$ce`#%rJYP*(SG;m_`VN#Cm!^P?jqvU3@8!si6W
zD(#e^y|ujM1BM6FA37UKP5&94ngyXcn*SAr{T&)aHN}3o*9ry7Ay|>r<4~t_c|wf_
z5`u3#px=Kj35L<4Wht<+!wspn6Mw2;V7J#b$^&`{IcC6P<NuuIk~kNye-<j<g;H5F
z<u(_2m`EWoR)$c{h;o`-5{Vq3iu-5s$gl8^vh$2SEJ9U}>B{cbJ=eTi9aVH!TM>Pz
zYuGh!3y8PM=_lk3v`cQf84e;BznR#~0cm=2A6Dogc)1~z*}r?jgYsWayi^jdzTQ(&
zZ~fl%b<LqPUY@S6{t9ukMU$D~V}Ww0LuT{y7qk-F_~c?D%-()Itmd}*K}`6e+55lW
zem~>3*rX_!F9}@S=~uGYN<X{DKR(4kW8`{>+%%<$b9jU5yo0MeMvarZFXH4CGn#D8
zV8TFjV;_ILxRZ+Y%iUmDzbF76K6Y0Nf3P<wf7aVh_vC}Cy&SXtcQa=87}{+{0H#!{
z{luhk!9;HO^3@biAUD0vYW2Ou8Ie)Kz^{idvK~Ym3lBnB;(g4tSo5LXq_i6<xUGzL
zD@slZ_5WaYL_}C;lHjq4RARH`j-xs)cNu>P@B?5}Cs-eGXDW1f;n*(q(RJ|lnm6pA
z?Wmi3=nci`K;Y$hr>O!~lw|ch@d@@ly(O7axPV8OFIa{-s7_Pl)`t{XIOSP8F)f^)
z7xjo5_hEC74f`ZTQK}KFf8m~s0wxXG0{WxNhm1lknm9;T6O4<Cs*JhX!%#%6#mMMB
zCj<^?qFS<XEXlM4gq7m+Tn`V(wj4JJ13kLj%i*`;l28Q?>e7u3E8Y*kHd@Viu4OB$
z)o)lpwQA~@N2L@t5pceEiv>JwduCWN^}!ZQru(?rESEZ%`$z;nc){bQFSmg?w6mJ6
z8K3;9=EnE<<lhSw?_W*ZgRzI&Z0rL^aDLo!%J01biQ|idmV2X8$;5Bf$q9?u+U62D
zJis;|J$qqVtdy-Y#uAISGOOm7G;r7W^ENvyOFz(CGK}kBxy<5i%!jPBJFL6as0L&G
zo)LHrl@nU)(BQ3183NCxRl*YN1$F&|&H-^<&%o>))B49PR}IRal{TCz_imcCtQ)M5
zavxvp`-&|kYQ1;bq3VYv;WjHJAppncD39C(&B&NyZS|g^2G-u={!-?WyxULTqZX2x
zmYvd8b8iEU`>4Ko@msz&H3yYZ*4^D)ss^}~S7WC81ifYMBeGs%)?6m6aZ3U>FnJp{
zjk9R$=MU<0E5h59_IVPxoaWwoGx^QE9G``p#!cG-z6#<Kyj3cNdMeg(n2dz=mndcK
zG%!|8nFc;=tyQqhFV&aAE{WX5OGE{|-G#OqkD3b?@qU5+YNQ^gfcc|JaK42Y16xV@
zh{fg@T7@Q4mXcr|gk$$vIMwi<wpz0qBvtoYu<(IGE3?R?r%6i*m~>1dS3j~>eC$(;
z$%<WIg>K2n^cY?q%*FXJL`y(q9b%2ZpJr2*YH+JH_P1PghQPsMNthwlnfBUw?^`Mc
zrvNbeD6QX+MU_wPKU3!C_h$KcO+kJI?~5Jj{I>pbYazv%stq2jM|LfLZm%h3*d+6_
zWdT(>F!-&C9qWY1u;f`?K!s?qY+mOTB--nnM>m=UbtsqoV$iAG-0B`FhCAF%6_A>C
zhV&+l%Ak^k>fT;H^wb!4$e0Vw0EMOxN(_mIV8Gy|BvenY^aexL0H@4K`d+ij5Dv+e
zUdu&?<Y}zs>4oH*uI1xG3LMr7+(HU{)(ZVYiq5Ysz753JCCPdOzBgf9G^XgXrSQeR
z%A{U#V+u#PC%`dKiWnZ!*WD*^Ik)^;ZdQS{q;kK+1lSDQH=Xr1PLg8iMYY&aEh{>c
za2Tww;aR&wjcB9cj26n!87aOuamqQtLslLbYfa@Z_dtM@)1q#4JrN3vhV)$hM@7vJ
zTXqK$W&`VdG&0Snl<nPAcJaqlZyav3lGMUs)<O5g=TP1KDQeV@DiA4bA4Qe*dY39&
z-RrdHMKG^p&S*4C4$jGPxAz37e|uG&EvGI?GZY=tomIPv;L0cU-U8eSEcNDdcWI)2
zQ+wQ}Djm#y-{T(1q1EtQXQ-CSp*2FbN&t_`taZPuZ$|;xK&ag7N9eaY$>|fe)8k(`
zOr|}6n6`|ix)VTwtPF8PZ~dck!#!&KQ~<HK5ob)rTul+z!t3r3bih+dV_)XR8n87P
zqi3`#WPQXIrp?LoZGWiBG%lk9P>(>Bn>*d3s@cJBdkET(>A{~~&u57*;&xQ;MDo}C
zYMiLc`Z2BY5ZdSIa-!uZ;r`~^lNF)<lBv(I){iW#uUyc4GPL?yT7b-eRzKmbmIiAN
zfzU36mVT~QD^4wsHV9<;jsaNL!upy0Tk406zIB2z<7DPHXZbdJ$-@w3%rL%PE}*#a
z!R~-R&1SSkbyzrip~H9V*oD4g9$&zbHCE(A*K#EFI>DBi9mzfWw)W&Xj$WX4?a^;Z
z{?aVr^{?Wifd*1$gpnK%P^%XDA<1f>8a5xUX;`*?WhcX5Sn}b$!#mdoY}6l26oA`3
zqz)F%X|Y##9Q^XfVS8ikyUMH&w(Fw?_qV>}v=r&|H%T{Ue@7?z*(mbJ^l*pt+Ruw6
zNiW*wAH`o_)&&)Rvp6_~^0jIRDjB~J`Zn8dsqO+tm>)@=SB<zQN_I4F>%X_xuhJ!_
zVMMbW6C^f*PqQZV1M_jxFWTi(g{Yg4u?y(H#xWb-57zLv&9CH3N`nsY+kJ2R(CZ}D
z*Npc2JHMJbgdX4ul9Y`56vy7>UpN@mjTFn+lFW~ky16A)6)AmpizD3{Df4(sraw}4
zbW8SSq}+?UV$;2IS5u$o@yK9tup_tjRc)1&`%4akWw8{c_#|=VAIV+3tT|mGD^)R>
zYM}^`jCCd5Q}bqX5t<p1vN!|3ezl<x|J8TPT42k4yi)8N%d$}-D^ytkqF6SCYov6a
zx0dbB?))cvhekW2r@;>bZlAIHA#R)G=Zt46D`H;ucW%slXwh<HiTR2h_39H-?j!k}
zA$nzMrfa^4u_jgO@q=*YS}G&_^?ub>N_DqY;%#K>dOclm{>zO9IW}nP>_Z2=Y-xT(
z@;uUv^(q0Z<trp`kK%;ob~X<;$WKO%S%Y$+s8bN-`BsiswbQhyRd5gY0mUjCW@{};
z!Ni`?k!-nc%yn1|ue;5q#YW`;0D2mySDbq&bdxuft*Aw<57Bw#)_h8fOWOseWq$I}
zilYU_){13?w$a5`-&v@YqD@tuI~h%Y4jwI@iC4Fl5J-7WKlRZ8)PYz?)qnz|-X>-1
z6N+i6wW4?z4Z9=RFQqT}fg2UI@vPEKOo27VpkI6)WAM9u*+OnGv%P+E%i|(#uCz3V
zMZ_8ZIBA!C<R<~SCt}uw(<;N`V)KGwl4R-rzfax}@AvC&_d$*~AJb<C(s)MD5LHn;
zCiBpj+V$~-i)9lrU(x3R9ovZlDW6XFizAXaianFO(zY@G@T%5Yt~>p%44NCpCbFB$
zL5u1R^jvNR`+|E6jZXut^RM|kPTjm{FZ<0)d;pdT<wTWU<z}}0QQeCAz4gV2=wZcp
z>#(+)RVW6Lm84k&H-_xt&wC7<-{Y1iB$1l>*CUILG+BQd!^?QsCKpe;Q4v||ZSFUC
zgL=XrozqGQt<8$UkS{}c<G#mHn?+&Nx0%lRq`q^~DTg`SIy!-gJN=0sw&dd3K?rb4
z)!HWlAIGxRljX%+IbxHF@EtUCeKPpr+U$?@2YDZhQ;(H@Jo)lpy0JGKirh;=8S`kq
zyXVE~rFz+nY1`)$L<_1}G7#X>=|N6?rbd1b4!uS>|1L%=gS}d6RQ4^Wj6HnJZ70mk
z8liM9JmYJD$g67-y+OCBSDe9-3Xv@A7c@!E;%|RR3k8QwV}P(X?9K<Zf&NsSBIY1`
z<Nj3VJ>0Ck^26lt^KTf=$T>fOYu1w=ogh7$s7Ka|zb%@YQn|?wtsx<Ve$S?)PuhYS
zt|tHnHxS?JNyF1fz57RFM{coczuWF!d606a^~=Bu)%lpacQ2s>f1j-x?C#>pfcL*(
z{1q*9`a!TlvMEmNH1RT9i?FSaPNxFmi9jq4wc3!+b2To`MU2_|lF4sqE+`$=)h=)1
zWqvFY)=__x|CG`Ltl4g3XdDN>S#agoNxzM^>9;Rm=Oy3j?KP2}@&u0KSaZ1QeqGEk
z*Hzpy!^3=NczNg-@0(9<xQWNV=xYrHhey_KRb^xr#ay`fgOy>U34L$644Q^OWL9(k
z>ukY+bDkib51btDKioz;BxfG1SVXc@1UHHis>j>aaEX2Iwjot{G4=*{2LrADcyUXw
z^z4H?l)%v&3OFUlcpG*M9*O`JM&ar}@?_Ai23Tq~>Cc*TxxNd8bK$*+*hhUs;}_SL
zC0^D$CVX<Xes?Ni#SSbKn(*0@_VrrAYR3L*e!|+#{k5uuFL(EC2_Wg&q!2@vc&C+I
z&r{B?Co<iu0>c&?`8FKc*%#tX2abk;Z9)B=?fvf;lm2zDt>s%EDv(bL<Bn*i$*?KU
zck#yTJ4A++7p(7EDoX=t@TeZ~Uk+aObmA{6E!2t&Jw~hc0VB1NcQTUyv?f;9S^!~3
zq=SxV>ah+wRm%ZxK5>Is1hFqE0&<PZ1xzkT<yS|?Lz$?1@tYbk+dIfWLatosKQm+J
z#UWbruYUpscRt<C{q*CW`<vVv$6`+4yX{>Ol1l|XP2BLB=-Rl()_$^*=t2Dwz@US@
z#14DNprdXHRu^ugrh!rbK)H!mv0F~?4g7g66z1E-_u$;yIm4dU6}kJn8PwVbHMv2u
zxmF{ub^H=3oX<uvdy-Ls!};n1yEk&CdoZe(YYgko`RNb3{Jbn3>smQC4G!7Ju#@_A
zj4qr31IuBzU2q5S(yqRFmv!pnIL^L=Z*0`3(UK!a8a}<V3~J}Ie_qh^0_&dr3A}S7
zjrpbpG$H>ddBdj(AKWkD-KJU6?AwMCG#BVW+z%L-`WN?Ew&&$HGwsKK(-y4GXul+w
z8MC*RjY3Q7u1H@fs;_yPB%78jE`&505*D&qXB5Ht=KOIN3hJwkD58NFfL9U57?2L{
z*3~2VXru^5bHyHl(K;m$k>gpV85P&f73oHq0HRjqozI_|bdfGyHHC}EThY?_&^f5x
zr&3uCX(;IfcJq#AsrotQnOl>U%(InycWPckT2dxPqcqjZ%xk9eQF;?yTFyb$D8ex#
z?g)_yjNEn6DS}x`fPCT~e!ttc{K5~QlY48QbnEsfSr%;#T+bgzp9u+)t1p5vU)Hgu
zRDtOIE<N%g83Wbg2>*g;J$K@NZ4#~0my{k|jt1FChPTO*M2IQG^Ci@ixhLoR|NOCY
z)$UvymGphr9F6oFKPqwB{#eB&l#f6jf&WSs@viQaQ|J%2_M#83;P`&VApc$5V}De@
zud6e;No}D1yTH2BmHThdm4>&kdgkBF9gV6VD!pD-UnlvlZ`YscdRX8bQ)lnZXKDKB
z1di0XS>cL7x9>kdI_5ya+SgKz*-%)Y(>D<vvbodw8s>@0IVEy<!ZhUx@q!$o1o&o8
zMR_G;N@-OlrZs#9<+er36D1w$M$e1+KcBihi>i}y{7ImGv$(!2{k{7?h(lJK55G#W
znqm0Yme5A#cyp^<UM$M-2j5~21+sNKPjhAWPLXQXa1=9&%Xo#IVlsDAZO&h6Xj4}v
z?%eS(wAD~){4et%<hu{URj8P~ZFh~S>m0dQN>TGR7Km=1UQ5zgdXrvZCqvf?;NyC(
zY|h`H)Zn_gDj?#XUvjOro4@bV>%~NkyTa4l;vKqZjkT9<iH%ErsE~cvzbNc#7e_1i
z%D-j<*^f{^pbLrlDThcxynJigfXJ<F2Oke)+F6WPS$f%kkJ&d%;1JC@K(U%<>7PMG
z(;c|`7$gqF&XYCYF`Q@j6Zt&sk;;-}ej!?9PA(2r)covv*d3JI-&w0g=Hu(k5!Cy>
zLRiVHwckd+!fVDE%%7<TeqJNjy3o?>ZmK@DsaKh8EC^Vv<QNTA=uEPmOsjFq+QlqS
zP$%U`^^b#e9~e**z>2@tyVXU@Mn%pl7{T&7sN^Ks>ytdVgyt5}cgVb4F#F*T5WhO1
z7a<~BZnPRm$4cT5x5m(Un4nDO6g|Yne!<%FAV8C(4V+)-`?QMW9JF)yQ*ERPrWnI?
zi-;-}kYu^CdSzBptZ+eP^cZGjG7aUOgt(ELV&#7&ORp};udeE)IW%_+TfGdArVPpp
zz2Xf(<Q1=Z1P5RyA75<?IE7W7>bUm1==0>IQ|ambm?s}|V#~rMz-x|XnaDytu%GC^
z^-=R$z8ja(fwKQK-oby)%iMV$km%K@a5S}!y%U}x2i{_JtmMKS-)>Z>pQv{sZI!BR
zP{mK2pR-yG%pdUEaCVyt02bISYT<anipPC=@;Bh&tX`ycuQZaTsB&@JD#YmY8nz>{
zgfcy?n>uS7T`8L5B3mtWsbLOVoab&@AzHCadV9Hc?&L!bMH!a53RV^(79aahmpTFh
zBsR&sd2-c)mr>k4LKKK;+tNL8r1P22Ej%X6po4kMYS&pZ^qH!7>;EdbOy<2`B#5_F
zh;5MUPx-vOCEi|tV&lB`ywB^W;vLO}8(|@*PR+j)f7tbE<HFVXQ}6f1JA1{xMWkuo
zFkn}>@*U_nGj6_BS~1PMijC2!sz#sB+|WY~gUx-S;1@a-4e328h6AV0gete``gNul
z!jgL5Y#XK8^uD$c`tgoBCV`%P^&pT=HlVVUV3OW8<FLxQt|2Q8oW2;P)NGzd|5to$
z;k(*|a|~YR*k@8j0?5_ooJeq`nQAWBmO#uS?%_C+y~dGU(pAROPRiyI)Qyavp`vNe
zZ`fmuhO%_)hzf%$LPdYh14AgWQyw-UKgmtLESyHN*OdWwjf89Ux}EvS*CUoQdam~u
zbK>i?5!||2NwPEOVS3OQ-y}sTWhpD5sStI-%UZ8-Nib*;O^m#Csr>soeR#^a{OGrX
zuDu&~r9bnZg{m7|f4Hz(VO*s%$l%ubxaC=s#Sl8_rRPR53IgRO-PjJZ^`QeA)P;V1
zCc5dB`6Z&Wqwom6<N|fL)$e(2@=W&3f5(2foXp>&K6e`$E9+dMACuq_QuUUlRJ$Yx
zi{T{{1$!1}QH3$H6w%&A$Ppip4N2mu`2~)JV2*&?D&7oo&|-SU*T>3_NIRr|22Ie*
zK3agvX~<d9O|D6BEy8T3NOw8RT86ncteEx<eJuG;y!_6DFaF%4uSK!0(!HYaA1S&v
zYJF1h=Cp{-0geBJ(t{j6o_V45Q7^GmRVpGRAKh6&_`Sp9A^91SKUB6NWNnajS)L??
zA9yMvVd}CFVUk$vAG|zrqW`R-*af<*8gyT%h?gs;bV*+Up~zMJ@s6M!R#`h}J>zv~
zW>9y7{!EVdH})Hgyzd(UV({MQLH7$*lXgZF@_8Iv3Zt!9r<3k3OEMRqxPsF>6or>}
z@(rFc#95ja&Y5r^;n=s$OZeJ_@Yj1BJK1faCP$FWjU}$X5aB;@f%(HlQ7z(G&jk}>
zl|};$W>8uhg)U7t=53t!mMMFi1%Kq<HoxE76lt*xotAXqU^3%)^B{14?k|>#S4*WH
zW*nq-;YSCTm{<Q8hga9IFANP@WOiNBzgzG(m(O(TO(MedPk@Mv8Q6WjF5~QwB0APD
z062rZew%Pz5=umX8HfvbgbzgyNP?yV@a&2pE~ex_ugFuT1_Pgoa^bRv<ZFH68o#hn
zHpKn%@Zsvle-05SwO+>$NskZXL%0^DozMzehXE#0KsXo$O-AuI1X9-I4<7=;zDRag
z%gNs%6t7%L2>*Xfz4u?z{~NdcMy3ja8#lPp9N`|Bf@tEXu-v0uxpH7xSy>_=;6^iZ
zG|<#+xw5jf!ad3y^)V|eXIW{fS*e*^e6Q>N;r<ie^Krh;^L!o$;#wEtpYeNKTIOf3
zUXxGHAbT(h-$@nUD-;mZSVjzPr2-pq(<I><&anGcbGYhkyoz2ZuItuG*tD8yII1!9
zkKr5&)dALV?YJp9{USla9fQPxWVPEd4K=t90mefMV{UA^WPtx4A`vG*I!ew1Xb4D(
znvc_Ml-c3=(6k=y;Q2sI48X5Lpilq=80rCPzy&cP7(fUCFhVXxM@r2IEW16Zuc4xo
zgVAzB5+MMc6^BzR>ubCw3aM>Vu*0t4|1Ybar1Uvl#Hx2IbGlJj{k+`z*w=~vyVr-V
z5}Ec9;RX{=Q(bzel>R?@J(NG@747&xXnpL)YUSQK@t8Sg)V<sO=}x&4&#xC<Z#XMd
z#xwqY(`rjyKKCSd=buCG@6y4N>K-i(q3o8;e=2K3ho0Dq8TqI-@8iqYAD;0V(|)7*
zsk~5DRBe85h{?}XwEwVv(*$pqTYXv-g?c|Uwso-Aez5hykB@@EGR@cGQh@E?*5X}x
zrR^7wxd>egj@~~^-y3{+|IizYg(q$8ooJzG%3ezRWNU=ay#~{-&W};9Uca%Wapup|
z&u<@x98$Yq#OvM9AqwSR`i1)fx-Nh)LPiM?&dE&?MefhNX^;PX_Er%?)t<-YCgC$2
zw&G@0xLaIGWhVCi{B$;f@yQF=Gne#gdx3m<pXZjq8xlf;G~{mslPtmyuo2-X%g4C=
z7l?ap7}=)Xt77ijHez&&QNLX03qKQ?$SPmwS^V(!tNoB(`*lQf-dS<iMvCdHlxs-i
zJmmi~e7bu`ICosX%IqklI0jgo=2-PwmkgK1!<K4}hx){RslFh_cecrby3Qyrt{vE`
zm+KGma~DQ;ct!7r9OH*=L4@QkVnE8ZVTXy?=v)W!0`?dGD}%~{8nJe~;okk$W;w)m
z^SjQDt!;0yyTHNVZw~6Z<}dEOj#SxgJ5lCa)%4u<@3)8ZHSbh_VO+K3f$85B;``r~
z{<q)$GP3Hu^ZKVwDT79$BA{PD>I|{zf$(0~-ydzcUDdm4x)+$d@%QBubLGu^V`^zP
zJA836Y+%R4?Dqe8J!OaNUl>NX4Rj*Hk^BE@tJ38^;Jlw3Cw_m)?IyyFnnSt?^B(eG
zk|xjC$<L9;K-yv#oPB5ilTs2ZXx|Gg;a1%^2q*zrC#J6^u<!!|?tr4yV_DV}`F}$r
z3Z>A@uz4Ff)P0P&@a4F55F#QgEG<2~$Rc4|-P$x>{AG<rD4gH3Q^>jo1@aV@ulZj&
z-EpA+v^k=iCuiCsX9;Tf>FjN0mFfZfr0HRdg3Qjz&UX+HHhzciRRq~Tr9R?WtaIP-
z^amcBT_q0a!4XQaMJ9Xgzl|sS`}O)|C3aR^NAZ>xPxWqzP97qxo_MK!@jvZsk%k)w
zS_{vV`?JP$Z-AA>1)7$)dMp3dSVk_2HM9<wbf3u`VQb}CU}Bc;;B#@(yNXSDCu!e^
z>$Qr2RbTs|!(#fK8y?n^j(6t~RiQqOQYUOJd7fS{Q?UPlgKYu4#Ut#{K!_jEM=iaF
znhlo!7UCqlG_ChN^tquAy~~=ihK{9^@M9tV<lj7WOT&C5CDh%zPdYD&rKReKyoL=f
zVyA3|tKRzSL1;+IwG5ltvo+jf!3ZseT5$0kzvr4INA=Qhn)zEHP-lS78JOKJmEC`t
z_?CC^e(ne!&<h8Kv8Cc5Hpa&5xt?6pgE*Zkl)|Mc$F?c7oc&5sEpp$EqL=Uw7TU7*
zZ-e|9=GtsQ#U3L``hlu;oaHb`f2dE{R)L%cq*m++QB|-~AQyWXJ4rmoP&CSB+-^l<
z_P?cvEi0^K92Mv!ijQ<Vd?%5j%6?vAO|ipZB*clPyHa<*A_2q3l4o8VQfKsa`-_Ug
z=l_@3j}3X&%tQBDPh(=mfnDdC@1><^V%|o309%~B=_SuEZ?HoBvrMF@sicb>ss}-K
zns}rNk1FV7hfRkfaykeYN+^7@ip~j-sIIggys@|NAulCJdnZ8k25OEC$&5aaq?Nch
z^2E^JX2Wna*WPbi(rf^8gSAWy!i<zsTM)B5qog(Ve`weBaV*H}39k$&SE73k8*2Qd
z?){bQ_WIH3t_Vp|ud}%m#AP#Fow8F>W%6kIQ%pMQP0mM$h7nkObj7LVPLY;#1p7ZN
z=TmEp6+j}qoAtV!t;7wp3si8bT@6?ybUPL=-;5iaVPxsMIC_v&{Dkq>WKIm;NjTh8
zuLOkyA+=<6u?HB7Nf7d_KSF7tq3wNMCLw^&R1=ft^!?ICWj2t#Pd<D9{q&#KNmPAG
zult9UvOjI}d+JZWe)i$_qd$+Aa_dt+yMNqx`{&8pVEws2&pvK#{CNsUHPGQ6lVU1s
z0<{T-%2&*IhH4Vwu`{8`-gl4Qt_*zm={lCxgo@R0SYYn5i}h~;&$oF*bkv4r)fZfE
z;(@xElSj(F-?G2zF-X646G2Wu;-&tMo8O~Kc?n}VQW+<12(f(c$p-9@bBVrTPGVwI
z&Ut;8hm?K$xfgD1&KO@jEI);CR^j3}QF@W|E7Ts-qV`Wf#7m)u(*SZ~_6ElNiSLzN
z-!nI2Z)1iQ{Ca|ZH}TWNy!2~HHq!%pBV>M~tuFnrMc<&E5mj)75q_iShs}xb!7qHL
zTFtZ6oLIP08QBY_80Aj|RR7}{nRj3(sJnF{Tnl^;F;$+`X1qZ}90~fiVU`lf$2bIA
z?NU_fHT|&M_;cb*BpeC^@%Py4-P>Uim#ZQ^eTiuI#{=L^se<$>OuzoR$m${&AGaAG
zzPPi)?d9p5k|(Z5W8@A?Jbl;k?n~a?Ka1xzQ+AYj+~CSlUC`d|vVFgV^J_dJkwMMz
z`5;>7F70YbDncaPT*~UwPe{r+qceVPw@zOAy{L2LL4^H6KOg%_{6Y;9BbQFnej<me
z_Egou?pt@vZ`#kgIyZAebR~zuylly#@=sUYtDoRgr_S$uY*@N0kg2f>KS*M}Ib6UD
zGi`sJZca8iWgVlO6Q%+{zSMUh_UBFsZk?*SEJ~~Xx-xUlZ6_R-uy1H5b@%!FBPHAM
zL8Tw;1_0X^`n~<;Q5;_GfI+PtGjp5^`LU5%)aTIu!QA0++q3;CkI&d|yTGfJ50Ii$
z^de=IZ{~%u$~L6+YqA?O;8w=q3O6j&XKa$uzzzB9J9lL_PU9gq16{&P+giip!Mj#G
zrKGFB=s$~tJE|MXm424|sOYb2W%)j#_J27pey=dhV@m!9^U&sB?61+0hg*W@D(g!>
zC<Hksyw$hroaM}2@8)y8ZexpzyTtYl!R1S&;jb7dMH2mBC_UR5*K>033E$LY#WXpD
zwDdhR8-rlu5K0tM0YtH3DdKLGY7bweSwqC(Fll^M5uoRl2+%{f4LcxpxgnT^!?bBz
zzV`GMF@0PLn7=K({B@m5UZ09eijgm2Ax%t>BT~y%v6l)?=fe!Zp62g#J%3WEph^FJ
zfq@*^s74DDjCEMXom*9;*})QzDH@)1iE>+Gi#4K9jZz1b+(E+#r4tH+-PpfG7b7RB
z3wX>pU0f^)@s5!6O+f-2%KgJvbrDLVvk)mhu*9;lb3P`AX(gF5>7s=uHc~{`p~Da1
z;sSB-Qvf1~PZIOY5?K&Y_>3}ac9V5>vtRc8l<bz0>_;uxZR6Qb*0KfIoDS=pF29_f
zl$^ejoPm~{=i@nvB{1y*YqYhrGY(!6g6t+rTBXRIh1yTf=ucHZX_#C|eBNxI^ch_!
z7lSMxj_MwZavp{q=fNP>qD6JdJSyx3C8QKU(~{5=lhFcA=m|Q?y-7O>CinBcIP47%
zE`BVjBS5Fw&^rVL|H4CqrDOR%bDvaVrnqsQdo^4g<J+Zoi@_Rkfq!{^HOC9!4_!eG
zh%u@%EnVu?(#a@cr`A(`{@=AjcW4p0(&%^I3ZnnS#ER{Z!pUwRP{=EAe~FzVAbT-V
zM`U3h{VYrc)Sw32icx*Y$L5H<0IL^9HH+t?Pka*?tkO`gA4qtm82MPIiQzp#^dcW;
zyQ~7K$?@|W&X8B8Qt3E&KTWO>FmzsmiqJm=fT9mVE<+Jsz}KTlBQss$;+~Laic&*`
zm_vNkSCfcL8}YmlgnE*cKvuQcS-mewZoZ(5)Ks<(?8SIOqL-v7Bgh^TOch_Xb4juT
zgM2KWR6s+fi%2tk@lyrpGkvfjy4*M1&eYOFW6}}|Bv=ahXp$m&E5wXwl1oo^21~<5
zA<i)03hW^*+1Un@r}v^jE9ik?%;NeLSrB0K6Fo}JkD5liL0y%b421;5@!hDbP`i;+
zhkPfo&z9uU`Kqsd70h2t35QEcsgfrec5pC~evXJn0wQGz`HWieh>yCrq*YFpOb&r^
zdC0d^WE?;1Y-6rOC_J(nbGa1VG=<3}=yVQCHd0H(r}n7XV7v+2#zMBGRAMrl^m>Wh
z#Fr-fKq`NUwvwRg{mRlNo+=TOZhglR_FTtg^s4>^E`yh$hgQ&&{`}QBWNs4jC}6z2
z<Qa+2cpGzZVG`ZUw}%z(ImbkWq@dKN(JfH)iLb89A+(Hf?4-E3TP5~|5Qpp_Aiv83
zKI`bu{g``4Nhvy*=8+4MjcyYRu0Png-jTnP1PLTcUGBhKFS{vQpt=q?Snsyw&?*N`
zNas<hem5{@8qixj_vqL|r$Tneiz#BF6kK~PrEM`^Fo3X2zW%&HH{iHTbwqZkW<5}N
zO;iD4P!j0~3aL!oq$KvZT+>MD-z7;A^yrJkb+P3XAyrEMuGD&n8z`iVqzq`>MK6X(
zR$-7jT2&teC6D+i>q};*Kh^!{z#yJU+de>B-NUqg@osUvA|?%gMnlc<RTqe1C=g0W
zM3dKVt^OwwvX0JTT|QWGdHsRKNjIGHHIx&<5;TeAR$=KvK60zUF#bH6(*gbOJV|`{
z@_S{;XMF4%iexi20tCQ3TuIv5Mxo~&BnqyGmt%IXqnm6n%o#;7X&8lsvd3Eu@w3Dl
zi-d&xswRkAuQ63i#kmDYl7Z29NNIf)_LElA>VJqxFD1&9Ie1+g6Pw}OaN9~55bs0*
zROAI|c&MPnd2)Mlv&A|g7BqZ8*udE_fH})oWpBq=NE8l`NaIWB1!55U7TMu+o#YhE
zB?;YrH^5~XewYu7XmC1qPd3p+e#`=MhJ<RBlrEsj6?_ee$H6%b;!{Mk{mQU%qGSiP
zCgUxJI#89Oawq}gyG1aC@4xMXzrIB;0)&Dl@#Q99(&`0YKNp0U`-Xl<RtULuZ&}OE
zu@#ff$9BBDmnALfONIL2plREn(2Q8HiDjv+t59%5qN1julGvnOd-#;xA0L^wKhYC+
zF|tAJs#C=@nHc$Hi7Zcn7#^CrjGh?4Os}Jh0w4d-sS};NT4-{(iOWADcl+o;St@lP
zdW*9b5}<hqY0&*V|8^WS@W2fa(Pdpg{IG$ZyooU=L0>-NG2qz(E`YC@U<L^F5~1}-
zPiO&AN=F-|aU7c4f)1K>4w^-E_{fw@dSASYiJx$Ksv^zftDgLZ;h%5YBHkA(Xbbf2
zcA0vxee+<&iqzg^xohR<8li#QWs{4IGD^?33qVx38}#n870H^n*uaJ-odBSC^xFOq
z1Jf2RcL4LNwSCU@M#?Mf9Sm8+?%vlg80K(BmUQM<r+T||SfrEGEv>jmo9H&AOzdCu
zA~xo@*`q(ac*zmFE&g-yM)4Cn`<8UhabL=xNw<)ausuqbYx0E1UZaHauGm~^5iQIH
z0gAp$EkX>^xxwO&o!2>)s?t_Wc`Mp8=$e-yCK*tCxEeoz54>@v{#KxKro53XM6UD#
z`pob-@xexoc4*#m1FAwTrUCtzFc83&`b%q-m}*>I5(%>pin_<;e5ex*5xFXLp++{Q
z0m+?|^Ibyb79b7^(`|q9;OUd7it6j%a-M9_Y&rx_?#Ut#4a44Q>5t!rZgbwZ!i2?4
zKEIy&v@rGxG6@R3fQBDGqw$Q`9Eyyg!^r)fSC%|QV707J0tkno;SV@bAr?9#rl0`q
zuf1;`?A=)1tBNl;sk-+m4!&>u&CmMCTMfa1!x=%X7`otAmGbD<U+QAg=(r5s!z1wc
z4yg%(@4E*!w`dWv7utr)(00h{#303jTbQ{0@ba1MGiB(#>s^2Bx>3s=9?eqybh&Xu
zOwAXryp}y}M9Mo^PHNHdj*9QAy9ZDpv|^~-twA5@&{!c)>Orv4(*q{M4W&x%=qVb?
z;DAlGAtppPEJYjX%6WV+7JL&#L*JtxCz_m)m_o%sbi%PNCnmRts2JTRLIP;$RhrGC
zNpx_GNN$Zvr^W$m0$>~F1W~iN8WV^+NAS;Mx@x{A_zx5?z>OXa)07%#P56ow#4PaM
zf7o}E<JQuhzibWo$4Qet(uZ8yZ>Atw_Y}H^Ln3vJx-st|O$KQ558t7pqC>ne1aT%>
zAqa!u4I>m@>^VV%`S!?7SYfiFB;y3IV{r<x{9qmF;1tolo_sD|0L!M&5h^Wc%g8?}
zF!r!`E(Y-j2G1K7&!Z!(jWG!r=X)lzcIr8duVhdUtg;OK7L#dhA~7zwbq`;2N@$#u
z71ag6U{8q?nHjRL`Kq6Z68Q4@j%ZS<eMkfk(M%7t2^D_?Tq`-4lY~Jm1bn^u<m>GZ
zU+cEMHmHAVvj5h6P$X{twgG}4<--gfTkkG8pxh%H_*?pEoor{`H-(poQL4$e5Q(Qp
z5DKp69zT)wc)NQr1bGb@eZQV3FQ01H$bNYR)3CNkXD=umn-mX4{&Ix%;39gLW*tE^
zzKWFOIg{YGix>KO@t&C)%jfLce|)-PTpWUA(x4G^@xT4&nM9kA8_2Ila_6w(H3GA&
z^k<1?>GP22lt1$A3PkMC@-f9F@(gEExp9nO(mOo6te)@=4}BN%F3*N_TzKJ>_wJad
zNeh~2bMaO?E+5GRL{fmIsVlO{v*;3%|5iu?W=gy<1iqh#Xs|@)&gJP`51f%wPKrvi
zDh_{%NLAkPJusgwWxZ<iLz71|nxgL59flGveUC_!9Z5zv$w|;m+Rzm#jYR$u@qwdt
z=EDmdThEmLAWN$!ZqqOR@MC9YUe!6AW=tDKz5<K`5e~P+R<|aXj;P8x@6&y?<ZHc-
zVc1?Aqu&G(_6r`cAO3eds$#jfFz$FyxIg-D;>R_UQN@BL6zq@9<*O@q56O%`ntg}A
zi%eUXMhm2jYyegHASD!U_|xX_TF=)X*iV}Q>|__;h30zWLx4o1kbvy0x@u%%K^j{0
znd0<^pd!88E`G--uAtFdURyjy?k4W>N78|pY+rQB?2o)+xl{mz6A&3tl)6(1b;^;A
zQnP1aJ*S<r<c$t?m3Yqdqyt$%%l>a4?T>)$-Ik*lKQ^8hv)R62L7RP=I#Oq6*kKGb
zGj54(GGzf^fU)h6y7SGE8R|t>`N}wdNW}=tQ_?io_SF}ky5Ps>pejBK?!e(p05`p;
z(RMfL*+EG@GX70{JFM>OE5sfrU`b4{9eZBg?Sb!5p0meT+=0f!pN%c8t){|y@{JVt
zUh@AL`Qq}fV?l1_f~Hhq6;aJCUgvAQ$xqh`J?GB`3_#cc9af+pcd5O4)&MzZokY6<
zJ)_aAygrloY4EZG=Zf4>y20Gm<((;mSA(X47B{|q#|T=1M%!5BTKC#Fc?q2^ukF+t
zX@3g7yzR{q?n>SI_fI%vSmG;Ko6ip4-SkY`qL0cfPrKrI4QV0B`f}xV$PvBkz&UYp
zZoqeO;Ies&)?Nc(hHT{A&@gIb&TP7A<gA#nzu=~9VwZ`FnueQbw%*p>QxEjL3Bw)O
zT!*`+MXY@0JrV<k9(StB6!OzPwKI+N)yj{$G~6$$Hz4Sk<+w9?77E=h9!K2WWA*n)
z4?i^rPvd(;ZeP4UDz<*J7?>_-Y+;YDNAX7+lp=&T(v4T=2kYGIUKmhX&o^4`hE^9?
zyI9RNALttAI>}OyN+TmDH%FXvEeUpd4*L$FLfo%+u<rQ;CU*aacMR;m=X)p(YUvkx
zh|#MdU^`p-AHI0F_+@Z;hGjs^^=eBKn+@PvK>UNb`+<p1p&~I+ug-&@V?)kX!N*@8
zeh_@}V}{kiQ=h9J96a+Q_aegbD~0LJtm87JjN%T1Wwt&3@8Y2}D+XA`<;ifzlr<2y
zHpNvd#U9E{3+yU8fpCnvupJR5N}NSk#;DpAe=90Zz4_|?%n7R0sfaw5h;+3Z)4#3=
zB#o7RPD}mJGXFxxd>(s|M$)@#%Uv=rPP6}HDa7iW_gE>pc+j;FV^?VY!=diqvU1$D
zp)rrba9~6;XV0`!t=ECRFAynUKDve)`1@yJ@!82wKJoY8=S5ZRw`i(rwtl6TD+9<1
zqn3L{YA%_D!j!cuEQ^EKKh#3kId(}IB-5X{5Z6MH;Wb8v`0AhM<zGyL>t_vXz#&={
zcHcJ!F`>8HYZRRhLIl!5Mfx?0ewz4st^cQVJ*cjzSavij<!UM{VA~2a$K~LuPw)=y
zVj`DPrI>J~KZCy_(n$ULEh*-(J_nA5C|pG<vx+@n4Ce2a&yU~AFB#;Hy8u1X>PAH~
z+ephfatzN}1_T@n9${D^SI`OO^+IiEX;}+qK0m3=N#X^zhsYSo(UjI^`jYp<;ih>N
z7BjJ42SQMZ^NxuE9utJ!T^MOaPK%~m>3QKLQ7ukYU7<>^tz9a{M&K-fzD-CSin8_8
zJJF!2FfI=0+aB#cDgs1*8RtlYcpYiCXRwd4y&v1=ob*OTE$8&zF#~Io=E^3(XT3cy
zibGL0QV^b*QUv~FrAzpdNv_EJxoZog$iQeuT?h%&eS8#g8wF80PNbN?rjg~xKS|Jz
zz?EQ*u*-t*kY=Sp0e!8L5k$U_CVu&W^{IRN*mLrf0Jb4huM@BHMSbtv%K5A>`Qb2J
zDR_O(fnmc7mC{zK7HV-#x1`bjv7_Y_aq_lke9rM%L-nHsF5!MuZo-LA=y!q8Sl}nx
z4g#ovLV6XI59es0oR0jACSMDJnZ;)uyEHeUYx|Uun>KqMx49Z_b94-`G8e7}DX4w1
z{j}#9%T-DAViYh<C_DqhA<ao|t-J@MA5cJwlxcBNbffl(tw@;+3CKkNq~lJRQr{9l
zFJ_V4lh?GAf(n(Tp3dzrIoExiXw*l|bR|d0RY@p55A_y5>ivFm^#r(JJE^!p+rC@O
z6%!N_U{YC0(=(O*7I!^rcY(mR8G^R?=A?eqGP783rXZqE$uOW&(wTkh4*gr!L7_<|
zW9`3udXB5m5tohWHnl9zSEZ=CY2|KrGEt6&-f^yq7}WO112K9N)~o%hdto8cP*<ly
zOryI`mjrMUMTEP2&3|^e8bv!0*;45Fc8~6j`{0KLM%ks#EFL%;QDH<Xbbk&|z^-FI
zdykM?gP%~HCFc8F^2LU;3s&2YWu|xjzSO=wrihJ7)*CeQ$;@*s&;kzW4aSS{p>Qaj
z|6wB`<*C?5_~1p|-)dZ^Og09p#S*Nb0HyhIGz2}17A0w29=1-2W=Qf8df5s^=~aD4
z!$tctkStH6+mKzjYa`E5I&vfbW-MM~tB<24mDH3zOy0ggEc_qdOk(@J0QD!;Tvy?y
zyvmGU?>2H_e$?6oYnb;C8gn%7WR8Wt?5wiij6A3NHfCX1OZ7DnWNohusKaql=}v}G
zlLWLuJX&3;{A#(dK<dsvEhK0OLVE6BXzgo|6}kJ^xz`I9f<jV;di&m76_(`pX+|_5
zVv=zhYF`+tno&Pn=1QD{c_lJk8r{G$(IZIjHeOuqNhs5@c($J&MlGjyh&tH?RpQ=L
zigL3s9A!D*_n4$I!R~nNW6f#pb*<N}zk69?{Ne^Y>#caG<+m$?-xzUt*GSdlE#lKK
zmlVg|!+p{s!2tX}H78UGj+ZIn2-{iJzWcrAgNNw!gs!%ofqR$#I3{~43$3{CCgD5E
zbdJ_oh#JsSKVo}KTRh8>_5MyN_O7+KF{_R)7|&?HA3pF2&Gs|Yti!vU8t{H{wD`fq
z+z!sE=ZEc&mA#($WYv4>#d{*$vhBLgea$~hy8HEWf)KV2S0xVU%5ZiQ!z2S~PTG?V
z1Q)E9G$QoT%L?OPSc~nS!xLEMH=CsnB%4XU7VTUNU-^9mvSAQG{fpb(DnFblwdXzP
ze7rtcmmTz}jhmE>f0ZE7e93jsLV6$MA4uFu&JAlEBU$mmL`~C!0Oaf&or7uKs!wbg
zg_`V6VxQ&Nq(h~&mYrxVro(wb1GsdVzAC~mxjiOuAObiE<Rz)TAq%w?Y$UtBZ!Kp{
z8+NCE3n`#>D5ORQNEoF3*px8{%^?M)Ba8XRSU;MoLJ-&fzJI#mJ5AT#LuDJdE^<Hq
zxO>Vh*!kaZ{ouw~EpDlP=1$``XU?k2WNLSVP_9j^H7$lI4PrX%08BchEj@K?g!D|d
z&CfJIOdwk8=cik(>aaIb=UHP+hpeS?N3!i4??GMp<IEP~5CK}ohbf0;O1EXndLbOg
z)s0#hqa{Qc(NJO&t~{Ym_A8mC3sBEAV*;URC7h0H7w+)D+Ur+;32xrCW*ri+k097&
z>zs#r4CnET2m(8Z52awZg3gR^0z0{{+EhGW`_<F_rB-3zyv(0g<UgWaE)jCLPj!)(
zZI$e>D~M}}pr5kNKCuMPkN{k`&;V<v3Nx-{OJVvN)<)3!Te4%A0XZFFHew*>#048s
z?CY%`pQY`r{)XU>G#|n$6^)B2DQBiHvB&Q+qWL&7zV<!s32{o0p`Z0RyC{9U`_qVX
z5AE?aYVP}=w$op_Gg=stda(5QjHvk<bY-Ts4L3rrS~I%me4w1?C8rAva8v_3*{?8p
z{Kn!nzIiO<_Da_BU-;_qP6m*1mBR6j&N%K@Nc_pQUWO-QVWBA&33O#(xa|ai9nyl*
zI^VUbBFnO~1KHV4(Q=r5Pk&`o*54uQswlz?)>Ca&?j8&~lwN+ACjaXI*J5J#9!C~Y
z84-``qVmNtVb;snGEs68#cvq-{+!1I{S_|UKu_#yA1AU!tcbuimqEBt`r|-Az?y7$
zGG)Azcc?1s^Rpg}<aQ5zl1!uErs1Q)XwocifHU9KN6ajw!JP4kaj+EDuwQILY#%)%
zlt517b8;HREcjsZ5(MQaa{$QJ+2rUtwb|(v5oXlV#=*ci8%Tj0(XvBj5Qh=;GuEnt
z5<BzTnorEyxDgJSugK3QJceGiT53zS@UpjS_Oq=ApR>AOOtrFS$r(Y<62r21)b_wt
z?##-yy0tE<TyB>*-9e8ld@iafTNtO-H~~ZyR|Ww;-49URQbLdcZCT+Wd5pRHw@Z)1
z&BcRLNwwON`q-ZBg?pE&?u-WZRiyi&S9@>e?Ag<lqe+!a;Ykd<<fpb|CTl+(R7Ftr
zicV`Hs4E=L+HGk9h_RA!nw|b<LqtssJlU@A`GQogT_1-<ei_&IE5#wX4beX?#q}6u
z5BD*6u$T@i>Ys-!YVdbNWqlC)Qt1$-AC=ZJpqtgN5UO-V9B_sJSsNTO_DUKd<9sc%
zAlli6!iOFJyF*Cv3wwh+hHk`VDS7V8AUyJTBXOIW`Kft8N}I&SRo#>z)!eRJ@$$Sj
z;$T3l3wxF?)JD;dOpazPJrl+_Sn3s(Y|p;A!m%W7OB3Oo5MbIS2Rh1d91&I4m6I|O
zzM*|S6;!LXd<*^aJ|p=<$r67AWab)`)91zT8^rwb8a6!8yq@6$fQu#>;C>FIF(X98
zC<W-dxRookoBPb!|AUo?kR^gE)^9ig0AOHUJoHv<riw$sv8*dIQ!!liHyqD-Z~_JQ
zwbb>;!hY#4XO-%)yIzk2C-#20oAv7wLX*pbt;3`JFfreDT?*O%dFRj(9?zi9P4Dpl
z0rlTNs1HuMFo{=P*wp2Jjr}*ZDD#W9-a6b<M!&?hFa;q2j6-#joWk|wl2xG05{^*1
zx-2tUusitGGbdT==jfa}xvW<R6G!eC$iKm3&t0r1L(e^@8Ocq}Ic<cyBlegez;NGR
zNiX4ucDSna7@a0^5GAXYl)Ld%@VFks0Ea3YW?R!(5M^o2;kKA>Oz%Fz?b#OrtiE3?
zH{A^B+iLqLZxAQ!M2N5(b&GHMtw}Y!o>96-!{fcb40o4SU$&&PJP2668h3{^#Dm6i
zXkb`%BPbaZV*%LCubC0ev~95dO$OW6-kZ{E%NlQGjeE`42IW8Q%V52ER{d@W>R!C8
z8|al)4}Jf#nrpLK^L!97=KTJ32KRVyu<4v6E#v(=XM}V2`}cG2Km2+x{0RLpDgR+g
z=fkwchZ*M&v%AX8F<49e68!!T^QdAEI_J_uc!HjF!#Il}fK4{CPu}LDi#{wvi+#A=
ztPAG#gmIKxMON+3m5f6{crkZX4w1*48i2b3+16Z$3zj{KV7t;FwxXF!_DAr!3pwH$
zO*pW2V}?8_JJ^;5|MeK-I4Sv|$UxBeqJTlfikBA26=9Se*B<V!%^>l_$a=7N3~cB8
zBXTWtHk8vbDkl8J7UAm{T&7=b#*zxcjSKbbn8g1^M)fJ%0KF-cpgNkQc;1`%CAg^}
z_Y_r66BzP8FMe1PO!StCDPmrI%Sm#AXpgX)b*9a>vV?Yemlpe#7B{l0t^3oKNY48D
zWi9NI!XAt1D^}a__#0x0eWhW;P{)3FmISc%j&l+Lwk#<<Ay7AGM|4F)wbwImoSi`^
zRC1i2UtQt=hKw^Su-bIUz6~=?LOu*d*Ai(+5zJ9OjDgTh8;8M{;m$d;f%g24%&|0t
zKwf(45<c|KT7*VuT?qxAPGLKwMpWm()3LWw*TCX<ru8UctK)pIU@q>rgcV`0=z~8*
zma$Se-(+1P{)E40uScl_FuU^_K#64VJ<|1xeLBlhF-4Yqj<!Br?!Qmx#<){&MMy-%
zw|@B7X$kB5q?wlMzfgcf4CmduE3uM*@E84s0k7&Tjzhz8XnoO%7&!|;W4xn5nr=)k
zrt9Pyw<4rAb&}z(D<=LVtLynL|6sT#58SK8{U`z4G-;f$L+JZiXfMO)MqeuHxT(hC
zH9%R<g}g&sa7VqY3}ZxfYP2y0r!`%l4qOUegP&g7$3n12hoNzLxxX#G-Yw>;uW<H+
zJSXd28VI^?P64|EL~{!BZ_$@t0y=LrGYw;^`B!{Insq4@E<)mH3Yg*is@=Gm?IAka
zjfTy|3v8O|ojRHHbA?u&=YJor4I}0T^ucc??PPE{KW`U4tjs(^*qhC$I*CwoKmzC&
zoHMwt{`>J<78HZ$o>}r1p0k&@TJc#&5;(HN37IVPMtB_zA|xPKau6-83cSu6Sg$l&
zTRQ6JFL+Gb;-V#jK!kYkAp4V~POC|n)-taJb47r!os>i0Py7fRdH<(4F(UKb`u)UE
z&-Z`F5)T!;|M&Zc5Vj=R^aX8O60=$YyDUL=C>rsYUdM`d(OGZr2gke-v#JHZw3XN`
z8VmU@t@D_fDu|<glMQ`SmXFzy1h(gzRW5zHbZk5}2^^q@FGaxf-ysS%(W*aaAh|ZL
znh?L18Kpf4k|^R$fSR4l?CUt6hJeRB<Gy&|tQ}Phw@1`}LNsrp4L>gD33f4}Nh3JK
z8%q?I$2hvg5uW9-jEE5Yjrbo}u85u(%<oNGiph>%rpzh$AmG$!rs!$k**~B%<NzcM
z8g1i}Xz`p}f5qvr%1G{Rz1&4L#I*^G#IiK9fDx~Us=0#Dd+mdNtq}9_d(I?HsQ1fA
z!?G}h^u-Rg2Yj3fTs|B9CB1<GF>SiDmRCc!%=*gm>jN8`Kmz!y>CuqxPwdEAC_$C0
zkoF~X5*FH5m{d_o5X;r~^eWi%N-`cD@8G%T!$iN%`L(@Ewr!n@!{biG!rV?82g^Py
zn8uzLk8{eBkS?MEPs}zre$kl~+BFR|e#kEiC&#|Vz%TC5t2o<-&0QLsmkV5Y9uVg(
zE#%Zo*UNWjSgkVq_N$09zbnBH=%MttiQGKO@4{|t#~i!f_siKc_Y}eCGC!jiQ$2wI
ztj4b#AI_i(a(#k+`~QU>X{ZCR$K#W7WEq9fpINQh4kL!16z2`+k0;s}Y1vM_jc++b
z{*g4=YDNQdv;lV3mQ|{cB1PxAUzfUcVTb;_H1-?f&J--25D`qvoT&}}hoW~S^Al_`
ze_w#r?hCHUE=n}oEf{he@k{Yh8p=Mz_5HAGLrGk;7O0qk(8QXQ(aU|9vGo*QL<74+
zztRB=T+H7-K`-OC6o&YX|D`-nTigCi&oY4|+1<((%$>>P<?jwoe%FhXxbsiwg8HNA
zk~)bSWDt#HOz+$}^oOGd6ZFFm&$BKi9j&9TSl!KZc0Duv>`ryxwbB+C0g`eiOrEo)
zaN`Z<NUhl0_guogg5V;nUoHVzR;kVfqaP1(HTy<ID9=k@pd3&3XbFn~Ac!ECjA1l}
zc)^Z!8^ZlHq(NrNY}<buiyIesUskTrN6>?T0BA0B7zO|ZnnfMEQd1V)McOMdo;KD%
zV4H1wa%JJm&uvsjanL~<*V%|+zFvV$(A%OfUFU&H^~-Np=U-OuK7Vxa>o0@xhOpj3
zqa(k+^&i<Pl3yJg{rHYEby`eMjF|P`@%7Qmm&Xl=_WH8bmn5m#{7b?!pqBS{c3KRZ
zc7r^iJcbdmv4->R*W!ZzHl@>lU&JeMUw{8RkXL?1H`<rb{hH~EjtlCV`O<Ua<j?Pm
zf321#O{%GXPu}Jej*J%thKu%2E#jWe+oAyR@7q6M|M~BtNc|M-nBTl$7kiPiXuT>H
zlx=fYcc9!R<K<^%r16z>@76QLS@xgK`7WQt_{gmL2GSvmzTRh1wre<+bk^}A(K~7`
z=j3o<1c5zaWIE*VgVz4;(4V$X*to^+m%SQOvt}48kerE!O*soBkY^#C28kEtk5y7G
zxmrh%-fo`H$1|`pl*0Au6PiUQrC%vKdnwBuPH1=-sZtPpdR?bPxbG&3tvs>$Ge`Mw
ztx19I`sOvAeRq)NQWVheOdtJn{B`f+^*k4hU1Y2oF9Xy?9wLJ#P5wI*(61QDnt?2h
z5%DYc`Dq@m-Xk@#p|NsazzGTc8`Wi}V@WleN*5hC6xNiygQpMGmj0^yUFdSeDT9g~
z#y%qZXtSaK|E_KRll?NCQD!dOEG)k?$9Mb4hwgfyn5Y+<U6!-I=hK~ZztPCIEicQ?
z7(ePbyfS1@Z#*;WkWPX0+dtXR&QRf6i;1f~kX8~YLiy&>ibrRcIjY{2u8>Eo%j+K#
zkymw+yaFv!O?s4$w3+m(aWX4=@!58!{W|5UE1jpVw3$8=8ntekJ`Y_~HXF2fmumJx
zE2_+FXxHCOvtg3tF7pv*m9yrft_F|IU+&rY&-|6A`!0+ByaUf#jQQ_G-5dY~NyF6w
z_+R^;{OxEza2#S$h}0w%pfcaMN5wX}K-If`2?D<DIi`HHYvcU=MnCeNlX2r6h2`rx
zOwQA*Q(?L0lQ2HgQu9j}tjT5XgYy@_?dSK|5kt2U?90zwD)*mud$nF{_T%41!YxCq
zoyW$_N8c$9RQ*h_EnI_q#Vx`xo<NI7(LS|S|DPEA`>CnXy@7tRYC(^v+BpuRuM}c|
znN6k?b@YHR|CgFWoX^0iynsIw4Xr;)&1n6?vC!6TlY>FRyOp_$il0^eON;wP#H|6k
z)L_U(qZ7w+PoS<PwWs7+oZFvww&Vq_d#(5IBj|OYszN$uegI-nV)Aaj#;|qThZJ%5
zQT*}6v&O3fy2S-Zr2(GG&<G^)#guN40EEn)&mhu|l3G#*x62#>2NhSerC}v3o&Dge
zsnd^xsk7LvlFZrx)9$>p5@%DG*tbvCI!sP{Vys&S#@7AJhn$8=yNFOeS(Eiib5oQz
zt|-gYdt8w|`=E3e#Atz6P8NvCz(%Hav^ZhHLojY&e~3|-r=(x=AnyOCDm`Kw@dY`G
z@SAAFG5OBAlzU}IGo3SZax%4arrm^XyvE`PldggR7oMFtSh-&-yL1wNzb>^xZA;HZ
zuY_V(7gM21Bh5q=yVR!3k<TrLavY+ku1fky5<iYO(`RwWP<n)V2e!xhPv4bw{Sn-c
zzE7qfWb&=CEY(@FK7#u6O-4?q#s{MO`=0%3nNzvjch6oil2w*77j$Y&jpHoU3){s-
zF)gf;`trF^q}4AFCowEHoIj--d@eE_+}|tTyp(s+nYW|STG}<tsSd+1lo?X$yH}EO
z2?(jgwsU*!FX5$62##pHUix6)?90O_L!|!D_mU9Hm)wA&;wShinEXxeCQQ5EI{!MU
zV_DTOD+4u@&eAVdL?5vhPH%fH4p<vW18JK^z~6ok;8I0{PEVgk0i~;;VJiPfs<yTd
zh#2V+_WFF>h<-dDYII2n-PglVU=t|jTO%(R=Bt!Ugg}9h#h%+@X2D!xK`;{L@TQh}
zr@4H0UF?H9qdtcB=<eHe8C+V*wZgFVPV%UULrY5KwphOy>t=xNH4vS5LVV2OcEv=`
zDc$@AZm+|oM&vbhtw;N5F{Hdste+TAa5KqR%dF4#$m}&G^5KhHr>AQ6Np-csGQq8;
zShiO1s@LrW)VElJ$tuM34aY^4rm3Q&t*YY=A-~>PDthGXaVwyh#)^eIO14l=p1tg^
zu19?*<E|IpAk4U@YVmAF<4i#Pfo+Xp_v|Ka56aA5me%I#t7~!?4Jn$-tDLs5<>xWb
z)td-4Lg6V*XmQsJ^YJP5pafHli(MCQr}PoeDT^CvFq~{cVI3^cx)@p}c5$c_uK4Ik
zt|t8=Zu&ok1BZW>Nk&pLAdS1J9}TuK?1m45LvK2*OzOsXwWo~`UK^x^f7UiTz0K<b
zT<;u{eIz#;7lhT{$4JjTLQ__uu5v8v(hJN(PO1{5FO+mQwNWYQwOh2rO!0DAOBh|M
z!YtFL2C?1KKgqb&m=YPYV3Q{3ut+GKzvSjF9V37$qCL0W40~7JZ1L!=+%nr?veEbB
zEI1EZAY?dflD=Jyn6^2pO4%{~ALlJ(&G3{q6kwR-pIz`AbeEzNU^1{X#%vaMb~J{u
zoPTQa@Z-g^KMYt$tDeerJ&^$!H+>>U$ZgfUAG?2Fj%bd&JQ<3PbY(vhFPuzkw#X4G
z4J_U6$bBUfhB4aKwd2}4ni{fw4Ak=6ZUuvQfQ+CTY;jCRc`yQULHpbW++ZP$yGypp
ze+;v6<fA^4&`j#v@`EdV6;G~Uk~CjOi@)?PebRO~`-q~$8K7?oqkkYm5si=WLxL0&
zBi^GH*Wh+dPaJwDF?4Y0vnrM%Jwl(RQ8Qj#25ykhm0_uU80UDXXc?XS61)9mOy_AK
ztnd_bQt9A#HH4?x#r)K9lBO)ncOH3^YxeE2m*0QIiIuG1*)QAolr&ImuV~$9;>!Kt
zguT{FZNhCI3V&y+Lva^eRF2y0lu5bu$!t6GZF*d%)KhNVxxHb!>+N8D??xs~qbc7J
zHQS4R6BjjiJr}1O@fV%Wak{_6D-)bZ2q;)gk31Bwy>V?;PD%4%fwO$qKKJL~W9zJi
zU~%!|{fd(yC8{bVN#bBFNDbL>V;SN(<)~6i3WjDFw`8i!UqwXbDyTYYMqKbq#%N<4
zu`R<p8`XUMI*u*8LX7cIk1(DYmv<Y1ty)}dn?Imn6_|s2$nt^vTf~Ek$m&QTUe>bW
zRTl{tgrnYO7<F}MwiU}pRwyLk6;D(sp2K6=71%tyQgMaS6})myg>oHU*|?0<0#a)r
z-7LsbQ4ooB8HxH{s^((aaqS8sP!5Yv5>anbi=7riHMT-=O?V|^gkeypS+uJbg-k|u
z*_MbYoP#Mj4dX)Ge5vIm0izn1i}%Ri%E=I{gSA@<9A*Pa7?9`VPN%Br?e;7K(=co$
zw+-nuQ&sMS1s^{JQ$E#kKRKg2!^vK7b%Y1fdMJ*{b2hYd!OgZG)4oJ1BHL4fNKWBx
z)ENgqEn`N7XB=s*dV=W1FhO?6^U`&mcM^e$s4h@Yv?D1=n8AskaX^TVAUfXnqt`Q?
zwe6f#`R(Ms3#6iSEx`;CQssb*AhETSlsoUOy{9b=I0qO1Q+3^@t?c^>PZ}1RlHZdz
z2ewEVGRuPETQU`b(#u04_EpU~+>UT}titMw1+}<JAO7f5gl3&$s|uWTyT&|KJ9fkc
z5LCsm{e7AXj;0Wz@i61Ue{B3@hY7axd*Adw@jlfuq^2G-)|>0!+%7<|OcuwBynPPO
z;Yr-;oiL*Rs5X`jlFMc4cX>)!z_f3R(7fSM0#GYP3nE4*OvsToJMPD~FH1u%qJ}Eu
zolLJ>e4r;YB-iW8?v^(PAN<u});6{h^z5^eu<LN-r^t>u#VstZ&zp^bs9G~EmYjiC
zZi#&}4#Qe+P)=2kKN&Q4q{>~)NmaMy%dR<HF}Tk(fpi8T`W4?_8>Ck!#&y_)UTi4%
zq_p23&@OaocV)<D`bS3C$5nZwx)f+Vwg?Y^m2TJrCQo>pZK7Oh{{1oJ*C0BjN<E@7
zZ%7n(Ux8gwD@m@zD|ay+a>(+Sbdmy;l$yRx&_P(ra2N*rRrl=MB2(FJYEYs<vdf7z
zX76Cv&bG0he!0L2va*+RWB>H;CGlaxHX0-_t!B!s#dQb8QA>~9N)gjWu<i$u{w?(-
ztj*a2x@mqL*_-LbwPOyH4*3>g_&=o6nJs@nm7Kt3nKr5PZ6Xg#z|WkG%r3^eBYi8a
zy*#{JMEDcCr8)mT-FSwy9--ho(rIO_Q_s48QQGN1Pv1GEVo&S9oy44NTRB-<Jvs4T
zlyu>X&CK!;X0lhrO!N8DGU&PEQI&Yd*4e4W%}%^m;npjV?7#D>&DmdS)1!w!i^o?#
zo7`6Xsgz%bzpd(Z(y#p_AAIASGi$G2S_4RyL?$6FI5emGTSj7AYO10^vKgITL7@A&
zVI^1chc<5{Hbmbn#>W>09z%8QXcogR?aTP}I%=)fgpgSX5mQ03&MbC@`lXA`brtdH
zJ4eadn2ztD9%9QUy;Wg4N-fir;bHg&DP84Sx(PPVaotw~I}^+-OP;)Y8vhzwCGQ74
zw7|3qVVdTVbx-s#1BQuRAiD-PJAOfoG$iSTw-Q94x7i;w$ox&~d12^N(2mqkxv{w*
zn`oZBx%9bRGcEx;x{HYXxn63*0!duSIPc0b5TmQ4zP}g8R2KBeHy^N%CaX68=a7n#
zCi(&?WR2S$_Oo4?6LTj=b95v8KQ(+zFemT*7d{v{6`Jn0A4U|>f^?la@KvPS8!*ui
zQk^mtFqZBp15q9(spx%v1FM^qGM-YXn^HHP)~%a1HlDGp6M@!ech}ACHJ<aSn>%Ry
zDY9;`1Qc^rSoaB5hh-%=v%afLq<@a|n9l;es;c{Xt}eMO9V;+i_|ReQ!6cQWD-oEs
zE!nm~Vu`7aq=-&)M4~>|dEx%|QPuhd_4;pxy5AHW9grWsWVNf7FiD%t?MpBdk1mI}
zM8B$pmko7mnu$NBr<d!}Z5rGG?)Qzd&SMiDs<+#<05X25M>VKJ3&Si2z*`^Empi_1
z=+-a51S?k()*ZD?n!7e`)?w{BswO&!4aSL8b((f8O$xz}UjHg&3B(D9?u%HEp;<xb
zJLS57lRYY!uI23=$K*OzV07^7L_CgciD7<GU}5FNc0`aZab*2hKQ_b~RtghG^%CJ6
z;f!(%)1ic{Pbm1DMRHgJ6OfS4M;oH34N&(bgcjJe&3V^aA_UBw+~c-tytLMoC>^*g
zeG6}9$I$?OI5dA(MRw^_b(ot+TiS^M*Lx&dGbK4RAfj_pEpy3K+RTXn5i)HtoucNK
zb<r|LacQ(|N%`)S4iCPAoBm^i{7tOU_W2O8NKE<<RN-$Y^zILY1M3IuC_wKdK5x%%
z=~R{Nk_~TwY2_;Wt|&c8-?<6478ozVl7I$U_45ujy^ilNqQotNey6dduv6nq9qu!D
z2c}DI+p%SsKnE~2QZbP~c6Wr@WPEp-40LJ*IVv9csU_E;*4$-SRR=yI{Fy*qB3?2j
z<t!m&y9^;jQ(5q-+v)Njo0Mjb8s{HV%3{txepW^ARKZCS(Ot?&CySqrW`9L0Wftzt
z4<eB!4ks#pCWFAHKTq5Rp>wTOl9k24==x?`I|w?l-hPd&<U;cx6Ervp(DEiyT%*K~
zW2U#ng4WvCb`zA*$s=4*sAqOti#RT=S;MJ8)5Fa!tw-WP0|{}|>ewoAt-WA80h7I|
zo_5R?o@=%3o^tGxj$N0!fml#-rwTQ3M=ROsYB#pLU8Ri_@V8TE;@;;3lW!a5^4EXZ
zdoaID-`gYEOq3i{+IHWcIfa3ntz@MyZZUVZkf$S#Me!2%1`D(QM6RyH{@U=VZ^a#g
za4bN~yJ4JFajW~-ta|Wkazu7J-q&px<Y$71$*s*!r;jEk4GF&keuxc$%#zL3Wi8fC
zEr$(Hc;2<dvYVX*2@;1K@z3wEa?G6t-_<7C4b7}ho_uf;UZ;5JncwTtl(Yw@u3DYG
z{@`@I)tLtm&OEhB?R}6sWOerSgR>v4{KlhbtaLTj!ecotU)AsnK+33H{QpDeX(Pf&
zn96{Ix3yGL7(1-bX$=~9ps$CnSu}XZUg}cl3k01e$M0wTOLAsx?%j3TLqDKXKg)T$
zZ3ljQ`ohFzdxfs--V_6$wUKCjk{ulRJ0ln?`9<%*$snOd-S&`To;5_%h8mLDOPFb$
z{p{PtC`WXtw`58idynmfTo5uZgg?wv$=#+0F5LkxMQ1rIMWzw&SOrz6^5wn!r2UoT
zGV`s|pD$iM`5bq<$e}Dld)`mkuIrKlL<HIUu=UWPkHr7m$>-RN0)nJ9F!Ll^PJ7sX
zt@zyai_U(kE@hbdIHZ0<wna&mKgHW4pxtAGb>j%=rjY4wyD_qGemQyVlh-JNrJr*-
znuMwL>{zfF?a=T7X+k<JDPWb$5JhuG6B^UhPpnJ(`UY)iS6$r2<T>9uXTQAaK;1`g
z`8q~x8v(I@13NZGYC)8g&aNxY(pXK~VbG~5Ayf_0N#K)@pqOoNrqI)<ZBvXqo*@M#
z+u_~6f{02U>TPjj-yT+UY<oL)CF@3UhJqn8`e>x*h#|>ov+I28h!^NZ{O2fuu0Y9h
zm<1ae#(7h>-5Ty9vc!U_z=my(YtG7Usc@1x^LI(DLflo8NruTkrtMh?J=m`9i0T`J
zBeBUHHizSqW7}R*{Ph4VP@CS|(r=ApgbUKO-yGQailN=jxW)SHaGN=y08&cbYZnAM
z=)tQ{6$4lu;aP^Q2y$?0djV2%!BzL+(%}n^x;KMjXc77^-BCE6i}~b3UkVf(f<7gP
z86nx$emSkS-f0jgVPMzw=r~&Tf>2c_HNT~!TfGXTTm^F1`&h4IfZg+#2r@3go_!wc
zGf74P&%5mw;-iR}s$GayFUFiJ=<;%9QQxG)YI+=^<Cv4<*||=$WEW{Cr+E|4Vo&|o
zD;$@~7az(8I>Ei?o@|X_M;&Grwv?dKvtmIZonETWbx{S|?7AvLGHNzDU&4XxJMq%2
zcMhyh>+z@mjxj@!yM(upL;yo^!U38fjILJ;FO<wd<98!zgI7&66-|tDekc0x&etHZ
z<!lNgT+eUwtnqqSc-TD?$fEu2{hsxVvp)nT63hY*Q@3tH=rIc#RuwzJ+5>-fNRRGz
zN8=42{7|H`-(_hABVGz)9q$}GW(jFH7Ux@TeB<BF6AG30QU}L-F6_LR5Zrol`O|T|
zrKrYMXoghk?;VHsq<3t-H$$`xI;4#N=-;1VQ!Qzao^Rir8#<(xj)d!KuleIA+1C`K
z#v}_Xo!dsO>xy@kpAfl*ld|{xACm4poXP+H1Ngm}Z4R@0j&t0>`Pc|KRdXh136X40
z$ti>!a~kG+Op=^Jk{k-@JaY)0M$So2i4Hyvm6Yt~d;R{|zx(5T-PiVh-OtzKDKL*y
zx#zenoSc@e!MyeN$!W>QUp^jl_2%j~n#v)m5?v@-S4%g}JUi>nu>q3;z=cZ*O~915
zwK((M;=?>UWR<+}pN9lt2V=9`SLXtT?R(V%fAyq4FW<1T@8J{;A{`+vll_ZRkVQN|
z&_PmEGI%)b8_u|yh|G%y%QH-(!7OR17lK)cJlfzx-cD}J7Og*KoxOmPr1{l>9ioYv
zuX_ONA(jRDUuITIZce=4pnOe^<FMi(D3BKqbzOeeT{qZYm4FP)yJ7Z)2c2Y~2P>}3
z1H(D4C-TpjF=))`Tcy95M*bz?f=sx;&MHTK%}1wqnRgTppI5UcUFEJ*J68&Qr=_HL
zcWl&3UCWZkL?gMc@Mtr|zeDp262_bUjM1BS2!G-(K?@vO8l%Da`DJj2U!R)vi1|J~
z>4{UiQ};Vbbz;i9(8hVX+e|>Qv%fUgdFK4>yTVh(#>BCi;D_HQ-e2(LQI+B5;hdbk
zIAY`SA#yr+^24QtT$j0+wY!sZahtDQJ|^sbpZu5z;d7l&=3=iqS8EO{TypXMw8+Gm
zhj?@F%c>Joa`i?FF4QP5RvTx#2dXZDRK4l$rThm?r)B}Y_I`{8ci!}@aa((XUl6oW
zS8%5V3-1S})EkhGDEF59u3L3kD%*tQtz7d29o7m~rrL5#<1d%`V*+Qm1a6#4F`}c~
znOujf!ZtQ63`kzO2N~ZP9?G|SG5Y%7cL5z4u^_V^#hSqK?av}*zG|~Gr}BOvY7+Oj
z=d=8=MRMP|Vc{}i-fuMSmi0-x%gUN)%--#C-9L}GNzt$#Z0`h_X%`c>Zc9t2&Rdvo
z#<fh>MM`s!G=9;T7U>VNEWD@h@{VNoZhWfON+VHI*rF>UtKx=qL1s(xP1H^3#;lRz
zGkPD!vNT{;b`um!Cs`V(`&A~cPDAT&Z(l3ccKb!xBwFS{OtMMZ?X?N?H-gKnec7wz
z8wpcHX-5TPea0B?k+S+E1dI&5-b>zEMO(j6IB7Jt!ArV(GvL+Xg?8{r{y9k)VR^$`
zpP5wP=H#c=XlP-u*Q0lp6m)UhV$g4Yp|Ln=9anqPCTh+>J)E$DOAWOU*XV0d(oH=w
zHqXT)4(*?cunS`;AU4|?!9X9Rn!M&xYl{dvn6nyfwZ>^QR{cD2s>f)RhoO(X3R<(6
zd_KA`6+8woW_W?o(E}P^@SGn0H-#A^Y?$hoP)-vGWAT3bUKX_a*uMjpn|8oJOC<C7
z3f>fHqxTuXlCuLTz1Yg%K0rfPK0iDOY^&xZo`vv03VTXvacPQz{KF2VTP4UI6BVc-
z&E!Xl_}jsLBhVq+M=({=wRf<FlETA$6;6o3=j^EQYoQ7aU6W$-k8CeIHCB-Z9W7p}
z@1-|ICS`h^>p0f{?&KQ})^NY(24p0*Pn=^6sVCP-^oG)PX>Gl@j%s`L{Sm33RB3a8
zgPk;$uovkk)PYU=vp{TFflsJhI`SadtMlUMjcPv2*M>-p=~a3hD910_Bt`zWkO>4O
zAFk0me?q|Pny2QHMT4;ghCMLlcrz9T<W6NAA6NiY<2P}Kn8?U22p#x+m~``6Kzg&1
zU`j_r^oM0$q5rN;Sm~k(lo>PWN2A=ND>cY*9<m0*B<sJl`oI+{bHEFNdnH<rrF>Di
zi5w<JF%*Hn-RZv2wj0*_sU~jVfFrF2^jE2u82D|fS5OSPtN2PX8L(+VgcTDxi23pR
z#Zf%m%?&n>rPS6+?qkM*pkKHf|APE6qmrhospRVt@bmd2*<s6vq{CbXv}Q~5BY*S|
zo{XECJp=Ruzon^61k<&~_zQbjH|qklT1%3q^@TqO5uS$T2z68RLgIVWFZh(64;|D4
z+N1%#$b8QZ2pga>hD5_QKzzwU{;PczT;|l8-W<H*^}i*_oxuW4d*LJ(6O8YdrAmp?
zt-O39jpq>RgG{Lr8iAlx2O4I0uZN{s{!YyjU$Mx@hDu}2>jebOkTMz(C?-K&`lQu|
z<81`}bn7Y6;$kF0qa>3KBn{c_yPFbIGI@13pLj?W3986t82b|?ke25FwZCXUVo4r*
z(OZ%;?ZtrQLhGpIpj)@0uS!3G*GfHI@L>K(0q(Z1p%~(90{$l<3b&nvHJa<=b0+j*
zcQ?#(%f0Q>`}jqyu9=U`1fD;l5`gLWjo^?zx&}D?8Fhpdd#DpUXc9}fg8;KpOQ}{S
zn^q&x0S*`_iWAc6ro}{`A;~+0z6_sVxc;a?ed&}pIkDGfc!*cYlpgUAkf6WcHhVnE
z5N7;C?LDI2!RSNp$7wkj!^Gb6FujfQ1z^P3#|}txw0)of?{JuMk`&l3`iAAeEj*BB
zgdcv&bycK1b4kNU!SJ-*Z)35w-!DjXx6G8kOY`5}g!%3#JJWs$5LP!bHu#Mm)xWXj
zZuyJQ6g0}_)qO8*`X{4JlDHi&9!I#FNte*@Sq(t{(@thuUh7Te>Z>%q%-AzmpWdnz
zUr{%RbVgR*&hZ06A=WMmM%Aefu>CG0Lh8V%&yh^}$`f@orJQC|0y*RR#F_2QT~k$C
zlwNQw$x@t6GF9K|$-6gQ^PL?XXS6u?1&Da@jEBHcHk=E3kanbfZ@-f}+%8xiC&N#3
z&^Ffi7*u%(_CzlNDOG+rxVE)YTUih}zeVLV#&eDBG}NC7vVgtuaaI5)D8MSY7C5Jk
z1z0KG9rhQf0AN~ph*=*7cTD_EA}DKQ6`n2x4U#hBng>BiaihKy2IKF!be|P|tB#Tm
zhWwrR{4B5aCCH(yLkM<t;6JWW?(^gbaNc!9$LX~+oM5ckL)bg?;2D_;GC$*u1iEs5
z;=v<XcoYS3u7lG4t0t#uzIDE4Jqnqy3|N1&<{r-3VdBl8__ypmuia-9#TGL6WkXh7
z((|(mjSa7#X(|#{lSp0Je5FiFXcF&P72F_%V1EJE*hBEjMCq;FKC1|v&3V`{p8!Sw
zz6=s*1*9z2_~jac+Xk+{mdA%#uGEUG10=T=TKVqkHY&?>QE(D33A2H?KX^Ma=nURV
zdX)f3x1qlhMPifr=+(%L`PTg!I9k<sA_W<JXn)EGRk8qvGPz|qFpr?;RtRWlk2uz<
zc7H)+@wIwa_1wB@ChfrJzzYkWlSH1oxJN+E<1qsS;~yt@E)#JQ3*fMv@ha874sYhK
zQZ!8A*F-iz@q!ZGQtNWJr(j}gDnJk>>R=n3y?`iI>BWeo)a>^NKx_Wf@cD!{!a65c
z<Q(eRuMy!(5%0<Y;mML*hC^yzqUB55{6>=32PNM-3^f6$Q9Q~%OY9E@MY1IPNjf|{
zh{hDDQ4ZmpVT4-4%g}1x394e0O!v3XD!=&ryOW<g+H()2>I$YvKB3}}fw<DvK8ep?
zp%j*m24RbU`=gK`ENk5Yk-bQjdsox7UsE@OxAEgAte&$CsL?&+gW9H^g8~BO-Yn?6
zob)GLIKTCYtW61~S*3<l7LW97x)gIk?1#JrKM5FKQIz&AmVshQiIPZj!az~`%!$N;
zLKPw3SwSN23{`PegYdIRHIER+UZ-M>(#)qQJTcx9-D@f=VC~B$kG~1G88@M;htDhY
zal`^H6auv1ajOg5!2F{Y9x2B=mpUMzKdoLvMrwd6qG8Rml6SbxkWX(2_w5C$1fp52
z{s*>Tbs`IiAI7y10BwTtu`DRN2B>M*`nRCvebH8D<PEl#+lyq}4FOwj5oMt(f=pai
zvc$=aNX<TJdebzVpYTmxGqTR?$vd1>2;`>!p%2BX%z03+1~W5sOsx@vr}nLS@jxN`
zVhcne;;F&;)DzN`_eM0{lTjc{W(+|4aT32I@nspyiv2J&OyT{;pdVwRBzgqG+j-qm
zc-OZ+{Sc6yXQ;BP9gRO;H2wKWa<51C&Rvvs9;pK&XzwLRk}-ZmH9Fm4zUkXO81j>W
z$HEjstf9Y#djzp>%&(Q4B_G~$KE%tPEbP=OLoyVZxNq4Radr_8{tmV3(X{T5upa8L
ze*MFGMAK$G!e+X|=ED!01x?#e5jG!^_-I}RpEd1%mT2=Yh_&>H?P-2&F}$T?DHe1X
znCKBKx}df%LnyDo8bNpkL+uo`Y+5rM&N$Yrgc4|eYGV1SkPb&vEt_pcZ1ra+muCJP
zD%g_5t3s7J@YSbN>ScNaBMilbE;vR0w7wxP1x<7AAhLcD4ox$kt{WO;QN$T0&X+n*
z_iCm&TWGSajYTwMoIIeBdju`7`?1JH@G?Zag@EOQWE&8Kzf~jod$2iPDHWX_8S9Q1
z0$<Ug%E84KXROqhm`}HoRm`Z0Fhd1ePupdMAYo-;6E$ES@_9CrI?f#?jL;QJPJ==D
zDtg3%5K5f^YHgkPI^fAlja-l>FuEY*24O;z>^&mF8k3v&N~s<bIR%ame%~7bKvl>{
ze3`-F!E}vT<feP!C?P!7=OkGSB_=*|k>I2=imNr_!4Il>Y6o0J0L^67Dg!jA8Q-&Q
ze#Q`>P_Zg+aH|A9IW1XNCDCT8>0Xbx*Wh(%wa_c(#XTw-bhhI+y1utSs*k$BMx@(k
z;s2_9Kgw9*PS*e$Yl0lS_(YX)br3@ph}Ay%Sj8$%CYe=hc+8cmc%tNj?v7{6YrNWB
z(%`2?9gGxnP|h_#NRNuq6cn6a4grm#_Namzs=}|BPgi<|^)6l7>0brN;+0LvE*YSd
zienn9MR!%49ga49trIP+G!TOS>LVWgAQk}!#u%NKFW#~4<<0^n!5tax(mTs=+cp70
z;~*~N?k+D8&>$GMjl_PMJR3y7{#FEj;U9hbCgKL+4Nc+k50>qnl=(4!;nvM|zd`PM
z(f}Uee@vZstXf!sAGPuz<vXYGJi-~1A_n$F6>x~pLu?1AKUz93v5y@wHPQ*oa=ckx
zDz!mLQq@U+o~BS4E~O`wz-3Ixp<2H6N}umpojvdhG8~qD41|>(<-9<cY5KKpk7x5B
zsRy%<CkfS}@HHp-2q;RoS~q~+NJ1N)6d7fpMsFru|DE$8q8-HKPXD&?5Hx$QllLy7
z{hnRkcdX5)d9=!pyxs2nf4}n~x&@pu1zZmcP`d>f-9n+5;a9&^WEv`GOnK%R-djv(
z|1_l70(PLY*&51ckjB%(ILQns%;v=8!OsPxN9Cs|`&o&V?5Hs2?F^TX1VIyDIeM&^
zIec4D`{qvwg-UH9-0g|4#S9f;xg`#(7EZUq?3cK7FJ`mNp{uhG%un1bv`QJA>9?94
zRlj^o4J+rX!V!OWTIMXF+WtS&!f98vQ?b?NvBEtS&lvJ)BITycCIg7w!1k4co$uLx
z!GWF>k^=7X1+`~JglHm4ti~VpLuR10X^ioG^r36@Dc@3F%VtW2$KuVLcZ9*KGEQ$i
zoZvu*zoTF8&s9+()KD;+p^n$By;Sd#c#1H_ck*bs+A*d7#F${pf>=k5NcmM~F~gGd
z8WFFWa12zQuSVD`Q&Qn=1$V4F%~vH4tf+0_7KQ{rH53h97}2>c9Hc1BZ&)VVbLTuk
zcu-GxZhB9GihZ(x71JWL)YVQb;It>}FUnT&CG)Y>X3Bf2CHHD1%pkTp7u9I00=7E}
z(BNnZW9&iOjcowon5}#xA+nEHhraH<_&TkrDP8QXg;D@9&qvhRPuRWbX#0j&?lPXE
zn!BRsS30-s_i~q(7q7CI7>%2vj5>7PH{8Y#m3hE+{TjI*e}0N8M5!U35(O&i9%K=)
zc<are3z9`v4=Ti}UYkDbk-03nYc<m&Y(c<w8`hJkSQ=GoE`?y7{N(z3EY`H9i6SHV
z*_o@i#moKlj}uQFc|Pqc8b?6@jbU7)j@n`p5ZJ#*zAri0&MW*?vMB#sNYI@<ulK+7
z&kb_5HC;0cLY~=M#8n!e^H_Wzlw2$X)n@B75#YQ{_|cU|B;e0CTv6MzV$<mN<X75|
zwO>6K$MCdX!mcJ&(cp<JuL@4jF!U#%wR4U2S%~#UH8M0^k|KVwXsIP27xl=i>xX&h
z`CWJDM5yJIoS7<aeL>`l7y()5E5eM~s*%jGklJ2ALutIFFMX(cu4h`|*-)Ud7njm=
z@MFd%4P*AT)DCXFym1k-J?hY&oR_^gO+G6<wFF0&QjompE9mt&TJ2-g6_fwe;3vZN
z48<jC9vrFd6C!GVhU|e%ZC!a>Y}}i;{tJ-mS9^xs1CY!Zj`r|zxyy05h%d)1sEU6Y
zl{YAg1_U&oZyk!)9i%9F86IOt^psPco_%P#Ht*x`y_TC;gA_6q`^{2yx{lwWDqjA>
z?H7O>BuESpB;I@wcl$6dGH~ys%s^D^l|9X%&IPgPd{y`po%6o<u?rXrZ;S*7rbOnT
zng=a-?)@^Q{V{X@#EYY(8Fv=NbdUf!^xg<gt<!)h3Z(SiAJmRKM;KF|{E*;Qheyqm
z{=B;Vg1zwKG;wg7@7OG(izP3{=nIhiPh!4KqKnUZN>a=>Wvg!ej28*_i(Iv4WH5`z
z{pzt8ipRa$<Dq>W5%Ln5M?_g2I~}ngLNwv#E<7?(W~9=iF6_iQ?1SAX1Xq?tHDrXF
z$lOkay^;v4PzMpwY$-NhN{wxo_)!>J?cepg{ZjA4Ha>3F8P@*KLB*cr<|P=vnIv3S
zMX`W`0KK>dOo}gg<BB!Nph;R3gZb3B`};2GWdu<kF$LT)4T$y3Q`u%EYks4eS-ccX
z*xIByvN}q#h^j~#F#D2zZ<ZJs|KR6UPER4|LGnP_A7#Bh`fAlVr*aGbsmS4;pCI;=
zRHOYH^XD!RqnEOJhB`VY&Rmu?(lQpyN2ye`x7DB?8S(sTz0?BHzHKJ|$X<`5CuY{n
z&G?bKQvd;2lqdvXJYoiPQVkQJx9x7bY)C57UhePS?{1!dk}aXSFMW<Rrjx(l<={rw
zs2{$f;{GU}&2_lp)iuq)nJ1Zt<%db>+FIOBCi1q52Rr<DF~J29{g^K7(Z&H=Y%SN&
zltb~BzeCNL$FbwL)A*zeLtCP4?pu7B><oJUD1qll%k0C5uQN}xkF?G`jsN@SACFGk
zd=HIB{8)}o`(l5Nxc+5c-FwSJCCcv4a&+&nysprX+vnBmSRJXex_&HIuk*`zv-{)A
zDE+Q)(;b2D4>;5Z>mQ!PiOh*j+en+lWlMd^{^1**W&xQxbGB{QYRNI){dwi~mCnG~
z2bV4_cfI+QI=T8P=Vz<rL2j1bcHut*`M90<kF6QUs}g$l_Pn?9*;R3yqCe)yu*D<z
zC~mcG$HQ!V2m9^u_U^R7<GT_aZ;6LT?%5f9)smOAb(5{X>M(v+(<|$5vc(50xh^a@
z3vXubk)nQYkdmiIT+Y-uD6YP#4f(y4>7IRN%t{7AUPQ{Ac?ElU{J%CCe9DgxPQD2)
zO-{a7H)F0<S+PZ7a`CX_YpgQ;mLYr&AaS@(TyXzBngBa*DxkW{xIcIDl97u*PAo)8
zu0|QUL#XA+jsBc{nW!m!y~xdF{ze8!%T5lG4R^qw`(h48r-NaGq*+*M#zju4l$Yu+
z>Wb&ckQ6cRI8NV~z~qCC+4&oOe`W&f)dSpCF86O`DO(Robp$!TmZN=*?+nPYPb@xr
z=Y2Npb`RSYnDeLJbP-xPY;lvrOMt9CWK#C__-5I;F(DS{LonQI9Inkw<Wul}_5!o~
zUuMq0>T1}Gh8QWAvkFUQlG2d3tCb9&*w?`vPql|lg~W?rhBzg!8-%kSO%$><jm)r0
z*G*a4kZ7M=P0)9&l4RWFZB1H$ZRB0_J*!9oJXZ9+UN+?ku4?IR5{r2ED4nbMs+qg!
zdM(6A`P+%NL`}^}nOnQcFT8r;i?qMA+Aw#adsgRwVL@65t*AqS@y1b;pK)v^iCR**
z(HOfCt`!idHjpA<Ywwu4G`-=x&;Lp%B2T+TXCYm!BXpeqPDf1npV+fM`?K<F9tHe@
zY_aV%Pq+3fTB4uX>>TeFtg`|>^)==k-)&UK#eN?Yi>klBC2r7Y?_%|H?6{qk!E?h&
zZpvoOt(fMmcd1Y7jZS!1jZV}j9-qn9e`^e149tzA3%Uu0^*@AAdP7wqjV>m-Z0t5M
zV`r|6GN0{o?%7*Zvzv~R#frwcg0~LqUVl%_KQEDP7qj^s{#X5@A@+d+XUc`to5^UI
zvlE&19*5-Rw#PcS7d5=GK1N@WWNf+#&)$^LiDS~&UR1s?!0;peJ*D5hi~6nEBx?~n
zcAxsIZ&`g+(jo9M)P1T=o4FJgnpI`UeFVzjyKnzZIq<%~BI{Jnzd^gBE4${Tf?9Yi
z`x{p%m);q1$*bD?r`D52&Xh5II=YPuEmALyEm_w|8<s`1ggV5R{8F&!H*s4zy1QYH
zecW~1cC8>pNkW*1qb-e)n|jn4`NH(_C8nL|TjyG*D;*}-qY_d`n`cU;ZLyKJWR=uQ
zZQ?CED(NPtS4hfrXXrbET(5=zJnB$tTK|M2E$m=cnvSFqV4KXHdga7z9x{e<CEsB$
zS^WDK@Y()@L;6x1p3#DoaH3Y5aBeYGP(@zSfnWECZjh`y@2#9~F|UrnFIHV8q(~s|
zWqxnx1jM$GhHCe?Pb_{e0<fIsNR51d7I@x8xqeJRsjo5kzfxOqS#$<MC2cQ=O*65Q
zGCPz-RCJ5DY3TIHa+mAfFk`_eyKUa3j>1f7yJG<<7&v};q{4ZsC9H>X^~j&LtoXXr
z+!uSe=L5H2L@0p;E3mwi|N6`kD|hUon<=_HT6%-Qr<!A)NcVbWIS-Qg)!Kf{{1~-I
zXj58C)xs3FzPSlJalD=J^>m=E{U4X)hRC+ReR#L;(ZwzNQSCirUynho1O_#t?uq9}
zQxRANW5=lbSH8=hJI*u1%8Kf!Q@wlME_-IIDXOzM_->#l&-<z2sICfXzSwFt=ggO=
z2hF-!at4A)@zKV%7u5OY+LDnun^6y6sj4Z1(0u<c-(#=w7Kc}7X1@jO$eFV3mvmr+
z3?I;kzyC^#;5w!zy5qm*_ra}kp2Upoq!hdlo~}B#SUKUb4CW=YCbF$S<!|0NQLZFB
z;5JL-?KO%}GMgb`vdJI;1DPK<93Cc*w9>&mZ6l?l7LjKZZepJ%_0NhyvT0I2V8<XV
z$<x~Poa-_++@EUj%>E4U<fhEVZ-jmh@lF_QUSz!fYOI$gKT$;HDCfZ>TQ9s&S#1h;
zRbx<RZvll3)NP2No4-HXP_qcH^{BHjd%Q&!0xFh#F>dKvP~eQ#q3PG5YDmqQQ+(cg
zM9IH{8WQW9`GHs(h-vC8MN3)(1`qJeYGHSJ5>IwF6@wn;WWO7v7RDXCOC@}}#v(7G
zZ7!CddlS=dT3YxXQ2Ct&u^2ENHU)jVmB;BVS_lz!G+dyLUq)>8yY_8Pbegn+iK01e
zLm04zQ6!rleHcR42KhaI`$9*Ku1>Qm&|z_TsCC$rf>0qForKAKlIbBSL4f<QEFbKE
znW+fFMBP6p^JdCUhz>3%j{UXWkz>aEQ-7QyxP)uwBb)9m+;%+!<68*%J>_!)E%cV<
zenH)|*^tT|!derWaJqObmP$5=kyy^ux0NEA%%v#Ye9Jjx{J72`?c$!a7~erRTNLk!
zzya0bU`)|hwUm}$lt)n=Kc-pkYZb<>J|hr@F^!u&_b%IH21o6BI6i5TpZH|gR{O7c
z!n9F(Ty&u55MEz@MoS35{uN1Z`g?3j?FGQ9@pxN(NKXY;l(LuH^Vff2oZWI$o_$l`
zyFM)=@0GBXLE|v&beicIUV!k`$fl6}VmYop&1|I?lYz`IUmf`x7;Vy+bm(ac?+3N{
z6`TH`n1N&D3k5nRjgP|D`;U5e_`Nq)5s7D;>*ZkxYw&pxL#$fMzaU9uq)1scWT;Af
zzf!2sYvywH{sS49CDBJ$_~mFyGcE<CtH~s~Dh>*(I9e{>Njzc-a1cqDOk;5Skh?^M
z(O43KRBa;iow)vojdQ=HDNqU?+zOKrzu9i-pZH(5@y;&Cd1fSG8r}Y-@qZ7;d@4Zj
zHzwcqJ+0Qx-39VwlLN&qQe^#8<moAjjVa25DXOa}hmfi23aN25oZ&$7)dl1LnR?n(
zT>Gbl?<anP->IC3Q|}WH?<vVk05@w#s1ol#K|#F+d2@DLzTsu9E{eaD#tDt{E6Ebi
zxYAnG{k}PZ!aKsf<U=2Rpalqmp9;{bG>ew7Q@Y7ya4ayQ(Um$Sc8bi0R_Ah~L?7x6
z3Bj0I@pJc9$EXww_|7ALrg^lh8_0~OHPcLr6f8;_Gw!q_F|}NBDMv0`N)Ig+{Om06
zNuYJATWD<R3_@tv8pRwI(e3~ncZ#J(e<4iOL~kx2Tm3+H7IJ`r8fFBF_#p4{1CK#~
zAPD4vJRPhYI-pem@}!gE8@70&@#1H71RfKUPLyaBX*u5M(3@R7-9i_mucG&z1;<C!
z3|<KPW6|>Ayu#3AA4-DK3z9SWBBDngLP2>(dAv+U?Rfh|EUK++iWR2{oT@*Sd@z*y
zUBD4RCdiY9ee)U@xP%Rn|Ap}jZ`uVXX9I1V&nXyx3(zgpbf3c8O_GIxegNh0cJX2T
zi$2$@1I~8wcHcuu8luKRF>UX}CKiS9X%R;SGfk(RMHI!O+RzX(N+$~W1w+v76qXZ3
zKP*L0Ff>d_Z0??)!H^A3FbwquA_ZwX0yE@^95_DFhW`0Wmt$H@@fPYY-si3%?URr*
zA}kA#wsY>hdg8pE=q7pxM1z|e`#|7>XnQFL8Yd_{{u3Qj055)ccy(Ul!bSA92++nj
zTr1<Cc~Mq>7rkQ&KDnfCxNGG>I6V-4bb8XU6j@epDA+&myIX)Bp6B{bbP1*wC4?e-
zSZX^3$&M`5AOV7LxZnftB!5xhpTERJ0eW1vfSrUoWe;{0pu5V%l!zkqNRU3}Bp`ad
zV9+v-jNB<L{aZ~B#1z4(8uz6+!A<l6iSLJH)hvZ`q@<KnUH^*%{+Q|E>U+g&BEaeb
z`%*)3xhKIydy9U^_b5fDvbj(<zRM{Dk}soy{@ZrgG}P37hlu04bkIp3`HL8|#!J#D
zNTVNo$Bl-b8<7h)WM7<(zjlfnThk2za6iz^x5^$`fRUk?QBXSQ0XmXV4ip6F3ji(!
zzBe*)Ra{yekBr!%)s2PKo(uj;X;ys0DyZ0-Er#&i>cq8y`0w+1|6zfhYB+Nt24fB;
zlEDKs*yMj`u$p55U(8|d1pCl8=LK0Ys004er9e<I0PHNdaYsGF`1T?0^UiiZPoW=@
zJ->)Ghhml)e4rtE(2UNNjJgd641^A>dICF%4>ocIu8zJiz{fC#8O5^8<YzRLbn8#W
zika({@WdJ#W!`Cws4r0x%e$4nx`AjrFCc?(SlHk>#jw3uaOqGgYFJKFefnHNQu=6v
zP{Fj?a47LuS~G;f{Wmnfal!WR7ol|;c<G@njQ=L1T+9(b(ElghBCHRHddB}q;c-9E
zpNt5`Yl_Lsn0dEm*UO#RytA%%+9wHhtw8WplGH9(%Wc*EbObJ}j-F!i{#rUXz!V{#
zd)*j#?XC1(kk1#qr}$Vr7~pE9@Z4Y_l$7ruwz{tsc>hTDece0v^<UmUdj0<SBzNv)
z_>ooYV<<8&sbEsQ<Cwmy`6lOZ8y{~epJGNG6F`5z$Jb9`pB>N>NOuO`l6V_7I9G=G
zFYKa~hQ-||ovwE}t$9wGfQY4;Xjm9$TL3sl;XI=(;28rhRbRV`#W~K1NB+GS{k1FY
zQ&87DoHCDm3fzK_xZkh9gQ~+IZQQZq0y5{gYTC{T*Vd`4-|)X9UicV2MS3Xqxgmqc
zT2Cw#Ig;@oXwwB?mh9W~HiP#;oC~R7KMAhUuAK5xyjA?Mh{M&U>lQ9Q_;6NW0!SFd
z0ztqTHU$v^3Ev?T^FV^wqF2-g@qpbuVFaFPLmu#TbJe`v^GNxk+5?fYzZ!MWiPY8e
zggyU+6<Dwt_~axE)5DT-q1@nvaEV!h8d2=BydmKS`uH1o#s_|5s75G<IPf_N+yT4y
zLwN_t{67kkJ28xXiaZ4GEkR}MDu;+bxf&>_eGomF6x7O6d#Zmq<ei$|pfLU_`gIs;
zHxxZyc&nWy5y}h*0x<tC*UmCfX#oYhp(qxG@YhUSZ4XVdKDcc6%Dgg6+Q4`HL7N&C
z?T2!DR!hwR2gly-nanVU99UXDyv;Zh(2T>qv<o~c6off|XxR2o?r-)}XZc*62lhh;
zTn)784DEI@BAsQ#E`T#bD+X945e0C})?H7-@L@b^n+(owL>{#!D)j|~*Y-YVg!o-Y
zn~3!MWvO;945FdzAvS)f#CmYv8zH4mP=`wGv+fCxAVF#zje@C|7WN#%?9cPA4>I7G
z7w7ny!ZoP8d3pUc4NgNIrvUL*#!Cx+fbk8@G<aE84FAyAs$=&28q21u*s_78cJZCC
z%no;1k_KX=7fv|qVj_47<XWyyAGHrocLV7&wQbZl@Y8&2Pu_eyqi4dhNEdzfcOKnE
zLBct6o8%b1IThT6x9++l%2i~pXdqkQm>SX@SU`0bW<<hJLhySJ(nD{ELWrX%9(sp#
zVetuvd!TyHZ32ZJ4o~$Z0VCmJYSMY3iLmq~xQIsE{*zkBKQYbVcR=yGW3NYx!jU2e
zElB_y2w|yiZWuiUFau<mDV|p(c^HvXAtIy^10v@r7(Yv}pTt+W!MSgi3n3kX08cmr
zUUw~w?|9pI2gjVW(F5!+u@5HR_^4g{D1;2Ze2H%pBz&^J{9WRV_Z9n~cYON20WYWd
zc0(&jM}z%&SPw>~Fk4fFN2gPss+&Xl50K)~N2+h4Zr^?_e7`t5z!8T3j-H_)KANFm
zBVc+Ah984deD$F8&Wr9E_$L--nf$&fSJlMOx`2F8?F%l7aD|b(F0~7q1cFp`Vc&MS
zsk<Lo!E>K;=hp7deSJOm{rlX1sE?bfAGd8j{tW)Oll!r~9v&Xrz<J<xGW4S`Y<N`C
zJ#|xf;&p*AQmb1VXC9tw{~VTEii>xB9<2OmCIBBQxGmhnmp6R?d6vQ2`5LO91h#Yb
zkVDucv`v$Rqdjlp6ZC&1Ugv57&sQ<RnBolT(uvP#-OCGq35d6DV4Zvqg39~;wU7lp
z<b%l)r(w}08$CzhhSeULWxuF_;rUKP#<A4qo`~4BfT#D-?sK1x@876y;5l$FvO(VJ
zV6FiY(uE8!s~&>b&j+_>v*%Gn1%!M&_`;t5<9%)sDk|(imoV?uCU8kzg9}66$3a%#
z<$&4i=y2BR{>G}`ex~p17WUSa$PdDYJJ77MQ`lF*bxSedHX_F>*l44(0<>RfHwx!>
z=$AO^7jDScd$wQwLcr6)Xq(F}e+(m#`$Eq{F)X^(g?sOVIf0A~o+-Tlb#43=GEbuY
z|Je5Tc+}2MsWU8OKbTWGFV*>1G=_rlyapGiV#I?4MBG0o?iIoz$j4;VdwbrSp%l)A
zZ>(c!@DZ+d#yW(8?65C=rK40It~BKjCh_$k7S>^q|DN!Xye4_<APKJ_T(3m<ELsFI
zDTGxrf@O&4A@N=kK_5h`dhAOftVkP6@Hz19a{;=?p7Lun%$IUJ=svITX|W>G6&MB;
zFnC+5hV!L8{pkj;bTsE<@~0P;Ak+Td@$u!h@Rt)^Y;<#J?N=t{KjI~s3tI~LTgsk4
z%&UIz<A7W#pa|riDnS3hqojEeugRzwF<=!yhSqRKUPHGPJb*7EgP;0%+JH3xW)0wJ
zE#L#yJ*&(P?X!4|^kglX!jv+362BFd1&Zc<M)#F`-d;r;JQ5!NhW-xn-XQb*G59S)
z{Y^jQ2`jw)cXxtKYOA$e)!0UhZtmExU|<2ixCls*@FsYn4JUOF-j3Q_7k(*uCe~mC
z0wCJ$dGI5Aoxs2LP(^q9cV7$OriSqN+Oz75L7Sn9#1Hwm#fm*Q@ZQ(N7`tdk0PgS-
zMP;c~tP6$Bqa~pWI_dwM^b$Xy!QDl+2Uo$mXEVUXA@TBsDxoX!@4n@UZdK22Ak=G|
zxYO!!H@BTnQRejMvSo?lsTQB<(N9)o>b`I4PQP2RsnDfL{rP-|sH#h6ac)e?Er{5+
zr=xxzIh6ON6ks5?KObf&6ajghtWuCM3B<%cgNi2!jU0mjIbYWl2=#z5hvv2j#ZFA~
zJZU&>X7ayb3Wh`Q@71@q*D8DVD<wX?yKC9Lf40zP{IIHiVuuC)x)|lU-5Ku4f6C@t
zWzXMapZZ_f=+D5Z_Q;jOGQ0b37LfgioOn($25<?G?SMbtxu83{CEHwQ&rJ>DjzhG`
zwA*3QQe@1am(@NVPBYDNwH#!xdopLZ-oEr>Yn1kxVuWx-(Gx%0m_D}7?5o;;f2Hsd
zhsqKpxB+5Noqc0z!p!uys@0j|P$O>Tjt!&6!PPaKs^Aw^l_wOxs0{EEnb(1N!eS@p
zIWdKPMyhDNV@z<XPTt^zbz@$o5hRJ87f~3}2V^xWC4~-HYFLH{_O&rjX#bGE!Dqa7
zTX(WlcdJhPUr(xx)ITm+;8lp#U|FKx-&fd!t=V&u@9g8kZS}r(Y`=NdRQ9<l&SEsB
zGEwty@FQBO<>1f+{3l8$oZdvNA+j_J>P)tF<uNAW?LWYe!_)F6ox*oltK@{nF?Q2@
z?M}6YP||>-;n~BowQK|1rXP+)n*Yw#UECK{Bj~Q5U#&^ZBHS*GmvFLhbh;k->$JbR
z)4;7mrV>L{vuB)Evqs;XR(BAwlz~2pM>=LV9kU9!dCT86p+Wx0GcT(_oTc^Z)uu1V
zoiTrxJ5Z@AUKBa|?0fYGok!zS;QEo%vTGiRv&bZg#2nN-Pei=qJDj#qxPWaM>-#02
zA}j3}IU{bK3|_^lB>AKm1`>ZD$pY)y-fvF6>LgNnOc!aI2hlIddRJMZE3_a5q^;=X
z3lm$CWQpgqV2sCS^ElpElDXq<<tqVGy=7u{6X!ePi?|qBo<!)l7LnE7A!?9i!NE_s
z(WUz3_Rej+BzE9_=B@nW%+up!x{58m6mF>(TUB>8WF}}>`N5v8Vg*5|GV0gJ>tfm{
z7an(^Ehc7B^(+S<Ud1}FPAj1#6LVmme(P3D$nm3j(exq>DIMz|r>nwW$J?#S{yYC~
zt74RV>sI9an&J&juanY}Rrm6b0(14>xPH^lj?CeryDje%^WMi7%e)Vpyb<$z>8j^X
z<#GrAs`$2unQhvZ`oPMh1wmxL(Z*zI1UXOU24a$Kn5+`ofNlu!&P=*kU236QnNl*B
zsOfnq9uq|Ix~z4c!`(SD@5@j+>NP3fWWG?0OIVI5B$KJ3GG3sEl*Ub3&^7lryMPWN
zPRa?%=8)dXN95UOTKUvkUv^3d4l0m56}ZHSHCz^0B5E%-R~Rhhve5BDFB@8leF2fz
zt}OFJw{ZyBj1sQ^2V~lyvDkHNF>$a5lUKlzmPO9cYg=%aIqfZO$DgiO4UzXVS(238
zwXiTNlFKUckyVYcwDxl>4pWgT)ZVqUPj@W2nKMzFXMDn`!STu+A79VD{(k2H$I|<C
zzN*17R%ccmuRdP(J(RF(MS-6z>y`0S&yBJ6kvn<qrH|j?8$*?vgA0_?1S8E`T+d^V
zp1l4(e&xcm1H;-vMp7_&?1-tnZTKTNuR+C!31Mlakb#qx{V=k`?^^I=bbqDnuK6)f
z_I3&2@8y};K52l8wLg2-=16xE2Ucu^hwS=VpM6k=MBo-riZTkMrDW-2{x}r8(Ky0x
z>$e0*qeV@!*IU<?j%zGjxsvYGaM-57cz%RXY|+!8GcFdC@&L_B`*K9>JWLhoz-cV#
zEzWG@=+*S+M^zRzoUCu!qt8F2#P@UiXpS7)YrlUt>uc4c5n3kqaM4={Z)NUl=D1UC
z2908NEvM=OJ?sYHZw;A({h1kBQoZT4)p4<u?K>9+%F(&yTe6_xTdg@Qk=8PPhtWb6
z+3&HZUul0uf5u2!?n53Or`g7FZNgMUmL{wtwq)O1(2uJSYF8<=@;0a7ZjCs1_Uth(
z%pE<XBp>8f;;S&-N116C4E+ozVTXYF59Q|__-`aEs{&8yR+jVEgz}Yw8y|iOx#XLg
zfzrxFhV%$WC-C!#9F;rL0%;_Fp5dPe@h&KbT#Fbkx>8m-{`l{wR!^3_xS9fu=jBL$
zB2RDH8m|s8>iha6`1Q)SraI(^!x=#HX7fg9$-TX-(8QyA)bi!jB$+~^Qzw+X_S1&@
zRK{OhJzX5S0wi@xp5!t5^4Du-&PA0356e$@RpevRcN`$oLT34w6L=pEK8|^9mpXH@
z)FPS5Ey0(L?)3P!_4U#5mGG-VUdXEG)PshF)YSPJ9EolG$|vN-@izt&iM;GoFtzM3
z!IAFllKFB#Hs;gq4qwmDv8P%8I04NFj{IoWQmU&%cFl*1RXVBssr)n|*TraI<!rai
z>krlTmZJ-X8RgGS8dFxr4x>e~8^^eJ5l!ByE@}Q~x>EaqOYYUTX0Ly}C60z!oBsRy
z4|*%M0B?fTMkQ%#rc4dUU2}TC8{}_(J=5z$`{nwC;2_Vucj7mKx}N^~UO05Bb6)P!
z!<x?Ei?`fAeD%BZ_`|=D=ojvD+YOfv7Vs~`f4<%%=9e$Xq##Nkj<!AiU#-@L!t*}E
zY4@oVX=2TpG94y1(=~@l=n3`Zu=zL?->=m|Mdc^XF6Ey`VY)Z6kM7DyvFEVMHuH3=
zgW@fTNWux7U#zPP3J>Ne#>|>dsl22j_qkx|;qlmKn?7pZM`hYeuDMEk7cX-x?EFDQ
zS4^FEpYU1>>f~^m+s-GmR&d3cmbzPE-mO+L-}njoqxoxGzADC|7d_2f_Ap};nnc2!
zYoE|^waeuZf4Rq9pOl!GEN#$`&-v0H8{$Z@PIZlZYp$iJL`~ImgE?Gb)sy%6L+4xD
z)^KKFHvU@<KAoB_1eWL?Bbe(CfS<gqN1)YrgmPMmrr36V2G`j&ac|#ke*&uQfKbfp
zGukSyu{A2wEJAF;*<CN=H>Y+BCdZh!2w7Tfifc}yQx29-6>Zpq!eUh35QUrkyzlEa
zpDf}|;&F0c%gv2u7SIpMSNA682Q&iO=M=Iy-9YlnNu(7>hDng!6v*4g$A5Z12da<%
z?R`G4EZ3iPGztlXbVGOFWfI>bBC1oBIr#LD=~NOu8VeWTg+H~T-;~buB<lbhg4Cqy
zc%2&nKK1N^s_$x-)g!VRHiLGcen({fX)ik)4X=1~6<S1}BjiaBXG}|HhSHe|6-JUJ
zgv`~R;PY@9r-NLmTzk<ypc<k3yHL%GCvh;tWuEav5B=Y5o@_|kqyGm%H!|e~m=odf
z03_f$0^MG~o{2_Oxzg<T?-1K?iG$^(?x-W|?u;WNoc16*m|RGkf>E*Q@00Oqu4y*2
zCd>`4Y)oGzDc#7Rj}#$i`z|LQ;Jkf8P-_*LiA9){@#Qvhc10r!fXu=vDB?82lskzO
zosmFCY}qT6DQegwljJ4Rm{Zpd;qg*4bt^?FRO}6ZJap1K*GwS?Thp09>MT)!TX7+d
zqzuFtm<62a_Zx0F-pK7Adc3=kyQx~&kyZG)SYS;c8$aA|b2H;Q2Y+pJjwPP!(eDfc
z3y$<=W*oCFh#QmGovsx9a3YDLstiF*(kZ5=CvKP&Q#h+!5sVXb+L^)hy^M^A7v37O
zgo+G}ZidNp`Enzw+v2EZCg{L!hgt1%oD_pu)zC#}5ytw0j>>4|W>opRI@9yzfo;%h
zLAmD?@IiE1aT{FGn#;VcB)U;3&7YvEl2h+v=|jZa*~_r8SJaHiO@II%8=1&m?w*q`
z0f18ibCuMS)%hE-cJC_xcBZUDQP@1ZCB*_@6y0)qX?_MpY@{i@k_tqUiZ%!ZPDnCP
z5?`(JxiKpdX)UK{eNUy~ZWujk6&&||86ttmv@e*$^9t6;m=qvQ{MDYm7wTk`^IqiN
zzE<L(1l6$b2rqc`j)qc1(tLrEgbn$$w)8LqE*<|GKb6c6yf(p2BA=+m$xY^$W3I;I
z^D#A9@%|VhHMNqhaH5k{Q41F0MfoLrt|l~cI6;$c+%EkVlpB)GLCyrzHU@`bsd*a+
z_(|jr&F)KtoX<OyYtqrlXwGy;x)}p!y_b7)2;sV#YiLpaZ&!#n7v8#2@*w%v>lsA!
z6bI)Thd0a4<_oVe5@rn2gzlF9RmiX<X)9Y?i~oK7(`=1~eQGLKMM4?E$bUrW`y&83
zf>9k2P-WeVP)<&{GfC&W(wENOJ6d+{25s<$peXa*wA6+}b__&Qe7Yb8RKEhNzjhK`
zzKxu+NdK0s8KB688<q;s=|v5ZNBK``cv#8`$?3S}nbC(QK>j(s$HGtU8B7_<lpoc&
zGmu4A>tvHEJlo5M#5lvNPhkGk1uO8rok4WC=NeDJEt_+rvBgFH=}<>_TK5gZTzXus
zlhucJ_v*~2r=TVb8fiH7_Wjm?CJu6&bn86SfRTDgfmux9Faez%o8F$jl4=0ZbT$lc
zkeq$eP6ga`4t(ky^x8T2gLBAt=L`RwLs2eak}lz@E*FowMA*1QdQ2uPsoyu^&~SYf
zq@1GNn5voN9QD2R6ayYO?~?f4<tYcC3c{mZ^CA`C@tj?zZRy(E5)rPPtXD4k;qW^O
zT#48`Wrjmqbviw*i-LVg(}8>WN->M4FrzeIi}Vtk)1SyM@6eG!p&Z(zf>Rq^7CPx<
z_EZXqMU#JW*gVU$Sd#Gm1d=(JajUxQ5~ZtT(KtwaCWtr5kS>$WJF}a7uVgyI1DSNJ
zfZmJ(w4<4cc*pblHi{OvwXxF`{;)Il>D1LUSBqQLNoiySsL3+ie^4BtzkldKJKN^|
z<R_}r*Zn~~-HguZj1^47)7-k9nmQ}4T5%ZjW|$|_D)BU0C|swnv?1Z)UEZWHmihz>
zdI31iK^XKbdslt(Ev|NI%F=@ferT7u0x-~tI<SZ3y4FEwhHp0qGjK_<oK}V$ivEV;
zU*v<fb9G$P0}qB$Qyk6Ss5{CTUdZ%F{0+Wwl$FDr$|)YZLc;f>k^p^fjh!YSn9N~n
zRbbdYn^<k|LF>B9AE8{O!miB><=;@mCY-dId77iEb)M@^5~%0;a>76Dkt@7{$eU4c
zwXzyvj8Cxz`h=#f5-IaQG{yIPn$a3aB$dMa-X&sTA`b8)?#y3W*H*Y;R$=KY{P0Ww
zfbJsnEI2Z&TLL-qNK-I35FRx@d^p}wqtM!A8X>sGXLY`3(kp}iVL8#3E-l9u1$b%q
z^yw(@1}PMh@YOdI7m9CRC2qibrfY>`(klI7RfA$Le<FCVXonR;&opL7g`pH(^OjB`
z_be#*-3&z-plngC|7Pi^vzV@2W>AG-Jx>xD3Ak=><&Ak2u}=${EAX<^>#gVShFjc-
zFQ+dhDCN)*9rc+8u6!rRg5pMnw!4C#$+I<kteQW|K=%-hJU&~W3((<;(Nfz!%SD93
zku=0a1je|4e=N@J<<qWXai3`24gK?(iPlJijZE0w%V%T4{@TiI_I|v6E05-1AD6jZ
z$+AA9eQj>4_*QU>vj6>NC$W)C1d^sbrJPdZnqgbXrMDp=^rq+RbjB#&ORRKEX252M
zJ1K?_IQfzZ;E8wtRWnz|F06|XlWJc@E4Qt3R#A$HI*)){ZK`V;Nuf~H{yH%Av7hl&
ztEBdYNv#mUVlhT`Vd15%5@uFhvM5h77AtdbRj*=GI4^mu`eO{gBpuaoMP%wA(i9Np
zPqn9NGD0b1p}^t<gR{qi9=YNFudFBkveNq9fGM6_XjZ@nhC!#lP%QR-<ivUZ(^mn1
z*y$_Msd5>$&$`Yvy4L;-m}I5k?_>oQq+XcKDAL5aHQE95U%RZ4kJd9Y`@W);hG_FC
z+a!3P^jCiemU8b`i)iQYR1Wi1m^m4yfeoCr=g>!{o;z6`Qj+&smg}vbcF7=Trhn>a
zRM6x^-HEo6&e-6Y37K>D>7}NKhb_T#r7~8Vnc+zzb5bD|Zk+D)G!wGl;@OaukdV)p
zLss)b)+$53w1j{hojI%0m+w>@;G=u*WHs0ur@vlqZ~=7l5C4~cG25&lJ-RI`lEkS>
zKUd!ElphH9#&UW-&D0vH|J?mNAv%M)I<;xm;Ky>hY(zgx+VHh>eO^sf=FRA8$?O}F
zRb-q{KG<88+VDxye{@|xc$JIQ4)ey+l<^$aWr(Vz+R3SF|3gLxjkVro{u`)2wZRog
z=g`7>ERApY-fK<+)ic|h8H0%Vi>NQd2>C*2_V0`j4Vhdo>Xm#DuWqI>2eqW^8fuQh
zSV@X@u`d(B|Hco-uR2#Q{6IYY`aelD>_8HY&S~|hdCx!h`+YpkRe-2N`=2BVuAj=v
zxnap6_#ap6lW=c68!Zz00?Fn!I|W8AygOOl5=VJ%Z~qv`Oj{v>9EEmPgv^-GqCU%X
zs91$-5$r^j@0^m8kx1|2Z7ALUj!0^%Up4%j!w@|Mr9N3mtWI~9&eu?v@?PUTLUQ#$
za$3oV{g?&=3*c2{%v0QhU&0QaQqjc5X{QHd)AM4u9=?xso1!VW?)<lYop8>FP|e+g
z!m1?KQ2x6tMztl<L!tb83NjNfpH1>V#SOPQnAf->9Jx5G9<BzkWy2t}CjYAmhTQeh
zl?`-`n19(fEa8FOl8GB|zn6?>QH7p%$WP@N6l7(}AKonfT#ev*#zsZ$(VRYHv{yh&
z=<ku&D_u4GdE0I9U3MuKqBYlF2RqXKV~J91odKVF1h>Eo!VCrB?HZ^4Jo-JAvD=8g
zf@_FPhE+vV!ju~YEDO_jvTvMDv-PJ@e{g3Xk<uK2e^!Q`P*}^1xG8E!&(Ew^7?M)r
z0+crq|6=}lx(RMm5h;x-&F<-+D4~tur4sOq1*(*4`IKMX){+-UjNPJ<h3o8OPwCb=
z$6QII3q3|Rw1Vo{m^(F}N`Z}1A$ji40VQ4vn4A$Tr<lwhOyWm-N7se=L@sQP8urth
zcn>{RqJ`MWYuCyjUaL6x%;&QBs4c%x)1z3?Ye}anWZ00p4*qcfzk4|pg^MT^gLbkV
z4&q&5;<IeDT>ndxD{6Et70ES2Nq6~wrF>QOGPsOYUZ;Oj<lET+r{f|#t6amSRtqZ?
zAs3U7_)vUL3LH(eZVV;#rt{&9aumXd{aM0?yk0eiNt@?{ZgILg!IA_4j_d#4A0bt#
zlO%;ExWU$Ci*k-DpZ<y@xgYf6v~U@8sGfV1ut^reD185TDCO?fl{m%7ratYZeW9aQ
z)0HM$&OT2;DMzVH-xGpV%X$^zuUnMkMNizHP+^iHS%7_DL3V{f;<8hXa(5s`H&0?n
zv^iRRX&?`0oTn0_@oBj9koTMBn8TmnR31NQ6N=Sb8*Q+=X?r(T>+3{|XK$Wroc8yb
zt_w@-H+SQX{5SV3kprz3ud}&0kS}f560f_x@}|l-UoGKLaK}YdL*d1=KWk6?Uu&O8
zU&TvU<UR9O$7S4%>^%Rl_xV%q>so()eLcbrR1b>yt~u@(=gCa=-<rM*NbsYyZ<d${
z8|?O7EFk^edxs<nYIi!=AhcbpGum{Q@@+YH1q6VwYVQI?llX2?fGTsbIMUnWO08k*
z-V&M+y^Q6FTaPiPWE+=v4QUKX#K;^G45<C6tGfV2U~_*!=>;Yy;1&j^|1MhFc-M~%
zI>S#Fos<YzHsLbYER4XHUMPhxllv*0=0E}6|0UUwd3sujXmm2~_;B=O8D2M>kam2Z
zEx|nN_Wh^m+BpesAEfgmWZ&!K8~z0Q>z0;E(}b5Wen87(=Epd(qtB5?h2HT{UgGca
z{g3}g)Sb9P`Ne+&zh}W<%);0QGj>8_%aWKegCPmY+F~u)8d4$EY#6eP<%>{RqohVr
zQfe5oRhA@0Wi3TTRJNMO?|OdM^ZX0vKIc03Ip_0vy{(0}K7UDlB)zKVEOP$F(X<Nb
zNX2SUIVi_&ii!r%n`<(eL~mc?kjDJOrghCn!gddueE+7GVk#(?bu|rGRIF}22NpMa
z6#4L6!(;9@mrnQf**?(}ZgKDnyJg>*p2vCX3v>S+2=a6#EHBPvmR`O4Hj4Db5pJAT
zfGBHhBtF9sb&~$(hFGghXjbYd?H0vU7%=CKm<bK?-76%T#qKocRF<6zjgp8PuzSf%
zhZQvr#`aiS-Kbaz^mLcu8%wiJmz%Gf<-6a62@gO1eEXXI`(MGM&ghp<<7&F9IE~eF
z)NF3T;X?nn`eg4T!_cK~XJtN~cYo1#b3A7JV*bJWcbjx+ermXTF;f0%T&~P@IxFlz
zQRsi6`v8R4Zud_zC#i#@vSif_pNPa6qzz;Fa*o|5=4PE;QpQVJF0J&}PZP^OH;YK;
z<S{1~pPq9Vwh_WLP^BQvd{4DV@xM8I{@$*s8{JS<{>Tg3zQNc2-L0FS23Z5Dire+Z
zRUcE=Wat(%kA_}epGh0=kPWZSb^J0ik|SDoxTd+l{8uD{XkOZ1CDBp{wvG%~4k)M0
z<4~@2BVZ5(vzaF46l5|P%HksS|AIJonuNVd7-_0$xi+^UWg+<TC52~Z^Bt*8`19G8
zg~XeanZWG4+DcESq-oq;)>;UvioEx^i+AV55byBg6|awoQGpIZlL-}<(S)Hzb+c20
z4{UdwJeu#?$u!Ok#%d_`hd(o|G|q}Rq@g@M|IDJpI6JOPLuDbnd-t?)PSS*i+KWmN
zEB+mW$I}_gSYy?><oyQO1V?qm|AxkdQ#2=Va&p<#IkY^1JJbZ>&Rg6O%6n!mT0yzV
zpH}-p%svMvxg3}cGoS>f=_92xoAK&S9jJaF<c71l2v}3Zxa(glSnNuIeM+0ss6%)z
zG6A=p{z7<0y!wf9vp_>lxL`>&(8X|U+~;M3*C)&`>Rr+2vXb)$JMiil`k_QEpAsUD
zlzcqbcdJUJ2hHB3R5v_k)WEZ0nk4nyD$8=bQ{iNdbpHvrc>{Z`65!wkFt;K>qFTnR
zKh!Zi2s2v@-Z9dW(e7%gU_VQd^y%pp6EL0AY)7nkC|K+20TFH!<hp{hE09pkC2xV1
z-@qKJ=*^tNngWG~<s#$7;jlwkfr8L4taa;|GDVlnp_N|t!J;L-hrr&4qFIR7!-$JL
z47%uuip>7r*Nm2hV^1<qBxig^7RrJm%+0S8^G<N{Ty=p%8xDcteOb&|fik4Aqn~{O
z6(^T(@hU`k%x9}64+#7b;S=s?{QK3V<KaOUxv#NZzh&q%zcQ-Yzp5UdS|Qudivb1H
zqd>yD|17IdUOn}C{}h;;?b8%o3R(+7-~5D(hm#fbtZxy|DALa;Xedlg29Qs0DE+8|
zmmhx1CZwW~#l5`;UY{=ljlb(3`(BvZ(3PhG9X5kL+>fit(DAm;Z3Cj(&oA&VVLFx&
zRlXIl?YvLZ`w$=^NuU`aN#DgEH1Icg)wJO}8yy~O#Y)j)OPNmG$#l9Qd!a?}#JYlW
zXY}E(C*pwdX7`@ysr?Mt(2h8ihxV<KG;DK6QGL&lD!|LyE;c;?)>E}`t%P5k(2z1H
z)jKGx@ArQ1d%S*sp^AT0t=fInOZ9%EhZF8Z-Fq~J=<?NfHlDbQ4BO&L9ku#oo7Y=!
z@^=QQqC|1ij7>>|mWO~zJm)^fO@^gRiHuQn=vh-g@v|xW-t0E4w0JX*SjZT{{^Es)
zoIYxd?6vkDgW$oCsq;}fSJfjt!A~I>*r}<Q(>+7FOG`v%Cr6nABWH&j%O9GRX><Gc
z!uzA(>A!Y(+mF1r1(%CIJYMd-TKo?saeg6S!Cw>cODo#hXcbAJHK8&35rC^P_h3B|
zh~uN`Mu<5%5|Zy8=#8a6yo*N%BZkL!^gMR9F)+I6{=PrvW$X8XCkN-xshj>w+usHk
z0=s5mN-1%U+3)zT!eN?l4N1NwP@aNK5or489yZ*ovh<d^K7$s|`_^%b`1o-8{?;ci
z{r_ZXnV5C7gQ(CwS0DL=T<=t15ZE|48fG4{ORE{6%X(f$a!!H<Ryk1ovsk~Ne>y<b
zydaOK9v(J2zKh~cRvanU3$J6qomVm{FAo3O;q|WiDy!-D&pjvgTDQozsA^VYxwc7W
z_Os~T*Ox>*;fzj@s+BY~dpf8VSY+M@Gh(v)aKBd9PpR%5s!bSpr0hA#`(ZV`%V)zW
z;i6?`*vTutjW5Q3#%I}n7kSqhGPEq#<`n7*bxv=BPNzmzQ*h(%tj^m!I9E7JR*t1X
zQ|{Zd4`1(8KJVLQ%dX#H_&s&xUM&ho^vye_`CYAV-hEUrtGUSJ-us(EE@qMrbE1F|
z70+pjf0$x6$w3c5;bfJb^23aB1|r&*T9jzYzq{tY+N1X6{l_)MNtMIzK>CwdzYk#R
zK&<&V#HC#M*ErOFQY1J~G-6UTE>J9KQjEDBpgRdW<ES*q;Qq>%<F|{S>5gdxY0^H#
z*5M@2P!cV{@`o6SSXGKyhjC}Q;}{O{6({~d)HxJv<KDA}#!@zeDUWr;i&JbfS@jGN
z1t0~VS?tL31`-N(E2hb0WVulBvJve4UR3p2$~O{JItlMo93<2zpR%jNqhE@mo0z0d
zvO+P%2uraY0r@U@Wf=}RthwoX{1-dRoNnk;i-2a&bKb5|DI**&%jxV@n98Uqx@_DM
zY9Bn`Nsk}5j0a-@K*ehxz|Z!<UM<y{^mA2`x0Ru$tLv3i606l6y}&7ahLU@aCY4fL
z&hVO@wp$F|8LS>XIci692e_n-v5pO?&VM4riR7-NEyxYO*ACD?U{YpIQS3Wa!~7Tp
zH`^nJY5!y;YPG?#s+=+IdnUU^w#5u3pBN#zPtgxn1-{luGlw}V*b@%1cCCVM5%)Qp
zfsJ$pgjIV3Dzgh~Z>UQ)=0RFzyVIT9_jG&^5|cakz&acF2LP{jbxoFe0?TBwV+Bgo
zXpyKl^CVF_T<%L4@cPtIY&pvgLW00J(4G_(>NK6P`=zL0U0~cpvhL}W$9Bq9%NT>z
z5wh58)ON%5e4}qUa=N37#`0)Fmin1Pv2|sh5>UMewv=p+gE>SVMcFyawTrDLhVDhE
z3=uO0UT$;f-1eSZb9$qLEwIj=Wm@iij;hH%Zj-2ep2~m?1hMC3i3qXOA-6Pq#Fi(}
z=Yy^1DWYGTg8z}Nw%!jN(gF(Rtg+;snPdRwAB#l>>wnteDWZJKZTA>h4+^m$_yB?S
zaW5dR>!@*hnZ}w3b4Im=J5^{r4>p`5JAgjLG=Y1e^iys9A4T}4bt(saL-KE3k|Q42
z&EK!cgK$sxsf=cEhr~~r%kDaaMz3)!q@7-Dy|<%&23%4!W_#@o91giqvop#2E;Biy
zRE1f}E6v&%vyQXrQ+5U;A#Oc(?qpzJt=DYE`Gc-%bx>Ogw&h<|eGnPo38u|1ojekj
z`5ZDBTj7fBF0y>XjKLpl0eMddb|#0C_@(x2FWV;8q9Me4i}WU!@yhBb{avauJjbrM
zV|yHfB%p>Ijycr*i?ajH|3A(7&SY`QuXVB(mGO1bo(mV)5sEyX^$-bfV-v*Kegk=O
z<zBF`>~NL_rbPH3o}w|^W7G78sN3)V$=w!HlJm^*=OTnJ3%Wf=jt&N=7}QlWy7X-`
ziCi%C`3+*rJG%sX)oSt5Np^59h)Ss>2KJqhc5+^<z7a1Gk?0^x0b9}1&2U;IgLfoq
zxEnT)c!)8u2(j7*&e)KKB=Xg-Un0w1@6Loe2SU8dwUm<Ot*UP(dFUXV)kw3RRKD!K
z4Tw4xoZTfSt6GSiXP>%HV%L490YIZDy-`WoEU62pDX7#9A&q<{HIc5wFiA9)-J!YL
z-=B&2L7cSa*H9;H7u#3N=l9-nvR%|5wJ=;JP*tP}yKO+(y{A2|-D;lVMPs-es*wwq
z5T+|Rp+l)p5lUf<6y;fgZ8#(|#+Q`bp1%b#!gd;MLH2O*ZPSil)&$z&Aav7#?ydzp
zI2gaU_|l{@b83*Vv^bc3<=8WOSt?0W`;$vol?IkM27~V5QP0{(;KH{Z%-~pp&j8}v
zz!?YQOqLF=22(y@=ZYddel9F;KXQV#9ZH9%8EQy?Q+N;@iiDnQHwHwWzZBKVq}t%{
z-jg%&VMj4>`aWaMzyDtU){IYiOuk(gh50A2?(DJ49Ow;I;}>hk5gP)ts0J6hi~;Iy
zwt+Wok?1N#pVunleLs<HKRqE>3YYmfENVatMZ9NSef^2Z>9L}Vl#JaFa#oqOy!M_?
zs9jC%{^6vb+yV0*P}z4@i8ClS17-nbK3M-AJ8M8%HS)!Qca_(39z#CKc4lq7Lcf3<
z{^V{g#nwBNVi(OS8T=ka2dM`#H9JMx!lXh0zWf+Tbz*{8w=Fu7+Hx5xnO9E1^L)cW
zDw7NxpH$aIQ8EC727ZWy&_pAbL{HJg&Mk?tXs}C5uzZ?$>5_OAO`?8D;y6ulgdwX7
zO<|xSv(Z+6Wh)z0BpV6Q<taLk$=PcV3$FSl99ZwLz+7S39B$yl2I)zG_sqfX9;3*h
zslwc%zHhWBfbS~HK2y?}sRX4B7j+XquE<_OobBAZM@~4t=NR<Za^$wSn*zb#a@rs=
zowu9;D2uSTtolH6@VD2l`?8H@BYRh+A71~^7d@l=K(sV502uTKW|_``A6$#O^oKLM
zuNNyvvZd_UI;M9c!`nslAeZ=s(Gs2X7i33IwvFEZ7aGlePny%nrX%(T68j84|1>)4
zgx@@BVE7YrO7ZSNoU}OmZpz&V3fWBoqOxXWbI1do5MYb559XOrZ0fj~6h(@|Z$rq)
z^9tf~h}Fzsm<ZqML9E<A$Bbi?o0<`d4^-+jBTVm!s#gD)RH?0nkNL;3sO+vx5fh>x
z_LL&T$o*;%GYYuHGGa3c;bi7pRUy?Tp0a<n$Q(^0nEscdX!}ESLCOy!n{EB$^6e+k
z(#Bv?w!I5Xa3LAw4WwXZyKQY=a@tP-^UM>yD-oyFVkTC!rU=v-NA(FvZ*^xam?&FK
zQc+;)gu85T!4IwH>qxPtoSto7@h@jz20*_u?@kyKujZ3Bp0j)<1ER9t>=x+2uIPF6
ziz?5O-7@V77>5h+;p~(E^HKR##p5BtB6OO98LiiRA~wwxMOQeJ{!oR+H}&ly9O`~%
z!s+pX(2czAw7*CRo`b;q6|x%2rphB5@_t*=$g;BzXm{q=+AH(UkKzr#{af!JlRR}Y
zK7NUCBUJFLfk$rE>=L?fvE(@VtQ*^BU$)DGQ$Q4?C~0vS+F`Qh`k=vKpUs1TS%HRF
zGcEM&EWA0UKlN*%;5~KDdlI2cn>BYg=VvQ@ZS2`;;GzQSWw1T5BiN)<#oq`2*e!l@
ziaZ-2HV|;`Y~-O^I$k7MRL8@I`G!z3wt%9xrf3nfVowdQ#gGTSmEouwxWKO6tE9k1
zhH+*T04G~TF;zwRdXRZeQ37xXgs+CuBRoO}L@OE_eQ0s?2cp`8qc&SSj*ZFM?G@Xi
z69@7JCfDB+6FMee2t35-S=h@&U(}SxRQ@JQWDcdM8plpc%?GvMB~7v)IT}p*d8}<`
zR%RN{UKLs?lauy3C}s8#1G})<_PeB@yOM9ZTNb*mdIOV*fy!N11D=CFr;bNk94t33
z7KkchJG2$@X3(ATI56^8yKHzOIck+u2U4E}DWG6S*F*vr9gc1}1buT;*VwpGm2|Uy
z<L14j`bQh}f}~sh8@FC1HH>dG%p~1DH`!5%`x2H0txvtNgN^9{=_-(o2RrnRb_NxT
zX)cyWjkuz*OoBnI`eza45t32?)Jz(5Kk^(Yo@od#xPA62CcL9CFvX&U5%DX{!;?d&
z>_d;WpAQsB*EX_GfZN`rnQsjey%;6{)otqv##iv<qm!Qz`;gd{1If|3lW7j<T9A^3
zlo6;xC-aBsQIcj46Vs{g%d(w=THgZSIQMvyz14$+ekb+sL}4DDgaSM!$=&o)87GUs
zt|5Goe7i<La?&5e+Q@))L`Gzn2?$u0#TrZj_-jX;vX27kF@D$?Tn|a;#<_Fs63&o(
z&u53W)yRObt`mC>2_894Jj~0nl%Nm>3v&<be+M}~e(w1Q2WI`au0Mo=9%Nx8m^z|-
zO)RX>vA4j>d4$?7Pho0MnfylqX}t{13C&dO6G;2(hbiPcVno-^EHldvP23ZWrV(<1
zz?NVW(j+b)xMf#&<%`(;Sm8m%CP<1IOZj<9Ax(TjlC6n_;KE4?QT9UiqM&&4$@djo
zM&A*juHDqV$C^|3{zn04)!VdE-Jkcuj*qx_z#-vb@wanU4A&i1mU*1=St6Uk;p96U
z>M|mxo*Q)j1bXzbA#8Ie6qw*LvnjfN)89%+yvx}E;Era3C;$VJvc72%K1qxeE!B!&
zLj_aPW%Rt863`)zS;|&tR@b(7;9Lz2|F;iLUM7;j79!jZL%_xm45EVE*_vIY<|0ov
zeWGyM{%4}(Ks1<KHIN!8)v*%gr=r)|^g2(PDAQo=gHn0r?JD(>&H4G)6p9{rntV?6
z!uo@qat=-{1+ohwJMsjl)-R9>?&>O<pX{Sq#np8U5l(gsP39h_QyZS17j`1pW&2I$
zGCANaveR{KIwP%6B+vfa$Hp|rJEDA9oLVWTWu))STG;zpvQ^@r-+z@8Xj6jp&+)$p
zJ{nssfIBy(={>d=+oArAU|=_T`mKY-pW{)u?ZVaVecf~M+I>LqFX)lZl7AoY&p;%>
z;>Z(zLM&F*{>g4UmF+jLc03jBs6d2*1?4`P!yU>j%`LI(?4ETedCnP9Hu>Vbvu<X*
z_G&FY?@4&~wK#jy%M7-gYplaX|IRwaW{f8I5u@eNGqo^Pll@JO)yg{R_`i7RN}H|a
z?#t6<$<lqgHD!4&IX^j{8!lQ0Y@h#d#$6>BryGUO(53fxxRjr{prm^R2o910mIC#U
z-TkD!quw+C9O%>!{C;>0YgiKt%k725>MAzhHIOu7O!U>t6MDF-4;kfp_1KUL&d1eG
zV)c(-dx8xXTuXk}-c@k4<pu%R@mR0E`0!|AJvy&MuO7LtFJfPLfUx(pPv#Td*CibL
z9qO*Hu^AzkBVT$%Ua^%99`y^a$(p}>abCQtFQ)CU+yt%b3P+X&l|EK(2bInxGi<)N
zSz=GEy7>WP;&hu5`miVv)D*9cK!7~9<7TJOy4NV+G3LYM1S!7VMW89OFbr;zTId_z
zPA(@n&T?mfBgWyEFOOCYRuIo7!lYTNY+(<EMG>jG73>h9NLDu>ea~RfUeb<VOnSmW
zv6M<-fa>|hJA&U|sk*_4#zbp%SGaxn#I5EJB@4GL{6kfnx3+4f89mbT*L>$K*$;t{
zvFzrnqwzOhw1|3UDFYe3I&{kp-F^i<=6YJ|xj)8X<wvZ~jo-cdGHD*!JR2T4<UoG*
zN$rfj6u&sxW?%SD51EJ=!zXK}sFxoAcygA>v)<Zh?#PlJ))43kHEBF1to;qp-Ylw9
zKS;1EUwNL>&2$S#Yg-uW{P0cuq;u)>dfHF-dfPkAAFpnHzY(Pob<y=p3OVJKiEiN{
zT#|TWs^!&>-6h{^v?|W02i{RszfTk*xEKB^KC=b!E)!9obH0)m?NH)ul3Ni<wC06`
zXN$e;O&m&ZLZEg>5tihu#gz=3$D8MIcVR28TupwCLrA8>SW_@67GhOM>%{ra+bawo
zPnAo5Ylnd4R{siD_vELL%BPC(|Ef5sTowuSd5?}QI>Td;`t@gHM#<Q;;Z=LVl@`8?
z(UKIq!>aJYCvSGE7W8D2B%J{8Q+f|oz*v%w=<lyH*zRd3LyR$$jio|W(MgXpr>Lsh
zrs-_mssq;~WGT0R^w^0nY9j!-zArB)md(OWwS-!_uI18*acaEYJPX?!y6*pGPGQp7
z{u~Q*s7j9dwahe1sG=~pX;I^x=g6E<qIlP46ANak5B~JKQDltj=;Y};+&_I#b>2Yy
zFbDun6+5T-{ggc1zD-?oLmn}C%Yi%vD%vJR>bkQl15P=@!bux@!=cFhFM)v9F0?&v
z7*~a&vORlC0|RH2KwZynZB=ANLT9dl+MW?}L)^c5g`z}<*lq>hxs+aAb@?l~WV6`j
zBNs5$coq3Q|AM4U8yXElVZ_Scv4#NcliGqz$iyr`@sTqg8@V`^0_Iwj^OhyU9x^c(
zNS1mN{UngC{cntgTsKKGZhfsPK<O9Cx?oNbjE7i{*dyAOx^{{)1hzjbt^)JZYJXsU
zw3wnt9O2e&6WO;N&bK{mMs)Y8dlH>&-^~`a{r-g?8XWyZ@%I&|?y^KnY`-_0ff+QD
zaj6831#w2yyq#Rr;lVON1j+0O?N{T>XIp*FO(P~$?f)7yuyZx7%y11!|KY2l@D3$;
zal1GC@@uftFkO5$P+jW8SU4cJmLrOoWjODFANx7QA+uTJRn9_6CVIkIqFP}F=sJ}_
zgRw&YYY7WVV^-7CLPid1PJoDmw_o)#corJ{3aZ<;-{WQ!juMCpQKG459-J=>6o%it
z2#Vrfx1L4r)kg;_P6Udbt(HEY;bf!GEK!14R$JnTIsd5`m|DdbEKWXaOVUpny;UjP
z4-QJR_-$N!o|h{LW@wz2_{>e7W$Au4snG*ja&5nd+>Ah1lj9m^;;|tn6H2f;jQL&$
zpJ(s`w-9h!mhM5&R|^_<S|r990InliI{P@c|1I+}xN~Y>dZO&T*|iMUPX+^(PL{Vx
zK_3pfyo|qp$`Ur-c*f>eJ40@@Tn&5)>F`EQThm^)gnd5|8*LfhbHcu5Sp@4xP<$Z8
z-?ivI5?moG5470Z&c})Xp}ORy!PVp@5NEF#PC*w#vtQ(Cj%%_d|ExLbs#m6r7>X;$
zg+t>MbWkzz^MS_%&+;rsvb7PN7)IXUu0Cz)#LL};mAa0{($k!a;Q<;iganTHv=XqN
zs*CR-!OR?IbAoSOey<Yur$nZs>f&tL;QFWqtDO#WrA(tv&^R8$gD@(}zSr%YJq|a-
z3H~UG3?*bByUI|uQ<YK?3jPHn^t6RIiex;GjGGR;n^wJ@O-4=l)3bD3Q}vB{42`W*
z7Lc0OQ}!v1w@#i6%(`1mp4^n%7)<{+v<ZJW9}o$#_N<d~#~jD>@9MFd;KtV<Rapp_
z$yd2|+nfM}?A;_R&~8^0#uW$89roFL_ZERYc<J7^X$i7=c<$b*Kzn)LOPe3oKm5t+
z#G}st-kcOanjlb9T~7DenpXUn&~2ysGq-4KR_|zH|54SI%Wt-XpR7J64qUvj<j;kK
zW3dm~1ve}lmVY|B4k*8_S6yu^Qb*77vTP#Ww4J?EZ+?3yGnhR+^91Di@y_Ao?z%TN
zN{L5L_Jt(BwflIE(Gz0t>Jc+(cDj2ip=IIZ@SiJ>pKNL{WWJg+uYbt2GaK}I`uip^
zTWg=aWVS5qIb+4$x!7KQnxsW5>peSrv{aK$Y1>sPOdtayw7=4{NVy;rz5x)S1yGzU
zF`rdCD`EG8Oy&)B{BxF`<Y@9wPIrhvryM|gmjVLYn?)-n)<o}eSk_yhBdIUca9s8O
z#}~E)DNN9zH8<8S4E`wG+4f0mw{+!t$w?e@3C|RAVKrZX_w~Z;L1;ZMAQfclS_ku=
zQOi7GiE&DSPWSx_($Z({53U%3f>m#d{e7OZ^ejiyb?4t_z5Shwn;l5;aTM|w&t#T2
zeG7%U)+xi??qy|3TMOuiXtu3niH=a!T`}t4A<=ae*q9wsRXiXK1-djNY>`^O0F}ui
zU{VOEy}2%nfhKiRlG*nAw5$HpCII>b;5J|3gL?XNcbxqWpb5CU5&EkjL&xoh`~VcG
z!G!$nfYkJE<qcs<8(j>v8;;%B26-)2x3NRe-fiq~*i9YrNzLZD`6u!&fUA8Z8rIur
zSv=_b9Ial4w9Z=+zv7`<QLRvBpjIGkm+6}xWkNRfot1FLobOsn($iNm_m<cXGBaX-
zqz*a1Ln$_##2wj*TyV#K9#VhbE%BR<(&xy10OKysRCrg&$l>RWz(8nZ55{S{z}=}O
z8b7q`>^OusF~(1zC7g`^7<uYkM*arV4*-&KVY$D)Qk~)=l<7l=oZN2;CN5YLe8I3*
zvGHYUtWNz;iyriG16OnqcN;J)3!e@*36;s`u7wXf$L&;28^A}!iN6@u|7fDqQ;z2I
zwWS%=@7g7wqIMAn)wA`%0-{s|<K!SnDx8UI`$3pW)tMyV`TL!uR}irsQd4;*d#0~|
z=~!x}suDy0+>FRnqp6C}{{C>5>Jo0<dPr*=VNPCID_atqYScP>z$x^eNo2l8Qygw^
z3dxMMjKFJ`4Z}A>O>PIFhI7;_Jile<TXcm(eL@ueTM1G>Wfh%oy~AE&5<p||(vvuy
zHpkcTc&UkUX0q;j{7;$l5bgQ{dlWPG7ewy)C}XSmV}3f{cH!01+N{a919pE-eVd&`
zGIQ)8UPQ41qT~n>i6O~&k>m?V+h;#DjJ<}Jee{aNJPzJ^05?d4ATLSbf`Zp>!`_u6
zhWXDa9a6Y<bjzfKI|lLiGvz?MgGz;i&dBn7;9ICVmI^v@-&tX@!eF#Q!4=*Z9;8+l
z^+T>*$$!YyTNu=0Z?Di-iI%P~P|Y}Zbycl0-sMEoGHi;BWy-eBNQidf>nfbd5+Y8g
zegrq1$kWg{!axm(eR=$B-(Lo5(rd5$eo640ssUq%|5Bn2TzP^nmEDk$YNnPK{X>09
z0URXRL6qTXs=1hG>Ia!j5~U=1&*}bBGmt&-!)#fawD*Gp?wuI>@mH0C=W=kcGkk~K
zzX}n_lL|Hwn&9^43>>31&HHbVWR&a`8`<UHAd@Ddfopgn(E#w)2F7rU|Jo59UH_{j
zT2>i@%F*+|3Q2f5O}u(erQBDhO2+CEFI?>%U2_tr_5tz$K8(M8Q1R~R05Nr$Ks+i#
z7>G_{D3{|iKQ$luVSZFV#ZAZ_dDx5&#@mT8Q4t^+DERQ})86v~K7V6qSW&7g*s6t?
z0H&j!&sb_!pKo=bc`hE(huCAmVFtQSho$z34WJ1j2OXG0NsIC&_-CSEd)w55Mziu|
zLH2`Q#}f<5gR93%MYYGOe8hsWO&+*lZ``r_$29IQJ#$B8*z5JFBaUp(VWLDtm|8)F
z!PN#AYtr8TK@&kLom}m^U)B0Rx})u<!ol=^K`Pl5@<+rx{$%_2O&N|c49jK}wOP@u
z_UHrYy?vE_h||5eFEsS8lW*=TK>tKf(W{?}2laP+FE3pF3RvB)xCF<mY6{t?j0m~?
zn!sZaoJ$7RQX~=ARZQyP-{(}0F&A7!AGzH>&%@vI|8?+>Q3M>UJkNLbXN0<@vbb_q
z^HT<$zYo?(CCc|76tPeEk(IE2*DFLY&eKVo@MpOi=Rtt%JM5vLt>LE4LO^3iTf2OH
zKyKJsHOpsZV-=TfcPL1or~wD6Zuh!zMyP*`;Jbnn$0`i!YAp$37sP@u95}J_winJI
zNR4U$NGpI9i#uU!Cy)vMMwoGXj;Ymoom1W~ks73G%~CC_Fy5+=`qYGm!vRE>+T?8)
zP10U436Skn(<ey~G)87q_UKb6c_d(9WQpB_6OFTsv1CaHr-=!t?d5JA)DKCQ+3qQj
zNy}Xeg%F=?F%kmXamSii%0IL-02H|WO!B?wCJc|!(PGqRwU*`pD&r(4SZAr+U|Un{
zV@i7sMD9s}_o>Ty?UzUWS?a*6{g$`<x~7I$PWtGLBWj(NVdmy{W+R<*A$0CPywa*f
zdh6OUXDO<m0fSeN>tyNkBLO%Kpd}P12eLxpgBM}D?M1a`0joig-R}Ym&lD|P_@;5L
z>c6R8oUfKUuq%vEeTB<f00YPiR`|O1FfKXB?Cqtl=i?N|k&*4SMv-`@sfv?!nZOm4
zRhU!;nT*g8+Eqh6lYZcGESR75`=oqMgB9WqY)}}~&#5Ytq|{#xQycZe{hsElc3i_x
zUmftfw(f_!0QWC{yF46-?%><>bf`_YhbB!0Z)@F^&c!!o6=QbDZEK2A3u<>GMqIic
zmhZ*QlXkBT$bd=88=+z2FP|1fN#1;rdp@MPbm3uTKiih7p0I(BX{|op`oVHGP}X|6
zWF9+A+WR{Q-N}R(&#1j@@9hiPtm~A@Ts2&ri8rGbjN%oo$u%}XIB<*a_xs;g&%FE^
zWzsQqB89aJ*IR!eB3E8dT~$&2gTKf0hT8l$R3B4y*GQezokO0PC(n9G!8g=;DsI-Z
zrJ90X|Bs$XmXr>&y-gbXV84rVbAJmS<ywHhxfxSc`ssaH=-pg_n!&lT-|f4yvo5GJ
zo6mi#blbdpQ27lPVgoK+o}NUxn;|g6+S)qO)8&+>bCQcV<e6Xi5#pTof%-+FRPnhV
zlYF#wI~oPzrI8;#%+<VmPCYKj<hkqv!MM+k3WFt=#{<gtS4fI26$ZADwvU^n{tjGU
zP{ZW-6Pb9~D7>6>P|=S^-@w}#)jCu}6aWDRdVmUW3rvInFd+be!2vo903b3Ft_K_|
z1ZgM@moln{I?gFhT8`q|Sk;|_BWFzXc!YMcG$m6f!sFCkSYqi-WzP4mzbLgl^>w26
zUhV#jZP}449UtBc_@uV?|H--1sBS0g*&zp%HXj$bo^Mb8cC?XAsc=-;TUb6w9^z%G
zmmCQ9t-=d_#s?HczkQUj^7VcHgC8%8cX~)Xmi~6lP5`bssHgn=C|$tqu6X$H#WmwB
zvA+?b;yBm4j6Uc`SMgI}pPmw&V~)INZC-f8Q&CFU@XjE53V$AEy-E$BpRe!xE$w?^
zWM{nacgmx;zZQrO8bcr%-SHovh76t@HBvHp^zxg1)g__Y{wI$UUx|w3t-LYHZ1)HK
z%L>^luKMrxKkYZSk`r<LD<uta3TAU_GX6<bAi4ZVh9PW{g>uxLI&x2BQ0zb(s>aa<
zL<ke}6U>E_61jwCDo{Ka+#Qg{2lo;^4f5dTA9PulG=j~2Qt(|-rkN_i`#5j@Zw1_&
z-qQ!p(Dqma<R3d&=e|w%I=e?p7@sKO9y;@7uE?lH4$w?R$8k-;iod6Q+ea+8I$@&x
zY`dn%UeE2`!JGQ+B!&bYVcpn#)Sd)-`Wti6jP3IHn)M?8Drk+S@`()3BurJU;>|DD
z%L@M#5*vJd9MM@zmoraS(-ru8NJsANw{@=($`B3W4}S^(qAW)dM%STyDGQA=T7$N4
zYy_W8uQ-OiI6d{>ui0Ago*l{wWQV=qIK9W}zumvJN8f#CvVXh7?tiqElpsOlm+P2r
zY^pY}2z5W+bo2yku;hLZ1;reP&E{;AN+emUiSP0I0I?5R*D1m)&|;#b-JzvUjL&14
zLa=x~lGHsrvtQ*zU|j^zPc_XsJ;6oOF?XNkamy!gBhOB*Z%KFek;EylZCl}H6V`HX
zG)2roSeBvRLC0!Mir0qIn^z<!!(SuPiMvq-V5_(>BZ@+>!su7qV`Fv$;pphcO`2Xi
zU0-B=%h{E^q|D#7(WeXyda*)Lm3{NVurJk4`}AU)3U3ztnc~Q2E)$D2<6p`Ft4c&o
zjR$$@8v1r`e)d0+3lq_t@$JT#2SVMU2VaU8oY|f3qxt4^(&5suW~BMI>cxi7w>OKt
zb!N>&Iao8-vacI52~EUt6O;<}UA+>%Z*gW!7y4^ljbt>__K19A`Td(JhDGM(HPrFe
zzw7f(zHi9>y!=C^*L`x`Y?rX#4sd=;YIenSz%Zg#$r*|si=I%+MGYV^5BwFXj#=Xw
zop)1~$b<eTzr$JF(W+GXaKvX7Ske;fjt93IJa|a}%YgmebQ<Ux)}BdsKMpE(QUy;*
z+2XmlE(I~&C#V84Y@4lZ{IFMeSFA(794~cZDb=oyK{4~~)j=v(T*R0;EL};>kc3po
zJxC}z-mnu0^A$TV*j@pYk)^h~x?hDqkWiNRpV;5-23-aE*~c0C&l6!^=kHphQo-s%
z0(6*mcK3JRdY2}_TcwrmE=TL1+TKwL%A>5}Sl*OT%aW6gZq3tB%VRNT*1GI&;Zc-8
zfpJJ=nx09B)I}&uvrT<WY!3*15zaKoy;WLu#Dsh3NJf4R{5ql6KFyIheT=sbR_z%y
zNC{^k&cG<x=eueQrSk1Bz3P>})B7SOX{B@$UTfLy{4%a&rEK1{*7{BF%QLMjSC%qs
zZ9Y2>B)wa?y7s)*_D`>H;KIhrH9)G4DCRQAR9Y?nIWb9|Ag1k&xrxjpUMDo;(w^g2
zD`%h25tZ;#3B+S6*9V#F$;@<?-;B}=T}NFPC&hl)0mOJ<hFv^osDvq#>*7*me>KkL
zYV{6_-gPI-!SMV~P*c=8>ae@k@mJR+4zMNb*~X%=A|}4Us@Zs!(fQ%)0JQ_tTKvlH
z@zC%>Y@@`&a<^s^jgx?NtaQs-IIz2z8@SYq+Vj4b=G(=O_U*1THNL4KAEdG`%FOC1
zw?3F<WtlSHVN5YR;_Nb);|ML6Y2-tkVI)bXc(xs2*-2<YXWGzFa;a}Sh&TBKVn)B4
zaqJQ@j+6rk*)!>X7Et#c+c6|4PDRM+3a~!2BO|^`;hHm5&DIj0^Ln2I@t|Q;?Il}%
z1QhX-=V*=1M-V4!Qn0xlcR$67SPk{MS=^$AbvjB#U_~#evh(d=#wZt}w#LYdli#<0
zZ75z&xOe<JH`kIxLNvvcz$Y&I0)h3}?pn6_z>@9DWzufnG^GG5%5G+a=HH|>nkS}5
z-Uf6j2zaBmN?+LDS^|&k6c9eZ1j=&`c}eHJaqIR}qks5%q|prF53PPYW_?QC>6<eO
z-zOW9t6Z4{uUqFjCd$~<Pi^$I3;B++8Nrv5TSi%339;MPbnyLzt_nxDQ|<O;+!0KL
zFm;J<xWBbE!_8nDSSO9|h2P3*u!lAor+3*k{UPmGWS}lpIK*AQ^~q63ve%XM(&U!L
z@wS_2^?6<?ah8a*3Vx`N4Cfa;EY3c^IyO}I!AmZ(R(c0Ocx4d(iVWKYXD3f#(|Yrh
z4l5a|TT4r)iM!oQlhQ6bwj|#GKs;J#nG^A+4c7Mh0|>bsyHz~4a>sW{Nl2+^h7vn8
z9J*JAlyk9(+}i2(fLpF#^6k4od5oSG^o+Ex_Xz>Gvo;$tIi-B~0ENSNq73tkRfyyK
zr&@UML5J3C*P^8$wbC>-vmboTa_?STe~VL03rQ>pRj)C;=CpIZBSW0U%X%%`ZkzhY
zTPi$tQ;ORI)kH9kkI_M)89#g4NV+1HxDIqKoptT7+iIoq-+Ai(*5RU;tJin`{o<a}
zI#TQQ>t?{;uf7AVqYqyGx_$2NLf}d3otFzmtw#dRx;Hqpezul0LSp9C{LCGawv&`o
zu9Qn5C*-$-Jg!%3bQm;c5X+4-U3q_ZvO~+|@33EG7)b9*{DW+EWHvs|(fyfLz3~3;
zmwrYkqeFZ>jn{3GEzqr2^w!<`**v(5-thiA9HJKG{WR%H|A$|TMn~VBzEko75`X@#
z2+?XfMACxZj&2LI^6OYe#(9A;&nDe%N6q9y0#N>FD3V$@sx-N`cXL9_MYyX$t-;|K
zVI_UFjVOO#`_R%8gPOB(fX%{xk6YSaSl!v2+L0$5>uD?c>tp^$UXS(%6(_IoHSO%%
zb}8W!Vx(!GM|*OQwBbJ<5)+EaqD%G>-~zn(^;fWF0?d=I@eT*y!9+R6!kWwBT}zUU
zOHPmqk!%9|0}Y;4Mfy^dD6^a(UXhpqJ@NMJ1sf1UX^Q3S$j+=iRU*a~pWhE#Q@HJg
z^5KQ?{>aqmNcGF8jmQxE%PBFZ!T><GC@5(KCkETjO{zM%yo`X5M92Tr{s$aw5pxw<
zIPjbH-f~o$A)mEcW;4mQ@EM#$>^Ve;<;gc}pvFC#kKqPNGzc-sH(Xl(A0$i;2%l75
zc0UCy!ACt1T_`w_>@88C{mMK21)V9tp%!THHiFs`4s{UabOi1FFqbwfuQfizlBz{b
zrCqu|bLno4jKmyD0K+(rCA1b_a(#7)ldykO1eQt)Pb2LO^+;OcNw!UHKZ%G#h9s67
z;m1EK2Pvotr7?%6q)fJjDO?C;(&QUX<~mK`DGe1wu--U(a`B8qThYb8Z+wdxxYJab
zQ7ua@7(-9UX_Gf>5JQ9BX0Bi|IXLTk_F}0##Hhz9G|a0~#s)%?UF3^Mki2VO;adYS
zZGjQ6WyKZxu@m>4HS?7(x{F2-MJveR)bK=WVO_%Sd+fLD3w!)z+KV&obuW<h5_{HI
zc77ME=DDk8Tu`7G2Q5jM^7}_T?>&!v(}GB2h;OKiD9>Dg<Yr9!DvlGSGwvf`_#M4k
zDBl$XY|4W}%6^E}{AZcwozLBrwmnF-OzJr&`A|2(&q2fdET|{qoT8qXGkvqWU=dRQ
zLYb(`83t6?=W_x%T<kL6Gm&Rpz(t+c$e8fPG*5;BL{a4#6UdP15&-y=$8Hi4+w$TR
zP&yx8(2~NogUOM5Ge0>gk3J|?nJTvSD|psY;1WVbv}b1eoXC9Z<|b~e9AbkyATnHK
zQ~iJf1|7x3!;+`7zznf$<HACrF@@y_jpOV5)j&n_@yJf8f0I&>wF}U<2V&0BS?f8K
zc+N$1@gGa+^vh{9`D>@f%J$tTyOxVQM?l$PfV?#sX<d}^Ph}=WOpL9)EtQp9B-hT!
zCO09!0l*;|F;o`tr|k%9(qV(O99jzGH48S#Y{!<$qS~^E+A_lpv_+D1cT3eX=kmp-
zBwI7@?P(o@+PO@KwF3b@^GP?<)x2pU%K6A_8mu3WS`9>%i^woj3*)5KuA*S?_&T4o
zQOrP<MF2)|hbGYAVj9I0GW3)K-1AoD`+d)uk<Q%_D@(SDuZcaEHJx^DzG@}@QmHQL
zP684PVtF*$Z3neUot%<#WtazAp%#`Dg+x(_S=p1uC2C5*h$V_!jEth90$TJ}$}^OP
zF13hfy4GdhYBg)KQfl0|*(r|haIU+jUzMa^H(QXSg%^>FsIl-p|2;9o7<6@!RJn{t
zy}^kUHY1||pkdX;c*t=EC*#TW1-DBvaBzJm%j*O+NTbvhaXQPd2<CiNO1*eM(OG=@
zcE-a~vh8W>J-4^S>mK**2e_ioC@`wOoU<YjzIw-6M<g^*EFw^O?0U3hBkT;3cWKyl
z2foZ|+losib*)t@))$zS+zFHy9S;=06lC2*Q?Nd`|7=3-!q-L)OiWn@`Hlyl4^;WE
z{rQCPjbP_SgL7vCiLx=K-U^rZOZ6(Iw%mIG189@5MxtbeyRPGAle==W=k8{&fM)M=
z&Az40{*Rguo!hVS$S^w)&KYbD9Y23j19gYy`G!V_JSR0e=@+tmqgoT5#;b3C7*yqb
zKWV`tzv#+CW0YQ6iAQb*B1j_BOlFRUWZ!>~Sx-pRM_nz4=RJa-m%09L>4x1DmP?Qj
z(Caq&;T9xOF5sIL(E7VplQUxcZ&EZgHzSN<pKJm<6WQ9Ntb(qR7K??Y8Q<_&maQ!@
z&&I<}3q-Qq;S=TXLU#+}SXc{6w~Z)y1&7MwHSK*=E?&`;N`zKA_`3x>`mjTKOjwJK
zn6&*sJ7YK13JD5aCyHV{L<L2tep;drAQiK!9M)v;8huOUi)<~}YndqaQJF7lRV(fx
za@ZsF?9?L=U*yajvWu&zwW08gE{Tj+2jyS=76@<WVXNMWca&p<JUGHbF(gE4n5Lj^
zz}MeGefonkx`)ho*ZO-icr#GSo2Wc;5BVk0=v698yjH3P0-RXM5D$`C$E9sXs;F98
zth?9j*y@ycct!#Q%SKBjZjTNcSO&y(VRk~E*a;e?pMfwLvRFs?eXrY#FX|8{b>!ca
z6fQk+x9L_YWsU7ZR_~T$KN3sB!Ig@T*AGIM^Wt35h9E-nvDbM{!XT;5@~77MVPl?>
zsxI9H*gFtVlyFe|UVzM#N9c5#!oxu8I!tM`4PwGwB#5tb!W7jvQz-7C5M^`wu{J8e
zzqcUsJiG_t!|OF;Jb{pq>$r@+mC+|jV#+H~5$*vL8<b;aXHJ<lh=1e0O?Uk#W8@+F
zo(euVNGy$!0&soRLeeNak!1DT-tIM3_n&Fl^xrcHf3?-N&odFfg5;riyK^&E%SB@b
zVdhXQc<S)!5wU>#V$aGW@8%(^mc%A_#+ys6;P##|qG$v^oLOU?zxA?t@42;R@g3uj
z;=~oli2Eo@H&*C%AC-U_ebfqFbNOdqj49)k;AL~>P?In+>fh8|5D&H`68$t+c?E@N
zr<pkrB;v}#EMUOEC#my;hb}F^_1;*dFC*Vc=&$3t%?`IhqZ%XVutdHmJ74rPs^Mg+
zj?dvy8M5eDx%ft~2=hL2;Mgeby<Rk5hdU3S3sjh*$Hcb1NtG5AtMcm0?M~h^b_fha
zqr`dcl2>?#*zd=(|Bi80-sbIjTX6Vo;rX}4hTJVh!`x;=;ln)x;>CXZRPPkMrM~JI
ztrWkrAa$$M@aVYpt}L0l^Q!lv-?_)%hqg-~KuA=iZpy>mzcOT6qE!Xa<7Ccm2jKY(
z4i?8fM1P}aoN*@IN#^`H)z{Gz)D^WjnnF1aby*m4<;u^uUs$)bJ>CJqAIA1j6+=Zf
zc}Ts*fbn@H6Dq5lD=t0+YodqS+?DEZ7u#QbKD(gGutKXFGI{;pCBc{CceOWP*iU}R
zG80*+ZR4hKfY~xnHd<b^w(!bDlc{(N8SHHdI>L<*<9^bZ_IP|s_iE8jGdhB)_jqga
zHj65rD`pl&mV2z^P4qs}D4CE?>-eeM)u9t-`TonP_aP*z%Y}lw2Qrm+%y=+9fJwAn
zn((nq`CJ*bcM_t?AyTlRojD)^I3(bLVwb<>oJVZYnKZhT;FI>h>61sKOQq&)bL%e=
zkf=Y%|M*ItgBF_rO!~0sN_&mquDvD(;0f>VyYt@qq0-z3Q2lc91&Nf_oU5dxnv?N}
zsmdYI1XbWVV3d{%i|$UfTToCp$&NQgonTpPtdGy^Y3g|Y^|HF{J;b@ou^0avuDyNr
zi$|_XA77`QfVt1bYTQ)xM%COEFTJaXIMGVH`7he-LzNol{oRJj|6Z0oKJhJ`J^MI&
zu4WmrNP?O)R&18PNd^I-2Nw-&v)@1fN&$EFFX_~WG_Hx|Q>oftZVOfKzkM~7YYvkd
zt28cZRrDM*{WI9sJhk}Yne|}hJyrIXk3rOSg(};zCBvlHE!DYHQ+thf;*Tc0Lt2%n
zS~_$BCNhbzXiGV(A@fASp7vxxT)Os{@TFPW<=VSO9~7VJw%q#+MkDX+PAUNbH6_T}
zn=J%rgkz(%ZusnHR{q~72^sNa{~b$onp(0#I?wNe^4tTSmhF5me;YD|9OtjRlGqC(
zB95=Ms8xI1Jie0b$AN$O{RlJTBSi0RKn2oa#VBzzd1X(oX!;WGRmU0qR)@1WbEDP!
z(g!Z}`2ESYyF(DJWe>3Oj;`NrPb<8({=00w?Bn`X;d;5+My1_G_0bJ&bQMNx3{c+I
zMQ^kjefxY*B*tA#qh4MX2?UkGvX08c2D%3DM4pYjyN+CcBu^k{9k7lswjn_eElDO^
zP*`>^-NRT(pAl_xPfDFaPI1e9g%`LYQ?@aFP3A*<F75I^?p49jvfI`_C4wZL-`MxJ
zGWVg!CJ5(3*!RA<b+_voqTnYIFdlFNm?BcDlw$WO(srbcrUAJ8(38`El2K<1Vf4vG
z#!p)Ee;%{cJgt3KDVIIxTnY^jKVd5#xK7=UkQr%8Hzmr(fwuMy$LU^udNKBxQ50ox
zymChz?y_~l^J}|`t#giaMZ_I!agXNoBsvy&d#89K-x<tsp6>%pH2$v0i%A{Y8~W`-
zSE<jBBTvqUST`vI4m|-%BzA2)_~CQp5ELC`@EfW8oa4E5B<2K~hcQnt4RRdgnFL;D
z|NQ$ZZmtPG*l_r1s!G6_*JU7K;9p5zP2hj8zWp>pEG1NoL?4q>-AMW7&m&t%`d7a0
zmZ%IIuX}6KQj=>O)2F|uEbDSKz4ScCzH2YL=Xc~p;cKSXpof9~D*CnN&$562Hk#Nn
zBiXxu@HOhPE`Gw-sa%|e-64sou?ZcQ9W}y>lee~2IlX^Y`yM=ElhY9FdDyYycrfR9
zu{6s$0~Z7{oiEat&_AvgROrFUJZ0&+s1|0B&)o^MD5R0AmcT#@kd#@Ai%fc6tN21f
zLd-?iPJ`;CYPHc=zN17hwfxA{A$6+h0LApho4AfU+Dx1FEL52;K7#bPNuj$o`N+c#
zoD*$D+=wWE1DK0o>Sy79-lJ9{`OKe(hSiSO8B--=CQU?(&T{-IFCJxti{3u68aH$G
z;^>eFCa7uodig%KqW0B`G@Ec)-=M5aU3<eWuLEv-M0WWGrR{Msd!er0gXpMR2h+*P
zGrB0v*SOm5*ncdILjR29TDj;DD=6JCIY2Dyen*0s!wxVoS*G<l5sqOwP7xHCPnM2f
zi{xB!&Ikhc=#*^zv^ThR2z;QY<a}9gUGb}qbtW!prO^UN{xxS2l4bEpLFayiWT0Z@
zcg35yi=xg*fWTg^b@PPvIqTmX3)_L5@IP^>{9y7s*5io3vFvhZlvbT$<xi@{7yY5B
zv6`c_N5>r7CUFr$)u2gV-4Z|J;FP-4W4b-_7rEXWYS&90cSkpCVYB$bp)YjQ!mxkE
z79Z`(XDMg@tk498GIKL=A%@#Ucy@66bv5U)26PFt8fPDI=GMgKVDtWr6hY+Z+=60u
zVW)N;`&N1!-pTEf4w9w)QQ4(`XWE`KZ~ts0OaiyYSX{+!=5h@8G(N(lEHqWoE)l{P
zlv^h&)m&FUtw+_-^Z%z)7JKW#Rppn*kJd@I#5_2>Q(a$N$Nl21scGDa`))8)lBH{B
z`Iq#Le;ct)pKUMx{c}9MW4nOU>E&YFEvHzD#DD3o_29{;la!r$LQ4weWp0i~W4#IV
zA;x0OLfT|dL#Q@4+2OFIo<cO3IloEF$(JicS@OOoi1tp3hFOx8jH>rZFgh#F6q;C|
zXBDw`?cIC}bGCTBG1(#VfWoJoU1Qb$gDbu-FXY~tdyT@k<0Mp{-IK@7X(E1<W|Ep5
zcd+PF#|Ozhm_Hs4JMIr<MQFSLiz@&oW?*=sGjtDl5P^I@C)+}2g)24YB<l|1>nBkL
z1|~4ywQr`Ibt1s6!5)ADIW`C5@7y(mVs7D$m&RCO8-baGVRz+pV+szA=Xhx&cM5c!
zbUJX(_B5)J82-I^UwNu6dR8g@vKZd`avwwCdwvC+ue*2M@z^fYebLNgFMUa<I35eP
zDhy`>-=rPm1FLkPLHneq2CISRWbY*$6+7sMYUzX^9G>SJRr;YU4}P;hc2B(;HJrT^
zrloi~BTcnvwvT!1jvHKqQ~p&`H}Z+I`%25_w`Eoy8MgDj@`gPKNoKZP_$#AuvmR?D
zkmgem4*A_*dJhi@SS&`K9CsHu0PatyN|&lZ3L;kiX;QAfvC0xRU`G&*QU_!;RV#>8
zQ~z3cRm_RK(p@*)5<6dIc)z~cm|p2r1Bg*9)un$d_RFCd+lZz*(sQ>YdOHb+NS`t|
z#D}P=r=qq(*-{+t!ofdxMXY8)sMwYpuHQ?1+T=!gX%11rvX6Y9?HX;&Nr@7MYVG#x
z^B%oh)D?Bi{E^?wGo$yeiA0Ax?Diin9Bry~h>ke;$ba<yX!D(v=%}#W0okwJ@cw+I
z@E&5CSxcv7mZ81!*Z;%Qz4$Zz{_*4AW|;Gw=e*4@=R*!7v6C}7L^<Rzhn$jQMUmNt
zIUkF3a;lI-<WLlI7IMm4lAKeioDzlo_W6Flx8HxT+xFV7UDx$|+#k6qov(ZN0#+HK
zLnR(3Wd0Kz^wbD@m?1hMjhCE(u|J0}I6R!w;0G{H+^@Z4&pE&F-31PJ$0%IC21D}4
zx}ee7hK?f0vTl}TPq4}b#ec_aZ~or9L=M2yw4^KGL-kg;sI8Zj6>8R%JcbSrz7zoV
zlPi?u8j#E|OJ?+TYR9pkha_>f_JHgVd;N49H6O88VCYuRCv74DdM2|%m=*Gpsi(=b
zt0A=)u{~m$Lg{xvm%Qa~H~7gjBQvoV5xga2k8qL`S9T|kPg-L3cGaPPs$W~L_t`-e
zx)5K~K3mtRb`oF~3w^Z29@|>2il-MX%AURgBjO}%LBJw)5uipYcJltw_!m>^hcQJ%
z;t7BtSxJW45gqf;{Ks>ieY-)pSQ@W>=4B`Wyev7p-kV@q!sQAshh(g?8<YY&hJv~T
zyEpr^wUV?h%p$czQ@EtJBLyh66=+B>Sffxo)2qif5{!6J?f5h#SMlFewbySP<rFLB
zStr;~yoQ4~X58n%{@2b=ewGsx6jiVydEs=#?q*~1{Rl(N3^=#phQk*?4++NbDSS@@
zJ`uA*z{o0eEr|0|rZ+ss>g#hZiHU|WfaPF?p7A}?-Gh7;%(D0Gi{^j1%h|)#3el34
zYo^?<$6}J>S12lR0L;&=#GnXRvOcRnsEnoH9*Rq7UL6&8lCU0hy;Bj#fx})CSDjkN
zHndiwxcg7T5?X~@N&PB5N&It}OZlJgy?;IJmVEZ80`{{0f{D9xH%4t)a@CUe<h4iQ
z?~W>@dm(*B+*TFSw@=A^=OvHZ`(15sIr<U#;G}eC5OngeLc_?y*edGzvlDVFinMFy
zk%JVD7}q*!vW7##oT$LxF^X92ILPQDE~UA!tK=727_hw}a1BO*+?$cl5_o6@pe^dc
z>J|}3nS6q)%!i^xH}l&ds6;Mjsby{8$YcT`ce%v`Fr+l_D^MYRNqFS}b08W}xFrw^
zG2Qy?O%IYBna}5@!l%X<-9NV3d4L;onmsWKD`;y*Ed`4>u-Kk`QJDuS)!_5w;6I>x
zBB_xxsh5K){vXPPmEq{(xwy}HWvmsTm6G643Mhs%kr11i)Rc+Nf8RO<P!Lv*iPDN?
zPiN!js?ZuJIs(0cIn$#FT3_G-09Zz1eadblt^+_e!YGtO?@8TloXrK#<=&#W>Lyl!
z9|X7NG=Th*QjM(8<pZ4DjY#FrWbJMq<<{IjG`&dmbx4;Gh0dVB2~-S0bC;8;RhxTD
zl@8eD3{GM%_tB8(Ay7+M(xKrdfPDWi=k6W(jv$C~{fqd0WgZ=!uEokCF0wC@zH-26
z9|W<TsB8w3Rkdy=z&SU*62m(g`rN7UaHUrR)XDWbY<Eslsst5q^s~0~Gl!|p{*5lY
z<edG~pj=Q5q1<@a%p2eG63^y_NToNZ%k|`_45m)80jkjtSTe!lx(J13plzl0J9H$%
zj9?{gwdGYmc2d2NJfC(_&!Qp5`>ht^eaW%+X>g0^%$^uENC=$UV<&b0px0a4l;)Nh
z@A~TC%$r&mU+@AwwVwX?cB(`h+yD-tg+Ofna_adMan-<SrMk>(ooty=kC50@wjLg%
z1qf{-KcN#vDIG}03<`1$s(ld5*QJ|~g}}oW5>1p!95uUuL)Wt8a16d7Ps8n7;bXO)
zkKMuya9PC4<-X$j8k&4Zi<S!^m-3KZt3b+H4ONwW_s5cF2PJTD-YWnw5)CrOq{vqw
z{^yASa=%CS);jPd4scpvXetQqYp`M^cSt*t-jeyYO+@6CF5MfMe({dgW<k+(m(g^r
z`5#qCdt-*YM`~y;dN>+luvwZ2L5m<D2IyWE7=0CHU^7>l8bo)TxpN(x8^JShh&y==
zk{U{G_*RX5)yb~vmg<k;)A2Fub%nUv(q}K;V}2aAqhe^2rJSGCY&WSL)GFb^MUHYU
zNIACp)q3(nReDSW?QWNVu`8xESE`sqz0GxBQH5?(mK?`OlRQ%uR!Y0E^q_vd-WNN1
z(u$*Xll98jdS*CZX}?Qee@7dm{Jkh~IA#9|0nz9zTq(reae6bplA(#AosIxocC!6q
zT@jU1am7#84?rges3zr4Pz1WJEBK^?jRA$tBG-Y{n%LpMCOncZe#$X<fIYiYkG*$X
zx}(M#lO-@YF2_EhAH@-{kTQu)72}&gxj6ka<SR#WZn;mOZ%#D1{U5Ik+OPb6LVa~Y
z<M)In`=plWq_)DOj^5-6vq@c-Gfc=bDj7PCz6oOO_1~YLG*ag})B=arbDXI<L99;+
z1x%T;Ppuw0+Om#RSxi}}=E(r(UU@b@G{iy}eg@D=nc=i#cT%qBppiLv!lvv!>9|<V
z<eIK#RwnTv)d$Mq;^Gp2=%_u}g>hhGw?;U;aG}AId+Jk=UkPvGZaYa6Wu6LM!HzaS
z$l)*F`>V6gaXAXhaQ84SiIyW$l?Ku;SiV=WuBBa~gG|8hvr3DEA1Wa05l&(*b=MCr
zeUlc1pa;1c@gGk6_j2{ww4BKjX<bM$V+Fo`n-RBD=c8x@Lyp$mrr0Cr`#gXL!gssp
zgm|Xvr1?@Nb3s~IEb~%*$7Nkt56^ZV-S;Z4s)SA2l05q#wc$khOszrAlW4Y9a#tq%
z`vjEo9egEVljFunch-JtFfT{oB7_m+=8!P0ZjJmBB>H{W@mIs$7<7RHIYaT#&Er$I
z39n_%Cg<Rt!KEHP2omCl;lstcdn8PUs6+G@^csi9Ra}+a$0;(wscJ{Fy6PZ3IGbK;
zVW0!+CllfU;pnthw4F_Ta_FdQ&0%#-az6f}Q8IUO4Iax=5jQg}!#kmixpUd|aZK*>
zZkI`041GFJ%vPNqr^S));s6MurkzaHg_sTNozb^4;O8UTM$k+mKEl;mA#$(<8T<bI
zr%$V&=6`=;erBIv5S?FCm|xPHUpAXxahYEYm|wd*|0Q{T{ic^(q2(vZx`KtFn`8C)
z1M}S!>hr%Kb@Y?SlbQbe0@Qsk3&`iKd-I0}PunrHpw7BG&mm}4NVv~{2AHf_H99$y
zdVPUIkOASa^URMugNhz&O7q?@N*CYKBredKc>%HTURuP0IoT&K^z&Oc_KWo#0vwA1
zvL|0bsNZ?|*0<a!<Wva-p441yj=aD}(rpi;j5upZnH~Ml2)*{Xo4xX)QSgb|SZ&cA
z&Q2GLDiu0Hu>m>1@FJ39-G9`*GedmmGc92Txmg+s1shs&lyzkwEz{#!mFERCN9clW
zH-x!;G9xt^;_jhoFbY%oDJYl4#Zczf!}bb>(cbDoPTqQNd}*oa155hkz$^N99B__w
z@VF*(*w%DWa@oo;vMVbMK#J^BnOP%w{>+(qo6t{B*8OjgR-&{TE1=+3NZG9}<9tj&
zqGdp$>ngTRy^)?7-`ZV^p#?y|%5-;NGbLe$(|v0eFhkRrGtZ2IbaGV~=z&T53l1kC
zw)A8yoI<pG5jenJtPDCwec|WeANCpzym41w=8HpS1!OQFIBm9q%!dE=!dsqhR+ZyU
zPTo<cU-2@EEC^`&z#FlY8+LK=4#a~R!68t<2F^_73tJ3UOI@v&F`O~Dk~_`x5KIZ)
zZTVGQ;Dau|*xr`x{(APL;Er;4(BERoJ#<brX*>ZcsV0^oPxlE*F)=d0A><Dtzj9}M
zP54=iAyAchIiGZJZ}FT98)9=iknS4DK(>Nx|8icVCnI55mT+F?Y9392{`f8D6`y3+
zpuwU%IMp@9PC-d^Gi4H;;<@=EAt*26XCT$Vj~o+fbF#pEna7rV5_SS}Z|#0Ff)YlT
z+J2Fd!!=7?m&6Kk+`P|qCwI;gk-AouroU<Il+F3BLSVX;QU>d|1E&stHBn+@U56As
zRy8~WPxo%+(!ylfJ)8zpAK85GqM(C|yB6W3;5RV&j%m5+n@eA=|6tbES9?uAGAri9
zE<zr6@Qm+Me9<*l#9RKi-bnnTPP!&bP?IMk9!heN#k#=hK8-y9TAMmGa^VtB`3pPM
zz?avW*!c4=@9|716XtHo_z8l~L~`t0TGZ$I2o9w#vS7`1c3kB9f1_MRrL&1-T9yXh
z;5O^I0N(?EU;4aGjNky)P?A1~WQrBW*Jol>@7qt4^xeYrs(-w8eNd7TKGVgeT$LYN
ze1>0q!0&^zRR{eC51Ca-<<Z@#`MOG_b8E>*Tp7E3(5;+ZMde|zWxJkEkH@HD_%^vy
zPq*I>EDS~DgbvCt$np!ky!1=dDDp#frs)UHIIDBtgf7NN<uL6QA0MJYTyvaIg`HZb
zK9e@Cz~L1Dyx*)Ui%8~Kj78@EXf64{+6A@D^RF%$_UTGQzHa@YQFQOlIwrPQ5c-*C
zK?8E?IY<6CO%z|qX&tfP)?7YKO5&YV{0hpmU{hje_vMEX8zRJWKlS>6W%P|1AN6Vw
zf1nTP*XxLI^CFoH*w2i{@aI*ad$!c<3XVJR5cY30)d(>+x7R?GAqtsRIk$ceHcZz7
z$I|R8RYC4>ZtC^>FTa&xF?{t+kmtra`N!(vx?i!Wxg>i@Ka0H%SGiD2N&D5`+2eMK
zCNa-_+-npe**<*B*{M!yuC-{2cR6Hm_jAO-mOiwKIgC=mkgKedQzOqr-BF=CV))27
zXwKo*cs$0INN>g!BtE{I2zlJ@0F#aT6(3$Q-wn>{=dmX*uAu~6p;e*J*?W#NzHMm5
z42(AW@SI#9jpth0jF-9C>R57=>bmYFd8aij!o5z!qXhT0>E$&@!vTMHTt_aURV%Xi
zbFn_Au#CC#AAs7BP9rS%wJ%U0VPNjwt0N9nUY8&WfNC^A{h)TBtV!3k1jDjq3(lqa
zDE(7@c<>==tC0SqCp8`;6j;znEX_WAD}L+4>&YAahoefjqD|6z{~V4h9ZeV<O<EjH
zojZCTcr<<WNMaUbP{sDUX8XUEBhE-R_gq8fKi<?t{|w^}4wK&pAC+!&RI#HE=6pe9
zi>#?Z&Eqd$GM=udKZCqX)H;hJYr>~V>tAljeBpi9BNX+J!z<zYPXp#ZjT{A>z=g|a
zPxNo^q$b{k@gae*PJV!O4)f47{VqUM8%PI$*Z^?Qf;)h9zsq}ZeG}0`7gBPn4cbEX
zWl9=EZLDv}59A^(^3{U3QA33)=bm5W!VbM9F+oK63FrmEP++zwX=Yn#tQ4Orq#m-1
zo~X1g(iw4$SbUavT<6kY7_o>;<mS`=@$I+jOucV^zIx~$deoIQ4BAMU{DKW(W-l6t
z{$Z6tUHh~B<H=Q$LQ)u?Mw8KI$ysJ?%8|~cjeYHvf&39M1VPi=P$QgmWvbtz^kuNz
zqCg|;ukJUW<KsnyD-5~xG{SMRF6^KF&pGuMM;`;xxd_}F4^DXbqfE(5%+hK^g}K4*
z`o!ZiEvGK&T}fija-l@AHO@bd`CT-_kB$HCdbT|MajNl;QBsNQOU}w;ljFm`e-iJi
zJ8a<(xiIh~cF9;cg-fLsPUSP&htmYDF^FVQ_gF-VL`W+lRp#10f{sYXAk!2|Vv*^}
zHLb`D^*S_%xz<a|!psx1Rpk=VbEH0^@4oA-R1sRoC;Q}m-F}6f&EgelsZ*5UTnojv
z6?wb)*Z{}qIZ*cX1Nw3*f$3X}=u@Axl~;5Kg*elT!?uej)c;L2KDc%MXXA8{f?&Zr
z(;PHINlU6tUdj6U-oY2sB;U3mhjt(F`=)>Av~zQOMJ95vexQI=rJHAKCe)a%jSngo
zNJ`39Wq;4m<(x*I=V6$|)cl&-mqX|}^=jWyrD%F2=Lz6S^joZ79Vz>I5a_+fV?U!O
z6Y2+<HJ|G`H~<^&J=rmX_oCY)zbHs`Yz;`EBmd>JEUdlMu(_#!U|$b(w$7}^k2JVH
zHhnJgtqDBOqiL0F*<0c4sH0GC3jXJ(^@^`xMX~r_6*9LtJ;qSj<}8O+zx&9vrFKq_
ze*vFXdc4}0JWz|ktHpdy`<RPtffI&Hqs3-wdQc;IIV0anzvm(cY}xpA+AA}+)t{qA
z>aj(rqo#@H(x=Acd!R>Ygp+>`8{7G>ALTv1Fg)}E7TUU;WB8C)dg{%=eKiiPMLwc!
z)&=s8g8`r2&U(lZH+nBbGNb7^wo_~85w^WpMbv~XU?-@ZFRj}kHt$&(|K~g&Vk{s<
z{#b8a%22gWH!V<w<HXg!TZ8wMp7m^*$eyHK2K=njd0Pv-tK;w$ILw`CbTFq5)xKIo
z<<(lV^jOfnx-B#%b+oZOs$K<{w41jRCfJ@j2-0v+`Pi5_eD45$0*bjR)SdC}z*ffS
z5D{mcX$suc_|?X2r*A!f&3c-H8_ZX;^*Y!2Kr7>F->zboj^wX@8A>Sub!vjff64v%
zHz<F$LOsov%}2Pb$h2om(WTbhF?1}IefcpXC$lbAEWSXT7Y2yP{3;wDa)w}XPAGeo
zaD`2|#{^W$-P7?+&S%K{hmYm!MZ~h)?wIS{i+yt9UYknBJ)BzLFS%<8?+`Vv87GHc
zw7n2n;tO}BV)n}T(^@YjU#cw5xztb+oLTL(1?rR67$+v8s-b6l!~u8og-wsO0P(zJ
z6Hr8k<hbhf;*+1TiUV?nuUVTzEf@Xy{*wYM>dmRTzmg-Wx%a7JUbyi?vk)}Y=%p3!
z63p`YPgE{*F(A_oBMnj6j(nOz{wnuild9p}Y`Dn2z!#ryMu=@_KdRSAHgBVC&z;DE
zY>!?S+#;Cn_vo7Z=$2mCd}NUNh21${80j0!cFNzy!XD`7|8w`YskwQk>0g~(V7)6~
zzUX=KVzihJ;{w|=g`08Q{`_BeKPHS-k5-C+B#vC|l$!?zQ-(=}O`(<shq$*<QH99J
zx17cI&8h=GY|6FN1_;={Y=DQ<#V}*LWn70U4B$`hfZBxBUyVyCFMX--aUWu-y#lCj
zVRD`#QmosfVO9~zW0?dMqR!tOyu*u{vfZg;j%m|^sc_aYi@8g+ih0o}DCzh2dnU-$
z$F5JAeHSX!%n;9kva}kD8q&iMv<IFyvT(^Ry|{wdNHXs^b=o-{5{l+Y!e53?2n@hg
zoKJ>4-h=qx2Et^%uRQE7Xt&B>OInfs=4kS#wc9$KryQHD1l3De^4%#;3D`Q}c8Ma0
zwrejqNqZ^wxGujruR=ZI-{th}MfrONu73U}Ro-vZDqf8c=^mdg&NnEYK%^T5l71EP
zc?X2#91Zlz7`F*%_l4<wLK9W|Up!dV7;RH?>{*sw&HiM#l0TDn{uKJZxs)o(Q>U*f
zS_P^;^vp|*Hg4TAhdv7i`y@VO*ns3A-2A*kEA+m?VCzrp2r#;}TlP5OQZx4wEUUGL
zsc52|ex`Oww6V2U<A!#opW3p-WNV-PYwhgl+GUv?jDkl5L8cbY8VFyhE=6qH914?P
z8m|mk{M_RHgw6QQD&vR?vWC@0X5mB>u}V(ER`(|Ym{9XUu<{8~X)WHPCknm`&vshU
zDmaaj(B;EDPu2Ikkh|VCz~8V#_}d<+*O(!?2r!dMhjRwTr;6F;QL#En7gF0(2tj*M
zRsiR(C!<#pB^r>jbM%5QD-{y9NmQ({b{^^~WH8(?t-viS&oxzXs!TOn?)CD$hdnqG
z;YGZBdKX`StFJaNs7Jf5E9=4(Na(70^Yhz$X&=sC8*7Ohd1SRMl2mzM>Z{M(Y0jVq
zdtCpa?hUg5?2U(d@z6%?IIt2!c|Z5m2;6L3eS|eqc+$cv1Ge!$Sa6oCTM=zA_W0ce
zxNn4M!N*Y7JWvJOX2zp|vK#rb27sncz9bl%_#9U!61>FWSw|2rgQn=WFBar+maZt-
zx7pXo{M?Q?i7vVnYvHM00I=+yB_t8TjTgU>bIJ`E@NMyF3RGDa`ROGVb6-kZ*b^Ez
z=%NHE{T_dxDx5rsv3Tf9LELQKKaY-d%~I?$&b?53K_D1QkYo*d#z4XEnZ*`b4ty6d
zQv$zOYkl#Xj>`_>?5f^MN<mZ41!{~9M?=e^8El=|FNW_l1J}89nL*dHf>SvpKetV;
zd4n#yhj&a9fV+#IU7<FRHSUme*1gO;uKzB+f*iZrVfym^%|%ymvnzuXR<iGf#&;=o
ziXYFsiCDA$@2=5^_|Whf&5*Yn%hDe7-%jM$0xmo&?>81xzP`%&!n$3OJ)xbv<&D3w
z^QBvaN!m|nH4%AclbBpX8rgm;TiD3-Gnwc3tvTl<gO<pbFqa-90M1kGc8QN=7EIx^
z&=~haL0Lzb*HN2b_zEH7&^)5k&1t~RM1&dvNQE~gVF3*Hc7mKU4#2XGf~eU4Sx0!7
z78n5m>-8+~rr`d^9qpR)3lSM*UNKX*1%G-t_<Uw(Fa>S~^j~f7uHd2xb6~Z3X-c$y
z<2l07m?u8Q#TdSD6`HCum17!@i0zcv`T99{U~Z?Or$yqUkP&Zq=JeGSf{~V)qz|v!
zD%)$m9&{m9gA1(hL%~Wj^uguW9yT;D4YAE-pp1O@TjFx7qyod+X5CHN`m@x}+mdj+
zEIBDLB1w9sOKt$jV?;yemn)kSivr43UnAA}%GE}Z>eJ=w^GJ=ga*dxz&AoEXW26>G
zg%-cOwpfL>`Lt*cP$npeSk<LdlluQdM|@|AQv5V|3<wn=U(-edyMqC!<r89F`a;0}
zaYyh)Z7&vRNtrWT!Ytqf!OXjgJ%oTbs?<V?o)5v)o$U`FQ54<X>s-d7jZFVmnDTf3
zOPeRu10(F_6udmm+Wj!RM3Z4Z2Wbjku~Lsl!KzX8nh4iRyH)P`o;(ZDz_OIfuEcr<
zp_5JETc4?xKVhBX{C^Rn9z1}YbmOSo%)In=Skf(0cZl&lo6L{I+7&_*%ApoSJS2#6
zbRKo(n@SU`y&#7F*S*vwgwIg0B0x|!6+VE|f%KqCQ=}~^^1R*m4)G`qNJbYdIM!`K
zV>_WwoLK!oUJ(X#UXroyNHpA_5}$(wPt%lRR?nq8#OAI(U!iJ&yR{A(0s5Y-(1A99
zNfD!UvEG94%C56cmLo5^Le!{O?5wGpFCe$eznp_4O>vgS?`}PiHzvYr`&5a<+m1b$
z!)}d3;%)$qivtjP+@rGJZG7IW)w4vawhw-HjTYf4Tbt}`og})^ZBl<h5JJITq)7f{
z&qshBz(7ZfUG5u6)9l!Z9|SdLUxE>f(IjZ^;sHd;^gV*fA^z{>&qx&8{{b^8@>70p
zA-MC`y0!g5X6X+KF8ADICp#a5l@HlWWEH2i!Fh`e_xhyE)&s@CIK$e$&xTZIX{vOO
zg>gJk`m{M|W-Zngj)G86gUKg&sag<f!eM1N$9!T?lEJ1OAc7E)&m^$SHM^!IjrB6@
z7~6Ro&ZxGJ1??#6teO?CUyb*((fwj7O;P4hdZ@=R*=Kv16-0xP){dx7dqmk>#gL<J
zB<(>EN&-2@h0r>$<HIZS7ZpEB)FcBXpx?wdqyVw=riE1PL%h)j)!_X7^+72zH-b=)
zJ8ELnXq7V{Kft=;DxDTJYP)SC9=*?-H)~HWS6Q_$#;YB5>+3Qu_H^l-?>2<IHCibt
z!CT&Td3fUP(wTb7&10&Te}(_ln(e|PR)|qutvdw9rrrZmhgyV7PAozD!&M%OsnKjN
z&NY{P)Tp}G$WB&wHEX?%KRTq~$VnQj>y_$q=03^K%9;K)rK+)(i|#s09mj0?tt)jV
zkbEw-2d>@C)AF`z4CD6xd(ISv`CxlE1zV+bORP(-mc3H@_V#;H5tLKk(rfECO?!n<
z`MUQhX#L6U1(U<TXW9}t4gefuAyFAjV0lT7M0*H}zqv@O0~-x>A%gIj!gt9WSXc~5
z9nx(yXJw3?ePaSquT2@{fB>3s3=XpLE<P58&$RB#oPV@PGK1HeKXZe_AVjs+UQy>R
zW$Ug}V1NeNT>FsPBF16Z8vG(n;R=i0jF~-|ySTJM?FhKT?$tB7w$U7-{LYtMt+ubv
z45?9@@<lI<>d)xZsVGpUVrv;T^=^PF=3MYX_5E3ipj})zR<cyt+XPTUSiwQ<7<tNU
zmDVb@C`EE#i71wV$rRHod@8zW1z49g-0;FcamzO!65PS7l64y#W(@Wprs#E-PU6_5
zsudMW$=o%J|3(XrbQ0PHy0T$%u}e||oTc(4RgyS!OptCuj&l>6jc8#U099jl*}1e9
zp}vTe&|4e;MCYZWOxCx(`pY%<k%n-y^S?~}e<i}6ShauGt4+>bT*dEJn-U{_BO%j2
zsdXXuMBt@*@EWc7)Qcs3agPE$7l^%URO$A>zM4yfu_TRCY__>TquS*BD^-al7vFag
zgG7MRU_o9D<uh?UoicMYcP5b|JYuA#XN(;y$s%uK)E<f^iIh@hyy__tY?p-?@Ca?h
zerVMd%6A!%$&I_gLBKf@#n}fhS(%iZ^mOL5qytB%Dx_L$-N^*QK=3{kelP#&n5x~R
zjTRzmXR@K=)#AXNCuWH7b)l0psUi!w=W%z2J!xW0f_UJzIGdTqE=UHdDeL^z)c=WA
zEl5I*CYHHqy33gM-MX=<9rEyF%2`mK!!HxwuwdFIVS{S-npRi0S#Y!(Z|<cL)PJv%
zdiI!2K+(<D$;)`-&ROoBla(8`yGg9BI@U7D_(_O&RjE1KW9EKejg1|=#`fEsy3f)1
zbb^36-<^^|*lJ^LC+TXO9sPvu1i{RM+m`w&)*rWiNW#`9%|<32Br`_Xu_`vnran~Z
zh_z^FN|dXz@je&{U%gsuezNp|J%Fstt90ce!H4d#ki1MBYmA-Qu_x|e=eo6AlkAB<
zvHJw=yHRmNJ8|eT!v7pkJW84pT*BF9MfBq!OD^C(T%n1LCCPyC(z~mKN*r>g%Xa?u
zJumQSPBWM^UP%`Zudf&|q$sUNO3diG6}@nKpy&Shh5Iu-kCqo6Z}iUhzc~L+&-1?*
zo}cx+OzBc%Np$lbhc9|Q24?b>Y{owQM#YTgsE>FU<yM)uDyP1`K(gscnl>5@$W7Ab
z1$$00WBjk~Svga*c^RU)NeaW=A({2?T+|gbc<EYm=reFv+P!cH?a3OO9<P$U^smrg
zSC$yb8nu1VU;q+LxZKwlxvd`+IGcyV8}U6P4D?=5YKcjekj7B;=ut+8>mWHIzG*Ke
z@sBwG(4$Y&*Lq6(M!ZCAxt0hPj89VPWN6Ki0At-R$L~iL>|XoQVtyW{zOX>R{t^1#
zLiV6h7;L-T=Dx9i$eI{py<#CZEpX+E%Lz=f08JFFEUw>^5Pc<C{*Pu82sR@nPK=h5
z<cvadMq?~eukOp>RrEWl*i3@=HH(h(G01286botd=4a0gi3tms<Q5>xAB5UxHa+f;
z%~fj4*EB3JXe%%^EVO7Vv^TtYuI;9`;jO^7TVE~<HYFKd`;83(N*6BEFCP@8_AXp-
zf1yW{ijfyTk2APdeKP}PHJ@hn(hS?}R}@s4I(~qiJ2-cE*%C5`UAQQZ0zKGWys3JP
zAWgMjVO023zKMcWgzBfhLfpsz@96cYTCyYRADgyD+_Ye5gBh&#_*7l5{ne&(l!w);
zYynZQ>N`d?;p_GWX5>`x(-CupIWFm{u6s=ix58(&9F!ia)3}b=)=G-)&MJj${KA4M
z&gVaeT`=rw_+WziGThv!{s0yb@{g#`NZ==E_E1oV{Tu9fK{dQ)1e-3JsQ{?__p;^R
zE7OmyMgQ6i@M^=)0>pucDG-7KAiYBP*nIcz1;Y|Uyh-WTd!l_}=&z;&toEzJUtUH|
zsVZuE8iMGrnwahiEGaUgJ)09SAg|jO+TS-w%)0jRGA%@OqY8V7KM|4iV)C2bz(<xa
zEvws;cZ!Ow4@vzHZ#YaF<zxr!AC{k8G@@@L>h4^f3Nh)#;B-$sm<j<{9*y%54MhlA
zJr<P=oRL)n77BV$KYxqB@(^3$^9l-VSna7CUMeihmsh|3$i9j7XN=(8r+(_X?kU&>
zrHlR8{SE{aw~#139~v6zOj=f?Ht>LP4C<K&NB7d!#-9_ACCp3tT;2B^2)>EMt2}Hc
zHwPy`X8q6E#Oe37d+M<JUrco=9d7th0owO&6TpDU8fWL%$0oM^SE?wbB7fFQoQ+mh
z@18O5-WIJJ)!95Fnj&KS(-h8B&^Y`kWZuG0{G?BK>;~Muka#<ing7-4cl7tXzdbsZ
zW^i!ll6m}=AJG`))_MK4;I$cA3e}KFl-=Y~XiwJBI)w#894>v<1ek#pMJ&gB1OePT
zD?C`MAsk=`Wx|^q`1wtc)7TO9QLevLfs*4R=eGO+n<7n8U!h^a1-m;2k!wBGYUDQn
zz*x^ei=R9IBrBXh-c}fV=CQrEqM3@r2h+rJrHaP>FPQJ`0kPmH8_drKb=3-kCGV?#
zdz0%xTl@c%^bvY(&9#a{FN?yx-y{M##cCTNF9F}d$A62$?aAr<oEEo?B^1g1Af8`@
z;iA(PfuO;=p&lBGZSfsyMN{;b{$Bv2(3InroEU~lqj>nE_B&U@Kfg(OCeo~83qX40
zEAXpcg_f<2d<Peq-21wzWuEu;==~pSlf(mQ8Sek|0jC}U2X3A!(M1SG0b`yT{H_1@
zXLEVA<Xr5?H`B9IKwgJVAeU~M?lnf6qHGdlk%F7sMrg{#a@USAl80;}x&V^9JVi9*
zd8M|*0oN*chKe-=Fd_MT1D+It&?F}k?=}#hBAJz6`gr0t#{1<$uk}5q&CcdYwdHPn
zeGpB)IMEVlt&)=YVs8R@yZNxqJlp(&pL}g%P+o{Spocs9bz^Ol%3JkU&UBt9nUPMT
zhF>=X`7Mkh!Fe*@H+EW1?#xAN>1{xkbsj<Vc6;-qzE<&>BC?z(tdyTlIo(!C+bp&*
z{4q6YkK?<k6Ii&Yh>zJ9ae43J7WUr7QNHkrbiLQp_tPGcBR4x;E~Y66*2eIiogt;E
zPtW+}*`56ma64@JLtt6f+1cRgr_-~c4I^hihPC~e{`h7gmyl&Gpf{Lh4n5F+h>=bs
zW~k3zu0UC2TD73Ad`dPDihKX#&j<6$G|s`xw#;$7{B@geEA1WWJU&qE>e>yp0^ftj
z_x$)8`XtYkaQD@0)(WLmB4-<BP&r4y4{~`&VR0Y4Y<0}JlQ7waOOKbJRl?#jC2^1L
zJC+AL;7e8LhRx{*sN90Ee~`z!S|cqDl5ZV9{`%N+RMO2RQ(}c%N9(ploetRDtj>pq
zllnotbj6xKNhj|Yx@3*Obt`cmaV7Wa-<?#YN2mttY~5N$B}xZw<x<*tB+(x66rnU-
zPBR|uhbCDbqz3gXe&OLyG9Is<%MZGpJ2U*JA*Hsm2w5qwUQ6GMDmu^Pyz)W*o#(kd
z@Pt{N?$BP~{k`0fkJWeC##T_3{0HoJLMco`l&`YnxB|d0rmR;mpTBFh*l$8R&Xrgw
zfg*<<UaHATOc5x(*C!l;5_4ZO?Wz3zF_9Ve>EPMTKmaR0ok){MJaXkluJ~w`{$`K6
z=XzfYS()qYia?w%&A_+k<*H)Y@Qoj&8)~-%roR$--l9{m*S2`oQ7D?=Y=5A&6GNB-
zo~*j@na|A(jM1e^ek~R>0^~s(e`iT$VCmj_;w?++Y9b&jPBpK^ZU7k%cOsLFQV_g~
zo({0H!KvC5?fdOAJPC>aY?Nr)ys?LV5}26fdH`7~>7rla8Cov(SWxLryawPtHqX2{
zqTzDoBErAa!MOf8>*J$R{^MZ<-q<=HCIqqZf|O;Fv(5Mf&HE$|g8HOzw^af0K#>Mm
z3JIhou;PN?yR1c1Y8{tz+Gmd|ffiu5$8MdgT{S&kCjgoS0kIbm2&Kvlo!2KclAJeu
z{cS({RCe__oIZ2zTval*R-1Kn?W>==V#5}93u?oH3=%ND0I+t2<#|%<f3}u);cnT+
zD#Rc;>9Y_E2rRTcx8$h(ecVEWR<&`IcGjGYklj*R^O!Y!e9Hp80f*Y4{m=MvQC)({
zpzWFCt^t|0x|Lt;^Iq0u>HHlGXj+tc@FO{=Ow|gBDlgg}S%>a9Rbn^BZn2amJgaq3
za-H<j_EMDAy~7ojWUf-9nww(Pa~&e}b1Nrw%n3fEI`|g^<x9p6%3YdypbHjC8Of9f
zc+_*dvH2uN3_QFolkmu={6k;m=uM}tSauk6JGt^e7tjnbmsXkJjQc4s=FHd0E4*C=
zh}V&8f-^*aiUH~`CCOIPXoz`vXcPxL{s7i1XS<5?6~*!SI}p?!l%?pPcQpU?qy#6K
zo%=8`n0m0up|54d@5=#@GP#{PQ|rqowf!&~b(<tjqoAJjP;<1-Ku#{L<OpTq+Zb%h
z7Sw?BZ+jy*5`oJ3rMezlMqjJo+*k$nDBURYAlW`wm^b;VP7<J#Z-!NZ+FX_*?~bec
zGiELg*Jf7ib5zJT|L9iPMwpQT%Bk$f7I45aulR9y=JJb(oLMNB-Ff}j+y@|}&LZ8U
zM-1cLNtJmW@dkj_Ks?=@NG3`9NxUoW(`(+!ioEM5^Q*Z3)ZSK3lC(cU;P!x-{&rs8
zU4I45+k<vjwhPLnSAzwU_%2&^Tg&%ySjL<i@=V!6);c~v^R%4%OJ$~FJ&Et4&xsL@
zn}Z4+(t$iXH&Ojs_kGgyDkTO3V7jD7cY*32R?=)xcSyG)?RgIW8FT*p2;u|Q`J*L<
z!mnE$SgM^h^&3Tm4Il6UUaFqDGspMpw!R+vq&OM2y4>55R)OVBS~VY|KwY$m+Rcbe
zBj(*n1ii{kC%ucmjN3o?e>12$Tjh7heFeFz!6LunLxN3hY_n!kO~<}TAusmIO?bT3
zKioPcF;bDuYKlF7T8M+4r&2;7j}UMKTm+!-8nd0-O<R1d6@n!3pO2Ht^p?$MXRx3Q
z0_+d={Y*Q*ED@%xS@~aNrkDT8r@3l<8q?#q%)zCQd<fQL7MG%5SSu4ozw+AgQf*iP
zSZaKWZ>JX7k(}gFZtivh$OhngaNf@vNOlJbSBPj?qVDv4Z8U8av`MW0v7&tST0H=o
za(WC8yOU-SsXQ6_;URi4Oq++BjXdO6|8C`$h@uOqUI1I%%<KP&7f=Va5ijp!4%@f9
zdS1C%2FRotSS>cU=z)HQsbz}k3PFqx^D<u?N&w=%-*GYddE&46d%4vJ%gJB&<4C=1
zJMoc@UChYMsm(pPUd-b$4fB-j&ZWCAVeak<|4)i7PQZ-Hv+HeC$ZtjvzUavvx+?@)
zzH+m#`p#jS2=m)Y$sr8rPH>d1@Bt)t*RbqP>@W9eQYf+GKbP5sMz`0rBj^6EY<Ohe
zoCd7`_wh7__6hZYdw8e%`BR+}jb`lR&P}%+Q&)~daJ@^4pEUr>bKKX4UIvWA`LxO+
zCg6OvSmn;F1EF$XeX2}6<Nx?k%f0|O6iJf-bm?p^!0K?yOv$qON;vQQ7dhigfB*;Q
zVpc;V4d-;xAiXq0QH_$ah?w}byH|EwB*feZDZ3X;0QiVt{bgr;W!6KpW|R2T*r10b
zxou$Fg$N$Q<X=JzxyqjR6w<2|ir%O?Y??vVdBWXH&}e1Fyg6@XGeibJR;-RlKxxJy
zNpO@VT8po1)q<+7o;F4p4?MCT=;Rm6LaE8~36(k6mLGy6g>r07&|5-OTc#L9*f6qx
zv<GdZEpoZ`@TZ-K-Ij=>wx~;_s9S@m=awi*TPz?_>|a0Mdg*(OhXN=BzrLVbb0^=o
zQtlwZK>&v=$0HwdxF)X!{80@I5A2922Nk??WzLbs`hZr42x&<_Seh+RlmYv8TBltb
z!AN>>5qV^u>KankHKSDC>NucM7W%qRh@8>OL4Ahm5{XHYxzKaxB3@GIk?UE6G`@_F
zj^(F;ZRZ^a&eNhU_+7cecHt)ikq$4m1S?Hwx=;D&4}~HUE>2#v&=`)?iLcoQ_$(ii
zmW>c%n+vuO-1XTC!OTU;R+2;rPzV%$fDMDSB4FE{)tP>2Q4a-H$}bpC^dF<i90LYE
z=E$`SuBR!D#|W{ZU$E^($_-MZ5K=ZfXe5(F%yw8fwiFIe<{3cp<ZSl?0Q`5mBqwkh
z6A1dX3RDN48y_TFk7pa{L7%piVuBfbicvB#K-Q-&)s9d?<VbET$z^l<sx_QVFO{hE
zm7a9!_p(DY0lzB}kTOf$QyIVF(PG&Uz!FVEUjq<@lNTF!jr13~U@o;+R(;HQ!u*{}
zr4LL@UUL44&gD$V>rP=G60DLg+mx%b&yqArIF_U-nIhNif9kIj+$1%Dwiul+Fn8P~
zwx%e4j7yi@QCeGb5s|l{<ryRomw+jf*Sgz&+B~mYpyL}=Sgj0z1qo?hDJ02pgGZ`n
z!R%t$(G6eWNk<nIMY+1J(%}=r>>ydjmTaKEs1ZpJ608E~G%Q*VY9gJYmkMplw@MQa
zio;d3B3@%1%|K2rOqDJbeqCHfZRPX{fMPz<;+>X`HGDoyt_RPoghOxP$e_{-6fHf6
z@Yk)``Zj{j1MsS$MS`32K<&aQhhT&Cd}8;`sT*TQqh<4_zp3p#eLl@g{C<H*&9{E!
z=+d_-2dlBVx*_fk<h_u>v-izxCrLy+pk`@N;4fU7J5wX2OxkGCsFn-`gK919kJKnf
zCCcwHk8!5GY=62~LLL+hbeeRw3mi_}TWr<}mQHz#x$c{mZUOfy+dl-#_AoTr;D%tN
zEO<aEh#j7Vw~b3B7C1W9ZEejAIfe123_l^oE|<V!^o4yT%D<_6#lrSTHJ}A(Gs0Y4
zUKZaK$SkiG-^~&AEwHSv6gLZy`uVm?mvAnumJf~)ZoVkU1?H_)bGGv3Sz*nd1M3;W
z=T}`^QF+UZV6QEgLg_P}J1@Mw&4iQRd$UiwU|*c&-18CCCy8DmNi>sW_DBeQUxizB
zL%N720RMXF8Fm^(x=Rq=<#%9-xFD(^xd>~mRlrR9;m$gpj`4jwhz#nItR(Hubc*%)
zb@Y`vl`+Kpuc#FPr9yNSt~~Q-p$cY*C@d`g_VNw#tP1*0J1saG;K-*8c7fMn<)g~>
zu|2DMNE%C#90dzF$0#&)O4b1rj!ELyOK6DgDMyN0d6UA>-o;gX*mvS3tV;-P5W#%y
zQ-53r$)@w41o8vO{Mkcde?d|xU)a#Q$H!&s?hM_#XU)<Vf(n15CQ1dz$cm^I`@U_j
z-+L+f<*>hfrS<j=D!eM~`m#f3xc9f>y^yDBQw4zwutT8B1N@a!1_!TC#2obNK+CA{
z=FA%U*|S|feoK<mPd<R)&;hn6mvSTw`QB++uD;AmzFN#D>4v{GLcdIGy^|Y?kZ3A{
zMT`>_4f1^#O)Xh$CP@NFixq!?NGM9A19;~jOPhD8kXLQNzC1b^5eJM=Wn1`mri2Gb
zc_2hQR*C<4kPOWNhKhxq77kklL4_HxV3Ne&wQrUbwGDklMB_)3SVJazPhtls`MW`s
zO1XqlxqwcYe72>~_h|DNL`WGva#BOCc7c03$h=fsK@A`E^_<XMp&WhHU@b((T33NJ
zMFzeiIqLL8q&!*_#1CG#VW&Wm{^cNA3h+vDG$;82EvaLMTNdPOzb<#b40&Zz8E^R&
zj)?tJ)}mpckdMDATF$qgYPCeV5tJkbk8&VbBj#}$+c?cu`0|=FV%HUs-!)maB)5R`
zdsyLPx|P*C<2^;jGrD|q5%@~72pc(|s>>&PPr1-QjJ6~(yDr(MK`*kn#)H?ZB*(mQ
z_V|-_P8gKF(}liTCNGwS_!*%6T9>yjcXY`>51@b3;Da|aTLoskXMNZuB#ncvRhTE+
zB)j~P!zW!nE)&ZAn!N=Bh{c}GVO*hd8Ow82YQ^G?y266{RMLfMb`<LJ$d?tQKdWDK
z5{7#4A>jE_kHKy!6<-PaxElxfNUJXB&kWh!Z;>7hL~#$Ce-)m+W-~cnb$?&Z3x}W}
z<hB<(YKu`AhCCLJf`CIrjY>TgVWWF-b%^*&e<W!@v=|K?<Wg`ONyFl}t^4Fmg75mB
zJ2fS$d{O+%{>|Lah5-Jy`kDc$+9H(fZIqa>=B;cj_m#(<MxhMlLMEwDpggE$D`y`c
zX9omOl4PG7-SYOmCO)7e;wMXUEILR-mF}xEL7hSu<P*|9pe|K(K2pRE=wQFLJUKGE
zwEtJ-5k=!Z>+&Tjv=K?eBYf%C6sD<anFzkI1tahh+8w9izKG^stPllN)+RMxwJAPC
zz+RJcj=JQg5iYuS8WS!r{-q{x^$6{VHF%n{2CbH}gN(sQiV1(g9;Hma@98;Tde$A)
zFHazI@G9NM&rPZdA}ZQTXFPUr&)FHe5#9Is5f&SfMkZIW2_HR1{g>BB53_qJSIVpR
z7!r&)gB`VYXQZ;mfE-3ed2>PiDN@c!`~g!7!QW=8Xf<z%|5{r<1zNDX^$UL}5jT0=
zo!jHi*hy@kkira^p98_^21*Z0;$zNq=6jYq9^)D`Rv4;tqFGyCf{<tEHNC;-6-sBC
z{3y<N9+!~ze#fO;lC+}ls@#R%{;WeU5U__tITzpiFZ*z?%y{Tw{7`lK(9^@AhV~~f
zey>LCE03CGqf#CJQM@|O!#7twrEx<0y_zMr8BgL*`7BD7mc3Pw=N;Z7wYDiA+eXph
ze)^9B{!sjTQc-<p0zmbeipFm}m$XIV3$HI9fP4ZiZ%2K)i_+lB&QwHXlivQphoDn}
z@2<&Fq?JTm5T(r%74fH<0G$%A4Du~61r<H^qfG58hUXF`RBmZPQ+r|kk%zz=(Z2p>
z)7ql<6x0|hk%VFPiievsx0!*U(UgE&PJx$o;<ZA)TsbD?T7CNP<L2p%jy529{^wgc
zXrWGsvO>w1xbnxSDhu&!;B}v<*Ucl>I|Il1b>9&bvWLFJADW{N@Hf^|#rPLbZgDE_
z_7gvUuM+k|07?YA8yDYnprrA&$0TW6Twwy+U6hG{0;5Z@ilSlJ*d9#1u#7t0;X)UG
zu+kDL?w9A#<7+pd6JoiYtzT!KaAEd5R{Y_VyqA9(nfeC-75g}-K;VzZrwufvVR+Ij
z>FLtTCk}xbO+hAxcJSBeOqguJvWxTK)tU&Ir3av_DSB4DK=@k|c-*<~Ot&A`y%Z~b
zuAfE;YY{#G+4wJX=P>oPbAxEP>7BXTz`ROqo)?{BxsxYLu>q0up~xV<J8OSf)sBv*
za)8$x8Ay!eiM9W>5Clg}_ZynaYjSUXcp&-2{H4cY8^&Fyf%5z-j9U(vqC--VE<+%J
z3qT1jP7gM@3A(+F<I^p#7rM-F^gN9h1q=;*{)1FrO21-L_{8Gu;_~I{F0Wm0P|CGM
zKkX$sMTF4G#GE)`!u!VE<F329c&L%@z1go)e2MUFOUTX5H8(S1m*aZXH^?gz-Hk60
zUq7$?c_t17VFdv|Zb@UhRv9CiSIQ_JqFvsTCZg)zPS>vJ%aT56y?bHovuWNjcgjw&
zWA=b85YUQZ;>RW}jRAC#+7mj3_b9jcWqCUJu*G>z5V5A;zdUV<H9e<e(sXK^Q|vvx
zb{^M$o1)oP9C@TTJi$G+6);hEy`pB@sMqo`fybb3t}W*KEFXMWQomz*=EuLQd>@~^
z;$A%b_+_wEBncq2`mZP`vdcV20HM-4RC+HF*bXe+!4wx#Le^KQ=W?|d-;0O~6tb#u
zwEr_-)M>u;Oaed48TaJ$52N3m^Pmyy3t7f(+pEKOY{DcvCoEONZuSdS2XDO9m#@I_
zZC<RDGGu=!%G+4Cf<bziXUhjE+#R@5{mv-xr^wp-TFuqhg?lcpN5TJ1lU*eAd=g%;
z=T0Z^n?RT(n$RV7Kv;>fVsGSN@0PtuFT~dpo&uRL$Bo2T@(7;mj4F=v7!&R^&V}Jm
zo3Q^l<6v|*Yn#&`=ZCOBL}u3BEG<T~j6)(MV&~n7kixRQ^P(W15tA8oTyK#2c;Ca^
zXMD;lIJ0b*m16VzX%|XDbo!m`CfFl-DFb=p04omBGY-;Qna*RDTb+&$nhFv<+1m1X
zf}LoEJl&jg*2*($?xB|ghDzf(v?dTvAm|A09ZWR%Mrk^?4E6Iv#o&ap(?cOo>R#83
z7v)w?pO?HVGey$kXiKt7We=+`7i4#9;LZLMB+QA*dFYs1Cv$DGU*(|EZ!WjDYt~UQ
zb@4CL6&?dz$jo9_mcNMezM;HU_=UU0C!*(RMp*my=)an(KQhJNaNY}~e(}d*Q|2=M
z&Z!QPm+KcDs&_AmD2Lh&esH32>e2IDdAu_t`y|7MBl~3&d7}o9Ikr)QiVrfQhE$#n
zN4?c}!y7%U^UgMUME`SU^r+FV;plfJOx~C=yntQIxVc<b%!IY(NX+DEQ@+bnb|)1s
zzd!5kxm(!aN*H-D6il%LT+a%#^L2fYb!GO+DLqIw(4k-Y{^e}qAFYtjSy$&B)%$u4
zWsVCF(NUI516qkkLTU0b>m#wt*`__t+A;s4&7y5(^1m*ZguiaX(qq=&d9P~p!;m==
z6sCiG6V&N{G_Aa?j6Vnt(MXb5=0e>4HTv(JM#6Zu=_*afGg_1MGv^U!*z!AVQwd#x
zd!igCf*xG@lbx`qD=;<emvA1^x|M<0F8ay&``WVJyW-*!b@r$7yo${Oj}wmeT6jBa
znd^9>eFVO}<ZZyEIQA_Idpfka0F33=zh)tgGzV+Ug;PXOw<QaO_|*Y$;c}_$DC?_6
zG@3f#rH`#9h@4F+4m-;pd5+y1(w+HL5zrL@MrCUY*<gI3l~1^~3j=e*z&=v82#`9c
zp8w9mS2+^gf%gHVH&z*XCh@>A(9+=bcAE0V-hCnUy>WgDS|0Fc%n2|o(yPm?*|P2G
z?9-d4XI;)DO8qx>GYVX6OoNQWI9USZv?KJaPl!?#XhBjS&2mCCjmkt*I1AVqiKRc|
zf#?*8&^&>^V1NK{hEq>u`2{gOsxb6PddwkC<__9|C&-db(VUW|TiM0^W;<286c089
z=>VMI{g!tfQ&kH|LO<mnYUdb=^L#)@ycO)jZzwh=#zb0MOrZd?4%yv@d}jtW9vM8?
z5wZ}e<Q^%zk3S6qgzn43T(o;l2a?19tvHEIpDD<jw0H5ol{U4YN&Gh~r@?x3DOkM<
zCy+iyQ;8|#4XYx^agWojW6DLIR+(w0k7tI&R7n4*vM}YI$o)3VOcpW|CrOhsiD(pm
z7P&{Pd4X;T7?MB#H_P%VOHi(|C-4QNBWff0&Ok3}5PdA1M1(T)uuIX$5sxe^^``FN
zf9TEY{I@R24ba(afH!hIJU^6|<B3FxC2|pEkGHuC?}l1C-JG>)&gIYV{82^;>R;LS
zvur8s5~N#OqRfRjbyuJY`+v`QJZ^^hIcvv5F9(`bY4d+5)i$KXW{TB8@g?rx^HRek
zZG{l|{SF%CbO#QBKYkBdF-Wl{A9bV<5&UzQO|h$@pj!5pJ7g_Y9g-drSkMgHJ@k`)
z1obrYn|%M|b+2R#H}=F#Nr|d%1q}4H_e7J{tCH+XPc@j*!ZC@jbc@vdP-KjPx^nt#
zyLA9-r_gu*);N4l5!@2y#2Pud-i)N5kb48bUWpAhr?WZ^fEbRzu*PB)Ln@-c4r2Pg
zw+^s;E+hytfvFjLlh<R_0b%dd1LfX)8KZ#Z8B{-aMauqfR4l{V!y9l-FwGpjteH;+
z!;$WYmH7ZT_(mPgWBvVAmjSgoKAntv`eylK>VPvn-`wk?ib{$(Upp`Vz)PB!I#_KC
zoPNvmVRj345wceH&G+Zd&vKtc$;z&F=N;GBp@7==e+s2;1l`&56L+~5Ai=G=lGbu}
zNwoiV@U(BGJo{67q;aqnlWd+}z9J|4Wm(eUC50IkTJmYcycL6z*`2Z-yxnG0D8e)7
zcm6n9IdCA&d3HQ1j62lT{zR63<I7YPxxb%jhs%ABy@q+U^~`Ctzen!KL_PYT_I-2O
z;Dd19|3}rkKQjIJ;oq;#&Ko;8&3T*ip&UYz*qo0U$|<rrlM1OQGIQ7*n;b&X91;~F
zNu`=YNGhi!ot!GAyqzjk_VxMR_x;2DPrMG-^SU07{|*#C{~qpic5<w-?ar;-A5lln
zzJ0gYcK5O9Vs!S|cXK=M-g}vQEJ8%qQ}1L?Ls2)(9%xqfWr-*>IpvEufbg9Y5X)~#
z$Ft(Pr1CUU4>8IY^Zaee)zmn@8V0<D*)4AIVL+`{EjR3M;Iu-gpE>E_WnEaNa#YC`
z<5hjJ{f<3G46e-{)B0R?p_#n8Yl5X1Su`pKOnwc#*Tw9V{9$S~-7t`2S@%G`ggdH^
z_Wf;}C9Dk2|K2?>PfN2ec_J^hFH-p)chi1_{D9jI5&Mb+_B9S?vg49s1F&a-u4v2!
z$Xil{AlH6G-=k~f;=G*l6K2LTnhDuXpoyEE*-PmTJ!`uDH^&cT#FRM1RS{R$;ro^z
z;s<|-Fb6B2M3@F<#l(T>aVBo&S;%|}e_G*u1WZ0sd~+DiUsKRhBh55V>{3b-eHlM!
z>R97>GU?)f(udM5K6k!7y?4-jxk=Sh<1@Za`LPeB{+sR1E$mI*zVl^;j&jxpzd0<l
z$B4J{;m5-B3^}3FFbQ5LX$gts&b?NknJnvnevy9{^2Y7dMgLDyKq(!4YKq3eq4RM<
zAPt93Wx-!IVIXzrNjkc#1$l=G_hccS@<pErV7}ml<t5qNXktMy?*E~iKE$Cfuy83n
z^j#5D!CVY!H=>!2<_w{lajL<LRF`e076S!mvNh`1I^MWa0G&dIWDlX=0iyR=I1U{>
zK*yY`Om<6wb7&{AF)~7yn8*o6*a5PS$w_Do;yHj2QS<2?59RiW6_J_mR5L7K{)>Sg
zzwLAvP9vlz!up5xp8qxj1Y%osiTqWpzB)$864fIBuK_7#HzbJe+NyULhTrD!CAsEf
zN@h|){Ox_~$#;C><0WY~FWfeXfJ?<HfRV|=2oQi&&KDB>rm$Po{a1)tuxY2qQy9m#
z?YH~MLma}PsdGZ!X)N>1ZZ-W4S`IY-^!{b0PrlYhGu)&q(kE0`svr<mr4=8qf9|gL
zyD3D*Z>dW^#YV;~#|Y@wW$`L+%nSkRnWniIbO073nlA~I696R*s4od)Lcvt8Vv_$a
zWOaduCB;Z2gDgr}=rwVmjH8zqjV)H+|CNVrrZdhrn_mLCPSLiJSv-^s@TtlBS+wXC
zFI>i|UEdITmVd!bpZ7-@AAmDeYQqH>6x?s}-{Z-6e|6^&WBV2v+|?z=m&o`~r(eSl
zhPGz*j;cMsdys9<-5~GLhbMrhF!B^3fyKvcF?Rn)Cv5N#fB?!W#8#7cFHx}+vZ(9<
zTmy;ljCK5iau#}xxU@utHAAn(pS-X{{LOctBFlmJ%3D0F7YVu5WFEUAd2$1LS_a7f
zgk58qmM>w;AV^A#Dzr1n9dy#gJqE3hm~abp#h1P0lU?%<-x^mdr4!hUfQPRRjn2n8
zCg|G?!D6EkmvCYhE$K>YvTGogDFLlm<Gom-&J@Jk@U`!|pSL`Sd%)5h1iPq9WApf`
z54*$&2XI+ec?S7dowyTseiN4g>jzEP=_#1{MMUcocCowsgA6bgf%~#VyhT*_BM^h;
zV}yFx%hCWvT2i<!#E!8NaLZmBj3j0=5thY|nwJd?RqM!42eFWcTS9wb%s+h@?O*j>
zmQfUPX|V`Ei^bULbJM+XUYXLqNWhnR7?^T?alq9-2)8(g#j5O%XCWRpX&92B8&lZ!
zXdLhK#mYCCh?FFiPAix`5|~78kwjxvFwdv3g?cqMXKM26vxU@TPx{W7pM}uMlNvNM
zg(-?e;TP^+WP-#aHnB&_e1{MrZ4nZ$m$9_E+>?_^Nr);r5$5Bs*y>Dq8=OjRSc$MH
z&o&>k!N1%E00B!x9|Pjh2KE-iwv&h5phDakyO*bAuM}V(06@YLu`n7pz~gPbA<xwa
zab>@EM}*;$mWXecur+kdUxyR%tm{Jlby(+hm52+e`MBUEqHF~2KCVD61(}?}m&9lP
zAzc!K0WZ(+C!mE*ZY5ozQ3*rjeKCd9@q!YmIwg;Qhq2hAS(0++eq+2>J0N+Ip5QG5
zJQgS_H$x5Yp9hhOn;8=BQ=(bhB)eGLSxQ#_C<>MWSILs0RK_Axl8UJ{!lpRTkfMqk
z+}ViW$8W+cG(qt`^b%aG9$~*EaI{JN{WZMgul)fG{M8NYmT|yNCow(r(VH9RLdlw!
zNQ9Qmz`J)yzNZ?Ms%0aZu%0U<Oi$efybnlI;!!I$Ke9NP8SzpEuze*&eWED*Vce|r
z-5D26gxJE9n;F{_+jF<Ex_2EE0u`Gl$&uR=Y)AI|5P3V6IooyRc32xUzm3zmP5!tt
zpN8{Wl19}-oxv&!%V>obxHK)hpcZGNN8DIy|2viu8rtxQQn&`dP7s@p)kfGn)4#uj
zj@8SEDXM>#4|~Q!bj3oar?DYExQXb*1RO#{o4{Siepjj9;?uf@4qRy8A20-q_=a5=
z@}l3xhU4JbB&D+`b?dVK0dWo032O}TgFKflz}b@uD`eDwSXr3{gf)KbH|xNcB*K+6
zA8y3Mi6aTu=bTh7;ZoPJ|AXdIcXyTG-;oHZR0LQ@C^+^TH(P{#6)9D<j)j;B(&+Fd
zvQs#aH8SKF!FN0$g7`Cq-32+4ggRPtNq?U-u))8ZJAQG1dBf+KXe>k`FHL6h0PaUL
zVX*{z0d+f?0?o~?FIiD$gyDQ5_I)kvYLAXhUaJ!hc|}d_wrFv|ClD`tp-=yzK8Pl6
zpJng4<7_*;7kE8M2XCUu;@Ohe_7qup+KKFgHenb%XG!|&kQaP7xV%SZiHhS3WRh=t
z7p%!LhQyL->?g*JN7pMUiTZt0#sOZKrt9(%dVL?JbdMBc?#yE+8E}W64xUkHYd-XM
zbOOLfZ&Aww_w4?|7ZpX-BoeT*L+BWHA<lQ{%AI)8SQ7ivUF|h%!m^%a3O(E08**V5
z%dAFHnlDB+5pKyp+tPb>XE4Dz)*98^9oH?IGPVE95FQvjMPWWCq+C6r#RT4|pNbVT
z*1vi}{G_X|xHbRL+O@!E@s~1mbeRmqr6GjlJjoA-;0+<7aKQl#c(7joXM;o^xhqiu
zSkyN@trm8wsYYlG7jOvZ_e0_|*eM`Z%o28PSmn6sUg9+D;7t1D>tT%X(9&P)pAhur
zZrJrp*hw5pK_4|C=sb)VejXaA_Rre3$n&xY>@huI$9w#~yVx&Ol=u(aWcp~NO0nki
zy}?Tr`Th7}KKio<{$}x5goF^D!t0iR>U#Zn6(Bm!+%X>HG9GetJS=xS;;72$`CYcP
z<7M43h+*WwMg9N$cK!N2en~tH72`xkh3!#JEV=YL@AkP)Qas1yfr3cVp4rF^gNdBk
z(_X}(ljViGx1}DN6S+Z&qw1~UGX%~O`j`ZUv!qagL!Tl+GZ~n7dKldM7sW?O-o<au
z%zAT4aM_;Z-xSRLzr@GUhixU%YjAA#ZB=&EF13)x+vU3#><I6g5Cf`Y-GA7x0Qwfr
z3k0B`ZmuVSM4!wD=DOsmSV?&{yo*omJ2<9(C`9EDRcV2BGMFX1OyBb_Q}bdalwqtf
zZrNz899Q7~A<P2`3lbtK1S%9-q%F7+)HIrMKs{;d7IZiol8;t)qo6!O46TglHm`-{
z#<!YL9NGm!Akt)J3P!#pWU*|aq5&<aWRONl`CA=jj@pyy(;^BYm#|+{$p+01aPr=*
zr4bE($%l-DYMTCT(Ov0xB$_>Ey+xRl)S8S*`8+(3`i5|89a~m4s(6N=|E2Q3u8*58
z{VwNrhjhXuGYiDK6gIe83$s}8&s#A4L6x!G{c*3aQr-riGit+OVw#9aJeNQGo3>SQ
z8$61(yCRf%Ahi;9CmO4fcCuS~R!4-%ZusIE^g!PLtI}K>UZvhXgH5h_59?H4rHa3;
zlbUuhm`W0U4GYpRSs|`6Fmj6Ij=+5a_no#U_f6;_ZuR<<8}G6i{}#Rq<?@huL-6nS
z)vTLz|FLm__2|eUnETX(Wx<zjMR(uqA8*e|Ydrt)(Oh~`Y;kr`Ds~8d#cA<t<Kn`L
z#UG1{|B3y#yz{@+53bHTrL%WPE*l>=J^_uvMW?0A?HootUGjZYgpUT0c}q}V-jck_
ze=^Pg!SJYCZNx*PMnexJ8PTHS3`F%_$%?*S!(AtmQ)BT?(t@2CON=hnay)DjF}I5C
z-CUBzUp{@IQ*YR~yXu=He)}U0`6A<++;XXLDw;z3#*Gkcb<P>#edbyJ5tmWQG=$GQ
zHq~6XN}Tp)!{gbn5tVOuCwDu?G+!(yB{JRKNYePmL8v*sGgo3Le^_TubcSZ<!*Y4B
zs0O^mA8ZUCR)6NFVRE8bw$o0~pscNQTo>U0b4e<u)>vF?9xk=sd|Hu=P|$|nAucCd
z;PYLgw&@A{Aiop(9-+5!8B-w-aj)yA5$fKUhX5L(F~p^#pVHHx%TBECk_UqtH|VPp
z6lgXNGd3kUz(PwuKr|dgH!b<f5|I5^^o!%4D!fg$9RiuhanViK8H%0Qtqt)?PArQl
zV_x66%k0T6>9ZTFtEy0kbWIgJM&@rOV*2Xmsz<7}t-9jXpGbs0@4PW24g?mi|M_yh
zLIAu*5d3T*0FX8-B~{aoVV1;+|1+{8QnPL|!Kp@XM~3Gd3N;Tl2EQ5k<W!;`@}kCP
z^s~$5Jtr40M|=x-l>BGw=n;tib^!aF^=lY%0QIssW(ztGp=P<I*q9=N`?SXQq|`vb
zEUBr0JwcC0pi3Eg!K{;gXL1+9C4rF}@s*38&;>el|0Iu=<%_ozc6vN+kFny`dpE`Z
zxm<4eGrmMGi27SbJp75=P~d}c=uwr4wTQ9$gSSH8Pu_9#5QlC$8B1O8@we7NcCaPy
z$g@l3&8_2AD;}Q;mcPLKjjfOZZVm1nB>+_WV>t4LlRb=bGp{?>JZ@b$*)bRxT7HoE
z@ZXh&70v2@x7*#lJ7fGHy<5MXNJRe4J;$kFwBZsJ0#{*+?hzYSk*{3wQ3Z@XAW8D`
z2KeiUngglI8m@~iPJ9cN?<cJk1_*`KY(lcib#XI;a@@R)unOaxDper9x67%ggJ4ZB
zNd!05nvPE*w5|lq(4Uqiny`1&ogSgum-7E#Idzx<xm)6dv%xbnx|ug3(0PC%pVDKS
ztP^96do@F{7hh3ihhJcW$vXims>M3%ELd>0daa#I0ph~DwThD`WzfK~meHt@FT!-?
zPAE#&Ud~R+$U%1VKxB_n>eBqYLaxTZmwKn5qLZFN-y=rIe)Mh(ypn$omDOOHJgKF7
z15C83Gd0Bk*h<r<R(uCj_l#{(HV#!x!HtAmiO*|UuzMI~v_qT^W-S_NlPaHiMGEwu
z%06|UR931K``VA<ugIv&$9BCr?G+;;70+P1J=;}z<t74l>4<D^s9|#JJvHJh)*p58
zG>xQr9$TvN0N)yA2_bvp0*zVUYgX)t)sx&WN@x*c<J9O#e8Oejtwd44vhWRu@8(=~
z%e-Kc@$*W9^GffPw(wJ%5p~s}U;BU&jX|4*wUH$yv7}u;x|7UkTyGOrteSlUD=<|o
zr2@~z#MM&ZEL|4ri{_5@jrzWu*+plr2@kWsS@pcG7(nMGtqgyDui?5`C0`jubGVqi
z==SsY;I7wx<9=r<Q@NC-{&}UZH%Ezp6RKrqcI^A#Frp<avmB=_5}(2MuF;^3CaaBB
z^(V^jQMp_X=Bpn%)xN5NJF0PEY_0UkTQjv|hztMDSboDv-U;jlseYk|k^6t-+22vi
zHRNFcIrfY`<c}!?1<^PKEF;bbHI|-B-umPEqpW^zHiVjK>j1I5SsM@WY!J7<6|90Y
z8Lal(e)pMOmSFiwxRSn_WYD{CfUEOWuVt3kT``1;-^OuOV6TH&hZ<21^hx0luHSrf
zsS)wd$`RDh#BPM@Jf90vq=5>AsN8sKm99A=L_gbNQ6Hl{mTs1ZL!9;OhRL2vBW>Xk
za;=>`KR?-%d<7%aCNjrX!detm$4(xDAl(0oD7fDoLl^WD3;Er7i8RQcc4gkFk{Oj}
ze69u8_`D~+MqWYxi3#dnuA_?Eg@T&k?F@yx-;jbs8zP%c>Sd!ho~tnGtQ6Z>Re5zF
zEQ4O`(9hsZ)~lo!NnDVcXK<)Jw4}2RR+R5cG+&rUNw-R<er|$uu$o8dv*6HO<r~i7
zwjO1pHK9fg2`*8g9+%$Eh3<a1;S!zUad}oHY|rzA{c*J(<qN@Kd*5&DkMH%USglca
z?K-Hp+axep^WK-e`-BcA1#2gwG@?TGiC*s_kyY@TNH^f{u-*~F@3Q!Z+vf=n_&>L}
zs@IG|E)38vpWeRGYqQxEIyQED%f@QpAzwc$-gn~~=VS%aGWAK8{RKdXUHzMDw<xVc
zWkVDt3o{4HQW?ibX@nvL{YbmQ`+dc>MU1q;K)bEx>Vr5HV%NksPw{D-t45H_0BONM
z>I=5{Dy;4?D@~aKLfR8~YP>Uwj%#CsX8G4@P9{$KyT+Pca6H(wAHCrHY|^Y1CQw%!
z9Jp(1DD~oRx9IgZUr6zm=wtQP{QkJ_?g=X|*=>+kx<XV$$j==z$dDGFa=Tu`(DG8`
z9L~_JFj9*ASXfA<NM!&5az<xvfZxub48aq9Fi(s(el_oTPQ{D(8Lx+^;CspcJmOr=
zzV~&|1#bVdJ38BrwVo&3=^=1sCsJBI&^<|M_DJI`X3iu@MNvVNC0P}7LCM_c&=5r9
zK-bTSM@Eul;ZL1YqJC;C?sa?KwX>-$j`>OP)%dDyNbwd8yQfLah<enT*hS6IGxR3C
zEqQKHM-xqPerDPQ)abLDZ`=oaK6u%>7`fs&De@)WQ|pdi2A+VrVm#FTVF11392f;$
zslB%6Kn&gwQWy?m#LTj|Hg~2Qf$#lkc}KsimzK_rM|t)IRY<m<$_n=Op^3(AcbPkA
zc-nyQJ2`nu%n+Pi_ExNhrv(EtKc@2hAbfdT>G-}tWJSsI^*cj3KVDcnhT2~_WfJ#`
zQ!e)-|3TA?y34AR|7W)hNOkBHjz*Vc4gZl;!^<oX&u{O|mVPoi*e-EFxAwQw>`;rX
zApi5v67Hv~t{mSp$6s)`A~+;Fsw+;`T$C=t^dg*qk(*g)JnNoEioBz{_Q@T2xjwVw
z>vvwyN)=S_{$WE->=l59dS4!ExO?h=-C$C^j^kx{)*30;uCX|k+HPN&8kZeuPWWVx
z9xO{JI5hpG6W#Gil=1L-ilT5x$#QWT`$B%Ot^MDT*1eWLP6B`f@W66ZN5Z?vc6CHJ
zeQvGGzmWv^`Aw?avC*5OLxJzp@)nhCCr6@pL^p(9nUF&0`5)MZZeNuG@d_ozTh6<!
zfzF#zOv0D12fY5f`svWe(xNSp;?CPI<GDHrBWn!n+#eBF?c=8$XF5c4E=joCV0`U9
zlSONFzxD3&{QTingKW{6OADzVk(1DtQ;%h<<1I@$`o}~86GRREfw^co9gIrhU6-~9
zd}1!3?2=j?l1nO~_c!eF)m6HETLZJ}B2u_HTDSu!xb;(7ECp%zmz*_?G%H<vhc_Im
z6m1DM{+^qh_;^WS<5}3b)pB9tyj{TN=(Te{8<La0hXwq3`{ms4hr*;KPQc$;bz$<x
z^W<|8?7czFmn+(ruWw!MpSY(RBRsK@wH5zsSaxC}S-5bl$a(70*{O`DEzLK))BfF-
z9<w(I^nK{}Aal4332V(n^gKR2aJ^uilc>!03@0-jbGP}OR*tzghtwWvb*{gCP)hCm
z;!Z=yT{A(knCsBSvQ9H)@R<ot3<9!;tLxCzOsQih0$K4BS0C{^j*n*Z-)3GbL#p&-
zswH-wD&r;Sp?<`c)8pk*c=7@fmURg?$sl+0gxaSE$PIC`aT6=esB2FqZ%N!|ch#K_
zt44{)XB>XYNwnfRv(l*=?6)(pa0Di0qTAdr?J!_Xv*y~G6f)=2z1KT!h1~QD`bf(<
zsIz?+yE`-O`W=+nL!SZS*o|yed5ztP0wW!Dj2Xn#yPOc0!8U>I@y?Ft;$M-#lyG?R
zM8-uX2TB3QB3J<>Ik2o!fW+Ct*`|<ecT5?kF)(}A;LsdIt!8bZcE`8CHo<7q*O`5f
z7upKS3YRq=c^F>%FVfa-Dc6k1pLx1VaJDU(m>!HnO@moBD@7qgSCo8JP*vDOYs88s
zrw=G-W2I(xm;D51y(iVCh;(RRnjWlc-#pRpCU2KOf$Ejzu3K_F0p((cZmVVZZp1b>
zvVjw=vb}ewOk|xJ+I!!`!8EZ#3<G?_ajo&(;HC=g7%^qx&6*BJE2)~D@*+1KGS3^-
z*q_#78;A2;fRdyV+|#o%Db#*LKb89v?28~`jR~Bukqb<Sp4t|s4h<wvIo^^$NHgL8
za9kNYqP`z~6Dg8B0nd`D%~YYej@)$aD59SbbQlhtx?Vlfsl1y=d9n%3V)VV5s1GF}
z)GH-|-jRVOa80zc!T|B<8kbVPBSj#VMp8+RZ!_HB^o!S4#N|f4tH_Di^C|YRc<|oG
ze%B<xEdOQBHT#Tu@AL<P^eZK%W87UKOAwEtONsM>8?4L8f7EAHo&fR103Q+ol1k|p
zspP^mxtCgSwfFsUxd-+?Kp7pHefBy{Jy*QwtT0^9FOehG+>~hVH0CY8?-D{<^J%hu
zkKlv~txyq~^E6~y>_ZKV-IUG-w0yOmgYGpSDt+9nVYQBSUG}?v<&YBB1aYL@h>1fP
z*ozuy5RQ9i1Wyf}#GyP<&l2a;K__$?RE8gX*I=roz8tknnNQuTQ^l}s5ZSP%{L%go
z@`MviKQodZ(66V7Q&`j}Z(HKH41p;oX&1@8qjhQZ+i2EhWOBQ80EYF>e$PP1NXLEf
z6kbuP3O)uQu}gXwkuHXV$glOiV+VHcDry`x^HBU(o27kWCIu!EyFZ1?QHpgOi_b{p
z!!=1#>h;cNAhzsnZ1yIU%|<+z;GPt2YYN)wX(kXpAMQ{-{KK%s`QMAHz6Yu&$4qRl
ziH(rV{EPrrx@B{_FU#YSo^42-a%PEg;XN%d6zJtcCCAw7E1V-#WyQeMyeT%DXFOtN
z<#`ABc;SYxk>@dq0eZ+aJ-syNZ{3Hi5PDRIGY?|LcntBecT2l&v`H=OhgK3FoiQDI
z#2*gx_bRD_@VQ2(a=pHv*oL~o_}d!FBCn*Y=6t%!^rROn_tC+obZ;so2<@Hb;+^jA
zopIEgljP0K_0BB!&T8<^{&A^r2)w7?t3C!2gy_x|ed9xe<c`$U(Dt6)frv#wA(A<*
zWp$yrjPTZLr??XN4}E-u%b5iem=s(ZMIY&5|L{?K_TIl7lT=iHzT0JgU;R!&<BS&5
zTSL>kCW)7}g9?c!anE_=CZ?vj5i_#ia#CL*4Oo!85Z_iKTr(H$O>3~#AcTk`?A9}r
zt#WycLn(;MiA^_Kf4m)J?wH|KoS%gMY6Vx;X)hvKT7`$$O&u5QM`kXdeeKKaYtp^>
z=~m%}b`uRM{~8$UUXMlJmk;?^^F-!{vYG2LBu)0=H%}`?S@9FPPo8mZAI#Kl-=Eg6
zqdZIso7erVl@Y&Iv_bHnd6fx2(rYtu3x@(Mhe{m0xeYGwwC30h4X#-flEToRi`JjX
zEZvXGV6xzw!ls?=)rccJScb;opLdY-b;-l|#(OmgNBT>xcoO{Rccbyy@$sceO&RaA
zGqnruR8mYd-jLIxbt~69fr*SnM&-|>sf%@N!@5-CAPgIarqE$*9N$6~@yjtc@e((_
zJ@;ZsaUxx0hJT|{MY4*<U3uj^5aWiZm@b;vxi;4tIQ21+p3$(*F>=hkJCSOI%Q(A^
z{2Y}T8-GiwQ>XVn3iS1T<VoEqZ@%vYyyq%Y#~Aqo%xdfB2piaDq%@7HHnHNv)$3i!
zh}L36DqHYs8lVRza{u_ka#QyPin8uK3*7gp=&Y%BCA1*U#IvmZEwqZ0$gnNqi}3j+
z4}?6E>kC|P?eNDRTwlGMeUF0YX$WJD!Xs3dG-?|#<*`c&v6qDCIFh+TaQ+1Xz8J4q
z&0zj$nLYmpe)UPPY~wwX_AGPzKr<<>K{&({#j*)+IL&Z<V5DdiooX9@yEYLyH^6aQ
z7diWUv^jbvNszHa-{|(3AWv{pyDbFKTQ<H~?Sf>L$a7W=Do*(2F6?8xw#mGIq$+{h
z9H*GKv0fdfhw`Z~_Jw`X@$9%BX*To*TVM~T;^xXoZfPZ)Xawwi<zq&F)v#QKF4-jb
zFI*B0xYxh+?1#(z3PWsxt@|N%^QmjHm!8Ioo78#wmNJanvv;3x-Tlgh*ZB3HkSr24
z1aWHy+vhu7+WM;EPDti*jznju{NhCOwE2f4w~!*hx60@`|JsUggAu9rtaRV`G`XtC
z#>L26Tais-N17FnwCp@`+k8Qp!ZzfkHrsFwHByTeh}7t``G=W*tUQbq3ht_PUb#8_
z@kB$Bwqt8s5oH}55`RD09u5^_X(K*TnDD-!h*3Ud>&PXh9@KX%(_uf-^}U<>T+55%
zsKO>w{fMY|zEa=pwMTKtxPMXRhacud^p7h>#bk>3d@3?|z}_Gh9kj}2wA-f;;f52L
zNp0GpMHHFTim2eDBBJ8&ch(Fp{HV-1^7xeJ#OB^lhsPhhI2Kd$!yD;zTPT2<0I9a~
z&_75Pu>)ojF7hxU^wrQ?M`C(FNp({6)TN2<i)&-Ycj!Hm@a<Up50qJ*NI(ATGuch8
z#W!f%Vf5oZ!p8N$^?$#j{wtOwe74N}^W+pz>q|o1r{{iLWN1h0CKDGgYb^32eadVR
zo%_wx%td3Vd3w>@tA99R0i#gWM}ozDk3FA%HP4j160JXc=}X;b&i7Qx*Ys<2k&~?=
zqriB_zs#Hz2%kDw*pAZl-qwY}j?-a&(P?5E@3r*O0w*$<jFtV4(Ugl(ayzcSX)`(-
z6s=G$DA8L<rp5yFl_bMeIQ(|K+v^FKlgD=Z>Vwg^$chu0eFd4p5jKH6$MWje8D4$}
z!mpzT+?H`G9PF<Je+@;oD$aRwa}dkx4B-EL|9JG=GQ|JbT-%KwkB)(#Ani4{pP>L#
z2SM<(lEMxww#B?S<>Iw_&8f30nFaB{;Rr2tB|51Tjod`U;WEoyfy2Rt_KY6<4;BSe
zYlV3-1(VS4Z`(L^4SaiR|B2Uo$q4LeT@lyV$ImW@Lo4aO3{gPX?%%P;krqm8(%-E2
z+pJo^qZzt93k~iaDuRuZOK$`3<VhUk;*;s&jzVQky~YpBA8+H&|50vEnGmH!=il>j
zxfS8DXQ7uDrXcm#q4UGcql!#H{jId$oOE3T!DUqL_p-jQCLzS-*zulYg`1}hXprZE
zAXAfV)*#9Vu@5lGNL=EW)+ul-as_WVA-s$PKKU5$+kV+cJrM*d2XWKE+U{qryvqr0
zoZ$NG{@eeZM&7z_d~5q=B39$IX$YY9dRdxZRNZ5@`U7&X`AdR+r-*B2x~43`9ykv~
zL)a7P+tM0|<t5LAjMKG^Y6Jv5hHFD^J~~mM-~%5U+sMDx_+ab7=8XiuFN?=pkzKq0
zCQm>qdTDG{`tI@s!LPQ`yT{IdtXBH+XO)_&<LCrTfd%b7FjLM2J*aF}+V8DQPf~;d
zVvUvMd@|EfTtuX?@9weC`=2e^PmVro{m<YdPD5Xaw)uDcY$<Rq1$PeM-nK_1fA1Uq
z5hg6QZ%;UM;@xf@<qc<<2R_gY9Y0=`)MCX#P&I%~HVjK~uG6FHC2t|XT>Ic@8ek1T
zw$sHo=E*`^<~u2YHw|b8-@FlzSGLU55p7J27z*sUV0duAnz%~oERsmxGF*FEZDEb)
zh^ktTs(SE2f#9DTC+aP)?>KJy{Q61l*NulCvqiN}>AYzPeOdLsOh@p@9E!)s)ubzQ
zhC*)CpaECM$+U-CpOn2JtisD^^y&^j$csmblX`(@`pw`5;D?x&@nyG|XPt@oP$_33
z6+c)bUcB?^p6V};P6&V8J_I@b=pka?5n<!xnQv3|Hx6wz5<7I4XL`>oyEZ27Inj`T
zIHN2scpefzau#nE>Na8JFMeJme7&jO19;M#vT3==>kAXNk<AX*AAejZb8&{FDb#v-
zWBv3C>kmn0pLR1`==ra*?fT4AodMze1>Qj)7vj|Z6&Dq}H6pSE&o=oqewnL$!MiF`
zy~;$=5Yj0Q?1SW5(q(>Cic=Y1>hk^Y6Yo<G9p5h*gJB3eMu|~LR5h7nt=~_)39ZR(
zle2ceeyS|3l&M*8Uf1T$r!Y{kLx}gT&#PF|Wn5a2Wo1OVYBW7`W3Kp00`kixi`tTF
z6=zr8T)QH1a5{&!8oWY~n<E;E$qfiWtZa*A32#Npgo)vp#g7vA0wc_hkO2#>d3t4?
zl<co*nlx&joB^$jbh8nrPrRzMhVsJ?Dnu4V);YVq`gZ!k)<s@@GU3q8=01wH6cAwu
zMv|E-)^J)(V*Taw0TDEg!nQx?iSz3`6It)W-)y}D;tb{N0_Kk0`E=C(a70+k>d2v6
z4}Z@*kZj!8ekk3_fxW#Y5E1ul>RgaI)zpQ%S1SJiZ6)8_BmPla@`=cUn#)h5PrPgH
zQ__X2_A3|owLDd?zT7gPefwR@Gu>|a+k?AC{cb<sJ$w1~i){qK?UxoJ3avv{;{L6}
zRMB2r`9msmFoo<38aBjJJhvai3}Jr0Z9t6SgC|mX)?oNUKdTv|iNJvJUr!nGC*IJ%
zQ!VMrBZ5_&V{QBmed))8K@nyj{$4-jc~GMJ1^ox+#1o%R3=~PR+GC<SyJaGFZ|Y*Q
z4!jQfsT)O0CR-D#DGG(IlCXa(FL#xshCVm9dbH*IA^6G48B#*W7V1j<tqS@N;k$~x
z3*AnBJtm;_YP4LiA;DQu=3w9;$&1H)Y6fw*=%+liBQ{;07aTdHzZGtkNUMzxc9D;W
zpT%p2+87*=566TcugqS&LjSup81Q&QC^v|QWa5qtre9)1Qb{iz#CAqOE`rr^NKe-7
zf(O;pW5(3awz6FI3|evxB81bZ5MO?Unl~*iaY>0RPX-QYH2r!~jgq<lG%aqKC$IWN
z8heI+{jkBKqu)6Pw`J<OO)<F)c}jFK-$v;si_3^gm2K1Omy%^-j%idA>S;2H8CBgt
z4O7v&)5>RZ>HLCEuTm_vU+D}p_b4V+Vw*yS&*fUD#!;k#br9rmvH;jl;9l<8mb5Qt
z?~|J2p!Ahx-&Wd6Tdo{F$nUc_=SJKik+Lg_-ILvwqCP7KQJUvTmGG@O42-hwG7+Yg
z+WasFF?+IZuL5nL8OziWF=j>Jf4u-bNY?0%RJmkb3Zdb`I~tvn<)2BG>6Zd)mZxC%
zx&j6Y2a_dKiiMB=LU)WVpD$1`P<lr~{4c}{_Fh$5=8bE5)bICfSt$aAf8JHS=Yjpq
zs&^!DK*csDH*qLcHs%3V{xUN+E?z}}6)hRt%AzID%}RO+c*;$gW=;+~5}#ymdUzQ1
zC%%e=Rmj>^7o*7zPm#0Ihwc0@oo`bUC293EUs=kq@SsLm>Q=a&o~c`Q%sZ=U<j;9i
zGr|ba)UDL2*AH2}D_Zq8Rd#HNYXGLZ)mi>5-FT<<2)um%1QBAaFN>j!d?oI&#+gNu
zI6M285|0FADGOEi9dokT+e2OSMIX4V9wFm2grw+c?@{_0Bu)P=;<BxqVi1Td-Sr@)
z*Y-jmy~AE<x;JN)-Xgje5b>8y05!#M<$h@}|Mez6g_P{_o$(O4pG^!>n#EA}JTpYH
z!-JIivKRb5y1l-y$iC5a=QUZU=)7<LG;W?aP{mz>x(X;okV-rGz>wl>R?6N}%23;I
z_G3{S73@UR6Q^id);?TX!`Aw&%2xhGz_436!CoY(o2fP+W@EsroTSU2z3dhrTnfYA
zvhZc%N;gFwI`~J@${cyuwt})CPoG$rme{X|?(Y6QU{wmHqcv=1Xvsa#B_mT@BE9eG
zL|+iueZe8qU8<8Pp<*AZgD<fl2Iqlz);oSTQ#^-9qF+1LzTYpEZD0h}Gc~g=6=HJa
zYrZR=g*Pu-MEmh*g_(Vgl2=TgI&A0d0;!E?LR8qz>0RpC7^#p+kG3hEF8BuG!;sTd
zR=2j?3vcs}56|0BQ(UZJe6jv)w+2#ctz&wSeCB?`-LSI;PTm7bU+MBe|CknYI^E=x
z<MVXDpHtZr-U-WZ_V`COWe@e4zv<K~JLIpU*}+u|xWE1U&*6obg=hETFWLvFLti>a
zzW@nDDZlW5B8+iXh&Tqk$ltEVSYN$;@(sE1>G!~ioqH+<`c`r7-;+rX@VC&5u}62n
z&-9N!^A!aO`fmm>ADDhf>iTJcyC+Cd>_Ks_yTuy+!U()m)ZRU{%kb<H!lJfJl-VnG
zawA9P)BaLg*r!S*zQLT?ewFgpv1>7#LyAnrcS=YsYgfidbnJQ%v1T8~&N1m5P%}vq
z`PkZV<ZxBWcV&5|23XEl0;>m^lHM-{ND~XOLd7qV?Zk%mRdUowzoAkSX^_NllWt3#
zKzY8jGeiYCnJCR+n^O7|*GJ$%mzRPiKJ@us7qo}z!WC{E%224`!R&EOGEMb4<Dk)>
zfS*-)^1PMFg*|U$8y`pond>obDzdJ>HCs{EV*7)$&De45>ZoOyvG3gZn0KQl`TF9<
zV}H&=Z6RV=<#uLUozF~`T1e+*cfj^#<6ONX6*ra;kKKwhJ_#K+6|5ZWB8v)OX|}S)
zqinmCFjt-zLsC)e<ULy8VcaWh`p?FTX1`0Tp?)V`5U$`0X)8=jxTd;gs6WTdsTAI1
z&Q&aev*gsAc!^OW90;;6M$-Tl>nCo^=o)AT!Bjo=go~cohIF=e^Lj+SI@?XDdThz`
z7`zi<M2jf&T=?hEZ9$czHFcQ_0%#o{dHn&uEBW2L6lD`Oxlrmx>;L6+$y<UA`lLu;
zH7Z+q4pj0Sg0G<|0N|mY*4EJ=#i>s88K@k|l5ih`@97k4bQ>F@Db%Gj;(PF>WJ?xJ
zVS?lhna0&l5m$2hdDAjgOxYEVYztGamL$A&k14-hW;!}3KRK;1!&Lk>t+>Ke+MHGb
z2a-@TBtjrrc7{v|q?~iMt^p~e9d<CBQC4)uy}_{f(3>?A6^trMTbV>+ib0KaX-)Uh
z;R*GOs<ZhsU0jF3v8U>}HYLGT6#|NSg^WZViS{=&;mr(fF0h9IeZD^6!yR}e|4h$7
zVh75LIpLmm4@5Mv)ZK2%#o>0DDjV7kMmNn|_D1@ID?f}=Hb6-OJ<lx+aZR`$lj7MX
zB1ZLdj%gnH`p`2qwz8LGr^!RB4-*diV1j*JMENSNlu4Ife78P^K{K@6fniG!Ew{0-
zdSmZtgAOu{6z`iEGP2gzBShilekTiKXPWh#){3vq{TVY$0$`FB<WG~F>a*h4IF6Gu
zaUhuvFPfo<li4f%j(29x<SYLDFK%Y}K!zU?gOZo#>Zp)gxKH#`UJ8yjbVX$cTla3z
z1x@enYCkJwOvVAW>%rdcgL!k@1D%)uS?SM%{Z%eqeE-piDq?)_L(`p^=ZV#KI<AJN
zW!k;CdT3nrQt+IY<<)2qm?j}<3uUR}Is>ZG?9BSDaB5lGv^}$a>2w-{-hCFAc2)FH
zuvz)RrrE*%>hADR7nYX`J@A}KhzC2gSN@a7uaFE$xt+aW1tL4Crc<Qo>5*PFS|T}9
z0@V1aTd6Qbme;v_vs>simm0?GJ8P5akMbB4%*0X#jUADftgp!|+QyEkc6&dyZLH0B
zlXA7E%keK>Wg_Lsigmm}Xtv>%Tug>NmGq#}8b8pZJCoza?(6+a*{h}+F2%(DBV7zf
zL>{}AaW%!L-Y%kJYUcza#axQ^9h@~Jdx+OvWmC61*gaUKB4n+a#+ZE`74AE)nxpx}
z(s_=vW$OnE&%k#sO3L65(Cj8Gvnbf`w(t`D&nBIR+`8a5E?YbPt=Usd)^9{NCUO&J
z($Wx`=fq|+t9%Rq*qIRP=zk)fjZYG2kixbr$BZ@hkuIF~4!7O;DnuS<=U8)(WLI)3
zn8TibU`@BP91<F9MPxMhS;Sk(3|*P-5oy(XdwD#9QTZ_w!ESCAA>nBFsZM=oDL~NY
z{$0a%-BG71CxW0E!<Y%n=nu^Z4g1BbepJ5!2)?x|n)xxz)4<kiVrH!CxjB(p08j}P
z?DKOqpWvj2+J>}RosLkJ3Z3<5_cgTiSRcNYwsbus@=I;3B$F5LS5hTc;YPN~jq7Dy
z%LhIicX$H_Li8Aj{kh$kJ6X?3SI<%G?w+!*DTcT`a@3nlizH}!Ny2WMI9-uV8*jaF
zMS>=)!&YctC_JDQFyeff%eARZe|){Zwst{4h-%~>>7+z;ncDbkMRl9%*r<H%cKqHm
za`lqCj>s|u0+2T#P#6FLbTj}3AQNmR0w9Ed2twYzX^LtT*Gly3Z>sF(;FMt`Fu>}`
zChm%S*WX;-cb;UGCGXHu^Rz(2<GLTxJ*zezyqa*LJC;;(1cU);fT>wF`FoSc<sA$8
zt`#-~TK)sA^`qD5MPNn<?r=$E%rEHBf&4%lKESnBc%UEkq$zmxy8pAbhPQXY+m(5}
z{k+S;V0EVCM12@tlbY0(v~cm-R3}$l`|zMi^JPFtMXD$djSuw+4UpeAC2L;y20tv5
zMBQ)wI$GxuRu~xa@lgmU3qfeljB_*r{YsFHADh{~BQGOiZ*jymfo&_|p#FiVOHHOC
zLPxKChT*`%*zF@9Upzc&6DIttAS}4OliHyh=+m2WQ}fL01?I>GTItc7mq%yL<1hbS
z-<%h|Z&*9bf=Go=rBId&?aYMX&^HuLL+fGla!hcEjc5F}IO56omKPSF?Q_2|$vFP`
zE>Yv#KF4(^-WLLP_G--L=$AbiNaP_`Wt>VPPD$B-OTlk+!72H!z&N5cm%8O`fX|#p
zsFZnM9-j9J^9-&3RGhQX+Ha=1xaz8E-<);`sId1+qYli$5HgX4`ul-TP*yJWKJm4a
z`FvC;@px}cJ^mD1DssNk1vCUJ0hNq6#e-BXRHT7pj3%l7QH?*=g62es=ibKKKz0bn
zd_IMGQ#OZK*W12*yFr!|4u=9a)`HR84-*+9XFzL`Ou$pV^rgu(Ph6~dnrjoNFFn%Y
zx>x(cFZG+4PWvBsCPI(kfYLUrG;f=C_g+dF{p{!M2Jy4Cc%Z4UL2Jn;me&gF%dYOA
z?fr1$zegNL{fkB{e|1c7VQJ~xW9Y90!M^w&&k3%)t(Oxpbl9twYPam9@mT(}bM^gl
zKahZ|ckrfSa5v6?JCIgGrjz7aMC@JT<x@Q#Y!PSW@GE6m#b@t78hA5gaW-mg_}xKp
zRf5Qm+XIK?vSfZfc%5rNH_sVQP``a{*fORS;*x!o87$0NdlP;U_RLRYIOti8b~E{N
z?HV3=OY_9B`!1?rAK|R4UUlgTcF)>{(Bo|$TP2Z`IlIk?L@tByl)UrCD-YSsiI{`5
zkiCl=U-+DzoAWgnk8OUfyVkh*?dILZ&4s4EoqxW!zCQNnNBft?KZ_l|7ytYxfb0HU
z>XAPFciAVBY}e`JfX`3}hRAyl{W&&mt8lPH!cLhN)oi1jKUA2n+^Z5h@+&|7<-_%U
zW!E(MxAG3s8qv3`A<~aodjiZpjD2)_^fy*yNAEONEj<XUg0zh%rEr%p7-eflpM^mP
z0lJx*A{G_!hY^Y+9}IJVKDGM=Tggr~tJaa8_1aO~rnEOlMJf<wt=O}M$}Ln@I;n-k
z2+3BmkxTIhNgNB|Uwz~bo-?T<Fq1oShpXKWBGi(e>;J9HZIL({0C?M&SPp0WF4qGN
zi#w=viNg)k`W$35Q<Y2XF6eJo=Y;*OT$Uo&{*t#NoeDzkG)+fX_-F%9*89p~A#G><
z=Sg6<e0xMQd50g<D#ISFES$EtA83wmLSXMf+|!jyqg1Uo?UZ(}%49j?(>M=akk6&$
z9)Zl_3Mg#V@L{+%i9&qK&j^97><fyvk_k2#y9ycMfY0cu99{1-gN%qJuh}`~>h&76
zH|O|L14(&Y=#JJsj%;tsOH=REcHEa?9o{l15pnozp!s>wiEw<ot!{TF3n&pi8mpT0
z4sJTn5;pUP$i!~@K8qQB3=0;N35qAt&gokMg+WSPEEne~eVoDNStYkW9D|y>S3e-q
z&?it-`MPWQ|KGq)!qT$dD4Z|S-0QSjY0pjzs@>I4Z==6Ck}K9zqan(2^!fH;DuH5_
zW`b5V{^?v4&Xk{i+NW(jE@@ZDJqE>SX`o8-yjlYlR%t}QQWi)yNtF#iv!vSbia}E|
z3adWWmFFZbg|h0Ty__@U7TvV`S(d~}x))$f&SC1=S3!Jim}t5F4amucqe(~nvd=i|
z<z~tT5PkL@mgSZKRMENkuO_(Rg6-;y)E(Bhy^$%C-ttwKhkW6(+r+oi!tct8p6xI8
zKn%{CJHphq{~2vl$-MvlGwz-pNw3kv<k+Sn(#;%{^~$n2-a$$);_dZ~CGvC;*6kal
zV?a)}-@xHmnbmuCW~jP)+E^Nef$POVEwiqaj40JX+!d)~sIv_eGlU9w`tLNi16L!n
z`qWBRDsj|YazI-ZBQUxS2;L5cDR!BRT2?J%dv?y*UJdM~;{IZxyVjM&jQ_)Cck&bG
ztYjW+aJW7z(tDz<A`6!a^tWPe=lBF#CC@)68LMP2m`TWXkh>77^X~P{cj-2~i)js0
z!)0dOS0}hVmN#jm876^N%l#s>l0gsk8|xQ5CsJc=i!N!${}Ni<FL_DQHh7}7*+=0c
zu!`pnaF)D}-W1Y_*L5iA<gM+xwjz9Y>>-V-8?&<at}dL_jv00FNkv2RZ8<Vv#2Lm|
zVuyZQ)%iQ~yF82)K=yD4hZVc~T%_JUq{{s*0$|NW;-v}07KhQS6LZzlQd&oWi2+gX
z{1n9v4S20W?{Jwt8TV{y%{=eT?(aJxV$Q|RH15%F$KU_~nmBpZBfTndu9&j&oKvUM
zm9a!h*!AY8otzrMmlnYBe{8Zd&QCID!*I~zd!WPZ*{QEIv9xZ*o$lfPnE$1Jd;9jH
ziioAS{>4-8PN?1zq-V%AV@ub+KHgy2xWYi$*2dw1AfZMAP}N+@`K%uVTDMA_YK9Be
zI*G6^7mQ_txm2PhZl7?sQ-)jKe!nNEG(nvqs_WB{LYn9?seU6_L#*ZBjxRfNHU^I<
zvMzm*pXsU|n3`~-o-qu3rE*U^tGRh8*?Pnx8dx-ASi0qpE4Y8&BhLSkRGcFJvuoM9
zxzaMLx@Bv&K+B=Gc4j&vIjqb)Q~@!k{!;AmXqaM(tNui~`eF)y78|af*=3MrmA2gi
zOK6|Zn6I=4+R68RxLd__<zowXT_RPJ;Klk(4cy@d+8)2B<hD+)`X|Z~u!sz&Fx7Oa
z*#lSFU+;5m?)>u{>xzn|{;zWe7d8i@^HbA=$}4)7>^N1?lK_Nh(g!u0BHxy0icmhB
zuj@(QQaQx4QUvgv(DT+?Yhg)X6Bfjq1=}7zm9S9lEX+1wWSxa0rVvb0B)n6k;!}tv
zDYES;@)IeF;d^}nI5H+#od%1e?`idb9Hqk}rjkh@_)H(vi*!ylgQz!;*mjXBO=xjQ
zq7w`wNGGf<+C$7hEPjfu4gvz2(7#DWYXZ?vUre(ZqL)<F=9^GCYJ{#PaxM=cM>(9?
zoGu(n4`@&25MUk>ink4L_vrCnw~vE=pX4>GiQqARSf2Hx#|zXIRhCiq>F{ZCNai$W
zi;7^)W7**uhro#CDfdkw4HrL(j0S)>hSx@ulMdPI4^E8R1dY){Rtntq!p_!;Bl~cO
zLpYdjikk+4P()IT=EDN3q_dW@gt+Y6bzF7}Y85YP*_yGiB7Rg)Nl-^X-9D18Y;ypz
zw_8tXQI(Lwcd)@J-nvR0p2r^2%iW^q-mg>T3}IL-72y(h7<7U)Z)nwwE(b^6-Hl60
z6WtN3;LbpFMvG1kp=)gZf743QYr1z^u&Zi>Xdd=A38!?yT4Wf}&c}2Qp_{4Mpr-Tx
z*3W|?juXG02Q+z5P(HyS-)0=qOqGPv5O?TF$a}oF6|C5s+(WUVTlAd0El^8gT(%Y2
zD|OcLAOYS@!hA|$cG10^RG?DUxGpLOg!6sO^S4_K*`j)q-Jmb@F!5uUXKFa#DN*mA
z*e7bZ{a-P0Ry3CltgBD4$Z%1BPt@}}xlkJQTVT=umSFrM10Rhsy*yj8f|pddH4}=x
z>fB6%$|xh{2;#buz<F;nNFa6tK#RfBKy<OJdzc#Tju=+yr)}*pi)y`m@e>`>*(9c@
zj!V5qE-A&H^eWwXr>sG<tR|vt9t?-t;R@1h6E?IAkvUo72VUa*9k{UhCe2ULh^}^*
zFH_iMzDp|=onHf$cqJChz=zNi{^R3<4tlQP9P$!$IeG~bLV>H*Flx0Kqa$h0bda7N
zE`JysF9JHaHC0g#TmdmE6pAYtnz*dr*q20LU<tcKJ@DX-mVr&)AZ)wi>f<{UsW~hj
z0JwtjGN0D-V%&U__>wmSg+^;w(a|G*8o2%L36liaB`Ug0AjTL!phcs6Zz}3-!m>Xd
z3DT(gL#+Z)tDS<8yHWbOra1lUJ7ZXGsS>b0Xa;mr>tVz>2^xBpDJtsA)F8{Aq}!}k
zhJ?mA)&%1(0F-hg-1Iy)QJEp6djJfmbG@!R3;l3DYPr=;WY}*(#@7g{<Lqz^l2Uu^
zcP)f`O{5t!J?zt@r({%8!)>{U_$J=*8#^ZC;|{8k?3vocJ1Ta~L8*oMHPI?Q>NwF=
zY{iuLPPj(Iece{LpLRZ6?n01ACFa`KvV>q<WhAa{6MKC?t-;hvh!b^Zi3yjEWn8Z@
ziZ~Z8Ak9trpZ=VrrcYwVcx(*u<33~ED6)58lvpEN>?dr^ozqX}^+DgTZr2FYU$G5(
zxOhFK1>`{y2i*L9+_Y)q<;X?|O>{LzdrOe_I7<WWi@SBEvTK9FnHG2YjkRGARSmHR
zsYj0SCFz<to!{6<f%qd>)N;SB4NL3~E>V*P4+IzOy@M^*#NprK$VYIpf3Wgr-4va0
zNqQc{v$qZfLeUwp!<wSuO^iSxzF529_VyS~WgTBvWSyrc{Z1gW{stw%MBHNF)z`My
zxlnf;8oFi!mIChcOeQIq8%=u-4PE(@ML0i)-Izjf=n+CH_N&`*(UdmW@*U>hwl!uO
zME~S!%7vZU8VTdUW|9uOua=07lxe4kOP>{$LR0!9^p6RQbHWs*reV3>q2fK-Vj&kJ
zt9Fz-V5g%+bLGSi-6OQKJQjEuId{G0`?%^uxbg+}D{}WCF^C&|wkL0>mM;}unmPP#
zDkJ0WA){vXf{S8#EGhpK_zM2u097@LFB+FBdUQz~phvY*4JTJH0X~?<g#%A<is#kf
zqj#{odOew~xOdNRzC!v#t2oh#x1?Ra+>ZXdzZpxe9v}onBg&@`JQf`C%`S=xPi5SM
zEJIK6;L_3xAr#{YFgy?Un5*~Ds1jCIKtOfu!Q`U@V|m~9vbt+bq`Z-GY`%C@l8(VW
z!aQa`AS%ZeLv(b0s5P;&N|7^A`b3ITGh-=4rQBekn|X+jn_VWCyG=W~&E9pJ|LvyA
z_gI?sSj+dE1(3182?Z-ygLluxV8l2>bj<SzW*FJ;OL(Qu1TiqxP3I`nJCpi!-RYR;
zt=RwcFh27={Z_EOYHG4(PpFf(6+uxjyjY7g;Tc6RNrC!hcnr}WN1B<XE{XBHayr(r
zog_@=b}p9re`q@Qf2RLG?!UJ&bDr}YHzVis`E1NNYK}>ACdZmXQIXl0k@G2{oaKB<
zqSS}Yxzq?zl4D5}Dp9h__quM^fAIe4{d&HhugCrVK#hn?dgc0@_}heuzj%Da@V}!*
zXW=ZNON9(zBuUJuhK`yATt$q=>u%f-&FAfxF@5k@nt`JVcPL3jJ8$9CYVx>~`NoGx
zu<<3Y(|6sE+t2KD>dBjVp0#2^uW+NMSUYl9O#NV8I3Mm1%>_EgYz$H#%ap3dv4G+*
zx7KpHd+P5mU2rb+N4vb=@QacBwj7G%2_(naIMUpwHp#=LUJz=3Q&RoO{eh+NJ^{50
zBq1XK?gY5<mSVUkn)R?RN;vSwmXXnb5j?d|{)C*{zWFkcS=F-r&X1f60dM=flANx6
zf?9WSJ%O_kPLe59`B@a_$*{hE$L<1S&--{uBTEfA0++ZaG)W`XGe<r~Xji)AKfSlY
zcdp(4aL2OVt+=!j`87?}6cjCumdR_E+5OS+rgB`^L5gw2?F2xPR8HS^$uFC4{?nW+
zOTI;3Vhz_u)~NBX6mrZ0e8)?irOwwU-U~=8!+R?22MD6R8At|!-Mf;V$bvWL8TPEg
zc<|U9`mhATC2Z1X`&VB<eG!aP)mXC;O##kxa5aaC*R*b7dXD2;fR$>6-f{PMw4($Q
z54X{iGVFqJntP_AWMabR`>SWafut7+jv>vHjCQtrbXc&DDp2vZy2Jk+UBD8<8t^xG
z_{NwZ4|}bXp8e)1XeD@=k;}!#!?rx2+b3>>d8RB}&AF@fUV3so!8Y}2;LRvJ_aQD^
zf;l37Mh@=GA?(b4h*KA>9=t$(qUxGC+%Eahaq*dWGjvxty#HKD8t<qPeCk~RA%Mpl
zSH{3un&nCW7`#V@roj(^xou56ZSH~-^A7&L=XJ+zJdG{O(6R!Gr@Fm{%f^PY56}|<
zI?KIY?zDQ|{%hQ<;%a)n^hC@}PTnGm$E>~paPEZTO-jAKpxv&VJyk{bB+eZYgxqlE
zf9a3ZFB{gOo=ykLGHY>v5tG0vybb(?+}dM1`-yu87k;gqoWUZ`2>JlvR^Ew=7x$eC
z>2Er2=i1r%;J`5Y)Sb`zdc^tO%<#P``(gZ$jJo<RoYr)=cmc<9Ax@JfYs$&XeG*Z;
zyU+e?l5Omh_4fq12*A}bnk%h!gZlrOK{XRWUmVMr_y(w-`Oj~bD17^ZgR&)xC2I+$
zr0|t5-o~?K{iVdV2l%s~()R5AQ{r1&Z=Y{#fj=)CZ!bxFTQT{z=JoB<t#2Fmzil29
z0{V%iu_W&b<`toQ$vloVE%=Vg_bkl!ulGe#;hd(y`rhrbj?vr;{fmu1zJt7Z*$v3u
z<RaHx?gk?`=SLW~>ZgBRBEIx;jx&PGesM7n-MvRKjSqKAoiZfNC}ac$3Ua-x3s*>_
zm@)3})(%jFYX@*07G)c0d6*KgZ)Jo357m?(s9k@x253VlJcJJGxcsxM?59??NGb>C
zI(^q)GI*f}eznfP+549qH!l$`;fV{zU+3}t&h2k%aUS`rA`<q3e*UwAAknRbLp>eb
z$45qS%n~>cY($FT>`54=G$7|S?qZm*7_Cw`b!8v_`pzj3i}*;6T1d-#7xs4i_gmtJ
zs$<{7xka9H3e0$L;q~BAxPrn|Uo&}*ne>9VlYP0GJnrh97=Ml3B-g7q<jOztp8N7=
z0)JM^7Rj2b{uBue(Er|R6Dc+pJm*sqD9Rop!s>^HJ4wMa<>6cXY#oHBk(`~vj7J=A
znLUL&CB^q7{{oXKc}LnwtTpo#_M1m6d4JECF_E6juk~j}?3B48xnDOp<i;=qJgOK&
z4GVCNuMlv*2mp=#`w{ycM>xY+)Ye-6{;`ehv-j`eEN;yv@07!RixQ`GyCTK5L+4qi
zx|hL>qKUy0=g(*E8z&qyiMVXwsw^|_*6e?ubG#3v$ID;){_%O@eG3EaeeMf9fKwUt
zAYZj#K_2bPe31IUSHCe+#Bcm@Yh`BxVYFUeQ$@x3c|yL*_RT4e=RrxFNUJjUUBBVX
zgy$Jw=A?m>qz-)&x{ItK7u*SLvhUriNd$pGa8@~j>1oc9f6+Rf=>x!bhSuV2SzB|!
zqKu?&QP9KR_?4kdq_xEK-Ko`!|G9N&U%dddI;DsF@(}N@PXKLZxcqH%rbQp#DCyc$
z|JZ|Hqjqpx8(v>sCkS15FLd+x*73i84BbuLRi$eC8vOCt=X5~HaJU?AXHe5+X=N9n
zZ6R{Q=1zX!?uaOGoe$q}_wt{13%;`!k^lX7x9N;@$lmS)r3b_ll<<QE5v%l1BoC^r
zGy5)8DnI7%v&17Oi*U<fs3M20Y<aSVU3nu$DpO0ZX4p<E9idX>u>$Ahy>Yx;r+I=k
zQ3P5!LTW27(bFx{(ZRd21aa>-^cswbpS8C9j@~B``NXOzJEcc!yo`>e=8n8dGh~XE
zlQh;0-)PsM5uj%VasMn5V{x}$QvO{9OG})cfE=Lr>5$Txy_ANn*?VOeQsDNZ<dQ<K
z^hDZ}o9aJV=fRz(E?ci`OP%>eqk)!rGxAr<=3IIt)1#&>8|#_`v=osu0#B>s41?@^
zDtC9%Sby}syTM|<sCee({9sYq9gEoSL%QAxy?QnIR;U5mWFCMcWtlyfW6dzwTOvNt
z;_Z;)NRX}T@w=@$tmmJp`>Dr2+Z3uFkb6>g9FTw3N<XmhTu^V|9dELJP|2mb-k{Pe
z!}^!*#eV9&RGtVm2(C<(c@kWmt#X51ce8$_Mo{#PieudZevLsbcog=M$6rB7J}dF@
z95vTw387&4xyRffVrZcvu<X6qg1_`QN5>}-=V9%Pj3+FTYFc$Z9UB4QFWpZyhA2L=
zJ9)uBS$Hi_yg_o4e~QjVyf|zen)3eKQLU+w!Se;t1}9Z(oh>uC@NF`w>J&2W40P!S
z{h@Pn*)zNJlt#>6#b#k;)wOR?%OxJC%5d*c=2@4tPAF1<DMZ#Q(85q@7SO89z~ptY
z{15ol7rybO;cPR9^+}ALm$HI^RLv%{DgOnhJ}6h!u2X1+IfF-2@4n5t?%~s{D^XCP
zBG)x%-DnrY#&mdA9<;?NX;PJ<7;oWjrd~R~`Pi)brx`=)F9bjr>?(~OOsGW#+sHUY
zQM`RtMFwCqHtFq@i_$biZw2$EmjN(OF&g3vuB=3EM4cxOE+fN{A?0Uw`xF{|6D?^j
z8X8b??EsR(S-G&bBlF+Mr{B7`=7UJ2ro3H~auYea4TWI4fwER<FCMGdTfc7CX$P<e
zirAVMO~VzZEj&(vB({x;hT9N9`sfg=9fRnUAby(svp8};?#_U@)93Jpu+caC@>XXy
zYhV)uSc{AhftQ%88d=Y`&k-wt(~=f%3m$51Hor$bfQZxJ!w+^4gi+2x#6Vn*&_lid
zvI=?COX0(6E53Z+^i^-g@l^@_ckuH0)v3GYj9jW3oS*ZZMT?0$ABt#@GzNrA-uQ~a
zo}=z$F?m$NnwGpZ`I!Lvb%=JBT&7MxuIST6%bfh5?mXsTOz_^2{=qyC>S<LT$F)!8
z@V+36t9$Ge&+069{>+NHxAxCR&7?{Ye!w1(>((440H22dbw9Y0IHiCEOr{1p5Bjcb
z9nGF6!>bDgG6f4%nM52x%K3RYD+RX=3WJ?4tUQbNq_MFTf+Z)rha1XNLP70=*2nEn
z%;GJ0&lOt(q3U@zs_Mk-dL6%deeT1!Ir(37bn@%r&9hhxmL_W1V%w(N8sul%<Qpt3
z%R_lz6hsv!n5~;?B~5~p!05PQZ-zKZBVEeZPkJm)o`(wXcx12(eT<gTwmzJ#qz0%L
zewoy0l-KpUe5EUhw?&>|a3MG6f15jNn$zAyiiix?3V+%)xS4>3{UaWiwB=(F^!X?d
zhRfy9vT7QW&15kBz;NPB!bU!lFy8)Hda`M=_4I|kbZLZ$zLTAu-ZbB>p9)NV5Q~as
z-AkAn&T|=7SZYp|K_&$7AlT^PqM5nmFF!(ly+Gl@mhy~cOWSB~`dUXV?YX&2m&~V1
zf_-6T!3Q=L{kKJWcDaM=msL{bKbT~6EOW7}Sc8CdlTZ+#2&f<rKbX6J;bAq;s5U%`
z4h*rHWVzfE+LC|7=B3Vnu4qt-2W8x7zBt|DFs(zj1Ww@8?;B&Ob!Wx|_nY3Y)C%t~
z6ZknNVRt2YY0izkXE^1puqyyJMT-f&>$9q|xR7%#U<erq>zCV%DZS40;N>gPPjSDl
z2IU`+ChW(&@QYg<!FJBY`U$Fa14i#7fF{?c9^n$owRih#Dy5xS$u<l4%m%Fh(a^aG
zfg;JG_+Tlntcvu8G<a`ATs3#o+(@ed-)LsapXr)!x1%$DWsk<4%Y0QW&6LYA>2T#n
z@dM*V+a3aoQM?%y6pR%grF-O7BymOHSW}emL{!&5efOOl+qZ6f<;L6hi@%3spZ|Jx
z<<{@_9~scNer6LqgDAAH#9|#s6?l#(>-Giy&(g-U?=vq`w_@oFk(O}KKw~^teuNCF
z>u~YwVW>QwJ;bs3xsou$g@Ew(p(Ic3te;+ag0nf~sx&Y;%$)}J3}OQd*k}~9<R@xb
za~U;W;P;KM;YmBNX|&{xxc4;Pzt`sBy??pc-z|#a=w9;~(#j-2aJk*w;&~Q`eUrCN
zmG(4!6=vdEa1N6Uk0Xrs_SrZzsp7@%5om#!67CBeqJXzvSZq2Wu&#ZwaV@!f?tIm3
zel7bB@ruoIW<J@fVnD92f=z51Q)sIvI+h?i@A$qVH;8u9tI<weOY}4L=POz;+Fh)4
zC4U3D7$)bF2&01O?Lobd#C}P#d!5^P&K;M&7TG%9dGWn{ZUF*~cuTiZZI*d#wPY?#
z+ptuUR=)~}RSAyEK@E#8AE@5kvYF7e7ZA+l2s?RP@4*jV7EyPTk*Ru`w`8iC#4K|c
zo=XQ?BcNCGp!V)^t)sa&gDF=JQuW;LsTi8%OA?h)ESc{5YV}o7h?FVVQ(6x?M+6~X
z!PC{l>1$Jv^<F9$mETZJZWb-BwlmC{#B{m$_HU$2A<}NP7u|8^EXB72_)<wR)|--~
zaN)F*8a@R)^bQ-rI~b}`EECq-b0YKt;-HPA`Q%_|;|4^aifc+;9CFtH?3e0FNMZDf
zro4*FPn1jbgF$=a%;Y^&{Wnq~b3~u7AhszqRSpiF`uuC{DVnR$%QpP>{k83lP39WR
zo>f@?ij#-`dq6$WSOI#`rVPN}zVt#vYudah?O|dZSu}|$bB-AZ=1fE=eVl^1`n3Uc
zaNG_Hu_8mmMyv=-(CJ_$qlkK|P?F6M&`*wJ2cF%Q8O}2fWX;rLCpcT2oN-1<(lXP$
zTzh6(<8UYik*eHJAs;YL!yp|ePh!a}qGFc$Y1KdlG|3TSz|Nu!01gMRFNUWgpVW{y
zAdT)R4L6t@`$_12GT_7Vp>yyP8zG>cN2k5$ldXWtSCz~psm8bw#`jHj-KFxI2Py8X
zs5Xq;=_k2cJ{9r7sakWHrK72)!5SJ%w2K2ZX`a>vm3%qHdbqt*A3T$dkIgKe$t<`n
zQO%GgpNXQ!`3_*B)HBJ$**y`gcZdzZQd<Dx&Le-T)fdHgyP!A9EJ<kMpC>0nP;x_5
zT?JKMHI#|6R8|QlycK?EFqUc|T#GIn%O6O#s~O3qvm=iRv*XO3+o(77C^#L!4Bf?z
z4q#_TN#u&;Tng(=G%1_HmrG}U%WC;N)GDC&MPl5@3oVYedZG;~)jJoOJSGkJ@aD@A
zZyiy#*$Ik-{scVtK0aH6f9y@ui+nRuAe!Y$Q`y(2P=?SGC~A)-qKE8d-t4|$h>jCW
zbWc7!&qTo_<3jSu{UifnD}91kSO_Ul;i1xW@rR?-Mf;I{M6H<(S(iQKHyhVY;WVB0
zp~Sgl7R7v_8nxz^6S<Z3@iq-JyARshM-uz3>keAtQ5ElFAdPskU>dYh4v~i<MayMI
z0f0&c+m$6=Wkg3UsV{5(b&s!NMgSW=53CDkk3jvGBhC8eh~<HF8u|nws9<>nYlBDp
zcf=ulnNBf7F-fdX8ellbJD4blfeJCQgyodnZL3U5ib4+2olenhKpjUWWA$>#6(<X<
zRD<1Q%qT}@PlLtR@!OM=i93$c+fM=%$tTq|$*L%@JiO>oBmb@szZNh;J`haNOV<3C
z^|><LM3RUG3c}{lu{6gVb%Q(t%QQwq!_$cW;lpfr+UXclT>T(WksjNA|FuZkRU2|P
z26<L4(=IJ_z`f~xpF-w!__^g5&fDyNgHz+{2MY`)2HN@kb6w6FcIt*xZjK6^87LJo
zo)$Asi&lfFM6rvG+26-a<<em%!nrGBPw*Xr%08nrJy3m{7YPSE@=LJHB{IgRBDz@3
z;YIO9Ue-+1IU0s3yq<3&j>XBncD&-w`}RB65nbw1ESk1=;^v`t^<{5GX6Ms&@(;j<
zqmX5ij5Y<q5M$M7Cj}X&aZMl?$`?44D<DR2COsUy3ZJg!o=kC^a1fcx6VQ92HD9p)
znCLoRG^2YudcOGCW0%7DyN~8ehvv&>=I^b~-~TmV&it-Iz@q?n*C1}_CeP5F$fn9n
z-EJPuOjznrIP9Z3Ygol_e@-!gU{WELUvVy(^LrO}JInMBMVOhEuO{>{loH81TZf-(
zt9=6Eys+n&f(KG`<iPrP=%*0aSseMli{$_QO`YGo&HJ*dVo9!$=S|?f3uo?j|CQvR
ziKh7zcrrbu?C;ek9HrI#^Kf`FIef20wu*!M4~rF~8cT->381>vx_g`HR&vnGIOu7_
z8!(uV^AvhHnCwBX%oA2-JcoP;HSBvk$MUsTTH8kKN^y^lCVk27xrR-j-FaxQc(G58
zOKv+)zNF&<hnHGDxSc-_)&vf(&s8*#>_TB%XK)lXsAqi@AlF~0=6Gf@1qX+oXzTLR
z%3-G$zMWFN^Db3lzEd`Wg7aCphbm2g+uPruC2Z8H%4Is7XMGF<F18oF{#D$w?#Z~<
z!XKm11z}3uNe!l34Ti$bOP5m*QjKj$3fFUbFR<#|P4z*Q@(K!Xj>%tLTdLW+pU_^P
z4@*rbX3?nVu126Hv~7+j%N!$E0Rq{(_as+3nIox#f4BUf$drM+Q=X0G?%XhBn3WdM
zf{uIpTWvLRiOjf-ZbVlkLwYmA)F!447ydo-`>(SlL60RxJB`Pmg&8z7Ok2n=&bnAN
zmu6Xtafdd*fOWL+?SHEV&+C5J-M&rA)zfsTrU(ofq+Qv5bJ|VrkV10GUCPxrJWdIy
z9nXkgQsZ20mjV&A4q)!V7o<Lw`vt3Wts2jarp9iN6aa#;8k9dU%~vkfA*Waol?)|{
zzbjdH{v>Upl@<$g;@?YkkX!G^R6agp36=&^@1@?X=R>%q756+;Z^-|-(jx}-zoaAL
ztCAMuGcA_nt*D}H|4XZ(I?GXxrK^H1yj`hCFF692-9TZ%`55JfC|<jzyJXDu0tc}e
zg{Y0PGE{O%Mh6gmoc{oid&;Mcto@B_=$9P9FS#;b@^rrBTYV{T`%)P6rRdt1JLE6D
z&xm>lJ%<|~S8~Am0JFaw)Z^euIX?N`!kD;GR!QrZJhjdBKvrc1;tAgg3DhrdJUKog
z1xC$h+Ead{g~-W2u{+Nl^DPtI4he6Eb`F!z=ml5PnI5Wq?Uq>}*Mpz<%;@EV!-B)Q
zi_8msNY6Pwu55(<!aN}#gfX#h71eX8QJAAz9+CB!x`V#{O7;!|%Cj-4u03*Y?^zNL
zn19Z1j`iEqighN2m_?FdJ)&IWJ@0IXN=uK^{DK81M!%9#yoq|LzIrFah>%)bM15cy
zL%Ciw_8*Ixbk^j)nSfTr%4NYfUZH3L<d}_cvxj^rcKbcTJd-f|W9kXHJ^KuTBNM|?
z^)37ouQNTX#Z`kjs>jHHqCW98v-N;zgJ-fmfCVpTROdi!F_;bF6@y~6&ATH4mhcdK
zvMuF`bx%c+&+X?jSwGHv|1}KzDI@ypKHI(*tGpcPT19#go)jr>>kA{Fm=m}k_}J<}
zF?6EZ98=O9i!&dq_69Z4JynSP%2&JKAJa=sOoSP}tY!C>lbPZ#9Q~XEx7JJ>w2R1v
zK{6{m?#E>!B7&8tB7eu9&CJ;=00?tS_N_VDt~;sioge5+k1k2FhS6dECA*9<pNJo8
z5|F6$+;NtJ)y!`<QX>Re?JJmRT}4>J$%`kGJA%n5jvQDIk*709)TeaPnLO%AikM`7
zI@u3Ldd?=vPPOh^eVs>GO27^0<C(rIlD!BiHmI~c9Nw|SG_>9HNGc6t-|vs2Rrvfs
z<D>PEY3J{xu^+O;AaohhDJLANXoARtmn_0UX{zolYX(2Y4mz#(=S2UtMJ-`gmOPOE
zSpaiWug33x#W+S#p)l#%QhfQl9TtxYp<D{fSF<jhK9e7j$rlwp*MG_vrTyVJ^^_{B
zvYgri=3FZ5a{gS(V<iFU&uww)(Fc>@U<S)hon`X5gM5V1OmH3JlOa=vRrIu;N+RJ?
z-YA6UOnm@j#SU_|BCc*MZspdUeU5aAU?pOB8uK=APeY!JeCWc|@sRp;klaIl3j;vc
zvX=j_n8%5bw_Y^R4PiRmYA8re_9`HEc%r}bwn<Gmcmde#<e@C`2brA@QY`pc6?e#o
zi_EMGENn$(c|w<S)ozv?5L?(;^X0}IKR`S0JPhoCvS!{k!K7U}IEnasWLx`vPPj1U
zyAQ}&UK-udyMsisaD*X$A532JQsBIFpqvRXm86SZSVJ=2gL~<m)gpUWFR5CfVl&mC
zGF2&3wowr#yjq7tWO`k~mA$+TKQ?4q#vCQ<fYOajXHZS!sc&JlJFMn-)yEIMz3*4T
z32TPiyvgfN7XK9&)O>LDjIO9)S{*x~#UkrrFYFJrO0Pq3JmtE+;z;7juZx4=@^$cO
z2<68?svK6_q9W$;9|)8BM?Y`BbNak{fvI{rP-8F!05jiz@jGm(Ux%?ToI%1>bf)~j
z73Rk$sUo^jVsc8}K$wTlts~jaRVy2INTf8?>XoF!^8UXUk3)Tm&vYfXR12Tw8ZpvV
zu2c&BDK}MPcSj>)^QZiDz0(7ULU08PXtZzfTeo>pK9=h-0tEn+7vO&$(*DExMRUI&
zql+0KSRtIN%s2vpQO%bLvB%9VoIatdIL1Q@E>@!eK_E9NssE%(0~)TR=+x@cfX0m*
zC-%U{*Y|T4OfQO-ZhvT+a12NyULY}-o=u-^^VQunX_)4BuaHC1z+oQM{GL9Qkp+-h
z{`rlm2hMGm|NV(UXZ!nG*I(Qnwm&>(raSfgb&?Ohz08&K&AYi3l(nsSQHh`icm{jP
z^D6ZxZXLa`<AE^KaDe;y6qrM@90iADXHBIGX%BTeN@zI{b2R?O{lMw}6|2b=$jQLI
ziJK<y5Cm4&HP7g+B}4r6JkqT1Ul;kXQR<XCJ;-av{p#o0B+-fFS*tiD3;r7p28YrG
zjwaUyfNh7v3agO8AFodeE>G1uGAs^O&)z!UvYM@&!;BdziuotN0eEZ$E_x>pta2-b
z2`o>T&cS|uki4m0HyOZiA>$A}&pI6|j@vch5?bQAbUnrvkylcjsGW{kJovF3;}P{`
z{W^&9F3_1osI_&>3B2my;D#@F>D3up!|F~V^eVPJ`|~I4e5+N1djt4aCl2WXZpszY
z8oJ}E$AI~}BI?)uk+*<&^+f?EG5#gfwysOI4$oi~r_igyos&py2R&TMU(b3T@l|6f
zxbVib#Vagx=0Q#&sDA){5wx-Q+BnWWcFSaJTo+DD(0epw^4HUu|6IsHes;O2ZPFQ&
zFL?e5)1UDjO5^fPeVtAWHo?Di*Qwr@Ji5KS8lw}*(*ySkLgk`im)(pW3ZcV%S6>@l
zXQIlw$8i35t$Ka?QHuBR+^J$UpDvyk#b0wIa|DBHlE%D>YjVjgV1XMOm^&#?a|I8>
zw?-u=iI!(`!IeQT=M{&wx#VPpB4O^oq43eTEr6H6A14;Q>!QsdX|5Ys%UoaAdz(A0
zp%_tcS~Ujl$RzPaP9aCFDgNSp4WE*xNu<9HO=J7f`>f6;Rqn2fF}=|)t5&-kivh^L
z?L(Oa5MIjiX4ABV#0BKL$7gSO!lu2|7zELNbM1BiRBL)PH?I%Gvgh?vuxs(_K9Ti3
zBZn{a-)9l9lmnwY#t&l#7j~3OYdj92k)09{pwRz@vIB;<094gPE8DlGQym7${R+s#
zQE#noOio_Ps>m+ltlpXZ9JMa&#m9z{Y|eAytsJUmuA!CA?lziP6%g{A8O<I}%~Zu(
zvyCC%n0EW7dY=ePP6&LUHHZ7giO=oHPHN~ke!{z8|43*fr}^=&LDHPBefY_^dQwe`
z!&|WP2=nQz(J9aB%~HFPMlkTmu6IY(;&d~Lyn<_KgbPt2|Aq}`p|!O^6;^%%xUIb>
zljHBB4*W(~y{k~SN#yq@@-w~AaH$`2h|*B#`%3vfx@YTfSrVQDBZxHC<f<+uacDw{
zJK<;)!?Vkb^BjV!Xt)Y$bkHL2Q9%+1^RRRT$n#vQ_huWzQ4=ww2oQ`WX)sAS@tUA6
z<CA4K+{l^z10t)o)*=S-uOjn)$ZIHlW@Ub364U97iom2sbb;6!GyJj`da0uC8eS*t
zJuH{!!zmu6ol#@*KmAv(*hRse%NgZd!IdCqA*E1gIAC72!ht=h#glIEF&BE$DQAOK
zn93QJgrmje?VKB@3Ol=MRTAXw{T1GnOm)@iJd-~Y-T3C-Ue^PYfATnz!gM9?qk1c2
z1*fquP=odXGS@_)(;IAUG@7Xq;w$M|-RN4PV=jW{A2qNyv-k2{@tf_j(oE+`_p)PH
zyBlz>yLW4jNB0T@4T4|0{a|~ej2=X!Grjq`^gA2h6=~o(*6>22u5j=<TwnbS%)h1T
z?O1mg?=WIeVALn=`qGPY3|4})edX=$BZy1HzdVQUjWUk6SX!TAmCd6*dyG$At1Z8H
zuI=U3Y_x!{s8+|Cd$YkCq32Ob?wO~YvYO`JX~fnvn$=!<;9ji#r<%ul*FtFvmu!I`
ziPG@chJYsVvRksiy1@FKolvjd%WLW}>*u3a6&-Ep*rde5yxz+{{@aDE$br*SG~wWE
zR?Gd4D;K}Hv`^1PpSmW+R@59XrG(Sdqlwf-XA9i?g-mR=WScz+4_^-9AAp@4nbUHq
zreOF|^rP-aMy^+4T@;svAMg{0*$FyREbi8V8*Ibwu;?R2cp|FGXnSd~_m%v@wE2PU
z={ofS@joXFq#xq@E{k!QeC=x)n#hGeF4)`Pkwm;5s(N=s=;BMi2hV@@Ig4B=SQVQT
z@~RZnt|YgCzoJ7Zb8=2T)<9KKj`cqXSD@pTZ*01!>?w~|S>GOn|NhAxw;*I!e$i4^
zkmpqmup|z0f6)8MF{Ss(xyhz`yy3`}%_!bj<rfvUwdFPM-Gypl1g?$V&@N6Po$HON
zmpk+C_ig$%;U?TL4wBkR7wZT@Spv$ZWtgh&;yPm=T)yUXF|8%S;kZh`r=7tjl;xQJ
zdQaiM@fNm<L>{R2G+25A10h}buyOayqs1<r@Mn)(zVoHO#LgXT>J78ialX)=5#Nmw
z{F20?-QYISAn@I@&3Pxmx$K(aw=hJbe60r)VQSCHZV!yf596rn*xUc*aMsInORalF
z#oI0X9gt>ku>vo(`g|`Y7pfaq_w2zfeL6|S8>DQvVP$%wY$okzt)}sF@C}zY)hbt8
z#+SLn?-|TKZ2i>|{p_n3!(fi4vfq*aY%9q0>GsPU{zugbQsGw&7h<(j4g1VE#MEgE
zA0>V#y?pjffe*4&3pwcLmXM6@8I+pNI?&&`Snn5Sp|hY4kFKYF^Mdt@F)o9$zO7@$
zZc+ZON|_#xSHI-&qd#@CZ~OD+eFAC_@mh*sUBXAptG??kOvB^#Z8J6tWGv<HHZt#T
zpn!=1$@JD&W{um=_^I4CODwlZH&_GssT^SkOqU=#(4=~*Sa~rC@vT1tSX&j0EWh=u
zt^D6M<n*tp^Zzz^qFC>~T;|m3wfLE7$C1RpB1yV*WSZf9yzLGAL|TY@1N=zFcFMc$
z6!e<6V+r!p#rv4{`@->yCiP$@JJf3B$m%Xw6Mk}u10SDSlI34o1z~mVA*wD*tb*oj
ztv>7~Ot5qmE3{u~l&Vzb#eCOHa)Bya|3PdGYYa;^IKr}+`{0ZjM3V!Op7h7vk|cfn
zSza9pK4?E*RjM$7mRabo>$1cThG^1r*G~B$*eWmuzCgIIP}FN7UJ|5RVkwPeN}yqq
zD=-wvO?lrl6Clk1l73FA;epv+%c2%+kYo5B5?qD4<rPaAkUS>oZ<QOYk;LyxI^bU;
zKVgN_lk_WWfFLYTzbpyumj;szm<Zypk`QSt7=CJ80SYNti0&d|0%+e|mzH?2>4htc
zGidh(KNUZgpUi+}ySUh`N(_bOHBE!uqMFuAYW^W<rh~MKeAOlV!QaX?&=7Y-g}T+M
z#49xJ;zwmT$uMKYXd#I?9i&bl)XG?$FOf26WUQ)rq{=-Z{gphi##PBv@2_l=MD9W`
z=>tcFz9x<Lg-|2~wn4G!WX0Ab(=F^yu9TzrM`gm0B$t=fG1dr;+K8;Nx@OI{NZmcP
zy2k9Y)FNrFCZ%byj9J10#cL{1f(E(T^yfz<f~9~*0B#5=$h$1!QH_b0#&wJ1(n&b4
zRAj~o?yiKU`^uW5G<WErEEw`tGFi%tx@ozNp(G*utL1Ohob{5nLDS5O7e(nL>AMnp
z10OCx0gpc<qbz1MbL7&Ynd#gbMomh!c@2AT%7@KD8H!Pdp1=<@2WY<*VMtle=R8*-
z^O?XC@uS-G;OE|tiw<>|c)vgo#)vpQ8F+4ny1TNr4srYD`_;GBD!ER*Q9MLtke@60
zN9E`xD;XRQNue3ERFb57OxwOn(-j0q@_shHfA8|%r!W74EZwa6HnCgk)fj%?OUE>C
zVvR7g|0;1U+Uimm?lUF;8#W5Q%r?WnNYV>{TqQ!@M@Y!AG06^pxLzlFH642~&k~)L
zYM{1e+H7{oY2EQgRbaQ&`(5I}5$#q~b|P2uRw2jV!p~<Nu%b{veWwlslZ~*?l^(vA
zY+{ijQ-1Y8=K4>FiV4-c-COsF#^v__5x<;HtfBmYq%9_;eWQ_Dm%Y@alc6(WMpW6s
zMWR(u_HjL$DI~uy3E9j@`jTn+Rk9(^?G)$K$E-8*g(iciHfW|B!G-(N2_6A={_tt4
zVRh-r1`8WS_Zuwz<lT!&QdJG5dDRLFR3)RO(%FW4i}LqBHQfIuU%uZ^ek@-BZLA0q
z7aKKGXebcXGS9U<FQ#WM9XueYN0eTBgViIdD{W%6Hmj{RYq%QSuDTv43#j{UVq?JZ
zmCj1jlV^m9+U_**Ow0WP$cL>VZx>g?`bMk4&E~wc2UY^!oXP54BTXjB9y@%>TO`N~
zzwi;lK@1x+2u|D{h%+kvw}k~6Gj$!4P&QvpabayDg{M5-f_%;QBb<R|usah;t-k4r
z47jubu5<*U&NHS_eUJz_Y>W-quf}XXm`NA|#<M0r|3ebnX)^VpKHi*(U}cg&B0&NL
z3@6P^;tL(Lw@lozwR(!@;b4bgv)f0I%aY6^$E1<FIO^q@=m?P~K_71jixrDeRefmM
zOeBB6UTTA?jv%SfiBfSRl1o%|G1^VBc?U_N#>Tkz0pxjJig|#yA$$v?Wv)c0PIHZ8
zwOTMnEm`-%9VhRAS;HJqM6u%3cH=Q?qe0agPNAdR(UMsKrg;oX@oYlza8`<-5-ouV
zqiO_EPjCk=ikUA&EPiY0kBq<#m}%l@DV11qrQ%8Y0=-b0pKP993sLGLjxzNdsh=Sn
zGOz}7L;6Rw$P@nd0BeZAs#(0~`{XjEqI@HUsKx;?I>O2bt3<2YIKT#V>|t_vuQXv&
zTlhe33#~2}BsN4-{*atLpRT?}3SmvwImjGz3P0mWGo5b9k9)H<cR3;fBsWM^+hCt^
zu@X2zxe-KJJT@%HybWdv^ii)FrJLHkY#o5i1XzY(m=0^5+-ejiH(kD3rD@SserpI7
zPS2aW)39=sA8|Hq?!?`nNiTk$11zWl9605k40Sy`P(U+1m|+(W>s;jjV3nr51z8fr
zdyNV3?64Z)Svr`2@-^%`n>5*+5o&_9_?D&I+<=$6`8P^wNb-PJ-%#uvgV?v{0$^Fk
zrd!$Cb`+Iqaqg^<%f$=93;EJu8)>k)7Bx-`%=BT<m5|NRHWqg@;#zN(;HY}$yz0JA
z+P+DL*AO1?Okyb~#r89cQh3(3(#@GXd^s{rPdJFJ6fKwqqRbY^zycd7rfM3uld<Xl
zRKF^;0DSFYS6tQlzzClqA<BD`_#$N{teCqcGOoSvV0?cH%;Ra+_l+ib1$5yRL>d9s
z&v~8s%-SS_io`<>GurJ1l0<OHe@w8J{DL>i)O2tb<$;}!X&FC`OBaK2fS3dDl4djw
z&EB#TTRW>ZOsf2{joD&01lmmF9ZDj(r(o|kr}*)7XoNdM`C5*B1R_gQbY`E+!UTbp
zWoLSrholJ88i;A4KBR*a?FoOHK;K=d5Ud!68kfumh}k^&IiQftaV8M_IYKKZCRI}{
z=j&p$V~3e^u(|R_u|AZ!jGj4COS8Q_PdqNos>@6~$E=$*`A|ooEKTd|@2;~9EgZ`u
z9JjWk&?85rwv+55Csl1{-AB%*+Ah|QTs~%<o;DNli8Sm0Nsnr}b``(SNI4mw!?#~O
z(q<Ny8oFqlOmlc-qD<62QZ;BcfBh?6#)kx!O4g2}I@_yy2+euRpL3hLAn>>3+47mB
z?N`2<mcGcl<3sNwCHH+EY8&Q?nv2n%dRVJ7`3uf7Qk)M|J+PjQ0%EkJZs#<eZ#nxn
zOS+xvuh9xU!i217wmOEkRCRzTm^>hZVzncsiP;dPI3Ny3=F)m#@vTP-5-H;iyaA94
z=K&qJSc`eC7rwr(c|#mmqdiF5S<&ZW1BTqLz34WX*|h#=SFJaUk+tmWe(0ESwSDU+
zruotNr;o?W9$g%ZZF=c;o_oaM@m3(|H*2O95YN+&$&u75xyoZMaKiM5pD_JqN$qg-
zw7CX9#Lzz6M<_|~s9RSIE7NQ#)(=)z0<*hP*N12O^mT@n_FaYDUGIs#^!y!Tv48tv
zT+3KoU*x+qO`Yh!kM*>PyBXL-Z|m#Tv#rbw<%pM9KhL3yVb=^Tpg{6K3a5o;K#CZh
zR?I{^FKzy2X*jHnIf0gOF17mw@mhGw^$gnYy9rlsuE*ZIBO=#v{d~WEb~#Q=iKd-=
z8E7UADzSevu<<>x1uoL)3n}dLL#E9%^`BrV*&G3ao%)tJ=)6$yjD=y2ndm~OVHYSi
z(KDJ|$2>gtc9>^W*kd14T^Gz&x)efg{h+Q~&xhm`^ZG=_!uHdL_DShQPV`9YzxL~g
zwwXY`{6CuZoEA_M>$c!H%>*C_Oun$eHwO^i`ZiPiZaGD#ET#9tqq)0D*E=e%KYH-?
z*6Eb)u)!W=%Htogy)3umlAL;8JlS4j44(O!OuMXH43En{95XSxqbHQdulLoc3sh)-
z#Z773!i7nyjppH*^oMQG<S6vP$8!y)g5&C3nV);oReukiWzI<aGbr^t-!gvjK-+q*
z=V>`TR(d3A=}86rIuH(trJLWs!)$blcI`klwm&-k%N^|xBuoJ<q4F^7&CKiGUV7W%
zVC}W=*sFsHe_u<+KFv3r%)dJQ-|y)=@!PoHxjWZMMj7R6EtvkJ+ysZmPcl?cia;0a
zaDb9QhsD+pWDY=TZ#<4F)yrfb96vvk7xCCzwb&&*zVWqj)?4G4AOFCR=L@AzW~yKI
zyh%5mR%=`PgV_?<x&I<1AQ_vJ*3`uqDC)zy#ZyA=T@{$NPm3g-PSj5nH4gvy^G)?%
zkI~*9RpTeRL%r3<qYrz($Ub-X9~<%cNoacUj0Lmk$2=lFKgLny8l3dUqh~-bk80GH
zL{C=nfjCSnG+^TwN2X#E$xDh;KC$th3GvO@@dt*9H#-atS8r|CaCMaCe*I}zM&X<n
z+nS$CUwa$>5(0!=H%A3y!?g4<Ot6CQNJ9)zv!s7b8AGr-J`Ty}trNGf<rL)wwev^~
zXNnl!IO^dc3}=hm-sNZQlpZ5Xftb{UH3J+<b$q+m5U9^DOZ8l5x4z_E8oOhX0{z!p
z5aRscY^7D9L1CzC)47hInJ0yeuM^Rrjg+T?ZN5FK7h42*1PM#e$&7u@Fp4s!0}TVw
z+2|@5p0f<t39k|1-B%1)`M%WU{`Lg8ytExig6EiaM;a{_qFvYsXx-h={fx)e8&4$+
zORXsCS2t!nE<Rp->Ab%&e<m=xJK}F(#Ke=c)dD7EagnPdxw7XZ1UzgKheqk1Tn5E~
z84T2ZXz+x$+Pyk(&g%Jfq5Z@KAoowIN}ZMS>f)dGZt{foM3CT@0D=CGorP2C=8bhF
zu!S%61z>wtvx1n=kS4J8xXl2pk|-|?%gk$+EoCZuMdLQ(a2({Z9USGfHi}%!(XeYC
z)1n*vP2(_}>bHHUb&~&-%HXzbQqZB_3R7=Ho{pZdluEkkFnX#ad}>U#G9#}szoyx#
zmlf0(idF30ntGu+z`-}HG^FILfPQHH=B4(0_?rpc1}C;x`q(NpMg1=?onIRt#z%FT
zfH+;~W~|E7bS#g9%cP}n#Pp=KWTwlMt$fS$)M@nzmp2aj+tY8(nsK^LJL=Aub7|~t
zN%6k4`9RGyXhgZrp8r+gFG@TTW+~8rygPz${7?}nMmgG*Ei(>wa67Ng64g|ha18qH
z5PmFgHSMtkR(gMZ%YF9!mC9yfnV;<BN=_Wg@6m);BIngYym<%-rhh-lMisw15j$wP
zFlF)3YUxklyU=`wE2K5(r-Qriy3fF6_L7r03+lPYmb9Qz3_4lRS_56h<KMa*RN{de
zpnL$hgvq5od+<lxl$wj~pGtZ~WRQuJr3RRMS3=KV%yC-nBmceSPqp3^+j93`gDYl>
z1K$0Sy>Eh9_Y>=%u08*?rS{JYq<MN(vb(-VfGptQ)ah1AUg(h}T#W%)A|m=K8_xZx
zuY{tLjg_l}x4Kq6b_Pm1As(U6fu)>lot!m;CnyO@unu%kSXwL+B6o*ItSPFn6`2Yu
zZ!;+LL-bdTmF&!%9|;zwe3N`(ln9mQ0Umyju-PtN3J#X=z42C_@HApT?oJ~5dzVpS
zYuck<pU*K=WhDCd9EbUcb8?R9qyAquiUF0+Uxb5MsWN${4MW3+K=@edii1CBOGL4v
ztsJkokE&rq2Pb`Hdms5W*E>Y&(y0auy`W2+Dr;K-h_rHl9aq+^m#=RLh>3Ykb!4yQ
z*26aRM6K2^+&kiRnoh7mjg3fTh~o<nMCFjlVye6bT?)CrL}ZTa(aywx(M`cTz@XF}
zAbwe_Xwu5wK<b_zB}aw!!_``%r(yF5!mZ!sM;)cZ)M8|K<ik^6+YRQ#9aWxSQ$>?t
zwT!43qO2Qm!K6lAi0E4*`0agx&XV8%#dvQtuLywjoBkz_g!_b8kZpdlebr);SfDU$
zuz5+jaTGW@G291RRo~z{@ybY@V@=j{otAZi-Wn@RYAm>E8NmFJ9A@)63$r=#gHrs6
z++kDjTew@sW#{*F!9x*<o$oEX|4-J=XtQ!$wIL-*cQNa)f#8un6KWkL6Mz2MmVWs8
z=|}xfhsdn_pgQT#`jdysMz#6(wqrgUE(@Q%{wn|euddI=yCr86zU7zy`}vuA()@<j
zqw?g)1%JP5&Yz*Rf=JC7$FSd^8#D7Ob9y`|P-2@%%o^A3YA0)r@}n=rPiu;whw4QA
z=F<kEk>D`995rw@)h4j^znCv&ezb{}1DP7fl`mG8wE5b#*AkUGhZ7huNpU0lc6pEX
zVeM8>?!^UZ#NUeHB=ab3ZmXdNTw&;awJ!U)@P^awyoxxi_FdHih)RO5NLqVtw$`Ey
zf~mvG<yCHWDR~gVzz2q!=lw5!r*Qql*V1c0s#@x0ti1ff&rben@GF)D+z4ASSt5iu
zy|ZjvJ_;_QyWAHS))2?;7aUbi7t*r?apF`vE9dvpb5?F{l+hy3TD$|#McVn>!8WMQ
zt8eY6sa#e17D{NIyr`}MT||kJPSk3SM?X=p!^Xlv$C2H@9mF$6w^HwXuuw#<;pspG
zSi>CI?I{ht9-!t|ql50V(r&g!GcEDH=^}Ug&OPX27C<OCF|r&N9@L*24+jb=4gJ)U
z#g8$iwlX*0RrOyI;z_5eB`+6$WW^$Aqn<!js01UKNrKC3cx%P1JIgboQC$C?sn`?0
z#5gH?_IGTK)U<ctH0f%i#og0nDxVQE^9beV_Xl@DEhYhIfDxzYxjrta=n0Z|_eAkG
z8ETTTFw|aovN;CRio%(fZi4!m$e(k$pI;q(xb}2-W{)Q`2caX4xAEl@HHQ)1t4?R%
zd*%O;ZA1C97Co5@6J|i%kW##z3aVEt|7T`eeLvMSr+wR`eW36Cy-XPk+y&6-PLFA5
z1?P;ipOK##yQ?T#`mtD~^&%)Y-t!LoSKy_#rFdQd15<O2({b2zsWPS0JXl{)<X4hj
z6&))6e$Eognv>ZV?9@;>zDx%LT9Y{o-IT{2#fzFnx!GZ2tH@bG*&36c`8&X;7tGFU
ze*b;W5tN|zsy^+~51xk?F-=y8kXVNmpjd`Hfcy(1-`ToZ`+L9k`9g9-)yHQ$lso*-
zpA_!bAJ5(+%B-3c;geAuN7=Z7S))Q6xel_i0EjutDhWnC0O8)fF{qcCJQ!*6-^_0E
z8|0rGyZa(6$}drmOAu}*SIl1^wtRhUexwMVZAj(SpY$BD4EZx;tDRME*)pa@){y6@
zRK5|Pv@km-@kE_>?8PJUD}sZAH^VM6!yU_*_<cO0XyEiVo>KTqdkoT5CCMCfRIMN6
z(G$tv64Cqmsg0m%Oya5g&dqNW5V#?zOH$Cgu;vsCYvvSw#Aoj0dq*MwMNCD_DfN1D
z8K&tMtF4_V7bRqRMmz25@2>64#HC)z-qy6mV_)_y&$sqEDp{G#7Qbqe`48Fd{hN~g
zPssru@ZNVJRUUwI+&EZ$5~vD}*F%!&SvaljPnkjEn%N3nv4(%!V{MGyvt_uWeO8Q>
ztp4CHz>3oT4e?~IAkTaYUD<)QbX0vk#jp4$;FR2kD$t7R&ReZFmz1?>3jzB`?4jT>
zsxe+%K<hAK3gDy?q_nC8P*nn2R5)X&_0zaA(?I<oahct&#eEj!>b8Z%;F!WzL|(4;
z^(2pO4eI%XeJN`@qs2BKbo)y>4)n%OtN3M$hjgorq|Ues;I?d{RwYiY42Hu28y1fu
za`XZwS;Rbfv`T72<-%<9#4UN`W`)e2!i87uQd~)>jREKjJ9+^ZJ(#%52DgE6Vz_cx
zEtzFBE=h=STa+y$6)I2GkI4I#s@F12y9T(3%gAfrq{PzP7YF1_z}!<w?v1k2$y|nB
z%Cj&1kzE6kp?-WFtKy+V_V((FeF1W)onbQWYC+qX)+{q>x>;2w99ye1xW>Lk;1Fp#
zL!?;&1kMc~_^TCpqZfjVIRa;Li$WC0;~mPLl51V$sQ2fqO`aoSOkL5AL$JMy7gqI>
zEDw9JE8awX=!RD)GZXGfLeW9okTKn*4rCL0mY%DCUq_BFXJbOlkJKe=(Oh6jkq3SP
z;R8?DI0|@ilFEB%bqy))C@K9;DdRmUGYx6WDCr+*fFYP`4Z~>@b?UvNtk1GY#d3>?
znFyWPaCU&dHS^R}jZ|}z05_*plr4cbQZ_9LZ*R_Sp4%Tx<<0Pgw-Pwid?ips%k)l#
z%GBU@jWD@O!m8>>_X&l8JUp-2>^E8`A-p68g#M$fG@lnl?VlYU;K!f-?;Duc$!7nZ
zhHBua!F@?M1J%+`0l4laiJ&hT17@l`&fa3nCbvL9@yjtIFps&PsEd-ivh(>V;NtK=
z=RtF4Fc^3a@ca29x<e&8KWR8RyOe=EZVXfun6=7C@^WcPw^j&tOKC?syToL>2c??s
z?3p9JG)G12saqnNL84i2MCL#qtsv2FZIVY2_OxgN<CJ4`%Y)VmF)$&f{-L2_t##dZ
zdXN;t3&deU+7ek=>Wel$m4Y$&0TM+=?G1>wOKMOd8FQMZ!hyOdU*w*d!K{4|7~uH%
z5F<KN6-wkpoAIFr;ImU0NiFkJG3N4J=E^_K)lUi@W3c*NSmU2qGc60t7z^7ji$L~2
z45&2cnh$!uNys6_AXZASIY|Vlfj!3vqggzrmeJ#b(%vz8)_(9Z%PA2wSNEoYU)^xl
zj&(GjYR{4wfHm@7Q9K3-Edd-Nl|n(z_D4CksnMM%Dk!8XVD7WhmC3W7)2E}~bYC7;
z?&_2jlb^eR1$r&u_)7iE0X}l*8OV-kf{TOc9y?fxe_TUqztT{L%BB=%TWP^I{ZOi`
z7Lt}@F2{zm>=cGoad&PbgGihe%)Iu?tx%GGUrn5dIYMnfkUC%hj@0p(akB25j7fqW
zcS;@uhB_3};{m=W7F=ta;_kK5mp2YyPLE`8yBRxiE-oXRC)C%sHQ|-Y4Cz!ZE?;q&
z`KgxVbH9`9kyjKs9TumV&Kqm25-Tf4l>wv6@S<@Izhx=CVPuc1UGqBf8q>R%1<kkY
zJx!-FZrNUV!o^t@=nf*V!-$V+YGAxu5|>wX57dPDPJ5eaAXHxOg**J<I@7wptXW&(
zZZA;1zlwY^wCVG$^Cg>~tp;Dkx&s82x1SU$Vy*!pxYSBZg8Lg0S^qux85BzkFwV0R
zp({a_6rX`y7YM3LX2=9PqoV=g%_X*RA71+z^Bk(+>w-%uliHmQcGs(R&?F8%(rKWA
zv&*^Y8`gmDOvkm^P|ZAypz}Y2Dz?Sfu^N@3))rFlFv4~mhM$stGl(3PjxG_(PTF|$
zc2p94^VjK}Dz1%wP9Rba^gB{gH|kVul>Fl;<=;{2y3yLP(fW_0jekd*>Bgi;U5Xae
zmsvrG$11#(cRA)(Ua8<g`LcIc@Su|-u~eRnqyzJntNyXq!p_Cyk}zI-!k1SCDmELk
zgc<{8^(X}PTS@9Dv_zkoUeijI&X6?6azlIejg}SO<(clIq#xkHhdv!LeQ&4QvGGZF
z^ulSfA2$a>i72PdgKo)NZ)JgTDPGs#qQ=a?C_ylL`D_DPu;LW__}jP8DzQCZMnye=
zJ5J(lte%M<d)}1hbt+$huW*4c>5gy2QPR2GRa&1fPb-Ftff2w2T(%?TIx|WBY{v>0
z(G}1GpXq?1!9%I>ex96e$)GvpN(K4fGFhreFC!_wrt9kUm2<}f*RmnM_CP^zx>c@S
zu^XOrzM+DwUk=TxjHxw$eQd_wN<cl|lkY=h48>70{gwU+m{fj;FMxmLVSSE4L56TY
zyQW*-ucWw^g;Z1#T)rj2g@S(wPl>*w^_Bh*pKF;(q6L+__cI*fX2PMejXrt~O;w!7
zzQ6XVNQE~%PRcVIJyL4t^A)Q!CK1Yud&re32T+d8bbojc$Rro5@f#$*QBn8>g&>21
zS9}pM`UsO|lh75RveXazW(Y53<d!Bd3fNU!2{W989P3Xcpv7m}R@m-VrrcN-Zp~f1
ztcXzump&>fJ$qd*nG23`n1Wld)u%|T`J|*^*;|K^d&>e6^ouWwbd{@9FasJ>%K{$0
z;wW&kF<h!>zfsPLU1t)32MHvcc9JV`O!en82)}`EEqmavzAN<pZn%zpb>bd~-|bGq
z465toS_}8pUP1|mE{85w3c4EziiNTt_=&?50qT-C8|hZx$wn#q+$((lo|*A~6-)mU
z5H7WL7hir<wW#(7OUL{ln$G=^$^ZT1_sk9$Hpj)V&78#?5)#{-=8#ZHD04_c8VQMP
zHs{kE5<*UiLP({9Vvdy<c^6VSRVqqRDD1QE58r>`K3vy*U$5u&co?mJ-f#a$QWvbS
zQ)Fr^gkV>BD)@`4E#$OnOMb7B#Vm+!gN~(<PCLj(5vzA$@seY-X4E281p=UjQuyTF
zPkMhF^5z8vMxIcGD(v1(07(U{>dgcwKga%LyBaMp6bDnKkjU=<^0>&Hq*nkEK8MeG
zup*HSFH04_AD)MS;Oa`0_OritP2SE0GuL+Qi<cG<hVUj;UpcB8W04t|_+)!=nHF$>
zWwk_$s)2=Tdu4b44v*<)J}9}Wm=<M4=Bh{`Y(hrvUhXl?lQw%>6<;Q;ifK?{XJ<a(
zmi2?YOu+AVnEkO}R3!vuqk3+qyXrAfB~puu5y{q6GtP0mYw%*bWuHysp(4dO<%&V2
zOly}45OL97^<mr(JX^d4+z#q`zvZX+M&UuLXrkD6ajlc;nr1c|=3V^T1XEWz(F=G%
zU6s=wGd<DmDF585bJ(bvs6qqbpg1f)NF~e&5ONnd@;>P81H#X%%=k%~)JSGA*X5Go
z<CTc<uDnXJ_#ohYh4sA|^!!+1ua2XJxpXjy5w=B^ZhL6D=)b>3kQJZP*()S5OjjP{
zTF!S_p7g$h{MsSzQT158;B3%-<z$&~q5iu0qBOPe2N;ZZP2hLG5&>9Kfy_t^XulV(
zl(hNtS62z2sk{LNrf2F?2cCmyf+g*sef~0opyC$4PK;V;=$y(uW3zl`@0<U4Y7-Mu
zy|1qXh#^7J2*HD}uKTJ|0$`HdlEhX3NvRv!699@+{+eIDJz2GX>UzRdL+4b}_EhWs
zw|5iXKInYgx!uoWAUfn7TY9zqW3`^|C){IH_HSEH08;)-S{aq%Wm>4afW%_u)ms!%
zBn}<^NcH>v57(=u!@5!Rzot-rk8<yvZk!DTk;K>_<%JNX3|y(a7;cF)+uALCb3%Q=
zN!!Hl(e>F~mvDt8bMs%2#Ky-qCxRtP{85d}h)Rf(2a`HUI&wA?gD}+Y!pcoJ$|}x%
zLZ!t=JyDk+E40jp8YIEaev+4{m^#Ybd%GsN8Jj~%QmFp7Va!FXZK4TYBB(9hGjphu
ziuga|LMd%u10mFSq=Q0T{8j&qhwo$kuU72GX!B=Cl}6hN6PiF|)%SNuRW4(pejmYt
z`5lW_$_bzPPgU;{86CALuN>D!d?`KwWb>4NTFi?PKqZxZdN=<Zv^US5@s~2MLZeyA
zYf5_?H<2^=$6jo?!c8swELzA<j7yTP(@^=lyx+VkW^v~1FHqi9A@TQ2Y^mSR1eJ~C
z4~IcGWyZ6oEaeuypVB?l*KI##WZU}ItkT#24$rFI*AhOS1*#yk-1NVq_Lu>6gBsWT
zMJ9JtlnZU<1_~<u(Xq?wQvg2bofg0?d73y@D{PuZ^kbNSFDv=%Au5<9O2{e`C}(I!
znHa&i6mD2Mm`89bwMaL-{`|78_rrMp>9O&rv9<se<hn|`mcWlz3Y7jaW3`XC|MlZz
z3$#Z-Uw8^ZCKOq5>cx`G==CO#u>*G(J;{a6-UcS{)Rz`hiythlVP}Mb*-n!!Ct3+w
zh{A6QCIOWba%OA#0%j}AA7VPL{hDUj8j@@Ve{q=75&6Z1QY_+8iO-CSVAVOzR(U<o
zXniX$bA9*SGv;${k1`0=@qAvM$Yz}HQqM~O((>m=@qqqPu!?qu#e-iThpz5Rlu%Od
zO-y|(1dtZ6wE{JVQq-Rxl~&Y|R$myMxY+s)m%QC$H{#0(eF6P@OBkrI@_Ny6E>~lK
z+$T)Tz3>dN<_XvY&kBSs+dX`7iu+dELEuk>JOHE#uN+i>;V1`boRx7Z@OE?F0q_yz
zLuEn4*jW-v*=E@4DSY9>KB=IE4<z%71*+vv)~iuD>1{B~;id2=MXH@dVJ+p2>)NRD
zzm0k4D6jBmC$F5iBogFU%a#YuOq(X10B-YA?10mdO2nCbv(!Rw+eJ@j7p$zcVhHA!
z&DGuREd{(iHc;eCa!{XYvK)7XfS>>t=UmPDgzvZj@3Dbm2fx7!MD%6{HToj{aXt?2
z=kr)W=9}nf#F@gWpOR*<{XGTOi$C2teVws$XK2r6*P)^t18auEErdQ)m{~~c9eewZ
z9qB2m@5Y^xJ@^CO{3gn{Figt$mO47<!KaGM@P}W$Y%*feP|gtfDLtl7-su7u8uPR;
zMhW$~Z$4LmqzjZQityZ!#6I6JLI6Jyg$MBfz14*Vl{G?I{6y74C{37l=K&kU;DP8!
z9`qpQG_<8J6?Ppba%P?C+-o#b*K^$RD0NQqdJ{sXje*1)OT?_T{P)btsl*g%BGO-N
z?7%plCa#3>+Zr)~W*ZNZO4;nYuQ3OX<=K}Y2!jtpZoiCv8-De$4eHEb#Gv{trq&zC
zO*u70j;ifGq(7pRTyS7{>(%&kW!auXm|UDPiO3h02KF&a@;~WWTnLssgZU(#s|xo!
zWF`;)z04Pnt4IqjupNNV#LoQ0j6M7`+fn5~OXvN{-3_9xO75#u2^_NQgwiF>s6lDZ
zEZN+DBNl;5HksE{lUqf0b7l4(Vu&msI50r4mGZ=5nfgy`yF}LA!iyh^CvN>3k*vG0
zEwmz<Iz2P;?pG&3f`9L-w%B>7()GHgBd0^dNoh6pEPFPW`XyBXEXHu&iXb-5f>2Ls
zc~&b(Kx;u2=%5Y~g<7oYu!FvGWHzhA2)-&zlN$ZTwyJeA@G}+wu8~z%j-EwTql+qv
z<TTlQDMr+W>Ipcr&+1a3l-3L$FH+S<YRr3*=lq$b+&X8~vWRM95+uMS(%Zvn{l@&8
zKMCh=zIwNXOLmUc13m_qXaxtzo6AaQ{UnuDSaNSr6PVUV;a!h4PdzwlsusC9Xdf+?
zEMp_wuW<p5Q<IwGjFa_Mj&!Ae8??FVqT43fKG|<Y?KX{O&#T1NFIefNb4-<PWByHC
zu^l8S_F!$~pF293l2Vb*D};EB$zjW}*C@XoR<ZJ?+&_!_)Gkl|?D59BJ^#g42>HWe
z*E^DM#D!dONG0ukgp0{YPdV-IifYj0(HC2zhVY6NzgAkV%;TTRpv@Z6(w6`>AkD~C
z5|;c`G8(ngrJUTcqEdu(2Y6AO-D~v{`R$VOb?Q6-c{mNE>2+TU5BqNOm5)8MI6vlE
zjfjH);t7NS?7^|SiDA{Mx=sH%^-!<ph6$Z{v(#`f@vDgz5Ux`Dh&z^{nH*IKO@C?T
z2!uqoCHDH~F{bTno!4_IjuLtN;669qDmibxubNS=nR|ptsiG&ffIw6G>re&s>2?=m
zrd!Xit?nXLr7Dp;Nl__J^{8mP+Z3V&qvUItX407&onu0K$MZ`IWI#&)1`Bau>D`5m
znkrLsgO7jZP3AW0``i)&yB^G(8mHLHKZSE-RyYz8AN7IsJy28zKn@{mh`%7&xHr>`
z5~;dOOoZe|g?b1;a!uNS_sdVwY!e&jO|++B3Ue)KZrj#|NBL+!OH4%Ck;pXV$%dpm
zEr($`9Htb>Cs-kkC@MAzW<Lc@H9;xaK-3$R58}5I2lw^ns<V~AKW(t>c{O?P09lbK
zE;B3&8IA}<vMY(n-$?m83*ZvbycH{5A3qAs6!4&0EAV*O)0N%5lWuTq^I@C+p2zkZ
zyF3#_EzJ$dH7CRFE}6L>%IUVaA&K#a?bW^~8Qz=SAtw?DoQO*nInW&WpvT+tE5qi_
z3IX?80Hj5=<plCl9)_91N+b;JyUIj0?#_Jcj;<=&fMTVYRTz<T_E(9ylSl8h4}QHQ
zD;c_GNEoiRH*H2qR<HwNZ*9p6<cs;%D+HzS15|zun01QE5*jHR)}eIqBr0Mb_Sfp&
zZ9qjLDkd~k`si-n<1|k;$6DOk#YN%Lr0UuDDqkG)&X0DwWE|nB{Lad=o~=8QXN2)p
zO1-WY{iB%_Wg9W)wShegoT5XxUh(IQC}58K5D-qX_3Lm!Wppczo%YB29PS|*8Y~CW
z2c{-GUaToQW#&+i*)cik-uGoydyh=@fcWdw=#9Q69D8Q}-+`xRCg}eVc$`g3O2WbH
zpIIZOh?GSeRg+h!Fnhd&Xs(335GdWw`L<@!9f;zDU}GbtS3RV~8tpioXU?nIBZtE{
zhPX5raJnTZmLeF;sE9qbddwErbGnV+-&ftytzbb;O*PK>-5A<=<L@q-qv&A%zccSt
z!(9CZIsc3+Swf0OZ;Fo$NUV3fIDRJmu*0nTnBBqQ{W#i2pT+P_zT%I0OfCHHd&%65
zUZc-`C+tOTD<wYl8YxFSy4CBXTa_89eQCAq$Cl$9GVN+b?`|y|=FtA!zvH(q{cb$l
z`OR1I-^7bcf7)+%E}zZ)H~sC>`r{v+KN2OkX2cRVdhPeSXN;g;6`a5g{CH4al)JT9
zBZqq3k@9;aWZR|kTf*uCJEJTE(N~6_EpCnkMJ}DPN)9eiU4%Va`@la`vL=H2xA^vf
z)C<Ah!+tZD-|_DY3StanklO?C7o%cUQu&P6#!3PZ9Ac1>&d`gN6RB$v`$j|#oV%nu
zeqn0il5K=b?iHkAAWEgfMI<;W*jPQwpYa86y4kYFy+!<D9p>f01*j%NuPXkqnv|L5
z1&u{k7#OuxcnKAZ(<zYKX|cf0inP*T?i_f3mv|2kDq@pVF%XJ{OXDY)c>{r7#jaNH
zl(VXd0^Xa!8<r2=biM0vRhRT9X{jP<F#|bZg|-KVVw}4i$Ad|~jA85=v%_?!?nS4t
ziuI68;!c-%COz&W#cYS8Zo9I3l?K6AsZjjHrBOiPn4C{Nv*8VMw3~T~npQJmQi+v0
z7nrzyR2>=t=|`eVH&Q6Ae4JN{j6_=!t~Ta^W*U#os$I-n0Ru-k(DO8S1yS{e4SU63
zJYhldJuOzbN|ld21>%UwQRMvZr&o8xcy_2QtY>~$G%-Uf_Sa;OFcTS4;$w1Bwj@m+
z2ieLbT&gz}PK%4{P+NoNY!>S+$0%LRmn;a@i@qnS{6?LSrvl=|w#x!*bm?oFNfjH(
zKEF7Bsd=9wQw4@`({;7o^?7&$%@Dj+OpSQQhJAEfT*9DQr)Qqd1wEh(dUNa;=omZa
zhU!CMz*icm^1HOF?b64iN$=2kx>|+a{$kyvNDvQ}a#!+Upx)_X);_A{QzSIRRcsvz
zc)XE|naE3B=f@|;=8o(w^b=8<AR<?Zk`h98pU2X+Or_qd%d9e77f~4#gBQ-3u}4QQ
z`8Qk{n$37>D0%O)-rbcmAXBL#R?rWWbsU$KSsZHuFY@}8cu}il@FygVBa*{|eVsTY
zStAz0gL-eK7ig8%XvGv2xYeeYHZ;T@zfs!srS$sbk=t5V@03JD@&v$=s}CBkK6-Yw
z^UKwzB4yoLWjzjMeW%L?(#xJTl+izD-|T~OR?O>TAQ2?ku{9|=Ad<5J@#2)b*-K?}
z5OZwIL__)X7x?=JWw&GC6EyK92lJ(p==@0OR+_j>Z}AHdbjlxYGKgs>245Y3-fMAe
z&y$=d@qP7M_hvKT7Ne&KAjz&mjEEq)QdH5pSLqK<20SLWV+fa}_<x*`@~IW^8N|4r
zbHBRR78P@n_)~P648J`q>Fgk7%aV9LTKx`GW9U`Yq>(6Yig?OnIK)c((1O}=5bqL9
z1QK1&yS#mRf7vO~1)hil1?JQy`Q+S%b`&gxq}Xy;N<dgUnu-zsE$KaVeV^z>a`6@U
z2&Kg!mC`Sm$d&M_28@fa?acvXmymQ)my!<_qAOMYnR{br<_069?)H_Wyb_!()`7y6
zUVnh0SISi|@-su=TwX;d1Kz7<etlG|1t}tWMC=(&fnO3gS}6HwR*K#tsVW1=&hyLN
zTj0+~;_oXF9awW%E4-bDZoyW-Q6i7M#9FY8EdUc<1<4^I-qR5)MaaglH(TQBoA)ZE
zVqr&SF1_*7-*J_w>QVwklmgczRsR;aW6dNYk=;Ch{UjzT1!+r*5Ra*@zXACOs9jt{
zXvmle%!@G4DFccm+(2!o6(MIJ0g8zLA)!I1R3bGYo2AWL=1mrk>K3iy*(+%P579mf
zE2Y(XRo8BI)taM$siS6%NHP9vJ=kncR3PGM<>3J%#D!?x`IXuRn0Pym_Octg^`Ars
zP4sD(xRDf4OxH@k=ON-Jdc_dIr6Cgh6Fp|c+uabd^>PlTt?hgH8fa1dGi2p)itwvi
zU+i<K$iI>$E9pm(GRq|B<ZRTr34_~M6|#{FMOXwJAwGWc#;w#n!!segi2I#jsnN<C
zDznPgh8A^1<UL_%dxXa^r;F|aA^~Y{DShurDaDXV)me^D$x8hr(~5$O{6r$<RwW(W
z>-hAL+1}snoso#q)##lsMdccZoY3;&QK;!3vBhU6H?gU5IO%^Y68@#`{{Xna1A3C9
zTLgK~W}j5=ZD=cl$N@xdf0HblflIGr<{X>9nOo1chQVhQ-{?R*(#3RG;YLXkPK8MI
z(zp|aMc!?MKULy6Go3J;c=8KWb{Bs2GIBtUt~c?xZGg|Z;w^mTpGL6<Zuubwx34Y3
zNL1F)AKZs4=fGqQMVzlA`g=Sq@;DFacdlyK`$j$D`9V0eJH>Y59T$*?ue6J{!Zy34
znIRBibBS4!#4NpMmi`nxB>2|`_WsH3W{AJOAul^GIYk$bmb-CIArH6<7XdM6g<Tst
z>aktYsOnl28>#l&rs4`T!C0dDvl_dl8*GpbBX>YTQD^93>Q|BC+%C(ki?$r-mTdS%
z<5Sn1?rGy1{*f9CVKCJ-?pPO2z-Uz^m;|;Q-K6RGk`%9e^JE%4N`E63LJstGkK~!>
zcm8{H(9S6-6!maLa-Cio<$Uo0Pb`Y=-J-_#zUoP$eU$WADG;|n_8|RbqR$uNkGQ)E
zd&mF?0%7~EBbY4dK&J6&G`I<JwKP^4>Mt*+)JK%4BvKO%kS%FXeFOc!SQi=j!LcU(
zOp@Z#jN<L{2!r(JO&Yysb^Y638p?_kY6j-9lLZU}TjgmK7a79x#F$LvmoCfPR`Y+D
zU|d-&`1xsgC+4=3;t$@<;zs1*)YAr^f<>3k)bKPmS7I*T9ljldFo=}w0h)J>=|A{;
zf213#d=q)k_`wuu&mq$@T7CEl*RwlB^bw-Ip%6U4y{3GCF8}M*2ooN70k=%EgO95G
z>FyU!YT+Y8VSb{v0V;247gUz{aej2TvOL`T%jIuE(DNKvPYp7J0i!W;!%o8dOLM(Q
zuxKPa!j-F+2TiA)^UQv8q3O-Vmv0i5-z17pFn3R|4ooDUnMlo^NN<|Rd^wT5JdrCt
zdFND|?kv=CJu_x8UMYPtuQM*4p745I@eK$6*&TLmd-8mm)J5-$F(t`m^~k7QNzE@O
zZ|+rRBq29B86WWun25$>$8y@7E<PVfJnrD5ZN})`|Mup6hWOxg=W)G(zhaZSZgP0H
zMWqUrXP*o|s#7+-q8j_oVw3r-JkF3ToqIuVuC`Ojt>Jht&#JNh;$pE{>*U<K3n9;$
zU!?lxUZXfjv40ofJze5Y>HO!r{NWvRL_fpG)h4Mtcx+ufhGu_b_iQ#6ow0Pqb(;Di
z{pi~??3+KadTiI}t^kC8(Y~LIDG!dOh(U1XW^=E2!?FACcaJ9W2CkJXzuk4>gMOez
zHm`@45C1g^_d`Mhk<c+H@Roxd=lIgc<nrbumuZM@`d$r4?`dxO%Uv<(aF@l@`F8nh
zN92H!K)vj^w|rNWEnuN)EV8#s{2z&6i#6Y@6t9B-n?<<j`T-;5wAkX0gj;H--+i<S
zgM^S^eG@uwll3y`xK=jut)LR|{P|&?zzlL7TL)f~@Ysnx5&Q9?{4CEPkNG|hG$?wq
z+99A>F4a}oO^$yK2C|soIlxf+oN$m7wNIN+$z9%&ai5F(JI@;oXFkyU+H`+r2Y$o%
z*F1kFW&f8&p#pW+0xc2$&oDR2GS9!NB0G9=o_OL#?B=_koH&b#Pdh7f-edJ&md|yq
z9zN~9-)VM#LLC&OD0zDB+pmcW%F0R%iSND2Klqiye$|W5^|WYjmJEfL^&^p2E<(hm
zfRc)ArO|?n^)JHX1ON15Y%er{T43S7wHNUY|43p?8a#;xXL7Jz1*Q&eVw)|-t+GH3
z4>mnh^}g=M*0CSxH{ZC*OO~g8Hmtu~qZh%*;sZHL-;<ipxvy;dql@;4E;?d2ojxLV
zrlOyf9eKiEet~+wKR2$qV<hp|cOR~wWSe9i8rXa*#_kbi#h~t9M84<2Zq1Cwp7`E5
zT;_G`rw(q~D>qJnh%TOiC%TR;x+i~qnH}76?t`8b>h^l($VT>$ja<piJpIjrgPWJn
zZeGdVEV;dTb!4;r$L2N3zrJ4O_h4^7CVj-s&b)uOtX8$5-uYMA?Qa$TP=uf%M@ml5
zK&47P+`P1|H9MyqyL!C(hpOoZy-Vu{v~w?9Lt5xxi_`sQWh;E6M0sQaqabE@`x<6S
zLb^#seL~`=SPpXP{Xp31cjXn!<jHp<9}d|dTjr7Q$S#`;GD=5yRHHl}ul!Ztvz(p}
zYTc4ZkT4$#xC+F&NiZ={XH7K*nQaSosWo-O*<_+|dW4Qqnr#wFGKp|(Y{8*W>qv9p
z<k&~2VuO>zwZ~q4I*=bBv?Zp-$s&21x~czKzpaS}C<g>n$v`Zs&LPw=`KEEu;bPa4
z{Bi9gCy(Axe`FY@uqVv+&WWbxlW$)ydv`>99B%Sl$aot6LWn9tXescz-?Ov)@5=4s
zqd*A_qTN<6zc=`yvigbXjfjO>QN>wzlg6XE4j_d-|KtvMl~=KP9Ol7a|8JS#WBaBx
zkyW925@+^?Q6o%--eXxehO!MixE#jrjM}%;o97lsuOF0m=`9%zh#Z5Yt=n#T;g`40
zWUljb%fACQgWLZ;Hr77{e!y>@`muAZE5;!`_$M@R#wuJ0smrj2`iEc=ALDN6-b9AB
zkeU7XwC=V~Z$lc}u|7y$m{#L+wL4VD(Cf&93VHaZqUsEDIq#^SwrD>a&D>wVP>a`W
zEt7PRTsw!LYrqPz1;hQdd8#B-h;d3Ecs}WXC0rg_+QodXrCxkq$Q3COC)8D^3cwA<
zq?keT!EMu~Utg-KtNH6y8Tw{YP0U7&58*El5gJS`rx>Ll%$V^B8AglkS#!0KKB;xn
zBV)>;Saz1%r@2?^fuuZmz#v1}T4<5Lh*lpTS8+*ST(}lp76NhHJ*J}$gqJzmRr1O8
z?w?d*y%Ol;Hh1HeH;4-_TN*?X`Z92c``R9p0f&CMPLg&JS}D@kZ8JSvOOHf(hd=uL
z$Bd<*b+FRlEbCTTe7^`SGgb&b&~+{=%m!;XS)%(sQGq;|pD^L@)hW6IJ&4|2F!t;P
zi@S2_8V!w?IgmPnFg{>0y3llQV$LSlEUn-cTJ^GKc=m8=`R-i=lVqd&1god#H%}G^
zKu5DLd^h?iUnAtXu<!bUW`-QIbn*-BFFR;ZG`-a8c8N@$<)EE2Oabb#z4l833D71*
zB*gx!_TXliu6Zq;8u(7HmQ1iM`W(^#DLT{K-s!R2QYAZjreyW?#k0lNi}x`2M?^~t
zLpq#yIqy2?EJD0?L<Ilq3iFfAVuY#m^By}#b@w`2(l4y8f)-B%P}mE3Cq7an9(V?y
zXB+fxIM4UZ&$VJ@mkVwjw_(rTNn4AOvokFDC$<13;j^mNlOg+=`|TI>KbJotP!ByD
z>-pN17<DY~ruFww3+jeY8K<;5%s@MD2!FTY*yG)Cue)F``lAziEwiF8wUDRZPZb%L
zy$zoo(hmnPCqUw{r28^ePOnMj#OPnr_c`6v_nvl!+8q*H1{3@9tL;@gf20K79v21V
z8^uTFXqz=kvb2WGEz>ZPUxQ+#AEEsT_tnvIsnO@3`F;H>+_p>aYYgfZn*YM1|Iq}_
zHQg!D-&tlM_dqZco*H~5{=K_MjSN*MWi>Tqu|`bd<*EI&$H+s?w3>L+Ipl1|h}Gh(
zOp{NKCZA?|WZ??F?fP<@LOzoHebBPvBPu)?T&p~P%4)tomy=qUfxUdFTHVe)zknd3
z_PwWE4T4p<#Spu^h=b(yc2g;#?!cu819i9Ws`QL0((62g>NWuf5e4=SR@Uuv_~?QF
z&0UR4e_{SbGln^J{Z7WQ9^7}WG+H%UpCy8R@9JLqs*s@j-5~GcI9~6Y8#EP3FbC-K
zD(z_>*u4%e{!LV|#8tsKikH^iQspVMnrcwlNBx~A?uimbspRsL4~E^9y!1E9V-jkv
zTf|WF5{4`uQzy8F*d4C!0)z2HoQQQTQ_tMS=?9en*)xGdEH+T};IE*wu`+~bh3Q{N
zwPPIHLt6DRq6akM4wZdcvyB2fsAWYV%7;HD>_K_EX2%__ebRSbIwHle!;cU}A~u|9
z{o;Jn{77Takz0`Si#Az@3nSsDZ-qVcb%L0BwAY=#MQj|@4nt+y_>h~<T@O9J9C!5b
zrz5v7ehl^9{(H0w>e0ed3-c4d=qccKwq~9T3sCZ|_i#88n?r=+l`kF}`YsDZ#@-|i
zqB6*Hz0%-TJAfUL#=BPwUnU(1I{we=t|-?|#vs|J&I83i#A#Qzc`g-}@b7JnV--fM
zpjQr==U~?R@d${~tC<q<GGS0wBap!kWL`YJ<ah^VH`PnR;E;peCqtH{sQTXz-CC+U
z+Ic>?k5()X=m1)W=@<U9cr2zuE=v~6)`SWs3+Z?0lJWzlcKX3TwMKiB<V5Q}+F(#(
z*3J>=X?Tj~n~Q!3oe=cDm5~z!O0h@h$;V)wq1_O7sK$Z7U51Z^jP<lQ37j_y$-A;d
zw34zDW#;XTb6`q_TLIXogVJ_5n`7!fD;Azye*&7J2oli6wZS;j@7}(6c@z$o^jv_z
zy&}6$pvvl+r^-(DuQuYcs~6P<Lxb*|TcQy{WBH$vjeGL3y^0L<l~XFONmD26n4fhM
zXD#1QpFb9=6c-l)f=dWzEVE2d7-@B5(1e}k`~QNRPd(gi<7(&j3nj@%mOK%<AQ^+r
z+f}t4AbFZ(t?)is;zpRBN(h>&OZw<~I;#YKa>rih{LfsOP_K!edkzL`Ws)c3zpAv$
zwUYkO;eOLK#0#-$omq!#oz(jrgcaeuxhlEPrJjDy4$OpiC^KQ`%EY&z`%X7GFp4J#
zxc4Vj)^2}p8}g&dgIIX{4k{-Cz|2h7Q_$bR?Mz`cE9vx<W)1hCa4~`$fAP$t-IpRR
z2WlxbTz{4ZqvXbGQbpe~E-wKjnBpF1EI(vXss`dOZhusG;Ds!8_phq(tj|85!A#+J
z(+fYC6IGgHSop%08*F3GNwIY|`FQ>8RbavErR43;HtHvSmY+(PI7w_DUiz1_4y`K+
zp<AmyHYmOZ7P3mH7Xtp!5NF_l`!>;iD&~p-8Ei$xKvz~&XW@K05C6_f<8jN;-?<Sj
zV9PbS@WAO`H_e{F6mja@V2ELE=#F(1Xk*pplR$*xT08rrDxZW6Kc69g;`f>6Wt%Y&
zeBf0r%eK_sG>JTh&%#f9^bjW>ZoY1bP*w31D2$u8b6<)O-ptBUb$+3i{<Bx<ai@dv
zPsCF358*%v$wt{2{?vG!DGo8?U!1<4cxg>112Ms~@oXeUq+IviSxt0P{4SjvYFdM_
z6B&?O<R=30IYg>d*xOWkOEch1g7}C5!7M5x*=vz)=}8i8B#AvHA%;le(<F%{lH?W%
zi6EmeWGMv0m;-)VlV+?5o&^cpQ`_#6bpX%qiEjngLMWSu>3&~sN+E70Z3vyD!sHxN
z9R#RKxRI(KEMV}-y-K!zH#9Uh#gCY*-;rKYpwuM9P#q$u1yV|Q1x2(5{l)@iXKf&j
z_3~=k>qkkWEalVnNgZ(LMyzro8fM&*{>sU`$-gHf)>=vT<_@m10q8X})&@vbCs<%&
zF#Ck-BLJJs<##|$gIU02>a~lR5~2)8bh0lgwY$T(w1bjAs!bh&In>%PJ8VknO8+_H
zuhRM`2yN;_dZj>4vXUAN2iNn|doz206<9-y5N0)XUv0WYR(IpWKA%Q2X7Iy?4)Pqc
z-*dbHcqYqP1gn05uw7Zv22%SNnG(-oYYbu42ZjRF*gj;sH6!_0d$uhV8nOaC*#)uh
zDk!-nWUZNU1`XY}!mZ@?Cl1<#Kh8VbnC{CJFY#ATkEjbWMCObYr<K^1<Ans6gSr->
zi}Pmq08vGwjOeJ$6i`1CZJ3B<1FjZPAsPM~uvIa}@mK?9C9FZyNa!j&uBD|mN!X3A
z^Tg>_YHqu>bsL<bdn1`re|J(AEaI5nt7QU6QHjZ88L-feW*`{C)nwrrH-HHPcVGbM
zNX>YVk}wEMpUCl?fG43;Oc=S*UCC2(&~TnOhSe&#Z~rtq8`_>H(#TB<jvcY;sm|r6
z@~d7Sb8Py{`Ztl2zL7d=sJ}5M^m7JEUQKlte&*{es%4r|O~e5$@{#^&M@Lg?gYCWH
zVj;K(z65FfhE(LB_Ug^OgY3)C8ix)PD7FuFhi;Z8CTaE{v~5hEcviBk2lG!#Llr@c
zfWg!nCsx?nbHEdNx){ctNx8-mx>E+PoJ*-CHMDL)%CUv|lc`@t1l}V2lN!U}f56R;
zVJ_DnmS-S)*fw>^O9yJWEVH(|Ya4pk#!CS@yLtkGCkofh9DK3WXBL-&{5AxTOquWl
zO~EOHub}oD$o#h{cL0S|<C}ke!EOq>f_}q<&Wo`gsucaab~4ZIud%kVX8!t|km6|a
zd+D@u6N0MRNu>{a3<}$G8u1;&%)w!Hix3qJ3#);OYbWVfJ%B(iH*$r!95=oZgxlfP
zq3JwLs#blj_Rev%(%l7{j!9gBd2hJZkVFAwRz5qEvn2rx=6fLk^I-YWLOF^nRASyD
z3Hu=J>V064SNWIc+pY_mba(()tqMFO{qcsvf_u7SN;kill+@CgNEhBsOYKIM;_H*5
z24S%i?ziCf2QMeZJZmF*O5P;H&uIyn0{I<I6@aH6i>F?{@1~=;0+V;x<@e!Rn$_69
z<?JE&(ZIvChV1H<6z@ouD>L=lVsbU0ji*;G{j{YKp6i#STEN+Nq|-XU41YAtbtMO1
zdHob!bpIYP@6}h8&wB%cMg250e#(rBR&oBhDKg>||Ds;k2rkrwNNifF-el^q4(mKa
z`<FQ^sHgY#mUtJ_A$lbx0jW~S&24?0Yq@dd=sS32$$vFco=j3|(tc0WUH5#0^6o55
zAopkuK1myWKe0H~xfpKJ(O0$$b|FK|XC?J4-{|nupSfpRz-3xZfM9UBa=$tlc4$I0
zbOn|<T@3`kY{VxOm%~esk2g+qzhx81kt)`<$I1=i*-63_IG9t(vSYAW7xMJGz=jMh
z0ZDZqoNWqk{aEQ$hWEa6Uc$_;%Wux>$+Gv;ZSO8|pKc`|?rxu+{XV@11Ut7r{bzgz
z5_|@;eV$#mGD!pTZ^8FgvP#cOXu-kzu;Amz(>wcg40)Q@(^zfql6D8PsdQF2`8d_}
z`0MlUo(Up904o3~Swl;W4ii4jNL}}Y9pVX*4~ybwl6>n+s?%U+XUJ0B2Oi!`@^3lp
zgGrI8713CAupwsXzAaixW-tFv{mySXE;p%rqa5y`sn7AGJX}^8uZ5dp;APz}3Xnam
z`APH|11^boH4Var3y*B39*xc0R1@KE!vOUxkopHXEur&2VaI7;!(cY8(&T_~3b{kb
zu!VhrA!$fIah+&<)|0J6ZLaBaNeq5=@0rdaP0`Ramhob4;-cf#G~t>wurX28Faq`R
z@N9aEUt*V^QqYXtW^;V((E@rKKxF?pnO=`NobT!Ig`7TmL`REPc%FgvLL(NhiWqFd
zcAM5DF3QN~`R8xU5ly5F)#tvra$?hb3we+YVDcVZU(*h?fRUt1rCD!4!a7oDro#VP
zg}oNR0(>KF0vZzg>OB9naKOrK$CUwxwu6cA+s2Eunl6Wu7OQ_kvWbjt<_7D8;K-Gb
zOfF8d+?gj;q`9O)$_T<<m5x*fQK+QFmlyal-Zx_=kcpIZ4VwR4pQN{${FW2=>1#fn
z7<7vSQ>lTQ3y79Tt{_qqERoVIouYr)*Hm4~&l4&)H_jArka@lfV(+M>Y;$RNaF@x=
z+H{@Zl#gE_J4$If#M|>m`OL1M$erX3S<047+JcM<#t7=^U!}}C6kHS(QunF(;^)|k
zQ?wL`Jsr6Y=;Y8rSX^bwH8%KEOG*?Y_f3J=?%0|5*km17IeUhK{e>e;0K&PH?BNO9
zXn72vWo!6!DDSGimXT;cS8|MIhE75K5u&Kq>PVs~w8pjX-h{soBE_XXIijNupnplE
z!itMd_shTw%hE0zTb<Am4Z*4`d>a|m302Epl%LHLbk}rXg1PasoA=tcPJ55(hX|4=
zlfm+2eBG!|?#xLRnoM#%1~aB+5L>FVdaqn)(RJ<GH>`uW{4XilK`LDo%GFHL_e@Qk
zNFibogcF&jnpv?krObLtw?O@2v4p;}H?aa95bMe8GEglMKJyNCel)axCpBgz^l3P;
z{ZiidpY2{8mNil-v3^p2Mc6a#(*ZN@`wUTH@Ec~O-?wKU(L>-LKSf=BrS4zRt*LzO
zz_0&Wsg+?t1+NCx7}wS<CH%+T@TuA8yoXM%4*s0p6`r_Jk^J#{!5R#D^6YKBYs^6i
z&D!ty&NAgeSvOBTsbkb3p<JgvnOm9C5ey&J&L8>$57>Y`uaI_X$+Id>JG7JPpqihM
zkg;)hTu3)dqNdK1bA`(&vnEPy1&MV}z=RQkCX_0vl13)x^MaREUc#7qdrj{pUp;q5
zd@tPw$1;03eO~0yr*9c}(|xh7L05T5GrhfSi+(3S5N4M{?P}_9O~qx=SBYY##-CHN
zYSo?69!GI*xuNIod!`W2pKu*qNUsOiY}{#5Z{_E703GHsfBe)EQCgL-y_8%XKF0*Q
zoPDxm>1jL~zYR-8rzg51(@=*sp^OWgFt0gmK2qbS$W7}m6EE!){_e8VU=bT^*1m9I
zt|szepsQIWY+`4hnyf{cw}Z3(8l`GA5vc<#%3Q-}Zg}OcH6I9WeG%WXw?6nyJUv6S
zVN&Yzps!6sUA6~jBRQG;urgn0Mk!Qv`e}^k>b*r)b!^J+li(W72xf;wBB{aqag)Aj
zYW2ps@gDPFn4j-83Ccz<QB%moGe4GB=^G3olHhuzuknl@_hKPF3|1QBH)sBO)iA6n
zFNr*Ju%-b5v<U5Fr7&YL`J|x)M(Tcgnk6wsD@PObA@x{;kj4wx6hBHV3Y&G3I$+FT
ze`WF#c<LN|M4lvImXT_;$f9fJ<Bqyt?Rk*-c_jPCI#f=fOg6Wi)ROxicD4&@aLf9^
zd9g2KSeU7=VUVb)rlg?3L_e!FrJL2Dmzmge`PgSgM_gV$YA{~0Nu;L65Hq4Q?K-He
zT)l7lXa2SI9~-*_F=xXfxa(d{olMh<HLe$Z^8Wt%FR9^0YW##>1-q3?gtlg9j+}rc
zq!(MDPpMYHYCyo=$|ddubPp+)J_v(oq`P5ZVLd76%bI(6g?KI4tIJ}0JfY_QQe$I3
zyygc@95pyC9ckVb^n7^FRA6!f?HkiHLE%us3w>W;L&Tm>WNVkDnK0PS47N4=(gUKN
zGeg*Z5Nz6<wgP7VFhc5efi2+tD>Sf82fq?8#7F}_%PRw*l6dEOI<6<heR16FkPS}W
zBKC={@F9%@Jvkz;#zDgUs?YM(4^}%jM5?_g((~nJX`NGlS!!~2Zm8j$#z=)_qL8?D
zl;&u)T`vB>%_yx`buQN^+1lr||GVjN+yCXw^Ez*uPdrT$*NN7hYzrExK5#2~_uG5n
zAGp~%F?#PFM*o<5c`HW$!;?#VAqm}B;w(2s@`|&yy_hwSu}d{a_k!Wc2B0?H?cR6a
zCy8IwaYK*wNS{Y6yM68iEgCYOH~aReI}?V@l5a_j@m)54L?1NU**S?9syx3m*PlBA
zan<Xx@(%AZ{rY>LGV;@KmD9S&=MR<#fearzy-OCGt(@X{|5!`XUx1tXFKgBN6@B*O
zkNFX+%ifF_j%?&=ZsIso!#2L`Ja@_l?ogGi+7o*Yp*{=YQFpVbepG`gct9!>F1v9&
z7NXr-dP$?2T44ne1_P+0hx0gAJMA0(vU*Yj1!ucDKjSHZwX1K*FOm1Ntp?DmBji;X
zo8t*RvuGg4OkwRr#!>$-UW%K-K)TlJ4e60R+35C<Rwt6Q)Jvwcz8p`39huE0_bqaB
z@<aV=YRPX%HGxL3WOOj#o;FCUI)*RR^keWf%@ip7SSg@p$25d@Ht!EXKwmp>fup6f
zW9WnSaS!0+L67}XG64;0oxIU3wZ1@hm8z<5y8kPA(6Ve>T1+V=>(4=jhmmrO+g;zE
zqYg%BPClzlg|=knCl*#gcg+jW1Xq9-DL(q3T5F{$F(|3Ja9)avYyQ@zb47{2B`0=1
zM|eh(@S_?1;^Nwr*kN^-DS5y`XUBthN_y9W13B$mMpL)OA&AhXwtL>KeIeIJCoR#t
z*rQgD0;dhmD}Ni4#y}r5(14@UH3YNSEa~AF@0|-z8K^*Aoh+9v#44&5pdoX8*3!G>
zP@6+(uCo6&0$z;%ma^|1J8&uld1F6cp*P#=y=yuruYUpU)FY+BK0n#cJ=#7M8hROV
z>Y{55{9K^AwZb&?*>T)K+g`F)(tK&h3#+x6ZqCbvu{Oz(vws?!3zOQE9xS*k{kppM
zBrpTr2kMo!10wn7E_}KgGb{~2wv7-tR-;RrLX(IfYP<wcY)}IHX?DX7BY`s^v5t<P
zLRy<W_&J~h=`tGX29NBoO{Tp2B?McE2S!&3ebJ9X8UufTvba8$>q9*y_xRKCoM8*A
z=E{Fo`*I#{t*%Fv7{SDIL|E%8Hn}^$Z&evV{~gc|QBymV1wOGd1yw@`)yXLZ%JRF4
zZn2N5uz4Am6s9X(;C(16lFvOS65*^$(xlv|^+QFQ&N@`yMfOJ!Qw)bB`+|ad6#Jp{
zMJ`VAB6?T*`Io5_jK43|zE>4*knZS%m%h5#t3ffya4*Bl-U{y1@kgbGaC+qA+N`VD
z-4Z9ep2@4-f$Sac7Bxv{sp6}WcbihA!d=r<vzTdDTSl|#S-qG$rpj(=EG0<5K->wx
z>`?44PI~Q?FZYmHzqW&vn@ZCsk@HZmtRC9zAo#!~kiI=e=meMQfD%NV|NKWlUqf8C
zvioBHvn&TAdODe0TBX5Way(J@Hih!1s-G1rrJ!dZ?;qB!^Ig1|ZkTR+O1L$3xQn9p
zal-z3Fn1`?RJxRZTP9Z~@QdW}b{rxT4xI*OL{3(o6L59yI*E6s?cxGZg71kd^-+k#
zl{PiE41^9Blwl%6mKfd;-yMV(iG79>U-_%zI0%RsPA^pMP!}op(=mq2HG!g_>Bbzl
z+m_#Z<v<eyN+Z9O*o4zZ?z@9e?GU6XOO9e5i&?m0p;w86g>`cKbIRs^zCfKop4ADF
zJb0<QEZ@TrSRe22S@|Ot=A(*Er78m2D2CNx5UP73#n|Snww`e{dfGKb4Y6^>aw|o~
z=yZ?OCqGWKvoS7vP-$<eTjuY>nsV*D(Dz7pkxrrL+wGbS<SuQGw$eR7*!fUkW~#QF
zYbQGLjh{Rs<>b64Y*^6?K6gNhtPsVkN`O{d6H}NH!{RmV-Lyaf6iAJ|HFpK5KR~R#
z-WuzA1M#urWIMh8iavp^l2DK?SLB9Zt<CM?`?;-~_e=nu^Tk`%RMQ--cdW&teUH7M
zl#Gkh03qf9rzwj9#-_W{R8`hE{c+|;k}V8Q$C{5)gtqe}Jw3baL3H8Ah-wlG-Gi<2
zbTg;@%)mkbnIm}n#O+bUY4{-4Yvv%3#T5Iqo2&0mhd$2wD!n%<Na-Ownb>ad%mp5R
zUfF=fNVjFk+~`1yZhdFZp7iV3QSF)U%*A#@d9fE%<IQE>T2f}YWdKS1(Z?}UK9Y<v
z?X8wWgxl|~#)v&Q!#wqkDggEYlEcTlv9Gr5Ef(Z5;^TM4Ls532PbvxTexF27=RsW+
zx|Om`dKEV5r>#?3Z_(*tGSd;)udaeVD;1<(o~}y9AS1jI+nF8=Pd8)3U~_;$M(f->
zx>43Xu60*k(lO39$5ZfdplhGx1dFTf{0zAA9VZ@4wKf%6neVJ0Q+cz|@C?5ztH3~*
zyE|x5`%;g@9>kZutrh3bpUn>bxxl;#xjc4ZM{s!XUz~Cvqsm2w01Ky|R`J;XCZe^f
z2k@js*ITAxi={<aWvVJ8m9D5u4<3BdPQM?E`?bekMkYAwheE7v+MYiK{Nu@{)kZ&O
z7RXENAIJA!wFq>bNkq>}O2&NII~)??(zsCJgAP1m`gg5h=rr=ALaoGat}^R9%77)~
zXUk{odO6T7{$Z+5YUQC_ak9Ix<Kg?XH!~CD>TdrOAW3-|7xo~?c(s_k{Rt(1Q1<z$
z{USOEQy@5UAJ?Zp{NEDxeb#79zKtI{)&w|xMXF>c@BZnO3?JC+$H|Lz@`k(smCuXS
zZbGeDMIU=)L`IFSp@d+mkIsGP*Z&*;QIqvSvj86X?FyL_JzX2^{q*~>6P8>H%mLqR
z>=`1}7<<nmam|4FPPE!>yDCy6B3iGTVd1u*%rMp5=0Q>SC|$0;7W|%QyW3~C65!n>
zbPicGY~z=O-5ff&;*my6SF)n$I9%`US3{|3d*kaQ`0<B@a{3uTz#`&D{MuXs6eN85
z{b(wBxf{JSlxbob04JmI$aVWomlU_01F^%h=ns~KqTS126An{h%?I!SpXvqU7C!7W
zshsLi*?Ok(6E~3ZpOZy9Yl-A|S%z&DmUR6$+p&seq6<4WE_1#M6u#MGG2>C%2MV7(
zSPXar?LI4o*&3QWfhsw}^y=}ze4$-K`!;&#yPYgFm6mbrQQ4t2;sBt9)c#2$Y**g$
zn~4CrWLG9F7kWAzL@@Mcc;umj3*0(`0n3)2(jiCXS{fhV^|U--Iz|kbP<zSj9?S8h
zH01L}nQqNO>vbB~`kn1IPI{f~bP&TeiRwS2<w-HMUf1j)_p+k*T)6|P#!C6iaZ@t0
zP@1UYki40L!61Afm$U@B?T4fabE#NiR6Iy|qFY|(pkqA<zrfVFCni5gR^DP_Hm)8J
zuuLQ8Vhvo@WCINSQS~CZhUPW0Uyv&O?~U98qzwZ0_y?GT%$r08?2Vh>n-pN0F>jh5
zU{<P18?QdZ>9!kZ4;+D_TDt9Ke4M+wN%2fML@)iA?S6Ca{!jB}`F+|n)*eJ4S&E>j
z00H93`U|Z7Y1VjOZyv56@5$2IB`l!F@rnIx;*z5(Qmp?7#D0fm|6P<Sv~Uzr_~bvQ
z-2_`y{df(bsIJ7<QTV^Wp$Y*w&iH1pPL~*N2K0C_|Hw+M)ds<}qSiBvYe-<ZYpd;D
z%1|ftm9oM3FfxY9)!Zn`>LfVAUj|bDpCQMqZ0lvKMcHA5c~-`}Bb6Vm>QA0(|LAtf
zR_&Rm<#eT6Vb)vF(2DMVjvY0D#o0RITxYn@V>(l2i0XT!&+o6bzn=Q>B#4Rv8%Kw(
zh(OwQ**sff<?I=rCy10KxS`NVL}Z}8>0~2~qAM(fB2e_{Jw}XavMHR6>3O;cvA^te
zv4!bUEsTk+B8R2$EtT1-Gf9Rr*7{xCN4t7M?tKdF{}cvgoO`Gq_B@D!)`-;p{AiDm
z?h2HG5ZXPXPJi;6?pSx!Q$YdYY&xXs7C2#5*z;{P0|RFf;bRtE#l*#88DSPhm<0ln
zgtmpQm5-6xWDe4Ab~5?;o}{HL)~C+i6mb?=*xG2NoPB{MQ&G+^VRctZrN(KV3DQLA
zod5<)tcXECp!+SVrr?C(LbPoq5~TVG9HHDND?B&TOF^-zgh7cXT9?UDN%<{conEdP
zJ=M#>;mpPxLr?H$G+Q>-`jkwMURb{+Ht;yZ{{QH7#4qM+WR*X{UEMbfwkYOHJ%qli
z(Pm%xmOL8J_@%l1%hmkTX2n{i&qXlpS>NBupt*~l3<W1BN#k*uU<+BH(z=_|gPX8d
z<O%IAv@W)|dE&ou*%^<0q{9G*S>6Q>Kr(fYj2t%0L_xc5Y_U?A<Wm+}Cpyxq4PYkY
z%=nMJI$QmQq?EF9CDvxo{=t`=d~FG?*lmdrHUwyDn`kNu1_(W8W$MV9;F9z=*ODMJ
zaLNl)R=9FsOg!139r0Y3I=Rhqta_nBf2Lh2rW<89dw76qqCv6vW(iP)in>h~toQr}
zsbZ5g1lE+sp5|T_W~0t|L1Z7Y++d-HkUd#SqjW0Ua7{FNpj};ZOWg{>cQAtd0~>T|
z?M8b(q>xHJ-v_?(Um#@;uGI4CY`Z+LrPe6iMd)(EQWYM1CKVERQ6Q2mnzxTSdv?M4
zVm}1w0McuO8x!PqZDZXajI1+@Rv65%vdv5F15MN-D{Rx4GP`}l8jF5$c0p|*$(FhD
z#!?e~UpD#QVWz>dwdL^?53Wya7PonvoHo<l9Om;l!Rf8SpmT)X&|~Kzw)N<+Ee}m?
z>a*_R+O%(jgE4Hw+ArjZGu9T(6m0XHdFZ@?jdE0q@nKMYQN^45WO|^c1?M<T&X(qJ
z^z(z%=YOr6o{8$5oVXZUWHmi{V+UNZd?>}m-Pfn4%}(oJOTHj5&2L@^SvIkGvAg$&
za__YIx9{6fy{^ntap9gmcAL(Nr|`*Q4&X8LU`+j(1yb~38t&DwfZGCAq>4-{^-6r<
zT1|ub%eHF{-KVd!W}gTvMfI<7K<0F4JrwwB$mXlFw|BrhU(Z^u{5Yai&}sMMsK86S
z$$Gqqb+;+8q$G{GP0-OgI*e2t&mFL^evBS$|9OxhrN6Yx1{(!kMu-Z8*vH{L+8lDI
z0FIw@R8U{X7QmX2cQd+aU-z&jb$Z3$UXjp2?jJl3-m!z}w|KH&N8#t)7F{||fX#!Q
z-}~4Jh{<G4Tp<*|5aoJBhUhQl{(>?dW+nA6SZ}%(@K0d11U$_uQ0c*ir1RH%43;wB
zw%;iW5tN~b_3@uds=c_SjC;F(dbW3GG)@gFL#*>P&0AhyoB$>L?Xlz$Erxvuvrk-(
zwZ1*{`~?n)3TIuLf*8Zough51O|9G+79`G@<(sUa@JLr}8(pJbL{FwwOPfw;9XX7d
zEgN~vBEp^Cjf<j)%#z#NQWSXISax+`u#GZ7-Kmz0Z*=wTV5-InX=b|x%`x>v1NO$S
z^`fBE?MSms`-j^s`;t|2d3z&WaK{Cx_MKIWLn%PFM$hOuOQ(MA35xDufh9PKB(_G9
zjv_0rkyWE8I%||eeQ&gqQGGTlHc8nY&V1vP@*|$c+lI!@k12SZdk9u4bQeTDHp)oG
zT9d)FyV(0iMqEG{I?`c06TWtUnz^)?@_Lu8etn?nQkz2)`=w0w%+09nv<3?NxASVR
zS;Hao|E^gPPPm0N5{fD1p2IrNZ#uLXj}qsPs6f6%8zOPPUFs2xWl=NvzWdWXNiy9g
zOQPCNfeyf)(ZHxfkI&E3LOnmQC*i*YuaDc>4XcGTodO4qULoa0c^r?cx;M$d2fSCe
z=lDydA3zrl0p2TYt?cUXtkd|?cs1V1!Dv{t{@D2-Sk`45dhiS57aqtH1*288*K@mP
z@C7Nw6$T~_Wb-xA8H}}MS-C^xFh6M_-GI;&8ZrFva^^qNs0+nTN0sl}UTHmde`KUK
z^W3SmV0ZYrJAa%jvt<@U_FKrg4=K|mQ)O)4SO`QGVG_G}&m&%5Q?$rUV^Y#1UVg_2
z?{V$P=qL;dsHhIxbL4kSBPsY4|9)>rR5Z-C(pgcncjVX|{a7Dz{t}BQ3kv_C8H(<)
zT(L)S94!CG(|P|>`N#kNI>T|ya~$i~$KE>jA#sj*>=j9ry+Q~{;yCAUj(zNz>{0YS
zBx%Xs)k#aGLP$~}iH7s_`L6%q`r&oEuIu%DJ|6e`OpBg%N38=nohewHuOGaW{acKh
zj?bs*{)+pelm$-^6Yu+ce_Un;t`{TeI`iI4fuhf<Go&*x?YBXb=%b*4$(~YdjYDfq
z_A@j!zU4+LBH`l3uh8iet<Y6dk6BaDOs*iu0_%%O$)K+;PG^Op=QGGAyYy9jGe|>D
z>0$&8EY0hexeTC<nj16m_KjZ^v$K>(e9xEgd}UlM7f8Hx#~E*{@OMm!!I#7yQ;Q#x
zqie*%FTPR8D!fNj++dn{K}4TVy`nyv8`)9WH7XBeO@tt?{kag(99SZA_ld7HsRt6s
z&~#mkUwe>sFiU<iL3kgGJ4;Oepz7P+JGLlkxx_4}zd7xt488rp_C!@u&QT}dhj*Re
z;|N$qsq?-g)ev@)%V=*H+czOvGkgwhRKE=WW)*psboYC%W68ODsWrPNiVaedB;OpL
zEPd$1=W*#@%!rw#VD_i@F8Z{sHm33)L1tMt)TM%*K!ytpeanz!|6Z8+y|!<uVAwFS
z7jJlb@cYHAGd=GfP1XIl`0&-pXRo|4<<T>uNnIkjgaJs}%!lrXSP@;C&aHcdzx)rb
z|IIpuB(YP@L?o8e3`(I7CcjY8p72Tu4*MYs7G~swwuw}XLXBp?+9+hV<b#>ZO9GSp
z-k-71J3an!#;5hjYf%&WNWq-^1FsWCle>QjVIxhVUqyE0FeB+tibmdkn7S{B2))>A
z$4GuFn7Sx&uqdB;2;5oHP5pTE;G;$Avi-rbd+N%mgOe4;?hKGrg(B+CAU<YLnAh@^
z=Y)1s8zH4%o_er$Ce;nDKp09Tgs8fzENjg}ez72iVG1`S$!tA8i`J*qvw1;s@nd6h
zP?NsT=I}ImB-;#~_C?gnPK{~?Uw4hU@PN@a&jA6+*`enJ@3XLuyuq%fOmhVnr1;1l
zJ80kHp=%h}T`O2;K(|poBi}LD!^vD_&oeB93j<i*zs%nLcT@!MH_zY^GqCgu$4Kf!
zl(ik6!5uB=Yz4RYJ%J!%p}cLG-bGZfU8(xX-uQh~h(i$oAVCZ!dJv~`V%<CmzO0@0
zCP_p;d1qNIjoncAqqQTfF72RKsFJ&<>G(CzfBsg#g(JPX0w>G#rv*tufE5z;`}Vn4
zCuy+|1#qQcwRbPqGjZ-j$5Tfv4FyBU!fg``r{~#q`wnfRPqF95v6Ht<wq11bpbjw&
zZsiZhs9z4gTF$kJXn1!W=94vzf$(SL;jelxOI(PqFyLyv`00p`@O%!k=;ko?G1mVJ
zct&tH#Y>**Mt1a2i9B~W{z^4Eb$7?tT<3GYb5zUGU$<JVuHz&!H&5tlalLT<ce}&?
z&o9u@6C1Y70Kg&1_@CmdU-jkf%0~w3Q(OyIF9sBv%i40Ax7A%n8mo|;kO85>UMxab
z33W=WtuFY+B&Rg>+Ga>yK)gQ<^BHcEBmQJ+$nws`ZKLmFm<-9H2|0m=b|oN!&?Z<F
z0|EHr`_;#<8+aZaznT<KpJ8tSW;Ki^PV}+cc@x1&Hayg^%53Q)NB3K$s17IBMX5t7
zbaDA%H-y@qraR70@ElSlE=}1uEQ4HQbiDKJ?C*dIGB-Hmi0Y;eW5`s`NAcbX%m}3Z
zJa_lgqRTV9eq!VU6$?I{vDdUa<`>s<hi`Vg9v3^A@UHaL>HY3@__>2D<vazh>v@L2
zI%}+-i0uB1iDE1}7NvpVmi3SRwm0>qkt`>&A1tW;cR!{3hlir6W)93H{@rEK)4<O-
zD#jU%Ww}~^zm-uJ_04y>BJGBMye2@LR3?2yfq%+eg5bKGGH>*K(u^AtQ<ltmU}Si@
zD6Zp$#@W=3isd3lejeL%f75A0;Zlxlo%$HKU9nRAkUw1DY?eJ8mxgrxAv2C%8k0Ha
zblTR}?Cr6t&n;K9R68#oye{yw`DsV2N}sd)QV!2>pWx#=@2DaUe*xFOdV2LYP1@zE
zQkLg*wA7!kcfTf9(RIL^v@#%U>1(f7M3%g*&DuV#IusNZ-0m5vGx7|mO~;n0HPJ_9
zCI#O(tz|&P=u&vP3b-Kf#+{>p`YaK`SK3SnOpu!jICPla#!LO0f7c9=wTG|nbw3Nd
z7cz1cr8dNujLEgxPeR67V94)(f4cG-a}XvZ^u5sds@GRo@NeGcUqu>)t!&R<J1-DD
zd}k%J4GeFI+Km?mLNMThc+`|ft1~diYB8A$8}91cD(JsFB6RlmV*{1+yH1R0(*v~S
zNw=R;e-E>yVv@7pSwAu?;tzS80~S@{OJ>HrOFX>$WU1|#qow~dJB3qV;a(OJ?=>+1
zAiEFcfB_&tLluw$=wK5F0A~XbxFnHThnE8Yw9f>yewc=ohXKpP{E-~AZp8eAt6!Cl
zlts3rZFkdTv5NaOpULj#=}cOKzl6so(%`J&d2gPdZWzT#P_(H;$a;=#Bs=@3&s51m
zssHBozrfHA;<M{sHzVFn-Map&*uQB1&nM@TgB}OGO1|P6U*~RrWR=XXKAC%UPy9bi
z`RP|zd(@I3Jkkz*O#e>OlI^=+-@OR#Y%rY1VB^)Ywf!Zo4!w2JyJ>%hN-eMLZ2G&g
zw|yzkG9}hLS^}qQ9q;w}^|0$o)h`(gm}G!ZazPRUGBN7Jf0I(SuWm%$U;cZGN1pj|
zF80aIvmYKm_%m!V4d!6iz3juRC%Hkv4DdjN^P~M)9;!luE8x(x!8`(9Kxz=zZM%p%
z&yyN?weoo_y@fM{Za%^$Cfz<R;}$ML65ndtb*7>c*A{7*)C9hB(0btk*|_8BF6JX*
zh79E(0TgibfK`M9EQNj)7_5Ia7a{BbHm|hDcdQNtIM<-IxnQGbq9j{u)s>Rt(Ls(E
zp@gz0__uoC`AeYrkEelG8^r}4pZ^N-q;0$&&BI4Fz2Mhs`8&jCxGj5YPX7sM*P&G5
z))1PQ*Hp$E*aTc#YsghHYB;RvSTW2dvBD0q+_teZUXS4;PJqF+R-pnAKAcBja8YIX
zR2dWxbz9bBPq`imIyq={^dRO3$4QZ?^)LSoh+EeNLInmhC23)D-oX9<ECiS)>LLQ?
z8L}?MppkAFApe0FUIM)G!(I}!p^S9<v!>&6WWPgj!)k~qJfOY5=WZh|+<*Oh|6iS-
zVT7S~@ErX6{`m0Nlw*yf_^WSJ=G)r9EQd31a5_Ffd=%vxzUS}9=!blR=4JAMUr{94
zAU@vhDUI75PfJJmdrn_k&)R)bp?Px7PAT8(sEfed4Wl30e_|RB>#}$q{y;ZZ$k?5;
ze3sLuU;BKJN)GJvk3~QgLtYA=G|k>Qw#cQ%<X70UR?g*j`xy6nc`a=+n{J>1*{O|U
z5l8eZwv~&9biw7gGjzBfZ!uZ<MiO%vJo5n`-jwmE+(=jbDxra^_%wRCY4z(2WU$K_
zXezRH(cC|NtXE`%^fDLk(Nv5uDL)eZ=c}z}y0v(C(no~;{YHNetp_Z^;Xb9Q_@%n$
z`#!mtxjkKH>GY&w(e}|?NVcn$WYNp3myaqV7i0?FO?%}F$j*4JFMT`sgUW31f0-+0
z9?}Q06v6BHP*hiEB2g1+JLP7HN%Fw^xZLCK{aYq>KoQN0=ohFHnF&M=sqCj!;tS)0
z{BOnt&wb`O3DZ7e%e5>$%mlA^lX=ocEIdGhbfJ-=vZ%R5Q8qIZj}&-->>U;w=*l!>
z^D7}IM$}>>>HKHL24M)}t*m*j|D#nS)+b)r2TM;N2gqUR{E2W&NfDS;I;&oQfjJ@e
zYGTab?$+V5q*3w{aoqULR({e<qx7$dans*h1ti`k45#gcx%f7N?$9JBIyqr&yj{r1
zZBkHvO;oKL<R{fH+s*Zux8R1*Szbg*R$qpuo*XI~H`&|UJZU37B>oDUK>%1>FZKf^
zA|h9ao;y=sOKWPDVegKLpm@9SV1XckG25C?Ccaulykjhvndgl<<euTs#~W~<&WI6M
zab0yK?3H=IU<H0TU3*5COWCN>(UQAC>T-HX@-;?%3{sANy2APB(QWqQq}oo^;I-H0
za)dHmUAji64i~R~pR+|omiWhkB78RfMv8(O@SF?(N4%<#X1#;<{mU)e)R3W098Fa^
z8GOlj($!4PTuecuI=LsNAWdahjY{NE@~$c@AM4S$=AA8nNV#p0Gsi(>%_R=B5!8h#
zIZpo&-r!zVUOUaIy<5$h^L1Z3lT$ob6(+?JAYGuQH=nvZ!R+5JQs-+Dt8;%MT;-a(
zyJPOJb4nRVgAF`zia!Q2KkL1(^6dC)e`(oyT6vGL7u|&W`mxtkY-VA7@Z8sHPpX4G
z*ka7b+`U~?su*DoD%Qd$f1~a)Q6L^Z`=lW#<mH@AD;njN$?ni$emkiu;(m5w=&qW;
z4%XjP2Xyki4ipG?&phke-SA-fN1tfm#E%YR-w<)bLSHGm_&4plE>Ma#Xmd89Ks{qa
zC&SE``XzeWO84!08Rl-@k;h|4i668AHSkc9R>XwYZ&<0N<6xm)UFpd^kynw#=JgOk
zhYy78GEC<w8zt>BGaUmQ?$1T6XTX=-U-=?T*d5J*x$}!wzdg@|yF0%vJHPm8e^*iB
z{I}!5BJY|Eo?$q&wlG<BnL2HQ`YacSm;rs@IcX_7vu=DNe&d=n8)s;)v~BMh!S`Zs
zkNby5_~}2t9rwF0^gE2ntC|y6E#_@7v)9E_D^px4d&BG*cahBkFw38mP<HJ_#s;}u
zA_Nx^kV=9b-c$t&(w7fet`(aZ`h$!#c=FW7#Vh#82;_qUkLFvYN9ccih*V;iAOi<A
zFnT2X<c7j{lhdthCmyYP-uwN6nSZMz)bWe=+utwy9^blg;nA1F2YEHX-^-*qZWM-r
z_~V((D{1Y*u$xrA`qT6Aw`S>q19vbnB&vL03`f+k?7&4WgT^_(oEVal{ztr<A3`>-
z(j;2duP;-dcQCljp_4_f7Q6TEQE16Ppv;~Y@&3V6x+O7#erz!Q;izW4PX#vZV8TX<
zAC+05dV5T>(862C)fe)sTwYG1Wr6OpmF^>{F2Gj2PB<+fZ^BR%0qt&#i`6Q)=Qaw)
z0DzQISwWwpg7nEBA(zf<e+80;rgh}CZNs{P1{IaoB7N<|#Rmh($I03;E|5T_r$P_Z
zuB;y4j+7V!tIk`>8&4g>+CQII%k)W9Ai2Mro5|lzOI1V$y*3w^i2GWrf!^={zf1P%
zM}$f>h><f-MxAOHbHa@v2m3M&l3j5meX!^h+WJU<EZ2X#ts+w@u%iI~hXnG*X4bix
zrIWLC?}3K4tj(B10)4@yj!-E!eRxGE-|9b3zn`&Rx9@=vDu<KqEGy-SK<&q<wz!ls
zHx;Fk;?L4@VT&Z_zRlp&pUq(B>fq^L<!r8U?T>1>Ks0>cO1E!Qu^smFS~cI}w~gGA
zk9Df|($ipp26l{FS}6)KNHH73l$E6<-EMAXU0ezTNZUrNxbO}xXw8WN!x-e37~TgY
zsZ*KZ|Av&FV~?Eqg{r{v4q*}db*C*pC8$mWt52kNEMJ7u)A}2P*qgjxN_`@3CkEDY
z>9%leVx)o?$Y6|vHvn`p%%+)GBQm}X%vE&W^Yv2fKzhXY1~uGXnw+fU>?UGA=mJlv
z+Sl@vyBAId&ZRz9qU6c(Hd^pa?do=LgyfcsUtyg9KjqBr;{LwNotw^S1qf{na6tS;
z-`6202aZPql08UZZ;X7MQ$vj1l3cxtVk(|`csu+E+N~TOkm`}Oy?COVmYHYH6X?$u
zmE>_`6(#-)AsOm>2rNw>h$P`fN--R#$UIQjbZbFis+ji-DsJc31<cJ9uL%L{vd?yC
zW{IG0;wLp5-L&tVnF2p@>-to@1jVep!bys*_5!3o3tTls-6o9iZ;)gXM!1&2X-Ytb
zXw!o*!f$ktcbP%=Z@Z~~OpB>Ny>$!zZ`d<0DV%4Etn-|_rJt8ahKZT;pNUDU$nXJr
zg<_c$ZfoeoG9riMk%JeZ1EDr5$RviyJRTaya2R+B6KgOIUDGK@C{kTCITd#D^hAo@
zn495P?x=7y^o|OSU4pno^6qQ)=U1hrj7mojpdTagPY2M4{ap?M>=ROK1ps^o(C__(
zy%)rrX#N(V`q`pc8iTfyN|#(uApI|f56A|r`zIUTQJKezQ1I}m*JTNHNKd3mzdYZ)
zVwf%s)sEwheqC<4%Nr=b<ALGm!iuB?xXmoVX@1dQ0;0`a-dYs?W<XS~JaiVValR53
z=2Cv4vYh*ck5N<QDU!!@UnEag=wo6=xRK&?0CKYqS;q=fSwUH~%BHIzqk;I}!|3mI
z)_r(9h{->R5q=4l-<KEOatYo<mJnNybXDpvZX<5KMjcl|=04^9{<5GZ$w!Sy3b|8t
z+zrdYj^%F)AVpi7ACV1)Xp1};g1zxGpJTxW>NzsJBwt}TGrAFu3LFnf*m)$J5z7zX
z&G-{g`^CsSl_o#U5?#KnUCwm|Tj}ww)kBx7_VP$NY>Ok2!I^y9Ji?FDA4!G~V2O3L
ztwv?v8-l$E1?qzhJ)^}U;*Au&KppSKRBF9JRpTWE592qD$<#7a@g{TQCQI)o>*OY4
zRg>M_CWkj?Pc6U_m<G8^4WI>Bp3BATA5E@RsMrN~VI9Y*1$Ys|PHfB8D;eecyV*b6
z&e2#R8qf0)X}(Cx=ive%5I*e*l$bvJf+y;+$c3yQEwNLg=aW&mWkhzRgP1FHldW(;
z+0}ub49|Yk(&f+7?jOdEQRq{Y*6BH|_B83IHOl1Txvao;Sbe*q0FRq2{1Qg^MZCZY
z6R~n0b?rCeki1bMF42MHuVcZiFr1IEB3Z;@?>dv9SdQTdfyb|66|~d(RdDy-Tz_bM
zYS<3dxrT^iz=FEm#RxD4HbN=3^Yz`%I}zgB&9HXaaCNIApArkywxZtAPfZ%zLnq>=
zE6@2_1{GPOr~_zkKMrMK^uON-wm5U;u*Ou1yo?nQEk$NwMcft<Zf^vaw-HgCdF^rV
zha|pNNM4$Yj~feq_pn7@$J4{WoJ@fC;T6J{+C0w(0-Jacp1U?nz@Dv-0B;@VaE*F3
z!1u_7#|3rT((3r-+hP`{juS7n_^{xk1AJ3{T;2&cjdD6U)g^#U4uM;U2q@rBy7bYH
z+ikJ^>XgRnq!WORIr)P}aGGOD4ERI348(A-fSMDk1{*?vmpU>Q`yZ^HW7<XhLUZIG
z6D>}@3653F(LM$BkET}lL0n-gG0|>YKH$aMq?{8TXT{wX6b@KdISZZtAmL>(9S;5i
z*SuOm1A=S@KXa3NN)YHesdZ%u@!2Ka@w4W7@y#(LZ-Z=Hz_3g8DanTnis~ZFt&9II
zl6$C*PjHT_m;>PxhP-}A=53Y_bQSlo6&WM(^lc+{3-7#TyQcra`a#mWhpV{+M};=m
z^IC3mc--U<#~_24HCr(ppaqS`nC3ACVvZ)(^h2)>1^iMoxUSGYi*N4W6#si0`FjsJ
zJb+&G69Qqm>*^hns>M}d{ZC{szruEfBM}E!ezg)8wPgl)kaDJiv#`(!Jjgw|g@20~
zXlzFsFKLDpBHUo-wZ7<tJ~NQ&C{hJ+25KV)87Z)*Mf~X!8<^lnSdmM0mEnHTYORB}
zK)63KeA%nKxleft7vNJ&#bP8^!78fmH@OUJtfP)3Gt3HOIDTv*ZVlLuZT5m)`9Uti
zZjE&EuoBir$s^|W5fC5s5+A`HDftqaPpXM$ud9-*`;PlaG**jD*dbq9gqSTMIxAzr
zUD+jpHS0=9!B2>KKTbG@h1Ir_KT_<4I1u~so<BvND}ir!+U1xlw8Ss^Tr3~T1Uc4+
zB;gTtu`N~$h(H1UkA5>_xyl6^5<z&xAErK3g%_v&sPPx#6^XCbzB>9#9?U-mgtS{v
z7h}i3=@?<=Q)$UKd^}UpvI(|>86eAZJdy-X2{JCOqtcnY`lX2Opb6zZWDLuAf8Y_c
zi|@_tnKw^G*d$K82C~p+NT}LO)E;Sn%WRzhO<O`lBa2dHk-pU;b6p&T_355S{<xxZ
zoQ=^RKB0aHa}LxDg40JhKrjLJ3W7%i`4B%NNMrSCSML8GkOA;~z4t^FQ}IO5(7p>V
z;n;IBpat4A-pBJ;#&D?V`kex1egIsVc>YsMy|0Ee8aFxTF-Jhk22J4S=8n(pwRu;V
zT+d@UsDQXk*u)<apGC++a4cWD0D{VVNv@0Tsz7{aagw??$M9+<QE2fn<o7z{vr?Dh
zdBK*mlg$F0p^hS3F7Xe{MUJ~lzBCuStc`f;;+ZAbT3jZw|8YvQp7)#pV!%Y?ss{4X
zmdJwc<uZ*6Se=nySP}R8bJY4djzWH$VOxfuQp$CKEqk+ef@L%yw0{%vwhs2qpJN(p
z{Hu;H7B9m_J_OjCzU_;AmjQ`6Ib5-kF{Ds@<sXX1<a6snZz1nN7kR1b&SFFJ`<rhY
zkxrj7`R2Lj-?(~E2~h7K&U+3|6Oh!Ia##Y(^4rZ>$3c!b24@;WPQ4yRXK(_%3zF{_
zr4JS{(o1rtOA4o#lv0;eYM0ddmo(llX&o$`h~<c7L`K`(Kc=0Qr(b^)T5Qb!v4s$w
zn-hKYKDV*!^1&C>mchA4`!+zklLk8A<YWzL<738CbEu^V>XpK^E0+&kc!a7&RB|J5
zPB!2JZ-a0@or|l-ozN|Keq8H$!J7!v+g#HO-h^7`a{*lfQo#AS<-yn|u{+Bu^)YjO
zr>Xs`8EjYIK+y+!C)4Z-5!Ul5)f-5@f7TJ-T6Jgw$MV-Ggo3a2LyzLhFqv+K4^UP%
zES~>|U0Sn8g3U27GKOi2;fTZJlXUB+j@0t6$v(AeyR}RZ^Qwuy;mwp_Gg7cr*t8gb
zKn^PMl`WS5Y;IOG=7oIgZ$+gaF$7fc<-0niPPw8#5?gvdx`%xnJrD*k6YPPsKLn_D
z4dTuYDi$er*~!Stk7Mox@4Zd!0|{jiRyiR~c^k9|KBqjDTiVb0O^!SKYQ?uV1j^&O
zu=b^ul=njI6O&&<xdXR&;2@Y=y#)YZ*bC<`tWrBnB)^~V)0;XH*e`_O-nzvWI0C|F
za}3ImV-WE#H#G+HAaw63K%9gP3dZs;DR3+VD1F=x=5~F$WUe(dPS>CeIHWh|9Fb_K
zu!yQay7@(KF<{N@6p>TkzGGD7gk-q1wa>X~!@IQqySXdkp4P_oja%&e<mI2<g<RWl
zd7FwH`G9!c=H^+>lG_~2H4*-0(#&Fv39(V{<VU^n#Xa#Qy$@|<-n3s*^;eRd(K3G#
z9~lgFDzYDf@Ywt+W+?JsYA*NUQOevI-VDQJ-N85nz%&y{`LV4*`Qt89U+s+U=|)^8
z4Sd-e6Q0;Pw)g|vhWsDA&;aXXrgwvdaWGdvLouRBZqNPu7cKvv4-PjfXZI23UY92z
zwO=kFu&q_<TMYI<`J&825EAZoII6%VjWYsX-#o?*3SDRvdi&!N5IgbVVJHX;95%E3
zfeao#Q!3hZ$ue75^YlnXtlUs0mw?i9^!CztrkrD~Wu@DSU74nDKUK_qb*6GrWegI-
z$R{|s0YV^5#_9+T#{T-}7i(_Vb-!q}x;*~MV4yAJ{@c))Gcwm~+5QQ4f7UzK1yT5|
zatzj<+zLM5lD8(J;&V6Q>-*8_6W`yL&8swAdOLOouu=Fh8(b{BG;jv#n0Hg$@022i
z&g4s-d;HvD`T)lNT(YpyzrR^M(ef+nhE0Bp@54-~Q@fGRqS#NCN-v!XsIp8Pk~C<`
z$iIS*?I8*|&Eu?k&BM)T(!Rgr*I#s=8L##Illbl3gEUT=(|?n;R~}upxqA9v^6uAn
z4{0)I4pM&q{Q6=1>KS(G!M}fOPAne8sldcT5SCa1hiDL!z$rt;nsX^PG0n4@@Wc6P
zZ`64djg5^$(5JxRw%OKlMo$YH8r~i%)(mReMn#=<rj;#IL5f=MFx!)S#&dpO>K)?4
z75I1xsLbNTgRRJF;V*7*#MvA5vsJFM+Y=b)Yfal#sz(dkDxXyN*zttl--xsG*RiA6
z8eX{gn9qA`f97h;ZW7VSxUxs^3By$GV`)5ik5htzS}bDQJM%_ZiYLK;hDy2T>#lXD
zeG|y!RWNi!ij0Es*Q6Z39AfCxhJLqJ^i1f4RWv$X)|c^+{XME0m#wW-a{|04_tI-}
za*ZdP*|qw7EbRJ98;wyl&QB?_;(ifg0anXDU$jlDvVve%Jj@$?)kvp1;-(H+V-w5b
z$xgoGd`=&vnAwMz4jKbjCI&Bh0RRvbQBqdWp0*sLfby>p8arcz>6WWa>)V%;!@|g`
zABcaYMik->p03>S7~*Q?lUq&-!Fcoj#w{1xAAAbR16(LlN>{@_GCg42))h79okr^H
za>bUpbu=nzELXm`Mlq$gu8`BM|4tQ_)D7XTu>;*s^7&1kq^%?6EE#e^a)$ZYmJO$W
zWMwqR?HVN-ylry%*cPIaed+2Q{h|Odm;bnCG42PIw;RMMpcf2!6MgkLxi-YaO!M2m
zjaVIA3@&)jSVu)VE&pO$vDc<w9@1Nq3y<^$zit!@U1JW3M2B_B0nPzkjdaW0#SpY1
ziDv<+gs4<0NZ(|r<fbQfw$ZH;ZO1Bn!k&uCO)Qkq>DIY-GOL3lvJUDsZ+x<@w96*7
zD`fmehuzF#v2Fh4k_vVV87{k_wHk`QC+hOq;l>TvS$~wAxFP-z9-=y02QltPWxk02
zD%GA02Lk=e0+)x6j82RjWQzciD#L7*A~<O#V3C(T5a@sUeD)${mhSKJ@i+@Uh9wtj
zpO#XL5_%0b^b^)RXSpo7A12Y+@blV$7?t;xd8tl~pdb(f(%DZ!S=J<7Q#rjXMjU+R
zEp47XrC}o{MIN~usZ(f%cRB~P3{2U;7Nj43jxUHguKtbHN`#U`6kJOUzzf#~2ZkLf
zTQ=kG(<{?l8YL;RvX&{I5DNrLu|RRbZKbg;EH$0i9~idCuG34a3q%jO)Sba}YhNdf
z@G(x&wD7XLQ9D?iagDqdY`?&2CaBn9ebh4gbAe9;l$X&6vx**5aJkqhU`c{Y*7)be
z^D0P@+Ti+s3k&GYPpiJN_fL6lYxCak8O3<(5(QwwJlj%1s`CI|yStm$$kHC^A?qUr
zSwMgy>ZPdJ6R!>g46I(7i`f`iYeWd-n4p&<`%(6QXRKPN&!Eqrm=%kcB9_)y)I^2E
zM%&@z>S-Gv#dQk7hCc-Of}|gN$ZLjMgJadOjtW9dxe|BWxY+R(3kl^KqGEo-(AnJ`
zldL)$3Fp$RdwyC#RkbRxzNSN2763STNRr97i~!zYnX}2y&29uCeP)XJvj4ub1Zy+Y
zU;{~M@$OQ*-F#{HDQ=fiyewOk1#rAU(nBPR3Rn?MZ%1E}ji))J7M7eHP?4kjwDGrc
z%Sw+4mh*Ihu%&nxxz6=XUOux4)yM?l(^!oiFn<}v6l3r0wnb?omld|*r?s0Ak_=)D
z;be!5;sZ9tfIYJNZ%oGEm@e>?1XqU(TUj<Sa$AQ!TO{8q@D^I+c4L{_{)a5}#*d))
z>1~8mqASHmz;jOJtwoT*NSObsVi)d(et@#T&Z@-&rO7qZ!~lVA=F;)khg6TE(gHu!
z%JJ)%DAFM1zg<~NQON7DexU%QL8g6sVox;CLx4sfkm0BNW<_e(3;clvDNtWMA<hUf
zysOoL68mB{Wo)}_1w}Y?&s!7;ymF0;l(TFbIb#;cr#0|Wmkl4sktKtoJ8ml)OXUi?
zv40~K9==j2LBsVliyls`4%eUQ&@h=26WC36894Jkf99oY#;r(*>bX(W^=k_yfx@y(
zhf>Hfu*+Kj-k3$aV=h46D)1Ak&+klv1Cd33|D{J=wz0iIa28%Nzx`b{0mq%Htk#Fu
z2=x8qa+Tl8R`CCt6`kc~KRf^0Q&4|2-dl7*Bx++==2ZTK4g>s!<`vNDH>RKH^Y3Zq
z#%q}{lH0-3K-0Q3)N6kEg%PYVuN8(t11xZH57Yms8Mg=w1h_(6>?j)Dg#xy*C!f3t
zpiiXR4(OlNWoz@_IiMt)WD_M{2Dbr!8yX{;ZLygrQ1rDwG9wm~q9h{}JEP6tSLX7@
z82G3___xNYJDGj)@f8RcB7r+|bEk1_HZuq#r*cR+bmMn@Trl<#aT!hv(5gTj{j@9d
z<ZBfCixf=%xtt6L&&h<iaOju#3p&+P#V1IsW|&uz2Dz@s*95rCbLG7aX%mP7SD3y@
z3VLM?3hBht-ED_4Rv$P`b}=QUXv!h0Zp;bd|G&f9fb$>I`NxU3Atv&V@KZ8M0XcpX
z=`)w`OMGchvmIb09*@a!>p?!F!yncyR#q&q8teQ}^P<W{BDYBoVL!@iQS(3SIbfmQ
z;@I7(p;K6T=BtrM2#aNz9l-ZG=Cjf$CuSbyuWgkGnoLBqDYn6FTcHMMQc#ML^cV5>
z7AA`=7ncJuJm<LXDbMl;eGA_$c|w=17~zLmkGSoiP4#cgJJ17$3l7knRe62+f@bgk
zb%6lQY`B^?qf#qk;JZQU&5_`Fc|fEI;=kFJ{Fc)fAZb?6E;Gn-Yu9cRRnqooXVKKR
z=<+J#>^F@R_t<heiyR(zmEK1Vj^VD(hS=b_<uAg|q2(^FUx^~sgk{lO=yX>MO?D`A
zB9P0xn4U0^6*X5cRh7-yYrTv++DuZN)Xmg9pD8oL8MtOD9b2E$SN*Hed=5^rSc4LA
z)W$9zO*GUd1}Zf2z?cYmL88B8z?0xjdNC9>YB<NB4Wgx&rOBX}092e;1Kkf|IY6Ne
z^Xn~Wgiol`_sA9lP@6r7{H6chNMxC7Q|UNj4Y6=ot!IS0P%Msu!>Q0t+<|GuaXH5f
zy4%wJyF23E!yp9o(0M4neYA9ZUl~&<&Wpp$a`Y4xSt+2U2BlchIik*T+3jWECoFvQ
ztT_uQW-9jsgT_MQ$3m%NVI^bXO=A%~V`oRkBA<^%EssU-jGf~xkRuK2saXG>xC)ic
zs`TS~iOV`)l9jM*7^6^U#e{8G&^%m5q9w{)>-78Dpcb-ap=g*p)2ec<3VgA;|6-Q7
zD>34=K!xAL9fl3~+5;LclRXTl1cu26S6sb2r$Q9xB&LjW=rW$u8_Ti0dO}%$E{;ES
znam2RA>uOeb7U-wIzS-c>9jB|QXo?Q-kPF4JmU;dmx7kB8W5*$An%Z}=J#w1iBlCZ
zcJI?|!R7|y;w@o-NPd%D4@NRADMx((rX*ln5o5!ltyWI5(M`#_wJ~)qNb>NQ8m#q(
z08}|<W^KvD-HGN)b2@@e&AD?_Z$BwZA}mS;W}sr-8p&8CO<W!5eL(G8b(y$5c$Gdc
zFx8~r5l-xjl(gx)6N}3&=sRS@5vT2Q{xivS@<XNGh3hwE=uS!2*x8m@ju#)drzK6k
zacF<uCjDO0kzKwqL18^w+?ly>r~K^N2y(kPhMQY-d-8Tumd_MT@or{HA1$ti&iVJ@
zSyJwY*(U0S4J4KaS2cwXw0l}H6*uc}&e-Xyx5D*-%zZhh3>C*4_jz7WHS_+`RPWPY
zPSa`^$?a{Ae``2>7DAR&<=@W3dq-p%jVF6joX>Jo9P2pz{Wx3cw2Z=>03+BWHRrS&
zEIh2A)^3^I)|e6_gWKnnk9`8*CLp#?UbGc@JbR4S<&lhfB5{Q^wg^`p$VdlnB;0pS
zY|1HE77WEd$OT9?pN~AOY;B;AQ!tYdSJwT7N1UaP6R7ZFy;*51`4(PUN=3OiSIZjo
zY5iI=`@{g%8s|FLE*~dflY${jO7TpTJQW?~+cJ?fc`%bX;&7DX8R+h8+BQuc!}rW#
zT>gqOv=feibak!CTAVzdiJJ!9nVm&CJ&kcud+_|X<nh@!XT!HN3>A)WbnjW4-Wq|M
z@c?*=rahKErt)Mm*VQ3!>P_E^Q^(+hW5b7OKs{8Z$6g+fdVd;DM14(NZxfcrfa$HN
zKcBg6{nIfw%q{c}*`O|C(2G-Ng6l}98yIxLM)T@l**sm#JR150#p{({R81TlNQTqS
z!fRr%`YxNo6s*?Wy2teAaFOTPDQ%QHbFOBJ405nXg3lAv&KDFfuTMKCE(F(%rqkI0
zo1T=zmqeAaQoU>+-0jcn=ecNw#yQR?IQ1pciEH%uZG{sh@%DcwpO+l7KT<k3mJYF5
zgWBM!hClf$yEqK|AU`dhlx5%^Npc_SeBIOu*S~MjobaaAG0TDaroGua7v0p-`KIH=
zn?oiLUS*<_<1JJ8ZI|NPZvD46t={%{yuB6twm0EzcLv1Bg>t*3FvSvK7zPE|G5WsB
zRH_UTS!7L>3cmaK5BcT?FQ3{CE0HTIxjkE~%|$c8I&I^RY{)Z4|K*P5ah*9&wel9+
zSnzq`IRA64nT~~hV%TSqjy1gF_nxEeOE9>1O3%k;dBt!O<{+&D-d~vS(gu9l@1%Tx
zGNE+>;tq3|1s=c?&gl|Hkz+tY(YZ(M5MF!P5V7}lvXGBb@Z|(9TR)Uhm|)t#;QHq2
zG~f)H=l!oamD+529~UXa&-ZIxMhdHs<MquHzcXbRs_sql<p=ry{&8xqeMp=5u;Ylh
zu4>QHfxG19{eSSqdu;(<94wHP@$~bo#Xv?N4hD43Lyeds8CeE<G`<MVAIEB}nSQ)4
z{jSz$n6-f|;h9m4%;$V0JNls#ZBb%XK%{?xSLupXT?RrAZb8o|)A1Mb^oN`-z&40}
z{R>WfOM9}!<4?Lv+vAY`NOpXdO}`5cqtjmnA4-V3D_CT9a7F3qB$(cp0BUxd40mSm
zT)kXTpfP`rTyo&{x@>}+pY*=EtKCQa=s;yt1TG8~5vEjA+&wHSo3?Oc7M?Lk<n%%c
zQ6>cDl9%HbTFwe6%6SQ<tv&GDyZ%xaY3aHA>1@zl23c{3(@6y8oJ!Bz&kbQ@uIt0S
zLr|y2Ry;#cUS+|9o1Djz>7}SM7MY04<hxPC9#3ufe>r)YeXR+2f=*INQj7|~1B810
z_hslvl*;}6&JSSM)keS7dtPmq7edYtYGs*cCjqsGH-ihXnnUtNhH-WRKXA^V{FE*|
z1mk|sYISE1>_X4*cd7f`-f)ZuP^R$B@Q_YmxY&!^oHvNrBo?zq1t$KZE~VmaO`8u?
zb&cY*c9FSM>8GB1_|Wh5CN?=|xd1z$gBBBBQT92*{<9(<P-Z|+%*M;dWzR~j?fUWj
zGtR!B0^f-UGmPi6pU5_i;UQq@#EKhfVK;7JVRRk3lf%%h7~i>L$j0}aO_@2@w0ddT
zA5-eQ(E8mn-e2VCQa5|GIt}25{GA79Ga7N9>$MQW7_x@C>Z!A9>cx30JOC>kPW(Z0
zVM3I;pfB6FAJ&Pd^)+TPIebnt9v*NeF+3~7BGVWiIZa&vra4<BDr;|p^)1`+l6D#s
zCKsmEy?XX%odX3qn1;-DdP_S$M`lx3axDAq)Lx`p$7EZm+(-kMS7XY6HCf{r?xB4y
zir_KMJ5kaZSs!1n0%048?<0EK>9)o2ja2&A$68@HVP8D=gDX*Q`md_5jhx5A({hfz
z!7hF<&JFcL8Db4X_32nI+Mu5yuZ0<fNsdA1BCV0X4mkH(a{gt8u%+Rjd4P$9-o)#h
zwIM~E?C%K_y3i%l52wFx!ZS|*kh(qcwL^%r-94c0-Yr4sz4LkZ>N({4!0Ycg|9eYL
zsN^JKp>ZVRQI#pzJxFw)k&XdF;K+T!hXZ#fwggvWWz4dj_hsvM>r?8spFi7DM&vlR
zmxR53hcqi73~K$DUQuioWH+J(-4pY0Dh&qNG=j#vucx@vSS6k0l8b<rz6>Ko{KpS@
z&MW+`!~o6@jX!*PwX<<iS!)~w<#?^<{o%>xSTh9suUVi<EQNlLol{E4;xj}~(+)Wh
zD$44NTR<OY6dgj0;THAKq-<uIdS#?6?0{XXWFv-xn|R!8vfZ73dKl76j-Jf|60=!9
z?Fk7U%Kj^H*`0;)JBKJY7F62V@5>(8gh@G4XNTK)8KY0vYlC1Gcfl8T!wjk6G@d9M
zp7{Uh(~oI{$lVLy+ljdBG0LxGnY!RGSnoFHx0}CGLu;h$Xe+zF(mx5gPh^}3gSIH`
zWrXf!Uf842_Sp3Dy{y)~?Au9Ld9VS-Li)<=jvqwRgsV6{D<UKRh;Uy16F6?K{0NJj
zmIZkqPR*}|mtKIDUAUO=?|BZQV8YETxo6x1+hKtztG^8kC>*>CK#pir-&pg+<~x|K
z6z;}*wLPTM6C~<z)Ubg}*Q6=3Fc;`A?f#?eGk(r>Bu<@#C#_T5T{bW4IXtfzW_e(K
z-wD<9?4K0afem#MuO;PF7t&uf<lyk!juXeL;NcLy*LeGrBcI&PI;Ok^NLXSfZDHy*
z<F!*W{Y04K(iY8&`IqWv7*BFpmW7gdx<+Y#N=T=Be&_l*^ZX$zB(0g+;$V0dnS0ds
zp)EK2idg0uR^?q<j{h{xiJ8~47ZJ(xTsP8d`Gafm!i!fd+vEGJx0@~EFW~ku**F(S
z-Lt29DyVT2_{NE@uLYk?^xix-%X0L}4Dw?C{FFKPUyj^nPb?B@RMB<00-C+&(@}E&
z2`5|*I7Ie_ZDNL~++0&zzm5nJ4!vd?9br!~9ckbBok}WP8t_!`vC|!MT?$hrq9=@~
zo{z6~7s~{f3GEyKL{$&|N~z(x8ywS&{&C>+HWwxu)yj3E)^}8&x4E^tbw<1h=t|pP
z@bQ@2lu;oENxpHT=U^nrO$VdJC|7QhoUicE{_Q8vPBq8!aox=96m94OEr@^?;N{)y
zfCqk7;%HHz!Fw{hYnt;r#=jW`LR#<5MUBo};mbGm^6FUyYRpa@>(OulBG~z*t6p#A
zUZupo`j_J#Bhcw}%TLx09(u-<`~^HxIK36WerLAT{lDmc#)+kwJ?q95tztdKCptIY
z-p;Lilv0f{cq8gJ?^<THa@;oiSiXfLG!0dP+PG=~f>{(=dM8;hETFL#egZF%9xSu3
zG0<76?dw)?$J&!Bt`U-{J@p|{>6Wt|uLhRuGgZnIGIWP|g&cHG3B~h~*)=p|&Tt#7
zF;}LjLh7(IY@|?V*#IgqTO@fR4S;}WrMiH${J8PK$PX(*tj76AMuwfwYzXX@Fb|eN
zo~5C$q;~?!)t{rY5^=O+WHuORg1VsfK!4rywI4PKk__`dqX&!+oo!CQRz+`B)YYyQ
z@rWo9A=S_vt&^+>mMwRCV{1b2qsZ!jT`#*zHL9)lpvro#UsFP|Qgx|_k$UH?H_6w{
zEhCGaP5Y&U9-FcwpLs}c%{9L;%R$G(NroJxyd-F4ksskeq4?clu!86coKShgFBZ@x
z2$*;So7uI~6+8o2c8o4k0qQHL1u&tTPV~R~Ba4}Tw*LJ0Q0SV-YzR~$zMiO(KPQ~0
z9h)QcP*s*!8+Zz3<_-wtRdj`lE&bM>kj*ji(B$vTLdq>Bx%-@8cR=?Fu$&oB53Ok(
zf{`Y18{_|zdqwdR_B+VFz86-kSTd7*zKjR#1=-Q!jg+kl?R}{DfHr96nKhw@as6b7
z%)6GVmX;#TFMgd)*9=;!l0A3lTx|(_FUxOy4R23+$VbxO*9+XeQVD+Fc3xg06}Obd
zi8(an;pCU)eqbab6@~26?d`>tgU<o;^W|p-ppJ2ZksKft$*hbRTVU3=S^a_xsuLWz
z#W9M)A4LS>T+Ic~9(;Ed2>ku=n`yL(3H`piA|q>RM=PaWT3#V9uiqx<@&Hq<|Jbj0
z?#foU$Yy~ciK0J&c1Ip5#a(C~P@8H$4*>t17oRs*KAB`U!LZqvo}#F<TH`{_V~$|s
zsX3dvi3RD$0!>H1tHa|>8w?#rHOWXz34+pu=~HOFTO!3SG=$P<(;gJV)iq`+9ZH~v
zF{98s(!7Bx7Hzm8Eq|^eot|#JQ*$eakrX7M2!v7p>*B9B#VOEP-1#mx=OoC*)AHpf
zgyqhNOvf5rn*8&I9tS1_8cu02aKkSB)AA3JL}!T@jAid!r@tw-bE~q^UeV;Z1k1|I
zW5Lx09*y|v{*}i-Dv{^*AkrSl*`t38@9`Rh%jhJR2(bza%&v4|!ZF+i@4ZSJ7Dvf3
z#K#}O%6!MV()p8<VLlTi{!Ru2I78%Tf$KQfPYTZ-Z)m{04fr|OV>=af<C+ZAP*)sv
zdPTQ;@=b_09TiZ^I;S+Eh^<$h2zNW5>Bg9^6Cu-%#b-z#MrjGu!h$raJ^DJvBE4jh
zaT=*0`k)RXkWHe+BRPCuf`HTmZC-O;@>MGO3{YF&>P4)FpXM3(*uy}iEe{LO;8!iy
zWXog!4GX5T#vJ8#?&XD#B}ddS=;qgsF33L77B#Mws&wPfYm()oHd)(0#fav&=vjq=
zxqfy$bvqyaEm=*xQR%ws^ZNJMyujUe=82%XZ(bP;_S%SWc7O&K$AToN?$9x|)gR-h
z3g~g;<7$NSq&-^U{bH?`c6tzjNH&!J2X+FtxL7T>3_c099oL>0%mfxjF<bb>KhSZ4
zXzFI=#q{csDVXD6G^5g)E5rQ2AHJt8qDT=|`Y<a_3L#lD^Mxf{E!5u>JoT@sXd@bv
zGgPi02cO)cb9$GTDO2_u(Q675+HJz5OT5F}ge%;@YyczVUqI-aHUWb-3uw*d809&J
zg?w~FCUCsIj~hJV9rDS#Fq4>^=uq3gL$ulSg!{RFRzK9()4%q{R;HL#SVlwZB)UYC
zH;;V``*HolmmYuR{5GOz#M{F%&d1;#=IHRk0^Awb!wdg^S!Vz8=UdI811>a^7+Kkf
z0SH=w2s_#&Tg9I9FL779XUHStG%5z|Y~Hcy6a993%s{C~guf6jV!?5^7_d~}2eBlo
zsri=Qq&HJfp{k_sOgg2;rMmJ4kKRG6dDQBZ-RuY+$+$2r|0nGD-HjFP;yW|uMO~H8
zI#%^>-gy+As$26><CD>|JC76lb!&fgd^+~y&Xd#w-8zWo8bR<bD>L(^5X+Bd0iNZ{
z_j_G0uld>bXtUr~fMM3Vc>PP=tLv|rWBN`nOLFOjvn{6j*D70H`=#?7eN8>9U2D!W
z-E{Y5uR*-9kTAb_*re>%-F!(&5SKqdL^DX#$2BOPy!UrsKVH50A91h}JD1V^i^?NM
zwxSDbWr+MqVlUhr*8GM$TOT{6!YeBo_vTA3^`yz7yh4CK9FPn^&+l;nkPx_!<S_a(
zi%#fe!2@F~#7blGCCJa<6g*kvI_q7ZyjE<3xxCkC-LTq+u2)}7U;-cYEa$3%a^DCj
zNVgo%6W)Zsnx;3~hyA1J%$sutz6*Q+!c#rNjJB@)@L?oY*pN56HwB$X-dWePm@dB%
z5iCvMv3s8ATmM`?An)2uC__7@a3V;c3B~WvDK?8NFz3JXDa7p3uaV{2l>5KmFrN0d
zW^XpdI+^Q_XE*}~5<nCc4V=F8L8S-9OHLV-`Lh=RT-!xNB?Z<ntdB0sAL+If!Zq%*
zMDDQ_19pl5KQFe5{ZWWZemd^Ev_-FIzrh!VNsk`i;xny;E9;D##Qxph|4PNb33RwX
z<-PXNzmM?@>o8<EBAx`q15>m4=_Qb}uq|;D*ie4pgOqxhKg5Eqov-k||IhpJ$2yV$
z+*yaTBHM?dPeIQG9r$uOd*y`$+N4Mn)Uw8%XIU0Q+Wh~%T$PwVXYp}w_+^R=NaT<m
z@xl1`U__(^GYmBDU)?K4o#()JB=CI$NRoZD1P+oo%c4Pre(yL{#INMLY8I##!)-ch
zx(CV29ZB1RhzChOX#Wt>bCodv_z?3VGH<Ejn~unOdIVj|#*7>RCXV<VTJ8O~wb-(P
zo>0Ru4wd5-vMflauZ?gUK`e3z=Smi5q(e-3IPO~cKL>xC_W(AARdzsz9a7W((tQVp
zrTeU8(8I-0yxd&ICkE);GDT6ZUgkiS&{6%;#RI4SkJ!@k^`@tJPXmz@Gc@F(#@o1!
zCxjWuPh^9#-n5CvbF&$K^vTJ1jsZ;WGm{!gOzjfaZ>heo5KWbZ1g87X*BtV0&PVW^
z>Khb~e+*HOolM7&se>HhurRat-pp?}oX>)3BCP?PepcV0D}tdWfE6Uo`=~RQzVe8(
z(&Id!5*V;_{0rU8MqDzYDzDL~Rvr_}YkWigXmmlzEqRl%zzKS#$xC+QvG?+(tBt1L
z<jr;)%?{-8uqHgJ68$`oz^`DgGb+_FNN{tPH5rmZQ_&7VHI;*s^XX#oqn2*V)`?H7
zMS^UUf~wP(rGkbjbcmW>Q-Tke5Hzgk0MTwTw|28K_zTfSQ^n|m4mT>T-h**MmZo%y
zjF**@NVC(mpe1y(YxZ)ru=z2}hz4dQ9<a!R(sB1e9`O`248_tdsCvuXe9gkrZPX^U
z$)>FNgpOi$7R58g98e)2MUHrRb9%rA6idL^Hi{=5;`k;ANCFXrnycH%Mkzy*^g$^s
zgfMUJp|awdSP;0{<lS8<2M|?-p!P7p>oljw?_oj}o8b5j;%S%R85c~THq|@=5mb~;
zCMraz<)7?d4JxWc&zLib3WO2GP*@1T#GGkj4x|ie`Yi`enTMdLa+qN~5=3WnNPZ^B
z5k(ObG6#Yn+I|XG_=15p^T2flg2^huGK2tcam#PLP^Ro8t#~o{6M@v~2LqBGx0HvA
zVE<A~Yg*8KG_wtb1eahly=7$po^Y39Ha}#88a4~EAZ&t3Xv<@gLE%-aVlOF)o=rw;
zSrMKYC;FAV8$xI;D>Q>3`cP|R@)}{PB_-mdb?xEd4FxJd_WACao}3=5!%iU<rV9{4
zn*}gKc8v=*M2<-8SO9&)nsw$tJlnz$-+FVIV*eg`wztyNiBcP>lxV4RslP4xTI<E^
zP`~KU$#x;-cEQ=*ucZK@!E%r+vW@huB@_kK!BGRGo6=K1Ifhsez@fl%)hu%r*FB36
zwY7}9udUw)0S=H#JDZcK%Ji|2#=EPTRl!$v)*F=~DzAy@gjt!5tW4ig$-A+t_k0+a
z0P(B>6-<!{Kse!ANIrPjpSuOE5@zb9>apHZk`2;^PV3!oO&Dn{`?l<MuwIe+*<nn%
zeCX39=`YP=V%jFbz;lQ$w9RZLEX}jo3~SLfrWhzPa)qp*s}f*fLOuZtXGlW}`d@3}
zMs75;HMFcWxv51jwc2H~+wN7V*mQsC-flt*k#pV;;rwlU9}g*;42k~@_S;_5Xo@I`
zYd5+-uP3At1|!vLh16Uo-#~pyfU1v0N1AU&BxkFRYc>D3dcEq{L<5Xu^mn*!R&kxt
zj^14Bg$+oVDAra5%VI3dkfXub1cqH$6l~y5_iKryVk05-e(#K?UDXHPYWI|)X4Sqv
zEsCs^`XWDPHS}#YCsE^!__}!0#t`hf)%#YmXX{9<QsA5Qsu!WA$J@r8IOo*PzD<oB
zzuVd^clMoKRAsm)a33`2)Fih+F?$Y4^Zb(55NvOHT}B9u!%fejD7X@Hr|fh&B(zj1
z9Ka0QC`GbvRC*q;ArDidWoLpDsB5!Y(Eg(6OQxFd%f!y0pcfi8?(7bq2S)-6l=5rj
zo6AavER#ESZAaIJqka<zYHjh-!85(Dol$|TI?V*q=dw5r^O3I?0#qjsBFb)jtMZK^
z^iejw*FBoPP{g%r4#Exg2$wx?$W=7e;;2V!z*bHaGvu&M|BdSK6#{N#Dqm~8|Ezh<
zw*$9pzXHBjJW7}I0bAzhitP=GAO9Zyp0MQhC0u8-+Gv%LyK!9TIy5a3;K6c!s9jIo
zd>yq}pA{2!Q5AkQ=2zAc?*C%GhHLOV#PW_ad7ohUUi~kY&c&a}_woPtX11|mb3Si#
zKIRbRY;z{$Op-QdqDF|29USI7r;?;OBqU8#Diw1+R76p!w^KT)oQfj*`F<Y1|KWaI
zkL!M2uh;X*7WhwB@Dp3`C%L{~U>|WIGX>gGcNH@LD;aUEl#DnHnRW+^X?kXXj-qR5
z)ivR#Qb7gGoD+IN_umY3a}4p;^GdTuUCu^J)Dl};?EoH)NV|i6JfFR7q}3KI{f-wa
zzrK!EaOztd9dC1cBjHW<jUozR&*({r*nL6T5xUw4<JM2S2Ms&zv7*oAAqb;m5D7P)
zLzEGV=sAMud~~Fn@$Q00K%B}uUR6(#sCeG%Y*fLTa6bA@WkH7c_@qlfk2~ASh+-up
zN|iODTaRNBDEzz{wtw0C-IiX<6`IwO&&y<_6yD145U;*wyBpQPSLqGTNl4_6p4N>w
zdaPGh`(89OQhf}16NuJvWk(2Iy++>pPF4G~32q!g(pvAg{Q*Z_v(dBI$4<TxdQRJC
z58pVZVAS{Yug_7m4aO+rs$aJ5I~<{2hBEG;+DDV3XW+(ZAHKtk$JY9mE*{DdB^c~;
zjbPd>*9b{gS~FBpC2)@bT?X4{x1mR_09#2~X)*ls)(TC)5<Q<0_J15cL*gqlL1*&m
z>Pmwp@aGcP4GXWfcr$&%tivO>IAHg<7Cu{Vh5o$9cH<xT)Hp#G*}Kx$tDBLa`&q7$
z<*g>wx7lxX5T$5Vp+Lx3SC_D6JHM{aD0==tF`zN-=Fm*}nnw#fp;DWE0%C>vYwZ;(
zv~P||G}ttYAhhzr3-S@#42KrEOENCp4bId!T`gz<ZKDeB)$O*HmxGiT<QeYcis5Ah
z=MBRC@G#;K0RpDL7k-Z`CUi)UUK|tPrTAJy{-Iv89D1efc}*}wmPQ-}2twGOF1pJ{
zu(f&JHTq_$o!CnyN5`8^(a3!?M-iL<DmDntC-p}>O#QAAh+Bm54U4&7VIQr{kb33s
zJrcLcXWB2%{OSD-!egKm!kJM-ApMNomM6tYQ`FC3iD}q4X$Vk4Wo*JkhHU!c*N6=J
zQ_fLtLTR_!t@Eu2Q{|Rq7lPk5A!N=nRZJ>h#B^T-4H`cBaqEh)HG7kT*0hduwo<AR
zBxt>x_onLWjagLCQciJsRb+b)i&5icAjcmg;>QzUk8ORXYM?da{t|tg&%_Da3zlSC
z0^ZolsMqKp0qCHeFiKeHQe;9N<lnq}cqo>_a@9I!Wn=%!&=uC0!NEZsEOaFhR@=LJ
ze?G(@qt903LyV;5Ao2-D1S}s9FaGa%@Ad9OR&yYV9}jxG)bw1@>HkVGcayLDvQ-J!
zH#ItZNK`^<oaexAhZ!%J$q^Z|{K;gjar|*HDg8e4_`<oR_9hh6Jf)DY;INhRHFLC$
z(GpLL2qZ-jVn7~D?sYT%uw_m+shW6T2}#m5vU&2#%bUWlhT7+h@tA8>(Rl!4H|%^3
zk9!0?v#%qK%w_0q_nK2W2xKEGC1DR<ii!~gbH&IC!Wm`JbFTl%3%Aer+^MXoP{A5T
z5WOrUX;?`sEIw7yb5OD9TEqB5Uu7rEZcm%00}O;$Q{|Cr?2(ASD7v4Wbc4fDR!{P_
zEQr>_I*EYue>xdd=_#v4mi3#Q4;IX>VMWNH?GJS~9>92Wf^fT)$A;41=@VKmo(9QU
zbFJ0LWpr4#=6*5MvL>vkFA6kdmXv|-?%`4A9~Fbh^D<7Aj*c4jnR)F_YAzg?>r2#~
z8u)nV(Bh?dM%hbMvv@o>PR;htwHhBcj|3ZQ3nGn(mPuahq)qK}hF=BC?zFM3_lvLc
zW!&Djah|%oKWzqe$%=?WGqbn5W;<p3H2=|sA1VgD+1fI4`cKsi72CH$cb1$2NsD&L
zX!kkP6XYOPj2at-FEr^6P|-1nP>k)0PP(DXNlhDDr5W3U`j)@A#dW6r`UZ5xzdWY1
zX}{7fk;YFwon1|4K-<?Wk;4QG#L~0E>Ohy3A{O)ah2_8Lr~m%5-23!&@24eq%MuSk
z88L|jIt;Di)yX7TXA9x%%8ZJGZ1W`a!b0ExfG&jPu$xNla_ve*Ou-IA(3dr(I;4SA
zK3GYej(^mE-i(@5E!`kyA->)-%)QROSjGEcS(67~3pjvKqtb@uV2NX=wvKYK552uF
z(jJI+k54up)pXJ>Vft7kxy*CSL<QcdRd9a)JC&jKQ-{8~-fznA)%h>|!lH^#S4C{_
zptJFL*^Z;Ea%#`6lv$#fy1PrUaoj~o6H-h1cljGWk}8*<rtg*Yr2eWzRZq7e3wN@A
z%tfc)J#$msqADqN(cwj$@zy@=SzVdO!364Xq{4;9Q|~UFoqVI+t>!4?MIz?+ViBl+
zbW7)_Ud6@NgYNCsB|QcO9Woi*qZa=*xFDn(9>_~BxT)E?{<#jwKu4giFOjuHc=epr
zaejNr;obc{u>zHGM7kq$x|7Mlqz9ajut|3^)9V)?<+~3^9kt3ZPFLe<2Ho1f7Ya&H
zXWaM&f1ByuWZgib2c)CV6Ko8qvOUW80*N^pSOC?ed^u<)cGOrA=8-p0DtJtV2{is0
ze0=$L<N->;woC-tKd6aU{2G#0=R%!RiW;*732eU5dAoL_%B}NGG^-4V$hZ?*t)(G2
zZSk!Ut4>QUU=bOT4u~_zg)o*vi~45+d4h-o;Rx@u&y}c?C7jD72!F$6ZRq(|-Jyad
z<*$M0{=2V8Iodv*VXwbgmjZiyIuxUe50+&ucKmW5rFNAzvs@uT+2wu>0+cc;3*9Ii
ze8Eu_a7*4zxEg$3N)=dna&!7vu<{+dXAQdhR=cF%vC#jheB1+_dJg)NneZdv)ld91
z!TBg`^jAL(PP$5f8%q;%Dm&kGn5YUQb-?Gus2A0Z0e@QoK$zN!qucv|$K6=tKHsP2
z7=Z=atr2_k37=|m4)`k?e)yv*s|^g<VC7)^bt3*5$Lv{2OQ;eDUEaTS`?b}&KNvG`
zw+fK>L~^Jifj90<^`Wua&?WcphHq;OrZYw>Q!Crv{d@|tY`i>8i-nW~ci!nMh7t0<
z4gw=CQ7_XqUL9jOcJgN&#7p0^$xQ(#1+ap^5tr|WkOywbjh-zuSPdX$9;sxVy#4<7
z)!yM#=I<Z;g-!iDEg1gc`$N+_mb==`B<vmT7p0<6K5njnm%bXE*9?ePFKU;ccz6|?
zwsCr-lJZ#Rzg;}NXSwoM8+8&B)5@np@jm0)K(Z}*XcRo5AV@^hgeP=u>KS6Ab@`2*
zy)0@6PF~92Ythg9NwqRG!pihNUOl5a=Ox}KGn!LHQmNo{Pl&^g+DjM=oV^T>#=azq
z%Y4Q%!{HgoE<V5*yqdY3QK#fT2R-{?-5{kvmz;ED?8D!S1my#5M#X4`vT%YJsfC7=
zouKLKPv(8^4BP)9&5+<Lz9zM&DDI&K*49_l)izMY6dGl$Lad7JvK0?j!!r&cGo-!l
zx&~8kf~8+Fp=Y+~(o~z?!ZLl+QxK0(=Xmat;-bgxP-B?MWUal?fC7_T?-B<;b{v?~
zEqbr_3A2iII>28dxV5W@1g&QDRfrXN@GYM=T?qV+G8}Q2rl~I~h6>}PoJrEk;f33S
zX59*?h|VzVo|>IlIR`o-3DLt%WSt723v}`=<$~8>hxUzcSxq>=dponC69o5I$+8#q
zFEi!&#1}0Mzar#6qW?LvhxDWLnp9J0{p@~-*V%^LI**k6%7h(|wGl`HtgVKK*+Bk{
zYhrgl+v-)i7o0Aull%4Ao*?Z}Tv%4GZ1}~|z0#w+wd}ff!j~f?Y0t~g%Nh*tesPJd
z^t}3`?1uTTFGs0PTDkHNjc5j)%>{>c<p%0By4*eSoETdWZiE1cM$o9h-oi`D{UVTK
z*9=>GZsm7-R;1>$JSY4+<gb2-%q!s$<SQuxt9<n39fp0;=NOXWZeNW2^=(|CJu_Z+
zl3yb^_w;TJ;t;b2-IEmPu{6hUfG-+yC=jJP7pL2yBDBq&Z{Y%A$oKAXwS{oJMSN^~
zjr>QgEF8pBvtB#@H@xF+zpp|-do_S%*t2r&^*zf)d2Nxl`EgRmz+?uAyeN@0BM<D2
zBThvJOV+bhGvfwc%)Pz%h|14XH9*Rh<*Vo4G(sNEV~HzN_h~Wwif~iM?*WpEQg!+E
z$iof&olg0;yG6oIK9b?i>CI1KD8vd&QQPN$bCBrt5X`(0l=EyvY5%?fc@Aa^ggwZT
zo*K%30bmcOcPL6;ZR|I~-?y(S&T1bJTg?j&83T5~z-ZJ({LI6u2`EwYo1x>WjrF&U
z@V@A8moxAkXdv1ATND`!SN*1JL)TclrhD%WWgI1xo?pk0cvs={_uO0mp?TCH<UWpI
zrxKB3gO%RP)`rqX;^2J;KxD`j#KN1zzcZ=%3mfI2_Z8tSHzbN9GW69H`5XWRp+`3}
zkF|t+s_*c{u71pa!!8~Jx{nq0&N+$s9yv~Bd?|Jp+-%Ad5j_90oivZ7Q}3-7YgfVb
zTD~(f5w-J2x%`mBK8S98*Lv&=lQnAky{p&Uudd9i@yQ%{IdYy&Eja1W)3phIA@*ZU
z=mE}Nqg9*nW_3jI!Iufqv0>}?NlM4nO<zupBp!}seP-VTQlbwpUbnn=zRaLbZF=MJ
z8?O&aOpDI2W(^;2jCP-m`O_=&d7w$C>O(~<wyG>i4J-qQ6lE)1=Z{kBRry>8)o(=3
ze!XQ2Y{G%~rBJCvrj<0d*k33&YwF0#nP)Q9XP0zyNg%bA$-m1*Nunc$LALz2e7;Nn
z2~B#^gfJ?4$vWV|7gE``cfalA^fB>oRo`rzrbmB}jDd(A+Mgl&7p1kfC+>uQY5&&$
zi(j&}v5~};I=^dgW>9r{qU8|XdMRZZ#9bWtcv&%ooS}&9aeU?X9xGc6mix+r+CZz<
z%kS@g)Vr4a>`e8>)veu61kCw~qUz1-hyQ(XzjprB?do5*&i(sFvXn)tW+CH;imZKR
z2N}_FTPWEEnJ7-C=2YJ>Z)BfdpbcuybYGfL^w`;VBKnJ|jLd==zt<CXUdrb}`PoMB
zHLh`J_HG((esCIB?|$h~%MEmn-;0-g;G%V8*1sQI*zUET9^#cF7}fAwqHNq3mE40g
z5~i_c%^!x76auyV2oq-dapol1!{M%+!<1eOxegoOo5jxo$MEoM2sIdxq)Mm|M>nrM
z(*B~<ihnO0!vUf1VFguiqEpW#_i&{s@TXRr_vf#ts93>3%H~O`sRp&e>tMkttWIGI
z_6LuEAP3F`@s;aBPUXTKR581K-#oryJd_^2T}~6FZNX{#oLeO5y7eATdI*>3tbhs(
zM&#n3VL1Z-K!P8c{NcGMNRUKHEqq%S07oo$C~NTdMMKArA#swe1ewZutUgE_Tmu)c
zk>~_ThaAx8=tgJt$P|J^64_6Yw4ZyfP0trmmDID{*%|A&{=Xqu=^oe5N+^U?rk|ec
zs&2zeyfud~nGXi`K4mF2$1V^hn+Gt<1W9JBWQ&le0q>OzlC}v=R<Ku!yF47mpdhEN
zlLC1v#`s@+_~IB4jU8IGRQasjO!R>)NK}$)h+);6k=W;JzEj0=XV$J8AQ9zO{4K=i
zg-!WWM}#Zs=hhW~*YzSZbU7c8_&C*g#Y$s28e1EBdSqB;y;d@wDp%3__w;j^eSzXr
zNT!Lf5>Fqa0xZICFQYWcpBv$J^{NAaK+>Y&$UMiSR^aoJY{mic2$E{DBVvx!*9-?n
z0LA~PkpTWMm?Dp)!jUDj0rUX?i+sHZcsnb1t$vl(nRg52Jg<`t%}(@+y8$L;s{H(0
zyMV|d+}{I<Lf!fKW8eS9>iCe%0&zM+D!}s^<CYh~zX>7S3kAk|ETqk8+21|WyWdb-
zr-uqNrfg#H9(o4`!nvIFhTQJ^r_a3fxh_~TW~k7kv5yZfjeb$PXlRiA44606AYkj;
zq_hV46PHx4OyJi^+Cv($wg)w}Lmxr<G_TasR77s%c6Y4T+^n#ATyMo6O*OvP!_Mu7
z9&~heAejdUYOfN_8SS#asRKyxyBWGHha}7CF?|e@w$*>a=~KMEa*>#!^egMkg~<k^
zAm$ulx2v_?OB>^qrKseV^m)*3mxOi*MhEg7jklHv$d=jdkr^BRDt=lMO)Cn@ID9!M
z@xz)qNke0K9`iLyePHo?J*lg9p^BMvZ-22`MKa^o;&eo{bW#X<d_fX>RQak=mP4D~
z^mpvGlbyWhnV~_e@Lc!^ixffXSGnc7+lL;@lQC--3#bz_<Dgtsfa)H@pc?*qtT_BM
zw%(m&0e%6&>CAvo3>JKKPEx-~re{s#sr%ORUVdaGvmV5J*&SB`ju7V)V2;=y=Lc3t
zg@F~d`Z?*DV7XS($BIRc*^t2J`6zKQ(^-H>Yzo_jm`1J~EzZ{bL6UbJ)$P^s$e;9#
z*|fw{%^h;iB}J<L&hql~IO@v}yv1XsL2sCK60d`+U-qEm+7(xc>_A0~8dIP(GAJ+s
zdm+Lh)Enze8h+bi(d?mlJ7l#m1jOami7Yqye|J=euNZ2Sd6$1j2-b)oVM5Z8?zy>w
zP{JB?0kMJ=TA#v>mGVjS2>M65=eH{m^Nz2T*A2vORT-ZA_p5f3U%}$87WXc3%h5mO
z#UX)2(pD}Ew{TSIP>^zBkovtK?cYIqhk^|ggN^S6+dJ_O&FQc4!b8ET(o_klUV+~V
z3Uhct(G~2yZh@~ry8Oa5;du$hS!_^Zm~|`z3Koe2S(?3$K!IAGXaKM6Ti|VOzvtz$
zs9`bMLQkU7tZF1A`b6?yOIH#kON10rJ%%=kdd}8GlC|i1!f0TyoO4a_EJb{PRLz-h
zBfn7O%!$<>D1G}o=C0mp?(GaXvPZh5N7Mi+6Q?P;oDd<<Fq;^T{XJh=&+_62OAp+Y
zxXwa5B$#uwRn$f%Uq2UhRtQ?350#;dFW<(Ury4_p%oDYZr(NwZRvHUL91juG0uqJL
z5>mp=11@E~ZZOAth_vFYcU}shritUak{O`n;=`zkap@)c2{Yf$<`FV>-jK1XEZiy?
zz$0u&lKcU(mse4I@*BhP(bMe<ljI2JlTfV`q%KK5K+%DRBE|uUzGcCeDAISo;{dF{
z?4Z<4ciiXc3v0gV_hV4e%lk8o_P0c`T}x`-eec)m@)ikLuL8Lc72uvgE0bPZqH>l*
zn=*T5=6V>zZT+R75Qcd^ruSBXaj5p9zB0!36?TeZ?Bk8gWt~~?k#;D~it)p~RtH)L
zhYNd1qkQ|{YL<fJNs|!yxTDy03K^mxU~reT^g3$Ic{K5sNYMPOLN6+!rvpkA2Wo^W
zYotEU@sp`CLGvUtoOr+ibUsxki*yByPq{hsJir<SuZ>HXm&_+fa5}L7NurS?lS>la
zHUb8=euHu1zEtrlUF2t*3%(>VPCa_hhzUD})u4*+vG`Fq$$JFpIb;xdUa}A;=XxDi
z#ZZg~MWch}_DBJ;9OYe-90#bzGA_nQq02}pfE7Mt0CW>^|3F7CR``iZpqD6-TsH^d
zb=s|39QIexONSUuPC<F_{CS%rUb!U9J&<WfPxxMslditFhp_zWsf<@y#`;D;=Ug_V
z<U}IEj@Kgy@7p6t!mM*De)n|LUycLg5qtCUPGQwLm&{j;b?BgLiGyaXKo0Lqvuz3C
zF+|}$oiIKabBBzBKEpI;p8A?u_onyg6gbtU1Pk<Zold&^LiZp$M@F1v?=x@s5&)d@
zuqSy+C-VC{w9eRsIf!M%m*n5k=aKh&hH?9%%DaGRAqiZMkI#3nKG=Vm(<c?ED94C3
z_P3*-r1v#s$<Edn^K`qr+Ek6qV<H;xyEthuRtVW|-0>FE=`Y#ke}wy`Nh%DMR{T&d
zA1CQ0kR}BdtfcPyB;<?+Pkej$S`v(W-J6M5FbMf*C@YhwhQif@?8n6#K>dlAZSU_2
z_`SB~@9vK3BxrC6%YLJDF6eeW{=~@Vuvu%zyc*+5f?#4e3T1y`cO8>zg>X|m=#yo>
zP(zK7NIz{t6z!K>r=C!`ZpJu#f>$B)7}&n#7`DF0_eGfbG6~Uq|IEdAQk6RoU|`dq
z&y}rujy$h4?;tJuZ{v`P*!#G4e$M1?!W}t|fJ+3f9(ele5q3rd$5O*=j<=UK^S@*X
zB6~#q8!l2a&0CnpD=cJv(x*E!7z;iis}h@E312-f_@w(h7lfDG-A~4sFkiI*w_!}6
zcZ#pJ{CbScE=Zo)jQ0-{4G6v=5R`gq-sZ==ZQMMjlN1-ggO0|v>9-7=sTzWT+Y&2<
zXVd|<T0AT$8nb}F<HWN-mp{$d-To`hO2n!4814~qOM{p`S)9@oHX@l1y?c}+RJuhV
z1mkod@faEi2w1=@f8{>3zjDp)9$!#QbP9$A0y?oezgcko{`<IWtgbPCo+;+{94Z6%
zZhbzv6>I(PDAp$Lgwf$@1UTL?q3v1(<_At>Z(i!{eCsNou*pA+McR|Esn~UooNIRO
zug^~#bjIVrKr2gph9@q$z`PX{Diw5fz2^y6h-1L?c>@cwN7rWTnLUr}dm#$(TJPc4
zpjN-6MmE33cx>E|fLxf)=r!yd=fTT3$@&faFsvBp%LD-*Xkk#Ryq52UH~q2XZy2{>
z!9bqxNe@FQ1)V}cscn26ybC<&cri0=x!1ZvkPjHReC(6+M}!oRfx+)iPg4~*ii~a<
zC&%!G@6sFz1&y9Dk%cACJ?z^q><8I*+z=uNFSFi*sh>mHsoPpa79UR;swbMGtoK#j
zlOKWj=qm&OpS?HFUq4qxBk<d(I3?R8SxsJr(d5V8J>KiN!GoWBW(thNU|J=EW)wxn
zG%@SXzHHD0g{kK{y1(@Vu6)1j!4;wjemJv#;C(w$kzNxd<zxyBQRIKm%f5Yub8UYr
zRJ$sK5flsR76OY@EOti*x&ah{J26_#z@bb#M8kEtz$X@O@=bS1?*Jfs^($f=cd!H0
z7oHElHz#mpw-1E3)@Khutd>`kuq)k$0S<zJ)_0zc8eWVRGRq)JNkz*M&IN|Z1@Oq{
z0`CH>Ph|XuVPO7p3C9qkVJCx!Td=YL^yojnGt(vkx^*8^77$~jGYEx$S5G|-+DqBR
zVLq>|hxUonaDq;?LO^W*C9Mq%8ULko@($p0K`K5%x3(`wRMQ{Xt#V8Ou&s9(-4ZGm
zrB8$VzHO)mSkPy|qVKq>NZ?W$w^fwyw~il>2)dBz?)fbch>t`H?${qKxMKHV@B48v
zBI0rS23AS|7Wbb8-DaE`opr-O+TkHm-l<WAqRvzma5^$GMm%^!`MSs5+*e<G=%3bq
z-KjV*-)K2|XW)^M-i)TMEs$!w>=h2g@Coqgiw^0__laDkLcEIOEJiB~WwdIu@}*C6
ztDDqIFV?b}MvdM*DKNeN<9%1k&Ypl-=jwc4p3LBK(O0u{=&eY-3g~;w^lu6cno+a+
z({Rv-$dqvMJ23!yQm+VJboU;>i32Ce;}HO9g{S+9gP2hArQw~UgV2*Ydw+Th^(Ko+
zOzAI3qpJjlQZ`ra!0=-cd!R>YI)`vo306#*bn%^|LW?(!9uq6jpEH}-<@pfv1;Q*k
zJTof+7$0XI7Nm<TCyG-^Ze_uAbXx>d-Ng0WkWEMnJtWc9f-khp!__gg+~;c;)&=`4
z7>P!M#s`eh-_HsrdbJ)xA10ASi}m-FVlHx=CC`^Se?Eh|#W$8bGez$~D5I{kQkz1D
z=xiyxj;pf4QKO#x5T@AZczn^JSUkAoa<oD3^V-!GiEa#cmd+v!QbJsSi$==Xgb1ZF
zoONkolzIb~DDm9lZh&b1#SfcpP8K>J#4p+Wk?fUBE{lB7$bP6@>gFh-ZQ4k94rMyF
zzlADr-Nnv)UmPo6C_Hld!E$xpkC>C#k{rdf00P=R&S=5m=3*29{y5B4)J`q}m{Yd3
z0oec9{M@d~la9fU9G6KbJMWH;pX#ye?l(s2or!c?IWAKi5%lUw|Mi}F%c<`95ZN<m
zKf8wqo+8hV>A!Gpe{l7l$Jytf9=f|)?Gc0dW2>VNzOwk%*Kqdbem^sQ(p3UhWXU#j
zxf>g@X>~Mi29-T)x!AI9`zol&CGkzz$>fbUQHxMJMK;lDR_QVMQR4f={|dI=#BGA?
zK3w1mB+b!;T$ARrFoj7AxjN6277Hx}lb1@4x+Z_Tc(O2gx$?~O<WJS<g6BWiTDwAI
z5+GQvZBO0p=jXq*nkK^!y&igUccn(MgJJkx$zV#uTa=`%ENp%-U;QM&J-<GpgW1;L
z5%%A|s`#90{_5d$Xu>E$_eI*)hoTrKD-Pt~n9kziAg0nFP-`oBrEjrp$X%oIsB+z|
z!h4JP)EDX8z0sAfWMIG2l{eH44?~fZ!cjgCnU>H9-e~9W6z)wHua26s$F8D$(<$e#
zPnHPuIR#uaTlk*|95}A60LbcP=!Q)rY($+!IvRV$P_f7uQEP#rUY1b0AK}x#MO0iP
z2P9zCO)(6@?4dk){;lC@=pK<t9ONrGPW}t;3bCWn#b&`Bhs}-6pG90FMBFK`<F4G$
zi}f2Yd=9Eh*qnFDeV7dckqgq6c#_(JV46XoL4e7@UNu=X9GDl4WX2ZfhnyG(k7MXs
z8JRXlc{Xf!*f-l@Dp1PND-mhclx>g;SrwK_0vCO<5wOc)@RzRlu<b_TE?z3N`m#iZ
zyQ~P=xjCMYG$9~JEp(MNCSB!PePf!I_5SjP?=WgJyS#-)^4u8=ORBxd*aRy%)LlRP
z^h>9bFuQWrXbx~!tpV`8LDP95fIrVQN3tr4m#4r|YvL;4S4W)R$bQ_-H%^iMQFv}P
z6b+Xy4(MO3aIHP5`L?{xJ^Euj`puZ7eqX82CfoOnaHGBD*ZUx+VlHvofguJa_c4^{
zrmEM4RXwA`f3)Z-+}eaGtcU=9Ep6(@d76%<=N@j`R>YWpgacS*-gpRB4*BdkUx5bN
zs6{CN?Y?B`G*s$~kMh0%YW98VbT?p=CTODumJi%4@>L>>g<vbh%X+E;*=I}LL{-5&
ztNG^!toUtNyk{HF>yjun0&SE96Mg9GJ`JBR<!AO5bK%U0XsV6_pS`1xa3S0Ki%z0h
zvpbGA+dL8>Pg?P^CxvAD9Z0;}qCKr@xm1*bth@fz+0|y(9ogrk?uIb@)ZNK}#_SV5
zVrGs`Sr|y+ckkUDi)k(AkQuH93aDlQij3?$pS^4?@)b8t>VMg?bG>J01dq(X<cUws
z=N?y@`VnRj|82(|h*`gNJ55#MZqxg7Pj|foWWhCW_V|;!AqUu0q5L_BW>OFGG@Fh=
z&clx+apY|q%UV-BU&QnXBs9_<SUD6=8FM6MBJ*Px#u*OLBt!uvLq=`)p-sS|^y`W?
zi`(;jtxB;`FC0#I-tt)_Z2unYq4E|V`ULfd@a4|W^mf|$qbUhr<va`o#c}&t<~VHN
z)+FnqLY$V;dFE-5ky>#M59~+MLOa810hVo@mpbln_AYs(qA@5tHi4~Bpl)yRdj8mA
zA5De2FDjfG34P6{C%JekUh^27t*sSd;-iM;mU9|&_7ld2o}7Nmw>=NMGZaN*_Gh5g
z#j^fpe_BOAep0gTPCi1a!jn0@H-B7?us_XYRT@Cs>sOc6GxdDLsTx&Vu@%pfU(=(=
zPHll%R-)3`DC`7B3?IY@xP5@4aM!@4lt(x{f6(do2qZ{w?SJY($4UpZcw1hGq@qLz
zrSB3z{9nVA8i^KuWbQj47fVcYc&^xF15q&GNKVfU=tq&x(2W$tJ6N5_$1!}lr@9t8
zhS&tZXyj?NI$?7pUZydKnYiuwu5LqLVF7!M2*V<srL)!V#kpzLXaT1L*HZ75l&9}<
zdNF5m+Pcta&6dv{!t=kXRk^AnHp`0nUSPoHgX0*(ukP40cn5(~qpfXz1^LNgsJ5(!
zt!bcmKIc3%)lbmm6FLg>Ap&Ar^HB&tH;L(ZY;acpdyF`ZgZ+|ZtJ&PUG1=FT`7D{G
zTNbtX7s8SofDattnui>-ZiSy+8$8*vl$Ej@EcX!DHv>}R>Csk_y_9Pb%6Ir*w?C1@
z1U(Y>TNDbOTOe{P)Mv}jnYIXhl|;wdSX}@CE?oy7AI;@yxhPkxy>eQPTVf^off}tT
z3exx!0qp{a`9KogY~UJF(ysQaj`_d#(o&8tQM7<!--PBH?swM-5+KJmNMeUu2zJG&
zk~Q8vw$RJ<l-oR9z=s8mC&H_l=ea0@2$YaZh|Nuf)4mF@;bOigp{QhCxm(1@o4Rr-
z0Pt>H?#$MOS-d<sK`0WX>p7`#`J8LX24Xf=z~;u;VLc%Z`>a@-!fju43sd%+n^jz~
zY%&w-2v2lMpxhRTk?rBv)xYop5Ppp1D_|iFaC}Ta+N&gNhaCnF<-@MQ&K!bcaeThI
zLLjy#8hv3=0x&;|M2dtPaKgl)#?^MJY2nH*@FG7m1d83zugB9Q=Hb!BFyRUHv0CM0
zQyDG6z5qS`51E%3ew+z8eo0k1mMJ@u?Ew)5Sh{k5+b{{ba&>H}eN(Xpuc{3SI!QqA
z9^_iF#B*e~jmpQdKG<|mD@Zxp@*hcHK^c7plpzd)dlm~7g`xJJ&ABMS#nt>5LjtMW
zjGD!GfF<DU1<|oFeaIs`LlN-3pTibLpUZ$7P~j@#z!3u*bS$|+?E-*>8LT0O>Y$sH
z=+lW|dDhTPrqIW3UVYUA9w_*zn*nTE_OCsf%x2Ipsc=!rueQwrauJtEVcJ2&;W|qV
z)RS@eXkEE+vg>nQxfr6(1QA7IV?nxtKlSA1@$$ZN0;cOZl@i92bXb*-GE*NPt1D(M
zhPHG-6Y&agPxMnfMO3+XBpA`-W&>iw$Ynx5y~C=@`3&6SJl8V^m|Uq#Xt=GB#KRJb
z-9;g_CRGq#s2C4lWJ{b8mfR;ArgaPW2W7*5#TT|~U7s&+a!~Gd6THe+@xjCSY8-?K
zjA=kdMhZ~AE3|=!*Q4Rd;u@|Xp%h)=G$IoJpsaS%aFZ<yB?#oIdx$#}xC`6;SQ3V!
zVXIiBNwkpZeMF%{^5lfR8ZBo}SLh5V%0Y?FT(l9L5PVc2H$0A6!wY3_E}aG)_xj~(
zPjfNb!ljhRI(J^K4aO1%m6fxtD&mAVUzFBGq|o!wd@1=TK;4&()GQXdxBxeB7q!7-
zT-P*j5)Fi7v-g`EDt>5+kMcg;u6E0|M-~07TWf^P&0iIXKSsDpb`%_=3EcF%TD!rU
zP2nqCg<ZdVpx6%`K!GK#@>0X&gn~;!6lnZ7w2I`~(eZzzI|>RmCLtS5fy+zR7)I3{
z&aE?Ut}`8}Gyhs=$zM;<sJC{iw~eZ|&#iZCu0JwT?^0=`=x-Pe@O@v_cY_{eRmj|v
z)bWPOsz+T5sFd;fTL12KL1?apmlf>JLG)`@Sr-BECrM@$n%1v(Lx(5m9`44=hN7<5
zGRY5b#5tkQO+`%{YN%U87CNZyjc0k@fnPFGk{^_@TRx-apVvQsUFRVE9*!>F-n0{O
z&AK7D@?uk>A^Ng!V@=)vG4Yz4o3+=3uDEfPkKGe8!SNO9@)e@?8I$3ivDeN?$*#Z-
zKFO7QoU68yogM4ch>cGdPrT-SvE{~FV;?8T#K8pb68JFTu*n0N>U&p`zQ$bod-JmY
zb+_gwKMmdG^D_QX=s=C;M{2I)Z;ffWCO)FTqq(M@;?O_cc&+-vZ;}8V%bVqfe2Yak
zd6zexh2Lc%`@02)?BtW9qP0Y$yZs9<yp0z>e#7+~dk1$``ceMlucyUFWklaaor{ur
zaUR_*9TE7c1&z2}q3AIVlAm|u-Qt%m_$w68)1cCMhHWTx>!srq5p~HS)R2$71M&>=
z&*N?HsCkI_{+G=I%XQf~W1n)y$Mg>IEjKFY>n*HwXn;&}Z}VN9Q^qfSXu86%e;Uen
zzQT!k=;=}2<8{i@fWRzTqG{to-8tlAtjg*tdzxY9)*mLZlVJ|&47%4cem^|yW?^=U
zH0o3*^NP%L1bSWihKh`y)~Rbz@9rFPyyte<<58S@FhY5n|M=|Mc@-nMZ7;}idb~P>
z5n~IP{i<9U)^Rtb!&#=C`Mcv$o=t^)bJyr2*@#D+(JP)QzWsTvRmG1^-n^x*+1kJS
z=;YU{b~_I)iC9r}y)Qnx7q%5zDheDwtNOOXEA$>}qZ?ZNs{x_h7NgS09PK#A7nESq
zc+Rga^U<C4ylaiY(Hl3P>YAXpZ~71Ba&K^?8#hl~154>tq&zM@h_|K0?-TtdWt5Fh
z!F}C$eSl~*iS{=V)$Ah&u(88fj}j;OD)IKKPL6jD(dRVK4PT3o9Pb)TxvP`kq16@e
zXsvbYcNb%xbNpSe;c(Z)yKd$rp%73sZn)v8aC39y&hg$vXqzT03(IBu+FeJ){l4Ga
z+qpKXa%Ai&b+ns-7y!?<px2&?xevq)$Z$sox=aR&PIX^75&{qCE3(Erz=RZwZC>Zz
zBFV^uP!|H+QLiR6_D~{_N$9Fbm1HE|ulerK&Ml^MU-!)pw|A{YV^QU^gRVO=X=c3-
zLHEp@TPy6FuBQ&>EE4u9sXq^MJH1M7BRl%scH5fwo!q~KK8#D=|0KFHdPl>w4X1Q_
zIBGEcVPEd4mcXr+vu0yTnj?EV10<8d@82G*)pjdCdfMb{qP-~8W;AjX3>YC08M^Q#
zXLw~OZ2;?$IcBxOl&wa=%k*%n&UZDc9;pYsDCr7VIq$kv<uQ75*zb7j<98e{nH%*f
zk4$HqDyN3uu5`x}Q5W&uZVJ4Ie}(=m6LOb)a)4^(nQ!8?nXN)#To}ELy4jL>WFUN{
zvs<fkTx(!ebFhE8GwI>WgE2B9E-g9*PiIn}2|hDYy<aFQs|?`bh1)oG^U*yN(h(vS
z6z64FA-j)qo<A$tiD<6hH_cX<4cGE_xt@A;xT<T<x%c_a8kj(@<gwSCHLVfPUPTL#
zPx=pAd^Zv?S5`YRD6x-o9(VcrX^b@TAWHTbXa0`K?sVr`#+>u?)5@8+TY>upR<N9G
z__LXH!<qj=p7zGRDLru#{?Em7MW*W3o0aPiYFyr4k9m8e;BC{bw>O`?z4iU=?X)@%
zH)sN-h8^=R*jl%GTw$+Uz}znZm~?v0MjuLf*Dt5@R~cO&qFi0>3t}N-qh}}5&_00W
zJRTlPWPwnza2OC}B)364(x?5t|6gX&rXq-m7(D^`^Ho$?<-?-DJAYlVkvZi}{u)m!
z-GMnwZ};_bJR;qV_wZe=z{^!tt)>5fLU@nv9Pg9-0v2MY0kMB6&BG($k*F*bq7V9C
zu(SY{gp3F5SIHl|eR-W}0x4FZXQ1{ytLMr5Kw8g2a7i?%o42Kh;jkslWyVAx6VVUm
zU2<WgdTM{j4c=Ce+6AGTfYjbN3~mEiB42sNa?pc+wATFiC&NVPi_n+3q|j;M7{Hbl
zgre%oZT(wxewZfQ^Pevmc!(E?X4^!=&6+#~`{LmM*;GjY0F#8zReyrwXmc+;2KIeD
z#mc7gz_V4qyJ^dImGCW;;|_)I=ldH$;8I_5l{Q}_V@b$C7U0kY?`o=CJ&j`hP<}Tj
zw5odyO5mp09WD}&M1{Cz7W}A>p7Z1C^7pK&*dB<6k`VU1+B@SK1rrj_PK4RIMQVAi
zd}OTbTiEh6hT<jA)oViODB#wdsF(dWr-#U4JqK8itcIVm8yXnI^VjK?ase^GT0!Lw
zM|Jjx9ui1oKNJQ@72lWJBMR8Cu}ycrJC7)>;E(_Pljz|goL_-barm@DP6#{xN#KPF
z0}x)42Q~vgquuYHqZM+W*Z)~P2(1^{!&<ruL&wm9Bb4<~l;qC14?uDFAvmJ*b2v^{
zF4OVs@Y<DqaOWOX@YUFw&4~1$IX-VU-VAcp!2`+_Y%zvB(1I5!XRYMW+R`Qv7oxZl
z-mzlG+9c3a0e{-8Wl=qO<GnVR>a8!aHhwO0St$9}5-j#r%x#4KSKL3e!X8sEOIPlX
z?gBBr9zY>ZCE2}4cK1z4j1tX>z8@cWAa0LY?X+*JXsVZaXkJ!8p9F;6$F>~!fe<qM
z${d_Au5U0oesRoAk}i3ViF$JN&&`w3=2vAp?g_nl_P6~cy0AcUbR60EL$Tw<&diF;
zhbw|5Z+3cx-d2(LAFT2hQ0ToccAx#+eIfL3Lg(M)(SNVb{Ocs~Ca|~8O~QxCp0R1h
zR@yU{TY8P7Wy{b1>mtBv=kvualq=m#CsvV9fhM;NKhl_SUzBXwBbiAg3IyQ_D*27G
zx)p$Wz@c+>&YFQ%cCGiDSg_5PGCaLBGqGsT#NmW1w_aRxq~5e~)lykqI#RC5lfRRF
z0064=6MoDxO5v`6<=HGGzgL7E%QWw=?8xL7&qnv_uGjq&7Q`wywN5xr9q6_&@yzBc
zTN?IrJbyf-A+k&bZ+$b?RwG1`h?`}e`=T<&@NEcu9LFo95-_tmpO@o&UV~q~`{@bK
z<Ij1ptJA}H*F1&g=;AK{4Hl*{hHu|&Mou+(AE__@dF|pOTksNH^$^}n9W3*2)Skf-
zx9{ze8;wV~-wFZIcmd`Aztewv^NM(lMpkZ&h);OJ{8!xCOXV3Z6PHZ=^i$gFzrf$!
zkNFXW=eFPPrS1Mn=HEGYn}1wWe&Z9ON#&*%C1iI^HGh-iaDx>lm^vy=@8X}UEQR>n
zHS*kF`&1F^tRE?Fyjd5e&S&{ni&8hY$nL-579wOTctT0LUyNiBYcHR&8C#aN$5)RV
zq~%*Tw=Jk!AxHrtVOY(s<d%vPuP0(yZD7Ao6@dc}T(Hi$d@9vxRqjWz(Mdbu*G^R*
zYnQ@Y<Bx9MUhd-4{SBCIxNa@wZ5+k(^cNMTAMhGwzI9&LZoUXk`cz$7KcQgmDZgWj
z)m`W7t{jnl#6(hwv0m7k+CSl!uUrrwvM$vk={+MuPJFTDHb>=0*fJax4Vxsr%YXS2
z=><1)mwvC^xM~$HBJ4<=nhlq?hm=@dz76243-r4JZrlk5SKKI|M)0xjT@k*cf-#y#
zV4tPMOEq3fjTXMBXm-@#=VSU*TBG^)4}mj*6dv&k#mualPxZ-_6MagD`9<MEHU~V%
z3$J`YyV<0N9Up2~g61j%h_sUBDM{1Ka2W;8zrhizcI_(-=_|CO%e45bfBIkgzfKOX
z{?CKKu!Ky2DgLM+A4e+cSo<ZQW!&IeEC;7r)!2&zPXRV^L+_JP1BWX0AKPtQv*WD|
z#UN5HGzQ+>+(h6k-yFQ%W%9>+=X4iu!2`zGJ!4f{?hT}@+CE<Ofuoap3}kKys1|K3
zXw?oJnF_T)bXy0*b3;FNA<if3R-O8NH*A#eW!u>)PoWM*#71)eq1pX>0>giuyd`f2
zeVNw{1PR~~y@PkZb)8l8I{fSoPowg+4)^~&52XIdzp(vf)b{rBeedZDJFi|kKu*~h
z6oh+Z|8wLiv>7nY5v77B%H;5(oW+V$r-MG}9R*K>u@XJR|6oq-Prt2?ms{$8(tF-?
zz(BubBwW&{{rc>R9gJTfFR9-g8AjH<Ip<>h(!DX&fTnRwW5}?RS?!Kg!fb5wkD9qN
zlct2^%WDvsWv}vQTk@hI#>Y2IeDAMB4#dRLuW+wYB=6&v-RMU`g1r3KgiBi#h19R?
zzxb*!lk$TlAoXRJ0`3$z!Rz@iokt!9+GOLs?9>|1JAQ-&38ZU<V;i<%#vR%1FA2Ow
z1k#I7zl|OSzG=y!D=j%Kkl_wSwAjXC+SW=pi^l8`JpJW_1?^JxU(t1ggoWV^gFlXL
zKeUkV*coCDwt1yCDrGlALN!k$V~ikt@^Ag@Oac}KK0Nlg^k^wmr)Hfu2EV5CfmN?l
zkn9|yQmQ~E+h|3Aa?R8{D<|v23~wd7M2C4^dAAgH`0*bXa+YV+qEfi=vt-x!2G6U@
zA=a`}aVUM!gRV(mtd+$7j3l*sUTfXulPu&;6kcNYdfGHv>CKQz5|NAi28(<u@R#{P
z8DJ#k(NM1L)(B00(~tjsxV_<iO?RdZ+rqpkz_*S(V3ipO<;#}->@6XuqEqGpTxs8<
zdK4{}<=C#4SjP82^$ipxCy*3%*PsHU`W_i6MP9KQ1$)N|D~T0Jm7c7)2_I=OisOl|
zmNPdz*>SfMe&{nqBkl;cOw_u4WPNt6NG#eCCCLyt{wH@cx_l}VLL*Oj8gu^ozH(HT
z_cnsdJ6jDHj41~14W011xG2Q;eE_4dVgtmfidu~;_}52e=(Y9~gie8lRYqrVSv>_c
zQ7_qh_?94-mww#?_rkqd_P~YteNuo6$B>4C8~m<mdDiR|%p=u*nrD^e_xYpbMcE;p
z3rA4(U&bYe$u7)=iEOK{zcF0`lryhH1KwnvBSxuBDcQvqq>j_2s~1?70bd#UnL`-8
z<R}1}CsMf=EDw5!(awKa@{hM$U~9bOf2i7|-VlXasG%!Z)#~2XW7T4vwEmR&WZs4Q
zpVWpdJS6k6V)F=}w|0^=8=rZO7~nfJYr(>yme!Sl%ZO??4>ONvUfHGf|7xXeLV_Z~
zeO%O<$)5XyNU+~9$0UQX?v5~)<*4itt##czkRN8KNR{H?G;~NoD{r?9bLDmhpoKCr
z3zO$KwA&sH%A+oE7cfG?>*eiTAB_$idvRyPIw3Ey)WNLba_gId7!Vmg-C?Dn>FsGz
zkH$*Eun%~?_^bk}`Pc_gnPN(0<$eT7ouMUX=JVDhpH;WvT2G{eB~-2M7M+6<5&VBM
zm2Ki@fr46ZkK#oQlQwuVl=T!cJiC|bkwYeqN$)${L57#Q32*-@e;NAKdOYpBoFi49
z%gPqMy>Aj5UqD?J+?NS@=3_%uG|t?r#z!k0pbpjC%Q{#j3U14fkw}Oh{zk$L-fFOh
zL*9>a5_>k<^GglHfh@L;Qaw;qs-_s~t2Su)f#fv!_WmspJNV)g^8TPO1t*$s9n<FC
z&BGsZma8SR)T?*^m3v%v5qjfK6uhm0oKXXhZges0CNEkk^8nuLI18VLrwbm~V}Ioh
zV*a8EvAo!%UNw7F4ghFsIZ5xR46UaQ*%<#+G`9KlY~s{~-;<&s*F6RdkMVp1)Dr@~
zBxO6kq-JSErBcDkaszXuPT<_ip?A;yg4>$oB7{7CB;I~x`J*s#=n53@$Cu;Ri-mjz
z`UC<;;*Dwl%4&OhPZ~qI^}AynP0X4ueEa~VVoHmWG8D2E51MLHc88zcZlYf+O8p6=
zi?|tcP!D9`=mqAG@Kq=>VeT>h9yZ$yP!M$5yuMcaGi4?G<j%WK7q%XA(^j)j?k=iw
z)Bik6zp#1Z<iBs>={xVa7q$ma?rq#i|2c_=t(V^r7`ySrdkCMsETU@Ac(a^Lw^^WR
zI@BAC3h~54AYR>nJ+bQB;80!tX@_ii1ZAJW84`QnyTZ6>o3;=BbgqM)1`K0^gp<ex
z32Iq;8w`~{*>(<)>Cbm|7(G%gJ#c5aMT9<$!KbOu2%a&z%A^@QP(bI%qw1iiAJU4^
zDp3HTD2dnh*sY>3`O2wqjZK&pn<E!5|MV~HIGIP6oDsOqLuF(H!!xwuJTCBdVE^>#
zHny3e8C5{uDBer=Gmm+BH?13bn8<T_P5`mNaDodPx$T1?@y~U$%u^ZG+}&)OfIgiS
z*}-jCz|1AF;Sxdx{|TcU>mfy|5i}jH8>0YAPl7qz$t+z}V8S7#Gc*O=9LhJOhe1D$
zVw=vi^>69x(yKZ*^t94lV!u64F3vqMS75U(5!s_3O_WjB&Da-~{i_jF9)b8tme_vg
zJxzh0i-gai3WK{dz71cofD3yE@o@Nrb3uGYL$K+CcT)EAuuf>SF4T?KNoCqat?=4l
z8P1KFiK2{sz#kq#v1`mEFb0Cgp(IHM>P~j4DdSxJV0wl9$=S>Kd|9kcuxJKWfedkx
zf+>{smSSP1Lzj&tp(H<8y5B((DvQL{Q%`CMiIh#nWv6qudBd^r;RluRs0O&Y<NlMp
zEgBx)EqU}0LxY^9^(QlocqlUVKt6%*5nG=moVCT$NXi=mHkiTWzDw9*z;F0s>TpGw
zqYQ%5kUG*h=5RNX$At><q|{0JkKPH$I<=}vddJhu20y9FUTPL{Bn!|O4^Q(^T-8Jq
z{doQG*;bA?>fDj(@gwuaG>z3Pta?_HMwuOU<YF@KboZn8Gq6x{fm1R6ad=4rD$BV$
zliXR`Kbt*}>imH@CiIZw9&$i#q~jC?`hil)nR@(np`b70$aheN73o1(GLF_YoWO@@
z#`9d!&548e4^jmM^I+k%y#7QZZAxb%mZyrVM&IEZxbj*3Jh5}+4s%MWPIp{1irn1w
zhqttorUR&*0qDIY{KjN~q)yel@E5^7(i<I}j`L2m?mM?r`Fz!B2E`?Z#$E4yd;Zhr
z`FBEw^G>!Oi^rN>lFq8voq_nHvUVO6ES2W+$wH^c%a+HlUaWBFG#X6z<CXgMXcj~{
zi#4E<%SCQ=S*r0EVtHcR<wy*ZV7M@V6mCDue{`<kx)NOaF54GgGCS-N^e%hujh^VY
z%rsUzqsjr<k2OUVYeFayYp}s2wE9pVus<%DW15U-g%}TA>Fi&)iFDM>!81`GH?y7K
z{8uyBSJ<>IN@v(G^G(G4>Ngxat`T3u1LO2@=|;7zQc68-#xvdRFm-!U*JGSY90$LJ
z$~&2v$$283=wC;a!Bpfo++#n!_QnVyb+vuG1KfV8mx|?`X7ea>c&1k~GS#xvu!>*#
zC}%XwnsO?e)}VGDFFUI}k8?wKk_8-@xgm1}MYFF0mEpvH*%F+WR936@`x@%1iTRYb
zm$#h45R4bc(9jh(YL``DiKkNx8vU>ejPg`02H0ms<KWlVvTd16<4xFC0I0-j9-oJ%
zyRrE_<gB|Z(vcLB(MY3TX2wCmQa=dIXeJ%$bXb65qLu@7F?KxYoerN#cvT(!4ED4u
zhf+$gkYXsXb7HtTxf48;TPb->Q@3Lh=-60jYEBl`ot`n{-q3U@q#kBQw3~VW4k1WH
zI%cOa4m9d&*_*;^{$*Fo!t4IQF4gi4^6^}q@@Pd!bl~7SRoO8yZ=M@xkTiGzGJPip
z21RFicbX{7&>(HMpt*&%aT&>VELD%YWqKLYe3bB^3cp6MIwP|*Da&iZ@kDnWfXcv9
zF$!w5Kkn0AUouOFsuWOJrFgx@Mq2I$EWD9N6U*a7o*ek-HdH=)#j5nu7#+U~MH{~f
z4}RVoli7D7ptJwVkrZSS1qL3?cB>czSlQ&xEL{YwsjT#rUui-oG@fCyl8QLYf=x4E
zt6YJDhd)bSIS(5E0Z;#CTA<-r^|BPToK)iT=Qw%-yyPslG+hmLsgnQD=PL^a&Y;Qv
z7Hs}2!#+=s$R^LZbeT-MPnxa%gRNygUU(*xx&3yK1<Mv@ygA_pPUQzEmzten_H%V!
zJ#>~qPAW^BN~9Bo(a}Z&S9E3fZRy7A3Z*kprx|%eHJF-0_TF{=!){Q<!JH(Nr$kn*
z<h?f#cT^0UM>Ck?GTcs`!}_LHi2lwNYn|&l2ER|qAar{foXv10Lu|10@Q*n<Mj859
zkbMyojmTpn30V+f=&<Q#3`3ex5krk;;Fn?l5^Ed*NjXnwZsajxl4zZaW?Tz~=^n9w
z8Emq=ur6Zj^knI2oQ(5_knV?Q*S!$-LkTzeP>%zlo))2AuA$z6p+2WWeJ_OisUQuR
zJm#<EfQpa);-YCep@D&XRd9L;OQRH}whb)rNG+?S@jFOEj_kpYf7xd-@-c<gX?}Mj
zf3Ust_y@jZY>($)bHm63aCNrgwJ5r-Uj}jYNapx(oW-a3>fEK#jPbQlJb!q~Jvch*
zQtEK{9h(0QhxRnGYx<LL+W+I}&HthL|3B_C3&t4CFc|xcec$)Qj2UYYA#2(9rLiUn
z!&tM7B_wJriBiUrv>Usqkg`PCqg2GZD4EOmb6vOVA2`3A^Lm}<^YOUfJK@aYo?X{F
z3Ef>mnYq&Y9JbQ}nTgqfT2Lts)yc%!-2^OW?sQr~pdyxWZh`9$Vk5;>QFVPTIyP5&
zn4@c_J{vE=e8Ro4Qt!js<R=~myV#|h6;bWGGk1&GPu0lWWDiY5e#v>C!?(|I@wIU7
z7A>%qJ!Gij<@KPq*XW7wH(Ugvwnah$Hn{I;qhF%E#$qig-g%FjvU3iy!k$%qRLnkW
zSJ+Vyb}xQa?pV%cI-4P$su-3o$DjT5W7tIp|1v?C?bdn@*7@XIC9rS;R#`Oui2gWv
z)p$rJ0g`$mmilsyo8=BW1#0OzbMpF)?2=0ZF>KfNu~H|~6kD%_yCy$4xQ>3G7U7JO
z^t+sUORWH3dz8y?F8zo3(|^^tzo<Dr!uft$G5I)UEG?prZRLC6r{KsYAo#QK`y7oP
zKtZ&Y5Rpa?GwEE_Vd+IWp2^G)C`xsF3t)ew1UFxaG-yg#&+eqx-xvO5$14RyPShxj
zCxmauuU;R?B4Z(n3x?<SAF+70Kv`Kq`-TxW@_mueqbn#83GK<uE>ULRK?+I!6xtiA
zfB*gbnX<GS{!ilfRLNJ%Q0I^N8Ah>;VKKIw!XEI0kA9}b!i((NPUkeu=ChJub-P_@
z;y<G9(BzjonAw<XAB=d-W5PpPMZa!Dz8{Ek=E>E90hR{PrJWotGF7={`L984W?8hR
zQ0b%04NcP+$((C}7BPBn3T2eO>J{!xGJFhMVvfCtF@6(s{8Nm{j~G){4E~K{4;Hdk
zlJnN*mU1@afc2Ksz^eX;?n&wy$_b|WH@aR6j<rnKwc?Gv<H{D!$UMaxXFqu2)gCyZ
z>HejK%qk1Gu%E0RBg4P_X;i8z&ET}~<XH7+wm|8-tBn6Fy8rvIwtJhLsVoI6+0$-J
zwNKyU_@gs_qd)s!psc4tyui-_+H{Ya4(EIata9ti)$Vw8^smNgYJgQ{wEBf!pU@^o
zE4i`PfJSwon*>c}UuBnd#Aey0LI64hrfflDK&P@Hy5#($U_oa#u>jb+BDR;JkPwvu
z_W-4q4P~)W;TQI^+;@XdKXuMC*ge&D)vwu@hJ=<ZfEDd&?j%I<Z;len{jBnmA8O#s
zlWYd8->?fa9EB0l&%I%mRaTdaF8Tm*DWyoDo9YUKN?Ac8lQKQ`@)s~X^Jl6J6~VRc
z8I|SPt`lh0M?>GwQT^%c=k3`&VfR007i=8Cep7ii>@T@mL2nBUHd<;+2*EBUU3@it
zUZ*jiOauRkg%{3yh3Uf$v#syAYnP!jt6HqnVeCq$r>kWqp%O3-l+CwcVbz5b2J4p+
zqiiU!%)qf_e{{pFyO9FlKE?j#9pj_EYf>K0>B&OU>R!^5&pD59;M1?NHl8FF&<&>O
zS*{A;oownS_=1`BXg^x-Om@cenXHzHaf*QeoU>gaid#vu?J_p*=`~Rxp*3ZUjhA%+
zt~a(6-_7Q@#}?UDuOVE*P=q-m`O9=NzZlUs<gY8a@o(Pz=eA0#-OsYyN=Sua$yjC@
zJ1<<On7#U_;XWiT1;*k<-8)_$u@W=|Rf(YceOzM&d3deOL*`q)RG1;<HxFnXy-<yJ
z<WAv)mi)M>OEpOWb1TIvjHdxIV8C9b+ce0zSTNrPd79{fulwi0?o`nm<r(^M^ilim
z$+o~ZwYGQTRX=n_e(K5hus_0?f}rzZHV=nLkDy<Z70X=c@=ritME+*kE_^(4(z3a}
z!@RdM&Kl8-kU{bj0$9I5QgscZT}fXLYBN8$VjRQVzx=YDUyFI}6_w=98kyR>-Sp<i
z1Y#HAt`qXMsZjdV{UpPkwb2qVjZY2#ROjeJeM+gQpcCN6ah^;Z_4?gwFK>v56{itT
zWDV+y!|3o|*SLQiJ19SuyK`t#^Hz!$HYGcCGI_=Dv?O7|f7Ma?aF19R0C|=!nf!OZ
zye3mLdb%cyuq~S*4cdg*0Jwon_gIFr&q&Y*s=T>oE+^U-sN38*C9bekRCf}nDmkSN
znF;Q<+t1_YF<g`}oX`5VeKjXlsivYzfR<OXY&V(eK-2wekUl1{zmfnWSbQm8DYiA4
zX}EsAM>xpA60~3oY&k_?P7i%Ev^V&3wv`W9w!J-1$};H4rUNXQC2=X`qMbsupVl%o
z{ljU+pcJ4UHDTaIow^-ORcJp&tV2_;o?(CBuxP3!5F64^IpKcy-osy(<>;LQ?NOgg
zx7LNixz?6>Q{vcm-WWfAF93)g%MiYybFwvR#>7DLeK_#=Am$CVOG3V%2HHg}GlsVH
zkz#*W96#b8eLFKIw7L>}l`xmcb^rO_pC5iy$?WrURoml)PN+WQgmNBdk@+Qn7M(u0
zS7wLQm^OERk5?*)#04ak7|pq0kF`RqfYS?6qq>Kk@5n$p60AKMC*v||Ku>k=!*L&X
zM5e#5FUqt5`@FR`&Kx=kdj-lnI5jMP`>EE5qvP2J*8$d8t1x3j;$d6J6uteeN#Nlu
z`*Co8OuW_W*V6U{U}m}o&5TcY9$%MT&D-*~D)2wIl*j)HKZHqM$V)!z?R^hg<=b6d
z+%8V&D!a*yx$yDQ?{5#+uE(fdHw77(c}G9nq)Hk|%axXjZ_GU`)Z%Pij0C1TG?A!}
z2mD;O6f41>E`M;Exac&eL$W8X%Vb%N?>+F#C5(u5g#tUS6_SCF|B|s=Ju#o2{SE+q
z5EIIZoq)+CApQxR4IR^jHKtG;EG0b2;?5#D)2M;p4jG@S1Y@Uh$SA8%9^cDf{KIKb
z;GS5B=z2GYnMN946_!mon91d<kuEZK^jo;j<V|B~P^H9hoF{^N_-i#Xlss`<9_u|q
zJsO!>RXFaj;9k)sjVz-%9IyT)CLK*dbZ^vD&Ec~`QJOi%N&UL_ee&guT63hO%mi|o
zJd_SU4CS<MmI#hJAxRDRs=)?&6l{SpJ1@z;Z<$(;7fds*%L@v(Q-``B{V;2nlq;nr
z9hNx*REWZ9o|$@LOF6(aRX)m!*kCn2c<9uFN$&y+tBiL7H2;*^L>c+1wpwEm>7xK1
zIO%=SaQ@krl3_xTPZ|zcxcS5LPSq_p+C({V1ttXQPA4+1W}f)7?9qWfa}xlxbfH|j
z=B|Be#XfnSV_;)&D^&H5cZOv|x(Mr+6j=9OPPVsy%=I{*2JITo8>F!w^sI0;&KGpo
zr)LNI&#~9K3)N`7NkW1tnIad`9w!XkN`Z6X4fcwwRJ-!9?LB!K_2q>x-R{=hM2V3=
zsrJX<GLrF119phk2d1)Uy3~=fp0UlFI7GnSCBw8Ff(%lc&FZ79;r|m-!H$Gf2Jq-y
zq<SoZh*|e`O&C}d&oW3Cky89ZDSkZ3|4*lJD9lxKvN8Yb`di7<#Z6Xjk2LM4RWXK2
zJwkTv`5G%Qf6oXmFC?xL=s3X>ORzf$8Ou}6oUlvcEN(-B0Dkc`jil<qx|1E9k3TwN
z2Vkk^xXXEo&B4NdD_E8{-iy4U`~#VdVO-k|YS90VW`;abw*qFOOVty=g1uH*#C24b
z{{WlC535fa*@>lA`;fR27~V*(hc9cr>>>2pH+<5nmZ46c$TY6kZoqlg2Ygp&M*+g{
zZ7s1_|11P(yfsz&<@q3-8*pjNSZD-&c<5OZ@nE4+Qzuai7~>Lw6oCcgk6whKa!sd$
z?8KRoX^IXpe>E{98To78%}kz;dxm<kz&8hSYZ*?$Up1YJ@$R7MD4H|)jeo8Sonr_1
zTdgxAj>{?TH^1!*&3LWGHh7I9BMopqNMA^7<4IBYucsY>(mx#MQMv~!&yxOdx}ssZ
zozbR#_b0=Xg{-k~#5C~S9RE63<#9_XYtX{ZVg+A+@QJb;F8O$RxUQhtCTFf!^2$5M
z)AhhW%G2-C6&JGvMm@_Y|MkOF34<5sr8t=8%L+c;^QL);ANaH2N-wI>){w2w0EviA
zKdf@#;Da@YwIs){N#CvjU-9Br7P^@eC1CY+&Q@qu=pFz`=^`U2G(BC91%cyIglv@!
z4y|%dz|K`zA~9rYs+|Xa@BBZ#vst%~-K1o6+8?(B>UDt1?smN35-oO&`Y@Or@8tTB
z_q;cxc9~Y^8Sh}MqV`@gAmL3X!d#>9!Sz|tG+TrCL_uuJF&tym5(69frfs4O<gb77
znYCwyP)hx>SrWP0yF{ely1Jo@>p)Qlio<dxID2u(Qq|;IZT^L%Fz~g6e)ZSr42}h^
zP_fK>!NYJ5kqp?wC{o8+yHY*8nN1e{QS_`mhgSA?_3Nb8G}r%jZgvGrk{6m@UH`tz
zW@BcmnQZj#uG-T89Y0YXH_N_z-~VfAAC+`B%M$O7{MDX*1^qaozkB@quZO+IzenFZ
zHvcv9_mk!0KN3G3`}Fq)$p|$5`Nsp1qb|NKx)xWG?3Lut@ZlaL9&T5<QFUjxuK{#F
zfiq(rUP`T)K~q0WL&7KblkWa}p#;p<^srGb^Wwm#dEw7`=TyPSycw<)%;jXR5LF$X
z8?2iFqM>Sw0vLZ>=%nzk#Hl{5;_-vE7(aPLL7yhLHA5p<O5zXbx#vJYj{QN}gMD(b
z`$?}Jha`5<NN-}{j)TkU^1MCdnuAHCGz&n~;nJ-Nl#d^aF8R~j*_5$$Zw7WGHhN0z
zn=vDbi5<+$%X30;N$k%kl|C|OzhMVyb3_TBIa382xydwf`Vg+qOonPHpkk)wny#+^
zQ9CHvu%_V9>3Rs_Oq{*s3XH9d@@qAl+sJ$VKWh;uD+8x9Hx0~Mb-Y7&y~1PDh)6Sl
zk#0KH(>-c+5lIlwC_1s5u_aFQo#QyZLf{~z@xw{I^I1Co7UnXh^cY+{W9BR|m0sP_
z-XKP=gu)=rI~(swG?{~>FwP8g58Qo(5KXc>HVsyULiEY$J{6^9o)DdN%Z~6d<;}iM
zpYpGp)Sddpxgw`;Y<PLR`DrYi;0+Pqyy2m;IGi_V+BYI#>tm*3evw|Fx+i#rEp_X`
zU`~Y-pYNEuL7zYp;g~lZvpXU8T0B=LUt7iv6AnHa;vU;184ocP+xoi{(sf3A?Z`yA
zMJE;dknf{B(JpF4RrdU7L2{$B`ev^{6iwr)t-?Qucs-$@s#5c@cy;)+sT0QyW)*s&
z=QC6!diMr#FI_vFiSLpUVDEOmM-?`r>KUXF=4(y6hwx)Prv3#ic2tF_@sKGZ2l}V?
z_Kfu0w+!j^L0pE*2nro%zwDkjqU>!Zt?+R;R+=G0G$E&7b|%Qs(x(s7b)FXPbCXn8
zh{s~><@Wpy#p)F|sWN#obA-WL-My_{qHj5=K~Vfp#hMFMLUtR)_(@Pp>7Ws}nHJs(
zpr+xGSVAAzBA$j5v%2=K%+z?%@%h=<t=yK<WlzFF&Jm5HquxCjTf$9s;7mVDCDd=G
zk8Bp<yFmV>S@v+K>Snq_^q7F_jYtg(qfMeQvf*s9II8(Nx^nOatXFAQ6ctW!`|0l8
z(9bt}`qpTH=_pYG3jVG`x;ULDpK60hwoAUZith+uS%liF>-6~wP&9O??i9IM@f)&x
z?!YMS_)+1nFI^;~*To;}d8^*Wr?k*EYvieWK?md-tU&z6@&+5=;4a5e#57tNGW7gx
zTAD7R^ZCQ8%x-Q(#o{^5QUB0`Wn+I=FEqu?EL(4y(6&<X6K|FL6r#ABp}R+HHn*s`
zOcU`YCDYO`f0Umyzx~+2Ox^%2MPmkq4hd1;^P>7#3lwZOQ}6*zOvg;7kNGujJ%1^<
z;LCc!&)~v8>xJMD8hnGs7g8j$Q6v>oth7<A6;fgpl69w^&`1#z^PfYB#TcY%mbwu<
zJ!OKKf(B_a+0q^t=RA)qjy&z**Db0v8fRt8m}6v!Xd~z`yxI80>Ud0=u4}r{BRLN=
zW%YqPVb3=bmut$f@Yt$*QLXp_18d_ZeHY6V>mU(2%x)Tq0yF|hf><iW@eFwz?>c1)
z>!~<Mw`w!DasN`=IV{Otj1?$0rOQNan2A!EQqW$B`Y#RKJ;%hdwSbS&G?2`}Z9J*k
zbci5g(0Aq98RyxiJ4^6z@+(dB6@zoN?q{2(ih6=vAxUECxsfp3O12=KQ)NHo+S;A=
z_@RH_Mop7eZ}ky>GUsM+X<D0~bobI*l$1hsz?NhZX-^aw%}fQSYP=U~pY{FHb$#r=
z{;`^{drsEC*jv+tbQ>$exx6bZK_uw*jcVP4-iFHMDDo!WAYBENDyTx#Bw4EW6(!M?
zrszt91Dc9%^SuQ(fr?3El4#qXbQvmG?+B=81rd2({p?R@`yccFm!5d0nZM^yiO?5V
zr)pFCy7^sr{&#vnJFLeJarOQN$DQu#({W#;yV;-aQ6EZ>V$JS8stA7fWh4=AMGvv8
zNoH3a0!bmRnqpD2pzfD@N;48{=~jgVu}y+Zb1y04`D4`=bSs0CXL9aaNdyn0C)i|G
zhD@)WJxkuatI2V8w{Ix9Vc>oK!^*qsYHD3$oX$_-*L^~hy*Ek06yoG^wORi&J<HRi
zS*^KG-?4p*a+S;*Us)T8L+5re$DnYA6R2g^r#+b26ONcBDC@?Cr*xn2dhODV>dShW
zMS{0{k}+>Z3sV$`#093RA$4rxJ_-3P21Z>NP|lSt`El6)HeUT*tb3D$#Z@aTp$ID4
z-RmEhGb2C|$+jpw-WyC_k7^z&_f8M?q%_D1kC=U(Jwu<bi2U~+jv{@Kv$}^SoiOf5
zZ#wA3RaeW2P)%vJp;)#v)NySnm+9>5)R%$j=Bn(!PjsvH^cKuTuGntT=g-_5zon?*
zWhGT5OiGA2zj5ac^x-}3soY6HlCVLVv>12;6~g@n{m*DyFeXaq(zZ}~6z0k{rX))E
z`nGUgl*rv}mPmV)=#wa64}y4Xb&Q6JCj%r?Pv#i@5v^mU6|P9=1|9KHg@P$qQP+5l
zucDG17p5Hy8cU*6Dg1=8U(eZ8jY~P012_^yFE8zy+Ta%y520(>R41+EAEdLn_>q!U
zD6&Tu)u#kK@6^ZqeDeBJoQg+B06p|*z!E}M_#V~G@e|W$!3S1nL(Is1R~qRTzz7_7
z?Gcbk3y}C2g+(ZwyE|IT7LeJ-4l*;|s~?<g^r|OFlW)pylEfOBcJ@8dPn)%R&81)k
z^1B&24hvBvQKaa7=LR+vYyrnTGa?>hfsRmlk%2XU{=-{ID3hh0#K>~>jiD(%-4FsV
z8%qp1a0-*AVSG;gAS%HCtfoNJ+y$#tc;^Fv)a21QJT7};i%oqDr_y`N`usy*^-vYC
zDh8plcQyC^36sfwqXVMYibHWt#D&_3L%v2sy+Gnawy-&3K+Y82wbctd+JU-{mO1gv
zHu!SsW-|=x@GhI`>ogiL&4&7>K9cclc3kUe3kNUpG?b_vP6(Iz@<Q(ZWnI;A*;!TX
zIFHnCx6B7I@IIX5g9X=^Tr{ZpXc*qtV+f;4i)SW{-`1plDqp;bZ|>FHHG`CWA2b^~
zw@V#V;*diVH9Y0llfy^OsXMg9U;8fWs~+c7H?VlNR}e|Tr8+>5s=WV*a!=J+R(rix
zR#a<xU)WQyqe{9BkQ!wRb%u890%w7WFOyPg<}Tc^d-qK4YJArldaGA?VdPWGz}h*-
z-#=ddigF_4UCUj4mR}^!A(oVBY`W=pknX?B7H|NOuwwc$ARDS>`X{N2qeRhN^He9a
z!&C<(W9X#h1JBZXfp^w>EfV|&nr+T>oz~yG_`*CE(K~bUly-2MpVXiVi>TTwmbjOm
zxXX6Q$+e%o+Xdctnhc58AZhhksJZA9PmQ_N{g)Y*wV;RjQCmSfhTwjqe)h-k-_R~k
zDhzc%!8TIm^`bobD9J<Ap~dV1EC0f$HW>EqNHz{XpU{GCGl>nepyzt5G?%fp$2!*%
z)haeuLvKc;y@>zSpvUj=yO;$<2vPiQ5^q4*&O^4l(O;xA#Et*<mbLZZceC?A_^YC!
zULBNQ0UqKWV{RUgJrH?!HX|2B`qh5~#l88F@b!^bw%9uCwKDMMRQGQa+SaA*{`PhA
zcB@`H26OR0gdDdsaHQc#V%kw5DZzxl;$1<0$n>|5LX8u&U4O7$iDU)0gq0hG&Yg;V
zA`nOO@TBc&^qqXjJKn!ifJTE<bx0M#ApaGJ0EDM?#vIL_Di7_s`^UAQTp#KT5`n(D
zWltQVGfOW`6z-75p0c~V(O48TKKK|nPT1}k?6<L&4`Vui$lqhRJiGuj3yb;JiGL%_
z!KjTWl93p(V7*Wt_L|h+TaGLUwX}Et<G(<=o0|}6(OP>g(4hHu<Wbt<mG)Ejj-JhX
zL<!72PX<Lq_>CejX|qc7+ir%S_bpTJ^t?7FzzJlh1Jwu2I^i(|VNsB0e_TEd9*T3E
z#=p6|9_f|vr%0OAqa51!<EdvK6NmYEhnFo(lyop!D9=R|SpZ?k>I51^oczhF;}O_=
z>)X=5Ovyt}@0btT$!-c4mx+gSCoZixCfj$DSN#r8RVA*)B!9ki_&Gg!{mS8bN%95<
zT4b6KAlxU|MG$X%{%`4-XkIX^_4(IcbFqpyf~g@guCXj9|B$-5<nQMx`*|DdCrI+H
z64dbCFk7nVSPyfbXh4^brV&mdz)dava@#STQM8>xBF3Dx+hQI>03RWeYxvkuRnXsc
zOZ$~CYRXK2llp?@59I~>jQ5W2<j<2l&btH9)Fb;78i7}qG*0Id){EUk`jT?^70)EO
ze)a0T7_VZN_uz*Y-5Bc?r{b#i$*4rYG*fK9WyR*2cF6mVi~K=$)yFRWYIc?V_<~Gb
zf^G=`d_}<Bo{Uf;>2-TrN0O0>2%aARNF98AP0meBSJtev?xizQj<@Y^NlXfF+<ajW
zyyWigHh>boNnV}!FGwiDo0-ljq?eQsP?fUJvJya)IF!3&hQjqkJ$1Zpr-4CMMV{?D
zLGFK-aC&EB=%1z76ge1GCHBu#-0u(R#m@R{&OBhv5Bw8NATRcghd%m!Y9`doQuFwx
z<JhFPA?PqbtIIhIxSy5m^F(kHIrY_C@S9Dbijb-m+as_B^=n0IEbAlc;S1yw7vK$~
z;*V#0e#)9+qj*Y#_Wv(CcWc2~`ql)Pkwn`3dk~8C{buQ%_B7D|CAU{}fCEAAhWzj-
z>K8oQ$1Ot3t$|bnACEjIY6G0un|HzK(y5n?HLY~h03^H24F1n8IPW7L1<CVz?NXI_
z2%B~D#atDu!L+5l!Up9^MOFj-+>LSH8n5C5j`|6BTjs0&a~=v+23JepVzpkosn`Y7
zYgnDsf@tu+QsF+19w*th`AMWK!P`&=T}nM#DT%n|#uOc&7Uf&`8ntQ{cel@tI0$`G
zAvTi}s7|?oSg-=;bIOUK1$6JdbyWTqpv;^zh!j7IM_Gs}a?O$|eA3(-YMhI0J1e>l
zQBGWuOIqyZ7sSr4ypMeLPtenGS|#{hhH**lTyPH`Li<(jLClr5_k`ZoKTEB?O)u{&
z3{_mti>t>*bXO<=`b+_p2d~e(vON0+8s^{XDbp4x86=}*(Mf);5M0`yrnt_P^6Sys
z!qITpu#2=FRr)xo`3Z|B)obZ-1AH5LOrzu%g9}@j=k69PQ1=VwEh_o|c^>1!by_a<
z(u4*~P}IRB?6X&1?W5z&1#+x}Pij)5O(4#<e>`qlqfyv$$144sQCOA8_pa6V*7=w4
zaM=nOX@RiTux9%RM$7TV(M3RISU%NMP=sn^eZS)KP4`?KxtAqigSAs>0+pBK-yM<T
ze;iqk0&T;kqJ}Dy*20HSGfTsMxcJSE9fj8sFT^iol|@aO0<lpY>uE~YX5iK8$_jVS
zaf4;0jRo)YHacu&bCuYYIQ-Fki0J8mKNm4^hi`2Am9vJFQqx<9l;*`WT*x8n2@b#R
zrh<z37o}4b_45turfAYLmSn0z$-L2>G2vPY)YhMFY4Vc!+%Y5btntK2BC@p*h=rXg
z`ZI`A+T(SsXHNvtip5ldb>ENGd4sB~QD{smyP%9uMv)n|O!LKMQV<T^?n+$1KDnHf
zi+i7V6`tctB7f_ZoU%Wsv1HcbZSe9UV|M0M<BnD)11CK;jQ~{E3iXC?YUAXSMg?us
zs{Zw7KwWA21*avY-JyUa7aq+luI~1Kjg6|1)Wh&~W~NfaqQ*0b$+$M;b5v1Ic+rEO
zAh@Cx6UjAKr8n)LjmMZF%kq{A)BN*J1Zp9JVr*%lAV8U<3i!@}SN><@?oBgRIx-dM
zu#Pm95E;;Pm6U94ewr&^Nu}7R#>;U|F*geGN)bEp^o4w_MjtP_-&<oCY7|eFi3(2}
zlsKH^@Y^aXUqlD_XgEB%*g<qRm@DcCwJck1b#zb5?Nw`9E=)*@5Ms|caV*cLR14~j
z{x5IDxXi6A%EVvnTlj4Pq$F>*-!IudT=Lijg|S`hE8^_i)Q+_xUdw0S=s1B5yI_Y(
znQ!TWwo>lI>3Tk<@i#l0Vn1LG-zF15<i7T#M+;fb8_~x^VK0iHs5LU@cX7dL;!T9k
z){2adSdFadfv941p}kJMaG0+<A&t*bkAkMJD4dNcb3fC5Uj~u24wd1l5jtQ^qE0eF
zfY4TIR=#dMcN~`JB9g{#)UnviOHuay|H5+#E1aT8pQ&yW!M38SoBoO(ZX@Re+poRb
z3^e@U_9j`dqekFcu(gN#+Z%!pnw-Cdx_xk;dM?=6di7g)h=<3AkAe>$z55nvSk7*Q
zwqfWUL%1e<C^=ZUjZ3n<|GMpr=jX!)?Q5wVR^OT2`UVKpG$S+qQCNN|oE<U6$i$hI
zRL&02<bN!kB#wSS{>QWOXj_*Xl{`R8pi;1Ry@iQT0gR!TY*6(dM3js2LRT{H{g)+9
zp4`pe`zBpUyVHXPV9n}0t2Au=(2zzlF3+1>;o+`4w7_Rk`wFebdO-D1KV^d;WC8`x
zR^v3OAxUKh24C)gu)Pl9HKp`d%iWYmFB`BEb7;v6XN`_{OUi94*eT3Qy+>)LKXILS
zw13)oPF4<g%vDYk5?28xQ@?<4Cf&&gHO$D=FQss$RvW$wi)@!h-}P0K=S$Om&za|f
zxO>5n`erNtC;h@wUY8h=rz3ChY<efb$aQhpgy~kSPlRfX6<5F7f}_;>X_u_lPXCRl
z^cOi9a!$l;I9`Sk58Xtr-me^My>Bh?xUwjP>I%<y<JT8MZB%#Tq-75C(09C>eb=Sx
zK+~e41rt0TG%3v70((wHer=HDrP=EtntA;*pPAEc?-yBuCzXFG=Y7=~uwl2(Y>A2X
zvwgR1)Igq8@8Dyfv4@-i{${Bfn0s1o860c5QM*0B`L##EWsdWQwRD;<VFqY`neQE)
zlPI1Um5h0Phm(Q+;j{piHQqNe5EbXsQ2niSi5Chsh<RF3Y0F${a%arwlYHOa4wps4
z!5mTSXI{sla1Vymo^nA?e%^<b7w>%TyDTuZ64v~%B#qcV9gEqNgj-jlnjX{3O<bdD
z|19*p+n)}Kes;Op4BO>8T5{+~bKfVn27)?i60k01`>SGqN1o{CE?iS0rHNfA9uRu^
z^LO`P$QCH!{NNMS^<MJz&7vPxl#fwyir#*jo>(syK_jIwxVC?uROZ{#wa9y3Lpbo6
z2$fjKm&@=D`tSE&%K~n-iP;p<|B9!ck=BB^3DO&qiHhe56W)Yyv1f9ktZ2lAqus^=
zWlf{1RTO!fyQRD0&)=<Eqd&w>9~WZ({6vUFoL(=q75j!HMAfM!<FZ~aQ1U<tY(GPa
zcYTn)$US*d7!<@852V3z0p0?NKbVdgVDdl5D<%=I994Am*^9+)fu2O>^5uY;JgT(t
z13mH)Rm*0{=dqx4FnB>kOG;8i4WRpQfp25?`mld;{GvA`u=0TC7ff@#I5NvJb1gbt
zm7|2p@s(!|9kNCW(wMvgDbWDD7bT$4UnD}A*aBQRTuL&Ra0^<eE7;>;#BDTyoA0FX
z!KI#r-o}2c(d<Kt`oD1)rQsB4<$QUMcwT=kB}141N`t_MSPT)ALLdm*VB8X7`I&?i
zw;+>e>k6(Tm1hf&Tv*san4yHnQEXg4*T?t*l(7JS+lR8T10X;}0T2hSf{h^nj0Heo
z=mc3Faa9PvlIIYkrZ)>IZG*r=fz%v~cIeztYh8D)1Tk04x~+b=M8WZn=WyGt69wVn
z8Gp+Q*9?pyF1mg1*8>2JDKG|X4^1t-BAX-i-*87$cdccOTAa;;JMZqgwujDt;V*xY
z0%7fsxLDHLGY>=e^V-!@<*o>*%CX_8cjxoTsuS-nJ#6{(A{D|V7@q4XZvd?8{C)VQ
ztlM^^*t}pg;?s+hVQleQcbse{>e7iZWpLe&jkk@CchA{6obT83D!*KMjDfK=Fj<9m
zsc8IgDvWablz&C1Wovn;MA@t0VK7j8G5AZ;cTYO5@^Qt|$Il_&lUGO&3|Jy--(2Nt
z`SaCmEM8sL@+_$MdvF-Ldwzd!=j*2*LaAlZUW>ox&H?oQ6M80;&6rjqR%T;->UZ8z
zU(HP+fhXCwXc-4Ny9+UW@7^tD%ajGzS_61T$M|RF=6!nmEBuy@+G}rz@u%6mGxT)@
z+DDAM|C2$99zw@>)EW+Yxb@*TFsBQCQPx&Uoz55rXg)D??8o;t3E<_W);dK4@8beq
zM!tYSElfbJ+9(<D%<1x|GfM)#*Tmj8eZG;DDTlcJ9=qc0kT$ndsO=CUPm`~%5lYoM
z+V8`JLrXR7fUhSfGx7TeT7I>cZA#ZK>}G_1X=?N}A90~*$@HJxu4ge_0weeJ#*RI)
zZS*m*HGy{f@`o<NteVcPA6>Hr?rye?7MEJvf`WZ&r1L0z_yYA;d$K{CZp=WFWh&9m
zU@?=wq2&x-s~|wv0b<e4Srj<=V6G?Z$Fn`2QVU~N-VR#?{NggNu?L@m+<C-B{?wjl
z-*g?w|F_>Ss#`dLJ^PHU{KtUU?O86r%L)%@|6A?H(4Tjly?_X~z-w23OFjS~ciiHB
zUf-z@J!t&fQ(oVT+bny`Y)VsJ*tb7g(^0$9c=v4x3~gn*3HYKV2BESJn#-v_`yXVX
z_fI|_Q2n+u6I_n5BW|Z!4n|h2RJqx1Y6YG=FA(Fd)xa;#;>X+m*n~t#`j^bQ&1TCN
zNa}Of#Gp_NwuPZAlUAQ=_q}e-R4SI+b=k`D<I?g?A9woM+<3W^)4J6B@b%57slrz+
zq~fWqMMvvzl$BUoyyu;--5lx%TYW<354MNoTMmAX>i;;{8M9RXw>#-_{@;JoK`sA&
z&0YBM@ApEM`r+P6`T4{B_1iap2u4n}%6e;ZSXjyrBK%HZrLD)UWd0tjRrTJC@gjov
zp66kBP%ju~p04R?0bLZH@M$+dtLBOY$@VhFDMvI|vw#y9%zGIGNHj;~^SS$>8;|A4
zpLFdBqitEhL)h28H?W0tF*0P(nWPD9nZ)-cb<s__E6c=yhE3EE!}evL8`{c^-DDR9
zTSK|rhT1HwAQF$<vlJ8cAE(R_G5$kz%!$)n1BgDY9Y*ijTx|U;8i)JOY*+(B<TqM_
zoZ#Fyw;ggo_)(VyKznK8->i6Yk_aNx40c<csdBAOb8N7aA0Xy7Xyse45M{vOdO+YV
zD@rSP;xjc5-qN(A$O3g$3%cusqok-$9%FY%sRxy-ha~X4*@LTY`l2-OV7|$pmP$b-
zJq1Hd6b+f_O5Hv&kLZIREDcQYfiqk1kcy(cRjiI#K?<W$y}fx=HD<r?EIYQUv+tJL
z)kgOC>{a0i*OyAq`4B#n?Kg6eR<e1TtZZc(lW%9*7IOvG9N&m5gT1mUo$Rg%+~RZk
zw#OmC;XF#i_GnSPvqdrdIT<i5$yTJb;V<UU6P1n{Zl84%F{7jSbD-oDjjnizD$JrO
zVT!b<X7xz!$~@H?e1;WSX(FqoDo42wWo3M@sQ;=D%zIZFs=6c%bBFr!z9O@WH+yqM
zj`hGnTO^fDdnyT&F4{}(bppt+Rx#f=$Z)R<xt6Ap#75&$?2(EuLinwu36gDw3=X$@
zGmtf?fi8CaGKVV#a{gS|tC?C#+XKZ20l@s<po38H%qxo(Bxq~UsE4LP8I6(P@fd1u
z+bK+cuPg3LAlV0Tp#T=yhoQ9;Q1B7wK(PXKw(h;w{K@R{UGWnIaRYi-XMSsFcXcb7
z{W=uP8#HmE(+uP+ok`%X#7kp(VFP-Q;R+fLP4sF#XD@qnft}`xP+a>-TMjdJ+lg<I
zFV~$<N1iBQ$x>fDsvgo-f%F&@n_;sT#ECW#&NKJ(aVZ+5;lU>sGteN{XBr#*Wkxmt
zLmKEHbC*TxS$_Ftk3AfEeJoc7844%>LBdGX?3coa6Bfc1UvcN|ZoJZ<QV>1~Q;w+_
z1wJr{ILq79?D769DUs0s7xUA4PL=Lb(dD{rDp*v^bw##Ua6rSN+gl-2$Nz@NY?i)A
zl$wD-FH3~)kEIc?hz!jOs1&%*K--lS23LhC*XJroTmd|rFn*H#5hGeF-D(7}Wl4j$
zpkNe^O|`>M-{{G@Da@e~5UUk@={>6H>u|+&g@Bb5UonAQu&dNrhJy`v6WO#TisAJr
zondpL1%bbceL_;heE0@y?Q_wq);B51R@h*0Zw9rt;7OCUBP!`rQgH8Mt|q8oY~^P-
z3#>AwK+jY@{Whe%R}v>!6cO3b3k(rxC)v7(V-x5=o*AhNrYh>*d*)%onNY9o7X0Qc
z@$6Mu;KSD7u|$1KSzdoehAm9&xfZVvOaZ5LU@0-ty?u=ik^RJj@A{-%R^(UD=f(2*
z&#alwZiMOK|G2&w_+o+66#?lyq-S+=6ua5PUhiq859@Y|U}_icV6L*=FU|Cr1CH(u
zUX9k0^|S^nmb8eiueohtJ$h3_Dgd+xv1R0k4oud<TpByF@7rss_Zvwb<p?fCsM0`F
zDA59e>|@I(_yx;l*7q?+L_mEnZ!1yqe7mB9Yt6Y#&zih_4Q=8Qw)*CqGat;`%-a6(
z+52Hv=WrIenumlX;2;g=fgBM8=)EQPTtguH)5doeL_|Jd?o(iUW(j#N84CoJ3M(tE
z;%20rHWhZYVwl>@%mAz?u`F!)?jV!9wh+2wWTUsnbrWTil=1p`@d?)G4k(OkP)y>g
zvsGYq*gmzGBC)T)Ar#17p)|Q7L?>veR!MUtVvPV-DMV+0u!}v^ARz7@EqRf_`+*jM
z=|^7f#`s&F!}cR9JKf^CF;OmIJUBKA1JT^UYngG5r=0JHP|D74QF(<FvDWbYZmo;D
z>a!Y}8@G`o-om;D$TCL6w{m-?hKmS4rnFozn!t0Yfr#B^`@AKvDF`qZBz<wJMx^tH
z0GCw}rx#Ny%I6ZI=n{(&1D(3WiR17^aYKZH%B5VXx>|4)M>EvCfg_xwoX>QRHvvfn
zJ7mQ^KzZ2*K5#~bcH6kON6+s@A$)@VrUo51u$W~;P*~ouG;bJ%k>xhdKAZ{@a)3^F
z3uoE8P2n9=#yGgF`1`N&f-!L{TKuQLxEDzF&?Cwlg(nz`bhcN#ZqHvzXZIgF=A$1k
z;d~C!$|g(vKZem)Gyb>z=l02n06Keu9%6Njv(t}_iszreB7Gn7ZZSA+jB^YCS<>U#
zf3Z0<g`8N~f)z|oNjB=0w{S`~vJ;7j#$USR?X~tF*FCJi=T`9kLKqwc%LFT4!JG)`
zLVjahbV7-P0N&X#9`iQtGpXnn4cuhEfy^)7+Yi~mt%*HkDv04*^NzU7$m(6V;8m2x
zxtMWm@Dg_`SH)YNy3f1;41czAPY?~k&*I~4)^UL>avs;=-QN<(G~i=vLUITLW~F}R
zdZ?*I-c9dg@Nx59?~+OTWWL(KX@J*Pljo@d(jSn~)uXjerXpH-1XlS%krzJT-8owk
znP#4`SOk;Z>oEZIbn%|Hhjwl8?#qS5#&R#qA|)ZJK`VtI{1KeW242JFx9G+h#WrHk
z|6Y)zz*|^I2KmumUs4Wvgi6ZnQQJns;hOLjd;Mu-k_@4Y%cl%helE5|5rYc-3lu;!
z6RC#01GMDV3zY-FRZbk+{8e5R*|I)s0e1~p!2+x;TGHE|V}#R%CoPNXns3Mg`%<85
zdo*8!JqM&8<$>k62*9FPbT0^#Jv)^nH(Mk)HD-bw)ff+}Sb(K?Uxtjc(`cMDGOYX>
zGHT4R_FZ+qF#YACop0lDvOQ1AMQ@o!&KuVJ8;tW{k(%M{#83R}PsqGpn%Pq0<|_>N
zhGGr2QsjFdd=bKa1<6%G;49tYqTp}f{?s<$I8w0w8t!#^iFF2*bw-ctjA!di{?y?`
z>dlPmN$&MEr=cINv8%bu&L|!ilCFmM;!eReEM6YJ;>~?R7+7b(cbf#R0_Hiph+c2F
zWFlX6r{;7tU#6ot*Gg?zVwp4ic%~t85V)<j7*?Up^EZc&6|bI9%y*|G{PGv<U>YsT
z{dmz)^ohad!=iKUJh<%&3M@myUjQEaTi!~b_^k<r@KC;=W+~5C72w-V@rjKSF<KyG
zg*(OZFcs~R%I&LpMQObL`k(sLMEQ85Tem{*j4fk83`Nf(pWn3PtB(TsS~(vuoU>_&
zS$jk{-Rq{i!2;-x3`mI&Eqi}Sfv@lG+%ha&i|5H>zUIg1YOJ8J0E)wmi@(9?y+GsQ
zth~JuU;AnI1HDFWN3pTtd++%<M#$W-Kc3d;=9ITGQ#9V+jCwdOBqfGBT>uDll?;2S
z{oxCL)t#1gqTg*Qcg~=|@|UE+ErDK6RM$`a{XVv9J<3`Zq8*`{`?F}}u+~L>_Um}A
zo^Bpp7K)cYLBP8KF#(iXv(tIEefAk{rn|fj+9C!$crkuUr>F*v6DDLF+qtN?c*<?!
z3PMB?1*Do6%Oiu9c(v2AekH1J+qCxm>{#a4UZnBvJP`2y1+N%`;ki(!w|soF9ry9j
z7t2Ytk2U!}peu7bKl&*bN(rt$yi+4^A4pYRTTOyP%u7q0#EC6V+ihu2j$2()U1#tz
zHabBX&0-Ev$@lQ*0i56>xoIi=6DRJST<j?SaJ+{Bug^#{$SHEZ-gTk&fh!u}HO787
zP0@eL;CrQdSEz=Xs8q{`<Euzu7s)fF;k7uH1RhZqP)1$9XyLyoR#o{Z+2&65AHGah
z$<w(VM@|O>Gfe0l#eGl<g%!4$MZ$(pH<n#DdOX{vx_x`;$#L=mton!|qVW*&hqtqv
zJ$&pc`sxdqiUkLli*v3UZ9(S|W8xq9B2<`y#uiaXSU}>Du9zutz{HC6NE!FYc=pI8
z^(a*J?1MR?>Fi>B__IoMmCYUss!N7&=U@X?L}&9@fECj#lvKpdOm@0Y9<!JvE|Nn*
zMtu;6zGU2^q};m~WdsZGe%}Q9nn8hZ9|YW&>#7b?TA1!$h4kDMy6?evz7pAL&!5KN
z&~;$CJ{2kJK6Oat9M&xXb;B0{c!WJPnk=}ArpL^k^7kGDQwHVYI^|iYMot{3FOI`_
zg||_7aCk9nZcUsNW#6-3TV^b4V2nJXMY}JkvdF`wNn$E(H~R<%EIJ)q`O>b&^f4JR
zK<9FNCraPpa889W8Qc>KcLCbSlev)>2iHLwBM*{Bj$l3wcohL3SSvt`*y0^tr5Rp&
z**NYEqG2mM(OzW5zl@mvrdM;LXixjJq8<%^%wyMuxT@pzb?!Cic<1M4WGH)TnGfu0
z09w1o-<^R-nB;on-92rLA&(&@u{d{l@^2+JO^XYVi({N;W!AgL7A^@M(s<<StZgiy
z^G-5{V~B|@Ug@vnZ1NM58y=bs<2~K4^B|&!WNk=mcrnX!Y_uli?E~&_Z~<94?jM!*
z2C7J-dGy;w1StqX)<;U4JJJQ<`>Ey~a$e_GC+*Kpdb0r+dNu0w3n1f&aM519S0Y{j
zyj25XwZ^;C9Y;nXWQB@QM(+bIzYlqZ=7#a!y@2XmB&V<Pmhc0mTfD?aQzb-bN<?<t
z<tb9Ctj$0$i>~W$&+jMpey9drIEaY^3lKOQooNky)-wewa_Y=@7CF8O7xr>57JeG~
ze(GGKE&7f)5Uy{X*{K1+on>tm-0Q|Hsm$DQkRy?k1qjdv<!BdtS9P_}i+{XZ-i>lT
z9KJrB(4WCPgZ{b3$VuB<uf>5eaiPLrVqn(xrT?P>VR7_V9|p%2z^H31EZga=<iBJd
z58zmJzUr5Jh8zW^Tf<MnS$}m7yL@+2=D$ySm+c^nbJoX^W2xe0l(TE9VzJR|u$Qmx
zhDruJs(2+9AK?V2Fn|w($NV%c-MRcX1s(SY>5l<SUM)&|R99?LUZ<sV-w<JL!Mzt=
z6?XDIf1kZ?Ur?w3D>a~LpIf%SupIN4&!gLB2jI-a^Su4fD!QEanYScQ&+8-KfTaXr
z{d^^Mc?C@2-UJV7J{PfrUT{-HuFxJ>H{qUWw)GjVeY9T#k=IVv^!qY-E-dpx;^ue1
zj1N{lsrN6Amv9GWOZOM9``j17vHt20*e`=|1!HS;Q04kQV_oAp-x+fH&AZ%D0H<yg
zfy<R^eO@#S@?|?_qb!QI^7V$rb!4M~L)LSVa3p6XeT9}-*J|=L)BdY^Yc<njUWWPA
z?`!}5!i|=5n~i*&c{tj@^Ucd`h*vbSUC8>V$v5ZI)*D#s$s6CCeE)|QB3I8I{fwJ@
zUpe=EE&2QUjqhKce`k=O;R{v2zR85sZoY$Xbnmjc11FD7!ODk_zrMrv?*G{Qh;ymD
z<>8K}_akez-qsMfPR(m(A-Sh%`trDP))=hP;=)#UC&FhNb6yyEd~3vE1!RA_;T^KS
zdu|vN>z1hQWB=rkzA4ArhOfat=Km$9zC!B!;H7%+NWG9OCL>bmY+8RC&z<1^rGt3k
zeJa0uE1kggcdYXl7`9FJdK<`B#)u0|y~0(*F4%{3V`X@-cujuq$V@~o$GMZ8I!8cU
zGS%wA?A(CVjw}x5tC><?vc>Q7`!MylPslIn;`1P&=H_JQ+=xKtkxVF+`&swGe~YlL
zBO2it7lU@eoC145L-c#M+h11CVj%Y3o^|o!)73tU|7kjMGL*5f2XXiVj{1}O370=6
zxDe{@6$RUY^}FNP!tWuONI7@pg}&eDRaGQw?B{+ox8_Ygp8Pw^F@&3P^y9YsFE$Xb
zdH=N*N**L~SF)&zO8Sn!A8^~I2(A9{Y({eN-KQ(IiLR3MH^^_^L}{@YJcDCgU#0%r
zueGXU@m1I(0F=r{lOPa6f>dF@XqL$>ZbHR4ERk{rRL}KQI4oNfh#yZbO<2GAB89#6
zondgUjCJ~9F=aAA_FQVbKcd)22)I!Ov>?=$g}tXuBRN}U5Wv?@$0}^Aqo1ywnsLk?
zKUA%&bpCqg{@G{AY@(gM6?PredmnzQ-w;bDO%EB?D|*f*-R)C4C{gcLQUr2=RDlJ_
z8^AP}@pnl-wKeG@LV`=9CEwS5e__6Vu4vYD$oJlASee^y@Wd_Kn`*XD08s3*G9xx7
z>Z%l*vn)?32?y%}QmNp*cA3>1rk+o7(9)sE>J!VYhYyJ2mwhIid~cn-dgJWh`0w-P
zzyB%AcF$eo_}3<JvvX+O;V*cSlNUHOYj<(NF1IE8rk_@bPybZF&7V)TUx~c_-j<04
z3;8n$9Flpj4AP5*hv7R35NvAL;qai@I0^2JqVfrIqKXcDWPx{UT=Yf*3qA{TV74Mh
z5vE!9UF|O8ajT_d3iR~dojxu+JocycXZjx4s`q9RLX?~5SrtwT2>H36#cjk$T9b>l
zk&;hUXCMZ#s$Gg3ZP;hC&Fu^mt_WMh&-LxEsZ_U&ymuY;nf2!oFK-DMWh;OSW37JX
zusVVcII)6?x%7<sw2q-cYfB!^+x5V@TcLQdF(*mXwx*rGL21lNn*01gjhwU2`<*XF
zVW+w8IC-4!*L@PB$NjnTXU~2Qof|SFFTumg3A{3~Q1Kbd6PF7aOP{deXiMpVb(e&^
zYm-X_#k^A}_1pL(uS$Gwvo&qN40w3<!oxIfTuScvj%Jy~;~)(02|uE!g>B{N$pD+5
z9HNFI!q)k~ojr5MNC3Ag8T+w+sN||e&-6{gb9XsE2}O28|03n+UeqZyRbq_>&qjR_
z{tk&d&*<j@I52&(8<Mw$mg+6giI*@8uE~;n99&muVH9$!Jn(VI?VFiKp-s0N9<xI4
zwhS1B-Fvw9IIQIb`?2uWLAfX4?QblOMLd`ad=l~SQ|7VAN1q!m`RlKHOZR%5u;^3V
za((Mjx0hNLIh=tI5<8v?)8~EqSd!I>3YkQBi#vvjzbXm4uX(2=ue1#%HKXBatD9j_
zZaXlM&ozge(9GkB<NV<JZ1;-)?aTkYi%F@@PA6v>@3FI-hA^&{qA!mhX|?6*UMi#n
zTWu8Tum5-fsgNLl5p6rCIoWnW>@V{{OXDS1=5LA1I|D+`FaJ=|45TR!G3sXknuslr
zr4)+Y!V2rdWl=>`%3l8-hiVfyLl`{H-IO!pipBm)6e8pRZ?H(uS8VbX%ulVaS(hbc
z>@^V4_upcrRH=JcEP`?LT&x`>?}_)G7MQq!$ieAV!FU9w%f))gWGr+kJ~m2wvT7aq
z)DR{ECf_F_(nVi%6Em%X{s+?DaJ9*FYR|AZ8sfcdgf`FNuej=@#nR~gN=df~Z)K?z
zZi=^=_iftj(YWnd-OKNSwS(CSWBFp6%VMbDL9Ae#4vjvT(5Wv%@*YMS>kRuAQ*L$i
zrSq7BQw3^$Xwkw@iPJK@hB^Vrfb1-ufyaZ`qnQZL4EyEJbv4BumL}98ByKsqo<QC>
zUU6WLd!CogHDx)H33Duaq~ou}1akzrF582wvd-rk6ic&5il(t}oVtz7#-?UDi^Je7
z%`}IG_`UBZ*)`eK!ewd!r!<*OEKy`>kvE~9k{|c<_IEXzWB5=;+`i1b$u=kd<q1tX
z-(sDZej`3vZzcaFRl!AMW*7*TPL(zGflKGyvc`}^K^RLQcLC-b0zq7M^D)-afu}>I
ziC*65&to~V5ebkJm#^UVqH{;8zr4!I{eV+n#h8dEQZI8FhDt^VPuBakHAUwIkZ!??
z|5pp@t~Fgp-Fu5EqD>uSsqz$G0ZJj493NSV_(L8e`W1PbY>3y!Y91;z=azJ71dDQT
zKFxyvOiTRcZFVt;P$)(#;LV5m{{CXgX}6V`Tph~tCxE+@C)0?N_*W!JVS`@pIyeVP
zIkw)O=k>w2ixg=W_hfzpy@N2ZzoAw3>RlsWs&ALIoxP(L#M$m*_bV~>AcB`7@@y`*
zw1Rl`p8wUmMN<MyQC8}pl=iZ7m>N5-wb2t`tn#{JIE3Ed($JXy3dwnOPghq5p3jnb
z)2-HG(dcyv{`FHChdV8M&C*}scc=gU;;*5_%_seSj677E>PBB%JvEs=o<gU!gMvS@
zg%C=P9w_+&Rw%NLqay_R^&a0V79<7GlBm6b=JOkifd0wr=I^@RkAz61k2w8R(tXtL
z*_vB4yaf3@Ep@&FY$&5=n<5sK59(^r)L~`M$3au&4`CeV?=$YGurCOKra5e68mBV%
zmxV+t%gsO|PmVX-Z}nr}D*9m^cpL2+r)#H@1TkLQds+V4WI&skJf2$uPURY0pusGq
zGn5)@5ZAl;WGC^NbW8&#<t|&st<?U@d9}QA^bvW;7Kci&AMfRjbWJ*`_A(g)_`7ms
zsW6?41}2gQ<3bDivn0Ii-ZW**%c@+s<d=zwdB4>3z=Cq|gxlwtX@vDeGNYy;%9}?U
zz_9D-n)4Cl9~sWDbt{~i`1rMy|I%#e`CFMMrO!9{=%$a27^@Ah9s783WdGSR;Zp>D
zXN&)}Ad~*_=l{dfz4$ZzzyAY&?O+>*&2bpEIpl2QFz1~xk&q-ILy}XJiXuDN=6tMF
zl2fHpQ7V<n*%F~76+%cQIrUB@`}urtzyIO&dfuMb^}Me8<05Ti;p8|!?m>FKV}h8g
zsDtl9aQhZ~p;H>XBF<AUv#H{$U?n!9t)j-}PkmNe9WBcj<5DX8DHj_`)nA~{Q^70w
zU)R-|n#b=+7ptwLe{IyZ+#>%H?MXY|{oggSS*zCkF&HBPEH9}4{0sWHpI^b2jl(U*
zkFXF9P-$auJg!Bozql}9KOVVZ_x6ct(j9o;eJx9^TM9wP?q?&vwW<Ggof<#(=)sK<
zEqbDBXz=l;pQYy0;HeW5&dF^m<BI~f)G4KB$z3+%OZkG->6^zS>_TI_SP31EZeNig
z4Ya;1f;)Q7v1HO~bg?xB3f3EF=JkeF<#SapNC<@!?@#hjtC$&vuVPKynwa){*Ne_h
z{~|e)x8rLngKeaZL^+Qj5c>PXfJ<7<iQyf6il647STI=-nZT&)hC913N^XvkIXX0`
z?~nA`_pA$QW+nyCXkmrQ<@J2T%pd<q3m<9wj?btDAy4``$AtllS%mFxktnjrd{Ydj
z>BHhMF#CEn2Yr>t!e`PE!q5rSlDCWzLppr|{A#gep-5(WO<(CtMj=^va^S-F-Kv~Q
zfkVZ46CAu~zzNww;bA0<(a<F}FMQH)kRk78D<`VY9j=nxi^~X|fW@<v-c)CAvOKcp
zq-!bsM)EW4P@5elGiCw|5P2zTl2nWgAj({b&Ym5Fee@xV_YM#wzdR`nxJU4QQc!e0
z43~Levjog>HmE4r#+2IjM?l8p5-?Prx5Z9rz=kM1xt0;NNB+$Vf$@Asnkcgt&2OyW
z_kU`aF5xgs;YAgK{UTl=%Wja^4wTk&y=f+g`8k6yx3z5KmnSiHh`=?09``)sH#}yd
z!>ePH|KyPez(B2p@jF_5X`?Gec-ET^)N&X&IHiQ&p`Y`HCJfi9xY7#UzU~s*(fWp1
zluo>1;VIv2A+(D+V>NmQ!0;j#;jWSrT<>S!dO9};oWk+&8xXgI2pKp1vvhPW0dWm8
zXo`<1%$LU63}h?RIPn51<ATofp9>u4y2W0eTo(jnJW3~BC<xP$X)hHxAb6jb^||`|
z#DO!5c4yOtXHPgFJ`Z$WnS>Q#pwy=47mS}~L!EaLg-00j#(SZ;^0~V(y5|vs)Os14
zgYYL4sO;vhudlnVvY#YQqUI*uKYe(@4HY;h+c)Tglh<W7T@{&*I)Ds)6_a_H?8vQ$
zrK2pl#BKI9?vw4M!OwdZv$-@D)D1x$S_9kTxEkRyCKV6|6qMA&X^!xG`uA}culK(F
zV^K}-oxeRj9iCc`ANNl8zFh6?hxQF9_6_Rvy|V0kP463WsGs^;Xc)zNn!|Hl^H?Y}
zaU;UY&LiIPw!br08XiTw4@8M4{I+WiY6KKezsP3?Ho+WYFGkk$e;g57ib~T(Z9vRL
z0?R3rhxpQ5`V}dUJYUBTEXYvvnu5wv>&jm>!G0llpWbmB=gtTwz|k!*$UA}2ULikI
z1!E}4yCM8t*MGQmhwYb#`N>u=+kxeI^t%BL%^=gL$tKAlGYnCtxC%d4gqZmt!QV8$
zNE8tP!f4UT9`LqnusQx1k*wY?;p>gFg>92Jn1)Kn4rE^>36HlFt(6Fmhy)<Vrt|`X
zj~xijpFZ~Q9;?2$f}vk3XB5zJlE#vNk<j}#5yfRdxj5eGi83!?h67QSRv{q~D~*3G
z(ec$gj#%d^ln`4~Wzf74JA@MU1swWf6_ez`!@cGOKm!+_^N75FMJzn=u3}tucjJQ-
z>iYAxLoIeV+ZZ>OHy64id|{GYKXv%df$Rum_Rn=mE~7kzcO_kzu}0+k+6$i&Z|tkb
z+ambP($ZuM-(LnMVTsyyoq9|0O(aewdBA}?*H18k9l3Vd^LM?(IrBW6VO5S5=7vdm
z^zfM7u8Tzvu^z()7yZ7^m8KzhyH*69I=P0qNRwKydGkQKx63P^_R+zCF_0+zIp&)b
z%WD%DW5MSch~y?rOl@oWoIFq8hZp56=dwALC|SI+*`?1?kSSXa93h?9I$CJMxHlZL
zA0=irS^y$wYr&vu9I`cm=fcRAY2fcqDv`FJ8vKzaJh37PGXha}j@4$I$(68iL6Ce9
z$Mnyp&#9Y4^`zS(PX8NB!&L%N{4n;-?*YDebFAtg{1x3x(HT0mx&Hevk7yQdNl!Kb
z0`BQw9Jxs>@UMWU3;FB@zSBd#Uyw^lo&HCIiw?OJZ%8};P=(*tO4W5G&wv$ocI^D>
zhp<JwyU<d^|MtjbOv<UMf@>GF_2gbk;3)Oz(De+|0Y-MnoX7rwY<D5_U{B6ZONnsN
zyVMpa`7VqW(ZyxZzx;lql8v8c$z!$^?6pFa<*GdN%vN80^EYS{T9fyR$vAv&yBN&$
zzgaqL*q~cs7!qn^-S)7&nL7$kF?}4NsIM*qk<6fBoSYtdH@b9Wy}Br$p@ID3y_Z*~
z;e$w($>B06Cs^mww<Dxh;W0Q4ZO{j9P+KPq=$f&6c)I#o`#y*0aV<0~rndi2grK04
zPf(Ip)0F^NaN|~~!PA`JOiOM7<Ufmh&+xCV{*>-FkqWr`j@Pn>jm=LbwO;z}!!K=f
z_mmz@EeQX4;kk~U$`LD!Q^=R!`|KKcQeOgZ5>ehbPKXG8B8mqP_X3Dw#9z)#z}`=|
zov`;Z%tg4epYfwz!sCnZc?-mL(legubq0c$O%deI<WVlxLBS+|<|qDrNBgEizxqNU
z_BGG*&Cu<M(J$y=nWZyMYup-3VU;j{!xLuV%{3F*8W4NZSQ5iHsIij}+6trmH{9M-
zPxR&nHo-I9A8~;Q%4|2c1@?%v4_xU#8<!Qdb-cpJbZ2~n_R&u;%Eg-*1Bd<zyotEG
z-z6`-k+ig>ysK|7EEOPqWk{HUb1mC$1Z19iBl);Y@NVU8PJ`Cw-&ZJtztBcye3#02
z^I$#BnBNk~KQZbbiTc9krHKR@!&y<l*x1)gq=r$aTacXMYb%VNvi)!-gyn#{*@)@n
z4UCn=*_P?5#ExJxN<TL?(Rmn!SmfuLd;506%&{I_yQ4M4DzF28-k8B9xprg-m5LJt
z=33Tr$pAOAJ}lUqYhC(DP%k0dFt*ejRbMcaFZ?1sIhS?CzAP>ySI9e@;!Gp#zo2Ko
z(ka{@#UEdRAFG(f9X76*wJ+-uCc48VJ+CY<zdkMII$^$K6ElL6GhEk<_lMP8SN_(Z
z_wA1Lx4W+28vVcBi;PLQ^>HMWYscW0#D9BqCF`8E(6V6jJTYm>l!&R|x9ow&u$+u3
zf?b<G|NU>B8`}XAFRF#_Gtyw@4cqotkW>I=t3hYpoo%8E!-)sFl;biH+_N}csVweH
z=}V{1@~0DEpQ3PX0WTbYnjpB_iD%M8(}S~d;#`1tPV_Duht>QC4`M-xQM{0WApee1
zK)C;nEkb`oz+U+N^(jJ{$3I+<Woz-Q{shARy5cW=aIn4bM-SY(eqr^NkQTr{d$4$s
zqM#lpG>d|7x@C!(zHBhdbp&3w>xX#O2B?sQ6F3{nmPVvNuKxS<ImmWYjv<Ie3gE|#
zoK6i8I01{ubj0GE^5n3(HA9*~lz?QyV^FUF;xj;hXMAo1p<>UDad(-sOZHRP{fIJW
zj3oRCCSfP{IPP{>?+E4z?ha8pI4E1y?J%mnE}T`9xh*@Of=dg48~c<la6Q~u(9K*z
zj|Avfr(H>9V><ndZ&VkNhxdtn9EHbrRXwcVrvDG#9fde8e?;c3CS)mLi41v!*i3>0
z8>?1@w($EN!eSX#a!+9W@m(KFkH~0U1ns!Ec<XX9&x<F5{v>;8v#+>lttg&2^r5OC
zttEk5sxRSLft?NHwkSA)04H-q>zkx+PN)6$oc4F;?%qQvT7+FlfXs2>HKn?6GkL;0
zr4w_f_kEe(eS0Cr67gnAN1g*SW($&Ao@@*EBLJe5wXXnT<zt0Pg!oXlZO>`U+$Iy5
zeNKRLzVh5bSY&&S#!x+^wKCx%v`pSkWke@;|4M!PEA8{IQ@?(t!`E0UYwRs+9Gf++
z+gfcQ6A0y!yw7MRHi&u0wG7A*d(pA|b!*wTai54@j-Ci22{wn3JmyV6P{K2hU-Du-
zO&;Zcd?R&QOENv`_r-9TRYe0{0i^Iq)6FCl-sN{UJ7efX9{NpI#e<&nBK-IW818tq
zP|6^EAj2BRbw$8bEmPt)em_#(y-a{gZpkeAm~~T5aBCm`_5-1Bnz8{-UV{GY(n6lF
z|Ifpe!qli2M17SXHCYdD|9yNLvBgpO^YDdTnF7Pm55;fuoaZEBM)*vegxLX~%%8IZ
zc_*(8ay<O`KSi(7i6h*4?tui@wGCm<0o&d!nSJ@fZT|!wN{6_$;L*PsPX{=J#ow=+
zz`Ip)k`4u8!)C<KKdVJCvcoF4W+{S`ANklgsgL`fOzg`#nJ&y*f|Dow<$Sn>r97V|
zKJE&v{#Rb34Bx9ZBQf-L`bq8dPygy0xZWM5X_zTqatH~Yx$+G2^C}{H*DkmiPLSj^
zws?3|9s2<YNg!|scWXU@Wd;E;K;98}ssRLInKOrK>Bv#DIXpkNq%A5SxD^>6T-NC+
zG2DG8_RF$vZ>hxrj^)ooAD^YRlk}FA7f{<TkdB_AEA)SCGNc>JG;@{)oYQS%p4;+F
z4b{(Yb(2{897O;K7>G~;H9WtkKJrE0o3H<wj5Zzq{OV@RFVm3InRD)^&ztQWdy;kp
ztohsc<1=wck($8=6|%ezIRyo;J!<az_I8TL!l+whn2Qi;#)s`KoSYrHzWZ+c_diy#
z=c5-UkxH>q)erB+e0+IsZ$wjV+h5qCO5SFM%3hfKyQ%(<w@1`L#ztOr6W7Mr2RlZ`
z{q5Ekr@D*H4mq`0T)P7MTJ$I`{!jWhNTc{yNDVP&WOZ+h0HbdGj6vA}tTKj%96<xr
z5cId1VnGx<@4vx=S1%sN^Hrmp@B+<-m43Tjo{chIfuf&Gq4pVJk*<%emG@Ecgn1zz
zLZNB`X-PjlX)(E-XWZT&e2Xu1QA^P&O8ow*-%3?NK}k*RyLq*zhqdis@dn-Cl?!D5
zQ~+8mC$Xsl{N*XQqGMZVD9j9q<+c082;N1lU{1c0rZ}St90UdEL>957?DQ)+hl>^T
zeHl!I<L|n2gJ!~agx8h7b^g~_Je;BocuItJ2Dn&m^>*l#8OlrnY6@S{eNIcBIUc$6
zMf(U%`GnD}hhL@C_0sxY=OwIcPde@VSu_;m_YCIoDhe@{+<#QzpwAfncfes>o^O2v
zvR>GEM5`SA+jf$!{QZRKqc7L(6-<^!OI|xQ3QGsgN#AvLKK?PQ@S_=*t2=!>v~W_W
z&DZBu?(rS)5vZ{uq0^7h9uDT61{sNrEd|)+cdouV9HEkBaM@Cq(uGuu9)la37?arK
z@w!E?`3r}weO4b*x4yLf*1Waf@$dT90gAMv<)Djtn&m5ZqbHWHx7+`-9P$xF@Q0>+
zf~|)4oYjH7)l4*TjgA>z;(PA<wQe<H(U<sK+wZPpw`)GG8sQf6K%?bD;J1r6RKr%s
zewn=XEG{&B=NV3#5;zmiVqz9K{oX&5AjKaKehPX>5S)E=+_MAspO7E~-7U2LJJeqI
zS<Ev1Gk#Mg>lpqYGU+JLyLQ*d?*Xw~X5kE+-0Q@>6mjfjuJ%^6MaN@H55J5x^c!RK
z%$0mwtoe`pm4U}k(<)BiX1?4GT5}xO(u)g!`ny=Xk{Of@$K??s>z<^zcC5GmT@;u7
z^*VyT{CQQ*Vgpv}F%cnqsO7n?^)lbBAWj>)E&!oLPbBr8pYla(jSN_$%~9IGZ`R(R
z<UyrJOz#xYB7DQMs`<h-@Rrv^fpcjC^^79H&@Wp`(#@BaK02UfTZ2Q{)F9F_^P|CK
z3_OfLePBrhJbEWTT13JAPW})=44~$B3S~m|+YX1V@r<SLd^ez4{dK?;U6X=Lz;V;`
zcS5%okz|0t2Hhi~?l0g9S;Unk<vWX?<hE?i123R?6o=`I;R)IF(rQI(tZ;d}o{^Ab
zVwzn&u7Ue~&lbhSd|h;NwEJ!UOCmH$?F&w)6^@KV(hV0%MQTpASh4>tWAzP2i0-~N
zq~EQgWA_zhO>FMGV6Vy-c3H}8O_+lJ_fI>{2g|VeuQJ~@!PGR22=|&pJAy(8TKoTK
zd4Us}fmDJm$h*_H<!t`WnmfCCC&rB6VA(PhSLI|c+`z}W8(8>Za&|7laT(nkE?+`B
z+oWOEQ9w?wk%<dy%J6eCZ$Ia~9eJogSNk#IzU?UC;zmNZvE7Mmo%55Y7XsSJI=|(P
z`}tuZ*WhC#Dm!*DI!j^(x}AAvEykat%#L8ADBKg8r#aP!;<5YCo!*E;7N5=yTed42
zC;)$y3bXF2U(&)>OMzZe&!ycc{|YN2A4T$1Z4Elq$LnE<^I~qD!PfSPu9UL}=OMM!
zCpVINzsiL=Ov#HFvLA|slmuv~=AnTKt7pdqv4|~fj01k7_gLm^tEr)6^Q<#x&qKEH
zVN%<mTTfG@$HVtCSCbvTCwH(*E1Pc^@iau*hkdhvp(T^ke?OQUws?4b{Ks`annc(F
z%EcMSPkTEmFgTb!^yWMS+ZVSG)9Gdo0u#+%qx7Ti8fk<^H9S5^XIgu!0tu;p#s7wS
zq^_RL&&rzQ@!m|J{xvk+HhC$Sx}d3+`Bo;Ketdt_-OItB!vep{V;nA#k-l(hetOd4
z{Uh(@>2uLu&p@BFR)vH&vn+)^*#)hL$B|A&C+Q*UpESj%qRxG62Ht-C(|Akb)Kaw2
zW{;-zs?5NV+P&DVg#~KM=$~ud@ei$~uk~_bvV<YP6-vZ)d<u8s#UWj3_Rgb-VL1_F
zGU@dn*s>Sx#pNga0uRDJnLCrR+{Qxn#EFtudoqs4^}(!<P^r)Q@cAn(ZoqQDXEx)F
z2F~G@P$4y|aw5F-cS1~O<cq>|gn!G8KI3!ReWXT{Tbd!zNo~D9%AvSO;#bj@x9cpQ
zw4B#f0WbOZ&Vk%?%an}kr6KzsO^#$eOvKrl?yR1vdRq$(c=ePo$^V<lY_6lAFU@_+
zwDEmtJ6eef(-e-Z<7QV*M6i#Ozudli^LyNp#~*B0#BKcYV5`KFk4I;nY#zP7xp4IE
z<FSQPHqD<*ex$s9JpSKPo2M%`f26Ib3w<|V0>IYgQr{(YFXJU!HLOu4<SO*Pz+81T
zHlnzNA{)IZQXcgd6g23dpDprSEuJP8hZ0nB8MJ5lnTVL6>X~5#`GrsC76Zj<jg66R
zdw%OuQ-!Xa>7f+;HhFoLq=Qa*=x?jKK_nB{uS5TcAk=V{hdZXUzGK|AYZ6Op>)I9d
z)P(<=bZ_NBs9Pl4jb7nT8)c-;w;B9(MKWb#5HYxsMGs<I!7}ZA#65*~0&^H4<7^C6
zZJ)q{u2y+FU9lRE|E&;BdUZJ$`6)e^;yEUE2B*YshZ_EFN{)$Y$oI{xQJGlZHvtdJ
zeyz>d^dq=qZ{0DAVNrk9Jy`tqJT&LH22J~XQ<p=0o2<>ehVVwgw#_naeR@k6u3Idy
zn%Y!3kvc1Zw$d0ZNRmOH!Q2Tu6JU2oIZu&hSb*syE+noPmFk$NW&Ux#@=`5e{gZ}v
z1J4|mC}9yArs-?YPOhhtSX6aIHkQQoGe)@AwA#@#wnlW)5jc<<4!pqy%eL7g1r`Z(
zbxWFGBX?ct(zk*(=MG5gc6vfRq+1_nD{{#|(qYOFYDq`yLFmIM`b=R6P#WTd<hTz_
zkjb4+WL(Sur@E%2c$$`*Am*t}chnZ};Ioj)G`hlUyF$@~Q$Rauo%SP<u0(F%?!ZMH
z?qBMIv>@r4bQdC$uGUL4Iybf#A$bkTGDm1IkYE#ls%1&rI?$>#0k-J?|4pG9_quQ1
z!fcQ<bx->5bCr8Y96v-Gl}Oi~Yct1iO$RuUo>1I8*eaH0p2OLcIM<)=!x=LObzl>^
zJ7$1t41@x8ZH6pY-H<T7_%PjpHZ4EUreR~vXs?Orz)!T9V`+8)!P|!15Rr5(hJ--@
z)NifbZcc+?`N`QK9Kdlb)+Vgh+F{3_7}Sf7T;{jcP2!ua>{+feLB}EKmdQJJuXpWT
ze@+e(2Y*t!=&IQ66w7@KWm)UDKc-XBsSIOFNK7k41G(9wrP1d@oDz^gLThD2hm-fd
zo%7VgW#yNE&d(B)P9(neXvgllPtH+PAc~TCPDnQmaq;S~ou(0uA*3%8N-TU#uI4s!
z8z+P2mfEVkz$If`H(LvNEZ&ZBx_2bcDq+$MXyZ8IZNK&{DY^M2v=fBS4e1g+lrR8G
z^Xnx9C1m|g(Q=C95fR<zk$mTAFc7s32%t&BSQr>t+cn~hA|#5`POfPuBDf6+?VE@o
z97fwR0Jcq5FgPaBW7Sr)M$-n!w(Ah%f&G4T8ZgavE`hj^Xnu>A_iczFp|Vh0q}x^o
z?cer}J%4ES7#a~O_?HXCT0*R9$DAu5xCEYJg5G9@jluCPdGvT!m!w#_&8ccPMth%z
zr(fju@4@A^mqUm+z9OsD4hq=tKw+bjK{{pso`>$SAcR?Ru}PhqpWkj6S20x>j-#TZ
z*y*EQfZzDsLl5NzY=9k21du28L|{jQ9GXBCSkKoDAf3@N=lU%GgXR>Av&VHg#Dae1
zZu4J&oRa04Pjg*hWZMb41K^^MWdi!+PEoWA`UqhblrTDNowH?Ttm9A-9XARUv3aRa
z=UlxZJ5SNGry=Kzw+sVhr5cI`hO>n?YXxg5CW&Dovs{f5w%T%8erc!A5VJ9rm)gUo
zuF-x-a-HWp>=~W<IWDI3PQsZ>HyADsqat!M+`+h;JfUk7)UD6R&`#awN)O)e(Cvuj
z)a4l1Y$C)sj>%g4#aOO$qk%SOmL6N_90k)InkDOVos*`?eq(QPJ5*RyV<e=Zm*y)=
zKNHmcG83xH=+t7-YxAOA6%SZ#>(p7(AC4V2_SXSAz+T4ST5t<~GxWNna~AZ%k<W9Y
z(trfY?s-trM!VW6gk^82@f45Z7vePEibu3NPD6P?Z1rKP>--j1hLI}0oOoWr3*a;b
zv^kB^^w!(AuDO|ubabM=IVXs}(J?d+*$$7FGn9m&h%4h{VY%#?4yB>C?Ve1)Z_FvE
zy*(2uISa`?25mE}b2HwrasrASrQdG5J|x_~$9tbs07bWH8&Jc|<Wc?n!2Kx#ap8VO
z*^JtGp>rwXtP~As;X1c)G|rc^2QE98RtD&B{HCeE2<32c4|!G7CX~L3t^6G`NOhIa
zAHi$-U3RXc&RmAruF*76H=QwYyA7{LZE%l8(=qf6@cZ$Yaws~v-MNL<*oY{uzvS-6
zxpo3N8p0ht2EB2LXZ7@Ym+SU65X%~QSrH4~zfOA{Jm<`qIyUQ0V}QceId@Od&8H!K
zh8@oJAI<b*fK;)_h!g_wXiiaF>Y30eOR1lDjtzTeKu_Qz<)Wz=^m&Y~hf&kX=~Qu0
z)6fCO9AtmpfP9lT;d^!PWv{vpfWqn~$+eU#wH+3W13&@DalYNQ>6$yh$vMVb^}YS`
z7&Om6)-9CkwL14PQU<7Ry=U#N<REn~s?|0ic>Iw>VDC0;=}nEmFV6Jt!)xt_6Rw^8
zLo*g-=`k{n4PV|f!uDIgg4OBH=2MQsT1dzaO@_-|sUQP8PWUwKwM2^@L&8C^RjKx)
zbA1o^FAZ{h(V4zTj-4Ed>`<m>NbRMN7@e2PJCx{G8gSSAn#<i&TREzA#q$Y_`R^TG
z*Bj1=&4xy(#11xnl^wZ2Gp_F@>p*~j*4YK_(o+d_9omWykFx<GuuNwbAbn~vv&yZ-
z#xWaww%SnJy{h)1U7C)yl#Yh)PQ6pgD3Jr1gU3dmo5P?hXvtF)^ibxp6Xj|^%ZZXu
zpYvCgWO;DCSYUd|c|K9=_VCRo5oSpp=Ckek>mZvt|CUp9Vly@K6npmqcR8Boh2h{Z
zo2$kaa$Me4TvuE?)W~SksQV7i+Z|mCQmt*Rbl|F$faVVJaK@N>xTV*l!McAxk^|b`
zUIvvVELPXFTSRx}thL)mwV!=2*qQp7+%)fQiUoRO`{dnr_d+ytGS0PK9ZM6B=^cRD
z&zCzV<fzpKy9#3svLs9yo%RSik&)4Rl;ejyU{<@|(M_T|CsO)AN11H51HJuV7VkY%
z-@1k7SHQjS=whIMBZIDO?;Y-%+<4&06@%2IeX)z=0t)00#AEB$*Ylb&eOz-t1E7&D
z^(jV8zsw)8G8O!JI*nd4`dqn}=H$m#tkX12GDS1nar2p9GG06IASb+dO5QIVqi9$%
zI83CaZV9pXggO+&1M8H`3?nKQ64o4)JrBvQqIijd{6BU0AOE>qj!v3~JUL816dI*f
zM|G;tV$hex(_HhCTIV|vUa0>Vq6nuTch~ym?bi3t60O4;Khgcf?1R3wo^E|AII13r
zs?~Amp$OFKU>qC;!lOK`A9S4k%28`%E0##yoler=-Iz5&s{0unTeEg=q{QFg706e*
z*Hd(&z*^6ac@RVWytxz+9b0<ExgKJC%KF&r73W6Iw$adStL`saC=s%{)&cvrCAV1{
zk2r10Q3oEJ{4gJJg%?*1?atcTSwJyc>~s!o_aLp1>NtlVJvf<;IG+A%dINWG<iT?m
zMY{#8*W97A%88UFWx!e3Rd(2=j<rFXn|@7#bdpfeB+Mseo^8s!M9R9_ly#ewt>XUr
z{GpO@vpPkMLD2DRaW8&ekOyx$#iPb}gVTR>Z$)wqpyD-8fY}=$^o%WU!T)Y5o5+>!
zTe-IN(>?z3^%+vE<o4bly$SQ4Ll0UKAIfxXE0Ny*(cmL-owNMBI=c6WZcdw7P{z5Y
zj3$xi-Q-^$(1p#+4%fMqbCB(-Cmx<w=?(}0S(Bgt%(&EB@X&K8*`4&~k{Bs@K9q9<
zhK@h%6q>zT47tVU=?zddf<Oc;*IJR*zM8`MoAe^-xpzDL;>XbIM>=j~C)TX=u4r(u
z`WY8*b*Wi=rzcbW3Vyhy8kiVwrReCE8a4IACVMu0OzoHI$oZW=f8yr1ob4m$(;TkE
z#4bAmJy!EHr`kWRsluC^4i}7-3p4$E)b{3!&WpFjC+}(XrPdy?XmY(B&Qrv4{pKz+
z9JV=GepL25aHTloX7gIF!{cB~YO~7rxVw~HQQ#dXP~Yy`<}lhFCZIM6o{XHIPKXzJ
z;`UDVgL2{D7mX)^Nx$2qWd^tFMZG751U*b}XrKI@{ZDoN#9Di@#os#plRa~(!NQat
z6`5i;hv#oQ9Uinr#WXXJ5r878_QXJOI{eaWWclmPA^5)m)^Dq6-u2neC$E2<?|5*@
zTPyuYR-pcgKHPeLwd3%X?f4yr>33mQ+8;A&4gk$<l;j>gBU{J!InQ59^gMXdKTS0o
z0HGB@n)N--6OJ*XCv%Qu{*#1Y8Y#x3FYO9ik9LTY8{2bcKlB8ZRZhVBhCkDsR>L>>
z++SB<4-Snpa*nzdY?MU^9^E~8efK|y@sv4u?o+vL$GNhY^&<{LzZfI)WO{}*z=`Y5
zYI~5gd?PL3u-oQADYB&E2GTZ@6-*mJ>ZSJ&E~c)gr+20vROCAU{)J?pb^h}WnR?av
z?*~sTlvDWN*?Pb8zqil+eRSUV{A}Zgv-p=Y8Hyqmgi^S0w4Ps60h1<>!@HJ{3d3Bo
zd;!IVrow8PO&;o~qHWQ1t4aJ<KLb^qmo{VXeNq<Gtx7vQ)BjGA<m<~9%ADCSCA*R+
zpK1+-;Kz~M4+2-p5#Y_I_u+d7Fxf>7%AsNu`r1wqkn!`!n9p6^u>rNuKQ1|^PySbc
z99EXEy5B~SXS!K`4oW}zqg=_MG=bSJurK=a;K#nFn{1VgF_^p!_gpRW6>`ErdnSi`
zaE2==U2O}@R<ABUa3I3Ci@i)drP~nn^r&sHm}~MlX|t8fhF@yRiX$?+az7z)r$uLy
zV*l-t^stoOyS?`rIQQr6iwPh9zcID-exs{vv^sqIUJv;fBtr4dC(i#ZJo)_g*(I^h
zPVv+^Wc72{axbQ9`L~-?^;A@yLO;K1|E1(VE8BBB&#Pt@K<_mXD6|tF7B9&<*9~+i
z_;~u@r)ELf582JzcsHT{9=7S*j);3YZhQ%aP895`f2dbV6YAFrU5>eTl?FwzYjCs#
z+pf~2HQ$DMrxA<&HP##F+$xT(7jkg~HS<}u_%qi!-Pzd83}qXdp-A55OKR~MlEnKe
z&-jvS(5>vIRSSUF+4yRJhW@#|Aq|yDlSV*V^mC4GsCFxMZD6JHI!W3@LncOhPUZCS
zbQkUr><;1l5DIHDSlxuV+CXxBRCO*4`gKOtgzkc}l9IRsyO(NVtY5|ym{<cAFPT5J
z_A4uj{DU9^r{C^w==0xOAykMmKcr@G*cLc*P#Wd&{tk!oEkp;Q$bOY_`Sb^Cg<4_Q
zpsFh-X~TRMj`=>iyEHUU{5}3d#X{T-mFm%^&zFuSfm|?g-bzslOn&C)OZ$<565%=7
z2ft}W-<!B%5}uGExalGr|8C~2y;SE1ZwRR?#0@Okl(sF=jI1a@H1QI=K`knKVVI&_
zN9@^bf$V}tcXa`>bt8pcjUXCMlAV#FW57RXtd^J=UDFVx{68p4*-)=F;VCMrq>F?8
zKPal}+mqi5_J&47744`Uh8u1kmipMMQiOq<K895Z>u%lM@SabXfWS#~bo$hLJ=XDC
zGPv0E(@USrEn#XmjGx*3xqLH*VIn1ae-`a}m+L=6!uyW|3UW8)W21aap|i5aaN!Q8
z4<JV)&grrzV$j67Al-v>)h-=2w4j&tJqPE3{R^3+fY;oLjGF5tqQaN2HI=2uYU*3=
zKAj)+IQ5p#+qwg(oq9#wI!YanM4&8*Ae8^6jG(`(Pst=zWInx9eXYV!Yd4~sT%mmj
z2qH$!pU--1Du8o_@W2K}Leo?rsi|AN4}_rY9oUKrO8Cr{z1Hz<^?)+LZz^D*0j45F
z$j!w=QL9lohf`<Ir1QeDo)H9_!vQn{FSI%ME7El{f-zl@f*Ee%tK1ySgEArN($eR-
zI9(KdUK>c3B5U^?7j9NJilx`uAAoW2uJtfnbVWC>wiIPCpsh6n5SWH{k=hG152%k=
z{R0v#fIhu}(_7h%Ge7ry9B9cG59|eWFs!a%_F-z~=yb9oU>zi@24!AwevcEpa0xeL
zCVO25S7h8zSd<zMeeu=Owji|Lg~tJ%Cr^daV-<Cd!$1(*_f^^4b?_k_<g8VLf#O~$
zP1f*TyX|3RX?74AIM-5gm3QY_8b*6F>6?cKFFgh#qO|TISV~>;tSD%x^vW9ie<pb%
zPGk<Mc;)0e2#;?xyZ{>L3Y+-im8^V3|Nnvz6LwH7UDYHcC#-rZ_}3&R)UwaP@j7aV
zVd#WhHoIF>dDDwBzFTQ^?;yRtRry3Omkp}u8mfl?Nn=}2Q!3w3#I;KBWFgXSX`t71
z!~(@WU5^A|Twwpq<?w3A3o*>=q9((V2+KFZ4kTeGeveaKR*nW_i6`0wqwZsWTseBr
zh?+B5mx9sW*?Z)bqsUru$N&n&>l<+HSMsBRnW~aK0_&*>L{~)~qKz@&)I2EIHO~zh
z8Rg$K{jjGJ8>TKx^LB{vFNj>*rV1Gx*}unS_rt>K^wOqpaf#|IGb~skZ;hr{E#LDo
z0VJ0!yg>P%b-o$m9aTY7KfJfpM1+@P3ER!x+hBBz&7-lO3&&g4LzeQ+HqTi7NEy5k
z^7Gc&C*P0$I60}l@Au2IPk-L~k+yVU-@pH5H2nOL4#J8<L2{)n64s0C$q%O4^&oix
zran6;qF|m8z_F(;X2@`bX7MCoA6DYvTs@O`YVf?mWMJ~mCiz+OejM0Nl=VcwRK1iz
zQd?ENCwo^|uH2C;6(aolRK3+Vk1lf3yt-S~cUtac>2sGoL&Q^wSpB<5^F%4Wwhnu%
z8}@jaOSovg*~2R-uOrLARK$|?owc++*XPXiDfFnuzR>AtlX>SAkf=VSTMTVGdW>;N
zFd9k8pLPaChxkY<Y+2T*LEpph6p=p2I7Ikm2|Kz;i4XD^@ajO=6;Hn&2N%T6Jvvb#
zvUYO0V_xBUUEE_w-J(+wc8ml4mnG?;-4A8b#f;2rEBcD)8geej?_dziw4gjOnC7f-
z?y%G?VpX=|%fM&n-z)g!kmWmM+{h=1$0S+WEo6Rzn}?L8lE^C1wm(s}I`tdL)vOB*
z{JHjSsNDKqZMUbQ`R)rJDfo=dBcLFn!}j|4vS0zI`1WECL3?BkejS*oNe|VorlStn
zcSuY|<x4-WD66l%8dsA4>%ug_fQk-F5pGXN(DJ@vaRX+Nz$Q6pJu3Aw`>!w$P-IT5
z6dV8s6!O2+Cx5;aBAXNJ>Ef%d`$hNoA6LNf!l}d$#&#P5{4H+@qxD$3N8?>Z2bbz+
z=7MIy?9R_uwl3#6+t>O9{pZuNob+%vRQv^Ks&Mu*!91SlqFik5wP*V@22NMouSl{;
zaKiRv&#Pac*X#!`k3`=cJ-KjNy!DR8sr*7^SJy|j|G|&OA$#IJTW7RMSLpMWw2yoc
zor_KLag9%T=S-J6IMVIZdvUVM`27zis5x7A=pxO(F5;}hpX=yX4zZ?B^m8x$Tal^C
z-Y0aIN*?&_9LdGpXy>4~b58g?^%E+EA-K3PPn@P9DzxjVo9N1;k0YAQ!rhoZKea^6
zl}d9qIb6CXb7wScD#b1~qO`jlIeQa9&;&<~=a}~Se&4Do8rM0bAKJSy{{w@8*ezFL
z!afrb%+1FbEo*$hIvzuaQc5uJ6$iQDn((L%NSXf*{M2p!=#QT)@Jr+RjkXq)btM{%
z-^qY{kq0kBImoZ%hVeuA5;OR@ddZ86l9j~G0BWgg^-?z%H@E+!?<Gh-te1YWDBVg#
zb|xU7*CYEDk%I#pJr%Mnqer)DE%k5Xrv{ev5(rZT2=ytM*Ne}97KQOjlXbRw{8fD+
z*;XDuz-jxpX1u`Q{wtCjNUnixq4wA0e%I+0=_ktlk_KMh!o6=@3_WxLOjcbsL4V5=
z%@z>L%<!71H=1UIxtlNM<8X#V!)PCcr595AI#>i=HqZzduF)U3YBEcaDw5Hky8Ven
zZ9;L;ssz=m5H&nOK`cR4bG-H4v`{s%;b|175K5>9193TRrl#LeE-#hv1=_19b6<10
z4~dfEI*m9q*ii=WAFKXd8fa`0mb4oEF$IW|nDjP`MHGh6ARjd;cO5`;nCdmH%3Tt8
zr6Rn>E9ES@VNC@(iLxz;t(*{vj%rmDbr~V?%666iEKLn9(DqJdC8aU8uD;KuB4E2L
zbakof-5uy+xh-<krjQPptt@(J@QI$bntTUl4k(+zBa0GruCsjW@wdkD^8I)%PGyk1
z4xk@laediPorcSk1DaYQ5a7F;p4SM1{%Ag6eMV`w$(xA6H(}<TCH*Ga`;|W~YwCjK
z4kl`dRXJudRI|@Mc;JZsyBNbo)>YFj2h=F~N2)HbGnMit5B~vND<tjCS626g8Hy@-
zRjymxsZuxtja7*<&&x6xhWagY)cdykbqyosH`VUaM4=YOgx<E0ozF{rY%bi<-FF8!
z*N;zrh2toYG*(7R28m-aWbXm<|5|Y#OIwoI<|7s85m9;9H7rJ36YCl23ej#<Aj^UP
zD#fy`ZKjM84B#vb^(??GD7$La<sFWFb>qFgAzhi{{DrMvg=Gc(AzzC$zirh}r8*bK
zDoILHq}$9WCX$mrwjVqU<tH^ULX-a}8PLPJ5i^`yEKM+OyvyBx9drQ9k_S&Di)*O#
z2e}CSNv(lOh67yl&kkHdhI$q~pRvtQgroEdbuXKIFH5B4es?Q2*LOaocfrK{_zKCu
zQ!mECR<+G-kI%LYOWOWocYI@W7E5Ni)!fP0NWIuj4MKph!vCxE1}Y3)5<h2=gPSb0
z%0blkion1YpnfNA<hAv?S*?z%O5jkfs2Qh!rl!R|luzz(mbmvtzkhDnlcGW;?#TU(
z@X*wL^FpWBSFRCsH|dGU1;=PLN@BB{Ds615y7JhHuAp5TtusR4e9h)M)QVOT$mVjJ
zta2VMHqwtGnX%rgCM18ZYqdU`i~eZ3r6KWWwD(5XqFZrnK;<gFzR+5{Lfyh#`ImKX
zoBPq7&pf2!xf(SzoWqv0!m0XDQ?1P;?8f5!ygcW@qgu!KWIG5N+dczs@rP7|S%B5l
z!tKN$v?X}?OaVn&M|s5;Jh-$2r5I}P)8|RIvo1AsWv4HEn4;ppw_O^*Le#4o;@3ek
zd;)TmfGuH0oSm$g-Q0k1Id5s|vj69ntJE{#is~R?2-(jNjOPx3LO$r~=I_!qX^`K)
ztQ%*+*ek#1?i<qS)u^;HKZVxMsj>%84~HFjvCpAW>N*SM&=|u3D_|gW2d)yPTK-J6
z;YpC`$Hv%(wypPDXrDpyNH(^tICoe{9R*c(lJQY}V*;`KA_fn4E-FWj51O8?k6OK>
zWObTZ{W_uAC2?P!?B(HRV&&CY=24_T-=gDSP{hu4=7~TnAo8?z_|GHlZEd|#xDovA
zb*9rXy2%P2Ih<$1PGY1jTW{%gt294`p0ZMDQ#-m_^4jXQ{VK;Qhqr0%ZVsb(19{5J
z@w(R!tNMNqusg#2dhjEWfW4v;BH1C8^jQ-pEiVr}YNs8KAj&V@C-drk|H_|S@h8iu
zkk9_|*0Q8%C4}|cXi8d!^}h|>De0SS^F&0Rd0%^dBA#?RQ67YQc*Y1HTWJn!_?P-C
z&;-m;r*cl$liUf`9$@a@U(&k%xS?>ZQ%g?}{u(kzx#Gtt&e=-Uq&}??5O&goYXjzQ
zZ<5w{kZNkAVYvP2)B{3vGXKE<Y&%{hq!Mj6Ajn-47LqbgCug2(%DlLiSxL&eoSc;o
z0fsUR<gTELT61fgvirfn9N9{Ofc3;j8&w^EhFv-ZLiZ-)C-CBCQeHm?Rd5_PcT_(i
z2j^dzt3dUS@W=z%>fa*!&$Y_m!l99T*(}Z&m@MzmifQI)MkeXJszAex3e0V{$XA+F
zP;tW%Dp}y&1!vELai}#?vClhwYB*hohMRNKAGsORs|O(1ZjCKyeye&OUO`O}9gSDb
z!ec_&MPv)*XpnN#T5c2@bshKWJ_RG*W_<ecZyYeI$;j|}ll6kL37@<)2|8{Y>wfRm
zEkqp%dQezn!8nefzRhD=RJOmpVp}d9rWisa<3Lt<QfKa2oHhQY#RD1Dk#}V?Rpun}
z&TtFIWXAtf#c^#lhr4i5@#b}4+VsOJ2un8PfV8j$H38ZTj@M7fFxFqys+sgTL-W|6
z1h=-BbCfXs-y{0t4JE72Nl_=)Cmn??lO$2q)rV36jO_PJbA^bPtMB+`2Q;yh`}W3Y
z0c_+@1#&7*qpdA+7WC-8>$tB0t7Jb88?O~|FK~G>KgI5JD_=9}s_Ka@tyFNn1XvEm
zK0nH_0xFE3X0ex<l)S6+V%bC9U=QI?3a&XXw#}=tEAV{ggdCK;d;W_SYjI219`b+j
z%(@oy<;qM^Yi1i8A!6m)`QU2YV=hirN`n^>gf*#?b=g4K%gGWg&V}F`833@$5Vl8M
z2k<fj-m|DIgIq!Fm4B^{5}b9f4^_AIfIGLVl>bzzha1(9&o8j6N<T|ux!i4CryaMk
zTu(+I!WI`}n?SZQ1&ok;7D?nl+$%s<zV*h&%@Pf+2EevhoWM9;ySdS-F!1B>%M=_>
zq$b>wM9s(XK0G#8jh4#XhFMAT;EaVDQEp8Z02A%?eI6taoZY*7x0qTXwv9V!dl-99
z{a5)|Vl?|-2~IqWmlN(b9g-q<F;ztBfG3FV5vAT?4O}M&Ls;qn)3oDJPzCMci-+;B
zDd#Gi4v4L+Y^(be>mIx6KlxVKptT`Ui|i}1b{k&HG*i^D?%fuuZcIrRvXn=_C3jPM
zZ$f295SopZ5egmZjpusDnw_7Lt)BI$oBr<mUgit{vhR7y<Vn`TdOyf<Kq75G^2vbA
zzX7!4;N^2NQ=vuDoA)jUpFd>z<rMF@>j+%%bI4sy=2C)3?rSB-EzMwL9?0`OM}yNK
zWoZ)1XRh$T3afmBcwNOtSDg)Ycl9iU-`M*5$~P(v{e-FGE>s)Zzbyb+mhS+hxyC*9
z#fgty*6$VVX`{%{tJ=j17ivO{q^90&k3Xed6}F{~oSmkdg&SX|sEn|XYIw~0sNzVQ
z+7wR4@8}Z&Sftykn8el?3A=AIHGIzM!stJ(iQsX^)1p(y)EY_%xWv)j-~-VMoe}#r
z&Ui=-glqMH-a{rdiPebvY;*D;p>FKeZFecc_+r@Hlyh+3iBF2E<vQNFnpsUZKZG3+
z;$)g@O!N))NoU-8yR;^16~aJrK|GX$ylc<2=PRiEqlE`)5tt_Sn3YCk@~+@G&56U~
zgy;vuLXG50yN(y$)H7<Bx%i5f4l=UXFE39=5eZ}RJbFeLbKwNe75`o4t5z60MV!~#
z1D{fv9==CxpUk1${#0qvAo*QPLH)NQUflZKhI7bd*Qn9YQ`*i$qsKpv?pE#$(J|El
z^q7jb@LF?hwPC2lKZ*>{g2sq0{=n!TJN52yhwJ++WddS%M-vkagpFr}of+R-%T~ig
z-LT4By{7Rq=8B2`#}O6HD75*W(;xM=YUzX7xuFR-lp(-j=Vnbv>+e@@W0^m-(^q!=
z1euUpj@AmihDb714luDudQ)+Py_A!8WrHaXrCMEeF1>YWGwTj$`uG<_V70KJ(rOMu
z;^u}skfoy-5HZ;fAhoxlo9gkd*$Vb2))5vpqCy>y^A4F7mwQed@6r4t{=C`C3_L7b
zDLs+Dy*^zk`*|Y`7FmBrQUGH_nrM0+Vk+K|CTE8>0Pi<FeT9jS4$J@$szEJuum4`i
z5ebHy<;}n%`+pLp=jCb#?nyiYFG~G~8y6gVB0DclG8=2<Nvk{MkQ%1)Q<ndI*exAi
zQ<oPe8LP9R!lLEvRb9~azT$asH*^~%CS{@l7`1TvutjaJPA;ha%`J<9*vFmCJG%~#
zGAbfpiXGJNk9b$LW=R?uek?^lY#$%GvG-Y?<H_e0o9g)J=HRKB2lRC?-eMc>cbn_(
zqk$!S9P6qNT&+6#EaP$lks0`@svzK(OvF38_Zm?Jx<tu{5TLrHQ5?cd9(%K!a$M3C
z6}s$`T**hALWBtkd59v#)pc6G3phBj-?<SBz7Q@T`XOW4smd*mua*2dw*QpC!5!;#
zy9*TA#@Z3U6{t5aZYNXmO}tJRTziKYOYqJWj|xkZ`YEe3<d@g<wP-ubGb7JOhdl7~
zOb(4ecoi@}J3M>zlU!`Y&EXkL+HWr2bs9>{A@3{u<iAUmEkVXo-@{le49I)p{F6b0
zfs3H&hX*cYpqY~)%W3-y1V@9T4qm^0tLHj{=b-F`aj6IG0G3#2vT44q0$GVR15wNS
zo#Xz&>i)){8|g2iL&l}O<h45n2%rebuMpEUM+)8FiLWywH6&QKEhLQaZm*Q+oBjM-
z_8N~B2Z!UDmtRVUq5CEjci6}Od!0!>SOM8-_k$?xVx}JxMgzB-tWXZ4>(#mBW+}z~
z%=k&rb(V(zHnU){1!-}QgnAeAIfhVn_PJ7+;z+Q@Gvtw8otTDR@+Jw(1mbg6Fgs>C
zjt4|6CcDpC{DKz9*(4$E<~M+_clrj+yA-m{y;^@QeYg&qkk?BG)o-OZ7rO@}MXFEh
zmUbMjF&zwfCUbmLd(6cZ$ipnVTuUTR39&eikDHpQdSeDQ1(1ioE9Mv;52VkJ*&Ncl
zeedw6GyC#VX3rmbnew?jUG~IWRle7WFIO(*iBEjJe*5K#Z?~Swo}9na?{)I~{f~Jk
z7ask1dGg0ov25yMo7|4nr7o@f)a4$t9RX@dQS4*tY@>3FY7&s<+xDp1=XhYkVqd3H
zYWV5dUwJ%dr<JcBrkyH1b=rY;#fV0s)%Vq$mxlhO29qj}M-{YBBtUF*nIFD4;*iOt
zNR7^lad#f5j85v(kK#-?tKnPIy%W-~>wefr{sp@b5!~ylSY}PAdLvo~^S7eQjlTb}
zQILtAWexwT-?CIG3M@x-&pj3}*T$V5(6XOr!t(>}AI|BN2~D7zZQu$RSZ&l^1Xr&_
z9%xmKM1v*ag!?D~;FpW*S`)msYb*O8c8t;*Nr0$po{>Y}s*$f}bJaq(K7*WI%8{u2
z<UB8Q(~<HuDG*7SI$0neAUTP=!3=VJNkRCUc9`a1$am3X{&7oP;J)xVDL@`k8e54V
zvTKg%xVv+Cue7R-XK?$T7ezjSoY2I30Phn@gAqDt#2(>}`pGg5hJblH;A)0iD)Ve1
zpj-mzW=$X&H`)JBnX@woeuAtYAp!Lgu)2L6RQ5M15SUQu;y?*1Z(I20Wb{=w@@{Fj
z4nr>*|B{U*C>KkTwWG}u2AC?$dz7maeA$Cn@Vab{cbVohbtW`<MhZ$7YA>T%iO?+K
zG--}JMMN^|+QnLX(R?Bwjm?^`!L^N`Z8w&r4-6#ifZ%C%kzeyqrpe0NDGIm#`IJw+
zUL*BV-w!x7hy*gfsMNP!JNO<vbViD&v9UI|7pGScxAqCMzh=^59p+nDG*q)?`@!2;
zhGjKQNjJ3*LR|4oshBlw&9}rDV5&YRX3hYZAAy9`RnTvCP^H$3p{|>GOzb*6;Npa&
zy+25rWgCT?5e_;ppU)5c*`r=>z&9PiD?E;0P|7pFME+Na>^6Q*ywB>h;}uE<@wm*~
zvF>nfqvF-F87(Jdi+K_MX8Ft~wSj`?Pmo4Ilcr~G_PR*olEZME^>&3n^K$p+SQwyU
zQV%RP=*G9af(3R|#ViRWOkS#QF&Vn95mCQQwcNskz1X`sHo7zXazs|?Iu*xE@I=}F
zk}eIJl>V~}!-U@X*d}T<Uu0Y*H&=(G*YC#t7*klSjox+1+xG@4Ox}89GIwv5iqDLr
znaR|<QN>~?dUJ(P1IesN2TYI`Dl&*8lcmXPxe?zt&k6`2b<`bS=~*PQhSX<iJRukz
zno>&`3g62%rs<{YbJaw|yfpfQBc7i!%|nkkjugZY%L_8SrSJ5mi+pgmS$!8?weGc8
zsNQq0Fw+t;keyZ`Q7L9rW{HF3?N_&00SUaap&2EE34-1r$#dV=irkIW6{8}>Y%!Ig
zD_Nf4j$^gB>q3`(FG_Vty}qX4{kJ$@BUf23S11`3G9wqTxyo<;E`nn5J%2lV;^D@c
zCI2$#P5oN?D{y6}^Zoe`Ovs6M+V0%&{|aqr`!8RRVtSF5(fRGDOv3$w%**P&U5XY0
zMex$xg)1M%(sY_|#wU=rZRU9i%^%crMuYUq|K%S}?pDkz<S~oz#aZ$^#XR!|;kDAA
z$MqmhM^6=zqYLHYC2*s?x7OT*1^J7p8mYgF0uzWget*j}pF24~UMrTH8*?d|EG^lE
zqC9(+FsMcBpL1RaLdCCXcU;~I^^S4MDOZkEinl`$Lfbmo#$Y|-voClFv9BNny7vY|
zo?)D~9d%}J>Nf>YveWu?lyPu<od1`?Gxsib0St(>>>dW|Gh02csrBj=5V=}h31gQ*
z0ub*cvd%j^G8#40vUBWnnyQR`v`Ex?Yk|OqenN6Kv&m9EpChjQePs)OJL&yS(DBhU
z;a2uWq4|=lYRi8m$(Amd8wJYf`vu5<ntICjgpd$yBEc^GvXc41&fUm{X~3cV>#hQ7
zG+*xP1#LR2o(abZy`c_RZhqPSW9mM`lKkJWf#0%S2u@sydnfLZDJae~XQifwD`%x;
z=BPwK#JxwQhTF;t&CJpY_h?~RnOV8B($cijG<o>_pXbH%hPNCXaNIZd^*yi8`OVJd
zyB8#=AM%-cjZ(cclVjnNCRCF6*DzQ#dv-`kZFmUgw2nfY+6eF4ZB7Pm<;8rIf_t+S
z9xn0W&T|2g)mWn~l)#5{uF_1b@ERaH!}Ly{G5QuOJoU>+b_TXl5Monw!s1REh)?#%
zG^zCNNtnKX{%H}<a*^Rd^H3I&6^9h6IF)n`6BCQ94e|xez;KLHSPj&T0{@lR6Y;-;
zD&cXW=hCDZCw7O<3Zj#02qN!PP@kn_^gV<=tV>%DV)NJ<foX74sMr=$6JWzi#Kk5!
zu%tEI;V@Jq?ij9BxCCVp<&HG8LmDtJCz(QxCPyxs&<(@rU=K*E)SgKad>@*4`Yyq0
z(+M(`ZUmt_51$o6D-_@n9crlm=k<}&8EeoCW@Z5y-X4#N!NaMj6JLKq6AIuTJwzi}
zhy)Thvql-7i{j6;l|PGzcZQ;FOk}}Zv#NYV8yQ&z5jjJQoRQ|7C&M|<mU3Poa>q1s
zUpeN!j>vt>$bHwG`+hk0!&2@iMBa=>-kf9Jf`(EQ7Je%N1(5T;M&$iK<SWHV1r-Q+
zL&cV3kMrU4-Qx1M%rHSD;kP)1xM)5!DF?v9sh+4oJ{19T)Hb_-hK3uA@k<94NPS85
z#A)m@1y7)OdZrMmsnBe!P(ivVLlLfD$X`k=)V&|m(<(A$iqced9gD-nu41ZLC-#mM
zr%DE|;ZH+mgwKRQ5BC&N(Qy45el>Lke-2`REj&u%uMakDB_W8hh(5M(519+6j2Rpb
za>{;H9Fl3_8EfPlQUVDo^ASV)0T+U7q{J?XNL)$~Z&ZJx6sBcB8zGl>Py)_=HW?<M
zC{AVR<`$7`u_BbfM1jZ#R@f%JVwYKw^QB_f45KLxXunf@MGPM#3;q=aoSF`SgLpom
zq%ruk#vLg!-bgdF;`Tdp3fV(k1GQDKr)^85{nAm>5itv=3S_TXF9&suEp~7{2&Bl5
zRFu?hLeVbS@7vmo=DYH0#9R+8wv87&O-7i`h@2o*<rh}H=NF41VVtCa%dwGa<3cA}
z;gMumB)iggL9!E&%&R8~@Y(YBl{h$6{nIo}LMi{^Wga#}@&GQ=k{~EeVAAQBe=jRX
z`TTr?d|7CJwh`*?bduemb(FH&$Qlzle^pV&aB5AY9<hHGEe;|a0Ag!H?4|ZKUQ#;(
zk%6Bwwm^baVg?JOHp{Cig;%wdYY76Thp=ZC>uc3*1c{fGLu;Wnwe)C$)uYJbpf!;x
zpw`w=%??wg=~aIGPK}K~qh6hm9sIP9s5f7%Iu}SR2)z_Jrs3OKA~q}a7`5jt8RdPi
z&gb5x{a;Hp#2Qm4^=}u6%-~_3cx^tMNT;VRAHJFHr=97Cu|wH!xeNVg`toGoSbEo>
z*bff8vlTvwce3qNZZD`If~%sydgRgTH<h4;rraYdES)8Lv}=W4qEmoqQBl*P<NzQ!
zE+MuaE27^Mkm!u{DZi{Wclq?>^=G46KrFPjg9qhCg3&i2gqxZ7Bt6L$Vp?LnGO{{%
z<R)F%J<<3vUhO7NC>_}w{;KBXmzK55T7e$0gfob1n^Iw<h(9t)QDj6CSz9ScN~E>v
zXB2C<{5t#w>xo*E_kEVgcK8=itJsxbgl(%-cB}M_R@o=5^50q&1lts~+msKqsT9Ia
zyUToAVs#T>X?G-XkbOr`@E3FY&#y!M*rrIBXl{X!v4i;HnLFl3+cpd;M}crwA##@<
zIzbY4`PS~L?Wea5eHd$)A189yS^Vq>*CK`_sG%-42PA5Zh2^q?amJzo<7vA39bx+@
zw(qraZLWY?{S3lTIJ9)(*Ko$6Q<HBKRncWP?nHE77D;#@YU@qh<s4P$F^oIfY0+=X
z_}1|g1O%*$bOLY^2l0>-X~*J!QXo|Q?f$c$B1^s)%>_G>3V$8mgm@Sqd(EN|kE|j~
z#B+r5*WxsT`18>4sA){BhG--QG4V?D{<cWh`>sM+JxFrbR|6J?Pip>^qc5M6%Qc_k
ze!>ZqSo1Ye3Lxf>h0X*yPxL(8oqjl--TmRE&MH1D>Prm>?PhRaGOu04$+Q8~>Ht%5
z>*cf$5qaIQu4#Bk=Bmq!Rj#fu!SzkN&?S}!vlwpBdR%iYG2^v+a2sL-FZ_`y)X8Sn
zXa?Q|1g-X=3OPM2TyM9L>+5*eOYSJN4od9&qw6-1CrTc#Y)+?S!S0G8J>5^m_t<S6
zZ<0`gtNju`iuUX+i1%c9YWJG~t4@x_UY;NzDAo%yCL}mz?uW}r?H9cr<;}DCzAv3K
zD^=l(6*g>m2-ZiMy;hji9xzjlx;r^=Y^V1|FYF2E$QzRO8#a^T1bH88m>DvlTd1B#
z5NUOXtjh3<%K-YdKA<t5^8*5N17h=ysFZNkCnVtv(<sX$LS3i;k8N|#G-kC+GG<x?
zogvt`DmaA?=Oc6Z2T(#n6EsMW087qua5V-T4E;EbsS>i@21d_J>87&9Qs_S8s!exM
zVpW`O8Uex;730GrGuUP`c7kUxBA>$o<4!~04F)o8U~V;!Mm~%DA*<#}7~J?J$OOSK
z=|gq4(cEdF8dFRGO6*BAYAn`QOi>7@k900Qc3c)%*%A4n^K^rP*jx<GK!rq2%TZ#D
zo}*kAenJOG2iqqrXA<_Nl09zV)!G^xza$WlY5bZMnw9oEh#Pjbo>Cn`c*A;>J_gG#
z6nV_N0}T?U{XsRZVt$bKE8P<z7rfLy@e=N;moFQR4UY&<mh$ABUgI^AYAPlY;Du!p
zHg~zFy~kL^%t**s<SuKE<(v@J3z}ny>&`O5UN&z>iQyh%?jEq6oJQ<xN!ZRo-LyXz
zw2h3C6YC2eU#GzIf0F&l9_JPj`RLHczNdG*pdBibl4}S0Ymd^jQJ)u?DQ^XXf}xmF
zk+t6^*CdhgH_iVX=ICF*90vG()nvv|tor*Rcl=Q)1tKi;qbvXJ{ybb)^Y86?QQQS5
z^vqhEEx*Vi{KMzVmvzfU8VHfQsH=a)&tQ5E7?q!Yz-j}bgDr;)(qhabnc{Qg+ua1j
zD2E4H9|hOE2)9I?V7=W5M%iY5=n^&r?ulF=qj5)=jf!W}Js*dGZwtif?#7~pTe)KE
zOtbk{G<2LU7hlbXrQFa$<;9DTo9<qDC74h6RBnSpS2}|VU!984DE%d}DF-}Q6+t6E
z>4zX1-Ugmz$*#Ja0&MwKb_<=5(s53z0IL$8ASJji(t<+MNpi!cK6dU3cb*zPa5n&>
zdH)m6iz{9jzh`doM}&$;cpqFSapi3VA(;iHcCm=%Bd8-G!jT2A`lX9pln9-)K*M()
z*cEZz3w66Vy9NR{1rn?7`q?c<0dfGB%rABVgEmXs6XER1f!R<NWfC*j$u~huq>7bW
zJU9GBnTY4PgUq?RVwXFpaYD6g$X8J_W+!}KMo~?geUUa_JkKSZ`N-8G;=LKhB3e2q
zBKcv$`aLS)E|}0Fn}bduJ#9Ar7NUU)>%8{n+0n+I5-|wx_wF~Vl^3F(c1EWmzW?dJ
zVTbavx1HQ4a=z+R`xL$J&2q~lEwp}S>9F#4F2*0o%Ee|i=Axrwvpxv}<YM^8Z_|4U
zVVT%$YCSZb1W!Z3zuywwdh}y<*FD8z4t9I>6!rRM*Q&@Tec_`ll-rtov57?fn)K~8
z*%xc_Kh_jPek$tyRMt}x%aiv+!SFS2RDufc&cWhY(?m3U`O$xdav|_A++e-Hecklx
zx=Oz2?O5Trr~=z#8{G%xiEQX&>{)%Z$VP|gGogLCSmCoTxxJ0pRn;-cg4p=o*rdp|
zUjf`-_^YB`i|=dJ>Wge+Oq65!=;wb<d}4Xcz=DJ(qeNRt%5a(U5tKhiYyX7a7OiFq
zJz)x^KNc!n6uBQIuel(c9Sc1T9HFE+>->;v^Wq=GA&%f-W$YzBY>qmbABToVaDpO5
z|L)@cHi&G#D^57}Tjb0+`HT_~<9mD0m)*mT{bZfl%SRH|C=;bkWBg*Fc{AHypdD3<
z9j^P%4Qo+tFIBg5^4q^ete#wc^6vz)OZqXH_aTMGccjYjf)_|o21@8XUie-YG?ygg
z;me<J)x6~z>Sa9-MG-apu=TesgxrbfDi9h3Q1>Ia1Oa!B=uNA`DCm3pXNP+LxY*tp
zUQuYFU00E`m?I9Y>xEL3$$EW_bR~6NpkrO#Vg5jce%SMR-&c#SmF8!^&%b;1*^Nm^
zN0w?r@n``0nzcQ&BH&TO04>`(G%-Eu<0--i{^)&V-RzMeh{M*8lv04v6|oMXV5>yb
zNac3<k57+MN9*wm@BgU1sprFv38IjiW7^NMB$j`<WDo03ef@azoAB&pN6Ad!@h+D$
zQ<OsWxo6?`D*|lw`iyle6645&`Tw3b2E6}$V(R|cZ3yQI0??e;9XoTstFbJOyR(pT
zw!suo%G-sy2Yxt4e#^Yol=3>N>TzoI%RK55_l5LbU_~IRaQOx1*12gZ>89IvOy$Dg
zyp(W(Ba*)>UG_j$1<?o@cPT~S7nV`G9(sgt&(E-UWuUx!>`72Wh(c;R+6lE_aP1UP
z^nlSCQ9R8?K-*6M1nm?D19;)n8nSRSW`@yFHvjQj*pLsBpCtI}4WW*S`}j_Mk9MeK
z6EmqEq)JW{kZHI@68PJD^}?;pHDW!gHTo*>bIcxDclv0<-tcMxcEtr9?IpRcS|OlB
zRk7AkRdZd4^z8iQII)A~`Pa1XQp(<i?`eM&zv1DiTxz7gl)T-ikjlJf#1cyd+hSY<
zl~h@u^1k41egX}LJUFcN&+Gnv5SCKO1$N@<nNGwgShwZN)w9O&YR1S1dX{PF+6zmW
zRIm3PYoF!cfiSQhAgW#BZR&6B;mM=m3YGVi%5=%vNJAk!a<xU1A=H(O{vD7wS9-*h
zJvb6xZ2%lt)0m#0rW-lG)atEBW!?YU%vk;lW)YT)h=X^TX^sL)GGSRp&u(40XTr{T
zP+Rt;IjF2ddvU8tvM@(8*DzD@dPP`a;NGqIk|TSYrMv$krb{2pPHcuVsgiz;pOyGd
ziAi60f6fbt=X)_-@A?b(r5^8r%>T@2w!QBW>T*zuQOyHmUAX+=m3Lk&HjdO}j{d!`
zq(f~&Os%>j#R`jRet)~PNgp}MO<koso;m|&*_xkyY<v5}pzOJ+F$vY^&#e*;YG||L
zLp{-Y(^*?X1{eR>K=g=O3f~kI`IxT)cmO-TtydxA`p-U4tTyoAl<dE&1p<>62luZB
z?QeV?GWqZiaIyRjGyMC@fxXv4%P%H>jox0_^T&Nfci>aS39GAWsbJ%)-@U?Y@0W$e
zH@-0my@`%l5&WC}#NxVC))z_(Q$qg9zarcF5xl6$wBn17UB1T^-Fj-=bq4^9qVw(6
zk)izkl-;zvhZAm8+4*T#paAxjZDaq}W=uPl56&<ORxsHoz~mK$5_kt9ph@^B2x|+!
z9;WcP0@Djx&FEr>h@^a>a`l;S2v>G$B}fy3Qh6Q)Iy1)w)#@Bn5H<H7%u@|5OGf-U
zH;XipLs>pgGbHV5bM;41nbDzjFg|xV*J(XFSQpl$<(CNYLz6RKg+nP`49?ML!mi<K
z-Xbv_D-!);uP-@RvBg?Uo`;g-dSMZR=$r4CdnvmS@SYtH7(x-Hc9EK?cJr0f0{OJc
z=!gSGY0KHi1c~&Ef$)1lI`m(M$%lLi+Orfam29M}dvaBj$O~4o(v=lV`m4UR5Ro}S
zwy~|^nTB7B432zV6nMhQzQl`Lc9U7SCzY87m$r&dBzVbw5^8dML@p0<_o`m6ESG!S
z4keO6qItu%bwuv$6{B%J6e*D(=p@4}&)1}y27#4ConMr<^NA{1(9FKPqFWTym|$Kn
zxx~bk+t_&5E2~C2xmsvCjjKwlheaL;`0H7*8!G*5f`0l<;j@ZG@1}hVn#B9wQt=Zt
zO}4609=TfkJeOuA?pj89RsHpDwm)>;t0C&p&E!KZ#}C~&x)62b;on0n`k|H()o9;m
z0tb%RIY*x7qbawXep7+FnIc;ptu&MT_FW4|_RU1}v8~Z3VuyNfzrfHn9~BU45TA_`
zR}@zywXWr@Ww#cmXBo1=VyTsPh&`MN$HAbndUTEYa|2k|tJy0p`=f5+lHNzTZu?b7
z1WS)pti;?8lH%6aFwT}C2J{{j<;U(Ax>|ZHN6YV<(hEAMHgrKJrs_a@dvH^@=4g>M
z=nQmbv#<8d0)OPOqi+}U7+ozZ9~-Mv0!4xwu(Zx6dxPh1rOfXIrgw(U|0h6>f9DC1
z5aM+fBh;r)c9d;*55)BO-*g&7mq%$UPbM9Di0YV%<4Vu46z^S<?yn3H^xIeA;?uUI
z+UnAIg}zDayQ+Tudn$;-zkmV(%d2o*lZE@&&_Ri)`wpbavqBUCZBG)u-oHz$gR?7k
zw^`RQsmevGYgFS<Thz@PY}o*nu8#hrdCMk;m+t&|1I4`^9@<}zP5;*q!nqkq$=-U!
z>*wVDSI}wyodzz9#)nvZtBVa?IC^+-ac?|T(ugs%XlrwBlau!GblrZ2pKOBCsM>7H
z*|d=BsfaU!#?NK)!s2hF`t*<R#g-BBf>|JgOQXe---@_ScQx}T@A{gYN(u@HbNHOB
zRw_sfsPwom{;PKHXaU_h@a@>G{@R4tQFru|dt=H@Z#etWoxPwtbI9=Ro{&REF60a7
z1udy5x$0HAo?KwSw+Eha>&`Myvz4Cv4Ot#V2<4v8@%xgDuz2HNU?P`RQg0S5TUk3`
z{bp=lEB{<ehuW!<=#^C;+e%-*gXachwX4oEhRW1Le_I8nW!e`6^^WX0Y4Ed9vCdmj
zlsiA%U?iSAohlA)y*r$dyi<AN4t=kh?Ax~tk;4(kOH*h|9h+rW=Y&())HC7=9u1{C
zSNUdxQ_kWpJt{R}gwnLcYgKidf`e9H&8D<n-@DXO+TlmPQspb4mpqmh(w2C#VyP4T
zdp{AhJdXft1~rdaUDo{$bP}>B9kYTL4rE`jY<`~;u=9aW?@tYP>TLe8vHSNv{Eipn
zD=|ju-ng>oItvby-K}ug1DeVG>T(k^$7|LjW;d6el~+1uy?Omx@*DLV7Jni?T<BM~
zTHvTdH!EKJI;xu%^r39z1=Lq8@UW==8R;n1<4+x0NPEvPI6H*X4pz*&xe@k%E^$DD
z+y^4B+Ro2@lTqc1=<o8P3BJ7dTgi8*#AF$jld6M6*GY}+bL2xuuV#>@ON=jJ--nn@
z^%<|k-JLF0zN@`2#rd)Sw@2ax>vL`3!u9*V{;yLRD^?w0*)94Y?wf+}MrLj?Uc#Rs
z8AFgdPr&35q$>$BEd<$ag4|Pr{1jo&GC^U7fEBV)l(SLNu~D|PQJL=<%`U;Qz=w)@
zPGv!KCqNDiT6hY-1CG9wl*ua*(dzD1ak+PdMUU37H88RT8=`>;3JE8@T9L7krftiD
zMdSB0v#pPsLl!i$yP`Ar)A%jpA^SJrRzkJ`Vkkq=OrFtr;T`XGQE`DwlHJ<M*jUpt
zz+$=+YacP7T`1aqmZ0%$&SVPz!5z38#Lm{m)Xg1s*dKOy9JYWG5&t52$_Jub0Cr^c
z@z8CS4DB2X8Mc~T5|wGxDO-UBJ1#YsW9-c}2H8$_XOH#<#H-+p(Ag8c71)a4pIV-s
zg3*ph*Lgu3wxBKxG|tJ4+sQa>=@1cbbZ8%Bm7R{6QHr7QUyFPE(TsMCO^-&<ZAoR$
z%yjE!P*wpfTLZB-f)+dt3u8fA>(q(vbOM6>-`BG&Sb{St(?I^thWf2KDyC)T_-B?y
z4B2mYG;GSb7!(pU7}v@C<`Y?@tt{4(B(J2s3zd0{TR^nnhrPfQ?-w8&XuzLsX1v$b
zjNZ(Mr3vWz(BCqI0Xbo-l+4ES&O<n-I_=xMr^BRaM{z=)-w52NpnpqL<!fh)sV2jH
zTEr(2dg78O*stJt0X;P_<5xufA5!LDgKJsc!ylF)K^Ryf&bh_ACoiZUKtR{`6-p~Q
zcXgr}oI=0m!i3F21+=IVKlyCzJpfDXWWY^*1#hE@+$VB?PSFld(SwP>!l;4<BV;t9
zq_>34%VoJ_(#LHIKW>(^t!3OYznRj0_s~1(gF)$jW0wH;f|E5g!3WZ-6I3HS)d-M$
z)b1!+^Q5lwS;vjaSRZkNO_RZXfmG>YXRg`f0X97^6JhWLyd?_xx^x?07KeB4>j=v7
zA5|@O9(_9{96gb7ZT#T9ZDB`1q&U`Etkqa)7`n>2=ed@VcC^h-0I)=5{$0zs+frux
zv!l&Pwp|*2va>ts>jBYBSTBUr(I+rM%4l-zc~WR!whnJM6QE>PQ5+$<Q6u8Dc?BCv
zmzp(Y!ZhEi6i$e%iJj>B7+e2#*mW@H){msDkAOs1cJr55?BcajZIy=d3We0>tL36&
z=$_|F#-6CZaI{RjcpB6{mMRfRI}cQ&qpZ+HARD|(&?wvwOVK8$e<`3(ztb-SXb%!I
ztnk_UarA37O-k-y19$L9BFvbp0S=`+yTGQ~L3?m#jg&O<TobQg(q!T}^wXG3-f^&&
z;(lu_h8Y9?%^hh&K|qT#?UHSmBM&kR(p}r~3dV&+0}8gfy#uZ^06vgaA{u&uKOur<
z%`+GguPMxo_k4gUDo@{BZR_j7XUUl!8X5jYYK5b;+WrbW4jDeI`gr5D|D3nO7>GDb
zyD$lE+i4;TKq$$XdTj8%P0CewFmafgWPBv`AFp=GCr#dmqU%H5??ZF-Ne}R$pYX}J
z;KRuE$*l6py6Kbs(5KL*t(--%U~8`Z?0!T7I}X3DG;p7bpoKOMQOMK_e?htv>bNsk
zRL|(=gegCq)vn~O+-L;=3$k4o0`6r-m;|WNESN3EdXfo!Mbo@!{y$}rgZn_{Ei*b7
zqF~(-v=3XgHKbdYPbfdRoL4^F0$?E_Vws1SzV8`egUmWaXxG)v2P-L>0D@Yog$U#L
zd~ifMCi7RX!EFG!{`f0X+kPgKw8`3=p_}EY9GbQxGMUADg;)y#78PAgz|iRcq2?EV
z{~f<_5G`@IA*8_mgCo@*&}Fb7T@0`>E1R5_b;WSX*arV%1a9U?^Pw^LgvkMHf2IZ!
zeTl#E8~^^hPb&PNt7Q6V*6@-I8np)Bi<M2qzT3X^E~7rc)Q?wwA;|LZJKN2mZ~@^d
z4He%Kep?jm(N}0G6mVce!!+oDWaws$8nHP&R0EdaGg)I8kZeH<LmYXl(lhBp%Wr}D
zu+cn<!_23q&L<<4@s22FaUvyC^}OZE&FU#4IB_*2c0w>{Gb1HJoVSs+z&<hs+%XH*
z)nq@u<DExhn*tn)S$$rwCIt|GPY+=ieLe8-Zf+Kh5r)y5j->}J<&q-ky7>AJf>(Oa
z25W#n3c+M16)7h)lyS1qZp4vkGGvtT?rv4yv#>HHTqZz*A7-Sh^OL#7=*+E*(>T~C
z0rEm-*I6@qAddZG{TSn=n{Ah{iw2#<fO9wQ3+!#aqI{3Pde(;<eA)4UgoS%v^aMx=
zM?>bdPT|W_har$|O5(JN!KSbQiMO2r0urHLedt2~IdPU=zw{v*ORYx?w5J3X{w(T#
z7WjT?kLa`K6q!ezFZcU_kJ|?-vr)8^O?Wtvqs5U$dWgh66E^D<bi=(;Xv;o?+3Uj+
zv_#|?+RwCa(Ccv}NfA_b1e#MZJwVgY#OH?qW0TY6idFoe4$FfcpRKhQjgyg@KDmjp
zrVWLZAZEt5ij3nN$U^hrBm=w}d-UkGWGaG21bL^jAeyXwNi@d5G;GWUp6Up@y=}XE
z$TRt`u%5i6()26E<98J<KA4gHGW$Aw+ZX+1B14nQ=ccp?CM4$gv9r%N=9)DN7CXA>
z?q*mt%UiOu4`K~Yp)*P1;Rb9$p8~yr;bQz5wPa7dh8B@Jcd2lW`4BZc`eYTc?2F@H
z;d*KYMs@aVUAFO{u<M>c%_j~EJ`kx_0jU!<b2^Ori}C;>%0?*1#Qo5G`ujqy+r^Ff
zfoffwLArzXW|}6^Uz5608T&**CONiYk&TOk!K7nedXX$alf)Z=s#NebNq~1b_#pVZ
zIXixFE+?Q6+aU5l+7qoZ-P&O}(x?V-G*U_Z9tWtzf-nFj#?!n@{UcT}FdGbQQ4JE8
z3|n=-qr`-+`Y7mfYR{wkUq>8%P}2%<S7~^%-Ku+c2Ke2P>!2?#;QBh)F#`2!weTnA
zf#_8UFFL;C<m_{?M`a&R2q$a1IKDW-Pd>eQ^E}WZz85h{X1o*t%pz1;?+PXYcl<ds
zfMZ4oTkuGh`zRx0S7@}2-Yl5TZ#gRb^ov{T3Hph3*80)V5wTeAccw`v(!u@Z;ZB_^
z!BHPbU;{M&>ZXzj2iD#XI}<1pR)I`q!^|Tf3;0H@X~orP7=CH+(T7t<8ynZ<-)Hvc
zem8ecU0t|u-$lF9`93=?1QyL;@Z9is=vG_>K(!dAevy|pW`l8?b7xz@ufudF)Na`R
z7Bn(FLr{pf(TlgWjwias+i{P@+n<VeNR4;Qk9WEn?|eJ{Kso+D5Y$J1IF@QLz43vG
ze;f;TaDP`m337w~!i?C+tz?@;&>SZyx)Bh^=D~LlH>Ngo53bs}yrYLX379g|<2V?R
zjz?2iuz?&+{YLKGvumWQ%-~dUC6d7Wil8M8LY%NISBvz||LpG1?~4Qq(lV1!*PkIz
z)t`u~b@%&u;ac>9@)@q^33<CmjC9@S;BHP#+w+x^O}Sd`uVb;0tM`$PsGEln8SW8O
zmzCF&Bf=7kLBnbS_n%#(x^1TGG3eYPgIGw|e72)|o*5pzz@nul&t5#X^dMpmSAmS~
zV>zn6grw?UUYe@rZu-|ICz&Wgx;PYV(vVcsR<XK(uH*4ArmRgTvOCEXz&~d`o2L|f
ztKc|X+;BMcgps?1AR0jYfwo)C3EFQL3WNWCz*6jS^yq1NSTocSA>=?J<}X`PW4H4w
zQ(`L5hLDDx&4iXPBO4K!M43hAJ>dxUf8Z!734TOLajyn5tnj#9n_L}x(x4{i4w*5W
z$bW_Bmt)6>?bG|Mt_|pk;U484TZ&^aGNzoIzan@-@b_p6qT*_HIVaopjPPJ=&g6a4
zHR1D*Skxq+f@{+a;{pYKU!ZpneFtKfQYi<%uOjVgQ9(c9ApL^3irJ+&Itj5??J%C<
zcW;UN$LoD8xa%l9phENn>N916#%?JpJy?GT@szz$`7KfSw+7=6BcGIRT)y}Ztq&z{
z-qXXAgCJmWKCE3$&-pQij-^JN(m<A^>fl!S?P42%w;&z)=ajrmdeFy}?C^%+>%i9K
z0Dge&1DpatW`CvdvKURi2&d&ukK;C1rSg?rug7b?Y7lI|2(7X-4`t;d79V7~&-A3f
z`EC9_%81=d8~FK8@K5@*2BqiZ#WksE8A1&_JL=~3b9$d1UF3q0I*GWMUb5KOdXra3
z;{)Q!U4iKzex*Z6!U`pIX2oFu5wW=S`F3eI<p%KwA4`|LPZutHy6f80PY;c*g4x_)
zSC-+ACl#quFkreoVl+SP0PTM%*U|l-CHAa*GPpGKO(47>QC{}uv$D@l%2xhBd{=t3
z#6@}Y?cd)&_2uhbWnE6$-c1)su>SPAtrZa%V(0rP2$q4bP7EzqjrfQ50H{pW5s7t(
zdp6PNojBf{D`zOFyT$gB3RHf6q}H=FLY(BgqPy|*B9|nV>2QvZ^z4Ar%O!;0+Pr?9
z_%dX5_CnDZrZ7NF=~8{s0fTocgeMxuvtl1;bX<-t1tQX2zTTC}2)<mY?hh~-^o$C=
zam7guUiWP#aRkB^Mh7wM4+M7Zyn0^7xt8(q#KAHjr?|tbgVo8UH08??Z@95>1>rB<
zkMJrjIdvXNqE3oO{N`wVU(EO-BC9IO`24P4YpT5*Ww)H;4L$OHs>u!=%Bc&g3r0uy
z*vm@r14@4si%^8zsdK}GM!AyXuE22ICq3J11UKii=FL%=?TcQ|Zzi^8l=DKeUeUm?
z=)8oFL{HCGE2fJ##5B&r&)Z#jG3w^SKeJbEAKP|0><9EP4twGtt@l;0El2)#3(4aj
zqDOG>Qe?y0yNYna7)spU;&d*UELod==9R=pjo$|=etnJh!DUHIg{R0jNIBe`FcV<M
zzjlSd2)j!*W3hxct)G)&+n3tL9F(h!Ol8uP(#7c<uo7Vs73zqka}mL3dzPg;^YxE}
z%OhkV#>(zIte!919&?JIxW5o(@EpGvU6OaOZlmYfMMcrDw^>etjk);4AvcY)|CgqX
z5VI*TGMY?um5%C%Fb}SyJQJ}A1-~2$R+n4d6$Uvuk(3a=>IYwMXlG{n^F3AeEP>>%
zKj2-~zXZzd`*hG<A2Pt__M>*7&L8ONKIp!0ka5@^s2gsmuwKVsSMR$}Jz{a}s#a9j
zujL*mcgxbz^q~{^2?~<m$Ifv@3Jj7?b1b)p)1P0pscU(-yS@HHN_P$7q`b|vlR&fy
z=Q<Lx-(uZlG?WU`(EYqK5(eLEQi-;XvcldmdpWtdt1wY60rTWt#{YU=bZ~(-GtS)R
zw#%6soc$RSgZn`h`H8e%f?(uec8SNWL>+s_#llQ+dqSR65Lm2y=CI(ErG9m-bfJtT
zhzgPbySnCNb<xJn?tg>Co@4MxTlwLF{h9x@zu=w2nG+?ti$6?{7TE3q(C~3+V-N$V
zt4A&lT7wJ<C~_)_!e{Djlne^9{8f~<;6r9621P}cDyrK2a>>31#h0g4)b}NcTM=Fs
z*UG7C9*7+Esx>IR?ystS^vmdxUW2l>N>$zH$R|f<4ay%(sp_RTl^St+jKwuees|W7
z8vf;trd+aY4EXZ5r>L?g83-j7&r1w`CBr=tDS}xFW=IG$DmTk<$Yqhw&p6W%H<^x>
zl2YU{v(<Aetv-O+odNb{VadZdX^ZVkE=rEka%rrJgDP=io`_J)W0XBk`~l(*MueaO
za-keddXSAAxGM9yp?uXAWiUJ-dDVAd1Nm}ruP)q$58HSw$JhB{b$p${-35uALXk=+
z1zUw>Xzudi(X9phyXGVaoed~mvtZ0eGrH(nA{y`xLXWWMrX^{D4)H~q^Fj+QUCE=F
zTXUGxjt;<VYuP!iMN~YCasb^?nV$Jojfm|VeDGH2mS~OCL*?Q9otKAoW?$S6ly6aA
z2Z-%DpKBn5rHixkh@QW8=GzSJvHMzn&{I=Qm<Oaoz^z(wli>#W4y+xnvnMy_cv~eV
zT_@=1m65|5bgYskLbK@Joz<ER1rkWrtz7I9KqFAceFP4JNrLxJ#}(&?UW>kRbkrV*
z!$!3B2WTZQTnp44SH-U%JQ7jzb$(8ySh=ssvqIc-^_Nsv@msY8yW3IbrjM%P`z(ne
z0<#+Stzvv^ZN$%8NuvGLdxbr==Zi$f18E47M6QXPqRzr^wOc={aO%a11&0zLZd;o_
z>~?0n`-tte@cTBxe+YR8)93m>;#qb~8UEAE1*?~4H`MO^Ej;aMHdGpuVg0cXl}@r%
zzE_KQ_T9sLe)-@%$)s{quFGZr<7LNDBdZzyHa$*e!45eV9}SeX!*bz*b5=*{9c5si
z7T-lnmAVkX{t4pq28JO;rrs|lKi*^STvDOR`jA>Xo@NV-h4OI*^mNpqmIcPZKj^A8
zoxmViUPeV>8QAZANIa?rk!S`BDDljROAOX^D;6}ecsH1`X#P6Ao_28buS+hwc<**+
z(2bf_C}YwcD^ru{(jiSw88-zM?MC%M6M5%_B1NkFS3Y^KEaQ7?=~)jl(h;X~?xTrR
zXnej5M`^#^FVMb5jKiM}LS}<^@n}{uT+`>Mqx<6eyPtF=3@VM^2~(RU%1>3akVQ!9
zjVMR@(BymFxe~e@J`oDJuh7nXEXkG!-(EEv&_21A9b!2r^T}*z-}kkAs^z?rg89gS
zlRt~=EElwnnLj!D{b%{UYeHucrPqk(wJhS5r2CrFvAdq>_V`|OVMPCTh|_K24y7&N
z6537_1UGM1d_Iz9VTUWswqKH6ToTVy|EMUF8Vg4H*^2@{V{@Z@=9Uj9<g35Dm~ih{
zh?tn7jp3sek<0!BnQ({gkBW>EqxRe3O`=GhTf8UTxxrP&skM;aRe`qMx>sHLG~*V+
zEvk`?3?Tl@!bS1v^Qge&Dz2r8cyT@n<Ns|Df<LMD5@~4QBv8HIQQtj$y+_Da`9WT*
zrO3<dZEj8-W)L%E@tB#SSZJ&1&!ihee;&n`sy0Pz#bV>RGub*S$R*B*RZGvUe1lWw
z17(areuH{o)dEP)ZT<f0c4qYWIfZ5X?XRVgP%NE_>M9mgnF^>FBBv?iK`M;F&DT%=
zAz<=CSoS6rhmhZoCQ1N>rb51h8iR(!UO?aj)*X8PrZm%sE{U(UHj*PSm>VTnPXI5|
zLX9v3%kGR|6RS2h3y3}xeW6~70zNhOVQVutV2XtNK5eNnC?ZOfEy=ZRw|(<kLGP^a
zeU1}vqn6!T{`S|NyPFCRYV00+(9-6?D(<wkmA=%C0rUC3bz>)r92NEfo_({1drLRa
zPQ2&bJk{7yKExM%Uz&7VyoWsxmhyzKcV>v*d`5_VL!%nKNJ4`~U%1ghpwo$M=i>X}
z10mi<XM=GV1JWhE#&ST|4T7N&n5TH{jkVS3r>XZ-<Q)nB4?*=GyqY<vi1pgT60#$w
z1?yb48?N3fN7Y{fsUL)x?@*_Gp-pkNhT|ZNGepYBMn9Hn-~$5vPLEZge9448LlaHD
z@_@P!PfWITi!Ejot)$V11=z-$w!*N1vl~yXaWzEuOv|sczqi0jD#3boU_T64zLF;|
z+J4pKH_N11N~C@02L)pKthx{AFZY@3l$dOCE)Z=1mNQppl|x{I<#np8V1S|}=AaO`
ze%aQ@$Qu_+0x-v{3WB6`a|?_v5li~4m@@<jc)JFgE=QD(8P1+|A<+nec~ni8Pmj<I
z9=m<NeESVKZVDT@btUP>u?V{sgo?Lwf(PVqW4fLDsP*|FtM8(FP%|sM_3I6LOWL6T
zfH$`q{NbL9YrnkOUluw~!K>vP7f}7Nv(EfOisQ2?Hcn~(Y`>+a1uuc5X+6QB_2T41
z7D7~9WuJ8{W@V=j?o5+q4p=PNXdtL2PeXx-o|jYddsio{m);)Jq2eJFRfc`v%|)yB
z#b^U4hB+|jO$=w%?c4J|+;m*R0<htp-Z>tNY_fCYVV~gKOx3+rbeIH$nZuAM%eF!C
zi12!tF;%XA0xQ>NEhH2U#j_&Ps=E(Tu)UJI&lJZg1`+-G{WiKJ9#u257D;P+Sd2Hb
zZN}JI(bNbPGp-3`c<dZ8hk}24_<(cuv3Z&+2(Q*YLokX6#V=X+^L}5SLKV}+-E9vY
z?7uDd$pk;0D3Hkrq(v|GDVu!ORqfs1Uxp_t`PIUK28Df_)T#(O{T=XYOuyA|+FH5<
zz$hSeQ~h%&ho^XMW??eWXgx724W$H&R}q($f?%!yPa$RZ-P}TkNzUmf)C51Z#bNS^
z;~%V-2{KHAjLIk%wPh#MykN#Ejix9Q*w?IwHBl#(z1%6miO<znj$<hQIi*(5`${hM
zFeR@?$X&PNxqB|XSsz7Z=fQqCHU|azmm6xtmz-8!KeN`UKWsE_3j_LNdoJ*fHFgE<
zcl&1K`}zO%oza0fW`(*#@d}83#>*yq4n=%;R6=Ngwqtu2O|;!@qECd{;lbMhR6|k7
zjivfqe00Mp2R%rY0dqiw2*SF5v)-^#F#~n%Qakpjdt$w<mZDyHEbQ^*Nu?CLkF8y&
zcDEn#EsIh=`I1!B8!{de)~J{+M?E~zd{pvV9*m55I54zHl|+2$nN`)9PY)dHv+=Pn
zo~-36*nP2f`9hFewBD#CPNYS+za^Y+dYsIZ^R%gTd|}*Thi;b5N)j-|sd^>aZtG-h
z&}^Sg2K<Rw@bIQwy-s58fuhHCEPdvjC053)zIM(=>)yrgW4(5W0sEZ~EOzAcvwY&}
za$J{4lbh<JL)kwNVBkETpMRP-(LOPG*@q{Oa-@?_2HEYT+1KB|JgO(wf3}V}GW_>5
z5whe#<_VCH`*H=31?V_`ui3V~3;tje9q(DcSF`rjb6QZW+%P>sqw6pcrrTf_`#mFw
zV&5F`YEbkasqYeQ+H$Xx{ZvHca+p41NQy}fUX1{DK<JpXh!{ej=r!wp%HaqQH#ius
zYY}M|x;!XKEWH?WoB=zDYzRJ|MZ|=pNxmiyyUe5e_1xc;g5Urr(ri!vAA<p@L|;ya
zvZsF!9a7(Y{kEMC)%6he%cGYsc}0@m1PK(SeaE|qMKDn5b#+WLVnUTL1CRk*-YM66
zfqvWXeG}DRtpROz^NJpg$B0s<YpIWX(_{+L)TV}1nhDb0y0`vDV50gzP>2mr!73O~
z4nL#=O>|WQOE>f7Dn3`kO!3|VFLVU(Ice2xt02zVg8^6l8xV->-MHW*dTy_m8Q8Dn
z22q?3exv6lc6PpVKzm8(z{Ss2cz0Zc{)L3rPfj$fx3l}Gp3Z$Fm+-VtXt!@ck$=xp
z|Go&@!r(6w5d+$eA_R6{SHEgvat^;hBzU$VRAbaK<{3`KE#SE%K~B#ue);F$>JP2p
z_07Ht-^PvAP~a(St>A@qOs=|ITlOyX%3tWI9GyL4h^oeE4<pTesQK3AHNto>5R;P{
z3=Sv)mw#+Coo|a+Hn8K_5t655o_OlGJLY^?diuyg;@;)d`>zO$Z}it`xOs5Ej*Zn4
z2xxcx4+@>=wVnpu*bDa~^*M{u0;`U76vkbi>XUJ$NiO$Uv0I5gJqElG1_9)Us{tLI
zBs@j=_4`<!|3t{KF=rhUT|fttgRG|Z5b(V%hX$eo4Y_uql=eLkzj^O>-Huk6K1n#>
z@U7Z`x<T+xbGn|d|D;I#1VtH3L7VU^no*P|U}-dhd<n6e{~1yI+TLb@>{A_UVVHE#
z=|i!6^8eE0Vr1=_`IP1fPM-t?vtY(0Up)Wkg9_gGeklCxqeDbFd=?J}b-B@A-!^I?
zEGZYm`0{4`6wd_p77%dt^DW+MxoP`NSW<e!CYa4gDfwuf)2D?~54iHnnt3)ljfa5R
z<R}fPY}gz`C&)Y@DB#bA9{n8_l5jlw_wh3c;VHkvsR<F;zaxqhMw<yZ&6g_GuTF10
z<%|n;mzwBm($xB?_!O#aj!Ka`=$X$eo&d_#6fy}iI;uW1LF$%D6EanB4v6U!1*X0c
zh33ab;gEM9%$Pl=ETw4@!a;0VgB2%*An7who@nATGX#hLWvhhFkZ4B%?_Q0a-rp;>
zFGOJ}nr{zF&~wp@3s;b8nWj3bPyeKq#NE6{63VfTNSA<Ivi85Hc)vq+#VeNdV&d8~
z?ZBVZx+00EhR-+rf#Ism99N63exGH-D6RDWj|HX5U@LNUudpnQNUZYlpc1(@&gl>{
z?X*%K-2z|zk+je08rywKfyBa>Aeo`Ql7xHbw58G&*3NE@(WvJtHa4}T%i1rS71Q4D
z4;?ptI+<=2ePgB1xZo%km{#+}$!e~3)^z)p{V7Ul_fyv6FDxF=*RXe1hJKpwYl!Iq
zEl}N1#Zf6m2fH$Ao|x~|wYktbV@=8|x6U+r+IJz=)<XeWz`657cc{MV`OCsBmDimq
zDt~I<ddiNMTUSs5H3u7}%zyZkUSBL4>HpU1NFQiFl%RK|<grl6l?OWa!>vddGr|7W
z%Z@4ccnU43QP~a+j0D}j4%7GWc=xrfN9z3QpWClI3p>DQOM5iromFgP(R9)w0MD2{
zi#C#e21t%A72lQ}rADXdBweEVtXt!@&(q#BzYXMT_<7{Ubk0olCB1CEgLw69pKhTG
z5O3oG_<irTpd2;l8eYo5kqNT>6#o{m^m%&vw+E_8=Z{JY{8s7K;m_I}|DEn+QIYc2
zv)j%7Gg$j0?c9aGrC<KsRnAB)x76vexv3$rpCMj6O|kB`J*Sr*a68|GG})|kB#k>}
zb$9y-?(Op~&xb)aDsq&sYQi_BZDd&lZLz{vUjHVfJPT`a@9OqzSDl@_b3yx^ap1iR
zQ&&9YAU3g2{(YFc@bTNfkLwpcZU6fOzBn!T=wo!69J^Ysh#<pw*nOW*K7Qz0XbNe`
z)E@XC8I#62^lN%3L(WBah1`1;MUW8h+ivf}ksl6*?fHbb@|iEoT?7_AS08}~DKY3(
z(Yq-SP`oouQz)G)KK_6w#<ZOAPjRE^(=5)HJji|3P3-Tz0I}IKm7(&<>a=%H;NL!#
z2tFpCh?^$exSt^NR7I2KuR6^{`hnaQ_r2@cHn!g+5GfJ;d@_vXjlLlzA)1;{dbk~3
zyx{#Hm`DcNA!TBTs34nkL1~kCUb>W+DW-Y2J#j4vmqy1WY;5Y2#Q{5jp^{nP{wUS&
zR`WbU^tj6<!^k)7Nn+v8(^<P)??Gfovep);U69=LSuZVek$)q@A>8|#*EQ#HRd?an
zh1m(JhGp53DrrO==u(I(o^@h8CRaB_ve2&sksbR>;BbtRUn2mZCf>TY90a}JiS`@6
zT6sO2D{Y#vgE{>)Xln<puc=BN)h+fG5JjB0%1+HwDmS?xqo|V1*DF!;ApL0X`H#CY
z;vLJpyz18UYh<i!(5W<5*sHyZqG!lOGrI%G*alzyw1?G^gbVU12`ld<lD|4N>jBQY
z$)mon4R0u?^5y;VACSLzJ}0))_rN_XdF*w&%h1(~lNG!>>-XDn$v<C6NA2o6n}bKz
z)q83ovu;=*ouE#hn4B0=IDrzaZ*rNJE$kO{Eg3<6Xx;*mZ6`-ouHq?UHyL_w_(@lA
z@m*j0_c#%W4IB{1zV+HiLG~qWh{17%Nr;6*LlTM~D7i3ej&SZn@i9lW!DemJs(d)E
z8le9E$>#=u7ay(GI)7g5xtXg!y*s7*d~5*;S+ZAQ-|&)?vN?4Bil7@wTCJ*jDKq5y
z2~eVgpwf;E9iKM*Wd!|LZA-n1y7!m57htj?KIEXhqK*GNk9{GNHtc?_oDf!3`ep#o
zSR6h7(_^q0*bP#aER{hol}jFqYIqZRLyMoR9rZ3(=Gv`_&sY6iWX^O@N8iCO7Y?4j
zgFWe>m5DHI5@t`vjl>&}kH>#gCLc)%@qU-Q^02)2QOg9iK#PHmxT>vVjw8pH$Tc*z
ztp=E>F?+RpucS`LxvJOi^r%=W6<sp|z-PZiE9P$te8tv-*opJGVC=iRYQF&P(A5a(
z>PyE{E;V#cQ;v>5dut2PvcHFq+GFu48tS*MP#I@KH1%>Uszs(vq_>q9N!CtA(JGMa
z66#mp@*hw=;wn|zs3Nn{o>DTdmxlE{Ra!*zvS(_KZhe+-AOE;dvEzNmtfx?2QC(96
zL}2bw-u{0MQce;|_v6wLB3PNnDD_ivG*Hs2LVVGj>;}h8xekpZI@7A5_fQ&AX+?ZY
zf&J^5hvFZlMh?USoo0saRUOQ-YDa{$gJW&4?(Z)hrG|*DE8xxj<mrsJu5W4W{Gw%(
zcRyX!KdciLzCT$ea-VR|t0V_zJZIW!<=~Zm`_8zQ;;3?Ja#V&(>L`lq7@AQE$DUDG
zKlVPMbx+gu3+wHD48`Q4d>l)Jg03G)%28)phYABHhbuc?uA1{3Je3yEx5rpk6l?2H
zHMTgsIcm)nBZP|FR`bBKT`6Sz7|vYXJ5#`S$%b~GV9NJ*8kOmT)@1Xc^B530xwrSs
zcq0-!t=XrOK&A_R7Nr;JBKs9jUmd4q2SP5{#1zV!xuA0+z2{`c)G|M)P;=u-=H$MZ
zH64$sQ~#DolHZzeu-=W++GXysSmxD3>=7-@tVC$WuVvYnxEB_d%&TbnIvofUExt59
zuV((v$?c+ONsah|hLf+eSG8y<^#Mq}7vDw`Ps^6~$H=k}TxU~!q2LknthCrmM#!d%
z;=Op{-gB3nLoPFr6F8EYV@<c6&z#)@!jM)AFycGb>l|rGGh*pyT}IgYWV$>3K!WmP
zv>=t-2$~s}@I2&^*FKt$tBuc?$vJ^}%;*70H_nlMoZK8CzAm$Shk(c)uu+7G`r9C)
zIMrD3YV<&!q)`0-3b%!{JXP}03|$&QY;7V}veZuSqc|_R!2D>P=TYpu1Vct~o~eiz
z(d}E@6!rc&xP)tYT&-3^a}i|qNwqRyH6j!)4NHOr-S*LGX57HK84b^fq&-(b?SE&3
zP6oMThQ3z!|CMnh)$h$<zm2IM6Eo7?-$Lb<#3`KU%u}Sq37^=Qje(<`lw)ghf;N;S
zi#XBQQ8hWithq{COQPXMh;Z2(9z)QXfq%0mk_=^{?~<Xq!G(-;VnQ2V^K#fTKfmk4
z2UUvNC?|J%(o4ghqD$T}BkP$>Gz2)@4{_yorI_fYcek%bbkh$-dqTqzYf{f*Z{q3i
zi&J$%6bJ2YopwF?;aX0up&B~d83QGo>CDN%-of|%CSN{?D3!lKPM_|+RvEr|UGAl?
zLq~}iGqq(7^AI!S^s1Rzb{HzwhZ?l}Ii~P!Pp8qb^&#U<0I=<!BhcKDzF@MjMWwyq
z!$`O^#1ocKp#=<kzS_z1(5wrla{KrawWzcMQ-h9k_Yq}lA@wZ%QHW{8D1V<?gkp{e
z9J|Mp=AvM8Cu{y;?-BPNdthRW^b|MZ6k7?GZK1pB)r_@r!*Yy&qkE-Olk`0?_FlV$
z{4mC_!bx|Ac&s9-uXHe%4?*K@%;h^frWtguDl}A{x%##>_iB{f_d`-*xfrVSn5VQ8
z8bBj-0jA`mwnf5hjoVNGMI)h8a*y|Hre!lt^sT3TN8qn~AO9OMy@a|{`H)<Yy38AM
z=}SLx-pC_rw3DzLAtl-a1Wl(_onc0FD|ju{9I64()-!M=V6usS=75)6dk9JBgU_)m
zY9}Qa%Cx@%2iy?0rd+LDS(`bbN;_NAC?@q}w+sCY;x*QvlUv-*7On|Q%JMyVw!HPj
zkBa&rbPym=u!GLu;t!D!QR$VO#sCc!i_+gR?Ih|^f<L?OsqPMEC?k91(m2W*)7u&9
zpc>&CtLu!zj<zzKY2j2yu(0;yv))1{gv)L}|73p8@hvDej|e3xWHT!WOX$4lL`}IT
z@_$OttZO9S^~GxW!sWO<Gl6#h6xJe2uUjJoFwjU-u4A#czpyg+o7@UI2%3bn30$y~
zQ?zkii=1Ez2ZYoKpLj(XmDI_wpQj5eZVimwM<cv;=H%>_A)hgyysu9$65br#o|hNR
zu*K^mKiVJ^<s9b_#HaH6j<Ia_bX-RnPo&W<J0PT&nXqE_J--c+2taWQ0)+v5fQ}|0
z543<R!2p5_fDu9f836!bF##7Z`<lKCl(KWBqlXgK;j~uN)NpIvP(Ic+OU|jSexz8#
z>$?9)Tf>ubUB3TLjn!OfAU=O-nBFJrgu$$*G-<ME2QbmHU-tOdCr&ZkEOeFg>zSH}
z3Hw7IM(^Hudz;jkCI4iNNw@=#3(Q<}_mfZ}Qnv)Be;f-)o#RwYExy3Kdo16l(se_K
zHPgos(++&vIrmJ7FY0-TQo;D+^KYlyXMXFkwJP;e_*;y=N<B#3?!83Qx*HdaUpxPO
z``pvJEAKnceEawheG`9rcQPIA6aC$cvzIzH5DC3*{ZM7=?}Bc^p@4{m9f`*054-;S
zn9j7~A~{1%OF+~t|4w*D^V0besLjv&8i1N#f(qCSB3NYq<`Bm7sYzeE)W-uEI%1B%
zI45D6in7<3NrN^>04fP+r2@mMcMA$Gqg&w1>e4WFo^^Y@9Z{bfQHMS@G+u_<Bi0e0
zn_#@yJeOxlX}F5N`Sgvua+Ru~tmb!UtVk#*;EtPBLBqP6PBGuKlqvUY=L_Q(%-=5g
z>b`T>iqNvi#Y-|(hYIiyC&Hlrho*b+XZrvD$N#j=%z4ho*yenmV{-^&m}7IuDdc=6
zgmjSE#)dFC>okX)QXxsGoJp#Yr0Df>EJ=kVr|jqT{(OJ`z%I|rWzRkLygY8V`}HpN
z9n$kkEcxai7aGhq-of`ZY`_Un`7B?YBN8J=H!FddL)?}a5)-*IhN@p{itOsoTxNqU
zx&p&Xizkmol$8bpFY&r>qG#zyf)U$5)tMMicUGbs&^aP(uC?3bs$#=C+VSl{5A<bO
zMI0|A$2V{65w}3*G`qbI_2ch1y52lnVcDU)-fOtaG3P`D+77DkHVb0yemq&JJ^k(u
zSAfoGQ??rqt$^Aw(HHgif){9wV3A(c;^W62@*f|u8t^V|TNA45<jVT0)(^K)*R~lj
znvC{68dPMW6-XV@xXzC{@M9ZoJAr4iWrXd4MZ4%91L$G(b54aPYS@kI^~nU0uS;P5
zTFs{%i588VmR{mZKB8(?O}r3u4K{W4_y@WkF-e`_A-S$v=Z?A3(Mex*L~eO=Q*zCI
zEeX($PYBu-B*H}65?+3FPq&tgNLl39PpM}0F1;giT=^VC8TJ_JSQ*%UV;Je6@bOv(
zcbi?<x0c1+8!UDLPoJ};^k_(Zy6JT!sWf&kZ=ew-DV1wy%qQhGzi`q-WKZ;i|GAi;
zVJ((tb%FjN#I;L>r8nBFbl&#TdqmywpWWq&dLUbAT539ngue06k6*LrfByY5N7Xvq
zSt>nyxVuvK;Bas4@z2Bk^`p-?*m{4K^>^pX1J>cepPwuiz;iUDh3^4L5<*XrXi_UZ
znWPJK{MQ(MwwlZ4`EDwgXyYX55kfB@A15z9iHDs-m4hqR)f#kPnoA;iQ^qnvYU`)m
z(DAuZuo{U$7`wO=>L#tG*@DkDV3gGsO3$9;qh%sV((P;yfU98PnZ5aT<yxb3ynvF6
zG=9}-#Hw+cLUM>Kv?MKHCXY1UTs7Obh|NKRLq~-F)fx6-O98ZuBHYn|rc$<KZ4^6@
z2PqHY1bbnaTP-=XL{0$>VWORQ5ZnVnR``sBUrDdmyoS!uJlx8ESzJSnHmRx*bZMce
zZzA%r3jU3Nbee+&H<fS_kWU%qvk1;{5>k+hvK>`b+$_x=lQ~u_1WY{nBKv3My+LS@
zZ9$VWO4e;e?AU@0{VG8{rz}^|UHNDO!bXK)d97Ylt3dqr-HINEFSgMh+AWn~(T6EW
zENv;@noxtlg;TWe_p)+BCP9Mrlo@2E0MUOby&~)a?fb=sQNqGRgjJ2Az#SF4Lg|;X
zzXb6ja|-&|){`{ucY&5avv8UBZEq?oykLLhC4^_n0rM$AOwGkM=N%k83DTpr-6C^q
zC`j2x+ge9ZFyB;p$);Ag<{r$jjiP+2mh47zx#^8BCk2b&Qgs(t_?3UvMZZxvE7WED
zE4<~(yAl=0Z@AVHI0n-%*~DdT1Ykv;jJR?IRt$^$_?j7f-%^YL&ot<6QM6Q`NFJ|Q
zu|2oje`95Wp06P;=eX-R)EHZXL>8FoCBp3>J(?1g(H8oGF5`YvMHb!5!S6;tW{qhh
zX(K^Eo505)mZC1;vHsGO;aq^4)|GvtEblU<%Sq~3k#>3d0<$lEyK#a-F%TGmJ+O6O
z*%Y`T)6ySZzmf5`O)il;Fe1^G+ue0Y8~Nq$=X0lD{zH>?MxI%RsAu-7rZFu^r3W@T
zP0p=AN)YA`r9bQok_Us3ugnxFH%~x%EKNF9Du{eV-NSr<2`yC%wy(pJBCdr@F3YSs
z%ltxgdS_qVM0$)VP?1;Xw>!%a_$2S*`+z>Qc*D1}V8~C+;`N6z4Z-mfTn3G3c)=sE
zp|-(Kmti|BChz?Vg72o6<%o|;evNqR7*)q)UTE4&>>k&krv6K{Ppf^?qgt`wFP+FP
zMEUTsWZZqTd=6W(ozzjhWl3kTs+ARQ_WC7#h&h$Da`Y#T&Q{8r+E~5rl|cjV7Ot4J
z5H)W>z%ziKf=KAtZdueX%^0stOw6n+o7d|qi{r{&)v1X(txPVzQ@}Z(bHoa|B9@fz
z9la14ou5KK@OTlQS8Mok)@_5U@P<0}k<T9ikB}(-R|491Q&N4SU8}bSu+jA*k{Nj(
zr33f#L>^sw;Z=!YN=m^b+TMOvd^O%`ICJ4yvudjC0^-@Fesx1_`PEh~uHi1!w4YkN
zeUw+!!^fizdsb>a1R+i7YTbd$S;8M74-6u4T>o1#;2&YJv@=!l_N2yU3z`DHUNOhI
z8g${h!^1E4iyGQdy7&<$EE9|nXp6P6cGR?3u9{s=l>Yg$FejS)u%tABx5u<Qoi_y*
zEUj~y6Bya{m*X4K++Za6t|L|eaZ9TfcxjN->D5d2dO51e$0wG3+pje*98co{PDrK~
zKKfU8F6egRKQpo3XQgiDyw2sP21i{*yBRB35hZWDI-sMDb_o1|`I;^Wa3$Csxp{$u
zru0jpSe*-F%pcuxxiKSKqnHGRujeh88`R&>XX=ysPtUy^-Fg1JgO@&XR9i{^a*x?1
z_y1Zcj1!Z87BuVXL`Z)M@N9gvIGp^Pd1T@GiP;}cm%1OE-Tz^;^5Pd*o@LAT_3vhy
z+3xz{75wDc!|n6KU;aq7<0F3_?tM|*-+uG_@Xs68;r`K6SeyvL5FwsKXbKTlMqF{R
zgBL&(;YnQL>D$LIac;1WHuEtG`3BiFz`du-=gtd?lUB*eAOVgWU&0a%L>AZKul(6j
zJEULz=Kum9D1bW_faWo|)6gP~SiWL_YY1U43nJq%W_yb84u-|477|SX{-Vn8od?CG
z-gIF=;^$H4b(qYyt^gj_&zyvHFnIcz+${)BP{2ttf*o{C1$qrmC2)@tc%H+#E9r3W
zIavQ3?=X?mb(;E|6iyX1$xdL$wNu#QE`YEc=d`&vYT0kG^x!PGT4n+dMHDE~gS(jX
zzHk-$iG~N$`L0j%T)||A>YQR@LQUB?YXOsuINt4=jBXJiyhmb#c?nooU=jF^)QQdo
z+lLeBSqkuewA8mao~LL&(`x5`&{BiVwxt`{HR8EOE?#T^EV+eGTu$Q_gTw~#cQLs!
zLcn$S@q6oDF9{lIC?#JTu`Cye%{*^h%UKqY7Z6S64&q9hcVvS@O~)w{JNYGjJ`&`h
z7ITiwX1<37P~3P}Wudm_dEvDlcJRCyMc=1Q2VPac2P@!Vq51uw%KHfWmvItl1Zbo=
zbg`K~5lmO-M4k%fm=NR+n}^9*2&=8+cCt44%LwW&fK~?`4zWVB`73AMiBc!S85p;r
zP5ztHx!0972ou*_B#;Wis`cZ(x*P1K^G;fol1v0UjVQU%Y{?c!usSNFI2Ux3zzOGq
zgXe_Qbm5)!s~+$R`{sP}Xuf%3={lzPiiC`+1>}~FSg14m{v1EowxC0bWinEZ3dn=g
zInMR+`r3r!dSVm&#rn|j7=jLWKkwl>EzPikSbjpfoc~gs5EU)OToG*S&G?!wS!2n;
zg@t}$N-P5jPoO}TsFDv_>Q)W=jiZ^77H*a~zn(?KXoFPsvOSd`_7CBx5edZz@dLGG
zR1Ca^Ahzhw?g41+&cUcGIA4(^f3cTwz;R8bP5xVO*hhp0w;b$YFCWnyVnyT__P2cb
z<aQR4>;pTZwoX?9B-DH{=RB|JhI)s&A*hA##hg$hDGFti0K%d$Q`x)BA~rPF&jkKo
zaT01TZlhF1>z4Ffm`Y$Qe;M(LO1eUoc=?8~l6Ox*Vmxnxx%@t0{7lXyRNGKZT%y}m
zY!(jdTjyV4*eo(kX6C%)KGp>FCh!$NCoEy_cf}(8IWm>JW)|VW{u~j)d|;tFImA0o
z-nE~|X<z~9j6Y|FC!~!amK<1{z-2o3-rZDy|6?=H5w$O9Sa)Uhgxw0<Kh9wEtu5DX
z9c|CVYXu(1nuE2NAN^WxWEnLSc{h|?Y$&T}sOW6C@v-67Uc;{3x%-O9JbxY<T%z*4
zW)+u3b(mBwtg*|v3besBMX-ENxT_z`n`bUOBMv<N$kVr8M*HI%UlqQDx;s_s-Hy#|
zZj=%h2ecaD4+ToKu!P$gLA4CQWyUp`ttii+i$b_7?QHj7U6fK01&;WI)lQz(Rn#H#
zuGY9D9nIAr$A8!pp@N0d8LA9X^)KELLP=7Eq8ZB-QlU`b(L8^wxiCb8e*+sY*DiQ>
z?_NVB_TH-G1MlYU@yj4&lbNmX(YganfjW!m3hrgkCGgBLcuLG8kH9Rmh^uT&&aj>O
zeAY#n(&zfj_16CkEkwg%WD_DCw_}qW{UxFx#HG3>+z#Kys%^Pn5X@N#O<UlFuL$zK
zlpl(dC~<@8mBC*URXpH1I0bm%1nxD$sVP97A;jM%q3-hSvOW71RcaRKYvgI~$AQ1G
zWVbrPOL6c%{8XIqFT!cGKr7J0-s>;+MDa#q08d9V`gf)BbqW0;I8Wnvk={!oRx?j~
zzt}_|?*u{YuDeRQu?Wkknf@qH#XZR|y*8~&O2QZ(??rVBxVJ&j+4tww6qoRB;V-sV
zdX^1;P|q9uB+AJKKSk%S!r%$oQlXflU1nI3PFL^JIp;?%AB<&EUp_vUgN<iNb-j*k
z1F^x*3GhPf1n(7?Y^);zL^i9LBO>m2V>(})v-mFE`d(jDD3bT)ez>KVn5@0plMXdo
zH5r9d0k1v~PCd5gG&$?E-?q>tb=nTzsLlUspc&M{K}GNsl=5?&f~29O7?!$vo>^Ur
z_QwNw_nAr`z#`K`l}8M8pG&Vs%j4%zcSH3MbC1MN*(zqJG@*klylb*7^M|L?J3s}n
zq+Wk3v>1zC>SDq-OJE1uqpU=Mo1Vtw>(B8Jy9~wTzCL%C(p3Iv`=Qm&&Dzv-qk%br
z0jnN~wdSBx<IQCj{JU|6F8<2)<VM|%c7Zym)^g%rOSjQtw{vfaFw0JJ{<@&{XPdy1
zgp=-$V&8^7#RqcCt2}WRv6BXp31X#nu8GbZ5v9&%k?g7NO@C*eC_#trp@y((z27F=
zrl%fUh0<QuHI+m+kF=iv7<3lEZ7?ecvEq-MgXZ=a>@zMV-Wg0iy6$F<p*hr{Ah3((
zN^90r^$}9P${WmpdcbAhK&~BIR-RTHP}^`bmJTCKr93zu($(G47-dzdp9dKhylw)Y
zMp)v22fyeJ)~ayt0{AbY=USXUN3ZCWZ63`0=vOZl)}Ek;+xe4fZ9=);7E*7B`;7p=
zvEB-^6qAG;<LgDRr@2C^*B{-^;Ju884-^fjniIY;Lje|3sj`~KVd426On#Sf^q>#%
zt9d;j8uQO+@WSfw*Sq6s*ofDSP#T>hxE#*KX&f7>BdDnB;49J`C3reF)$XrpFp;-{
zpzaP&-iODt(O#d)HH{%Ay`SS*_7|I<J9YRtFzS_QKpgKis^mPq_b<nt^Pfy(;GE3_
z?wkH@;GIk9Pp7Ybn$G(>O+WVG+KCTEz8~J!4{=pO`7yZ~nWl9)<M5JqB^pR`M~eyu
z=E53u?ckWu>HaHsU5eL+fACCKr(PN50?yXK*9mv{uZ{PjJ{H%$oEMF#J2fM;`PypT
zWf1{O=qcE5P8UFh_6W|%WAB?Cz^7tnhjVcf8~h9w!8WO&O!LEsCDbgyJv%Sl{P9FC
zIhcLFng5O&th9xb7*D;B!c$I%=bCeuD<WnPJW22nWUl7;?~hF%eXPD%KjiiO_UZ%A
ztkPi|PXaM_V@^1T4G4gHfGc%DY;ydr9r8n0Jo~G@i8)6;zWmz&$LmzQzy(}D*iRks
z7aEJY#~C`ea4&9V6Oi!J6AH}8$G47a=Wq$tKVAsk`~WSO0U>!HFGT?QJr*P1AJCej
z$5O8;=YU)flU@E^)b#ZovW;1q+i){%fys8N<hFhM<|4ii!2b1ts$t%OTljrcByC3B
z%=vVod_wm$KJ(qTi&?Kc^ydl`2D0MjZ?Zh=&#}n@=0!8DQHv8p&r+M@@8et7z8GIS
zF&Zb)7{-0mxga2beXgN2rJ;1*|8|ri{ONB02=deLYX7PE)w07c-qO<ENy7W)@BP?-
zQn?D7npnf$*!!2>eBE5m#{Ki~wOk@D>RF-C^<DleuS8rB27eF@rPo$<$4l^z(IS_c
zEXPGsZ>`N?UtX;_ZgZJ^zf$Jtcq%0rMKl-MiLlK5k>o$D6BlqEBID)wOmI-+M~&~}
z+%_4uqjwtzQ2@=Ha<H8>^0|Ia=&8hU;DKhk*k|O1_n{_I9uH|=cln0pZ*TtjER4&{
zPHcw287gJcF9a+RnL<NovF}zqDI0KB;D!@Blt$z%=($8gvPaNi!JR&f)*CuzTeve@
z)@fV#+go<ew;cZ6a$;=}WPiJu{dQyJ2i9Vxmqd=>qGWR@_5Hasvbv||ph*OpvH-`#
zL-x~%RM3>bor^1~>DzS1_Qb>HQ)Wl%F<?K5I|<oT#zK77xk-oo8_ZJ6oHg_!v<=O7
zex856nM1jy;}GBs_{v}0C4eL9N=oj^xa^ju{aIzd^Zh>jlAg$~AMj9Fpu0cA@XlvJ
zSMEzEq<%3o<psDO3cxO)r5?-)EYsE00`^(N{Z9V9ub(`dgik&YwpYN2<N`O3Fe8b8
zD9#q8Sh+Y0e)YR>zDg$4j<v;;ls>2+z?poc8TpH4O$dZEYpEd*56urhpFCK0)BPX}
zRP@L{=y<Eu!Vuy32I@rt=^8!eBzA65HpJkZMJDetQ;N9r0xnyGqjC4~gYrQtW%KXb
zgym{vo`T9nh{~p{ZJ~zmGm3=kXNL;?n12Q$ga7~qfO_`6oaKH4oZ4g$FMT_wmBxbq
z-tubxqMbIAEU1yPBGw+&%lBJ8Jj-2HjYf*84pjqA0;eS<7HgXX`|9n!FRZ<toE$S?
zeddk+ax!o7@%s*qyX;wvYR@)FIq&d>jo{%ngis>4M{EHpm4y<y?6DO-amVqt_03MC
zg^DwE`Ik*il0b$m>oLu`NZ{Bp3j0@xRLPGs-2pvheUx(azZ0sEmq)nKRe#eIHt#~i
zKR*`}Lby()QAa{<Y-4mE=&2brzt`1ZPy7D%Ry+n9wfQSXPyF?>)C0EWVd?{8(rbGy
z;_r`OEiAiOa5I)eAuvj*9=a*7Y;nJ;rh)lmBG4pl^TKjANqV=AQ43Xt3#WnbUy9wQ
zyv7UD0r4;f<3=U4A-!!*5lFk*yL=Nk^jhkL<b*5M`{B<m-b$MqXBQ4=+sI@%QX~{_
zrPb($i>SA#E7qrREomzw{*7qF%e@bN=y?3!rigY5u%ZDN&sBfs2KXXuo|#*_l5Yrt
z#lN%ybF@3G63KrX6vqG4jB;wGu>Eyt3Qte=qt_A%GB^M@(u|;zcLw|g|EC$HKh#sn
z9M_aQni{}$`5^vV`G`>cTpjleajMH7YM1oRJ>SZ}D<rp@OSK*9UE6TU`nPsH77w;8
z6CtBA7!3#Gp+_r=m0OBC-8bU%0UBc1#wNLfGMHWwp_;Gv;~oFakm5as`lt#y-n`n+
z0#H6`)rU=_dxbZZm$dSC*zYoH{QQ|5tszWMg=h7-p+M_bO0prr2g3mqHFUDn&Squs
z5bEl#4dR<o`%=9bSLe2@?Ubq#5WeC-gAqRzoMjYyOnTOOwsl#%zP;sT_!%$W`k7@)
zmEKjpWx|CrTCFaG8b`MbCnrzc{J%V!p+HQ<$$wY%t+;kUsj<&Dst&N=1@cL&>+wZ5
zBPXr;Lhr2CHN*{hU5<~vA#=Uj?jWOE52ZSO(lV+8jjy0cfG9HG1yx}2gAz7>H%2_d
zp8hs4^oueeO$4-Pj$>pvOfv)}TSoy;?l~PxHuE2{cs7jEZ3T&i&$6+Y`)_||jWCpM
zCty4rv&~BcQg1)y8clkiF}G6jlT`83`Qq>QVP^XM92Id0yt~ifb{FchwXx%+2?N=O
zy*d(lp%9|)ZZ+>W!6Hq`zM|C0%INQ8Ji21x_+$zd5f8sP1|y+0MIbC5(k2xo)@R;>
zWm1%Il~zOp_zEwDCl|1c5=3?;&sys}=wX)*eM?JS>OY_8ossMxa1+a;4eT_q15N$|
z;bZk-&sWOUKyeR&BZuhTSF*NVSzmg%oLnZ1f`qVHbNv${zPy4H*Rg_q$M+xIDb^B`
zz+=EiPVN_iBHkNLO+P@&xx3*-ACFjBh`OX^S_Zp$YQqzngRHi~DSs1Cx{3bPzTkit
zPIC-}w6P$!cbw+Z<`Hsf1O5JBqz~$sdu4jBBCt|+3OQVf)Yex}sj|(?TtIemCf_ev
zkP_60c)>?%p3rKpEJGGQ8GHAN^Wv8YJ}h&C<DV>R3OmcoMy^}8&LsGY+*S`iFx%6J
zTn>_oZ1%@&7T^q3DEie1o5|**k%L=tQUHi)WPOengNX>)fDKwy2<V5varQH8gh9N>
zo1L-3a{i3)p^7_?Cwl)cBJXjj&_IBM=y5n1V2J)doCpp3A5H|^MZS)NNx{b_XrwUi
zgb^@e!N0d+q^MS(J(7@N<W?p6uHMEf(xtf5t=8aO!^w<Dw>w6s8r|PDdJIOoKk7Vn
zKl$C=Gwe~GgGTPHCGVQTtfIW%b-K5=zq@xf;~PPC1g_DO&IhyLl~|!?R^Ue(timmi
zP4u{ycd*s?bb#<DKdAN_fm*V2qgcTwb?YqgV5w@Fj8t^x?ewJ}>5%S!#ggOmi^s`Q
za;YzFly$<QW;cuP)=N83HVUle7v%blrlMKSGc$HmkE@Xu;(1tjh`$2x#M~RZ>D<?a
z51?Bv@L)+T`O@+7SL_DwVe_0%7Iybpq`>Ud>C3)pa8UOl{O8$s*M-an<RXXZH-#Ov
z^PGCvfW)4BZ(Mb493qfAz6__F!lj$gh`wl>JD?3}$v}sbye}8qD$Id7^m~;2hOe!g
zDM!!$PCl9j4!1js$nzIg?|DHC{Q<7XS4eE6uaeBjC%c9B^?X5y_t$I@q}B`+WN`4_
zL<`~KTE6V1=@BhMoG!o;Anr+nQ<|k<?Bfa*z7T|LO;BZ|kf35Y+gXGQ8i&4Lnd^5s
z8v%?!)IrV^t1Xfgvm+E}o1+D!EQ*)G8n3uY3t^TPWx!s;W}`>K!JLIe|B97*vH@N1
z!IM{KpM_R`SPR7nePq(y69Gwq94ko*{87)Z$^)Kotn7zLohQ(&7QxE&=zsz0Labx<
z7JtHeyapkwA5CGCBXNT5M_Qbc3x#}>|1OI49B|Yg6!HaZf2s78b89j@ir%L&!1HkE
zcJdN$fKfhzWMrUG%o`g<yN>XlOV)VGtA>&aE_qhn{;1{Nch~n_sHPVJm#a~A>E;?h
zCnnCRX<eH2{0Qw&xHjP2?OrtxWe6z*4y*d7^L@YCmj(GCc-P#E{cO+CL>0o@lo&Je
zUy#2{?C8XUAEgyli}!j``ELs87rKUh-e}lW_WF@f_EMTpLjCA#4meviOwnjk-2gtg
zT&*>!)^BO!2AD)X-r`00#VB&nYv<7+CP`F&+#=~CHZ#2_J^W`le=gL5-x6LaWW+^O
zso2a(r_9T}(_cak=)t3z>3a9VM|I%BwOazJ%F*X{%zVBf2h0vii2qK^Jv~PBIRp=@
z9&(thdndj=7i{2oW%EXn5D*!Tee|cWPs~qOnGo&D<?}iLQTmW;?kULhise6a;)z6(
zI?K{HjV>pVP<JvUGeD>f4mEBy5FhtnlwD)CYj4kY0rF=bgIfknX@>A`KmGPEr(M~q
zGoxd|Z9)SG#m&agujJHpc1V4<ohggn`=&bRm9!q{TDu)6@$W~aYp`r{8r&R~ZD-C%
zTj5v8)=XJxuN|ST=*V*xfP7%u<8;t;PX>ut+$SU)_7DVH>mlu!f9o;lz0nP<pGeyg
z@(j-&416wj0~Wc%kxDjq=qc1XUAaFmuF}l@eHvPdL`yI6xa`1;=|UzuFbOu|7ltvC
zhp4u$ln^ehvIT|7*ND0(MYiOa?9fV(n&nb3#YC944@~obLrWSK0`vnTVAc)|s=~mq
zk$Me_V1JCY^_YSQfM}T@@6nn2-w|pX7-)o1#ok_@U8kZ7=%@{j5k^5;N9|p4SnN8-
zDp?t4*Uw;7-(VW2g|m}-$hFGd8#LYXWL)OTz{#sR&g!tp@NAha4)yAOuV@(aZtay9
z9K~SCzR|3=Qm_aj|7$$$N;y?^dJu>M?*NKGcvTvK?C2~*T5t8;;kXEBgeEA8T2NCF
zrd<qhNMhyMH1*c}v+!uzl9vp5XDAJRn<YL>S^@8`SbNvlsC9_x%^5_PlP{Hv*tMBh
zh(n0-kk73-IEgkO4l-_g`xdd=eTCC9CF4p|wr6<W)<r05$CjZxql_i;Cj$_aGROpz
z36hf!@XSEZWoguRE4FbL?7(d>l(B{(&(V?0dRubbi_1jY@*0l%yK>rJ^)A*76S68^
zduIX40|~7H*M)f9=ZB)Et-r@<8^wb!iqm`ri__!4k-N0?6e{*~U#h>Y3K!AYv;0yS
z$M-TD%~gquFlrQ|B#v?XPEW>PPipWEtd$$k35Gq>qjg@b=o)+3w4?Y`*v|X1F_}q^
zQZaGa<8Ttl_1l4Y+i}=nbZ_;5L%F#M$^{I1q@K;_0^u^dFQsP6A9#O+>dDvS=+OcZ
z;D~BY4SXhJof<_adw<|4lyIa@J9bvQ8fbB3&FYn>&w+Fe$NHm{Y$KH>cSx2i5E~-I
zWZI;Z4KQGkv2hK$`yk^Hu#9e&o+reZAQwsk+oU+*&|?z>@WxoyZ|OIgBkViV4;O3R
z>`@x+c4(Oo-~3%VS)Bk4naj*Kr*5si0qGM$E5=H?hQJ|A=!wcx%^99}ien;^>k*TC
zkje9o$-B(t`_1HMABT&K3n+{W#;9H~E?H{pOP>bg{hv`0FS7{aQ%EpOcU<Ze*MBe;
znmwCKCaNP7!9Ia-9INlAAfIN2qBETV@L~cjYtxxDohh3RGp&IsXS_<i@U&-|dR{zp
zx^Env#Hm9pUyf_-+>s$qbFhLsZYp4v&p4CSQx*LZp9R7&<aM3wvbQY-q{a{Y;bl(R
zB9qzTl=IVFf8=2BeX2hkY8~R{<;Dewm!#1kuG8$|oWR+U2~vtExy&UfZX#o4QevjQ
z+1V}Xh`7N&);l)oeiP<00*k5_NR@+mzUzyQ);#{3Pi5z5V>L~j{dr(G?;XHBcbq?&
zY46R<vrl*zngRO{!vX+flTxQmQQPj@0UOkM1jt|N2`!vbu#_2!=TZ49fWlA$=AZ$}
za;NMXU;&TLKa!1Jo+RiCCTwub+L13X>G$HN(qd?DuJ^8Jvwt^-7^0t=oXSRdUb{ro
z1Yq^Rj!+gXlXd@U{u^bIkz;0k7S*(@VA(-M<ep-L^oQw($CRUlY>D|<xlqcUJ2B(K
zM4M&3s~hiprj_To-=urHGD*6e104c8z5`R{%uv~_^g9NNimR3*-Olo+wZ?lpX`G7B
znn;N$L~L?AOQ6(ZG8tv9Wf>oQi?H6uV1#CVsQ_2*HTLh}xoZAzFQ;TW4!-L1a{e+(
z1LzRSH1wM`E%1}o?VeMl^%)bZaf62GG&%?k(~E8Ha)q2G-c*iMps6aWSgun(M`Xvo
zn5xA?qr{8tc)+(4Vd)z={&BtOWfN&V8THJJ;6@MIi?Vlq*<O6=uv6`8z?s>_TX?yd
ztOMg>{k}Boo*{Eu+I_W%bX4N(@}Ca>$WT-Mhem|vJcSM-U|;$(7w%=G#@(A1diUk;
zu`>sLemBbh!3-VGV&CzkToo^|B<3@C{5&!|YH~d4enbC$m`(G{a0;i`H9V&(gY1-X
zyicH|du~mh6_2FfMLjxp_qSPQkIQ&S;fry4Vt775x#v&PRI=phEBiB=B;JkO!bh(-
z_@23nf09vpLH*g_y7r3t{n#1j6KH>psr>K$7()mpK|5#%hV7XvE1qThsB91?cy02-
zfT6b8)|or~j5I_YC@&ja;^C~XsdlQflr-Vq0D>M!YmDS2Gng`>Z~tdzkw0I6>eH)P
z>CGAb(<;CUxM+sD)ta;XSJ&yc9~D#WX#PUYUv8DleXf%I`=D!BBew<A>zalS?nhZr
z#HY*nOoy*xEs({~;x2EL0=}U9!p_y*Z<d^P_iI17g)kNFN(*wS`q#s?Ah*;kDIT!c
z5a&A!$8Evczo<z>Dg)0Ubu$?Iit<;vE^Vi<O@Vd+4W+mBc$e`zY0PKL)!py5`?Yc7
z4872OZf2rk{?YW?47^j!Yiw`?d1E^79CO*1?;kC5ibEX5bSDrq54y1jHZ;FiwE8bK
z?!AQNLXZl`Fb-mq;+(Mkg$nvt!gV@LF}&*fm#pw*M~#(?lBU>pT1@B)&EOI1(zA)_
z;+34Cm8(-Lxt~|^wpa3@U+JP>3lzWpp5fH*P<w{}_jcZH(D+(<g>Fg9e7Vp-iEDnn
z2|Z4`u0<dF-oX(I%$Jn~lqp8OgONvFA6X>-n@*(uxe=7UVsLx1<W5G`jK=C+)7<Tk
zc>u;WqUlyV9AcQV1avfa0quu-TDHv{B;wOD@$jb1Z{q~F@D&N%F_>XE*Ryf^zn$Cy
zs;wCet{O*;(!6hd?%9@}ndWp7?|p8yX=>`6pbQ_;QJh!6r7)8y5uFlsBwt1KWa^w=
z0(vN(FbE0{IesbgwBd21hYualYwt_4s_j>gHc2orP(x;2%7{}Jp^%k;80p&94@8Ok
z3PJS?NVEDhe`4oGPkSZ|{Av;&M*jZwO1M$WAZY}w;gyGcvewl>x^?tl*xZMo{_${m
zH9e){|H!H}81U+zY4r!eC^+`)4lS@_@@k6L>gS)-xRUZ^w?86K*lSKySqLwZD*MvN
zTbb&z**S!U039S}i7qcBIB>!QvRQD6ScJ;$dLjiw@4)tc{1iM7<GqFb=}T!#{QN|m
z*Jzg%xL%h=FW7h$jf4=*FxjV?8OS}3Svib<zwUx-=2ZZqqe+e*p+3^vP}F*Li{V}s
zPHx-caP^!?Cr;u+xQ#}hrxC8+U3nf_P7y4hPWRMdrHOai_zXST7=;F(R-*n|e-wK^
z^Cs#IRpnc+Lu&ko2GY^&gluqb`{%MpiumWdR3~#-B5uiH7xspWLnZh|&DCFu`DadD
zhwDX9Jx4tsw;;QkUCg^d?Fd}sy_}a&U?Ku{tNz9GvVr}LEswK<!VkE|ksFWTnMfqz
zhVs7vJ(K@d?(9vD40@rfpe!Y>`dS39c64RhKJ}6(!Sn2<>h$o@D@|mF&1?K)C)jUG
z#`-vV<Sr4CA<ggz=W;iPS?=I~j*&EU2a0YMhQ97bdY=xX<gequ!EI5QN2PLq%C)oC
z&^=8^TI!B>7oskSXh$luQwayV{BtLjA<Du`2dlm8#sEG}U)e1cY0gLU`FQ)-**}7R
zAOVe{X&s^{BD;%>;KgQk&~wfgda%Tl(wA-Ej~fN4p4zDOG5_px1Ev(J{+cK8BMIZk
z`vD5(*`;fN(ChVh3?=><w`SaHYuan`n-WDsuZuwcX--dS0%&+L&i_q~(thjl{f9RD
zZ65oN!uH$G??0yQca-iwsoU>-yx%o^>CQ*c@p^K~j~S-lvEy+NOT)Vu#-2u84xSl7
zj)Me^By1WV44gUW_K-cYn!KuB#Sxz9z8#NRaqb)9)M5O@ieJ0|aD}Kfz79K8KH{53
zgy6c98ZgG0;eX%rXHVB%{)+v~DwYU6{fj@Kws#z(aB^qn#!XIdf4eHw+a2bca?Bb3
z*#5Mmi&ds7gwek6Q&w&t&Yr*dKd%XlqLY(K&5no*hO%}>W)>!#%dtM}x~HTVRQ1<`
zJ0jItcvv>ZoXnVeN&;v)c_R?zaI|?%+TjAjIs7YPfF`Kq(iFad8oDZZJYj8RLvDnQ
zvbm-nu^D`H!dg?$+5Er@>&o7cyMLZ%c@V?eO!DRg!f@XE3v3#Zdesd#^<oy}i+<iN
zQ9H>SlgM>y)vVFxal-f2-)hs%fy0rIqe?5$l<n{Z4-x+X0lYs@;Z_^|_qjuOnhfsJ
z|DCN0q<aRB-)996C5)3G<M8`ILlb{5*=*~KJSKz2?&Y+;dVYa@X16ei>8$SEAYcp8
zFajdpmW92&AG2@pV-|YKj;$xehj=+2wB;^Alyq&5JN*6&(zAmF`nLZX@7&Gq)tE(H
z)D2ho==9lm{;MXxz^-GFM}>&m^tW<R^3=c=vP699KJat#`p=&%Ga}nW^3=KQ-!617
z2-LjP>&#$!sbZ)|GF+Mc&M!N)Z^BEqcH5P@SJ5j64}GzH%9DB8y_8=kjX?`jUY^%s
zx(+5R^+i;k;cACmK4MpX5dF?d7kT!mo7SV<ec_JKNz-F(Ryp4o8?NFdgF#lnUE#?w
z5q61(C(pCkFs+3K{=)LY&L^(vpSc+5^)O#Ia@0`iX3}SC1n^ur(NRQbK}C#wDJjXr
zk0e=SlXP#rc$stw((DNQTo*H^%d0NFIT0Zau@6bU!oKJ^_i06?;ZDWHNc`Yn>sx(y
z;V(jGSDt=+m+<Pu<8Yv4NvKEGMZE2U*)<=ex5l%J<tNLQ<<EzjE>(I9UyPdiqyFff
zcT}TSvGC-oUs}~WFOpE~?>RGpTUG%{DbjAkr0O~6V~RP7x`9A|GVUd|qdDcfEhAeY
zH}`<c1l`LL!9q{$7WEI_<&}zXE%4R;;Chw=*_wZvL%($jDaPS%C&2!$*XMi!;ZF`W
zlBw&~%R;prCD0l#O>~diIposLdC5tQj?7rAdOu#t0qZ2Dv~ZnS%m{MHE1-rf7U!)j
z?1c45A(w{epIbWXSrz$Le>xzohWA`1B#?#(y(<L>L>5&-kF(6Hp%RgEk#6^fZrn^p
zL`Q!;+H2(58v%?%ng>l-Od(F>BBAuneKtb-8|BovUmXtv?I*Wq;@|k5_ncZf_iDyB
z@`}-FU_M#w8~b-DK;^I_&jWiXjoQHN4zlH2Jlz-KmuCNNu^&F9?s;SkHQ#5N0FTS|
zur2#P_P?KD8@qUe8TI^c&kV)pllOkOI8o8~n7j<aH$t@l4eN~OO`WL^SQB|^Qk-wV
zipN;oti{283773Pa~&N^U;fwFfA87E)#1PWy6l$`5bo`|%{VsxlpTwxRdeXgV-ViN
za7&1#a-YDpW{RQ-lFPNePo%XuL-R6{CrG(pVxsw|nuz2(SKohZvzcmofP|Bk2atj-
zG;0%-U}61$!e;`HWIRf!A2g`!(n1R@>pwQel+}(aP&?Z}L7`Fx)vsmbxSHU_3Myf`
zw}SafQz)YUVyLPU&g$nn*fA?|d}iV}p3wDb@mK+31kkD$H8P~f#WrFlvn;w_Z^QPp
zY<T#)vwGTOAntG_&qj1YejsI3PIyDuf3l^>Z+>tySPV#=twe+hTO#+I=`6Eb<I3mg
zpOpN(><z93i?ZTu*qps?erR#Y_Pq)d8{FVOx85rMY|93Dz@U4TwN}_TXBe7lb7;?|
zOY{l^1HcpLIa*!e>GB{TLBh$ps^F&F6Dw2Vixbh2h1bWXIWf-@Y_kqFc=J8OG^`Rh
zSI6dgC!bLCg(8J@UvJ3%V*=B@{C=#O@k>agJRE;n<<0l6E<BGDS7Q7mUI&%bz`4e&
zEc)u1#TCH?muIP}d{wZ$rot*{L%0<e_9_qz7FV@eluPO52?Q)fVK?uH3&(Q@!-ERx
zCL;=e#oI0RoGZ}3vt>onuSO8T65TstSebZkud7M9Ke`7z-`cr*5n1mL`3P$djf-@{
zrNxHT9S$S#=)}{|rQ%RD2bQ-LdVZ&0`c6HcVwcM}F+o85-G(oQHxL@<KZanfSj*O7
zO@fo%9_at7He4q;-KV9CK?9DN@?6VZ)~+sJz=!;lktFKZ%N4h3j1ag%JfZR>51xI(
zyVW_v-%3&>CO61dta&fSSf$aEwHROw;c>n`Q1r9%h>DNOY>42gV{8Bwn=A<=A;9AA
zGgeVz4TjndWTS!aqf&b<{O4yuB0Ve6Q0@fIKzOyxZbuB(rT0t~YB7EU4GUpmdHiPe
zWn=zoP%Jm?0!N%Wpb{%)DM%=#@md?(PPpdv2xwnt5HHK;GTHdbu1%zoTTb9~#PJ&#
z!mSDnFu5kDWu@AF^RU0q?*hax7CS*Z@+3vF>dgkyZBNZ*6g_-rlP{;foR2FOpDc$e
zJ|!-s5f}4sr*L^zT+jcK+zOv`W;YIt_t6cO1EhZUrT5O`f|X;hvkNS_zLh$)GBq|z
z=E*7BV7odlctIA(q^Tw^<Q*42uauF}FExe8OHDbCdU-Q}@+yV9+kdzC&lU$-CZ5x1
ze=#?Mpzdd(K4GtnD<J4aGz>EGfhAo4og5fbply}g+4|7({)gI2V`29%U&MY$X~t$>
z4u7m#BXds=7Enhm^$P0zD87+^H9B@G9$+T%Kv-HH6<z#K8pT9TzCa28T`xMht_|1>
zem_6Bo>@17YU!rcsr_mC$7^CuXzrYnr)IqGhC>i9ynHB4X@PphWVw!=jbYd$ut6iw
za8Et!z%4oEhfHi1_l!VCuva|Nh(6t49Q5;^U|iEo7RvJR4cJ&|Vg?6d=sW?Y&A?D|
zUkX(RT<RZsg?*_b3X=HSW3R#&8%!HReoQ!lKYqX#d)4(XD(@AC>>o}6^D7t1`~-fz
z{bR_nx-Odi{qL~Utr+@ox-Kx5$XTlWf%o&0*SCtUPT4Vu68qO!+5PZe*pHW1o}1p8
zg3b?`{TTnzsOyJvX4xQ7S{EKYzxM7>yxo>%bP&)Dx7;iU+d^#U<cOT>L_D0bQ7-nP
z*9jT`ca(7k7vG;dw%;9+|L5}3yJsSSv})ltH{4e+D?i%YsO9e8J17&@nuWR7vASD^
zI>5g>jVE<X`2P)e`};j<u#<0$-Ef`yjm@;93w)Di2D@-OaQ&pow#qMa%=T~fQ}-N?
zp?-9<*{(PoJ5P}M#=$W+!Nve$Csj=NOrw2F-9BzPe_DLR=Xc{hK7Rb=iDHj#wnsOo
z%rIU+ckf1kgTb^{;<y*EWoa<m`|>+@r9jXx(GpqHr&H-1mg;!rT^_dkn1^y-WKx-N
zuo&)gg~f>biJmF23`JF0=v!icmj*-dGb{6%<ACIBx@;L+PYgr0iLEDKLUM;~#d+YF
zfPk<lsIrn`_9?wrqf+7)QnGe_?4Uw&`;^o(r1Vgw^lRj?smf#jAZ0#R%KSjeZdb}4
zA`#Fk1Rn}1T7?uH6z#ws^M8RevElxd-7;w%A2%THG|)uDDM$_|lw@3!Ua)(@rqSf|
zlVT~eKB(r|uU~^wZLE?@v=V0o`pmuXz~eh+bMefD7<s%k6Qv~y(Haf3IY5z8a+o+O
z#hik^Sf&4ggk$!9)a&0Cfg}x(2G$^hv!m)pJc)Ej)2y|UAEb#=trfXw7l$iI48#~*
zRkT?6R8y^?DksunfgxH*3A56rF<`$rdmx3Rv$d$RRc)XSqsFl_6LUJ^GO$yDwu$zd
zRaVyW@|vxV8rDmiPR!R1H6(nnmNibNPwrSi5VpS8X_`YGHR8BKmSS?9<Ebf3VaG$w
zk0&f1pRiU;z&RuYJCcH&>~IdPiv|`Hql-&6x9qW7Y<_f*gN&SmJHMuMjWaz*QJC_k
zjQ#&NlSr0|csc2Q{kZ=uCHWgUUWv;dnRkMCsyon2R>@0fZ+WZ0U>89J=g1nXK6zYw
z_32p1X=~gW(&8B>$Z45smrZ#zSBP-NqS)ksDUZzngeci;38aukyXBl5cu3K5Kv8-t
znyItH%C>`8E|tA8apM7KpSOz@Np23IB|%tvkbK|gNF$WPtsp~dhvTE4qxNc|1Ub%H
zFIY#T2qnSRusQ|7u*Bxi@rUw(s?Lw`>AK30(YX+^8=C>7$7BSnEyK>Nzk?0O&hC)4
z=RgsV9#l__)Y|C(BaTum$u(g>Q`n_vN@rl%*mec&y#+0!8sFE;?$B`ZoRamP5>a*O
zv|_N=)|bz5aBD~?Sv2%abX|aC_&G%Zc|OadT>Xq5kNyu!<?bctNiKWUFUlRbeMpa(
z+ps=-cxa8RxgH8cI{*X94(<zQHMxv`gpN#x+SlTujCk_*YGd}4qe2%91z8dFWaXGZ
zN{nh);+Q<fPUWOaM3nb{qo1;%Egrp=C89^u1d+^kEcGxe&gOUAMCBX~`eka^Bx~5-
zF~AOeY<@=&Q4cmiI%wVh%S}+Yi-mleWWDBLL&$bro}_9(=#tM~RV7cPk4v}}TrL9@
zZslDcpsK1fb;qBtu|##eaSeQ1*|vc2%7oq<l$WFL7lFms0;cYOIQ5Tjzh{M_9>8ca
z$}-Mg&41Py6&jK7V<mQ}(O72S_*C!%i-ux996__e@kemc4^<tDh~n+gI++56HQQ2n
zb<lyO5}_`n3U~f6!fxcX8KoancK1nwrN|8{0Rre<Q-+yOzt{l_BGC3NyE(6WB1(H<
zA;2Z9;))tWCo<hBI1#2=b1|y-idqRs?oK3xvZ++Nx7;gPeaHP9964rsqhEAgxha~%
zI58_;ls#*+F~Nc>Yqnm_sY)2qr!(8{RMvOWU+!h++Hn0UJvQ*9;<vN+7Yj#MqPLY_
z*g;+!Ma2ioHGiymeJfH<N6E>cVNh`V)j|J9bTDa&Y}RITC4s#{Msaip+~q(YudtGi
zp4Au5w4=S8PRKle7&WG<;IkdY5Nz@uRp9s(GN7nTGFc-Vt$uQktlW;NHM%q4wDxun
z{$UCHv5fa)6E6@xYSz=&Dq|&pw$)ze{YWGLH7EZgcbZt=WW+7aMSIaj{fZPez=sWq
z=FmSFScwHWRNc2H^uMW<d+|ek)b#5c!LKb7p|;!6Ek@rTENEJ{1rxZ`;=FMq|7d<!
zJ-f8o)F-OR&o)d-@vUpljgGeHmt+UZtbb0vHe2El;E_-MhrBkT0{CQG4D=7pkDbKO
z_ndxC@~O{2n+^_@Dp&6^alw8Ds{=oN{#vageGCEkwX8sB(%#Qc!5Uk9&gL=$i#23y
zPw#zo(u7Qga8o|k#0kANq+DdVa{xB*2gOVG8O-vZ8vrYdb8y<^*)y88w%541zhU-*
z=|&F<KHo3ci*B8Yy~d}-qZPsbbHV9zc)p<aeLdDs5J$mdTzze4%|BHck_Zc#GEQ7v
zy7W@7><C-(dYwp6i|BdE8$Hx)9!~rmPNFmebbA1}J|L;oB2~R6$oUh`^G)h~i?xok
z6d5NoqrH_~FSy&7kJgY?YN7D8B4u?@O06g@9l7JJa%MX6Hm&j}TXp=f(#+l(@oGu`
zgjIaHG?An&4Ay{yY>!wT^FEcI5f?mll<XmDVXZd8y-1klV<UB`Nvx#wS*7VdbHXN1
zOS(qW$lt4A8Q~V;aEl6ry<KOpz%&-?PuBOh)Ht7^X#P;&=Al0A?2-JV!yNu2NY(fM
zr609o)tnAEDa8U0(LW*D{Eld<jcFU}oDC7Hegj-CJb?81rBAiMs+08FEK?Z$s?pkE
zXsX!(2)nb%Jx{_dfxCL-)o>6KO1eGBTup|eeQ?%Rm<&Gz8%j|$l?M!Y`n6NQ`XsE)
z^Sf5jY^s4^zZFvK90_ieh#hHb8{e|->3u8zkA6pNNn+v^T#V`?TO}HwAEQ4``6y(w
zR65H4nQVGLz`D;O`>v7^BUl~b0r`#^;mcTg3`u^?PFwnc^GLcprVo8%%;PQgOp^nq
zXEXaVSr5}EPkba7o?-nTZ1*ds4CKne@1{HKwx8t6VeW7L+qwvAOt8^aKj*MUK|}h{
z2NuC^>*b}vh;XcUG|M7)4GgvXtV<X++R1f!K!4N5=698=(hU#DZ@I|@YY&mlq`~u`
zL8LP7w>jjA&lZ-#=GRTaPYxV~D3KfvQ8nAvbBksKFjI6ub*DedpMstn3^k|d&t;?*
zC38KMuUaCPz+RiK_1D8Jusey)ZIoBf`u|9BC^AXMx<`>cq#$vSIuA(3q+e$;U3i6L
zAk4kXv^e4iQPN}sVerM%V{Z6?t|fA{`9Ss$u)aG*ZjPiQY^l{_A#XllxCA~EwSbZb
z>!*-)=0In~D58u<$E7V5rLE4VoyWCxSo@5bF)S@?-k8;JTCdof(zmgfdyNP-u~CmX
zH>yO7SYW^Ugv8hF(&2a$e}ac_ZFE>-Kr`8lY0)9vZw3jb`-68AhH^2u8n<1Y9VZj{
zN7&i+qcBMx)}O>8>k?^bdAJ=59Cwl;>ho&rMl_b*Z`PBDTO+lNTb})?_bvFio$zjf
zJ*0|7Ry_mJ`)moq4xD54BQM8W>GhfJkhh-gl!fNg`FHP5M&6di$t1RayP@Qv#buuV
z`=oiCx^UJ;w2ii#sB_sHZ?v58<v051T0L{h)xu5enEhRg6zo8f7LiQ?(N!o$sV^mK
zA6OU>IdLmVR1QFD$I`S7tXbBl71#g5JN>wcmG)Yn5t<{nic-IS0aw#yeVMIYmX(E*
zX9r^YpNQe4)%*3Q&zUxny&VR0mHDjFE^;Q>U%`N}mRndDc}~)*T97@azb4q*kkm#s
zz}qBY$WC+Y2p_xs9<bk%B}&@q$ro^3)dhMNyM{X0Pn;ad?EARW-ewzv?Y4;gWpl@z
z5@!REpBs#_q^QgdCX#wxd-iSP+OErXW5u8LMnRBsgW1Df@X+7oC;1Ib+Kx7xC2?Qo
z{4~lsAnUs+GBqt0QqCyo{c+x@2@$p&!KdGq9dL{T1H%3H2e9HM8QS<>=-IgYKP^wM
z47*BqoR&|)9rQYlSm$5*wb;aKZ~!(|@6tx(WS&dG5r<6UI?APR$A7ZGh)G9@tNqWa
zaqrVk?DL#ZKMj#b+aO?yQX{>{a0`q{UJezj#3Z2)c5<amafyE{!&5oOL4KG2GTN~V
zJ7kruK6J)GA<MQ%4nH6Z85F|O^}t6oodrNjB-oV+{T)_@{J7qYgMj>eu3*P5sCSHt
zxb=$Kv+e36PP~1IU4POk3(;%MGr*8Kx-D%AyKQ%#y)QL2hcK3Z-qzP(gDbjqz$;Zq
z3F6i~Kn~(D%_UBNqUg+rbrr;B3L9Pvwk=e0u628IEyTW5D`2R|P$;<eGCTiKIhEZU
z2w`pBvk3oo1~{vS{Q+UP+I6Q5!bNSx5G8#<Y#nUM?I&5{fad<8uZrN>nPy<^@R5sn
z^qFTFv>w6i=`a79(zu@k_eRnD)3#j2-;EoaXP=!pnyr`Q*jCg>vo+0*9oLk85?9nO
zkQE^mhI<WlwFXI!1Y?@5<SX)&1Wx+e;{%3EPFzopnRy)lg^xb;wL=TW24`dby7@f0
z0xaAs>i@6kOy4CaV&Tng^xQYlv>iU|kpa**3Sw@)xn1(}9k}NghgyKZSyqXf3GR?E
zU=CSC^H{E*8rVJbw1x3EtGk5XNK59-qW8cg*^y@tBzO$|Io!}dacMY2z)5=AUnLn$
zbY+Q6i(tGE2|DgLDB=}8J}4G|Yb@>D1M-w6K`cfcgYt}fPF5%Sw5pL|&qw?0I8d`D
z5j~=!dN*+M>uS#R`}Bp<*4KM=W)yX{#?r^JI`UO!#7_Il?(GjzNTb+`P^1o%E&E2s
z>la_pnKcAhUV9rBUz+x#SFT;+PlGnfg4Z!3Cw2QtZH?Z+3nf#N@fTr@w5na|t$zd8
zCf}aK@}6=l>A)7yu}%s#c^sUpOI!e-*S%vilZ4N7lY1$dCOARw*jpx`3;dO))ZH&)
zsCLBJoL`xo3`{^zxSZ(f6q^p9!Nh}wHqo|nxq<?nKW`t1g2>NlZ6iu9Hhi2^6UTU5
zy=_o;Do<tL5Zm%&6d!Wr6##mYb<7;ZqJ#2-q%#^O(+Dx1rzoPy;_pt`d)I1Ch>zY8
zGomSj@)KV>CWu5mB4jeOBv#3tq1G`UmP-Tjo*2ld&MH-=x^pwG0kNayhLw@u`a_dD
zuxhfgo4D}eD#5_v>#6D=8`U)7f;s9Buiodbzr2Qrbzc|1d-nrnr8TFrd(-(`r4Mn!
z=w?t47rD7P)wK5e`HxlFmCik{!)|pplVA8Y&kRXa_CA8nd?|qce?;B;KhysoKmO+&
zW}9J~(;Rnj$hkR7(#D+0Iii^JoDU&HW=?ZH3#FV>Nk}D?3^`SDPAbizqSQ;0DD3O~
z{aikm&*ic|U_U*ckHhVLy**Nt3KsrLxSn{mTT%QAho0F~L~GWUrU*S}h1}S_(zjbv
z_O|DKa|kAgN~JMq>DOl0+PRO-j}yM1OYVX`W%=%rs1nCpJLPF7BSEa}#MO9b(d1~h
zMM2HleVkq`rRn27rWDzcs;`4yTDq2ORMhOdxyLlkHyw5~#)ZXZ9>I~@YJYr)HFOv*
z<-GCHKOp_y<)?4F<Y=wOEi@tCd2zTEH0a3?p_e-k_*;)I%#kFO*Xr|y6{br0A|2BP
z3h^`$vVt*yo2<E_%Ef`oi|{1((0DXfeQ`$JNaJyOj!yF;OvQmydc6^)I?m)zVf2&K
zN+HLG`C@#rA5PYgTGP@N5!F;OwzvtQtJf#Eu4GJRQTT=$$5Z{Zmc=G21~0?E#KINx
z=clQIhshP}?l@S%TO<1~az!$Xv5WzUnUjL-6tScnH}D$ia4VqrZ<Q@*E$hPXNKh{-
z>s*mj-@Up>BcE6wX#n>ZLfoE!<txTbvJEROom-2`@X%WF5(4t^esTHz&QGe5l~(6|
z6kmS2_33Den6(#wNyT%m&+0{$)_!Uwm9L^dYu1X{1fD9Xn#nDaSOt1cYou3T$)kCt
zM#iNPzpm&cHfm3td0}d9d}8HHrsB(c2xHe}@g@j=7-3N%L8l&F3&Drb1*<)cj?{!)
z9f^P?ye>H`cIWYHCQXUipN_J{4KhT<azUklWa^PF(wW5rWWH$M=Zs#hBM{M5RH+C`
zPOfpp^0<<H<)sePAbLP}m~z-nGT=t14n0on7<pGA2mDVVV9${dP#pJR{{_{^uh?$2
zq2Z>r+^SPRm9tfc7U26fvx0*HtFiNuln}lV+7m4xDeNUdX=hmvpRtx0<+{q+b2|6>
zrt?z{)a@aeVP0fyE(u_XAJ}CWh58(J`IIIdP`NA&ki5r*aL7T{AmRP^IAHF4ug{n2
zln%3J8T^iQ`Q8$E@`cPzrG{H|AHD@oQBRq#GW_k|LbVT=6Jw*Ft#*g;9}jSl;u<-T
zF*}ICORlL#v|ytK?ubi?;HlPYrMM$}0T&y-O@0{^dhkJ824Jz^!L)VETAOr4n&Vvm
z4;`KCynLaSp9S$-5wg!o!zY{V^I2k|Pa$&6XL+;P5|gl)dv<ql0meC$?S#wB050IJ
zP#vFUx@OOiUU2ASc9pVkG)6*9&1jFQtokxLaPoerNa`a8&|@cjWSRN7(9ZX-y1SU#
zhBC+=7St8K?65U#Yc!KHH;>R3n~ktMEJ8x<?)Q@*OcP)a)WhDsTmkOM3oOB3Ej+7@
zYvyatW9|(pPjld=6)N~5Z@=UHwcS%(1Wq!;bH{RF#bMCHxaoU45%%OjcgmWHFPtjs
ze&My3PA5+!mq0aP+WwnxM+l?)aD1PhD+lU5-dtCB^i@6Vz)v-0*TC<C!cOn{r;Z@u
z_k+fF6H>)gEYF|+W&`IT-ceHQyNY~tMwT5a)BV2sw#E1Px|7OjgOHR+zDF;D{4P(x
z&Wp3S1#W+R+vOq$6kb09DukX46}f$Ij-Y08N5c6=xtW{C@XgofX8i8Hi+)DsMsE(J
z-;NfJ4N^!IXYuf97kV{xuBm!B{#`o8#>0b})7{5Yz$^t_)??Y|nn2ArpOv`o8hG#Y
z-F2tNh8vhVBH=nKqO?eCkr3#~-IHH6eHAWBOyiiHMq25a7x}wBJ!#l|DE0M|!=K-u
zKlvXUJ0`vLenS@*R@)#?bi0>)^@5J?>F8K1x=0%BlX&WPYHaeW0NQ^mI<B7Q@4jA(
zX?2(UYNY!w=l`e5IMM^13e+Z98A|2@?E8|*K_Pufu}_T!Ro&<ReFR~4(x2FGr0edz
zoj}#}AHDXorMw?=@HTG5_S$CI!@W=H*W+J>U;9=4XYUIMlQ2<mZL9H_FLK^4Q>(@m
z=SJg{DjX)oXr}RnVC26#zfP#=0-^F*eZmO>nNvR({`6i*+pq~=J(S39Q2r;86>90s
z^_|NV<B={_l_2PiBK#iyo|7@+?FXITeZ?O7#pD+Bdf$M|>Vn$)Jvd12WbcpYYVF-Y
zRi7oxVqyS&>mPW*wh*}<YdmEU<MHEio7u%ZuLbWV;o($-TR(=i>W3Z2$QBwXjUPNw
zM&;uW53q2p+Nfb_vOb6(pz*V-Y7bM?Y!8lIgOu*mM#~7g$R=*((g-KXj?2PMUJ0ba
zBJ%AmMPJ&$&?6wn#s|s4Xge}~9vfFmnx~|m)t8m`565{gV*H<1R1|vo;t{2dkk#er
z-f_$WBHUgLT2}a&;f<N6X_tOJEMyQ|Jq3f~(5)ni1Q1gHHu72sIsqpl>xJX56)CMn
z&w1@--{kv9kY`~rKR~!y&})%Cfie(+TOFqXI=qa9h}4R9fyC>0a60XRC)I__)Nv|E
zL7sM`H|eJk9T5Z)L@Xg?)B$<>?CJ5xt)s~4#umIc@8<zXxD4Q#t3n?NUNYe=hk2un
zV9m8OR73?kaRNhAm%r63HuzbzDkTU-7vp8bRIP|!#a%>2NWS=a4uz1sKZMVg<KvSx
zLf|DHwo6=SX98IM@<s8{lw)&Vhk%yN0ZurW6Z}dMx4NNn8YBX49^qhlj@F{-pyRT>
z=w5HB{94h$MR2+WX187KKwbA5NCh8-|3xx_)rW2u$sqA^;ofqQ5wh%B**A-_oB)5c
zuLB1S5k@cl5jjKg!?mUG<2jV19sc;H!Z0vgC-KsJ3Ou0>{&`)BpQET8lvPtl#HL`|
zm~I^ryeVrZ7yJ|=>xBsrWp+x;PNwuggJ35CH`}55Q3H6niD}*Rm_*@dL%hhPBWxCK
z`_kk%fQ9R%h@^RqabTria^cdL{>>mlun+$~Ybpmtc&YK^0m-gBRqBa4kjqrqa_H%_
zzzY4m44ERltql-4uhX`O(bL4`k_f1}Q=bd0wn6HenfoDv>h8a^k$4>*8GahxaN7s7
zag<QTCxfUPLwRF40Iet)z}5zp&EbQfQ}$|64ZW(@RB%;|M54Ty&=PRNzJfr<R+Q*G
zn8I`m;<8O7*(rXgKG;&D#fl(q^&Vxq@dPL9gkYcdUW%3i9bKfkx`fjwFx7EWIurul
zoT=JvN=zIO+yrn6AOf)j9%d98og$Z~D5)@{v&oWI)54W9<=O6&1Y#ZGhcC`_3uD=N
z)LsktyM(DD!IlR4VWl5RL8Ax`zN>V}o?h+%I!uNGneB}fGO{pM`4q(`Kp(=d&<sjt
zf%#s=-j0e(eHfOt&cU*UGKU%uN|rwjE4XCEEo&`^7iXs^?BS5Hr600cF&tkkH@yTH
zo#se9PPC6NBx7~;rP(x1fs^)Zm?i0^0rV_kz{b3+8(QH4Qrox)YASzkpPhC9<}VWW
zHLY${7GofcQ~8Y{+*i{P#*Km%6tqt<t<k4RVTC3JoUBupa)9h-uaIT6L3x~qIo78Z
z)<AKS)&R;g1LhhZtdcZ~zhVq<h)$AJ>WDMDlFGZ?VG`gIKihb2LGH{aKWn)<i<g~2
z({h;n825Lp#t;sXGc$vKi=_3A1oSZ_K5*k8L&kxeyXYlN&R)JHTuASd)NuOANPB~1
zS-=1nd4Q81fbb;Ul+?L#z8CKi&MAtBl`3A8Z%H?CaWavid-o4|tDiOuqf0LYofBIZ
zEB@KT0YnAOn04^j2R>ItbNB%?zE0f5wpzYAV_x4GOsiK?1!rQ*%DFBaVgTl!4E4Kz
zgC3C@F!3eeZ2+bddWi~>ZJtduP1CP=pl0f5KVs}@Bl42fi_~W#5w*U4pLy4@0)znE
zG$o5jhp*Rs%m@s5u^r;F5?Ycg&)(9JjRL8NtA}u3hzP7hh4q1;x{<=7a#u-WU5oPL
zpit2ZQHn0OFgkXWWT$lD{4tln5S$3A*6R3$Xp4u@Hh-e+bz___#GH8;bM8-!mu~ET
z&itznGI~zsy{|!HUp`*yMdC@k4|*@`Q*n|^bgT<5;m?IsT~vlktV?M1l2^il;x!Hc
zxw<Cax|nb`#Wqj|z8csj&8O2-T=98Cd^144u;^TKG%lNUqhl*!*f?pTKi);v>4awB
zKsIh06cT8x_p4U0Mp<VdJTehl-wBTN!Ha|$A+}la27zIxwQ)jvUE(_!>55DJFHs?|
z8w9T#2a7pMnsIaz+B7bWy{P2^H3IG;6o)k{z>89`H_QU*`uimQNt!#F4#$E*1Lra#
z(W%_OT88nM-fSV1W?*X$=^GxLlP4ci=yfqm=xd)iKUazu9novVi(kg{-jZ$G!E|;-
z)AU}Fzr`P<<ep|?K6{mHswo~zdrw<NTmnf*enLP(j);>)^O@-A6cI@hj=@4)TSreW
zs=9Rja8PV>AU`dv<6Ggy&DUl)tBX)miXFpnlJU~mGsQ#bmkq%WjFfPjqR5qAgQ_@K
z3J2}aOZ~5S+$GT2E|$Hpkx?trOwe1~_xr%6R*@21v6CW}+aY=lx4pz00{oUp5yPd$
zla4=n%m5C*e<|WkOM7F=d6i&gk=jM?dKnI4x{0z7{fHE0QJ5$XY&27Ll%+CAXvBRY
zgJ?0&JY3Z+2&%n_VV8Nbiq6*yrg@=ROtmX-*QG;n517`(+A{ad<p1s~R8%xRVBMI-
z@s-ozD@UXgsDUu;lPAv;q?LhArpGOvl@7JJ5XD!n<lG;cHM;yj4<O`y*ey(z9&Ut9
z*6_obf+}=u?wrmNHco%w+Ao@c2dSB302AaZu?Lba|K!nDcQoF=;g&bA<Lx|mi|fv0
zalozdci2lrU!2bER$7x-ung|YD5|$kV95m0i$}Gx!h>)gG|gjwi;{282COT63%Plj
z?J^*~y;yNyf3=WPTFYk?U@2_k_I-`@pT44u7=K39@ej)gt<wxtNHyz&_=@HrL8IfS
zjV}#txA<~QG~`kb-2OYux7^Wey9ZJ%>cd`nv44O=b~GcymJs4!FsE^W^6%uK!Uxlo
zShUEu=#hp$`WT1q&SO7df06zsIehq^;)effHkUD4DV>sU57*tA=;xUC6w7^*cmf_i
zn}QvMou^H}sPb0!R+n4cbla*ri`?JR7lnHP?H<YkV^oBW<BzKokkpw9s)uaKV6sUF
zI1T|PA)<AF({@+}3&tOTX}|#wh-RNbDEOhgJ?P&+4=`O6aLuG0X)R}GQ$B8d$6RAB
z1YOqI=~j+c=y3^EI)z$U;Xc1)TvCG6muZzj6M*d6BTE!*4h8ALyQ1`fggIRO9>`o0
zh5KAPwoqH!l3OlG2Mr-~HT)6|xCi^!yFTC<dMdcjOtk)>P6I1rUs!>T(|=#1&GeTr
z9fh6!F5QXa$1ch{Kmf*9*?&ZZNz&`h>~al|SO1`XXulZ5EaQ>E%XutH3)HWyit7Q8
z8cgJ0mNQu{W1Uit!2g!LpvzGce4DpO^yzdede8dAOj!ir{B%aFW$EmR*~h`{eotpZ
z_h%zdyopJA6aVy0(*B#26LZX5$Q<_1YM5Q6SWM7=#W$_z*wy>8qjy8E-Gwcgz)TB0
zp4P^n?-y@Nd3T2?=(?08N(Wzm`d)NNPfS4{Af7{VNN=CkJ@9gI^iDj<cm36eH*$+;
zfW!;ASLDzP$)-um8zWYTr`dQHIVMtN(iP7{LY(Em6-oB{3yM82AlB$A1b|(_jJ<X1
zG%lf}8^Y}5+`5)*3}wf%ynm6XcWCzJ?p+)d!S2I%igyUhTS#gO;#Myr+e;!X#akAy
zZPE?tBrZN(M0fJxmS`tLKv$K#uG(IDgSmy=W{R7=5F1`buK>rF7J2KAe>v#SPlw$s
z07ZWB(k{Wn)%+4x9Qpl^5HmSXu}KoH$G^Itz_9-y?SFYm!A*{A))Z;oTKisoD~?0$
zAO$gYOZ&zT@q<rYq(0b_Mfq$mQTa%WegcA%rTC6=dL9??ePNdKjDn*4;jaH;TJ2qb
zPW{g^!1_*X9N(x%Dx|#r0l99pfE(y#$v>%r3}#5MzS!`ve>o=*jx!0IX6mm)kO!vz
zF`r{Avp*yIK65J>Mw85YR^F1Aj%<SvJ9pqZ8WE*DmwNpN)2_cM(*z7!_zvV-{AJ@%
zi{D7fg(jEQIVln~sgPT-QY;KEJJkTd)1D=B{<44q0PV`fLo&hwjjbEV5>j@1!ceat
z%#%Exum{m-7%q~vsxrvZXdEq5aqmuKL+|+*0HD(S7Y|`HA$K-MT)miP-6?>vy)U!1
zK|zLqvgNpm!Jfx!#O|y-KK8%+&NKZ;l7h)A!}^W)tMF`{JM;HL-gPJO>bAar6jB1s
z-5K+Id>2{y<6UvNd7m+t00<!&=??e^`s};EnYi-oIzth4voDlI40CCo+=uITu1+*q
zT`}Zyfpr6G_{o0(Hh91bbWmi$%fi*&&S+Tq@otMU;I=y-GyVHN>1!W_KwO%)c(2%d
znb^5M%RljW`}_OHo<a|@t&LPi@!Q!7yPh}3GMDx>ubt+t(yD-XTb2x3dM6KJQIT*l
zvy`*X`LX(okuSB8+74HA9MUG(`6of<OXt!>JQ!XX;$i5CW1w-tG3}pZp)paUGiu`G
z&)l8YhPRtd+)e($r{0`A#b;s#Y@88#$3W&qIRm>d1$zw(AAt(;L&#i=wA}%wSE<7(
z3%|0{*<5@k2SVrF$>d(60y2Bthu1SSaQk&U$aUG4kSXUodUAzAwlrzV)tt~#fK5%|
z1>5oC8ZP{n)Y=T`ASucGxTRs7pOX_8nn6L0-~ubk-<=WLJuPJtDC=#8X5?E2-E6v+
z9b^fWk}sto8ezdL9b=Z?YHdH<3cS<(V>I|~4}II;sI}v7aQmQiPDlrC@m9#aF+<+a
z&dF0&q4#G!azY=>hrM8jK3urO8`iayZx#0F^R=9??yr-dz*3MH%Oa7e=tp6J?p^j~
z!oPpKxNDJT&iR@MYVpYyaT;m2F+}EZW>@a_eFCd4n=9DqT{Osz97O+~#G4F8>(^9o
z1U)&edct0-KuY%R)kwKPcoer-`Ag05Q0JFxuVvjjMUkZ{x9?l()pnB7Bwv$DmtR}n
zJ??aa*-14Aa@GZD^3@vX-lJALF~Q^@^7PAD?<>bc$ldTQZ51Ra!%i4xtNp-=37at^
zH^qruSeTE33CZ3~7ewYAY&fSyfZFa{uuL=?;JyYLNV%|7Y<mSEIp$h2MqC3>MMscG
zIsz!QQyDsh3IDR4kzW6%c-xzv@!tu9SvBNI^4ydJv>{THhdpn-9+Qp^;}y1A<Q;J0
z=BV^``jIwx2|sCz$WN;od0u~poT_ki^2!<B!;o-ml<mRYL`-!0$Rh#g+=5+&<#@oV
z{6FN4c5-x{aL&~0lXsdqow>sIIHd(F7{c2`NYW=N#$^>_hN9O2D@UVS&)0C<%-m<F
zqz0K#M1oxfAMu`QfcQcjk98r6ZZIO!8<gCE7Q&HeNU$?9B`qzg&nQRl2tE!m`aTLW
zK-#Yprfl$u=1&Ofa?{{>3f=$;*%XUaV|3;)a2#F`(%JS*r}d>$jfVo^6i(?AVwocN
zJ{Xi;lq!X)Gm|lb3}iJjy#M=ICv|Kk_lorZx-NTIX$y^v-UH<m--EG^z75BfG>k)O
zWO=NY;_Lrw3bNWv#tI8_)*FtTgpS%}N0m0HG%DI=jXK?mDr*U8RQ80va2<^*?`&yQ
z4bOUU_G^^O!o6G(7BN$^&%_mjqsvHwpuT-6vUz%gIHI?;uhK8eyWSRUmny1*^TRK{
z9Tie-!SUI&Geu}Q=7xhzlg>GgtCdUB8f`_Lxr|Tps+05PtabrRyze!ax0xpzqkF9H
z$kqtF<tH5*u?e^Xi$<<llcT(f5~p#hvseg@K4YA$Fq~Nlr-`&2da!U`wy0=){ttpi
zesara84TZ=`3<d>3jCG~Tc(K`;#O33nov8HFf2McQI{M&9=5#7B?%BS+qip00+|_o
z8O(>2vvN8{Bx%#JqJrdvb&SMQb8+z$a52UCwnWg4GiLs%vuCumj2|)F0!F8NptsRn
zIL0Nl$qYs*kE$>q(O^p$P;5)Zp8N3GWca7Rxw9+igK<-9#BEo_SL0S%PG#1Mqayt}
zUpgWi%TFPY)3?#B__K*fw^ow&O%vI}wpttcAg@e1n1yI(43H05#bgaLyu;yPVC-Ry
zTQ6Ot-FzU7vn|VQoC#x?XXs?BKg(JvZ^>hD*C-e<+$c->N^E$`8Q~$x6bJI1hp#Bk
zCrV0xCD`e7+=1Lkn_L((%7IWAcE?Ofg<v;d-t&KlG<Fj-{1O|{Rfp)_oOupqVx}Dw
zA$%=X{jDC{82xQy=rA3y=tZ$<IN}aI#c7)3H$8*-sqlg9U^$ruuO|pqR_M0=>aV)>
z)mg8x##-_5h)2-rA$^lv9rh6k@&BB9MmKFVb0;&c(SE+R$K1SUmZq<*^ut`R%TA5s
zRjwP~(I6H$5k#16vQaQcsapbFl7O{!ob)a=qk@y*TEDU^uBa+)GH8j^dy=7u!VNg9
zL{>kq7QS~RKKKTBf8m0K#*>Wgu==bPRe)Hhg8*-_d2enud6QSf>hmm29!&_E(_%4m
z<EttAMXW~${q4=EA=dARX9b?ih;%l`OdFYT1@8HXsl9w*gF*soEz9!t=^-Y?>V@Ce
zVrYG2n*#exi4gq2ATdj^HC%b+XW93+Gih7*rwbb*(AI)=_iu%#c?kufTc(bZLRH@X
zf|Jg1X0>N|s2oC|NpZW1Q+&h=7bO708=@*e+o0jqi7^IT2h&tItd<+4n6-5UAK3-H
z-p?vX;^I8MmZThpI<fG;lAMmWt!-LZ|L?5g{JRB*AVOg!obK9(q!&U|!QOnS&hiSv
zeB3@z6wOk>xIV&EyImv~!NX2%Q1@@~R$%8WQ@MKk&-2b%d^bg0R}EPcLAIZ~#FLY<
z_eTHZsf34KOMS0mFNPg&wSITP(WgA%MdbapFC!jTKSy6juBb;UDZ)v%35h8SExVcJ
zDaE;oah2h53!cc_p8|%qY2mZf^HWrfITvg4t=$OpHRWQSda|)Ldl(f9`ARjqEW7wa
zIGoHS^^yE|VdCMr+wboQ=N5X)G)x4qYg1Ffe+v7_I$(lA!{K;&SNtk$R8kG=kQv`H
zKRB47V}y1e`z&ethF)jx@#9Yd$kGr$_yD2}?h{M~B#vvS8M?_|nG!daxS>{>{80Pi
z#gMGZ_lK{2o0lR5MeC{SpHa;-5lkXm;HwMQSrG|E6Da@zW;BK?ev#PU4hQrEXwDZ8
zuLOkEUGHF#<#x70>XE_|Jhj4D$v^%de_u+}jgm7<(ZWUbnncJnM73N_o<lj}R|Tp`
zf|Wl7Qi%{Fg)~8KO6_4pzc&#S;1!R6aA+amP0@peU@8J!F$?3IfO&dBs@_nbNWM1v
zbay}qBnbBef)7{%--t)u&C*Z1BH!4#yeX4<2TrC&o-ru*3HuYG7wdjJGx(r3;n<F{
zZLROYtRhV&;7Eyp1zqIQg?I;IT(YmfK8K!16IB|I{0SU2VS%?Ignt6rf430r6Y8(V
z6(db;|6%QgQ=CbSwx~!p#Dydf3h^l@7b(b~=89xJ(Tg9N$)TDs#!)J84S|f*EJ1Zd
z6<R3X394a2F>~Y^ZpxUa@YtS@$t=n}*x*lQ@KhQj{?kN~$CJdlgnD!k|7!T2IU;MC
z#6FlK&k_;2OsSJPj3Y&v9n3S5jgFG(p>b0M{jRE?e<!F6i!_@dJt;iCZ6|f87loPN
zXaZ#5jbx&(>w{i!$an~@h}X2pWr0)}x=5G*Q|K9s;!`Y)5+wvVqRJwKspZA$mAaL>
zsIeOO`v~DxN{+@z$;lE?6)}{HI^t8|sS|;vDuO&I#3F1v?1A0czcHouie-)#WzK<R
zE?H$~ZkD-^u*=S^l|9jjh(E2bWF{9j4q@~jjigw(wQ=WTp<#B&L;I3?1{ov<4OuIX
z*ezRHQfiCf8^^k{=_gK*2w)$%{C1fkZ^$f#k8cPCtP12AA=EXZo|aUgK$XR70;P{G
zFZ3y{qh0%$>i1-jgG8DHO1OPT*%yd61(hfvd0lXjixI*^#mFotWc#kby)##;cU4>K
zxLI?lL@(%3LCp%HCVNA{nS+-N6g<~}{73M<cpp_vL_`&Wx9txHFrdee;oekMAGDq8
zd8=9(1&`%9+VV$hHzL@{h&L}zrC}UDTj+4N5|u^~a-#^d$FE7ITxZu@e?q$U2?}J{
zu@SMtzGaa*Y(!*DB;;A!MJ5GJlIPB=;T@vDyNSH{L}Vt7cPIiralY~?9WvT>0&h~S
zGy!H4W%ZW?<VAoPle3*0*23*|s^U0;e$Ct_!ix~HOo7#z6es=Ct;4|^#E{P-Tn@3z
z8XcsUEYbzwtDV8$3RDsHyRJ~n{h}riG|u~aJVbcLc8r2_pKtW+E;=5hnu+uNhkzI~
zduD=oUJ?0N4F0Q};<Z@Z8o+yZTpR?z?wU2VsC!8tt~hm~hiK*^>*_0dUFZa~j{x^|
z$`5i=bLg$@E`usMN%hzZ#p8MUc0}AMlHU-KzJ;<s$B9j!;1`~w<KD0#s&#x6n%2fm
zmFW$EGq*&_Za9^@sRa`7%ap^zTWbGTB~Jj>PJpix5x)>TQlCWP#|7`w^l3{1F@neq
znqE~#mhoi)PeCMOt@)s^E`*uX6Qq_p&pXlpcTtBH0g!Vgh9|uE{>-7uiP}jULfWE0
zQ3N;Hfp=r`782yN#n9TFR&j-if_0l$_0{5zAY@GOZ&u`vf(6FsMXrqtzF1U>AtGui
zJSV&YkxV}i5il3h)@r7Cbh9}enNjw&jdgfWLgUj4=3A!-y`k|vqZPlXA>0@d$*LiI
zdx&+3ggiz9O~L@~n;?kD<I*1K!I_<3q0)8hw$O~fx)ock#JQz~BiY4{9~8llej%bP
z4onb*UlS2wSe_F&KICFOihjhMh{*ThUL+u7+*DM*iF~<re<><{?@O{45`Gr|8>W*%
zHRR}8r%oc5%lOrQ8xPzO^1lFR29cjs>^4y%P`|;WccyX3f$LBr4g!K+*MR+i)?lxQ
zIlFGV-G}cxQco<}wJZwkVoiO8fE9vC6q4t!EaB&d=NEPF^<MNrghV|}UPL70^{#SL
z+Y_17^+Cvtsz|N&Z>qNHfm2`|DW6k=#M`xt;JFA5P#a&+xZ>$H(nu{|Bq0zkj(i;{
zxG>IhyHFt6O{J39m;<Q_T!hEEw9Y+NCF-z|AqZ$y#G^pUUFuKnI0}y^;#jC1&w>~-
z(2i$9u2-yuDe;miwa&!A`*13KGS+=^A$>=3`xIOHlwbC#uJ;*|%>%JKZCB0&3>}@+
z@tGGwJ@vJ@xYI}YEYVKko9?B0*1#uxgx0W7UO1}C?w)PPy`TMB(l<~}dq|lq)akwc
z#-H-3g>L;yLXm9_f?hD+$0#m;q!u2zBdT`M^~{ZX1zLXn5$`X#pA|Qa=HFULHu{;}
z1@KVDAx|mTKpao;A#+U;dWL}Jv((m~4@}_wwHPR#`zpRrk8gfMb&E>Tjbe6z#_V3F
zI~qf(>V_&J$^P&zgGAJcSVzOF?2-B+iJCG2u_I0>P|ya}T0vB(vO{9e0(t0NLVY36
z+xYq@X&tyjZu{OK3knxb<r2&4se2I^6ZIhAc|e(CmwAMjMe&#4qj&bWw}oMldCI?W
z`NKk&e*IBZoJ!iFz*G+69ZLYK@BNG7t&hC#UF_z6+2^n8(0!x!a_7)s(V_j8q+Ny4
zD_fbI`@<h!q68-3E)zU-31kRGsE`5^78aQ8tqoEaGKmzD(Yo{|;;AJ!VEr52M}w}A
z)o+@mGN~i&^y0_XBVYYS2&$5L-^bVg^mG%s%0JsB6A>&lk`wp*KOR6^zt#x%8h;VJ
z!m9^hd0c+-+u>Et0&F2-Q|6gFqaEI%K}E5m6Ei;_&g^wfy{QF%PzVERe2wIelZ1Jr
zBOu=*gm3@5Wd2UViPZD2hL<?OyW1x2z&iG??deV32JU$3yvmdwLjt#(Q}=Z^_<l}d
z(roQw)NmU4fN(yQ#uFpV+qVSavY!iF9LxBrwE2XujKo`zf~eXSNLsmc>uPAr`poQ*
z$hP?`n$)|uI$Cy4{O!YMhAH5vj2Rv#w+r%25NOi8R&nJ@6i=|EiJkNxiXJ=m?9n(o
zxj?1j#6pHh)Q!Nx*Y9(BLdBVF7rS*sdLBmJdm^wP!ySYk4YHp<FY|hzDGJaLv`vAo
z{?~*=WQc*XrxaUM_rbV+bY}3Av6WZP*Jfs=$b#w*1(E=vr|&05UrFQ`_dMV581RyG
z7&rbG5tA=E#W}2;`$0rT^OcO)LeU-8TOpNmFVay<d=D4FPdNpIUZOThnC%qI1?P{=
zsUK6)HOK6DT<pLlh>t$6-g#EA7)ygTt*8>=aZ-kj?byux_Mobvc%pGwts=6CN1$#F
zUk}JIoO*(;F4`8!Y=D4J!~<Km9@pHt2}x!B{m6yyg{=W!)Iyis_*H78km6{-nb;Jg
zEpX+Q2y=YWq*@-yln+}{iqtq_v<Mz$F+}9!&s-XPT&)xjVW=;z9g|~S<G<kd<;#Wl
zUqBm&wK8l-+Z~aWPp1j4g)u~)gh&1FpB#-I8|%9C_34jq&-mAwYU}-{)}M#159P0q
zw64DxTYvRq-RaoUg@JFuxXa|@$jEU>VH<a7yv2vSk=Gtb^+uhmVB}qd12*Od&Ux|N
zic(HI--XoC1_ReIWu)!0K%GwI!w>IR*Iwy^s`w3KJ}DzziaMOQfEGpMP|XLDJ^yYY
zJ<m%h1(CpJrQbDN*b8Hk+qnAzTR<%6Xd8SKyZM6UdJr+~BnufaLyXp}QSHI`tm>k|
z7%KMsL#ZKjIC8gX2m%ETci@;clgMI$X}jxF{Gyk@H7?kiVEZXOPbApVw*T$N$Hv;P
zFR;zz66#iNt*9+RI!%Ka5t+J5=wnrBO=IsCG-uyAor(Oi1!C2+fd<Lxn@f%0^>M%Z
zkIhd%-cYl*zxl}@dx86v9sE&BQ#CqwF7K75st4zhZ=wIi&;aT|Tf=}Xw>3#1ir`Dy
zl85ze^6ew9U~m3l28V|fRAh{w{&9&Q`CljoSzGN4)Ijg!Bp(*b>;kYn4EZWbVhG`>
z^(w_zyu4R<4?47izcz(^bFSq&lKDko8EY7!Gz!|_34-wHg=|1m>fCKdDP6(-W}gz7
z{j)B!6R%fXe(b(DI9x|~i^d_N6ro}OO6%2)(-80@OvN_*d9#lyy?lRI00A_xxv*$}
zSVTAB647GVjgkO31~1#ZQOnGNYlp4OO)Q%g;!N^o&rGgZlqx#6`o5j~^y080a`&HE
z;pbNoK(r}rBfNxEO{Vb6xlON5lpapnPeF+a4s@F=^M4QF)PZJlTU2y+S?%;)ecsr-
z<{4$D&cK;gzjw3W-xc?@cwGs;bFL?Ou5G_#Se1DEu*c_Gy8GP5V$tk@l*HB8w);tA
zSbo`x_Ikg(yn44ieOH|Kc&$l+{JAP$J1fn*zT6S7udCPi+q`Z{a#D1>6EtFaTRb}0
zv7lGCIPdH6mNPf*mmLjQcz<k&S-HJmPbJvcx?Z~;{^e95qe>&FYd^J#oslbkUl8Q_
z;)3d4+1IPbN8dCr95DZuJpS*?$B)mfIvjotWw)<j%>_Fk|H4WA=4)&6bbo!a?u~}5
zam>iIuS#9-yDSlpZe+hJB%!Rd+K>Onj(oX>;H1f12gL3FBa6SA^sP^B;v_%Jtg7Tc
z>Zb++?&UG|z8bz#LYXtguS9QJOeFfCES1g_Tedu;8(CWMx3_Fs5&DJBTWef#@95T;
zayoCL^DbIbPw__L`BVDeI)9CQGAKD5>HoL&%a(YDtY&A#tG#7M7IcobH<gIlvNxA0
zi*~S7zQ5&QtvM6zc<T7?El0bVNf@7on{T02*Mo=wq@#cjXED@5sV<MLKUotZqspq0
zX)9|W%2r%QkH)x^9D*lB8b;3Bwq$*AIXrO4!bzjwD1M&p<myPpcDMcHYLYuK-{2m2
zZMX4E1^@05%oe%c?|Pi6+d!)%Cow>n1M1x`Qh7;|N1(Kq(Rfwz{>0^vl5h4e)EhT2
z{e|*c&%C+rS$uALN#A9yxq{K!W+xN0X=9~qrls$1TkQL8r>Qb(dPj~-?LMXDdJrGb
zK-qh{>PwIE+HFewN`U6aQ0u-_ok}=}Z>r&iEmvGAofsC}rdsmw=iZAgDV5CJHL0LH
z@sO>vj~W;}41U8{pF(nWyisQOw?}B+<7c7xf{c;K;#1j`Uoh;1xKN7^NptAD@<f)H
zVzCd$TRhxmiI3v%IJm|YtY3BJO?mNn9M4_<Hnrx>7o5Y1=jlM!m!ao+-pgW7W&@3b
z=cmp-zaHObnJ<~V08Pb?aiRlMotEQOAC=pEXhy&19o@Z7q?E^Zx*h}u$S!lBGipfs
zL8<aLEuu2y1KU2W{!8wAwtt-(Cy*?IZ?3&rIsZ*`sx(<PoLXzx^v=X{WZ%dAEo##9
zAX2pyi5E%j?bj^#%EYf4N!%w6%LkEol(BfRXiZ7dR?{=nm0^T<AeUOHdalQS5lS3N
zR%=b+^PzdCf$T&d!!#JK(@Tgu4DN*C!v2rkfJhU?oDH?D=o3cC3bsMWNRbKNFybMY
zevGVIY7dX?wUVtWGTNB0!5Vbs$})Nn`4~ho;m5LHCUr1h=sdh2F-0mat89OLr{T90
zN9th8fHj1K2$=SjFGQ4G&b^>f3Y9s!g&o#z(I~OxB1U$$S(28#u-)1P*pV6w1ZNF*
zxQb1v@!#jsmrM&Q_I>;rHACH4^=ebDnu3EJ5z)QH0;NQaQq}qqg^`~Hp1F7ZbZ_VG
z#RX~>A&vm~v<bZ@PKBx)KQMKIS)VuCWeUk9^3y8Ap@toqNtD(6<q*^x*C9SL$|vDC
zQmT-*7~scBXN0~RJ<h))Rw%@I6vW{1aAgl2i>3O;ffyM)zy4TwS(~BZ@q^K$_PLZ6
z8O(wLL$&E1zn3qE=;F8--+5m>v-g}4a#m)B-bk7c>ysF$t^edOsW9VUxfWSXC5<w>
z{m#lna*GX`6innqu4~B(WEr1&K|;i?gRaA?$Aru_xs%tI#qn7;9Z9p@1w_t>Yq9|@
zqGVY4Ti;aBPI^#J#EEd4m;AGu!i*(9cxm8W`7ws^3!oOBeE7}SH9w?o+VX)FAMDG2
zJO-;IL*{+D{0o+|`a!MEF&4LUBxP8{PEpf>^+`I3uUFIUGJn%K66(P9ruXg1xgil>
zNzK|J$Z@X|bRu1TPR|Fpb>S(yaFu*cYYnQiN_#>_Y>R#VH;ko5)hAB+c1iyHY^FgH
zB*i&*vn$Ia`P;K1b{u`6`#eCdx|Du{m;O`Mgm3Ew)gmFEut-RMboOC^)}9O+1fc?-
z#c1rC4y^}gT?{M-?<BXS@^bI0nQ*e8F0l<64|=T(zINp#rS<bcmz7lyn8!l6;(ECh
zBS>Q@moK<^V}9EVp8Pz)1fEzWW9-e*IwW4Nm+Hw;8?XyEae75$?{gFX7<rK|3w7zT
zc@-65MgNwsxNK<vcPlJpsFS?F-UOyip&^|A80yd(b)f+?!d|=GbNf^rd5gynn!`ih
zTPi;QDugx{1<n%K<nSOF6&JDM(JRq+u_c7aBYU{Km_1|ks|_Bx_wayYH_EZk8azoY
z#G>dOpBAp0V(O$#oFdC8U}6rYO7+geWcntR{$|`@gMtdQ-pEAOj3njl1%0`y2)zBB
zDWt*t80A{dV4LIJ<j)tzNk+*26#@f2#6o5B+Lm8@tIBANkBN{^sobQ2?t{xbPweQp
zpIQ-FzlyB#5n<=p=5D0Fw9BD;sX|}<GOagg-;=42vF{(O8P0VhHCUe-xF^!>Nc4s?
zzXX*lD#r3`Cx?>A4`sO6namSLd@TvG0^d5gT2vRVlKgh0T?kx9C+<H5_SD^bt49(|
z>U1B3c^&4zR--&PBkm;$WYx`KA-|#mMy7u}5awp47QZnSq(#b>mB;-$c_0CleQe;L
z>4AzK`l8o)|HGX2V@UdU*wH(2b6rn6OChM9nHt>Oir%(G?zfVB#)n2f+ushv4(O`K
z*&p|rSK|JVekphQoXaaW(%%VuSf8d06z!Y6{Pn0HJ<3aeBkSlr&bIUPhKv^Q3`Q!-
zmv72uNQ?{De=I6`8c0*eV0`AfrxAU+ug5+1O%mG7uI?s>7y{MoCz-!U3wa6$81QUg
zTqhd!9RijDxtftjs|rpu43vLg8~#}$P>c-_j-XUr{B2gB<2mjMi(_n^yedWW80XS4
z>1FHB6cuOqVL5Ov8!adGBv2+`88^)dqZds0$D^IhsRLKD(8`AbT8vZ^R&z48PC4#g
zVnmv8A+#Qut%OCxZ*nSQIV~CY0Q1Ig3KGdRnKkz^p3@bp5cfE@GP%z7me*$9*pd6C
z42i9Q+CsQO(ef(p=>!Ht6@B~SGPnxOWyB&$3sn`lX2jU*<&86wH<;40T-Z*!mN};u
zMDEb?ln)UmLT;GeGgL8vXF*lo$OycsdKy!af4=QzEGg%F{n0Q;XA%qC`>rBU;la_~
z9A9^xzc66-ZDvg^<msb+$A3m=Yub_zVa?v0d2i0w%XgDDoBMDKx7DMg^XZ3~!U|wG
zEk^y(Nna_FEScVQ^Wr-Qmrr#ZMc_FSO0Ug~s8FIqGWot;j{H|-FO+3mkssZxnn5uk
zA0EO0@~r&{I*=M$!SC_X$SWkrr{W6FNTxTSn|e48=-#P8&e0lH^VkGG;DwrZa^uJ8
z7a@|sICt{S^(%puN#hyBUX*rlWgI%w!<COdPDed%JQO++Ze)4{ryniz3WKMLmqzSr
z#42$NZSqu2aaCcpwQI7hsY4gGGUKie@rw(%b>((^Z6x+yS8q^SfT_7@^))^kF2Z&?
zYGU#YnsT=8`HX62U^xW#GL<DwFZ<>Y2x&IdG<hWyP&j1H;9O!G@v1?%%&A;LnpvL4
zg0Wo$9ZIU51XR0?^Y}7Dzb5r9F1s<rvKY&GJZ`X<#%XqlgA%zksK({kRF%J(0oePs
z5uC$2Jkb@EmqT7yG0l`@j_9oRB#vj;#bw#|W<)r=XpXje)=*lvXBfqi>bY~JI}w`o
zHuF4|`_`V-kZ<XQijFmWD!C@zJPK+x&RulTdMvF}50VzNZapDsGpS-TWneRHZ8LM$
zW;Vp;O`^?QuFc!4HuI&&^$3OOG~Op-HYXHo=meD9qk{Qpo9MTUQ;2NSLh$m<tQbQ2
zUw2;Xwv6D4vH!`SH9hkn-nyN_02qxV#*bJVTO`}Kuzet19M57VAU<;z^{eSs<BW*7
z!4F$Pi?T3T9Q<z~qc->U&%~F%q2M;?IGF*lB4m)dI5c|G;%lHe7Q7`nhXQDN-P@<j
zJEa>duZz1-pS<`4b_);A+O(c&7n=~+al1?*!!}VZqjO-JT-e9=rTZ$`3j=mcJwfI_
zyXhy@SALyZ9F`8BK6=06X!2Y(Vl(qXU9D$tMld8pU%$<@jZ@K_%ZHWWwQ7~xWp}r0
zTz8_FkGqiHzH$!1pNB>gp4(3iTu(gIJ)2LCjl<2UjS&>y&2FAVSo#{ZPAwHVyPKY<
zIO<BZh^tBc`2Mx~BirMT>?_)GcRMGlou(Vv8dH;JuU}zhnAAXS&{F+tGJY8Iguo`<
zzh>iUUGZ%kK-UYvoX0he`x!5An5VMe>%9E6rJYf7bY>h`S)y^L!##ca?aSwwEW{id
z1rWJ>WEr7_oNX$wKSC-%7l)7Q<+6E>r|y|rdJv78@;LJcw5ojn3Hmp&N!EaX*(;kf
z^(DK}ysVX(H!XCnX3j&-^Jfi|XCmt;knV~GM^|LUGg42hXMeE(2Nz0)?^I{~%5>>P
zovz3-1ZWYZ1Hf>4iw|GRs{IckTb(tBrFPetbekO4bjezU?_Ko6k-^{^`!d(rG+eVU
zFM#})Y1n&&RFQA4K&R2c8F6A0Y#b`;sqMCtAUQN=@BQ4I7Js;_sKfp#e2qff>YKW_
zYtE}_ro>b}5<$oKntnx=9RNJfvZ7;;Ce*;y_hBlpoON*SOKXVQGMh6~8M-BOF-3+S
zt>~Imw%?3xx;fVqb1qyUmwqwb|MqiW9NYq#Z;x{_IQHg&`I}BZo3|9sBBST)kLdOK
zJWX=hSJxDfIJ!;+^i+TL_Ib{X`*-Nr;luTUkMvIc!_0A}D@^_E^CW9`2)LSyW{9mw
zntMoz<0jZKj_PGp6`s5w@%o~|`}dvlZdkf<b7j&_1?_J-!7kMey>MUBsm*s<y!su%
z%L(Pjdm{ea>;SmBGLxHK4Rt#1jM@T+&@!vAnMb3?0rcdCEJF|SAipXr4k48|&4}+!
z{Wv~%oAFUc%$=<b6Zq{hlQ{c`nG;XQKulcqe#PU{d+I)QAg=j!!b<`gN(;5)%vKon
zex5<vfc2dyu8kHnI(#H(qi~wOI{JUiPKsFuCDnYK%bbuF6vO*tg>kf(^Y{+O(Jbq8
zcBwjr^wC$UGv~bIe!Q+rdm?wqTj2oGmFun4>MgRzbL4@y>S^y|tDMjUZvwxMy0njm
znvbTTkJc$4Z4V!vFdyC7CE2i7$_!5L37hHa8B=pGnew5O#%Ugrc66M6Qs;%PPN}>f
zqlNE{Ya3Xd9sDY(2>N6=Go9qJHwQ`YoxSb{{Sn0F&D~^VD)eB2;f;WOM05EFiOo!R
z{xLAc`sTDr@#0-oqY3V16pdtT8ex;C|KAFc<k<F8ye%-zbD3@|iCX_|?TF2M0isR4
z&15Yuynk7sMNJFRK3k6MPCjIThjl!3grtPs`S^ybx;Wm1zStmNw}kPzpI9nEq*byw
z6uTOYfB2t-PP7j*vYH?0Ub%udpPd-El3LM~2=Qx1FigzBK^tJd-t>BRF1KNv>)bL&
zc3NgDw`()iHSU>hRGQaDhL5><2947|mO+&9P1r6mC{9&E3nhf|Br9avHD}c)y`m~+
zhO+V3*zM5Sukz(*zyztx#$6&ElKSIuR(UB$0Pu)H&DcH>c#<@g_7?1Qy4b%r$8enM
zQIh=(*I@->jxZUfgJs6{ay#yDhoR-HY0Wc5Pt{YKy%1oZjT@Bv9O1n=-i70m#~f~)
z7IK8#{v)LfU>k1wyp5D*O(x!*a~$j}yu<t0Cxew2{R3jMnHf3P*0a5GSjGLM_sLTa
zAv}fi+hkhA4l>U^^$IleFX!4NwSb30V6@`L`*UXv_P9&H9f{PDyx!|caXb&4G9*E1
zzZ6nyI9kU1g;r?Xa#NDY5bz;o{qZ-CRRkB_$;L4?^nu-vKQrLdZy~oBA*gOSezq@T
z*kB~)*yp7mg8S&uuXf?&L|abBSMIm7zC`mX)6y2jbc1%hi}P~x=TZ|Z^5yT-&80IV
zu!p}5y%XUk>ik(FJjxKTT=l6Ch*t7=hTOSVT95~kfcNYvX(PLgr_ru-+WIfC|Dt>t
zb_wC!;iZG-oT&F^d4>GUjev>h*GaCf!KZRkDj-FM*6#+t13UC9-Guz{^yIG08uy<j
zBk3MBoQE#?kNT|tmQf=z&a+xZvU{Z1OIhA%9y?$OugCRi5^}38LtaR7;}yo3XoQ7x
zJ)vYuz3uTKn#dg~RehOB>Cd6=7)d-WN+yJlS#RVqGWm}}KR(a7Kp2!@zhQK8Rnu9<
z$qCQxH*O^ETuH+I&=(MDM#>)k122RaB9cqcaeZ1+E{~XLgpt{J{ytXWHGt^5V*cgl
zxhnt8yEENcp<OSn1xg8eT+Mu3ORyf@Sq}ZSR3am_Av#OToU7@5Oh9rhwIDX|dTh|$
z*x+ZeA+KXYKgNdr7aPuwjS#pHiMgPDs`%yb%8!WD)-49|v*7t;sIhidY(Q4rkqbg3
z&g0nM<cd>kD}RD_%H@7tNI9wB+?;yz>!0AlQzV-#%Wo*6*t=TSfZE*Um0IVEANlXB
zay@<A7|P&mXI16VDD;gmdT$QHnm0P|dCUa0gm~4Z(?a~?q*z}38TQ0NiQU=qiiw<L
zet<Pkr}Ahp81GW<0^D|En_PabU_aNtegw3e1Mk@1^pp8q=CrgXove5C5+@!(x1>*x
zCnmE#CbR<ossr+sAP*w2T%(g><_H)*o5w2j!hc_(x^}$L6PlOp)ME=i8@*j9Z~ik5
z>~-AD>mKFdfzk-g&~u1{_ZIo<UKNkpdpljZ=&bfUTAJ&jjQc;`JHyj_vzfqkmL@aa
zp_SDbcQSr2`?@RZujls_`<XxaG25`5>&~+uH<>(qq1Ko*ELSzI0|4U5#O<gVh&Dta
ztkA2Ic=^>d1Fo52v3w(408my?$cuYkc~ZzL9J)(%s%C%8T{_}H<8|@+@6w&Iq$wKs
zPhINbFDbe!hCas=PEEU1#!*$zV@*$>Q_~0#P8wG5vn7rG4)*t-S)Looj~fJ0o*Q#*
zivZ0F!~chl=1U&;hbu<Ojugw=)>+?-^0O?!p6Qcai}D|=1Wf1m;vAO;^G|pV!j+;G
zChANJ@HV%i6{ng`an4m<9`~dr<!NO6y?k`#nU74)xDq7ji(?T3cJS`T@9X`5NgMa@
zpYUSSP|)CqXeT>~3cA<wiBgW5;ZuDMqxe&~lN*$dY!F1P1FbPST&it)iR!BUW$fC?
zRDRWjXmiIvUVh#{6Fw>9Yfre%sg^64TjP?-Y>%{!kJAqT{)2mE>Mpb>U8x1D669&x
z1@4&H74w9IiR)d0-%33?zKpDk-TOCvD#>7X^YiO^vr2|XAK<1r<9jyEnKY+8#9iS6
z-g*mUW}n5Si-=i(M0K2fWzQZjEEA-;h^2EE_~-kTUrSHX7O6_SoaKbGD3=mBRE6W?
zYO{{iRn%q6-Ha@7tL3UcZRql|K?>RS$+*z8sOzBxHA_f{Va+2Z=%4~>F(#ugrKi0x
zF$fhZwpA_;sHV=6j>y^J<6Rt2E!vAURrnO&oYUxtX|OWl@zQZMjop<I^L@WJHAdSL
z)`D1sbK6;)d#Ngzk)HWBfKPyc!3qYBUB3I4k!JG{SI-@)gJS4GXPcX@M9r^RuJ7GD
zC0rU>KTE?1C#-7gMn)H$G|6ak2aJ};4MpZ05jRXgXT7eUKY3!M_(ry$m^cy-Rc?&?
zm~zaaz28XUPN%|;<=3}{zzBFam5X9Uh|29AI>zRTXfPe!=gdj0{w;di+zJf1sAnQi
zzbJ8NaGW`WKue0!#4Wyl?zAa#ZS%cav^rZaCGw=1Dd>NCsaMeP>`%w&&z#vp4rn7=
zLw28VZ><wIF)ts0h|}axM}cK6?s2!hy1n=u6-26MXccIQO8xs(F5;5;sT9Jye?E@5
zYkhj+4d_GXl<oC2=*X|m{&yz{Y>9ej(_d&uG6U$fx0AUXC2wv~BP9Fk<Ws`nsNoj_
zQG4fwt#(*zs3lC>zF_l&qIXh&!emA%hlk<-^jme;lHC+XMee_GI)&sZNzal=c4bCq
z_vWX8r9vxKCYG+wZ%yB;ufLYi=_@%2mCY=y?Owk(<?;CY!{uv_e?0!R@c6%HoR}vY
z{eqrPeh$f8f3o>P^W&3WuZ=NJx27CDpZ<R1bN%V|yYnBP{`r`S>DjT%@o*52et)dz
z@3(s&74UPeoX_@VS-EHAH=1Jvbi;Pe%`$QZ{zH71z=C+qi=7K|l`p{nq?>wiTyKu6
zR3JFK+^d(@J0ht8`-X4{mrIFe+npxsP3v*sGJUBgsA@55;Z5A-xQ3&t8dq`K>pBJ1
zzKZ-mpeCf@Lc}6M73sKZmQ1A%$QZrW`l*LrYGoB9x<;H1TpNHj5^_7Keko!j|F0)!
z{JF^Eo#%x7A|gQjzn8M<hvCB{^8dnz99aqP>zfd(7=7RT<M3$HkbGQb^p1?Q=PLaF
zW9r`jng0Jj@IQAn+svHjd_JG$Ol)(SL(DNb&MAiwIw{K7*qrB>gyxV`s*y_R;C!wq
zMWu2qN?ubcRQC1$e7`?@|AbvGkISBq!~J%>2{9)y8S%<;Jjzhh@ZQZQR#^9$Cc*+t
z9Vz%5Q3jgGI*WgEOMAzTswl~@br~5t*!$gHde+IYa~^Sd8Ds$S%x}f2HDweiNyhcq
z9gq?|pRre51KN@Rq&g}i&#fswPx7$%+fkI>4ae{{x15HNM8ti6rOE}F&!<U~bp>0>
zk|8M+M|!=*6`<RBH_1*Zb+L&tHzdDl02ON48~k26b_uj%UyJO07Bzbn$6GlFl$K!k
zn=Hw5nTi(Lah}gb>jhHG`_)d~5$uX>5-Rm^CFo2(xnlf74>Xgda_X{B=f8+}0HJOr
z2Y%TG>lXgg68jL`jnN|y;{I?vWIBY~4YnfWdpb3|FXq)YK5E$Oob0nsjmQgSX#<be
z3c9LGu(C#+vZoWdVhUnFTdA*+*D%92X`@Wr$QT%#D`ZhhSR4zJTW1`Q3jjqZLk6BL
zuZz$d9w<De2Rl5<rE3~|!uJ@jNWkCmoGpGSzB#eHCoOOaj5rrctXov2yzoP|?6&Eb
z4W=3+y|4Epz7L<0(Xrp214pk3OJ7%2i3D&%w!{9yAHFmkXUr8stcc@4|D8zNrNS|<
zud|;=RlH%&5Z$)qvV?#}HKA>%HDSA)8>tbJBiR2er(Q?^HOlgj44ltQqYOqT2)Y+k
z`a1JON^K~H@?WWX8GodK;J-u+s|TV4!M*}g_rljRba7@9qMIpfSfMbjcrIKjW2ppD
zI|WOvi*PoQD?Awgl%b3fDr$WJ354CxdG%%Gqr@e@3(3hI1a@0?78$HNrbDv9S64+Z
z(d49$6kvFh1zGmL!lazPKj49ro=4oYtDO}XQCuPxulJgdx$lQNpAJHg#6rb?1Izo@
z1|(gzAl9w+3?CjL|3xg_{phDz4Nu&~Bg6GVv0-+k&TeV{Sc?fa0h*%aBtl=V08ha~
z)l|X|%l<K8!*MC3DGI}Y)T(fwj9P(yTlENR6;3&gZE;PAbGNXQoMoXbIq6>x_MLG^
zaVA+5Nq-God`rB}anQlmHwHnhW_smJ+wv3EB9yJ(jE0!rzW8k|+Ab|1Q#x0C2@l5*
z#)Jkn7Rc~uQ7k|D#D$w~ow~k>Ooxk9CTGy(?bG#>-fapg{wDW_h4L;{42Y~@s3z5l
z1;~Au5x#$}RCY)3I%=j?Vzw&zYYx~)N7lRC(fQ$3j=Y(qFDbKV=X!6)ZC~lxZWpYc
zXs)LFmvZgI%f<(;uAM7^CH4tnW>ddjbou@%Y0UoATb;JkK&0N~^V$L{CL0z*1D}T|
z=?1I#QldqvR_<O4njF9Lh48!*EU6$I7x7`}Rv8ga>fEtF?zJN-J!{n;ps%g=2)jS%
zFU{G<T~IXaR9Jni(<$*jtqDIhZS<0PBVNhAXaZSpe#{{lPI<IVZHZ1Qx_a!%^pcL`
zsng7xjt)KcFTB2=T+z6-oyF4q@1xzEz#$V=|0Y-qtSu`5QHQ(!Tv_?dHseidZ?>Z-
zO?s3=Ki+!`5yX>O#64m=s280O3+T@hXBc!Thxa_UL(`;tICo|?YFkSuWDlW=tqy$B
zJ9Rm7_Rss!k$%Gv<?@>KwQ0#GEB8Mq+Yb{^{L+qhPAX+9QA!#-EYcnG%8S>*c*%0R
zbBZF5fNrs>%Cx2+>skAgBMyK$WP#FWD@wDJ^|qb><;=`}Hbg%km}R*6kr1_B1qv(K
zb4#m1&uZz57cL&UqY!>a{-*-jPjOmFra(Q_+rzEbhb$Z39Reg}-raO|i~-d?MCw_W
z`o%(p?CG{{_728F2aabMplNg+yY^x9QSL=!6?@S)vY5i!yt9h^!HoA;Lm8?LxH$fI
zH|%#T@_9cMWd`ocy0-+Q!v!^J;2J%7vZ8d8bPyoZYdcvtf7!vhpxnft;5avKGyGJ7
zm2c$S<GTh4#lm&d#}63im@L`tBfW)Q%T~b-nlAO-bo0wDZ|F95dtMvZtcY><LGrCX
zJxmE%(kwWB)m}TN2zA)Ln-0}a<Xe6-zv)Aen#w$~=}KIa73y%X>F@JN6^ZtjP5ftP
zjVC(Fys=#)NU;f0{?Lmcs*!bxRI2^c4!h^^^tb-ls>u4l1iIc|nxXH<9o++OG@tg2
zMC_;vgz}?4(`WkX`+sJ;4``0fIPeil>C*7U%}s$l9xF_=kF-oP>c1$34Yyg_v-SFT
zRm*mAqV@+yvI|(K`=UL-$*0VTUK<0-MgKk<Y-xj=f+-@0GSzF-DW?~w@Ug!pqB}@8
zOX2d<pcOHPZiMRGtdapnHXO9P9QN*$ZWPhWqY?m$A~8-r1UW2GsoGV^uhzCdgaC}#
zVx5G@1OH<v%cBnMF_b#Fwh!Mp%@8#%$N}~cBV9$(aDn09y<aG^|M7h9{vg@cVI0JP
z;GJ<#ou?A*mz))vw*EERzEFM%G<kb@X!nk=Ru@bzL(pn4o@T+&%n+gfRd3{+Ez~X&
zH>&#hyqeshY`3|G#*Vs6b_d!Q+^gBB6t<_<A!O;CCPo!iM?Wx1*Q=!Sj^?ow7YZXo
zJhq{Lbio^ws>YM{VBglPylsVpHc<K9zGtak@l&9%5B-JPkPv_>Mz<rDM-;LnDrZ%n
z&J^rS&bJTG+toZ9d<8v^J`mYZ{-&h<a9ofpLgm-wm95xk;Y!gzQe9;bj`C>AeNlT!
zV=xXosO0m?swE^`v`1``Ce=w$?jGD5wp8dJu-YVa;%LF51k0EKjlZBr^(tz}z4#VH
zvV}kuwLfAs==@qGp*LK&vSDtn34U!sI|P}a1WVRZb;GTC{Hi!!@{~Ds*c+~yAs+Lc
z?zUD^U^45hO&&1k*byiCbQKFO`3n#!eYIE+M!es;(*;Of<Y|~koFn(C3`7~TUm8o=
z19QtxG9w{sL7|u!Tq3`8%0~)PP0GmO_QZU~PBca76T4v^_x4JP`_;`z0o}`24Y55v
zRXLa8cuOFwd=IAVJXoD$7yD~L!@MkjVkgJ%SP%nykEWdqQwobL4d`$H*2eYyb09s7
z$?j6+jvx4KuIkn`jA<U~25EaVzmFGx)+)R_Ki=Tw@}bG}xr72y&73G71j_CNDVc*+
zx-*k(;KUUA|Cq|nY!X)al31qMUs}R^ZS+dC8}8b#o-27%Uv;0=rz>5fe$c-2NlKDJ
zQ={aIO%-^B4Z}{)ee{>>h6hS>9j$|C`_SyY#mFm6mWMANITYX8_bC9!!I9SO%qbU=
zF%w0-Wu0f%IClst-9+8vMERMoqc7s0zFm8|5dZAU+OzNR&v*7}y%HuG#D$tNWsV0Q
zXzDp<k5Vuv3W|HYK<c)L^+;&gJ#KNZY#|eZ2x2EAr_ruQq@KU-r3G<l(~dVP2S68-
zVdFud+B~{3^-c3^)JDe*;~mIsoo+$>`LsE(43(g~31*7-d|2)?=_W`Uloux;XM~@_
z#n$Iv<T5@bWcWth<EjG3y{x+PFU&h#8Q0xl(L@pxiO1KMzDv})iLyrH7sTjND=%!h
z^QjcD?o4Ks3|PlUFH(nSM5dW(K=f7|c!gdRF&xn_zR#dv@4wB=pw9DOZ#sOhPK*;G
z+=1FT`4bf0+nek_6h-O#CMe5ZPUoM!anulfxSl0`7`lIrJ`R;noP_*b#;9=NzljQo
znMXGp#HCwcDpkaj12hw;zSTEI-QN4=`uo%+R~-Y#5(80bvV+xJuWvHMj6MuKw`5{%
z7cjHB-jNl6=J+9A+R7O0HoTVSIzDE<w4Gz89Rf*M3!CW(fA!)6rlv0Lr(cS(`z21-
zwZ0PU?qDv|13fAH-zNBI2Nz}4U|XQY|DTvrdgT3y9>t)Swk??k@i0IJ68H+#q`MI_
zhoT*(AC&O}jtAKM&BDyrsPFjk7FG}b=WlpFvduQ$@Q0CM+<d0^V3yNLwk;m~W!sLs
z4i>@@2?j&x=_Jxz(sS~JPYg{tslRP_+_VL!+wpmQt4&#@Uk^%E<T@%&w}sSaUVc&O
zn3Nf`0#>6gS<K?bxrh@r8aN3$E}}sU-)l})F=^6X+<_hVh0(f|t;I*xY;n-eXb(vk
zuvvpfYE<baefOz>0ZoIyiuiyv2`mhd1spNaI*J;0ccA!x>4}7usQ--j9o^*9nmlUw
zxx(^W-xoMO!#qozI%*?x2-q9X?C$G0nIq~?pQUH2DxS|Tg~?2mCak6a-OXQ@i>$9W
z?Em;<Xyvx$&<h1+f8JUr$g$gQZIeh$g^4^ElJe#Y8n=^!W_7JQ5JdaTslD>znZQ3<
zZO*a#KHt~lj~_H(8K^)>uEyRVJlJKpKK&SNecF}{q5SQ$Agi2i1q<wyo2^0YO5R#c
zcm=es6Bb+kEAJ7NxD%xC)BUTjSfp3=VKAnx2irAd&ONkjQBIfv`9)1zMc9E~@sD#a
z+Uoc^R^=S};eJR^C?M@;2na7_3|7Gsp+Xp0w5fmnki;BF67iW51CpH~DD-FUstShN
zWrg!jOt^eGoOYLMz8al>k~{u2=Hkiqs<qhbzv6D6Jks^+NZ-l-p%*VtCR~yV;}B#h
zt)xznY||ZH42gi70ZH0-cw(=vi-IKa)d?@L0JX=E0zJyHTQ=Q$hz%yR(lq_=t|s;9
z`}h+3X=dcl^}AocVF_ZQ5RW^31~R(GM6jbPCxWItg^KBKY~V@hO@95lehJ)r1i5um
zPavazU;OWG?!7d|2!&f|y8@PG5tN}2Cpcae*QXE!lJqAY%n3d;!8Ft96&nWe^7;+8
zXbF;^e!VHuRH2*n6QpK_5D<afi{@EZNJ1+PHd}tZ#&3eXJHls0?iJFBC(4r5wZD--
zM{n4jy6<``pn&yqE6-lFf%MGAQ3lwmG*5Ay2W>O$yr?@v`jkEsXy5meY}E;(yg!Ji
z1nn~=(@bvpDC21BzQl(5XR?3n<}VWt?m+(TK9%3hGLg~OG>}usx^Gl+nsA(`GuPvR
z1?xifRm|lT96##ooCz*9zZkhzcEw37-g`babGk-BMaIRvCEk0J&oYutngAh|U9Hg&
z1PoFLr5YrCVN(x9@!N?OLeJjFz9D{Zz%46iO3rwqGzfYtJcuCi(w`82aP)NP5<5o6
zKL>}pW#~^KQ07c-?-)Pcxo!q-iF**O@>8Xt*90nQg75X{&fMn@L8e`6u*nu*^0s+M
zoEG?ySo0E`3HEL3)9&cCB*Ut&m8Wgd_U)ZsrRojmdaYFY{dAvs{h^t||Kk~Qa~5`r
zyE^O)juUkY`l?{vk565D0!athSGRKbFw)Qw4X6n@+ite&{jZT!#-G%Q(az!Fr^Y!V
zmmF<kXfiVkA6qh2uMU`t3d!_?hZtVEGG}#sX2dD|mh7Gb^vq-Zc1r8tY{&Z!u?v;r
z27)sPUL&|KonNNbr%maZ0V|u{RA1{ku`r#|mkgIFzTax9;T=cekZFy82?t;Xb`H1y
z#S_{K?fu<PAD%`_6u;_qys9f5-!GB6hvq`^zIe+}tvr*UxVcRqnIw;4^Cw`u9LrUk
zmHmFJPmV5j6sjN0<{bQIC)d>T^-|T_y!}T3Dsj0l>BnHOI{ew+K3>}~zLh_;l?c@8
z#m6HNs8L#}i3r0m+5Yol^t^}D;mZ!X#*W%n;Lc!zE(>MivrA?TKO7+yIXJ$i7ex8@
z`u!!4Rz_@F$osz8fq%`OKBWR0C4mdwb%tRe*GkvhBH;kNJPh=!gg=Rlq$+`QmjC>A
z8tnmSGA>BgdT1+?uXuS;9FM#U%v>XNh_P$?l?EN*04u59{=&Z4*Bz%tqTOq)PXF56
z7KtI(+vSRzoDse1Zp8ch?;RMxQ+0R${>wsAhhHgu0Cy{wimFew@|`ddJN>iDHi7S!
zFz5ufc-#{7w=m0c{gPhpL4wymi9{Jn_iQWGBz>z{wb_mLGFZ_l@1|=1K9El1p9<Y6
zfL*nadxnGY9$x!9xg*m(^W+Y2x4u$RyZgbTA#m%{GiOo~-*=t<{p+9fR-)$S?&Le%
z+~}i>j=YCHTW?aRRb90n^7sC`RQ|~;@86=<`}_9xY0|K*Q!U%~(;v+w+75sFI5hVo
zTdsGVJJA!)2iedI*P^C>kNNL1fbGGQtV;Fh*&eUVcgCFgwcUa!`4y2bULN`OxpY-h
zqhLSQL8hc%I4!XGYG;rUU5~_B&<3=J`GHzN^{#In(Yqr<c@o(h>X&YXK&gc^_Q<&8
zgSXvzH4lS?zupf0`zBgX<OY<#uDRS|B`*b>dd1+&jsfq#3v@P`D$vZfcq-Za7D1KC
z$jSYZf2=y-hDqh#CfPKX&d)U+zbR8bK@`~UV@BM4qh4c>M}gF(FMyP(p#dOeCA}Dw
z0`6l-4-8W!KK|J%+wYA~<#~7}tm!b~8Vu0(7f_J8`>-R<DjTyC;hFl2*&-NWPu#p0
zBz{1Rs%0ra-Ty(D$k!FM#!?a>Z6ethGQcgWj{YZGO{hn9b3Yf`^xprkkp<Qmv`h3Z
zU6}&BD#Crkzde%pm@cT>>zlC<J9Nt(;}Y$1l#}_Ho!r4q@ITJEu%RG+iLP8n`;_}x
zo(^H!Ez+v;_%Mn?{CEis6RY8}flnh>G>>n-;^_+T{d4|Yn>oo9pc=m@VQOYQUZ}b`
z@Hcyreef^;Tlv(vKy9k^y9IA@p6+1h;`tkorM|Wng7Nt);BlvR+S_p_wTRxWZvhux
z$1Zi!znc$5oC!KHQg{UMHd%VFi&V2F;kq`t!E^ZjfAaALlTtdsEbdT4%8RXUswS1O
z(L>4iwp-U7HvH_Gqso6U_qwgytbo|vRn>!jU~|5E_aHiniTzQRYERxcs@x~!gx(Hs
zHdPo=q1wp_CZg;OGW$!cT^jhW8-D@lUKfBlu%LBnwA}TY8GQfF+mc?bB0#2uX4BHd
zZp4^0moazNW5JC@^GAfWb(CrtAO8IP`H^>txBHK0YyJu}2k`sjA#&JE|0AdZ;Tb%i
z4K_=te9j}~RSka#mL@qh2R~w_BAtw-D~iq|oc)O+b=Yi8pLyh=8KT5vY>r|1JUZ6j
zPWl6uVKFt2IX%;dAgT%+_n&b~6af@>i!*H==JMr}E|ht~oeuach{kGU>ucDVVw{Im
zX2KnG9w+AiJNBIa*a@8AX{K64&4}bBI|s8t79yE?(QUUakJg`DWPMwi7ZTYEJIB$;
z7?%^Z)gTcb36*HNkt{e7C^Kr0(4#Hd4XN#6l6z@}f#&?NiI^&6PITb|m&K32DoNgT
zSb$|9sJD(#CK+c}fVw?-r8pk3Ou#7FGkw9ms&mYHSD5awHEfkLJo5W5tqN-Cp8Nk5
zoioZv%5jDWO<V)+Eq1Wu@b{6Zw<$;2(0sMv@E$#>GPR|6WrH^(1b`fM=wM4PYh|H0
z_1O=WvJzPGq*~eG^uyA-<~embj*rJTjk3MmkOeE#qx-`C+b59l*<OFE8Nm07zUEGw
zNKMw5nnN3<3i+IF_`q)dZNxpG3=u~62`9i-q$Vc()*foQ_*9Feh&8Radmxy!)<(?(
z1W6&Fr`$%iNwZEv2mm&VLuFLZk&S}~14JZOnN2>M>B0&Lxnsai>6NhebD7rSC`(*}
zN31z{c|6Z=jW?`s@4#`h*(L9_p@v0%H9uhUVzBNUlB*E68KL=E*}qLroOaURO($`Y
zNy8J{4rB`W$b1#_EkXbYk$~slCu?5&{8W(qQbzp4BxZxJbTECtL0`_X&ZZL%PQP<F
zB5~pous5RHrQn%@AYyv9UQ0WWr?W8&daPCvMbn?k?lik+uWWv2+Ed<4uKQ=7-Rcv6
zaXHVeRhn8x`KA2PBF68#ijWdF_Ig&eDpGaF_vYSO1Kb9Sesx#={o82$<Ehix;FOP*
zc`b+sml=885D}EBnVqKQVzPiMF&TcPXQP74!%T`EEhi+e;ilhct;wRh!Y*%^OXot{
ziUAI!4r{LgmMaP~d(A#fO3%yFleZ*F9TAK6tl<{@<D*7b@yT(wf;48nqt~F@av-Je
zUW&(9Y2(WHv+d+AvapzY$mz3pTQ!f>o`{mmIFzC9>^0l8Dy&(st+1)_!|Ong`Ga_x
zFyCa1!Q1emWW?3;loQc)k47)rW=T%maow{LK>Wl4e<hmUW<AQ6ZmiRbVSYfJzwES%
z50!ekjYI&7+fW!B00BChd*^^wur&lg@Bj!xhQwjxl>oF>&@iXIkAW2g0}~pO4NTm=
zxY^;h#-U;byF3}^_NI|C4ex6~Bkig~zB8=@HJZ0eTn|7RVO!Z6^CZ9l=pK`JetEJH
zavAuU+i~^f6>_6Xt;?M+r08Ar?vI0GQHI&qtFmfHk+ZhP{a!jksjSww_mUPzYhCZ%
z962yny8LuZxBH2k9)rJpX=LUhuzB~dPj$1WR96y6L*SZd`|?=Tz9S!W+HZIOp+9;y
zq~<u?p@$&3KW8eB`98l9JXUw0>u$o8va{lbD&*<C{^5LN{H8uoPsiUem-_V0UyTi+
zDP5~*^*8WmL-iWOu8X(URWM%ilzaxrZ3(?!W-<4T@qd1D7soDnWGDq@#>~MG>e-0c
zmmrnJV%xASK0I!9>-H<Zrv|=s6WG6(MfmBhidRN;{2hh1Lo&D7wm*gmmz)v{V-|8X
znybX4_=VaI0NedSa;`lvcDBLxUuCx_ztpk_!>(5Engi?nzn)tTZ5lnZ=?x1H_I#$J
znvI|NTefI3ZT;i9&C?cUN#v8$nxCp7D=!EI{yOo~L%pqS^Ofy?vyE)yfUU^9&?g9}
zqYVg8nlOn(Kv6ZqAna4yG1l_SoWMiEfRJxagqmG~d)(^fs%v`%Pg%1+iuc`zsj(^s
zo-UGvz?yr`4wY5!D7gsbaf<Lm<*(t#JC+(Rr4bI5d7QrpCokJPKu@{a#6($6q>Y+>
zUAtZLMm@V}qbclChVEH0K#s{aWy^veMa(k{+;fX;M}nmD>EIGofrj-1P4%|#DAItg
zlTDyf$KPLHZv~WFw8x#)$&(U{V#dF51^l=do}16JL@@pHSi+zUue-NF&+YE@a+5#i
zB0!YSZsQGn$J)O7+mzj}-^UE3vzyI8-QL-071uV!sG$BI9-*KKw_{x~aO{v@uQd`c
z?T~xDqn;}++nqCr?O1Q!V+?-04mx$C#LH{^M=^y0kK*Ew`>#f~{hl*Sc>_u>X>2l0
z@t(cux{cI1-doLcBkOLr&g$F_kx1N{hk~#zwry-p{a8>F$Vq8YgOrEQTpGqGl+Gu+
zWrH}4Z1v0-?;t?C>rb&sY?J5bhrWWxPc-MfJ}1A>`FY(4IF6t@Cwk|dQN22yG`X$;
zSysN=3O;Rw9o+C?{vN`8o^j*))}`MX?SSY<RXt$n?=~ewE)U;vg6&JRUR-M!z#}dQ
zU(ed~QzDB!sd*-#&{N~PVkGZUj^9i4{uJmJ<taEdQ;yvjD*P`KtK;3Gq?~Q6(u)Z*
zKuE5!a@cfbd3-(_;Y8{cKBIzu$Dxa1h$z^%Ub;a+JvsuxSI}c8Jw|dWdbp7-xx;1P
z?Pn!;9fT*a(~E`#w+7+!Gy3M{O5z=WgIpD9Kr3J)&wso@{NC_@-kH4$aC9SXh%{(a
zy-^V3)+jZN(A8x3V9WwN#;{ICrf=Kmh}Hhl6){F53q+(*1)MwX-ho?ki<qMF040od
z5<05d$WK*&%+M;q79A<CiBK}j?b6!Pk)bpDjG$ot#!W+@n)BWxaoWVr5|dt2usl{&
zSv&?)pn)_hU3aRA-8-&R)-DK5Q%AH%hQC(@z0A5&o~cFLdZwYYGu9qJW9b_A;%3Q?
zs^j7SslOKsnD-lWZlLaoeTi-Tdw#J})g<!4%czNNf5R1O<*B)L)y6lBA5dYQ)<7-I
z2j>m{wHsCtDcW>uU^7IOXF~XGyjhDqTPgdgULkXhM(Wx`xlgRh>&`rtAM75mYHw$r
zhT#cQ?3^qgF@3mPd+3U`kEODUx1004J46z$<I(FH3iePK9%F!>u*4?9B7DlQOw(UN
z+Kk6nig@8d*B%~xc`aN^Xp=2pPzO1X8JU#{UVUNved2*JN$Ze4lB$aprUw0OlrgIP
z<bHAa#fgBQHzU3J_8W-jQPv{N9dnmdaz~1MK^^9YR;5j^aYO^5>*oiT)IWx(y=s3d
zcB?A;xsfQ{J2>)kh@`{vW3WPY>)(j*7Fj+sKa$Cb<?EMo(^j7tiM|}?y*+8aX6_|(
zMUD0QPSX|Csw?8MPkT6rDc<s<%Aft#<kN>=_qlHvw)oF-Ker(Qdbw(Q3BW67Tdrhs
z0{wKVes}b@y*iSYb@R-8#JzMX5$R<B-5)1D<149*&Dq=CfqUSYf5UvaGc>OqN<rhV
z8#r&I%R#T910#AqwX@}4&Zq}TyZOh+Y5(DK&#=0w6o&%-=p3+V&w35u?1GnMZ=9tZ
zwjz3M4V(u7y7UOofVE21V#yB`Xwq9xR^u67cTP5hdozT?6#HY&Na0@ys?ri2Bp3PN
zFq8ZwnT3+L3kYd!CPPl#zGD7ZZ26GeC!>qo<1y~HtEb05nRadSo+cIDuKDct+49}?
zv(#s|>wb@aw)wODoO>TEi#-0OoRx_o^*8JpOMD+Ip%_*YRN^Lfm2|jCXviGuqM#e=
zV%7VCx~nM5nJ<2lLlZ4Y;0GRa@*f4{%FT8r3%{Y{C&iDrEE;?!C2bZvswg>G4<f8B
zPYQ?pk(#N8D=DrdKgi@XOemFPW%7S7=KE72WjpR5w0d6fXTg$KpdwW6u2D!~mFgii
z&^_D!y=JaIWYppN4Aq-d=1G5Ndp*rno8C;OZhx3?J)#c37gGH)N<LSM6OgSAQw?M_
z3FBxqDT7L%LSuNBdghj`ihJ^@=LSLp7gRLGn#L+czsgth9MuU$^MVNmZRtG9RT8+Z
zLRU0QTk{_B>A$dJHEBUPZClsHwVdg?lU1tv<4#HqWnTbM<zd?sEs9ym0tuT9>d^n+
zkb;KA^x&gnUltUz-O0eykB|P*Rg!$o%`r++<jkistX%b(D(fF){gbXVK|C?XiVT-B
z*}>o1cbwj3g!Jw%E2jb+@ZesDVr98;=A6q>nH<G}Lr?8+Y<YM|)5Md0q&*I$I%IoJ
z(WpNmQw9k(Azhn8_pCKZR!ETaZ92sI`SyxsWTFUKLuoL6TOg7&!FXVdefw@#qBGhW
zT{3ia1fS)Te=t{UG_&n=Klt%Pi9N3fYV;78(gGf%-)m7ybiVKbHw}p8J@<d13vz2!
z<26oL#S`)<Ny_x9?$bZG+VC)BO|<MFd4HQX?1O^G16JTR)$@gf{Rcm5fP(04OVk4a
zF-dxXo*2fQNJ6*l=Q+U*z@Y<=dRPzJnJ4jk!n1#3{(}HN>;xZ{oD23wBfq1;)51k;
z1<W+|zm#;8B0A6zleec#uoX_HxLRZ-h*a5oQON2)F-=(((i*T(19bX=#G83Tk7$a@
zOTLUdNYqc{xp`9{31dN2Df03UR7T_M1d2WhCsI^@b5U=cunI5Fpfd59WiddxU<Mh!
z=SH|@nRp`XOAXPYyq|)b9Q3<oxZb?viMbS{Fuyqj&^hntpv*rYgn)t&>QT1#>@(w^
z<@~r5y_dx6-VDciw0wiWm2fPBNQV(*6u^2Akl?$!3ftXz`8c~WPbd|O`0u4y)1A!2
z%93{}s`^Hf&}hm<A~L-<A3Sf$o8x!sIeUN<P_}GTWx(LXi27prmkg|5%tb-!%}|6K
zixeS9GOVs$P#9t;yeQCXUZCa^=tadGjndclREiHfvQ1VO=}9RqRpb`|s8?jwUx^rR
z2|g%S)ThC1>@aHxF`9w`QWyy{q$4NckGBLbQn0ggf_8nyZcsDO9AaPtIbkY3UoZM%
zPQrnQm)zbbSm0ok$US%t2Uu<h#$iR{I}JQP8*P^frcuNaS%QD&Qqplo@C{h}mS86v
z+Xdu47%X)zhv#GA@tFu^alu<Jh2Kw}EHVh4Woz7EE8L)Ba}>%zT=Y31l&=D;jU{$+
zTLamIqWm<{+!oy9jIs|^eW=u3oa5gw8j1u9z>+muX>ey8V81EIO+ql75g*hLxZ4)?
zWN6*KjF4C&LKOJS!UVPp=5vZQJQe?NFw;~FZtoyGtet2Ox_@8j1`C^r6~yNl{+Hwe
z00*Dooed(6^u(%my%3hmGW-Tq_`N7kH@Cjp5^=9t8)Arjbxbh4Ofb*C+JM)O6jQ~n
zarpL03J>+Bt?s>v^@^vm(|1{dqZEbsqzlL_fqO6X&Js|RPe!!ue3wtcOnjWfCg!d^
z7O=M+`ptaOg6E4A-@GkQu28p6l#hXpO~w}KZNPj!Ay`zt<xbIfJRgly0^Wd~Wbsv8
zFc*4#JfsPBoXVF4@Ev3cQ*sI7TG1zAAyzw$u}x$>{w8}D$D2#x4%JP;_P#D}o7{Jr
z$WoWREHC>6T=qM2*}wX7K%Qve9Q*`_NEU*hB*Qg@bV49}DQvig5ML3N|Nqs7%2Ord
zzceRlT?urN&!Gss=7fRg;T`yNq%h{Rfwv|I2*jep8x?-=IHk&AC4nyyFR+4}w=vD+
zBKZ>A-8lq<YFt%+wdTv!(@6P9d=l>1If&5SY8Omp)v1*FLE8i=XQX(*1-Z#cz1wLs
zl2*z>C<`S-8cVt0xa8v<!EUYA#s_jVO7^DmF>nuZ9zZ6Lp(#|c-wW4dJx_h$AOaNl
z_B@X8$z1tKcf$z&K?B4=JiLm_jI<PHuL$mWM1h{Etc{x+mbXUENH=j*UsJ?e9$@3h
zG6D<2n0tcX&70K3Bi)u#9~uhNsfGa)2D}MQ<pzg`ZL=V@ZCgq+*=QO!ZFjB}Imrhu
zVe6Er^Aw6%ap!cS4?^~6BC5dj9__m&`HT01&zFkm;Rw9I(nWe;g=F-bNPh6DPTfzz
zTyfz9u3+;dh8uwOnm{~ALJzW09pqCWGJgm4w&mFEYuD}sb=}_YiuJU*<C}H|<BU3|
zwfE6St={W6@TWt%OYSvSkQY$V)-IS<CG5)3d1M!K9E<Lwif<U8v!v1f`O2^j6y-q<
z2#co09RKD8U!I5uanSo)bXeW-$M*>baL{jGpq`T%K@_u|`=#-S`+!5lRq6Zv;=tvL
zwSmNa15`sPD_z@{f$ZyPjaK)*g3^^-?<y?{ew-2J-WA&hP<}~P1{eHMMoC~H<e?G_
zhl}JF20~Nw0+YR-a`oI7Js~^>O8W=vJotYu(kKJd6eH@TkiW~q)cp2PY&x^~@)2DL
zyE&%tVa#J4^`uwf35aZ?>x8v(y7kyqeu{Dr9hPQxS`=WzE5_6psV6`H-~0MA-^i%<
zLa6GyFp+l5>#X!0Awjd9a}$lR_3T;@{%kJ`8%maGidAD`Yu-_h>a`&Q7toYA^fsq-
z_P5{$wO1>?7q8RbmDQ(syKldBQXsMIDPHvUneI){L)4`06N!OqaDbwK&RrH<KhM&=
zsCXJ%=GKE$cW4JG)PEKM%I9oB-RWt2G8)AXL`^*Z9md9@XkB7IIQKN#6uIOJ9umYj
z9c)5DV)po8A`d;BRnrAh;KM;IBU#EQ<pDLXd#ALqU%#idH^-GJ^38Uu|Do7oeu~X-
zy(_r~V|1`ta}w3e>TNE%#1~2l@Sj<gm`H)$>At0x3=3~8fZP*oksfn1y&gYv9!wYm
z&5iMZaW%DZ$UNHOd*}_0>bdxldxQa47{5VKFG)z+o`v#h&(*mikkjE2d{u52C<U?4
zQ144QPy()+7|ycpqm~4!4s~dR@fEhG6wN*p9l@@*V*joQ78zmXgo%rv1YhH!{0r(c
z1>HzDY$RUL`S3A!f;n<Y&<r99l^{Y&PM!WNXPTJ;o-dRc4OB>Ie%_9@2!F0lsN_*j
zf_Xj9UDIFuAwPu87a|p38p{Hv-&!UpsxoEmLi?58T4Q_m{?B(r{}7=kF9@1h3I(mD
zK_=ngdJ*%8^ScID4$n(JDN)~LRcTj_Ramig6!`)tyTdpb<O`oznF-X!D`fra-R{?k
z{{)j{flRXf%3QV6Hz|iCW*o)rIaez#?!rJx=%0$v;QPWH>Rw)6vanm-PFa#PPV&Md
zmIu@Shd>#$3ZTaxQ4T=}dD~pf*`$4G6tvfA%^oh2!fJRf8L!m_8#fhXQ4p)0)sW<J
zG-wu{`OdBD-J?f>84lPP^8P-lnR{*YfzQV(_G$6OiNbR*Z-ESvE}bN@r~=PRv`d)J
z>7LjIC3anh#5d26G7?Pj8oE%bu)jcn%Mn|eXwaTSy&J?pKMNKcPoU;M!ZSb0H+&4t
zi~>;*!)YGRf~7Agbm7(VntvR$ti(9hCqUX%*Az0>OZd19+|Xw@{I2Rdaydi@v$uKu
zcw5K80J&^nO{~;J^F?k`(6<vr{WxgcF~PT3J{C)v6uIy$2#bG=HLF{+`mjiH#qL!f
zqx9?osE7;L*fi?ESSkDj7GZ+14W;s(<ietAh2p4))2!tSz3>t?e^+gX(<J-^WlpW<
zQ(_4AxrWpMjAM6s`B8EHK;efcZaUl&txC9ye#%kY?ZzNKd=BKPH1+l$1}ZQ!%$1PM
z&nbtI_qoWzi4j)aYW3sQnh&dWyQ^%uFAX+dJad|AK!_qrAEONZ&E-qzal|B5U|k){
zz>667JkurcJBf)rH$XR28{|v&GmgRf3`BYCkJN8pTt(sFb}^+cWb>){x3`7i9SMun
zWJQ8W&M_FHJ>dm)b@Zk^6)V_x?A{ekbk-l#%FTH#&yflP<P(7P$5gmC#QaaS;55LO
zKzU#*yY2)1b|(O%7>GS=CU}W(bLyOzO&H8KC0MEcTQ(%^8`bp=_w{a~1A~KZsOmn|
zb!!7St#elR-{rJrBP=Pzs|t@g$&zLOsLM;_qfP=TJf~BTlKsoca(&#D-4}f2I@q|m
zeHINrB%a$l>tZJoFQ$-T+84RI-J)M^WHu~birhHv#Sa8Ze%s_|$Sf#s_FdCIc6JXA
zTJI9mx83xmkHA2CNfCiU>J7OzgWnwTG)J%p2V9dx>3Eso%Q9MMsAevTXGT6)sv4Lz
zzWV}+vuo}z5ggg8jXCnm)o0VizYd(Kx7x^U8c4YmUN`+#FI2HY|B0XO<)8o1n*5ta
zU7rR0x?%2P0{Ux$73giZ{tXxb8n3{|VDld@6a07XBe)Iy!axw$Cs1rZ|M8ya9k8*#
zfbtncQH8ON>M5Q1H~J3`pHueZi=Ft<?y(8s$p_XMwkp(e)$b@g8r$}IE`I5#0@}&8
zBQ-=C9H8+dfM=v}@e7gfvDni`|D5T+az%6ikU|hO!vQQ~UqzlL<_JJGEoZdKl#TfF
zn^4&62tX4k`nCvH003>);I}{L|C2W{;A{J*UCDa=_#`IbL;nTu&+c^?!+M|7iLQXR
zhVoDQYM)iF<^#1h*;2k=e6IQ42pKrTt+tIq<^n((w)+mS-5R+cr$e<ZK~KXt*(~>m
z8E-M?#GFZQY%)NOva_F_`}g|uJ~TMgyqd7hC=imB8LT3Qk5=f04%Qs{arjxx)qhsa
z*ltI9>`wTRi(=t6ngV>tBeFR`E{WkhD<%4Eed>EaKSHUs;@08l1+zPxKlg6E>CsyK
z-g6{4Xy^EsS2se3^zI<5jbk5fH@=oF><N0bg4N7Y5B_*C_f<PA|DLXC#*gpN?}MG|
zJ>iS^v;1tP-Od@fK@Vb|PS@(0SRG>}daRoSOudOiMCtcWTqS$C6xo%d`Khh#2uqFX
zdMs_FuFx`IgYCOZSdl;Zke_`QAbPLXp7lYp1<zATbDPoov?F9ICUVs^OmZUIoz*YV
zUl@5vHG0`*!0)#i($^&i^QPK+2QH-otpBdlnn;6}9^Y+SJfG2Ofe_lc7C%&ew{^ow
zm+rRBsL>FKpw(y%g)Ms62|5__JROc97g_Fmyh+|l^B=IFQGgE#Wx0k>!RU%F7Zf=v
z<U)MBJseDYeGf+6@jV!tZQ^$*`tlvWz@q~u2ZK*7-#HkX0W<XvW2oNsk0^F9Jrs35
z>h7WFOWCFYu~#nN4LEXZz%(%7-tyhRqfcPJ-Hg{-l!9Of|F#=B6*$xD%^lx|qnwm7
z?X<)#q;!Li{oX%?J#y19N)fP>e0C|pW%-`@!@sa9w=pJuT{b5x3@vPr6LHky49`|E
z>9$3s=m>MPt|CA=)KZ&=|9}Qcge-F$#zyzbBeTN^nk;K_oW9oa$ta5zG%R*#^d=U}
zMn33OR4IzWWZAEbGfmI%BF0A9%z6?oA0jZQGub)LX;KR$*!-wJEHj~_Wg_o|K`tur
zkKJ5b>mc-%n-hIrEFdfJ1z$d-t*Sk=v@h>Tx!ySNVz1(`+>pt7Y@lh~)+h2gZ?Rt{
zH@otgP_Ce&(%Y@*x?68IoG_DChu=pQ**TqwpV7YZsPnmtjR+7!*2=*g2dAo|&mOt=
z<>UpS+wehJb&tfVcD3f=j*z--pVmtoCM)c(#eyv5cRA`d>7$~j-WQ#|HhV>gF)-w^
z(I)iHzA9`b0Dfy`S!C<PzkwI>8NYb??%$K9_iJ+bHTq)YfU90mb6J{kZqIp>U-M|j
z(hbF|KOw)qn`pvLa(PBet_UGvf}n1Ns>pvo=DY`mfhg*8t<>B>+q&1-rxs0a*YiET
zdUf{o&$=tdbuto(Lg;cR{;c(Jq*Hp#g~IOK(=zsm-{M(>ri7!$r2Yk8Jd+h=Jm?Ng
z3{+cJ4m8CSX`fdtGX|4wuiwX{n-v7}EFB#!i4IgG;hE(q4436|tH`qFgRG%4Av&I{
zC|=N@=y2?!t*Mb#pfw`Y-njHPyQjpWL{LR&-ylv;nbBZacJNatmKXe@+)6P^YLpF6
z{0otaQ|K#=D;Fk{MzNcz&oqygj{4sHUeQLUi2O({^bJu=%Y|0|<S_O}jk@JMpdSWE
zo~m(jN<cX;aLhVxVIanIDFMB~FqssVk2UzDkS%%u<K6h|U#>&E#@Z)MlX=B6;Bb`=
zCLi&8n_$42VIBXZz1?ou^W>9}7JR2?i8mR>J(}$oF#n?M?GRMQ6JTM6{{{Q2ea|HB
zdN#_#Vo45`UZs^&P3jJ@F1`=ED(_BR*3XW0i?Z~tem&J}HW2H6;(>Rak}E2SO_P6l
z-)4M#T`Rs*qirtrf}@OG4Kf*`BGZ$tO}Z0OUebt4d!S=Fqa-6cx;OOIO$KC$QZu*#
zh!7;_h<_h;jNagLxb!(?eyladS37FYGk>6EkJE~^SMq7N(r;{hEAXtJo(l<^vDAn;
z#Sh`F2jE;fhU@h&U@v|hToLvEYZu<5M2r+NdNbDY?G);Cb|kmE%HJpFgrh_2Z8yUr
z_ihkyJjT&wVK1M*SCGy={mJ*{mt296l2&rPgC6bGyN`q8o#oDU$~yO1E^H_!4nLxz
z6)`a5m|vR^Gd}4zSrvo0md$;L>;=c!ZE9UM=mWh@<#~P>zhky9lQJ%z*Iji*N$vXk
zY`-7o?QhSvE+{Z!a`wZR!<%wVBBqA+1~=;qL#!Q*3%j$8awhZrNlGP*mTaTE9?awF
zwdhVFCu`%={(j>IaSk^~Ne0PCpQR~(-Exvqi}Dv&j!c7!;*^We>jNJ7h(PR=?M+@a
z_P3|0_B9l6nC50U7_O6MKLIWj{w^pD!y~8s*U0DduB#Q_qSv*C0oUdV!qS%|p3e1J
zzHxpt9k+g>A>LIwEO6;CXiie&!bM`il~-50L5}@TuZzmb04H0);#dBSk&v6kDWb}_
zqmwB>PBQC+Oryl2fnm@k*Xv@Qi;e~MXtljtzSB#KxzFz`7)E@H@RW{B8dfpBR4-PR
zVXb^qF}(ilbz#O}%t9I8B-r|Iy%DEeF+2dkYa`kVJcJb0X1O>OcRP4V$FFk<nyNR<
z9V>r?n-m(!jQsiadGf^A`m@z%$EuyKem%l(XEuesRxF+B*59wFTI>I5kHabD`C4<u
zG<xiWI6X0X3XujMu+By<LpgURlz`(mP87!uG{BC?XbaUSu#Wxie)wL>dwfbR-xK3`
z#yelUu+8!D_LY%QQ~2#0WzYz4n+@KeS=ejX2}mko9bl*cU!5J}EdRVY_4tq9foFG+
zVa&wSjjU&W61gv(Qcf^ryOyVR_zT!K$p78AVU+WMp^iv(@M`JD6!g<vtV<X)vXWwO
zrn#h#aK7`Z(s}F0KX1UF{&#(LOzP$@qt^Y2B?Ia<lX*v1rmttiAFvit_RAj+#?*<0
z^CBK`)p`g1wlUjudkq)Le-XG767gf8h=f>3aL(<|!S{=Qd9V6gylF{Pr}0u!e_(!F
zse0&|Ek_9Qt7t=>x=Ut!j+i`h3gS{T*$~6F7dTEvNInBKrT|ow#zqdIV`5aeSf%s9
zm#te8i0{P8^eLo8hSAk6a<3ro&}_`O0-`?S-!wtR4_o{n3%*XGJ?%w~?J&Y-p1{g4
zN5>TSw}3U7*@GI`Cz>cHbNVey#2GH`<O=G4qRoV0^Yz;w^2Go*h%puqHpX91t;MzH
zh|Ypf9aAhey3l-EzKP%LPg-Rr1(Ay7Cu23bNAj*OU>Q~jGp_D3A@>v>7etnGcZFB9
zAUvo-m|R95jW1xIPM}clM@#0DjazDYO&Kxp(jyPcy`L-uXz+r(ZRLC_^}LzKxK*FM
znc4*OAs6N#l}V#O5;PR!V`z6Lz`23>dz6eLsfbvT73z=DLqTmU7`Y2A0d0LWwy=(*
zy3rxH_C}MT%f3v*o^fr0SscOK__AIQQ=db#p15_~6Jmvc__!jBIFS8K^*_oghV2^r
zUf@C_tpn@_!l0VBlm{dJs{7gxMin$qhYv>6n?-1Yu}y<<9fL>u2jiy(6P5-OHwTZd
z-PBE@S(>B#6piRfG)E36OvovvDbKu0LYH-(lmuz=KYyYenOXonU32~n)F~(#5`bf9
z@$)@U9w_4nVt~PG%!>dHdLj?mct$^re>iihn3q+K%-i5Y_gB?vWHn^oDu_fEZ88eB
zhXUKO%O|ev8ANSHPbLv`jWc~$@i^+mC(ZcBK$Uiw^GJ5gNDC8Ifu-*!^OvvYrp)kN
zEXia4Wz_48mOT{nL-3JfXi6+dbPPHl1w5R{`bjC!W<Iz=ZNIqBv3a<M=5HBR;&QFS
z1^Hs6W%&M-Gi0z^txf?#8rHbVbhW5*&1i9LsSz{vp_QArq+7r%@VPr8Hvv)?8aZ~+
ze27N6soSdUR&tqk21&&8>vF(`<(Q{``JQdMb)&~`LZ~(|1xLa8_A%%RE+b{lENknb
z1vuYs3l`s*LotVnmS#ClWJegldBJR$)9^#P?(7Kjoa0*z)>?(9<x`qMwzm)R#RUcp
zFRNk4Y<>VwjL8XLR?}kW&sJ-8EtxJ@kLLuB^rb9E4R|6M?rMPl((!Cc@jwuWs!zUn
z7LUv8ZA&(QRa7}w>*RliNC8{goE=6e^?)ABZg9$I&vJ=j5(n3`L!H(BS~Ja4-4^|G
zK32)qBjNo^tS{EgC4$>MH|8zjNf8I8kp|yh6g~3m1Z`_#=b@Np5_~YJzbm!+ECTAf
z<uXdH%^0TB(9}Io<~TL`pnoxdCF(aSWRMsK-q}c>#(p)<q2QR$cPgy<Chu&)!pe|l
z<lGYz*<>s{VYq|m&XP~Xn`QgMwo5LBPZWQ|*$x`OgYdN({!nRw$^-BCOo)gDG}S=&
z1yEmbCU#upT~@XK{{b{Jy{Vm9fB^?c%1JTKNuOwUG)E-F<lbu<4;7NZSL6)$BOPWL
z_#@1|zVRF!yd1#?Y~(K)jOdecoxgjB)VCj@J~d|YW#IVqK^FmTX+K%NXcU55y|8y}
zdWTz*fB;gf2qkQ9>D9dSiN4q2?jdc}zqzm8X?F}(F)04+*%SLOvh+_*^c{{V*iY&)
z-n#bk?W<tTg0r3Qj9#Dem26THGz#&+nF-BWu;xQ`0vzajt`Hpy&0^BEs~8zAu;Yd~
zyt5PSDF`6KTrL0lM93kbqhr&NL{toR^2nBZwt@;H30lGAqgf-C{3kJ2r-MN+9s^_a
zVZk^f^*vlm-3rm}hR{X>=dGDT-x*{M?bhkqh`DwE0l`g<(wHc{pJGOuuaC6&+~~_w
zV$*LmlpbOG(pQ>t0O%PKCS3<?vdu`s@!gFIOq`g$a9PZV%{YtAdngP)(hYxf2QK`F
zailv(R+l*F)0K^F1!5%HxKkPCP<t{zL|VYg93fRtV=L>Juo<xe;+pJt05-4W-NY3H
zJu0at9Z^M3^4&8_s&r@RGdax_fua04gWZs12me9y*E5^eISRD^6V5xOh0REUO#k2`
z2+&TfpvdpQIFLz%0ORq>>tGPDKY7Hk3)!0wx&7)DKsuNWK<;et`8hB{$z?-%!68CD
z=>|}O0UhrjdOlL^0K(Fl@VZ?C{_8|2A%?cBiTa<NW8h-)7JR#wk7NK%L0Ar2BMOEY
zo?DQ_xssx9VjuiJ{yO`yAD5FdL+`u~CX)EQ?cSg5&hfwIbAyzdssKfaL(i|>Pfumo
zXq?|~0RLbf8W8&-JC(0Qqb&T<p?;iK?Y~0v7V;pIas7+kU^t_P%gEb8X<uM`yc`fJ
zNuqy2Wic17li^yqe77$LXEPPGG_hKDh5u3YwN<9mV$i%ZH^L6phh>u(t#%TmnUaYp
zB<Y_nTS3Rn-#lxEkwB)cwPi(36sAq&m{Xw@)Tvb%^5_Z#(#NC-5#BRP(o-Wl%;^ba
z{{8}n`T;~Vc5<LT-^!ieL=INHijChIGfCVFDpa|&(KrW~rY(@feLco4G$KLV&k?Q1
zqFHZ2EST?F$PoKs8rgR_!tqn2->0a<pAMh=6rJ-art(v4^QXAGpN<TEihunnVfT_Y
zlg19$w=BxLZGG8mbAOIObYgSGO|QvvtTx?0`%y*o;{mvb1L|&ywkf*0`-i0G#fIPB
zeG6Wn1Nh4{BGE&ZSF}DDWwd0Udnpic<VqLTn|EYY{@T{9dSdjv^vWSaSW3%{ccVAX
z&fGZQpA)IEdgZEsQsGm8<Lo1woBdEcqYf#j+!flmT39L82D)YTQyyUErkhV+$GKkQ
zypNlVDZH?+juc&UPE1L<FzPA8)mNok=;HvI`Z@}soAiH<j`@^E06mfoKT3uNDNOC-
z|JtT^#A(i~v)$uG(&`m+3!j&tt9Rv^Z;AmESt&6Es%f&uGrdWOi5Al9zx<E_j_@a;
z{9x|L6lHCofpNkz?oYpUOH2Lj*8XE3Mso+h`b^4JP<+J|!Ld*I=&NS9*w}mySXVnI
z*c_d97_u_(f4t6I&I<Dz5W{$L^BeEo$?=OF6*ZgsbL(p%^Cr>EKu%0d<xMnHW$c7e
z_TX0bEdWwM6#<yl88f=fDbr4ava#2<$sJ-TCvSM_tOsph2blNmzyP6>&rQs+6>nv4
zXA?!j;F*_=aE$7W_J8k7LNzLSR^O)sNkfgc<!MKf&mn`Yj|QH;Z#H7aVP)OQV;FM?
ztt-~dUzbizlo}ou;0){Tl|nde<rxNGgw!`u`+9;jzg+L+!k<*Q&6Tw6lhjP2F9EPh
z*IOCKtp8heJB8s(NqU!r7c4c%{TQBmS0lG<4qNHpB_FY|<&K8ak^?}mGjNPC*Ymfw
zFsUtIW~)WT$t#>K4AW|WXY~^Gn46ypp&B18ASoXW$vuWJ`cJF4B7{_AlN4LToH_6{
zxxeaY5DEz1Vx+YM_kKnAj1|6*$+x#<&JOc^m`D!J{n`tTu{tmI_YdE0V7Da~cm7cR
z>$g3dacJ1magqQPPv$=f&_Pykq19p@mOpt<+1)AzBv~Q*UU)JpEH0Yyz{lLqSJe43
z4JG;4y3`i#BIzY>Xt)9z4kkCkU<y$CC~s*KC8U6vBfnc^M~<1*Y&OHK{~wah{h#Uo
z|NqZzHpA?|Fz0Q~=Q+!H2gf9Y95crx6+)ECVU}|vR8pB!NJ3Icy=>0MkRqv^lB7aX
zQuguwe*c2!<A>+tak<~`x7+=CgC5Q@!ftsTb75HXPkj-x8zr>RAr7|i&(0ZdvbZN|
z7$)q?j2ck}OZ4H1oC}lnXKsthEUq?g|2+N6GxUScqp*xUo(|93N#ej9_MkUB>pS-P
zapm++zw>_mzRbVPlGx5y*)A~NzGAmsczC<$=yvg$?GTx(bZ4x3uYl<?BNzws&FHUQ
z9^T{qT{Qf<5^i@LmCUxwVp13Zvmu5d8F^6<(=wBX1APABeC`($ndmp4@wgt+wXzpk
z_dC)qK4G?I8Au?M4&u%=ow|GcaTgGESVIz_#bQ1@xO1G;e`9(7KYHX!jlKHZ8w+c@
zl+B$e;P1^ToF3gRb!vfDv(u(CW6NS{h2+GMpjPFVDH6=~_CK*NLx+>0iFN`-0?Ibn
zu@8+|3z-Pl5&oA}dvCTtj4CV`erc=2<JB+G(%-2M^jvwIqC6jaB*Qv0ku?LXop%-A
zy*ZU(GWGmn8I!97y$-#5wD$+e{npXT&BsY^OV)dbb-;E>uw$!;DgmH6x}?YCO+6q)
zO6IHOzPv0gy)TN-9u3R!zPM`O*)|LFLIR|4L^uGq&m)pk4O9UxLr{XK`0JoVXNHK1
zTm7{tkH;=2GWrsizRPPdaE39P@bMrD5Ha=d$FF+f<ZSsgfeHtG4A-#-=1&Mdb|m>?
z2)6Cm>*kwMg^pMCPONOIP1LyEal04sQ{6Kg0AzmL5eD+_={}(3rm?VqTHx;2G<&1H
zX3+-Sx^sB-1ebVBf;j!_vJ1^PQbG6chE6~|ulD2CKdy#h!x6QJDWfYUi2<QiZpF~4
zGY7s+0oA+R6{^sdLi$Z%twNEnYx=#-M_)Fa*fIJx6IF%XxugX|yc2mivvbEuhkf~4
z<fV66q+9<53z&6tA@LdnpFA+UTrB*c{?XX_sd?K$N8n)7D%K$+=Pk*YjggB;R1Lay
zIRVGq{=FB2oxNI+qx)nO+)r8f`(QtfW)L)FIHP$;C{XakI^KA|UGJ*LFcj@6FMplr
zn!(GdnK-{&FWTct>oa%}7qw3Upz#zRy5K&yFfyVn{`^*8kp<tld-)%O_~pR8Df{I;
z@ghS;6H}?^xE-a!cku%Lzi%;R)S<ZnyzbGI5v%WvK;I}(d+=e3X-`bak>17513>rU
z17Q~sy#hhu*^2=Cn@lRu<}qtUFRbd-Ci+MdGOz=rPQKGF0Q2jWYc$`e(>UKti4R8i
zZ5#BA>RceK96lzHAC0_oK}`Yb4Mef&mSMUEUjkdpH**5c0cU(Dm3W4|j1LX#4X{Rk
z95fO6=PGlQ>S(6*@Rg5-m~4KvsI_^4<Fq{`Ti}7yo$Zb^)(yda2NlZQ)(Dw;$2Yn!
z?8sjs+9eK@qfV4nKI?2R+DzOcNec=b+z;D<jG66jIvm)CMAf;R-<`R`(vv?{x^@wi
zyq>Qe$ROL|=!>C+R?7$l#C6`P@*>NZCiW;#y9{12d<TB4sn)7zc6`k$o8`eb@Jz;c
z(~XX`%cb27pSf<F`}o@b4?nc~4CrADcNc$jKMc&aFnVKcTF^+5f0xcml`>lhH-k4V
z9JCks86N_eJzCTsrRW$=TY?t#5hqz=-C=-Dq_of_U~Nzs=;nK#BU3FHGh|h_EuCy-
z9)bB~m9!1Tbw5<?e68CwA+lc%E*T$j_k2dIm;PaV$k1NjIf$d?$`ohQDrBmCs&*5K
zi?EDOqQet{N*8fI_CsU5R7BFb$6PWTucC>KpDJ?MA|Bl0^3WR>E&qI`eq^pJ)I9mK
zBEgSdvHGzFAF$-rR^LE>TNS*GT7OP&Kdz~S*{qoi)Qi5clmj(=yO*NA!epg@ta0os
zX@TXC<iOul9KX<jsz|EPNK;DCR;E4PvivS%QzcOPE`-uLcliuXhyXn;`BuCOZITos
z$4!P%OV;zvE7=)yzxhp@H?l|lD+Dp#<yIwqg^o$IcuZ5O)G{4@FhL<urLItgu8WY}
zPLtDcx6f2%KR0Y{%002@2()5I=_XzB-X&dDtx(lAwZ)Tg%)C`bI89OAM)=p-e$~`K
z^`tT71IK-CV8!n=0M;YUFMtjS^ecWfP1n<VIBtp;rcf+i#}%{P8OXhZ-v6o`ewdXi
zULBv#OZ;0QE~sm38GDK4k{dy2pT`=hD?W-T8Vo#~*&W!BBFDt*%MV0mt!<I_Rsu4`
zZe{g}MMUGOZ4{B0ywjyS)kdP7_iO)cvkh5nHVao}z?~5tyXfYIz>>Oaj^50S*7EGj
zkqQBUWcah+&{Ft&JzyFSp1VM1Xtjh0iEZ|hfVDh;E=aJw(QEekG=*8YCVzDE+C^gO
zrD9DLLjP}mBm{T>^O(<&dH|CE<DnOm6lE3~YY#kWa;nRD5$G9ygmU)JP_@gvf^S8J
z7kIQgX)2FkvrIH^XY^eDn_24lOx^S712Kj3s<r!a-cXj5IRI`!-mc`>fm3y!H_Lep
zr7txUzt*{{QW0X#pc-(wtp`KV(FM6#7P1J&BfPgi3fjPJm$GK>dsbF@|8utw*cHjQ
zY_us7Nc6WMe7UOgIz_7u(GhgEAFak0Bsn<Un`u<!R?kY2+g9b5NUqvby^N}zuOG2A
z-wW6}7A(KZs-qOoNzAHeCV5+E$6OIAYS~mi`gtbQGDjSv_p?ZDhkiApV%`^Q#NV`Q
zO+A6b0jK_S7IzTr0QlkB(<ZALatIjEGAg2F9^3dS6-oihtfjOngEkJ?+gVL>^R#G4
zEl?;Bvx)hoMk6C4hAH!n^&j|VC3@24d{f!-C^cH=p6Tb%^Tw7eKRaRGAaPbqwxBB`
z_JlnBkakY6<^qFZgFAA1EUu?{Jc9)(ZwS8cjR~4NPoGk|F~F}{iHA}jZ~3(xqw1ma
zi;4D~I+teApoR5ImJEfc!ums&up9js+ncW>*G1tbT(Xn+0NL4Rcclgz1!%4m;gGW9
zfXj8%U|XKn^;aTVpD}wI8=dZvp7u3)t}w%PlV=~7yRO$;XLQ;_2sJbO=3BsBOI#Y)
zeGIn!zt~Y65$y^7Y3XRO;+8f=99|ogCkAEH`#=qQMztWujNlb$vd}dMUNF1!j-=?*
zDX*eIbtELa1p)pKE^v?5KrYcbvrSrUi>)?(cdV+=0Qix?lcqR<+}jrkv1_BS$BzQj
zo7%b8;3>V;@GVsONe}_~b1zuCj&*Ug)6{5YYOl>=0s4!<Jp39Z9<&x;_)0#stU~Aq
zHaR3*Q*LnlAjLetac`EZpiwQDCOM9j$lb%VLyR2}V<PdT#|Tru;TDR{xz#~hXQr&L
zS@ooRioX|J(X+d6bn>y7Nmqr^57pc&kTQIudgVK9#u*l-d|fWSl%=|7{dG%cogW1^
zw77O2eZ(nGfYK#@p=FGh@i_}cjuOBW*L;hRPRxm7Xgc&+HRxtM<13T+Zd%j<vA)##
zIECP|HZ36$lOBp+ITszp2pBIzpPD#*8f4OC#LEh<OJD>MD)4p|O=Dkc&5H?NGWv~n
zM~dS}A7gjc40w&7P6Q|POI|d#9lZIeCMiUD`8m(xjq{aDr#Ca@o}uh4homtNe0{(6
z?(h3VwK|*4m_y%8?jkT#rL_=TOdiWTR}{?LBi!2x9do74HZ>YNCR98*MwM;h6>9Yn
zP{|pPHxgVJZI(Uui3*W)fS~V<6X>Z5e>u)dG-+#!GL1_}4q!ZEX0brgpxe+Rcvg$O
z)C35><}=O;uvrb@1<sNPG6HTwGKJJTerb*F=_(=b11qTlH}S%+%Y?%`I{&^A-g6hO
zaxIehvRu0d|3UWEr}DnyMU>ehM|eW}GsZ;(1#p@a%~c5x7p@K;W!Hi&ev%+D&6N3@
z!XMAZ<q;%{*^;*iQq^p!27+`eTlzUcriU#vLXdsUmVHl<TVl%<q)Ter$bVx`{UzX$
zM8Z;!%nV05BL$iTQivfa7zKHnmlG|^54jM%?SlZXAi~KYlT406NSc`<V_!`wQJX<@
zq8b%a)TVos@H8W*P6ISm9X{`SEd@796nS5+JzcI91l9RAul{FF>ot+IMO2XsmIgtn
zs}Q~Vc`1Bak3leLgsB&kCzRPKZNgMmW-G=o7&xXIQ;3Hm7d#jX#zY0vf?*{*m2izC
zl|;D}5)5Ed&93nr0X#(8O@ZP^Q3KLUWtb)=FdfS|ZCHoSQn0&BrM79e^+urXtzc8z
zkT+-u1q-IsaP6GZ_VEGw)`~||_d2?A$q<Nd--1$Bg+hUXiCekjE?l{_lGYP4H3Oy$
zfhekA{gwrT83l@|t)bw&!tZVcF9t4&t2L7%sS4H$f#|k_wADinst1yNY^d6m6!Q=Y
zR)K0BLRIb}YtuZWg53ucy}|to%V|~_o$8iBM!(Yx-ZS;KI@K>w_Ip*@JWjKk0qd*M
zEM_<!%nDq*f~WPoQAx0;;1cCp#oq2y0FlqBSSduXSB6A2x<*}ooF=czr{mmdHLGw^
zl^1LY4>DSWSgNL*G4f_Z(o7g5&O|<UWU$2U{E4WKJ{LlRo>$}N!$Q7QPpN{Z`K*n8
zR|Pj$S;a0Mjd50^ELg27IWmHP<uoF$(iA=t<uf1r4X-@16c<KxwB-v5I~u=Ho!~rZ
z_8zSJ7*ameDGLMxQPoGeN)%G3!33l{mTD9hX2S@wtV|8wptyuAxJxNUMzAC2nVycc
z!)K4Cgq5EpE+<%qpR}LX`rYjuAMEQGeCC28CEO`G?<0i~bo_|or>T&@uyAeWop@qc
zP)T@Pd1cU9MMh8f32cqYBGm$}s!+mlp0Ds&2?mC^D&|}%zGMj+Ek89>b%2*jQLV6q
z*XXt_C9BV+uD}kbh87<ASg03X6jq)SUwZ<ttk=TO3JQuYuQ^EE69`gHhbfr=DrdBp
z;tR^Mwla(xmiLVui#uC;Yy8;Zl1@vfPn5@ZE`@a;v`m*&tUcZu1h@xZhN&7W*X*aL
zS4Mok67;#~n_Be%Ot*$BwOA9gyC}_2H~HOZz^HRrsqlM!>@*C}t>?%LQLOlq%@Ch&
zfR{v`FJJXh*;f~FuWsc`b9goExO?QHMF!PqCLGA<lrIMB68Oresx0Rr?j=i<)ig`|
zM@6F=_lPf%qf3XH?*vC^JQCD+V%u$y;7w_XP`d!`@UF13z8g7{YBj-2yZ63Ix5>r`
zo7(VN!&p76VdHo<S1lM8Sz3IT<JKi(PGPBo@A<qs_MR(Kx^jXW?j81-?!3YYTZPVl
z)C{lhy-@!UQRgP}`Kl*P?N)UGm))1DIrvSjw^ehfCsGo&Ak$JY^j>phsea^}=8LWR
z7rUCHuzRCOtugU?V{%&K%J-x>DKa&jB(DtV2{M>?RoVc2Ig;@5y}hUT5yfzhxJjxa
z_WgF$y~)&jQ|elHqf~?Ncc$0C{!c(!g??NHRW2DCLl7NMVoy`-_P2Z;Igoy4AEi5C
zber$nZ24Eb<0J(~ZFdr&ZoYl#Bc`?ZLiEqgy?tD3ZyQZ~7JiinDmS^Y9r?{F_S+|-
zHr|Kpyve7$*x$LgYR-VDwvaJ>Df%Xe4!neBVZUg(_CXeB<pS-CXS!kwL#7hsz<#mz
zhq^9z|MN-Wdf^L-lPzFCT`UmQx;BU-dRkh4cSm#myg}tr-=`A3TZMyum$>~9FZZ>c
zrFgjtA^Qn`!A5>mk_`8yBUxdYtBXt14!1Lt1#8Q6>Mq;AKRIXl53=KIBRzrgS3Pxn
z@%!%9sbW5BrBSZDJLgJdnt_Qn)RzRK_QT9jd_V5<w82`6auggz)BPZz8Fi~A4RYr@
zUVT5npo+KU?W}g%ZD){Vd?<gp&e3GYkIoc7keM2f?_)f>nIz;H&e5wspkofXC7`Q|
z(T#;do|I<2P8Sq^l=a#*+5*$GSf)d<=U|$$MX62L!6-Q{S>FZny5)`Q!=AF=Y2hFT
zRTC%E4z9*BMzt_n_6}sOQSd1`g?}5;3GKvuek;<ZD|2o}<|Pw5b;}CgOhRuAK6cT!
zPy1%XP(I!K{6NfpFFoZ)paXNm9lAQwr-DLcr;XOG3lnHn!u{f1!=}mdlBN62r;sMl
zWPMFh?eoP(YtuiKZ;G_)`L=JIP<(6ocjN2g_%~M1c?NjPQo7FRw4we3{VQSySBj$l
zx$e=>CK~kc7eK0AToNmD51=7Q@B|P=tUdn&&`#;dD6r~tw&J8wyJ@Eyg>EmVz3kz8
zAHm*N@xb)KgA;u$%eTUgO0>5j0!m&t#~<?1d~Z@F-|`v80`AW59}1PLYVVUEhKGpy
zdZkhDFU_6?u)HX<n`Bb~Fonj|eC1|3=R8t_|JvQX81YWLVAJxN!HJ=kjr=097Y8l7
zY>%wE*We8)SkPJcPc5;B`gq6shhX2;DEm)=9m!Dl1G!2h*Fz53J<#Mh1G}T!RMjc+
zelJR1Ao6BC^xfh$t=Jd|5%S@eOrM=JrJ8KpyAxEWuDvq&$oDwP<2XuAp_LZ|Ll<^A
z`V(K?<3)OJ)!}&jYv;a5GIZCT*vOM~R-`H52MC2CCjIHM_^vynpz<1~-?b_JTz1F@
zl6OWtr6$feP5iq(UyCjyQi1Qp7ZC#)ruOgdSEfez);=%46hV=IJ*nnD*Fo?_w{Uan
z{>LdP+nt)1IHo2!J0$lJ0z-_E)`@KtC;qZh{T1o{EAHqoE5^+D0oplzzOxE^@jAHV
z6A04~qv**%Qac#8+$}*Lu|%V4pdEFYCHR)<%ONl=G)HXlo2C1-xaOd_bt-|?$xghU
zx7fMIH8YlxI;b#r;m7pF2R5_&Y#EcNbYBzSvg0+$1~s(9w9?;<!@q0GG${16+T@cL
zzRa~Qjt?91*<SU#9f?qY@El~q{hxJp0_xue*0Ze;HgMr>^JKSt1;Xp!CL{R}+n2UF
zfQ*?z=@!(8n(>4Z`$Xt`;{HDQlt(nn#rJui0>AIOtGj7TDJz*R%$5_#l%_)>dh(^B
zGQ{AAftfU;E|4NVYY~)8ydE!KPqAD~6p^yA_}E$c!M1D%%9b`QSD;-L{z-{#qxt=@
z3i-oUSW_nqOt){#HIo&?!Rab%+esj~DUJk9`)@wEK(!0jOm46u+<n?c=s0^~rY#t~
zLmP^-M3mL(>@?efeG$?R?4AbeQ1$y*R*j`CN6*<max^V$ZN2yuaf71WPEn{aczoNe
z?atG-`({rcJ$?Eg&#b-oY5NPaXOA>7ji7Cg5hdzcOcQ8p9~83w)SWNsC(<F$p^IY-
zm4SCjgr`_{ab6lx3T?W$W|U4V^V~#_XQ+9i7i56lsU9*xpr;wK+WUQ}pI*Umerbj{
zaLAyo?x(}1!%4@jTaN&}L(+LR9hoCnuN;w~7|=Ua`@~16wtl4U>3?ajU?VyPc}F^^
zCSQ`E(2?;MzK)}Rd%g!|4!-m<5vJmiC%QOx;i=IQ?Mu6m$3^G!EWUbH+@8+9>REIC
zAz+PDq*7GV4nKR=<J+at!be!WWYxv>YRT9sgUmpzd;eNc+$Y{1eJ1C~)df<;864$G
z!QZ)i$uqnGoe4gLVW#m%stV3xNTq4)N7C-Ic1q!e5>05cix9pGvMNLUBAxeHCtV5e
zC{qKvS=Du{lB`hpVfDjvyU!N@7w+faXA2PGoSUEt$Ns|4w#Yt?-KxZ&eYW2`6S=qL
zH_sGpYfW0YX21LkF`yydU$mm)e!0OZ%U$9J`Y(6rGyd#Ab^?wpa?fvkpMyg?5C!04
zT|(9X3tVOor14{v-5;~qWE0+2qMj<cgPh7_cz3=Q!f*gcHW0<w@7;8yk?5fa2VC!k
zbWeRuyNV96NyiE)`>9p2IVJdGXWeldcMfD*om2Kt2=^`nCU#{ZZRk7WX;I)sg~#7`
z0i|i#;oWsmp)rcd&W5C)1m4-1VV3JtWOntW|I;(;ORt_@Jr(fZMG(JuWaHR#U?H+$
zLt>Uys!juFa_ywN|1OpwC`Rf^Q&xkw(=Y;P?`-3=V&NFk1EbUPX}syrIhud8fZ<k!
zx23X&KYe}MoOp0k>&^Vy?D_lKhl+2koO<F`Dts4L|E4%?(wXPmivH6$HgV5b#qxSm
z;*U>bcMkt|>->9@!G@bV5_JFDY1O+`hL7)!t@lT7d<iLMAw@{?@m`rW&jEV@{N8=}
zeMctvf`bZh%6%j6dGJ|DmE;5wVwQ2K{o=8fa=1C%CWR8>dPnSXYPKq;K2zN$J%U$q
zw=SKeri?@1#5meW{*yk@v&C|9>sPuSIqvWbxgPl(XslhZoIq}<Nd8=G)Vz`zslP0U
zeoN@Y>rDv&a#}!w5;t^;kACgq<65{#T7#}A;I-#x)SgMuM?M;gk<J@^!;r@4rI!X5
zJ{f}vBc6T?-{1G>iPS@b=5VkV%r!fHr?Afcw&tseL#_urJf3iu8RCJj-+a2Au-KO)
zybn31D3i9~t@P{?u_PRywrf8)nfCiHKT54pAo-?_r=GGr0%D?^oH%WgA#S)ZuwGsJ
zUc_|<<p0;+{`QEHgkN^oyLBD4n%dW0WqF0iRhXX5%D2O2PMmr7XxHCkHbsD^Jw^Y|
z;0jn`5YN~&vV_bkKO4|Cn<#TwI=zCo2CwyssC`@Kze>qwA2NsqPi>TWfy3{(*>}dq
zn!Dse^uunXi0ZhP2x)EV^c5TmWAFbwt)+IXWw7P3U8wfP>>YNV&&r{E!K3o%gIK|2
ze_r%mbKnPN)c%I8?$AKmT1Mj)b7Cot7P`e@Av*C!_E%B9GF#PWgE#-+F_`(coEVHx
zzRJb94WXKvsP;$NXC#}$<d4E8&#7`dyOUOi_kExF!O3v$(boV+A%WEm!oPNH-uC#>
zo+aO|a+;~_A}i0EBaHI?!bbuEkr9xtGiPsH|5P1kxqHt>TCXK`0mOT%6@I{`YX7nH
z^0AW!!)qURmEEjR0e{!~dw<!hjrR9)n^2Cyx{;;3LSC5w3dn0wmG>)wzbRAT9)(e0
zv5S}Xm}nHAcrifB-s!-mDROb5`(_a?#4mln1Qb+l$oUtl;?m@~wDj|_ure*+ui&*t
z?F`C)MVHgHV&^!FCP6)xtz_}%baKp?kSUrCPq6O|nu(PITq1D{90Mbe4@)ywpfs^4
zm{u`h;21%Ex9@*=W~AC!1^(EdODbS??sf;vDV5UqGiS@f`rdk|g?`r9YcJb=Ka`G#
zHC1YSR`{X|<Z`&Gea(Eh&i8&M-2MSf?u~m7jeP1{P7-fUfgsthbW;J?g!dXYis$Lf
zW*)}q*&A?!ZxIue<k7ltTFx9R5noxjw&sY5$-k{uwSZ#^PyxkMR)Rh9xKfNCUqB(Z
zo}eA2xZ<11T-5oGkxJl^x=8ukr2#$mG5p7vnMqH`!Hxwt-fb==N)=ZH4UOV^JKTV8
zx(JP~7dil)N~zow@;#<tHWi-c*iwdg@f#u?6W*0HflgNM(>F}UcU!q^nOo}}%<Gdb
zkp?|%pHwT%WvpHgh^a+iM5LCFJUC2yfxG^d)+ev<b(uz8={wa>SfzC{TUusLK(m-k
z2sELoNMYb=477z<y8v#5#jmYN6HWji9=t4Tm|10D`e(NNk@6?T!x+sv>`a*MGqE8|
zTj5>*pX!J2{_=1qx7-vH`{F%T@>;^u<KCURx+CwWJ)eveH9(|8{BIQ6KA#c0fBxr}
zfP4dT2eP;^-EcJ!bHl4!ySOPgZZ()7?cMKO++6f<HB|S8_wdQ$2RDDN9wqy#|Bs;H
zu_og*DB|;~q4;6qXPVj86XE-nDixr|J%;ts!cFg>;ynD3<0;a9b3{IIrfx?4K%tzl
zlA?TfpO99Fp5JF@i53sQ)dapSH#j3;5fepI+zVL=v<8bj<nGt(v-khmFxmWI4=%z5
z@}IIV5i?j~gq5QbK7P5+{{6fk{4k1l`J$?VBBK$ZJYI2Kb$bDgNvCNdK*|4uHveb;
zmW@cs4#p|SKDX%;mkLCjRIL!%7ftn&N<rI?28rqHe9sP?IS}4ghl|C{nw@m`z`~ao
zGW#$_yMc%zNkzF`>0Ghq-hu0-4whAgMS2O8O9_7$<Ya^a;znl&?$q@`ot92>7f3$V
z?3IzwNm6-hzHCI720)P(Uh@gdp|7eN2`(~^=A>kw*$ZF*)i6S*$V`K-PWd&LpsSdh
z;p=m~q-`(l^ZY>{F3w)Hu?hE7Q_+<=OH>B(NEt?Xg2^WWPhhtNnB?cPm(SCC@#B9k
z8MV6(OsJQ<e#rD8E@PIGcu8uUeBB>q0Bh;u)I9zP+<KonvE`hMDUh^r2q+1>Za%9k
z?Bi5p{Zm!RZ>r?&JMn8$-w1bI_^6)SxCiJnk!bn13~zV6d*qCFd0B-OKJYi<=IVRo
zoxbLo23@#x{qM`sH6w4K#wJ&a10@g9Y$b{v^v@5jUVrPYI9%%|c|HUE0iccH-^O3Z
z{tdhyl@q+E@Cn9wi>F_tf0^AI*Ph*cmZ$C#BHcU=uJn%i&|x_EWI93;Sft}pVb;Q%
z9ll-56QWufO*3<|p9k4;KcBC5%1@0s9sQdE+f?<MKUHf&@oGf^;enO{?WxE9gs=i?
z{zM9Gryso#E&O8BkGB%{XvhCsDavJa0==1`eYUQQsTWyZSm*+gJn38oU>Bl*8k<4H
zo(ngp95oZZS-=A@39Bh8=Sj8?z$|!%eGbB}|B}+TTW4RXKsm7Mb~hn(L5YJsW^R9m
ztej<&PyFu0rBlB9fJs@5A;_`DUyQ;fR~rV*I$<}%&Kg3>a2x6DyZh+*Pn+C_3*$jc
z%TL%>wr`%R{7IqJPw^}5=l>-1Gf->?cuuw@=f&_K(r`Iueb~EIm4Ms4*N={=;OEdo
zA@#on^+uDC-)dE+0L&Ww%AfBbf=d#g23V~TJh>94NrD)To}P+;Sgb*AGw)kR@i{c|
z9a!UYB|&)}QBdzjsQ(%?kOT{jg86<CT*f29?w<xYm^xJ0ZWg=+KrZ9gfwWwAb&nj@
z&G5A*AQ{=nG33rYo2U>eflAlUNisQDnMR%DoNwxP?oV}yi>PY!%yF@o>~Fzri%AdQ
zoMjQ>nQ?_*Ctt|-q`cV*`lYGu`e$GYOO&6^)4{9rA67z7q93%-Wom{*8UW17Q2WRN
z6Wk#}VN*7O5x>fXv}$T62CzMB(b+PA8=&{Qsn?K9tWZ-k?S;Hv*3+dg=FY?Nk@JGd
zL-MO6owY`zLYI5ZRl_DVVMt|xgJaD>oF!zcQOgVSlgn~5Tug{fydGP8)tZJRi1UbZ
z_&PeKfFspTmW<+HoGOK?I?!2UX(k7GtKq)(s@I<&b>+2F<pWU#pYIhq+}LEwo>Igq
z-PPX!-Kg&%{SB<~YYNUO7d1~qmv+mCgIpY$w-DtL)r<IV9Od{^o#<4#sj$Y@WEmo#
z#(<+SiG=<T&ZdmR$?1yZI$Y+0D_2ln{y5gr0j;|1?0Bq|rK_>@QEFpOE`dua4Ogm9
zPXQW2BiZD~Dbg|EzJ!lbWr3C({P$^$%w4wFIrSSe7@Imb+lCmw<^jKN`AYhCk>(3h
zj{yLYGAbxyaiob@*-^Snz=H4xMD+Aa_e;|{UxGWt&E1FxAwM<0l6Zdwjn5*JCxVYA
zMdiB(na|rRksWm<1*_Uc9#mS#)@3Ag91M<V9<C&8FLya*C97bFMJtNH3|`~goWzlS
z8|`~yr&JI8iNG_+o;4{4Mxsf7s{Gokj+}gH6CrwIHM&mjWpgDR=UH1&Ob|5>mKdfY
zfAvdp7qpC#gryjxQqEQj2jiwVEH{F0{rGP!OI&krTa&>aSWuL%RiqA>yEf<VR_bDG
z?q4|cAgc@xkb@)Gg<<+6{JI#4je(7-nE$}HRyxDV1&Jv#9S5b1YTvc5t<&!}kU&PK
zzA^ZMH8`PnpEpK-YoeV0Y_ae7(NR0fybHdTOKBa(uh5Hl%i~931WCWN>#1761`Ez@
zxIaoC=;MH7uNc`>xpv%1u>BaO*DbNn;6Z#B22ae8!`v*XgPZe>aFb=0Dx6pB1ZVJC
z%e6Y^PU2gu$e&ieZUmx|9SWxe)kbYZpTrQVV@n!i><u-9#R-VWwBFLo@GFP#H}7~a
z5l~=`bT#7^P=@Q_h(1q-bI0&yY@#~SB@BE2F-I?N*;QZ;)vq8Raj5E=Z8<H*LZ|3}
z)*u!!FZ24Syg0{c{iX6`te9MLD3>6QTTb&)mJd+^w#tYJ4a&Hd`|+W>38DR?S~nuO
zlt)?is<9;|51YLRgsDK!)A>5$VRC%~WUrRJ$OaD5G;J6?C*Uyf=>2{J9|fFX_hEB}
ztKo|L=)nxtBBQhJ<!c}PqFvG19?kQ!XgmiKzTy771KHORgQf^A11LTavcbAe@UANO
zu15AKy(z-`LtG$g#6of_uwq1=5Ff-I$yMD7@*lZFiVxn`8f>u@Og7rPgCP#BAqTcX
z2rd)|U1+8Z32&g+m0^|)MWonAq~`-<IJk`$>Ot{g$BP@Cbgz%bQeC&2DNymkaV_Ua
znUgv)8`gn8%EcQ%$@Ars^(j*YMBzvs^?UPf*+A=KceR$St;&L=7%Vz{(?w48M0R|0
z6j$#P^tfoM+)$%=1BV3WXl+@0^6JTIkCUb9(L|;;;eA6O-yNBm``WukQNIGCx-Zco
zRN*Ga)aj}dTKn}|W-l!*2u7xgaY5MWGWcSLq-NT}K!vUN3ssrsm1QvIObTHrlW?vO
zfoEHN<;D$OI<b?AKJT8J(G#Qf1y?#mjtK(4!dp?+%^L|?uNU#}*@b`NwMPi@GQaRS
zbMjsXLf3=N-n|OZFeasXs&OR}6f`iJ6@_5>O>95@Pluk=qPdIlCW70+)dNfk;<w_B
z5GmrTdirJV5_(GUkXlR-K{GsX9?caE;>d`SyO^MTsQHVcU`=yF0)ikOzn?xW3VEBE
z2oqp+bq4jFY33$t@On7d@t`C2i$dsV`N(*^Z?EyT5zfDj08>qIS{H7MJP1pDe_`&(
zA|A&Ch0X`!7$&&YX4}$wH5BDT5L<EyC3kjhO3Ij!MfSYqVAEnhh^U5qut|HL;q*D(
z&o-gC7(@hve*PuUUx}N}YFo^ok!$H_vxJz<x)C7B1jEj_+#Y-X&Mo=`-juxe3Aq*(
z!tC5ueTs}`S|%EN22(Cf$s-68(dHFDk+yupofQL*ALJMS7k=+=WBT(^sFk3IA3=!+
z7UX3D_a63d^<=>WksBA>lqjj^USN@3V8^#?@h+k`dJ6AoPuLXZVQXaTR0&c02n}cC
zn{m^;4T9W}R{C_bMa!crYR5;Hqi(wBoVO@|H-3|PEl~8m+}4LMSx&xP&t^7o_8mB*
zeYn#|(Mva2;wTz?%xNG|i~2ii*#tvL6(ue={&I2@5V;+u)Spw@<lR(C_B<PSq==xU
zOb{{Y!H*t)Ro6iQEu1{SzWxIunl~q3&(?<|ht?Yh&4QypezxZ;53xQNrFbb*nDT+E
z226jKHyOvfpCy#C3wQB=4~Tf=THR)xg~3_2Que`5qxz=GDVhXLNU^y}g)L<cZK)u?
zQM)p;t^dQsJxXE<-&rcxVD~`fwlFdOi!vZnAV+~0i0&~>JEbyaFO^F~7+ineC0fhV
z(NL%#6?`*S)I`43mn=7;W8NC0SN!YQEW5B(p)&Y-f!quH;;fuYoATpF>elmTm0+n%
zNpBv=0Ydjs+dfo#l~AlFAIrH`QC;$Cq2y;<^Q~$531c9Yqo<vd7rrQOodQ2gkY6Tr
zPe}p>&7YnFvf>IhM;9($R4`_6<cV&_*1QQ@LzNI~QO$}-kPiVow>6sL&Yz#g{{tQ%
z-8|(e>NZ8|Qk6%L_kbPf*H2IOr&WY@HJ$iE{WFX5G&EG_2hhfneb&OylZ{>D<mqHQ
zJf$r?QND5Rzc*9fyK@p;YvBlT$0%ETXXn31YxqX?%y>yndXdHRGwo`F#=N%cr-g}r
zFZw%Yf5}rotf_s#5zdE+#gR=DJ?<<0(uYJm1lfY3CH%Y+`6B;SNbM)kb5!RRQ<Q+<
z=x-2u5w<Sh&gu<0cD?hY;XztCK`oH7nb*DM<pg;Wo5s~hR4_GMvBqtryz&h4_?0W`
zrl`14CbN|*H`I3L*YL1R(rzPXKqPfIG~Ez0pS;Tvs+EjJ7n|d+4!qksa}~zEp@>)k
zggboMB`SL3Wk~Q`&0^4tShDc+tYr~bd_&=m*t3Zz4j+61b%-G1+RTK%Y{96M&YoNy
z|3ZF>(;r|l=?j0gp88>&gN(J9^0i0)v3~iLi;bBRlbU<Sc=m>O^WPh`#dOvA>Dp)0
z_x?>c`8UB|x=ocK$AO8bCigL^!eG|JS^AOxtc8|-rb`nf<6jd-{oj2yeEUpLJBTAy
z!%-FINYMxJqk&@A{+V|GW<;mpFO*RBm)`XibU8@+w<PJv4|yr_c-@(%%j<aJh568`
zbD!Vchz~~RWY0$U67tCGuS6t*Dr$|>F%nxH7rM_)wy~&q^>1EGP^94>h;uM$8_Qk#
zmx7Ku^2u!XhH9!%$*O`AO(YM5ZowmrK*uBU%{!_^=OeT=WB=1W(f|<TI$n72xFTV0
z!h#10<7Jp~OOehCtCybNb%Yr@m6jvGBfn?Ny;MZY{p@&Mvfl3P4cG<wGWMQ<fW*hq
ze+(?*a<pMQd10$-lNYKQ>$4CFmMOKg4+0iTcS>|p@9!g;*iyos%cZo+m5vaV!-Bk?
z-MDd$t7dLb8lhM{PF3bmH2b)kqZF;S@^#-8p=pl%00FzS5DKayAv+hpqz1X)O52xK
ziy|5z%MGxU!K|`|gK9?Fbrqu#XNkt92(Wp>!q(8VO3UrmyO3Yrb&`&?DAIyFW!Yk$
zs<j#%1n$cIdZt>G@85f4Kq`!)zDQA~P=TO#O-B~MT|#@neJo&u)pO4vm3L)gHGJAL
zbSrvtrSAPR>(Q;Wb?Q#-e*4L(a-c}lw=Ib$pkF<7-Qf6id#1jMjr}fonHZ#&{GWyh
z>fe=&dwI@TF@OIJ()a)%^DweifvN~d#)D>$39JduHQxs@p|ec12={o12v=}TyWAac
ztqSwcI{eA-;=qPa&eo~xA2<vlY0DgwrunXj_y2_MK&_P-Hd!>p%go}&IQT-pB;wNt
z%Y!JT-F^vrQDMd@-kd<P7VuODlM7vAq8HnZP{-nOr=kMay1Vq<cCJnNJP+%>VRjK|
z(YE;+RPyhK#1N)3*iLJoR3WRuUF|WNA}!NftNc_%MON5AjDTksSI!8zSOzscfR91#
zjU+Hle4``&pa~_pxbCm7B!b5Is(EyVh_iiQ`b7GJ7gpOD)pM@A*(Fw}KzcCxtW^9w
zi&n8Jn(T&owslY?5pR%5J3nU&%WmZ3PuAY)5)Gi3XN402<x&{e3{}PYL#{Ym3Mkoe
z=%)`9P1T>iX*9`qde#pPV&%Aa{@$B!#)-vE5Ji-TSmGso*Fd&rxmd3&mo{N*&g=SF
z<qxv0l?ccLDdWnRa#`W!W1$6sp#etNeC%$O=%O1t*VBg<RaWdq8|Pa?Nyp+h5tNX<
z5W0P!q!b^MyT>@W%r!tFC@X6uR;J*RTJOxg=evTDjT%i7$x3$KnA@bgEJBg^z~+R|
zS!ZEtAO4j{0j##Hhsd+Rv}_g@h}V2v=p!f+X_rG+Hy0i7(|*4Wnw=+Rl<m#dQ*5P<
zB`lx}|CEy}15iE{I^J7yIZ@o?*L4CEw|eo8eV|d%5kpKm^+rInSBNhVHS{2mDb0Nl
z4LorwMB4Khm}C_@!sbEq*M%mF6|L%#uBx(GLu^92+MB@pCa43kV=u<O^jZCI$6ySc
zZ59ve4k3GB+1P)nXiQ}ILgAsQH74r;d^;^yCKq013wZpEdFP$X+PHji-oy0Km}ug-
zVY`2t-IU&0iHI|^si<2oSw+M}royd4Us%^zimRQRpL-=tj_yZe%7PGf37>9VM4nwP
zzwCVWbM@^!-r1G9`y*$+H2jA=x7z%|`P|pm4|(UlwS6Bs_x(8!nY6}59ZXv9k-wa@
zF`)Az>Boo_>inil%n?^=WLHyqxpC)6#pa%*fqB;G_akRPASF7deX^;dIN+AOdzIm2
ztlrD(_h0U){Qg7bv9KwCip0JeN8)zIm4G2ie$uL)^7R;ho*b_6p94BE{td<S7E_au
zyI|TD4%v&q%#qA@FylVXBjG`rFGwuy#vfONP{tgb)C(L@sH4;9QwFd|l`zu(;3kur
zfxwiX(|vPm^^Z!YqLdEC`HjmS$4?BHRhDxSI_M5NBvJ8u0UdWJ`vp=Laq=%1MJ^bS
zKO2~Pf`>@MCYgyo^SOps8o(q3c8r@iafld?6gggp576SmH`jqyLG9I&2!j0-Uk9!q
z?mc9i&eEV|C+noqGyD!e*cVZ7=E4tteCqsVT`2wp=vtR*Lq6)P3q(Y7DBHiK&t@wU
z;_l3b8J-=-1HXIZzrt-*B6Rb1ymYOP1l<%e&K#Oi(gOYitUGr>O+1?%YK=gLDlAbH
zFPMM2>5WS+xGWdIDgsK`{4$CKO+KzL;$3||y$=p%{~LrY)PP-x`@|~nit-OxodlO|
z*nc7Grhe@~K-f0Qm$n%4(Yj9+Jr7TFtUMA>5Wcd+JdhA!5cgurMMrTA9@=Qn6JhP?
zI26z9OEhr#1vNzqTC#GAUXcZIsc9dG!G^gWv|nu@P(AOA<O)8Fn;X6Ho*{zN>o_jt
zCeR`NcMfGW|FMYgW}l`RbI+cp3=Aem_^UeBTZS6M;$-W*533-K)2a7fhxalYQ*s0B
zQ!Z~t&4_(lM}2r4Lm>a<Cn$^DfGT$x8yluGH(WF_PMo?^CA8u#KWG{(tYqmQH+(f|
z>GIZGXqj)z3UQ~>gR#j``zRgux<p+fyEw0$bwca2UU$uKW(K-kzz&zy0ZUj^kh?m#
zUu?pKc_1=FBmxid25a>BpqKYA_l@eU;?oVRQ!kkpWkhL5JpR%a|1^zvI?x5o;tcEd
z%CCp>y9XQK9^hW7`I#;gA=qg~B|)|&C*u`Y>Q>W*Z|U_P8!l#gYCN3jv<61Ovm5!B
zzyDG4$wPRblb;Zh>vjkd$OlUoN58x_+{`TsT0IUGnCE5TI(kcM-1}zXb~s}2DCaw^
zhkD6$51y&e(3E>BXF=vmLa+I^rpp%*i+G{LKALuO{^guSMUBLMr<2WBZX-Ub?oS+W
z*Y?>(Q(>kd8j4*st^Ha3A0^t5$o~f;by+&?yayvq5Vh%x3^OpJ414sftG~`V+8VSF
znQ*L6B0d_GKb9u#G5UQ;<ckREsNz$ODZ`*~-Q@;6n3`+f#bZuuU=se;5U=doRq6PD
zk~tGWoOJ!>UX`5tQ_hsgnc_E8O?7=WP*o(Jsc?1u*IklK#c|=fevJky+}!V|wdfms
zo$|)<i+ty%*gZ|k#rcSEs<akwigu*3tol3yg7MAhRNT`qrvG*ZNsMXNclv+3-P$#i
z3GQ+*t<)%SCsLzasLbbT`344HVX^DKtX9r{5BqfuzSD2lf1$7Q;^XbyC+l`5I^d<X
z#Oo|ky9xDD5#bp4fO5*?5%DaSSFG3>d3n^6j<~;*z$#bA#w!t+>UtTaQHkSa46}!i
zX3+hp($B2BXnLS*YiuCq*(}VU<}O;xBnbE31g5OWE0}_f4_uNnBE})da<*kYE8h@N
zE=Io3@aaeuZ%W>#wdJwy-}dW0ma*R?{14Tz%JH;zPAAD|;c_B8_<QH<18nM8YlA?i
zUM#^*{${?hB_;*2DK-$tU|Lx{^LiMk-^8xyEW6>(k%a%X(N}&{+zxUk-uV9a)8wrM
zZ>c1bTO);9)T2dq1RI(Ux&W*Rfw9J5u}14lOu04|(>6p>{6^7qdp<j8IaO9_{(;h)
zuP@=sdTwraTpAE*nNQQ4!fWK4Yh4X+wPhTuNi{po%u!hL?X>o$vh<zv)zE~s0&hSS
z^5X+W5{QfnV&W;^guY;h`GCMi!hIvBLmXaI5cGI!e5hDKA`(n^XB?8!p=MAm%2|hY
z&eC{*pq>iU;OObjF@DKr!OnF-$qgw?np9Glz)pvlUln1GCfaR?+-dZ<+Ty%ioc5{u
zq<xp7?^VV9#1yh8-=UV!xl8ysw6ilt01gM9wgw6i1tvlAhxy=>t^)ADgkd_~6HnZb
z*gGYvIM7PWFuD~Mw@OHK+DN`cR;9v2Y*^IoHOq8RkYJ#YRI{+FJ715>Y2=SXm5qea
zpNA3}32|P?olz%j^x<+ca*l+YTg!OQ5_2;?pB$d@CN6P2`n*H4Ow@9)8%JktmfFx2
zU{iz&Ac#G+CH_o>Pd34iH1pt-bEoGwQEepqJx1tzbo37q%)g=laZIA~IFq@Kui($x
zSB?I$hJw4}IynmCEIY9tqy1^LlPtmrNoI^isEkE!j|y3cVV<s`Hmz-|67(%i;vN<|
z8~`((5*ht9!88{bg)G!H;nw6L#QzDN)FtdZCFndR=o$zQ!~id5u}v;eH?&Zt7>4;v
z^gyUfDvPiR!1vgn2~mhe@x<_JXn|`!&r}JXYdU|4!rKKf*t|qCnH0{l*hmNl0Egny
zy!`~|Bwp%El<;sB!B0`~q&4a$rjQ>4oLoC8vX11xnlU_)rxAnwMM9azrj^)Z&Uh8A
z*b~aE5BPrO>D$iR&+uO%!hjRW=v)`ih6y3*0^`rKaLo{jgedZ4KI&Pkp+yQhKmpSf
zbNOf{x|-w+ZxSvf>HL12Ty&M$;z_v4GS2QdP8)NWOvwqno)ZuSzgZ@mKqtinTEvpz
zn&OxMI)CC?fp~Q0b}Kx-LoWssq(!C`d@f;mFtwVP_Z@D8d7LLiUlRAa@$`v<ws;t`
z{{|=1$+H(@s8-sWS=wJ)I@n)2{JHdnz|AqWn=c)1(v+bgQ4B8lyeS*X8ihyM$($U8
zKg5Yd;rT1wG5>>u;vI>BCYftOaX8FM|1B)J2%aMFWEB3!`(}F@d_&X<<f62BD6pH(
zJF>He>>RySeT{$pkP>^1TJuo=h!7seBTgELX3S#$KEXAib!5ii<D`R=O~`6G>7=#L
z0?T*~Pmv+W1+EEh8lKF!Qf@Ja)f9}Q(c!P@!qu~(Q=>EvtK{DkGp3l{)+=2%lD;TN
z`1&?=52NX;=4Ha!*V(8q8zg8Dh}}-U)lC+<(TaIiM!+-?yoxRfd*-P<#t32fpGyEc
zbm6jO^wAZ9bWk3K3~S9N^a5&dw!maZj`lK))@CO03&p`BGO}t&M{8cA`6H60L98k;
z6rh*MvZ7?yix0p&5Y8Zh3KHViENaIZtH);ZI@nntp>teJF&&W>#e;?<3;dYH{=@<G
zXk^(a%m&Y&arLlYG0bZoHPQitrQU5Dxcj{Ba9W4TBpZ<-37nwIwinhh)XkzqQJ$G-
zn{MO@3~<)ax}j@do^F*f+uzf%5QMMZ9=%2i#O|P7M#w_j^du<|Ir%Ee-vJX*MxbY6
zY&vAN>B3!^=)Zq5L4YxcE-W33FvVd!0O4|1_19<3B#cr1Omt$D?AIcgs~T2IYOjDg
z==DmVDcLJN5Z=O~rdbOmkMa+XB4VSUk2{2$tg*MyLZe0So(|zozz8&2D<=))&0<sO
z{<&pBy>vudS+ghz{?uCdtqY=p-U5oMv%|qduJYh_t%d%I!$OYUz1t|5pW5O$*s_m-
zF0vN7=mO0^Bi`bL1wF8jqY%9;q<kADVoE_e0#or5Rf!fkHIMp&hK2s7To8Kfc^8qk
zr#ZMq!$Gj;pHPbqO%H-AGw}TRV|NNzgmJ8J%co;nRsLVsP^oc`nmQB=7~<WHsJGUI
z)1!D^quY>#&<sC{#b}r>M!lB;{LmT?C29}S@*e)u^L2E*)QFNSFxX*HOLtJh6;NIj
zDq!xZ?-LYfCzms8Ot{i;7~S;nYJ(q4ASqTGyAG9ZLGj<g$bLkfckvG(+JDlJ;#ZNe
z8^41E!IKv67wwozd`j5u5YEOE??&-tj{!jVpzJQGHIeN4qf)~!`f^;8{G2<*0)(>r
zh*D9wND3B~I>UlvTAm3dxQeQcM9F@RI`e4_6`q1_iIRO*D7olz;IK51+lX?BGy1rO
zIz>Lcixvj4_;*KL-00lhWG=Uit68dk_9X(vRROthzS0pK7x#npn5a?21ioUKB=6zf
z<yM8EHxh2UVc?XmNl*{QHAjpfT(NTf?~ZAVpt|#>_Z}rynh2$LNX}R%Kbmq|@M%L*
z17<dq@avbmlck37`~-dY3`a@lH_Gx3bR+1h=O2Z$;5%O(I#dacJuFmyiJX;Q&FxI|
z_W_uBbmv1=;nQl;(t13UZ*uKWQ~$_l|7{seCQkp9h~TDAaXDM~nc@APb(r%u=iZi4
zL<9RnhA^_mQj!E{e<bE+0;Z<`rN-ZT9|Cx=_HdK%TOHhs$9v1kQBpztp^Z&iVs;8U
zN@z`ts1skYCVv2{7QiER>EhArsQfTJ3c2`Zg!_7#_uE<28mYvfms>H54d0Ks<0Iq}
zhr*QzX_U&XrNUchQRa%HeD~xvWH8c;sPO#)(P`)x+$zi*+xQ_S01#{<Aqvb;E7Bvo
zQNluXd+|!xi!6*E@uk7N9_cff3)!b8XH4H1woVEGO)SEL$0!Z}oZ3LaVk1^;+l1Wt
z(ljxx(Y(GLKp5zNN;dP`01206fKM1q@XjfdBGkDkI5+w5Hc8=dM@}^pZGf%yY<nu+
zR3$Us4IfMW#S-AHAx?TAE<gmL{-I)?*-uJiKA1EW5*$r)JU$3k6G6aX7oqZ|N^d2p
zN#K?g$ap(yNNkP`o_>Q_&l8VUbJ3dU!6rV=M|rvkoV|j~2eEfq=?FikmMle}W8@*o
zc{8#X8ZVpg`hp7p4>rUx7_B&HOQHnEX%nRq%s<JdKk6OxgL+6r*ZC{-!U>T;eTQcW
zQtB%I%de<c!?KQud@&4cl70B}K%F{9j5aIG15jrO-jgnML{|Z0i{VN32V4`c2Me0G
z`_=S`05Hu$?c$-AX6;YD*7Y#+=p;a;=k46^x-nY(zoPqG5J3F~>M$M}DT;9G5QFU_
z&N9$Xq%oWHLFOh(NCtR$Vz5A63ZJdK!xBg;M3q42B`N%w9r`}Nf}ZmN=V_rBnZL}l
zQCoXRdm25M-0MR|?L;9f)I<(X4T+Iq9v42gWunI;G1tlnuOnx*x?l;Rx*h;Cy&Nj?
z61gMWe8^R0x9l)brY^JzT^<#kUK<&r@%he1Z$`cV&=OrsPH?h6AqO2li@i<cpCtFh
zEn*j1_?<z*;t3D)@Orp5q%#O*6Lr{`9FYGFb!GQ6Z|$lyjpr{)Sl(oyJ<&+#l<~lL
zsHsyRXBHb#Clb(McijTh_D$-tkd@^L%<EayHgNXnbJJEdBDzuP{HV*0b!1x^AutGf
zp|EEk2iDJmBM8vDGX3aa-Stuai)iGlmbM-GjKAzW{d`R`$0@K3_Ap9*xiQq!5fy>I
z_464j_$f5W;D6*=JxwW3D&KM=VK|xJ2Jb%++FsB`Sjt1AVj5pJp~OYk9I0!t+wIxH
zdq2*jZIa-{4&fOMrTYNvLXYhJT=e&X`>AyJ9ug|G<BQ}RLb`cU1oXqu>WAU&R2vt+
z2(-ovz|UU_liFdI-@keXQt3#&3l9_y$%hp@<#~Wu$X5}fT$sdkhss;P2EHyBpNU>W
zYhaUVpyEay=T#0i7=-X~vlC^fti_)-UR#~Lv^#q*0(~_*6K#+q@0?#4zl!CnyLO&|
zj=yi5a8dSs+k3H;(X;xf<iKtmIpB7VaE~3*Ny#}z=Xc7}|D)+l9GU*($N%2JhGFiT
znYoYVJ`%ey_brLsrBH~Xl-Xv6xgtpvQiwEC>HN%n-x8vPBvF)#lKp(Yzu)hVc)#B7
z*Yo{&J|0%Ynb80hk<DoSn`h$gqU)t+wrUsCEe(aca6!=<*L)g&n&7v@TDw;zfxhyu
z3D}d8KLid!fun$dK&{)y)?^X)vn*|Nh?c<*q>!qj$i6yPChmXLxol;-9^OGtvJ6;Q
z_&02<|9LlC*)UY+Z#f|%2Hkl1-&ozh+1z_?p9wP+*3gTBm)QI}0P-`Ki@^A@gA8dq
ztW-@fit;$+@7~8OGxu^li|3m23x-H#2X#m9_&u^ax)aA!N6uQ&S#&Jc4<D*JGQR9w
zYM$_QX?pyVYdJnmNOzmZUCr)NLlD%Bl%rx7#~hm=z)zK23tlY;;V>#9fRO&HAJvY|
za+(L<PAIE9gqK-Fy$}j`d+tO@%fadWv0g87vi9WUzaMsjLlb5?{~EOoUvGx?<g2>g
z^`HJ8K5+d^)897^KTeETe<-}MB7CE^{O04)tQHsNh^fZ#;kyBEe?|9h?6$Ve9W=Ur
zY-{&lyQKKrjo7+Z+sEI{?wnm2y(7G|mh>l~B1pEiO+4P?LE%(qu6iK%U2>B7B~Iyy
z_wW8)+}`{+Tpjp+@6zth&u^dJzvrd^5b+osSiool2Nm;*!Sl++Z{Xo7g)s#Fe=5{$
z3veExp8w$11`+xGAXF}rtdrB>#_QKna!!pODD%FjQEA}7f8n^a=c{6UlH$d!O*^WO
z%;}!gJ<a3gK@7tc>HT)N+U?j8AkIOnE`FqNKaY64IIuY?3}v4KB4uGsGStx=wJ+h7
z4z@cyWz4q5I2VgATdqAx&-m-KsT}@D)c&BcstNONbeum5UNGijE0<7s$YU?#L_5O-
zQ=<ut@dMW~rkDfcsgncg9ssH$A|EI*AQg*V#M6n+5w(l_TvE>HU1{TU$?=DeUCegs
zNfFAw&2J5xIon|SYx9JBKmVagu{QW9R=SO!|F~XL#F4w@i3=M)kH)mm@%5)-X6}kK
z%4UXMj~wDd-AeewjvBnE#WP=W>HGCYu~pxU&N+Zw@%2{R0~vMn$qw(tV1@ue7eGVE
zUA|}`<ziISYJ`EoiHy93;t&4M&^Lh@<#z4=i`Dx4`ZPxZPld4E<sR=W2i$3K%OM)&
z|CsYOf}&V15hBMGG8Xbf7rQ5CPsp5H&S&0uyw{^n@ir2qJW1Jr<30k4LgiAK$J%$I
zn(Hjjxi&oA^mG-BO_C{jTFTnKb;3_5NR$fsfJAbcx_t9xK>Y`#V@j37#n>)<^P6|K
zvJy+nV}50%pX??@^JqTjl?}fI7+`w7q-=XXl?b5qK8c+?dd+Q^z5C)gS{tlUR2~Lz
zxYU%x#q=xyZmJr`Q;<iJzQn&&9!glgk-}yg?e<o;cxfw;`QyQ4*pFJ0>LZj{!?}!d
zI(O6S<6)ymVU@>9&vX9)XFsP2p))ze@|0tscnO2HF~aq0KPykm|46S0c~YHfsRD4B
zY2ul<tZUi1I&A<^F2tRa5HECDZYk)}@oTxsr6*CNQ*F4RP2mgl+bV|zy5ls)UtI|2
z_bj2dTRIu!r*PVj2A&nce-DP;PjF)r!-Tm#aANUAMCf@Cg>i*<AvYw#&7cL&`S^~v
zDAk`VM?|~GbyVI^v4SFfF(ER88aJ`>m15a&5)!t+YnRw2lCD9MI{{%>ETszYen9BW
za2VQQt1KF(s-;IXi=gI_|LWclT4ATh;xofEuPRLSqIf#4W#r0@r7-nFJN9l2kHXuS
za82hV2d}#xSL?#Uwd;(Y_HafMMQ5mTt8Qt-zQQVUaddsr)Y^)U3X#02Hc7^3-otlw
zMc%Y9jEj%7L?)uMx)%lwO*#%$=Cxj@wV+K>z*#BCulUpDoo0-s+?X|xA#8wr*z8Bn
zlwg|Q9tDbqtFXc<bv@KKEA&}h@7fJ0F7BN;zdU?7L&oF|$^gNy`yC_<e~m^%^Ls4U
zC^8P=RmvYJQp7Y-fea{GSadYdDwelCD8l}ZzN7cy$9Xx*M^ar2rYqEhS{mQ}!$@)?
zV00gm9Jl6FcwAyvOhlv0dzmWj@R*L?EBu9Iq?%9!iZ$<a!BD4jG1kej%YILp$8j_s
zwM*s0rV<4D@nptT4<ZR^Am?$(RfAs6lx)C>5dD81Po&N{rJKrU?(03Sy8Ekz#4!Vd
z7G+z_pthN8W&oyL`e`{2Mvn&|&M!!Jk?qW+X5N5!YkY$~x5sp-$)J%HB3&)KrbX@o
z{X!igjpaPifgcZZ9Y=hgJi61V0}F8qjUmch9q|TcHgb~?RSFs7b%Vb$m}U{Jw;_D(
zL0!T8BlZmj>3jg;JRcBD`O5f@^YP5neB>Eq2mk0wMd+JnK2Q)v0M_3vqz<73BCF6C
zIi|7080$0RHioMTmvKoXhDWUP51NfleV?3V@YRz4ZrG~uwuqzvgqS^Fv~%Eb&;Rc7
zi$m<Ywf!1%Qpuj>@J*P-z8-X~Ov<g#*cN;FxXuWA17{P#8$5GZ#&mX3>B|U@2E8JC
zODIgNO}gv)<M2Fh?DgJGvk=-Nj$oTKL@I12eFHVnBCd<XfXsOD^7{FK08UJxStV=%
zoA1Km{(hqC2RmGaWSsXM+BY5eS(P-31KZ<rLgqh+oV=pj$Fy$07OP6F!m`fWs5IxF
z>>$OBuCRPVl@@9C`Wj<|Vdo`#&^Fcj*J%EM144k08$<!|Ap^sO7)LO>o0yNRTK#N=
z+Iu@BU{_#m%^`Q|Py>npJG=F>?mlwLAnt#28x5qHF082?6x<S^2Hbw}R$<7J-a5x(
z|L#2y+!-?ox(67AnkA8m&v{B;dR6N-I0tt==lzGs+#-l(yD>-@5Ff|6tNbr+Wl0C0
zZ%t1?isyGoTsfLWh0iEgnKLHk`Q2@YpSOT#PFgjLe(1A=U^+5LcmE;8?A$Pl+$0V7
zi5C~HT<esJj?4<U@FSK7bTB__rOHX3@$mRtWu!R0mG*5FSL~js3(U0!0JD<3Z6j1-
z>8j=+-m%=ltDnE%CPG9@xmx*1Xf981Z;K!pKDk7@^G18#x=lal$$w>XsB7l!kDn<=
zYt+H(4MegusDe?uz6NK8U`Kegh$J#pL{Ns@M72RSDjWi6MKsdoMit``mHV~)k<=bs
zZgL?_psYIrRn%H?sq}HojUl+azf}k==tx(>c|~CV0_U|@3~xEcADnba)4DMgJ3_f(
z2p{L|w4pu23UbVVa-KGNyYk_Uu9%wpp-|P@Nb~!wyIbP0Nw-|oLKhb<-Gi472wRf6
zE2*$9b7H@9rwv?;Ic$YAM_vpkpyhH0IN2g_A`(i3L)|_%UaCp+hEylJz0xJ?U0^~9
z(y);vDN&VT_Z7%#Gd`AMjm#0F{W>}b!2x+a>)rR-t<bT)#)N%aw<bJtqs73D_D+B@
zJ)NF}f{GyMS^N}hCOmP9*1Q4<MOy!kEMCM_Br(lT72~H`jh~%;sD7^~HG*wMfoWn`
ziSrEsOmkTkR+n_zHJK|(K^ZqIrR!9X$9tLQ=AYG)8Oj;33mT%L^6*X+!sTFP*<Tp@
zbAw7##Rtk0bd+@H{@llav4EEFd<rv(XBmw?xFr1u;KtBo<(biL5a*}V@RpL~ea&4A
zG=syB=2SB`7*_icRa~Rv(}Q6AW0o(B%AZM`;#F2*Cc+=mHnhUaZ3q|=4nc88!5*~n
z-WBLz>`;jusNFVAot|yj0oUU|EVrphL%qj|T2vgwA_8(fQSQbx*t`dVW713@{3bYh
z1jaVr$u7a)?p&1J`DD99mR(Y*-GzF)i!bbw2kb7*+Ff3=OWC!fAbJ!VZ8w7;<OrQ<
z_G3Dxr+DMhxy<UD^IgLwUDw^nsVw%Z{+<KZ5f&&B8k_N}pRal0LFPnDMV{gG$ek-o
zIH9BiPuuve8A)b`%3gH8*Yd1~5zDK`oj8y}Y3cQas*fFb-^UjtT7A97By))`!-;HQ
z;ZRp6R~6M)($jeInPy9?{**rRRC{mQC_S9ac(B{|<4?MCIpX4l4j>O|R}8fq!Q>~`
z)V?^F2F{eJ6cjGxEAnrCM!!@0qSs3t;~Ua@?z>|HR4P)1s#1HPk4*mn7yjCxQKr?N
zxm9;(i!Uq8mQj__r^6ha?F!v=df(_^;(wzJdaYyvd6JJ3kZ4oRu1=N~w^d;tkb!Dq
z=^-P$!9ZpE+dN_oPq+r}IktRyjQzuf7e!w7yIH+dH=D%?32#g1u~3(a{Gla`Q!!~M
zt!=27J#?+cadCI(YjW?{?A3ZMf?|X!ji~|e+x7P4ts9gc0QY#Xtvx9(vmp<BirJP*
zsV*0DZtT%aOYSS$8onnk03LKWEk4p;=}^C>R<=Em{=%VzGE$6kzCSR)t1x_Q=Vs`|
zYi2<&dd(c|0Ehv~{k~>SK?`pLN}4`}B+E60uJ9aBP5)5XuK>DB_j6f@A5!?I&Y?eG
zEw~{cxl>VNt4p{WdHvVS2KipQWS2CoVKfRSMr@DBF|`%8S%|I<B2~sTtWGOcD`!jV
zDo-0j97FBd%Dl1aYPC5Gda0mrblh?DP)U1V(K8G4&R4IVd0H5|A;L57hh=^*b>q{m
z!~d(d(Q(tdB>sgDy2%Y5>xmh>k|)hdy0#@Cu`W`RaUEuoSCKF8B3$3A5Z&t*-K-g)
zQDEtzYGZ%3P&**R+v!He^>~$6r6bRi$Bud%X(o)>JQ6*mN!{8P`I&k3M7R=Ls9J0=
z8x0Q&?MyY(5{CfA4!l#E4(an&Q121q%f2BUx2Wts3!Yb?Xi<YdlRv$*vI;$KtW5S_
za2nbjFS^oq?2ed2Ed6}G+9sX#&}s0qRt~QmocX2paS+O5G%fw!sG5j}hquP&gyS&@
zCu*@b^X1K_vxBUNsm#F)kHOcOORwh!eD4CIO$$>=cdi_=KafZk;D0^VRqt?I5J>4m
zlL-2?8?fN10u!!TfidfiRmM1yh~mH6(;szM;H76w+VCBn37#~Ewf>A@uQxZOXRJE=
ztC9~V>P{=x7A9@O$o-?pGA2IBKIP8T?bX^te_&@KnA%y)e$X(hpm%Y1l>NQm^Y!cd
zO>aLJ9&JQ9<)pcMi=R2HI(>D?x<%Fh#_Vg~PCspBYS#v=wqT|fp!}lq5TxmSs{6qn
zlTb?8b!Ull(n9+}XeRqrq_>+%!ifA)&lqnn0SUhr`?>E?es$q))mxsYjROeIeXkGA
z#gz4sy#19xfQ2;NvBtY654`xHnx`-Qf&h@BdX@4T86op9F%d62X!fA<9jAFT{`2UQ
zXcziVt8}iy>(w<Em37~5gN}LGe2cG-nR^E2|8yUN9Md-6H%UpIzk~o#^fJrJCLQ?{
zI3tu#_IR&&l$_9MI8?_RW_)KZaXrBF&cJcYf$EoYBlNkaZhn=I`f8o#1mBG(1Wd!0
z=S5yUyL0I9AHn=zR}o)#9g9&k3+#>dpS~|x@2?^KZ)&)3Y(7wnO}lX(mB51dWZiDG
zG%Tm*ox(!h*oTKAA^rZrs^{+LILn<&n7Nm|5JvUTc^9JhHRQlv2v#UmUoq4`FVxU#
z5t>gmsG)_ELQQ$|*c;H;@37OrlfSE(#f^->g%74*7nN>SQL)$i@|1b_f$;KRYnQMd
zHr0^J2O}_P{s_v{ss#{Z)>aHF`w(jLF6^dsOFADdwI>a)2ezL}4{Qo{aS5*+0Z+Q|
zJ|GVU7qZw`UOib}W<Atzo2G@m8NFXD!%F&3hLhloV|yQ&(a?Y?oqf0R#Q><E+e-jT
z_r+Rz?=3`>!$Zp<=Tl*BcM(7hwUxswN3CYZT?>+aG6<oZ?MXj-SL4bOSm)x?EiK-R
zo;s!kd%EuUfi4>6MRD>JxerBE+)DR0<89lQp(umnDAH{a40^@mw9Dvp#nLbOR{Pdt
zse=_iPSL<)3@RMj#tgr-9Ac#nKl&H}jPPUx(ZcvBek(XYBfV<h;6l#-!p;7i%7m3X
z{+x<>?EF?Cv?m=S*KvvcDPEw$MDeq@3;iPM$|Vle`Lf&b{8!pc;-|=3+9vFxAVn4r
zGY*%$ugGlpl^MMOOVp^)+=a>1S<cGA4SG!P{0cDvDpI7=f?7)c-e)N^r8!MAFXd%2
zd_NH+YtVVMULtE~-8F}Iez)YA4Gv8}3@=@P;=_dh&5YDJ#`u6N21e4Zoiyo#%NnSp
zx!1f(ftNIx{paX>b<`s|mIpWpcv7(|)9sKpHZPi@8Od4GQ$(EeMf-R??pa}8y8#b-
zi@ZK`AT#_$@jKYZn?nE&nu%Non9&t_Oo>6*)xGqJrD)ZCEhKlPKz%daCWD1dydLAm
z`|}uMXeNCRM4=s7ug*SWa~0AS(Yi{=$z4XrWBtGR`0Mn;Tx+OWD7qP@w}%5A(O(6E
zcrt3}?TT_Ay*?$cq!rJCCyQbKp<o5YIF>mdZtslh*BnPl^&_`gidpGGh8ihusI;$9
zut#NSlRWA2H_AfO@mnxK187@M`f15nRbGlOxgjogHWrhaaEy^H!e%zeL&H3PyaM%H
zZ*5=Rj24)S(bbfQjsxY)6rS%WbsBLBYKNnDwFru+1+!|hirHxy>`-j(kDjvkrObPm
zm|^C_XDc-puKO~MYkcY4jy<Hbbt@?32C5@|3Qyn$Zrv;nxq(gdPfW9&GO>LS@AzN5
z({Q}=`}qAM%at2%+eo!QZvBp+hhY^3Pa{L_>|fRVk_0oWp$Svv5azZ~L=M8)EI%TV
z5xDZToRW^DeucTeuW<7y<pkfvo;&geL719hR($Q%U|>6l5yF|YUd8EvJh&vkFr&Bb
z(g-f#+&~MJRsnNt*-x_6UXni6M`>=}f`(4{UBE?FkZHCYev%#%_3!Pi;@;Ap^JN?7
zW4l=-6oL*G*thBj)UZ@~3sQZpf74lBO20BvMtrKXeU-NRV`@@Hzz)|%TB3eyjTJid
zr%%ZLe+4gAhlQj26&I_g9y-CzN%Pych97CRE$1QBfZxvY2E%(HwQs{rU$0<>{u}V#
zw(-9F#P`YT#6Bb=r3LmAk#z@!ctU3}qy$X2(oZXvWTD`I_Sl>W)8GZKx*u<b&X-VZ
zguYj4#e<N;+~MlgU!sy;Rmtnox^K>;|0&;=|6MQMe}&o4K#<3^bdkK7oc)q8b<5yN
z0M3ST?so#y{rHCiP8y6LX1eo_A(DPZWFqeqhfw0R#8g<|L0Rw3LC62D30m|#7Bzq}
zGbQ^X*ykfwQ}TFUf`Ex_*hgMkoxZ%iA~TYmb+XRk`}4jgUQaZ+P)<8fwmK~F{x<KO
zzXF$kP7brQilxI(=BILTeEEUzn8oS$i>UsyFdPbEtN}S5YhxflNgC-oaY)hjVyk3X
zKWRGswc3qi@<_`5TK<0G2_%Ges)<o<XYj!!<yYK-MAAVheiAb_)Fw;Onu^ej!}MNJ
zbFFl$jZ^I}(hIz&W5&AqU&@b?lYc%93l1<kg%<Ez{Yvf!rQY+5)J_CalEM3cW)aqh
zat;OpQ0VpdO<BIer++-jh7<g_lRus6ij+m_kG!!MSbeNZNjtq568+ch^t-1qT(FQ%
zBKAWYLr|=cu#}71H<Bu>ZJ+n0Br1sfd;3P4ay8kxJ55DODBcVmCe-FoQx`|+0P5Gz
zPClE*M{zF~apz9_#Gc6&KPk7T>mR(pkQ006BJ{%a$MVoEV(z=r2ear;du4S3+n+4g
zuX1Cbujq0Tv*Q=##Tjhp7XW$3c5z0k-a6EC*x`iB@B4dC-#u6jf0N8Vdi7Q+3|(AK
z70~mdt2n<zONVbtivtSWrBG+UqyC(*BK+U4PW%V?Dw{+Q=b<uba%tR&q%h5Ri+{BA
zP>x0kp12Vv<zD5M%dc?aaIC55k*a(<^htNwj8aJeeY5j+T9EZl0k3=p%Tr7fw*RN)
zAVr+st^dZq!^Pt!bbn=HJ@4uppUJ9xM(Eabx|`0n>a=Iz#XZ=Y<O$HzYTJqR^Adp|
z@sjGwEUv-KN?=`(uZsoO=ygv}p>DjO)ZuKZo7E2}Ti6ejSm|aN*5-MbBx~~1)lj0V
z7^(Zryl*V)i4XI3j5+#zo$Yg>+RC`6lYaG$-RLYgZDalCE{b7%k_b;&r{R#^*<;~-
zX7CK}Ui?0`iA<zG#Q=+h(bp0W`y)<dTYp4{^;s`rBF8TO{`FMyRnm0A0m9$DM^dkT
ziu$u#O}k>@n4I$Ta&gBQkuE~mRDKt8r!>*q7WO8q&hJH>d{d7~L8*uITi=jQJZZ#Z
zTu-%K{^5Y(xc^y)n6)3mmNPp0KrS~?rE-uc7SKFuC-pbYWI*d<b|;yr@Myx*Gg?|c
zhuc9A&`9!{d-Nudrto+wv>@Q|^oiSLk7ptu&OLs6rd{F5?Ah^vCv)c)%bvWu*xqR?
zf7FQ7HO>;6PR9t|&^3FXWhmr(G)R72=;0c!DNdr3ecSV3yZ@#{P%&o0Nxy=U|9}jF
zA$`h118+XHz7aUuvi9%+lp?>S)zOFdV3&*-PVGIKCVZ$#9m{RZ8N4`T{b~2$`Y=(+
zL*(tB+X8Z7Mxux}pkj{#<JhVXf}T~lzfv!*6juryG`@ObETHy{-MQb~WTjU{ql>rx
zBM2`)oFRCy7ImBr9D%;zXE&pk6%{nwOyVZ1t|0i5f+6LAa7fXmLSl++$NR(ucOJ$(
z7q9+-A1AxqDxQ)I$A0{teqOdh%rOBCC{+q5M{Jf~HExrBGv8%!3dFZwqX(o*^O`ol
zd4&8EN>>f@;Wu3&b?u{~pluu5b4D4r_!dwjQ+9QyrC;1#IwkIlz*&HiS?}c`q3|6Z
zDY202`w*OTZ_qpIh0*kT0h>xk5FAPUE#U)J`guv7kUMJnnUPC0#fch!0QE6<!JMku
zJ<_WMen@z-F{IXLD5ksoUCfw=BlsK6v4{up2S>Ea;lgB%YupQtdkyC2)%Rllx!dCx
zzMoE=UoaPM%5~vUIbpL6_IoVCDBby%#Si63tUVNtkgsAjqI&RaXVH#4C@JntM!AxD
zEHZlS_BAhoWoyRMoD^xX>regF=Y%Q>lP3s5>6A?CDI}r{S}rZ!1d)jcANZkwk(rDT
zPQpk6E*Cx(z*31G%gP8wrJfF#%|nRW%r(dnyY*)PX8o^sD7Q^lcz`xwgU%PP|2L54
z3FRnXp3LOHhjVxGY}YDJcKIu)0P0|lVbO2lC=vk;VhfsBB_fYb)SPN0YckqikEOg2
zukr{uY8?q~p+%)?{Kuwy^hiH<U+EAnvh2~aXk@l3&<pq)b4$K^WW?xn%HE*9Umajp
z*T!Bw@_GA|Z}sZoX8V1bx7@CwAtpCvWC7VPR*BEde~9B40sK*1xYs_%U{2PzY{(~|
zij;l7wz}Jbimzr@-SxFrTtMaggN1Qd{hD-dt7$?h%HVlnG8v?3?9O|n!7V4{1u<N!
zc^&jQt@c1EO*2}8c@99rG(%`Ezhz!e#65pY+m>u;yQF*mKU?MiT?JtiM9f?OF`_)Q
zWPqBsLqC))IZ<7j^5*dC3;*j6Jz;UE2irHAfdx4HbTg(A;RaIns?RCOxpc3otcu^~
zOxwJ)!8-p$gnLz085lah%=?Oh_;O{xj*sJbbhCIO9aiX3Q51CjN*ikCbAzWN#KLMV
zIECWdW^q$?UzvK9wxpsIV#Abs{OCno`OgD+soiXDLldh#geA19T!4I{-&eKI&sNlo
z_@D+dV=mn9xt`&5<$Tm~W$;I%94viAlt4GraT0=oi3)wJy#HsfY#jTwY<A0hgsNy%
zArQSnRIwP%JZ5xTZhgg$Xfbx>rqLbk=+BO!7UL!FjH(Z=e|DwGj-D*16*9*e7Qe4!
z!^&x8C(;?PS5P5=#Wo4at`T(aj7an2gqoi|c?UEWORXK#O(AS}WHZfU*{|~)<VRY-
zY-rNfJi|S_nkSgEc;btO?LAL4t59v>1oy@06YeN8h8sHjvf=HG&g*$c9U_&x&4OI3
zf^MAD47Y2oV!Uf$OWfU|$qxGTYR40}aEynI#oyE9)_<`vWtil-a}XS_`YJEhtWqk)
zjEu<<Vd~QHV$kRWS4q$@Qk1e#!PIv@E<XH4YJ$>K3`DLawc=<~m8dz5CL8Cowj$mB
zQE+s}I`Qk-jQ98BxSX_DxAa;(+*Zoiyn`Ydhe)A_o>|)HK8QG#RT5RFnmW=enOR;i
z;qYno$l;!;f9}5?s?44KkYrc8{#_-Lw_K1q&BGAgL@Rw3lWU(YQ>MlW8Y_pGU#Hlh
z_GkXbVj!}0_AE(xeZ(1gh?q$25v90aO#oY2G1P?LaXv3s`<7TNoR6f}kSZ8TseBCA
z-2HGdl}Qh)l&rGuQ4R?n1GxL8Fj^i}IkQ4Ac<tCD>uBa@cdqd3?n9@Y_-uU|+}82o
zogz17U@wE4m?e4bLYMh)^7{k%gzff<He?r;t(hjFbr5LFLzwSv3QVJx4&AkfaRMg(
z<>9IO&!wRbkIH?Lgc;=SF2Qi%^;h<&$NV^BR*W+k=(j@)SEgH~dicr{NA&wGdyeds
z1^&6O^f%ZOK$U|Hg0=>o<q~-@#nk7eeSBBm8~77>6($rB42k)9%hJ&<a@#P5e)*#p
z5D&h?Zr9=vvUzaT@=&2YmSANM!z<Nv$w|LP_>NH<H+DdK*NORb#7d)mxR@F=MHs55
zVZ*?B^!8@?4_qtE2hk9wn2SRP4^Fm>8LcyHjDs*Z9>^RSg^xs$rulaO_>SAPmO}n-
zo$uX7LBZu9uN9KH+Z?_bq}xF_&`F#e0qaf_Nv`-D%meuprd}VJvvCtXG~t6-x0P`j
z#nV$yxDj`H1`e!rNF=8&B|@Z`Zb3b*!yMWwNJ!(AOF<zz#=iGYQ2F<0)I+AX$W&LN
ze~6l&wEBe*<?n*%Z7-dXRORwcYfES8D6lS^cHN6n%Eu5-ZpH4hPEZK@Qa)GGn<#10
zr+@8QZk|B#R64*hubRL!ubS^oDHW#5=CwY?R1Uytmt}}UY`-DglwTs4Ass}RQW^Rj
z${k83D>S^eT2f|UJP)ivY&G9ohNvt~rFvlG0n46f<vxEhXq*RU1n;^$k!qsx_FF*5
z>*)6XCekn~BvfLz@*kpVn9aY|F>hbI-AYl*1T=4*JYeLnGSP87`I>cA*SQHgUK8r}
zhZv~<b-$2hpho8%vvVy<V{I<ko4CkgU2kOcSie9#*x#^1iswX0zN-k2gqGQ(p_;oa
zg(ZH)U6wkWWWLr8=W_(4CGRkKBbW@+k&uBfu)<Zyd~w?_nGl45F#O*K@*XE3m#qu=
z?a&?am#QL^efxJ*kFE-eEJ55cB#AYewc7**nQAaK$+?86$Rk@7?t^v;+zbuq@$GhW
zVtVfmaRGz_c3dlCXx24X%BNV$I-To094s6aR8Ni4r^o6M2pXT(H*Y!d;uHqjt&Kth
z=Iqfz)sY4+CzfeK$4IBH%jG88iQqadVm>$^1ORd0NV9V1<hyc9EJL!b(Gp7*Nw+@T
zHNUBFXukEm;GhKNXx5sG#ag=@$QC{*PMjaGo_~+mSg{s&1#0a8I{sf$Rq99ElhX^9
z$!f{(29?>aG5|%c*xr)N!q$T+BCV1bh^NNgTO9;lRE|oR&skjoulzJ+5*e_Bcy<sZ
z$atNJ4nu#a$iywZHAetW7)s_75l=0CAwRf9aGtW;|F6My#*7DgwVv6b8BU~1<bhOs
zmJ0WXSC5@6nza4%5sylwdDMT3S0xoZZY!|W%$^i<Rpqhdv}=4MYFGvXBSbTQ2tJJn
zX-gCLCmyeFH!i1L_6~_`0Ug?PvMkraKgD0%b{~2{Y<HV=(Co&usF&x67nX^HK7>p?
zaj2ANx#VOno*Tq&O@LQ6J-X-Gda50l>H3IhRx|20*OjU&kza92;l9>wmr`-oN>J($
ze&ytmwvt<0ZNpe+3o~#^7?0w{Ete(QX+@}<PPRu7?OlLPV!UWYhvU@e4ih)<Xbs*R
zD`+nMC8#CUV5P{VgJwUbJwB^V5O2*BO*5Hl<sRBR3bgdM;2oxv>CX)uU&PhT!Rehi
zuyV{tf;mCm42;ghdx5*8<iY&}u;RoVfelhX5N;@UNKN4t{U!32LW$ydSsg+LDqG%&
zfY~^5W&)%zUq{&188M&_7uDG>tqtX@O)^NYW7pqMW!aSVsmmoPTk6x5>$g?yW}2ek
zK3jj=7CqayK06jYH?uys5dCgdx4R})9;#~z#=YN*Zrts8C);p4$VM8|{$~aHF@nBO
zV!!Bv@t2-JB}O}9`aYa$sGJh|D!=MIn{&WMBFM-|eVgA2+P{3SA)gF->E$X%Z$(3C
zLXxC^FHf%xH3XH1sv!m(%ZFCM-?-VneO50tnTQ8mH;o|dgq2RnciwM5a-3kBcN2Y!
zW5T}%mUml6wDr9hwhPKuMz$g)M(MJBKZ_nr6VCkEw~(+r4!DWwHhr^(=St>%Ud})5
z86n-1NMhAXKe9w$zT2?hDvPT*1FE)>b<4!i!6uk1M%b}&4J>4w2DvyC*fVXt@pU_u
z<jc%5CPO@TeZM`sKE2lfy1{mYQ%}ScSI74$zLx$mwK{#T<9-q$kJ4ee*M9u23xHH-
z!e0|xy1wpi@QF1#w0JtNL3DdS=n+r3mT^30Q}nE~9MrZw0-SI<#-sStsd>~dJ~AaS
z4I#BDZAeno5#|L`#>}Z)nNYGiA5;Z2=2zIzJ-gxdkv|OM3qaT%qF9-~v1G5;))Qrg
z7<bh8nSeq+(!EZe6Ky+GD6oaOcttdi(&)Np$H$FT+b>8|eY$#;88ix3=hD<+6iG^4
zkj^)>-m=})QLB?s#lJnsz|N6|CbhRsL=D<`w8N>VVR~F5f7*j+=LWy9Z@*rJ@f?L>
zV7Rg{9&b$8Zy|nN!Vg_fLqhUlD>_7m3`*kRSeCvqKJmk(z1=GDtc0nJKAfryr7FV-
z6JO6*J!OP{-2A+7;z9gT<F`#uW+u~OMNWRriSqS5IC0ndFPi8TDJcgDG&59<j7cp{
zmtK6xXXxp{aNt@c_Ivw-Y`)QKgn9jVDxaBm__&FXUU*3f#3F~kr-+{>9X{(*hzHEt
zlsBS|6{f0m7!8ZsrxqV@{9!a&zBT_d-c4ArVmsYUE@2SJ`ltBQqaX2~!B0<Of|uh@
zFV6(;qd&bv6MP~c@p?A}=i$p*>BMV;5*?u0pQMIMsggQ~tyGc<26C<q>Q`sn9`&=b
z9&F+ZIrb&t*!aBPe#D_v`^PNAboQ)04m!<F)#XU!WfR33I|wB=OlAV@!`=qGf`*w=
z!=z3IC}kKrITBW&_WyW{^g66ZLT>PC*l+Yt&9|Mn=%CO-YClwJJrzubj`07t?=h7>
z@u^o$hsZV9{dFci{TDB<NgAZDGZn)EH$rdzjbcp|gU#c?@&KTKQGM4)SKW2mmlO{}
zb?mF~DtZ165x;*V?6*2h&nVef0vy++_WS=jPwhfxf*WV11q^7;mGfV68|kPOs1zCG
zUak<o{lpq*q164(-?a_vxv7WSBFnFxS|cXjY`!OsA8|kOK{8btPCWMZ=6L{6>mZ<z
zcr@;v;Sz!1_3onrQAK!=`lRbueH+d2y{!^ywRI7Vffy&!4Cbj)x?r_QunxzVK%(Zg
zgRiJlGmk1RKQ$xFvrgoV{ZMVmXDP{6k<B!0gXo{E3n5YI`XW88f9~fJuiwJDZFB$X
zlCU_(volIITv|50^|^t7&G^9fNsv%mYnZGnSdoM^YJdM-fnzUnNnbEUg;azKa^Cn|
z`di8JPZ9w9nfG~0h3boJg;{OLWM8A7`G+{<R1ir5OR0WQQ0x#<6xR+5IUdz((;{~`
z0**hDYP##Bzt(2HP7LgJLP7wee>6SI^Y6Eb+4EG*U9f2wLQR~Ag@0jo^*7zPrH^$j
z8@O=){e|Nz7w)L@CE&WO<Eg&wJR&2~5BIknS2|V4z^z?G_2bUb0r-o|1$-WUnL{g#
z`HY{1yzWGL#JD=MkkY$O-v$r~yL6@x=yDwoW&(Q7l$4CJAi`-btah&d;P8L27mrOH
za^Y>k<`5RQ6PJwFm!HHZ66_G9z?<>FZt978LN2Fmcq6nk*t12EZV<+c%1f0kY&BcE
zH@L;TFp?WO^4+f)e|)L^0Na?rW|keGzgTNOh{zfI1{wNdIs8MbONmcyI$Sn_eXEB@
zp~l`BE9x_KUK+;1KtK8;@Ay95VKzuLzkqOFdIo2)js}$*n{}On*c$4jnV5lZo#|{>
zhkE~^(bY(^2P_yPhb9k@Lo9o&UZ^;v?4I#T)eYnIlO&xT4;5Q>QfT2-TyjGEynS)A
z5g*UXz%576i6<uz_!hHw<0{qH=n}X#vu$zX(!&G}<Dq&7S8<6rgfKhN9J*S-d&|%&
zzo#>i(+*R}TtpfAe<ZFocU~Oo7D-nR(AkMYJ6yBc!ZTg}N(%y2_=_ysh!HmkNi{$;
zi=pZ5h9o)ED~4*vZzbywlB5eByodhs={gdl!1O`@$b|kib>*kfZNQw~-@`|M44{f<
zyZd<1(@Xzhczre8-~4wm(W1yGNi^Kys`in`@jGLo2Qn_H=|KT8b%#`i4{QC^gH?}`
z2VE|YZVyZL<*A%CN%$jv%B$A1*5}a$iAbOOM?raf^9S~)gFw&eLo#(fr8#*k{}xR|
zINB*(UkOl9&DD+*XG8g_RP`4)vE29s%tb?7dHNa`Na{GdR&u1*?>(<HY32Jzi-Loa
za<ElL3Oaq+%20Ft)+3{n&G8*3rZ+1F=qBpNW_|k>drFgj|N1AF81tdM7F@0(QZQIn
zs`BaRdBM5%OX;T`SE%d1`<W>EVW6Pp+bvS!DcH?^b<fJVkGHEn-S~axy~V;0cZPrx
zu={)cMeaUyI;6fGq17w9p@?2R$es6$QA)H35w`k0Uy%EXU-t#F9bvpwFPH+3S;C@|
zzkIBCx=iTK&*=hla^jt4?PM~TK@g2MGj5|dQbP2j>aRG-40J?mO~;s>Ue@~D@eY|Z
z*pV`$|FJ53Pe1m0&hp8o-ne9FoP%=4uIK=^Q=WU)>;`plA<soN6`DKg<N*haSEMn`
zR{-F4j%AClUbT^EqYA=+W@u=pyTVq<Gn*agbH(vo5+5V0mKBaU=)M#mcQT$U9CtbN
zPkh47M&as&hw~wc*IwQMS6}-CT#}gd4KKSo=@<P{;*Ed8+|@V7F8!033QAKbnhME2
zBsm>+HK1tvc-bY%nTWK%D^=(oGI7Rnt{ieZ>g7L^vBM2dyGmkv6-;f=_cRy^88b4=
z{4u>zB-unuM391~<kf5MFKZXZ-747IapaG5xo|u%#c=K8t1GPF6)!W1o6_E{g-2|!
zv#yOEcW?z`!}TH;$nA0&<O<(*2bRndzk$vsR}XmL5+L%i#3oH_0bqfK1vPn(+AaSF
z9vNHaf2~5U48j;dy{SlT*;CGkNo&ZB7(O6Z)0`hASo}{}bM-@qR%Ce_*lqFTP^NF#
zwJ=t1nk3nxiC$z?kHb)+YwWcE^vYwo{GhGni}jD*UOxC05UuDGZzB0y6uGqB+;u0s
z4(h(2sGdYdW|Z@7SBPuEa@-z+;oS}I9@o@YT~QtLDArQ#>uzQJ%DB`DoPq`YWI%eV
zmqHW`NalZil@xXaiC*v<DJ%KJO7FX*qg#8sM^uyE_fXqqBFFMI6mT62_u<e{8C&W2
z*^-FT2Y2HcCBRH@O5g9rTY*MDM(w!jlqWNAUpeK~Qfq_!Ly(Y_2pgoVhPWsth*Av?
z%o{do0~8-BxEY+o)8j8!3z}o-rc(kG!-YE!FBJ~xEt|v9`%ia9;V0!EoErkaRoadh
zj!1)W!71N^;byv_N<V7Aycy)uM$o+Q-UiGlCjyzWFZ|kTgvi{jYDUMU!2>s-I*j}r
z%~2JhlZO2!;Efy`!O%+~%H4$|)BRIoQH|t#+j?fZ>q>E>O8d$!(h|}@B>#i*%F_kZ
z#n6J-mTH7aMki7B!>vGoV!`bZP;RW02mC7}KU6TJAI0%}n+P%Q0&dy?<suRBB>vTB
z_L{$A9Wtuom^TrC#=$FG;v1fF8PM%s?Omdx!`>C`u#66W6Mba&k;=<^<ZcNjHuHfm
zxY*~2;*m@@gT$o)og)H(+RY-C5jY4dg~$(rhZZ+Qh>5A%cPXldq;E(^DeN%=jXozy
z{ETV0zi;mMTAWk{h!fGNHJ`jhnbOn2XSJE|Voj6}Y`Yu@EQ>6S1~C<@`A8K?Uzo%M
zU(xY3qLgs!Tb#Yt)yCO&C3E?n%&MRVDIFTX;gPX}^==+D@*?^^C_7-JwYR=U*>V)=
zDDA(M`>VFGRIK8<eE-uI0ALJ^=E2<$O}xs1H(y?vFK~YPM-&M9qQsVFUXKIaO7LmT
zq^_OXKTG+sTsU2zn=E_g@rL3B5*4|Kb+b~dRL#M#AILq`7+aO4JYP1pPBuok%|isL
z?n^XjgMck?IbW#*MsU@0`5-5q(X-rPquyb=-j$DixVAw4+E-!ShbjhE+G5j#-$#Zz
zJ`V8hAg%jGM}~JazfVhzx+QViUS5=9i#&xo&0hV&HlDp^)^05%;B}^f%}U?J2;~5-
zXWR30{pNL|=l(UsVLax(oKkr%d9s1@3ds(x>3+KDeJ^UA1bt*iZTg;IFNbpH5bJ-N
zM%O@Ox^~n`$~t1TMA!o!Ap+Z+;N(A7H|PbbeBAniHknB*yJ(aZ?Q~LMd~SnjAElil
z4d*JH)7Z>Bg3$I@S&-<C-ejHh50!f_-EBU(nUgdds>I#L10}!br5Zmz#aCQd3Z|>%
z&~%Kj#XasreOm0`Y^}iQzHB%LT|X+cy%8_rGj;EXR%$ljwIkDxwJEC^v!qBm3bawW
ziIeUueMgyL*I3(A`CbCB??=$x8?`?5%sa7wnbuqK$;JkXtd9HbyGcb`o<@zVFyEQ6
z*+jCwN-PT(rHm+Hrl%mICAWOh;{R=gShcxJm`X*8Z?rPxrYOV7%$TvK4Ev~q<Bp-f
zG=TQve$<8A&FV!@lJ+znd5Yg33(jv>`c~YayWHd-5O}m{0u4<*eQ>hdB2medyO8bl
zHQ#W3FH{87L(*Mi5Brir(B8fzgZdAG;q!#}6MN}pg6@cD1hMnwDkSmQAj6%eK0oEN
zZ7)>HIKQnTPh69mmd_VX@x5r!b=gn-E{O@S+m)KlLc}9UP{y1i`ZtbMnH$Us8&eT}
zNhNiI3Y?zm%71zwzh<(Z;h}c~%e>KmB~LY`i~Kun{-&q<5OksQm6>zH)nHosOt63l
zlqNSz@%@2_7mV0e$3DN%Nwj=RmOcb^Fz?>^zAI00DNNHz-%v1F!LHOt%&K%33s7fN
z<77b1wv`WU<UiM~XyPBj2iwgWF6-aXPOebc+u)UMzI(1z$ypz%8Nrn{!3zYl7nL{j
zXmby!is9r?Md1&Ofmc#lw?DECPLp>IOn?I~eOjcxoU(hKsLI-1TT_ZBLlP%WB?aW(
zFX1xnWMeFhbLZQLgpbY@)l0%BqAFA_DJ22mDbtk_vRn>1;N331D`#XuNnG@Ap{%~t
z^{BT>A;wmZr551a#DOc1tpk7s{Dr#mPyb_dEO+Af8&<obtke>G^&U#J2XC>5mt9?Y
zZBZ%t9h7oTRZNjB&mI<6B#15xzZGhi+XX2?LrTz2=t5;n2aUy7AtSFoox)TKy}NBI
z8il-q&j6#uF_qH}Xvwh$hY`xxZTYizTNiN~GvW(}w#Y^pF7JskTFPWA_a1c?c~51=
zPFfm`n2b=;B8Fhv1h?<ms=1*ff|c~#4mWW684Fj(f|V9p`SX#(%<@NsuW$MY(mtRT
zW{^M(7EnC-$3Ny2W!?CH)Q-w_%ayj4?P3HXKcbcBUkf|90DFDr@P%N#xEeS;SWk~E
zboPF)4v5X@N^1KcyPzD@mMU<8sP<i%TUi}kTJ>6s*uc51@Lk!O<?{ZW6Iu%?n2?5;
z1X&J&B)Apw6Z2vZ?hCfv7Rjkm`PFtl6V#^$`Lp~1Iu3zdCCjaGP|GLn3u`XFOBF}9
z%kH*j2E}g1*$DPk*!O^B3Pj%8=BvwBh{=OQdX!K?pBDx0GW{Id+%|B?c?!>U8zEU`
z(S`Y;`TQO*7*O7U^6&y6Kt}^m0Pce=Apo2UK;ZIZc6loeE~e$*!~THB<tzaxFsGt3
zOWN?%MDg8$u3Qu`Q{KL*s<%MH^PYcilWH$<l%1`W2oJ8w)YBAfmJBMcJ)qk7Pg{)#
zCvuHkAo{`paqLyf8cV_3;nBU<b-oWz&GjXO6^HHZ?RfgcNVJ8J@^}xL2?_Q_@3BC|
zZyz;uYL9lT{#3u8Irkq0BB1Eh5<|vq-u(Lae0_Os$_|}J?w4bnN~!KezIvlosb|37
zwtR8F`h9eP!Bap@7Icw2&HZ)V+4=e7^|vi&L;WQr{hl_4{~J^>%Wvp^w8!h$D#^KZ
zG(RT$bA#hh;BzcEGEKqs<@4X)=G&ihEt_@RfKx1ih8)w4=FzH>ACJ<-=igTX#Szn*
zr~V*y{($Wp$p#aNw-I_dPBwlL4DpA9*mKP%WK+IosCy{6o|L4>ZsLBq(j^%h3rq|n
zQ7{I&`D<7?&I_L(+ih%$6uHT?Ap>jM#D0G<i66NpkoE7b_^tV7XQ10ivdDUCUU|g-
zfFvw5LkJ&o8#lDZgSzT}?(@fMM~)OI;&U~B4Vzrkyfb|W)N+2%YDfO+kaeRIoDx3^
z@34(qpAYFfFdIYj0|<vCIL5;rzXl4#P4-(^_jQ)tRq|9HN^9mGzxVlWX-GW!NSK~^
z*x6o<v{{meyjYPTxKWIg<0{D&+XsH9ulU>$=YwAJEpoz$n}cnxOBNO<Xt^B-Inru#
za4+UZny;*^_ImR~T*k3bs7NbAK0QKoC}d|~`3j?-Y&dH@o2Tq%0qP(GhbHlk@J8(H
zirN9Ye3%KVXD{A3T79uJ|A5=^&}LP1FD<$%oDB0_Z%5i$&Q-%~_#AyVyQWHy4M(IF
z)Ey*f)|s@MJiKO-v$Q|Xe*0p3)f)8Vi2p@TS%ECy9Qq?ifWhR+>cGKtw*o^#j^?>n
z^K7hJdxlHmtnP;`z-1s(t*6VrDm)Z6B_9R#n$7PK1*QK88Dn+-Hn&GKLOiqVr#?lA
zP&Bh_47TPHKdp;)@``XTYJ~aJsD@tDf<^V?;^W~}g&<_*fK~5cbDY0nH~1{ubI2)r
z*b$8$!5&`K{j*XP8Gj#tjyI2Cy@O5nN?w=HDZ$pH;f2DIB)to9Hk`)c`f#zI$8>jU
z=I)+^N?6{PT<e%*;k>H~ge_@Br~mz&JpBJ9T(h@hz4Ts=;7KBhRbrFc_V-mE7McaC
z_$#I+-j=%G$%6Dr*}fL%R2CEn6zWJBYKT-H?^?C-l_f%h={8bRS>@0l`{Y$xv_50|
z?YPBOVMNb*0;nauZ02#M`|EUtcW~Sb)-NG5!CK+ghhj6V!xgE`*?!@^-JT=)#VMsk
zK`}%nlB>MT=f1BgB=b97+KtT(hU#gyz;TxI=e3hlRn6bB+Yjuu762&1WiX%PL8nx)
z$ZZvAj|&Jkc;28*BGNCaCg)gJD?@o^GlwA1u52;N#Cd%?5XgbNzT$(_9cdLxWzxD!
zOh^_+VA0=gw=wGWy;U14J{xsaYNoxtE~moiU!PW}+u8Sd_*}`nW^_mEaBm+UwdpFG
zbw}rfeZSw#_o9}8J9_7P`;YzkevN~;i%qv52$B6!+|!XQ-WCKi*ww!-n9;8Cgq>zf
zY7^v*-CwVYMV=&3OC~$ijJi+C5q%eB?*a&smW`~W6;;J|H48d}87_rTqD~%;?n`&)
zBGE?Q6kt!Qt-n8YjgxK0hG7}$EFURAzL%P}*^he+$9by7S7>B(hJf?aJJ}CVAAu>n
z(I4TQ3tQzHJS@~qqm<k99TD(m7rFrjBUcrm?p1ng9-i?iBoTCCagYZH4@RxRQuQ8u
z)y=cdtD!JMc2T+@pmN0~ZM!GoPVy-)83$2<rH#PhL<e5oh1V$*?|NtFNFQVc0`q-P
z?>{8-lW66==qk~(>DxRe4I(UJ&$wvw3QYnj!isiVjDghN)o-a_Ibh@bq7t+-oyHg`
z2z6lKN;^(oM8GfpTmw(-TDW1|<k<0#@hR7}Emne%7EX+SP3f*MDrnq<%NME--AN-s
z+;T3#LuDFM5th6J##x+~%y7NrDd)Jf<2_oy%ath?>W$n_GF4B9vl}Fx`sePwc%<hy
zFZAVDEDzO;paUMw!rc_eOn6x-q5q=;SNRNcqP#oNkK*hfvzf!5wF`M~)2Bw)X9?-v
zehybF@shj8c&mF{zC4Ynb4uj(`H7IW#+qKqiN``lUKj+B-7Pk}S(ub4B>p$Z6|e=#
z{Jzwx^tXj~B$FW#xkmHm8`|^%4@hKET2md{#Ftku^kyyvlkam_M|K-wsk1{$ImjN&
zUTXtjq@t5Fe@wP*Gj|wBZ1V2yPfc)IuG4u^A$A2~%DGdpX#a^TtAe1YF8xSfRo+y(
zf+U}*$k)v<`9{sN&*>O)l8E$rGQhmcpZjFt39y3J8TjDtQVY*iHb03<h{##0<j2#<
ztxCas-DV`+Q>QIOLb7Z#jrR1HNzY4EjrJThK0TM7DDAS-)PbWf!)5?ZybV}6wwWJ%
zgEgl+>C>p66F3-ESY@H@E=#WbE@GBxhE@8G0OS}QpHkU<N<a8H>lV>@fgH2(#Ea(~
zJ7(9;WzpfMG-$Fx5JBTS5Hlc&M{k~U%a)`0##S@f>atoIes`d+yw(P&k9i1?LQyZX
zzu@<fa*1mo<4agxpK6{nN#k$dZTn<aJW&4j{n_6oDXwyw$nS;!?zadjO!=w|&p=?m
z;OU3j1#$B8jZ%#r5TPIcU{3`-ZnFo7!2y?x`!2q!DyqA1px^fCghVADvxE;BAoC12
zIm)yKql7<6!w=O90H*%5XK&qzKil$!_xqjVOK>?8>?Zr(jnAuICvB(vEq=cGa$JDP
zfnwzI)8~E}3MK&1Y5q1I%XyH7TrdQ!`0aP!(Y^1*!!MRihj)f9?)@kiez{`j`e*FM
z-d2t4%hkife<q*r{bc7}`t%5ZSw#ItS&n6bj<)fV%>vGxf8?N&vw1O<6TIQy(l(!Z
zOw{X@`>!iuG~E_NL#)3A4ltt|g?*nYqI{5@#FDrgeAh*rYt7Dl9ku#>>zim|)iw(D
z*G@%rQ~Y;+l{=aCO6_c8++@WKcyN$WA6CRc8P=Q6*XE(~TwT-@;&uT-0oRy2h<G3K
zK|TmlNkmCD28r4{ru<R2zl#+r1LEU@40dA7JSft^XAynlq644!$m3LFjA%3VP~~l^
zz-uZwpEr9$p2wXp3j{mGmM#bqEpI-kG-V%+lnes_$2WyX-4q~9oR)}vNjWkaBU%({
znRFZNZYKHkuv98a@~9g$#621HA=!S)UPeO><OWS2LHHgvs_YQWpWx#UhPTED&Ws4W
z{DsM;2=rkQFOdRCj7#Zm0)1|XwT;W7T!ToYSo+x>>4cX34Lkw%{E>{j6jv~8Cq}rs
zQHYDQkEW(niqpR3Th{huMEcqvMcLuH&2F`s=~Wy7Q7D&Gcz!pN{u)V;%6XoeAXf<3
ziE>hlosJ^&R8Wn<MU@B;8zDf3de0-;aU%bXApEf^3L2?zHC%&>S@)TC!))m?Tjfu!
z(#tENF<1<iX$hsJn>F#X=fkf+fUNJrAKehGNNlSa;^=wAOO8TrL?-U6E}1D_j77A?
z#1CR=HB*;_`7%UmX&+YXJCTyZSPdJKtoh>omw;r+NCc>yXCp`<3@a7B;i@>!|FaSC
z)&|<tCU_FW*PALB>?R_|B^zpqMFWz6=l>z<&i|qM<38XYW6TT&W8cjTgRzf&4KrgW
zTS%hpdm2)ylrfvJk2NIwS_n}pePhO63N54!sc1zKC3Cy3>wet#pKyLSpYwT~_xtsH
zwMck&$F{#P^>I?LdKqnXq@X_eXy~a6CuLl$65*}y#S#J8tGG*`X=rwr!1rx|>~!cp
z{PUHS3qmWt^%NZsJ`ztB??KteouY{y0(-r@sJ*B(QHm&WQdsrR5^pW8w-XEr5pvHo
zKc%02WK0aQEduio=Rxs@io(D$02w7!g5ul2`&QQzBx|k5$+ALDWwF~hI)7v-7!ZNx
z7Q_^P{f%)RcX;DpeCeFy$*0AzL^;TKmUdU(U)1qL2LX>Rq**%DW0C(H3UNXW5uR8Y
zz9#YA0C6{%+Qck*Zh#Xkm1r6i7iy(S?350RUA-WCrHBSm<PwBgmk|ngDzNJXToT;_
zr21!BBs*9k8zseDu+i2)q_7kWG@yTJ;wPriM#UAjMD5QbVuY6!Kd2XAnuaeSRh2#V
zJ5%9;_>ARQG2e2Lwe4d2MM(A{oL5{ZyB5-Bj~F(_d;oyJPMNnPi5*G#{VW9U1aizz
zazcvA=ao5g&gj)@P4SRWh(3%4G}vY(_#v#{stCO*f(TWJWtzkBe;T&8;31-dz9_yf
zasdy*&*METV;};A7l|oQ;aT8MuMs-GNan{DKJ{*hAwwK18eFr)^a`b4Of?-{bMR@%
z9cwX<(M-3>a(otb+I;rdFEo<=M<nb6Wi<jD!PP({AVm83<hX0X1vEi53E&G0?oq32
zoYb-&9BtlQE3$*5#Uhwl5>8>!^)v8%dK$0!wSL1(mVcVXm+Rd=5kUpDtGyVfWihlV
zB1BXtzD8(-DRhD?9>6M{OcYA8)%fe_=#4lmBM!?KJ#)Uo`FY)S@S@25c`?tK*gahF
zH|K2l-Q1U<9X+uwd7+Zv7{vbwW1ftY4UjVk2-Lam%-Z!n)9Y>E>sX%pRk==(WheM(
zC*(pW?8<&CWheYq=e}8okna++?2<UzC3T?-agQ&-6WZ*Dcy~myuT^Xx6H6;Im3!Dl
ztv#q}DVDeZE2!Z+y3oBOalIp}OPRX_>A?xti3tzCtkMGs&H_Totzsc0cPcqYd*4K*
z-UJ;%S_#V74|oSgi-Cq4`93%}#oa`Q3bOPO9@ChUF-kmzfxc##!*@DB)GC>fOLbI#
zyQGV!r;qBN66;!%pmah#5=nEvT>|3J{~yZr7$J3HwPHWb`q>b3xaO8xNOpF4j$*55
zb*pKbd>=JCEF(@j9N_;<5zAW@Nn$}l@n?;SnlEZ8iL^pkAwj$axUO{uF<VTp1z{*7
zW-N29k$SS@iz=;CCLowEI)d2!xvw=&9%3YY5g|oTLu4YP7@>S4u3~;Ih;zM%FMf#m
ze;F-XK`-t|MFv^W*+Bi!l_nxDk!PykNk4UVKxooakVO{H?M%P=;c$pQ|JIiyyRYJ2
z`onV~`0p4<*Qp}PCCgI<_IvIXfi*s_UXcbFNS&E*6AI~VdrPVO`jaR*s7kBHx?uAN
z-v~r*FokalaStkbmGFL`2A?$=(!#4RLRD7#l^AAn&4@^0`x_u4JcaqX;4L9?0iE!d
z&-I=Bap-#k@6dclmPEwV5d*y<>B0P<kR+!N^6iu|03q-NBzVI!f;KTUSs*MRdq$Sy
zQ5FFoM9IxokP#e}(62)-i;#^j;kyIF^Q6){F2Njnh2~8GutTtQp~91r;}MyHkHmoA
zTzp4g-GECxdaqApCiqy_x*)*f|D}JgM_&G$(<OO`VN9?@_=3bbiO)M&%2dkitQc_K
zP2(mA;@EX(l;{Ll>WDAp^Pq&Dx{CEa*Sp}_&)Bk>2vg^D$}9rs3RU2e>)IKGx1Rs(
z%C}O!mm<_$3Rzzed5^kZ%F=eJtwK9zJAM?o5v<ULlDfFy$peTWB>??$sfhuLShBdh
zOwGkVBX%gyXJ5xud6G*d;axBlada{NM1{MI)K|n4(7F}36MEuq1kXZ*lPqI8P`Ok*
zjPVJcJuO(U0Gn8oC_?c2JC^uqTu-_sb8#V$;%Ryqr;sq)az0R)i<0CWytQv;Uq&37
zp7rEAmnqi7BNUk=^z-i{fONUh2?s2|JVZs#v5f2&G|yh<IOJNHT1~5TPmWLbfkSL4
zBgyfv#WFL;bB-jZAj(gpq-p_WpWV9^vXD?7Ezn>u@F6uvTgUIBP_E^y#(wLGEq~xG
z%&ceCslkMcys%A#{Cz+0__|1gN$l&|f(vrZKK~TMZAJbfOuu6h>|mj}nwKx8m|T+3
z+}hBc@o_I9VDq;~CYhGICXs<Vyc7y0CY2_8rcvu4o59qZRz^iZFOlF$Y)D>uCp_N3
zbRabv!ULTw64@xRaxBybj`kPmOor&c00nd;jZ8W(PBy!OOFoE9bAuH!mqZeRvx^h}
zu}X#aw&0^EsrR0u`-W2J^38kw8iTkuHJR6%(w!4+MJ69rfPxU&pF{#?)n+PU<^(D-
zWZx`?H0|tbMf+ya!op>fOBHJp(v@#mUT_hmMG7K8%}LOX#Am89&eO@ad*FY3q~+k2
z2jak~?$CYsC~Lhgulwm0_JXkRqFA1UJr4e%li&0lpJ|ek!-=pt(n-J6Gv0PE3tgDI
zH`xEO$d4(gF92K!hFjR*Y;9SPn(5(N7nVe8$K*agtl+THdkiEBRqTGgw{~iDDaWkN
zbFW6Xo~7VwAaZVz{Nw$|bGG7zf@A03is?#<(61_ly{S6K?ZQaXk7-3&8HsUzvlLcp
z_HRia-WGfS7YIwHXKfaU9DOU+a1^0qf=KYh-mQZi3gLUWX8F5DC=uZID1d;vq*#mp
z3lMomydJ+%PFY>3`=XNwdxb(83JZLXmU|qmMy=wUg-+Y!1kjR!r)IA@$FE+Yxj;po
z&J5U`d<Hp9Ds;_CIURoQQh-j&QOQ8mJ}(K?QEmomAWRlCd;j2z`?l4gap>ZYKUErY
z|NYn#Rx|$l1N1~S$9xU4&%;!&2|QSXzgrXLt|8vJ97aHIHEZza9e5<OehYIka7$t*
z_#!V_moHtY_rpa4wM&Q0#hzPRIGVkad*|F2oa4$Z7Fm%x{c3*Z3>NV&a8=Ih$BO!_
zo{ejht*{CVP?eEq_VPbu!CfD0#@(uNO3c8tZ~P9h7>;|7_i*9wqqRAdffrSF22zg&
zA<F_gbgL24HWrRYz8|^avJ)lYD5V=?i8xRs!kZw5h9=)TGCx|+mxqJDCBe(rR&Qyc
zz@aFZvc>Ay?Gs4X%)j#7fz&Z3L{(N;rn2hSVAX}UY9XC{t}`rQ9)JM)bOMxm@9g*7
zcP_xfQ-ZXm10Kw&648yX^(d-s4dZ*eCNbP8Sho@<+@)UjL7l9OJzr!ob@fjtMvJ=u
zzbC1hFw4)%6{~10yO1Zox+x+Cg=|dQ!?`@DTcK}OW}9R3cU|xNqh=aWNFooPeEF-5
zxEhEH?-C)CPDTtUp1Oxv^wayz-g{oC2cY+Va{?fKh;5nYB7q^KXibyxTC&TM)Hya(
z=JnnoPw~Jdu&np;Sbop$zne{swZ$avQX>zdsDWb!Gakk$i!a^-xbAy!mdAu0Fq!)2
z*+=Xrx2A)cOF8@~TOVcj_G7~pzF+)0g6>~ZE!TMW00?L>NZve&YyrT0q3yCYhX!xL
z+Lr|_bQSK9&U1WAU;_dTiGTNU8zGRdp*acr<)*He*TW}DbdHZynxCpj;f`FKzB6^j
zCdIeuW7`)W_a|<`_xVzC5t{bTc(^c)SD*9-u#@FHHG4Yu&YWBt&P6&_?Z)Z#UQ{wH
zHu&+bvlVia&ENT?h#184eK9ls>dH|XX^U^FDYXkf_PqLf2J-k`>Yw2|R~78AX?qs?
z2HCns>ASj#YfY=0M4S)}B%7^hE5LqV7Khc0RPg*S`U~PsRqM&?FCp-DqNpRL%T8QN
zV6--+0YuKL!iAi~_EEgQ;Cgcka!qL)1-j(ZSPRC;*)3TuvbB4BmhR|lLbtPeHEqT$
zL4n|?sXRY5DSE9Zl+#(A_lK{x(rv#dwfa^oP1&w<{nNuUZq7O``7QI_?v_7>44-tA
z=G^S2%s36@;czn)VM|aZk*j*ZCiJA2Ba&|9?X2F|<L#<9Y;@?L>4%;}9yWZ&K3<Nh
zy*`IL?2UbW4@dO+9zISt_B#^Q*z0%n<goGKptB!(4<AqCGw~0}P`%Zy^SXs&G+Bzt
z%X80@9VxZ7Dy%DTYCDb5oy<G<0-aFOi**1HJ9Hg-8BG{4T?u}FA26716y?iqob@)1
zmi?rj#(w$U09fn%D3{(Y+vw3`CF{Qs2l`H{jr?yD>ZsFj#D9@YFURKAyU(lMyzui^
z%)3jXfBcVM(#guoIXtt<FHaM5He37#ir(KUIKL64ct}EsJel@gl#z2jBd<rQSIi(@
z$x>UZu7IAUK|qf?$u)6Dy5J9+%jlP6vnxY$_&=2Z|8>sCCaL`)$i=srYr8$lu@<Rq
zxGW4L$baf!)|fp;KSahxsx^*Ob&lu*AJ1U4$n1Cb8C9GYiPY%vUxBKXp7SU|UX**?
zum><e1{d}yAB*lQSSDe_LQ=)lHlK@i*BK_@d|)|6HKGR!r=WM3m1%c5Z5s~_-|bdE
z=0zx-nl!($zqv8DzFKbbIp9M>FzwFXA3Magp)!02ic@&*yqE>rG-sn((O50&xVx&L
zH?ci(SK`Liw4TyGHBAWp92VoXrz=K=a4U7FPUXW~#;aY)`t5IFmxN*#c-58Z5#gWY
zz8lb8QDXJM;iFuHU;)8Mm{Yq|(&^kg?u>K~&6)t9==C*67GfsTe*tZFtCp?;Lcs#S
zp(2wch+<o?V8RqzfM?B4`>Q9-PKGMaArWH%60BNbiNQb4aUQtI!d2SEi)gTw&lJGJ
zmMKy!|1q<@X?@23uNE0;h6|otW*BIS8ngCC=bF1vL3xl9-hCMn8Q>^GDr9}046_wN
zdjfZV=Ko66SG2~{_>Es;01`fTXG$te>1XNL*CJ@|zHsfiQ#q+_tui}vBirYj;BwB&
zz*IKfaE*dU>DM(Vhm+AmPnjW}?{QPG5gcXkURUcd`R&rk8)5M)v`Q7E0M}<suhXwS
z1xtgc-kY~6MynJgZxq$KG1Wz=?o2BV?q5X!;FONA!(2nVQE2bIpRsKAsUpeO;kM2`
z;LTrb1J6u;xF8fb113xPOb495HuA6@HH3U~E+YX!$W2-qk?r0QlKdB9e-+Cc>bO()
z?UFPD$3nxi@G$&EN?r(zSCLy*NJxcR(fbCg|BpZtij75Ah;r;5xLvTqv1dp~1oKd>
zg(z;jNKUx5%A@;zt^?3y^|;f)!o5(~)`}*#HwOI%zU#N+ly0%ZWE|EISNXem1J;_H
zqrbH{@l%^9>@Pl~zc-CvDd!jUo+4PDSC&s-`+=m{&T`SQweVgA6{%jPy%K^j(EaVb
z)0kzBVFwv;-&-6F8&V_4C6)!6g-c|tF3jzA<@09_wc|6jlCMDy-*LboGGhFRgpm5G
z9DBwlJj%Lf(Usvt&_RaBB|rZu*d53l2vzhn&3`DIW+j0e-gZ2XlLE|HIt-vjcx0jW
ziWdNpjtnINo+{p2x~k}OGk(i^eO>j>c+ju*b2TY`y_ITqx$!<Q1$P6Hkl-k^$X`dL
z8QfxNO&I2x5c#w`At)`nPr1ZwJW4i{&v<GOQMESWC9uQiF%T+qc@uhIE)!wvO}J}n
z?XE3+DpzGI5@nSxNAPx5^1EvQJlWq!9pTPEHE5ZgTqeZ)h<<5>6{L)<z$EOEWIiVN
z>GWdRk_f>vEvIHF0euH+H+dkgNecbFN7MvdhFCcv9w*0_nfG(>J!7T(iPX7o)`2~P
z>7Ah!LU$<B8;Q>uLyNfU1BngB?*rfX*WNCdt=50cev?r(EVC#CoW6vo>1>A!0s}Iq
z4K!<LxF{vx8i9*nB!JyL>Q&8uON6xraW^bR)+}huU7kR5=~-5Pu|NPCrkc_=hhM&5
zaL7MESOxs=-m%`fX^%}T>?Y7`H6D*f*H?t5tR<q!J&g^|56T)$sUSZrfX<yiMDN;N
z(lKou#xL9E--p=7u~!;GIy`AyVe31RAB9J)Zw<~R{yNEuT}?6+oI{LCbqmKHF^okj
z(`~gmiGLB{MuKjIXC7F-P1H2+H{5uY`UsxGns!Kdbe|O=6Zw(9Yv|PM{hz~NVs_Kh
zoce!Wg5@j@lCwQ2{Wwu<9fFbprYIhdDEhzt@JdCE4>^-f-)WjOy!i7gl(@W56pg~b
zLw~u+&BCtIhXxaM1qbvZzq~8o-bJPWcc1pQ6zKUIEAx6&-^W^pzB|%~j(U?3aPGg9
z_UQL_(s48td_UJ^&?Gc&OY_M>32_uC`Lm>P<R8`=r_TTh9Nw@Qa(koBRffm54Es-|
zLufvDp@_L5e{3zpV2!H{9DVFKG=3{TN;h0^rq&Sy^D5(f?XK7{bC7*j^CG0UUYyzu
zLJO-1(c;e`*XB5$e}dtC7lzjVmZdJMKN$Yme0-z$hLa)uX9i<VStg16OKD)|(eWNo
zQy`)(mDx^*fz#?#M~DM$*dj)BhU=FsE0kc$6ywZP?ukyy%@n@<2zpAHSmvJ$uU8<N
znQ@5OU0@7rXfANRr9WigW|1wEr=fQ@6c%`j8AL8Svu%`y<-IyDb3}j~zMYvus=QBx
zd6;FL8_OudS>^lNGNK0npuEUiI|~P{4$i<IfmPQ+kqwYU@#`1YAn{~qwG8wf5oX|@
z(cwB^oSem_$1zXiWI8;l#;+ju-pq)#X1_Y#kec?sSI{7U{QebG0}Be=&iJj_CU<8)
zl>_^T6>CVxTbSjH9f9fCUMB=Fwfq@fo*nzt6sJs@w#GOSi=~;-POPc7WoCH#Grdq5
zC)kW*e_^KKFf%y$1gq)#PC-^p+ePdH+IEj)B{U3Y8Z~AgHb9`WKw%S5{!mU-poESL
z*pUP-TM@^#@W%Dm(SQQFzh00NuW4V0NfxFcnreZq&YAl^e2O<I0A^wfw({&>w&j&6
zf<RrFdS+lZ63vEnix$o6GzNAuqj~x;%@DPf&W_Q^PJZcCfni89EY!ZTnVY``_OZ%I
zX5Pry9P>S5d{BTI)R$2t)1S8{o8(VFzdKfnkz5I(lR;E_CjG@W%w?NyOLn}xJnmIM
zwIR1wNlesYChCkP>g^^Pd?p&hCz_HcnrRa)#S^U!F3VWTDL3lX<l-a+Da7gseZeIG
zoY#Ndr792{SH=cxGkjrABQ4;|N3KN4Kn?{v7uZUBCBh34(*MjaZvnMlNte67I?K2*
z!<d{7rVdjUN>j*m6p*wqf0RppbV5RyTJ8pwaLdo3g~4b#Fy4bJO+c_)Ct1@KMnB%y
zkUG~~j>z}mar+O>Z(VSk7Crf&#N|hJE}vn5LwJtxM#jxP5I24;a~ho4xhz4edz8QC
z(!F`B3oiOv!R4qe)1(DXy$e0{cc`&~d9Z~KO`wHOF+zi>SBob{Q?pY9_}597e^0wa
zJnU{IA6)tB>^P8}$b8hkHhFgiT)l?O^w$djTBJ7`ANG4340)W#Y_Jy-w@Ala_4M3{
zA2;)7#I=kam6M&oVQZb3abp=5qCFVcwwgYOu>iR{TVpHri5I_HTgpM$X_o>Qg?JgG
zi7}4|OGXjNfw_=bGpD4xEh=P>Wob^io%8I#xl13Iz|DaJ5Rfx6*(uDv54Nxf76dcY
z%AheB6B&fhWoe!WRcGcs3CYdZ0{Zqd4MY4I19WZ?ZhGA55i5~_z+_zsF`@;d(^~jz
zPCfE6pSnKx)X?4~l0PFAHaSkdc6fm1FfhYpQ5c0|!V^&CXo-2ZY5iP}_LhUTIuj@%
zU}6KB_~oFXtTzJys<74?DMFXajir@Klz*{4J$qIQetOF`<Kmn>@mJoJdZu!8i=UaQ
zt1S~Z?)uy4kSF?3JNAYDH|G$4K6_<j)b7Ck(|)Qv)cluXg5yV`d9~0}o{8@6lUW~p
zUes!505ut;KE@P0Bb+l;Gv}IxwQm^DurOoJR{G8sPfGS?y;7L1!l3C`#)<YE<I|Ys
z2Bx@z!U-77p5X3xdh$c1u@v9zrPIz_GZM|61h(^kCY-KxG?>=}M@;DV$x?m!C{WKI
z`?6T)CDZ3+sp4!7;mGBZmxj4i+m?sr!!IkJzr6b4W!0~j)qL|clJm8y^L57aSE;<_
zo>a5t(p&rQLeTu%F(200EX_?(XO8l$cBp>1xI)9{>SB4Jc@}A^t$uT!1{{4vnoIiQ
zM~6YGN#FuGy^j0Etpr2aF8V!Zn531<J-!hUzU=TusSCbLe;Gmi9JPyi<ZiEo>zdNq
zAo$4qAP`I^0dx~A$b1|7-rQyMpOOJHkXH7Z+I?dr-k;6_SF?C?*P%zkUmwiWS*d%b
z>|Y%jKQT94bnPIFfP?GwWpmS5Z)PVY7Vu6BW`${eV~v=%?JZJ4W{|Kcx<X;D(GFG9
zmKHn*iD5l%tvU8(_}DjJ2j}x|SDx3}*YF+cyivKYA;CIKwxLJr2C$NEoyVI27&Iv~
zUk_V!v8=1E?cLw!0=hDH+6!|}k?uzHU6}#{yuu7Xh)j@NpaaA-LpX7vo)Vo|IYWsU
zs6Lj$U|oIZm`;tXfpmF4Oc3|h*ly`_oe<Rxd1DKe_)kF6WIrS>{NK2S@|xnCwTws>
zBW=!0@vRKfWbjZxh`bbpw@OTVJ!7*^@0ehSM`ByhJcH+Sc4i^N>*AQkp5D$?ekVa7
zYNgAlUJaa-xgS~LruLOTHONWntTQ?mhLd{VI#4jTZM5mij70e~=PtSKfIOM>kUovH
zvJ6d5=Iw8tf^HKw!pnHw<u-q_6f@&i;0EZBO4?K*P(w@eXS==-Q=SXwWG_3bf!fDg
zAN<LfSEhEYy|PyGrZ^e(b~4tc^yjZpLX0OynIA5eeYlRjnFbi%#kPMU8pvvZVs18t
zDlx-^$p+W2^iy(aQ;lgg5Bxl{_fAK+)QT&kZdal}!IPa@W&TI#0ttK2lmWMbPTuNH
zFhaBq^s05{13n12ds>)$#zAPXLVz}BoVHIYA+8^L{PA#A#lc;u28(j$RmQ0~koEY7
z5aZ|pA%3o%jG&V|?5@Up@U>?&+xFb1=w)Z-X+J|cnZcRj;{Z+RBgHSHKV}&P-@kY7
zDcQF+d{v7S(<Wn?w(uVSqn@71Rr67?{aUm?Z)V8c1I9wDwpM%Y-O$5BgM3$=`5A`+
zUdlFTa6V%$sXx`zW=xzmp)%3h@fpL3Wrt_!kSfoS!9*0ae=egh<mSG)^n1~Px9W=w
zKhPr#^hSQUo*qXVfV3TX-EvE!)XPxc4wl4vihXviYHqsD=qoNTZ1{0jYd1k*J!2#D
zlkWlf^O2sM82p)muZ%WAkBbAlqgY`Q8rBj^GqYKmAFKB{@q+QWypvM#Q}_gv*GVRu
zd(PRcjuQbmi7r$<e`S($Vd})&EpNKhfnEGJ*BGkP6s=dyy(Q=SstN7$t*le8{q`Go
zzwbSzjlD{p8vSJQBP4TwcX!}t<jLbl7?A)jt&hFcbn@7pE6Fui{=E2cRR4c1CYjNH
zQfoZwYar7#UdJ`?;WfUfHOOTJ<zQ-j@rq>#FSSA13~^O&3N#(k>@d*J7$7-Lk%Z5Z
zyv-l>1iF&UF^e;y+ckW~Y9&M_Bz{V?V1bhs4IWK0OhG+k^sOtH!cDc--Sxi!I5!#)
z#=tU?zatb~AA0cfM*qtAC7gM9;mIXkYu@+EjLxJq6j&RX<W)cm1Hd|-Gu)}l%W#YP
z;eYtP#?Yh=iv-MN5PnJ6GBZdP9js2U<{{oUVN4^|Wyaj8qhEfeb#~!QOV&f1911I}
zzajjACC_oq=oPFclpnvAnG#nd*$i|04Lyj|urn?BEkMqLR}$_Yp1^@aIwA2Z^kQo-
z$ANv|k#USnH~-rh;KT?e%^2?$6a5)6`b}0){-1M=M$e>v-q-dg|Dxf}&}`3msh2pI
ziTt(OC^7@@9)0yI<<<USd1HoR%zLX$ESk2Rp)OJqSC(`?8S)0sh-5v5{}qEaO`b`^
zr(E9hD42>{kVlH@8{a56k#g$c+>@iBbpMpqY%mbLl9@D6kX*LFZLP^m^Unxdp|fj#
zdWOh{J`ngnu<4@zV(M{88NT?tg216|v1}K{L?0y~He&-#Wl*3c+jSA15}>2ZI4sgB
zE#AxPtm~|RXx-UDn-bg#SS={S<dP!nGL<+5o_UyoIi6!PknI~RQk)xeIRrYzlrwN(
zqRKN?Gb^NjpZ1d7y3q-FW&Fn%FJydQkq!v^n`QFsWjUj=>BE`b8&FpkrErLkDR(w`
zEhD@}KwYn-hMR@d{c}rQvftgz0;&49_s+Ns{b$YLy92zO6`B<;$C(6wog!p_gZq<m
ziXNwUzD((rJ~!%E(q+dy{u3H=MQG|F)cT`<rU1Zga$(vHU<$IvE9Z8BGO=1tS!Fae
z;m=O;@v}Ej=Vxt7#t)k$k3mb#r*Av)_WZH$B=h!@AW4Ocu3%mZ89^~+>J<U<P3QX;
z4X(koOL~51^*-@h5s{31<JV%?nnu1BxWZ=vz?ALR8h-x%;Y+3oNE^hjtfB1~Pj>m3
zs*Nxm>SIv!_$R&Udg9`qYQtd+U`ee4#i+>E1PzrLM9s9t{ETF4M$a^?f6SNjFj7wx
zJBa;OZCn+QWpLv2rpB`t?`H4z*k772+Jv9*)kuF2=%+3Ihv|1PINqPOvuFRRu2-${
zoWOGkSz0|rm;QIJ(Nb#Rco|T&xtATKV>`#ao%N34{rBXL`TGnh^&ZI1al?rU(^KES
z?ij92dDiN09?pT2X`}GHUuRF2NlpvCjIJ+39KG^Pp`>6l<Dh$e+TJs8%f>@hQ`?5U
z+M;h(P3qJcx*)RQob2hehgGM3eE(;;y%w-&wjt5&#=&J+7z<$dtja9T_4P-!Kt#%v
zfzNuFF!kI^yP2k_bUwKh6op^24@DKS*hbMrUChvQ$$%6zLpHV#ouPPs8_h&#nJH(g
zR-`CrX<X}5&eplRt(>DjVWyI6JfEVHXa2cQCI7&meN-DSV2&xUmpg|kbe>s;D8{ce
z)yn6gLQ5n7@HXbqVTjDz5|PuZ&q}!_^gC0R{4~!sWdw}j9inobc=HKg%DRhBRRx|B
zBF-kWCA7KyL~&67Cbv@KuV#k@Xb>{Co?%_wQo}kwyHX?IRe|-&Rg!CM%1)YSZLF>{
zzeZ1rzgcSYp4@#zPgvHlIGSTM;%PmMvv;*7Jr0j34>0g)ENxvEh`(VdD%f_GqiOl9
zdw4#%t(?awyRB!?uhsKrL#$v3YUiuCZ8*2A?uhCLJc&=XbW9Ss(mlQi!?0oMa13i~
z&_|m)(4*Br7r2Y4hwr?)QLk@bp*_e{GwNg;pT0|CLtW+9AJj_S)fo}+!{^!Txz!D$
z*JY9~M-5_(WY03c+A}Y44^DS`gc@JeSSy?JzVhJ`Som-Bq`^1swO*rtZLAxz@<9vA
z7h-0TNPl-X%60igN8g~?ij)`v3ygb-=8%30DzU|4VY;I-MS0b&e0S|tMo9H;s>C~Z
zSMA(Q!F{0>k>1__H{OjN0zp4dHJ22Y<NTz>-<m$iIT~2B1W?Z#eOUOl`b4VCuj|Es
z;?VCJrFn*MQOqV7A>8&D-Cc^tL&*n$5sY|(RWjJKQF0n%6c@xUOw4oT*Z8TV81u%E
zS;A}?o@BppuuLXCZoYJ(2X6j=wdp5$;{Hv;Nw<$%$4WK+`%-e{$7`IDC{LS2-W^HX
zt>>ZVPVMp!F6J0>`S@7EsJFh~o;<JW$$ha)m3vmhG*DB^0k-QEM_>+S$GS~*aC&F@
zwhsYP1uPdCnqs&Ub!?#k!VJoy(cd5C7x{!`_{N87RAxPpYR1-@e<u|yKNUi5-2S<~
zW=Q1+(8~6iwC(rDW?X6)QBCqvw{XDq_g77F%DPK>znU!k8O4az<pMdpm-2wiCIg<0
zmxoo1>z$l%-aq-W7BtW!{@Et|U8Nd2@PLrdl1g8wqqNPosF}O6Q&pcFao-9q3{ezN
z<Kd$_5!q4ZU(guKu#Eej?*#!fJ4>aX`L>v4|FsLt+f0Z{EdGaJ6?qsp^-<(J>#I5U
z-uzoJg8^>Z907e!Bcn%bA1_B-^Z4O(FcQRqRyCk0D^mw0Q@bq#jW9`4e_y|g^(Rgp
z{OL`lE(&**OqRu;I;6e)>QjaJq*LJ`t%ta=19qi~Us7~SFJ4(>cf=edmaGc&dI}of
z{W<jF0RNe}778JjUtFX3J#rK!)v>VN@bD`=-6NEGVnp<ct-Hsisn3`jQiWr78~XVR
z55s=dcspfDX)8||YB<`I&)6_}Ds?Aa^x1{^saTG9TnN#T598!uaQ%{Fj*n>nx=4zT
zgwc)oMIg6}<qr;4<bmbbL=S2NuEbrG*l{!)DR|zN6jsL*%{d@ukZ)oXe&sPZO1lKx
zsTRw<Nn(d8zo;VM*r%TczXt~fs$RCcU%J_NsU%Bs%N9nSS<*kujB@^c9(Nm()94#G
zaxCkQY{@@r#6LK>UCJT*GI-$_ciW!)%vPkVk#SD)Q7fTms*tv<q5$fSHaui;vq;#W
z*+#I@*Wub&&Qik#gB_(U(%<RXz1}{r#S<1=1;X?;iQBhzjvrBt<V(UeTRI+$^G1*O
zH0ur{7oDC-rWW1;tWF?L<7x?c@AHqB4I9PXS3ABMpzpOf<rQPEXMDqZ_U;7j!H<Jq
zgPz2`<}q#bWZ}j%2U<Bhnt2Z%MAKz>2Iyfe!{K!Wg#WElZKI3rSE*hNJ`4|iPPxhT
zwtZ#oFbz$xb*SapCIVYL`3HPjMMlU$fY`cB0zig;@yu2|b9A~W^jY(>E8j}9Zndc(
zO)ou-jj<!Y>aWzeleH+Wn#|w!;R>r(RMZ`OVDp!CiN#FbA%_=}rT0Wm1``jzuQ?PA
z;NT#!b)=NLX7eqrb}uK#HpiIJx4;?)c*Ie8euC(~R13iiDI;mOu9_Z}3C{ZPi>9XF
ze^g(`+vWKA4uYXpbI^)kBKy?CrVf5BI6?T#E?wzNoYulIna@Bx4Lt(mO|(2j^V7i?
zNLjn+bqr+zq{jVb3y1Lj=?vemVT$ZRHg;@qJ}sD6oJVHlHX>2ge^)g<DvzsE{AGK2
zLCO2|U|qSR{avR69k0~vATg4P*N?t(*?P8hW=vDzr%v+jVu9Nwr+Zxy?e?k-LaZ@6
zjIciY`_$PGEN%b8VEbZ4AWMijz<b2x=IoW|ilvJ}9-}4xu?07KpZ>mYI<a4NW`<&m
z7LbWG?%!|rTMRu=S^9Q-QhVl9bN?s3H``AR=p3&7+rPq+NJz{Klz1n1fAy36ou~D>
zzgiF7|Lpg`;>FF5U+t&ve>ujrnByoZ>oXOV!}ToZeZv`+ZG!}Q%8(*CoMHZY5FYcu
zlKGt_l=jtLp{2&tWDlRCG`T3XFcoe+v<U4ttRmcUc0zv^wOV`>N_evdHQ=5f%3gJH
zL?)iJT2aRc_ofoyS)`1B{h`-@$Xh{6Z@Rg)eg^P5T{iZP{mLmW%AVCA5xV_P70wpq
z53>GAsG#D@YX5%Fi<Y{8z9;ht#Tf15m{<4Nzp3{)b0kn1m@%a)v-E{XD5`Y6C+rKa
zCoDXiDsyeN0I5_j@bPJy?K>A3Zm%|<wtEbIVLjtbCc|=@qqA8pgW%YN^K#cIB;3$T
zNu+`2sP!|>(kfH7jEaAB?B9u+luCAh1Oc#nr)tK4Fc=o#0qxXknebz#m?8O1BGAXt
zsR7}ViKgJ-1-yfa8#Mr1o#)0m21i1L7tg*<CxuftCE0)g7YbvHyp%+7g^ro9-t6!J
z5^}+Wz$#MmaR6Lpz5>&i88SkkWzRc;KN4+xj`ta%qss>QC)k8e)XNx@HNg4WS|bBK
zW(^Ag0FJfK{^~X7SWbwn)KZkyF#>{kK*sI>j-w89<iEs_@j-sqph*y_zd1XaSP{5<
z10Q;82#?q{l?%DADKd~6bW^DOwc}`~cRFqK_&&4%BbYE20;?EQEhF~15nr9I-ER`p
z0)^(LviEoF^(P#-<s6&T+Gyq=zn}8A=R|43yC1DcgH2xhVuDoYTLM#AV`faAR&HLi
zq+hBMW%o|S%HcyMLzYPd;KzWrbc6HCo6g*7!lS`GjT$|67~wS=Iq$Uhfyh^(f)5z}
zcV|JRZSaQ%$a<T2fTa?RMe#|o7gcH2VpOwY%4Yf7<A~7p)9<nKOeralbLsM5NsNp2
z@Gc+OoE2(gMLCeg&;)zHDMV{>-TLstUaLJ{Q#AoxpR1rmY^CFx8oUgKEi`GC+j#W}
zh=C`~CY*{~Mxr&@Z=aW2R#FIVRGYOh;1R}fhAEZw)<CK8h{3P|maRIVm{OLGY{R>0
z(zf2DBP9r!D%E2ZVTV4d9<O`-(%cb<tuEY+I4%{L@wG8TO$}ODAFSCFW~~<P&=l^j
z7U9<vaZD{TvMDk_Eox)R#hB|PX#~RbRjTxO+hGb-WOx;y+ePO^Vu~XfsgZ{QpQKMk
zMs+YB46u!DiT6)9=mc^Mi#-hei8{k}a^a&kc9V}noJGUEKTQoKx@RPL!^A_18f9U_
zuhp_Q1=LR$o(kmL27}tZ4jxl*a3k>;2UCr$MxL4tC9)vpI(FtpuMXBUpYLv_54;*(
z98yL*rNuU9A+n?-z|Mh#mvl$YhrTG<q>y?<59V-ezOspJBfviiB8vypBj{z@Lh~E5
za^?#|J264nYz1QYfX7L1h>4k;)xb;3Hu|}lA@gP81rwUS=g|VM;hY!I4BVS|iUeg&
zEwj!^Sq7{fFqp2%b)bCoCm<-v3(o381SL`ydWtQ5MBwx)TezKJk`kaY1bQ>YMjO%8
zhbW3pc;&uHTpykou0hlW>Es9!WeD0|GbwYG_r}GKj>}c&%^Pau49y`z&pl-|ImztK
znUzuMKLkXPqX_Y%y)iQ(H3zi=Gxfi6Vtn~^|FIuW;c;-{sUZ$7H5M1RdfvgIT?cHr
zOVl>vL=5mYXbh!pU?ZIw4!J`yicWXz`80-K6*RuOao)RtC+^<GCzm&43#C3Yf=8{v
z1lA5GWPGIXF;&WEe+J51)mh;qn$;dJx<XnRHY4zgA?&ffKr#gf=e649ZO{c<xn&rW
z9@$uNd5I(}u?Ihz5=Q`2Nd8CDb6P@EvE%l_VXGq<Tdo&XuXkrL`wFFjaQ5+rmaLCd
z(_Oj>X40mNZd~bazfy2~t!(!zwrFsl=K`JXCF&H%Yv-&I{E61!qHD1;#nE`n6flw5
z)_wpo0k$=)p&u4vvSR7o%h>z>uDF!*cS8=&7)U?X`I<%cyoQQl@d1S{Uu=3n2eyeu
zYYby7?=2Admag4xNI+d*>kv%f^0ns#1^auNLzXf_vWs+*TOgrNgE%&LtVdL~jqk?4
zFZ*}y_h3!-dH1GPok4@Ls?y4*bxgyr_If!@24?dZI|7#mNvUAx5+G`xWyTWR!6f|>
z0#-6VXuNIY(<KSsypd*tzr!`np=<0Y0`8T~Kzgc0F42q=FyOCc#fbTQZN``0^+z7X
zf6~dToRm9`{`Y;Ul<8TZ>f_)U-4=yapd>F-rBc2blTQHgek%~$%Ujv^T?85$+UdG>
zMxAlQey!UYVCoE&JQqh?NGJL8ib~k!Xgb09PqgxNEM03~FcRe|Ki=qO;{2)Suc=!u
z>zGW%Mzvuz0Klqk_zbB-f@GhmN>iXo=8HbelM?KFjs1zc`jFlBMQMmYBU-P-5f<W!
zw$y+X_OZ5)l&_k8Ut@niEBzcR@pwmyB}~fkr;vQwqubQ62)y1hmwKHK*aDGzB3?+>
z@Y+Z7)`x4<2xQ^<Ak%!nE0dvDlmsA}f_IC0qxOjiW+&HBhZxYR1i2TmH$f#o0(#el
zKd?luJ7Htkbq1d!1HX5Z5`YC~tIa`V4T*pgS^Z8l*ym+ZdG399Wj(;YgrG<t9<dIl
zDm!Yqr25IU;B{W}p3<&tQ|?xddQAxC4R6ysquIXUPTxeFygy!g>Ax2x&(||?6VK#Y
zo-^13!6$)!kTRRsbeDQt%tg9)#A?^IW&r<)M(@B5?YKbis}0>#{$#a)C)&0ow>>1t
zP)N(fU<KyDf5TQfUR<$+Ny+$?HhrB7%x+t@^)i(m%e6OJ=2crR=m#HKmP%4Y9hF}f
z5Qr1A^p^#e@%V3i2YPhc>Djj<HX?#~E%k?Ne(+t_AChjfk5nA%(-|q^?@^k4;qcSP
z>V{zkj6|W~6>E4VML$z`Y~`NeQDpqV{&w9Ky!=X++Z-ieDuKf4iL|}yvuzZRnQYz>
zt7T@7u^J&<nb#Ejg}8RoOPgpIPaN&!n8qD3(?6{#cG_#@sKwl1YmkJWe7(XZkDEAM
zW0|dG1hTyvz@hgZePA3o+8g-9IB2#v=$-MgPrsgjxbdzNuh@`&@Jny-S!VYT#n_Wm
zq)jmnp9!epX!_vgL~ez9IMu@0|IU@r^@sFn+|BT_Ta;pcX~08CorY21MMdLf;t2s?
zd9fF6#f8B>cSCfkd4#}q8>`K@Pg^u>zGJGZ=;pH`PhabW;sj|^S}NXhn`mwXd0xk=
zF=AUcWF>msrfz<<*-Tg4<x2x>6|_0VBzx;NBGS|JocdTgAGy?8OHG{Tp(fa*^6<IQ
z-{h7-%it0zD{Z8{t4#9$u#kt)42kjE<Wr7@FvnH`h|Wh=H3KD_6*J@mz6$rzvK`Fe
zs@i+RVS=6PL9-0111^|zHIUb2x6CG*V;pWm#PIT-Hp_nKpk`MZ?u<XBeK>p8EJ8*Y
zai~23#?h>S0D&h7o9($G=avv$*E8?jFOuko$#j2~L4l3AFD|R^F(-hS5>p8&jxt|+
zd=#+DJf{FUAAP4R-@N?to$_k)ism~NH_WfxzH{Y)dFAMx$|vSmMR3Ajpz=e5W%@AT
z*>e#FSqTtzB6(1MfJW-1zQB#i|22;gc0J2}LKsW$`8D6E&x|*?8!kK{g=oq9=_S2G
z)$PPz<|8T@In{*zi9Dtm<b=N%*qWr<o3d$s%{8*X!U1@6%VUTr$<j%c9YbzXjN>^t
z7APVAu}9-6^C#yul|I{GuATg3SN4xk5{(xPv^X1>&iWx-s#D(ir==UIa%P(sW%b3b
zHJ#+f#s>0=9U|7r!+t}!wzy=1P7cvOv!ZG6`EBWNPEza{F7YCmeT+05*ie?va<f|L
zxfEV`6F!;t@q&3>`dAL9<6TnhZhpWsih=^j0tQVK8I%3TDJeZ^_P3RD`Mu%V35*fN
zAT=9f3qmdPXukm6u%ir1ja7c5GSt2mzJ#}3wu0u-ej0e1vC>`pMMUHAqc~D`e1=WK
z^Uy)xfCD*Cu7~m<*FtabnP_)Pl;!=^9Fn9xzjtc9Z<*N2k#fBnsdDfD9;Dy%dF0G4
z)wtU2#mb|UCvhc4bFHI^VXYT6H(q4dM;DFwo6+#1ojjF8#3LdwzzBM;Dn`zhef{sm
z%wvOhBDD|P+7Z%RJdRF3G1vOIfhYI2Lr%ne;PmX<!`7lp1utH6F2>+reWa>_w@!V{
zkkjT3lXjq2y?hKlSz5aXIi_CDN>?$Xpv}zBe1|GNOP7-<vH1JnPaB&}#|N7pHop!(
z_;uW7E9$}4Nt@qiAN+QFvw9s7&Eiq)*=icE%yWC}(>EBMG$@(V<gRD8FHc<11OK(8
z{N-?eBc%yPcx|0{5#$BU_!q)zc5}>NVulFXVZU#0;BwHu*7VRZ|7b}jQU$~^K!iIN
zse3i~-0{Yci8K4Dd_q#AUC7R!u?x*m#xCXWl6`;qsZS58j0@C!?-s`#YWApgD6uGs
zeV%CtgsVPV<GK)|_E3924?m10YV0=>Cd$Mkdn^27N=q!Il?!mAa+<v4U#nVOv^8cf
zU*c<<WYK?rc(uzC!bbDaj-^)R-QIxVgW|up^=w6Zy^VBS)dGxe16-5IAiMo?MV&-7
zdg0R4+=Dn{z0vmm3#v6KvWZIatuJC4b4bs^E5Z5)Rg6S)xx|jjv!}nzc16v;?JJv0
z<7tCGx_cX45X!SLTz>t_CYnMT7q|N8A^&~*)w=ZNZ#_BlwDUL5Ya+UCVF}v5J>{mV
zK_ZWy3_{U4p6n6COSgKUq3lFcf!w?%IcNo>Uu`Eh?`frRmw4T<;E@5QEUssjPqYFU
z1DD!nas3;l6KX<kpmh{vN3Mk7$~`-X6+9RqZqGcD)4VYDNs01e$MFC~u9Z(JAQUZH
zhi!(}Olak5KYe64U5Us!v#SwR{Nt`b@C|_1>AhkayOm&i&F^o9f+d!sl@~%gGFp9(
z=A10Uz*$Y8LzpU*%Ct*~O|@xnW0*O~TVHz0jjrGQ_`tmS8oN9M_NP%+S5EBty$EFk
z$>)GigygfMiIcvw-4)|4`EKqi31)@2UaH?O|JYqune#DImGc@it`00{!+{%s#ZKN;
z-(b9By%$#V(@aDHHKRtef4oH|Xl|N09aLV|<Se|(rcIsO*pYa9ap&9Yy9yLfoHU@#
z<sU$5VJ8Hx2W)+@Tf76<@?Ld+XpR{$>9ZQGP6@3Y4kLo5*ssrwp;~gzyqhLGPK4Es
zB9txoYZNJNFMmi=*aPG3X>oUjY{wdQpng@Ey7SRN&&i*vNj>}3gcO6o#0J}j(<64w
z#_dp<N*E}@#N2DwaajHDLVSt(@o|`l`4jWpX^MP+L%q#}Cp9N=>&T~-qO8u5fF-4y
zkx19yy06zby>Sk0!3yb^@*moXb}XP%lYIqPat?cZpqX+*_(Xs9@&VxEbr1LdFrr$l
zNgmPbViW4m54&qIsm+IeY(0dMh7>1Ud?GN}4$*Hj_1>o385zu+&vCz3iE=dJZh$$j
zQ6^pjM~&tgb;_~#PMq&`8XV6HSs!pd50u`Q{rnKrw^TJb#vfHlTKXM%cBwkv+aPY^
zz*{bthgmEg#4A7B=U_2Zmm3GGN55TzS~UR3yH;)J#VO`Qw?Q?@Gr@|dg=OPc-}!u-
zS5)h7M*gy$dcrp69FLof-zD|(8lg$LanGWVVjX{_T|4^cHuPH3Pvbj1L+F_?W`NyB
zcG@GNhes080jAy@UFjec|Iks-WvEW%A5|&tdWh?vrUzp%-7GVs_p%~TX^KC{9fKyw
z4iU1~*CKSgTKLKp@cC(F3~KwFhgN4O^Dtsr_HQQL5h6~G>W}iqVz|BlxIpv_K!Mp0
zaP<45th5@?LeZoeqp1OBWiyAA7c0wBQ)Mo`ds<9mWo8tXknz-iDK`1e!M7dh!V9Ps
zgM=C=erf$-4R}C^vm5}tO;p|dM!fhgZVXF4C4&4&JUPlsx7*|C9$9-r=sx<vbg*2F
z9zjR{L?{FE<VMGtMrpG<K^6+r2>N3Bq0n*Y+VT+OsVG=}wE<?jhZj6IlNm{0eP)7P
zd{AaTgrt&kUR&66NbbdTqH<FA6_TdMQWp_dqZO2Vwpgz_(}k(q6sHHl8CDW7jTnEL
zBHPoe{Bd!UaqsHE#EL^#zZW+j__gYhF6UD#T+(81{Mn0JP~p?4The;)^yfpha=xwZ
zCD(j=Kl^r7__imMTo3y7`EZ;jpFwm2K{^8I&8Qc<`BpES6-{%z_MYKTj8i4Ch?1(^
ze5TKMLR_7P^cp@P?r-?2mW|n~%m9AF4lvOdxCP_g$N_p*gG~JVs3l{179FX&-&_CH
zn2=bV`KXJkxjq!tJ`E2+jbR#8qlt*F>LEXMDQ;Q0vm81%B{^2H38tYRqo4PRt|DU0
z&(Zq4dcYKXwr}_%6WtafbjS)Ue@D>4P5MgEw=#mtm6$Q>93JBb2f%U<dM6liA?Qj8
z-g<HU=^_F}n+dPK*E~3$d~oBKj>R%UZcyuFG!M79XtVC#GXXt(XLJAeGhV8RYkt;S
zA-Qo7)Zph2b<(`HjQQ~80HNt2<J3NpGky4bs<$3%Zi&M~TKtEP5!P+mM4`rJA`c?U
z#bxB6{9Ov~dsUA#JK4Wtg?@#K)ys?=*x#8ot6d%iXMVGZd?@c9{25b<8$os0LfjsO
z*+igVT5O&y6A8TVasFtR8Bf(TGpdj<&&{&&_{elfFyhC6qBU{`GQ3l-=w-5AtwPL7
z8{)J{?m{hHq{!w)VY+hmA8oSG?}{3XG2c$WE@sFApii7yjas8L)2AOlPbnimUUSA7
z)g5HE;8osgXD)5%zs>Kwo5q7krU^b>%;5U)$Xz*tsY(AQBk_dO3m)ez!3r7Y5JSkv
zy#g`mvOpNvT$x(Khx#*>6FIdg(6`{AeRnC-KSxh=WMKriD@#U;TWaOaJz4g~(j8Xz
z%W9|ibe2{TwqGf7udpLnH7Hr#(HsFfIHVc9UWp@(KjiTr)_i2}<NQ0zcRVd%ojp%J
zJ8+o%Oy@9BI6XT|fj9kjP^NCUR)O``3<>P&4VxF~Z}QuAkvhL?3>4&undHHv82Hwc
zPwY3TD1z|8q8k_kF&M>;7?4o(@B+Vq;a1Xj^zhuM$<n&w2`q<DfF;}uoxc8^O)TZH
z^|dnbxsr<6$5nt9;?^`<>+2HNl5fvl^mUO)zfvf&GX1UfQs!ow)j>gSU&h4igvCD7
zWrZCW<8|@nRjtkQ=gQsrF`IpZ%+y-kU(_Mzs(mVJvldhNZa>z}#sm?;i1W$DQz0Uf
z67p`^ul>P^e(2JnyRQO5)BAE4iH=H#{&~ICpZ&I5APAIM{L1me;9tBs<Ma2um8VLe
z1?;(rwPt|!H<*KZG+sD{f7dAU#E|vwV!lJo4`iq3ZU3gS43m&C+0eoNaF4r28EzAY
z@DC;MwA#NpXc_Glt{X_WB3<q?zhW_1xuIrnx3=5`1Sb*XT$Xr-3814NY-|Z~g<l&&
z^}yAk?9Z<AFlCuDFgSOUA)oY-wjA1SpgP0!7$eomE-x5ug&^_<u?;mrX1t<Vwu1Bc
zO&H}rvho*Yx0{!q$RZ#B`{B7I)cDe%5C8>>(u6>ee`EyEuvi5mE0RK$ZrP4ntNw;G
z-^f8D1EP;WCJzv5pLK>C_VB=AlxJl(Fo=+Iw-zCv;taKMcoUUQYc_1(Az6<2g`(tc
z3=-`+MT<bdHI&fj0fbe0eylFwnQQo11^E@o+a2_}#_k1zZ#SJNwq?UUEHv!$=+Op|
zo*&%zLL{7&rH7QSGTgMI^^{Px=pLw&C;uN1S>7Q=Vv8es{t<P660*Cfq#cQhE|9OA
zvP29@ad*=X+*(Y(wEpkblbVfOF*p@fJc!)vK*v5@b`g;X4UsvYpyYY-PY3>{8%1pE
zy@)Maad8@*oS+<?V6M=GJWP1d04yyD1EFXYKVI=5WflL$)d45WJkN}_j&hr@9Ej|@
z7b1e2#{Rd4tik{1w`lgrU1e(lL0i1IQQOxM{Bo=gT}48z?5EtWqyJ>13_ysgA+fDR
zC4)s|RR}B_pMXNEazj-4*)mf3D7hcA$69X~y&w4OIpDV>5F26`zF!j+hwR|#@FYxa
zq>HF7Y2Hjy_7TA>1RF}tAg4DlCQ+w!)sbyAVkCWF1|LBfJk7vv1LTK{8yHZhI@f0e
z>C+@BJ9Z`*Z4Jv&id6a2sVussA`Kc4MvbD^DDsd{*_j*TtOC>!NMcC^w;MwDOaE_X
z&}IWL_{Wp5Oyt7q3Y3-MOJnHHQNWi1>t94J3`)ElLw1CWd)A44OjJ%fWoo00^i8nY
z*4HUGrTjtw=)rF`EFk(mA`uuNF3;OG<#q>x0BK1Yb3!=_jg(p0-zCs0Zc(5AAi1Kd
zurZj7(`jG93mtF@xb#E+0d>SgMdY!-vn{mvCKicG$NXnIxPlUGu@^+}sDBhUSS&)#
zs4K6K)&C!&?))99Kkgs+F~-bb%#5*(Ei+?Zvt`RNW8acUmMmk<T1Y}<7RK1ePDx`)
zl7uKB+4pKlC8?0m=7Tm#=62uL^}W9T!1>|)@IL2yzn-thQ^H)}-FJjrfOx#p;JUxe
zQ=Fu0&4ph?lnfQF9cMvYMiD_m99^nl(RnK~5HPoxa<-PwF)Fkj%bBO>->RXt;StM>
z`Q6PB=P)9OCE_<N6M!S=`kN)o?Y0ddehq>?E*{<2gg0gegGk6<wX(m17NsaU+msIY
zuwHgw$}d@I5Z3;mzy08>JvU3!*|ue9!2S+a>erx@>oT8iZIot=nWm$BFCo7%R(+>k
zj-i8ZB1%Q2TZxGDQ*nrpTI5i$40_zAkPB!cWR{0%%wffQEcv=NWl%UgZs0R!41bpe
zbADp1EDxV$iN1qMhh+C2yrz{#z298R_ZQ1nxzKRpUVXZb5>z@Ig*?c{WBYA(9sUDI
zU69-#AZ%#(u^3K^HV}IuGr?_7kK2Qrwbi18M=8lzFCjZ|+fI0lF9pH9$R8gqlLw01
z?ni<9Q6Mhgzru2rT#6E#xCIg4k0ri-<7a09Ruxg;vjQGW%$Ey4;o06*%9wOHTsO0*
zIW#mo)Bmh7AZl+(x}8h(!4hAdAbwXn2v!pY)&U|FHOgQ}+hx)I8e9vmuB!t#SFN{)
zo1P`RO5ru22-RqRv%;|B9RF&g{t#G=81r1nFn-!Y2hR|^xJpb2`Yvl=CD2L?+oMQb
zKG7LHdbH-3tZ$xlP&2Mw^iP8t5FQe7G`#~xh0i)hiNss!H+8S}V;oO7&6AHkI3h3?
zuEGJm9PnT!5thZa4-NvruW>PHpG!;+Z2$r!AxllLoWxa}6qU$0sEFSnN-hKFX#B(+
zOMI>xx7Z)I-?ur2)z9Nn+@t6Iq9CUUvZ9}3b@1o)ADs6Llwll1A<bobs*$H~GE=j1
zbsgQ?{TTKUfN&;J7oTt(w5@#$SNLj!T!xKzNsKZ7BvHdh4T*mDE9x;IsNFBP3)uMC
zA*A{Rd)l<x$*8BV0<JDQ#SsPOu~gGj__i8>&x>(pHL!ISVvcndI$`4gN)@`JAa`Q+
zRE+?hD3tIb<tqNk5LIH4pt6h&-J?iLG+#P07d?MN<j{$eu6V}TF#%nRADouzk<tO7
z`^5b1)yH}}>A7^xBJ<p6?!z$*coOB%FAJ-3s{g3J2mwV;FAp`^5$t~c+>1B2k0nT|
zw!IR7PU5<hk&u;Wjo4jG@H8i<L{>I*W<T1=?l;I8PRJSW%z3htGi{LjA|dy6XYSi_
z`E|xEOF=Ss`uWwJT*?MY7^IHC3pdixJ983M{uoCb<L2^nmoSey5cW5?;9diJ(_qfG
z$yN8>ZoDj}5A<hb$uPG4@?)i)x&ZaC&Wom}icJg)MI6>oMPe@d55K#i-PM7%UJ~mG
zmeD<@viK!O0-aV8V2Hz)=`@z)VM;n8<}6<uB@M{f4)C=Q)eH=aIUnY7He(?L%Xt-%
zl}e2AV~%W?dgg8J>}?{$;I|9{EvHKn{k+JBTEetfV`djGzf>t{fJRq?dKsaY`jqfr
zE6O@v-}e2AT4C{7|0xupD;OVC9xgkD5^I(zj*fqdqm-^*UoNl~zxu5_57KpAEW0~&
zTjsw1zb5YN4X)_seve<G`1y2&yVaUiFVxZu6+Tv6zZp<=WL{<~yO0|z&V0zy3NqcV
z&M_UBwNCT;sZeRiplW{4(eBbJ?5a=Ipw1Bx2%?bgVVPB-Qr-aZI{!o3R7pOJocTqW
zaCr89b(Up9ijzdf`X4Q+*S9E6!f(&zuX||cEyq{&_ju{LavEd1_Ld;>UG1mrYNWYa
z-b(z!cz&Om*XrsJ8TftMVfhQFk0x28Sa+k;m$!a;y$Z)&&i{Aq(5{5;@}W;xZh8)Q
zFZ@@c0ae#K!>TbXDNUk!b>FjS@fa@1Xq|6xuYq!tm`2=ZTWkw%D44m0-I1=n6D-M&
ztrlBn6|R5MO}NS`d0lf_)isR^K93dc3y?nO?NjrjYX7b7NT_f9(@7I(|BjPsJNwC?
zSldzpdmJApz1%apX6ft2m<la>RH5-ByNB}R=FyLbv?q;{^bR@xk&Cp^`9v!O1zov1
zpN`q<un;W%Bgr0M)k@${UnSk=dBo<)0%K+Ppriq-y*18;T!Ho8(EIz06UoCOZgkJR
z;Q}25sGsTIGZM8o5@S4iA$c^hXEbGRlwv%Vo}80=$$g<uaNWKH;-GpRkC5O(-zV`O
zAd|L^@>2bn9yygtV|2~l`0eB|j-sIPB)N1&f^gEGv?Ni58@fh??}eZu%T?-|BBDYc
zj))%D+*YnfqD>hT7b?s-MCDh{vwkV^*>C2sngkioEdMYK1p~mCSblo|;Ton=a`6x_
ztjxD91HvJ-mmi*}k!lE2(R=jV>=B!@HtZ2OoYwCk9K!$k6RF|h_-_lLx~nP^S|z7&
zQs&hH3<84h(^MrMJ%mU2{?>J`flKwbW;~kX<Vznp@hG8_|C@wMmGyv9x9Z>>s?GO)
z|G8vk(A4&+%oo3weil+u(dPWkfa1wqefB?@*=uiW|0U#j4j3}Dx+i5!D^*rVX4<&g
z)@9V?YBF^RwQgV&j}y<qiG})$Ne`ebpJGsqr_+p8=LF?>Qf5u_U1=&zq94;tku0qi
zl`;jSssoJ_#w7>P&Q%WHz8`NaEEHFx;}t)Y9SbqI{4RU#B?^bQLie?%+H?G+9G4gp
zwQ6R?om>P=`AytqqUr<EUx@}>6Cptuj_A+i=aV(5TIRb_y_>YuEWIpNtpB_mY~cHh
z+T?z4i^CCi6i*xb((n8ALRCTt63Tg0E$FDFiseJay0+iOOGKHBDX2;NR*N($w`39g
z*c9iU;J+Z|GYFgdRXA7FPc7h-#=>ICOQINocyJ=5>k%<@+!yrACEM#ix&zG`kMjc)
zGC5pgq}IwW@6z`$(8q&bzRFeGOJbFf@b+seop0ZK2;dJ1k!F*y16bE(F8|AS#g~Va
zu0fMt3i%BFyIQv>U+dp|8~<p#U(1Y|Ls&jq1_8ex+JY_f7k*8Q;H0X#39OUR*Vbg}
z`30x}QeY!}llYfcYu<A$`zajw-CzR@_Ss|L4*a0drtf_f@CMZLoEkl6b{1Olr@IV-
zYfAkOb;USS`^H3x+Uc$X|Kr}ryQ%xlZkd_q<)u<NtGu*(+VhWt)jYSnM<M<?Rf#hO
z0>6<yPj8*P?e!?@$nBSRyt|YB@rl+816Dwe`hW_-^c+wn{Z;-}L0bw(jtCO|C0CjH
z*SO$90^6k*NUg(439~jz61l>~O+zEU^~ZAZD(Xs*zVDt?dXDUt{dcA0snYf7C%=)W
z>xy4)A36OAcA>{u;q?|z%F*j)Gd-97?h6=qZZ0YEgRmY<hJJ_p0B(ghrTY8Rn1pcq
zv*=lKV}&o4Qt4-K3Vq{x5ST?#shu}xUNF_H1AT0|Kl3D&@2x~x(G0y2Y>5obESF0+
zGfvk*P+_q;63GZt7{@;i?SyglJX66#*898Tnx^@Z^u7AXHx^w$?=e#p8hVWsipKv1
zlNoloa`BApgZj!L;)TtQN~ySO2~3F}UxkqA!iB`+rXRoRR|-?qgceQfD}$bxKCJ_1
zMExaG(fX_6ydmWQd3FkC0N9^rN1(VfOnF_O6R5D*O<m_oSZgavSHb7gamiRU;U_Wv
zb%W0hxI&4~<J=PlUG0K<#o)&mcz$EdW5A3jcIJW?(3ll=orC@3oqPEg^Q*GL8yj6h
z9W-MX+D8q;hhy1(fx+hPg24s%Uzv`80~lC3xbP%!_nWH&a4JWbpvx7h^~~&trTLh_
zO#xAYQF87K2daNF?EdF-^P5K^TLzuxUu%AhL(|*R$O-}_)g{#<A~2u9SH@}Ok_>6+
zzkV^}OPH4#S{3x{=mEaNjv{)-(>l-2aybW{1I9&G>f6XMq8awXQo>MU-Q2IojR`z0
z{KsJ(fsU5JU`_kD{i)~IFTv02<xR=HS@6_m4-2vC_6m|e66Iu`Ak3?BjPuW)cniNU
z>yi-xKO6TX&@m6@1G58uqoz;Ws&OqsdT&P6js&`^(Y#FOhn8SII6)jd{BOeZQI)?<
zI!8R-ctjm}Unkx6#N^?y5TE^%%3t}~P&+~7V!T5-TWLizPe38%+|$H0<mDKcLf+mq
z)_zpnhJzDJSlqI*kD4XYV@OvIM6jrY-an$TD_pixB}u~&eA5S~<gF2z{N(M4!_Shx
zKQ%+9{Fpg@Jmu$0zx<S6^XHzW{C<~;yu7oVfBf>F)$93}cR$~KcKPqdV`S>y_Os)u
z|9-vCPu<`B@0r=DIsajZtyE2_f#KU>y;G`3MKX?!;aJ?=88DQcCV-U~rmbW9QIxTh
zC#!i1UY@~$!#|pfnP;ZEm=8QQj!u7l+A0pUou6+QDu_O6mxJ0iE6W)=u~u{q^l*7l
zYMF^u=3S2QU<`dOpdKFFN!O%K4_O(n)BB?j#+rhFO*<kZkir|%7i@a^7F!hu$JswE
zEY#+-DP=~cRq?M0TEYaB01C;D+izREs^mYi&5tZD0S^LXza=-#u}XPg5P8IWozAec
zlMUB`DPw9d^C<dbM-bU!)?9p;Gzyhb91&V>$(ae9mguHhXMbxvC1;8A4DXmQpV&^&
z*c-*IlX!5ZN~n8-D|&k|IgP|Khhja7gd1Yeg$M11mX3=umy{nJjpw-_`sH9X!_)HU
zr`Xbkl?61CDsk4pJZ+FTWG=-8(XRWh<zg^LY_3)ed=ZYx^c>Yn@>kMq)GDbSV!pH&
zcX*f9b`_j{NErdTMw7G1Q_;C%X23)C(-=Yr^^cg9a+8~H(BZG@+>VC)9t}5I;RHm~
zgec$nBUvOGcVp~%$#q0)=BKaR_=C{qTT~mH=AkRo6>WR?S3w>i>|gy|=@c+4gv=;*
zZV2%YHcN#*a^1HsR=X3vRmDqom!nIrfDr;5e}?MGem<9VywzT7uIbFOOfomY`Fs+}
z!y~B9EV3SpG%yLPZ?8D@En>~ZLv(G2yKz8k%@o!@d(x{N6LQDObYXBBVDsUssTmdx
z_N<$ET1i*`9aH(oH-AgK04Dm#X82tZtZH_;g7o)>*4H26y&^im0Krx=>&LX$R)>Mo
zqj!2dMq_L~_iz{6LDOGLPk+y~7i1n83pl<`{H+;gn6d2w6!J}^imu)3<s4Cs);zkf
ziFXuxtW+<&iJDCfy+Ajn@Zca@zUGnB9gv)F#6nTvI5@x?x>Rj{EcVrN;^DreZ&NzM
z*(A3Lb(w;rFx~r_R<+d-Tv#;;ez;ies`?YTt<YT4tBr*zz1xXb1VYcalrIXKea6I5
zoJ_M~ilBlublAU91w?>AD%c|a_D)7M2%BCZl_p6ssB4OQ^P+HDtI^|Ml<#uGvQoA(
zoW5=;3#xt#<%*Ygu!4zyW!{(T9=h(Laj)W8&Z_S1#3zww?_GTlUo)6Yd>Yq$@7jMk
zYsOy^pCxbHyUu~H6Zn(ZX&OKNO*m)FR6jd~THbJwy5=e5Iy~(|=jGH2n4AF;mZf#K
zp!!ZPCGk^Qg8eDlr*0}QLjPTqpE^mpJv{Z9dFp#}{qv87TK__Tv7d6^7)^w?Xdu{j
zcbuGlfeU9Mwb|A+=baqx^y|~f&@=9hq83`sZz9w2=`>VKv^UW8^6D@<=#UFp;S4M?
zvb=@Y{8l_~S4r~c@&$=^b3F>hiQO9!cg2-ljBL9>O#b(C#fR%Qo`j4yl{g%Qy*^Cr
z{Df&nXB@sX^zWpd>d$K-Kq!tdfrSNdlX=gd8^KJALr8!#uh(8R9|Ja`SLdG{UZ4C?
zJ@uh_-zk)`uDMwMERT9iC(Nt7rVOlQsb)lB0^d))lnYk>9K^Z#rcN@3;X1m~bH4Cg
zaZt+CX?MHc)(<P5WfC8hH5_!E1K~zve24sPADn7z$(z;vCaq{@V@hp>FL;;TiXS~1
zilF)c(fwVpho^z8Exbjvpo$b%+r679F=<EN<OFHN-%xwpF}hYaQvlhjJsJ^{u76d&
zQn5QLpO(Q;w^Yx?{B;Lb^WCHZaVfUDH(Aef5=vGKRv2T%STlF5n7Z^Jir!=}Lw_4O
z_zr-9kLmtCds9E<t!X<(kn45ddUpG}H+Oq)R8*iLBXwVvGP+*+T<?2(#dP@0r!CSi
z|80Mol~|m=g{*IJlUE5%V+%uC*3}XHn_-&)0M$%!2$AFZR8s<AYtO#W<|4sTr{VDX
z<dBtv+?%xmg@P~j5nDeFDWHfkP<2DcMPV@tKPd0g?I!f})I6j#U`a^*fG-!504D5r
zi==TY@&hi`UkkxmlyWB^xi$kuzti@~R$K&LF02SoOxg!aa4|~cjtH;`_(Qj}763g{
zH1Nt96-1VJ#JsF{^Vm1~xp%Kp7GK5TtuDk_xhHpoH`T|TIztaUmC+HO@#z(M#fG-z
z299JRY5qi^mq|*Xg9ZY?vK4uc2Z)D8n!AB(Pl)D?;R|3u_B2Lenv6}5=Qv~Tpn$(@
zEzty2ja*E5P}Gfb>XjRms!<=Tf}6%12Q3D5nAHnW#89p3s8({>DX@d4Hsv}3s;foP
z+e)G%4qm6pH@St>wE|y9tJsF5u**|;{Gmd@=u-b2OVpu#l7J=Z<V%2>R1(euA^i?X
zsZG!OCYnLEyx>N0f2%K&ydD>yb~#`z`|GIwSEd8>gkXlbL`dL~@U48HC6(Zk2ziKn
z%rZ}<z-UBQuIOAYf=>{a0E?K)A;S!3f(xOvnN>>Z#pvt9ROv+Oy*Xx`2SFw*`!Fox
zW_kVq4?v>`AczMSQ-T5a#QjOwB^KQ5A$-0KDa8YrVN`G*(>QEbn_{U{G_VzWi26N{
zM-VnmL39UPc3jIlgW=={JP7ivxR3}djoCr_m1PKAERDcKm?Y%=#uT}|NT_n=aU;Mi
zJmjuXc;l)QFavyXCwN5zFFs;Ylgp6Q*H)M|9t(s2bKN#CA9jfX$O1RH_>aj4)H4zb
z#tX_;3rZhmog9w7{wYzt)w-ap;<|oh%^ytTC;RQ+rI*ur(K^VyZKUgr_+3Hd!!)T&
zOUScZIb1CMxuHw;p1BYly#wbcl`fTaQ`Dd2{&}7LGo*C*4_%M<+S8Q_pBv83k0)=@
zOD|$l*6D=h-&bIw{5e}v?F0{!|HVlr)p`077YZ?^?Hs6ey@Oc@@#m?GMV{m4Z4gAK
zP8*5E$Cf2>Vo%rGH<w?(?Mbb<mG$Khi~B{ilt(r!JdAlNK*TGi;#Ky?*X}`ptLC<L
zFD_zjExzZcQR_YQeL#Zsvb64D$!Y(*4{N1@HdVg;Dc%LOhbC&>rwbJXd6So-{%{xW
z7iF1b)wyZaX3oJMuOPo}p4+`wdrIquUHFYsh163;h_YETP2T+G#2fxbdXLgk^-TV|
zY?zipeZ)k4)aUwhd^clMZl1Tlc_IAf#jKl&5^lBA@hQ(?<IxsLDh)&2KwL{QR1i@g
zUE^8J3tLiqOonCi32pX~XyLc2EMV(lXu;Rw+HvUH*jpM~wBqx(Zb%$)-=zH@@wzi%
zdKS<gBIo#lL0d(F=Ma(ZV<KT}m{C~cqejh4f>0G1wRoSuXG`mfkxHC!WA8*$6-}H&
z7QB&wB7sH2nSz%tqH<eMX#mD+5jMCeFv{drg#ip_{_z8|7vT3s14J?Y4uGGMg~}!H
zr#bT!wF?aN5uZ%lMd0C_XrxwrX66#|^pN;ymMdhrQdCDtaT+e`1~v>qf7^1J?pIdW
zav0UTG^l&}-{;mrExtHPa0nOggK4c#Z5O?q^*LC$PY}<P2fQ0=pcA0g8h(5y?M^wf
zd5a{k)asfXBk-(G?Cw^p6~9!Rrp##qm<}M>TQSh9nE%K$4pzVmpt^1&2_O!HhRb{Z
z%gIvNJ?;$pDiw|Xh%AjhCVE8Ldh&kV37(IwxNj{<4Xs|4g13|Ok$HUudH0ZH0wmlS
zLT^Jr{KdaVAB9#QDh)>8A+{^{pZJT)<zn;yAv8usJWRy#3=)vWTF58thW$lI9nK<w
z466;m?t=jN7~SpyBpoLbE$_+2JPn(c5z9tBZWnmeeu{ej;Uh^=%S|YiEI7W6^b{5S
zQEVIH?-3BnLn}b?nj`qo2ulLwa9adaP~~DK%FRVLPtu~S6`8cs{o${O6;^evrOB1j
z0uwZp;sPd#KDH1*+5Gf<H#y@tRL~`Kb1?dsRWIj@NL~x-OFE}*KD+%7Nq``#@|&z7
zw#`G+lJ;UJ%t`<`U+%rnM&-%(0#p531(5S#S(+endj1x)020lF8Gc7Xt!!xh2r@}D
zAsQZz2JF5gcZdCiBhdd2m}BC=UN&m~O}_<P2vsdNKahml75NdQ-x(v|2m(aGPC2dm
zP+XH#yue>VzZ+FDx7%Z}yWdi6M2Ra)p%szXS4yH3$qFGqwD8MCYSlZZh5jt#a^@kR
zfdv58zp1NGaFHF;YDg~%-bHR1j$~A#W1?X`LeNi_0%RhgCmQYjN+E`5#2<D7qiOt^
z5abPsSHK+H-X}ENHGX5tIC>Mm$r2!DO1vX+TI%7GBj0%@FY3PQyWN^I*~tw=FTz?0
z{49dxL$#?v$Eo4SsnMLN@usQCsi`MZCXpy;XA(LndXoP+v>>_-xocuYc#=02ESV)F
z?Ikj`Iwfq5B1OZ$0n%TAv+)ady3>fkXs?7@3NND%R9Sd60P*G;n&~vLbmqAhhuSiJ
z=BednSY1j0U;b!}1F%rKqksP3@ErQUXBxd4Q%M#=ylfQlo2p)r<>5_6i#`z%&Jt4e
z6j6A>M!A6L%gC-iNDv#=kD99Q6MBh)hV|vBEr`?9c<WjGU;Bi%vPJ$)(cc6<=a8Qp
zrJ#(X*zI)o5hIaf_h-;lE8}#IxmhQoRhH*-EAnHXWIzJa%N6{FAl4f%a_G*Jd08GW
zY0uAs0O^s)N>lKn_X|Xu)E28=VLBIX2M+7Q=u$MUQi}Eg%=~Ah&J1rW849t4nU%%m
zlHdo1?&N`?yNLR60XEntp!@B~@bgy+IaT|bbEaN&b{zYMg8BSfiIUYZ|BJ64pWw0B
z;rFTYDI!ZyHAT15B<v0by>ne9MQ>hjBU__!qvUbe7C&>m*DLVE2++Odd}*HchJ%G6
zAQha&Hy)G<$-o)3eY0p%g)A()8}nwM8p5x|TN^F#hk%>~&YG+u!vP?#MN)F|R^o{{
z`(ObR|HF0`{B7SkS{a`qzfr&!7Qc6mK;%+B`a5!#AkaPCIVb!6W%zq8^8322@JY+d
zcTZh&zxYlV4LckglzxWTzj?6I%oFoKz@H#ikUi~NB<t>c<S$Fn3U#uTOi>Ta(Y?xF
z#uEVjjx35sO}a17(Uyn1mxY&>?Qbn9zOJsfi&>Uh9*Tj<79l&Z&<w1|ejg+`QfnBH
zh$ldFwZ<y7#>Pnk1s{;_*ct$^sGzk7;Sx6468f~BpGjc=W$JGRN4vMQ{t#9}oFv>n
zKYLwa(d6?HT?maYN(EXZ=1n~3uOQ)xu!a*OkJbG*U9?=7A6}P_Vge*Ot0iPhmFHOX
zT4E!!LLB}E;=R(mPdz8<WTcbIORBRk%gNGipC(}+lkdX{5bgx9%ifpJebluUSP$Qt
z&5cYhmcW?5%nng#*I!Fyiwq^I_GFu!#cTB=baYRA4bje+oORQ`LWk17pz%Ch=E#y*
z9=Zj8MxQ~3rYPe#@`B`tz-!hnT(7vWP>V4)+=`rYEXvgdT(Nu$U>&+`YO>vnx}TPg
z{~~$Mx3FgI<R@Q+Nvy7DZNfgl>%wl&4b*Zci2uh5-IW$x0RxZ3Zu><eCd$sw$0-Y+
z{KmCO<|+90hI?B&1|@eKt;p#<(@D4;by<;^kCDOs*M?j|K~fvUw_2V(>=Wa6<1z5$
zl>6Tig*7T{Z9-EtuUkNZJ`ZRBBpw-P2`t~gZPJ8G3>XIhH>AX97)jC6{@R+)1K;a9
zj2}oB@ZA&IpDQu8Vn7%fp<95+D@26$N&ZcVxJwA!T$In?b0=5`agm`Xcf7_6zQ3{9
zfyV4q-QAIR7X*ttcjz5mzUw!lCPqw>v9tj(vlWZ+d6HP5wh0tYk`~Jyp#v>QT}K1R
zWeLV}tAEq{xMES8Jd+^Tw6?oLmn~ndL=|2sW3`v>HX;G3k1+b?L<AbjT!cwW;z-WW
zFz4{D!K1yd5n)Xxmh6A;Wu&mpwLzZ$z8~lOJjeN+&-rtg^Y<C&9}>j{<{;!e*oz0c
zpom7$9DB)vAt>)u=P|u(l_P%S?8@Bq2OB2NDo@UHX2q^p*{wO~^~^_ya;@N}b)L^x
zk5w98*jRb}eC;@kn2wP5nq8k}gsq2adDI=drt9KWSX~5>1)6N5YH;7D1>|hJo5|_i
zKO*K@^CrTB-@J@E2DtPpo&J6J{o}YIutwX<jrYB&>!&;mKrA`(;qDEtr~jLB&9YkV
zy>QD4)6@MW%kHhx*R!>j7inBS_mJ(O6Sv&%irUFNHKg4J=jkP=soE*eAw+Qp0oEfK
z00R?}vYpkQx?iYxGbH%K?Ul4mxqP?h`kOTNKf9a03x6+e_D}NcoZ(CgU~C@k!*b%(
z*rl3RmjCfH={sXqph4U`T9Kgi6s)~^Jwi$)=fS3>#K*&t3nZFkchK_&bl;*gx8|cz
ziIzT^(%z^!Tu3-(=szqDDV9OsQX~@@N_Jut#EErGYCG?S9{MPL^!mjC)R^eUk=IJh
zmHSF~L-DYh=@A;^$EdB``QljnJDt3X()AK;RxCZoc`KGBD(iN6YK!5fDFx2EDiM`L
z4AQ1(Q{<U=(NF1;p(H6=ejEDMD#o!vt^wKC3n%CP0q$AI8f-tbVRh}PDlxsA`$sU&
zaGdQiy|;2oMP8!P>r4;4U_*fyq+oy<&@N~_OBtK}#^PAZ2w+`^=U;T(6rl-j@QtBk
z<*oxG#CvkFBx$Ap7ho-jFSiC4;xW50G^8IG`?Dr?rr34k8fDDZW?|*Zv`FDPI5xyE
z)p4qU?+jgVy)2{?Yn$Z<SX>+in$z_kM)3rU%6P%>MdML>h9QKQwE|fn<XZYEFaHK<
zhVLcrKKJ)N7NVZ@dW`fT;fTG=wJYIeKC4$^*8|Vw7d2u2yPg<OP@_qa!^N{6gN>|N
zPC>prqH*hz!K_%!-?fj)i-HY&=Kxh}vG}jy6%+0o=CWk#eV0`YSI0J<mJ4a);Ie2y
zBS|Jc&&lZe4Q|`D>z^S;3NotPeXEB#-OZE{jSDG|J&h6ip~RSxFi=|W1-{+Uq7!98
zFi9gP(1D0wZkpDq7n;d){~!?iG45CgvrAeVu1dS6dQVExFiBUvOPb<%Vnd8F(8+&P
zCDm>t>+t;6sHA4$hih_%8&n$?%0Y|Jg;Wo*^`EIN@WsWnz<(M3G3vZ5#^Xo4*dNnw
zdeT2f-dwycZ&{g_j<CRUMjL^FxinG#xreG%nbOu8gFBu8L5rzXVuvj(;Hw6;@SS}`
zHBLZ{8JfzX9Qux7CtD_ECRh;doIsfZp<+!y2nYn~Rmh*L?2P@z5=GLSIZP(OmkY!9
zPW>Ec-sb&&DbnNs%lK=X!5I+VF_lx;l8g6ndIu~rfFXX$KmkajSV*7<4pqIt9*K1n
zAup-fVF$Ew<kp2?Q~;k<f?_<FJ%Uoj!VYn~oJ>3A<-h5g8>-7$#*$7H1}Kf%K(uPj
z*apneKeXHh9sJIHBFbxzmS%pt0Ii-lo?pim<A;GMa{L>BAs(QI*T!_&zwm^UHQ)V~
zNm&ceGy%_uVlHetq1dW_oVPA)QguvZV@oVHEl_F+R<FNNUh9b6kom~0Qr^I47Rn83
z^sB&>H)1Edot-kkc98cPzw-l7b)tXz-Vy>b?c(b1;Vs89%mBTPl$}5a&~%M|u~yF@
zGX}fV!tdI`F|Uoz(Nbm1O%fPPnN(D}2L~2F?2IuU5eND5Nn3Z@w()&*W@8z)PM0BV
zj1|-mZzZ&?^y-!gMRy7V&P<o%1vy_BIa!Y=2r&&6wHL2|PzuFmjI0?G+ya&o<fUWY
zY5K@9O-<lzbeUS~4)VxJO&N9LF^zp9GB@ih-{tX9$s5ePl%Wsh*a|1px)_u`Fd`1l
zgpg{Cj{5(2dfH?!!~klZol^YW*PwRQ@!#$%K+4?kof7xKuW)z5jxFXkj23;Lne(<n
z?!YkR7MDKA`~HYBxZ~`kN)LqbLKekAnN}io%m>r=3#ws)VA32H3@^-u99?9xlBz2?
zC89*kL|B7uBT6ULpcZio%Pnua3;$UBt9`;wU5{0gK}ZNRTs-}W;AJ!pME{bh5&%NE
z{=SU^k=i+AsPUnaeCPG;#-&bcV?YSOEJ(BX(rLXGpgV%^q#WYZ+5k=uXE}Ue&Hu>n
zG=#MIMixHQ{ps5%9&17LRSrIy%xScni$-)yX`DV=-lEN`#&iqql)mu;XE1E%L|rd?
zTn|2%tu9{H!MD;#LBnE$n+~e%hUFe9u?RCuuw_y@EWyA%cDp)9tBqne(Qhre!Ck$9
z8xp=J^h!^uRrN?Qx6ew$rriQ7$527>&^@DKJ@$(giZEB(#w=aBCH-3QGzT)oL7|BZ
zwPx9Fk7u@OIc``j1`z>9<gKU4qN)Rn58}n?bnv0JIFugSA5|#_3;4=}emWs1klkXz
zvQWsdw!|a2T<oOR+48jHrI`v1Mx&rlf$j06XZPwa+=)tw@LuzJ)xCP*Zpyz167=-k
zphA3WZc1d3;_26uA@TRF{fi8>IX(ZpKEC5lN>t>T({J9a-oH4Dg`N@v1Md+RA3RCf
z@C%fOA9#VWbAp3=tyhir6CT(Nka8p7=40!t7a!Yz4@B8P>>Z44AAcK?S|*2x|CFZm
z?_V_It~DR%cZSBnoWctHp<XDzW>~8^rf7_4SkZ81=-B1$+LIA7oJZ2OlRxApTB%?}
z>XxO7U2bgUnz!O=cE)+cvOtMvzoxu<XRI!6C6J5EpQ{AXFZRz|f(;3_YJvq3TJW=A
zZe(cVneo=xCTBjIwLry7eTQD~S9OJAU3TQ>xmf9Q1DSIC&uj*1_Dt=eNEvQV$eI09
zIYD22uv=r5YT}{aw+xM+WF5Zr;aC-9*A_247n-BH!jqV4Tebb8WzWv?5Kx%v^X>VU
zt6I_iJwQUcKX)r#_f$JPDa-d)^=!b6i2o86%)C)UZT}J0MagfWbZq=BNxP6k<SR0l
zvHW~wP3u2AyV2|COg=o3<=(X)elNX6hhExv^!S^F+8LR4CWjkuw3e@z=4bffaOw=(
z@5jNm<1d5ok*r@#h;H4|uCkAy27|kH3)bBr)PQ}isJYwqp9A6iB=^YrAwaVrH5v@5
zLwcd)VQDo*>)<_VQ4<b%(-8Mqxd^zG-eYfE<=F!m3VrQ1<caJLm!*A7(5>Ih@FNo`
zV}%d0@xJIxfX}2(QsyEb;4d){laK>A-}>9x{KrCw8-7%KUSBN7JmNOBsI5eDNX?5i
z0CZ*m)71Se?E;VN723n%2{qBC+k%!_B2u;8ffiT4m@4NChPcvmY81r_@N$1Mn(WaD
z+`PbMeyTy2qHwog^i3lIOs-v{4E;z8-!*4pWWXu5u(P~xI*}2L<yIzf->QIW!T@tN
z(s6bOShOru0&&JN0#INJ7}x>@R^%s-J}fjP=a^_h6#g7N+poG{XzW|u&4VAbgIk9b
zQ9E2J;^(@(`N}cb8G*vE2^=rEwpK(LvdohDSe|jo8S&TNawhf`ciNC*y9rp>I@VGT
z=%niNkyFN?dJ?cWIaqv-VLlTy_LtDTS;8Zc9_y?S$<kWcNe9BxlVN@OUx!odZp1o{
z1q$V9!vGrtu)Qn{uf(lHwXJmKwj855<uKj|2`QblWy0;AoKPuHvn%?_AWHQWdE1p%
zGIR|4OLOchycw^r+Fk9jtDLgC##ykd`f7K5&yEGRua>f}QM12h%Wc?6rG*ZZV7VJM
zElP&!4i-snY{CqH>;s{#g<O>pnik~Tkk@H%Gd6KY*S;^wG`Lf;&lVb*gpF*WKge<D
zT#zUrzz<neURtE<v@`Th;`Lg1E_Y=oV=|g1U_#otJAXto`*MH}jKRpXp#|c-oLgpJ
zA5oO90x&U}ZJw7B@Am7d=?K$QgWFjc8;7<U%2r0Qfn_cmv9WoeKrvpoPOUNWK9Qe{
z|4;?Uxv70T1^~@^o#%)O^_T}eNYm*<dtvHWT489#zjdS?hR3ByBpYkzpv@Dzp4P^q
zh3sS}PQV;GvkjbS-JH(0x=`@mC&uPp#+KT%g-T`Eo>NQ@5`f)I_Q)<E7o^%2%FIfp
zM$3~TxIdCja#3k3iy-Cbn{oxb+&`gUH}>yhWmQUs%~9Jbdm#$RkV!5`*;FD4Gqqcv
zQV!rZvV(rb4QIY$0+wpoS#)NMXKz`^%#iNLuq2MtV6R~Y9yYfA&r&?of>@Aq&Jgdu
zzFDDbUSysYDTXb<#Upw~^L3HwAE8w_hV(yi?@V?ap8Dv!2+#t$E=%aJ;J(ERRfaub
zj^zg%4HXt~hf%JDhKc%bDp8afB<G_53Y|<Wiv^K24aBIS5Xlm>I=c<|`rr&NCxz0Z
z?=_}!J{_iXLgH}FR17pM`3hy{d8(aF@X3?bFJ|HbXpfGHM{FLB=p%fTrACcqBx5>=
zFBqzGqqnot@ttg2fH;DZs3{OXg^}KExZ&J}-A#~)fT>biK;L=E0dqX)nn@oDy_@aK
zByqopgnDbH`z_LYd4c~G=A!RnWMQtGFGI8-L$@@79%TpL$xewr<^1!u87m(zVLBl`
z<mH^_v_AIImOIWl@2nxXga6=Wt}Vep`uTLRs)78=7(s2aG@qM#Y9~}&St6DfnA+nJ
z<Khlbb}QhmOO2-YO7Pk`BmNjOLi<jpqv$IbD05nR_@G|#A2ct;z0VvReC4_Yr$y$7
zfe<l4_>9M3K|*gpOG!}j4X%EOFPv<KEp>x2&1NioKsnZn0*)k23PIaLj{9IK9~ahw
z?&6PVa4rm`Js!*OTb!V_(3@Rgt~=QmZJ%A5hZ5Lc%^hA>c$(e}NhVS8$^(4Lu!e+|
z{QM>d?HZZ}9+~*(Ccvf_SElLM*D9f}r^nLYG=Mr}%Vy!^<T(d)HP1)b>5_G)m}!U&
z;W<D+*dKwJY(tyyjEkMKPaeH_Y|cHxIIMv!#m1&RHo$(QjR-YS6O-g1g(YQRa+m)x
zN}s#{9N_=V;|B*+v8DZT^|%EyqMbs8$myaMknKUcW-UE8=urv>_KG@3O9pay(tZ1-
z>PZp`UrKx`!WH}PiC)}wV$m{G){hsmUy&!EH{i0V3Ge$<8npO|(p=Pi81@v+>p@XN
z?mYRr<@qrT+fpnzm~k^z$&_O7dRCgDm+&^#!<PzlLFn&Ai|SL>X<GOOSbJ$vTNzSd
zo?qa`y=~|%jC^E8#?{l=n4+9}yHGvGydU8Nm0WOXtg*MU(07MlB!t(c+eN|uQAboq
zy>dQ{ot|nCAQZ1<foXaf!@WSsXa)dG+7n{2+QhDr?fTu`{w#NA#3?4+!nSjErUJiS
z6@5+Ghde}qrFAFVAy?d)uPMyf%^+eApn#wi>C6BQ2I{<6hetJ~+NxI<zSgy+*_>}q
zWk4-#gUm_C%=V##QV{Xoas>zo#Uc|J8T<1YU0md;KTt=&>kqYf7u~{BLe*Qpdu-z_
zhe}H%+iX*-R?`i4rFe$MGm5%Ie0UuNbY2!3(BYRdE(9&NU$_$2ZZlLMK_RTRncTXr
z{jnSmO5(bb*x;gxcFxd!Qn=VkVOz^e%N{LvzcA#5ch;tm+T6WKJ)ewdAhI&8EGpE7
zs2pTe^MpwNuPwVy$-xk4G5c#74g!4()om-7(3n!?@l74`O<f_mfZ|1}RYaQg^LJV<
z+;+8#&LEo67&n+FEW?&&x!xZ59Aw04p%EC|MNeTB^`CO`%&ol#p!;Dp`yIZ?<26p<
z=f8HbPKDpp(4!?E3{=7!o5OGShBrM8zw<7<c_aL8-nd*TuQH7LXrE;s$@oGnw-GEL
zpTS-Dj;anjQoqalfDY~~{c`tZmU|~XqEEl~*O!E|y!b_`pMmm62K1b!PZs-?LpV6B
zT-H`A{aQUNGE*#XJEL<qbAp~W`Sfd#9v|Y0AB$_S6aavqk9yIE?CG#H$D8tcut4T$
zCWEIBmc|QLzs~xW+7i{*_wAVi-*IPpurp-Ym#(p$aV9ylbc=4)2{JSg*A<k_#4I>8
zf&(#Ws#tCZ*ea0Fk<Cb3;V`&$Z4u)?c{hJSw-o++ua|{9R-Ib@rHoLJ?A)OL<B)b>
zRC!Nbod7V;7S6?{b+f6eo&20%yZ{G!Ae#Qv;Hx<b?!zjVFJ4OpCZoY5_i*!rhE2ad
zdIStYKBDBnN;ho*S;FX1EXbdnh`{JBduEg%@2K;P&=E{H9ea91uL`igXEm38P`vBS
zO2_bR2_D`O;yB?HV}xvCs0~7ge#c;uWJ^{${m`_Bhp(g<Ov-Pw+QZ_=n8aD<iE?a1
z3L#_QsE`qi?%#Pe0Rz!R((i12rR=1WxXAT_5c}LKvHhCCE|90km`A(=ag|Hi1e@;9
z>1P_)>SR<fXCedA{GEND|11KqF{`va{sSHe|E>(-QG{LoENLzVv$!6q{*3qaWbW;W
zm~u8qWirFP6Eyw&Z6Zx9SOn(mQ4p7qek!3fXzKaJc*vrX;=w~xHBC^zlvMip45A?s
z<*(uZaI31-v{gok-Ib`0^~D-`DqA(;_s>W_R_OI#Q%2VlvH}(z5OIet)GZEgaHX%Q
zM;$3wHM%5pi%c88a_wS6`gj(P_-oLDXU5%enedH=BoRg;wt;*1F3&i0eg~8~mq9E=
zkGH&LjYFfDv^_*7>Whlz@oI?ZOR7FLG~`|PPJ%OeHRl{X_kBiC$!fCFX7C)e&ivy2
zgaI>7v|=cEs|<tCoKq*`c$QnDp$I_giAD;aRw_#z&oY2dp(qWHQ^#lyFU^*OgqL<e
z$I0osH?K{oWYVV(Q5qVeeu}1gB=ulmt%`pWzwO#^U!tH4D@0)0o&1f3iFF1=G0v;n
ztdBDxSi?ogh~~2sMmJer&&&*phza%1;a5)H7md{`KXX6(;+4YXM^rBsGMu%Q)k!V-
z?07yPuKsn#@J+>Vm*mVe_!AEFsTk_nxuia4|MgI}u2)%iv%w$dz=|g$O8^@mk~XFA
zEEt@=GG~OlO<VD}V(g<1f@3c3Lh-^1XJM|&1tv{Opzjo@*ek}HIxPybKHO%X#$kV;
zja@#=ck#4+o=b}8VrEJ$2@4B@)~~-UBSif7$X^*N^qtr<WSKU2yYwIY6nX5GD$tJy
z>QF1c@+JG}2pRJnr5OBhmgwOCT_qkekvhp202ddW?oF+ic=_kSv(tm;L5f{cu!1_f
zViixl<a!tP-c*JqNI)e{X}ZQbAAhVdPWgGgc_z@g_6$P=oVg4Hl3r9lO+E!8h^!ud
z@7BOIxAz@-2M3(t+UwwQ*to87KZJX4`@vnOm%W#zy?C(YERk3)w*Nm>#VB2>|IDAi
z`pruVU1(Js@2_`b$fE^{`fy=GZKJf*<F!tAl8$_N*{lw-6<U;O0-%NpoXc-FMKlZq
zB)?5&6n$t+{X>$LI(d|!Q_=y`Sc9_`di@0SMR7Ye@;xT7znH=LOUXliclxj^u{k8o
z+0(24YQ-|yorQn4kJO#@so7`z_u-lQ^_U&Qx?{)xs@YUg`L*X*G^8(>ECmij&yo1E
zej|<MrbH@mZd`zkG5CoN-WWU_vmCjP63#z&Ki5L+v>0U3&WkfugbYLVLSEa?H5lZH
z-ukBP<@F6ybV?jN9O`L#%>Lv`?mqTbodvzF<T%DS_VtZ2KdPOu)XovA&snaa8>fAs
z5)YhY5mCjXh9kqT9No@(e_-o{w}?2IJ`;&!TGTQF-<!>m&<f#CIhZx3*6I5AVQrI-
zwa29LiseoNmq8MOH_>+Xw{Dd0*D4eJigj~pZnw=h-sbm8Sf!pmAX??}R!;C(QUwdF
zrOD(i6yUu`85L`z4?*xFy`SABnL+42Tz&IPYw4gL!Rq&gUf0ZIKcPxCcYY{5-TZJ(
zPd+ndob{%;`@aFnyFK4`I~;Z1)O8^0er&(F`<Mfg(kxFB&&ZPo$yT-u@arsSTGy>_
z+gBi5y<3OH0xMfbB+oCjj>^!a+QwvyyxYbVYb)C(RPQacO&%VUx;Lf69WR#Fqs_yR
zjbnSCY&v~sS0~p*NcumOIS*R<jNRi~BzXrjog8Jq@_1oA4oBFv-8tmSxXP=}FzNf<
zPc0z@X4mq>;MvGr3-zbOD4miyJnygXv~&MWM7*_}daM8NidvE5BIW$^=L-B2L3T=y
z>jJ$E$Wd~$FFgN76<Bv#Z7fEieJ&?{y#BcHqQx*qY?S)#Ptlx+`(K*11%X>c-;H%#
zPPc8PU*oHr=*+uI<qv|z0G!IVfknb^uncf38_cv*kB^g!QY+9sIgB6o_>imJX)wcH
zalyFc=nc-D=!m+Ok?Z3&eRTFAEAk-Ewo17I>G?O%#$oQRz2E5Oz(MK)|83eB#9iom
z;E|5KX3LKQ`Vgt?0rR@&5F!IBl(8VI6?4?OP{KUlc#1Q2*6Ow-V@Gu0?OUGoOAd}3
zAlH78tf%oB;1dCxzaC3!tVg_o<$cOIBc<abEAyL46`m0!dz6QnzzzAc=l%Izz%<DP
z*t-`Ju>zrcvcTD;_pb_}M!&xy&j-K{%{31e{Cs^p#Rq%{@n+|S2&hrW!r`i!%SC3O
z<%km^ZSkE#=+%vXgQACrJQrXAym<_$ZVfj-Z`jQTI{v}wG)I<z<R4pW1ccriE323o
z_mJ>oNW99``EX7xJZwr9_a@w1t>#Qlie??`EbQRJ<8SoL?Sxq7Lsrzw(B6qwL40kU
zpWK=lkb5#Xbu?K<;^-$w4W4?~yB!<jnZBbux1#Jh`_Ut!=<j{7EA0GJ{<ER&OE4Nq
z{_LAE0rmaXJiEr0RR1?Vmd&0eciJ`6Ew1|WUjK9)>OU$tvSkT$S=*QNfP`|fgZmy8
z4}(@{ILTY)a%24pVN$BV`v_b0?dd#f-qvN-ptmL5p4nWoRd;4Zrt;Jk$HaY|`o>#V
z_4l}tX<xs^T>!(MVrkj^vs|XaQ=hPft<Rk|kHtUCOh5Yf^@tVU?Lvb=Nt39eK9rH%
zMeVmL5eSfsoBH$eF6ECV^A8?kcn7im<@{=cS0wcpZ6rM^ythMJ^Yeer+~Dx9TF^he
z>}eFPAV)Ds(>o5$_+N)DJ<#AgjW1p`L`CHt<G}UywDOI?0apsDNkEns;&?LUoD5%|
z7l<`W*Zg^{T-fWsWkZWspT8H}eS7nXLUzf#g5CqiB~L(2(9C6~EgP)tWCxqc8&%)J
zc)|%sVa53-sGwT#CnevvyKfHH$K1dP$YMIKngy@^?CO#}>@v?Bww`k(cDAU&c_U_x
z!UqxkJJ2IADr3TEMY=AOab!<0XF(XMyBQf2aU`tlS1G$M@8hi|VaIn+S*spC^oB(*
z2}-Xo#(J^14}rNdRN?7&^}&bz^&i~c6Bw>T`D$gK{<<tSXfUE(rIi~I`9bo7!Kl$Y
zt^7-0Kge(!j+r0QF365tk(D(ZxA$$+;qd=uY0mlE8T6i%Yj5GPu?;9i#-wRo1_`R1
z7N7JA(PsJ`U;wN?Q(+rbRG=lD)TgNZy)Tmk_ZNt$OjCYrn=Okd5cU7jA<b!Mw)pim
z-;`4^MLdh3NNwkP^o2{_)0#Eyone}kor(;yb+LOnSnTn`5_M_aj=Fsh`N9-D%RwEv
zB_a@XTuJujB%?!b#@v~w^|fR+`#|+ASfekVm<f;^I$B?s6L-T35oYU9bI2TG8~FwI
zc{`)6;@fALqGIeQd%Ap7b__`H#M`0s=WMId5kq6o9dMR*?WFXo98uY?`x)I!DN!<q
zw^0TCJhWdz8;r#h%`HMxxXTnyZUp!P>P+MRU&P<hBX+VG0nrxXrJA@wRCNv!yeP46
zpyxVu)qd6GuYN0QcmgRXSR|?c@%Oter5Am9sR@C${PtiXyZ>|s8;2Pr*Z|8~@M<XS
z34pRb&KLCw=#;}uvYwk-TQaqaE#%{N8N*Fm$P21g{F5y2!&TMafrNjA)5(mv@w2}w
z{xdk`);VviFoaci3{h)I=-Qq!XG#hN#aCl(jYwO3vJgPHxWYxJZY%#{s0Yrq-|8rS
zuqP|Ca;5Q8nkJnqKQ&r<!)8^YjvK}IC=UvRk0l)+5j<-!R3mym%tk#xhQI9GQtg+P
zgCuWsO#+8(0L)g`Pg)cpMRLvM$%sC&oT8gqCq8_++iGq4Rc=@IKLON*9BZdHa6pq0
ztXo@tqEEjfL#-FD-<04WQ$BQt>TGTS4zmvWzY9~G)b{A!nBRvTwx3LakCVaIL1QMx
z?-OKmjJVWbDKF>xlEnS$$4gT%K}IegI|cbk@G&*E`0FwMq?Pw-+_fJM=|{c}&hsoX
zc_4C@){1i@fe#@jf<z5VdIH$`k4a%J7&v4A_S+d;<N-opuG0T34033K5;%RS(t)6N
z5tiKRH%JBk8RjkAj9VTc(Ne2FwB~5bLbU=5Ind?Jg>zH%NnXDTw&336>JdwsxjPWf
zPftJLMl7%n`xqyaNN{r}my;M)o+fFDJir;0C3KfoO0-Ly74(aA6zUq`jN=N1M<QqG
z7<HK1B2_ZfQg&s~UQXzs>`WMC{^_-yDH|l{&7~GppxZv=U<t-zMvwlWG=HUNMZX*n
zrbrx6cuGS$4Mg$H@q<x?-b%oxNlm^W<!uyI&foS~*a4$v*^@rT@F>k>*%~|Ad3BC0
z8}c6bPnCAV`|3H$m~n$E{^7<;p>ZUw{kd{*A0E4yz+SXyv5-v=1Xd_IXs}7NG|<`q
zLTao^4#`y`V3}iX*uq<*>!=Xw1KYR2HqmujGFNZO_7Y#b#hEKCOmGfuN|Sc%v0#Vv
zC5m)1*NFx${7S!#Q;>b*ihWy<L)VJKK#=3aisMYsvH6u_%Rx?`SDdzkj_<A<2L(GH
zjK(e_D28bwv;Dn8i&BO>k_2<ZB*&yX*0OSgkB@+*7AC|(`|td4b_qp~3Vs}wIyS?+
zG1J2fu!(nmS{js_(|__{ylF=;1DKyY>Qa6uC5CX8+<G}wk7|hV3hjkSnr5-3EPLp(
zoYlqj;4$WtSi_;$uxI0jLn_`c{D!!)PmU=(LbxJ$Tm`R;00c}6KT(NxqQ*K0C2iRQ
z;$9+p6<4{BJP)8wDZuj<<+$~W(-gdkIc%D|HxYjj^ks8#9F?t*<I^Ht@+am>NN3^L
zA?~YEw4!Qj30+W!ZkqfLOQ{CpapwV-rh>@Jj&2u9WBQ2rIWLPA67Ustz+1hwa`<+#
z{sarZa$!ov5~5o?IJQ+pg_(OrQ-o&)PaYa}rz-mPB1=~+eCFgI35pUM#=?5W?%1W_
zU=}k!sBZg$8cG&gKR{}si`qDIbvX;ImO-D1<M)qD;nZjr_i>p&hw&}m>U|)5d3jVH
zF*<t4XwSm^Y?<$k6Mm15=Zc1o#K}nXadY9)H1`HgFerfR;gz!z_QN^-YnJfTtE@UJ
z&2rSi#O~U^w_>8iRKxlWEQV8}aK<Qo?8uNdypkhqFsKQ$*3=yoonk~t&&f;AVFf;o
z#32MD2UC8qm5S3W4uR!DecX4gq=Kens_X<iNk9v?>d=58YUuLo5wAT9Lk#x^FmR3X
z!br;EFw7(2U+8dxPh8tg7m~Ra*uuDyWM87P68Xx3GF?^b*fdn&$tHSv4~n8FI4NcB
zYPyuAwE|;JWQe<j$#s(1|D^waSUUHArvLYkziczZu+3@Cn^VrGoO9UBVT2|Uk~2A$
zQ&N$!nK{oPBx(*xMU7OFG-oQk5jmuCjt+9FDB0KNcKiMVub-aR^Yy$Q*Y&tRC}IFx
z{dJ!noENC)GxD>!<O7!Qv$=EPgpHx&jbddFwGzLBMY+N-8<mA8YquNIa<0L;%=ajV
z%j`uJDGnri0G&m!s&_~PDM8tC+dXPQf*RWpSz>A;i%<*&P9%ceRVK_@@BzbCKs}L@
ze+k)rz}l1PM*ZSG%bv4tRq=xh_qBZ;7|Rt|@ikZ~7J-A!Sp#PJ6y;i*CqH|G_X#1R
zZxw58Fy3_aKNKY*-gD#q3Is4(Kget#=xK~ImC7OuBD!$g3ioLz>gBKN-3rt5h{AuD
zxzW%cO2vJr%nJx3_fj!%d(C3&zL50lWeUFoletfju@;gowmw8A0gh<|>G$1*czd?h
z=8Dz0=g9<voIi}&@JOmbC^Bm_-x|=+Rb8G)gS(B1m_^UAZQfRpzOcl;R{ptWsnK=f
z+HFhf`#(tP2U$%(<*p@+5YUopFnS1X_<D_`8Bw9$`dD3HPE6TF>t*6N$C7*%e=!fY
zL}{spO7Gm0kmxCUeeVyEaE!%u?$$vH2SKa=3?y}W$y3EtsF|i(y?)M8k8Km!RrFMm
z_qJMtdT)PJYdqco*H)2$TD*L;I)F*b>*=2I3<-jRv2YL|oK|N>2*S7^hpmEI)5T`(
zEVi%hF9jx;k#ZqcjW$r9(}js@j-s=^l4BwUwVnT(8eP}37CZ?sLWJ9t>x2&x8qxSS
z9DdF}4Fbi*z<d{G?A|hMg~Cn~UJFVu4#fV1m~E4^a>5QypM7MeVEAdXGN#|3<J|z(
zdXLb)+Z$Cj8*9+5{q(=gcj11$YVbHmDHdH}#$UbIsbevU6VBq|wpg~rC`*MBrb5Sh
z!pro63M~C7()w0j>-M4^c0ti#OxdY$i|=cEIaCX(C3z;y+h%1K+}1HG(<P?ZRDw={
z3m91+pb$^C^@&?T&|`Snz1t1-T(V@YEF?r?GWGlokH5d1(b_gU0kN9zH#HYxwZ3j@
zZN+N;-P8uh>F{sq2*>G4ZRsk+>8Z#4AaY4grgGtX#9Hw(xWf@dv}<dsg5OFX@vuQ0
zZ)q;pwFj?&>k^CPGP&^nf>vA^&gKxzOD2jS4W}L0yp0<KxbP>#8J*Vz()fP%CS8J?
z^P?>+VF!_R$$Gs>yI@6(Rdpp};(lByfV(3h&UpgG9sF4`r5!gzMqc=oGQ`qPTdefK
zYi%v*`0DB7JzdOYyglZ@Vp_cQ7E#nA&=`@n%7Q7b52;ZJDlMJ5b%DKWI_a~kA$4DD
z66^ZcTaJMZ@UZig;#39e_s6ZRyn47KYtxm+9Iw69FKunSMZ=4&9^cywkoKwrxmd>v
z_Qn=Edj96eZd1j)Q=jWTAf7iU4NYxVBP1X|*@`a>xNv{Dai;{;@$I**MP@pcDs(iv
zv=k}2iy%#0R}LDa6-`>ev_$ou>4p7zU=pi<KA??u>y3dF6=@2%>6cC=*jt9Lp8k4K
z`A|2=TPdD;f-U`W5YPWLVeI203XZ_B7Xiy4J{*b6#K&-j4#aJudR|!d*dmlQ!#-%^
zw!|8+nj_al&HQV)RMStqj(Ll!-tX0JjUn_9))PNOy7}thqigi7r3>+&4XJvV9$Rnx
z;nqqq>wLf7_;W^dnb+N+D-mxO-H?-+mfKw+Pc%c^3+K6UrtMbh_3s*yJExcjw=Z}k
zd2SPHuVdz1X*$_u?V7qZ>f4I<Y@}$Z+%PoLz(-nr&V{}68BmM&`CK5FP0ITXmDPfi
zj(D9&veHjc&r+?2;K^4{J=M^(0V8*AxwdN7C?8vUDl92&jczB5d*Tnm!88rJWlc5Q
zVQxSu_!5Neno;U+^4eDVA_udX;I8karD*G~xyDO7aaz3F%XW2#o1LO7mu)8J`&@yM
zVlU5*6qD$`+(yFq5=4i!ToGR_(GkBZZ(6o=oe<5i{Kf?kr;k*8codMXx6^H2o60-h
z_wCA(%iC-}v{&`-v+g_4JQ(HNdeKuW{|0`jx^<r^3m-5!Xt{`oeg5R{csz~E^j>|Z
zd9k$$gp%COn^64Gz@t;Nx$VWMQo??>T+kcLHdWCZuU6$$%KvHNL@rTE?6fJ|b&2vY
zKhia_=P;Vj&^qm?g!RCUW0@va2b5IViUJW9rQ`T%*;0>1<`358K|O2RQy}ueJF=FS
z2ByuN+%qn+qbWm<a8zo!Wxa_GJKZYlet^Cdp2a^(GmtZYXc<S{c~9zc13mES+}r1V
z;Fh+ZOEZX0J#9RH9{`!7?Tp1mvPI^Qf06(X$sZbRY{I}$BS94QQgGxHlEGyT`}CS~
zwOF#hrcKldW3>(RTNW=oxMh9YfoQ*HwO-F<j#%?M?fCXH!36j3=HcEYA|9hbc`Ni-
z;u?m}XK5%m%J+aXY<iZ6d|v&HV(Hy|Lbav%Nxz^)<7d-9mDTB9tq7AxsUKo!XCQ3j
z=rAuT*xeiNWbVWAbu^4JYYpj*8Y4*?n?Lm&e`?iZ_ov&?J^lPQoBX&&*uQ_JN!lui
z0_-p)Gq!|-g`{C&X+O>-y;!5@?p;~u0ZF~S83&L>nE@91eU~BRq~Q!HVd4UWt+LH^
zR<ggh`dAy-vGF_Q2l&N$4eeD4;Sd$SB@DvX2QW#W40hyoeF$PhU~F*;Mmk4iFSP>%
zX*WL(Z0phv>Xiz~1{l?d0P9R)Rri)eWT0)Xlu5$&4l;;XpkQC3KZPuMLEW1ExApr!
zx2_m9aI53agAaq*F{qAO38qJv@p|ODZE+#zuG5y_mcz@<j${|L<Tph$S1ce8w4PnM
zD;znQy^tf;tL7e{m%gzw)k9FMdUwyFQnh9E?UH3ejJaw>=`khKR?lZ3++}o3KyNlj
z!YE<S7-&r7I>4$v$#=g>eXl{-dvZ=@K_6ww<GQju{dp){7TVgZ;Y&`Mo;SX0R!(P?
z|84*2$t@{Qrom;b3~$6ph0SIQMLn~dift!B#6h9%CZ8;WBRJn5?@65YR;?NE=VS;J
z`KNb}%U$5eUP;>B63;Lh;~mB7q4=MidwoJ3I5ZCuGV2&tt2X?CSy0a$X4d3pw{PZm
z{06pPwrVa8fEmVKZ!^^m5xUXUfNBGxSLB3uL9f{9BxE0YA&zJ)5!H_Dmp(sJ&@Y>;
z__{|pMY?c6KGzI2sOTH?0IO7)gnFrRtD^8_gK`7vmByo)!dF_)_fW5OdZjr<ul0t^
zgopIUy^DqnKO_miF<z=DdSm*%UHCt<JB}1VP37`v9r<T%5Ao&#=57udda1XYFSo`}
zOs!c>A)^kB66v}+_j%a}$?N)=wx*d1f+NSBGz;nOidl!?-R{>`ZZgG+6sjBn(M<*T
zQu`y8Yw|x)JNcEVGZnbd@6M=h;%;P_FO|3Mz)5yg4LC;K5*a(T(4H_Rnfgy`Msy)j
zwU|0U8Wd}F-#8<ie&0Lic8b0|Y`745_2C5YQK0nGl~2#QZYGu3t1zgh_5;N!%GnXd
zeTgqW&r&D(+5b;<9sRp558U-ol!$0|fr{HrRv44d{yTkbsjni2vx+tu<;C34MtS|d
zNmyacfAoxa+4J%N9it%Az83~PnMq%{RZm^B_i_|o`0`-sZlj=jeqzTx`)O)PuNH7t
zI#sfv_SfpYHsyQkb<F|s{<ojm>IV>RB}8JC&}Um!1DuXOeg5kUn_K+O)l$@`6ZUu+
zA6xE`^!>1p807ucQfe1HS2EX8kS*5z%Vw)<__A!p_NaQe_1EN}zx{<jrx^<jr!M=@
zn<wWCCg0A3(8f3ahe?GuTfG_(xScY0$KOCIM9=MQWr_u0v>Y>7?7R8JR37lLr%UyP
z3b5bti>BSyxEZt{r6BL~%U;T^h5Mg-*7@`sS2~M!BSq(;n>Y=Zv-jq9bjF(B{k^|l
zk<3t#UV!m{o~L%?oxq|N2b_az{SO<Q&puas_Y<`7onT6P4OXy|7Tk(MQq4XmY*rJ0
zx6f&D1qYERM4F}BaV>+)v*ED$S;3R<#3GU$&{wDOtw))r)EU75ktrKsB{ics=BUC@
zwohbBld`g|W0u+2{F8Qkw^L{;EMs{32&y{Uci4e1vCI>A{P|%DoPwax6|iFr1m2A%
zL&jJk*Q0Zsf@{$W>(rrIKiE|q#pxv92Qi6VO^5i5keue6?}m@^lR`DI!;@Vt%)|Is
zXa%jZ*y(MMj#-X0*z|j=<Aq=Bx)-OL3YyGBHEtB0D!n{rh3zL*S_RZd^wndJ*#5QC
zt_#VES?ra2&!pNa+H|+KQ$&KYB_9NNI=QBDA<Gz4tSz`e2Q3fe!l+<%#R`3mE<yiw
zy4cEr8G=2>7n63&U^VPE833@m5N>XO3(!yjWPqz6GcW+-0AQF%qLQGDCRkX_dw^Bd
zoq<qrfa4$lITL+2d}g4jhMgr#$da~it{p5=alPw3*nI0~USwqY-_rbLV>9qcgPwOQ
z!GO*L2n`}Z$i>-8nesmeTkf!{?W(lSJ3P8Oe$V4!_=hjTr7u#zoZVL^?U)Z~`{BDe
z54Fk4*`k`t+&JpJ54q8rqvMyKJoxm24CWV$%<?{D46Nw?eez!k+v!!IP2TIMPcIxJ
zxD)j5x;c#2PzZ4)d<F-1Xuaz_A19Y{y@tM}$;C%lXeVQfB}l7=&JVZz7|&0++4>LG
z7Y2&dee<4#0@W8oza*`BGqL4uW%D0Dhxv_VTR$@9NG^Z(P_7ov)pD>Mx~}J)SN3;r
zKYsh%?#|ZNPd~)TC9%G9zh-;@CRe`YTw=+TWjTCtI?lg#Yn(bXGl2k}(Qh%*_cFI<
z<9f!&=je(hq1E;P&eb*Hxs6Sa;qIcao$KM{w}ZIj+<xgs2BHsNnfm=yL`v;Lh6T0i
z_PPX&_->$&=lx1uUMzNVHwo5#X5!k5>$xL}J0!pSSSsW`Hu&Y)7chve1((NRq#|hQ
zcxjCLylB8R>34TN-$<e<!>_-?Ec&^m&1~f#b_qMgI8<3BPS)f428Kz57wb9$UmeG2
zxZORy!0Kd&;*|^A>EU1Q)CbtSI+?1c*z34a%jrBBa(35n_{cM-dVdQi3kW+vID7#{
zyyLSXl^890?_2Zh!eV<Tu2BCfg`89rE>C-CN9hc&XJ?4T0+rxwJVz6*d*F`K%L_Je
z0oy+0EeIKVG}Co3sN4}Owl(AAY;i~NU0e_{JB3nFJ_o-jOzwLA-M}T9s`BtyLCx$@
z%<1Rcr9b+lZ%^|FCaXMRh-~d0ejUf`XgPfW9(+N_x%SqfU?95XmOw}CW0lx`v)|r_
zjC=*G=)+bMx`!kJdSi8650{&5zYT+l5S_jO0V1;f5G5Dg1@dO^qYRN<$BsVD?^{!$
zrD$iu2HCFvY}sOkr_(pR5XW<(ab9|L!ZI9ToYRkQ;3&DEqG``*`k_2IBY~<oB$CBF
zJCI?~<bUnH@2#nF)l%nHCnaHQTCQc=<3NWSFXuCx<{O^8x!F#ZxN0k(Ky4}zi=RXi
zrPC6;?|x<TXz#7}h@acr7&!D`Z}YX$kG-v7JMDklV<*r3`#E{$!M|TK7k>QvJ)5Du
zzq43+Zhv>>_RSw+XUCe9{B(J2?GE+B1CL@9>_>=-e~(ma`hAP@C4hE1a?pav7cBSo
zWdl8+HB~Tj(i70D%C@z3N=Cb7N`>m?@nS=TlDPochL~KGSD;A!k<3Gm9$gWPbz8nL
z=<-?}cUUVcT~UN)J&GxjU7OdI`o{F&SQs-fmvp2tJ#?Re^{n`BP$`f-gx_<Z*_H^F
zed?8=dda9QWrlzb8epQ29_R0a_vmdMNJ3ed+G!Ci_NUdL4w@irx(q(byKCb#-~tb%
zE{JmNq{)0I3T7tZB_~->C;f?1y~j3~P`5xp+OwY+P^%JS%;T|#7bq!6%X{WO@d321
z>zt|t)KttGtl*2zxBBO>wg=R@kXeQZyx@O3e45_^kUBUJYHZU^?MzWu-asdkfuMO%
zH;#UQ_wen__f4Qcv<EnFS;5W{M&Bwgg;lTpuwh9vZa4ol6jSlI=YXhO4^5yiNkn<P
zRO>*&{l^~O$V3p8a&$R#bw(#@Ytjjw4QoiK$Cki`h{a><vXFI@+xHzFS)LQG8JI3T
zsvlhnEu5JS)01mL*qi+79C)VDQYGNOVj*pcR2>MBn_w^xkSzHb3^jCt9@VNAAyA&9
zS%pg{MyrixJgCT2??DpH_U4R+dO$+=6d;=O3NSB7fY4AhRHng?|LkxVAJ@9I#y1kx
z8cmVvj_!5?qG3(a0q4Pk-6x}~89GS^v52Z&@(Bg-z{NDNXomsg{f+K)L>02H6>3!C
zlAWg<#7|$M>8Wk>6~aXUn}7W-;)PQ~wu=a^^?uVXhDPe^I9b6{0}ahv`IL7CG68sN
z(iwgvz=`%}>CFe{eZ;z?61g5X?Yz<5>}(BK43y#$01PoFgzX{h%BE=ObqGl4%;?d_
zR$M0(Xn28g+(Bb|z_tJnmN5hwQdetvyP>gp&bo`@=N~#c@mL+C=zN!ZxpLz8*`q}q
zCF+Z(l>>)0z+J|LRv7xM48Z}+>wZ5Mo1#-38G3XsU4+Zyxz1{DiKzp?QUF?_1xn5u
z+I{&&!t4*cIg+J_2nSSvGZF~o^q2f6qqY)dU$H*-R)=(`sc`?q30HD@o<9sM!}0UB
zYTF%>mkgI_1JZR`ntU{wC(BwrHY~*o3i-2@y2bi*Y}tM);rc;0B&RcsBxAIUjk`IL
zs6Te5z#JkxC%9bnK1;;8BtNtwLcKOiMK&AozJm^w>y3J)x5(DQOE1V7pFb0d#Byu4
z1R9w>Td{<>lmpV$VlVw(>jt=Fdo1EHax#k+unW%R`U`v@lkH2~dZUGWwMhLz8-guf
zxB@yVr(-jCgR}g(V5sT8lq*C`D5yJ~TAlaoj=d`~=~Gf@cN_m5NML;VXFd){V?u>V
zQ$PMT>|wVYR;(cEY+W}nfM+;zvj^i7nLv(}bt_C$%B$P`Nu7JR@5Te%w`s!Zt4hH8
z_5LH5jO>(zf>`NJFzF6GA%B<(R&UQvc9gwwjR{uzB#3MMq+U`GSc~%I`2VzOU_wpN
zUBVw%=0aY~@_N9*kN24wY@R|-hxqGVP0T?9wj{cG_AdG=_x)npsTttl-QZhqFIRgI
zDaBEcbPBL>3aJ(OCMh4xwF7oy<%ai-Rl`o!x6tpC^t5|T<sJ&+E=OrHxF(QNd7|_q
z3rB^;N)=aj(WV4Idnaf8lH9q6sxBT?J~Z#DoL!y6gn3Nm&Hvor+caA>|3i@iF-tR8
z+brFE{5-Ii20Mj#B?d6NiyA$`z`K)XcV{If-yeYMU^`ZcIVaO+@fu}BqF!MGLisQi
zcC~Df+R&K}5L4qhn9}Y3PJ!xt$d;*t;WGbCq(f5rn~uVxoYz}i5&ZqqvR6+KLn<S7
zsfDSsyDB{5A<#0lu|;tvUQe?^f#(v&6!4ITKMs~SNrD&$pKoMbnPUmPXM~}95y@<H
zkev^v7g7G$^E?|Jb235@%bm)CH?#=ZrTYk$qJD^{Z2guxq>>`t6uHaRyJ(<2t)sho
z8}Z6d!oV0&!ixG{O6t@(DJhIDE)|Q#3mzbB<2SfJuZw;Y13G697`K|H*5~#CeqsTy
zZ>M~W|7Cc=WezJ2GI5y~%M*YU0E?d~mG__;=<y+W8Xz`xJdr%5D9at8L<AM&k`ez1
z=}QWEbOIU9cJO)_`(Zl<?tkVl`HZ=-?KCSYmE#9X^Mj?bGCW71gJhVv3uM$!B7@{P
zfpbk6=HVv__g)nOq0e&|37<mFzd#&t2KWt91w%226C~B^B;jJ_f!X_rzfpqh2_JY9
zw-Q0900;YOCH%J6XEz!i%!DQy!k3159|v+%al)e*M8FfFbr#Q!5uQFELt%ve7n8|Q
z$&6RZTSR9T(UC)b5-DuNV+1@FclolP@A6OnMof_Rdg$(K1RoMc1F2@CkA}4(zOyd6
zA!WD#q3K~kn`Qxbvd9A+>{zd{;xD1wPq;x%m%5^<T&#eqal$q$qkHy(Z$Sp{T>6pz
z%K}aOWp4#*J_`l2g1Ae)xfpO^4oav&|0H;h*IZv{cU_cbjN-n7;E@2ViUUgxkrQ)5
z-~5j7jo57a6^)UupsGVA0igh0!FCly5TIya$Y>fP!<z&}mr&t|3-57WyiIVLm3KS_
z-U;<>1Awkpq2nY->$=dca#(!4z=9G&4y<`*F`o;^qrc(6SH&GT=gAwx{fZ>~PK+nd
zPeNP~@sVUCr;Ny83DCN<HV}M#x_pZyqe(=PBEE#*zXVq56JMl?Muz_d^1!;6s3t;v
zj4N+u4`xkQd9mCdt_o==mGsz)dg;LOW?{{-atG$ySG*?$(=zz41%%B)=R-Um#-gG~
zJm6mBDGbj=02aex`hq*5bTUsCT{4s$HyRyNp8zYHg{Al<gGZnY1}`HTR(cH)GwfPD
zUfC<bd^zVFP;VYh5=^=1r#Q!Z!(Mombq*w1HMnu<lQ8sIw2-eZU4F!7k;S*FT7@Z>
zT<hVR14FYB{AGAl@j8Dh?gsWxbsd%`1rwy>RbzOm#<;x3w5`T$y2j#94NkJw%Cy$n
ztG4Pm<oz|MmY33$s=2sAB{%?kj8Dh*rFpiWz)=Zcg~hjhNAxOSlerD=_T!VggsOb3
zI~j|jxytY_R!3YaIl*U6GePtNx3%UX$_@+u%|vk$v=a+acZ(vEzhL^)7%^Vv1<~+S
z7Pmi#$-DLFwg*>834-qhaB6qmPmL>KeN-hf9JOhc(y^q%w{a)oQvGP09v7m_E7f(M
zEOL@85TKi_Hd1^2Pc8Y<p#;-gx5DoZFQB<ts@?_uzZqAqJ`F}S@jhampfljpBzPp#
z_okQeEZ1E{E;W>h(*1cARL{Mc1z4n>;IlSVLz_q?ModB!$z#PYT<7*qw0>^-5Xltv
z@VM8WVZDH>^zdNgJ7Jzz(E_kP-u5C5DQ^`g7(%~UwS3sHlsEy3C=lWy7xD7&`!B*3
zcOR?}0&i0VGW$grz9jXpi+1xOTQ`k%d$_N4sq5KFwS?>LPK&5VG|dS^ujBZ;*n$Qe
zq>yl;s9zm?6ezZbGKDt$cUhj6+d?jfC5^jq(!zFbF?BizIoVilpP2IrskaG>a7k4p
zK(;A7gg7%VbT}>J*Cp)@ho+v*mIdL%a}1%aN1}ee_{xT1IDX{ub^idm>n;xRVj-!z
zO;`B6NO{)dkAdp>@?uL*?pBH32gvHnOG$hO37JK1GK2?i8_j9Y%!!vZS6D)<)yG^q
z4bm<Uxp#aW!MvaX<w<#?qemMZ=UPhNn|HDJYSS+nXBM2e-g=?>k%tJ}cNlsvO*LrU
zc&%K!HC#taO8&un^CbkZjS!sB@tqq^0=-ffRYzXGXd5&qT~Yq@io@N?KPVcfsC{P3
zmDdH{86obI>ea7@#7H<yBVdEa>r1YiwoNx{Zrq-KW`2O+sGNn-b)JC#2t8&)BZsew
zTzvu4u;l^q^UknEY?%jOXxyU!xJIX#nQaUL7JR8wdZtr$uM;EPC2!WH=-s89)TL6<
zwF}~jWkRJ<xYKG(jc;A4$W}%C-Mv*<0h9aGEUb`Orluk7KK9sa?1=3cVJ<qH%d`jV
z(sKp-G%4%eMMbeZT;O-Ho(8TEK7Tl00RL5e#KA<&s{-NuP5k~T)VXp*6G=FY#be;o
z>CrA(!alZ7<sCFA;$rj70en#;NNlv&k_a<y=2(zlKPa_d`TXNU9ArH&mNx*)W40(%
zFVR0Z7csLeV;w{4+N~}zQ!+L~Q2ivlW;Hp{gT+bG8qGI*@Wvb_6I1@uxyrIF8s5j`
zcO92vZt<KT!#Y_4qqFw_#;a#DuU_n3=hAugDCt!;j=v74A?gon0tiv-LW4^Tlglsb
zNBp=Lm@;n>-)PmpthnAgLo=^Myh&*VT{=LtpmQtys=n{nnK!&6k3Tmc!lC36f7sPv
zk;7F%UMzUx82^8M>`60p^e}u3gZ1LO@>`8t*Y*PV;xO-N#TEAO>}9cihTx$Zdk0&{
z2RFt2Vfg5}kiypy?n9$;tEY79M!MK<a==pi(TBlJk%b)Z;n!7RZyyPK=Mz;@7Wh$4
zGS)<xeh_&(2e&>0k2XRm*tjx9`F6=REy}*<mc~e@$Nac~3*9<3MtR^7c%)Rf;gF;+
zz}KV$CoT(ZvCl^%;Y#8KNYi)0$?w93L<C?$_bwnG&qY&~go=cL;&may(}^MiBqfS|
zK6%2LtmM!a%3&G=k%R-K-wjlW<oBb`f<*B=t|u6EJ@!+1i^|%a37qJJ3T(v7op`?E
zkarV4^-dypWq?Q{d)i|iF!nTOJ+G0Cp4XVV>!NHOeMJ-xsZ)<ViEFK_6o2tgXx*<~
z*`FuCpBJ(jD%c;CWri4Yy7fi|7?u&w|0NCLY+U{yF${xc4!!RmQ2`;ZaWLG+*RTAI
z7CZ$Usm#^<lFL#~g&9-{TVw6No`^`kH>UXW(@wH8cy7kt95GCmDM>xOtSKEI%ME+^
z#(AKq?^K15?A%kV*aRBzX9?OIXHZU*{!SG+{}d5~1}ui=WIt-F-ces+Py}vBcCPdJ
z%?{;17V3CM-zDYctH6ql8HarqNEa63+EAz14qE^(4JY{aCo#5E=((SqVAmU$8;9*=
z0sD@{_=QDKs=zl;zix-5GvtD&Dq@lG$o>xYnQn8B$?`|iGFSAnV^wcJr{IMJA@KPR
z+h0cdE1uN`6(-1f0n^31v)BFaOJX^HjrvFnAZ*_7GLx%(WtX+0(}8l2rrf+I5CiZU
z#Nhco_*XtiMS#C-#I2UZ2$jECwY`q0H+ISBkc>p|mNOR_mui|UzS2lvwVNtCPkm7A
z{2KVRcX#&21D|j8DBc__qp#yzax;905$znd^4jA2iR1RG82hms-`xWEp04xdMpsTB
zG~*U)i#}`1SJqZ;tbOTNV_8EYXDfbvSBzxb90&8Tx4FFl$0HN4(gDP;HQ3JmAKyM=
zPnO?0<%MJRBC6KkR^j=NebCK72uw1J4q;0<!?1GO3+wF1aQ_YTISGXM`YV@3F4FC~
zaYQeBW)K<gc}d%!^lYE`O_{U7x6Jo3_ir?L2%-N&i0Zc`|3a=X8ct?%>;0|wIV${1
zAO6DcST1{=g6ID`{P-6Lwh`_7HUw3|Iv-BX<}ZMX^&mVs>8ChC7QeR?N6#*t_lkCV
z{ECZTu~It}DgelDDPds&x+%3q>%#uO_sPHg!+t3gp5p?lZjL>kc_m82z~7Mtp0j6v
z&cRxl@ZMp57UP0VD(n#h-s|^}l&qb>g73UNebN_YaQHNC)AE&LIBRwX?D7W`^N0Ki
zn>#Ev8}8*B1KWc2dSSUE8xfrdWiP~qp5G!%nh4JD=5DNj?oE_n?%mE|xTkt-Tl4)F
ztME5M|C;jU_AUvObEv9nMy|gf2{@&QFa7auK=7mPGgX_VmZFVTqyPIaMvuc1>>uX;
zD*to0npnd@m66~8Qsbk=87{c2bs1^SiY6dqK}EaFTW5)C`t+2!EZFABm|rPQT)Fuo
z1==)j5}KuGPuVX_9ZOX5AtwaE3;o4`8zsO4xYmM%-vI`i_rVk#`1<KcnNwwK`|`0V
zSNh1lW=;8tukQCxKfl5)^*Er+xrN&J{<roGX^QpafJv>Y_jJ;|9<{w9ZMK>!kaaK`
zo0Yo(OoCW{=Z(lsNgv^|{5lVE1H5);KlIKNOj`~FG%iJycy5P|-g3IB<pco$)mEYv
zq5hJAMxhPI?wFcHr~x2P2JJjlT)JWD{VY>NAskV8bfIbg5kV%|f9y`ct<zU;oc^1z
z_QB@&KXoPc%r%~W&9XNi53IQS1&#3v0mr7DFOE8AJ&3#+s2AqnI}v<yv;FXp<eRl-
z8U`dD#KQB)<qR293MB^lwi3Y@a>V{%ztxB}pC6KnlHf%a?D;DJ<IDWadShFZtqm|;
zmZ=KUty$B$$7*Y`lS_ddzqi%HkK>EqwExW90TH`zCc&iy1fN%6^?<O=-3$R!R?@O^
zyo3B9vNj9ekI`&ZU2VoZpKf@_vfz($GWlHl@C}vfnVvJ=LZa3Bz+c`HH>In9^5cn{
znVgn0d%PGi)huRuZCcAfzrCFx@9kP(#WP=~(2Unw%Bkw1aGlyPQ9<C`UX}6*{dZem
zOe2m9+;uy3uGipMoT0$y^3AT@E~Wr@;E=2!Co?2_bhhj>M(}(Vc$hNkz|)-41!EV5
zjW;Wkx#GrEiUU{w9MU9oIIK?^cLqN>ec?%(05&CSWJ|Ziw(SgB=x888%GRm;wPUcu
zCXbYfq=bDgaCgVX^(=s0l8gV?J5Y4hwrlbxzQap7P*xRc5>%ib+l@S?rAesL5nQb;
zz}>YL$T8iV1%*(?*x;OX5&7;s{RCN)(5ejOw$Pe<Thp*xr6Fx$w{Ox+!|&X#YvY99
zd(dYZ(fDM!E#koo=#j{#e&uJ85C5}067^^z<XO~{PqZUvpMI{p9AvcOr_g=ssBMqx
zy2sm7H9O>zvxDhyacT1`n2}I>n;fSJ88!y@lW`4~87hjnuY0#Br??p@Kc(aCWRPxK
z>eM%y%Rhr1)y)w+&-*^$`F3{D?c|^1aVeE_N_2+V4wU0IfcCJHdTCDGR8_8dsge>(
zT+KIH`SAi=CL8@ls@X?(toefU-_A!5>MwhA{+3PN>J#rs{-LHD!cZSz)lLBnNhd)&
zc_h@9i1FvQtstn;SJuuWn`Nxv#%)>Oluh~LF~2T}<1>N(FbMA<?n7mrpPJrqlI0Xh
zI`G*0Z!z+k)SZJ!J}ff}<D8oF%x^~zL|BDqVht-`f})e9(p}Nf7|47=e9YmoiWNk=
z2}}_beV+iQNWEYaXv8xxZ|QFIs)qy3?P0p@fr$6A9?~#_%l6Pui)S!<)sk-G-zrg4
z1ycR2{BAR*59GGzH80o1s{84Q!@1Jm7Nn7({TQ)keFn2X@v)JlwcjAZOn)$-F!feT
z4@J-hL>8^~XT(ZCWREL$o9G84g6SE8eQo`i15HG53Yz@6rmC>T&Vo9Cz%Ec~@zJa1
zWqTxSM-H8T!tNCf=34SpKS-|=#B;`Dfy713IG1Hyr~o}HmBzvH8q{~z-)T^`-4D&s
zO>?PB*jaOg>O!?56{`WaG{tWig5><1P-1Or?)moHYg&p&aN(@;yNVwyHh6`TM|GK~
zxf*GsdfXMm#oU)vm6MWFgFvVPS;@?wPa*S`J=$7|3vCBv&B6l0!0=>Ge=|LOJ_<yE
z;Oi&yc{o!kDiM4%IUBnZoAs*l%TPwvd#v^n+Ct_MHJR5WTrNsttTv$ePHaxF^)0?a
z?L?4RH@n($1=;u(UBH;w%g_`o%m#|VmtCLQNd|%2;JvCscN_@UhO3^aHDndF>V!)1
z@V000ZKhrN?q_xJ3_f3)ktdW33;6xTj@NmecBL|$6NCq~s*j}+#&AQ{auUYfel>hN
zNcH$ylHi-Y?-x@QPI_GtHa6Ugkp3H9LDFu0^`-K5N%QHuT4#74o^<|oDSj_XC{^<L
zOjdCj;c8>h)q4dKqMcG4a=-lHg%c54P;67ZH^5pF@<Q{7|A$QzLI2E;&Z%i%TI%bV
zjuxU2m*Yi5R%C@&j-~H!J=keb_`-K@^6xL<D#rN_Nx$0=`&tuhk!wrG#wa5xOvXd5
z(2v|<_@aXk%DsT)ORiv<aM51Fw#Gs+>tIF_wL8S-!|EJh<apg?y!G9yFj>kgx4&uz
zPkX(avI++0!M`Wv&$WO|6b+qHq+@cqTI+Q6IrI<bA>>2*FrIVwS$8#{v*KKnJPwNW
z6SUn0ajEiBE3Q}1%<Jwq1wz*ge%OcH7V$W5;H;4ZHe23#S^CDJ?=a!YNLCSu%zwad
zf!QgftJPP*ud`7~V>lWUU58G&$DMwQ+?$+JEi}V?bqKu9qtP8Gl)OsOWm;D!M}vVN
z51tH-PB+uO(WL(K;d#9ovcAs$-AVtTq;cVLAPpV&ZvM_A+tiCkJwH!P!tF<|u&U}}
z`~(jJXsDrq4GMqgsmT;KTg83!<JV&0%hTcKZqXbS&K*plDZ{VKv<8=te7yK-_xS?;
zQxtA%UHFYyC-dWGC1HQ<@<&?Klaze(Xbwe05!(l&46Pl9%*#*<(>k2B=ZmUOi>AW5
zn6*ZKSXs#pgskIen=<-Op-4X~l{LI|5@;*`%bsLw`^QK8MUq=7Us@FO524;59SP<A
zzwT%+8+7J>fD(g1s0`NU-;ihj(U_@%QJD3!lVq3~gkJ-67Q^PKtgj6p`53ZqI`Ld9
zzL{s}v7El#ePQo}$Jy|&T~dE-=RYR2J-Ih2XB}hfcltudXTERAJV~?MmWf^BAJ;SN
zlIBHUB=#A7+{n*JT5L?<HuZ~eCP(+QJ*eY09`2kf<S}<#Aq%9`DoNKegbnwR{&$-?
z#jaJqGKL9Xn!Zd$Y@?Tm$3<$Rb~uE=6R&!E-3x^@CqC|ok8~OD#|Rzu=0bj-9kxlX
zz4Y$bkjTOcL>h$42#F>(^z&HS5Q`f>;L;QckmEm69y~H+)Gp0sydVS=h}~e(U`v18
zL-btukMw*-G|{R2chhVR_9fS$!EEkAz0C0<5J3eRg@ztsNt&sMKcm0k52E|cA~r|@
z>O}sOS<vWu@mit4;*N^wYI*^VetG!%$A{H9RT*Z?a!m|R;jjg~2Tw(FYak&TsnozZ
zwGkr9&O~T{mHV!m_Y@}GZx(u%EIMA39YKZ)>Kfm<NNd5pkRIzYMQ29Lf&d-rMM+*O
zv;Z)WxfY(iJOcgXg5#VTmgil4Uf}Uap7fkiSRR1MJaf<j=2)sS84mt@4u3Lm=v;ZU
z6_upt$`2Un&@b<#hkByMUu9@~OHUritVhyXn6&>Ey7`OK{L6R>nHj+Y)B>{Uh)y?9
z#-fl2nz6K;18BfbHhlGYgelBxCqtQ1PTb{*nC)@yVao$l+%O2J=hm1au*zC&@$^!X
zHBg^M#PHyYX+0`A;{<x3BD1a&;<RVu*V8$!Q<$Q2PtOt6u17ZwEissB2GG=?bsk$@
zZVKte*O$Gw@!&u#&pohRbdZ3ZN~tw6R~~i;J)(t;D9GoRHX6<ruC<_gR7H80(*`rl
zSNb{5juaah_+zMI3Oyr0QJ}jl!wg3Kys1J_p~VcBtecjm&`U3w!9EZ7*3Cf+(GaWF
z!Rs0w*$_)t9eNxQrEv<9i^@HLRw{>OB(VgH!g!v~BC^~2zP#<bo%%fHAbV!ce&PLd
zieH9#;*lm5P~x6I6bmfS(*WQgqY;_6aOM;iGzFng(Q!CZYd_arc6#vTdNzeXhS<TZ
z#&$qQFcg_U0Zk^@3;{82O=}Nw?D+evkNW!Yk!J(7ubcnAeA(kD_w3p0#n*4PU;hUg
z8WtHEQ5+i8A9`y&G-k${|5Bh9O6|y@+U^`(E6}vlfmW2mCa6wR8lvxJVAEa*&a9i0
z+=z?^!)g_k?bQl3kE{$~(SF3y^#{sQ2D*TVN_nzHCKa~YUiJl!f|obYycp?{&hro<
ztA-n+t<c{v>cSMIWu+uz78K5gf~PXnPtj?a;%K#uynFQBhW}zakD07K%}+FdnhbA#
zLrx8+5mYnPTaDsXGXr21BHKLI3Smp{xoO7G6l45=JebIq%N{0~HW^)b21}IskNY?Y
zV*+(RsV+kJBZspqjp-NIg*(OcxPc5V^VSrG>Zcx<>`#{?Q_m!(4WP(3V(AQP46g<+
zpiU<}&_Pg$5DJERb+*Epo^GZiNMLevNAhFea`${8Md>uy(z!W$)#(Hh>=>Q<2qVpU
zz1rW{hKhMh^?-P-4^nlg9_!LPF%LzeYWiEAT#{1xW-`V$#h66c*^FQB4>}IzrMOA)
zxDICr!Lxtv@luF4e5iFP^z<Da+VLaw4xM|xEUd|a55BA{5lwR!fO6|29PV1(7a0%1
zh$jx4QC9ww*MuHGpdEKv+}CvTFlyB~2Iza5H^Se2Fg;OO_*DAnJJm|J?<-}=FzSh|
zj9$fDwOqJnJxI5GxSM1%>e4+kGW>ySAY~B!m5=O<p!t(|z7b)Gt>}pQ&Xg4tRmFuG
zYAIwx$Dw(PwhmPKEMb9)J+DdQONVC)jEIlkMFb-_<QBby<n2zzh(r|pAezI5m@Uvm
z3yv@5*RxXn!!Q5bz?h!yg=kKwPcO;kHnM>kyTB4uN>f&(G(%sen82?78%f4g0im>j
z)W+`~$FaK75`VCDN;kvP73*`|gKtgB792`R)C4>psZ>rj>M-1yJSlWqY7@=kDb3B>
zrno`nlWL_|E_2-2^^X<(>rR=J5^o7e#I?uuiyO=YHg%m{Nc-Am^MTKznn^MBK79EU
z-fPC{{Mg-e#2I3?&&tu@;cR<4B<y9*PkrvdfvF@m1ose12<oE{tyg!)#j~-CWE9$g
zamoNzkt_bxF<WYT{I56c3>)Pfksf=^i39R?Z!CMK)}+K#^YK$R?0R~moif97QR`Wd
zh>DZ|m^Yn(wy=0gYO(3b8m&a7%fMGjr>G4wF0dql910PCiF_@^3C6e06M;!1jJWWq
z);G{S`j$+eUafi2?Q0hPQ4R@>sQ>RzPzIxyCNIh_sl*MCc{DotMy{rv&eW$cz`yh!
zy}*v%{>lHJCZET{DJt7DRXRV(xbx<B7g|}Dy(9lj5+m^E^+82t@i+sth0p4)uW1vN
zZ`G?&2SLK5`3&$}3Z()%rvO+H>~GqV$EgL3D|A}Gf1O9nO{47u{lYrWH$9k>@eAs}
z+jJN;8=sN8l!vcufPjnvf*WVIS)oz*KdH3>>9<tJ@v#T9Gpoqc0vjb3JCs^|dNn<N
z-w~=uqG%78sOr2-CUd{TKr}4qkWMK6*SqdkmJW&H)yk7;-$ns~@XP%aHnh#y7gXiG
z9F^sL_#;zY%k^xN!ubU#zOpfW_}sq?k`CtKcix-hy!s~iDOPtuSqA*LfH9hJjqPyH
zBlF5Q@3V@GsjZ2eCb@&^D;VH;rGQBP&X+#^WG_mC#txxfnsE<7tfo?v2Qp;dWrYGC
zK76@p+%#ixADmNkXN&l<BACY?Og6(bwxD~d!yhW5Oe&PbBPY@6WuIGGt*L0?NciX4
zN4~C5UFoBJC&Ohp;?OgH#<h8PDW*8El@%t#D_6gsf&(a-tbo%biecG828&y;>BB~Q
zD2p+cPhaJqTgj?BQW2G&OQ*(Ov?Ry}Uspb|)k_Z!rG4DuNnkExVl|k{M=JX0G4?#X
zj&*DPUpk5?7U<P%opkTSblV+`;DCm^Vqcq-zcw3weQ5i&#r^A}kcjB}pC<h%rbJ5d
z*{^L^m^*at2qul~35g(EXy7wW9Mt^duU)n_a0$rLRB5X<Jy7RNH|^VfKw1l-WMT-j
zH-_Sd({v^wfm0cddEbV$1Qz`=J=`lP<oOhI=t#)-*M7GgV)EsOA5nJhC;3s{^+h%9
zq$R9paAFaqDxxYtC^eZqJ!81`KxH~*1?+^#QR5;Td(a{#uO@k9SQxK;eaE-OPu5#{
zM^pxt|6Hu>S=;ypGf3pwRO`#h9pRVfe>mLx2=ilSjlM=XYDb3P_<^I*)NzXw@fD|c
zq0!l8{P(D%DbYDJ(jDMrbQTO6Iav|GrnzkmNBDgU*~{hbU(X(Z{KPpcq}IWCHcSrF
zrI)=ZY+-XQz(N<+DX<~-Lv>jTB|jy4Y2~W#YLNK3m@%$_i#uO{ogbf=;?m-=i0iK@
zD%XlksKpYSN@q5eFKiyl*i<RqRK2~a_GDANe^X;(Q}c7Ia;ZPyM=>Uq$i_5j8JTg!
zi$MA;itHITc^zkSN0^Q=bOp_uK$3^y0}pGrkLy4pTA{A22hQY<#2MNPY1FoeDwP2)
zh-+<(M_|X}*he1yJOT|$OCP%=xTjjF89j^=zr)z%IUNet3#Ixo@MaUs#2*LXD=J=&
zH<-?hQPQ>|pDk>Sv#!lX8^O4(U))^F(>wXIO&xUeHBUIHBM>MTAIx|Rr^IeJA2Kfi
zbiSX+%uw@tZ#I!<xxyVWN%O~W?}xZ#{#@=CO!&<OSd(bERe2_(X-C~@KL<urbUY~a
zV=1j;lZJFP_H*AAeoYk+(K1)vFQ(I2`Bb30yVeDI+YQ5A%}`=?0F%PezL-(FhE4$>
zXMZ9L(3$q=^axl$c<cEe#P@zH)PuI|*Pkawn@^~v8oZvrA<Yz0Pgyd0p2G4t5xkay
zDZ~-^+ZSsc6cG2bGNktS@6{;DIFL$88#;9nL8S(+J2Rn2=t(_Z5gAKx6QtlB?$#Yt
zO6&JEzdI?2w<gUYDe{50j@6CKNqZPQw1%C^8RYpXNIsAf>_Z{{V1WI>IT`?~G^TIC
za81ASLf`Z3rFxy(dOBzIcYsfb_C(X5HKPTV?#Ik7|4(G)U+w`j&q*Rqelji5dX}e)
zFU44oCtz|{zM(f?V?6Pqq8GGq#q~6X_Y{1V>sN$ECk<SZ#<4#BiP8%C<#6gdIw8R1
zy!7<z_kT>rOYhe4NLHNAko^SxbBZp#=Kj1htJ4^U;@kZO0AH6UI)-cTHXcj)4d>4(
z%=Zlg!?+Y2Woq=gfbS0g)13^<&`|*yw&o-bgs&Yel5){gUVS6lgY8cqETLurjAk8j
zw>+=7A)Kuf(3K-;6#H#uLt%g+Z&#=hwyF5CSnXtU<m#r<>oUDFqYYDq^m4uM)_;^b
zT249DY%8@;z8CR4X<ZKl;A-#OqPhc$8lxHqFvfjULbJUvt~_3X6ZN5gJIuAk?YikL
zNt`C~LG0(z#)#iqAKNee-u%vASnQd?LGk^%paRr!y0)eZ{+-DRvj!NTne6K>uk><v
zHS9Mcnz7e|bGH6vKXFp%9jMf9Yn*01`aIcu=I#BczlLXL$_)!Y{uUxxd2Q_PzB$;_
z7fly_Yxo^T&QY+Vbu2=s-1sU@!xdxQPW?Nwvp(Nnq%9|PHZCtn@O)Z4J!f}k^YhyW
z=QtModw+g!{rGWUdgJ0V#-wsfCLX{%)LJo=1MeP&igYl>ri*$dVrdfLt=I$7-VT<I
z%`%qHR4PxD&yu@VAfKY%yd$5plc~F4cQ|WqLh?epZc*-`>BI%cIPcAYEW(@45rqMj
z(E^4w)GsK<WjcXd#(&%9*40DTuze+`KI#qWb0qH+4(SJ#doC-S&uoHf?}(f{W~3X#
zTT72qJ07BX>ZLV2EMLV+Qb+pf!(-+$8@u^8$qrBJ&&2yJ<e!^k6qeR7_7zs`EyYHU
zS!qGpuid2z&S#fTMQ;mLav>fbD^vMtJYPN#M16fvd&tTidxc@ZZ#Tae=xq1oPtn)=
zIg<CpvD^CYX!Q$9&on%TO7uTVE+fQ&Qr_e)xZX^x)Mv|^V^>3fd6fVf<6^k=Ys<Q}
zyJzmois`Lb)?(iVJC^Pk_Dgk~?i!KG|29z2!CC+MqltIoR<AK<CU8)co}=8~C15GN
z(Q^P_ML#y$FDpRzKp6iO#BZS3mPZr3)%7_0t=Cm^74FWz*I(Z0c5KuVwR)EobjNY@
z&Hnbc|Ni5Xa&naqx>$%*Ov75A9NpKbB)#RBoi3E`8PEQnwG-k-v^sRzAQ}kZ%-re^
zVST+n!7FOzXgCGbz$ych<d0$l%s`GtZ|RjI3O!^>PAf{S3qJXFFYer9ouPtbRb2If
zI<rp(0xph7n9J@iD#`u3=-9MVXJc!PD7|WXQD0a<MlW+;XqER`htL<r#<@Jp<>Ib5
zt4AHFM~rp<ySn_~!uHt(=^jK)p5;%K2Wn5bAZ-N$&rk8g4^#gwINL_(yomfI8nPhN
z*!7~v@#o}a(<^~<anvhTUnmxwqn%^#ueotLcDvJUCmH8+9lw<d?QygD{w&DZm(598
z()mwRmb+TDH3=oZ#vhAEQcRKvLOyd}QM)i)Op6%c$vrDf;U%ku_%|k1bX^Mcr`>5S
zMMUq=(Cua37S)Hay}D~!r6eEo%{hxd$Px7#OfII({XxosU2qN~U=$SFlcHD<el&8P
zsMRFuL!a~A2S)RIqWL?M<j)v*7N9?_Kc5--ZX4H{&i8LF&y&3&=64wUd!~s--8*|Z
zRK(8eOOs;EAW1as+DFOljeK{f0XO6K+4D4y9{ZQIf}Dk$*m)PURVV~Gw+@w8yEq60
z#TF^7Di}X@Ywa7lgOCe?PLBmaIgbjIv0vt=r)68^Ez4{~cglM~PaqoBN{hZ<h_J(7
zPSB0o{RQSH`*jZm(R2z(+HWT_6jkpGl@PHKKR5f2l&oCG4c|HlJ3Di3AMaeC_*Rac
z*rUYIEyJcZ2F}9RW*^s^_@`F{r$S%9Fny<Y;pYmfbyUQ2KfN=hRVa;%Ez<(2$>$vk
zO&WiFRPo83ky4^RdJ6$JFDc+{ZmH6e`L|+eWqLfN)n9R*c*fKv;XkTbwa+aW?)|df
zZLJU0J~3Uv&*CKjH^#DH=oUDvC%rS-QRsH=*IW}ea=iYH$SJ|DiTNEp0qoh9dzz{s
z3<%%m#h{Vnx$b#@aqm*fI6oEGbSdvcpPM7yw1HX1!p8j4)rws;xlj?ptF_&xhFt|G
zLkHmz*3!Kf&+kg@*N3NH(eH?yR;uxNu5q-MoR?Be(Jo(VaInCa_bFL>%D=yJTDqJO
zaf5M`O;nwB*XQ}9ukXm2L_)Vl+#YOn`Cn;8l(y>(HCUmpmzke+kj7V>jD`p$GqYoV
zcX}7Lzhqj07o-wIZ6A~=Da3EjD16z-zxgIqEbUrvj!5S{z;U5n-Aj9*p?9)O)T-c1
z{cSnMM)N(rErAP_wkf*PS|OMCo<iRcCB+JqtQWiGHt45q<MAcluN6D_&#qH$r$0WC
z_BxT%YOV1-KrJ*xfx`KDT%vRt@$}-X0#M)@V->zTT&Q{eNv*j}%z9NrlJyqe==*@>
z7tg8q<G<Kt2HY`k3IylB1tO(AdBO&Cg%y7g1|1VNTdow>T^ef)%GX)&CgaPy_6Rbj
z6$Ntd>V;5sF)yapE6{BlLOaWjq8)0EMxZ~;E~VOM7?If1)Al9uQd9RDFb^#!n=<my
z6pg;J!K%_*p~XG!51Kx_k`&qCP24Y0h%4`w;d7a#E)EEBzf&iI5;Dxi+Qy-I-B`>V
zOd~-tAbU2?(N8nN>si}G$NqVzcAc9p;sujz3&ZB3#&5xgpH02FV%Son`8~|_+4Q>(
z!^aOBzemMAd;f8tW7yg~gjHo=1z5cK;j-1JoHE4^tsQVh$%2Zh)+%I`KCkrR0Sqg$
zQ{X%+?I>y^`%ZA}CyoWLa_k6QpMH6o&gwIeKbs3!x2y9NSm{o4-MIh<&z|=`Dyt~F
zK{B>cjNEu*Z^pF|;ZY;eWem4>ej}ELvC@Ixbkf)#5iHcVk}OwzW$MV~Z!{br9VBQc
zdmKeOSxe9X;J`@kM|5pm58@rGFYwQyvLuMYQGpAFg_ny8lFcOLg+IacF&d@W`c@IO
zsx*RiS9x|KRbED-59MN8-tg+5LHwry?3YL94iuLJ#np7<QjcH2r2Iy06_2blDq~2p
zUy?~AE^z$IM+Xj3;kmztbPcOBBVJRCzlE+&Tz}5j2_c{x&n3&Fn*XGDC<unH+gj~t
zl|CjP?4FY$o_Pf~$}DfKDSamDLcp0W@C8{$TbKQ`RowNrP%%y-kG+O}4&FNzUWN;k
zKy_tBldA=67?i^h0)J7hzf4dJR7ziOfAgm0KaNKVaG=|CsnjS$g+e`Bx`%GvXfCh{
zt372)?Y3lrlOVvpy{E}7TPv!ou8#GyJ5qM-eIKsc+G2bx;9d5t>$Z@O7CoOLhtrPN
zQvr!IyL$Zpv2-r}Ouz3Re{Y7dvCU!5Y|iKNIkC+!hvbyAnlm|s5K_kGd_IJv9FvMd
z6di3wLgkdGKIN2jprIT}_Vax_e*eP#xZm&Vy07c?dcL0cTG;|*^I9oVFWJ1m9<)w1
z(05o(APVC+V$C=}n(x28q>lAjNtak@%d?5%V;uhS|M?C}x<e>Bk}{-2UKK!)(YMqa
zrwh-6jhNtH$pm#IQC5`02ySVsK-?7bcQwu+yG<nMXJ|@NbymR|#tdtKq3JYWC^Vof
zj{>GYSis4cwo|f)Hs5+YKm%zo35O0|)i#1P2_*FnEB(!%;0D&%#|s}`gh;CXEO>r_
zp(8m^w&rWM3jUoylz|R4mk{Uo227Lwvw6H|!IV8@Dnn0FEq>M6Q0O6h15fxCIy0qY
zhttusegKJKtU%OHMULn*y!QMEKO{d~^|28eFpnIFflv&UsWU_Zs$;-{NzkJq&AJ@{
zxFx_Gu+sN7*T(=cY|!yAruqCyf-hYYZoTNm^j{u$D#b9bwu=ASpm#739hN>&Qgrm8
zRP1UXP|NXFgKGTdl`!BB6_d8ZWpvS~HmUf59~^fxnR@!OXESMs18Lhs&g8x&A_am`
zhQY<<I@+(fmv9<=sQFRKIY9RZBssjC0)!fE2+%siIGVQpkPF6J6X<sdq8Z@okz6>5
znWlfcmO5^Ydh$e5I90pW5+FJsf-JS;!5Sq4+<dYl+P-p!7TjG+IRIy}&!O(A;6=1N
zq^(%QR|*+(c%=q=9vouL0TXq5J<`DMV5Z9-%Oj$e+RB*iQi!BJhk^co7WEv5;Eq#e
zgIX1Ah-gWcehxA8&p>D#O$)qaL*i(5%071R?(^6GcrN*AR|t!?4R~gO!hH)pdL_0`
zkX@pQIwjV6PViWGh7%W6sJhAP&;}QVKceqRn3r0EXY;4j$}7_J07<~C#(W6W%%n=p
z*F-QRCG`1xO_czWrTH(JBPBy-ksy}epepitq9RRanM$mro?#C7(+Ip=xc6&RLkd0y
zvP!}*tfM&wV;~7dA+`{3Eb@bmS*wi`heH-kVH&3NB;+m#C)|ve63tL53D)GI{Hq>x
zU!h7>qzg<AqQDfz6Ai%>NWusxVb^k%hicKgbObu2+-s#-QgH%p?Km_LB+q7s_Ya_h
znC@|wz6BX%V+Jdj`10ln-;V=W{pTfd97%>;hwmv14AXFzquf-*KZH22OI36sgecN<
zcd57#;;WmBq*RbHlc5b?GOGx3Kgp3;1W|wv$<UZ}T(_*7LrC+B@=0NLU;0@(1(<{T
zzmvVR0RVqM?QXmJ$p8`<)I^Gr(}w`;{ei~0*8(+i`kwXjf4C&O1E2h$W1#~_r|l>G
z(gkNStdo>Z%>QTR4w=7Nas~kZ=fyb8r6nD;j7L+g2;e&h)H@-E=NM@16m-Hp^ZA?4
zizXPGYfRy3aO^l4SpHz{JMj1t4YXoOO@Z{)e78BAq^Ce6k?iL!rngFaIL`vW`e&-J
z8`vvJ;VTX7<pwTjd~SoiPEtP%aVoMX;V<U31p28K{frH)^wIdC6XsU3P_E25I+<u?
zO_Mfq8q{T8{}si&)L39aVQeg<JN_9^o%b^>p;|1bKmWrqEFD~<$n@U~v8I8%=4Dni
zLhO*~M*AFQo<muG1`KeYY~8>O7nzfW8YE>^lJ>19_iG-3D2DpgLXrfHe;i|<m4pvd
zXpCt>B|};rswB7))8)AZ?vvKO<*kDOHKre6R%+<*1!PWinU|&phZ2$^fmOLnpFvz9
z5S|c55kA8w6>mC$m!*}UwP!7m!9Y^m#Slo^p%=q?92BnZPiV!v5QFX1ExkAav2n{w
z1}b&{gO<Ylc0Za#4ttykQH%+j0ZRZK_;#?9Fflj;LP6J3Uzx0}8`vBYFvh+8GY<wr
z4R2cLs}%ofJ^b064a=D7Xt3zT0<-Dlf)+_Q7cC1E&DC!#&y<D^-8wCYZAq7_wleSc
z1=^_OeoK^Z`qn?HXTe>Iio5>~EdMATUbIL;B*+WiAxxu^XKy~3x$fE6N{*4XOHJ>}
zxor&@faKHOJiT2jJH9SmtpTx=jJKAFpD||=2xiB04^=^9YvxIJd^_;EOle}r7Yhvd
z<NY;rT;$D@cvSsqpn6G*mM%WcCbTyWyj+kvdRR83*36w2(c>KE_zY~T0yIGcRnHN-
zh)0Psry$pG;Qqi0Ydh5yK1B#n838zKSd3AHZ!46ah%o<^VWaM4Uciuvu{<+f)bKPT
zovU92`q@0^j^T9vp_?BIA;`LRkc>IPBUh{?<ILqZWsTxa>@ywr2lSSi^Wij%@+d2d
zm40+YBF&B9Y5AiWWGc@zB?g<q>wSsR#^D3S2Lpz__)94?hQJwu`qF@PTWRB%*?hW>
z{HJFj5JP5>R0QORevO5Gy}15WYx%9e=A4?)p(FaGTx{xKLI$}uL<{pyuiT1byUm95
zwQI~$AK6aQzj`r%&0$u;Y0`UV8e4NDpQ+wO)ez7&k2t&jPtR-o%$L48|B|lK3m*ku
zQgx=4fo?jW#58H9KS~}{%tji~KzbQWtz`~EB;9P;QkaBaT3{d_`2pksOsmA=9+!D0
zH7<lE4F7pF%u*5u4u@kT^f`_MLCk(c0sDt#1!N`35$^CIYu%FCh=1bw!Qrp<u}|@i
zN<`xymfeX&ZJ}(VUv$;w!%M*w*K#%&wZu^6i0J1Y<ut36fvIpN_Ds-|)ZZk!L3o=h
z!7V*t-O@w0yYvD`HYh{x7ijY|bI<De!;hJ0Bq4rS*I~a^vlTBv0(n;uUAys8NCT1(
zKCy$1FVwa2Zl(nrk?nF?c^V-S#0*7GoxlO&-%?J4$KM>7=>dw~@|!(TOPMD38Fpb9
zd(wPnKi<z!)NobWK8azdJZj!Hp!CV`?CVVC$Ln?uiFWhfUz~)B{Q@6_avAp1REh^w
zdqd7<Kk!}Nj=mQKZLyAVfr{#b)yZH72ZGjYPtxlL$A<AT6$W;x+wpqb7j_<`v5hF)
zy%dCTx=3%jjB$oiZ-$mJ)q<4Z>Qa!nO%yuCwQ_sQ(0El6Z0I?Vb!I0kn-S@hk?k{}
z2dAn~&K=7kXA`-O;lA;E1T2Qo@^2Vr$&CKs+p>tf9+{)rSjZvwjyaY9O|aj!hqL!I
z)tIGfkd*PHLOr|LzK`1b8Q-0oBK6NI6fm?RXUr+h$M*lrivN~Bz?_MrRYfqXjZ9XB
z7D}du1pZKcJk!~`1I1~anP-N}(lRpz`x2H-YN$n^Ar9~#tMK<5fDT_c*^3kg)|kdK
zC8>uEQeq_S5l<gybiBj9)EPDAhXhDVc5>bOUb19{q+5FY&tCWLETs~w>?~&SBt!X`
zT)S9uSwzmoQRa)vhnYvXGpqjGP=c5J7SnvK5H-7TbpD;e4@+~mZky`BIzP(+2tXr1
zQmXn&&Zh|7vc7x%#0=kA-HyGRmP{S!(8+wF+lu9nC{Q%o)Yrkd+y{Dhi9JXSJ)&T1
zC^1aOhJmZTaIB<Q>uFK-$EaswsA1W}<3Bk*&23mfGSApQ>PqWNUdqfH{VPAX>L<{0
z?K@|&(U4y2)dX@~uX&b*lS8{)@*|Jo;eo$x_GYVN##Kg-PwJml1Gf7|{f>W6v{ql>
z?&R|4_?{h<a?<J1$W(FLDa$7q)l=QcFGA;Ca1X5JKPE2S4t?8~{rImR^Za<kl*s7U
zM324UZed&XP{6?hMQM||*K6e|m*Z*5e7^hU^>NK#U@0UXHJ|P|yB3MLaOaBTHV=nr
zH(ot*(6j{ayPRB-*4K6_NoXbF{S;#2i=}yLAV8#kAL8nKWNiDZJEVgh_91<bG4*H0
z`;iCk+v4lvy;`G3<0Yel&YFpu*pea%C7Ff*BS@?7%_-=b>%aB(zpGS7(GD9qNXFau
z*(Qqwi4HosiEH)e(@mwZ;#;gui)S9CM!$};4UZcAKE;+F#AE7>x6eJ>Nwe6^ezsd|
zu~+qMug>DnjkIp7)U-pAl2Bl_=!d=`qNF}pK9Y_$Cdl{Sw>1XiMD2wrWIUA{rKm1?
z1J$hIBmU6YxHP~jUqmNly0<jYrdS4_C1g^zJVbnZ$IDU-cU_4J0Lb)&waY?)f?8Q8
znv6tM>zrBChaRd+8*EBb;w>X;pQRn_XTGQE&AO6uuJOJn(b#^@%_si(y{xH-^tu;1
z(Q@LEyWGvRzXzYys$YBlk1Gx7@{!k&%(w=8=y_qJ(w@qiRn+wQ9`#{p>qkWar;(F%
z?_J}{(Fgorm(wn3siBY7#D`DaFu4;a?jRa5!@<!n-=%QXHO)QaTH%sg`H#Awz<&|h
zHM`6c3xpo5?3c@~-U@O@3#ltN6^eo-OY!3Wefsrnke)4Kac$qqmA%NrUn`*n1jcOr
zD{nM({NT9udh(sf-PB}*Ggnk{OLn_^Wz8+~Bv^G|#E;i>ZfwE0`kNJy-TjPIJLb*Z
z{XT+*N$m*p#s}!;*OF5meTvnVImWFyR*AMl)xKfr%NWZTw#iU+{Nu8cUh`Vr>&=D-
zm$T~=_e%#bvf?@`;?b2i2dy(Cb2HIuDEzR1THoWcN_AMquxNC}O`3K_j=nA+f9co6
zOQVH?Da?ayyga`K3)bJFJ+l`o={j$^rEdHY{NoN4KyqnPFW!`Oh(>O<VAL98;pWU`
zp~C#w#k{6wwHlSI`jgitGMsnCmx?hF;-gCaR7QBu8xIc5lB7M`ImA2zCu{(?9DC_D
z>z{k{m_f$J&6ZMhAP4#K4WM&bMQwFyjX=d=m9KhuFQ@}mVCBUV@mVOYt7#YoQuU2@
zI*Qev*=mLwv31|9G>q2wLZ$q0C~FB@o_EA*|3&s*s2I&%ENMRA+Mnkh8okLQqP`zv
zPot7`UU>%IC*Tt&fFf)w)CN3!i0#$KlJfi#?r9y*xGx$lr60{Z(3;fhmsuZT2A@Al
zk;=7~(1uPPe^Xdm7Es;W=#Or<UL3hD8?hbR(ipG^`vS|b&Q%l5c*+W`izv~2|Kr|K
za6hlXsy0)Q!bS=39Sq&ffQBET@f_;5QO-XzHg}aM?r~FdbvN(x%wHvQc$)eJ@AoMc
zX5{Gdu9aO({w8koCS%}c@}Uj9!47dPNBG8!e^Y%(?TB3A+d!)?n{(lJFLZ3@k*^1x
z0g^)8Y{i|qG;J{;hz4Otr-Ep|{D=A(4`%P$l&KZ8Wd;Xsf_iJy2%5v%4iRkS-qbq{
zmF=NUgNkLew%7z&o5g%31oa_7*gTE#`czs$nz)Xl?N)4Nj1be157rMP1h!X`?PHR(
zNmAhXV&{2$O!e?F-Em=xw%KPBPI_j{_VZG^uve*(Sb{=8utY@60%lUXngHO7d;6_}
zo%U>uhte%2<C<vLUkeDCX6fHyfiefm8QN{>h4S7_QX6zG!yj+DQa?Ob<iaz}!GL0h
zzHCZ%ZvfzcuQrue1L7#7TD*;1DL=S#M6eu3H=X&>MT%OZB@5=XAmlACK5R_usr&o_
zo$)=TC7BgSV0stPb;#5L^|Rj#AB3Qv?iCUvk&^oG0E4t{Jby;MwFARR!h#bAJC2_h
ze!L(wDyEC2$K-Jc59nqv@maIR(62}^SDcxZ2+v;TEN0lwpZ}izeQ1`XWKZ_l3UxHZ
ztN55Ms@0P3o5m27hK2a&;94~S&^sFqFqyLvf)NMJGRzL}#Ux~aB&*c^Fi5M|`B%C`
zmFx<>djlO6;CiLQY*c$>B3GMMj*KlG!oNFLsN32Q3hEv5S;0dua>?p~b_aasJG1wG
z(M9h+{$hhy6^b;@l-}w;1+-4+eFAXa3-ZohW|xqs20_w%_l}tnAHZ%1HT$8|Edgt1
zT-w+`<_0+2l^yv`yQxM&%;?gBnopRkx%Kf@zCati*+fV3@_<Sg?5hX;8!B-AwDb^i
zdMz>@apP)moDhg2A<bJC)#~rz;c1<^*-&U~4Av}{%g|oDhdA@gU-&NzO?r@iyI*=n
zJ$u&r>AYZZkyNu-tBW<B7wu`Ed?{j?B%{a>_ntVp49o7P$sLRjRO#!Q`Sx>2-_I&B
zoKA=TI|3D79nYF*41vWBb6^%R_O%@#RL6g7v87jhKWkR?y-Zj?+aTfh)v@Z~o1XQA
z&MSUv(N&NB`@MdSE^%_BsOs@&gP+M0S5E%EQ}tvm;ph1UiBo$Icf2wF9P<3AQ!p<m
z_Sx6FY-@e?DbQh!vD1$MDvWuj$Lam{ZUNdy0=mE4`l9^ckrV+^j)dI}?Uyoi2f-G#
zr_~pmxhDed&DfQW7(7TjjI+xB?t`qChYZ1fu?np$Z}{&w8XS2#8{RJjw;^Q&73H++
z-A*d~sk3ug5}k)U<z7OUhm6<`ZCrXoz={fT8>U<)QM3eVugjjhZaDPfBE0~m|44K+
zN^vxKlKQBsjLTu%o+Ni#2dX04DEba*Z55oF<E`8z`h(mwQd8?M2J0-@&DFJSk-QQ<
zG{g|+FVIt33pplZWxzIuNW}z(EJ9=lJLj@2;)AA=yK|u~^+WiS={AGW-m&Xk0X3)g
zAN*m1lU{WtwzL{a{V46t#B3~N$)#wBw?X<*WDND*IR(yQfo1XPA1!*>s3!@MO(IKB
zVE0yPxb3LPWZ^4)Zvl<Sgu9tSkWM~)8U6EB*-@G69Q`*rLv#DdOEP6(O5s6zVY)!W
z<u&rm#S4Xt^&R&o`rY%>-b%%G2{k}#&6tYF-os7VoC{~J5q|e7!Vhx&Fa^`5ckw79
znrq%<13Hp9kSQXs<h_!W+U+f*5qlLD{IVMF(KSan6gDjKp6FnVWW;@onyp6v$$R<2
z!V&4Itf`C)U1mfSeD}Gxw_rZE_tw5^;SqdXhH+xs2a4JvZ9NjTy<=sb)pQlmzsJTr
zq1iaaMI$>$=T^SB+xO9>ce~%zeA)?94%h!B=B>q=9@_PZF`iOvug|sMI@j_x{6~!c
zP?Cnb$o>}#*-ZT(fihE?eD0h6p*^2yYhp96V^*NrIXtgE=b)$U0gJIKuWzr^?;N#`
z-+(FDf)Gk<?hr@0cu!;ia!iRBDRBlnEVz8@6ED%6r_1hjpz?RzU8%bs?~(!bwSB?d
z2y<R*WLPA~fE?$5kIyD&|HoguF>(vPIAI>MBR#N;-a&-(uS^CEjNAnfi=y)k!_5X!
z<1hNq2Ihw~8AJaQ`&iLGp~BX-$91zYy;$U{z{{Gi|MtKB8+KzR^7{hgHNZY`NU!o2
z6vrZ?f9f-%Wg#V);d=hnJjj2lJMJCa7g*fs+R)4xXl@6zkOeK(=D8HZbGd`(DvPH<
zoA-JQ@68V0cGjW$4|cl){teet@%?fRm0OJfk2=n+A-i*$CEM==`#LK4aY1E2U4m$%
zkpmbCq<<e~Kwd`<IR*X|VnF5sUygM=Lpm<FuoR5%j?KnA0m$F@8>N;tHBz!M74)B*
zF+Wchz=h?0CYG!OMgAPSBYW%c8QlqQFAzF+1~oX!yDKLN#qw*a0WI<xtzT4D@Vt>4
zD%Qv?V#b046`>Iz(&>oMBcS?<Md?~wsm{XBN3~cv7%o+y*;<3`^iyM<wV=p%jugNb
z%wii7B*Gm82PP!g+LLAzlg6cDbQsW$%c`I&O=<$#SdmhOC~uhPY?DCP0^$~c%J7$H
zrlV`DWcDUxK$B>1h+=a+DjshWpN=Mlpu*@vwL?m9EZTHI6c)STIcj9QY2-LQX6-a&
zEr2qLQ`={KW3dobI#|=VbYldn$5HCZcg;quc|kgVC66?NjI?Ux{R5G>|4nLkNpce_
zdQHI`OtDyJD3|JLLL0XM3QTqg15pF=K>0|>ivR^bobw2{L`bLbgM0C$=9=2EQi+K;
zxk;q@R4Lch0$Ei)XGawFU72E^nj)*e8FC|tE$**Syx6$!FI<F=`2$!czA&s=s4tLJ
z9L8oOX6c+E@a`&0jRarDT<2riNVw@DuYtR18*)co6wWjb1`K@PRqH2gy$vZeNNyL6
zc&TulCF?DK9eQmD+IpLW(s~r3t?i__4U*A7sl<acXX{ZN(AwIYlJm0Co3{gz1B%sx
zNBKbjVL>}OV5v6U`-2<+v}l6+kuyzV<Hbi*9F8;FU%)f8!K}}(CI#OJ9(_%l7~3!#
zoUqz29{Lz3+goa}qo+AqDw*v1h%Ad*2c^{p$f)N?XJ)u^t@5s7fyXZ|8xP8m6ai%{
z5X7yhDm0fv5jX%zdCSMnr~iWz+}OPhR%62r<P7+tT%NVwLV%F7x9d!z^8&h9J|W5`
zSw|tfP2R#qE<}HeQfe($q0il|IERs0CeSN3wI&+PH}M#bdGdC{F`!@hf=y5!#k)pV
z<{HT2p%Boj1XPq`zGa*X7&v`EPxi(F+jQ4gu0f~yCI99FYYa9c>gag{>)S7(owM-2
zdgl4gl03g1Z96Q=^&iz{Vn}qQcu-m|T?yYfRg^AdjdwZlU&<j@rKmuTPr05DRQ!SY
z1eXm`yi}?@EYp?_b$lgmC-`<ZM$y2<J#zzjTn~A^@L7C3tA9-2SwK7e1UBr1qDq4E
zWqV#@s#FXWBamG&E_;V<sws0#7^oI394pgmJ}cw6;xxm7S`JtO*SkFtoT|ra=55I!
z@jgoelEMiS!@3#+8WN*x8l2;fCW{RI9#QsLM|O;{g)^?S=OKX8?C@WBIwUhbug(Be
z8F(>FqS&JC5rE>F!n0ufOU9aCF|e^5JYTOr?4u~82yUPpBKq%MN5)>7DRVZ87_+w2
zF3YQs3*7cJm<+yPFqh>frq*c4UHNcwQ1DhgFBD5CZc*0;X(F4CdV(}nv4#a*BEy^Z
z*YD@O3xvtWOJnHBVUTg>uzDxRoQz*t`F(sq*XQ$8<ec8XNM-P_)A7B#g2zz8Up8ge
z1)|S!o|%{kVW%1PX)iRd(Bl@lG{BHhb(+&Y{hX-*5Wip`<r--7Td}bfGwa{Bk3V7^
zq_%~HYyWij6ZAZ#8+SX}{n45D@+bpp=V6Lw!kfrYkEyd&L56?Pj{@+=J`|z}8_ET7
zV#6Bl(p!|LD*r{wN@l$EK@9TReUbjfE3g<CHxn4KQhap8kSrGU;X~!X%(&kTk2S@B
zlW!uAKab;roxr_68@1s6^J79{dp=xKGykI9zDt*<8dx#p_I*VLdNF`M(8xKtM}FBT
zVb9PbFi!rYt1_?Wh3neFFj>=WEc(%HAuCx6R1$A~f>_PM^nSWj<HRF=V|ml0j0Pl*
zkKr;28fVXJnC}@-@Sad^(So=IVetl#M^aXJZ&uW9R;+P$LQ-~eZ}x@V>~v4ZX=|!m
zuZ1{P%uzk(lBYgE;WsYFFz7;gNpdb(n31m{NdG)Ru=Mzu+$Wy;P<kSa;QN~4!5<*p
zy^Ar<y!W)X@bx0^VT-E1z$<_~xr))~(g5V?f(3NaDxGLA%O~E@{-L+zg)HhC*f*#Y
zlZe$I4ko6l0AOq(Utie-LmSQ1go0DYWZxHYod#2oah5Pif6>PaqPhzT>tNJrtXLja
z^w3x@uZunnLYEl>;^}B;1MhC61P#PcH>p+%@LNwmJ6v(As7+mZZmB-wY@l2PTlx04
zynb;Ek|ueJV)q>5xF*UwW$1panr?!%PS=HS2#CwIm?o>(@^l>FMQ;uB>i38y(tUcB
z4L6hCKRkBz^Tws6hSNyd<&PPPfP5{_L(D4f?0pIp4w8<PlYU8X%Ui^;@!~9bL)x-T
zhcJ8@>@G6bpq%(EXA%?h6~lTd(?*5v@}={d*4_rFd96}^bj=^DUv08c`9eo^|L)ob
zA%}5%BmM7Z78D5~(($*$o)!|{WxMlceA-@cO;eDWO}d`x6~4M~wgwx#kC#0RU}FKO
zi#)2b96*8WO_q|(ie+MB^!iLtyRY&U7~yMe%U4nRTlCA&102$UvzC2;Jq(~P=j2e^
zrk`xXX>MY(hw<5rbm%aUFIkF7`5NZMs6%9|!54q8{^`mmUw)Ndc2^N#_L4E2fIKHT
z;J!JSya}%7+YP+bwwp<MC(~b!Y5Cc8-82jg>>b$Fam?3m`71ToSFO|QqQAfnJ?of|
za@5ELMIR>b;@VKbeV7Sf7}U3_ELOS(GYRkufNs7!R`xkV3IJ)b=0(w8ZynGD?;MY5
z>%;gCi=WJn6@QHhk$9-)6}p&Xv#)!uSoXcXn)x07A^=Cvdr5+S*W#CzzT+=rY|<q~
zbyt3WetV(s>)-rO)0i17qNqZ(mG|h7zet+|;NVY?3zJ}9GX!n{J{%MYph30qk5{DJ
zm79AJyo+WR&oTH+`1$G9i<EnrgkJ)5enZd6;eP%}iWUPa!}Vh5QmrS0ETK+M%{knJ
zG?rF99?9h7?|@1llI)iTB+BMS=pSsJQuNA4B%mf^6Z<9e^>$$(p%tZ<3udoAr@s37
z_|@9}s|~Z)zf&1=7=B<6Gdw?*dmSMUy4q*dmWLTn_B|P8=!6Fg?$oNMg5gCV+iMw8
zA)UOug??EJtTC|Qu(bj~K`19ne({lqWgb-j$)9%(Q#;6)Ph&$K=orc!RXL35JS}<P
zmUX(m3}dIDaR{Yi;Q2_4^r)Y=o5@Q2i*IegscZvq<`KqR#J?AhU&_R%^9|RdG8SGQ
zqpP%G`6qF%kN&C$`3gATMP}(Lq$Bc<R}G%sde2^XKk%RPskY!ueIpA3@`jWO$$DA8
zz;&kKe)GJ^c7r74D6pQcoky0KmleP>W)c6Int}Pxcc^gb$yX=?%!N;}1eZm87A)Yz
z@hs?MKj|8yZba7qEXV2n^n6n+n$=H$f@F1?ZLi7OVX$Ax5&*xyXs`c!kqd!D=|^vv
zGEUO+`)Wg7cig|g6Zo8`%T8_?AIROp5Yig*Ai)BQmdHrPyTv8KOUB8uhZt-B?+agL
z0u~aBKrdj6B2Urxpwv$V*!HCbZM@xgHXDze{u#jr{jelVG>*+p@i{-Pava<l7f$+S
zvS<M&3s^6RZ>CGP`rB!b%S;1+Bq;6S<$@Q4&*z?y%$9G3HKY+g=WZwf+X_AhR$odp
z#alsX6*bkWb+dXhLDw?2qWnJjRelFz<I~+XMrDy5Pza204U7@(XoWtlKYkwzpJ&`0
zWt<c+2kwyDwn622^UDG0N59LS_--P?y0c>TO-3;tV_d%blV@)yWsjqNuTJK_^{I&|
z!!zIYqSIwm_#6B;8_>)1NC4~yq(x@@g8}uk&r%bI_qRmUDa>3UHSfncIyffqqHXZ}
zss@~p2nusnN8=<YKn!^Q3R|g70gzSWh&&q}5pW0is{3c3N56Hvfv6|`O9W7`%tq#$
zULpzhkJX6W_)}ndR(7V{tuEysuVLG4XV7TP(R@RVS+l)^wc83PoP1SLfNf+qON3$>
z<#V%r)_#$ZIeCXvF*&u)3<ULpO2G4TPwBI=AZ1yU4-k1maV2ucsCzZP^POQ?Yt>JS
zXH6VJ$*FrAR>Rdgla)txwxiy)pZ|NnXV%MF2)camUN<)1BJG*Fv%|T}VddOcHfMa_
zggcAp0i>GRF!f+J*-MP0sbPgM#+3!7cYZczPhIU13Iv4qH~-%guGa(Fl}~sGMGam}
z0|_Xf%HY);CR5>dc=l_HUnHFg;hlZUQEYin0yJpQ0ZocX|IgLO$_o0+4~QF|s*Wz^
z?1JZmsuycQlm~+a!uZ!kDOueA&gKwh4g?#|++7QijTXl8V1mrdd4elk9L1(}5B8}x
zzFBZct`N)jCY<0=vGw|hdpEk&0z72p2n>*Z4VsW{LVS(^OnPGo&><oM{B*utUnP(!
z)?Xcb%|sjpcn?Y)Lt{NB(kPC0;nypRtaE%8XwDD`76ge91uZYS>w?@+&gSX4qB!$M
zeu@(Y^#>C+#(zo7V}J|X)lunC=FW)~ur2p;c|gCubiIF#i2_<RyH(R{9&-8QX7^RU
zFV&p6&u+idp$d!cT`ck;>TwKC@w>3&Wu3)W%_?3U*>0Hdso~~Qo=_tlgCLC9VREH6
z1qKDNE=kHGAJfx{-q$?ZelaTeq+N{EN!f8Z(b)`*RS+JKPJ?$*fw0ao;@<MTQ$TdV
z(hUA{<XeeDklB%T;^>DdRik+5z2df`(bTQ14ccO}KKoarh8n0=aPt(<<}fiT<hcJW
z0zKg?IO8yMJz?r(8ed|VODT#XmzBB^CRt)E%Uw*KF13D+j>6hVQ<ypl>3LaF;;7U2
zG<*k7hmW0G$dV~aTFldWm9$i3!JoWbcHA-fbLFX`<dvE;uadu9OXE*jZ7g<7`Px!f
z#7_Bk>+Y+R?{}W@pa0SI+VT9_{ZB>b*B|~onIaw^7Mmau^F>NhEWRI(etM?~Z|EJ<
z_Hs}-;(`9xts<hu(Vy?sc4tLK+Vnh4%Sqii25a2~uT<TQUwjgI^x+=%=!f`~6EAN?
zVBuy_?XK{R0G_}aVt23{1w4P)M)jv5W6s0jMW3qOOHYu3((_BNgf-V+zU?e8`nNvI
zN%Yb~HPJOY`DU)hq0PK(Bp88khEt7K>G{p$GHQ|j9A}`Cht_YUXn-o0vca88Tog^8
zC5Y;8lmg6lgZvVbF|sq$7(xjX(iyTy<r4bXs%i1JKTBeE{%$I%MEz1VTyk3b@&?;r
zIM1_<B*u;%(qD`zYEP%x$6zb`F~P|5hfH93f#w3q0T}?6x9MVY$eOm42Xzcy8gj10
znFYbDl1Laa{b7PPvFxC}S>Y>m<k|8!seYK9BX~UP;}3#tZvSwgP)6Z<Hztzan`M}i
z4pj&SqtlfcvMKb#aK2bs?--``<5;+Z(;Y;)S1>TkDt$4Vt{yYY{R#}2tGLS}`+B(y
z3qW}q$7q%JnF?0A&iUbv%gD}ZdqCVdA5Wqq2gkFtr%h0v0nIgU$3m3Z$>?TCprS{;
zjJ0HGF;EbAtP#s?t|XA{4-J$$pd3z9bqc0dM=-)D>)hdu;#0;{HZ8aYDmICCNvpPx
zD{*Qd*2YSw&Bm&qh#9&9X61*phRV9^4hFfTR5vlFn*{u`EnF%p(rkky4ve#eZH<fX
zTg5jDKT)<eNKw7gXng}%yXE<=#EDeR5I@LyZqOl4F;-s^58?%mY|l%m{a`6{mVp1t
zmyYN5TFDmh;FS0oMJM_f{dO;tObmY&_pB_r-q;)p%4>inszcg~&RhAcW>#HLZqm>{
zU8tdWkKaECEV3~B_S6n)maZ9OYPOdR<A^CpT|TX+G5Xw~z7u(Nq33?j+HH@t^JttT
z#9U}ETWKcw+SoYV2*6Qs@-9V|)6IO{Ih<3AD42KHIeTyRuG^8}jxya6T7`iBWsB9$
z>(9Oo3wiv>Br?V;MG5O7h(3nM<Yzu@Gv<?~QcIuthGV&y8;=fl?+}?jit}Q^H+fa$
zU4Oear6qA(dUHuIvBw@33qCgxh=&9O;<+vRzsP9A1{A}v@WgHf>8Pf6B3Y$x0g9}V
z%eYdHGII=QYb4%{v8}8O5&u>{69U__6g#xe$Nr%9mMqQT3v@0o9aHpf*kBSuyip+s
zfdzXt4waJ&?^M?V@6UP;Yjcd}U-%_o#~#LHe{w({skPAoVjxv<dV(tRi*^&MeD2@s
z3%7d96{(M347tnZQiW_~DWW6=dGO>VJ0@?>o(tRIbvYu!AUdnC*M+S68R6O8BI*$k
zWF@dxY{iZ1JxKbMalFy(%I?6pK*OL#HT=ETK=RuFTT7qqbVK7l=4I%@G2=~C@yAtb
zkNciE4O)SN@XahCf#k5t0@!~SSPx{;aWE5xPEkzidx;D2zKR$B6~|$o3q_R@Bg#6F
zR2Q01RA-`35p3nHqUHU|d(R8yUGh^87a9{QJ@h98TB>@s?1|ZI3r8^uTX_kqBqRZS
zS&o>u4K7(&ow7sX&D-@SWH2797O#9!(Yt|+YCWQZy*a$9C`8!fPplPkqeRg$2!#Nd
z*lj46nvTiMI7Af_17aicV)o}9w0IwHu|Xa*$XCjo_lw-hwnz;woOn5XEO7Nm@hgW>
zKCLJ2b?gSN+*->MqH~$F$di3)wOTT2R%7Oi4dFc<+A_>8sHEZ&Jdb$Dy$QXn{Sh{)
zv-9_p!rb$Iy5`Roduh4s-ZG;RmVVh`@B_nh@NP~=W>EJ7qs~?<$(F?&=*vpQ_FfmY
zuz(zC?s+kryBR`4mgh-zl5!c<@FM`8COf|%8kOp+bw}u$EOg0E8F5T_co`8oP3H}&
zhm6<7UiX|eM|+GMHB_z1#w9J8@o#5Oa8TlXA6zuZ%lo(d>9y25HitB;-^-i;^5e-|
z65ptHFitcTH^0aKmgRetVGxaDBh-duU$p4Ll~Lsz{Gde7_aUgJ4(yJ0{2nEu*plnJ
zw%C{Pw6B$kPv~4<v_*3iP|?VYRdl*QC-37o{LigJ4y;iiqZnu_Wtc1N$gXI*lIX8`
z2Z8hp8L<k3<7Tn~f!hnvL|wroiVLC?K?4JkP9%>Ez9^jVL53UJpLgXq@;#2HqKWG>
z&ShCU<LLs|2su3X^P#cA#lsk7g-IE0;7cSUb%^e;Ul}Dtlp~4Y+)F(I6?+fjp^;Au
zfVhjsd5S1dn^lQZG0=P{Pm+_J2%Rfl8%nQ~I7Q}8rbwPF<;o{>XOm3g#-XJYBc?NV
ze2E>Jo_j3`RlCa0IT@RKSv2QCPJUl&{-fdiC#(6-papd0f&o&&U|7NPoPrmv1*5|S
zFINj*LklOA3#UkhZ^8=Onz-Uvxo8kD*IW1&TC^aFc0qByAiE*x{GMpwGf7~zwWtBb
zH50=}otIe*D}D++?4%Th>Efzg#e$uPf6C&q9muPI#7<7hLuJmWMa08#F8>ZF9hm?#
zLGtsI3d~8w#VB0H8S{KCEjuUvcRW?F!Fj+<;|Yj6dVyzjyHsN?UJ#8Cwn2S#a(C|#
zklGW8jZvr}V*mzcp%eT=J-l*WIam;ug@a^k!#^P5N#nwj_XM(Op`TaEPV||$Q1nP=
z%Z1X}mu$Agy^*PQx+R>+WkSweL2+t^dIrJn@E0YO^<BPiCk@^aQ1RiH&fPQ#k3p6p
zd1p%yzc74y*Q*Ztt1j|X{}dG$7Xu`dF-(1*AqwoP0ATvuP0*ijk|Lxa7%LJe{BJ@T
zO{;3KHOVM(;#5ZMX-hTlAzJ#pm6MTb;Z?h_NJfm<sTicWYlr}rr#e<pDjS)2(@OoT
zhPzzNpo&R$jPzd|ERF&NFCd~QwH}SNV|$vA32{>~pe82FZ30f}<PN8Bh0kBH&lKu)
z5=`s1gn|eoQ{`89YKC~~3d*@9Hl+Zv4SOECm5l5@Jn`_*r*zF{xe{fc1#%47V*k+g
zg3hp_bAf*T7G3hS8!8RCfs&V?W@8IT0cSfoJ*3;Vh{jO$Q7;ILJ6ge%e@iZ62q*mY
z!PUCl(0`@Ef~rk9uAG+Vj){w7yPcXqF^J?QPW7(L)A*wuUX|}zh!67?g7nJdK<YrQ
zj<-kTtZtL5xABP6Stpdd?xB!4L*ctTDkm3xZc)IDrzvj}HtNhR>Kw0D6JOYO^?0(5
zo9Yd6xyl}rKM2ElO#s-!s4@hAb2T^W7&n@nAubh&K@2nt3C+SlJ$p}cZ}49j7duae
zXEG}l2r&391Jt|vWTP8(rkXCuq~JIF4>F=2E>c&^DxVL^h$n}WoY`=LSYHoa#7>OD
z>z<bN()e|+mU^D1dfql^4!{Ew{<j2C?2av)QN1*OGYrd_5?&9}aT0KbG&%9FX7S;}
z^q-X&wU;2i_G!GC6z&pg`>d*|=gbv+7FyFP983=V{zv{a1)7XewL%G-FSM-Oy8CeW
z=HG93%ii8*t9F#{sB%PfIGoeszTE*E?cn>~fq-?Q)H((2JB1@UMQ&rlG2B`7LMs!=
zAi(G}h|qMFGnRGa)jh*g^_&rcWXlQY3#YhH|D&p-U83*xdv3zXhGJjmqfN8;W?1*|
zu<i<lu2bVMr6u$Zr8yLIy>5W(J|z~W!ymI_Q9c2cM!PsRur2t*(2j{c<@j{NQSEa9
zH3Ab}a>0icLxlD%B;`c(=-YEAv6t%Zh2E_}gxjI@+$;}R-UPaC@RbLuOhT&KeGCWS
zu!ZOaxXI(tC*xsO9Xz8Y@G`Z&zD>kC6LIn1L}z)PCY+g}yG6jBNehnu>bOAsI6N8@
zdx&I=LUErSNBesUg^xpr1JUh&5qBjXW&YLK>3i50dpEX0XnM&;6Gd8k;X$KWMjd|M
zCg=<n(ig)y8f(i7esX|$GClf8x?GLrl<O-du_TX@yNOQgMwoh33ec^$^&A;MckeF^
zpxz-J2gwB-UiYh4IXgU$hhOe@Dlg}T(Srjv*yoZzA2;iPzQFN)tcUlq>dL+RdH|Tt
z5mYIX-VsA@Cprw#94<Sd4xuaDkDn|MAP;n%`dwn9^SBPFdM>z2rzePCD_huDZV@X1
zZLBk+{;W&CvqZNM0N9#XxtM|he~OFH1e^^s@y2DvxS<<UTn|ZnpH>r96y!iLeDa?k
z3+nKzBuKxCV5(eib27ubnlTm`Tn}X3X8_e1R$aU;<b8~8QWG;oM==VI=yZZG#dx^I
z0SShOz=lWkAn!~9aykncu_HH1<~wH;uI>SUg!3h;nT(I4mv5sZ=Mms+SPKjGLE8sJ
z;Tc52|9znf`SUibI}foU*8JI=AIH(9aPz;o7ok6N(qfPiEgsJ~n|fjtt|A{d;vwsC
z3LqSRc8Afl6)Z>;@$QnJPaNlqZNEGMm;Az$hhGpoNcl8QovXiLd0;M{!J$ga)9iV8
zsfc(<jKZ@B)I^D=1s0Cb;Xg8X(n|tZ*hefyjvk{zSGfYRwF6GaNMum-Ug7REI$s%#
zId<dEl?iJ-5R03qhc{X7w4XSToq(%O=MgtnF0ei%Z*!G&r<VreW>`;}Cb*(Y5zofE
zg#G#AzX-O>qkmG&1Ro$MtO@MPiN7E8sS+Wm&`@txVVCjP4W!ZUVHsCEclwHeUQeuw
zb4z)Bn9xMnfs>T_5*r@p%6VQ+>+U;M+i%9*F$#)Ok~i%M@8+Rek@`NqsH=%5V|MsY
zrYhWFOkt^q;Sdzx5~t7=XtYjXr;6bZSI!&pf;M3LyA1CnHPl;leZ*T>V+1G9CB(vZ
z)B>7c>x1!^%GXN&Nw@<%c7~$UPIoK&5I1~L=SvXf&QD4;dKTRqtNh+#n_|w~R2v1w
z>hmB@P#!bjHBwcGEPU93_O+9ym-{B{<ZqmRINvF#<F76vGWyRroP}EIzr(;oN9JSL
z{oaBLuOc;2QOLL715o;3KXmdLvhE`;AVo0Qb=f-cXUd*JkJUo)>IXP%l|OQ8-eP)*
zdKa(G?&q3oVT&a1*zAzc9{X<mWFGzPs3g<1zeXOV)!r79G4VqZc*sI<MSt`UgjRB&
zj0VJ6I76UcsFQWO-8tokl5k1C>^%kHKbwd)mUvdbc%O%d6-(;InC?TIjvxvewQ>HT
zZtCC{W7Qo56$d31E$3;74{Gz*Qw*(~lG!Ea1^xABO1Q$EazE`LHpoyrM`+UDB{p)|
zMSEG|KnDQ$G(iZ+*7G(_VDvYlI%XUs%7E-rs^mGN`epr|QgVzDLK~+*E3=C=5>2d#
zJ?;2eeG})1dS40g=h~t_$!)Op$($2yN=X?7nKHTN@t)Z$a7&26b&suix)c3zu-=2l
zSa!Ey>}`akNMikH4X3c1GRl3mRY2!rC!nG~k*U+eH!N;qy*@~}jm}|Ru>9a9)Ct%5
z{CErV_G{M2N#h8H^tZ)Laavf8ZN_{%owIZnT0T4%+rU-r`5(YCOvXI<L=Xxufi~?P
z_r`H2BB8O`>wydFtcz<BD=kV-f3k~=uZ%nej<d*9w@H319vMT=CKlgM76P$>(%KL_
zz9D>OL!@{kb80PJfQt__b1Jr^b%`q;IUk1NUU>RHVsa_&v0L0`Ny(<#r%kb9!rK_W
z&9E(F#CIkh;>&_ro>SPsMF*kAnx>$WECp;N@6Nig4T#713nJS{#S!t_<v4pQXyQk=
zhA3X#xI095)B4m2N1+8DQ{HIQ(0JQ%6b#c?*Tt<Iaa=ws?RW43&qxP+gt9Y=3_Iw*
zwb|hOu><OX;SP8seEF9U)WY-<8BUGi3?lQSO9S_y=u#FkmcoTJRH^uhs4U()tA+jw
z3ufaIc`|JFoZ?(++@g*MVJ%D%?I?i;{{TERs)5sE9NlT5aF31XN&9=v0$sK!hpWP@
z|3>J1zfAuZDg8*~8HMjH5<c7}T#18SAamv*;qP&Lw;yp9lHr6GZRJasp*jwyot_g*
zCrj!yHPG4l9k3T<cpnbtsrYaD%)ePg?AED&Z|nXgyf|1#Ap64Dc;1qn%9{X>uz21Z
z75^(~TLSmDlx!BP3d9VemuDxIY)Y_JMe<&g%eECNC+-C0I`dLw0fAfoJH_uWRjQ#l
zXS0hO8C5!8Arh7ArylzgsRk~}>PvT3c|aBKl_D=QQdvS}COcZ6o?T#9*uL<ZQ6H|?
z<-j$HV0_0aJ!*vQXTM*r%=hU{=KTKV3gMRf-w;mUggJ6M&+kpXD?iV4-p$g^x_8-0
z^FJVQ<J#vBb6cU~4OYeGJpKA8z@_6~Q)p?ojmFZ!-ssM^yl{Xh`46W3{=qY#8V@?Y
zbL)+18r#fP>c)7T-f7S~h3T%hbvnL3%d}GdyU-kN{HpD`eKnikDSE=H=B2ffgXqH%
zo?xXk$F)!Kd(Rp^9dEt%<os?gPkrHq{fQM>e8?#C2$w`W3lEiZP-&?TvxQbn%fkV{
zVEAi<BvF?pSLq#e{svkg&_tf1(c;5hNMj_0)+M#gvTA87b37HmqHUPa-3;4RSlV`<
zwIwu=uzdRhc-Th5<fK59@ZDOv3J|!xr`B-x>7)+e6z0}Cnv*D`2dHj^uZ*ZaFdI^P
zA>bWSm)uC$bTr$VK6|`0PHzp7wx2$9yaz+%gZqPz<p}jS9T~#ibb?_JAH6pOU(Rhq
zDbP4D>v<_nv9I;=@+N7?ZDf35tLMX07NoK<q)DlWO|W=BRCmr0My}okvshD3Y^+wp
zDLfxpz+dp8fk$SNur^>)c25zj`}AAziO73z65mfuiYwJ6kC5yM)h^}KD?`eqx1fOs
zbS~v;aL4j(i%IciHCw}GUh&Lk4C7UexCGod`l$W)>uRSL3TwQNJPNp$cDip^^f~X6
zM?;#%Q{|;>xof?Pv>Kk<#lXo8)uIen_vGM8BZfxVvf&&{KaPhJSGD}{>fQuLXeCd@
z9IL-D$23GD*m5r38TtTdhW@IH8Ok+19UU3jcfBE2ZBZ*J56V|Or`@M~`DFRZ@Q;H2
zZJWr<;fsdAk&r9szSTST|3*Ll*&K5>k=59-z~*wjolx5`Y}a0$cA#3NPGk_4&$JwP
zp(vVn*R%$J?UW-wYY(#2D7V2Z@$MluUb&&MM^aB_)ZmtH)8ugk=C_7m3YWUy(|5UN
zKc3(DPj7m?Pt#>ep4dL~eybDJL)<bs>0%i2D9JL^EGp0yaY@m<;Z$DR($1ww$KgE3
z3DCZ}Nl3opP<&ZL(QI1xTjleGlRKgR07e+QZby)p_B5@Ysy;7A2Jt}!faV6Hj@j{E
z*<ZZA{djEQEcY<EOwqGB1PO=tr)*<8ff!_(>)dm#Kf-r`eULh9mc#208GcoYCHE|h
zQ*@Y-87NOAHOzsTt0*1<@|D`2asivih#)K%(45@{YD8|~nfYN<TgeK4;dT-Z=(QGH
zEFXUa&M7?gPtI|E!x>mvXks$4I`?czX7V}RyBh6DJR7t#E2YKDt>5w_!|N(LN~>d6
zdG#Lw^%n0YG}9`u7Mr8cce;e(Pm*zldA`Guo2aa#Aui?Ts2nJX1ssn`q3ua8Zdb?Z
z>^rHM(l1N$B#N3#4uzHB3&Y${tL#3RQcLnI`MsjnBK)ocyu7K8q5E{R+1OZCoj2ZI
z!-Qb(6VP1!eA-&KD!EjP7A*R7ImD=M&`Lh)Fc*(PliMWU$gfr8O8_9E+F(F)9)vh$
zEJK>5<RqsE%0*F_8T@Se*m`#Ze-Ntx$1{TRp?og<6BK4C^~Wh^(^lZ5tu;|2#knBF
ztx4I-TJOHjl?3?NCOL(0+hez0%O-P5B^rm@`~7jLjw=#+m^7#qnBrQy;&$W6=kVhf
z{<zk2ooKaGIPF}R;?}Hq;--D@Y1gZN+*(g>x}-FEc>xPKb;J{LhDT1)drfWHvo7h~
z?$0t9NpZhdBS5%>`>vPepQi<nQMgSn@I1cSm$Lqq{JAUQ)Y-*?<shcaM7)zWG_f=m
zhz}uZzi2O5@VHqU5|(u9v~`!e*Ko*v`5I4aUDNko(WzD;sIFQC!Un8qSx)k6g^TTK
zjo0J*XxohUq{yvXUhEGKBX7}7F4Jhsh#p^mg99MU!+vpg?BehHaNRq>#Wt-UtVPoC
zwoq(;7mUyEyL8hb1&K|+>M+gVuRB6imu)CfRhJc;VP)yY__qP$CwQ}zvkbHRx%;Ar
z&yud+xd;+@AHRMsyz9wlfHV8;xr>@||32T2mwJp^YQY~_z$wu#=3fKi0}N>ZaAY43
zBVg}@62q<%)*C8)q?-JA8*HSPhu<{mMs<FzXbTeD^p!N?ZIdXQZqYoi@_F5TsQN-o
z>CVGK-bVFDCv8U!He(Sgq;#`Rl0ARjAlH2N0J<5<Wz?(l@Qw1a`1t&>-}{d|*3IAC
zZ}RcIGS@cW(!d^n$z8Nnlb;$2u|w0Y&TdfQun*IRTgSE^tn6&XMZWZJGWUBog3eq*
z+V?N}{k+#%{C8|x{Ki!1(V>lkQ<8Ic%+F0(44u7cviSg)Iw+P_?xgj&5gtyGKg(@k
zr*2-Q01~G2IX--@<uvq7`#V8H!91pO>%E(4DD4fezd_XH!oDC8<Ni^Do}2%=dzzX-
z4^g^5&Ro04*^?y7Ecm>Z9>?MECu{(vQ~IL)zO%CTexOw0osIifRZo9e7k&8hb7xUR
zkI!)rpLtl;i|EZxNhkB+H-D2j6~*yc2Qv?QUJPebPP$~0N&+h;>qAr7&hWk&S(z#P
z+0KTC#)a~!zHGj%w^t(GoVtljn%8??XtWPP450e(X)QV_@3Qk3-+%&ETIMii4XsYv
zGo6`vnUC>&b9T=J@0GW!KfUoZ@Z#&*6&K2^A<Q9aqW6!qh<{Hc4OOn46eiP`m<W8p
z5u=7_cRpMnG-nA$buRv!gG47rAkbUh&SCGK&!qI^)(<1JwkP3>CarHW_|nGY5b3O}
zGb!!`u}O=tg2Ji6$~z@3uisCeDm-1J7WL<5<F%<j>zzx%lYbahrnf7R+TmAeD>Nq+
zbwRJSdmr^t$}5(x(%gLnVo}}Qw<li?Ro=V$`o~Jb6Uj`9$HgB%;iZ5+<0Fb;wX8Mz
zqlw#2A`!|SviOz-9X_=z)$EjGu#YMrINwZbdVcP!?XkxWkFMo=oSFUCe&*Y^eB_6L
z9IXzHoIsOr{|}=qD;s~*kzvvm@hIFUm-g2JK8EA_faCvxL+s;_a6C#9FQASWG{Xxy
z;Dvqh=t#UsDqgezFII~eZ^KKt;ptQ5+8rErV0us<L}M0glSA_xfZAwh{YTG{fitk`
z42ib;9vxW`)dZDh!fpx@n9U$ls+X&?-%Y4mc5p?MT&-1pcHD$E7sJ~X!F@0c)r*Jd
z|Kc`CCAj(^lpp4#<#5K$Wqm|eU+55D-^>1rSJe%x>KMk}%gMZpq#fPmRaJ#gum_-4
z``p&?MAJ6I<4#=1e7TNIXU%yQL3Pk)JRuq-93;#DFfVppoOW)PFW5Lg_g0QR^hyDS
zgLL>P&9O469_;BOMvT(km~u*~NNX5HemW;HS)o~$v!jD+4#(`m&^pG!YB>d^B|~ZT
z))Bv~%x-sElK6eck#eR(1@mI(^$IO_IscER`|wKoeg6mkVkvIixN&dAZEA{wiW|*6
z3TJ9s?zAjXP;rK%a+a%d=Pa}3z?BU&%h6KPGPP2((lYt+{(R5*{Q;cAIlS%{*L~mD
z^>{}0Wf6@jzD-cyJ+c~xLY!lZP#L8xX4t5(ohGn3po}h9K|_%gppPvr*}9tq_o;`^
zjz99Q$;|dI$|tZGR`}@$-J$h4bp8f*I|^khC!YqXBM3JTID<hz;9hRt9t^WtOf=?J
zQmqG6$Z^R0G<bD(S5_L6G+M>T2p!;l7H%<$*2~|rt9g)@r=eTfl<}%8J1d_yw^f=-
zVtrW4aJ^t)sF(uJ+#zLpAw{IqW&VV-MeJptt>N7m;LY9BqUz!)3I+dTD6=aa?YYg6
zN4ZIaGIRJ6t>S<a;Y#Iig7HPL3t1KkM-&0x?9p6+E+aR&PoUX2SC|7f1P4$}xw6}w
zp;0P-7bj*r*bF)+nG)g{cxiZ9D_n;Mmm;2KTrsX|>snu0tSaQmDy%t3`)Cn+cn!_2
z@F*Ulk0-lFOp>E$U39zYnf}Kd>?X40(2dC&V^O6hN?AQu)SjtBc(M7SmgQQ(4^EO+
z3R@SmyP^Vl!!<*t8tOFNk#zy}WVPYQ42iN5L;V_$aFx&S$MeR=3#BFB6>q6$4S?tE
zNvAE^pU9C9JzvpOR1v$#HngF1H;NYCIJq~|Uo*#*G?2r^ElHd)PNQ;`g<pMUN5!G!
zE>+dMr{NVAsF&1S^Zq<#<9G7xC$#DDm<@5i+MIl6FI|N$z=_?zu*`GNDdnPSWjjRu
zww?WbqLCw%w$d{t;Zc)DtT8M>cn`pgYG^j&?5`qF?}AaPD9VG78>uxgxjwM>B2R>O
zwZMHiW-IsX8o6-}61*mMMh$F$f*8!@og|QTX*U>e*`pSZv6s4;$%AL-D6Lb7YNjQ7
zv`TiSx47|E(KxoALM12f70k!TXVzRVXsp)~lKwEGd`zX`18sb&k?;rQf-~rK<|J8D
zpTp-}@`>3tcs*boV&?=u2bTh3$ghaS-pg8_6*TgZnQ=(P<3Wv%9d_v)l-Zap*K?Cz
zn!Pp;1vN1gN0nPg8=oZj-onHvgXs{{J#Z-jf*Xg#J@h<#!7I7IE2Y}&T$|VVhhC}A
zye_=+y7<*A?H?<4$~#@kJ44f(eAGLuSSP<D!vvxF$=9r#2*DFx74^GJhf_jOV-ylO
z?hjZ~MOksU;v57|X_M>HRWCiNeiHypw&=Iv?8h*e7XbNG2OF03=sB|{b8@CJ?g%A(
zAj_3@WQvrXN}I?-WOam7rtRdebhH&elp9#)$w#&VD5%eUs>cADK_x5A%f)o{TnRT>
znN$Jb<Xn4rC}D1j#&dKCUb4+@MW}p07k_!)SABu<Vy86(b2W`YQK#{o>!7IPp@!Um
z32^^1LD&2~rrbKGU(YumOi4!G2nI%{@MIf;MrIky9EKR|aVAdW6nDQ-Yqp?Iup8qk
zF7EI@+@t`E|K*qh*b=<jG{@lRWPxwy3Mnhj7*8V8pxf+PG2&@8b6a9Q)0bsSxd7}I
z=Z&fPsE|7pd_E&tp70iqMX+_R!wO)4?EoxPCF?kol)3dl5!aX*qQaImH_zsKJj;X<
zN_+jHbl`<Il-dgOhV##Z0pms#Yl`l9fcWQnbN_xxh~UD?SE*MxNb**842mmoFZ+Cl
zATW?KkC|l<x-`2qR8=fms|tuHBY=^iy;*Qq75uwoA$9U`cAP`+KW?%+i_2`EiOC8?
z7ZAg<G->iPeii*c1JfK9!8?+2b6Lu6U9NDh2qzx=S|06RzVTwg2#;Ad97rN&dJhx<
z#K$~KSJPD3gE4JDqttD`?BKP`{b2LS(8iw>J;nef2%eRk>~clVkoQ_QWHeazy+Y-@
zo?R_@zAsA?1;&Oi@(31$?`JzUK2~Q^*|Bnv85FsK#I6aDyw(ar2e^ParPH*W*ALlr
zX*sq%{U2W4lDG3Kh828lBCMt=&%J4WDbeNjK3L42%d#&!Ehej{5!|Ip`$F}cB0)N~
zDC$nNx4ko8XJp<UfV}Dm;(l#^hL&Sgo^43r;<Dp5`{Zz;IAhH?3;r`duGY1%<^%N9
z{U~QW-*&mTH1HEDdvv{+Dw6FSP?!?V=2TV?xSMZ`=e;d#5VD<(DXTaB$?ibQ=;X4^
ztl>IM)JWLM4k7j%O3q9DRGLY4^OVgntX^_BzjTd!G^hPtf)a{zzTm=Q(V9Yr1p@k@
zF|z~n`8jntHHP}wVL7dl{DL`1?pTA0nqJ9E9tl?>caUJ;reQih-QaIZ>kD?@lXD_s
z*?t=kuhx3hAAX`Kp=LUcBqLnKAKhtZEHm&c^Iwes>ag_y`qj^Dg$K_l17DtkNGeyb
zz2Ri1k$0`}ji0;Lz7ba&-$+j`oI2OCe%ijE{nU|Oq5=8-3Q_vg{pAxL^;!{ooQC6S
zUW$;tEn#3U<Emob`W9!@@sC-)l44(ZZ`Zm$l>Z#0b+Val69NV@cG!<@_UPj&1U8c5
zc6Rb2{(^I1Ac|tS7;Qzoc@od7rVjSS7p_l%<({w`H*lZ$DbB|QxWJ(<j)nK%7!|&6
zP(wb~?>G`^EUX_B@tkQ~(AAT5tSO|)bPN^$aOzmJ`V%$BJyS;xQXIZ5mC(ZNOnpS4
zj&TCUeezBJIFkuo{)8m}pB)V6aui@ZqO$)kohWwrs&2)|N61ehB!8DKgc%z`<%xUk
zdZuA##3CV!F%+rj%mHvywKR`mcyS)SP$38sJ#HV>7`9Ged%wjVMI+mk@%S`@1?_oH
z1JJN2zmXrOPV~QTQXFR(v-0P&Jw;Bnc|1&$KZ>|r$NORi3;3{sI`RRs$vAl_8fh>9
zLB|9~c0!)@YP`7E%x95zt3A&6Qv8wY@g}$9O&`aby@)^hA>RCZyah8J!<S$wlVEk%
zTonT`ZR~i!j3Jv45~ksp?ih$IV=jLIY;!h&=g5$dL7s6q1wWUe84krGN2fFsrZ5H0
z#9<8U6;Z@tRFfHtLb6MnPoW^Hk`&1w`ER6}yuM%e855Li<aleqrAL9{@WX}I!jG|k
zwymNPc!A6bY6`K5o^`qk_TUP`XZ@K<h=F{hZE<J;y^9J{d`|AbL_y5IhW^f1o10+;
zjg*3T@x)dScs3y%Vx8#0#m~bNw)8lRqf@Hs+~eP=F4POQ#kw(2e~mnRS%EPN-|V0y
z{8>tzJ$ZX^8NJ98D2TRfoBI2_qcHq!NwWXd^<;H9%56r5`kc+sH%6{Dm*zld=$5z@
z6X5NfHw4C?m07P);HL`kV~J6=p?;JAJX<gVo<Y^X4#0%<as##F+A>wDm3idCp}~D@
zr@ga$NzmRH=+RXC2)XBWHonVZlwg!~u@%}k&XZeOm|G_A<Ggy+h$|e<QdS`zDeR7M
zD6M1}Uyd*naMe|eukshJMgsid0G!66${QJ`bSfyR@zL30WwwG7#Mn$~_SDqGdqPP_
z@He6x{L*L6d}N;S{rvvEycZLeoK@$$JIE<DeAm!7CfxX3zGODO_zJ9jPT-teHs&>1
z=kwgj{*`>`X+&-gI*aJ7DgDdhO#hvww3jbp$en)d0gL?6)K8Q-=)GP30_L@P51PY0
zoaEv_J`4QYWbpdD>nTjSz@`K1z{79<?N3fB4o88Z=3Hghg1$xallJcN@&KxV@4x1q
zyfNMk>{kSE00Z6tOXM;BBZ`qgs)E8{aMk}#No5^Ggqq?MC$DIo7|K_T4|6Pb%gW5R
zp(weO6<B@hN7mq<&=lIf#vAs81I4(!)xV<O9L8N`$pHt;+5^2M&ej5o^YI$<U12Zk
zoLZ7J-`qL<q1g%d;`(UXzHYTb+_o2xHru==%z5^PWPdprGAD+5VUgA*knR5}nU53=
zdLO}`Q}V_-^zhpaSMH5CJpCq&&$&$;Ae|^+u6sNba3-bwpiD8HHOdlu(k2x~%_k~^
z-z7#-3|m+~^N$!1<8qj0X=2R$>)XLE+Ao-%-HiP9^{=R!_g<<+^(be`v)p4d%}WPw
zK69*kIk+;ZJZP2X2K67{nK}V$5g6gQ#aObCfad-{yqov#<(X=V*+|grxf21l(|W7_
z$W99US-4UIz9VoEpb#hQBF%3<=nP0^&0ft35{52QjF!vl3r%;{rgam_hbpuZd`5j0
z*L`I96X!-OuPRM-iU2AFOZ=fgqP`)gv}|CVn=U8@i$fMn$sx6vJ@pNzXY6iyUo!IC
zsSv&yU>l&gr2o3iz@J)LrvIoH3ZQo9E>rE@q7+{lFEKStoB=zqXejZFn{U&Nt3f7$
zreKevX~U%mSE$&o(D-M!eIL>6fa<4kKyFFa${k-oIZMUgq*6kyfpPx#+Dfn*wxb*=
ztH*D?E2wZea??Ed9oY@q#oYv2j1&U!sv`oDmERyw?5$%UVb=qjptY@Ib(QV?8&B?B
zIzfXW9D|`S!RagZ&gTLGnTwZ2Petjo6`Teczx0-fTM=?Yeu*;R1$^~Io?Ck*V`ohX
z;*;%BgN#J&%DGp@0g??tFO`9Z|LzDNW%uj39NHdwXIH#hdUJEs=wns)bM@F@Q583Q
zAp9tIR)Z5h3mQa4;Xj<0O8tv0*_}@B;CIv8X1-!23w6v1I{|(Nwk`^k{B9TgKBctK
zrha$ODTT*=x5f_n?dcW6ZP_;cmvisjS$(zPPI&xunenngXd{2oIq_#$>ihJ$sTmpV
zp>B4&3&>+TwY#t0-TQp~H+8}j^z^0kwO56D=YnNx%L61eZcDrA$c}(qHVa0ue!%^F
zX*bhReNP*pKFa#4#gBvXn~$S>IsW(*eroF9nY|$9W=1)knH_Y|=6ZDWh%NI{o<NG+
zwAp@CW?`k?$;}6UzYjka(PYu&v*tbS{L_X>O+p_`=5M4cZZ~=1-^LW|t-0`U^bhGW
zuJA?E2l<ycQ2Z3v$_vT$d@XZh%ux^dxDn<VjVnGm%&vH9^xOK2`&3(%9c(cx=|s#X
z$2NcntuD&Xkdz!^QzE=<MSyjvR#hBgyi*)_$qa67zhh??6soVpfcTR4zz=ZKSthjF
z6g5kT)B-|~&fTf(9CbbM4l3IWkmKcun|zGW8NsZo=f_paOKpUYneu)jC%=`K`MWk|
zkrk640#%UZiWtYrP5a15hR8{L8Mn34Ej|?#qM#lz;Si)-Qt?(n+4ReVONMS~ous0w
zL&TF~b-I_E{T0>yzC7_7(zT7K!G?KTDSy_SDDll#)IL8^k`V%C1u?Q4y+w)Oh{NI&
z{x=O;Go;W7BZ#~xhXUjIYrpn%E13&X9Q?k6#mRscz{9_|*+K3ABu8_ia^#g<eso3;
z=~d#8uZ_X!=mPw*Tm$t5`l4(;aW|fSe(GK7%BV<b)U^M(d}VC#yuvnx!tK{N;_Mk~
zRzxbY>rHV3PM2Tt58J60i&nAoNr9!U$cLuGIa(Tj^8GnNRc(sHJGdkkWrPp%4{wd?
zoa-Ac18O+)@L2{AYPtQ5<%%sHC@DIuySs=yl^LU9O~44gW@?F6b`4n=(|mhjSKUoi
z7A%Goc^IbOTmO(6fd5wHX|7vz;mifK0PS*iahn^4V4ex{Nr;l|Qv=POqD%M=AJ`en
zEoA?kJ8)4~&@k$T)EyMl8r?U@Lp&l-$=RlU(srJ+pF+=&lePZt?Rm7|@S|M`H%I&7
z;8hl47(G*C=LR9>b((J%W$cEZJb!<}hQWw(?Sy*sCQ+S?KU;r%@O%Tz$gx&hGuq#S
zERQcX@;;&SME@Jvz^vipCfX_<Nogy+Lth##8!||k->?U^a%q&wDp@;ayoAuBwiQS>
zn)QN_sOPb*nk*{Gck-V&MZ_z~o42S;l<)9=xVrc8)^`p&OV{{Jp>Jf#e9r8whqWKB
zLJb5~sP?RUu2)YhT2$dj(RmW{tX5^R3T!Ydz;UFw_#HM@&#BE}Xq6}blc$n{I8OJV
z^D+Swmp{}Ll*g=e#9R4%^dEv>67VTz>y9YAr=K{X1;$*`3@Bk8f085^VLi6u`lo}F
zbSwXQ>!d|lap8=iJlY~azyUbWZ2;>5**d;|7>uMK=`|d+Sv0tu*(Lzx&n0CCCxj}E
zAhVSl1$x>r^2J2=la;2=Z0*D8%|ktt#`n7}31^9m`ym@SKL(5D;_2m}zOfVt>0Oy*
z{l%~2w)wwM6I;{IUJkX(Yq*u&IuBJ*7(-X$8CM=}Hp;4vP9D>y1n0)$&PbHjaOf6P
z-8xH?>o_mDrIj814V}R{{-;r7!HvaeWL;<a9{Q4fahCO*EO*EhSZWIeH(r}7jxaZ3
znXt?)vb@<6=LzFsiEmrkShHn;>&7GMr?>Nh%|42MFdj4gwtb0gwjw99kC-H|<9#AW
zuGV3dS-WpvxRs_yI8;HBKgUM@YT=R-UHi%1Bj>bXym5r#3as2N_BK@TUO45xowUpA
z<YlRXZFZx@fe=X$if^_r%ivDo%4TxihM(wP1H(=MIsM>;!<up7hR($H$JHbqJM5l+
zlIrV$WpM^@4%m5gR%cz2`*!2Hg<OC*)_Yj|m4KamgXQDV)?uOEsMe1KqWcrUWUYO8
z)}!i2PC$N`;@5GxOAU+OMM58MshyofZ!Sj)Ts@}n5dOkAH;{F>`h%-IoBv4I5G<0Z
zpl5#jM(Ht6abb>Z1w^~8xg%bHJs~_q=Jl2*F5Rorza^wiHpdkpN|Abt=YGDQr5ilI
z&zBTF`(wTb%rk6BosEVGEKBDfA6SIrF?Bj~M)Q9btk@4G^DJ1YTGhw!?jW8Na)By$
zfEiX{@%l5KA#bAJRabjrIB01fJCI3-iC<y^dx*DUgN-2)eG@2r_4YW;-aA8wdq|iD
zQaTv3fV%*#M6O4RW{eT;ES!XYfkhAYWzz|bqfWi~b^vswFy?va0d`Y3FA8PlPOrQ(
z2UF;veEW($S2J>CWq9i+++Gs0Kw*D)p|)ka+Cj)NZiQ@+?{mTja_8#_W{Z&J!xgMh
z7v;gzC3|;}K7C9N8mJuss#O_whC2fZ90I)g9&Oe51S^eJDgg=BRCtAAfKj`adioG4
ze~?xTRs%;-re{duE&q>5m8co5G8mQJbdyftb|8TQ4$2+MuKgdBs?ZKSazK99iIc~O
z8|h;;3AOeymhwUnBNejZu8ePoja>Ng;2M9tas9?VR{sg5ZEx6wVks$`q00>h{K*y#
z#Cy=}$pZ+YnNF*!SGT%ufwGd>anr|T>M#b6KmoIaYlV&_UrLYhH#%vUQFS)4eg8SA
z5XT5Icc!fZbl@f(%$)-@V^{{>v&SQ>NMB}{*Eg~HfIAvT1lEq56J>>da_1kE*_RHR
z$JFAX*gfl!G%8LE3D0ie_M=$B3(2aIAMP(TI3GfOJf!Q@xX3j6TsO`%kc2y=!W0np
zah=d(_L&acPb?JJ&4vV|7Z=ydY%f*WnBia9_2J8*qnpSAG^OGz$@9d@(9vIo2DD+%
ztw7t(QQ3xN*~9S*|FCPBpnx^77-jIpr+Oir$NvP>VGA>Fyd%n?v>dZ$r2;1#R)qlJ
zmM>bRv>wb^bX@h-z@|bo6!mQe5<i)zhK27ykvP~=Oi2ReqjB#4$kQ@m6ClHW;AYe`
zEcy{ee{a~ls?6g~aY&656Ii5Iju*^aE)hBiKA$RUS?8oT4$9#f(mB9BM0*1CT#<%}
zwHmtMAz79<E<2N<J2#?3x6(uh;k}o>&1c@uIhJY+X+UDl9mDY9OZJAIsawnT`Bte^
zPrUeX-w=vD7^6g~#dE8iK(1Mo$~vgX1RBT~D6HB)c=9b83kp)s_g`}$g_(1+PSo7w
z-a^7hY-QtaBrq=h?j&23<`9I2Es#9Un`FtgYwjQtY>93fHKM}Gy8S~Ib!89uLspA)
zMKP?O=g`%cZ#;z#u$WS_){0G3nAW$tJB$%CDEV6>ZsFgsbOT7d0d(yx!M7pZs}Spz
z9%hh*EB`ahET2Z{??4q9BP#<?<J@533@Z(8tm$*?^9z>OzC{G@HaYBq0vy5AE&+)Z
ztb4wd!|2$T#9E;SyY(B-EPw_AT)~o!G!SE%ylE*p>VQ2Q{$OpByuxPpAQ<p(aQtbR
zN^Cs00Mo=<Hu{4)_Qos}{P6IQ3nEneJ5YVf2LtY4d{nMO|AMbEHhI_TnJU)Z(MkcZ
z>N><~<1*y+H!RFfML(gNuMW3#;rLOj5?w6O)GE~*>p*L{*H3@h0j_JG4k*qz-WVK|
zw3H@ECbTwsudC&=kzj!^`W{*2ZTRCZMGg3<?-axinni04k`()5f%*bI#A-BCr1aUC
zu{qGh>5ZU^>WYgw+x`#_q4c}a-t{pM!Y_&u<;8DY{*&f_U1LQ@_n|7V$Ek}&Plkqd
zlZ2kHN7V+k+;4V+cVWHC>4vzGm7i20+{kTzdf@8}@A1K-#@@iwLNqWSiW?EegHCvV
zrnkEqn-LsSl%<;KGIN=CeV6dfl(Sk_N2Wj9zg2d`O&*=I?%m{jcqbFB^74HbHrXFy
zxcBnC(y<RB(u>cbD0=pbhZG@vW8WPd<X^+3O$7&HMnI|xqe9>hk$f47GWkYr?obJN
z5USHLDp~^xpoaqoVE!n};HbfYPb`r%gAfir!O5=18{uFUMQ0-wyS3uSEt$cMpPZ&M
z>l-Or-%e6n>ElAj@dp`2I!#dkroy)#PtbNr1(m+qtRA8ZBdJI0Hh%Y03~EZjL0YOm
z9f4#kVRw)$H<#loTtWdW=g<0nSa+0Fh9tpkcTk2Dor+j7_l~}Gh;4h~Fnef)Y_!y5
zXqxm@3O9np!mW}WGsH_l(|6YMJ!=CR+wf7K+NTf&<Pdd)y*meIuLKcm9L(Xt9*N3$
z6abQ?k43?N<xj(=yOxKW={i;Az8b|!k}^L)u`4?iJzVCUiw@8h%NJX+%l;$kt=xFG
z&*lgM8q;~sx$|uk1%<G8x^_l2#~J^0nB#DGc?m8ZPB#rFGYbvB2*XFzkuLZFY+q?;
zqWM#{_l-bT=!umHGyP}iU1#51&mAdMhs{-bKTf+*$`rU{;a(nO!{^9GI=RUE>j3*Q
z*-GZpnniwuZyDQYe`jYy6Z;T_)`c~HZ!ejLQ)2^$8Onw=ibrrw>gOREMp+u&P%#Se
z+r@3wk)bpiGOunkNh7v#(91Z7-fQA51;?5vjA*ZrwE$r5KUFkc^8lhnjf}>@3{yk!
zt-`;n3q*n^jwVmphYy->lEqpm!WzS9ON0UrhB&-kmqX{UhUJVve&*0sO0j#}49lZ%
z;ZMWsnNWo)ai4^ndfhlB$y43`hV27*vRBAV9b7En*t6lWYn_J^4sZCq+odWzrDP12
zTO(dVWXKy^g(Dr1Ga$>3m&HG?7p`ZB_Y9&Rm-zWl$(O)HtEObe2fI5d;wUTWn4W$T
zF_=KUGW|b8l-lvx#K8Top96jH`X0ozDgh7qdNcW0z+ifMxRz;4mU0xNHU=>r`*VMY
zY(Y65P-Ln7)H*xF_S3&%<JO@w?TKE@VXw0y|3RT;jfpHMv~}iqc8}!lpsRdRu<5U0
zY*L8BuaIL&p?<$YgOkEe{R)E=i8I_}q?SMHym)18Uz305dE6ZpVTuwRYkr<A0Yw%P
ztR@s*{zrta{q%!MC<MOr11g!Fn@Lp6?7@vBR-f<vcBpxs;aLQ2p#UP@YI9F<nluQz
zC+0vasxKD4t13Lm$S0%T9s?Y~v5&2LVVM7jP|OE&dh3}<cX=Kof3!ywm(h=BMk#0R
z%75khX;&J(bk=W%RS0DYGs-M5XQihc<?kI!ynY91kbJSEShz9%3EdwkdspDjV{A$n
zpXd&IPElf5vC0a$|Ey55c<Nj#bHQoqw=aoNc4O|Yi1n1Ev5NI8_kS-uw(%q`8>PR)
ztB)v!(;1>;*yldK)7}($Nx8?+r^1Je2=s)4wCMn;mh2z+-gl6&fZ-;CM!f%LbAQMk
z7%8$D*%2sE;K$BPuuIYAw{7IvDcnjvCJ6~3={pWMnIoTw9JrV#(={`b6s=Q|4)!bV
zPRmt^A`gd){8R86EFTn`90PF~rsTDDZ@wC>RSYb@o|1RcHb(HATJK=WK3TO@H~`66
zHOvc<i>^NY^xk{>6R3Qzz`F`XcWNAd-?}c4@@Y6DAU<_#y`b!@It#4DpK}yS&)Z9E
ztb4}y>UViP=h<Y@_LkzpI}rXgYktO@IWD4*e#D10#`hqR|G;}f$lDq6r)}0Q!{M*0
zrO!qE9~MIQDee;2uUhBr`A~^by+3~qh#B4bQBcros^*a&Zw;;P<!$EbE8&_Sf&YIZ
zbdc#>^{dt8caip4X&sk=>uy!vE~nJz>Q3IPIQ7I{LrvxV%mqF@SstVAVB6%_1Jyxr
z(+bB?g3zVK3=2Bs-W1NSyU-#WQg8R<v}_9U-m&y_?lU6?DmNsQa6_`m-=0TtYW095
zXgheJf77S_Nq-4vKl5)kuh@(HZ|;(t-(!RM`lHG$B6KBb;r_oj!x!F8{(JlK!n-&B
z-hI6Ae&eXgB<M>orLn>Cb!DXlV=&g=zUS`9g%+G7<E=<k`ZJxM@8h#2k!?X48I=f2
zVWHu@o?*2AzhMLEw{sOMuDSP)y(FKo4#t4x^hYZl9wkACVwx$cK%P)vzrERTvu#z%
zZ3<H-A?0jxzwf~vd%9IJ)JmE%_MMd=;Xdg1XILQ|R6WIeYAVx!ZYf@+pz7_f*ipmf
z3w9heeO+s+r`3nYSq0NU;{KaEXU62p3Y37n;O$HyVkKQ2k1vIc@gwHhik2ZbAf2-F
z?`7PL8rgI%F~fvCL=Y}VP}Q?1nLpU3K;lT!?jC>0cxK1p{u?j}Pg2_l_i&MJt!Sr5
zeB#*6wheKvHck08)8tSiew_~_<kO>G-s#_i;!p@u#mK0GGNS9lCRN>=sLjVi!-bmM
zZh{1+bXggLn4YYlM1i?aC!Sq7T;c9LFM8(q!}I&^rLMe?;a9c30afV>b+csokF{R~
z_g=W3m?%-*py0GIeRAjT#+)j9QMnKYqG<lT`~8G@a-E%aaGx*n^NZR%MGZ-SR2suH
zWAB@8EgLxgqQ~9vqGU?kYVpy_3KS7QF->u`RZVrK=rJ&6-|l-T_2Bq_eWow3@iN}a
zJp=DyjWht0_mN|lqrT@aSX}MfaQU76STX&z;M&nZ2FF0R;je95i7cq9YRQ&D6>W%9
zwFhDl`G}RvlH~kXnMNe2FXttK=ajf-NL{oM5p}Bu)EJm?Q|sXau7PrOsBYMG2GrzM
zO$veoD7~=k10U~0fNI9&A$^@<QXsSvAaifhRyO_0{K;!-{s#h2(IYd=@bWL;Vy7Ql
zW^`)zrEa3?8;GM-FNd_v(nHG<?CX?yAF}XGDNQQ=RM|dM?v{e>bj8Z`1QDwl8EX)6
zW=aqwETp-2t|Zvx6jZLh=J=ZA<rz0sXib^?j|p2b7w}$ofj4I)uI7ZXMx*etL~AW0
zpuJJiAabYwzcx^@R;sF{Ut`sU8r3JN+OWu9^C34-Lk>X@<2#M2E&h#SGk@TVmuLRG
z6@HiS>L-V$`Y%)ir(8G(@w&Q3r#2}eLGp$|<LiI3TBSAWLzQWZ^P5^_2ZK-(xndoC
z(w_v&4cVM2`v}=GFmZ1=8!|9gSZo$BCKCuU7h5frUl(3V{jthK^m_5}HzH@iu3{%I
zc{{6<G?@`8Dma4P$bt!UM+ZQipZF?!qdW}11~~dO7QUqME|$McPz@iidU$wl)-r_`
z5cujj!DAQ-?XRm!dtc7E*{3W}c~Tv56rp{@KG&uO{WNcHDlI{5MmC@QEdD!CXE*u%
z%V?kqf_Z59+3=p`<F{72;-KIT+}hL`uJky56)~XMTTjMS=fuO;p2qB?JoQ!jsl1>s
zITTuKNJzxOg{a=7D8S}#^(qj_xA^O=t6#5dbPy%;=h_X6!pqqCslsbE$<C1P3Gew;
zr1Wn-emf=InI2uWyt5EmTf9&^eO(vY<-NElbG`54wX;*q=Qn@9DM^#fQn521LYuRu
zMYUcp1*9Hs=>vUBu}|%>tB5kalg4ypU`<Uxdk6QG6|6*T3^Z~YMT=Rf7cupN14Er{
z)$eYSVW3*L-8fCVhRs}fW{KBA4rYuR;x8gWmc*?n#+V^~gXP-U1t7-}vy4zIb(C1g
zu&r%Tay=W$uu-w%#v1(jfkGdVW6C)*3gr9<_mAT9jV+=2!4ir-wxBoOwx;j-FO6@H
z?Jxqf%?|l#=|UlRd~KeWeh``Lz9J_!kGC}!C@v~pQBd`<b2u(gQa-bybY$Mn<)T1o
zE&ZeL8iFm~paJe)MSL;`j5zg!a{T+i0*~jIG#km_Fy8bV@*#E(u7`2X2?K1*A<NuO
z%^`7VD;^Wiz)ak?ToD`bkFpKv1+H5-WVb!eGVHf_go#2WGn{V7oN^*wE3u{wIAXmA
z_2RWwkio}9?H;j@q9undBH!5EJFtXjjtt5E9Q4EPeR)v~2vu|3poy%<|1V|xZ<DJ+
zAwN}<Vkx+dFA$ow=6XfqM{Ik)w<sJev9Dp{jl?`tkSxx!p}vq+{%33N)l8_&Qs!sE
zNy^EuOM%w4ATF`d1lDb+_ZoYCOPRC&_!8fRbp?dtycNHFu|pp2m4f@vY>zVwuRhYj
z2EG{NXw^(hW<sn?^j@KCMl4S>i=H^eCFUp}Q=1>SD<@J+Q_qg9%@6AMSZQX4)0+<F
zDc*td?)PP5UT<HDht=@+l3<!aMbvDCq)t%yX7Iy>`H7m-XmS@g@?bFYlEG7cQVub$
zq2p#2ygt;oZ=vO!AfQ^-df}(gM}w*-C2Gd<*^k4sB49&riVubjc=w}YvNwD_+lL9|
zT6!MioK^<tfnu}BXXdOlq}2qgTbtf6jjbf7w`LzbR^iW0u4GE=u^J%9)<%rYO-2t&
zOSQ|8S?Etie80>@2R<}aShNqq0HmDsp)B-tpEwZ3usq`H?PNNRqUm;gbOVihyqNLg
z#_kJA2=flO{_cMB-r0sJKF+h1>+=^qu=YBvkK=!n`rPa&X?uNV8Od(W#fQrt#)CG%
zT;Sr+*0^nW6}v>4h?8>8RL9=se1l)HmLeza>AE3poLH7^C~jQlbPQD}Mi%i%b}SzR
z$NiiBc*!0QLiaVEs67{aZ91pmTFA=RV}AvBgoDKx7gX)}0e(1ZK2PNKxldNhvMx_(
z8H!055nzjea9OEEm6rABUV$~I(SxS_$OXvn4q~VFj2KO?Cr3t;YT~N8WFtR*h(*-C
zv_^;UD_YWJ?TgiW7NM3PMx_NMT>|J?!YlHAyrx>RywWVbuqpo3O0xE)moaM+N0&eD
z?IQAIkA`?7(-k5`2oBY)!rrQ10!OAcz)r92P6Xz6HMK}apZ}r2lLv>`6IU)JH@YBO
zR8ahPNTa~G!jTsYXN_i5rne*eL-@9>xnwN$9h@Sqdhfl38EfuoO^873u@avqv7On&
ziie|)v~Dk-JXLCz@cYU=+nZPPk4~N9hfA=!g<^S>Gs%5#FYZJDiS4>v4X6#wM+>!0
zwFaiV^fmFHyq4Rw$Qz$ze5NOxEOtMXryZ4VEqiX&Z)%vShr1=`$t%&Lb1JGQ{iN>}
zGJTanec3U1=P_`^2ppK3Rt3qgroCOv>lb~w_j#V^m1?~l16LRY`EsXYLnPDTz2wha
zN#n!9?oxGZrs3!vZdtO_45@YG`tesF5Fon`g|Pu3Km!1zfLCBM2mogS5V$11qh^o{
z7i8tA0hl5EPyzcYd}rMVg(Nv~Z@ja9>=Fu_D{0r&Fj1m%tl58}>&E0&bZ{M%03``k
z7)o(MV?vP+QkipN>TY^Uicz2rpYw)KXRema9SWD&^{x+Kr#cF{p7gfN-X;#`N;w!t
zVY5z3tUnNVR@0+~3u61hddMyAACA`Q+<SJtvx}siWtZjUvp7r@R6qW-PiMZ$8vM3Z
z)f&~5w%<M&G5qxe$;0HtF9Gj}8SMn-uS`9$#O7c+X&LnH_xHJtH+}IN@1L2*_@=KM
z^m55}h`fuf4Pa|&d1>#ScHZvSzc;3vYWEpW_VxT9-v9l5aritlTe60aF$J2TvkE5X
zr&IfCToh=6D{J$(>BtrX7g5M-^9aQ2yy5<MEm=#d%Mk@49FxdE*r+T~gqnM3z938-
z>%!*9$N2!}U{94rZAw=lu(^lL^Ti4MxMV2uGci9Jy5zcKKO1%SW1-ovHTjIc95bBJ
ztiKH(-JYVI<G^p662su{ilC1PlWrvjq{TuOv;X@4aEyF$;9YFMmmBe^JpAUqurC+K
z%w&LP%#<_mHZ@lCoOZz)O=xUxH6ODH?O1j`Ht0QN2;L9218_L&!U~zyajAw<&&V$~
zgug1E0EPhJ0iFH5W47X-HN^&Wr=Maaj6&e0&OqlT^JL`}VOe34mOhN(V7@{0Eh6jx
zQQPdG{}~VShYZGDl~4F;MUg!_DCbpo_TP_u5eTe**(X!Z)b+%h8f&N~bJus%viMrd
zxBksvHzO>|7*||?&r$p&)gJ4hNcD2#>2-|tgUC?lvCUzpIF8;VMa{oY=i4zMY=5`t
zLS7G)^4Kg-c>z>o{iiu{y4i%=ceru3X4<1`qV+r@0wmT{<*Dtb`m+xNoGS$yV5Ut5
z9|^)=Rv<3VH3w~XF)bX&e2^<d8+Ge89w<f=WPE_`Fg)4z^R?uS)n4a^jKrr_LvuIs
z9M4_UL>L}EEwM$tcR!_K{qjf;Z4!Om4<;Vbz+5V@nAt7JD)ARRo&1`nsC7c@Q=R-9
zi_eX+FT<VGv>0mFI>!o)62M4|4wu)n(<)^*JWZmrB-{V23&~6dg-4nBel?CFWae3H
z`|nkTP^Nkdq#hpx7g)dE6U_g1^Weu?|FuOA&Ew<_t$(|QFQ?!Nv8Z1#=@7!FqScvf
z?Zds5t7i`P*KXZD{IhxY`{CcMF>U6-?(7-nzrD}5nTH3zzcZNtcMZUf9{`JQk>HLs
zV9{|5^f-s?=^BUx;#0LbUhcf&lo0G_oZ@#y8?HFiFdJlRpeT7uPPud;M10(8yYHI@
zB!Z&9XnFN&IoMBkkZ#Z}OA8Z{7a|%@BrpYbhPcF5GBy5+W7X<R<=L{}adV>&z-V4V
zatrnSGIax*VO>p(MfpY5BF~e%bxpoFv57rdaXUtf!M7{8VyR*iSOkwqXrX!oRf<oL
zswzMiavln9H|`n(;JP%ar#UkMM@DTv+2kNOSw{;xRCU^*zz@XuV_b-+U73|=`XBbs
z_PV$uhDA=$Bc7J1d0HW^OTz<RXrWY_iEUK|kRhvZeu2^ID&69K$JGr<JI8m6QOYU)
z&VbwRYiVyG#5Xn1l&l48b4p__tKvSPu*FWD8X1Na)LP6%*|F31D`hPYCaf78XcLhi
z)dlm_YA>!x_w3haW$71Nh+8s?G7+`>qkU{fS6sR9Jzb}>kv2d^5j%P98|uDbn7Z)J
zq=(j2t-b%Ms#Bdt+MEN*qwMM{{d2BLHbVJ=1`&3yoY>@kAswlx&rT@IO8|u&Q#Y7D
zV*?VhT;m5G&#|AUh+nEhjUZW9KxTgkG!*{|%~a<WMxcBw-TgAk-HCOxEM6Q);q<Yl
zy|6IP^*HOcQsGk2WFX999Ukqrg{7=v78kisJx~L_08o!l87``{2x+giTN2mq@dl8r
zkPBNjl?ZD@<SwB;`rNv<@)P?eCy~J0JsJWReCWkx<1&(wa7A#;)dIYT=0<{?jnRF<
z*U~!OF$HZN$Rh|Gb593YKu7Cc7bB@3gvu})@%($`m;6<p%ij4jrohcnA1_328~aI2
zh^~89N2B$J9<A`XUSXS*OXuyW9TnYs$@@|Vf796Kv&TKtF_SxYtL84Zr8Z5|Gg1cy
zJCLI-2bO%?aXT^-9c)j)i#*G_g1imY+33YZ#EkBp5by--c!|7Mv0F!;f9j1$zw=9h
zBG6$)pR9myo!35FyF@lVz~`RevYYf2s*|{OJKv|+IO@|1r~4^}_-dwD1k~^tZ|$=M
zxuW9@#ClGMs*h>$$C-rF@kL|8_!7k*A!_l7&5L=F2`+B=exI;n*8uyk&G#Mlq@4;k
zM&c@3Og|cah+>XZyt3mrX1}C<J4B1=ZLKU)lvV1yqH)=qC*ofqj}{%~I>Qft-$m6C
zIkwfH71nc|=ST!^%hyCPO%9;7gWU>M?*Df$_CkQz$M`$D!v!{pH{Lysq|MCLdIXHR
zpH*Mo<-FSO2B+(;6^S21{f>v$X0CPJxBT8UkDArL<9_?E7Ph%$)Y)mw{M(;MuXZun
z)7IL!tMArNdqJNINKu8QGYfUEQ*J-XkFt1`Qfs^=F2QTrGqV*o<$*QH8L`p45$wON
z;r6F)(cCUqHt?!PNb;)>S(?^f=N9<izj=fB{@HVEo)i6+!Zo&)uX{o+)96`CzDUu~
z|3V0&DiBARhlx7Bj^(8qb2qECcF8`A82cKDcyigbMXW7KKv#cg8Nfqtzu9&z`|xMp
z@c9v`=(g9Ny9|~IUaB_}cbYFGLnO8k<Hj+2tTDc}p){qZ0n3A@?k_GeKxnqSAXlyD
z&H;6ow0hs@RiD1V{QLEaw1J&Bs0srkNf$8e(3*9>ja$Bc%RbY0um1VomnUP`y9PGM
z=dHzZgtq5zdOykDiRF8_Dlc72xTT+vsOY&leDC>au<u8Sc+*?vE%ZCzHd@+N!%FC^
z@^DP1V`Hy9F}}a;*29X>=X=X%8+d5rPzBzplP$?}@_sa|G{B!-^>ccE{qXqGQlWtA
z0EoYk3S~+jL>JR%A5NEL#SRp_xQL(cznG~oasG`<ntgTu#ZRJkhZ`@_^p5_!I4UAg
zKAQ#&*MNJG;AJGvJ`(pFiFc2LK&A^Arwe(fizKHbkrvInh=hSevAuLYcq()o_N0UN
zMhWkvfhL6Czq}(EwU+_xT0{8R8;!zKlmtJ<Af6Fn=s7YwG#()Ef&;lu18jv1t~8Wj
zizV-6fO9m)L3Ww!mW+WYBl=>}bc)D@iioE>M^=n7iE9>XGh*LsU`$cL7Jem&tYIw(
zC?Ih?L32Mua22Bv2l{X~G^#2N1&xLG)^Lw(adjd%O+Lbh7kS1=9D#jQgObSK%pOTx
z3=Hone8l)1*pfX#hm+?ftX?0%#Hdr_xN}5+@(_=iMYE)BUWg^z7gFxC0cyv%R);7M
z4G7VQoFjsKvjZ;nNMKMH2xo|GGg1MB5|hBo5-A?)+TZEQxTJ^}#z<_$a6d%zT0z|2
zV<biZ`?A5j&b@*mT^}$AezucW;+W<&5*Y;W-Dhx_2?CWwqc)81BuP`#N;%w1G|vr+
zU*d_ijA4>^*hZ6hgE^Bdok6Tf$<EBhIocJs_{-^VGZC%?B76fQ5kbnru8K*O#N!8f
z{n3cDT5mg9#BPJSpa?Lr#rFdpmeIv`w}-oIn?1CKEd<T`mq|0?y;t(<w?q;_vy&uJ
z2*~;L72ap4Gf5oda<Cs6T+mtqyC6Uv@&?OBZ7d?%%G@V*_?r6)8@)B%hDw5bRMl~6
zO*+R7wqcmqVy#Yb1`0-{iEkrtAO-=1_Jsr@6>@~yT_rsrKnNhDrHAN`Dez*X{KfDt
zp?Q~T$_|aM(8`rGte~}4q9<Kpe;4@>zXW{euxBmhvr!6=boK<6s&_RUhdC1$BRYge
zM3Z!Rhj|VeIYmB|#a}Gd%lXdJ1hX*`@8_<7YO>ag#GA0}FiW=2i(;!aac=Ta@k6j4
z9eZDf7+Mu^e~WLID1YZ(wQ1cM=_Gj45>F@-08S6+Z4-%AV!#z7&_ERZNQ8Nzwf7g{
z*$CcpEZ?mr)2NeLsylqw5by<pCa*laXONeKfm)N;#|E%(=WCWglt?(=)_`B_Vur%f
z73dNVMpm<rb_CqXI{^r_4PDjv90v}RGrO6$&$tXibMD0P{UC{%e5ujzm$;nin5K)^
zC2`Ep3i$5i)~C3{*TK|%L}yX#HeGzZdS+wsB4s7yVt%uvL7sFJH<QGhrqBDLn<v?)
z{&>HH(OE=9%ux#IT4*g>5;~<U^!!)^`xzl#R+Dc;2R!1>jilyuxG38jB1efgw1+5~
z9Cs_j-r~C#A_frJuHl&^@lG+tiphT(cgUF#5L?s_v%1nET1C_M_^hmTcqfLdwx+tm
zq`ASj`R2Li#){_V{^r(&=Jr3$oypOjVYU5B@KF-n>^HhgO`v;E{2^z{H|0X`Hs|XO
z>@1<xG=!%RA@~Iej4f~vAu3c|p{oYUoJJZ(z8BktUEXlEhRbDufCiYQ1bJV8)7sZ8
zj8n~(_sB%lCb(TpKdsO;{=K~_>J!Hk+U-f&ZS*qVvp)juAdY%8_wPl%+A9Jf07skL
z*&%RHh0WPQox~H~w<C2)SuDbEkxi$Tu#J+DJ{zRo*)kH;DYM;D5ZEQerMe*sOs|*f
z=m`I)5q!GCXKsM-XENX;13XWN9EUd0?8VX<Bv4JvzW%2vn-+8}5^iq#AF@@quCD%<
z-#O$g`>nHAGlP=7dK(*JG!1&$%esPeL!q^7>B~IQYXXuR3Zo>kN_RFZJYup#)oUxy
z9;Ra=3_K?}x1}rG5ab*Eq8?-_@J{i3cjS3Qgh#X2Dff{m-w{u;Lkm$tR^U9sgCz8$
z#t#kZ1_oe*F`^faR3`><_bsA-4XU*H7>pvgTc$2!Hw2j--1lFKz6#=*CW>}>s+On=
z@~U@6&jsz>u_m%76`fL5;Zg@%Qr%<Qw@JExi9BX1Vt$>horLo9b;N^4o&?n>AES7H
z$g{tdo5B<l?s3g_E9c9wQ5|szR&@8!8F{p_-S>j+G1Z}OIPZS7HG+f@odWJDEQvoC
z<dX#hxA#~}jxDuYd=0^35Bbi7JkY+2nBMCDtAyy<=(-!1e<iM0hu>BFQ?;t1*Fb}>
zEO*ST?_<6%0YHcN544knI^ui`e29^<&mdSMRJvVFToozxDp7Y!1z&gYr7c^!rt?&~
zaq-A&L@fw}Ct7(4pKxkTz<+MfJ!SMZY-n)3nz_w~JtbVBj>sX33V1>jw)ygWMn4Yl
zco2z0S3*EFx&4AX0-LxS4dKzEg+qVCE-DSNC$|myx!pT8LKjfbpAy^L3icT6thD0W
zXAZE?G!+-UmbCk^k%VJDcV*sh=q;%WLs<b6nX2h60#2WtCvD=tpY(KP8y_wX;^9}j
z;3FI$$r{=bt!H;nbY(C4<w}TzWrVez<R6@*1;ul#Cvx{HRtXe@^>Y7qpLlR)+%5TC
z?vs<teQQuaY@e@#M%Sz*?AEZIX24^+`TA~oMZabD005Tng%&`AXngfs>@F{djkbs9
zFl>=AupL(??fHoh;*UXn0)DG>`mMg`SLZv~pIrtA5fl*Hdok)$Pax?$#yBX`gzrVd
z4REJ0REMu{gqP<vB3dW>MUCL#gX`?i?)OjL&$v4VpS2be>1F#WpP^uoEe_-{83}bo
zQ%eYLH;l10n)8f<?_3QvtHCkvEjwr8W$$0gH|x2b1qR`&3j13xg)1K!{df_11>u&6
zcl2!3)-0C@cl=KR!(4?H74_<!R2_B`>2~$E>{VTQO*7~Wh{lAFcq&L5o&!mLJ7WLM
zzKFkoiAE>QE^@ENh%R9~cYg<^J;VgY@LanpzBDlORrF@wJ4`f!ql3UzJ>U-8OTGMW
zzD8=H?&v~8z{1T73yswa(Vq-BYT2Zc<+)Fpr{(veM_)JpL+cbcR%{vPZL+ohmXhP@
z^A8YExgX|!;mw>{YZm=148#|fiyGNfzjHz0$=4vn&!^)~8qff!fdOv@6UDB6k53gT
z>rpjWdO=`!J>le)_wxZd_q+L-0B1#rXeEbiXMyTmTN>hx%inkJzgpRPcJTd;xu3yW
z>HyN0NTrr>K&Rk6ixH46o*@Fezi`^;;^V_k0@IlZrrA*sL`M$)wI{IyY0G?LDE3cC
zJ{KJkR&?B11B5wtP)SSYYF_W(TUy0xX$o)eZ+z}OkXSxB^d6wG-|czMB=iRd!m8wj
zZ6mTzl^hA!QCu>4?DOjbidWEscclP-mV59mSe85PYwG$RJ~#*4k074yD=K-@Duy?D
zC10DI*bw;Lw#ug$o7Dr?SywIIed8eu%j)DKVP1sN$aqb}-<aZhX8Mh{_f-cq-|adG
z7dU_Js}71r)E^Q#!-asHf#v4#rUZT&0Dbv=(B&#cAB&44$NAqCpVpCX;4Vu)e`irl
zK}^IGbv?hSEMJTl{^aVQl8M99bKlRc>bkyfG1uYy$vXt{#CP&htJkZrl}-w0OfAm{
zk1|HUv${H;M+)Dh&`%9_3%2d^6+aVpi!uC-YOWaCn6);DUv@YA*M3P$u;|g(X(^xj
zUq-&Eu!BzNKbyiAC~_pCAm<Zo?X{#+zjb4El8rC=1fG^{b^7jkt?%-HG$_Vl@c@Z@
z_`H0kU6I4&$Wm2OeBZ`$@~!7iL+snLhhsQ^%V0!$m&nC)LKt8YISIa^Z_wKyg4q~Z
zWZj-u>g)aWp=n*_E0x<?J((UvR<VoVc$$rLqp{@>ZaLpX3?1L~O#A75{ipBapZ*_y
z9%ud}%KQql_!V;ES6JGw@Y_n0Y*unB!fpt*Bn(?=w$;FCJ-<b^M0Ab{Kl^Mq%nxx9
z{+j<z{};8v-?YWwv-O=3CxmrX5U%>x9zs9BW3b1>FH8jAr7w|_{yL{ITpvlIhX~&D
zB!TJ;J{sccVNAc;sGf%XA5_Ml=Er*yZ(Eqh5v0<u?skZCGQePcmc__tzGGaMoFsk>
zWGnD<_3*Qnr^M|={?!3>_4ET~&B0Uczq^UOoe3^IAr4^X(h2P;_|iSNR|o$i8^i@&
zqcoAvU%NP$5S-C~^$VitDSv^Y7*UpZbhcAP%9ZV~O90^ia{aM!IGZmgjj&{u#Uo`-
zLAoyEa)mXI)5}~x+7wD1y$BU^TN%#;asiqEaq1CJk*g3@x+Q8y?K@oMA_<U&gP0v2
zX64172zAzw#{Iju%kftGhY|OdXJ}LTPS<Vz8C_oYY!7&N5hmfeIhV^yz?|newRoi)
z)Vvrq`}6AKG%DkpKlNAH<LIzAT4uXkZ+eN@47DCy%Ozpl;2qcQ%Yt98*o^k6wj>B>
z`#k6W%P>&vdiFSl<IR3a$=w};)02^wZfhzcZSz#7xNk*urJ?2<PF26r1GlBMX^``+
zZ&m*Lai5-5Tbw`&eeXy;q~dkTr@x4_Q;X~B<KtwjiNn+X@{C$jJIXjRJN@@sa);vn
zQZ$d1@f`;?L!Q5LR0BdO8HIXUqxV#Ki`v6)mQl{7*yQc~0?~$&g}RiQDz5~oNb*$I
zp=Ed>TepYO*xad>><|)R2z-K~V<UDl;hV<eZ}#IQ>G175fqueAdoJj|iO-kSMdDVj
zXRg_YTN4gAP^@4`A9i~e0Wh(O!WNe${!w5$qY^mKVY_-3ymyjc{IObHdHT8SCk5vZ
zeQZSul&MjPOhf*#vgE_TOSK+<HoKMkJ-OqVHM$>a9iAD;Wa_)wDSw5VexY*>@Nzco
zgGtzhDKxEp24y<|jDFDsjDwo2C(lL(8eGAG=j7TG8FQ-ndXNseTk(u4c76cEu{gwv
z;L}Bx{x1nqMbSPt@N{k#{I>W#RneT*`7yDa+*q|LZ2>F8>qLQ|*FNF1p?3q$ay`&_
zPq|XNAsw71NmoZx(&JEWLerBn(H&+Qe2RYaQI~ao|HmDTCeT~$>Kq%z`gid1!F*FG
zMhz#}`oqj`FV>ur4qPOuh-2h~GTRg92;<9X=+}EPg{GrNPF9~)`r@XMcMp9%we;SO
zOxeR?E8f#q4bVxs{B2cP2S^8$dCNlN$!{6EI5lM;+|eorUNk?2u0_<Y9I5v{-G9@o
z;~K}*Excrx4UQ@qt9H#yM9%bE_e(ajm_hb4d!toAM-ZP?Gb-Z>@axF5`s0M!ja$RN
z#rL+VsXV}?%yneEP<PMFNbCLQ#X~avLt_7rraKLX>W}{hKASPdVC=h@vG42Hx0$i;
zLbi~dY>g!;`xs{IOUhc=Ns>J&g^?r*NvQmWC`po3vd!&(-~apZd2p`t;9Tc>ea`3o
zdQ&dVKa8#-QssfVf9_LTMro*fD<sSX*LWE6YLs<g?VQ_1!z&9xAy2M+c~`33e23dw
zW@4(pBuWJCOklAy1jFRhmYtZ;O{u|5^y(yf9JMO7|KZ-j7hds<TS*gNZz{@xJc9R=
z3FlxB9=}EE?B&O@M&B;~`~U~la@1|2u@-QFSY+=JQd~MY0k@*B`P61I&j0JUkq;tb
zLw#8Q%exlBLay@O27$_lEwry~>q7uYhVm_L)^si|%8G|QMxJ$!Fytto+S7qifrzqQ
z?>Ci>heWXa6wDR^LboLS6TZ{g-F(tnb=+Gy567SXwe8BO8X_5Is0ILZTv$gN)r8zP
zmsD&=ZtFtnVZgNKVjXXo1NMv3mn?HIAU_x$#zi?NXs)Zr3H9Mzm7evr{Mdd5s%feW
zcxO3b0K;42moS)AOKUOb5es9jnbPJ6amd+hepgAd$W|Jcp-?ow&YfL!A;F!{<Iksa
z^aAy(e>w$(WcG`Cf%=K_AXq+_pnYu#e9HpR3mzYeJ_<#@W8|^AmHezvK>Wyh@~Fue
zN|g@xye0~dmcGy$pyAT@<|g}`)e#TDyjl_>nz|w8me*f&2}_XGdqGRBCUCF=huB^d
zoQ?Wwp`c6&R78)<Uy?dJW|U31ye8;ZpPxALUcCZkVXT_KQ|O3o5R7)tBAh_#;2-n6
zc$ucn{?m1?R9ErYy#^9Nu23z9R#eX~g2YvUEEa3{Kz1vW)3z9B)@d7B!Vs-rEM|am
zS{8Zc-W|99jUVZWWS{M<Jll2SZCi+0xaZpe*S@~D_bz6Jd#&ra4a~o7zx*uR=l6iy
zlRt0or!qzOGU>aI@XdEn%p&}GAGwcd&36`NMlb@U^gSk;&Sr7UfJ8Rv;+;k5>=)44
zU*|l@T5}jSU#4tf>O`gjQnLc<bWg(l+tS3mtCOBC8QY--x6PmC6SKB78jBvk2cWY)
z>bIb74CmKhHI)hVCTn&HPMuxYmKY&gOK`1}#@=Ij#F$pT9I3yo$%#QccciMHaHV<G
zL}LC~uDUijT4PycFvAO!GIeo$cYGP<`FM-DPp5<dLXxjgsKXd`#y3@@{4qxsCwi6h
zL4d6tyh*@9hJK145M|Z9qFw%PEr6{!j~-cwptd{OZT`Q#0e*_pSq)q~qzoZhY^UbO
zeU$F98aWej^X#;g(Ao~=>J+2y;e}R5ocD#5e_Sz(WM6xUy2x*;TqXC5ApS~b0^@D-
zYeA_Iz{wNjucEhY)h1Xl5;#7sHo`whraSt1Et&y#&lt!W@k<$=eh3<ZslHw&!h^^g
z1V9msJERVlyKzcebiM}sZyZW><`sv&pd@kpxgl3qL8>ejlRuQHo;8!}9-)NEi^n!d
z4LZ0R>&;#>y433SaT9<Q=erjO!-RESIGcHOuF)s9t0FdEk|CABvIr_U%S$hA`HEWG
zX$YMBpDuuUYiVxt+e;Em40%(5k>~~E6t!2WTREm*Wxr6%sSljb2uqwLX59dv`u}Sj
zw#%|#4tbnf8JEtz`3Sk3HOyPbltyu;zaeOtwEi<p`d0PdiEI4WFc*)?SpgMJJJ<(M
zP42SLGx%?eoniy>j1_(KqBY?nK(AIZz752;(f>l0-h#v#+LWK&fo7gk|6S|#hU|GX
z_4YIDl^T-@#6t_+9L~H;<YJ>}=Yf=V_L??+?oFrWfwwEuv`lv<jF814cxG2os%qN&
zS<Oq04h_5dQz~;~|BNns=bF~^XOZXCY)YYOyh>ZmqNhtDg5!VKS%Ty+d#Vsly`PPM
za+0zJ3r?WA?mV;DY9-4sRP^yId_a+AW_X5v2MW4U!3Y>I@jssIwz`VD=|cxDd^YY^
ztVtbWWOQF(PGPs>`l9=7&G2-B#CPkQmt0c1UK8k<aU)>EsIWxpF6=)A*|mpzwRa3d
zZojiT!C9$?zOKh2{$ByW8k_F9;W6Wdm5TvepAvzNs042R?Br?<%s<AH6R_dGdgH_Q
zwN)L}s-ZVxSf4-<tijIrZxdLbr)#W#QmNOusRxi8D6bmnR6mtttOTgIaWqbVYVBT|
zD!@6)$({hy85n0i3`4&u26?Hfw-=E%hcYwEZ_Fw1Ug-uM9t>x~2q)8cvB!e|_bg5X
zz`Z8-UCfZ|9z1NHxv*Qsc7f-PpBkcsU9KauY6048rKXg`;zWe&Q)LZ^ISRlu#=($*
z-qmacq+AS9RBsO|=!L!=EgMjqb9%YSO69H%Oq&cNM8J%Xm~pnSAmr#Ni~`Sw$_+i_
zDjBifg2S*P*nRF80shuixS|b=;{|05oHhufjCiR3*kRUG6V?35{C>P7bwTE-B`j)(
za%j^S^2so@qoHocAT^XJa|k?OX$YysW?wU->_78u)A09#h1KM$>@gd4kA^A2S6?<4
zzF=+!3(tw?tlPjY)D)HBvI{FH@*86SA{Z_x14yV(bp)UHKxHC(y!V-}qT8i%WMm1H
zWF6zy8gRTVm1~jG{_p9PB-n31)Ts%TDu5<o$H^NR9RDoBdn_469i%)wIPDq~J1!93
zY4%Zqj2EyXP*qxed7W7S76M{S1lFZ+rXE$Y8%%eAn)#2|5mK(s=hSnX3j+6J#-T~#
zLm2^%YEZ7Mv#^Zr1=5E^lX@y#Jeq7WeKWBdb1Mnf7D#QGq}*w<zFMPiTgU4AXuN9+
z=AT_fpU45|JR>i0-TRai^7DE4#`7wq#x)}NswFi_{sx%{4v5YnConsQ(~=WtUv+OF
zAD-6MW#@R+wAWII{m=jw<~$8}6}9S;CA1m$7@%rO*|*IavIWf8zJlbXZ`yXdOy!ju
zWDS)8EDZw=DCbvle2DOHYi0|_p6(%Vf-tpqn2Vt`E;9WK3m~H4bJdwc9mFN5Ss?mm
zAk`lYPUL1$vdl`~p@bKKBNi$3y7tt4drF7>)|~yeK_!_EGV_@FJxQgG6l4({I`>H?
z8xV^$h{3*LGZ3IvlYuXiH#-FBkApSdQ?c$4ecuKt64;`}!PIi<z9Sf-lmoMyri?Se
ze`5d4O|#|SwI=42f0{<}&UD8>gXpJ^L}3=4;SD<DGBDNh@;Tr28NtY!vmKf4mSmrX
z8PW9_vEMT&rdc%aEJkWpTys{!Y*zB@tdyZ*(K+tFZS|Q8V9Nw!DsD0-&B<U?P`yP>
z`nS_(RmiE3<Lur=#zDgSv#@4w7}!WV#0Xh)Fe_L!>kJ^{H;Gy`P!oyf&fYQ29df=|
z@#M_{<+1?u+rg~KZ@7Az(2b(*DF8ZafjMAEOvmpI@eFt~4>gzb)L-^t7808~K382#
z8u(X~nwE8BI_IL4gHNEm&K<f^m+Om!dR#vn*7hj&AH`BN)4Qbvumjyx%)adjGt`9Y
zN5VLlV1eJu#SfXoPo135ev7kjFNngOEaBnPT!qfC@O4^psfsl(Tn=W!^^mF{I^>`5
zx=!_7{7+>3hOK9RwpZQ!6;T#b$1FSmU~5}`9wgwY*dF_n0t+jwucDf(T1SOuy>o>5
zOOZ?jpi#&y6aS{B2{gl7F<brP6f5W%znVbmMmx5gf?5>5D&<ks!4u&EbM9v`Eds9}
zo>GY*orlaTfV2`g;7l#m7iJ5PD-d6p3#3*hY=9NBUpGz6Ce>Lq+<Wq^Rzsi|0v}!s
z^_3$jEw)a<o(_#(@SjJmWSLFRUWB*{%Yjalye5}m+Qb|^7A6DE`e-{?c$%bUrTP^=
zm|)%eTcxPnw_3j65$e0l(=m_%ovieJjk}s&#_Rp^w(kIdOpZk^t7pSL{VZGkAgd`#
z2*7n)QPiONKA@O<Z6WK>k9z6**v%c+O!P;GOHKkai>XB*RkUW*^y5H-4@=jn2{Ue)
zEu;o@hyxMD7}zgMZOjeq$YOo?OtnUziWZ!OL1k@WhR4iaL#*DX)Z|<DAkFGLL)XCX
z&hu<Vx5k<EWi!%!aql(%YcO1tk64P5lmLIoDId(vq-H6&du69(-5i82I8yg%S#kF=
zlgryT_2&;FJ$KG{&L!8yl@`0#6q#A(#Ogxen3umA>4Q^lz!|eEKcVbg%c<^}_Ms53
zheK3Zko9TB>qF=r@%g9j!p~jiQwGHblUMQ@)dg#BqO6!%STecW=wk5>@;!t%jT(_H
z>=z|j<cdBd0UjzfP>(&bbYCz7mRuN96hIa&KuI^&+pSK?TSymjgG(cT2*+=%sJl`>
zXx1`r`)BCtPSgPa!f^MQC3kAgVx+Jb+0*ZFs9(<D@`cUiwK&+L_4jKnAbyCL(tct5
z^cfAK58{qsbw}{uD^Sgv269KH@4h@>1KjkUnYkXm&)Zwla-M40VCO!eKx{bDd$&`|
z1PF#*SzUF^FGv`uk*(w0oT3EMuNSJ>nm75rWR(f1<b7E|S#23|Ab%Qowm@}+M$Ot_
zhiiGC<bq>Yg!lpjdg*JubPFqR^)Je$G)lT9Mfvyo(iGXrt|b-8JARgWMK!B-bl4MD
z*t9uE0o)n-@DhA*^E|c173uxytN*d$(hOT@T6>7#1uz6y9E<)E6ThKyDs~ac3?uh7
z!4**Z0a!P*y-8?=TE3uA6(A%B(j`JHTAV267cPUI2PQ9;#$U+)w$at`zO3m&e!yys
z(njU{R}AaduC$t)(9IgY&06WrI<3um^UVg=&Box(CTW#!$BZd)R&~{Tt6Z+lV__-<
zSs!OHrRAOUU8r_ZwMvH_@*#7Ss{gh8*|y+sAeM{|;eAtpG?r5?yk*+qBs;BMKPCHp
z;m*50=+@^VRU}KAd85UlATz!Q?9C1kd!O?Msm65;a`PN)6P$g6eQQ#hH8?Y?{mNT%
z5qN-J{pzUWo@yO7mO4m0_hle#D*k(i4mk)0kprwg>m?;GP;i(}fCUIc)&^#A1=cbQ
zoz#N(bwDF<J+jZp?l6eBCD}3&8tKt*^RmY_;rqAvPrbR{GKpE~I#Au6mV|wWR$^(4
zj@2~#gIM*7C~l|)M%(!e)wf(4vhsie1OIo#d4;xpd_vvRJY{+_jMEFTKXVi|DiiaV
z1oOy1j$(NmY6a{6rLXo20WhB<4Pjg-RD2KGEDQCqgSW2#;CxPf^J1x_+}CgVa~+x#
zb;22A+5MzGGe$>xxQfjLkfzXIMC;~L*OB?}-0AKd#pA-8iARsg0C4jHkt-yo+TJVj
zEY-}{HtAJfyK1(IEVTH5qL6N~B5eZL2Uoi@fz;|#=|+sw@IpI%;~+~oE^SR+fRaR<
zly3e-8T!~Cm8<1zo2tt6!VY%sp1yEx2HO$y!cH#7<6<jEu4+4~_Ah2K^;vwN$Z*o|
zi+jIpQmHnJJLbs_TCXYkhlKOJyLax8R6bBt5%8Bc*e8svUjL)m>#$^+p7)7{ufUo0
zB5wAL?s-2y*FC-@6;K*qj=7y&tyq_1#QRL4gVR}3Ade{uAbZQrfVJ)D!udfnpXc#8
zE#Ie3yRu)i_~E#DkH;LYXNmWf`l9nosV#v*HP_N4>xbD1dE%Rc6oIMui2I;ITX0%E
zG(Raj>l-A<m@N7ur*x0iGSrIuYG$VaiwVq}jlj*gt^k6^Wg$JAa_p!$VouFkVO_+h
z#O7b3!FLe1;XISVnG2MWMmX7%dBBDGsFb9Y@HuLUIUpSzFyFnL3x0Ea-KQo9B*=t(
z!92ESQS{#>2iaydL242P<em_Wtz|yv{<F5jE(=GYF52n0+)`Vll!ghcNXpy}&5)7+
z8D?iz*e_xPsgXE*{pG_A0Jt`XY!bS0j}AJBARnG4g>%9f5%Q`n83rA;$~UN3O9)Hy
z;i%iuvyh{)%SX>CN8@EjFPf92xxi|w;K_GKlV6Ue{vN$zK7P%AJS}rPqkTMUas0;Z
zcrN7l?d9Wn%JI9h<Avtq#Rtbr&yU}~J7#?Na{Te{@iOztfBYwOnUfX%lOC<RFWpYo
zLry+lKKVj9*(f{t+I+J4;N;u$ldX3r-@lw}|2_G^%-G>){FGtrYBPRWF!nB{^vj?8
z(N6hGVf-y)>^C$1JzyL>XB@s`9DQLNGsDz^AzUJ%9q5q^IJdgjMh9k;0v$vke1D3M
z<q2uWY;F9M7%vjH2<8dcm7FM*ck7Dyx+^tVt{yVmcHx)wt7^T=yIWs>$xPP}C|pWm
zSg98c)@ACE@=pGvEsj%@4<&xLj_SsC#N1rsU8%Ond2&_B=1<#VPw4Bc!N9S}dYf22
zBZ5}E-}?vAU)s-pd!RypN&<6>Mf9usF`9GuHKM$BTgr7GjQ%_P@*1UMEYE89vT0LV
z?K0m-PGQ+tyDx+yhgSz*qBJ8GstsA0{#?B6{&Li1Aa-z8E6QvjfLkT%NN2aEpiJZ9
z$xq_axd)8(N0tu1hBU{O#SiuEKK1m(Dy9&&e!D(-H$ByT{;8w>@6?Zrub2MbFG3x5
z@m0QTF7QkKyZ-le%6Gwy<#ZPD{u&aS*qR8LQ~g1uJiWB*t>}NpvAI^6RKB#J$+?Cc
zv&GQ2`DQKSSc{<b;rXTT7cWAuQEp_)&Pm;v`k56}*0MJy5#Cl>Z>;}EN20_^{$b!5
zF1>$}&WNVp=72+LsJT3!okT%WN;Y?z9)s}Yw1CBZ3h#Zzi4gbF=(o;(Qzd&N;o}YO
zE;maf#^dWDn6Q;Q&4Ni|EHbqjLY}g9-|!D*>rtX#n5lQl8(<o(L7zC(v3MbXsw^;|
zIJj}r|GM~ioXMoCbmx9y?&(C%R%;QUal^WBhlEgn{9#qXI_E=9p57BR-H7|wbD}Ra
z;cr?MT5X>;4O<mXs()ANY3hmSe$Dkr>A}aC_p<#fo^dUv=RbE}C%jp>FfYaT+sYBc
zXXu|5+O3*VtnYf}(z!|mX8_84NS5qxPUmTey7i~AOqS-<s(-t5GB6CP`bNaS+sI8?
zvJ=OveWdmfohzbFTCIHC68$%3V78GV{>s!JaHrBV2yi>OrBRpf;p4Eoa@YNf^}5IF
z3d|a-8@lvHkpZuaKUSOO1#P3jh%&XSHW4qMogQT_DxW{rT=0{*qQ1yg;)R?8x^GQi
zMxOtD0l?xh$~wp|r#?*q-K=nU3eRqOB@DWUsjLbfYEx4`6hQD_T5MB8R%I3%T=C?%
zJvfbZb$aq|y*hFEpGi>evPg8_ziW0j<Fk+l)_j)^YG<T>`k$d2++TZc44fo!WuJs*
z)#*271AE{2tA64zO0R;{FW9uER1f%Q8yo(93)a;8lkdIkY1Cp9sO$E?eNP9E{UPI-
z0GaZi@e0{~qm3_f`SKk9^W+nsAp`g!2C4o}@m0_J>H1r*Ij7Nd@J)fH;!cn{GMznw
zUezUoZysv$2I6kobZK$35?)GP?w}TKuHOMn2cY|$t>j{wE3PF?qni6owiAN50<m_8
z@P0Omy}0OIj~_ZhSo^)JvZENTpHkcgbxxLj(4;k*$i?h&;QiC#5Kk!j8!PU%sk50{
z(u)g+tHLHcorQo8`RGDGvG}OFM#hk1w10m_GDNyad#>INnM8MCx8x)Q*#{&%mOwLP
zEy0-1B5@BkHTmulgnz4a9VfH(6CMf9$~Ep-=d-!4G19%YYd&U64bLK43MO!~h#Tn*
zxFJ837+<vJYw)UZ!@CKF$86V?tjCQOmN)X>%hn+Wx1{1nce4EAKcU_v(1bv4Hx`+E
zwS&>8pAc~&U&&v5`>-_K(yvB=`(0HNkKY;T1VTO5q9XV9nGKcCz+z=>Q6QFiBgYj=
zlx##=#^Vr|tbbYlVj2}xCts~B!SVFf?ivU$Sed)E_^soZ`AG-0!(PoCd3H?vq~nIo
za#1&6P9oLUX?aT7snDz-MB-7l?M3-|r>hM){Jf%5@kgBfPAzllza9A%!dXh4=X#nB
zhhziif>5dBPR-_q@+Ca2bJ4mj<t#5hMxF#@IXE&)ytz{5_Ic;@g#QMO8LSCI5H#|2
zG}IrtxN9#Hk-=+>JBfasg`SkMj>#5()aF7x{+B$m)#&#f_hfDjp1$^s&E5_&@1j$*
z2PAh|U9oV(w;ME+t3AFY9lS#mB~waTVcAj_`%Qw1<(Fnk`g)#QwGr49q?B6!blgk6
z7aqX+e$j`imqkfQ%I@y_kGp*j2t7*5OxbQsovwXjjY=_vcR#FUA^IOEeiuEO_V~}~
z!NB}rR7`car3T_}Z^HNO7}`s(pCy+cf40ku?|jFc2dEh|4OIawfAiU&(0;Nv_#^2Q
zRXm=5@O1y9O4{+u{}^zcA&AjV8u#hEm%o1)=A%j$ouo6{=#20@*&*|KK@jJ3Xrd>?
zOp{4J&cyOj23kxl$EJFf`)>a;#RB5h;(k9lfbW<l6p$a;79etJ<rpk?7G`|-gaKEK
z8yj^M<+cS%3hTbG_364+|6xteq+-J1NmuFJwjjlGx-Y$!yUJ)E*3~j9CeIsnm%nTa
z##ZT0Mfh}AefscO_r1=TMN((>ugCs|kIG*sENj#pifkCO4os7cdTw(YhMEai&QN`@
z4Z@;dEx<#sxJxyvzaD+I3#fckxs7cxR@$_^w)Ccv{r4S<$j!6$m2X?4G~3QAebYSW
zNxH_~$w$XAD}6Y45*3<JpJC^xbs9(;xq<DHV_Wt5F>qSW36>NY&QvfJW>1J3Rm=Mx
z5o%MlRM5fr(|KKVJ6iwThjr=8*=6AWuH8Efyfd#Z9Kp$+mk;K!Z_3nc=)9l=1B>x_
zSg17=1*>||gtCa2DlT*uCQJ&guow20d@{V4`Br!pfXp%zDu(4kOkVA{C(x1=^9(K+
zIEZrSPW*SgQ+nTPosZ*EKnX&*BKPG7_$xC9rIJFujWQ(vLlEUYnl0av1{b?QGto%j
zW}>a4epvpQt$*TQ{e`{mWI=cCydNilJ}lm8`BUd4oxSDFU)~!l13^#h|Mb3p{M{+!
z@O|W~a;Qem_R7^O*X+~^?A@!_r(igvi0Czy(f~a(z%N<F5jO2npfH~YQ{{>;r$fil
z^1n2Tmkf=<zs}!o{s8RgUxJ{%S-V5n!#c(#=c}{KYw*7SE#zd|i?`<<Ew5jHI`}>I
z{NbdE^h?KG!~R#tbgeW?!DFQ?lYC|WnEg+pzM(3D%baP^R2_D{8OR3~k=)cCiS1?n
zC#3g|f}bq(kbH|H{$L{P0ka<R2L5T#JmYxl&F$mgx1Sz=dL(e*)9}P`^{LrDs(-_$
z{L)7w+;ScUGzLi<%3r+7gi~1%7-LEk<r$Wq1Bto=#U)RJ^kCt&^50B28Q%&Fgr*s4
zqJjop(*!BY(p2{dik2fqq68&b6SWTTI464hyHEAXa3s2hX0>ccU(kc#ME2cz6$$F@
zj0|mAu(A%JK$D;}1X3C$h$AZ`ZT)z|{1g=lg%{E#5E<GcU}+ISku@69dRXs>#<@-Z
z{If=Qtd{*1rclZJriW=^(5R@^nAm5(ofQ;k1W-4P+WU-Opyw2Np~<eXPX`G|x|^c6
z%Kk9{BmrqpXGYY0O%2BJi7(R4WIv`_;Z<?htyySU&&v1`Ow5nK+Wlobjx-yO(KqWT
zH0gXAi+>Q0f5+K$4FoOmn4m!fCjTBWYnem#z0;hVQ{Q-}vsaq07?4zq*V}W^nC4eG
z5C;J2RhMro&5LWNNGL&<PF}n-TjNhGt`FF9(`^l?e_UH?m|?a-%Gb<D-ecgU)5ceB
zR?IWug!apY-N|y6Kz-j)&AbdVQ*gmBe%n#3=n~1SgC;)&(sLh`-4QT2G128QQRS)C
z-dRvRdat%e!u#LSpTLOlEov-K3~oslbfz0`ndmQo<RD;eA}!BvL={FeSToUtR>-Y2
zm<wf$2!IRDrfV-)sBM7s9W5j}0<C6Oob?*5%!7V>bk{u)F!yZ?2n_;=c<iKqO5~-P
z7=rT$`6XS(lmTf{kThdiROT_sY^O5uLb}-z2w;h#dt>-{Fklc)#0C0?shn>p!?*`5
z*yARsxURqBsgO3Vz9YoRV{%G)dl>O(k?~2-2!Ocr+VRrvAVyl?3D_g+Q<5$r2<Ah!
zq8Te@kXbT<@@RaI%j8_Lyg@jDH5SbTi3{6JQGc33M#}v^xVin|PkdN5F!hcILf7Ng
zi&!#}9l`f!%7un##$@pQ3xr!(-|Kd0&V>bDcT)&^AfOyn_?=|dfae?qUdpQ}`kkKK
zM#>)~CDZYoI%4`TiF`p5KwKcFB+Yp8bfH{82?C(0HK$uQ#zFyc)<K;8z)K%!Dx<@t
z9yB8z@bwDNr5+RG`2}^y=cv+jp`u}(Et;NfW42hROVdX7)k@Kr#cM8$sCa25mn=<O
zaH3{L5F|qaM@l`&kkTQc;}(qiZY9;Gn+=hq<QW?&6(loD+1X>T?B_B`cXP=Jezd!}
zlqLQWeIzA0PysZAm8PX=epEd89AdqccVd#iE1j&H5!BJBr86S8?S^d&CTWs_CQoyA
z{C;|+`D?VS3c0FVUu*bUwO@&n@Y&=kFA;x|nPN*}zR3u#)b~n8*~b9Dbb8@>x|t;j
z2OUz_cUJ|7aayJmw!tQ1f^uuwqWc13YuPfyFn}YeP>z-Y0tl{IDejjmdx>S7$S?bi
z#F{r}yW%Agt8tbzevt~zowaKZLvEo-h2F!4AE3Hqnhu%Pd)0)qMK-6s<pD^cU&ur6
zv-|ldf%>C`hpwLWaneGgG~*&#*B?e1iw{`Ki>BF-5fn<(gn=^!M~Y|p6(c@+L(`U4
z%H{n}-@0{UNN}oLjd4P4q7o?xJ%VvJRT$zIGvEoDNDtZ%PwWLgj*+f~x852IKg9ws
z9=t<K(oXF%*}bx`F6oqB{Ou@GYIKHiT;PlLw%30Yr-fQ$luze!HZ#g!tWH3ewuUSG
zz8HtflzHRzAvhfuVBvLey4W(VZzS*DX@7Xo)pnU{57U!%GV;wbl3ReH?&QVQP2Dwn
zT>yZ8f%yR_jgLr+<Z0<o`SwUI(nvM3-@HP2jb;=|D>~DXxw*h!ZE}lFDESW3TNz%q
zkD?bS{Fie#b{~^yHGD0U5j8M&^VJCrjU3r1P=3u+F6C}6ks_c5O_L)98}yYuWuo!-
z4Cfut^hBfq247DXLVmR36Aev*MhU!@ctw{n4Zskui-nQS2xhX%Y?_wXNi(@ZK!;}J
zmwtT>zgL?X_4Q!;>zKD%UWQB({*DkK2xpS=_KxN$TonOKx?mDCM8hQg_zEW_cYx7x
zGGZb$O~}0$Q5OMVVh%?B5&Vm8AAf9(1n5D%u)SB(hKLorhxCGlQI??KPLRQe46{=3
zPD+^h)`vVRG3we2Gh`!AKi&XfdtK)y*&3+q^6{yZ$*t2^c>>5~-O2#_4RSte{g$T=
z(UjvCUCq`)--W?U2X5zUev8A>@_zG<+3v{7P8v>vFO_a^IJd8db#iEn1lU%X6N3WM
zqWj~5H(GhlozQe)0=Hh7c=(qK`F=Mm0`ENG_wgZXnbsxW^f7laR~hFQ9>4h3&qR2k
zjBj7&oKJ=b{i_kAh3C{}CYqpqH-uO_q*#TteMe0^Or>Ha#C>T&UZeU&gtSX7)=Hle
zr!q8Lp}KQr%er$~jw66r6{Xi*O56+l!VBhzNae$_7jd2J$}y5Xeg$j|N*zGq9nYrZ
zbkQ~70j5G|0WV-GD7cU=6sV?k@#o76Kv8-+dI&fj=_8~_!p3&$hG?kX{#E^~`pc%D
zsJcZ_F~d%Y(exDaRf${G=yj~of89oZHH`m@y%)rxr@xNNYSlu;>2dTBBzp8@uqG;T
zcbKq$ywt0#Q6<|NW{g<#i&*o^J;t$n7Q)S@xdkS|p(2nG{?a&;`&iTNJ(H(B)(_&e
z3in<hfns4j7N6oQfArY@#abT5*=L~aI5f}j_ntv%I?41psc1TD_c|MEx>)qOIB1@A
z>pgp3(>0{m^`fTR<zBZ`O?OIfV`RGUTsm)@X@0h*RgcDExq?;yZ*!`e^H8tZxTa-C
zujiLuALCx(X@bU*rOq1g(G!v;J$zWOPg4g}O2+$fkaU$N(nP-`201+X_?vXEK20ez
zWreX46arDX_{WFR7b?@M6ag`e^9Imc%oixZM%h<CgA+Za0`)x}HfjEuEVuMpJgep5
z1P~N6Uo?YNgs}b%<$n;(j8!0mWqa_P<LMeMV`<Pd8Cmcp74W5S@VTp?QiBVnoB!46
zxCe+tE-sW=rd<Y<UycF`n3rD;4u^!Iw3D7+_J0u%XaQb2@^)K|cM}7jJNb02x;6f?
zRDPqvz)4@^kJ~AQ?B4f(lYYb>tjA|OdT{PqxYwuNr1Lsi4n3EdaVQt4TwJ3ic<31v
zpuEr%4h{y$tA@n>e}T|eE6MM@CecJ=jv%!ZmpId(|4AqK@A;tHe^ak$g-S4FLhfn<
zq7u@te=6Z`zN(U$0DhQ58NHTB1_(7<{!rHs)+xKJ`{>^SKl!7P`+uUX!?>&9`}h~(
z`hh9k;chqZD=hQs#O*95FqhkPVK*Vb!b1deny_$!uCxyEo#sW>{>WePH}8C_xgT!8
zJ#bMW(_3G!Am6kh#I*imdzD*4dZKRg<%4T;Wjy_NjE90^Ts?VpmJNvhO%|}rv3=Rh
zLmxe})aW2_=#Y5aIvqNs_y4HCoe03%LHpl>``rq<Tp>9Ye~J&giWEACB@gt(4%6?|
zE2|`e&&8)jLb@oXrQxG}_y3m0l8Y1d9+n*nyk4+?raiG5_~~jTJI#1N2I$l{2VS?O
z^RK<qRP~i`$yP4<_JkStRQT#aadZ{O{=?N3G3d|`e?`5<z*%+=+BtH8Xwq<ZI5`$V
zdvuxP{BJBb@j3HBtId9TmHvyeBhTmWWDjVX0yl3dsG_}~gy4r{)i!C#L$jlg##`x!
zP54s=p!@8Y0R$|v(SK4*oVF2TNC^Z#y7DMrzgR<`N?Yi6)6&;6yn^~?i4!P3pM2G!
z&%!G)`iY)J+@lv|gNq@ff4<W+U4T*V-I1@sf|5z(Hr<g&|8N8~s%%nY1rgw7BE_x)
zz|oxlC5!r3EDJv#br=}R)sL2WQtn5tDSW*8wEL6FvqrZhrxu2S=S#z;RC4BR!;P|}
z&DNvKLJJZn875H=$vt|f|MoZyTrLIQ-HOe48!saTQ8V+Vb=|tm`QeGl*ObQEfN$R(
z?#MJx6&j{U5woOJdw<0Ij7|RRHu$FOa?!=XcM_@N#>syuMt`sA3r?Tvj5NNE#QY$2
z{iKja4a(ymD_XWq8K}oRkP&s4aHFD-D(18!w{Hpa$*xVBI7^@-1P90fK=^bm9dqy$
zc4qOsg=t?xHbTanTt1DVQP`EDMD~jVt%`&+DqS8TYhRQqXpXG)mjv5YX-9vadw4Cx
z;kI!)lvl4b^h~{l74+9%jzYXRpaz--N8f(x54=T?B9$@%s~amDf-mhWq&?O1Yqpk>
z<qZ?L%4m<2>VI4F9`KI+bnQj+yUW1UH(k6oPIv!nIo-M_*!=73Pj#?SH&0Ax4j5*-
z!WYld-{e|(<6#z`VP)KfH_d07T?d`tKTXPl2*M$c?#y9<C&OKq(Q(B(?YYlxDYfL|
zalqZdZ_Z3ZVgXAa9zoYAX90j4?D)OKJ^G%VQz!F63i0pg2LFt+?L{B?=O5QBS|hWI
zQ(or$WGVX_>b!b<{OxbIT*Hz2frIg(kr1($Nibr1m>HAjNT7_Vh00M*t~{61MJ$bW
z%mU~;w^?5ve35T6hz`A#c*Ft_y;JHjaXVqz6JB`w{L$1gu5g=4i^&v4ga!@!>6<Dh
zU!<g4GGmfeqlDzu)g+4v*ripqCsD1@*)CfWC>ezFq}mI`H<NE`5<^k%W}{&RNg#KK
z#G8hGJG*zJuc4(e#B<!jwxFWbqR8E7yGIE)k8npFwk75>)J<-f6W}(aNNSnj|D(=^
zbyN{oBL1wf$zE!`^hveWF?DX=)%#n6!|S}W^Bx!O_1Zq$lV_QnBWiw?(?q@iBTD*<
zBnpk!T2?VFIfhz`6SD6kRO^~D|5)85e!Sa)DqNkPzc|e1_96O3a>vt{8E?7S+IgFI
zA1|-uyZI3B-sJbbm@)EhIr-oBcmJiP=djSDof&M_^mI;p_m#|*-+3z(Oo97qwp{zd
zYOdNV_fPq{+Y6rx@$4RJ#a7CTYuC=$d#qpgh+14P^DFT9ToF4U&aT%(MF2F3^X_n6
zoLZBBCyaA~(*lhbDo~Hye%R0ydvb?rLjEc#Bfiig!M2Rp9ObhZukqOGv<aZyAR?wh
zL=1Ss9IhoGCY}px+Y67gXLNKzh40$Ek^J%Wcc1h#N~@!}zRCTPk;)+;YD`)S?yZ69
z8o>&GC%kP}0=#_VQzfJ7ulu|g%K;SGaYT5IR>mXDLU@DN2F&$SQ&_6D-beGp%Sv{2
zZRA}oNiv8xH8E=v0qwl^1OzQ2mVZ*>7=k~m{R)0c-vA8x-ug$3SQ@De@9?nZSBsuW
z8C_<Re|kl5<~2(}+>L=Rl|Ml4&yE`HUBZqz3!_`O!&`Sb;zlu-nXonX<1;KefHd~0
z=>jE$6Xa@(9Wur;3onf~kW0dF6%;|LbA~l%#_?PQ0%MgaGkCqwY_UU_#hl14(>qHV
z=e3<02}JF+n5~Q$Zgn$I+58Z*&>97fNJIVw;;Tz*MZ?3OA4UA(?_d%Fw0$OCVLzmm
z2pH)Jqe-vUis}oRvb}bHqqjiBX|{7(mtLSb-S9)|Dl+jvJ8yDXY1~WL|0FOYK7}!l
zqn0GBqs9&`1#axZYw|v!9#I)@g&CaBOK?sl+R<Z9Ei+n_g^OZ3oMTQ<JXg44qhJJf
zU5M!h^SibYwCloiBS|?bd$u{-wU}{z+a5mK=@E85U5Fx@6JRprk4#7yQ{O~0d56~X
zvCTk~Hi=B8A|}GmTGlO)XIex`ARO(BV5`9X!f*FRIr|;W)vf|_EtA$nt|?^moR*b`
zC71~It2UVQ_!2IPNO0Gk2{Ll`C`pCRNmJdq^&<WvosPg!+QXUQv-`y=Z2@*9gLSiL
z8A+wm067~Cs>Z$y<q`xfb{_51j_9&ji_8=~smVN_^OIu(@d>ryJLA2oBW?qsiz<7M
z9jxMqD1ccM-zAtNgRC}@suLhEf*gzPD6_mCIxPJ8)0oBh&%&R@f&7QRm<`3ap!@gk
zms&1{TG+(QrzXrvvrjU+82dj>6<PIAxG-vTbOw`tKtsJ6+Bp9_ODvQp>@M_$iNIgK
zqEyAYs75&88^OIu>lsL53^sH&x7fX8HR}u`4XuypEeuzULCp?*uFUyU6iC+U`Bds>
zbQK6yAD?ev7u+(Q@XI^j5P(|VA7@Y8Kx*wvpuP`f%B2kF-|d?f&XgZhp0B;BD7N00
zd2D$pdY5U{lP2ku_rbVN&71N+-VoB;XnuzIy1^&Zo`9I|3TyXh^|)Y%K5R!s91)ox
ztO`gwhiV*Q6aXIYq1|Sn0P@d5fX*jv8=z?(nG=wpD22*~4e`}gakO*3ZGqw;N;f)r
z0;a|JdRo}T2Pb$k9)k+b)PIeUo3kvz`O767QRQwBbX9qB9+`VAJAFSaLcQacA-h`}
z+mHh8`%Gg@BgM3m+_-Gh)SsM<@-QV22Pn})IDe^@;^k{!%$y3V&m5^d(uYMS(O|%{
zG-r_!N7(>NjKdYscO%=CA|Ia3O0oH1s}s5qyVV}?zbT8zj-MRyb6SA0B4PcH|BAIj
zLt+TY)RjL#n0iYs;uG%vnXV&_@Sz<{t=J`dbnQ*tehyoV4q18xqf5%F<?ca3%>?yA
zOBhG7&8~lXCqg?*&oDQ!`TU{CU9F`9+yzYgoxb8BwyYRtoUm!l1r2IPCMOUy3?zCv
zB-)O0e$@krC|jX#_+Ov|{y=qhka*f1nHH?l%^t;C+WJKlwRyh7u$LBViFB6TYI3KU
zvh=lBeJ{$mttVqG{ny&JvotBgG<jO}g$Seg%lV6s11qL?uSf>zqzR4k!T%^x<GIJU
zc`;M$9<fz_F$e(B&(2MjpnBr>CADYubWNDKUc`Sowc(FM^7JbjcxNd(MUo?YqQ<0j
z=KX)W9g?nTqdJm*Il>Sx;pM^>I^&!L_bCBSjehEk*u=zVeUap9_xNq+f6Sp~EXkN>
zTW^ZLIu$*bs>tRiVi7qw_a=V25w?JQ&1bD4AikqH;v^_1_7(5|ETba;m>!|_9ld}#
z2=IyiG`BPMk1DA-L~Uxpa(Jz{>Q=P@3GQ!31;1KeM~ZLS2xj72uf{a&9iviJSbiiw
zy@pR>lIeO$;kE7ZOhw<8tgP8xu6^AZ_`_uId-m&dBOkw~O1faxifNT&a!lKrMhK6=
zh^k+hUn)GCaHoB<S75->9P<!Y`&T9{hHVM%3;64b*MZ4KjpME1g6Uz+ao{Y8RZ<MZ
zo}z45_eBi*T(;@{fu%nv(Vx|aMI}O<jrwwDnMHKB*3Md7XeoE5?gvCEOPGPnMncn>
zScWgRZld&7-~c+3-Xv;m!dAM16dHjqyhI^~F^G#|yJ)1*Yjp4?Dh2c2JdhPRiFz`H
zA_EaiXukb0(FhCHX*8RvpQ$Q_Z8q&6g0yF=(t6@|B1T|s6-SAzAg6=nHt>^O69Pj-
zcSN1Q7?8&{EbN9q0E|Y$Gerwb;5&2ytg5Wb4$70rd43wrRm^!#bs}uF`OnICBXRz#
z>Fm@R*p6?TlY@XOhBaUfwOuHAkam9p&UCiezrWc*WaP{cLRVmum&F=;fbLvK7se@|
z`qQ;t@rwwO=wm;Ws>0{sSLg`#FLAG?cUPhi;=>3#{aeq`jJzn+!E4QvADEc*-q{s_
z`L#iWKLzn@yI|OHdF4w_2Iv&--W`7V$FG6B8Uz3Ch#-h{v-4dPuR6hq_N&BuNuWkr
z9P5BTLAbaLj7U313@#;NyR)~1VYsS^V}e&JznFD^_=c=IH-`Bp*yX0t+ks?ZTSs_F
ztr^Hyc#D4AuW*&PqPLqa7V5}<<d-BJk=z4p2jNmDn|atq*!Sh@#7L~$D=0^qdkD(?
z4m`V%pXtF?*F3WrNja&!Srn_BBVc9TSId<p&N=m5{9#P0;;wWhe&O@BK+hMkEIgtX
zpV(H13ScgfR9D6{8R3`^NFcZP3UX{5+lNLn(6yYEyO<{cj`5+h(m~Q<pdMl^+Z-Lv
zXUeuS#D0aqx-rBK!mx9_!px#Mw*Vp+G7)0CsG8xu5js+@mJ@_0gNE2dhPjtI5Y`}e
zKq%_3lXB!6Ezu^)tMbC1?y^m%kMz_Qko|cYc2Tc@IZ+zA>$_gopq_-NPeW({q=Fr3
zWPf6q$G};)*O~X*I!5Q>j}bIyDCS2Rh&v8b+NWVCvFmFj&JL=@ywxyTk2U(*ZS?(@
z(N7KI-?7I3x{Z&283VC6rZ^l+5ANI;+Xg@u1$EU6w$EF|#gp)vAOc$t0aeG@P%C}x
zCu-~W(r5(v<T;OHD^?Y#@}yaik%Qrp<d$n72edTE4m3#k)tP0Bn=9>^gVSVCBLdiL
zMBcC_h%O+Ki?uH99l@yPg4A@I&Qir);t5t&J>J9~g2J!>bOk;>#P!)vF2Vxo{)JFF
zTxcrc0K#$E;`u!{QE@+HLG=OT2DgPqs}3{UO!0FYan`_6-RLM(--|~rwS<CU)od(a
zyEZb%S9pF@i9#S4W*JKNI7^cWKTC1VX3~t6N+ezo3IwzdqefiJi^Uy|R;+H!qDI4|
z3^06KH88GWfqp-M59ljfJ%Kq5_Jx6_i{j@*2<NNC&F`<<^-8J6#5yryCD1EMo@yi{
zN$3P`dCda5eV@)i_=_^|H^M+Y{=@f0Kw@!9E}ypp?1RpH&(OthORa&eU-#nlMx08|
z8fKNc|Kee<9u^vt7bSA3>S@~E*2J3fYVdqPeI8Z|uWRPX719YC7OS^0hg#WN+pCz^
zrk{2HzGuJk76(MbPz2$)@8WH>9!!@`Z|n%B!&Bl=im#+0ZHgpER-)tLbiKD(ma?X$
zi#6%Y`5>>5kuwT>7TI)G10Y`(9`ZFkjVN_K`Vw{=E7*p~I~o@5a+a#uMMbG3Pl)H^
zGR!~nV7XLmPE!y`X6kJXu9t7P->>0Akc2=%;^l8WjBhC9@WeLYeZvWGh@y}fD8bsn
zNDSo7(Ec3c9N=w9x_Au6&uV%-=ks|F6@%5O?hwuw-cT5i<JI%y42yNat}(VRij@br
zzsH8_KZvR`J-Z#}R=sA%!S55>>cu+}@In(y_;W6@4hGrMZ6qc3)p~LK3OI_#11@`?
z)rb`Ax#Vy;<Q^SBo5keuxfIr&*8t1wJIEJBBt4dN8=N;Y{)_!%6ERblpLNOY{^bOv
zJ$_FhLWsnAAR}{=^kyzi*wmR#YYJO;))-<sl!8Ib)$q|FqSHez@L;RK>j?%UMCNy$
z<vql7{v?GSyQ{3iHR^ydOqeA;k>_rUb^ZDO_N1|En5A##ed7Ld^Zo`2=RM;5gRc8A
zP<-|>;7ra0T<=>99U`Kc-g~fyBC2C2U8CQ8lE&RVL-%)<%5+NM4@gT04*G-1NuY8#
zhq$@p-UGPQfn0lBKGL@QvqNm82oJH#Ka>UJdg8MObzIke<UUKtdmX6#Vn1(2hk(od
zJ=>rEaRIwV=WyN2|Jq;heZSzRPT}u_!hijR$NPmq-6EzdMc?~jOSo{7J1c$Y0xZja
z5s+gtR>b*F_5=DtKOJ6@buX~7M0BM@qoPQ~`jY#X8rPMN2vV$MNaXT$g&}|n0z*k0
z3BCYC>6@2wJij#RC`-7<$yMt(9_JeWuxy2+)b4B9TZBeT`sGa=Ip2R;J>89QrtzvV
zh);bjATB2P)n!>9KT}w3)ls_kRAAL{ZIuP2I$QU$_=><OO*2A|^rG3@`ibyR(?w(f
z5$P4VBlQM&??eKTSrH}FA2566=6hYV!aEsxKRY^(t-9Tn>*_s$1JteU>bJ7ml$Fz@
zQ$7eMSXw4ahAS>)`Uk9_h(&?Qo}Ag@$jS~F=#Hz)5~?q)QLemBVX4zP3YAkY8CK6{
zX40}RZH&MOwBv=Z0y%H>a>j=UT*dH7V)nvTsu$94n0;=F^^{#+6GMm(Od#)E$KR<~
z!l(oJK(#QwTK;~Z5L}_{`9Rz2%KuL3&Z+@U|MYw|5;6?v2%@(#y7ewzI7mwx<!mL~
zxAbRaC*Gqkpo<iV(XS+LpSjkOBk5}kZy8QfcMk;U-_NOomrtNmY6bhzYym}Ad=>Ae
ztdvwXcUisfDXZ(cGtv6^UL(q1q;ejOJ-niK*nPN^21t9{p6>7`UG&KvNvPvpdz0H!
z*Do&k@%j#nH){coIz)0X0_N6#?Ke>KD*{)C-+%@J5*~^4fcwwT@`wrp?^b3;)V@uy
z)`${BSfvKRo{wwK4WQWAmq)<g1{}vV9yr{A8iRygsgm|<f+PVsqe{PCfc*P(1iTIb
z*%FQUtXqZ&YxjQ`+SU{i(qOX`P#qz6bcpq=eYU-W^4*eWe8o`o(i;M{?%Ikx1Jh{|
zRwHH~(AHdyY$HTEM&q~e^(W)=PFiAO_5xhFLPP^>($d9?ohewWVwcIC1>gf=C4hZY
z?`NQF$l|tM@bk=cQTVgxb`mp{A250NO+?+z6Tbn)l?S4v$tjU3@X*Vf29plk+PlMG
z&I_nK-RD3X_|{YuZ@bz2b_bYVA!WkFGsy*}>m1c`H300lrqCiG59yQ_2vVhje&Ak`
z+<p?4?;}d+xYyzk<)j8^!(Ho=pR+J@Y^{59eiD;1fpS$^MF_u6RT5JLbCZ(B%}j3F
zka*~$f^2niC&S#kLulER*%|}Dc#Y$U1OMEkK*k6VZ6m<}Z(OK-^%xB3cLBY>9J!=2
zwN$l@s>8$KJApxi6EUNbGw8hW71o^!1)~8;Bz{=nB}RZ1rj!%^v&O95n%%tNC#Z&P
zM3!dpS$16uONIX@r98H;)R%qkw>e}b-~&ebeYZJzaYFP-4&99Y^LW>fW9j3^M@^C+
z(4C$-fUQ4HjC1E+&_zbn0HOAFYy{Q?w^j*3(dAC;hOeEAPu!n$hcS^pm%5vAbC{Tv
zJ6qH*$+v`9*~C<qOL5T&UHLC$EttRnF5ylrG*alrI66z8uN4Pxn|^4)XTLDbCQ1@>
z50f*%AUy+mjX!^7^Jfh<06ttjg=*Ls|8)#*`2XiZ`e8M)oz42AiupT=5PyTzUUibT
zzlP@S5{nj&Ty2`}(|>0-(&eflwykDDZhZsx6;%#B1PyV2Rucn+?rM%b5=8xCU_`2u
zuwwGx44yhhSiH9({V`ts%_j8+|MUesQ;bLRXY3b20b%W;kC+xQ?Q+U`EOJAvjt7{=
z){}mvqn1t8gtdGU)sB~YCXxT){*`_VvcdA7zWM&&W`UId+DbVNuRH0B=Oi~yNq+cG
zvMtqgE>-R?9{<qSR1vkm2xA9~oRP7hjze^)s<k7T2w}Y>*iSmY{*^vemjIbO6ZQBx
z(<7LA!+5bIW`xsn+V{nEm|9pMgJou&=5=_|o1U%F{OYDb;=vIMwq?53G*`$l2YY9>
z(U#YB;_nalH+Nj_dJg7j-krba_2}v`e5OJ@%5mlnBv<R+Qg6ijfn-)~W&4(slj}4I
z?fc7vNrwl=tO?)c&vkNnv*hV?u0G2X)=xp`cCDRGY0o{$)9wB|Rjr?Rg3#;Pm}#)7
zGRoKM-F(}2?oo<2SAj?&JCFxBy<jI{+L1UG&13bFj~>ORr#_ara!Qs;@cv*kJowLi
zcJ=M=2d_%`J^+y(kDw>|`}P*JBoqVyD6Z=~>2;1Auheul&N%+{Wn((o51!i-`?@H3
z|LYfy)LBs~+G|iXFpr11Vwdrna3~P#BEndE!vb(3YV#-^j%El6jvYB)b1`}bx{gl7
zF})<LZ*{Yq$ez@T=dvtQB|L8kXpHj)`l>s42Z{9L7y}^^h!RWbm{O5TK?KvQB2cE6
z#y_gH#`XVxY@T!|`5<E<^w+NoDOgl}eY)&~tQ%Yq^(6axq{vcPA%?k_3unL%t*MQ)
z7{=Gh#B9s){7=26kesBahP{h1r_(h)S6ontWzmU*Tq7}R;*QhTdzXupFE!#DjDI!o
z<4RkEcrCmulk}u+Q;tYenm~~*`P)v|x|eEW8-!d57S3pxGEn3idzzE--ko5otcE4v
z-Ts?KhsYz1*ZA*k*$hXC&gtFn7=(9KB;ftT%!PqX=-V%mMbp0=bYS>}n<DQ&n#-Qy
z^IvEu92HZiRb0`dOxgg6H8z49t{Zup2m99%GOx3FjqfE-tfR{7(Ddn1$M2sICVT-R
zX=5Vyb7Lk{Ie``$a}C@>#v1^VV=<@L=#;n_dOZ-}Xw4D^s1>MSSG?a4ASugi#Tf(m
zijbJp1rlSCoY1}iTh(2kJ3j46t(%KIZ^hqctI~#ky;hgMKh@^|kfcm&ZHPf8hMA8|
zR&H~`g`!WZE+5zn^%bXw8c^<W)oQqI+4_wDu`xwjz9ObJ0P1eG3PE`Jv!EuAN|2q=
z)afDVs{(L`!6e&>$asbSH5%>6dtuIxD&z7lQ|7LD*zWJvD<A$&w6;O$4k%#6Ck}&i
zM2gy5U|a=9ByiM!8{gqN7_l&?C1tnNl*;kM(rqrLNOS&T`-(iXu6^I{igQlRD1DTq
zrCqU?+H2$9NmQEJp`;f%W={ok9XvC;M%HCZ4)&J@iH?sj55u$|E<5gpt^MFM@_K-;
zS;hO;?O(DF>FFky`W<Aqh$tK4h5(~x$wr=nJO`m$&u5(NHj?OTGNmPQZTWG$jqk=|
zOoc~ZmO0Xi$S1!QI32AZwL-w_CTNiS-34y=uVPg_5lI21TFN@tY`anVSS*{1^@jNu
z8kRx&0SA=|-JZ)pYJD*A#B;*|zJCkdE`4`?w`+mb*~>fZ$Fu(}hDMEa6b$6iE;4%r
z0@~2`H!=T*q;v6S>W}~U*=)8kY_4<3W$xG9lj~+K<4f*^$Xt_4A&F9E8=L!FDz|E`
zjgV_eDfisUC52MCMx{bhN%r&m{r-k?&inB>@6YS?d@fT+y$d^qlV)u-(fKO81L|Fk
zEr$yk8K6dM?Zw72^8$IxDRp}^=|)Zfya$!6O_O~?E(x(>h+4H<UfYr5d)gf?&D4e*
zHNT$&2!lfYVEScBZ`|46&d{@V<`SPGHJ(0LV@;Z*8|)-!g-fUAFVlqdI+L?Ta(l6$
zuGBA#6HoHdP~g~`$qQg-<Xj)fYWks*DbrI|-j{wzev6K`DPtyB1*W>a39Qo&OuuUH
z?n9hixNytmMdn9%7JSGSP`b!OE577h7?1^XQn65-SIdE7Jlq%O$XUF(p^}p=VAS`r
z0|hf!tr85VHqF3(Rt4Ix{cunsD!jb5FORZ|=Kk+l^#t4g4qxuLm5yB%^RO&dD0{6}
zMEcUT!}HzzewY)7#w$^-O$&0k{MwTrcuq9HbsA#p@A|IV*)_hua4+%e7u)d%a!+~U
z8fhNz@on#!KDD@}%!Ama4DalqeOz-veO>V3jM>q!xR%nd5q6BORO8BS1{_3|Sd(>n
z*a#97){HDL<$XJ28H9fQ+sW&=3v}NOFT~xqcz%?@7Y>;g($JY&(O*@bRlE4mHegUk
z+sHJfYe~`Z&ogb$$y>k36XBzruiruxqmj5!Ib;a~mPYiTVaMfVmQXaQylAGKzTLsb
z-p27N8etn6tthQ4YpJ{X4hX-W2SVBSmRpY%s%ipixn(Zy)&~<cPSK;hjC^>`3nC2>
z6Z5_+T-TU$CDauKo9%O1*6&Zk1e}MRfoQ^ApakJS$sTquVJ2GT*O{^>?~QDfP=a((
zP4Ja#+7hWbb0;JX17!B2f-aRt-wqs<v)TM@dFU(q7W}k8!ZVd6(~qL)19N9c-y;Eu
zm3iwV2-eJDmu^VRST_3aXZA>Y>eN;f|B|W@kf8nDo=ZEZZ>Q3U!A8g#U1SzY2gyu#
zg#t!AX!Uq5wf>oYjxiDP5FlEf3<~YN{3crHXvS`RpDWxjV$S6Fwi^Z_%|nw{SZF`g
zCv%;6%|u>2m$APj<^tw&AH7lg<=Au5K9R<<&03dEe|WG`waMI~HSlR-lcddviYT+O
zw+g5GrD9G4v2u5yZQtaFWzn(?Ua8UZvzJb2&pgw<u^#`Q2hRWx&<h?<-Gg=sceXnL
zg3-Zo!GFx#y<Zt--%-Q5pFIRRJ!tZ6b}Z3I#q4bRvn#{VC4nQCm&`I@XNPa*c!Um$
zqPJ29E?9;VPB*~6X$<t5PVr|seYRYJ!;bd2{D`WvC4|8@E#?=vp)rYTCA53FA!|8t
zkmoo5l9XLealQ&5&aciVm=G`DI)py=yLVYg`nX8@gwxr?YimK@%Y?mcL*hXtP8>`1
zN3D*kq7Q^_(`v2FTP4xHdrQ*trZqn)E<(Pf3Z<Tn%d-MGy8d+(<fjSCHc?@qo>L*@
zXGTldJSMEklH)7HxJgWQ;g`j^JgnM{iC~aO9AHU^H%hIS7Hc^|_di)|^Z2WqlEEd~
zk_0!>){DzI?NL9Mm4fSS7i1;#3f!bx>$}^E_C3^(KNp3a5jgW^Xa&#?a{1~R4gmg@
ziCy1zmRF}b(Th0&r77^njm39s{u!xaRkxWBQZ0OH)!@0kau5Gws7fWE-l7tFP;wbe
zRPPc;pxFH?@0ybG0^*O3!aoo<gN(?Hf_o~S06wB(ZlKOE;o{w7IhAvfuT16?Da!59
z0u>ZXIz`inl5l~br9$1jPtgmd9$`?AvZ*G6RI@dz1)PRgp%I9*+!b!`0w10-Xv}=v
z^)~2PXPAdG4M{w-;VcGX9(tRMifQC~WysHxP0C*3Zq??uT@_epgt-x~{xfui`y+o)
zFY)^Gr2g`3i_$~r2*j~c@1H=JF3Mj=DR4+AkH(~ZZG<-|0j6^`zwQ5cO*lx*e5iIS
zJ@|;@PLn`fGkmBL@gx7tQ=FGtJgOCR=9*Egn6TP~1+-=lG0_z&Epk4;jbr<|;&gRX
zOm%#awFvNC@GvaecOOu*#;F{Gd36jzvxQ*~7#U*MrK9GNugUrxCcnNA&?f@WHf#!_
zVoBUyksgqWC4o-BcBGJU&Mh)m9>!lz2jTddw`5@5?s-48U88*ep!lp%p3A=}e)EV%
zZRF6Rz&0}zh;n<qa1Mmh%zI@30@C-R_&mnLc8$WwBEXW6+|;;o|M<yaQr3GhuacMc
z(<EqzO738sC(H%%e&f723^?8h(-sA;wFoQ;dwoJDPU>nac;;0orNf$#Lj|Y&V^P|A
z?)e^&pn2<+E~tvCjY(Pr`#13~o!_wU5R;^URnDlSiJcSX<Q_{4dOFTSYLxTovb3d0
z293i5{+v5C#oveVvJwUk7+I~Y*G{R15r0^G5|&$v(ybK*mb>_EECsSynN*L|i|1p3
zfE(r9!K*VCQz=HP4E`kNLTVeISRP7&av?+fbR>W%>N-fMqg(+P1CWYBr5YT~C><)U
z|5SVrQPQMZ(qdQAcBbS(TFJwjl1D=&ou5jcB1*eeOXGh!Td|-~WN$Y#RR#~qo`*9x
zN&yeStSDqXRPgzq(us!{B}R<)j41!BYrV6W7)##QB;w^B?)&8Mb&nfX{=6TLs@!iv
z&fwDcC(heJ4{#3xGP;7l{^<NcV8~VeCUUHqYK|z>yJ)dS%$1S_(}@Eyd6BsSY#U*r
zB>`HaZTteW${-t223>R!do+$BPiON_s4R&J${gs~B{16UOp|EOkpvOl;j;M}7BgDX
zuhHHh_mqGx|4je};9#N4B&%dTX#?b%5c279?>{rBRi*$?i;~~E#FxvRMdsE3Rk^+q
z+nmieZlWBMP!1?Y`4_W}@QB@ZMeg+Bmts)Pio!zq%B~o|wTu6kOVvUeYI#GTV;uEt
zULZ<bIPvoxa<o}Zp4mI`ij!q`=7(;EhOu4Aa3WMBDh_q>OrljZpL{SGgn|=;&5N9Q
z<H(_O6mKqIb9jr_u3bMoolp1=$EXe9oezjmZbP);V8_YuAr@c%d@j7KmS;h8;u?zP
z%o{`zy&}(o6#H=P`uP_eKE-1bz(X4UT!)xK#aygsz9}a)YOZMW{KDt+G(rFV5|}(H
z9J6cs#RWMX%?F?gTN`b|d2ZA;6CXvHMFR$D`T{-k_j;LUUdHH+ps2@*ydxy1&8{ra
zxC*xTfE66Y<C41mL*(v5w#oyw5%G${pUZ__he<tZy0^ln@7iFd%H||6l9R~Ie1z#i
z@Q>nh<&v<igq&n7H1tQfE1=gzHg{bxjcKm>hef=iqYR=oV95w)J%MsP$BP}V)8i^T
zY}Cox0|M;f_i-p1z!7On6}4WeI_)hOVr=1ex1QVk{_74s_;9j{q&NT|bg1`y!l6==
z1`0or*LQ`40<|9*)yyw5H$Dq&)mEQ9-fV?q7ff-_V+}SpG+S}J*S1uPAlC#g$~p8v
zZzx40@NC{(BrFxR!Yxp<A|iJ;pWsg*xwp^Z?R*~kD)Ab!i5)q^_cO}48G`(8%MjO!
zb0o1y13cf`<OgO=HBF>bV=TkzF3XSk8cpQTeS(32P~C94&imu_l3R{1v`<_t7TAtP
zJ#rSp93Yr$QGXXB{pSV#;_QcNaUo&CFBKf8)NCAw3N9}`kzmxfgo}p?Bgcx6s>^T%
zo1+)}`QA=&E_~V*C<EC0#}UJgWt+y?+ujtula$w7Y#7~ah6~`eZfprnQQVdN)x<#l
z72v;%g5M1R0lXKI8$?P@2>A#*pYfFW+i~gu{^-%ApZ=5yBHLZi%cdfpjOc``3)|ZB
zq{_N&%i42Tk2zf}bGgVrID<7pTgO3QhSD~8LGrXh!Npx3L{sG-XIuA2s03%BiKsYE
z)Ky>gdWAC`I~n~}DYzGx?pF-eZk6=rp^@`0>eB%8O%&f=GWSPo{--B8@H#pyStw^g
z;5h&wBh-mhUbZXj55Wr8@=yT|kkiB8T0@FjQ3BKU7i#lP?A_2EK}|V}DV&H1k8VoQ
z;6y=vDlSYN*MVP?_+oJB(zB(ZfQNqtTv47+qvXyM;<`tK4$_|8ID!7-5LbWmEZ6ve
zfjfUU9$yjcbX0|QnF_=j*8@?VywP{+$*Ai%tdH6g-U(PiN73iY_k)JDEKQ%Hgq}V!
zIT07}^!&AvT)f@lx`1DbB<Ys`6$c0S#)ZSW%5V>|9+%CK)Dlo|H7~KB#nM>;$TMVa
zf82w5XR-Q5>D2LlMsc^j!^FsW)Nu^bkJ-LYJ`{Q&eQ@-JNAsPutP2A@QurHNnbDnn
z>80lS1Sz(+1wQht4kPfgd05|KtK1!y8)%L18!vtgA{*I+Yi(_{JXo-Sp#}EbIFPfA
zrw(w7Usn9Qr1XZSkUy4M?F`CzK~=;RKX^3U886`I*%Xi=9Ah>*={;?x`s{)a3-=Xs
z8FKUoPGy{SmE-)101CdwJn=Q%#d`dqN<Cj3Nk+O(dVE<xbjKhbm9@_laJGi<U;xNv
zRKbB6oW-}vM)k$XT)%?yiIVYnCMthdSnIR5*vK`>lZ56`-}}#}vp1_?Q%CHYroDn;
zL0tpi_fQcy7<J=vYTNybVZ0Gt+~w+m`u;-E6L0MoUR)k{@rzfezw>QTa7x{vpws5j
z50URZy8G4TM1$n?qOQFEennV7`Mo?|EN<e~M%D)+8kXERC$ED^(P{Xj$(iRmHV-{J
z56hlMG|cn9m@i!!fXPXA^k6zbM<QFKdKTb$8z<q>QX>38UC9d)@8@rqsWnFNjgv#C
z{F$EYL!`T+vrw6>?oKn%C|9%0zfGBg4yeH`nIq<lrA<exzmAAgix3mC=@Wi(Sl5+K
zAw5@lj`j!GCiYXr1=VJ(^ZrsvnVL6qR-i-PY)d{Flgx1O_bgYO2Hi0(Q;Jv=7%WDG
zOwz)&lp=4f6w4_;>vG-GI}z)u%JBC|YgWl}wK0iSEh-Pdx~%C<uU<GS9&ubOcA}cD
zrp5uD9M@5A6GXQ6ls!6N^9gG3xM=uZ*D#ir7!%Yy8l*W>t~oc!3HTtWwN(E3W6$Tz
zQ{oSji5zYIYUi4P&Ww%bq2qGM>>;KU1c08WgElO9xcCa}vEf%FklRA?`8tv>b?jd0
z+sEs?)Oy#-Fa9~X@h=L#YkKVSgzjNCF}-{d!jirXA%u58pMWrM<#L1+#(D|yA8(dm
zA2ST08s2*Tl_dx5X%@J<8))Tw=iJNGXY#PvcHtyyil?<vLW~it%t%foLDL4CM>uMC
zQzB?e`1JPoid=44UH<cT$IjnXt7$P_i;}sQUu?T+0z#SIrjRd%96dH|daibMl5459
z?7RKKkerN!<4fN08l<xhA{T&{hvtGvd|EGrHiUq!m&!mQ$6~hG;%xlpLdFqD-|bq^
zSBHt`mI4y%@-8qmKfi|o!VP~MZ3)u0taY{AkFrGfw80iy4(Rj0Ty87ec~ial!>)<2
ze{82j4%w6Pd)--Rn#}jKYhYyFr7uF*Vf!2cWX+MamcCY_61y1-h<v)s{pErWdto!+
zuyKlj#Ps>Cs91J{FtEC@WfQFl+OUPAiTm0_w4lSK+eGA-Bfl1iOn0%$V-m?Z!uXus
zn`oQI>m%(8b}X84@F&+3$u^Id|5FfjI5}_K7v%8ji0ja#!`QaY3oVIPv5vE?j_-nm
zKL{TSL(LDJ6aOP6Cy=i1S$QMr({;BdC+baQ0E+4abM}7NGH*5k`-2dS$N0kIP|kZO
z%X4DUI#b->?DEXSk}Xrr@u-65<cBh*>JgjR-wrGP73u`PsPuaI(XsUCg>TEVFHgU~
z0+j&S3XSUz;p}*fo<@$2-8kF$@9se$5}khh`q#e~olcgPb0(dU0|vJrnBU#1qP}^p
z+3#S_S;_zJ$oR?h7i%#dsng&6x{{#+N<K4D4nSI(RNJ6Zo)R&2QrkRYlULfrPvt~}
z+v&0a{R=bhO1^Kl&rH>L+zWa4=4bd!Q}9@|@7tZoxrZ0Ne|-1$*SY!b6anQ^bHAgP
zhprty{eJGx`L&5Er#q+K?Os@)Z9BL6{@ve;8w>q8%6^>pdkNd0UfnzW;r+kMzc*)<
z-zVy1m8w(3rf+ZryY_Fcz5Q;%5nZywf&RKhb?4B)vZCQ^5O5bz+OsT*UADIs+>bv{
z1Bc^;CnTIO5!&oB=XGZ#5sySw>s#Kj<5m*kdje$qb)GJs0f51EDAPf%r#@hBC=`<c
z)J?D@MJfdDD3xp<ZsLNu$Jl8sNv3C<|F~<*qnc?<*YcSMDsoQ&UM|W<6{3SM4Oi3p
z(8e0YQP20K`qZq;q89VVZa6Q08Z&9ppX&UVuA^#^E~`3tJ-sr57e{gKAvO`dK1SOs
z>nQT!o%BRrJw~95Mr0aPkmLiY<V24O=3R#nn$v-N$VPj^YkHUg_tDka82}1$BfL>(
zK*&-pPv^Mjcchz%S+rnlPnm}Ib=}j-kGH)&YA)=QpE)gc!DmzOZ~395VML0ox(YTx
zCW$hXZmSmj?>p1}>)gQYz-*l}(nm?xrm<Dnwk^8~{(&D4Rm$|W$?EFvMw6-3tQZ^>
z-}YmHG4wP35v#cDu7Km(rR#hRvO4|6NsCPb=*Lo4w7Wsq`UlFxeRx>n6|(<MAM)33
zQk0Tc#p=&h{C&(n{$M-Sc+%pq<F418iv8c8w-^#cF|0<}T6)F4tjbM_iW<AG8q~Or
ziuhGEoX4r=xnp^B?UHgf4`->|R#`Cwxx{%a)9}LnG4LVOEgKapw(z7W&eYUEiN}@~
z(6uvA@m@(!$tJum`!B2T3||*BOtm;n#uxKNQAV~(CHi)Grj|Y+#>FsrD_Y;u@oCN=
zz_21heq|?mv2*DtnIx6m=a-}r9fUHqPq)^wg{S}1Omwo0{}3r%y|T)aA+CZ<M{J*T
zQxY-sGw$JZw4ZXEb}tS1N!QrFy8f}6-9YKY_ttf$r18d1r1*vG2v|CVtF;CqHFqZX
z-~3#W9t$9Sx_YOs7V2dD=*P%ZS5<3dS_XDbP;TEr<tB-=B%$6nU<@zM3LjLLVZSL5
z-dhkLE+}4(;2M9D>Hox&ECAGD7@R}80}n(lL_{I5qumt6_TTvEXkHV45pgAzk$)9%
zJOZa%FbNw7;tz=*lKRABa4n#VE&7Md65c?OuQ*p=9ZHVFRYPx{LsXxfXdZ;ByFVhm
znn<S>9J`~@tpyhEA-?xyNWPh<9m84kh7!4y;FL7|$}(TjMj4sX&R>x$FZY7oD>AH|
zCUr|7-c?sB*4U%z{x;urhdlRrT>lZEEsy!givPBKhzXA+6}!QJnHA`!KY#}&`P9Jk
zz+@Yd2`qrBbCw*AMu!YHoD|z6$vqMuIhVb0=DGK4sc4wxsp=LZutcDUhAZ?mvQqZP
zAmkLqr8QmHN*2^;^SGE3l%B+xR5|O+Z8~b0Q!=3&{k`PaKX!cnu5axX)FVY<KUM1s
zA^JvAbwmjX5W<o<c6en9F8kaIX50?ap(vbqbt%s_Yrwr)uj-6r<R!P#kM4I&R?awG
z*>z)ad$0+LVJ=yh+$)tlYW@ojbGy0g&bINWb*uV(c6`?T`ffjZfM{j2xG|v_(S0Bl
zCBVkKUX^(xL_zTb&e>b(BHn>1)66dh1MyS;FqRF~o*zy!y7<$A6fm##u2~d_w`7!i
zuwQhHz#q0FYkg>1lU8cLAQ_b|RS|nt)z%!Bmg^a%h)S3rR<|j}_j7yboRpQs(w7mz
z8U*nc-&8|E%6(1+&tfjW3wO_kE4QuHBsN!;C^e2l-RqACs1d2v8QrR?5QoZfLJ6**
zVu7%O$ndkl&m=frOw*_Ac*r&Md1^6(GTtvk`f)Ocze(7~wBQcI`Cy|Q#h0`#T45G#
zr4hQ|XQi(NME-teDoWKlO8Qb>;?<~@?|yjT=c~sid{o|N{^?Z_6LBqWTqei+PgT1H
zJ}Qai9f_Snnsd+dJXaZ@UD`xyvcuvRGqqmQo?$A7F7`;I)L8%v21yaRc-MAuGr@?b
z!&)CDKx_5c;mrttq`Wl8Gj-uT?5X<F*7bxh>OvPCrarGMi2>t%xLdEVXFhTXE9!@(
z*P(%L#+)K0{^kMmMXzV<g+C{cehh#PrQrpW#Mz+?y2XG?N&}kaQnK62SLQNOF$sIR
zd#%M`M<_Sgs4$JO)cg;1Iyl=p{wd|#C%v`F45GfJxKA!b0qDLH4IxPfH#WIi*Lg*@
zr8vDFgpCy{4*LA{ikJM>VhFlYAe=A3UQkJ!br9s=wF;0eS&Ma3{u+E6PLy!}7&E~C
zz%SzO^=lh$hR!KyZ0rN7)=byHVduWAGf##q?Sj2Zxem!2zZI{(s=sP@CR3Ai<H4Mj
z$Ee(Ni8e6TD+B*j(Dq~G(`|jkOYqLus=+H(-rm~*Tr#!k&1^Lwb48|c?T~94D^-`B
z?7<m7xNX4Q`C_uUE1~+7l6fzzzC_4``gU36*_Ag6)N^@fg(vznvg~;h1cQ>4o5awS
zO|hp71s0urCMbkgpX~qoR3uWY%)ccs16^`5piry&9Pf`AgHTknguULayGUMcN%_5<
z*KJW(&($lpEjYfykQy5DpSqcSNl;E)@Uy?zt9)wn@RgOtL!9`;l0#ehcM_A;P9=<<
zKJ}wyHF4F9lQ2#{wOyfn<&)#s%YIfek~Hl&zll9=+jvVmf=sKzxzb)#E@X@TFTHo8
zwulHqce4z?UlG`2#`cJ2tMq<KN{44<f@i%^+@=Fhvh@cXcx)0w7zYgv!;?Wm*gVdF
z-c`_*(s^~6!xoubOQ1Y!&!yb|@Xyp}FH*~11xuYvL|_73_^TT0fi8;>y^Mdo3<C3j
z5~fso^qOC&`Rdymk8y^mThpCK@Gz7y+cWdga9wvVT(Opc)j?Dhc9r006imi2Ii+it
zak+;PNXqn)MbHOfBs+wWC!NBghp$1>3-N;6Fv&WGwh{OH4!F~N8-+-3PVXwkLaQ*T
zeyCIuv&Y&f-Nl(FB8tn9`~cAI_Ee)BE~GVirw432xaOVj@0@P8MhhsUC$V756^O)H
z`UD&4JqV-jGKfa0xEYG}IPDiNAflfVy+&&;r&bQq-FM;o@vsg~XsS{roM6=lIQKmq
zl*2LTtH!CBBrdnVMW17OO1z;-g>)4jAZCMp5mh6V-d25=Vfj~XmWr6JU|{jq%_@w6
zT7<AL?<5=>w#68TR{A^4FjQeYfg?_<z|YK>WfBLHJZ;?e=%Jqd!4Q0y3S&vGzZlHM
z?^T$8;%b<Irjw}nJ=ixY5BgH2emT~X0bNT-4Q`}j$DxsIXx$9Wo5iJ$qXogq0qwnj
zXKz#lq^eOQ<A4(Aoa(=p;>o0Cz-c}zqJaQ3#ob~@lIF=yA%v!Q0*7?hh`AJ~o9AF^
z;vl1r;XqEosZgxfpl8Xc;ARGa4GmV|j^oVGqm~(Oaw$?_RQ|MER{%oJpj0eMD@)d1
z$dnf1`RLMH#$ghyqtWbKK~0z`BxzleD9b30=B{m&e$bw0nSoamOik+IzQkgL59(9c
zv;z#1_n^KP5|eD&pH57rpbkJe;B&0*qz%irf1nL4eEM%|5i3aGFpM~#ZUZMbY|{l7
zD3USCPazK73iPDkDIpqZY1+k+3f*JtaJy()lO#QZm#pd8pHyg-<Js5th4D%QJ{>f&
zx5zLf--z!RE~50TE^^zFGEcC0^_i4sLAo7AL)w*@7k|_BD$4^{832Rcxgkj0)XpIH
zhqB<*_5b|m(|gMqr{~jSI4Y^64XJZ%_{n)5))2%;RwA9<I}t^@%pern(GwX^qYB;|
zja0Ir)0V!|b{!)oz9G1s+blw9$29d6h7S43C}U8$I;#N^-Av_vI%X`1J(Tks?CzzT
zGw#ga#yI%}9?Bp*S$>|0h309Okdb6R=hpKG;Gp14`JLif$NcrTEXT7Kh)Ok5LExOZ
zlW=)sqx6PFu=6loTO1$Hf}OT{a$JQG447MQ_H>*Pd0fNLG#V8yfONFe8v^cr<sl={
zJ?czIQdF91m99G9X!^L;!B=qd6D^6QWNSAvh8o~@DGB-SKVxPiI^r%9L!;nKvN7(V
zkMF%*W;k$E;CSbW!XC4uMl?q_y|b|E`yLF4YDi*H_2<*C1U$1yX088V1bC(!!MPex
zx4ZMi*4<wK+O{O0-p`}-`1ZRsB$yT(zG^=PY|tLI-^y^dILXS0Z|w9vc(bCY9Yosq
z<O1KX9_hbdrDO7wjE?;`16$uNPmm@4`g@S+raH2q{;c8acG?*;?qP+59NC7%HR~+W
ziHr3N_A<P@4`O#sRXHJrLVj>UmSHol3=l<=Jn!1!navPHYaMFdO~_xnt{n*+t!3nI
z!yb#{O>s28cDbZ@dDTKWpGJnkb`RRYCF8d>-N+`rkOuw&Nn&z~38sc@!0h2(NgT{<
z2*oXZeDv%bnn$igtO_nF^}Mg?K#vENPvahDrBE7EFMVZ%&ADbpy-6a!$trBkW>6{2
zS64jlgm$|pF)0r07cpy-`FpT5pBKVKx|@F(Yr@>XZ_2$~3MS<hpk1HNER*~6qPLXy
z{3urk3zFfS+QNb#9)?{UW*Bb^%G5E;Ss9VPVXj1vIFg|$YA#83E?wJ)#774AyJX68
zb&QXtkEg)CGS-Sq;z>w{`SiFeX$^C9;w#4VKl;o&hTsarv@m0N*ZV?GVNE+-T^o{*
zvp8KV9_J%N!C-Pc2~zLClo>F<@Ra8RUbfxbc3}IoGE}J#*3YD*bGoQWRgAD@i_G8F
z{}q-cwX1)+z%W+Ppv+S?4t?0Ff`65mNM~|U;A4h`&Hg?rc3uN}vaRIuw>Pw>l2pty
zwMj9!`MSudtQiOq`aV;w!1*1$<RQiOvq6P_Mm(+;P`#<~{CzgjBX|+qz<zk5ejGsg
zr5h<=R$g4Mfg3xgAE`K)f{watc~@BDYeRHitFDL6T(nZT6eJK^nDOf^MRn=*e{=rn
zYyMTNaR8I=(gqjVhml@^k1yCouT)@xybDI@nCEme24Z*=hU#bN9b3w7pUyIJxfIXC
z`(DxacM9Zu#p}tpr&QoH6-w{qhg(EyFb-1JPB|^h(Bb@qw<5U@Mihlr%J5L4@}wRP
z<+}5ee&Kf}b{3}3pjyioCmGpo3R>D4K|<bk%hiB^ZJ28_SeFI4Y3-0I3%@k~^y;GF
zeKq(|<CR3>ibpo#?}US8H9XF!1UJq-7Bq8!g|3*Ph>7@~Rbk*|Y2i;kO76i2hv{!R
z8DabMh=CBxcD(wag8uLS&af)=nPxchjoY1p>K)v*T^<j~sakx1t|zR)2nG&*dYduF
zv%)R*26h(ZpUHUpuqs2n@oiGq+toKP$x5a{=Gxuor+wyc9{`~{ej^Rn@=j)H{HbJk
zlL8*krUX(l9%2eJuQp_T3r&anW}#lM#uQC)zQTb@dQ|9A6zes3Td-xOHz)pH5)oE~
zB;S7W$_xVCPiRo6hHHny8sfte8p;F5(Ud`Yfae^K3zzzFYw~`YewTax1~+^MUT`0Z
z9j9Do5`b}NlJ>JSm9#74sW|qHY|XTI4E+?T;K_EmWC!<A9MPl>PNBf)3_6X6CMj5h
zbrw!)7k5-)XnIg7>^o1D;7O>6o+pIkWpxiTCX)Cd<gL}5_|#@}H<9ObmwqIZJ$v_^
z*=r^I%hXv}1^D%pLf`Dw+J<s%ZJJ{!?MA5yfLSLVJh^`eEjWZ23Zb|o=9=JL%}_%U
zmHiKH(8yKr99|&NUpn~hD~BJU+emHXM;JxXjzvMNWVvY95xO%&N%7pZ{fHy%mLwcZ
zWc}-1s|cE=v|(s{;&`fadzwoZcl^V1-(R0Q2hr&4l+peTH9~HbuvV`a!Cc|zpckK9
zG@4Pva)qY+SJDXab$*XreQpG&wP;0)_(hAJixx|Y#^gkc-;S2J7cKd8^COu`9y;pP
z?R>l0<ZRxfz>*_UPbIc{8OJbrHq2DZiu4QG(BTAL2ln0YQ0_ns)MOtM@hDCG5!~0Z
zy;D8r*`{~K{KTokj12A6<@afN&lpj_+HAL=<!stPT;yBrd7X=;VMuPZ^&eJ7JpXB@
z;@iQxU9<!hI6NXFnUe-_n}Hr$4sfjLhk7-XvQ^SPqy8H^Uzgl-3sPVzQJ2UHyN!Y?
z85Bp7KZOkCwM-&ppPEfgZr?rVf>)}*2~zFcHV>F$Nh~C7o4$l36At>BJluD;X`YQ-
zszgZOe5yZjL*sIzb`HP8!~UY*`Wkx1v=Xf6)8a3dkfSUqe9a-Ew$i_7-sE<=IWKgA
zhsPiDXmvNm5nSi_+bf<e6d6-<`G)Da-L9+yIaTj3**i?54?EE{HuU*aYg9azObubB
zzP6;#jQ*7D$i<?X66SM3N8CK)q4(i{Ge+rj3wQFQcwM*@y(1g7hfv1;#s`G8%*c#N
zq!%?YA~{Uz&Wkj?)2=`}IIxiS#tg;Qn?9rh)@^(e9~vsK#IyDi41e=8>21ExNJUUd
zcCzx}>oS#Ua6ZBY<hUxlQcuj8k>c;U=$6T4H=TBQmwrH!#&2_Peez9;Pr2j|r2rKV
zL%M)LXgbE)4&A2ND~}*(Tz$Grz~_26r*DtmR9883RU(l&nD7uz4h>xcW?m<)QO$)Q
z4GbD~L)*U=E)>!8!KL`-Qgmv!$%8emp2N4EY^FY(M|a6lwrTX1v9wmd|Aj{D&j|bf
z^ZZeBFsh+|HhZ5RNM^xm?Vj&^-cpQ7?8CIZN-7PVNEHX?C;O!~ojhM^`{ODX*^0x;
zuu{2c!?su5Xyms242*M2Ep670W$z^M_GMhH1ECDrPN>LI_4exX>?@`1%H$0(5(xmf
z(^~(m9xm=q9uw{WZD`>%D8-P^SX~r=1|Sxq%WG(bp*$t0a)+82#s99sPWJemi3%Dm
zHaxdDT611`?3Q^Fm`^QMW#aaIN`Eex<@7M=uiC)~;c-9%e%b#r>{~+bCH;bf*=oV0
zmZU$S=!f8un%3lX@E%V^_3IO{XW(j@0fM+wPe6U5e8_@xo;_q}lJH54&eA}(3?W-1
zK{vQ>2J)h0)v4@2Jp1y`$SR-Y<GSVh+Wewjw+E^6OMPxe&i<xGTnh-!o{@mS^CIQb
zak0J$M&0xECr!*7a*cj`d~utQqvgxixdYnzS8_Tcf!zET{!x#+I=Vh-b64%(8h6QT
z^4qC3zOEO$xCrWf>Gv7t>)X##ew|pEx%v<7$x4P{3rS9XvUzFpSA6h-lDVPaG`TYo
zDTOiO{M%6JxWtKZ-1pxV84{7iZePb9)tT~)!#$XaOub2!rNsKF!isE@t(l4(3vhza
z*+z(0Wv(r@s50+A?hEqyPL|?T1#YfIEU7D*C#tTWjG3*v;YSg#E)2}`sxCTRUQ}Hi
z-aK1fa;``GPU-ncuRAv{E*9Onb$RPkHStPEytPzpyy)z01@S4OE`#%USxAa$w3Q;t
z900Ma5~TxNRpeDgGYqDD>}4hI(*m!1EzN_xPAPgooy<2;JNepw_g=!Wt^0zt4RH+t
zt~wGA4F@lRJe$H}+aqk4mVc%eZZl+~^<P-5L4Lhd=Rs5Gmd@gD>r1K&6&<vD_poQ>
zIiRloqhIZGu0I$pvOK071>oox@0(u#U~6AB0Z#?(1|j02*~y0#zhmn@s_l>dm`DYL
zE1Zv?h$_?$8n`eu5Hg|<lZvuHl%vF4e=j*zi&mH_seVju3p>RqTp7D)-FKt843v6}
z?$sHl(vKZ-UdqyKH?kbZw)VO5YGhU)aaJIz^BHKQC03@$_j2OTJ1EI^H#wPe)&Fp+
zGR%Ls(!-I$+KLRMY+IY`7YNxOKOW`269k01ya>5}rkxjG@`oURp9c2FbYJo7A6rN{
zZ|aO;*{wV2{WaDb#dYgbi{F(vA++LJ&z}E=^Dv<L$`mKQJKJ9h;|BC+K22gI%i5?J
zs!yYO`S69pLJp>XjR<+FodWWiI=3bDm?G~<Cq}jWzrTckd3o`S{Q}pY{81YwWW#Cw
zy2GBvPm0LPPCXBO?xB$Tv9YfDsdp4IEtjHnm_Iqo5&&k#OYaHCO)&ZYi@x}~iQD#k
zLI}Dj(Af4ASWmJ-4@?^`71H9riUq2t8Eol1%qMfgWxltM;0hLmaZEg4FviyWwOqHD
z`H)fLOy;-Y#T=3mSkQBmt|%o3$MB?xmNd-=Mzl*r8d+L%<#O*iOfvE&<UJsAF3Sqn
z1ulYgGVr@j0P=SZHh%MbwFKix>sr18Ng3dyWs1n^WPkIgOL$=!2ISLuX3Ny$%5Kte
zTRPcMOnIp!Bwd{Mll+2Duf}mWw_(EqF@pA7=1qHQ7_ul|zb`~e&if__z`=vp1NAC^
zp}!KaJVWOuA%)FUi{a3r6FWp55Rnkt=#u9!S{Kq-XLn*}g5GZ$qLJ{)+q@N&$A5K0
z-cJQqzhN!t8*iQds5B%qW`frkRR-t8ljqb8T^|7C9M96qk9O@%MR*kW=2{(9knWlp
zO~zVT8})_U0tqU4%k!O4aR;;lr3vhO)N>x3Y-2A!4ua!}HySV){4@?$+%j(JKBljK
z8UuuuU-nE~JNUm4^pxXPpGkPun3yoiwJ%?!;;U*3*G(T=36wq-EoU3PTN<eFpWH8u
zO%pdo$2JId#n2<|n>{5vdKZGeG2{rm@#o3YkdLXJau7M<mYq{*=}mrXqnP^HW0AIi
zx*2LEYiMlTn<#?!W>F7;(XgvvMZUB~0%kI7`q84ny-V-Z{r-NQehM~hq#V-l=MA6f
z#TquH`)UMAewle@Y1o{1lcN!=9zF{m%JXQ-%axQ$X5_DBI28RukeRh!EjyL1H@@bJ
zF5|dgiYlVBTT|ul;ZHgtmql9YH6!o2=yy+*m36j#HCQ9(w>bnI{wgmtVE$1k$DmeG
zLn1T0{LveeA%96fUcmJ2P~o*)1ye4a728GvZ(pKl_AwpaS7$9V5?iMf?qY>Hge(5L
zIdic^yXdg<*4x%EZ)#XQj}8Zlii$+bwRhff9?&gVm=DIhlxY`nxSRy4A>zP-#VvLk
z`xDt87>6BRnY}n)!h13_rCnKotMO(nE<4ZBl9$eShBI6%yfYwg?xTSK@_q>%VO^A^
zZXh&w@PYZX*A6Bh)516<FM~wK&Y(X`SS41%ZVYNfNM9(?BJyt@^3e`Kb0KJUvS?ny
zK`Xj<e&BHBLo{K25d$JVv&iGU{;?r##CX$@=ni>zjvE-0)!8h2oTfuh8|-jSed)c|
zl+xj`5H6F7j7M)CZ_TsfJGWp%qeuakg*3B)acTUbzt4&_Rblhri1nY#N`H5kwReMm
zk`2M(p?_{zoQ9(CLH|Bj_nyK0*?^(9bVb)A+I3D#4w^rnfPc5|zP`;Q1ipF8I1uI`
z{nuiF`^lXL794lb0aKTz!;HhoV`!zZc=*lg&xRp=j4yh((O=JA%E8QB*@D~;u|#ya
z{MCth`z>M_$;rc(9syWJI!=?1POUTl9=_lALV+h>G&+9y!JEO!gq*|)-wM^In{hwS
zxKVCpjb0queUX1C)H(}wsQl0u#UFunEN){=k5KU3sGG$WEEz{#Fh&0e!-_=%@qcAr
zAaPn?XZ{@KUugv-kefGhKTG4p(23KTtc22^c~WogB<=4GZ?<MWpIaIvOExF1kMQUk
zuV?*G=?$E`%)t8KdG<2nEK($Z#5U^T69&I=FC_g){IunO-S{WozJmQr)+;~zV`qOr
zbR<^gWrn-HTFe0AqUf^BKWq8`cB0b}SKX;kzy2WKmYH5hg<s&q^}xU%1x%((EN=*=
zStOln<WzdDzdm&NoBBCrs;9pI&GT)-ukNq8UyK3tYhJ(h1^;$krOpV8cFhr6<_~W3
z`9Hj535e~|M6FNXm9oqvfp21YrBdEc4b5+>+|EAw{g(0%tt6mfAvb%DYSI2a5cTf!
zQHL*AAnOayaq&|k?UPorwnX9L!iaZ)D!I2DSsS1?w(he3J`FvtaRTZr_rLbJu=#-X
z?hfZZo4J0AuAX{?&81hjmZoe0;a*R7YfXI*%Xc5lGc9F=Jpidw4d|I04${jAs8}~?
zv5eOfRaRdnB6w-Ogo&3YC%Y<u&Eh?q4N^6s<oRW81Lmo&GnU_73hlP%4B@g-u^7j!
zJkHrxYZG9kmnoY+c(SvN|4_LnWU)m2^Mdf}p|?=rXd@LjPF=&<TtJn^2`4`SfDihX
zdx!ynYY-KU35#t?Kx2=2Db=ayB%ps%W_#E;-s*0ZOkrU_9-p;Z3}bNO4cge@F9>_H
z&hj!6V!YS=7e62-1y(ZZkr~g**jTV-fey8T7ztuOmrI;u=QRe>gu6gkBTI!Y(CpDA
zgMdK8uqDHoz$2HIj!*)P(wB_#0*@9i9W4(uu3a*24m9alGO?$ZU$K%v@tD4mKdO4o
zfJ8OlT9VwdR_fxapF4o5g2L*{T{S4?-zLm-gGw<N;vV%E8k9}8G9A4|g3vj9xhDuQ
z3MFK*hYa3_s6%M@3nK_cN`dM{1P9WrEB$RvNq)A&l||d>*Uyl$4(tX<h<KgAe_$L|
z_}HcA%g)yk?aLV9ju8=>%@Ty-#&#V;_Vy;o;Df*#5KFX%<>4qU{k|7C_Z5$jmE&>2
zmLQz`JVh5tINaA`Z)m9jU$jM8YLdV%lPj^98M$%LJ1HJCB*#LEDn+(2O$1G&yWd6-
zA{u*ba=G>)V-YjrN4u;8<8p4ENmf_Q_-0i#M5ZlzhWK7mI$t;12my{5S)N<&&P`sl
zK;2Ab&RS$z>W-)DgStF?=?nT(3%=KCG<prXrfp_kS`-le)KNL15I`!lOpG5QN1`hx
zhMX6KsVa<oV0sgsmvL~yp*IkKTx8LX$ErXIBl{$w*>b34HAe}6p=^dZfT&XFd=P6b
zLYb9=i(>ClG!4;Ba4=rIYG{LQ?FJ$#wqLo%3W6iXhjE@1ywZY4=Y(iqs;!8X^6PY0
z?bVZ3p}(xKMqjBZZv;)ElKn7*mRE&d@&1@W2gS|P>BctaFT4!pr%4VLSj-(e4(STh
zwdpbF4awv~<3jW>bP>QIXP<qF*xk5b8EzGfvbko#oJIcQ`oIn?h|8-(=UHT0+w-%(
z21AdKlpVI`J{D1au5e|m^n3j4S>}W2-BhhxN#=BKr|6<qam%23E2=Q7*8)c^_<TlM
zYdU6*Kzsb$q>uh+neY#usw3jN5HEM>(wH4FLu>i1oC+ixLlcJj1J1p>Dpr@jp1H$6
zkW|%ukwmo(_2(3v{KZTrF}tVZdvz74cN@6sGhsj}!F;>NZt8QrD1<Z)s@GQ%XUj(N
zTgjM8IVOB=+M#LfQKUBd4G~ru&3P6P6j4-nCX{?r#9A?^U#^wA{dcd=Rwxied-i)O
zV1WPOsqV%Vs=SnC4H9C;CSoH8PGZA57p(}sw!e@N{m>WPYvGA<r~p%f`8f5nyLDBi
zdvTBTl}K8VZUjI+9oazL*(1~n_HpD$Ff-4(&X@>CsorFMD|2D$2N0l<*dH-R<;M;L
zs1eSq@*5**KM%0QVDf0sTU;pKzTx1&gO@i-Sw%y{RQiCph>81F7)+0+@5&WB5JncP
zMC?iFt5`H!w`GHT@u#%Lhjk<(rw8m5Nw9^4uQSzYdMaE;NCyfOjoIeNA`;!>q1W5t
z$ig~`W*-=9`eE+#*Y{hIA9lZf0H2-b`8F?jcHxciVzO0u=XJ_3LmoqQeos^X2)XB&
zCOmv%yIbZXwrU{`fkjS7nFRxbpf|+>)v>A$@!&`(*+8GF9TlE5B=rdN;rpleW$*kq
z<c4*RJ<~QGecVm^_F9XRUNp0ADYm(&wW^C~XZD%5-;xcICKiI1z}D`9rT-vMJ@N37
zu7H5T0DQsq?VaMKuitj%c>eUzH1bwL%cP1M?k&e1-a3|+4CSIcKm3ZA{C=IP5COu@
z4_H8?{zPyqWcFw$ru+aw#c@4v!bsB#Z&_$RhalE@6<9g#W^9o^OXM)jT$}qtS?7Y>
zo-RTa(v{G94$$wJj-WgOJj^rwNLGqr@59U^WC9EC^*Yz9eY^3|*tY)be?t4;`1IbN
zla*W1k>jUs<OX>W8lQWw_tMn_>Icud2y^wKtS0uj6eS>H`j$FTR9#QYzrZuOzFD1Z
zux2d9hA1#O-orV-w#t`!wKaHY_eJV`F5=?42Py8`2-|qROOqC}<!<SNN_yX}veJ8B
zxgq@>4NKd?Ql#`zBqTv4izY1Ged*I_=f~Q31t)V)4WIz;#+uTdmj!(Aw|XXUWOq(w
zuHHK4vM^Uo=W<O`xxD?tua4VzbFW=)o&2VA=<m(;Q`$MtWr&dT%ho6z`39`~P;>t}
zw(l7YO(8mfyW|Fhk08Y$gyRlXqMo;b#h$lQp^u76ELbHSzISb7DcVTFf0|qw?6L??
zs(!>MIA0y+q-_?+G7yxwxc=i4_Kn%}*-eox7}YmD>z&1ksBhjCx-f*w__K)iTZfP|
zgRVJFrLRtaRaLGy+hE%r$ec7!ToenkCfFr!ulEjk^k42Ks2+#v`b%6MPgihHiA$J5
ze=c_X;u(@Fg;HP3Mn@l0DZ2{&sm)16oA|3g`QGrSQTvNFfy+*$5`Sp9^jkzKTnOLS
z$uqBT+Td_@LX?14?3nZc`?eA!*R27l5JK7A_}D_J9dV)P(Pxi;<i<es5qHhhw{MGk
zpQB;$AEIR>w$kCYkUaJ8<yME(^`T!3UTYfKLGHW#BHrC}5cjaw!LUD?RY{Oqz1F+s
z;Jqi73DWJ>k>v$XMDcDIYJjjf5p8n_nxoMKGgL`&o$4_k{HEGm?t1>7R}FUM{yom`
z#c7SD?K(uX+sFqay8wZu4OPqgIX;H~hV;8wE0JZ8oG`C@Y^$)_CeHb}g}yHu-e&=y
zjL+dZ;*R(I(>uyd*PNQ=h+C<)og}c!bXsjBFEs`V#U`G!=C)~sEQ%l6{pJW5ZEot=
zo9@WSdn8L9&iQ%q{Exvr>%#7{{ZZ9ai+ff|EfQvZH4mV2-s0015W=YfnZzc2K-O*d
zwXM~TwdQhf<d5wox%W;dzx67$I3<3M64T2$=y8J2XZ_W66Dy;BC&o5)pYZ9G(mJ64
z?^9EdclP{YL)^A#?Z5Vi(89!o{pK0~kws{|A?-i$T|ZwvKO(tL*qMw@GP%K#{o8gZ
z2ND2F@z*o#efY4GPyZYDPBQP&EGcVO4QsbL5>SvVa=afqIAvlKO%letPf{h?@$v;O
z*SP`9m0pu=ya<b>gK<NTdzokU$S@mnua&z_p$#jY-&e)!u<u7cE7uA;hZdB(`!oPz
zUFLLqF8hO3_Lmrbne%ruzK8VRzNdGjVKpH;-oJO58{J01WfJ5Lw4nvnsRcQGBmqNV
z9<+leFiHTpyS#EJ#{*3a_P9*ij{ubtJ2Uy0A;1+FZ2jGll2x7LUuVDl)Z2(83JwQu
zct=5g{b-+lWTv+P7BFGD(?i2-4QIy)cerFdf7=t28~FQ7X#|Gy07qq6sh-s9qh_rw
z#XPc|+?cy~03QmRwC{uBPVQOy%@6u=^ap=!-&KF$y!s~kuzy|m?%8{Ar-~X!83O^y
z^Uq;>+1d;$ZtyrUS&}HP(AC{=aq=b?SwhxQdK8VfYFiaaKC;JEzHczC7<2Q;?^35{
zPaj!XKKsLsji+)<zc4|Dp*=C4c=}g@BKpWI>)e-(z1hD`mcI$6K2$yZ6bl;lBP4#7
z{LdNr<eiffMq$!ErFURAeztB;O|5g`KW9lRu*Q_7@^<ou{r<=ES646ZuTrnBW$drz
zU;U(aLShjAzFGF&SGcTE59hv}MB|fBZynHy$-3L~7L~pB{Cymex|WlbhE29XCBL8C
zrCr{5`J}%OG<vnqVtY=c;IA!_`eA4=u?4Yx;?=gYMbCKHuX(T(885#LwiHQ*uO6JG
z@RGtJW1|f9%avZNr@JQ5zvrGdCAR7D83x_&U9VY}1X%&eTnJJ9c$B|o3a`M~AEz_@
zt<r>4kGBpoOP|L1LtbzFIyYyXD{psQKS40q{+hbi{n$T(Ar3{5hySQ|tYraJARV$M
z-*^LOunF03(aV=p@{WrW1x3L{D@$EP6)QeEifh?&HT_dR-tXKL*_(|u_|ok3Bni)j
z{CDU6y4S<=pI*0J7CU#U^K#ny4>2SFs2>M&!DU~`$R)qv?DG{A-?(YvosuT}_m1Xj
zL()EcQctRDq3Pfn;$?4(n1Lm+L<C0KoA|Ia)pBO~{uRlKXQv`|{!xR5y~**f?{kML
zHad`P&gCN%s*d=QJ&#?qTvlT8t;V%G{97DwOz&z4`{jFi=iCRqcb887Jod!YulfDh
z^z?%ynWU@#5;zgr<{Jm7B+>|v)|*Xw$zk&FffNp0sBtF%JU-C)EJ6-T?qa}^`ZF2`
zGNWN|)~Vr?q54J_<VavfpQvvldI0l-Kr{WcW)yU&Z3?Ay8<{io?6&cwC+e_jc}5B=
z5IjH7Xb2fzy<r3n9d2ycnFwZ`+VZlsDU6R;e<u6VnUm44_1skGx&A8+M9%Zdmr-|T
zNV9eAz6@<ESx-zXQ<S1G#Z3T;<(|t#O3k7O^!we;vfld(F^&Zvx1Z(a#38zv&$lxR
zULG_1H)XBAgJxuuwmbhP=5WdFOQ|MU+nPn(Qd=BUxS{W$O&sw0DHGO(8dIl)&fYoX
zZ0q{7KFRw^+Yzs<E23{gt8U(XcE$YVkW5m<kg%bZu9OnF53@XZJ$X$w-4b<F!Akro
z7-KC<mz7YtZhPk@<L&dud?d{4Z~w&R$<S=}!z)(>L;Y-9NwCfkNG;YlzDHfR6riD1
zkTDX0y1h5KDS_^z;5GZ6<glSTGs$T0_67ROA&zapwcuMtA<mn~E=gT*RE1}J?6(zp
z#kBU{G8#X7l*kEN@V=4(C1G}9H0}@O4gvhzwv&HV<lx*L{z5ktmGWnB?cQ^9$;f{I
z*+w=V%(9h@=Tf1LB#q12dl~F__n%3g*$lb;1?=p~x@cqlos^fNXc*b?s-wiC^X0A5
zt>M#md&DUphnDrQGngiJ^bF21J;;dbdA8p^LJP2JJo@i*97$xb_$gd>MP__rU&@ea
z^FZqNe994Cvc5zz4V4X#NzY!Ys{G1pIv7<ed#jbzn~huSIulPTrZ4~b)-Q8AvB*F}
z=HK=!KN-?Z^FW#X-z&GD_VazXBg5JI`GNCP>(;kb88S$C9zb~FxTI0Z2={rg_zVta
zj-sFo<{_${c-~Ves`wO(SlW|n)IKbGmeu=x4V$7plZ+I)jJTk70-}pNL)9tpKh_nM
z84#IzDCZ1Ke?Ge7LLud{o*Y>0s*b>9U$10l7y>XXFvPl-VfcA)CaKXW;-@Ak0F(Od
zRv!;*J5qLFZO8#=%(|Pqs_7xi_}m<lS6%7IQzt*DN10JI3_$1nS{O1itl%|dmZ7@`
zsW>(NOuSDr@_Hd17i*Yr1Mic}Xs1YBbz=q!^C+g+m8hBrWEoX<OTGZTQnbEq>$X@8
zKRHC7*b|ffykRBVjT(F&MB(t#RQq&^CJ5d!C8&8rMeY?I+)>=M5jW|Vh5$U+bgEEJ
zX>s`KQJrFm{nb3bIbFFMbE!(aF$}+hfNi&tl@K%l;l16>!+;MMvRxXIBg)VN^QpRO
zIs-{<Lo(AyoP?-&!%JBxkhGR!FkqREM=q;=cx(d<{3$xt2NoEE0CJ%&QpCO<l#@93
zk*nwlWF)bKD@{q)F6@Td_>#=-lqH&NrI?HZpIu<xa@a}XH^$KTyD>Jgi#o`g+)KG&
z^Z@(y%&7l20%imU7k`mk_g;mN^0Jub4Ut2I{tr`k{tfm2|BwGMi!qoni>0xTG4^fj
zOJeL~X^<tU#ul=KRFX0nV;^J9k{U}=Nfc61_N@|<rPR}wWT_DqCG+uqeSi7>1&?#)
zJkFf^{rb4xF1M`1>b<#xB11<D64Cc<!8_JEZ#QzhDE9VAs~K9QI;>dkjPC7&|7?#W
zyiYq*B>X@-cZO&al^s8lEY4ynNnZEO=2k<{j@Q#gE#`CL+qyC!QS`TQyn2bWB%QCZ
z)~XYoVjw;u(Q`9Zr`8;;KE5d18ryFx3L-t<NiOXb%Qo{cxAAR}!<E<e8h(qKeihO3
z2(%p*pios|*1H<hUI_~-z|aOWiYOo@26of?V=>eM?{va_X4h733yPO{&r0qO00Vl#
zbp{Jlp8F|e=EuDSspiPDYJwn|x^SpeFv$`3Nmf!dU|G_$EcG$joaNGHT?E=rG8=+4
zP`7H}r)J0WyGF_$b}nAppe2*9SF-<_9)6*)b{5z>KJj&#$OR@aM_d$S(XZ&$?ccM%
z$FGK-kmz1SJHND5UyOvuP*c-SaiD68E2y}hxq7u}G_DUO@y8^;z^L(*wD{YM-|r@5
zE(5uJO7bjG?rkxdK}+!gNx^4Eu{uD5qba4e1lkWh$sJkIfsg|eyh>cWCbXkOR6pKE
z?h}st;UGg9&GK`#w12))>5#|!W4tS2INHhq6q(|!%Mj1-uvh)uk?ro{ci2R$&n(7X
z-eGGQ1vOeWBj#4@W5MCz+%BPi4C&j?c`m%oNb#QC%)IThZm5+DZv8bnK>58m&fQMt
z=dCF6DDz4&d&(4MF_2Y7s(~OSuoY{`^s=`2i~?5{64KI9p&syZGF{LSW5I`7c}^S!
zkM`O=l`2*`n4iug*kQ)wni`o+AjPYdDcoY+PoVot!fg!=_AYBWpjD(i@!+=Ijf!G`
zd}ohRsbJnHmh<bf4rl%xPBULtC&I}X#1RJy=q0%fi6vq#`0&??F4dU@nWos!j)ix_
zwVz{}+H=9@)r1a*KRb(G<>`>)M!|1imy-z#xkWxhFf5Tu^7Pm|2Q*0J6FO96l3$?(
zFryMyQ;#t1jpD}9rZz?+a*^+Cya%<%Z-@Pzme9!F`DFbtD`!^-h|S2hGV@QtR9L=M
zZv5}>a6YOlEI4cjUhwbgfz^(HVVQ7hCAY7^s^raXQs-V#iE!L@&eDGAxF_DW+ZRl`
zNex%rINg1kz43g~P+6{<^y<Ly2If_PR<98V$ZI>T#d-hzW4x!SB|Py)B)tM2Mzb}Y
z-?(?G35=MV1J8Yu%=erH3p&|fHq9Cqdj1(AYAi;-Q9avmh5VksEW^e*?dxi}K(*Ol
zTEBGHTVDU=AE%;0hf1sXv32)+{1itj42lw!#{g{BX$qJvY8U4G!*>rnE55XX`h%DB
z2z<Z9JgmU^wygk+9pRriyW`4|&FJvmm6aA;lruKRk0o}tfh1-WfW8VQ)#BO+NFwIT
zX)r`EjSw>5sQ@JiMm8w<pasEPd18$D$4~u2cK*_|#aDm=a%xy+%(rI@galNOdzMXL
zstk$9*PTMqb;O@c)S*J8&sYRFGqux>q%$b^rA~Muh39ueToe0Chw46OsP`!epJjgO
z^n4f8PfFZ8<pKc(UOThg>8ss?6g}hKVvaO{0V=RD@1c%?M9&705Eur`;G3Y8lGNod
z<5aQtvd89q%b=CmaCI3{F1`r#<wv5#GPPDz1*rB_KRK8=Ja<(Z)3#@h-Jyu_bzL3k
zz({tYh4*!peU2}&;^?Sa3xFYku=~?aSsD0ZCFBZ#zA7*I1VC}f;`eU9!6qTm=2GsA
z^y(hWB25F#wd7xB3y#lzu#=aX%*A(*?XdIl@H}{5qvSOg*#mjeZP~IiSVB<WrXi7_
zI!3q^_yzl&V2~#lNaq-1iI%QJ+dQJf81V>J-py6sGf)2bnEWZM!fyg;j3#)2aspAM
zAeT~xNaLIotWbIwC;CRwA4|A3D^QT=Fiw#2uJdPVD|3C7-_frrd@1xw8asXF66F=X
z-c>GLn<pJFh{uea5wPldh~G<88>J7AohBUfBYePA45Uk49#hT40w>i+W&ng_#R1pX
z@8Y^exAHXqVV!8-!n_9)y!O+COgutIRr$V#3>K)KmkIl-U<SdOc4;3t;&fpwtdg|j
z$gNaN)F#+GQkBzL%9u6&lz6!&!hZIi-fdUSrVb3FQ-bL$%v*^$<BP7wt2LS9iYxJ=
z`RaPPT5jNF>^T*mNBBG;RTnog5dJuJjsGsWva9z3<&ClBBaJi~qKASnozt;^d|v95
zPC2Wq9;9?6sf_=J_GfKL<*`E*`Ka<m60Mu(K?UY|C31Y;;Eba5mXO|Ed_kMVfoi4N
zr}OspAaQYjY|b|obz7tKFMG>6M36Z~)uA;FK<ig+gRL|Hz{8c_KaMVrwZ^MBe~Yx)
zwi(iy#%jEow^rXGysTI9OB6(aT*ugJc|5k~n+zHnH8RL|e$1hU$jAXaae_N{#Y5Qv
zJZmPI*WL6`HfK{UAm2uFOwdkFbgjR#WlN4lB+XmtuYrLX24#jQbG<9;RWSY!)HOa@
zT{-9wh~M<lIH7+(f~--jjykXvBQxP*zBlK}nO_=UNeXMYv?tzLV&bhhQ{Vcvrhgc{
z@pIkKC8Ps()Gz6~^A`Gr_`B4j(ASO+x|c`JSvoscr=k8UNYhabG7T)y)oLc>&#5=5
zS=KGdNDq2!f;<z#J%c{GI{M=;47*sq{)XSuF~NA;A6IKA@R0q1HtmuaVhf8YNE`Zj
zb1S?bxEl&?Xh40BPJz(>rw7mCMESR~%q!F0kmzHZ*O%2-g+I}gw7uo9z<9U9tn2|x
zS;ZR_2D6E$I$xf$JQ@L>l@<+g@TkLCL}o+=YWeboqjlueMYO()5Y7|MWh6;QKl0c2
zz#Hr9S#1gb^OYd017~<iy45XxvJ}TnT`rHVvZcoZA%B@@#Vp=S9eU$2`j^gB!N;hW
zHCj-=^Qgks>HG^$U@#!N1Lc7M`>87cNC9(T69@q30uZ>QT?4x_8IHmFx+!KC(5(RC
zb-TvO-b^&eu4kaJsy_#BnIUQauzE0G$?dMs;KN%luaW$R5Df#~&k}a_DvrCSP%%Ji
zrLTm1;DX~d;HvZq<43iwHI%Bu<%gT^zPsmjZ+|65&b>*02#9X4PbsmfI%al;nAf6i
z4PYjpmODJI|M)C+)44DP!73t^&Hwvw%?8ho1;Mxne{EKLN(VAboh6JyJ`Wb_gnoMU
z<lIqTA6`D6LY%iz!fClUQQXDz<E@c;Pj5IqYgzvg8#NaoL>{ULOaxPouL<8DuV&DX
zbx#PmxF(hczk8CjT-@S!rc1v?P3-aEm!OWzT$v-!+jcgkB-S?#oM(@<Oj2GvR+0Cb
z{JWRbh~x~*+z*8I3Z-6dynkLaPH`}0Hfg`@IO`v!cJ8&2;r+L%<PSVlCm`#Dhr1$Z
zv0G5Jk%9x1!Ht_o{Qmmr3{%HiJ!i5|j78sU!=>5<rn*$pe`ZtTbJAgxP*!Q!(G!VY
z2Ls?%u!EqED(eF9=X^WhcwO>a%ZA24d=9P|wp1KY6ry168)K14T3y>bViLXe>$-5a
zl$(!x!lDom0_n`dNrT8@H03ux^V}}XAQ#6=_|p5At5`M}H-uXwd7NTleL+P@ZcY#V
zA|W6w&8&#?B}eaj$(Z}~Q`lgi>g$KODywx(aiYVfY2lu9z05$ncS?Vu_(d{p4^o+N
zKkUFO(>TVY6eIUtod5lCkI;3W!I(hnL?GCk>TWtFJW;rZ$KEo#YIBrs0HSt_=UG1I
zzf(Lp5&FH|);`hM^y|R1SNTO(p41z|WQhf{wmaKH<f6K%%*#jknw0J{=R-GoaTkfN
zRGeV!6m6eFl4OzK>Rg7w9>rf<+}i7>qhF()3sfB}5_XqFZNg-lf$H8y)$w)>g<lgp
z5WY1kJSH@(x3MTZd;pyC&<}{<U#yY!=+r`)8+GbX*%0^g94V&LhvMqOug2@6VUJI!
z>z+LS`G}Sj?<}7u^pd={yFdt64(&PB)QB;O6{tqy|MHN}#@@Al|M@cKsrt@hZr5Cz
zB2&^8W&v`8*+^ZAbYW$*Hg)!ijJnqUS*d$0=$_Ens_}QNY0??{u;okr-*3-^zA1k1
z;MI)(5CsMQ<P0c2*!}U!;QQ|8h^^+ot#Qw@|9(ydJ^1%)=HmB%zh|E<!lc?{n^Gjs
zZ&`h4iZJy1R=05NrmJK&`C+eUw$(h0{`0?^+`Tyg>QQl7WY_sXshZ+E@(eli*RHzc
z<zhZDeO-8ENkCM?cK<=5HMxrqn#ix4eq|TLXBA_O%MtVCJEGJfs&VT;#$b9`mKMuf
zGC=wQi%$|d&-cybHc_O?+LSvhtBez;GZfQP%D}n22I`KQhj)2}%9p!T`l_*gxE_%K
zYWk(fTmJXpwo32GP@^_AKsR%6QrDL~kWTby+_pVPO|e#wjtT|UO4t)d3k}&7s<*}j
zWd6<BlD#)rI*o5k8!oWcplmU1F^VZ!So&0UfOk`ed$pPvB9ZivNFPWSt!L#QnU^o%
z;sTX1gG1MrlT?|y11T{1e8YcoLcSqRR)QM>VLo!W)L<X^1C5yhIJpB&w4P@G749S1
zjr%%+uUq~(1oY$)_uK8#ALeolcj(1^RyErH|0|=f0HZ{xd?nzELFT1b0WdtKiIifF
zz;Fc)pFUUiG3*xE9n2TED<=t`v$*_YL$7$>!n;8cjs@@tgF%kW3yMrps|zc>LDj?~
zt#ACUm6aV&9UBC<?XihYIW267Z;!Qs8)W3;uId7xr&38pnC`s!qqj|(YmYqc$S(CR
zIMM4RZ{D?mV#3(BG?8S-Amfp{aZthG1{>qnJVBSw+RCi0)PeD0oRgZ61_-eB8{5e6
zs7nsQAjz1n45lv>ka9YY;)jd~`a>ZV=ja7C4R_t^!QlI(l2FeT6-1k{9-#RnLx&;c
zH83CaFuI4LBYH5aZ>br%y77Sw9ToBM{@J8x-ebL4fjoOyP5T0ptc&FpvganH*&Huk
zFdo6PNMR&tkEwieX%tT)&R<66JbkVMk1mykxth6zBaZ)7yH*EQ?9tPR=8a}vf7R{7
z9;qfjz30Tq`2BQeAOc|i9rd4G%zru6Z=##={tshO;0CRiRQVMZr+ZZH#q!YpapTps
zSRJ7p0kX8mIDZnWPX;psOK4)3`Yyh+1GU=vLg#NIjRjx)S@#5XRW%F4x@Eq@D^g?}
znDt5qzzu8^;Jub}px+Cx=)6JpP(vF<23lTvHR!eO5RmIrA!=9wGoLTc3H9>z6Z~9(
z8oYDc3~jaVNcD&;ZRB_h_v55R?2HT-ak{Sdt{;qkWYoI&6@)$EzJ!7{ozBJGNkp4h
z#V8Dv-y8~*5VRVGgfPl9w)n5>HVvfh4Lscg<rML-vEY^@o>LF|yb}GaY2s<DT`hi-
z7#^YTgQB+G4VAk5&;#-1B4HCE^0v=<-tKik&8-fx4tyoZwwS`}0uQ0R1$qQeOphEd
zyuR$0Kzz;(786^}&52HPt`GH34@V`XQQI|5vh7~U-u;Ji(>?9AmS@>;RST^*A_u&=
zB}&Uf3Pr5C;m_k<IXyeLm^4!MJ|gaM!=e)_2w`);=t)Z>?@5em6HW>|J!Gc+QKfil
ztcl0BJ7c9TH)*E|8NGa1H}0AHKwOwL{EEuZwwrqLe|idH+~56u5H#cdUU#C-UjKc}
z*nG(W;%C*fMxIn@8o3846{yfU!t*23gJb~sM4mM@76ZZ&eg9(?**Cr_eecG(+>FBy
z@eW=Y2Lm44ANwA61jbn<p%>sDY0$9;SF$QmGqt5hWZbtBiHEEl6ZodNz89K~HytyR
zH?W9S*-lz({~prMH;Yv4{tx+Y<G8hk{_JRBlv2Z?ZH(RN!9Q~KR(gWxz8^NZfTNv2
zRI6T*dbebgi+k`&&Zh9n(GTrfJ1)mgDm+UoGyC(t@b$5YCD`Ck^XMFzPk+0A-&i|r
z+Qr#kI@n!ns0G`M3S)KFSt_I)Tc`f`#vmMvkvJ3iiYro7p*YdkiHT4_VCb@zXSWh{
zCvys3!}3sH-vsO$X_@`uHqJ#ZcE91BO8~sk+o?kDBd>n7MW32gXnYr+GYMm{_*ju}
z2^%!)?P)g<;6vk$jWppIg`FqE%q`KuWZrPH`hGHxwM(RclHv-m8itq_60Z6SO+Pl-
zn80UfE^0WHY?>zhas=@qlKl2}vP~?#c@8C-B4|XXJ8#pkoAW>A@MoiAD6uJC#VOvc
zDLzvvC%03mIEJ4gBfyJsI@a47ND>5z@m!DyBPBkC@Umv%K9M}<ypkcK@cu|RuWV{e
za4M6Q8Z;HJ7bO(&P^eQLokl~x98JsO4#a7JVAg){kWFk!K}23Oe2gTl(s`9T0#9cN
zT{1v(@F#iZ(%DKG$+5}&w=Yw*#8WKME}tX8`?Z6&Sg}RlTr8}AR%D2cO<6+GfzU=b
zv}RHy43pJ8CDPlP@%jK?KN@}<4J*atb{c%E8wlMTfi5)SLo3|aO7Bp$s=BPzxqhWo
zUzf}ZY~idzBpVi?%?I08yE=};Mwwg=b7MKn%n(tbB@QB?aLZW857g;fhH|yoDB;Ul
z5BYsC$VHmC3I=|nk;i&OBt8uz{1qjdp1Zr8tka58v~$>)J>#GiK7x&5pb?X7<m+7H
z!cllD8__)?(1_>b<8}(xc-a>Y$fb@TD!Wu4q+ucFP%>L6<U9Dj*VTj;@bp7lUn)rb
zmHYY&e5XSiVlK|zPpcZ#9X2ANV}?JqT*3Qxiw)G96n*=*mq=7%nw~;wCDwfw(fCu~
zH75*&miZ0B!?doQzjW>BPAn!G`I&@ULz}lJ5>^I~OcKjVnK`1bRo*~YYv6C7d4hm+
zAkyYD1<@IK#o(vt8AzastD-|9U%4LYt4J|rSuQFW88a)bWKjfSA($apo<W=c=C!PP
zh*%dGrP3cM3cMuATX9^&_{18cJOZ%SD6&Xy$F;h2I;~M*jU^OG@C;GnO>N-YdrY_&
zSw`e;=#`J;gGP8eAM)3?kOU0SYqV>+!lf*&{fn`Jg_y`h18UQt{D_@0YS7Spli#Ep
zId6nT@k&4{k`LLUE9X&#c%HbVGY3V1!4gb(Q<=&9bw^p(vB8^^<%BeIIdCFnkD8*k
zL0MRqRl)*JO6cBszDsPy0y6rA(#`7&mS=PnYWVh_QYsynGBhGmE2KKbLH(xqG`o8M
zPch#i%sLSBGghNp42UJM4`5V-Dk~g7<x+pDY`vh%4XBOD{1CL-6opOD3fJ9VgwY(u
zWy507YWkKi1?|(KzBhuRZ<^e_d2%ILLg&hH7Q#n1_9;go8Z8z(67_&qBg^%5=qAIH
zfje|IOngI|ixzOl^Ym^b0P<nkJR`?moh|Zl*qm?9+ekw{9@S*+F^YBw`L3p{>jVoH
z+`x0?OmfN{UB?B5IZoJQ17Qb`>jWcP#D!2iS61aQ5w!G(AA(VMOl=Kwl`P8TBtaTw
zP4!C63goWUFjs;PlSZpDK=zN{$G>4;=8_E{Q3!W8`CjrV%?g-NVtxCpeAukPZ;WB^
zEuQIl)IMAo%?kgEH{+=|@`W7~@kFkiRv&jx*yOXw3GaGnkWu-p>4Z3p0T2=?P=!k(
z0Eg!Si?`PseTK?wZHEbRL&vH#svQq_b}3U`;!%$6%|)e0`rLz&5l;*ao;^ylxoPtE
z5m}<i;$V~2@g|$gO?G8Xho3b$zI+&o=ba2d2U2*`2gD*q;NUNsPS2W~%*h+GB6wj@
zV3zMY-e3mcJ*zA<NkvYMw3MN-0_hDAJ<Ty?Vx;OTcEZw31N3uck-wx&>8Ny`+=u6n
zw-)>I9c!{Kp0(!AUiQG_=E!hJmkz6=7H`hW0{G;J2qv1Z{xjxD?Zfck*6M>|zj9Go
zP~PN?h-y*b3H8Yt%!yl8rBc4kTbG~JZyerLM0-;yLmi@YJh}}g6gpR$iq>VK1sG&#
zDhV-zMz~)@j|zK<ck*QK8@_BrQG-k*Stpw#oy#Q)tfW6%ln~)LPk~~PM!txc$Oca2
zLpvAY85_9r@#@}=WH1KRc<FW^^|oH`wU`FIEfPGpGxaZ};&WMtDv0+r8L5#fc=B^)
z)=QloR=76iK;PdY#hObKXt|zC7;nnaJu0HL!-+dvo!BH8$c9-7qg?KFkg~8d3YH%@
zPcA13fk$atzG8Pp00u|xTOQ7k55S5>i)isD%OdPIcnn>La~SujS!6^sTuP$b!x4K5
z;BO=$Vn3rcM=0r$s8}6bw?kWGZf<|5Fjf?3Z4iBY`nJd@!l#k9sTAgzl9ijN{d?nS
z!{y$qCYUoVC~_Zchb2^nMra3g_Hb2SL|DAIv!F3W5w`ZV+%LiF72*!a%W;+!7AQP-
zHv8F*SgToNR-fq04v}g!=4ob!YGNnu$#tvibx|1G)!Aa}*$2FOf^+Pb3mwQq7)&^o
zvWG?mjQ3Z>zk--w<#N#8U4kFRv_IevA5?qB<#d}ZYS4}g>`(^bTJ#z6v$-f9OC`%W
zyv{)Uuyhnp%B2R`c~sC-jNH*gyQsbgSw!q<gpK*j0~-Q+-n{1o020yTg|R_j)-b;$
z;z4B0so9f%J7TN@4csX_bTaDTSF8sc7Qp7)sD%Zx$y4$AB|WcsL2$zj!7H<am#K(K
z9_CI5(ux8b6$TOmMs&GO=;NPV@+U<WDRspiI-p}MJ{4y*E4pt#_EcoNc{HQL*BJG5
znePOKWphUe)B#Jwpd|F+aoQ+-pSR0x$5y-&Y!%Us4SL#(G792CT0Jo%I|99<{I849
z)w2F2eEsW$P<s&o{6&$=$@F>sE)30A3h*)TZy@Hdk6%p(Y{g!NR6MAJrLlN@KThVY
z<DU~M^RG;sXzP+Pr>|$r=}Lr`OT9;E>sFq4UvuSsZTb7V?eFV8zOVoHzTt|dz$iLM
z3h<!t`cg(BKyYTmyXI(~C^GL+kq@(OX?o2<Th_eJ29<Pep#orVf`jO$@=M!ce}$@t
zQ3V_e6Bf|zJ>2y}_tRu7?cuSD)Th}P$J>_|s5!)_@d;Pu@@uH>A0Iz;AGiv_b$R1F
zIfN}LpC=2R*!+Sdt6fOqe?jy7OYM=1`uNU|e{qEGpcU`QkIq{kE!Z2V%3QeWm?c=t
zx#oaS`65cfm&bYqwWf~!maQ4yA%ZzR_o+%^r$fS`;4pJ8_)9VN$0liqa+<{wnoZkZ
zucTiT1#ciZ=QhFz$;eM^L@UQ{J+I!K3h!+|c8^pxKcwz-C~63rt|S(M@CcigL2(zK
z6D}XsG4nQa<6StVy$$JJ4yuv|c*Yrrn4=`3{Q754o-{{&Qdjnl6yIt6{86V^I1eRC
zKzDEn*4Y(~5!!`n8>HW}XC^z;)P<ZH8>Dm>kA`*VtkVQ)I07@A*I<`w?HJ@<3o6J;
zb%Z6<p}0J~P`YER7K5iACqo%ja;TtC@F$7(ZInJlzNrBNa9k_(oLgq)Gq3nDtf2e#
z&}LVJ&m4lYvND;k5IUxC7OUvaQeSmBW&~2vl+}KTM{dq4%#3LL!|D`)M4k2Wb~pkM
zZ7u7kDE%O%4Mo)(!N_i>_4f-mxs)JR65>mZ(`%~7UPp~a?x)|fZr{>vB0j~Oe0c0+
z1(G>psMvx`w-n$;e$TZKFl+g~`~1-3A3nL}&;&f(8vyisA|M**`z$^t+t!-P`u3r-
z9?I{^V#OMnBW?R<UpJ!&ClpFpLVu)xfW{wmrmz=8fG?4sL>pImqpk=`12K49<vVdY
z8?l;OVyNHc(6W)2w?9-OcsgQhrb=@ctYtF?SAAHkRk6^VP3hvGeMkJ%)#YqJyqyGZ
zQyJjB<d#3!@-NBZ^vy&2vYm{OHaHiSj!y#E-ra~FDv3)6j8{%x-!J$N`N(?rk_6d+
zo^>SL<eZJN#spPHc?K<>Cw^!1#P(>uuESeh-t#8$u7X-8I-BofS*E2`TCUs<!L|9L
z)LfzO9crrD4p(Hx@*aNF(!~`o|9Jy3*w!*Q|CYb8Rqzt&shW%O2A4gJm8&&*guH;J
zl3UVRUx}=b%!ud7Kr2*+nST(f??yBattT6m`lF*F;pevNo@j~y8$76zeTWT8E~W@b
z9ZZ}Lw#T{5TV;r-pX@1iS+HSB9l8n?b6vE{lXtpdRpR>jaFP0n=X5c*CC5^|@J~G@
zZeN^l9J;ax6+gO6skF|Pwk|#T)wRZ{+%!epedXv~_xmS%OWjvJ>QA&^<&p4M^LiNg
z`i6Cx$GUe*_{Zld5}x0Do}OR-)LZ8H{p9m2|Mqw!y*Sja6#s}Qx7&w@lUxDeIi*`J
z)q~9Ww3q<3T-(6{xnsZH<2nxaR|;GWd-brXv%d=Yf^kTAqB)3{i+Nh1H!Ne3F!$?K
zwe>SR2Iwt2aj#J8wOPVG+0JiI|M=pf^fiOCf+tir=Jz*X*dN<{7R!-(_RPcnMts<>
z_4BYlkH5<V(3|(1t_RsFw8V3v_rJ-}66);Jn$w@NU=pEwgI}&?T;2Ink~uUOB$b0c
z$};C|J`>)&f0BAl9+vi3w(6g;)UqyavEx0ciUv~)BP~Lb;YLIRO|(Q5!N&cF^Ziyz
zZ+(__Jt5}KGA^O%NiD*506l0&G?M(@Hcz?xa44r|e>Ew=9jfD)pOyQ-?1Pnq9g<#}
z`?d56IQB~h{e5l@8F%DS?e#1A*K3Ot8ZOx%F>PN#%cG79tZ*qNy#Y<5+1QYJvxG$i
z*@6CN>UDwC_slf(8hwo@YVzDN4ec$N4yQ%kc&6<x|JVg3YwK5$;$ijFVIbdYO^JZ<
zZx!pyPWO1HQDGH4dX!-4_Z50~vms1m5`3R1BKtk9Z27&{?RNcl!S~MV`b5d``<Ey5
zX<3{8@vuzGj6!EX4qe-}3@#aE_(qbI$95Ep-Z2ML%jo>ZinLQ+$yrP)W6t1)uc%-R
zhAtYfLpzPO34ZEz{p%6a*hSXzb(p+LjhQ8p|BFmwxi-=&nQ9V6rCZlE1*RMKlspF<
ziI|FUmF!DC6;dY{Mr1YLZ@q`3)GJH=#(^ep@m#F3<q9az?+61IqKOZRfnuLhxN^Hd
z2WE+2{9zT)$DA&X-8;qzGi>~uS{hw?&W4~Yf5!i&yd0MP#PRyWJcTna5M?jR+K=u=
z_NFo<qaWE$^f=x;mJj|fzEYMDd~Ie+;pW2wU%!`vGG`4$M+bzxbj_m}az);suG|)#
z_BVo_2I{8!ODrJ88ZrrJKC*zZk(1p>I@6c4827s*NUO#|cegw9YRiD-$FF}6MSt(M
zhO9=3TE>mZW+szpp?AqXD+wn{`ei~2_-NvRyO=zwgy1_9M-=W6J#IaR(){C*HdFk-
z#Y)iQARa*awV1U<WT&LQ6_JL`wLG_G#n{_Q;zmZ7rMIYQ-^h%4>Aey%`}?R;O;8L=
zdx(`o#Dm~Bd%?1k4d7?gE*V#x+$qoibQ50iv>4<_y@x4Dj`4!ZfLEL^zAx`3!P*k6
z<Op@kZvwG-RvEgMrl2^U<fhhwl8-%B!j016&paQM+=@y$YvnSutluArug03kjmA+Q
z;wh5ggF91Q|9(7v;jzO>_&8lA&A0uy_lm7}<m$x1UEgjxpd5#p{$RD%Aql?UEi)c`
zxG1u#)x*i*Bt}a%OHxtYuti(HtAUXuJkH#sLL>wUkV8LQ1T}ny^+{3rHM6oZfx;Cu
zs71e7aFn>wh`-Ez|Lh+l!hrJjpoB2j7y12%Lhjcl0%2~dU!PcMl3^le`g9q!F;HvS
z*W^N&%1rwev1H^qq2u_u>L`#jDrr)SO}xBos{|g&jGw8(0O$Z<U@pfu{)@nu;9+j7
z5ZM7l#_bK*UZNbk&ZFT^K+&x&v`4Qi%P%Gg@j*Y1Y`m<djVOr!{Gx2HlzTLyso+<S
za)x$AJv~^?lmVy9LP6tK`{=35T50HazjI=DD^RlmBSYSD5B&?wk*7wEVLUq7EEpAi
zB0O8~M-=kj$wbq)JJz^yO6DFLf|Pw}>;AwP6CP7{FJQ4`nChxjCcjAG8B!HCTkN|o
z>OuPK<_&xjp)GNiWY(vIxk^oiBc4=VSq>UEg%-=bgclJ!yV-B@36=xKn2Tq%=X^&K
z?7!%yN?Z2^gnrS&SdtWFeBtuSN51B{4>d(<-SP-=X+7R8dQFq1RBO{KmdiY*q%bmN
zs}Rl5)aRj!{Z3PnqBo*sWqY(Htp?0mmOO#QImw+$+w;EFp8%z9{m#rcX7yU|jMys2
z`9rLDhPk12yQ4z5)%d}et%ojxTRQrzIn*ZWnRb{bfm&-RzEynpmlF|r9)RMM=Erzf
z2*?PQv|SiR#t`W1RE-Kra&PmicKjkj%!MZBb^3`<PW2h*66MVvW}Oa8Hd^gi&rUH3
zAlwcxu7jtW4RPs$|AeOpk1!tEEOK~}$#miUxotTw@j#7>(=SiK&K2(uw`yOTeidYM
zuJm2oY5m93ug@}ciZe$T@Uu@8>SFjL@VN({k2fh~8^UhN&%^8tlLS1KV$zY1XAKSh
z!~yISJ?Ao(wHM?eeBb)QN(hmBy2TlWoWsG5Ik9UgdZ~6JN}|^JzD03_uH_?g*wLHR
z@#+`MzUIgKL%5(4lx*`!>15A5b9@HtxMCvD`Ck@vk}z6!DDAzYM~YwueN=|t0XY}5
z`(O8G<H`Fw7DnI>H@ek4E^*2Nr#rWz`^swc#=x<=%gR{q#pI?qkd?`|%ZRQ%A~HL6
z)k;NHhHF@BZkk`q_ogj-_1pHH$+Dt>tL?@@>SrqH22%EF($B8B>ne&1r0Dlu1n>7H
zE8wp%TM1(A92*HJW`mFRS;bF)-jp~G4=J)nV6sAks}8I<y30jYWch9pMDy_9WzSS(
z`86bu-&whLTyPX2uCa{c#M{fA0cCp2S6+@(sx^Nll6vab#g{=n#v?xd?Z6|GVQO%y
z*^n0h(xMxIiT-Fv-#^)iTqeNy`mT7ZBL1Mw1!kSnhIS8U_xU~gaPA4ijE!`o>VG<^
zgCvVw*FwziR*LzM?=CnhTR4=z(aX+k`S4+_H(|^7_GY@BWKmRh^h~PMi>TjMX4}sw
zFLJL--J|g|L(rXv?U!XfE7_3L=&|V!7I5ueb<~A_MSZlq|1Nv-DKKQSE-fzjg&^uQ
zZ@<t1EE(nFVb4|$2&S(AKqJP8eh!_4G#()ez8<yWZ{~DdU{x3f7Ber7fB}v|Ya*P$
z5sv^+zXX6V&I@3w1$MZx8HbYPGwO~awjL9&CY1GK<i{o0XLoM%xxMglgT!v9M&de#
zc6f{U{|7fwQ}@zRpJ%2UQd!Qp22)m!dq=(}3uU4NCi|wIw1E4=fwQ>mfbG;vRLJBA
z##7ad8=X1U@U$s3J#0nlhw3w+`-c3F2g>tZ>zF!hfYI%ZRB9yDj%vY8Xn@+Hp%J-Y
zA5Lq@06Sp-ipkJQfYZ-_pi8w-Wwew}TH3#P#%OSE068b%9uq2F&mWpOP-e1rFkR)V
z5{UoMC9%%3uA;H-o>2!$9iP^yWgJZGaXjcj5npP2WOFesd7A^(AYxpXQ3un+OqNkc
z1|W1cJ&i3RzsSD2BOgOhf8=2Hn9WFNHEoYhe}`7p2brl{hpU;q2;Nn7+0wu93>JpQ
zUOko<ie~ggAp>g<mbAV|XfSmD!@RbcY8_l?O%=47)j4YcH<?266hM~Hu*u-$$4_)k
z9tqeJJJr^hwiyzr-P<o5>?kI(&Q`KvN6i3g=c&?40y&j?C9+=Pm3c`N!hnSevda!;
zq4a8Bq~Vh{`DxJrpus|&r6JU38QZL`t7Vz01vb~v$nX{E(yjU%n1<q9#jpN0X<<#F
zowrpnjD3IT`&3duFw^`}`awyU1rB<b2-V}G1qCy`YQf5BDN8JtD!M#Aa(`!u7@f__
z8Mz5?=w!~FrQjZ(Zj+XVBwag*E(f+_4tZAHrs2W{J$b3VE$Vw&lK*l~8CJe>SAP_D
zz1#>HRh1gq3iA};m5b@+tmM$iT|gw{%7XAtEU$VgJIyOKU>T*f0qv|ZZ+vQSEbD1A
zkmC00Rq<cmFVpvu8iaO&VJ4jxr|za*7i-|&Saa$P(^1VWz7&bzbmXQfF?b93>ax<7
zICwf05*}<47QFvPffWMkLRrZ+X*v9PVBQeH2sqSjJ2gqGy(cX5dZzOd`$6$Cv$9k0
zvU1Lowvv>^BHQui=fq(w9b&r-wIxH98u_d%(li^AO-N7NTp<VH$(Q!s+Xl$;uG5X9
znW0VT{)im+GMmz!H)s);I=c#t-l$MGKh%0uB+#WQc0e>`6!$ZIvS3uac~qizRPx=Z
z)aOy@pQAE7V|bA<S$Wq-6o}DOQr#>?NMeX^-j$`qoTkCbm6;?v*gs#v3p9F3S}(nU
z5emF@s_hwH6>yCk(^*d&gG0IRtL=>Nsp;(gVwPe06mPRKANpsea+8kkXScGkq?qOA
z_`D>8pS&l6lSy85YDar98)8SJcWm<ddRa;k`Rvvnb+5g3{P!#gD0UkcOP@~7dq0vy
zhUOcY<$Afg{T0(1KkB3|Xg7Eu!LBYegEy_4Oh_|JFr@z^i&%EN^POc-aUw^-^b>4G
zxDvx9%`$4M=NW})7V2)Qe(jtVPf32#WnArB&YNpgq!kNgK^7t_GXh#4#3~H}tx107
z@Ev>uyDc+hY$SO7ZRK<-xkHie#ROP%$}B35#ZX69%n!UfA&-rU7PS9>%sGsg+DN?s
zXE?KYqR~>e!tLC)k-WluPgA|JLm=8@70MhfHRq5Pk2l>Ry1T85k<(@A=-bBpw7&wh
zSacD68~jzsxt(N#dObyOf^0N`e>;fN2i|S7d5p-=Gn>3+`ES1Cyn3~~EUe%}%;ULy
zkz9w0t|kGExi{s9+=5s+CzW&qmvijXpyYvM?a|!B(_;x_k)0UCd9ddeARM-RYq3=~
zzJ%f-(mj_Y(A4c#FXehRSiQ5G8HtB{p~2}icmi#xXqK5+2#<R2NN<q+;tfmS@b-n+
zb&m_Y4)^E~arMfR4~;b5d3sA_pQ-HdNMZ8^{&|pp-zgnE32r=2C%?Heko?ub43V7~
zYO>Fgo_A#zzN5F^Oi)ts2~?wnlYFe73?ON*cbP-hX@`QD%D1N8W{TI{&kRrWnB^HO
zDY5&2hr+acl&O%h(o~gXK2-`tdxW0smaJ{(6D5L_dZN4kzp@t$lXZmH6=Tt#KeTq>
zF8(|zt9O{*nxvYW)V7ft%N7ECbv0UV?nL$jtQnQuPf%9~`H;k?DW5rSeMfaFp|?c+
zHLn$jrb>BmWgzu1n-BH$fi|ec_D{+?PR*Sw2>oEj#vk6;5w%a7gKd;n%<$BArR0Z3
z^imOiheH(vcCs-wIb0;`oBX^=%e-peyxPRP`qI3{uX#<_0!eg1OJPA<e?iA)fvfAW
zpm*Az<Ug;^@E4BC@@jxl4yU=}KAIF28!q|(!sVE=a^|ezK~u<dDsypp!Ab)$F`JZ>
z`=t38BOomx2a7W~y6A9Yem=4_I&9$WW@-F>fm1Z_d2H4-A?av;xet-jE>fR8`Z6`s
zo<+k`*diJL88XJ7dg%P;6U@y04Oyne1F>-k0{V75PVS`5QY-a^oNUtNpQ2V5-UJja
zwNR2T+I51qrqcHP#14-j)<_5}=porsj}Bdmvb1GCm}eywr1SC#J&9xlHPG%dD_$2t
zOS5@W^fJC&`ISMPwITJw&h7Mh%Q4&NsVdv*S3QComc5SZr;Qi3{&!-Tn_k1OYOdxA
z0+dRsS8pvdpYwBm)(e4Xc|B0@ujTv;8KLHd%OQpOQ%Kt>(So9{_u<VYEnmy}zFwdB
zTE6u4#;>n8VJqy3^tLg#*;mt*3M*9}XR1!GR7aetW~|)0uyTjFa=U2dZq3TQi8J?>
zR_eZ;se`TF|FzO6xcWeJ^`XM*BahHWr&sS>5dN6=veop}r@YXoH$q#VuRiSyeYUjP
z{wuT{w$>)P_FOQmOM2~v=~|afSoi6*-V0&9jJ2MkwLWIp(2ceJ=W9cIKBQx-O%b6@
zu=QcV^*5sHV+!kUf31y6hriPgpRief$5@|Wu1^-NzlRM+4zA6#tbObY<9?c0`)^|X
zlW4^3uk~4lZ*%(J7B#+owux9W{r1J<+tS`@WYqeK4NjZYFn$_h$X@@}@@--QJQRue
z@GHy!PieUTF^;vkVUFmH47b`&i5JcORiD&23_TGH<&*n9y%+I)={xt+ci{I~|DN#W
zZ}+W$x0+6zP}<|~wMjMp%nLXMRAG%*Mw9P$WKSQ2=XaA!T15LVI`lE)G@M~c+Bb{n
zOLoaZiV-$ztNTV9?;kBUT*rI|@*|b`X)5`pLbB&9HLPJ{W(xW0CsJ6OuBn%z*2!3E
z<@M#5eLcN_x)%NAMzqp{A4*?VBQcylJWs{|uRjT{JX=m@<pkl#+*_iX>7;XYus5!1
zj6LTw@#%93_>}L=7gxN_0^GH@<kVVNUWSpie=y>2@#ZeDYDgYDl4PKakLk=uSzbhF
zle_l3Y?24)p}`;dqmtDp&l!H-I`U<UBE$J`HB{x|b>`nxDjMeQ`O^w7=r)B6O-t4t
za4<%#1&qQBX~~}nJiRc8t)4^za851gx?ixM9X!PseIvdVyzIP@5E<l`8kQZJ+EEYn
z$I(^s5Qnsz33$jn3nSi$xqnol*CY8WCpBnbcmw`h{7LQ-n`a(PckpMjUSbW%-4`ej
zx5v>}ul-WxjZHvp_t!*F5)fNiyf<=_E*|6M=7YV{P~5_pl@t_!*MXDp>glM}3)`uF
z=%0j+YjlG&GezkB4-r50J4bWHC6jkdu<Z(<C*+d6-CA7tOX=Igm6HEbOKso$IaYWN
zLQ?i($H&5wf5#Ns{&6vjyEVB9mf2>m*73a5@B7EpUA~ZjD}1VPH+hbU6x$#17dZtI
zH86CnGlFfv3+prm-4a90*(v0y<kOKb;|B2YS(x|sv4-!3r}#uSNWW@%0o(m!m0=FS
zi+;im=0CvWO@pfLB%f?xgyUeY_;_K@sBdt(w>jON&BG^<?7d+|pr*LvP~Eoiy+OO*
z8lc|G|A+fhr(kCqcvQ8ZK87&=*=rXY!nh}bnOA}&9d}ZR+|`*4-pu~c*#lSizmIes
zuzP}loNW_Hyta4s_FlrxtE&(8o=im7{6@Q`p{!!lN=oQ^+bDomA0I`pvS|eX`n%cY
zhq+1jr;F3Ji+?;?GBDVuiji_)S{^7Zd=m`qsL7f&vv-~Pm-#shZyp;B*opnpydex&
zGylD`We{lUGsb%#CPyU(RNL)JU;WORugDA2CH%Pd=4KU>2{=YSvCk-CdRs7Krm=y2
z(SPacs?!*0JJnGyQ=VfzDic|rIu@0`HD^4s@lUc=af<i6?&EKk%n1EjpL)16e7DeI
z{lCViA)wtSzt4*Kv?u-+)X17>nB{h72<a%aO-1?luoNBYcc-EkUzX}9GM0CAmPaaW
z^EJZ%=&p?4Jp>7Ms@9`T*89F>I{p2%HhpjR-$MJF<5iPZ9zQ)G9WFpyyXRcXdYnjS
zN&PfBU~gEbIT~92u3qZRO|1`W;E~D`YBYU<=szCX<g<%F!c(Bl|E9^o%in;Eow5Tz
zJkNGdd06SRSLkGsmUp|e!<x1xoJr;5+QWw)yxTe=4(QJ3nEi!b95!n}`#PQ-18Avc
zUxJUa&3F}B*<pbjOF23ho8`(#C~+Z2L+;F!&&B(lb6I*{iPr@2!^i<Y&BHJw3EWke
z{IY!2UlReW$?YlxtHH(p?E&r)5BpoiffwwTO8oDJD3pfRmnf8-eJZ9{9{JwrOL_Fl
z^v5$-{_H5S6Zg`^0<WcXVJ$9!&{_7@@r};F2fA;bMjnqPOV~HuoN{XcLx)q=(a>WD
zxx!V2xsCKdM_^{{@e$zVz-S&`lE;mHdyjTErB+kK*Tr<>)!SS>&tPjG)7Llwn%0XD
zVO!gcj*5u`;=Khq;;fh^R4rij2z70>ST{%Xy}ldt;n3-EwZop}3u7i}05D{_5nSMA
z`kt1HQU57=SCnAG!+IbY=RWSDYZY1Jf|ok~W2$q9s8*~OE9+rz&)9vYRUvh@Z=+vY
zQ%!rn?GgWQQ282y#^$O&+tq$mvtDw$*rV1wRrW^g<_+b{UoEF>FR(_BlcG<GlSPK@
z_vK;^S~nxC)ynhp#r_Wclb0Tr-$nvPFns@k_G5>#%({TtEi=kvg=RCIjo;E|Ib`q$
z{k^uTlrYgJ{2fYdMuepl!9SKcvM!qN{wyxuFVpM^K>7XglIF6wQTuw&TeGiCHCblA
zt7RqBxNXU|Lr=wmUy{CV*}OS63|fAp=RQ8|E#LODb4hcfSEHuLr*xY4Yyr!3lk-R@
zp>1REZCm`tE4lA&KVE+k)%p4E`1jjG#239o_CU|PtDMxoecnK$Iq#SnG`FHi99nL6
zQuj=w1w}Hc-G9Y{d*|+X$9sQ2Zz6!_vw5a=AabXd9Wbw0wDYg(s_3+>j35SaZAK0S
zw01R|sSx#FgeaqS?WlfZc?nPp_2L2EL%JI|K@I*gy_7yPLSkn^Fhxz$iXSKdXE&i`
zLtK@3Pmb^FTV(4%&suBSn(9KYm_>09yJ@Av7Q90wEx<Y8)d^vDT=3^)qiM_Op(b7%
zt*eb$zLIj{ukCCaeI8^-#LHQ+6>TTi)MPvxpfh7pJOryznIc-gJlv1>{cIvWq0Lz>
z_-!WeN-pGRDQ|3#rS$s-l|$X|4$ZWNluuz5p?he`73|kiYyD`me~GX6r@;jXvlRx#
zY$t6hl*SE=w9_|#I+A5!US_hzkl6FGW{znICM;GI?#12;^&4bQ6a<<&^IM)BS`hcy
zR*Dm!7Bi^_16iHJ{6kgHvw6A-5yqpA?G8d5tl#VN!yA{z&MBHq?>JxTdsIG{EN8m8
z^H49(QQ|Mh79*(DWf@S7Q{bZq2%4ik=<-)U<mFgzOi`rOkd}Mopk`B&;EynC!L8;0
zF1_mG$@i&%cW(FJCm4@r?5z-dOZrW_K!8<okMQw3miF%hGnif!(qtFi^M}^stgHfJ
zj2GQyuY#v^ue(OL^UkB0!W@OKfgarLUXO7yDj_#aEL#Qqzrtap>}BN3R7F9diN+#s
zp|;3Dm>;JVmA#>p9dxwn#A?Q5`={myaphU25Y?%7<L7PwBP(Y0=9pNHjo5=HVDx{!
zJVy4NAq)7f&}tGBu=^DTqNRjucPeX}zm#dFA&tOzJRyEga&4}Z1g12xxBZp6l*)q4
z|CTy7^q1^zya`?DkPsTIFc?j9!i{y7MKvjuzZrlRY81fiI7`y0wAaS-3Mr~1$p)pW
z^=3>5`l80QXzoaFez2+=!KYKAP3+@l9mOc7Ndec^nXLB$FRwNITV~tot<mePTUU<W
zYk<`#CavG0c582U2xzQP<<xvfIU-suaE4@F3orV!T(0YYwS69lrgA;zF1Kuu$2`M4
z*8xVmyYT;|$npDK+hBk!kth4W(Y~9QIyIyRM(3Dq$x1eWLrh;ObR^(j?%%{3vqHia
zM7RsmXCf`-;>LSfh)n5Re2<}b9*V{8CcbP)7OpucqnsA0P(!je`9;pXv(_yp9tCS`
z-9>38AA5y&8QKO{J^f!pGT0u&{h8^pCII-%+L>l3@Pr4bp&4kpEI2VWN3WZh07u;V
zawfzvw3J{)u@oC8VS{TE5q+Z$_}$8^7h}c`TIxCX|CO$KFT`~{|MfHZH658W;*W<`
z^htwQjBFTQYBEG$e5EPOPvW4|XbmcOxiN&md3fkOn(JPz@VC@+N|7Mfxah8D&vNb)
zEx0+o+2X|a_!AX!7MQZ0-yIdi?o=V}+b2hVX-5fcC|Cj=JZIl)<(}dw+y|DSXX7@+
z<GaKEYu_*cO4DnecZN%k)z*|}ZApX~ssjrRze!)pIn!d525WFjmg}(eU)puy9ma?A
zL6(g3TT4&*A~<iP5L;BCE6X+qp5|Y@zt#DplvMZQl}VNhw7J#y5n9<++;IYSPYAl|
zy&-J1AC|LfJ0))B3VReq<s?QW3wBMV`Xw~x?1X`8O7g@tB7dUNh!@tpkEOdTVVI|m
znyY$xF&ut~@Y)s=k;i?zwGV&Jiw(1sqfKqvawh_@p~4^`sgg9|Axd78=o}|~vTt4@
zp)hiBp(#l=iIg>;ZCd9ivpPFvY3iRv3J#Pwsx`E(1?j#*O(s3Rm>v}N03)KHcZUYg
zJYhVRb;3<%a$@r5&$9Y|E8hdZeoBzT*obUtUztM}NA}3{T#+F3fUwNsv>#L7uWonu
zg*>%OmXMs5Qb%-Qn55RoDHv`%u~Q1=|MAqGn1{r8r)_Jx@QAroZKA%>6j*<D^Zy*P
z&L41F39^NPRhMkQz%~dFuVtFqK_s)Nl8z~6br3PfS-A8G1mPoMf;u|N-VA>Gdz~#2
zDDyjaG`1}X6%Dh5%l?v@`-POnp5ekIfn0kZi1JLSVp#I2MN8v`M6ALb_VgU;g6x54
zSro(f=L{PuE=tI)D5qn^hi1j+@e;!}xV5fBoIX7wPM-ras<S9=@)dhpA@fTX|D)ni
zx~%NC`~wjcr?Po1rTlzJJ%p>WgfkVyN(4^LLM;G{b?wqDK+9bq5S`~0<NSzM9c7FB
z*t->Y!5qn55RP40R_CV*o0oV>P#^MBubEdLu2la<(6Gr--t)UjuOu<&Nl64P=_)OS
zDkT+vEsZK2egD%yl`gYSI+lU+k<&k2r5_<@aG}cJs+=LC%8)5%R8(bjL(aIS%D7(c
zU`y4(=W-@}RVKr7hbFjHhdx#5J6D<JF~ri$&GxFyU_`QDHCdEsE?sS|K(x@Pw$LY9
znpRud5Urf6tvra<C#$Vb6Kx`@Z7vXPuU6YKh<40syCS0fjcWTE;^E3g(-vaztej(C
zwc{|+X`<Tc6VZ98+W8ytNM)779?`t6`mo?Fim1Gc^eq<!c~^~FuKMzBrnlT|<c~Vv
zI+{eJ>;)Y0TacXTl&D*fd}Z#zxaGx^KUQ?>*bRB_dH+{FASrs{1Cc~YdXknfL>-+J
zf==W<ks)>@O1R%LQ?bx@w4@3y>0VDVGquofO?E3zR*5BQwL;8mAzHzU^5`X9w53XM
z;;9G)_X`R^SGhGo42583O>mJy$ghQ$Bb`#ER)#DKy1ls@Q6w{$A)Ym2y67y?TdhLx
zGjpuL0haS*s5Yxg%n=go2r&Xf%oocHV*<TR6=Q5}$2cpVue|jVo#eUrVHaMcv1Ma~
z=+>e`)QTCRUfp`ZgJx?Mr{WY;3ZPm*_vPnb<hB>&@s_g1o#OFb<V8zQ?M1!PPGz)}
zL42S-+RER#IvUm?UjQc6TH2;1huAEK99Bwku1)b!Vw|jHcm%u*Ha|9#Ebjv%*xitX
zdSKGr4Z|{Swh2U>%!&A8d59&aMYNU8sxn$jK3LbOR}TuXs5Ml%ZAPsU3$U~|3_35Z
zoTtFOlc%AaAMO8=XmK_cY(<&8#N#2kjbtBXYSaa}*K}F?EUH60Olk5~e?aCOFnKr_
zm`N0i?^18LL%>_=qq`+{{gc3pa>YGzyZ*9hOZ@-{Ny&nokyzGs=Q_4qBCNLZv{IGE
z-70;RYSX)}Esko%bWt)CQ($EhZzHX1sXLPRbIRO)t20;^tfACR+Okly>k0zAgO7F+
zh{<}f$=b8v=vaoRVHYX3TZ@_$+_r3{)Fnk<kXyC{wu22%g3ZU3^hLquK1n$8k~%3l
zXuP{&?=-MwsejetEGaZ8j&auJo|$84^U2Ws8>&xh?mewvHEeNAS4WzACH_B}?mQf-
zH~t&=nK8y-m>KKXXNK%F_BCd)j8F(k%D&4|DoPn+8~cnTl(J>ZT3JGx8T*nfEn2^}
zq*5V?l6m}|=lT76{yf)pU*|se{r<e(cH3MY$vCLtrVV2Nt^`XqSWDA`CGTTb7($9f
z=c}HWzTkq?OSHkmOK;y0AySZc+4|&=h@i{4PDbM@gb9#dK(fhdso6HjdIC&T3fq4|
z3{VarSsBuKh?p8F)nE%Cz;KDjVtY{qnPOJU(JbO2qN}A;m5EE_vF~!@HtN%d!=|+x
zrwz4c{6faEY4$KqLB5r29Q3Oe>{oyOnF}doUf|>|*+h(tZy@tsfo9R5GO-l1S+E*}
z#|WcIbWJiUveH=rlb6VfJxUI@NzsEt(SDV<e!hf&<VUo{(x6HyBm{4zL0m~LD@ig%
z_8WlJ3~@YB_+(2`Q0{5&qD*w8Ws~O8pT(tRp6=V)U#gqF90?wq6I*?L51U{cHG9Ac
zLo$xz!8svt{a~$P0j=F8xlTlsX5U>XK_{d!I7BVP7#uZA3n>Ce%>|)5AqG@vaO7QF
z0?imbkd#Th`hnvw(r*seu&S>k>PAjhM-VnhBZHbme4qaFWcyh1@sd!W7EH*G0O*<l
z%VhP2sIx^4Gs0^#A}t_EJXirwYR?wypLTqA)I})5;uq1bU?upShS_rsVvGH~56U5(
zMB8_L2fe-p_b)3{NlT?jRV55MPSEUP$wq0PEiu8yUz(YjY#C&~rm?n=_hKXz@K9dK
z-saKUtVFAF!vXwP1Jir7jcCK~)t1zcUykUAA8!>Osv2{JD1Cda8$gPBm}J2Vj$+`g
zC~QZHkkyJKr#d)f?saxZvZ5Hs3ST&SK1KHOU`k{Z16MURsA{#mS^}>6cbfEP6iiUB
zvDo&fO>k7qInqT*lADU^NXSi_`{>ypDq<U0J_1f78k~4vC0$oFZzF}X&$5#+USG2R
z@$@XrC?v?&bU_ZprRm;k46f1&aV07-$S!t$k`R{o_J9S0Y@AItMm{h~xnuA_iTN@a
z6{V=VIjDD8QS=Ai@Jmz<soKC>(HKH7bd5}iU7Ulm68shwktt<i=L|3WH1cjWd!lDP
z#C>4wnJ1=7zmT$yPPB2@CTkENnV5rCsy{;DB;Dv?%M>tiJO6d@U}!JVa<$J$aVe)h
z*_xzm3{*Y)qZ1&ldquYi#}`PdhycW52-3lT(ia=9qKHwGYKOkslZW<0`VJSXel7J|
z^ngR=Ky{u7-XF=lWQbgm)psU{zS?)lyOi%nn#@w4MF<aZ72H#7<FEn7d)-s0<%#mp
z)2XH9{!!FbvR&L$C2m)jY;X)n$~p~f*>RF3gz(AlUi*bgyJsZJF9(Gx+dLn%oxIp)
z{=3ba`%A3bL0Xe`5=vn0`&MEHtzv^0J@U{-lfhnW$EE+#9P`$ohg9{51>97feI-t;
zeLXi>W%s@q8XQI7A;M^OEj$<`5jDrwS<;Zd9F%nSek(6ae|K@{L$YxI`4BS2*lS7J
zL0fU2hgd{TY-$Kz;kkKL-$HXqc6Tedlc!kSh`7pgZtUTOXPXx;8ePo0KeqbZ;#ObT
zw>}&-?e!ix%<Y-Rr@o_Ph(XSzsZz2%gRQ0VqFMxETV!R1KX2>0IP<Xo5ZvCPVNG{Y
zQCC)qI7jZxWb2P>BvhR@=}me@f}HiQJb(FtNETa*wPMsuJkxjBkkZ<TgIGlw`_y!1
zHpk_6!8Mj-%z)1CzXoTV^W>r_e-qLq`bE;cl4Vn#Svc`oW%p;Bb8q_o=ey989DXTH
zZI}`j(WjXR4Q?WCS&(u>mSoLIiW(fn^d&iS&H>80<>9Z#^OvOGB@GK#`F-HX!qzTc
zHoEoX(XFAKv|a~US=wKwP6&Mk_pa5aE=i7h;Z6uhZvO|B#TKUz`tbc}ZfY`pRcW@}
zXZXPQ?(wd>H6Pu&luFG44qseKG+atlSGJ8Zt$X&U?uKc7O+a<Wl9;9GA)7x{-dzpP
zOdH=W)&KCXM=Z&{t8u>CCAHcWbi1qN)1MYev(|G<jXaBTuS_58r}!<+9F@Bt9yMz_
z-reSH)*js59%a^XvAZMDtTVm4GtcbNjqXQx%(`m2yPD0qJG#4{aLsy#x_dNAJ#U#6
ze*E5Zc~GL0DCa@^rFmK@ge_rAQ|ct%F{bIvnf(HKSY{+8bV9FfPyabHT+yd^&s~F9
zPOb4!9I4MO#IQ{d)%mnrW|B63#ah09+-|<#VyG}oj98c5GkWsK*wLP+|CzVlB!#T@
z&74Su@KMDA`rCfnUwziCwR_t2$@uTxWXx)kefFm?)zqY+@oA%fGmGXggZ~}<4n53I
z#>YLzD}jl_X%duG@rQ$L>AB1?GmR7;)rTN2Q=X_v@HmAOHB6N5bh*O-Da~H|HT&3d
z?(v84L-UeX)$%#k{Y>|SK^-MGl-IzdDC*_Cq)j#)>rpS>$xXqo&VAHyTjusH%k-|~
z?M;6hJo73oSP2}3`7hwx9CjCM=tahRy$Yrf6<0Vq=w$6lPGjyr>>Ni&Hu=l&Zhy^8
zez$|nZgOiIc`ngLvER^0pR7dyTj`TDCpo_~o(H>feqFTOnxS#{fdBO|!NV%t4I|6X
z9Z&x9y*%=f2RF=iir}?M0X@q}R-5#gOjIDi#w4j2wzs>$*?D)yoJACGGr=G2<K2@X
zsT1_Plj(1pr$9WitNZ=GUSq6D*a`P+pXOjsG<59v#((4Syp1n3Kd<^3m;SxFq2y65
z`?PorT^}IDI^a-nwA|*p>Gd$Td&gUYUUXgOh99rrKg$&Sn)kK>2fuM09-u~jqH+38
z+J+=XuHpD+7!9YITJt2f4}9xy2OdEAo_Q-JxcpPjYbeiPL;SCxF40Ku)n|bN4sXe{
z(iEZO--yrsZslZ2(Z5l35|Ms6^I?(~oCDu>#C&@B_~yl^|Kf8*c7q$rD)XNJ0Rn43
zR(}8|-|%|eNW)0QffgR0vYwRU0D~Lx+O<M(qUTPN*>P@+hh1og%=PC3Q=Yv+vgsh9
z->Gx8`RP2{71iM{H6~d+C<iCvr+P}IFxfm_OVb5RQIt;{Yy|`M{Ttsq%=h@`!~u#D
z?Rxtkn9ogM?lr9+a8-0D1~!}*2R!z;8If$BWYkw_1U6Z*A)b~*Rt%-Qg*7D3I#-qj
zao#8j=})imm&&z{yNqc)>KCEn0EXZ7eEGA`+S9lgtKwqi3<%>t&DSba3swObAi^@2
zGUNB^?j8ZMW9VfS**n(?GrKm0hORW#;fz9pz+a>(`1?T$<@mD!)o~j>^wK*7N7v`h
zc3Ll73n&mO3;?fHD{FWOWtFw|3w$y<O6n)OiF`$Bh?(`@4>%6wN@-H@{S|>8C-*{E
zpN|@Eek$oWt3eaFGuV}8nO0#ZqDWX#<42`suBkLc4-zF$MOMYVe1CC1=i=joeE|l*
znT>T@fqh!B+B<xfDJC<Tz_kx3vqFajRFjd#q1^|+VOFrFK?2IugD=X`t>e3K$+xde
zyykQe3Ln)dA5*UX(VI25t*>xY`^}(7ZfMi%<(m)Gr%oF>D7Tck8Lc`!HY8;aegJNx
z#)M4zFa4N3zbyU9q_s+zl^MM}jrvqi;}^_(U!tL!8+}C^HZqL{Co3f`cdtmE`#S6S
z{n6*!Zwq}ES{~$8Y-QZVn6aM+R9|>;vRDGwL>+kiiBrlaLLQc)<7m@$p#_$m%y$)C
zmDAPAWQdLua`H)9MA2D8enqMVOf93N;5R!BZcr;US5mTowThkQ2Uk^J{1Y9E@P9b}
zZhMjWOhksZ{3rtxervxCxIZMEtCjoot$>caVzD|!^8)>6dNyFQ{^3r11wZTclBIOI
zyXUKm4#lkt{I9-dbjf{{`gy$4E!-<THm}7i;|j0-94Lw`n>OBuwt~IAgK0&KG!6;P
z!cfHa^0Z|SU#YWQ>4pnHMzIqgz-An~_opQ@VU9ORW?j|^=O!v)v5b6MWLLFNej~$J
zF-;FgG0*lB18>#H>hwdEJ&UXkXve5~6RebFr_#T~d=`vr>66TLXBa+Df_Hb(lV|6w
zmDTBjXNUU~mgZEOYC))Y)o18=w5`bmGxz+%MY;7N+e6=(c~>?U6+luHqHsPVReuSK
zDyCR#=QDF+xl4*zDLcC(`T5r$E*;P*wsVZkzgD`rq(YQB?3}xi*EbEDJTd^K$ogpz
z^a9<y9;x#_-oQP~&YU1sJkXR-cB|UFi$%;I^xe}CgPa(^Ghf4oC)wU=Stng5uHDX^
z6pa2Q@b+}AU31pIjGOXx%5%a6Pc6l*ZvCQV8uPmxiH@8pS#}6EN|btL8Tkp<FhAj?
zj4SjcD5LKC4O<S1i_3=QD0a!d)IKI||9Rm4jT!wAW5k!ySeu9C7`qU%kor{W>CF(S
z>z{0QJVbr>FA1NZ>vVZqG6I$S?@~?-Tk3<Pte*G#U5idpl5N$h-47D+{!=!P%72>i
z@aIj{x?{#%_KD|N2gGY7QiDwsFFn6ouUC7N_p{q4n8c?u1sG{wz<z^$Xh;*MnN*~T
zs;=nVj_)sA5>q7Wt6%S!INL;Q3@5(L9L<|Mi;Eff;ypykO!RqH@&hhPgcBL<hk~mA
zVj!-0)ea<AHgaG#4gV#&Fbr2AF`^1Jo9t6R|6Lb&(NFPBSAQ{Fb`AUW7R>0q-I2Q&
zc-z`y&)7DEd1QTf*>VBA8g-+yid?1B)JN(&&mndWZT?gU`uK6mJvQ4fCs6(@<20&4
z=bm6YPoq@hij|vzYi2L~o|M!<(ukRBT2M^S!(SRE|8+ClZ~yA9c@eJlL(uD=#H3i+
z8ym&@Fs?DKK~+JeZrtJLJPgn9WsjaZUDd>V2)yHSpzaKr=1vLL4Uiu?AJTl}CwO93
zB)9g>u8bS8!RvM5xdFxH%upS$fBQ!JK-++Fgu(Rlf8V#`s>@z9<YPZvftHDOV8gkj
zhq~fgLkbaC&PD_;aQNS%^eG6{^Tb`JQ&58^&+djCH&M4qJ?&8FrF<rV?Qps`C~*9W
zqbg-`^`oKv!3vXJjlA`2JzNV>IDOK}*oX2ApxPmS!>D=*m*+5}pV7Q0K3GV+%>uma
z1afZM%B+YxPSv{)-ZfZv3N?STyi(LrKA~k+S%3X?yZcat+nF%?U6#kq8-wxfZBM=U
zvs$>wG%J@iJM(EL?`Hffq&tHnUXN@SKf}|w%$yjQoX-nTiY<FD)O@m8=tEGq$>YdV
z&F$YZPfzC;SAG!w+3vfuoHbtDcySO`f+%4c|5x(ihq`)M@dMYzRUWa%G(j3)`AM2)
zl-fk@#P%L2%kpytPHtl19-o}wSyDp%E6ri!gM0JY_qO}B<y)N^?|;b+Pw4Ol^A8>*
zt$%oV^W%o}&u<$^47d0`g|%8vp~AU<2lban1bT}8dx@f6+a{yC!+4PYF+XlLnUtQY
z{?V1{_&xXKi}#@t=Q`Rrk@qTPCY+6$XKv>Hs_D43`YbF=dY75^QS16q>bibWfM@<t
z#Vzg}1T<q&*>@*VNfKzP<2N^aKjo5WT3fBWGyE-bvBQ6<r1qDQyZn=lbM?Cq+nS6U
z9Zz3)dQDyOaal6YIwQBG2UoiIGyT8iQoUsk4VfHr2;1I<^LP6D8t}38Fh{|jrKWbv
zT&exB_)pJQPwws4r-r3Jvc~43OnyBwKX@hanS0CS<4<1+_g)(4jsF%r61>AYt#5Tf
z#}o+>#r-&p8WdNXU#%49NoSUWk)^n~FlEb!V(A(mCZwDHtY`jbIV^f~(9dzvJbQ7e
z9<a`?C2)43jD95YIV|e0Qnamf4)(h*THh*bnS;_6&;_W-H9KQY#W0v9y^BSs@dk2-
z=l$yEB;Au`0AkA|@pHw|3De1UW!iruke@hBRw>UaS2N3-INPJyu%V|DUD>e2mWi`#
zFqJiaAtktQxu`T23CDArklIIt?(5Uwt5nmlP{Bj^sfm$Yr968v`~VKWV0wmIwkC9F
zgpaH?-UNotuL<kfEi6pJ$M73#YY0XD)rFQXP9!8~9jOp1go;5)wW8$KQCJ<312H0M
zts+|MB04&v`-A%?t)i%mjl+UMtArf$Rx!sZg2=pd6I<FfM!XpmBv2vxhN!vgD+7n?
zQlY+0AXM%Tu`4m6YD>5c_9vhD6jhw<;1CZxAQ4QE()=M=?ksXc3C*>smqsZA^(-7G
z3Ax}S#i6;FxBS>%N{F1`uUwavX?+5-uZL%gaUdr!jk=tw)-amn2vTl+3e_gS$3qZw
zu#sXxAY4#J^!mM!K=kIQNJu%N!N;pTNjjqZo>)E>g+<Hj;toclE?}jyv63N4E+R=1
zPC+<0R)T_8aNf8E30FX3g&$)2%Rs7`Ny3xmCtQQ!mb@|xz6t>1JGe|1Oh8XU4^7v}
zZV^=lX{!8wf~OVJI6O8%xK=br1*UkQ@$9uiB~951)Z|m)Wup6G@Lls3L_bF?o2dB*
z(*qE~202ovZEauP$LzAT7N31DA!<(gqEpJ1B`buuTWp2Q8VrP}S+J-sBzlcBPwS}x
z3syW?Qc`$#ME;_$@+`p@%#wJ+>oCDqj&n}8`YK!KFK;SpmR+ZOE6Ec)pqF_-p-LAp
z4Uyk3{tY~q-#`#r0Z8VH3O2fcNRm8DS3y8j@~*Nh($;^N_>fMO?dPCiej+QlG51M@
zB0b=io}5RZ%<jBgMa>}?S(t<C22<fdr0Jjs=2~^IBUNrNlF)aMDv6yEM$(i^z8pPo
zKaEpp7(0^fg4?3OBES1>{fyd27`Lj9qQU0<l~Pok_33iu$SHHIK9V1&@PQ+9{+d-R
zR?{7#yP_s#gB1(;t{@+z#r19dkZr|vd}y^s(1hh<@_mEAfX6PjyKMP9Zqr7wE^h7f
zv6u79s{t}p+@-k%w!|50eLaQYYeJTyc1GF&5~O<J!Ewl4Og?m9%PWi4x0h7&kEp>`
zeSCDOUtw}ihvTEoAxaezr3%WG2W;I6W~`jmOzby57Y!;*fAX;Up-`WO0VlanVg=ju
zoqn%GPOAc2fIbf^3S6c}BnniqkSjzrIYm)ug#k~Qco0ns094g@ZX2FgU{v00rygCw
ziokqjeL`q3u=ioG1mu?+C^UXANxnB9Q=8=J87u#AP^>do<GZdI8Z6xJm$={}d9~Ri
zK3ejFicbIjT?7Z&k5k}Ain!Og<t60CLvwD0l-Fz}N$kz&WS^C~Frwm)2RK-TFd}z)
z#C`f#dy|h;BrHW1q{?DodI4431J7T-a(m~Hcs6Pepa_rz%zUrsPZ2i0Ko9z52}>vz
z1uFE1c^{Av5Z6&sDp#gO_!(^Re_T^5ESCxxRCwv@Y1AHIa1>$5QSgDu;RXXvwXedN
ziWH*c>2ehCD=@||`22<7`1ar{Tfs?&A*mNaGTKA#xqXE#2&`b>mtLHbo=1C(d@X{7
z)>S-i?+?pyXCOhvdv_E15i)CPvhSu04SnNVh|;&`C0q10=0MH_oeU^m!#vx5*)W{f
zZgMYF4Mz0mD$~Trbu<cT?pvU!W|~q{3i2d{ANx%B!P2``cZU1@Dx3PMFtQ+JL0)rS
z07<lM7>g}=Aex!vn)+OQx(qeADK)>fs2Qnlk!$byI|dZ0(3op90G8kZWF^ORJpANW
z?}nF*X;c~JmK?m%`z<U>^1?rgoXYnWKP)A2IbEFxzff+n;IE+RCMfHR?wLn>7GQ;a
z?_?(FW~u?w<q|$g5`I`zNqqv}ymJ;&CZ#;^#xSDXuk_{QK%}P7e@7B|khQ84rK_)0
zm>qd3S;G2DZ!Re*P{sw8`V~3>-3zZy=VLV^^I^k2X|M{ZTpNLi0_?4i(z|wE12D6^
zc};HJy>s*J{*B<u+#m0%zmGk1^gZSArBkS9B8>Vk<UqKevq_6(5cnuG$0cZi_?UF*
zE<rE_qzXV}6leyqNpdif=6m5j{Rn?Bkdfjmzsl352}|3@6vId(0xRb=$mfl6+X^=8
z#ye-;Ak(o%kfdzPC2P<9v=n@v)W6WWKmIt!HsTVcZ-D`)Wd)cr97>a(6p(G5SN;dp
zcKaBy0#6>KX=So#{gu>~EuHA5iiMnO2QpKC2^4sDhQ8m<%PbT66CoOrifbneoYwc2
zR!qA!rt@w>b-~v(3sC$2{vsjlWs(~$LVmUk6OyD~GwKpYs@GIiz@1Ux;)|}xJ6$`K
zHRCW|a>b=S%>E|N_S)gs41l^RasFT$JATDiN|&hl2B7hS5y<&7;~&F;Ia5Z2_6Epd
z4d>6#aVzBw>Eczh>6DP7NoYr0&3N{>>sw>*y>Z-$?GSXY&7+>)V&>++_e=nJ>z)L3
z=-gsbG%`ZceQ0tkN%nba)#GwlzO%D<xPQG}pu|Byvvv+lsN`4AaFW!RHU2s4r0A+$
z6Zox0xrA9bG?~!+Fib@Cb@4?(FkJ!+NG#-w)}Onvz4Ar3e8Q%(<)>$i(n=Bi6Sc!X
zE314x{9W8cbFNV>LQQBX;G0wUfBic;RUIZPWlHz&!3ZVthi&b+3Lc04GVz)VM++X+
z`CTgeU0#i%Uwr^x4Eib+?$~-#C}+x)5j!urp|=Sm-J0=1aR_eGg9;12v5#p7wm?D)
zKByKOBYqNcDMbzdZRREsBBD&r9>g!^LAwW}tNX2$PTUiGLnZB$JzD6w`j)@)NT=wf
zIK{uYFe@6Bjw!?L+HA;rgeZ*TE@>Rt1z6!cbMlcmh0Zq@66u8e+)|dPYDu{Xv>Oxh
zhic_0@Am36fw^I&#X_1rT3<nDGi_R0G1Ct)v%ZMfXpIj+bwlNnO=Xo1zDL8EB3m>c
zs3KCBN3J0U#_-eZ{}q3PfgKDu`a1njMDm}8qYbUkdblZO?<lW(f2+dbzM}Qf=NIRY
z7&eODNyx-J_(l!5rwH8Y_xfF~{@N~&YHFl@A(gji-AQ5qp#yJci#)G|g<v)FV?~o>
zMi3}rLu;8rkQ|jGvt=rJEN4^>1!qZ&^pv00YkkL(6`5zD{E{R{*k&VV_)NmY=bnjg
zyA$i?&weF5+v$1s?;SJ2UYPR(H_RG;ABez!QoY~g3Y2OLcP?g|4|8SnDN68sQ05ap
z*}f`tkiWtQ5D!;E1Lh)rbD!v*&uPHj>ub!dqRzN&&G5E|J$o~@D)?085b9%@mmuxm
z7T8=0EKTUv7}le6e24Dg9`i7AtI90$Hx#&3xtbHJZ9VacZ?|8H+X)n0JM#tum%yU8
zFo6pMAyTZ7T%R8pBjVsIS+=a89k1>xSMeF9c^Ln0=t@lS<oJ=Sn8qv2`i?VBWA3w9
zDSlIh*!Mb0j!C~cX?x|qcfqeE59I>AS+{zW1#YX$%XJ)%_)jild4X-FBwz(*y_=cS
z7^pZV-{-fBz28qNHpNP8V9Mc164iQ{-Zy1R$|W%D)AvhY!oKKEB04rOm!Q-K@>v?<
zEZtl9QZ4);6VEcZ%BW%m3?CDe9X_o@JOTzeRAAGVW;B$($#ay&sGJ6M6^T71r+OD<
zWj}eCO7$-(GZ(AeroD?GpRb`6U%7WHZoc1_9riwps|od!L`Wc+jimkJ7}=pJ5<oTK
z`gXxOG@Rsn>*f`fLD({n6V$W=;GeoxWWDbLGO_Y^_Sn)@zS{k9*@OKGwaM#pPcSv_
zekj@@gZ$`)`$c)S-|hl%TCNN{{)ocj+}n==6S@jpwgPK72};9MXOf%Ks7KWJze2JI
zensUIMR^bV`{I+|=YH!%N^i-0M!Hv?{0N|C9|~OxP@oeGHrT?q4Em0Kux<p=ciA$o
zD(!iXF!~CO*(n=YRplVRlhnjcF#5STP|8k)%a|s>bSnBY#56o3(5wIT0t0&=9~@i0
z^TbEe-UdRQt{T0rd9o{k%db~GUaTMfrYA$MW+FX)E51scAOKK!<OVh#QT*{hI`saV
z(3Ts-9Qn#qIvz^<#S`!x-Z^L)3<%k&J)I08WD+AlEp-MS8U(Z2*mC)QH)8*rCR^Nj
zDTLYj_8&V%P{tzLxOHK`V1&L~Gk~EE?_G7fw0iK=k`rjxt-@ZHRevOB5)WZ%1Cyzz
z+sc((Qe2G3U-d!&%;Z;6(^vH0!noIWC{F=W#_p~pfC8S}G)ojd)V2B9@ZR{}i+SY|
zm+BGMf4$bHzDlI69Db@&R9<inv>;t@O|HSI6$I8AlV`a)wGT*u>1LAWv*T@FVEv?y
zxyL6yRq;s{wt#VcQ$$9qvZLeBR#wOM2rj(l94&u_#A@3)aaX0CzFTB~(Z?iumn|Lz
z-e{^wpz;UU?+rRWDodey96dbJ6)Kb#ER}@QTrvsTBLUZrSe!s(<x|ONVi7D+mbnk4
zEX#HT;xlj%nh|;$_zjV8_k?~%A5}<9xt2$K2N*h-+)M$n#8c2#Pd#PJ`CX|_U!DhA
zi~z`Ln}EGk<txb+0-;s;HtMN*xPh4o8*ZGRleECj1K~nY)is+_D(W|u&O#rHERxou
zf94rN)gCyRZ_>p8`SFiw>VV}D&ucZ%)G%b-;prFm&a$+}A|6cW76$7He!GS^+tH>o
z@$gfDC-=D5`uGiZ4?#82Psh*0uI1%|WbZrP`fq?o;L7ywPr=Sch||Oa{62zDerxI}
z*-83rAI*j;jOU*XG+r3SwwJo^?+A@?>*su*C#BsN-mhAfPaJkmC6CEvMcbqFykbVw
zo5#<NX+MFV8`pj2aPFz$f7$0IOn;1@duG9f$4-(Ej<HiV3OTXUhYvoDojGDDbpE-^
zQOENy+`V(ozx0fHdj8evM4=0_eto;1z}bRfBr4)L)8<kNlfBhjuUu*)WyA($D0+u5
zFUlep8jb$T-9B_-K0tCkRo8Q;AXf>h<>zR|MW;-tV_)&IBp)yRe1GU&=P8k78*d%B
zd0?wQ*8!!^zj#cMzWp#Hxq-WAx|;Ui2VEdWwSUs`4=>W;9$b!m_K0=M0bMd@TQSGl
zE>~VC2xoUL-l3Up1(V0cym+_q)H3$5<?E=t%R2{nqK};DWPxlH9|L|2r6Hig8hx{W
zCiGN}L&mT~3`I9{GZqpr#-BY!nP-Nx%7t3q45<hCW!&%IuLLenIR}L?VSD~Gas4}d
zf>8eXS(0uoXYwZ)15bumXm=rx05)3;|7|ixT+MfCf9Cu`3P_tXQs@A|ifB{V3VX0;
zQ2`WkIxwX`QmQ~%!Uh7_0`km9IV;nfg)|6NNb~tHZu&W+1-+;+OE^Y`W8vXkpGrwO
z@&*x)$|4}KsK;}IdS_7uEg@`F-`b##?)>2OU*(!E`@F!yJTq~YxbM@wY%#30^77)5
z8C>hXEkUy}xX;8El?~t|&%!*A2Y{S1UTnP&-7kWSJ|8lS=AUKQ6o$(&vMaO>Sf^ac
z?#H;dkPh$a-M5JdkR9k7!KEC_H4Rxk#6d#Mc6AWG@XF#WJY7tehLVvAkloCG>AFnI
z$5)Y!wIc>~?V<duQvEJVvIiX04dBU;N~x1hN7t%4m}LPew{ZMvhIbxGC&ya3gJ#n#
zb7SD+<7B_HA<KG|CXT+YGbIyrm9>@lv22S>A&aCGwFVS5&ZCcuf@k#UHnDF54V8$*
zM<kO`Ql3X`B$he+$#wKRJUQ0y?5dBo=7f%k3q|>^#R({7oliLmUWM*nd1@g&b>Drv
zKk~0$!O@h%k|zrS<v6SqEzVSZ>2hU_<qMem%sS$`R6qJ}(Xo>vkMhFJ$%@nUYF_gt
z$8x@$Kaq$QCa3hNCCmDq6=d6Ja2M*_nSJy#WxQG&;)tO^nnW6mCBF7bSa+5VuPa{=
zJh7B_Sr!bG!dPZ-zfAN$KNBBSLCT4jf=rJj!EbAPM!lGP(swK2z<9oSIEQy^P%%9K
z4-4kbpP=dnltFcBDVpn~h<)M}6te374|T%Rq5b}4?zhM)<a+7D>3QT=)hubaNZOG}
z68bTJ=;+Eus$am6O44IT)ag*in19$K_mFT+=vgeVly$+64IvklqyD$b`c1cPtmF6p
zY0!NOvy(g;(q9UH{like6X{X#krd(<4ydlWfBw#cbspjS@$#_EkI^`nH=@GF3&_(#
z@2iiyOycxmJo_gIi#nB78F2nTJ$4S-NO;m6%Q8V~#C|*Jemn#fu_?U24vqJB<C<0r
zu=!OSkcJ#dEO&v=ukJVCZ1G)_1k*o336BJQBZ<MajxTn3I4WCw#9(-cYB^hF2c{i8
zMq@-j6$74It5?=X2<A*WIqE>Oxg|Efj6Ufl5_cuVV|GT+I(<waaAe4sL(Gl7Rnn!|
z2Px;q<X$S_s4&X}X+J<+KsHCEWa9eK!zUN!+s<ooSDukVS`oyUs_CT23)j>mX3F|Q
zQWWh`K<^Sl0}~qXU}VUxP?79@18*++*b!%%On<hQJRrQ^r`^MBFmG-cUvjtzq?I43
zZ6O)oi5T|z=lmT|A}M`7oo;Cpf;7eCmqB0T5dB&|&F>_?m}uHg$uCD0eo%hT#i*eh
z>lm?OdMb1IHmNT}3bV(_T5wvQX)Bnz{4Y5R{K0k=J$?7`%4oLM4A^WXjG<nosIWHN
z=J>E9&%y*E92f&7J8&(20^`c5AQ+E{dH#Z*UX{d-Q~PL6<a&$k5R$VFl>+9{9<eGr
zIUWPARgRSdD;HE+YprGTAsHthi63bA!>7^jN59NFCxy5{Lb)$)z74RK9ItC9f>A0L
z0Gw8waaxy;#;sc-zVTm$XJ7oA&o=cchhHOX>qSJwdBRlIXQ@H*;Q5>({5u8V{|@&{
zPXB&#?ZlejkALR|T_iMPf)$E{fy*nX+_CgUUnl2RrcLV$YgKoJHrFy5NnuFi@nkHU
zt5s{=DAAg|V7Akld)W4Li*CVhg%!H(iHVpGT@TA;UHPN7KA}E*mkAKR7?^I9_RoDV
z2svCG@jUp-i%;B;-WqB)5#q*(<IzDBw;(6yNYHu2K=g(4ttLWA!nq8bqCelFlE`0z
z#=(9l<bdq#B=oSz<yNON^)&TrmgCYxq3hJEynRsPP4ptmI(Z5@I)}ySARw`{-71<O
zmUo0;#cdI~uqMb|^L*K2FX$`4W#Ql`+L9Gba5yy^D-k*gV-R5B?a0VE*zHMtAaKE$
z&6`e;W>ERuHj!ZjzGPNHJ_vfA!I!p$^njp38L$h4G(4Hlcl%_TGhgf+6v0ftyp8mx
z@(uhF*_TdFg=E~IXB5|F+#Jp*UCFou%Pd#TtfXY#4auybXV%qb-W$$rT*+*PWwoku
zvmQ{g+CsAKQWRpGjtXNXBFeJzM6|8?&UH|-k8(VR@RB&T@OKE{L(S%yM~rz$1^_O}
zYcxF&nedZV=aT)tQwhNE9q&Z$%t_9v=0b_N=jYFY=J-9tC<oVLEEjWg7IJ>Uu-5qG
zE*3Ok62@lmZC%eh!^+$9kW8uMcipo8d-lkoWX6bJ9zqS1JBQL-PPZnw>=2kxE6J<Z
z5O)K;*_{V@{PnNGm<RafzDpo(kOMo)UDfPJ=Xk_Lej-F>71dg0Pfo%HSwf>u{JCKM
zRv(yy4*cDkprjuuXDEm8AYXZ;px2qVgQV=~1i|eTY>MEHN#&W&pZ)8^^`1K`69Bl*
z--SnEPYtdefD`%hr&Key^fqS;qKeUB7?EpufmaN~CPAoDEHO6pMqGx(Mxp4{pNNv^
zg3$`z7SiQTMj#0941FQRB?vvo$R3zw<PI?&gKreaqm$-D)eOY@k1Ieyt|>vt%IIW0
zHuLTQ{9P$v2Py51RQy6S=i>RH<wAew$Q96Y;l_I5b;VCi(A;HI8-_2PDvV=8lT&m1
zLvKN+lDh+u#Vt8dtQMES7fLOCK47LFAXuL-$YmTn7)$B^T{B%|urh8tG5P*ON%}d5
z%XQqAb`}hE2^S?xex1$jE0S(r7A+-4%sTOgR=9yk`SJSPW6Phff37PtnMZS4v#eTp
ztu_UP{vb{=L{OemGNDMm_#<R}WIeQEUpIX7GP({N^Uck0kI67TcU$mFg#mW|r6OoC
zyswFZI)4y)T}XpJ2+&>8I)2o-1$PCz!U3r2S*#T9(M?#%^@CrkbXwsOIH~J*{hj|H
zZ1@4!QC}16HT};>zx#;B0(G_N=)HA~*B;kQ{fm!|R^zb;{vw5aogl|WTuyFO$C%bs
ziy}^f#ZQL9lYC$_A6U|4av~D=3m`6I#IE?jhZRo^Ag^+hsub$ve}w4$94<UlUnl7d
zc^a+OW`LA`U00f<X1~I8!WQi+$qqt+U#W>Y_qnADz7^`f@@rZvZb(NhKC0`!B;pC+
z7GbCI=kF~RA=rl{@8%~SPD-gH2sft*K_!5n(}E!!fxiqF%%dt3o~yj0_ukjz00I>5
z54&irJO2f?_~$aP4<%ChE^g;{eQ8`*Z~l3>`Bzx;@66_%`sTl*&HuhMa|K#J8ZA8b
zExh3^d|560_gb{BL1QuL?OlvyA~cqzH8I1`0yT^2RCoMQ^#u5Y!$tS|OO7*)zIuq{
zM8l8ji{k9>=la|iG&9H`+Xpg*+tj3I%WO=t9?Sx6W>^XD7Qx?ykWH2l$dfP^tQ+Pc
z5<YTMlmqp4OI-9R(8c=ZFkpcw=>s4x;xB`$=iGMuFXDvY17}gbPfkfZAV0*c+1{MI
zDN|zlZhc`plFf)!*Dbw*Zmn^?Z4ld$moHeaF0wNjeh_7`xQI{=LcQDc(|7JPNbB_f
zs{e6Lw0#chGY5O@Qwu8NA7j98jXgTIfw&2XyEr*Uzp;$L^Ou)Z`Nzg1u%_x2RZZb_
z<$B#maLJ`}XJhB;cBs)h&ioc2zOXq_!;>ODA<~BH-CSf(pWq{BQ4%DHfg(cwF%ju>
z(f!*jE>iwg2+~#=C3U$Va;%j(4ZUU}nuHNKxxdcK?`J0U?v?efzU^`1(fCou+r^K%
zp&#Vr4EcLG(rQ#TG>KSP$d&(pF7nNOWHBI^<OIobvYjL_U0Q6f#KI>_s)|Ol4tFD^
z<E2~wVkmrmI_%hOqJ6ptZx&;J3|?rIDyS5Q%yANIDLcg-L+0cA-dyi%MMjIS+M;h=
z+414D=|6EKTiFvK$B|{!N664<&v~aqk!H?IEfkm(-%LRC)N_Zv$p^1eG?tX$^_8;6
ze+y2qj@JAl1(b>BeMWpxx_#YF*AU{+ky(wn&uhAU|KL1TVjos!rJq$fRNjVs#X9<A
z6uAg=D%?kgHPlDS0+-E|uX^=6&Oig_on6p~SCbEfvB(!Pcz3+dPo$s=pq-CY*){Ps
zy^H!Ea5<WLYlj+2LfwYOxPUO~Zfl7H)q<8c5Qnnrns0jZNskZZmmxRc7VJnTHgt~>
z(M}LxvxLZ*{4*(ux!ImGu5dQXUA|nVb5(SpWlX+x<eGy)Otp)rA@Wxn^7|Bjjftpg
z5>x;y@)7SjI^|)Rdg|IokL!1N<?~OdIzugkpQy4OK?KCUQ)?!Usk1&f?<#Rv^6@)+
z(!hfPv%-!UW)OD`?r0|JyM=fxi2CU_jKsomI>Oz<lK~=7gyV$!Pt!)V(`hZj7S64|
zP%0Ccaf_Q0-gtPR4zdi72YZD=pYvI?3P3jnEPM+-lMh3E`TsJcK`n6kb-sOzHUQ5R
z{!6WBHp_;<yCeG>?=OlzUu$uihswtwp7=b5`wIOnYZrD-J$1bGSSiBo%8L_EgSF%g
z?i9EyDl$#e#I;V$I59QPV>CD@eoBT_s5(Cm1v?-XeA^d!{1rSth*wWMMTc{Ar_A(x
zcJaCFj!~B>p^8gR9xr3rM{xU8C1VDJJf!#@`IpD>U(i^_Dyp&ZmE*BiZ-z4B!4rws
zC0`sQ!Pg|1g^0IE)^E2^I7uMTmk&<k3q*P3{}mkQtNhCdt0@fo;G=lr#5nX1(&6jG
z)A=w){F_*3UM4|!{(#W;Frgivr-IJU1AU{QG4EgJgw4+hb(X%hCqu;3aLvwK-Y$KT
z>U^X%U%>U(XPCYLqQ3{n_r0QZYc;0Wo=?=f{x}3%=tp6z+MhXJ{a(cBq320Zx|Q&E
zPjqrw3WqIq^f#jA4Dt*zrQ$78rpfhRsR8;1;xfZFfoSF)D<@%qhNdV_x1jtqd5;<+
zKw*T)IZ@+A<*7N*^&1xDP}6QkWf$0VR{Ev9tWD%+%+b!p-g)Rw3nDQHdFJ0s&>HV&
zG7^#WaTDKWeA*!0=|Uj&f~6$F%nEX05%CaTJ?wJv$w%0w^nyl=Y-5XT+L{0~=2EB|
zuM1L;LyWujI1;aKM4J=M=aac!qy5(S%~El}CBfe5)_E=-mcsZ_XTj|>afUC>@wa1n
z1AZec2a!|$LZMV>x2hrsgh+4sk`nDvvWK{J8gl!{Czo^M!@P*sOoWzvz!9NkQ!MYR
zGSstl;S@v9t&h-mD3^Chu8~N@zemX4Hstd|d4jFs*Ull{{`Lub)F@1Rw;})XxsFV&
zL+p8`lf{&9(07#i#LM}QgCmDSDk{QLUVfKnz8aa(zg`izNoDVf^l5!*zo~fW^IX#V
zM%g$FZI6LC&}sb!V{Y4tYyq!`9ZZI|3Q0WlzarSG7&+zOAXg*YdHazleezOpwi{gM
z#ZtiVPoKA+RFjKZH{b^id{onthtb}1X}LgpO{sE(Q@ZNjzK_l2>(SoFp^%|1Fxocz
z*F@dysGcW*FAf8XrW&%Re;tn6JR|T^8TIAN!QTcmRg%PayN7<q|In2e{ylZ?cj7@k
zzb6li1-4V8w$t;rGn%)vo^9v+*v>=jY^w7H;Ac}%P>fDjTe#l7p}iiAX1!yt?@7kY
z!I)*dC+A@KEp#SVvw0uQ2L58i|H`ZI4mh3syC&RMcBbe7FFRU}qk}NI`WUONmxB@N
zJ0SAaN8nSVX!zkTSG^^Vt{{XIMO=seJiXs7t)mqxF4jDNoMi19Cdu%y?{r%#w`q%>
zj?`;))5f2=e7=0IZ}<HLCg!q}MDT@w;|u(wEbbV994+96{{8gq7}afW??hJR;7KY_
zjX6@~F|}ZwEh<OcY^P+&Qbg3`e|Bgsj${FJfbe?yqkWN1VEe;>h)HqXqGdHry%`nj
z>zZ0%OxOLDXLs@iM(vIvMO|v0?;g49`QnRP!-=-Yj{<H2`@zZFk3T;t6FL)DhY3}@
zOs`iN?HHVC=&FKYy>}Mt<Cvr-@R+^#QSbSyK##}N)U5*#f83GK*x3^|^m@G!I9_ZJ
zwQN44N+pB#<^>ovK6rZQGI8@p`j6&EDt2LlVe69zBVN(uaHg#yjh1dm-nYt*->tNB
zGGmSfWl(}wka;36?&2N2D_o>Mn+7>ZHs&A``4mobcjKt*oD7+o+S2ZeYaod!5xXg;
zh9k(gyC>z!N-a$)M575{LH#vClgP2;QlMuF2iVC9LMlQw_*tzs+lL{z*p(LgKGI24
zp~j{0>lCelk^AkVS6lrm&Ta4qNo9|!eo`1xszec=0@Re-i5wj`pxv1if|pgGsSZjp
z->Jx>1HA_ARI%zJwkithgF2&_e6W@x&!k_mALh%)V!n9SbB=~@V`p?L_KyLY<H1(7
zW%>Z@M-k0^-aab^yr!byar*g+!b<^?KH!fL7`OvWCw;sgi{TBd=&<@(BNeJTO}k0U
zW`BH=C=vfa!?>heS#D|))Q?xYrKVcCfBtLo=?<O;V>{(|cjuFwL;T0h;|BwOrMsVu
z5h@c(+?`6RAlx!N?-_QlZR<_;UOrC3ii}c6k5mEvr9dY?S@+bg%c9N5V7Va9*sm_|
z)rByok;I4g5EbhA4LB7ZN9n=sPwS(!ZcmcRL&RiLlUB0WP3)KIR%d&nWz2Rwd2NFm
zX2*&W3gBh3Lr7svK>|39zLe--bK+yp@6Tu)<NCw!JK8r#ROHDjTRXvJ$!QN%2_-qz
z9RTEQI^7TYpfY=A7Yx9COSD47KGRFI!mm3B&RrkyKs`jzhSXHe4};M<)F83{o8%>g
zpD9oL11|8e(hRw6{O8S}0ynOGrSY@Z(=EPli7SS(>up@&1RMvO-=~woz20!6OYc>}
zxe0F)oEp7VoSyy6KPCbtn+$T)Z=H8(fSGhMBkmjq6B<H$B94#eUjbt-<A_#SDRbyM
z#kF)CJaEWv+3YtzRU?c&CEeRp^y!W#(mz&#nN_2@qncy6XZ^LcW*Gfl<*dzpOK=G9
zP;cpt#H)W=g#<+CrfQkBhvOV=1p(D@g|_6eU@#%YOBHgE_*$BseU<^tCE?B^3p(g6
z_hRjW541n<G#;EMBF>Tpew`aROrOh1WG$MUY9$jjon<UO3M5Mvms@+TAndcPP9WK2
zVgoVduybAtS;>!!;;WK$YF!j)=6Slhhmy7-D#bO;+&($%!uxpkfJ4S>C!mYc0zb5_
zp_DAd-UKtxtWMGo?u_YjcqOeULE@J}eTS7vgV}RaxR~AaI~W&RCNChJJeBJIq0Poh
z*@fwawb!BH3e;I-tl2cjWLFRW>ID?{3_UKA;nH?FItO-UAM?yPE>TgWbt+G6^k9iK
z+d4?_lF@x7uO%mBDDnXOs}rRRQ!$zi%-}jUZEL_SW2Z^>SOMbDX}=wZ5SyO|LK$#P
z5k1r?xUv+eg(Niwlk}M52+>2WET)48i`Za%3O)5(35uF9NrN4y@>*r{1NK|A3`IDA
zfpUN5TDW3?%lN?uVp7@1saQ?#xfu&5o*P;~s5}D?F$sFrec&U{IdsO9jfRNxp40OR
zW6p|I3$yal;bV6-PO0e_p=!jT7@-wa*dt7S?$@;g7gr|J*cejrbyoS|pLE;(&0o5@
z+=#+DmB(Hi4V+2{N=B}yR4m6Jg0%D9uzhKx!&u|qO}}EKZ~Cd-R*6&p6q6<E%B}lH
z@7<SxG+Js=EI2Heo@F;?G-DiBuUcxjy+QgktmZA^fx4j2Def9eKFTHL$$?lxamDWq
zpCcvcusVr1;4#kVyj6s`HS<Rm#Ui_Wav*v@U@Ut4&_fg-g`!+je$Uz_B#X&?(Z1Ez
z`p?#vXN`BHz^=LPz;``1j?dN@=bttO#_59iZCA^K2_S;>7bFbtnga7?CCl|jqbkd+
zgy_TM3wK7+C?T|pUIPc2FZkmPoszv0tph%DPF}mq$DjQD*c^mQQViTY&f-yyP7+FB
z2I?<H?fDFyLhSm$Y&|%wu`Z^ocwcz1N1u#viQ3uqOdD81pQ3V1hGT-CSdGVkMo>)F
zsa-$xkjJ22bxh8g1b^929z$l!t=SnYsKC_&Ayg;rq?yTU@+v1r+)wZtHp~a~5KPEf
zEjDJ*%62zb-_}!hZ>?_Yz>g*PjybUhEmOMx(}45H=c|1!y0IH%+`;Xa8q=h^gv-EF
zU6;^xA4ka=y2AQSANR+{&gsXc+M|X}Ol36<D;F}eZ7oY=a;G3ExgeNUim#~kd%nvZ
z(^+g+Kd~oepDj}Kuj}41c~V73%f12XuWU1?9^C$=c(X9?ue6i3fRvT@+G<{zNBQ_3
z?4c|4srT9KN;%;sYu(U)tHw{7@H@k0?HF1XyCq5Ejp2-sNZ-k0hX#Z*Ody(TpYB>K
zB};#Bf@;gokGmfKpB(WZUc2Fyg_kfcOtn7XyU-cx&uwN1%){6Qc8sp?r?7|A^tviE
zQ~xI!3GzW|`Ml9jhWbcmmB0?AY;^dqg%)ozd`@GX85w*m4=%6CMb@cY|HnwS(hl9*
zW1%HG+(TF4>-H%RZcN^@Q~nA&vx4{h)*soVW(YCD__Q6?1taN5T;T2Z2F8yN>+@~m
zxu5M6AAUx=^mwfr>^VH(namKcUqZ?v0K+e=PmSicU@n*u%Ui^k`{6PZK=m3C3sO7T
zU*Hqs6(pSDwCpf1{(P?mEV<VwMBnMF^sh<C5>=#Mo;@`T+CGdnB?|gBR0f=-UUnxu
z&I{b{&dr^Ndge?#17s_`{v=T>uA(e63*r^RzYR?M>cUy&3@Ds0Teej8j$f)YKH?pA
z;`UaD<-{V`WfGb2Zb)5P-?3^T>vMPPher-)jB(Y8Z@D%Oq3ej73*r*N$A-1RK6F}@
z{?1P$9X}3_z{J(a*77Xd&#mAu2_dNt(J4E+UCg3Gv{o<$oi4k>7lv<kt%P~bre7J+
za0p?Yo2AjCv**h#5wfjiYfx4l?UNa%Dv2IIDENHe!bk96Cg#S^G9Fc(+GiL@phssS
zs{}A^&zLLR^jF(HS$$CoTJV>kxP({hyzRSvE2G75LWUW;_T=7vD5L_0jVbbfBMxze
zU!^6N>(#<;(LIOL1^P9#JZ@jXG^$h53z8lyCiKA+lWFu++Y*?s2d^$hK+6eA`JDP?
zCNurAMS0mZa~MR7CYG$876YUn1hU9ZuyyV{k-o;BzohY6kyh`lVf?NiR>?EMN>PVX
zPnM@gGth$k=|2SS0YKLk8q6{VcOj0BpBEL3PtX5TiVqMJkZscS;2R;N$1$?cIq@9P
zwBhkD>?0b}scGi^IetY4n=m<h*VM}yw1Ae9Gc7!`NSqZ5dM}B70nc0BvM(1tpl_%5
zk7*cE46UX3BK2(I`te55kfZxVs49<9w(xh_V8$fav?ZCa?}o+WO+z3Q*5fz_N~#wn
zErODsK%r+-GHy{a8z@;ll<aXz&O1u(DkX21!hqW`W$p4c?XH>I6=WaSA4nE*u)C2k
zawje|yb~H;Gy>F)gwN8ibAe=kj5stIqLyM;E<38$TJ+{`dOHA^P;BWwsb#W<YaQ&4
zI;907Vf9L|<QBQUDPBWNvJEWFe7mn!*1pKfbO<kKi>X?4hTo5{FMoH391WiiVcZqb
zSvhClV>R;Z1mmn!kvfpCJ59qGSN3Q+<iiEjSb~>YL=9BwcIedbVZKXcX@z<YW1GXT
zOr8KNOF9fP)G40LLCN(vOpg!S{z(o>f?lW6+m6u_YI#kJAtf8>7d0K<-Wu*lrzaHg
zCG2LI7nMF0$f7W^#U42>CJY;YW;rs{O<ZAY-wdsg!YI=tU%V*&!1W72*)t{>Q=Z<8
zF4q|DX|Fx9!404^=t2YG)IcYgxkovsVSFR|=n)5=Au6wO3XDW3i0;%d^mq`5Kez*T
zGFDP{tR>S`!PA-PTqpW2(uwa7srOI14a{1noGCk!E_=yI=oCelqD`g@2nji(<eWvc
zoJ9{gi#a-rpK_Ks<1Bf_8J*)SRq8C==q&TtS@!7^xEpL5-7?|3uZmVUl&G)JuN5)W
zvnfZ5qIp&pXd2X}>Uz43aT<A>tb87#k~*#YTuH7}=fpi&#4rOW<B3`=jmD(bJQTo}
z*^zy4O+_sA*EJLMnXgccCnWv>V@N0~&6%b7nF1F$!#@|EV%5U%nNt~n747{zMn^v<
zasTmIh7V}xw03vH5^J?cWqeuDqrD8C)M1Fy`^;ZF5~5;Ot-JiEG+c1j{5TlT>ttA<
zha<ggusb&6IKhN}gU|HV3s;w$o{wJum=yWx7a3(Q>{4|c>G~9V=<A(yN1(v%Vah(e
zCg7#rMCFlPhfG|WDPRi!yEju8O<KW>7Xm49AuNB4L->qkQ7vSM%3~0nZ5P66p(NW7
zc%pd$FztAJBh2oQyM&p*uvE4&1!6VjPB-po`;uwwL_e(I)-+crAU5mbc+7BNdIIlq
zgF;WFrv+ra5Phzlb3P-4pQ@!wqaj_gCJlfhWTNrw0=Z02UJr49``v!jZ*I7X&U(K1
z7t3CHGCO4QNeD>|pW@RAJ+s1V1;F3$WZJNJ1JP-x>AZG68Rm_=fvV68aru^~;4z0L
z6M0V(zP%av^Agqd?5XI<7~bd2XWq0wrISO_j<=>I8mF1@W_BOS_}jJro!OU2AKTRO
zdX%MlP#`K0pm*V<+S<t!r8nhwPl#Wu*N@{%gz+VjauNux8Z1@qIl-g<(jA6Nit@qi
zGQC7(+G8hvEvNjTC1_1PIE-45fsvq#pK3OE@qc)_^JpmlKW_ZjEExNYbui3g-}f~!
z8-~a(q_Sm;vPUViVC=?{r6gMsDoWBPm7TO9NkT(NB_WBD`OWut-{<~s{=Cln%)I8D
z_w{@|o*zzLzZvK=dw+V}08=h7r~Q3){`z1=CvR%zTX)I1vPN(yGUM}3ddP}jCjPjM
zPlj*8@f9B6%k|?Gmpq3(pS<S0&#1{k%L^&Anmw#r5R9DVgWY|9?-4xFoBOOcf$qz9
z^r}+Tn1L|f*bUxhd0s9q9JG>-cde+IoxC6X;qE2(P~UeJ2kTCq^SgJ|{lUp2_XpU0
zfKWu{<Mvybf8(<rq{AE=FC`B%L#QXZE;vLBpAi3WZQ9~M4fXmdHW<)LOJdEI1bH);
zJZnbj)NsCb4G3>C9}vMa=FJNP%K9be$Mt30$Iufan2*2Ben=qXY4@nKAJaA&XJ6$e
z`+U4`$oek}tbsR|SV)!=KSVMh_c82*53lsrk@bO0kAwg*_gp+nD0EceRGMlkAoXnJ
z#Wi8yGm_a>D_3<d@QiV~8Mto2#Mb#ccr+kFjk?S{8!31#!T*l(JB^5d)RSzUSJoYo
z^G}<4owtK;T;P9Pee}_>CD+7z#lTWdwL)ks+a+YaYamEO6D*O<w0w{0MrQ0&TSkvb
zz5eGhmJYiPqw-f|9+APQV+8$@lyLF0l(yjP#)h-eO}e-9OcF6Qok7`plPdL|n!Exy
zc^~nufP{{zZ2a*hCvEKv{@CqzVJ^<<m7kO@1RY;)ZGXXJ__J|98a|1Id}Vhl?BnlQ
zOSe{5Y7S;>9r|vE&w(Oz5+(y+AcA8)nH1@yR$tpZ_Ry~)bNK-J?j$$U$9q`Y(<|(i
z=9lu)lO@#||8Xva`-RjU<2`x`KkpMVp``pSRY4z-#$@yzD`n9U>P+{?*%|+s%me}%
zFX3L{>At~7h6$&JrJMCY(%HPYPG!l8OcQER)~z7j8{TurJii(ocm1>Ma%(D1=kZq8
z=TcT^TJz`f^7kG2pL}iytp|RtnbT8t48JkJZr_tl$``19$=qusnyy@R_?Mls&u6?2
ze<Ubq0KAOF6wSF7Iny%DoQ}fgy4sBEDii%KseGugioA00d&Lu2yUmy4=p~QCQ6^#$
z)jI;GSQS3|?2@T3JsEm9s%&a&=Oagk4GdD6sVF8xx$WYRj^v8mX<t>KfkME)JRYra
zpHC0LcR9m+=gETU)y&WStW++>je(6}JmaO7f3M~3YzH(yetv)ZSf|b>L!HUJi~O1t
zNGF02o_WP6DS!8gclUMx=^k$<s5#p>^sB@Ae5oGL9eJqR-yL5PN8uyC=X<&!sNSht
zhY}*jG3x(go%kZB-fc33WCyph?o+F?GMQDjY=MhxIq7UU>tOO#_J_fk!%`oVW@E}a
zOL#3udi}#^24TWCjsS36W*9H#On9pBJpYg$fVmEYrJ01Jhtzi-^j>WQsH;`S(x=n_
ze@3XQ1lQ|seoL2#EIq}7-1)#4RZKs#kbxgw_a%PSzHnw=iu~dF4~@B5t&TvSU!gi2
zg`l!9mu&AF$4L?T1*gVl5t-d{HVyI1k7I>{j^<=CNYvYA-kZ0mQK|pH2ZkA?EimI&
z2zoY(i+3AS!x6j@xuf5s@Bex{nc(HcZXUL70TK`E+F!h(zi?FmhTbkL`64Txcr!Zj
z<cUQ72K`4DtHKKsSsnqA9}`diNIb(yj21l`gFYLpdp1tA)1Z+dS(&LF4M{kwU>cT2
zlD(andbS}kjWSBt?ml~u#c!vVk$flHto!VR&%fi)xZ3r!vudzZc7~cTU|P-7BOvx}
zMUYPp`gl+vOa68yn$JRznca{*et(GGO)OUfYig33k-L*dyNqjSfb}#B9+=576V1jv
ze3FU&r~j*&`ewdKSG7o}vLV}>B}ABFL|o=C+U;pl`;%(+r#?0LPa9Z`pO2UcvD#zC
z1*Jy==_b^x4)V@N=`fes_!i{b`Gs?L_|B)p&);+r0Kx@Q;kU{$5DI(f!3lwf4d-v3
zRX|8*=^=Cdx-(Z*v^(J&86n$E)#<0--Wl8qZwkvD%FKO+gg;{nJzFVy@&ly}h@DIl
zA-cexG-Q6{e{@YUkE#6WRD;g%mHZ!SuK+WsAIx0j$nL^dNV?v?n^Of`j`Y;k@l))K
zkjC`VQ)%89KVKK04YP~OcKgZB`AcCUJ)bT_Ls>7&&_H8kP&MNyjd_G~EmId(av^Ny
z){5Ma!b!vvv23#jt}IT7z~6p(XPtSi2`N5rA-=*ZtyP%2-)T?XDf{u!DikDw6H;Zd
zd+D&}B|&D<+@*EjQpp2T-zrM86|Ct(>aj}Cid39y9dE`eKQGle(VMFtr}FZ$dKSBa
z>Ed6P4P124U-?n?vM?6B_dI@GweXq>L&4G1aq1y30~h%F`Oeige}RvZ!kUvOU2c(w
z&cz!>U%l<p+n!9CvY*mR;;5bTvne~Re~V+_yLjU*@^<3>zBaKrN&nMeKAM!TWo|&l
zHEW1KT-soOdY_2Hn;GO`>V+zBbgA3!;u7$xg&Swk!p{JCum}z$j^$;QRGj)8W$QBi
z>BHan!uHZTGS343?x+8ajg}w;@I8ff@unR3y*BrhA&Qp5*PdtoyELd|VN&Std&ehc
z#OxKp$uae|>O*ayOB-ewOCkd!JH-XEuz^kI0}J}zh3EIXe<M-Mm*PU<So^qllxEc6
zD;l41+>}Cibzuf^#i+bCTl4NzZH{VN;cI*ywD>jQAeJ&}>{&mFya0+H_c^(n7oUFk
zzK78j)5|tSa>Vvk@z*)C%AK$C3kim!aqsZpB4d&C#bNx$qATKnaE<x(%ct(Xzj4J_
zI}WMN_l2%tTI;hpC;1zpKIsYy9{0GW_<q9~DD{ZX^#nL+HImwr?>9xg&sdeJrX8Vp
zL6rrrp3RGww5h{VsG}q}?#gbQx7nwb|1`KAgR;#n_r|9eEI6%@4}`z}-XLVQR^#$h
zL5+hlLG=}bVmOlyDSS;k4}J*WgQ@2|`1o!1<eeUozeh38XB1iL3hF~McF~m;ufr9h
ze!lj6-z#^g>!(R+f%Oz-;yAEhkHG6O=VMshOHP}Q)|XqAm^J-8@Iec{Jn?QRUmFxv
zavs%zd2ICWuXA_BISIR))1D>R<B~M}e6QgPTZftwB2o8V7`{Oj`G56t<-u-2F(-j(
zSa2pL1B%-k${8zj)+b48Q{+^ldVX56ki`7FznoR^OZd9Ip1e}4cQaz6yD%qi8J4j7
zE0q9fG!GW+N?Nm;V%6~8;5(-1VwqO1Jv>B(Z5>9pt_9?p1SnQ@E<^;z!p{}&8=eLb
zf72D*iggk_mM((4+;kP%f^xlrp?V|9zAwc!mUFHdz53E{Ctr%@JK(O-t&o0h&hWtF
zwX#7_(!x7SZeR=dZAkIjUNF#K`-bp$hm<41Cx3h_Znyr8_tSTW$hYjh*a-zDF?a))
zr~Ai$IH8;U@1)q{<5Dkd=gQxGi9f;EEHw1puM;9}P{_E!D~HW@n0bQ_b!h^A)s6r@
zgB00|$W&w40eX5Mr!T5ejSv}FX@*5Bhep#`prba|`OLdDv?B0ig?PnY>0Z5zOz|S2
zQ(=8_3wq2Fu@aH<D}89NerC2z5j-cXUlE7Ma<s>ZUs>r_CF*CpRpKO@!v-`1^>ch@
zaMF)f26XBAxq&D}ndf1HhP8;ih-#8uekg(dcs(yVp8ujwXOU?>(^<+<5&cPx$Ep9*
z#kpt_LL?Rz=?y8|AqJ~0duqvv-1Ii8w~xS?53wxos$FUcMjyC|2U-^t*Zq$IW*!e2
zdnb?Y(CSe~?TfuOU6h-(1hkeuJv*v!2WBb9#4NIe=#C4R8}Lj$?xUQL5Vza->MES>
zL9su4MrBl~)}cJSI9yh+j5F;~xx6V27@!8F_~u6~{q1!vx7V%iOepd`b|11hZCDj>
z4?MY!gV7=vF!eijmN#S+w9NvMb7mQC8o2cTcQxfY%s?5{2u7`t5>^}?5<}FR-sc*s
z%3N`}*k6RPq1e@B!9&h@RB0S+aLLCq6Lu68t{E(0U69Y$^dc_8!UxYK1~g`ma#N!=
z6qh&Vtw&63{5yhQA9z<c#F`v0b^T@U28n)iDNyn_FbtXEEkXwDZ<&7x>sLkxrFZU~
zloq}Bk}yTBN@NH6&9H5aW@UlS%L~$R#_A%<U&@Qz3{6Ib)J+UEybEPbnzOI^xD&H3
zB|5BG^4W7T4h;P&xJT`=og8&61N#dK)rw=U9dq!E2^$(jB`DPhKRa+q1D&8_(jf=w
z#x1w87#<51WPb)qq$VpGrG$P7&X?GGAc~*3C4@N245{iUNZF%XRmAJWUw?G@iS4F7
zPSRe*=lQeik(;%5<<E3Y`yWj$ua&lTB1dk)1nZ%h2LRyt@@TQ>TcBFz(whv$rpq7y
zZ9iz?x4f08+c|L^HKp2W(@HC&%<;W;kO7A~)rT>>-vZLcGi~&|%^r=|b`2Dnohyma
z7g=*9nJSs+XCL$K>#@DjnquP=sJS!CNRu9f&uv_pYm*d`0-g9fMfCVtDtZjW2gKYI
z4(D8v1&C^pbJv5KLaMcvT&Gyw#rn}ahnm@M|0^8|yy1DXh2ZvWj}fn+PLvf$(_N#0
z%zv9r8<}RyngxH4Zfc7|tnV38d<_jG53W{cB^<jpgB&wfFsysGnAaB{=*(ml4aSZM
zTI3={-~S!b>=K8`wL#!ld;0X-A=JQJh{TD;7g&)^AyAF)+m=LQO*t(#@50!n6Hn9+
zgg#Skesy=O*UMGe<^8?S_Xme}0XCs_?ACYgiS@jFW;NN=$msg?FykvD<hDFDQd9}J
zK&{V}gG}MyOx=-vtVbL<xO&zw6V}R>(fFc24WK?H{6_K?#YALhe?KKRAOhf8X&i-*
z6}{>_5Bvtjs+MlhleIcdtJ?EhZtQKz&dG{8BYLSYNAd#vGl_x}8OyST1`d8KB+7~f
z@VR-B1>;*un1#{7^4DF<roV&j2a0C%AO}~7Xp6C&(_3}ich?RlEZ$sM+iD;k{OWei
z;%)QkU(G=WzxjT&c=u@S*B!>eqi%SHyc<%?q<{W>B=NW7$|$!8rca8NnI$2M;D2;r
z!ET7uuiKR+W;%*Z!-BflnnnD_i~<(}3eLG(jEUUZ36hI}JGpm93-yJi%d<L-9WTeW
ze~GrLKdz9adOJq=RQdkayOn-BqQ}GcVFcMG(}Q1cxfdBlo|e|64;WX~Y%)0ObHBB)
zeVXGj<)(`L@WwI}Q5GwlR2eFNqx0d<nmdwTKF+W?olL!nuAK%5`>{ee^D+p-7n_nM
zS<?`NC`o1oN?0h*MjZz3yyK3fK+K|AhJNo@_-cOvzWRiH3e5;pgs-$=K*6N`6Mz;w
z&In`Q-(wC>vv%qGFQs@zDD6Qw`QJZAF_e0a2LlV~H7;?mYGKHwe0<|cD@lW3`w5kM
zq)<uP$PPoN9VBB!)LR4%<PA7e38BJ+e=fYYAEqhdiC#MlJv>-x?-{`x1jO`l7rK!s
zUL!nRkxUd9p*yhptXqW`k+h9)o2T;q$SS5xX_{<hmbGOc=M5$eV>y?+<80$W*B9!Q
zWYLsg^aV7&mtUS&*bcbtnI^aL&MReDK<C)_3;RAe^tl-wpB7O2&tK)>+`n7U4~0;i
zB_EcWCI=@gr9cxGNm|`x^HmZ!o2egNFw(X_+?%6lG4fOT^_C#UjY53%wDYSBY#LPe
zPc0$c!D=-hr*l;*EyqAY42$9gAM~}XAEm3?Mhq~lljOef<W|GM+Ga!m2G)l5Di|>g
zM`@B%VAD}>WD-$pihxj}>qqzLHCEf9=w9v9c8fjVlgLPvZ9^6rq1CIS#L!;^YsX6w
z8*|q#KoLfCeLsk)7D+oZ&?b^Vie(rqmU5hwdIN;gtY?IYk&DEnV26o1t|0pY3&p9C
zq>nSKCu%4Y&#aYd?fMrT70AeXhF4{_zKT4z!^BMjB45p@Z*`I^8Sx1tAYPz-_ht^%
zyLmwIT9k49#Xe67l2s(*r$0%4pP>ZpuITUG*MnMG&J(nrTSJ3>3PX%xP$Q(fUVH!m
zRI6w7OU>kx_1+UIA@Q_+T_|QMMVx1|z@Q&@$n1r6E<+vfZ-WX6)KPJ;?2B6k*|%QT
zIR{lLamcs;4I$c5_6VJoLe8@Cz!dE#YS4<EDH}GRl-p~(2s!A|N6^Vo@Kl7|B>|&E
z`IG(gFurqB>A|z?2UkTn#wC3LNU}}I;z3;h>Q=tBFPDWNAXx-tr#AwHvv3@6c_K(m
z2|(h~<kAF>QhSf;RY<`ytl=32SYD?WwblUr`qt6&PeNsCp~$pDGc59<CrZR_nxQvD
z<^}}gK~CNO8~|;kxR7WrHDO}MLiJ7n!Gi>7Z=8$&Bxb;h@*$G=h8}--yPs(CGQ%_E
zrNMB|FIcbs9^`&~j&)_WRC`}s5>$1cp^6LDrc7C(NLmv_t&%Li+N{#tqw4%*!x>@C
z<&!{lt;Sp?evwFVv9n5gExp6I^n$Fkd0j;)&E7}d)&GmN#Il{1zg6q;*geL{s-<6H
zB%i9A`1+e1iU*ibugnmUM<{_0QoO8!=^-Wc_zB_};p^5C3ckqllB5q&%gd>IK3-5N
z%AaWr?$*=7rlM>!7U*8kh*&xqgUXmI^!tJ0eF5z@+37nlQyCqp+P}vjim0W-`qDkp
zzAX`ChrebGa|>@jnRRDhpUJ!R2Xb2>+bbp5-lI1F`h~LcS?wHHONey%4|jgfN-KT4
z8<Bo5gN#P;Di4Q`-RwDNX{QEdq;HcI!tAw$?3IMbrmvP&%uh0HuiL9<dx|LnDLwct
zn#3MAd9h?oCfT(1;-kO%45}0NX!w$)1UOk+qDPWKlk#U3?m>z$Y22@8;o9}0|71D8
z{rkuY{T0ya$HV=GLS$VEQIYI(gb2n^SFJO(o>?)KDqHMbhO9;j_8uXH6W|$YzvRrS
zb_N;c=-nZ9RmkD+)iezRi*^ED5fVvg@{UyS^h8gqoK|^u?ZTigyr+K$QpnG+PRS@3
zJIVKo@ty~`LH}~&Vt?G9Iy*Ma3o{!0Fvl)ll>#RyM`wF^L!{w{n(%zh>)NJ`^9~cY
z8Zt=i$+D1qZty;Xy4-N6h>S?;v+gEAEOZu4s_!Q%kBZDzv@qUpWJ^&9H%I%b?mKl_
zW@p^Cl@ua_YbjrJG+uk31i0HJ(LHf~1Vkq@d!MA~K{i|MyXcXYJKo5#+X4|JS_(>W
zlwq}>Z$Si9cv0-T2PGp`lzjin2qzc`7jWi)5Y)sUVi2H<3;$sqedZ1QCf>iA;!Ub3
z?KiMowrl-iZRB6Ig<BSo-(opNy5v|_6M$iif<FrzmLBOaqp{m!jgJJXKZXu3nO6_Z
zd)w&&RH?9ZDWH4Omv1WzU5&~(n}6$INYneZAZvPB?@r$n6CoKes;MdBQM%*Ju8QZY
zkVcJ++Zj;dYyHwQq4ub66z?8s5tiLn^hO$)zSc({*X^1WQlrqgg5~R-!D1N)vsPib
z?!LPZr@Y$<1{h+f1kK2D2y0oA*x!fV0{xH`=o(z>+GlWj=QP*$iO5ERwh+`}^$g%a
zlP&2{5rQf=f@D@_x|c~Cuaqf~w5TzX61+EyKP}Ir|F{B4rV%80!%4L@PqNF&O7BJY
z8pLw7XKRb5k2&EKO#FMUU#;(qgHd1H9&Ki!O%}#$w6($9BWiZSrK{CS7SP)0G;P7O
z-$`VQ(kBF;JovGshJAj50@)JDTd!}cfE2I{V+=-;Qc&auPZ3K$o-@ZM-&O_i#NCQM
zEpiYgTt6xO1ebPWAJU)zozCdj=@K~-#={d6x@6`IDD@>z<exw}t-EAChQ+vchYG(@
zbpTqeTOkf#iyO|hZhU8$`uCm5C&}rzlSo^fSMpGqnQUvd2E9Hx?sz=%9im-6Yg00a
z;}#V+_7t8bA(2u5H3uIJk@sdM?p){AS7CoJBqRve7l=<bUmN$I<l8JL-HC07^;-`5
z(JZ-*9z6y#uXoIP<J785qhCkKj+>-C|J6@Y^z2t-K?XaboJw9F+`$lY6MTyM^D<&D
z?5UApjfQ)T`rRl$(ffX>X%ekVvC;9P=B#IgUTo3{8x~E`jE+Ta1cvos;2jG!j`DgP
z^cv%>FGSf++LYBGFHeU<B!M49MD^q3Fkl6gNlrEBo&%$~iu^w%eeYLLv&kuLkgcDv
z)<O#T@hj@UU`73RnH~Z;(w?KJlcDN=A74+ZUf7N?%y_r$id+S6%-jhKLz}nshAEy+
zU=CE6d7)`NxPBr*n^$>{IO6j=DfAWEPd~Zt?78OO=kA?7|LFJmzOyOMf2X`Td*OrW
z@(qw&dcWi-0a^X)0>rE?!B(ZaFKz~6+DWq?<Ld5QVH=G2kF2cb23Yp#m4g%bk}^yY
zh?U!R{Sfu<j(-SdhvIXWTwVm7O3GG5AXeQlJ4N`U>r#y`4tn=WV(5bscf2#JmD754
z7lW;kx3dKwB4mV)Fy2^ay5o@9s+qQ-G3(xYIo9kUNq>gd#0D!U8GejFV-G;?9@nz8
za}#hhFwHnOOH#J^#W^RIgN61Pqh3kby-}GUn&XHDVI=+5p4=tx{}7Xzp}W`4@*&zw
zP{?bJyE*tqTldjoFZTC9@<UVt-7Be9V)2Iye;<i})_$?TvBdT(UqU7KdxHKnJ{b0*
zy^KqFt0t6&kvLSgqZ!or?t*aEsky!_@}DEOxzm2BWJ#0g#~6W9`5QhY-jpNrNZnL?
zl)Xo0qRFcY{hLIXG(g3A)YTgf)}76$-Gju1fwl@iI+yfB6*Wck;;oeEt5z>A+&`kV
z>l@bNez)&D1HdZ+@LYwFElQ8>d%<PPp&9LrbHbTMFBo~zkS|+3aV<m>pSbQyd%(;O
zSedil%Hbq!nAgzW)ef8=Jj;};JaYWs#F6BT!+Vf}S`4=xh+AFy?@Fe%8KjVhsuX5}
zY2jn<klF}n<CY=4-M+<RmmcXB8bzdxLWXp|lTLYjtxfUxA7SjGSCpjQa>P)@2rOeM
zrY@8wUoN2_)E~amVgHt51t+x0`PwX%UlaWI{&iYFS0Bm7-HQF4UPCe8d*HOF+mER9
z(&{~@ML#SMs+E}`VX5<^>p-ivC!^-y{2|+lt1@n^d^?*!po{+g8X1xDssd6fXUR15
z@Ze53TBW_FWyzk{z}YWTcCMBSbyh)^m#rhgeTSzX$dhHYz=y<p?)I11{Po*+yX0;O
z;hgIyN>T_~C|iBv3B448+$gbW!sL>Z=K#;quOyDQzoy%|UG)8o#Y)oQ(m@=VZ9MQF
z0Z}MN;lJF~S74MvT4V^Fm})D#xb-O2DedFI)&7GhJxy-;XKSAV#ma%(APS^CO$Ncl
zpa2y{Fqz)_cPjIiQ_tCbu+dC|wo4DdmxUs)=m!v3vi7A$$zmrRE@}F7#P5oQI93>j
zPqrtEhaSFqAbERhS3GRA+N~SYtMtr8wkSq~5G%olN7NWToqBdJUFlJ3$5iWBtbqo#
z#0H=s4oF7%-aqxeBjK;qX}^bYUncM8h*ep8o0wNU{wp2r-^1XSHc3Io1eW=7PP{Za
zwA~i?tXTa>M~X~b$V+3@wM+b)?2xfK`!bUYvI$>{V!#(F_|2Ol-roy<*KtAa?CIG@
z$-lS%$t6Y4_hm_&UPL9wE<LX>J-d%O7ysqW%_9#k%AZf1@m*vQ)YEgv-xSUo5w}qJ
zC}XQnX4&;8a}@1QOFT$Lr#?yi_cs~L>eEIuhxwI_==Ewh<WskkLy?*j0*q?HpRYIT
zMgw;n<d<a&RjM-fe1=Ny#Qzz<+KI$akOP#hA+p5odBk7^^jU+Fd%fQ1<)UgtOp_Vx
zYkf=WIl30$yPd^+czmBf`kFFFKcvAMED>A)93(l8q&Bu24C*{~w9k$OPjT#uwBgUb
zq0LQvm8q#MStQ{zFau?6W5{rQZ^55$YJm5CGSmD}uFRr<fnG&JjX``-Kh}Ia8YVt~
z{59lCdD<oMhU@gi6w^^Yn`J;fOchA%(k#Nnj?;r2orSVjRed*UcK`X88j)3rmnV9&
zffy&pcd1FgjNb$XZN;H=1n$;86Z+YxhNO?<+iOG5N4ksCHz!tDCt4q>l#})hS`o*<
zdV_v;Lc|rgU%t7DywJOs_j*6Yhf^#or*}fD0kQUb81<2ZyvKYelpDo-_Zz{5{vCyb
zrF605o%2jZkt8<#?Xff|3wr~l(!;Rn2Om@O4kkYh*xpdpQqSJugdVY<exXJU3sY)D
zw5PnVTg=N;qLg0|{4+qHcd~CNnVbFxmZeu(ZoVx&sv{zHZXfHZs$Hs{QGL8>UY}YQ
zaMAY*@amar`N=BVqUw8Zjz7Y*T?ux36?l2?ZFlrO!2-DTP^9}*tE)n#h4Vf?l~tg!
z;UZ!JaTzJh$j1)H)J*L0y)J|aq}Rs#Co9X-@%p1O^l=&6@;EU20G2teuY!CG5~dy>
zr8DYeBF4jE^7x6OUK!?L=L<jR!!g4(A@#d&k{18DRwcVKeuwVFWuNIor?!u&!4L6s
zs;m!$wJ!?-BF~~n!fbegu0F;Jb<f=N7VhS5s7>Sg68aT6jLD?iu<n>wYO*CIld$q|
zh>%;M<gFAbCCC7;S!TK1iw>@C(E<(uD`o0$x^~1GsVgvHc(o8umgv4>nxYmKFf{8H
zISmg<I%R9M;A*r!3qL@1u_c935cC}eyknXVk=>?rKurVqDxO^cuFiT=sVvGo&qMKc
zEwqCA%YmqTUa(%{C*SqZ5v{B)liG%ayk^rAfQ?oLO@#S^k>&nA!@9$ph1=v-$*3U+
zY8#^Q666A{g*r69!H`8_TM~#xD!xsC8$cVS%}Rn3vk{`@OC%ZGU#4u}SiKEg3AwCD
zk-Q@bU=H5U0=4#Afk*kKV027jXD>dYhJyf$)uWtoMTJvRN;lz)p?wdD+Ww_=H(zX`
z?`vi1Z@YHfJ4jNrX`MH$`+^D9h-19e$}|LTF@bh)NKECTS%Z7JCA^o=)<^*~=DXrk
zlqF!K=Sv3qx@|}uAZZ5%d}Xs-rf8Vb(cwjw6fbj>=-iQc{4u$=VFBJF$D!I$=z)Ap
zSUYBj5)9-^TNlSqC`tX|v*oYlPVXM<B&K&Q*Zy#sZ>T(o!rU$25=B%sJGGXaXa-AN
zA&;sdWZ#!Ky@qtty^Vm_S`wAMfixZsN+*8(qMLIs7nr4}Wx`yRwEhtN))YNdcm2KX
zYu~0uC)l491dK}Sb5uBzzplsR9ad87y`fPZE(0B-f1TcVdg`Cz(e|GdVB6F1sbwGb
zbZfB@Oe~{(SsyqWJ!~ctm>zAUL^@d?Cd2Jx)?9Q;a4%$#kaEC~Nid4K$Fw_CYd0ws
z+`g~&J)BcGO^5c9F4i~sC7-G^Fv8J5-u?Kw8m%2|_5Y=H8@n%;UX>)lGhk_0D54NB
zVqn@a+*_D|DeX~3;3qW=>tO@;8i}{B+ksI1ClB2t8(w<KKd9M_XX%E;qaB1s&h8o?
zkJbCq74qCp$vM^pT%7iFL0Ok-PtSXJ?B)Z6!eLFAfk+}eO(EaxknH{r*4I_{M5*C3
z>wPJ{4$nnS^hWtd8h@{d+HT*0x^*~V8IhMRHH;DY^>WQ3Q#c8hndAP&=Jdb$KxU;t
zy{dhzea5P#VxPBSMl{80PBlOiG8DvP&xhFqQ%$B49Y4d`T!@w??UMb%Q)YhHx9f*A
z7mb16qqZo_n92sU&fflepT;KQKi&wa*OTy!in8F`KR1?MIu#jSg(y`;uR^XUC&$+t
z7p<gf$%^Go4oic#9%!ciXX;j6pojr6XG_~)vC-ULT~e7YyGLY6)1KUQ?-sqjMkJCY
zB8RKV+Q>K8j%w_?nSzT9yh5(oEk`$2%&xYXxp=t8nfT*Ch9@26KD?i!d{?QDdZ<+=
z6UWhtz4Z9lY5qE~*{jCCeXB}EsJG?j5Ob=;1z~CT#RbW{M&je$*)ypeIW|aor<?zH
zGy{#A=RdO3D>E0(v_>r`w-M!gsh{X@ns5RI;$_q4l8#@v@oH@2Fq>VX8`h(~(C=fw
zZYnG~u&}6Ju=9e4#22Nd4$SNEK&1on5?f^Co2SnDc8^j>Q@W~dFV_UhNTnn)M6NFB
z&f&B%rJqJwEj%<nVJEj=seb>^J`KB5OT^6NmWP;TvqO3*W-bZ$n3%(rXUD%BV+o%0
zG6!I!SpM4Fp5;YJ5iHc<U(Mm7m5l;reoHw2nWVec``SlF6%T5~q?7kj(D9f|j?({)
z^F~6poy(IP!aqW%-=|N<0<`)zdBt+mHZqkhfpI8N63#>ZTjjX^O`TEL><K-D6FFi{
z$Jb&XjZS`am!J|RZaV#%Xc-7!*s!v3Hjn(nXEZV|`m|t1g&qx)u4g@F-6QYqW1jA&
zf81{$ZaU+A!H3_K-_cKP@w=IiD8c)_=#hggt&~A{T90gNjWirY2UE3BAnB4C<T;QO
zt_L#=Mnqs`vT5?=BIfmMcqvw~aUPvtvmXr>*`5!XR?Rn4k%|CG`QFAjtV7Sg{uiRB
zmNq}0Ap+d)CXFx^qcbk4ow`TuwF3?*opTY0OdqDxYTNO*ra5V6YI|j;Z#%7vnA<MM
zb~(qL1}9~JN-krEZ^M(>xk??af{a|=*Dk8IGz=JIfC-3PplWfU(A(Jd$r{lcr?bG+
zPyw)sqrK>Rnq*+lIWSd1s5X4R234&j-yW{msRvBXBhO*)9~LtIqi5%@`-=`1&&DFT
zx~Bu5FeygcNEf&rAeh+=N5V3vc#@}~a$l)`F4C*aa-44i_S5qo!|Y!6yr!%oP)Z<Y
zU<<#tNIZrB+kuHiL36TS{s!u+MLG)ExXLnW1$JJc_0GHm_h|K2i-!@Alc2Ok42P1B
z`O0TfzaSb`AN!}?X&nQ!)_9EAX_!&MRYDb7ID(!?HFF$E0Ph05B%<AdMYo=k72H%E
z2}G{cV3%uTz|V#8bz0FhTs0PEue(;2iBXx44$Hu#gx1%y74|^V_=SAfLP1fF?nIVA
z0mSI`=#O(Q+NG+p!bK`EV1rDyD0E&kf_5pJjdIWOSO`ER)NUEXNO<2AG3u4))QE3Z
z+pB;~N(fhmsh2P>{M0tgUX95TTSedY%38Il^ckpH-iEb&MpZSg?YzpM2TC1UAg3Kt
zqK}~A^W?pnYzwfcH-Gp7JNj}#D@#eHS<l%o_Sz&^c0f%36mi;08MpzP6<RC^5zzkg
zgF^v}gh3^q(cAWE!lhr))#|`7r#sI~12EJ6yp=5{Vuv<uJ-HVHeM7|X8|a7rR3675
zhS`|*5%dB<P>hK50-63@o(6^<P6s1l0dQ6^ydQFTA1mdTAqA_AZ^xkbuxLl}89hf0
zomI3Y7JfP(=e23p1PG5~gu8msjXjoQ?1{9%<dz;w9;V6XdrEq0zzFvECKfFVYHndF
z^wt!@a40`g=oV{q8{_~6ME;~>z)*#9HEDrb`|*I-eGt*_`i%vwUF)V9G2rE9q~kv5
z3^<k^Tx{j+q3BzK6$q5yq}Emk*rYZh^PSYDs_iqiR@+ZvFRq|53tH`X8Id70my#A5
zMo-oWcm;DSj%(oJ&gPa_+vEv!m9zH5ASp!5#<fJ<P3Otz3xs74nYE(J#Tvh2M00bL
zCIC^f#zTT!=GTAg@+aeaC5OLF9R4BU{L{nvcZu`g31^Ok3&hif?~;q)TNhDDS8-2Q
z=}WG1Z(Y&%wL2lEAKXC$IFT1F+ONh`X1Wo6>lV`<s^i*#ILU)4=B8^S(t*Wq!X!{l
zirs9aK|gkihHU5+zdbM80y+}+OZJ?t%AS&5GX(c7e{J~|jz7q|;FpJ?GJF%;y}Veq
zSJx$gLsP;vxHHo-N^#vqSqgTb-qt;CLG|G!9RtLZ@hBg@27zJhc@=`7NDV321q88|
zp5jo2WU<H=oA#ML-hWsdOb@+9S9xviXx^_M(Y^jom$acBH5h|qt|16-d-03UsFyVX
zD`oV;=dH9}+T}F3BN*dOFT1ViXF93kkl<){U&&=Vfctg^_f4w_gEtU7_zA@KGE76G
zUgxzgfWb=Tufa2Dau<8#jkzmZJ;!pf$BPg^M>QgsCRb7;1|Ag-!%E2pT*J_$ya+x~
zb$a1rGS+o?|M9R>Lt&rS7PMaFeoa44p-0XpMrPeVsecmLWT=#l7pUYi5Zw{I4ub1m
z0mb>?EM@<R7sw(k$=>y0ElsIBU#P_{tYqGHrMqa2K+I-aZh{Juf}p8xexEp+;zPzD
z8&h9TlWB){Whr0c-AzX?4*GqbJhZPHBSIHL+6kiq#cbzgxh!5|jaLI*F>x~NUL%*7
zmHqPy<F+Up!1ORUB)Bt(j1IuDi>|8mdW-}1Z0zAPK}w@{PyG(|{?4!cc`5RB?|D8=
zA5p2qp3k$5H7T!#!ogVhWu^AY5cGte_KVs^7_BKA|1vCC>;+M78+$(+e{2&(Gr?Jy
z;sD$EXrjHq6DkfY0aP!d+k51|P=r~&Ddl&<1zZB?mRrEUMWS^40n<yC<&1Y_(E#vj
z4SW1T82oFjeFQ;7q$h8W@NT>}Ma0feEh4`IrxXi9m@Z7OVNb9)u3DFAxXo_MH&hR?
z0$3Apu#iu>+u3wWDPXL3a%S?6z|Wjxzx-po?s=D2zNjrKg%<A@2yasDBeJxV*3lv=
z+Al`n{x&aLYXn~PN^N3Ey-I*e1EyA7p`WNZU4Nq~4*b5GImnHsvEq6X62^LiLD7C+
zMKShf<>08JkaxNI1BxyFqOgFEVO+wRC%H2d)`2<Se^@PX`^WMyQecr7`1OKRIcDvS
zd}j5Y8V)r$UzS=Sr?88eW-H7!3eTD344DctYCo{OPCqie{3-F?L|K4!MRc#{jqQLN
z_1zIGv`@F$3NAL<N-OA{ceIHXH&0#CYFbN`29Oq;u+7PEGbIY1K7G13ApLA#oZVEh
zWO4ECXxc~3U-ePdd6V&NGAWV5y8uP2v<92K9j3W(wgFuF&8GBMed%9YJpY2gs39;%
z(7H$<6pbro`rBNbmqiheCPSk14MMM&4^5OteM*c9Kj&BFQ}gum@t$riv7U(O0KtAb
z++PLNTMe74P8D%dYr+eU_=`t63lHPT6D>$woz&h`JS<S+4^{3}4s9QA{F`n2ryI%E
z2j~$A099yO6-{X}y<vN$fgZ1_m+tw1Mt*x6BwVy1TXgn6Z*LlIm?kevS7?<g=Z!KI
zuXjrER71rK;%~C{0!qz^R}~Ho8U-qp^8N7RoWwR4v!<&_3xr(2A08I0Ao1?H`1ZA3
z`iB=~_XmDoZ%Fn#F4yYH%Shvu->-h&ZmT%wtL^>b;@i;Vb08D%05mZNM$f=>1-#y#
zZzG?S7!IJfV%<EJ(QuH7e~o>{8&hvD?e6=Bdd?@H?-jqkq%`=e!`W7V4IpM9BHceQ
z!~SoDX!ySKDLurBF{((BIcEw$th1lk*XA%FH)d<29#6?!@`+qZe2hl*D*E-RR`zPn
z^y;Ge4E_2{E4go*`m9m?B)@*U%Kk%s2X0eEdVw6dL?fUF;qjqAXis$okdsjQOu;_!
z0?7%mhR&koVnZ}EKniE~WHNdrcsVmFE$1xYJwxYbWY>=jrWe3lGL*dMwJNa=g1u<9
z@2V5b;lY6O0mRaVAj#-<tgpq$&|$%?6$K4Z#6=zSDp|Y~E3;Dh>V30&npQQD3&o0`
zI!%0bogv{Lg1ksT(rZSo)n8%@c2+)XvCiCIeU@KJUiz;K_i904;sv^QMtRWBVx*EF
zJ^Rn%=9!CGuxZVRi#Hp86Lv>&MQgMsR8R3*z0@jT!j*}Xq7|F`5k)<+T?CnETK+9x
z0ihaXdjN7S%G?o@PQJ<;rHpPB0LoA9K~MFm;7}Q-HEPpOa#?uj9gjUwjYfTD2Q#sR
zEbwDqYdO=ulBuv|Y(B!7xv}D}ef8?<`VqK7pK!SDY)21NQ(g_HJ}nq{_Q$;K!jgF(
zy;=fi8AX$z)8snm%O)aE-=^K#1W8;98dc4dTbY^*e^q~nCYWCu<<+KJ!cXzNqSARx
ztDcRNrDJr3YTDCJz4+%JNzjVa&a`s?y%l;<#E^JV`NQhsa(%b##~%AhxXI;T=*k++
zbb5CQL3SC7@0|A_s!I7o9Ck9S7FMNG7DM;n)tw7K>$H5CW@ngUQRTt%S#$Gn?m{L_
zp_K5a=%HdZrgi}<{KQMGYX-a5BSUvw{(W;f?&3KVQ4SU0@i{Z;-ZymZU-RQNSd(|(
z<<|7M95FaRRhYA=uQ%zrY{ceYkkqR|<U0wpDqMn>$@PPQCXCqrsmOX79&#0P*Vpn&
z(D#1<*EFr?@45)gG@>@42j}N)gQv$I%_<Q;@55?EUcH(*9}O?Up0^FVD_(*z@wJ#(
zRoKh^EhlnECN8_<*D7k`3uEE!H}m^x1dU#H()K+62KNuIe<u7XWqW?ROi_3{06qHO
zUpW!XxRwBf3ad@oUkC@msgw#}Ka2-(VFglikcJU6!)-xSf4HWbQm-ChlKOKKy1D)O
zqji*YPTtQgWvT>eAB=z0`SMy@ZrlE?pOp5-u{uhzhH}%lGSro%@rNn*+ne4td*6$g
z9l789ZtRYKU$*?Aj+Xb=Z|w7!m2vx|F63nU*T;>yApkdE_@G?%5o${E58fx84&Mh-
zzxVR66F0o67czemL|Q-NI#LG=CP&`o-wD0<Ze}^>^ESF&`<i?6@t6PI|Mspm==t`@
zh_Y?sd57bXbsdGnuRC4bBz*2t3{r>hzvtgBn6@FS9{VrFuBqNQ6{9buVEX9MP!Q|-
zXHBnxN4q~)-ZY<h{p9hG853ikT~}7e{<Hja3Tx<HCuNZY0}n~ANhY}>Ga|<+nDa6#
zYzEv`Z9Yw&2MS<!p**|*2+&dh<bisKB?N$R00<04X{{zOyuPNH54YCzG2w~^&_zmq
z|Nl8r{q9R<@$K;_`@8keiq+hk{GQ#t{=7^tXr$8q-i?=6G`@uWE&Fl8%-!r*;NK%!
zjbkN|k?EhF#i6R|T<RRII^6%iCz@S6+La37>>eGE{A7|kI1(|i<lJ&Jb@yxI)k6<%
z&pt}}`E~Zd?~%^bEv;kr6Kfx>EK>MHv@e@As>fbsL#yAsXuUO9Zg^_$#lw4_Un`5#
ze*LcziV}4;fUCO1zch&|dsyZ4sN?&G&bTY}Z{3x+(tlF#mF%oidG)6t6rIN&1E}W|
zx&FK%RHisUZboW!M3u|Ws{UN(C<#94`u|U~L1XpfV+{}hbdFDcl)kyTH&%4wzbWge
zSKo0`ge@*Q>obJ<DRt2K*4aX-rFP{ChJ;txd^*z2Y{ZHK6}u+ELT)>w+^&n`wQMZ;
z@V+y!{tRnSJ0nN^X>?zn1X%d(8>@GgK~sh@CQv8m|DfTEg%p*W^}g|$2`{C{NU-yT
zG%^ox0JQqq&vhC(<p*@Y5hubod7?|bOQHCFmqjfZynd89<l2?^$?(rtlOjB93^I1#
z90pL^i&zi0a-<+(2-=-Ti-MKB)>Xol1p=h+?)CV`i}zj?^=<{{QIaz>zBbk?s1N9E
zwHrGdUd~*~xa2*~A;QZ7!7e@*rp*E`mxo3v-oUr--3u>jZ~qm3b6BN$_3i`21{328
zxCk<B$ew96nHmuozzc71xSHbvvCStV$j_}(aTQq&)dt_z9<2`^Eep4){Q2744b=MO
zBzO$r3><6nQNfO^LO!YS)!Mjd_2MdQEjhVy*SaK*L~ab2{9A@O-=Qemn1Nu5F33gd
z{S_v!0CdO-D1Kg!zrR>~yYMk`l5f!LbIZ?HV%G~{GMm_<0_%;i4NZ?JsGhR|EeYcF
z{7gP%MEa?`ShqF)^38R;kmxBT(<otL=2YPGfuHZg8oui!FO?(lR(TlJw;IlZ{rRSU
z+mZNM@MBKj-IqF7a&(FgeIK5%;xygbS;&3!-huFKF~D~uO$Aa{k+`>6U<}66UoIVa
z04c#w?uZK!ZtT5TF7$u8BxR8|r1N)GVlW1#l+Vh1E1ksBS0_9TCott{{bM@chgI+F
zZ4Qr|HTpSfr~7Y9rit?J*Hq}8f04y!e*F8*X1?}}T_`)Vzq`_KXaCRYgCF~U*N1dD
zdt2|$aQ^LlzQfty`~8E%`FIGCZ={%ROYWsU%*g}<7hpk3I7J>ye<iV%3ZC0!H;q5D
zetMY%zyc=qoHA&TkLW!~relsqljN5rBux4P1mz0Bva8*_msnU~9s7BK-wQ<K@#qZW
z_B0sB-i+*XFgW%)&8C1CDe1dKVSvI0jUzyXMxBR^;aG7(W_NySm!hIq%WLb_Mj55c
z`pSFeipR#wZAEVk8DYeSkBTkv`sUVI?Zbu?%xe2X^;~iOX0`{u_T}r^*NdlbFs(ak
z4&)+xW#1v?2~94!I)B2EM@EMg6@6G1bFNy+GeNc{>dzQk8wFz6B?8!-(k2mG!qQs8
z!}%R-1^SV<PaQ(Z7opUJG=R570w$XXfS}hVT16k0uBQo~T3?hF8uOb}@?^z^X(&FA
zTsAa+^ZfJ;GIg$A(5&Z+?bhC)9CxWt-Ag~)6TkuY;f3?d8&`9oL~>6_Cdwg%)0xt`
zfNKS$nbU-f92ThT;QR-Cy}vLm@OzS|xthC#fMIfWW)-guw_Mnlb>2--QOv24u$^pH
zwdan*&NdRjzHW40fB1L5&uYDG1u?;GMn@@jN5TF)Bk}_kXKMXk?!^e_maMw*nrB!8
zMk?2MtA+B_)a>#{oD9qhtkv3@JipbxUAy$ga+9C=rCo#NnWiWag`uOW#-tRFD>eLT
z>$S;Vmrh-w3kQdh^)@ku8h9;KT4tZYbl@-(hARwowIw(Pw3yZR$VFk($s&KH2E_VX
z!aOyPa^}7IaFgg#W0>Cn?%lJCChg#wX79Dj?;c<7xXZKA><m6ImCBJw#9aQMOwL6#
z0u<0C!b9HYbA|S_b_S{P5ygBP^pdfo8s43f?@;=|Z*)scnVai9c2{uV4t*$mv}=tp
z;a?sSoc6#Gbed#RDq0_+Bw|?@3H16Se_JRe>{bt+P}4|%+CpmTnYJ@mqM!KJG=W{5
zWhN`SvHuxBA0KqpCCR3+X|3;`NZ07u&0i7S9e?M>_oc*1u_&`+t6%Z3uz(Bq@16#)
zwX*q6)>`-XB#tgvKtSCm5@S5c+C_Qb7_L{MzbGZ$FW%NlLWl(jofi7!$@4yjAVv`M
z;q8XEtw4{TOA%|y|B`%y_io(nk)<1##~OksYo!DiJarGe<~;h0`1WPQk7d<9Fe0L^
z@4n|clZiJ`Fz(NkTH6pk>G5rV)15|!*Kj3JwrsUBOrd{##^^<zmGC)OoxE`PghKx-
zPWMlO$-fnf9QpOZ`JXnF*)Q}x^U>zh@i!0tFZ24JcD4!Sw4zu>0{Ml6)^pYIOc~%k
z)F0_M?`N@(5EN2SM4!vid2+F^=NY%AO(lCs@3wrdE$eWVpbAAgXkMtVrw<1;AF2~@
z%dJAzVh&|>nB8KE363AQFVkZ3<lzBU%+~||?X6+fFNU6Z*z?fx@V5ao(cbi@i*<$Y
zFTd_s%NA;kenP)|OK(*M3yVlHL{`=phz7(w0X~1RgB(N}-r|)6>O}n_N}JM`435d_
zp23Kr`C2(`F;}k4EFh&b2M@&lq_^&U!ln)l3yS4lwhfjE1d%WAxlT8>lq>kMh?f2+
zs`vH6LqRINu7yZy-mx|9Gh)LkY5GE$GFLD^;EKk$EzwYkv?gdcqo-U0PRLXikNXl)
z5mFR#_rT{Di~`XGcdw+D4*j7sR!QlLU7ieyd9TOau!(=zgmH(ouKn_UwcCZF=UhH@
zh_>}zpS>%3=2ZP#NX-@N3772-wJ<Fi+CPGhZt07sa}&__DW7jXLCo?2TeYf>zqq0i
zp9IOj0wXUNT>uy6@ldBPcV13AgY%2u??dFQJmVOfoV_K^6K69`lt}<70A~HQQmM&y
z+H+{ZW<-5WqAo?6IT@&pdT<)tc9EwBv%AjyAoN#Hw6#=n=2D<e;hDc3F7Hkfo*2`{
z(+!|!X&l?bMRr)Wax^qX!xACvzYJgHak>l-5JSLFfx6&yJsB0}zHY=Tva8cj+zIxn
z4{%--JwVizA%vyx;^}grG-wPR#G-RrFNg%BfqUq`16}_D4CH)Tqas5X8z@TSJ!&fA
ziHC;M1Ks8w??i`>R}0P83Xv0(eGD{#AWX61$x|V+4)=wbpFPIbMbDVR-8V%&G6e&B
zc%j&nJXpR#96Web{7HjUBso-<6Ofc`XI}6iBqWgu24%&qgp^Ftz7dkM?BJJ49)iPg
zzZKErNT3uWbzvLMWOEH*!PsaR_OmFR5_oeVoBI2FqofdI0ln+b7mSf=U?5&Gj~+J2
zh6kivPvU~I5&u!(x55Hj)pBU%=eteeS<yKvr8)oEUJ%(3%2wmgbI}7~_*v_R`)mbd
z?~7JcV<uhHRExB8=!CDlP7@Mn8|on&Pnuk)@Gkr`WXxs^4{sS2haV~68xums8s5Rj
zCACHCgXnuxXQWq9yJXtVaDi1q0q{T@^(^Zv?XbXSs!*}$JC_6mD4#PbxZthF@y}mb
zfhV^rdMLpQN5yqGO#k2A*qUfYbREJ*72Y-~p4aNc92GBMAP5ijEMtnup|Kjziarfv
z_3UF+Op7yIi$T%FA44ypuJaz)6+I}Uc6%uP@MriTtnDuZkQ|)A0R)&X=-pPHh$P|2
zDWC8f;SjQCzAD;bz~i_He7u^;i#W?PfE(9Qp|rC+0epcy=HJ+&6V=iYTVe&KAw^-b
z!fjcsBeLDaNk^AFF*g+ez@Udsy~I{hlR<=6915&CDul?5nkRu;d9po@iMSrEs}qb0
zU`}TGzEqR?!m_WUsyq#c-?aB=POgNEU5?nj{30v!G~r6e7tzl5Det@^&#J(?c154~
zz#lEcdpZ8XFDD$okBU!Gh2Ld~_ns6008vz}_nJ4f^^;dDUUV9Kc;Y0@jg4MWIu4<w
z@{ZZqtHX_cT?GyM3C$~(j*HutN~3nf5CYX`AGqXyXNoclXD5!;`6#>w9p@wPZm~p{
zx_M;vtCqrrKktfud054Z<&m}%b&TgpoAePLv-#Fd{Lqbs^B}yEVC=xufo|+mC4?6e
zz&X^aScrLL)-K+xUAb8$6OgVafHd^2bB~BUrmAHzQpa19jvUK9!ls(eJJtX|MXczY
zR~ay>Vu%DzM2qN+D|_7!I%uoX3rH8&RY188vKrhSEXa+VMg^Qm3xm@z+)K~2Pn^CA
zZP(<$NslYLS>}@=@m@*te{8RZTks)-q6)(mu{We$k5+`h0((+;1N8o?!Mj#O!{Aq+
zyk(Xq@GP-yp6|k6eZI*7nozE}P;Ap{WXd%Q_>HfkjnnW~4NcIoraJ;vbHj(87W4N^
z#+m6m*0avIvGWV0fQ@y&3wU?%7;dXvbjXD_Vx8yn5omm|XzMzPfoc35TC_YJdTdKD
zfUC3r6kQo@fz+H{I(M6^0UrS0p_S33N5q7O3z0r>K}|USUpXm(>Iwlb8&)*@q4-}e
zf6GO1tJ}IX5aT0p(gaurLPW5Kcbz4=p{E1y5w-*gJUt0hv_NsW)Ci9MZ5=`32t04Q
zH1N<L`3w$tcIWK2X4=Kyi(uV5@Zlb^xefKLO)TJ^*<VqM=lA#!cPB>RZdckp9<}Ru
z-BrDESM%sSN^`qcvzo5lJ;M(-L!TY;lFT@0oN*>OBtZta16Y6nQ60hZ>unZ+`l40p
z=xCPN%;g6>`sKe0Q$g^vxBD=>t_HvKMR{FYc3b0f)sjm7P|Lqn6n0jmM8NZ;lgoD>
zihrx&vd9hLN!PY24aIL%sUo`Uj2IJAzEX&C_`^))|BtBqjB285|3Ez?Ap{7JP(x4X
zy>}@I9i@wOHS{h;qzO_IlF+LP2uhbODgq+<(3^-65do1VRY3t!K#?5Y|2k)#Z}Tm)
z_RN~>eeZi;zd$IC>8*>fV*&JO5$g|h>B%2Nbr0rckb2`co#t<d?r$Zh_{9JIbRomL
zsX^+G`PrWSWqZbqe0#5(ju!SJ@!kst<o#|U?oBwGIEqv7E+c<>FmpTna93j<%h1;&
zI*}|8)6cn$)|AO-_&v#S0OZ<16e^x2ibSwv`y&2+;&8S{T<yVxcA2u6bIkBrGkj}B
z+(hsQR0z6st&7ob9xw|;qQ#$yULhcJbJ@Pi`rGnI9V19*GZX}e)L$&~h%=&j(ncgD
z``Ru~vOTMo81kH4Ds9*LQ&=A<uaDJkfR(EN{J2lva^U<pX0wi7ahyXr9%=1vziHmT
zAKA|gt7UsfiTR%c4lVxcQ*a&<V9Suy^8~3Z-jxfzmfO$f!Aw%dxSRNDVY+1LM#^PN
z(7{3x?OfhVuxuJ0#sRh`QyFu^VD`7!jS&o;glk;+BN_7}Qb=fyz-YmIR%@}`<tb%R
z45Kcxjrub*HCV{{3rlM&(_=WZ%*Qb`57?8^*J|pX<DNwVkKu1}2TogA?_4;SWnSAJ
z%<p;og7V#Q`S6=9s$(OQCXzMCQ-su}t<Bh%(1~E7#xVFGFtJiv@Ohp+4>7R`pMboO
zi`Zp|C`DG6Ge1ITHp0`^;@=*XzWvkv_GJF;>B(C_kP6bHLM~IG2~=1amFXoFYF7-g
zgM{P`WsXrfFTe9E2yMf&Ok%Y&$}2@uSR3*593k(-LgWug9K7z6;>pIBL=XuYnPAGe
zjNbc1+V(JRnW}b~eRPlhnNG7tEIhfD-lLomQNU(Y`riEC@O<Xva^aNZvhX>sj$k=N
zKSIMg;RE;lC7j2QvlTl9ZSzVUdssXCmnwBRVLIpQe^9?z$+AlqvZndypacij!7U`%
z!!%n-tsDL^zL}i}*G&vzAMSpYu!CSaW=jBKM7{~6++YE>vu&f#r|Qk>ys6*|o)udT
z4YHbLP3EKP@w(`AW6TaQlXS)g&+%hM$}DCC!yhJR&4DYRyGtDJ@)JCE1Uy<9+t6?}
z0k$Ier=EmYDlgfYCG&da5gqLCY=AL7B|Y2rHHN|rQqCQ|{F&wD5L;)=qpZ0vJ^cc-
z2=&b=#Gcap^qbi^bq=<S*@tI+WMM2b)P>jW4j<7f3>D4;P77<zb9Z>VN;4M06~zAr
z5eK}0<@RFF=jk5RNl}ma4?CCYrAU~kOw2flTlttm;8JSy=LgQQISq@wpRJz51n5w}
z0fO~ouGVsEHR{$JKT|S$-Gan&@3fWgf(D!AfFp#CyP|ug@Xg}e>&0@t%SUCGp>zx%
zmtmCFFS@T*R9>xGpRU>pt=a3ZIb2zDytU?hf6evPn)|}qmD4r6(7LDoy7!fJ-&^bc
z6Z+DE!hvXpwql;3`|BV3m(<_2ez5XA4`JcwfsQ7Lw?sDiAd4be^eTclGBy@@X$Kb)
z+id6`v(d-#MCot7f8Wc+n<wA0#H%3eT7D6)T+8}NBI*OwqZQVRo{e6v%h%WA)8}Z+
zUViI~>fy9(iI#2(<_W+5wcysb%iLS1S%G-WheYm<-%Z>}t;|!cEQ3l+RCy&0mQ`%_
zH-FXbw=M7MzAtL~F%76;?Xmu%0czdZT;81Air-fd(vPXPG{jG+FnxA`&e_v{eaT8U
z2Dwc05lsEYY?HvI)3RePm9Y)WIxzjU`PO$o!uve)1=Qo`O)Q_L%|g-zEmNo*tsLCP
z*i?5UgAzNNElGew^a_7WFXVy7`mI@5B62Hhk<BYzkG=!So<+hjM<l_X(wsBgla(%~
z6?;UF-{z~w{HLnR#zD~AY2ASfOfq*?!3WeB^8i@v?&rVB0&l{9x+@col}72Kx4=%{
z^m3G~<T((>z0*5tFJIqTMr0ap2#74Rnch2VDdUf6^yO1X^M3YA`{z$(<wJ(63)XX%
z+dUY0SNi;$Y?jsZM*&sN7<%kuw)oU!Zt3?Wm-izVb*-*#*&1(5f6laTc7CCQ`2Fz5
z@e?zLdm^L_O46GTc~_OI*}8HQkv<X!tyZDZF`wwDlRk>{QjKaqnz)RCb2KVE#ugF)
zFt%Okb9yxUFy{~B>(+1j?1-6P!y%>~n_I7LC(gZAIZGk9?(y{6b#)~gNC%g=n<=?E
z{6hhpNN&9PbTMb~Gvv&IX4Ahx4-~WA&VA-=2MMOaFArdLd!kX!A;8&9BLO-%6k)!*
zWJqEW)F-0sR*ciR<gW}A*?lq17Sy{1;k92i&leYDh2$!&VM#I<*d3&)tCl6|AqxY=
z*G0}M5%KKd=GB>10QuD>=j>BhnNDz$#)%7J%c0>?^OeDpOWzz@7!vkNkDvKDJ@I*S
z-{hX-j%$0!=U1uxPT$?TZtN@!-gEkK<yFGJQ+fgCU3_0Ei?C^_^PcBWmY@OYtmD*s
z?6&;Xp;DKhz7u77iBLh;1OLeys|TiKuD=4On=k)I5_J0=Jok(ivN%-cc6e=pP<1|4
z=eJC;PJsDu$d!_ZZ}Y>@+J7q7VoOO``Iv}Jfv!lishf!#M}K7^cGp-cIZ?0q)R!7t
zU2X~s-x4haULA~``46vd&Q}wSEwocu)1de4yxA>^5>5jkdGv_^u>0{V;pRA~;0c4_
zPmMyD9$Q|@mJw@oMqq9N{K*R1?<8PTI5Dud9v18xKZf==$uq5bP{=G=Oej1)U+v^B
z24Umz3h*yYq=x&OC#LI07)w{UTI-fI3`CrtcU)O1P29(A{wJd0B2ldJdQ~DRQLQ)a
z70`$C&d?Im4y*7yEmp3&eI6_(^p9H?Dv>AmPLWmppsJcyp~k1&f-$5ibK1#EUY0h-
zeam2cX>t9<`v-}j&dPF`mogGb@k>1xJnC%Pp$>%XJv08S5z!DXn+oY+VRS0k0>Se<
zw@*0H`Pqn5ViMP#8LPWlGLoy+fl;$_h~voz92rue3V=mr0DURI{tNojq01`zE>vax
zK@j}>X8Bp%2lUky1RX12>B&f>7{@KI7rS#$_T_nWYfEs9vARg)0(Hk5MNvj6UcyRX
zXNE}vcZK*JSA1_v1x2!D=3Ibu!pwY#$)sA+d9(XF8Br(Fl7%)G9b$(8YSM<4bYN5c
zeBxMr)usEZ2vbzlNwHaxN4f$}1)h&-T^cAnsi74UP6IZ|l_vMvf*R#tn0`bX<@XhP
zz?o``<yo0N4JO_RuiJhKHoqBi=V9ax%;WQY`?D{+f=vI@pE=q14>;prDIxnAVBEbH
zDKmpO&)%pSbL*3zuWfRa>k4dUJ;b>c4>4=q*ITX(l>k!k9;VO(S>L<qhv5Y(L41x<
zl9uU=6895IkIx-hUcU+p&nMX^9DP80*zt(SG4?!=ow(V~ZF8>TgM`Q=_F+&2D{mu<
ztN*C_{XMUWnoqJ)!DKjL1iv91(`H^OK=`f=NwNmT45KgVen6lOs=CISf}9-EhCUTW
zYd+r2!o>2AhURx*r|OmkX)rQ3fN$;hxj++7=`;gMm-FwzSD6PphaZBL(t_)oU|VAs
zUz`H9m)e-Q|MU{Z#wsK<Jv=dEGi>OQa*|4>sPMPCOwKwaK)y7{cYMT0f7hq}_8Kug
zyI>`tWVsTr1!5mQDijw`rj%G<1R5_8z#;5hIwNBjbN#uRye~aXvFtNRMlhq@AusFy
zfnzr6`z|iLQ}2kC5hi6=+Vs`J8_kW9UA$fHe0|^X823bN+1Ymeph_ZCU;z1-ZgBax
zgW+w5UhcoML$TFi4|N#>Ihh-bD7&rY|LB$kjyF?Z*iY*GTlErHMw@Bf;$^+BU3;13
zX}bC?ztI<$(+lOomlcXFO7QqEd>?58rh}e0vL5md@Si4`aaG<Z*nYWn;r%zpriqy*
zqs}__5ewskRwGEn$rm>njtR|kX~ll>lQN9NPii&vxRRr0-!)FD0F}q+;Nl=5nwA^a
z1@mseTvYh<=q)y7FDDjOeL0N!R`}ALs>D_t`7brM-L)<wabA>s7suAGwP7qJ5qXjQ
z*Lh}9b369A167Tu1LNf;BvFff2|f;9v9ta}wGZ1|_dV%x@OMlE-TsS@kJ#kl`@{MR
z*MpO(Z0CSvgsy<s<-B?j-()T+)ZVMvpDJxF5Rmn3^6kTykBjY69mjJh!{yPxENg(C
zTBR~FYha(TP3V&r(JNrVL=i{Y`8g~bVSw<YiO{bLe}X3T^q*@Vs8K*_ryHz&srZZa
z^fuhfO^m!CIX30aNq3LGcZi4?GUDAwXn%U6n*n=JYR1KCNYrQ@LEau<yv6iftP%y$
zj#?_o_}x1)@Yo|8+H1;B`j(Z5PKz5=PR;LX&pK~D#KE@5z<c9KrXjSjqjRsB?`4W@
zu3A{>j}LGze$V=buw_J<KSXR7@AQ(<m?aW5V0Qo|>8#Q@^II5+Y$Kp2j?QX-vObN9
z_`5Mj&-4pJ!zm`Zp6qvL1|&_x(=T;<a(B!ODw4u8eRRF}KF$nj4uxmm==KsioEbKN
zM&zdIdW-PPjtq(#@h#ILOtQ6}idgzmxJBMkKKl-`WN#LkoUMBb^u3v{)e*w<QYcr6
z5tys2s-`Lx%%*~|7cNCTbz~2>3UXHkZs>=uG}ywUP}PF{MOPByQph^*V>!pSY~xi|
z7<JsLczbQ9tvTNyjAI(?+>!?k{+Q*NnuCQdyOE_~+yC1&2>Rcyftn%7$yn2-TH{%U
zZF3+ARXI_MhiT~EVDsoyoQTN_wT7KHTRe4@t)6*%mo=Zwt2HBuITo56l%H$re+@TS
zzG*}{%(YYTMvXeYPdRUv7ou8S_IGpN(LXPz)UKLmbi(~9i#>CU<V~Td9&-WH4Yt75
z;)UWi%~y+e6=?s)575P(L-skFP_K_B#*UoZ;771GB&R_~8jPf*a(^!dx|B$3H5Hf%
z%ng6^P7<FqaNXS--s%i_&Rh`+r0)&c!oO4=!`faWU*?{teVKGkqo0<sXY_)vFnPBQ
z=<2S0`~OP%O@G*$U5#1xeh#a)-OQ~u(EEDvQ5Sm7&it#&0E^p!*}1+;;hi&w=M!$C
z#iJ*ps*6^H_j+163)@()Iwg=bmqUS}D{wjMfzi0v?YLKOx`6JR!o;4D<&6EBXN@<7
zGlxe^50~dibsh#!%3wDS!>1`Rw}h`gy{TVUAx7vBOFoW)eqK!Ru+(!eWV=wjeZ#Xc
zwuhz%nC_EFljXCUFWV&YtEtNCrwANX1aZ@!q`HZxcMBtMOYa-YZQBx!Q3U>ed?(I#
z;qQH|zKdTkjfq6%!M#>fxWn8>gyTH2Lf`~WZwU6Sq9CkU#FMK{DO>3*SHLUvQW(!K
zFM~tEe?Tk5brXC>KH_Jffvu^o{i$9`q)2L87M0$nUYE29w&{JA?k}0>%)nGYL7b40
z#t<L0Xkr|tIXqA9y<Xc{x;URk4mu|yf~%tuSBh;<z!J5nXh<>S9|A&1B5~Lite3PG
zZV3n9D<?^j;%7)?CLkCP`IifkraW*CBaJ6BXxnywuz)FzF<b>F$uB`^Tq>0K8A;pN
zj<ELvL_AldD&_o(I-4<uGt4@1h6qqo6f1-^+S(P<`Xgo-JP<Dx13IQ-^<r)gWZ25U
z<6sK5`SFP2v=|b7#WPCJfa0t%A-A4#MBt2gBrKPa76cm<VPp}-%w04oY2_l!u!Z^)
zA3D?XF!KEL65&zC78Hox`O-)_(y$rjHQZ;o3?x~J4*vJIYR|3zYFOTL?b1g$a*aoR
zEfe4xmKOyhS=Xh8!zxZLa(wZJcvJ|A?6Nz<k|KNa7Jri8OM}{8n|fdwYIR_H5lBCL
zQPbnRP&E=B#!%4+(+YzIQCcEVjsFZ^xHrI*%qzt6DRGfV8pRuiBEkZ9$?>+WF567c
ztMc!tGTxhQBrs{@ilu$1?03TPlm39j=15A;xi>4*WXJgW?irqqF1-s><%AsvRN<vk
zj-E>y=Yr(@877#LLht30#~6Y}p5r4)TXadjpB`!*<;Ns}jqQ~@?ZD<o>=;gpf007E
zOKxm#c4BMEWnv{(m6Sl~cUzI#22x+E!t|%0N=h)-p4aJEh}9%iC7AJHCdo6Nf<4Or
zmj;to8u#ojo4!stKf^Y0akR;q*QxtuS(Bn%iPn7AIP6IZSQTP3^N_2WpC?cI;$v{-
zKKYu?tD|&=L|gp{U6@B0Qd^5@F8KTzoe3PZ(GpRq4}0i&l<SKxT6w$oIK(l4&hcN9
zqS)<nnl0TXY@$LB7~+(OkEN`yC4mhMA#S_m#93&f{{-Pk<64tsqQAnq^9%%AXksV%
z!fQ3ZQi|d(#2E!;8K1DLHcjk=D)Z~uY=P5`-U11*tauogWg&GSUCzRybgB0-!h%6C
zZP|nV;vN*B(Ekf7xC$g0QP~=vq%A*3OP5k)GGA65kwG;>57Qp_V-b#0g|+iJ`dUOh
zHRt9C*!G<qN*mTBM+yDJpi<sR@PDXzLdN>@Sf07LRAOQbG-`(I2~?VQrjSAQ1SP1J
zF3f}oE#i0@fvqJtcUZJhWXm;aAKWPAugO8>ycwv}e_C>su!~xsM^sW_&EsTz8?}Kd
z&(g?te;>idK4q{2`@526-S@oQGY>E)ZxvrmOcL^l=dKYQN;}ekx$q}C-{aT5hfAk7
zzS*&quU&ndZnDeie)Q62uY$0PyauHEAh`cDsJR`GZLw{-VaRK{<V!toB9)%$0<WCZ
zDc)2wf-U>KDL$Th9fFi~(l|wANg>7`GX|k*J%gR!EhLp%^7LM$*xHh9aTeIA2HPo5
zBc=kec61u`dfD_G2nd;BNR&!3T53u}-?{H@-}6a4r4ID(D7Ei8<^GA4f^EUptQ6`W
z*>ObB^1L|z;ET&8WLkojD8pVSp^jiP`*7+tIKY(>HO64++yEp&>X$%CRRog}0r{R>
zBs?kW_G?0?c;*?c7n4h{1;-s-$a02~m;jY>a=a7+@eOQnoU9uJs}OgsN~MexQp)Fa
zW6ILsZfkh_9H)G;Y)BX^yTn8E*Zi6yVD)~wwcJ*OI>zJjim6u%mnrn;dEVlQnzM7Z
z<!)hU-q8Izu+1n^`>4=giPCK6NU-hoLp%Q?7@TNRZeUHNJ3(=~g@*@jiNHKC!)L=w
zCe%s#s#9>r>V(de&^c^YYf79ad)FT4mwt+3(b+yRX{wA89s<jrC+DoXHc+Tv<<b}h
z`DLGfre(FJ;&Z{vbA<P237miK0_ISlE+vbp`JO-Fn-WDNmqf2k9H{DxKeFO}36hR^
z2T&edg`IgV^#8C7YPQ{X?7?RqW6Jh>U<UN2l5CD9hWC`FF#?gh7UyzP)RKsy+L{^w
z;Qr#A>xFV3_6kM2vZH_G<K{)nzN;pd(j;n60xDI1iDYSbk#dykxbzxW0;z3Fgw%~=
zl^{4JBG&eDnm>vD7)(YlzftwzboAH|5mEOy^0y^mA}Cn%iYI?RH@tL>(ssy^nv$6;
z>|yrIqCSH<>e$28zAIBAXWAmMi}yC|!X`;~kI5mepnM|5D)lO11_S_?PPh1IZq*FB
zxlF6^4%<%}FXJguNy92i6t$(2)R`RJHnj&m^fmzuDkt<dqff1OIVtn>KGj}4kG}xU
z)8yO<!x9Fwe8;pUzUKqbn6SL?)<)-xri5ykQ5Z4`+nc((x&|`0KU!@`Yb*ay>v+Wz
z=k_U@h3z>wgFpVca|<lxsiqfI8VDnd|2td1sTSCRzmJs`3wV-`QWI=%AAM$!mP%Ri
zzEm~;B?tuxi0iN_A%`8&)4fbd8e<5dfX$q9FI*(}<W9#>ob@UhM7b!Pkmo=TQ4uq)
za(45~8&^d9uK(61z{v44_9QgO<A@`4lW+;!oE}Cp@@}_ZfRYz-Xj2U^^c-2&g+iIG
zPSc=Becq(sb0p%6N+x}(sg~63aZyvms&qisQHoIy#O#Rh<VK5D3~Qe;lROGy7Djx)
zoM!VrRV@r04)RLdOw*_Xi-uU%+7dedD10Kqs(-6zVZk~xU77x1^AU)-7UTgdquP>9
z0G2DCLV&3B)?eFV$a>B`*4ws_c@&$v+q00-Q$LmjR=J!TB&D6ROAIluh&LxkUjNoR
zq-@vhGceD{IGL$5lX`QPbMhxeLV|p$^>SZ(Fki+4_-BgGEtTfaa3yD=^HO<EIq@of
z^0jFQe*wYZXvxLpQ#!SA>dww=?atg;pV-jO{PfP}^&Q&6Sr$3;`x5u}Wr=GgBR<{f
zj~I2nGs$23uY7IR6mndYcZi~IsUvQ+ll)N7i*>>Ix!rHD0lE0CPoUXU)Q@#i$Y=JI
zzJia>@9bp!ENqm%-MlH`Bf#*;l=t%oxNv4UKRjF7(&?a`vU(-ELsSa%@y9G{pT`k>
zme+3WJ0?mS(e{X*Wt^;9l9oT4DSC@BHe^tgOa2qbF2yzgp?S?EQ$o2uXl`BabUOXv
z9z%U6C^!sx((>pdNqRA(e6==6NO*6+G`QW-iE<?Ssr^OThw;XdnwwPVMA9y0hUi+P
zZ)^??k%DT}sYrdv)LRbD>Cs!MZ-xg|h@9>*h|JLbecj*9O;a<-`Ee`MMw__h^|2`_
zd}+5-vVvk$mFkemP-^W|_bT(5wS%$hs71y(f9bC(p)ey_D0Tye3;j56sv*8c`tmj1
zT}P~a^lX!DokV${*$owEOd9)aDSj$_$jW@tDe^h%Pd2j~qNcxgYj?sgc&+WE>zKiu
zJzl5Jw8c{-6|j|-9r<4tc8z&71g_rb^1b$`=;x_v@Zz(O-~h0;7SXC_H(~dEQ<Aw)
zE-9AEb`ATDviUSV$wm9rFD>HdKmDI5=^x%7k-zSzD>(g{tF7+zl`;D-?av)`zt($Y
zBfRMc4>l`U7r0o=bFAW{qh}O$>nYm)|Ank-i_$XZm?-h|mj1-ByD&v~Ql~!U;V6TM
ztsDzmlhZ@SJewFr$)6k#%40irB5U?;j%YXa+|b(+{$WV5E<vix?DwerwlF*@u-U$^
z`MokKX7T%CLZ^R=bHu}2PxM9Yr0X1D%0jGQ7L7+~kqmKNce<kzO@3<}&rhdbMH@-?
z5DrfmvJ>|<E5y=)q*6wbB0`vZ`9%tL_d#@KSI13Jq5Y-@6v5zf29=}Cp1%XfKj&YO
z{uLp(Qb@NxMqQNdNZWjxnp@<|e*3M!@$ZSh*(02<$RV#ae-thTH(Ko(zS;3|&TSbb
zdm?O`kG?Ei3{FRhxy>_#^i;XE``kC%y&)e*n=nZ8F|hDs3v)O9J;e$(njxCPAhrKx
z96hE#lWhWwy2m#X%;)0CxxcpVW<DQ0-PyR6mh|mA18rB6f{QTQ(@fmXAz(MZ|Ma8%
zj;0-wX-9Wy#}8?LI%t1~X(u0P|E@AOF;D;y1G}96F1nA%#3K~>9)|3vuuIxE`6HLP
zHE%SzyQ7Bf#N^$uU5__MPy^XaXBAA|`s%SF6~D=*fS(c*rJNZ+Zsku&YPlhqT|Ur3
zTqNk@9arYoHV)ibhEh)#G|TUu5{SX-whotnQ{ql`{@@mAS}Tz@MS6W*b;i|<Jk8YT
zTwUf|7WQwn#_hM_Qcns4^8r(j(k!i>%q4Vs{z!RsB;T*(&;Lr8$$v9h3PI)O<rDg8
zL&%x>jg9-*fSnA@<6l^}JIZfs$-}-)uTy@zlYAb}zq+Awo%ZQ7zsCOR*z36US@#?7
zHtus&4t1UA{N6Tjs%McHe{pD>`Y_Pq;q)RGV6s;C#@kuO)|s{tAUrN3P^V$Cs&(<g
z>sqm((YztoB4=Z$nD-`UxdE8lS(u1C?@Ya!-fQNN`c-hs*@+|WXqi}j!jTin2hE*R
zzPt0&25H)xTr647Vsb%$Hwjh5cSqfe10x&gG3Y}wpZ;QC0F4#Rw_v|B=kKE|{RJm3
zqb+`$5U!b%nq3CNiUeL>XEURj3|8Ec5M)>TfcX!9-AajEB$dmVwHcAA+(lh6$B~yJ
z#+A2LFNxbF)S0APg`BA7V0YA<ZAFLO`>j-;otdMekExzp80aNW>4$eG^YgLpYW8r=
zF=s;vjwHgDR2c#Mk!jMn@oSyrJJwayZ0BPU)b#RCgT2o&T7=APyU#hKL(B9U^RZ&(
zBKthFimp|<i#)hcL>JbZg<F6}(yO)AZ_Yi^N>FC?t@%(rs4@tfdade;;LJ>a+RT@v
z{&eR{CT@ANQSm>}ZM*DFnw$~h#dj$1sC!N4L<u($pw*0H2d9?c#9bMbhXvUNE(06k
zXR*eT?2qBT$<9xvxoD=34|8t1GI6G3w|e%^>wuC$emz@o(Q$2Bm~5_6&@(SfrPIlc
z$LH;}o=z*8J`bPO=^~0`YAlpUj4SP;f~hj@*DsH|(xjT`HG_Bw8I?4-KDBv)>sp!(
z^x?2VC+JR>^L)Z#*LC12<A4ibzx4d<xR<wxEmEBA*NVRKHGv*(ujT?$oc9dM=5^x<
zN0O=sUqQ}v7QU7R1$yUSwaCdrC{{BoewCxZ>{9SHn~CMAr`A=N8k6r0`rTBYk8QV3
z8u^@@sMmRHZdG2VbI#QLr3tb%;k$ua8Ku$?C8VG)&U8Iv_<i}QB3fbWEg&}jG(D|}
zIBy1gf&g#1Y2ZA)HkH%Wsv&Hj%AK#$-ijYbxb2q8@5DmDtc-a>AKClL5?jGZpa7EV
z?_8)_b??<pG#X~m)^R9CN^nsr9yhG(TQeWmZiMydche;${Ssl%wjJ`3Kr&);C0tSb
z6mgaJ48x2fVR@aP%D`nUuK`;$M6~p)>(jmzqL1*$IzyLoyGKEmW9aD_Cqseo;+Re!
z^!Aa{%i6l3Z*5`d_o`!TyiR4>_Q6?E?)Iea+ibG_^4>l_$=E(z;oZS)tNTauAy9jA
zZfYOvgQpN&Hl__AddSn#-o$S^zY1z=k~1kM{x@-*Wf3XHhg5^1H<Nj7E#3+T^O|Yl
zwOMJ`@O#<q#PNA(L`T)C)m`4XHF<&s_gcVN2{SiEsVSMo$CV%`+XdCA{H=w;S)kKK
z%zy!-`W`_La>jkoU%;XZpf0QQq9}Zuc2(;6$wGg%%uXR36rcHim0GEhod_p{R;jY^
zeWei%3F+}<!`j%gdS5$4gD!!+ts>0ZNH42H{HQQA{)UloafDADU`#;2g%$I!?rH~E
z(z^umGOSIfOajgrfk56RPC~^U<G3g2aN8PV22d}73j*KVH`{^lGdn3vR+!$f_lhiT
zl&ANpkNUP|R~5(M1`%b|-!jt1qnMM&?Ks{vh}xFl&hdoxA(EAd=((_7V3kJTHttM`
z2O(a_*G2qatd~P!F>oX;e5ML$4m~psafUYgn#fwEs$@n48_GJNi9U77ZxiqYc;IIB
zML7;OLjgxb8ieSx@Qy+5doOA(S0*rA#cXrXF0Q$TQLva(oLJl5&fPl%+MqL!SKro?
zWyZ!$6A-C`7@<V>3%UZGO3#Y&!kG95W2aTvE-Hki2WYprHpmv9Vw`TP%2TA@{<KTR
zcLXcxt%813++mw*e<^spmKtB&SKJf*iaSE_mbhnT%A0-^&y8lkt`XVtY7Yz$2G%%u
z#-d(0&h*;(-T%dUx!3m4!G_Y!Kawx4iuwhL1(OEXmMa82`Du4~d6r-+nQ_uy=pmMH
z((K<C5mU_k&@shq(aFA#+}Z7_v6I=d&@uszS@cz`v4p@ohVi)&$JS$z&^C4~rLBV1
z8>q!T877H*Au>md^b4=rzAmk!L&lm5-hJ=hSpD@)ec&zC(l2rw+V7uFM7>hI|FdaB
z@8|Qkw@y{d!Sb6pjxH)mU#*g(dDBF->s|IOwQ5oMEsKj?lXqUJ)v7jcSzYgXfB#gi
z&Pe`i3HFkBaFTH?NYC));GyNyh@W-5%|*_KUlFgnZvb~Jo(@x&r^nrW?G&HrOsPys
zoP!4C2=Y9hnRLy<UTL;VZ@!SF&Tq@1%NEOJTBIOIyj|l+qX1RsJ4&f<Ui~y#Zftzn
z=ah3#YDfRQ;s>i5e1ae9zawi=bU{8|%ac7OVxZ7P7CD{!x?+4NZJ)T^M1Z<1pfh*)
z@5zX->)l*trBQD$SQT~9qt&K79vH4xT~6_(%x|A68aXC}`z8LB6#w|)xzjCCWZtGl
zo&_TYF$r@;R5FpIhBS!C;1-ce?olb|xoK&$KpVIA;exyzKlYa#cJL8~Vx1fx>z8Xt
z<2i#NrjW9h8{$^G2+wP=_%>eH6*@fs>C$`Qjb)il^;C4CVYI^YKl{xDfp(r0nHQP|
zhebIrLt~u+7ejw7{w-<R)ojSbI<{q*!cj_;qf${?4;K0+rxrGY9#J2<cMgDyhJDjA
zRkU^8O^vwy%gwCac5^ev!|>*8>m!S^!TdGrwQ>K}e29w3Q`ma`N8zgIzoKjfcpM0C
zPwOP5)UhW;`)?A1O~;L8*)-c;y!g<4RrL3R^D%$Mn&z!fUqw}8AsQpgh!TXD+ts6@
z*M2eRVU&4Fz{83wt6vEAoiyFL+h6B%NR~F&!)||<cKf!yU@L(B)13FQ_uZ--Cs@DS
zdpj!>#xh1{diR8YaZcuR$8kB6KZW$CQu_>G3_!f?E<K`gisfGTrC-HYS9)2RSO%M1
zmYDJo_|-ASQ9R36y!WQiiFEmz%Me<OKT?cV6lC(wS;`zZ8p2Ll>spTcxeE@k%)bA;
zU~5^1&@bgVHTfPcm=v(cv+}ORo#2DE#lsg3Vg$NA<QSm9i^SBhx{O^2mcJAFiw<KL
zCj1NV+>Tx3)xQis9qhQxcZbU}f)mGg^mgNou<xos>4<p>S3ljfp?)U4bg%GSJgY8e
zIrn{wv%`SA&{VL>%AWB&3AJoREaNdPmti$kH~<MEaL6Ux#7Vy_)|8<Sgn=6>v4f<a
z3kpW13Nk^?!HAL&kcW7BJjS>y_3C`7z!!0ct~Z|QOe^XuLM)YIYEe}h>?FQ*BYo6e
ztg(?U()2ua2-}u|b*~&a83qJt?6`q`p5_HE5#l#qA$lQ`{;aCuk(J4^N)zwpwu34x
z`;fBnU4!|4rPc~OqVF0D(G^So>c~hb>})MUz&i9Q##^6#Z_pG<=32Sh9k*{&cX6*o
z*c7Vg=kWpykPD#Y3w>f9#9mCKp(rF}5IOW%93q>aELh$9)0Q~1Ty6gqf@4aJloNL_
zt#PmxzvNhR>590cZ;j(Mai^#nr(5FAq#EaJahE$aF89S<YinFv#NFC!++K;h4~fGp
z==f%Oiv+oNL2FVf#?o_FE+`mFKk*!^sdNXW;thv9xYtbptRy_wAehkAlc#|(M64Tk
z&qCB$hcGgbcot(nSDJBZ=J4oaSEkfj&ysm73C_8!^?)ei0hjSPtcPLNU6nA*^R4?$
z2R?X&gx8V;$k5$H>GI%?7q9-?r_X91)A`v!s`;fQBkYa2I!(0@h61||JY1>V<Algd
zy;u9VS>i-7Q0RHSnP}guOIE~yu_d1;5~(Lk*BglH*^9D)rLjT_H}`!4R>2jv`B=y$
zJL&@;TM2<nW!DrWLYYjHYu%G2YEr(}EZ{#6NDG87Y~Xazge#WB_67YbQmNM{+*1WA
zyAW|t!{`ZPW#f-Z?wm+xko-Y17urxM7_2^%GTK^~(N~u_ml9`g^8drXmghyzEa9RN
z2Ncav4)2{1_uxDfdsM%w5Rj%WawYC-*-giR<7X~0wX43<V@o?y%Qe1aQwU>-^qo6(
z#kWjE7I;eTYz5=`)6b;ec<MP~a*4(pUJoPPZ6m3#>|rqQSkuVA1Ltzq2JDG65R98c
z3}|tIH5e_v9lxfE;jc4E5?wF<9Jy1&?adz>c*WY-^HxK)&t+V0gMwhq)xP@6T7KdU
zGT#M#9zF?do=LuzwyJNt06jGpZc3Hjb^@quPXDG{wFur>gAV0W*Lc4%pSSs5-v2fp
z(b0zUEp>E)^|{Jf$BS&mNnBERQ*v+ReC*2Q!YjVUMZ!g64;yc6b=|*bX}A?LDdV+G
zE4zKga<QVZ+p~hx!PIy43|$Pg-tO~h#fjoMvLZfcyASDN2PQh9He%Zqwh~fpq_~l*
zs%>x}j5Ixe6+nRkb!T*sAZ<QhA%Xt=CT!QTw{!KxN7Gkq_P>PR58Po{Cw>i@qT3FA
z75r+BrQu58eQV=sm(LSVTt%p0bgYF$U656I2Kq9c9wf<(8>&5!inRn?EgqlRA9S$n
zGpHuS&AdIQW(gDuY1R$TyAT|5dwmX4{39Ak-nD+;v*HIOyX^zwl^1?htlqsfUoa7p
z*4KPASc>*tq^dw~?&m*$w?RFh%r|f3O9YV;Sl7f6zDp@s0ZaXHK>%P-i=;u3_&mR`
zmdtns0Br|MfpGp!aX?S@Nk8J3r+%U7W0%bo6-oLzg>cd`$r}IWJfvY_`?-YF2W31x
z>mylig&^h6c0HAitn$F_R30cv0mx@$AB2eaOA%8#P6#J-K-ZCEXWS2iO+#`dy-@r_
z7NhZQI9N+3-#{%j%(nmQpK`D6di&3-u=-MA&#e;q`;$Ttwz-GKGmjSezPI$vzg^fk
zrn|PCJP#WFHo@Ji(gKcVBL0IU%|K03YLM{DN`RQ$Cy7Tv$x1`zP!Vs^4|=R%eD?Ig
zfGVD(;0_fz8sOKyT&E#eFR|2{w%a%t+@MqU<4)K``{Cr0ZRr)79GmE)&()ruo>I-Z
z9vuDBX9lyn!=m;vm=A7(>a^FA>Q|8>sFe4+O2LqpAv?}jd2>P+Vp7e+3$esxa&w^r
z#4xg=Khkmw{9@K`y1DRo{!PPOOJ8aGv)URT1gxqwo+tT&wOOP+z_xAcp4`er#0CAN
z6i)MGjIR7Qn2CgdMPOT>4|Z~0B)c{{VkJq?CYY|0`ae=u>p)iHv7@pFRL*^Q=g;=T
z2$_$wyL1ctlNMi^_=;|<Mks-OsZn3Ux;#10g(|b{;Y6-0v&l<rPwT>|2GwD<+prDi
zk&L5$v)E7|_eV$iBQ3%g&uvif_qzs#y~Y-S`b%5zTQuL;^~as00Nuv<1r2HR!*8+I
zWT}142H$?#`&6-O7C)b>4os-RN`?hZ8us=g<mbh0fngP(_&?(ityLrW5g{Az1JlL5
zNOwA$H3Ct)FP#$=cr;-E??3x{&4<?P{Ry`G*?Qq{mn0?TC02?w5U2hYH~ilAW;p`a
zFL#z~D0^DPzJFl*&0Dg(B-rx{MkK&Tg6QBddt00syiJJUJuu9zx9o1D3#zx`-bah7
z#LIlQ{rGSx@7c=Eb=Qj)dr))zw(=6`A5N+pZX3Vu_s*%P8DWq6b^Pf|%QkWtTdxTJ
zE-P*@7$_2?@{;-de~7euzvn&7OHt@H6y4nR4y9@MMYsDUYWS1e{c|(|?zRU!&<HF@
zMOAAAJ#FWO^zikJiJ}Q2ZBaGPpS`HKQNXK_n%*nu-G40&EF&-|$q7-C>I?irJhyG6
zH`87{`^@gB){s-Zl-uw+&ww0?UKur@UuPKciKul#(ALtd-cc5K*Qj<SpqLb`AD@Df
zN;wA`5ab+;Vjhr07+rtgAGA2YuiM9;+fj8KVW_QY_r5`-$wV4HAP$2lQlkO)XaE4C
zx%#5Po!w_=4BRBH6-XLAT9ZS3#fnA8a|}lD%!|gerjn0D5nwH}Q8+V^mx9Zb?URQ9
z$^b!5EC$f+lOHk6`51-Ujln>$7&OgD1JNJvruE=M7+&OYkc89?@J#UXGituL(g{JI
z*okVQ7;Jag25S;U!RTgO#G_;#PKc`iv6_STQl?heU8@ovW6dM53c6qTgHgV0?0q^8
z+*>i<^+&gv_7}eXxU(7MbidDs(=hX1ulV?oKyD1s#H8E=Q{L`CB^fOtz>1~E*~~=L
zREG{4tdx03xe8KViq;>{#(5Juz5CUiNe$nQ%ao_a*|qE^0#y&chn*@#CawuKnP?2e
zU^@F_;m5YYhX$QSdUb<p12F(4Sq8$Y1RLP<K2~e`ox*_C7-&a%A5z!`8i%{E<HxSv
z=Ni4bn!fPzMOSHYM|J$6g)`xl=r|OF@79!U7#VbeTTTg&6SZTJfqJ@qLHBSa8%CJ!
zUjC+JEl841lZFZe(9`Y0PQ~as9I0&+I)h&LsC8n2e*Lhxu203RpK1e-)i`o0N3U+$
zB#Phrbo7K~q^D#Q{+BTD_a<<ZECQVUM82@@&3G>-V6#8)!ErwuvBT}e!26^$8jKt7
zGf0Xb`RHQhSyiC1&q028YMtQ1o$~l&r@7G0YQ;av8%Bg5hx$cet#Z9N0s+;HljATZ
zB)-5}8a41k8b2NmY!K$n63XOrn)|s!C$7EWeq6I~jjSl9FE$W!&nOj4U&KL_QGSV1
z((Ag}g>pZA^oe$a9q)brJ)x6-pp@q&R!eW{r`~-ZEo*NH(y;8c!=DZh*3uZTQATmS
z|NiKE8v#W)!lKdJ{?5!tQN9lP?+s#b?(sv5dbs&M{j<iYPsL+FQI<+|bmt8a1tO92
zO3vSJV-F6oQidxZ33oS$zk^=sclQeDrf4;p%fO5=-p_U5&rwIod7myzbAlQ>V)xG8
zM|AgHvOX4qK;fqiZh(;z4xPCkMr1aOX`xo0r%48nvhP%9o|jpUFpk7InhOH}kQGR(
z*tTXgPr^wgm{HYdv;geaAmIPg`^`Pw<OKokLVvp|vpgLKF8l-S8#K_t%|bOmxt6y7
z@6(|o?Gsk{A#}Qm2ff$}JYb)Aedq1vz5tgF75<`~2Op9<X6!$_xEp%)zeG9)?qJTd
zzE^uDVQwA7<K??qToTusW|X}~4HfxGa<<pkdmrG)>y3)ba*43d$4DbC=cL5b)8`z+
zui=Ku4FmLAJC8nzCwsawZ#z<E46ZX4zq}>yw4|08Mc<&JP!f0J+sDU#AFt&}yh&9z
z+s`cJs2l&THTuFB<?t`+@W-<3euAGmUJ?GLJ2uiUD?~Nu1O+Qi=t_Ru14dff_R{N>
zSf-P7zR5n$)ct!+6{<XL+n+bR+58H)Hk*Ez#X|1g0EeBW-5{4s@Lts%x<vE=urf;G
zz0pnsJv88n-F`PLoD8=g!K9V?XSEa(SV}e1gC|END>CiJr0d&YLyPM%-gjKiGq#Q?
z_QEfYE04;(A6I>6dGU?<Z1DRxn#-9NC$zVk-cOv{8^8Eg?|A$DTLU^42P%$Heu`>@
zT(e`*ZpTwH)hy@1?AnN~FiUBn%i~oOB26QcIa-(G-q~5mtBVx$nUe%(PCOXchtdOv
zA0#aB4ly+-Ava5cN|b#$mGtL^guTY!w~h6CmOYzxGdTZthCIMA>T<EZdD;P3MVnPP
zLh}3gI-x118P#z}bJ?a-Ml+V2*5ijLqS}iozSMz#BfX5W=}y%*WuHzjCeq(FbW4n+
z1&C&vq|6$XU&23?U{&u9e^XeUf|O#v80EsyPC3VZ$GOy#sbD!#faF}Brnk>1@!b$=
z;Zp`=yZGwydz|MX^&OK1RhX($<wEjgG#@a4b3N}hjcnF^j+U48950RL9@zkrzDqd_
z7{2&3Tm1Zc+#AXl4~+`lE6hXHYU|-|9_Z#a%m`QT#Wt^7dyZB~82N`oDonGVlkWKj
zCa+55q-lAht`U2^zDbS#ez*cqx&3zvy`D&8ep551b$@gB3#>kv`{{b{?sehHeIPD8
z6Gjx9l|l4ZBK;dna%2vL9?~-n{sJbCCGSjR&XVsXrxYVAVkuX2c!?`pM&r{o8l!Q!
ze<qC_m95d=@o8M?x{}H*wxE(HgHL|kJ^1<VfeK5V7$g0?_|3fa4}fE=JPRP8y;Jnj
zF~F_kUOF}_ar}$pHVlyW-B$>K4X~)Xk`)Y*KuC;N*u(HF_3H2vUrPP0(<FyeP^&@W
z!4IiYw=!%>C4wWR<($05BC`id0yhp5WE>rq0@-#~CVL3dmP}DkBA(9Wt>K)MppN(L
z+9DxnZewtdGN>o3fNIU7ISbbq7iUZk76sN27xzvv^g^ac3JoFRaquD6Mw)n0>K%`d
zC(2A)e+w}-%OJm+MB)2W#nMY<LZ&Bkohz&eK4r$LG$C_7#)!h{09q2=LkR?Z3oC0&
zv6+%galU*Pln4CWg{6OWI03SB`55Jm$(igU`A6JV9i4x@j=JD-D#hkDIy?pJHY93^
zaD!Zkj^k03=2j8^^(Q`REj`8Jza!8C`IR2!baxZojlxEm0SyXwk}ITK&@+9|ksFhX
zXH}IxaW&_gg_)HmDc*Y;xpB_Q7`m2u0sUovSWzZ9H`1RDK*F*5Is2WLBF`RWE~6OI
zP%fmW8df;M+t{*4Zx*rV1=?EE8E{DZ2=jhG2OA6mO2)X`$MeJz);vqs&d0PA)-X5p
z>7IsnCHp4}(aHxg)v>UCl&EZq)H;=0B=x%gb##PQ87EDWBMB>KRLfBS;x1kv35im*
z)Jh#QV8tNrpY}hDtG9hWQEy#b^r*&1T{fkVj$gN2sqr+)m}`mdo{yG2^Tv_cxqMzK
zEy2vq@-Ilox+*IlwN3;m{mw1Q?|^tqaUL!XcY2kNz|^mnSn=^S=QJU&GCy4jy>EUv
zH$g+ZxPW&qh<^#06boG7adx@Sb*r~<hWlsK7g1NwdxzvORA`I|%2Zne2?gAf5ugeZ
zwtSBFft|Xgp(PZ+H{PDDWmj1sd_0;S)su{4E35eRJ^EOL-fvSvXa}`spo_^>EB~VY
z&0PKmdhNfC8YSRSYdLnQH!D$22^d3}>juWr_y*~dDpkXqil$`|hY@P8#N&A_MxPci
zc==XmfPbVaZ$FU@wv9T51psqOtdaCf0xbGt8ecrDlcfk9HxQ=!?EFba0$FmdX$(>V
zqFIS2o+|VEl|=x;lURs~uAeF~{GQ6u%r%=QGqGDxF)t@lhyk*-h{hcD5N)kKWMQQ>
z>T43TNc{h+ozioWCM;dopWHn(yc+OaY3xS(&$7KzKfNEtZxeq1d_X7Yk7FyLrfM8i
zAj|ws6ieP^MIBUO1OqH=N+xf&AJiz91z3ghy${GG_(b=SbgC=LZesfDv<)}3YLdr9
zlEGpEd-U=>I;^{~H=6u*D6X{YB_9K2#(4_gy=bmB%Aj*5s?Q}WL^f42c?&WDuc#UE
zJ!?YqQtBqtb+xi^u#k%fS-EH&=`qfVbSwTIH5BqP;z#Gl9sL3iTpFTKPXRNGx^9=A
zWWpt4j5^IF8LPaml{FT%c$7yf(c4e|hybxY@{sWV^Y2Hh)Vwe}y7Psyz61dOCES?=
zM)AF4#=?x*hXEpYUn`@D;Y6Qs#bqtT<5bt2%Ch7sP2;Xc348n+Uzk7P)*-Gh+gU`G
z?KP9QvDbAH;-9c7jbTz%=$FjaBscq3Gyr`Ukpok1WI1Cej+l{`o~8+$`kRS9W4sq0
zZ;W`foWgmsoYO*Br+xFVG5_>$?|0|h%U=@`CwG@{Hk3#eAlN(|(SKYfBCy9-#z(;r
zJy?PdK*&^Hn1m-1CL&hJGaqBBfT*N5gZJ|fj|>$2$-Nyxk7Y?8PZ!h$krPml$S+JO
z=&*2>U{pWHU_$(=WDbmoPvLGA9>L(1|1+hgATB8xE4O1Zb;O8!@I1Ypd*7pXG}B;J
zYW$Id?YX9z5dyA<<}0t2{}D%Us6OWpx<uv7-;!6DZdsZuS)%|Xt&+E?>l?NYEqL-)
z_-sCf_E?7W@#cHqY8~b!;Yv#?>`<a8sI6?*U=9>PgLqyNNh|yvlyS0*GTu~QPqv?V
z`|pJAl(uSvVt?c>fB=by{q;te&)^Huy`1afLQS|(s0izwWxj10V7fOpe}$=gQ+RVZ
zT1J%JGyvUdh%T2pJK8EUb4I(K@uwc>30%pYUcTQLAxIxnH%2xc<JGnjN2=y(PZ?X0
z5YG3IeS(k<#>h_NP)fbreZ48QO2Q4hOwUAEZ*DAeUx>+NzWjTc?><gegTl!24p9{b
z#k{jP1!V5PFw}2Hh2ZB?Y|<2TFC;~Pb(uJKmJ!pNv69T`mCOyt04)IgQ!?C<42MhY
z>hGz4$28XN3R*)oe3{`-Jg=lz^IYj?>cl#BE;C>8`ju(O`ea2gSP|$<;`-9NP0N=6
zy!V9t^T0@v+@lN5SNhpONw7I_0c<Ac>t12&JZ}4NF44z=X%J+!H23BbLg}mUv^enp
zI<g+JD|8doP3Cl5EeQQ`ev@**qH>Bib;R7m_o`1fWcZq)l`z6e4ga-)5F`JC`~>8l
zSX_b2WMhO+Jf<Ajq;+w!C<KOkUzn%>;Lk=!27&YxBX5+ntz=fqFK`Ey%<oCwt6s(v
ziYeI8`SX3OU>-b}FF!?M6U$%db<48yyKSGi1f5K^AKG+6xW|rm>d_6YWU}5AltE}D
zrJLiI)%Q1qqc8w`SzTyfDxFS)s(@*k6n<il2A283SbiEq3O_E4e?N!&bXlYVv7Mx%
zoC;wHmgb{RVfJ0k6cYvdmYMIdt2Fd*x20s1jH@5WUkQ@}G?anqufjSwbh|AtvXAMB
zi0}|bU<4y@MO9$m#$2iQ&grrM-ymnZ2z#y}ujkh}5T3K$Q*93~Yh570u!4diC9A$B
z{Z4+aySvW$R40}wcCXcKrR8fwgm}ION?ZA9#MvuTFZL>1;KEn2t`>SaG&0iYsBY+t
z(cwQy_Nrc$ccIrO)6wOmaN+xp*ekP7D(Jyz<Q1bMHPSh75-VptKbaomS)mj(DNKE@
zBVTCp>bfum0T4s)Y8g3H1A_Y%>{)X05JNti`96-RKPUI0zucpI5Fp3$W%0CkS8RVC
zQTgmUMx@G^`7BF~zLIGYBfNyuGO1ktz1+zOVtoRVvr&_UEBX;}=)NR@))k4nP)s03
zxVpe3>%g#A%?R${6*I)r#VC|-igHZ$1F+1KUxgi>N_kdrub{=z6}8tU#kRi*JNGKV
zlifh*v?6n+bbMf`!@z_T2Gsk>)S79xJhZg>>}jV{$`@BTq#^6-r4_6#<#37Qa}PYE
z7;m2;cyf<1^gq#vZk)D2TV;{CA%o``H7if2ZW(eL2P8>9M)nkmsO_W+^)2(QU}XE~
zUT2F8O`lyie`Bp;+3Xb_2El1yfOXOr{RAWwtf<cK$+;vVj1Lrs7nqOX1)qQfN$Q$E
zkkWJI0uv@BkQCRNE!XJgTh(cT-4)tTBhmgC9b}(N#Rrv8bvy?V*3e_Yuz3Ih@!^d^
zPAX6h%Kn*tXlgIgd4v_RtNy$9zrH+{BW8`(3KpX0C3-uIC2qjkhhIO_e5QQ6&`Th=
zP-YIxyOItG&G!2D!;4pxcjdcqdoSy)WN%0xpMcrIX+<EU&(lTRi#{rVZ9oZ4&kn0l
z;2k-$c*k6=6g!s?Fedh0>@KGv%O)O?$tB)X&br^DtSG|5-pgA3+hVgEiC*SCu4LWp
zVd1U}ej9~(1+dYCG(>wGgNrr7=%d3JJHl8F!;qTcT+!jY9pQq9;TX*b@#qNYjtKd~
z2xZOd>e1J=JFe>;D$bx;J$JhdqazItBNaQu&QxCSHFbA-jAO?=_h|8q6nN7zAG9~Z
zHahw*t6Qccnqq-|GDu1}lv={d>f&z3M8|$=hD~SVXZ{b_osj@aoirmcaSuD<azt41
zMjYLQ*ulH+4<v-yxiB%d6bTOL6+l)8*EFPgOP(bdVU5{TJ%f1ihFYXn0Sy)0bz4tn
zzFt%(j#s8a<qXq3o7lq1{I@)MtjAJ+YYNO--ja{WZotdMY>O4i5u)MBZRM~hA!6Cl
z!nFL37b86_B96TI8^W0wUJ(tUO+5O}xXI}GSVb+empM!M{~5PSWWIGW`Cl(Nxk!ju
zB-5=4^f=W>e3Qtc;~ANp!G`@$y|p&-k{uWCF?t$!k=%<)0C^OWm@vQT$U|D1@_U&D
zl?gS77Z6X*^1k5eC1z{Up*fQ?F&lTbqA7u2UDz}fP|ReEjf8N@{tu@0$eCHn{fWur
zIWzq4{68e!dpy(s|32^+J7TjrpPBPn2szsca|}6!GRNi^LKGQ>InOZ(IVY(Wl1k+q
zl8_`MXDXHCU6kzS^Zos^zxU_sc0C{0{YpByvin#c_;U={!65aoiQ}x?*}Dbp;k#FC
zFKnuL^gd*`ybsv{G&+V05-wcz5K#%1*7CguE9%9({bYGY_N;o-8D`Cu4d(Si&K6Vt
zkj0B7B_iZi4n5xpF4polp;ar490OjxUp3=~DR(zs{HEjo^ZJWqvG4&unhaj+bK!qN
z$JHz^UVT)_GUp7=l5G9N`K_mM(EwPD$87FXTlaJC*gWr)o`?DdWrcb_8U8W-E_ZRJ
zQsl8mDejJguRwm(-NR(d_XV-uDNct=NiGV&6(3g%KIx%&%&39M`CdgmSf$vd2EKsy
zU()}BUmdb7s12QG4I9rHN>T@u>Z=QX^$4@~pus(8_GF~JFE0p?{I!TXQeSt&f?9)Y
zGEYBIyXVAP-f;hqLl!x8+|ku*Md!}dzHSFpK`(Qpu-IPdDcMhwv?FC2?>-{p`fzW-
z!SMFi#}2d3t*jv#smHBVyX9(XOE$P#__X5L<l!ufWbp_-u_$>US}g{eBJiswC+v&%
zU9OOChHbC`xxzsngiokr3ZiqX?M^BZ&4$AMb^fNVJ#)J4jMz%y{(}IcH{_s>Frzp4
zwWFb($td54iGLp^8+E2#?#z7Bnftf1!01uQ<wt8u$j$B$T`tWbD!1)ufJ&KdJHTD#
zDK`&HcP?_0krv7+=l8zJhJSt1cm2`jhj}G68LcuB3O+te+|K6ZXZP8Vne4N%OOm0P
zlASeIP7DxV(vaKCGcS@Yjb!A+q<LCX78KYe0X;eXiXK)^&)c~VbPV^1urz5%<l9S*
ze@i9t<%X=76{#{c;X-Fw1%2D78nvI&^|~oXnzWRKo(wTZ(F{MB);f5s;vKLE59>j8
zck^6YLS<R}k9I9I9?sa1(qmKRMXmdX^WtkNn~%v_?Acg%@Tp{Sm$Rwz7t5;ns4ilW
z9Wu{UWssb~a)Sp_BL}0GjaQ;Gx7~dM9GZ$(W0k_8w;hxgn_3-a0X>}#S@tE}j%xVX
zx-L-N_`jubK9e!6@VEuG$N8s~67H!N)T;mNF_GY?3=PjkNDJS^i7CA%vMuhOJ;!5+
z5}k76B<AntvGI)_BQbX6Po!7{H2*rfFc4%b_@4~Rc2%rKkc^WssEnbXkti||gzvs(
z+1$GiV}B>0_80T?gMD8peUTIJYM7*|_0@0&Cd&5SqWHWvTE-q~avsi}7pB}itWNnD
zaWqP@CS>eo5UnLXj0JdVMS7oFc2ENbuFG=%Vl#OxGA<ayIVJ_)5k2^R58^96vLm%?
z_z}hgK;%V83XA*MtnM9T;3_mtPx5ZfhaUlAfycNj!sJ@2#XEc@%i(SE(yCx~FFXm;
z$UNr8CO8wK@0hZ7?=vh@hh)$w9Nj}@2cB21igYX|WTzkl8ze&i&z}v~1~hSpGqcMl
zEe?-n1X5tCrj4B6-k!;lRAp4H91lO1rYWs4p%~1jw{Y>n4I~oaQW;r7v%-D(@1Z45
z74W+`ayfkwI9ZE8P$s1gbvJzkZZeu3)`jfZ>Fijm8h;Jek_gyHZd!X(2>(L-tTb&&
zcM!*Jmn?KkM^#ShYeV>lR=gy#M)FPdaY0=Rn8EWeal*|o{^?I|6x&c1K>}G@0vKN1
zwpt#^e%@a_oAO^!BUt1R`D?F$+`|-6rKd{sfa<p+B{%`oHEt!;%g?Np5DgV!;`gs5
ziFXV9_iv25IQ81L<%zQa%<lCo9@mxPYPqW?brXtGYA7|23B16vHx<jq2?hAOy&F<i
z4|QePtE)?7AWM+F4V3I4u&*R~0N1V`Dv+}&H_mL8yOT5BUZ23qoV;d{G%Fr|ApG^C
zc44mOSldsYvx7CFM!m*aI=3bpY_A(8a_Tlu-EzL|@ia^K_VgXkH>-aie$U3;XT^#{
z?;g8x^GJi`&un_D?xozp8SeLGdggh^`MGEEF6btlvCuoH(!=jpJsED_ATyR4^PLd|
zPd}_?i6}QFvYH-^dNHl#qPz`k`2J3KJPVZlyY)9~)6b7tpy>7tVfgUdhpx+i50S>5
z+e`g8-r<ecA77~aJ$S3W`AW)I8O_$6%S9b}5g~rY!)!g@XlRB_P(;pmL25se6@3~t
ztWJHHKYdRKmaDK}7S$AwvM!xBtD(x}+RHqUo-(`Mz41EXw+Wo(L*un4`J@S+jdRfs
z`s#=VGQ6hfxSt2dZGkAO9swXs1WeTta;#rI#u_~ZA%*j=+Ty~@FBFJEDvM4YQ%Uz1
zG@%Jh38lLYm!UGc9~Hbdou&G}GBrrqg)mr)GLsrC;amP?zIj%G*8;18)}=+_PeFlj
zCLh+=2aF|(2v0ak5xoYSY{cKQEy7LM`YjcKJN{Fg#Plww@#ByIr!@ZiI>8Qv$Ie$P
zaVZgl+!!K%@(ZnZ)t~rJh#>Ls=BDW$7p;{znNt3Ae=w3{aJmR8>M2}rXR$3_t0LV3
zWqvZNydruepK81eZ5uP?QojZ0|3MjV>zBT!DojSQ3gi>tUoC0<;+1NT+fSg^i=`a$
z<yZgUUmbh`jr?UV4wY`4d8n4xd)oAOj&Qf(L@z(Ldyq&)zPYD_UxblkI4K~ATSP8$
zfD_hz-h<UBzuhgFgoqlF$*(BRayv^zDX4WgI>;skPTQD51B&xx2bT)C2S%cY28%iV
zrP_(Ti~NbIN;-S4Qh5vc04Xn*@Bi6Ww6ae?W(Hg~VMI-CAGI|S&_Ov83w{<%9@qUB
zJsW)QRqUKVM~MZ%Kxl7RUO`@)6UvBQhRekz2=W4<<65L7i7P&qlAdz$&Z5~fjt}R0
zgK#j(l<vqhmpp<-{6<w0_odBRsSh<Vm$LF$mp(V&8@u%7?#Z}|TiH+TFMsX$n0NVG
z$HuTx=VKOk!gep}q;YzyP=3PB$g$T6KgY~aiMx|0PbU61?VX?aYxex>#NP`^s4IKR
z`6sXJuiwbO^5^rt*M~MaLPF^h0k-n*zDEo#$+|@9^JWTqZYRldeZ7~&$|eGH8QtKN
zZvxYu=^(K^?Dc<8z!N@5*VabCOa`JmLufk7TE#JC>=7q9pcdkh@ErIGUSSu;>C)6K
zJi-WjMY16sYTe>kfXMx2_FDQotJXISUA+4x4U6?f@Z;nKy?Od2pRs3iY5kD0r!6Dy
z(ajn0co8ozsL+FCp1wVclm&O1;3~jziZuf>HZ`)2i8%NF8@t{8#+=$_O(b^NC=$rR
zIk3j$PhEb}XstAAxP?z-Rd~pNeExGQY6tN{9XgTSn&<R<PFWl1QKC!N;^AYI9!~H5
z`ZWB0zGEqGK}%>unJr96H%wXoc_%#Hw!i25czyIQgZ^X8$Xv2Gdr(RBfK)S;P7WoA
zzE*|{i8>;}mHK#RBR#7O>$8uxi^}bT`f@lY^KdCd&fM_<t(+Pz50WM@U>vA@_5En9
z%&BXm?Vbj&ui0N$PZ4Z{XG;4{WTwRZJlgHKDejdyPO~6+vpIl_4wsO;zZ7`Haj=K%
z+v)~K$mAyZou-~>PRw02OYZr0O(vB;=bnkhSvDnt0Xh)#P>Y{8h4V#L)e(};Ux#@b
z2jzH#ZNHLio~rcKBgoxjD)nn>12*lG>G~<eSecV0MAq5<qA0b>+PTK->*w%1C{=~*
zX8}Xz36_?k+})Qblt=U#c5+S%4R7#?I-ojPz~jJAgZrz}&5o>ui~K|`;?JW^aGtTG
zvYTP=lL^P03fh2b5c>N>7Qg>;el&t0ys-zXVIODI0KcSC0)}iYJZE3}65A^N3k7Bw
z6?)wDjI(#{geCJm5l{Dx<#X<{d9KY(RD*IS1e1({dv3ZXP`JLr-RIe{(707u$!j32
z0Vi)h3Q6**V*xKo&l#mQckigvH{bbnNW-jy0|dyC=~lS~D5OmKnOVD;r}{-709x-e
zHuAla1+kAQn*ma%!Um)5F3o{eg^$Ox6QgP)UvV7GcJz|$aTaVsXa2O9vJItT&-VDZ
zlIu|lqLz5MO`TL7S=q}&E~1>S8iVYMT-9`lWg;&u+&4gM^1TZ#YiTw`4LQJ~M*`_y
zXlwrW8YX&h28TRsOeq`T{b?ZOUe4O>1Xc0BWiS!p&)2O+q)o}E>6!I_e<&u1RJv#@
z^~|M(RG}l4hj-$!{WG2=V%t~*?iL7^Mu(syRosLf)lGeKZi<3QF&4ZjBL51EVAbO+
z{b-iFKyKZ=18Lw6ko~k3@!8?T+DXO`32XIR%$6q^{%DB)8pB>C@obb&xTkO8Gqr&2
z#{(0!$x}S+a@WZDsbbb%V(!v-+I~0Th3kEgh1w6E^u%c=xtdr~#a9&NnD!7`H^`y|
z2k!D9Os#61usy)*#QJ{=?;e&TFizEVb;cI5k^0?~RIZ}`tq`W|a&QN}Lg7i@;@I{)
z?%zwH-)rf`jB!Wcw#|9z8FEW3_c-!oZO_q|sruu^QT12I9Y$)u;ZRR7t*=5k)mT>j
zEd-nPoo)J^FU|6DOtD!w82II1bQQ919+m!|!Ggdl=Q|Tv+ie+GPNx#!<8EnT%Tn_{
zn@`-3v3hJ)y0CjQNe)fK!NQ5$zoI~xa29<z6N(gdUtFf<(hF0aSH0bv=xBo$A5%(A
zr4p3<2>=R9-n9_1^=lG|O%swi(sK_WD+1)|A)!1+hJA1V*KQe)90DiG-13{i$z*;s
z$H%|)d!}=p1=su2@SA!2**sC{ivo>XTvzC{*s)i1WodR;{Hv8SoY|>edc2DITW@C-
z49@_R+@8z+{X?OBAqj6s(NZA|LcV?(XAf}DH{ZPE`e7XZo%2o1@&AZP?<SebJp8kp
zD$1?x2`)=|6I}BxRYF>O$a81gX>5EYBs}HWnVoYoUV%Yzks@^t+`OqQBy~zp*ZGpT
z4}we;ab+SZB2lww7-L)DwLDesezJ^oGCw6*cn|g31?{~p;NEaW86M0$VL)eaFc#sL
zspJhGi6d?<8Az7GfxW4)*lh^q9B(ic9?wXvd;=}0=D2E^a%}<{qj|+;f_74gw}T<r
zdo#t2o_4xZtpE@-s!Q{Rr~3#?zZ^#xucNl8SA3h&Lx$4JYMeh|gu|3FE|4-Dd^jI%
zbLKk8#tda7Ze}FG>B&m;R1!UnLeHSnGn?qyL-gEDdOke!caP8S9~Mq*@H_|Cr8h>(
zZqnD|q6^?zA#I#9WMn-htHC|#8II%T9-@!T>Af9et;KRxf}4Kaxx(k0P2kUZGNU)f
z;E`TJfo8;ds>Lx{+?49nk{EttLAT`#p(DcLCBpj6(A+Lcu1p)pO9o=LDR;hGq#O`W
za^tAm=8|}TTAq;p9K+wHZ`xXy*RvG95*_<JF89Apt+JycCtSR86&2wF@moU;xf|Yy
z;~mvEts;qw%kjd4@{tCb*PXBIGZUZr1RULT$WSE9uw1bbr!oL8#`gJa24ZRvIYQ<7
zqLb}Hh7T~2ePr0xiF2?G<D9ze9ZL2tkJ0XrJm8$nqqtLQJ4F~=5$+SiTv?qn6N>ja
z)zgz-l9oUNfUQN8MUe!y!zYl9cNY*cj%6VberWQf^c0*n@KZa@SL(I<X=Z(?$Y5q?
zf2pqsPnCY=08D6-QhYH;p@RgTW1#l8gO>JCzqi%jZHt;afDQP#KJvQJdZ8l|+?{03
z=iSJDSF~RM`W-Wh&EcHZBdgh!ytuw=gdnNfPesB4<#DN3Z|$p*1A;2a3D0mj|43jb
zK$69fbu=ik^ea(dFJx^WRUH6hS9B>uB6!+uk8X1>-lW+=D*9S!z2DV<;R@zz#p|Z>
zckk6M%EEt>uW$VlvuH=X#2~=~$d#+y`q8Iy_@$h>weS7l`qdj=`bpBbp{VAONoCN9
zA4B1P42&v=izM*HGs@KzCn+ZfmgWxzRPjX4`L$CK(j^u@{aBjv(~bm!Bj1o<#UT?p
zPvl~aYlRF~yeCv9*D<>4CFDPsf--f+DOW+CYXc^QDECp9VzQt35ckJ9uPws8(@$(%
zD~pIk{6$Nh_kl1px$)*mGMc9?j<21GdbL)x7jLpF$ou`~F<p*0z_7gOeUaaOt+%x_
znnz+AeO~>s*nKOh^Q+Mv4CUx*DZW1zv}(kwWG$YaoOe82l8@cq&X^1tL{02lOzPKC
zFO`OIG-h0qR?(J`$5YQf7C2FUqu5!qcU;hC9KFx1a_59yzlpT@gBoxMeZWAydfT8q
zY~s``dthaCExPE8=q>$WmM2~1HXl3iegjp+Tgwdcx$JS;?KmnP4PU6{F<nuq-cDts
zYQ)6egcjVC;;g)oX@W7#ocvP}VZhk!seRXfvu)%~Po!fRqi9JOND(Q5^qlo}L~m(I
z(Uwctwz(S~qT~bt+hDZ4b#t!h-716p>iuih(dCDt#otdgH_hIG%!x4tfV}GJXUSZL
zXw-{e=Yc|=IWkOJJDiQII{>%;=Zv0SMD;{SG%}@TtaCre-ce(()ro5jyw<qrTM6ZA
z>ojLRbu4#Jff-vD7yH4I(J;>v-s87T*#DmY0WZ!A=G7H#v%1}G^RnIUOZ!Q#2ac)_
zPT4$g33=d_{owR%)&tL%56*mf;LX+HquSwT(-Cl4fn^}>gf{ahH{a!l<pLa@Oh_&n
zE4>6C#5zj<=!i6W7!%Twbe;d+HkLaYiEg)liUWIXa|!ipEMOVaesE;}eWwXLg9_KI
zPer+SU>qM^{eqH(bk<zwJ@bYNb=3J9D`Z_FczNamYn(DkfL{6`z&Igrzgr}k0juay
z!bDOfK)fA)QJuG+)Y^0@-ZwuxWlmm2`A&)b=VswXwJ7pLhZ0Rv#<`C#r8)Ja9im~B
z?NDh)sF4cq+}zWTo?RPH7_4g))*`8^M_$;IH^{<7<~nMsTe4kMfVM5*5dpcq%lqfL
z^}oNUQ)#SckkHcm{UYE0iah`y$-5znFrH^%+unM=QY=>@8S<Toe8mr32tiCbbKEb}
zqgNwR(ZIV!)O#@j5X64j8J&mbYDf1;okOd6IcS7-Z+@xdUORmaB);n7D2;=Ol^p-E
z?I`7vr13(;tp71x8c}~;P>2Anl-C*=?+7IzS=8r_k&stZ7mon+G*z>Ohxg3EfN4n|
zWYow>({-1T`8?8<qX2bpvF{inLG*_oq{fYn!F_L>Q$p6l=17}n4Afh@3rD(tXYgdN
z87Q^%dfw;g)kOTMaS93@mhs7MuYTb*D+W|Ukv$?k0qA}guB{*3Lup<w-+FzaLV0*t
zNAVs?p+Wv9TCAGsEL193_#1M_L@mo3_;w9kbCg%SFg!3HGW`QK%!X`Q7enKG+}m{1
zcDkoN`BcP8aBZOMc|CY_I9TY@s=rY24Co5NuX<(ZNdaF;=;%Pgi4_Lwrvr3BBrs7c
z@L!>Cd}Qy5AP()Huz|o{7KQ`$5QS@ZyS(SHb5&4u&fv88XjzS@f7jTcmsA0RhpUz8
z?Na)f!4vE%6&f8{jX_&Fp<9+wb?6wr{qx;=BC4;D$2avhTErl=V?33Ei8!6Fi@c=k
zV$PTRE0SeY*!@M^&}(nI)i3aD?!?RBbZ(Rwc6W*O*}nOL;2C+BGn&(R;Snopf02N8
z^x5wY4aK0r5`e)nN)6=UB*bg_5QWV!)T|WyB>tAyE;dl{_0u1modE301pMBQSo4Ux
zj&hLH>WeM+Q5k^{CI+o@QTR}SHwh5jX2O&vVS|fFp#*U75p9gs8Lx)=15~dX(RYmZ
zG2-uny<E%D7w)^EH>t=(0pJt_cyty0L<o2aLpiN5UE};I61+nvWQXqihZ8t`kMnKz
z3P7~^`@Lp2UtVDwhsS&sQ<BhpZ6_6v)rH_t{#y#~sG4)t&;dd2eN2wD7UwF)nM28-
zy!tV3D!Oa}f&XvlW$v?E>f)YMco~oy-~D*dCza|zgZ4n;s4Q6e1^!Sf9HjA)<L)BY
z*dp@VB8q#7M`MZ4en}vFNhohg<nEH#*pkGzB`NM@X-VUNVc}>-dUbNGYY&t`p1*Tp
z!fOKlVtly{k?Iuz(QKL%lPi_s&a89KG7Ha=W(T4pbSrqc>!}UyY|yk2_*$@l{fJZZ
zabgArIitzB+bOUe@lskE;XMKW^$S%96Sy(FlE0a4xy#cd4A3x2m>$kKYk{b0@oNsP
zN`E^olV`5qHYB2<d$$pCV**=8F7*#iVH|uR_O??GBVdeP-km#FhM3<LxE|q}9K_*9
zg})O6qR8!bK512&`AklM_HOUnAovfA^9yRnnF$u0orAZeTO^_yTA{_^#M6+oK$jH-
zu<KVd(H2n0V73Tl&mTdHB;LSg{`gDxn%g)<c#x}%-to_3$yA=~RG#Ce!A5ysvPlgz
zKroQ4i+ak=F;C!zpo5$bye9%VJI<vODw9j)8qq{NMRT!LHfK0+jW{5-m}{Sg-h^L(
zzoMeM)!N-A;12*U?F#re!MVd)nJ?R@r2TvUJ^E~H)jk(aFDZj&iF51v;sxJJyLO8l
zc0)WJU85!Soyhp`2D~H=?17n@SAa}yXLDU^T^Ij45-*?>ihk)(OLTyYX(G@+xL!Hz
zbp2@!zjj->yh8W}y|oQ_??+JGIFZE8;(-0U>dppZXZvgv|80xO$wd1pgvm@faSxyo
z>~*-D$J{T*xg0jWe}fw$B&yw#Ij-xXZYMX?m_|8%=K1^hv;B8^*PHV1$svakNG||L
z2k`0kTO!G`a(5y432uL~L_qZ;53-WbeS`)MY&3wJ<=L7+LwO1aDp|Yh;y}{ECwm`5
zZ9Cpc)7&>Im95A2a`x1dw*|(w)t#!Phos$k31|-<SkMGVqAU8YW8~-mI4hE2=GB2)
z5xWucQam-%Kf9q3HN!jFKdMfFS7H$|p#lW(TUp0#W^>+$q`&!lisqOWxV52^Cc=jg
z_<NN@c;cC>^acyNfrp_B4_W(MU@D0UP@%4cg~tF58axBC2*qFxlZMq~X#ahez{>!{
zba7?vWvgOkm%IM&C)aGsG|bQbys5TsS0+;jao5vs=*d+{F3%xFZ8}s~m1qRaPJKGn
z<k(=};PLjeOUvm8;cK%GZu0}?;{RT5C<8MxxNLy4ULJcVfmI)!_VfIW_w5uABP#@^
zhBuBhS;LV&)!Us1hWc}Lg=+35Y>%Zws2$n?_pV)EM{a*F3#0|zfly)}!L6U-)o--V
ziyo)U+z)u&cxLWb*!-iI?`M^HsV9=Q*Z-KpCm-@hvqs``SH9n9r1$e6y@=5hSYigc
zBa8k*%3LN2$~iZ~QdoE%3s2k`JX6^CYG(3K{dm^o!|^}AkgXdZKeCbl5Pt-g{XuhR
zRgwZH=3cd?SjY{xGTGZjbm3^f8%Y&QYNCj@)gXE8v3*5q)RA37IB)+ZMeND4<FN<q
zPqbf&zV>emlscz$p`~}^ipQ%LOke&el1#SF4oNOwt~LiasF9}@s#*ILXd>`(Qc25^
zw^a=)#L^kKZaE^7Ru!pHdNfWq@aP<SXKzh{xWQ3_093t!iGB7{4jl&F8R}F@w&qn)
zog{&fi}kp^@#PK~<?^H!gXrw)spHKPHkoruZwjIR?VfTV2*gaCG(&XrLQisa7xTQf
zdT}>Va2UbOq75}42mH`cvXTg%-t9_#bnn_UFm0uvq0PSSPxM^5ub?e?=2Xd48TRxi
zDS|)0x(2QMnxOQ%TAR1+lo&*zNAw$)i)Uiz0-AGq#BiL_uFt-VO2z&f&#^78_#!W(
z*B;3&9XdNh%J#R|-4Hbpy`P=ib|q*>DxBTtzltLLJ5wKul$?ie;QVzc*XRe*r=Q2y
z7^|3J^OyGm%KS>>1KCfRE9Vg~k#g=c^)8>djCN*Z)QhK>vN_M4Wcs+ToR+y7_+j*4
zY4gpRjz7UIZPS-R?mqeTCxqE2csaE7rQYAr_BXDV!#d_-|Auw0lwJ;h{H5b>c-PPA
z%jci{{q^@es~aSg5YfwZ;vk}*&n+QxQ0(GC<dE#ugs2hKhX+xk`D%6Cs;;xW$gy*m
z?Nm>Q;%Hm13Flt(_}M>H;kJ~S@Xen2pdU0}fBaqI?`!5etCh(IOVGT3^VI?38x>p`
zn)iB{>*cuGDHXxpUcD<7^uyCv9?Hz#T4*Li3ompPxhiB`+<oIM1h_i|XCSger3Ixg
zZ8J2f_O@Rf=X0;u21p4dzY<ir^)Y<petwLXykO)}u(>?>j83|p^tp}<De_PINlQid
z{Na{U>&=Rw)*{UrsmIYfavIWdd{-w=)>Taw<WrF}8Mzt`5Vd!n!Nxn>nuR@(&d@=C
z`PR6KSzPLIL^;k|8h<q*_+HIgFL$CPe97&27hW~s!K$`X4Wxb4bs&a^o#4U5d$qb~
zK;<2CL--kjn@8g~;xsf|L?&|T4UER<rMoYQM7u}Py^mPYo^kGA(VA>OVS-S51TmT(
z0rwJL5x!@A(oshj*R&LQtURb+>uyhO;8braJcy{qj^^?ZmoY2Rlvg=p#q~~_#>J)t
zJyGnF$!J2H{fQ+RUFnokTGIyPeEhU>hp$um2ZW=$g^hce)#}hit{E<@xaMhrs<mVC
zK|JXMP5!Ii(e|bD*kRKyo&r^DpN49|;&h`3HF3K|wI^c8YJEvqGzMyU3ISB^vf_Eg
zjwYF28VqZ%7YeGY)d|Bt4IFQ0v`^)HE8}ZW3f<PsUxi?#a+$?e^<;d~!E%DfCnvyF
z-wB|xOaEV*nT!spgw%f$PS@15u&2T6t`5R2^tEHHaJaAfn36KL`9(&|Cca^oguok0
z=lGBs6>(=E&NUu6$>Y4zs(89q#L`P(NF|_0JjndjrRkZL6gA$=>O6&3R1ir=)n*rL
z24X_K-;qW7NP~=bc=A<AJ_6g(78?NLcB7#hFbnhrMZo39upAc0UuLH)my6^<u|i_W
z6CEux?_VN7grz-pyhXvO>;xa;JBO40iUghZLDvp1t9}z`;8m7%^QcS@Wm30=S#?Ke
z!(fsND+%4<tY!LQ5`k_#b|7D!=wCChPuD&uK<S3|7ni6lC(^8G+v-~n-?ebwIn>H0
zkB>a*DMk%Xa}~SjXGpyN>U!>1M3c@Qzr<$_m6w5ky#dQK<UakS(q@oQ-ugf>Tc?G<
z<WPyeEh*{3eQ^38z!OJS;&odLP`6KU&n{k(8Z4V;vFrOhnasKLm%<ErP$)?0hY;Rv
zFXnYe$%=hDuboG?G2R)klVK9-V(+`0o3(D|hq({iJR8=osIvq%dkt1~=<?{OTvbL%
z*QrmFX4*A#UK%f@;($O2C@-fGrhkNI-`2cpv%Y$W^<8#d_S>kM7Fz9{fhts)U4FB;
zE2OyeIm7T;BJg7{u|Ep;abiKgcZsrP0ByQ_w3McvTNrbYD)HRpmEQ7>gZ8*AutEP8
z@=#6Sv7`u)Nw<+HoThh*_r|1}(<Lm5g$?`Vh4UOiCS6MJZl_(6s)q_O@3fX<)m9|o
zLB14VTTQhQ%)N!lKJC8ZRbl<h>zMYthNu6+Xk-pCBFFc$@nXPV<eNNnY@SpP;#d+f
zRq3@bU2K(#4$_a5_$UJ7>Cj|Ey7zM~MQ~qCEq_4PSNw4J;etmNh^kL7e^45H-nyHL
zPTE{n<o#(W(e9;epX|9>5?IjM>;S=!gQzU{1Qd^uh7-WcYoF3JPiL`RxW-kB{2;@n
zPLD{->;CU<Z58Y&!pyt$&96aLbU><8dWG*HwA`rh^o^Y#J7urCRR8Zl*|9-&R127*
ze92|vpt}D1BeGdA=~fN+-#g}Y-!};Y02Aideh}*-7XOiz&2jk^C~hoBZznk5o>@bL
z@2|;V-PfsmYCiXca!`O#juyi|ciCw8I;`Fo9%zR{UcQ1q*m%f(1L$AL{V4sj+UjFt
z-?4?0C2}bbK$@sIC?HW1b?sxK*_`{f)1ZBn?TzB9rwLu{syHIY=`ji51ljKn+f2Hs
zb3j^v(m%;rI!JE05K7xFRa@9(^{Etko8FkP{m!%Bxbr9qei9`@t)_-~R7m^jTdW#a
z_9U79;(G6>1Uu-1+BOwS?VEs!s@g{+RRoww<}D^mk89qz(E~EtOKA;GHKa;e+Z_E0
zs~dKH_c$@W$Zjx{YQ{)aVP-KLK*XWc?7tj~)>zRNoLEkQ+!LI{JWjG6$+?BYAn?*t
zSrH<5S!2AMSJt=<ULh2(n1ENx!7EqbRa)?>U3j%oy!t#|V+()m;HccpfqGvksG=&b
zMQGz`)I7Sgzm2e?XLJt1&PRZ14ZxwybfZy1h{LVB0BBm97GA{Z$0s&#psQz0Y-0yp
zNgU@4;T|E+(paCfOgZ^+V1>3%8ahOxoz88U?FW%)+GVi<D<<4^80K@7&hDk18dZZ|
zXy)MSpH~*+zi{8KWgzQwYne>ycP1p8e(db>G2QtrhXd^rX@w@uL7m;Z_V>*L>y=bz
zG7|Mga9FzCP+bxn6L!74nIh`(h|48aO+A9<vz_iYL<=k8P<E&JS3}P`K)on(%>9DM
zAd5>n3g?9BevDLb77UktFG(LPKpb>U$lKiJ0N|h;%+pCa2QZV?q9VmS{jlVgWtMZD
zv3~y9eb{LqJx|BSVT`Mz@Y00svRi!m=jqwLGikP5fNL~|-d<j8H{{eFBzzItyi%@%
zzn{gLAC_&tYB+I=t_c|lDfA!8@d29ze#xn22W1E&%cx))GcDEK;$BVL{bj3`sY-J!
z`uv{^Yo#L{HI*<9zA@QkInSxqta_aTxIP2JVxMStSAkP9E8jGE!%K&kMW0e`wrtsq
z27$moV5c@AW>(-DYIP`=25p>X_!mC;vN@r1c!2_)d;_(FTij(+(fnyM)*>E&$#!W%
z>}x4r-Gha7Wrb!b(3E6zqjaL;+9TjF>%SbTR9fU-V^Vdx@UG~*^6=QftD$&U5(Op$
z&y-<2OH_JLOulnzIjhb&^MauwS%(<Y2FE+3C+_9F`BR=brM-ACHW)7(LMjhu{eem1
zGj;a3Lpx>ST1|?_J1^6Xp1rA^PX;x3KEGS=IJDk=d+YU6HtvJrR)T)M^+?*;YLJW)
zyRpMFctQWzUZExj-!>N&OXrFOXd~UAlUbR*!Y~J=J2LvT?^Kg-{KX4DPx8xGST_~L
zQ3+3~b=MDW8)ib+oJSAaj;1FHzfLKEl}pR^aysKO5*G#SmhCwTNBQk0pCv;afAU>o
zSkv}$iaIlV&^ParK?o~JGv#K6CS=R1Ds0cX3=0n3hN*|aPA$G(P?nJod(+JZB6ibA
z`ZSJQx~4wOo<hT7o#vWybV#&1M^5!>&=DA+kLkN_fIV@>*&@u@l9lL8%5}D?bhf_Z
zZ1dFF_LZ~U2WR`Q&L{slJ0M*gC0v};T~3+2C7Oeb+;P9$ZGKg!+UuwLFw?M9PGt&>
z)cv+{N%$R>=1spvapYh|fDFkXvaBoGIMa4K&7$d)v&37*CiuJ7n=qz=t}fa*t}3Jx
z8X}w)62^IQ#x-nhIs`LJr$E*J%kY|D55l-bK803CXJRHN&upSnsc9i`P}2do!~u?v
z7|_+vIsfHw6XL1@v*{KL=&&$7MiZiK>mEm{N|*1`{+DqXo&Gby)geIYce2#HQc7uk
z!+A%$W?`tzm*=D$x;LFGN(t%*&wx9s&mSm6Q8SM*(v4Vh*|p16BTX&{gI8Eg>l^>f
zb~=bBh&PyNqTSgw#+amIMk8()i6epDiuXL(blcAK6C)WhOo?2`Ta}?|WN;xsrM<7f
z9`$lb<JXeQJg|>A4d@a+!ub!LKBRYJvUu9*0BC~>t<0o7K#EjgGLptSKL}^4$K6V1
zPSQ#9t3LBr0YJA}?+C0-&4lC1rjxNIw5Fp+YMLqrWV0y$b8G%J^20<-UQP^XM0~7q
z-@`tanSg;PiWa<joO|;}RdLvz^8*~jqpe2*#|dUOiNx`CBm)wX1)6<7--+;Zc-+Yt
z-FP5i8lYI{bALkFJXknG6o-^px|671SImOn*fvL!hGD#EAMD<yT&C8&!O*@Bsm~4N
z$8E!Iex<o%+Lke33r+x6oraxB4UB*qGTA*Bp&py!C+QF)r4*tjG+Y>ZV(}?Km`-34
zX+xkin@r7!Jm{HB8F$(l64Y-9;z1oLT3onf$00)j`|Z^Spyi8a*o8V8tc7PA;F-jT
zyv}XdgKWA)hk(=|$JgzQm?mDEBm0_O^_$U?JKmWT_o0Z<s<gi7_5)^q>Z5HM6rl_?
zoVj-~PGR0ob}^Hv99J?}o#QtIi&9BHQm?)Hq1WkLR!v<=^t8X(@HnO?B}#%o%C!)N
z24lD=*a0%y>zdud(SHzReKPx$L%%QtTX#8qdteZN7v$0EKD%UT4z)*Wrrj{fv_H%^
z$-Q<x4vLr%dOKBsi=8E>(N3tmET#s0J)LPr`G|kBZ2JI|Gt!(0KP_dP_2-o%fY$cF
z<fR206q&>0w)t}2=r85KgOxJA4{4<~k&`;fwamLOcFDBGxn5+dCMH#L=9LWPOmx$&
zRnjPc@#-_-I6?VX&kpe+H`Cn<ItCz1Q$x4h(~|+3(NEamf9H~b&4H&JniTI=KF(^2
zZ!r~gj+sugg<<tM=%tj6YD#H!`j<)1GlR~q2BwhV-0ATT<5)jv{DPkA<0G`?JTJ{}
z54KR-p@0J`v&K_)n~GlUeMrL4h74&Qd!vc^>F!Nw?&PW!lhaSe<sOW{&N)2UNc5+<
zFBC_VB@CsN2tzgqN6a%!uqf+3!yg!@ZRXOMrNXVH+1KH-1<{!@)jVz%bX9}XVT&t3
z*_ZRpA*JpUJO3!QcHm2$cM>pz>kv+%$XR29_2us7QjoQQgZf_xHFNwH9Z7Xm;-+uI
z=+Yda&lbrD@CHNC$j;5|hyLfE85c2xqJVP(rFt7>FrV()BJ8`QArN8sUeez4o7mJp
z5*aF(6soJy!Y|lI(~{)9rK?Tg4W-G2h|Qus_LI~!pHAOP48_gT@Xvx@i#9<UnuzBe
z&bq8l7=j~>yr)3^_C{up?&~0+V_&Wtz5>KSfxVQ@O^`C9?Al=lWroL<o=vVnm{qly
zVYr^G2R~^_lYy(LD{*uGg`u+Hehfk}ebq{XZ@xc$ITs$>=Ao9Eb&j5WcF1Mx0A@u6
zWB0a`HX&9N8qcvGSywpjEWl3ra41vON;^|LFxhDq9OCbOlrTQD9fVuOv?h_>C|%&*
z@I{@~PR}KU)^-{Pa8tdvA0}7xSC+$<a?+|Xqw&lq1)HI~;IB#J-vD3(Wy)cUt}P-7
z$Hty3!K7I4wIwstPZzQu57U_uhlNw;8yG+5tgB|W0w;^sN~^&eagjG8!_ll?=}FX#
zH)`w_7o$rS!+C{vtQ$IFm`@(fq-!nbssJ~ilej%Fq6Q8IdkXn{`x&ZA><c5`UCT-%
zW-{bH1}#=bKT(PZlHoGXgIAflAD4YqR2>{^tw#*e6ZF}*g@zjU_W_iQ&TeR^!$81u
z!Z{X<!n%5u9P-;a^WnFJ(jn6~UK|l-uZ+Hg*j%03>VlFvkLfJt!hdFXXmUhtXZUE+
zkLklUC|dv=dSuZjkFx{g$|JvE?lW}T2=2bMP%c*vEybVQhZ)E7;Xmjn6s<|YS@da(
z-0Sgm$^Rht^uq1{-&W3ME<VdV=0LgT5M9D#?|mCqOx~YA%aOML%V(MXwhZ%kV6ZD|
zg1w6nbCgtnEcj@$Ca9Z1a3~4s95mZZbyv*R(;L{&%kKUIxz@4rKmM7TJs<uXXkyn@
zO0}bNSv!EVu~TfXVO}TwOJ>-?HUD#<=j5{2iFA@_y0!!8>DR~haSEy!aO==RKzKWm
znqg9wZK|1`oW^-!n0CX&ZV>hRIt7Z@Pd&l9q)X<ZboyV}PjjW?H0Yla^iPcaP8d&m
zRs^U0TJyS|<lIf5$B)maHXv6nX@mi{!}io^acMc1G@_i=lgf6S+M+I@sFdkR_Cole
zSXrXkzwr+J^RAg^Nbh1hjgzQY8pdlZo9<7NeEXBHoW<Anv$wD;KTGL!+sD~D>iW-8
zO<FP;re(_EH1n_T4R?;FVkjkWd7<#n@ASVged;(b8H3aQa=33qjF9e2=a$0fC`HN)
zWC<Sg9c_w~eUT?=mV!`@k{d2mI9Y2OU+CHe{5@Qov%H-(k`>&gH7^M5?hW`&j;fPA
z;%$NFzdo@u0~Sn`%_IKx2~a;g2Uus%inTL^Mw`LEA)X{y<MnipgSF%TZI84jXg(N-
z+|_=CKY#2)t85%)?)8%&cr9`BZ{N&9%kb<B_G<Xig!4BZ$9c4q>5y>AnSp7CQ}5D_
zu|XoH|GRr%6KwuOKCHZkKUnkn+Z^@FdPffO`4!gKoy#Y_FDUehe+GX-i+lt>Kt!!7
zA%QAH&y>$X1&II<%a7AGPP&Pn(2+j-!oJn6a#`%*&@f0TuQ($Vy|nK;FH;^3Z|Lcn
zfjTuVMT>lU_fh(2OvzFQe#dViflGU)Iu(T%uA%Wcxi68NpZeCM%k(&oxv;zlS)o<i
zkW+@Cp=GsMs;x7%*~fZ?SIocf@nz?n(BL1`_`L_J4V~E~jj8M`xz`t1%3P~2w7E+X
zP_=yqAC$T8FC!-Z96Tvm>>2gG;i`8EN27QWm8bFAx!P-u<sq%_8?T@56}ee)Ve<6N
z%8Sd_ZdP61d4Kb0)Je3dI+fR>sU}0Fys0*ur9InJmyZ{{RbSAE%fJTeZOqprPG1d*
zdz<+pD6TU2@vU1oYdQUVuXX>NG@0*|7CB!+Nzc`Njqu|vP}FK{sC-%~TIk!YJ?(Ih
z8+m=kx2JKorR}vLiKvPkXghUu0We<Iv4VDYx*2;(w3)PI@Ae^vyC6iO{Y&dycsOyq
z?X`aLkdF&csCn7*80a+b$gy8*eB9Q3(~m-1<#}!&y`YKRR%3p{i{I~;8<>zKvoV%V
z0v!%7JlzlVFGBR-F-A^}kfLS{E9InMo|nt^;%%eH3DFRbmk9nLY~^0ZcN258+&i;u
zhjuIVX!m52_AGy2`aO{RL39PDsx5EdOBU~Hgzu1s9(r0QRYLDo?f!)v@lRm%>$^`9
zTY?nfJotjx_C;F<<Nq$1oav132yKm9<JS57sM-+LIg=qf7B2ZC`Y7W4yT0;8x5Vln
z+6A<B;g!CNIl*D-%*y_Mq0rQ-&QCXA%v<M!IF5VIv5_Ke^O=sj-0PX(?g2wKq9k=8
zt<U!6(u2yJ$3I>W=HM%Tw-58>^HKFVIzKxHa#MKMN(6CF+|94{Rh^f3+|nVD-L=1A
z^Lfx1er<;fpXY7F=s47GGdBmi`2bz6TWcr9*>+!DOnq_+2>PkME3KKFX+7xTdSAF{
zHC4<+Y)Dmeg8s#h$QeJ3#`PBF57AlNu?--%`{8|>kXp^Oq~Hv*g`Tqh95pE~y3~*k
zJ23a2f^q833^X=pIIaa9eFar<W>bg;6Dv~FN=puh$+-DF1Vuy{f3^|wWJ5$AK=JwP
ze{<H|N&8Os75BT|wS-Cv#d8t$!7HJbeODd9Nk<H&&@7fKSDvnzGACB~YtIP8nU|9y
zzIs(@sU)tQQ{i?Qd6lF%khwZ=e7}isUwq$WDe*3?)oOYV{%QE6B!}Q{rgi=|N3NB{
zUa6lXH*<;(<2FSWz4qtKh{L*N$#A+?^}PJC05FtD#`C5toz8CZJ?fk-IlZ0mKX(1o
z=(%53Mog-L?(HBuGoQ_J*6h5(i4VlOpxEOT%i@Yf%V_$8g5#B+y%de+K8;=MJzlj_
zp=k0Y==J60<2U}yE1LcN^g8LA6;~97@QiE;T{q_Aj&dO2;xF_TB!o*xX3_*Z7U`s7
zNVTX$v3O@eelkOrzuekZ%e^!IBBGD;NhnRnLz@v(hQIcVt@hzTCxeXX=gGj5zUX~E
zWyW#zh^m!VT2IbR#}XP-=iLZ7j*mV>N6J+oeAMP;=q8<z3bPL?RrL<sNm~S7Pb~3}
zo%+yacStm{a~M0dV`U@khjzn&6xOvE+G?9r)w+NeP#F%|kTeo*fN<mTylIgT&F2x-
zkG-PBh&amd)@xW0(v3`Y0#>;eEZuL@PKG=rPcv(C`PA<ALblwK<G;eOlIWB>Iy1VS
z@ez$0Q2b~ysfOpVe!5mPj%)DGU0$|5f&iK)Cydl5c$QBiGB?|6jkn(9$=9#vK}@(u
znQz29EuvbS;L*6BY=>I^9OdQ9MxQN^|5J94bMilUD<K$B{69<Cat@A5V2t=l6AmG{
zO_7SdZ{ioc1}R>g02{0>926P!?clFK1^<eCI>Xl&^TqprIW_1gr!Ed&KxGW`MSPi(
zYnRV(VW<Il<1<?5)}fQVH6l}_jKOiXayvs=&riY@z}OEIi#J&uKJ0qD{s-y=bU*P>
zDGFfCE2W9U$S-=)Oz>QUMVOi#Iu)XIb;%$0(0zpq&?g!_mZ6h7%{j?45+`~WOJ}d}
z@>~=d(i`$D5;7t*uxVPD0^-!DE;&g~4s+9yKO0ync7Ud#TIIqC_<@1$!A@%mXgnvO
zpYZz3LVG#AI!DsS<4Q!I@=u)#lu>cdgX#lzC0{K>G{#?&mHq1f0%!6~VKarH^@AmN
zl`yYF*VwI?6uWbtE3<~8zwU`Mwb9z0X}2n>^vVH;oYE~>sgcF^W>e_wtLU&izbnH<
z*hej@Q_CurcZLO~-MGjieo|LVElsO<p2<+k7k)_!J_8+nFLrsJX8dY9KEK1t0NR&T
z+8XuxdZH^;R+G`L05$i(C(RmRFv89O!PEW@NAUEBv8a~bj=nIOdy2DqERzwV)t%OE
zOjSf-NBZ9Qenf&%@cU36O4qk^&{G?z?9jJKt-y!w=F*otKEHT4Q<}7OQH~z*Qbx!x
zBY96`{JF3+u6^vkTd>6eHvRY;LhQ)0&1HEy+;Hxpzdnf)DnL9!k-s!Tq#mwtN|`MR
z7|Sh|4=tI3IQk5A^zwWZ(@u|BSrgc$fS_&KwuzxJj=kniQuRtf*vEr{k#V@DW+2a(
z%P$ZhV8b8i=KMC7;b$h2<3^PPyeV4lzHMo8V<6si%nQrkJzdGH@h3taFUzTEuZMwo
zQ{d6Z#NaC@(V_F^w<~U#=C$Z^$5L`6pLg70f|z-&jVm2~M9&-d9bKblj_FNWz>P3p
zQ9t|VGm>R9KK<_W$sNA;@BQN{X>?)!TL*7okgn_n!PSE>RBoW1ZH>)al(K-C;Kr?{
zYEi2~-Fvh(Uz>D80uK6;Xnm$r?4SH|yJ?vFh<?c95$I#{hY87^lro@qF`JYuhDnjd
zvWsi-O${YS&4?&Hz{yckzGdF9X25Vyy-55uXVq!y-NY;Xi+p&WN@A~z5`o`iN#O3V
zwoad31&<Mc5lrzB4j-n}_r1+r5~-CgEW`g#KufS>iT3)4k1UB#`bf+!Ni6$FeqNH?
z@sawoB*pG)<&KkZw;`a}#E6zt18^}!Mq4+VoPMtmg-uRF9H)cVZaG6R_LZ}*m38*T
zsBn1m@K`dkkR{7m{P|)0jF;j|FLPw9#*_8p%=ODs8r4#Ci?4ZB_o+DdfJWfz{GwIj
zcpY+|QZbQFH>Khq;fp%hnC3yi)M;zWDy1(wYrX05qRGb;5-ENJE26U<@x&irBIOmK
zz)vB51y6A`C)z~^`PrfIq3Sdc65OHLuT?Lb-QR20;#x_=X;W+j3j0;NbI0D22%+}B
zwZOPPAZcNLZpXU9d8Zdlgav(BH7bjxTE47;?>Arfo1UNi*D0eB=|>tYu=taw)Z8x+
z%5CC)RL{bjO(uIwfG`xCaA@xiq9%L1*Hp8t0>B&B51NS+tlU#PTS`0~@PvAt?EJLj
zA;Iae&&k4HX}$WLZHYPW=#PN{-E<x!?vMZC8f01rjbZ~%R0SB>gAGkf3`&VI&S{EA
zMO!fN8*pfX6Y?o(1;wReuQ)vZfpii|uz55L1}sGC5m7#4F5GB_Y4mjsP%2zSeR8tg
zd}ZMks0Vd2kB~dpxNKQbOB{C&EcI_<tm6|Jt$-CXN^&X5@pL9PxP~4noTBM|#6sg0
zQu1XNQ?&UB$GY)yR1`~Q3a`x%G6Kt1iuY=7=7jLeTXo|)o;o}8_Qwq1)w@%|HHgui
zZ*d8}5+1U9G{vc6*>`C-J=4*8cSrRu*~y=2aE+>b*(q-jxc0B>X5y8GfHB3##joY9
zXqW!nG+f`%I_xuX#x-tA;D=s(*TG-XswOP)6Tk%TpyV4*3sVJpUO#m*TNu{e1Nmh2
z7yXzK*CqUcP&1z8r>N8D(|(!DOQaMz)%aX1PPFQ<_cUWQH;;I3nKB$eRR5=xUz=^0
zDQEWxv1r?9E*hjisbnBJ7FfH^Q`)c8<#tbh(B=RI^!I3crBc`W40n?wyIwgn@oEQ^
z^gV7JcXI=*2g`8i`n&BJvz9)s-Cq4Y|0;Ko<1|!(pP<>_XNo=TlGk9=EH6|dTO;{d
zu;84ca`W)~xoPHxd6S}fTtmG_VS-_yd37DqE*N@7#ayWwUb?2A*YCd9ryI(~Bb*Z3
zjRe%!v1Ee8-k?A`(dekWunIATgJJ4@4T!$G>ixQ9mfq``87WF(;`FSP<-pHx7j(V^
zNTS<<-Bi*8bFZxCD<~7-w<w<}`a31&fa61pe&WJw;@K~FwV;AV1%vc2QUR-v!ifT!
z4woXEJU0;l4W~GsqPb;1yNd}w=&`(mZ?%16wul2LP$Rm?__hdDV9mH4_YSD5d7pV<
zIi01uN&q{pjDK?Y6nb=H6UrVt@pgCPN>#s*2@!r;MgML<eBtM&aJ#xFKLy8T{oat9
zDZ%ls{qD^zf=G%LsYi3sElxL8!QaN>PLng3TD~(V=bWZy2cztz%9Ggg7gKI-mM7Ju
znpH1EZ^>rNX5L>;FHly+d{%n!tRkpU{ba?RSzpV?&HWvm1?R@@1m0DB99N$|`PFjA
z(K_%80ekE5WZ|M~eN(q;pfwxMK{Dn@Myi-J>k6F}ziZ_X1UMA7F80_&<0ZTL<$!GM
zE@hD}uo_@9`_I2}_0xsfbX_3WMep;_pkj?-|Ce;f2GQ|4-?i1K221AF)?>AivozM|
zAB`dQ?*@lzCknTIG;ZC8-y6=N6>!cN@H=b!+nnDjj!_4D{Q=2r6`L6k$M}Z>BnR>B
zsWTloo4tUUD@x&VAuj0(K?`9Et1thmEIs5dSO`|NFeEN|tao^*T0?IgLi0MERZpla
zEv)CVmhTk*3A3Z;$vO|Hu4ePY#b&pm;t9pa_p)?4A!6gnp2mG`Js!ZgH`ifmH<&6I
zL2z*ht#scCBex7fW%SAyYw^VIlMz%&m87cB`dWo=J2!WF&#f**{P0!bIfvY0zaM9R
z_q&(h>&CV1X`-kcJC3b;YM)^2m8IE|A`p^{wVn$%P95w|IW<3Fwpu2*3SxO|^7|vf
zCIIr+zf?tViW)a~X3$EY8YfzxEaC`~s$=8LrxlzANnI9}YRqoen__!;?9sB4>|gc6
zD`3m@uU2}uik#%;2MgF0nK_rf+}u8I85L!b5_OPbt?*G@uBbn|BsFo{UY3$cognCY
zrP`!{4A-FIL$bCrvn^}AZU+QI{x!3*bVcBTvH06hy&Nx)YYwg+q0Df%A*R&f-IlVg
zE3OxAO=%L~$4J;ny_;*?87tL+;IUXagLk1dmp=2>aT&^fzo}unRY?0Bm-c(DXHiof
zw@1)2E(m8P>n%$4T5MqxB3<@CdP6u_3{4b_73h48JtC_a?CWncS&Ci@=HDAa(PbUQ
zVN&I)+iE*XSE7saeA#3zI`VdjWnUK3TS<ps4;7;HX7Ab9v_9<RG569A=F}wh_eeYV
zUU{4>8<%3g<dTZDl*9xQn%E@!&#p0&CG@M&mVu+fTE2S`FBWbZq^|!zqTc$i$@h=@
zJ{ODuOBzOOW2AIR2^*a{Iz$~I0wMw;Vlp};2GS^Qw1_xT!jCdQ%3vsB>j)JQ5dl$D
z*v<F4?)!1?FF5zZ`8dwk>wUbRPj4G<zo+(tQNt_w`F@{U*8gbw?>`;zB28s9L&?*V
zxVJ6fp^-z=`nRPhqp9V<uU*dKD<=Z$j5v#jMY^3BKWVtlAf<%hJ)6M>2_fd2AvOu2
zE}Nk`Ib>{c5wt5Iqp2yu_E3`3cYA2~_0y-ze}2mDF1p$sG|n-GKR2OUyS>R!4YYBG
z-aHclZJRR;#MNluGQ6^Ri=UcxT<Lh)c40ib=VvTG0jO3fPHaCbkV5@YfFB*XZKn9?
zF4Nvs^HRQQjY6(T!zsEx{1`vR+hI5%^=IOXMzIfF=Z^pURAQXZtUv1wGQB!Q3J2kk
z!)NA3P}V8BtKuZ`;QfH%7osagYquQ&7WU8EA6@EnI`uW;NxUjL+Syn=R)ndJ6AIkZ
zW2FUN4^I()?ko8?Q(qKpZex2uV|}lz-e}FI^O@aVUq{Z0grC>>PH#Pv_g(6;PP2ul
zv13|f<Z-WvEl8`ogTw`Kg?0O1Dgj4KVPW!vx-mmKJkXnrOac#l^3|yMVxfm&ie5~r
zzE_HPFGy?HT8SY{;->K5{#5H=ccm%nl14lC-|0NM*;O@UJnI;t-Z&q3dn@{d7T3S0
zH|lp9R|j(Pxo(RdT!M1GCp~*}WO_T5kXsNYZKIDkYVoKp*pKqr@4<Ht<V{g>fmWJ+
zr=Yy<lYNN6U_6-G+4!*g-1Nt;Wn<TK*H1TO44ciI+bgB#d-K=jzwFkp=Z0RHy(l+H
z2h{S87iSrTHc(TtA7>V2I^X&aZA48S@d`TCnQzsZss~LS=!BeZS|v+Ew0qopysZly
zePoAItp<jY@FwX7zx%D$)JM<L&KndyQA<sVvwWfj@O28hO}pGo-rtMQdAoS^Z?XJc
zs8N<o#YOmqEm-#PB7RuU0}=vSDt{QO>th)XkyeA{tf%Sa90V>Tk8n4iZl@Y2rXE}j
zGy2>bkfChSu9;}lJT}<lm+-jlvxRtLRD{&+Z^2!@I?o;-s0tT6pHq&%g`3eYE^>)*
zu|KF|t!YYeG>;b;&?!s(?lrrwj*_^ce1N-OVKr73jxaNEkSL$pqkijZM{o3p`Zuzz
z*A3!Mp10K+zy6MI>MF9T(RY!gdgl6`J1iw9=YrC%E?dj+Dn0&Cl)Xi`o7vz!R@|*p
zU+mF#*Oms%h)d|@1~zCXFSX(MU7e9%b(QlMnmf)UK_}alCr=48Ixe-MZ(BUO@TT{7
zUR2~+qfCiq5Wx$?$5Ll37q7*V`x~ZZ>#%8g%lQ$%AzF#TUKh>>2iTe9rf#@c?F|pW
z<rb}VCBJ=U&M6CwY>0D=OyoS<_}y=$vTnY0XX8&u4;$T=+qq}!cyUrq-c;Uim*Sp=
z@R8FH;3&wpABY40`|Ay*iyLihK7e58xM4sHf-kmqzucW9ww~Vas0RR-@v17~PH{C4
zGL;=tqO#j-#!FR#W;*>nkM6H9ug|JG+YvfRB-?C~nngb!D6+H?J^e>K((8uj4WF)a
z632aRIaNjf{PX;a3p-@I)abmVmJbo|fzcOq2AaDgt||Qa{2c=j#qS8{`iPQSfUn?i
zA)e0F_j}&+|81ZDwdza1cpA7}|NHC8?c--IYdtqVGZ)aUYjr#H@7Wtii_TNpy|rZH
zUp;Gaf07|w)fCQb4e?!(7d1LGJCrT8cfWC>+w;-P^{^eebMari#|^>H46y$ted~5D
z^RRQPaNF8(_plj>0ir-TLITu1bh7%Foo~43nQ!hTZSnT~Q<ACPcW!B@{3qD4&N3Rn
zhg{p%jBsmuJzO*PpYQ?jxOGl>j`|=YPMB%KW~4+6H#$eTHKHy$JE@fV{K3?VHC7dl
z$ew^|*c83($KI4My~`NIr^~Hr_^1#w<$D$*7VgXe(hbZJl}OF<>_7Tp#vC|=Ry?u`
z7*UAme!~|54yaYCULWBKG4m3^Sq{i<*tnppncCpvj*n|s9~&dj9{)P|6i7!NU_0OZ
zLT!THa-&)&D{UBl03Y?*OVs*L-1GMD+*^~b*}|P32khj3j(Bg@!mnA0R<>pxb|jv>
zt^vVxNR{MTG!ltv$<M1SeO?{AmMJQmE|<T<fn5PIUa11MUMcnXqlQ=6YWTADRoiQZ
z!;*###&X9U$_KrR1FG-d@_EC&Yo|6M>2y)*z5BD%PB#(>fiK=)`03^%Y=Vg;iJEL&
z%|BrKvt0;j_L?qaY>eT|i_8ahM0#W>NpuC<@k0%#_Bp(fT41CvCmwOE5|{Z{?EQXX
zwB+XlzE98T0|^zMDo@;#`F!>C%m(k8!((YJ=0%0d#hN@z*$9`fZs$UGH#rNxG}TvE
zE;ZlkPW*JU>wV?d*8g^7m)Q>#s+QXyTjIWTK0jRbt^3_2+)B^K>Z+B#Z})KD@BVyW
z_5I%V4sLZoK+)pno<(@7@npM#1jb>RB)2wp?VriV%gSYysHl60%;Ihz&WJ464*ehY
zV%t_@M;lh=;)c6+(nZI{^>mrdS|OI8vX4*PCl|&_iq3}<|F(`Vd*8h)vNe7D$fc15
zvT^URPiJO=uO_XuEeP8}W#P7NrB0vzepmW)OzfGvYE|){j4iuz+RPE#KfhV2e~wms
zDZ3s9g{<;Jl^s={3YbhOSsz=&3SJZ{NDMZ3Z?XD<eCKpC6&3HVxlx<Wg3^tmHLwJg
z_RBIyYa|n><Ah*rc9B;QcATBDw>VkEfw~a?P0v=ZQx9RD_*k4Da|L>~M<V*f*Mq;D
zu{m$;L}gg@wv^?diIleM)h!Q%|NIb?5-rI%gKrSN?BY@s?p_)E&j!c(^576TuAl_|
zU3!FEZM9gK*(&p0F_W1pQR+8(Bg&aBa1g0bHZ=M=Ek|4aO}V_CvG5w)T5U(^fZSkL
z-bHc7p{Gs`K=5pJh$9JzqPv(!QF3T8sW>T%YnRqyk>SguGKX9g)%lz}DN)hVEN3i}
zX3MvI{c17*A1QNar0a@bN(<^tFH8c7MeATw4s?aPs;WrJ18gPW5W?+PXIq)?>p4Qc
z==(zoUTM$rY)VGgJ@ha6@Bgrz5tlW1<&<u?>42>c<4HuZ>9Mlh?cekA;!_9kUZQX_
z)A_6s^+A$=P2qhtH6XftY~Q6Ia@|#JMc}HV&L+sMRf2_#GZ|JH1l{!J8kAbJWiL-l
zIK^jsnROu49QP@w2kEXVZur@&pmxt{aSraJGi1Dc{ZV*ITIH+w5!tR;c$$T6;zbr*
zYlkA;_Fs)2Hb|YYU0$i8wY2|&>*rHU!Lb{`EpR))7T>vAonrU^`&aK-Pql%fGe0Hm
zDqMgpL8PGkwrymOBswA}9+xjf9f*?u>EL@$gHp1jRz^0wq3zxLfNY<2EB&#!IfUI1
z$IZ}NWmrS6L+DO(Da6w>nvtReokAK?j1fvN$q+2^Gc1W}>>rgN9d}^$dfHso(rSo5
zc(7jPC@}&#u;;aYK@!<1dr}>2lCD>%%Lq}56Nt9{B5wcl>d6~_0nL|B*##G+$L^eV
zjqW8Le0l)8X)=z~DSXP#(p?n5M&vl0%c5rV#}~Fw`A=G`Vc;jDNWhHNh{+>csJe6w
zo=ZCcRu?+h`ejZES_oEnI#ur5awoZGDkPfF^qia6V|3WfrQSF<h*%NKCw^uYgi6Lz
zfR|qsOZ~pYx(XB}#CtWDU3D~H?7Y6uHSM<ekFN>0yDJ<<YAyM6`!lX`R)L2Z)}Q0B
z-!6GQ%r4#=-VwD{??<T5W{05Z0e(QaA$w6A)Rj4vAz$g3m))}Bl6Q7j<r<7k8jB=0
zfK^}Q6CU(0)Jl85Y`=o*dJbd=d#$8Z&xuMMa76y`h&6$d<gl56K5C9f*btcpoVXSj
zgifJDPP~wW+3eDA|D_r3tfpW6yFF%7ez@y{t;O+!A7o!7zB$@@_TBL#H*Zzkm)vA$
zKkllRz`Yvx*=(<P7j?`E_j;;yv-8HG6UUF>-n^RG?CyPc;$+g_Jsy0#jVxnx>1G9P
zPr#GnKF+)7E}22u8FE{G&eU$nJ}*DSoR5!;%{vy~Co{uNk3t;kvfWiQrQ7$!i?2jy
zR^=fgrwj7cLy^T~rF~Pqunw<%h5Hsq=RyfLrXO{^Z270_sh0G6;=Xa#nHKi|**}X`
zEm%RL1w&vxKi|mMBey$uO7R6Fuj1y+^YjmO&E?K!4=Y-`yaQ^_i3_@$fCo_eu4$4E
zl_=vyXhH7%R11QjZ*afQa0~mdNBGG<uNyPqM-fEe#j3+2)wvP#10>`+{j$~Do>PEo
zFfnblh<nXLDBvGUI14^vT&EY46T`wj;AQA*QsP^Gc585cEb(hx2DccA_pV(T{1$C=
zB&Pd%b%aG(A4ym=E88}8znJ>9kqQa=QP)suCrNYalfnYp+iIdYf-EyZDLTq5JMPz=
zlOy@?R)dMvgw5UdZJJvlR*%2f^y1Rvh5f&Jc>93-@Z5Z>rC-^PY(%_u8+5N(rv=;H
zka-FxTZ$-ohwuj9gXl+IQH<nj|K8vNt5eoGfKx_eHyU&!Lw1L<6ly0tz@+pL5IYWL
zJ=%>s9IPb8$~fd#6d1@kkclDyJ|YS#gQvk{X@xlv<CInHiNMPFKlB9~>rj}E?F9S#
zR)QAj3?rfsO{xr6goRrz?*bITlhvu81CkZ~5oC+`$)Ab|i=wUP{>_%CvD#H?WQ2p!
zPXXjp`qE6@GWolv+QT@}dW6$*$e1qDWpX2ti_EtF8R%lQsUr=Lp^yQ`@JVq}w3Y6x
zboh!I!2DIs`IAHY!2HrWR*N6DpJ6l|J`9fZIr@j$qSjns7sog>{S~=)>evMaQ6nht
zDM#0551>IYOVk!eaa`6YB22cxKJNAorN;6*AqUXjA;^soq)rv$pjuI|2n0yo)E*5u
z*+~Cw;+we3WQT$3S1>C}DE^!xlm%XAo#G{1M1Mz{Qv)qy6p4^S<T{-?4Y^VKt-)JI
zbF%8LHk1+d97?eYr$)q7YlL|$Jv#q@NKC!FBhoApC7#8US_^Ul4@g)E0L_AQNdbU3
zq^JhDIS5-v)K@4xJ=>CFsG^_Zs-m#>>CqgX#WWqaGb=M_gWNf0H8w6xoX0hW%)161
z>ej=Yzb!=-#;DB6|G{709FT4~e*97mcCw~TcS_~3mRjD}vWciVWkh^9BF|PAIWw#{
z!-8%T<j1~=^9kbMdi<$czj%sL_JHe??+QFH;?5`j;^3ldEi$_hFe(~)t*bsC=cP{=
z7yY3ahz4HMCQ0*hEgohxv{<6G^bSG9Dt#%E66O&sPNrHh>X)aZ5xB3S4$h*=bqk;7
z<UV>BP%^Y~$S64u7S0DBjr=w=4Pe&*#6VbeZmMBdjS>2UL5QdE8+);1&x}uYs0w2C
zp1HF3<|p~{VkW82!kt}BE<ZCV5Hr2vX<By0wCb7ZbuqJAPqW4=W;Z*c06a2hm3ZXT
z5sjznbz~HoBb}2hX`;4=eB~(~gqpKMF5>46KN;lkFlj6?%_8?!JnF4jwF=nk-4&7<
zM^bKfspSf}YYtNb!tKY9T4~bG?4?}L#DzJsSm(3$M<~BW%f~e~hRLU`M`Z_#h|L2+
z{x=Nj@bAsUowHJqqF6aQJ7GhD!kCicT?&giNF2aR?(WGY#t~J#D5@#QsN|*4c)3+N
zF~v}BGsG%~Urfw>q_}$;i+DNL5)ss|+IMw;R=h0LTJ{1KXf7regS3@B{>@}@M&^QZ
zlGSlacIwtrD|2!gv%C5U-2s|g?38-<fNU$}RA`}>Ur^o(SV3h~eFKcr&;(XyWhX{^
zpGK`Xf~D@I<%02wYDxgnh`P=4P^}SbA-L^;<PqV{4iahr!TyTtQV#uzvk>Yvxp`vJ
z>-&<l{mLHEIT0cUOG>sVc32>}qevWV=>vSs&sghJ!r<&a2u)y}A}bdp8uuKF(bSj-
zQnssyFA@|-D42zT>dhcgrnT?{Q+}gX<}FhzSi;+BP<)If#^XI`k5QC6dFYK1u*hf1
zEDilou|`%?tY(stjuNyWa6XeIr{HaqQ!fvfNZgE~iTJo`ozz?%F0Vtm365y5f>q|2
zdWVHbg9C%?nsXM8UJFb;au9Khskipi)8mU`6NnIA8-(mON(>3w0sW@dAXl);%elIc
znPcj6m{QKqN-XIQt!CqN=FV(JN<z2{<{hG5`SAX;y2+Bu1N%@Q$$z65S`cQHCsWEo
z)sdw-S(4h;V&N=Q`)BD+mh?1Tv?|@Au7tEYFiH&;_{CyI4Ps*`GC3?M8Yhih^D98y
z#v@DCZ!F!>S|sH;E<d>;Ln&ty^cxyvCH-6-!@_fu5ydGH_4M#O{+iNTHN^?E@*2&`
zv5a_+CciO{N}4(Sc}fd4WRaOe{3l52JL!7d$Rt-ixhLHCo?31k8n+TeYz6)PH%n>F
zl8oMTvy}+{UUOO%ESi>l>{^g?8bvx%A6VW{)NWDfr0ao8<O+rlxCcw=OPo<7A~d4%
zggs3%CKU52s2Psp93i-R?(jNG1^dl_c4u9|T10qLaYjrT+@l9CC#~VTJjPES+KW=J
zkx;3D<7P>!DNm#y&V?EM)xT}?8q^P_Gri`RFKw*er<Di?^In1mb}`b;$9x>Y*o`3z
z^}*_8(UYpd{^vo6F<R#LGel;x#RNzC5<z|w^jR$>K!`8pXw)Si!x6s(DpuPiR|ol?
zVNo`NHW!I#MsCUGr20LwXK!1bLXQf)=YmeYMHp7On$Q66N`^=#98v~a=pxH`xE0_0
z12&5aGkoo^U>9&@ojNHcQWr8HGY6anK*CiIDeIusZo2LoYmc_^xvHaQaYNGKgk6NS
zBV-`N;HRRQOmmd+zPOVYAox)Cx!q6Lqm*EEWbp2*yPQ?~kkQ!7v|inrjorshN^aJ>
z%8_!icH@J}Pk_Z_AuI1qXjW&43Cg5=g4@!7#>bb$${!KOjUw9~-dZyTw4Eq9$@}N<
zh_NB*I%ak=v~rX3Iq;*Ra}jawtKxzrX@^g<vK1q(_&7P;xN;y<{=!S?uwoKS>eyE$
zMOk5GdvVMd-eQEHcr`~`lGC#?A$}b!x-|4NdhnDCTO}d=Q&CsN(34uqVEp<lrC5d*
zBqg~rSCWtnuagLfKC|*t)a}fjE^8tqSz{mz|En??-p$hnKtLKtkx9CqfPV0gQw^aP
z1raf_Lub`f&WCV>>v+P=15))gP0D5By~SddOP>1N;s5HI!sm0y{zYGEkhu>PT|tXG
zpw+8$C08m9&zV-r4#`?qN-mq#QBp$rl+Ui`oX1T7-Q<!dEb~uVF<)~*5#F9=&~cAr
z%=bCOyE1^8l0Yxns+9?U(hFzu)l<}KoP)n#J1VX6hiSPG;QuSNN}Y(_m_Il)o#jN#
z4jL532g&(m%X&N$&N7r63z8aQO-&36Ih-Lzu`KhY)rdh>+UM$^=ZX5Dx*%|$d8OK7
zf}*o5yHPv=8I-5{%PF*s6jNq?2fQ~6-xVzbz?F`C8F1?)G(niCE}r&;bCV|<dZdpS
zCw%vu__>PLH{9p0{8vWOHbz5$-Nz{Qe5C@X$ZWFo_A~St{U)tV@_s{AOR3}ZV2rGd
zSi(@!Ghlp#lSu&&^C`pEti>3n{SGA+A~xy2Sh_c9MTVD2Efvd*5YhtKO4wPrX{Ge~
zo<0qn0Ej0tHZNSq2Mkgu!p!mWmzi}Re_xxIR9Q4tr2dWeJx^SuTfp^zF+hHEep}6&
z>0Yyk$1804>h_&=CC|n@p`f;QL#2D5|FC;tfCVrTu9z#SvKly<O_U9e9QF+~yU7%J
zM%Qa1AbVoe&ISF`ZR(vU<BDx_#pIET*2v;n%(+3~moF7DLCTvq@9!KZro6zP`=i~B
zZ^}HkL&YFo<0W~)@-Q!vK8)B3SWNWd2bG!|{Mj2JTOlGQZfhJYir|DxRZzqB<r1bm
zPZ41VaiYB?F7@H|7sZz>71d?w#kZP+cf`WKVi>t&(ZMpBvMR)P+-=Tdad{%60s~{c
z6XJOE@{`}~{<KO+JNT}*zT8Fw@wHbUuq_BU#OvLH;uFp_-><DI)>aF>nt$m2FOzYa
zIk-BWQe-aiB?q@jAm#)qYFAn9#ofEP;=RU+ta|k!sNM}S(D{oq;oYwi$NBJ#HMzsd
zgU|y?yngR6EZ)x+F4ayVvzd7!erXW#aV3TQrxmGEYCKbU-UZ^HL)f3{)eyYXiNwt2
zd)i-ZeovQ;HeC8}<C)mXv?4Em*V6jP?cWhqu&ruvUeT5&m%c=v%lEbseyR!Vg0gjo
z=H81-0X$*onlJ#+fiVU3LB&oG#!E?hMSKD>fb!V$jglg=0@`!`g^;Jn?h;+fHlK4%
zl}P$;m{MhTD!);F$Lw>%s&;o!%@?p_Ddy}VM>6HFN+qZDgYmLz$+yu<?<g{ekJo;=
zTdzcIe#J=>{>Rj2y|@{bdOKJI3=)-Ptvk($tkMy#`w!8q(_>l4X}aQN8{{he)s4Al
z%XrKj?e;S~cA5Dp9fH7s#E7$)f1<l<6kl0{t!H4A#ZSfNxZi&j@nE=|Bb&)dg^Otf
zj<I>>No}&uR~_4G9$c0-Kt-iK`EdWjYjQ-LiEx!w!RNQRf#dD<56g5zCayYlG(4^{
zIkoh5yrXflY<Z{ak5gxpy)I{N`%R<P=dOZ}uIYNtUCqyL`gKIUo9Mdvf`8j^b}Ln&
zJL-vUcDVmUw$lrIN6h@hHJ3ZB@A?xtBSIU>w?EvcLqrr@d)Tu>Sz>z*Kk8|lA7v=H
zRJ-=Je|%VOaQywF-j2_cOq<IJZhf6!o;7*iJp8z?>+1`4$iwQ3UGNG+k$ONa<qjNB
z?@Sd@+<(`^$7ZIrLf@}m+C2GN#v%1xg%#HCMfI037q)*Jl?H@%YQOK<T3>v2^Q7a*
z%h9A!Vdu86)r!*Od-c%4N!+p9sk2Rmh0)u$j`5P=Dr1%SZ~x{CttK$gfjGXOn1k$l
zxNQ#kIkwHt3?1P9-i?z;%2w}V&%0+xd+)7D(H&8n&n>E0!y3&GI57C)^H4TQ20TTi
zn#wJOJ+k}`D)ZFgzrAt<`vxzxV7E0D{;|X_EL(~=arZPb4LVEU>VWI@3amiCl~k|*
zY0ljewZF_Wdxs%NRzewz0#%v+QXU&|<gACu)x*IK*lg*c$GXvXU$QQz!f1_YQTLiY
z)|ZDhN7zp<ns7;=e@a<o?y><xsV}|liPe00N@((4y$W<PkPH6Y1i({Cl>1%;Dz(kT
z24fM&`}HPzbj|)|(RlRIatGHQH&BK}b>@)4W^?WrKrJ5c^ikm8>{Opc+s4c5+Xj>I
zL;=Q=J-1qv7^>iXB(BwTacTp*==B$!%pIS|8=X+8s8#;CnM4h$F8D|HlCh@%(*>Ik
zW$YU2!-))W=aJWSCw+VFpbbG$Q~3qqSyChBpkdFIQxQZ_x}+-Kb0J#Jr&q7NQ(<|1
zk}Tq&Md7?eko6Q_=^fP#9~K)h@y6)2TKRfqdS>%UA$cA<i3Z*Z#&`7Rx^|YafCVdG
zAEO=7-lkd?gNELDPI+<S*Sm((6Sv5112>KV(uzdto=N!hWm2A6Y8{CI%zf}MKB$>@
zwRAyjKvDkw&jJ$2LJCP~Nt4a2+xn5)@%G`|tv^dGM~pYfp62CG;v@ftIGI59EixbX
zTv?pbxTcx%hRl4a`H6hG&QuuCbTH&5t$XR6+1>vadKC8c<+0n_K|<f<2MCUX>WRRE
zG}$cO8QPV5M&Aaqk;eS9%L{E#LU8jV$d|22f}O=)@ywn#Bag+~HA7E)r^8*Dfrszt
zwf(CN@WnqhpHOB4uD2o~SH^oa>@dbJb3-B6QmfYh&{=5bQGv<QhI&xaTy;Ezb6JRE
zi(<qk79x^2V#Q>^^x<kiub;C%m@1I*QRz~{!{M73)_eRbTCE<#2P`A8z@CA@u<Kvt
zc!SK006&y`_?UkOoMg`{M)?@J*2=!<5%pMH$xCs8m_02<m2N4?2QB;7k9a>oMC!Ud
z6LXZ~we<@=fS`VAj9D!vXJQ2&*=_TQXc5AL5$AxlB9W=#^Mit>qo4ugK2b-@3B9}5
zwqT;5-35`8)^>?kf9#cu8}b~ygEUf8SA%Sg8o@v=z5hMU-7uI*&~<tgEc*-}MYNW~
z&t?V7FB}P&1uLv_%YwFSq#|NcZ;L)13^})6#fx&K9>zY2t6aazIGeT39e<M0_e_T(
z^v?XV)8x5xcBmvEb>FY?$xDCMuLH;?vY<0JMRtP;cWbhin&4)bZLlzhlmM=7{YZRM
zDnt56gqnufUfnAqzBCo$?3}v;-K!4krhW`XKt?s)!UycGUufRR4~|D9!Tc5W55(jF
z(nSADcO7+8JJF5VFhK9x7rs^GgkBkZ=wvosY>2luon%OC=9f1+-*K+cm7AwLmmQO+
z3&KPe-#iFcx2GPNd*teO@|O54kK8(@Kb70na_s2%9ywdMg-Q4|AE6P;rewx{e`;?h
zeQXX^f@CGeJU#D0ePhX<g&D`#;9m#>>ZSU*N8n1**A77g59)gyuxL|;$-%YOl8vYC
z7PpsfJBImt2$47xq$60u=k2p+sneT^cOHKW&U{nuok)^h0Is|p!_v>#K9U3r)yIA&
zur9w3jpuV;zG*QRU4h{x`6d<N<zEAnUk)m<LY?q(o#{jq$6BAQNKaJz;iS%A{|!Gr
z8H}1jjGivQU&M@QL-~WS+MOX3h+XLJ^y1;yfEKYq@yU}2Z0_;!TB)pXcC>7=$WcVC
zR2%PVUHqx60JR}gI|(;MS0f%EE*%FC6OvntMJKmJ#tR79YPTjML+FDTD2tu0=gM%M
zCXRqjZ8eDmhW&If#$#9a(@8*(M4%Bb$z!?4mur)Fe)nmX2nd8eF(f=JgA#>n<n>#b
zWjPj^sLxpK+W1h;tnicK_Q{<CHGzi{4tOwOm2v*QT=HO88XHxqnC4vS#gQ43_B7~W
z*B-%t$-@nuBK-WfCkY;bcdYtu{4W;q%OYIiLC%nFS{o|qk&QH4VdO&=Ji^J->`{+O
z?t8fP6F!iJJ@B__CeHYwQ?yBNr#5B5a`CA14|1a7vY&t^H>jfw%#7iyIc&`oq9sB2
zr<P{+I_IVXxOWHR!Wk*mDagi;ykSYlfJ|Ne<jXOLJ~5Z<%}%Ser}6(F?9s8&>usRk
z3xN<>#q1gqZ+Lw5tj-IJ!=v(Xar&MMEcrvvRC$Is&69tJWSMeWM|SE3I=e!gk0w4b
zUs=C@^ljz^{_j(@Z6FfS*7h!QEB&$NCH<3h4n_P<wj2*ypi>qV7Hrx}_Sh*XIrHQh
zRH%z=|Bcxtp3IYpglGlFqLPM{Bs<~e45j@EE9#m+U(v3in4CGg-3ULy7$O*BQ5lo`
z85NTiC^fkwxD%Cjm5=c(eZ>**Q^>ZnxtjSVWm<n~aY+#{d201qq51c#VKK#sc#6-z
zg8utpr{J}{v;xD`f);MfUq^>&e&NUV{=;(<5?Mj~84&<ujaQvk0uIj>T79UyH6xZq
zit4_eZ1P00gkf#@FImJKsq_i#zHcn{L*Ue-_ex#&xBX%~5Cyg^_@Q48KLo&VLGQUQ
z*YB-a*?vQVniFn73%`H;e5Cvknk0sp+>{j6yf8i6va-X~Gjb2OQBNohIU2l%u4V|v
zSPOO5Al^v=p)^x^m-WX@ncsq@AK6Lb#9-q>gkqbU07W<^g&t$AQ{#Xc$H(x&l$ehO
zn8RtOKm!Lid{dM4!ZN6i`ZmzQu&^tkM$j|pxRf)jnnMD~aN`d6^V+l>Iy{qyw{e#r
zJ>?%qGZ<uJ_ba7V7p9_9to9|I-^&RbJ(Y&4NrSY(QA7j$pfT88aGib0^D}ycjNvKk
zKz?}t7m|7|QHrnZgDgV3ivu3ab3dqfSTXFcu0P=yO>h?0FsRe_!<5g2#nVautYM#N
z2DXC&4THo0rcIudtnX@OvPqU!s=dLi?-tnyHk-vC&;etSjzqj^TsjB?TVRXV|4Ok{
zPBoL-cV0So7dRThfQ9prJ9uO`H8=ICh=N|GT}(QESJ}EM!jD_UB?3e~_xOD&jUh5T
z706FpwRtHi;*A%0;%VZ`zOcoEXJSx=Ht5tfIbmt|YerZ)O!mp|-TwofYO*$U7x>7-
zKcNcxkYU9G8IwHhr>uMhcM}jzbe$oX%tQ7MT{>lgIqitK#lzmxRm&L28#F2MbGJbL
zQXt#I*4EIUd4{hxZ4LzKIVY32>?9LbRMiGn<_k<j#m+4=Br06b#mJTqkTwRLevlQV
ze#>acXlR*|tkT4y7};Bbs$k9))h(1sx3GZJ;nR06L$RsQS=a`k`h!}!&#5RfLj2mQ
zefoyvE&<RsPG<pAGD_26&7rrb2x6jGB%sQQ&bE!>iub1?NhC}FkP;Dxj02*gl?2RQ
zoKI%Ueb$wYH7#R#lv&KeCV1q-FV1N<Ap1hfe-|QDXVI@|f_653AR2Oq>HTg{L!dAZ
zU4#zmD(!hC(Kl6Ih!F%QUe4eO<ze7WeiFc{KmtS1*dG%~6AU8T3s7JQn39IJDiF8o
zey`YRvfzmr%-D^q?{{?y99X<A{CRQJ;wv!_2q0`h1z@|afu;f=58MHhApo2YKz0)X
z0}lYUC`q|2-Mp)NM3nyDgdhY8d^^@wJ6eEOCVEM?*NtCM^KAbA6T+70|0J%!aJ#+R
z`~dODt|pQF{fL>9p+F=t>v4eR0gV%XT%Efjfg7eLKXv{uA>5`7<;c4jf8?a4ZVGh{
z>Z1Bm_^$3+l0QDMo8S+Zz9nw*9E;BXe*r-?7R-xVIdTv1sDt*L)&5`=7&BnFB#_lC
z=aiozu`Mx<z1DOPE9Mgj)%SV+zkuM@Z#)sadkaG(#!hK>eQoEJ=*zOm5u0B0wp+#2
zCU5RZt;_ZO|C#yP=5OE7dKw^n2UzXI@F$(UHHZ&0+9RXH=~M}u2i-z9p9S#TC_Sw~
z2A{GqvA6u(jvn%EL5BY?A(Zo^zWw&xuh!ot0bu|B7JC%n^V`nW;~3#{LEJF`wi_@i
zcjaL8`j{R=TuOAKAi#H9xi&@rvEzK6$)_eI|HpnaqaJ)mNdO0?1m_s>hePs|Zal7&
zCfZ@aG~gwa_R8{wMaMydVdSq#vq4(0i^)!|6w}ANz3y;jRQH!pRRoGhgSM@oDBTJp
zu$oE!ve-~Xu7*oLiyhA+akF|~IoX!X!bzhc--js}De%!^srZ<b&@UMk2}@rZ&6<Ba
zv6>ABkySRk5~|7kVe3)CS2({8mbv%ZuLI|dg}gpm_93QSfRh4%H^5j3;2sAT3NG0%
z3HAOjA-Ehg=oOfUlT=`|Y^79QY_R4rQx8%mT%L%@g5>oe8$sON`!FDJ&oJqWZs|9U
zJl)?Jaqr*eR~`RZ@zeDo{oC_MS@5Z3Pax1@W{=wedw*(4JaQr09IU=RxzE(-xC$kF
zr%JP(SQfQ5t|^fE*hn*^V}JDPz*9k%uk}djRyzm>F_xmFVT~T*!CEW1Wif2D!P01y
zYOVbJ^4c@1gS>}|U92iqUuTmdN91IS#NJwTle>Kpm=*;_K#Bcmqp%rO3ChHdOZ#;E
z3%4^_uk9DF5c<yYZFU_Jo$F|eP*S~sYy_<crxH;|n4OdrM&1@*Soq{B?^~>w{UlLL
zu>Ahd*Wtew>pnk}1zad9B!CMQJYcbL*F@NR&~J;#`TN%H=w0BjYas3;rVDpdk>AN4
zYdjzLXYJAXz8gxr%8LhNTd&zi<f&Tc=jp0{wkB_b{6c1r#1(p~11HoV1>~Jao*&b$
z<23Z2mK&esZ<~P=pIPs%pMsOp;Hflm1MGw8WK{IPb+FXf0L*MP8I#L|sycFn16EU{
zA2DHj$2h2StEqSd3+~`JC|bFirsm2L_8l9P>|0IO{a-+E9FkQCcRpNbExk;J9rL$M
z8ihEG@lC+Cij|ru{+mHbS!^~`au_?}Xlu)W3n}YQWg9=Li9gKIKh9p3J$yIgMWiiM
z`(LnvYEI_fav!Wr+YhCm{aH8xBfL$bySA2)eKbB<K5051Z%Z4sdXL5K`;%JGyHzVG
z<zIEwc36L<(rJG;f&E5+DeSrRz^b~95hin-0KMw?w*0gTw2&hWHP3Jfb}uF`u+(n*
zIhwA4Zl|!<6kF4jmCl&r4yc95Ou#?scg8jbJ<r+)J2)({K&!h8Uy$Cxhk>jF9U~PU
zR?2b8lA#0>EA=7e!Z9~FE~6>En1f9}=xDO7_ats@?OG=Y;O-<pC>IAw`OL|_s!Zco
z?beD}qpz>;OAVLbEz@P^e`jhOw1z(npA`<8ceLUE;ARc3*EE}^1*{6S9SQ6(6-xe;
z)w(tU$jwRZ5y|L<2MYykaQ@F&xQW$~ra2}3mTIrO1i8;`J06izbj0Y3iL|X+2nN)X
zVRi3Sk+JOoJkq0(EQb{d@bbPc5W8f-TteRn-ng0O4l&;~^IAB0TwgSK{ACf78&s#{
zG!%YZ_oWghNL<;Zw&L*qi8geQ=6u4I-v{rp7?h8Moy^TWbE*y_o+B`CW*aNR`cPbY
zm{*I`B&LAOAn9sr)wP#B*7S40NvnHhD;z#uBsmh>c;Rl%-dT<EUlU$>RQ{rh{O#}u
zX7P}cRCWUX2@UtUb0F`nG(_q<_c77J;Xc#D(+2isS1C6!-5g~tJ(M+SCFk^dWv~HW
z2o-QY5+`O<ep_vxoEFT(Tn->@$ajUG)O^$>z_|rMng|V<Z(`AVsGs!KsXA)E_b}W|
zRHRL|QW9FHj6VSJ`p^?qKPsU(l2+%QnU|wK?>-C~`p0tRN}qHS1;c`P%lqr7j*i=U
z9yT8ddvEDZYs7U3CVOcEhpW=up-&O-7Fe+n@KLLjqv}jy$EN9LVRGI!?{3?M^vmb3
z0siI%yS<Qq-0%DlwON{%{!61<ZD~h$$kh}-m^z4eJnP2Z{{Z+Jzm=}_%o{Hf2Fi;Y
zyw}?iNje|Y>ZhbwUDD2c0H!-akBJ3NF^<Hua8Xf<cy6)EJ#rz=f_D?uTX6^wZ5A<m
z@49zZ+M&tjF|ylHst>{W6jy9qrE=a*ma5R%@?Xl8xo(>dZ;BXwge5u7gYJD_zCOs@
zK-)5JVD0=Pj-I1T&&ADid|9ihtnKU1o{tP38DGsf_V~m+z*E=(0%|HYrL;b#Y6<DZ
zTIvrP8ZW2}yPmR-eodQC;%4XH=kAwxK4*EJP*FGkGvY+xyAst?cizBnyUV6PM7EXf
zgl`W#A~UX`Pnsl-Y|#bw!$2Ym_nRaEHds?mEH8QWr_=~ve@5{zv|!&t9eO13LxnK(
z4sbdyI*X7ZJHgDDv$jEomX~<%TtHS=8O=Ht<aiko`ecJ__AU<Ce~b^wa@chq{=ke`
zv}?aK8Bp2_%@&k{4SwMwhs9{uM?*3m1=>BE`o;`w4|3FdvvR9ggT48z`^u9uR{{^=
z^QiA#bC@D;O~d4qe>v@6<4Ql|DsiKGMpkV}@yTgQig>9DfPK)tWEw;aIb)Fa!V4oe
zVlS4V=y$C7X|A)+o$u`1k0mk5LXIXx^oe|J>{F^BnI1$49Dpd?BV)a!(vVrwJ5>H-
zDWB1uE$(gXHH!86;z9nOJ%!pw9_4SZoWK4@d<D+O+&{3hc5ry>@r#D77n3`i{rv6K
zg8TnIAK?Fa!{7Nmd4I>P9An6sZ4|1xWY8v%&w~Tfl2L%rnKM{BF6=Y|W^cIrwI>))
zKmICI-2>y9Wsec_OJ>?yL8gSdd2pZZB&{^KTVaY<FtQQ`1mF>?tI}Vo2&}Z2NsyrW
zqWFmI;n5Bubv5MVs)%2S=vX1TWUpi=nI_c+pTV2hC8KWQ2{!sFbR$$E7wZp#wP7s&
z;@zUi>6}8ekKd{P%l>63pEX<;Q4UX0?-YKYx=-Siz*9D68lP@Zh{@MIc=40ynv%}D
zb>dC7XciME;w!1-;3$PfBn@ip@MD5{sb_W==+g{0-#Z6EWb_NJ5Ez?H`>a}Qf(c?e
z_p%UANSa9r2SYw*sM!kZ=p*jq5hs3%JnTBFlY)#MfPKIMsg8S&0J4QtaS4dngg!z?
zU+5YY5pIi?3>O`1L)&^tc4GW+SfNo2{2&Ha$vm_blhvS$x~7{DPuALE8X&S@-)S<B
z0YT3nd9!d}eo@*C0{1^=K8m>%wTdWhLv4)Ys6aE<fiuRR(BJW75YynkfZm!Ide%pY
zM9?{?jLFS%(Qwb=$7F?KMfh}MNvzor6Xz&_J;B7?eqsM&9sQIcMl>$s4|v5$15;#_
z%TYI5GO`aFzQZ@MhDo63rGSf6@qRoeidw*@3Ch)IrWoW_P<KI8_)LsQhCRHEt2N0+
zxZMzWO%=J-wi}NHbxRPhsfZ{%X~eH!7bUF|3>TP!_b?GdT#+_<7z7LNWh#yU!jTak
z`R->^xrZ~k!fm>HLb-=wLL!OK#1mVkZMs5`LLoK=ZpViIH-O}>>Ox}ST};G-0hII0
z!h^|T-K)gy9!%u3%TgR8o6Wt95{vq?+K&Oa9WCgYD(1)ls<e%6Dr6n=8=c83NrVXX
z&MJcNCpoc>PVS+g0fy8FYKJV6l#ClDA^3FU1|IWb;Lr|Lh&Odru<WXbKp~_M(Z>&B
zfS3aBsb~7(GWV(C9m*KVvsqaf^DRKgj-xQ}1x@7$m>BH)lwA#RH@(k8ysyn-1YJpX
zWXe&X`D6njf6PJr6+SyhijseA%Cu^Y*+*bqq8w`U!<?rQ&X-jwF64lNWZv@NmOq3`
zlVKiY-wB#bruxNE1C1dQ@iwMH^M?Ebn#{PVE=Nx;#jEB8gQ}~JIqF}X@DrUQ4op(T
zKT;7KHcDbIrkg5GD-!A<t9)J~+Rnj$t)e&Z+FuxG>r;qQj#I)a`r3;+{%W1OSv{EJ
z3++I>Am`af*6%Wx=V^^nSi$&-^kr%YmeWugffdeBCW3Z1Sg;rPK3Fc$u%KR}U@N=~
zNdPerV3t$jARfd+(ik{}dPdYRV-5y{e7ss>y}NA>9Wl8Y8$+Zs5j!zbIpt`NVS%<H
zbP*_Pm5lD&9nj4P_q8D^({cU3)l!wzA#DOH5m`kvnO}H2S2O>UM%li2p`8Jz!M;Ne
z{-D29P<P1a$X7x*e^Oo;Lw3ASa+V;FifnAd(0?P0)Uc^c+zn6ikAPIDDz<`&OTphz
z9F{+U7tCY}<yniTme;L$iN`Zwb|B0BDaCxMo*k_g3Nm~P01udwu^8B(AM{*2A*2MI
zDN`&Z1B{sHZeh?NX-NJ6s+fowVWT-Jn)!T?9M(Opn<n!k=1e~uJ<Eg9OW>V&Ij^;L
zJse<gumePu;gfw!+31kdH>Sk$zCEpw#KNk`B7?Llr=kE5qi&j;D}mj=g@H@BoAY(M
zMUzj6vy7R7Y<WY6wuM{3s&MZVypI#LGmDnLWAM7}>Tql`l+_I2uRY<V^n&1-UmbW@
zAj$v}$Jzg*2A4>OZ)F(xstFhlx!W(@0)w&&oiUPMR0--BGh_5M9{TC3{vbD`c%XNO
z*Q+Md_cP<l&I8pQ`VB~7)~+|kgD%qN9w%9gn;~~gv{g-LU^}TQqvqJZW_Eqp+PEr8
zb-Y;K9NL2+1o1>Y(vafw@n!lNq}Seh9<;VuCm&f{_inl_jTP`<I&ts<ArdYSJp)`^
z-O3kfN`+u4MF{$%#^|!q7UR6Yk6h?bHe^b$v<=B83*#Q5tTP06{-Oa33^*$8FQ$1n
zmX{I?AuN##m2NNl+abxjFI2Yz=<46q+oH*X$1mT7Of`xB2;QQpKJTYQXJWL^qkU=c
zceMxll&<b4T0OUxvzhHZ&Gx=|PU=1xdXRxT$n6;dfHdeJ0~_@nQVn4p`Y=nlrHe^q
z;`)24e5J9H>S29)_U_B7r@0Qj908i<NT_SVrX)6w;Ru<6y{>P?#Y)Pis)FdS*LJAk
zU)Z02&^Ue%CatC62tL@U%S)n7Xs2?BKoUUpqrKw<QXt{u`r;O6i+fXA@PW{lpAJDW
zAu=vfgKTNLSONTBG=~Zekr-hl53!o>gUEt9!N~qVah$!Mj;KY%y!7evj`P{2hF8i4
z=A`}a2)tJAy8jQ&c`N;w{K%~ejWJiZbMF}bNeruS^PoZ(+33|8r!9PwBJ29r>QRy8
zC+9Ii0<+y>KbkgH&zH7Pb_*sAqCldqIG=X^KPHas2~F~9(kp~Lq(uQS0s(XAY@V36
z{{OL!=vqvvKg{`xZU_$U>agUj3Y_5H{a&<xtsNbX5xh)RiRIu7ub}f|;MNVe4L+OT
zO+}S@{@>Qg{d>ga*>fXvV#g<$xG0GG73pUN$cC#Prtp23M_cG>4E%Kr5$=o~WD9SA
zAIxo`)f{~APViLxOd2&C_rrIKHz>eC2JM>(IWgnIH3^TYeo8lqh@sP|1e1zMDbm@$
z?DioD@{ueM%0}6_`^BD1)8h<8k04jqqJHXyK&Mb;jkR0ciA=<O1?6^uA1^k3^p<#u
z&*;AF0sM{>AxaDPM{yGy{;TJzVY+yairPiml`s`CG_d>Yl1^09Hu_6^oM>`FNgYYa
z70a<f&&D8sN~46u0BgzD`2;^Hmb-o7e&~<4SB@#C*hO$pxP$p1*f*;9qem~K;t|Ug
zxZO6ZR}hG#KL(LeIoG&?=9u@ZW0vmFxwERf71g<6<IWQzwoHLv1G&IJIHe*GGL@c8
z7TqefpXZ8%)eHEg8oa;@hHt$F&%&1GRe!8nCesaI{?MLTw0DhAAFCyjiF>Uy+dGSv
zxHLQE7g#v$RJn93nMTbzfxYU5d9b<{H#n2rgfq2djU2ZnYaeS#d3h7J&>Pz)ra%48
z>AjRV?0+p7P_g&e>~1NxE-My@fit*ppM$%{q0OxC2`s^}dzX-fAChFj5_J2pvE<rb
z(HQN|a{uedKHxxt`COrVI(+7_Xy`yiRp;G3{8^Zcaj3NVM-@2wl8bc|S2dr7WHCi+
z=|~Cv(9<i6e^nhf&8=xM_9d;NmoDzw7d}_#CyoESqihSay?ISNNT`oIeDg_8EC!x=
z;p^S^U+?XF9Z*;vv|JuOygYJgd8~Sw2ocmEPEPDB*QLUPp!QB(*>qJTq8Im-Cfr~x
z5&JM?L|2#wjB^jKv<Fdri+FQ0BKhu^5$;E=w#N`G>O%C&rUI^C2GQR0{b{7oh%Vfh
z3@g_~_f2IO=oJ>yg!|bCVW+;M4&Yj)(bdBkLaoD=?t6XCN?)Xy2OD`~dli3M7EovC
z4cg}>v^#OKc9?|lFX-i1jB1I;1V1*RjV9>9fSVX0PLNj!AJ$cqSF-Se4MeI5RH)71
zgCS?-7l3DRoqY)i3p31pJRwC~#6$@FeQ7;lQdH-Q>RUEE+6EfKMNIGZQS5W-1qMp)
z&>|yrRP2{szY2R**ai#i8b=sUG-d#n`MsZ)3PjH+W(+Asn}U>~ZOAyTpUih@(^!F~
zV)Rw7Bj1Z)vJ}`?F*F8S_rRz68`&U<zoiTUya&!_@Pzt*59qB4Ffk%Sbd;K?px|#&
zu?oZt^Uw|t3El_>tqOZ`gwNC%<upZr7$UuTpO{JitcopC9Xsmd1={2-Ev}2oT3Kvi
zkY`1^EXO_hf6y6xV;}B-=S`}(XwJWdBjgRSsLx?awwS0@%wKK2!ke^@;bcsBnK9Ho
zdne}0*ZC#TzzRS);0&Y)AQf!Osk7D@NO{XNY4<tX90{$%!{zSt_WAPrE<t5H795LU
zySEj<yin&8TmPK=g$8)-7eKI51o!Kad*v{(=dPh_cY0DLm@Trp6h@EP>YPoJ^<MI7
z_P%xaL8bRspH?J@-TUjiECm3v#t<>}f%H?hOxXJ8+b#a7Cw2s~!dCr(q-gM65zNgf
zz-?#e%TlG^kKmC!d8-V$S8cawv9L}5ejP~;?e;+3zqsXS-A?7x?_Ffp!#aSiaBMI5
zYpY?(GJj`VxVFK^FFu0AhbaX9j+uLqcXBu^@x4V7^i~9+{K*l^lP`Jil<z1<>fQ_c
zT&*mv`rc~j<2;7|pJa2+CORu-DjwOn@aN|@Ps7cVAD$$w=k_W$$!rTxj7sa)H7nB-
zy=<~I_p)bCUOzFdR%5)KAPiJdWbfX#L0dufY_T`~fD2vazRU}!z09%|b3{1J|2KSZ
zU?^V)b#7Gg&~&&>PDiMmo+BZX)b6PCvEx>WQdwxblj`-fBGOM<cDwVQ+r#<~iC3oE
zU3Bh44IVvMSez&8P1+i`8NCSYaNGMK&0xRj=emyl=HG`64($82&~d<u4>hDx1eH6f
z`;vyU`AElH>-8LyMfwws@1hzv3qvvLBIJA?eYjAkbI}lG<Dj*MiE1&Gs6yNlN^hA4
zUgpXc(-A_s$6NG5XG-jAc5eg^hYpp-{C;>$&Z7CX1gn@guBuQH{-0y{wk##|{t?Fq
z#$(<SN(IcM9KyqX$|hk<xGyHB*3?b^+C#kU-kguu6NZP6?mO9dGqpJZtAG4z68CIb
zt?!r;6uoBr(0CT@_R6W8ma+9<mIY2My?p9-s?h5KTO{+!F;BB_pZxGwstS5;ghnwF
zfN3*uF^Z+pmA2oxwosa~GFEh9C)+0Pn!3Bm;@|FTqy4T}jSP#mR%wK)DSRT0RlBzc
z$!F^(ZL}hXN}ZPbzgvi=S!mZ~U3O<p<`)zvNlts)+a|1Kz9nj;3I7LJ1dU;WsNV#z
zm*hEi6~X6{m5Wk5tm{fcbAm>FQ!RbQoeSM3LK?kmJR%B1n||2K1j?z0V*`S32uQjf
z&`>LyaycSj$`pP&SQvEIR3$Q%_p-48n3<J1@uA>Nx0-1)+=Q<4`bXnc>Wcnejr<oM
zeRF6l9<Q&{04Q1HB<fFQ)zGcBvLh{*Z|nb!Lv-L&fdus?i*v$#8E=k)6*3QQi3r>D
zE&1<p6h4+Q>uS)sZVndC41&IzG?x8Q9k$$puEbAxa8FAWuvTKOH6i!xPBl{)DSS;X
z-q|$w$K`k^?K~93Tgjig9BYwJ(eD=pm~95bw&}=c5rW#TKSZJv3-IM?_PTRz=wtX{
zaf)1qZf;x0Md{kW_b>hR5;*-AU0dkBX$9(V4}}y`EuNv9tDQv?y4R$p5vS{_!uDb8
z86Hynh9B}Dqu~;F=?k~<6Z%XD0L0m-&=3PgV|XzQiO@Xps_Bw}pXg&=6b;(HOs#=h
zM)<$f;|MJ5><C97rF>9#clIxx5Qfw&Z8xzDPL)HkvSTnL#WK$!^BpY8JS^BM{$|xB
ziz(xje?iA?vhkV;8G`CfIr4jnSz`YY#HJqABEwmBz$LpjU+;D2L4MQtsfOUPx7#Tp
zLT&bzzZ)?b-{$4-5wi3*AaMQN3nlYoqh_wAlf1-RnqEr^SZL@z2eP%{4m(W=1}cf)
z4mo6hWt=o7mel}Cu_$E>?gP_BQt6j*(UeT9BKOL~$0CLEe*=ocgQQP*9KC*FDnrT8
z8x!FdN65<(*_ZFlkn=teVZl1KpWylUSeHIv2Oqr@FU3l_$|l9W6oPq+(cPCDQ6@t}
zm&^(UQ(On}6S@Ro7iZwd^N>>htG*yDUhlfB2_&@SNZ_Zecc??I0=xJmiT2D3%cD^s
z_TZBo2~=EKh}<lE)cLg8%U1k`!;6>M5-G`f#|<TMch@ud#;qLr#`-qAy*c!(WNfP~
zWAr36$c|DY3s@1KD-M!fa3di`YyRrUd6`kEN*{^cd9=)5-A8IDk8zh>;=0iT9%UEJ
zRx3Kwb6?$BwxL!d<?ci&e?WOZkNI%tu`tT~)JSVxn}IPm8Gl{~kl`lF0~dmh%}QrU
z_OxAzSaNnTd*z^LYhRMw0zI?e)X`+rpP^G6Vx?>I|8R6J-c0}h1AotE=DxYkbvC!T
zHup;|ySRslBuOJeF1aO1nQdn7mn8W}Zn-5P6_Up0k|d;(RBlO9xg{0$^ZlLk{tI5`
zywB@(Ua!aV@nGuiMd#j7e9OvsW_w@>Pshwu(77z-<5vRt*S!gvyb4e>w8EcQz9GX%
zPnF2P9kDBWp!O$<gJ#&m6Fr#<FV^-)^ePN<TMwzFC5f2`-S<}%uN0w5I_mX<1l~!_
z!Wp0ghqzq-Y{P2w5gC1F3!$<3Bwi)>!P9(7;ncL#S)W;_9ts3(j5R)<38EO^xTY4b
z)>D-jX3ZNN0L<V-?>}5bt<HGs4$0p<y`nC3q3Yw6ImEH6h=tUATESt&oOT`aOz=;o
zW5C>hrz-YNmtO1NG`umyNg5_uuR~(%ZpR4y`*0d5)g4|VKZdfO!i|4_>_V6<7rx{_
ze*-c`HUC2uHZ!DJoQ2^fn}U#$05M`Iq14~VO9h32C_MiG!xX%dr?!zY`HtKDN_;N=
zpX?bOUcJ<(L-(_tm{Zek{A{%O7!%)oL(Ag)1?;!Hw3cTM!U@|#cL&LQak`u*gjYNY
zD{v;))Z&kFr~_SLFDa5?GCeDrmcUW9iq1GTJtsYo&~MZoopWJ&9>sTY(AFxZ;QI7}
zy8XqWqunt@Rs3UX(KKbN$JcUIp$tSvM{C*b{L-}7R7Cy7=ZE()`hBWe9-Y-*iaL_k
zuec!l@qxo@C7$tjk&pqyTh*kxD@{PS!k{QfgV3eh-EiSU81cZxhltkuA#)26_u@Z)
z(;U}wxy1W%v}o{YM}c-)+xMf_pInMVtrL%>Un5!FIxvGy+seO0lzHxEw{U$;B6&tw
zJ$+k+fC2G4l-|H7q%yM+Lx}kEcUShj;$PV$pTB#{^7RSPx7%W3@%_ouB@(f7`yAP|
zN1wT;%O^MoNe*61-CW<FGW>rZpR&rIw{H3pf2y0f7m<)U-Myt?B70nfpz8}crJRX#
zRtn(u?bA;{+P<p#%B*6>?jXE<Ut%}DmV04(vdmZ1`|GKnf1i&l4h%(Fzt+lrEr;h3
zl9{T4?ap7fNrdf@o;VT<-{@E8b#`ZeO9$M*)icnVS<BshqwBWWQ9VW=x$?nU)755b
zmr{lUjqk?l<MKmY3xZv2J&Vp8R=wZ&f0y(uHV|Z0EHbtq)0?f*U_=J8x7VQe<{eh{
zzmfm}ATbZzq|873FU=12|4wLJ6)*{{#0i}(XDqTBTH(;{5WdqehSyoXM@o1uD3HBh
zEC2V++H40a?OPT9r=%*B4We7}SFxeh=1wVWXdsKv;z{mV*qal*8Fy+zhWOmvdJC4G
z2-fpAVqiz#$=ng3)P_`G0EJqBb`@zQJxoA0^nkkX9$k16xJP=SC#C&hhGXCL6Pia$
z?|nJJB)#f5s@=`L)7_V;7!uZPTix#Xht^JE5LEbA@7Dv(Ho7VTfFQ*eMtJ}Ljh$(R
z+xZPGPu~r7w}?N!%+HG2?=FZxF$*WfF0gqluG{>5+W74tI7!|%5SCbKA8i5ScQ#H?
zvCGIzmnuoqpXtj_cuc}lweon{Iypk24*<%Ii}}=;?X=TO{?1qew^Xm~*$sl9bCJKc
zMNSgoWTUR{keP_1g`v0w6G<dP%ze8WQ{t@r7am{H?r+7FCQm|a3VQR)iE9P})TLfi
zW#)^#TI&rypKTG}yz3^u^%fj!i_(%Pf*`Mu4BP49#Qh=96ZV8cVp1XOoggcwu!LxV
zzt=c)FIM_~wIlP8@Xt`bB`k4&K~sEekAkFInKc(Lmb`ZmHY!gmK==J_wx#9Wz;qE#
z#i5^W^yDqv&XspWXW8U>KD&APS=WEhI2?zs|IEI|K6?;u`m>!cISM036F4JbEg&=$
zg&w*;ml=i2)I#e1{no#$Y(GUOy#+r{>auoOGe0PShk8EezONqYinV_LIXK@o&?aHm
zy6MaW1E03jnw+c(@~DrhQt>zl0Y}Gsn?BA;holVtd7tLK1dfC^NI|+$fx`l3hTZQ8
z3UtDWz?Z)^2_q{#P|l6_RWF}SJNJ3KRIp&ShmSD9lv;Gwn8&Shw-TMdX<>pxKfPT5
zB(JUj<zh&^Q6p(Qiyb>W+Q=C)Rk80JeM*`lt;`PW&W|Rnuq`3xwt-_JFJ1^MjAlG;
z0zx3g66qK?okqsEDKU$dQ;+fMh-mU)SZceg3@h){%id`$U&s7H+y2d$Y!%0$6^B37
zR)rJ8c|w+0%f5t-M_>Mpdu8?YIX{y*?;6A@<<2HONyUTBCoT8;28-_<&2Hnz?|76y
z_aJ(DSh$R2I=CB3de)gbw*4VwNA(eodj5L%s+`|5D`CR++C(ms!&5K}=^A!?J&`jy
z;PPwYFz;(O$=B|xua6kL_ON~JdGz(sprd&QGYu()Ue{g+6jGgwYc9<|pR!7?deepU
z9De@ynj9gHaVwxP(^A>#sM%XVWLN+5UZ!a3Q~5M}9{7L&;K(Y))KT?L$Q?9)70mnA
zNTbe+{{S_wzW^(!X(;3zIuUjL7_Ni*wO!?wknXR1s((2rz^&Jrl8VPt{XRoO>d?T<
zvE-9<KiH(KCesd9>c5og&3a?UOdU0cafx-j&Ixa`R7HZ7a`!VKVi|maPF@&%Sp-rv
z-ZWiKIStrO#jH!c!KA&9I$qgaazDc*a!oPmSK4C%%3lrLY+j$iLE0L!!LP3rKbh<9
zz}RJh^FWjbGr2*?%&or<ElQ@S35;EAnvxISa-KorHs2x!Mx2z<7nr(#SqQ*-QSmzU
z0C0OHbEE_-4FRI7_()1TLcOD%pEDo7cn`2fy(UW>9A!~X3<WLN`3B{-pnabweJ$ZW
zK*0_l&x{5rIyjk4fjhC2H`39{@lgbk1|oIa_XY(XKT{nzl_pMXNFq1km~umBr{8@L
zFj+NBo~+O}@To;J-vSiw8Jv*2US_d^`u?k69-3$FN#p!c{_Ev+RMy)w&yADe*4}v3
zRNu!&2k35lX?kbo8Ljj%59ncB>aQU_RWp7rk7{8Y;g^CVFi5-Ap?Oc0X)&3*k29|E
zRIGgd)POI$P%fuFoHn78Uc2<L*;XalebT~n25xD+?tQ{S$(ROXJ77dRzI_tv=WkY3
zZN={Ucfh4ew31aukONfQFKu_wWaN8lUo}!H-r0Oo^tvi7^IcklFvY6e#_iRNqFVaw
zdYa2955^R7wf=ZP9sO~;7GsSs%jF{gSDwy#ht++e6~!;%p?A9??HW;=UG9y7p3Vbg
z3IEj`qh<sT@^MpeOw&o3HwivPN1Zc{XPydi{&~0Uyb=L!%p^_9B*JEK(1jcT@Xo8F
zwx>Z-GK!Bvdm2!I%6F6TLj(x$Gd(b2g8Dr>Gi=Fdmkg%O@T|j!@KT?%@_2A~h;tqU
zxj$<xsg>#mPCd=^oy;{=`0Qg<;F`*Gn!Itk`LmyK0WljE>;{dTl!@CueadbTkv^0@
zDRWM%Igqg^TJM?e&3l5GYBSjz@@6q&aWQgh@f`F^l+>4KwJ$M6raF1F(?8($IOx-7
z69;<6valZM3BhI0kHl`l&6LipE2X&sUfIoECqnmM)8A!dsquNzHzlsdNi5)ZoaSw;
z()zz}|G^=Vmmh@DG9)TFP+op+LG4IZ#nuW8+t;x)4=X5J`okP-&!_9`he`hMf&0=Q
z)9LO=#^`if_(zyNg$|E=qy5!|;P(V#F_t~~qVQp^-Q*1y@ASjIp9+9-UNr3H>XZDs
zVB8JYi`~JW<+Q46MBh#F=@tuWO^W80d=;=2w8v#B=)iPC_6Y)LP&1?l6OiFkk%NY%
zD=7Gw(n&FN?|qzdo<UAn)cWJGNMp5LU2?cQ2G=Q@+X=qM$nt0DoUG5=#kJ=%&vrh`
zO)_27XUziMjN9$hT_Yy(K2(Sw2;Me<X)tbo&P||nY8`L5YW!??b9}0Q*lWarTc)4>
zJ}3NHywG7K<j-c!^}Nsm;CkgO_3K*NV+*aH2p8W~Y?aaYSrXf;RaQur@s0e(W(peF
z0u7y%)lMHP0PN3OjFo$x<CBOKZJ~vC=97xA-}DcwQ)4Dje8ccY8l!hFV@dNJnPGY9
z>0?lX^qMUv{@w9$p$>TX=iVf@wslZwUi-wyNZ4-S%ikgh46EU0RMn+Ftow_Cx6}C?
zlmy>wr&&6H4IOA+Jjmd1VX~YPEBi^&T*+nrpUDY+*uAvTD`LOxjzK;TwG2NM{k$sb
zm>xixPI6<oPKwG7`~)UxBsimakgq|LryAR1PD+0O`y8U#7My+uLq&68J&fCRsh4qK
z*!t7;rk=fqp#~o!KDe&`Tg}lN1QT)6bi#uI@5r`t;#qC#V)5;##JI>hYHHZQ*xk(L
zg}c!U#4$r=!tAV4um|zlfLWnc5XZ^4J9gf*t;r>ArioeSCy==6qp?I>&E~JWdh%(Z
z+ScoP<*^a8y40kQ4YiB0j%K|VtcWv$zm!3M1UK!6<+n;S>>y5P3ZVGk(Z8ue1)W8A
zt=C`tBO-5Iy($uPD7U~_-SdO?!TS@V_YHsfqjK~^AO^?j7q<m@`p+f0flWdn=Vtt<
zqpeSuXqo`U633{;QpJYS+_!0G<TkD{wZcQx>0O+2da#0b=ecS!9>fol2kkAgO1Hh5
zqT<v=dUn&I6I#?g&Fd(UG#0}F&GY<@Tl!yV>Zs0EIiqUHPEsW|7%v!kZ!@`lQ_cTp
z;0G6(XG2?FtXp3a{$bVk9MY0<Go*Bx7h!2+cne!5wL$nq)@|faWsVh4uJ*YH(+LkM
z|F0-<*=vwb=~Th4=dFuZPR)ZyvBF!G)*>2FV4Ed%(`~O3kN;)99%;fpEiGW0f7ceX
zVh4)Me!-&B{t?jN@KFfRLQQzb_s(VKnKb|7)wG0mXmFlGGK}wK)y~VGOdMX@S&;8M
zbobR4rZE$;A0lyG0#BsvPF~-ASGzm)X!rfV?)2Ns+(8Gh+345q1GGO5D)=b+LgZCL
z*xrY?;)UBhLGYK!4ty{^iq=x3wgIC9os<s9HYz|pwyBRVFatY&8CP66^M^0K{mSR3
z;s6tDZ_EsP%p+;I56zc7a$rW|!T1Q-(%`Gxe9YuMh(Mv2D$q+8kk$`hT19i1V(Ld4
zL)I|;S+XWED@$w2gLxSH0#DeCFD1Esh7vj<2qzxluAij6V!VF}+yM#$Ck6d)yFVS>
zeJ>q(dLKN62mCwMs6J7L3>t4skNu=s@AD|;`|>ZX$>xB89D3n+5h-SGDwW{<{1heH
z;sI1}=3LXYn!V8w2tM$KadQ8l*j8Q9-S^y-c>#mSm2JI+!2)%@87ZKwh;ey+_n!>j
z#e&XV3E#bOPJ`%BD$UE1VC6^vj-oyKnQlXsffHRC?9X*DkJ_U`lJAYP3_lP2cTgE(
z85_60G+yg*FY<#{{$&sq1d#hOhz>mb=(r+}@`(ELKh-u3t$@csTjxKWt-~jJPnt=N
zgI9h|>OuaHL>1qrtCm?W@RC2`_o{=H=m;lMbZTBpg@Q_rw>aM7jVaYl>)(!t9gw|H
zn8mCvlww&r_Qk)j`U6~d1zOr+EOHSq3+nrQCSd5mbQI0Uqx5_13j<qAk6ABtj`y51
zcCQL^^{CH9)uQ9BoA$1Tnwz=mT+k*aPtv!|<DE3m#hS8{R~)0Aoko--J|)>e0G7wL
zMquX63wx<<WS-+<0Kz4|O4af7Uym~f_oA-WSchTEHEv(?k(I&N?THI2q%~eGknN3<
zV(I<a_OO>NbriT3{M^AnlsKK20?%$Kw>ujIdw{@aJ>?+q;Vj<K39C+(i9=Sm{HF5j
z%&sM#Z5Y-$sPo{pkD!<$q>l<mpv+;J_#D;)K?DN^dG2-oo$aW>jTai9d_fE8aNq^3
zE?YSn3ZFE-JoG!a^{o%2$$D<@{vlxTFRh6sd~m0k6~ZhQmFADmKMZt|^`n6=;RuQb
z#;!F0xEnY(*eLM20ba^2QVrr&nRnh1H6lZPdlK7LV%0ce5j&*=N}1CJW43Z9Z`V($
z{*OPMtc-GHt{M(sihJ;Nv^E57V;{2p=k-Z|j=eAHTLowq6I+0!Hj>*v8jR?vK4|>m
z{CkDt`nJCa2d25EmAnUSjo2QNUl+hH@4DY8YA4$B)7+2?3xUVOThN{m`Khn(Bt{}X
zvo}6~09{jJDrzKQss2v)Uk8TJg0KwG9<63^e~ag>-W7g>yq2#I-+eem7L{XJT!hSJ
z<3UTuhfT|q(C^VOosI)j{PhY^OOLo<b;M)ttApQWGp+Y*0sK`li?vbqop+$Z3T^YX
zsQ4UN-`$DIBivSvR5!1Z)_IqvsMNd*9IW~!xgrmVN`ukVAD2thKkY2rck>@<rcO6d
zOKl8tow0P`G|Zss<fx=?)KVDhzf6gOv9{!Jw#ZW$i@`&Ig|mWAe#iCsHqMHkM{^{&
zrW4B+ljX_uQL3E<=37Al1He<^5&kd*Sy1{Z+eN_yhvTF+Jl{bGM&t)EfLLj2iz{f!
zI%A<M`>L+rsI?_KGD%r}9y?$*-jWmFrL4G7H(<Hml6z%GSqZE$NDynyV_2wQ#Onub
z^;`3El2lY4_cBbAve1#`V7a+pk{a|LkwE-S#b?bn1sp=giAka|W)}LbP)w}W`Lm|7
z#vyLb4zJKaNFjdG|35niu%eM~nnriK<o_^NNP3#dPU?WBgmP4vOuwX!n9!yYQ7QM%
zh@pa~OR{fl(MRoD@{~Hbmr|g!kRGG?VXH6#9T>ppICx-B?}@2XkF0^X`(vV*Ac7Yo
zib>=RoHKiwy0U@V-T7i7?vszv?niZ!!7{RlEDN9yNo(hk(FWZC$nKii2_G;`N@+qm
z`)uo|hrEj(JdA@D{)mKKvl8P^;edpx)GSB$&b%9ct7=S+V%^Z|6-ktH=s)5``~0D#
z@376;o&e_MX0*LV7MQG2W$QkK5F<v}2_BotI)V~Enilm7<;NT5_G$_a^mFHL3h|en
z(tji0v=gAjq}*|L=@kCE^vyMGo7cDrK_P9v7HeCg{ePIi4XksDbX%{zBFjm|_A1Zw
zB5OY+#c;Ta!28!hZm(s`?pX>tc`4N>i<CjYF5F8Iw%ZgNPxnreLetCp(u$FSw-p1B
z)7!QYh{|JW^!T<t>|LL$aum(RpVCE#f{Brk^k1pqPWSpnt5E`<bgCYb?J!_Hrzi9i
zT7}@hIPE<1^-atQ3HjU&W<lWv^h@W>Fh>}l6^;2vU_9v2;^UE)`|#^bqx2u=LCOB=
zdUv!9^7qcbfsgzjBUGzB&Ch1&6;#wGjG}?KRo#TXLw*~WKo*zRsyXIW1EbVAK;rEn
zpJm;elBp?M*3XI0xxF&A52A#+*G^rP&+nqEhz6Ha4w?InWt?ZJI$xM;!Iu)Ufl_|J
zhm}r_S`%s4Cf?vVk&0gqZU+7+Yn|v>_MwiY`(*9cS<Tk13%V9kOm8Ucm8TL{s%r7V
zblC|cQ=dm^0WH!Jt6|kf<f%|7#0H|iUq$zeRSGY}*b1kKjhR+6;HDhv3s8c+j=4hS
zQbdIUK%yP#T@|5IzNl#2;G4$xpy_RgPoAPYH`2azm&~k#o$}@rWGhux5>-VE_IXT+
z^;Dqn??j$5*@9)@pNc$<lD;yc0<X-ztj%~8zQ^UOvsE}@bM;a)<e9zBLKG}+(v}X|
zrmB<IPCg!`Wt;%*zc!fU0h~?Os43`^y+Xc}HcXRw%X3ATY6lgq^4{+(l(?S9NJpi9
zfIqM4Iy2{(vWnBJLOM_+^`ny8h-mVbeed_IFZ889;oMOlAZAVUuGb_AIAAg&UcjgP
zn(C*#@&0CHTxuB~dFXe1zI=Oyp_9#9Bp0szgmRjHWM|fkHj||i!2Y=LfdTs|Bu~tu
z=gC@WOO@)mTlpoxMhbnkJm1^fi|hYN-XWlmann?IaNh;K%uh{5-O;hK|6cp0Yc){G
zLG{LmHtDj}7=WI3{!&cuk4@Kx%^?jE7mtQpaPElk$k<+J5U~0S+zAE2229;@6C){K
z{EOgj=9Oj{x154xTsGGKGr0$U`Hvm0iP|Z<la}|bWu-dxWrxImzdCVxS>X3JUs-NR
z-fyVVx~kdPJ*f@R35Omlz!!$Gp)=!*i8g5tLuTu<GP@N}_33u^Bg}Z_jlPG-o#_nG
z4T3v^&P7EXa`>}L+JyHF@lxbRX%9YR@qBkK+hzY&IMwm)qji!LfW1b8XRJaflJWxP
zOR|o|dHgz#R&9#FimO$Ej2sMN$PuKqrJQoeX<2>kJMr3T0^~be#&SqGuuCfEWl0u-
z+aHv9Zua0Uz{}O;)=?)f!nmBKx;~r|N4k`ahkPP?znm()Ze6MbDUw4=*qYJ_h-N}k
zAMM2sQHw$dk0MaQ2fQ45v>GA6*))@3TLk5}6>eAwm-PgKe|a3#zCbb@l)kjf^Y0my
z81>AG#a86lp^&uCgskE3Bz^6-hV`e8mD8Bo;P7gY%4W`!6%uOCUkS=GqQ6CL5=@<k
zAISLV!2F1lXhr>DsfMEne5o~uR8?)GJ}Pi80c^Z)!+?o<0)X)DejStDtLl6U0OUC|
z{4mXc=d?UWx&kftM4O@OT-MXU=gS(xd&_gGLGIfm^DY{`8hk3sR<;^kA<0X0uA;!`
zMo^X(oGWWF1CgwGAsJa>@E2^j2gZ#A_#Bt{^~>8zXh_UXmWU)FDPoQiDY}zyof}EY
z3&+A22$!RwmUww$J3+&B*w|t8ro62V`P3C&78XDRlWAe_Y&p-@oI*DCe5$NAtv=e$
zV%ir-2y`E|anR)GTb%kdmO>-kG;|OoHt**TN=AYf)}!|YR|`q}C1~ych;1O1K%$B~
zQ8t0>84kjbc~ne^ik>OIBD@p;>I-d%^bAPR`?kAGDG31NlzLC>Z#$eG?<2C_4j_ez
z6j>X;6CYI{sX&nB8TQo#pQa#B<HZLKw@%yD1R7@votX*rQ#*4+VCQ1cnfRJuCoT+j
zr6wdtEwrd6v`p=6P0iURwXlaZVclvSH$dSdY7sshx#^T}eL9la6S1gPv{HkdsEL}(
zM;52Z;ArL+Y39B}B2qnOYtmX<{a7Q2C_#*t3U(|8#fzw47|BNtr<mdBno67tj4#)-
zzIY9Th)FzAKhzw7;0yig^67+xJ+{tpkE{g|kl?vkLSs$`U*Q2K*L+FztBo(9$N#NK
z(hZTd>`gYNBbRC~7pNzREm<e=q;{&)BA3wTNkBV|RGgAV4T+7c^{NZDB8LD-tgS__
zjs#U^HP{#qjw}eKmV^*}zhr#Grft<NZ|*M|J5qBgV~b`DfQf_LGnahoGIYP%#L=vk
z!1`Dl%V`3`tB%-KTLi7mjn{ZT4C?nKYC5wifwU`7N+Og}T%ciD{57QvdykCGJz`_L
zVs915He7%hOky*2=_z{}`HA)A=FaE^y16#Ty0G^OhHfr|AQtjmcd{*Mt-WgXby6=F
z2qXa%+O4x8MdlhsA`Nu{S(xEr?dcSZ{IYcyp+2L(zDASSMJU?hRPTk_hMcupB@&gs
zR%qH#mlyA;Y2@T+wzxi5fOE9-YOnldtIB`F5A#HoY1BBKO*yM!n^2dgYjbb0t~MsD
zx+&z5)SY&(Avq-fd9_fdRbq!!pKR3Ej%Cf#AEc{LZkSDRN{tweI87vthUIkEH$#`(
zq2WbK`^yuWBi7h0*4R^^-m72#$d!&vSSl<CZjB6MET4JAXkbOITvK8@Z-Xvs5}lT6
z2NuDDO?88N>>EeIGS)R%#+)aMb=?Ia>ClFpH`)V>E7!2S_&By)k~*^!e13h!dRu#R
zk2bmmc~=qY1Sg>_zP}o3xQ!uQ@(Qo@I$L+PaU^oTThU`!O+VNU?q8r)HZ8ry+?^b;
zdDp8!T3~aWI8Q#-b?bAo|9*S1r}cI*g1)j?mSJaEhi%`AaN3DD)|FzVvX4W3waL@a
zYg143(<wR=(Y~zn*(oi4XjxUFx1$KVc$TYsJSog}TKlP&?pNJ{1=q;0H9wS|o%z7i
zu-yFv9T9rFSND5U)7>|^KNg#Q{LuZm)%0^ucNKbXRph{$*gbTPt$IGwVJR08ks>#d
z0%zFBn-Wz*dZbLLDx3maQ>xz1CkN+qzx?iLO8)%NMK$sT|1CTBmobftB;b&*@WX6y
zB4pJqPj0l=RLI?Q1?3QURau^DbkYV<EDKJhb9rzk`S(7o%o3TfR7YN5DUi5A+U&n7
z=3}$xmZ!7Amkc>(U;M!u)~guB(Ds5{^3Szedkf=|__dnH5~%u|RecWb$~Nt)qiy6x
zHfG<GHS4zK7-b6)<!vGEyX@s8xGD01ZlFZE3XCpaoq}(xw#@^na1<O2*P;n6)($O#
za>D;kmYoba=ULuowS(GHrN6SoKnFfSF0TbEK|B*7XeLw28{}iwFaO^)1un_^eDv6=
z<P(mR?u?RSR~}atqI7|8@k4r0=Nlu|e!&p0I@*i!ObLjf8M1tVD1x#CE$}!G`h=j;
zr)QviBKDL`G#V1BW1}q3Hi{w{Ob`<diQ1z?o!k>dPomDxR-ISW-;puu$*uag^{**h
zN6Ed&HndMlph-p5IH(YFL*IU0c$p>)c4tl|@Oqo{i1XK+!bvPx(V@gb5PZa$VCAg;
zR4%tK#oz>8N}HX|&-K7*7l)|QjV6yljdE;c9j&g$9**fZdm3wj+CT|LOFF!^7)%Kw
z_T}(%6ns+n`Hws8k9&CfW0hpIyLb-n(Hb@6=ZtBFNwP%W8~?M(&xnQLv-m-orGamV
zzv*&O{pL$V?7pqpf~*c><5+C#QUmT%o9p`l{EU!eu#A&<+cG5cNceLrI?u*gUZ4&H
zkFl$fseI(<dXVl@mp^r*k&Vp<SuBt&Y{Y?4UkjVVSYPN}$v&go{4SeWM-KIf|DYLK
zJg}GKZPBCeCrIQ?I5?(*srToV2htKFkO}m!4|$48hAxI#`jGkmy2qw`v8`)*`iF(&
zEejO2_V@pf0G{+&>XoXEfe=Tr8YEjyFh!nznfEc#7i{x9$dg6bfs$IyIPQNpiH*JZ
zW|~9JmUZD)Xsxj+CjP_pp!+abrrH3)cWC@J$I6rEN!%xEZ^aA8sm#ruY*_DTsg2dJ
z2SS4IjaS6-zBs2HmU@zQ{LHEso>t?_rcG{GEf|nYd0f{IB(20A7P}C@O+CKD)@^F@
znpQ$A^y0lgp3+`_3js`G{8m@}e8fRQnDtu{Jp%Q9%h~L_Izxogf>GWB_&HmI8}Y2k
zpb<-zXhS-D5Tb-VC8GsN6{V-%D<dtNa3GmM%_KvOUt^(SX2nB<LB^}&j7?RZU_AH!
zUh#F{<1;1Q7i*Dh>m}HG2artT;n6{9xeK;Rkk8J=y~LICr_Plme2OBPnialESRPHQ
zx9Ai8C>O5oXq9)K|1aB;ekSA(8!I+cu+7%Ixb<79b#>x({irZd_dNJ+hnM#;dF&^D
zWln?v1nGH=WCSUHn{wlx2%wD+956b@;?WH`r@X+nO1gD~^3IAyJp$)ReRs%elzJ2A
z?C{C)?_K^2ynxa$=ip`!VI@UxsgS*tj)qaukluTjaGpXWvvA@GUxM@x+E|Z?ao+y^
zFHS71^cE*JiykCSBw9@;HvLSz{Yn_2^j2+9>6pVcy|ZArh>iEItpNsN*uXsxa8gV~
z-&qh7Zt?kcMOB4-V4H}!>}A*qr^p?{l4y0JgallM$)H8wJUk_*`z844ovlarh2_b^
z80;f2__k#WINc>yv2bJE{nkp|+Trm-nqoJvX>qXsGX$xOh0qR)9k)tI_mb~5j$-6<
zNcLKEgAgatm_cjqM%2Be=do)X>FkP2sZvTrwXDyIHU}QXr3FBFPRC?QzU$ctq01`m
zAAT&yRGu7*N|9gaK@Fyy$mYDcuse3o^8KSH@1I&u4?LNEY5C#plMkOPKYn@g@u%gd
z-%marR{Po)BwI*0_(dMk3~CtO{`6%`lT0%*wOX+5z6fGTu56Z;dwA+{sYb=J#Ql_3
z>F(Ume1nzu#O?jQ+`h_-PJjjCwC_eq?p;etSUTLVrcKhH?EbFx!8(NJsm#NptGRfm
zUOj*+Mek8#ZaDj8oP2pDa7L0iX>X<S-roW-wl*nc&NXUz(>8Hn;}ApcKS6h1R!jmk
zgb9t2zm;<g#s3|)lEz8HlJqutw6lbWWTG~N2Z1**u^{P=3gXEbl1zt6zv;5i0&rk|
z&^{+hL+g#8S2d7LzRRP;%jyMaAwlb=1%ZxN)!l16I|_mhT|eO8UubsqjLUx}(Ti>T
z6!rYnkeNS%>Z(9>@*YelZtDQc-NC%V?wa|vhC^jQlHas6nJfRMLFGY$*0TsSB^q?a
zXk+`{$#>D*@xKRU%XQezdv<%u2UnIV?$`|f75{fF%AcKvQ1|LWHjr{`nc>f`9~kNN
z`nPvYV?4xPf4CZ%CS}=qn{E2M>E?;{CeZ=*s8o@`mez;v9>9~!?i%)?Bm}+u{AxG%
z(a+Xq@L-JsUc2-XsL2ePw|Po+{B29{+wPkOT^f&t>8wCZ@%O5{+S@*FeGa+z<LB%*
zPT~^wRr2KWs^N~nPkkN1KNvx+n4Hdmd#*eQwaOUS<^T(TCk0m=lUmQM@aKW!WICWA
zAs}ck{mavB2kkMAxO?DNJpj`21r_WiVP^{DJR7)WKF)=YJdwD#kY9x}udppXkIS^r
z$q`_y0rB0dgT+alxjOk_Q$gS=@a8LwqQR|SA3ARrFz&c0l|eEIHy4<{l|=nI_QGT~
z>s9leYM465aF6;KYrim+3M29CXT8n%U;j8zR?Xr)5YqbBDdS5NL7x(^88Fx=ZOKzE
zfJy3{xZ!LfJTnGhe$^EVS^6;Q@jOghT~mSVqi>Ffo*dM(j{~a$UvWLo?XeGGtil@Y
zhS!t5)v?-?sHCfH4Hgees$sc>EfL42*Wa!AylsB%bvy)I9H<gB=!?xw;>oMYh}}zH
zoV+lbec>RhYmKi=6S+Q`_jiW?VWk!n9Gm&CoBOT)erh8&s~hkph=~qE0#{Kd^?%`j
zbd86FU8%>{mi#>}3u-icb9@44uDZL*G-NOS;Ul@r@!$pH<2<w|n&bR{Vx{Mgi?<~&
z7V+E!#-ocg%||aYu==CNugVwK?(|hj%48(IXYk<7DZx?!CH1wIf0cpREzqkk_s3i>
zsQ`m8!=g;C=HaH(x>9E<vR;oI1pK|wRmwVpIxlfL;ll&@q?N+Vvd|X-`0Hg&F<}9N
zzm$_!*y5t(=v-#I+Gw)R*x{dJj@CsvsW?z#h5j2v<WlO0d(~#!yW8sWFQo-)9oaF*
zUsc5|i6{v%Jii516<_SX+ckep7>{n{azWkov(L=~D=zLVUflZLapAsjmwfsqG-eWb
zTpvBT^f5SOVSVscz?7BHYSm7UU5;H&!Of23fVI&(YfpNtx%ukA#)kdw4{7YKPN1N(
zUjKy&X##(N!+GWC|G(oLa&`-fjH0WH9E0}Pfkeq6ijH+&1@jejI@uvzmp%`D8<oc}
zYMT{~Mv5OIt0kCi&WffWIq!^4%S^*v&F9o@RCV*yU8=7|EgZ?QFwM_6+BPTo_`bji
zP5?r=cTTzoX{VQypA}>{FEdtbXVjFR9T7J#w?C0=Hj<xnzHMIN>o)Rg`)r)|e@9W6
zmL8=7v~Ysq0$M#TJItGupXtf1R@TL2m*avIYDTGJ4OIS@daW{juvEd=R^enMn0XWn
zeX%o^<L?W~zgt?>@Q_%LJX&ediB8w62`W~&8)`c1UGCDnmh17yP2kPy>!`9>+he-1
z*=271`h|!WK_T<lG8kSpOOL6Q*R$_&IV8sass?cAmFOg=`9fpG-3!LkYVtCT=JFVc
z`<1@owqV&CUsQ(MQ_zV*cw8J9dlEXM*rDBPj03xtKw^tc3wuwzL0J1N)yV&D+sDiw
z<&nrx>G{mk`Gxi8_u8JJ3VLr@o4!i-o~a<y%Xw7}*wO8f^Rm<4b~<IPdFP=saQ2KH
zu4a&6A#ZyY<ggzJ&!whi>Plv5c!FQF_Y6r8sft|k8~^F6qTjQLrc@<au9v5BD{eu$
z811M_3(X3|A5gqJGo#Yk2@jDMuW^2$B`K<!N**VP1c3ngQvd9@K~)6`UdS=ub2xdJ
zcI``b-znGI*{SWbX5U76vGfYzb4redzbc?c3jqfFO_*fR%q#1h=)$AZ*B-byOX+}t
zjBH;)#L_y`c%j^~x4pI;)K1llqm`ESVXgy8pS|xC3aS_#DDFiZ1KL_dUpwQF#TvcR
zZ`N`n=pciHu<sX=y_>D&;j+B!A!!RxrhoN3c9RKKtHq22dMhj1uR(uJA}9li*jB-m
zqrf7XE96bU0XH9{+9zH&SRP3|@@GF4kb`kub)Brxle4#4bcdFsUp{(37BHI8x^_}P
z9W_q=Ok~J;<$-2o1~_&qJ4om7nK1OjLHm;`NWs~e1E?bh=}|refAsrR&HTLQYT7}5
zJW^=NYRH6xbZdsIc4gj;p`WKO@%To>Wx%dEOuIMs@ZQXcQEAyud#4h@f8{pqT9s*r
zDntGYzd1uL{LkUm_2U(H7h)bkJ{vePpzndf6vcnYZ)??XW{~GmZ$bYhhmaOgdHblU
zuC|ZWIJTzQxz0<J4!#>3w{K-ZSptVi_RK2k<W-9Zq{5$GvjxoYVn<DpO&Fy>KxjFY
zTP*VeQP`^jzK|NTGq1ouzu9t#k3!r#?Kb>v@PH2pniGY7z_l^*Z0(%&P1IFPULu($
z8NKl@tP*G6=Rp@^T2BbZsyt}d6Tb8)H*i|0{2g)Yi9H{s8;TcSv~95trwJ$Eg5-zj
zF^(E(Dtqmsih=pRx^l&G8|G~5JI;J*dg;tIG<<>jnlRu#o&rtE^^J(aA5%Vpq}-m2
zNB5VP`S*fFEyB*p=nnCjEGcDOp7{ZPAC-S^4k1wHIFFhND2@wTVm#VzkUy&S=he%_
zpZRSdu^SW)dUZkpH?vfw{EjNW4lqrZ;?r%IU={h6b9MJ_evi2D@BOUeg^rguxj)W7
z`uAb2?81|uH-BFK{qGY9mCz$vwwh|PGmE&jttvLD5?W5{d9T~uXE=wvu9hx0I+ChY
zzWdb7y>&?fHE@*7maR6q{MGD!{sFA=WBXFh1GCFrBnPluRn%a>OiS*kLL0l2PV^|1
zEb$1o)n;&<-9Lx9+|}aCoyudd_vvtkq9$!E?c(!q4(l0J@PN9#g#VJn_7>(Ixr;w{
zVElP;j+3l(@lbI~svK*E>9>=z9Rszo$hjz#j8PNLhF^5l1R2cWg>my8F#(Iq=XUyG
zG0s6QnqaYo%Br2^<nl<#1&r)q52{Xdvq>4A6CjvTe!%Mt#ncV-7W;BE0>zE@M=!4^
z*wNXOKj0-j&5fW3u1uV4g%mkODgccLQ1fv9p=gYG40-lWvrfB!H+5%;&!stAyT9%u
z0UNSH;d~WnDE~Y4L)H*3c!wzH(MRsD6)5#b0?Im^;i}%lM?`pq)JN}e?(x42VZ$@@
zr7DH#U@_+&*&VcEQ-#w^j;vc4LkKL+ARrgfs1pCwJlxASP*CP`#O!E}h^mE>jWsZf
zeFOTl&|5My5^D_COQbFpfmAzxs8r{GW@{kIh@5I=IGrt14MyZ>NG-A8%mq|w&i9OR
zlbqR?0`m!3Up-vsphvNvv*6HU?m6AGXFsaRE9F*y)6}E-P~4b|?+HXfu)1DC@5!PR
zVJ+zEY7t@U1E8z<S&HCe>pdl2D)w>ng3XJ9^wYfOqaV73>B(1`h(&Xyh^V(}pUM4*
zXD#x5OPb3;!39|!;gDJLN`b8&lt}n@B|bS4Ny1*o!&7g<b4-r6HOIR@C_E^&z~5yH
zaMXMudMoGR+2%9}Wn})E^0TH}#d#{oXyva=n9U$6Bt0fU;6N9FK213@H~YD4L||M=
zc(mNF8YG;tE?nD7s+>hN_Fx~eLJG5D-{i3z;F6*1*{<q<Hkx0W8Wsmt4A+&Iay{m}
zpL58-1@z0(PoqnEq)oIvl*Ux^2XY^dXHQWyWGl#AJEDNqZL6hOrzsJFb1w?&@7f$7
zA>E5Y#zw@A3*U=TY1LQS(9dEOsQeWbgAuR?ViAAbt%w^2j`s~+HVoYjjE=?{9lvjM
za>K~qz&I$@IP|`8#D;OSfywz;lZ&rx+VCP0PI>{Yn$zWooj!)$22Q>QnR8WTj)lMw
z1RnzCfB5y_%_iy&A`>rBgJ=ou`)a+Ed?;GKzIRwnhnm<6Z|sqEp2a+^giWRBIP;Y6
z%tqz(M&k9fS`4U=l+PBu5`G1m!_{KBdFV({bxg!>HD-ivll0RKwVLX;7Q}%)0(=W^
z3gy*foU?vxFQ9oArQ$CL2PsMszr#*{;_CZT0t<K|h=*0^H0bR7LVzGYOm7enqsErz
z5Jkpku&@nWQ-Ow=;W=5*N#m4Y^8RJz{8Q603EnZa5H!l6kmf)zX`I#B6g_Z{2FH;E
z8}X)Z#&J!t4#B~0TeCtSmcYYG1-hZ8v4i-LIrtTjToW3peeSF*K{}@g88>@da}gdj
zi_A%RqUK_4&xa^P>$S8<Jgr0or0|8#!Zl+Kd`VHC>Oti!$cg9Zt6z0Ds?mlm@jok!
z!&O&r<-b%qr)gX#j(dg<Q~`3nN@wW+?c_#_ULUDBf%2Xr=K#_pbyd*`+}Y8Gr68FH
zWSI<q<wW$2w&3lOU%J<9&AHkRh}}?Ad!uuvdK$oKvDJW4A(F@{#?}lD3>SouXC)<s
zbU+4f;}!6uY_GNZ3R!4mlast-UR+bJ`0+xVIRVM=pXtnBqk0Oz8ub(9Reo#ddC!Qt
zLPj_CD2Sr1q<ilad74;&WF9G5y#*c4pa{*NQFF5b)#L|TJu+hb?Zs8ft9+f#4o_vH
zACkwVU-j>szJXQ=iJu4rcTBk;ikleEfBSr}u*4be8bR7Ch>4e3;0X+tAPXsrEL48l
z(FfLNuzrL%?^*0$0C-3UrUs#1Q{|F~p&JC@yoHEmjPQq7!QH3b-x_NY^Gyq!J>J7T
zZNF5tiJfa1_u%HnUy`px#vecx_TX%t@Nelyj|QjhRfvjs!g0!CO=LwLir5L=psVw!
zsAtMzZQ7;3jz#2!d=f_<ia$|fcPQNp6|5C<vNi79J=K3jm%6J2)+unY#eZjhX|aBx
zZ05+8==!}{ksOSK>>Dk6YGgYIn1HCO_DL~?l?S5ZrH=a7SCY$OBzWT^{=}dC{swbr
z{ru(cy2ofC`x5jSR={y-;L1;wm_H+96D2ZhdMpfGrWcgIh@z$hPf!%A;}B*r_<cj~
zI{~)S`lz)6WUUcC8*%>2_@&oh$eBC`yeeEOc+PS`uIhQPt#MQ(A+Br|J5ByHp(CW9
zuf;4+;qFvuIq1kQU?MuAE=|WLotis<ZT;qxaOo&ah^;62;Cf0&t&nU*kTfCY)2xsn
z+j+eL3F(3J^z6Gyg=b=1LQ-H&_`_R-z=y0iiy$$f6!~ziqDd{lZdP>S@Nd)WY@zM&
z47~6lUU+#$W};k3;DTl~ySUju+qUSudw?ORU`79GT1TzqYJmKRV{Gpi+}7RDo`=rM
zcTOn(c$!#oLYk^Td5)SoBe5D__hnY&)TWYx={ZK~DJddEkgY*_hbo(mY<X*`<>4PY
znHxMHk#H>p05SY4?Ss-?EP91Y4%JR5U2i1IJe*T(n_Zz-4NV2QbXACYp-~czS^rEU
zxHbVQIgYO;$I+#r#KKwp%Y^eTJU%zSAGrJa+97*^X#gP)5}U!FNnZ0iwC^KliA;}$
zOqGl5Ff?A3i;SzQw&{QJjMJ-@*4&fP|9!NSe=5!QQ8}W7VRfKFrjsGnUV)ai{B2gL
z(OIeUw^Gl%$|$kQth36}r}XvATIU~uIec}ft^d23<w$0=i>&4h@Vy%^IO>|`TZt&B
zFgqz*6EuYg`CIiNP<g+^;xH^XJ+n2*l3F%G^;gUZfrTsv;H<YBfT>e$95rXkRf<@D
zLsmVm=};g-H(>6xq=aVYl&K!c@$%o=gAA1!v``X}#}R{Cp25wLwW=RtE>LZ`FRn5q
zZmTT#sJDq~bpHJ3H}|&&)7<eB3p;rCQZ;Pzf;^<+Uh&*7daArRNCcpWgfF5qy)Cjv
zH_GB-%?2g3<?b6j?vLvgqbrL{;7ze;wZ8|XJuW>s@ek$qU&{xT3u6UBtG!Y)&(py(
zdWYLIDsNbX5&cgVGVFxgQ{SsWX0h#f0g)xwd-EN;=+0WXM;~lley8YZNIi4L)XiOR
z^nc)3UxOARAf4_>!z(B#3`VUIBZWYmMa#H`CaYspGw@xZ@04fAsPIe}HwICVBHKlf
ziK=LlO5r;Xua(A#A(Qw{6ZpjaRoYkxMvq($x@1?5b!;A$==1n+payqm7P$a8&-q_q
zRaWj*Y{07YHH$A@CJHQFJw>f>?<E$AL`b7MG)C@U;@AsnY63HO>M0)FDK%utY?yR_
z^!Dv17DT~sRUI7xcDHu)*yQGI+cujZA!*{X8@?QO718DAje9+TBhtodP(4j$l+eam
zrNHpX6v=>;lRV{R0RBY~EhI`3@H?ZBQz1PP(D>TkXQN9aZr1S*Rd{E%|9?G^6uEFo
z@eDL_^)S-DS3>g%{FaT$<THUTf@y}obZZ#O`N*(fs$`z1b;pI`(v<%0Ywc$59$l$Y
zm`f8{7gXG%5viAKcmmNe%d%5Y02*|4>{YVsXWORcr^k7CxZITchbt405|KIkf8gj%
zmN~$}n<j!^pH^jF<}+xd1%t|eH_jGJT+}R<@Bz<=js|ss$!>du`a-&6^P(e^7P$y&
zKl!lX=>?w^sOH$scgF$_fOe#b)5=g&Rq{pD$DXhFKosDg{d}fZW#av(YGI##lyi^8
zLS?Vf@0+?`Bh(YnKYZfU{Eyo8Ht+O^DfXc-x7D#hjSMvz72XK5B~9|TY1Ld@Ny@3V
z9>hmC3HM5b2vhN)xxlTYP_V?j2gGKbpj=J47;OaTr@a3u6!$dXsAM$S&R=VB>U2q^
zc==~k_2+~JTkS!zmi}gB*69&IspO@?h%ozqISy`4x-8yt*8Z)Eu7tsl%|mYk<$F{1
zztwNAzkX5?cqf6&P%7R+dykiQ_xoRnZ`V}$k8K~|KU#{`>^il?Mwvr#Rt#-u;p_J^
zCRtBX)Ng5NTbDnj!W(RL?NU^#pQudXzkZrlURJ#+VeQp0Bzvar_f)^dR?pplEgU%r
zRT8J-?E2a2NZ?+I@bWS3Cu%?$RPlNcx~+U9jzOy??`!q{6DB>{JBSK&nLS^m(oH#3
z{y{lz7WKpbPVy<&WnQB9SNQTB-S!j`Kpj;|p)W&BnYfDHR3SOVEb*C7I4by+e3F!2
zQ6Z*H#9Xjk_14p*9Ff$27xMh_ffY=m0Jr-4t*5|u`KhjSgW8ds77;NAO>rSTWi|*Y
zIlkpX6inLAF1y%m$~r7`JcPh}5o$pq3PWLqKT!wqpz0a3_`7ve55nJfUKTWIn(m1E
zHg)X;e-I^Mt@p=?^EhANY2xp`$9Lcu|EK*Ty*IAov@MvR81(e-10PzL{yYh?JEE}`
zVV4m9S>0V-APnCTt+LuWu=4owm4DbahFSRi=Pjh)ANfRQu}}XjruwCscdUON{_kM2
z$P;z#M8wVU`?d=+FX{T+ibEsN`>)oxR}@rw?cNh=C#L|@I$Ig1<jDoYf_gRlwNoED
zKp08Zg)!klaT8b7g~I)Tqyou{--}zhqxv8I+!rEl<k|a~@!!xNp}+Sel9`wshk$go
zaY-nq*d~T)%P$F{NC2z^3_za9=aUwyPvJx2oLb;A@$Cr#`2x=zPRII;`r9i-`yM?e
zn?5;qBj3v}J*dbh@>$SzzbpJ_iUV>S&)hgumVTz>Y}2zd|3!B52bac-I0oO0|Ck<J
zmiXgY@U1I*{2}F35vPy}hGIrYWrprhNL7xNKxlP=t5fLhBEO8#nv%$&I*E`;_f!`L
z^WXDXrLyUPSq9y;qq#!2OP1?fM;fFMK-_qa^Io_(AMjH(=7rH4h}MeHtqQyTX4>TP
zox5#Y5a52?A6cCT?^GwW?+6?Z<9@&Y@ydHR(5yWnBJ(p}Y>Jp&0p)WlYc$s+Hc<an
zHaHF)JzFo>_rBrD#<*bfqobUS!=`k+p}5MsyZRouUelE*%ro~I$A?p8U&2^Y_6K$D
zzxGRlKM=aS6U|b4DQh1NK;clQ&MrQG3oSGI<LbtD8}u5Lp5ESgV)m<R;~DW-L!TuV
zdtVG~;2#4gZ$Pq3<oSXEUP)ym+1dKnhLb+Nej9b)Stn1$hW?hEd3mk>?Uu&fw%Bxe
z{C(KPl@(&tbIZ7o*NL>_dT~j=U4xGR?V=bs;j*+m-;>7&fWT6)?3p3pV%|l8XIXg{
zThR1Bgg;YS*pb){*+*IHi_f|6uiWJqoz?NaSP$Tzp_o4T!}oa?<*-{)1J07M+V`a1
z%g~-5<kN}Cllu*6&e1K0Rb`trYQF5+7(Im2f2Now(iJ23NW|)HO|={g2a`k$kp&b;
zW<Oib^K^cx;z&7Xo!Y*C*vEFXEH^0n+ofAWoDdDL_RadeV|e`C9J6Y{TVR80uta&R
zv1jIgk`s77QbMm>ivjQ40*0?PkQxaKWq7Q+T{A3QI0(2+TQ8!8`mPCy7^GAPeX}!(
z<R6N7QU3;<9HL<~4K}EN*+qu%-Jvz}s7@YqdAzlzJJF(YGV?}yR$2ak$z)}*O18tf
zhY9$E^!%`7v6Hdeyc|QW)ma(WH6<W!wlIRDa{@L?wrZl3eB338BcB&b?93KMWs&lz
z3k=DUqv=<(24sEPr4V9fXuA>jOCOGqe;0#IjLsIguWS#PH{e(iWIMqlLKNezSyBCu
zszHC6Z+uzo%TA7B2j45qm*8m;N-XEl_*ztT&v%HzWN_|+zOG=C{hnjRx-3hO;XDeb
zeCNdrPxzmiu)!V(-Q`I>U-w^EVD(*7H$J(aAoV+(`aY{GqlYax)h1W@UlRKCQRR75
z2_Zsm5=0$%2xG|OJJMpyRiwVrpNnTBU?f;CJcZ0A?7?LdRzMDyaZqCs{j8X{N+-H0
z(-0?1$%eAH0(9mJdxWW`;c{r!nn%va9RDk8{{S^mv3=82LS7?;qS!157_Al${Nnsj
z>ccbD158BoAxlcn%0n&c#1R&_^J;quXD?LCw#uJrJbd;}U`+eb(c%nA*EUn<$Sp#q
z8!rp_-@!qPtO_R%oF84mZ%4Ev<Xk4FhJs8v#zg}in+lwJcF$cbAeYROADla!Az7uj
zYxHJtF<mHa38ErGfTkwR!kz!I(RzO@8O<O>!glWuo@QRN1rR*idxdc1@zfh*o05XN
zcO%YazMo!>f7JE;?zv>a=^23w?Hrw^=-kZd1<eZ`!x2rfw*)^dIbG<SxZ8C8-oI(X
zQIJzS7fgxocwXcDqZ$?iOV!IDWad0fh2=y+RHpBk9?W<CpV(FH;e*!^`(54h4q($0
zeW$pZ)#4AMY-F1Mn?~-NCyG1xOs2`5tw{u#LH<MLYHLR|CP8v<W^l$iLDJ(9y=(<t
zJ#3B&y0`eAz#FXIeve+<C@>mTbP$mh;-7t0A2MM6hQELX7Zm<Zvg9|T8#e0+q-yud
z8ubX7d-?Oywat#XGW3Z}2)X2)ITlP;7va;Amq4Gj+`rFTXa^%FCWjEnso|4JNJ;>?
z?jX*NsT+7C$6tOQn-*Y~-qg=24e|GW8#SbRcHvIW5Ts7PeX8=}oR(?hX|>IE23PBN
zyikKC3Eflv)$M~k#r3d*TKN{;$fn@NcKq>noALpxegv$(!bYq?lkZIUEEH#2DV@B1
z7SXN5Z*Nn1j+uT;9y81Ir>i1+YS@|UGC4XS#{b9Dz4$Zv|MBC$uoK2M=VLafoX_Xu
zY{MLLKIMEq7E(zL8^auPrj(o#qR1ga%~_#FlFmp%D&k!!?6=SN_q~1phwZvv*Yovw
z-XB^Ev4oD3D=_^2n%F_}F4gTnFoq#@cjcFzcZ?HAYY?v+OBX<|7MnXrNb^j>#so%c
zb4J%j&G&nCAF=oTpmeMV2Y6bFx+!}bb5y`Jhq-}?UkLB!y*sgm*`|vjg1f(5WwZUM
zC&W9EYI>jfV=$AZ2?6z?{A@BBIrnjHCMPPtf&htwY^~$BTDJ)qV#iDSy+)yr(%|)&
z(b%W-Cl*|{w;?OEp%J12W4}COsSRd&30k&XzQVTN%IqA<6t_N4^&m(B6zVv7XD2@-
z*+=kA^SHH+Bd37}3+f5oLVao3i{NiD#L<ZlkJkLgyeE_`pk-=g&E<IzahTp;I=I#j
zYOu$s=u;Yainl&9`0^*A<V>4<q}h1d+I!uAxNmky6e^+Wt8aEV1fA<&kTx|?3GL3@
z=6;4eO@aJoKVUT+nU8B?EDASP;0=D&^8vv8U6wvpxwn@DBfP{Gws)Y)CcW|h!SHzw
zLy(0d7Rf{pi7jYO_CoGVTqYJLv>2PKNx|d?fL76|$IvID_29EJmkeQ>^g6+L&W3da
z={z#Hh+F7BBO#V4fGs0FtC=3t!dW^<Tz^O?D(@^(lvy7%M^MgOKetq(UWn!)Paq{X
z5Ym0f%Oq<FO!A|0C@>j6#S8R7*_-I8yRlpaSQ}wWgC9ExZ$V)4HtNoOVN*wVK&K!D
zh3b7}1ubU6q8Jt=7Y7*@P#42q3~#hd$`AznkRp!(NH8+XnvC?=NBsZT<H0f)$8b!c
zAhUYg^qW6tBNG0Omgc(5mD0d@qYTl_COAtHPAOuqGP6kkgP?>{4dYA?cvVbsT=yR!
z<2vB49JuR-xi1$X%ffT2nsc~Vm_Q%Gbv}LYB?puT7$G5pnaA%=z1!t+{1+K<m=`>+
zE}k&I#YIqq%dNoWKk@xfcl0-z&=les1@rfMWEZ8flVP1S3sWNJTsRbpiD&(T@Hn5#
z=zu%ik3YPKl+BLk7!GClUxo*8*azqbAO#ix!6If9(Vty88~L5da|&EJMxWDDhuIHX
z>V6_~*5$8}xt?VqSze2?Z6dEO^QAlF4!(qe8r%Z{*r9b7p}UCABC{zJaPGg*-TUWj
zq$uo6R{DRgqdU`eOmPN13wBp7MvU+Q*}o9yZZWHeF0#)->*7*}ev3XPyDp&x4C0X!
zB*T2mAkGy?XB^@&R+zmwFwFrHiG_UXK#05+hy)Pe1~5>|V83+{>CsZoLNBj>z*~$I
z-OE1Hse4(ei@h5SfBYM<o{bEkSDY0Vh<}1iM2g&aRrKI9WMT!;M3b;58>N2X>!c}F
z>gwFaq#Q4Y0uFiX<UF7w<r%<~Zh1-AtH-su!^4Fz7R)idO!Nz4_%@Qf%-3L*mc5zm
zh6byg1WRJ#V4Zm%gn;8o<e2V>H_I?@sno?P#Fs^0p$)|Fvaja`qGB1Aj=es?&dw|~
zfambS_YkcSx{M7Z6MHoHt?>2$;k*&2_p-9DJTpyQst+k@S`10u1vlZcR>DO*9tfH)
z*<f;zPmqALr^^Vy{KW~lqrrzLxD%b{_eBQsLOEi<nb~2H$-&}y&`}Co$^1vl<S2#)
zn6b0h!J{{_-cKN1k?d<&q4`=qcL$F(EKzQYtAoh*sYB@g3(*hD^<GuxF;w0nq{#f$
z8^wJUoG9*tWfAypgIQ!<r+V?HOQ+#~xYc;1uvZZU(mY!HcCIAr&q6n2WqD_q{~_IK
z76)iiao+kKC!qtZ(Fv~BhXejb{0iWhM8^&HYjE<lm%{N<lSmf!P$(H{A5gs<&YMAZ
zvB!8o0vi%g@Zof>h+=MyI<8kcYE%)Wye&jQYwq6-zTcm(7-#eTWFd16w+JL6t2>H_
zNv9tMb6H8ktBO56s}MI~fcS3)f+TdaK@u7;oN0~>FBgHxR^F7knhVgtRdHa&gZ~+i
z%Eh;xVjBzHOLcRQ`uzx064F;L5pD*p8cx5$D<V>YEXd|PQ-r`@Kn|dDJu-#7H_PGb
z6-{4|-fBD%#T6ygGaC-&T#lgq$Z`%;?mhr%j6D7K3!=IfOo)Yn@cDMThz|}BU>R~l
zI`lSEbR@yl;=#|+yg4)lLGAyEj$#SOH|}kf^1P?z;n#(MVHDht4(V3o{aWOScI5vZ
z&K_O_LFwII^h|?XL%O4Rqyu=~n;`~XU?!MtCD>fc6?W^mQ}!%ePz<a}U4Y;K3S+r<
z#!UBjBKRPaf%KT>m2YZb4*<K8A%A~6x)zHwbw}6xU^~|nP;zhNbT5+(CXuY!H|`ai
zvnQbtZ~@T>2;d7s?D%UPkUXe!&;uIJyV~L|EzLW%g3vi`(@4qz?Pf5nc73jd!%XzN
zn&vaDpiajymYv%9H<@*gbsXdx&u;D~NCDN$$am|aW*nkbbKEN;qBn(r2Ieu_U+kdh
zUNpvn-vwmoLH#trn@tklTz&{+;dq1+hKm4|#Q(XDJ8o(?`JsiVp%ru)dnc)CuJ)p+
zXGe$8`#40;j-8SaYM)jaFC)ah!u9Qmf;ruVMXlw+vh6nU?vkU{en)w1Lii8#ExZ5&
zcDl!Iafy>X07@#8;OGQDEDMI$fu}YRulyzIRvcg`n@?u>EHpG}LHtLDM(u0Nr%o>6
zzXAey!#%WAN1}w1(RKR(uDdVUKMji?t0g>F3mad4XkZj+G>9b7Q{TuvdH{wfNU~?q
ziZx0g1pqq*oBL!KOa|BsiiSCN!56R)RFj|C3#<RJjezfT9mM6nfK56y9e~y*AtO3q
zq3>jZY1~!2@Wo5KvCFU<%P?xkU}5p(<#&@$GDJTN7n?^<HDgjg)muczk~-_SGV_F(
zc4PCJ_~6B<%4Crnja^s}<S~7Ka6!bQ7x4wl;h6vAcC;XC+f+3Hl7nS%qSHkxYB`_f
zKJBp;WGarq;nM>%(?i?SkKr@JN;9LjGvmw*O8(4~wwd61aJ;`tY`qheN3r3B2LUyE
zc30nfa0Xxl;%Qt|QD6<p5daoU=2x2ahd0pgoo(vLns;3@I_LG0w_8TA4D|f%b@_DQ
zndr#f^Tjk&vH1#}c0SJbJ6!9?n-7cU19J&-6g=OT1b-%(mUMur9j6+j1ZM=<n>sj4
zD>}~pvd^k_jjb4o#Pdn}JeNJ9FVDjQ$So|fm*T%Z&oI+xVvp@ng0F0C4Se`sCqKWv
z@<NeIr2{GQJ_?-V%G(^^eq5{kdj)YnlD7uQc>xX1A!&~;Gfw<5*C@h0k6{U;pM3uM
z#mjSA^TBLxOX>J;N(=Wj;LQ}IXh3mLv><yj!kd?)id>;PXVvNdU<X?iGVBD4k+WK$
z2drsw$6(>_J-8@KBxB9c?!~Tnmt(qPZ+d_Rc`hsR@t$bTUeOh9OsYTxmysagpl+qV
zCMR7cCN-qf+>UIURp=0ZeJKbU5Ww~A60Dy`!0)mk`*j319voecXlj2Ykdx%)z^nDy
zqwt&D&&??I1*DOWO_mQ<S^KRl9yBZ@nyrrM_7<Euc?t9h@xlKocYqNCIb0s_nA_a)
z_1=r*di;m3mn-#)=qdb<!w;|8<;Ryr4r<{yNWyFd3?YVX(j0A~<pqyj9<o;o|7M2%
zy-jsyPP2vW{ZYC_p3lnP*;&^jC<PhPiN11sIQh>108%?c7GSvZDN7M;pFZN1H=oV(
zvDVzm6sj$dvFPurA#zt8^(bpHTjY`Q(reG!pOQjb>a#iRa?@PmK?%~(;1!1&52FtT
z-^AJNi$f(Jy*96FVxeVvUqZ^cTkRFdeS43;*B&Qgx%gkqx{Hcd2pwj^3gr2V{h$vu
znZ0^_op(|Mc#MQZI&e;BaI2)R;C(HiH_j`XEq!70#AIyb7-JFN*Skt?f1>jkeuf?R
z@Y(o$((gQ#pp8f@QonyguJKuw!HM}dn!3$*8Om)YoBOP#&|>au^4Al{k9O5o^yetG
zWUdUffr-yoGS8Az>Rq#=HB_OK{juHC<E;;p;4>uH4*&K^N!r6&NDTcs9eV1nv9kJy
zZP=pKrN7@kop8>v{r=^|sg=U-Umsb;)1hByzVE91*t7rf-<co33x6Ek{qgVFk0ak{
zHwS3YIx>P5a&`n#IWD&`=a*&A7rW!@R}20TGHJ28QwZ$x{P+=#gQ}y12KhAH)!;iw
zfo;J3g^Fx<?WtUikfGh+NU&gw$Q^C@7v`*c1?WBDd$JTjn4^=UEgrlq%&&4!7G1MI
zm5hv$6}*S$rPNj)$3FC^-!FT=f9lF!P&@-Hjzd($f^&)%K>Zr80B8)-CT&i(+g~VG
zl6?|@d0{J&o>Nf)>;WifB&p7u=l4si-we`-tDkJnvP#?iDuyMumZMA$5FUeD5Pv5p
zqnHqffoTkb)A(+m{`uz^c|Z!jmTW33$3S>t^)-3LvZq)5*fU<pNoLVfm*||$?y80U
ziQ{z64z&ySD6pO)`1sD{n;+yht|HvG1!A$H&`$0Ig~EFh|GFfADkLWv3(BE$zT1Hx
zmmW@kJbW&3G=2}>q56+W(03GlhN;849n5HmXQQUO*FMU;y@;q?Q%scR^&>R|e^GoW
z&zq-@c3QT*-m7zP8+jjuWC1Y*I%Vn0k1s&@Rf3o3D|jkO#=cRnbIv5~lY)KOYIGIN
zf3{a{VRiQ7<I<D;!eYOFxObJoJReeWoSJAQ>aGx>te^CexZ^=~<_<k}s#vsKCFIS*
zrgO97E&E$uFSlOiHvBr`bODk0h%CJm5k0EdtC9t*Yc{>*e2cek9E1HQ6&Cf$XW0Of
zz_Ooy5X<~G(TBf3Jw88~RPa_1@jYmY=abUF1!fJ@`4mZ2O2v<RoqiddP`xjgzG_4j
za8(>%H0TK;-!RRV6$73PrM=?gdE*tacXoL=6LHe_T_V9i?p_Qg5aw%*8(Q~TDJgm@
zST<BBI=I>=E=&$y0+VhtWN3=y>6yL52Tm*6J1qW3mmj=8p2zE)3cSO6_|ob>(AJY7
zV9IQ>=H^=KDKy&=Gb{xL|NU_jczsUwYAHmWcr|U+^M?r%&lgAFu_<fL4ffhQi6I+t
z5`>-uda@E}Tf|Y-Z`=Q*ZUSz_tiV10UCt{&N8MLWG@F|2&5=TO{~Dc=MkXR^+pUpr
zAC3yW(Y{*DrWbu2@P#v@LahCI`vM2RJHs5%N@&0Kwyaf~R4TP1uZGV~0V91%LW*qs
z2@W{U6zkl8joql4P%U<vgzoy@WO3<*i0_V=Z`HwfvA|9l411!7kbC)Xc-$GF$~762
z>ANR|U2>?OWf^#L=4Mjq-#7U#&ir2Gw2JGF%^Z@UJd5Z+wq<@nKTkWvEoLV5v$S4h
z&o8g&uAv`_lE+8_ClI-N2WH#*bNhO+ElRHBUpGfB_r27ypgZ<Imm*6NSsa>lG<wrz
z{Cr$q{CX4%DxCR{ChHjfan5?W6O%29^H|}E;*~=@Z)_R49}fBTC#VP?nhSGrm*N8O
z`*;G)lD%K`F(BY5hblupc`o6`ioWy#aGQT25s(0><(d@WyVS>b)EU@SeNG_UH;nVp
zvN9Xqc&)C9EBzV`Xw+vHEDJVCioQSnOn?Z$<Ad+I1I#@A;x$xrZo*XQs)=4=!ulC<
z<8D3|!@%gWtWm<c<VljM5hwKInf2EBZJ)U(x4+M_GQxI%DLJE?qhQ=#Wwy!LsrVV~
z$8G1x$9-)*`k0GH=a+uiNTD>0%qbQK@Yd(XASW&Z(w!fdCnO?n$)#76QeLJ{B#Y@w
zU+-tFy$yS4|5F+nQy-@OtC`{{W1?K9zZo!9@%#3{mzZn5wH4`M%|}@?mJ)wU7j-v8
zs=ZcH(~kc=h~$5MD@f%a9Q5(2+U>MjHk~gHc<Qp+m5d$Oi8v%t1%AIgL2pwc07g2g
zvQ(E&n@F?mgd2~<6(q_P+CF|VzNMC!-yU0}b%6eelUytkxVA1KoL`6I?kvAF7DmBK
z2QpBi^SPx$!Qz+DSFuzYbCeJy7A=Gl?KU$qFlRq0mc*yCMu(MYb#OeUp3nu%azP?-
zQgnKbX)b1LmV%Hu-jNhKnxg@UpCmdHsV5GEOt}v-3jN>>xL#5Tt=X|SZ`)6dn}ywS
zY(<fCmqVNtVCT37gP)&b6a3SJ)Lv$R?*_tzw~HW78YPnd3(8)1&swGMz^@d`5E52|
zb(@_k2i8JVQ#K83qQ|WsONXi#T(S-3xh*`soE0|DG8t^)eC<VJs5aN?)zUI4#Nt}0
z?$Cjq)ZGz*PLHu{+9mshCg&SpgToBpAJ`{OIM?hoh8cgmbSin>`R2d1Fw-N(!6_1?
z%)zS&|4nQaVk5hGzRml!Q)=10<~7Cg<2<|+x-(N*Pm(A0Pa{?=AfKSsST8ucVIi#H
zn2~H=#~RYYSnJ?A0rnTGm8-ytU<$s>Fq5=^VC<BCK@>ba_-6V{vVhit%eX=er`eW6
z<}dkM_R=j5TxA$iWUh<8w3{e9#2QVe_QQf&>?v;zC$`4!`tr14HHpp-w#J%!UG8>p
z5^VVcIkv!9gHT7R`p<{LdfgMe;r~#<P5XKyvcK*T9HZZe{BtOjTO<UlO@y$<=8tGd
zcZ%kWyRml8rVXy%^Od&*7ULF&4tKkFtXl}KZ@kKrLhg1cpXQ&!Ofjs&SCAb~g8yGc
zSC3swf;YP~oVB&N=V_Zq_q&#wo)%8Bic`6h1`m6^xDGo>!|2xQ&u650<Z{?V90GI7
znp)w7XuO@Xfp1#bMU@JV$n%|??yd7~kI|<oo?6B3+T=5;MaI@qa27G+&kek+X4L^)
zIz_J{1#ZD*JDg?VlFr^)A|m=((elEl*Kri2(fkO%(K&yPvllQ@$Cf#lf~kcHln#lz
zJE<}G%2qL$JFd&9yf)6k(&aeKcs(mwq3f=FCsqZQ`YhDA=f)ZZ0#F0QEcJLZPGVzB
za~5q}Js*Q@P+w|Uj*)c!@fP{d>A}oGyGr$KLw<rBBM1pFo4E$Revo>6RWc@#=gFIu
zE2@{Y1iFQ^B&*(LrD4?o_F_EscZo~Z#=%6X%7R)rfs*}UR`Yb?h7-o@N}3Y49{GJX
z6l&xKz(&2><E;40z$E3q+uE$VSwZc{f{mVyILM~fc^{i)VZ*goiXq#9TpH1t@V85+
zas;)H$*;R42PECYE!5{1^TLv+MB1KNYF62N3k21|mUP1IOC`^rbM|^q{t2>%krk{P
z8|Rpdqnd5Sg{6&BE--tQR4!JI$Bm!(+dZJWMlk9A12*wdB*Y-et<8nAQG5b6vD$kv
zSo-#>_Kzw16WVuO3U62T|1v+Hkfv1LxcGX25vF}<N~Xjw>;H6nK{I!hLW`!CK5^?G
zJWMf>G>py^AsUQbF#cNpR-PalPu-1E?OGm6Oyp$ugo=Q8vi^>Za+m}D5AN+q1tDc)
z3XxQuP^O3g!cvgWqOA>&e(^C3zT4c`$qc&V>hISl-}(MRwj<YTU+1;&NUH+Ps(-&A
zdk;Gi?7yCiOVo#4UpvuZ_2hca4)_!;P>6LOYAk&qD#;j~5`Vnpy&r}I{stj{B@5s~
zU1lA(T+CA#&G?Ko5_8q{iwYyL(TscZc74*U-f!cXw}1bw7|J|Uu#8WTxDl7LKZxn`
zotS!&AIE&4{<-qy_yXVnpInoYc)G(_HeCXKD=q}8EW~!Z5@WVtr_(Ld9H?2xm>k8K
zPZB*F-B;(`-URSayEC%8IE=Ph)gh%iY{}X|cx-RfU^AOKG&uLcIh}B49b~D(kTWc5
zqxTo@gW(4Cz|v0kZ4=%@u2Y@q#%NHW)j&#LdY=NTae8)j2ItyesO2REGLYGi=E>MV
zqzQo~ccHe_a=sOa<W4C-G|cd?xIpWAprQHUYacRi<V#SO!aKc5N&StthRyQ@<x%}Q
zm;1k+gGF@oQ;WJkNwu#2qwyw>-hmB2w1PgdMs#`Tv=KYNoJIt-ysS5zJ%6(C9#_+7
zckVT3EH-QFt8ub0Z*?5XdKhfOy`|~{)mW-E%}V1zlc5f~t$JUP+~Xa?vC>{D%q&~Z
zNVkk&IY986Cg>%bPYHF|NY=R0HMZ}kkD6t>l;zSj?>`94=%@3aLJ6dWXQ=LGhZD=y
zXu9(8)&0mGMY(*nx1643of>2Jl-BzCtXtMz2<x6!*c|0pzhkz2hZ^e*+d7B;)HQKt
zrpt$7o*2x*<h<1W6cd1+3&dQ%@XRC-6U1Tm>}6dv;&al>`oA1!Z9Py_oze^jI?`=7
ztCZ=cNmLNdKYw~EySt@2MJUr`8PZkDV=HFPBQ^|sH|D5i4l#Nl%r;(TTf*bbA?c8z
z;gB&whG;X;Y?v2gWEXR-y<F}=h{wb9L2IKbf^|hQEiu~qPOM10KXkP&+rmR3SqdIa
z%I+7+j?dr(YSG`5%F<vD0BVNM9%mXgJCcRuLuAjn)7AweIeJhp>5YEj!EYL9UR*Fy
zri|>wTW+jQe5~ehqO+5C*k@ZODmf=l6+<%BjHshFw1h`z53Ozw&SZOlrz6WvrwCz7
zwq!Mk@SA+ezM-f{E-VVBOXoWG8lv4-E!meIvXh@o&(ezpb@ibn|J*Rz%5YuEUM$AK
zD73!Ofyvxn`1JvB{u3^54!hX8e*c~nXX@wVerpiW|GH>|#~xv*{R;Qs>X_~B8cdIY
z1r?-ctVOXAr$9tK=H=5&^OD8ZDytDKgWrp))6DjXM?|ZZO<93kCpecDO+6=8#?nr`
zK8hQ^KC>H5kFXx>*RbL{w1>7k1ar{)4d_#J2hMK}e%23OOFo<Qutq35`Y=D<?Hu`i
z90g(=1ydY_3LJ%RIEu78iViu7%{q#|cU<mcHGr|jCwFVrX51YV&<Q_v!p<qNku925
zAB)apJ!B23;ti{>nq2~A(jZZECsGuLSE8B>*NaIhkhv$!4VcuUac2I30)M&gdsEZY
zIGWTH)Z3jWU!+&`L2de23I4^Z2gSObU|oRCas&MLUx6MKWZBW32FtQy#DZ*oI+b)g
zTi?>UwuwH)3u|Q|b^L*bvYRabDXZ28DXuAbwYa$4YJV2lIoK*cDVJWJI8*|EDY40<
zDnZmpikA>bUX2n+hXi!6Jzyi@o53M+kPC@w${sFf^&qxPUXq&W1(VOHrFdYkxXij;
z+-gn!gDUAvZ{LBc0DzhGtYUL|%in@Jk(UYYA!$1rnN``?QLRW?{iv3RhW|v_l)b)O
zdCHP5L61FVi4dc_bVdaH97)OM;CxPHGZ~O}?#SvM%(B?9pTbtZJ%9>DshRZWN72i-
zK|ljBe;j?Ke>baL4&p-+W%a6DOw3mE&-fMz&C>FyK9VIc_Oqje-0@WC#?pgyPMcFO
zr#nd3n{vX7c$<9%R;k^rK=wSz6||>kcc6M^DY8Rt2Og<Lt=Y+r2^UNIGg>WvI;td{
zuMX9)+h$@k<5A0o4;Ozixa9So!~2GGlTY6A9Jc|S6r5Oc&2Au(SRK-rZ`x<2;h(?A
z4k(9<oqG+wpW=N6#|QfhP4a+9DOwnI<ah`v+#irW|6dt%K<(7t(imf$K^%C&1ApX7
zeP>gBeLiRU&mA2=J53H+pXvSXNCqv>iiLq<QI%;$=~`-B(secb@$Y77OS}#CQkPx;
z$jS=<ps`$RI`8rmASu!cQqbA4LfNs)zGwd^YBTh1a<^2xGyWKquAklIBUy{OER(K4
zgPq0>y9m1qM-35pU?yHr$)b!74OqRW7I_&`M}o<t{i}Df6tRAg#rM6ZtM`c2UGLc-
z|Je1+hWm$J21og35(hRuvv$elkMqNpmcUQ{8_t43p3}k1K0Eywf1%JuEf0zsvHY#o
z^nZGk(w!^~0MI2>CkoB}w93%xpzPr?v^<sp+Q*hReq^C5X?-=@yLn&~rQIKjMW;*B
zGJ@y@ObVFX&bq6|u2>MDsUmqE!^OgrXRh~j_yC$ng1(z#+MnE5PwjK+xoYxR_IEOq
z{ZY=E)Wi*%&x_pYKIl;tuU;bbFC%dYtG9+V46^zq;YO@K>1+JJP~dTGb{LqOK8L8D
zLgnyJotm>PaHz0Y%fe2nY4gLJ!*j}(Al5J-04ACl4lbK|X7%CoQJgffq!9ulX?4iq
zkb$TGa}KEtgG4)ORe+&dsBd9tBEd1@ZYXD_L)5eNsPDL#@1Zjw$FtmFaVNs!Rl?4h
zgeBOAo%ap9a3<{H8S668Rbvu`7>bSHIK|0pAB7pexPHqWXpQQFkOVfK73AA<Z-lC4
zIab|jiG6iAG!lfPkWYj+<NI%D@~Ll!`9)@V|Et}~%okhfb@=+^_EL}?p-Ib^nvxja
z>|qrZ7g4Y-bIJj7%@=Zwv6yAa9y~>yC8}lmz~0P}II=$&2YY3f!XN?I$i^nOGEsc~
zg{>;LTmGfRmQQZY(hJYXa8&)xKJw-$bu%*BmeJzD@WgPW%9eE%MrtQ12J*wa`+Qmf
zzBD04L#I4@YNipDA77i9e!Qx(o)y}hsl*G*mQBYCLCzo{Mx;}c8j<E~FIxbU@dezl
zk;4;j{FfIt^9>fU*Ks{6^)@aUyE|Dm54Ya@yW_B<G`!T1%x=i)81Qhd+W7lvv&H<N
zrya>ykUk)oSCBiXNSkE+YOmD0a>l9;zixB*?RjWpLOZKevHSB!9Q{p(Vb$5Ugb`j<
zt+At<KrGt{PpA*0IVh%Cdt{<Mtpjo|VyeC{rzYal^2T&Ylz#E_qvh#G3GLgTRhk}r
zYDj^Bqf_B+kE#`$+meOE<eRHKmPK3Fv$`F5eLNIczj|1qw*k5Kpj9)ykj*^1@8zuH
z9DA{uPMsf*8@Fc8`X~rvk&VG)^hx4ua7WfPUJh<nVEb1&K+g(nsUUD>^{n+R?zv>t
ziewu$DG)OZ)Ig_-w1<cvz75>_cj2e{s7h67{FB9K-dDGhJ+Gs2p@6CFxg3a$3M=Tx
zof<RI*GsukQyQ;TN=~KwMwX=OaBWRu&$zdB8l2P_uzQfRrHvYjZ;`!f@6++GFn_^2
z(>@$@$EHPup;{`+D3h!O{dMHluzHhyAu!UbHQD1DSNnwQl`~W~&C0I{rF(mRNzLW{
z*<cms&|@d7h;<MtNZxp*@uLUpk##vXBxJ=Oa&9kjB;s-=Gn72MzA)hb;M|zhe~AD1
zMA&t;DS4X~U89(3)!1^;lfw7V@AVw`-q$9mckM?6W}N=L$`yitx)wbVW!d|^KhNTq
z4^QZ061eXl*S9`sKPT{>nr-qYBbM4yE|(r4mu=U)q8NJ>Sb8JLP70h7L|Dk4hGpsX
zRhx9|T&X$teQ>X%H*5!f=H_7H1^0$yeyUy3^Bbvr2PRkiva=^v&b*Ndc*8{+_YIVZ
z2z-H)m10<Ft@6O4<eb__KmPtqP`vj8G_HT@N22!A>Z+CaDP(105&iq>Zvzra)dW=K
zmA6QRIux~Q9%kCVkl@snt;j<6-Oc^9-w|+e+>H{kD*M+j@&b}Q!vM>6h8s{R$}sxF
zrXQ;<-`1pxrP#(&OdM8MYC~I)hhI1^_n0QXkFg)~OZHW`G?8}b<gPw-^Kin?^6BH`
zndix~ACsT`NPf;prXy0~1wuV=n)6}XQT-MvxJP4cxMqQrS5_JGlh?v&S^eHrMWL+8
z0O(`umUkbIJ}|hvv1hy7A<_OLcW7b0PUk~ke97z}e92DfI!JlGeDs)u4Q`fG{-v<c
z6IQ@LQ582*GyfdVF6pEt>b5&_-xK?LA?$MVRJanM>wIPE9V8?z)^-(^=I|)Zoee~y
zR{r?-C~cAz4R@fpkdj|5cdul{@-wMYF<colfiqHg!ZaOzb?40^U^G`6?nb{hRiT0s
zU_pPDnZ2fSc6DacQI=HY1Z*T6ya+p0dm<%W?5Soby~+M2u0Y|u!pl~-dx3Ty+Y-HP
z%F2QH#G+M&G)8Ut-t9IiAfDxaoGIsu9%b!txZLJd6fTOvI#%5h``$F|RR=3NuuS#S
zL@tYTRy2Qn@D$;UQ|k3T^)JtAOf$HZMZTz~y~TZ;6|Jp!{V=-%%z>TtpEQA8#xPu%
zHL9kDDUem}+Uf`56H7la-V_J=c$!i~;Qtc{wwlN1)Xq+7{3oXD8#V`gz9Xs4&<vQX
zL%-M)Q%y5D`nv~Sd6+d@brL7e#U8|^GlZT;$#(Nq(lH&_bO)(!q*EqlJX*?D{DknR
ztIZ`Xw%JVQqhF_DA8J>kaj%+RI%XXI5hQ7*VL<HCnLU33flTeGN<UaTKUO_d*zJWL
z<8a>A@|!fDg~18!uBwz%sll&<b20lum&^5^oG54UV82!AmoD7oFbsGKnZc}3`B$-!
zbDqHVAH0p_>4*%v&av3JnQMDfD3aI+jO~lj2%N1sUOd3r!`+!NJ0*!zWxXneOBFA3
zP=uAEuu_6D&W?)Uaz}y`OvV|BPcEi7n7D`Ua+^JSnZS($E04~fVPOt1apT*#s;0ms
z;hSMLPe5&*laf(w%53dYaM@nUCj{<>_ZYWg=XE^2W%H2N#&Tl2!Lgq0e;_MJSlG&J
zP3OU>TkM(6^a$sazo(k2*PXXaZ`V`>;)Xqk&6&FD-gwLqpMY8kSWw`)d#csiDd`+<
zid~T^YNf*Tw-^uhB+Fn%kv!}uURY?#xUwzTCtcv`Q`J$iuCRFczP*@u9E!%jyKD}@
z1$QvZ?Y#ztzg%Z52-9w4dX9wDuYl+f<?crQ=L?+-dLY%3O8I0*cE)U983Cou#aea^
ziIUW&SYmBWju(n2Vxkx?e!Y!j3-dPV7~8v|IbC)q?5Q$~gS}Y;gk%ML-4UXhkc#Ro
zgwLz1bcKH*uh)F8KKG&Dz6L2BVVMRWL*Y8$6ieV;QgzYWRi4J_#|O20?O8YH#7S>s
zZx{b29@qF*Nx{D1D2psK*1Vli{(C*99ct@>a!<-4ax?^axoJhuI@~j>G50(@@adO6
zRF%~^x;^^)wTtn|G%iKUDxgya1bbmV-NHYA;o5pA(0$kt50kf>H)=3S(@Vd^qDBa)
zeI@ut8pQkc@1%Y&l2i;v^YBF5gH;n7h-!>1=_Y@Fv-M%{@Q}3Zm#OU0qCoK48nZD7
zZK)S5#LehLsDEX*ONwV^-DPcr8GX<L1C8ADWEdt<ZferwRdEo76O*H0VaeP<mfk$;
zSo3-rYY?8BPTIL>jDxX}UC;nr3Q$rA3V2j80d#K!FkqQ{>FWq7pC4)}R&f1ejNx7%
z9C$d-k5ej@LEC4B+>8^J6y2OU**T&lyETR3I44JOn2`W`Wt&D9BMtVIBQ9!KSO%hK
zC;zfV-VA7vMQOlAZg8c;=5X|10gX(W$ZDsERe3J6$Q$BcnIr`U($%k|$U!r4^6yMi
z>xyoHupIXXvbU(|C6@N!bBvpFVmbqxcF&i|=mmhCS>HWGAqJtNVOYIm44gu#yK+Dh
z=jV0GV;&zdk=HCyrs>(nF1IRs4?_%oc1|nQVz?r9vP_%n9JFd11w-{=s1KWyZ*9wL
ze!yuG=l2l~%)!>BWcJ{!Mozr7JaQ@kiVkL$3vKLH>zm0}#7<Ss5G|Sv-nY0k(k;{U
z8o1r%Mx~8}Nnuqo0#0(Q$}{oyd9zXo@=n%O!Y0B=cC3sQPE(v2;V2VYbrOGV9$=ur
zpEKW7A6o1q_vW)(dpS9dft@@f*9@_34?_3gr}V#zjHFc68yh>Wp9p!$8Q2bGeiRW+
z)^{u0f0i{`UuA4#h5~1wTIh6L<F^uhx~p&j1LEHEe}!F+>ni9g7ym#F1e!d?6)!Y$
z?aL93LNDK;G&Z2m*I9f2r+^%Q(0D^czN7obAP;sz#lE)9$MOC|e2!l?uc+O;Qe(y|
zxuGC{DbEkIbreL$H1Jf93)wpwv=tTV4sHEM6fI*xpl9)U(R7Qe9dlU}A~`Aab(VN4
z6M^*@l^EWj${&;8QI;^`*f*0x7hS88oIdx3q@S@1#ARDxSG&bK)v~m&D+Q1nJ#sqO
z4i}?Vc^j5I&evuz3wN>%)-Yib2dpQOfAMM41CWqCssMK}HP!y}h_JnSabEPAl$8Dx
zYhR60M)mgENxc43ry7m&JJFvNgY>7pK4?@9Y=2hG(4PrBp?P&WdR?<Ye>T!rv-<7!
zy6&j{vv_W2)D-$bMXYA1aU+MgL0o>oQhKU=G1Jy{47W`52ywz@h_?d#ghN(7z1QiY
zTg%}^4sYg9JfWzF#C_4vNII9*F`=!tRII?4Ar6a}RJ+?z>R5TLINvdUE1&9lZR(9o
zP2YqzaW={+E#GQX=9WO?T$HcG<pvci{GSUfvL4kBrEY{<2H2KvTq|1P=Xm6UtNn)3
zr3Z>(t!1z%)-!SLhGL)3w0nNXz(unSK1@mCvmhnC;oRJq=jb=jJ6Z>fF5fyyeeqQL
zJS!u%crZTwYq}a!tSk%^k`lWI!@lNAEoOVL#yL;R^82}BD>pZw|J$Nw{4L9mYh#$x
z|H7M3^6<o8zT7BqGv%cbkMy~`S7Ml}eGp@n`-KA2h8qDqpdRvqKafA8ALkKnUXd|A
zA}5uy&ISktuTe*YJ}pYmZrZFZ!-%j3wUHvnn>>M;kN9V#{M9(M&?{8pRCAy1W`pM@
zeqUQ#s4|5UidpS|cTvB~M0R}A{9au&Ao^bF4$M-HSw^jo{!ilIbn+(&iG#zd1HzdR
z*?yVdFa6`wlUNXPdeey27yWWiOcFn}5pp1W)1i7r|Fxza(y>VI!Wb8bJ;?HD#g#>d
z_IRuW^vK*R?T4QCno9uny<LS_QI)Lp{=~%`k!1FgEkw7J6LrG8?cc$V=TOvBIh9-y
z@2^*G2b`GynY}e;3IocRJLD^`2TYnCP9oC<MtMQXtex4RdTinzWaU^kWe>C1@pN%M
zGf5#fT{s)v)k5ZA6ysunTO)fecv(`&p0?MCe8ZC4I1M2te1u!(%IQi0p|sM~z1eh?
z@X9+UaM8mY@fjK}xMAZrf56zoh)Lta42@b4rYduFfdaaV&yk`0`-a}35G1P1yI)T5
zrcz3}QGYyFl56cOZAS`VtT-&*3Qduc%Z%=;34>?e!7i1^xjGIOURfJu=*(pB{WoPw
z9H~y2*2jR1_H&%jBUqvIb*&M#84D9EUJZ^{oAMcF`Dhu<qTA<cf^@>Q(Ra>|sd~JN
z0RzIpoC9)fMP}v#Nn?V?cy&69!QrSOy3WQ3Z`O92ND3szGE0j_d%##FUy$-K8KE-D
z|8q5bXPK~O0Z1c3?X31Kjtddufmq1%Kh>>sxKIbj8-pd?w9#wL#oL1!-S1%9%{6&^
zPJu);czxkN3IZxQ_U6D*h{7UFVG)uhpu%fRYw>ke^%l~g_bC+7Kg$Litp5Y&2=xMb
ztF9|Jo#Rm%yKz;?s=rsCn84rJkjRL_QX9E7$FYXd=p}}EE=c<i-elWDHC;N)!P*jD
zg;RQF8qIdNk*?i2rcOT*MEfAO>IRIlI)eatD}s92n8wubLs)tZysEXuksQuaLL+Li
zkiH$UVU~gcF`P22cwh{tJcc`gru>+FXR-u|{EXM^dt>(<FD*&gNdY|yh7$8f%*)mU
z|KR&Q#)+u}a{ILCO9I-P(9r|(PNnb-I++kM?9840j&BiNSk1&v5ha`4<r=S5O}edR
zh%b4l`CA>h`iBu9M=}&m6$`D_S-&Z>*URi82cw3=Y`FZ9pyhNCWx?QteCHER=&JFa
z7=Qia(d>6m40o!n4l|7B$4zVfEoo#=I0r*4nV?x^enQSgr2B=hqq#W*D@n&+UBk;R
z5oD^y-FhkKN^AqXM{ixCqzPwTOsDW3v&l%WUkV&ooL|GDpQ!@asNRv_x>=zM6T(lW
zam|<mF@pX2s3t%YgcBr)<h1f&fRN$TF;Woj;Z%YuIvO@F^Z9`yDDw^T@03(~lY?f>
zaYAg;Nn_IKV+uM@oiTr9<9Z#Z%p{IUV?Kgh^O(6&uubD<6Z)`CvmCCf1TVI1xwfIb
z-AqLLnN)En@kF@DHOjPE8T7pgJQz(7<_W1mggIpW)&9gtwgHGiK-r7{--G}_Qu{Ni
z24JVgaG~fKqr{V_Zdq_Dh!K4}+EW(<O(N(Wu%Swxo=F0kH2KSP^A>sFpApHXRpwl%
zExp*$E7s=b$L~%3i&VDV?HtlQfe{<MumBNAy)5O{-wm6hFmZv++a{U52A@GaviwJQ
zbVs8ZGBa$9zz-kWdC9&0gvA(ywQuEOl8<KIW~gQ>2MEanLl~UlbV}uN4z-d%5-75i
zAIgC|0+g1QEN0XYpeTe$G(#)lpR)+y^d!%QW;VZBF-ZKP!$&yNOYvF9PxpiRN?457
z@cL6#mfc?mCZcT6n<iqi&0C80a*ce0uMm=B{LLQ>#cD$xnk3)zq0l!?qr-u|anY1v
zeWJ~c!P4MJGe$u8aAjer8s>^)@Q9a>mEIW(%f6QAYo9Eq%mN5(Mlo;C$c(XnzhyaQ
z_FVa?YIg`vh`IS)vHg}D(^?k0WHP}?ffoW?J;XzjD07lAHnD3a$!m{r?L;Jbt(h!^
z%Mc-O<JMTs60G^*LY%JbFTIo(Tg@~q%tfWyB&P@{BHm1FL|fd#=+I1JY}#+<w%Xwr
ztcM)=QBFk`S>)Xd?;|A@t7o!skc@wOze%`>+*el~Lf6yUpgFuWazw9<Gd^LAxo{=i
zJZ#C0*H6HCd$2G+;Iz<V8Q<BAwuf!^$?D;A&bG>53S$-*x6DcDd_*#)FDhb@pvgBT
zK_W1=-M)DiDdWO30wC%ChZV%Ni>p48{qa*rl?X~ltotkkp0zB(nZexy5^O~l3QZgF
zQ`8^J%n8dicAPCbXl>Y!mZ9T6r{h6(w0(DtmO&s&6(h-DFsU*<LL?*zR|Pg+W^t&U
zD}cMt{XO+0m2f?4Oa<<47)&({ero*P3g>VtV4>n_FnR;_<?T$l%XQV5yQ;D@_c`@e
zyE2qvV<3<p`}?ly!}F>FPh$V9l}@83{)YbGzDSWZTD@bd0Q8ZkAAP-jptk<g!pv5|
zuX(t;DY&z0Qsd9E(cG}1c$Q4ff`Hfyr<D=Y#!xzZENAeeEg#F7qD4RA`bi%UgC1dN
zi3`Aa4{N{)CgFId-)ffZ1+=-HgWYmIlYzKvV?;@}%xBfNMd~bVI*Y}*9gp(7z<q3+
zW(tjoj|eW0RB%f7$L+Rs4tGpkxKG~fJb9VI2VYg*-H|V?9C_&TDKcl_e3k$_U5cqV
zUmVMu(>R^qW;s}?(nuC{VR?1lLUdvHiQP4^H5T+3`6PrXI<uZIQVydGV-i@U#aPu}
zfJ9>ROo?o9sTN|fH%;3zv>Sfv-FBxlv+%>@F#a*^9ZtW*5eYwnfs&y9i>{;)skISL
zq3sdlD)9cL%yFS51*3Duya~ZzyL6@jtb|i?2n%u;Q3a)I2<{WoN*Q8@WJ9L}i>Q5z
za|xE0_boFLh<W?O(gdsOeXE89>pNP_tbhnrQ__6Xdb<0%_{fB^z!i2jBlM&JAKL*k
z?>do<>RITZC>+=`X)E=gGsP?dd&AP3yqN@IKB7X$=J<iG8FX|>OeIF<y!#grdTbO_
z{vq%in@%5#XgJ7{Z(Oi>&y>&1nOoai@V^l8>+WyQ6U)X;38Ow@H%`||;)Kel4TOqj
zRQ*S6Z3WM(eEcs^FhJ9`wV64Ey+7Q(Z^4u5re(D+`T2~RcZLoU#&?$a0zyklXXx;a
z8j1FJ-xhMzyby(m$!I4QP)`ACFd?|De&elYRmx$FR{9*H4DBI7<?TS+82)w4`MXSW
zssC5JX8YIk%g@hnWVHJNf4-aUvz&i;J|%g^q+?WpmM#yW*+FLu^e9Sq+b+@1CkkEl
zACf+&`T&>ujz4*rmdIvd$SbXe0JI90=-C2gO-}-HTUTVKnyn=lBm>q)ZL2Cn#f0rb
zdM-ccZRWsR0YD!J5P#>X+H9tsg`bEV!3Ot+?VDM_BaT`N9UzOg+pH(<WG9(AQ?Iy3
z;?*gSb$K7*0?^L_dSFUpL2Ai98fpd1edt8uh#$-gux&M^zPjv)58<maeU~qZ(JhJ7
zE>L}t6v{eKmH`eZlFn!AmySDU8x>x}8gE;&b%<w7U+r=N;Z4>?L&BYXB!pAE^n(<o
z75QPPMpRyGZ|aVhPSmKj+}m*Uh@UqPO3qU8y(Zd<d{@cZcHn18h{X-dzOOzkJ?CYv
zDOnluc{?WmF{SB+^_f{+e{rg9+w`3)9Z)QZjKF+D+Rps(o;0{6)x&SZhquDxZViXj
z^2_s+&Ck1pqFYRpKPP**KX4)Qbr=2~dPTA-=%$=22lmQtR+Y=?wqMkiQ@bw_TJL=W
z?^BNdf-;xo192B-i~0weEx~d7aYA44;@-~J2lR?Nb+rO6J6&Xj3tGgnkVFzb6%^sW
zT%8Px<}iH;1!e?U&zXw~Wtu(9)d7tJV*fH+8>%v#4~GVRotiSMli8a-ye+=Q!U$bA
zU1AmOFq^n`xy(^uqU-SQU?p2m^30WP{psY{>;#>W!P&2a7L#UZ`2I7t6guY-oi}Ap
z^k_~hWnS@UUNhx|VT$w2KSaNoRI**k>({PJasQWv?&$0cK4SW%uS|`LG3ocjMenVI
z&@x$Cp1ju;x!_VY&&7L{k8hN=J!%MNYcc^R8l;1`4Lbf9FIOHF^DkL$XFT>?oLyt{
zy}RY=fs$>i;`104#%J`Km@C04=<Q+b+F|k^K`jbpox%3ya_Y)SPc>M^)}2S>k1jV4
z@p#1HxMk)~N`CR@9_=wRUYk0G3tzwK6ie63&C;@oj-;_4(6j()jjfwPcu>|IOJg@8
zOWgO2hmyA<ZNSPx3&lOWhP5BY?ZB9_ubfBtN6##?yyJ0HhG{s<LAB}L9cH$hAok28
z&<_k;uaG4U9A#5%0fLmzWd3ITXF2Q$K;T|6xS;g@@dXZfx9&t#kVS#0{)PQS_2;H(
z!#qt_znluLxgz@Zu)4D2hN->)%eVU8_9ZzpKE%<;1?447?v20}m+%dLoMk6mU2H;G
zs3v#vFk*D+X9%fE)BVDKfBB<5I)k26XkQkH@#+c7tKuj^6pJYXxj+%Cf6TaK9M1)7
z;wzO8h2DKfZ!PDlM-=G{h3|Qlg7LuxCCr#=nVOf$C`07x%lmB}BfihO9R}}5b*(?;
z$Yc^W2bJX%RFI=qFH@q9X5`A;Y12P(14u~c!v9wN(6Ks<lsyzPpl!^Tw75S=6~BDp
z+uKoA4}R?0W8j^@OMWq7;FT=_=nhNsZQu**%4RpzHNl_))C$0yg3IFHL7*u9;&~Vi
zRaS`F9M}p+wcPMGsLQ;b%)<e`mEeC#M!XDbMHNpAuWPPKYvb@2EpxbUAyQUhre?%H
zsu@ZXi5Wyqik+Xa&qbth)@lT8)!TFEjqQOt2C~+gX~6Z)dMXfZt3-OnN{8eFfDo!i
ze8^T#Xtohx1l>sMW5;XywC0UUOunn#$OC%AzuY{}4JW}9f98D21;QIPs*>Y5{U1D)
zwhFIKKF*M;@R}-auCNF~ZB1J%5AnUQZD*^^)!I@UD;+sxC-F%(vyo=gwBqg=1Gb;#
z%oBT&O5JAVmu$FxM^+PGh-9cMk$Cnx8{oyn`ZIiG*Y3zkr}@@V`HTO;&|@fmg<WQA
z(6Bki=U5&}Z%q=fd>21!tXuc6tox4D+2!e|d#?=GZQoy1eHd7i7MY___qG}2K1H)g
zhWl&>wnU>wi3W`tZmpv0+8QeN8}CQ(^EBQk9v<G-$vh*Ppc~!j&|Hy{XxB`L=J37x
zxx&YS@x$1C*IG&9wX_Z5)_-0pSELLH_tyr&=Q#03UcnGrMcRkX-yz)!IqEm&aj2G(
zt%}{Sg*+pal|tqgQl2l;ynB{FIASjKcx=Ick2Sqd75(1F>-GCCrR`@}@RM9E_!A7v
zCm3qh?aA9O$vh3CBSCBq88yid%S7Ap-VF;vvlr^0@r~xU%Asa?>Y7or6a!1Y%(XsC
zhxdsM%@xV^74x=JAvbSau)QddUvQbVZ{2m@$>*i3a>hp@cX8veV*Yst5lj2siQ(zo
zScjyc3mvVbN%Jqnv$s!e{lc<~q{>G=xfw2(WYMVmWEc8Sm2M{gwoBgWvUo0K*Yfw)
ze;*k)8DFE>Wx1ukvh}gj)t`(hN{k~Z7}fxoSvNU?|23<zH!C~dWlAl3*BNKA3q8}E
z<$tu7``~ABKH#w;n01hOo=W1L)nY@K6WOE}_(-9HSptMURwcMp0mYk5KjjZz&xP&&
zOL>ZbYy*+}izN>rl93R;6}}b^^Fse1mpwfzT$}oh>L+Fv8VVL5#rZtP7OMCJGH0yh
z7BX#SG@0doz2$tYSXvv~2}!HT8?6ml+~Y)P_8hzsuz4kshQZu}Nf~kQns&=jQu)Yi
zn2*G%$yrqC)$8>l+CrpDLJb#_Z19mzyl@StF%H$glg8aBC^3B9e%PZx_iqOyH@OjC
zDi$%S=NnXYZfDLQIvirC!*->&KR~zjb(V-+J$x3{%H7^?fot5o!mrTCe}JyV{d6dt
zrGGN-=lh};@*7MDmIP8ZeEZ)xKyw1doTH0`^>v*<`g$WM@7MOI4F{+WMFYb;C5x{H
z7ppC>a0TzWpzjk-Wt;HTqsli3@?MU4zI+YBFE=do-#A`L<!i+7ZxXG%oJwo>ZppiD
zT6?~6s(i%Pq+Y&h8{y?#{ekbc{>x4KOK+TS9(Q|3)@BG!3TxIBk2l|*S#TWCd|ocb
zCFO97I79MsRj@YW-A!!L{SYi}$AlXBJF`yexT<!!QO=~<%zKRsO7t?kB7FqZqx>KJ
zbjuwpmyEvk)o<NP_tE@xEBU2gH=iU=B4yZM9BXBMte$Tt&UK%^|HfrX<-)Io;QQ8}
zxr13+Wu_zD?zcVM_RAM}^ZYoos~r~;0e<V%&rd$VB9x6@D}s;Oju^xjQKYgQulf;2
zP$MneL)7XAkN>)2#_gQk7e32;w$^E%J)-(BO58T)Kj%!pEGfCK`2JJitDcn@5qIqH
z360t@f!F#JBDcEHHt}WmuliPx>#b7LZo!Y*k`$8nG+!5N{FVf2S|i6#`&W1dNc{7F
z_<(k=*#)1BWvGGT4e?Y3p?aaWNDJ}$ZWXiTRgopNtdlUZ;E<#{1Cuy(=Jb_;;*EO#
z!K6!Pd^fWMdQ{~5=fQ23&lEf#ujsYD<LW5d^HOD#5cYY7e4@TqJDA9~Z}9a$%gfKZ
z3IHQ%i@hqV%Z;&Z<E&3y>I<TM<!#nqxK-r0h{wdgy8h~)?C;qK`L1eBL!Ty#mqRQy
z_kw@hhS4R3>H1IEFo=e$=HXCOIR;ed+H@_d_IVadvrW=hX}IkYE=jiVu1|3O>bIJ{
zhe<<<&GM`7*UtQ1XzcC0Jz(>0lSg0b@;Eg&03IxH&Vb%O!KWzj@5)iQ<<oE9Zj`6>
zBFm3X8eh9)DRyB3JXq$|ojP$g^z{orb@$5{L#b~ATX%{~5Q*Ka43p^_uMfW!RK1m4
zgIuf`YL77rI{j+*!<^*Lkh-TXTqD=6?p$)|y&__964*$T^!&||BU-&Q(A{*t)wAu^
zqjdLy_w7CA&DBAlb*?L=eckuE9ktc`#$X&J(KG3;bhh+UGuOe-Z22Tq&GUehOHsW)
zb&_=J|FU2^88EhxOEqB^8!Fx}_P**FH4a;e8<>s#^&_%HIqU+j@n+}uUjwQmZz4p8
zwm>Eai~SAxui8dbtlmP)@0M<)DP8+GTt7vXbpqY{_(|n_!<{ynf~ZWPtE<u<cPDIO
zekU9lucfsAYw|P}c$jw0Px95&hoIRlk<)9tc_;N>$)CD$@lS&|!T%Hk#nA(<>UuTg
zmMRTIo;&Bu809u{KDsvk?R9g5{(G-VofikmPaC}k4A!2hrfH^szvE}T@p|I#0K@yz
zr_#*y0I+S;@vi+>LgGgbN8yAmC(d>w6e6o`Vpu%&#KeQ7DfQmII7^kP6VPMHnD_r5
zP51uK<RAYJ{MyDg44dPeH^(_P=R*#2K2}HwF~=MWNhld(<~)ZSa%herX^sii978H}
zLh9|5q?1EQk$rtWpWF8zxPH2B*X{XwUXR!P(YE}yCMv5$s-y7nue;+u0Zd)*gC}nv
zd-Nw4ob&<#Jjt|1g`<rU*A#{uZz_w&a?db>EH0k6yV!TcLRD1rw9*ms144ri&)6Uv
zi$e<@yz9owMa4Y3qbl>)UML&WAZ|Z?)!4nC`Z^zgWIyis!aI@`9jUUZ3M^w&nYjj;
zL=zVoEMlk)F6X|H_HCn;yPu_qr8>T}P<_RA@c_s3Civ^{qJJy8wFi8U>*@0HTJEN?
z^mflw?;!r-)D-9YQ?Pf)CL*?5AVpG#vDYhuZf}4))d=?l%jS-%jt%@;Ac!!mW!FGr
zRd=7y=d4dUJPNq@etGiOS~lB?J=;JETb5eauKn-EZ|!PM>lb+U790hhfe}a$zw{E4
z)MW7dN3UKD&pQ3iBd!(7olV1KuAT3PC+iUrQNkhl|Ey4G&5*rVCDf_3jue#0$mh+3
z4WWw-!i6Z&+c;=h)CR_1v=$}yC!M<^U#xFh>@iAw$VvQ3zWCE=@fRqGmrfFI^CjM)
zrjA6;ic`nyFo>@t#0HD^_839%nKX|mh_9Q-C647ohIswml7d8I-a9c?F-{hK;uBvC
zs3flIrXOiTVg~jN&2%)CV~65fIkD_^0OCWM%3i<gW)>}L?~J{xgxp@T<{MPi8JSR$
zmTD$RJFkln?KoSObdNeho-Y$sWO$WU&c?7Qs7vD@zBpDj&TZy)GcobNm#>om43LjC
z583tmqFM<&m;r%BveJA*y@RjiGKTx_4=I}^6=_r1Wq>>Lg!Lew%<PQR0-suC`)#3W
z4K34i2L4j583sM<YLC8n9GV7t*>T2&NPPHgy6am$mV(qW=V~SV7b_cxm)2nUYAEv`
zyPBDP;Ojces^!!o13P|chagmuTJV9dSU{dp!m>h&bdgH3&|fAe5{vFm7M-!jcGFSW
z$zny-d_iqV?JuNS$7NmW!p6YLL^FAnW!{7V(QaR~jW058P=S=<{8#!&{s-V#MKHiu
zDh==~DPA8qelJ`5-k@B?>01V;Z&R>R2g&fFfB>zbokkh$-yn(9uya&@bfltw@sJ%r
zK)ae_uMf!c*NE?$qKmQGY8eQdC)!0IDa&9!6$LE4TA?IRrIjv1H#cyo{pe+`>0Yal
z7-q_{z=B7p*;o-T89hp^p0pp~#*iHtu(158uypBm_o$RzixCcFSXF4yNh&$ON_n$D
z!22Q8unZ8u7Ra}3ey}R&QGFduYT=W%wHy>_G?lI}cgY3`tNoDTiOA&~mMT>=J@hp_
zs5Wg}F~y%U3-uM>h6!k_+THjh)!pe~Qy1=NVbz!{>bUG$rIkGhF}UW!__~O1#Gd5w
zl~!8OIBCf(S+6k)Lh0o=eRT<umUEsDI|(LAOabv=S;_D<aV>vIXMO>3GTD2@{So~{
zLr8AGXQ|9Zu89D#LAu7Fs>br7HV?<i)zp)A+StKG32}2B_fDTk^UGS0`>g>|rMFMV
zf0iIzc1Cw~0fZahv6AgpvaN*%vk=60g)p0e;aPJv8Fg7OUGRCW=`IF~V=?sQm!u-c
zDUQ;-qImAXB`LP=t`J-IuhZ_$GG`A5%pcgwdiZ8oq<FJB@hhLC;xvKiCC^!kC)ZcC
z%w*a&_Q(z8*CKOM?9Z)|#IBQVZdl~-Tso&RV0K879{c48rkjcky%Q=bb^fWn$;k9G
z)f8RQcD0E<9Pn*|`0biX3W9@Jra^*!NUaseieD4X>5hm?rVyr(S9&<lCI54G&a@DD
zRkGn$0aC_%8p964j%I-#_2;fY1%`)?f5F&UC)=|??xzu9hgk8^>WlluV&M&$DxlE6
z0RrDOG+K`wO6d##d@ooIUXbhd0c%@IHj&;mSdM%QJNIR2##d^FRn5}}85ynCs3ROH
z)pi?l(_oCYV2$Qsva{=D-eWa*XkZ1pp#)ct#&sEJC`jp~OHa05=C461nd5SYJir8=
zb&$usSSJW3!y9&4S9lx%_?R*$<yM|g-3|&^yS|N`{6OX&hMeyTFg~c}-VnT~zAQYS
zdf|yJCw$8_=2iIz(@2?GUdLsT&8Tbts;^aA$j)3z%-!UA4!S-$8ZDEdT_hmW^!D}`
z9VM!S^1CCkU1;D95{9?i?G8llH50Z$LSOxm6}Xw*Y9WBhS%H(9OgClm$s98Ai@v;U
zW9a@jnfO>Khepopa#BI}4W_C!iU)Y=h?LNEio;%N94k0239f%g=N(+q&0df9{B+s4
zG}U@GIeFvf7}f$zl8i1gaFHjrC4=P<UGj?9wSfY*&joygG_BH-?P6)tE4ejIqGnU>
z&vl8Pxat-e?n4_ZEga7_E}N<i2q;>iGon8#MBsI?@=eIMdRd7ZWL=2FAtq+T?1V#%
z1anVqd(oIlmb|%iY=P<epI;d+h1zmV#wuAnflmx?TDU+exn3*2>!k6DD6-C`7o-6=
z=xaNl#TG9~dXvT07YPwvH?Qdd?!HoHW#zb^QdaQ=iOn`hQ_K=QS;n8s0mUbd<!yiS
z%#a-^YPZ(|@NNPV{VCi?)5@%g8{4*oIu`xbEBeyZpGs9QVgo4YOR0GF;O5dLG0082
zTQr(WwEA_F2>;FM7h9rYqBSxeH3~Otl;>-XiPma*)au@>Jw9Kn%L(fOcqq+cS@g=8
zMKcpoi66_zI*^zZ=*cYb(%D~p6I1^#64jD?k_RH;x^(@_eD%;GTEI-CLP=OnTIz$a
z$d4)MTx_A+8a=tU23S&0_>4}S6d0}MUj%^lMauSoA6cC*7mMu1AljQ{ch6VX_trdG
zk*e`c%<NrHxXq0a6a{^Sk9Q?V-n@%#hVxX509c@9;6#qYoA!%R?N<c0PIAWar!Z<!
zk)|S)YGJ?XAP9z^h(%^DPW7-rqM>j=<7$U+wXmUB=MU+2g}!#)`XhZ=a3K#FYFfPS
zQA6JlJ*aLxH+80)n0RPPPIhV*A26%>)b!Yl>+d~jXc`>Y5?-r4DwTh5cU;7Ujj+Aa
zlc*Dm37Wu!9c`Dt2JcrdXNtC}w7%I8xh^RBLz<^}Nfb_%*acR%r4=H&(J8(X2JZIE
z`jXk>fFukMjd^@~{PCwg@r}Ogd=MT#`v8E9WDfB$kJnr{e{<C!&Yj(0_jfA<Z^(p*
ztz-6H)d*SziZs+(MAsS>6iMD3Jf?BV-f;m5CXVng2U}mmhFaPefaIV9M*TdJRL;Ti
zrU#jrmfQixk7dFU|0%k*+;EAZHb~?THbu{Z^j7ITeP)5P$y|m(UpFqC(U-wWR!BIs
zJiW^{sR({*Bo8!NxbG|>AsEEGMb!0*D$JMeOIM!-`&zDnKak!v)&as+a-z)@2vs)W
z=MX;!!(Q7z$LOnbl9tn5Y<5-DDaFCIaA7mZq6QHpcir>(lCCZDXR|gBzmm-Oz%jJX
zSCeJaDI;lKl~lg$r)7LAYN7)8r{!;^@4beQY%&a<J@|~TG3Cr%NjjcbAuE2ri<=vs
zA<nt+$tvpensCHhzlV!w@SA{~gE+8U`b^2|T^jGPhJV2j=KPj9cC^pWa`_`wV(fDo
zBcr0#87H;Q>e?^9#!6^`vt5vIeJHcOh_Arf$-lxg>(v5&e_zX849otnQWgt*2vYR(
zxGrP=y0WT;4w|O3>Oi2EOqU+)6AoXbVHL8-0G;M57<=-h0}cQ*HE^eGC6<tYklgx!
zOYw0a1|(4XZtbGAwW_R?m*m>Ro+|+HreliWuGg}*;)PpCJLMe{=8#zxBPV&fd>t!(
zQeV8i-yjm?&gUoL=<RoS{Np#yuSo-~J@pEGl7<z>0R9xoF$^nLve01Z=|Y^>6G)#E
z_$GNvWX;&USVyCi+09rJT_ptnt`2yzB9#q&1kmvUNsj;@*#qCrf7_e<DO|%tXmQkc
zZI28=&$~j&C?4@@esK_LjHHJ(=l+U8v~K?3yhs<6{)JMOiLTa|$2`)N`t8=tr{&*x
z>A&Be6Cy=RWbm6GN&oHH+G#r0h|lcomHX7W4*XAPK+XF<ALTIsfc?Y94h2AfiX<Qb
z+y@gN0GtIt;Nmt6`T#j(0stZz)kEn>8M_Lbwi<J_T=BCD!TH>E=7JfFra~*bA?2v`
z;3XTz7}mFvv&JQ)tx(lEz<pz3yyNzZTLdzvgk5LjbWJ+r?CDHZ(u^bI9)etQ3^?v@
znJF#@r&B9aDmyO-HfDr$o_~yFH~M)|s=Q4g<Re)(D!(h1wf)che)9xDr+e_@v*SFx
z*7&yPA79HO8N`QwIK>PFxZgFVyq*8Me}ljE(+j$JmgI?Et?4s|hxNM(n?CBvZZ-du
zanFt|q=|Bf`or(fhQ4lg16dXs<a|zPJM1b)fBn7T4~f!utGt(MsrT9WzrJo;dd%XT
zJG?AJVR)AY<IQ%x73@>b{_o9|r?+_jbMf{ap!^&B&j!;p_m(*g)s5h|QZC?Qu}qas
z5cKEs8d{ahP#B%u;WhF+7<M%d9kzaIyyYM}u1*R@jmmFz26_Pvw3oJ5W3*lts|wzj
zes0XtT7jCXK0*_+H96UA3=@{%m8PMF<Q0R9)1Oug9jz4WiyEIn02J3beWX69lb=H9
zs?#|c>;^{WnON_xy)cCQEAYUWpnku|{4uco;<yS&;XH=BD}P=?P`^-A+fRS>lL-k*
znm3s$T6q!AeYVg;^R#Q|=las1`IkvsHb;NGsyJU+pLtkXXO)?d_^a%;W&g@Np_Gk9
zgxvwe!CbN+H25hd&alHl!g;;sgsOaqnZ1M?COTVZBnIc0isgJ|<DDw73RjyDc*&)b
zFCYt7drS1sR(O51k@SS1z+9@-ez1LdK+C&1<pyL-MEAQ`Wu$x?o0*05!^j;6HFm7C
zy~YSbQ`o*|^>v+T{AwWGg1SgOd7js@A}={z1)`wMstcJC{;~)!Xu#cW*`9DzOQ4FM
zA&!g5cHH=ai0ipt{IP5lF?<r}3^)pXu<$}yo!{`76E%nKM<3$Dsdhx%)-aZKF`Uz-
z%EX7WE=~7klqOB!S@PRrLUe2Cm{GiGfk%?o{)#Q&xwn!h2)ZV*OISHz?bvHRR#k9B
z72H(qvCR3p@}l%e`Cm8rc0$(Qm}IdU7n;u>^Q>0n-8aNjdb--*b*niAWbQkyK~H7y
zQ6M+zk1Sb6kuC^Q^1jDWbP{Nr{T}kdPnhfvY%RL4nrO9a&Kke{`7lrG#UX!<(BQfp
z!gOl=Os@Llx{f?u$Xv}^gFzx6I&5w2b+ydTgG+f<A71h?)%C7lcw&-$p7mn)eUizP
z{u57%HbIN#oBad*5Dfz<@TCWOnXCVCx0VvEF*)bB%5^xFt}W|4Kz5f2K*o=z^;-4v
z-P}yYsn|ROGeqxl)Cq&zz{15tImZ}CiowuK+04%lItmK_aoql_)N0Z5!yrA9BgLc@
zmiKB^1{LFJ?d`B!e*C?R_KbT5!Fx+V)ygIuL?e5D@a;;D1VxOLrFyS}Mt}u`!Mfu!
zqgFge(zV<y>h`h;6AeU<p=2w23JD9ld0{c5C*y9yJ+G6wzo6?fpEGhS;Q2QlEZ7PP
zUWtE_Ovx~+-z=mf>Kp1XeEQ;M{7cBOQE;RYM$+6!HXa-7{;_$1op_}!Zt4Jx>~9{%
zA`(8I#UG*&cRB;pK<h`*4gu^+SD@sBs0ou<U-M+NjMO3*NnyUAW4x1HIH4@v!<%|S
zSLGtAlTfAAq)!VA(gZ#-osz($3^?a1npJ8o29;(B_d3WTD(Pu>J9#60fw}}1gCeA0
z){)5kjD?>GHYdoplY=KiY9<@4bpJ|L2XY93W@S(WQNX$`NcaIC+}5Z=GwG)T#%T2f
zkcuY3waIW##}glaYGvR4<4=aP<(VKnEDbS(Ct~+A1zM?GDM;?@GqSz|6+^d^9nBJs
z?yYIfY~}d^t$g;stWU$XT^{{gxdh25BTOyj1t4Yh)9+9P9znQMrlhs`?ot(<{T<U6
zw5z$a$JQ_(k@|JeGVv2Fe!}(w|0PbGZbA@Hey?v{3K$dEhm#%|uJj4a@s+S8pWNKV
zB7jJcwHus?&uTJ!!!3*6Z?rp6uZy%`b+S|9nbWfH8U%}-AoBfXpsCKQ;-ujKOd>O1
z=g>FP?<nAu(q?{v)%Gs==WZo1>}xtks=Wav2y?C4=na;0JY4OP&L4Yf&g<;WG+reO
zYQrVxQ=CTUe?Qv0Yf~m9-7&d3#7Qa52^|%w28y!kEiftXJw!;C*+^F4YI7>Z#sLU6
z)mEP7=l|C>BYng+oGANz6J8+Qrdl8f8Gz(6$1-0vPGF*&Q<o1=&$#Z5@^qhjCUml5
zS@7a#DIu*fREZu<rw*4dZc7Q>ET#zL)ZP>lu?W?grpd4HPH>B;SZFPcA0+&FN;I}X
z&CmuKf|t&N=q^Ar<9HnW3QMJ`0FvvcPIKwjKwMw_=&<87e{5Z@>oKN5-A5g1zsjCI
zB?_0=ZZ|bp|0n{+nv3rY)B}@Oq+SJ&J($I-j!5X`vb{=4tJ<%%woaJ2LHT5SJql^U
zl4<wA9CheQv&XFZUl|X7%BJ6*mWaQHeK>X50>_D(n}R&`J=xu^eKX5@Dj9Cc9QuA}
zx*qUh$1dUTci#Io&_MCQ)2_&B6XZa7!{kxkcn=?zy{22y9K;1IHl0cXQFMj}FML_g
zzIc!i)syuTZ>p{odR544EpCQys!n&UTeLndeFsrUikt@{IbTl>;XydB8hY|bKWbqS
z{+Q<eS15qYkkPJU!H1(y^Se=7YcxF^mrWwaa*R-ZNL__g895E@bji9k7W2W>Wi{IW
z=BfcPZCWnHjC++g_ViBs?UTO*{_098^4Vx<2#_@N^ni6Z;mq@;mb<cVl@^YABkMLX
zOX7JFi((NWFVG}qf$GwhbKc(DTgz~XQ^(%Yud4m5;`#fpHY@^X9hIj*<JP|;6p>+l
zHKmfbajHXg1i@U)bBhzdtlGytx3;yc&J4D+Q2z;kqD}p|5o#Q?m46#9{j-24`}Nr$
zmYJ?2EN`zPhYay;D(lCclLyP`-_g$>Ji%}7mbk!(;=J!TMMv#vqJFj*=h=CaZeN(|
zMMq&4lbr>$(s&b&R-L_@>Fnij$q1M4U5_)K=*6~8mEIYZnxzeO9ysml;K={N`2129
zdH1KZ&1*&9B7t(6XrM(9ix3zO@ro@>+W({?Wpy6r#GYI%x^OgBp<=~X#Sa}3Xh_UU
zP)Y&W?c@{tmu-^Z{4+rvqGz;`<z(FG6|x>x!#5IMIR#JN49b*8MgggwZU0NrImWVY
zvBwdwaxWcct2XSJf`-yO#H*ok02Ji}i($x^C8v3e@dXfJG0_saiyTllsD&wX;0Z2J
zKp>JP$)fQDmXc%R(&K^!9LdS?aN!81YZi#pM4fY%sLP7v@t#f3?4f46qwca^Q$0b@
z0h;ta6K%ZY^O4Bu%$`v(n~^<h@!?~J8R|%+<N7tiUrOiF#AUY3X6mD1$)xaBy{u06
ztnRq1p3<z|o~-`atVerUOmz03UiPqi_Gn!8SZVe|Pxj<&cF8g{2ANpB<gUD)ecV*J
z(+}wwjGWz5e6yF6c?147lKTxlSL6!!C4L|W!wvNCG|<_(K*FW?+>f(}5hN!Ob9%7H
z$9&1@;0*GhJ`b{#=K;=zmN~I}4I%lw$Li1Z`W}x&g+oz1c5o$deAcVDe53sQYG-7N
zbdb<zcbI+wy%RS;lETed-5?^!k?a9Pjvc0G03*UPKfZv-*~^NIW^JAXVKn>DG!{-^
ze<TkO$%CpF8QT`vg_!N4ctt)Vhl-R%^#$-Tynaq>??^J}m7HF5fsnqydw9M8s`&JS
zqM!_oGbu$p`PV`8RBI=PL(J)Y-BWAZT(gnf1CbiX&|I;OY#Btv0v?e8w;-IA_o^=T
zUMsW}5jcA!qt6veUPk8FmTJWp7nf;pWWb|<Jc$q_jlc^+^1OBzz!&jK=yN7u;Z@Rz
zvde~#iDDD{T)}e4%_+Bnk2j?B^?K$6$476Nw&nPIE`0?r;N`0*iLWS25xu)*l;c<y
zxrlf}lequ$dgQct)B~jRrs+=P^^`dKdsCb~CAk?aE!;;8vLmCY@NB8Z>Ei5Pr7GG*
zV<NZY1L8+6pJG$LdY&JcCzku8!d>;Rk4_0)?qZK?;|T_od^dS8e(aW;nj6(Z9t?37
zQ*1V_e59;A?{#^lehyvwmZYcwKx7Xkz$l9xbHiScE%qvaYlwN~kidJ<y|5`C@dl~-
zVN(vZ!h6?|c84x{6#!zkcuSTfa+XR>LrQ5)RbL;tXW7cX{ax*NQ^PmIZ?-P4Dw>^E
z!doVk&nV%YAzlFyITE&D68i82EQj-^<}?9`69V!(at0ME`t)!9{#ag}U+#4Cc8M9y
z0x<qVOtYOAl!EfcC<z31a8@$lAycJv7F{%sSag{#T6;7O4W_@*;q6YYv&^XaUglHT
ztZCJByGBV)oCBDr>!lS`KPAbei3%Lf@d=$(XOZB3WqPbgIJYR!Du-<9<QAAHFL+RW
z`h11BU21JY%PBArI%UkENAvJwzn+?+k!hT(s2NTdog$X%uJB#}>Oc(VGNx!RQ>-uq
z`Nj6y2~N?QnJr&MrMi&_JU?(XlE*JS`SBDdaZ%BWbm|W+{$H6eq^w+{owo~F6I;L=
z7AgqZ<npCMyBr1ANl*yrHlSY-=W)A!zS&|r=i7YS6DO)LUm@6(+qG2UKQi|wU33NM
zesSE4O)*t5%eWaE4+d$ovrKvO3}~m6%D%+6R!uaq|EaS0+-4yr3Q92CAqhgFG;bFQ
zk1{f>owz`RMsHi>1)4~iAn=Y3<*hMn7X;qo;jWx5+*|G<8%+U<EuLFNmhZZ6ZLz15
zIC3{(lh()xfTL^^bvaHfEgtDbg2ipJo4&K?r9m$^vfKYf8h`1|e%GT=XZU)pr{MSl
zpYHUcs}D;1+$UZ(l)ZaURc;o&3G>~1Q0Lj(aJ9Fwytlcpx8+@L>wYgotgroeU#DlE
z1*-YhDk|ZDAV@^&qY}!3&K^nNFZk1h0>NlUbZ;d4I2R18sKq@Ef5Paq>g^Cq?w@$t
zpG(v4-p}bY<9frwaA$A{5DB>y$1bZa?6k)1?D)1Prfs}SXf8#OT-##7WXBvD{0s^q
z9NO(?i`)dHUwBrFB|rYF9Q=Mi=Sw{C(<c$iFW$1L4(nta@N~!2K7ZC1$uEDAZ2rh)
zRHKjs>K<J*m54q>a`pQTJPfPzPvHSK4T`A`9y$&-`!;b*X5ZRo&n!86c1h$2A+I8K
zTTh>g7A-c3>i)6xh{u<6Wm6hJ%78(>A_f)wSbthAv{#$vXftx_NH2|~4`dFX$(D&E
zjl8-%^k&S*qEHk>WMBEhAB7JT%<eM>xxGG)6zS(zUT}(WK<)qZ<j#M>i-LEwv0Ktb
zU)dv#S$C=e`=0QdjvW%msM({>){l4B)53p`8b(?CiS&BJp+rF<-qN`r5-!Lux#y5n
zho-pNFdPWq{B%dIxj`PTfC|6x>id)VzwEnvRSH0i>fY?c!*|sTJEmB26#wbAVHMQ3
zC|<g>rMd@u7NPb79nrH0=beFfG1S^<aIhlBI|r^d<nuNLoUNKY7mxT5i73)WM$&j~
zUlLi!+M?`iH}L;);B}vFk00M+7F(40YdSo~B0Qqxd}NT}llBNxHs_;~0#WCT&eE%s
zw>1K%FNGJ`aav@~m7*i+)<3skAEG>&a<tR^Vh6}Gi-@63^Ca^t#{zUfi<5S&9kHhv
z8ldn}2OTm8l61Zwq@s#EcJ9T~b;V~SnM9&3izay3!f(>g`#HEmy^Z%PgOh=@21SZg
zfkXCBBL)_UA2uh9UK8P3@`tNAW`=EF@0431EIh>v9#59fjolEr^Clwasf!9KcjUF4
z8}g9~>i&T++bmBvfpdV#eJzz^2!q(6@jk=Q8W^+Q5s15goR3^_J!gb|nQ)BlD<}uh
zv(4KF0F+o=)2jke2PBbi+A-5Sl}=ET9iGiGgZLP^Q@_mh$=p6>Y%y<mOzP@{PZWLD
z?<BZ9JcQ4rHWd>x7G7^mi>fXpenkcr9DhMbeQJct4L{c8%k}mIa)w31-3UQi{JiFM
z-|e~#lKGR@b7KzL1dT!QY&LQv<c~)Vj8~}?pD&qA-Q|sQWIHjy<3-Fbl6V7Jblus+
zZ}aos3xC|_g=01ibMw3nH=3-LUJ^3Ui8(PT#PgW9?WUd?cg5$oLOiobNnnlb#bYEa
zz#a)%MFfUO{h8vC!y-=?^8OzK&iV85SMJ<UAw({~VfRKW7Xyz3O<fTO3h-iI1c4hX
zyu^CRWd%*2VPxNmD+J{HV`>V0V!=jfOyt`~rO76*wvNa9bti7l@NT(rcD24YLJ==i
zbqtst0p721V!9F!h0eoHagu@xc}3r?jE?CwyW9dX3$0jNubkfJ*EtFv3kt!0<cLQ)
z7ZH>v9P0xd1&e#H-#d65S($@Y6G}ce9DB2S$N?EQu@v?1@tu>X(#<91{0*7h_s!lh
z`2?OPGTdXul6i^9@p@tEX1*I!XP>~cgy&fze*J)4PdS-gBd)fxUNaxbjiAg&SJVY-
zimiDKtQlUwRM(zOfr;C&MdQT~K>_CqR>u+tl0z4A#0N1(YkcBs26ytmN`8VSLlw<<
zUb8*CcoH@Dt;JmfK7T$Qvi1Hc@&jlJ`t?4CvF9b~hp$lmitT^AKaGTTA8zz7LCexy
ztJ)h__!{g-M7KFKvyJy7(WC6fi8guUmv?2S#VgoYhF?HeH@I83ZmaCrAeJ75Pa;vl
ze;6>!YdhkmI~G5ne;hN|r<cKh*a3m-7fwv}MPktkTQc#j6xS;!p78;j%puw(y-zA$
z5?p66>}Yt%YKbWZCjN8N++>GW@xB+I#8E>^r^LhQZ<1x-PL|zM`SHT&#&r`EK{rP4
zlTC8o`%zEC$|8r);uM7@dih3OyD#@B=pv$;y9vabj*rQeh3gISkbsD|NW`<yU(bTO
zLGOnm-$-(bI3pC17l;WUl1#wQr`(!`+{K79`TU>tkafCY0z54P$BHjY{QAe0e_nZM
z=!IC9@d1Cn-SaxT^XCo{PV9v6U4vkMI`O)IS<?vQ_|+K`WG&I~H$K$x!e2cV&422=
zqw{$eIK=hXfN&<7namxrIpKj{J&ff3`&I}TkS7)SfDqAK0UQ76lK}u3wKr8g0PtWv
zvTahAEi?F)?X<?6WJYNyu~>_yHff7YRg+Au&(3S6Wrsplsh^|P9P-srzB_NXB@_X@
zk}j`ZJkzjThkIW3?aZs5q!ag@=F84}acw>K@H)Gg>sR;oz-LvK<*wg6x`VQgf}?aB
z&(^5_?B+NYvnmZegPPm;gXFz5VqYyvDBoXq?TZmCNi=+;wlESQs2kgq#v^GO*-Cw=
za^?I@%jC~hR+S#VLf_my_n0E#x%)P&gB9_gReAgNTt!bJ3o7Zg7r8tVWvx@S5WD^$
zq)a(o^4#B;jn{Xtbj6)J?wK3faS<lveGs?(vBO#CmiNDe-EZ$7r%U-9Ui<s&+ka1P
z`LM1Z{`<#*;Rzs^EQ0{ywZNOQ3kNVvVN$7hGY%MEj-jroX@D8G?kdB)&AV+)6lE?x
zo&RPdIAb_$9j9EJG{1$n5;?!XC@b6jqfq=tqbTH-<wQ;3t+-&>b{iS4pB5r=B~H%e
zz`<5smlR}Oj?V@YCCjHak@E4@m0UJW2ld~O#Zra$v+ATocu25Dd+<1{O8rw^$Mau2
z>Tuz=d>o6n2)GFxVC|=#N;Rh}$+OUgM^QPXSFXN%rSP}9PG|f2)8tB^e|oSBu_KaN
z)0a88cFV6IL{U;mxfgsh$%Aj(`Rw_6!ES0ZGe}Y2dw=Ve)fil6R#|?2ttqJ`f0SMe
z#+aeW^Xl@Yk>I^{*RXpdyDfb&2u#s?*QdxQ*AC|tfWWl^X*Y4XrpDRG%+O&>1hbJ^
z46IJ-_$2<8$c7URwiIrby07evHzS-Ia6sli>r><y4!U?w5eG&}8#mJ?abxde&q~<P
z+<8fj@7u5F=5<pwR9|i-X}54B7rhvmS8T2TvO~r{#69}ebN<$+)ZvDc_~k#HijXGm
zDZi*uJ<??WzH;WOVtX2Ez9wnZAWY=JpY+NX3jwNLI)Qe&BtMUWvLJ(P4h%Z;75$U<
z-A@h2N3R{|_w~Km`+12`?>Q4CA>AE!S)ANb8oSmje15?cm_Z8{j}xKym)+UaWs&A=
zC>4@dmdI;wG{oliveV%r<(s?M`G=Rm8MNBw6B@lYTfNJhH*TFl%#TX>8$?G*kgcLZ
zs)GAtjN(83fdD++!Xm%AOh)8>-?~<VAlyv4Ue<EsT6pVN1iAmS|BY*QKE{c^KG`ci
zAb3XOatvl06BGA;ln5Ff{Qh+7P2E0>2z*Kv2MJA)H2*#a3HA`6I#bEKsYEt8JyTBC
zsTAR1;t^eD$|G;X;*ME&xkgy-VckuO<v5sttD0-o$KVs4rz{LdZ}48Ek85X!q-rw;
zWL^`kOed#rc~}WPWbDyY%@H+Rg-<dU*gtw#`sY~QbP^Q18${&rtNu{&vYg>Ho$BRM
z^CgpzcP-l-8BKU?EFWdAXtN}#m-*zpi+MY{6ZBlk*{7@UbwPt}%e;#m{@bfWen&zo
zBC**c3{wDKShCetx`wpvFC1B_V5B7nR0{64<<$w8A_d<Kb7$cZU-G|%s}5MG&_)$5
z7|I9>*nU*HIz8dmJ&fw1yB{N>G5{^GP~W9-OmKb%crHpc#zC5I1>A_8V53@f%6NID
zOa}V3Uw+Ptd#%2T>5sd%L;>Q`O}asOt=hMxDf^a!`&zw#qg<t`?`@%eEdK>IQqf_g
ztmWuZUOW$6&d1Av<ML?{A%jbFHue=ea5I0Hh8nN=V7_U?D^cL!vs9hUXwNo)qqtlY
zc>`zC5Q9kVe=D`vdbk$CnaBU2CT1sf$mlRCrx*#gzJWo`;{IBvoP1tpXz8GpIPbV`
znksmLgM`-^6_s8em%89?aVGQ+GTP;%WI8}lXc=v3+*@e|O@(%OSGOQ}WPo1?f<`!>
zQtCe$Ni4$glvnLYKf^+~Q#r$0*7lV!n26fJ)tg2pn3s#3<l5S^US4+Q5g$<oN+WNw
z2GL)X$pqK9DlXu7e+aVTmnP5Z#2KKbn0JdkxUoiS?PT`4gS4wfnc(u5ZD0z@{5vG@
z5I<(Z*XHtOOa*w(uoX8p6Fd(zb6WJkqjK(`bfHXNsJ@s7gpu8RpeUr1OeU>{-bt;h
zi;W9(IjJV%sqU--+#%UZKXiKBRSNc{<JsTts=v8kAtTijcvkCM)_(vkycXmxV~Kn7
z0$BC+nrR%=KSXhZDur|il?__3m-C05+FGk;B=!DPt5Z9(y{;d%HX$f|UQWNHkYQAt
z=1ji=y#hgjqo_<>xl#FIjS~N_7qJl#{t`lglW~xcxq82Gg1GYILG)X!8_S$>H9S;g
zJWk{Is32wJdo2b!eUwv}nLJ}Ogb5&|o7R}+n-oP$m9QfvBmAFdw#0U|o{-j*GhF=@
zZyr2kz~(pCBx>K!c}M81<ryjmF!Z^G&QqOPeY%Fd`{NKQ-Np-8A6N@pZ50Gh)Ciw8
zFGw293tsAyJt=SIW}w^3SD&43^BXkz+R$IBQ1V73%U1@#*9n_NQ17aWlRTVdC4&CK
z1R#-c@eIUE<cH6iGA*aMexv5<FG#4YC%Yufrrd9=wi|S8KUI(*WBpEU(9nNcOttjw
z(c;d${~$^|6Z!lKgzw(Dve5Cc`^WC}ZfWIJe>1>i!2J1o7NXg;r&)Vvc8<l--CSeT
z)x`X`-rjcFc_hapX1_S*!2hIYxV$a<)jt^tyXSFZ>4s|MMJtb`t>eSpe6!qDz^#hu
z@sokZmu|jYSkrwH|NQc!OI5!YKEYn4h!fPRj75i0qqx}@H(Jl>hm%)VaCI~%@<YJA
zR%AdgwcoV%vNQt{Zx7o~0uShvl!9q3>USJ$2G*npW9$DAF3o<-y`@Bh5DTZws>pol
zVYk+bXz&sI_hMdsd8@I&$l<9^kM{nkfUR%RZDhQEaqTvbv}^^RJT|7?-6l}Eb?fn|
zk^|5(;F271)%DrjS{vHBrAyW`I90u;I@^x%UapUx=E^R}<*~`CN*73GtES{M`lxXJ
zeDXMV@n3a;^kSe_o!hgIs7r`1iXuROW2AkNss3H}+Jrxj3YK<(+1akA&Wu^JVho)G
zb@WsDPRt30x$u%y4{DS`cu7K2p$IP*t|uOIY`$pdut#z6dgVejG?c-yWA_-U#dDmA
z3f%((da1FERVJp#$<*|C{1NzMxExYmvzJ1rE0!R2${3VHoLUL)Mid7=Viq<O#T1dv
z4P<0oMHk5X-FdB7Urd78(5XrjWG&2K2!|#^uL@j8g*eE1@545$2XJh;euS1xC+I1(
zaPk-vSSOpqDNzs7Su+9~890T%oMC`T8BQ>~5zJ~HhrKEs)T`iDo`skNn|okN2JIi#
zyJuTAwk5+eheeNQzTv1vs4~Fy&B^RTyl(cN^q#^Yn@+(3+w?@jEyS>4W@&n&O+~^@
z^%pCd0$u~fxEqoP5+>Q))@8)nIg>su@wU{2+z2VRDF$%VL_)s69m5hEv$A!G26gJ<
z*%4nC?*9QssaY1d_E^%RbuQ9XM=}=&><g&D#F0O47Sg{C@rU2loJ<eHL9}uG&KBjm
zvZI&kvT8YjBMY>g4to;HeOll#5={ElkrCfh4(JV*0g5L=IKG8sIvrRt<1J#eY`WlD
zWF{(xG5U7#UOhbBr!j?Ikm7`au{H*vWAhvbVHrVmN$9Jp^nkQPOcPnlww(snBc!S%
zlOJ*M=n&WpXIm;U;8s*y;qW*V3ke@fU26mjkEbg?9j|tv=`?1>Gbus1^k#T^iOj@p
zaT>m{GYVA_iGwr_+d)DgHgW8p>#4?L6AXc;ZL&|>wVrlZJneLO+7)0Aw}T+(IkYg4
z5(F<HGWE<H@<I61k>spnj+D!|`WQIl;F3`H*>t}}<JXOB;ZxN>9K{!(R%XE!U4c|Z
zLgUaSN0lfKf1;(S<bpalu{XsdoFkMl{00uK+u%<+T36d=B^S}A!)u!HC!P<B0*taG
z#{a>aX%z7^mfHYSmk8<f>v}!apU6mcj8y!R(b++tgmXMkL_c4yvwC+Rf(b9Jq-I`O
zudpaEePeSXiAq(*2_{88>mWUYw;lhX1@~lRYz{xqZMuCW(vG|i5uZzYK!oJ~g&hy(
ze%6=n6vZa~C*Prw{W$uDIhEa8gR1178o+>FbcA|EvJK-b|Cj5e9C4lfz=+<{yn}=E
zb9m}uizHC_B9|kR7)MnOHed9AoX%``&1Sa6R+_ucw)<2iiJq3LS6)7>dK*u@>Yn{U
zA4)9h%-MjK;IRKlY?A-(%J)tSzAw=sirL`V!#307dZ14d(xOZuijgXTXyM;}+|Qn-
zv&MTU*Lq<6v?BLXgr=#o4m>lK!R`!)URb28;RMNhR&IY(IrWdLysJHczf2;Ky`_aU
z|G~7noD)H*Zpp(*RKES4bmcuTdJBqg<g9kd*@}TH0^LfXPoyfT80}s<BQ1lP;TO+m
zzkbgvf8b$))FIR5L<H>mwo4N5+Ga$^f?oAMN++@^$p+%fL;*xm0~?5V{Mf50!%O+l
zYlg~lSuZ<=L^`9%ZV%FZkgYXOVFI-Ulc9y28G46~Z`{<OM|Yru*<BOc$O}tC03MaJ
zIMGZkN$Szo*@C$fPWXe+=Vwz!^j=TkC`moz%b}bRk!%EyQh;=Z%n)X2aTPsW&U2e`
zD`%>jHFA=2-i9ZON0-@NRGN0c^eL#g|NaY$wLMLaV|UmSoTQ#E9mjocPO-tjnh#(h
zn+@&iBb}%l=k|Gv?p8%_a-BvCmvGO8VN?3lhi2Zvj@~r$xEsx5NNK!s(qg}3Vu7QK
zL=rP?q!GgGwaq}Yb+u<W2A7o2QJEnb-{*PnL~u$zxZN5t?_mr5GDoH``F$RM(Y8a$
zxJn1F9BJlV(0lD><dHp0Zk~sI9z^Jlr6)!f6swDw3rg&T$O9Z+Uz(&98!d*Od4}n;
z9f_d-!+1^=#U1t4{e}4-L7hkn9rM;Yy1X&MnO>T12xntm?BGBtQ=&FgZ)vlYJ2p}O
zRc65}-mhx`pV`ZqBJ*7t?^MrufPiEBM~G*-{8LyrH=xneatYZKO}zh_2G)+?(6t?N
z4o#07gLT$Cy4>vbNSpeiEW2}#8@9u{HG<k6LG3*J5SE<fbO1}3vLQP{a9&S#x}?1}
zVLX%f51l=erl7~+lq5QoyvIQrudJrS)h;^`!fx01z6Q<`7qBpxB+(;-E18^XsyC2n
zbKizae)coxp<{pX6yo_N;!U#@CqGT}(UOq2VYc?Ntkr*?9GB&TM&vIq<BW5j-&j`a
zUREAmR(Z3my0)ygyL`->Tbo7>(xQI#TbhMKSjT%NUdCy{u;iZsS$bo9s<SC7Aw8dI
zD>iih<52(hNGjfj65GNV+cRxNqr^qlT*jyEFLbKHDf55R<1zRyj5ahs#c%d?VqChf
z-ifX;Vp3dZb7b+x-m2qny3_X+wF0twScZLVfm;-ZTvts-JvDJX!1DlhLy61L1*u3F
z`tdZ-N<PaSEo?eV9>enNzYHwHtR>-t0#1IE-cULhOvbyX64yNe2Ae-RRT%?upe<?#
zar4g!loUc#-{<%<h#i0i`&ssK21U;ia{TJ6E?R0cjjYv}$;QKT`H^i&&-tXWPl>r}
z3~EUt!`ocdWlNpyZR5?v#r#*xEv&MdqL2WX+|bZ9VqhnuDQOC<j4q)_^7zx&%huQP
zcs{2<v*I(;JrCP*rqk#o|JOKb(juyN`#i3JYQD!F-UDrUsa)}wtVBp9&O$?MWYZT@
ztZ<aM4z}L@Ji|uLEn7%KV`kxTuG*r-b2*QTfz)$!N(7GLv{zU8{qwEo3XDwl79BPZ
z%qLUDB6C}Tm0Ebx2adbfg_2!E?gh7c19kNqGB(umNW9+b#lmX@n9zWXKAhqU?}$TF
zMtPvoCzaZ3sXltoJi^2_YV7jCBn@}FI_A<ojZJ)j8N7Hl&X7yhopO33?R?w=<ym%O
zE{;q%QjEjN)R)D<ZmdqFkpOztj(_-**gIpn;S)g-Zz<m%e&<Z&0c?+e(J@#8jUtu^
z*9(S*+Q7;QFaoXj<rKJiGyNKgT{#$QtylUwHL!srjcx;Tk4yW;131DnnmIX>f}!7<
zg#N9lc%ds<FY^fIr%c;8Hg?iiT(}Jv7{qlpkJ+>2;EQ?WAKwmPf4@&RC99<c4lkGr
zmFsc-9F<te4_p)CG9{KLvbij0aQSL?M9|1)iFNGVRk3ENBP6nWV_I`)x(9R1omr?#
z%D-$wuE9X`Giq<7$QW{@>4`|b6B=++95~z?OrnADfWrkiIm&kZB^8o{EI7U^k4dt4
ztFnDfZ=3bL^~>JF|2Cq|-Yzc|d$A?F6eW2oj88bre5^8&&aO{L#qXr+L{g6dY3`BX
z<Wkt9+M_%rc|MU7c|fiB&eOz0a%;>M-hnZ~Z#PG#*3eUv^ahpY$yx-m7JiU5wis<Y
zd(CmB=|YYZgJa?XN7HV4TMb;k_b1oIj8wrk$ThWdaf8K-u;Zt)43Q;GAmE$qr}3T?
zk2t}w*^vbXm%fdJwunlPUU|ttZRW~g@m^h0q~m@9ltVe?<tu?Ii4x;KdG2_}=qNG2
z{d8gTzK!yX%zc=HF5Hxf@;1BlJaa)iNhGr|EpfIZ^_!KiE|<obM9+qR4|`W+pKzmh
z7OM`M;t|c4;rJ;+5Bs(H3qU|60sjfU>^<bPFq4fp7ytHGudBf({Uk?PGrHw9W1umD
z<LbhmK_h3k(U}i#A~Pa}i7I2gLJDN-EG3{tz80>E(?DFwsHI0|rfju_nm@pN7SW`p
z*ct${Zq_pz_g5-AJbYT;=9w>^wbr2cUEofeg|#$LEzl)(U+SX<_}O>v0yOef$4f8N
zZ$vM2GzlkkIzr3w#^&(_N)Z{#43VjTksK`em`s0O<GI?489I14)RW`bRVA{GR+BP3
zX>24fZg;N{9Jd)so&vLn!HgVoj0oQEG$%+Q8Rr{0wc7el{{_duy{%lFee0;KCqMQ(
zHfOKFVHz~B4y`brUP7e*0`|a~bLlf4-0n<v-JUEfV)^xyEW$e&=?2(ru~?~wUAhNM
zlY90rQ$7<&&5Tbs4jwYXQ<BzreO|y^+Q9oA?GMb-qe7sDxD+iCn*f9w#M+*gj%I)J
zIB^Ed*0X!e`<BVlw%qC{^4()UgviYN+YA1rGe?z&G&7vgSdo%jd-&&Vxye$E^D`|W
zJMzyf46bZ{{k(JD_B`ld<me#BG&zNM$v*apTdco&wHvsck%Kje_=rB#>_h<-aps>g
zazrt?vpFp4;GE6(TWZq48sD7F@XPt6o$r6RNUchXOqG{(&pw_H^Q@Q<wtFsx&waed
z5?_pF_3L=Q1MbP*OMCL|mJa1;^n-|e`Okpn`?lcU`C|32v+d_!wnpshL;!9#BNj^T
z%~*XnD)@q&KK?eKZhuzWjsx?;mGZMVBIeSWKRVi$M^A9$BA@_g;F_vNv-n6Ni{U%?
z%{!<(3c_FI8D4%uGnV6AdQfoUq48XD9m4WY<mq($AFm;r7V7})to+B~J}PGa#BWK8
zNN5i>UBV9zpaR(z$FM#mHb5*tn2&_roois1E+Z_DNxCxF2%?wS{KRc6t|g~S_)J=Q
zp9sYi!15%c-BZPL^`v1G%PA+A*yZ}4{xsz@Czz<=$DY~(mT#uMd|BYl_#lU+oF`Lp
zp*4TxE21X!6)G>!$DfbD@F)tOvsnJ4Ku_j0z*VP-+MO<6PQJZfon!D9SC?;R@cC52
zjHO~jS!l1~?aG9|ijCEo21-r!Hxrbao0@x-?%eJDtJKmqVW51sYd%4_^}$B3^1VX7
ze2Tama^iez^sfY!_7<V7G!2KQl3dx&<Tg4stM&8Cn(pS1ySK&@_Em2K!&|~OtWq;i
zaqEzoPhPVr?#g||v0Q2oe;IHx^=+2GFm%pOFuWIWxu&t)NZn3(fWzMR*bp~ACx>%4
z{*^+6<6+_WaPh8%%H3;xwrxY$EW_IZLIbsyz&nbrrzdM4Hxksn7_u~m{~%t-5r@z=
z<HDXnJ5TBizH+J>+-bOpGglHb(s+5|ip{Xo06rj1@al6Rn6q-wfg0dzD0EiSA~$wY
z9rFwl2y7)RG`|kH8eac0>S+#E3}Nb*sSO(T&yjgMO1W%Y8QvKIxW<_~srR+)oC2P)
zlk%hA8Wz$bErt7)mMmX9)c@4^uT3Dp=GVvZ8PeJ8ttyMEFBo&;DnH=^D13-!Qp`qR
zvs%LcjGa$t{};Paf5q5vOCLK(OK6*lvIzw>4rrLy-I=6mfWAWDBB4d<CxK@^x9y)l
zTs3d)66>1V_>&=h&T#+Rf2lCHw$3lq_imb<t)nc&Lz#qt6RL*uI(rsu9&~yC(RtB#
z%dh*cJh+$46JuL~9%SEQBXQk(nf4Ei$3GVQe)$jDT5k-+gQV1|p%q8F4Yu<;qc)?P
zo#zMPznLO4_=tP&V37JL;f(RM7?mw6fD}w<%U_GVWNN#kr_%;$wexnJ@ZqkVHCB`*
zV-rhfw+>BB<~qLyDh(_eE$Tje61b||1!r=01U{;0vrFXnyd|(=V|b4(|0u#ZWW8t#
z-T!wq2%(3iIDBsr98)DoNM6a@Hq2Z;#Smjw13LApl}*&%JGy^$69Bj=7HN`i#4MRJ
z5c*6VcM)Rzi6Q#aLxAq+)Ja$o>-%WNI&(HRrL_O!LNlf)XA<Jy=}S(~gOtHUrUe!X
zCv`}W<4J5o&JBAo{aD>`InEa@1O6Db4iVjbq%^{h@02K?FYKbhlbk0hwK^}Go?mY7
zsQi9S!Ei<KMf^-h)o#Cn@lMl=#O;n-hX)D-h|*LtUnd=EgfruBo)USkLHCR_muM!)
zTcc%A$r<J{(nr-!T425lK*rx!JyZ6NmPOw(D7L3UXH>Uea(AMi1RS7pjZ!n<f9Ir#
zDQ!YF7(dlPS{=W2rtL;!s`S0D=T*@q1@W_3hxHKeGk#G;gjG|cdjJRGj^Zn5f|<xu
zN2q%VN;D}h>em1F8Vy-w8DAx`%r3mt2Cv2w?4I@Q5!mqVg&PzA_sqn2;)S~LF<>xX
z0PB4_P1!Lu7k}Errz4(PyEu634}>WQA#y(Yn+ngtk81a{WqS}(Y;vjWs*YLI5GXUY
zDN)rf_q;`}C|PWxaX40I2Kw+-y~H6w415)Ke{8~u`zsvKO@001S5)%V^Go5Uu15*b
zhGp)*acuVG7)8EsvM!=jqD7u3zXx#szAJMl)R`}{&Ie=fD|UPwpn94c*)A#l1k_CK
zy0U%Ps}-J2%@O-PZFG)ghMwPq=IdayeO-b?!nnp$guSx67zJ1lh7FLN%vGW0mwYv?
z_1gK_hT0VHFl%$6Sb#EJ6pTzJXGeLd^$MC>p7ob{z9__%;eyCa9kKx712rL=X^&KJ
zceuH?<UVb~lJ+2?N5a<+$<@3t7t;*J_@rTKzR1Jpa-uAH?kIJHbF78TZNYa^a)uuC
zK3}=OCiat_<5|j%s<0t0geo{Sjs`j}8_!aQMTh)zu5Cg?vZC26m-AsdlK1=eMJ6)5
z4uT@Az#8R?=Z*qplVP)s5p5tRxj~djSmeMEH+ZLh4Gd2}$fC@ZY<&*Z2hZk_#dHc9
zG8Bx4UUWhNH5SgJ#umq;i~c@53P;w|A*q3k1gTH+t~qH1`g-f<rR3B~E%6mvo+rZt
zdtF%yK6a4y13Oh<lV2_Dh;6VRNq+6tR#Y<Jpn~roky?bzk$2U#LhTAN{u`CeeFe!<
z-|aA=z*DhoQJa^Z2BAN$TcD3}US@~@YzTj6$^@OF-19bJ2V*hF`{5OE?Sj<i?9kv}
zV)mC|jr-vT_XR+h^sbgK1OHML-Q;)j1SjN0s<YA+M4~VBx>sOz*X-<Y*A_aL*fn;>
ztbOLgE!YPQ*UCattA0PoNiGVLa?E*#?T*Sz#mh=oyQ3$0_VYGw)M@Be<oSHi<BZn3
zX{4C!`+5a!n9}~#$dhI+37}w#h?1Mv4Gxmr2B8*<15cE<Vm`<m`!jy}(RT4;!!?%X
zy+6+`J=&>a8Lpcj`#W9u=x2k8(Z(lP%BzkKxBTLa>_0G|vwi2euf&;etwruLCzts0
z@aDiZ6PW(5!`}l*!<(Kgr85EkqR)~Z?MStu{Cdo#jtaEZhk=8+qknS!OzSIOrgI)-
zETQHipIo1;&TK}KrSlxwEJ@hgyR4OeTW*JUN>RN<dn-a9{E$|*8{jas5#^(UNDHiE
zQ~x@oMMdD@FFi02$H_qtffT8h5tT6x_P=CyKg{8S2?abvgGz_TLM*SD0TtktfFbdI
zQ(eUH-)EGc>?A#$8Sv9v5w~a}P8{<BYY3PfUBgqTb2eVAI^~s;&`D45Vx?4ImP~L<
zCio>-`^1-NZvZ(&K-|)2BOPx6nJ<6?sE~+Fu=y;}9z!<Sq`yQ$0)XmM0)rmFe;%dS
z3TCy*ShdO2l0ZY|t{@R$E*aCRrNr4qJ`e*NpGe>-C@2BDQEf-`)hSKhO&*rzGuH`#
z;BhHZP^Q8d7-<Z~#|&u+EL$0Z)kzQyI<a}d%uLqj)TF8LD~NgH5P$Qq%qCb93Bix0
z2t?N$X>_<uX~o!O1<Eq6VfcRz^cqVtV`k6>3+zJ5|D)+%+?oFWxPgB*+stVP#GGg5
zd_Er%J2;b2jwze-VG2ofGTWTbB}pgeRFYFdC)=EoA}Nxu%vn*CN+rAf?)$p`gwOT9
zKG*erzYdS57N<(*Xprug$~%XY$&b_at_oNf^r#vX$QhACH*vI~3QK&j%Mi#AB|sh{
z?`@wG%>fyB@FzBZS6Xfh7%T@J?ch2zq*=iwj4K9JmYKF$${zDL^6K1ALzWDkY_QO~
zWoT#fMI~ZO#r~6uEeYnZqhuG*w?(BY*0C(MxaLMI5)2>*hum?ha?K%{uQF}$AB~@;
z$yk#}SONPQ@UK{&?FiTSSdXelk7n@^zzM5v#M)cW(V<a=kFhK*WQ{|~Hi`3&;sW|3
z!8Svb`XTnA#W|Y}rqV>8Nqwf}a+TFQ*BM4Q^s4`mkLn>8Rqv!w{~fMBm>h6^PCoCt
z?2fX1nTl(d%buq<`0=>a=O6i3(rg(_=|2L&MzHm4wj5+WpiDsF6<gP&*0zJI6S}Ai
z@GFB8c&kvrJc0K!n;S636g$tcrPOE<V8M-PHrr%@oE)5=gIWC?Z3rA{!2L<(*^N@7
z8^dFcL8AXKqZ5MTVZiYn=5ZrPoDoEJhbadGEW5~LSl!*np~@bt<3B6+!sr;R08W+{
zvU8IXc~fRY$$lP7j#R=w#jlG61N9_w_>66y>ftUWi!V&8ig|)0M{eMT#nw_ioTuxd
zWIx0_*5_cRb1U(*%As!&>*))ucR{JUTM0=u(nU+ouh@k38QCqa&9z%e?Sm8s^XOwX
z#b!>00F&vWdT{zE(`+UwL-OejNH~|$cy!kgcLFMHov1d5c?Xl4y#zis)bHbMx^nDj
z22n~aafciyrRfx^9xZ#Dd<<f<spMp*PEWv|AZ2LZh`if@cVA?l`B|xjOF#H6bUps2
z>v<l*4S)7a#aS4j_1K+RuwYvse5iccp(fLkPOg;t6mTrKK8vjLDnn^o)yaSv&{tdG
z^~uFLTGHWDjZqKQCd%er-Ib?<pVPSE$L#iSDwoTYrNFmoqIK~IyU>DL&UboZ!75Hp
zADx8NHS6rmhd$lKlH~{cV*ijm{t#_FR_=b$a^7LKlvWBRd}@X*0VJ6AVsyQ5olH|e
z@>9HY)x5)Y#6FGa)2}qiV+&`>iThv*PD5<Z$Q1yWjxHzL9O7%K>~QxjN8GhrNFD4`
zsLw2Z3i7jBI6wNiyV35M)sh)Z$0?9<YVGp_VYM&lyUATz!8q<GU93vZ-2-mY<ith!
zLp+r+ffje#iSP=H2FKWJ#&!t2zOncyJhauwPI;)#s-sc~OAb0MY*^2b-uaj)PV>gp
z*gXCize6@{QEhFvv+1J&aNXC7y|0aW@^_dz);bOKbE@-Es4sUd$GDzlT%6UiPB^oB
zv{Gg$P3IHT20}2cx>tQWb8km*MSG8CqO?s@fQ`lKt@*iqS!A>1HCyaFZJl%8gJrcm
zZ@alV)zUM22g0+O<ayZ*mnz$jkS7Ax?$9+1x;{Aod>toxY%IY2OlMhHbJTLulq?!-
zu(hG#0ufCWN>69<?y$5Z@7X2_P?B7ZB)|;a8fj&qraxrcc{TShO!VL}SL|08;A?>B
zR|U!A6Xirm@Ue!-SeN=a`Oqa=LmKWZM<o#a^bQLn8l)U~95tP$6nd+#y+_WPqp)?%
z*M{*+3%otrC$~lX_stG8eSGH_L?5sG1J?96kVC`O0!r(P1_H)C^S1Te1)Kq-aEM0A
zuw)&F1jP;1lftcVuv1NfsRr=OCU~KN(B&qfn+C#4W5w(=dC7NYvPurDg77oa_nbg7
zHN?i+?8Pz2b#Hs0+Vz^pV3#XnsGE}iO!y3w9%g6*Q!|n{D+E)Mj5o$`HSj_Q@?e@T
zbCM;Q$Jch<Kkhy1i=%H@FG1-NwQ?x)975i)&I&vI29}|`9A%RMzz7x{>%9vGGEsJ7
z{Rk(5z~GjhQ;OVvd6@&EEsD1`t|fZ=rCl;>NcZw%7>aWC6oJ%+$U!AU+_+t*JwsCi
z5ehH9`W7NJKBz^=Fzrc`g}?6XaP@fGbJ4rkbk7Z(oXc;69z())N-fL1c|h$=kKB^L
zq%+&hgB7?ivHzOKy)4<i18+U;FCN%#%5*xRYc4z>4-P%_&V}LubU4wR@@==ART}J1
zB$9M=WQ#Fi-KIlx8sg?A0#UJih?E3dSyaFrE})qB0+Z>Y*kIpT%eEeISIjaj_Ip1@
zM8Ey<!Su(#bi7QX_lfF(qWFJIb4Y><fuWu*F!{Vs?j!SII^#5igs$P*_Hf!UT${+l
zoma#ruX`B9>FhqKI9WM(mI>L8yS&4klQ)uM8{ksYE$w9=2EIBV81V3)k=^C&$A>@;
z*YcxH1Wc_nf&kH2h`_}aXS4_N=%JVKuNk$GcBvig&kamH79&l$EE1n->O>BL_h<e-
zd@GA(tCOL!*=yL)t2NYj_=EkY`kuqmn>s2dz20R1nex|oERRdP964e@8)-K9oME^-
zn(7R4?k82vx7a%oPpt9<%!f_pA#^;gf7PyEH%7W1B4F<X!qmXbSs?qk@3&-HJRkL7
zE+rw6?KP`HSOb5PwwKa$l8z{uy2Z7oyrlX4u*EY?clRxeB=&AGeLrI&YxW;rwl`=?
zf1Bq3%z%r#&AL?EZY_^_M%vj-5M{Q$)94RRR5X)RrZahFwKUgLLjp3}lV^?)z1EmY
z{TU&)0VaW<N$>WDm2LJcL6fXe(~@`P6o?ruQ8(G{g{E7*(_7m_KfvTo=syANkv{Bw
z7EL0sfTwVFsXdSY4uvB~pM}uL%$Sh`3ig*)B1xr!eR1DI-^0$KnXoKLkZM+WXdtu5
z;DX`S^QanrpUkiSZXIIms}mSxaRM|h(je_8x_|f*ia$WwDTNm0ZO<c`m`&ZqNxJ0d
z;fxUGq4q3a-G*%WDP~%UUAxYQi72U*Yemc@vMf5`wmjH#hpTMBGW1|!r}{i@^~53z
zqHe-(#8}o1LB}?lZ=ql8DdF1Azlb-M@puch+#;U_bxT(Wgf1s1ckh2>YIlTUSS*d|
zy6&>44C)z`mi&O3a4x{5WCMH~a^b%DCGFESGjOjWNCA|qO(!OwWgq#<b@~4AiMZIL
zCB)9j?lh&08%yee0?Gyu(?C0ij?2RKTY0gYx8hD1IZf%~A%^xTf2LY0nU=Wf>#P^;
zjUxQP0K*=&&69w2#z8`FfSbKHvRB5qCw!th0zydD;D!PUzSpkaK5kd+oANAEm}<~N
z)k!z!_5~gIUG4h&9WeZeEG+-{6>htnAa9>0=@^Umwq}jdB?r>*1GsbrxzA!6G&|-t
z$H8%c#oDS&6$W|)oyHvd*?k`Um)-vEANkn6K-+FClq1(<sS!xIGY(v4Pw7Yp@dRk*
zUz)tr*nW*C^#<7&4cd>s*-MGrH+uQW`<weFZ#|j3zwg7tCm){eo9cfuHN5Y?@hAU%
z+&BHE?>^)O;lDqzCM2T)AD3=+-q|#%p{)3&jLG?b7YuS+w*}g^-&DzyOekE90Yh3h
zpKMcO?*eC@HX#MKy2pAL&pli3z#q{j`(qBFe>9z<4P=hR_GmXim1o!iQ~t+RPpmwP
zd%Deiy7}VSw#2S#t)aktB<LV(!s#()sd})q4nkBX96Y~1Jwq6>T}QoNdZWn~Fezc$
zYLIn~XJH$l(#u7*n<+PRY<|o+Jco2Y$H<9(exs~I#zN>mO5{r8K3t8DZa0{K1!JLv
zVnC3$`ocHvzh@ROq?C+b9Il56g1Zc5HP7_sN~$2NEnbH>UsU(3JJfk0%=NN9wXekT
zV)*{6=JAVToyI`%IS@mkEf`Ah#90@sd3TlEei5@%vL`m++sZTMi!4cKoF_l0m1@s4
z{m^nU)TcVYwj5evMt@hWm|v<IlN5dA(W#Baw~sF0-)|<Ue5FMSd&ATb@>k90aamX&
zyB|N>dq~Ic@wrzTF1&Kf@8S8^k>L#*-&*@e^E_|)JSji<`C2NX?t8?Ko6mq716}W)
z$lZDu1FCxZAjWL+Sy*iAdFx#3hac|6EOlKvQ*>`?>Tz?#_|xlW-0TE@{mZpq8tGz2
zcilR0zj*Rlh}@c2Tj_ln$J|>y!S0XE_Z)^*{>5n9{($R@bPN38%wacb5+DW;W!l>9
z`kFg0bffZO?vfT~qV+5nOakwck+pa9I1-+2p1l`GI<iEHI|kH&BR&m=`Y}^{k+?g<
z4V`Yb#iY5fH6VQ}UHnVNwvLh9722rtG*A?;gf?t>S*qSVA4OVjJe>1lw$%Svjo5zD
zUAL~jZG-(QEwnc;&97d-U19#gtUOAUXB`~AJbC88fW<=f{VH6VwX<WP-QI7*uZyPM
zymnMR^1O)oSXlrtpA-TVjc{vi!X~3mT)EVGp*>=`WnJq^F{HN)mt`-;gQ3>Q+5|WM
zy)V6e_kofZvB}^Hb^1An_di~HfCrXtu6O^9@DdS{)p?&<P8@n#lC|yB7JL8T=)`e$
zY>RM&b-DV*xF4G}HIvbDp&eDF)bX1J&yBw0&$xQI1{rnQjeks4aht=EIDBAhzv`pM
zxp@71_L`nd<pRIiY|XmoJvoN2{O0mc*>`vr5E1_K#h&w{J{LUQ{TD8Ie<)qJOfB%=
zeU>-AU%VRs%75v4%9r;`H`5RS%az%Blgrh`4$dN$7T)nZ=2YDLqim4{%>oDP`(P1A
zTpAbenCCoSbGLQ6>vPTPoy%~`_F_YNJOSOPX9Sb8`*?lC8oo=MW_M_i8#?<+F2)Pj
znK_|u?=L(1p7$5e{YMPkXwwulM?KtU1l7NPd`{H+DxoW@^eo*J0~qCX4h#>+=BPd<
ze1m`8b8&FD+IKOKFPQXR`|G}Ot$~gHo6c<(_#4dG4(;E7$!+gj9eVtng_~|-QusIT
zD>%REoT76D@+Wl+Z;LvX>t&xweJuF#*AJy5c<cRo(eo8SB?sCifSa%<JRtJ@QZhZa
zqVudrh`i;U$^Gz39o;~p|8RmcnBUwDYbj*JO<uKak1N(1$U1$pm<;U1>wVsY0GV4*
zvqp3tx&Agbcf#H%uUKTaXl9kl-Hik<M)ZS3fh>=VN9`pKueR}&zFRo$-QHj`EpSq8
zk+WkiBs&!tknPeiv*)Hs-r21=UHg%|79&6D`)lMQ&Zi3uIMog7+f~BS@4@CS7m&yE
zdW3s7;47k~^)~xN)&H00jTqgnpYd=OE+OaKW*rGILJ_NnKdW+OK6?^H(k|(~vFGZA
z$En?gtauO<{$?Y`r-5r0rb9ZnomN2IHNpAxki$}r_8|}z`9mg00?(6`Il5sI9E^jt
z5yYAL<vD^^*(dEXQ4qHBO7HoL{(ph(>2CL`?Llzz$60DR&@hXA*});^H5XdKum>gq
zE^(K)VQQ`zI<&YJ4w$;7JdKiR?R2!J36N4dUN8lp_dEp`3Epkvs7!74D}tNyfyZQ#
z=Q0`E$f`VGicC3uxPIk=03CbbwjQN?$??M>QOe?OfVRiD?GCPwIkRX|T7;(Q%{Hbw
z%?f|ta@4g85w%pTkq0FgE}LBHA6hj`Jaq+$;}grr)cmPPRy`O!+F5w~U0BM?y)qgN
zRTa5o%D@f=su;}_dWaXOqBgl$=`%zQe_Pi%%$Po6kSJgK>WA|RoM0thCmAt4jL+H<
z+AVH9OO@x`=NqIubjZ>z2YKq7dkdR(e(5L4#-*N2Q$J!DqvAA?aW&~T1%7}7yGsah
zoB!r0H}7#ZQXVhbl5!Ymqg)Dr%?MX_X&~RWynbxdTYcrny|e-BGbWzow+63v`9;km
zU`VJ8xSh-A*1~{YVynqwAo?NY;AuMsYHrK9CD^#Zb2CkDNK2tRt0KdwK245K&yXFU
z-;i6Fll^@C)A5bF3O@8A`PC+|eX`B`4>ghEXI2A3<zL+$PL4Y!Eq#0cUazG>BS?kc
zxAIJrcftl<^Q~qg-};rmF_c$(ji0Gb?~l-D6xhNoG{FbwY{xK?_5alJKX?dSXlxRd
zSs=^B$Jr%A93a&C*K+4(7T16}A<UW3EA#<Z<Iyc-c6r(0y<)IDifw8!u-|m|eyF&<
zo_?{d5>YxE35*aj%|i2hypz6P<;h1_4qth7vi<w@jcXD6zFrwV_w)NrkU}I8Sw50(
zwpoe39%-*%{u<{hpdcS5uG<Y7)j2kJ_zDN+ME486n2{LN=3D9@ACex?E+miT!Sw=_
z-(HJJ9D!XBN@gu7PQ?iXPf&8>_&T4lbKTtja&ShB9~YGu?83+Wy&w41D*x&9i%K)&
z&&iUe>f{|q74b?PnP;+*cGyVgS#-v|`Czknw+6x3?+2C=vtF3KKm1YD;n>||3#BEW
zvU00KghYz0`u#Gz-#@g-F~NNJ=0v{*c;h|b6s%o`aa5lH04o!LKHnCRB|j^TSpPq&
z)vis?<Pq`N2d$N)`d!=4mt;6pD5qN7wo9I=$XIs^o+0FNX+?VgBfk}m;Ak$b&h0HT
zPF$5l`)?ELbN8le=Zn9y7H(kAtGbevX4e{1h8t%J&kmTP1bKJ+*j-4;17Rs=?X#5`
z@nW%?;2fnWh+c_d-q9WsU;L`2oo<PzXwnu^Z+di(Gfezvb5NIXu2Y8T<4V!Mc}*a{
z9;$P#EUU_8cEi2ltd0~9t!ojCnYMtbxqvgzPR(J({HNcZS<IW1CnJ*bGt2g-6zM{~
zDmC875$F4>X=2=O<}l&tHUoFTXW}Yj8o!=Izy0Elrv7Yg-pv6Y$<3t{ZVKKWq%Esn
zi<j)^PI%i%n@=AD@?tK5w(N~N=%;TkP;1(rKR&1SEpL5fSud{1r4QZfo74c7TDEX%
zp5*xMRLW~`ty%ZC-|;Y~sq%jcJa_QEr^9yE8DiU1rAfAwlQO1bS5Tm0SX9MjF5ZnT
zps8|=qI0ruSdP!B#w1q8e<OB`eT@v@Z3S!EwFDR6sB9^lT{LrcqlhSOS1JrOh{|SG
z0`!VJW>FSU)WOp*(*~N@USPsZ$sAcv%@<fvN<it$Q_X1XF$AvBhlGg^k>?CZhI5-a
z1pj(vSYaKSzM@{DdiFdEJF=`)&-PCAxKC-2aA3M~LiUu-@8Jj_a{xIoU11b?O)^G%
zAX;&Pt~0ulDvz4PLG!^_<adr3WmWM!Z_{nI#fu|JX;9G80%lc}b|_B<x*rt{iKX|6
z(FT>=c+wN9-z%6>;au6k-sMsfBAonRDOo&P1yv70MOTa05FExn;e4{?+DT>?l+F3m
z_cAUZMSs{y`>KwvlYY>+N^NYk->rx4Rp{st#no;Vy2sH8RV6<`sWTZ3J&o8nP~S`z
zmViVGWfzunb_VJZdl`}?y@&=VvZPny+YDBNt%4tvb9eL)uJlX<6?Q<W2~df$Uhkh(
z!nibff`)Ys=%=tI<Ukcta#m^bi|`k!|G+Mls4O2aDmRT*JO#_1CgNaVIm)X22v9Zv
z`Z>W`4QDP-;o`TcXsu9mv;f*-?E@G<(yE0HzEEPN=}ZD;^_d@&YSsBX^;6DNn6eCO
zNh#qAu4e>4Nl`Fo<2%?&tU|T?3`L(X=PyME<zJWt9MhbwKnkT}`BPZyYi!#pW$Q6I
z!i6FFimf%se!(HDQSUz4awjNy_|goOeq!~%l2oR!N<WEmE+ol)vm&pE{^ia1B%abT
z@$O7Zq(iTgS!HEjMCQ>b6g<r=sughqp-$gW%BVCuckt;As#$QQa1D0%OnfmK{_;Fj
z(i(P|r?LIn3`~@pfKFdS_+o2y`E0Xu66R}Fm_D||Q#!n+8x_uMv#zr6gNhZn%7qIk
zBGUFsxS}{r1z>kF89)~B%zeH`Xi%qTsqZKat>q^Io_?MyW1OJSrojO8ziy*NUF&IT
z%BR;V@04Xq(huT=SS7Uv>rS5AdS2l#@H5Kh$7eD8(%TACeMYw5dy78xQZ^quDCd7+
z*U@g-rop6~3XgoLl+q*Z-4|^3il;ZP?ZhYkK`_LoPE0pdiVcuN2JYN#BqE05m3BzN
z%MoTB$|$FJC;eHg6X{znv+^bSnkbMQYY8`<Ch3Md+SLDdG41a}uZlj0Hy<V^CGMCC
z`=7LnXQSNF`kn|6l8MP07FpNmI@XQgP>|2N5jm2oCWy#3I%1uGnwfc8gcFlW^Zc=S
zkZ5{nH>AV)!J+*>4tbh-d!O|7f8c%Ohd0&KC+wt8)B~T`A3j%VL_ZO(W`r8WgnAtB
z3lWDcu=e<-)M;4r6r#CG9m=x>U^IA1mY=ad;68iR2S2u>s&R@Fn)gNcUUg8OcLdPg
z<wAnX6%h4ton<}ZuhS1-sKQBP9O0P;p6nB*Ys$lwQ)mL>IgG12%DdTT6p#;%2HE?s
zcjW@dvTc-deBs#go``MF6AjO`5~$b-lNPm;_Vl-Y*8O%tRerYbKuS^(Z3MkbJPkN+
z_iqAx*h+Qv7p>d%Ix5gPyQ(c)yn{B@m?l?VDYf-hC9yQ(oLRVns$N@*c|#oe+LBup
zGt$v4w2J7TmxjoYR1{XDQ$*48-QH8qhJzKitb=7_RWSxj*hMPsg&FXwG}z#~+DvtQ
z-b?&+lJkxB@O7;F-c_h0Cy3viDJKO|_auwV3@Giovh_><%#49|MCl@XIeGEu(9n1?
z5hFhyrQ9oh3taK3J<^Bz99*$&Fnh6TRXs25m;_lkCrl}LMWkU?ww=_Gn5L73PrAs8
z-EXdMmUQBz8v0A+R4H_GvPyWg0wKzl$SRZ^G|>ktY<8%~QQ%OtkU{|`CPxGFxX-Qr
zlwyOq-NaArIRUwo<`EP0njNa-K$1Tt?y%KEv`jU8f=!T?Os(McHl_s?Lx9CoS3dos
zyG0<^7)Q9i5ua9+ill)=qU-xu?M02)zg2MBoKm0>qd!gV4n;SIE}kTIrja<LgJCX&
zF*RW)<^(>1%Od!)423KXc2bSu!7=^^n%E)<OS-r%nW9Q7|Cp$I(vnpL2*IiulX2s|
zu9%2+xSSRw0sI3uLEqduVF+MdhhJLaXLSKAg0*0-!N|F10hCW1e>_g=K9v<!_vBc$
z@Etlz^h+vD88b^T{!?-5XPU4K_qo&^q*gLAk8PYw!3<I*de(%!%p{PE!haY5u=Jm7
zO5H1!acUmfYY}0fd~=cLA3+XAd&b@xP)as5&8o;7OLF{&w9vyT&X1a{Q?wZcC41dW
z-#Sp)Kc?G$6vwJb<vHbVr%4q-p!&gzdCDojtKbeG8WAo>|Am_DBg}y$aon>1!u>C#
zsPUhL6{jU@O?j7|$Ph(PC2GPsHl!gVHu?|YpsxTh2B5#qTytTF%wv%|1jMAq_3_T@
zAK#a+blzC|ePhG&=8u${zdLXK`+XB+RRKL+A=FhN_NM}ERk=4zca(tW`5oZgp;|*g
z5ZIWUG%4_JHF-ALOHBO6@oV;&#8*{t1QFA4Ni~Zu_6aM7v8?r#ov>m{4XFEEI8Z6l
z4u49JS=F*0t^6`u4POQ18i@7HyqaRLjY(R4=IPt}eq-+tWJ;a=0cYU`>g`LiiQd6y
ztN-XdS~U)4%hppLKD8<)`v`Yqr7}wTU1m{LAUR+iC&iX65n_!{_bggAUUK&5e>#2R
zKGlDlCq3xsVactFsmUR~XP-^h%Bd1ru)lnX<Ca5oj}W*UQDgRsiYeIbp&>-^a*V^l
zB4EM&{Is1u87mm?Q5Fa9{>Uu(t?D~4BJi_fBURVmRVPMe8G*wz-MZ`Z6_<Eb;U5p9
zS0%9+Vm1Pjd}dlB^nn0SO!y$_89-FFQhFH^@DwX9PZY1|(gfQf@M+)Q!5@izcNNo<
z?=S@X%#~``Xf@?W3hcDNU4c67?!gdT2i7pmPME&-RJx?NxmI*i*}9x9mLPzd<@K^Y
zsNi`RfGDzyh|V@uNj+vOS#$R7!cAY5-YM5wbBiy_*_(Y<(s?DwHy(Fe*JM9ov5=LY
z`ohgHUvV6YS$Myia6LP*8Z(jJ-UaDzUaIs40|QXxtu0)@yC;Jnt-d(3t><_a@i{r(
ztY;V&@|%mUc{0N;Hu^aVw)2<P1Ps!ob`38CNGfswMWLeBXJkq%5j6zqHqfoIOsP*Z
z!YCf5tr9afa{@(WxPcq|+VFnn1-=~gOe5wrND4=F`=0ic%w4Zn-jKSFH@pA6fXGV5
z#kVi3=K$UYPr!Uo`GHyY5w@4?BC1pwWy0Mj+jruVp^{h5TWTH`Ixq50*}9<-;mAq7
z9k}l-M=6x1(e$G^40<#1{j*56ZrqfylCa#Jud@94K_$+T!m;;%;R2n$+q*WmIEyVC
z&ediSG0SDGd}`kT+}8XdHvzi5!(Y7n#lI|Q9~*h5YFq6okUgj@*?@b1teXDEoA#Ge
zb9(ih1-D9Yj_RyI|70s+;`W0-tM{eZ0azrB*<*qKnWR9Pz*>U^9EIn4_sH4omgCm6
zq-<19&eUVdprlJsR%1<k_nfS-24FCxBCK7FWHe9`{p$^$oB@drbT8Q(0pA|V=kcUR
ziPv06Pi3xyzgH^6RZ5w!;~Ki<YEDbb1}jle>g7cLKlF<>;h*`HpD*=3J1{HK<{prE
z9~%cTDp&a*b-R8>;ZrDnO7Y7*(ii^MQ-{x{D+({pUY$oq3v45T&B|r}xLJ2N&Ymkg
zhX<VH0J^9^x6IE3Gk_>lZ&ZK5p4Q%N{f!sW`0w4WR~bpA=d-gTiFbqLJNU%AM?rt(
zS1L!I^zFy>>~F-6tSiZjh?YRtj^lbxrolP=N?%_566h9>=JtCsP>kl~vjWe@ySU*3
za;s~Td)@wAE!DwU0;N-5V?u{7M_CV&{c)z=?b}LH&cY7UDl9qKT%yA)MU2nJBz+B%
zi1$0|_h(1h>xt4+eegO6ck>zm5jp?+;nyG=mhc9u=V#%6ml=KEQna1c1D^(AgxZN6
zhVK2qAPS7Dt{dt&``MxEEI-@x<)c(y8!%AP1SeiGc>wADeL#Jvpa=y!EmQ#qG{<%n
z<Yek3bg7@k`*s&;K8=;~8^ztaOrmb2f^@|8<(l1_d_eoqbxy>*ajG-%^W>9U^RG_U
z{Oy0aPyj$Xo>N{qDN_aq7#rI%e+Tsd-Mn6Kq>9mMkTLG?A21j@^sx!}3ijhhYSC>Q
zAjlv4=8cMiiWS&f`C;~hm$ba$E}ctA>4nrOs|$Z`y$EZ4dhUTG&TIYp$CaV)&Xtd*
zf(#ss3VuA8kM#K8F8*Hel6NIR?^K`y9S%lue``CoNuM!(F8@-03E&Z;fKMIalwTT5
zF^j?w)*GNOMXQSW9zdXuDv$JB6;tZ5v3<}Vu&<FI=wSBsiUF5|1OREFBc65!e8@q&
z(0dd~H{f?7%ZbG57!xF|q7yxAa0Mlfq>GfAAscDxp;tEY`Jqt!9KH=@N`X*%Nx$<X
z5SF|+8TTW+-65e%qAA98BvIXxkqZ&_RU@AI&c$O<{Te3~9Fk!M;ntWm`-q#0;T@7e
zf6EpqRXKWtk<|q@lN6hsRh6>iJ6j>SjGX6=J++*(Z@uauuX(r3DxfG)AYe1>V59~|
z0?>i(iAS3$bS@%kD$jo+V=?Kxacw=`pbIe>e@Nb8ZoBn`2MfP4t^rAzE4-QlWxh0>
z3~uGSpBRTQ@3oJ|eU8nK6q~)Q7I|c@(C7>AmLKqZGpyH_|J?OBa8;@%JBUdTj_U>^
z-Qw6VHDhs{h-DSF0yI!OQsl+@9R*P3r3u;U;PqaTuhYhhTrWGdhRm#=j5$(9$7UwU
z78W;RLr${mCk><QU{=D#Z;BlbB$cQW<5n*gnn6~+4evuJEE;%_^5-`L4zIQ%&*}@k
z9WzX{Sv&0IRdErSwZrS27^kK_hyY%1lZWkK&%{nmB@Dk@9t0(mVZgDr??~%Ve0_#d
z=15ep@j2xdKcM~9MMvy(QJ6n)<sZjC=rCPPHVOn6aFA=>lIXTd6|8{DMo~uj(rQsP
zp2vxg{{$4p@=K<Qr7kSa4Jh*r9FgPwGOd3uLG~CUG$i)KX9bxHq6SE-fH++;Sw6({
z2!B`KdXjyr<caOQyASd_^}MO4Wyic)tz@l)T3x2^Xw69vUVW%kCbiC2;r~btoE-X@
z$VYYq!g2Jh6{Phn5y^1UCZ3yc1SZ(|1EFrhDFM)VI0tcjwc4V0LNKR;fRcJ!?;x(@
zWb=)hX)Q$FA3oV1DLh(z?y-)O@n<JJzpcVVc@<?U<-(P1JJeU5c?CPNlajEJu-QV0
zB0S3Z2)wp&87ihy?l&O$x~fUO0HIQ;0lxxXFT8Y}8O!T{p}4&E6MP6=G0eL9L)GOH
zgSI(`j1C;=YgWJYCqqxWdWNxqQK8$`Fd-5y;n1;>o@}o#Qz6oAwu)+bgB6noI!HFl
z@lXJ-Zn+*=6Ws=a+ryYvW5r6u)i_PFJeJ6>El24i!Oxy<3CJZx+69fpIW2Ap_&|sd
zGritxNi{Ij7v-<aw5XT&3uREh*K@E!q_Xh#TAB0BuyOE=&@)P?6`#?U2%jwsrZw9_
zg(9YRHWe8<<l-~5TYEnW4R_X5qKmM0NV&Fj0-*}sk@#GCodB!FX1ME7`)%W1!%PFI
zp3&XR_30|8)r2xCem&cDv<SX;N`f9*rjkneb?KfboUd{$j-{U9n^D}&uF*ItB;U|n
zlvtyD!{pxW{l{|-u8g5>ouUa?ZF`w`=tN3B+k9a;)%~VM>*Q@W)iPql*cgbRjFFqn
zd@Y$MmR`b@l*_;4`%L&<(_rnz7V*z~P7yo+t3@mu>3udNJl-+5r!gMB+q};ifBfm>
z{j+O#gZRP|-NH#tEZqhwGIyd!E2%jzwjo4G<o$q4QcKCbhA{oy_kGbs#NnZa2wRcK
zkpdPxVWN+;?P;BagG;P8_nDS^=6P5jYHPc9FZS2O<KnW}a@YkW1o!pu2jNp4J*Iwp
zk{1h|BYCL&mA8x`RiT5+42AQ}KJoW+|6A3IL?ifl!2oTg23onQNYdn(iI4iP-8uDS
zHD5$$pe3Dgh^oAn+!);+;hJhvh0WZuZ)e2A!Bk_ZBn=WSkDX7&KEMKAb@UG+Jh*QX
z<^qoMuBM`HOAQ|OjyOviX|)s#o|k@-G844phe~eBpoLy+$_?7~J5ZF40;+lvk0zDL
z{#J?iYU;CHZ1(V=>nYriOqbY4M6J{>DvfDm26>#__sd$M?@*%=Wo?EKeHH{{)*mO$
zvnn<|%?tMt2F|s6d^}m9tX-S!_yoU<v@2><2pufC^fhmZt;f~>73pUAF$a4>l`AWE
z#|POjPWN$2*>mST8A!IwN#<4Q-$`8OmweA#am#&xk+Z5aD%wVRA1lK~4`!N31(eGD
zBi8W$Wa8cA#fn>kmE*ART*o^rfuF7J_)G{WpEj03s}BU;UGBk!2cSHPph&Ssa!^g}
z8`!Vee$~>J2dDDaXxe-1Ryq=o_N-ozhZ0^vqwGkO?}u8_qvRAiA1FK!`<gt57Ox0t
zV<cLKnH520Kb&v~Dsp+p2n8ofpKeN>R{hG-4m=hb3Bfd8%!0I&xz+86iVLKoa8!*H
z(8M|O9W5rh8~+zw-<v<uyx8oS)hlwm^99tW0VpCfHX~UN@1OjrA%RCc4om=MJ!4)L
z%O-A8+Mnp?-n^`RZY8_r6mf*Vk$H8gR;n=R6mhEPErUiDOEFr`hbQC{X@wrRu&(#R
z1z62)5V{}>A}^|Fpf>|T9`18eKUoYjxA=a=%JI=hzM?O46tT|I-#&UWdaFm<W}Tn)
zdsYegyLOO=Y|VeXpkMfVDCYe4YhNEP*&_dp<euNG(SNdX;6Ri1h_Yy$K3sO7BA~nl
zB;FP5T5|YfDNJC1VjoFX7+wF;*$omenBnZnLJHnK)x*}K+E|4Qm-3|fTLo~dPxh{v
zLE?D%n)RDfEKs4`y=shPAPUn+6(gfQ5!xmMQO~~^>|=kl#obE{Xs~Ir_hTLxBKB)N
z6*R&0OL3Y|yR4nLIA7FvEI8FGmBOZoX?Q5_NsT4a`4qYcRc~A{fK^0LU<+rTfR4ry
zAw)4C8JjR8eP!k>^xM(eO8u@=`l*aW{p2%)OG>2<2Gu?C&<)Azw-nlj@HrwJ!9&v7
zl=0TH27a25v_w}Yrq`kraT!UTkltIHcDWY%A^}+%2hH*bLRJ$()5MN-!=@@w?wQy)
zI_gGT{OV=o<HUHKUv$Kl`WH2NOtUFOLZ}}FKa7Hv&#3>V)1a^EG*2NRkYF?gFPapy
zMa?9kGn33RqgtghciRjdS-#8u*#s$?6Dk7@NOO$8#vN#%k)CV9#uw?il_f&OMfmIK
zj>~)&rqb;@=v?P`4nzQ3y@8~M>w9!ar2#?q>#~j=41Lesmk-Y@v*Os1mOW+K<;(uf
zMW_I*BxF`yOcHohAwl!--Zj*P#RY|53q=|yc~Ri(II+nQk*pI6p>N<F6{7!7%*#bf
z?TUGW9-^x==hvj9vWVFilcl!IwL3D<C<~|fdTIIv&A%hClO5+{JY#+}N&YvhO+^=e
z_bYTHp{@WTX&#W=5s@iCO!}LIvgHNUlnV;Y#ha0ZANPn9_@Y=IB4t>U-*HGtTJdO^
zzg}>B4izfILk4<Cf|^u7GsoY6a^MUGzevc@F-wo+!l{s8R6<>=_RF;LF;Wg<Hy{qX
z*TKJ}T$g&M=UEt2xc<TL(xK$McNZ}QaVqs1xyMta&YOsiY>2!BNYLU-lRfg!aVJ!k
zMCqEP{Tm|b&Qg4AX=*34N7=HsUgs?dmF$c<^Zv3;l)v*PlF?+E(Ts}sFp9)NXKF=7
z4BetSGQ|B*3myL#)2lEBVRaJ|jQJjjUX-XVPi$+8^f^xS2|Z`uxG8!dYh5rqNh1}7
zp+DY}4GAk4ijt0R5*_zIgt8F@Nk!@PQW6&8!$qjh&Z|<MsQpzakjM4oem4#=Zj4vl
zfPijv+`jsma3hX@<WsawJ5e#USE?3hyN;JcF#M%y`hf&KG{_@pI!<+G-B_?HhmW!k
zy$x*|MN}Vz6>lKS3|06|qGm)$FF}3;lru3xw!`Aq)+x4IXI+vLbxy~HcILH2=3bU!
zMp{Y-wue?Q#S$rbTTZ1>Xr{_*;q$L68K5eL^W{wn+-^ju$q(h+RkQz3I(e|tW}{Mu
zjLI9!g?fswQ#}7^26!3hU%-_H`4|EeQ6Zw>K)4ISrC`wsHJO#c`Sw3~ubqRCAgM=9
zUi~Hxe8)y#*f_D%N-xMN63<G#V4)$LT)(+=J<BEOWThmvN$8+5@hCeXZ2Wr4vN)>v
z7L|PqT8Wl&QZHREuL_{op1zYKfj*aAcdC_tLb&*5cMDPmUPrYO{SG*6Hi>$!AY(m@
z@=>-<&Zw}35>1UuAgoX*C>#Xr+wl<c!fKYZX<qTffdCx*AgbjXVn-lv>vbOVH4F0X
zo_R;n!->)cKc-o-)VpvhX9M}Vsc}JA!ptS>jSKT#0II(-9tegW;NBM;kGE33$7WNi
zmCJZ@NJo&!dFr``vH{MX5IPEOMm)*KLOq?M7f?am&1j*jjKB2I0vA+GoC+^ehcYje
z0yvaly>7j~8XBi!+T*-aeS3?2Tm1Jia}me!lGYc`i-e!I##I(k#gPM+#cNhY&|*Om
zqL7wg>*wFbmLKp3bL02_MIQLe-!ll@g?QpO{+Moqnjh?`Sw;a11V~0xS-b=43b8@x
zTLrp2F^eFTi)~Dji)i8@bEGiIGtyIpfKX4vU3%}lc<!@_(?9=I(XL=-WvicANS+(-
za655Em501ya=$~c@nM#>@#w?UzcmA%mm$qM8t*CBueSIFpn`rQ+jp0w4BFfF6ph$P
z-S=<~s*isyfZOOkoM~9_+oPcT6AZx$P83hzSHP_QAYWBTh8j5h^+0IO5?rgG&%t&d
zo|n3Qu7C1~{`29rNOWq>X{?tAWVs3HK6Y)j>xmvwP-w#un0XBMMAVntmeiwvxGJwb
zdTdecFp`TltU)cyJ*v3GhvlMRj7ozY6jDmnwvPa@N6A*!KaEFY&l`%e4B!|y_`k%f
z%^pxM1H5^N^A3G)7kBRnT82L(lvW{@yTX|JbdPtZktW2Q?qWQsKVzK7Jju5C)dqzd
zCq!B1&g|{P7;;n}?>+xI%`Q&<c`^6TXb)IU-|^bsN3C~}rQYX>7X?=RxrvAsg4Ew8
zIEe^zPeg3Y5Ef8@bBAMAg&cmbV?Z;o@xy9)n&N-hDC;Yt=HJX!4x=`JgK=9~qRE;4
zGG~XKGkYx`X{qmKC>5QIzfKEv_;C3O;e}K}7MhcW{#<b{RRHk*J8*LqUuYc_&Ur5K
z+CQ@iwOMpDFpuxw&~ypeCb&}#`~K*D%vmfze=$^SOQV<!?W%wD!T<yP%L!r+Sg1P?
zBPd%ejUvpiaLD~|%GkQviPxx=({Zn((b?kVi4D;jNnn;GX?sWNxbx6V;?Um*$U6|A
zmnh=2wdafIaLvIXAZO@v9y)MDI(~JqVvk@Z;cUFe0Mrmwj1pu=V5dJQ22li42=RuM
zo&xr;r0$cs7Y2@P46JRmo^1BIJ_FAh89cyx4y}Zt*Tko;6vbMIt17_c_M<wBQ0Vu=
z4_#h;I{8w>h^gW!B=VYRELJD|<fu$OmUORVuv<(d4WYdD#@DY0Ro4L>9mB*2baa}y
z{&zF?F+b%lMPyfEtq*@2B=(M~`z~bvyRg`I5&7?;?!Ak7`R?ok|D|~^5dDSe0xX|!
zjJroL_7?Q;Zb(NH1;c~)#f@W%$BUcB&;1*Zy?!JiZVW<1RMLY+XCf*?goDblzwk+$
z<<j?)JLqBXcNDSPDbmVw$j&#?%$S(7Z{A;iFI~5WtiLzWs|pXwlua>;RbdauxuUM4
zZbL`UC$9R2dV~wTesc;fqSP)ZLT&i0*$s`Kx_)Jf-!#>{FVJfy^e<NEFdhEb1T_)z
ze|2xVP?s#AS&Q|nWE?n)(Z%>N4J6*MAEY!l+%1OPHWm*Bgp~JvOz`-)L%%q7BrrdY
zuX43WT~q>)k8fQJHpd=TQ@PrfLKOM>+qZ^}de@}W8!OH7$oCg_pjGnt6;S!7Gk{*;
z*9S<677SSi_>umy3$S8lVR4|!YS*6H+amoG(Jq1r>{U=loM=DLclU{JR)r{^qqmVS
ztwfw&Ym!}%5@}nXe~^iGaYwlogy8i8xJ}5t8R}M^`6X~6AxXrD%$%85L3_qqgJN8G
z7TU!N<qL?#Fi_oMel{7rla<gHBg#+KMT0(t&=|oFs+S<_rPBO`2dW_lmlZF@g)l&Z
zF9~8RGt$fJG7|FA0-#H}(M&IT@QQ&br^12JN!l4f^r1u_sgyEK&Lc+oLL39p_3p~d
zFTqJoyB{2Oq)zRI5Maq6eZUI#rC?+8LRI!j{#+FO@$HT)_~<0o8tr~9?UHFO_+Y2@
zXZLfqzX7{9#1MG_;bsHT@V~d>D>{>ja^)j0$?Rk6g!oIK4m^>=?tP#B;8PBc@xo(G
zJREnPWHRVcFmQLk*Fz+fDprb+ZexESi%9rZ+&$!oKGljDzw+VP5x*q8wZEw4U$2hl
zctTSMa327`&F<Uh0+9wG=gvznA9)i&6%1wH#Df9qi1bBIRO8i8X{KMZTg-kIY^<54
z>AsHDr+&rU#d3C}ge3s?hu@k4jP*&Qn^+!W&svVr+TP*s?oRyUjvr6^8a#X5@WJ?t
zR02V2v}lhzE9ZJz0E7zV%}A5J_?myk{&4@X>J3BOlFaS4`#N%&P1qZ>F8QE5$IMHV
zL4l`H;0)}Wh-Rpe39^U+pN~^HL`G4rA*<H~9rrDzc|)S<;^AAOnug=>V6ne+F%90^
z_@F=!Q^eQ<hk_ytY%qEP(BAE?AkQ%<b}sT&Qn7ysVT;IAW8oSTWX!?uXKNL^YFxc;
zU}KCGUWEMV{V~KTMch=D9CJs-1*QlZ9n`HswOdL0RDAzcAr=n^iKNlk1l8#g!Mky0
z^h-hs$JAbyV_$Wv@#*s~gZ?|#om2z}b|U~9fGRfOLk&vQx``~IJ$j)NBRp;<0JPmE
z!w6iHlM{sbiPv+EMauRCc>mFP=Mqit#?bep3$A5`VXtcZ->3qb(y?FW-@jQpP(e&b
zs0NHJd)8pHo!lnJRu0yC*1FdQyp28x*e4!cn0))$w~5+YpnBH>SKJcywlVC(yS2j|
z@e8kN508I2@;K$kmxT}GUxT{Sph&gAiFImE_AbafHL(#gP^@|ef5G9^o@N?WApuUg
zJ=f}X*k#jA_MZ2fI`#YEM_LA?!&bnne=oaV*uQ@QOlj@A`ta6;wr}hcWv%eJ28)YJ
zp|{_5e7pPV^6}Us|D7fS@gths5rg5)%$=QVX<L3nXhZ6nRj!Zx<h~c9Up@6NrT({b
z4p;(jbD@H6)klG5XN0r7Oh$VUE}m5|^E10&d8z2kG0r75w=Y^E54w(XKV#nymoiDM
z*-y!RbE|m2os?Ux!#D}g+Obz%S`Nb&ZSkg>9lO(>y5J&ra`^=^{${GEXFWOqew$Mi
z+>Wj*NJrgPy#h?g=qc-pZZ4L&wFqMoev$t8-L<)tUW0{#gPI(m;-ChZb>7YRmC2GD
z+<i`}YsB#yDfEj2K}jX}Ccv;95Y|2<GTJKs&k|i3yKT8x##$^^agUMm`dVQS>RNv#
zcfO)uDHUv~f!=5<W;AWh#1ube&0gH2%=cgUaK~pf^1<78W?^{``pkmD^gV(lK4<_=
zZqH2=W8{CIP+LG%=A+URKODaqbHlP;hBYKYxgK&_Mx8Dw(8RgQ%y}PnJrx`|k9FR8
zeoMh<GE)7C8Tdt!Rr${&Kd`B2Va&`5u0*ernd@!QVvBHbeEe@)s9WMZ75BQw?_u`D
z1t4og_gb#C=!~opf}y&L&admygGRtAHvyx4k!2elyzs|%km`-L@+7h5-lMJ}KYh^Y
zU;I3)Q~sq)q+j(BEoMgMrWcUkSvuvHv+$!%X(vB8O0!N20oQXiuB(4!M!w&`hJ_2T
zL`?@V<DZy~9ajd<^+>tBvThAGrt_cv-Zoxm{XObV(f<(o#{HJu0ntL{PIkJcBSKsz
zz`?N2doDKF=gjrm_G<A;Kk!6i?}pc9i<_weadS5|20dGw{H390c0cp_j`)5m^OF2^
znCd+lKPy5OP}ci14-Ri)4mnSz*5@BIUq^X8QUF{KGoh^R^CQA#-(}S06F4%q@;Ba2
zWSS*UIjtVQB5t$%wOjhm%~ugn$G}&!e<SuRo&#Kk#Rbs&^%m>%pxqcD&Ht=gc6(;n
z8Zl%58W>5}n*!Yvp27~>cBEb5wh0F`4PswwIcV4E=0_4fUmD*2#d+pLO*{ujkL`GN
zVxz*G?7Jj>h<k~=0nLaA3ib1eZ57oIoI$i-^xb$xanZ?Tuv}X<w)~6W#igOb`1ONu
zX(1S1eKdz;fDZ}kSQN|cAnscqnRaWVXP8iet;?LqvJG*ld>O8Z7)@gD&$(<uq=51o
z!4*sCLl9;l$o`H#qHM92CaY3mw)17sS?|3=yiXT&OhnYv9^U;3eR(kquX+Rk@|mbi
z#a5a0{dYQ0$EkBly+sJ!pUs*xc$WWs7aRykDLOk;eZ=R4fc5AJ9l}<K((f#$s^H>d
zM(0Y-Uv9y(dWk--@K!zVIEPxJ=8F_3n)2z^3|j_T>EJd~Uhp<YAJ;ENC<>-Y`{!u(
z+24pggabI3;W8ATle3{Sr(dz@J)ERg9!OPB7gVl?d)M#Jn(W1buy&Yh7kbl+*a(R*
zr<=RG{<&5esW$O%TwMlHc@BqawZo$PGRD2i`VQ4O@;<o5o<4YOvc|`9A?m=n(-#bP
z4%L%YqdoIaAF5IFzU>+oeen99L-h{ccMjG@d+(X+ZQfKCf7ufx^Xmbs;r!b>Aq&s7
z8{@@duI;%O(aUo)cs<Z&R*k6yxGuN{glR)Hbj1G81Eb|HN>+z-y8ga(e}3Ap9G<9b
z=Owp)Q|*50h?=~gYqrkaU-o@PxE6Tjew+1j@u%Lj@=AMJRLHDQm=0Oy?vV`aKak%Q
zjMgrzo~}2ctjHIwnr}=G8`8o{iBbXS4ofDQ_@m8Zf4NWRNWhHkh?zw5f8_o46R_CH
zNbwiAh6DN8ncG^D`-`$pcFx5<SB9sHT*VA39ggZro_?F{H=}IBs<1ztJpvC2WXip$
zhvE|xd;$4j%oN-~(cKU8@zq?UpqVpCM0l_Ox0y6wyY4(T(~q3AqcxBRG_vqnKn*!z
z*wVqKXuycH;<dlUq;DA^j+E7NX#GpDlW*&$jME<0Ktl#*zxh(JXKGBmM#T2%U77|O
zq$%&V`mGJ-90ST=){Mme_C2i?@qiHIrnl}}@QGs4PI-rOH)22i<mEf8(>(RX60RN$
zzShU!gZp)}zr;6E@&>9};4Rtd<v<hRSm68-&_KHTMCiR#w^=M>Y&e(%@+YCQz4o#1
zT-DVT&)!ZuG=inkkQYQ_dP1zHn>2umYekwt5X9drnFc<wCi(xW=`4g{NJ9n83d50@
zcKUBHX>`R^@GyQ39xhY&`$E6CrqU=-DY<nG<pQ-*A6{OyZ9-@Ftia^F3Ggg4XgLlr
zQR;l~ygB{cmrOg7^;OCVx6ns9?mCR>bE1S0WD6m7BolrKp82VPoo=>Joc571<ez*U
ziTadSxg2gmKK8CaF~wZ%<d==4Roy!PB*4lG-ecr*+eqoRf!(-vvU^)IGIgj?jeqG_
z@(W}FGF4~Y-o*2(5U9!h_&J`u_?ry7gsO|H4PNE|D*67Fh6YfdrpS-PAE2*&D;2<s
zwWUGLD&>H88_A*bf5=Ll;$Q`5>i@?8R-EUsV`mVkXV)=@A!LL%(5?7N`Tpoe56L6b
z3Ya%g+)qhRGd)%4epLC@q3OIqy@LKx)eOP5`S?OeP~L;(${D7|oN#ozg3#~jIG|zj
zh-R%2is$);sly#qt7958oh%~LxP#a89W}~S@>4fSRt<1M^`7tVnL}KR{nmz?!=IFq
zaY0Q=Jy}+&3u-wJLd8ca2wQ$E)0YQJ6l`%7iuvc(GlRD0)cL8uU#6blycP8Cb42Rj
z|M=&(`h#}9-%9<rmYTY~l-d9gxF@AY`JUy)>2GYo4Y}kZ7;Q^c2MtT6Upc9f@#zg1
zmPmj%JS}U2#uQ~R{9&}Fheec5uqg2%oEd^GY<JGm_Sl<V0sHF8PI87zH3+Fy*Kg6~
zQzNb1c4?p~;sbz{T;J|2Q06l!NQ)CNBUE`?WO+tj##xh6oJr-~Fq}-r5*&srmMJzc
zSDYd>YqUmU1ye29DF0ih;J3lDmjNu<SQ2S+O-Su~W^%>eYn055Zg!EAhTagj#ex-%
zLaB*xfUM>t7H~6-%c)IF8*IrDivm(!1Gy$UhQHik-<?f}>v3ZX?HZ{uBN;~tkWT{;
zKR65L$2vL#i;PsvTGvC3k$pC^W8hrYIx4kDF#>~pk;Y1@w13-qtt^?F>XA{a0s9t-
z*W9(J?BLWgg@molpyj%~hh!IG?4!1YqPGMI))xVb8$TyAB}||+I|0oJhcK*oP_B?>
zUc=cYhPFYSwkX}*0-odt^_wUFJh~Hrx>P^d-ubM^QBKsh<CSE4!_X^TzZuToGP;6g
zP6^Ys4F&+h0RFJk6-vw14M8UYYk-p>HwK=qxSXpYV0$`K5kx;zC8(0(SmdNf4|Kk<
z#bw1kF*AgbDw)}z(zX5=PgXo<@<*=Hr!xIe4<h__9n6f7Ex{P49>6dCz2(JJ`n7HB
z1>zjW_8Z)S>U_6BD9tU)H}3v*2(V%(;V6!5{_RpuY4Olt58Q@?b+D6#fP+LhXhZNE
zju9r`YSs+CH0Q{E<nlBzI~vmC)_pZqBU2aXeE+BJ|8V!-K~06>y6++c2oQP;5K16G
zXcCG@Cy)R^dQn1=4kAsOhy^JLA@op`s?tPML_kD9RC)*LBB0U*1O%~wlpOZnXYQT3
zGw05|XZGAb?%!)>t@X{fX1(9M@ALegUW9o^6*8Y{Xp1HZlqV{o&IgDy<kb>Mu|+XE
zq#{&eG!-ACmQuW7Hs+F4g@g1WIVusLy*#7dR9Gc5P*74?cf@2(jkj31_o{_46$->?
zQIvO?tdM;%eh(tOGGVe7E9T6(IEs8@?roUrWyxHLsNo<w*r&BK_&KH@5VB35V1ER?
zVQ4pzMj;<t(?8cpyv<oSN`mY<S?>RW$X80L?J&kr88yz+*RL_`5{e}##fx)&w<P0f
zIj~E4s;ftd)~J@xP#`F?NRAp$pu&RI^RA6CK)zGRV{QAJ)+B(zgm>^cGoVsa5TlXE
zBxv3*H%i3V7|JsB7clo!@yHgNe>^b2+i_KcVs9NWJP-fSafN4W&sxHWV!0-c6d|eG
z5O1Zz!ziPG`xq(8wy?76JRs#U!4J682d#+*`q3AUXQF1!5(;Xp<!sefD5oAw<7qio
z9g10~-Q#_bb}zAgf=ArcPWQ8&-j<#Iu^ooZ-ay3OP|+T%Ymc+AH@akR9As}oi=OyS
z1*znnv+EzvE+$&y$sUyqoZ3lpeqekE3GWB4{+Fy$N&iDN3AfKMy+Kh7p|=mBIHXOI
zT1hT`;PVL+wP<ia4LJ;)=b2aj9}r0V<jeUBcQx(us1zLyN_{ignvfLl1hI;mdZqQu
z!Wtss$B4XC%xf<na95Fnr=MgVDc6`XS7y*D%DWEZh?!>`WlcgyB_w)iCCp!Ny8t;?
zoDjNJ9O5@coc?&n;(m+~BrPY`9U^;)ja8*pbq2t-wi%LQ$)Z=X$wm|}YNHRENkS|J
zCi^b9&!(lR>VA1zD2mYwmUs~otHk-K*GVRQ9^^lt)|=H^*8AWCt$%uJMwH8fgSG_O
zqMiaG$qL#O@--ag6+`YLre0>?(UxO{F2tgd(PM@wGUQ>xak7D*15fH*q+0(eZW8L0
z|NO%J5`&Q(0t-3>jBo7%G#KkAN9f9l4QGvGI2jvsRU*01UIiLS5c=IHGTzVG=7KF1
zmKX!;ET5i13Um0Nh2%M3g@}_h2m>+mM(KF^$X%w(8uy5(*=h^OMF^9%A5nrzf0;9*
zTj=wc?&pbPrc*VQFDxUnce3hHvfxX`P6nJTN+NRPL3jM8xzC>wm!@=r9GsG!Dbv}B
z(}-#thz3<)(C1Tc|C=mpt3spXlFygc(yC6yEjRiYsI<J#x2e-am}>wDa+WIa#-8#!
z%`%}9<VUGudHeYp2JB-!Hm*bQJ^Pr5C*GjKV*D;1O@2kYIOL-$qbN<x0ThE`2Fx1K
z*N;)F5#%yYCbUAWC=A-vcpRbFBkByvFUQ1`qQjX{VF5vNas&oaLM9Tt(2SQVl@bWX
z_B!0gi)7z5rG)>0W}b#(F`6~L%R<d(#u+I%YPpxAc3VjqemU2y2_*F5aS%n1ljDXb
zMgAmF;i5+bEMvO<Yqg(c)TfNssf>A{$b|il3prDln*>g$4W849K`4PBKj9e)Nsc*|
z;O7?QP9?>Pt{Xt;+ulY~$nG$*J9_ROZHVdnCCHh^e1C1#gq^`nU5Gq%RN9Q9f?~3`
zSk<b+u3`*PJ7MxFCcYsu$&x9TdzoS=%89U*gndxw=R{izh*Nr%GkM@qfSYndvK-lv
z7y{nSQ$yh(ae?mnJ1q=kXYh(llCm_C&uuYpj9BS5Jq{-k7?Bnt+jMh_NFo|`IpJ=+
z)33w`7^6qy8y;;)=Y=^^2)%?O(<KOl$FvGbqjVR|=#p0+vp<wwbJzH$%h?VhV0r&G
ztUf&|KgPN(v2yX8<~K7&cv2+figg9z-^#Q70TNYF7NCz@AXA$cfMW9N=y5P(8DGhx
zbQELW6-Le0LIc!!Y<@pLixpC|=IGRhe7iuwRx<cdbG;}DP85dNpiidva&<K*7bpss
zcl5kq=Mq}KBupD;ZP)ZZEj9kqlSN?9)+37r__yrxXH<4Z`&}T<uaS%MqeJ`>+yh>_
zLd>YS22*}dD?PpDm?Th)H)@G0t;+<#wFjscrqQx=_W(^lN7GL-G3bmO8_e!+CN60Y
zG6cLky#f#x!uU8)%(3{mL~S<UUGO(GwU4A&`rW)lcZvgPekx{~s1{pxr_3Y=lIHE3
zfs55t4fo6_2Jia8D6wlYPdn_l{1)#}6fdg1sZO>@XPDV}9InOnr6cFpwPxlxuZ+AU
z_1#%r6v(S;{dE20PX|s@{N9S`3U7@l#uW^*Bk>#d*{9*n;)alX<ZGbDn;gs7*23so
z-tpiOTdw=kmM8JHc$Q7?a<sJ{Wu)ph{s)=5Ld0+cE;J-icLIt-5-DGz^R`zWB+FHU
zCruMYlcs<XnK`cQeBcp4CM3>34u3i=%tL;2NqC#f`evnGzbj<mglUlR8^0w)8^)2|
zM&PieT;EnczxLV#UMeAeHwG<+5@QO+T*=1!5*B>V=s_-Va*Rb%&hH1Mb8a`iYa^La
zl;4w8UVH9ZZ?osJydvwi>13{M*dwCD?}NBy#j}!pA-U<rO5$1a)Ofdjrk#^riPAb*
z(a{9jKK+f*kd5D_<mnPG_OK_Gkf)K9bmINng!~{>Si$~)f~P<velkcrD>(szp(xb5
zLbPRUZcZnLL$*lbM2C#u>D02@mEYB4PFD+x;^gQW10DM%lAKw1t=!#{h`T$jiN%7~
zXX1CKL8orwo>ec>2$=r&l^{!sNKfF<NhoRm&Eay+HTMo7^(_q>iUy&%;*i01eKS_a
zeKf=;plx|qLo|Iq{*kI1Id(0?zn{GSmzPWl>t}lZ`FA-AbT+oI@CLcDMBx%uK&}>a
z{omk$W7Ju{{lpi{>Ui>LB!w)MQG(fvlIP_C0B4HR<adG%zb?5!=+9O%OdBL7(VEYy
zjDTnINR67mF}NR&-P+{o_(z3Icr-YywU8GJ`C!i2*ys02A<?3yQeK?YtFjK@f8UNu
z)SGY6MKj{`nG-JW$As*w6j#03CCOES45NOBtwS!0bJNkur+(b8b5pya3^qWMFs+9b
zljJua4&Mrp;!Ge01TAahsB&~dur$Xop18G>cukx=;sL5F1CCVm$ZI7=-e3xfV%nW1
zt6dE>WC9dn8L)?;i>Qw`s4wyzk7A;vUbk!}?Cg@~ttLH~boLUz8@l{#Z2@XrG$M3j
z^&wXH`!_~{X7rNo#=!=@LCx2qtGCi+L^&b}K6gW-!9vr)mV#SKA9HB=zlXYRcPb^D
zk1YGE-c9nu624Xb%uutqW0v2$|0z}>^MvBon@ImT{zh*i<bqRdD_`uT*yz)^`VMu-
zsXw3Y=CLZp+7q3~{{869$L>-i#lt`Oi@l@$D#X9_U2!BdTTciNjVmI`Pq;m47n20P
zuq~x-E)fG_D=;nZjERGH7hFe|>O0xSGhT|^nfYMOmCLXDbZcYa_BuRRQEpehM{Z0)
zi}*BBake4&YkQjf^)sKFBY!LoJ-e>-wGn{zhc4qSzqU9*n0+;Kd)<Ik&3Ai`%`6HZ
zC(JfH!B(6R(7bWd`-Iz`tyIVTpH{Fr7?qDLgd^l6&kZ%loK&{anp)I{9b-1Vzq6mY
zt+Bh<ogryeeY+_*lIEnGaprAxVHne~2dm@UxcW`5k5BT?+|fDsx%#2Z>Y=~`eZt09
zRhjXW2k%MUwUc76H&~BOPH6P7;@BNcrq8iV+YH8%HT(8+$hYu>ViJ!np(KH~f3)X{
zK-hFiqF6kvlp>i$C{2<n%_~ioubVDSQEG>krK*k*%F@m)=9Q&u|C}z%&<6>YQ?cBR
z$nXro{PHX_6-O^F08fWen6jpi4Yjq7Pdn?Rr<yA3rt_&h&nwH(_fm|qdaoY4qlZ)|
zVDDX6bdpN!_V-=PfBeA5kQos82Ir0Cy~pN&Q=(h8>qEV#6`!&=7aE%$muK5<NO}Rh
zl9vGooE*G}ZhxtQZ(4(7{OECM!A6P=e_Zdi0Di935L<Xbh7W*Q9FYjRVrVAfARd;g
z-c>nDHHy|Vt$aG5G8-5c6Fr))zd~xS@Va`D_bC<^waAGGGBQrF=kMa_sm-mJdh+sn
z-R$-yD|Mo^SOIwFL-B^IuOILi$qHOJfW5gF&VNZYy=+W_RMp<!JX_PjK_dmcZRYey
z3MyK3h83NV&Xah1Ccc?>>(?gwNdSSh?4?#Eg(3c&9q{lD|CYT<e!$z)x=M1-C;&Hr
zSG9UOM{QFzp)XuqEuoQmM%tl$@K+O0)t9W%=`>7OYS29m2}r~5&|iZ?*Q@#R&t?{Q
z3VZlHt(cj(+HwD~2Apq&dahIOrnP*&hN1EMAU;?K`f!;C^FHyf;OoT{B|)hAM@+g!
z(1~BTg;7V)+^!p)%MAamnnp*`xj&)rG?yNiJwQIQW~A=vYx8`2`P`BTqwPHW)-%8B
z0Pb|F?g_ovQAQw>dngdZpWB4@i~pX1cCY7R?fD*f@mBMr!ZR&@X5XA@;Nw-QoWJ~4
z5R;lu54)Qo0)PHR@9&R}j8gw}FgnApZ)wp=N8;M>#lGJ*?3`R?9|smMx6;S^U84_U
zKQq%xmapu(vVaw5kdJ!W+u0s3G&kSD(%Hsws)=!Y$ckV#Lp{*|$LmYGAXuH(+6CIt
zWR)TWTYz7O@FF@<YYxG2Ypvs9Bb|Eqm4~Bq@r}&)5>M%I{a+Wk6OA#Rtj>No<XkMS
zQf*hp(H!<{<7X$zvNl<tH$yTtlfreyfPHe-OhWuJ+f$dNw9j(vf?qTs5t&;mHTxz*
zH6|EjC^(~#2e~`_vqwVZF-uoSy8etZ6cR=X8oXtO4y0#xV8FmOnq9?b)lKymM<wEm
z%%qM(O=lrqsbh%v@PGRV&5=&^rPd@@JQr6Az7y6RhsEh23~)0E{0Ffn?dg!Se~wkm
z`*0VXDX^NK_%@+{Fp5E^FPE2IxFW3<jTirE{lWnZ4ISw4RetDO<pWv~phX#5H(bfl
zfi3er%^9|||5Jil#wyT8*j+C!WB_0+jE-$hFoh@apPyk?ds3JF%z}zxq+Cv>j`yFr
zG1#xX#fMWAtWb-Mn61u4c54J48OXz=7Pv)-aS=88j5GyB)=}Yf`RehuwlPI&kM_JR
z1^=C5)u=?T?2&fFqK#Pix|FE1+M0oujpf3Kr`X|AukC=Kp6|@c_0`OF4G=~bH7X&o
zGQX%Swa;(JYsu<>p&-(YI$!1Sp+etEU)0Q!wWVWtPP3MGzJ9*K2)2BS&JTyXlPM6x
z@;s&|6B|wT)U8uq<$NDSb3wE3=1uT=aJ|8kmBUWQ^@Md>a_fKc81&9q)$%Zuqm)?g
z=GHYt)?WK`-r;*g%Y2(US;|mol@6m5`?FS(t<`w74R(dg*E!|@t5j8+=0Wx3gl8)F
zD1NW7>;yG3OM(^G1OR+z>GMPw<GDK}mr`N_g$=HB=#%(?<$te~aHp|6)op1$6A}*W
zp*RJ<Q8(OCC-<>PP0STK_Z0I{*qpVoRGlE8t<xd+U3*ycxRxQso({p@m7@4Jj-oNA
zpxH9l1Lw&_d#vpVlqQYwH!e_}8C!)ff@1kf7f>lsJ0wdgQZu@zx%k(##HESF@k;;U
z7IP57l^#%|B`<y!f4Rakgd*R)>0y!LLMM^%tPpFRdKajiMm!!WUI0Q;fkq8rdOuM)
zOF0whB(l>LW6|W$nJ8%4aGM|a-s4S9`2fVb+Xo4HkA;AMkVpO!%uEj4L0l@phE%^h
zLE(8^k;ig}n0I!&?U~yGG5uG>zWCup6T?ShZd=uA9GGaijwW9_dg%;(QlLMg4D~3c
zA9_ZIk^35u>OL6MA@}xPkeiTgf~ar>PnSU8%a5DMQ$BnR%pAujC1+!*Bs@sBQ_N$y
zr;HiPcwWJn4nRQizxscZzY8R_3w}<UPpSd4z`TCtuBQ*Ul`DMax-$3@{M_7<*!K|z
z6sd%k_D0kDKOq(;wW$xQJQr9$*hl{p0Te?z)Vo`ayiaQ7(^H4VAm`F$0{0XXtwFJU
zugp;IQmLxKGVB)7{y@Y0$hAB<z@ySpr^=cX_^nLPfs&<+3zGWbzoZ5fGZY!s*@vIN
zHeS!vUR=L9i7*N54SzK-@A{YFZjdCDakQ(Johi3D8Mk^sVS*0|04LKf^M0{o!;kzE
zfYc^8BdfgvE|sL2$@*s@l&;1D0&9EEBIk)TyT@K;$}7C8qQ5MoVS7ot4SYGwZKp@C
zvON<QB?(W~PZxn2vYo(7MI4f-m;PrP8u9gUDD04<$5MqOU4@FR+se?T0hqTxM%o{d
zcR7Ly%wPW!N^gA`m9?ykXy7!m9jJe6y8e1gW?Zb=>AYa9`I8K2LsJpn?D@S7nm6z7
zP?G<(9~l?R&1T+<;qAs4t|ks1iZ$S;mwJ+2V=6x`iZH<^dUPPCAjO0<UATRXVRRL}
zFaf7JVIo>?z@Xw(oz|l=(W48SEW&?uMT6zxoxN;5l)HJej)n_IbSC(Z`uKJ}l#yap
zy7DsdbofPRE5f2hbRzoG?|x9;C1f%uZ)t$1_z;{z`G+~5GZ%~$#Boc<AOH?B#Pp~L
zdVnw7$HTtr@upR2;8;#N#HxnH#YxEd`(;(b%FFa$r8<v+R@w=(GXU$*k9q(I^{Dcm
zj`Bd(1nh`Gf}}W3Co0=WBT>)C=>{*hV+E^+BFcz^!STgjsg`<}tS5+^uqI}dM*j^4
zj7V%h3dq%WkM~D*>~a~vG+4$RNtk-9=x2Uf<GrB1Ng2lv(guaU1)UGxdR`(xfkz#D
zoOG)PL@9`Xbh`cPP!glRkfML7{(PH}2T4B_bUfN_H004TRCp%HjPX-8b|gncl!?n8
zR7OWV8xn^v>H?jB#iLC0c<s5u2K7lD8iPwZVI7|{6Ztmj5ENs=7FKH2=%HVS-ae6d
zi9Dk@nT}{LfD^WMKIy|jv0HX^?xfMawgT8a8n%*7SM3tF@8DGCT?1b(yl=_4BGhrc
z8^PO!z?mwC*loFAy3jYt=Y*SC#){_UVHKA3#pA2g;tf!)Wg~{C27TR4dSNG*E%YV0
zFAH<L*Cx1KC5j18!7bA<z<DJULvh`Y1Y^rP^r&5~=x*aNkFB#86~8bGYp|#_nmg@d
zg*nOkIHDKHKx>%^@QW)O9I6m6l3!R<@cgRSe{bE}4QcB3tBLvFZ|JQfq6)g3kI<t%
zci-RO>p@p3{+B_t4mKwu*@+QQ!zHUucN<f&0F-$5cAMq|llniR`V>3%nwRteRxj_X
z-5-XI&baIIca2c<R<U%N(~O^vJ84QG4`iylL_;LPF^19J!miVXXc8l^X;7Z|sVX&3
z861y*#3R5U<i#Pq2~b*-34p^6$uj8TK!{W#Zu#^{U3#g8Vj&#`%Xt}^cF0jAUKEkT
zwtzoL|MW>_Vgz|<*${`M2kZ@`cGE9NjXU=ufnuV80#O8SAcTnzk#mZ2Y7<?--e3eS
zbasgSGSI+-ZM8bHCk*vEOX^oTqS)J`W~AMqSj`AS7@PwE2e*gd#9Xn0l?GC-Sll2z
z!cXS9<+K<Mth3o>_bX0$vjTerGTamkqZ&vC;w7R?w4-J&&GYFtIsn%6=yyp?ek_$o
z#I7znWk*s_%_Z8_CJ4~PX%Bh;z1?bIojOHbWL;<6C0{&4*Mnw>I_BKkh0?kOBO!Np
ztzR};(|yH4PZ6@d?d1l9#WDZ#b*uU-KrfF;D>0?E;!Fv1U>F##R-`|O?Rat}b^Fw?
zXsr`v5{<lkb(*|9$@+HG*&K}N<8!Y#re}1*mF;(EB2DN|=r!wS^+)I*t|SC#b?U&d
zT#ffbc-y!&J8>?SKqK7+e5ZP4n;mZ(p90pRm?T-nY{qHuqKhC_)vh<4J;AUri9p<O
z@_0<K!^;h7-1o*b8#p-PG|S^=HODg??M>Uug%pT2T^;I!goZHi>o5H()DJ>q268vP
zIQ}xEy{~E4gUFjK8<ZoSl|FguI*4mE#p&3m;MK4;^M%DI&$2Dz3&vK|DNI@&a#OGq
zjbuu3WzedccfH+)aF3TfqSKQw@i2x8%+rZhQt{s1Lf5#3Mht{Q#N0+o-E{oTErOgm
z4bDRu-Tz#1=G?Ht(}_$N)E<Gy<P@!A4MeQvJy|NS<pv@^JDH^578rLKFoe5|UaFy!
zD1SaJ4U*v8y4y-8p<#$@H3-^<aP<#HOIy923R-4F)|y&Odk#;Y4_+NMvb0RQv%xrX
zC3vkr!9OW@y<mI2G<f6b_C{Us_vY>I?ZKP<+nZ-xPhYHfG<f@-wR9`dG=wM&@1aSD
zknZ^<UEJ8--8PlakuCb<7mAcJIieqy`0;CznG3dZdM<{a@{jUL42<F>-DmW{M5IQ1
zk<E{T^u8wv?QVhO6G5f|czh7N{Y>fAWBxwA!BrJZpUo!GPRc506Nxyokep~2$HyUf
ziR!2Gqc$V}Haz1(uMVR})!#jKs!5^v0&pVywvmp)R*1{_qkkPok;5%_r|wJV_HYXQ
zIvHnpQ<J>hb|Oxyh9{1TgPdhKT`d@#8DmS|mSC%hXm8LN5|;J-4p(-sTRo`A-<D0A
z4EgY573}t$+lz~ue6ETN=VjN)8+a5Lw<r+`v+K=PGwcxT6qrH-!Xz5-GM!H{IYbZq
z#jy{*?vQWv47L=S0K^KT67=&7PrHp%XS&@|MVVz%Z!#3K-@JSG*Q~zU4|kR@Q8N{_
zpsPR?2nzuh7}dGy^s&*f3<8KJI#(52a_<IS)tj@53I2(E85RM=*0*$IV@$u^Un<n8
zJu=R^sVsl4+PLAE7-{4$&l(;RmH3FQBv&&i<d-R6cNZ1jY3sxsvO-M1xs7(-yAhS6
z9|+pz<MZcB<hOTMasmmJ(;?TxnnTL4_HoztiK-KEr$|*P@1JMKRc~6iU+5$jtYX8t
zO^jfrzp5RTt1Oc@WQ7AaQ-(rx<?C;>w(GX8>r(4NVN>rWO=v#|#M3SH#|ytdNf1WS
zdu@EkKJyE2#sm`wN#o-Y^@=xiK5tAIOk_ov%QLU{M_BMMFU>?)GMP?pL|E-XzWs}^
zX8mo=bInHhx6LVZRQ|WE>MNkaMn%R1Hcb}->4{apW_fC!4xu;Pr`N3dA@}ezKNu_a
zI@hkWd)D=u1*_o#g(SPFIQcYpfW2C47wyU!==8CkH+51E-_9=%@~WN-iOM~vU?^k&
z(!U`IY#7lkys|uJxB&TaM+9fg-IJq^v>q(Me@wV=?hpRQsNTfST^J6|Vq)z2$7+Pv
z%Ncyl(UR90CpFS8W=|&p?oh{f<Y<8f)C`ps@}y!zX_vq4qB+aKd~Fxzw?lY&weplq
zMn0jJg&wTuU-#j5cJ5T-+|pdeqASbrIdRu`yCUhY%jdcPoQD49@%_=^4nxuk(CT-Z
z;J2D2b#lA@BYK6F_)7(aMmfIE)rsj^;O;B%Gx(IAgum!ng9So|0KNn(>-e)W?wWX~
zhT8J{Bq*ezV?pH0(M*xUqqw_NI^`~UFkLI*7^{Q&(x(Mp-NL?zZnNiYMDxU*9+qYV
zYxRrfR^sE(on>lcQ|C$_ZC~*(uK`v5GT4Hp>PHDkfdR(z^ZJ_xLexEmcl&4=PaL|`
zPI-t1>b_`#lbYVWbl>kGp}l~&$tY?_e-l9i+|Oy>_v4x`3y<i!V19shFc9Tz|LjBM
zBJLP*8JwA5dQwi#csu|PEtUD#@sFD>q<wdQ*Fa}VQa7FcT+8pGl-mAsdICpPYZkWR
z0^PGgkAmlx25%(+9i&<MzMePoVo=Af%}sNYcKzMG70{R}9NfKgszxvL4+P)v7uG%?
z3Lho3QSaArJ=TX^e#ROuNVtMkh#zUe`f)HR%*P8O2fR{*1Waf3V$*p!4H@|iCYR|I
zIotSBWzMn&C@ss2!#lNq#rbW<DR&CjrPRiyV$Da0lJ3pU^L$!<L>dEzL6z}|y8Kfu
z931BKyzY|UUFj~^^Xi6N?BAy?OUg9QB@yxEH_rP__!_Jvi3eDYqanV7ww0flgJ1Xe
z&yi$eEA}m2jI8i2Ff+OxPc}GgImC}n!W)FtXcvW6pYIA1AK7ZSO(#0t#`O9kS0?#N
z%h8x>^tkr%I5v91?0CX1deZrL(kpr@;CL!L`s3e`Ko3FNe26fneT|NptA=jYve~6I
zZa5~6f30PjW-_bYKHKy5<HxS-|ALg_<b|g}Wsax#fX5-RbQfTT#0@g~k$;9l{MkxT
z!{QFP@-WvZN6Ag353OhAvfh`g!7%$U07VQ~`Czr&QCnDmMe?q0Ghj3Sq@VhnXN=ib
zyX5m+f)B9QP7=3fHE7%4-+g<-AinwG0-Sg;AEX%pf&+jEN+`I{$!_Jl4{ow;kAj5L
zi=V>!0^<c=s3}R{;FWZSs2j1di2W4(ot^|GELL;BW6kbiz?N1NQ{t8n$U>l7^xzS7
zZD0SkyDLB{jyY+>?|%DX4J5D%sz>Z|dg79}7`W9aA)dx*!kUr4_PM<AnUbdW)NXM5
zoKLc4S7halJ*9ry0=#sb#nON*%O1+*k%~l7%%RRoAYq(}4w$})X#O-}1Nd~^Y)hWt
zw0Z8`HN8S);teEZHJ+?^5xIxo-DdfCoU$~+RsH0`3%O2SdCpAS+eY1iS3AL9-bT|@
zQnf$&#~Rnr?x@3Y^4ab60rd6J^8DexLxq~x{~QTQ0i!sO%id#iHDF95i85t-rd3~~
zXleiO@s$XyY#XBrv_UJD|0;WvqJrm8<j<Hb%sHkRzlZNbWglq>SD*<m6`=|8uP?bQ
zG{(Fyki9H==k`I|fIy@hO}Disj#)5$@0<?i_jkIwtJhD&S^)+)6;l&fDhmXFG*(+5
z`_(ZEB}A+%q}OSUu0Ki8vZ07v^wcy#*zzZ%W5ZGpr0z%Wq$oX%nbNGt4gHh!xK#*|
z?3EudEE{lNPls4x#A9P0S`zLw_wAuiReo)+WVTC|aYF2oNiT0Aap^%!wFiY0DPPMq
zi0*>ZvdxF>&4SD(oCd7xJ$b__l82XT6tm9?Hph2I_KK%LBSEnyDS+#)Oso$m?T6To
zc<q*u3UB<%!|VN3yVSoYZ58Rmj21tw4_aAci{iFTE3@$eERzpy=usDJ4T4nd5mtQX
zyBiGnZC4*gvER@6=o)?eYLIC!<%)C}sKykQP&F!n9U@8e6B14c0eA0<rm<xJHO#U1
zmH1Vp#g5VsE<aG`FYS_dr-PR9IFTHg`l6QSp@lKc$Lezl{RVYhZ+<$OxZOEsAUNN8
zdjaBdBsX_?7HCJw!>&m^$XiVAIRE_Yxb=XAnv<uq`q`Pl4vVv7=>wTqj0zYD#3*Fa
z79Rj1eKmPFKEs}e-mv5Z-IT&?kiaZ{5b7Hf;!(M3)fG-Ik&AV1zA~1qceA8iz{$5b
z*RwWA{o&gaq0O3%t{shhp-$Pl7>piOomJV}FDDw*8&MKSTSsy<$;d8Vl<327^OGYy
zY&VD75jrnhX!#_B55>N>*Ht3<2+<|@<5riBQ%*&)NSQ4B*N73vp82TS8Qoa5#e>W6
zt0p`_FEwdTc>W~FvAJ`RxvvOj&N|*;;XtN58+qu>=kN9VqKSZfeq7Z^m2C{+iSxc4
zEuXX0y7nsS-#Q=5m(_&w+BAijFgMZTUz0tX2KOmJ`as{`T^q#yeUYcALRdV_OR=IW
zBaJPBFrXS~$QY560H@nGOldFSR17IoaB~#9Hj<eU5ojDsiy|9BDXp=`5)y}?60AyN
z8xVmOV|M8k>p%S*EI7%^IS7-dr=rmEHsO=vZnn|Zb34#@P7GM$vzlFD3{;Y0YECp%
z-_Ic6OCa^)yyNv$j+o`sgm6gD&9%03k<;BgaU<O~hgCb$AzpmxEa@tNlA1&IyUC7o
zr9sV<2V0sro$G-ae6^KEXMP4DJ`$|t2MKs=fif?O70BX^M`FRnacTD6K&d^B0>i58
zh1jOdhvvKF_#oCb$cF8lfK@%()mm%WI1-l;;vy*u)yebKTc;syB%b8Z6~l3n>r^N9
z6|vVxCTIA<AjlzX+B5rA6@zcgvuLDd!(z9pfTwUo2$?M`ycd$x${2)V5)O(=<`22X
z8Q5FGMQ?)zp6;al4x#5P-|sn_FUaK=)g#u0Ulkr$&j_y=7yAy4Jy!(dith$VEW;`K
zqfac!fga*{Ro`&38>)vQkD{mQxL_MprZYM?wkUvpR>+W1TcNg;CzL3uli8)BCR6Ut
zX=W}}n!?|Nc%(VGZh2#7oJIhdmi=0{PI9s@6P-j15g5-o<)lYT@IAG;yJ7D!Eis!@
zCSyOjaj|J;GU<6ce=VW2y2a_@%LjbVuUz=<^l9eeYudY0PyXHSF6&MXZ@%!oxH0+N
z^<c)~eY}MX7vf5|5Ex%u#mi;HRuvBSNd2sdWKWCj<Zqa#;3Lvh1=FV7G@ZpqVeLX6
z(MEl|S(E@5$@<4^&t){Q<PmmHi_6@s<vFj%KaeBqTNj{Q(;jk(JKbVbOeZGwa>d7$
zikE$SoItPmC<C)R@G}ChS5zoilBXgwa-nzDJpK&xOhXf^>^%=nyYv`cBtM>owCGyG
zy{%PV^W(zyZ39WjD)O?|Il5M>6E3L7{>S$jue<@guM8R1h}4lUv)r1ki(CGydK#5(
z$H$!%*Gb1lUrRdAc{^u1GVdK?%ACubEB3ZEmZk$`QAm<)qHc~EBZQNCeN7BmJ6CeL
zWGr{x8E_Q-D+?@&H@(mMwQvq?Saq5XLjlebsPp|Z4f^?sDL%s52{>tq|AP8L|Dnqv
z|0mS9|9>`-zXrdKDAz@1-*+h(FSb<uk9@2@n>lh!#ca#|7TQP3N(m8-{gMB6Y?cSt
z9*aBlWiqlHeaXFaW1F5U)P2fGdHhwW21&Y|T9|!@OC}+3!H%Ub*RYC{%~}unZblLL
z$fx~EEx`-La)t2|e^`PqZ<+MlC^A3L<hbT5@aeX;$_qY2+k^8$Gg57YE9LRE$KBoP
za{jo02>E+6oUkzs8eM|n*eU9lGxb%Ezwy9-v|nBJ?79OImE*ZgHDWZp!-p*jDxT+C
zK)hhjoQ(s21Z~YEXn*ZVQ?=x^-0{<gt0r8aCX4a1@X&`VcFmY4{0v2G1(%4NF+3$(
z?xYJkmO%9TOjN65dCYGvNvC7-)mv+LGMe_Mb=1o`1tQdk-2F^X20l!Oov0sZ&E5%2
z`JICJ5>edC4_K4$^G#rwuu+~yWoaV!`9)%Npyhn!m%1>2fY>1LyvUno_H)7Q-M7j;
z&c+4sy>okgzS8Wiqo-r`v)qM+nIMPJn9D<UaJ?upX?8v7v1O!u+H!jx$Orv(@a4~*
z0JHiv4hTytP235YByZlt54~|<(QorT{1K~+nam48)tUVkw?XMCLQ`;RP|l3Nt(v+!
z4U0FdxC0)tkAcP5eUdfmu!&G!`Zny=2AXQ)Ef3_mQ-&K2NQnnTenAP=aH#0F;DMdL
z*Nu<5>?PBXnoh6BjrZGx@BdhO|L*TDjnX;Pa4W&D%;y;gYmbk4gtR0x7Zs{?vM_Mo
z98qw!7{IVomjwV*wzasB&8v6UG8X55touo<3AKMK7+O<P`py4+jX&TG)%@iAj^rZr
z2PRpxGU&T+PuCQQjS(c|Js`+f$_CvEhf9k<eBi*TCrtt#yvP#P`<f*q-+E^lqoD9-
z`-q*!F$(%Ix^V`0P~%uW0)7!9Nx`u7W7xzYLKCr2a6f;%0sEpi2L>s|>Hm}54g<Au
zg4;Mj3kslOL2@boDSlX7N=)xEYelN4L>#9#ZnBrn$GC)}k<Qdw>C?|L=^RtmrV-XQ
z>tc1uKR*|Q8h2Piu6E@qe$vPU3ud<HaIu<jN#NtGYb+3}SZCgN(TXac%90gzOGH+g
zKd%J)e95^QMbTzo0ZSXiYLK|AKQBZ|bG7ZLzxQzN1Jzua&&r1HT-gz<U9gn8U0Hj$
zy|n{=A!M2<ENIB%s>qi~@_8x`oQ`LHSt(d2Bghh-yzOjY)4~P=wyG7Ddmf5EX$HcJ
ztz1;^B#O8rxn205JKvv$1U+<F&bn}tl6q&YDo`v~Zz`we{|V;#sY(ibHkqEIPWW8b
z0wxvmZk`j}#&t4(LvKk)B%XB#;CNR&3Or};#q98d*w$KIknNDW>y0O6-;2=FwWEJe
zXX`{;RALq?Wek<UEt_pCo0}zDI41j$TdvGj?s1mfvoX0B-10AN<zHvXzZsK%U-t~a
zh$xcT#1{tOhJx4qWw6BUJ5qv*oC-hA%cvN{Z^sFTB&(`>IM;Z{{tKHkZ10w1euuMu
z+}n*7P<nUAM`Ee&1tpd$Bq2(XRh{c>%kk33#5ed>oxS-~=>1h>^9R))8dy#6r7|J}
z4l-bmkOq)(>Jn{S<PxKJ4{mrIJFfkWgyB@!Q=af}<h^Z&+u3S=`zZ?BB;I!Z)D%eR
zHwCO=n{SnjrmCX;OU39FMPm4i>iOh<XM8*d&HX@JR1&AqDMr?V^OR+pY#>Z(V}~zt
z8fM4`o3px(3#ZfZfaKXdOZdSG01ClBlTw;Dj7$zjpXKIdvy-@PN6(hCHe$O6p3wUJ
zl<}0Fw>%%e=y6ZQ%Od9`qQSuMS%4@shyXXd(K{ax^ZW?Huy41C{fYAd0bGGtVKlc)
zoGp^O`dBF4A|$6jE7W8+Xy@l}YoMB%n0@t6_iIi##4wXk5DmmdszL}=C{)McrW7wu
zgN!S%@lOH$WCMYlX3BDbs4ocUwD|Ij2fNG&W?>97Hc?~$L1X%tMMf1ywyu{l@xm#t
zfMj6t+3c*^MAxuoN4k%5OPtz>xpNqE$#4e{vmo8>u2|`TI30jB(8V7iYVSSK%FI5V
zCe6=XT_8o+u~wUGsWl0CT(jR2Q?Jsd{Sa#(*JzLuYcL5LTab?M6&;@NDlPx<bAh9g
z3awa55QQv7mOPLPyD)1H&OYOq#;`7=EcyD`ns<)<K|k9nosW6j{Xnd#vc1|-#GB#m
z&EZEXxTSdeJtwCXd4&Y)pKUcWv7(HnaI*c^6R7GA4Z0In@2Ji*{PV*5$`JeKAx?)+
zZ-CtS{NojVA|^NPn%<x2ZAehzllV0g*TiecCbet@nrHF!75gt{uf~)x)Qqhf<$!)x
z8pWfaVeuw{eGoF<8?0oRspzhmGV;YBro7no=R(<?YO9C4&h*92oc<z|){$h^8=%<3
zWG^EYE0&5Yx-AHP`KMnu&hG16a1)DnHTiwKe^%!5)QgKFLQu1bleqR)5cb{63vGiQ
zg6&?&$jiG+alG-y$+3iWgfm19=7bZdDKR<|UJ9r!Hl|=~8txRGH4x?v5f}|P_SZP_
z;Heka%uZCTpC>CAbOfUKKMcdpoA`ycTb<AlsXJDPFALIOgWzd8&eJTtoq1RTPT9Sl
z<zJ`znQzp1UiYp=#a#uh>%0Nlc02sRp@+%b{1T$?o++!9iHLaWZ#;s{Jm&wopfi>h
z#RnGs6~N2CC|dPO1q85vLD>4MaP}{XV(O`p;~}}`zaPZ=Eb&SV{^em-i~7w1xFdXP
z{<3Q>3EbXAP$gk#-^~h1ePfgjsHAf^P7T+=TOq00;1QMJA>Qzck1_r{8?(vZoZhhO
zXY20C%nA@+)=Dioyl4fu&<5O44+U0ldck%ZX)eVSaW?)oc4YQrwP%_ezmS0%l8P|W
z^?li^xu?2YxfNbYB211gosuyv%gV@_^h8b^01yXY21Wn?6q>+p^mG6n06@S19T@z-
zdEu0O_uqA^|Hilae}Ak0zpUebxpIcntyZ7|Fmx^;k<&e=0gu2id`)p15yB(q(pyu~
zk;o}|z6f7i+LZ!R^`GmlE$hh;$0oy{P$7NUD7&XFeRYopa?xJ>MNf9!-o+dSE>7g{
z`F^;scY}rPJa6UbLwus>g@Ss&@kf^V=hM#fJ)L|^c<ee^@XG(=bJwP1HZ%UJPcQs>
z9$YAF2%LQt{HZ_9OrZMnYdq_}!`H8szP`UhPcN#_h+gO*^GLc@H7YOlq)TESC^V_8
z4BS)o`cl=T`t8F5EKyXkS#5p1!a|@$JNMe9mggSt(=Bc_1buAu`Bwe*uwnaaOWYy5
z<?Y7M#+x?sR&QH0_r496VIQ7(tM&W))Jw0g)yI1qOYOH(XdG7W_M`Sz+REHsygR<}
zcm3-?hSkF>VcRE-Z1U<=`m~d^efkWQDyT%FctdB0qs9veH(ue3yYcXyLq%d*{D&)`
zR;B%GA3eOG>=F=?=)L`tB-DdS&*aa~FS^-OoeI~ufL?qVZ_klrYN`&XhCw~>l3iCC
z;OCL%q&-ZK1RNk<u2Q!1Dq^?n;$@JT#<mBZcU^+lAKi0r7myAEM^_F?q!mA@I8|0I
zK~ZxfJRg*U0BaMUZv;Aw<oEJ%eCCR^Iuy9VyEh;g3Se;P0S{2@8F}Lkj|Tw0&Qd$Z
zpR2OGsBU`w@dNVA!u3lk32cA|ieR7htK8>2*Yz(n9ET{-l64VnG*V)xm)>t9DrJP1
zU9EZ4{oB8amLpmA-0O~M)ypnp)~))Xx@&I92NQI$%9Q*4T^8vpJd8lcz7+K7$$rPM
z#;?ssL+Cj`eeHfsCOrUbRSs0U?NZ0t-A`P?2bD&0vd_4sZ`b9X>%c)aItr6mG0M@J
zVOL>H*s9t}_|?tO9$F(I$hwfX7Gie-wZ%z#-L+eKuiIv~q(K8qB&f_4dw9ucZK0T~
z|D4Yp)+gaJq1LCl&Pi4al?L8iQEOnSGhb>vBnLjEyHpL>RuSz0^I?VOQxm>Hf2J?z
zURrr2BS#Mi?(7?VQ0blkF#!=Uo&2*nKbk=vKTxj;0c!kgj3n#1OQ3Fh1!kn`lhdiW
z%AIvXl2i;c2m`N$s<MbveyvnWx#34C$Ygf<pFPRDZyDV7%IPqwfpzcxZ8dyLzZG6?
zt37<`Siw$cnT`3SIrjnc#<rH<Adoco&RZPf062@My7^1zP~#xCZRe=oF$g2AnSd=j
zXG7<_oOu`l0+9Ya8LmG=mnTfQ(vR$nxil**{?JZX#b+2%`Y&ppYadM00~Zl_QD7o}
zA%&g`Kr{CheZL%+N#A69vCQwN3wG5D4$SPNdQlfy0ZgaP{%M4~LRlElTBQH8gh4_)
z9-a`&%N15Hz$xl^y?J(^iMFxB5yZQ|`eVoBem_H}G~;NJ_3cu3oUi(&KuZHhL2_!U
z!98Ejrzj6<yNbVb!UbSO$h_G!i!zaPYpvYR<h$wEJu(jg#mv<+-D6dZWG+^q2NF5m
z>257`X^arrXZw3}{nfe+w76rzq-9Blz6bQdGNLZx?PsNzAQDJVl^JnEK8PIy5JDsl
z?WCwsFt`|KGV~S9Sap#R)@QS=bT1p>_Fy!TnY&-8^j3~sk~;;ZuAE~_VE`Cw1%l0Y
za=LRo)gH@QnEnnne?g5G8Rmup`^oZKc{Zdxb;%dHS5x(Dd}XS0<)6UfV{{xl_p{p5
zEbR@9*Ls<2NC`9^B~j0;%-a?kSIQGY=9ghBIpv13eIv12yv6Tp%dathWbKOrQFHp}
zPgVK?cBf?D+k!4~2izRI{8-X2xxt5^5dr5pv)s5FiHu%xXaKdT6fEz1*5R>@#7Kma
z0K>Xv;`yOc?z@`y3KxWuYZ^;W8&L)ejPuDh{EGe_aLrvtfm6Lz;dE8zk2NgUW(~*L
z^9z@)`bfN%4IHE~N_syhBY#lo=*2m2|2trBEaEA@A_#a!+v(<OZ2p*_H&Jt2vC1<}
zV)Xk6UO2&k#3w$Q;+5)ILn|Mw`eK|ype~gCf~-Th3?QwUaU#)I;GRXHN;-b>?9UqE
zZZ6FUI9gRH&&(J|+n+_Yh<m*9*=(Rt#4d|kEPtbkQFU0he0~7;Gvir8vh+=RuxzVm
zwRgUWSYW+*)aLRHvn-HAHy5u*eYRX}<r(pDgr3FnvQQ!wbbYp_v4~I#X`WBg=eae#
z8SG$6+&L4&lsXMky4SjMMImLXB-IT{6sn&v*G%_F1?YT3`Y=73tzG#yTqN5`B_<kG
z9%*4Ac}?9#Aqh5vi!05IU8Y7gQGplT=>PuhRvE5MyLNkCB*VN-kv$bpJX)0CIp{UE
ztn)2OS^8Zx-lLlymi=gON!Gckf0?c>>wr7`vBbfEGvmv=4(J>Vd(eNmJFMWNxsQ5T
z6L_eD1@gan=J{XN*#9ps{NEf@{*MB0_n!qm<^N%Uw-*1u6!?4_me^CV@qbr=2ThxK
zE5*LMeGEF0Zw#65AaQZH25QuLbtemB?<h2dEf3@<TYU-Ce0h1eK%01?&>XQgUT%}&
z8l?3qVCt!J#~sBtk(;yip&z~|HqL);djEZqLC-~Fcd0v@$<4J$GwfS`p;?Tc?td2e
zj>!S%*IRS*ZxU&=Gw*Z`_P&f~I9z?8`|tP8Y)_2Rd%fes*Q}n2={)K1v*WdNCfAOn
zUNIrVHcjT^S^ABPg`oZd9&v2v35W!KU&;cRu)gBz_ks{UM3Kl^g8*rGo(z53{>yY(
zr)6m)<*oYtVf4ijvT4#sHLpRG`=G$I`U#BqkcywVKAXC=|MEkcrd<AVrtL-3mAhh=
z`H${8pI@CNS)JXp(xYvv`sUL*ZE;GM3rs7N{Y^dC@`F$4EmD1JO~2(Y0KH=BG~SMd
z1ov&3Zx6h`Jn<+=;ok5oqp}OhmbHZ@KJt2iDqB}6@E<Rg0SKOh;ttffJ{^U7aWirX
z{ya=@+zHK##lNivmL&V8s-yIrBli_#t`noY)H51^CsF82jmEQ@T+sKxmm`s~iZ93I
zo_sAg7s<}h4@U6~=8?<!hV?f|p**nNWvr#s%?)Iix_4HnNO6~r-1^&&v;lU(bE7J&
z&3|m=LR!II0qA!OUsn*X9*DF{oXK8q_Y``zGU|zrkN$2Y3Pf?Ih}a@Mq31g44G7Oq
zAXE61G+@M30lw!0QA~$U^(uc188=s?a<0mAB|<yW&{624z*nV?n;hLhd7OWWvarbW
z3A}^F?@1Fci!Zs%^u>(Yv?!vCEp=qiO2f<4b5#t(<>@PF6f0t;daWJXV-fg;-X7)4
zNVCOhT><$F>do!*LQ83bWjt^DCIqd-PECb1Gqim+3~;MmQL{bs`qqta#o_5Ck1ldt
zWGLS2MZn-g*4gYSYk=pBoFWJU6IQGS0XhnGer%cwdM^d~Nqhzti<)&y9EwSNdl~At
znhaL8nn@C=>Mh%R&wh;6Oq;LUU1o!AonY1=DLu>8XZJT>{CKy&(Bt;|Rp~cgv-}dy
z1pNKOK*=7*#6uIls5%Cfbwd_+RUV1t;)KXRd6_LxD_^Rz^nxi}NbP)51B*<;-7Tzu
z4P8z?GL9$eu2(n;O85_h)wLs{um^hn+s3&LUh*(mtp(x0FRh2!?+_bB4+_vQTqz#K
zWk!3H4u7?KlJD#nJb@^t6yvsBm-=4sSN}{@s<<-vZ%9I;ZAAC>7j=SuF|aEXn4srd
z^9T#^O3nLBTJs<EE=LE5;X+*XHmw;^Q#N;g&?80Y4|)vWkpmc6d-PTf$j@9#_<iaa
z9X&lNjQ`-+d_9fkHo-X;@|f8J{KxZ3LmBS7TZfSLnAQG7q&-mF7Mrd~vhc6Xh+Nyb
z*H*Hu&u=50Dk71s36*9~bnNh493z)!3n2*;Nh6$Xr*UQ`ZWy~H{z-&#q@Rsc<Tnli
zl5Fv-#+2V-G|9NQP1(~N%24t*SHjxU<?WkpfqIAX&bg~1WO#Yj(@(TF5uGUB8Du%;
zw`_0x>Ui<@vahR+2G#P#K7!s^AP07Xii<lWes69th_=h}fFvn4l5Ggi4NH%iFq8>v
zG||(5<zN(+M7;{`@~(AdJ1uwI>*kdXMI~2Y=R0A7L$b;lvJ<7;zbj1^7A6`lKtH;a
zz-byi{!d%qgw7*nmiA4w;c{JseIp))F(WsMfZ#lXyOJBm<k`RY?6%Ifz>jMwFTmke
z@uE4p_CBL3e@YXwg851!MNsZcw;bB)m@@az)91S{Ja>qtlX1g;)kFK<(^xHgV#{fq
ze<zfu=2!yiU&&xTN>^gNu_gO)zh~)WXH<o+8q$I4ksiFpU`WeJ5;|8RVC`pPR?a?o
z=AH#3P_>gX^lz$COZT+E7tVQWnXxO*;JjROIj*|Xiz-U=@LOk-CI2mn?)lkhiFXe1
z=U*2!68^%WyO;ds6+{&3^H}Ak0LRN()Z1`|L0wj1!fwQCqto<o{q6y`cA-D5$7e(0
zmC8m;+TzSp2+4UHIUHU(4T?d%a`%Tb$@h^v=F>2owYXr$6BN;0{y7o-Gc>IT4ss1j
zW<o_uq{SS?%RKMxVa_~sh6Xg6!+nD@ZkR8xupf}mzm*r3C}GCK;#=lr<KgfH$RvYt
za<es7xLo`JdSam{dm$eFbB9UOzNFQU{a((KKp(LDK5giVYfa%^(zN7P*1+eSVVS=J
zmvv_kKHOpdrFft9oBQr?VVGq^37^O}Bkkr<>Vt6NVW5Z(Yr%&+Mzu$((N`?OPXitv
z?By(vB#IjqjFuX|dMb9`|Kf{gr)%5wRp++Woj&{<Z)`aGTppM0did{SD|<stqQ$1C
z@Zof?WkX%=(5A2U;ir-GhWf`ATmH_6Gt<Kj4X=l`f^Qwp&a=O6?6KGmD?FTAvwYqB
zacDd8&Ee;r^w%xlEPmXaJ^Zpi{QBMBp&xe+55EE&jjc?UJMqFt^AM}Xc7fp?vi8ve
zXGUY^>EtTe`DhXLp|Shi@NW98qa|^Urd|`vpIL=R%P5*vQ@_LT&wFo<R?rzugO@G$
z3TBU1H9j;AUmxCkaCr0$!_hpFX!)!3rLYBM=^-lnT|~L|rFHX+f8&Mhzn_@B-5@+}
zo_g`_+Ou1_-(5HkKfYoAQ=9U3(@*Bj%!hZ8FW=~H1!f%1&a(e)8hE=M_4v(~AMdW0
z3v|AXJ$H4UNol{G=VXU$rL!pTV!vDUWH&uSXIVz+px^G~=e-X)tLI)E42PfWJ>bw?
zGg10CmVNT8!b*36b?k4;-tq6qjJMx?zW$r(xbvs+weHr{7l(6uCx72?y!(;x^>C3s
zX8-8$%|>p<zg1P*!ElD&ug6Nq8+NpRQy=vHynb=KeeS{U-gA1i-3+CZoow3ClGXcz
ztp^+d`}D`(Ghz<Dam4(4_VwiFhs2+6ex!NqzlWWig94Qo6|<n3?o3G|tnT4A7Is*O
zoRAv8B8MsV>|*rI3t(bvw2)t1QZB~;8rr84-99343eL~viAuzPv#C*%5I|~LfUY%8
zr7=!TgQ!j*el_9TmpT8;oo`*0qk5SqY~C>BI@?7IricEzCdljHZ^YLnb!|e7?ONnq
ztFqC&(zkC=&06-qRG$8w2*sEBW{(qWTN7NPV(g|#{;&kUX>vf+?Zckv{u)RcCNYx2
zGhL$t>@Ym5XA1^^Yv>y*)(p6L$agBc%uoA#2QUsm!D)>Sak0d6u;^bkEb6rauf(J0
zFkssq>|VX@Dg(#Rh*8|@r2A_e4>gjq8k3(+Cs*a&obMr9C$a&YjJup1^xkZK?QH5L
zY@U~sBIc1vUQ7VMdik66%nlj<mvjY{GK`o0;LcMZ&TJc^zbnAu>Lnd&4K|60oTix4
zYSKQhkw4(mhoaI~^V0j*PJf%k0}K-mV=#pQ`&&naVZd3|Hx62rI_6y^VT_0K9Ge*S
zU#$|e;!x;{tNH>Z`8CIv5NP*^Q(P{`5+~codA1enxYbu2%i?TP)~q;j$cwe)hmYCr
zQ56odlP0b+M2$$0Fkt;(uFDwqC2Mw&Z<GRUJqvA`CHW~^=OA0R@8%jo=02y2&zSxD
z327=1lizhiBWuZs_%tKxg;;CwKr5S14NqZggc<DG3WiC?gURuNOrN_7#)kQtA=}e&
z_3woApij&Weld65S-s;~vuk7u0p4bkMz~|{^(X1Uf_YfkyjaaV(~s$Dc~G1+W6K_g
zVg<wOn8Yrpq=WU1ta66`!QFcWHQoPfyFVZy0YVZWC?F+NK|ujgLJv)<5I~Wp^eQ5t
zA|OiWp@$x-p*NL)NEbsdq97_=9}pA})KFA<c6|P8?Spq_?}K;N%--{!aSWLupZj}V
z_Z@p&JVe^1o&pv^opT%%OBy8N2jKQtP~aFxyT7viyiVtBkHC4hQnG5A)Aa?U_)R=p
z1yvypn%OB6LI!|SGEqZLY$UQOWj<qgH-DtHV3<E~#SrcQ0F(1lf2i^4zYs(U&lEVQ
z`<IhhC95SJs~zFQ<4DDA(;xsEdM7gJiZYue4zleewLw)NVWpOw&eQ@{yHwk3tkidT
zG!c1ymzoq4LcVDvrSF{_S*^y$kU4Y7NFNf9U9nRfX(k6j)RleFqi%_1tHUYD@aZQV
z2dcb-Yu=@bS%b!$t}{Ai-JGs-Oh>4EhW+>eE8rv60YI>mlxzdX&Xid9n9@S|RngUg
z*R8=a)d^)-&`@rfp+GrKwVYBFrQ6B@AR(ZHJ55yZg)VTOKb&FIcvZ%DlkYg=KrWV9
zkH@4MgTa2|S>`7z^l5N~ARgN<$|${)d{Nmm{5f|vqq$Y9)Sx*wUd3(Ca*hcUC((_I
zqrX+{#1&5+M{H%<MJ*%d@SJYrE&;fZSt3uYC(qnGLTm!|qZ|fcAz#nu#ZS8EA#2{R
zB4*FmeEq-y;PQ{isue!hiPGhrp}}1$1+|#d=6kjM#^r;dk5w>8<Q}{JSh}+TJ3xUt
z$63L?NG%X~@K!~y@QfNnw(o4fP|KZFN{k@{p^}!SvLNFZ2rbr;D%gqfOJ@VHP-1A^
zYBM=84*^f8OKqzI_Uo8$gr(a(hy;KawBT(TSdRwFZiWEV;sza%u~p4>A9zE$6u{=4
z;1?g5zkW6p{L_=CeN64TK8QFb<_iF&V``V~mJJOTnCvB7vU{vRuYIhX|7_H|9FoUs
ziLSF>M#Q1PHF-fjRO}*F>XW>A)E45(^b_S@5KAY>F0vA!Mwhs;>r+|b+lW<p^b?wq
zJ`wU$8K$8C_0WOZn;>@QVcb{hSk~&EdscDfRRx@&BquZnwl_OorM#a^jQRs}9D}~Z
za@@s&9D#&H14J-TS`Tm>q(k&ix!h!|95#^J8fx^YU^gVI8?Chmo$Cvf7LwU&##zgD
zPTxdA@WIyJV`AxgAaDOmzD~6-;-47~b4Jkc2i>d@XlMjlAA>pVO~W4&+Ew#A2HO+H
z*htFtoR=nHI$V$y{Jrfl2v!t&O;75}D$f;v=;AC@%e9AxWF@shgf>Kr1tqws*@5&a
z&~<q@cW<SpHgu7u5ld~pXCL&Ij~ACkZY$-fAU5xtP+1?pO#aq<E*L(JgbmMMD>i@+
z_`{ZgV6h<B3Lfs(9kM~@oT4d}59!B25EEmh;rrdM61z_objz+^*QsvC?>0hUJ>Vqj
z1=F5$4n3H#o_#V^Zaw(ee$Q$3ULA*Cy|CWV$qv<yhhNwl)eCxX2fdaZJ(oLrEz}=s
zhV?G^b4vO4UQg<EI_Pr|?2q`<ZLQwt>Cktzpx?Kn-!G}Zfe-oLk2s8b9}EOD*)TJ@
zJQ;z0B0yxuqP3&I5GnO4WN}X{lHb_DaAQF)kyqTKql&9^AO)?GFlV^AXqX|XTcKXf
zUH&Rt-gel*XzPn<{(0B09o0OQqea*d_K!wf07Je`mD2agtRAm0Db*?5Ypi)!Yx%^Z
z&p4}g;;DU4q|pBJ$CJ-oURUUwWIvf{y0O?@xZm`2wmtCs*FKY+x=)?=8G-&mGsW?-
zZnzZO_;P@2|KC8rqh-_eRl0&z=ZMPf<=1}${nuL*r=H47Jl4sfcfU<Ob!{$s-FCru
zrupWpiRAnDe*DwPmN;RGOB7TroTl!Y7F3)tAdpN%Gz+&EG0Etg)1Rfe3*u9fB<aJ1
zYijp?zOJrq?$p%S|MMds62AX!=KPJ{KWFc`U4GLPM&Dr!+{9e5fT=Mxog3i|V^pc3
zU#x;(Y5fF_i{9evcZWW#7+Jn7&!iJ+h-Y%p2SxH)f=jf-(n-Z}$2x<Zla#u>7L#y&
z&2JUy>stuCCbMB8Dq@MpEtO7k$v{mAt}dRl>jfF47F{0TmfNMWJj!wiy%?*Yb#yx^
zrGAIcP*}5b6Q{EKxYQz-UXbf?|C*oCa$(Td>QXPoqA&4^ucXCS6lXvyM!ZWqi=z^D
zg4~R-q1QP_hUmir5uC*uCtM4_))*zb_idW1VX|jD{URHAobba10!H`%GM$Soc{ytV
z%5V4LoB88spMq=Z$VWatl-^H-WyAiRm3}cz9~Yds#*t12iZPL7#>W!DG^+XKJ!&Ae
zaK(sAZok)Rx#)A7+i>dp%lAh@qk*bEUO=GRs)Igaf41$QXzgb`z2Y=YkJ@yXklF&s
z7i-xoT><02_r@6D$4~t-!3P8LMzTSuG=jn$Y?0L}5Stfo8+Q=-`h1t5%N4G~_4Fi#
z)-h(I%dzu;NeZhtn{^8KWeh<v3h+<XdXhcUueBxkAw?@t{)?e(BTh)@iit8O^_>M>
zc75`CoRHF#E5bBQ02<gcFTcB^+pBFE-3m6z0H9Fa9aS-KWIcw?vZO`Rlk3aezZ{<?
zZ+5h0!pnZM>k>&jw3NvE7JF2heaQScMDIPJdXe`v$_jTDC*a1JzN=KqwNi3iyX{!M
zr(e)I(<{GyS2ue}@CEu9&v~vQkRjA66U+YGz7{kXYvl`SVF!Nl(GlmrV84x66drAP
zUnOJn-kg5&n5Fup0q<K={0dAQrb_oO&6H;o;4#INGT#jUaZl)D&6L4Su@U)=odLxk
z16l{XG`zcsQ?=Jsklg_k#a<tkTD1WN1a+=>=ora|Nr0n$yA0Z-nImUnp)y{@LYk)r
zn>V?h#`|htS;O{V8MIX(gSHwn`N#`RmmT8m;?f#t<)cG&&fHe;4+>KK*iJMgN~x3v
z;nY8WFXPjf;?|Ea+>I(BD`dH2zX_+>Woac;WCI{VfN^}jRwNS;jP*eocg1W1xQ6fo
z*y#``?ld`FJ$#)B$PJA<mZ_NZTU4L_sKr1aQ?VGug-mpLCn8a7+3Jp_rID28CC-Hy
zy))$k76%8^hvm~;K=LBHxY(0GFKc!$GuF+CAOO5icyTB$0CNW8Kg(lIx%YAddn~%F
zOlTtqXJL93ST`vRF=SLMSY!gtmcQC(zFB+QwZ=o|ahmFB%Z>a`u*&mmWkZHoA0Eg0
zZegeeSPbJY0y9pOWOjp8nvRGxCR~>-7^iboD4e-JTgxsj|CQl=c%lCEMq8!7)f9^s
z#WwmU2pW|enWbDx&&iAh<c8lSgf?cNKf0|8Po_v0O9<^7LN397BdpONvk2sZmR$tV
zf8CX_0Ge|Vxgf5GF5}Wv1(|2KA)|ii1_sjJo`sdLhGv@N&zq)lSFh+*CA_OyOgd%V
z8r^q)r-$!e1gNYCa$Ke*Ku{0E{#@EE=E5G!u}edsvO5u(s-F~2z21Tx&-$DMJlBRZ
zCB#~E6XAx*EPx#phe-+q-@*>3iF{m2l$f>vE-RL0WyyMo=TGy0Jj1CO8KXZqMi6C2
zb8Yio>2XU>6plAzj~OvI%Nj{`q(^IWJ_nGhZd0!w@QEX1k<p^e_3APOw?v);cwVVY
zM3)~^?lu7=+Rs%M1}pR2=hGKy;gaz2`PD8e8YwVLjvdg}<#fZbaJPnVZeC~VuzhhV
ztXb7Df)7bK+R40P!z2?(VX@q1>|2dfHN(ePa*qrl0x8@Y3ct^|PGuBrCq!rjW2Qtl
z@I4kmq6<N!w<7KURa!zFk!*SAnY15=jD&2z?&Zs+{r6owRZJF9qf`CYrv(Lp_k_eH
zq!Ht_6*q@_g3c1>gz$@|KecF#D(ecwo=U^c`E$O%smlpz?N$Ub5jT6gxHOG*xd><&
zI;0d)I~AAz?esq>Ud;4iLuSzTyZ{OJ-al`)Z=NffHl>_EfZ&9cl-R4f(HLwu*Gt!g
z6My%7<lmfkpt1;`^2)mKo=L@Cn?+~_=lVKyW|aKnPE~-Z58w9?CunG2_0>X8>#f!g
zl!wnB|0+OQESf)RI`gYatMJD4wKm2%++^iZC=6=NoajwC-;nd&$K!PSbo16-<}Wme
zyrKQn%QwHDN4&my({=X!DEwZ-z<1w3UHiE&X3gu&)c-H<{S${PhURVKId8Tr)DBm1
zscr8o&3@I`AAYkLZJTI*^XuvT!!;*F`_zEh?}q%tbuaVwnaMZ5o7xY*`=_?gEt~ym
zn?3vyJlg*0&znD;`-eaAh>m%P`A+wVBO1ZH<MZ*+oqn~W4Pt7?(n<5(Vf&*^(rCw5
z<<Z?Y_m8&7h!-mc=6mD$N845AFTPzJ-J57X`b9~7vF>TUKQnvuyJhsnk9(v0pZ1Ub
zP!XN9IP-(gC+Ita=AD~4qX%Er=(}U7o!gb>hu`e!dsCyGzne!7f83`t4#=1EodNTs
z&3yX7iuudE$<d?V?es%h>dS*=bNb#a{b*<O<<Xx}`q4g}4)EcbF?f&-o>A=yCE?jy
z@USVy`Vbz;7r~8*K-okb3y$C;MF_M+2u?)^??j;aA~oYwB}ka?+mVt`PbpHQbW7x!
zsz~{%NQJ>jrJYE{;HdMAtDh8wX^GOTio#AsX%9x}?L_GWN9!|sWk}J6EzxFG(YUE-
zi^1s2JJFWGF|ye)$D3m8reYj+Vy-g^+Ay&$HnDEOu^yyYua;P!saW5gSU<ive@tAU
zP28Q}xFAwoa7!GcjVf%#$;vC{3LhalI3~)A5J@7$1QU{~2n2cyA!Uj{#KfoC#HV}3
zr;*|_gX1+m#})0wJ>p9sV-iYi63T)TDo6=c|GD>f5^4tH^9b?zn8XH~#1_NEw&28e
zuf$GLVh3N+%c(>vCMjnnq5mAB-XD4wU>opv9zwDO5uq>e=$m}-I(cXW!10M1yCe^r
zw}HL#=VXdbqWpXBue79mn@U;VN%`TG(g$^4$Fp)Pup25OlzWhY6u4<Hr!^I6Kc=F^
z2SXHtX|74^Dyh9w#O^^NVwK1tlZI4D;|fXB^h!y@GGZ6bRhs%qW(!8xF-Anp$}8R_
z#(o(yOQFD5sUlZ_OYRsLKxFM7<EW*Noj=W-s?MLPv74dEpNUn;)UnNUC8QC1z`#7G
zW+39#JJ>D~afK>j$RI<DISpIbEwPZJdGRfrIRzixjRxa+CD<h)sN8JB>g;3F*}S{i
zzHB)+RC4^LiC<d;mrJD`v7ioD&d*<*{^l3{vAcM|9<)aHJnp~p3qXdEU!=OKE9Iuw
zMq1musvA5%w*a8~-;q*x5os#9dbW8NL-Hze^Qv0&YFZQgciGSHVrnL2_R*@cV2K9+
z5HKJ0(Gpa{EOGI&TwoJy4#&z`&t~XCyaT9w6aycT5R7O7<_yvQjp(s07%<8Sw9R4M
zzMrNG=Z6YE(_0H?y;D{x>h_d0J1QqJkdyG?0uwjFA`tB9#Ywp9Y!S)n3Igiom6M5(
zI21Z7o&-<|l3KxfXvhl+#~lE$pHJPNeq>2|#5A0DY$oq`UNK)=vB0;K8GblO8#(t&
z{15HI=!!Ve33<#TY6t+-E=Jn0N=0Cijx@|R+AR`5yV_=dkCJoVMP#7CcjqtDkq97x
z(F|HD?p=!6D_mSHTVgA>6ezMVF1Ok%GxbW@rivJIL7kTnT$12S8aw}@;+S|W6OnxU
z*!ehHC4GRi)&-`AWo2duZqCC7oY;Az?X<?N-=H;K(=H^gR`|2a1R7Tg4HqZmRVC5e
zs#0dET%bA372r2$7>hRK4^o1WCV>7;69`|T%t3b9Jgi?`3-zh&#3)X{AFSy@L@uyZ
zKSz-5KtBPMuK1c7c8SN|YOW-dQ}=4SL(6-7%KHT#lL$#QTNO;q*6iXJkEone0Q$$S
zoD0FqN8+Mb+oRWLjVCT-B_q}*H0(94oIYQq=kE*(P||<*q;~U3sz4p_RNb~}-EY;*
z+taS$c-340c;FvZ1^|iv(Olx-R33>$NwCJb(qX*nexos+QYu?z`6gbK#B%A}u(<Xn
zrFW)&!0z$jUcK;%1__P^t;i&P9*$4OAV+G<HYH~i9~<7tKJLn{M<*K0`KWJD!Fqty
zkv!SHh4Gh%jf+=aB};#=d8WSh?AJ`=pS?!26VGvLvA0&C`uJ>Yw@8#z<dHwrJ~z4t
z2eLyN)8{#PGi9rW#dpWx-ENSJn}}hyDC2I{?*Mw0BKTxpyk}S3_cYkgzCrv(Lxft3
zn0*WWM$2<T(qq-iQY^<co@Yml!IJ;v0Mv%u$k=T><hB3@1uqzachY~yN|1+MWi)M~
zHShZ5+VUZM<trHpfanD47ff6E{kCeg=a%j5ZL{qiC!XKQg*oDp4uBRg4&!DV`18?>
z10O01twf!KS%BlP*PIozU#&(mj(bsdAlbjxs6q9`hx;u{r&|anEngBlzvg#VWu$DN
zIlIuXasS%!+i+Sf416JOiLut=59hX48o<L>=5ufJA!hKLTeOz|lFD+>-nmbO3w9xs
z^48Q+@0+9@59<^d=@fM6`nKP7;-HqtG}h=<f~0!4v~1VkdtW_4be#yhpQbR^g*NRu
z8`g87phvi%{4^|<amD-fCTI!v$~p9E`1Trx_2O-M)E@Vk9`s`7dM#mnW^)84rvE?S
z2mfXWON<Ob{r~U`p-2XtTzHD_`Jm{#T+V{gJO&h~S)l5@HeP$<Wv7PPpP!$4-qB%x
z%~tK<M+Y|(7yl*(D+3Xy9Lo9Bw!g<-TS#1Ggb9;MR;JQUG!L}@3&~(~2*)XcQxsBD
zS~QAB)lk&ovoq+GCY?IqtTtlAWvD3_x|1q%!N~biJl%gM>6pT=ahJGrv8AlRQ(vYE
zQ!qbPTvM?gd=jZT$98R_uU+99)mlJu4=5fTu&{AmA!dB~8v&SS228mdXU<TW1}<2n
zyIhsGFm_2ev#z(A9OEy>?->&~!N?GfzsapEy#G0OJ{8jUR#b*1=55ItK(@PBiuL^X
z=d(&i3U9R5q7{&Qv~?@9ONyUdaa^<hhOA`0Y~yd$x+OkkH5C=#zSUrU(^ayL{W&O2
z!ba=GvjG%xv%b|8>ZF-NFd0&9`H~z50g8HE47lR?dS1)>$;VV^;Z(kvi(eAj<hU>i
zx;<$1TJyyB#t(Z#l|}1M*Pgb~hG+abwuTdrKL%;{I4j&CZ;h&D!x@x;o}dIc*`A`r
z7KWGCgNCIT1~|&TAwg3GS%ydm-BRjFsCGAHaN+C~m{LIBx$6f$wL1;#ina1}g129t
zdkK5n9yG$^p1JRD5`A)os~aV$=2|duYNdVwbz<cSGgVEEu6s$vLiP6h=cd&=qw4z+
z-0rG%jSXg*MS|e-p_W#MsULpMnB1EE)zA57?$+e@-yhwpeTI{EVf0d>kf7xj7>Fwv
za7Igmdx}xen_b0c^yif2#Vozv!sEbqPmS^RH$pi9`+{b;KuqT|b9HOIPsLi9_9-E+
zDX(PJUO$^P-Tw;(@_dRP<GHJuD-Zsn^~X29Nh^xV3xrCZzDv>S0s!;OQt23zae%yQ
zt~epPnyQ@rHRAedoapya;c=^58ovW)KWcuu)ARG;!Ouzam)<)y0f@L_hNI97lIc(1
zOhdQ_Gi&-f8OhG;vc^_1X+9xNX_a&#t*IyBmPD?^P0{4j&|YrZ?%y+8#K@2s$yPtF
zHIHwfdQJ&C^Iiz%xzjCRH*l@z9N6*>SNTo#KKA=)JzhEin|SQ|Nx5uns!)NYY`D#5
z?;}Etm77v(y7w*KLK{7S0%mr1m2&tBKNwX`LY>O?edv|>NZ@<U#S2e29^TA+SN-Ez
zN;;RsW%?NN#qs*oJ7Y^oK^L%&O91A>b7s+nseucM2I@)ZNL>QfP#kjysw-xhrr78V
zQ#R@`4NcF;TbI!J(S!(hU^&%=MXWw%j+a*9)O~jX!j&Rc9d0Z7fZ}B=RT5pbUJj8p
z-5OZV{0!T^d?U0~efSLht%<TKPs**NQl(O(*Pdopr*}SIjKhk8W%we6cku(*!7)ZJ
zbJ;z**FYWPbUw!Gitbs#oi+WP>iG9^#v@b>bLd_0_%eRE8Zhv9tTs$9s^~W(Dc;>R
zvQSmZMBen$)0VLiZsp)n%O40SaZ4zrh#4<=z0+D*c-CIl<#<FMP#?>HE0N@UEJ_9%
zp8kIIq?bu}K-XM-o;F@E+?Y4kD21!z|CbpE(czWLzFhKPti(;9k&}&WK*){GmXfCo
z1mI$={MW=oAk}?Z^BY{s4pFyeaV%H8dyDHd8%t2hYxZAM-?q-&6{Cswh^jKh>k=1a
zEb%O2f?RAxPh+70_-JwY-<hkcVw`>$ai11EL>>0D{wUbjE$!6%Hv)I7$iHMgwG#8%
zj;(6eVZLiwa!j^2O*Gae%UyH7adn(N!RF&O$K!WXZRS&KcJs?$PrPbX?7z<$5H(c&
z0<N_?OkK!ndgK1%Zsh6HDhI{b(1tTX5o&Wk0{^skgU{YwMt$7W`O`6asqW6}+UviW
z!4)bobzzGp|Lo2*ckaBXd${%LpToW8m%vdSp2c*Y=|l?^s!56D8JP#GwR9mLQliC8
z7uf7cU16^%gHyxKJRvqcLaZBc%Icqy88*Grn)L~nMm}@5WBTM`HxjR^FY>*!>Bn@|
zr`#M_6xhcMXs~Xk-cw&f^Vkj=YBr=Nk1UC)*$y6035=<f{c_4`ci8%kVs`W6FK2G=
zzPb)SM;ZwGN9yGCh{?miywS%VO6{%m*Zv;Q3MNgLl}D%F+)cS%^z*T&`hM#u-mIPk
zx%5?sXKyUlOsVAfla-6-_THuxDL#q_OEMlS=4xdK_pMxsSiTb8csIpLCT&K9w#(N&
zc8Bae2Lt$AK7<!-7n#qcc#tBIf%3hUp0BN68g-pm;~U&`y5!5bFEG`ea=tF{g|F@D
z{ppb(H1gI0p{lo7$l@7mQf6Sx4VcX=ZuK{wEi(Dy*(hivL8(k`UAYVi0_?_OGwlx>
zL(t{?Yaa41{&Btq%-eqiMw_WDW{zG_m}C0$%;#6Sl0oCn7Z>qql5dz&_3!Wqsij~5
zbOby|>GNm3&M)^1G#0ISN~Wdh%E5&>3hat6boqU<ScYCO;ZIXfI)5<>Y24Djolj?3
zmO!+<iFvwN@>6}lC3fH;rT&>R)BNKjCor%Mh=lKO0bkeZ-dCp-g}rB51D#>!8ospR
z4xo`Bk(Ou{C)CeNtwMT+ETQrjni|FV7@r!*#}9t@I`<!p=>4I|%+5Qj0zmYUe5Jg{
zduRkPLRitP19i+%?4`z$$SMY6)yf6CMex;{u~E?Iwn%dI?-7ys%^*g#ll_y#g++wp
z&X+}SFhDI@i^yL36N_j$b$j;v7zaw(i@k}LpLA(_5Dg3}#aW_MaPX?;Rw3d+XLZr9
zr*RK9|JhgwF6ePg<T#>hF)JLDu6<f*HK6Y@$$2;<yO1h<EL`(6ge@~LOLuBVrMO5Q
z&4h<~vD^ckB!}L?X8gqs7tVX>`t9h$9V=0H$QRT~Vct02bbs}UF-fyDzwpV3oh(Ew
z0HomDNjSY+Fx!TH#4*B!L;&a`bK1M11a}Z}JCO<mzk$+7vw(;fjPJ+(2>D;^Cz{Vm
z5`^3Ek;0_t2hGtu6%VHXRU$-$MmwFd741M3-S8KGWCfaVay4JU2xhBZgF^Kg+`=L>
z2#b7$6BE12SOUb{A#%J#L$YqG2nBM2c_5|pY_V6_Bo*OT(O{o3wo=@cla&t%UJr#V
zu|r6Xb-D$_CW{a(4GtZQ1LouCEI=_Cd=+3bzeCui%H>bRKe7?au!(=rg4hLE^@*~=
z>B0IqzXVL;szKt~)x_IU9$Q%CFj8_C%Vx@j7ytl2yf9fl+CCGue?F<}j`~di7$&Lf
z(ZHXG!Yf-4FYzF^<BsOhkkeU~uXNZ}0^p1by8>rSmp4zt3)85q45p!T3*iwLWV{lw
z0@#etdo6jTtW>3VWk3zISr=%CO1)G%Km^c4P)N|CP0BK#<k1SE2>=k$7Z?Ys)8$mt
zmNbFs=w>JfD1xn)2m$a=sYT^rB4Q2zoGEZR*}7WK^`S0ABv!i`1qCtYgCrG`yyr#9
zIidP!FmOd|6nC50%x(!>lw_7cZzH<UV0WyTkV{|_iO_lv@q#hOj91XdM>Y~Nji*IT
zS4HOn!84f%^Bo^K%WTiwY#LK`*tu-R9UNr^lT26d$7O}aCpJ&zSR1)UTXW<*2N$AE
zuA)=7auAG2p^tJNv;f<`>*tPi9AU~G+G3x!mgj&1vwY`&d#YP7BMz1kI=5jK&p7n_
zBN+R<fD?zsZNGC<X@c>>KYK|D)_Ik=d9u(THC=3b?%kvL{4zG6BK|^Ebsn8);!6}>
z002i?@-v2r%3pZkp0$gFe`-RQOGEZ4>DEL${Fs;$9dhbIQ#xb74_wbl$Hu;*T6;h+
zLgTRlzoW0<iyTM>ORJ)9qv9E$$M;oHspTBT^m7_f`eC)fx9UeZHez#uurm{6$yl=Q
z^GA~0hzLIOLNvITniD=<%<`=`jLo|km!6r9x*`v^aDf>{g#Y1XEEB>lbZ`HOQ$IR(
zUWddsjS1S0fg1)~uuzl*i10I^p<X<ZYbyxQ#x09YJyw;%aAosIF%MmV^B4D0n^YWu
zX%g*xxjs8!kRYrIf-tUMmX)&i-W3f)#ZugeY%xw+1O%kbA*omrPIL8dQ<nU!bXWDE
z<yeu3A_nfG2OvX5j}Z#3#E!RuS<WFR={=%#Xk<DdVh>glRD`u`7L$wvU814S2y&KV
zRkh%1H#VT3>@sIrGu~fyZnFwNR-a3U?~5woK_$#J6-{=v%)?&0PU&|k=T7aFtZ>2i
zE6WedOYG%|HI?A2c6f_!cmx2103jCL_)UFHKO%gk3w{#|`WmJ10C)O_Cu%zw3XHLu
zjKi9vqr3$Cr|?#nl=U{0ygso%HP8mJ+D7ff)NP)xqa&aG&a=uVqk!j6LH8@3#S>m5
z8S}oddWx(w@%HU_&6`dflrik(X4eh8rZ>RRh-9_&uV1qT`B0z{w9_a1l$*D~&RAAw
z9ILZaj_VaUcRX9s7}kd_kH|WObg^VK!Y2ueaWWUP-ob&qks9RS+Qx4lab$1`64vj;
z{!tGq=u-_)o@sCZzEpDWF4>;L<?@Z^ny;)M>NOhWSGU+T8P<A6S!bGaMX2y1M)Od3
zAP-<|HdAO;%TQ;IK*i%9b5!xZ;>k;%S5E};jwtNR7GMH^cx?;nXS))CgL@p$XRQq?
zlIOiT#;#iG6_?+VINKs?2r4}1n22us^`R9Yw<IyPfx(R57YF!6dscgN3kk7GgLM;O
zYx6EEPOu>?+;^h=Wxg}U8@2{?_+La!Q8-QeoLBuhF;`sH{W-7QZSqL;{OJ#4Bn0mh
z8%IyP(4+r(A$I{TJKZsPztcOvbK*qEvm4GMGo7^4?VBeMo1PpS_g`+Bw6ENMxE|lM
zw*T_z1hw`zY!nB(ORL`psQag>-(FEyNH6z(bt02qq8>*(dZO+U;XEB(ya(=_riq`(
zoUw~ki4LmNLDv99s;`VHGS@A8&^<oUC8*w`=+L9Y$Pi4Om?%B!b3K{|Jy^kB9d$-I
zV(-PUUc-W3<Bnd_xn8q_UYuZ`rF!3Ghd%4DKAVC*yN*7GxxVWMeNKY?F6#Ym4*ecs
z{aywAJ{|qObNzk?{r-Xjf$9Ty90r2I27(I)LOTY+<^~=f4B!O^9|*GHOa~*w1_=d&
z3EUlnNppQ&Kws+IV7mH{i{O8u2LCV4!T+HB`EL|KXG9SUnuUQgFhM26kU$q>C{)07
zkbyJAAb5>^q4l4838=GnBZCZ_Az9>n!aB5JX^<#ko@YA5z!|d6UK#dfd-ipNq;zX$
zWQc(?6l&dNzhnc#qX7N?5uD+lS}YHObH*xQu`h++B*m1!;mZK&q~k<EYajz>P)URf
zO;eoSMI#<r7luAxo1j>{^3d47`+chM_ACQuX#V+$N`Lq!B*u)C<~8UL^p3T0E0eKz
z8mgJ6>Yc1V^WNxoV;dGj6bzuZatputwQ!~@@#N3Jj$eOPM(;m5`?9n5pIfU=Tg^Wm
zF_u=|qA>Mc#!J3}<$)wx{ZNR6zV77Unk?G&QU8_Z1}$hdR^an<!ujt9??hB<ZMvK-
zx=~YxVqjK(ml&7wozVojPA}KEodxJ(in5=(h<^0gR;rdRe8^b)s-cxc+7ZsR&&24A
zN?FF)A#FD)S_p^%N{r=vN!0@PETs?h8uXsl<&GR6){|B}^t|>;rSfk@dN1b$PvlnW
zYOrG7X#KGX1dEA&6_2whB@mKN`1&)fhuX2M70tO8F35${i+0Ba#X?IK?HiX^5UG!{
zee5L$Kn?nQdA(a+0=(AraS=hEZDpgBmLSPBt;U(W8;_`Y#^36?JIg(F;$f@RSR%5T
zLwjjw%Z!hCT4xD!PJbWH$DFqDMr*181xd>b&b5%GH$Gb~9Oy&=X;HZ2gG76j!jkCv
z8|6B!U!U@SzFcFSJ42P>YQHRd=$(e*67!fc2yaLA#nv89*H84&w;M9$d5_l{$=$Ju
zFjSmD^~72RsL!z3#)57qUwDBYzariuea`f3y<y-7(dW`uFg3noryIMXr^Q@OsCK7~
zYFvD>WiDv_*7w|-4EZcJ*$7m<;n_KCY2pW)8?T>FUNw4f`wgJP{VL6Z%aTJ%U*>fq
z%1l>dn-UB$Y5c_dm40HR)PT!PKm5p_$taH%Op%a~7y4n2Mt*;VQ9l}M7)jp{WXEUG
zos7~@;i;>s^7{N`G0G+Mp4V7QTt;XPDF1Z3QOeTdD8|EjVMHEuI1W3`R#>$6jWum+
z^z54?HZ`t(@wx+Sw@K@s{Lv|;6s=EuWokcx9r(dIbCj0<PJLAGA89aq$@>Lx|Aujd
z7ejv}45Pe;?SImHgsl9g&Vtp%Lf@Z1%1rg*i?Q0LUA9&g6$^UId~7B7y>#AY(otq9
zUzd%6X2ZQqXQdUs7kqJ5n?cH*wvzByEf-Y;TH;<@E03hNII${EWd?3nVr2vuEPQvW
z!k7Fn8$=Yt=;uiq7%1Bbb5XqrS?6wU)weM?iG>^eSK~ylu>{8wAQ{k&MA2&t9N($J
ze6ib!nRnib*g=K)nP_maFXCLleB`^$fXslyQio%2nZL|vvqoex;eQ&so+dOVDRCF`
z)rcEDJBr}+;bOY>P2iD49|W&!$adlmdJ6r(%TO<H5gon>(SR}j=U(IniUr+e-suxB
z9UDg%Nf;{5pGUeMun2pXx$O=PyfXSR9%E_PUt0E|=Li((N(b-?d%AH-+Xk*TwWYYS
z17kdoG2wUR^{s;5K2k!7y6@WLUXgD~DDNoI3YKQBm}2TEl|6S~ANf^%YAln(T{_{C
zgdN`nZ90cDr4*Zc|Fi0B^~eJ%53r1TYav^Y2$Gj9K4<5po2EEc(ZM4#-^<_!sE?e~
zEfUbLJq@*da>5zwj9X}KjqJ2|(dVLO$!N>70HZU%i&-i_hedD9$qK-w2p|>uh@UB~
zr?2U8>qgFL0}5rvhFw7|c<3)e4m@0fMa<r==<NMfNtyXbL)MW=t3$32QKom%{WoHD
z9^+KM9_l^;JJ(u}PhI)IxfGbn0>~2Fimv(ns%u-Sv3X<zVswEeKbIz=6fMvkeoR1x
zG*RMH_f+`Uf=mc;oqn{DPze$j*+oa9kX6)bVhJ`Vm|d8CDSqTAirc)}@%JE(Y(rPq
zKdvfK?H7M6CCrU*>uHRfm79IfgUo=_7u0`Tjyz#6AS{VEjE_Z$K{>;I1eHy^J`==Y
z*}2+JgvQ#Wj}WjLD&-O#M=h(^Cbv%)nvBqvG*)po7Xx);5SOl<p3X4^2|b%}ktfnn
zVZyeN3e1QP>>X8WwmM1uHk5tT(!FzZ!YKlVNn_r9H;FA-AmD7MAZx<fk+V`b)q*0;
z>Kk>{m;bwQ7nfKl7<h`S^5D~FU!~%>CUjismy26ArW64CG?WQprDYzqd}VG-#8XyM
z;Lw6aD9-_<SfH!-h2R?AVS$pvobo!;`7}8JpYq^wPrTJpTn3YqyR4QHUF6)MvCd*x
zmQr2o>;1t%%RMADtiZMmf9x5#r=T>v+?gvyFZ%oEv{%=WLwxU0vCpo5UI{0{fj&~B
z`5{-**~W-tN3;ReJ)8I8uqb2{_PpqOG|>|&bL<LHN0zXi#6NpRBn6{~Nzg+?Qlbot
zpwSl+%C108<STXC#E3V`zgo1|WdDl;TroyAYn~SGZ*S5ie@8g1<xPG#Hh4avHvuIw
zJ11+s;bJQN{y~Abkl4(CSh`N^-R)(;4GOw;&GP3_@1pSD1$N+;bV=BIQ5mT0*U}_s
zl=71O!cTO~)qP*G8;St4q=EVtos;LdL)#l{MK!tulH=l{$oJ_z;J!)cjc_MHU`WGc
z<XK5z<g<g%<|=v-D{lu<Av4QStSUDohS=ZMyCN7Tgi602-1;BARnvQ_Ck7f3H?e-A
zKGL{v%>Kv=UaqE7SOM)u^a##T7rr$M(J1%7_yMd_wTx|^v;FKN!&{olEWS@X2>9Lj
zjt597i7{YK<$94X^j&PPUAskIBKDE}M`C!#(rKPPjG&mh-beNsacAWo-_9*VCbHZV
zHCE~ASB{`T-4|6QtZLE4vTl?pfrn?d9lE->3jIN1gY%y!UUu4aDw~|yd&f#X@$&az
z<pZN-O|{{VnY*h+>f4p0>5Kve)3>9Vzsf~IzGR^Ag`92lKdD+rOI!W?!}Av-#@-HW
zwmTlsv>q<8O<ert6Mi)NQtOX+$uGXo+H`=#*yNU4QdSB;LLG5<cCUvVI}c6j*_)6Y
z@n~oGApV$5#HZu<o#u%B$_OD0USu#r7!#S#1xN))N|Pc_wM5EJMV{G-l;?|5#6&6C
zL|q7u!jPg=TcXsbq8PRESiWc-OthX&^u^$4LsGPHOSI`!wAoHHjxWX%6LZ-n#yU90
zh7@Dh65}uxbA2a<u{Y;}iFLDy^$3pjBE|Z&#QG9q(<xDmX7E5v+#Q>^px`*e9S*gs
zxZtU{hdXh2K0+jh5N$(<4JHssgoGAC(i9<uzC$4L#iwK9Gi~CtgX2l0_`H_*f~okT
zop>@|LJ20J%qF2CIH8J^P}7p|cq-xPP6CB5u>q6VXp`6!oY+E2Y->sEm`d#2Nu=^6
zbz_oxZIb$flLkpi!!1c8Q%P@jlE(Ow$1%z8ZIUN~lcz|@GcCz;Q^}uplIQtSK4Vgr
zY*M}kr>u}tzO|&RPo@0WNulwjZemimZBl;+r|yta_gYd9rc#e~QUQJ<vkDPpOJofp
zLUW1itwh)~5xz@A@~3gDq@irnj)kQ0<)#U=rU_1`3Gb$%`P0Qz(j{!ur9#rBbJGhA
z13;7M?2|TUhtd@o(t>S<qIZT8JtRXlH$z<|Lo+@@t2IM=Is<E)spFlg7m{h5n`x?&
zX%?Sp-kNDKor$x}vh>cn9Fk?1o8_RAbv-`Iu{Fy)SJh2M(mf>GBRAWtHQQ%8+jlqH
zk3Yv><u5gGCnP5*Hz&9?Cv-X|Y&Yj2|6g|@(v}n*LW<2LMe}E0W6MsF$xfXn5mj>2
zZF7@Ca?|2-Gplp6b90MYb01CTl2!6bZ1W0KG6}hP2@ITJI`8pr-c$a3ib{TiZGK}&
zep7CKOKZNDQC=l~-pkc|s!Bn(Z9#=m!GL!`S8f4AUw9K=Fj`$O=B?JzD)C=n34k^I
z%-KUL?4uR-(2+$e@;Uz{;-DRG8^J%@!eo|CRkyMMIPbQQM<0x`*JwpQRc`L?KHA|Y
z1FB?ZJ8~U=;TaV~(iSRkUg^-n%qak79>OWrjk3pbTJpmzMbVu`Z2IKDcQS=yKDjqM
zcwdech$fVXCy-_HO61x~&Lm|0kqLGLICm-kiZxV;zrxLYDb^0PFPigzOExL;uBW%N
zdjP=O3HE}*p2wq_@b|flgSD-^#T)BJWXr>|<pUKHShB}(xmRd~PhLeETj>V!hWm`j
zoIh#?mnp!@isH$vMT759MHokS5c#UL49wEWNjbVa5L;k&<@Q;6O-YJC)+ic$W3x(u
zy)@gnI%lRT&#t<#I{&XjgO+3jMuz&?f2|rP*xg*j10|TN7)%fO-!ctWf&rtXbW51G
zmFjb!alTwDb46kU2N&&@*mvR_pmB^M<xC^X+prR!hKg?3JqefL1jZn~K2PS_o_v~l
zGCz}FU<b>3pZ=FhA!aaQoT2W_P-|(<C{#EzRG;#fO);uxV=61YgEO_gs7%K~H!hpH
zXR;}y;3pSR8GCjj0&pK9>L8|?ySCaa8<L+_T@YH&lV2~GSTC$r`yqsr;dd}(i=+##
z-noB;nM|vk3Hb((+>84PPyoqcPe*HoppnRl+B$aN@EZcv0CU|ufAOM31QrwkaP(l=
zBk<5sc7O!1+MQzqSzKQTeeULswM4Q8Gf<_m@P7oFY}A@u?3-%YO8=nkxMxI&L=+7h
zumq@2VzaK6E1{I{*9brjHoz%5h;RUi#G#{os%muQD2yMFrVlPy<>Ana{-{sH472kM
z?gC~2l1-?+UQD3cq={2tzcrVmP2_Z2o_(8^O6f&ywmMq)JB7RY>4@bv_B%s&S*29t
zKG!JOgT`<Y#EY!Dn`QsuR~!K#9xZW%KRYbnsE2FZrP&aWavt&J!<QxcupqjAlUqJw
z1qmN_f+^8C0C(V)hkfVFjn0+(o%#*c43@><UzSCDHoYDHbW1+#4N!iDpH+VhM#t7Y
z#+eFSxkM)yTP?8ZjEgXzHch@lQI>Euh=2}^-DFxS&cK<z!aXf(@9J%ZX*ID|oM;nM
zZxa{nmN=+q`u5k20gE-r^e{dn9g7!pW}Q$TAt;6+qcjV1ErDt7xBGf<bdSO88YQ&V
z8Ub9R?j|h!2GU2~<p^JHXD6YVbp2a?r^z1VYDeGdY@fs93JDlG5y+^+fo^;zeRo1R
z{+3>FLeVOkb8hS2{LB_<U#02|wWKtqmN+Jx1kBAd%p}w*4xKpT$^ZEFN#E`Px=e6<
z-k{+6pya_|g6xoMNX37g7!xt*uhtyHlkNI0?0Qc1sxUxZU4oJORkQbY8fPcty-i&>
zSc`j0-oZ-~&RD>Jx5j<*zxuwOI15|q>t27=t3Fc0);9F25;Y*y^gin^^@7%6P%nM$
zrgZzd)Nyz?8XQDK9Cp=dvMC>AAz=4Vtow*zH0<fPjo|?M;X*O`l-PwJXolcWt~cj0
z*8e$D?-y+7Xl@j^H1u0m?9c9h<1Y*ihQe8*TY29I5zG*ykc>diAjJP=`P{z{45eX>
zTB{nGy=wvr#zFFVWc2Mh0ve&UV{Fn-z;iNv8gv+7?K^U#O%XrFRw4hE(Uk0DKcbWT
zPEX_gP4DX0INku92YVc<=tM4qi!l*}t{oskU!nerFIfNRnL2fTj(3-hR&W=whlojk
zsM-X|*U7|00^B<0xurhFbTg|F?QG->el9;rmmRw=HyQS#ekbH#;{~bRVDzu?f>u?!
z|JQiY*2vj%;?y_I-a^7BoH&<|(--BM1pgGy0S)>ZGlkb?$_^)Gjq7q2Cm(;DeEMXP
zl05T7Xg2WD%)Qp0rkgWug|i(mW;-wC)Cm=a&W<z)%{{v|*LZVoxNvUd+R%#^*%Fft
zqldHaH9k&U``DW_H}ha_?#0|J`}dC@Kh7;YssEqHWd3*3tbem99J3Ach5yqrnQDD_
z?&!&Bs`i^X=SPMCvC1bku08wpZL0i6W#?h&pY=Iq2)*vKr+sJmQGZ0}-e1G!$3N}&
z^qP$of>vfZ+q;iv+~0YP;$i3OP<WoK)t_{g!O9$F4Tf)YEwe>&oHATsRBKE*#hh@N
z61DjhgEG|IKe&B8zJjlDL`$;B>$6tlphV1hxrUulhD`H5G5HJwnDL%Eurej+MH)!R
zsBe;-(*8NmFPvd6AXA=!JJVl$^$Kw@RV%|Qz)=0@fM>v>NcvflqSu*H&QPAG?#86Q
z=u8Bi$UtYD|3zn_S6|0Mq*fNPqP{j6le(Z8UM2BiE7HXRI(uHlX_l(hv6q=ChVglP
z@1cn=iEgIxH^~xx82V$LeykJqnYqgO@ATkQZGB%WG5%t(t!YKa#np5fdhfd%Syp>K
zvh_X35`8nXbif>;3_qqX<h$=(!}ylo7)WUGsb3tS|BECOyvOpP@<@ppd$K;d7A4v^
z=857;=DW?Q{OUb(d<2x)e^7o7lo3}3vmc%)-cq{1+RJI;pwI{R^xddu<NOav)0b#(
zTE_Ztjy5nZvCPzs6kS#k13#?CEQ+ZI!WvyQVab6-Xv?xKb6J>B211$r(9$)&8;&Yd
z7;51&7ZE&ZBALFA<~B%q74&3%()y}g)1<TGI$LP8yuK0XXsII;r9GZ;`&un|fFZz;
zn;8NOg?`8|V4_z?EWRtAU)0*7O`eo9`&)%!&>CP~(}rhMVSG~3_awc?@pzo$yCu74
z5mz!$qMR(qyZ7yQ^HYVjx^~Ubil9ux*T-3#U0u=ew=QDRs$i=U25e(daz=mtkHTNr
z#w;E@^cS|FKrd<Q3`CAq86My8)@;3lS_;WPmc7<o#%uh}Ebg#bRB)>k2|C!Wb)+9C
z#dn&L{@}gaw4(6CB29NRUVs3NEBN8T11=aq6*n!#v7cFI1=J74`6mdF(2n|3fGqq}
z$~#ued1OTh)K$f*I72QoJu$pYJV<_o_@7$h?h_T~^kL4*s?!^^I8B&~6TQP4#`#rT
zWSG_)GDRf@EV&B1Gu)>)e^HzT^(Un1e^HzQ28uIfk^C3M;gh(pua>7%WFhXW=OU`z
zeUTaLk{EV*?cwGY?`hLa74^Nh5AnT^&|59C)3(lt=qhHeux7*&T9Vs&M$cI`LRbys
zZhu4p{d2&@QMv9V%+@%6O0}M#<nSfRs9Ja_-7?<)U{t^XV@xjKW-JB<#HDvTYYI;5
zI_x#%P&?e^9}r&NSznA{UFg@ENfR${SQB}SHIy~(RXb?>50q2#C)M^YNJw6hAh=SW
z`a?#KJ;H`n!=|i9Y=vF4amwI1>#o6Q!KjEn*%QsyN*@i~w0cy;FD234*jzDJ>ZBVs
zk0JPHS{*J5S^JZ<oZe=dMjIVBl$pEQs01qwTM+cuVb{*)j=Sr^BJ=FBvE1Z_iL;*}
z=UT@_lNiiM?o49^M*q^}zkrSe*P5?EBQ!mhyGutwZq7h~F~Gp{%LTo&tIziym$*e{
z;Z!}BX84rrvDUU|zLZWLD%K*!?C~&rw0xRUfs{n-<zFd>NwqG%Trd?0f5fu9#mU2=
ztF1>{bq~POdUgW|@@b{!baGrrrWj<~%jLW`P^q<|fY>f$;WSvCrE}k?WA|H?t)t~@
z%@>bck&3#xVdF`np-rL%+{@3D%iN@JNe$B*k_E03zF)eVZ#BIa)O>y6%14Lj6fG<W
zzU<xWGKa4@_Sa&uC`x|HMU8s@S%kJTs3>($NfqiUqA1rb+N98WtWTVgQTJ<wMj)-p
zqjeECjea>OAzV?Sos0**hv58weiF>s{jt&FVoZ<^*W&->dcO8&LcTG$9>aMbDh^`h
z=gtv0$bzO0&cbi6aKurg#gC8{2$ny+FZAo<Pk;F5<iawqT*}5nCN)?7t>%8rj}N!*
zPc@s>1P`2sD-z=l7R4$tmCAnH4@-;|C6srEF2n|=l&>#o39H-*++m4`_H{esm^<kB
zLy`1iu2?!hWZ3hmV&3HAuNSOT=;|dOeG8UlmsQ{Gz6pABuISI>WzDU>)f!4<h}_Em
zipiuXm7SDZHMZItPc|DLpJVI-huFO<Wc^jCtnm$(VfVgD^Lfps*WWDLRX;q5{Z)Ha
zW6kEB-9$_0^QSjoui5RZPQGCMU3X7o-HFG3YEZMOA^G*Xi<;WBRCi;e+@<f{_U$uM
zolQ;8UVp!NzkPQ8sHvsrlApTriJ8&sL2aW?{O+{3f24UdcT8UTd2e*~)320!oj;%4
z3fpi02Uu?2@4rL~Jkc=^)oSVHc|(g)>sUaBW1iCwOWaVpx%po&$}&3>tnnZ81(sU|
za-IZWkuFOw=wD;yt2VrSP~wJ6|1^)tXl{|-9elko+Dg6AdAs0`!?HS}t?`9(T<LqU
zHxq+tmQVdTUrGv{GCjHdF6YxW_I@PPVTZK3X~7zxf3U_4X`kvb`(2;^V%_a{u)5t_
z<Ug%mf+`KYD)aSF8ODg1WTYCfWOlE8v2Zdp4x~C&JlDP!iUQldjqjd~f25|lq8X<?
zCT_kvWPh}gHE{4na`dN(L60=43IwDaX;}kQ`0~a82NO;?oFx1!Ti<x?@L=!#aw+_A
zv#O=wg7PJ10Og6$oQW|%SUB-=XYgLj%lcwA_aGhi=e}uLVW(gx&g-Dv$OGHuxI^x1
zBEWRcFZ%EHTO}#6T0+ZXPAX9g$;U)L{aDfy{82_>JMmUrun)tkd{D0xoFsm<z-Y_B
z!5>v{_Mka8213|LAsj6supK;{FCtGlg3~af#N%eMeCWexIA9F!%nh&vpq8i%=LW%m
zFU1Bu1$VF&@8B|g*w<uEtw<F058`SZ>cb+Vy#iI_WYfaHZIGCXXHWnKn{jexv_jC|
zaX6Dv-V~LA<1s_ZF_tzlmxE)bz6KZKKz;*aC;PyrTjG-pWQG>w3<X@hIGchj`+K~t
zv9WaEFFVunA9jX<AT-Mphz^$Mxa1soi!P*<#t}HCKI$sA$<1!(4<^#dM$uzp48Y{7
zJbOD;&yk2ndPQ*CL=?5eKbngFtJ-*lOt7k#9hdqK0z*BAtH^}aP9+@C5{{6GVND4k
z;&u!crji%?mxZB7-Uonirzl2(Ai4$LAcLK$7;2?aFwQoE_e`dfYBKY~rxI2Xc;Q8S
z<fZ45S|uFTHYqm$QEdn@%74P%UVRAQAwDS9H5$SP4elDV*d!=zd!_D3-w@J=JYv1r
zMME$&jrU_>wItSEeDEYvs7pS+3@M(EH@6&vsc*tETg>*+XRne?cl|A6{e@qk!EO}9
z4+xNgOemO2m)%V-TS-@7%P5!5_!b)>K=)F8g#`^tLiFY_4B+PtC4=GI5X3XXnljwc
zo&yUo00b1ft4<&lFBmfTBo4+`W`?0YgX8$z9dX1XMI%PivC+?#5eCu1+x6fGhDn5m
z`e8vK<di$DDR=+PrdTUu99A?9UBU9K&`K-hEG;KOh4kFzhT&~+{zX!N4Jcti?3I6L
zC={6VheOhoXWp@$yaG;Ui`zw?y~yGdhyytwA%6J0s$Ekh?~JF@c@&k52HT8!qx_#i
z2`c<jvhIH|6lXE%@05JKvHX|uC`p26J3stkhKkTm=IeQ7Ms-ClKIuI&&X9}aXg-UK
zhZ`2#I$O#ys1#@VxOB=n&kSm4Xl_w(YtgsqqV;Ld@6ZQEkq{7<xm0>YxWDi=8}K_9
zv9o()n@v`(L3!7kXh{*19EZ2KD#3FR?Iqx+dTDfjuq93-9SYd{i)|{ND!u??7)j4|
z^F;0P#eDLm>`J7KOFCmSstLl8pN)@@aA}*OvkAhAKAGX!XnUY^fegm5M>+q8DWRBM
zt&A=ClBF>i<cC%|qW;B7o*6`ck?~w3ic`BU%n_r0t`=RNDR<f{_dMx8BM+52&Oo?W
zqXB3XUStE8^cNYy=~oRX`Jbx1V=UJ3yMiHBQLr4&43%e(^cNgK%BA&*!CSra>G9Xr
zELlnOY*)%yx5mUuR(-5?i)-<0VZkM*R7=R;s*CeVO82U1LEblh@qXr))n)J>$n3}8
zP<6&$8)G#W6>3+Ql1$T}@_PtsR2e-gs}!AGEpC|z)H0MW2UX8kI7p2yC~h9+top>o
z_{oIb6E;Y~3UGc2?K7JP`&i@mkHFKjfy90a{G;)$Z9L~J`QdUue4N6WWn5EYSGOHn
zSCLRx-d5Kb`y`aLY*K)7q)K77r#RNs<(!O5^RC;Sp&TSokZTm!K84eea+{TM>;^@E
zkxjMNdl}R#FLTb2)p+b1xHuZ5PS>BzZ;+n#720nQ=6I%f;+azWO{V|(lk|VEIP!nz
zy8VBIIQ~6*g@6SXEX!Xcg9R%1UzO1U65SPM0y6CXT^W5m9suz5uKIw0oZtJw4fJ5L
zFeF8`I^C^5S=MT}!01`U>wL`ZZ*xP>Dn}n-qu7Ov8>`+XCO&??e-inz=9I3C^D`;h
zw7ivLEVDE-c6j0`=B18$=-3Ue1ebR;OFm6EMpAv7*-cMOI?YDj8T$6|Rdd}xFYzoK
z!lo@0=g6)De)Zo?o-P%jfnu(<hRxSmc;^xg?~pUgqsN`oWo`Ml=ichk9-2M)zi2uW
zf2RNVfzLLxF>LPJ=DwTzDrRmWlp{yEuaGko*=)ACZz1K(m1-m;6()p)Bs%1dlCLYd
zvY+4Y@%a4*pU30#cziyO_v`(9J)a%Vetn|(4BxkT(H5GXm&G)}<$v)kA&9hhc<0GP
z{nb_AI-B|PM^Sgf-k<oTPd%T0?hiUk5x(d7_xJd>Qbva2zqW&&)ejG^zJK-a`#3NK
zCL*QL>`ic@{oBzNtUv!A{So~As%$)|#FF`T-(?e)Dl!)i)G0ep;&BR`PZ8j_;S4aH
zlRyY({?>3eP%z4SZ<r3I6{34xh&E@agVHH7t&<VV5(9x3Glbk5Ebhle{h{7-2VZu+
zk2Qn9`10aI<)reL*mr$yn67-ZkCn04wJ(4>9291w71kWdzC}SRC4sf^m4QIbmJ5JI
zJWoL)2s!`uHYt#Q<aWX#w{<X}>(p8}44&h>xYftB8eG~SSBFKa9af}q7))0LmNuuB
z)F?%K=Bmw4+buV$wP{5Wk&U}@xVpx*pATvM4254!=OTCq)IOC-j_D<4z$U~0)<?fH
zI4JvQ2{@q9t(1OXOj#-G(7s8{MW__J`8+|}KhDusHz)V}?O4&67$(?;%jfZDzMZoU
zU=^HjY2yRj*3BQ+aG%B-|9f@3_v^nBlxS}NfZ=)3ygut7s+?y4v2G1;KAz$b1m+@@
z&$^z1ojnIqz;3=@2o_{;R_CR)MyZRg4nt8!tUs%nt%R^cFg>9tyar2Pa8MI(UyDft
zZg2$$&3D~-Z6W(;cfy)w#Zlnin8b+Q(J^<nh}Vk7SA$^-_4jwb+8wi`K16`odg3gQ
zzYS^=KC-0-<5M?0e$L)K^TNC3v&xH^+l=`3qL_K*zwIVrGk<dvs;?=;?9OI>%5NI|
zvb$8^9ConG8Y#o9l4kVb>4j|3o2%-sPz~5c0s>5}ECT<`)~qV&EfA5urS0(c%$MW%
zY8Ih?JHxX78LW*LJr3R}Y&hw9I?5t{{piO#?X-j4N$2Z{uV>ZxFHGrVPFu-j<)D}3
zu1^^u#K5r*V0}g_moui%`_>uC{AU}L9H45Jbi))<!|$7_SJ@mZSI6-qHc8;uEDNbm
zk3iemw}>z9gJmsxSZxC}ftHZlD>az+XRSP$EXLiryy^vd=;AaTOJtWlCM)BogX;5{
zO)j2Rz2yy!Zct%kw9L8xx;6tVRcFQ+R~$6%e6vMYd-Ecc2m567wo>skSv-099MI3c
zCXiiT5sO{Sp(W8X#O{mX6)(Q?h&ul1n_NY&G-{se1Z4sf+`mr&i{xG+!#PL}mK`Ld
z&I(dFV%HWm0P6W?w3S1(u91k6$Z*UdNV?jQu{V)CfUyR3rZ`BCH#$XP42R;3x`*i=
zBfH3ji2Axrz6BJ#5Sh&i=*sun3NMm(5sOG|QhMj_;v?kdx^)q~?Wdwjy(6WvT|8)A
zs|K4;x=C6T0>R9k@D5<B*+p{@fqoVmDG}Gl<l0BDHrV!}guZ;3IfDyeaNRj$SekF~
z`>eC2K)vmN{8IRzhi;}k^^Clzk5BQd?zLDJt1%heq8(_<Tvg7=ay0Zze8?CX%aM|)
z<@t-0H~~SC>dy;rk5sD(%P0q=<}vkPPQy?Zo40k<=LnNV5<!JXLCp_V2TBi^-!<6A
z4ryrX^m3ox#S3Qins?zVIpXJVM$?pZE!sS5jlxghBOQy<xhL5>PoY{dd81{~g>|0n
z4_yYVkVbESSNlP~*dJM0w{-q_6#h;A$d&M<sj;wJ?I76w@6e}LV%wwuZlUumpI?*+
ze0V~&Y4Wb)r(mt~bJ8=Ld}Yti47u*L6u)co*B+i3y}9?ag8fmT`T5TirF*UQHjjdx
zhd)ns?mfHQmvaGG`9zt~QORNV)>1?WnW`L8iOdNHnTdG8xqkY#=WHrpPhtDQ`mZ^U
zvGd(A6L%pMF!?ZT_-#zU#cw5m-6ZN=M6hQ>W`OS}S>K8wR2hZa<#<uFB@(3EkJd{f
z`EcsY<Qt+0)PI8m5+<JF2{BbyPY&Ckb4AMAhs;c5Us<EFCI^uy`?+)lmrGE#E8?8j
zUbL2`(P?mRr09BsX0vq6fiSBGcmbyPo5Xi8?a~yymECx+K6r;lxAC@rhFz)*e$s8B
zyWO01Z*yPV0HT)s1=PKH2riF|QjJ}2L~J_s4e`t<h~^jgg~7JNo%htx4P^-B^RN+*
z$Ig6rYu;-Td>L$O*m_=we*Sd`mRnSF+we2`p(9C>C-l^=em|oA!e=S2qg0U4o)0Xe
z0G*(3)N07{ZdLlJd9g85M5_9Lm-OSv_-lT4Zl-A$FI*Iejpx(672|Aj(YSc>(cZTP
zRS#>u>Hz_*snPiO?RN<xibH2B-x%DcpV6G`5Y$HZrM8Bra0^OchE7<X-U|)-6aMzT
zp_e4F(bZ4&d|%GRLXI}cx+3*ksb4t1J{F0+_aIWZZ^R=qR+znY^mgyl#&0nfBsgLu
zs55%ftw-iEcwJ;Bj~DWV1z9!Hh|Pkh57D7RR-M?Iz5Qq2uC~Kc_@wzApp`D(`tYJ;
zMg)79QZ*k3gP$ttZNygep$%2!`FzC9HvJCUQhWa#Sxq6LCNuVU5&dK@-u8iUa@0pU
z)O)twTr^k6f#jQF>TPLk8f|U$Ev4Ci`9qzUb?w!cJ=*UMKV`yV+>2asUeFmG>n$1C
z9p5)co8WmA<%x1QNDcUwq7Cs*2_${!SDWJJ?>7?B|Fp#VPOe|d(mdztbVt9FFjW&(
z&gsi9B~nn=wG6_N{lD#t4`KNic*XHoFjrQ8Jg;s$Xv<#{Gim(xIM!sAiq%L5M>f_S
zwa1+KmhkJ5>iBQTjhVq)Sm5`)m+!~a_CQp#BRZ?`!HS`V{RidCVxn|}S!9PQ!fU-w
zv>ys#tQ<5wk<jolEZ|8K-q^~HSq1X+j`hznx4^vMl41<GOGZv!Nk{y|3pI7ju|GKb
z@odS-67@gapJ)Wv`E%cEGxm1A<`jDY?&M|4FVtTxf2A%s@DH8`dQL%|@M6+S>!Z0C
zpF>SmH1`73dh1l<pUCJA(;vS!kn9Yz*J2uj+c5+B5rCb6<bw)!PZXlpEaa&K^C=`e
z4oE&X4(-cjLwd0vjhVvi;j$7oKvmX0BpkTKd_v<KE5LIDuQ)#lb8<|$MkcTI-y|<y
zxag!)scPtJ;UB{*v*{#y9jy}VLV5Yg|DvXUxC`Rd9kD<J=Lv?x5ev>-xsF3dmM~CW
zT+QsKfZYR01RVkR+Kn8V<NS*d0nT3mX(_&@iGRv*!!fZ?)Hr)--q88jLkglPT<%vl
z1T+q(<go<hq!-^2@h<j66Oyr8!SZo8WSGR+2Ne|GIPgO}Fa1rIc0t~AQZQLEenyJM
ze#m&Nk=fWx81O;A50`j}f@M~~uS>vkXnNS5G-ZD>B!c<NB{uLlakd+|yvfO~j==E6
zHFL4`MX--K^Ss}Tn?}G`yx0rxAhN<GwsKg&JqFnUK7Ys4f9FaC@A*crhH{}V+$z?I
z`g`6+CPCFG_hGwE&!yb2<Jce3d7`@7lFx6&Q~kiZ?(2m3st>Z{UJ)$AD<IB46G~vQ
zCcwazMyEPWFPb=62GKzac<KPF+0QmL0vBTQkG$BeOc4_~Nl+%}E>@&JMT&KYbN=+O
zDOmJ%u7ImS?2%N40W#CpoKV(F`Z8!7ToSEloFQtF{1JL5R-VAvI~%ulS^&M%*qeX9
zR!EZ9T47a8S&jGNIEQTVsd$df$cQLPfL_mw0NS%yH^)ZWY39izg0Y-*8AV?#=YbuE
zqa~jM0y<1947rGKut)(jv2egxArY}(V~hA&9M=aOyC}J#Q0&w*!<RwVm+i|qCn>n(
zvbbEwZb1qY=|Z$c*icYdo0do4+D+oBnEw)|^Vl6xWH^Wsiws4vSR>hiNXQxr@v(~e
zh>-6*$4=o&d$KLC8pSii%i@;G&ODz6VS+5t#5=<guQyXxs_*hloLBqka8~tBXexmu
zc;nszLCiF>t;mGcs?ubKkCQd?a%{$@!ODrJ6=<Owe8C!Xy22p^u+Sej^q6A%5l}J;
zN=86i<&bVPn_UEqgyFcZW(zcmIKr?dcC+JU6;JIwntIimH_NfA@Z~X>7Xsjfh4yWk
zg1vG+*+GH<j=%_ZO)XARcMYM!hiQ{V6T*25fK2p+AE#FQQdODr&vP>M6Tf`x!}GB1
z4|#a#t=9v7k)8MKZ-io=hYkkZyKYgxuvKQyNb!#q%2$gEDr=@j$?!}#=TmSuxtiIS
znQkAcUaH17?1UFCu_*3-ludAGG|YupadW!G%h?7iC*o4-UGv9#y%W?p55ncTpml3T
z*Tib>s8t4)%Xkx+o5Tfz-yYfzekQ1VY<j#BBlWXsq%){-uW9N~UVuxCBbKwbl)Gmu
zUb{bqJA(O;pA<0%b>tQ?LBX|G*b`~2M|Qr=E$m5uV|Q73C^Yu<0G}-cD`Xs=Eo%uR
zBrUl5{L)2KV>y7Zf>(`V@~QQ&F6Z42L`Jio`RU!vd+Wk>jXD3_uqdf}aRLeKyGYSt
zTj8LxC{jz3RQ+lMfmVqOwPVR9Ap#j#mQaL~8;T_!0F6L2sP#aoc$Vxxv_RcQ=;@ot
zA^wSu^EZM}7Ho<(ZrlxRnPG40%<ew30QtG5mkU31I{)RFH=Cl6RvR0ix9{>z{}*iz
z=UYOKxKo6jgbv%H-P&*5YLC0ye)C0p!k6~jN9}mwj%57~l3NG)RtNQNN7`^(2mnUG
zJIR;Iph}(J7wbN9ex82!dC4=@j5P_S?&3@YPjq+rJ$+u5&qz}jf3=1)?$@}Hcm4IZ
zI!pCm6fDCvbrDBQ*;q8L_>fbJf~=sPNqu`pF-8y{M6eppY<<y1eE=KIfxkcM`Wh~A
z7r}FeAD)GRWno}hcCGxm*)Ya@%M-48f*g0)FO_9C?jOTl>knP3wvrA!;|#pq<(#;W
z>l>ZibVY-k>~HaOPrm|ub@tAcJ?d_l(iex0L!V)w4xZ4{oxfhsT5tq((*?ecDII#=
z$xsUuiwHxPH2(y*9838n6Q409^m<DR1p%(kd!`wpaev$pU*<Tu%n>_?Xa_7i1evCL
zNw?U$t0tF#hozqRL+`QjYTkV$*VV_&%bzFk+ITB63jp!OzFFO_{Rd?SHpkx)0Q?Gv
zzqC^(@VB3*myH><NS&?UDCoET+JF5S*Ru+Ndx+=!Uhc(>NdQ!8p%eIcjlCf^a=P0t
z!1VULt=40S<a5XvIYyd-rTZP^YJbkxzAz+Ib^$Jbjr+`<c%eS@aS10#&yvZ`l&QjK
zC%l?z)3UGV9`?nV+ogkAfng#KLnVaYwwCom25?(Bkbk$hC48aIcFayFW}n;vCRFPF
z>Koza`*)91^8-yLr!}Z$p#$m0y<d#qx(rWuUG$%aD)ravZbim>^B*@fFaffEp8`A9
z2vDc$ABk5_CWgXq)qh+L6|x+dNqGMW#JvsUbf5+68oic5r=HV61U%zN<`V~vL%6E-
zQO`8Sn|N*9f-mad*>@iYYjQF$aPgye(BrU0YeaeUsH1KY(1o_UsQ4sdaHDLHpkeVI
z7RD#~VdxUXjG_Bn4~-*eB0flsmD!Iea49q9U<8ysaErr*(q?(F%g8Ik{*#l{qe(T<
zk5m&DM<1BKJNN7Jh$a-`&>kLY&vt;l9chl(!t!qBm{ES7$u13zaJ!yu)$btsiMKW4
zWDNQugPVlN1>3)5@?^g)A@p#Q^JA50`2puw1XM7Vqp_wb_}-(`<JV17@>8x&ksdQO
z55jo3wO><QLad)DhR#%oey%$AxyIvjZQ|$pd!HL$es22q`SHKcG|?|D=f1Rhd}&Mk
z(sA!g=gTi$-%gPXgr6OYe~@tbzc2mox`gLp|Ix%xy4k}KZ6T)M{$<tdCX>B{QzWtj
zkn;hgs``oXFZ4>KB~t}_Rjce_*|*h~T~7F<c`WpMjX=)kHyakfMu+&$*n9c3^J_1^
zkFc?5l1oel0nbt2|6T(Bi}CT8=~)~84uAaIl~y>EBQ(EG>lq|!&b*1ThqZ39IO3r_
zH1-KkHc;if$i_TMW#Rh-v=bH4iDmoR1#QKbfW4s2o7dQHFWwMlm-U86S14{`9u!_;
zMibdPt;zx690v&a6KW3=e#t5e;T|5#`8@WGo#y*J<>EVcbzUupq_gax^ai;)aYo=I
zPq~NT@S|~-7#s)eBm62)T8J&?WNyWD0e+OrG4o03>n8}S@gxulJu;eiH(2!+o|fVQ
z2r#Z#mXAQZAHPs=;9x%L04VwZ0BcT?YhdK`#r^F5iddi*+{!imR5C@kS*_)$OAY6Q
zI{GBv5B<o+v1`K_Ud8osf%B^fpa22rf&xeZzks>Fx^(E9G-l9N(({=T27>Gh$f}!N
ze>DVI+~urBz_n#obmb9kW4y!doaor41JtaD1DLV;d+rK&fkRc`_bL<q+73TpG+e@O
zmQ_>c_2`xVU>$G@j#a3VjZ(F2NFWYiS*uay3_Q^UQBmHcR*<~;IhdtT3laEu+2BCW
z1QBq_>py{VJetlCb%XB<EyM^({#(k~@4j}lSrWI%yBxl~Lx##G6Pe~V?=uV#V_1<+
zJI%}Yw)8mNUZk;eR$aZn%I#GlFkb;Tdkx1~sdk-k!mgetX;)Nu-9JUcf@0-}|9)tu
za;S9fxM#b@@&oSMF*{<RRY4>J0_?gsG@^&q@ghtid1)<nBC1j`a96~QR=5Lzot~z(
z_hi5XcCG$z9)|mkDX_n)oWq$BMiIAbMg<jDI7_29t)Dznr>}IPyk6oP)&W0Hy6u2o
z(4$;VtnGeHxob1cMq5knhYh#IEBH)ud<X|%p2nH=SbD^s&B>d2*iQ3r1$%_21Ou_l
zw8<=s8-0*;{J<1Kp~157P-9JDPMxRslMroKktXW#^qEi8Hcl|(?!VdV<HKWc^>xm5
z%;EQ>lj-BwHB`^)_mkWZ*5{k7nRC4xR~dUrjQw)P;cLe6cLo57ox>(Gvx}J&+s)(1
z?4kxF0s94$G+yN^eZ}^RW?7==Zi59KmMrq5ZSI?tI4oNgDSNyk30_>WF4YX3?JK$X
z!}k8U#1pX4rB$3_OfNv-GtFMj#PXg&ijd>aOO1|?uDl7(&1y>m(o1l`4%}MTrmM~!
zeVml+O4w?7l_KoC;oceZd-kJc;Qby)FH63izo*mJo`+|%jwl@edG}|E8j?jWtBopB
z*DiPF)!)PF$x!|c%f8KTj%Tcft`*nXm%e@E@tQ2^winWo%ILhw%4RvIl8^tvgaXbv
z&tY3L#m(=#A4IOG1uY-dnWlA10O#XR_%EF1gEFz)LM|rh)n2n%ehXq^fGXFwY0N}s
zt2qhR=HMP2*z;D5d}biBu{X!N4OyEdaU85-#LVwYGh&J0S}DKP2&m{)1R~bc^Aa8+
z@V>`evKfS43t1YWbn7AXnzhEN5Z@ix<6Zz@S_bcvg|w!{FQFEU#FM~k7HG<)z=FgR
z*b-JgT3;<I&mi6WtQWY{0j1c5tS|PMT5HTDkdcA+d~OO-P}Z~Q0pbB2AI{(<XfQx$
z;^X*QMV{0?^$X|zE^({rfnWHuNx%uRn56EbYYbZKhM={OGDOXfb~PC!Sq^AILi2ha
zqe1d6&@|Q3q@og49YQd?Tl_o_1sn}WtgAa+4tVg)sjSgrr9AO?#u~MnCb^~#UoIQS
zB^0c&BGe}3sz(UnWp$afK-gTTAZM#gxj%6F0!jxoW{Lvbgke?P-kWNB#C&>Zk><79
z6Mo-c!}4P$J9956ci!QdaYZadU1K1j)_9=Y_c(32{GFZ@uGBuDKouW)Jkx(kqTYkz
zk*U4Xu^9D7a)HyR6;Qzkf5@hVm-}-u-CePQ&9f|g5N5s-PDL$RxY$8r#oG(O-9nn*
zLev2vC-RU$*S)omK6T|}y`L-IyT2G^fKdW(jW=*#*{r<-IVhae^;QqB1Ll@#(pot9
zanC`KC#Hnerf^!^2mcT=pYdSj#r4;WD;e(yB5OYjTl6EHm;aq~@yL5f^(|JMsbCAx
zQ|@5;-T5zh%IWoPhS|*>*X<yo@DCTv&&5<sSk!#@v%MvI-`o=Dc`a!IFPR$wk$f<K
zRq|s&gl*}p2oa_QNAj^9tReHyMcZUDH7qtF7GC_Aa*O%h{^QlHLO5GRS#;-6UGAEN
z!h*W4(a{efm0lrcdg8WxX!*-?YgV7uAI}W9zE{osU|8BLIwt)t>b&B;zdRjSh!zd~
z$kQG$mCMqZ2?q2)UC#D5v*o2QGXS;NjLJ597~#@9f5Rb*HUOE?2bD4#9?UgdA{X#7
zgRYAov*?O+7>n(N6C!lLQX)u7)eI@-2EyKG(352fj1oBje8HZr%XxP&mgd~&&F8^I
z4t42eRjD!cjN3sp290L~nD_`O11XX{#=^rEEYV$+XfnXYGPuu2><@L|OrWGEVatqL
zFw%H#eLRO^BE>mBM|Bwk^2Fl@S4QtxSUFAP-Rbj{(R^-cdt)NM9PB4&s%zy?G*M7z
z;-}#F+{&qq%OZpd3Whs?)u4F_iPY0;d%3%=r#jHr3G5HD#yO0ejkTqfAo}2mEHC##
zsbT@@RvMBO6Vi7xjzP5H&65}K*W)h!4zBY6pjbrtNW8#YAON<VF_TMjhrlR88j-Eu
z(ZiZ+XD1G)1#NHdsVkbw<r_x#K-4rO1agj1<R&CV!&4qmgR#VbC14j<aV3m!IkU%t
z%~K{n#o0mwJyAa|<Q478_YawOz)$;+kBD$!rPIDO?(r>Bof#ue-fUG+xafrb0Q1pN
z*IMsV)gk!&R(-FL1V5e|f@0qROgorMjQ3E7&!22M$a)hf!d%IG{gGb(KgP;|4r_9%
z!ox(OQL5g&^wngR9*sW@<h)?}Kb_9Smzb`+MxovVF)%m`hZ>t6n6tvEoKID}&A_ZP
z_Pv{*`(PtbuPu~}s+JxB1SAEwhi%3C{LJ6O_LTGSSzaK#%O0Wd$&(aitI4rK%Zvq~
zg9;YSESN#Oo&;t90o|`HRiHlD5#Q-RYzOwx9t9br!s^%bqM2B|0*N7YYL@`@Mw#6q
zr`z<3)$XUg$JvuMOtb0ro5oz!KG#gt5w+apn^aFyh-9jQD9na4n%QTSRS0Nl4)7+Z
zojwl0e%ApIi7fIEW7o?s&eGbOpPf+apoYWxbJI4NRc8KL>^okkn!4v2L!0;_bx7XF
zJrKUpdVz{&W7}o@uK+2!P?(?_SK;%o0-C4TCiM;mpYg8qADypu=#3$eA>y3HrK_SO
zGLpW7^ywLi>vQf`Gu}qY=D(BU67ZIa<~n9Ol~|)5xhQ#g%48~5D0S!iafeq!@c~Oa
z;?vZ=A6aB}R>uLp8sSjnZ^1h*R6z~dv*75lGCwnI*Hqm+KR_Fx>Z*$bd9B0l_>v=6
z>WR<)NvHHq`^)N0uRl|fNCjk;fGd%0`lXmd%U_S=3|EyREuLBshP9_@X#BN*E6=J|
zspXY<F-FB3^m@n&AcWmA=yAi%(YoSd$Z29^nq?X<lY&+9nP$SIwCCI~2dAauC+?@W
z%nYo1i@;pE$$zPLki`#x-H3){5)bPiPCw`pD=u+>-xBA@kmtHgp<{>mN09<QZjKTo
z@SoZr2Q^-%JErlH(qDl-{0BIG5em$X9sF<}>X9M|H}#~)EZD!3`fu^6V@{yK?AoY~
z<#tqm`hfT$A}hfxLST8d&%OyS7esw=KSapm30OPFXyC!}nSja>Q-hdYJ}<XsNg1*p
zI!B{kM>K55TyG39eo1v?>PdZY;~bOLkEuA+mcX88QK$Xf$jz{4D}nBvD#cHB64x)W
z9A9CoV0JiA5Px+)SGbI~E^<0jN`}Z11Z&CgG0x@aEzZYsG-n19WyC6V%IP<mG@Pub
zzd}DRyYoDGouFZ``Q+2Jlq)}>#$)3t-Kj*xayU0;l3_F%&p*hwl*5AUGh!9c=0HaN
zNBu^hJ$O&C<V~H5UUmL{XsdqoH6$@{BR0vSrtsC@H-;y!e&xqM%##j3zP`QJ{{7#7
zl%(Tj!=%Gc-%tJyB%K&KkhJ!1=P95;df{g?I`kK@#4;RoE()rHkWlFWqJb^to>=p6
zEOhcUTWgvrjeKLQF!C~UPW8Pr(<!$GWpB=rYlf)udF;vvNZV$^O$q2-eFPN&Q9Tb{
zrK#Po?@0<I2_I8L`nplptZ+4|kB&%oPV#j$H3`uKuO_F`bf!Cilmp3NgwCeg3rZYw
z4+`A5O>wD*$(m4=&+?oB8>3C=HB^!hl*CYmf^5Rs>eNzCSs|0@WSwI0m?ZT?O)S+#
zZ+h-oVmCzF6EyOcWz&mWFo9~N!=+<Klte3)&KZ+D`;x*<EUf9)aMs`4Pz(%jgh>rQ
zVDSe%3D}~vrBi_<_Q*|2tc8Rd6do{dBBPHZLcu-L$r1>-|J_s{9aB<=Y0}^ukI6po
zC0K=#tQ!IvBoCV%q?qJr)r@8H9~DjJ1C62NYh&aqgPih1U>A!#(^cj$JOm+py0iuf
ztV%b~$y4<Pwdr!{W6i=W`&^}<I)jwJMJ`!+Dt0jCS~tW8ka9~H8Zv1XCPlTbPq{5f
zHKwMVVZ)o%rx<ngdyhdFUY>)53Nuo-dEzn4ZH@k%)>L6Gs5z}5!mc~Jf-d4cD4a(0
zLXcxNDe(w$sR$XI4@B`m3edpFeah8vG9mCT0Y&6WMgNz_W-*5&gp&nuis|aF$@Rd1
z&AzLFWM?0}ku-D<R#q;(^4?jor201hBTC!dVxQGB#xuyL1j~{d%e&SzK=DvxmsM`-
z`O@hu9T)O7L?ghHa<14YkCq&%lNVpy^ez{CzWJ$SGm@}MdhAJY#4|?&GWSbzU-jj@
zY%1c~CQHgg(t(*Bq;zL|R`X6)q8(%vlcLZ#(A@`h)5(iLkgdB@!s{CczETFuMuxz&
zBpqWyeG@}YuQZ_(5(vl)O(p%Yx1H-8UYSf~l~?6{uC6C1_1TD+jLeAC0Sg8Z4_!Lq
z0;OClQf_@n{uM|mQvlrvylc(`2&iN+MkPP`#hV@6h{0#c7NlQAWGL<fy|*El`iJY1
zHDWzbT|7q|z|xWpzrDn}d+B{_9M7@@m0$h5@#RA8o_fIQsLTH7rpSdK;PJaUIhg5F
zZ7bvkJ}WK<bZZj&Z$H@!e`=Ub*(vGQug=o)8UVPY=-*6{Oceppgv5BDeQW@MA&Q|K
zNE1bjpp`%G?s|+NOCq}^1z&108S;ffkKa;!6reYDHIi4ylc*wZKhs0F+Y5xKSEeZp
z>0vHm_Hpf(sZ51HcY%z+ZikGDQa#W6N%+CJ%{Ogy8B0V4wgZhtoL&lAGUZ7qVoMT_
zB*!qyO(?n<6dsAzO~R)z752-uLc8}VQVLL`Ka^NDfbky|t~|R;rSt1J-ipt{bH}DS
zg&#}o`oir>^j}hM769D<?3d=VENcdSqL^1{#CJWQ)lJgyS4u7GRF-~QVufHyrQmhy
z<ikPIA9<EZ4D)IZ*c5J<K3JH5?MW7xN*Wvl=u9P9IH`$JeQ8ZV32Mz3`d-P$n<=UF
zOFGxNV2;reW1bfPo2G8ck|qeaUYW4oE~Pf`eNy)sw?%TZ7u=YNezu>%Fiy34-b;0?
zXeXjvk}Bu~7jREt8dpyWp`JKVZwC^lUM4!aJ^OUW1Eyca@y3P4{TY;(2O2a+6U+tv
zE29`(<JQ*6tKhj4*o}w>IyAf(-<e_lF!->u1IRJS7j4B-E)Ohu$yfFa+Brn2QioRl
zW2xe$2I_Fd<1!RrpmL3iaiY}77fp*o&c%ga@(^T49ahUDrPIspBY>s3K${#Z2lSBQ
z1m!S}V<yCryQwKPdh~#Bba{wNCz2!y6O)hwF02_pUrp)8&?FG#Zo3Axq27%8<VXZO
zpdO@%0$It;04&_UHv#3TDc#}j)g^DwLc!Mua|@)QMeG1ZkMvgn=Ie9mD>)dCn^4LK
zJ4=%kY_Ylg8kUmat+f#jinAAtOEuP}(ghM(Zi4~6zEei(Tw@)Si9w2UCYzcIMN*fd
zaX^X8scUjH$@C;fd5Y`bQu*sqzQL|Cb+K5M%eE%f87oZvX=8sgFnz(%Gb`>J%oH1&
zoQ1b!`BW-=7Gsq($dUyDXkksOgFy1VWx-zz!r9P0(-5nAHcdGS9!=Tj<yUH*A%}zf
z!YAYGa2y;0A^V;`_YsJ3h`uNKxCxys@Z=5s4%_G)v(rL`OO0(f*aSrk=1o1L1C}L&
z&j!lM>mjr%h(@$?5eGp1L85yNRl@}=<qBu$29n$lUk4T}WYmN7rstEPi>gIs0(7X#
z-h%YXqQTyxA!G^5w`3%<gwt9wHd``rS~B%tGP|*4PF}JoTC%KNvYL_r<`FH<ry4F5
zzh9#&GPByX`J$V0Fc#$WZ5AK3R1A%LO#u8meg5qDq>B^vGKAGlY#Aj|7b!$dbkWGu
zxeHh&u^t)PZg6|s_GRW6xz0L&Qlk2eE~5&7<vjITP@*Z6d=8VkGE8#l(+3vv3fxcw
zl9qp#!EV2K!IbF_KWkH{pqx+b_O*dNI=A9+GawVO9A(gc8MhMi3fr7YQ55mYoio2_
z2~`OsdCx)oXy9;vseSi{Z9@+km(36YMeq#AA3Qa}w!C*DA%)|=15dx=oW0BKR&U#%
zpYz}Qv6Y|fb4ym4=3ZC?y)EK@TLo0v^3+d9{N|7wfl3+0)=lwfR2F5#x9VonWNojk
zSi1iFAPKz{_EYg$|9jPy!uzi^5O7N<b4a&x(40eF4zXu-rAxR=P7UI|T9|EG*iC~x
zQSQp^?=6^`97I{BtH7AP1$J?;*-EQLXz`|*89d~`8R0pi?A3>*U^-*GUupeV>$~hA
z_C?EHfDV^sajsB&;RBoO8glT38yOEC|IDr*sN<NbYM?b`8Z~PDe8(63lRE^SVe3)J
ztcwK??NW4QR=dZ*E(W=b?rEY1mZ;&W`KAI15Aq0yi36qI=5hovJ-8;=^XrA!k7V_L
zj#|y1VPWf9K_$0;{~abKR2BUm%S;MaPKIQ971b;<u@Ala{y2`ix<o2Jh(Zh0`w$j9
z2zb4=7)I&%kz8#4Zsqdi)9V*(&rNP@cuNsQO78WX=k@1JrJYc$@z-kPfQSQ1Y0qYa
zPS1kVWdeX+`g^s7X+58>uH(u^?%Zm+<h724)3u762(up`{$2&S%s_6aGX7389QJ0G
zC0->o)v_|tUr%SIl#p|s?V6AB?0-!<KgH|r0R!|N@Rb>M1<3O&-7JbgUm|Dv@v84o
zo^Yh<jD`N($erJ$F!Tn6IR5j1Ic#)~ZhR8(xZYO5ExQxFkqeZn$+7)$+OJo-V3;>d
z2}gnCEp#6@$aq3By%AtzDA*W564jbah@%)-G@iqd+ax0&!0@#ZzdyW?l)Ii0Yy01e
zSJ!<v){i+h>t4}(Au)#ShVp?{P3M(jzWEadA1et$j|DU0JqscU&xE~a2yIb0x8bih
zcF1Gbo@ZTib>HJl+IoH?<{t>Jh#fjWqw~9eCIi?Ng;OE}m8$K{DNIUQK`B$l?eX`&
z4-N+8V`8+YTpKuAC$%0$XWuvmWvPXO&2>m;Uj6dZhH7F-X8}Zw>@7<1o2i_r!nxnc
z-P6ey5rzr-jGK4%Q|tEA+V|53_A@^1Xa3mF`n#Xaa*)G+kSlwTr+tubeqh3NBOe9&
z{;*Jy3ep?&&MfXeGX_Lk*->0rpRH0$Umu{Y;{Uoax1bJN<k-gHFu;EDl|dHW=PY3s
z+h{M4o2TaLASEL1b9&r_+3EgAL^#DWU1y#8=)c2q_~Bj@87c%#T5ZXV`_G(r?foBD
zRON?9eRF!#P_=bj&;C0K7EWJ*zSO2a4R~#H8kEpErvD&I=7#54(86hSog8pq*hT4M
z<V6(47NDjV2=TBt%cOx<sUS@}2TvCCqd<2C^k25rza&gz?}gW!62l49?p!<hD`%ls
zLmU}rgNWU6*D?^`o;jdA0Qr@YI`@|{f9CeI^J`zeD`NoFT)T#BQ|d`C8Tf<47(s5C
zGXwXKT%ceH3sOV^*&RiV(#Y-)$T$mNpYMfg1ve#T^q5*ef;S<4-OQh=IFGtHi2$la
ztM|ubO`2yFfE5%Np)vBM*_w^FcjnH8`Oc&WnaK6kEy=+g3G+Oqplzw40tM%mkhN{;
zkz%!giKd_(nb9)6*q`9Jd@4?3^Ef5HSG`*zW%*}xfuyy-3&0ME{Z^?4zQB`lYy*c}
zn(s(@U3&24@X5Dc%-T>(=#AY+mdeXRy}9ylW-uu|rJ*Gq!%A*9*`752Yj0ZYVDzSN
zDqeax{k!)?JZSwl+h4Vnky7objr9Zd)v+q`02Ltibnt1?wmjUvwOSa-bTXdq=<8jR
z$l&?;N?@+I*OqmrIW5K(-H`HQ``?F`r(U@@)<<zZS3;co6EiJ#Nd4}g+_X-%pV9q(
z@@t2&sq(V%T`zx{Rr}dlvp=D{dF>;^<Nd39`gkT*9Tb6CC=Qhj3xfcV226J6!`a15
zO@vlyrlV-KXGUzwQE%v8O05E1-Mkaej3IWuCd}D<thrA=o)f&W{a&B7#9`_TE1{=M
zll9dl>&v5;w)mv{W+WUm$f;5zPK)7Ql39A&tCEF|uJO`EmxG@_$gVGu89c{e=qySD
z&OX>PRrUJ0@)p-1xWlPc8!y-`&i}}}07n}kQye<~Q7jF9$<<g#;d3g@1Q)?W(w4oO
z(+h5)8h75Gc@pnyV~~^RYZdihO*5kMNFc4gDp~EOLSsW?r^3TWe5(~a^T*s5gg9=0
z<R${fDl;$V$SrY)e_lHLAoYUTp%#Y+&t*${rs~@BUVT|zeEDE*O+nf3GDzP29iTQ-
zvRy?gGf!M|A=_|w^Z8gS-tpF>hg(DXXI}pKEc~P_OM}G<5GnEHLz(0B#8<6<_nqKn
zzExU7227Y|h;jy$zdQ0}oG)|KK?XO6?tF+yR#(Z{(h}aBj1ON7C-FVVXvS82tGPj^
zUk9R}5jfI3Fi(=)czN#VSbfZh?cGJ<>^|sy4xQ`w9Ij<0>a<-UW_-z<vVNlw2Rk5A
z(;4_5x#P3DWoBm?89Sx{B)O*-E?0*aNco678{g>TPC2JB8~^L2_V>hct@nocxk0sM
ziz|!S_6<RroLx-a5xK*xmg>U7i7TtQDvYmB!(P7B_%z_Z=~R%dr4;aaoPT-shOc?a
z^;zxp=3xW<-<N>c{+4EwP{j-2H}fc|-Q(&j0E3qfe2TS#6KS~jBYf#RroO`1C9lM9
z_NbBO>L#8zktmz4uLYV=^in=!)AmgUi1o9nh(pm1ckVSCp`h?|o6C$X0dE5|X8_~<
z9&O>==Eui)$XOJSTYy_n4$RG}&&u>Ef<0Qv*WV?G=;<#lu%;6x_P2S)aL%hCjo{1k
z_btoZo>!xj?jv1P#;AQ3Q*W%xQk0T$Nv&P2ahy^gDc@?Il~=A0&DBh8y#{g?>3LDT
z+pEoHMB$PJ0`zNq&_{M;9JLz~$^#J&-M^!KQmLO)ETI%KV<z2e{;0(+N0!=s)$6lY
zT9y(B6LEJyh=IPFQh>w+YDk>^kOqyWei6dwd(nF1P>VT&n+OwLXcYr(jR3=A2I=`u
zd1RAmG@Qhf%D3uC!S?m!s?Ye!8a50$wzL#JPLNjeksoGUo@gm*>ylQ9Y8dv|Zn^X7
zSQ<l=AMxUPTHJqDMlHW##82&M$!LO%Mz#FAAcv==Q(ZDzPaEEaMn1hedn}_vmmiJD
zds^mV`ObWBvmvsRz)^TaeeJ+SF*EUIbE~KmmZ_pm9uG^UyhwdAB0omx-QfMyLDu9*
z8zbsT1Ut$>^xOV-DBB}D8$!|`w-m+{C%ds9zU4Y!#hZi$BHfT=9-~9<0(?P*N@9@W
zuW3xyF_F(@4QYPAGUayghbX;c^V_$VpH!Ag@pZyX#G-f7QsI9z&Pu;6^HliQAT-WB
z<U&?!>4aZ7AlhgjQZyHGAl1xxp0mUL(iy5$#T-TtSKKknMw)ih^HM1;w^P)yZK6pl
z@lue|GdV|)q6<jxj~1&cIqWMch1MkbxOLh__x?|tN9#T&V)FruI2?2(aGrIfxe2!y
zRN9l*)=FG|h~uafb_WAE-JZJ(ZFVS)rd;Irv!|Q8x^h{*Ge-a3q=?kGkWAMl1p5b>
zm4QNl^J7(<PFNF6n-TjIvhwoigN*2gyFv>>+WbtLjuL@htc9nOyXN}4K_4E@g4k66
z!Bjcz3N6?Q6o(!Q6o?X17@hkE@)bh|TRtAk@RqCL*Sj~!*Rh4Wn`$G^gfRQM-9uk^
z3+YuU*nGnE71_+Y_>?uDcWX*<0U0&m#Hj0mgeD8)9YdJgv*yy^|C-aT_x1=*xeOal
zR5oSRUy?E1EHWIk=Z%K{=e+1L<y2;r`BWfYao9mE|A^Ta%|=ZA83g)5`jdZnXe=Rh
zqE@W0e(5d*z*AS55q3JCH42r4cRm->Ms68RG!!?a6s}vjl*!jK1De?(-4Q3MoR0}W
zGVA563Rr01IqgN(`mLupJU3t%IETq#Q?FJ3SLF4N$zx1l$^wL^B}^0GZm@ps*K;rz
zxTL6CCFQ~G6xWgvy7+%{Q<yXn%}6E1v^S03pN{8$i73`gwVwn&PObC4ra^`CHy77d
zEB`Ldv9#Zj1C@C9l$ous@B?%h;HYBRQN_t#|H&NhTRxG@-9~}vy`XS_?@o{|(#s;T
zG?tIjx{)-QZ2jK}ukWE9=>Y^a^}#@=_u@i@MS&l8q+gEo2p2vY8_IK2Isn-V<)lx<
z$UOeTA|sOr_h9M1x#U588-EyKJsrICb1PM}$d4V+L>Hg*wCjy}ypua<+4DOv_w}V~
zPXQvma&L5kb?@Y^EIe?Np^m*1;dP*_bieS9eO2^P`0s8~G0yhl_kr>Un;9#s$-3@e
zbU%L>&4qlUiyMg+@n|%{EBeT0PN+KGE0g_~KbUa1rJDJKCoFl~`tAJObuc{|U75Q7
zO?=!l$7iI-6acQmtPVDPW~gU}0}_6U-|UP6L^j{`1yr!QzGZ2BaggrRqy%u!@iMUU
z=&CjQDD4IiIVWL6&7T?3_WNv}1rWJD=fiioofErpepdMVT{Gdo1ZF+WGymQ_bm10#
zl7pMr%6fFVfBfB@ZMvB$TgE7@D<Sr+3eSfu?SpFg8~qj)+l{9EBTc}IxxvFb%O?v+
zFB5kd$kV1AVD@DZjFr^z5Ei+7y@0M4^T9*O#Xx{4`!6l<o}jgRkD70WRv$rfwZ9I4
z)mbuD#$WkBMZx%(APV5M@VO8T6u@o*bNm4?>RB7})dXQAf=!m36x4afB;|{f62XCb
zO@$|o+&zleOHGhsj7oF(h(R~g{qYJOTQu(kNov|!?NTLQ7@GfapPB|;D`XOU11(ro
zDX2g)+=b}%eHCo06m~$%ul6d6%n46biq4|NRw~6d(BgZQ;wNYnqzc6$f##|b<dKk&
zS-`&Q5$$3MpfX8Kn4r)0ijIs5H!)dYs|2P=GGSFR5*D(MZdnBh`P&nczC?Wub3ids
zq5F-rFI}U1K?7l|AmVN9OE*LquOo>1t8~M9qKX1ZklKUclT@7`sR~IZOG&DRdCMF4
zpqN0;;b66{6pb4s9i0VShJ;l#(eRSw_u?Lnj&wt7y4DSExgoG#qz|FVM+zr-mTO!Z
zWsELn^av&3t~2AcHozFUKIsA=rk?nYN;lD{wwkL_xydxEvna1&t~Jsl98G-JS|!Kf
zW2#lH+zVEBT_S|ksP{`+NZ9E?e9$7MhKEG;QYMuRx<N~|Wt^nWMyBpMQQy-W@D+C%
zQDa^sX-%p+&q2NL%Ey93`nQ}9ptwg_u1_Sv*Jh*#x4USs(s%kwCBfaYUwcKvYa|AH
zrL9R4D7pq7q_&B3Q~={jjnF7#ErhXCq>0*4y7(&OjGW)hs+sf+u-TA_sshQVQ`$_d
z8Y8yo23bLKtl&bH?1BD9kxN&uNZA|IuGcI|t{MZVM7tFe!#%qG?OrFIWPuI_(eNuy
z?!;J2sn0#q<eU=NT7n)1?lzbtikB_w^$$x&*WxfB&uD4$O<(ISN&U`hJKzs<*1C{U
znd@oZ;d+Y~a57P>?=YiG>b^u>Ig<W9llf0DW_sj`zp=p_-M-NnFp{k5<fARuC%j9<
zeFZ82jJ2bQ$_op)?u9T6-Rs29r)5Y9Ly<JVMWH}ZH9)TuY4<o^Gp@iy34i>n2lkM_
zC@s0)*eVGNk)YWgzesO@g`^cuLal%~@wR{94GGnpS~;g>Ln-OV+f~|!i!wzk(f8{k
zRem)1))^KP1o1LDO+8Ln>F`&~dfR@Hw<WaqR^|3qQx8|O)gBOK7!9-V#dEX3Gin28
z?c^@_1{h%I8a4iaXrdNtjZ(Oj+PZOkDdFM`S&YsD)ikDr?PT@6YW>Xzgf>>yRWm@s
znxRHj7<T#YhRIc~6+&%|w~(LDM$nZjHOd@~d1Aq{9g?<?ZVl9$jfJG=K1e-WDln~9
zog5g1lL%`u)jA7IJ2ci#SW-H!%I&Ovn9*o>7I%5X4;}JGX<aH~s_*(qpb_7aAIFbJ
zVh!mM3QsuL)fK=-Q^e}eCO0<dN(sG^O$5O>f--AOoL+SjSzh%@vTnkdMpIAPinrM;
z&Y)Gk^79X`#v$1RyYyOM)T+Pv*8p3kKySW!@7iB4_SQ_kGV0Vef}YG?dq1*L#=2Ng
zmHx=AN-tqmX4dE&HBheB&oJCnK19MgO`(CW;bp6Wn_M!ERBu=y)#M~63y~k-c$n+2
z^ms)fcR}&(=k!Wj**M#^F;O{M@I!$ng02Ro^~w(sJAW--Mb!{Ro6exFq4Nq(Yq)y)
zwPaG~0=PmbczpEQ`?iPWjfx#bN|O_8s`bD&v1RfVIa}*$oQ34gqQ=XIpb$QwPO)ha
z1fWVamUoeQV{1ZJ>8r0*%I#OE#wzIauNjuD<cP`ILIVc<tNM!?U-8uqm?_WSw;Gux
z>J)_f`Agk^01Qy|3LS`;WaA<Q@HGcnKM2;K&mU06SjL4vY*%~a)iNXm{cTumd~TJj
z8(5wA`Jrv=#<<$!t3w-FTyht)!sb^t8mx^kTZ2`nr7q0X(6ZLcs?rU8iQ>L>x)8jC
zFL4Tj*DveEZK|jy_%5}{%?&A6cM)`X`hT)Mp50LXetX@#TkgA>-~P|XhyHIx&i2Y;
z&TPJV^Q88nxZJ~EkZ#d^BeafRM=7atbXfFkuk_}Vi5A7|D|J`4Lo5U~54C6@S&Ksh
z8klo@&Q?6x76S<g4+KAk#L`%NAfO}~G#dlELxYuLSnFu4PcUrlG`826(<+)ur5Rw5
z;OA*3Fx_+V7Hr6Czgr1rF-ztPAxN6w3?djLNdfvygb9K(0x8}MH{T-cn+Ql5UkYK?
zmvg=lVuS(MULFB;z3j7klZAF6YMR{R`Sa2IUY~_-^2dFUm8zq@iJ*DwmheC`&yOuU
z057un*<_vA@f!@_ft#<>zbW^fIR<IelP>mf2zI50S-9T4gjz`?wf!Tax-)*nkbZ*4
zaqf{a>XiGds`4NzPZ!m26(>yUkpR=hL{e_Y(<K54BG}$Io4!eenpKnPcX;n!Gc(_}
ziqtheOLuhmgB~Z6h<Of^6lNYL@Kgk)K3J%xnGI?GP5;C*WiRs9piC6DCs>Br4%}jw
z*Pv*UQl!`lnS-M&5y@eJM(^+pKFf|B!|t5`M|FcF@^~K|U4GSeY0ywf^*=zmVZkWf
z<`jelYPlO@M0#HXu+n3_;+L4BLx~!+EL^yeBo9bijwoGL*oaD2gW~`QGmNm<=+;$>
zRPgl!zHns|Ns`4W%3;zP4LIiGTzP6sPvIfKT7#I78R{3LObjYOAVGNWm=OjJ%6&t}
zD8*n_KM`a4&WNa0yt(pKz!gwnr0eeTd@Nn_*jR7igKq90i@+W=gbP4Gpq=z5(PY%5
z;+gByKenGV-7TI<k$_rDpmP>PzF#E1Vta$`WL|jss}ZvIZV8SAbgls@bpf-sh94`F
z3^nLWlTc&1;xF@z-s}HBQ-kT2b<L&?5r8%mS-Us;Z!$fev;{zcQLVYS>5MPMsY213
zQ5hhK3T_cZUwW&tGQvd3caX2*jb0PCV7IYBA7~QLE%wHkOu_-Ii{Jb<7D*z!LyUDP
zUDmsJ+UNw=2C`nGwEK5OM2#hjpn$mtbp3f&0Vwe`q+1TfW+bffVW}sq3;2Q7>xAb3
zh?LOe!P3^?%g1!F8YZC{LQ}U^;1S(Yd>2y}ZJm=IoUWbn+SFkt!={q_<d}Hrhl$r)
z!c7fxAyv^{Pa=*dOL~>uty_p%HIw3bAK7=|HBS%Pe6q|^#U=gOy>mI2=_bRMbaGy&
zG!&X1JY!G|Yp&SVt0I?hmy7o|tl1OKQ)NS##o)t}2cT$fqlGQU5+0_`-B0}_UF}OP
zjU=r*?U(-bfWLxu@BT931&p5Sd*+#Q`2sWskVBuBvO#ve9e!sificHzez<XLOvY$$
znwssVcu@~BZv48qmEsgT&==dT``|lCt>8^3!ibzxP=bvEWPJNDSa|C@$ip&iQ5lTX
z$u?ZNn8Yt;rPz1MR2}YSlvM97G;CR0#69@$&>E5ajsz04U=rROJKK8Swi~E|jgaiK
zo^GBtz?SnMdIjRo8;k+%GPakxb$%-M88Rim>oOLHzZDZ88ns&?>w7BYrqxlbVXC5f
zf{eV_|3F$ItmRvsFCX@S4vo*Y8q<$KcQ;9?43J)+vGbi2KTW7e_}E#C0n!^L7TwE$
zK4TBW>>rW)IO_xc_Iup}!_JTF$vIl8115R2l#K5$-rfNNpvAn)bm|T`{})34cpw#o
z6^nirHU{zm;DvSKo1fj<BGC<6-7a6~lPjRJcoEgwtz_afhrqof|6R1vp|fc2zjaQu
zz*q?CBnw}ha0_IT@J;5}=s~lo|M+Nx61c^e$Rsx1!*5b)QO_i?#Ppes{juB2Z{N?&
z{&+e2-?{I9Uw&ttn`3!3$7wLn|7u>`U_tiP!Wn}_?c0K`Mxua<FS7AL-@(FIpv_YT
zm&ocIe;|RQzx09zPHm~J?)odq=#w9HlkSAp#q!O^aF5euuGep{0IC4Z^L_mjSlLrx
zRs^TvNe_uN`A|s0?7yAz7#)#}J*%;e<6#(T^ltsPU)_Gf$_<<g?^CdTW!=Z*>~fWB
zd;5GJP!wdt3sTSi_|LMd*9p-(keS<*!mNi+0@S}Yq%oX2UR(VY_*1vZOJc^3J&l&O
zf01;w3byOW@iL}xq7^c#Y1{yLKpG&BYVTu`%@OoF{co<XWxlL^Etu!b_nxEytt%sO
zs(yg;%8T_umZ|e^G%_c`edBhnj@~<`JGAbSA9S(qLZw-uUSY7~L+57ykDY~#YtB!u
z_K<mnRmWcg?(5;U|6c#(tjnq%4+h`|FS#&gGe5dTesm37K9;{`;j8lPxhC_!odMG{
z!z79TpUm0zjo!X=VZ$uz%iCApmm5*|&Xq<7eW<gqbF#^EdIfN;kyF|}Bi{8Soag3t
zphdA}$V-GScn*4}#rvhFscSLP{*mvS>5o}W8hgPHDMiez*x$?j8BC;F($n`b_!v`u
zl`7tcd`c#KcYp%roQnsk!^#Sz>-Un97z`%3T{ja<X;aGU<ar(IzsD}a<!8D&FXTVq
zYmpOp%5zbvcnC1odzXAN@2`7pDtQnyDyM;Ya1EGFZ7Hn@_ZLV>4)RY=abb*vm%LTT
zh$wy@+|`Wh<yo+QBbjUM@K(AcWWw^LnY~<22`XaE;PC?Hp+srXFB9|)m(*pE6pL}r
zQoxD)K=IWH*xdi{boc*E{{R2@55_iZwmF^iZO+e6a!%QthlHF{nX{aSB#GF}%=x*T
zl;$*N2}w#P&T}3*6D4OwQcglh_Vs+dKbP-s`vZ0ym&b8`+;7*LQKGN<df|osBBk2O
z((QrbUsg*wa#ks9Ql+uCQ5jG5QD^KYOay}8PQ2q{pDR|Rsr0r1huB_uo%ciDEme)Q
zS9c=^Fln&JBa#^haDi||K(VtVTPXc)P97}XgSc|;AMA$xBp+67tIqGprQZY>d&cpj
zPf_rD7vp+!(=yxhIg|3*oQ8qb8ApEpyh=oWHiT>wTf7LASFQg{ddB{xQcc}*$#~24
zPi@ePPZ9=u*PB|7S5k2~-#?Pr7)n!f38>kja^i|h;PED^?La#8L-B@jx|FR#Ru3~^
ztZG@=E)BS&<)na+Rm0<*)Pm!k)X1oR_TS80ct(t$w&YYh^XphoE#D<^x~}+K!X59V
zdffN93;g;iHyra!KjL_8w>IJ8aWq8&ktjtpSGf!v-^@A}bK?243#qSX{|SFS_a$lS
z#gL$(c(MOV$L5&Z`tyD6HrkaV9qGOX?SIlr|D^Pcn@vJF=?Zb=bF}=#rc(m(3ja{m
z6`BiO^#i3v_jPc@`?&Yc+}U5<cHX&M{(Srh!8%b7F9-<B2mP5igRPqL8x$Z_`6s8F
z-?gQ|B1UkKcx6|1X-&m;Mp^oWj*`(2CO5wxX?dhwSfBm7-t|Q<-8h65$c{NoHcK69
zat}lsf=PF?)On(P?>kq@kP9BMzw3S!BOFExEtCYd+xhhl!wT?z;zlZ<*U8LH^(GEX
zaDVdztwREwqa5p-^Bv|8;S1;J4iJ}N|H5WlXvnJ>!0Rh(rt6oRX=?w<pS{-cDGzhf
z^;To7BI#9ZI02tnxrnys=y6doeiStlEYVT#bd!&leY(9;(*6WXRLzxpbtAzkK;Xc%
zBid9oBRlQL-z1r*B}2dIfqam&pwauS)Wjx&kY6wO8BaN@Php?fRF;uAPX!gQCu9W9
zgE8ith=?Fl-?l4^9BJV^ECh}ti>hNC3b2E3OniNPwwI&{0z*&{X08kxh^MPXQ&8={
zkt)c`t`e*t&vXNZO%Pd;=3h<Dx%GVet1?NzipZH;*r)zYHM_{lM=7^xG~(NdGJ!Mx
z*15&+TEA&D7o7<X$u0T3{Y|S&z&b1=_x4xyWu1v4>#L2qcYa1J>&*+Cy*~E)h8;dZ
zgl{`b@i>&eufKfi@AZ6bb!INNDQ1FnTb9E690`uA62@THaYbz$S9{sAiE6P-cSJWP
z<72<9#sb(iO`KH7{z`N})-Fe`Urd^p^Sf0z_P;S|3aZ~%soylmxg|{10d^+1*tYCA
zQ3(t<7%|MNvR$EJ*yBvO_AQG?a!-HMw%E=XiF0w(vEmT+fxI_cXj~4S@35}_AWqLM
z>>o8c;2l=nwV|rnEQVy2dZ?MqG@eC=M;X}Sx_5r_Sit|+^FU_x`)OQRp*DTq>vpSz
zML4@|j>LPh)L;cS)sl~I_3v9TK@(ge%1jcWYQP2kdxD$`ef0<5B`AK$e2wEd@^ahB
zGGQ_n?tc+eLyixh?*#j`hGxdeEMB0PW28F88%{}#^L%&zWl-#PI=!=1A~^Jx;q-jw
zV+9H{U8P^6y*bSlzaUXS>x&-0F*_i;ME_r!+qMmGz9u^L?$_nbk}pm8gn&MJ5AI7C
z!?;R@!f}<oQ}(rs$FzH`Axv?Qx0u)hY%d5%*bgXIuI5M;c*hGA)cFqr?X_|VRAhll
zqGH2E-Usb+#|8EY%uSi58|;@%{HQL`Va{R4MSjoYOEM}J!1Ikp{B$H$bGDbC2=f~3
z8_1%R-9vlLEr<lVu%tHM{(8S~0TasnquY-gj%(7qZHG23yjmxwX2zPeKagmjGNB)l
zPS)(Q8Q?!`&J6S`dL5f#ffJ;b#RywJeW^06QHTG0S#Vm6##!K9!3;@a>nT4&>~nqJ
zMNL%qQoP>eAqZ|aH^?l0D{0$vvW73k!~AN0OLC%NBQcRF^Nr6wZD(g-DDM)(8!a?c
zn=J0im3d#0#X+?C%xTLzK|adf0)eW1?h(xe!3vdJDNlAFJuW{@-3Utf40e>9DjwpJ
zz#+rLa?&rCR;v9?Y#yD|@p%*;qFgdtY5GpLF6(Zv4cyV2Zgy(O_E+out&$^fd*}Jq
zZ?)!F<S_ovsd6_iZ5|;W&g4?s>YYuW^@@q~Tv<p$GoOA$=xr?H)qp|y$~~k$=Zcck
z=}tUn-^v2^<-ipY_0lVLX3AppEHV#lbKO!kRE!FxU|EO}c}ck|re;qkcTPC&pYr){
z1r>E451lsek@%oJpby>L#@p{8Af#8Ko^K#t&)k=TUn@&l=w@aZIx(<d(?wTd^jN+r
z*Sd&$P;pTX4AKYsjMGY%K)udLjKUe|xu@2A7QOyu(o@3jGemJqCzxs<CbIacpXcPK
z>k6lA=QVVCH7WA%q9_XzcS-_yv10MISqUEo@(+J%2vLn9n7NWL35}v|>xu(dL_7`D
zRoi`B0?2f}{o2v*GO^h2XYU@odwjIhd^h&z<-31B|2g{8C3bT&^X}nSEyn)D-J3fP
z?*99Ejq!K>?B$^4T9xZ140~Kj;5^<{Za<U3=zyS_y0oC7K*iGONH#x5d40adHai?s
z?Lr$6%ItKBS9C#4V&rtRiJxHdi5l`fU|n2uTn?Ybd?xfVm%kW;I?qqRq8&GeN{u}z
z;InIqa{cV4?aOi@8!XpD{SL}soJwNkR37b`k`Eq$EPEKyp=@!~VNHcdQzH&xBKp}p
zI_NUC&I6UxCHRaW5ZZ<EllkArH*%i}X0I>=3#b4Rq1%{oxRbnE08+Nt7hbf%$yTj=
zG>=^AWY@P*r^UmjDcEA7Y&5Bsc}^6DLh*)O)?WeXd^3?-T5tb>f`C{S6S$<C#U)UP
zlbbGfp(*WMsO@$6x;Y~i8~)=rk83)dt41WK%&MIvRNT)C0{Bj2(Y|4;RA0AF^7euk
z=hslCA2zF}Hqmj%)hhn3l_u%{{mBs_Lw{I<QB$TQOuz<_xOKh>f-pk<R+p6q<&Uy1
z4Xk>aTR*ix3A~%IO`*e==8&3L;kp54qY7x6q}UN1_BI~2>Mdd@2W-uY-X!8`E_pJC
zV<1YGDYn80R^05kbyE`B)?Y++%SC&U7d9vm4BF(95mO^WZxeD_yHI<q5+*qkZzgcq
zW3)6>+-|w*xJN#}3FmL;5?~|xuM5_<z;5g-Ho!D{b5bZ}4p)ca8X(qHG8xh)WwKlL
z$-dZg$!H-%Fx&?&67W7iO<w40P7{{Uh*1ad#yM-Ga5(@>*x(`W=q@UVhy%`-!A_GW
zVD*%sSHhMuERWQb`Avd(aB#*hQEckhi4?lx3h{fS4g04~jaK5EF0(4{Z&)pt`nU?#
ztDEzk0%S++gn$YEO#-I^Gh&jc_(D#dh3G%Ugrw1-8*}Jg7?45~)}QC-4{D<m#4nuC
zymSsbMgggA%18EbC9%xthJuoQOKSYq&h>r`g!j-1=AByrck_!a!uD*n$QCJp*#j}<
zgKgl}vkd^J+Y0yOw#BHfR!-LOvFp4$aXQ8CcMA54`Jw<EcCL*i&5Q@QWsGJ?JfUEN
zd#uWPzhS?XC5e}$v}~P^l%ysmpdTI**d$=EGHyYlg<S=7(gU?NM-w#USOE|$Oq?&m
zjr6vSj9QCUCFL1=lLUtd6PH$#^V=pwbyJ@RQ~y@e;BC_|b+fAxX2+M~vD;?HiP^*m
z^W;|ZE;IO2rw)S3sf!h$mhrJ*<?7<;GIc1l!db3){)lCXIXtKN5A4%zOMYhVa3-0w
zZL3WL(2Ws5nyXHcp7o-DtvSKQF2R*;#pm7JYkAgxwgokbD%xjq-hO4TBw7D>Yx6Tr
zViMT&`*p%&UXV`W=UuQB&zJ3<<2C#(mUjgU>k@3hF7TA2Dhc*HULsaq-NyOHpX2t5
zFroK2F*3nuBEm6{8CZ%J7B1&~(TxLSd(@ib$JTZ@7o4Qi0{Y9)X++_O9S%HVJ2YRS
zJzkIj-oR9bDKisOMmAjC45d%vIJ1^@@0Ts4y+XS$1oJE)6CKWvJ#uj~JP*QiHxflT
z$s$}Sjz1qsR02-_2>jC+7#|k>;-Neg1QTZBs_PXS$(LX0^zgAjvqyIDbl*Sf5<*&I
zyFC<3v0Si%av3(sev+cT5r^74F^dSS@q2<ro5bXt{$ZDZdN39|FCsDM%h%17MnpEo
z!&K(`j>=#>-M(Rtm#)9R#9s~%39=9Wej%R^=Nlv@cvZpE%s2U+{MfRXZ#}k2Qfw{{
zTX<FM!cW;TtXSPug$!a{RCCaIL%Wj;{aamv!Z_CZ^IqKVu}TtRjcwS~-4F<yAcK?q
zpkVj1z=F{Nah4tlGU+?7hvnPCtHDTojbTVXCgcHKpqRwj2=KRK`Cd$Ndv<YFVo;v~
z(bJt+9<vj|I0WngwiB;@@;IPM;LqqnM|6b=8Gb8m!wQl#o|Fmn*JIo1sFeBV3QWpa
z9O{CDD%1&^b}i))d;N5I#0P>SKQk(ilw<r#y!@wFP8+u6+6`W2SQaE4xE5pN+x;RT
zsu^bj$AO44d~JQ`U4n56QLL>jxs{+&W2$2#$!8UK0p}B4YkCgt$$r&Wth|dgq0FmD
zL+r&awjC3#AEW@H3-1zx_;F|oFO;_&HbhE^{3g*or{CYj)0U5A819Lgwo}e72#nuD
zoazqNXXYAL6vh}*XW+Q8pJE5sV%D$Pg7931OhQ{E(Mn<<YXQ{cYcP_=XWi?~$4%gZ
zifV6-&S6RKy9EcByoAalunE}WbaBRfjnb}I1PRtXm*%5k$|EjP2n$sS!JcYU6vU}A
zNCSrR133yqhs2?lA7UO&5^DZp%w1eO72crhSseQkopj0eU*e6ouyb^Q8tl0VCM3os
zNA_b5)=+S3MD}{2BWst2CjwKJD__nB;x9k5VP@cAc=LRPz!E(LTy}mfh?jxYZtc{~
zK7*}uyo@O0+m#W^Af4p-Gp6rc_u^q9)MqvgD<+{G#852cMJz-LkjHlCtC>AWT07#t
z_sAd&cTIKBQ<sd+eX+N@*hY<O=H1bP%qaaJA<XWnFFK_{<gDL>c!Q4@EdOBq2%Jb_
z_8~E%V*!D<HFaR2c3T@53ldw3cR^_alrAw}31#nf6|xLnfSfvUU9nLeaO6)5Qv%w$
z#OAtm?yRNrc1MaBPJWU^%LTuA?}?bClMT=KnD_{{r)QNsR=%uzFZ+*#3{mkYUPAOb
z_65M>Nkn&F6K!0o$&IenbH$d{2X1}5(2=6ap8D*FBy`3F{6Q-p)EPT(bbjfYKY*Xx
zr9+h}3m90tc`x3YZ&jc7#Wsqt2XmMeof1Z~D|;&)+DP|r#9s&`VdtF4vf9NUK(KmM
zFb(ZM;nh3cEl^X<kLyC^l}Sorxd1{7qm19;dkX{mP-9=5OIB=a8tb8rYsA!jdXIJd
zi*dbCh42ioD|Q^j7%9LU51E=D7?LkoT?Fu(g;8n)4nhDxAeR|!t+b!Gbm5SR&w2^@
zotUpajb$cPh<K)%<zm<7T6oIO+voxdd)SnCuHMmUOeJ&*K06yM+)i@i?-uHuB6Jg8
z>|5vf6-vkvYLW$=P0e1+Gi}g-PNvIsfhCUh_zNce-V>t_tUiWR(k1JzT7liLOLL-I
zUHO+&t{)u}WS!$vPaU+$R0e-8HhLdBG}bCo9w;=```icnbf!p%x%g!HJVjot{KxO^
zzj*d>!6{NeBa@JG)2lf5bBWI+^iA&=knf!I6tJJd-aZr?L2~<5G$KBk=VPxX18Tl<
z*2yeagoT|_3F0sCK1W2=*H#&Ac-6M}C(_emg3jDrwBq^>Y@^Ug`&(B<3^{o!vW=n?
zzn!QWoWfQ&epTP;78b88GrV`_v2Wb8#0%iFryefl0NY4Uc-1?pDuOeY5R=;-O11y7
zg%uvavrlzueq(}7%Ls5WiC1ExLZ0aEDu^D;A(l2VL#|ia;{%SO?~h6fg7EMFg7-M~
zR)dF_1}Q*_03X8iF@6=7Io;NDjls47pT9A2!RBQU3+a4haxMw>mcCyX!kw|g-WnoS
zL%`}wiOrTF_`DHmWxeMNxl5m6SI!UFb_=+AwhEL(cWvS2%L0XWTFLXg_9shbe8jjO
z%^{9BxK7y$86wAnbMc?ey;#mIl!+94J4Wo~H#!w&2|_Z_LXC8Bm2j-Nt8wX`SdJS9
zkCy}PpjwIb440qi23?#w|KbC4Nfk?nkYNY5oPRGvWZ<3HO+<#|>4b;ws!(O4f{ab!
zZ=#}^vJtvIB6qxP%OgG#qItV{A}*+6#MSQz2vtsr4G_$GXN3kXsE*BI2jYD?+85G!
z089{epn{9>f_YAeEYuC0ApG@S#iN51fty${!$6M6n&UqS-x0|>B^cX8MDk5cdE{eP
zF$9)kZ0npdAs^e|AyD&8v=z&VDU)pb^S;)X7c{r+TAs2%aOd~r86wslOLw-+Tm#~`
z(3ko)xLoi{tlE6xJ#)Pfg`TZ0H0O&}{k^?hF%FJ)n<ddR-@7k?268(LIiOuA;jSC}
zIM^xxH*Mm2r3%zp@xP_RD?7EHm%~@*R*J|Rv~|Q%=UqWVI1-B}j#GDZRIQn>V#39D
zl2{;Z$(3w5W$LV;CPGaXu}6FIXy41Jx~xB4STFhzs#ZCWEn!)#pR86jl&|3SG={-;
zqI#rAJ#hM2@`-z6x7LmxO|z-XSZIAc`uaO*)ZY5+%*wx+$JXiNwf6O{&r>w&-`{ud
zi2lbODW@OT)Lk5Vx|;uF9HZ%LZ-3;cI^|10rk|&3J(ztS^Y`H2aP#unP6~+P&%$wT
z?DTVH-kUI;mZiZwdAAoZJ8LnOLcJSDFx}RbiAu|oQ|Y>oR^K(ab=-vOwXJ<@4V-zA
zuJ`!Y=Vv$m9>Mk7H|GC0Wz~PO^>w5~FOD;|E?<{;jI*BU)s0{K;1vF4_H*mbn)oZX
z4}Pbfb*@j$bi^Spii-rBf+#0g>E_lJQw?k}nrX5TU-QHOJDw=|O%_Q%4-(U{u3bhJ
zRV}2un4kwH676pD5D73o9%2G0G3xlh_>KQ!id>_!F!uN1xpBGGcRVmR*7O80X|77E
zBJvArb1uV>yi^fMtV){AkmS8yiZ^6Fjm-R%zUQ4wI2!OQa1GI!;axm5%9M1Hm>fG7
zvGg|8Ha~5PLziido0G(YLw`-ijMZXKU%z>EArZc#vuGxgp}l-ZLN{5ODy1ody_Io_
z{rjcl&Xv>GvYH-QT5BAf$l{%H&a1Gt(Dc4wv{uC;>U=gQ#pikj=XOQDP=2w*b=EtA
z{*6z6v7;6DS?GOKCLSV>zTf+035nxU-GKxXG%ihJYMTsAvGX&u6mi0YGtxBsYUZVr
zNjJ>{5;4C9QKh2gd(ss+)6+z&Uj<NQiulgyfcBe_y(<mh-tQ|tU`ALqIdvaiIm>H(
zp{u|EG~FuOQ0i=K4%o4H+4di?fFywRJ)>bYrYZDUVG$?Uz^oY(E&N(*Ie*}gY0Hpz
zp6W|V%cw@`_G*LtmA4PaNV+;cU8Z8`+tw9O9vU@Ef9I^QcGdOQv=3{!nK$pSWFhn#
zdc!%>Dq+JJc$Et$GVqh`TFQ4=KDsE=yW5^Wz$dfoA)ivH?T<exNj}AV!S4L9?F2F1
zY@b{CekWov!{Fv*5tI8vRumPj7v863611txbhvm7u=aA}^}M0R4AYMreoXPrrjq{&
ztmsGB0`m-K^#-eILHx+G$3uF*NDI+FMwIJ&OEaI|y%%HNdpS=pzuw|Yz<nd5jM&|2
zh>eLF^ZvPSr&PdmQ)m2tJxo*oy~Yh_-D7P2kYmZ;L5SMrJxAQ+-`%RW4{=+g_r6mM
z*)K229p6#zXy))>)2A~zaVfW(jE5$AeOh3ae9Y?GWXtlY6k@QV4T5_qG78O3sAG{@
zbCsroe_x$w#bllCtchV}>K#y+SB-P-F{_Tx7H;IJ+GN?h)MxoIKk~i4^xy~$@wA95
z79weX+W(r3gxyBGsd3>b%=oq2><%8<uX4)5$apUS<KfJ)%LogV@*gsjSDQcHwh!c4
zs|OJ_HlA4X5LBeu!SAO`l}Rd`A<K655DvouqJUjiD$m?Ap6gl#L0KWe;&z}3?g5y_
zR&YrKX0{hPWD_EL%>+85^J0%{Ok*9X5>SxKrP>mZ&dN6@OV*kWzw=4tL9*2+pY=8w
zb-9lgQ6kCjq6-Id3J77BM8B8UW(im+a*p0AZ>ZL&SkyG@T;Z*WI4vY_T3P#0E+Qqb
ze|akOW!y6yp+Ln#dCF0%TZb!`!~L!FGTUG@b7*?c>Kr2=$K2Ytg?vZBdtND7CU*B{
zF)X;|%48N)%^89+OHSe|H|GY7*CLss`j`LDUu9s*hRgm3u<rGU{lN4L#{B91jH*n1
zTj|N=P(5r9|4w_tQf*0=dKMDid~1jWr(7b@TVZ`7nlrfWT;fA^biTNV>7beTFP&W6
zHV*g$yv5I{Ajk?FqINSCw*9v<W2VZC^VVj>f4V3oN~tF>!{-ukwfL8P6nFT%y!nEU
z%u~DYkf`($o4YAfz5Ug^np^|ATk#Xc0Kk7ldu9Eh2OJ#pKrz^3##y}@j<;f~zMx*M
zlC=D0Qte!=ZG$KB3`cGWr)mqCeOm2?oa8&HN3<k|hRbm!#oEIEO|Ojz{$%Ct|L3np
zlmF+hvKq@+%Q%a6Iyxy|X7DCEp}s3cyCU0{6faMn;^R=5EU;92{%d=L<I5hOl?q;H
zrQ&HI_u<gBmxr-$6?D4an%ka}V*2%fglH(&W?3Mz8aE|~!RDcsQQbU^O^M2B^RU3E
z9^qe2Nd~Y5WNK8egi>>|cm=DDd4#wLCc#)~5p0Gj*9f75guMUXn(%lt`+AO-`9?b`
zYi~0-6XvcHwCKcyhRCS6CVJ-GkLaO?SP#tICD@;pYTA3HXa5H3A5&0O9baat@(p2*
z>Be<;aumNC@s${MX(oB75v<BEvU~S1$|G#TEOxa^L%mLgMx*;<a;LnWN$@Rj7>oA)
zVSlD_AeKShX53c({8lc@t15TA8*9!F)H2~^8BM0blXGxV8eH0rBVH=XIM?~GLZq&i
zqIwK8syTa#2I-u)#1XT#>0P*jPL8I3*dR}@=#L-VS^lb*(M_RC{Ct*fmaJ-%K%Tg?
z-SDgTw-Y}XjC+dFBjNqKMCdJ~r;BTQcgtk#t*eZR&+EQz&y7C%#03$39QJtcZ=!(!
z2nPO4RG>3>t0&GISA!X}M)5VLdZWepTjPxhFjA@)I-&03&2*(HTz)}o8HL$D$>8Rm
zCe8Bp0v|t3(r*GHkHMj5=u}1U)>h%`XWz75mkdc?*aRfVd=^il6keR%YAX1(^e03Y
zox}*^!AbZT4NrGVoRWr;@CmWZVJy~1&k$$l9)`Nj_3yFdWZHA|vQOY6nlFIZ?)45z
zI{BHZvP`C)LR7AWoc)U*YDN$hKmq$Q>T|4T_Y8l>x-9&@p}Kk|EA%iyh`ILfXHeF)
z6MC_~Kb904K+8ld)U7zTIO6SvyZBzS(zi9UrwwfOhCfGELPwEMT`Cr)WqSbw0o_$4
zW3Ri`gE_~VOm(MnIEB7ZcKM#f{*pGxQq~v|cw2aNTf;Q=2clkJ^wmjS`WI^Kp3y@P
ziekbyw!fV;!MRY;&kuysHf(j#WLW1~8wyNXA-{8<DULj87d?tU577Mr?w#4EGvK#T
zz@lSF4Z)Uj4=$6$ZJUo^mO=J6Ap-b;<tBySDqeJa2&juBxlO{hN1GB!O!1_EYcNx$
z%S^}Az6!#*>ZS(m<Zvh7A0PmJ0(x9i-RHp*ITyHnja%jxThmw63=&wUU+)<|^`Q)Q
z6pB!O?;~<c@Zua>lM2lKD`I;*K&u&kbbL-yg^f!impo7x_yM&%P7sNDM5hMHAc@*k
zW?O29G$g3`l6RAWn@>Vq&B^0(kjh-gAxtEr6WrXSFv%CXA&pERa>wxjB)$;AFjk@i
z2a9d|2V0)Hq~OFqf=)IZrUbZlSTZ9k8AOELlt#uw;3uk7?zb}#51{hwS5j)DNDXLU
z6mu#T2|PHiHiXi8rnKJ^S#RK>$5^WPqhl}A8lKDf_L2ILO_0_^z=Hx4F%m?j91WU3
z`5zkUf%<rihSFmjiIxliamd0wvx4|6gB<jrp4mnGeT=&3naMhT+%^krwclX!fbh+W
z{g^{knWsUD)VJPJzXNgUe-KF+<TW$@!{uNp5_Iic1d|O!B_|*pbBg&=^tK220V;vf
znV}q(&B)3YDk9+u5jSg4!q8ln>>T-h9>FQwvt=B^YF^OqxvaT*w_2jXTP{O3*JpM)
z9pky#l5UDmfWrat2@H}rPCWxw;8VSJtb7I$8Hx9atbQv}CVnV8fAp(A2>&b8odJ|z
zVI~Vx{t>>wUVxtk1%>}ctl$$2YHwv4g3|#oBnN6e!RdxUKH1=zJ;%EJC+Fs_)c=oq
zYVD%jkdFU{damU<G7}vB5A{rU^1HXmai1RVK2F}pQ#6T19yvuNE)H>z5txt2_)8@>
z{@@C0i_$M$VlIQHIq}^%efvo_`=tTS+lGkraS{JHsiQ2;i{LwDp6PeJZUu#17t5Aq
znc(dAKnbX_f6zhjVq<E;VgzXL4G+{J{kmo|$A^!1zQ`i?22k6zsP$Ua&F=^SRV38|
zwVxH&Cri&TB!Nf_&N#XZFbDP<)cCsLsnvx{OY*z_9p!{kbFY9Olbj1Z$YYW-ZTUZv
z)22*tZ2TB6rB}DZhRN}QLuJe;&i(jQII7}=1(I*5T;ORLV}pJXbIMwqPN<W#10b|H
zXf^=p*|s!BLV6`hk=Y{0?xuV-%I}!n1cZVCwxVPHa)Yjmt$HEFO`JxxZSdsCRQj(H
zBX>M<Ja}d+s>6neEtfowfwCD7)Q_z4@S%Hrj>%hJ5$Q>sk>mFg1Bk3`7c1!;4?-QN
zt2LSIwb^pDxfZqg0kyYMYK!V>ONMIitk&L@Bbs2U{IhOZKk~scL3;aGo$&5{)5htc
z3|JEKWbG=ne!9*r`vkqNKC2n}9(jr>p0l2w_dWtT84tJga=y8P5<5VoA2U0KWe{e>
zQh)WxYQy+bUfRR@nFD@}N#v_>w@hyEt8o=mopbi;T%CK@e-&P^-;!Lx+*q}MuBFsJ
z>AU}Dh(9|NMrvXu(%I;{RTviN=3G|k%IO4Vu6)d?P&#<w%GK*2z<(U-=b_F17Xkax
z<VJAX8)}Xs$m4aPWv%Q%D0qo)BT(QfjDqqtv-U0^kOKB6AGREPYf&lTeKOswBgDt`
z_R1Yri==UwrZ=47(Zp|G2gh1Fc*WVCK&IPp9Cx2I1A3smR<N30SiDxE1H*aFSekEJ
z>05WTu6$d&t9r(U{338hECPNM+HyK4UDTF!45)lL4jYq129~G}V{U}$!9EfmyCX$4
zO-`DqwO4t%nJ2dY&}d7w<b`lShC|^qe85`M@uiK$JEzut9vfK_Te}v5w+1D|(!ARJ
zh%EK=W>rI4{Zn_MNQ1X{FadH|$TV=K&G@0KqAiO5z?CM{KIkQB<f&i5^{hw2tv>LX
za~PJ`#MX*|tu-lZVj%PEIz}Z=+=jW{HzAfH%%ME^PaVoPaA)T@+7_=q`>Mx#7RQ>$
z3rt|1XBu@Js(HvvL_Q7dSVie~8b50>6g_$6r6JGDZycREWlCY5443zmCt}3&GDJ9C
zNE@`Ryu@)@kn~j0{xnlimtpgXZ@LZT+b<H0?#X3$C>R;HhnpCEZM&cN^6`x>`5^8=
z2bPc)&YwTD-&)$31#(T*KX)&2qULo%B?$~llY&C8CKgt2Bf`|g8d_X}@n-eU0{b=P
zPsW3-VG<@r?aC98?>BlWgRbT*XJqTGTEbn7toqe#dA5<9A5@U@9*;d)*eQ@#-=&nK
zuXAz0G#*`R`oh|^r1xrdGtLJ#ptuQ3=gsz%GrbdfN07VaoJ5b9Y81SpBkk~nWW$M5
zi>?+D9i)aq874@^IGdW3*-Hl*0;)~h>&cwY#gc|0ro)%@Ym6Z;%cl<%hU@FQ9|jHU
z$ooBR815Jue!e#R5;oGMFw$c+(ib%HDs80A78l;x7dsD5AJ64da9VF}h6_LCy*={r
zwgfQ?=HrE08xPmQM&@3DzYm2kKVy@@27Wy)=l@r*uY*hbhSl>W<LRK+;yB2X4e~FL
ztjSav`V8^Wg$q`5T609O;*e`v_vz%}`9CqQ?KY@S$HBy=V>%O}Lx5xfY<^NOvx7<r
z+eCatWsB`=1D^-^pT^d|j!%Dr>gqVLgkuqVWEq0rceT;RGHoT>QB3n2`8y+S0*Ibf
zD>YTo#=wW?`8lX~mLwI}CnOB=STre~gDDhd-#6wy&VcrH!iPNAmY5*6!!%|TTWb@0
z#G$}Z$zYAAyv|pvmy2Vk;3IaS2*z9z|J5OZs~Fi@9nhw1A8?Nug~$=tZ8b-Jbp+?=
zA%~l=5ltmnA)uiZ!DttZOW|4+YLC0^#L4pE<83e>maQxvzK=&tBFD74L`=^kEwt6D
ze63a5MS~r6U-C<f++*#y1Z(#QXPUDpIQ|qpHl9`ZHj&{Cq#AV+r6m2+@vvf;tH3uG
zF%ZqoihIMcz_%dIhA5}Zhl->X#!vAbM@JgELq#rzYJzNG3kmR9%qg>zAFrizv)%sm
zXYJ`(0!Mf}^vg0Lujt|oX<EFT!ccj4aE}p;_srW@`Se{f=FuO-jg4M^r1YpFt6P!k
z6F^9;K|EdfOZVaNfzJ-&8OESf_wzq2Jp9nJz&91IRW!x9-yEExi4<oI@DVQ?-qK;2
zXj(YI*-U#=o5qd2JwI&)7Vz=~0HY(7-2Tr``NG};bc&J^@;h%2lSKwo=#`6(EVsA*
zW5it>zkZ@G2G8;2CssYM{j{$!Y4B^@VFPC&k95T&IHJz0!mmdz@-g3E05CfDYr&U8
z6zu2}hRj)~_<L#moZyp!RSKP2>EAvIC+={+6F)aC(D%hcRPu~9(#D#_J*~h|<ytEk
zc>4_z8R6pZx%9yU#eDLk|MM^C7mSq`R!~zEr#FT*$V1^bJzkT@8h{5E&ou?ufPEd8
zrPb_O9a)0+KE-Wh(yL?E#~}^?aKi((^cZT&l;N{c^o}N&z{&&vygIGGD&^|(v-1=~
zWlW2y63#S3^n>Z)0)JqT<BG`NnEdrD%de*pe>!DDy1|<^E?lZmk-dq^FgLxj$<L)D
zfXy`!Nh6=mZ8nSK-Q<8xvhQP_2qs2i<qTl5<`qrBHVN>Q%_s(PlnLM%w(F>zc%?@g
z2j3l?u?1($L6bT?T$x_O%D%j=1k<u0kH@x7uKzYbY!j5Xjm~bHT;4Xz+&=wa+w%4H
znf2|nh#gzyopWb*%yStnqJi@9b5N#>JLg{t){l!3l@%ws-fIxpSdKkR&-WrkrC1T6
zB+Ra-82g0>+hh0v&^$s@mzzg0_U#jiGv&XURa+D(cOvd?mo&i!v-Xk=iXUic1awP%
zfk?|VONStYPUa!Hk+7Z(j^c~E)U(^|%#{7PI`wARxp`Uoac?BoUXyBz1?0eLUGu02
z5iG!c@Yxhrt}wy{q%=FShC`c>V|Go@K|Fkx4r`x-vQK_+I0mPi;63=7ze}%DI0Y(?
zp?vgT^Dp{-Dtw8JvhrWWOPy4Gj5tm)Q<nIFj?hSE0^&1@`pTneJKoGGrY=u)F9`$D
zeeur(fiwXa=1ew}fwq|a1s0E~@p&T}N>X!eXT20p{;>O1o(pq6-Wkn==IBhv3dJ!^
z&#UdE3Tes0n*VvVuTP(#YJ*@31Kf+obV4Ghq-$PTZQTCR&%clFXWQ1;R#{iMzFT!@
zaCsE+b^6^8rzT=whNRp3HJ4U@>0?T>Ggy&&XSx9X?X{Sj?5o3nSNgNg1Fk{W_&Df4
z%M@|2kIWwJ>176%Of(M;d}G;6UkG=-Ltw!Aa@<i)nAG{{ZU48m4i9`kPwxayH9zFy
zky#PFIGy&&@zZ0gY5nR?11g7Td8r;RNr5)Drp*tA(`o{%s~>-q4cu*c%taJm&Z-Wz
z`h9=$0%P{@`u6vC4=#O~{dXg&u!{1RUm5;w)bj_`cW=F@fO^E<fbE9O)E12!zUj|?
z!W<e@(l&LxO?h=IHB@!4j_jkHtG2yigf!v_Gv=~X&z4COc45y0jB)klF|LEX+4I73
zV`WQLTm$Up{it=ZfKI>c7Ej}HpSzI}Gi)8)iR|llGm7)VE#&H3w=5Ly2Mr6w&DDC|
zgAUgHXjBn#l?L1d%f(B(J0s))!@Q5uRkng0@s(81{bj2@^&VwQYUAl4c07m1wv92j
zL&QW4xOn+45k2&?uTtu&%x!=|l!1l&sU>5`XgTJL*lAe&z#?;v<lRWY?hI-Cn+<6(
z#t{0^j-&gPcUPT$1L(24&JusGG^lR&SUtVI1??3&f+_e4+q{rj$+|80`&FS<@_6o9
zgARwSUiav-1R8F`{L%xbD2Hq3BWJGu`CPu@0nPnn$2<HqHAawz-OBS!5xJblfzhGP
zexy~O@;<m{UMdxoKPX8Iwi~A`oL;@_*A{=xD?@L0&r5E`d@!3h*ew|!rPiYY$mTTH
z%j(@^>lCCSyQHds-GEm-pBpx%3rDhA6dvvk>DxYF`S;`!+K>==;9pZwQ2Z#`?Jskt
zp!g)2Q;#_r)JcnO;h#|9{9c)j?=OuGZkvhx8{EEFa3kdDkG8)d&wjtZarwpH-M^O^
zogn_0&~6T`!_Z!Cr<kyQp=*a>1LC)0!iVG^ABK;d_z-htOz+R(m2o5f*oa9>t$)98
z1Lh!^cP4pz5mR2bP6ik?Jn845)yaHQ&Zj;p$KoO`Nw-GE#GO-c4dGhp_H88nkgNFe
zJoMo5rN>9nBZDg6Jjp^i<ZnqwxjZpRNA<JvL0fG2tWO6vDTj5@3(i3Y6}?9{53&4}
zcPjIf5r5*G#X0?<&VYGX-g9VHye!t_W~V2-m<MF=e)E+^Q+d&T?V92Kq6dUKDKEyx
zOPH}DI^0hv6FegWd{vn*wKLBRzx_a7kgZei=Hpz)(KT|}^wbaiJtGVkCu#_7%m5na
z5ey9$1T5PHm{iHk+XEq@pl7)6qWdIMSjkL#5FFYNdfTN*F=>xgvk{eMq%H##&`rb|
z;%Od134;Dy@A(9Yun?IFuH8k4ZStNO{vcgYB4R+IT?R_USJ=bCdL{D61AvSgU=h~q
zJo(|akBT>1eF6(mHpQzC7c61KG8MJKte8$CRc~#Gv_LuR(R|%aQl*dL&&XbhtyF9P
zG+unyu*snTr~YjFYp0=+sN&?3*!DP?X8~ox(Xt};J<3G>eKyxwnQxT4Vf~mZHHn-8
zApUia0o?nqiU!kmcYZ_&vRI;Fwzf60#6oM8LOY7`ZGR!6M~YHEqa1bFCLFcOou|<@
zUU!vFJhzkvDLa<OmBxBf=~IvrW}ABepa>jCdRX68DO)z5s}%o?RubWY6$5ni>1LyJ
zGHEieL0wD{4%g4!XP2?)iF<2f%K96h>!?l9KblJLR#-&juzGO4@isq!&Ph@?<~_IK
z%)fJJY}eqM@06fGRLI-P0}h#ix9oWNX9t<4<Hik1HWoI0Ij8LAYITaVO##KS7Y5pu
zG)5MSthj93+<uh~zn8^WG+N}olw)(Un!k}kc5B38qjlExwF~;VkK@KtMRe`nOIyu}
zr58Xv>Vr6=)vOa~8Ckk=UM?0#sEn{qzP3+((;XIV&WumrA}xMJ3}9~>J9Zz6BVU}c
z060;(o+^?^#wW<@xh@{YyLW;#nS6fU-+6IaJHq=btmXoqIh@G>7lp25hm78sMQJ$N
zZA@8mJ?K2v9|-Jg|B}?We$U4BUQ<BASb^y5%p3ZWtwD4)^@F$kaVkmBJ6p@vj#3X}
zZ#$|6M0{|VxIu(HNP-5)BnY-|BK&GduxBv5Qh{2rTxV_vOf?M1VT$LG?$a$8fymZL
ze+IO#iai42c|E$aj`N8+Y6;F4{xD^p?5#xf*YG~*eUH2A?L2g@04|Ha;uBCssyi}2
zhIkrmr0w2`uS3u1c0O}~fHAF1v;;XJuHvXp2BCz>`6u|=LNd#!xR@;JVXj7$f*izk
zyk>%h2#3?|w9iv&6ke?gmalYutC;Yy^_Hr8eEJ@^6VAu;TJvqFFhCI()93t-Hzj0<
z5kcI`4Yv-#{{oyJRx29QKoY{(B-;4&`}Pnx(5}*_Oi6!)B7$%m$hAlTOKP)k<ik7v
zg8a<frr%UYKDr+p9CXQTX69Su<LCc^L*uMJ#+fd+-?s>fxa;=$oA0$JpYQyN?D_lo
zN9na^-xV*%d~y4-`|aBEe|Oezf)2m@6^-g-QwpVsxzB?yMRkdkZcvS4X6GYk>Rp33
z4@l~Z{2#RYPtJyAU2$I$lHPx17P6I-r2my6?W8kwem1=Dq5C)ad;7zeLVg#&(qGp4
zpfeUbdxieneML|D;B`_)c*^553zir6dP>H&X$I$4ZSOsOQ_p#|{*uTKx4Tc@cZ}`S
z$DLmzN_V`>9c!zAJYNaWI+%WQ6#4ko^Pg8P-S|9j{ikE*{IBR&e`kLmU3&?6u^wUY
zcY263R6UEh_BGN-hz}9@K&T!X4oy@|A#fN{?m#m_Dfh8VNw1Pb0e^Y|U!xMMc8KA;
zYrN6-(b4D+e`~qhLX8D*aW@8*FKoAedHxHbywiO)ctc-@qTZyM;^a?2Z`cg!reG5t
z`5Ai#PDfY%Y{!(%FbTb%I;E-46m{!z`QJ~{3<H@J>BMuI-e{8=vc`bH5pn!>FC6t_
zBS|TCDM6h(<OM|QQ)q+=jg?OhcF<+8<^gi+%%h?q`gAypJ)Y`;pWcv(+hd)1XwbE&
z2WNQ+AHj1T;t}p`b3f3H9H2@9F8>L$zj^UE9V|Z%<35D>;I(<Z32~uaaWlyl0nj*e
z&e>G0ZW?WGI1MbHbUf}1jb{bu_h@KH+#BYZ&6@LjU8ECT)WWXsVe(0|B$ZHY?K$q~
zcB*xJ*RL+ak%2_oK$31KhdKqS5y5e`3B0oj)!sNM*J`A{cJk!m$x|awQEA05L6oSy
zY_FPIw$AK9p&-q@rcE@IAkj->WIr+b1Yx8m6!{q!dC`;$S<GlGO1Lym^(Wf2<KKB{
z3&y$|$vAq_ao?|E4Zn8<*er`;8qQ(_=+e04k?J~x-t1^Bv!ielJ}Y4Y3Y=ciQODd9
zt~W|s>7&XRH>)Owtx$9;6RaL4lCn$#Sb#upXix<Hj&qVGlmJtBWuyP<ys=rhy%}lG
zs0Q2NFqP_uf$(f|N5>>7u>fvUsbPM{cPQv#b6k9fnMx>!8s_26B`s=u)+Jo>Nn`02
zT}qf6?LxUImMz|CLw9&QG3oGxcd?nq3BHsy<%^sB2|rSgJ8#JwxtXwmC@)S8J*~o4
z<wFc}fM1>7n)w~ZT95wH;GL1v*J6sh^eDan1s5uvy#lJ9VkLQiQi<$(GR)=b7RA`Y
zqH{xWE3Dajm2tG8Gc~NbQ5D|fR8J33FPG2}Qy*@C;!3kvNKG^c07F_Lp)=u<GqvU|
zYj8~>PKNvdW@(HbZVA%(fn!O12%@ee91z-^ZJwBRvihK@7ifuIJZyY*2C=o|V>&DF
ze{_~v4Zos{$z^S@)yk7v{UK6UhP-*Q51RIsJzh0N=Z7Igt>*6A28-O`a)&AHS$C^h
zoyMzHW(&gBi|VfyjIDDxEba}SbRUA5L(@kr(<(_UpF>lZ*SMoot>d7S5h!K6$$Gau
z(T8DP9F>)@7?yi!ivV~);%u-~XW8J5%5!B&&)ca!dubK`;D9^(+xYbe%{-sPLIlJv
zA;Cm6c-`HQ8pV3`4VgI{8nRNrU2F(1R!wS$9AXkOLutM=Z4Nb~QT(7+RzfBX;y<W$
zZwP{?Jw~2+tk{$W)EL22Y^n5#?;jKF!oYXeCT?#}lpfk*;db9xiV#b6pQ2c+@W<d>
z{juU&rIJ|K36*ew6`Y%lGf(&wnjn);o=0T{qRV1v)Y$LPY0L?mwB$IIj8biCOyT%k
zolM*lwA;pHm3fNF8FsZ%_zyKow5%!3&q@~Gb`b!nsk~K2vfYtM@`O@PFgC%lgC<#q
zZ23*Bc2MfAPMVwy-E*9E)}KP}IPJ%itlv~ab!I79lo5B;u@%v|GtQcJ!y)s8O7u$i
zlDC=rbBFUM$J{@6;Qpac#aNH-C62d~mHi-b8^`u5uHP9(<Sn=^?ii<Xa&(;8H#X_{
zvF^L^=xR-#?^PAR&zu<cx^o=1FF`ingj}M5jsQw&ib2qsl;E%AkkO=kZw{s%Zev>F
zxu^QBbXGmT)Km&o-;d+5EBK8#bN3we`$zNDkA$GZ6Q9`RA45SqWz@tQwwEWmtz_GA
z?7*2Ct@M8nF)?5=y)@_K$FN}*Dw1*+W>*;NQp9R^=g=Wj)~u4T#MUUxR!u(^5ZUj0
z7m)`(noH<3O7NGqGt(8x^MjC5EbY8Uin_`h-+XebdrpM&xoj1%g}tm&3h3ssj7F&S
z@R+WQas_D93cShPt?d*xV7r&oTYQR4heggYmtxq=A6cdJacX(cZbW4q=u{c3sHka|
zU6s-O{PvcqiUYNYQu4bO*ci)o`{ej051@nJbhuN;KV=P<zp=NT`1x+)^SjBf4($(J
zxMH3yr)4=o(@m#Rf8i+OHin_W=OGo3KkPu%2Vm+o=Z~Is(b>|q{T%!KQg<R$!bf5I
zm9Jj_C49W#I3#thiaNiOw2+Qusw$mQxR6imc5WxjF|r=;3qyCh5=UrxY@=!HCenG{
zG*%S!ap(yx_tN+q6C7a)*R@lm*yBz1w7gRiZuDIAvc(3PPci$_Kvb=irJ}+r7pUlD
zQT`lMO7Pw1LUGBmPXiPk#Uw=lIA_Cty3nrQ&q4l-4(Aa>cOYFKNz{u?`~;;^Fw9&b
zP|eeC8hp-?%&A&Cu4f2s@>$G9Y*hY?d4X@|s2gt%2IbpXW&20k^*x{#18@fE?We4_
zj`d{otmC{b*#8Onh6gk}>%QtP6^DH4$XnvMHj2|O%Ax6)`?)xZ6gs*+8u{#g(Cqd4
z<P(_-;*<Zp-mrSV6<K-{o6qs9OpM2|O@&g)Ah5JeNyH628;+VtY}GQ|g-E`IIcHe|
zo$vc2IAlHef(ldf%h;j<Qm+s$KCVeHn*c|^>w)n?=jyXjtbF^>Lfih#7>A-?j|RYr
z=2Sn{kpUdF50T{am=G#Jg(kMCu$iYn%MMO;ybjsVXC4}WJiGrm^D|2}{Imf9q=|+2
zmx+cpriEoZKI8Y1?WPBN$fd}e%j0_9QC%)vT*>ltcVqT!RxFcJRxLl<jC#>s^E#G4
z)G?RJB;C}UaqOhMnoc_4b|qzjcGwEYXe<#4wRU0G9?b*hn5pe#T>QNjk<vs_=xDbU
z+0QL2dZv9RSvo}HIva2a33bFt9x$Ga<S*JWE0E7af#^=qi-(`c9wvcP7E}!A)*?A0
z;CM(*mYPn;xUpJT@s6zEO=w%ij|CVynq6<Z|KK6H#t@{G4OXYswXGyRR{@7-&&D|`
zHd%w3tp{7I6I@cYT91-a9c!OEEAFyWmHj}jO{rJgN7bFd#z>m{c(QS5Q_1N9pVL|U
zZ+W7ah2Fg3S^fFrC1(&%IENxlZnTBc@`Bmm`-RIyLx@A0yv^O1P>NAJKDs6l(8hYj
z|A?`#4cnk7(}_mr5|5D-J0b*+;n&xu2JSt6oDtZf83;hpaZ@ac7_yN^?lp9~)ewY$
ze!R$8xKteotYi@|ly%0@FO9VjD)jP(6lJqi6fcvHxVn7x<~lp|@}FOi8zXPM6jHQ#
ziZ+l;xayH|1>GAb1JOW34>i@RY&>%pFIUr&Zg{XWiP4lL6*PFDfA%4fbKq0+)C@F~
zc#s{5e3X7PpUJn7)^g6Kc!Sg=OQRV~dw6bBOsIZVsaF=M&Pm50s{E{B+Dd6;VGj@=
zK<=yo+LQiOWfgj%k~hv-G!YMejuwg6N3@Sd6Sim@=b$mrC^Sv}8cpE=zsdmCsB`uH
z`v6tt-}Uc153Jh;eo*8siwU8}ZZKpVlf-nHL-R4AIO<AV>TjI~zpcUPvEx)$NwPXp
zBWVNdk1D`1LIpa;!FqVvw4dMACyt*eDPZHCti(MQwrv6={wS7qp&i+~4bh;NDth$U
z%4jLd^t0zA+?#@Ec4ltWmGw0V+?GWPbs+sCXu)(!><>!v_!Vd9BDEbNs@HDykb2|M
zZx88pns$<J0o3oo=?(wO`_$#VvEBXI-5AR&k*F(9nG|gx9|`*t_9uD1nN`yR^yUVy
z5|qW<kK+8eUD>a;;xEV5OMg`Pg*2KHRH8cWcYz4;potgl$9{2~nVAZn#VU)%s2x!z
z4w}7AT^J3}0>mQX_hPlKs2TjuVC;R}-pzcvo8hf2>3+#U_j>TF$Pj65&6V+(ad6Js
zfGwkwYGRlaCUHF2-Y@vF59PalmFaqes3>|i3i`^t>`zq1EghA;MBLr8=XYwZU|8MG
zN7pa!)jLHuTsEVB;k|qJa?q%EkhFC3^7R6PzZ}>EV|t>+)M?A{#E~D@pP2o9aPM!y
z`oZ~+2lW{Vcys&v%Qs%0jqZAV(DmVO_lM|SgBWD*jq}YnUTNJJc<^`N?%%<<n8BAZ
zLub$Se~B4ek9p0A8ArrUh{aAS$G$O$ee1+y)RvNZ1>scB-Yb`q6;1n?+57fotZ^8J
zb352?PQ1C3WyW953!O+3NxgOhdS&=?m{7{sxbzujQJ-A)%Y>V-6hwGO+K&&`_@3Bb
z_qe7R&Pr9Zst57eNzkNy?$oRf&h#0!Y$5j4E9s62v|X)~Keu=e2uJ&8<91&%eyzvF
zLouP4E;1N_v#JTj8j+0wU_3{u(;&`C(9;_|^5vy@b>#hu6-DvE1O&E}Wg`n?L1R7F
z&0=F$HIkzl+~1(1B7G)D@%%4}`MG=eQh5+s@*sC*wA%WvVY=K^xp#Gr4?IWfuF8LC
zyzr6?myg86<A98>98K#NQBBW}s(595++M_acU#B~+hgLN1#_(CGrwDRrjmA;HRZMO
zUs_JFNrwbQmU&b1*$#fXMV(k4D>X>qRE$>tK3RSCAxjp`>wKJJXUO*BhqisDX-vY5
zgT$Y%O-4#gQ7JxV7C5g@)JL}0_3jbMjIG#%XHQ_ycH-e`*H#Xr?em83-!&E#SsZ^p
z`&`~C+2&-_ubMACnaXje{vGVDFJ46ZetsENy{h!>o!g%*-XT|#ij>v)z;`>tfhJAA
z&nk@C<Q=CQ2PBH9Ozf5Db3)*Les746qbDIHJ8H@sluw&-NEdjEOF{dXx?Er{LVMA4
z8w>Ad8ZZk~W*Kq0R9+fBe0Ua9U>`Bz)C{+0(O``Hc9r3&0u9T59{{s^Z9pYTG?t*-
zX;!D1_(~%!MSSdSf^J5=E&h7a>20Lq`6}Ol2;bfd(Z5DrmMzC5DfhCIaK$y{sSLGg
zKfer#eGZ_gVdqwSC|g9LD$~+$E5NOlyHnR6Y78#ibjPyl1^i1eN4d7<W*P`Y4@}X*
zpO_aUb!<KQ;gd8U;NLVlYTn@6rt9m_sPNVNLUZD-pF)zt$(c|0GdxS~x6Opl{LJ$2
zU3{(W2y|8kHihM-X>1;H$7>N;vdlUjAbTx<qiv>6J>hh+ozl;?=G)ekoWxmrd^cNO
z+2dGR==Dj5dkx|Kvqcl#iPj3ABi;wYMCh|*;g$jMTz575v4(e+5*ae*K1gH(;or%j
zCX1Dle_6&M1hNee8-;;ioR`z?At?|ZnX*;1zOQrUo)i%+*>3H+Am#by9OK$G@rO>i
z*M1T#%&M<W-AD{>`FN?~PTO=w^ttRAp0K5}+82ViU(4N5C-?W3wx&V|S3e1{0~>pw
zVVlbn;)SJYil^Rw5SiI;Ui2Ou{QsCb6K|;g`2XKoFvd2+VC*wv-^ZFQX0uav5*hoN
zs7OT(#x8q8lr2#dp(GW945e%#RJKH^P)Wjk=kxpie&_uDg1P71d+wd*`}KT19`2tw
z#!G#j0?gVw;^5>X@8d3)ozq&mW|p%%bGP+F=hyq93he&vt4KcMaPQ<{O>J^h3@%ij
zRD6;pS^dTAet^gk)0q*QiFQ40^@#h9{>9;MdrAMo+dS1@dbEr<yM3FQg{Z23rk&?|
zvir65<FkLMrT=CM5120u98R`LT={fkcPaJRK_5w}Y(8D%hCkkHv!8k<3H=VX-F#T@
zGgVJZ$_=$sF|J2XLWJiAk{;a{eah0L<0P@%)^%8W02c19%%J7Hm4$yw7NK;2)u6a5
zz}~v3uLD{AJ9}Zi7E9JP5=p<&UejcK|D2a`St^rMB6$*)HgVAgnPET?t_!*7_VcaZ
zo#}qnpv`!BNm;R%Ar^bxeS)RCB@dFKHBGtY_%|_D=8KMPJ^l6=7e=z}9P06_Tbwa4
z_B2+>viS{2J24}BXaylAl;zl*A98v*w)qTG$4|SkY;HN2AHsbkMnKi6-W*sQRZHvu
zNnDs4(4QC)S<+gSnMOnXiVY5nVWUHr?)v?{5!)`X;H2{03n^OoR?q)S=C$6gTbc0F
zHb+Q0Wn<+*dD7_>n)5yUEFUH2v$IvH`gSLkuWw3POP3mH1@)JIYOM8`upU0g(7CY%
zb)tJZDzyxs!Fuh%)3?^%Tn6h_mSes6%+in0I?t$b3oDT&zKo<5)ZTcP9P(?Y!93GX
zw?>?!UUC=U%;pZO!AU7w+lGx5R_oqU@m97y{$=bML$^-5LfJk%Z2bD7?ro#@%11AL
z8NUhEt0z^!B{0#jwp&%a9*OMpvrP_lT|NHazIU9fzQ7vzV`|&1QnfpWTmxN_Fz)FP
zskV_)U1pE9z9acqdx1++c6*a4>8@uJ!>yG+K+xOuh5J<`&xmAFY!V;v?cTC5-b)rp
zRq}BQ$rr$1U5EG5SeD+?zS(l7=IHQHC~oqB@ovbrO!@B!H*-(=LvFd^>wd}V43KC?
zcJHY}87X@8zJ;1fvQpN&mPT^<NaYZmbPQW*K1VGiQy>yG`1Anfe*!Q4VzEruNTSEr
znS~eI9fRJHq>%9A-<+l}9dEyRUN~N`c3M=YM=CO!qaeFfJw%dSzMoU69`K8o=QkLq
z8?*{$U8ZLSxTmMiE-GA6arh)GjD<?8Y)y^AdSwooq$ln7P`R#&#4i7WQ&v{^oEsS^
z+=`gS7l}vlz&*KSkC%_N1-Z_a?8wwH+08aDWL!6otgn^DT#;iQXx4)Po7BoxUGz^X
zGGHpbX6CRimgfn(Q!Y_rPZLi_E{Pp|$K-5i$%vMu5z-C%>OyAcO#R^<Fg7G?$Gq(1
zl5k@zF7wL!0ZD5Mc!w8+|Kz+yfg4fSc0!&%te!{S%9-~V4m!d@=vL|Mbvm5(fS>$l
zo?}PMIfA;vKWtT?Zo^19(<PF{WoYRg1>(Z%R*PzdTOn8TbE9D-{z0oTIXoD)@O>N2
z@%W7CR@Z0KS@EgxQ9YvCl{FxwY`o`&SPS3QnnUpN<STtx1Iste<?e-dk4^LM`l^R}
z%20?~`@9LCL6-NKiMUd$`P5tBtjk?B0m~bf#;3h_a<Y%BB-O)2YYES5a#qj>)10L3
zZ>-!)tl80ft@G~Eg8Y{|9FsvI5X)l60`fr9J)T6UrBQ;AVN{<j2tyvwBKcHa?Uk{V
zW_Ep5&%5|%U|BNJV#qxQk;&>^<TErJcFjR#A5xYzxqqH$a3GL78?ef*lrmY^(*-j7
znCCl|rH9W1J8M5wHJ?pW^nix?8-hiLlq@u<$c!XRwa6fw1uSj*z;xo4DA*D5<cnWg
zL$|L?^n!rfxzwyVv0foMCLJ4)cI5;n2~$$p|DNkK%p+bKxKhc%UO!Lwiy)(wrPH+z
z@~4xR6Mkg5b;L^|X)V|G*TFp$H87DrAH5{@c%J90_s#SZeV4XBKnT;0r(y?Ly?(+}
z38?zyu<-M?Cedd`>0Mh3pR+Mwje~j@iydBpu9-ggzv;Bse=2hAsmpA7!AMbAMQg{K
zr{7s2U1tYmXj_`Kf8PYB?+mg8ehSF#KB&I5^IqU`l84N8#WmJ@A7Y5iA8z`e#G6ED
zuj%sf;PN>vlPKIK;b!&LECkFcmMRiQ-d{x?qGagxdC)R=<<v?DY%`Df2^XtG9o}RD
zl&lj03YxG_Sg-@Eh<NBR`~<i04n!T%R~4E}h)6b*?A1a|o77&HgeBv5=1pL|c-;kD
zb2<;BlDFW)#i&Xm4dc(8(sW3d=0F44y=F9D=_^>S3m9|SJl=)QI@Q)^u+wW5mEvIH
zg)g5agb;`J$)nUh(Y9o>BC--i%mUG4N+>6IBo+ly*bY|7#$>a;Uj3_mdTJGflFF2-
zO1RsiymX)RX}U}SU4EvV090cH{jy@Jho$^*oZUDh4rOt=tTaT<1}87lH{t3XTz)KU
zzgJ(EL3B)U`9xN<x`GD-x-g0%x>wT<D#h82pXfJ|Bx`0vD)Q}A8&jM{EllNlJ@Xju
z(+piWM4`=X|18+68KT+;uKz|h;G{(!E+L?MP0wQWyCzM&dUfQuQwStAklaBaHi69<
z#n<S3he(0D4ITPC)spp!1btktlSu&;@=MzKODr8uKoY^!i(}63lRctS{Omll&`{lp
z6pcKJ&V;#4<%n6jII+3MlaQqB(QDS1tXFcvVj1+LPf&QK&%W%Y{sH6=qyNwW#3YFB
zpaQiyNVee&1c^Xx50Y)cOndw%!mDMoiDmnh<s-!uH$lqL?{40}En>Pv2=$mW2SJ-=
z&Q{TNwg{0&Yyq|8W1w!H)5&(|_j+^YK-clEE3b}saEd~4hvJFmOmBB4(YuTMkpmEg
zb_>&OjrZimD9qm+GyyPMSd2x!xFU`OnZD+e7y+x-dYP05sf{FId6yHqk|O4Au@y$J
zJ5WQHzQa4ITF-h*=j+T?gMf`X7GdI3#7ZDA9hA?<uvUT`fm7W^`lLh(f=|<Rc#n}O
zU=RoGaflabk7yp1aV19T%G+yr-4r!`sIO<D?=HkoWkp4SqUG{ACZ}4FlQ!BQckTo9
z0=)0sE;(*;DsD1Z84gt~3MQ>C23vuU&54qdNeV@!KNC`9E|7He=qfD`jmXSHOsL>%
zayN|bPb_9CSv{#tF`FQYSNgbb44XD$h<iluS2EPel#fhVVrBnf1#TBkg61;B2toPW
zFc!WGOAS+sUcdlFy+KVk>I0YsnQn!teS`p|&yQ^-<+=5l6m)lrL=4B)e)5*yD50oc
z&*V0#zQ@?1;+P|xb({*ty|Pmq>A^OVz3V|1Y7CQQf2$9DEN)5$XLm;3YGx4qrU<3<
zhOz}Ztn6MW&=z`DonFOQiyTz0m<hE;-ytlo-N=-K7*Q3~&H45rhv-FaRN>3^{A4Ro
z;yej~`+TOm<T!ud<$Nl$>$;f%*m6C|&y_-qPKiGt=Lq-7xj>V6p%@pscytirpclbO
zKt?84jxfyZ8VIoRR>8G|#xP($>4;?6$$|wl1IRIlO3>AXjx7$3Ma<m`s;Bv(1@UYs
z9ZBi5M;Zqpt)1O=nqGP@z#N(^O8^V*Cd(Uu->6ZNqx(!qnPy!fq_)HxyUEIk6*H(n
zJbxdnY2}OA`W@`AJN+V1_4V*-Kj>x7?mD7mH(afUKWTsyVAwDTY7xEK(7_{;eKw7=
zE)g0|?}Jg!rNl7TZn0@yiuAl)6CXYI3RJ8y<vu4(gSy0|lGG}CdCM4{_0sOTpAS=q
zl^Xk3+SfhNOIP^&w5Dqa^Rk!t*gr>ZlAg&6x|@JF3D_mwQX-RVkPYf}sP|0L3i(5|
z)tq<}0rQQpOk@LE>eq7J^8x^evJaCKg$a)51r!5d`3A|KR0&G9sv|@ZZS*N;Y(ju(
zQh}F-MS37W`4(<}5^y<bNx$VH2wgr%Ue@nlbNYVcwcVO_-&&A{S43pM1r3&U`S-P+
z{-0Owy|4asH^%9R7sLx+?bdy3v%>w!bQWPA^qNMMbfKSzQzV+RsF}P2FYFi1m$+k7
z67PK^N|MaW0|7abx!egkoRm~^R;$QD-7A&$#rnCfZwZa3fM$}t*N=K_{>ZKRB}5{q
z^}5~Oso$5Hp78ha9h3OCRoMIf?xzlD$1g68APRo{h2Ap%<(*{x4GZ$ROwfqHm~!8<
zHgW|DWct0AmtSc?82z`iO5ru07_wmywQ=b}HCJ*J%pJ;oG1OvYox9Zv-WmZkH}mv1
z^9oUt3M`PdiDt{mv#0wfxs|L(h@NpnOi(D0Hz+z`UK$Fz`S?9Egk4izC!^hnMka1{
zN6eGI^_~-kN=|Te&Nz5C6M+tqKdGR|mE@f2Z!bTQo4(AOFr!&H7NT6;IxtSLN{CmU
z^$E4LVEMHGr8U!a{`&@7qPC}><P8$`K)2<r+b@M4le@_?*mrzA`8B1#CaACR>FI;F
z93Cpr!>=@mMXNp{D(jrx;(uxgUD1;MD)>Jk1>IZD0bxYu1N#6Kb<Ll(i>Ju}cQnXy
zrIRU|0u+cTCU}{oIRZkWK+<-7o6Dl+ybvre*jNbMfTxSpnzO0w*bWi%5%Te!d9yeY
zCM0=wB8>S9Y`H3qq)a<sN<r<_=}hzp7xl=+&FRQBqEH|fGxP4dUG@x&h-u@qoW5^1
zf1j`?sxq)*)=WB%PCBghKx7Dhc(!$Rxm8sE<mHsR8tH{5XKW5XDURqn>nJB;*#?$)
z3InVZFGfKu+s-%%B~1lU_5$eGDEgtf6p6N8vu?;CMGDseS<$Nx+iXivqzG3M#cPRN
zPLN|Y#N)hYLE>$(`gD)N_G2|M$0dK8Da9D;#CYV!9Q)UM>^9L;g6`}O_4?WF1JQS3
zCA)9|uE+J<WTCz<fBQU2aXS+O#Ocwj-@m?O@pFZ2+MGq8Ku~8mw2A`@=)Xv-9|*OO
zcbwtC#_+4<<?$Rlv57T-g&D)SHTO26VbQiH49b#x1&KeV=hnoy@gVt7k-G0b8OueR
znGBN{>GkX*pPhPVQ}g0^pSg*kM3-7X?$EJwf0D|FKfG$xH;1W4!um||dQj21wOWxm
zUhb#d4_S9D;{@o=jNY?~))&+%@?CBwu-R-CC>H+5vqRzJ6o=7VY@`k}@z1tdM^HRu
zIbOiv`}g8-5lTWZJ=t9&b?MQiACSxLaf#$OVCS4STO<VAxvBCa80MAuz87!u!!05(
z+jol;(v$xeqR#}K-07`w>zRm#9s(E@DO!WgJzbB74Sq#?v?XdIj+nnno_&z0KOxGN
zL-TK;EhCbp?7a1}sL0muX4zYWX%Ou@gq7&|CuBL!d_6ALof7%TUah<D$g9VO?S}gs
z9Vhn;h!Mmm=wvS9=ehZ+o{5-jDMM?*kjaQ5*(FhDV#>to6uBFGctZ5>G^s&>uGr@>
z*BAlFolnp@ZxMAN&$Vwzy7P*BC#mSd?aM|)wF@<^7jEA)(js@xS{XHrcbdgtxaD)9
zE_hob)&eaF{s2u%$g((A50a)4&*mpeb+^up5ZUkWfE;tFk;G^*D0+e@y{AE>7W&^8
zmf|G|+<zRZcCoefoWdc5sW7Eem98<7BGGZtUGAfKqJ_AFF%}kXK?C8a|55MT-22<y
zpUkWp%WeE~-MiQ=5KoHJ;ntdCJ$CNeo#WL`?(a>3sCJQ5yTGcvC;GEqVB+Hko`XxR
z<DX{j4c)faQG*<sFgHqn;@)Qe>4yHxGn`J0sY6eWaxCt>NwW*zBO5M*g1bmsX!4ls
zQ!S?2NLq@l+*2*Jr&<P4u!M?n|NV!JN$PzJTzbT0a>8`h{&Zo&yX*V!{v%EA&$K4Y
zKG~n`O_+PRKR2H6ehI_oEi}qx?zFw`Y^9D*3?SYew%FLuLxIE)d-F0w<g+B#@i%M<
z0Ny4=QLb1I+VV+4_UxUUnK|nhFrn)cmY>5r7tf4TxqxQ5DaO3ya|Nb(05D#6@XDv3
z$Ia@P_9NHYqcdvbE+`>ZC`?_bG~lZu<-2A7L_&*)6;WTPPbdEA#;m3AD@OwaNm31B
zse9Os3F?OTZj;zrFp0D9-|ytImxCQ*(=DC^^8cMW40G*o&*1=GO|QQo9^;`q8L@H^
zvL>h3OgBQLz;qOlzP&Gt0(?m+JYxE1J)ksHnvk+vTO88g;tB`@S4%<=2CkqETkvvI
z18lA+N)@X$2nN}e>V!_Vofiszo!@`pJATY@r~~-Q#MGuV&mFyGTdE(ki&Ak>|8t=H
z&x-lc%<gCg07R|cd`{-U_G|x&K|k_|69MmxznppKTg%!0?Mr*O%hN-kIgX5}aQpj8
zkomyrb5S4YG!{hh*AtJHk53Y2ogxi(H1nTcH$1m(GX8b8<IGpi)eEbl55s$2D6FFZ
z0Y89C3afT;+hL}iC-?8{WJy&;@ay%t0Eu}~hVIWjj*WABXU?vTH@IKp20Uq(`&TRf
z{n2<eUYNeMuhWK@HS-@ty{IYNu+dCq3C5bNjb6A!*EB4ndpOrJpiazZ;IBX5nB^VV
z!k#nWb|bg`k&GO0AntL2US7QkrDrKa5bF~9f%57#6@-l<&BMls&ErJaoO-(bp+>gE
zckHj?4c{={y8M)f%5Tc9D~ujN&@105R?X;p6$~m=cn#*9M+}ACl<xn^qt+5%z9kb@
zPqY%t%Ym~hE2u^df#nx5w!E#1hPI9PcWU7_uLrgLTeW&cUbY^2wNW%aOyKB8&}#OS
zf4<U1g5~d?JrNpM(P%<Um%1Ec-B<#&5ks!8wEYx(1xRwMs?n{6U9hJZTPt<02q*GH
zqX%#ITjI&5!c)UIZSyK$jap|+5-)D#_EsvCIv(wi38{*kC%~#T35%NDUZofCq}vD=
zD;z{hcaQ{@Ei1lt&}lv*AO6<+k75uc$_*R(DCG0an2~g)>~q^01DQZ%cAy!M{cfNi
zh#&jTK1rs@is(MSduzeN(^d(2icwlpN3E3la`PmEhaehjE?pXsm2O49(OC9UvC!vQ
zCri~f8#HZUd|Yryo_5+n+}v26C#!MzrniPzTi33nr=qdIMP9i<nvgj5R@Db*o$97%
zGq@Y(u4+{#j4%!@&)ykXnoVwJ)@^%8r6F+qJHxPne!<`P4s{hmyB)u-qyk)NIgr>O
zyzRJM>5xR!22|JR=_WrresfC*As;-hNKfUa$~=RFG|$n@;F5JPv&Gzof8w}=GsQ+n
z_s@(Uc87V51S(!Y?=qtf1GYo|AkT?Ig?%3{yO^w%#KTj&G7FX5nI)I+y;CjTYTWyz
zO7|?4`nS&Zr>LGFMn+!0V>_U&RvM~rfu&8Yg^7Lc`{VrPdEVruYO|&CGs@i>SuED2
z;hj@IFCX<6--jtFegC_p5eqi=@DnOAqNfB0+1mZo*K1{4$hBJPukBo@d06j}<Z@s&
zAPnx-x$IF*Q+BC3GVQ22*ko_)IpWp~Kb^O`19i2)I$OnE%{5U9@!CFS*X}l*$3;|)
zy%jz}qFZ5$<VItxbw$@jTqvr3OcZMa+X=>~QPOLX9Aa7LLPn8>Bgs@vIDsER$VzA<
zV@-Uop5S-P+iFvAX2JS||4t8Nt@p~jfn>bcOXR%W-5B3&?6aG?c-1uIvlw{vX2kM<
zo*DegQHaY>K;NS}AIB}Nh|HOBhDG~dZ^5fa*2r!+vD;nEShW$@bsfeSE0xXdmU)I_
zh`!DjZm;-368B0Y(HC;#&lX@W(vH~I0=bQJWx(BP$awdvP55@cgeNowRZE3kfCAD-
z8<NC_nlrW>NPGc#RXvk&_dN5IV^)=z+UuAUT>>uPqu_fz`_JmPso|tuU3Y@~a?@M&
zQBu>tIX$sELICrp%&#^@Q{-4S@+}x}qos({jNUN&g_VpoIbp2mk`>>rg}qxTpyr?r
z^H5tB{nYZ#{<Icu+lA==H}5E0OTlO|;JPuhdBRy^3h_J!o*ai%uo|P`ob`fb4vc4%
zo0w=qMp_|I{-vU^Ol+Ea<kDeb)sV6~Qb&FHvC%Zk20`$BfYs%P-H001+|QqQR(}*5
zmCi+4LFQhjJ7Yg=4j4uiaGo_#l=?wv#171Oyb}()4;vgX4cR2st)In>?O1BA_hu#_
z+z1gKoKJ^@azDxyWlf=^T%|JAIfZ|@-)+i6u}zaRMk0?yGSbB@!d1o<`uL_Q1#VN{
z-VCfCj5`a<$LPI0Rv0JJ<}Dj>esz@h1FE)OA4HR&<KCUF#Xef-7Y7(o=|>2Qh_bu<
z@&ZCgqX{-s_xBeMv2n2@8s9=)AbhO8S)a5xbNG)dn&b`|mx)ytmRb*qQ^x5{Be8rj
z02GbJrBE={W%_Gy<RZXr$?SQK71>O;_VQ!5oLT+KZkw6M=KMsTqhDwhZ)S&j`Ad96
z4;W5v=A57NmtmoqM3Jq$46guL8L>fYx2=NGIkrPgY{;>AtEj;%P}N85<*~`FVy&|r
zMs!fABNifs-t*I~pHhh0z>D6SUkEm|9?qe*UVqHnVIc|e$Nk(I_#)|VMD2B6z;J~B
z-AeIB9Lf4MpBi|yk;AvU#^kG#MM@ZscTK+9<WhLSE!HT^jzu0%P!KoSHh*CDuLhGO
z(w@b=Ih@j*H1f&>EhK!pLo;IsUgmntqdtG3v<s(3?<RWyZc@jMq0<Kl{TBC=?a_Nn
z&A9LwST7?p=&lFPn`deA_h_)9q-o_W7MlHyZ%Hw*!=Z|vRsOUv$wd10@<lL%OvB6z
zZBS7DFePT*opBSQ_VNc7^Ut&U-VbzjlUlwGZJRxOe{wA8$-Mj#Xo3k5ZH1A$X+LW2
z=JhU*KL>qnzSPUD)3%U659Beo3WzcNkXQIm_LFL^L7w9GT<doVs$w@Er~5l1)Z_1k
z<)0kVXe)s!!_yU~*_-LS$n5Zt8qsvLC`lWXML_u?pU!jYp1sFm$=fS2u(S4Y*CEdv
zL+87sZWSE@PK&S4@c-^)g*hF~7lDSLK3iLj-;|C?38)r{uw-KWklb|LYLVpCAgwkw
zJy2F|jX&CWZfaBD@sD`2s|SUp-MGLPIL`=9PvcPc%ZH^}Rg2V|D)}N>g}9&Wz0NmC
z)~Vi<uK%?s^Hp~^ot|@^HKQ&AUdt4QFA8YTja8SMd&d{?yuOq$X-3`wzEO_jNrfK3
z@K7>5*yIUb_iTY-$wsl?1il{d3HDgP)Lmnv%UpWI%=gW8a^6(>pv>t19$$jBA62&P
z-;`PXf-bWRTmki!{rJ0w-K{$sJ%99I_06B+TG9GpnRyN1p6}F5F!n{&o|QQSLfsqs
zv4_GP1~){urH`d+s(sM}_lKi~$Ox0g#i6CGA_jb@3bR5qN09`#h*%3KHt3enYO<6Y
zNTf?vrcEJuU8(vW3o8TMg?Ck9GKr#|N;0T{uoG1#ybVYTirA2UeF;MZ?k7dZ3PoWh
zO#)$ms$jVeS#2vmsOq?!U`pGncqK8bQB`m#nfqIan<w638hAU?BVvU`cT`cqfKd4<
z=`CNV5Cc_yAD!e&ZG$C%G5`5V+F?8pjO36kvSN{gRb>@H&QcRV^nXnRXYc^sh(%&x
zM7{C|AZ2n(QlXB|Dz|wND-zNp`i9I?-XImJ2n<!GeDJNfF)XvXV3LZsWrtNQkOdf(
zCXwI5E@9Q~&GXFk$aH~t86@#i68{iHTH_QC7=so_IhDO>9KehK^6oLfDVdnV9`d68
ztg35qqoSe2A5NRrl33Lsl~&vx9389nVnLD(fqNo=t#7dv0V5e~iX&FVZBsnwhp_*s
z%o$sF0WoV2yN9>Ttz6_u?csU}L5YyzxKo)!Ic_3f*iVPSYvKh2LvR{_Ehc6iRPv66
zvN41u%@%0*ViG**6&&1J%n)j0?u%5fA5?w#V57h;l_316t9Tjhd!pMt4Ve3i`eSZ$
zgskriqG1l$MqiooMBIbb+95l|pNWbIf=ah)WX-muj<jI5VQNyg@KmDBL85dqR;av}
zuNn+|AxK#DZ`eVAmAX&|lHjT=LIa9mR0|@K{z;F*O$SPq9I}@01{AQGkPk?vFs#~%
zJIa|@)tzjvUXmuVT6=#%`=b_iEY&%lj18$ev5YwM$H`$@Q;kh-CFlUvi5RJB9^s8m
zqgKezM1w;$nxzmtM{99>YYV9w24E3w0PtZ=W}-<MN`glav!)f~%05#!l2P%^Hw3`~
zLrW`BcuC<!c)gzt6D#=wE4eW)!H5XZP848ONxmLMT^dj}(Uw8;VJCmeNdGv@@^xCo
zV+(rXP6QaE7_|;VD({Ak-q*r$iIQL!afBMSu?Hzty*`wTTj(|2bT<3@)6h`X_>m4^
z_r=)QrSTURmjABgp0l!`tR#DU*j0UqLA=zNZYr`s>SGPdxcz!}_6WA4N}_cDK?*Ss
zw|rObC;Y&#RFHk!tA7h7St}RpMPadDsM6pKeN7~`*d}tX$0}OaffFmXhgBu{Vs*bl
zgsb_C&IqANHlNe2YrBmXEsjX2WLSJ^@*7rICyT=uWpQAM&pi|hgD<a7OhiQ-UfmI*
ztt_0hx>{um`V6=Fx>t*l+LpJ7_M6@!ii<Bgv54wIe$FhA+YNO}UH-o@CRIZhJ7-1C
zUy@P!?EvZLQ+Sz-0ILV<oe0^Ic~yiZ#kh!p1*F$>ECOZb?|6u*@QGk~cau!^u+nF9
zmBkhK5xvOO1sQmqswY;}vr3hhc>HFSp&zRXUW*a&P{wu$*a(pj@FXc95ta!E<Scx=
zS10-aoRC>ra!}=Sxf(u%RV%OJZ=~@mfjrk-<G$<puolElP(VL12$%kAle!79I@r12
zGV@p0+G391twF!&5vsj){Q-`B#|)aVd?OgFp1kV(0)jIUL4U}PSoC3Gsay}KY@i+k
z99&&}+)Tl1;CJBt!HcgKEbzfdH(^C+sMI~|47gH{#Nb=4YI~;qU=AaVP{e*9eqTO=
zv*^kBj<x@ZRccA)ovgyV_C3kb)={3s_Zp;m6p5X9DDb@3+a;5Gc0p(@?~1kyc4#}|
zXVsrO`bIfb{Ik9f+R`IlYZEM4cmi3p*(N0N>vkm4PiiPx@)s`4^s5CM3(S}}?U*5K
zkmIyXa}2E(jd#F~^&nvo%?;Wf11D3d3``RwB19!-*lyTRJ4ptrNK5Tuq9E9kZ^(Cw
zxp3+xgRdyjaLIQv@7z@JBhxPvN7{S%*H<PRdt^xVw`};aboao_bFsG}NPut8DiM3u
zDbUox$T%tn>v$od=0d5W+Vn5wutW6esxx0juP)9bOxC>~yD2{F?qYLhH)vj>NqnnR
zgq1G#SvUU{=95eH@ozLeh$X)`R&Wt8Q7zz)$iPxc=n^FQsG7XdPO?;qQ5%hagMgT)
z(a$c@ozd9Nli`0@;3WBywCmFuH_@3j9+|gGGVe}j-bZJ(dSpE+$zq=XKSyWxdSnlj
zWWSuweuKU;?r~+R<jU;ym5=D0C3F_#4)$R;pUOiW_NMS$CDQF|3Y!4@@DE;T8oSty
z#1VNO&gb!rXOx8)@rvaO8w#SuG9H-cXg+?i%Rn^th}(e-=4c`YBQA`Ev>Q0y#szWC
zs%J%{<fN;Y#EIfmEw#xW6!Uk8?&7W_*7o#oE%)<Ar_W!L;XR5kE%E0Cm^AxbEP+{w
zrTkW2q?sCF+iCR*bM>d&gTZ9?!!CjkPsHJ>(@=jZO&rG0JWMgFRs^8La#mvbv4Qd|
zu^a9Y2o%dUum~H$-X~&!P&1XVWvbgvcgcqD&z=ogTKd(H3TSFQXwC&V6A-Fx<+T{R
zqt<}Kjms=!_!xfcyIe==Wwjwdjo$9vFLF0*jrxC`lWAOdmjg1hy4@iit^8qq<sh68
zk|c7YIhS_yM>VWUB?%G#8a`AbbMot|>C){{t$L~3`B^iy*FC#9Nn&5XkZ<R!h5W99
z370Dv-nxl62eO_=4TBBV<#Z4Y=?QLzvdh8fNI8#Im2;LsO9!AXqq17fYQ9uqYzJ}?
zN@*ONX%wm!3|SDk10a)pC2ENn$i-&mt>$2O_wEc@I}#bvgL*K8@LSLW&)@qDlK;i>
zERmmSAkRLhGsO>xrMLg`bbj?}7su9?Vlj*{$^(;2*xn8dO3TvWJ|OTe7VD;Z5kvG|
zYRgc2hijvXIouMxk?3{u3IAUQhfr<ww#zC^wNt2i0-pT16c2dZLg)1%*2(asA_)wm
zBMXaT11^=WoVjDwHv7+LfAReKyQV{F#d)&NFOm4mWQ90kz{Z3RbwRjXMSe}9r98J;
zP|JO`2c3jHBHwuw%*9`pD4r@R1yo%V8^7jHf=_Eo@y2`q`Q1=PY-Qxa+}r~xCII79
zZ*O&P%0jo^6T>#5{x(wv?|VmS=II%)F0VyfkIw7i!7{bP+{<8oi`vCItiTgr<oQTR
zycl)qdjz<by!t<L>O%?nP6y}id0C+B_8K~zo+9uFG#3!gbS6btRF$#8xhpWB0BrdJ
zhl=vVL~RWJlPGr}4UNvJJi7R%GzZ_9<-;t`izy!w8#-FIdo;Z}Qey<ZbJzO;NyzP8
z_}+rBc(O2~T0jjZeL>&3gQ!!~Q!+ur1Dv-Mj6#}McnDaLRATc=;<5SL_X4Y(^`GjS
zb>Zm@nIgJirTUQ~$0-OPrJEcSa@Yn*;?JYxF}t}6oeJUa-$mag*!*h?7xzIfir?wZ
zzXmS*Nh}-xq`+cROP51r+0@tN3PEr}7f4=i5-l=RHrU@D#QF>m^Q9#9wLkEdAKI6B
z{a)oy;xPAD|F1PZm?Q<r4cW}f(U(sx#FB<9e9wU^g;$rhhW6g6-nhLC9hHI5!5Q>v
zTgg^Gym_ed&0cLc_9&h|Wx39rsj8+Sk7YWyMD9IfrNUe|r1kBJOr#ao3DTcNCT-_@
zH6g1yNA%-N&n-8bR|ie+^@yj__8J!oHwG4OKdXwHYx7Cs9a)tWd~o|}HS>>eo$cbd
zU{#&OLXKP8hwKyY*D&KM6uws?%}S;hi>pjJtVu)X6~q<4wWkjk`kDIhM7}IF36aN6
zoFH!CRe2V(sJH7HK5YKw#v|V2lM-#E_DZn{M|T(R?X$4r;!9!-24D9#*V|f7V5%g0
z-<)4iz7fO6s+zEEpw+I)z-)`~USFI^{0zTey%?v1swV(J>8x)^*P^w~P1tEOAl6Lj
zvJ3$Bof=7edVPQM_RZW(OvMD|`i;c$OjWI)JqTzI0=)3=wyWa9r|52<Jq}{3x{6Fl
zBJ3WuCdmYNIDh>=@+_8u1V=xJMI8W`j!*v{X`Y|~KrNtDfCtFRT(UOhRxQ>2S!kWG
zF7&!^NwQB4k~bE=zyRPfkrN#$AD*Aj<IR`oIOQ{V26Um+B?EE$brIijPMWe#wLKl)
z^6lR>0k__C9*He4>-IZu?|QU`y&r17JH@(B?ah?3ec1S}HDvsbch=jY=gF)Ooaq;p
zx;v5&4i@(RL^hQ_Jq<w_qZLnhbsQ}A7*4B30kJO@3%K!LPM)~@vwAZH4gmSDZ-APm
zytOKx$A4(<$+C@n+4H8tH|=1?AkvFjAW-n{w(a)ksb%ml&VA$06eeiTKJ}zh<THG~
zZEB8sS=;Zg)2-njUq5~F=f`|+*3FWPN=h9I%rT-L9s2BS`1tDKo4L!xL(?VFb9Hr0
zqUy`(v$^`w1Z@X#uKd2DLkW#rHz>y6bfu3CBj_hgU&NzE$&SiU5t=QZ$9y7JO6yT|
zsT(ef8Ojz=KLAJ47EN+Y&~ngHwuic~a)h>5mvRZ5%FB5ak<b9(nLWijV$%MQgt^bW
z?|^89{e*>7K%ASScuaFXGR88p-$JgekB%|7&WZUHfL6CgMhmwi**hlh7!!V?_M$5{
z;<wj6-=uM>tX9%R!s;#Z5w)+Xvh}~L*5p~Jtko8|8O>-9M=a%<t<!ziZdazNe5tQ3
z4*SyJS@r0sQEcUxFL#??sC;c~n+z*fe%v)?CH!#v%h&teoT}^1eInuOElh>G>knS(
ze_d}Ku~7ZiHsKcjt$jM^?ze|?v0uMEnom{z-mzT#uj$50(C0eWD8eFB)U!i^iw@`(
z@Z#(&CcZz}G}8WYuCJ%`dpA^c?mY`T?NPYFn56sRJ<=%2!%8-%nZB+JwYM;w?LH1k
z-dGmOwH6HAd-FmnIaq5@;L-ZlOTQ+kQM2TpY*+N4*F&YJ&s?qFszxJ|EWKI?R(%Gn
zO2~Bz;h(JT=)B?MwqY0dlX@0*+(NJL&qLlb->QNH1?*XpHOo0tPJx4j=z1-Lyr6QC
zg={EAesqS_wyz%-q66LjNPFG|4=OhojWbVXLF^3=*2_N^N^lE`iaJGjiUvE`$~`tK
zIxhXYz*AadcXhE~E0-w0Y1K(dQ>&5I3%uOWX%V$v_=fm(S!xv5*5|~dwsWEW{x_aa
z(rK5uni@N|R4gVA*$k6EJz|lMwsh_Oo_4>!gFWqnJ-&_d9*?{3d|xg_r&n$|JDe-y
z)U5WW8v3Q+o<<)j(&2yEm%Ddu`NT<oRlKY-h0Hd@HfRIdDR&N9u2{?oBu=JR<T&Xb
zzE7=2_oNS)mOJJ@JIrxm=!`Un*(x#JD}p>pu7tans6CqI)EuN%?MS9Q)=e?jc}Xbj
z#)vlWzje?(YU7Mx9U|<vY@}O3MUc~&G;#=oVwYbE_YHoSffqPWZLu&d+pKF)%MJ8F
zN#~Bm=4owFNY-{W;wR-LJeE@=RLik{(_tc^d$MW2;1y@Ta~T4p{wP<$X=#?ntshOB
zdFdu^bHISPnm9hmmDR^|dFFS8&r>VqMD_=$R0e55K9??QSF2?Cw?WrCS=r5@O7gi2
z;oiK1^(V+UMxA6?^ZR~or7T$a+@P&xz82r@o)_>2C1d+o^DM9I>+kDDUu4-i(Z^fS
zbdh&2!#s5y9<Oppr8_`PN>*g<<Eg?Ud8xW_Yyr5EqIhl1%YCs?)z~%*!}jKZy_9>o
z&GGXBXG$%5y?@>Wq{j64aSzfd$qDax`oV)iu-a?{&bLACLcyBD%GJ@5k=j6R8Kq&`
zg<my?Gna|qwRlxm&&1s5$Udo|1C!f4noB+Q!e(=I%xkx?*ychoWnIkdY~rumgl|XC
z{G%BbP;hmI*E?2>lafeX<W?>5${m;6o@!*L-*-HQ!x~BTZ|`0BefR2+q{o2G<O6tS
zS&;o*&#9rwhn>HhqORQa`fM}RIrIBo-0<BKe}<->?Y6uBC$EZot9Zx&jC{REePm*l
zAAG{4;qsOBqh{k7v3>nAv*{3*!NrV3&n5B7{RqW2aMtk1*v-~0WsegxuNlOv?FCnw
zEZKCM%(mnsA=V$gn8mqez9}MqX#?g#imJ@i{_5+Eu+xDr=fd22Fbf!pWO2TzSc5r#
zPC6aGh~u?l4^WO}^qb9Wb_`c%-n1Y7c>U~`BX9NpJgqKwH?@k+!y_o7;ac1S2gLMy
zBh{D;^E-_=*0OaozF37T^?nkvA?4y8S?mByIe~8xnU+k_5K5$|@q%b%-eigA-N^;K
zi9D^hdfT|(kz})b_yS!Rry^J1PvOAao{iP*m7boePe^^hb|da^>RM7-HU%K~YxGw_
zjCK~4+bJAKNN7D}%Rd`!At!w{%28JdH<z3TQWSLLq^wd)F1G0c=~TGn(e_tMZf^=v
zF5j;Y+b$ag3jnbt11Gk%{1q>*Fb+DrC=XlMry)xiV+ak;KgRD5m6ZfxP62JrLH~)R
zP95tbs^p8t=3)6ZH@Hk*2iyTxrmSO+{MHcigJ<w2zqWT}Ui$Y0>&xy2!+hTuP?pkJ
z$sueL3Jmz7BtoO6ukf4_TP0>|Ax_5mW6}?wO0-<^a6N9EL9v1!))1n_2Y@H3E%?+b
z((2`D9PTlUU`T1LznItgFo7EoW#y-xt^<v&rdtWW4wdlg3L7|L@vWWf8A)%>U%3kQ
z!f`jdSkcljlF`TM3yJz3D_1KCLWDLyd6ffn43Gx%VG>7v=0?|!xt>(ui{^g41#$W#
z(<Jix_`^j1);`XWBnw#86>NTWQ!>n+KbEp*|6yoYUUG?GH1;@p3ux=<DajWaN_izx
z{&4ThwEuwFq}Jx?aUJztZ+KIoqTNSM%(MvC{Q>@J&I_<vY?PM{sjiyiqz6k$W&sh^
zP~KS_=D+_VZ8puU=nA4>$G;*Jd9D)M_VWf8RSMWKs)a;xoRX~71U9BkzW@a0K2GDg
z!7Z~_Csb(3-t)Ahho?JwP!3i^cxu$eYvWEFdPTlMr<@^T&rZY&fh$GwEx6;iwK7ea
zPhVa(fSGJp=9!|&B_Jy(ao#F*?o+Q|?FA)^H%a<$FUmxq_#fB$J`;KG)Mr|z%^BVI
zBqteRjQg2qQ5(Yz9PKufIW>4rf+QuNCmDc%XbBusP|*(zqdwC3c#VdK0Btm*_YVcy
z@X;ZoJYv3<PrI>=%>q;lXx2(JFHR>f4ON4XTutOd>GRqmPjZ2HShhs+O%hd|A@brD
zO?L+m;9V-%NJiRmpw*uZX>{TW0J=HTX<R-I$yOzFn-03&H2ug9-2t8AWRT+Gk>VDY
z;!%>~*^%NkopNF)g^Et~Ge`~aNDW%mb|-L+EGWADQFo%TS#I2JRUA<SE}vj?_X5rf
zQ``^dVS!PpG_=xL8sBLoe=QJsSDvE@hrCgF&UN8j^J&-^UMmR1+2X(t?U8QO$@p;&
z5kciyh&s1~@#A7M8mY%@6Z!9soV`uI{Cp!V5uIg8f<+!evau{DHpQMQAO~n!gwzZ7
z1UUyPbpk<LU-LwNMe)_R`t+hjHA;9?V#NM-pYIpB!iq*(->5V{pU)qM%lZJ5^Q7ti
zp>n&^U<I5fsP0f7JomeHRDZX%Ys=~TIDHvKCu$<+4?JRc<O+z8yXu=;hv%<oMxS-S
z{*8(RA-D$+u;U2MGAjBnAq>>b`38^pilBci$zQ}Kfaba1`g-r^iB}@SOl}LGTvf>s
z;#<a>`Y-UF$MRjcR-n3;gc{{MPb}op;yoW7WNglNp6DnpR`dbMV_U_+96!Q8eU97r
z*t4tLAS##SX;=$_8$^J$;9+qayf1;Pot1p;^D@^Rc+OHe((`y{9C%MK>?Ch_WS@o&
z127O^?GFmH?o9^G7e^^yLu={&!<eId6<Pmi`IsJlNd6hp`I2cQuU!@5rZ0zWk0I`_
zSe1yilqJu&BQL94dNzfxJ&rGKS>P%H*q9e+BRDg*Me8{Ub-_w^Q6ik&*U+P7!Yv%C
ze+Bl?$Q;_`bB@T1m^ev#N%wiF8ayH?Pf(koUz0ERgP?;1$+Q5dAc$o@9>K8CKNB74
zY3VT4eEqooIXsN*WV7>4jQB^06UE*T*<?SZ1@so)DO$$AZvKl=$dL^;F*l&6^k$eN
zS9CO=7XYLp!icg36~qFhV`+*mdR>e6!UAtJRf1N@dyr?kSuBu&0K7&n{RJEkma>v?
z*H37{&R21ZgQ^7`dCzb1vcQ}n4-@$y9>~%>(WJ_ox|t$QdAxQD0-Gz*Ys8bbgXLTc
z<sN-!#zKXn5uD#WpqbW!QldZ|RqzR3HaEqhsQMZ;U+Hh9w3zQLAz$r@sI=eh|Dh`B
z=Z#hkknv)d^g8SOu^hdX!P}2{kE{tKy^AVX6DT?#tJo<GYW9AOI3EpyWv&QFp@9j!
zRMUz8tGY~aO-W%$IHR>*bhExKPjnKfLt!~O@<iXW|7_=pY7Nv??+WucLTLz?=f=e|
z3+Z!@5UC5tUn?WE<SG*2fc}<%JBH(?D6i8<^nC!;lPB<Z#1k5%y!ux-kAToALk?U(
zlr*D!I*|(w4lLn(F1y5pnzAM@tSu<-)F+2Cd{bi4zA_*{<{%akQyI)74m>A7k0V5n
z<Lgo4fVs29hYf*|sS|h4E9G_y<8}p3mmo2joT)^9%MRoaLe$*>c^y+Tv)g>k_i#?7
z=>7RB?;gZyJmPnlXo9ED6C}{4!V7eB*hX{M><ZY415GrOVge$Zi-dGi_WC016(znB
ziq!dc{xANfgd=pdS>T&H^0&2sIJm{)iC}0m%y(YQp%`7_DH7Vuo8FCZ-{6hThrPwx
z{mkP^jJkiSs#J-m{vhuTgHT_+CeX9NanhmTpqW2{;Vkk*(XH~xXF0y*BF_0TVeP8|
zFO86_GuJso93Gv!YdhCmNXNs{Y+(~hymv<ej_2vHHXaCqU`bp>mKPt3BF}t|@{@i9
zn>Q3mh%#R9<|Dr3GpCto|BU_ygpQR8;4U^l?!23;C3D8tIA&gE0@a!WhM${y;xs9o
z){I)CUhDc7Ei>g%71Cul8dzc_un@&3{!3t?n*#;n{ML+mp7nUf7TK65%GJpgeO>rZ
ztTA$d&&5f~JWuC(HD4@2Fzq4FiUpL<LZIOe&jI3ANi6zbC0`=Ks!qWwdyIRM=|mmn
zE$&Q%NQ$bvcBlqQP`7y}J$PfSp_3bhvln}Wkz8pQ&DmfPF9a-a1QyCIA4|P925~*-
z8O#&W&DpT~_zj73y&3fe({SSd@Iuo98Ic&rRZKp5uQyw}ti4}7VuQ`g=Hssssi{Pr
zPvnn*_c@p-d5Ru+59WN17qF|!2#vN8w}S78^;1ohO7#0akT^34JXH-M#g#n%qAw!V
zl%f$Zu75AiN~(iE0QN7GgA)J&YSMrd@CZzR05BE+fk|35SN0?UKz&usr^?<m#Q&H3
z=a?-u1GyM-rlj?Q+QC94=R01Z2pY<M6T0$qB{dKL%mH0EjV~Vs=qJOaY})EaYpe=Y
zyocJ>?A<sQQhZDEtaK8G1;H`@<^KPT{jm|q3x8j57Zlpf%iVFRotyom`9b(v;Lk7b
zUp~73@j1<LX!DOi5kVV#vPBMzLHaV%(5Lw99zXc>vP36bAvEygvp_Hh_Z+32+58{*
zPc`+7YMn=7x*WWljr&goP7EBGxVwEaDJM!<b&{vJ7Pvxf(l$tUs~aAvvAucZX(u_D
zwI@~BszK<|bOCj-em>&+U>0kbF()ZHKjoUpnpu$k^Jc$$2htvQv3y_V5petO87tz_
z&eD|_m_q%060iPMOOrc2kJ9Y{Xo0x$U~Tch(L)tNv@n*M|CMtc=V3S5mjbm9`-J{!
zYxGYNHgK5bMMhxHx{l4~nEV&}ML@t?0;B#BTI1d07N!|!8H@rbd4=x}rvW3@zz;w;
z5IArMl`kedB~5GdfmUx41`+y9!q9}PLSEDh<<I4#>e>QfcAO5@NSCWZ-3CAi(%B&X
zz=hx2n1f~wd^K77Y?h%hqjdChqGFzw4mT<-Y#N5*4C@(D{x9~6yGfke^|#SH|N5bm
zB={|>AWw(hQ-(-*%?l+6Q|h^Zd!1W0bgzSXl7m(-yv;5)5sKjPjVe+3FZX9TUH_{l
zN>jI!?kG?OD?>7s=jyj@0K<yHqneOUeOTbj1J%4Ipk?CJ@d);Uq;!L|bH5>r;{T1E
z`y=p_rFQ=SWX1Q^ew&$iri^a|N%@vWr;P}qh((PTDk4Y~yw3y86Q?ditjXwt1G~75
zm-qoYmBXy;^y_#TT(O|oAL#tB_8>5PB+M7x`9>46Uo>u?hD#_M1C8X*=%iI8iyK1s
z6F-~2A6)-EMb+u}XjU;7V`aD15Wrms;cv5veX}o4({K&d^BIUyMA1b4?yw4TWz*>6
zGKb^&&)Q#ZqBrd<X8YIqhiP%Q<vvtC+$yjD?I%vTZg7rd*)~}_R)4P4RCmxg&MJJZ
zb=F>Q1bcS4=FC#tROCeuN;m0E!mnw+0GnURI;8}TvejX;7AwwA1d3!y*ZaTiYq@6A
z%u%b@FhrYq?2EbY`+w$TU7_f7s^B0t^z5x)8;2fe6_Uf|L7bG%S~usNozM3#m%GLU
zaC;9--vqd<2w!POWQRRC4>=X)yc6C?L}XKabc^#R5OtF0^C~$HF^TuvEM)ICo2!Xz
z*728Z(3R|};O<O@NaschKD&xH*s522W+T<$RTcj^X73Q&pvK>qEz8Q*lDN<_m>_rT
z<1XH>FJEah`Ea?A*jR9p@^^Fo+2(lz!lv=nIEKY!vxQF5sD3^oQHm8eV2}PO`{}Wx
zoacG}Jc3(+!3(X-s5>OBk=5K--X%D3R90pm#%%FO*Z7Nub$Dp=?$oAg)MBg+w??Jv
z|0<m=QJb@zOY6(>I4xIhf{{*;;|RwHQr;+GZEVilbk;hlxnc%>DO9DjCcxZOl~V~A
zWTx*gb(s`iYca`0^y+V=Q<!lHtAbLyY_w2Lq|1uZ`2aZMKWHKPxZLwV`-m`SwXDi4
zg}L^^8m%$o6#uuTu;>DXtv3}?=d0I>aYwi9orzABZ;Z}buz23?Sj+$28!+V<dy}vy
zq}I%QEkbZhnW(jw?<^m1ldMwsrpG|fIlQ=m@Pm0lqeMX+PJkqm$Fm59jF}Bo<3;}8
ztV&LH>a+{oKI+cg^Va1Pv@cssE%l~<u>UcLF$ow54J{e)4=_R)oAipsA~GEJ6J2fv
zr8W3$-ZD!~5gNU<;;RxGU_ue4`Bw(T2H=s`nc{#dtP!(;NY}%mXpJ6%5-hw$Dgh;6
zq?TTY)v8wd?AqBA^gzC9FTn4krN;yQ;(B-)C5$2jgp`jVp@V+I6x_SZ4wDb!7-}9S
z`BJ2i6hXm4vIYb*s=kLazJf{@Iam_#XU&tYfTF~JC=psLS{A*q`Yi;2Rs|{@#mvqN
z=+zU^fl5lJP~bbd`R@eRW+pnf>5aJ`R&v)Jf5`;>=K2(0EOjc8{^WzaUEIK|u<^Pq
zFaf;5E|aeXrMO}?JDg1$9htan9Pk(B3Ot+71-u|i)o)+yfeBft#MecSwQ(n$lQmDS
zCm)8v<x@=85OLy^jE<Io)i%}J)R9{-ACCbuwnm~e&JL5YVPP<|gA`&x`c;Bjve=sV
zk-a79O{M0(NvLDu2A6bR_ps|hewwa<VaF<vdFBVPALs_#g7fWkNo_Bh<o?KH8ooE<
z_mm3a47|->wM1U-&@$dFV)dE9En>m6#`x((-gij6&9c|L(MQ8KzJIN?Fh#lXO1(l2
zzP&bnvuR|gtll4HC2AT;bJHG_(b#kbxW?u?9tr@H%mLT$y8;m|zL<y10dj-$bd}sT
zMp6To9@Fk&&v<9qVm17GE3u7Ss}QX`s8{PS{?+HF0oH9Af{lASp8yq-N4_7zxrqSE
zs2#S}+45oQFrRA2y&i~Gar~kZp9Wd;@p}m?HE3A(5<kZiSbh+3dQWRTc5~9$bJl+h
z#B>Z85Dfd8Yqlc=T>b}{ryf(w9?SPGNOvv#Ic*u0wINfaCj#6#`Gzpj{G_BqfFWB~
zq+$3p*VXd&TMO2CJ)()%w>+WcmYp1-^^J*#eiQEUI!En?Pu&m&<o?R6AGU7eaN=TE
zEh$*dT1sgb=V@~s0^B!>#S0&Q3LHVbhaNjORk!rLYVO~#_sW`7zs8Reh&6m8<R0Ok
zLyoRz73N~Miq*)y*!oBNQl|uX#Kc?XDeL#7s84?!o|sRyfN2~D|4k;$x1`<t)q}1m
zAQ`C~&NTIy8*k$Ntv6Jes*2*jFPnSy&P%VaWAhx%(DS$^9#y~Y7c=X;r1z#XP8^2!
z?_!=?*_V)U7iVTqobdJK@MZSofX8JW@9M$yhoHbw-T>*0JuV~YmQT_vf6DrXa8Zti
zR&d<ohsS~svF<KBEhsl_{ear@II2j#H2p(~&rM>-_(37RE=ukojDve`&5V^e>!Wt+
zr`6aWE<Sg`?g7t*4IbBSHzz#Y10plstR&HUTx*Q$imq~HYd}L4Z-8qg7Zd(3@3Nx%
z(TJ;pja=rcX{V1CTF13qXkEEvJjVGe(dv^!Af(5Lg*cAGCSwW&^sGdj{-3$w&kNN5
z=Ko?6;y-6Yv(_g;ErS?32gO@{GzQO<WqTd+=3!!gd^2dU^M?ezcT#+<j00$V|HIUq
zzeDx^fBa|m8HO4A&KUdJSQ{l~%-CA(A=Oxuq_JcvUS`8s8%wAp3L({qic;CPRJKZ`
zLWD@DBw@bu{#@7hdwu_a`C-m=&UK#W{<uGGw@WTWPkuzpgOn&@n#eHxoe5@a5Pf<U
zGg-DbW<8A&ui#H7f{QVeE^uZsHzQO*sDijFpov}`L}U`v3%t_{<I{_a(=RurmyD&C
zuBVsDXIv*{+$e^lC$XVeY7%IVkXikor+$r7#=UAu;}uwcSpb@|gNa8k^As0c(2=eT
zypRa9g6^P+9Cu;Ksrw7C=c2E}TIMoaiJ7CJsgXDqsLbeaYZ8<!=7q~rFFye_5x0z&
z2unR1b1xfQr1Hr-dudJrSk`?o0jEtMpOnSJdh{Y%;WK&J6G+L`095%hzIr7_fgJWy
zUT6COW{iJfh86!qK38ESx;qMc@0a+UKv9^bxR;Y;IqT%9w8PuW$uBGR&k=RxF6DBV
z{*v$Vq*v5_Or(JZ5iuY)VOWqW_=$0?lw6F$T%Jb8n5e(<M=VAE?<*hT3d`i7-%N=0
zGemPpUS&G4R2TGn0($p54fDSk%k+F)-bG`DLUC7G8=!TV9tHuSDz&g<>L$)rl4@28
zSNVkn4x)V=LytMD1XJvv<)j`O8tjNs7}W@y#|WGKV=MA!^a`__v8Q=XJetUx3Cs#z
zEPYj^#y|P36wuF8%q);x%)=~1i~XfzuA3#)^KC#J({LBscbaGg7Cqi7cI_?uEg)8%
zYp{oPNl<pFcIc8|`BL_~Vn(ax5ro>yKfc>^*m0cNCjjnvUovuD67&o6!?oxf1^S4Z
zay?k|NMytX5FIW2|Ax&P{e30hX}CdW&yIJcT>9R65+Zd_MZkl%ljJ}&^bdQ)Ns=5Q
zUUKz1dYFI#w~6gyU%ouLN7r4d@~<erJ?rmsz!N^E;El$gKFtkb8Zm$EyH!c-pjtgc
zsdxsHQ>>EhLc2ymzKaZ|pA338iFt{QKbv3(BBfAy#qY|+a%j8y?u$W(4)wgl38xsG
zHe>y77{mAF0hizxMmZC07cVUfiQ(dyK#`hAWotd`T?Q%}ORW}OyA?HCS6D7d9IPu=
z2tEgO6}|CR!&L<Dp$K?wV7zN9{GFjm8bM%J*uM$P0~&Hm0?-ZCPSv~WH%!kzoGX;w
zKn02>apuUAZnScS-^9&`sU8i+hCCOC1w|FdDi-!J6wfo1AYi@2gW}b>GOytpE3{L9
zA|QNIEw&x;$7wY(jjwCMB6v<7)m54&qR>&bHTu}RhnU+NH311oj<Dtl01>2<D+HM*
zF0^hE)LxiUtOV#u6otOg`@fH8YnVey7eTyq8P?J6cG13OUK{KCM`Psj;W^fA6?R<!
z3h?-eSq3nB@-g{}K+vGYEEW^vD*moPvRv;FxL*0@sCZk7>6JG}{xYuJ(2qLxzG{yo
zKgNU)JI`NxpJ!ZtMa>Q)sf!I;*6o<B*Y`J+Oi8iF)@+xF#bWhGaagW^A!g?w|AQoQ
z#N^V{y5&rthR$=f>9Tuj2D!GmHarsYjyv{^6e_YTYwrpyZcV5LK*Zya^yTo8)kfFz
zjWneP0lOar9eEIP{z2%K2VsvNgnxJt@$Ug$>0#9FhcQPU#-4u|TMLiE#zR4fs4}=9
zUece25E8k(sFIN+jxQfZjkgWTZOY|0WoJIzgaAUXMOTr^;&Nd&PK>OLU7(4WCP*H^
zqH9($KWWGAYrwjArT>=2J6uvN3RM{SDlPW1iC&Ml>5mJ}J4Y=uprCM}pRF5rU#Hy1
zv|RDtKi@&DWu*sK0EpeVBGImmJkL{fek47xfPH=biGcUyiQu`08^dC|O!PDso{2@v
zoI-UIkcUa|Vp18%rAdF~=qHk06!sD<5<M+pd28@M7{RjrokSi_C5i`s=X!5n+cTSU
zSlA*4QPMgoEE`wc-f@BouDYY&X7rEYrV1~<3btf*h;PPNs53PLWiT(EqGF3QZV{_n
z*KTOtW)p>5!9CvbcE757j?RiGhv^npWw3cmEX1Mq8AHs{O)K9O)wqoC{9l+WHe4p}
z+Xl;aK`R8KvW9YtauEz!!1=d4dtM?|_u2fVR4@qnm?ZYW1$~3$1CB&GCW-}7u~)I8
zfyzKCN%XqCTPg`^+$GkAiwl-%5O?hcM|PVFgl4i4(S6aJ1&9z0FW!AbGM%9~M?zeq
zBH9ROFDXpNU|$=~7sN1&d94~;ZQKSZLM9^t7x?M8z0X_Kht*Nma$;a^qDndJIU(xF
z@?J<J?C~HQXQw&%Pc)%OyqALANH;AjLf;%c48kF<ZuXTc_g4%&e~KQ+9Ka!!fjq3p
z7!UIcCzdHZgbt!d2?;_E5Q8S=%kcjTh<*;$%psikL%t1`5P=nn^Or^DU1+KGCYWNC
z7xWnSokzymqVt!IFh%9ZFWP**f6Q>`P?9wIDoHft(JRj6E8u`U<Y?lAHa6b5X3Jkp
zza#jMwaM1dosY^oES}SdBlfSrC5g3h3{o!^S|X_<N}IN-o>LaR&#?IJB5J213b_ZX
zek6X9Ar*u@9NT8DCW(QV)|7fBwfu(dkD`sNgbHvlT3Nt27GC4urY(Wkrq$)_rh&>v
z!S?otu3}to52&AG|D71Xu_}F}{ph$+H@8v81A#llH1QPqf29A}K}KdVu0&cHR<v|L
z>nCI13<5s3S045!3Peqb{nE9)EYc5^*~X<mvwI9?`kH-2!yX_`GT<kH;8FDxKW0t@
zFL&vgh;YdL(8+hRrr0{3N}ld;&nm`aJvgIQG|&M{u^y`k*ij9Nu=%52?CCAEl10Jf
zi0TMYO>C$4>0W_k`ynYn_!dYib7qm`a(TvoNftldpb2RXd2GdHvPwO+pjJZP%+XXg
zQt@wD#?%41JR){>3*+SccAy0lpDh;dDXO(|eB#Bp+o;-^VeI03#0x24xwR`q+L5}f
zG$95&KZ>oG!Ne03&hk{sX(qojl)^orBT~SJs?%Ru#V#f)T*T4m2eIWmm5<qy&zGkV
zCR0&yQ`>}^_B~jJ&-le}cZz&_6Ht>;Zm_svv%h3Bv9D2eeqZR)d#5uC?SW$1o!E4q
zVtT7rc3HH;7xPNC-*)-A(aBS|VawtvpU>A76AZrw9mJm4#z4S?H%8bfIwsBt`&9qj
zE%;X#fw6u+Nq#@9*Do)K(iID$iz^;;C)r!H#+V%qz{bvDh6oC;c$yF0?%FSQY`Y)^
z?NvN^v3?JB0wdynrzFpl<c088(BS+TEo}J`#zK9c#vj-mNq+Cr@Q=NkS4!uiuU}7f
zg1fcCBP}pLrO<Z)xYY_QL<X1|JIEKFEY5$mX^?SSw){sAb|WFrenjuL6Q$B&sQVbl
zo1d<ko$9)T`Tz7Mhg4O1uVPO7!|nzjG$2Fgc#1C=2zwr!H(@eYiuv|(skSXCO$w8=
zjF?<@ivOO~I5-h;LvcD{sdrn$jb~8sPW;Dj%u6{Sf2Y*g#L4N_hdLmDC@@HR&rdtI
zd6f>RZxb-ssgsddDJdz;klkSPh&$M1s_ra?V=^*QpDYY?znajk6D7m2gA2Mrw#mQk
z?p8`cFz&r~CgV!1lGFC6tro?=ez>0eJNR)fX9NgAk3N-j<B6VpVzD@gtjd>4z&;m{
zFm=j6gs>e~FQzIAv}qYAIwT3GauT5`*6U8Qgx|Vt@D~h+7!W2wVf_eY9SSOmJBn!M
zVJszqnXl$xVU64ydme-T@61{e70N{t59ngUv8c-cDs^zwu3R{TK^<>G5cgwGx*(W*
z8gvB~PeU}kvJOteh6xYLw9PlJ(5ML{tvD*i1rbi?^a}27A|&8vNqI^pn_WLPGUuYc
zUfYhsAN}@uJ96sllA53g8oPR2u$C-Xzb4ptCfNKe03=8gBo<6em0IjFX_qRdV#ASl
zouX#Q7#-^@cKzazqq65esDj(HQ=Zm=QtBnQnZ1QZ5>>g;GdKWG2z~^0mI4lz?n&B)
zDtgShT(>s>>#o}SJWBqzU72rAm>&iXmS2WO8!^-?fQrNd*65t~z2Fz6_E)^VI{}e{
z3g%k;??+gIslqG`7b)QC?%k`uAA2p++Ec{T99kq=n*jm64Kz|MR|eS2&PJnsOoLm%
zyA!@|T)YuHlz!lv!&Tqk-wJt(A1=>ts4W7Cf^?{=-pxqu=3PDlxT@beeM+?%#<)3C
zR`8{7Ce<iF@}TFTS6!Cj)Jzu{O4kF_EvYA#^9xYQwH>9$w$816w~~A(hm${U;Dv1e
zBe$QH)JokY7@?MZSdR)-O3txLElY^Gb$iG7Ii*4JAMFaho#^X84I8KZ_1cX1x=1R{
z68e7da<WZ~X5GuxzvxE@nf9-0%(dpP3JO>1bIjQ!jYB=6$xu@#^^pxqcZ|r!%}2J-
zy*<~GOQd`A<!l28`N%B;7hJL-ih&FVBX8n9i#)p5_92yOcEIB8ew4&ONk&Qz<;}_c
zVmo0QIxnqYZZ|6C!Mwbdw5Q{aMa*+3hTsmf?88tGARlbz=B!isOWnG3z`Yf_#hiB2
z39L8j1pGAg?gDFh{PNS_G5B*J6va6B6Db`%0KZvhe)wpdn55Xv)yV*yu~4WXcU%B^
za|=i{itRc$9pzDue`=VD^ZuZx>$`v)E<AkZ8Eog1#Le_GuF0Fs)8kR6@~8aXM}0Vr
zJ0b(7c?M2rYk8Tx(#-d2UKiU*V<K#fE>&&tM030C%;VKKr`*@oTpce*T>Ca=bVyyV
zTBi4&FSxZ3=k%gs|8y40!7BJ-k7=j#nO>k(EPPTu(4fe_@UPlsfl?}uoT#mtEu>lP
zIPNoZ|HbhSAzf#KZ(d8?&;-g(q6MY#b2VYo&DC%IeyeI+8YoLzI?eT6z4M~5r<L@@
z>s|Hd)ZGymxYg~KnA?}qc7hh3?*5T)s@&_WlN{N5d2=Hpvn1)CQYh&sP`Ep)Pv=ap
zX}P+(W>(`!C^Y)TNWj0Ld_A2fF(b)AEf0`~PCPmLc4Wcz`|z=wPhvlaM)L<g#LYg5
zyBF|hPyA$>&eQlW7aVO8W{OTcO_;rwW^-=-=FO+)7VZ|strb)tJH$;JpXtV!KcwHt
z(YMaH@zdzR+_+e}vWa%?h2gZIBuD&Tsq<UA&&^yuRk!k4u({Jjm{p2CD@IgJO^O{p
z+8JpV1u^QL#2BRnVw6$c`8Xz52c;pvQ)xZ6pH_0wQ5o#*<%w;N>fGSoYFsf>#`#+?
zFR|o|kfPONragR7{dIea$h{7SfXM>VberB?o|DyTq<Ic{Ma|xNN~AJg;*f5jLVxR&
zX`=*?>=&+?jpgo?jf7c+BX{;J_sDA9GgrTjS1u2QNKBV?96qfnc_;&-SlU_1EohUl
z_}QznmD{uD;1Ex8KG$#Q_XW!Ws2r#_t-V|0X~5=}eWyHJd6EhY8yMiIs16Njq{9Z}
z!Mf#}J-Yi6oV<2b?1-|WCenw@bFfQlc^)dv2zIyUjN7sQ*Pqgqf&BmZQ+|j5|NgH`
zV`tqeNC-Zy8Y1FrS0NTJ<+OXV4F?j&oo^?)O~c5w01+?S7_VcD2uP26BUReSyJ=o?
z@&GF_T6I$SgaNG9L^Uc;1vJqu^QcB5<vT<r2FuNy!)Eytv{XCFLJ6(9JZZ^kIZG(X
zYE3;W7_F(cERR%p$*ijqR(>Y-WoJU$QzDU?;-Y7JWiGqk27XN`^fyo5^;NvUES@`j
zP1A|!yP+MV?pbMgwtpYux_jw{bhR-38`*5A2L>tP=6dO}-76J|Eq3MQc@kAnIiQrq
zV*Q_(WwIg@R95911-Bq+V~yxvoV#1Qc9%4ACkS_t#8t-~t$QVRj(<^G7=#IQIptz!
z&_Pn|@($M9uEVT4a6|F!iv0NZZ=b<q`9AiiXX2r^5*c=hco0LecW5{gXXiub+8cFm
z<oHfo%BFF(AG~40nVd<Lf84YrSq)x-E?QbuvR9W^c@0Qp`uT#y6DkO3CkHn2(kA|1
zR6X|8Vn>9C9z3LdC1vj5VceTa*RYu@*w34jeuKSVogyG`|B`*Uisk3VBkOmsPLmyO
zFTc<)jUnT8U#eZd3?*Nltgx<VYv1cBeJYVcO!m7Wf~hFZ|Eiv~si3KN#S>{z(wHNG
z3ThWrFQ*7{C;z_jjw!5}x9-QeE95zdkFU#Ul?9{sId~WrwhpNI3CxiLRIQ4CWxmvT
zZ5~$S_hI4wWz4D!<CHhEM>8SSrCuVP?X98aWWm)SNL{eTR`k2r%NCvv4{YWARlCyU
z38CbfKb>oLE}9lqe2pvy7*o#ibB9z)D=Z#wcep%x=lr-tIw#WQ^6)tS)tPlS6f?%^
zmA1N_R)Ie86f_ezOj;oWWK2-sE5H0ZF?A+;PAKJnC4P6wDGNe=5~9=ej<4+1GElk<
z;M(=LIE=giH2xe{8yN9(A#&6mYD&AUT=nL@a|M<g%s;0Vr&pVR0jKHPKEw@GoqeQ+
zV4Pq7axBpp#f8vrB#zBmZoTMXyzETXv2V7F{pqNov=}N#SXq#pu4SJCNJp(ny~puG
z$CSO3`j{of4Ny==_}0oCOF2;ub@<^U5Uw$~H6ULzp(_wR%uSlUaqo*O-G(-Kk=)we
zb>Ocz5U$Dy?X|DqnB9xdXvD-XP8uW;;9bc#94OFsEGzU}$3D}ns2ICwFC6q<g)7$V
z_ziSe6RPNnDaOwF$vhd|I+*$2uZpz9rvPp6nAhRF9WUgS6a{H|N>IdgI8Bvme-fC&
zuIr#QRg=Tadr&G``(Fh5naRF{u5f0OIa!*0*pjy;n!lN4zVzACSrelh7ucr9IxpO;
z|4=W22(XxXu4y9eUex5OG3#GhT;8J-n0k~MF1V3@ALVEhbxh%*eUWlNH;4X!S@&p>
zosPHav{e3gE1uJidx5Prg<to1w^OU*2GM3;eQx6G=W?I)-huH15Xy17Ew!Q6Sp@*W
zO(H><_;v6>Ogo%9VY_G6(blRLLgGS-`;pr}pRKyL!h%}iF|7zrE3%*!RnaQa*ecrD
ziXLqhn{E~V)rt`|)}`AdG}|N-FDFP~0TRS?uwg-uWm(NOCy=D1+dNz0r<&T7JIMqv
zV1$Lo;|kB}rYa<s+VfLmLo=v8Df@4<Nyfl+^^nQy#Rg-KSY>eSic%V{fk}jKQP7rQ
zb|XWaU?;e#CMBX3ZJmE7sTD5RNrRj`lCqG_2}E*?kdOm&yUP`F-ilEAoi8)1D-wG}
zqn6X+)|KBk-TL;o1DLo2$U~=i4{b`6RVBD}AJUE@88&p0{b;~)?r}2d@%)g5URk!~
za(h-N)Xyc=e=fzFE5huBdLub_oM8kb)e*w*F6pwLgB|JY;yZPDhIds9q1&_+mIz>1
z4O`8pHYJpqW9#TdHK%w<J1p{qlfgmPPJ~;-vGc^-LGYO|JB}o_>o06jsyu2lE!yvv
z#J4>9czZH2$3H%gLg%5*HHTy=%Aqn(hg!KOzy^dyi!t5cRx~}ol+R@cH>F0E-P@yk
zDX;8Clx`}`8zCtA+1%ZVPNj-plhV&YTLZ<t85Q~cEJ$4&T&})5c|s$Jb9ozJl>E!O
z+Nz!`6iu|so&nf8phxqQnUvOo?pF9N@4DPjn20aDthVCIL}vXe;v4~rk1vc}zTj|v
zulwb_%upE9so%IpwyLuwSswbq1%9<zzbHm=6$u@n!&k9zq3tS=F0#uBa+7W;?AQ>-
zpuSjmtaroR>yL$g5O-0axz6x85iu~PYwVwPwJ9svdw*MuS$j)SQ6?m)E%hoA5>;;8
zXx;Wf7kq}8Yd)8GI6lvTF4=X@A$iQ|T8pG!D@-IK)x83#hb#0^M4k)kXHxV5J}YnX
zfFR-T3&-XItO?_jq6}FP25HbrN6+Myhr%2k8dM`L*9WcAPcuR?n%2_}m#F?Hok>VX
zyf5Ke<7D^him~hJ`0LH~ljS-K&JHH80PH>H;L}8Nd}%&7W*w2tet8juj^rR{4Pq1*
z1LrX6sS4HNU!vbd8GKPx85)2}A+70>Rr{?gK)2A}CGGMDZ`Zkq*u4Y>Z@r6`JpAv_
z&6Nyj7<IJ?tZCiA-IW*Lq&@$x0w14w7I!GUjJ+QE9Eh(?qC0gCq&=1{2zhK0JU;{w
z@7@#v(v*>$zZYls4Hc-fOegT(%!kM5dFS<n_A=r(iBwM{`|21g2+J*%MhV<j)BZ>J
zm%pD}h7g4E1Df-ID@I3~Mi5%EJ5xs5uec`+iRk#ldTZPYnAHHEa{$jiOBd<Ja--Jw
zeA7c%i6K6TBHEQveol5wZ-hB)_&vS%I1#ggtO0PZ51i91-x%!%D&7Nk?yxQ??(ty#
ztpY+hn;AyBGRUZ6k8cTZU1@GWyl37Zm~B;bipO>c&5-?R;0us|crTlunSn`p;z!=p
zhSp!oleqr3+gGbN-|Sv+HU~VeMx=8N(xFrw#McP*KTf^;r3aH13F*CT#@koI-a9?R
zvgt4#Ha1fO9dP0?EXJlI;lZR11%o&2v)+?!XdOMo%kyJ`jNey1`6=E`P~`owoZn*?
zVDES`?{c-?<ypMTw|`gQnHhlsh=bWvyR-H%piy>Grh}A=R~rrkIKjJj0#vR8FEyT#
zca{J%8XHQ-*$Pg=1La{GBS?t4l6o#H0DChjKFz<?uEhR!2+c;bujts^dnN&npGKZI
zQk#rSJARuhKUssz1)J?Y5=z{6yQ@~eA8$CEs#7DrkB~}k0-LsS66lhKMyPKYQ1`Kv
z=8d$(7G$+bo+n-M6c=KFb$nd*VH9u4B&J42UK@B(mN>XOk5rI|71JAo4}^MW&_1ZU
z>c;|_z9iYM=J7fqUW}gSXe#w=xgojfUG5-8kc>nN2f2iA9PeKCHbMB{$vh3^1d?us
zc;93)eDOq%{{-B>Y;29d-^6mwvEw=?8{Wz29(8A9S5y5&Rh($|2_`6NbJ{5p7+wUZ
z;=)#W`%WGq4!B^4Xdi;Gwej)te|XTpGgejC_pI#EMAWe4eR#=Cc1T&O_9c^-x_-v1
znfNkzOFbrb84;?&3v<=jiL^V4OzB${R-CZ=>)|KqlIDRJ*iS@xBvi*LRVSSS4bl2<
z{GJOolTWZ@jlr$xhk5cJ?>2$)&k?(J<#}Vp04MCp54uN}MV-<mZpL?w%)DMh!UuR@
zf;S=o4H-bXD;HiDif^JX9T3?31G{ij{3i}27pD<J$&!-XAU^!XD&ov~37h5h0q|$8
z=O-Xj=e=8`yFUgnTTp#v>qzQuUAE5re$ztyDl#ppI4$;~N_`VpO$0bae9t9(IG&!$
zKN9dytLHrfUiAp>M86{M+{dg=N#eJx(XZQwifnN!lW8z#OU<hcs7^xRxQ{iy+AzL2
z@Iu)g&pD0*&NyN6%Tt``=`j>u7rd7{A|ANID{?1`o6>Wgx7X!Xj7yG7yyU?z!Fnw5
zX90*yz^mk=@BsBA*}4H7TGnJf`+P5A(?}sAy6(F)_jSrlVsY>q5n7eu8Q6*@6KD0N
zG9xGTx_vqg=)Hny;@6z@qkgU>0b}VqNC+KQjpuZk^e^{5efY|p3(@zypwB?)Od1+_
z*ThbYrF56(o<d)tT%g6n2>h%a)&76igShn1V-jMwfeBmW(<+{2?FZ<KW>%fXQ1W)#
zgCrTBJJ_QnS@Zi~<@X4Sizl~oHJD@2;-Eas-|%n-LO~tzy^c2VaRi8mS^Y%B6U8lt
zpXv;?0K8p27AMbC@yz4DoF$%0c1rv7J#5SW3E<5M|MLE9A0m+cK5xA^KJ>)D(c=--
z5dU7pVusB?e11FtTOnCkoK8vX4fqqvu0NL_jazL0q*kwuwB$k$FrXCNfpR2!7YQQm
zCkxty2(03tIq89|=upQppEs6EUmTXEy_RM|mcGU=&89BR6)w$JEq!~iw9vh@_;jgj
zH}Z;i`R3kq2Pb%fB9cgZwqp>yW+szO8@xUmai33CF8HB5-Bv>rxy9pLTf2IP$O&yt
zb*+Az2edym;6CK+4?NN{)I0r0HcMx-y!CH!Gb1x2qO=A2T9~LWS*F+T-ShB{!=ZPk
zYfs&`Lg<BKP&31hAixx;$?hD;>Mce~&Z>~Oh^k%iLK)OcpVRhTS$$nu8>8IV!WGFw
z>CJ%#L6>rlmu9p6dCf7$w+#`=y>!Z16gghfnAhkXd?u`tj#tYVuoz5?H-8o-o}~~V
zn6u&p(_W%&QWIp-?HM<H8L$uF9RPz}NXgi7?1x)r=VG5<4PD9RSJVwB6?5--`nt$w
zneldL)VF51-dlQZ{4b_A9Q#w`ggpEyGBw0yVZ72y8$mk$ZBSh;CT~sxPdrMNmbj^#
zD+S7xG0j!dIh)$b$;d+dv~zg(PD1@mz_A@?JLuR;*7<meaNP<6nc)mQ+jLMpapU@`
zuR?zFk<R04XgLXJPZV4(GQV&*KXVgtf9v3ru;_w05wmFje5>eC2{oIz=rDxJQy#c7
z12NnvcBoIPakzV-IomPLB}#{N`_`{B*)g}<#f%TB#2xp!Tl_L9-guQ*81y$o;IB?x
z@GnT#^)5hWibtl}CR;+N7}D%-AIJEDCNa>SYlq$BKJ&~&^GcDEafSS*lRErMyuZ@Y
ze{<u~Wwz2B3Tjg4A<xEQ!Fi>FwCIam@#r7Xe`4NVkdspGNf@kANbW5%J$VU;zXbGN
zx>{4JPlAX_Ifn5G=1y@rd@+v(xTu+L=))NQDw%k*)tio))Gp|M%3R$B#WRpA-|C;T
zdmrZk*{f0IA%m(DeG*48yE@X&H-<t)qBv{}@bskhlX}%18SRdm>7Zs}aud;IN58~1
zIrgE=`(@|Z6UwhZ<W7O;P0ZHo6I*ZMw%(>~jTLRZySerL;ns(qt?{>8f{(LF{X<|Y
zr;qvAw-@N_vs)6cKO<xD$aS(S%juev_qDaQc$*(dxjgoW3^x);F`h-50%hdTg$s<7
zm<k@q1PV-PFa1Db@dB1^x!5;c)a>dvMEZSBX8kOZ$jc=;pUVPq0Wd<+FqDtGowzJ+
z8a}tI-pQ5J0^<V1CrtDJ?Wja=<Ij)S^=n(A1!>c_a`Z)IL1p!o-4{(y4A-6fsr|BK
zSKR92y!#26DB%+4aFlLoE74X|U#tuT0C*SCy&vPv-aL!l_i#yibm^KczrW0PW*0w8
z!xW*x%x1&uv>G5c@^0(@G5*wY?$7G?g+CM5lMZGg!!?(S#syVZmBFFu`EP70l66GQ
zfA3JcFT}03RT%PIo+kU=;aGD1R6g$x-qR5AeZyjL4C9X)$74ws6G889Z|gbIwA0f5
z^M5S6$ZNxA#%h@rX3ADH1L(<JA%-8H#X-xxvh}a%;Dgy<zn?q3YW*DRLvK5FJ_)~)
z{IlZ0Po10LA2&bDKgE#VmL1(bpoNq8tPqc5q4b?b2oxE4l7t&NNa-*gIqiG~6snm;
zE6@G4Pev-r-Noh;I>_F<$OM`nw!?@kWpSlTv&ce#lqH$fNN5krypSI8-tj85UW2pi
z8xfo799Hd1-Y=_Ho^1A%sCCiP*XokaHI!4jEqJTjQ(17-X6B<`8M5G|!EKH-sSs;v
zCcUcz$vy~Zh-hY!zROGPC;mJ8_TxpBp|b~oz~J=}?RK=(E8FM5xewQZUdYTde)v3c
zJ^C+KLHFj>a~m}WW0BPC<g`RB7hFhJq>ql{o3+=wLYt(!cjx-JcItzsM+RiJk50dE
z$Pvm&ENM<o&tr`@-YQg!KM6Vjl&E}j4|}utWgs6?uC3m%FSffb7tFl1m_K59-uTgc
ztVpXVXfyhdwf|X#)_A`@2`}wrkphJGZC<m8_j!PS0QeDV;=&#eugJ3fQ?Y_O{T@b|
zPyS|!@=Tb$^w`}~@4=CJMi8r{CVB3Fp<ad8p7+<f1V)cHO<9UE8a_7tjeV&;^f7LE
zULj|#CyUL|?vwcmbrB^$i}1+Ff@n1k-gC$kjRs6YMvHx_eHv~(bb8dNlKatk;d|Kh
zJ$bD+9=D!Yen`j-?o#D&xQjMVSPF&OV33H2cRbn~;eBI59jgu1a@UdYXV~xaX$q1t
z?ZUWSHR;>;TI;|K^+RFCy_fgiN$6LCjaklDUir^G&#O|3v`cBWG0Y}2{fZ)9Q+>)C
z$mVhUf*~MPfFG6EbVKnMHTFtD)mz=ut2V-W%giY3${N}Iyiw(^=*s_g{rPxafKB!y
z56|e|`4aQPwk_o)+<S0y7VUjHQ6Zb;UokR66ab+hFQU@X$phY+Yq}$@FN2OuUg+_L
zKVp~FIfI5T#QggG1m(s*9~8=|2lJ5U7E|qH?&X?*{gGsOJeJszn;ixM41}rYuMe!D
zISG_q))$9I{vY`cLx>0-RsErB-tSR+s6_!;Y<wMIK1zaH1RbzA^4LM*F80CQ+uRJ;
zJFm=Y9o}hAe&(?tC4)y)@z|Jj)og;=!OQr&Olb|hWgwH(Dv1$=(d2&i=bN;;r2<*k
z_pM$=d~K9`wA_{@t?6^)@n+j&h=aXi<S)lxs-sqjg9~nwE!p5_)qMv_MQJ<Hz^-kE
zLrFy&&ayq9G)@;&LIo*>F@|Ld%dZF$Lp8*6aL#(^3>~F}8<<;TJ(vH}y<a4weg;-Q
zWDEEgj+);{6S#C|v50%{7O2b<k3Z>J)x0<@Y~9mI91T1u?Ny(a?YIe2Zkds`BYZFJ
zbTvc)?twKQEEmHl;06Yoi=y3bU4>6#c0%+AnUalVVv!fgQniCArj4h+4unuN^oP>j
zMlC+v(seMa9m-ykx~9CP>qOBX&dqDA(B7lB*S&W5;=RU7<0QTPf%+qth8wFapVU}>
zrX$P<o#^PXlMS6X4_3>hWJX!pA?BleE59iT>(k$qJywxH$`^I^pA7@bGDdFuI-^6@
zIlIq|Wm^@K(V*fEqgE4MB3ICXiSuETL?&N1f92ePG<Vs2o7~gLVqXkDd+H!p;<BSI
z-n`Yt+530DRNFS2pE{!-bX+slN4`_#6v1GJ`1K3Bd$npo!sRr|sW(?Rg}8?GwB0Q|
znY+b<8mz2t+lovg_%07Lrq<J}&Vi4-8@9an)Sf5*tsWCC&1&d)#PRX;&p9+eM#s@o
zNfARnOvZz{H(jWsj^{HIE8fIdi!t;&+x%wjb^^m)eOgYYX*+q-lKKf98lML9e{Bao
z`MzcJU$9vkzrYT6W^UNX;RyCsVUdCBR*w!8?+Y5KXoOguj%(KOWnzgsDS+sqHaE{#
zeq(A1Ydxty4FcZ$(ohq?s*EYXt&I8qVsURQZXFgSXN3oS;UClD%B!}ChF~G`_vmMU
zueHc|NsaoC=j%xWWdZP!AR&9CZr8UXSbJQc;sgo4L)C=mIBq9<RJ@*KJTzl+-bdC~
zyH|r7IRlmI>~kqx<$l?(5W;{d#JM;E-#~}i#p(~~mi)(K%G1LcAbFZqqb*mRX2$s9
z5V@Gj>LO(CPSt9!x<Usw_WNs(aC*QXxY<(!>@l38VTKsVa{BiLDN(AjztwcPXbb#o
z^?S9twHSb86lV4F+>ZZ>dxBG6d$U^N6_@%KWB#bmEj)-<TXN|#95AVK*Bu*c(sBSs
zb20bf3LoA%2;hXMQ}e^>KEpl6w|qVgVorPp%e2nHD?0Y014cVK;m%zx=d-d@@qxJP
zZG=g@#7tsI^IQ0t7l!S4>=}$^<EK*i&EzPW<)QV*g}={)eQX<fpL%Xmz>PcS`s74^
z&XpL^?loJSjmI5pyy5KWUURQ4YyiVv`Ln0Jx406+VoqZQA+QQo1ucqiL3*8KAtp|y
zVj+-?hUg~|>d=NM#N+3;-ys>@Prjuj-Fl7Qs!BWY;>xVX=k-Y^%jMu@P!?Y)Nbw)-
zEZHMcA+Gl@F6O19`lqtE$VJF2lHlL5uPzvVb^D;dUQ<HHy%@w!mB!+yoqQ28w(noZ
zlZ|CZhCpRIk~z`*8K#%;!S4L0F0=m(VhRsiVr_ZF9ZAotzAlo+T^A?|kmUzGqNd>$
zB6mMcnXYWt4PSV=P#OQ=5kVHI9|JkhY?5jF4|$+!wm<7MVnXauE{x1O5NoNldt>fF
zx*R?V6&<fTbN<+qCzz=;NdaU))f7RTz$8a}e!9Ic_sMRr((L3p_RTY8h=?S)s?%Ma
zDjYm|U)#)>i*7q;0}_mSy#WI%KDO}*<H~gGTz$6u=5e5y4HTC8NP|s(L6T*l3o4z;
zy{aq)>dtk@);l$HRM(!0@jqH0ZCfvv&p>DiYMChCD=3GAix=<DOFI|5RdPCl5aG}U
z1;=-ypVwT?dHEeTGSj6z*J0zQLT*wS|Lqgn;<xtXxp;S({2G+F&bCbiAJPK@v4=&s
zDe5ii%EoG-N1`UJlS*%{-hW}|^V;jr(NY`io6{&xK;;|T0z37^<3&NZ51m(3o|Y>c
z!%Vmoy~HBCZYgS;VmWuUx>7MrkEPOnO#N5ME~jI_I>?kZDPM&@Kq@5-P`r<JkJel?
zLqX%Tj__BMQue4jH?dEgJRVw2dG?Xk0Q+DabM4PB86)w`JGxT`r#~6{P6l)Qf&G-f
zGTwiW26C?2VO|R<bnMSHc;cN-!wCw03u4nU{zHuFJ?-`A_xR$x-|wR;roohGErHJx
zjAR?sp<>O-?mb+t;=5DYPJh3Pl4R$u{uF%0<=SS*eVNXArakj@$D+zKi6eJCm_3wo
z!{K13qHep6yywT}u@U?6Aa0xDI8zOME%|SoV&ZXf9aD`HBzN`dv9cg_{>Ou@Z&gY@
zJFHb4+SYVQy|EXr<tkh0s;cFtUFl}5<!)K&ZlmSlQ0Z|{%hRjU^O%-bNTpYV*5R-A
z3ZqOJB4=zOCI6T2H}gYpHPc2(9*5g;9`WtF87a1Oh;lpv@7-ZBt##~c<s#i)eqsja
zE#mBX@F3^a+}r`kX+&kCmMa)IElu6s=?-{z>xgyQSNHQ9MdVImjzmext_V05!M)xQ
zuCkNjf!h@_guO&8%Pj__8Q!TM<4izygue{I_jU<~JN}YR_C{Y1T1#7994H57Pl797
zF0%DTU-75g9e8#?C!|1#T)2;-R5;jQ3^`%f>0>t<D?58gcskIhFoh%<B=yb!CH525
zU0#YpCu>MUcIvXVc<vg?9Ts$o*{EI2fPK=Z6aPKcCa-^eULs{XPwmQjSxMmaDObgX
z1(|bFO$OVnpnx?8#L+xqgKIxiF}q(kH55!zD4+nu5mV|3f_$fSarI-OZ^l9QCVuwW
zCC<Hq8G=G**5wd(n5ODLhvE#|f8Fs8PI0Fp*y4286DT9%jv#e=EZt;+C4@}q&v);d
zv(rVgErERn@YVva`HQt^dQ|mAg6?7J-W;1s9Tb%vo_mRSnIuoi-R_KB&606$(=Ble
zOl%9rW=P9-+suJi3C<emOk>)MY&Quz*8@IZQ_L^cxN5iW(JjfA&PnzlD~>YN<J%?9
zqV%9A4srTyv-;-DDc*}h^$J;$(_uS^0=&72P<Bd?h;mGyb(8*_w_Cv1eA|y*w@qtZ
z?~!dd-MUbAntW;=6leu7#Rs8_p&@I0b_P+(SsG<t@Y$l}YZj>^W1DhcF)Y+U=lb<Z
zzbx&$k~5~9t|~CYnA63@=8=k>Y&exqCPb&h1yqURNn1__al+tf6h($=FW~~N?SF2;
z&u;<@uZz{u--q2hm|k3%56ZsfdZ)vd&z7ORu;ir5mchxP6q|MS!}j@?O`$+|hwyIn
z4GYH^cAyVddA3sfUkdZi6QePQu9v3Dk_}yB4K2}51ctp{Jz8lTl0er#6t90iq<=@T
zze*4{%;}&qeb7SMX<zZcNSJ~49>aO*>JPnAFC}Lr>YZggK<e@rg2wC!olJ*cpb;p^
z&@i0ZdeDT&L!wxFU;xgqd-pFgcadol3b|a^q0MP?;GKBAd3plgDuZQZ^F-b!X3E?j
z@Xc6o^YeJSt*Jfm+`2Q^yVuaNSD=4EJkvrs%O??qhmn+yB9&is++gLA2w9{~2%`D<
zgmi{l+fw<9rIwJqE~@z3s1$#%2$ycwP(0Um5L_@Vk*Nq7TB9oJej)jFr;B&$CU%l&
z><ZQPE=j6&aXN{1CN#cx&CC7d*OAyM-NT96%U~@9<#uf%7{4e%P6Xkhj%t3)4^bTd
zgPDprJE4Z)44o;Akkop~TxlpEN&p?6)vVkB*~y345}=NJ=ph2^FdufD06)QppCKUP
z_=sfT1}z_Xfq*LFld3@~+$CEHvSKguWA$?|g(KYy(v_!}41y=$a5RWu&1Hg$#lHWf
z+tiVi<5gL#djhgb1=E2iC4sA#l%wj5+4&apotin?ogIJ9v6UtcN+dE(>%^Ta*qR0I
z5@R4s?+%4PiUd34eW;z{4HIRdPt=2HigOQb%$4?rC_jt5Y{R+x-Xvf-#i5gBLAc{2
z9p%^xmG5ll47&-<E#|ZiUFlA|H`|K?-&JP^LXfnQVcMrwNp-_E>m56)VKULu!nq9D
zBa{h{lm}7dP4>WsF+jAteKf?@$KGWBwC%5Y(j3^kq=TT$-q~pfFhD#0ps3-XW3fxN
z>ovy)yKu^qEwY{FY<mkwsz+<v7PNJbUxzlDDzC{_)1wH5U@fh#jcDkuqRT>y7b!*{
z#1O%DnRn@(@Q@g!*krMBo8A2VtgsSF=mc1qLDu-iGBwJVP9$p*S(@W3({8!SPAm;{
zN1D003bcBK!xj;RmVRZM6WcY3jT*&p$AS(UsHsmFRL*?WHZdG%jN!L6HWZL|3)NOl
zWFG)5t084A#nDuT;6lmr;b6B#iXM#Qf;sDICgLW=QM86Q*L9#iM%$NT{^XI1#=sub
z9^0|@*PnJ!t@pNUn%}2=S7&tLB{(;CvB(^<cLnr7Xt(j4y{9yr|F=W5LE`#%3!xwO
z!6w9F|94WSw&X>2!sf{NMYkvN90JEa5W}(HbY1a2Ywy!$vq*Ui6)<o}Dsf*Mx0OAo
zT02A7=T{m5(7;AxpfF{yAvI0CwH-InW@boHabg;WQjDCq+Jkl~ejvOu+ftgXD6NMt
z=q69J1urtm6Z1Cm4HP2SSeIh*OZZzmGO}^66i3?7&eVmyQx{^~WI+xk+n?_+sm9n#
zgYbT-wmeSc<DH4oP<)f<uFm`d<#tmjOWHfz*A8Vox7SmS^JTh&asJn?#hl>7(wi*}
z${eb7Vq0fc)GuFhSJ?MM{QWHxrV1wFaTE7Hi+9-4*n@dJA^#|TEtHjrwT1W5e`?Q?
zNi4$tHCrOP1WB>e_-Whwn;Z%PE?&NhhFV$wBrghByL%$G#xd7DA5as?NkaP?Eqc=?
zq2M3Il0r4}OEp!WE7P>pnt7>v0YaI}vE}|HPcsz)p0f^ls1k*N?@6Ept66N9EtHfI
z!A+~2TZyo+y9b3^g!WlZCe%~b15<|)j0XKli%<uEC`lfDX*<m)X?7TW!p9`X>|lTt
zLLYH3osHX+|C!h-I&6xO<g#C}qEMxEicKTLxVU`>ox(f9+&R8t?6hdJ8A>&$g#Kb`
zb5b9!ZrHBx;vedi<L_!D3^s(Pk~`Z>{W`4tx_A8o9kD&%$cElG>onVh?D3wvyw5{k
zPeUKps#cO-dz9<F8|w4y=V?9#AP8QbZp^g=7zA{tS>0Z50NgQw8lCPq9YJ=QW<RXD
zkC%bs2kn}-*(Q91(SWhv<Da$zO9q@SQ|=uuqM0;!pPcooT#cj0vB$B=p_;p?^cG_*
zQ;X3hdL<F4XgPKWs@`i57?efEZkGE~RIr>EX|R_&J7=~jLCKHpjKKVPxU&a~q#UQ*
z1y)gRzf8#eae2+Q<c{>Z6}h#cU78)yNtP#7OaEF-f3!PFoVue)bW~?glv1afUw2XG
zU6l_jivb;-vF8AJN_tS7O~pB&v&UxoN#?^l*+9GG#Wo^?O06dQMVSLZ?TH9r>hnSy
zVcWLlB!$GvuE=Ou7sLslBAr1NL37=<lky?@=`8!{oEh}lG{q0OWp^LM|I60<)n5Lw
zDk{zXg99w#hmOXjfz*fp9!qgrq?p{D5Q%V*@TxueM`4E|`VM_{X-opJo4yz-j??v7
zt>OC-rnDb<EMn*eoOnDi5kOm+%TWuTXIc_j)78XIQR_msJz;s-q%}nY-Tt@7R&&5M
z<83lE(VDcGFU6pd*&x90=gq|lvR>2X7W)mMwSz0A*PkAm5#V@1jhrfNl^5ikuj5+f
z(VQ2&uV{yVH@ar=_)|}yVr=8#t0RE<zp$t_1;)Ooz@wnpPE;APEnbizVVGx3GGzCF
z=@6`^KprqA-IYeI?eLa}1^FtVWm~JsR1(T{u_1b*ZHL8e%K=DC9y!<=Q~2Re=5-mT
zFO0AM9L4qn1{puIMIDVxrs-6>)O{`a-(MzwGJpH4PCoP%FE<Ph_UU|YTZgmg`6>Tc
zqx5QF-q$xzuEd@B{EUf^Q(e9KESAb8bUla`J(B!SWa`)Kt2aNU0RW0KJt|KI7Qh}l
zPL2;Ofsbs^;OeVug+I3+wTl9`Xt||h;;I43+<-D}q@sw%^~1WuuhhIm+9A3T;)=7^
zj@sa-?{Xc~dzF&+@79wKzcY`$a&~Ow>t&kd;__t-McK82j30(paAZaF6xQnILLHLB
z1mRBkT)4u^9yKP~tyeu=Ij1zaE*Jk8;J9XG0U_fzF+Z@V2{p(60>gBz82$S)=*614
z=&0>J;VA{QZdY$mv7Tb6_YzNF;OU}eMQp6=05)U0y2hBj^j_yKd(LH1fz?a8sU0Q0
zOGm9;F|Qp*T<ddGV#WNORkij7<D|+iU!NOEwv#!TnY7jn*VL<yJnb2?TAqQ|qg}jT
z9=csVn~6{O{`&24rdaGlQOMkM1|XhLtHMI3_bQnJ^cz=`Clc=Mv?#EmIvbSwV{)}t
zuIOAKwdk2K_ND!umBT-voyq)@ikeW-ZVT0rO$K}S_!<p5L8R7%2i0t4lwkFT8h`-@
zk}?{5d#)uaTWKn<MHyKDrr8orCaeqvM8VNaqULo91W7fC1!|BN0zG6<j~5KfBm39^
z-Srj0v2M4^^*0WDu?qt`L9(kjKEcO>@sIMIZ=i<3^T`D^)feV3OT77ZtNx|$g1Ujp
z&eC|NBVCWvtFvc&lk|Vx#>|aPeyyvk;F&W#2eh~<XV(1r#YvB*SY`Y-z6;-3t9?D<
z%_$P68<M7sLhmGP8_wNHgzwRn>k>H6%9phhoCrff8guePpK4-m>Y)@<8WX?1Ls=JH
zGz0^325xSSUDK+1uLf>g=t>Wv!C|kWqr_$v`2y65w*dEMPyF;n0fw(4oVk74Sg3zx
zqv<_YZ;C$`-nRd-eu>`PwFFa;xEMif>TBjSG7qni2pQ`Z-+9~Wo0=ccgjYLvN65;=
z!Bl^VGHe?`$aNS_ULq3LbzK(Ny+2J%Y_fgNwnRn_F?-K;YpSwho2o_Qg@A1yhKyxq
z&%4yAD4THgl&4!ydjx2{1pyL#^9%a4o9a2l<1+h)v$)<J0ib0LM6A73mHdS{qUZ3V
z*xN4IIu|eUx5u=x$lfR-H}eS?f+t9%Qz|BL_x4dVaAfXF)Co~0gR0@+l)GbsiN1HE
z*G;!QXX`#$tY;%vahY#Y5Xux6CiKdUgSqCK?c%3?31k$ibR;;ronkr5)Xx4v-ri%Y
z*h}F^<+}3X7+!s5rTL7W>!tol>6=ltqrOUm5)%8EVB!rIf9lIg_~E6zq9?y*c0kH{
z8iAi-G-S8?T4c><zZ=>!gcOZ*g##xK=3lng$0gOG>Ij-F*|V!++A%{n!gKOVX3S6Q
zo5FHuuI69;9y7apQsGd-%ly*cjk9}JE*(l*%D=YtYt|N|=)x2)D1%wdktHs>q!<^J
zi*;R=od%4K_Z!E}R?H0ui9nTOLz>brvK=hGx#XG_Afv_{j#z6y{Y<m-eADD$mLVZR
z{`xglUgf4(q@vW~=&xYygi8mG-y12(DX2zR_)rA<T{}POiV2B6UmPz*9W-K^*Y0SZ
zvp*#Hc-&9sg8lDW(k)WXyl^X{58tbKzM&9sYL|XQOKXU2aIaY{xI-vkIC~KPwqpEZ
z+VS7FY~_SNXIPm8lv!|QDdvKUjK30T{_1{fkykY#F}1#{GM-i&hhKb^l3mhwlF7PP
z_qnc1%}li1RzykiP-nZiy%Wcz$ppP~tl;j-X3f!m??>h~Js!T7(07U4IKp0DOYL}Z
zI&$X~zw_c9{!<35@$Dhy&U;#Mwg1v^)ayOo1$S}F>r#jBZ@j$Ku6gh1#eRnuM|>)4
z<8J&WpNXF}m*$KeZ2o=mrp}m@+@eeS`P>g;CyO)%DQ^ZkF5vXU$+GU^iIH;ZZQoDr
zPEb;wntHwa?4DlE?~F;rhoX)@jS!dW6&Ro#;7c0vIV1U@z(77wM;_JpVbfL1$nd$}
z+@3S`FZw)D9S=2fe<PiqNPX&yE$&_ObD%D%Uy;l(yA5?twJ2q&hyF*k5jY(I=#i}=
z?+Lp^gKnlUrTi|8{?efQHcHJb2{|XL5%bq2RY%&rZQd7UI;^`~`%+Sjjhmw(`@-#O
z^<VSE5iJcOF%_wcD$A<AFS57q$*hr(xZwbuxa}Qeuc35%UX&(Ke0XN5f>N$1SN#s!
zKwp34&#8Wd3psYSHg_S^Cx4_H<kVvmo-zdpbY-<d$opbi8?)Dk-@aNkI&qun5z1a4
z!;zj6>QAVAkB+hecwFw7!}(UXG$^pzR&|r`dg4poyOPnh+`R^i!9S|6;O<1+KUS&o
zBQmdCg686e&lwe;Ke$t^SO!%BUd|*`m&-bk5sK1V#~iMl8`}H&MNrR&#eRpIlc=})
z7iO+T9>dQCoVnqs@!+a7AQh+ib1#0+vWuTsn%`vuM9y>P1CyS+<3spw)?Xx~e`l3_
z!E`SjFaiUZ;Adlgq~>niay32Vg8RJ9?12%b>tApU53hUl{C(}N2P5LzC2|>%NB6x*
zM=RRING*YN>HAm5i<K5mAHJhHGacLf>Z)K##XtDtN@-m4LhhGyfBt>0G)l7_kX}yN
zxj89uExv0<=}LCo<`;FfguX+is}~<`&Y0YNWiY6YrtL&3sy^OlNn+V98rms+<H405
zL&bS?s8B$2j_7??2<&{K5ppe|WrUmpMIrRU?!f$8DJDYI%y_JGW)kO4NhaSRUBJxo
z#13d3*l^U4ESJ9@@nU1_?bD@&gWM$*j?BJCEOSLWv2Qo-HE8cR0om7E`nF|S=I{M%
zTi^8i8~@nYKd)@pBM*uyPpcYEieSl&-|(mTZDL~#r7*i$w{+RnNlw3>WR5!a0S;|G
zskh1;@x3m|0E>?@cGL+sf5}j1EFk!3EYaU7RS1=A{~j<MoE@%?@AfYWm{g-KTuo&<
z((u^vO5|F{ImV#c0}^tp{FeuIApoS?i1X-lw0xrt;530T;L>)R__;1DYf`bXT&|Wn
zr3jKM@RvWQE~{CNE0`9-(iAe7Dup{rV*=FP1KJZfwIwEw1ig(6KtEqbkMMA&AX#uZ
zQnp;K38cug!=i?;60Q=McFYT`7|K9);|>m4E=yqImI#=im9Gl13*Fa0hxLmv+SQr>
z$$kztqE}%r5}r;K>7K%I$~_u!6l@lG3K5#uyY;?LLisD)pOvUMD|fl=jL4Mil{vMT
zm4MMM1=ZfI-f1~OS#H4iA%!m&$irGFB`5{Sk{4T$r${W+?ZXBj;4&KG$J%rUNg^Vr
z)C$NZexXjg%J+}?%g{h7ZaurjXVm)D_1~zg37sEPGiq-p<<I#mYxAy7(G>2KE61`_
z)=0!sknXmLJlK?C<7lEBrH%^FxI3q4Z3^fQt7U>TV5Y#tgwrxaN~YsVcm2{g#-2N5
zU9`HYG8a3p2?(_+g<VRmj6LE8PK_j+_ieuY6NaDEb5l<$Na_I@Oa&BJw!Y0bijH{R
zN798W&Ebf?>iCkpz>2*8horOcYwG<U_Ss-;z>3j5MyIs28=Xo>BaV~~1!);I8ioP_
z7TqeTARvvC&=D#EDlIDdK~w~ZJ$!%9pKxC1-1m9sbzwa-g!Zb1qFUr$+d`RFWgl-z
zSJ`rZ{w!RQBeA?9?bY^Uy-wn2@R)9C$wLAIIUuPmQcgM9v^I=WAq#(!WVe$dn5u8f
zG^=`31lUYMko6Br9^V}zvY%${^8}^U!T#%Bn%H)%L_1bs;~#7Yv*!`!pwj8~E7+2q
zmjSEBfJFvWibK4GpPV`K=PJ+Up!t>u@5~F~1tOhK#2>&a9D(kn8e+!9(9tqJM-`ar
z0gwI9S~Eu6vxCAnlj;^w_vKcFe@~umn-y+r#y)GuQmX@4hFHuubP@V`vijPHN?m5~
zl_P>0Q3Q7trSUCKItxI92X#q5gsZXaro+N_QbbQg&}pe0IjdnEj3|y__FcS^6rpOh
zRg#KV@+4G6c!+(H7NGBXs6=@g(3ARERt;G770JqqOer|0IU{DUF|+5H$y*L$`uJZz
zp1|~lCz4?Biqs)R_x*fRbcH3?AeL*;6)q;<l493}1J+5p&lt29@aioy_xy&0<>b%S
zsuFOOyn^0r(l{&DR9&+4Da6nck<5qFmpl?-BXRsUIgt)t=KOcXWf!DZLy}n?Tp<r5
z%7=N)#ra73h%G>>D;u71s@_SGGOzL%Py{Z{{ib;cyVso+`Xh`hir%ZRWgfD@)!Xcf
z*uP+~WlOtgRfH9)lh9MU@LA!1CXx`T3#TTM`)%B~A)btK*t0dM=ndW-ajr%@%a09V
z<Y=OhgeP5sjNJmMeEce`b83(obc+wao8_DPgs5=k;@NUePcgD*V-c2WXvOb&NxIUl
zhV#;NZYgdR6a418+m^sgh2@?Hn|>O6U`_ayNW}O`19=2dlCSa+<ngv$<!yyBeZ@>C
zDeOc<Xg3}Fk{NgJb2JGj5Y&D)%tIBf%zJlTG_XU|yF*m}x{A;fZ`M^bM~aaCf9|b$
zoVZG?Sli|t)`6ZR053K@wSK^1{0l_04x%w~ix2N7DN}DXnZ^$u<Y3&pOHn(ihiT+J
zNhwrM-6Ombpm6D|2A<tAKJo}GeT(fP>E<N)ep5gq2mh>+rVG8XI1!}7W7GdBJeFZ}
zetiTV^BR~0-^L?=+jo}-*t7=O&>p^t!=ZI@5(0lkuY#n$QiA3GUX825aCn_4KE0+J
zC4QH{+eJ`1HKd;V8)5TKltUCZK4@<DH`3#&h{GV4=cyQ7^?LZ(sK}_On5R(*f1{Gl
zMyEwZXFiS2bu7Y~S4x4AOhaF6Un2NK;My$jFAjaOl}0{0&-$eN+fsRkz#vccJ8a8Y
zOvmjww&1?vAJP0)NMpxK27?{dAjt`DLCe$cTomrc@+CU!>?7q5H!R+qIBo>xEzbQg
zfe-RE4{|sKf8d%I9UBtH)mlFDd|$hvp%BC+%A<FEVo;su<J{RP#tM0N(~#H-2|99!
z=ZE^)2o+(iq}W^fDs>@SAwjEU3TYEteK%6!PH?TfmDiPCG-DhWhXGn*SC}XgRakBN
zF6qf`at1S4t3rW1^({r)l7%BkSj>YJy^{KM2$SQ1enf&RdI;f$Zp9m%o<sH}D~YjR
zlL1XB!C9O0xr>|gXPH(6r6hnt(087$r-u4k#{}dIK>UaRr~sz$=^MbAGQr4RY?!Ci
zNNSjW&NnEfP6%lcTb9ei8i!xF!GOH(>G?T(!$lvg#6^qOAoJs<Z7aj#QaG*;@rCU0
zl*`|c$P<Hsv^tiRP6lsfBQlhxnT16G_@MQo#p+Dd&9hDIdjzSrVGcS2z9aSG=?P(o
z5k<OGe-MIeBUiXJ#CVWN>DR{vBUgBG2&WbhHpMj`B<O!4ki9<^CJ#mCUnNe+o&H9X
zH0QB<&SGc+FXg<*o<<)1so2*rp_VE^a5t9ke+I1z)Znj$<#?E<^Ez?yYs@B}Q)zzy
z&t64`RHO7=bW`JZ)A`S59lF>t3R=yfDmN;Oz0+AErc)UP_}i)y%PT^_Smf>CEEDJV
zdGBf7(etTgu}ay6g2~b@Rq0A!>n-$Iiz|5As<`ii&bX$i-UZc{YsplT8h<J`*u5_v
zF01Ni>EC}`D>0a)PzGBr=dEASt~%pGV#uAnvdN;Kq73DtyRV#bor}XN<BvoH$poHP
zgO(jtPXF_NfGnRyCLU;#xJ~m|4|03pUD&v`(dO9}gYxMgZGqGjL?wHw2hZ|K7HPa)
zcKgv-&Jxw7eH*XTOc*h>RGnl4J`Q1@5Rh;+X?%>ZVRzFLqVwCNLMmQwHOXqkSNJYL
z4`PRH7wzn*Py&FU3%n(X&V6#op2x1ugRw=o4sP4O_mOI}_v_x&$*LY*j6vZF%Ru#9
z59=BNCf&L_O|oG3C5)JHlC5k1U*2JJ<RP>=@av++o!3Do6JkHW0O6<t1rYfyw=RW9
zDJZ3g?5;F44<$!s=XaLAA)YtAEdSub;T-+Q@up)>twx+#>O|`$a;LUF-y`ZTCZ{FK
z__i-`?N9X8WsG<){u7=f_C6}-8Xw`KEQs62)-VjHF#wS;aL<Vd=23ZMz)GcrindH-
zFe^A{4OB&o>zX;6)f4~a=KI*1`S%W9RmIO%IFQ%5Li&pCY)lH2zTxi;J$ihzie;CC
zZU%s6u!&p_EEX&T(~;iN`Tzs>FVA7WE|c^LtjB|x=zxe09DJNHh_zDdqsUF4S6!PL
zRsQi^^HZZ|-6n~_vqeMXi$3`xnnU_Svk0(baZ;hP?gOh2_rEPY#vpWNl45TUN(E_1
z#Kw7=X&r)r3w>2BCoAa2bzujQ>-6n%iJ)iJJoVVQ^0>yuHV57?XJ<s~aa~W`B<|6o
z6}XyuSbwi<@p%t+p1<MYoyB3T`p~}m*olQr-+M2=v&j4rV7esHav<zB(kiJ1y!u5(
zjtVaku}1{H7E$=yL8kXLmZ{S$^CtI?=g0i}<~B=52>c?*<ORH&xb4y0+1MhZJ`rL(
z?_S@qQtX<&-pBq%_*bjzTosWYLA)s|oCEml&xsK{^;G9dm_rxO|D+zLYLAMmO%ng-
z@&NA8LRs^?g|LHYYLe=nh;}_r*mwoCaJw#We&QbY#}5-rp*$Ij6Ys+`K1`S*sCb0H
z4)0t!{Dwnw!u=ornVQj0C2x&4B{yoDX!oD5E`9j+af3CWWNhUjm?R|NVfNe(+gj0a
z#`n|x5bW+gseH9r{g&>k#~uJUy&n#7k_%&49*21fg^jLbOK0U>ABe;aUv%A2Ieg<O
zEOtsKMd$Dv>1>!iUw^!&!@SBHE%oO^^q$9qoj&t`iWKY&2;JDotC51;9pr(9o~<4z
zWA{2-Di@FP<iF92YbNrNR)so5kk~;fDhzn?n*Se>(^I@hRH1iJFRkJH(%Ry2g3A|U
z9J^uhtCN)x07n|Y0o5>_3`LQlWFSi_2sXg0@59J|FTBb&Fqp%rBr`H^Q$Z~dvnbQa
zRIV8>l5>3)PiI!Coh(%iT<F!b&EhxA!wxoNP^`qPDDax;j9D=N2bATB?LzYJoxv^6
ziHNrOmuUr2By?ZS1x~bBj4H?-+Dkas%1x+??}k03cKXgP^ktuY{IM_o@ZT|O*O}pg
zRMuPD(cxzdM#%iyH{hCW>n{uckRRq~%75s)qY`%l*Xr1suI2{I=l)yw9IdnKxq;Ar
zvi&~v%Hs1}?WaFJ^u`^YAauHRRz|Y<&*kZK?`}-q(N09_KKuP;uF17OPq%09`%+I_
zT}aLOl4s!Cr<4JRI=^Z9^PWW1xf3(3g%f7@74x8iGvhOm`M(#mZf@5w>(4t~E0<K9
zzKPP=)rHYLQWw~i^Yxps5WK*a*zbJlI8M=-bHf816X(90W_V`FNJNcl&}m*TIWzC_
z0D>TN#CbjXG8oE}`x{JkziPTlRRm5jnWE~?4JY(|Hp6@hZ8wWE67FLmnfM;3!i{rJ
z3e$^ytOR%S&!u<$!N}2jRebJ*Jm=+0q5FBza>1HXkh7qHDx(-|D-(dz;sf6_&ZX&_
za*{dPa}^_l4AHnwF*~?60#|KR@KNB_OG5a7{sazY51x<>yPp-%sKos1wXVG?1Rv{j
zgD|3Z!YE4NbQoZ9bPp}?mv{^cT6?YZ0;`%Yu)*n(dk$6_ZO!v#-_Eym3MK~CJ=tfc
zXW%ofo2>3N=2?VvLvz7Ite_7wQ6LD$m?{1Ch&^8|FM3_pI0G<+dCkLqzt(%FBTDP!
z%H<i*dhuKNJaB=Dn08i+t9?QXbQVVuqp!~*d4oH=Joz{CPN}02g)viHhCE<Y=Lvc@
z9Y5<JODpmO1KXuRpwnSh9~TV3MkiO<6ocGSIDr<%ojl`O>%(k3am#OtFkJW&an?t|
z_Ub!#17{;;(4m1Bpv8of8fc}3Q?<Yi72Jl&CkB27Ak&}!={*yevjDdIBDQsKtcDZ!
z`J~wuvEKDIV;Tot@-$ADZ(SEYUA~-mkYWor$bbDy)vo+p$g)kaT&O0P9=c@F$vsfY
zv)60&7{u`$>BcXSVl4;iV0fpk;Aj!7xB4vnLg|J^Va)FMHAggCBCHYubnd$`@&TK}
zMg&k;!37}hGrv?njPvK23@GPEB;dWxJ}?9Qeq7C|wW)GmV?EU_QKPM?6-C<VYV8GB
zC|cf{R84RgGIxDgc>CAvljnuETh@a_bXAOhV2VW!VQbjnXv`h(G9od$O3Z$F?7yyp
z`=G|Kw3kU#f`G>ZM?b@$!!3gt^oq*dfsAd6KI|iysF!4UCgJjyy9Q$=MEAQH_L(22
zkSPWZd;#+V3s~028Ai+1B5dA%S>;D;`FfB6^xUp7_Xj{Znobly<AOKfQ?!w=tQJ8y
zpiLn$HQLnH;VbuHh6(Y;Rrsw8LBdV2P+mA9Nfqp73p3EJS1Xq@zk2hDa~giU0C~7x
z#TE$$RO6ZQqiLeVs`&{f>8GtE5ja0xipjIgP!u9k?S5X1dt+BApVU2t*ioGB0Ru3m
zO;Kc_T&<GDEK7i(w_ps>g4T#-BTZG=or0rx8hyHbA;a>u`%q0r+q8P-RDKe6^qhJG
z+OCW0vsiBkIBlS8PD>;{E@MjnWxk#qSwU06PRqJy^?>RMHVW2|N6M}~RW%iU-IQV1
zxXnmgK=lE~!!2rn*K|&R>a~>j^(N;69!-!U=+$Bgw^%K*W(pf4YUF|&EH1OmmW)T#
zsy=M63eB3m`!(Vw&}StqMwm=VUDq@iHLJkLlvUl2sN+l+ReR)-Tc`i0L2HCn0>k^p
zmqV0;*uvZ@*Tr^4L6Yr4Zh-S+5sR`NbEisYS>sakX`gvX5iJ=vce&f<KpI1cs)rBy
zKi{*P6n(J+K-LO9%rlLBQWZ8;Ct27E_c6WBy8t7dn~CLigWxf>G>G=N)2+w%({#q1
zA)U!0@VUz3K(%nzvITSQ8Fh!78S?oMI%uGWX<3LWJERVD7?<v=m9N^Kmf?I0Dqk5k
zJUoD3^U-#dd(L%bdl(WCoGhCdUBl)>A99lPOoBc|Cv(}0pE^du5g~F_TonAcW4Jmz
zgi#drjx*0+mQkYh6{Ev}eSP5Q*SCt!>+*rR6TXb`=z`s-fwt@rrGiGXZe`1J)h~B;
zf(}pwM(nLtsX3+HiV@(bG6|Xq-F5PZFBQ#`lMy_)RkUvW8}Is@zG+Vf6$(FH`o$z?
zW8Qc2MN^TqG3D!u;%R>jVyPa|u`d;Ds}&!|RA0&OSmw--;Rja5ExF5KB=z1E_bUfE
zd~;#NgT-D80pExDbNv+EVel)DkD>;-GUdse+Z<1lGhZ6NmGWf0jk2DbS4db31|AV}
zNC|DQlT64iKqQ3lm}9$nl<9c-M!OlTx((`mUTQOzk|<!IWGesl^m2G)$9_=Vbi>c{
zFvzCk$itNuE$^;+2Oc<5W%*G<3aHPa$ObYZ@3S+t4$rBa5ftO*56R=4!$S?CJyZ35
z(Wchn#2l8AhaNJ-n7dzs!NV?9X#w*(<LLFC<;WW|rWG7~xfCxmKGD}*AJ4V0We%LM
z^4n`rZ;u;abbzHUM4SE1vkB%C=H{kaK$@GNDQn@591aCL?<JTfKfAJebKY|@<l_Qw
zr#M;jdz|6~hCn)jVS_l%UhI11Y*T#ojza8Mw3AQva&GUN%}>{}OvT-&^R^lU6Jk4`
zMIF+922&q_s1AS_J(owC(UbQcD=D1{9my@v*DB&vad*GRlO%8?nq&o=FPdOuVYu|n
zvOE2p9PG1%Yq1WnFER8y40*-BN}6ZTT0raXnfnl++3Mw5#2l^L@SpkM>PHo`tzPt)
zsK%=h_d{LCR~4r@hcjG1eohPQrR$|uCB-hdX=*76$)feKGicKT7PXPhc^uExt-nHA
z4|{rb{w|NJ#a&1!*=yB4`dj=$5-8*Zth%0*UCVFByRZDw^+!y|T%VV^mj>-x`YBJo
z@~Yom6{Te7wHZ35^5B|K%#7{xO^Ct`qZOL&d3Av^vnek;M>})kN^<!l(BuKetFXoL
zQ^+K$Vwr7bhmPta@qpj?Pk1<iZA8re`u6<w_A$AR>0;wBbqn}>W5y@20K^m-#<AWC
zxk`bO(9qF0muG%L(n-vDJJ87A+}i2vs`b|A-X&?)r!<PhYj36K@et2RrJn0@GVn{)
z>WVk1Pqm<?T5Y9XfTh_;rP-OL+54qAW~7|~0e)yV=0OfOr<iU~j7{<t)Cx!Vii2~s
zQ92eeZ*9(80T}{NAKH<lSOox`eyv3DdKdQ-B4UP^G(kdGrnC1w6)<*We_ewnYs7!4
zB~P$3y;xQrr=T5avCIU7vR@`kL1wJdnNwkhJ3;HDJlZVj2DN~!W*XyH!r8Q+0b+#x
zB+^5xB(B$VpyrpEg31kxIe;p(Vpn}Oe;xNcO?McpFo;+4pH6vEaNR6CF|sx1^?nwp
z(03Y-Ji%x3|Frr~(FQ%I2nx$xl0tvn%G_f^9bZ4YO;Yw(BG>O<uH|u+wIR>e>!j1*
z1m!awJb>I2@l)t1>KE!d4GPTU(_xC&DctX9_+1Vd=oiX91yc&Jer<#G4IpScx~A3A
zFG$QI=~+TbeyXir7ByZtrJGYm`7f^_<}=XFyUO4dxDWUY#ag0?8&LY9aza#%`k4u$
z<c=;Y*Z5)9cToLkEAUSO2+wqqgq|8m8cIre7)cI&!+R2W#iQirZ39FlnU1c-oW2KO
zsT1|ykL7W>s2>)>vvy0%GdPNn11>;0ghBcWbEIsLVF#!QiYXEU*yDpom!0=2ieD=w
zYIB4;J6p<@=7L4eJMKX8*AbV*J^QUC@?vlW&JwF5x9H`PTA8qZ(<~_vfLKHQCc;28
z<{nY>+dWo3Hl_~-h-r_MtZ;IMv*kes`s51R*nnQdPB@6hdh!=VVZuIV#ui`WX5nS+
z*@I6|Q18OvDCsiIT~q+GY8(f!SBOfqW(vSFA%0zb#db4pFyl##QP%sS58~)P08n?9
z`Cuf!-5q<ftapc(<))K-Q8~P#fx{4Ac!ddYAn72lTD`hSNAc7P*u3Pf^SdwCQS`5b
zx&9*3l^Ds(UV+rC;QWUwST8=nvyds~zjq+h%mv~}Y#S}8vI9v+MbclpbAQ(mumydo
zZtjWsa@o}TP*9~pih-db?o4}?PqG1sq^RCqT8@Qa*HG`;9_VXgtX6QJ?C?OjB;)7c
z)Y9-9(|Ko~>37AT9RcM7qT+v>ibg;!ze??ihbMD4>VOTtFr+3Hi_y4=N~j8O)kj^3
z2%st5kF~k)R;J^iXyS*~pIJ8c2e|w2@>~}g`G2E6Rn^l6>KzIT_IR&YHS(Pt)c=%%
zZ5x;xS~I4vS5rN%u$W)F3aSS&vLG|fbq$$9e$i2%cf{z{$oM~vzznHVD@Ul&>uMuk
z)cZ0c7!ca!+FhtP#TK6y!);#F2%2N=XLy)GWD5wp4HzKf)gHc)LBD&(t>nxc0V-sy
z;)}KQ`EQ=%tGBaH8={cZyqR9K%@Z|cZpI@5%|$aym!N+KJl;3w8-FHu>J-6<KW4CK
zfdsZdvs;*(T39Dq5Z_u*tgURat?U-9oPn*}*{!^HY;EyO{V_a3W_;>0>=88Pmx}Pt
zat~!22;&B<fCeMj^ZHmrm3i1RcUVi(Fs{o?D%u#WiFQ~Lb2kkp)YMAzIMo&*f@9FO
z*6{oe)PIU_RavxbO2>iCosHX2W;Qy@1^*)H6=q*G`wNlbFaqNg@Q}+p(-!ii%m?Ei
zW>xf++vH9MZiV?jYl)Kq#K>EW#}13iTJ_bY4rgQ5wH@shN+)=QDaExbogbJ->kKN|
z7)=OxQ~ZF+{3yFhC<x(MT}Y0EC%UBgm!jkMG3D84$Js{EFUJ99?3y)vOcD7I4P2%;
z#{9989E8k;VL?@;350HBO!xO&&jg1td~HgHM8qWtbbnwsvj=NulW2@q9_<i!p)md(
z#p2Y^(=FcpQVDilJCoJJ48;o#zz4tG>jP49;bk0_ASPYHt<j;*FSjuf05b&*_rbyC
zv*VXL0zaPGp4gb?cIohfuzq>jhq5cU<9Y5+tUB4HvOQeLR5bMP0HvLY@h2*sEW`W7
z&`5#jutAm;fF;=al%NNn^K=w-8<M;`M8{_Y)8IZcNW;axQIGS~Z@7O_5R(yPpts{w
zZ6^>Bp)J6J^?2Gefx&5Gu3al*0YUjw2El}$LrR=tfoNY3x2D^OTPE6OsTRz}#6KJ)
zqcnU#=>`vu8oOZvNVTFXW1eMbdjJ6veRMWRAmh|(UseS!=zNMp`=f6Z7j?$!zyR6{
zmj#ZWJJ+EFWxxM$k@4;zMOX&_OQ6B0@K8q*>k^vv%L;QV5o$|;jSV1%6*YQqs>BvU
z=RE0sFc8z+YLVtN>{%Fmteo{$4%(3UDRdf^F@l&HaA*EM;_6a4ym;pkiwD(Y_-2W+
z`8dFxikB}b#|*R~3*yjIcd58(=$!Hh%g-q~`V|z!w1usXZWeGaQ_`E22cZ!ks!VeR
zU)`8y!?GLZl6iU?Bu86Ni#v)7lw7)X_*Wj*D^DcVlX(tzQO96wqh!({8gU9=9i$9&
z+(9`uqut8Y_MZ4MCsn%0p{dkHI_WalhH1lkW^WGjM-Kf{t|1}}Ne561L73MqcsXN?
z!aelmW!xdq4qKT8vClz4u&PwrS2uyo$!y`zusP)bZhfw-(weM6jvPyR_Qg#u$G!8)
z?=2L(oG0HZ173)yvX3wqCA3mFCV+=;R`nQ;>b=oS*95z5(YH=0$YCs8MbH!6I>55R
zq}7IehGrSs@qrc?`gp>-c1-Em3$oKwAQE)NQT|Rf#_kvDwiBkHuOmu+CTi`ym<R%H
z$Y~xdfXYIbi9?7)r6on1XJHpxW8juYoTf|W&}qMYTqu4{cM1zFRDn%r%FZ94G^!zz
ztC2c}XO*wRI!PJ_VenRK*4D5tdw5@5OE_o^uIvXtz=wegMp;CP`{dBiyHF0P(^avU
z`e2cmG)3uY$|0#8H~0}3u69`do;m!}!9#R$i;{7`!f*kddeDP1w1)G0L46cw0*&6Z
z`*XJpQOPxLpo4Gz%0oM3`-hfMqPv8u9j?huRD&gB^EC+;HrSl)90)xD`G?9^mOBAZ
z95QI=$9K#7_12d1ztHg5#lpEZsQ<FDRQh?!@g%GO7E<T?_AaInFR$c<xhn`9SY+A8
zp>1y<F5XA4HT#3k3;Ypa1#lM@N3@zrP6rtommSgjIg6lWKiuC4d<Uv?3<9*B!an<h
zSP>b6**Zc};OR4~0*c3RXdWw8+j59+mX0IEVpjC3a4uRz9z!FUzatHPEqMma%(%y+
zgD5C1WfrkMREj@lvk;Z6htZkZ1YJXHmC(`RIK^f?3{fu3O<~zc2q*${zR)Bqu;`*?
zmy5xTs8<{-x8Jm<phf?lx5-QQ!RYcSz=36K%Q9Er4lc@cH8OmaPFW4poq%~j&#{Nz
zEk!5xWfYRG63jS_TIA`ZbKmulOXbOu(^ElKuPhDa)y`vzXzRNn-@q%Ms!eY|fByFl
zz4Osh-u3*qL7PtxQ_P#Mxh7MrQC~A4j%cmQQs~H*RbAro(RskykRArH#g`5X0w08s
z2P7YL_3Fr5=)@MKTD=}n)%0SsXfF@&>Bk3VwvS>;k)yXzZ=WDm_1IY-DAEUzsyzs;
zp>A;y45aeuZvB@D3)Ep4Qu#g|?XCF7J|7cShyw2KJTIWy)0AT}4WXwK90Vf5{mlk9
z)MqH-legYw5;E4L8fVPtYAxXk0DP}jg7P@Z@bbLfTK);0Aj)^?=c^xXps!j>+~#5W
zhL`^ojqdHuVE!3JFOTkTkyj96|ImvsQJ?Yg92WfvsVW@9O-~IjkBe6PqwkDMOv}yx
z`qO8___2Y><rh3>*wLyG)#U}TxmC&FaoF|v@Yf<Hhyu@~p>44Utz=l_P1Bz=Xkysz
z-t_Cw2;drW_xcG+jLzy&&eUnGv$b>QwJ}o}fW0-KVetu?^a#zP`wQF(sZvE55s-xj
zp0_(tFIzNf5NHsYUbM&|F~F%$-?L#w1GN75|NdQMZh2Aigv_fJB3DVy;R~VPZ;-C4
z^`OSzZ@egC7<#!kS4mB4;xs;+%o8@qlY4K?Z)lJVKP4=^khHEagz)A{XMF7UQLZ^(
z<MQUKeY10C$i~8(Z;mY<qj}=4Z-W54lamIYo;_=l>K1t46&f1yOcgP!?soXNqW|d?
zuhpN2=NEg(i;n=meHr}a#GNk4fYkP7MZkqG0EC@<&;sln`CQaSp}c@$p{IiKIpM?j
zfVB~L)!Wud_vZJ!t`^2?8q{CPGG6@uHMrD*bpG6ny6|wR$zR0aMt0`+-lzmCAKi}P
zdxN<%&OHc4dPuL!$i{2B#p8lWt=;5}*L9aaog^F`{Q2*7HM){s24)6G>SHhc9$ecE
zsP9iu{dWO>h+jDM5dl(_B0yn-v~b8*;CmTx<E05V@T5fYflPJFhOir$_@bZO!aFhq
zRBwrs5>6(RfJx=XwFhwv8K=W9d+*On$QHl+DHOa)s+NH8v((iJynnex30A)-C1kD6
zS0f-pA7o;0=9&9BNcJo>F-i0*&~Ng=g2P2shT#-t0A%^OUf}zZU6o9=4Yl-`MeVn>
zA-jEqjj;-NKwncJ+z{Cy1R-U-`#qbCHmh2a%F&{gu*_Pj#l8@}H0Ni)Vu=W@LVoI9
z)z72roKRA5rE_>Olp>?(8pTS0Pz`@HLwYS7u&k(xBpiFB&l^`2U3Up+>fCb)dK%kW
z6x1U>k$V-p3%w)y-!Jbwb$iY)#6lM%|6Yn-D|+fOO)UNE-bmd_6Y6YviQ?}ZbKYQ$
zXI0-Prm{bea!o@qRk1lyM?!D9V}tfRb5!0&ueGgjRXOGvaK(7vv`|0rF0^xq@hNt_
ze&AE$RUG467Wm}A_wKc~F<0)#?HybxPvMI7tISsax77rgGPv9_Gy3OWU*&#4@oV7~
zuazaYP8fM9jI_W`E#}x_puV-`V*Kmp2SKfaA+7;kYkHbF-t)G;RkD?tW_)hKqY)H3
z6GO|YZR)Z6p{<3Pk!#2p{{<dO^pK8m70#3y`yg=H&#Mh^7_<&jcy(}rrIq!}hs~Dv
zzKh{+UC%^wc9u)Oc+ev#E=jsR&{QMBpeDoAHp=zjo&TN8sN?AM4P9?uP{YBM-JE}Z
zTVuc+>5G!KvcBOGQ}#}o4J(3ej4vpbkU9paR@CIlqBV{0c+Lybg5P*KXvZA=iu%j9
zpqA{dpszZ@d&8ef2k)d^->(v=*qK<a6i*{sz7QV7>KmLl%C7eo6Kdy0uO9hImn7`i
z{1f$HuJOtJ?4Rli!a9gzZ|0Dl6o9FEGhx-AC1;JA*l&A5Wj#fn0n{C%{P!>DYNU3Q
zfBgB#5LS;x+rPT(#x_~|E0@35zC+7~i6kvyoq!NV=FY8TSaHb&XJsU$q(jufy9J}8
z+TIy2h67wl7xX?>cd^_+`$k(XaUAcP3~Hca5p2eKOc6Qp`&CGmuW5X3?8sN%I1}rO
zbHea1-8u8$gpFG<E`D>_WhLH`h?vER;(bGWt!<HeL!~jXmCHoco7+&)(119d)5$o@
zM$s5^kz2_iC<b6|w3Zlb>W|qui-y-avDW;~s9<|*8QxUwtJah}L|_8g6aKx>d_pQF
z8{z~KRxL_;2kUKA>ydm)<L9n-$^V0R36lkAU-*U$?@YfgJ6yj4xX?@44Dd{B47R7u
z0XBG$n?c3AMzQ)MHn?%5B#<3eC~&Mqi-iDoMjCbfs(e=PPL{~AZ&%Df(x$n7D@KQY
z#s-ZolF{pw8#j-j;_MKp0Y(NOTCAR%U#?7Ck^qW#SpWPmG5<XcFOu*H;AkR|RjUX2
zsaZ073Waw#Fd$VrEv?Gb=whN1!R2+drChZ&qYI3d`~YOY@2ON4IWiuW2lk&Z+#;-~
z**|{dRetZtZbG?vO=*i{c6Q^lq1BvNdTw$`n6fQ<bXdzRja>`9ZOZVRjY5!>&W7jT
zf6nh>JatcC5^VEf+Rt;=>LU6IMNgDaZffHlJf+zs3p;%DX*5NdR8KT8&Fa#Xc$8l*
z{)1!CINcbZobnS4@O-5}6@u1{y8IaUxz^s_n??nVZiGa&N6NItIQFjnQ5dGix&KyI
ztNP*-8rQ&^j*pn``&AQ~@ICJG(WYbn;YMiU@!@3v>NLP05tf9oY@5oOL=08(^6J<Z
zYlua$x|%-XU*_~Mwd@*#J_^Ng1R&Df8Ak38piajiR*Al;)xI%4ac&N2p1oAz?>uDQ
z2@D|-?-}<Xi90W{mx~q_{k)p?-77aqSXwGjSj_nA^$mmU_@F5t+ZLv?*M7sNDB@h2
zEQUf?#pe8u^~G%8@1A>h<RkK$`_>?u>CSt(7l#0ys7~(^QDv5V;B-_asCX++Z53<Z
zNez=LaIz4fEn5T#4hwhWGFKdX_!-uf_8HBe*XdO^KjiRGKbT+9RXJS0-D}A*kQr#;
zS3$X2n1)uH9^wqJo$x<?Ri)(o=bX!NfLZ$~nD$z8*slOCz*+_<C2eNac~%&0<9NrY
z5P5iph{5tI&zLDR&fS<N@u*V7zXa-flf78I_lXEI#}nfd8f##X7f-cmxB>EKb}Eyo
zBI1jo+;c0K%ZT#nV5*TkN(mlvw7Lkg{;gh(33+i-``wqK<c+<g42`g{%)e$=4N8ti
zE{A%vN=;KWTkFr}8XoxEs?Wsofe|5JUFGPGe#T0*={~t`72H=E&5Tn$HWH7(j&G2m
z2I!ZXK}W+pFJX2%TWCOw(TnFz-V4P-p&VoH)D4BdxJm9CA1^&N7WwGMSR3mqta;Xu
zJ?dD?K8rR3lzZ_EQCL4~sf7H`mfaQiUgoVQ#-zUH_Q}9{!g<{_Vnij^T9=6dzM?py
zx03UlHS4YS(-NPKQ=TmPv8vTq6!&yr*S*;PEFl}6H6bnb`$dang6j9%=ZU?)?OG4v
zk9TTC<J>+iY;giJv3<oa+iNeAUaJpLsvdomM4~g(+m!WN<U3CJzNdNP&`#d%jH1tc
zN@IGYlLuz|-oi{*4dj?!-*<^V$Mx$6T_*uVgs9O5(f4=8Ty%J^Xx59f$4^EZOVN??
zza7->_AKho;AP^%TZ;x;fqlUVT#DOJzKu0&(QJl}Q#NM+tmjv{ZWtSNBI8r3PG?J6
z4mB;&v@=JlYj^RCWB|Xz4r^$Af2*l-+D@unTb8WTEf*&_FDf+OLTyI-PRC8<;>@(N
zu!?xv6NCCpSaZIIb%xV>m_>c&Ia&sxp4kjW`oc;;X0j<|%DYn2PowOQCAZi{&Rq7&
zxi${vXXw$e&TbuUYP-b}G@NQ_MouirQQTp5F%@v5wX0e3wzy<RC|22Is2(~oCGMo_
zzyWKg?9fBD#ICXz7P1P3y(9FUbkT_n9rn{Kv*XO<neVZPoE_*LOwR0D$K*fNMtrJ(
z66EngL4t;)rXM;u5T+K!yyR7Cuv|MJ#iTHd@*Pjtp)lJWr6-MN7*h+L;?onuMgR)K
z?Jm7ntbogWx_nT^r=MMx9cOxzjbe8sIXSY4x6aimJt?82bY?J(!BQelnZY!0KMXq7
zmE6$wM0(=kLU(dl47BxGzMggVm4Qb9F{P74E_GrR5rHOJ=Q3zPJ81)EmbW%$VXvv_
z`pw3BZE3`=qAZPcRf4jHHO$L8tAfbDsalX&o^Faw4c}sq{ddb|iy>r-UC5gkwFKp9
zOooj^zYd}zs0BXsu4YwI>hf?+!n~ktbWJ?a9k`z!y?<K7mdqd;=hj2y=U_b(&^Tri
zq24^x`wWR0h~0WZE+;Fi4o_uMbLZ2hiP_grdzIK?h*)lnX{BFKY1i`b_D*_)pWcya
z%C)<B1DOobl=9U;_*)9x6b_8LQh|EITvAH3Q+ABs<n2lG-Bm;^3n^x+>_{qEwOli8
zi;X9TCBqM6LM`Z}HJ1G%>p4LpGkMQy;4-Arp*<)yC#H?2%xJ|fa#%{$_N`#b1Hg$K
z=Vz|f)vd`^cn1zR;3>IOhUo_8SiJU2%g1Ll7%jt23-T|bV~WIbm{rSD78{#%uii8>
z<B+D8r)XI-+*t+d3@{wbz&>Y9c{VWMfzqw!3x~ZIjwUZ0FI_m<zCb^^03fVEg4SSp
zYX)6wMk{N`rBertH8g=HWzL{QZ7UPe4(V+QDs6gPBJq&tQOOR?bI};~q0W+&F22IV
zI+1U63h$kV1#aEM$Pz4nsq#Lod-W{KYTe|RR)_j9^2k~@4{Id8J1sJ*VIn=qcHHbh
zd)S!)-Ra8rw9d}mho<zR{xK-zS`V{5vn^<3k=Nz8d}!UqZu1zU@YY31At6`w&qGBk
z+ge<5kU%<~!k{skE;W*`k-=!fLoS1n&B9WvWLpKSWcVYMO?c-nRA<>P<a1Bj8q&X8
zi|JkzjhvgBdGxqpu13aIFmm>9K!$ZRhw}V@{ukr`@ES8~ox4nv8=ZL!ROq+T>^Y_F
z`&e`qU`~RZj=7o6-?0uGa|zGDiPUr-*d4re#`)R&%VLZMxz7j`uz?g)Fq%BE&@jiG
z>ej^+q{w8g$T&x_F_?l0b=t>|&lnYD2_S3*|2T9w<4nK5jg+t9eR$ffa*X;j6VCaL
zvFcsupEm(~*hCE`O^p}Peix3gZw$IrhQ%~GBP_4rz|#9^Oa->^gL<V-dsT#i^OU{P
z@r>N}8GHNT{D=0B6xDOY?a)QcVLEmzO0&7*7B`Nobo?w0#@VuDI1HoJ;^@1#^}3n-
zcCw2x{75%F4=SS@44R0~HF=YfS#>eAZ;lV*_(pV&uVCRI)5R=!;h~01eZoR@_dE0V
zjuBH$VaK$q3GeL#AkxR_SbqDbfOLvM2X5!~H5PSh76WP_S!WlUW#r_3X;>+@wm$*E
z)~4dB_T~y^Hb>3A32)Eo<=m{X<h8aq1bH!7lyynX6(5i~7DOq-ir$%G^O@pE<SoeQ
zD$tb%V<w=cJfkx&=UN39o5UCS<>ww6Illk1pbwd8zSP$sK2t62T8g%v0=ox@f1Dq6
zv%i|6_7iG{R_UyFK2~%}Rnu5f?F7(rK*mfWEG2Yl=Gn}m@}>9gbRRn>$R~=6W4^sJ
z!pcrr{8O%zoy!}i3Hzn-dv2q-Z}yBnt|bj8I6+vuhh>)X?;Jx7sPDn?=Fe^=Ydr*a
z`Y(rGT99ycUe0|7b8u-8|7c?G2)nVAAXsDB`7T~py`^)m1nbebPdvU?$ruZ5VZKv7
zk-nAn@yQfNimNFO%fFp=&q`T9$awyeuJi6C0jloo805l1=jDMSx5vb#D;Vc9f}fU)
zmi~=?3hrIvP_L--o1W|LPMm*rXzF0_hr5yePRBw!4x1BCVS4+}u@14gJbH<vcKTh3
zBi|*r_$;qSXm^pc59Uhlv7Pp7qibi8E3$c&4ZG=9)P4iM$tXJYlkl75da$eoNru14
z12wb)YDf<I3B6L!Ad6)%AApRJF7G33F6pj<JU-?9q4|5hw|&H7e`7<^VYRQO-{tzL
zo6pll!5dS_h`6atuhGcB)xDrXQ#iaN7w+k@^Q!~6ab>aUPM12LccL{eEcbmseZOS8
z-CS+%qMf(!eRb1tG*g4?v)`CY_z#<vjSUPKaFXiH=}LE*_aPppO;a<TmkR}!l#l!r
zU})tyYfWC-O^+TR_il*FJRiexc}gLtUBA0h{w@AR48M3Y)7`f9Fw8TZ>HWZmEny+g
z>v=duJfkIr(SY>&U%8igXO`B^`2=zAW7<Nqng_ntC4^q>kL2=h8U8}~__|P6D6exy
z{kuQC@XJxfrpB6o<=YEm;v%xe`L*r=CvI079tAW#4`_ZB@bF{6qaOi}PXbzyfedfJ
znmeod%naJZvh{GqgA4|f3`Y6+<frFtqQV2aiocnb2e#JoYA%z@cA!`H=Sn^%6P-T3
zt2BOl$_F+r|35zPtJVP}6YQJLVD6W-+kKCC2~?=e%Z#g;?O%1#R4x@#A)m}IS-*1Y
z)}6sbbgFJWb2Gd>QR;gMG58(%`{aFI>5_X1lvH^<W6ys2)pk_EFR~Ff&{Q$a)<)Gh
zg->u#MJ@WpYb2|gU+vUyXl4P|W^vZnJ*Z~ak8S#^@3;L^%jQ#`WY%COQONi%T!P`5
z)UvRB==F>uy9wwVAFDo<O}+)}c8BX@NoOuK)O9Ts%=KSMOijWv*rGLAAamj$O`Ry_
z`M|ZqJ)tlv`)SIX4D<4|bM;_D7&(~2gq(ya_@#O-Gx@YI-VQE--YpOQ_M~%bv=!eK
z{_95xkb0?{94tk)QS6pYdYX>wkG=Jite6@f2s7C_i`zdN0wX6ahLo0vFSUj<B$j&2
zr&mSZVVw>=qEyA>)A2RJn$}v~e$VP=pT4T^&e?}->!ioS$Ql)xCE1j)m0CE4*Ni#}
zWRMjzpS9AGeafG?w>%?vC10Z65)={Zr+fY)mkg2X^?WUvLX@9*i(RXZ(5kc3#B)dJ
zKfYS*j7-tLyB#QTL<29w9GrLrY{MV+Z)KbOoik2PbKGa=K>$}tIlkz^-?U^3#n8>P
zJdxy{S31y3?fLAS{k%QDKQMiu3Ual)&Kj@d{K<kRc!WAT@Vte|-#WXVro)WUy6~D;
zTTv_!TVgQZep6OS4R*VXC;eA9T4U$AYiRloYk!K>^KVuRV_1fs3@E>Bx<F?7Qy8S+
zbmw#_9eW7Y<Sivy%PEpjEDf2<?fEM4%zegs8?I2u%HQ~%DCwj0`=VU{@|i&QtXyeN
z^y9Rc$A5paM%@)j?h$z&=bjDFv)VUzbK-;`bI}}97w$sgBu6TTgCFdRG|DLeX1)*I
z@?+|pPf;Z`?vwK<ndMAM10ClF4xI)P{RVRU!WFd%i4>v07Xw4pI$SSdm-g|wq^q~z
z@wP~lr>3AjTd4v+t^P$<K9{I8mvVQ$<z?YVsSJe)=ckgxuC;;R#l^GroByUrw;OFu
z0`;SbJpT?ghT;{!Rg4#$=70n$+fdYRfD|D+LLO~|_~qyTp@*G=g)&qIeV)5J$wB`H
zL~+!#R7)QKO<01GHee*fyR5YK$VWq&groE@p7gbIH$vv;$PJ8CQ|J^Cn>c@Xh#rZ{
zW4699(h2mnCjM@t-!{y(p0o%GdGnMv@=|)dDb(a-IyB*WqA45e3gT6GrJ<sjMqoz$
zVfp~D@0i0(n%~QJB_%VVaF+F9BEw{)us%FY>QjFL9m%O`Y-2r=$7*FiS*6G}Y6#`G
z8HxUJSw7|Jj}1{CVDXgH9Jmn}MVrUx>m`B_G7(bKmB#rvtHuavyIKGX*?-#TuMYqj
z0`YriK5;eysRuodG}!`mI@nOfbln+93}MMTtP5N@lX&vgddjtfMJJJ7%sJQA_JOkx
z@^?SYL9D_#(H{{I$xpg_?hfdA`LCvj%j$_^$gzJ<e_)+j$rq~5Ka5rT_V$tEZGXnv
z<;ob)$8b6U!TN47S?X^LzpT$GlMSdwXW6$nlj1uv+>$tn4^&e=@BVRt`F-orvj=Z0
zJvrzMxa4{Z(z4sMdS=d$W)noNGvzbA#-O_RPbYTtE9lWN`vu{|RD)?f<!NtcLdSO1
zEyBomQNgR@1&$SI+@2*BWd0|s?=-ge*#X_WYO>YEEkC<g=Wg)YqS=4}whM$`Bfn5O
zkWrB}!pR6jI$@nUN|BU3QF*O<qoQ5J-oLzkRcoiY<UC(PLqXnU$441nxlX%VUclop
zX4F}F&b#+ln9|hC2uhDkt8&eUc<b(7o6(ds<+3S6VjDMBQTI7pXQ>1ufMTKvIW|BM
zL3Ci5oC*2fp34VKYrkLt&$Z1<q7zfh?wNM7-A?*!*}%s?)nZqWy9Qa_a^N(Jr6_ZZ
zUQAa!aI>SR(mSqL%N_{CQYso{{x!6|z};zX6Ea(2!sX$?FFc$4lT0Nj8g1#EEY3y7
zf=QF=Z|yHHd%WP*Z%8r~T2YX_$aYm@HACPrC&5H8h?s`%-jv}m7WCuTknj4Aacdcb
zin^Ve7R8oYhELH2tt0HhN4Q}Que+^d{MVLRUo2t%wNgcIxwXBNeC%ugT&jJkZQ{(Z
zK>MW1tXuok*|odvue5(HwZA^cAlN}OV87HcZ6bQFW5z<|L&wWA$`M8a5q>MGcMa(+
zHYR+wP9Hko@vz65s?O)&Mn^#{9u^vpH&tH6U%vG;L+$%rPC%<E9{TiS+!<Cp&lYEO
zjw58H(poS2XP=9r2rgpsJ)i5{u5~pATvg)>^mrs;Jpv2`BG#Yg%ipS#c&SA4V;hsu
zDt@K}h};tDnXo%%u+lt%AtQkT?m6=1?D6}zN4Z(;Xjs7}f!<wli*TxP5+i=<+=~*y
z-EUVux4yYJp<;hLYQ&MZw?;0gw^ZsIz+@6iMldioiSS>R3SO=M-N5yYoI6*Qs+F95
zuw{V*a!I2yT)q?n4adIZiXEly3NL9|`#4MweLq<dXTpspftO5xv2e~gKe~tptbiF9
zV<TNwgxVlwL>`xg*8t6msW}E51afPo0i`DO1TDf8SJE=6G|2}VxC`Pomh!V+*V9vF
zsaS2v3A|f{{kE0z-kKpdxp0`L-xL})hB302H^|Te4@3?~jkUTd0nSUFKr#cg)r}z|
zHN#xI*zZO1rBT`L@q6~yKXXoKh=xW9jN2m#)%C<GWP&QZ1l*F-2pJ$VcC%21l84VP
zkv$CS*L4+>Uq*4Pb3$Uos>p04Gl}6dDJ><+V8)k(p&6$)tR#+VlfG}?|C8ltC3CrR
zPn4I)!|#=+DZce6h^BhPTPd+=zbYz-XM7Q~(UMUPUT%m~gah>1BNMg9F%)0EbroEW
zfl<pTWH3mar{7KT-qmOXOd^zUV`XD`{!4*?5R_Xad2GBM2Weei4I16bv|n9?rvT+F
zh660DC@rqE8B94?w}wz0&b2i<bcVY_(nN{zl=b8li<dK%xbECpaQ(N4u<m(ah>a92
zbxk^Ed0DKM6Yz;BuzvUQJi*x9c$-J;8mPn{kPvB7=MzI6z(}f%EjM3Ot2VB`tg`?3
z(u7=7VZ0V5VPCU=ZoHugkQR&G;k<x@8yv+|x-OBTT1@TyqlYP^Iy-rwJ8kE%Zw{ae
z4jr(^;9|9pO&h;^xk>I9t5HKgeTbaO^U0<nW?wSs4Ype?b63K0;a1~NO}~bzgx}-s
zZ}0fV>G1&*OeA>_ZQEHZkaAA74i^w07mTojsGg1qf82qpUCkzsh8Yy4@{EKrCv`2{
z^yTy>mT(o?pznV*Vm;U~(Gv*I=sZXh%9i#3B18s_+GssQ1S#T<*QM<&YONu)=(0<z
z>H5%F>5BS0M%X|3T-~ZN0;z?0tNf%Qny5gxjH$+5{}Q*LQS28DW5Uotz0}@NhFrpq
zhj?@ML2$sJP56$JB8C(r=XmWz@TaxT%5A}iThYo&u!5Vao_=?`utg#U0cAb7M4|yQ
z*J-+XVL#sq9_nMbGnStcuf)G7{vvtTB%jXOme$TAnlE-=*#@3XDYEUxhJ>X`HoKDF
z)`L()bbx+y4w^whY;xN+LqTelEaR*B>Z*I0xZKdP=9=bf{lGEht^!HEZ<@5^SG-0?
zw#Wjw)^t|hdzm1%Y@^<*(>L#{*2o5bvGCHGE&Hfir~UoQg%qv1%JW}RIg@R(f_d58
zvkgRXt!eVAU`(H8hG>q*&D55KH!a0~>NSHo4V>2aYGHu@COkKg@o;`{k1>FX9kJh}
z$h7Q3r7kfAd7KgFkxgdAIb7^bL5tYGG0u2$JQy7M*JT#K4wsTOCICuh2=t{%&!1KC
z3vT~?u&glB3mH+q-v9NLS!S9MScyKHn1K-~E0gzQxv`U4cQ}(wds)Qzlxm+U#WO_f
z8Ve0B(bzX)|5Vd#qrX;u%j&Lam#ev$0|!*KnTlbSP7ysNG8Z4NZ7AjM*JKm3HmyY!
z4Cj_!uPHr@uOi<)*kUaEHB^351{XVk{rg?456kjfVd3z%F?n>7-yC}HbMfiULt(g1
z({;|ZU;E2$7et}`-pNq`paGE^NvDszhCYVl*|=J>y?I2rJ4oXMcv7|(kEr0Buk-uY
z&#%^$jH)aCe$mUan&CtP|7!HLEMS>Ij%WAHkUMKU)&v2=k&4^@o<te#Ahc6is-80)
zq+y@7c&6;oSf-;n?;m|vcBLz9uuQdBp04?iQ&y$ZU~GCnbA@BgwZrm}BN_>P(;0oA
zA?tLsW-BW=E4g}&^Px3+`@wzv2)F@{l}oFl!yM9!(JNRowA9|Qo!J9kWjqjfQg=>f
zq(WsfUY;|XdFe$kWOlIh)|U~j@<GicTb-bZJyin_Mv_v54WKdP;AhaKBRH9Q5!6Ul
z+fFg~`Kiu~7bw59?v%twI|U``hwYEP?iO5n`N8^LTAZ$_>o(yOH5lA`Qw(z6spC~g
zF8{HvP~i5*lOk*#g6qqQ?eo68OCoRl2MFI*ZW5e^Y>$&N1Ye&s9paofmd_|L&Y)y*
zVEYf;CxFX=P6m2XpXiu>WsDV<b~`>$)S!^BX?x+9&m|2xFAoxy)6V69h3-Nm?pi7T
zX4E=hkQXq#JS99acR6r73p3<Vd+@-Nv*39!`P}@)Jwf8^Jt1iD{ZPYE5iA&5I@B>o
zFk(y>a5D630O@Ws%(YHJpOIlViQ<imJJm$tmzU&DpfANo7mp2=`nVVF8u4+C5DpCZ
zse{gj!}h63MMo*j{)1WT?>M*LuJ&1q;Z`nhdDgKd@f9ZVomTMbLA<|9<QY>0E`osV
zL32hRjmMbtM~V_-vIs0$gb~ay_adSrmD7^ng>isu(xB21ERw@;A6~xteOT%@=<IKy
zi5xG@`(9e=y!3#M6}3W9A#zns0eH>Z?BYIyu?~xFhY`U##l-iMzLT*4p857~Q^K}>
z&LHi|{_yQw@a@UrQ=0EfO0rSdOGLxiBR4aJ8)7y7`pK;&M%&C6;LGW}25cE6?j5i6
zRar>Onbm%;IOP}~`WXmlBpaPtIhR;u_XcIQ8HS4{Z9~Rux6J}nhaYG-+IlWTiH~p#
zfF(4Bgq@NUpEGeUgM?1E?K=p9a*jH@jC?c#|NMrRzOT3WrnjxHkISZyr>}3ortekX
zE3unbl70QMHvMk;`j>6`S4#K@t(De*-t>|^Ss?uQ<n%9-0YVU`H^h6(wZU1wq5=%T
z4v<g@I2|ZYnu<()FOaNCnff+uE3v<*8#dg`J0?L)QM>p#(q;HB#0a`NNxZaT6D@h|
ztywhK_sY<)oHApnZVnfWK}YV57KeeoIwM<Z(!kGx><)eX)3BA-SZR_*D8cAQUN%6B
zyy9_Q<b~)V>eB``2~tvfnZ9maJWsdshTW191sK&RMFtnoU$h>PmnU<eljQOYuvE}8
zBh7#0lsP!0Xl?laSh^QSroZ@q;P1`MFt)kQE!*7hbHB6ArMXn@Ns^&lQXv&mZo}N?
z8WM9UM9d|rRPJ|$<WlP6T9V4GqGZ2)zrXLlu$`T~->-9?k0+iD4vxnq$TKV$*jI$|
zK&d|4w`+;9OAL4S$guO`I^a&#-gRucP<nT`cY*{n&OSKHV*I#{LsH*4XGu#dMIi_y
z<5i$6!cpGxk`{Gnu_kXnI|ST!iKjM*_JwtN(K#p;4unq|hq&J^rdzOSNS&V2=!K(a
zKv&gxb|HX#WbItZlKJR_%~Usr9ETN3(1RsNmCRwM;`f;xQKSNq)*5}u1Z>zb$zGD0
zEEwrXQYA?CG4ig*EBM~@cQ{p;u)gL4s{I71jc8jZcD#QWe_mz^tm@~5i~iibLe#eG
zNuLbJEbvgr2A=p=<E7{ZY><e|xXgous#~rryA{I*J*kojlI}Ka`>$9au@CKJV-(<z
zDIFfOSVa-lun_$Q5nXXhZTzU+9yg|g_8>bY+S>l4CXbiAV#L+|61+y^iUawMsCH?k
zcDV(Z>M91jaJEvq-&aU8htIO+Gdz3F2fMZ^xe^l1W!KxZ_!l*M*PciSeIjO{$$)Bn
zgkIlI3~5%3Dr90y^t2GahXe|90wgUo3h6Ih<6y!G>Q$+Lu;s`HYcw<Ncx!_B`E&|a
zC1_Kz?)bL}P5%bBhXHSuOXMN)RsWf^Q{J4(vik|Czx1&AlOm~bE>Kpob7R(Q>K<H+
zYWyKD{u=wLSWnLjRa69;AM4^@k|@`~e+)9<j1kB{#f7zUxD}FU2l1}dE+@wx_re_W
z;GV)g4jfJ8$hmsx7tYSizL)Z<QvCIu-ES9=s>P-EhwX6|7?MFmkD^mePv-Z%i0^^B
z!@|*BpCc{WsnaBwFpJDLVXI5Z*f<Held?W>&V?ee9Y>C>BwRP0F{|SEuYAD7;39y>
z*&9xtIv^V6#BtYh0|8xy3q$I%Uwa{!=_1O$XT%i$xMbuMp`HY}t}D+RQBl9||EIL5
z=&drV&3Z#Km9x~XmLTf3je}TaN=W(vh22rqL0s@9$2=9blj9$3;XV-`fVce#K29VL
z7~}2Fwk8f=?DOd$OE9X$)$-Q)tFzVWd8PX{N53zJ3wN*c^S|GWUusMM6FgLVdf4Bs
zIe*VEUgjZL*UG)Z_Navpg|aAs`)&b>dwnXT2O?-S`f=u&9IRxKdK?fpy>=4l<N!Ro
zOk3Ry(k)m9bdC+D)vq<6tDLmY?W(=h>glN3sHLDf(zmxx-<IpWT7EI>cu>!AUz*hm
zq))1eXjs|Q+8PGOafn)`zIrIx{f6u2N8{PNlog9hRo0xw^deQKVhCaN=4qfcE?xDz
z(l_KesiPsN6n*AOZ%6GKY0U{!gSf5!9wouYx?uh`H%(G==6Hn$Z-9NqOwrb6B07G!
zRvhJWsp9+PpS!i7i5_#<guBpdb96OD^1+U{Lp*!Qtx*-y9QI2&e}5-c9AF<qECeVV
zR*-=HHASJe%L>y!mV1BnnTS*lUT(&Hz-U0!q2UgTT`fm0NWE#a07ASxK_A+&ey)uZ
zrc{>j-t;9Kj!XAIZW{&W!SN!S7c+z?UID~Qr%0oVBAltsee^JZX+ex2VFD~ZxZJ^n
zAdMF;pcc9`;qEe2nw|?tEOyWwExf|Gq|TewUHat`&y~-5j}qM0H2&gbuHWz5DAlb3
zi3fM>jV79}kTg^tp~_ATI9X}z_4x~R>8Utc>{5sh)YJc+1RTH>y*(KLh@hI><l)n?
z*S3DPQWM}q#9j-DKOb{0^_fcgnWaM|J2)Oa>iP;>H+4DEk5R$tTTNG7H1*Y!e%5GS
z{g80>gv9hQ?S&ThRt9!!`|I;-^y6hOdRM?fkD>c<LqA!I@c3f|Omj&D&>0_S*~c>V
z<oSN+&%KkUyJvx?bB4~>3e_JahFD-?Erl`?m3sT~gL^z5mzk59!>!$^9TX0!wIH-A
zDe-Z8`frV|%~}dOm^%389*111P2SyOpN}j@O7EySa{@I)rX{E0RGY2Z?r1y+=N&JL
z?shHhmy-VSFegr`CT?5YQd~7&YSW)}O>dz0f%h4M7E;6o?X={cFa8?RxYl|H$X>nE
zPlv*cOe>P)W*wm?B7I~p{Y^y1`@M|ih|I5hnL80#fA_LDBI&&Qbiv5pz&J_OnKzf(
zhurlX>s@dMr2VVCBJD(}U`0|VJI$moze1A1v>&xs%a|$NXi&&e;RFWbSY;QFD^~5D
zaJM?5_`WGH@D}1qe+`^@s)zZ=aNy6Fipvjk&tT%hlldSqwRDaGDn|u3U8lDvzdk{!
zLqKoO$_!$Wc%54ODgre=b^>Q#EGlj|`os}NauKI0b+kK^yWYP@jmIY*xjp*ykpxOE
zajut`Yk%~bIHYq<j5G`W@tpmvq3!d0)x7nNyk`&bJBKmZ-;%D7aYFDkZnOqrT+W*)
zH2=zs+%1BMe|fCUs{@86@XCgK-L}3u1Sk2PoJWeXY5XpudYbma2&nvT>eM|VlVlJ}
zlITd&-s6<PHEP1Uh3O#q(S)<nMeIk3TYDD9(S{b6H_~%Kvf(?dF860;et+BkT0Q3C
zv_0sNM?+FdkU@}e-<Cg4I!^|A-<!E7jNk1zAq2XzlAx<|X1Fo>tu9qOxbM0IwQZGS
zM$A%}U}06`c9a^KEx|i*qhs}A-w$YC>$e1jYA&wOr_P0em5)y=^pcLy6S3pq6burx
zOVrlkU>myXAr`7aNeaF3Qe+|y&7lwP@zpM!Go|O_IIZ`3jHq$*x<`1tv?6a<N$+tg
z0WVzF;?H`nKGwJSbUycD|C_ba`<J~q^mQ!M=)p4HM?Qi4i7up1{vSV&sEg{5G(!@!
z+`+#VyR;1w9<5tj5uOXX_fFmD#c%Y$ZMs^cKbYR|I;J?w$^vC`3Rr4dre+3MoH<PR
zQ)R2#fi*$bjksKKGU*9d67lE#G2WzC9^G}<N6GIDLYCoYKr8$WfNk|SW=h2WD;Jyo
zzVG{@<$(irg_A%QgE_V3HNJjH%!^As;Fi0TU<FVg0UX>SIuS?;dzSHQU&VdpKX$c}
zkelk-mojq_hz1l2VJaolWNgA9Az|JoF$1t>UIH)SD9{HE;Kiu=0uf?Y{*2svgC$>B
zku+0@6bf{@XLkbJE<!jpdXKwn<*$NTxqbCv#WmSkm(-T@mjIIbCf&n`z6Rv$MmAUK
z#Qc2$p`~osjn>}S|Ml~)Xoz=LLiN+8r^in!Qr@vTP#dzrv#-u^og^lCrYnpA9_{CJ
zlIrfhj7fuE`!$deVwEn=eO%z%3E8v8ZVzvQLTWyk*Tp+YLmVKnd2v4u0}Cqj3PPT#
zJ{cPoWfV!){e?>X6;+M3qto;r^CDZX?|tmN=fE3cpZfk~94^Xs&)DEm%vy|~ths7M
z>mQCMT!k-=W#XXm8qWdMeTCSJ4O|vuH&zhQ4U;ROck>{EWN~Lyo8`;StNN^!g{<><
z=h3KQYrG#yl><<hx(%zk=MHPtfcfyh$@(v74%V&FOQ0{hoLK6JT7J6NxSR)1g^dJm
z^Zn6Gp_5<&I_7^MP`WjCO(EtT6FFM>{V6M{?mkdy*=qh#qQ$;r1BWY2Z)oZs(;%dr
zLx*b>D`bLxh}R&J&6>Zyemuo1IAJM#CY)qoc}D?lAe8f|Y)Ht%O6S@XrbcYy7n}do
z>E7p(vNl|D)X$Ib8Ef>pwR@uIxa>Qf?uB0?$69c7m9@c7sdHT7Ks!Ak3%At!N-luM
zgHzV#*iAj)!YAKN4X5z5G0gUG&M$Nj2OU>HYpCs3Uw!fLN2&)-fPA_I>35H~Cj#ex
z7xnGA=znpHqVHuFFvP*)n<b8esJf-0O3bxOd9<?uXEGGa-2MOY#wu@PdQ*Y!p9;&c
zN8$mc`Sj?Nnc^Ba1`V_hl6jT?p;%BL0vvmf;RR+4%tv?0wy5auKaf2}{jQw$nZ$SS
zy;z0Xp9Z^p7*{Rx91z}B!7WaTeXV~a(g?G)zWJ>f#hrS8k_wb7R2)K;yQL?(#Xf&~
z`~>^^RGQ|rL1pGXZv5fZZAUv2_~oPZ+i_I}3b7uroaIs=`Z+gS&v{BpJ=>7meedK8
z_6^{NYI#{Nxc-5wOsSHpyy0A2xP(&R)f^6c`F4|S>KpEEKMZzc_5IGrn=I2>Lcx=x
z`p)pB@t%YQ2LtKf@OPi2r=osKY`&mLDhf;#@*TW3&~lno4+D>H@P<nUZ4aNN&EhK6
zJdZ$QRei-Aa^rL$N4hI+eqw#)ZROnl7WC(e9bPh?D^X~jXLXNjshC6samz}3D$?Al
zlFWI%LN0)n$&%x3xOj(QCr(h0fmWD#!a>Ewt7w}e@ODLVzz>ac0T6U-3oY_sSxO)s
zDUp*+`;SZ%cOz26N(Hja4zQB1L+AH?fm$g4mU;T09>4Z~GGd0sQE|LtA+9D49<(;9
zJ>>xP_}3@q2I?iIZua3bo6=h+q497wR}ZPkRD<`c1fXLz-2J6zCqzOZ6Hm{rr~(Na
zOE|Gpjg&lJK?<x>7=}Xa2+4ZS!YU`BVHqx{rOZf4*q80COf&igL_gDpcnga<?M_be
zM$`C0Ygj!mT759f<NT(Qp*5QeAmWd4>jE${L#2IHcwxfEKR7-&&(Tj?!8m)AXFDr$
zq3d>rXX=)lE<L?-O(S^_W-J?sTz1t~#EU0ec=ZVS-0zXz--PO2TSA0&zH;z$AJD(4
z*BTro$N&i=9vq+$tts~teNX2*cFeuH7UhqrYx-nr>HHwRL`G(n>7Zg+X*aPcfd4E@
zHhNb<grzj;P-YP>d4m~7Fd69+`&MS*pjfq08EIE~w@PTX6eLnmBEh|ukekDufZvdg
zgN<srgwyR0S}7ohbxC4(<4e9OG1yZ_vvlkT2vp6JCs5e2Bxh7nD*P~xUGH75bvJ?)
zyMzf$A2iP+(j!LSJ`j-_R2=To2wrHw3^0fDmHl`+4il>4vg0L?i!gF$SC!Bt7%RC5
zQ^(1|uM!em_?^1qJ9?y_I#@^`i`=UA-o#ODdd&V2`TUQC#2lqq$m)Q&Ej*_&p^QB9
zS;wS%q0_Bh!k3)dG07$eME-D@ba7-hSEG0p4~+m(P->m+H`8nGSxxH>sr?ZBgc!HK
z$)#t>gFO+<aq+MFfEX{%;KvKm7hCy_5etim;xSPVzco%%%Y+PWN@Zmo@_nr0-id=F
z=q_$+{B_}AWxNhpBsODQHmcm^%~nH~*z{)7F_mO9liNLe7a4IDo<4$QXjY$++g2)j
zJ}>$b-LF}&l^*EnEAbzCz;JpiGjiTnnuQ)Difq&6!V?X~LB(8}S~&?9bTC<aLD0~!
zw+?oGDre_#!OXszcSf1iprVndTVdCFEVx-dJ>sv?NlH+A^xJc@*Am349`bL03Z8p#
z#(jFHlp~gR0x2uA??5R-;nuh*pN;Fpxx~AD<vCAA;%hP<R^IdU7T6JcW1`1tXawQ{
z#<6vOBUT9p-vS+u`c0vlPXWrBsb|*$rAs6b&jr%`jS!#0LvO(z^5tA;J}*9Nt{x&`
z>08Sq@GMxMJJWpLhcnoZI#FA+9j$f@t;lg(cINm+=9A~Xk^kfoPg!#x8+-0%efycj
z2WdKGHp<CeM?WuH%&?Mbh^6@kRHB0h8ybgH|GRug7eDp%XU9gzg;jXRd+wR0;bE+}
z|EXiVe5`>B*w)~m_14#UKx%3vbZo?KO6SbSkUUQ38Xk{tW%5}MyHA<<0vlhY<y&<}
zkJYRL^F38Fvq#PT+(ahw`AN@UC;-#P;6-Fz7YyOqaQb67?#+tyD~AR*9hs{<rw&dJ
zu+z(A(%AprH+N5FpDuRMFVD6J7q`8cEA=h3RvFrf|B~)8eWklTN^G()*|MFOl+*4f
zje9g_uDAN}%G}KtFWVft-hYgcctg^erWq44C$8I`jK+M6?q{ta3h%M_dLx+FsW$Gb
zfib?Pzo}e5SU*$3U1#~GwzZsGifvtY^Xo?4GPgx}PJW2<{%qKKLbfs2i-E`9{W;_x
zD*oMw|NUOhJ}czb;4uWcUPbP_cFPIh1LM{Qkybr{)#LB-&mIc=#^G){M6(k%S!QtB
z*5aw_fj03^fB^OE0yJ%Gsh-T&`0{De@BtLx+fLMh#vzeN(AUm5_@=ZF9>h%<$Mr5b
zsK0NvM0Yaye7dmHad1i4s@eT%*<(M&$AVx;PF?$He%z5^(ljm}^J~#HnE!Kd#vzhq
z48uupck%P|Liv7l-g4N(`Mq))hY8w8@q?v?aoiHDR2TW)*B;DH+lm+Bwh{nQLp9@I
z!H&1@gbC&wtOwtlI(}UUD*7&#uf}dT{RI5|IG+Tf_0wm*&vgEgtgdw=VrTrz`qvk`
z>?&#en<WhL9URGC-3Sy)&=Dn?jgpu^Nuva090e4z1ym*kG*E&lAKrNef8GdYK9+x$
z@uwBK&(qB(NxT@V$}bKQX!GWEpWx%~My0bG!F+^IZwX_uBHG!aD&2eml)GBp(%lpU
ztO8Y4&cop?WgoZGodAdUAn%7Lw;@GB$USWSuc5r7UPA^0LTN2o%9AOyA<R;*bO%cE
zhNBdUbmkWp`f!N<*N^H5&MipKDHGP>+ArLpqK0&hQrBQ7`Vv(RDkCC`Lv9mrn~j)1
zK^y!Pm|Pw#i-?`c#+}4UlFIpL1pZQ@PG|N1F@LI*BX0hrC4!Dl7r43!(!*JSv`2<5
z>#hgkaafrpfKQ9Wf>*%95ZK^J=@2Icr5wfU$tF`6Tn^XkTbD8LMcJ#Bf_ayeY_qrh
z9J=5t(lv2Zs1qL6rQEu}Q{SzW)vcm{Q)N+9)10JQkN|j9`qj|J_vGij7W|enf|Ct0
zY_E^GC?3CvBx_`gP(;~YX;_@d;i?Lp?e%q`C%eR-YiQUa8Em5uiUlH)@b5Z{p*S68
zAIc|Aguv1k<|b*|X#qygYHyv~$%@j1OM8<X0v-yI>zeolhUs*ct!#XL-UZ&`5RAAl
zrXC{>uaHJ$O&4rGCnVz=7-Bk=qIy}Fszgf80H*MbVY#+$N;9l^SlaC(W}#E89uy+*
zRn|FY1qyBeW2C&wg~cZ$+pb{7DQGrTTlLxR_#1S5+!c&6MB{QhzJ;U*()#{jx%my@
z#y8t-tT-8g$_v1>f==UlZ){_g=kOaHzEXNBKsUy23G3TdEoShA9Qy`!#H9cr*qo>T
zXYI&n=X3-oedTwt=I#zte<S#BP|%x#p6Zrf>(a$msk0W<Z_3Yu8NyQurw+=|k69qQ
zoDJKm>W1%FKEL?$gN`dpyo4@lFi*I3i?*ka?d2E4Zj<LQ>Pn>GE7F^&1=U5v!%k1t
z9ckG`9$TkSn2#kFsglHHb+zJoq56wFZF_pP-MLnQux=h;CrY4J^8iJ1*p_w?cuxQk
z+0hV}L22vqL|Ih;CaBvD5WT_bA&b)QDDSIKFPf)Fga8M=ysO*glI@+Oj2w(=q8`hK
zq_XRP?2>YBLJ^jbe=Mrj0iw7C|9n#jlue{|DQ9HD{~NL5aP@Z6HRfKE-UKv0^z!uj
zbIZw+lXo3v0b*Vv2HJ1u<7=QV6w*)8M#@SKFY$B`b?S8>O?fIv);YU-y1JhOq)9`W
z;PS*<<-(m9)Amjyhx?9fHFdM*>>EBKu(!0(0M7$WAZh3RC3yiD@eCI!1@IU86Dz^K
zTnias#izlRYP1=k^iNtOgB9^nGT&CdsP-=m+0|6)T4_z7WU;31t#BJCj(<JSb*byr
zwJyxNMe;${V{4EJn=NE^8(RlsM%CNNUFB|^CGvicwQ$yy0?{HN>~y(mZ#R*n6WzT4
zbsfP0oqQ%Klr|z?-ZGD>oHQGUv)z?$r@=m{10CfEH{x@z9fzdNdiDU2=X!=>l^8u$
z{>e4#_ke&FNPr*9=RQSh2N0XFNDc<yI^j1G%(up3@Ezoa9=#oIHxqtB^s4j8t0!+?
zJw0>vtmrl0lh^!jU%N1K?Xu|gD<`jCzkU72$-Y*Azc4s(k`S@w3h7%h;U)#W%nG}y
zKiCOx?5M|7E%4@1HtKOwP&xKW9?MiPO|}o==z;!FbxU+G9sR9xFcqn(CVE(34$ok3
z4WSRd%www1^P=N0l|e?mzHG*D!z1%bxA%FsV`gr@wx>uMeS6caEbXOaI^2~%55OhM
zMW-xDOBex33c4PLmhVEX5e73GBKs_Fa`Wqp^|CD67y4&nf5KPk4;z4mvxnu?@IF%S
zkTgG0>q@W}H~T+-B^k98!RJG>LmYVQ4X?3O4PpbO3-7@kmZccnFgeSUtT^Q8gOglD
z9(Xyrm57c)hHzj-8$c52AR&0U>iF-8XuKP%g1V@Y@!oy7CTAhqVup?$nNC)ef2IBo
zI?=%3!CWDQxF<i(uo1iB`iUs(QxP_giW#ZkJ?h@xF&>rkxJ6bl2n73iD4O*f4wMpc
z-#^=d0Rj6iah`Q?anJ&;ia3$O_b-jo01`*`T1+nIA5x^KSiumiWZ@X~sNNU1IgR`7
z0o1t#@NX_efV8pLAmh7O-g3xH`CS|j9!sTvpxPui!w%{+0fJGfJb%)8Uc&g_cyyQQ
zlbo!*SiPc1L?T4Ef>tCpNM&_N)nbRj-`??w<A;}HL(@{_mQvsLybQ4Y5Yz^nmyyO0
zQ|2P>b)W2AiMU+w<OCnQFk>g<Wqjsp<bd*tZJuua2%Lytg{93CQo|fQtrnB#w{f1N
z(;cgZeNv`a^zNFw($ap8^Kp8N-QD*Wcy+}G@I?L7_c4>+M!^;YYifW}RX*Qh{y;TG
zXu!A%BNi@0mtOgge>L;MSmAH^N=>6X%0}1%F~gfr2gVl~2D|jgSul2O42{7fj(aP+
zQv5c-CQCNxv;RHKdmfERjd3IQ6X<t;->;5y9}atp6DQNGZr6v7hHX<2d6ynY-5_|c
zNJqKWg5K31j2QfyGEQXyh1*1Pbky~ZKf!{Cir+r<`E$3O{xZK57K;Aumqda^nX3Fm
zosM$&lpAHKyyS%g?<9tgzgJon>taybkPL17R>31QC|y#{Umpus1c`bZ#R{tC$VDET
z-G9nwC4Nsnm)Dp{dDibXj#<EFWGn?P#6@glg=8&xm<f~)C25#l%L%RruM_$3JZs@S
z>bFiQ3toQJ9Hr6ek=R)LU+-?`=e?JG&-$ZtF|R<79`N`Y(fK7Zar}$4+qXPtsCuE*
znLFKldF3y(a7UPNCC9Epp5gKF?dE?yc;nh*BcqsN^8=GIeD2xEs2e185BsAP{DkWj
z&)yAeJL01s7M@bM(|^w8e)4FHT-CdrXjgWopVr~lDL#x4y8CmZ@u6Br<2*rhex#>E
z0}KYR`w&hj00LBx08&6M*n|Usu>cO3B$>(R)Cp@q3y~q^-HAvU+Y)k9MPC|PJ7|8e
zsd69-W05Lp(_A%_tLXf|^OOMLe>}#2?|*CDt%}p|g)#zj?-B4b^<rV%oz)YS<Xq)5
z!>zS%svRotLy%l|iOw8#A_vKD{UwWw0RV%0R6o}e@aDmpk+yHnz-RD54=0y>rB^JZ
zJKt_b-K#S6aP=#MkZSjsCaB^y+TOH0Ac`G&#OW9Y41;<Fl-8XyU&a*ar6t-wZT<45
z#<{L^Pz^9qLq7R;<KavQsxst!6i)e`H%cutDbl#$OGvDBE6i2XCHM~0=rQ*@_2}6)
zVntoch5ueXzu|-X3x==+FZA&cHxK(c6g3L8M-0k(GNnxM_D^4P+zI{o>BnqS49A$v
z0AVL^+UtC=a3142TyJe50h!cm9YHVjIR<RGFVhHuht7+MVwYg(Sn4r-y6{Js%c%NS
zV3tOh1r*11UjwtFgg2|~Li8zAZzTl<Ra&82YVC2wehFT+0gnF3T_KdI%@vu0sMAMI
zfs0718h7H@DxoN}vy4!Xo_Gvc#E0MWx>IX&_I!n~(&v)!={XVH{^;%r)o{t?OwXVN
zLuVlRPf@kF*{Voqj``DScx)`a+*)iIDdY=04VktB+|K=y$?V^9yAyh?AZWd|=00`6
zysWQ#Jn4|YYF5r~3V_y~vkqL6_y6IrKi3%lv;RLmcPL@RJf^{B;SMJhQ+%V=TIE~o
zlsXl9Y(GR3DSCE2>>=UZ`TlR_Pb1_UQYt*M{efkw#c_jgNfvJDeU|<kX5ThuWsWDt
zy;ID33sv3hy!UDOM1;YgWyHC&-+N9`czoL?V_nVOp9enfE%UWPw*1p?G+}rZT6R!=
z3-OTZ`t9Kla@x+)QCQqe($EH^g`mZSsjzkGY<hEvC30`X{PzL~_53-vi=EkiaZTe@
z$ok;+l*`F~h1jx43n*}Dg%=?PLgVPupzv?vvnq~qGk7X|QV$zQ7aqL5u_DKLWWZB~
zK7dJMMX&y+DC6GzmMVIw{S-iu5jEKwZ+W8_rS#nc$m9YH?W`aL3T?nGRpg5Hs`hL9
z7$~9fdFz645L><C{kg~-Q2%Rd>9ROVV2$Q-6Wau<j0Y4!<5*_dzip<{GIMxcFCXT2
zEb4pFHp1|k$HAw;&esk9e$D&$`ig@HBr<x2?X>Q#ROegcu2p4Cyg(X$_;;{7Q?}jm
z>vJRP@M`lb77KuTU+2*g0f}$M!ot(11O_{yMw@ZSbOuC$+{NRu8IK-iK=lXN9S)lb
z?B{Xl95Pu=b;a2}n}psVBvs`@5|!V_ORPI^=JqZ|pPnVj;1;172HofsgCRbaOm@%C
zPY3GN^^?wd5!vcel~ON#lFxaCW-wePQfFq1Y-yc|XVbrHZ*5vPk$f0=PvS(D_wvoV
zo49fy39fVkq>h@6!ZDYne;5o&_{trP8Aqj9fjvQ4xIs<!#f~tB7ttL{KQ~CjL{=o8
z0GNCUE0swc`+er6i`g^W^&)Ib?)wHl$9-HD8Oaz@(Q(R*&TEjpf54^e%1y>?eJc26
zEAf>qmyL57mVWBZAtsJWH}UHi9ClCADtH3F2<en|@)%0Px6xDv%Sq!#N#-SU+3Zp?
z;YFC01PznyA8nn3OM%oa#X{Xqkz~$=K;GF_9FJkXx%)_RatIc{%DcIgg_9UQ`UF0y
z2o|$YKkCV?4yI?7qy%C5_6CZ;HAzMDWLfH9u1Eu2p($Ukk~JG}bVsZz<_l+%vSw{{
zp<=dBA4e`vYA%5vRhsx`MKmmQZ2?j-c2V&HCV7vOoyAVK@JxsO*hq+sZ{iE`KCf-0
z1J%!SOz|v!fGGQ7OMXW;jw59Izyqn84P6=MrobmNY3$fuv39&W>0!tj6}5Nbu{FmZ
zJ%B8(n{=!rm^o9#F@X~Mxo}fDL?lG8Hh%dQsLIpm7~cjA&~Kod<_-o+uQ4pn*IOie
z!)0u?&`JIYnqvTrgHqHh3k*{{j{5K(iNf|69uWiB`9Y?OC)vwv37?~)Q;7zD>C^Vk
zwRtrmdxWFOT2aH69zqR!!jb*Zd)M!M+@44~2&o>*TE|p#9y6L1OSxXlflqPK0dmoO
zy4yrVko);#PBfJ13Vtv@02_HYIH009B6gH%iy3y#CJ>1C{x>Yk$jJj@|MNFW5N8dZ
z1X{<70W^nbB)k)M+?9Hs8RTpo+G9$;$Lj#IkWdmBl&5N@M;!QyK~Hg}osyh*?R~qu
z{%J_#VH4&1WZ<zwol^_&I}D7SEOIf0m-q|xBt}X_nh{%O3oxKz@E}Rr0$kF^F>U2}
zrHE%{A9lUC@hYQSkuu1P1czjrj9IYGGiJHM)D-AjkOf|s$<wt}Y`Dm>hprq*^$ycS
zUD#N@CZJ?p+P#(dnp++X?%FZi-S9R1*34+AQ$4D#wwfqOirlYBl;o!f$1uB2`RsG#
zGf?jDKmfd(F{y2%NgvzYy$l-Ui1k=3bv0?p05O}*B^~o@rYtd{V;15Cckdscv&lVd
zhuRDNEQ*Bn_#;#L)8x8SU)L{B4IZX97yU!{pL|zv5x3x7opb4Hpa&*$)>Ca)Af<?#
zdNjZIsMw1Bs`OBt#NrT_-0`UK3x!hxXa8^zq1fAZAPh-%v3Pip0)0?il+fJZJh&a2
zp)0d0R?=hroX;mC8b5={WDPo-q#M$Wz2?0?7dU4=5cDct)B+B?U}Aaxq_|)r#Xy)W
zYu3Wub-einhpF?8)>^)+2_%fQ1X-#y^2y4%R9`2?r1?VM&(M&b<*)~kI-?gtIG64x
zFPp8~p}35T8W7|zd!8WptEi#p>sQUkt7aLcZO>Ucw?eCvc^mOQ;kJ6+OyZZk(+YIk
zf0g=)>}o*noR&85f)xv`eP?Haw}7WgSNO%_&ncGBsFg~|3ujY>z)k7xKP>8A8Sj!7
z7PhNJE%nM@8{d8LxAl4&^><;xpq827Re+}E#=$l(`8}-5;37cDXmX^U;MZuhz<iG2
z$hU(DXq@{gQBfHf>-cZYtKHK|=-v|);u7+A3flq0tHaP#)A9I&CGXXle<gb<jH{JT
z<yhfbLPVH0il5>D2?kDY0nnmss1Ar%xlf>xAlfzoTg>)RZ{mpu@fzsEB+-DVEAQ8>
zxCuNG>2K0i9r71I+!&X*=?(v`pzsban1qBSVPLxGtE!st)p70>UrtCNV$uOAcb)GX
z1ByTaGkC!r0!-gMp{iF_yDMHDmhh+gM43PwIQvRce&UKNO6r&W7GM=N!5yWEIYf#a
zRtpFwvIkOR)`DXZh-+{au@mdb6b3@+$-pPXR_w(Mk~+9Xw3K1816=v!CL35~(ut#}
zva;bXCk=)x6TlPKUd9K65lw~#Pk|k2Z_ndbuO*U}PJC=t{V69<<?fCI0UpR0cs}As
zmFVm=th86)r-EpMi$_#8m#wv-XrFGBJo-HYsxHJ|ZteBm5nV~($0l=MZRUG(&a<&q
zAeqT0lcctV<bh7WODf@~*L*5k4L`M|k13{-w63hK%G?zZSX;Y6g6d^@!!q11(DH>&
z$Fj54+?jN)H`k5?I&j5y#>)3_M#OTRWjc#?L22G}c<cX}o{y~rc!uboYEC>9aehFy
z7E`*icrQ^@EC+W=JkcdpCNf8{7F|-1qdJ#!$uUb^ELY1gSLal&USzHTt0>p#Nv_FU
zuGxMryNdgL0{uJ@8V;DrYWmeSXB$sKuhOA{VgezIEYA?mKQJ0iGe6TI|D;mh+h(3w
zZ$64)flqCk-7e>|5X3AAF+ZO5p*NytGLxeTHa*TC70+J>T*F}Dk(00#x&r+^I(i>*
zi@VUvM(tIsH0L5>2P(XE4#}e1bukfBOw@${h3|R>YXh|UFu3d%Pdy3NvZR~}Dn7&%
z*OQ8q#ng(K@S%m`h9SO4r*MY}-^EziX(U%JlIQU`IExVYBR8`;-tH_K$PR(WF*zv=
z?gd&N){$EW#8&kLbD8MzeZ-{A-8v<;F;M{Z=(MAwdJ*fSDMwehM0wt|$!L}zvS(8a
zt{@QCseIZ2QeP37f+{=2m;HQlcfzRz(vEnB5e5|_uFTxHBkU;1Y2oAz>k8p}H_m&?
z8pDP^;~XGq<Gk|#-(#3$cPRYT8m3V13NM9Md*UVz#I+xS08ijLT#*^Eyu*0-b0qIu
zC8VH7xoC0u&+C;UspaD96?o;!rVzmlByYM4lIp-Kom!zR4yX>7)#983$5j>=3hbLG
zZv+!L1-RIV8~6E(-JL#fWI5w(klpxDw_m)4w4)POrPCwAIAopihDfE)h<q)9Hf=a~
zi+7A3<w4gh5sL~eE*#FKbp1jE@u(*KsV-*Cir@T%_%#<HE`yAGT78q}UbWVh_e{is
zlCT>P`b3b|2``m1j-P;GO2vS?0A_>9!;IyR4>hbyG#+8-N4j%<Bnb8~c(3On&Oeco
zCzXIvT#r2XwY&H`&kJFGBUT;YT}=Lcd?ce-;ZZRn+Tfu^n^$yu{n(%S32`7~{1yb{
z)I_U&yRDyLgZ@5yA|RIkr4xTLUi>1{?eju%kQHw$M$ZE{{Vi7ST*%QMfCO9~$yP`$
zy^{p)%h8mP6uLtG5Jv6^rVOe&%Q$5{!Bf@*?-h0|Pd>|8_W-4bJffmkr%XZr^^y3C
z5Qe6(HcKDrO1wYU@Mco+$`0Zc3mJXf5q%a9|0)15=sMX7juoHd7n^v>ws~|YIyZ=g
zek5cj+bIp9`r-Ni;xpzK6LI1Ig~{EDfp0LvZuKRxZL$mg@W1%Ti~X%2Z|=XHDR-*d
zf=5y`No^dIHl_Q9g2GTP=lfd5YCCKnY!k6Xhe{0zv0JUQ_rzrUFC049$Or;Coyu_z
znAlF`F$;)Wzvow!)FvaPjLo;+lUjEZN>t%&-xQM@6mas!>&YQ+%Ga<$!rZ(yitLar
zX;;`yUya7d%oRi&5@2qMxz9bG@R2yoN7!{I+J)LV5i0f<+SM2D2%eLwqAOg(OGVHX
z?3z9PBEt=?qp2)?!5@?AKXBIY_{{%QO2+aLSK0)&ejzyYk;9u0!J+Xe%1h|hi!Bx8
zj&Wq|E@A@1$y7G%{rcD^TXPeLT&op|TlU<?FagG~z<BeUt(4*>${|J@ZmoWQFEZCC
zHDT{MWJ~doPF2!udWc6xY>G*ZbRj8MOZ%0T;8#`ckyD#uvg-&=kIs1|&dSPaD37p{
zJfBXeL}Izkjss`K5>zKH1#pOG#VUq$MK;JFpKT&`2`PvQr^n%>HHSxLM6P41$jL{D
zdO74ps1I*;KQFdl&#u4aTt8%jtK9FAiR8U=oAx<6v=d$D)E;Puo}}CfZGOlUOJdrB
zypP{tIayQ<*}U4m2?^7TCkS4(fLO)qcg{)eC0w}wi04ZSr|Q?|%3Y58tFYwQYwqcC
zbU3Qc6IoS)xSu|}i?_Dh6FV9;@W!X90LVF3uJ3w-@2o1i__M$z2g8g6EE^WRGTriH
zykh?A^G0o+*)T-qvTf|uz@KS-iy?el1i?jmlyV&J>qq=UbcKL~m%MSWII*uvEM9%G
zM<&x1cJU|LCDlByN+!M+dQMm9%;7h#6pL86zrUJM)CHY~$jBFqHB%zwQ%us^`Tp`Y
zeb+;#!d3eSuYav-@m%2x!vy>VF7ZmCu+NbmjERZq32o4&g&g0XlK74Tp|c^dy9=;p
zmOzVwoJlwywnN68_2!Dimq}(r)5gt6;GB>Jn05vXeNiZgFr_##^}Pl8gdoWMVbbm9
zrF^<VZPZ)OV@|Ia@a9vO>^{8p`$s$&t@rSp4*Ec>^X6@$!{j@r!%Szw&&*uAITLYr
zChGZ2^oN;S7m2ASMRXMeZUEerXL;pzNWX;=bdz1$;%v;ARHHZFNy|CcDy(B1cfn1*
zF>iP!hK^m-oHv{>aDqGhFaH{4h^l<n5P$4l_Cu*7zvNDr7ayPCZIweV#wtQ8UWgDi
z{>^3D$Z*R2_8j+qBY?e4TYi69vA*e{)L^guNM8HIiV(YY?tUlkl#E}j8>)gObx%$S
zS+^-RjpPafYM2A>tmS8`75&zK%~$YR40z+YufB)t&cEM$RoRT{%$T)xDS6e$AF$(>
z3P~D--F9rsw0PgQ`CNSLI;?Es=?PHa;lh#lPY8`k?j}0dE(O-gu*#t8&yU0Xb&*Fb
zAjx?6JO&;Cs4>4u4Od)xT5yC*6Y;V;Oi0t<f+G2I*HBbw>c_lP&d{Q)w4jC$3n_7d
z^q+{2vGev#O1~Yv%0q0eFoI3visvPwqS-%5y3TG6yha$IpZj7ER`FNsN=}F^7{yny
zTel^s+^sZ!7`E{DOy3==lILB4>JZ(8j1}2^Rac}8*hysV<l-Gi2$H3Ta07sBD_%~p
z=llxv?EiwG3T>J<azm#vd@f;*MPj!?jl{p-k2?g+GB?Foi-;Hf*_EeFOFAwY9r^h1
zSl%uE`VL}od8gfDDODhZ^F<M&M3&RdOls$YxYH)?FW%wYEhYL5iTv<>glox1?7Srk
z9*N`h9>>j(Gu01J@LQMt_*=WgKZo4<q?0`Mh<~{l1mh9p!;K2vDS}Vq{Xf#pHWm<>
zuf$NR_P~Pn6G6CHi@a|<Z%JrcZNy4dC?;{&dU5OSH3w*Y^Qz>;-S4K>1nA1{#9eut
zl`k)(G6dM$Ho`Bq<xlhjHsyMfuH)wAb*e#Q9Ai5JaGSCOWM&sgj~GVRznjCC%rgY+
z((r<GYiCx-$Pw(fb=YlAxpRuL-xS||mXcnlZ;G8Sd~MrQR5#9@5prJi%8$%Uxfeq}
z3hcRSBrkF)$&bwF4{d*8hfW`QVSIk8d;uiNy`Nx-D`Io1%v&xq33T3r-8qUxGy6cd
zyu&u`ed~vLK>PF~KsGD{vG2Vx+Z81v0^D~HB5Nb<WGKh~I|Db9+NxJ5_Gf=&Fh8ML
zKYlO3`AVPRY-!cPEsdvuH-7f#cRR;5Vd>yQ2e{7`=l4H|gI6+r-M4JXBGKANth132
z3)6T@&UO6BrE1QWxBQ`|TZw<Ki)P6kh#E+|{ME>M{cB+dA-VVM*~coCd>uQ*Pch!<
z+Kv>Hc5aG;5EX+&+%V$EHY#qExv%kb8mnuOivY4!WAo3le*NR2J1mlt_{6|;Fau_p
zf)sQrL2E8sWuVodjP{Vq?o=mmdU&DJs%?SVnHN+s=TG*<x)(q87CC=DUSzo<I}af!
zq5zXnDDMISm?*d6=-B@K`Yb789vom-6CA|8h9Gd*lN)l!-1j&~@1Mt+esAtue|UQC
zsY}f~HE`VK4A+UEr#dE|`{jy}n`f&N-b1~g(!am!x-4a$BzbDvZ#Z8~o0_Z9S&@ET
zqq_d5hSva%H-Gi-?X1&Ml>G)dlh$J`-4P6yknP{!BYxd(`@>4|YFj%Y*+=YDg0<Bj
zbzQlcAud|Vyz+UeE6uZ{-9g6UYwz<IE@`iWy~os{+~85Xy_8OvDc1r{;kC4(YtRw1
z6JpFBT$rTcpD&ti;(tcUdqcuB%sEB<m_#mVDxSoxP{kziYV_hQ`1Dtp76@~QrX}jA
zY?Gzn2}?~Y;gfz%R-$LAn$}|eRZZ3smwPpjN?l)RIw~Cl(IR7$Wt+(|S(aKha<~1O
zZ4}Cc!Wy7MH9dxka#Rk1qc6ruBL?C@vSOB!!(k)pQv2Jsx{aQk5*OyFJ7d=U91Ce)
z+r*1yH`?be9=pSz0=?t-QQ&-8j5x8E<v>NpE0je@D({Y4UfF4JlE0hs02>n|)(8vE
z$x(K}i3s#d2dbV^O82YSK3eqHD?1fwQk8lSyE+~UbBpo2C+vDQW8SaGk1AXsVWBH_
z`4!Mj^kY|!i-ni_9PaPVBmpT3uVXSJM+Byp95{4s#ceB5Dx%xJq(k~1wVlB%I|aOp
zUO=A^opm$nm#&|84al!yC{@3G49QOARXW)EOfQ7}8t|qHf6`x)w6h(gPi;KZFSl~j
z`c!to0bC2SphmWcTAK9877%FUD$z@&L+7w+l4AXLe6@zQ=;y%PvBekvi}x*?n|3@|
zZWWMnPsF`HSaGd9t-v5ioR^)S<%>Aru716#$ImD+63?+fQ)aonk5H0OcP=Q!X9tyg
zTOT7oIa^HmS$0i`N9OL+e}PE@7a-T{c>I%W6bsL{IjsF~xE)Fk>E^&ohSn-1hZ^Dh
zMij=j8uq?PNBKNCUQUJ|8yuf&=VRnjXDM<8R|IfY<yTtI^cUYeA~h&6l{%NWb~A5m
zqPR?>r>f9<X>LGl`1a=sQ^4SuDRYa)Omhvx@H6;40=NxIzxkH;(Se4DRw*rOxrE?|
zRx(Yp_Pb+yZp=rU!Mqv~P7d7**ACvhE>-MvEf?x{N?f%>{@zR0HX>EyqRY`Roje7y
z6E&0KYXsU$IPW&0;0^&;s@zJ+<#~xI(KT|wFdl{(WYbvbl~m(xvGpY1jOg8rSpAX-
z&nhJUL{(hSVjz!HD@vK{2?6FOlXhtMlo$vGc^+ixq>6eBQLo|&xiRpOl#h5gR}=HG
zD+35MuogYni-I=sUF}WC23)#CpmY5;7%jD6h`-QZSm%t8KtW86I?(bp(V{-KI67TM
zas`%*?E&daa-T>lYr4BVXka6P>XSH(O};50dn7`Rn!Mi*_Q|9@N|LNd@w6l3a=LYX
zQ|hs|ca!KZ_Fe)`lLboggC>Vt?VJrLxyiv~b9)@BZLBh_h&xtRFzi7L6GY{*Nl`xx
z&0+#dNgr9|<$RZ)jG;iWaGTn<w|aA14MsTycK4E931Fb+AVFAA(^5rX8;<BF@mMkX
zT=HrqPin~`YbZyB?!_kicJy1jvfGCyLu`T+h4{+r;Fs#l9e#zrsW?($LBbQo6UTRq
zp=SnkL#{Sb$>n@rsEm^#T*;AaByV$E6630sYO-o^`!Al7L28nGBeo*F)RO+KpmHot
zMA+hDVXDk6#ZqHUh?K2sy3}Mj{pMa4EO^}d19Jk}60t1($SFlBujj!<mnG}caa<iV
zwCEglSlUM?$WyI%;vi%Zc{czeyXoKvu8reQ*dtkVIwYHfbjb&jsZ!mTll^+rO<9S-
zEI&EpQ^Ri4&A0o4&+9%r_3GMmOBv_I04rmU$%5(DYO9MuuFpKC+om6B%^kOB#Ux*j
z`W&Afnjlk{B%>?dXH=SE;q{owdDJrA3(u`Cn{;}9`NhiP#(OI&4WWD&>~BAPa~0yV
zf|00A=Mdt`fr~vbrtKO)MRuNLQwk=L7A`YF+SpNtd3j+nhNRq0<7W4f|M$0F_Qlsk
zb+PxUN0SZ`M2?q?k?gbY4t18Nlq%YU8*CrBGmewqY<HwymH@QE;ksGTL*b+fx;t7K
z8Ht}#@o`#;DKY5NL~VtF(=ARY`ic#AZfPa0Ax^l&Ny6?>Mfg!!wY_oK**3ZIP*y8)
za|xn$y#;l;<Tks4y655HP9sG`fV;LA#OG9mvv1!(Xe1bpY~9^L&lMtl(ZhUc1_dPX
ziQcmgvzme1zP8HEf*$h?M}>G}m7Fa2R%2)7Uc17u4wZ>23}}sp<E}aS+gc&UXbiHk
zf`uoh0VOliITtF=GfawrMSHpbKOu*2C{@AIX05c+vw1y)CTK~WeVXan{JUD`Yt@b5
zxV)z6Q-4k>TAPGPu=UT1)*fk47&j_!EEq62&0m_moqezMmCV`Vu;(ru#*<>h6o}v@
zD?E1)L8@q()Q&|dxd5#{dH>4#@vgg&&3uZGDgeF<p3+1;-AZ94dOFL?h=r0G#?yV+
z8|dqW3wG?c$RyFlMUU8kPVK{N>Ww>L)NHVxi74hoZ_wR5Z{gN#6Ja@yJzN_%!N_ZZ
zN6>at_T~<k(Rh+d^s+wi4R4L_E=S8<dS+#Jp4@aj=bP_K>X&0NPw$#$_I!~v02oY~
z6x=F916V-1>1m!@q8A^pHv~>Iw~gM(B;q@kuem99E3bS=cK~;yL7Uc&uOfu;g}v*7
z{8EflvOdWMlWON*a-W$|-K#w@X&OU7>j<=_*UT?FUOJ;vTbaWh`iZFg5ZF{^S0Vwu
zTT;<-lKQC?`8TRSm!zuLC;I#w$Mr0~7%6ES>s9(&q0jnQAQif3GCV%w(_5MHKgIP9
z%cD>UNVll{jC7_pY>K?ZvjYQmXVZUI<oTYy*^E!JfJ)IG49X~LwmbUR3qJKpK6p{R
z;)z4$AFF?}>Nd-P-LT+IpoVFM(s=w9pV#H`m;^jEqNh66$lJTa;ufGd7)LFGv!#>s
zS(EwCbv?l%t^9V=yNXZm-$?oJtdliN*z+w-Uw}TNlzpry44+M|6)<kTqMKSMWa-Vc
z#tUskHc|<M@3|aS+)}y>E^`iUu^ZVtr@4Esr2o94-hT%#*r8a_&ehxw+sx4*(|Dd#
z!VPClc9A@Kbe<tzxIaBr4@M6l(>jV$Lji!LMo$e<OjT*G@~Sfxt?kKMBb2P^9e8u2
zTxiBr(!kfWm^H?ZOoH{AF+hfd2PI$i)la}D5%3Tqo=Wh3aUM_e000$(#%My1TBlhQ
z4MIY5f$#8n@y4>vMqeAgtv5{eEZTF@pvxPpOC|<5BnW#v&A_zhk2Cw8G2G#nU~nwp
z*nHe4u@=K7t9YV-QkEUeE#)?q#_@cXr<Rty{4Vh!8OF#>)gt%Rdgn)WW;p&O)PB8x
zg?hI&C)KSbrRIv!)%tFhc)up;zV+HY0Qr1!pDTPXVZ`8e<1AMd8K&P3O+fPM&St2%
zL&pZWF0zR)eBKKT_&^KBy1bU)+Nsp%P4fKn@WVKyRA5MPn0wpeD0rWosgoHcTgj)Y
zWI%v?QYH>D29g%o&SFBt*EYQx4lST7k-%XTkYJ``bUnLy0I)1@8NTN?d_R1+nmSyQ
zH(Xma{GfHXu6MY8YWU&GaKr9!BV>drG}5$kn@u><a>Wb`Mt;yWhP*k*AxFixEE31T
zk1XwO?{y}IaHuWDtBmJ-ichgNNNSh0vx}qI$8uTB3F<5I=`lHvbXSrd$PWV?>sr+O
z=ybE5yW*NQi6Qob_8FmtqZWUyoQN6LWXKd|u#h}DrfPo{3y$=mMZgj&201T{>YGk>
z01GBN-syJ@8d<Y-D7XvleYi^PAlHYy_Tba7GmFA8KwV*b{!FU~4&5CJqm~8WY!rE#
z)*%J}V8q0pu1UXk!zu^geFyduey5Khk^BP=Y}xZ|!!_63X|{MF0|yR^B5IMMs1D=R
zSx{#TERl*ysAVQP8m5<<ln;}e^8=diM6j)$;f)j?)m#HLXBvT?s-_r!4ent3KM*4q
zXsKu_yK)&_Lv>HgUEwx4&20fox-bsS#nP=iInSY!yl9*@4m6qp)x#ml$D0cmZcZ^F
z(NED%&2g#8j&=Gnse|b^Vqq0231+qNR%GafP3XB!&ZDy#)(b*aHV{HC<Q`F6=R-P6
z=x$N5A=G}Y9r+xkwVUiqPpC~z?tE9JhT&4WI&oL=5u6HZ+rqe^lE$%MwORc{a<%lm
zB>Pa9KzjCBXP8+APp4nX#S0_Un)ohk>XSuq3rv>G2Phw-y#(c-Ge{4`xF&j++{17@
z53M`DXJhy%+XQbmwTXE&rwuTwW5yE|Z}tKaX0PdBbDw0_*u?Bqk+VM;VfZ7D+@}Uk
zCHt-=hB^#=ch8QsOYz6&-5O5$<(E(!z;zmv=)C~F1e3BSNNiNToz>!O)hyM!Q1L7`
zUU?I0p#(jHd<+Co%^$gn26B>rK0&EM5m8CBLYv3v@q*k^U_8D~Q@UJ{gB5CQ3ec+o
zA8DMyEEgP5g#*ExLoFDiFSQN=LnBFwNi}5mm$OwDuRtKCdX=YB@y+Ibf;^Np^`W^g
zD{hW4Mp7c*tY{!)Ic+os){?Pl7&IPla5KGWB)R$PJu`fst2gr`UdUuK5Af#ddH14&
zH`dQxPcI~uqem)tqe9Te#%b>9vkvYS32yy>iW_^08pISDtxAZ~ggBCXjhyfS$uL(;
z@a&x~5%&-e<v6p=<*Z1nnMFTg8eIr@2fGPZKS=%<%xgnWRfv~hFCtqycx*u@k^H=3
z{Ei<!Z9xbwQ1804+!OtWYv^XC{ONQ*u<*@Ls-iFtAi(Gh$zmDqBu6qizC0;zjGc;B
zeA$zMYP#r@QbTwfYXx|BmQu>1qkC`C8N4{oDQ3cQC&$z#)r3q7b%dQ9GS(vS-Ee}P
zX=kpzHHekVcJHOO@s*hVb>yy#Cu6uSW+$;ncEF(gcRK8W6`$p7rV4=p5M(V#vX{wT
zt2a^pH<D9gVc8?e4ps?Av0SWsQ^vfVkKB3wZYNs>Jhh_pSjM8~;DAYCDpy{@->_6Y
zyqV(rDaG7I_+c`ide*UrrccmR*OXN7L((0&r+V$hF|*X;OVF4><EjL2F`~i+ZzdU=
zfOF3?HE`PN<E|NNc@@H85t@`igIa8<Bw-S+1XQrX06-lt#FaEFBunZYDbH4<MRzVe
zcBuT7rlvobd~^2p+Suvrz4*C(E>A|?nN3L!%SnZ#Y&$kUIS$65o4uT?i5Q4oo8M|W
zd_*eA?w6l#VRa2HQJEg^?mf2^N<L};IbsWoLJOb&e>A;$JXHVt|9@tNF_<wk*0Ilw
zeajHCo6VY?WJ|`DHEW@iF=Nk8Lef~0P$89iwHR9}X-HB@w#rsnN)+bj{keUA|D1o%
zIe%QY=Q)q-y6$(yapHuIanL6*Bh+W#+0^bJr}6oJ-Q9s2nX#+s-6dek)}^}uD~Aku
z4gy-Y_~0ME7^@192xW9U1CLc@1_WVh)0Jm)`|J@~LBYuzUpKGi&3OxDbo~d!K<3v%
zD9KrRH@Y)Cvx12E(dtG>a()sEw|01BqpbgrkNDL%wN$I3KL~nYDE`02xv{Q5qdMHx
z(ME2nATXN7cfG6r!P{#RAHHJJGR~@wg^fP(^~-Kbl6?ULXJ+RT?O?5pv72!MTBwf=
zT~MQnJLh7Q)ri?m)0sq6XQ|((`h;T$1l@NW&$23tml30OL(};$CT7e23f1sH*C%&b
zg(>n`32V%Kg06oL#eg8xZXR1gI(_G}WjQ=5I9t1oX}Ze!;|%GybAsGumU-|SITlZ2
zh5ns_X|W)tC?3OA3$E~Z=00B7lc)dhQvXQ_^PrVy9wK)$SDv32)~jE6dAh`}Z{^k3
zmEp~m*U;}A@$Vzb-}h0NGHOiYHbxmSLTF}L9^Likv}WyUdSa14>NIrKcWJ5W0C(z1
zrfF$jzW|*SGut5UJ**i1zFY%Xz-CrV5aYAYd7cQhmmSi4{$K#zdF13k2Y619kGxfK
zgPvZudMOnKr5XO*@VKUB4;#99%q;Sl%=VY><r;h+vt;wSfx(PAEbj>M^+YE84BM~!
zO~7%@l^jyncw@BBC^*42(*?(qA22e#+gnG~MGAKd`l|f@oXPa8SMC66C}KJ@q>0yO
zZs?wS9q*y$P$D9b#eA2>H}lnpTEuKLiy7Q1X}ZE51?ak~Pinj~JKx^%=N!o(C`&(|
zgT=4a^*~xqUQPjO)`vw;PQzbv9NnZ*S~jGPZr&3<ZkML#08c*dF&Hn618uYX5qS8A
z%4g+~%lXf2Va}@|R#$#NTNYN1-66f_yZVozJQ`B&EPgCTfH%6hFeS?H{xxbvPsUW%
zVpP3e6NIwLbLwwaQ{&03Pxqc|XPMbB)1@93hv&>yW%;ut1h0-&20L0kRWj%<O~vpk
z9?Cwk<D%v3{=EC3;=Fg<4>e?*aVV!e0u!x}TKs!i>*!U*7cUd)IJ`CEchU#5-YVbS
zJlTP-$W66rh?3_!*>vAr6Kpq)^LPN|Ua1<GPz=7RSV!a2KneYb``BWWyFR&5maUM|
zyYDzHAbMu<Op&BUBK~N_oceajzbCWtjrJWOzyMezJzY&5jNxWZEZ&Z_Ew6xC<w9=9
zY#lkC_dszAWJe0P$xz3p<N9QMV3`^Sy7?BOM9d^v18P@BCHZqyUt}dNFx3IN86ndm
zB!{M&<>1+>flVj9Z2KPiwD1|uej+!y?R(P%+sVtI#S!*C_~%?+F4GczS>v)A9B@6s
zf0S*NP?bAUUA*maMmLvt<)ug}E92APMh6N0a^XUa?v=Ni43`BN3L9#BB4+}t$ZX2z
zD@UJn_-Bh}QYLslfuCh;fvJN$)(cGbFtW}WLLGz<Dsr|e3ja=^3oUjy61yWRyQ7D8
z-&pUC9o>C<Vs|`o_g&WR#HHQ$Nav@ye-?A1*NebhBY-zh73!V6TD^tTO5?HLMcJN%
z)u}Qls7zDJo<$H-U1z<e<b37=k55echq~S8beO|n`PeG-&_wL4D%d1jByxeLClT&o
z$UW2!z4gsqbm<23A~+(3YgoH+k$#HdCprtj)PP(7=D&*V@f>f$MK%@T$PBQOc%&+?
zeQP{-J<P;r)mbmHo=46%=;o(^)CG?tYRS4^UX(*`?|%IDQ=&4{IB|VtaYKc}B4-I}
zh5u3=ZLqtf8?_{=3V0aLWZ>4_)c~MCN~$Ha$Y#8S@51)Kqnj&FX^2ymW`|ZP?t6l|
zS(efV7Q`dowOxFx<e>_*dEH!>>3rRKk$WW*tpKln+y0IjGkWoHV$>Tp;W@bCi1@gF
z+ryATS$NcDr^P7L#Oviz@nh9bJ5Id074^^H$K=CA@!Ct#)mWoyh<)y(|8RiXalBDU
z+0WxT^E|;Xi|0cpW{wXnVin2J#|^a*Pb15|hPuXEXXciF{Ii@ypND+en6F!VAbMrf
z?W={M%U%NP;>a-VRaY7cyM{@a&;dcQ|BpMkHddBNLfP5WX8iL{Dw29Fb5BTmwK55x
ztJd5#8x>c^n@bAX5}|7iTv7G3Tx-bm^}j0{Fpe|ncNzCUWVnoL9M0c(ePDG)730*;
zI-TL@T4VWzRA~0T=wPsm8<oOs8G`N843n%T9DB<2VNT(Dy&;tGvbXRHr#>XB)Fk(u
z=r{kT8CZmc(gtQzb{|7Nkt#R=e6}DNu%IFc1Ad83GQDFj>$*_qptT)FJ}i3_8<%I$
z-vkON&o(__lM0(@ACWUIzF+8TZp65t+y4uESP^lh^z~U|+kL6PSW-RwfTdhR|EYa7
zI={<C|2Hf-J97Rttw}EEX2g4|vTD+=j0=Obh50cK?j;YNSD!2MX2G#5(mmkO#*2r;
zG}6)o?Wenc|7l;Uf8Op0tfjbo^QSF_?xz-8lndpqr}c&`CMFNQxf<dn+--u?-gr$~
z>k~hK{wufc1r)&)zFBaG;R<;KI)?hr!gjqO<4|4f8<Y`u>)M+GO_i2NGR-+t>WURY
zIl^SGOhh1%@7&0*H!h{V=(3s7N+i}`fNxwsq;Aq#!63ia?fqW$V>h|ItvPsi>`Svl
zpYDGd!3}aX161hGYekO%mJK3AO;Mdk@jCx7qOWP&m|uljpf<?5{b4B9p$lC64~Y|&
zEVH-Ef9I}|y!{Idm28qvLFv7|7&xT8xH9KJ`ObR*CB3(AXg|=n)AMQ=>NWE!zJH~|
z(IH<I@ssq*^j((n7H)pWf^%4VOyZ#r<fPMhSBsm>OW*j<#^<o2dt1^MKfgK1<%n2)
zT6<|>v1`%pT2A8jOy5ufjGLkKUaT@EhnI-K##_laLSVsLl+@J<7jxnLja`(c{5E>1
za3@x`4a0-(^tAHIBVE`hwjrTLC7c%lJ;0+n&6g-AKvnz^Q}c!`B8}>Wzc1oersV0L
zRG^<%a+f*HIRR=*_i8Kacp{^dL%~tKblL2hbO%Y}=hI<rE_~_!?V8>z{L16*PjyP#
z^SIu9rUt_FUiW}hkz{KCkf0~*D2V49TbZLy6d9(^7!4GW31HOVbKY)Iu|?h!V+1Xr
zX-U3S3P#>*L(k-0SFZgyDA2x!Jl%Q#7#QUHj#_W|DBFP02aOM+>hh`p20UD~*KnQG
z#;vmvq-F^?0lG6cfu@=A*^zye2d}8jm?ElZ#r8jUw@yb68MF1*+Ei7NP9VIg%*s)A
zT5l`PuWY|OwWFN!p~xz=qE6zvEw!ejj&%#8NWY3>c~_CrwJNSf{B=A0>|P?ut-{if
zsZ&`lB%IyRu#VNckRjF(lc7FH75KBtcL0UICMnf$!Xm=vpmROKnsp;kZPKO%cvJti
zQVCN)@6*xynoSBClUKI9VF%$AmD{5T1-`KrJBR1>E#s9kc^~GKJX@Dq0j{<(Q+K`E
z@gk)aZ*;H8R&`C0mshObB0<yFvY;JlCa}*8G8_`iMGcbn>cu_?44BJU7r#2iEjSBZ
zq&PIF-OV3s#w8mLDY_f|_u;__6%Tr!A=Mf|;OQ24z3pH)h%SgtpF7YQ<Y!1#d7ql3
z&~Yhcm{zw`Y7^O4fqR?tr|f;{pnA4S!<XkRo9tH&9ry0u`fmH|1Bs_ilvMg}f?Sh5
zeeafdknCPl@sS1p+JXgb%>GZ9S0@1M8gb;?nrzUIT-t93DKY<s4-&a991(n&iey<X
zX*C9u3uR@R<I;5_*9%=RiYKZZUZ8k$@*_AB(t{gW|C_J%AG-hK&#P!`nr?PSXh5#%
z^F=4(x5B;^DjR+>Te)xR1HW6v-Th2kUrH(OTlKPIoFUu;f+|RbQLtRvf|uN!ClN@Q
zF*;h*b9V4=?jCj|VFqub@UC9O_ABKUwDQO?G&$>=se;wQ1k5OfxAiKXM=0#O4KNW`
zC>D_6Z47E8pc!9kBWs=B87e!KY>TL|6y%xz!YW_4mWFoSE)_d}u=;t$9Uy^Wm(}KM
z;@JQVmcd(igkH5kxuBm6DIn8|PI@VC79JmZqv_*$%VPCCk<f_~Kk4)ALFc}3$-hUl
z!iFLxCqrL3nRwvS+Z=J<Qlzy^Kwofe7U66N+*xEC+mGQ>74k@@lwBLFKQCkwq|9q7
zGbe>V=Sq}j^zm*4y|075c(zF!!g<i%gbhmS6Z4@2{y?$H5bm@E%8M8+O%<FLPo(Tk
z-)rc9@ae}bA0<_Z!X*FGVwy|L*$Fm+97hq@^|G}4U~AI%y}relVB^VLLw3Y9#%{Ou
zlHf@w{Q(p%=2KQ7#Q7msK~dt8eU=9o^px4DqI3;Gw7a@d&^g|h0+r+q*(e@3Hzcgi
zeefW^?oZ)sIqEmlKeh^QNSWSHAiU!7{24uRVT><xiVJ(TR5qM&opMZt7W%At>gMm8
zTtRWF3BoKgtx>cV*8!Uukl-k01a*Cv|Jc^6O_2GLIt>Pn4)U4Z0)S&%z1m24w^t|b
z&S*6+ZpJEGcG5~aJ!VFZ3+sR7v1kxESc?vEnJ00((xj3iFKCB`S-YSEa+R(GOGm*4
zIz&Pgtak$CbVvA?j~y=y85)%0A(g67<HZd~^#}G;t+LJ*R((#y;AsDzUG2KH^X0P|
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%0A~yXc2w>F!LIOlTXNiqJ02TZ=~D!8HdT2!AIlA
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%0Ao_
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%0APpe8g+Rkzm>6)02wEJ
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

diff --git a/docs/images/logo-small.png b/docs/images/logo-small.png
deleted file mode 100644
index 2e5d25fb6103111b055c9f91d266fe848b29d3be..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 86921
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%0A@dTRF;*}P(@SmL3sUB9+6;kilX
zM%QO>P^gR>F-(#Xu(qmLQK~~|XwlH<mIC}(py4QUe#pneQ181}fkR92`gz>}mjmRl
zUw>Bh8JNJ=rg1&QT(V!>sa4KfwMkZP-7Rmu|Dkm3+VMZ!S(vwA0k)LJEn3UoEt}-z
zw)Gi;qcSQ!A~0Ii@^1vVXp%rQ<f5lUAihTmbyAFQA=kHYA2R7i!Oa>Ci-R@nJNH73
zcvv*XfLdGISW4B(wsP|LN%?2?Z*uKglFDPEJCb~4FHe{y4)vO-dfr;*Qf~UI6Bw%}
zf1{o)xX<Ent`{LN_T*;&!n(~9FEn^#;Ho;279AcN;qTKEuBv<$96TQvCz|TDKuZwl
z=`L&j{u2*%iZpKC9C;T^D&kfd4PX$NI&Q4E9Y3nD>MX3JHM5qJgTe1u@c1-r)*SV|
zC&2CV_zOtst~K*}X$XzIJ9o;CjT@w*g@t@MWUzwHW;em<dhopxDr0}0k6I4qGGg3B
zDUSu@eySh}j!Km)O0zcY<-qo>a%AIbsaCt8SlKxg369J+!GNDhQO;U4>8O(t<b7TO
zJ<dRw-&BYw3*6uA?rT=v;5?wXA!nLD;#5@uY9Tri!3wxulVs|Ii85#UPf(Cjm0+SZ
z(c;;`G7zk_v^4UA{aV-8%mRbwy(2INA=`VWZks3d{izTdym=5D$5W!hVo=1XyKBq#
z#miR6KUWpcM?ZQ6i;7ae6EyvlYqH^=KgHwhIcd<isZ^|JrrcFbXxp`Qr~EN<Dm3qs
z;^62gwy2e%)h!hg5~AorjF5OZZu-w+=Kuge0adQyMU$2P{wwZh!7kdei45x1No4|a
z?6PWvQcnMSg&aNOE`6UHAkV(=T$X4soyF0zLuWa@f1m7G{*Tx?RF}%tYbrNJR_7@C
zUcV8bML^V08lLf!8&M<-#f9PmeWYHK<`Nbhq})p^7FGrVMPI?e?M>ifO+abbYY;}4
zyga3A-~JLB6f9qV{E_V0x<wuLCgvJF2z@^uC0&Pn0=O*{vwVzWQDC@jT_bCL9HZP`
zPm{pl)A7^@4PGoQ4hW9$FkkPU!15O_2TFBAa?S7@ncHmyw~0Nk-KLA;wK=eUg=}B9
zRw~&$N=+oLMMcNUx5GXGf+$*5;d6C$)q7&`e4MzfgmwW|Mhf0v8ww0M7Svp%Ib`nc
zBl}Em#q}GvWYM2<<Z4)`yff$-sa@ScVezx-1O<i%DAA`bScZUSDf#T1Z>4h8%Gu_`
zP;gj6KzHokQ!b+D)TRZ$qsF*}*w<;8G0yk<3bQ(S(f1FGfKFIk2b9%q`#M=Z5g?9(
zJEiwC&&W4ZenP$Z!E*fYA#jNWsQaq5JS<(VWWuGJDh?JjDP~qK{73v?d6a=ALU$As
z4FC7tbfusXC7FMW02u=E#Ksk}cIsFqm=ME=g>ZZEX|OPK55ZF<G<eaBaX@ec0aew@
zxoPW?<;^T`^Rc?*Q=_&-%fSu{m22~Ma{25jSv7yIT*oPo?B6ek_w52D30QRDmMW(q
zXvl7J0<(N;RAhwIY0yZ%`F;|-QW+&M^XankbXX!M$*r}Rfqw+HKY3-Klt)#y>@?9*
zFimDGTq$l~B&D10tq)NM=r#_NL*uP2Z(L5HZ{nh3WYz2$l9rSx)tj_Z0n#jkqZm`V
zTvTK?hjTnlKNI#!%OV{N#BSTy%km#aL0D{;o_+erH<N!tV7k8of|Q2;(H^xoc7X~f
z5zNXAh?7GtyL<ewapd+!m>-;@@yNd*G&>c7g0(Yl!i;X(dw>iY^OIOtLk<$$RQc61
zgk)(syy{=s`11su<~D=gsN5tkAcnX*zs_3_kNeaK4c>&Ll+?2+(UCqOUT1qbHELek
z#L_xn1qaW`IENXypBi-OtzdtI<z8?<r%Y)w*jA}hMYCHfA|gWkE?-tq#czL{fh0c1
z0_&FISfFw!f}2sYWWirj6E3uupXr|MwKLn7d_;6jvGU-Mk3W?Ljp}8KNaJ~QjWHxz
zeC@k+MU_HpS^dW^;^%%^m5VjDs`y}>0|Mg~&T~CEQHlfRN%-c|-dOIH!XgE5+7oa?
zt(^R|1e`b^eV*wjUr+i`dOzC_Y{O>CUC0;{g|&UPN~n92BBzfYQS1a20rH?5R!bui
zFcwU>y#I`I7@J#3pAWy1Zg5AjUWK9aE;9F#$^$ETs;YaS2Vtc^j7Jy*$@9p=IGB0c
zr{QzXs@fAe3gIy^%Y9EDeR1JeAH)WGd#DMK-<L|$xioyQJy5W|B7(Biq6jV2$}L6h
zhY3*retsw<lPUvVc}-fjWu8NRUrFAM&q+_lUG}|B4M!<U@~LbZ7pxWA_DUR(VRrV_
zq(iqJdegd7aBv}e>5W(A*G0?ZMr?%q^6o%6yK@t=n9ERWyxRjpG`$Y*5i9pCVt+FZ
zHROsjUF`1fPtylxHq(cn5ECgo=KmtIhCDB4*DjR*y);<<-LzFc{c5CCg2KbZ(fi|P
z>4>MjKJ<O5Rlk8MFYF%>psZqj$B*-b!iG?Ex~n*kYN9Y&n-^ZeJ-v~y3Lh=2Vz7p{
z&7CIO{+N#Eq$Gph{>UHc<L&KzMBi(961KlLQ=WvY(eoOTQqz3W6QYg=oIBM60a9Zt
zd#4ArPCbvA)8<^DsIi;_9JdtUqoh1%GM~O?JI})j<OhKf2Fe8&xVOe2XQ5;%1{`zh
z#pC@Q-A2vt7%<u{mH}PcXB*F8!d75txcoGKsS1X^@ah}VrF-Z9z-;xo8s^K`SF0l3
z`t_ISh;Ui;+f-!phlo9(qUB71@<AMmajyLfX32o2F5+7Dx|F$<Cb1=r<vNgP6dzA|
zqcWldDTH+x$Ow1N|5dinnJQ&c<K@lwhRUaiC$((T68SOZ)P2b6dE@sL%9lpbFGnyo
zZ;~VkeG|B-w3dgZ`<8rC@i<OYkRM`GjX;MFC^fZ#d}tI9w{BjS4KpUlp%s6F+6QQ^
zV#Pc#SNkJ|;gJugEEI=)YAp@j-HD7#IuLx(z4ziVpIkb>cdH^9!;_)=*`V*N;>Fs^
z2f<H64W<$pY+3P43tEZ-gN18C;NvX?P5q-UzYz=6^~en8HE8DzcrY%zbQdx6x1yyP
z`keJbOqlK3T?ZrrbR!k5t)<@!FM^XOZ=InfW`e}C(NiYNl;8i5s~)FhCN${N+tw&r
z_JpViiT3xAazNPeR1Rt3(mKgYtgpw(O}HkWRI7v5R%uujboF?kPR9H%-;>3ohKl*E
zB$+a6mi)eCh4g;zSunR6Da!(~HOI!WZr#3>Jpa-w!qTvGqmtB+f=S;-#md3KL0RW1
zh)ZpoI~}o=6ivs<>D<h4Pra5X%g2w9W1t7&xS$<D-+Lp5;hod|Px9|iwWXoEvDZ?s
zhZjqY+wA9dvZax+X;p=;G4SfkNkWZ?i9n>0HipJk3swd*xV1D28d8N&a6JF=tMbZ_
zHw$DE-@~qr%f+pmw-tRz?>0@PlJ&#0-$`ptmeR?8E(Yu}L1<<4>EG8N*GVmyi(U<&
z*m^wsyrd&JZ0($xa{1h8NyUN`a{iRO(6h55!K2_Pd;7Xnz8)<l;INN_)o~NRLohBq
z?D7iLcPhUE!kYpkD)@>V2A%gd`0XRkpOlX6+XAIFTAu&kV6mxES-GE-Qm^l2WBb~0
zQ5^yFIW!~)uBK9&%ENMC>84`-MpRU^#DrWCA|MT2wUJg<+|>|S`rT)8@#sE9Zw`UA
z35ps~QdbMr4bF$oYFn}Lp(Bs`kk`^~#Fa@)TkCV~L@oFzT%8)VfCdAtGAr9#&koZs
zOhPlFFBrIUtyxpiENHPZC}>!|l`lu<>hj%BGZX^LKwZ`I%Cv1>8c8a<w{DgOPF2Ox
zj?mc$%?FYaF50*Q#DqtsnuDW!Gii#HMNG($*U3eYi%{E+?W9$wE(nmHk^Ly=%Q1eg
zTRSnngJ`35L1AZgBS9?iN-R-Ml1m^KQV0cyazDZ9EdgPX4024yZ?^wAQ{2`sk;)ay
z$m{RCE$<B*A+6fAMm=y-72M8^Rgu+`!24xvTvn_>=fZo=I`!sA_|uZa%K1q57Gros
zWrg~9i3?DP1T<ucgv+X95BZ++Gz7_si$;GejCGd5{YRS*Nc)>`1!s_IJ!HS9>8m24
zk?C$Hrl+UG#>K6T^zo>e6cg37dehc${UAp0kOeK%ZaIErFfl4PP*zPEg?bsuV6d%>
zMbJUBTZ)`K2*P3ioATAf$v_g-)$HTXvGe(~fl(Pyw|o0Ya%8BqR{j64uY<9S(1<9R
z@cZB3F-ny$$9*qNn>Wsv>*S)wSckQ3Md{VAuf)bD%E==~q+h2tVq*zNcBcD(8x~`^
z+i9>mVlXnrV0EA#!ySQ=PeWyp!zzmcE*A=lwB&2zd-k~OTlA+KS~6EsLwu!2_b&3m
z@R9P&3j>f8S`Ft!xl)V?3@d{)3TJ149>T-I<=m;0%0;EMJS;n80ssl?ZY0LVNMdvZ
zax{A8t)IBB6c}CycgfPR!(eHID&-Cbod|@~Fwpa4&!U;Pvlptpi-g95x9diHV$!A<
z|4Zqh9q9<uw|F@dbLCokaMRp<L-fyv8RI1Yt`CwKGABbT^pI!7LoAVi+4dbcNZ$J3
zeZ7%Hx$AX4Zw0m84CO*sEM6?#TQ@~!Z|S?S4Z5XD0Ehp>+(mNm#2I<@o%iI8q3;^R
zEtTC>Q8pliA|B_?%fWqnq+PRyAX2n@AcLG%M+t}un;UUrax+;HN*T)y<i!}&1j??X
zx%iFN1OvGx@3@|lQODcY?KlFu|HzSL^CZFdytDw<*N_iBl$YLq7fb~WR8}<+P|5|B
zi*x9`3GR8_Mvdk8p@R|vE1CHhTFS%nyow1ILNFSY{vrY|i#e<q``YzY?uNeoVtkP<
zvm@{VteyI;5~_%~rNFBB2=R-l`X28|-(DMN`bi%ZTwhpZ^rTxmH~J?=N6sGb)emM&
z&eKwxf!Ox5J2#5^o-K--$I;PICGnB+S>HyN36WA)uU-`gzz>IhJ^~4DI0|2dtZ{Lw
z*RYN>>C#Ka%=|;XeCK7csb~odd@)H#N|xW3u9X#AcFPNZ5r6U(D-J%I3*=BTNKfm+
zH!xU=x2IF;!A8Mx6R*m*;w8oJfb1(?O>Aq_&ewc_2YYev8!miQPIS=W6a;ajf&wMr
zyqjF{aFf*NaH)jxZQHVyG=1+)spjO2GN`byFs{58`CV%Tw^d3(AeSsr43><8_+Ipu
z06=g_F`~sy#rZ=rMAnT71%1x01;3&Mb1TI;r4NM&y#OrIw&k}e5E=_rJ_f!E!^pk`
zfwAr02p4_QjX;sm(2c}H-os-PmdVM30snkC^q*%wALCNLb8o$>eQ^TEqi*%izkXJW
zkd2M4*rK?S7J)&{k+}^h8>w*WJrTThsA4V2k7zM{$nfO(E97a(d!K%a%6(=s^0!4|
zjHi)cfq;;!a_z=#`Eu+y8T{s3YB9{@A<FZ4b2@;Di79GJmk>|i00r^PZu{HVE;TM1
zgp+R43v?D#5+F-Z`-fHMZYtNNq2gjh^{M|<JqZNjAt>0Gw{R^kR-!_#NXR8G3A^Me
z*CNBjxNIq@UZaM*{5)t{8Z<;q!CJ6p%XK_6q-M%*L7^Kr7?D6uU6<9X*2==UvteZf
zD$A13Ga=)wP^oo{9G#pLp<zr&knBPp$qS<<DS(6S+}XV|;2j?krmTw#hxRB4G5T=^
z2&vaDU%vd*LTa-cGyYa2G;$cB@Pw3O*S$TvE*tm7Uy*@+-8!IDBsIF+Xft#VuvTzH
zz-6F3OvKsQ84C(m6#Y#D3Jq#zjAxj_t+Qm_9El3Qs*<Ow!G)3z!zC}l${dCvUw&4@
zfa`j7$Q#o4`4_~`*H`gyk#eGjt1BS3=E^1YC<O*(u(fR^wWxXfU6II`II%J}eQ2Pb
zgF?74Go3FU{6hjRxQiun5^SAZ@v4qG9(GazTvug~&p@~}7kS)$7>2n2{QvHAkny*A
zHt;(i5hZ!>L2Zxin8bDi$&jgtM<m5YODufu(V<r)2C=ehQCFqd^)#_CGZ9BeM`_ou
zht#N5TWpZSP_{HsdpH`c2@2^)>6nLS4C5nmV9!4J`}g1EEMgh7meu9q-_meTk@DOc
z<3~7k=GYNOAg9LhV^G`y*L)GYYiD+>mpbjbN}cxIa-bB!xdDFgKX+1APZ=%YfLD|7
z5a(Zm*H8$I$ehmoH2+>CG;(qGV^UIrVtjp{P5b@F$#}p%>4$>!6+mN<9rZG`7@w1e
z<>aQ72tJlkfo~@9X|Xbxlfj^0NN|vtSXs*(Q|5?2XfSpz_)T_i-YEYY@{SCI8;1pm
zn1%Z&7uj44U$&cY-6WR3JZe2RYT7`zZmLD@ab&i0>}-%f!+RA0xUV}Z1a=23_+~nn
z-Uk~OIx7oPvA4F6>sW|-qw=7~*|Xwx{;0$OCY%n7qa-WN0UFBcjz*x`FsfiGWwF>X
z@XG9STBKAkm>)r9<T``{xt-FIlN4=7T2g|f!QFHl#f3^?#U)RdCD2EXRjWvQBuCmg
zIHHz(Wx%-0D@%esrT3FAy+>tDWF8rK_tbqnclr!0i#c*=&u;bH6WpL`Zot(`Hrn{e
ztFj7oB(ydd+n`(Uo*>P9#H>GaK2?VGPC~;72%znM&X8*L8e@!^v-F?~n1Y)uxX0Ho
zmo2|fQMnk%!2s6f)}+dnD}T3d-#*NsqL$qVWC;E2wkZ1TKO<mcVfwa9vo_P78$RA7
zBhEpRG^~7?8Xruuf6n{tb-4oV(;9B6`VCN<SVN<Q!HIFk%}rvXqh!Fy@1@oAFRRH#
zgvX(kf6L+3i?MK-%d79bFTDp06jKoNr9q{<tH^3N@6);qwfq#IwcdKZpZLJ<KB!k0
z`Qfv7u=ql<Wzh%?Uc7Oq{P5=znTrIt)(D^{VZFMB*bMJkEOQEwFc^!VZ35g#gq)I%
zI334SN<=1$f-C`~5ibX!!XiXw=H>tlSc(N8rRJ7aD!->3ga%ykN@G_70{?J*eBAdN
zv1BE*ygj{T$^3c90^h8zlciW$X4M+h^le{!6Qx)CL9>Sf1tGZvxe#Y}ZI<dTu6ViN
zIv!l;vl#ZfUsI`Kg+I=b6uftYH=xf)Up-)LP(agC+YUOAV`~>@2<ze{q9HIoM*hXp
zy9X@#knIQ*35{%r=ixtEm>9LJ;#BL;-tP~u+XO6|e9$v%HPj$?&YLMa=KZYl3K}+Q
zr0N1tE7iBroM#p-&F^|0y2&fw|C*tVVTGWEN+Pvze_z?ZbRIIA*9plFUmN;?bnVj*
z6b@yIgonNZj_s)_e+3rZ?HkvNeU(bG6o?u#6no0*{t@jJ!{ozHzZD~MOZj8z3M}##
zO54XzaA#&{-kfarPq_c88xQ}T+wjpL=z$Q}$1NQ0A5xvLxC99GiiLm6&W#&UK{8&|
z?I!Ufkxeb1dkLji2cpIdEOb~>v?%!OMg<4RA0NGfe33Y5)TBwCa+d<(z9ri;^Pt|G
zIu8~6n%(sVa89Cnr>vX$o%o$OuHqNC4mSwxw^3>D%>CC?^mo=H06arc({}_?(ryGN
zCxxvFbURfQ{^fcOC@;w*APNuqu7i;rv~Jp1EE>0zkD0;mtQMT?&P@%9<y*ax`CZ=3
zTweV4CpGD4;<It$(VaoRd0hyUTCF-tcyN%cK)mD7&h2o4Q~*7-6Ds0C)8oo>{|cp!
zQuNRLBLG%!pmJj6$ll$O2&=;tF(VQy-ncXF_ixYpU}jQ5StDyvR4Wdy#7;eWV7L)a
z;9`##cjb$@51C)O?{)8)f8%G}_dG^H6BZP%w0L~IFUjl~(`DxO6XfiP6S!XB%J8Bq
zwe6rcrT-UWrB<8H87?>mR_-+BKbctBs72lr`4OpbziBNG%X>g3T=G&SfF*(1;smY`
za!ldGI^N624_EOEQi5Rne_+wQjC?15U4M$+b2kD-LL+zM^uSi|EF{Oq#jlRK>=hU6
zd9ED_!IZYBY^OAv)$r4jD#QZr1ZIBof!5NvAIrDK!==${=x`O_dsrNWlaB(+6x8cX
za$?<%kU)P~`PW?8zkM4fPFb;s-@8INKuOURjos05359bXm;+^v%FFikYn2NrHT}Bu
zYS$v$`*;h3THU^i96swM$BrIF{Rm@ehKht-_@AUk_Z<V=w4OYX&oX=3beT2j2RVBZ
z!U76RF_=OW1Z`e;UHX4MR_b-?p%7&^f$)0RgU9E#ic1{{^SK~_7tSkQD|5Kyw9FY=
z<>jHgMIydI3#J_6M^#*E%jRDvE0@#_)Z2iIDgnp-9B|riP*Q-t<)WtN2ownoJqPUm
z&67|@Hu>t6eLkm-G%IgnY7+=t{88}tP@5sQl-9yZoB*N7$?*5}m6|QvOCOZ7<OIvE
z>4b-wZDnZyEsOhwhla@N1%JryO&hR)-A0{d2Qf8)riIB*S4UBMa0Dn=%`MF2#NorL
zWNBn<g0yN>M=Do*I7b$bz(vjk!F;}UA9F+2^9iY5s~#Y)4o`&O0HcnSfn{+MgLCTW
zG5G~#k8`H|B<Ih#!5YdC7G^e;5wmzho*nkB)a%?!p`#ef$VmW@9I%peP4U>bU1B05
z#R_ODChzIncpf6}Xw|c>c$n`+bxh9#I~216qVs34&0xeY*6DlfqV4aEK#|b6Hx`;d
zT}!_aly>#%@<8u1b^&Kk)#F2JSFM^<Mx6mIZYc)8$q4G@;h}u5FOHe2tcaY1hVBBC
z@PK>3)TWZu>)2E3w(A07!#G*LXn|~5wG5U^0%{;s6-z5qxD1Mfhi=?5zZ0sOd@WTD
z?%9PZi?<Y1v`dS|5CB;VZU(iPLC!pr^A~;P{OMEDs$&<7GnsrdAHDE=hVG(-1%vu~
zwr!Ic6UNKmvwww4>Vi^Yn2cGmnv-;R`CWPD({Er6cfTVnSavmc7B-((Gd!yVka!;2
zt;RSn6eDy~QD`K_$AV%citaC>80G<Z@G6j6mkZD67tEd(2@M0?mo%Uot*k7cg^*}K
z)C=omFeag;aX$w1B2n+5JD`aTy7s*r(9`F5I?Kb@vZBJTH-z<Z6BK(p*RGN^3m3qO
zxvX+NYysC~0#=dh>fY#bxwC@1kL60!P+pWgSe;rl5_1N`vsnyz@9I={lzk`9N>Ff!
zs%71!S04n02`9aG{DS;R=Yk@oN=Q(MtXi@}ri~vftCuX2P-L02=155(qU=zEr0ZKB
zOYaZ96qgq5lr~Q{RBnYu<}pxis+x6G>3~3QPawxk6nI3-v1p~!;$THfe#SB8z#a7g
z1WA!QD)XRg{9Gh7G!ESTyVa~&a{v~FiLeri<)yF^AM!|;=swWooWZpF3{3ru)kgb@
zlOa5Ah!HZKU7EL*COw}K6YI)IcHbu}{`x~s9NZ6gRSA`!U;;K$x*{k*p612{-om`R
zT)jiEmyDzlx}MsoGP7A*8x$y(NCvbtHIcn1&q;8AKjI?SrERD7DyUtM$5dxkTt@+W
zHw3ij&H4pys2^k>;$m?z(aIz>B6nKr&eH4s5lUd#*KMRwe7SK$<#g>N2eomm0m_}N
z5)XJXtqm<4Z4@-Rf=#qIFeQ;YXuSft97#F#q3HLVN1#Y(<UB?>ZsFqMVuc5F1*{AU
zx}@yv>@>TjxWIUMo=2pyq`WxhN3pDeW5H)^h{nmpTIHm=V9k&wJ^PDe{U#CwsN(uX
zf5UaP9Nbo6VhY$OGj!?0rtIJX`cyW=eQW?1-M(?18n=+}XqD(!0h!Dk%d8q*ST&vO
zksKH&9=`r^(ZgMwp+(m~?e=WETUi}0U%#g@Ob#jvjL_gv*|d7K{5<J<`4>rfUgypt
z!7v%W6~}W}O`1P5NctkS)_TCJQV~@y`C!~+s(ChJp-<<Dx*|N6&$|a`J;=<<_(pbP
zo!#+G;HF|y?2YT!&9R*YKCjPi`=Z}+Hv&aMBX{GJ?N+G1Hw7E?AZurBx}`V+H8ffo
z{&2a51_ev!*M~~e-p?ycyM{w$zY8WgCnjAfR`w1mXin5su`)&qs=Mm%d2-^=0nkp|
z6w8V>z|NOf?5|uK475IE-@gL#E8`H>Hs*3Q6fp|7(~^*!A{KB@wQNu)+t`M#`;BVX
zkYi^(m22zr#S7B4_cK6cm3{1ENcR(v;ZhopX+lDh96fLVRs|~aO`RgUHgA#$05Aya
zHUeau1&+GB@u5QR)kS=)f*JBpROWit)|T%2wY-zFt7^@966k(Pu3WmHk{g-ms6}w-
z3O3PAg;pQ)^dtm_ua<rl?Q?Ggw5@LU_J8U>)u>UUJr>_tc&JMdUdu9~bO-6%xPa4?
zzToAlD4w4iK2B*``Mtu>m&_O8i8a6y+N9TWQVlK#mXY1OY>8}Gx(J%GCj?<>v4GZR
zj3PY@o-6lN*2=cNmtSDF$NDM`&MvCPbt+;T!Qqk8vu$%J2g;D_7Bc>3T;52W0mI#S
z?6ib|iM1RS;g)S$JQg%nW<ik(ZjtlIo?bG4f&4mUlB`<vuUz!>P}$Oqz1TQ7OS681
zRIH-i;J4HwPK1+kL1}ol^}D&Z6)#jpdq-r7Z$Y7@1hKKT)f6A(Jx~RkkW7etC&cWF
zH3FP>QA|t>LXbsG>j)GH4Xq=G{lHa&wWI7ZxTUJv;=y)saM0wIVi$<AqQFSMenSR*
zGeuD@(3SM48YdWC4YYPDR&$mH&?*~t>nkQURlud>ChPwFTehxQsj|~cP=HujA>*99
zNg3A1lWKubI9genNJ{E;#C{GaYXggqv~SiRM{9%0oeq_4a0`pck+U8W3U=2{y`M!D
zJHu8V%<37T>j`VUq9muF@Nz!~0kK4Wn>tyR{Pm}}9RoiWViiO{nFFR>7s#h>0ABD_
z8>D~6$llISDh%g>%BruKzvnsW4!aKiEzcu+Re+ro>e&hD%=_Q}nP@6<Q{nlph<jHI
z*2eDpw<-EN_ajgwG;%*y4{QlR@g=@|g<L_kLGR23S4-o5K`2TS=<g@(2fwK(7ao?x
zr{&mM_R(1%Wy>2Q_R&BZ_jpDvC?)atnPbOf-J*YF8xUB&mwXWOD2^D2xhm($dI`+`
zP=OFFCoZ7-P;j_{HTD!1*{G{waslkOF4d|EGsUxm;PP@<#<qd0vv~Oi%9-<?QWZ2W
zjhZyfH*15BAY&9nJ|)8Sbnet?S^4iGB;oxei|74`0!aH6J2EX;Q@9>oTeO!>uf8ii
z-u+yfz#U5XELoiCg3@9!8|oI`MiNm~<hfiveN2M=d{t~iOWh6jhdCd#pjfyJGNTFH
zR68IzLJif|r|meL;zdov2q1B<E^zrrp#2y#iLVlvQ5E@|p2woriu%KH>cnxef`<S0
z%)deZVf<Jp?87dhIQSw+$H1&wR!Z|ex?emF?v`+5zME7iC-s{&l{THaNQ0)$rHXwu
z6-1|#j>b~Hdo&)_VFQ21h1l!7mwfu>t17r!35kAl$9*9+s)3e16E()ePFouAR1Y72
zd3D5iso$)n{JQX8jEP~U9<2#ddEiYk9AAYS>^v;P6Ne5$V4MPE_KKuIW9QjOsbPw2
zZGs?bw(clSK<AlPs*)ija1ELH(;jvmkNP_%$oicDitCHFkdSI34K$K|vfp(7dU<+E
zcz8Gk#~}!jE}ovAS+h_+>WeKz=QGTcTZk^$5MAxqv17@QkdVzdR(IA?s8hGDX49EM
z!{hvUKs!TK0h!hV{s*Sc<N_x&?u{EtokESJ0J#pXplIOseNP`1FSrqcKm$?y=5=wb
z?kr7P0ovQTwbZCt2eA-yDTybounUp02p;d<wO2-e`Vp9FlcYBIsDA%;n5rXwJqK4}
zSuEHir_GlAXT4<^_^HgnN~}egQb>T=8|7wU#lQlJiH;Y)OWtw@N(Wy)s2v|09ZAHH
zS}0k|!vcsT2cYC?0B+5Am8o?l^;>=hwC_DHT0Ws(H>~&6B-Cn0X@OmT|Ef@2gtAwy
zT2-@hmI~%+GU1Y481wEkluiCwOYffceTsyJh9|())pZCgjCnM98#M-Ze-04LtWH6<
zR2XUiTmT^<j<?6u+Qz<B|Cg#W2+7(DbWv&b<7RbELx0aY5DbzMjg^2Zg%lhYj~^7j
zvnM1zJQTs;@~R+EqZTctUgIX>Si=RJTo%gD&Nw>U{tAX#SYjd+9NRW+m5C#Vt9ltN
zQL=XCsE@@0c^TOWjxrD$I}e|bQM2aDqK(_6id~f);kVEyRLrO(1O+E5EAGXj#z(+q
zU-3lE4tKXx;&Z_ZR578b>X@v8OU!j3fu*gJi#RrHrmTrd&aR5^l1E`MyP#PVnV(70
zm$QEtj_i}Y|NO3=CkhbG1G<4Z-?X}^INw+r79@of8Zqz;v_Qe7A~aRz8<307MM5JN
zgOqub>eZ`P#lv?JfooeASJymgKGb+r4S<xC%RqTF_4Pel%G|_uWVJet-s|x4I~D45
z=&p+NJkIz==4;RCGhG11VS&(kN<-ZOlEwvkoPi~BOili4F;PHYq0*Xjb*Tfo_&N<5
ziIa;f%8;_?5l~q;fliQ63)iBF=hR0-{7%7fV9$P;@YM*oe}bhg>Sz2k{C%;uWTnA-
zEUuZ)MHkfxcP|<7^8)#I!#2fjmHGN;K`1NYj)3@oduIY>S8?6>`_^7wzuwfFdXZYK
zeL+YFBq0z2W7%Uq4@>Zj&Dc1TnV2s_9DniH6Mwdo$v2pI88Vr85<6f#v4aU<aBL4?
z6B{rxU?GGgB!pI^R!iMd3vIpc%bVZ7-h17z-`3r?we)gJy8Z60?N*&zRj1CWvxq9|
zXz#Jk;1B-Tk;B%3z3*5D-`&god)8Uvx_~b$DTl;<E09-U6;;kfLwh9@#dSzKEypZJ
zh1sp^d`bciIwP3OLB6_mmU4XGZfncqk5~t{ZZZ9XE!su9ALiQ4BL9yFpLmuoTgKS1
z*Pke5uY+;!e}<;`-PEmN=Y%mrz(E>g1XMH|ihMs}*Yhb!b6j=RRnh2i|7w9feCUwX
z(9kdl61odg`PpbCCHaA?1NpPQvgo=SKX&sc?{n8&vz|?&c8ODm1*^$vJkqfkgg8m=
zLUi&xNJNx~ybd-T+Gn-mpV{LIVXmXps#&<uTC{8hM*f!JiLS;tuFApOIBTuhWgBF|
zAFUNy|E@G;BC{)p_8+po`4?Zcw!Qwkb<K(;);GWKM@Ffy8}0FU3Nah~jE5e5+&a;h
zVSVe{e`8p6ntbXP0&|Albr$!%^=OdSVnRk10gkf?K8?Z2Rz$JI3e=d%fX|<UQ>LQI
zYO7)~uv)gt!oo7rPZd!g5#|tE$YLr4;}Ztz;tVcVU;FV7t=%s^XS^2b{Dm>}EO2~~
zh5aq{g}L_#areomxRn0vAP$X7Il$Tln+jjxs`ei0e@Zt_7#jo}q%k%)nOx{(e3U`=
z|5)VRB9rA3)Xu=w<VRNAoMo_k`XN>~{~%d2O7ikH=arOv1;58P-*gZ1@=LEaXC2~2
zPqm=QDpr<TVm+*sqC{Fi8mCz-8V<f|)pOy4-Rfw*U=T?j{zJ+utE@RSHP+nu3-Jqr
z@9pvm<H0V7Ih4#SpM|2bK`4TS_MJi`l5~niDwh(uNI|Z%t<(C^qu;Y0M=~kH<FdYV
z->0mPZo1w$ATsPK+9TG~funWSfBj#NT3>wdTPREB7@JNF$B$bl>S{4HQinEn0~TJ-
zfIM1ZOTu$!jL4650R0(Rk1at+Ldan@m$b1Z4(lUbur!neES-2nHJQhVs0ty53#aO>
zZ9jj4vx}ct9ZlygFV+eO+vv+*F)yBv?E_T4L}s@!?`q`OOv-z9`Ybk8eSN*L@5Wp_
z4)RzFo62Ya#=g(FPYwYGX(WeBLTq()bv~kd+Ym!sJfB_hT&&pIk(N@$LNt5eNw>7L
z9EVT49x0B~2`?Ou@Ze(hV})fEUt0NrkF4JCu}@p&3zkwxnC&o}ZED>KiMUue3^l?6
zsfAAmpDpK3Tjx&HS&c|#$tTI#6UU4%X(1UM{z^Nz04lE-y%-^pQm&G+*+z4{fU}Yy
zi);X7p2?2f4-eeylTYZdbWys&&f1$0M$2yy6a{I%wP)vU>wDk+Tg<7yW?jE(h4p)z
zH(JZ)S0n!FMclT|`rF5zu^KtF4hD0K3s~)TbyzJph{cqd6SRVuZxO{X3szGpu2D-+
zvMVf~W69uTMs~m;5*Z5|#7W0sEM`n-`Q(j=B8z4=3_=v!pZ&4b%-NUDE!YC=0}1>!
z^X!RKl1-c^-od>4>D=mSH%P?x92A81zVnXRyn#6W0ZRY=$qTi~)v|Q+Vsf?g3bzI-
zL#9IhEFX>Ut5>bE-5Tw3jva#qar9`2`;RkNpBYPKm6nw?SXB5)L?l0d^{pRWCO_e2
z9B_tt)>Du2NY-bANPv$P7ExnDu6>C3cHug-^*lbd8yl>1Cr`lUI$>RCthbu60xZg;
zr?cJIhLVz+AKBPUB!+}I0$3ZCwbbwxw6a;4vjW)&E@VfLir<_WNuVK_=@%j9K5T*Y
z!4}l{QxE3qySX|+V4WQuRtLVmJ3w^u`7KMho%p9dhb}-j8pt96@;JZI_ipXzGSX&Q
zAUyfT7JDhLxXd7k!tzQGLzST>L_K8Y<eDA0*pUW7z-E%Zgq<CAG8kW}IKfwk+(H&R
zfB92u`*TklDnkeN^tG1$eVcFo1Li~9Xl-OJ{tznT_g5l<o0peoo7&fRd;9ITg?RcH
zYahbx>z2{p?W7M=_YN%5KmcCqbqwm?GElRGFk}eLE?cUdg=IGbwXd)5NyzX2kmj{X
zlL`w9b2B}zd)a}0cI7P}Ub61ad#u?|9y;ihWX!Y+qDZ)+h(v4~EufOt5<=<jXg5fu
z9pur@L3=CWrfvM{UU8iuobL8kBeL1c!rtH4W8f5K=|mP|U}qL(sD_aEJp}Eh%pLF2
zuR&;P3-1?&BxE3|F)eyB0O=PZ!c0guNGdCsXAY;cIiMDT$emSUegoKTQktj+FXf_$
z${+<%5JC=I(<z80=><+rr%&R;{%6)(&pi`C7MxkQJ;&+mcYy6bBGH5y-LVDEG|GB<
zdbTqcs)RV~27SZhum+DDJqoMSy{oOQZ6l7)5JPi9ItVzFMmp$_#sKxRz`x9*a^pPs
z>+|5P+ht2>;gL=Trq54N^*VMo4Wqn1WwJpYF4w&Uv&-*ae$(b<>+bvnQZp;fqSmhi
z^GnIhPuZ%=n;>{<M=ooqqD-`)n`fF~5DN>iOtI(;NHCEUT0c~P4wcP4)PsJ7K!k+C
zdJ8Ptv9kh<VI+HmB#;afqR@`nYgk`G7_h)V0OHRpUU_tGqc*91LO5YcA&d~zt}uc!
zDCzP7>@vR1zyX+@tFMEy_!khy&%<me-~_U$r74dvkAA=$IBTa_u&Mq%NcO3Pix#<L
zRod>H)VFwN&mLp<jqmkU4#mH2r#&;NOziZSN&OykUm=D6gv|d(WU#0Vvrvt>^l(P)
zYUI9EKEGMu?u870d^pwq9VVcHSc3X^ZgJ`Tn1oop?v76w`Ft&8I#8YLqL%i1KK7E~
zZzcpIoT4EwM57;mO{D5lMD(w@9r`o8ymM#%>yH+HWf?{S;Yag#sO*fo0iL2N1eeD5
z_M0<{y|27rD8C3B>LBocnCtQJP!_3R$lQFAGr><xM0Z1*4U8EY>K`Q3%5^=6Y=5eE
zI`PTphy#}h1lY~YV<)nmfmI}gVV8fZg$i=o3{2d({uH*<$9Tm>U0tdzE3><>@b+L~
z;r(d;Zd!|i;G*j{Spg{tvdf+-BACwLn|crsg(pg@4~^?%yWg_5KmW9K7zNLsjy8};
zhA6-t^y*=#foE8dTQ61*=g*&CMO|;sCM-n^*Dh;M8@gk)wdSmmx%vXs#=oWBsUfp`
zv4A;_dL)qIgcK0Ku-W%O8rRK{zi(_yiRWx5Xg728$Pw8rI>WihzeBO8*-ky_%1~i{
zdso*!M0p?UIMeX@!QcHRaA@1B^SV3Qd^&W^K{7|}Fj6<^Dss{s2#gT|VnK<5kTAlY
zmwsXW;_ts<z52xWjXg4`jRDwoFHzMO5j6PnfddD2Tx^r%O-)U$nDIH=(a~{N4nhVJ
zfj6wbF}6RNO=WW7Bv79=cMFS(ifWmwd!p&i???!QY4VYA&Jz%j`&R9Yg2A9mGU3{d
z*cp&os2PCfEQ9i&VHflL%LU+)f`XM9ng0Jct9;JKm)>wo`RWhffv(3&Bi}!ORM2EL
zCvmx8<h*Bm5HM5)XE!<nYCL+#Ad7dm{Ht~T<Oy@I&-qUi42++%V}BGD)Encg-BxZF
z6vw|XPw&z^l_Z?qdD?;!<sQyA*c>)6-`9fZ8f~>`niq1AMv@N<!k7iZcoXTC`72kh
zv~b*FkIH~8CAQFR>0~rF{{jV~+j*TmawSPS#~M{q5-9Z!WZs=qSa@&M@>T0Fb?#cc
zev>g=Cz4(Vz;-6uSl{pDo8k~)9EXJgyhbYR$d0W>b6fVsdXNT`Z~(~U0EptB>FE=k
z*B!f@Jr)}o1-&<`tE-FWqq||3BY*^zbrd$0B&z7k|7C;shnKS-Q{`O_(n#{9IAHtV
zME_|Oz7G~GTxk0|K-5XCc%`+q7Z}LvxqmOo>n>-Mr@SC|y*E4O-r}m7+ZV6jShn&5
zw^^0gEXqWGK*&RqL{4xZAP7W_QT8FKeCqIiYcCYV0ep9#KY5%~#Gt+2PAKV@8QVX^
zXy>oqdFLGrVqKX4wecCKjPFSVSGrVo5C@3DNMT7N9`RdEgxffOeDTWkX!5?*K^k%2
z1}b9%RK{=Mk7i87RDsx147{jL#%DPI{7&4fuIOWNAW-Jb%DA1gj(cY>Sh8Worp@jp
z*WY5yRd_hml$|T*@cfE?qAT)p>5dqy#cUoVE-Sw&`(Ay~I(g__qZcEJ1CiMSH125@
z=BFo-q>%^2@hmpsZWDJv2*6Izyw%x;#Bia$_fpRdV^KJ?^RB5{#vWv+YHvqrH{@+5
zyOk{roOLorD5HdSb}Z4?NGAiQ_AkzvGv~G~TeeKrExfCuuyDQ0@4F|jsN^;*rOrq1
z!&-3d2BWDg=S#+%_7pLI7lpm^J9Y>dM8To9&bXQyPhypLtF<2oTPLtk+}YZU0EIF4
zBDZ(HqSmKSP~9>amEhR$ErLz;2D%%C%sJb-8{!Z^VHj_kAdLrLQ~l-Gp*j6?I!Ght
z8>9LC1$GyIU4f$)?rkFs4LY1ONhhO)>NiZH-B?U-6K|0k3Hk;HZ}4Sh+?ii8`@?v6
zt6sX{mavDn@=A7~9Ds_2B?Ka2d?!pz2(Sy+7?l}&Z3twZMduR-aik?v_R^*|3X@)M
zD~smq%!y}^`uo*XI2eZ7_$>Z5{%#_EZbYTX0<PFpAjo!}Zv=5T(o~Vr?jVf_AR@bz
zZP+X-SUmwL3=Oy*c?e^`p_B0i5XRq3#g&D_|2&MiZp_Tex+}M|Y;)z}6;+GZZM5dC
zUTYOq&9meYE^0K<u6+Ddgv(TIv!tHPVK!7lFAkf|!g`V`)x+CgHCBc@nl6ASILGjM
z+dvp^($AlBNoPUY+fyd2S+m9md+C?BU;f}S{BGD4@DQ77Na}HL@TKyKijPcUZoy^!
zJ`U0dgWCmV@iP|uJLI~R9k*>NLxWA8!5Zr8U*&Lcb1G|{m-Q=8@MV>`xrKv1-%Xg#
zxHC{tu&K0qVfBJF>n-{DFka#C6sJW=COdQvVt1lWu$fNr7zk+dBDRyL2^l_Y2Prfj
zIcU}H+6J<C(|Z5d5$txgMJbB&<ln~iJXGY1Y;=ysR5j&pv3|RpzWi?4^5uD@SVOjZ
zHmA7^(zH%uwx0U#<Nnbp2aHS5U<YXcR1n4|IJ<bVqN2iDykyCQ5XN~tg6-YAx1EJ^
zBYe@_m*AUS(JB{UFtNikxXSJFe=sW;yfwe9;_9lUR|RTTt+nPXzuGFSn1kWIplPFI
z`5h#3c|I45S{O-SAW%VO<|XBH0#A5iJvAJ77ZdZ1h8-mYk7U#_%DhI_7a04mgD4tI
z!D;dbHq{q%g29I-$~D05oZ%XDw6~vTPRs8`{WJlQ?QYC?q!DrKvOOz1yIKPbTmH6o
z%9^y|gUU|^wrsx2B%Be3&x(t47x*pTjhKu0P<DR)4Vd|!Q?=}BYwn8GI1O566>t_J
zB%*~X1Qjv>B5~MRw&&|mLBnnWLAanM1WzG}Cd|d3#3N$e-d#r8Ne+(Whs21-dOXc;
zkNX|&Ut#h44ZG;Kr?XU$42{AbeyO^;dZQ7WpMW)ob7#+5a169A{0M5}(?cI&hThD0
zqyd#7)6DnF?{G;;iES#w=wx7G8C{HRkodRM)zx*+v@un~IY>`N#x<xkZo-7b`mEf%
z6?mPisKDD?<&vw6*ST30b1j(&_sU-?XX!c@8KOp<!}Y`=!)9cNir_p#b`|?^C)?3{
z9v|!{tWy{UY`}%?>7xgY6<Hw(7B^8H?NAd^xO)Ri;<t>+9gNKri7%MGG3Z;Z0y(~h
z-MAdPx*LK{l;wQt<jFzcc{?10Urb-9joz~vjWnP#HUXj+v3KU1h_iYPDp|^e%IL&)
z&CN_s<I{L_@K5g?h&>kccXuy!yF%B&Ti=k8oqbJCLDAfz%DFx{kkWZbG2ZD4aAzvt
z6EZU{sU3+q8wW)C6(X4l$Rvs!7)$ckp)nN-$q7}D)!EW){85~#J7Ufy<RbS%!*OHt
zNoL*^KoaK=jXeke-=wS%#oO$P>qxrn76{ay$r9$xoA>9lii*B=HA;U%zIKAj$qARF
zsX9A54}gHLXO2rUaz+MwP@D#!!T@15;Z?3RQsTqJa(IEV**Ce4#81Wp45q)dS;e$3
zCYZb31M^+|u4`Sc(0aGWw<04DsL9UFFU2FFs~D-Q;<+_QXH{FAmEZ@v*tkJ8$V9tr
znIXr=s@O5+Vo?p_6A;U!4`FlcLW(Xo_w+}<A{~Svg&f3UYP)dO=t`WcKW3f5XZm@h
zoSM&^GKfP?r-V>pO|^R5o;rT_u@de8N$g^?asZEz?@xL#T;>K=R#s-ga()F<BkN>%
zlm*{b3xvecxv~!I->-Gz8zAJb*s5q66q>O}1Gdzc`F>wtx^$^kHhZ@1!DMtYkgh<6
zeP<vL*mNaLDNM!jxTw6msL$=L=^yOJwsmMFJo;rmuW!CTJ5UBP3FH=)7+0tTvn!2z
z)Vz{1<1;$|Ws-rXJRiQmy+{a&$FCisK_6fe?a~c`F<52T=Y?Pt&0`y0q6(sgb<d^6
zU%v(+fEbiPxkM=m!S$oxBGchA7v2Ho(1!ckmNTcJAQ}vkke_UM9qdAxP96p&iALFe
z;Bgizq7GyuUle<Zdl#LF!=<IACmj*c=toHZJ8#~+wQLTzusOuzZooDRT8KkPqp`8E
zlW%YnQj$B<zj=D54vqck*}dewg4el}$+xYntSnb-DNSrUL5oDUbTW4C?CI+6z7@%e
z-`T0hDKioRh6?m}X2U?9$9cy>{O>Jd30}aYor8&sQrxQ+;A`8Tof~$m8bIV%rr&i1
z@(N*f<%iv>f>h*M)t{MZyz5ChF>H8G>>us)!-$5}-YoF?ji8iBgLu}WFEpdy2m*+n
z!)Rd-dj!OXI17C*=LyFBY+H*#3^Ezs(R3bhS1!&V#AfPhYc=`$db^FCFDM7`$y;d4
zS=!WqpYx+3m+L+HdYDEWV{vNW5ca}I2suyVg#d`-Yv^wLIS1qun(tA+IIyXHi+`QX
zJ9qA!hCY_lLw6=34L3;RIkZM^6I+U3+k?pLJn+Pa9QXf(E%l}JpmtIx3W1w%zS)cU
ziu}Ru?h+XFv$-lmp@Axhib_`X*(|=LT!rk+^I-qvfFLsQ_u!U;Ao=k&E?NDV=IlfW
zL|*2G5sBA`tj4!dhxB1ru(*Ro{8C6lcDck(3cHLAyN?}^>sZod^wEeKhtFel;Lu5%
zq*>j>csUEEY6LNy0&CUtTu=N-@WyEtqYE=pcp@I&m+BdNQ~?(H*U-aS&1P{zoQ2bk
zjp8h*secTc>bsY!&6Bm>8HY4rOWn(k@v$YarQ}#?B0Nr<Dao+eURYF)QL{-h!o|ae
z6%n90xh%$ceCvF;JlM8(<#8sQ$6B823Wb6pmz6`FY>0?V;<;RY2noNA9Ei^t(VdX1
zA1b7u1b(ev=#n0Odte!L65qkq2GN2hwMWjiT0jO(j4S;%bG34{K`nHVW{;shqA|{c
zT?o|F)ZB<6(wDATvnIo?-wnMRL~refP4)ii(`TUs*TSZ%v)iVrSZ+ok4M@{6*h$;r
z2Ukh+dm?Np>11Fkq_^q9g@1GW`0-b!;>UN|>_A|qK>)<@t-00Je+IX~_SuGzhS<`Q
zrsDT0L~!q!NpR%EZsr7701sf=qpD{9{0ViMoukZzSgkEB-*FJegh1&Ob|7$BApnK(
zAnfG5&3Nh4Jhl_G*@T+4s;jG2{NqSw$+_B$BpY7<000iYNkl<Z3HG2i1;GPb>Q;6L
zf50xok_3faDnkRUrKQEHudm+^`{RKr2nwgk4g_W_1f&Iz&c)|yj~?x{%bFJOR8~@#
z_$YV5b$AF@3I#I-s1kmk_CbeWA|uiGE}w`yNC8U729xLgSkk-~Dr5h&2cFYG2LjU!
z0#F%s2*4C(`2E+*m9yOqq}WvWCbzIRHw!L?`@)3_Gs4T?jG#0+IyycNTWXcqQu@$#
zgLE<^Il%$=BPULrm=OcSF07n#4g@AS1pbFMeYne*5SvO|3vn+%JbwZ=W9=mG^F?Xi
zw5K$%slOaH(ho2hl2KG#JmJGHMC}e@2<=m_sAimPsf#k=oJt%BOachNDd=G%c^HxE
zdx}d+Y_Ef&QgU;1EjFg!_O`aANM!yqmLaCKlw8=3@}>QVqGt3_(rxjjU3Vz}?Qd;u
zd#I$WG&l={fdU@<rBPZ!a$-QplGYzObh!6;L&KNbnw#6mgT=jZ1;Ig=S}@j-3T}dB
z@^6=u;|+vDF%)FBc~>Ya<jNcz94>=?N;G7Ue{j$@JaG^>jmn&Ya5=_t`=QVh+RcPP
z<-nCZ&Fgg|s0xfC<$RXKe-k3*qL0yL45e`seSLfyuXDwu(d6M)kH~8t1_u1JT{#lk
zo|t*k#q^@}m)rs53>))qR1#Ad^s|?5r8$&po(Tqs2`7F>`62d%LcP&6)J+HoC0qS`
zDlhT<L+~TQHQ@2|dt|OS5=<P=P~s*I6_!Zo3H3$dEVIQje?mPy;e4pDL^HDJx_PVG
z);bi&jrtQ013kyaslRGpvh_o8Lv80?VW=$Jf|vUG`u`y}zu<Gy-2i^!9OL{8?5)bG
zIdCA(-+21W`THpT_v5T$N@Y(qz{cB&5-TffVR3H3;)1-K`T03HRlz`ZaaLAFp5O1w
z@OeCbuh$c^ki}IWa<MX5W~j!cBs@xY*XJ8v`w}w5L=1*P{?4xM<(XM1bfL(_rohao
z0S3qT4#8v&Vo=7)dNchQhZ)-meUZtEUc_)y1m;!9$NN1XpZGycTQD=h75^~?LxX;U
zu1M%JzA2)ES~EXnfS^9b%wLho#54VAi0S9hL{L<?jM~_*g=eTGA$JHP+tIcQHq^tT
zYSH3hkex|Zou-^(!x@HPF(|uGkvU0mUMPDS;h+g=G^^u!scHs*?QmP7CBnaI$51ng
z3cogz#!tAN;pd6`y;${()`swx87)`(bTD;7hFBOWQ907ROKGYnzMRT>A~vyf5A?xZ
z8U*;@F!74zBkQy95-pgK*6<M-mOOZgGrKJE@n{xv57R%=9=*~`6c71yDS~{`fk7Fb
zxS^%OH9!<~xKPAIi=TfXS7?A=Q{HFxIn)YrrHy9&P+2c*WCC@$`ly$kjfeR!1CXY@
z$~UOKXJq&=?=leR?(M${{S6gSxuKvngKQ(CiAV;2!J$XC!TS5#N{b4&l1)R3CRhU=
zx3_nwQgg#XKpQjt+BXfqlLA<c@q%aBZp8#m4?k`3`xDna^hEl77<5xv&7$s}-tL~h
zzP7gZ&gQ1J_R}D-`dx>P9^bKJ$4RPekEz!7tw3Tg_<XCX%FA!7sjT?m!nqYI7R;$A
zUNE=PDlaLr3iE<ifQ32(pkP?d3^qaUVgyy=9$t$^tx{uKUrz%@!HfYOKq%pear{*u
z()GjcPDSk-tvy0YnyK+nR5!v4d18N5r_vJ2&}Sj4*Z~_01|hH^fW;<oFJz;7qjko<
zl?iBI9aqFWs+{_nESNg!U$P<6N1e&wYGxyS(>pIl=##A{+A!3yi&1HkI(%MyU?l5k
zlDx^HR8)107PPRX+Fa=~XmQnooh&4)Uu|aNHzK>@*bt70(}Na7wKFzoQH@<}H4+r3
zT~usPox@0DI7NBmgVuq#;s&<y@YQqdyG=d3R>(*pJpVKwMh2A|*}8Cg!YJ0TA*0%8
z%EUKnWVMkettCklQbs0k&B*Lp@3eW-oayQ9v)Vd3t>(72?sHA8jg4o|?>$g^{M8q?
zZGZW#w|3)OWti$3Sxfq-aW>oX<rNm+xn%yFKe}PniW_g;aIJsE!g<!Lyj+9bwV0@}
z?2yfe7_ml-cu3!<(NYsW+Gqumq>s1bNvcSU8t*7btie`H%D$L{l&LA-m9|8hKBg}>
zJV{f&I7vd9*O5Ez8<W(QIx78pQkNTV%Eg%mW19h^zf1MR!*F<m72mg{Z%y%%q<P~j
z)Gj+o#w1Y*B~wQv);Y2IQom`kr$iB$q3GBo2+4NBqOWZ@)pw}2{;gMc?tbjy$A0`{
z`XNgOV-E2nCS}2_V8IQ`7FK`b?#(xCynFK|t7>)$c|%sJonXp}oCF5~4g?$sI1soZ
z5D+2}`%YBo`Q}z@+wOgbfAZ@s-+1Du&;1h(8WVmU6VfOuo&EWbY+U=`7yr{e*^B2@
zS-pK2Zxc`42@V7t2sjXMATT8%pff7YXs!CwXRK%b^_6G7{H<^QF&#NOT4xd&l5r)<
z%FF-z@89*2Z$9{^pYatJ<{Lg)D&BNlQRmTtfCB*s0uBTwDFnn>)LC9`PPVo7s-?>-
z%gb;2<@R0AS$%zSET1x@MH>0DN`CL|4{iGH*FN`$F7d^T#7)YooCF5~4g?$sI1rd>
z5YWN7PUTlGU09jz&shAMt=pfW4~dcik&dN98o8@iE_?c+|Mp*I1;IpNX`87A4yU~i
z1RMxB5O5$c8U(~WlBji6S;^x1a~BRBdarhGsxpakY>}M7{8_htXv1|2b>Mxm#2QmI
z!ijev;6T8EfCGUm3jql=RaeZmZn<vFf2JiV&%0A1jhsOC8pxHf?E01Mi}Q8|0uBTm
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

diff --git a/docs/images/logo.png b/docs/images/logo.png
deleted file mode 100644
index c12f180d6fb2ceed90b8901055b6ef5541988843..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 395487
zcmZ_02|U$l8#n%|MrKk;St?sm6A7aQB}-)~%9iX~L}eF_>}Tq!L`YdGiIOOBtmoLN
zEJYI8k1eu0WM7WM|GIxi^UU+U?|(j@dCU{%UasYPeXs9z>#nw@+NKRVH((gH>C9<m
zT@2em#W1#qzpsZs8Q5j12w(niIc?;IVG_dV-!<106$u!&3p=BHLht(1(GD$#2(KsI
z3zxHnQ<EHdo_BC>eww<s>C0s8YomMi=WN#$W$nl*n2u0AvyU&PMz8N`vbFm8IomN0
zOQ)J=A{T;={&}R~c>~}6TrBeLg$lld=KDj|zLvVEd7|}nag9LdPr=j4_kQp3n6DiW
zzU6SIHzQ8?qlMzK!3v{fWe(1UVX{|r)w4KshJW^T6cR|u9usZ14pbYfh_6N8OpjrR
zWr*Yd#rrZsJzOo7<b8h7_^P6L5+_F`J#%~PbpZ}G=Xui+N#C^D{N~F>v#*-hp`Ra>
zWq$5!mdtONjRp#7Wu6Hw>dJiLR!Ni#N2Qw^N2(v5mpXjV_^Wi0eS6&a@Jx-G(c2P3
zu`4mfxieLjq~Pm3ZMDu<E*Uk6ToXkrTCQxPqC=IgiPn8nRxRb=L8X%_vgN#`$j7C)
zPJQUwWF%H;Ay^hwQIT+1dbxsR@OVh#WuHw=q6}-^h<!?(Z$#0>v5Rj>sr~~C6*tFj
zbSqq+S?ip@X!)u8Hpa%tabFaEXMzm#<fFo(iLD=Rwgeu3&~d$Ft0ZfVAa~A(l<12V
zo(nk#-Fgb#P8#;ioN!)lug(}tiT3gAJ~-anvcb)w=#2?=cKKwK4V5&4ujuo%g&W;~
zkWsRwR-aPzmh|0W=x2Cz+6Si+A-TiHclLeCruBwLE8OmQk(0@n8kt1$Ei7D^n6)n$
zk<?FE7`(_~-yW8#k;g{z>6$S`OSLe{$mnbO2VM2Zmi&VS9ABf_#?|O<YV?UBvc=;L
z|BK|q(#1O(HrReg=SU-^s!r*U7xHL49(3Pxb6yT+)sAINTpb~QQ6g<x-+NY~)rc?d
zI<A4Q@ml70ucXi@)Ht6Jwrpx|D~;!}*r9#oB1N9kFKq&Y{o^EZS66;KwNloz*UCwZ
zyw*%d0xiI)?7)V;@}CxUG>uQq7NknneNioYZeBw0vf6+9wwm>oONXl-p68gD>}#DY
zYf>?`47hTjpXVCI;)`SI0kxEc!z)WS7i7K=E(%vUW(&r+Iz`#!`1|4^CHp(`&V1LY
z67^2U$#=5lEfP8cuW0lM$9x~HU}<~)JzPZVm3hfw7o}|dsDzyQ%`QCSj`GbVA_n*I
zV|AUvk5^g@5k&6l$ki-hI5zWKy>nab#qsbvnUTG292p*W^_AH+zE_PXVCXvaE-y6=
zJd^i}kqk&-kemDqw$MamsxzCYz8BFoTiBQ<8ub!Q47pBj^SA4D)H1j#Ryj!|A3w@<
zN;pC1*=Y#!orxK#Y&n?EIe{JpU&s4Y--z<X;2iUk=?ahbTLxW0uE^*u?5m4;izcco
zI|NMoJ|^_;r+xi+Mc~`!FemdDsh>a3IA0~oC+9_|Q5F*0XA>5t9Z9{#-a9DV9H|GY
zxjV0!;iuxTGC^Mnw+zz0IsGR)F;KR%rrGQKSqQbv9gS<h#vCv8YpdNp=c;^|EYB^(
z?rQI6yaRor^9dfPME<GU@#L)>Y6T0&BCQu#+NvgIsgJi=857Mcg)3?#f266p4WUF*
z?S1DfX))&YW5QARKe=dyjrW-=6swC~5MsZQQfIAAANFXgZ@C@;X^HYwIDuiYlgM9Z
z_%v)Lr}2tHRp;#fv@JaFSt7qMnFYSa+lwaBI2`wq-?#O~`iF$Xll2tpH(#B~B_BLw
zP+EbF5*CiM=Uh3^S$(rT@lMh0+%Rjg(hgrp;e<FkN;nsnKs=1EC&-w-jtvPs1*=qL
z<c*sqb2Y5}8q#c5=BQBB+b+=&6sZ4W&6w(c3cil};V!UXx<Fa|YOgv?^{h!yAiG?w
zB)^kIk|S$Q-zUz*jHRQPh`K;GS+YCrfLiae@7t1(aU=B=N7{|)j>6TM#)_Wk3YOzr
zajfFoMY?Mz#^GA{ZDF#k!B)=%4~JoOajZbsO|-<9YFJ3|+C-VKET&2dzek@`!Xq?Y
zFfn3(23G@tzfnK5M&<QWi&v?ip9V4m{3L;e7#m^n&TnT;;sIl^>N->J?KNs%kEkph
zC<#l~2;pXI0cc44Xx(P_<Amd0A%#)*<;G<4;iwXJjJ0O5&F-+Eyf5|lIsYFMwD%Qo
za@7?Ie)4@x2$&6w&^<Ewh(IrII~DsmYTv6DhouGjKD`#vdMTo%dDm`D{5oC^C+i7w
ze=f?x;hpUL1&o7~o&pZ1l-d;J1MMw1ik3=DRpqp`eq2ZGg;h3FNDTsU)xB+ZVVzg+
z;T|{b=rh#*`VULJYU~9ITf>CeUF^eIb3-7S7fW#1ch<ly@|O~%7+X$cOOU->zP`y(
zX`aN%@Y%#R&c3^^x9{8`?qGm*(~ocuP<K0#cl4%}7>@L7v<DG<c^6pPjn~+tBYkCI
z9%=I#(F@jMZy_+)<sS3y6u3L798@)thi(?a@0!Yu&E9XSx|Xf~Ockyt&@Ew8=RKPp
zBk8KxHsP2p`Q6s2X?W!otcMkb;=vw|QQx<PR8DC2S8Y45vy(S$@`s+Dt!A!18%8&@
zc2y`L(nW&xr>-6r`0ROTS$1+>pNP;%`!D8kOuS>#5nA-!<%9@}e4MwI@*6gL<9Klm
zsY^OqfWX_W5au}H_+yPz!iovH2j2lazljplJDVUn`YzHg1=Y9YrgLM1EviJSu~BFR
zV*wJ&icxNy)LUyUR-Af^4bM(9W(6&LM>Ty5XrkhEFo)Fq3hlS~1zg#GfiPh%$>SoZ
zMxS*2-34VtaWsC#T|&C*)P%Oy!1?rtdB<PH27$>YFI~&v#<o8SVau&ad>f6;`8%-W
zvKd7+2DNa&CoLtJDZr|!{+g4c@nb?;2<1+(bDI17Y5!Ehwf*}K?fXv-R+`pqTJ<7B
zRuBT1NcEjgkC`yZpsfYe4-q2#2FtY2@RY<MyQ2Cct!_MK$3HGxqJ1{q7;=xhKm;q@
zeC5CwHRP}^ro+C~4b*LRriLLlQ||BwES2tq!vfK7Z=&Aa=nrk+eKD=Gj^=M`y0ps0
z|G?6NQPs$sb~#k)c>K}0?UH|?FN5&>{$6B=^{4SL9KBj(o(ieha?f7ukXyL~e5&$r
zbSBz+N{2gyKGk7b5)zopmDYtkMGwTS*K!DDVnUnU^z|ITFrLJWiJqw6u$DVb&H5HW
z&OU|yCc#UKjtN9Aw9^JA3KCKy>Kz=+Qd3n~4eW)5_E+}5xaKQSVlIbcC_1l;62v=2
z0s<5^^%Ib^C{E?d+6^lx1u!paCY-1jlA4m!7$`gKcPQ}#RJq45V1I})NWYVwzhT`o
zfFF{qxnTl?L;hkA-#?n2O;kpIhef`!;o<q$7STlALcS*dmQSW$R(6Nppt!l}P?!r=
z8Egd{k;|`n;ToWT5MW1%pkyT_WUW4O+~DfnIjB9%<XF8y)iy6vIpBRQp+FZ>!1E#H
zJ_y0!OUANQ>bJVe@JdR~7TkVvXK|x*3W38?(+Se~$m;vx3I;9yP;1QHMD1B~r;5rb
zY#Cf#5}Y}}urVTT^1)z(o;EvWK1T6l0L_|Y^6|%IIT*%jYH#CpsL-)JF03glDK=Cg
zELyTF$QjH|Eat!wTi%PBOAt<H!H6;(_!$cRW-b_*%Z(9FY{UQT<}Msz&BYS+f{wqD
z=jkzqYWrNFjM6L|=FH2IitIPK4$snELgqpCG6I!yk5l+!f&pe8DO})cUW@&u%{$@9
zAc*e_p2PDrA*{Erni6u78`*Al4{m!tOVLC-2Qw0Fe_BVbC16Iu1-P+AaqRfs;vxZ)
z3CEOVespx`ArPRjo>spqP3}Q)Evj`^#l}`FjUSNlnhJ)AoOKfoUW_$9JXWg)HCrZO
zPMF=9blFH>%t{76X*q}IYN<jLFl&8N6DXNoGUt!^UYfc_n|}QU-P{kkYKB@8R?*`N
zrDN1~T0dK|%hrgj{TbRBtkh{YG6~Ud4{nlFRe=_PRokcJd`n6JSd=83fpoqFF+Y_;
z37$hiV_f@;aBT5-+jmD`5DD=p{E2IDKa>hY>plrdt<Di796bN*QP9x0#+r{nqOTj-
z+Z-LH*dzK-(Nkm?kkK?W$Y|N%OybEAgma|3;c$^&`4Z}<M;>`62Vl-Cz#P5M+Vbhw
zamqHf61P=V**XBCW@ADI$^Hf0HBfqX6mik2DMnG^oSA&EjJ62wfYCKjbkboFaNlEv
z3n5jXP0z-qsY3Xd(lD&s(#XOj1X-1PTm`5=_A_~!`?Tv11812Ys=kgKLI4Jy%tW(f
zzaoe#M()GMlVwmG`d=J$6MCg(5Nxs;?sNv617>Y-ZhiqwAf}EUeuvU*R)p-?!K{7-
zW#o~Z0imA3xg!57*DoDH=$&VdBBB&hP@uDO!H;6#9H&O_0ZXQ)P>>}wa1gLm>g@NX
zO%I`)r=e35{at2IH!`chykb16^QGj3ksJ<=Z%J>`AT~=CzTQcJSbotzjC#M(1NcvJ
z!X3yvO?VvG{kqOV`$91F!LMM-j$zy5LsBSgGS13VbswBmoy(gVsj9oH!JSwP?vJmR
zp_gjOH}@%g_!yYjBZXLtbdMr9#^z^00+YL5s{nGt{Z~`LdZdRo^B$!FaUBx^{O;?v
z1=^=@xK7i}6@kWj6wT@#0Y?U#gCko`?F^pMDPho)yV6ufTEA&lK2uW`C#Q9iHyFd=
zu+5zK1*Ufaj2wR}&%+_;c@U!erC-tPKAp#p#a!ed1r)DB{{ab!g6sNUT{VM@z}%f)
z*QtXmwy=cDU$`~nPobW09ko`d=lZ@wk=AasQZkVHiM15yP&VKA|GA4}YBB@XuvBDb
znZ<qGH>&<cv!)21n%OsnDckfb3$#3YQvqDRP7K0^)sQi(f1L`n<68!*V!|(?Y>ZOk
zXV4-RTM$l_N&_taXttMGOJ%0&p8b^rR*MZ<R*UXAEi7R9&iK3t6^15$A5>TCy2_dw
zO}-<C7M?_SQTliDW(S#`wlIJTeub@&q*6Zp4iWp#Kc~aT-BX|wouPsO{%>QX&*8?9
zy$`+T$KE!kF@T3Xl6RAapoZ?-yc>Z6BdeI4?=?a8PijKuOjapt1YWnna1(rQ_BY%o
ztf~mJBw7fZEt+v}RBdcE5zdYBdb!h)H&L6USt+1aHuF)kvuT4d`Xpg5{z<yATsq^x
zWa;dceTN`!rTp@DqAyTcet5%At;^x)lm@h8hC`+Pb)Ta2KKOIXXxx73<1ZuLWO%%r
z^;t)S0`W+}43hhgzri{#mPev94RgJOArRi9KB`3(w^lJ8fwd}S&&Pcjs+Mwo!~0-Q
z<7u>+PnF4kC^;=b&L%9WtnmNk)bWoz+Y5CB6EP3_?x<YmeDXRnx&mH0EVVdVz>6Ed
zs9vW6lJzIt>A1H6m7$g_JYPn=*TUAsjwIX(IdGg)_@|5iL?~-%uoZoJl%JQ!c?7~0
z(Ni7Vvjxvku_BtCLRL(l`vYIn8DDZ^L@9jBa>YCN=d3}v8l^e7bt4@0*gky4%ESm;
z;hroA?S$CRXXD;fOb^+8es<L4haLP3=gZ2Uv!EChaCO4Ae{I1F8=;K)8~NWBAB_hL
zJJ7!5tW#nZJi}uj8;Wng{de45w}5mDu{$URZ(c_Q2z+`x-~>9OixNUT|AD!V+Y})G
z&LmV(8k}I$EqFnRuWkFAmd9)#BKEzqn*H30d<FgF-&8PHx=AW@p$yGb{;sC{9UZ?r
zOI`-O$npq$elt^mau!DgDgB?M-va?^4XYpmGzUp*>D>CeGtcsZD$dTm6@}7N%RF#f
zGVnGk9*`@9jm*zNKJ`Hu1=+q@vn|N_U&DbhBgp#RA96*(yQO9@70M8hCs6)M-{D@4
z7lZo!1I`~P+wkf0=;N?o37T6D2W**pqG5EPy^v#unsY_or>$ntS*XV@%7*C}A_E7$
z(mB*f_e?PzqZe9JKH3!<GIYKX^*q<)(LLiAX~qrXO9~LLIDyI-;Bb`}lDPcKkfV~g
zzsytkTb>0k1<@unZPo9Dm3^Ax0jxNpZr#h`gksi2I<2E=ydi&w51+|*;G)2mu$Fyz
z=oIcroHqIqPOFS9gzB@$w)SaA>!HgD#~*L#Knc10;QzD)KqntZbJhWSF1(uhMB!0+
zTJ(Z&iKUN(&}NT=hy32`%)0yqg_&zGI8rI>iAHOGITcu0$Gzo0h0<(|2t|)-&>8IU
zGqCEZzuxL)NjFmFqg{G+Tq?(_oN(n*b}q{4_%OJ;PRSJAFn59KRPju$tnuRq>MfyJ
zaFeAop6`6Sn0Toe76^@K#Ad;}z$j$BmQR8#!PbF_L{N4ydFPB=PA<JKhw0DWU$<a#
zf&%;&-Pmc-*x=)t45Oq&S(g=phR!RZrQV~xh$o<iRCY*`RG^L^ZgXfc=3@di<<<cd
z6KOaVXh}k#DG9C!giQMt(g2*On4waN5kgiS%I&mFj`^22KU%?eM>imEuJWuj#sO&T
zFWDkWkS?zEN(gDML^DS}$0OWMoq@MvWL|)HD3cH-+;dIYv?lZI1)QvH3_|{}6hsbT
zcR-M)Y5Pj+f;EH#_*UHI5bV<u1JT)D<d5nH3M;4|$^sqclD6oZ1Y9Sw3`4OQW)C(+
zR{@*0mQ<5kK!0UkWHtm2VD&xDSs77I>ssL+J7v=^nQwK<%+W<QB3vjHc&K}fXMu|v
zCKvlyeoE)_vjuwc=g(YZBnXXqrbhPF{3OqeUX@9p2;q#iY5%38@GWMO)UvM4z(FzW
zc&2>ACqzk*LjkpTL1bbEHLDhQ0+|9>8h!%rAI(lYK`nqh#AUo09@T}wP<AlQV5C1p
ztpY-qhXWGIUI)4I1Yn~r3prHqM>}KEn9}Sds8-e&m^<8tPCkZXaf=Pe=iwF^@;v<J
z8RA-J%kjL@Yve+uWBdJ8NX&4VqI85V@1GnbH?5??cdnb@ZZxx`a#6uBKqk@<sFaSO
zC<G#vOF#gwh1c2jAMwRnx=afI{9EXFKFEE>|4{Zi^ACX_!m4s*_#f_ipMzqg2rpdP
z@#bkQs>)zk5!>1&Kj5AlsGHE)-a^(Q_+eY|{eb_x8ICyGMELnAaOT4S$+FSMS<G{-
zIS-(Y;t6UwE!iFsOcvaJ(>m%yS%LE?4&7}R^-utXKt9|c!)>tHAlL($4(&4{2@vha
z#}O^mlaDXJ*o#Wfbq$a^e}Ef<H<Ma6Zwhk&Glqol<nqJk(+$MogPtXYOpfj&z|jnm
z9A(2+?f@C(l8&3lI|3re>k@T>i;AcvqaX|M7#vkFx;jwnf@V_r`<gC-oVViS;H=#W
z1&$^wiyO@Bv}mN&ND!?~bHKLNmlLo(aPrcAJ5)a`<4i0}U?hTASWF#Y>XFHxWSufp
zn&^*F{=~0iqI>PJSj3<9)mj7sDuTeBo!kgNL|m5)y#+dZ2<sI1eihSJOaSdhwQ%pt
zTtRWOuotwkFBbsXnUI`=e;gAMLbCw$c?gFx;6YBRDEa`{^rcYg8)e7WFn~rUoRu7h
zCou@@2-Dxhncn+VAu-=(=nxvl8(z$gh#{sxov=_T>-)vSENgKuW+z5`Q4whIZy!Qw
zl<e;<h428blHLJV!HzWoNhz=}M=c};GO@(nCudv(9pWN7M7NTLXe27`2nfEM1NHzn
zL0x(SVh@;e;{W3!2%%Lu3eXyRnQP#MPFMM9FzB_PH*N|mgW8~{n792Gy~YOPR{1rp
z+293W0;RVk=y-nWOaMR<vFHS%Tzn#;iEfaMjP!4h>%R-TPA=U-q!eK*>a?(U%aHN~
zgz(UEctAX$GD%py$~ANh%Pw>kAVR`Gg#PW6_!@MT^$Bp59LY3gfR!eTw;qQUWq~jV
zbdrNwAg3%Tc<)Nr|EE+9yF1N(R&$+fzXg2bhBTlv*1``Rur-hdywE`1r_Gau!kl<;
zT5Q>jS1USbW;?wu(Or`c0qa1wko6iniIgrfFDy~&l;bj`dSGcP<O=9iglYXBb+nna
zO%T@Ganh6S{4zoTYLtBEKkh`h?jQ-DB^JHRizx3HLA=GefFI=};Bu5r>asJW)L+|i
zBWV5O&r`S&RA#;fqejUAi3P->w_pSmlu+pqL3dJ(Llu|QA<eV`t{@ZTMWNdY)Zm!N
za_UF9)u<(b8s|X7E3nzv|J#*I^^U14F(@GL%8;G}3_V<pEJ!$Z=<snoy#SZXpheP2
zfgi#~eb5o!D|Q7|++1){b5?=sL|f5^@08<hmd{B5CZ-!vX&O%ALA37$vJxhH9~wr$
z<Ps(>fD<Luz=?|`Fa=RsK>|3@3~4)owbU@C1^zcT0|OD`DbC#r)D1}xHG@;oEOJBx
z<Kax-32SsAWFngF0}}w_${Q5QjQv+}%f^Q-B<PNIdXg-HA+biJ^FspXFMuCUu0gje
zJc5d2x;-)hM04)9U!`ey9}jA;S`Z9j?zRv{$&5vHq&z?vD4SMgzGc=IZ=BYzmq>J%
znEW{VLGv;|L(h)|HWZ48Iy#{uih1h-s-wKdO(>{_Oh|_rHYSgU;kt*qiwA@xRLbf!
zF9T&%hA5Eod$T_iP#bGm2PSl#s|Mb6euOaXs%#n(SZx%QvseU`TPX>lYiX!D<Wh+h
z-AkEo*gXw~KdTtYh8G}W50YDF%Oi2trUo$trS%C6amEoL^kv5_AdJ`&^xH3jKa#IG
zNW6(NzXu}B2^1z+`a=*e(GkFtsxUepAuJhixSnwb92ms~H0@-<B_B~C|E8LDM80P~
zcLh7356-@Z=*#tC;8k6+jt0CNib@Wi0Y49-eYNrF2N>@E5xXrmkiZH4N!&RW7IzU}
z4ebj0Cw70Jiz`{oY;A>7hRP=-FH1PA2xA#C9FtT>>qV51(FIQiWamF`eD>=tz##LJ
ztC`z2^!e-0)6gaD)_hj51^A3gDx@dSrL2Evz8<>kbS$by*TsYYzJSKo15~$>NYh(8
z6v6_lIb4rcXX>xWAbDady4ly92whPj1!u+09>)xh`R+j$g|fBk5{4RDapMED;@~3?
z+*(r5Wfum&^D1^37S8bun83WrPJuR0KO$&@cwukzcs7*XG4p^W$r9)eV7fcBDUR2x
zcL2lk8(|jF#$&JwHF)*b1!ccj67Di;kHfwX47yPLx&@nw7=pNGEGBs;l@xq2MuXkj
z&v7PkpvhvXFFC5C&!f)yweKG2S0oi>q?cm{VAz7X{Xu_VO*7ne&|;HLqSL$Mm7q{Z
zF0+V}Lvh454dO=gS;-a<I9ME5V0u`S7){D|Vz+6Ao8?Vk+erNoxAyk92*3Z)deBQl
zCVw<ERgz4*#6$dKhFP##fjX3m+wh3?EIfC~gfVTUXPZyYDnoRQ@qQE^rrE^A!83+{
z1&`Wi{+9)2AJ7a46pLoRBlR=RW>`z?e<QU*qh!AEd6zP(!FG%;=)swT-_k!JOh%ny
z*uKQ*3k<v>A%72|G<D!s*4J=on4uu{k85d`e?3iS+|6Dn4iH{f`o$RZN5pObh-bET
zbpAICeQ<_?f>;QmAgti=w$`<!-F-Zl1yz-mffCK|cpWZq^&&9Jn+E=V#~i5m@Ajnk
zwTJxWdFA?#M7Dgal*-WoV9D46ERDGCEq|*yOhfUNlqSr1>d=b<x7UpJgtyUG01c!i
z`ZtH%Q}w#`hVfK{2lL*Y4=AySyMpyT_;$U$&uN%;@^Em}B;LsY<O6CCUGK4vGer3p
z*AA?BdU;*j4|N*QO&~GD^@IdgczY1VH7^PiStVsMmVO8z2L|-v`ls18R;8R6tGLx(
z-x4ko62g964r}r93v`0^pHM^u`bA`tSym!!y=X7|sv}pOn%lKJ|8A+2uy#;o$VH$d
zs!B~-vbUdIN&=%(O;kaCK(q$0Kn39_0cNGZBh!DDoG$qDRmaWSYO1{*Lvx+;3*mKj
z^WQDzmk3$oE4dc-j^3W$$5d4Vepb}VM8_#leR@b)R<KVA2z4Ima-YsuY#a%=7#DCi
zvagTQd8cUPoRpK7P)P(E<`awVH~1fXtKG2Gk`4Y!W%@4&7L&04Z!p61URWb1FYDiP
zGg`s_{BQKJX&+L^`O94^-Ey@VS;eUV+w4<Py1e|qk0|;M<n>QJyuPTeyyVD;xt=lG
z;WZn@j2qRy>&pRwRiE!}M}xCVJAc|@U-?l`|BOau%2JR6f+Nb{W*f|54J}MOV#(}(
zeyeUa3Yb=(UmR9xnUot>_F9VNZw)CDE2*GQMs^$@WK8u}26*rNSrjmy!cPqwb2Kd%
z*XlQLxs{8Jvb+F~b$g(MNoNmqSR?xp{C1;Fz%k4=tZ-|Y6T5AB<|qrPBA<Gy!$5K*
z$enfEW4F`Q0|A>c!a8)WbR5xU{{ow^s^HNIdVgW`ot&B^c*HX^d1~Cx(dT#pqiuB7
zg)kc_mhJLY+_#9U(}~@EC70&qI`(Bh%=K>P0&|4mpqH>=>!zaWXpF%5<1nGe!H|GM
z-0Uvcg5H>7V25DMciQEv{icSIwQWoFqg~3%Wd+|%;#h-n7~W293l=Y0i=*gCi!vGH
z{GA-{+l4lPZtEqKcblzLsnEvVM{H7q!mJ>pxUxCA8}N8Gn5N^{>rZD~)?zJc3T+F#
zqNb|Wd*|D@3R-;JQDM%Be$>+0PC~Kuo-0rB@`rvmEo$xEYxESrEcHHNnpm!oDHeo?
zLP^17H7b<m6)MntrK=&5V#z*uBvTxEj{*OQI2AIs@$-ogyRf*Al3$n8{X7Wty=|?t
z9>&DLKxe9fE5)LU(c5g{=s#B8HoU8uI;EV8aUy08bT-gw4c1LWHNR8>MnK8}t;=s?
z@_<0=0M;QHu*?|y$q%m$o`eYq1SS)Dg=pcPop&ea<zjZH+Gi{2m~Xn)tiQq+@TS??
zai%sSqLH<z^I0~>_o#ikASff1<H{xXul8%wS?{8)ESX#F$z-vlRFN7KLSU40MWWBu
z5yl56NR0-(QnZQ-ZJtS8_9Zon>svy&+nQa#Jg1Z$%qmgD{Y}em20+a2rJ{EPvqww=
z_Wnlvf^K0MfclwI2_aZo<|@1_vWw9$IvgzkkDs`q0bO6zWU}qsTGqPR?aemrV{ow5
zXAQ~lx?&Yeyu~rXYc!7W_uC6oO`jbrz{?yHN=$${FdrinD3QWx|1HnmTF=&g%>u9n
z*$9m>X}PoCpOxtQES0fJ9Xz&E@u|OL)p+5yzKN2nC4QH`rmPt~#)OBND-tUjhvSal
zRctJ|o731hPhLJ(XlTMe?Ojk`!PO4K!sBJJA4%WWmaa!>!4&eg!@%ZO0pFL&5^rE4
z<w!TC>2jx{Ak%MN#i^dta`7F%+nFV?43^v?mDsW7bt$_ooH_0{sT@dO50eX>{etM>
z!{nu)s?Y8525T)#AxkF;0v2sZC0|7Vy@_V{m|)#k`%AnWz#A2nXC4MaP!~7PrjucK
z_arP6xUckJPX1&*Th0w*Vu!U)V1X;g+;R~K?40(%q9}H2_gX#|;OWZHvUxLXDp#Q0
z0Fpf81=oo`g^<1FqG+N<-Kk4*KK%*F{@0|SzTX;UDeWY~fIeelLL_YE+|nR}-Rjab
z>%^F?A^l6d!Mb>OD_{}^@LJY39M>CW5x`Z`hXd>h5?Ku1Eo@Gs1Uex;xdjSXsS*xy
zcM!3HcEmM1CJ*G(`JvjChab6#=b#_FB4HErw`1?SrFetkkC&c=LRe3H7@F$=v`5=Y
z(U)0onzIr4X8~BRK&txEr$23Lb~#04bNPyz0O--1swK}TgdNW<YC!4^jE*4)mEL)W
zIEca6esM@e(UL{B8w53hW`(M@XnVoU-ihNL5Ff5D{T>r$8G;46Y)WcRs<mD${5W&K
zm%+;6L{%l4JU&|Iueiy3FSd9E6umL?k|uk1I`k?w(6i!oiiA2Hr4zd9jnL>oZHDIz
z<yryDY~kXiYf#IM(yG079aX@;JKtJ42OIs3W2_qH@Z`1apF{&#SS$qr??bxG7HmMb
zca-b}op9<vb=n+qk0oyg{O`08Dco^Y5<oqq6(q-V#7lAsuKvyDsj+9j=?Dbu^Ot3q
z7gGHL?bdA1rg4nL4dcOfz-HzIDW?}&59tq77_XG%{*itshe`U)6R0NP7SO$WiU9-0
zBhByOKhOh090~@YZQ1}mqe4Iyq9vNi&*b^1)g^Zb><9sD2o@|_IT6w2wXgG>mm!qX
zPm~$w9_nb!6$P)Y0ZWT1D7oGqkYx8x<-Y(EWM~@zia`D{En#V~hFI63&qSjB*=9-q
zN3;{qVj)yxzAGpuktC(7Y#J&cL`5RlCpR8|uk1&C*!JXp-KJ3csZt<LZSe+ehabP{
zy+dQm0U{vV8T%|WyiRZ<z=sGPmsD@RLuG!8KhCt5%r(Y0w@Ja9kWmzG^Bsze%;u6C
zlPMo1JERv2xM1J2Xx~BLtc*g2Y(vc`^eZnGKdCg|!e$@S4D5Xhl^Q&Go9zN*<@v`o
zO9qU^F^8#Pu6C3I!8wg!Wnt;GE+^&O<$w+8K1ei!=45Dwl&};H-G+V~40Va?RFFa<
ze_GT}fFt@vHQrBsVe~u@v|2m54w#3DE3L<u6n%Tq&cXM1Rd2vHMemiH$KN_yq_JSf
znoa#5sO5rzwP@QtZM?j`+H;|oJTO&P@e+ck1`<^duYMI<^D_wOe$QBRv-d)ZXsz%{
zwP`deS6}g1a^KAyBh)$dqqiWC76EUzS+d)w9w>3oBUc8W^gAT2ATa)Ft_Lb)`6yj6
z)H5l`8ZvNQ#~;`%JY!L;q|A6jdfZvJtsB~_AKz&cON*&1wQEN=!}(q37ITvQCRSz+
zE*}?CsLdR;3jn2$$iN>*z=PBa!eI`Iqqg|56^pjR^nn}RFR|E3*wAvN*&Tdx`5I*2
z8)Gego2`iOzHF|3hWb3b?gZ&K7t7U{W!7K3O&*_uCm-p~s0w#W!rCyoao>S@J_M3T
zun}rn3-7{6P0|9N*&Wy~0<|||6)y#W7>qSCnL5vHIRLMB5<rwIT2`E0ZQZ*7JS<lb
zc$C^_3sZ6N<Z?>fQYFYgHv|u^9ku%9CwPLv_fg=3aKZ#|!ij`A#Xyu1=wCpub*(Iz
zh$^7HugS`vh$W(Q_@}rS--5?A8#Uo!TH4B_U;+qflD#E&p@YRsT<J2JyAd7X#Zut>
zzhki+s1#2oFIM!+UxEt7IlcQ70tGd-1}-{Q^%`T{-3w&D8G>-BS=I1O^VeH?Oo*`*
z=vSA<;{10&_4VGdA_+O~h{J!&6e5UUqi~5qEjrw>uf<dk`~r`YPR_24_xT5y!xS(1
zidpyePB?i>`cE&1Ar@{m%U~z?vcfw{!z&g=z-s~mowJ;+P+*G9#DZ}z!|T)vP`Q|~
zxbhS9nWr|biFk|egWj|e*Ga<Ts6cp800jY<&cwI474)2etz`pI6NZZYuC#;$JLd)x
zCM^AT`S2-DoIqu05+1XRs{k4Pdvpybur+=A;1N%Z;rt@|M3T4sSQp)nxqrMNAXc)U
z>s~a&iJqtox5z7M!@cW_Alt<fjay4D(J#ulfxxH3_+bUD{_{uW*t|I}k3E{{0vW9=
zS+Nil2%dIcq0HAoHnb98Vyd0Z@Mj<?WPc^4#{^qUfM+>)u1B9o5?B)sC!^vBPBuS{
z(A|sVo7((Xd9N`+98d@t0d?6h)j>~a7Gv8&16C5YJ)Bq`DhX+w3mCN%2ifUxbX?i{
z=71}#xfbQR`hwHye(+?U2R-9?{5Tjoi0NaPk2y%7{&QL-_do(Ey0`KtO1Zan&501f
zVTj(jSi&z1a7=j7U6W&4K_QTx3)VodfG){k#bROhQzJR@%e&I|t@M7?KC78H-|f6&
z_L(dRKsCy;%8qceR+37B=ySz8;S5LyjC{N;W+HVZZryYmC`U*_MfzLyd;kjIlv?{W
zFlR$^nQkS(Iqroc)P#=Dk^5ftBq^@kQndIZeI4{x3w>==m>2Z2GxDXUotMvjem1{L
z^XVe>k>ASA>z<26{0qe}O8HI&uK#n!V4{+=vV{#ehGdgIYmu%6h>2J4P|zc^0m-kJ
z`&FpSVNRr#X7h?THGy{XF&r4|5iqngLt#cU#L5EvnQ7ee5)T?p?Dko6-(JE7gtK6n
zEI}r>hmU(D>ji=N`H~dgRv_eqES8&uH_3#X2;wQN`ox0F!sCOHi!X53!&48vBM5Rw
zu+be5YPrkR8tBzZ^?Wbh<c#>C$3X;sRKn@HNR9?EnUdA0wQT+LxaYeIe8jcr`8Gq-
zKM!6&k%gP>%R!fQZZh@X%0^3}(DxSeL$3%e<7^)_4>j1{dx>Tw2({*bg)lTlh@LQk
zHw0|VZ8qWCsH1nDz`7I(a&j=;Rb(s#OrDY@Do}?;asvG3UBJw)dMgYqYsg*1t8N8o
z0XkbLR#4#S2+aJ-nU9p5(4Fki+yfeu>BZ^{B=R#MgQ;%QRn><eojEz~<o`o>6kXO0
zK8!6krz<jQ1Nc|yVOn<~6gH#__ELfD5qwQ%*eDnY$quk+S;xpqPV@wfbU+)^V03^I
zw;nySDt!jO7NA-NuO-`R+JWAq;R7g^B39zWbvFA*&C88HU0w$G99U*_1@Ns@uFR|i
z!X|{T{=v=~Fi=P13R_M1G92H$rsV=sd>GNu=tb8m0CWz3jV*T}*c&xMZ~RR|L7MrM
zn&lwN(&*+G>pP?;L1}<T5w|Qz44D9kL8m97D|E%DArDsu?f~CPN*`yzlssq8`{Gaf
zJM@9o6tP@Mfd@0=%R|xsau9wy0-9VC<w1=GMO(N>upl-S-Xgk{<o;l_#pHqhdRh7u
zG>u${30-1eS+uBJnJm#PV-28>_be$cmB8ahqWllYhM4cP_stgNINxZ<V!mTT4>F(y
zJ3(6amkVy%mAImU5T~i)+T#JSPI7(R@nx-tgmu3XKB&K5o*oPTkAU(1#Firt!J_Sf
zyOY%q9gODFmE(VS;X}sOYomLfx&8iX=+w2-cV5e-CAU7-=8B%Z=coLad-L(#dp}fW
zem>pz+k?5og*j2TJCEKtQ~TlM+J<Xw-j^*(T}Ol!f0tP<-L$2vmfkg9Y(7z5!&c&B
zS5ISi(h@bvKW7w*L~BkK8^A>@g3J0WC9~N<rvIQp*43={MeBUGZpE(sq>!2=EX>_~
z-u0&~G1`o2ot`C|$)1B*o8~x2kzOv6Mv3x&J2lWhlc2%lv7jaC&0m?bKW>E)OqqLg
z(K%4E4@)+*f1GVwc{}ov&!?LCb7yoaT~);^(ad2(XeJ~hR&_(_&zBCL2nG^v7ZggK
zw6$>!4~m|azzm&(Jc^nI=0=|J7fjo;2AHwmD$z~{5fzKi-Xmewu;AvlSeF=_-+#ah
zHeKWov1{Sc{ZPEcqIQjTcogZtet+-Jw1S(Iy&iI*+bA&*)0hZf6@(fla<$@-_Zgit
zW_e%M$FPeu)O}Da!n)5NFbm{a@}_C6e6GDxUAv;S*nX2eg(0}IZ6QU5^9O!i!N=3$
zv5GRJvczE6ThQ*v<LP4$#E!&Br(Co+{jQ(8(eaRZ<r?A(_0Kg|X3Nr>oG!QDD|zEE
zL}+!|4;z;%F!wjAc$ECI_klE6o8nOb)_&8~YIxri(;m}J`83+sCKhb$Eo`1Xu*4oP
zK0XpXyOjBa-B;(_oFeo7mVVdmhbjd*oh<_T-Zs0MzMfpj;&Gl+NWSg2o79Ub>Abb6
z57N4Kb@%L3D%Yt8s{EB_jP4<C8>+MdrN{PGZr>Juc>mC$yw4XFmNs}yC%;ZD`s*DQ
ze>T;oew@diEud(YhwP_clDT5g*g6%%;)Rs<{c5wrG<Mw4HAa)iLd7=uoEndIKJ{kO
zz=xj|+ps_9iJpV(n?4zyj(c4Z?(MEmT?<~r=P)@DD1KP{rR~<kdqXs;7M3oa|Dkj1
znD=}o7gjjFuh~9YqO4>2;Yixj4{ygGrwa&6TY1VsTF~Au_K8>Bbn&^loE)-ve(V_^
ze$mSwCKR!j_7`y1#)kEUq3bY~Ece}Mt=m301&q?)WF}Jo)1e2uD*5Bvmbz6u+IgmO
z@237^CM5|v-#h)mN3%EAC_OgH>lcxdNl0XyxM4<OypCHGW%x2AudMJGH_Q&M><^f^
zed9QK1~k9tF2we7yJ@R=Q7SdxY(|ck%fab;?0TZdRq=;SCmnPr?ml!fc&bZwkICE)
zMFw*T!2|oa&Ap+h!~3sV<ADuc-XKlk+{1%K1Y2=B`1zNNwPtACIabi%9`L2I67Ea9
zv41Xw!VIRs9&w_FC~nc=*%UdMy(;{bJ97BY>K}LDDSQ3>_HBCPOEGTtDWa3fC;8>U
z4^;N`m`(h47Ha9r{M2F}-Ct$p=b)m#nWe^wXK2jBdGe@5QR?JEW4h$a+ePeeE?RsX
zk;N=)>Tl)RYHcj=3v)GU6{EPOJcpkp@@b>T2ueCTtnK!w?3I5u;=l-1z2!sCn_L?&
z#FcMJ?_x}Ajqvb})!i&v3@rXRa;J~fX~{s7Jf#c<)J#&zwWbl-qtCCiSr!>pzs%VZ
zqvzZ6lFF47A>Q%oKm~$;u?_fLI76gfnY7xIdEFkTOfGPZ@oT5&CGN_@;`I{s9~wV;
za=`H2Y{^Pq+&4+uvW@)oN1p5zwxtj_UFo9da(m&IxR~ZJ35Iscr<cvHV>`=Du#q!%
zM_#wM=v6yQ<nJgE6&;rSlH6wq8<y^SfqFjTjYAc`MT)m7+#hjZ2BTgdi7dDgQ`d$M
zCbGHi?YGUo#&|Qs;9VK(Y8>;6`xZXd_4P9ESVl2=R4u~eEY2{5xR{xo-eKkzRT%p4
z;q9X5bJdjHosTgQ6Ahl8C-PFGv#b@-kww>dDfq9$&To$Z4g|mDf+AAqOxVD`BC^SC
zjnZpT_jj}7j%_b3?B(8C$jy(uVRKmB&huZH&}?yZ#N+8x?LrpqFHHxpikJP#6(>7H
zC>OQSpoj)%!0Cu`OxK;*Zk-=lWLqE=owq;E;(O;BmY9X7M~O43Us<RYg#!UiJpPRI
zCu0G`8wiK*CjgE^oEM^Wqdv}FHD%xb<~64W-{ppD2jJ(s*WuT(jFkE_+2Pad-=>#u
z*06Gp?dXm>fi<O`<Z<97jOzUmRCq%dXp;<>SwBKYF|Iz{R3COk&QFyT8`EreaLD6n
zfo|VaiABDj_9psC1fB(CW;&}E(L-Y<s;kWNLQFOx^a{kY>VQ;5!|5P(@8iv_`KeSC
zD~vCyBYDstLY;}~3>2HVxr5Sdq|j8m^tr2UW$VWM?QN>>5bTNEi2SiBR#A==om4yc
zB<lxkeR6_ZDGy?kD{lL@lcPr|Vw!kqL|{qWpoW8`*P#mKJs}!xkE%^0Yf0K_VNjvi
z9<X7BlMipuAaP(zlMaTb|Lo<QIfIjS3O`jk=Dzx;6rg--FM=KSLS&L+W1B}vPiKyO
zF@to7fBM$c?XZtk87(Z@Sv}}j=pnnK=z#k<@odPoz4zLHe2K1<mIV;IVQx0%m9(WC
zH+KC7?kDZMgF`0A0-VfYQG=d(m5whji$dXd5`6txVoW$4oOC**dp-EDc|*4I4^b7M
z5h`ltQ^1Vp3{lA^Za9VC>*yh{<1vY=e>Jy0ITypVW4kWckq$-R;|8O2Mr&MZy&wB{
zGo<$KEQle*e}1YcvvOjA%op@8h<cC{b;h3HV0bq#x;<?^Ei>BbJhwI6JpKkV0yXbR
z?Y1Gc`v2M7s$FSq7nGe+W#I@{;cNuUZFM`uiBF$>-&_;xY;x>KvvdpIIeTkfh=ceb
z%hyIH<NJxkPQOaT8ahII%MKvcpu`f7Cvbt)z1Pu)_rE^U+zO>1jO4b1MaihzoaCnh
z$>*eKGN0kUu*^E$O}fqHB!9&Nf9X;GAlF@Iptfcx$8E~^+@D3EQ?G}~P6p>q3U<!k
zo}V~Oe6Tfc`*{RX69$pu9THRx^x%Gm$x{>}rTTMUCcg|}R?WH1A}#H@sAyj)7isAP
zp94)W#Gil0PZ#A(Ti0mDiN^Fee(1apce-A?F8<O>{f9xD)N+>kUqD$7?Nt_6g$tD)
zQ^oxuSiOB)#9@i625DLE`qyok+vqa$n^Nm@^duOIZ>f5H-2_h)#*1N3X>X{v*^nhI
zALFTWvd&^YebP=xIN=AI_;G@fdsFI_YO4krK@8A2p>?O0vcNi`m)_0t_)qZ6+#-L-
zAOFrk_>#{HA1hrvuUSroFhGUj6`8;+tnoL14*bI-lJ@X>^6j&cLV?=Efp0Uv#rmvr
zee%oNAIEryub+J$DnNgZ#bXdZ9eM^y0YAf*Wj2uE$FWIWSRQ37L}z;5ElK`0KR-`K
zs+8Ymjr5-5m+6&>6mJiuo<q?&L&URu&zXux3nQ(yzup3P+h~we^S(5VU(w5@Sa?wH
z!7qJVeycj7b~kT_xLIHUBdNNw4K}rCUGchQ!afWPmFWviQM9v|FQ%S$wrxZ<F8QJ}
zqG?A)*}V8!ly1T0L={}?Y4a%$^7$)`$kFK6l=_(NzI5-Xgy^s04dvC&&R!B&Y5GO+
zhx%4ds<3aWX^EZ3TrK0NR!RMm7s~qoW`1`sqzefV<F?j?2NIq73rm8g1$}C5SdjRC
zc~aW;Ykd3cq_)DYRohYS6F1o2`$K(abhcP?>+Pc5DvJre+*_1B8Ru`QHP7%9cJiAW
z5b!meQ!KRj-gL9c6TO~NlBi0&j=T)GgxvR}jo9pp>D|Be`b_!0ifn>hukDhf4XM3?
z_6ns>-gA^b+JE1ZI#Okx=?5r^vVV-f`w$UR*9AgbWJSNZ1Et;YnB%JxVc7zDvh{xg
zd@~WP^mgmeA#d7fp*f<SItn@v-ZyH*3oX`a9|ruj60Y<0kML8kcdc~Qoz+E1@DxXa
zWGH&~p}|mm_^aUN+Ooy};2aKebleqB7i=S)itYF(9<dF39~RHN%c1JxmIK}dx%ML8
zu>#o2{?b*p!U&%|hwe3s-|Hw23);IoOKjyN5Gwp{aY#LBmNB!C;<5694sej%Jtp6T
z-X~*39{mS0?#pnWX9@}SUmi5OD(H7K(ZJaTA3C=vPOsP2hHLd~vo;QtA0U*cR7E*O
z(-M&(Unk&(TysyV<ALg4$Il+p4HJ(bPMQv_A)4IEw<;Lvl=t3K|7x}RG0hjx`F4-<
zVEMORZ(4hy{=+k*Uf;KtQ&5*nKC+jr;cS4UsCl-%scI(0sp8+2K^?CQM32wg&yz-v
zP+70VrgqgOyErSx{amNLb%RGaS$fM?;Z#<xP(D2~%ix?MxEiKC+-ba+Vg6J$vH8oF
z5yGD|kEdaJ5GXg|oFNNUj^wO?X2CECE*GTr)LqUWalb!;!_g;i;N1D`dAv`lnt0;)
zKc(+l_@kIQ@Is>)Ss@^2EZ};{d)T_YsIm<`W5z@b0Afe_T6PpIR~eBKeBVMOLuqPA
zm;B+uiH&@Ptj*e|n*F~psB{+(%=9nYt#4GBXLUs4bW>&h3)2m2x?eZg=|VL_T@_Tb
zwobFTu{z;!X_RgVbg2j<u@RL&{WQ?dx4tF0qYmYZ+MCvFBVZNa%>jOHY=rw2P^Il|
zbj{&^C4?v*IO&?(t?eR;F3CL_ae%wJj1wWMp-m_?gH1&yZa(&v2yA~2MrN?nnxB7h
zYGfh*+O|V|^0uw@<!NAosee8+uUt4iBe#=l$(L<B8#9bFKDS?*uV#S1(GyYl)jljt
z2T^N7*8f&VX0js+4>dZ@uJ6f1@mAwvD|#NQV3Tn8&HVA_j3xpKSfxaD)BNPsBy_r5
zZ(f;q3Jz@P#@6h##?a<_6%A6)Dhd_hQem8+RkhHY9TFZ0)OwJs1`J*XoCb@Kt=E+9
zGX_pRt!fH}HO}*IZ0l@OQo19T&lQ^e$)e~T)0L%N^Jj);XAHi0^Y;n6(qKA>C%KMz
z5r=1im9egj0Zf>&DnT5(4%*zidwM5Vv%{K*yOH*x+*S_(w<zA_((P@pTt-f?c#da~
zw;@mc{PZj79&KlGKsgt*HWcolkd66%Ngn50--|PsX2RmZspTV7*E6UBIJCWW8OLA~
z&U4SxTAU7TI@aEr2uW6pKlH|awwP!rHU)1>nr>_L!l{wl9i$CF2*hqD78>SX^MTIP
z#{M~+L;En(Kp(+Cl_-VD%udQQi$$CBR<6~^l)=dIow*ThwP*#ZOITzqIy~mHO1~s4
zU%BIo$G~Rj*~I1-xFN{lm3rwBHUp=G(B6A(ctJbK#EJEjMYg<5k_BY7+qpLgac-=8
zADH4WuUrCf(kn<!_`(lVq@khdi`*eB%`o>G{mo0Kw07`(1Up`H_lDY&G4&1rioN~C
zq_TF6Cc?FHRFko$uvPwUo0L=-dhHG>=M7E3so2K9Vn6PQ!PE(hyosu-(%pj<4Pqvl
ze!H5D(puMwWapeUMs@V;x&1R^a!s>M>(?G@uS<1#86t+4@ANO1>M4hLW9r$q_3rhe
zNw@eaoeL)*twU{%wkq@>HKCgZrcSvt&$)(q&X3#OOm+2;DXliRmg_%wpX#`QBB19o
zCy?R;F@s@=L#c^^BjtC`qjG{r^1^)pZAJ9Z-_w4f>V?&Zn@$0bzC@zBxD_Yk@&9qD
z;Z_pe|AULFX3RdUeVNAqCy?<cZR#oRsCAL`Q*VB{7hv@?o)p1Q6fd0T{dsIN@n9*w
z&`dDX0^Lu<iMm<WYU)lp)Gxws9LUe73*6;v@MEV@@_Eqlv^&)o+7Nq#B^I8`f!fR@
zT)3vw6>)f2R<prQ1b*<xEwm!B5*4(DJ^i*3^Y89Ob(v<9zYUNeccuA<N1+2>#bn}4
zQUs|31+n(!Fhn}P%MrD*qt1v)Z*8pSb)|?&AToDR5+<NnJKm~xgSN3&gzI(VOW@1U
z3%mQc_6j>P!ydBAUJf^AWP%>414staz>*WxnAk3Ikvpv&)Sn$WxcZgHT<>q+v{v}Z
zV+ZFCLlzlk0MWjiH!dbM_n@)pdy_P<r~SD;VU2hRAy(;CH9L)X9)9yW)eQA#;P4j*
zO!NFMK&_~5IthF4+J`4m(1AF6GPEl}(`tFPY`dHl^Q;P>fzFA|`I{(kRX+Jttl6Z2
zb2|Q8EEusQ6^{E~D_jp??G|?JgD{Tw#i3DTtM%CspbI8$u^?A)4GH!fTTd(m{wx^b
zU{?Hf<#fSVM}nFVP+a6Hj8o&ac>(%C;Fmz=?d;Y;BdKkbdks;YXLv2+{9EeJ7Y=n%
zkUc?85L{c`x(uww_NMrJNOe5cP?uOM-ENIH2^f~Qim*>&pG_XCx^sAR(`&dr$Ua4(
zYvaqn!_c}t!qds-1|CdnTx+<A(cm8SB}-M19E_<(yuS~IH{Cqe(7G3>lRY!w(|12C
zPUO*wtFQicIs3_3Z~lRGpk<}N+CWK337E)kaI)2hI^WJNrY%l0PkvgV*#TUz|KOIs
zLvGkLGPGQ~rC*n^+eQF+w)detUe7-^s+&6#pTh(w&iVznDet2MRa}4(5ljZb2Y}$!
zX*r9`wLkx65<{kK-s3wMMvWh#GCSMUfwk$yAi5yhKXkI4rm+yl>Ew7G7Qaz2XGleV
zX#}PumAXn|j!GxuLV>~-2ZeZTHFm{Z)?K1>|M7+A{y>h03FX<D2CE%mw;vuR2M$*J
zCqldpHH47s9+zDH6Fq`m%Y+!5_-4J}Yd5x8A;4oc$ni(~@LH3%G^mnL$23+|S02r{
z`XiS=jmQcn1N(sl!doF0r9T3H@%VE#Y!oS+!tBCPNWU<kMtc8{tIX8%&`QqX!Hg$=
zlrBa+iqTn`exy5IZ0&d%*k?lJqI=gVI#RD3QJV<R^r!343tK>Bf_K#j7!YX0^DhDb
z?}edjORdG4`N~yanC8LZM0Vr1nv4Jgo(|B1zJz9oH9ZGBWy?6T*Z(i;oJ)uY9`k;y
z^{&I`Ee-uu23R~FkiaX_1XanW3QYU$0qN#lEhSmBK5c(M4$$}ONImAZs?FmE@v28w
zv)x<>Af^hJZ+EdHR(3)r>s+`RNaf#e9VKcZnxP=|3WTfFjxUB(UU1o5h5}Afm@dnE
z68j~}iF8!MTrGSLh`#@W6F)yPo3W{d2?o%VJd`%~1#tsP{Fjc^ys8P>xbe0B<pk)x
znxgx}g4I9!SwQFimNpH{IyVc6nLqw(#1Rz`C!h(g8=a1TP6368<rI%s((ii7V4sZe
zWKd2D%qGYXBHQp*L5~~X^60?|zUXOw86<u%(WHADw0QOx?R5Xit-%Zhz$s&9JeGQs
z9~3@sHJoju;a%Q?mq-!tnAOf_+1~&()k^s0f-l4FqwCY;B4w~Yvj~=&p(5y0gM_OT
zUw@UwJ3vq`9pxg<>;YAHekj9N;SbL{h-ubY`)wHOw07KwoQFl)5*F_j&y60!1q2~c
z`V4|{V2cPFF9AJzCOBL>aAz@kuZJ5#v|TcIh>XFM1Mr7notA~@;f}yJAnM5T5GN_j
zbiVcaldpts`)=S$r})hl9X`l2`5vY{v^82{_!hJbjL0nT9*C#XIXR$!zi-YaZpixU
z$m`Y&4odH;LcAT^ZE1#6j-P*^9xuwlq~r4)pG80brz6{lGrM!1G`w#>wWLWMv3G&H
z*+bfwDJa`U@#w@njn8y`ozJQr%*mR<C3iLESf-KlYLYvf-hH5UR>C^W{7!iw6x#a|
z*K!S`aV+uOXnppy?pcYnRwU>!a{}U}$^>-P`Lah_-6V~uL%^$CE=O<nApDnU0x1Mu
z<vlSiT6Ek`6<2cioIyf}$Mnxc@%S5`p)EoR9b6R6bF%P@cHlk3PmX(1z;8VdQ8~Tz
zK!lJujm_VO@C=F*_%<06+(bZp1~L$}%s7X}Fi%MC!C!qs&>nS)Qle3DX7a$D;s><`
z*_vmLF<D0#F3og1OI7>^lZ!U!Nq|)d-_%NBCP9_KZgn!V5;;cTL<AE#fkff=L$1u;
z=k$YN0Pcp?4?Y_4Ytd9DL>VY|J1vL;vhavEl+RLcJgK|=DjxMdDDJf-gF+F$ECQ9;
zcNZRqQm7Yi`|^JWqR2fE7ef^3_i(-^bhlny`wX}hbmynFk<{Ilt}nQSVS@;HlvVLP
zNX9SUBM*W%+<^)9G}d+6Q5$qJH&Mv1>4tGQ;xc2PJp4>oeQ=W25VDcn!`Wk@cG8ae
z$ysWvl`0+@vRd{T`@Y2sKv^_`WJ9wY5NA<Zz&XbLCsKb3T{W$*Fugni`r1pyH_*F#
zOJIFA%z+8C91Etwx$E{KWf3vgvx`wk#GiY%>UxomwOm2~X!B)fkjFuJy3B;YNo6FK
z>AjpIwT7w>Upv$VE(c+|;5il%doseoZ`lrNVg2(j5~we1#jy`luO6M=Q3M)LpJLIV
z2PZh2#Som`^3zhmqW4Ku15H-5$_f;1V&+MFaX#y_+PY`!FGG_(x!`f>=hen>hit)(
zO0Dsi@J17JI1Mcrk7n2i-WaL;lO6_<B_J|k2TVXv=Dlk-6p~Bjg1qFbbVXz;{wYpv
zxXQP0i#$ANOZHbw2;CU^^Tm#2OQ`$Mg{yxqx`Y>`5Bwb))Y?Q^QNM?2KSv$H^5`L)
zj%-LYv5Yl&^hD3s>Oh?E+J96;5jKP}N-BR<G-&LMo+idDxM-nSs-x;!ZPg7IGUfj#
z{)v+aF?qDYpi7Sc>ix|2xjWli3ua+M%^)oZ>F#FaXqcMDXXED{dG-&0p$S~Q;Drup
zYXGo%wNKy?_~-gBdc&5arIXL1{a4n$+c{f&zR*CvtppNELF!t(J9Dup5GZx^>U*8~
zSBC~H2eto(Q0%bX>7JVv`~Yu`uw47q%0DhozXx)ORu*7-QxcT9a@F-YAZ-D|c<J;@
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
aJ~=HfHonn+c&3|SB!1pluN&LKPyG)b9>6aE

diff --git a/docs/internals.md b/docs/internals.md
deleted file mode 100644
index beb28f17a..000000000
--- a/docs/internals.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# Internals
-
-Expr is a stack-based virtual machine. It compiles expressions to bytecode and
-runs it. The compilation is done in a few steps:
-
-- Parse expression to AST
-- Type check AST
-    - Apply operator overloading
-    - Apply custom AST patching
-- Optimize AST
-- Compile AST to a bytecode
-
-The compiler has a bunch of optimization which will produce a more optimal program.
-
-## In array
-
-```
-value in ['foo', 'bar', 'baz']
-```
-
-If Expr finds an `in` or `not in` expression with an array, it will be
-transformed into:
-
-```
-value in {"foo": true, "bar": true, "baz": true}
-```
-
-## Constant folding
-
-Arithmetic expressions with constants are computed on compile step and replaced
-with the result.
-
-```
--(2 - 5) ** 3 - 2 / (+4 - 3) + -2
-```
-
-Will be compiled into just a single number:
-
-```
-23
-```
-
-## In range
-
-```
-user.Age in 18..32
-```
-
-Will be replaced with a binary operator:
-
-```
-18 <= user.Age && user.Age <= 32
-```
-
-## Const range
-
-```
-1..10_000
-```
-
-Ranges computed on the compile stage, are replaced with pre-created slices.
diff --git a/docs/language-definition.md b/docs/language-definition.md
index 251f84552..c8709aa04 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -486,7 +486,7 @@ date("2023-08-14 00:00:00", "2006-01-02 15:04:05", "Europe/Zurich")
 
 Available methods on the date:
 
-- `Year()` - returns the year
+- `Year()` - returns the year 
 - `Month()` - returns the month (starting from 1)
 - `Day()` - returns the day of the month
 - `Hour()` - returns the hour
diff --git a/docs/operator-overloading.md b/docs/operator-overloading.md
deleted file mode 100644
index 2565f820a..000000000
--- a/docs/operator-overloading.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# Operator Overloading
-
-**Expr** supports operator overloading. For example, you may rewrite such expression:
-
-```
-Now().Sub(CreatedAt) 
-```
-
-To use `-` operator:
- 
-```
-Now() - CreatedAt
-```
-
-To overload the operator use [Operator](https://pkg.go.dev/github.com/expr-lang/expr?tab=doc#Operator) option:
-
-```go
-func main() {
-	code := `Now() - CreatedAt`
-
-	options := []expr.Option{
-		expr.Env(Env{}),
-		expr.Operator("-", "Sub"), // Replace `-` operator with function `Sub`.
-	}
-
-	program, err := expr.Compile(code, options...)
-	if err != nil {
-		panic(err)
-	}
-
-	env := Env{
-		CreatedAt: time.Date(1987, time.November, 24, 20, 0, 0, 0, time.UTC),
-	}
-
-	output, err := expr.Run(program, env)
-	if err != nil {
-		panic(err)
-	}
-	fmt.Print(output)
-}
-
-type Env struct {
-	CreatedAt time.Time
-}
-
-func (Env) Now() time.Time                   { return time.Now() }
-func (Env) Sub(a, b time.Time) time.Duration { return a.Sub(b) }
-```
-
-**Expr** uses functions from `Env` for operator overloading. If types of 
-operands match types of a function, the operator will be replaced with a 
-function call.
diff --git a/docs/patch.md b/docs/patch.md
new file mode 100644
index 000000000..835e78f6a
--- /dev/null
+++ b/docs/patch.md
@@ -0,0 +1,125 @@
+# Patch
+
+Sometimes it may be necessary to modify an expression before the compilation.
+Expr provides a powerful mechanism to modify the expression using
+the [`Patch`](https://pkg.go.dev/github.com/expr-lang/expr#Patch) option.
+
+## Simple example
+
+Let's start with a simple example. We have an expression that uses a variable `foo`:
+
+```go
+program, err := expr.Compile(`foo + bar`)
+```
+
+We want to replace the `foo` variable with a constant `42`. First, we need to implement a [visitor](./visitor.md):
+
+```go
+type FooPatcher struct{}
+
+func (FooPatcher) Visit(node *ast.Node) {
+    if n, ok := (*node).(*ast.IdentifierNode); ok && n.Value == "foo" {
+        ast.Patch(node, &ast.IntegerNode{Value: 42})
+    }
+}
+```
+
+Now we can use the `FooPatcher` to modify the expression:
+
+```go
+program, err := expr.Compile(`foo + bar`, expr.Patch(FooPatcher{}))
+```
+
+## Advanced example
+
+Let's consider a more complex example. We have an expression that uses variables `foo` and `bar` of type `Decimal`:
+
+```go
+type Decimal struct {
+    Value int
+}
+```
+
+And we want to transform the following expression:
+
+```expr
+a + b + c
+```
+
+Into functions calls that accept `Decimal` arguments:
+
+```expr
+add(add(a, b), c)
+```
+
+First, we need to implement a visitor that will transform the expression:
+
+```go
+type DecimalPatcher struct{}
+
+var decimalType = reflect.TypeOf(Decimal{})
+
+func (DecimalPatcher) Visit(node *ast.Node) {
+    if n, ok := (*node).(*ast.BinaryNode); ok && n.Operator == "+" {
+        if !n.Left.Type().AssignableTo(decimalType) {
+            return // skip, left side is not a Decimal
+        }
+        if !n.Right.Type().AssignableTo(decimalType) {
+            return // skip, right side is not a Decimal
+        }
+        ast.Patch(node, &ast.CallNode{
+            Callee:    &ast.IdentifierNode{Value: "add"},
+            Arguments: []ast.Node{n.Left, n.Right},
+        })
+        (*node).SetType(decimalType) // set the type, so patcher can be used multiple times
+    }
+}
+```
+
+We used [Type()](https://pkg.go.dev/github.com/expr-lang/expr/ast#Node.Type) method to get the type of the expression node.
+The `AssignableTo` method is used to check if the type is `Decimal`. If both sides are `Decimal`, we replace the expression with a function call.
+
+The important part of this patcher is to set correct types for the nodes. As we constructed a new `CallNode`, it lacks the type information.
+So after the first patcher run, if we want the patcher to be applied recursively, we need to set the type of the node.
+
+
+Now we can use the `DecimalPatcher` to modify the expression:
+
+```go
+env := map[string]interface{}{
+    "a": Decimal{1},
+    "b": Decimal{2},
+    "c": Decimal{3},
+    "add": func(x, y Decimal) Decimal {
+        return Decimal{x.Value + y.Value}
+    },
+}
+
+code := `a + b + c`
+
+program, err := expr.Compile(code, expr.Env(env), expr.Patch(DecimalPatcher{}))
+if err != nil {
+    panic(err)
+}
+
+output, err := expr.Run(program, env)
+if err != nil {
+    panic(err)
+}
+
+fmt.Println(output) // Decimal{6}
+```
+
+
+:::info
+Expr comes with already implemented patcher that simplifies operator overloading.
+
+The `DecimalPatcher` can be replaced with the [Operator](https://pkg.go.dev/github.com/expr-lang/expr#Operator) option.
+
+```go
+program, err := expr.Compile(code, expr.Env(env), expr.Operator("+", "add"))
+```
+
+Operator overloading patcher will check if provided functions (`"add"`) satisfy the operator (`"+"`), and
+replace the operator with the function call.
+:::
diff --git a/docs/tips.md b/docs/tips.md
deleted file mode 100644
index 415b78a8b..000000000
--- a/docs/tips.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# Tips
-
-## Reuse VM
-
-It is possible to reuse a virtual machine between re-runs on the program.
-In some cases, it can add a small increase in performance (~10%).
-
-```go
-package main
-
-import (
-	"fmt"
-	"github.com/expr-lang/expr"
-	"github.com/expr-lang/expr/vm"
-)
-
-func main() {
-	env := map[string]interface{}{
-		"foo": 1,
-		"bar": 2,
-	}
-
-	program, err := expr.Compile("foo + bar", expr.Env(env))
-	if err != nil {
-		panic(err)
-	}
-
-	// Reuse this vm instance between runs
-	v := vm.VM{}
-
-	out, err := v.Run(program, env)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Print(out)
-}
-```
diff --git a/docs/visitor-and-patch.md b/docs/visitor-and-patch.md
deleted file mode 100644
index fc4334f34..000000000
--- a/docs/visitor-and-patch.md
+++ /dev/null
@@ -1,98 +0,0 @@
-# Visitor and Patch
-
-The [ast](https://pkg.go.dev/github.com/expr-lang/expr/ast?tab=doc) package 
-provides the `ast.Visitor` interface and the `ast.Walk` function. It can be
-used to customize the AST before compiling.
-
-For example, to collect all variable names:
-
-```go
-package main
-
-import (
-	"fmt"
-
-	"github.com/expr-lang/expr/ast"
-	"github.com/expr-lang/expr/parser"
-)
-
-type visitor struct {
-	identifiers []string
-}
-
-func (v *visitor) Visit(node *ast.Node) {
-	if n, ok := (*node).(*ast.IdentifierNode); ok {
-		v.identifiers = append(v.identifiers, n.Value)
-	}
-}
-
-func main() {
-	tree, err := parser.Parse("foo + bar")
-	if err != nil {
-		panic(err)
-	}
-
-	visitor := &visitor{}
-	ast.Walk(&tree.Node, visitor)
-
-	fmt.Printf("%v", visitor.identifiers) // outputs [foo bar]
-}
-```
-
-## Patch
-
-Specify a visitor to modify the AST with `expr.Patch` function.  
-
-```go
-program, err := expr.Compile(code, expr.Patch(&visitor{}))
-```
- 
-For example, let's pass a context to every function call:
-
-```go
-package main
-
-import (
-	"context"
-	"fmt"
-	"reflect"
-
-	"github.com/expr-lang/expr"
-	"github.com/expr-lang/expr/ast"
-)
-
-func main() {
-	env := map[string]interface{}{
-		"foo": func(ctx context.Context, arg int) any {
-			// ...
-		},
-		"ctx": context.Background(),
-	}
-
-	code := `foo(42)` // will be converted to foo(ctx, 42)
-
-	program, err := expr.Compile(code, expr.Env(env), expr.Patch(patcher{}))
-	if err != nil {
-		panic(err)
-	}
-
-	output, err := expr.Run(program, env)
-	if err != nil {
-		panic(err)
-	}
-	fmt.Print(output)
-}
-
-type patcher struct{}
-
-var contextType = reflect.TypeOf((*context.Context)(nil)).Elem()
-
-func (patcher) Visit(node *ast.Node) {
-	callNode, ok := (*node).(*ast.CallNode)
-	if !ok {
-		return
-	}
-	callNode.Arguments = append([]ast.Node{&ast.IdentifierNode{Value: "ctx"}}, callNode.Arguments...)
-}
-
-```
diff --git a/docs/visitor.md b/docs/visitor.md
new file mode 100644
index 000000000..24532d3da
--- /dev/null
+++ b/docs/visitor.md
@@ -0,0 +1,49 @@
+# Visitor
+
+Expr provides an interface to traverse the AST of the expression before the compilation.
+The `Visitor` interface allows you to collect information about the expression, modify the expression, or even generate
+a new expression.
+
+Let's start with an [ast.Visitor](https://pkg.go.dev/github.com/expr-lang/expr/ast#Visitor) implementation which will 
+collect all variables used in the expression:
+
+```go
+type Visitor struct {
+    Identifiers []string
+}
+
+func (v *Visitor) Visit(node *ast.Node) {
+    if n, ok := (*node).(*ast.IdentifierNode); ok {
+        v.Identifiers = append(v.Identifiers, n.Value)
+    }
+}
+```
+
+Full list of available AST nodes can be found in the [ast](https://pkg.go.dev/github.com/expr-lang/expr/ast) documentation.
+
+Let's parse the expression and use [ast.Walk](https://pkg.go.dev/github.com/expr-lang/expr/ast#Walk) to traverse the AST:
+
+```go
+tree, err := parser.Parse(`foo + bar`)
+if err != nil {
+    panic(err)
+}
+
+v := &Visitor{}
+ast.Walk(&tree.Node, v)
+
+fmt.Println(v.Identifiers) // [foo, bar]
+```
+
+:::note
+
+Although it is possible to access the AST of compiled program, it may be already be modified by patchers, optimizers, etc.
+
+```go
+node := program.Node()
+
+v := &Visitor{}
+ast.Walk(&node, v)
+```
+
+:::

From 1a5df77b1313a7abf6a02f4977f8a27d38d91576 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 8 May 2024 22:27:02 +0200
Subject: [PATCH 328/506] Improve now() and date() validation

---
 builtin/builtin.go      | 4 ++--
 builtin/builtin_test.go | 3 +++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 9687d7e59..cc6f197cd 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -487,7 +487,7 @@ var Builtins = []*Function{
 				return timeType, nil
 			}
 			if len(args) == 1 {
-				if args[0].AssignableTo(locationType) {
+				if args[0] != nil && args[0].AssignableTo(locationType) {
 					return timeType, nil
 				}
 			}
@@ -559,7 +559,7 @@ var Builtins = []*Function{
 			if len(args) < 1 {
 				return anyType, fmt.Errorf("invalid number of arguments (expected at least 1, got %d)", len(args))
 			}
-			if args[0].AssignableTo(locationType) {
+			if args[0] != nil && args[0].AssignableTo(locationType) {
 				args = args[1:]
 			}
 			if len(args) > 3 {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index b7579153c..b99ed42ce 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -233,6 +233,9 @@ func TestBuiltin_errors(t *testing.T) {
 		{`bitshr(-5, -2)`, "invalid operation: negative shift count -2 (type int) (1:1)"},
 		{`bitshl(1, -1)`, "invalid operation: negative shift count -1 (type int) (1:1)"},
 		{`bitushr(-5, -2)`, "invalid operation: negative shift count -2 (type int) (1:1)"},
+		{`now(nil)`, "invalid number of arguments (expected 0, got 1)"},
+		{`date(nil)`, "interface {} is nil, not string (1:1)"},
+		{`timezone(nil)`, "interface {} is nil, not string (1:1)"},
 	}
 	for _, test := range errorTests {
 		t.Run(test.input, func(t *testing.T) {

From 45c1ae72c0b5b031cca3533886638a7d0cae3165 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 9 May 2024 17:22:41 +0200
Subject: [PATCH 329/506] Add int overflow checks

---
 checker/checker.go   |  2 ++
 compiler/compiler.go | 28 ++++++++++++++++++++++++++++
 expr_test.go         | 14 ++++++++++++++
 3 files changed, 44 insertions(+)

diff --git a/checker/checker.go b/checker/checker.go
index ecf7a04d6..314cb65b2 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -1039,9 +1039,11 @@ func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newType refl
 	case *ast.IntegerNode:
 		(*node).SetType(newType)
 	case *ast.UnaryNode:
+		(*node).SetType(newType)
 		unaryNode := (*node).(*ast.UnaryNode)
 		traverseAndReplaceIntegerNodesWithIntegerNodes(&unaryNode.Node, newType)
 	case *ast.BinaryNode:
+		// TODO: Binary node return type is dependent on the type of the operands. We can't just change the type of the node.
 		binaryNode := (*node).(*ast.BinaryNode)
 		switch binaryNode.Operator {
 		case "+", "-", "*":
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 1aa5ce188..c04611bdc 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -2,6 +2,7 @@ package compiler
 
 import (
 	"fmt"
+	"math"
 	"reflect"
 	"regexp"
 
@@ -329,22 +330,49 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) {
 	case reflect.Int:
 		c.emitPush(node.Value)
 	case reflect.Int8:
+		if node.Value > math.MaxInt8 || node.Value < math.MinInt8 {
+			panic(fmt.Sprintf("constant %d overflows int8", node.Value))
+		}
 		c.emitPush(int8(node.Value))
 	case reflect.Int16:
+		if node.Value > math.MaxInt16 || node.Value < math.MinInt16 {
+			panic(fmt.Sprintf("constant %d overflows int16", node.Value))
+		}
 		c.emitPush(int16(node.Value))
 	case reflect.Int32:
+		if node.Value > math.MaxInt32 || node.Value < math.MinInt32 {
+			panic(fmt.Sprintf("constant %d overflows int32", node.Value))
+		}
 		c.emitPush(int32(node.Value))
 	case reflect.Int64:
+		if node.Value > math.MaxInt64 || node.Value < math.MinInt64 {
+			panic(fmt.Sprintf("constant %d overflows int64", node.Value))
+		}
 		c.emitPush(int64(node.Value))
 	case reflect.Uint:
+		if node.Value < 0 {
+			panic(fmt.Sprintf("constant %d overflows uint", node.Value))
+		}
 		c.emitPush(uint(node.Value))
 	case reflect.Uint8:
+		if node.Value > math.MaxUint8 || node.Value < 0 {
+			panic(fmt.Sprintf("constant %d overflows uint8", node.Value))
+		}
 		c.emitPush(uint8(node.Value))
 	case reflect.Uint16:
+		if node.Value > math.MaxUint16 || node.Value < 0 {
+			panic(fmt.Sprintf("constant %d overflows uint16", node.Value))
+		}
 		c.emitPush(uint16(node.Value))
 	case reflect.Uint32:
+		if node.Value > math.MaxUint32 || node.Value < 0 {
+			panic(fmt.Sprintf("constant %d overflows uint32", node.Value))
+		}
 		c.emitPush(uint32(node.Value))
 	case reflect.Uint64:
+		if node.Value < 0 {
+			panic(fmt.Sprintf("constant %d overflows uint64", node.Value))
+		}
 		c.emitPush(uint64(node.Value))
 	default:
 		c.emitPush(node.Value)
diff --git a/expr_test.go b/expr_test.go
index 2c8ab461c..e16d987a0 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2645,3 +2645,17 @@ func TestIssue_570(t *testing.T) {
 	require.NoError(t, err)
 	require.IsType(t, nil, out)
 }
+
+func TestIssue_integer_truncated_by_compiler(t *testing.T) {
+	env := map[string]any{
+		"fn": func(x byte) byte {
+			return x
+		},
+	}
+
+	_, err := expr.Compile("fn(255)", expr.Env(env))
+	require.NoError(t, err)
+
+	_, err = expr.Compile("fn(256)", expr.Env(env))
+	require.Error(t, err)
+}

From 6cf0edb662c172f835d09cf93f7e2977bda52a6b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 12 May 2024 11:55:15 +0200
Subject: [PATCH 330/506] Add better error messages for index out of bounds
 errors

---
 expr_test.go          | 10 +++++++++-
 vm/runtime/runtime.go |  6 +++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index e16d987a0..234b9be61 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1329,7 +1329,9 @@ func TestExpr(t *testing.T) {
 }
 
 func TestExpr_error(t *testing.T) {
-	env := mock.Env{}
+	env := mock.Env{
+		ArrayOfAny: []any{1, "2", 3, true},
+	}
 
 	tests := []struct {
 		code string
@@ -1341,6 +1343,12 @@ func TestExpr_error(t *testing.T) {
  | filter(1..9, # > 9)[0]
  | ...................^`,
 		},
+		{
+			`ArrayOfAny[-7]`,
+			`index out of range: -3 (array length is 4) (1:11)
+ | ArrayOfAny[-7]
+ | ..........^`,
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 7da1320de..cd48a280d 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -35,8 +35,12 @@ func Fetch(from, i any) any {
 	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.String:
 		index := ToInt(i)
+		l := v.Len()
 		if index < 0 {
-			index = v.Len() + index
+			index = l + index
+		}
+		if index < 0 || index >= l {
+			panic(fmt.Sprintf("index out of range: %v (array length is %v)", index, l))
 		}
 		value := v.Index(index)
 		if value.IsValid() {

From 1659c2350421c350c6aac17042dfe54d47c78c35 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 17 May 2024 18:10:26 +0200
Subject: [PATCH 331/506] Refactor lexer (#653)

---
 expr_test.go               |  13 +++++-
 file/error.go              |  28 +++++++++---
 file/location.go           |   8 +---
 file/source.go             |  73 +++++++++--------------------
 file/source_test.go        |  15 ------
 parser/lexer/lexer.go      |  91 ++++++++++++++++++-------------------
 parser/lexer/lexer_test.go |  32 +++++++------
 parser/lexer/state.go      |  14 +++---
 parser/parser.go           |   2 +-
 parser/parser_test.go      |  12 ++---
 testdata/crash.txt         | Bin 0 -> 6 bytes
 vm/program.go              |   6 +--
 12 files changed, 135 insertions(+), 159 deletions(-)
 create mode 100644 testdata/crash.txt

diff --git a/expr_test.go b/expr_test.go
index 234b9be61..bd099a276 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1623,7 +1623,10 @@ func TestCompile_exposed_error(t *testing.T) {
 
 	b, err := json.Marshal(err)
 	require.NoError(t, err)
-	require.Equal(t, `{"Line":1,"Column":2,"Message":"invalid operation: == (mismatched types int and bool)","Snippet":"\n | 1 == true\n | ..^","Prev":null}`, string(b))
+	require.Equal(t,
+		`{"from":2,"to":4,"line":1,"column":2,"message":"invalid operation: == (mismatched types int and bool)","snippet":"\n | 1 == true\n | ..^","prev":null}`,
+		string(b),
+	)
 }
 
 func TestAsBool_exposed_error(t *testing.T) {
@@ -2667,3 +2670,11 @@ func TestIssue_integer_truncated_by_compiler(t *testing.T) {
 	_, err = expr.Compile("fn(256)", expr.Env(env))
 	require.Error(t, err)
 }
+
+func TestExpr_crash(t *testing.T) {
+	content, err := os.ReadFile("testdata/crash.txt")
+	require.NoError(t, err)
+
+	_, err = expr.Compile(string(content))
+	require.Error(t, err)
+}
diff --git a/file/error.go b/file/error.go
index edf202b04..8ff85dfa5 100644
--- a/file/error.go
+++ b/file/error.go
@@ -8,22 +8,36 @@ import (
 
 type Error struct {
 	Location
-	Message string
-	Snippet string
-	Prev    error
+	Line    int    `json:"line"`
+	Column  int    `json:"column"`
+	Message string `json:"message"`
+	Snippet string `json:"snippet"`
+	Prev    error  `json:"prev"`
 }
 
 func (e *Error) Error() string {
 	return e.format()
 }
 
-func (e *Error) Bind(source *Source) *Error {
-	if snippet, found := source.Snippet(e.Location.Line); found {
+func (e *Error) Bind(source Source) *Error {
+	e.Line = 1
+	for i, r := range source {
+		if i == e.From {
+			break
+		}
+		if r == '\n' {
+			e.Line++
+			e.Column = 0
+		} else {
+			e.Column++
+		}
+	}
+	if snippet, found := source.Snippet(e.Line); found {
 		snippet := strings.Replace(snippet, "\t", " ", -1)
 		srcLine := "\n | " + snippet
 		var bytes = []byte(snippet)
 		var indLine = "\n | "
-		for i := 0; i < e.Location.Column && len(bytes) > 0; i++ {
+		for i := 0; i < e.Column && len(bytes) > 0; i++ {
 			_, sz := utf8.DecodeRune(bytes)
 			bytes = bytes[sz:]
 			if sz > 1 {
@@ -54,7 +68,7 @@ func (e *Error) Wrap(err error) {
 }
 
 func (e *Error) format() string {
-	if e.Location.Empty() {
+	if e.Snippet == "" {
 		return e.Message
 	}
 	return fmt.Sprintf(
diff --git a/file/location.go b/file/location.go
index a92e27f0b..6c6bc2427 100644
--- a/file/location.go
+++ b/file/location.go
@@ -1,10 +1,6 @@
 package file
 
 type Location struct {
-	Line   int // The 1-based line of the location.
-	Column int // The 0-based column number of the location.
-}
-
-func (l Location) Empty() bool {
-	return l.Column == 0 && l.Line == 0
+	From int `json:"from"`
+	To   int `json:"to"`
 }
diff --git a/file/source.go b/file/source.go
index d86a546b1..8e2b2d154 100644
--- a/file/source.go
+++ b/file/source.go
@@ -1,78 +1,47 @@
 package file
 
 import (
-	"encoding/json"
 	"strings"
 	"unicode/utf8"
 )
 
-type Source struct {
-	contents    []rune
-	lineOffsets []int32
-}
-
-func NewSource(contents string) *Source {
-	s := &Source{
-		contents: []rune(contents),
-	}
-	s.updateOffsets()
-	return s
-}
-
-func (s *Source) MarshalJSON() ([]byte, error) {
-	return json.Marshal(s.contents)
-}
-
-func (s *Source) UnmarshalJSON(b []byte) error {
-	contents := make([]rune, 0)
-	err := json.Unmarshal(b, &contents)
-	if err != nil {
-		return err
-	}
+type Source []rune
 
-	s.contents = contents
-	s.updateOffsets()
-	return nil
+func NewSource(contents string) Source {
+	return []rune(contents)
 }
 
-func (s *Source) Content() string {
-	return string(s.contents)
+func (s Source) String() string {
+	return string(s)
 }
 
-func (s *Source) Snippet(line int) (string, bool) {
+func (s Source) Snippet(line int) (string, bool) {
 	if s == nil {
 		return "", false
 	}
-	charStart, found := s.findLineOffset(line)
-	if !found || len(s.contents) == 0 {
+	lines := strings.Split(string(s), "\n")
+	lineOffsets := make([]int, len(lines))
+	var offset int
+	for i, line := range lines {
+		offset = offset + utf8.RuneCountInString(line) + 1
+		lineOffsets[i] = offset
+	}
+	charStart, found := getLineOffset(lineOffsets, line)
+	if !found || len(s) == 0 {
 		return "", false
 	}
-	charEnd, found := s.findLineOffset(line + 1)
+	charEnd, found := getLineOffset(lineOffsets, line+1)
 	if found {
-		return string(s.contents[charStart : charEnd-1]), true
-	}
-	return string(s.contents[charStart:]), true
-}
-
-// updateOffsets compute line offsets up front as they are referred to frequently.
-func (s *Source) updateOffsets() {
-	lines := strings.Split(string(s.contents), "\n")
-	offsets := make([]int32, len(lines))
-	var offset int32
-	for i, line := range lines {
-		offset = offset + int32(utf8.RuneCountInString(line)) + 1
-		offsets[int32(i)] = offset
+		return string(s[charStart : charEnd-1]), true
 	}
-	s.lineOffsets = offsets
+	return string(s[charStart:]), true
 }
 
-// findLineOffset returns the offset where the (1-indexed) line begins,
-// or false if line doesn't exist.
-func (s *Source) findLineOffset(line int) (int32, bool) {
+func getLineOffset(lineOffsets []int, line int) (int, bool) {
 	if line == 1 {
 		return 0, true
-	} else if line > 1 && line <= len(s.lineOffsets) {
-		offset := s.lineOffsets[line-2]
+	} else if line > 1 && line <= len(lineOffsets) {
+		offset := lineOffsets[line-2]
 		return offset, true
 	}
 	return -1, false
diff --git a/file/source_test.go b/file/source_test.go
index d380c22d0..5aa4f23ae 100644
--- a/file/source_test.go
+++ b/file/source_test.go
@@ -1,10 +1,7 @@
 package file
 
 import (
-	"encoding/json"
 	"testing"
-
-	"github.com/expr-lang/expr/internal/testify/assert"
 )
 
 const (
@@ -55,15 +52,3 @@ func TestStringSource_SnippetSingleLine(t *testing.T) {
 		t.Errorf(unexpectedSnippet, t.Name(), str2, "")
 	}
 }
-
-func TestStringSource_MarshalJSON(t *testing.T) {
-	source := NewSource("hello, world")
-	encoded, err := json.Marshal(source)
-	assert.NoError(t, err)
-	assert.Equal(t, `[104,101,108,108,111,44,32,119,111,114,108,100]`, string(encoded))
-
-	decoded := &Source{}
-	err = json.Unmarshal(encoded, decoded)
-	assert.NoError(t, err)
-	assert.Equal(t, source.Content(), decoded.Content())
-}
diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go
index c32658637..e6b06c09d 100644
--- a/parser/lexer/lexer.go
+++ b/parser/lexer/lexer.go
@@ -3,20 +3,18 @@ package lexer
 import (
 	"fmt"
 	"strings"
-	"unicode/utf8"
 
 	"github.com/expr-lang/expr/file"
 )
 
-func Lex(source *file.Source) ([]Token, error) {
+func Lex(source file.Source) ([]Token, error) {
 	l := &lexer{
-		input:  source.Content(),
+		source: source,
 		tokens: make([]Token, 0),
+		start:  0,
+		end:    0,
 	}
-
-	l.loc = file.Location{Line: 1, Column: 0}
-	l.prev = l.loc
-	l.startLoc = l.loc
+	l.commit()
 
 	for state := root; state != nil; {
 		state = state(l)
@@ -30,34 +28,25 @@ func Lex(source *file.Source) ([]Token, error) {
 }
 
 type lexer struct {
-	input      string
+	source     file.Source
 	tokens     []Token
-	start, end int           // current position in input
-	width      int           // last rune width
-	startLoc   file.Location // start location
-	prev, loc  file.Location // prev location of end location, end location
+	start, end int
 	err        *file.Error
 }
 
 const eof rune = -1
 
+func (l *lexer) commit() {
+	l.start = l.end
+}
+
 func (l *lexer) next() rune {
-	if l.end >= len(l.input) {
-		l.width = 0
+	if l.end >= len(l.source) {
+		l.end++
 		return eof
 	}
-	r, w := utf8.DecodeRuneInString(l.input[l.end:])
-	l.width = w
-	l.end += w
-
-	l.prev = l.loc
-	if r == '\n' {
-		l.loc.Line++
-		l.loc.Column = 0
-	} else {
-		l.loc.Column++
-	}
-
+	r := l.source[l.end]
+	l.end++
 	return r
 }
 
@@ -68,8 +57,7 @@ func (l *lexer) peek() rune {
 }
 
 func (l *lexer) backup() {
-	l.end -= l.width
-	l.loc = l.prev
+	l.end--
 }
 
 func (l *lexer) emit(t Kind) {
@@ -78,35 +66,39 @@ func (l *lexer) emit(t Kind) {
 
 func (l *lexer) emitValue(t Kind, value string) {
 	l.tokens = append(l.tokens, Token{
-		Location: l.startLoc,
+		Location: file.Location{From: l.start, To: l.end},
 		Kind:     t,
 		Value:    value,
 	})
-	l.start = l.end
-	l.startLoc = l.loc
+	l.commit()
 }
 
 func (l *lexer) emitEOF() {
+	from := l.end - 2
+	if from < 0 {
+		from = 0
+	}
+	to := l.end - 1
+	if to < 0 {
+		to = 0
+	}
 	l.tokens = append(l.tokens, Token{
-		Location: l.prev, // Point to previous position for better error messages.
+		Location: file.Location{From: from, To: to},
 		Kind:     EOF,
 	})
-	l.start = l.end
-	l.startLoc = l.loc
+	l.commit()
 }
 
 func (l *lexer) skip() {
-	l.start = l.end
-	l.startLoc = l.loc
+	l.commit()
 }
 
 func (l *lexer) word() string {
-	return l.input[l.start:l.end]
-}
-
-func (l *lexer) ignore() {
-	l.start = l.end
-	l.startLoc = l.loc
+	// TODO: boundary check is NOT needed here, but for some reason CI fuzz tests are failing.
+	if l.start > len(l.source) || l.end > len(l.source) {
+		return "__invalid__"
+	}
+	return string(l.source[l.start:l.end])
 }
 
 func (l *lexer) accept(valid string) bool {
@@ -132,18 +124,18 @@ func (l *lexer) skipSpaces() {
 }
 
 func (l *lexer) acceptWord(word string) bool {
-	pos, loc, prev := l.end, l.loc, l.prev
+	pos := l.end
 
 	l.skipSpaces()
 
 	for _, ch := range word {
 		if l.next() != ch {
-			l.end, l.loc, l.prev = pos, loc, prev
+			l.end = pos
 			return false
 		}
 	}
 	if r := l.peek(); r != ' ' && r != eof {
-		l.end, l.loc, l.prev = pos, loc, prev
+		l.end = pos
 		return false
 	}
 
@@ -153,8 +145,11 @@ func (l *lexer) acceptWord(word string) bool {
 func (l *lexer) error(format string, args ...any) stateFn {
 	if l.err == nil { // show first error
 		l.err = &file.Error{
-			Location: l.loc,
-			Message:  fmt.Sprintf(format, args...),
+			Location: file.Location{
+				From: l.end - 1,
+				To:   l.end,
+			},
+			Message: fmt.Sprintf(format, args...),
 		}
 	}
 	return nil
@@ -230,6 +225,6 @@ func (l *lexer) scanRawString(quote rune) (n int) {
 		ch = l.next()
 		n++
 	}
-	l.emitValue(String, l.input[l.start+1:l.end-1])
+	l.emitValue(String, string(l.source[l.start+1:l.end-1]))
 	return
 }
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index f30d3ba11..5edcbe5c4 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -5,10 +5,9 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/internal/testify/assert"
 	"github.com/expr-lang/expr/internal/testify/require"
-
-	"github.com/expr-lang/expr/file"
 	. "github.com/expr-lang/expr/parser/lexer"
 )
 
@@ -17,6 +16,13 @@ func TestLex(t *testing.T) {
 		input  string
 		tokens []Token
 	}{
+		{
+			"1",
+			[]Token{
+				{Kind: Number, Value: "1"},
+				{Kind: EOF},
+			},
+		},
 		{
 			".5 0.025 1 02 1e3 0xFF 0b0101 0o600 1.2e-4 1_000_000 _42 -.5",
 			[]Token{
@@ -265,25 +271,25 @@ func compareTokens(i1, i2 []Token) bool {
 }
 
 func TestLex_location(t *testing.T) {
-	source := file.NewSource("1..2 3..4")
+	source := file.NewSource("1..2\n3..4")
 	tokens, err := Lex(source)
 	require.NoError(t, err)
 	require.Equal(t, []Token{
-		{Location: file.Location{Line: 1, Column: 0}, Kind: Number, Value: "1"},
-		{Location: file.Location{Line: 1, Column: 1}, Kind: Operator, Value: ".."},
-		{Location: file.Location{Line: 1, Column: 3}, Kind: Number, Value: "2"},
-		{Location: file.Location{Line: 1, Column: 5}, Kind: Number, Value: "3"},
-		{Location: file.Location{Line: 1, Column: 6}, Kind: Operator, Value: ".."},
-		{Location: file.Location{Line: 1, Column: 8}, Kind: Number, Value: "4"},
-		{Location: file.Location{Line: 1, Column: 8}, Kind: EOF, Value: ""},
+		{Location: file.Location{From: 0, To: 1}, Kind: "Number", Value: "1"},
+		{Location: file.Location{From: 1, To: 3}, Kind: "Operator", Value: ".."},
+		{Location: file.Location{From: 3, To: 4}, Kind: "Number", Value: "2"},
+		{Location: file.Location{From: 5, To: 6}, Kind: "Number", Value: "3"},
+		{Location: file.Location{From: 6, To: 8}, Kind: "Operator", Value: ".."},
+		{Location: file.Location{From: 8, To: 9}, Kind: "Number", Value: "4"},
+		{Location: file.Location{From: 8, To: 9}, Kind: "EOF", Value: ""},
 	}, tokens)
 }
 
 const errorTests = `
 "\xQA"
-invalid char escape (1:5)
+invalid char escape (1:4)
  | "\xQA"
- | ....^
+ | ...^
 
 id "hello
 literal not terminated (1:10)
@@ -291,7 +297,7 @@ literal not terminated (1:10)
  | .........^
 
 früh ♥︎
-unrecognized character: U+2665 '♥' (1:7)
+unrecognized character: U+2665 '♥' (1:6)
  | früh ♥︎
 `
 
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index 72f02bf4e..d351e2f5c 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -14,7 +14,7 @@ func root(l *lexer) stateFn {
 		l.emitEOF()
 		return nil
 	case utils.IsSpace(r):
-		l.ignore()
+		l.skip()
 		return root
 	case r == '\'' || r == '"':
 		l.scanString(r)
@@ -83,14 +83,14 @@ func (l *lexer) scanNumber() bool {
 		}
 	}
 	l.acceptRun(digits)
-	loc, prev, end := l.loc, l.prev, l.end
+	end := l.end
 	if l.accept(".") {
 		// Lookup for .. operator: if after dot there is another dot (1..2), it maybe a range operator.
 		if l.peek() == '.' {
 			// We can't backup() here, as it would require two backups,
 			// and backup() func supports only one for now. So, save and
 			// restore it here.
-			l.loc, l.prev, l.end = loc, prev, end
+			l.end = end
 			return true
 		}
 		l.acceptRun(digits)
@@ -147,7 +147,7 @@ func not(l *lexer) stateFn {
 
 	l.skipSpaces()
 
-	pos, loc, prev := l.end, l.loc, l.prev
+	end := l.end
 
 	// Get the next word.
 	for {
@@ -164,7 +164,7 @@ func not(l *lexer) stateFn {
 	case "in", "matches", "contains", "startsWith", "endsWith":
 		l.emit(Operator)
 	default:
-		l.end, l.loc, l.prev = pos, loc, prev
+		l.end = end
 	}
 	return root
 }
@@ -193,7 +193,7 @@ func singleLineComment(l *lexer) stateFn {
 			break
 		}
 	}
-	l.ignore()
+	l.skip()
 	return root
 }
 
@@ -207,7 +207,7 @@ func multiLineComment(l *lexer) stateFn {
 			break
 		}
 	}
-	l.ignore()
+	l.skip()
 	return root
 }
 
diff --git a/parser/parser.go b/parser/parser.go
index 6d96561ad..fd1b3c043 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -55,7 +55,7 @@ type parser struct {
 
 type Tree struct {
 	Node   Node
-	Source *file.Source
+	Source file.Source
 }
 
 func Parse(input string) (*Tree, error) {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index bb0fc078b..3c6ee5b2b 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -724,14 +724,14 @@ Operator (||) and coalesce expressions (??) cannot be mixed. Wrap either by pare
  | ...........^
 
 0b15
-bad number syntax: "0b15" (1:5)
+bad number syntax: "0b15" (1:4)
  | 0b15
- | ....^
+ | ...^
 
 0X10G
-bad number syntax: "0X10G" (1:6)
+bad number syntax: "0X10G" (1:5)
  | 0X10G
- | .....^
+ | ....^
 
 0o1E
 invalid float literal: strconv.ParseFloat: parsing "0o1E": invalid syntax (1:4)
@@ -744,9 +744,9 @@ invalid float literal: strconv.ParseFloat: parsing "0b1E": invalid syntax (1:4)
  | ...^
 
 0b1E+6
-bad number syntax: "0b1E+6" (1:7)
+bad number syntax: "0b1E+6" (1:6)
  | 0b1E+6
- | ......^
+ | .....^
 
 0b1E+1
 invalid float literal: strconv.ParseFloat: parsing "0b1E+1": invalid syntax (1:6)
diff --git a/testdata/crash.txt b/testdata/crash.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3721d562474afc6e4fe987516512fb8e91c36fb1
GIT binary patch
literal 6
NcmZQzU|>?`1pokN05<>t

literal 0
HcmV?d00001

diff --git a/vm/program.go b/vm/program.go
index 989546744..15ce26f5b 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -21,7 +21,7 @@ type Program struct {
 	Arguments []int
 	Constants []any
 
-	source    *file.Source
+	source    file.Source
 	node      ast.Node
 	locations []file.Location
 	variables int
@@ -32,7 +32,7 @@ type Program struct {
 
 // NewProgram returns a new Program. It's used by the compiler.
 func NewProgram(
-	source *file.Source,
+	source file.Source,
 	node ast.Node,
 	locations []file.Location,
 	variables int,
@@ -58,7 +58,7 @@ func NewProgram(
 }
 
 // Source returns origin file.Source.
-func (program *Program) Source() *file.Source {
+func (program *Program) Source() file.Source {
 	return program.source
 }
 

From eb70f943cc3d585443f34580a7e7f8f0bd197622 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 17 May 2024 19:40:20 +0200
Subject: [PATCH 332/506] Add checks for nil before string casts in VM (#654)

---
 expr_test.go | 34 ++++++++++++++++++++++++++++++++++
 vm/vm.go     | 21 ++++++++++++++++++++-
 2 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/expr_test.go b/expr_test.go
index bd099a276..8b7856a43 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2678,3 +2678,37 @@ func TestExpr_crash(t *testing.T) {
 	_, err = expr.Compile(string(content))
 	require.Error(t, err)
 }
+
+func TestExpr_nil_op_str(t *testing.T) {
+	// Let's test operators, which do `.(string)` in VM, also check for nil.
+
+	var str *string = nil
+	env := map[string]any{
+		"nilString": str,
+	}
+
+	tests := []struct{ code string }{
+		{`nilString == "str"`},
+		{`nilString contains "str"`},
+		{`nilString matches "str"`},
+		{`nilString startsWith "str"`},
+		{`nilString endsWith "str"`},
+
+		{`"str" == nilString`},
+		{`"str" contains nilString`},
+		{`"str" matches nilString`},
+		{`"str" startsWith nilString`},
+		{`"str" endsWith nilString`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			program, err := expr.Compile(tt.code)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, env)
+			require.NoError(t, err)
+			require.Equal(t, false, output)
+		})
+	}
+}
diff --git a/vm/vm.go b/vm/vm.go
index 7e933ce74..fa1223b42 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -274,31 +274,50 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpMatches:
 			b := vm.pop()
 			a := vm.pop()
+			if runtime.IsNil(a) || runtime.IsNil(b) {
+				vm.push(false)
+				break
+			}
 			match, err := regexp.MatchString(b.(string), a.(string))
 			if err != nil {
 				panic(err)
 			}
-
 			vm.push(match)
 
 		case OpMatchesConst:
 			a := vm.pop()
+			if runtime.IsNil(a) {
+				vm.push(false)
+				break
+			}
 			r := program.Constants[arg].(*regexp.Regexp)
 			vm.push(r.MatchString(a.(string)))
 
 		case OpContains:
 			b := vm.pop()
 			a := vm.pop()
+			if runtime.IsNil(a) || runtime.IsNil(b) {
+				vm.push(false)
+				break
+			}
 			vm.push(strings.Contains(a.(string), b.(string)))
 
 		case OpStartsWith:
 			b := vm.pop()
 			a := vm.pop()
+			if runtime.IsNil(a) || runtime.IsNil(b) {
+				vm.push(false)
+				break
+			}
 			vm.push(strings.HasPrefix(a.(string), b.(string)))
 
 		case OpEndsWith:
 			b := vm.pop()
 			a := vm.pop()
+			if runtime.IsNil(a) || runtime.IsNil(b) {
+				vm.push(false)
+				break
+			}
 			vm.push(strings.HasSuffix(a.(string), b.(string)))
 
 		case OpSlice:

From cae6003b4797768f5a18001bdccfa47aaeaeb6a4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 17 May 2024 21:40:50 +0200
Subject: [PATCH 333/506] Fix build for 386 and add build.yml workflow

---
 .github/workflows/build.yml | 23 +++++++++++++++++++++++
 compiler/compiler.go        |  6 ++----
 2 files changed, 25 insertions(+), 4 deletions(-)
 create mode 100644 .github/workflows/build.yml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 000000000..d2e6518ca
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,23 @@
+name: build
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-versions: [ '1.18', '1.22' ]
+        go-arch: [ '386' ]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Go ${{ matrix.go-version }}
+        uses: actions/setup-go@v4
+        with:
+          go-version: ${{ matrix.go-version }}
+      - name: Build
+        run: GOARCH=${{ matrix.go-arch }} go build
diff --git a/compiler/compiler.go b/compiler/compiler.go
index c04611bdc..457088d3f 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -345,9 +345,7 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) {
 		}
 		c.emitPush(int32(node.Value))
 	case reflect.Int64:
-		if node.Value > math.MaxInt64 || node.Value < math.MinInt64 {
-			panic(fmt.Sprintf("constant %d overflows int64", node.Value))
-		}
+		panic(fmt.Sprintf("constant %d overflows int64", node.Value))
 		c.emitPush(int64(node.Value))
 	case reflect.Uint:
 		if node.Value < 0 {
@@ -365,7 +363,7 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) {
 		}
 		c.emitPush(uint16(node.Value))
 	case reflect.Uint32:
-		if node.Value > math.MaxUint32 || node.Value < 0 {
+		if node.Value < 0 {
 			panic(fmt.Sprintf("constant %d overflows uint32", node.Value))
 		}
 		c.emitPush(uint32(node.Value))

From 65c7bc95ced83953d330b4b8da6762ff4d2d4185 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 18 May 2024 23:13:58 +0200
Subject: [PATCH 334/506] Add checker.ParseCheck func

---
 checker/checker.go | 39 +++++++++++++++++++++++++++++++++++++++
 expr.go            | 29 +----------------------------
 2 files changed, 40 insertions(+), 28 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 314cb65b2..5e20e5e89 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -13,6 +13,45 @@ import (
 	"github.com/expr-lang/expr/parser"
 )
 
+// ParseCheck parses input expression and checks its types. Also, it applies
+// all provided patchers. In case of error, it returns error with a tree.
+func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) {
+	tree, err := parser.ParseWithConfig(input, config)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(config.Visitors) > 0 {
+		for i := 0; i < 1000; i++ {
+			more := false
+			for _, v := range config.Visitors {
+				// We need to perform types check, because some visitors may rely on
+				// types information available in the tree.
+				_, _ = Check(tree, config)
+
+				ast.Walk(&tree.Node, v)
+
+				if v, ok := v.(interface {
+					ShouldRepeat() bool
+				}); ok {
+					more = more || v.ShouldRepeat()
+				}
+			}
+			if !more {
+				break
+			}
+		}
+	}
+	_, err = Check(tree, config)
+	if err != nil {
+		return tree, err
+	}
+
+	return tree, nil
+}
+
+// Check checks types of the expression tree. It returns type of the expression
+// and error if any. If config is nil, then default configuration will be used.
 func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
 	if config == nil {
 		config = conf.New(nil)
diff --git a/expr.go b/expr.go
index 83e0a167e..8c619e1c4 100644
--- a/expr.go
+++ b/expr.go
@@ -13,7 +13,6 @@ import (
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/optimizer"
-	"github.com/expr-lang/expr/parser"
 	"github.com/expr-lang/expr/patcher"
 	"github.com/expr-lang/expr/vm"
 )
@@ -206,33 +205,7 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 	}
 	config.Check()
 
-	tree, err := parser.ParseWithConfig(input, config)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(config.Visitors) > 0 {
-		for i := 0; i < 1000; i++ {
-			more := false
-			for _, v := range config.Visitors {
-				// We need to perform types check, because some visitors may rely on
-				// types information available in the tree.
-				_, _ = checker.Check(tree, config)
-
-				ast.Walk(&tree.Node, v)
-
-				if v, ok := v.(interface {
-					ShouldRepeat() bool
-				}); ok {
-					more = more || v.ShouldRepeat()
-				}
-			}
-			if !more {
-				break
-			}
-		}
-	}
-	_, err = checker.Check(tree, config)
+	tree, err := checker.ParseCheck(input, config)
 	if err != nil {
 		return nil, err
 	}

From c6c72273c963b594f2e164c17e83f230fed2e3a1 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 18 May 2024 23:41:49 +0200
Subject: [PATCH 335/506] Return tree on parse errors

---
 ast/visitor.go     |  3 +++
 checker/checker.go |  2 +-
 parser/parser.go   | 12 +++++++-----
 3 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/ast/visitor.go b/ast/visitor.go
index 287a75589..90bc9f1d0 100644
--- a/ast/visitor.go
+++ b/ast/visitor.go
@@ -7,6 +7,9 @@ type Visitor interface {
 }
 
 func Walk(node *Node, v Visitor) {
+	if *node == nil {
+		return
+	}
 	switch n := (*node).(type) {
 	case *NilNode:
 	case *IdentifierNode:
diff --git a/checker/checker.go b/checker/checker.go
index 5e20e5e89..a2c86c208 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -18,7 +18,7 @@ import (
 func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) {
 	tree, err := parser.ParseWithConfig(input, config)
 	if err != nil {
-		return nil, err
+		return tree, err
 	}
 
 	if len(config.Visitors) > 0 {
diff --git a/parser/parser.go b/parser/parser.go
index fd1b3c043..77b2a700a 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -84,14 +84,16 @@ func ParseWithConfig(input string, config *conf.Config) (*Tree, error) {
 		p.error("unexpected token %v", p.current)
 	}
 
+	tree := &Tree{
+		Node:   node,
+		Source: source,
+	}
+
 	if p.err != nil {
-		return nil, p.err.Bind(source)
+		return tree, p.err.Bind(source)
 	}
 
-	return &Tree{
-		Node:   node,
-		Source: source,
-	}, nil
+	return tree, nil
 }
 
 func (p *parser) error(format string, args ...any) {

From 596f54f26256d389a380968bef0d6ba67b0e004f Mon Sep 17 00:00:00 2001
From: Ganesan Karuppasamy <kbganesan87@gmail.com>
Date: Tue, 21 May 2024 14:40:48 +0530
Subject: [PATCH 336/506] Invoke the Deref function as needed for the function
 arguments. (#651)

---
 checker/checker.go       |  2 +-
 compiler/compiler.go     | 48 +++++++++++++++++++++++-----
 test/deref/deref_test.go | 67 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 109 insertions(+), 8 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index a2c86c208..c71a98f07 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -1044,7 +1044,7 @@ func (v *checker) checkArguments(
 			continue
 		}
 
-		if !t.AssignableTo(in) && kind(t) != reflect.Interface {
+		if !(t.AssignableTo(in) || deref.Type(t).AssignableTo(in)) && kind(t) != reflect.Interface {
 			return anyType, &file.Error{
 				Location: arg.Location(),
 				Message:  fmt.Sprintf("cannot use %v as argument (type %v) to call %v ", t, in, name),
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 457088d3f..205d60234 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -592,8 +592,8 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 }
 
 func (c *compiler) equalBinaryNode(node *ast.BinaryNode) {
-	l := kind(node.Left)
-	r := kind(node.Right)
+	l := kind(node.Left.Type())
+	r := kind(node.Right.Type())
 
 	leftIsSimple := isSimpleType(node.Left)
 	rightIsSimple := isSimpleType(node.Right)
@@ -727,9 +727,44 @@ func (c *compiler) SliceNode(node *ast.SliceNode) {
 }
 
 func (c *compiler) CallNode(node *ast.CallNode) {
-	for _, arg := range node.Arguments {
-		c.compile(arg)
+	fn := node.Callee.Type()
+	if kind(fn) == reflect.Func {
+		fnInOffset := 0
+		fnNumIn := fn.NumIn()
+		switch callee := node.Callee.(type) {
+		case *ast.MemberNode:
+			if prop, ok := callee.Property.(*ast.StringNode); ok {
+				if _, ok = callee.Node.Type().MethodByName(prop.Value); ok && callee.Node.Type().Kind() != reflect.Interface {
+					fnInOffset = 1
+					fnNumIn--
+				}
+			}
+		case *ast.IdentifierNode:
+			if t, ok := c.config.Types[callee.Value]; ok && t.Method {
+				fnInOffset = 1
+				fnNumIn--
+			}
+		}
+		for i, arg := range node.Arguments {
+			c.compile(arg)
+			if k := kind(arg.Type()); k == reflect.Ptr || k == reflect.Interface {
+				var in reflect.Type
+				if fn.IsVariadic() && i >= fnNumIn-1 {
+					in = fn.In(fn.NumIn() - 1).Elem()
+				} else {
+					in = fn.In(i + fnInOffset)
+				}
+				if k = kind(in); k != reflect.Ptr && k != reflect.Interface {
+					c.emit(OpDeref)
+				}
+			}
+		}
+	} else {
+		for _, arg := range node.Arguments {
+			c.compile(arg)
+		}
 	}
+
 	if ident, ok := node.Callee.(*ast.IdentifierNode); ok {
 		if c.config != nil {
 			if fn, ok := c.config.Functions[ident.Value]; ok {
@@ -1162,7 +1197,7 @@ func (c *compiler) PairNode(node *ast.PairNode) {
 }
 
 func (c *compiler) derefInNeeded(node ast.Node) {
-	switch kind(node) {
+	switch kind(node.Type()) {
 	case reflect.Ptr, reflect.Interface:
 		c.emit(OpDeref)
 	}
@@ -1181,8 +1216,7 @@ func (c *compiler) optimize() {
 	}
 }
 
-func kind(node ast.Node) reflect.Kind {
-	t := node.Type()
+func kind(t reflect.Type) reflect.Kind {
 	if t == nil {
 		return reflect.Invalid
 	}
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 0b228ca16..4bfb76168 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -3,6 +3,7 @@ package deref_test
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/expr-lang/expr/internal/testify/assert"
 	"github.com/expr-lang/expr/internal/testify/require"
@@ -253,3 +254,69 @@ func TestDeref_fetch_from_interface_mix_pointer(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, "waldo", res)
 }
+
+func TestDeref_func_args(t *testing.T) {
+	i := 20
+	env := map[string]any{
+		"var": &i,
+		"fn": func(p int) int {
+			return p + 1
+		},
+	}
+
+	program, err := expr.Compile(`fn(var) + fn(var + 0)`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 42, out)
+}
+
+func TestDeref_struct_func_args(t *testing.T) {
+	n, _ := time.Parse(time.RFC3339, "2024-05-12T18:30:00+00:00")
+	duration := 30 * time.Minute
+	env := map[string]any{
+		"time":     n,
+		"duration": &duration,
+	}
+
+	program, err := expr.Compile(`time.Add(duration).Format('2006-01-02T15:04:05Z07:00')`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, "2024-05-12T19:00:00Z", out)
+}
+
+func TestDeref_ignore_func_args(t *testing.T) {
+	f := foo(1)
+	env := map[string]any{
+		"foo": &f,
+		"fn": func(f *foo) int {
+			return f.Bar()
+		},
+	}
+
+	program, err := expr.Compile(`fn(foo)`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 42, out)
+}
+
+func TestDeref_ignore_struct_func_args(t *testing.T) {
+	n := time.Now()
+	location, _ := time.LoadLocation("UTC")
+	env := map[string]any{
+		"time":     n,
+		"location": location,
+	}
+
+	program, err := expr.Compile(`time.In(location).Location().String()`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, "UTC", out)
+}

From b45ee4ff8901ec41aa12b3e6eb9f06d91a95ce6d Mon Sep 17 00:00:00 2001
From: Ernest Micklei <ernest.micklei@gmail.com>
Date: Fri, 24 May 2024 10:12:54 +0200
Subject: [PATCH 337/506] =?UTF-8?q?Add=20Melr=C5=8Dse=20to=20"Who=20uses?=
 =?UTF-8?q?=20Expr=3F"=20section?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 5a587162c..6c56c67b6 100644
--- a/README.md
+++ b/README.md
@@ -164,6 +164,7 @@ func main() {
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
 * [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products.
 * [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery.
+* [Melrōse](https://melrōse.org) uses Expr to implement its music programming language.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From eca9bd7adefbe01fc0e8b7af25b4a971ba666b76 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 27 May 2024 12:05:19 +0200
Subject: [PATCH 338/506] Fix function calls with int64 params (#663)

Fixes #661
---
 compiler/compiler.go      |  1 -
 compiler/compiler_test.go | 22 +++++++++++++++++++++
 test/mock/mock.go         | 40 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 205d60234..720f6a265 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -345,7 +345,6 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) {
 		}
 		c.emitPush(int32(node.Value))
 	case reflect.Int64:
-		panic(fmt.Sprintf("constant %d overflows int64", node.Value))
 		c.emitPush(int64(node.Value))
 	case reflect.Uint:
 		if node.Value < 0 {
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index eb7f3d323..ba5d6dc54 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -628,3 +628,25 @@ func TestCompile_optimizes_jumps(t *testing.T) {
 		})
 	}
 }
+
+func TestCompile_IntegerArgsFunc(t *testing.T) {
+	env := mock.Env{}
+	tests := []struct{ code string }{
+		{"FuncInt(0)"},
+		{"FuncInt8(0)"},
+		{"FuncInt16(0)"},
+		{"FuncInt32(0)"},
+		{"FuncInt64(0)"},
+		{"FuncUint(0)"},
+		{"FuncUint8(0)"},
+		{"FuncUint16(0)"},
+		{"FuncUint32(0)"},
+		{"FuncUint64(0)"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			_, err := expr.Compile(tt.code, expr.Env(env))
+			require.NoError(t, err)
+		})
+	}
+}
diff --git a/test/mock/mock.go b/test/mock/mock.go
index 5c0fa9e3f..fc91652fb 100644
--- a/test/mock/mock.go
+++ b/test/mock/mock.go
@@ -65,6 +65,46 @@ func (p Env) FuncTyped(_ string) int {
 	return 2023
 }
 
+func (p Env) FuncInt(_ int) int {
+	return 0
+}
+
+func (p Env) FuncUint(_ uint) int {
+	return 0
+}
+
+func (p Env) FuncInt8(_ float64) int {
+	return 0
+}
+
+func (p Env) FuncInt16(_ int16) int {
+	return 0
+}
+
+func (p Env) FuncInt32(_ int32) int {
+	return 0
+}
+
+func (p Env) FuncInt64(_ int64) int {
+	return 0
+}
+
+func (p Env) FuncUint8(_ uint8) int {
+	return 0
+}
+
+func (p Env) FuncUint16(_ uint16) int {
+	return 0
+}
+
+func (p Env) FuncUint32(_ uint32) int {
+	return 0
+}
+
+func (p Env) FuncUint64(_ uint64) int {
+	return 0
+}
+
 func (p Env) TimeEqualString(a time.Time, s string) bool {
 	return a.Format("2006-01-02") == s
 }

From 55ff9aad94a176a11f9f9f333e7ed9f59ec5e37f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 27 May 2024 12:25:09 +0200
Subject: [PATCH 339/506] Fix coverage reporting

---
 .github/scripts/coverage.mjs | 9 +++++++--
 .github/workflows/check.yml  | 6 +++---
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs
index 330d8d873..c00242894 100755
--- a/.github/scripts/coverage.mjs
+++ b/.github/scripts/coverage.mjs
@@ -1,4 +1,4 @@
-#!/usr/bin/env zx --experimental
+#!/usr/bin/env zx
 
 const expected = 90
 const exclude = [
@@ -6,6 +6,9 @@ const exclude = [
   'checker/mock',
   'vm/func_types',
   'vm/runtime/helpers',
+  'internal/difflib',
+  'internal/spew',
+  'internal/testify',
 ]
 
 cd(path.resolve(__dirname, '..', '..'))
@@ -24,9 +27,11 @@ await spinner('Running tests', async () => {
   await $`go tool cover -html=coverage.out -o coverage.html`
 })
 
-const cover = await $`go tool cover -func=coverage.out`
+const cover = await $({verbose: true})`go tool cover -func=coverage.out`
 const total = +cover.stdout.match(/total:\s+\(statements\)\s+(\d+\.\d+)%/)[1]
 if (total < expected) {
   echo(chalk.red(`Coverage is too low: ${total}% < ${expected}% (expected)`))
   process.exit(1)
+} else {
+  echo(`Coverage is good: ${chalk.green(total + '%')} >= ${expected}% (expected)`)
 }
diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 63037cd61..674e07c7a 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -11,9 +11,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - name: Setup Go 1.18
+      - name: Setup Go 1.12
         uses: actions/setup-go@v4
         with:
-          go-version: 1.18
+          go-version: 1.12
       - name: Test
-        run: npx zx --experimental .github/scripts/coverage.mjs
+        run: npx zx .github/scripts/coverage.mjs

From a601192193a639ddc7789c0ad6fb4e929e23f8fd Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 27 May 2024 12:28:18 +0200
Subject: [PATCH 340/506] Fix check.yml

---
 .github/workflows/check.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 674e07c7a..fb4b102ec 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -11,9 +11,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - name: Setup Go 1.12
+      - name: Setup Go 1.18
         uses: actions/setup-go@v4
         with:
-          go-version: 1.12
+          go-version: 1.18
       - name: Test
         run: npx zx .github/scripts/coverage.mjs

From 7e6e6f576031e19c1b41a4258afdb7610a9c021f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 30 May 2024 21:45:13 +0200
Subject: [PATCH 341/506] Improve compilation for detached tree parts

---
 compiler/compiler.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 720f6a265..29a6d4cdc 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -403,6 +403,10 @@ func (c *compiler) StringNode(node *ast.StringNode) {
 }
 
 func (c *compiler) ConstantNode(node *ast.ConstantNode) {
+	if node.Value == nil {
+		c.emit(OpNil)
+		return
+	}
 	c.emitPush(node.Value)
 }
 
@@ -695,7 +699,9 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 	}
 
 	c.compile(base)
-	if node.Optional {
+	// If the field is optional, we need to jump over the fetch operation.
+	// If no ChainNode (none c.chains) is used, do not compile the optional fetch.
+	if node.Optional && len(c.chains) > 0 {
 		ph := c.emit(OpJumpIfNil, placeholder)
 		c.chains[len(c.chains)-1] = append(c.chains[len(c.chains)-1], ph)
 	}

From 73cb42d2d97f1efd524aae7263e2835024634c45 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 1 Jun 2024 00:09:22 +0200
Subject: [PATCH 342/506] Refactor checker to use Nature (#665)

This PR introduces a new concept inside Expr's type checker - Nature.

It's an abstraction other reflect.Type which carries additional information about possible type, methods and builtin function.

I was able to find and fix a few bugs in type checker and optimizer. Implementation of nature concept has proven itself. As well nature will allow to bring more feature for type checker in future.

Why Nature? I was looking for a name to replace Type. Type name already carries much information, as well can be confused with reflect.Type. Nature name should be understood as "nature of the node", same as "type of the node".
---
 ast/node.go                         |  38 +-
 builtin/builtin_test.go             |   2 +-
 checker/checker.go                  | 779 ++++++++++++++--------------
 checker/checker_test.go             | 474 ++++++++++-------
 checker/info.go                     |  11 +-
 checker/nature/nature.go            | 142 +++++
 checker/nature/types.go             |  13 +
 checker/types.go                    | 234 ++++-----
 compiler/compiler.go                |  11 +-
 compiler/compiler_test.go           |  73 +--
 expr_test.go                        |   8 -
 optimizer/const_expr.go             |   8 +-
 optimizer/filter_first.go           |   4 +-
 optimizer/filter_last.go            |   4 +-
 optimizer/filter_len.go             |   2 +-
 optimizer/filter_map.go             |   2 +-
 optimizer/fold.go                   |  88 ++--
 optimizer/fold_test.go              |  82 +++
 optimizer/in_array.go               |  12 +-
 optimizer/in_range.go               |   2 +-
 optimizer/optimizer.go              |  36 ++
 optimizer/optimizer_test.go         |  41 --
 optimizer/predicate_combination.go  |   2 +-
 optimizer/sum_array.go              |   2 +-
 optimizer/sum_map.go                |   2 +-
 test/fuzz/fuzz_corpus.txt           |  11 -
 test/fuzz/fuzz_expr_seed_corpus.zip | Bin 2827397 -> 2827225 bytes
 testdata/examples.txt               |  36 --
 28 files changed, 1218 insertions(+), 901 deletions(-)
 create mode 100644 checker/nature/nature.go
 create mode 100644 checker/nature/types.go
 create mode 100644 optimizer/fold_test.go

diff --git a/ast/node.go b/ast/node.go
index 03e8cf622..191ab1886 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -3,13 +3,21 @@ package ast
 import (
 	"reflect"
 
+	"github.com/expr-lang/expr/checker/nature"
 	"github.com/expr-lang/expr/file"
 )
 
+var (
+	anyType = reflect.TypeOf(new(any)).Elem()
+)
+
 // Node represents items of abstract syntax tree.
 type Node interface {
 	Location() file.Location
 	SetLocation(file.Location)
+	Nature() nature.Nature
+	SetNature(nature.Nature)
+	Kind() reflect.Kind
 	Type() reflect.Type
 	SetType(reflect.Type)
 	String() string
@@ -25,8 +33,8 @@ func Patch(node *Node, newNode Node) {
 
 // base is a base struct for all nodes.
 type base struct {
-	loc      file.Location
-	nodeType reflect.Type
+	loc    file.Location
+	nature nature.Nature
 }
 
 // Location returns the location of the node in the source code.
@@ -39,14 +47,36 @@ func (n *base) SetLocation(loc file.Location) {
 	n.loc = loc
 }
 
+// Nature returns the nature of the node.
+func (n *base) Nature() nature.Nature {
+	return n.nature
+}
+
+// SetNature sets the nature of the node.
+func (n *base) SetNature(nature nature.Nature) {
+	n.nature = nature
+}
+
+// Kind returns the kind of the node.
+// If the type is nil (meaning unknown) then it returns reflect.Interface.
+func (n *base) Kind() reflect.Kind {
+	if n.nature.Type == nil {
+		return reflect.Interface
+	}
+	return n.nature.Type.Kind()
+}
+
 // Type returns the type of the node.
 func (n *base) Type() reflect.Type {
-	return n.nodeType
+	if n.nature.Type == nil {
+		return anyType
+	}
+	return n.nature.Type
 }
 
 // SetType sets the type of the node.
 func (n *base) SetType(t reflect.Type) {
-	n.nodeType = t
+	n.nature.Type = t
 }
 
 // NilNode represents nil.
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index b99ed42ce..97f249896 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -235,7 +235,7 @@ func TestBuiltin_errors(t *testing.T) {
 		{`bitushr(-5, -2)`, "invalid operation: negative shift count -2 (type int) (1:1)"},
 		{`now(nil)`, "invalid number of arguments (expected 0, got 1)"},
 		{`date(nil)`, "interface {} is nil, not string (1:1)"},
-		{`timezone(nil)`, "interface {} is nil, not string (1:1)"},
+		{`timezone(nil)`, "cannot use nil as argument (type string) to call timezone (1:10)"},
 	}
 	for _, test := range errorTests {
 		t.Run(test.input, func(t *testing.T) {
diff --git a/checker/checker.go b/checker/checker.go
index c71a98f07..fae8f5a16 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -7,9 +7,9 @@ import (
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
+	. "github.com/expr-lang/expr/checker/nature"
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
-	"github.com/expr-lang/expr/internal/deref"
 	"github.com/expr-lang/expr/parser"
 )
 
@@ -52,14 +52,20 @@ func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) {
 
 // Check checks types of the expression tree. It returns type of the expression
 // and error if any. If config is nil, then default configuration will be used.
-func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
+func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) {
 	if config == nil {
 		config = conf.New(nil)
 	}
 
 	v := &checker{config: config}
 
-	t, _ = v.visit(tree.Node)
+	nt := v.visit(tree.Node)
+
+	// To keep compatibility with previous versions, we should return any, if nature is unknown.
+	t := nt.Type
+	if t == nil {
+		t = anyType
+	}
 
 	if v.err != nil {
 		return t, v.err.Bind(tree.Source)
@@ -67,23 +73,20 @@ func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
 
 	if v.config.Expect != reflect.Invalid {
 		if v.config.ExpectAny {
-			if isAny(t) {
+			if isUnknown(nt) {
 				return t, nil
 			}
 		}
 
 		switch v.config.Expect {
 		case reflect.Int, reflect.Int64, reflect.Float64:
-			if !isNumber(t) {
-				return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, t)
+			if !isNumber(nt) {
+				return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, nt)
 			}
 		default:
-			if t != nil {
-				if t.Kind() == v.config.Expect {
-					return t, nil
-				}
+			if nt.Kind() != v.config.Expect {
+				return nil, fmt.Errorf("expected %v, but got %s", v.config.Expect, nt)
 			}
-			return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, t)
 		}
 	}
 
@@ -98,14 +101,13 @@ type checker struct {
 }
 
 type predicateScope struct {
-	vtype reflect.Type
-	vars  map[string]reflect.Type
+	collection Nature
+	vars       map[string]Nature
 }
 
 type varScope struct {
-	name  string
-	vtype reflect.Type
-	info  info
+	name   string
+	nature Nature
 }
 
 type info struct {
@@ -119,285 +121,278 @@ type info struct {
 	elem reflect.Type
 }
 
-func (v *checker) visit(node ast.Node) (reflect.Type, info) {
-	var t reflect.Type
-	var i info
+func (v *checker) visit(node ast.Node) Nature {
+	var nt Nature
 	switch n := node.(type) {
 	case *ast.NilNode:
-		t, i = v.NilNode(n)
+		nt = v.NilNode(n)
 	case *ast.IdentifierNode:
-		t, i = v.IdentifierNode(n)
+		nt = v.IdentifierNode(n)
 	case *ast.IntegerNode:
-		t, i = v.IntegerNode(n)
+		nt = v.IntegerNode(n)
 	case *ast.FloatNode:
-		t, i = v.FloatNode(n)
+		nt = v.FloatNode(n)
 	case *ast.BoolNode:
-		t, i = v.BoolNode(n)
+		nt = v.BoolNode(n)
 	case *ast.StringNode:
-		t, i = v.StringNode(n)
+		nt = v.StringNode(n)
 	case *ast.ConstantNode:
-		t, i = v.ConstantNode(n)
+		nt = v.ConstantNode(n)
 	case *ast.UnaryNode:
-		t, i = v.UnaryNode(n)
+		nt = v.UnaryNode(n)
 	case *ast.BinaryNode:
-		t, i = v.BinaryNode(n)
+		nt = v.BinaryNode(n)
 	case *ast.ChainNode:
-		t, i = v.ChainNode(n)
+		nt = v.ChainNode(n)
 	case *ast.MemberNode:
-		t, i = v.MemberNode(n)
+		nt = v.MemberNode(n)
 	case *ast.SliceNode:
-		t, i = v.SliceNode(n)
+		nt = v.SliceNode(n)
 	case *ast.CallNode:
-		t, i = v.CallNode(n)
+		nt = v.CallNode(n)
 	case *ast.BuiltinNode:
-		t, i = v.BuiltinNode(n)
+		nt = v.BuiltinNode(n)
 	case *ast.ClosureNode:
-		t, i = v.ClosureNode(n)
+		nt = v.ClosureNode(n)
 	case *ast.PointerNode:
-		t, i = v.PointerNode(n)
+		nt = v.PointerNode(n)
 	case *ast.VariableDeclaratorNode:
-		t, i = v.VariableDeclaratorNode(n)
+		nt = v.VariableDeclaratorNode(n)
 	case *ast.ConditionalNode:
-		t, i = v.ConditionalNode(n)
+		nt = v.ConditionalNode(n)
 	case *ast.ArrayNode:
-		t, i = v.ArrayNode(n)
+		nt = v.ArrayNode(n)
 	case *ast.MapNode:
-		t, i = v.MapNode(n)
+		nt = v.MapNode(n)
 	case *ast.PairNode:
-		t, i = v.PairNode(n)
+		nt = v.PairNode(n)
 	default:
 		panic(fmt.Sprintf("undefined node type (%T)", node))
 	}
-	node.SetType(t)
-	return t, i
+	node.SetNature(nt)
+	return nt
 }
 
-func (v *checker) error(node ast.Node, format string, args ...any) (reflect.Type, info) {
+func (v *checker) error(node ast.Node, format string, args ...any) Nature {
 	if v.err == nil { // show first error
 		v.err = &file.Error{
 			Location: node.Location(),
 			Message:  fmt.Sprintf(format, args...),
 		}
 	}
-	return anyType, info{} // interface represent undefined type
+	return unknown
 }
 
-func (v *checker) NilNode(*ast.NilNode) (reflect.Type, info) {
-	return nilType, info{}
+func (v *checker) NilNode(*ast.NilNode) Nature {
+	return nilNature
 }
 
-func (v *checker) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info) {
-	if s, ok := v.lookupVariable(node.Value); ok {
-		return s.vtype, s.info
+func (v *checker) IdentifierNode(node *ast.IdentifierNode) Nature {
+	if variable, ok := v.lookupVariable(node.Value); ok {
+		return variable.nature
 	}
 	if node.Value == "$env" {
-		return mapType, info{}
+		return unknown
 	}
 	return v.ident(node, node.Value, true, true)
 }
 
 // ident method returns type of environment variable, builtin or function.
-func (v *checker) ident(node ast.Node, name string, strict, builtins bool) (reflect.Type, info) {
+func (v *checker) ident(node ast.Node, name string, strict, builtins bool) Nature {
 	if t, ok := v.config.Types[name]; ok {
 		if t.Ambiguous {
 			return v.error(node, "ambiguous identifier %v", name)
 		}
-		return t.Type, info{method: t.Method}
+		if t.Type == nil {
+			return nilNature
+		}
+		return Nature{Type: t.Type, Method: t.Method}
 	}
 	if builtins {
 		if fn, ok := v.config.Functions[name]; ok {
-			return fn.Type(), info{fn: fn}
+			return Nature{Type: fn.Type(), Func: fn}
 		}
 		if fn, ok := v.config.Builtins[name]; ok {
-			return fn.Type(), info{fn: fn}
+			return Nature{Type: fn.Type(), Func: fn}
 		}
 	}
 	if v.config.Strict && strict {
 		return v.error(node, "unknown name %v", name)
 	}
 	if v.config.DefaultType != nil {
-		return v.config.DefaultType, info{}
+		return Nature{Type: v.config.DefaultType}
 	}
-	return anyType, info{}
+	return unknown
 }
 
-func (v *checker) IntegerNode(*ast.IntegerNode) (reflect.Type, info) {
-	return integerType, info{}
+func (v *checker) IntegerNode(*ast.IntegerNode) Nature {
+	return integerNature
 }
 
-func (v *checker) FloatNode(*ast.FloatNode) (reflect.Type, info) {
-	return floatType, info{}
+func (v *checker) FloatNode(*ast.FloatNode) Nature {
+	return floatNature
 }
 
-func (v *checker) BoolNode(*ast.BoolNode) (reflect.Type, info) {
-	return boolType, info{}
+func (v *checker) BoolNode(*ast.BoolNode) Nature {
+	return boolNature
 }
 
-func (v *checker) StringNode(*ast.StringNode) (reflect.Type, info) {
-	return stringType, info{}
+func (v *checker) StringNode(*ast.StringNode) Nature {
+	return stringNature
 }
 
-func (v *checker) ConstantNode(node *ast.ConstantNode) (reflect.Type, info) {
-	return reflect.TypeOf(node.Value), info{}
+func (v *checker) ConstantNode(node *ast.ConstantNode) Nature {
+	return Nature{Type: reflect.TypeOf(node.Value)}
 }
 
-func (v *checker) UnaryNode(node *ast.UnaryNode) (reflect.Type, info) {
-	t, _ := v.visit(node.Node)
-	t = deref.Type(t)
+func (v *checker) UnaryNode(node *ast.UnaryNode) Nature {
+	nt := v.visit(node.Node)
+	nt = nt.Deref()
 
 	switch node.Operator {
 
 	case "!", "not":
-		if isBool(t) {
-			return boolType, info{}
+		if isBool(nt) {
+			return boolNature
 		}
-		if isAny(t) {
-			return boolType, info{}
+		if isUnknown(nt) {
+			return boolNature
 		}
 
 	case "+", "-":
-		if isNumber(t) {
-			return t, info{}
+		if isNumber(nt) {
+			return nt
 		}
-		if isAny(t) {
-			return anyType, info{}
+		if isUnknown(nt) {
+			return unknown
 		}
 
 	default:
 		return v.error(node, "unknown operator (%v)", node.Operator)
 	}
 
-	return v.error(node, `invalid operation: %v (mismatched type %v)`, node.Operator, t)
+	return v.error(node, `invalid operation: %v (mismatched type %s)`, node.Operator, nt)
 }
 
-func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
-	l, _ := v.visit(node.Left)
-	r, ri := v.visit(node.Right)
+func (v *checker) BinaryNode(node *ast.BinaryNode) Nature {
+	l := v.visit(node.Left)
+	r := v.visit(node.Right)
 
-	l = deref.Type(l)
-	r = deref.Type(r)
+	l = l.Deref()
+	r = r.Deref()
 
 	switch node.Operator {
 	case "==", "!=":
 		if isComparable(l, r) {
-			return boolType, info{}
+			return boolNature
 		}
 
 	case "or", "||", "and", "&&":
 		if isBool(l) && isBool(r) {
-			return boolType, info{}
+			return boolNature
 		}
 		if or(l, r, isBool) {
-			return boolType, info{}
+			return boolNature
 		}
 
 	case "<", ">", ">=", "<=":
 		if isNumber(l) && isNumber(r) {
-			return boolType, info{}
+			return boolNature
 		}
 		if isString(l) && isString(r) {
-			return boolType, info{}
+			return boolNature
 		}
 		if isTime(l) && isTime(r) {
-			return boolType, info{}
+			return boolNature
 		}
 		if or(l, r, isNumber, isString, isTime) {
-			return boolType, info{}
+			return boolNature
 		}
 
 	case "-":
 		if isNumber(l) && isNumber(r) {
-			return combined(l, r), info{}
+			return combined(l, r)
 		}
 		if isTime(l) && isTime(r) {
-			return durationType, info{}
+			return durationNature
 		}
 		if isTime(l) && isDuration(r) {
-			return timeType, info{}
+			return timeNature
 		}
-		if or(l, r, isNumber, isTime) {
-			return anyType, info{}
+		if or(l, r, isNumber, isTime, isDuration) {
+			return unknown
 		}
 
 	case "*":
 		if isNumber(l) && isNumber(r) {
-			return combined(l, r), info{}
+			return combined(l, r)
 		}
 		if or(l, r, isNumber) {
-			return anyType, info{}
+			return unknown
 		}
 
 	case "/":
 		if isNumber(l) && isNumber(r) {
-			return floatType, info{}
+			return floatNature
 		}
 		if or(l, r, isNumber) {
-			return floatType, info{}
+			return floatNature
 		}
 
 	case "**", "^":
 		if isNumber(l) && isNumber(r) {
-			return floatType, info{}
+			return floatNature
 		}
 		if or(l, r, isNumber) {
-			return floatType, info{}
+			return floatNature
 		}
 
 	case "%":
 		if isInteger(l) && isInteger(r) {
-			return combined(l, r), info{}
+			return integerNature
 		}
 		if or(l, r, isInteger) {
-			return anyType, info{}
+			return integerNature
 		}
 
 	case "+":
 		if isNumber(l) && isNumber(r) {
-			return combined(l, r), info{}
+			return combined(l, r)
 		}
 		if isString(l) && isString(r) {
-			return stringType, info{}
+			return stringNature
 		}
 		if isTime(l) && isDuration(r) {
-			return timeType, info{}
+			return timeNature
 		}
 		if isDuration(l) && isTime(r) {
-			return timeType, info{}
+			return timeNature
 		}
 		if or(l, r, isNumber, isString, isTime, isDuration) {
-			return anyType, info{}
+			return unknown
 		}
 
 	case "in":
-		if (isString(l) || isAny(l)) && isStruct(r) {
-			return boolType, info{}
+		if (isString(l) || isUnknown(l)) && isStruct(r) {
+			return boolNature
 		}
 		if isMap(r) {
-			if l == nil { // It is possible to compare with nil.
-				return boolType, info{}
-			}
-			if !isAny(l) && !l.AssignableTo(r.Key()) {
+			if !isUnknown(l) && !l.AssignableTo(r.Key()) {
 				return v.error(node, "cannot use %v as type %v in map key", l, r.Key())
 			}
-			return boolType, info{}
+			return boolNature
 		}
 		if isArray(r) {
-			if l == nil { // It is possible to compare with nil.
-				return boolType, info{}
-			}
 			if !isComparable(l, r.Elem()) {
 				return v.error(node, "cannot use %v as type %v in array", l, r.Elem())
 			}
-			if !isComparable(l, ri.elem) {
-				return v.error(node, "cannot use %v as type %v in array", l, ri.elem)
-			}
-			return boolType, info{}
+			return boolNature
 		}
-		if isAny(l) && anyOf(r, isString, isArray, isMap) {
-			return boolType, info{}
+		if isUnknown(l) && anyOf(r, isString, isArray, isMap) {
+			return boolNature
 		}
-		if isAny(r) {
-			return boolType, info{}
+		if isUnknown(r) {
+			return boolNature
 		}
 
 	case "matches":
@@ -408,43 +403,48 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 			}
 		}
 		if isString(l) && isString(r) {
-			return boolType, info{}
+			return boolNature
 		}
 		if or(l, r, isString) {
-			return boolType, info{}
+			return boolNature
 		}
 
 	case "contains", "startsWith", "endsWith":
 		if isString(l) && isString(r) {
-			return boolType, info{}
+			return boolNature
 		}
 		if or(l, r, isString) {
-			return boolType, info{}
+			return boolNature
 		}
 
 	case "..":
-		ret := reflect.SliceOf(integerType)
 		if isInteger(l) && isInteger(r) {
-			return ret, info{}
+			return Nature{
+				Type:    arrayType,
+				SubType: Array{Of: integerNature},
+			}
 		}
 		if or(l, r, isInteger) {
-			return ret, info{}
+			return Nature{
+				Type:    arrayType,
+				SubType: Array{Of: integerNature},
+			}
 		}
 
 	case "??":
-		if l == nil && r != nil {
-			return r, info{}
+		if isNil(l) && !isNil(r) {
+			return r
 		}
-		if l != nil && r == nil {
-			return l, info{}
+		if !isNil(l) && isNil(r) {
+			return l
 		}
-		if l == nil && r == nil {
-			return nilType, info{}
+		if isNil(l) && isNil(r) {
+			return nilNature
 		}
 		if r.AssignableTo(l) {
-			return l, info{}
+			return l
 		}
-		return anyType, info{}
+		return unknown
 
 	default:
 		return v.error(node, "unknown operator (%v)", node.Operator)
@@ -454,11 +454,11 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) {
 	return v.error(node, `invalid operation: %v (mismatched types %v and %v)`, node.Operator, l, r)
 }
 
-func (v *checker) ChainNode(node *ast.ChainNode) (reflect.Type, info) {
+func (v *checker) ChainNode(node *ast.ChainNode) Nature {
 	return v.visit(node.Node)
 }
 
-func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
+func (v *checker) MemberNode(node *ast.MemberNode) Nature {
 	// $env variable
 	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "$env" {
 		if name, ok := node.Property.(*ast.StringNode); ok {
@@ -472,59 +472,48 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 			}
 			return v.ident(node, name.Value, strict, false /* no builtins and no functions */)
 		}
-		return anyType, info{}
+		return unknown
 	}
 
-	base, _ := v.visit(node.Node)
-	prop, _ := v.visit(node.Property)
+	base := v.visit(node.Node)
+	prop := v.visit(node.Property)
+
+	if isUnknown(base) {
+		return unknown
+	}
 
 	if name, ok := node.Property.(*ast.StringNode); ok {
-		if base == nil {
-			return v.error(node, "type %v has no field %v", base, name.Value)
+		if isNil(base) {
+			return v.error(node, "type nil has no field %v", name.Value)
 		}
+
 		// First, check methods defined on base type itself,
 		// independent of which type it is. Without dereferencing.
 		if m, ok := base.MethodByName(name.Value); ok {
-			if kind(base) == reflect.Interface {
-				// In case of interface type method will not have a receiver,
-				// and to prevent checker decreasing numbers of in arguments
-				// return method type as not method (second argument is false).
-
-				// Also, we can not use m.Index here, because it will be
-				// different indexes for different types which implement
-				// the same interface.
-				return m.Type, info{}
-			} else {
-				return m.Type, info{method: true}
-			}
+			return m
 		}
 	}
 
-	if kind(base) == reflect.Ptr {
-		base = base.Elem()
-	}
-
-	switch kind(base) {
-	case reflect.Interface:
-		return anyType, info{}
+	base = base.Deref()
 
+	switch base.Kind() {
 	case reflect.Map:
-		if prop != nil && !prop.AssignableTo(base.Key()) && !isAny(prop) {
+		if !prop.AssignableTo(base.Key()) && !isUnknown(prop) {
 			return v.error(node.Property, "cannot use %v to get an element from %v", prop, base)
 		}
-		return base.Elem(), info{}
+		return base.Elem()
 
 	case reflect.Array, reflect.Slice:
-		if !isInteger(prop) && !isAny(prop) {
+		if !isInteger(prop) && !isUnknown(prop) {
 			return v.error(node.Property, "array elements can only be selected using an integer (got %v)", prop)
 		}
-		return base.Elem(), info{}
+		return base.Elem()
 
 	case reflect.Struct:
 		if name, ok := node.Property.(*ast.StringNode); ok {
 			propertyName := name.Value
 			if field, ok := fetchField(base, propertyName); ok {
-				return field.Type, info{}
+				return Nature{Type: field.Type}
 			}
 			if node.Method {
 				return v.error(node, "type %v has no method %v", base, propertyName)
@@ -536,35 +525,39 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 	return v.error(node, "type %v[%v] is undefined", base, prop)
 }
 
-func (v *checker) SliceNode(node *ast.SliceNode) (reflect.Type, info) {
-	t, _ := v.visit(node.Node)
+func (v *checker) SliceNode(node *ast.SliceNode) Nature {
+	nt := v.visit(node.Node)
 
-	switch kind(t) {
-	case reflect.Interface:
-		// ok
+	if isUnknown(nt) {
+		return unknown
+	}
+
+	switch nt.Kind() {
 	case reflect.String, reflect.Array, reflect.Slice:
 		// ok
 	default:
-		return v.error(node, "cannot slice %v", t)
+		return v.error(node, "cannot slice %s", nt)
 	}
 
 	if node.From != nil {
-		from, _ := v.visit(node.From)
-		if !isInteger(from) && !isAny(from) {
+		from := v.visit(node.From)
+		if !isInteger(from) && !isUnknown(from) {
 			return v.error(node.From, "non-integer slice index %v", from)
 		}
 	}
+
 	if node.To != nil {
-		to, _ := v.visit(node.To)
-		if !isInteger(to) && !isAny(to) {
+		to := v.visit(node.To)
+		if !isInteger(to) && !isUnknown(to) {
 			return v.error(node.To, "non-integer slice index %v", to)
 		}
 	}
-	return t, info{}
+
+	return nt
 }
 
-func (v *checker) CallNode(node *ast.CallNode) (reflect.Type, info) {
-	t, i := v.functionReturnType(node)
+func (v *checker) CallNode(node *ast.CallNode) Nature {
+	nt := v.functionReturnType(node)
 
 	// Check if type was set on node (for example, by patcher)
 	// and use node type instead of function return type.
@@ -578,17 +571,17 @@ func (v *checker) CallNode(node *ast.CallNode) (reflect.Type, info) {
 	// checker pass we should replace anyType on method node
 	// with new correct function return type.
 	if node.Type() != nil && node.Type() != anyType {
-		return node.Type(), i
+		return node.Nature()
 	}
 
-	return t, i
+	return nt
 }
 
-func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) {
-	fn, fnInfo := v.visit(node.Callee)
+func (v *checker) functionReturnType(node *ast.CallNode) Nature {
+	nt := v.visit(node.Callee)
 
-	if fnInfo.fn != nil {
-		return v.checkFunction(fnInfo.fn, node, node.Arguments)
+	if nt.Func != nil {
+		return v.checkFunction(nt.Func, node, node.Arguments)
 	}
 
 	fnName := "function"
@@ -601,240 +594,248 @@ func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) {
 		}
 	}
 
-	if fn == nil {
+	if isUnknown(nt) {
+		return unknown
+	}
+
+	if isNil(nt) {
 		return v.error(node, "%v is nil; cannot call nil as function", fnName)
 	}
 
-	switch fn.Kind() {
-	case reflect.Interface:
-		return anyType, info{}
+	switch nt.Kind() {
 	case reflect.Func:
-		outType, err := v.checkArguments(fnName, fn, fnInfo.method, node.Arguments, node)
+		outType, err := v.checkArguments(fnName, nt, node.Arguments, node)
 		if err != nil {
 			if v.err == nil {
 				v.err = err
 			}
-			return anyType, info{}
+			return unknown
 		}
-		return outType, info{}
+		return outType
 	}
-	return v.error(node, "%v is not callable", fn)
+	return v.error(node, "%s is not callable", nt)
 }
 
-func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
+func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 	switch node.Name {
 	case "all", "none", "any", "one":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
 		v.begin(collection)
-		closure, _ := v.visit(node.Arguments[1])
+		closure := v.visit(node.Arguments[1])
 		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isAny(closure.In(0)) {
+			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
 
-			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
+			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
 				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
-			return boolType, info{}
+			return boolNature
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "filter":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
 		v.begin(collection)
-		closure, _ := v.visit(node.Arguments[1])
+		closure := v.visit(node.Arguments[1])
 		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isAny(closure.In(0)) {
+			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
 
-			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
+			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
 				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
-			if isAny(collection) {
-				return arrayType, info{}
+			if isUnknown(collection) {
+				return arrayNature
+			}
+			return Nature{
+				Type:    arrayType,
+				SubType: Array{Of: collection.Elem()},
 			}
-			return arrayType, info{}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "map":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
-		v.begin(collection, scopeVar{"index", integerType})
-		closure, _ := v.visit(node.Arguments[1])
+		v.begin(collection, scopeVar{"index", integerNature})
+		closure := v.visit(node.Arguments[1])
 		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isAny(closure.In(0)) {
+			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
 
-			return arrayType, info{}
+			return Nature{
+				Type:    arrayType,
+				SubType: Array{Of: closure.Out(0)},
+			}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "count":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
 		if len(node.Arguments) == 1 {
-			return integerType, info{}
+			return integerNature
 		}
 
 		v.begin(collection)
-		closure, _ := v.visit(node.Arguments[1])
+		closure := v.visit(node.Arguments[1])
 		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isAny(closure.In(0)) {
-			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
+			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
+			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
 				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
 
-			return integerType, info{}
+			return integerNature
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "sum":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
 		if len(node.Arguments) == 2 {
 			v.begin(collection)
-			closure, _ := v.visit(node.Arguments[1])
+			closure := v.visit(node.Arguments[1])
 			v.end()
 
 			if isFunc(closure) &&
 				closure.NumOut() == 1 &&
-				closure.NumIn() == 1 && isAny(closure.In(0)) {
-				return closure.Out(0), info{}
+				closure.NumIn() == 1 && isUnknown(closure.In(0)) {
+				return closure.Out(0)
 			}
 		} else {
-			if isAny(collection) {
-				return anyType, info{}
+			if isUnknown(collection) {
+				return unknown
 			}
-			return collection.Elem(), info{}
+			return collection.Elem()
 		}
 
 	case "find", "findLast":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
 		v.begin(collection)
-		closure, _ := v.visit(node.Arguments[1])
+		closure := v.visit(node.Arguments[1])
 		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isAny(closure.In(0)) {
+			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
 
-			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
+			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
 				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
-			if isAny(collection) {
-				return anyType, info{}
+			if isUnknown(collection) {
+				return unknown
 			}
-			return collection.Elem(), info{}
+			return collection.Elem()
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "findIndex", "findLastIndex":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
 		v.begin(collection)
-		closure, _ := v.visit(node.Arguments[1])
+		closure := v.visit(node.Arguments[1])
 		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isAny(closure.In(0)) {
+			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
 
-			if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) {
+			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
 				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
-			return integerType, info{}
+			return integerNature
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "groupBy":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
 		v.begin(collection)
-		closure, _ := v.visit(node.Arguments[1])
+		closure := v.visit(node.Arguments[1])
 		v.end()
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isAny(closure.In(0)) {
+			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
 
-			return reflect.TypeOf(map[any][]any{}), info{}
+			return Nature{Type: reflect.TypeOf(map[any][]any{})}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "sortBy":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
 		v.begin(collection)
-		closure, _ := v.visit(node.Arguments[1])
+		closure := v.visit(node.Arguments[1])
 		v.end()
 
 		if len(node.Arguments) == 3 {
-			_, _ = v.visit(node.Arguments[2])
+			_ = v.visit(node.Arguments[2])
 		}
 
 		if isFunc(closure) &&
 			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isAny(closure.In(0)) {
+			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
 
-			return reflect.TypeOf([]any{}), info{}
+			return Nature{Type: reflect.TypeOf([]any{})}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "reduce":
-		collection, _ := v.visit(node.Arguments[0])
-		if !isArray(collection) && !isAny(collection) {
+		collection := v.visit(node.Arguments[0])
+		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
 
-		v.begin(collection, scopeVar{"index", integerType}, scopeVar{"acc", anyType})
-		closure, _ := v.visit(node.Arguments[1])
+		v.begin(collection, scopeVar{"index", integerNature}, scopeVar{"acc", unknown})
+		closure := v.visit(node.Arguments[1])
 		v.end()
 
 		if len(node.Arguments) == 3 {
-			_, _ = v.visit(node.Arguments[2])
+			_ = v.visit(node.Arguments[2])
 		}
 
 		if isFunc(closure) && closure.NumOut() == 1 {
-			return closure.Out(0), info{}
+			return closure.Out(0)
 		}
 		return v.error(node.Arguments[1], "predicate should has two input and one output param")
 
@@ -852,14 +853,14 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 }
 
 type scopeVar struct {
-	name  string
-	vtype reflect.Type
+	varName   string
+	varNature Nature
 }
 
-func (v *checker) begin(vtype reflect.Type, vars ...scopeVar) {
-	scope := predicateScope{vtype: vtype, vars: make(map[string]reflect.Type)}
+func (v *checker) begin(collectionNature Nature, vars ...scopeVar) {
+	scope := predicateScope{collection: collectionNature, vars: make(map[string]Nature)}
 	for _, v := range vars {
-		scope.vars[v.name] = v.vtype
+		scope.vars[v.varName] = v.varNature
 	}
 	v.predicateScopes = append(v.predicateScopes, scope)
 }
@@ -868,83 +869,81 @@ func (v *checker) end() {
 	v.predicateScopes = v.predicateScopes[:len(v.predicateScopes)-1]
 }
 
-func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) {
+func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) Nature {
 	if len(node.Arguments) != 2 {
 		return v.error(node, "invalid number of arguments (expected 2, got %d)", len(node.Arguments))
 	}
 
-	val := node.Arguments[0]
-	prop := node.Arguments[1]
-	if id, ok := val.(*ast.IdentifierNode); ok && id.Value == "$env" {
-		if s, ok := prop.(*ast.StringNode); ok {
-			return v.config.Types[s.Value].Type, info{}
+	base := v.visit(node.Arguments[0])
+	prop := v.visit(node.Arguments[1])
+
+	if id, ok := node.Arguments[0].(*ast.IdentifierNode); ok && id.Value == "$env" {
+		if s, ok := node.Arguments[1].(*ast.StringNode); ok {
+			return Nature{Type: v.config.Types[s.Value].Type}
 		}
-		return anyType, info{}
+		return unknown
 	}
 
-	t, _ := v.visit(val)
+	if isUnknown(base) {
+		return unknown
+	}
 
-	switch kind(t) {
-	case reflect.Interface:
-		return anyType, info{}
+	switch base.Kind() {
 	case reflect.Slice, reflect.Array:
-		p, _ := v.visit(prop)
-		if p == nil {
-			return v.error(prop, "cannot use nil as slice index")
+		if !isInteger(prop) && !isUnknown(prop) {
+			return v.error(node.Arguments[1], "non-integer slice index %s", prop)
 		}
-		if !isInteger(p) && !isAny(p) {
-			return v.error(prop, "non-integer slice index %v", p)
-		}
-		return t.Elem(), info{}
+		return base.Elem()
 	case reflect.Map:
-		p, _ := v.visit(prop)
-		if p == nil {
-			return v.error(prop, "cannot use nil as map index")
-		}
-		if !p.AssignableTo(t.Key()) && !isAny(p) {
-			return v.error(prop, "cannot use %v to get an element from %v", p, t)
+		if !prop.AssignableTo(base.Key()) && !isUnknown(prop) {
+			return v.error(node.Arguments[1], "cannot use %s to get an element from %s", prop, base)
 		}
-		return t.Elem(), info{}
+		return base.Elem()
 	}
-	return v.error(val, "type %v does not support indexing", t)
+	return v.error(node.Arguments[0], "type %v does not support indexing", base)
 }
 
-func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) (reflect.Type, info) {
+func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) Nature {
 	if f.Validate != nil {
 		args := make([]reflect.Type, len(arguments))
 		for i, arg := range arguments {
-			args[i], _ = v.visit(arg)
+			argNature := v.visit(arg)
+			if isUnknown(argNature) {
+				args[i] = anyType
+			} else {
+				args[i] = argNature.Type
+			}
 		}
 		t, err := f.Validate(args)
 		if err != nil {
 			return v.error(node, "%v", err)
 		}
-		return t, info{}
+		return Nature{Type: t}
 	} else if len(f.Types) == 0 {
-		t, err := v.checkArguments(f.Name, f.Type(), false, arguments, node)
+		nt, err := v.checkArguments(f.Name, Nature{Type: f.Type()}, arguments, node)
 		if err != nil {
 			if v.err == nil {
 				v.err = err
 			}
-			return anyType, info{}
+			return unknown
 		}
 		// No type was specified, so we assume the function returns any.
-		return t, info{}
+		return nt
 	}
 	var lastErr *file.Error
 	for _, t := range f.Types {
-		outType, err := v.checkArguments(f.Name, t, false, arguments, node)
+		outNature, err := v.checkArguments(f.Name, Nature{Type: t}, arguments, node)
 		if err != nil {
 			lastErr = err
 			continue
 		}
-		return outType, info{}
+		return outNature
 	}
 	if lastErr != nil {
 		if v.err == nil {
 			v.err = lastErr
 		}
-		return anyType, info{}
+		return unknown
 	}
 
 	return v.error(node, "no matching overload for %v", f.Name)
@@ -952,23 +951,22 @@ func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []
 
 func (v *checker) checkArguments(
 	name string,
-	fn reflect.Type,
-	method bool,
+	fn Nature,
 	arguments []ast.Node,
 	node ast.Node,
-) (reflect.Type, *file.Error) {
-	if isAny(fn) {
-		return anyType, nil
+) (Nature, *file.Error) {
+	if isUnknown(fn) {
+		return unknown, nil
 	}
 
 	if fn.NumOut() == 0 {
-		return anyType, &file.Error{
+		return unknown, &file.Error{
 			Location: node.Location(),
 			Message:  fmt.Sprintf("func %v doesn't return value", name),
 		}
 	}
 	if numOut := fn.NumOut(); numOut > 2 {
-		return anyType, &file.Error{
+		return unknown, &file.Error{
 			Location: node.Location(),
 			Message:  fmt.Sprintf("func %v returns more then two values", name),
 		}
@@ -977,12 +975,12 @@ func (v *checker) checkArguments(
 	// If func is method on an env, first argument should be a receiver,
 	// and actual arguments less than fnNumIn by one.
 	fnNumIn := fn.NumIn()
-	if method {
+	if fn.Method { // TODO: Move subtraction to the Nature.NumIn() and Nature.In() methods.
 		fnNumIn--
 	}
 	// Skip first argument in case of the receiver.
 	fnInOffset := 0
-	if method {
+	if fn.Method {
 		fnInOffset = 1
 	}
 
@@ -1013,15 +1011,15 @@ func (v *checker) checkArguments(
 		// If we have an error, we should still visit all arguments to
 		// type check them, as a patch can fix the error later.
 		for _, arg := range arguments {
-			_, _ = v.visit(arg)
+			_ = v.visit(arg)
 		}
 		return fn.Out(0), err
 	}
 
 	for i, arg := range arguments {
-		t, _ := v.visit(arg)
+		argNature := v.visit(arg)
 
-		var in reflect.Type
+		var in Nature
 		if fn.IsVariadic() && i >= fnNumIn-1 {
 			// For variadic arguments fn(xs ...int), go replaces type of xs (int) with ([]int).
 			// As we compare arguments one by one, we need underling type.
@@ -1030,24 +1028,40 @@ func (v *checker) checkArguments(
 			in = fn.In(i + fnInOffset)
 		}
 
-		if isFloat(in) && isInteger(t) {
+		if isFloat(in) && isInteger(argNature) {
 			traverseAndReplaceIntegerNodesWithFloatNodes(&arguments[i], in)
 			continue
 		}
 
-		if isInteger(in) && isInteger(t) && kind(t) != kind(in) {
+		if isInteger(in) && isInteger(argNature) && argNature.Kind() != in.Kind() {
 			traverseAndReplaceIntegerNodesWithIntegerNodes(&arguments[i], in)
 			continue
 		}
 
-		if t == nil {
-			continue
+		if isNil(argNature) {
+			if in.Kind() == reflect.Ptr || in.Kind() == reflect.Interface {
+				continue
+			}
+			return unknown, &file.Error{
+				Location: arg.Location(),
+				Message:  fmt.Sprintf("cannot use nil as argument (type %s) to call %v", in, name),
+			}
 		}
 
-		if !(t.AssignableTo(in) || deref.Type(t).AssignableTo(in)) && kind(t) != reflect.Interface {
-			return anyType, &file.Error{
+		// Check if argument is assignable to the function input type.
+		// We check original type (like *time.Time), not dereferenced type,
+		// as function input type can be pointer to a struct.
+		assignable := argNature.AssignableTo(in)
+
+		// We also need to check if dereference arg type is assignable to the function input type.
+		// For example, func(int) and argument *int. In this case we will add OpDeref to the argument,
+		// so we can call the function with *int argument.
+		assignable = assignable || argNature.Deref().AssignableTo(in)
+
+		if !assignable && !isUnknown(argNature) {
+			return unknown, &file.Error{
 				Location: arg.Location(),
-				Message:  fmt.Sprintf("cannot use %v as argument (type %v) to call %v ", t, in, name),
+				Message:  fmt.Sprintf("cannot use %s as argument (type %s) to call %v ", argNature, in, name),
 			}
 		}
 	}
@@ -1055,74 +1069,82 @@ func (v *checker) checkArguments(
 	return fn.Out(0), nil
 }
 
-func traverseAndReplaceIntegerNodesWithFloatNodes(node *ast.Node, newType reflect.Type) {
+func traverseAndReplaceIntegerNodesWithFloatNodes(node *ast.Node, newNature Nature) {
 	switch (*node).(type) {
 	case *ast.IntegerNode:
 		*node = &ast.FloatNode{Value: float64((*node).(*ast.IntegerNode).Value)}
-		(*node).SetType(newType)
+		(*node).SetType(newNature.Type)
 	case *ast.UnaryNode:
 		unaryNode := (*node).(*ast.UnaryNode)
-		traverseAndReplaceIntegerNodesWithFloatNodes(&unaryNode.Node, newType)
+		traverseAndReplaceIntegerNodesWithFloatNodes(&unaryNode.Node, newNature)
 	case *ast.BinaryNode:
 		binaryNode := (*node).(*ast.BinaryNode)
 		switch binaryNode.Operator {
 		case "+", "-", "*":
-			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Left, newType)
-			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Right, newType)
+			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Left, newNature)
+			traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Right, newNature)
 		}
 	}
 }
 
-func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newType reflect.Type) {
+func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newNature Nature) {
 	switch (*node).(type) {
 	case *ast.IntegerNode:
-		(*node).SetType(newType)
+		(*node).SetType(newNature.Type)
 	case *ast.UnaryNode:
-		(*node).SetType(newType)
+		(*node).SetType(newNature.Type)
 		unaryNode := (*node).(*ast.UnaryNode)
-		traverseAndReplaceIntegerNodesWithIntegerNodes(&unaryNode.Node, newType)
+		traverseAndReplaceIntegerNodesWithIntegerNodes(&unaryNode.Node, newNature)
 	case *ast.BinaryNode:
 		// TODO: Binary node return type is dependent on the type of the operands. We can't just change the type of the node.
 		binaryNode := (*node).(*ast.BinaryNode)
 		switch binaryNode.Operator {
 		case "+", "-", "*":
-			traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Left, newType)
-			traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Right, newType)
+			traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Left, newNature)
+			traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Right, newNature)
 		}
 	}
 }
 
-func (v *checker) ClosureNode(node *ast.ClosureNode) (reflect.Type, info) {
-	t, _ := v.visit(node.Node)
-	if t == nil {
-		return v.error(node.Node, "closure cannot be nil")
+func (v *checker) ClosureNode(node *ast.ClosureNode) Nature {
+	nt := v.visit(node.Node)
+	var out reflect.Type
+	if isUnknown(nt) {
+		out = anyType
+	} else {
+		out = nt.Type
 	}
-	return reflect.FuncOf([]reflect.Type{anyType}, []reflect.Type{t}, false), info{}
+	return Nature{Type: reflect.FuncOf(
+		[]reflect.Type{anyType},
+		[]reflect.Type{out},
+		false,
+	)}
 }
 
-func (v *checker) PointerNode(node *ast.PointerNode) (reflect.Type, info) {
+func (v *checker) PointerNode(node *ast.PointerNode) Nature {
 	if len(v.predicateScopes) == 0 {
 		return v.error(node, "cannot use pointer accessor outside closure")
 	}
 	scope := v.predicateScopes[len(v.predicateScopes)-1]
 	if node.Name == "" {
-		switch scope.vtype.Kind() {
-		case reflect.Interface:
-			return anyType, info{}
+		if isUnknown(scope.collection) {
+			return unknown
+		}
+		switch scope.collection.Kind() {
 		case reflect.Array, reflect.Slice:
-			return scope.vtype.Elem(), info{}
+			return scope.collection.Elem()
 		}
 		return v.error(node, "cannot use %v as array", scope)
 	}
 	if scope.vars != nil {
 		if t, ok := scope.vars[node.Name]; ok {
-			return t, info{}
+			return t
 		}
 	}
 	return v.error(node, "unknown pointer #%v", node.Name)
 }
 
-func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (reflect.Type, info) {
+func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Nature {
 	if _, ok := v.config.Types[node.Name]; ok {
 		return v.error(node, "cannot redeclare %v", node.Name)
 	}
@@ -1135,11 +1157,11 @@ func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (refl
 	if _, ok := v.lookupVariable(node.Name); ok {
 		return v.error(node, "cannot redeclare variable %v", node.Name)
 	}
-	vtype, vinfo := v.visit(node.Value)
-	v.varScopes = append(v.varScopes, varScope{node.Name, vtype, vinfo})
-	t, i := v.visit(node.Expr)
+	varNature := v.visit(node.Value)
+	v.varScopes = append(v.varScopes, varScope{node.Name, varNature})
+	exprNature := v.visit(node.Expr)
 	v.varScopes = v.varScopes[:len(v.varScopes)-1]
-	return t, i
+	return exprNature
 }
 
 func (v *checker) lookupVariable(name string) (varScope, bool) {
@@ -1151,59 +1173,60 @@ func (v *checker) lookupVariable(name string) (varScope, bool) {
 	return varScope{}, false
 }
 
-func (v *checker) ConditionalNode(node *ast.ConditionalNode) (reflect.Type, info) {
-	c, _ := v.visit(node.Cond)
-	if !isBool(c) && !isAny(c) {
+func (v *checker) ConditionalNode(node *ast.ConditionalNode) Nature {
+	c := v.visit(node.Cond)
+	if !isBool(c) && !isUnknown(c) {
 		return v.error(node.Cond, "non-bool expression (type %v) used as condition", c)
 	}
 
-	t1, _ := v.visit(node.Exp1)
-	t2, _ := v.visit(node.Exp2)
+	t1 := v.visit(node.Exp1)
+	t2 := v.visit(node.Exp2)
 
-	if t1 == nil && t2 != nil {
-		return t2, info{}
+	if isNil(t1) && !isNil(t2) {
+		return t2
 	}
-	if t1 != nil && t2 == nil {
-		return t1, info{}
+	if !isNil(t1) && isNil(t2) {
+		return t1
 	}
-	if t1 == nil && t2 == nil {
-		return nilType, info{}
+	if isNil(t1) && isNil(t2) {
+		return nilNature
 	}
 	if t1.AssignableTo(t2) {
-		return t1, info{}
+		return t1
 	}
-	return anyType, info{}
+	return unknown
 }
 
-func (v *checker) ArrayNode(node *ast.ArrayNode) (reflect.Type, info) {
-	var prev reflect.Type
+func (v *checker) ArrayNode(node *ast.ArrayNode) Nature {
+	var prev Nature
 	allElementsAreSameType := true
 	for i, node := range node.Nodes {
-		curr, _ := v.visit(node)
+		curr := v.visit(node)
 		if i > 0 {
-			if curr == nil || prev == nil {
-				allElementsAreSameType = false
-			} else if curr.Kind() != prev.Kind() {
+			if curr.Kind() != prev.Kind() {
 				allElementsAreSameType = false
 			}
 		}
 		prev = curr
 	}
-	if allElementsAreSameType && prev != nil {
-		return arrayType, info{elem: prev}
+	if allElementsAreSameType {
+		return Nature{
+			Type:    arrayNature.Type,
+			SubType: Array{Of: prev},
+		}
 	}
-	return arrayType, info{}
+	return arrayNature
 }
 
-func (v *checker) MapNode(node *ast.MapNode) (reflect.Type, info) {
+func (v *checker) MapNode(node *ast.MapNode) Nature {
 	for _, pair := range node.Pairs {
 		v.visit(pair)
 	}
-	return mapType, info{}
+	return mapNature
 }
 
-func (v *checker) PairNode(node *ast.PairNode) (reflect.Type, info) {
+func (v *checker) PairNode(node *ast.PairNode) Nature {
 	v.visit(node.Key)
 	v.visit(node.Value)
-	return nilType, info{}
+	return nilNature
 }
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 1509045e3..ae42392c0 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -149,427 +149,541 @@ func TestCheck(t *testing.T) {
 	}
 }
 
-const errorTests = `
-Foo.Bar.Not
+func TestCheck_error(t *testing.T) {
+	errorTests := []struct{ code, err string }{
+		{
+			`Foo.Bar.Not`,
+			`
 type mock.Bar has no field Not (1:9)
  | Foo.Bar.Not
  | ........^
-
-Noo
+`,
+		},
+		{
+			`Noo`,
+			`
 unknown name Noo (1:1)
  | Noo
  | ^
-
-Foo()
+`,
+		},
+		{
+			`Foo()`, `
 mock.Foo is not callable (1:1)
  | Foo()
  | ^
-
-Foo['bar']
+`,
+		},
+		{
+			`Foo['bar']`, `
 type mock.Foo has no field bar (1:4)
  | Foo['bar']
  | ...^
-
-Foo.Method(42)
+`,
+		},
+		{
+			`Foo.Method(42)`,
+			`
 too many arguments to call Method (1:5)
  | Foo.Method(42)
  | ....^
-
-Foo.Bar()
+`,
+		},
+		{`Foo.Bar()`, `
 mock.Bar is not callable (1:5)
  | Foo.Bar()
  | ....^
-
-Foo.Bar.Not()
+`,
+		},
+		{`Foo.Bar.Not()`, `
 type mock.Bar has no method Not (1:9)
  | Foo.Bar.Not()
  | ........^
-
-ArrayOfFoo[0].Not
+`,
+		},
+		{`ArrayOfFoo[0].Not`, `
 type mock.Foo has no field Not (1:15)
  | ArrayOfFoo[0].Not
  | ..............^
-
-ArrayOfFoo[Not]
+`,
+		},
+		{`ArrayOfFoo[Not]`, `
 unknown name Not (1:12)
  | ArrayOfFoo[Not]
  | ...........^
-
-Not[0]
+`,
+		},
+		{`Not[0]`, `
 unknown name Not (1:1)
  | Not[0]
  | ^
-
-Not.Bar
+`,
+		},
+		{`Not.Bar`, `
 unknown name Not (1:1)
  | Not.Bar
  | ^
-
-ArrayOfFoo.Not
+`,
+		},
+		{`ArrayOfFoo.Not`, `
 array elements can only be selected using an integer (got string) (1:12)
  | ArrayOfFoo.Not
  | ...........^
-
-FuncParam(true)
+`,
+		},
+		{`FuncParam(true)`, `
 not enough arguments to call FuncParam (1:1)
  | FuncParam(true)
  | ^
-
-MapOfFoo['str'].Not
+`,
+		},
+		{`MapOfFoo['str'].Not`, `
 type mock.Foo has no field Not (1:17)
  | MapOfFoo['str'].Not
  | ................^
-
-Bool && IntPtr
+`,
+		},
+		{`Bool && IntPtr`, `
 invalid operation: && (mismatched types bool and int) (1:6)
  | Bool && IntPtr
  | .....^
-
-No ? Any.Bool : Any.Not
+`,
+		},
+		{`No ? Any.Bool : Any.Not`, `
 unknown name No (1:1)
  | No ? Any.Bool : Any.Not
  | ^
-
-Any.Cond ? No : Any.Not
+`,
+		},
+		{`Any.Cond ? No : Any.Not`, `
 unknown name No (1:12)
  | Any.Cond ? No : Any.Not
  | ...........^
-
-Any.Cond ? Any.Bool : No
+`,
+		},
+		{`Any.Cond ? Any.Bool : No`, `
 unknown name No (1:23)
  | Any.Cond ? Any.Bool : No
  | ......................^
-
-MapOfAny ? Any : Any
+`,
+		},
+		{`MapOfAny ? Any : Any`, `
 non-bool expression (type map[string]interface {}) used as condition (1:1)
  | MapOfAny ? Any : Any
  | ^
-
-String matches Int
+`,
+		},
+		{`String matches Int`, `
 invalid operation: matches (mismatched types string and int) (1:8)
  | String matches Int
  | .......^
-
-Int matches String
+`,
+		},
+		{`Int matches String`, `
 invalid operation: matches (mismatched types int and string) (1:5)
  | Int matches String
  | ....^
-
-String contains Int
+`,
+		},
+		{`String contains Int`, `
 invalid operation: contains (mismatched types string and int) (1:8)
  | String contains Int
  | .......^
-
-Int contains String
+`,
+		},
+		{`Int contains String`, `
 invalid operation: contains (mismatched types int and string) (1:5)
  | Int contains String
  | ....^
-
-!Not
+`,
+		},
+		{`!Not`, `
 unknown name Not (1:2)
  | !Not
  | .^
-
-Not == Any
+`,
+		},
+		{`Not == Any`, `
 unknown name Not (1:1)
  | Not == Any
  | ^
-
-[Not]
+`,
+		},
+		{`[Not]`, `
 unknown name Not (1:2)
  | [Not]
  | .^
-
-{id: Not}
+`,
+		},
+		{`{id: Not}`, `
 unknown name Not (1:6)
  | {id: Not}
  | .....^
-
-(nil).Foo
-type <nil> has no field Foo (1:7)
+`,
+		},
+		{`(nil).Foo`, `
+type nil has no field Foo (1:7)
  | (nil).Foo
  | ......^
-
-(nil)['Foo']
-type <nil> has no field Foo (1:6)
+`,
+		},
+		{`(nil)['Foo']`, `
+type nil has no field Foo (1:6)
  | (nil)['Foo']
  | .....^
-
-1 and false
+`,
+		},
+		{`1 and false`, `
 invalid operation: and (mismatched types int and bool) (1:3)
  | 1 and false
  | ..^
-
-true or 0
+`,
+		},
+		{`true or 0`, `
 invalid operation: or (mismatched types bool and int) (1:6)
  | true or 0
  | .....^
-
-not IntPtr
+`,
+		},
+		{`not IntPtr`, `
 invalid operation: not (mismatched type int) (1:1)
  | not IntPtr
  | ^
-
-len(Not)
+`,
+		},
+		{`len(Not)`, `
 unknown name Not (1:5)
  | len(Not)
  | ....^
-
-Int < Bool
+`,
+		},
+		{`Int < Bool`, `
 invalid operation: < (mismatched types int and bool) (1:5)
  | Int < Bool
  | ....^
-
-Int > Bool
+`,
+		},
+		{`Int > Bool`, `
 invalid operation: > (mismatched types int and bool) (1:5)
  | Int > Bool
  | ....^
-
-Int >= Bool
+`,
+		},
+		{`Int >= Bool`, `
 invalid operation: >= (mismatched types int and bool) (1:5)
  | Int >= Bool
  | ....^
-
-Int <= Bool
+`,
+		},
+		{`Int <= Bool`, `
 invalid operation: <= (mismatched types int and bool) (1:5)
  | Int <= Bool
  | ....^
-
-Int + Bool
+`,
+		},
+		{`Int + Bool`, `
 invalid operation: + (mismatched types int and bool) (1:5)
  | Int + Bool
  | ....^
-
-Int - Bool
+`,
+		},
+		{`Int - Bool`, `
 invalid operation: - (mismatched types int and bool) (1:5)
  | Int - Bool
  | ....^
-
-Int * Bool
+`,
+		},
+		{`Int * Bool`, `
 invalid operation: * (mismatched types int and bool) (1:5)
  | Int * Bool
  | ....^
-
-Int / Bool
+`,
+		},
+		{`Int / Bool`, `
 invalid operation: / (mismatched types int and bool) (1:5)
  | Int / Bool
  | ....^
-
-Int % Bool
+`,
+		},
+		{`Int % Bool`, `
 invalid operation: % (mismatched types int and bool) (1:5)
  | Int % Bool
  | ....^
-
-Int ** Bool
+`,
+		},
+		{`Int ** Bool`, `
 invalid operation: ** (mismatched types int and bool) (1:5)
  | Int ** Bool
  | ....^
-
-Int .. Bool
+`,
+		},
+		{`Int .. Bool`, `
 invalid operation: .. (mismatched types int and bool) (1:5)
  | Int .. Bool
  | ....^
-
-Any > Foo
+`,
+		},
+		{`Any > Foo`, `
 invalid operation: > (mismatched types interface {} and mock.Foo) (1:5)
  | Any > Foo
  | ....^
-
-NilFn() and BoolFn()
+`,
+		},
+		{`NilFn() and BoolFn()`, `
 func NilFn doesn't return value (1:1)
  | NilFn() and BoolFn()
  | ^
-
-'str' in String
+`,
+		},
+		{`'str' in String`, `
 invalid operation: in (mismatched types string and string) (1:7)
  | 'str' in String
  | ......^
-
-1 in Foo
+`,
+		},
+		{`1 in Foo`, `
 invalid operation: in (mismatched types int and mock.Foo) (1:3)
  | 1 in Foo
  | ..^
-
-1 + ''
+`,
+		},
+		{`1 + ''`, `
 invalid operation: + (mismatched types int and string) (1:3)
  | 1 + ''
  | ..^
-
-all(ArrayOfFoo, {#.Method() < 0})
+`,
+		},
+		{`all(ArrayOfFoo, {#.Method() < 0})`, `
 invalid operation: < (mismatched types mock.Bar and int) (1:29)
  | all(ArrayOfFoo, {#.Method() < 0})
  | ............................^
-
-Variadic()
+`,
+		},
+		{`Variadic()`, `
 not enough arguments to call Variadic (1:1)
  | Variadic()
  | ^
-
-Variadic(0, '')
+`,
+		},
+		{`Variadic(0, '')`, `
 cannot use string as argument (type int) to call Variadic  (1:13)
  | Variadic(0, '')
  | ............^
-
-count(1, {#})
+`,
+		},
+		{`count(1, {#})`, `
 builtin count takes only array (got int) (1:7)
  | count(1, {#})
  | ......^
-
-count(ArrayOfInt, {#})
+`,
+		},
+		{`count(ArrayOfInt, {#})`, `
 predicate should return boolean (got int) (1:19)
  | count(ArrayOfInt, {#})
  | ..................^
-
-all(ArrayOfInt, {# + 1})
+`,
+		},
+		{`all(ArrayOfInt, {# + 1})`, `
 predicate should return boolean (got int) (1:17)
  | all(ArrayOfInt, {# + 1})
  | ................^
-
-filter(ArrayOfFoo, {.Bar.Baz})
+`,
+		},
+		{`filter(ArrayOfFoo, {.Bar.Baz})`, `
 predicate should return boolean (got string) (1:20)
  | filter(ArrayOfFoo, {.Bar.Baz})
  | ...................^
-
-find(ArrayOfFoo, {.Bar.Baz})
+`,
+		},
+		{`find(ArrayOfFoo, {.Bar.Baz})`, `
 predicate should return boolean (got string) (1:18)
  | find(ArrayOfFoo, {.Bar.Baz})
  | .................^
-
-map(1, {2})
+`,
+		},
+		{`map(1, {2})`, `
 builtin map takes only array (got int) (1:5)
  | map(1, {2})
  | ....^
-
-ArrayOfFoo[Foo]
+`,
+		},
+		{`ArrayOfFoo[Foo]`, `
 array elements can only be selected using an integer (got mock.Foo) (1:12)
  | ArrayOfFoo[Foo]
  | ...........^
-
-ArrayOfFoo[Bool:]
+`,
+		},
+		{`ArrayOfFoo[Bool:]`, `
 non-integer slice index bool (1:12)
  | ArrayOfFoo[Bool:]
  | ...........^
-
-ArrayOfFoo[1:Bool]
+`,
+		},
+		{`ArrayOfFoo[1:Bool]`, `
 non-integer slice index bool (1:14)
  | ArrayOfFoo[1:Bool]
  | .............^
-
-Bool[:]
+`,
+		},
+		{`Bool[:]`, `
 cannot slice bool (1:5)
  | Bool[:]
  | ....^
-
-FuncTooManyReturns()
+`,
+		},
+		{`FuncTooManyReturns()`, `
 func FuncTooManyReturns returns more then two values (1:1)
  | FuncTooManyReturns()
  | ^
-
-len(42)
+`,
+		},
+		{`len(42)`, `
 invalid argument for len (type int) (1:1)
  | len(42)
  | ^
-
-any(42, {#})
+`,
+		},
+		{`any(42, {#})`, `
 builtin any takes only array (got int) (1:5)
  | any(42, {#})
  | ....^
-
-filter(42, {#})
+`,
+		},
+		{`filter(42, {#})`, `
 builtin filter takes only array (got int) (1:8)
  | filter(42, {#})
  | .......^
-
-MapOfAny[0]
+`,
+		},
+		{`MapOfAny[0]`, `
 cannot use int to get an element from map[string]interface {} (1:10)
  | MapOfAny[0]
  | .........^
-
-1 /* one */ + "2"
+`,
+		},
+		{`1 /* one */ + "2"`, `
 invalid operation: + (mismatched types int and string) (1:13)
  | 1 /* one */ + "2"
  | ............^
-
-FuncTyped(42)
+`,
+		},
+		{`FuncTyped(42)`, `
 cannot use int as argument (type string) to call FuncTyped  (1:11)
  | FuncTyped(42)
  | ..........^
-
-.0 in MapOfFoo
+`,
+		},
+		{`.0 in MapOfFoo`, `
 cannot use float64 as type string in map key (1:4)
  | .0 in MapOfFoo
  | ...^
-
-1/2 in MapIntAny
+`,
+		},
+		{`1/2 in MapIntAny`, `
 cannot use float64 as type int in map key (1:5)
  | 1/2 in MapIntAny
  | ....^
-
-0.5 in ArrayOfFoo
+`,
+		},
+		{`0.5 in ArrayOfFoo`, `
 cannot use float64 as type *mock.Foo in array (1:5)
  | 0.5 in ArrayOfFoo
  | ....^
-
-repeat("0", 1/0)
+`,
+		},
+		{`repeat("0", 1/0)`, `
 cannot use float64 as argument (type int) to call repeat  (1:14)
  | repeat("0", 1/0)
  | .............^
-
-let map = 42; map
+`,
+		},
+		{`let map = 42; map`, `
 cannot redeclare builtin map (1:5)
  | let map = 42; map
  | ....^
-
-let len = 42; len
+`,
+		},
+		{`let len = 42; len`, `
 cannot redeclare builtin len (1:5)
  | let len = 42; len
  | ....^
-
-let Float = 42; Float
+`,
+		},
+		{`let Float = 42; Float`, `
 cannot redeclare Float (1:5)
  | let Float = 42; Float
  | ....^
-
-let foo = 1; let foo = 2; foo
+`,
+		},
+		{`let foo = 1; let foo = 2; foo`, `
 cannot redeclare variable foo (1:18)
  | let foo = 1; let foo = 2; foo
  | .................^
-
-map(1..9, #unknown)
+`,
+		},
+		{`map(1..9, #unknown)`, `
 unknown pointer #unknown (1:11)
  | map(1..9, #unknown)
  | ..........^
-
-42 in ["a", "b", "c"]
+`,
+		},
+		{`42 in ["a", "b", "c"]`, `
 cannot use int as type string in array (1:4)
  | 42 in ["a", "b", "c"]
  | ...^
-
-"foo" matches "[+"
+`,
+		},
+		{`"foo" matches "[+"`, `
 error parsing regexp: missing closing ]: ` + "`[+`" + ` (1:7)
  | "foo" matches "[+"
  | ......^
-`
-
-func TestCheck_error(t *testing.T) {
-	tests := strings.Split(strings.Trim(errorTests, "\n"), "\n\n")
-
-	for _, test := range tests {
-		input := strings.SplitN(test, "\n", 2)
-		if len(input) != 2 {
-			t.Errorf("syntax error in test: %q", test)
-			break
-		}
+`,
+		},
+		{`get(false, 2)`, `
+type bool does not support indexing (1:5)
+ | get(false, 2)
+ | ....^
+`,
+		},
+		{`get(1..2, 0.5)`, `
+non-integer slice index float64 (1:11)
+ | get(1..2, 0.5)
+ | ..........^`,
+		},
+		{`trimPrefix(nil)`, `
+cannot use nil as argument (type string) to call trimPrefix (1:12)
+ | trimPrefix(nil)
+ | ...........^
+`,
+		},
+		{`1..3 | filter(# > 1) | filter(# == "str")`,
+			`
+invalid operation: == (mismatched types int and string) (1:33)
+ | 1..3 | filter(# > 1) | filter(# == "str")
+ | ................................^
+`,
+		},
+		{`1..3 | map("str") | filter(# > 1)`,
+			`
+invalid operation: > (mismatched types string and int) (1:30)
+ | 1..3 | map("str") | filter(# > 1)
+ | .............................^
+`,
+		},
+	}
 
-		tree, err := parser.Parse(input[0])
-		assert.NoError(t, err)
+	for _, tt := range errorTests {
+		t.Run(tt.code, func(t *testing.T) {
+			tree, err := parser.Parse(tt.code)
+			require.NoError(t, err)
 
-		_, err = checker.Check(tree, conf.New(mock.Env{}))
-		if err == nil {
-			err = fmt.Errorf("<nil>")
-		}
+			_, err = checker.Check(tree, conf.New(mock.Env{}))
+			if err == nil {
+				err = fmt.Errorf("<nil>")
+			}
 
-		assert.Equal(t, input[1], err.Error(), input[0])
+			assert.Equal(t, strings.Trim(tt.err, "\n"), err.Error())
+		})
 	}
 }
 
diff --git a/checker/info.go b/checker/info.go
index 112bfab31..3c9396fd5 100644
--- a/checker/info.go
+++ b/checker/info.go
@@ -15,11 +15,9 @@ func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) {
 			return true, t.FieldIndex, n.Value
 		}
 	case *ast.MemberNode:
-		base := n.Node.Type()
-		if kind(base) == reflect.Ptr {
-			base = base.Elem()
-		}
-		if kind(base) == reflect.Struct {
+		base := n.Node.Nature()
+		base = base.Deref()
+		if base.Kind() == reflect.Struct {
 			if prop, ok := n.Property.(*ast.StringNode); ok {
 				name := prop.Value
 				if field, ok := fetchField(base, name); ok {
@@ -114,8 +112,7 @@ func IsFastFunc(fn reflect.Type, method bool) bool {
 	if method {
 		numIn = 2
 	}
-	if !isAny(fn) &&
-		fn.IsVariadic() &&
+	if fn.IsVariadic() &&
 		fn.NumIn() == numIn &&
 		fn.NumOut() == 1 &&
 		fn.Out(0).Kind() == reflect.Interface {
diff --git a/checker/nature/nature.go b/checker/nature/nature.go
new file mode 100644
index 000000000..a7365998c
--- /dev/null
+++ b/checker/nature/nature.go
@@ -0,0 +1,142 @@
+package nature
+
+import (
+	"reflect"
+
+	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/internal/deref"
+)
+
+var (
+	unknown = Nature{}
+)
+
+type Nature struct {
+	Type    reflect.Type
+	SubType SubType
+	Func    *builtin.Function
+	Method  bool
+}
+
+func (n Nature) String() string {
+	if n.SubType != nil {
+		return n.SubType.String()
+	}
+	if n.Type != nil {
+		return n.Type.String()
+	}
+	return "unknown"
+}
+
+func (n Nature) Deref() Nature {
+	if n.Type != nil {
+		n.Type = deref.Type(n.Type)
+	}
+	return n
+}
+
+func (n Nature) Kind() reflect.Kind {
+	if n.Type != nil {
+		return n.Type.Kind()
+	}
+	return reflect.Invalid
+}
+
+func (n Nature) Key() Nature {
+	if n.Kind() == reflect.Map {
+		return Nature{Type: n.Type.Key()}
+	}
+	return unknown
+}
+
+func (n Nature) Elem() Nature {
+	switch n.Kind() {
+	case reflect.Map, reflect.Ptr:
+		return Nature{Type: n.Type.Elem()}
+	case reflect.Array, reflect.Slice:
+		if array, ok := n.SubType.(Array); ok {
+			return array.Of
+		}
+		return Nature{Type: n.Type.Elem()}
+	}
+	return unknown
+}
+
+func (n Nature) AssignableTo(nt Nature) bool {
+	if n.Type == nil || nt.Type == nil {
+		return false
+	}
+	return n.Type.AssignableTo(nt.Type)
+}
+
+func (n Nature) MethodByName(name string) (Nature, bool) {
+	if n.Type == nil {
+		return unknown, false
+	}
+	method, ok := n.Type.MethodByName(name)
+	if !ok {
+		return unknown, false
+	}
+
+	if n.Type.Kind() == reflect.Interface {
+		// In case of interface type method will not have a receiver,
+		// and to prevent checker decreasing numbers of in arguments
+		// return method type as not method (second argument is false).
+
+		// Also, we can not use m.Index here, because it will be
+		// different indexes for different types which implement
+		// the same interface.
+		return Nature{Type: method.Type}, true
+	} else {
+		return Nature{Type: method.Type, Method: true}, true
+	}
+}
+
+func (n Nature) NumField() int {
+	if n.Type == nil {
+		return 0
+	}
+	return n.Type.NumField()
+}
+
+func (n Nature) Field(i int) reflect.StructField {
+	if n.Type == nil {
+		return reflect.StructField{}
+	}
+	return n.Type.Field(i)
+}
+
+func (n Nature) NumIn() int {
+	if n.Type == nil {
+		return 0
+	}
+	return n.Type.NumIn()
+}
+
+func (n Nature) In(i int) Nature {
+	if n.Type == nil {
+		return unknown
+	}
+	return Nature{Type: n.Type.In(i)}
+}
+
+func (n Nature) NumOut() int {
+	if n.Type == nil {
+		return 0
+	}
+	return n.Type.NumOut()
+}
+
+func (n Nature) Out(i int) Nature {
+	if n.Type == nil {
+		return unknown
+	}
+	return Nature{Type: n.Type.Out(i)}
+}
+
+func (n Nature) IsVariadic() bool {
+	if n.Type == nil {
+		return false
+	}
+	return n.Type.IsVariadic()
+}
diff --git a/checker/nature/types.go b/checker/nature/types.go
new file mode 100644
index 000000000..1f9955e92
--- /dev/null
+++ b/checker/nature/types.go
@@ -0,0 +1,13 @@
+package nature
+
+type SubType interface {
+	String() string
+}
+
+type Array struct {
+	Of Nature
+}
+
+func (a Array) String() string {
+	return "[]" + a.Of.String()
+}
diff --git a/checker/types.go b/checker/types.go
index d10736a77..2eb5392e0 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -4,204 +4,193 @@ import (
 	"reflect"
 	"time"
 
+	. "github.com/expr-lang/expr/checker/nature"
 	"github.com/expr-lang/expr/conf"
 )
 
 var (
-	nilType      = reflect.TypeOf(nil)
-	boolType     = reflect.TypeOf(true)
-	integerType  = reflect.TypeOf(0)
-	floatType    = reflect.TypeOf(float64(0))
-	stringType   = reflect.TypeOf("")
-	arrayType    = reflect.TypeOf([]any{})
-	mapType      = reflect.TypeOf(map[string]any{})
+	unknown        = Nature{}
+	nilNature      = Nature{Type: reflect.TypeOf(Nil{})}
+	boolNature     = Nature{Type: reflect.TypeOf(true)}
+	integerNature  = Nature{Type: reflect.TypeOf(0)}
+	floatNature    = Nature{Type: reflect.TypeOf(float64(0))}
+	stringNature   = Nature{Type: reflect.TypeOf("")}
+	arrayNature    = Nature{Type: reflect.TypeOf([]any{})}
+	mapNature      = Nature{Type: reflect.TypeOf(map[string]any{})}
+	timeNature     = Nature{Type: reflect.TypeOf(time.Time{})}
+	durationNature = Nature{Type: reflect.TypeOf(time.Duration(0))}
+)
+
+var (
 	anyType      = reflect.TypeOf(new(any)).Elem()
 	timeType     = reflect.TypeOf(time.Time{})
 	durationType = reflect.TypeOf(time.Duration(0))
+	arrayType    = reflect.TypeOf([]any{})
 )
 
-func combined(a, b reflect.Type) reflect.Type {
-	if a.Kind() == b.Kind() {
-		return a
+// Nil is a special type to represent nil.
+type Nil struct{}
+
+func isNil(nt Nature) bool {
+	if nt.Type == nil {
+		return false
+	}
+	return nt.Type == nilNature.Type
+}
+
+func combined(l, r Nature) Nature {
+	if isUnknown(l) || isUnknown(r) {
+		return unknown
 	}
-	if isFloat(a) || isFloat(b) {
-		return floatType
+	if isFloat(l) || isFloat(r) {
+		return floatNature
 	}
-	return integerType
+	return integerNature
 }
 
-func anyOf(t reflect.Type, fns ...func(reflect.Type) bool) bool {
+func anyOf(nt Nature, fns ...func(Nature) bool) bool {
 	for _, fn := range fns {
-		if fn(t) {
+		if fn(nt) {
 			return true
 		}
 	}
 	return false
 }
 
-func or(l, r reflect.Type, fns ...func(reflect.Type) bool) bool {
-	if isAny(l) && isAny(r) {
+func or(l, r Nature, fns ...func(Nature) bool) bool {
+	if isUnknown(l) && isUnknown(r) {
 		return true
 	}
-	if isAny(l) && anyOf(r, fns...) {
+	if isUnknown(l) && anyOf(r, fns...) {
 		return true
 	}
-	if isAny(r) && anyOf(l, fns...) {
+	if isUnknown(r) && anyOf(l, fns...) {
 		return true
 	}
 	return false
 }
 
-func isAny(t reflect.Type) bool {
-	if t != nil {
-		switch t.Kind() {
-		case reflect.Interface:
-			return true
-		}
+func isUnknown(nt Nature) bool {
+	switch {
+	case nt.Type == nil:
+		return true
+	case nt.Kind() == reflect.Interface:
+		return true
 	}
 	return false
 }
 
-func isInteger(t reflect.Type) bool {
-	if t != nil {
-		switch t.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			fallthrough
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			return true
-		}
+func isInteger(nt Nature) bool {
+	switch nt.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		fallthrough
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return true
 	}
 	return false
 }
 
-func isFloat(t reflect.Type) bool {
-	if t != nil {
-		switch t.Kind() {
-		case reflect.Float32, reflect.Float64:
-			return true
-		}
+func isFloat(nt Nature) bool {
+	switch nt.Kind() {
+	case reflect.Float32, reflect.Float64:
+		return true
 	}
 	return false
 }
 
-func isNumber(t reflect.Type) bool {
-	return isInteger(t) || isFloat(t)
+func isNumber(nt Nature) bool {
+	return isInteger(nt) || isFloat(nt)
 }
 
-func isTime(t reflect.Type) bool {
-	if t != nil {
-		switch t {
-		case timeType:
-			return true
-		}
+func isTime(nt Nature) bool {
+	switch nt.Type {
+	case timeType:
+		return true
 	}
 	return false
 }
 
-func isDuration(t reflect.Type) bool {
-	if t != nil {
-		switch t {
-		case durationType:
-			return true
-		}
+func isDuration(nt Nature) bool {
+	switch nt.Type {
+	case durationType:
+		return true
 	}
 	return false
 }
 
-func isBool(t reflect.Type) bool {
-	if t != nil {
-		switch t.Kind() {
-		case reflect.Bool:
-			return true
-		}
+func isBool(nt Nature) bool {
+	switch nt.Kind() {
+	case reflect.Bool:
+		return true
 	}
 	return false
 }
 
-func isString(t reflect.Type) bool {
-	if t != nil {
-		switch t.Kind() {
-		case reflect.String:
-			return true
-		}
+func isString(nt Nature) bool {
+	switch nt.Kind() {
+	case reflect.String:
+		return true
 	}
 	return false
 }
 
-func isArray(t reflect.Type) bool {
-	if t != nil {
-		switch t.Kind() {
-		case reflect.Ptr:
-			return isArray(t.Elem())
-		case reflect.Slice, reflect.Array:
-			return true
-		}
+func isArray(nt Nature) bool {
+	switch nt.Kind() {
+	case reflect.Slice, reflect.Array:
+		return true
 	}
 	return false
 }
 
-func isMap(t reflect.Type) bool {
-	if t != nil {
-		switch t.Kind() {
-		case reflect.Ptr:
-			return isMap(t.Elem())
-		case reflect.Map:
-			return true
-		}
+func isMap(nt Nature) bool {
+	switch nt.Kind() {
+	case reflect.Map:
+		return true
 	}
 	return false
 }
 
-func isStruct(t reflect.Type) bool {
-	if t != nil {
-		switch t.Kind() {
-		case reflect.Ptr:
-			return isStruct(t.Elem())
-		case reflect.Struct:
-			return true
-		}
+func isStruct(nt Nature) bool {
+	switch nt.Kind() {
+	case reflect.Struct:
+		return true
 	}
 	return false
 }
 
-func isFunc(t reflect.Type) bool {
-	if t != nil {
-		switch t.Kind() {
-		case reflect.Ptr:
-			return isFunc(t.Elem())
-		case reflect.Func:
-			return true
-		}
+func isFunc(nt Nature) bool {
+	switch nt.Kind() {
+	case reflect.Func:
+		return true
 	}
 	return false
 }
 
-func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
-	if t != nil {
-		// First check all structs fields.
-		for i := 0; i < t.NumField(); i++ {
-			field := t.Field(i)
-			// Search all fields, even embedded structs.
-			if conf.FieldName(field) == name {
-				return field, true
-			}
+func fetchField(nt Nature, name string) (reflect.StructField, bool) {
+	// First check all structs fields.
+	for i := 0; i < nt.NumField(); i++ {
+		field := nt.Field(i)
+		// Search all fields, even embedded structs.
+		if conf.FieldName(field) == name {
+			return field, true
 		}
+	}
 
-		// Second check fields of embedded structs.
-		for i := 0; i < t.NumField(); i++ {
-			anon := t.Field(i)
-			if anon.Anonymous {
-				anonType := anon.Type
-				if anonType.Kind() == reflect.Pointer {
-					anonType = anonType.Elem()
-				}
-				if field, ok := fetchField(anonType, name); ok {
-					field.Index = append(anon.Index, field.Index...)
-					return field, true
-				}
+	// Second check fields of embedded structs.
+	for i := 0; i < nt.NumField(); i++ {
+		anon := nt.Field(i)
+		if anon.Anonymous {
+			anonType := anon.Type
+			if anonType.Kind() == reflect.Pointer {
+				anonType = anonType.Elem()
+			}
+			if field, ok := fetchField(Nature{Type: anonType}, name); ok {
+				field.Index = append(anon.Index, field.Index...)
+				return field, true
 			}
 		}
 	}
+
 	return reflect.StructField{}, false
 }
 
@@ -212,16 +201,15 @@ func kind(t reflect.Type) reflect.Kind {
 	return t.Kind()
 }
 
-func isComparable(l, r reflect.Type) bool {
-	if l == nil || r == nil {
-		return true
-	}
+func isComparable(l, r Nature) bool {
 	switch {
 	case l.Kind() == r.Kind():
 		return true
 	case isNumber(l) && isNumber(r):
 		return true
-	case isAny(l) || isAny(r):
+	case isNil(l) || isNil(r):
+		return true
+	case isUnknown(l) || isUnknown(r):
 		return true
 	}
 	return false
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 29a6d4cdc..b4ec6dbd4 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -377,16 +377,13 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) {
 }
 
 func (c *compiler) FloatNode(node *ast.FloatNode) {
-	t := node.Type()
-	if t == nil {
-		c.emitPush(node.Value)
-		return
-	}
-	switch t.Kind() {
+	switch node.Kind() {
 	case reflect.Float32:
 		c.emitPush(float32(node.Value))
 	case reflect.Float64:
 		c.emitPush(node.Value)
+	default:
+		c.emitPush(node.Value)
 	}
 }
 
@@ -1202,7 +1199,7 @@ func (c *compiler) PairNode(node *ast.PairNode) {
 }
 
 func (c *compiler) derefInNeeded(node ast.Node) {
-	switch kind(node.Type()) {
+	switch node.Kind() {
 	case reflect.Ptr, reflect.Interface:
 		c.emit(OpDeref)
 	}
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index ba5d6dc54..526c5d67d 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -442,10 +442,11 @@ func TestCompile_OpCallFast(t *testing.T) {
 
 func TestCompile_optimizes_jumps(t *testing.T) {
 	env := map[string]any{
-		"a": true,
-		"b": true,
-		"c": true,
-		"d": true,
+		"a":   true,
+		"b":   true,
+		"c":   true,
+		"d":   true,
+		"i64": int64(1),
 	}
 	tests := []struct {
 		code string
@@ -497,36 +498,33 @@ func TestCompile_optimizes_jumps(t *testing.T) {
 			`filter([1, 2, 3, 4, 5], # > 3 && # != 4 && # != 5)`,
 			`0   OpPush  <0>  [1 2 3 4 5]
 1   OpBegin
-2   OpJumpIfEnd  <26>  (29)
+2   OpJumpIfEnd  <23>  (26)
 3   OpPointer
-4   OpDeref
-5   OpPush  <1>  3
-6   OpMore
-7   OpJumpIfFalse  <18>  (26)
-8   OpPop
-9   OpPointer
-10  OpDeref
-11  OpPush  <2>  4
-12  OpEqual
-13  OpNot
-14  OpJumpIfFalse  <11>  (26)
-15  OpPop
-16  OpPointer
-17  OpDeref
-18  OpPush  <3>  5
-19  OpEqual
-20  OpNot
-21  OpJumpIfFalse  <4>  (26)
-22  OpPop
-23  OpIncrementCount
-24  OpPointer
-25  OpJump  <1>  (27)
-26  OpPop
-27  OpIncrementIndex
-28  OpJumpBackward  <27>  (2)
-29  OpGetCount
-30  OpEnd
-31  OpArray
+4   OpPush  <1>  3
+5   OpMore
+6   OpJumpIfFalse  <16>  (23)
+7   OpPop
+8   OpPointer
+9   OpPush  <2>  4
+10  OpEqualInt
+11  OpNot
+12  OpJumpIfFalse  <10>  (23)
+13  OpPop
+14  OpPointer
+15  OpPush  <3>  5
+16  OpEqualInt
+17  OpNot
+18  OpJumpIfFalse  <4>  (23)
+19  OpPop
+20  OpIncrementCount
+21  OpPointer
+22  OpJump  <1>  (24)
+23  OpPop
+24  OpIncrementIndex
+25  OpJumpBackward  <24>  (2)
+26  OpGetCount
+27  OpEnd
+28  OpArray
 `,
 		},
 		{
@@ -650,3 +648,12 @@ func TestCompile_IntegerArgsFunc(t *testing.T) {
 		})
 	}
 }
+
+func TestCompile_call_on_nil(t *testing.T) {
+	env := map[string]any{
+		"foo": nil,
+	}
+	_, err := expr.Compile(`foo()`, expr.Env(env))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "foo is nil; cannot call nil as function")
+}
diff --git a/expr_test.go b/expr_test.go
index 8b7856a43..3724467fc 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2296,14 +2296,6 @@ func TestIssue432(t *testing.T) {
 	assert.Equal(t, float64(10), out)
 }
 
-func TestIssue453(t *testing.T) {
-	env := map[string]any{
-		"foo": nil,
-	}
-	_, err := expr.Compile(`foo()`, expr.Env(env))
-	require.Error(t, err)
-}
-
 func TestIssue461(t *testing.T) {
 	type EnvStr string
 	type EnvField struct {
diff --git a/optimizer/const_expr.go b/optimizer/const_expr.go
index 501ea3c58..1b45385f6 100644
--- a/optimizer/const_expr.go
+++ b/optimizer/const_expr.go
@@ -30,11 +30,6 @@ func (c *constExpr) Visit(node *Node) {
 		}
 	}()
 
-	patch := func(newNode Node) {
-		c.applied = true
-		Patch(node, newNode)
-	}
-
 	if call, ok := (*node).(*CallNode); ok {
 		if name, ok := call.Callee.(*IdentifierNode); ok {
 			fn, ok := c.fns[name.Value]
@@ -78,7 +73,8 @@ func (c *constExpr) Visit(node *Node) {
 					return
 				}
 				constNode := &ConstantNode{Value: value}
-				patch(constNode)
+				patchWithType(node, constNode)
+				c.applied = true
 			}
 		}
 	}
diff --git a/optimizer/filter_first.go b/optimizer/filter_first.go
index 7ea8f6fa4..b04a5cb34 100644
--- a/optimizer/filter_first.go
+++ b/optimizer/filter_first.go
@@ -12,7 +12,7 @@ func (*filterFirst) Visit(node *Node) {
 			if filter, ok := member.Node.(*BuiltinNode); ok &&
 				filter.Name == "filter" &&
 				len(filter.Arguments) == 2 {
-				Patch(node, &BuiltinNode{
+				patchCopyType(node, &BuiltinNode{
 					Name:      "find",
 					Arguments: filter.Arguments,
 					Throws:    true, // to match the behavior of filter()[0]
@@ -27,7 +27,7 @@ func (*filterFirst) Visit(node *Node) {
 		if filter, ok := first.Arguments[0].(*BuiltinNode); ok &&
 			filter.Name == "filter" &&
 			len(filter.Arguments) == 2 {
-			Patch(node, &BuiltinNode{
+			patchCopyType(node, &BuiltinNode{
 				Name:      "find",
 				Arguments: filter.Arguments,
 				Throws:    false, // as first() will return nil if not found
diff --git a/optimizer/filter_last.go b/optimizer/filter_last.go
index 9a1cc5e29..8c046bf88 100644
--- a/optimizer/filter_last.go
+++ b/optimizer/filter_last.go
@@ -12,7 +12,7 @@ func (*filterLast) Visit(node *Node) {
 			if filter, ok := member.Node.(*BuiltinNode); ok &&
 				filter.Name == "filter" &&
 				len(filter.Arguments) == 2 {
-				Patch(node, &BuiltinNode{
+				patchCopyType(node, &BuiltinNode{
 					Name:      "findLast",
 					Arguments: filter.Arguments,
 					Throws:    true, // to match the behavior of filter()[-1]
@@ -27,7 +27,7 @@ func (*filterLast) Visit(node *Node) {
 		if filter, ok := first.Arguments[0].(*BuiltinNode); ok &&
 			filter.Name == "filter" &&
 			len(filter.Arguments) == 2 {
-			Patch(node, &BuiltinNode{
+			patchCopyType(node, &BuiltinNode{
 				Name:      "findLast",
 				Arguments: filter.Arguments,
 				Throws:    false, // as last() will return nil if not found
diff --git a/optimizer/filter_len.go b/optimizer/filter_len.go
index 6577163ec..c66fde961 100644
--- a/optimizer/filter_len.go
+++ b/optimizer/filter_len.go
@@ -13,7 +13,7 @@ func (*filterLen) Visit(node *Node) {
 		if filter, ok := ln.Arguments[0].(*BuiltinNode); ok &&
 			filter.Name == "filter" &&
 			len(filter.Arguments) == 2 {
-			Patch(node, &BuiltinNode{
+			patchCopyType(node, &BuiltinNode{
 				Name:      "count",
 				Arguments: filter.Arguments,
 			})
diff --git a/optimizer/filter_map.go b/optimizer/filter_map.go
index d988dc692..e916dd75b 100644
--- a/optimizer/filter_map.go
+++ b/optimizer/filter_map.go
@@ -14,7 +14,7 @@ func (*filterMap) Visit(node *Node) {
 			if filter, ok := mapBuiltin.Arguments[0].(*BuiltinNode); ok &&
 				filter.Name == "filter" &&
 				filter.Map == nil /* not already optimized */ {
-				Patch(node, &BuiltinNode{
+				patchCopyType(node, &BuiltinNode{
 					Name:      "filter",
 					Arguments: filter.Arguments,
 					Map:       closure.Node,
diff --git a/optimizer/fold.go b/optimizer/fold.go
index 910c92402..2f4562c22 100644
--- a/optimizer/fold.go
+++ b/optimizer/fold.go
@@ -1,20 +1,12 @@
 package optimizer
 
 import (
-	"fmt"
 	"math"
-	"reflect"
 
 	. "github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/file"
 )
 
-var (
-	integerType = reflect.TypeOf(0)
-	floatType   = reflect.TypeOf(float64(0))
-	stringType  = reflect.TypeOf("")
-)
-
 type fold struct {
 	applied bool
 	err     *file.Error
@@ -23,20 +15,11 @@ type fold struct {
 func (fold *fold) Visit(node *Node) {
 	patch := func(newNode Node) {
 		fold.applied = true
-		Patch(node, newNode)
+		patchWithType(node, newNode)
 	}
-	patchWithType := func(newNode Node) {
-		patch(newNode)
-		switch newNode.(type) {
-		case *IntegerNode:
-			newNode.SetType(integerType)
-		case *FloatNode:
-			newNode.SetType(floatType)
-		case *StringNode:
-			newNode.SetType(stringType)
-		default:
-			panic(fmt.Sprintf("unknown type %T", newNode))
-		}
+	patchCopy := func(newNode Node) {
+		fold.applied = true
+		patchCopyType(node, newNode)
 	}
 
 	switch n := (*node).(type) {
@@ -44,17 +27,17 @@ func (fold *fold) Visit(node *Node) {
 		switch n.Operator {
 		case "-":
 			if i, ok := n.Node.(*IntegerNode); ok {
-				patchWithType(&IntegerNode{Value: -i.Value})
+				patch(&IntegerNode{Value: -i.Value})
 			}
 			if i, ok := n.Node.(*FloatNode); ok {
-				patchWithType(&FloatNode{Value: -i.Value})
+				patch(&FloatNode{Value: -i.Value})
 			}
 		case "+":
 			if i, ok := n.Node.(*IntegerNode); ok {
-				patchWithType(&IntegerNode{Value: i.Value})
+				patch(&IntegerNode{Value: i.Value})
 			}
 			if i, ok := n.Node.(*FloatNode); ok {
-				patchWithType(&FloatNode{Value: i.Value})
+				patch(&FloatNode{Value: i.Value})
 			}
 		case "!", "not":
 			if a := toBool(n.Node); a != nil {
@@ -69,28 +52,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&IntegerNode{Value: a.Value + b.Value})
+					patch(&IntegerNode{Value: a.Value + b.Value})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) + b.Value})
+					patch(&FloatNode{Value: float64(a.Value) + b.Value})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value + float64(b.Value)})
+					patch(&FloatNode{Value: a.Value + float64(b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value + b.Value})
+					patch(&FloatNode{Value: a.Value + b.Value})
 				}
 			}
 			{
@@ -105,28 +88,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&IntegerNode{Value: a.Value - b.Value})
+					patch(&IntegerNode{Value: a.Value - b.Value})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) - b.Value})
+					patch(&FloatNode{Value: float64(a.Value) - b.Value})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value - float64(b.Value)})
+					patch(&FloatNode{Value: a.Value - float64(b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value - b.Value})
+					patch(&FloatNode{Value: a.Value - b.Value})
 				}
 			}
 		case "*":
@@ -134,28 +117,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&IntegerNode{Value: a.Value * b.Value})
+					patch(&IntegerNode{Value: a.Value * b.Value})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) * b.Value})
+					patch(&FloatNode{Value: float64(a.Value) * b.Value})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value * float64(b.Value)})
+					patch(&FloatNode{Value: a.Value * float64(b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value * b.Value})
+					patch(&FloatNode{Value: a.Value * b.Value})
 				}
 			}
 		case "/":
@@ -163,28 +146,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) / float64(b.Value)})
+					patch(&FloatNode{Value: float64(a.Value) / float64(b.Value)})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: float64(a.Value) / b.Value})
+					patch(&FloatNode{Value: float64(a.Value) / b.Value})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value / float64(b.Value)})
+					patch(&FloatNode{Value: a.Value / float64(b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: a.Value / b.Value})
+					patch(&FloatNode{Value: a.Value / b.Value})
 				}
 			}
 		case "%":
@@ -205,28 +188,28 @@ func (fold *fold) Visit(node *Node) {
 				a := toInteger(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: math.Pow(float64(a.Value), float64(b.Value))})
+					patch(&FloatNode{Value: math.Pow(float64(a.Value), float64(b.Value))})
 				}
 			}
 			{
 				a := toInteger(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: math.Pow(float64(a.Value), b.Value)})
+					patch(&FloatNode{Value: math.Pow(float64(a.Value), b.Value)})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toInteger(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: math.Pow(a.Value, float64(b.Value))})
+					patch(&FloatNode{Value: math.Pow(a.Value, float64(b.Value))})
 				}
 			}
 			{
 				a := toFloat(n.Left)
 				b := toFloat(n.Right)
 				if a != nil && b != nil {
-					patchWithType(&FloatNode{Value: math.Pow(a.Value, b.Value)})
+					patch(&FloatNode{Value: math.Pow(a.Value, b.Value)})
 				}
 			}
 		case "and", "&&":
@@ -234,9 +217,9 @@ func (fold *fold) Visit(node *Node) {
 			b := toBool(n.Right)
 
 			if a != nil && a.Value { // true and x
-				patch(n.Right)
+				patchCopy(n.Right)
 			} else if b != nil && b.Value { // x and true
-				patch(n.Left)
+				patchCopy(n.Left)
 			} else if (a != nil && !a.Value) || (b != nil && !b.Value) { // "x and false" or "false and x"
 				patch(&BoolNode{Value: false})
 			}
@@ -245,9 +228,9 @@ func (fold *fold) Visit(node *Node) {
 			b := toBool(n.Right)
 
 			if a != nil && !a.Value { // false or x
-				patch(n.Right)
+				patchCopy(n.Right)
 			} else if b != nil && !b.Value { // x or false
-				patch(n.Left)
+				patchCopy(n.Left)
 			} else if (a != nil && a.Value) || (b != nil && b.Value) { // "x or true" or "true or x"
 				patch(&BoolNode{Value: true})
 			}
@@ -302,20 +285,21 @@ func (fold *fold) Visit(node *Node) {
 		}
 
 	case *BuiltinNode:
+		// TODO: Move this to a separate visitor filter_filter.go
 		switch n.Name {
 		case "filter":
 			if len(n.Arguments) != 2 {
 				return
 			}
 			if base, ok := n.Arguments[0].(*BuiltinNode); ok && base.Name == "filter" {
-				patch(&BuiltinNode{
+				patchCopy(&BuiltinNode{
 					Name: "filter",
 					Arguments: []Node{
 						base.Arguments[0],
 						&BinaryNode{
 							Operator: "&&",
-							Left:     base.Arguments[1],
-							Right:    n.Arguments[1],
+							Left:     base.Arguments[1].(*ClosureNode).Node,
+							Right:    n.Arguments[1].(*ClosureNode).Node,
 						},
 					},
 				})
diff --git a/optimizer/fold_test.go b/optimizer/fold_test.go
new file mode 100644
index 000000000..d3f44fcf4
--- /dev/null
+++ b/optimizer/fold_test.go
@@ -0,0 +1,82 @@
+package optimizer_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
+)
+
+func TestOptimize_constant_folding(t *testing.T) {
+	tree, err := parser.Parse(`[1,2,3][5*5-25]`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.MemberNode{
+		Node:     &ast.ConstantNode{Value: []any{1, 2, 3}},
+		Property: &ast.IntegerNode{Value: 0},
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_constant_folding_with_floats(t *testing.T) {
+	tree, err := parser.Parse(`1 + 2.0 * ((1.0 * 2) / 2) - 0`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.FloatNode{Value: 3.0}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+	assert.Equal(t, reflect.Float64, tree.Node.Type().Kind())
+}
+
+func TestOptimize_constant_folding_with_bools(t *testing.T) {
+	tree, err := parser.Parse(`(true and false) or (true or false) or (false and false) or (true and (true == false))`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BoolNode{Value: true}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_constant_folding_filter_filter(t *testing.T) {
+	tree, err := parser.Parse(`filter(filter(1..2, true), true)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.BuiltinNode{
+		Name: "filter",
+		Arguments: []ast.Node{
+			&ast.BinaryNode{
+				Operator: "..",
+				Left: &ast.IntegerNode{
+					Value: 1,
+				},
+				Right: &ast.IntegerNode{
+					Value: 2,
+				},
+			},
+			&ast.BoolNode{
+				Value: true,
+			},
+		},
+		Throws: false,
+		Map:    nil,
+	}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
diff --git a/optimizer/in_array.go b/optimizer/in_array.go
index 8933d9b91..e91320c0f 100644
--- a/optimizer/in_array.go
+++ b/optimizer/in_array.go
@@ -32,10 +32,12 @@ func (*inArray) Visit(node *Node) {
 						for _, a := range array.Nodes {
 							value[a.(*IntegerNode).Value] = struct{}{}
 						}
-						Patch(node, &BinaryNode{
+						m := &ConstantNode{Value: value}
+						m.SetType(reflect.TypeOf(value))
+						patchCopyType(node, &BinaryNode{
 							Operator: n.Operator,
 							Left:     n.Left,
-							Right:    &ConstantNode{Value: value},
+							Right:    m,
 						})
 					}
 
@@ -50,10 +52,12 @@ func (*inArray) Visit(node *Node) {
 						for _, a := range array.Nodes {
 							value[a.(*StringNode).Value] = struct{}{}
 						}
-						Patch(node, &BinaryNode{
+						m := &ConstantNode{Value: value}
+						m.SetType(reflect.TypeOf(value))
+						patchCopyType(node, &BinaryNode{
 							Operator: n.Operator,
 							Left:     n.Left,
-							Right:    &ConstantNode{Value: value},
+							Right:    m,
 						})
 					}
 
diff --git a/optimizer/in_range.go b/optimizer/in_range.go
index 01faabbdf..ed2f557ea 100644
--- a/optimizer/in_range.go
+++ b/optimizer/in_range.go
@@ -22,7 +22,7 @@ func (*inRange) Visit(node *Node) {
 			if rangeOp, ok := n.Right.(*BinaryNode); ok && rangeOp.Operator == ".." {
 				if from, ok := rangeOp.Left.(*IntegerNode); ok {
 					if to, ok := rangeOp.Right.(*IntegerNode); ok {
-						Patch(node, &BinaryNode{
+						patchCopyType(node, &BinaryNode{
 							Operator: "and",
 							Left: &BinaryNode{
 								Operator: ">=",
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index 4ceb3fa43..9a9677c1b 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -1,6 +1,9 @@
 package optimizer
 
 import (
+	"fmt"
+	"reflect"
+
 	. "github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/conf"
 )
@@ -41,3 +44,36 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &sumMap{})
 	return nil
 }
+
+var (
+	boolType    = reflect.TypeOf(true)
+	integerType = reflect.TypeOf(0)
+	floatType   = reflect.TypeOf(float64(0))
+	stringType  = reflect.TypeOf("")
+)
+
+func patchWithType(node *Node, newNode Node) {
+	switch n := newNode.(type) {
+	case *BoolNode:
+		newNode.SetType(boolType)
+	case *IntegerNode:
+		newNode.SetType(integerType)
+	case *FloatNode:
+		newNode.SetType(floatType)
+	case *StringNode:
+		newNode.SetType(stringType)
+	case *ConstantNode:
+		newNode.SetType(reflect.TypeOf(n.Value))
+	case *BinaryNode:
+		newNode.SetType(n.Type())
+	default:
+		panic(fmt.Sprintf("unknown type %T", newNode))
+	}
+	Patch(node, newNode)
+}
+
+func patchCopyType(node *Node, newNode Node) {
+	t := (*node).Type()
+	newNode.SetType(t)
+	Patch(node, newNode)
+}
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 0ff4b4901..56a890492 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -2,7 +2,6 @@ package optimizer_test
 
 import (
 	"fmt"
-	"reflect"
 	"strings"
 	"testing"
 
@@ -92,46 +91,6 @@ func TestOptimize(t *testing.T) {
 	}
 }
 
-func TestOptimize_constant_folding(t *testing.T) {
-	tree, err := parser.Parse(`[1,2,3][5*5-25]`)
-	require.NoError(t, err)
-
-	err = optimizer.Optimize(&tree.Node, nil)
-	require.NoError(t, err)
-
-	expected := &ast.MemberNode{
-		Node:     &ast.ConstantNode{Value: []any{1, 2, 3}},
-		Property: &ast.IntegerNode{Value: 0},
-	}
-
-	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
-}
-
-func TestOptimize_constant_folding_with_floats(t *testing.T) {
-	tree, err := parser.Parse(`1 + 2.0 * ((1.0 * 2) / 2) - 0`)
-	require.NoError(t, err)
-
-	err = optimizer.Optimize(&tree.Node, nil)
-	require.NoError(t, err)
-
-	expected := &ast.FloatNode{Value: 3.0}
-
-	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
-	assert.Equal(t, reflect.Float64, tree.Node.Type().Kind())
-}
-
-func TestOptimize_constant_folding_with_bools(t *testing.T) {
-	tree, err := parser.Parse(`(true and false) or (true or false) or (false and false) or (true and (true == false))`)
-	require.NoError(t, err)
-
-	err = optimizer.Optimize(&tree.Node, nil)
-	require.NoError(t, err)
-
-	expected := &ast.BoolNode{Value: true}
-
-	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
-}
-
 func TestOptimize_in_array(t *testing.T) {
 	config := conf.New(map[string]int{"v": 0})
 
diff --git a/optimizer/predicate_combination.go b/optimizer/predicate_combination.go
index 6e8a7f7cf..62e296d1f 100644
--- a/optimizer/predicate_combination.go
+++ b/optimizer/predicate_combination.go
@@ -29,7 +29,7 @@ func (v *predicateCombination) Visit(node *Node) {
 							},
 						}
 						v.Visit(&closure.Node)
-						Patch(node, &BuiltinNode{
+						patchCopyType(node, &BuiltinNode{
 							Name: left.Name,
 							Arguments: []Node{
 								left.Arguments[0],
diff --git a/optimizer/sum_array.go b/optimizer/sum_array.go
index 0a05d1f2e..3c96795ef 100644
--- a/optimizer/sum_array.go
+++ b/optimizer/sum_array.go
@@ -14,7 +14,7 @@ func (*sumArray) Visit(node *Node) {
 		len(sumBuiltin.Arguments) == 1 {
 		if array, ok := sumBuiltin.Arguments[0].(*ArrayNode); ok &&
 			len(array.Nodes) >= 2 {
-			Patch(node, sumArrayFold(array))
+			patchCopyType(node, sumArrayFold(array))
 		}
 	}
 }
diff --git a/optimizer/sum_map.go b/optimizer/sum_map.go
index a41a53732..6de97d373 100644
--- a/optimizer/sum_map.go
+++ b/optimizer/sum_map.go
@@ -13,7 +13,7 @@ func (*sumMap) Visit(node *Node) {
 		if mapBuiltin, ok := sumBuiltin.Arguments[0].(*BuiltinNode); ok &&
 			mapBuiltin.Name == "map" &&
 			len(mapBuiltin.Arguments) == 2 {
-			Patch(node, &BuiltinNode{
+			patchCopyType(node, &BuiltinNode{
 				Name: "sum",
 				Arguments: []Node{
 					mapBuiltin.Arguments[0],
diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
index 7b0174923..59349d3d5 100644
--- a/test/fuzz/fuzz_corpus.txt
+++ b/test/fuzz/fuzz_corpus.txt
@@ -6262,9 +6262,7 @@ get(array, true ? i : 1)
 get(false ? "bar" : f64, list)
 get(false ? "bar" : i32, greet)
 get(false ? "foo" : i, ok)
-get(false ? 0.5 : i64, true not in String)
 get(false ? 1 : greet, ok)
-get(false ? div : true, min("foo"))
 get(false ? greet : score, score)
 get(false ? half : list, i32)
 get(false ? list : 1, i32)
@@ -6350,11 +6348,7 @@ get(map(list, true), i64)
 get(ok ? 0.5 : add, f32)
 get(ok ? add : 0.5, ok)
 get(ok ? add : false, div)
-get(ok ? array : 0.5, Bar)
 get(ok ? array : i, add)
-get(ok ? div : foo, filter("bar", ok))
-get(ok ? greet : 0.5, foo in String)
-get(ok ? greet : f32, Bar)
 get(ok ? i : f64, greet)?.f64
 get(ok ? i32 : "foo", score)
 get(ok ? i32 : add, div)
@@ -6365,14 +6359,11 @@ get(sort(array), i32)
 get(true ? 0.5 : score, foo)
 get(true ? 1 : f64, foo)
 get(true ? 1 : greet, greet)?.foo
-get(true ? 1 : score, String?.Qux())
 get(true ? add : score, i)
 get(true ? array : 1, half)
 get(true ? array : i64, ok)
 get(true ? div : foo, list)
 get(true ? f32 : 1, greet)
-get(true ? f64 : greet, String)
-get(true ? f64 : ok, Bar?.ok)
 get(true ? i : f64, add)
 get(true ? i64 : score, i)
 get(true ? list : ok, ok)
@@ -7595,7 +7586,6 @@ i32 != max(f64, 0.5)
 i32 != min(1, 0.5, f64)
 i32 != min(i)
 i32 != nil ? half : 1
-i32 != nil ? list : half(nil)
 i32 % -i
 i32 % -i32
 i32 % 1 != i64
@@ -9647,7 +9637,6 @@ map([i64], #)
 map([i], max(#))
 map([list, nil], i64)
 map([list], #)
-map([nil], #?.div(#))
 map([score, "bar"], #)
 map([score], #)
 map([score], array)
diff --git a/test/fuzz/fuzz_expr_seed_corpus.zip b/test/fuzz/fuzz_expr_seed_corpus.zip
index 0fd46ab3a7ed432a2219e2d07e064dd839d54010..d812de92e3a296725db055e96b7a03d87bc86d43 100644
GIT binary patch
literal 2827225
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%0A0F1IjYgaT3_M
z`bRUk;~x`#0=sa=9d-(Cji_i55E}B5&Z$=c4;acg7a4U-9XD?s1$bar#JPQf=)!bn
z{aiI}(;XsR(VvpC>;gCsQOB!O<g-bj<zR^3+^2R}Wjb^AkP8=3v~ua%C8`48YMyNG
z7Y1CFSv5RY#r#Fz7S*kDp$AxWhQiH%e3MhHa(!rC`X3j=5V!f5f>DFhhR`?T#mS3q
z^7mKfTn4UX+(+lb3lW-8vECom)*0W>EJTSb#!YlC>X4CTW6J5lb*yspy&$;k!Zt5h
z1*ovpfSo%bWif)4aS(PNGPuX+vLa#)*b@D2ZUdtrhMdiD0j-$ng69uyZHR1T_Qzfr
z7`9e^C}9zTWfoWm7P#Qym$#ipuuR&zo3Nl0sK)lnn-WTcN<S?7mN2}9%EJN6a~uVB
zGGuGcQu&)jJzg(;bfUX?EEQuHto0iDxQNwGGzt`-j&QdhP>|5M>87_qy|v#j=l+7j
z3-N_3|D;jQs{YBgEeq|Kv`HyLvv#oZfeJ@LpO0u%v6T>#hCUx5f1uvV1-VO$A9y&J
zAndxe#^w*~5wFms9%x+d&O;UVKAS5oJ+pR{H2c+-MZt#EE@TUM37`3XmYCynu=BI)
z*Gz11h*D@lyHtd3rMrnvnNMp`2K0KU6|D&UDM{KcV$;yUwO{kDKT^#+$d9pKIcGp?
zViV$jgWnow_nQ`l|I#U8`EMLik1VvMDR6^byk^*HKv!v5u>x>|UAtyLgWy<kX5769
z+$vf%!OdOA*ntHqBd5rrLk30B05>|09*ru`L3YbM5*ymI`}F*x?*gvd6>PfQK=e6d
z<%t@AjduB(iLFI7ZO3aBSRakhWmq%a;*0`yu5Wwmrw0+bwZfaW1KrN&Zxs3(dEHv*
zP4qyx5Ze!Z)UL0;=~37&4G+t9z?-WRe)tHu!md>V#+pg>$tLv&16SC!Y8tv|+6^&C
zziQv7BkV{SFR+bNwV*(O^T;ca5}vm2rdNj6OU;igkCgKQJrE#7oNIU7-2z!|?cYt0
zQy;Gt$@|w_D~Ql#x5=ZWupDd{b65GMEJ(BVkHc!VgDZd5Ts*xTq}gOi9G>CEHIU@<
z`;(8FUzd-INsg58V(+LrocP|nWcIdz?-DsY-^~?F?X)5vaD-igX80I{$F50D^MJE?
zyYx&47jze6I)m~jY99Fs5XUY&1Nf?^X%Vlky*>_vw*87Z6C2dCy$wg0*TBWa*e{tg
z(T!yF$?Sujk>!z6o?h5717=6!>DQ6ZBc;4R4@5Wlyx^U0okf;MTIC7bw7mQs=|3U#
z$T%++6TT2M^xmp%5W1u$C!-L$I0X$vI`O{Q%a{6@UA=P39G3Tnqd(u**ZkORT&!Jx
z76?BwR%Gsgv9yej9q5o|=9E~w`piHFnfuX=w?-lG$jUsK4!$+hd&Bjj<|4-0b!VpK
zA-_-sbKluc_-NNoQ=1dZ(4MK=dPmuU?r2C~`Co5jd}O?LJOj9SX#JswP2R`aHD>|W
z#6a%+?`qd~%t9Y)|8%Q{4ffgtXFa|Fg-c|lr|%aC$LKX;#_Zc$klm4Sp1=c1oCyD5
za*j)8p^ud(P~i!0Hkp%`y)+A~pIvpP`#2QX@)YjMmbbnFez1$qG;Bck=W;dw0+}5d
z-JP!@7<uYST!V$C@*&o)ISZIAF7l!*NYX()KJs>|^*CUpU2PWl0kLBs))+~ALZKf|
zmJ-Q@{^W!z)_&WZflik%*K+R3^E8n9gRI=Vw+dj9{n9z~Q#$z9k6dhSzE>A(zitkI
z1Cn;DJ7yhPgvc@gErMQ{sn*p=_-ZLak1Pdv=tdTJ>*Ka3Ko*d}A3h71Jy63&Pk@PR
ztkOtux)je`BO-52D>D{2L&;iPbktT{`tF5Z2wi$30`!2ZX(5k3^!W=2J+dvnXqaJz
z`{kv-?gIp}Undugae)qM+#7d}uZB#ItnicRD8ggUoV|w7BWw5x9WCmV<0(CmV<Kz$
z2^|!Vv#%^%W4<O6YnQeKz3zP6Kp2lMJ-j~n*M{aXR;*pzX8uGuiX8DI%8Z3Nfpev1
z<u?!FmFo_}<pAT}Dhl<D9adHW3D+)gLpGc0ne~@`p9oxHzf=yv(<an7K=07#kGD(}
zcdT9Y7W@VA^0;?9BONBXWl47HlNbKm#ysVVwF}__hj6Kt8#Rp<H!y@w`DE90sPL7g
z=8L<r_KW5MPZ7EXNx6GK{>JhJZ#@FY8y8t>a9(T{%b-{8$4m5|gU};O4bJ<nVEk93
z*rGk4tF(*d0{($tCb)j?mDZrEwBI<VLxW~`(zv<bA*V#v5r`8>N(X^5McLq;=B0+y
z^3tCi_$zfJd^QN+Q7-5{V%RSr|Jns~K~GS3WDWuzSa;uPkZ9uNE{0RF$rW(>^~C4V
z{{x=33+fEpQDrJpcFPaQGm$j}WV|-VCAXhkzabAYJ+hI%0}euP_o4d=A@m4YPo`@j
zNVa#Yw*&2J>_WSs+eOJ10d8!{YNpoy6uCXJhCqz}P(WrYQQ-^Zn8@}54mfa3!)3Sr
zG{@bs_FLx+$G9&-sOgrt-{hq~yjv*(+?T5wp8FtyZ+r2J%)lRZNuFV`WRR?&IcjEF
z3+7#RabBQ;(zh(&-8Z!dl~@2G#V*b>j0cmzcI&=62vV0_qX)o&<FBVAY(|ccjQ{kK
zE8<Xrzl-ld=rU3`d6&@TvdW%fT%`pkK$zRLdjZ#Y=-}e#mRTM(KVcsin-EzBpw7;h
zZb{pJno{{4Qz{*6zmG0pyNUbm>D=PWlKM4fvG%*@bX=ju73oFW0_@MTC=P4^WSeCn
zzBvcjRI4@G)Y(OShP}?qE{eTWA?AFz@jM_8SKH?)?}V3~H$FUf$h<P@iGrWd1|v%R
zDT6P&urHWb4mF+-bF9FK$*mKN+odneoHUExL=C=;8f#bh1>ED@l_YL6a`unTt5Ir3
zCr6Fimfi+zWb8se<9D3RV~lvg%iJxM-oIrx7;{Fb@N+i5=4&1F6c28Aay5Di8K0bV
z<NkoyP6~A=8slA>euWmC{?tW}EGxJ_LYqp_AXKKAz81R2#-FTheqA7zEBgyvtKlp>
zysKts{ZXHR{RdY8m`1#ap$lKMp$Byd?^SuZAlM;DKZQ>g#!&CTt6eIB)W%f+I<|^N
z6<ABLGc4hsG>|H|B0%bZeP5tj^~vfxyMYOi{SG^qVASae__T_2$uJc|uuV<4_<SX>
zO|{=<r~iamRX+b;&g}@A*(K0aLkO7NFx29_)aE%Kf<nlZ0(#KC$uc*0SW`C}H3#H$
zg{F2Hpqrb$ZwfRbY4nOUU}(~{@2-(3USxQO%{8vw?q^2QhM2pL2B$hDg2ZpX#Litz
z6+Z0eMQ-ix_bG}?=8!=B9dCpc*ho<xcr*W!@t|ptTOCUtFvmR&pMC5l;Crq%&@-BD
zcM?h7^!=8Y_eTMraK(WtJn{);n=?;5odpoeevh5HyjbggrP0*>U^imFzs`ULIi|*%
zv{A_Jh!O$59&FN(7al=&GxrLv*BxkJcfLw@*G3V;><nCRQKTvLhIUah*%XQy@eJ8c
z<w;34c7dRpY#cpB)@jBES8HuO*aX=w3B<@WWV`4#M48fCznO`3N}?r=C<8chioi^d
znE$}M-&O+VOJoc4&F#X3&E=4af~yjA*U>RHw2E?1c3;dldq6Y9RSEjwa76f3hj;%4
zUgjzUL)hT>J<I%6_XFZ^1%f^_^`d5U9Lsg#Ed(AB;T_dODD)(4W}YqEnrd|L{iRs@
zH)vJbr0(DQ+^R;C8-d-^ea8!S1kADDPN$|q;S@TK44E(ErRDzB%aCs(Y5}PK7o!uS
z+pQb-_eoHM>^IZ}Y<G5iwM2hj70e)(Up!bG%uiAzKN*Q7gZJKu{?C+(J#EroIo%6G
zf01WHdoLL<>DRlBF`GK^O-<`3X&vF3+tj(A8(F&SxhlrZX>DqbC~EFd#U}x6_=eNn
ziGguoSaL(PMyAWv@AYwAUXG^ufdLKm6}L`j&0>b6_=HhJ50JrS)<tsu>wHCv9za$(
z@%5WXz@5*Th}8ujOUYaRpGnC0h&ll05KlNpFLS>YZSyt)kEjEnU7oPrBdd(d-x^0>
zqS{Z%M)iy}6R3%dKIfs#mnHg^3r`NDsH9Poif(NHRCMui0&&IRr26$I%``fUei!P1
zZ+gVpzf`M+J<U<|88BsmobyI+G{*qSA$<5O5NIkW#J~J$*c`x7u71!hcb>8EsQRU-
zwzEK_a7Bdj2SlU<HbZ3npW7}hG)t1W_$m?(k@W%`e7Q5JbLj#gzi^d=0o$Dsm9txy
zp*Zxe|CJ>3gS+ZDyO2-~#XbAP#54BBYIEFqt!Txm=7>jJqY#mI#K0Yn8VdhC@F{u}
z`crts6%TsOf#dw9my6d#F=I^t0R{<Z>2%p=bi7=?7V?Uf|0=k+Kv{$g*cx5@tX&85
zwR-UiNF+Y@=P$0&MEj#Jb=eP!zl`(nv<I!|BhRh927Jtw47$rlvwU$<U=-#Cr4IsO
zX&hHED8ZdC1nD!boaded3uwRWF1UbH@}td3@xl+=l`^+2af&dD(NmCLXn&|#e)7Ge
zBS1b;WF8D`ifQi)%z9N`G$1ZB!jFjX?krtg^knu!(|)}5Ey9ne>bv-YJwZ(zrSn`b
zoCK2LIQwU3)s=PeyN1kH((SFrH!0NyH%M`I-Jq9lwXaOn4}E1q{=~j>kF})6Ld)oO
z-5~ynYEcKWD;GOZCTNxC&i_CrkS(bt6PUf+d*5YAF$HUJ%FZHeRMLg@-qBv@GY3YY
z{&&vF&p_lTeM=<25zLPiIaBZI@S7=4jN?iNm1m$f0NsZFMd7#4pkI)V=RN`T>gX4G
zzP@QM`UU2OKzRoDV+W>}3S8>h%e=}ujw>5feu4Jy6=_cy7~#nxd!%`ryykgZTpTk~
z7{7#HFxr>&_5pLOAIFsvs=p#=;eBZ#v{9B%b9VjMU(w1iTL$HKoa7{aNYC6)R<HC`
zl*k+Or!-S>%(j7k!7Z9ZL3|EE$>XkzC%&S`qCY7!RHUillZUZW`||U`vE&#n-PvV^
zGTnJcLtkd=nO*;E4-tFZppR>shtP3ctzpnH8O^h2?x@!-N<0SrDc<KQ4&{$f>`)kq
zog3&4TNgWh5j{%;Da2i5YUk)@kgmV`zL{@>4W0dVKevX;XUQm3yAQ4W3Md!$Oa9y+
z7%?<`q+2h<BZx#r3B;hoo6Wbq4q7~}7BTP}ej1cT`qL|A%TY0+$W@oyy1i)Juwuh6
zTF@!x(UzH7&-s1Kj?(pKKY3ZdjeOGRwT-h0Z2D92t?5Ek2CZX!^T7`1{WpbFC~IDz
zgKZIoqM9j)lmfEm&({p}53)tHqyT@YE!`QlXifpz^3b`nVxwJc*m!Tn*5dmrsZAQ{
zpXVUvSI+m|yWr97GDGjtO=p&gZFmhdA$Db<L=^ASIa3bzN@T~i(h;+_)}BSw)3Tvm
zT<AL@bF07V=Po)aB`s>mn3e+u+;NZ6`;kk&m{$J-^WMTZ`(=RM0|>fRYWetRB_as*
z;}(@aFfUY#vwz=KL3KZMsR1XAXw($!h3$$$30w=<o1A@k5%a>yIJ=P0gLPi5&`d4W
z?twZ!E7Ta~P?mV6ePM#!`uFQ)N`o9`*A9ASI-^}7GZRBnI&M%5CK^9Kuj|vk!Ad2U
z{gs8r<~E@0mG^2;EYqLj0=srlwYSHR-gLE|W2_`b^Q_f&fDB<54tm58-+(|FqSm8D
zwgNue1%sZ&H29O>RSc#|TEP!1G+Y2i0d~1y0N=Ub+&Egu@xM*KgCMp`1U+mg3n?){
z_CEYWnK~e2+7*F>Dax?vfti0F&w&tSm}Ri(@eswoG#g)UTJcvfu}!qrUWq8yj5Z#|
zXI;nzjb5Jr6<RVDkA(~9S87r3CgAny&G~*k+k!ofUEQacF1}qveU<nPm)Aj;6S0Rz
zZL0~0E&UUo*r4q^xqI0iplaBaexBX9YTW#%|9Ma~><T{x6;_Q#$2!ylRl~0BlfbBI
z9K2fYmU-)SoL$eS!a{?)d_18uptAj|v>r05M~lQ)9gwxMO$$#v_w_+hm;!}^7&2(&
z{;QxY*_C{%we*1;SAeL|yLS2=1N`V!iirJFv>rOBqs61kbp~19uHEw>-7N1qM1DP2
z7N?tuLmH7o=r>f8tt~bcC+`DAE86c#-QTeFiY(p-klfJ$(YetB?}i$9rB2Iy6o$_5
z7P7g&%!>i;u&ea~?(myfbH=-MRQ9T-f;7%9*HiH27uw_urC0Uln*mGg8a)qJ7CgCh
zxmIlHL^+6<qAZ<VoaZfF*=7eTH_9G!eYO5cvr}8v#84Nnb@Iv9QJiY5Nb*juuj&qD
zG^YIV)F&;$`Aag3;X-FAH|nB>=;NfKZy$XWEh4LKdn(IL0$0D?xmC;2%fST0uFNC9
z__)MzvGphIxO1?m|HvH$iVX(SHv1)h%8!tDyrH!Ce|7it`DS7{(AL;*@)KBPqlH30
zpf4htms#@iIP)SeWqcQw=EkY~^{S~YKn=7D^T<G9Ukui>Y&$pN8VC!!B+r9Qb5FI5
zW;Xk(N8dx{%Hzq5t5w-F$K1*k5E?}ezxm>KpmDKF@yJ{kR<v|_8#ix3g9LvDsw55j
z9eo~ZVC|`*_L=rvAu#T->+Z}a?vd7@D@c-di5+#5qS{ACn}=%6SO1n3J+JI2GgurS
zQ~#p<*^X7mq9~FzEj%DK@A_wC$d9#ezqSqGS_`pfDB+^l?7rK&_gA0ovIHwL>ag4t
z;ClLKw>5hy)6jUkZcZ^&ybxv3=(~I=jS#L?FQ?#&fHzvc^rg|O%{^DV{j;tLuG}XZ
z@ayh+^`cqH;_WKA06a~$#imOSwr<&f{22MfT8R~KaTaXkmLE#JSk=re@l~wl*TZ$b
z@MoaLE<D}W<ZrzFHoXvPdBX!OZq%8JEambyMv%>nwO2ZKaz-+gwq+KKw|}%%T3Q~w
zXLq7W+9c!vE{9`CPNI|ns;zxv=X?VAD_IeqzviT?d!BbcHMc<VcFkMp*~Q1x#jd!7
zh*$A1#av2boA+kQ3f9XmcnhJUw>^vP8w0*p5^q<!d8j>lj&Q!%q8U4}=!RE(-zs5X
zSGakw;$IqKnYHV(0m9lfZ4!|_Tx2B2YHhC`MYvqT5<L2V-M3@Qo<<(9w#vS}hNVl^
z<}GDTM&j)k-$_JzA=k`VUrgEZEOG(2@RB%Q6i8#q-WvPTod}mpTEZ2s4d4=SD}7b!
z0kbJqPF2Ga*XXmB6m0c1Fw?GBQ~Zib!M5M_l{EJo@piGAkDE56cf%pQ`;7LE;Qa$f
zx%Ykk#DKfa{y5&QSo42j(9j;@J5G8Z@^XvP{eAx`<h4uHJXkf+Qsydo-}nbW=CaGv
zd^}ib4ph6;0ikk<OCR1e)4|z0P8|odwSSP+w>1#0^z^F-HGTmha_g*FWBcce-jAM~
z%U6LYJgRp@C9_V*1*(@_V&*@&Ko#R>@lWTA^h)|B&L)+cJ;L{b(kx4fLU_)a&GMyh
zUTX`op<P|(nLDV@5Kk_kSW4^l#^6!Unco_Vw@b=AVCNfVI;9R@FMke!T6eNOsPhFg
z&C-{eJv|rD-+tws0xH%^w{>CDu^*aBk9bAR6Mi4&4o010#;Q?h2>sxQVXq;(xy*G&
zcH)C>nmg_<mk+|SDsK6xveY9A&*-pUBt7&HS~?bg1#FtAjfSnMD|XgH(aWMRfr_rf
z`3$3O?TcBi9YMgXnoGcfzXmW7c-`X9YXbty{Ze=Wn_+gPV#%z)Qf2=fCd@obo!ew|
z7u-K&+gRUHrF_|?T||rWNW1;wtiF2@B8$BOQ2=YP`qMvu%tnYZABKH+FpfDqG5a)x
zC>JO^qS?N^{O-2upf9ouvRpsX*hGwu%x7=4eP9&AW%AS+^Po9T>91ej0Md&6`>WDk
zz1yUEFly-3;s};WRWcX7ZP2t>&vFQsNmLg$xM)PvH%o45<sXzObylX<a5Pok=9Eq5
zgidS0!A-nfh9%uf_tO~^_~PzEcbOvFc)Jcu#}!?Nt4ysL<&5Svs%@=QFBXKGU7Z#9
z9kUDT*LMFA(1qDmSuU>sdb?w-JbEg%tk+zkF|DDJyzEk}#&L<Q4!5e3tw$wI+;yzo
zq&JbBG9<z#1~KLlWHUCS4;0<f(vLIMP9}+CXv3&2)Q$#Ujzo~mLaUE>h`Td)?nnZ)
z+kStWzeZ@B`uoCjKO#^jbLsmHL4Oi&mtFn2x<5@<cq`o*p0`GWk+$@+6JXWtsw@A=
zA!my$OSu=J%9)uZmfXuNw1xj|c$I^Ip?1BMYpX;0PJ*ENfnWZ=+Z_Ts8oSQQ#dUSX
z-f5q?`TqX%W$FHkDGabHtz2~RPmTI*7C-V3#XrTC3TP#&Oa0WWGiK|G;W{r*`34jj
z`xjM1Hi|3a%+xpeqvR6k(V0vQMnCbi>%>oYB0HHiRsg~g!S+f6G9g$dQwbJ*>pbS!
zqjmj6rEpa~eR!@4-|8)E`<6FzfRtjFQhDnn3=Ph=$*HSWP3Q!k-mavQplD)T^S35>
zObtW4T}S1?YEv!ebpS0Pyf<LW1dtHynkw%noUxYZkaRbv4;!^3mtYtDDGakKs$5*X
zU`=RTau8ZID`7o2qY%)l)w_JX2U;~*3Bsn>G<ta>+NA7`&NUaC@}79RfGT9G`{8@x
zRUxl1cXKOGeO?}<1iPBb!#A>F(RbrMAm>uKQP;}KT{j!<$u_NH?iba3NL6-a-sgq`
z=E^i<VXpby3qOio2$st(n+iQQG1q9XPH*cp2DsC%mhxZ?z{E_CtO1m=%cMep)CY>y
z*NWB~&-c$oOGMbpGBKo5PQOaGH6ISD+lT~NOO)J(yvp3n3V%Xw<?6EIO>m-Y*G5Sv
zRCgr#WdQ>wHR<*)$Og$=;tHEZt<~I{ZQj^-$i3tY)xEOTWRML!76|uF%sNe_0l9Z$
zlkRIl8)sKSd43RAt^x;Kz1(dVLbWp1MWwl^_%AhQ6J^icGk!autON~DS+PS_5uM=r
z^XtsOPP+)ovr~*>L2apg;`<T^mDw5(7O23dYk&MP8lf^LPZ>-~r?e`P6C?w>0Lt-z
zn7xVTrwyF$+2dd2Og7cU@pcK6iW^N?Mn^uIe4{6_m{)3r#m?@~Oy9YuWom<Pd8Bo4
zooj(zd*wEM-D3|ICC+MTF@?w5qpc37W<8R7ws8f}y;H9|jT|fsSO)39cQF0C0&?)T
zWuH5ZkR{Jp$RhKqOGgCmKKIBClfcUO$U@*CA`$qbTTAzvi<ZFCNr@^(X+~6CW6wOT
zWK2=h2MP9j#X{b7`*1(y$Z!~PImS_01j8Z0u9R}pxCn<m*^cCX(F+F&+xPXic9~I@
zU{^?~ux6Cy-`uUMzhbiJB-n2d^ZWpAKY1|MjZJ1hlfaWji6x8HPb<H#e9tCiBbT^f
zf?oHVX?u~4R?hm5ou+MLPIvrvHL{V**684PmqLGKt&tZIB$uYz&Vcy&K&Stv_<f7q
z%_?KqF#HsHac4fFa-PiWm1)j?^K2)9r-X9*Oy`~(qm8}rb?j4s`aBVo2aF~fTj!p8
z+^n++JQ<Y0B{7@`1Fd`eyj-><LJf9r33e5f$ImL+?#?mhUA=qjRIJ(4$W~r+Oty-t
zrZJA+{K)p>ei$gEw_obzMZXwpnwscL&4w>QalmD1hNHcf;|5PPPrDL$S}3tz=2}Jd
z`l0}3R(i`%eSRxhy|qfs+A{a-+{1IH^)2Hrm`u}i`w!hm3#Mg%``uk3=vJqqrsq-S
z`o!CfbqYM_FPOqx*%@ZcTT%YR$sB02?%8(m1@kq>1fCSib*m_>Zg;3>?CyW{oB_g?
zCx`N|yBeyM>XkB`N2t;b;rkYfUVqy~$v;yj%3sxs-QEtui>H7hTaCokzh$51AaU_D
zP%a{M+#arstx`LOt{_}unG&|K*2dV6tvK<yq?OrQ>Pe>ix*kse=JIq<p1tl}#adBZ
zcx7r+1kA0neO=9(*%i)wv&>h>!&U-&35*0QXbZOa&T2<ZHCzHu7bQHQb_K-S8BaF>
z(_`h>(8gP%Z+*MSs)c|9JSh}eNX5&D*n%&OyMa)78(KmY@7@@wYj@Wy12T;LLM?BV
zoQq@KZLP8W%sKSVJ%F`5Jrw!DDB#-%zPyOqEsb4vDU`>qJui4KZc4(|JipgD_tzo0
zgx!;^)u^>mlhtZK8EZi9`Locob1SW%S!523-n_6h;FJ9lEPtiMW(fK8+uTF8f=!G4
zW17BCX=Iqgn`ueE-bnqgG=jBu#wu*iz^IJa`udPcH9(b>y_SuwV5l>C%Is5Qs@4`V
zl~2N__>)KXY#CnAH&rPGOx=?UYvh*IuU0Js(zPPC4qsnMX6d}spl=b*&i^Yv2(Nga
z0;+rz0n@uZI&P-yb0#6@$`uQ5Fc?D;zn-16cO!ze($-^x18WwomJiNOMzCDkI$~23
zc4?nIr$9E~Nueqr30%MDJKq9TFrHOi1)|;!#?H8VD6-H>SMsO86aP{g3u5ZrEEl8v
zt+CP%%LTGA)u<=c+SHr~o>>`Pg$X5LqgweXhVJ<8Vn6WA%2wNgXH?Tg4U4S;l;>%i
zoH?NIrM@)nM?Uczh)JbG32Ua?{Rh{Fo_@o|ZxfKMEMf{PMKKZ3%AynK<DI*Gg+S%1
zhqcvthb<6E1X^%X&d#9ovEMJ{#%2bJskviQ-bALd8ee*TBu;$$j(sx`D3g}nR9tiF
zjV*`sAy6haN#NwSQf@mz^xXY;^eaB7LQk3Ktn~E9s<K6yl8^;WLU<yl3Q_d#8rTGv
ze0}g>u>AI0rQGEwRPkSWU3$O#E2qr^_ynHFsX|mhjD$23b&KBIK%SvLrTX*4PEzF}
z8>*O^ZJN`9Q7TXYt$cMFs&*tt+SNecRwkXFcm=fo_N$~^-_k$Do5+-6%uRdcvAr)N
z56BP;n+wdnO4%ox{|OSI{Z1**Sm!jr%vr0RdmUU~mtg;9qzWtk+hMI-ujBO(wV<%o
z*UQRUZ@t7I;IP^MKKj=)+W>84(z4Rl>`q>3asLG1SDxBQgsSkXkWd<F`^>*l+Yu~l
z!|K8!z0=Xm(Jz>yfdro3Nx%xdlYeE1DI&}|?;bSI<|&;7xHAj^Ta5a@)qNQG!b)B@
z#++FQNR9X0^ZApefGWZM8AumaZ-{a|J$s7zR(FE^&L|I#rkFbBXZsg)@Y_HoZSjOo
zV!}pp9IYPy`0ANmJ_l4tW|2)3xyno~h3<I$Jjhl_R=Rr69teLbu<zHOf7`cGDX`K=
z8&km*Z(p?7FbjkcPu(P(Dbls<+GMI4_WZZ4L20q8o7_~jC)*5gEK>BIr#}N5N}j^W
zwG|F5pB$8PC0HoC!pU1GqiG*?V#iDVLMh>7zXU1-7**P6+GqdwcwGd_Y=lWMB~HY(
zz^`@c&CO`}nHALq6;^AowV&v@9nju>+mq)2G5#>-6k}#weF8LXJV}#SeJp9JF!2hI
zG$q(Cbdr_|4ydglG4-(<Pi!PI(4WFo$^5WPbqM8Tz92H~TyDK{S3kf3p0ufgGgE=*
zx#MSUy$5*Le!-LL2bxlVYVzU6@$m?ib#_xh+*Bq6V`g_TF8U}Cw<YkzO)jbkTy@RJ
zvwMCXofX6^Pue6<(fhkYU#NN*JwKDPj%3V?fvp7xv_hy%(h{l`v-JFJ8lF1>8h5*(
z$%_C&O^g>;a?!0^T0R(+(EDd(u`FF-8}|%EZqGE@_bNh_G-IF!W<tc>KC{mh_v1iv
zSJ`of<u3f_==2u%ZZO9}i99(|G#b|J9(DiY=HM!kCu9<cdL8JqvqfiQA&aO2&+LBY
zE_fy<vXC|X6^MF^)^+VWZIFemewXl!B6aHHuN#}SFOjEM^3TA{2ftln*h~b=Vy6o$
z8dSsDX^)=&48h8MT9{xD!5Xc~isUx;nDr!)cbk(7OYe~xxZjmc0;l1L_D>m7HVNU1
zgrZ~;V&}ah3jOYffx=F?1GKQyNKJ=QmV!g&M4phzHI!a?3m8i2bZOc6{9wI!Iwltv
zZ7ODT*>x|1WfIk!s~FMsO+xl-W-3jz>zLf-a$a>ceK2svXM4?^S|aa8C(*2eE_m|a
zFOD?3;6$E?$%QoS?6A97Ib<i3vh=E}o>0q=EbzH`s+P!;FOi+@ex<arRXv^e;i<?0
ztWrwAXvn;B-^83~`B{}T+8MKI9R+c9Z`D;Xppwc^wQyC$mflD_I{)k1z)+riNf?@*
z-s8zmY5HrV-EJ)(YHk1%dBP>>Pr3d5Bi|>_(32BW<pwa(er=Pp{cW52{8Uq8wtsY$
zQMB+nrnR7Ym~dLVaLSoP<WFW*CH8}hQu_~n<eI<zQ6Hbx_B#F~RM=6ExcT&OWH6Je
zWH6;`rK(V}j-6kl7774naW%`|zQyzM0G8T680h9x0Vu{QdQRzGD19xc)jXY&a4UgI
zy#_sRrcA`shHKAf0X&s~W#g&2nQFfK`bbcwc!DL@R5ANB%GAhJnZ_bmS^mQ|LF56E
zSG`&->DsE)``{g{M7w0kqgGs8=4s|hNTo*QE`b=}iIrR*n3KwH=kNaw#DHC|Bm;~3
zHN&%+rtkO#8Ox=t@T@7_ygumQpU7A)Su=Xe_w7=>FM=e%6D|qQI=DtBIHkj{1CX`M
z%Ie7$&6>5i<+wd4Xqm+oP3noY`SWgi4RpdXb6Z#&*!WTs+?TqbvpM=t<cXHdNd2|y
zy{M_;iIoH#X#Vaweja62o>Yk-r7Yade)QNcOvyPObZR`A5`p@inx3wY9K3ec9H=DP
zzo+L?)dv<S+dN@RC{SY|peyg@CNkRDVQ5wGjvo&tfhuVKcAjUjkyOq+b*3G%l37+o
zO9`rA)w-vC05s+4l*FSGsEh+y1O~O*u!52bVJl5byp^VI5!jP$ddH4I)uyvw{oulC
zP+MhMwXxL9C+qL;aTR!#Ct7kHVD4Amsru=MAf@t@OD-trs~XL{upOByw*X=5HLaDY
z0_Z)ZYd;XCJoS<=)!3?^oifnTL6D`&%G+;b^5S09KC!XV$n^MA?Q4NBwSOB=g3{|Y
z2B(%kdp;4llvz{7(}O}?cvQd5X!W^7#d6gj4(0*3!Y1<WW)ce}P=&er7O?!Mr@+1L
ziT1DKxsG+@sy%z8mr!wusk4f&d=@ZO`qjo%)6`GK&MOHjzcNb>8~zyyU^fqp2lAyv
zo_s0VIaLvHr9MB^!MZbh4)dR1VF6FRBv8@$$J1?JnFQjBCs}eaK?Kxz_L;s2Rkl81
z-I~F>1@-DI_!RU3JmFI1&>Qn+6kI-XF&khk?}{b?>`3_Z)oS_0;q1s-7Gnh{<pF1p
zp#yKK^HL?htyIH+)dg2ZXBEZQb#*ShBUBa9T3Cs&0#W=+$*n}y+I^P)<$F{a0?TI)
zPgVG0T$7`R_JQZ-NtVb;qpbXWee2WU1cY}xlR!*Uo|*{y#F832k%g>cN_d_hWy^EV
zfZrT?QjStq#;#3rTAub*4#%}UoF(u=1=;!iW0i;dtD~Z_=;_?GAi6&N;XCZzFdU>(
zo-WA+b;4cqY1bZq{)}vuSwBoF@nLma?>u?Rc>zdwtBg+$s1Z+tH~bA$+ljmjm|R<H
zf|HumdAZT(pC?nQEC$MS1#G}rqUe`{vi;+a)D?=#EMlXmu|4lOyEM49JCUbUB0EJ;
z1<a&ay*<A<YJBWEB{w&@LhwL-BGh)P(tZc?Po7YTObtzc41=>2&KCn}A5W`9&`<$Y
zsO^^JfCfCl5}|eld(;z;Zm#c#fRYDzcQLu3I<snze10J4QFu2nRd&uPjJR6x?Z;=3
zN11HRKn&idQ*UsAVj@qiBtK~;bM>9=-=0F*UrQ=>p^}@cQ=bpyX`<-QyLMjo7hR#K
zEXy{E3J#QW@~O14+QS!e6Q*XRU7qAwnRR+%@I82<Q%cR7;2zFIo;C@+qM97{-zZQ_
zQka#L#>gn(>-G3I1#J0vx+Gy|M(;i6Sn|sXkWP5Yq{>nK`i%7D$wu&3Jyfq0@`RjE
zge_HQHc2a1``M+xgHa;yYjoo73av^%GyTVYfTBEUl7MqAt}s(+<DB3IzQhz+qryJB
z-%iO%VwLCbEriUJjIsgha%ZCHphi<qnKV`UQY%f(ElJKZIl#0hi6=;M?iO)Qk~H#P
zO{-eTB!7}!l;o0Mh<-y?Ye=W|dVcBerc;yb7c03HTC5T}@Ecm`b#R$wlKoyK57i4M
znfP`t8uT8S8BBah_8XPFXLoK%45Vn{QOV~v_B834#FHqAbrOlHCYT{jYf&iH4=Guh
zlXxGSb79THo&zt9s*OOIb(Cy1XMLjw_5Ka5K9{2;`t_@njHy4*CGAG2T%wv%Vj}9<
zg744w`yE+NmF=F5sK$v*y~m3GXSO>@JZ+L#CmNu+6<R*~vcKa;foJFGk~~b)qrZRh
z(zE6`B8hjqQst;YJw|vnN;fytcm0+ibLHW5*qoYyF8Spy{kkB>GPkINYLwC|e_ZU2
zEM=C`479#K>|QzA-1H~Kur{dG(KseOrvCwi$l|F$6nxUk^FwX^dJ`eCNJ@xCX)aYf
z&rF2KBB($N)@CASjg~V8`q@b#r|kHw<TQi6VZAw@0V{c8B(l<Y?!(XT9Svy26Cyd%
zW9lI2<x#CPzdG{i2kD}G`s$OC@p*!z6)kDfv!Z=!#qy1ow^=d%u>Q_x?Mv?#Hoqs8
z#Jfz%HCudFtjC}ceZ-f=objv{VRe%WCz)^PCGqZ7@_&FTOjS?~GY^?I**vFBvR|-7
zy?_rsbfEE3G-nd<^SviP0q0$^<YJ>Y76&}?SWZ8h)#YSz*qPZFU*lc%WwZJSlu2V6
zu$Z|a&)8??gG|fQELEqeO;86#T;6hKdk5c8h0C%eSh;L=#O>d|{|c~^Cs^|A)VD2z
zpUHC2ZwQoC;(ce1FvS^|MufR5JHG8dx(X@tSeSB1kj@-X16`HyYGZSMnZy$+5vU-q
zpn~9*k<g;+e=!FnG@e|^gC07Rpf#H_FRb1M+03f8F0h*q%+K&{`Dg4TWHYnm#zc)B
z8#QF;Nb_sjzvVvoFN!fHYiZJCbRD-J?=cTyGD%CAMvHhO*U?kv93v@?S$*M^j!uKz
zCr9Xh5QVq0=?cqR_f`PCKWy^C!pflQ;)#~3XCw&j&~H=^khXc+rRq_=(?*p=uR-;w
zP-Y2r;`FDmm#1GsFT~gGw->x$m&DU9Ie>b8rJ{Aa_H)mnr<V&AHpx&fK;yBz&DQ;a
zo}NirvrAkMm2CjBlSxz><B4v`tAlbYzobs{vJ_GTt*(-lrnHq`(K6M%W`UgA<=+2o
z0;J-}mYnZNktSNa!L232ABqfm3S=w0Y{~6j$O!^B)H1poMPloSZ5<N*>ZPz%u9l6h
zMy@(CZ+ctvf|MklaLILn{Cql%9yM2FUQy*a;9{PJN#MIzEtq|Ni}&NIAY5kA&2X+;
z?3;gqnmLIlWXkw66)~f;eQXY2lX!9_aj}o))dKeo*x|>4LI<9ZNx%UKU*!jXdJ%Ln
zyz7?;(h;0#cAj`Y@$kKZvh=6gX{D`8gf!8`IG?f=&4zQGod%y&t^R)?d-23f`gKW^
z5dPaYJsw3Bv&zz7(~yP|Z?8A1TEus*!dsaXZM+pJL9epiXXF6)<RtNgOwPkc4Ndnm
zt(#)V1@T=*egYCWPsrrLieAgu$aL&_{3EbbJSCHWHM-d1#qvx9OU08hIe=7X%-o&x
zO4VuT`I&{58rU*r%;$gS-=|Rh<|&z6bM@CmXtkQ0ec)4Mt&FU&Z2?&;&b5u{QEc6k
zK!1?LyMswsYYt<{*jgpa?*V-=?+T{sjz-R?Uo|f+8wh&ML?&awTkOQwr?&sm#?P+`
zUuD{|@zv<x6X)i*1K6n?8HHV_4D@lg%Uo~Z+o|MNWxgE_ReZ9{RI%rNXY*!2RNlo)
zLLF<o#@_dEh0vEsR2$`Jz+$5ro_W@6T!<c<$5COU*|)ZP{Om#W*s`^<SgDujE{jk8
zjcnvGQ`l&xyq&o=9|I|mcgYehjdRO{UrA(heQv;>s+2?sTU{aRe${ENSGLVSbG9_O
zX#>y&^F&O-TzW5BR8w<qys%};5>QR0xmI?X{p9Vo^T3VvNjxQ!XRI$cm!56?cXnqt
zq<PjZWl}vGydI7cY2AGVHh@6jX_-7@#RkJD()GvOC}4hyCy6IylDOK&g)DycSc5U3
zPVvM{0@<04n#KCT9j)#L6@@2fa$wDuxoiBD>k*Ktd3q)X6TKYt>qD#1=|1oFB@Z>o
z1aj;A4o9~mTO}33XRR38XBuIUH)b%JWZPv;PS;+;lyp%^EqP|ZYk;(}PFqRqCob8m
zzIbVcxRO0nCi+tnmtEQ98ERIRxajYyfSkpXHHl>+V9HrWyISh2)IsJ~k&}4xCJ(rl
zlM<^&nd8x)o+}P+o=)PaoCw{sS7xr%p&j0#0~k8tQC({-v0mn)iOY)idk(c*ktJq>
z@(mS=+P0q+8wS!>3b)qMd<31qywy0SCt5si$tBz#LwcKpm_DZRhWmsg=udTq><7cs
zjBcZBIHY%<(azoJ6~zzeo4K(yilmeC=}-LyE|L4DrDt?nf8fyQH;}g_^THdC^khWn
zLp@$TVG>#?m^MO#n-AA#ZF|j>=O^<tP$G`?ChT05{j1HglWbQ%c?lv7?-8p;tp%^p
zB=hu7WTtqJ)=UxA*PMO=8Ov>y#Z*V{mWXY?7eDxwStF9|DyWbT(0i%<Mtu{7P`Mm-
zzEfiCJAYnrcLRjVWw7&|5~H3S{_WUNvrHsc;nLTvySIN>I@9D-GVg{a3IHk-p%9Q+
zch=@9Hz))si^(*QY`>w&%evw-CFq6MCKKzf_1h%5omIL}qALA8E_5xKv)#;`DN{Bw
zsyN+AC)8@96L%Aqv^2hJpF3%#$P0?4b{UkkRQtLX#p;q_e>v~_60(ZQx=X_ItKWso
zHlgDBYsElR@q|zws?feW!$;|X37ygpQ-!3euG(s)tMtI{xy6mDx!Xl0-lJ8>*Yn-#
zZC0{m-X%?*#juiXnO1i^paSozCIU7Zn?GAee~p~WrmQHsf(qJXcTtxQSDWgUWZqRx
zuAO3bOdAm~I(7~}wI67GuHI(A;23Vf6^?-8(~3ogJKxzM7OPRgt+q5e3(?IDVJfzx
zqmIAgubaYPdD;=S*w!>}f6R6Np&5SlR_tWzq(mSf9pg`r)f^7OmMN90;oO7@KU>pg
zUiuYK8tqakuZB67mYSRX>@N-Pj9{%4R$xUS=*?WE;j<=~;-zG!GRnPVNx)X5GNEJV
zoxeK=GMQU<!N8LeZ?<#&dm~sbi!+!{X8USYA;0jbQO2sgVrv==CUrf_beL=o){=SG
zI1#2f^ZaP|xhKrwUouY+MUd)614P&EOP-nOKes|x8CMp%ik*nQ@P8hDt`>M~o*0U3
z6fvvizz?@y=!YO#)s`U5#%Sl_5lIMACaN%-4F}TLiLNSphr=d1rB-6du7q;x>>6h}
z*`jspJuh5)wvb+Dm$ki=8&m<F6iS%uj3~7UCDCbSdh7FmPH`-j`nW-n9l;*%pVS28
z*EkkSJy_Tl^qtu}*4*GG^Db`^z%lNbmngYCdiNF;*NnC8*YDZrGeTWOR=st8!F&-R
zw&O=XfEvcrL<vkoyhYR<*6pdQpwh~@hox6GPJW8+-@OUM0#6M^Ryy}1#_0DWrv5Xs
zt9i7Z%#%Y2*ubZ4%z;GgFS{%HZcx^XCyNsBegw#V`I!y(Ehax`dmFnh%HwfrR%35N
zoG4yv0l0iEnRla;Ybca1be`8GvpKL!=H2Gx;notwsOl;hwA5SRr^<hW{+4&GQwW{D
z#7EKyx;jPsfo_xAjYaFnt-St3Q0}6J4^ONJ8hxHvicA(Av%fc!QE@cK`@<+Iw0)#q
zD&<E7DZ8=<UeY2K$83JOl%H;t0xa{dr2vD@>%YBeg-yMCGEXVxJ%24R`V$Lg?xLO^
zT{s#<8&4)h;9<XalM?mrHjv(VAFT7xn}l8mLi5Wdk4E2HTr4B~Dd~bIn^Jy3os!b-
zP49xHpX`+nwAMTwmH3@-@7?AqpKt&SA9<oGft{vNuyWHO8vtQ=iYmfWMnsZ^38(-3
z8hL<AY`VgZsOWr$P_uZ);9R$n#oQuIA}}*?+`9J`cwaD?cR7^f2VGi53}0EL(mjCT
zvK6v1+-$LHbeq@)JU&lR<rs>T{D*%pa}`jVC#Z5zrNGim920Afx!*jpP3GyUJoGe?
zlFUs}@BbE!1QmoQup(q*zcKNpogX9r%HAsc=0G5V3n;sf&kyb%Oy()8TsuYBn$Lg7
zoP<*7`DKJztTjeuL*{L-i=LlNT|ry(ygL8CSDplW7@n$%o?oD%6YH9}-gyvo*F0qv
z;fe`SK(0lst<iJRCLdI(%hChkSqpE8y58+vZ9oB@v`QH2y^jh$k@9QaOPhUbm8!;*
zS9!?Be&EX;tyhBm08d~=pyE<D5v_V<tng$l@NI)+`@K;#%kp4FDCn@Gn~b`{)Q2Z0
zaXBjv`NXc!8S05FBVNMLN>0nI?;J(=vQrDsG8dmR18%f?9qaif@-~;n8O+Oed|Bxi
zkQ{hYteR*Bl~})TZiL9Hy#mp!yL+3|i~{`(Pk$v4)qaM!d*;CY75;2T;jT2$#@#?R
zpuJnZDz9Y$&#aswhgp2G&?qt8+h%Wt5LqKFLNt<g*;Y@z1F{QGYvmlB(HXMyBCQts
zyOzFm8H6TJZ52ZHPCMm}s`}qevQm{HXeDXcrB=?4s<k8L^EXryHL2qZ%@C@UrwXbm
zWc$3&ga^Q$il?=5T_E0bbY4a@<G=RUD{p|*!joM2;Qs3e;MJCeFaBE1=Y#5KNr<q~
zi@u~XIQ=TPMKhVFyb`B8`0ayfJHC70FJlUE<&l()xS~Ypb)ozh-%s{2m51j^ugFsL
zDS@09UMPw{ne3%EX-xt*{rbW{Kr^25iYyhy5hxljU-;t#un*%&t_Zdky?h|57Kp4n
z9~(Fc`GHk*30urcjntSNb7m6g6M3qun*Ljvak2U!a=_%PKZ3&(-n~-d@<Y#1nQDF*
z`%5~d8f_$GzgfynHK|#ROTVesjN5z!T&I`JyIIOHlg5Nv3a@=<<L|&gK1EV1YzpvN
zFD<&L*52K8%`86xBxMzLSt)C_ayfq)x6xdv6rQ+Bc)%!)x$-o7&SX{!PhI5zl1q(1
z9dhWNc?gzuhUCJcJn;OW6W^O7*A(9MQZB4G-k@Q;AT6rrYddByZPuF<p3utwfiRMV
zjl~Y8A-`BlFol_mk6!rNxFX+!=BtS*yo;yAO;#Eu`rf-B-H%*Z7*cp*D**@hqL0-m
zl^20BORY2WGUBZIod2ytd|;9{7`Q~*FIM$B>Nf-mX=U}Yk=EENKDBKB-(bn@Dl2!%
zg^9}B)N+P6;Po=#;4FoA-;`J*0c%QjTK;$c1>jDe%1VG5>E+t#<(sG~(4P`Xyzk#R
zfTG6I0gRcsI)0FQnmLn8;pwY<XlIn~^oJS+zBxYPWpmDx!V_5ubW;LE1?<M(&6grn
z)=t(%6^_vRxKVqfIwDj#kqKMDXm%pPK}UUHea&2ET}<Jrt7`hU;e&}x-|l;=BXgOY
zbuRP@I)R8=yWQGyetJ=eD+`X5xTXvK>+)F~u#_jTs_EXi6r7(?5d2YMKud%wb4=Lf
z%0Q+wYSsMne&SM?#*<fx%ZtJAq08|i&x35hyMBrw^}5n@_u$LOMqW=0#VS$n+}?m7
zc?Fdqjht0;(vgoq;PdX55|8Z&O2nN_9<XeR3;r_gQK|&NrZ^?m%2TH)UhTf4=Wpv}
zCAj06W+%-}K?+Yy<=HFtM~38jYsvS($E8zviYkF?-iAdy-G1uZVt}VyS(P*E)>BoE
zpDJVn9^mP!d`q<so|yV+&0S6X^C^W>yo;tB+|tJPYi3<uR10CsL=}$x<W=+dphA)K
zi3n3V)rRRG>dUBlVn_a42$RcIbj#MaHyUjMnU5!_a{MXw8V0SNJk_Rk2|=qe!5+h|
zsPbvmW<~oJjrJXC-zxP$<8pT%s<`*r^bZOh-QQ%rrs$42KP#&rx@tIB`RjCYK&wPC
z_R-DC517-=lsH~nEJZqU<*tmMw+1wvJV}-CGFdC$Lece*yT+A_@?n(%E8~F*Ed9Y3
z5YmRY`!1KdGAAycH|8Xv1{Fmqc4d{fco`^)uCIul4>AHzS>^e_`Tm^N7Jf2yYg4dV
zJV_Pd8r7!i?avD$OS#+?i0+s2G)o`4ckNBkdGj<?WNF54qkWmaY!4`qJXsY%yBD&X
z{Z_kwZ~cvcdF^osIM^H#$=+*w?{Va0E_0pt=RoKERg0OE&EuIAo}Nm0LT`{ZM*r|3
zvXj>u3q0B?YK4r7?t%YaKja64!d=-Ug>8=M(!C&mWwM#Fbjh0_rSlY3<N-J<7<!-!
z_>e#fPfF#YqT}#|6~3SAr!Xaf^E6aGY;a~k(RJpB)vJ*YxD@u}JQ{&><liXXDbn9f
zO5w?*9Am|qEvX8{?paK!HT2#Oz0nI$jVF}y&|Mvz2K?8zP3nUT$x}=burcE)a`u~4
zK#Bw|dEHTmDGoVWw$jsJ*2lYf%C(fl(*87Y=upQKvb5!U;>!dI3$k5}HY=IE(k5O6
z93K2=2T^(3o1J?4O^8BenIbbT!=h4%^Z;}RuRVLFFjzC5Xo@^x^knZX>^PB_raik|
zFy%kHxVOKBxz$Ok*na?sTAotMHPk#_BMKicnX|BY5|qLdN_oKUpvsS583*xqy}pvL
ziOfnIB+AYygYI1M#fqFW+U1^9uAF{Dbd$LQz60Fg38y@}(N$j!-fS@yIa-EU1~z-G
zuJbiWaj08D->O|-cdWf1zN$00WOjyCI_Q@6QEd<?w}*D_)X_m_WWN0)C>A{JlyEIj
zoe+OJ#e5vPyjbC{e102$4FyKg557ailBb>OO5Z_rE|}Jz|NAvBT?0<#38x%b@ikl>
zv|5!)3xQL4!YK#Tk@@Mcdk&wQ4#JfuoD#6kmIr0V6GcxRL-ty^ONbt@c<orXx7OeS
z<B@M=Ll%Z!0@nG4wGO)E;Nb?yRu*RoRG2L06*_FOpR2b+zLgPcvDJYUB|-<z@n!eC
z$X*s}J$r#~CzQH>7_!$|cD*GdH#i@+Qtc(?7OWW`Iu%oxE6vTgiFPZm_yHA@>du8c
z7wZ6HdFm<hfk1XH|I>j>&6(93lyv33fUv6uUa<V?=OO#RUWX^5>Kc5%k{*5QpgKp8
zg{-bw;0bSPt>+8X@@_yDGRbO;tA7|<ViK~D$x<L~n^1K1NrcFxC>U11^I4{5paI|s
zq`Eq@YS9z=4V>K9tsehYDj+BCJ9{oJQU^`^V^D1b%Ood_*2P#RFhn70&REs2j-O8z
zYD!cqHO=(2Gh4fZz*I%Q5tcz@s(h0|c7ydk`{@udUh4+!w^LC!IMI>ztyr18b@w~<
z_h5HCIJ_XTmo->+SFCGD$s+^d{geAUg98?xMyjhASDT8PyGvC4!e1?=2jqQs&x16`
z|I<g)zXwF%Nuvl<+&Dp<kUI9HG}UZ&mmOep&yz-Zxc;6%dUe&N#5KqT%%X}v3|eJE
zF?4#*lSiSo|8{;sM=(myuP&72Ragp8L8a@Alr&9bZQbm?<$gqk$QrLmm~0)eC$W&6
zdj6}kjyRISKV+vstWs&@=#g#P+>t4326nof5^A&1JvI__=A7nLXo+-C>oIKz^j2{9
zPSMom+{>n3MOextsXsoJR%YMXJB^k{x6)cgJuB&oxBqi?<pDlbUtIP^DSJgVvSb;|
zK0~BrUx%?|NeDGzWM4{UU!pA8cM&3uEGb1PyX+L<7Zoj{kV5#~^Oo<u@7~XM-g*7;
zZK^-cJ@4FeKIhzXKkvLdJg;7onyH6!#TZy3)MRE->PgFa&r;bfzdmPG|DLXZ5bK*z
z6=hfFXlfsVrP%(b3+5ngb+Nu#RS~<+6)R)(tMNBN@42X6#f(uhf}m_D&QF$|P+|H8
zWLa57hH+K9It|x|{<u#0QU(D`Se6;7s+JU@Tb6eYo&A&$m9Fm_qGqZ4_vwiI29U-_
z^LSA0sZlJT#DM*-QwN!ZNFi0KnyEcafq91?X#+NhM}ZP*3d}==Po6)1HW{`;Pv1DT
z_uX6akRxrKc<yiG<RAnxLp1!C0pq&uo`LqsH%M(woj0-c^T_-ii^m|TzA-ALiht9k
z?me`$GLp&+QLC9`R({Q1Z1}Np^({=xj8W<)8K>ykZ#Tb++=>~XmQ0OHMS;3%=F!*P
zIzkClnNIuyRoo2dM%}k|(;dL5Jl0ctr|)IZAZvcHzMs)yjgRKdl@hm4Z7sTPR3yzy
z(CO=+&%XWv*f1XViDU~a=rYF)fBB|y{UY>b1*~&p)~9FhFrVMdedXSo*+t5tpORY`
z<E1=j9|D2}1yc4R!}`ao-Ib_7Zz4KfaorV0-@fZDN{IAR)%1^AN48!~Uuo1R*{%Il
zf&KyO2y`nTnWn!hlYSHF=pU_)$TTfQ?@Qhsjdb)6Rac-VOHr7vD1TwC>!3=QN?*z}
zOs($~>RYojWn*{ayb~YI;5^w{(x#)2T(pZlG!jHVgYzWiipH;I(@Q@!-;A`CKou@c
zt5VI)pERs_bC3o72TM_PW?zQUyFupt=r2z;{l$1?P?*<0y?O*|ckvXj|BR0K!WiTs
zBy;1HHco!k6U{}u_C%AV$SB;Xr4`_asTbbb)6$q%Bvj`{FTF73%)3D^UnJeV*8Jw2
z5YLTd>zyeBAN!Z8dJ1G-1|7=YNt!UFl^zt*wd<BV>9+Eeke2@86VgV7kSitYD6nh(
zOen{d?HN;|P}DP7?G@whcQsWom%)Xy4Imy~i{^Ise`2z$;-eWXsE|Z@`M{7{es9rw
zNK=WEnWKb>4_j&#Zvb$I!Gdx$6@Sp@S2xcrd<38*g90Vxisq1J*J7humwZ^HTKcIw
z#SL7VAVf2M)CoN1Sg;W<O?aOU&-7DQ;YM*L%&@q1A4Y(piNS}m&7zF<5#FJvya`$U
zsERg|o0zS`vj8_$E`@TgF+&%F>?{G<CzLgGAdp{JY0twzRR%4}Hbl5{{*i8lo-(dD
z;-eYFC|j;x>$E*la1iig1|!Om2WyCVmsd1)4XSt;W0I6B)vO@y-T2Fs02>%|C`YD&
zHcftf_<giTa^EvY8|SERB%CoZt1B41BC$u@C?>g?QMdAT9KIP8{0u%+$P&a`vW7hB
z2(;_B4JI2^=*~^Sq`P&Opds6kQv>s%-Q$L?xBo#wJ39Np>8_6{`Bxg*FKEqk|JLHY
zZh{QVpg}o?6@NsNN+68(^tV2`Xx_}nNBgs(oYZa&YBu#PH*dJr_oV7Z2{Q&8%GNhb
z`=i8<$@$%$f-07qg<=2Ww*`-#2343p3Cb~nMbR-+!twZ%wLlCr_)oS8MBxuVpHpH~
z!m~(S>0X&*10erUS}1>QRy8D+n|i~%`&Dklg#_fdtf(y)X*B>Ki{Rz?zmGtISz#Lz
zEP_{0xs8+F*zDqg61~z6KGAEmmy%jGzXUX8kf11NZ3d7<_*XThEnEN2QzjEGKAJ&;
zvIP?&Le5h2#~YSL8nceXLStc7`+`~5c<iLR&Vw3(L58w4_6))%3)C&wqMf@}3LY@V
zN7?es^Fyg7U)_ZyvNCTu^s3@RRT8r!iL7`P62&fQnBC{urOlB<>7tn+07-P}0(ng}
zy;|ZowBer5F$qudjnW1*AGMhn>N9e3uZWplOY0=iTJyU+4^V|MB+A+#I_`^M3mywl
zhCTZ5fzlwuN_G8W)P(Epoy%Vasf9sz3TbMdn%?d^x*e!t8B`}rC>XdyUjNec8tsv)
z%<!b)IIauGUS*z)8dH%_R%#X81ZAJ3U)|m2_aCWMrJd(E!=fy|YM#+l_*RY&UoWXs
zN}6AOKhE_4CGr`c=CdqIof8A7D~)P;3$$w)<Dx8?E||#2pIGya@uVb0fU2Z#pxR+o
zH!gA5MEyp&Oy4&rkxS_^rSFFc{*cUO+CXD+sap9S{sP1)V=|Qc=nA9Ab}EX~mQ#im
za(79|r7}nR#i=(vlctR`z8McRWpJNDnpzY}4O0)bEIu4mYyR9PDgv!GOr#)In_Zq7
zKYYFl_!MJ2lr7gd!c}_f0t$Wx>B$vHk!n4?bksHDdyJ&u*PP0q_T)HKw#kVmp`^jB
zvg3{EYw^(x+EYkV%vC2hn0<Twcz~=7?vpLte$P*@Pj-A-q!!>R_|Jy2y}&lB#MJu^
zU-{W}e<l7ItS3uJ>y<fOX0A$CR{@-6%!G1e>Zd@8(^?<@WbHo*mT{`^A2N?q<;@-G
zQ|HP|?MGD#-B-znkKr(%2>W+r?^w}#$yrK#cjd_fWKPmjmFP>Tu)S1Bj4NQvlv`AH
z{Kl51Ib#^CC&!$UNGXL5nil)68T2uXSx~l6PrXCl-l~6r+DJ>;(hmdrj$evG-=q)T
ztkTka89P44pYkMyT4SFyBrSOPovY~Knf0z&nY{FRN$dO3UT}(GjC``KDgKFQFNY&m
z=0-O4O{C7_TVnO-?D5=?^JaF6VUV3dx>~1Q#ikUW4@Lgl%f0ti;!`@lUwj%@I?eA|
zRv9R&gnZ^6CDgSTMT(;2sHG1+u-b&>7zXFbettZgXk4#;3z1Z2!Am_V&<KyXS$Z;(
z%B*-Tsb+n0xopvQ%(HV0gZyM!AUyf$r4CP;bL-+`7-OGo!Clg=&%^2|@1Ca~NJUm)
zhHIEc-QFRKK0;D`D_=Xf!nD+Kwq1EAlFAI(FrBZwC9`!yQe~BzX()ik7lrIE4~z?)
zr<9PDF6$Svz+-pZ*)+<$`Hx}HpU4HArk8cQse8e5B_F6}mcKC!3X~!lyj0h%?Yd`?
zTxo{PZ0l$&j;p%9h35{50ei-vKsox-A=m)L15@^YhqUFTS)r{pch<y&^)FQ0gtX-~
zl`Oep3XX1r0+IW`B~c7x7*xmx)*wq=ZfeSiCy^C+u`9F{o-4`?W6vsIxpxKfUS9N)
zT%ou1T@hPjSr``jE@}*6E=gAkL;rD5R$+Ls+5WoO4jzwqqS=%@%2*u=;<RbU-gRpP
zC5UB)@C{<q89u9VxD_xjj~zupY@5L_@6r(i<^d<;v7<;XeKy)~vNiX1y^OSF2e9=q
zYO~!o?)%CABDvDEKEOcDYf;nc&KvXLckcry<B_8*D+sxYlgXlfY01u~kYsic+wJxc
ztV{Pj{N18&s1_r8DDKOd5+zPb!hLsSKM*l$mfm~4o#p3bq%b><sf`a!v9kQ{L(t~2
zBbg)%?9n%`P=~^gxMi+t2wo-@oo(;^CPi@JXHyHfB9#c1i0&7`hLT5X=1BtQ8y*=-
zc$jgC@z%6`(_Iynr{<BMNT6^jtqebNx&3w|k{h*P;^Md|X|>Q}a|70Rh4t8|mHUv6
za%(b20B|v~_J?Zokw|Wcf}4@Q?m1^ov7q##ZjNtx?4%ZIUpEC8BX2#D6iEm`KUFR_
zIO%4@dM(f$k0;@zL;o8EDLOr`amL5^Go4(Ov*#1v4Nn=TCPO;g&5JxV0N{!LxAd%<
zo~{V0ik}>lXG1FmY4U{QML?RB+vXdjW`g<Y;*Q#8_c4Y?a}rTy4d%B~tr=hUKYgmN
z+1QKWah)vT;_$4;?7io9g8a?nJGnBAcJa^G(nF?I{EWwU5>kzin35-CoQN(8ng=|>
zlOt4^R)_!jU$@U;-fPA%20z&at-DV$6c+t^)k;)a^!oFioKO%qFj<?5V9--*hl>MV
z0f&4Z&q)|SXiD4;v)6TL*}fLY1l-Ijtg5+HrBgf1F%I!DjL+jaMiqYq8{M_74B8EM
zj4cU*Rsy4M(7GNV_p5v3tv^!?X#3?)b8`1<cna99g*}&y0Obmg<3zh<RV%Iqq_)=v
z_qV1cYjvAH$;s6=TeHx$iIm!~c1jTnF5L#ciB^%iKGH#NDR$Z6`UT0fy0X6MR*Ka|
zei0H(S-7DXGOdK}%#%2o7WEMu{P^!N5MYVYyL{w^o8$PymD%k~8gNV^H}9%6VAp@`
zm>_dJv+?71kU6;Fi)g?k_e?^bYbI|dhB5HT4q`ReP{RH0<0kb$>`EhK8oL6yMERkk
z_sWGcz{OMyljbD)1q3syqLzQ1$%cBgOo|f;MV|oKo4RZ?NVSYnPmVdo;l+gmx%n$n
z<63~M$RszBt~B+`sOA5iyY6A6tZ(2_Yzg#Ag8{blWVL5NqDkTguBqpnH{!1s697X$
zrP4^^hAbVAg$GbWS!f<5T})!wuFY%8k}1f_>Jrj#!=QqLVLReQIv=Gc^H<trPe%sk
z1}!OWQhye2Sa~-xF!wC$tqmw>H(p-wiF>+Hj<Qlszo2!RCDNXGDi_{H617z0&v|m~
zIU-dz=95jUmjVdLWIPFP6;6xz8MB_u1z!D*VT^ckqCosHYwlWuPviq3%lJl~BNg9Q
z{kY<}(=NO!e(Fzqazj>#H9A}8pMUFfq$@XKt(zM2oYXyf&?87!ZrDOf^(!^vry^Z_
z1JyAA2^9dVr<mwNx0ZktC}Z-Iy<N@)koK}V<(aPE+-L%#mB)W7j~Y({9*Au1+Es~G
z8UB9J3Z8#b%{A`<EqUB0p{1~{b~@<NGw(Z~u;9_2ghV}GzZdi5BBUX!@kH{B^tZkF
z{!2)rZ#hh^L=uf>j!j<skGnHUbo!H>Y>Cu)G07A&YuvpOcs!5nWHnjo%EWm3SH65_
zF%rv)PFpN0Rl5C^Gao={9?!`Z3y-gZ+fVHbQYnw{BrfEvlcup@_nrUY7qnqAmcpcc
zd&8VdImPoSoBlnm&x@{58K25ks&9On<^QEQmyWwKrDw(ZQ=VK!(TBo&>`nau36<mz
zpQlITjy4r)w~@MI^vblVsc)QGnZIRp^9+03TdogRJ`tsJs=D@^eFkaF4A~f(O=LJh
z^f!~2n64GenEPbmfDo!TF$njIoI6_5Y~;oAI8f!S?wD~wu%&95e~_lkn6;?Mrf+>Z
zd-Me)m6cM3rZfw@ZH)c`_SA(rz)Q%n(Xyz_)VadG*xh(+mL=vfJC?_TDj)e=&wio=
zvZP0eum7lZ0LAW_@%MadR>BHd!7p}=Jsa2J?gTo?(NBp79vup?%a-5QsEG;Ou{<J_
zB@pL>M#r)uvA%I@BaEmij0QY~!MW%;UC`q*BUT8v&{du+mY*5;G(iCAs@l`{&}!pL
z-E339oyp_P=3O$gRxFPJC2T5yfU=g6WX~78)D{_)8L%W*AeJF^@Xb#*A+gMeC9&vz
z)x@knE<{#fhOG026BA$t-jNGX7h_|XSr)afC|2K{@X~i~GEnlYbXeb5HO~RfD?YXl
zSXN2inW9#>H`w3*ZpBTL{T-{|N~U7<TDVHx;mrYJGe$pI8Oxd~=e^LTP<>*?={_#@
zDUrovJ_#n3sEPGAtH&L=me1WHRitmQl8chaO5nxf6SdNN07!{t9an`=Bb<^?r{4$s
zo=11G1X|rN1FD8je4rnd02)+rK7A+H7cE6k$$d$O9yd!C+N8F>-!l(clo_Mq;e}20
zZHmeN_kGBpm;p*c#f`D*r4*mLKHFk`y**xWC%^avW7@WLi<%0yibrv>w~AV!Mh&<+
z@^&@gQ#^{3kZTC+S-;++07&8_I%OX5!v7Kfzeh^?btIOVPKBNV`OOCN*}LC<2{-_c
z+aw+zH>+k>UU3FV<p!#dDqKq~(I^5QTCuV^asg&erH^!2<)1FM-sjg^QJFzM1*>>-
zp2|m3V@Y7D(p{E8`@e)&t{_7&gEmahYVVB+?;)wos13s|9#*AS3HRKhWL1gSnMUp7
zvbioFzulSgQD&nhmd9(Vptr!t2WB>kYHv1|VtK?SAyEgw6}_I@i8N$ItB@zsmC^(t
z4Y$r}9ECJw1*(v!f+@+Hn0?Y0NJF_VncxY@GqT>zj#(xliLB@(iN-Ux*>kHNh|G9a
zWLgahwM!#Q{&jbZTSbnp<<WTGa@Q*P?Jvk?HO4(xO8%-M2p@kk6V)cRwsZ%k?fbZr
z_v{A%&7(5eQuRY0<<ince_ZNrmJ*e6uY97?==nGNr*CyoNAO5YuAchCpNQ{neE>__
zC?0t!B-HTKsMd3yHLvVrdHf|?tVsGAg_DA6db#M=kP(<c>U={;^MDD{yL=A(ibr7*
zoI9!|%?$nB=$zn|DwfA!a-^CV@J!Lv7NF$!XEE6^V7=;~J${YX7RMr+`Ua~j5|urh
z8kL-dgt8JSJv}-{<lDXZJtUNsKS^j+ZJ#JmE6#i<G(A8GR0)ATfeP+sj!$XR2I%Qe
zU2-jo&ia=de0V3=c^-3#9^Sl{ex>oB;0?W4f6|hzCv_(Q`D5<9J+0h&L@CP{AE~oo
z8jfSA`|9_<fkefd%T&SXc#8a|_dKVsZ~g-~MeqhQ>2GHeK=s}+Y#GQVJhGA{Q1tqQ
zd9@h5`R>{uK&i{4D%oP`O2xXau|&&Uz3ZRR>p-qf^o>+IR}(FAk~!?<O4+-IAUiNa
zm70?xSUq;2U|m(Hktp@4+*e;tSI*~t!D{xpGD<DD3S5iFRkBSBxjNSmZCwLgi$_-y
za-C<F8}-+tNhb(Zv|R1aRB|>d+msL=QVOm7#e^6n)Hk7qgwEVnTPJ?pjM|+YBvjrg
zChO5<cS5TA?LTANkW|_%1y}rOO0KGt*N3=}@~G2h;Y!r%<WZGuUB#R4Mg{am$rma=
zC={iisw^|962J<t%A8@?Y)|1XWFGpdYxqVkNw44$t{<&uEUuCbgfDMaQ-#QI4d9BM
z8*Bwdu~gV6e2u%BUL!vL7PM*oSxdGF^m6$54%<>d;^r}y1iMhYHD{J=+b6xb4kT_K
zU5SL6UD}B`&sRYreWTWSY|v4Rk9)W;dUWP-HI2TcV?;sgmT!i5;fjayCNt5a%lm2>
zvCY05S=P+~s!&<6WqPnqvo3zL{JL?{N1p-2Vtk*@3ME^nCtFc5ko{aK3tY*rs;1K4
zeKbWgHNJQ^X(PxhJbIGOfTf&zJ8$FFu053kSY~R!pfo#vMNZ~R2hPMJCs{huU4mAq
z<XdyG7${Wy`AIhZ6X7#dsK~6+|G?8-2<fz};y;urB(+(_8uP16E5CgAH?T{*(M-Yu
zhA(~IuyQm&WFAw=5-18w^9t$hg{vabPRTw+<}NDS-z7jvo1Pi>(+m=-RVw}inH-yD
zpOR)46-%}kN9SoCPe~X6cf7y7{7?i4d>%{5mMUORPoM2~jLznUloI&7!Aun_-m|Cw
zLt*;bum^{^GG&-5_b7g0YL>qF%JdbuMA)R_Qyh<@B-BJ-5c>VzCLftaNnA9GqGZby
z292T!(5*TlCb@>WS8=@gOcla?@n^{Y<{mVARdKulO_l7av{nO9SNFGik1RxjSsB$4
zZ1uu)!P~n&Gz<x5#cW8hC<S!E(}p}4hXk`SYe+DNhvRp4D{X>T9B*us5KJdmAU6Mo
z_HUcu6~|*NSz<+BL^s0M-`oYh)e^^}D+!@OPob@5T?*jjO`mUfwN(OG21e!q3}3YQ
z{Idwa0gB^sl^kV5Hjn`R^Y+b=ln}`oB!0#DGnOm>ZzYBhH2XxKp+N;vzsqYky7j**
zmvw7X2{nYTJ#@aLd218L_+XvLTtcFLuXHg-kGx1jX3&E7@0aX+vnA4y8Lh^>(#M7J
zwnQ2-gB08=6>L&%xa*keuCUIkR-abX0BKsaR(<^A*0qYau8Q;jI-Tu8;$8U``wwPy
zKB6g${~ZtaPau)HSXr%RQm;6=>J2su&O$@utGXvDB{-#H`UR(fBk6PF{|1=HBPQ9J
zqL*KiC$#ziiIp(oYXED~k9Gh`X}GC65-SbhD;6DA{x`70^T4$fN{O#n^G%)6iLE~b
zWee-8bae7XFBhKOy!52`I!PRlqC_(7*W*Fea{tO@Ctc4{qKn5>vL)NGC4=DTxBDxA
zLP%+YW@^<iqoiwpKH>+oSFF=2DJpi#IJOM0b8!QRSO0NL)TyZCHtyqM)y6%=>)Q{0
z@Qtgi60foW;uo*r+9q-OpH+cbl@dEsvpNK5Ra44&bBfFXQ-9-lL?!gX#<@FZ+yhL?
zBPv+})k}NnRX+?In8!7#;;6ij)Y)>~G$4g`D17S#z!e@($rg%m<&N(EK(WlEO4kd*
zTaA9zzqy}m0#Lwz`jYLfB-Z){sMlY~3;yhVH<%|L$KxsqI~ajg^Hh~x$P1X!N(vjJ
z97xf+ukD|KHjJ5INv?hyPVriB(!W2t&ZWewEUSFu)jY2J(d5WTpem20WZ9G$dyW&x
z;&*Pjnny@g60O96KUK-DT*PPEKQRYj4{hG~ggJsHj`uCPN}gW5X^31^?zo5yA<-~X
z;6mMca)s*+clI`$>v6oV(z%1hB^11swaXIM1ys8-V^(mWLBwu&tj&)Avv~|Ap(AlO
z%&u79li!2kqH+HGB^w9Ad<4AC+GUR;1299DE&|L18$0d3fk-GbUa7_I1s96e2XD=8
z@763zw91|Gi&o>J=4y|>CIYzPv6pC{9;X`1Z8b`#s+_bx0X#mBz+}tyK0Z1A>PJ$*
zK>0WxeaRAv#{ciibsG%Bj^mAA5>gGI`uUd$zf&Eo0hK>*$p$LORzG{bS_c3nJl2w>
zq~TCx(WRZz!4&j39&Jg8b<&>%>Aczd&LDrH|D%A3|I{Vt*|Se>(;>ETanF=bQglec
zQ+?6%b7NGbKa^9>KecZ>xv9QYzESF`EAQ@Y-=`?8HSTr`*Y}kum5l)3D0Ms6(yom@
z|1pNT3!0+-)FnsJ5e94X^oMOwxys`$SzAwJ05eFdb*(YheR{<Mc;qEpu6R>RI|lDK
z`N)2dPI%lUAyiy4fP=-%ZN)nxsj~XXG(VG6aIoAz|5Ouj4CZl{Dp{8d22B6?(=PCy
zQXG%IBxKr@dcCFEa7^<D(DO4JOn~=Jp<24%u-`!=%%8YKNxCX(Ca$==G8<^s@kT2N
ziE1;E0yH5l=Aa8EN`T78&NM*9Ndmt1@avT1Ea16$ge9S+n@D659es6q3X;g`DUn3u
zbh0|59Qf>eoIh8|-WySoVN&ghN6uUUHx#_NO4bMJ>GnVLxpRqo?cV4=nf{AvbOlZP
zDNBTV)|aVTWaOICG9vBTHJuH0w9x9Ip!E0WElFEc7sXE%+Z!~%IyR?P?FWR;^i%bg
zNgxwwu?<o^^7-Cfy7Uzbps$_3Fm?7Z0JBNbiG3F^iKpK`pS!pl7^>E+ENg4sv$uE|
zTr<W!*$z%a-r<{NZA)8YKGS>l^$MmyUNU(33*;U2QvzA4n`t1E$Z)}&uk`l2LC1kd
zV4@kSwrkK4PBTVS@!eqVP8^TRBqi$^^4x2$$AUth$7Zs{_UtBnO_zH-CG973N<bWM
z{1VCSnBF<k`A({da7#b>_Dzs0c~h9G;>o8G9oIJmS&c_-vSkWI^;|i9!XvAZeVGC6
zG$G9fRML<0AD{^z-YFk(Jcd(MX9`32v_5^KEcn#bUjF>4@{~~Mr$jVw9FtDVr|e$%
z`hepAB6u_>OQ7f%cu)2e$$6$;484x3M6yJPu#rs9PAxN-lTW8rN7pAj!jr45Kp`!L
z^X>1GA2@?Q<;ey#>PONWPez~f_xGEZ0if<rdXjR*t+A%;wf)t%0}ta-o@^V4?|sv3
z5&;k1og;_%Dr=LMfrs%3P(r+6+?r3c`~i3vZ%mUV(CBoMp3gkjx`LZ4lt}O=KiRfb
zDZhG<<;gMnZKN?X7l-Tfy|K1SH0bm3I8cJ2srkXVA$eXw&Lv|k(~5z{bh?{GcFdiH
z;<i`UX^jbN>G5UUDy`lyahrO0$IhsVO;gsk$a28=Dni6-b8?xQ#`E}3;=!qwG>VWM
z4`!QWmV5C$0u%|YZr5QV2t+#5Y<qjaXMM~di04tDgm9yWH0-a5Nv>U`x5oRkpX|C<
z^pKjR<S@?s7bo5UKJ^>V8_;B_Nla=ZVk>8P7ra~(&zsO>i$yzjZ0fDTCd!Hr-&gEA
zuy2dzcV@|!xx)&SrQ*Zzgvt4%N}$bRhO7Df56xKsUaE`d@twr;TX!>hxUM?U`fsz0
z5#Q!yKE27Sq<9^ZQRf*~suHjAL>VSti(4NiqdW^{NlbX^O>p`XpDE<2N>eXmAhWQ<
ztNS*Z<)QeX8dESLLKb=9%oDB!l*o!<F)FHBtrP)+dJ5Qf`@=0rD(kApmMYvpmwN5`
zM({p?_)Y}t`Qe+oTQ1a$2F}kL&?Fjuo@NT=)#vW&^p<-kq1uxdr9z;4(??p_qgm!v
zE?ooZ$O}**QjevCVt0Ilbd(3h%#efx8l_t8EK5QKtNPfy@U%#S6ips*q5$o2WymrY
z^ppUV-kEuT3LJ%naKj&uZw3CzV?Bv&r_PUCTH4v4_Wq+w@5WN*CxsOw_)lZ9veasO
zpg=AoO})3WT2u4z9nYJ}<S47QlcZ<eF?h%tvldoI>16H*WCl?O^z13B06KVRWx$J<
z7Jq0Smg9L0C`a+?)@fOEl{$CUq%UuExT@<Ks<q|yU*^hN1glVwO&aB$TFU{oAfCsB
z5?Y7hEtQ#_e<gA`ZWODp#Y$x-j(R)I>?Os=azokvW=zNKeY$AYePYvq!f5Zf0ZlC*
z_mm_Y#F8%S<bvOHvR=K^>SUQ7!i2R`Cugifb@Gi7N9zL%^N3N_#vy80=bdjfG*2_}
zJYtlPN-v6o%a*^N-aj1_^*nl%Bi6VVc`9PeSfs18Yvv(gZCKkhof}rS<?x5i#(O-E
z9VK)%Q(D(S)jt5S8^?`ZY8hDUb<JzX-&t`ElFQA$B-eVGL6e)%^pi)53RI_`f;Bu|
zlx+d!!1Ra+h)1*)Uh7`C2Z*;gZXlE9@<^s<{Jt&kNxNU@PCr$DZZzA{sWLa)@06y`
zzn$9O4Lv1I%fc*7JUex?$WEY+E)|y_OgN8MPScrtv-fyT33^q+_7bF~mY{i@sf^Vv
z>Sk+p+$2ratabEW;B-9F6gh`5t8_Y9POLdP?=PgSZ!|mQgwPgHyvkSUFc)bn_sZ9*
zf|O`BzGjUYJp{N|JUgV*(mT8Jb15t9#ea=5H>!h7$D>e@m96jVfU`>3ZQt!f2H_^=
zaQ&*Y$z8rPuW93XbD)I6dJM<bPP)sDF(rn16QD?*!AzsbUH<0f!fwh?B3JHO*vO?@
z3{kQ_(y3$bN9@g#t~;Xm$!64D((uNgN9DNgj^-Jy>NeO@wsDJ$Vf*!)%5|TdoClzi
zN2an2;nu9^Ch?)#-`4@jj>oDZ>BiY;So@~nD}?bpMwKnma~&+Jzohp^>;*CBPpu-z
zaU@r_cM$gR+H@+GA2bPhG^>z&QMwE1&e2Z#$o&;7|3KTQ`-pF@c6~%N_3X>+v6Z(j
z*PWzKiC#s}HgcodY-`mh_2Ll_e+k?SP1#d?u2{?asXu3L4$z19u{$!cl{`d#R^(D#
z&$(HAB8Y2gT;I5+B1Mnu7v^4V2T~G`cO?=iy>VwI(Env^o(3$-<6b#7FmLapt6Xgf
z5(bZX<w%7M)64yOX9J}>k9|dgMK98L53Aaq+%4VxQqY|@I?53WlG}}llO2(+65lh=
z_7<s2PsM3zN#H%%cpm*q=xTj1%e+$_F>uXkWCCu;hM{%Eyg2M@B$gYu&L?<uBRqdS
z-&N2=<FT+r!K;l8q?k>gUAvXLSxPRJ&+iwrqAD}gtajfGN*MH0{EA1zA~kiux_Q@*
zr@(Xb21b!UFIG`mJ~6Fz=!@5?j<U;_iIZ9)jXRjfejPj(J+^P{Oqr2HrYU$zI<6?T
zq9}T7R@rO`^guL;{PI{_T>$+&#+49B-8b1Ym5FumC)+2HTmnDUoD%!PnA1wE>+Cip
zc&T-LyCL8cvhh5Qm7_1b=WkoG`U!ylNvsHU1PfNHwqv)x9+wrFmv!cqQa#&7QF^uE
z6S-VZP@+^S>ldX4_E#wO#BZRW<*}<AO{-g#K$XbOY5g@je3E_4Q^2}BhLw;`FO7<*
zu%t>S>pJJ#aU_+HRdF(Zf|cuJ+4BvWSy`{zs?Lbq4+>fyy~@&6_CQdV<%@=&J>Vj&
zsx>!?shMYN-|_sfg0E=C^B7h_X={|EnGU!0DtrypFUh`P>_C{)%riMwwQttig#^ny
z69yl=g3U3N|2}i&V^DMR*j2(1W@cEIv8x=2VIIB8mT0_=L@~U3=$YNFA1E;_p}{YP
z#hFIWv@hS454?^O&m&hky1I8t@`#tU*GqQ+3-GvAj#M<Hc2aVeU%+1RxK$+ANV#v$
z>$?xQ6^~eDOT;v=FFt=MHvljmrOFX(8n%A!L5q-7R%Pr+6|a+PV0+)$9Yc{3xIt@o
zsX!g~<*;gpKo!fID@E$spO@C1_Ei2CcY)NyBUK5pDi6%Ouzx+eR}6Aq8E2Uzjn!Hc
zo~CL|;k!8LOKTb$8AOJ!(p~ZmU*hknQmGzmnJ>p#vtgIO<5>w?q-nm8T<qD`%q>gc
zQLIQFez{=w%4dHw9XEkTuCm0+`MMHkp3L2ME|SVEnCX)`X6vg@*(G0^?v=n}SXsKt
zd~RlkKHJiAAf34(Oy8L{rM}l_`e_px6L>r;(%Dlnl4GTpKDz_y$xXOIqNu@is7b%E
zXt)_%2|SvWttY%gYj-sHHqw?Gw4|*U7%5~2F5Gp&%(zO=)-Pm5VXFshm8Qi$FmL4&
zctk750`j#It6tJVczc<gtAQ`@7+17{ktL7DOdbn%jmNjLB@*-0@iAGC_iX*chXgi6
z6p@u}g8zgmryk!iBBfNVB}N<d)ek0J02s!jT#>pa?~Wqk;9a+FA+hYp6=H=AbcgsY
zzVKiqmYaRUbdU;<AN(B>%Z*<WD?Gv0R&Lpi@*TR7SaJt-%j8KiOm=j)Z1<i!nqE7m
zpP?pJ{HhheT;5ml#Fo*$jyO$<DArGt6vtbV%hmyLEL$~xaU9w<X^7!jO8-+x7=g4_
z4B^kll7?t%-2{Xths(UyzVxG@ubSY`$#M=mVY+|!bbfF!00tf>>v6sLM<KC$LH9wR
z`ryr=5)$?FFm>`*`;dmLqppzWLX0%!KYzEFk0i2!mLwWrIDJ6gJm{HO@hT+h71x);
zmQF_+vI3Rl8L9i~+$Sr5(C6{1tdCX^S{vPyh!4IPNja88s~+#0V=a%jK4iS#OBAHo
ztg&`*XgIb~7RwUOH#SX>dh*=*Arz@}4X9}9PpXodTA>+g_Q<e*bKNt2OA4{2G||3v
zW<_+XGL83Es(&Q<aMS3+%`=+q*uAG|#yWG(af@2%CtcK1pF+Y`7^o!_u(#2?U@D*V
zBp98Sz?(#63w`Ak_g++n+2WC#{zSSm1J|N8dU&*iE(IgjyaD`}N4TP)CZf>{xRTc=
z98Yk2p{iY(0USf`PiQ6A*|RU@M32vmVd_?z<dpVD`xQk(eN(Ny|1k<bM{d;Q=zUj_
zP~RYyLcM@PG5qh;<AvOfQes$czHbZ@nNu%}S`7HCB~X<|rK0UeEu=+1{<Q`P^^ITm
z`O(0z+rzqzHp$KjJTet&THU%A3Gof&c71)N);3TV#Y=e16az@I#TOA}5r~AxhK#xa
zB7rxBiu7)89Prkk|7jFBi18Rzk6UeJ&`2sizv2S(C6WXlkII&6bim7gKXeO{$&6X}
zEv4Px9xsTVo*A-Xn(7@A7d>oVFeLCuRF8YV@~*SgD10AFn6}7`2_<}GiR2r;J$vfG
zyJ%bCuH?q_Q$SW}cV+6hW+4~Tyk2=1V^o36z!d@^9`1W*bRyD|nPdejXsO`on0F(<
zS(!(ivgR>T2hGg}vhY}XVDeo0FYUbHPn)s}4>3CLYKMdMi$A(%!-zatQW|8-E<tA6
z^SR0)(@F=(e6K{gfyk9V7AZOwbUJv0se~m2x3XS(=Pm<Xf@RNcx|1DGO8f(aoByOL
z8_ezYvH=XM?%MY;+CgRzJDg4Pp#S#lPX{71GgB|3Y*O^*Zj_elidCXlRx^IlYmF$;
zO`GMF?z7AnmlOO+Q?_Z-w5a%|$B+Ro#3<3rV@ruyQVM54`t57mW^@JH&m&8bP<XL_
z`rEr+LaH)TF1=&zt&pgcy>hhQ;{axOOevwNamL#<bS-jH-h?VkAa2x`zBaq3>rLuL
zNq5Q=3xuL{b~My|ci!BZNGvnil33B@F-`~@UjOm|0!8|%+A>3x#EPzwD2`mbmCiMD
z&5!A5$C%OTZK6_~o?biefa|SFoJtG$#VG-R9i}oXRIlByBnj2pasEsxJ1guEv-;XZ
zj?)uD&n^icxT-2<<<X^tbK(B!<dd!QBB{(&Yq9#=v%cJ?jSX9$M^c&LO0+&uaMr$(
z&<IJDN19B-fTV_+r&8A?Eh|q2B`1$O^*H`0%+UjH-iI`01}wFC1!U{+|9;tNe<Mw$
zw`TtQ)I8Q@j@~t4IntCFtX4zX%&K*!MD;^bnQ;mR;8C#Nio4jwJsBy%DpmChR^#bM
z+?+Sim8irNk1vJ4*u1mJ_#ptIcqAzjskdMIq#vD&bmT=S(Iky>xNgysQ;|qscoL`4
z$R(v-UAGm9<i#e5G_;KG(lHBgA|4w`SW+NJ=(1CS^TPS>{!YM5+zNHeeM8d%=QUwD
zjXeexvt;UWdBN#uD`yu;g@4V_Z6{@EEt~jrp;U!)8t;PNePr`4WL;i}+WNZRth2$C
zLbSjKgSNVLni8T?sBegxU~*vG;fp|19v#Z@15y5I#qVQT##{mi3LYIwN_7H3Zr8K_
z+|`X*+}e@QpAMyLS4JzV{hW36$JU`x3ZF4^#AM(L{>&&v_?T>lFU+lZpa@7TJYJNr
z1+_|b`(F9t(MQm(@y@R#Q@+V4lXd$azB-7c`bMvH0wSq`Tw);2g_M6jMN+x3YrXq!
z)WH#pFAPOimH8^ObWOUNoxD^3^n4I$Dg(?<rhZXCQ9GqXxlsREMy+zJ^o?4xSlROT
zIB@xp$m2i>pMnJ08?7=Hm?xG*9udkBD$YTA5%ltRKTJVlxha-(1@&6-xZdN<7Ga|Q
ztSQG?pX=FA6z$<>5O%CnY>atHnaJZr32T@q!ko=pjWT=YiM)YRwnWeUjzq3!>aVD0
zB3Gh67s^2{@!9oe`^~{y)21b-n{!7Jc^}$y6s~S{;l+7V@D;Qqan~agzC{-1hOk+B
zef0TTJ<PO|$eTVz3X8s;>_p1MdwRms9xgB_AuJoQej!Y5X2*rxv}prh$Y#<h68&jW
z?xtmHb~QrW*G9CAOe~`HH*YrVx&Q<Rj}YY;qPqQ!OR;sPD>rVpaXc_Ij~*rDBgQB-
zjYf4_ve0B2B>K~%oS@e8<eB0h-)CltL>@0n=t-?D{m78i>b3pAZF#e(NTyNV4;{F-
zm&ry>jN#^8YU+rKUo*lc747^q63k7#Bv@(9%Sz$vOV`rT{&Pc@1Y4gu)ga;O=saDK
zTy6%o<$7xn%E7PA-@VSPoRzkzUjPf+>UnK*dSUSKz(jvKl<TX)28h_&CicSXz`uA@
zDDp3(0;@861Q@rH$YeoT5)D|SX#G0(o<U%@m|Q4Vt_$N58E4=3L2-gxk}Xe>iT(qr
z9Ap%)FSl`DUzSn}o?I}AE@vLpr25v(QtH)+$}_i?if9=zGjdY=b0sQjs5@f*<%#Ci
zbs}#hmA!MKIcp8H23Ob1Chy#Ytj!K)k=*q9ly<TI%g<f|^%;{p<-8_rmZ(L~j=39&
z<%TjKc~T@VtJCdu7txheESoESk!;?nt-A7YaiFO`cghLmFx<m;-zfYP5-Y2Q%uf@b
zPe<F8|H%rMkyuta-QNDfv|y?0Xm)+nxNIO*@K{nIv7r2aadoHGNMBa($`LG%mAbyg
zPE_gOBD#VRJf@ToYkdS-7y4e;?BKpKk@v+uOQ>}dq>HU|_{wc$0#@W&Vl7^eF7{ye
z8SRl+RuXo^ie#aS9raE7??DX~#|qr`-WDrGZ24I~TWu9mRf$-+|9%l`1%j^SkdK=_
z1kjL2m9p;csbn%M+j|f6djc5MfA$oCfh||GYm5~9L;m{Uy|6?cU&<CM2dT-N)_L7O
z4af>!+GnCaS&DMn7>l5qamSPn#`&Rc%zI!~Rw9okWvgqC=FsZ9{qaY)(V2&SO4RbW
zQnp;W#kT41n(SVu9vlL)FOM<h$hN9;*u~0sdT0wb@2HwHV;FuWxb)`v7m-Y609z9*
z(=;peZgU}rc~y|eV@`>d7`=z9h@=31xZ2$J!Rc4lO@0BaGq5O)Z5}y17T`CJEk$}-
zpL10-C7~n!=v4&?Wu;tOs2RGq$`t*{eSBr-d6T9{C`E#C<~tE_PiwGGJkk_NZSUD9
zdiu+a^VUR)N~F!C;AkK2{q}n8-*^SI5_rR<+GkG1Bd!10c?Pf!5_y~{bbdN{EO!Tx
z8F&;aOCV(icgG~w7QMB71(}z!gX#yq(Q0F@)nm(Q+zzy;*y2UBY0PXZ5}3v5Q38QN
zcHhO0A?l!#b7eyz(~uSLs*H=1r~X5ABcefWR9e}YIvD9Hlb94c<$-@tMayGK*&BxL
z9dgba3cePfs2uuzwG~tD6~mIZPEWaKA#g6<P$^qictrpEt5I>tw9MEg(+WT^%8sck
z`v4MFB9AjA)HMXwdim-1(eq2s%G{`;NP=b8?KYFA0pw0(rdKMy%v-YPI`2&c)dugI
ze%8}dHpJAPg<n_Ci44JwTl+nKZ}m-)dwtHD_gzO&B3IhMH*)1bI2mGd{=SgnN>#AS
zpEPAxwTOsG(U9@&!9GYVGv9{m0%v=p{z8+9naKOzpP3iyq%=$f5X<|_pAd&hlbh=_
zeGw#Z|8M-+CbeF~*T7}lcbEDiMP;RxX>f_JFQXI9s$)X|-#amh8M1C7l+HBb^!as2
zP3fbVt7)bz@}>3#?)U=vl5cu->=`Dxe80KI??_o@oKi!X09)B9iqeS9%|c%#QleDq
z>KCPefEV@Fg;~G=Ji3%{Q!51sV<@VUUBCSFUhrB%B9Ag9bBe5kK5sIs5J5HRs$dCk
zq|}&HLBIsVnSXt$%RzwuyopklmPA6<9{t`YK1as^-go+Jp=JeesZWc)0r2yPQ?^iY
zDC0oz@`;mRx>_P{j+Br~uiAUl3GM#-g}zMzZ9U$H`r1c!@7SlW{W3yX&9*m=-@Ore
zs|<lmL7;n=bnEV27d!m;1V9!^<V})lZ;h<fLW{z+@SDy1xLB=(tHc1ma5dVc0|vLM
z17L+mn`&?0tePXrhF`w*GdOE8XjAkyAyrm%)TS<fjCdW^#DZ_mo?QUE!Jj^5zfo7Z
zG+j=hZ>2UVo2Quh;!C1Gb;=ejhZ_^EP#izZzFh3QQn^5Phryz<Oe0r-otQ!svYi4<
z2gcX?H0h%Fs@SyOKrL9NeP67$IiNX_@fANuJeft@!$aYfbIrSmboWokj&S-KFqLBD
zKjvJ*gog23k>ULVT@i1&r4Vn>xL!N?b1x)ahGsYzairT*tA%B%SFF*ow_<mS`z<Y-
zKJ9{(jC-Z(^^1FJ*o=-*Uo?;S%-qc+2Kma-nNDl=ZhBQFz<wrX`iNp8v(isy*CYlB
zOBY_fVrt*sY3a|G(e>}W<BwF+=1GjnRGuZ$A}dx5<uO?vv_8H*E4d@#nEC+nhAzyG
zHn0cDx2j9uz-|`3Kdwc_njF10Xe7<;JLXs)yrCsj@xBLTuXw8)<Bn#K%FkSK<N`_d
zegHekpQ06#p6yV}2r=Iz;&{Z&ZME&0FH-!p>i0cFme+0LTZ((c&+J+{qW}7cnY#2_
zvxZfo<F5BIAjzMu6_UPtU#pC)lLil6Qb?axlci(t1T!-wF{W5KKI48BT=Xcc_L>r@
z<o2(gFV~(f=DnBmNet$eBi{lr>#Zh{`K&IsrxGSKC^qsGpie8W`1qj#m~GXe|Bx*Y
z3BBp3xT8Ob%T0Wa-UJEu>n>XPLdJRFo>Jhm-boBLmt!1y-wWowCwt8)37~+%<8mci
zP$sGki#(@o>e4FJE<7R(LqF9xzEI#Ahn%HKq%|QnvT9`Cp7m3kG)7hKh1fF((PQ|6
zf_EV+i<sHFM8o`Dk#zrKxnm^jW6!h$)^~|DBQ0sN>~(@04RRRdFRyg+AozCY+3RET
zBK6tzfulZEA7;L~_rmE_#fAFxQ}>u%9?%>svW@T{WlE({a1Vd?uWslm*oA_<4%lLX
zhIflq>+T*ul|n&sD*T{9SYJ=GC(blGVAf?x41Soiu@(`CtZwIV&2LWBZPXPYGJ_`O
zh_|lQh3TD=J57_{ZRLd>NPTIOFnQdKDOWyzE8x+6k=M)<LlT2Krm0Wup9*LWR?FW9
z4*-GX&mwalz$#ip_7OX*S*YbbU8~SgB=2CPq*x{{Sm!9g_v&L;X)$HRUeLq9<Ijk_
zC*DB2?OQo?P3zvbOK(AU5yhJLTx|&w4^qt5ruDuzTjfcy{ve^q7jPXVN_;&KRyP}*
zJ5tz*ehNe|2xhkIwj%F76D7WiJjk7kU|lHd%WRrCxf1dye}r(B5j`34Jzud>39FIn
zZKe=Pl%AOWEI<jF&U{hAE0c2jyk9q*28Rg-`OMbZI-x{G7Pp*MH_7nij~_ALI7niA
z6wxc(-BVe~7M+`QJQ-W7d;GtP*kJdbvh^w)tQ%FX{>sBmQ|i}`YSt`c-N@*8{cWrb
zQ|8nok165x8h=6>T46_{sCs+rRv7h%vy5zJKe@eF^rK=4`YF!I_-LZXM0Smm-m|Z0
zLG^v^g)V*Y4eHo?x0FD;?GG8A)k;taT|(dOuc9Is1H@*q*G%D{l{o*teeIF%T!?Ty
z)zaOd^G!`EQ3&boUq+a^i#XOzQ)uH$rIC0pHh6UR1~CD{v-yUN1;8N7PhVg##|h>6
zY=2*X$P9v;W|69<rxe=NyBm`2e{W~VHVU;}2Nw!Dnf{7q5`*bx$Oc7K{q~n~An6i=
z!&N1wbniYA7(ck~<ekVaawFN&4G%9`>(8}F^T44mt|Uwc-*d;fIUqP0<Tu?e09f)r
zx~Kz)p7_9#FYYHn?QyVwnc+zHz_BmH8}9gc?s-ok-2+EH-K}~(h9W;b>P9-~Fv?B!
zi+nhW==hzZQBlAk$C<lnIAYHNb1wmlC^NpfPHtUe=}?<?@MtTrn+&>~rn@LqjTARv
zN#D9ic;N6C!VOo69P#|8$S{GU->%?w!z{=h{}vK2eT8Xv67Tgy!mihje^(BfhI>K?
zr8ptp@R_+KMm9#e2SxxP9K1@^?ZUlz0q!!s*{J!<<EG2>oB3frBs(wwh_<4-r4;=m
za=bX(y#-X-2GZny(NEn!RVZ!bkh2f=0SYr%c7`#GecZmF#sT0Y462<j8wBUEZ@%A)
zg!^|4OyM3=lU2SP{&OtwKnC&76b|Z&r|#K!2NEAR_U%TfzNh&MZpc951INBi9k9jA
z)7YYGuSAo0t%vCUrAO_o)N;q3)GTWf^rKkw<+nD`eUx_C^C#yS;&)eSN=saJmXOD=
z74vhgM+OR515hsu9gV(xun_8jGQI-o@g5SdmD2<R5B+%~pGhxJKDg%x14f)KY}xz=
z(C$%gE?K$4))%;Y@#DF`2i%gByO1FA&1BTznF3qDb}|@zhP_3`aLNGb?<Id++?m9a
ziIhXTKcmm<kk%bzwn?+}%dVd)jjoBb4+sWieG#ul5%a&&?H&X;$(V`eF^+YiV+f!0
zXPLD~cbSt|J8KCCj&nYG(g={86klhG*TRS({<HY6MuQU)<NK1DUBoqu>5{XO3NAuc
z4_F6SuXA{;P6#mIjUM2$If~}K2w)!Rs{dFw4Jgdu18U}w5hU?;{Buojfqi7K0yW{F
z;@S}Ld>q(Ee}bUXt9B|;qA-aN(o<>1ucsnFTc5!c^k`1J5n&i`r8{8y@g?9Yn!y_M
zF3`QZGhIe>PxXhGy|qpY5Ty(fp=S*dpfKHyTK#w(kUkh(LPNaLZIJl8X7TH{NWNBY
z__GSV_)8>=jMX`s8UXxquGHelJOQf#G7ob8grcSEA_ol!1tcCE3jWUZc<3V*%Ar6C
z_r(GeypHtSz7!aQK{qru6lJ8;v73(}@d5jR0(GG~et-MEejsESv_r4<ws?REg=hTT
z73m+aEkOE<HjfA0DKV{Su;P6rK43jS;*mS{Yqj<j;EoLPp<y0?#@QOrjYrA{EC@(>
z;X1~-?2RW!-9mdCurna8xyd%5H_&Rp#}xq~j`8VBk9BPRkyrwJ5_VwpmNEeGE6b2&
z6*ZwH^i#dnDyW+JsM#t|lDQu$$PrR9i~qf>-(zNpkj!8rdTe98IAZK<tNA&1nU0gp
zU?Q5rh4<(wuwH@N2}pdvZh`eOI4D&Az4NpF$TR^VAq_fx?5->Kn536v#%wsvG$NuX
zu*8uS-rp9U*AU$3CHvD6y_J->FMzn5`d0R$XbS>D1Bpkld9~fs`;qv7&_Lo5Z2nyS
z`aUE+V3FX6H{8F}lMj7v(g~6oj70AqTSY<%@dYJMS|La%y77PW%v(dH1owjkfR@+a
zsW!&UCCLmvBGOuq*@7Lq9x&_5WCjrtNC$cR>56+=f-Pmx5l#6ZkDofYwhR&<6cg--
z_3S5=31990`WUi(z%qeIkKlBC{L`M`yGY55v2$MASkfJDmlb{9m*4G8rtx-ElKokT
z-im%lyx?x%VRlqzfBElpWci>_K+1!SjeI^Uxa3QY2?_;5yg(WQ3i^ET#A&2`!1{m~
zh<bC9a3KHcLXqwm5P4uwj>~>H;L>wsVbJV@PP5ITDVf1N^f-&7F}$Ok(xdrQU=#-b
z&{zVY`<T<e-f7mA$&8tGNIWPIe#!dxJpkVs1Vm$jwDd?>oynMLe6CPUdW45PUCLyC
z0-_dEyZ1F1x%%>&1fyyG*`!s=%-6Y+83aVnBbe?}xb@br&4M_YG04s%*q&fkqO9Td
zgq9Z@PH%`dI3OfgBu(qZG(B0(Y;k%pdWe9aU@aiHny^4yRpH&=krM?(28++wHm!=N
zMV?VerUVX+ZVdjwBp4{&E<bQkre{glT=`ImZbYmr?R8Cm)}iZ~!&AoAsx@|Ml?eJ8
z^{grpGwF?#v~9JWR*qchRK1u4BFL7}R`P8v$dzd3VwH%rv6Z*dO7-iFtyMo_=AejO
z##)d5GV}{dz_jb~S|FKEN*tbIuXXL%tPaEUPsHqMHh(@y@BV~Drx>^1ml70QA_<xy
z*X*-iZ$}Ef>8I+>Egq<hwcp1QD~LoRFxB!Z#hobXUg-Hh&|^<#jLown+g%1TeOILJ
zIBRy5li3VJLeX$s*4~SXE(Ty1$HfarwrTmhA1RlU{FQ#H<+(WF2u9Y<n)cHK06~mV
zdbYJ~(bg;;%WXuW@l>4z5QE33odb;p={J4=ffRo_-;s|98#H`ilMi*pL!?;I=Xt~i
zY6%g4tuH#2z{ty^Pxc?V=Rm}colzAJI8@>?73)QnE1P#;)Xvv)ztH;*Z9r>U?TrtD
z^9!4s=sXrZgm~fJyB8E)wdR+t4))uB9G?Rbs(gY8w8p2)KP(Aij4_%|^(o9CPJQl)
zP5|N<<M|BP!bW;RF0%8%en>jE-C$eC(j1(8+jV<41=%GSK3MNZcw&t9HK|VXdPwtN
z5Mjv%cIor`o$ZlyZV}<yML@o07s7|9?(X#tC?F*BBvX749%x<1>3g~JiM3lmB(WKa
zw$5}zPQ5R)JDA#f)OWxpY?7i!zCo|3oINcLoL$%)MJZiOSuk&I56#&PsJ_XJ*?wvm
zSy%9&NwR9$mD0#G67e(dR@=(kuY;PpZ<$fMC6X@vg)LokMhc`nA2hrKy0VO6e_qQ}
zMK{A&yEPsK5;<e=pDx_!0Ay*L&@WP?DEcWi0-K;{+q|Q=5_T@P?bC!FRc(GbeU?s(
z+KDkC7!oMUSh-zYg%IJpZ)+X`6@!FfKSZFXQH9dZuKN9O32>ZavleX&iR*Z(T=feS
zTA=>6cP4|FWm6aJ1?bLJaUNNO{5o=B4HB<4!2G8LdWw*+H`=A<<*p9!l1*Qf+6(iD
z4xw)TQhR<`2Evx{wN=&k$vWtg@9~?9x+Cp_fr4{|2q0}_$5&I3^GKKEfQ}VY<UVGN
zpXJ#%A4cX0Rvd`j4O<!C&z%L{O-^Ra8T1(6z5;cM59yiHc3ro)BD!b#f`ZpGX|}^U
zjcY+@u>R+#H@T>(bRVT<GDQQYN>yqEsd&NTkujt+?W_Wt{v<|2apH{jGG5*LDc9TW
zK=Xx7Vzgt*zO@xqNGM&&C)lv~?xXYsw2Jx!zIT+KC)iPUPrcNXwK)zMJeR4juD=G{
z(x1oZIWJh(w;-x^rN7r6RK$!4g{oUx(v1pg>B&B&kmkV<A>8F{|N14CBI&{Kz>+Q+
z7CKg5-S*PkNV;@+4%*n#O(dS$Xk}R>J=j^nx_1V;pMA8`3MAbZ47?sAa9()4r_3QN
z*j;aRBlmq_1q-C=94w%)(oKG1W?CtbKot4|%jCA&p+J@Q9lgdSEda%Va+k`LFZgcm
zo=P03KcUNqpg2&jXu^p1;y`>Dx?A2^$36p_sx*1Sh&MKsiUZyD+hb=GK(+~XUZ7h^
zc-TpJVf_1OYl9(y*wZj4!2+?DhX9mka~W-vcjPP0aOphlDwTQ;R3H9qMvwWO6;L;A
z$UEPTMEfh_inG78fY@K7InlS&;%5NNGe#z=FmHCH2@t-0Z_;>hRFG&B77)bn5<1z_
zunyfJHxKw3ynK+%CNtVQYEL3W=B`|{QVQ@$#uP=>AVR*Fqlo19SbO%EIRP}8O=ooV
z*X{D!tWWa*KV%G1RP`o}$xnp4=nFj4bJQVo9#b-7hN8VdkB%?7=U00^JdMggeA1pZ
z{)#fEVkNT~jp{<wY%Pn%iah#V);f`*Fr%MRoH2$f8c$O~EMWB&K^67K(-i>0F}X6g
zT2P*amNCyJz4PAxA|R8o369DFLVbHb&^puZE4&x2BZE0}6ry!(*L64FE>cu4Bg|;|
z$Jc2lok59iAIt!bJ8*XHzbcAtrk~vE%50vaqPpWw@=nFQnlR2?d*2;?4{<2Gw~3Yg
z`HybWZxprPxtchdy;F`_Z6k;4SBeR9M_e(Hsxo5|qjX_=OR#HoIJK~e*-xs>_(rZS
zKSsDNbq55d8wu$7OC#Sg$tIQAY)H8~cDfL;sQMH&e~KO3wcD&=Dzk}@eR}qG=NO~V
zSo_X}g^^;b>8JV^_q@^PrS55c%UCmDqMX4mXqnM**LIniy0ZU(#;$4Uos|(zk^&`5
z)a31{m#M}eE2)p*TVn`sZE#@B-rak~9%*X55T`c@$o{jh?O)+i6;<gB>=2r_?b(f{
zDyf@FKrw3JohjyPlS-QQ0SXgJ2gPNpWoG8e9QLD7(`n5XH|5^-@zGB1xk!0@4)0Ns
zi)x9f{bJ6S6kA3=RkCk~!Ey;lV;ju+^zGQYZ=Y6aeP6IACaUJ9JzU-8Kq~nQ{nVux
z>__<!_}*|${qq@STfZ{nGrQ#2&QpX-zz_d2d;t>9IACbP!Bx%PR}Vdcgfk*v6AljR
z&%b?RCP1wiM(LmmuVB|Ep7@~+%^T4aj0LUCVLhti0oQcG@lU}#hRQL#a1ZUL(rC9&
zTNL%h-no3yg%a6gP>N@ts7FzB?~u#+L40!Pj$TW6IwEA_;)4!71R$Hka`Z|DzPIqN
z*DD~|fns0Gszdjue_R+o2gwc??8@7J^1OVd@67W6Nc?$?DrQ+T_6(P<m);BvkEzUI
zG<wVp=M4Rt?Xk;9?|`u`vajJLKYd-T4uBEP_(V-_;3sEZd3zGl+c&iv_BMJ$O_y$c
z6p0QP=z3d%;{5I&-#%fs4wS=eW^pbEov?NAP5M8xft~$%i(XR*eZfhu$^Pe)fiXDK
z64gx<!VUj;`RnO#AiV>Ix)2Tg<HnO;Z9u{U#ySaiTc0x6>wK`I4KfO&d#D-3aK882
zY`+uf9Wb#Ay+Q8X_F}(5NO-_t7sA1LG`;nt0U+OSxQMDzz}uROcbAw6a62wwtiw0w
z2R5A(fwT@7?2mg}%oOV>JvRRfDtYN6KCy0A+^zdGNd|V{5D>i<4t4XTOW!`ybRlqQ
zf4-p?L{Q`F^rFk5%T%St<`4`$Y6A%Q<z%}PNb7)6F0?iRvEDOvM}t`5Pzp7zK_G5T
zIJU}ceplvj3Z-yrY$-Q0axd3y-~2dIJy4ii(m`Y6-hw~;g@gyH-$}SY5u?<p`_s~P
z$io9gItd3T(sFW+r;zMGk#5WOq%w;2Wj{Ri9;n|XX#2!Es^1sY$aN6-Hiu0peZ-v1
zLIwPs>UZ`9d&nUYYNCZb^dt4EIeV5N;epb647mqL>$gYmyB`S;6!4aCfPrHV?;j0v
zL4t(ru+3oAEWr0t7ZxfCe2?+HV5JujX7)?PspZBZ*@2>+WCNU9b^oAGknBLgZpk)_
zsO3NGn~(fEP^=5t07f?dw&e^G9VpZ-(VnzGk-lknw$-45m&VR4(#faM<=<N)Mh*Zy
z5e`pKIvx%05uIo-yl2cOBchOa-`9=Q-0p}E6@Fyj+*t@svM<Zgn;Q1sNqCi6EWri`
zoT2A+_pBHZ(_mcvRQHWODgRo`jmJp7mvB_spC)K^aUJ<tQX|%{kDxc148qYbXQICb
z7Y-bnptOD_B+Zd?Z=VF1#rWQ^68r)S;ak3+Z@>B)h*1A2hw9#vaDZCp&fmKUR4M)=
z4o%r0PrO+*X(BR9p!l~m2M92+!PK{q@IVOQ2sg5Q?BQcIz-68UMIQ_Z#gHu7a(~|B
z0?^l=7U(gxprfF>sBJ@ESPkNz!wHlQ?u_IBN#ecL$G<@010{S%JTT3z4{}xn9?szd
zdbI~V-Mv%y{)$u&l<`S*d?c<qZO<qqUe<+-f`Y`0Bo~Sx35+d9bv;GEMfZ%#!OH(5
z#wsw@wZAYYzcwMAve!2&yO`XI%AC1|ish|@M}8?>M|<(Ia%8#RLBXYr2xQnta52q;
z#DVv|Y7Q!Zq(Jd+u{=Fz6siEKwi@sUIM++q@`--)T;F%l3{(kmh=9`07WLAjEam3b
zeSVz|EX?5ms-i)1IG*RO`+<f1>3=F>S!4-A=>@fiR|8<kq5gT47A|L&osGWvbP5t4
zDCC7JL!?bz@X&Z9JW#+p!aZq+_Oe&ow~hlK<dFUpvrrvj#!K#PSE7*OGN*AOF-(mz
zvsc^W00xs~$nb@WoU9)>@4uP*7bHGdtlPQ^uvNuVyw58A)Eyw(OX-=#d&l(7fZg<d
zp=IZQwG}!L(;%pavZhnSKS+3>YM*>i2seCi^vy-3fUT9AO1|crt;xmn<!-V7xVUmb
z!W0hxYvk;j4<ow-3;Zx8R;3P`|3r!h3w$9Q#OC{jH{}Cqn8WFlaW4uhLM)r5rlsLB
zXETl>%LEF3X8{Auca&TVMhsWxF!{XNOJA22P>tBJ_Y)OOJ9_#LDO4+<9lQ55-Qf&j
zf5ZEJJjMT*kDnfFocI$Inw?+#qvqaUYy0&#j#ffwbj7{{`?hF)XO?UXM<;qR>?dUX
zeSdaiLxuD}5J1wA>Ju}5k43@*mHUE74Cm84TeFWjE=*`1sJ|zK<9fXG(u@1t*S<pq
zvydJL0?hjDt<N+5hb$5(_=VWWa&+0K1?RZ_xqn8UB0EkDPqBoTqjE@-{@nFH%{zKw
zkwBqO(%Xab{=lKuYmB!Pgz!LlKQu2%Hu_}zKbj{cSEPu44^vF6Ad_<#<EZgprfj)J
zN1E?%Rkulnp?7wfHPeKEqDA69F-rafC7d#Y0PB;MYEeOn?nv9U=H0iD7%2X&=%mK2
zwyAX*e$~@R(n5Hk@VAAdZT&UZ&u@{@>8C^yXCR?Kbm#pLhYuxOCmdfs@6V@38N__?
z6g(*KE@M56LuWTKRJCrKHz0HIP=P8X_cNmKhIwd(zdIU7F!3BbbPyryh!>{P_Bs3T
zQf-atKSDAO8f=bqaRl-0A77bD!)H97nG}L~sG#uS#dlm0|566<t}mXpK3zxkjp|Fj
z5Mc$dJLE>Z#@j4o=zgQK+wSp%(*Qe}ls)G;h#YSWouR^@bH?O5L17^CU}mTwUZa7j
zd(V;tgqcj%o~p9*7P8^)A3qfL4Dd%Ld(U10GhSPtc(g2%EG-fSjjfh|D_PcgvJ*9<
z_RIZ^@;V`!GnY_6jv_hKUz9Gm;)@ESsf(t$pg(g@b-|Wy0oltKNVt1{3zMoVbmzst
ztvg*iLrUW}Zyat5Je)I>Fk~1@IP8@a8U0!%G8Fxk=wveZr0OC?>DU!_{Mlhhv~S=m
zzCz!Q54A<5vur7l>t*CDzD0pow9<05WmC*2|8dVzPzlJK<P-BIh)+LT@k;>WO!l5_
zW9x?1wy^Z;o>N-)q^gwML)kok=APo$bsN@estibw!b=^S)EWu*4Ruwx_|k=#0APOU
zqS}I<qd+~)87dfZYP!2oB1UTdznhgdA<ccWy{0+*Mn~QkU#kkjkuyoqtGU%J*LU>E
zn<IN8)qV55t~z>~B{Iji=J0}qXeNEn_Cva=5KRWqqkE%Dmp;faLBgG+3!X9P=`Jn(
z)ayukkccPg;)tQ?PBFh})#g{-Q)7snpP(EX!^XUIb|H&^?<?f#9eV`m%p~(U_O|X;
zs#mPhvA0$l{&wZxB!GcTI-esw%w(55i9ee}Dq#=b*jMnCrpBN|U#Z8-y8#+<h6RQK
zh%SVT#$~0OCo_;ie8XN*+PbX}exm2HRh>5OL0cIl!_zTBIJf40bW}W0_~Fh-x^L90
znmd7M>OS~^4QG(_Af-N?QSc4ra}8@+)DW$<iuVnB1+lVBiWs*(!kVmW6!`sjZ90Z_
zHAvv2#wCUQ-EU5B3&LJ*s(;u6E>6xz=00JNO%kG+tUfz19gX1x@@wbQ>Vd;7liKHz
zj|PrCu;jt%AT@J_1cu_%QQs_ursaO`eXyIH5rH1z2w3JkGdCNuOOW^{#f5BSm#5x-
z^Ha2~(p&tGK8|=ej^lR!PQMsKRE66F0RfWl915-Oiw<L(OU-)Ncx73v5d;d9HOQCr
zC3;ORRT7*KIU@t*4#QE=BhU6kML%asU`Vn(J;Uplgan)G{_&ohl#~KM+TI@tV60yK
zVOA}-fuL0AOxm9vt6ps>Up&;MLm^;e&P+hX5@kVAQSa5e)+5P562H*5V$*&DwQ?mY
z*XJf(D<RsS;-};|lAPMNcUt=Mn(&W)`gtulYBKqKAv0G8de@AqYqhT^gQ`0iB<zLW
z)v@9kUo_|eK!wTevlY**1idTb)n7n=p2_di<U<dC=lb1S0HSk-0ET?gYES}iymGo@
zM<hE)?zd%o{gEPmNcWn5y6?;@5igO@KjKlA7;}2gXpn@MEI-@ew#v}a8@C&7UbQAf
zGkJcBcyyw;zs|)wK<4Lsz1X{zD2`H#+&Bz8oyqa@Xbvq?Y5BH2z|%QX|8(VT`DOI8
z`Ra2s-lY{hTs&cWUnH<AT`?BLAu6ZPT$Hw8F3O7hot7czk!dKi5<?k?gU6!0xu^QQ
zNWAoUruZ~C(5LHwLq`k}gRqb9Nx(vQMSIKtwZR#b_O_qMi@=P@_><#StbrxQBM>M=
zWK7Ef4g~TE{6RsKN4n$GnKOSl8HSukNg@8^zmVhj%+rb5TP6vVj!X)mGz@iGy?1r8
zsaAGDqZ0%U<Ur~}_*MqmL+sdhG<yO4%i~jyT-yl1fk_9H4-n3Cs*T>+$e00@5Y73v
zu>c2AG*-81HIY@Q8|~aOiu1f){MMOR<zIlHobMZpb$q7vEU(vjQ#oOM`l&m>LkBXA
zcns@UARfcInTn#Pv0e+PUXc)1tEvio-_4xgC#=T8i+bsuy9_MT)?y=xDL7^kJ1H&w
zD`QxikS>EQ6Et$A)6JcbZa)TS8)naW1(9$#Ljuz~Ym2y#V8;Z(#hm%Qx)EH^$w8?h
zWO)(>E>aJdX}q^m{T3-}TV#nd=KD?_oaZ)hA|7?n(K&_&4~Zt3aWz<d=I7}k5|rsf
z{#F<Lv8YI^7!<3}#RO=Wy>{VdS@aOTa6!qyc?io#=|S``D^q#*a&V00aR_bU4mqKC
z8Rwo;Ut(0slFMibRx`m^LbMcO%IZtB`t9?}0Q5N10$mfiPXX_lqmyUXMq9wb3-2Si
zt}k!kQl@V{3~C9^ctBlw3$!ihk=bVZ#wp*G6;V~*i*^2#LdrIO?rBi({ZO%0zkXD+
zW^{L3_v;4E7jn{!FXRkZU!r;iu@?OlZ1rauN_TbkLQdGj#0YuOczoQ77G|-b@Popj
zNAWWDiBC8cxO8|T-zV1eaq=wrBr!bNp=Z}I1K^HEC4M#Q>==b9<qIH=rNRxqdjCSh
z>u7}l(4npX`t21uJ-idGAn$ksJp+KhR|XXuh*k&=AC{Fssqyb$O&XvTd`}~W$J#5H
z_XhXYTa_EF5F9_O6+(rv1d)>;=9p^MtuZ`mqUNjR%F$3(GgmY#nY_^isu&(aQCkD#
z(}t<D%uiJ(#Q4(_!8T}jT2x`Ay*K<NfDw}B=Z_KKhT_?FPoFbSYB37*@cm!8ftMRw
zGb&*lFglN(Xc*mKmgKF|wk6X4zaRu0_4VfN+~#X>2{AlkqN%?bTRE~^dehAPF}%rv
z`U2qP*rEecCL#I%1s%}fuL8MmgW4sA$4fNzH+Fc`GmGW}?BUT9fqe6*w&2jJTF62H
zjvt{cgKncXExxM_k}nSj{1~&!N9Axv$Z)J|r|IU6g~HJFM+Vr>tyeqG8DM!HJ5jT|
z&>Q5&`<}_2idK-I7RWLnH^vV5$9!EmA%^o2Wvw`cDWy%P8>s+(cvMBrM37G$m8H!o
z0H6MRMUYe;H;EEgzj*s8r2l^b2l#D-{*AW3gckTOl><Co7N}n=kJ&qj;jtEt9UyW;
z1(UzH^!W5k=qdgSLI`@KnFR7Ktnwv*h}i!E5%SdudBC{uWX4AGibF|a{t$t#IPN_<
z;{;HfM`zTH4_-hl_w_f=0(|giH6rhae4G20Cv8Gc@L%c&VR$2Z-DorVBzl7Xa=sw>
zZuXMr;}0?xSELoFdR9((alYpZ^L*TrzB0AO;WWz?K3o^`I?Yh0W|6vrFG!#joLBEI
z8_emW4{tsXVvO_UWDTjQ1qkZ%`#(DPGTMp&JxnLfTMGbpJ@@*8wcrrL8(ruL2WJIv
zU|m!o>I3u?!I6U2(90DnC(_>@RvsKQq(Av%1vua}sNAQR*+q-tF(3`wKoGsF<A$=p
zG&~xlxdf=CA4pr*9IX%>Ey(x?FA6_e@*aRkJW8bJ8LZEn8vW9B%Lg?8^#pIwp(Y>1
zSeZ|%q2m~D)S)3Bxc{JqkE8QyeDHdL-X{Q=I5n|*2HJq&D1oQ(UHvKgWh6g%DPaw^
zGdB3h^^arF1_#FnYUg{z6F4+~aNkRykdUb$EI3%VPQ({SGtr)&zW64v3XdqM`Hf!x
z(0%d8x97bCsze@9(j(uQj3%ogB~K3B@I2*6&nM#(V*KfnMxM0hqa7MQp<wrdZ@VMX
zWJ@J!R`h6qLOkZA=V3&E!8v1->veC4R**S>doH6D^dv(YGPnM{r$DOY%}6w!L975$
z&g1D7*MW+HN24^>(1L*;qUvM+>_TP=jum7k<hQqv?#P2y2#yxw^bNQA*K+wQpp6KQ
z7tRVArV?m8z4G1*F7;7fjw&4@U(f)%+a|}`p99nI_>|t=6{bNx+M&fm^ML>GxRu5V
zz<;g`$Wj|ULhy2eY>)is*DQ-#qZNW5Kb#eeS1l$zQ1+=v0ebXP4hKBGrN>AFsr32`
z>_v6icWx|55WKO9o@LT#4NqR9Q2zD$w{M}n4qjK#3n`+y)310VPkoSx9w0bYn1jmb
z0WR*UQW))YaHO#0hYp%D?TozpGRo13!I8q8UPdTUWXRQ###rS9rO)e&66W3XlpMES
z2Uh2CFg3Rk5Mdneb38M=IH<OGBuq^{0ElV>Ud)Nq4-OFKhw8{_Ztw4dZa;ZUOt1PP
zfuXp1>r$(GL0s{;n8pg=#4-G_S3d>kN`ES*(IOHqFG5$~oF2L}uea%ep5Z@WgSCX=
zMW1}}Sbq?^ywQuMkpR3sod5aH&<g(n9mFG`WO@F`h?Ss@;4w0dXAmodQodba6GGHU
z-IJT@2<lEKb%cC~FbE+?R$}Ul#j!eIyj6B_;q({5?)p<Qp#y;+PMY&ZEns^dCDUse
zk>yd4ebat^3|iqoz(kl*X!We6Pa-1)uOq0#4vaJ?D$hsg5rUsMtOY;_%sTzrc(j5%
zx^mAn!ZYDEjF@(E3R)pJPB<$V#nz*jH|_(+*dR1ar-kXPKvYj1?p|3k;Sz}CAZ$!!
z5fRCPnW?YQy?ob^$W*~=33?E*h6hs#D~28)^(kmn$OXb+Me#CLqaxhrm&VLpSr=sF
zAdF1cIPlH3#b<J!Hs5oJ2|~(r<eSA%we7DVqw~f&dVomChU3dN4I48NZ0mnuW6}!Z
zBF-2h{ASA!kDwKT;{>fx35;MH`Dd~FKtb^zxR|tpIFyNsLb<S~vTM`sn@dgRZ47V5
zqh}*R^gnoLdi8~I-_f~@e#+VGKQJ?`m=LqgVDqkQ)!LQJ*<CUI3{9CqExCe|PJ{KU
zMB1<T2=i%nyR<8^EU31FP%~}O#f|46$oOLQ6J^Z<h(dSpg$z^W$Ig^)ZoY9J8-#=D
zsEoL=bxN-|Pf+dM;8=eKrtCPnQ?-a1n}OzncU}G0b0lA1BS3LsKY{hG4JA%Emh`id
zZ=ayXskeC=%bNvh$Ar4fb3N1hc1%m}gBP1y^z&V%#A5W5ff1`r`S7g;)WzHnXu}8l
zDZ0&Xrqjl9KHTiyYuamB)JdapQM==>ubY)wY;=I4LlF;Bb=KV<O-Bm^Xj~`@h;*$-
zb&gAo=OY8jvYxpaCE&rN>&16IMf%H1Ac**o{_<3Exxg!p%u|UnVJ!@7xTliT)GY3)
zMBXLjU4HN;X-&CK@lbzWrV-iJrGAWY-9Bo;;Uu$=i4DTbw71o|s`l1jl;alOvHD*#
zjm9dhG^W`t`BoOy9p|NKr(Z=&1UQr^k05GD^XQ+lEk_Tt+=vZA&Xh|){!+Vf+b5uh
z2yiS>RuFb_86vWAw`S8n^FahC{deY8ST~MZ1khfOi!1#j9ZQHLqB^TDMCi_Hy%pP>
z-i0zJ>%Fyf!3ne#fnmbB^g?}}Ayre)p{)pv6x1s>$NNx;5&OzBjm%St!bS{(70#)I
z4pZ{_RHDVrj4X%AHl)3>0ZQo-W`~Uph>L3qXPvd5UGx~Rje>GvR**HG?WSZK@fg61
zUdVpeDFAtjal$MCA0pc%qto+3o0MP4MKw1KLe_Mif%bq#TFaVDMq8n0N?OQGkD~5H
zfD?+dN|=dUf6b2`3&NQ<Vp6S?!j0t`mOI<a$WDPv3hPip6`#B<mv(x0<#mg*M)j*|
zCtuLeJ<7T_5-tVafGRqp&$Gx>fiZ)6!(s_fmw}M4Lyhg<0#FLV+q5^E7BKPyAx70P
z*|(Z^r;5+|A_fSxB^Pg4Oeqa7{CS&tsO^YPY?iSGOm$qbx79UZm>|qe$1sGY=t6DP
zA6FWo6#}12?2aVp`;U39YXRUryvdYmpotxT4a22(C-nuO>QCL&L%>-8JVW%%^buyq
zFqSu?5<G*Feq<=Wu(0>@$WVa+gPuc#nQ_RunDgORkf8!&g|h&-pUvNVC93p-a5rs-
zb(U~j0WwKX9bPgUJ%k2$alYk+5p?tk3&GUw<#}J6z~cQk#*_jb44Ha-!NOHrZtjdP
zx-I~57KFIz7$)2YEGm53a56Xm2H|bW70d@Xdu>8n;GMh)mTCxy;SVC0nG3w!<fGMS
zfxzbwG?I+6%p2byypQ~deoCqgLfW(qWa@tI@`|BI_rS*wAv&@=oj$al-NdU!??#&&
z7#nDTO2*d@X1;W29MV59GLU$|Dt7djQTy$V=aXmwt!U&8wX|P9w_9vG_B9x}`a_q^
zCl~0~xAAv`(B7|F#Ks4P1?!G8V{}T(4)v$x$&%6_TXuU90)|J<B-a2v3c1T+fWhfe
zWUOlu>QP8!==@f*cK|X3A#K`jX_e9R;e#~Id8Vc$*E2s&5F3QHsjeVW3w0CPhqhTh
z%hoLeW6?^1s|ovAEKiCQFCv=(apg*}s%WLaXko9U&Umz}Cq3(MpNx;mZ6n1`fersJ
zTq_Aj8&&mK<kvYY*OHby+vCs$^gPnH!W`RV5u*%zqH$H?O*`1fc(KQr8O6o3&`*7y
z08pZ=6l1L<0NtrJq}^V6@KdW5{iwE%FQ!1diK*%b4maHqFAmnIP_Eglc^72907n$%
zq38{7G9W6Vy1sMw_(<_c^i$2}3p8+}>_SkR$U;z4V*A_k&9_mNZxn=q8mGlU-_V0a
zW}$2KH-l4Y5Wc5kDC+g0QA86{+W*hI{EiL6`J`2B)FEds?&e(SU++BoU1{2K4e@!O
z&~{Rah)Z`8*x{yicSfZugZpJ{F8!x^1yDEhCT-fKkN0WZhmlMCc&qjnaBmZY|0$QC
z=4BM2GdXbRG^1E9%jhbg(df?t^+u*`xh#`rRf)KE%xM$JMG9Sd{xU%fU1=(D;y;KJ
zEh1)|9d4S^QtZy^4H|HcZv4pta5Uo$<g_=(GbRiUc{){gV=B1m;?3l=7oj|(Og$63
zLkJV1;z`5J+;F%V8I62fHJmTNNW<AROsf=YQcp&+EWP>_yyU)+X!{&N%-e(KjRHLp
ziO>EJV>)uHq;KbdSm9Ac8+Po|w@h16T!<M})K3s;1)MR@cG|ZY)WSTrsI`Q{?J)1J
z>6p-KVCfIRT{CZJr$@Y1T4>cokwf?0B>QNEus>JS+TD6l6%V*GFYV18?tZ~ZI?x9v
zmklE<DdTk@f3m2#1brl`OvQRp<(xTB-p{;|wf>y3ZV1{8R^6gn3*XB=J8sDWa4_-z
zTsLJ~LwpDeCGd7ySg<2nKt@3(b(gV#=vwI4YkhVvJc-<iRhf7f2!VxE|NGmG2ZH-Y
z9$!?K9*Q;Fmk1-W=gm2ac%pRMBDtcmQu#0#;hcEt?rG38ON^(%LQd1;(`;LSO?YHc
zU2B8h*RWmj7l2K8Oi^7r<x=f9wP%0twn#qfkYmU<Z%ey;xpD!r4(n*6%Qt%MYscQ)
z0s@vdxl@xKs`{lvjve}FXAn=kft`l<kVnb|-n;eeNu)pP_+l(zI8UiZ>h?wY{|7uU
z?=H#rm#ivU2Q45&iVZllfayMqhW>%lBX2^dVIaqUBqB^{TikjJ&C4EFu4*zzgdLTd
zfgVWT$_=&xqwx5krp~5O^0irbC-52`A=JA7IusTeI$;^o|35&25D&cmu~n<zKnwf_
zOi<4RGOT{BeELqbfNXlR-BK(7I3NXPbX*EhjYkOe?f@XZ@4Rr}BEV!G7gU!H?4M&|
z_v1+W{{Rc3sikL>wZ|_ELE8TZOt4yJy8QT-pEXAEeUB7o6(!_*ql>D9<xziRGcQb(
zd(beL;4~}5cRkI6#O5*yZ<!Gr$D@2|I|}mDl~GwsoBkf>&-nx<ff4)d^2c+a1^xph
z*z9M0Q<q03UqS}@50D@hFnn_Cht<|1{r>|Xka)L@lE;*!-Rpm&gL|a-$#ZU;Kcmw)
zri4BuYL3H+t~~5R^b~=s1%V05<+FT>gol^^LEU>g)2UD43k>>GMDLFiuT}vLK<Svb
z_Mt}z3=YmC7&~2S%G4AS9pZQsH`Pd^1wv;OSuqq!I-73ZnkXEGFzDc%A(ky~3Mz(K
z!`@6VZ%yL-nVow4+DdDnMul3xGP~{ucIQz$4YL3U+J9r(Hnc!sgrG-|Rf+V?#^r}(
zqXo!Lif=0O%EIJy<eM3Q3fAG)0zeFk<MBFm6A6?ss_}UR^7c2oNpZaIfP)1<xx92$
z`KJJk@@Spv5_nQj+lH&|K%4A~54xXP;(?pKUHkhAW@Qo=6Br(7l8-?dIkWk>f01<p
zR}SVFA1WO39GHC5{W_LxFT}|R2m=kpJ9h70#_8h0YmRpNUje7AIDaaqX?AhS5&@=X
z-#_{kXa)9_$K>?74L&E<>0UhvSl*w<X+D9(23hYPI@~r5=^way@UofZ0#^z}wgP_1
z8@cH<5UBTmd1%FIWSzimM=_oWK=a>ecdkO>1D6e!cmvjIp1CpDyt9boP1{s$<BU;K
zUR#ssKV^OEk7$P@z38v>?wIJGB{gFG`g=!}E~4GM6sdc326~FX*g&tViB`Yy5l2FZ
z3%$p`V2;sK$b$@oFb@|)`k$x`@``d|31b^QxI}x9R0n<EuUCK72UJx`*%M$1fXs~#
z)p!R4u!5Zd<f9l!S^PbC<0noreXs?LC^+?K66o#6@pzkR6o{-&n_v{Si=G%g3e<=^
z)~3Dy9CJ5n{wI~tCIrR_dIYoyUE?PYM2;G`d?1!OcGQizcb+xx>f?BnP1Q;+gB%3I
z^En@%f$S6*Dy*?Xp~Iw|Z3rfwzIOLBCS5{tB?e5$>pGdmYMwq`4P-GMZBsQ4%`-Bp
zt4XaE3<hb2N7>Y*gDf`d>I<lZ;88Zc;*oDoNZyI!mp5e7Bi;s4!#oXMELa>kKaa4f
zFMzA8J`-Ns4IGm<X;WW9)L90|y;9+`qaY3NCT;2qfI{fYG4-0E2M7!hL>EE3JZo?J
zK4=pHpD&yRKrLOXZ%h<=hT!O6CjyTn5jxEJbImA#4zgIx3>|C|5<F$J%{C<tD9)p9
zdN$Wq-0+?nwHl2E-os;V>I(n>%F<=f6!ZY{0LIMm;$RBrBAzJ}+X#3MZ^)+c0PrNX
zWPPcp(K7^YRMIn`qf(E2g`PvtAl)Z`k;DQZKj!&rwe`{-J%`e%;mz38&4i-(OzARn
z(K7^x31K9$fR=)(U-t8zTYp0P5Ev+geW+A%qF5eizKtt31hiWHKUc1|vv!C#Ka5r@
z;Y9xWX-}GrC}noKKTeoujoiBrOagY{F)r1;CA&!fly>>FNbZ)vF8*XoWEV()d@tK0
zzk@>BpK7TemxyK!k#tMeCD!`^S^)4UmL4OC6;L5}C8f+rG8z4p2;&hf)dkEA-nqAa
zWwgP8@j-|dRiZcwXoQmu1#<omEfDyWVHrleUy`ORaBg?!eE=PJ97@$Vp#_W=Sl-&d
z@fJ8`@EDZl5>(9@b}F>?iw($5f$IqSF~n7;Vkg3f$=h;%ZN7INCqdL7ACPZ8)VCno
z-vFG+G<xkL#^U^=(FJceZk8X!Zve(56>p&>Lf9<NNg2m`UIK+m0Mewhg7||7<@cXE
zc^7aWf7)aSfhfD%Pe45z;Xj@#krLSHJ1^}vKkpgm&zlUbVV8=<(H<A<d2=k<0zOFC
z!tJkNrlq^;%QR4Gd5h2JT?_ikr-E?)RLM{paH#O|`<{FEm9MvFPx(=~&F_1zE4A=*
z^F4w%-mpz8p4I1ZUcWI?{!=L*b}*@|asFRG5Bp3z8b#IHTerffF)o!=8nDa3S@DE|
zUTSWfKbO*2jA*mQ6et3anv3?Y1NR-WL<$Qa>4U(1ht$3ID_gAyr+%!m`TmSbtb2%6
zEF(PI*iM6i0|#JLIvXxJQIAAQ2bL>bI@F^#aH(YeVMJZQ>r!%+um1Pt1klmpeHmSG
zT+CN4`QSI#kaYfG#C`_+?$PR<hl>D|4M46`q=O+<e?2!g3zE+-G!*%vV~+IFsm*I|
zA{5uXR3^|cCn?=aLyQk|z|Hm7cQiqMDq}3n8XAf_m+GOXkRG&X(Roy>1|V44R-zS*
zue}jUjC*HSB)IdCWefu)%rdn_{szB-%?-e@wAHpQqCppD{Jh&Mf$ImLSSs?3PRJL3
z+}8_94+;*}J+yICFt|X=7?ApT6E_u5ppU&6s`u`GEfon5iU}m#(EMP`{w8QwgVq(+
zMJ3qPEfrsDkL(^467WUnh$@ec1HsB0t*O|Z?m^YgiiDiT<2ThI$e~x!l*H&iRa1kU
zx_fpG{qSJ^KI2l|ch4mt+-&jy_(Dn?Z=j~~6jouXQ@RNdZr`l?zS+N2E+H6zfQr)Q
zTe~zi%^x3tV`+!1eWb5mu|~(<%87|;>IyfqmNV~&;{(tvofX_EPG}J^Unaqff%xd4
z*br`#Q|WzuhoFbxb0zGDum?E_KShI_ZuhTR&J478-Y`wYiL4tk1A_{7|M4_3QBat$
z@87%(VA|&`&0qNo$qxz>)&~~AJ2$U)yE+uf_pKbXtWKv)u>ppCo_=rFV<-}WRt-)c
z902K0Z`@pro<L@GUR~m>;7J685&2eBUSu9El&i$dFv9jvT+(iw_iPtnngC2oTe{O;
z7dv2Zsgio<GW$010hpF@1^D^jl$Bo|HSbyDc~dmi*rMjQnS-C6x&Jq0p`iFc7Q(&t
znhzH5VYWZw0}w533puTIIAOQw#fBdM2Mxfr^sHgDSB_5px*xJqP>67z0nDk(mos-d
zvQkixa8`hg>e8h@E{2{WC{Va-xI_JA#nNf~k9jB>Xcbwp#K-sog;ueIz2#Wf<;`{G
zEr-Gi@J9;sbaA}?3yVPv2OwN}yvJPNMun%p1MV4sa48p%w<xlRdvQjM6tJ-Y_?8~|
z0Oo!znD05XLQt3>*AY)3(82~%={k*H`>iIeKwT`wb^JM(z;$R?kvkequ8?!tACbU0
z{ikNa6~NmLccmV=0?Hs|@Ch$XQv1hsBB_4IBHfOd4TyMu;-#+szLpue^0kZ@G_$fX
zA9eCeJDzb9vAPLC5yI78y6AI@CvHWy@kIu$2ojRDQk@EjNpo%tyxVdd^;K_$%@Yn5
zES#h{u06YH)qnivf4c&O1JEq(m?DLn_8X{4KmYSOKv0Yiz_66kQ~UN#OMhNlVD_Au
z!^~^3_y813eStE1>9Zi)_mx3q5`bhGS^}Mn{=RSgEF?Z?>p^Tlb+7|PXFog-AX)%|
zrJ}vE1u|gIzxi<v+JZ<gqA6GMVc@_B*ajm%tUs<kIK5B4xD1RAk5_K>!YrXh6&<j{
zP%QWU@Ag`dy8=)wZ97?KcrA44^fmLVDWESL?>`e0Jc1r+1PzHb&TerbO}?g~@bEH+
zhU)g`Bg7|3)C*Noyv_APuYd?sIvaf3m#wIHkOa*)*IWhki+JT=6krJyW5<@wiUpOA
zQcne1z{I(X-%frC%31}P11$ipRP0#i1Jok(w#nj^E%sYOnF{7ipOZJyGM=~WUwNAD
zc(i!-=Ud8n)@SLpjT~;zX_R~3@t1Np%}?pX2OwQ)Pvf)=j5E!kJ1e9j|K*=Jw1v#1
zf8^?fhUi)N<%F_?;7nM9?a=l2(-oup)3)ea!>=xsh0?TTY!4tT`Q&>3{`6@sstXh>
zk&UP@Sd!YX!Je{>TV#l-R@U`uvn-cC)?P>{*R1YQup0sBn937~ozTYe5ny#_)4v%R
zh<-|O7l4qdFF}Q>;a5+e*>E0o9R0t69s+b_87pgqo<+vupkKGwphdj*-SPh1OiwJj
z^YgNI%25l1V(n`y|1t+N#`{mt^gM~3{;U`NEXP6zxOa0Dc+tE*j^}*~-D>iX&FqzI
z_mxCSX|zuLv-bxl2!Ey~Fq(ICo`kQ$y?;G#4g-u&2!<;5lh`j+MOhPDjmt*z=!q43
zokSbN#}_egxq76vHzLD}ceyMY65!V~YL)W_Kr(;+X2=z^L4D}!f&?+ecm7z#{raB*
zF|yGV24d`aaN=R;X10o5v}i|yzY6#41e}ad=Cp?awiO9Q%($~gw1Qso+9GFXgN*Ob
z=yWY*uafDQyFb3U&<~U?d`_o#4Kr~K8~;ZofW~}Er*{E)e<g#lK;5*~<Wb%akj49x
zI^AHj$AEe!>ZPn58Ep(Kd*}B#t<i?atmRW4d7cIL*{eVHa(U!h(rp8;0bFa#@FL^T
zDr{^qpCr_Xk_c9@`qiCi6*j1ttB9_bet7P4u6RQLUA#}J6XI*Di0@e1*F&CsOo(!L
z#koEv@iSf;jfW^P8k&r5`PIMR0r<pE?E%Ca9yBc*^d4WYKHv!ujC=;Dxstvcjn3Y4
z6Vxnx3aGIJaNl`#k35T>gWW?l7BQ{@PuJ@3J9-Xw&%{^)+-G*&8FvaT@?QZ3esO(T
z(%@>ySpOAK#4E7+rf0N&t{r*~85zMq3%+H0_TR(c4b^ym7AQ=IV(2a?PPRV0bq_!+
zfAVMeH8l4n9QpCxmv@0iiiAZTj))>lLy~{q_&;aY8D3S<gz43Sf;0gGQW8iY^`;<A
zMXE{%MbJ<JmljBZ6cH&RQd9&%Q9uy|QBj(JpNIve_aYz`1VO5WrdYq7bMCpjclS+p
zZhl;S!jE_7%+5PAyE{Ak=rs_a?De0yi*FFazy9rSfQtAPpgJ*Nd-^l6*M32xu!}js
zDBekl3{bybK7ukVeif)WiouO__5SRMz9ip{1YWyJS+aC68YSPJL^)ZK`ns#Z(=o`t
z^6N^_0<QaQna*02zD8MF^PXh~;arTNQIOU<J-XG6M_(d27@o%xqZmx7U9a6tG$-t>
z6wSKC7+OpxXOfV%VLossauA*~5$T)eOj_T1{5TMwUny#e53;vogVv^j=)|uV)kXoA
zqx<|mV*rRwyr<fMMZw~de{a2|7W$6-rX-+(^lG2~wLnAU*OP!6mbv%;y&b74zivbf
zVS3#QJ*vC|xX16(sZTiw<d^DhSdGTWZ$=_Efee1Xko?UuM3DUY5HSYr%sMobtJ{ei
ziho6;XnXSZvQoUdbzU$wUjZ1DF=C~;v{Cj<ZC)f!Y?X*&98LJNs>Qp|(k66io@6gA
z%}x024V>57%odMhmON6~oQx!XiD`&YiHHF&AI~qj@1qD~GLq~yrto`mZT5J2>VbnM
z4U>59w;LXdJ_g+S|98TXx6mN@b0_W~M)s4sCh|=*E%|dO&LBayOOEu58T1gE7HeLT
z>$Jdkd*}7d8G=40e@=xy1|>jGA1U`fnwR{!6&eM^#07gR?L&jev>}}Q#~mbO@+mc`
zcyVSYvtV60CE+*~+VRsellTh9PJ?;i*P<F+mwWs&*<CZG_6_88Lmh7tzaABh0yY7z
z94*w(3{^?|veb}qaR14ED}Bq&)FH{<0~9U{VUNh=+gcw+pOHUzVm6ATtbOt4E#5?9
z<j<SnOF$Q{Uc3((m(`c#rYg9Sx}{S2vgk|l=SrOJiy_;Uq^;sVT-}ByJ%5gb?j0FJ
zRGQQ2AQ~cnZiI#i$+F0a9RBBxvgR?4at3O1B6KTA<R)2J>7z71^3lKvv%w_rt5r4T
zNiQNp)3Kd3ePm9W7qJ(t;?UHI-m3M|H#y2ZOXnU30nlEy3P%yI?3tZW$f6$EHT4&|
zTps$EUy|~Gb~sTZUEF4Nk0;$4YkgO-?LQIM02A$XtdNPcsW1D<NH_n;Ta&JWNNBHR
z&2<!zYu%jrRy`0)`1PzImPVf<b}xgA1^F@4GYkEM#>t;sp>afp0>&xuSM%veY58+4
zG!Aesnf;&fqmRj-b8!YSK88HZ`FhtsZ|<Nd1rR(BBQ`fQ|MKLD!^43A^9x@?XI<P2
zK?dA-)(78$x!@PT8lwOM?vuTvAo`U2?Z*m>f~jxIEhE21pOU{#6dDEWacnEtZ8G|l
z{3R;RAi*VxWMal|2T^R{7sZCmiXW=$&^<f82GQ4E77JaMxO8U*_^ok6zC=Uh&!Nx|
zApxF(%9e@EP%6YPi`6tGqp+Nf&lcA!f#y7au7v6UB@^8!OpYXLN`;;DS7=e2Qsk72
zBMBC@IVA|4mQUF8kXF;SqTd}+fEfG=*-#x({4nSG{_hKn2L6^`BWn%<_ui}bX)*>(
z2ESC+7)LInWlHq!x!E;AN@TB>g(=aNM4#y80&c48P5iqfnwk806S6G8!jfnAKZ!J!
zzjcq;l2y!ClBCL$Fa3t*KYuHqz$hZ@>Umv@2RlBBz9yeOg}gj)z>5k#w$rRLOR~Q;
z51k|BsiZV;f-yMddhiB$lKstjIFJ~C#;HO5aa6^Te|aQv+A|<gkyen4e+gE!QH%97
zIu6qkl{a3jb1#??W&1arygu*=#$qwO`q=}(zLfo-e2gMKMpY99l*H%Ks-to8m#YN6
zCfFxOdYGZL`uTu|Q4+^oz6X04)Q*xq=kCr4sc3TY=V9n`q`Q>l@6e<1-DnhPT)BKq
zu2w8Y3E2^(Z|Q&A@yE@Y)+Bq~Y_6jO8axp{T|1ETQ?b+VAL;NR^ab1`djV}O^Rv6n
zq!n%8<)K~Y#`ZKTxRR3cw;ZBRiVRc->bCvd`C~K5=IAF+$CLQgvmvpQMl$X<lc!1c
z{m=n;8W{<Ao<@*H^E6vGUw+ZN1C<nR<!qp))hstHyrK>=<9yc43jBz=wEoq;;#BOE
zwty`8teT}!8qh(hHcFijnwAH1ozK!)8bxdxn8SSdN>P+t*vn@jCux|TR6(hIOy5}r
zpRFm3mVS!i+FzT8qtKy%sL&QQ=V|7G;>PDLv;h9!{^oqHL(%-0pLENN1!F;m!S9zE
z!bPXD8PCu|4X=KWJ}7_g#T`i80x%42POaY;nD5&sg<DDM-UMzE;TMzR^qA0Fd6I{D
zY;)!?Z(%8`^A+FB^Dy$VhLLV$K0S5}h&ADs)n@ny<@C)8Y*aeB(?5p-+nXgSUjbYV
zx3bph;3^gYbSXf@Ph+hdz4Y2HPiqQ`!mX~QWrpa2>PKIakQDn1Qd^jNFy0Wp#AvcK
z`WlgX=;7>QpQ7CXh4{@@T?)}!!|O|nlk`%BXJi2PlN@GxBL~uZjmb=^*yU!gfDmWz
zz#8g)+@102!k=oMv`^<@yUpv?N&KFxuFeAZjzw!D#Eolm6&Z7w{>B|aZ&fQ5RW$SL
zeri)2+Nw4w++y3nFtlKb7@VHdyMNzo*X^i^BbT!@?#eol)X1;mxg24}n!b|j-BJdy
zGTgFT_e1ctkdc?ie+af2!mYYhh6pZb<b>SO^PBh3AYm??ltBRH51lF42PrE||KbgT
z)-v5jZ<&O?Bg_?(GDPq@<mw{!`>A)(Ae09xuGrp%HFR|mxH##QWyK}wcUed7YT>j=
zrGeBzWFpR5mAPL+RT{!O1{P)VOWF;LsYYKBp$%f)k3nBTHBGR1=I<?c-asShqe%LN
z`6+Y)W^OM1QMyznn)@(!dR>j7Ca2^{UO#bgBk&}044Wqrg2RoN12uhZf%M_l+$z$G
z*sJ<M%2kT4%GiYliL0M8GN*H=k_8HfF%!8xNcvDlOl5Gk9&XXC_a)*+h&k8qO+N~r
z9!%o*YgHqmQw;(PD!$0B^T1!F=F6F=B`1=A<DPjxjj|xxLQq(qYE4cM0o^l%cB@6-
zCc~YSK05XwNVmeRymcqVz3Z!{Tk?xe-qC$1`l5Wfl)$OT2k46qz4qE)<WcCSsxDt%
zg|<gUJOMrB2K;n21u0H4J`BnPhJg=Vb{;yho>}dpY>)6fi_>FN%Tg}Y7`V(-mCs&_
zi}F%(U}EaQ?(2%Ze^fR1MttEG;<`3Q!@x^z$F}|TE*d3Ysfs%aa4?rQe0UD2EMK{b
zGYTvQI~(7$92zEHE{28?MjZSaNy>_C6P+9~G-L6_=FiO}hyyY382HXL6<3<U#TT2e
zjD;4CBFqPt!SYKsTq$+L%vgM}`ExG`3GJ1mJvmB+(b3yz+a+|%$`@<(Ezm8yeM>$F
zUMrX5^y*dN06CY?B6(k|)w$$8PRku_#xD=KzfNh(+;$tEFpK<^y-}-k5%VE7+%(5B
z|Ng!Ina<G{ZaHp%@#%xI`$nV>=@abRC)X$Sw%q>(u&r<_asvZ-y`-J5k+X5+><`Xa
z7!guN6ra5u7tV%gQlr?G{FJBHOnuWlG4O?3kn4Vm+fiD$W7JXlrIt4~M6;7G=MwB)
z9b6E}PkQjBKFf$M^ivgQbuTEsIIqa6xrH2OWy#CO%*@gkmoE=P53-6)9X&;EcK-SS
zX42=2vpN{`En<w|s!M*xtPisqk&V$$RhQMfz#-gl3}$6Stpd-2KxywIo7*r(I3~~X
zT+dzq5{2j|cXO5V5T0kDS=Z=TblKRqfvdOI=ps5gRU9io6-UtpeMZwn&`+5RdzEf(
zS`rlrAUB%!#Pnmpf!WJ+^BBfBWBu^Ogj>Okhg+oUx)$2-G-jL@k@uh4`4ZAtzT66p
zB61dyy68l_D<NkP(pbKn3JoJB#?aV1b?*4k-17E?Tb(O47C4l4R!I66t+{$VcniU2
zZ$67`KoFkNaO3QwOJb#-NNxFYE;I<*W_$gw1;3idMZS1z-U7cQb4XwBZ7Z?o?P|@9
z%H&|4csH&&T_vKmk>X%vBA$zb36|E4+ta0#f73mBVcmaA3j2Yh54S|uoqC#fbH9Gx
zKZE}Oa}jQRt{ehw+4t`qeG-tK-=tRE3K7SuIP`9>y2fWVlJ)WX)P|0tQ{#An6~Cj8
z$d^x{gJ{tONB9&iU45=^#1b@0zFdkoigA{@wN{UZkYVL3OQBI>jJBzD{woMxO7rns
z)@rli_(tPHdVah40!Zt^Ezfn$mrR#@2}o3?{j&ZWG)}&}i9->m2~yyDq$i1~^2p!x
ztX61|u2Sv5@FZnk)_aYfI=`z7AbGe2x>8F~;DOd>r}SC{R1|K3t~v;v0vl8Q>BIuy
zMu9Kf0$p_+k!5Q%ELO4hPLM#@>vK``aOd0UY^V)$UzzJ3Ksw8pPYDd;WGdP?FaKWq
z9<ZRZx3taubHwY2=+@fR>%X6E9-I33ZEaoJE3HA@V$(p)fssqxKA^xx^XS~Cv^`_(
zeJbNoXJA@*8ACNaKVyAe!A<%pX?VCbyV_8JBnd5!_ukf}BC?J!osKqOXbwQ>%hn>B
z-v>J{GUVjqbb^(;;<Og*ybLHc^gm#9;nwXc;?tr<R)x4;lhXa)e_wmO`K+wZUc0L;
z!(`j$0v%sYEA>>VscTBjH6Bmcw6WMAU~<Z(&u~r7t#TA5uIC)H>aHA%R46mcaEEf7
z1Q=<3&wuIwTT`xwut#z|E71tlhkP(-?ak&TO&`AluJjLb96CD|>p*jX_Q<>U{|(ko
z;a2pL3A&@X7MM$Wwmtq#G+3D1GIB8bpxpf4z}Npdg9Zz84P_37ZYvBge5)Vq(uG^s
zs}E*+qDK=ys%aiwE47h4Ph=(yI}X0S84yW1x(d_0bERyQ@265|q%hB~rLLUFAibX4
zqno&W<|MGfRra;Q{3bCUWNw*RrXz|v^`{@?L*Z8Y%CB<A(*51`AC~n4s~;u*Wqnde
z59UxSqi|9F%D#;^h#*csC6IHfeY3K2BIBIuL|ydzD;%lrJ&3D<GL}>l)bwBj@9O!E
z_u`ET%Wx_L+g<pO9=fQTXC1r;VKRJ&i|I==FiRF0xWYRcR^?>mDlR6StVBnUmkq(D
z{A5z&tP->!(iTNh1vanX9t_|%3x)g-?DpEgD1vheaUH>huZgA=V~EsbWe-l@KiKnS
zDlo$lIKXbe5htYv^7Lo^d<`Kpj+Y(e;Kd39IeSyz^}sTc8Tkew!!1Q$kJC-O>{8VO
zV~ry*#YG3dwx((IUV*161*D&fE7R6oeT9nav?A7^Yi@u3FoI@s*;RwOz?V+@-|7#=
zqPdgC%#petouF$%HyhS5+hd8U4<@SvLN|zr6S@{@j)uM<>D!q|B}{$?(CMftL~x>a
ziR?x-JlCP@o=Um7^bUn44qj^4_H!ULr}kB`5t7>2hG@~fVIKs|q<26eVz<eJ{%U25
z-oQpunEVbvi{=6$swRDWbm*%Dgd7&Xsck{X#uXtqUHiX|qz-yST(Q0sE6dw#kFHyP
zuiM_<?H{vFyIwx%*X%jwD*!%wEo+9KCegd_LFF205zhKYv+b!PzU^t&#QRd1boU1E
zqKt8Zv%h(R-C(zs(=^uk0QZiEGp*vf0tL#z350Yj6>|!&1$*Bql0<pBm5^&BB4N@q
zhQYly)Bzb&3X}cL#gUNfBE<W#r5lX#7^LuCV%m65nX#Bs5qz}??OXMx=0IFdp(-id
zz2~Cq;L_g8(?Ej9=>;o6%>?g>j`v?duuQTGjyso2bZJLKAA1qOGMOHLHB5Qnf4!dv
z*%GJT)KP*ft#BW@yg$D`>N^C?jOGH-$;wUrmU!yAs@DmpL_ftbajHs5V#>l?S;<sO
z6d+%>aQMSZDAE$)R7h(KcYU2xRNrY!pjqfJ-QC@KZO9X7=9pA=1P1T#wLM<w8w4xq
zmZyhsVM8B&BNC?#e`lZ<Q6!0#?3qbo<6X}6F)dbkz*5P{oPyBcyy4gO3jGni-^({t
zWM<@cHQ~NcXS|hpsmPQ4%w#v&-h$PQRSq_K!0(OQPJe-LnRE`|hE5-ua@~~2u6RCJ
z)rB=|hsX<`>uWXQ>|DwQLNkJ7dqF3FHuT(h(4>B5$WG=Ia*}n>K13j%y6=qZ?&!LI
zUax{|#7c2jcm@A<BbaU|+Iha2s3+SiHw|psjnpNt*lXn}Bsr7kisW%2*hKc}<37K~
zvqFXJk~lW9)1_PU+Wp3>!y5vHa7r|_$)w_VT_N91s&ywqms02H_!NcEeyon3)%m^m
z5jrz`tLP#q>gWT9E_@21Gik4)i$~mb^of0M+5|`x$0Wak?xem3{ufP0uQQX<<Tz$b
zSMZ%ZP+k1a%}bvKmd+`))Xc_ji2l#0O;Ggk`R}-1UG%U2w=D|z#yDn-S2P2X_1d%7
z_CeDcz6WqGfvCch7dY~DR8>#!iWiU;Z}kEq3lx{{=}xScxX(RUXEO*#_IgU`8cE-D
zzNJb{k#0eWuigME=M+(T*5X1Vr+ebBtA!A_)QQ!{xZucvEpC=|5zvTJG8rnlyD^|E
z=1Sa0?U3wYcmY>-adXJf`oB*vehh(!;R0N6<a;}Gi<yJKnd^39Q2-pc-g;@jPDS8h
zcmNk%ETsZ!kt>Llub-bt;N;ttv@71q|G)}D98|kkbH($V#`*OBE>Cz4*-IGwcO}R4
zf4tCtrM<*lp}!1CR{A>|F=9eB^55!z4(wqhbE+N5&YdSd-TVAb7ct$=`#<&TE-;~-
zO2;5Py(3{XKO^t5BD%v<2%PBv+~-N1R?uYVnqn?pJU!9e088c+HU=ekxKGmeO3w;u
z-A2;aUe<dbNHY?cF2IqVOh({~%@|$$=ZZ90gwUBjz(E)P2^`<(=<l?d*TRcN3Y9o*
zMuW<6&_T<A0!zzvLXtCmfRx<0O-WjBk@Z@dM<i8ps}pd8opQ*j>m+%5^ew;xBrrVy
z?U4pwnAP@bC;_PdTeoSR;ED&3*241u=DyvF8AH;6zBzS@G?xLnsrgA7D0PnNHh-PD
z4V%m<P*l;WRlC4<_hB`ro~ga#SM&i)HxT#$#~dk|YUoe)y<>>EN0!VeN*t7#o)Z}(
zPOe2KuV6TmyT{dTC_2g9BTG({Gn!la;sR4jq{&*Y@qJ}!0QxD$&8RqZAwzbHi7hLa
z4VaB&v<G_^5ct*j>Zywnq@CUYNOK#rO0yq^q0hE++J*G%dhDH+RsqRqr*Z($3ny;!
zLG<nU_dTnLzT`C(`bu}43w?vP6)5#+zr0XK{kp=5HU64FRz|^JKvq+qFYLW`qqpOr
zn327*FT;TphUuPW>S|5NnsXb%wG&mr1txXdv9E^QDD+A{RbH7L<;f&hUc(5^oZK`Y
zNz3GC0M)Yu$$P(l_In6dngT~!bJjku-VB@)Bs0qHq;{P{XnopJyN>_F+{8{+8nf92
zuIt^{mU<X6q5gQ_SQ#BMRe6Cqd~(a!!U&kjUT5Nrw~~p&r@Lj$^=3}tuylsGa5z}9
zD}t{GV)|w2C2K0h0rO>)$psZr&s6X9Q9pd>39FDox!P@=wR)(!^Zl)BIwEPqAh9T<
z&~5D7UdKxyX~UqfKs8BG`InyC5N;SGjzQNpi{JIY2Bd{BNE~C%*_yU-Un6Oyg<0n;
z2F=-xcU=7jNz076#0YWMNT0KQN7K6@X_;X+fNDC(pSs2mM7Uw_S4bOb3q;>%C++$g
zWYAIxJo<`ES4+DR{{5^65Lh{nvrbzBWMuuy%>4pP8>53{&@qV0B7NFk?eX5dNZK$6
z?6f}Bac|rE&sc;T289J~=(JG|nwjZajI<C2g+&6cOZ#rE?<yc^!ys@^G-nl$)N}F>
zl2~!Oj8>1qIqPZ8*|<{26OpvicC8jBI`Eph-FwpylMrqg6z=IPZZt-;pTBYq!VQDM
z0yk7%qVUI+U!DmlEXCzfSZG2M_|s>vd<}92M$MWxZBb4mJ!5~Z$lGO0gFPxnmqrOJ
z?yQPcWG&MyZW)z56s&w1HER;Q9$B$)@1{;#C;f>W1>-4n6<s7~ny#zVntKZ{4tv#F
zaCza}gfwu=SO2*XnnOON=}K*kDR9@X7QKQ5=7(hhHgO*sG4Lyd%V#z2Lfxc7>(U5U
z(!}O1L|<@F$oNyQ-ffVA`K*p|E)<8%9MQV!v~_O*T1#9et&QID+m4JqWR_MZGiuTt
z6NaSweDU575T^ZTJBVpSqe|(&_&|(fv__PeW+FBB!up~Jl^K!g>op%t@%WiqFLgku
z%y=BAbk^hXt@qXMjI_!mFQFQlPT9Ee$q19lTf#JE>eri=e2TuF$yo=}oT;JnFJD5a
zOvXB>q0y3N>gwqcpvp1X{!X~-Xa%aVA3$tf^~L)yc<x0mgOyNeW2>{(YSf->Px$PB
zSwEV>s67jCKuBv$S8DxVE}M!?VYD6$fI8t(H`aIh-PhkVtQ1DUSrFAQ*4fXD`w>aX
zCM#U6-%@b@A%w~%t3WjkYf;4?N}=y(lNIa$6uz~|i%3#7S>Zap^voN6LXxuS3Rdaw
zuWL6MNy;WGT%#Ahuy7KRR0hF3gLa(0LMNtf`>>Q#2}lX3!c-ZlY)o~|M(`D`x}{zN
z3!M~3{aAnlaLGIHvt9Fn78w2ff~W?wiq)ETJD4wf`##SN!ewdi4e9?ON!fe_i_&r>
z#yo&9*=z+%$4Xgy9z<Wy=Bo2_i|zsE{yWi+P}yvS%h4($_BTY|&t|JwH0qLWIXUhy
zl9bI>xWH}c-+vCFve~LEZ{;CT_D4-eQOyCp<)H9Y?#$%E*T5l>Xz|&8Ph?cxdpmDw
z(4jzSe^x>5QcwK;+J5ucK7~=~<+96J<EHn@js&~zgIeF0X12RYVU&6)*pE4N9%;1p
zc)Uq{bEmE8-A`RKk0MeS-SWIaC`m9@|HHe+?gF#PDE9JToef8AotyD|<}<*W8IM(a
zsKP~Pm}9U0F%e11Wix(Os`iO`T@Wgl&3L)^;`iN8qsij3S)ihedT9?#djJ_Rm(Wp8
zFXSOPkz(INcNX&&ZtIJtj7w{=z73f&3c{C;ocr9%YZX$<IFSpf1E)rA-&@TLCVk`^
z0aVMV+VV_Gbeu3ZB-)Js{6}+vpTeltQegd*iD>ecth&Del2>}RJd+!8IW$}PbfuKN
z{uNKPa<essQKRL^OR%B!_Oxp9&tLQ_l9d^RJ@=@~Iy`apY$Pj_xddxgOs{Wnr67`(
zNn8h1tVVTN%ltR?Jc4C1*MSwQ1|9Z+29>XR3rBUjn9LR7AkrT#miapF^y?0GN8&PB
z>s0A=j|;h%PsIH*_2&NOu9UJ(nKyAoM-SRr6>Sss1K;;<{I?^Z8KdILHCrl%>MlZL
zh{R;Ng}xuY0RhW|KX013z@X8@XY~ek1{!9xe^Vtk<gGj3_l{X(nZm8D>YX`UxbeW1
zB3h~#mhsnuy^on)qf)pvR_*|Sa%JZVu-Fn3H&tm-s2kyiag)D8-@@d#Ig~!YXUB{E
z4A{eH^5)EeC~b?36HV3(!5`{1=~slyBs<|kR`y!BF$&=_*)F0Jt|Ho1=-pI=%VfKY
z8%$tj@}2NTgLjBL^e;-Bmh+bj-2=(@TT9#1?a~6-`qk3gX8-*Wke6Ga<;qJ1gj!5}
zwbJ`fBU~og1Gwhq&MR#{{1P}3MyEB$&Kz80-;lgh$?HFR2sjb@<H+thJOFGg?+a!P
zX^dc*@j3wO*VUVG`CuQU25Ap@`ce<p)bCesuYL~A8#87TFx-@E@IuR*K@!g`({gbQ
z?T#*a^i?En7%YYxlkY5;Ru$of!D6Q$i#u(S#f!7&RHP$Ox{IZ-SSmL+7Vl^oeM9|w
z+iZV#PrKHwqdV+tFS-%xwU*~!?Q<Ro&8^fT6~kT1=h92e2UEwb)pBu-srz(!x7|ou
zX437Vg5BTA)t3B+q?IcgD>Fbf(U;Hu^%#;i3>w27#b4sL{Dh<pgU6tV#vk(ns8LE$
zn&w$`0E=jTy0_mXBrP)-)0}~Q#T4I*psp;%7Y2z1s_Due?EGUKnzJxSY!uN@=Dn|4
zR4byi7K)`3av^c`Axg`5cvs-+)oIm%#N1LX(l6W(eRTBUn-Ojp!5Hp{F1hgZ41^m7
zhn1a1S$un`*w2Ma3k}mxS&A`wj(I^|kC&C^%zF(<%IB~1uzE;s0A&s9n}3R!#(1VT
zD5;2-V&b&)Y2o6zA0v5Xq_8m<7j^8|SmFZ0mB!1$HTEc9-aqgIgv;kJ$!qR?ZtnFd
zoHss)og$PFd5ObsR2Xvste&N~91c5+I&I>%_8S@l6rr3y+ZBweTRyv?-yV?gaVxci
zg*h9Rrlp;}?T;1+n9pISY{mn2a~+~a>Y_nT`4{Cn3W@CnT5Yy(y+3+y%LL!PPRmzy
zF0ilEgAYbb)%({kTEF2Dq~~x5?f5ip{$ASJwm-t<2jnQ>gT;bK!+p2xuj>&mm(b#Z
zEL^q}SpMp}2$xG}2bZivlXvU2wHYAPGrEVlj?KX}mMweh?5>Zb<<i+j4V9MYoN?Rd
zK0s#)n<t&sEfh@+pEXO}1D0>x5-pLRQkja8{KhA|x)hL((Kt+M*Lf;LpSFq>Cszgv
z=9X%aym0w8?ER6cz#JGa*9HX!w?IbiIn*7Ya!Kq+YZzILn69Ic4!9H+sBj&0q}GcE
zkhEb?7_2NFuGIe=k~Rzi3)E0bko%oId~r>15S1!JT;74m(E{O8%C51Z!l}<5L*^^_
zX2ot05u*uBJia=$%|MTCa(%3@jlpBHx$}yWf9x<PE|pumMWg_WtR=55`PZDdRBrK>
ziwZpNqa}VHgK)V4*^yS$Eg8fMKOK4l;c^$o0@qj$5$>)}TbDrE4THp>FeK&fb*quI
zVUQRuh1P93HyPoEL1MTR%AWdhthr=KwZHHh*giCuuUm7DJZ_fHr!snic`ny2`WJ@~
zz#7IU?ih^pz^5=Rhy<|W8i>KCD-Ipxxdw&7a;3>&Fv_d@e9)^eke6G~CD?|m(M#^R
zl!S1lz&2NAE-;7{4}UrX>6cs96_D3l5ba!eWdUFt;~iFM73SMU#Sh-K4rzhUVO(VK
z#lHIQde$J<0I7_2Uy8J-7T~`n-@Ji<`83X@exvr*v<?WEACBD$ju2vyL0p$J?Fv#c
zKOQ^f8wT#U#SsIMz~K;?$}Nl~a`*bnTX-b_3X^3R%ALtMbR$R{EgPws@3z(8G$fT<
z;^nY{9>i3f4(axz{rh?Y9dN6=g0O~in=knKM!+_1MVA9CR)d<jHI|)dXLe&t<rZ{#
z&85ZJrns*Se0#Y*f2>9LTsAu|S~sCxDS;2_kP;ehFApM9JU2G`hxGBz#X+ySySo+m
z9ZAonwt@~%-M{#tZWr@8=2XUermjyC`0j&4?y?b%G0fj{43$aJPw{*9W?q48K#b8g
zU9_(WR1W|xJ=>t}a`Y8k+G`^iUqP{aWaGCldbCnJfJ_+k^Z+7ukq-d&Gj~V*o4pNm
zMLXR3Ft^u{qnapp{VO+}&ep#WPYVbVTZOiU^T4K4;aSB-FZTMUN!W!a77ip|NYE;*
zbcVTP2|?JWOwg(C&A&j-MVD3TH*e61GdA60qShW;-l=@oQLW?;h&pjbMr{-I{1+Ab
zA_Z6}A5_3x6ZGLK+pD0-vNBzQA`M*H(eyV2YYpKNR;oZAO2n_ZV~n|=PG!6+>iCU*
zeS>s1%X6N1eo_{~X0lnq4y~Xe78l)EZMnHOrnG0zi^b_fMg<xon#<}POJbITFu*Mo
zQ-v1Uxyxj!?xX*8`p0uV3gsBBxg2#<d)UYr3cxz>-HoQT28kHATFe1P<(^Lu9y$`?
zTIuZid<PfFTY2o=o6V}<RBn}+A6?BpvFYYlKwiUb#pTC)(c90IYmOwf^4Zk@p&C1-
zyU)~Lha|O<Sz?k>wG3?IoR8`tNtwwwNgBv)WsFGq=-#7bu*754V67Z>-OiRydpc}M
z^i7x%QrAHQzQ14f8s64|5{9Mg&5OWJvZ#Iif{QUFflj$KU(VN?8;;e+j!i?T*3c_w
z3LN4ue`8s!w+d0T%B}YjvI3*ZDERakiV#{j=hk{Tpunn<D^J^rV6CAyr~zk3MK{*2
zJNq_5ij@YCOP=7t!X5p`jz3Thp|Z&e?_Rz=yyQHD%BCyqlQj5`4|*b0HeKO<{?Vkw
z-+>cgJYnfX7`M<?p%!s<OUdJZl@OLiKZUDOsd;hLxO7})&Ho-UAK6UhR&<es^jfpK
zT*<2v`J;@>;4)Aux5Uej_Q(5gDt{JC8sja>fO_G@#t+-y(;uNSqbx}Zyv&H_ADo3y
z+02D|&A(SI`5HoH6Bq6@*Pi-74TLIf%;FAU$xY#ZZy#M!7%lx2KkMTXS9e;~p6}fj
z_(E<`m*3gD_KFH*R@icUfpQ4e8e{{$5cI(z+MYglWibsxKZUmP<MW~|t(_G&KpRrE
zetiCJASSnv%l&$D^LO*_Yuh1MZitPdXlN?+@u4Rw1B*(wu5N=$6{Iru&Z?F9d^1Aj
zGL?3eO<8O8jopn<xlDETsYCWUX}-z~8qgXkmdjLUGuagO;)t=U5iFOgxojnmJn+ib
zNC(nf^Y#F=ku1^|&1P#H&D@7jxj~ldUQE=S?bl63sC>dY?#hwX&9#ZI8FS-qqCA_H
zp9){4sJZa9;|_5N!nuRIyz7?41kth9xDfH`$<MNYz}x~Z!2`75dhz8UWe_TtxejVz
z$sxVreOb@{icq=46{sLPE^)Qf+h8GUFWd^a0|!-*K@SOM_s6USD|+S1THa<$xUdFl
z)899}fPlH|b%8-b|Kd+K*FwNt{<^?mhrYtVX5|qum%#yGb7A{$_uqCRi;&E)>KN4N
ztpDfs>ySloNi4)Qu2~R`BR`#ArHG&~{S+EY*j#8_-N=;d4xIM{kWi@{v3@sPBNV&)
zwTBRH7`%0w*Xdm7vbS0Um?v(X7I_&^OVst@MWDJjm0P71KsA|Lcy!^@NDJJcE2M?D
z9~%ENECp#H4B~>qoQG<DnG7~l8P7Yq3lB%yI2<H>6TSoeN>Wq9Ag;)jbZcmqxbbhK
zhcH+RN@$ip8!;ZunxvPN6UG9BSnIEJXr_@Y`;=;`+*wNpLI!tRwHaiVGzh%d`Z*(W
zI(I5rpfE#DL#H*K-!R_WH483i1S+4o`Yi1)Iq<UKv;`tR+PaGxBlG&P!kmW2L<wMS
zrc6b8sBuW2w3SN?vl6&`+B&T)wLG!e7u(DmxdN3>S_jq8!b5dt)ka$22U~oFAYs{_
zNTdZmWvRl)uW2Fe#5Oo*e9Ahg#;WPNl^5F~Bjb~nRyZ-@fI<<NSUdmN@K-$GV662i
zbjX9XwQEPvTS{ZbfG1Rny!>Pl4_DzCw=j#6BWihKE}l9}{pleD90q}%UMhx)JJh)S
z9bjnO(kw?}v4Apgi^Mm*gmA;5abvKMo;z+(5>iAsG=>dTE}#6TF9HsS$wuiAEvHMw
z99o1l5e}6_=rJ_hx8*%h!{JaFEmC_nTKyN2HykpHWvU_X)`dMA0@oAAC9|lY5KT_i
zI7CeT<Mv^Ty~w68S%#rJm@JrPCeQyadZG>Zd~Q`16?zCU&9rgAPbC^4TrPtJE?n=G
zX|?buP%F18i{u5%-i;C6P6IY@tFjzavAbrj$!=a-VgLf>@|VPQ!n<k+M6>VCKQRUA
zm&;!P43CB`ZoJFf0Pw}ebLs2g0!0*<J>G1~Cvds+6}X_`Wy{f@{)x1}C9i`Dwkx(=
zowXI=hCyCq=|}XPa&+S<kUq;OkvDyf^m*=u8D`yqFP2+PMRp4>kW@<Fh`a)~-BtkC
zq{GfFv5y12CP@F4ce*d+g^S5YHZ>~?yaKn~7Rd`1lj#E=HtV>BcEcbqyh=azj<V&D
z7Q*1Ju{a~2@Osq?E4|>Lq+^V?58cJDIbYvbzUf6{6I*D2&syi$K~JDBx4&jSG$mm9
zw8aVZkPE5pjjAMp%cpH%<?mjl*RtrglW%S1`En)pN^8i2yiMGfHr<+91(&Anqq{%Z
z4V28Sr4q&~q&5qqmqZ<E=83CV1Gk7O2x~0XeqD0Kycg+<<rY!-0}T%Kh}Nvby)%t!
z4*@HkW8S_&z?#K%GwMvb5$RS=niZ77gD&eGzu#~i!EzZaWThCX!(KQ1@;syhZt$h+
zJ_cy>+57)RvT`|0pg;v@ns+OUV7VM7SfGM89$ET7WVK8R59&K4(tXob)h&hInSK6z
z&I4B1D`zZk_R{O*g1zP=rI#O_cizKQXvQt5as(!DW8Pki9{2?UW@gX?tky}(lcSk+
z*90GnQzd2wVFIS|cSGQE-<D_(EP`8EH8_1FY^7PY^J86%EnQ!15|hFKSkYe&7;)73
zXI=z^OOjTRr+Xl5)92J^(epkK-nq{mI-sZ>-Y>hK-s2VXs`JJqvWE*ucleo0z0u4u
zxlG8&o%PwCI2UP`$z_5Kb!Wumy=~5)@o1s&Sh~nOc`WwE1dE+s&RP^+_)GmKfDX9z
zR*ta1!me-f=1c_3WU&JaX6&^VMa*gtUo5x4YOsF@<l2_IE(`-R=3~ZSf;IW@>E@j0
zkP5g27N95w532BAF9gfwF2MrLPU_R?38VsPV0pU)0UK(xl;YhoyvA50E0?+i3XJQ+
zH<!*ruw32}EKtGZ4j+yHX|#{YTj!l~p;|#SDs0yS@tnHHZtxVW5Ll`rPXfom6ncBr
z$=SwRX1-W%&6OjuUm*9(>f1L*6__S(McnP@fR?$B9XgM_16urD{^gShmKla!Sku%J
z7ZpEbbbA%5U{W{$>%<@Ga_()!%3Ak<1(y$@FhmxjgrQ_Bo!wgZ$oqCRXgz7BxDpgn
z>`sclDY<*_wu*|(WOQ~;mVZb;=-2kYIqew`lDTgm29QnHHf(LZOc0Wjr7`E}ECRU5
zyM5d5wFwBBNo@}quzSIT_=!jtOm+v5Lk*7t^V!FrnC?CIt?*h3Y~{7yjk?6atJy#Y
z+;S{WQlNup8~E!ZWM)*($!y*6{`;V%of@CL3TT)6@L>Siw6ve!uk;&|m`UpZF0!;c
zpO{$%AzS(EmV9~0K+Eqe-exwk^Tnnx`5ZtFwKVb*4XfT?07=XY(H<@cs3{8?mjH1j
zg~?~C299VFK`}~P(AML~{wm*<LEw@hc{&RPoPxHNzOHKd``(JeBhyduoheLK2f*E^
zt;tU0K9+RDk05AEbSt?9s3!7TedEV^6<~_UjJhr3HN}I!73>Erg3(heGn494+-t?o
zs#X*7^_V7`z@93jSSx^R$QpmS*GEWJJClQm0UOi(<?lbGJwS1qeyT$4Om>m!R;GKg
z-LIQhv!naUc&jcI+D>H`dJx@cm-?02MBmL7_fjUI*{!``tIhV^UE8hhyk+~2_M)D*
z<&IVzmlqnQcQ~(jv{?q4Jv*O;*i@Nd%wDmmd&Yy@n9*7*h$v={a!n`G(yXn(qq9-n
z1LIvp7hO}cyXQmv{Va0oUX#B{p@x;eo+{+jO<S57MVMq4(k9~UwOcfG%Riv08{a{1
zWc_jRb!HE8Uz}2_lADusH6S+V+*%b)vnO*t*=BTQ5V-biTj2VK2oEtRr*Bq(9<YIL
zrI!vxdHIj34i>M)2*eIe=xReZTyHw{I7ShdD>Ok0Ya^XF%|bNzFKRc=H2p;!qngWw
zADlikppe^je{rSs+gaw~CN9<<q6PGj%p6iVP{_zPzrW7AVyEhu!{_>Ure|pisC;7b
zD<+xa7;UyPGYO7DhmvJ#=sy=e>NDegT&xV5xtp?sUN0hN)X=_>#-fx6Ju&g7pn_$#
zt-MBPCA0&piJZCS;}t+;#ZOp7z9S-#U4hmg4|k3kXKv)iDKcBYg+q1}0<dSivtmtk
z;fLs_7zU%RD=?E}bA!`!diU>}?M<n^dEsp2^p9*~Jlo=nW3=E>#>vh}&&tW}>d)y<
z0j7ROcipN}sKJI+?*m(p<3#iN?T3%lruK=4GR<p_LUK+7CpfZo^Vz%j;{(C@T3j55
z=N>BQSrhieeboz@tEjj*7S991qWC)E!xK4Xoj_ciJp~u@M7Y8Py+l?9!WvD++)5c8
z{flaRR-%hQc&K#rvUVaEw%opZZSfT!D$gPk%Ma9R8hp-IVYv)iR+bwjBby66w-oq1
zM!}b>f=FSqO@cP78||<yAGZY#gwc&FfbMuDaD+$X8~Ev$Re=Lx)P4oP72l)_UTE^(
z=4MtN$EW}c#Wq)~^9R2;0!hu~ab!Sh5yg!ow~KvOJ_WKGMmH``>MZ}@j>9uD{39cs
zLlI+yannm(L(+2z9_e^&^GKHF^FZqUy8+7?HDR9g6dp~DU*5W*qnY)`F*<MwT-O_G
z{^-q?Js&ogKXLI^hD-lW{?l_EGA}<eYgKJ8Pf`djbH+RgF8r}b?7S^ndBVGF*}io^
zTt-<~PyyuWOm{!x>4#qd86%@EECd*(9u3dW2TS-kMrl|GGzccG3e0{C2`!bJN8aI@
z18D=rlNbLw*Vbqw;frHbhy{g?)IHI?liIE_ZsQ9~PM~fAlH8V=z1IVW&!`F`M^9O9
zAP;pEpiBGuoWmPD16E=mqe9F>r^S`A%s%l*!|l-`oYGH)<pgS1XiDh%4(a2jS&sh^
zD<S6-1ZAAU2#w>F7etgndgpMwiI#9t?Ea@!_mv(A6>3Yj&!IN8W7Om<wDH?NfyNo-
zVx;jvaun)`$Qf5SKe@FhuA*^9xtIcri2ds03yJ_Q&nOpDfB~(e`rP|A5|~5lpdJvZ
zOVw^)6)9NGT<-qD1%|#et4Fr8RYEeW3g+=TkbEKq|MkFBP--8?cz)4Su#guhxb49Y
zk0AwflJKA&q=IF>{6N#&uM#ljTdF3k<QDnzT1uGrv@9Gq@8)TVYPw7|ytnd88$kA%
z$fj^)U^P!GOx4p7pQkmh_a4|nlheoGvtQ$K(cXKm1EGmgJQkQbH@(uuC0!gmuy7P`
z`$_gAE)RP6(4k_-3#V>_O3Zr(Y<4kPa}hesv8vzLq9(||8RcUV(oC{Q6(hF)odI%K
zMg>_YG9q8~IdvAJ8I)#`m$L|D7a}zT{JYwtO+&D!!Kfn(6`QvInm7Z9$OksnTHWP)
z3aN+3bNLC9>M|3JI=g)%np7**l~pEAMVqfocm^q+$Mt~JrsE@~4{H1S)1Ko~BDY-f
zFqn>%G5%1QN}dN%{2rskOirkgF0RU+w-qb_8ST4NP%p<L^Kc!Xbk_&}8Z(=kGFJ(8
z*Y;X7*In0-+P0(3p*@|Jw~u@(HsP6P46nW6_q$dRwvNvW<nByH(#=<8p{)7Y@!t&G
zP+JT^KUMR*kRBYu+aS!zyfZz!uP-s+9JRp)9i8M9$B_3`2eZ3`tjxgy;B0qK5Hx>2
zb0KPg(IVRy$9Uh-K&M0BK$w%Wo%Z^vSLw__pAD-wXj5<7?%}PY?@LP98@Y9I{0sXo
zUYebl<c4SopOxJ=o1m$+ovIwGLkNXWSU=&Pe-baoXD22FhLAqz#xvF0fKwAj`I^*_
zVoG`*@O15R9|P|o^^>P}5Q}x;g;4?Oz@JKV0Rfv)!)AyL%%*1h;-!GuFpAg=bj56>
z(yJCb&>W;*j6PxtK5gfSO^1-wivoD*9dj!naJz@lz{Rr10MB}I{CB`y?DcFJ8n}BZ
zsG1AO{(iv<eGq&&-at79(&2xqmU#qOjSN<~<sX{#lz<qzc`^33_}c_i>8G%jQQxMa
zQx4+op%|kaI&x1cNI;UUK0%)WVE3hdTd@hL-<~FDU*H7v5YZ`BsQOLRSudn3se+W8
z;SBULj^Uq|p9rRuQTC>Z42fF&(6?o3iRq-DGNp{iBn7%t_U3LBtEaRPqDcg5HvDOa
zKi>enWfa4CV+G<MTHqvn_WK5q05V#YY2aqD-D~@%K8EDBrwbZ1s<*qYP{BC}oaGRl
z2?!_!Rj+^7Dlr9^dkV`Pgn-k|Q;4~fGaGyAzU4^gGWg};ZB%%3(|-6P-%LenkyPSB
zgSx&W%e(eN;4Ci?BDYrNNIu}N&2_5)A0V;w_5n_zykE;9e;st{1>=biUmT-0PP0I#
zzTav6Y24#XEmnULaJ!76Ic*H!cGEH^cLqL;Q8uSxD?Usnkq_UsW(G|sS-RrG?7hw?
ziM&$k>hJp_w-)c%+JEg@Yp)7jg8z2?iN~pcp46{`Tge{+E}jw*Z`YP;+PdQ`_xV~m
zK(UiIj-v#U{zV<Y>HtCp0FR37dF48%HjVN;71&Dt5a21TzN{?31J(Ib?9!E*twTz;
zaz7NkdGjf=P4Fh$)}5rGXaH4oEBiyh{pd-MS(Ot?AZW?YTpUX%wEipzF@H|4;<pnt
z{bcl4j?(jHzVp_Sx)>mw5(UW7w)uR`v!;#2GivKp3kUD6oE`adIa3?)_WHUIZOlcA
zzUQsJ*ATR<R^TXlu2i&C$3wnBndGX-rAYILw|7Ykkvetmm$gjOTl&+>?U2~v@qN_X
zR1>;!+M@lm`$eLwVu#1{Ye!7v-}f&~BB6DKghTbo?V7*2)Pt5Qxmm|H`^@v2c>8OX
zR6ZORQNKRjw59t)T1b0+@82WM7#wdewv)KN#OR3hUfJL>RaEril}KnS$wR?IgeHbR
zGJV@RZ~szZxZFf%F&u2}j;LMYDGyjN4SS`XCa_3$G(8X6;;ZWIPpHUJ=3Hn<$laao
z{vKlb%qs>nmieoj=VI~p8aoHrIdUanUEcO}j{S&Wt&4jH*4dLsuoFJs^eQogeySR*
zw02;{dNtbFGMCT<<T~dvKYTu$_OPmH&~{qiAG7!A`g8&AVEfoT2?yI3Sk-%Yx%i!J
zjXlx6AH*Cs3)SN7b#)|t;I)Ss<3XLl+a~-Ep;|+@ifT;YZ6|WN1Mb<2>OxRWLoV|6
zcqayuF{?Ak;&ea<ae6~;BK5gPkH6`ehC*r?r}8AVV{x>H*DF1%hQ_^!AzSBq$co5H
zMvw>h6p;b@zWm|04S?46$~r~Maj1vZ&ILWcLBLWS9GO8!;u@E4uYi=nBDSXt>TW6)
zx|*K14sA3OL9@s$q0u7)?Y}rz%3Kx2+e_+HJv(m#h%l&$-C<wS9Z1#Is2z$e8bxZr
zS3a6C8R;V&VvDZFs6S%+T4jqPnXQ?5sLY~8q9Zd&>3Y#RS(nd%<j7uA*G72JmeF-v
zzk8s4fsT8hS`l)OnD`y>XZ&(cWQE_-?pXXbtKXL2^jjbD`I_Iim(?k%=$$!SbiScu
zw&)1BwmrG@x?;5Sj1WJ?h1g5%6t%Q$vm@%h&da;D+#20+`Gj8s(M78M$vsD(AR7-|
zD8}1s?bI>0N7sES%RAta>EnIR+~uUxG@2^E)V|%F(7ScO1r~kzTorF#Rp@Y7??>$)
zR~5c>q_=~k0$T&RGO<QjY_M-j8zgNwWEYRYh)1zBvj175%6)+B_L930X~jDrrh~fL
zXj(M{9S+%r%&32Bi#0zy2-1IhZ#GqGad>8Q!z9N08{C@a$*nM68U~B;XbZdWsu7Dp
zc51J-3l&>WdLJJD$erf?SiHU3PJ>k+^&thgu601crHe_|+Un3=a;NZHyhpgN)AA3B
z?$vMTRj*Rye_$f*ecE)<8-u_;u}RI@NZoQK8Q#NOy5#hUtp$R*{mn~NW&!IoW7XnV
zdZc^JOINm)=OM~Y*xPB(zCwnwOV)d#B(jrm0y}xqz_MKPBro?!yu&;#h))cQ?u0HH
zg~XWNWKLxKVsjHa-d>KUYn}R#I4wFuOWle21=|;F=dGg^=1b3=C-Z4xo=Z9KP=C+j
zz+~*Dc|dqQ^(nM&m~+;lnT)+QPd6FF&q;S~`PtKm63pzSd8*(dM=_7Z8b0vG$4Dh%
zg?53APQ_lF(x4r}4vYANEzD7Owm+Y{*cM?+BVjldfh{aNfGu6^OG|1sroZ&542%7(
zc20~n>sT)QUE&;?$Z)t%{lm<OY?iaPFhUN8_tfjlJjL5ky6_I9>TuTV4suY{Ze~eT
zU-@aPu3na=P+e*|PpZ?Ed-I+_<@*ag0OYlo<SArvDg%I)V`D39H%o5f?Ui{7HZ2hX
z{Q`{LoNwa){?jbZh_~0}5x$e_2xRwWgisCbt;*^@na}U5)TU^JFmU=Q?!?{_4viuh
z6pfo~{ay5~er6eCypP5I;KzswrY@cSXz*CYob~0dM<cMjfHwlQc5ya<<OtFi+|ps-
z8JdvL+O~LmX`bWOy)|2d*7wG=U*5s#lXY->yO7l_9Sv=(RL~Drq4w80)d>j%K6f2T
zeoe~^_V3xBg_One5T3FKUFa)LZ2Fobe7oT1UdH>jzIc0;p86Sq5k!U~#-Jw1<o=aU
zA-B=w;=aRPN~yRF=|!z>1J!+xJY41=m<4;ao+`fMIfRBpd5bvM5QT4w=rq;OzHxdY
zV7R?#FV{hwDlcu6H5os|qET2IfZkktpW^rtG)nb{%ld&u+56Ht-=cQk5akBYq89FN
z`XCyC=R(X8LQRS0qf*t>;$Z(gndL(KP7V$ZK$d)X@KvyXZf{OUni0$*T;iB+J^$-p
zZ!(DT_ToJUSLE9PT$8(>wmBK+MPel;*bDXu+4VUwhPVSN_4?Z5sS3(U9X!xbS&9Dh
zC-;BIn=^&}(vex|Pcc}d%-Pv-XMn8s5<OJ`rhUDzcLwMj9B;49ldy5LL84ni!j3@?
z0t>U(;VHOL;A&}~Lj|rOT-JiXowB$n?dl})toz*BTPdv4Pca4iYoQ_Xx@G&?%zZoK
zwj03ig}o;ofHv-8-0@zy4q(gAUVW#6qdU9<KN$HN0+vB6j}?rkXy;CzrjF+IGq;2M
zH$~Ee1q@Z)XIl5?z}|(uC0(dCT<j2C6R*D;JYbGzdkU|mx5%5<PSqW0MpH=ngquzQ
zP1_6aq|j8MV6Ke5`>oktVAJ+$I}KQPIGx^S?yj-WyoDZbFSe7=hRay-QJ<?w+%Tve
zc*oti+g<wJ%3TmND^9z{ETBa-xw)J>F|bQ(&nOhfk;)3t9yD-ttB0nYLAY}5X{CuD
zIl7-7KG_?oA`D&&T*$ur?>Te;8FCoR_D3OKRI$fLBM`7;9zz$pFCs>ty6cy|UcMq3
zt(>mq$!MBAkxHYRH8pR(xuogj670ovDnD|$wK_6$-#4a{OR(3|A?y$*M}hEA=~r&>
zk{4;u3HGja3VLWtM5sk3mFnOrT15?q+X5Bvq~n4N(4{uP-morIUXT*>d$9jtGj1o?
zd(~;kkSiJAjeo-22T!nftApUiERG($@T|%51YSj5z$*!TBQnN3y0aC64u|CqwCFFO
zMZ$tr-uMw&b~rqDpbeE1*$eJS2*z23?6OFWLw1mv*MDN}esj|;fmc_j>KddS#GQ}(
zb*~0|iM@%PVk#o{5J|ewji&LgleaViZ08l&1!OlD6%TGm8wJ>IZ&?>2F=G4mZ+7__
zA%_#lg}i|6y`HLm6JWc&S)C@cVR|%$v$xE82C$u1TPM{V?184u;>zj|WB^Lqd)I}^
zj@W)OE$K@H9S+-t!u8-wO6jn0<qLrA_UB4<sSTAA+o$e+?oV&SKw-PwVak*3ba_y0
z>S}sku<QHZ0n>T4c5)iMxE}D@q+a(Bz1!7oPu?#6qIQo;l(ZMz(QfXRt<m-Ow%@X&
z-rm>)otAeL#hzX{PN5aXh2_kw_P>}JRf4^*ouYd>o-!5&b=vf+5A4O>)J_8yu1fb+
z(_T5h5kZH;eUe$2qYgcHXSKP&6nPbR?!-EMkexce0J@ykDJe<c(Dk0s`|Sz#2Tqk~
zz4zTcu?O03NlYkM)~uf&@y?w0kY>Wj>Cp)ok@V<eRqsO3VesF921?)m%Zm*WbQsYd
zor4kir`%F;gSU86$S<=^2Khmxuk~kIZ4e`r^@3#`(p`k$G(WC&A6MXNJp?ZElRUtw
zFLI#B^mf{+)(!l}Zuk5F0+7A@j%cZai@9_hqqOj>#}~~tD+m+pkD)piesA=iKyhWe
zuY`@aimpHYSMzMT=$8``&?m6yuY3Ys>;)R?_srU(Nd2sJyaFGGz@J|*_L%uXPJ+E5
zo~C}v;Dqen1jr-PlkI=q4ICJ+Ku?k0J?PM_r`MgY{SD%t{qa;yd>7r6zVv-3>wpZG
zSExtQyDr$Ud~yW?igaw}?NlkQKw3?nu0TA~Bu*2xG~kgd#U=n{^9uAdam|$c*r?7c
z5IWlrD9SKZefp^n9|u!uuha9U(nSxD$i%Pu+Rk4QzI447FXrOAffUg6;N;6y5x$&H
z7Cv?55a_1%4;OlD3&Ll+0ayN9iTZV=LtB6svv<x5)qidWl0TJvHv>4DL{=ssO_O3D
zb~Mx4%|t0MuYS*Y^h}tJ;FLIej;1!Ux~rM=;l~@1eppF?gD;Q;zH`1Uw4_j%yup^5
z&oA`WyNWlEvupPT!uu+qlp{S@Zopad6gYubx2MSL9BfCUcYKbntu!52rM-HOti~N7
zD=U2zEotDX|C1N5er}c)B=8FO9DJwNiE1L8$_26B6Q}Z;nkx1Fu7X*cnPBg>7yJmp
zD)9-<ervSbSXG^0nu-!FFU~=VVz~$RL!2=j^CTyseZ$vx_N_o^yq3z_UvCY51NjH}
z5r6?(Z+vP2vL@EXzw-&=Kkhq-Vy<c0^^X`b_@~mqNhGnHgfjy92QntAtpcAg@cp}&
zgIp?!wP?uB%nIBm#2)(M<}aHdGh%rNNAM=(9fbJK>Op)!W~QnkauX%qy*d-DALJC+
z-Gl?KS<ib-AMOvVlUMo|5S_}woQjvA*fI^T)jqzpSq+w8FaM)7JTj{8y<*28w$t(s
zEvX=EuP6k&I$AWW(5vwuzM*FWV4%Drz`$3yPC76F#%ksFm{)%TEaMdbdLslJo+wj6
zwLx=xZdrzgU^xnH2&Wb-G}e$Wx^(vM%V-E0Z1PA|0z(KFMDv}Qi7O=^AHMSgG!@cN
z?L!FuiXnuWT+gkU?3L=HZb2r?@)d!P2*w66>nhVoN%e1hpa=Q_maFjaos;$4jOn^h
zPL~JXj#u>;7$M-aGY85VOj#uS(NCTJ^!727oI+|SPiNtXEhfP6)SB`OR_neDh|a6{
zd(5e`b)59$^&L-bn&=;o-nFZk2xs(DHXIq%e)MXsCT*8S)wX*pEfq{|x#nh!1co1b
z`LX`_=?K%lobWIOgB&@fmz=ui1Lsk5`WIDBEA`trb+Y0GIC06baC^~yL-&l0tH0dF
z3mYo3o$;Qug6ZIF;^!OUf)=LY+G(!h8r$T=zY#Cyj0PLQjEX%48tv}y9ouy%Skp5K
z_CkOaq2&xtX;*O`?d?-0uj<2^0>~LG9;ZIsM=^im;Yq8!0y~Aq(h;#}?AMH~N^JX6
zWD=APDWclT_N1tj<3!U@S6Zop0p;#KKz^Bgr;2OcC6Ktq6E03GcirW-w+tG5OT6CK
zyh-Wt_j<=CDn6gg6m>NZaWZTCF|f5^@1N&{Ch`yjDy|Sv5@b9x)NAEm>p;9^l<;{L
z7eIGhu^2&QiP{HLoIUzkGz6dEfg#))W+#)=4Cb{`LsMx19D3tB!Cuf8oLKi|%C0So
zUs@KCSV4K-iTHl8!=Gs&p4*?B4NigE+gs#3P(y1E?;GPSuvNQ}G_nN&lsKQ?{>VTO
z1{igH&eV#+Es=UCb4h&PKH#aD-cho`cj-g&<hzp?1TJQ1GdR20;l|`r30zTuy`ImV
zL3)|1ZL5OquN`s2i{$*^)9tH}S%hBpNU+!QslejtQVL(g_I>txmr|nhl^(--9-bKu
zRL!XD^Hl9cT)8{ly3$)?fzjEU=eb5FrjPRACNzn{=tM4~OeGn0{D?<?0dY6g8qtIJ
zIPSi`=+QN#e)_31$)vkmFNka9N+oAxgScydgjN+9#of^@KOF|*ZmLX2^CX}vvv)$R
zS@!uK&VL2suKguiX@H?|mnN@!gV`A%(%2uM4QfJ*G(_%BakVOV79q*4?9k^y?(`vj
z#LXTNY{be)Q^0E%R<)p63pI#Dds$yl0rYrqyCNNR*2P`vHp_EH($W$cHGLlI$SsSW
zxPhoBoyMOFM_n+zQKG$`PZe2uBT4Fg{@Om%(<j;+<OSyqdHS?PH(x=hOe%|)ow^H6
z^w8$5eb(12Nxei2RlQasJ4)Ewu666^4juM%DX`zT8rP>_iA0lbiHtfvnmD(czi7DO
zHaOPY+TQ!pmYF+UiHssXi5=w_vi|g!G>>(gKkZH#4UMB}#u~2`&Ft&szKUJ2y?;vT
zmrHfqez)?dF*Kk~8X0Nx@<@RP51a>)L+ZMT=Fi@>_gnATJ%#2n3AWJO$RSTxt+NqK
zC!?0nRk?^GHE24iQJ1^bAyxhDkSor6kD3wM>-aoXi#M#X5gs``<xw*&O=MK@NvWgg
zE@QU)288$ueV-<J)QLt7#3a&Bu@go~pE?A+kk&hMNKU$cNOs^Ju!!n`ow}eKmnz$_
zsnBCo5Ea@vJkkCjt)jAhog(YEimn@V!|v#<?OINLx=yX~QU0ugT3+1Yj}>LjeW*l6
z`JeNB-kn5uGYzuYU*?IuW)hUhr~wQafi}|=^OF9!;NWuOfahcs0lN6YM~IjA^m%`H
z#vmUcFQe055Y=76M;b*}i_`D?!CP>vCdKp%!bqKhMO9+*3EBO6Cwq%b#V5#xYaTu!
zGfVWCA0l3aAd}Sh`Y2hM)Mvokz&|i506lehsg<V>Y3!GtYIqw+E*RB+&USsv;<H+}
zn$jG!mtHjEhE@nzsw5W&?6Qb})xOoz<Q9y)1+;}qWEA^3+8C5MBG=cxb`6QB2<$GN
zmj^@!pvfH@cGqR;e^bmO=0rxZpCh$%0Os{D5bF}v{>Vg9ZhK)4G7;Wpo%bA^OK}~$
zf60ZPB5YoAAH;@gIk_YH1*CCnCg9|A9(D{BC+T7j{Ppfzkj9xz4@4z8v=hsd(B2}%
z`0w5*a>8>Y3ghJ-ajuNdi|WM&)LjEoaz?SAV<u8)Lmh8*ss}m;C))e%g=jid4`g}C
zKQvtftb<YHr%K#i=(&d>^J8;Ml|kB&O3uZHgvd+>K)P|<(Xq>EBsG)i0X;h&+rS>&
zvBjN8YHQvfA~lg*mpbF@gMNe@9?R+MTu0uPw)aVd93IE1D}|2SZPuJ;kfy_9xRdG_
z*!yq$ZW)p~Jc?7|sY*@k{ygC?X8}tQOkuY)4+gtww@$?+woH7y2?_(s9s$Rqoh(G$
zWD1Baqxq!r1(NA6Qn-@c*xT*7K{wKU!>(oVVP?O}TZ)`}9C&I*4WG($O1DFlO-ebL
zJ#)RcZ=y;a9?i{b0js)Q_YyFVL^+EbWs99ZL*m<>o;(~OhevS~wW1q!g=!9u;&gOu
z2)*OoH-7~SHb$AAI)k+3L)%pF-JD-HkNgJdB|Nf=Aq?RknepFoA|w4&8wro<;xJle
zBr&}}!{$B@SYf)H$-J2E)?K=~(DqRxPA#4d{2rq|Pt~@wTNNTR5oYq?nRNgc8I^e|
zw&R~vbrAF?e^wmsEo2luGm7#YXzj&F9sQT{F}EXhCetN4OeUv1S3Mi4oXPjVTZlLb
zJ~Fo)=&UJTWvrhwGN*H=k_8Iq=}SCpDEHi~ijjad_6Km?gdu<}GAP4P<`3OJ9e7qo
z(OqCRoj0M(r0<!HC$2}DX7W5BF;1VZUF`om(gu_10c<_VA*#2WQGA5AS)ou}x>h^Y
z&1#m;HBM9p;xfwXR28Gl=}h6<`vWE03+qD60z2xq#m^@osjaK?P;4!8A_uak>wpQs
z<QQdisy@tM9^JHYF(h$#<VL}K+>8%E|H(vOc+^J0{D<+QsscZ4Z<H6JWf;sezi*8e
z8I10Ds+v)x?e}ihYA+xv5x^H7x3x%1mhsimrp}JPw(HNRiBm-mU3#ejhA4h|Y^QUc
z^(hpW%NRSwQQF?R&-xZ%A{jMts^~D_Zi<L{4A?cZ8ZJ`ooe$3C?fN;sDlrI|%W(%8
z2CVhzjpl=WYetVdR~>|$`#h4ZOds9&Td;3!f2=mZ95F(>tiBokk-6yRn?a?gA$%_9
z6?~|nzrMP=9Kx5eChv4X;CCFJk-Plwd^+q-gf9)9jjza0ChlGef4bv!yQ%6UA~fB$
z7t#e5lHx7&>+9d!X8XH)+O-xZNc+SK7Um7&mK7%aV^*3bCUYY_-3JhzUFiedvLM|X
zym9=~G;aXK8%R%<n>Qe)23I*^4Ciu#S(%m9_|Oi(FngU{z)I;IXq;}=h&=u>LY9Y&
zdC#wdtjw(3K3{s_%j%woRNOnGN1n@FLPn|P&Zp-lddZcF%T4VG*Gx25ReR<e^HN75
zv%D_Sc~F}AlsW03Y98cd4pcii8L5Kn1W07Gx%g<-EzZF|O`xg@F8Li?=MIf7@#hEL
zI*26Z(w>mf#^Tn&AN-4OB~$F?rf1xw;SYB1NdYM=vxLr_K9L$nG!U1|U0t{?ibDOQ
zW7R59o<jekkXt&BT*%!qn(myq#RKh^7d5J4`hMKFEYO9$l1?EtO6PB0dGHXRw7rl{
z#f7^rV_u3&LlScXJz0hD6(Jg?+1s6b*I?4HX2<plx<C+E8r||>%i?k7t@?AFZ)pfp
zOlIkvYZh=Paoqb6X}}3F`r=9F=2@C_nN_|&aU;@iIDAG6kL5S^KaOz2VKZ8G>>IQc
zsy7@q!$rr#O<x384HB7EbMCz9OAcob?$m1^UgywQrLwYBmJ5}udvV$*sTsI-;rHI@
zoOHoS_L@0`Y+wm9VDrh{CWn)l6?3iv@Rr`FDTC5YN+j7U<`jY9`eI-8YU$?EC5c%v
z7dd?B&|HtpCnVQ%P8$ebRWfr)9)N~f%JjC)#}*Z^^i!d&p*dL3BkB8Um$N^5)}>-u
z=}TCY1%{S!lV_}P{;y2)Y&pqZB&R@nX(f<2rg_ChNMb92J$Mo0we9G$XNUNa8OU&%
zON3V-=^&hJOo1l$)*Cu|l_#wX#L8xLp6r$7qjJV(ef$t&ue~776IR$1xY6`=uU_Dg
zGs#{Hr^0r0s?`(~kUea8cJe;clPB40;S^+4S6$-B{Ptkh>;-TkxKQM`-)Z`gSpl77
zuX6LC9mk{Tq3NXZ@0)e}N%n#^50w6|VZLzt)b&VEHhodWZ>`r}xZAT?#V6S7)*L|v
z4@{rX*LV2`b5kVAUbLn_(sGunIK^@nXyV0H8HJJ1JPr$?L)`*#_gKx<J3UB+yE1dk
zle+@ah`eV97xe?zXfIat)F6ZuY7qK$*Yuh-ym(id^9B)}A}JGRuUAvysn|Y_N>BAB
zJFlKw{uoFb>>cVnbnJLu*<EW3NE_@WYbq>c@y7bIj{?VIuUJ!%k>gqPODXWWWs<#I
zEd&>eyu0%1@_^6w#&jOEbUfr51COjuEAj{ZMT<?<EUc;Y_Le(Zb)?%*RL)pXUV4<l
z=<S+MfXi!1@w{LxDB{TLMSEc&nnhQ7@Slf)kGH=M8={YhF=IlxNbD~8b>|#!_e5d0
z+>*(Y-O?91XGogZH5V3o61aMMrJ5%;{olcqv$*K{Ln-7tXlGNIMSG2!H;Y>e>>V(m
z)Z9{!t|?V)^kV%gTb;6X)|%H2lI*2w3jEblUv9nDd}*mJrJTA~eTe6#KX#FrPT!<{
zfmC@eX_hj?6wy1yyoXn?)}79#l8$Umwu8vqcNA=2tNEM8Rf!uLum8le5>;kau1z^1
zm4vw0W6dqn-KQr+f^cAOLg$%@1V?fFx0z$F0%u}xLFd6E(A35s|7RA;B-uO9IiPgi
zfNli2wIO1CP9@#$-5}{y3Jm*dMwGA-`l&kSh4R1<Ub6*vBxfJoxj+1P{g9|ko?yVj
z8T-8DrQ!*s@i0AsU-JTcGM>K#BAdOQjZ_sGL;JGgt#-7Zoc?0lBBU?+DH^huvbo4H
z#xruwYg|k4uI;FRGS|t4nl2#8sD1qGwXZBIDa50nifARfi)cvL?!v@-%-yRbd%c>A
zN4gZxkLyzUum7?P`fe7zBV%YQQ~T~a*T4D($dc^s<QzGLB1Kzppicj^w|@X!w%4aA
zu!c^D%vv-V$;yh}bkHGW1u96tTy!FmmBrrxY{*OzN#px1_{<}dLQ*+VHj>g-ipZKn
z*iXyTCQrZS14>Xf*zz)cR|&L%soB9NMJ^RZu+~E=Wx{CxQiHuO_CatMkz_AHld#af
z${*fa0?^Ce3Qol}4D9%<q@O_so+MqXRky;zOy%~vE#q5+E3JWpYihUJlCcAj7Ff$^
z*K*OzTSfW~Leg6EZ&kOz#8y4+dl=z{L0{t`bz;QTwWkXq)8+HGp6<ek!T$}b*u{fY
z7%X*bVK7n6Z2fxV^=;n(XJaoh3o5ssxWJ;Z?7?!AZ}vo0f|tFzOaTRE`}Io)sv}rl
zl%?;lhy3ldiHBw&SYD`gVS#y-zVXRL2$oOYdZ;n-jtMF02$s)XHz(4jY*g2&9g!VK
z^Rl^w7}E|Osor%Ml9kWg805Z=Eh};-g5?uez?$A`SY$2mB4d)hhAe2cF`*d}v36ba
z>%RucvD5&IwV|79<YZQ?DSip)z+N?`3TsA&xU^26B3ORd6*@3gdvey2s|c3Q+y=T!
zBqdZT(mDzlt-V$(sDuWl(YA`+atg`H=WPRIv|HD|auC7tc`IN|&EE9b$u>v@eBM(1
zgXRogTJlmKB&)Pqn==rgrg2rQx4kQZ<?~j+nkpFGa@~3a%a6A`b>kxDE?PXgrU$FU
zTPZAyxqeNx89V>D0OreH))h3_o~Frub?(r+o~TN^wZD0)fP#42rQegUB3M3adm@t^
zva;)QNCo_O3s$1V$4st|WaYC~fSM*d`PTzg5iFmz0@gIy%FjJ>0i>Sxo@m~Lxm{3<
zzERcxeBva+WfRxI6#{Ekn>y{&7^DVC28%<8qNT1O?#43@{D#D3GgrXsxJ2C>_nqqr
zg06(MP}e;mGK21W)3+=H^4iO{<g}5zhI(I`H#-t+)7#6pB(BK9-Q5Ij=6-8*{TeWH
z_U>mYv?=knmj7))uxt)TiCkRpO_O#>%#fcEEStp+tfAlWAAK2%VA(8=5*vx8`JVr-
z(<2C$9eW*EL)us89iIjKqrKsooHCJwX_`Is&f@+^)-V_>K#d72*Xdj;l2ua8>KH^!
zS7asnE+{{DwnqmUd6gw8i@x$GPi~EWQ));pQwu(O>6TQjli4T&JIQ$Ff5Q<hJ8O=j
zDpbP|&Ww(J4Z*VGZ&bt`V9v%LoHx(hrSaLTwxkm7XcRJOq=SbFAG^W4HQ=*9TPjh-
zagQJwRYhr)K!hLn_us*XE@Y15vp-%Mg0Gqyp<eaRxW)A7K6|&bP*j5#uUuEKIl>Ji
z5DRUXCh>Eh`}UfA^Tmci<Hp9+9Y6Zx1!QMokXV3*=zwUvzsEiM0gWXoY%~tE(K3&<
zpW86}V<0fEhReBO5FrFM_|~ZRtz*EX@oKmNu(HXb^g8W|O^rslVenYglbAvHho>Go
z1&GY6;0nsCQ(|ED$eKvnFk-NfHq;!5YQ@T*$w9bb1YyE8X6=h^TPvGK%szV?GD+c{
z5s^Y(5#x=W%ykFKoJ5uu29L!8AcPvEi%W5BJ^?i5)pJEsrYE)?qqHd0CawBXuii@W
zkoM<C9Yqjm$mbJ<D^!@X)l8(7hcTEG)@|(JnKj=B-_I-La=srdSHG_|!fB#Tz{>aY
z%C}rlbES4y^JljMrSht_98hC-<=LV+G3euYxiig^FerWUZ<tc28Up39)&Vs?{z$(%
zcLE2)tJI>8hjx0`&DXv)t9yLBA}tp+#88P)!@p?R0ZGc^sUs<{s4FdRO-HD_XzQYy
zT5U79%O~jjdEwSU4Y4UAYOQaIuK=-DniQ9)hI@UZW5qo{2fSJ=cea4J*8INB34|(>
zgS^%at`1Diwn)395+H%S2rJ+LjdM3Lt-s1PdjWU=`%|DnP{Uf!&Fxqc$;l<FIL0zP
zz`$Dyq#;mVe2v3rW0wZ~d=-5>Z;4BwA*M?DOuM1*G$bdNs?NTF?*9Haq1`$J%4I4%
zYJ2>~^P>?cm#D@;8!`2!HchvA>58(rl~d1TDk?7PeyZTDV78bQQ*kH(+WYRr0YC@L
zQYnH2rrJJY&jSdQmk>LkCiy$geQy-{c<BT4b}8E79hqu@hWk$=Ipt(oAx)l+TRZM3
z0_E})9<X()mJN;-e9W?`II;Zz63T`je3p(h%4I4zT>InWD*vF5=kgRDt&NPke-{Gf
z^3*t3Bc3j<UNaJ;zH*i<Jf*7!;yDx}^-tI~1YET6G3%vhrVNi7Rk!UE;QN(ZQhA%H
zv!$hb)TN7WYl}d+9CbFdbkOZz4qAdhxg0eP>WHOxkI8-$m?^VLDo)fj8UearM&Y$c
zPC5H|YgC+jnZ*C;Y`Z5BC^weE!?d=AzuAmFp370OI@Kp>&2Jr(kepnOItyMMwD!!2
zFM)(FiN{fDvp^0?MJ19xQ030xj*SvbrAApKHEJ5qem?STAgr<jo!9g`Jt0JVQiUZu
zjs4%IAzlflvOZ;2MFmksNcC$g|J6I*oB(zyly!Pu@(NSM8wx)x{p)jJ2=;bcPUh>v
z8q|8}#N35QR$feXK|vkFnXfv%hGgY2)`c~gu=S6Z%OF{$ecAO27C)_Ww%(3ld7KT%
zY9>Gxdc6KN*kH3a*OJo(*XtksyYqhtmq%SkT%!t=$op@BMf*X7m0GZnmypq$W(~6z
zOabyTOQSq_P5l<wyf0V~qVU(=O)IEhxV~&Z?v?+5<tFn2Er|;%Fr!cZTpXAfvogvB
z1uT2uzr^`SRz7*bg7EQ67r+s<FPTqWxFr1Ni4BvG3i#xOi^8;vg<2q3X|^_>U@QwM
zIQ%yJ=uo6tUeKip1H0GdzikZaxP0~|SV4<53MGlSY1e%+77$m8$|A0L%lTTVoST6T
zn6*)^4h$dOVpAhfcjsf)Mg>64WNvfoA)rdoXK!_-s8*b1=s7~!6Z7`~>#{#68H9x^
zx#w%&S_)~F&s(sT`=sebP%G+7;qw-*=9=tS2r65B%-SfLFk?MO1RHYbbx<_yv%eFm
zXcolspS%ACN}PQuk_<L?02fNrQzpEO?0_G0jinMXcWI%m*8%2AR2Fm11KEgIE=&dD
zG7F<<&ftpawF(<PM6kSF;sC5kvfr-zxCDabM_jnX88+_ch6t9oxOJrkE@AZ8ITa8r
zle?nB8O-WFnYsN8a0&KyRxTeLSR=Xr>f385?XW)rselSa=w5N{g+6G@m{}1e@)$ZZ
z(?N^3UW)Pq``eF-tiU1MJpSBQAp5lUv68UHd=YiyPgQarVI}&?rLL0HvZyNr*4B<c
z@ACIE*Sg8fk|;;F+QBh-+YL3I++=DY+1|`b)dH}D#_t`vf^eDCB};G$Fm+=%wPI6I
zqy;8-U0lP&GCw$QH<C6C>cYd`8$WvIfXUrtW-S!W8CWv(`s!J*Fi&QdLb;$|#)^MY
zWDSy)nJ+uC8j4-j>^rc6PG*)txv~Q8UTzw<&vdoPu`)j98O(*OMs82keST}VM&{wH
zvTn3dR{#gz$kWLC{(a}V1LZOcp-2y4)zIxk&(DDtm}O8dC@_S>nb-e@VENQF79-?o
zmc-o+Do~S|MNqD^hJ8)RxuGeNl}}u!SXTEkCI9G=jbND>vol>FL)cxlUUg&z%$2Ty
z1=;<ui=TByvhsNgv-{u1&dflt%zW9ARZN<$+1L6$e+a?ynX4Rv5LZhSAm)DdeOYJg
zOAETvWOHGz+Xq%WOrDU?etDti^#^1l&V2qOkd|5gL^cZ-4R=mmaU+6drpp4>STqpB
zmLHgV5||gW1d5~uCoDfleRms@l^<~7iecS5zR5^dK5@Z;NRtiE&PTHHX$#j2pTvLr
z9)ji5R=}E6XnTJB+h%i<<ajo5b#C3$_>M0@7Q<^&6-i`u+MOGjXT9#rW+PlSXI<Qo
ziX|fLpKt%L(p=;!Tc5d**6sM(gbHm%xHU87$J^}M3FKu~LV0=+Go}Ucf~~eL0Cr&S
zOy%Xu_;OX+9S!FoSn0eh$qd1o($=4_&1cs6Co{{T94&|x+^M%!);X@rC2w<j-nGxD
z(;C&t$X)j21S^B77u9~@aQAlFv#&$!o`j<9=jwj<Vxv*uWFR?#O=S1JnK6TJ#8lpk
zEQ8Ht2iMcJ)J2Ua4{bI(ekI#GP$|0T5?iEK#H`ZV>(E>OD^e602RjVYMJq9xnkmoz
z`t%0ieiOo=wAgf4K#9-Cze@>jE-5QtX%IF(XJ!gM>+KjXPQ7|P&;YYm%CTeT*g+AN
z%=gt_`t?At>==x1upOw<V?TlogUn9$tV#Qe|NWx~mK}xZ2Ak<AR~|013&F}Mv$`H9
zdDNu+{^QxmQ6`2#UuSDrgZ*(!KjbKxwNs8IILV_1J7w9`O-Kp+IP7M58tmDfhi*l%
zVKDa&z}!_I)XoOXO$>v%;;xw@D={~#{`dEowT{Zco`tz?cgwU0=P@@0n~1h|U9GY}
z56n6$XV%c=xb@$zz6-&I!CwJuIL4Y?%APSFCroDcopPmZL^XQQ?bcfS#w-wjnBAv5
zbn$;p$JuK(Z%4Rc@R)828n~N3UOpJ%hCyU_JFZjrAHl<A$@a$%WhT`)f(mVn4T1L_
zpWe>1WF;%HKX#}hi%k)CFJ4pgyh;_OnJ<|nCxt=j#u0<lM@9-w>&biizPCFeRfoZA
zx_cIqyc4xcZY-JV$*crrnei~GP5mV`byS-1;}ozL%dEa~teGx~X{Zk_>Glv%1he`o
zh-%pKSH(u(02~Il_KH?V&Pvu1SEhdRicIT84ukreDh6k-y>e5(Hanv3>%6?HNP|0z
z{fC$JM7Yt$+k?feDms(cgEG@|-0qFKxn(rD+5>5s$!rH$FZ3gC|LmaOzCku2?JduY
z!of9PfGYOMQ{X+xWcx#hE~_0>+UeA_@OI|)nMeyvLc6%aGIZRHZCdU_T40jd!3}+a
zhNyhMf80}EU7|u|nWtE&Ov(@mwpq`y|N1@IKn=>7m3`7^mtI%H6W?}UfN+^H+EoKk
z?+u3!4XQ5qMn8oW%t|abSrKu`Z8Gom+7H&%OK#6>ci{(`MsgeKIM%G&;r5mSH;Mk!
z-ivn<wP%6y`w^;@(;linqqd29V~f(W!4g!-;c}Tn4|Q&-|53ke4_V%dp1<$2M?uD!
z%%ij)pK8A{|JLAZKdNe_G3O$#!)O9E&a~r(y_bRH<dK;m!C}aXfBxx=KzU4dKtp4_
zvrw*HO<V$V8`UdBmV)w#j2dV3UHIc^;CYy(SwdcAuSc3d?4N1f&6|+P%-Spm)tIiW
zg{J+1B;~D?9ZWD^t)4x+9idt&>)91NbxxTyI~9Gum9i4m$W&jd^mHpEDK7#$-w)Er
zs3U9k0DEN?W%<RbCFlp`^w(Sc*pueng=A()7J(YGKWX%lPm!FG19|fw-mENob?PMq
z$|bAOb(F}u@9@M|!7jDLw2)N<M%tw|^3k&AGgbj%nWb2M^8}mHuW8L1mIgD$Y*0m@
z#!NNY_}~mACzq%2FgWd>Yc&xlm!`0I^4!gT4MQK#WhppZozrtpB9fC!Qh2mle&3hH
z5hypHI(uV!u61H?r?TkdxdBz|jOmaqwr)ZdA<V)nKkbT{C1RVK&z^)nUh*k#;u{C5
z#L-Ko=ANYli+(boDnZZ2QRgHH-PC=v_NgJJxGBu4D?dJ{ec@=U56rnrVHRBxsKL^b
zlctPCa&lP;4`~nIeB^Hg%4I1$P3^W|>TU$eWhp#M%}VKUlexH0VHR4Ei^h3R#+_A>
ztW2glu*Ot<_ey+0BrB7t4k*ZcdR9n}N3hI@>cWQRsuWQ&KKC6q*KjG!QY%NZhH8nj
zk6(PHfw`DfGD-_&X+KKDRkQcwJ4arwZ01!d%u=g>z{aF)OMhSsPy@5pDu4=Rt@VXc
ze<55ZZ)w(G#=2;6(nzEQCUsq0BO=^-wPb4~Et9(eR5K{NGWx+$2$vaV1GuK~Zc3=T
z7I1>ua*AdR=ELLeuMq*<0`K8K=R_T3#AmCNe*wwL=dY2z5`X_L_U8cv%Z#@|1+Y|d
z(1FB`<`P!9Rl}n%3b_&g>jipFr7(-GXwpCy+wRTTUjQ{QdrrBafWCX8HvNuZ`SgY9
z@xcmx!Qoa4@2x<`z+i&h^vvrAf!*>R3Jky+o^jObQXP>B_}qm_^0kx)9zn4D&<oS#
zmUFHL4Fgh`MOS18AW?qn_6PSOS^3n3sdD7|C66OmK6PQTTz<eC{mccea&yf>U3!cS
zUFU7RV{}O%F0<^4R12#bn?#hk2^cN2>dJ*RjP_LKEtQb0eBQ!@Ir-sFz~Oufv*yZ`
z)d;%De>8su$;uD9Fb`jwQ~oUk%jYf3#Me(9@+5*~@>VRwjC7I0*pMDsK4b;Vq}hQr
ztYF5Q9hM+jnY?vC>A+Dt!R%e_i8nwt!z`{6J4Ij@mQv>F^BxE9_oYZXU=deDF<su-
zz2<;iky&9Ckk?S|?vKl?23lY?qza&dkb8gJU6T<mle(^U!K^J<T(&5}WoFDSt`J+d
zh7#i|)c{7ue9({d0CUjqa&9gS2*Iqea$$`*d!xpqXbs7%uyR4cl+}E%7FzK#AN32s
znwpJYy|o$AET6tcYD=zW?D!6#{Z9(B!iuET@=xOK57*9506|weTON0fUE~E77PkjF
zU{+VT!h#vQ_029{Az0qYEy2PBwA#Lz{{o|BR#&;OhS9DqmI~_kQkX?mE+|kz^3(xW
zkP4)`&2yvDQ2}r><(D-A&2LkZq$Sv4jT9l{dH>x=R({Zh3FxV+X(JFUKj<0>C=u+*
zv90DISUzuIqL_Yb1n8@o!t7i{cA)L65^tOJ-?a|#Rw|aqTjRm+$Zu;;2RdNZPPxJY
zqkXIW@J|pdpSL2fH9hUM){lbPsT5}Ilq;>sZuQVOYE!L7NLqf#g(+ym4&6Yz^%NhE
zxm2HrDw|gPvSE&Q#vm&eQhYq(22i7&8UtMqzZY6`03={OX=Qo&1cIhH(@~$>(&;CJ
z%46?f{}8B#V<m<UL2BTUH-H-LoHFYIUn@HzxTmCQn77^~=r{*BS{#q4*u>)=XFD$e
z+s#rJEFRNwzLq@S_0szXftH!IQzSH+yDif{Tj*`CDXLJeBIjihnFGaB?81h{G9CDc
z(&tleH%pvTnAKA%cKV>~zN(_hxyOwkdpDAt$7vNkGt<Q;Yb#NJu%COXY&|OOCFxbI
zSc&b_I7LR)y*H0i%RiU>JH46!rk@JV;CFVrtiBokk&#X*S#*T+2)lFVEzqz~e!=cu
z7cSKh1Ju+8u`+#o%jg^G-`i&UyL;NT-oCr*zV-z=zFg{BbE?=X<y%wAxIuMey@Xo|
zi9zV6evLHvTnxys*>~rp0ymhq6jPF|eD~93!WdzN8sM?so$o0jq@tfHnU&=(pn5%s
zi2Z8kzk*j-l%roM9*fxeSMT0<<RkFa%87Dr>T|wYuul8x*B7@uhXAdC+5KwaBQ(JE
ztCJIf8kHURJSEgW`0|>1tB`zF+Pd<I5bww*E&b7XW1a5F<QtV~R(30Lk#BpacB?y6
zJ@lU9#(nI5@A|>(-6{4?R*sb95k=Xj(M5E3baEr$vg|ceLDVJ@al+Ti+b>cL@2}W<
zg8m|WRSi}i2Gy{<>y|`chvkJ<eCS*al+gc;>zqN}kS=+u(9-m68eZNt^1fXST6bPP
zVUJ#T-geBmb7sX`N(zsqaS^q&iYKD#n!3$y1G%(>v`|$9hqMTA51~Rz_NmfB3G`DG
zVXvfe=1;s)VBA5d|MaqGgvetnb<<bf6osyFkN@#MpileregPSsoeIqbTs*X?B$ATH
zS*MG<hFJaI{l$@#)&Lun(sKmlOA0ta`{na>Y9dT)Tn%6%#>Rh9YQ1Mk>Wo{%XaKW`
za00@XJYglLM%7$=kTwA+RaAkQbnUdIL5D4g2?bZVT$M_wUTpTZk^+-{Dz25Qj=*L(
zdA4V*uaQzEmvZ60hbK%_4FN>YH{&*4@vctENUE^NLQm%`H^dFf@1InyRvlB`RC^g!
zP+n1-ry1+6Pnsur@=Bei+N-F7m`$830MMtj?Oo($bHY+%t-H)FxDl=!-CFubbD5B8
zf6LFqbB{$d74&ajI~u8#$5)Y508jPo)J?0Aq&&V7rnB{@NqTbemR4qrO|>_z3Vy%0
zq7lcB8uqY5=k7BXG^w#x(kj?a>=wpr))VcowW=982>PjJ#-y&$N0SIzHwtjwg5SUS
zo=r&AOco31F=Im08RGG>UIo7P1Xg$~V;7UhrlM~?|JOp(?WWpGt6W9<v$As{9YsfJ
zGx&P*zn?evg;VX-RW7h|QOMXAp89N!W9IHsY8;co?&U6X)2dXVVc>>;s=beuA}cNV
zH5HtGt8i^#3voOuJNFD|*GfZOJauXL;=*w0rx<S>kIZg_kkRpI+?^ZA-OyC2Xx6an
zB(qzJ+%#%#s-9>L9Q9=<;KJ;+RE|2S7S>!FjVOP0CUD;NSNmMdz~W7QcY3#SPR%mS
zkNVwKp1R*H()V^nL)J1x(`PQcaK`&^g{IOv^Q39|kUpWzclJkKT|NfbkiBxs`)(0r
zOl_ur@>MEAl@2AZT!V@loR@Gk%N$UxS`I>$-)}>8&K5M(t<x`nrk<(x!l|GJ+@+jr
z`7(cbchZ8JJ)f#rfW2}`!3|Wb>ZEEi>Yp_80&%MS?Y^LKy|uLc7SU6u@UTnq+3U3a
zF_p9XeGaH#f5Xoe+{j~QKK0GVXxezOmQDgh!JDx=vcBR?*>r(A^b&Qdy>pc(rHHZg
z6tRf0&gPqD6*K1j^#~H$%HJTo?q!I;$EVMI+KVp=f#vEePXcFVMO4qA4OC6m>4R@A
zW!?=)wO3KOvJT0KGy>s<Qt#ddqN}}v%7JwH6_{bL$kl>dk(@mKI-B)wu##@}e<%JN
zObVq1m_jmp^_0tm?K=v#uhsm`rFw)p(k;6uSSQ#URXLwe)oy|1qO-lLO;?j2PL)Ht
z<po%0$z(RMsQ1&ch9GJuSmUf;?7PJ1S>}k?39S$sgR%lm_k=TkO0NzaN&+JtCNzWk
z|4jIG7{X(4lkh?u6tS|*^>dq=2R*4Wjk2+lCS2@X8@q%Z&$Qp}#cRbn?Nw4VDRBfD
zDl7%;<I}gDMwpDyN|^QQgPu+wytC>p3S9J4<zx_(Fhx|=O#G31tF$n;nNky_qsui?
z6Ch~uQR$H`rO;=~NwOjucC`Jj=N?0t3?kNYcW%4;duU(Yp!({PW=UA8y&Q_BJR|qz
z&a_N_8IVob>!Ap@U*EtYDw+(+^`SCRiTZWb8^y%T(@&j!7CqgWmkxP#eB?_s^W^7M
zFe^8OL+-q#NP6$v>nrI9v2)M#+Xs13Ly4JklJaDyzS<=UebKST>mH&aqrCu%bV*l}
zO_%h@jHk)~gSS7^=R#7)Bh8SG&bSEP=1sNNJ-LYfA<Ef;oa^oD8Z9u7fKu&+PY$ZF
z%9&qjQ+;BPwz{)F&*#jxSmb~Mn}YBBpR(%=uc~Om^e#wm0--4c0!eN{5`=^<MJb_4
z5eS45x=BDlk={g*DosE-Nbem)snUB@ks?iyPl|v7-^`wK?(RK1=brJ$)rUWC_RQ`(
zGduh4Y?Hf0=H;$-GKUxdZK?Ehaq-V9j!_@ZijTS%F8=eItqIrR-ZM%J5>i_9?Y0?@
z&(Zd63X{h}$l?fYAI`S*SIU^Kbi{FX@7PnXy&xt3_`0cAPpeQ;+R}lNM&A_pba-W?
zT(!7Fn*p{K9}z<sz+K>kgEjIZEs<T@I`AV3lNBx<a;+beCx2>X@rwU&mo`BMh5%H^
zfD0iCFEf_x|A2yJ1Wka2B@eLhU%PvM^stflv|Al5BXXL(T*=Yiyt{KeHCpMH9Rson
zOI~BD_|~GlL~`t|YZA5v24H#GZh{xR*K8%yS@&L02&yH=<ww>1iby}*-{KQ!glk%I
z>M%7r21j9Zsuw|S7XNTj4Xfa)a8qXP3~t5{<jnQgmQlo4yNi~@SL+`1Vu!c$5EJb#
zS3*4G5LI`|@xO`bh{*1)Q?fvPkGL>dIJW9VaSD>fN*t&Dq-WTiwudQ579$bTw;Lyp
zvOxNGP7@ne_f}5Uha0^d&6~kCzdW!-xx&Quz`dIjf{Sx~8(`7Gf8-*Za)ex@etZWU
zzKe%bY?yh^kEul&l@UF0kmBZ_4YKNiyM-x87BR)PNZV@exPC2<b?&6FQx1~F&c?}!
z2|YWPvb(u&r^YrT%*s(9p$W*mY2^8Wl_^X{{0tQBHi<x2>cXTt1ob&OB*2W1N6n_@
z<Dazl>?SfD<&L7CH6>1%T0vTG-_F%8kRgId8{H*Ixb!VoFLy`(escCh{Bj(q5{uo%
zNQax8h^_5`LxBxx8`+ChyKi0iANA!j9rN?$m^K&<yu{*{L%lq!`XOqlt{k<7x@NsK
zR0-NRXN_=NO$e-hzg+(gL$yFhr}jA%LDyGu(2UO16tP(9dvt;E^Or7d%c9&8e+ok-
znj1s07=%YHqPQG`8*V5u0}E`<rPH=<-xJP7(M~v+LaZzR1<KkW)89Br2?pFdISEMP
z@KP@ilpk<yAi-9S3@K2YVhgphZK#8;p7@ujIYhCds+#iP3i#($@ri_wQVMu}Olj5Y
zZ3E2M^6~^~dRXZ#_A#=^FZbT@F?GoqXYo`(`h*kw^0sxi9Hd6+N>ZG0v)hvG!$ZrL
zo=!o!Qq&8njk0j2ZoLSGx<8vIAbrYq$k1mU!;X~#cH+;=Q1wwezYHy79QOqD?3EnQ
zv1fcz^MvFs0irFUp~bcb)$xP7jMBU-{I%e6$^DX>Hp!SGwZFw>cvs8INJqHw$;_{C
z$@&BWKy?kP=m=5Vc_LL~dmNZLc5b3JbAZXH;);aIo2klS{xLFElsSC-H9)%3)H_T|
zkSj6U_k3@v7FYn&HT$(N*Q~Vyi{w^PuNN`e5(7{kU9}Zk?M}$Yn$H6`9#z3PL!HoP
z-6C0A?fkh11<E6<@c4QdiJ$&qP70JqR{#|?1Dg*RarE9aYR$_a=x@yfC>HR2z8`t}
z<(GSstcrocTe;+2c&iqT<Z=r7xMmeCrGUpMUHNG&Cr=|HrAYet?+7iR0Hz$Ozwd`i
z91z~_M-m%;svn5}CXbz1-LoUk|9#0uYLu?z6mFHS7mod8NplL*m7IuaU4yf&rig(7
zMJY@cH}TY$sA~>7KX3(w$s(vjsqpvB^Yy-3Fhd-Edh2?`%tr+LrFW_VTn<IOxP%RU
zjXbi9vH^#sfQuq_pIsDkG;ZZ}@9~wwQMpLnIZ73e<`+Fagm5Svl@V-CV5sD+`<B0E
z`$ju!iwJga&;*MWP{Bi?pVq1RdP>zM)M%v@oat}k+OG4X`>#GW=l`@S3XGORSE%#p
zuK#|v;4g`o#}OF8=lc{6aeQC(SoRh*J`PP0&d1*);I#~q?^A#rjv}BLm8GjMb2n=z
zOmHxWcz2IrL05u;s~69PjfgdJCJ8yJ?mPb?hcJYykgnXcAk#J)Y0twl&Re0&)L@uA
zUcx*>eb0CIfXu9TY}p2@!ly7(t{x6E9STQJ({9dgVJlYP2#Ac@0oIOSzCc;2FN32Y
z^U4w#3P(x=;6eqV=g+~jZ>_|&h08%5u`5N5c}tViz7TRX?-NWc1dfmh*H)VB&|%+>
z*}d+FU$wLFh+uaWkvYih+7-<L^Xp%sY{}zj2wr9LU0KM}XYHz<(<=KgOdd}yJjtn_
zXNFZl_i3Xk<7GRfDO9;qHG(Uuc4G!+{A>|^x*e6rR77oT%@8ge<D$_gD^^`3JiU9{
zB@sd3(=mPa**zdt3*}kAiAZ#14&|4sKz`+PRGM|d-@$(pW_1@6iPeO~L%DI1sNq*q
zwLuAG0r)9Ia&Nh$pn`5A_GzY(nVJQpRK**(w!$VXJz&+lRd`pPdJT*(6nS6uuw|B0
z)1DYftXz)F2waObancx-f1XvAGO?UFhrn+d!_$bW&ko$SVZS9WQ*FQ_EsPT40iGu4
z89<#)Df?OrO+{uhSC|!0?Hh}mxqIsGI7b9?v_@!Fr&|zVL!<SVkpb3~!NyuJ7J+`g
zovTvcnFNR3doKxCaSH-$tl9uMT>7(e<E`9M3Ab|2+&N4o!V}MIUZI`!Mg()DM_}3n
z+xkE9tiSg@fHMCa)e)j;&I=j4<?6}%L=}mnI}(_f3D}0YtoVgInm7tRTIMbev=TFf
z_ciQ@t9ln3PY~Z-cVr-Hsp`gZ>kkrfm7_VrkA^tl)$>SilJ&v-VuUwwf3Z$@6D;yc
zZz56m3~e5OLq%kD&Us0&C>^HL&QN~Lz5W-<o;+&mnfl;wUY8-VDfhlg=BIm7`li*$
z$bcdd*9b;RU+15ZzM>;(&teTWFCb>gU34UeN~C_tZO{BeY*pM}q_a?mm|GQ@tCasR
zO(NmvSgIpfqYy@f;Ks(yExA1@iIwmE7M;N)v({$=y|pI&+eBP)@22Dfs<Cu;fej6a
zf`@xMB`+*=>#_~?$E__Z67G(rHv+3d70suHf*!Q=?FHQ^le#ig3{$jb(xcqIko{j-
zt6!l#OLPR4IioWZacthDW$hi*V0oKW(Tm7;ut?SX<LfoD_LEBRlm_5X)nTt%{i8o;
z5fjGJAsL3y3aML<=8Gn5z>*@FkiIs+Rq*k>JcB7vUgqmiqO9BE#Bd^gh+st0GP;m$
z)|Zt_6J9^UHQmL`A;{YJNe}h(&WipNo=ln?<2>T|?4!_xdB(4MN`0+#`Tp?iIYY64
zT^9-O!4Vw^0i+D^@{3a}J*M|diwNd)Ix;Yg?7`-f9`1`gLM?FyCk<3z$r&;-WJ8W~
znkq0NSjKk-BdL6L_=KTTEL_DcaU@5^P;qNR9YLM<<a|j)JLRztKXWf?X!av0Tv5$3
zHLXdIlA}B_h8s=PPp17@`wL=!$59@ERuwjOj_RWt7cV_076M0oWFYGtZCCfoG=c^0
z3MBC)8?6zmI&gjzHB1&y;kFMZCpHR{h(6Vj8m0^(ex_esAky7Q?-7gIQ%g#czz?S5
z9F_j;hvr0ugVXh>OhAWTeISFtTfWfc(cT&ld3*Kyt;MaduS8Pm3H<UF%Y8~MN&2n(
zhnoCL9361PM-*9e9X_QuG>i!52#*9Dx>kL@cK!6-MPgZTghvJ{<Y%^JHM{lysu0VH
zBReu7b<Dvl_N}07$%>--R}Y;swlJ|uqgX){;LK9I_;9()Y4_FKtLXR;S@F|Rt`vp+
zNVD1=Pop&(b<xGD9G~jXCc(6`NNSXci0V_SwYf4;24K<DvG|l~V2zAu4*aPGkWBJJ
ze&_ph$k8^>Hh*BnK*>=>fWY7=6<fRK|8$=otU@@-qcVo@j<9Z(3h(_+fik2GCMc}2
z(l%NZ7}dRorsj(X;V6%E!F|!B(KmG3hq!Bw#LYZ1ndmxrT~`W{MNxd=Qa{z&elcR9
z&iW9J;E1|EIJ|rvg7qOB!I6Ly$*C4aYm6JwnVM`CL9wbuwUE0!|GS&I4-HXrNk2?N
zP`rX{TR`_R7j8}sl*LZOwC82W%Ygm0)>%~ug_m-r`{gAdlA-h5j>V6OiC5_E@AI`O
z>a@1|1>(y&QX`mnaQ6_GG|-sGXL1nhouf4}K=nF_r&!=VV%9k=i~tgn97sj&Zlirv
z>0}C%M@w43^kUVy)Yha+KOe&BUQ{Nadz@3ZslMBKHPeGqi2JK>=#=mtrMUWNH$c6m
zrN5>Oz~ZNa+Ui#3S|ce;R`_%%KHXh0A+x>_4+&w=Gsw5>fV_-)XYNg_ubaY4Sr}pP
z(xEssZ|nWKdIchcqcehm>bs>)pZ?XK_;8NG2=MG)Zsw69)u_?QFL!huh-T7UCUx`j
zKOKcrjs8Pf>+XsoNa~Dsxv8|1fY_Fk%Mq@FBPtTXg1DB@?z<22Q;>{|)_~OeIQE=&
zHyU>{_*1{!HJugDRTE?Uy;RqKsWCE`2vRQq)H8&!{o0<S#>gNdLi*Nluz2xuNQWWR
z7+EX~fm1X{2bH*sRJ^^fnz#3rLPc3lbf+SfxrTJU=xy1cOb<s-gr82Sh|>NLpkEn`
z2;r!Rf}HN5EsJZAhH#Z079Zo<Cs8r2-_s(L`*qh5;mSlzSV;CT@i6d>KqBRE*AXG6
z?$kb7lw}N&a(GyL1UPcF53TyP-dz^vhs8(%s^4e&G4=eq)IeFJL`*6-daG&5cL^48
znh^<Of=TUXNX1Tls=xRS-_9Z?j#Fwo4Cjv2yf7v_5!-YZgr7o9nHxD!vvJ+JWn*J&
zA3I*A&XFT!nl((7)T2l4zs&B!GIne!F@FdVJ6LL>rYI&NI(Iw>+jEhaFLy1GxlX|j
zx*NUqRXP2#XhcXDi==2=@FrS<JiEa+0|-WOghSLJs%PXkC$wI4Fh)69egb=^gr4zr
zdd7F`XVw9Gb+hyT%N?}>DZ8==>(u6R|Aq8%#Gakgs7Mb@j|)ZoLc}_bVhF&9c--uD
z0sS>wuqZ2dCg25mlKck?Mt`j<Q9?LcAsnYo+k!M*R`0hm#et&uQ)nuu#(}0rE0hks
zdM3vu^h`4Eq{SFV0dQYb-_sRL8vK9=RvhJ!HFWJjJwEX>;$}t&M?Zv^D9zI_V+S|x
zpr3|>aP&iniP!QRdKWFO*fWtJEk{NK$l5?twr-it+J-1e3P(dE;GpI}HpszL?Qrv~
zX$i)1^h5@>Jy{c=ZC@9ozMmChbszY~#?_*Cld-7YO3^8yd&jmBA)FRQFh;06z}cle
z67Gy!5JP=8kG7(kp-<Gqc4uZ1TY7gf5r!2UDCU&DdkAFi(GthoSO+%>bEP$T%%!VD
zv;NNT8(|1{RgoOC?gG|V+gO$GUhbkI0ZK_#df%QKL^u_WrU*<+S9P{mE>N5rrQB5b
z35JNN=`-HHnd={70dV9*L4ImF8QOpIIrZ_<cl#NrL-pm!rH8*#m~vIQV8VK}hyR;N
z`L<G+tTdQV=%6q8_lH^|C`=Yn9mFY*ciy>0VY1R-qSY3X^!TaV8LZ4oA*uXyHc6>{
zYNz*BbSKglj+O|D*u<5mEa!XQAWXnf5&@uSm7~R}n6%lK5v!lm(@0>#A+R{SR<{1Q
z0=5=tsNeIC2;oSH02X(un(!^dv<bn4)8pugOh{t$o9<@Qb3_S_)7c0>?IpN5UlvPA
zI44dkBSeGyg7%QNJkP(s5k)<YtOyac>Avxx{9fxcQAtZUk|F~SFZoatzCWqQT56yS
zdLppT9tx>hB5uvqLXh?1PobvtApe1y4&~g9_0wJ;=)_SM8AFCmfPDqDtew2mQdB7R
z<p_&ROt3HUqEw?vIjKz=M_Poq^l8S+I%!r>gJr~00Chgj*wib}MB+GuBP>E(IL|-}
z*aKDN)9<Y$N-G>~5ujqE(p<{$E1en<E`{^X8bA_31zlfq%?d9Fj~XeXier#2?`^cG
z$LWfnHfv46N=EpFHO}(%>R)K(*)1tp25(`s;9zhk><f$Z4M=$@j!1tcs$cqgJEzd;
zZ;m$0yAZyHqc18?U3LEAb;FN|AixnA0iNAu|FR|f2x@eUk`kclE_?mYgU?cU43;9E
zk7vd8x$xs$zYvR_)6Ym$5}}@=@5>M68Zn*%Wn{ZvP;I2&pUO3e@FVWBBJ4ecDoxl!
z>O-yiaN9X*s4RXWDpg0!e={L91<GP4f<jG6`~I?(-t9qszhsdg$_r3&Z(2#skecON
zOgyJ2y~-gbo0>A|m6hLiPxC&(0*%k}k`bZqvLZM&Y>tm?f)uRrwoKkjFPK0Zw`tP`
zEqtL{Bh<aAk+mAIZH#8){q<ix(^Ixkj<^Um{Zy4AZI&OO>2WHQqcB25>JgcDn_oYv
zXDXrYO^xu=jeFVJhhJDSX}Z2U3FSzP5L4H1#GTq1NqskCb7}zUlN0r0z<uhwSyUCr
zU3wh-XY4+`p&u+z7E>*6BG>z$dtV66H?B;X@P!7uaunA)o^;4tc*askie@>oJ+q$t
zD!PFGKv9R}_l@&c8WC*b2#rMdIb8Yrggu=(_ZG1RIC>)kRe$W^>jzEr9+?rL9JLYE
zb+vWp6>D`z9m-J}2{<zP-DtjS1qI4Dp)o+IgVdVuzpPEo5G$mbm)d<3GmQQ@iw)dQ
z4VA@Gr_-L8H>%#GKv_Jc?nvWEKX^0iVf_dxl+)NqUqxGEldlq<grhM6FkSzMEG?Gx
z!B*=mLT*t*WuE7krEm-Z*{$|oB7S+vh6R5oSfqq#KXD%pPKbSf?eH%)QIJxu=mx0;
zkd?C*6HW0#mGAclsZ}OUR@pR#8X+sq#eE2rj76p+eRIpvyQ49-Bdp?^-PK0uo8d0A
zrC*YW6Q{JBg3AaOyNc+_NiU+_CFEGlAFT=Ua2`a1r74b}t*|7MrSD%w=uI&rLfxAg
ziME~ETrU~1dlx|;&U0umM%a6LFR;rYM&G#Emhf+!Mn(pvlHD6Kgrs~}_}Z6N#}S2;
zauqp{(hxQr{Ge=|W3_`o*YGHp)HTR4=Xrg&hQ3=4<w%c=G2_v(Rppb*DysB}O4uR=
z)fmdMa+e<&%L?vKtZ#~U@7FZ1eW+~XHP*V7<Gy<0+}DJyIa;Lh&H~fqY;%H$mCI2h
z8K_j5XXA?ly{MtGVkw@Rh!omhJQ|%)@PEVt=BSd&Tlbsom<wyYbBe-bg;H^HqGzX1
zJ}S|H!em8K!~}<6A7|xH1AnG4SsAaxX-s&U5xXf&*R&V?3sE>j>VD(da#+9Dt$1q(
z>KbB)9&yPXx^zr((A75>wRIP<s@w%hsP+gF&!50Kuidg2a=h70FC2w(BuRj3FC1Mi
zS7WSR=n3U$kpNAP0mJttmY_x_eW7E32D}8NY=BA0xafCIQ=?<>64A7HKYP}OF?#Vi
zG|V-W;*4N%18?;a&sFxmJmMDNlsL*GFRu2~-i6MyspN#CKr%qBi+$4PPwSTVGBU`P
zO1Nu~4mVlT2n!`A^hPTa@=u&heLI7d#xUXV!ROnNmfQCJkxMV-DzCwEX-Sof>i>F6
zl!`E9E0ND#cVt;%P4k9AlDKB*345o+=rZ~8S^h-DX5_qvHDa)O2y!XvyzBc}4F>7@
zo=}bu$rl{AKQ^jeUi{B^jNSNC2hJj{XuN6ze4XNm{=8vCC`XKhH|Ui_OQsZUMs#XP
z<m(&}5@Om{8oHR}8}2<ug5Xd6Zbm>wNSH442QXp!L-EC)#(zk}D~=qgk~oeg?j;`k
zXVf)aF%=rlh^zJ%ocQ(S8(w&eGAN6@xKJ%0W6Tj!_fGBpH!!F4RrxAA3%}Gwv7A>z
zsGh_~C)S`<+&RLDxeJkyzF7St+G8)6lV=@aR*nt{%xZ33<Pa-Y-aeBWqTHrCL_uSS
zo<=A1bb8&=>OHLzy0TC?ZH-`v?uy(gsk;z7;3$$RnQvl<Z6R#D>=}zE^uQb<LU5WK
zS<pIYrQ7qz5S1EEmm~eHsl1hHRv?@o=QTBTb0r;B(v@c|C_olXMFHLBO+TE`Zm6!I
z2(7>(Y67?^+_XbfiH}!+k*+twemWiibj6>tca^#Sf1|5I<@dv3M~)MIh9gTt15?`3
zDINP3qaaz4R&?Og(!=TZZfqmG07sVuqtxI&@A^YuBLC;;kpvvZKu9{32}75?a?q9U
z2sUvfNd_ua_dWAE&ueO^ti%|X7KBzk06rPt=PqSWR&3P^{pC`mPNKeCu2l!GD%A5(
z5PJJ<-%JzDnW5Rnz7!~rsX~ft`F}}&Px1FYr$BjZ6`;P$37MKWctzM-z*77vOqB!u
zPfV4Gu^e`p#8WSc<dq{%f~5t+j=@C$Zl)MS?qareJ7HVB!h}sYDkTG)asuZYj*cZ#
zERIA8KtZ7d{IZ9uz}q(-QJAbu*g^I5d_kE%2!3(YNtK*6`Tc_PHKR<*Vy%<pX?IeG
z&eZ3#NGqyAda(ZcV)R`Klf_(zYS8P&6Gu~+k`I2o0Z|P?XApj?b88}Ob2=ZvMH*W<
z1UZ|gNB7G_GA#XoD`#C~NzWGz8cVoXjw}gBY%jQEoiw!xVE~RQNx*5Da8l(=A-M3d
zfURV$?j4UH6JBfF=suN7dmr%5;nTy3k~pX75eyRxIpp^8;?iHXP_UeGlL1SH!CF`9
zZNz(z_)~4bp{W5IW0Wr)$^w%|EnR9YG8Lc0*vhbng`!qm_wL5K*k#2de|DF+Bzn+v
z!qITrB7wcdU(mCI&g14@CsZ&|90DUKJal3UF&To2eM})rx;eW9M1&4=3L^4%Qsz>3
z^_Z(1z5FNsQZaXX=TjARH|BBIE{VH)c&T1bKdzrHxKv-q9*$~BOjit~NwC&bW1x4u
z5MGODq~PJmmH?L2*Uzi9geaVPIJzYh67nSbYVCYI{s%qSdN|4@1a)|gwfsNd9MNmh
z9*%YiQ1wdr)N(VUsY&9o7HcoSTb)&nCSI6DeLN@BieW-Y$J%trf=0imM?^x4$kN4l
z+yzX+jXPYf&KYv$Lw!%{ahEZPrH>XM7Ams#>ZeoQEea#WpUjk%lg<CgT8B;Tv}U)4
z5vJzInT!<?&?`~jkW`!V#y7+|<H(s1RXaxCv-}xx3hCi!nG8Hw5Oz=STi5fMiM7iS
zG?|!WpbX3(mRYZFdqQ~e7d{=!v7m3M7!aS(SMlWNydHhIx{n@&J)AB|=8$2sz&GGd
zSG=uh!>?RFDiviCCY_BJCiKjC%efnIdgS$RUU0)<8!t@Q9c1^W71vW^<wagcnOC{F
ztv69)<%M4%$qMp0?nEw+y7<#HYfUIzmX%ajE`#U^&-_~@*k8hazh^0;$ESxQc>>!y
z>C&cNyf|Jz0re<CN`Fa+J*D~k#*wyqmCM5sJi!=6`*k~ca}|2Hgm7E#J(h&qO+W(R
zL(sPM-~Zn0DTLcnPSX8;wpKiQl_eV$#FZmJ7d*_2G}L|lU;adWJCCJU=o0s@ZQq`2
ze9yhqxAS7IUg&z`)B!?u?%^n(aMHmKQjfK^t&^?@k!f<YPbMlzrj;*8c0Q}vqf%*z
zviMWjDN7};?6f2lqGV*&sg1+Rih6A9(_&jTB4beUaleZ~1PC&<J=3|~1%hTu%HS6m
z3Q0bW3j<ES<DVQOydg*agyzQEb9!of=uq|^gy-g{p8(XcYv119MGI4~yuj<&GooOJ
zHwI8v<!yXXSEXH?uk_=$L~}_GrzsN{KnS38tL|v<=pHpyJpMYUs+tUY)t~x!UXT@q
zG<)3cabZCMHBMfDC2Dg>;VwC@twbFl{uBz!sb^DIJ+75S<&f;TO6nyg4@U(Bk%o9A
zG{wBCp?b;7!x2Cspz6Yqr^|00oj{FGW*CmtM>svk>>t|tdkRoGMgM?W2H(1G@ha2@
z%PH~;Xiq6#{=MoTH9iI_@q>L2CeVTtCdCl9dORHUlK|8{_;SS9%S4psD4zfj%X{K}
zs1mEhF!!!)N})0cX`({xH!}*kGp@D%%-hIGL{@gj?){fwXS@*$oM{_9zo@E+kdq(%
zmNKFU0OC*Kq@1Du#7T$k>(Q(qtkDGp9(Ng(NCDBxQv5<Bgl`R)HAO#6@^CsandXiW
zc{}XpbgO$l+8It*-CYS~S-mMC0;%)%+JA@z!s*5YBNkOo!VV>7+<2@PB|RJ+lt9(X
zoU861+(aaD92Jy6q%NrDFBSGJ5v|-`b`y(%yp#BM<g_EYqQt|IKZ#*ldwHTW!QvdP
zi7sCrjtWXZfA*Q4Tdt3;{D26qoSsa8iPcS@gc`At$a9vqTxFH!6(Y;+#(yC)RX+Z`
z&G0?Myt#{^#JrI;+0|_q5pRWiI9ez$1XNy1g_I4@61Q0o?{y{iNSwY*fT~B?K8HI}
zWaY@A3_O&sX_4pY)BzQ#QSw5qUVIB0xVQq5SaYOLI7-;CkVW2nP4?^{JQYX$WWtK3
z=psPMP_}DPchQ&97RuaJP{OIglNu>)p$wyL$%k9l6Xg)jD{nAVd+w5<;oO0Q>*L6v
z5KTKRL5{YHPPOQ52(<W9I4YBWSB@qn$0a5wHBU(HBD)?!rI6UbMh;&TNsOPPgA(Hx
zm#=Jj&8N+8t|t5}r$dv#G>hosNZbZpJS_cEB6e{EQ34tomD&)GUL74u5R9XVLPV{g
zvwBtG6$HUJYA6GbJ_+8s=;}Bk7;suNNm%>0XPr9oIgt@@IyIS~-i!#gS~kOeJ0gF3
z%CK@7``aYwp73;~q$7lj;WTZ+!5W^+N7s+u;91vJg(y_U4%S2k$K|sKkijpmY^tGO
zU03=a{}%?+yV&|kQ_EQw5|lKbBaJc#E<2%G$7{F=Guliv%(3IVRpeID8Cpg!y5KKy
zYP)t=t@?z?IT9%oyA5%wRBQUl8w5c(FT^1#RJS0wso4^)j&&2u4I{|RQAq))V;O4K
zoFT)hvC8d~KWaF%MXdhz{gM=@Ozqr2fg^SUbiG~aYa*NDv~dChkTs*$eZMMBEiK-z
z7v+3%muD}X)QxU6h_V5X&4vccr*4X5j?B7lO<~{#{*-VmG5;f(sjT@>-O{-TXUS1b
zMMDKdOB-8mjLc6Mf+L%XHsnZNipg{=ZL8J`5Y(2Av7}Rt#bqt8a!P_0-n?@KCLjo`
zcp7)*6y$gYXnO5|jj<EXoF!H*r@52y^}go{=m}OI8y!eEEzXm11|-nI(niRSACT~4
zck1I^Ict49Q8f7Khm1Xlpw5v-MMKRX#yCs{zb$T*+Jbt-$WDcc)Q%&O@&(s-CZQKT
z97<%OQIcnl{wrGSc5UtpsoS(r5z(mtaWjKX+33G4_fE)MMD5crbBdH{o}^5XA`O0B
zQQSEj7c5nWh=?=3YxzIx)LuFRrFQJs87O%<9o1{3`0%N2gfNcy3XG7L7}sAvRo>UK
z!D_u)8^#e|*`NGECM=El<uwJzC{F{N=BXZDpYoyZslqsdD**?URXu%Ku>Dq3%8YX6
z{j4QJPT&&;@Vi&6_&1RnC?jY`oA;6Q__{e@d2#*HP#EV;I%sfWBWJq0b$+D2nvrn>
z816fKGg<uVZsjjbrZ5@N+QQVPJT}Yj1ijuL#*tYeCTuyC4@Xk2IJF~QKQU6yU;YCr
zspy=1d1G}wo`i99RXAWuR5iJ7*}n-EaYR)B>9gU$Y07=)rx{ik9vMZ$IGQQ}2W~$E
zTs~1PUiWT`5IvlPag<dSGPpXxrnd8a7BwtM8J5LUumV0jqO1k9#H;c<mr#af(Ns^Q
z^4z&WTpAAJJW2<jPv7UrR=xQqy@(OUkx&_!S}n8N&zGkYEah~GG7<GN=$;*JwV*Ir
z@fi0gP$D&=r;+a<QTH5wf4S8cQHh>1bT|;Taoxkmn?sYhrg+UgmB)H&NA6b-M(*lM
zn3SWOiVh&p^@k;Pm_vL%M>PeA(1XNQe8;sJUF78n3R8Z+pRi=?PPD178=osL!B38O
zD%$KpBKN7rd`YvO$}?*@;i)+qD(Evw9F?y+eRc!EPL7BQ0qy&}!VinqqQ>W%KZ}P|
zh?C=_scZ63fSeGDN6}iWE8VqhxL!dB<0z-#gE0-oiy<0p^?Jpk_3cO)M>=J~Qe~^s
z<J<PKx{)aKlsW+idKywGI2fRl+Q%n56E)^Aj!4QJto|NYa`!bY2)lChQ6{FcA(IRK
z?AWQ@i8#v9NSUxPc;E!#&K{RODm}HGUat$|2&KHpRz*!;4<l-xnNRpX&hvGEE}BKz
z;%KMaJ&sV8;KWfxv~FJN$$9lZ7R(?LX^vtF#!8%PqHEpN<ai_n$|Ej<+P04fn(l7u
zR(e$?OsV5K`)lfm@Ye!)a#D+y6H*19?hG)hrirh<+7cluw3SH|gSJ%K+cu=i4@9_9
zHoGpLkJ?n*vRa#_TC}x)RuWYuS9imVF$xnvF{&fYg0|gT=^BzSPWvcWT#&NB!nJ5d
zG^OeG)uhbCir_qIhwz#oFFbz#Ou~<IUbQpu@X%P>4Q&5tCehY5jMG)hM72i;WW&vu
zMQc&ZffsDy+ll4y<cs`|^~2aOj<5<wYF}Kn0^+9-PQbmJlt>4}4w!IP`ML!YuGL*n
zWrF(F5|OXNPZm6Gg#v}I(zCMo>L8*jay(--Vz?X;6<XA`yT*C{W8<1agjG4ZDS=1^
z+8bea=Msy_T`y%?6+pGKyoN8@r6$P9kxSt~H5xq_xVR(Xt~o*}0}tJ`zMw8#`Qa~u
z^BlF52}@nEjGH>?5B*prjH8z_QQ=qxI7(ersyz39jVZ(Of~%esKRkaf6*c*sq7qCL
zjMBHu6Ry(HpY6><S(O)C5mUBvkQ>%awdXIw-4%u`g{so!IZ)Nuu%3Vxs;B!uFPUjZ
z|4daX<W14AUg|V5*Syu}{bB^KI7%s;F<Ot`=<}7Ch&9X6N&%?Q<3kc(%)Su}*^*+F
zUiS~<h@}7)x5F4(p<1JtK-W#~+Lbbc+;#ZN2po3B=~^_pM1jhj$Pu(nfT;e%9Yebj
zmJA$xkFu?F+-{)at#v!>_)k+jr^YH5nLk*xD>2rj35ofru`(zN1~5S3zxJ^{daGy|
z3YNiK39GMxCZ7ELDOd)1O<2)EUL7q4+QS3h*ki#e?3FffV6U;C1<7`=UgfIACE8Nh
z#xYMH6GcmoWC{i=UgA{;iq31u$p4ilmH<aFB_PEeFgxh@;&&EOpp0r0g2K9j9?f>p
zTi5#br$8BOH9;Y@w1e)t{qrGfo|H`iM>A!DikEKeu)SM8ARdbf<7lQ37D56E`*Dhd
zeUu4!d^KP-yB1#+olF#-I8WTQ2?!!CeLSgfZ6lFcbL3J0XfL!a`)%+63XMfjpQbLN
z4BX|~R4Z3ecqyF-gO?8JZ`BT2j}xg1M-~O2t>=Jc)6Jbr;W30zh^KA%B4<oLZI#%R
zrOpvQiTniRx7ZgX!RC}=cKkzJ%MRnnpA1||gI{*+hgS$s$B{o7p!)v*x7tg{ak644
z<kCP%eHWeQkL9U|+>i5uoiR?hi3h>XX3{ZZ>i>`6IY;|spu*9LHvhLD)h0pZ+V>Oe
z@%ushrj7L1I^Py1@@Y<&D0smLmy|Cia&+OwJHJ^ARpF>4ygNs!no^l`pKK+T6i4WU
zL#0+}mije%5IbIu)=5C>dx^;v5*Jc~WJONV0Y{snW1}vvr65^xQ`BcQ$ODxs6r~_p
zIWE3krLWG_e}4TrWl9!1$-5h^ntnyJ@(<&@Ue`v{dWj@7Q~fWACkMhf3MT^-KHQ!w
zENK5rPlD_mVH03Fbm;l)>n|4*yyQrl0904=ATO)V`8Sg_MN-lvCkSbYF2q67<db+H
z-s!+Sv#j$&$#bP##NoL^FrM3VJ8>2t&QUW_ZtmjwH*Z)jNyg4_j*v;f8L?B3NuEs4
zOItm)R9qI_VSOSlEGeiQ<IONU`_Z}DurHy<4CknvjG@D3M2jU2lXJb&9Y8pzt&{=k
ztE9n=NYO91?4Tg!`tlQ=&=k<b(iTSN&hBwf56<BniIXu(qda9p{VO<-(9eVi%e|ey
zfoi6_P<#0Y)OWMOGM3G(AYzn`(3D+Ut`L1(@!Qo^B_pWA2oE<I-5BmJ!E-igefkU{
zTk{nt(oerwpp;_$vbB<VbQ0Gy9@i+YTfIDae*4s?mP1g+%@I4nd_h}pe|`IM|Mkrr
zVli-JPXO-JlW4>Fartx=T{uVm1X0koveGW=HA{Ee;T*vefaxc6xE7WNja@-3FHRpR
z#H3DR{wW@mhZ-h}siKIkJCs8;FA&nsaE{mshN(HdisLpCF*Tf{a}scPIZgweQ?t)z
z{aiYnBXu%B;p70FwMAH2k8S@}=ib!XbS13WyE_0Jm1R>|L0*@-TzRY>`@TM)oO3uZ
z)~Fz_X#^GIr<tN=>?@h6S*C>jwbYCGxU$9{iv3D2%!YG>Plh?LJd1rz^pt2}KpjFi
z9L`Zd0kr92r9b?5__n`s!D5!B_!alYQRoj3hLKMYENJ$|y95b1;wLdgWUHP3txpCG
zCzb(6^JHMc0<)H_{Q64|GB2={Z|c{(($)HUhz5;6rdGhi%Uxsi%r#tj-@+lzh-C{*
z0LQAu!=YE&)};)~3a{cam0mlJ-=A39%3M_wuwpE(QJ>ru7ytefqgzv>WHDA;PVyZk
zM%b2D2c@xUkxD)+_h}A%HEPE2umxE&&iZuZHDaV32~-<XrKf%U%rXy(6ZYgtpr8XC
zC7$>_wBHsY!RDx+EJX52n{6llo~VmH!a3R}FD{%;LdH^&Y;~Bm$ge~z#c+=LNyQg3
zW$HDpb2I<UPuazlya{kjXIPqi;&e`t;wuSP!%;%vvosdAErB_Feb^IXJL6$+S4D;G
z46J3aIMME+^};Hrb(KvxM;PVvComBuH0P(@8&%p8G%23K!{D_Ej}g9HIjuX~AMqtR
zSre&{TUJcm$xRit?oW-#W(hi!@p6Px=6HL=^|sRH;`Y+S?3NGv62|68rcCrtg>!=b
z$pg#jeMmh+uDzcIVlw{J!MpE%wcPBJ*%wX|X)Z$@Wo$+W!SD~aU;m|_i-a=-QYNJR
zB;$U!l%1$Cx^vkCv|_tV9OuN$9!!nV{Xocsw5K5H7q0C~_)CT=$^gVVF+44TcV&%i
z*XAM8*2@1C;ddB1DFZ)*e7NLj@S)=rsyk~fR7l2rG7*f&H`7<nL{L^vmw(DaE=C6A
z_SxTjP6TA7?&Xv<S%dZM&5r3v_{hY*6sG%Gk%j526+_H}M`sQoT#K@Qa2scgP?6Jt
zb8yCDwJCI&?YN^`&&~Nx9ge;D?6Qps$HmZ3S@w{ZQ3)+(P}+`P5rqndj!K8uv}6G*
zCInh(pyCx7aw-GdK~dZ+c|scs);%_xuzFD#E#08q#PO7+-BW7=wnMKzASV(jVOh}C
z*&|T>`&Ek&nI@wXl>zVTGLhAJMnA4>MR+9;OOMH5H5G{u24Bi<c?)IQ7@8{YNJ-yz
z^T5Iu6fT$An7dLZmoHk@=|B*Wp{tVPwRC%W0VZ4a@DrAmRcmnRjibgCO=Cy#(I*-Z
z3xe@BpE+zFH;*fL%9^!%h_Vi&FO?V3p$~M5Ll>u8?Hg1h$hGF*$Jt*h6#mZ6keMMj
zej~~-?wzX4GHj=W#3Yk|cId5Z2G1p22BTk<X&JiZdgV8p{za`kZnW;)(d#h4^BaRU
z${on>0R=OjL5Jkq!&T|D=fH2X>b0?H!&II#XL5y(8<*>kTv@i-l#>&3-ycG-k)gmc
zOd>j^L(#)->XviA*{q8_!Wl9w12@5zXN_x9{4b(3!{}CJ;$eNtp1_u`m(+n+4~&LY
z3aDQ3$@j9@djzE!8Y~l5+YK~Gwf8L|A7sd{yoji5wApmZs`4qQx#!Xu2`6NjHr#K{
z{B@Vexfud1Ia=9K$@f`HbZ~v9ug^=_mm8w>^y=lv=y8-KxC{nFtt~rpx8#NOhb>$s
zHp_uJaM!4SVfB;DxNn>~HPM1q{4hhAWg1u%?e+7jzt#+|L^v|WGky}+y0m9?Xpwun
zl|9CGA~Gw6UQ0#C8V6KTboiyw)z=YZX2`Zoc<fu{Tg1f0mazDPjfCT22)7JavfBC}
zxOW~)wWm&?+=}@RqzDRrr!4MA?4I|)+G!$Qps7`CE~~Ma3r#)&xhz(*?eOKIvY(;s
z!A-kGt=JBlXMC<D#Qq~v62-qgaC;sjI)lK{u)DdjB{$zDLJ>pK1v6L@l!uCYLsG~6
zQ}2W|ScTNmS8zz}AoF;gWh2p0IGmyBGRLZgj`Vr!7bZdnL((M>g`~}LnDPuJVB?}0
zxPZ|P$|7U*uL`RW+puYHn)c(~_vB35BW=L4LuqX($>?nRLWmXS-o^^!5$LSZ6KhFv
z=9LeLSMI_YeXLAS>gxEa&sQ|2M#`cwj+Bz3^za;;O;ptwGB0za(b_p&-J@rl6Rwe=
z@)D3vnyg<Eil4KHpe_OyYfHjY@VHaPk~p<d9-SCYG{z5S2)@La?WBFatM_oLpd__k
z(kCKk(Z@Jwy=;L2-N4d-*bl5=DcyjwJ!ZIpm~sw&Aa+QFUv<`2V933Uuh)gB7|ZT>
zrUmNN)d~#Nmw~D|m(uxS=2OGu6ugauNeI3a2aCh(mScNeeYsX(D7>s;lH%53AO1_|
zr7JKrUJ9(bu5hfwo245-nUv`QbVoI{?~a#xZdZY!@iImUshuW5#(~!Q_5Lx+sI0gx
zJStRO^t#C77DdWZD}d<(FmcAZx>x}+yo~wtLOc!@4Iw>C1^2dAhedcni3271nqT(i
zVQXWeP*zr++$d}08OB+jzVEBIw#7@mMpS_z_YzZQCSG8Y(l$bLp51Z0<-8PgFr;2y
zVC|yN;`Xn<BGv;#=mnU8#=SPE+Z#ibGxz(|8bxu|&<^TQUF&2xb0=a?)J`3HDN~i$
z$(e0Q!Ky+H?^DB-=Z$_cMDK7lE9B_B<UBQHEczlWtY0CmvQOEjp{e&!z%t_aAFp?B
zZ3mvYGUgfu%;GVO*Z?LH`+607wWEMpO!fj3tG7z`IW6_=dW8^~F#9!y?LroY-X6Du
z!*I#rPvNnQI(~T^ZAv%cSWm0Q24&3Vm4qwHm!Sa@tO(MbLd$ixh_?|cFr;4wVuH;z
z7D^l37#*(7H8Qkcf?%R|Y^ug~?OU&k%hnR~VyM5wDDjk(%4HjN3Hz4_W()zC7nZzF
zl(xyS@AbsH0;Bhpz@@hc_a=9ZqClCHrEk>i9F~zvIzpLrMNmEH*1dD<fxbnk!03c!
ze!ea(pLguHcd40TlGMCm;R!X~;WXj_QuS)b{#!BR`f4_nmpmM(YF4isgJyHnrc8M8
zKVeMNzGe1x8@T_Cc~(SM_{tE22}}4K)?sDI?rpnHoIi|6?-;@`fe+gTTPTk%{`mtU
zUt;LOEI=w_PXE|*ni{5S)Wv8(?QHY?yy+;x1%?dF0>p)D`}P-g29GD4jE5O)G1h{U
z(M%c`)a3;=Rwi!|R=>S5{HJFlsIfA6i=eO%*T(uw`)2v{rhOF{YA<0|yG4KKxH1>D
znwYFj5NpY2kjUAfpKC{3zCa1DGSzb6tWmX&#-cTKpqy%4?@YuzF{E9_x5J9kOV+=f
z?m37^jTwqA6BMLvcB`(+_w#DKI$MF!_{zjAZ{0Yv{2_AFcnxCUi}af*BQTjNnhN<$
z81C)focr}H3RKRR-waEDY8A6eL-t%Id<vuUm0<;QlyYk@qkMshI7+0I;;Y@C5;V33
z2h&XYE?|<eFOZ;vKYc15bFqWE^3(#IoNmBkBdSQy;T^Y&HX=wZb)>GTumw7?Wu}q#
zP&I#NU`fKGFq&Uk_S7zMAX!@-+MV7i!YO2xK9xgOpDL8J!_dF4Z6<O}cV(Alhe?|@
z1$<%O$~C&ta4fN~l$%%nSF5&CcV(CsO)P(&uuBN#uxxA#R@t{?zC^fIMh7fox*z}$
zuI1A0z(&+ixl9$Y%0ASHD*bm5D~qSzGQOWG?JP;X{Ul`pW?Xf+y6|Z6@Oc!fD`AaP
z#XR}4=V`@4&J?FmT^TD;iJj}Npd=3wTzF!wK+&to=c)nnwZyJQu|#l{M)l8Erz7Dh
z17mjSqMr&%IocnoVEc|+I1ym&rVZ#@J0FECt7Z&j@v?v&`J-x|d_f`0eLM>prqGUD
zWZ=8UDP&%hHLaobLBdd*<7Umg*7PZ%fhX4j35w_k1#GjAINye<qMbL6TE&%q+{G3~
zb_}y<N4{5k4AH@|0^>bFbYxiAfvnqS8KWIuR?9MjvICFChzhO@?vL9?+b1${CgIC?
z5-k{Qkm$ysWk~;=%`t=6F*Dv4G>kwLp~mDne$uL!DS=lSfI(y`O<uY0<2}Ssd5SEw
zfWGVa{@be)DM&7biRL?9s#oem%s)?$1*1fF0|e71s=<kSR1KXc$ue=FWTe}m*`=eE
zi3q_HWtqTmDbZGqYjkv98br0FpYFmeks+Om4NjANMyI#!sp7o{i?&f?l|jP4GoTNa
zcfQ(xjY5?x)*TgCYs-^nb?H%wLghtX5T$8ZExMP|uk*~avRcI*M({Sah>EQaz{S}2
zj2MES<f$-<IJuQ0_RHK3y?Q3cCG<>k&}Pj@tos{b51uv))*1RQ@Z~luznSv*Qo=3r
zlv#jEbU;BfPa8WmHBp-9NwNUe;;-B?R0%(@2U8{+A>371CLwAMYdFJBhjzyzf-Fy~
zEC!wg%NQkndFRE0G>xgx=LTJUo}$|S^Ox0BLLDlXxfsR0El?6b%;deSAx(TQarj9z
zFS=j#Z@BW<GBGs7IFU|!>1{y67KDDT0#Ad5R)(P?>1-?a@z@uah(N(pUzxDL2%kWK
zB<?WzSb(J_RKl-x5Nr}tLHO@&y)zSh<LR())Iuq)WlaTs*&Ri!WS$ty3k#OEr%m05
zOs`B>*<Ft%_CJBfqgq7r*kjMoH+1b>1)dfQ25gU)b5_QS#t=65;4Z^5*Y3eI*}e4|
zSyU^OanDe~=Q3UtG_pIqz7HR7Te*8?J#9sJ2c8fMzujleqPt!3s&i%v(UrO8Ea}lV
zp?#^ptmnEEU%=?KWq!HgZ!jAJ83u8G_|u=xJ*5_w<eC4Z!ASFc9VODYe`xW|*4A3;
zv7{l8y@>3j$MU5BBIffH-=ar#C2jWW5IXjZHy-(>71zDH72d9!A%dsJ!nFW)rY<ej
ze_Z!nedR{*6j@$eyU*RQ_s`Q5DtBXzqt#V}_iijF9$1Lr$+FC`LYF`r%Qkxs-KNIM
ztB4tvweoW55vtuzYNGq^h+uAHcX)2B=Ya;FP_W$aE^1=FOBemZ^{Y!t>R};*(Sgfg
zv3zyPX54>TAG}VDSEjoD*^81SBHDcS-r-mZmg^LR2Hdx5gAD%e^oWnGZVNJ`D_4g2
z4E8B#%Vp6%Zr>loz<CNSSi(k&bS<oRE!>qj*o@%mv%IicEu`nf;5vG^h~P=I%202H
zZF>J^Nj;oLFdA~fLIXrQc^`Ma^Di|*7I^{BH?2b|%t+O51%=2WE+T4Mr@OO8HK)Fr
z#aTeKJJ<Q2e6f%kp^ROAIE8p-S|Ahp*b4cGB0_|FA1;v;H8UhVT0TGL#QZzdT4#||
z)NAnw-zSGbk`BvP_m!S^D|H_>NvXU$_T_lu>G=qr{>m7%-b|obr(TJKC3q4n3)ITJ
z<h0#QS13P5E`*l3R|HduWlURIZQ6Q2+`EDrEUR>F43_HkR&(6RDMXm%DX|P#EUVe#
zOR>T?iS9BHJRO#S3V8-``d0Fn?1W4vg3*afI4aC%iM?p%ERWCWr*9EFF&3;VGKEW<
zu|_KjloewU6vS9QEJHWg`ds_<dc`(^@hGAAeo+Kh<_d|s<w?z|R%t?su5w-d2jV(}
z*CtE)6(&r<Q)8hiAd%Bd(d&ne+liISlVFuGo-_B&HPFB}7Jbk}-#A6^bXaA~yDMgw
z2l5*G@oKMX>!;iij7D8z2KC4||D9g>C_rYc)dS;zxI7K1*<yxT0E7TxWCYSFezgAf
zc)}^V_u(>P88&M@kxFxl-xgj?ls6(6eYgx`;!y3CU|a<uHz!@v%ghlxIhGK-8r5s9
z%#7gKy6o;w>=_xYx4eVKs}VkgKq5ar@x~cT^QaJ6t^>bBhE8XAe?j&%vgdS<4)p$=
z;2Te-W!Qvpy=%uT%R_`Uo=(d^rJTd0{F^@{CXgr90$8QTuHLI<d)m9->SDbJUJow)
zU5Q3J2Ja($I<Nm0z<Jpw_cMh9dVWAqn5WS~NGes>TrXp9BsBh%yvALp1xpn+3D6MN
zC?^sd$0`>$ou<ai%$-HAU2PLGBX;(igk$8j;DYh`5DbaC^uu^U3mw5zY6(Eq+ZetP
ziJNKl4{wwNqrL+_g}Bn+IuO^;LLdB~Y@K7ZgPP&H-LbK2nv1^HsV6tflz&WAg8j(k
zNQu{}3E$(c+%o47W)euO2ca4N9DbLeF;BZ?m<DL9?a>}bWT`?-Ay2^tuqL1kL&eKn
z`9nX3if~tN8DR)6kPVq&w`qs|<;qjvE*-DmjUN`(s1jhAQH@hlQze&$D=c|OqU#TP
zc2mP;?t5{#_H!2`N806wc3Ndt#XBhdXk3S@_N`QsR7AhkuoI!<iU?;W(+>5u5qFyO
zBI;{A9aouv?r~H@A!Kx)^Cxat;YVS#G_eDt4W)FCxa1C9IyxOB=WW%i39&ACiY^#*
z$DXCcpDArKalT#ksuAmg@vNb6?}&?cw(YQi8&{7Zq6V-1RvDp{gI!x$bjNn+4+cD2
zOpRD>UHmRN>t3ZD_DQWJ#3Q^BJSmqkVy$EsIXHG0vC??Gw@ggZ2G_?_C*-IRJQY_N
zvv8>mx5>h*fkZ8f*J~??sxao+y68Ki+Q!pw0irz{Jr)}^ml`3fiUoMSAq+WtJ7Lpp
zyp800BS~pa#OAESE_iyimIsI-D<@HYmMaWdPe`7;b9fqs$kJ~iq81<5O)e>35<yxi
zUR){TIgC-n$EFS?$DD6wZAK84C*BgBq_E_uWe0Uy{xyrp8hO$!0~T@wn;X2m_{XEv
zSXp7$3##Rg6PiA+PQl8M;9yuxybM?>Cx15O&C?VtD{(epsWMZ?%;!!LF^2K7p?9>H
zduTJ(f7qZE#2%6--wJ|4kk-NgnLG4p?xR-fp+sAm8*rIRRh}n}-gKE*WIWv#4q2+9
z<o@jGlY`XZCQr5{K<y=XOp><$IiI-i5W!PzA*y(b)5eGQGY=<Pc|^Diw~U1gWlSNs
zv!RyS(Qc1^l`4WK-NK>z$rVo(|F<u($Re2xHY9N&#)VZmWvAvXnL}(v7!M!{N?7qm
zZbkCN?AVD53+b!4TKBgP4Od$`^`w^8wI?~s8dpQ^6U60-wS<GgEvio3cM3%PNcb6^
zTFbx{WqoBCAaj47(eDTmb7c_s%UoOoE~?A@hp+A=#?8}f8RMq*X1n)RI7Tc6o?Z)J
zwYd95Y^r`ZPMkYsF}Ulr%*BA^(Nn1!*|(;DHrvyH`g~S~EXE0i8(jg_xWf7p6fA4U
zYru-<l$F(h{_DeOpC(YSOyYu7!Gq~(LXTTf)Zso)uVsuDVx$(!s-?b{PQObM!E2rc
zu+Hsh!>3n2OE@r|cngr}ZnWzvr^sUMN!2AL$>ui$p_<Veeg}zM=eNdPtV~qOwtOQn
z!aK;ed^RA6m#0r~Ze8-B1l|AS7^t}3x#f@%dJ#90r`*yXIJ}bhptN4ZjpPZo01mre
z+2~MXed(|D%p)?GrPe}7sAFq+Xs>aRbEt7LJpxvS?OU-elN#5eAer7k+%mR(da>JC
zyXg#w<jJ(~)5)YGZ29%iEp4G>KqRk)7NUAPQptduvgU%R)Fd$za4d>j(LjQJbmy;y
z)aOe+`K7AE({sbu?%l5ktw{IgSw<%3yZuCx2Jh(cNRQr166;D*7j<QyQA1|w*-Ru)
zmIV_AnU`|BCsVHtWkU|(zi`u_EChF5mJw~?#(9NJ?drBFdiuz4`z7Y9&vFq$l}Mg8
z%NVk*g}ig7>DR=}@#I+ms>QBZdrPk(RxRVPM3Kw_px0kXtFHg^UKFlc4B@I(UBkC&
zRcOxEP}jXoS{eL^-~!{pMDI|E`_?HZ?pRKta%l?&Ko?_kTW?M*c~ehdBHaaBCc{K&
zT~D`erRpJ!YBwx1a^q~-?+zh-pT62~n2515y!<EnQZe@R<qT5@hs#rK!McSupqi#~
z;mp&AiJ9YxwhT;gxb~Xwyb^zAqEMwV{CZrxeGX=}qxRm^I+b4ajpTLD3bG!Jgu1UC
zxKOz+pHahQhFq+C!!om@ep~%%D23`uU}O0jB3Ny#H8<ZWK{zj-WDBUPm45TL8{3Qm
zWN{Y(6Ku4t@n<seaC{`MZI%Gk(yY>7-29EmiFi6K0qNtjk*;6m%P^-XxK{khDwk4+
z`HysUs8TQ4{PceWXL(vJ7&+eCv}cHu&sG^hgd3hz3oyk?Klatyaair`1i5%hEd({*
z`O#bP99>zUnx$k_;uue%1;9Sd!*un?i-+w#(N97mc`dX6-oAP(S1yyCnlKh?5s#R#
zy)R3JS=%|)1gvT`Vrqmq+2(bizFUsuDYXnlEdCM?B`%x3HJ%zPD_KTlAEsd)V%dXP
zgsLo(C(tqw!KS`8Kn6G5GIo`vEmRmRowh53{hti){&vMJBK_bgv~b)IZ;7yQ?d9Iw
zL>A7IXaTI#$#9Vl&rT6ufv3>|TycJD_X-Phl=_-jXFP3|1xmi3&^%kN-ze+K>GP8!
zn8>gu>;pbO?7dSIESJ9G&WxUVOl!8WG6l<JutP9kkuWYL;dFV=CYCq4$q2cR-3(c>
zOd+kyVle=V)&{zDD@4^8N|}L`Ity5+r}@Gnlk?VIdAkV2Vf-mfmUH%>nCuXVi*)=X
zmf#0Zt7VQ|%f@zfebk3A2v4X5pkNHt^4X^^BqII^u`YN*EfZFhTJ6Ah=57z5fLZk_
z1cuFzC}G=yYhNzAo-zcB&L%KqI(FCt<rlq2!OErK$4daLkxFZ@12+!ZNd!6GTZ!c<
zK}O%Z9ZwKx2v4sCi1r-sR`tahs1Y&=Y!hT)7!ItQem*rqCU<?(d?f96{acMB%2m=M
z{uk0x+ugN|_cbI;z*A;{NqsX0G(q<J+utEv08f)8PIFN>VcYJ+6nS=+SfV^dmH|o~
zv!q|0`)wjkP+I!>UHOoB2x+O7jh$^flq!bu<XG_9tI!N+sDqZRrkpEJkcFs}Y+}NQ
z#xsZwG*65L%|Y8IQTf-!6upQhzL7jJ7S&5>L&sM{^WsRJ7K=I#&HwT(qA6}9uZxxd
z#AWKUXF$T%zgau0eltlqAa^BfQgU2kvcLQLu^GngBNi=BlVyyY)I*mYHE9gNG3Cy(
zUotqop7_V4(dCIlD|dMoh7};K%@d^hu1^nQ>&Vk(0UT8W{p!suL>JFUo+t}2eO3Yb
zz&u5Eq#=Budn+yTo8im#>qz%1l@Tg0JP=hjxDhfKILwczRX0DFW^%%tr>yF~EP)R#
zy#5&)6sKN=buCSqu)`<lO~0=7nN9TDjpS*uq@$LD9NjVdaU3A7dv%bman&3o*6BB-
z_0bw2TQhe$y{0%o;!nwmW&Hn-Y;}AC>0z4P#FL+q%HgoX+?fjkGD0gTN~8SnIBp-#
z9IiCQD9T}$1E|+1DYe^a8GoPMnQ$&VJ(id`JaN>|aN~z%iJ)+qIWe9GAg&e@KmM}O
z1;QQhL|HIiC?9AWgALWv<e<jN%!h?qy?tC_F?*gpB;?!_3fGmu#v*W3!C%dOB8~{*
zO3-mw2L`S<2=Lu6q7UmG)-8-emE`b`itRRZ)Q4Ll(^IIfL^j8&H}OCo7o3x$oPLc^
zQF{61v1`PAp0{2>Vv+F_S>;91M_Xj`7QDNOFa%GIWn${)ZCZZo9b$>OYqHS1l>&mG
zL8?|fz{OC`Q|BJBP2ly;0$lxoaKpX{Z74+6UKS8_7jy0GqjVG^i?)CWCa~oi=Vo^K
zj<P0;u$4q#P&muiaZ^98afZmWcrq*lSIm-axIH2Y4J5J-o(9W+)z9%)7p{_-I2Gc(
zU04Y=9lq_zk*%dl2c)y;B!ySf10Y$^w>Sx}e3v~UPU&~HvtFfE`1v3BPwkSUmu1~z
zjaWw7D4y^NjR4EQUVQlUy|z8{*^1(+uMm?`IewEc_ntmmQ9S*X0csy-+DE5$>l(Z$
zUaKsGj0rHVh*cz*(C@?eReGr`iuaD80UiRKC3W|*uW}|r0w2XwV<9kgLwm{GGTC&W
z9mNx4RWgnQ^|E*S6yN-*dxI!m$E->L@d<tLjbp9+_DAm^;>bBFm=(V(5h+})8I^A9
z-Y|-%#S(y+!udXSjpW@ts@E&MFs%f_|3qGg!u0-oFA7-qEffaxWLd`Gt=GW4odsnk
z{_E0KtB@nU?^H+e#93<^fi6BgJQFle&h*8mfWmog&jk+2y(68j9f;z|vta02&K&yl
z$3GJj$&+RYK&(&sP9!D?H@;54m>@Gxq2<N(nis#>cxa~jsprI{$*2%!WXF0sb)#i;
znQQ|oJ21mL!fFc|?XaX-!Q0eYbKOxJNf_eBApg{sxzZRtYh)N=#X5B*b9pV$J12JR
zm<;%$-HR=aD0Jz@A!_(CK>JDjjcJS#hu(m1<vs>gknJg-4=+&)=Cw5Z<d$1WP#xHQ
z+UON<@NoG?wU5>-o%MLxLk&}8P6#aV`=V0uGiQ{#P%6Ga!H-kgxHDyT-3o+n<*B)h
zZ=o)Z|Ndx1HT}dkiYMqYU_bi|f(!&2oAINEy-T!9k8*FsWv(4sN1ry=HKJq~#S?YG
zcnwtFybD))mT9F#`(`w;vKD!rxGFhz>Yd%SL=U}W7{zPF1x0R~O@qI`F`8NgOrDFE
z#R#u7z>~CwNZ@!KxL}l!V(59xws!Ti63(8d>!RxWzcef~gZg+Tn{iozv-f#i6lvUj
z$na;nvP;<yI?%XOF|3S;t8iW+wQ;o{eW}l%!3CCXU#82%=y}R6VGhOf%Xodg#zN7%
z#kOwU#a&oAThj={)GzdVY<WDje<GX$PuyjUH3lpIUeoRr&Zqsg4Y4SA>MlUmGJroC
zlzUB?mAU!GYMi);Ya?3nf)mpySZ16?Si9&K7s0Sq(?$_#w|gHh!zVgOgkH^Dnwvsp
zMrlzw)IH+odH#8uLS;s0fvRs2nveQtFNMk^F;@7%)u{DI<Z#XXOGfEcGo^pIJBN)9
zT%}3wW_sH4Ph!)|lXg`SN@8tObL-WEbVQ2D({%wRln-IA1nWYz1+KA*1<D2!7Ul`N
z3}DFH?5H0kq$3_XkK!r23{<UfcyHWi>!^`3x$B_4TJTQM7z&k1U594E<F<ARBgzrH
z_FHgSfv6kiZLoU?1<9i=K<b6V%jM3-5bl-NbPGpmPdKW!y>gKnBaf~K=u?VBu6B7m
zX>%xKS@=`ZW;s2MT!jvKM!dCzm?8p~4v6a+Z>0aY*#OU5(NGuLT>4x2izO3;;|aRJ
zHsE&X&Eh8&hi4`>Up!Hl1U54U8QQ~J)cqG@5MnDSsk^F6g!Z*g?Ldb2pVyM$hkFw)
z5rYgnSSNULFBg)r@)wj5cw9D6Wy>&$yMNi51R@pTy`l)l#iAX)*kW--nzvM7atUmL
z;Cl@%%3aiDnYYQB=A}vpe$aG{^>Dky?sBH%2CSmkv0bU{#XeX*7TdY3+30)Jiw=I>
zk>s&NZo=!v1tt-Cem!n<san4vv03J|;{sSic#jhCvXJ|!@dH^uw^zyEt$9>fFE=hu
ztVh}zFCdEE2tMuvtx@I8+WGafk|>_+3x;hi47ubM4lX*MSjs%vmw|{!+*+!-Y0`lP
z6fWzQlZi|92uV6VDU`xx9Y~wFRQtc6J{O5b_fb6Q7vgFbI5c!bGs5-oWM2j%TGr;+
z+qB>IJ%uXQmcJ^G7$+p__MOV|))8+IEaU0EaIAFwBHzC+8c~zQ%c?6o78(+c{83()
zYew-zU@%<OsL0pwpW58A#;NdCIxrqzRaj)}lIzhw6LZB=eBm(h=Bu`@@}wwJmGA*P
zy%(ZtUZw2pt9yuKfhYAc5b0#$?5ur7DFblHib2@-91_iXxJRltsNr&>FQUT1p3c}$
zJ8sKPSypCi{<)>k)s%E^J;y+aKP9Vi*M6Dl2X3vg4^>?Eq>eU6km{3&sn(iRq2;1=
z9jsO%LhB9+`RpwUm&;ikGSv;@K*9U@h=|MU$AyawaIK>p-!lwk@WKM;9}p2&4w}he
zjcuP#xH;VdR?N&(fWffo#+_*B?GXzSiDm3A12fkK>Wak0LN)skGk7xpHev>OS}+{4
zLwn5!pB!#T1PSF@sQ(q`@NRZrPt|lpJ(ed0gW-yuvE2q0o&{00V_st}0Cm_HM~@mx
z=-H!qow>ZQT5TZb)+5h|jVDhD2K85Bzg;Zw-bi9|%<ImDkoFYeM&R&5)EHTtV+8c|
zw@BLFm+SSl7@&k*iO3)=b<Fem%Q26MZ&!3BeikYY)gH*#RlHS`_;%&2+YM0jE02e^
zAVh^x%7L1HNZct<`uGY1M}9^eGb$B+cib3}csW!SzM7agh=}P*`O*CkKmu-yX8Yf-
zk%jPCyyp{P%FrBCTL13!vA+_|h1ZY^a7hVJ=LUCHQlPBRYk}G=Q0nQY?FqdOPX#7G
z;b;<1pT#+)&Ag8b#_T3C8=e{rz<u|P$laxjlESSju~!VHL`9@7E(9krm~YV)5#K&s
zs+{Hx)FxRhZveqje7h`9wEX4OUi_C&c>-{Q%O&?qZrUVciqsAZR+J|;Hm#jH_G!CQ
zb&HnwjIwv&iTu8#_m;IcIRI!@Q(VKWkkjA|3?Q4R@7d-pu;igd);%)y53qL8-ajCM
z8J2~JG_qEq1^U~#@CmFG-TVu^67>_n8K1BEQ(JL>%SzG_SM!*eo_x1ea}j{Z%FYc$
zGU2WLb$opam$jodajA!0F05|8-&)V=+;P1GSb#19UB9&G7zHeoU55pYiK8`Os%CR1
zMaJw}Hwv(@49M=lF#&P$@vzpsk477%CM0;;35C;GhW3VgwQZe$f`bn#jRvth&NoIJ
z?H2(2#-Czmo<t1I0S~ae5AF5q^o;M=&&a6lH9gF#_r5vlYc2bQ(X+Wumq=!p?Ea-?
z6m|4mhKuW45dBKqJjcbGU*^zCBrsequkBXuTxrc)TG$6XE}!XIMojs61FWM=_3OEu
zP5}35sZ@nF%4UU-q@+xiMp4D*avSlJ`}gix%6MPPAtmyhtWc7&4VURCDbf91=kmWl
zp%xsM<_Y4cNRws^Ni#T+8Z4LO2?3C2_@E-UYv-@F&+<tMx8*8!;WnfLXaub^H9vFf
zTSOS)3BiEedOC1-;E9deNeFbhbmg&`4jfDq`!v&-(xo#sv!o<4)o4?`*i7vt1hAzU
z92}^Molpgmjic6uKUt|C-JwrwV&ZsWFvAo?<@b2cqnjxMvw5w>=@+-}?jbxHPX&hK
zbSNN|XtDb;5uJF=y-Zv<GKGi7DpI|DUS#-6zd;9c$0e~-)nsL^*xLk+dCD*tHX#DR
za8xDjIsGLd7%rE_ST(_jsyIyK@#fiezPHL<3Xf&f@XuqQn~2dmkta?XxsosgPZ5S@
zfbk-_GF~)8(FS7zwW?xdu)8A6%!Qzm2reFmi>^IB-iF@uWZqEAt101wCk=x^BRZbf
zYp30n>rdYm2>D7m-<-u=8D=_)rOoOdKHhv?Y;8}4Q;i0%O9~xZuj~CML+gDJ`smdC
zC#mX{*<usarZ0BxGlJ&4PGHegfvHB5o8yQC!@~;QfM~BT%|4Uu5H&(ps0KWJ$vs><
zX9k7HVl*OZt}WlNQLm|QW`$%xv?o=E_jaF1jgUoR#Pf-l$lo_d<Q!m?CKUckZ|;x3
z@cb#TS4*%L&wIIt7$r{-hNIN%`0w!^oe5{alY>QD;uN1G1f4<d>lgGlwjzUhVlXc(
zAsMa{b5HMN1i;cQI>dGKG6pbp-gG#o`6MDz@?K*!VW|re2X7ZnATkBslZ;+mW3kHQ
zrr@C0tq>I_PH~3rqA=mJ8jJUO(rFjhUv17<(ps=8DwCvG_k(3?^V`L4w->kT5m*If
z@)SY!&XOy3)f`AIS|(W$RJKTvyW%xde;s8l0)?^Cjk+_I+ROjby5%YhRxtrj0A{QK
zBY@dV`(1~Wm53~ir~fi=V*<R_SbY2!Quxj1sVWlj++7AHnP!Tysbbfo+=n(2Q^-?;
z8H1-bDd~%qJ5TT}TzXx<?m^U;^<WeC`}$Yfp#$`#mn*{s75YNjCU4X83vW}9%ovNW
z_SmV`zTeq+B1Pi$_KNl@*7V%#;}5nECL9A#_=UjsZ7MFW_x`T^w^g-PS;6EmiphMm
z%@}fv^*QQ&09PTfw5cnB!7bP(YV+E>`m-GHdVp)q+MofB6Bbly8*08Gx2qECl&AHI
zHoMqruNB=-)mB$}!B|~4z2;b*dgI<Yd9xt8N&G2u#cT2vP1F*OObr@Nu%9RK5`bj=
zc=^BMj%g=u@cm4l;@$&Z!Zz;LkS@1;pM%G!amy9v*Ad_!pd!S;=<Ab-+8a;vWtans
zZ{k{zR_;ZveX$|A9yNc=AgnvYTH6Zhw_m`}O!5LC*a5<@!V2VXue-7JEDxseS0*6-
z`3u=?X*`M5LRqhzwXzTnjHmtr`@(SbB;>~B28$_B*Xor)HU!muc+}DE`g5$2!94w!
zF;Z}0ngM>C)3^|kg78{?8L%WDZWP?}8Nml$+b=J!wtEQbJFvU84itaGYyRbhC3X)#
zyl%f!JJ|*Ea`_8$79;jNREZ+E?=ZcmFM!MC>)$y5ICXCRx?=NdM5y3(0s~{vhaL6j
z?OH^w2rh#SRNpEPQuyAY{*SDrRH3l+H2x?oZp2~r*{KuW<cvA>{>G8P%3-%(6FZ&I
z?0&m^VPYBc^k2^J+vk}dbU?d=3!`O*V|ymDdd!-Zgu~&9zM?_GN@)SN9xl3v0%a!5
z_>7b8Z^x#s)Pe$K#$h~!(S6w3JtM0VL5wH(g3s5S;`Z71=TfuI<SV*y>I!Gv8<7hv
z1}M&pC-)NL#FI2Lm_ut4B}QT_&zZ00|0sASadFgeFpQZV)LHcq{QjQ5GFV1Y_$$%<
z^Vg_aX;r2T@9k@c<qP~NHsQ&@ESnhT1@>Lfm4$h863c=o2m@$stl=3KuOmDoPYxyk
zX|2GFd1(SH%c?eDR<6vm7;U(7&!t&HaE&JdGlpyJPGy1VgRcth!8nNvO&zN%fsF#w
zL1-4aruo4`Wy>}4UQ)t2GJBC+y4!)+`SFBcFk-6V;O^DaJ|}`CuOFC+sqfN;&r7|4
z8mWwCe#4Du3uxc@o&WN)delfI!~A2y;R~=<Ma8h&W!m>%ah=qF$y5|si@3A~Oo;aE
zkPU;cb+LFLJ%OU-aQ6h%UZ?$>4?64LAL6b7L(diMqy~Ptt9oC(oD#y5e?c!_Lbm(m
zhl9k17Z<MNKnSl97(&`T)rqePCF-6kgs1O9KqDcLES<OO_Z>Jxm@2CybdBADrR$B0
zn#B9Do~EA>@~#k`ybA`3_0={+TJXosR=cbfrH+@EeH*w`DJetWy!w4^crTC_$Wd7e
zyMApGay)QBgzi{Fc-_Ci3gWt>N-B)rD}Q;bi5>((c)BhN)N)kDN<jLTn322=3m+&@
zRJiKPf8?u;|EI-KKvO)sY;xjM?1>Z~Z_IV-$opYiZD*F3)4fH+t`Nl;_;Xrd3!}1R
ze_cBv<@xdYaaIUV$OYEWGtYN&r5kA-nk!3;*XheZ#L5z}b$mLqaeHF%@>E<VGL<gQ
zcz*Lw3fGmy!XFA70NH#KIb3OJ;%ogv+153LTew=Laj(al8TBev2=7fsv;b^yfoOOV
z55)v)#L}G|YH>X?as#cQ&YdfbO?OrspTpLllI-+WQzGDo@SbNhhpiWCuH2e8Nl(K=
zLU>`^Fovae@IG%P3H@Do&VFbIbnObE<<8L|_<9NLIoafd{xbO7%jc#O!I!7uGHsz>
zS*^5l!7#$9x$C&Br6!6AKGl3&!Hw%I4k4J~F5xm^op$?!I?dFZQ^Q-WyhPl*3JZ(b
z?%OlYE!$L=B!uu<d4X|_@GkS@PAy|cP?N=FFs<{P@%|gRsmbC7;RGT4)i%?On{Ak;
zr^+Eb%@%$<6cX$P*qWtOlwPe1;pw#mrgclv%P?u(xp~{1Me!m26mP>*ZJFT4j@0sG
z1~!J{<UI}gS@lbWy>fv$uop9Xs43vuBI_zK**Bacd^%6Lg=5yHEjGF2ND5JA4*mnX
zzJ0FqL$@acYk5K~93w;t*)B~+hgX>^6}3E~GG9!c*7~NnCq3a!b|r59_0>i1Sj1Lw
zUE{AAbp&pDO-!+Ocv2?)C@O@h$ui8~?Ey*Yso%`7Vi09#Hjj;Rv$i6Vn;#*x6(PJQ
z8*%<{d#*djKZ|w<CK59bZ!7KZ@@}3-M<-ikQzwuciOI{m$l_!9qFPv<Qem-N82(wD
zK+CA(s^q(5p(?{=O1K==m&-ckiKk$>M0U7kJ1_s%bQG*iMEv^)16I3bd*{IL4#b@C
zR9tPm@6qYY?9$Q8%_(3xX@16wz`zRf;kfFv5)V*@U<G3U7Ow*6<NdtUpsLh(Su93a
zD2j-(zC9T^e1FjpYP_z=G$JA}7y?>e*kPB3Hfc|dmqlX}*66BZD{HTr`TiLSn8jif
zSTh8&`2A{qS6YroVX>Sy7Z#f`YCX_pDt>%8F=C#q%N#NJ_~ERFF>evIES|2bO+XM)
z%evOH-QPr*=V`eB(l^Dy<UIGwQaLC@ndA5+8lmVdH~LZm3Xw@&n*tZd`0(?eqKE{V
zC)*NxYU+~PuTS#MA(-Xfzsq12rg-8lR2u=ZzI$r{QEuX?w~WDBb$prRKF(aN9tFyz
zD~=VKpV~%xG{wKAh|Gi6u*(=J?EifUg-q>JsoMjKPzqC}D`YSg%8pvy;(FgQ%ZaTC
zPr=nj)bX^v>CRuW6Q@ogJpC3`8+|AL%-@Ms#glFcKvG%syu*9hh`Hh^w@g^OQU|Hk
zul1|~1hseqE-$WqW#zm3Spm$<@u%cQJpGn|YQ7m`E?Sx9k4;@F7M&`xL4}s9%fVk^
znm@X6?bMTJw6+yRPi!Ad97u=oR9i4wZK3waS7sr>R^AJZ0uUm%{nTO4AB9R&D}WhT
z4fzNZTGdPd*_!o@C+`w$mHCA~wu*LgB0tuQFsox#sy@NfYMIIr@LTF|alvk`J5X<9
z9~r`H)#WTm$=x*bzq-UDgs0bPqq){Gv%^GJZQCm4>9hcjj4VI&%=!_rtau_V1f^a|
zy0@%S8o~kaBw7dxEqL_uea~Dy_7SNMPoIUT`ue|jERoPYhVWEb0I6+|7sYj=2*uN5
z2|!vOa4^l^{RyJ-x^hWelTe1|L!vJ4{&@u?Dki~7Sd}S&15u4qa&z-+DAh^B{Yj77
z{&DLsaam#1Qaq}=7R&Ic&;kCEb!}HBEZHU=y+VXRo)XJ20@cm6&R2EbC2Y%6Vi~Zo
zUVT#*^eQ8lUnhjoAv{SI;A-CQw|aBNQ{T@_f&q|Z>#C*Ij}UC-_26pbbn&%R+vBr|
z#EPfLGElX|Dj=ZUYYJ1w6^A%&WY?tRqWabYnW?Xr6!4F!-_OOlZ<%361ck~BtVF>D
z+4^IK%DIWKDnT9CDoV#fi-%!V_gd%HHGWFim8Zah9`)h`*R~Nz@y4lXL<yZIy#mZ0
zalNf3AI0tQ`loUKqr5Cnh1IiHGSnfJF-x!2H!A9KVenY^@`mEI+?#Tt*TScB4jyS-
zyKG?H71)Kj{;~3Po30sp!k!tfTlmdR;-r+P$ubA;&p0biN6)A5Wl_V=g4Xdh61KUK
z^i~=$5dKsnxhBiHLrbhWaWxUq8Nw`ZWpEBalpZoIO#eAX4E(91bEmTjX-|=FZ?0W{
z8lxnglQ~U5-$Vv!+^t80KP^b9$C6c3WHEx;^cY12jUm+dObG)1yu9X{Rs@q#TsgRP
z@e6pQM0D&Kaq41SYn;-Sp$s*a_32s&YnIe8i#|P}3@MfgY3vFmWvicPnhHN1-J&{1
zX-$XeIV|3+MwwIEM*U|**%O$ECt1G5Sc}*yu4@TP#eII!4qN@vr6E?nrNX*~a22*>
z%|*-XUS;9ew}`vMp$u7;VOXr@=#OYVpYY2T-Is(iUSyQ0AY{OPW*{im9YC*n+s5f(
zGL#|ClK6U7pLPF^*Sh>7lp)TNsN(qs_$L&j>>i<G@wa>70>qy>hg^>!t~}ydf^YQ<
ziTv!_COPzaw4#+@5?R}q)X#h;nJ_d%qh*+czNUHP*oY2#LK@1DXc?#u_a6thP5eSH
z_J%TaS_Z7;aiy0Sa3}pw1e@LUStjjZpA&n+x)d*AyD$H`5e3U-vw+o)hp&BI<_A4>
z3T3><=>2|>@x$!^;GBK&PCVLuynb;zl%dm7v2pcMeBN7i_9xUbb5GDEIwYvJRPuhs
z>zAnYz>VovF-=Zfi#dO%#EG*}*j=Dyt%qT;W1{x?IANsk^c|ae5OG+>BLDP-#GH)7
z&ztQ#Xu&EDM~UwaF%EZp*p?jr2jzdwDg5>K8zU%O_hVs+OI;|OJL#LV6t1*``*;CY
zOCC~WKEIlXMhtD19ItglPwcS7I+LrSOJqnKa>MsxL#Vq(%UTuCfi%+$XbU!P;nJ|F
z_9mqN`#nno++5&KokjP&+#J2x|IpeM8LjSYR9TcF$4UGk+rnlv-?IKlVp1~QuKfMW
z$Cp`~Pj&okZd11caj*RDwci>LE{UP!GREAwqd8)Dc}zb<|Im~8f?AB+XiW(Pk?X&f
zUl2)zYMCFpaNW$gtym?iT*+_Mzeo(2q2n^l;dDJR&B7Jm=nBM8Mhh+j*Y1@YZ24|4
z5&RiiE)x%PE8iCaa5WU{ace5E8r-E^rnAFVkk$=0-MH@zSQ|kN+BIT((Um@7a?Z{*
z$bO25Pz*trX$#Fa|8x2GDMSvyc$CqL2!_DN+jS#s4;(y{8ZDQ}x@R8$)94>`L0c$8
zz-5jW{s$dA6Z_ycLAqvX;8V-r>tL}>aXua{i|OYbkjI7M3!ku37G>`&7lad!Lxco|
zF4tcPtMEU<S2A>5hCNVrW<1+!^Y1GjJ$Om1Uq(kR0~p)$5eHx?8V<Qn!Ez%u(WMZ%
zJow6~Unp4VB>g7>0#<kFjp_|;O~J}JbB84&#oorBza$(lqaBxFTfDnK-4)9J+pqd7
z&XJ++4Y^F8LllG2xML38Tub=#FcynT>Nn8N79RB@g~!UW0nZ*ELUxUeBfLx)i?WF4
z;}emplgjq<)}s`v$^^=Vs`}32$764{*H1q~88R)Ha(M9wWfeZd#EJPb-9O*!)$~w?
zM9Ty%S5Dgk?bzDcdxcZ+e+-S5iAlZDRxhx8Me6HW^u({H9=51ie(q)pltoSi6;CzW
z+}`!~X00F?&k$>wpAS`2?}CyEf5)fIWAR_UGXGF_wU$Wun+7*ov(dOGX_W?Kz}i;o
z?TJMEW+=AI5o^a361&BjbFZwBr7i|0Q^nmw-K)Nn)c-bx%H*qYi_fR)6ms_4t((qS
zPF3NoJS_0bS;r*#PN6-Ii4q?}wk6Dqz2vQZ6lNWzZR;&C|B5e&bc3PbGT|L}QK7q<
z?A0|Pp$sXPK(;&CE&=(y*^9Ci7!oc6E&zRv=E1V1sBnT<ybJ-CiRx$Z79G@UF)n5N
zsUwzN+)wZZ(XlqzQ%iTYvsRc2D3_QUpjjiat$}8@UJW694nx6Z7y+cxRMXD_rxS`3
zG-K$vys#*c6oZwXY{H_>Y4KlpBT6-bD|ro1b`Z`l*MN>~-SsNn%PC4WWbn=pFMMbX
zSYfbCGn^R=2MVH~WfkD03wyu7tEa>&U<kPkD`>T$ubbZQNQ51Rgv$aXjz8usPp3b(
z85znDa4DeH{!32Q!@)J{<I2KSt4x-=kjtDb5XWTNRs~Ar4eO;&BW-%-S=171qEuLB
z<Q3`&Unw7EGhqQquZV1hq2&@b5dFaI?)9VYSB_C5Wm485AugS@T6SX7#SnABNCN}J
z>8j8N*@wHn%5tJLd?-WIC4r$uoE<hr=z`_cl6B=Q?h9bNAt31U0Y$b>uJO+Z>&#YR
zt4s}C*sABqRnFJWNto4L%4H4{tIyiy3tU+}-tIV*aIg$Hm+}2(S=(;b-t8`i5oTq`
zxeQp8H2Rno#~L{J*9nvnSgA71721NlI+Qw~#7b+v6w)$YRTQHQBJN7$DwRBd*myDY
zTm~f62W+A6!!{c|#MY3Z<uVZMhfw2xS$Uiqp^PbhLUth4L;m{qN^>bhx$a#MwSaQ|
zdA7fZv?7wpPCQRHj$V{VjRY-L|MhtEeTc0PRKhwC^mK5O6XG2KxVnGZe)@kTq1sl0
zN(=#)m>}cuUr()y)hY2W1<N`h5;p@#!QoreSA|iqtZI`13y<e%iQu?#t>4jagonDT
zw+u&xMu5yp1T1}bG`n{O53w8=sx7aD;r^>W=pN~RK2LZn#)FDpT+3z41f${IU2yz_
z>&qv>aBrf83C4-o;52b+5{Ulq`-pB|5D}ZF)PgjS-e(M2{d_fr%499n3Mk#};yp!L
zP^gk(etkg*t^!{!AaD1Etv+r|loV}A|BtjqTqn^MOuZVZ5OPP$Gk2_kN>`v9^f<Tz
zi2S1NL>?Bud-?A!7N`s;9-e3mXNqhEQ1d{w4*K%<@N`>&R*N4`sJ+S0{GVH9)As=$
zMjtJ){4GAorJo~bd=dP7^e^h?%ZYNBd}HYgMTXucCi#5jRJzCVFkVTthDp}S8us~~
z=)CLUiMGV%Qp}bXyJiMYZ)>ep)d;No+Q7A(irik5`E0Gw(AX`@4B9YNr1tpumcwnS
z6~OcX*49$4fUrR?&f&+~$LUIca|OU<uKl&t0E<*jQK;$#YyB%!m4VPNRn0P%<y7QY
zFVx&#pBSsVEXx|}q>uG$5}j^8)ZZ14^zc+!F#E<iy&eMJ4k~v;kFOq{EGsa;|1o{a
zw8=#01CP5x%Lv|1hu-n4BEHefZ63yRh=RBYO7ezbuwlMBHE}bHbEXi>U72Of*TFP#
zo}Bj3da&5k353JuDY76A=-~=SI;#1LvxEx>VX_r3OMzu=`+&zsqnZ<3Wpv9jtf{4J
zjXxiq*`k$dPgkxQvkrvP&tH+Q-3m3YYx!%1t}?-NrmL|_g8*xJ7U==MpV-P<%T`9q
z(_x8-jqX~<{d!2`c)|*b?9(A;Nh@H`)~2iLlS_|@HNfbRWla}xWp2jOrRj+^z!PDC
z5zJ9aAK3NJqfc>^$N|-=u4OBWQxjWe8fn*A&pxtU+`~t+s-Uh_W(73CHw+-FD#oP?
zwbqpi%M7eIU!tpnjaOB3rn#XXH+UHRv5bj=|N7i$kxRB?=0St?>YazDt%BKtemz<(
z<j|+}JK^-<Pc;IQw5C>|EH?SGXT+o4$>Z&kukcnTZ?3!rx21WRS<_2=M0i*w(e}$P
zhjQb{oU>aKlg86i!EFmsZxn=3t$?d+Q{L(S5dMIttg?`8wL!$aHn-~*$_~=J{_G$s
zj#Sr|^XKBJ(Yo?icrQT3Iv&V9?N<1!^W;Vpt}BHt+yrpqwl#)Uc$5@Cv^n(flvQY5
zED&m=y*1+3j?`#*@fJ}bmO=H|ZiQAwQtT((El*hmqtzM>r$5+!0|m%qF90Se&I@Dh
z;AQuSca@YEEB$d6&W9)k@zVT}JN2rlho_&yuhyMF?5-b!hza5;rvTEZk?FyEW`?Yr
zC|sFq_$L+OQg1J`XnkO$eg^Adbiu-yV2oGbVmVuxGNizi_>}DkN5FW{P-5%-WVY?N
z(~Uyq5*96?U*@?z<+uBkeR(0*u!HFSVY9&(>nhwPk|Umc3hWz#<z0gdGM8!oLE-^4
zfo<;@=DL{`X~!w3yk+-h9TIg$M89?TFJGC8$6ZOKphi6(Q?kIwnf86{iH3tGSwvF;
zuADL#^6F)R4+<rwB~}4XQYGw4sfy0l4WjZGo~Ft~RUH?yAluTwBqEvPX{rP!77Dej
zd(i1#vnc~`qihJd^~w}6W-&EbZj=>Qt$a(6XoFT|zsO6$$_3!xdpT%{T0|}WT0f5Q
zxC^Vy*lpGIWFmWGW$r}%0M5hHQ^90m`AIpCk-+PA_6?+fT`4PvDm;O<uSvJd(+M3H
zf-7mVdnYWDwNQ#o)yP|lGQ0uC+rJ+V`x5_!r5J^>(jPid77vh`0Vp(cPv59Y=xP1s
z`du{(2M{5LC#o`SEbi?<Ot*)e9aRRECCtoIRGHXHwO=~Np?jK&CX{Gu#mw%4Drx4}
zHL0~0tzoSr_7f|ZC#=HpYJMTMdD;DhU*L(V3`ES8Y+<a<s9kF*yK)JP$v4>5BAm4A
zJGU!c!r|KOD%Y8VXRz#=I<~J>o0O<;JX+Hi{f&(j?xHFMbyI*QeW@_A+UJxN*dzuk
zkmnvhH3<Kn@Q;kQ42?|5D5m;sp^?K~)79&2B{d3%<z~Tw!$R``Q)Zm}XiIGL=y$12
z2v1c7ON_efgi*rtV%^*N`M-xJt^!>9qRm!%-!Xz*JY5yyX<PgTl|G|r;4Y~$y*Tc^
zFg$3$Wf$JKMXW4Fe=K7GATaVvo2zaw78KO)IeB=xD#Hc{jMWrkliU9NCUYnYyRz4^
zhc@0R?RQ?cmaO7und&N0=K%Mm+u?Bf+BYc!bE%61CabE03RNIpaPu%)W|=bwwJ)1x
zk-C@PjhknA1ckbCxUSTtHoT2PGwrZY73(rZR$yHiEcyjobXdQ7z$b)pnG&nO0LObs
zcSo)j&vD?G)$ww7y$;K^?UcdqP-fuf&JLxz+!Ic(C)O@cWK||0s1#<8Fl~18ep@{C
z6@q0vr4``9^0G}>#j}?ZC`1--0a15g&DYe6q7Y@QafstcEJV~i!G>=)e?~+D#v6tP
zqCFa<{I*maH9}TJ3PuP66;?E|4CLtW3HL=a6kJLQM<t*GN6i!&o<|v-x{<n7#vnMo
zRkbTb!GNc+5~oV2+OW;{%HL;QC6Yo$mn>mRESW$ouqWH|?tPPo8Y+vO#!#VrY#VC2
zr`zuk+~motEKogi?+wbGWK|#(Pr?&c!6@+-rfsBS{<xe-9D49HRR~F>EN6p85Z9VK
z?vg5lMyS=*zx~nnatYKtF}WE+9wr?;b|sDil@ZD>;Sp3HY2lxvGEgR!lyU*J-DyLX
zcF1vcoHg@OQ6&o+NK!;~QdIf4V+0)0<B<2^aY=inXzW0HkyXPt)9<Q0Ez)e6ZqG2D
zpbA$Lb)jw6fCJAdP$?*Ju_u6Pj(OZ~8yo7A6vh)%iIG|rO<5kPeDG`!3X>I)5z~8F
zMPdeikTH(JlvD5b<FV%Cv!g=qoIY#1z4#aKC*4RGPfA7A-%IZO=||l&hw)lp8HIPk
zGY{JlK3&g5!gvj@3{*1N?b>bH6zcPtq}PLd`cWy5Py=NW9su?I6ms<KZQUwbQAFXW
zT=#xCiaTGqiI8Q5H3u$rL05v5Qf8m2qiRMq@Xk0O!%u_(cq%HGDKLOiSCNbVUff$@
z6fQG1Bd(@TMFLb?pJKD#f+372pn~zjjmSDZ<2&{%h0kG?g%>aF$!^<}zjoHoyTf==
zD*OYEcOu`*TRu`3mW8>is*KpG3d{5gcePIU+gl4xT^h`c+NmVcv(Cw?6f84zJL%O@
z9vWLh*Q<r`6jqR8D2XsGiXJEOCShug+)zK>mBpgm)(rG&s#*>Co3`<wZPs@y{FSTM
znZM$JOO?Np6oVVz|C0!ZJY^MpHkk-@nvi$Am0u_y&y!Uls9wcxRJh|egq!6ls;CTb
z?y{P%sSjs{S4di5Q(@24fBgKNaTF*sz8awRq<X=clSGS<uuxW^S$sMqLVBDj71X*F
z;SPBXs|;8Sh+5t5MV~uCgty{JstjBQNmZp!A0MIC05jBDX`2jQJ$FwogwutzQr9V)
zq?5k03hf4?kf$x5JxU~aD%X`OPbno;zT838iP_>QslcibydWvEW=oo2_ebky5+-oh
zQdxd#a=HPF?Hl%-M;4yekF&yfGAd)Ruoa>UYwJc7yiZV!*QLt9){o9p*C;}CPYhF}
zG=B49yub^lwa4uTO=qnk5?NkvsxnRm=2gQBHz9I(o{Gvq)pGc1Pal6vjg%QvO<|$^
z`zOaOEJmR+`HHBxH?-9l8b_ujdT@mC8d8-pU#i!3uoDX(NNa^GCAvz-?T@v1*IuiI
z)E+u@h+eD<Q#QqZ)>M!#A4_pHQzpGw7siuO0iMNu8T*?(Oo*irWlG_HgfKa_xp{Z$
zvsC}5>^cLaDwZ`FSp+4hAP7rlVF}A-B#KCooP*>bOIo4?F(5&*WQh+YN{|c!62(B4
z%oRmJKmh|HiUh&e)o0FhPxm)-YJPC<d-un;HP!W1Rd;`<8X>CW=YeSLtT#`X@-E1G
zJi(Ogd!$CdvUJqHRlvJmalDaJ4z6AP*Vnk(-c9{lJ>kupazN!y)9~tr;)AjySQb0|
zu$F5NcfC3b!LsP-z^WagimDa&dzY|pKH|JJQ&giISh3AAPUxwy_WN_j-)`pDD5}~Z
zZ;D!BF!Sq_cEATb&6Hy-s@64H4ISy4ss#d1G$mAnjvtIL_-5^g;Pd)8o@&YgwR6CG
zyFcrVEM+nlpIH_=U9=xa{P8NAhD-zCJ5btEjrz1o9fYa^zylSY-@JM_wKXWGJi!!s
zRiK(3`v-Bkaw1G7Vc{{`g6%J%7A2m^Rw);=i|NApoq;wt&RZ(wkkuJICH`;y>r&!s
zhtnrUxND_xRc-yfxT<<pm06zstwT=w|LC8_DxOLTy_R(@_k-@>_=6{nl7LiPoU6}(
zj)KB<;Q4uFL2B`qM>(z)RHdfE%2-Eluh|L+%acbrHruk~Ap;t&167u%ka9pZsfF5I
z{5huXPZS2^2YtmnDJypu&FP!qakfHi$hc!Kpg2&`6*3XnTj99}u781kK9jF>GAK4z
z_MP(n7B{63k+Aij&*ZElVKS5u6k4f&zx^7r*K^<M3oZGbsj*=p)-L%yZw1f<D>rzs
z))vW)iOP7(%>$YTc)BPNSk4!*<`&?>?2Bo^SshOmWy|Mp?K_?q8OiK}Q*ehFm44O=
zKvbSEN*GD(w|cfqTUu2@pv=muzeK25IxTkU4k}j!tS=IirP{Z(3bV|f4mYU_r2j?7
z^yH|+`~%HsDB7mS|Ejm$n6>pu@8)$tZRM$<$gQAWKdM(e5qXu#Q~b$py@!?Rf-J>T
zK?y?xGC#3%?3)=5yN$J0Q<agS*eP-pZBpg@3fWhxr79i!Rauavy%kWtr4keD8o7fT
z6l&WhM{^@ob>9>uNh?(UyC3AnG-)XF-OP7rDWEEE#FTU@-3^)jTA?`~KMR(M@m`?Z
zve-18Q6PQ}sQo<IlQ2`j%9BuIr5=29Wi<VIqn>!Ho_s#dFn#!NTf#f$m8I#Cv7S_Q
zstNrk64vcacW(_^DpgH_1b_o8&(v&P-L>gW54a@I@(ND^RYsnv#aJJ}Qe@?sToAm|
z6UUo6RmRr@1{|yrXFFHCzt8op##vRUJvocEmy;jl_z1)+PY@;aAl9de(Jj_2bPK=c
zRh}4%0L7XayVd(uYdiuy3ge|f5l;eAZUX5>)WAKHq58mlf&=tVH<h(v6}aBlt;N2`
zFan%j^K?<-FKD--0r5alw)AkLSHPhlPaq|*&CC_iFyDvZz>O!4BD{bqLl#b1HS#Gy
zTi(1W2a!4#W7S?QHQ^SrQx&fe$$(I;_{w&+N?T;7qLwG3$g%nb9`W_5CI9(9sa47-
z)d&$?2{))RDsYQUkX^1+_3L<43eZlNLZyHd=X(Rgn`Q5et>k7E#esO9Fp9iMS1W;*
z($fFe>FjO<>shiXWBXu5K$+e8-TwK(g<w2S93^1!3ld~-roUdTZ|9i!^4wfNB5O)9
zrp1fD>o5~Jg4JaUi-U-vXZ^F`8M}7H^OREM+%c)t$r<smBDHU8WG}0N3t-=QqX~Qe
z{KZKKmQ}$8tcV41kZI+>O_}SJv~xi`?~%ZA=E*R{LCF)%AJ|znzC0@z2t+dr?7dpk
zzsu4nt9al+S<wzz`6}wxtcBoLdkdwAT*5~C==Q~#8IB@EWoC#BNQjn=gEA$K2Y%$u
znG%R8MqK6`{i>XXNLFfjil>YsJj=pP6BdBEnDIO*lzfQ+Y9Vrc^L0UxNO(FZ2Ugr!
z*h^Ht=m%grXgqJil!Gh2ptrp6P0!}->^*QiZ^V?))*$8jl{cG}xA(yDJpB`4%40wy
z0G^$lwA$8!#CyN?=L9{0g6~zRs{Zlk*;m{qO{1tfvI$91QKY2QTzv3tpV|$Ms(Ao-
zf+vY0PoNh+E=(Gh-)>jpd6KAdkwL!pUfpaM7&#fwQ$-2X0RuV>Yn!4U-cvfwQSW^)
z7%-kUXi8iOT0P~1j{Vc3AJ3|%5>T#|5nTWEDG28I$MbYi4k|bc7!j2T%*Bl7$)eDG
z=<Rbi!Ladoo*qg9(z%WC+fTl+Wf@3Vyy;RtP<3LhPHl?){;(RY6k%%_yMkvWl_v}>
zYp0*yrj2{T;Ghy&54U)&3!zdop^;U!X+g+JUj;Qk5GTG0YLwCXDrn@l8OMO`gr|sd
zT%gWa)Ctp~CpSa@&w2}@oRlS!HC7)l?N&oRmu+~Kr-^dRrD(NkLD6d8J&o*D&JEcG
zI4A62GqCi?d&Lkgm$S|tgWapXI5lM@$OSx6l<)(-5g6R|hZV?LW(Vv;wXLn(?w3v|
z$e1l~Fb#8#0q0&ou&nKHIp=F}un%a_{`zYBUL>9;jS9THA==hzcLdCG)Nb*E&{pgx
zWC@HC<<%|*?Vc->0|Wq17bT38w=EV8wlsRV04Ul#brhkhY^ZWUx#iPQ>W))gMo4ZE
zsQvr*js5F)WGR!dat4}JVfQaM6^lTbY{fSiwO;uP44jPTX{3ZtEi1Qwe`GYWlF3rq
zPufRIrINdW(WvpfaZ<ucE0m_ZHFFfmCElZ?oC-kysYz{BG?jXK*(yMKo-j%pN<DUf
zxx~^^N$s9>VYT8KcxFXRHO{O8Sn5Mnjlhr<+4s=4jgYlQKs&Yy68cUfaA34G*Jaq^
z-C%-eJWmtl{CxEGz`b2x%mnF#r-~A=_N)PFf%lFn^CUuLk~D}Q_M5nY(Fm2v(jdo5
z!z(@Y9oV(=p6II-c=|!VJ^IzXGr+k5PZ1^XY~EK-*LXidWK~f@3<!F%al`G-*WIAk
z!;@7&D~Uat(CyIkb4FWzK1b^fAVKluPy}m^A0mRzZZrOXyXqQ2RniMpMxAH8Y?nrz
z>|PjH%F{xTrBVuS{QM?=cfXE6Stm*aD)?k2{aKwh=A^tr|Fosz>7WR-s_b{f^TesW
z412S+zflO;%VH@(qr;V#;``2XmrJ*oMbb)grw-cbl<}WcMyM)H2g#>YP6VplsRz9A
zNHi!~>CAciA}~Hd#a2jEyE(b|dI@x3<vk_JF;f6ig|=cKPtN$u_Q;)h-qU+B>x(ET
z+_}?$!YB+LoGc68LyzZ;igM7+b0Fev_YCzayV0fbRwXSD-lCh^I;~%v02Yj=hf-g0
zsXD!NT7Nmi+o;ptQYfm^>l=#=`}x36m?*5id}ez;kX?CGqNJ7ZH1J`%{o`DRYRuv(
zqFh+#j9EFLT-Fb|QE1Vdq&lc4UHuNY6EU~i$+{mVCGROIPOAf7_AC5!o4v>rOxn_E
zK<WTHajnnvLNsVG6S=$%wz-b!+{fPw>dsIx8!{gR+pd;aUh_KGSMr|W6Y~;`wB5bf
zQt-f6JWm-V;HY?a@6>ysQ@x!~Ai|cIJGwY67I{`9tm+AZ5SEUaTGoyg$4tjhraNJN
z%r+o;>pOt5-ts6XCECd_du$?j{5hUC8cL3|5INR75L`C<(kT$AJYkdriaLV4cV=uu
zu*?c8e!R#8_7VH2G<CuAp7A_=lw&QrZfN-Tl1sLpJKkF#<zFgMW?mi8t=k|`W=s$F
ze3ZGi{qS)-?<qdV=BknOQhi0Inj56(H*oTyydrSvpGMszCUwcvRb@*n@MWbm@C(){
zaT0~GVn@i-AUtFMo|tnZ6UgQ~!IbcaNR77sqSn1{E4XcvMqzdQ9E8GhGwTyeSeBOD
z)pIQf3!Yrcv9u~3<Ot7pPfa!4FnQOV!|p|twr)J>lnYLYSD>4T^4N-9>0EE<*sSv>
zfi3p7!p%{J#Xl$P0+X-edE=xiMUpTNXwsLDZjp#=^{m4V_rNtDbs_~$KMCHzjpym5
zgst=msrmbJ&3-i>vXohTgY3c&p052HiUTHpT~unHtpIMgrQtrn-DDnj#m97JF3UON
z&O=-87oV(n7AhGCz`&gY72jFq*1YMa1Eri&J|*H3sBsEaNIu5l+-&FzMUYw3P1{ji
zq(l0rl7Y6x4W112XV9Y}JN4}v**CRsH{XO6^zMAF&Sf^)E>7S{s)YHL_Tj}*vzFN|
zPT;-UCjqTpRMbxy{zj0zbU-#*k(H*v)@1vFK7ps85>|>t5acMO@w&EP=yC$@;XWU-
z=tzv*b)rO*X*PEgcoHffs{Q%Xv7TK9+QO^^-oz;%s?dLk;x5fqo0HoQ`;?*0NnlY=
z@E$rPHzymKmp>lce0}B_Eh6fs+`CuT>`X^=ZE@e;MI`WqRKo0Fr(k_IWW8-SeF;1{
zmBgj<?|@h%I{#evQWMu)jn3+DDHxrdQw86H_7*EPmdX#NEF|!RRnl6qbk@<*%}iJR
z&+Zu#ctfZpYE`Gr6J^~3Z##HWZ{T2_&Psw)Mzdi57uS6{2xFeyO2GQ$Aog3KQx?BI
z$v(eL;Hj<zaA38dx<2l|Cg7#S1fJl^L5wV3+;+kJh9fG0{J;}j`EcE?RMGfApIwV-
zy(oHBAC};)xAM_gzHOS>x)Hg*<b#SXA#_-7StnkgL#E4L-2lUJ6L_jCa)L$O@2ci%
z<65dwR}~%(b?xd?ZPat%S*!$}(#kQ^*h5fkWqo@xcriDDC$;jSqTS`cf49!!Izd}5
zp4dv@20L9z{O7w2_Wex)Pi`e}%^JCP@vKJ3PF^Q2@PbtIYgevKvQ>u(JiQg!363o$
zk7^c&Fje0ex)G%h8qMamfB(y^Kn~yuuB4svw$bQ3Y7L4!1quRBaV1f!(!sbW2jHWY
z&Cy$nA(OfNINjd|p0ZHE{U+T<L)|i?u~wbkgl4VSPK)dkkPC=j|J#`7G$;l<-4!{)
zs^A%ywtg7|EKhRfAi`o$^UF3D?IV>0p5)4hD>nY(ph9fT#U+dxXj{&WAB{Yr9PAOi
zmT&Wy=}-cBf=yjvD>`p$8C_HMphh3c6J3!f1g<(6>zeYKL5{PPHnwpiO-qfunN)<2
zPb#LpRQg-6JBj7(sVj&0a%6YG)~U!~Zs`qjTrs_Tw|WSc%VVh<2t2VNB2O$c!aqe{
zBeIGL4<fsAXJgf}X6sP{Sj$sliB)sYEDYH61HLMRU{#|ZnidYMb!_u=w=tu^?w2RV
zvL^~rD!b7=R|MGf^IrNRNHZf`x^uJ>vQe#6h@Vb?fvp$WxOGGSp~yzo4HQ8-?SX1$
z@0472pO%O6jK)>(Ayu-O-9mfPjE(PoV{S%s=X#+LsE<4umavmf5~_+VDXfow&o6n;
zzCTXjNwWOlB5zS9x3ccAKKrgBbQWv<=;CNtpu1Zgbt~1k`&RjOH6=2QylVY|koT0_
zH8hd(=i}*4IsR75IO@wIQUPNuBTt~UUM^#EFk7W+WE}XcGJ&Vk^7%q^4Ms{>+AV%J
z=x=x;ErBZE8nD)F`-hvJK&Y(xD^bxFGVQ~)JwW=>WUrw)EWfU?d3>|~(MiZy6$f6h
zXf)iSe=<fOR962iU0_NIDd#M#zPb)_0jur`RQg&4ToGIxJo8%w%PP7)SkXO38NpS3
z=GIT``P&IR(UySik~&zlAM)@cTHc`Pe}Kww@|>><yLM{~Rz42GVEK5BJkOV%v|;vz
z?-QQ_-KloG9XcQ!vz?jY=tR5X%EwEA?vyv&O1Q<%WK?{d;TtWFEF6vy)iFS5i)~W;
z{%@8`px@;UvmzTsUn;}^)=AjrLH~XP8b{tdD}@Ubf@x0AlfzPobXxUH;L?~Z76U$H
zEU09@biu6U^#4&6(ot221@Ww}Cf82i<W9$vbqmE58)GV1Ug*)KUO@p%|8!_Bm({!k
zA48<_LZ=92jCa4^nGDV_cmglsaK|Ak)ROBq*$46(Ptrwr;;g|9U{#9SH=nVadK99a
zMr7rRAVhXbaSPG;oS`Q?Bg}7{$OAY3o4c1nnGRqzKYJ^?d`oyhJU~1?`HPiiolpB*
z<A3O0%?LQAz-vo$fonHw9ltvE7C3g{3B06x?dPI<Z%-WnvI9@uMVQvPK;e1APlEGo
z-V1;ZA}R3$4@PLMKAy1QdysZ`F97<0<tJH2N>BUUqr%7qo;0TYHQ`z<&Yg*G4MCQw
zkPVU;6ry!BL>_p4RnZ;pZLJ=y+)_*%cI(6bYrS#<*<b=s*F`^HfC|#;xrNGa<<DP=
za&v*kT4ibw*2?lLjt8UA$D_j*9`6h)1W(l^Yz;n?V(O)5in!f^=31V-OCSf)SHwNG
zpa<Bb@C050mXt?+fsj=&yH-E?KV&qwl@4+g(7Q_K9SD}Y9}aR9aB%9?>wsrGomUk!
zLE_oeGs{8!;)%NiqInR|w0osjkcBMX3Ou)Vsft)7{l||ZL`8!TnSc<j-15@4PfnxX
z%-Z$}M7?GcPYZS}+riB#8c!9RCr`z>yOB{dzSbcF_|-h=7TIVOl^(f{HA9H3(<wr<
z{Mh5m6{+s;)(Fp=bX7$je7Jf})e&ylTjnid4kdpb)RU01ooGtJ0U>6!KAO(^!tKkT
zr1EB4Ikt*i0{Y@EyI#I)t0NP5LM;c_J!+Q%Od}5J+<p0NaJs~sbLEGZCp4Y9b~V7O
zrHOpnEik&TnPin4e!I!|sPiTNC@CG4Nm$=Z9>dgcf5>zXxml4cWEP;0X=MK{PO4-(
zufY?A@4VkLmmA7T#HIW|45mK-MO-2<j7>j5=DK)ty;}lQR?ymFPFAouw{u5}?zY-4
zktf%xBF>Zi9~Ier&Rw_tyLNM&$Wv}rk%u2vYm_-nV=xCdkv9X&!4wHx?~JI68~^UQ
zqIP$f$Ww0#RA>B0;Ph_7Ew}Kw_w6(1M4oo5ihtv!idXT2@x$G?Qd~&n$+je**fg6p
z_Heqk7i=yh@>E+6Xw^vPOjvzQplp8O?xe4f6BHXlQq8WnCEov|CR#0KLZFiar;n4Q
zRi)x$$FHUn7brjK&h^X*PN@)|0F56O6*0EjYs=?mc}DyGh1mOC+dmTBHd$k@Dwd(y
zOQ&_R`?d%?KeFPJF0f`aPqif$FZi2wuUD=A7H~69xh0UDZ)*a#Aw-IIPW3$FCNkY(
z*6CN3pfelR^sQIJ{<bEOC)%oFHB7^QKYR!<jVIL-aP+9J)iceEN(Ive5_xJZ0yX7;
zatk{D^c|39c~UJ2>UK?vvxRTgt7YH6C3*|BXuC|9w&FD6y?uWmhca2KPux~^4$V~-
z43<dbDYVGW_Qom^R|o%CGM`H+jjJj?J-90Bi{z@c{KF={`8CLdJeiiT)&gw#af{7>
zN<4*@1cZ8zF)!W(4~Hi51X>O(JT5A<dHn{vKTPBawEVc{)+YD0n~RWFS$kuFYNgbh
z)wX|wyvjP7mVg@hRe8C&;`MGs0D{)?p7%g3r@S1<Fnx#pg=zbYCx1aMWfoU(QbZ}`
zz3K1B*XIdYH<im(QlZ$1|A_)8+8|p!>#HxR5NcrWMr=Lyb@L|fPE2E~+TVp@tJL@i
zwi;4R^1=B=OA7&OdGf3(!5%aDyK_VYNUS`GmYBG2Jm*A)zL@*nNg)1t>MVjZ`@wX#
zUbu;DR4xtGutD)fp8Z!JAscxd^@}eE!ns20^V-8gpgG|QvBZxS8!Wi$O^>Eo>qe6n
z`8)xZi>t0ol)=mPmIp%ZM4kl82aGPRyR6LywCahmJgPd5(7It|@ZS@Q?r^K1?g<`S
z{lLZ%2Ql`w-oujI{Hifl#R7}5P8m??wdZ5muh1?gaGrUhw+Kt7*G<kRA}wo2m#Vv_
z+4^^mo3fnOpLw&7eQcb_n~UXJKUcVFf8SDnRi<X-5(;U}+1{Eg&3GU}$@p}^=j<E(
zM4m3oXEc2wAx=^0df2sF1<9xZyK90Z$$M2$`~e!DVsG%aWv*8rq4El_gK9TRdFQ?Q
zEja4%)@#Y~L#Sf?NSWmSVqW>-<?1`vJtx+V{^{$-E5izV;Gh91eP4An6y_mC$rU43
zQ@GPV{cmuYPWBTUNxG#SS5XOBvFS=a`z$w+H&IJ0qkGEku#q@^>3*{<6wH)CG>)qk
z48n2ehPZi}>GSAvc%E|!uSj0LPV{uZ6Q)>elY9v4cslC?k^}!+{XdZPd15W+_fyAj
zNAm5DTOUWjYA+GGloIg-upP|5@9H-l)W3LcjV54p^Lps);Fm!p@I+hW39FmF@LR6w
zfXuw9S`H%EP4>I=%S-6@vu=oesOam2y-m)QM7Ufc`wo|^d%@VX1;G`3BJb5fpS|!~
zwKnJesR`;5PqanADSf-Tnyu7cdd?vl_xNVYK~SodmxIt)UKtB{P81BX%%5-12Ux*V
zY>~~uj+U|{)+yzhtEEVuRLc)+DW=ahy*?M&%Vx1NYt`NneNruB3WzqIY)jZ1>`SPY
zOY^^J-$*9%WLpB)tPiUms|<9Ei9E3u;mI$@EmGWC@@@@~Y<N?*2-Z3fX?kYVJmgR=
zeFY-z-K`|H;LE3TAxpWn*G7C{+^?%aTI30{=(mf5Hesn&$ce9Qo|)0uC4g3T)zA0j
zYkU8%S5^0X=5o8JbE5WIqm_2|6r_szy3+$0n)K}1@lb<8NB=j@l+{iBq5scd#k^%%
zzOIb^3r)*gIOpGufU`Vhme0R%U({pfwseug5%f=Y2DkE(!6|(sUoR|l?uA7+nGp9z
zS>my_lGKvb%fDrayOR2!QM;rdKKJ=0$g^JyCtm#<!K%j08&>=Uy-tv|lM82?fnZgk
z@PHNbMMO(t!p@x0bRB|K@f;d9h?-{36Dz7ASQeYxyYI(XcavA<Ei8sYj<sX<!OBo}
z+@PB2?$^I6MI0e;jn&HBAguN^)4nesEDb|}s&!(48+g(!VXvIhX)ju-V`cY)gMOZF
zOTr2#n2~TT>wx3PR#pjiLG8Fb-g?_$uw=Xk3k58-(ehNrwD(5u9#11+7JYrd^4n<>
zc-6&!UqZkv0u!)EKk|Ia1g`!3w^NXZSrit)z8fzSwn_D@<q#~3!V=awqczfF^qi?<
zkQ)>yLSzPl6$=Obn`K;)TL_p-VoJZ_^2?=#BJtWIuWuq?V@IrTIV1*S^<MrYbu%!S
zr|cq6$O0<D!d$uN@0xZ7Jr8dnS9^3)eX-*8_YfkJ#6X1B|JTf)gYJPhf~&oA3XD!`
zU;OOHs-QdL$-5j}`Wn{=+V{HGtb?p&a+l7mMQ0*%j)D7Q`qOz4E|a=0uGRH!&h<%k
zgv;cv4_5@3v{&_$uME$8nQp8pFKE4u_ZTkfC&!T{Z_HHle70!ZtpVT`oHvO}i16ur
zQ(rIYrjPB;Rn)x*Q7SH#Vu-PnW`e1>d>w+y0cVCr3@3*YUsWO33N9xHWVQ-<pQq=2
zVn=HdPsHW^b}Onj_iF%lC`ml|7NNp}s}2Ll{%3awNjw1;p`uHW5!IVtLZGakoIvI9
zVuMxBygKrR9Z^X<@s<P)j40}p*B`F@Ey84G0Qw%#YCE@Wp1vJnGTAR*#4>aLxpuF}
zj+25_F*M10-WFAp_Q3^lgQs5yclAlUNn7pxsZXVnxhqR1QRoMzk|ggDTTUvGp9Z^c
zZac^MMEuOt3s-k*s>V~ET1y_Q(uaz6qR#WrP#^$F;)%5cpp~Kbe6jVG-CZT|G+Gi+
zG=ugr%IvehfwyaucyqOUumaa0RJ}~&J0oM6ETzsBkv}!A%?Jd`Y_$m%(LcxG7W?hu
zm&DU*IX)2Q2X66GS49W2KmRkuFa6V~#gl6}xK(5tbfFa)s?6)2OqswSgSTqSM}|>T
zzkJE8t8+draTA%Vs$j@QTYJOV+S5(glk^ZRoN9?fLd(NXqi-ehu6hvVe{EGGuWB-b
z6j`~M^OM&M-gR?(4z=ZlNj&YAI8-yZFlp3^ilAiklv@H$UN>1K`;$A({ZoIn*y0Jd
ze5h_%sfaD|&IBOfP2$P61gd4`oa{OJ0BTiWGM4skG`ZY|tK$DyfdTOpP)61A9<1fW
z|ADxKCXF`R59H-7-1QP#D`tTubEy?FA|OkS;RQkT^QLP_uflBDb<i&j5iFChWGuRp
zFWB^#(Fm5wRe}}N3Rp4XYU|G@$oFE6hFDdEAY64$wpxl6JK1bpdaEIB@N+((yHDb2
zw}fx4I-BK}hL3@t&y#IQKuv9=0=C10=tj0AFv(lG<qOyh)7#jRz#sR#x*4!5Ryj3f
zS`|NDCKqehwrO7<`J5~HK}#;No~(6^osr^}7v+KPm;O5kdBC$FR-oOBo1c33J^cDZ
zI%gnY-BM4&`anlpyUWCJXgo*~PrW79-<B@YZs3azE0()$rfw&btHD2=eWm5!?NJCY
z*-Fp3%Wqnuw46nBo$_Dn6D|$3(yAgL2wi=rj^aQ74e%(CH{&&sU%i!E6sqlmedqi7
zkKg<TwnaR_mV;_-wKnePc^6r#dW(?Ml6Nxh$)KvQH@5$f3!yRz8|0GX)6|GZAh>wa
ztoH6qvS|C+`5(XR*B_bdNm*yPf_#cR=82kP(Q<immQclgn)wwT@vHx;expF|${VHS
zV(Q-tsWp2ccZ+(q;46tYNXrkcJ|aZlYCe8;bRk=?mc&zKiNDdOQ$JVPQN(2Ovw0^q
zb=933lhqoAW-_(i_<X1A=qCL^>hV@+(K_nW=4I+pg<|KCx^I(|F@IoA_m*fKKJs#%
zkN;?Rs!`p#(M?V^PSbQ=#QBK1ZqZOHdh4$>?FtBR`llsh#%Qg+UAql!*uA8<&n^2x
zrvcHCJ`tbjd7^Z;Q$(h_f2fd~K=nW3O?6R0%7{A_IfcW59eeVXCiF|_pAM@MbFjQb
zu#}dyL{E19cqer~*zGVxTLft3&6`g?ogSnN#!H9<M<-MiaHf%^`p3S2ezo`UG@*)S
z)C64huw#D&=v|K`pnZjMWBlF^ksH11FaZW^n5q2s8k?sOAgxM~p-C$k7KF49e(JIp
z{BVXKOWJ9BGNSpxJz&8ZLM#{1JddZSe7$G++sI7s@+(p8^%?arZ#iTpi;i@?;n2|_
z&*7(P>;<Kap}rDkI;a+d%C&zDTu3D`6j**t5b*nZ{<;`hsv;^x-f%1p2vS<4M+b}V
zLOx}&(uZjW)SER2PeG_GYWh&^^^baSV@{Bc86qs#t5yIIPcu|+`y=3~@<1q_I&uP8
zT&-<rz1t<rgL@8dAr@^wq!+}eo@Uk?^YevtzzGZmmI4K_m9f{97zE2AtIt;BbdSR8
z^uOP4La=<wilZ1i66QBgI~T+kV?>tE3C^+^nIPXcO;#aP)n<9{OCH6T3pTLEq(y+W
zj7Jaswpy&M`&nb~mQzxqidj!fsoybvf42R*Z=m1LW-ZiyeAw~CeT2%YsuWq4@PkOZ
z>Tb1$?tV$@h?S|KNlU+;&UmcD&VK)l915(}E`2>bD`eERXN#UJ^aeszS5zLT<;)o)
zM6OTgEqM$?7GpM+FS5$n>1AC127QpFY{JTOLo>1-d-z;?gv#o8DF&Q_ej{F6|5V^6
zLS^$+lkZWZ;(V+4P0#w@Ayjsi6{vQ``ZP-w@J?J3<DEm_T1lCT>DSMj<~V{PK+(V>
zuEfQ+iTTW`#wF12XY*CudId6o_&W0N1^*Wn8ebKt2VaFpp>X&}^zOC50}MTt->+77
zU39I+Q=n)uq*M;3)3#gfK%JMbPX-4BjDcA?toXk{c(u#>ETSz#S><BOif9n5{D_I*
z_3k8wu1Z6-{LsDkwQeB57&EgJs&Ii}YvpuVH=;n`(l*LJpH`)U*WcT)30cZ5vl7#?
z^q*fI2cNwpdF!csZDCYo*|Ol8?&mYZnuFsrhNQ}MtMhcG(ZvyY+r(u|?>4eZSry1#
zN;JWgRUjX1s`1`1_uxt81C6$!@_~O2K)^6QDv4iZ%lDy8-DHNg%5{QJ0oYwZuX7pa
zx(-k$HpvWel?Iz)MC_gJy}?Ve$qa3k3o7RFnbQDjOgc5kj)G*yY%D*hkU<a^thgOE
zYj$6o4ap3Jl?yHJK@BhD{v&f0gvu@A@`}Q;b;gKa@3`%uzF_=p;GX&#=H88N`G!4_
zFPR~=a-CqEnyP%$asC@ow&FIKp|=v?^jLsZ%zIop2|f@__7+@Gu943V=<NaJf-f&r
z&F?ZyBd+RXS;RHD@Wn4@?%UZrnIW}u?F?)=C>JzdxA^}MrZP1|b3|WDh{jX@^@REG
z@uO1^CTp7<<O_^9-u}N`2$R)vOH8}n+&=J~gCLR^^RT2p#irZ*<!hcfRux&v;wf1P
zx|UJ(z6bO1k{RME$4a<FLo&{I+m!)p)c2NEIUz5!9~O(s-Q3U<r2iOJn=O7j{DR}r
z&`Z}4s4A<W!&7)PFy@J!e^po&;pRP!ohm#T>{QARm6_iBYvZ@TScaa;T`92qSC^hi
z0wKjvRY}m&h@feU)t?OlpP{MpVOooSaN_lR$Vw(X;h9jDHb4G_tYqznNmOmo^M`2}
z+afEO^u#AO$Ft={R<epH4RW=7SvV>MrFn*mO0JIVO3cKxZ`9E)$Vw(T!5PT;b<1xe
zUox3#omCJqzpm9P9U!I(A{H_2rflNoW$l5j4DFQkC_DklnslcR!ekasc>a;nb_@^<
zBztS8oU9B_KX%uBYXw+&hIC5)c5wEQJ9S5H^vjvNl>Mz4pEECCFM%+b%#?C86SLOC
z-n9@WkD2o1(`uO?71{VA@+NDuORo)Bn#t_5E(``mgE8!i)<>SA*jusqi{;)xpgeMd
zqZwjnwi})Af~Hn2JA<8Kp^Uvk@o^Dgh*&a1DdqfrS>QynH}`m(t28|gR-d7ja&hfE
z^54;vHV9L74xzdcI_MDR2FCASc_AVl!c<Am3)8l9U|f@Wpu1z}q@3SQM<<4vbF-93
zWQyYvRL)GXt`Ux$>OByUi7~y(F;nDF!^(a6FHc9#<kC}oG+`~!H`&vG5&p>xS(Ia?
z_-N85=;mJ2sse&CbWjR3z)~XU>bb=~1LadK5s#n&xU`>ZRA_e;2q%XA$uX9`88H^B
zMZYoo!0-2#KFLZKg&)K@w5#+FVD&k2Cz(pC_*Y+Pv{no{c8-qV$gkQ)$$Kc(;UlF_
zlt0~Uebd^94>rsYvt1jWO+LMK;G1*ER+UXd)4mEg-29{9qPxhcDgZn%QKT*$p8X>P
z%B`aGb*~jsS!?V+4-VksxjYr1!R7=#Jl6nB=uc)$rE-E*Ud$NLI(6d@aIv`MRDR;5
zVG>z;yj7qmsHV!Tp~)(H2|KUE=f3#?NU1#4lfbm=^Xjk4AX4#UPY$A$_}3ozVU7FS
zHBu#T>u8W;#}V6ye*i+2F?vcYz56a@l(tSp)cna2Zy`_?QKigJ96*?$>#vWTjzC#V
z4W=F3_ePy1AWbtyPx*d+ie=})iLXpScCvU%cGBsK`Qy8_J=X<+vi719R2=1*p!Yr+
zaT<ZLDC#_R5z|fwC5}#5zHSgGsOr~;=BS{j?D(zpSF>j}F!?2!r+M<d%n@55z+4K|
z>pR9)2DIX-o_w(4!4KUF1Ut3HJ6Y^2*<{ApDG^utOQd2JpNW0;*iXm6#RlVHK!GjZ
z=O`HyEsl9i)Njhx%ZpH1oE59)h+a(8aq$g5LZ~d#I;h}$uU}N%m(ZfALJ*>8OH_Ek
z`%0$Qx*=E<yWX(IB`3u~w&w<)MzAdI`m8lhWC^xUvFCxdHkt7{pa=tkwWMl9-+34J
zUIO%0wtCPvn4F?gm89$-5P0$@$662w4>pZHf>2opN`wlJCtE)G3lQog^W;wss`yWn
z3T<aDj0N2*W5$$ky=ac6QD`4cE&)Vk$w_R|T1Sc$S@rr?L&ubi=Ky_{f&;Ki=X<3^
zE5)X)CH^5xU(9}UGV&>#v7&b~eY$>MkM+n>MFEd2ATaHFvz+}dwzNlaCMU6Ktr1Pc
z(*k!VPI3#3b|0hQLi1EiWR=%EbcJM|0u`OTusO(AnuH>>1ETb=veivbo5y}{2G)uv
zej*PTb1rH9yZrFmaj;fA<&(q|H)vL?v3BfVZz2b<j+Z1V)Y0rJy#X4_B`ZD<s&cLA
z^T@5-3M<ubMq2r-(&B>lFyUmz>wr!IkY^2~u7tzl+fJ^DE@zXuq;*a*43j_q-<?y)
z4P4en(Q`!xX7ips7N9s#B=aHy4G<03$q{wWZ)@RK@B2kh8oP+O1RPZK<YpJ=#DySZ
z`mZePp1An4fi6x8k`2W7^RbPOH+LpO+5@G2e7kZUi(Ue@eAz)m2Q_b&B~5xS2gqD#
zxOK*<+4kES0+m~|qk?_s`DxWB7a((4TV#<2L`nq8jOQLNe87q<VJ<HlNL1^(@|gv1
zO+uFPQh~%YY64}$_n(ZmJ3?V8FBLebZfvQ%{bkm2cIPHgd6iqDg6{RDcSqO?P=U%z
z0uHKe>)^lBSF{)_P<dH^P+<sczB<+a60iU4MZoeBfdd;51H{=UH}(F<`Z`Eg{srNz
z{D|I>?MnfORldGy(c6}R3Sb^<9cw{!?VMM&vUOS@V0pB4V6A5Bv3-?30t?2NFh!Nd
z2Wt1)<Lal*N3eX(LRrz0_a7?-Xv-5nk+s&Ai)j1jq^$E1Dx0=KwP8~sKJ6#15h|Ou
zaBGz9c)H;r8S*qx<N=`F$Xj;eaAYZ)wDOA3Y~%Zk`b=Ct&;^8c2_eFj%~?agL6j|B
zaC;dyth6$#>Pu+Kil!UY!*2if=?pC8NubE5;!e-}^`j0ajs`yEDWC`w>LPO1?e{sd
zR5>72KOj*9(jY~DxgM=%B1_p+g&V`^|8DAPZMTF1np<E^e-3H$Nq=|cwF=-pQi|^0
zgg@n;D6kczA3r-!wEe=7Fq2DC-!9H*u=cn9(>~J_sNC8Lv<zhIFZp`zK&#K?Df$rN
z$$LxYpw;KHG)m0u3v?^-bn}wU$F0q=E>#c8Q+m@Wa>R&8aqNoUsu;Fnw>^(vKy!<$
zFxcD^kZ%iLy7P~<;}Wpk;wtw<&U+}J*{a@h(FNdTo<>SWugF^g`xvr0x<dBJ2$joR
zoDGLOh~8%D;DsmH%(bV7s9rYH#AWvDZ33KEYGrU#jT8^wi?_4DPNDYm1qz@=<gwX@
zE;=ua{$N+mya=7gY8PE3Ve#&l-7)3K{8M{`&Lg+>co01;7G<W-kM~z7Vm&}7{LZ7f
zK(9l?Rop2y#+?W;{!!$<XWaa(Rb~}5!5B~D>K#QGO#(3zY3B7ySJR-GfMGM@yA&ST
zO|zkA&i+)bbwTkb=$}?tc#<o6w8`;I@05Xqq9cot#zV}XvHbtZV@n$66@P*L>3@Y+
zxQ)MJxSvu%q2a^kTSIe%qj;%6;MeOkaFFv$<egeHC15j%ikvPtB~ttV`ltU0waB5m
z5A;XiihQ+V{B5)%yc`kmXPi}me`VeuBkcD&g~xcgLVK;<^itZF3v6(ipnHjzCgclM
zl-f+#)3qME0(O5qMVC{UVl2>3hx_(Lw(`<~|Mf53R!Ro1<}Bd<@=HqwY5~2Ifhc-1
z7bsCvrk%C7Q(dAYsrl7g&_$vqsb`wry*RyQ7%{h+?>$3RmyYJUItn;~C++e*gC?3x
z-4R5~xg9s$0E@;Gclo*r3v~0aq(#V99@qU(pqaMjS-EKdg5|N>fdwwuyk*N(_mo9n
zHWdsZl7=?5*bd$bjUK+}Hkmpyi@_Q)?cGghG|kbgCupsBS}(uK%S7#v?cE6E3s#Mn
zs4+AzK{O90@}lZfTOoT{MD`DG)=`PaTQ}7E+(p%RtQ;JQ$8^Jm=5Va9R4dt1dnK3W
zslA+T!RQi7kA7Ta1j-5lnSrPFlF#Lc2rw|K)+^Z(VX_K#3O>m0wECG((JyBamoTlp
z`;42lY=N`zC5y9!2#y(Zb;&&l{c;vzB_{CZgy)WfJjhdd2~2n>JR@qrUIfZ2v=S8k
z`elV~BTyDa9Z>t{e^#M?e+0^6rvx?57m1wnpKs}xGic;gzdkrQDU!&kDMrvwtkvNb
zSbCnsD@7cxf<0M@E9EaCOxDJlFu@|-8Q8H4!eo+DdlpJ{0I&TQ+X!JY$qA2u7q;89
z0bw%f36E9l9lGpacCG3qGU*9Fw0qEMY9m*3q+_Z?AEHL5h>|4237)EKt`}V#IY0%e
z2QZy|7(tr1ZL1t0izYG|3eIX*=j+%3S;?fQb^b~0?2zTGf3&{FPGw{$c2dYoep(yi
z((lLi2Bz{<Tq)vE89222^c!b@LmBS`ilbG+Ofi>e_@wd|kd;h+%CjyL^QZqFKA%|>
zc>1TsC{Mj*S@^-GJ`tAeSd3%fG1ECrHsbQqN2Q-aKbl9(C@0eyn4fH`T_0ich)J0C
zso|=&Ip!lw9w+4)vK5w-s#Vwq3S5#3_fR}{#@<-hsQCxAus{D5Ys90aDXSq;4nNhZ
zqr1h?NT~olNht|rEYfH5?q&rJ)dVG>e>{5hX5D`&_DA1hxCgIl(xJS&fmRjnv5%X~
z0*l1cYKd;1z6rAy>BRocwk}>6$}5}Bsks$Si%K^wfIP}&XB80ke>V860m9_cQ(#(0
z5(g*ckkgYWrnH>oEz_bSi39YV)qxDL+l-H_Zg0A94WuTXI!i1QNuG=d{iu4vOX#<A
z=_wMjweTx8{CCvd8|uGZkttNvi!*llytkg^iJ@Qa+xe3F<CQc^MLiLeaDz#+0uns|
z{(LBJ1$REYqP!->2t|2$U+jDg;5!wSM~Q}aHx2uCp6!Vko=8jNXS`XQes^^xd(C2a
zA}t5i+Ac0?@$+_MDX%U|OF{o|Z}O39c3z3$>9eGzVke>p0-c;?9<ZhoGL@GCgsE^d
zQuxH-w8*KvBp^{Or>;J+KN?xetI-k@Y;h{r8qoov@~X5zh3b)aicYkL9En*>yhI>T
zt>2%cN3{{iQg$M+wmHPxeq#zPwWi1=Yg(t^ymeL{_s<jB7X1|jfR+zDvKIITVDEoV
zJ^~KVZ1u*pw>i06Tt0wM*<6K#Ws`>e@C!oam1_|I@Oy=clmC4Op|Z&e#V#ev&X|r+
z*<`ggW|UY~EZ+MeLS@qx?xAMwYtaP76`QW2#F{DawfLz;kfm(0%Cc>u?*DoH8C#eW
z!;@u+Y^~!FQM(rGcG&KzHT|F`QROljHMMz`EG1l2)m_B!Bw1u7{sf}<_{bZ;r94%Z
zgq2;3VQk9c*~{Hrr5nqos@&_->mLU0w)NwBfuLf%_eUFZa)Q|Z8JPXv90|n4F+5$C
z#1!e;YS@3s+wpO<TwJOK8GL%P#EmP+0bH({dqCoUnXgOP1J;vcc-k!K0C9q3IbiVl
zd-f-x0+q{E+OgR^cH6(w*ss(GRBmZ?_G|&h5@qlAy|>40*tDKl)qqfx6-Rx70|A)i
z)^p#NUIaM6lVwS_3grZNSpJ=PKb-@S#nWZExc0WSWUnUQf<(X*WJ%a6U^9IEy+yqc
zs`6~8PCzJwq-XUEORhc9<K2P?l~-K_D!k@teC0H1TX{+>5vqi0cP*dqj2jFX8_Q#?
zM78Q*%)YoIZn$dcmGR~ur9r|3`->4b9+X0c@(3$H#qcI`p$5%rRvTgR=qfP-emrsY
zR>|89+#j!TRjs`TS4Fb2w(fC5Z$AbCil?d~hr-K_4lN?jBUH6{_XvJjSWKV(aDL!*
zgvzU}!d7c{L6n-ZuOGNBkKxIs$OB><5ZDS4>T9+305Ne4Z-Nz}I(Pd<#lCa+*Ef*|
zc(v6*wTZep_Ov~kHaUhTe{yUMh*kRiC0^P2FS3-^1WQW=vKaw2tA70qLS-`*ZZ1-u
zyd8&7*<97O0qQfrk1M5iB#lxY@lRu`TB;yyJ$0bj@fPA!z!S~JH9cNCHlfM!bhpiO
z!KAEzi~$yV>z_ygPb((219r@Adw0oJgvw?u++@_~b@?Z-$>8apKnzq~e<CaB0=x%W
z`F^{z9k3GN!i&onyUA6nEb%J4hE7@V9_V3*(tGoX^{0P2s0soGXy26HkyXX(@)hOC
zC?g}B`S;ZiK%L>e;z!=4KEuEq)Bc@uC=R&X#a-c*vl;!WVBHs7?#i8!-MwA=?!<m%
zESJ3YB^H(1oELvC>Y{4oRjo@9@`^i9Q4ocxk!5UC&wmls4@53g?L=z@KV@IL>1;(1
zxlG9u!P0%b5d+=YeQM7g5Hq{EwblW(SeCENl0~-aErvJYN`|Z08uUr&Thb~xKYi1w
zfxBW_croQq<OS5lUsyBaC4|Z+a22pYdiIrC^H3nD@bXFva46l0O&Oj>#`1ZKj$htg
z@+x#JpSQBu81Xf`|C9a^=K6B+X$xkk5pz?2Z~mI=TaCHO2O*hD2PLwK8Ri!3(6oX5
zAxsQY4Mouv;z5Wp>0bd~G{^A9UQty;8u7pLtzYWio@ox|4ZR{zTV#86RP@^*(eP$n
z5hUGhm@QqMrYrg&P+r|7P~lw%RO!RZ#|-aJRgr-8AMZ(9c^R9bQ<oz3>z9>xu?lm+
zrCSRSrYC8An6bHBOmz)Ed(4Lk;G~52!k_lkyy?`28QUbgB+!39i?j67eBsWW1{Ai|
z>g76fY9Uw_Y1ISvy0t{v3k4pnc40NjDr19F*16eoHcJL&$7E`OE;xDeC^D8l7_nT?
zY1oI~gK*^ur0A`A#MOn%`h5tv%A0XTpf*=Oj%xEOvXgcEM39PBDqN4hb8sE9lf_j6
zwI|&To&WfA$WBkDQa+K8e)=mr&s_fa2L$R#RS7D(3$#chBA%>;e!QwIA&NG&EcPO8
z>2g7)D6&<fDNiazkSL)xsXp)+Xt8)wDIchqNob^M;_2ySIi3eRRqXfVsoW?VJk7hQ
z#cyD-c#<h;FNlB_zFu1!Bvzhg$_E-PPWALuMaLR3WmeV!LBP{Z5w6XEjwdGGLcgEK
zRDv{?itId+Hcfs6%3~^l0;kSM^UV9msXVSapvb9t8XmWYDJRExOQ(pgslCMJSn!p;
zq!l(B!L{$pK}T#ga|};FC825GE#`EZ!2MFrH=*8u{%O?ZJ?|%h#j*)#@%^$1{rRj3
zUD4Vpo`py>1G}US=w_rE;_k#H%}2VRN=&78b3|Q&4JxJ*L8keZAio~ezoWa|P-R=Y
zmJO8-d><WH8^rM&W9>(nk}L28RL+mLDfapJULU)bs>Q0n(@zZ?G$5t#tA<O7W8>GJ
zT!K)QQ$wwjgKFCvbF}zMn`9Mu3M!wiC?hO<?&B8`E-NFrxF9Lq`gq0+<ONnz7?fJK
zX~PD<w>u}4T8L0t72Jnv`*!V_+=<8stP<{`f^3^E<D&BjS9P!<BEiK4zOD1dgbMbq
zvjT6_70DAtY7~8(NHf&X81x<g{^qrAM$qW14tqW5D=#QCOrk{6k_K1otXP33sR}UI
zx=<^;E@G-{uEt?+WmV5qQF+?R4UIJ!I%fQ$=jnW&{^_8e6qcZUI`wm>AmIH{r$wv!
zAb8KxZo!K=0`_(+Z>Fln>@g7)yeDA!;hk^dvGITO8av7EBP+ys61!KoVFOFPE<t5Y
zenXEuijo5}vK~Rmp5*o+lQU#UTgV^fdOa6H_9S=!vgoQU<mzi?<OdY@ejG3WImN<V
zoIf5+2CLvL!IHcG7~hGo?qMp;Z%4PS;*v$<whC(xZlgYZ&y2EZ?bf$~R_}u(IcaHI
zk%8LjW>O&hS$W<|u9+JByd_u;q|{+spab`xiA8p*A0N_AkuNRCODF&7Wp|Mkyv0|J
zo%Bt$+)-J;U(N1z5ZUTklqInI{iaW&fBCUCpn&&qEDaJ1=7v8Q`6NR2q^*H0x)Y;p
zEF4tSKj&PJ15euO$ViD)`^y1OqJ{G;%sQ}8j93<bnz8;U1nk+P>%j7RR?QW}+~c$2
zvb%XkW3H+gp_nT#Na#a*tF2yG`~BAL)?M?kw<Igj-W1JRBJlE`ayJKV@K$8$ut-F>
zaK=yV5HOF#4lziWVL9UG(*4hYn(6(TV4%hBPQ&oWtgQnsfria{UY3q7F8Q3ZG6Q^X
z;rg|aPdp2<4lXs@2JoZXU%ich!y-1iJ*!$Q!&~-LjtbstE#2ZO(i>Jkm^JgDZ$LKk
zes(Yb8$B4+z4O)a2stcnTNiXh?p8G~{O#5|jod2Rdy-q+O&N>#!DsCn+S9x$cni3s
zAG-TSkvRt_uMX(eZID?|N@t#M9mKTvP^^GIAdXPPHpE)RgVVm>gur<`cdZu<8v-wx
zQu%#*Vps)lWmkaZ)FVsus%6Dtjp6-rbH?7aXL(idmU*E+0nUP!)SLE-Eg-4j{c53u
zpVE6!w*l@RMS9CR(VTqchvQ(6;w}CHe*w%1oA>+TXyhPXY47g*fDog*3Y@=l8ypmP
zkHV7Xr-1&M>RQ<j6~1??uvRX;UpI76ML0T24V_Dr0G4*!)6^})S^`iRJa_`|4VgxF
z>1$7Q`VCm?tp*FQ);>IK((A7-z_;FmupC@*@IYSBeL%iFwD!Lt_K1NB-g+>JDlg>>
z64uCis1K-L-ik1V=$q9ifz_37{!S~OqU;nnW~_p@ChTyX=&~mc92Ec2?7-o2jSn1Y
znx?<0;k)zaJDHJpRWO9wr$|4PeWB9;!xtZ3|9vS!<<)WrwejGg2I{)J@vV@Dc`SBN
zo5~YU1Gwe#Av3^%k@sVVYU#>4z$MK%tNdE6?Jn0e4#)G#xU{*d;b5Y0ru$K+T?cCv
zR{jk|VdvD_ZqIx6Dg7+4)ms^++)%Zwy=;54mhBHZ8E<8n4hz?<_xRQCfX>ca9%dt3
z3zx6?&nH1e^45q+Y|lfv)=Tca0z%GPC}zSJ@zqk5FAC-@wubVBah#aoNoglv)Q>)1
zJGxZeHK!Y=X*zG-E5<B<0t0@Q$%y`d7SG;uvrN0u)n388FI55Cq68kn$>&6v=tz8&
z*zk#gJrFu?8?K?lW6*&=4XA;loJVwp?yje!BOtCfx>48vGKj`?<rHtO+dI%t@4UYU
zP{&(J=3ht0)pVq9=DaU6ev%hqt3&-zHAT6CI#Cn*+t+^Xh_HFBy23`9g}$S@EJfJr
z*n?*`8n;`j{kNZh@JLj<E*`dhos|9a4bza-o^&@>5?$AoTJ`dDurW$hb%tj(oOfF^
z-P-YhkKVE~X}EUdE{{RXK>1&XeuqKJ?>&@Dq00jtvFUQQEJn{Taof~v?idd(5qiJ1
zsPILc2y_wUbka%3v-)o!=6`mpz;3r7Ys^;(D-`o-J!!m_b!u4q#NwJ@QN1N;%5wS`
zpkk!#P7Jr4eXnFkP}jVbX$oAdESyK)GuyqU_C)Cl-ug5N?Yq|_A%(B2f-S|O{W*UC
zW#4<Km;Ohbg*8`{wjEO@PI>|Po|guEzkz_o&#;a$igx>MCj#eX0w1^t8-XqM(8j_}
zDz$YENHa;iRN#WkYhcUpp3A!wLWZjn7b?y8uw~eYrq(q4i6QYvi;HfB{%J(@mbcN0
z$^qmJyE{r$(OAgRPqVCqm(cap&Zq9S1!>+}_U4zniZ3^uzastbbaj*qHoWxVD|C!R
zIY-L{s=Wx33&e+9>l+`4OK7sb<$=RT8n166Kk7PuGTjNYwfkds%hh0e<t>5p+a6@b
z!Jh9wdI*-+TLz~A7mEyX*uD3$3}1p{2X8H$29EAlUYwQlXXFj<X2368rq6usUDjI{
zFWyAJ-YFme*uD+=qQIJE2-utc3YfmZv2H8s*RIhXx!9Zf3b=~@`buq79=3nsDQW<W
zjf%G{?r@!>ryA9*8{On&v-O*rmp>lcd|dizW;mZ4zON#3hpL{zl8R<EI+@>5uu)G0
ztf<HX4)8NkJZrg38{LC>rH)epM+_(Epz655<VTPf%4Ge{T{@LDv<tT&S%c)9;`1@z
zNrBZu+?n*zZ+0<=_14Ep(oqr>X-@nXootx-`clrKHC>ZczK->l$@#JA!#A5AlZI@0
z3gLS194H=~#4m6IR*g#frm5G#vxTwVQaR0DaYtyB+lN!S-*H<%-3z=d;aE%Oo(62p
z<pT$h6L>kofko3HceLFM?#^SqUxd`0K+_zpNIO@h*an+yvEGkD8o<`FeLsJ~4CG*5
zdT=};z5+BI+^X6K1(ChH<e*>!96?NuJJTSu3#>6&?WsdEnfANzo3i*~F%4Z@EzrEh
za+-t550-;lmY8-1gqpWhP6I~Qx$~Ou{KD?gW3~BCq0+D8;Sis}Rk`%kS^HujHb$l4
z5b$k9xwqsskIy-?6dBB-a$C9ijHX>;wA>^5;8hiEe6D(bs-l4p`NVoF<fw{{Yw+@s
zs0L>m*FOAp=A4nQtttMDao%^o$8VeLFS}!7She3V-g3x<&C8;Zi@n=@k%^()s6n>b
zZvZlT>*6TZd^!!W2RF%FF6ZPSh#M?2Yp@oXt9`Lxja%t8GOJP)n#^(vsAcTGnLcu_
z1T-QulyS-jqP`ggV_4I1UjffD#Bmy`4SVK)FE+N131TZK4}@Tu&$FVu#Rzqc`Br_x
z_ir5pd50mBQx+ptar(8D>mghgjeRDg()mXFpROVgvr4jyYsYT;--qr7vFrVgq(%vn
zj|9Xn^*gZ>um6sK!(cB>1hzLu-R4i&ihx-a+2;rWY*(UjZ+<(;-hak=4=p2Cxato7
z!I4G~s>{u@U(Vp}_%$l4a^XQ`s>^Vnc&N?UeD(omtk%1SponX=b5N%pD5%d9PmZcy
z9b|TfYL2{ud-w4xpLh){q4y9o>1l!K-l9fnUZ$Wc{z>acZo<@(8$&SX7%T5kP0)7z
z=6&HVoes)kwD3UHpyn16&n+N7usALCPeHzY9=x(o76i;H$39@$0-3&8ajoHHTLT=+
z5XlJ#O96{@syFDf#Di$fSbV1aCnb2(&JnxjtVW=$lI#Nw5Q7kh2XFkZtLs&b!zvC!
zao9K97fBi?#2@(*q;`fXj-2XvK>U~KgNW^m{zkBBFAyR#xUhj|1;nwPQ@*YVTpP!#
z$s+5*_1b)^V+jPR@?$7lgNS!B|K6oDB{KS_5tpHN6MjXv7BjE5coWoihQQ4Qq$?b|
z^4y#9od0<T-B1=?rJ*#`&?>=KtIa+ETD>?{3HHI-Jz0t2)uFL0zB;Ig1V<jL6p4Jx
zVypv8Cj$ZdOCoKp5kLM5NUKsTgS2SK%2VCXp9S_ZbZq`u5c^?!(HeK10|v6jGIVS@
zZi-PDldgW45%7zlWAmemqgeyA%o}HFg6^ClWz#_gdF^wpkp+^*gV6OBvr&iOL<9AB
zhQaHv){U|sXpN0m!4M+LIH<lO0a6IaUQ#@rYv$cNEo%V%S*-VzGiiJ35FvtfIx!P?
z@yrALY>9BJ_uGyNcu?vKod$MGh;#pf`6r5`$$HtoY>#C~+{o|J_Cdq?b@PoQG0~qc
z_{A!O&f>V{a$C4VOz*Y$uV3AIr<G@wL_;&34zZ2=LFMjn#G+cD`(voxghw=+0|h&T
zyk%%&MQ}RK5WEE<D{YNB?aA3R^J&5+Z)+9BTk=MyJqJQ-yM~oK@))w4RjW0Rh+J*y
zb~<L;UkG8V9xDVxb!_mIb<Be&%7Oizx8RNFqhZSndo#4BZ%o*P!bC+M&v09~vu57B
zd&niMDz2F=+78RzkA1cYx`b8BHEfw1O_x+TJ}nxQhlFt1ZV2^>>g%50mf2lOjq1uJ
z-c%P{mrws%TZimF{j(AzDTd@NFiae|k?E9{TffNXTCNe(dwiN3gyiaA(#6al{81l)
zvs!anP9Hej`W1iT&7y82rCZLXy#sFN!Qq`Je+c4)p?UK;+yPc;P#s=WnA-PyWHYPa
zD~H&lb+%S`4M@Rb8H%?6n^6i(toT(Lw1_IWJu->o4o8h<hTn}njdvh$HsKv`=i4h2
zJmUWv76qA#p>+#zij`l9@ufDjAL=%+8snASo{Sd*#f^6GtxwJ!2hqV$xCPj2r|gCe
z|H%Wq%uu%l0OJfY=Y@nfftMNjwg7OFLs|9U>mT~30h=0ztW97KOdT-DcS~YM#>K2%
z?}6&*{c0s;y@Ag38N2DDCTjh2jn^S$7Q<a+nD2f)pC<zOf>qId$S5bZKQakCkQJN6
z;<pdiPDs<DlGY$=6+uE|4Ie5JQeUaH{9WW<RuOk`2Mp*mEFjj1(Nl`FxdPgC1<YY|
zz;>VF;oZxF9|1q`)M-9@X@Zs+!IRqbK-bhfahea8F4s-m$O)H|kiD#u?c##YE_vOr
zIS?+ZTD!QQiEfwfk5(Wal35M94;NRD{gua62H7|{941?(gF>S9wJJrCE5ac%9j}^8
z_jl43bc5)vOVg4XYRd0th=Yy@hsso@ErXvOQnw>=grb~xju1CR0l38EpJ)8+9}1`h
zX(}R!$b=kBkVcrYG&}oOf~@+~^-n1nDAZKB*G|NPB!^QZVWk%d5>7Tl;?)x!k8E|5
zj%s4#c#1S%_!|2W3bDI?wzzMzB913U^TFb3-}ut4S8Z0rl@BLBz*66M{)zm^WLARk
zjRC_YIql>tbrG@(h!A1sBEynA@Uv1g?EsD|&q@(KWK@zDbzJ<s-LJ**WNAL!7~ezk
z0qmgI=yh#SC;KQfjwelX!7bG0=W=yMPG%(uAF6X1Zl<+dFSL0XIhmCue8^^{BTCQD
zvG-dSSEIDLjS50(dBY`SprXjh2a${>e$Vt1;0?Pto-oZd7ZlK#XHI1X4(937TwEGh
zVJ+SAPriT8b%d6Kc*-;v8I<O&mzV!xZw%sik~D=Y#kOWp6#x2YDhOil>1|Z&eAxCr
z>B~PJ-+??44xdqF?iu-RON7g+_^!1eCK9(j3kLnf#jsj;A1<uSV^W8Lt~HJ)O!EPo
zm6>wS*;lGx1m%t~uuUzSzuc+neDq|x@dQhSNu#o=NkORWtIlbr&x>diIU%c|AzaYz
z2fuVx;{{Kd=5qopb<tDveFegSCr%Ta&pts^79+-%orZ9gA3_y6i3`hI;Ww)NYM(&H
z@uX>FZ=(U-x~B{cV)cMtgLfcwUU}Bgq3z92R0Lxl;}{d&DB=Wq)4|<?+n({OCk7(h
zdBoPxq3s<8cRm7=oc9ZxGRe`k7iumFbU*U9Euf0?eqqy(YVY<Jd{)9gcul7YuSS!l
zcI~GcovV2J@ou-N5nJ_yL5S_E(UgnD^9HuSA+FvNNx-u_k(#_vM0@h8f9K4FP*qD2
zihtw<vrnO%IiuKI@G5p3Pn;%gMW?!V)BW5F<O-fL%|V6D#Dp}n&mkZ1*erbjT8U!s
z_CJBF<rQW^#e4iV%ZjIhdgT4erk@LVhyU*D`$7NCQ>97gI<WMrlBJ?)T7B>Xz+cAf
zHp*z^3%l{TQR~GY(W>$JYqmYa-matfed2moW3LJY5B5@rEu=0+gZ<L`Uq1nC)%N0E
zEJKGJT^7tkk-!+#=6V%2QY-&gemOFhSCVP5P#g72ryYCU%LgspGG?>6#`>EmbvO0)
zkaGh8$9U>A8CUqkAVZ!v3b{F4H<rcS!TtJ?`~*Iz(=2;!@R>s#WB8izf)5zh-49w9
zKJUh@ZZWH^c4s%oykYKHKDhRx>`=)WIxK68?81sOaUZbL{!)e5H8taN^ra4Iadco$
z_L8{bqZaf<>PGo}b>p`;#`cQeuJyr0<NCjD_CEum(O9itC>s0T7*by#DziUmTWK>5
zUo0GGwzpy}!0d8$>z6svxY|!=dJae{4Of3)?B|=CkhAH3(fr~qUGx2c!(X@D*d$HU
zE!H%l$}RpYlu>}vKONYc)#4b`NN2YeAM{U~*0EHN6D*wxERt`^&dC5x+P1tQ{c7`<
ztJKQ@rMYgYy$t9Eb*lHVMPG3Y&6;kn|Je~qZR1b$II;4gJ-0EAAz1VM348LP@fWK9
zSg$0gp$z4k?=MiYH!yeiF3}wneTG!chpFjTEDhfW`Nj-G;GPsGLn%r$@BoDg5&Z1E
zf;-#{tr1*pVnP#~npXJfa?+)u|JYv;#xbO7w$b1fnIESV{RNyaG4yI0JoyJ`CKDf)
zT?aOH-g-6N-ww9la+R2N#*djut4Yq$IPX2A?XZ}N*tpT==A?)_kapwX+|`y^pFXC)
zb#xGD4j3ca$Ss2MZAFb~X9V}mT$LfHDgvPriU37f>VDc5ol$(Kz~g|5R3cnVvv&-e
zi+$NDJs>$_ESt{}w0;s(tz7FOhu2eUU?kQA&l)aQZvB?#2S%P8HaFQB`k-JNFROWs
zN@3tr$8p}$G(T+G6L%s~x)+aV5i!1I&GEDJsS-r-Doe80ahp4h;;N$wO>w!A7N2`L
zE>?Em`}$NjV7Iq6O|$!6&4}^hOnSoB2)|=gQ@W`7`*DDW40)Pw4V7q$(v%S)$J)#s
zgV0%ZoT#GEX-{Fq%B*g;<yM$Z?KPHrzxe5Q&fy~?o0y^U)K_=A(@Gj$q_;XvLrvTG
z-Zv(0>%61alP`>%l<3KD4Y%=ua!n3o*pTh7dU_8@E$ZqQ6DCsF7`$QV(|qfwiFph+
zKbKf8j)o*fiGRAARcr^zBCg?X2YjIRkvgXuH>xYXDIc)6*~h!uFW->E{I2}9na^jj
z-(!zsjAs+SqivZOGq3)8?cZ<gZ_48s5;ch@c&Q^2)Aw(#pX}ZfX-roMipg|K$ugqr
zx*Nb$hC0nLRg4%g=-2$C^WV9BhqiJIS(+cw_bH<R{N^t+dx2GANYWf&)6i|TJ}Ch<
zgbW#)4-cF9-_no33odaC6&k_D(Bt!g>rYIZ-D=Y)Q2vuVc}&$#fXbbk>40h3w}aV1
zaf~Ty60~AUJIa>+daCmKwO?w#ZGXQR#}J=M;C9B0VRFEpKZ+JXkct68@`2-kc3>3n
zm8UAL1*bTS@n}9Pn@Y)`7Nx}0odXZ`cEev|s%q&&F*U?Q^G_$#8}HV7jaCfFS%9_H
zXyIBTzperLDTd_C!8Hd$(_%e2Z^=c3$*RC@W7?s?&8O#`oeJ2R%-T^)Ol!Hw)Li+q
zm3Eg)cPnd8t-)G;{kQnjW5C{yAv7bux}VI8rk#c>n#`SX^u|;K&g!xK;NlRH8f+6h
zuJqqK?Qi|#7>YC9aybZ5j4QPZ#GSFj|FfUxi1U6YR8qNnO5d(>5Tfrh0&(VP{(zy0
zJ%@p0nXEV%Dp#a9yIviXcs=6rxBdGLB|lU7muO9}P<~bgy*7CM=UyY-&{LU0J17gC
zDP;GKMyg)<v+x`C&yQ!Q&uIMwY(-Fjy1v=J0Rr{D1@nX2k&w7O&lWqW$1`MSeo%dx
zh|llL*;J7V5&ctqj%N%&^Ff+`g^PD9gMK(KL69dwH5*(x%M=8v!YO2g5~w}ee&y}=
zve*?Oo}n*ue>!exvbFtljN5zaF7<51C10fnoYZUO$fEC_0vERN<#|P&kWuv+xM0tG
zyROH3KN0G;*Q`Ip|7}M~M!WS#W2=gP7F*5JjDorI&vA2r=39oY%w02g?uXWf5D!Y^
z+ZqKTj3F$Oz~Xc1Vs_ctaWH2K1j?)HVl$00OU0ViyCG0sVV9tGW+{4MR!@*w7)mnV
z&lk<D;n8%tFJ=Lm#e1}w6IQm3Bc5xX3H@+h5f?ukWtP&Jl9wS+CRqv8&Ma%neK{Cp
z7KU)l=goFFvplMQaR|sP4B?o88<1Iut<QZ^tiQ`EjjbwBgR)gbekob4;kfc&50~By
zatlK}=30z0)~Cm7J%dnHatT=u#G;uQi&8+nl@ZrmA85ISG1g4ks`bq3d~j<_n-8f$
z47{0)_g0S4+06K3o9oh;zvk;(zJ0t!#N6)1H|WQjWO(bRo0I@dtH3O|Hg)%2>wfSt
zVKDvEJ;5xuW+q6gH()AAE{thr(y@rPsVxhD7h2;PqA(w%P1;tc{>y-ZidkHPP`1wU
z=Qn{=z!+cVGZeG}MA&aX-dWJa)d;JKKxo1`vw=lUG?I2)%Hv<yJJEQCB+M}vv9-&9
zj@=O^ldX`ePuv|n6mXRx2XpNNekCqt`nJ|c5CsfHm;~-SNU9A@1{|8Wa}z>kGE|_F
zdd)=r{;5YFBgZmnDo|4_%&n`de1tH0Mb>$A)U>l@hV~5*Ca=c!5pS>Cc6KfL#VGsQ
zGoGRUqIHt*kBF-fv7HCke6{LN+ksY#w;z`JpOP^Fo+ZY9_)~#{pdnTv;K^9Dd5!2<
z5*1j64vhTZ*y?&$Rjk&P-#=tugT#C5z+}ZL8&#^lC|BaG0`X!&n*N=gYY>IL=ld?h
zsg0ra)5?qYtg^!g%QY->QVx$7pOd9IWl2(=ZT}MD8AB2#hvWzy6dG#Y=h3uQWIg@U
z?Nv(`tljXVy4l9OdmDB?cP}?6bZBo1yU;S@ny|eNoazkN!4QQh*kC5_yY^*&<PC2&
zOKjg9L#Sn&_ULvA1npgdb!bh^MqrPnp}fB4>1&ZxFw8ad<g^oW2hz@{TW5UDx`A)1
z5v`AmdT*|~f?6R~3&^3huMR77&wL%*f}YEX6#uli&<?wTgq+{pVm0S(-?uC!W$shY
z`YgBDa&}Xh_8>~Um0`|Ese$r1KZq=G?6N#y98o-Dw3%E=7h79P>TuJ@wVbx+g-Eas
zVoW&GvC&rnzt-zK79lg4?z38y6zlV{lmFd}M7~yW5@bOGd~JUpK(T#)Y`N3OYVVq@
z`vYnDZ&j`EA3|nw-RBR|9GDrZ-OcSe5i*nNE;9HWY-`nWHIb)1nI7P2dr*t)x+CIl
z7ZFiN|1`2IM~5c6qY)D`j_fmeqYr=a(AMXHdl;fIeMtp-EXViSvHd^b9)?~_N5&r#
zl<4_%E|9+&dNCaveoXNEjX|s2{f?Fpy~Sbyt7>chi%#yE9XUEY#*3p>%hBW7-MoyD
z!(+VIqFKlVny!LwR$<7=C3MVYLBE>wN${0;JVPy}uOL$Emm2@hD6nJm){F%#AW-Zd
zt6Q)g3h40oZmaf*?-#pQ+Y5@jN`ImFURu7u10J*4vNg31pozC$EWj1oN0q8?c#yyB
zTlB~n&C}Fq;;j^O`i7DRht!R35FdL&>#?o2VMY2eJ#D>Me4;um3>kiE*d^=%|9NVC
zC4{a{HkjzJb$GSNoKHcpc<aU-*ZaO_#b071#(xanRf_l4js;>vyR)z8w;LoAhH^~u
z(q}hnd1_pbp9c~v;~`HS+5Q-^OKO`hkf)gi-e)mxc>0z|(+PQlNqHZ(*_IID(?6Bx
zyql%80<Vk?O?X-0#WvkKSNrUriIafE4B43OW%LPS=5_Nv0Dfl3#{!VyXN=#T9K8%#
z&1QPtrVSg=a|2eL$$o4Sm>Ck!(30s^+vWVzSuLg_i<#xz7a6FWKU4F<8wi<M&Rt|s
z&QIMOJrI-whOA8Y1uW-xBMPIP0Yg}(L!)wDX3G<2T%u@&hVd|`jtt8A(1_|$$Q$8t
zTPu#vzLCg%FvIY=F0@8&h3r9Yv3BA+Y7z&U&(@^9Jm^yp91O9U;|=i*ygU2Z*a-ab
z$&2%CaZx-&Zstc0Id|aQd{vqtd@jYculHd&KbI|Q287Qo=NdjNjAfslv9XY7cIclL
zhm6T*e*gGp8whw;8&ERJN?2Ea+0zECFqi)H5i4#Rwmh8hI6`K2^YWY1Ad|_*M=b!Y
z6hoNi_=ap2ErTP5wLCIpP?1E?I51>s0q7R)*-sB=2B+@~HJZW=Y)6Rug^pJ0=jyhV
z98LL{s85Y$5ILIfYcZ$MCcL97N;jlmPdQNK5^aATB$tR`E3u7f6k6<wX5-Q~Hm`Co
zt$3rT9SjK!Et>lAxM#{=zrlWcxe^$|&=fK{B6{Yprq>WIH-S))nVlFNYJFPte;E-j
zH*rW@P;JM&x~n?!Ft<aHxUgGVoc3HavN)U+fqJD@KbC%gELOoAdPhVS<MWyi>-A`3
z7x4tf5HuAN@U&+Bf&p1<4ks{#Y6{qH?)uK2@)vTjD&XFZFwawn%W><jftxw)L@WrG
zOA0XY6t452pVjh@{HA|9U@b$crhI@pug%f_G<VM=RK-hRDAg1$=(`@~oZK2j8DsvL
zg0&A(h{>^2bAT`Y6BrZF6tdON5%9%^m!EL^Io%UXDu<e?u)g)#)(D!(WqYoIQ#r`$
zV%zdHB1hBzqFe1r=fmQ2*YeGdpK4nEbmK;uP8_lhX0|6TJa4Pq6TAnZ(Fc4n@&zdI
z5iotDLK{t^5&e5Z(@cQU-kLT)cnbK!_@grKH$o)wq_mDoNmH|yDE-#q&%nqe?I7BN
z($2@+qAqE;w0L75r92B*;;m=X?RAo|ft*xebqU}J?{R1fIkp1uaO>~h%>;71x2i1=
zS7Z#s;KKDXd}?=>3ErwU1)LBUO`#@~g8^UTlcRrZ+2jgxv?sR>^uW*{<l9AlpAM+)
zJqs-mS?;$Dm!#yI{IY!(li)3MBj~nrd(h6uKx_8FKOa_&1!><~@#bLD=83S)Rjhcv
z8miRZbI>GgOtknM2B0puaAN>6mPKp%<-G`uz@;Nrue|!qOgEObrdzdyp;&FrU{M#!
ztAE{f4w&n$dXr8NSwi>#q|9??FDw9&=KV;g14~V&0CtM15oz~V4Lb`W&0GH_p=AOR
zOD7GtLL%2&Qyw92C^rXbvlKRpi6wDA{Q?R|EQ`@?sm(;Fx#zB&j*Rsz)Y4eT14g7#
zlK43N1@JOkg7-)?2UaMI0V{^inY$9Cc<+H|4yb@6eVzSOOOshyN`kuYt%Z}gl*pnZ
zMW-q7sXI0z?ZY`wJdT!)M`Z#xT|rD9lH+B>WEBexCX11VR(;OZ>HZ#2l)U9|(iM_w
zzGr+)t0^klWR8mf!R9TCQ|JhG>h7H1f;{1^hYNspw*AKHZT_U-Oi)I>1#tu|5u+mu
zIa&w<`S7-tXWd+^wXxoV(sX3m)*HaJ6EBps=N=_^Kj*0d%Th`Mf8gWEWyY7=Z=V?^
zc&p>AztAPM@1Ra8eFx&dQ~1X*{ZTNg>*ElK)aQKX%&@H>rlYE*IB^thwOULXOnwTy
z>P?7KcU3{qX&+HLx>VgYVjIz-(dLXf?^Nr(EX~uWuB6jOo>90jso$*y3LX~qefAfj
zRR}0CME^Vwqn>n$q!n_Nv_sQh?6~Du|3>8Os`ynMV6V4mPFq)LuhosF+cxccP;R}I
zawan95}GcVo{F$N5710(y0tPqQgudTL4?gJ<@yTJL4<)_@zM9EK?3l83^c&*Vu8Uy
zVOMngh{Fh2MMsdpHh`^FjJ|VfB?9)`c^kkfrYk1@Icy<F;NFAOOkjHjv%OhrErRxB
zxe0Ao_Fqz_v_S3%kKUyM7m(P!E2Y;&_s&OSw{o)wyJ_=XE|P}J$`CZYop)>Yd%z{y
z**hmboR8Lwn2w)Y;XH!&{8S~t+w#Fu)9SA8#PmYY;n7^oC9z}VO7_k`pPt~YjWetU
z-QS;gI{yw*s`nVRKxiXKh~-I9yVHTx<o)iaiA<svV;QeJN}YkMRuRaG5aDbSx#n{t
zry{GvDd|PzgBkWRelhLj5`-Nd)oDJN&Goj`e(wdi?mb#9z}ux=u2UdCmWH@~<%QDn
zy)XjTxUT#WgzL^dSaW)G;J*Fnz{k6WbpT}XR>&FVg4n2;SZ@&UgttP@fVQg3$muml
zAe+M@xbvin5zqB&Uw#_d99|ixn+gN?`1qHOBAeAdj6)OwY)5mWj88p6(BV~a0c{8K
zgDq>XAa{gE?=o&Mt8<|D$E~b{Y*x|CaffrzWO(}OXOBNXHit*<GWJ2~^QFH8@A)Qp
z&rS=7=Q1>6U5^gpcAfpP!`w8gaa)-jgxm67teiX%qf}>~qW`vQ$z0$JZ#A4@vlY)b
zcFsoKlD8Pn1P*kD>`HSEeA{(~w%_%hrWOEQwyYg>6}z2Sgpk8yw?MX1QiW&Ve29?4
zqqjh|9K9xS^hHpsyyvT#-T;{+`qOi#5O#R<Cadk#G5@E&|A!(kJcgIE7jgI8gw-H*
zc<bQ;9OBF~Gg8O&tr6o8ba;Kb!$%F87+(49-~9t6G=?kW&<v-=!wjGNdzZ_=&)$MK
z!yQ)O?f*DSGH`~s9?k@|8D67Mn+OCQUICX6t>~GQlE=ZUWw#@Dgh%m8cG&$^FwH|`
zb9fA|WRBY+o6n7yv>e$SUIDLUXQk>pQ-4D?hsW<qX2l|#_m!{oJ%SF8-U8ar96!BM
z<~qow-g38qz^h~&hLO>COTTvqAuASgx(<OHkpGF^$JgD=<$idtL~qI&#BRb4B6<TY
z!GZ(*`np#bDq(1SIWJ+PXnBZS5S8^U@L5Kpx9rVyE=c(`-s@l3c5kA$@GSsah#~?`
zG0Ez7cTZJD$l)anfgG@Kg#1a?GehhWnCLx~&9oW#V`Zz~_uITqEFWIVsA9Y0lXCUI
zAlpRmcR&M-u3~$m$H#vRw^^O&J*dq9HsYBay}jZGcM-JW2#0%B&;}@Z>+Qn`TD8wi
zXge4E_VDUb6nNofj4DP*Q^vSks@M>~Z*~5~;CK7TGNwL$<>rJ|AfCOoaDgjW8P%!V
z6KVnNeWJG>&cwD@IA(st>&WWx_$}NF%E^PjuYCiS&|4H|T5WYmr{B(U2w5E_zbm7d
zzEbWxAQ(;bp6M1~b$dH^6nY`*5+F-Vcs)UT6d!+<I8g%RJDw`ee+MF7;4+)KS6+J>
ze7BRxQ^e`Ob}Rbb{hHN~JHjKlusJYy5W}CGcB!*{IIn%Y8H(Y3QwK$+^mU%Gh>9#;
z+<h2_Y;|rW$1dI7hN6$|J=Hcj(OV!Fa4UJ>NYgZ%0-j)^WPR@K|I2O9>PzHF<Xne4
ztEdcal=)0aWUwd6b%W0~6VH*P8Mw{3K>fc=#ar3Jj6|M9&TlZ?ppuS4_Dss~OhbQM
zMq_~kr^+RIPkpltKXCX+<MkPvn%^SKX|QM%NKrhYoZotNb*;|XPEYy#ZMVwkK@t|*
zquN>{Coi^{HO$tkB=R(JK8wp(ZQjs%d49JaXi4Nr<XqH}^3<OSftf~rC{$`0az;2@
zFJl~Z6VVgKRZ4JiwN_niIfD^h49Akpjv^(n_43uDGKt-Rk9k@-*Be%;y`BB(v97UN
zMDV0?E-EOqcbd!rL;VtYIyo2D%KU}rzLWu3t9<L-+LbYKGbOk_S+^bmrJE;_^I0n*
zL6cmlbTKDauSCj4Mq-Zj+|Fz1qWtmL=0Y&i*ixQfEzxY5t#nD`$>jnK2M2;ZbG%-W
zehB^3gCm?Ko!kO$AuFxlFbH`(oF-jD1MKrj`7$H3!yz_d`)}RUm#i7i<zMWYt#Mnm
zcp<o*Iv~;!bVYXR+tudx@S|<PX=5T!L8mPxxL$eo|K|S*9Kw^&Y0%*Kwf4Yo&md^e
zDy}uA<ZE!m)*{2OLkKz?vOCaL);l(H$6i32urzcMT5K`wCUWw@#oOE<(P$HvkdDyN
z(Z|U2)utfJ!>QmtY(V&uk@?mkmxoJua7fXuWmE!!4wvv?5A*ly4|;%pDJ~qo$7s1*
z(S20+ZrR-qM5DV(-J$6&zTKcjq~={R-#C2x<?+`3O8_lS!jjENyRG<c*=_DI5P@OI
z<|HzR?h6AK6$RTm?*Vff<LU7rtKB>N`t;TaI2^vqSBcC<@9`^Ng9G)%ump27e895!
zg|}J)X;Gs0W26DDkQcS4%}e+GdmO~H_amf%(7@;&pS1rPA&0|p;SDj1!L)g5z4Mz;
z)P+NFi3~E+&ZFz*qu>aS<DjBH{_m!$uIgE%xXPy?C_Z9Dq!dz9+b(R5bWWTMmJcZU
z8<-%J7?x^Iej{jw--ur2`U0P5-_Lq?!!bheX90K4KiNN&UQ0~cSA0BRD?*+fobVPX
z0$~Z}VnnYXDwr93>w9iG2f{im!JL3Lj%I0d@YMF3`4O_J0vvCkVm{@k)Mo%;5>)Up
zk%3D1)5EXNLso}JbMvU0{L$!8V|1qMJy0$nHR03Q^otj+LLnU<&5a&`Hsx)yt&VVS
z<TRQqZv>%v8Q&ld5OL3)sk#N&s@=(PR?q(lCh@{K%DZ}Q;SLH5W5?*Nl+$;N&G1p)
zv7u>qfw0hyAsI%C6Cn4q2z9pfVwv;Dz~0>Zy-__Z{AWwb8v`3P%|&je|3yni-jm}r
zZ;Z=yYJ;_RPKY@Po?lJ$9vi0_Os`PMFDBcW`KbAjGI@}r!{K(P&I7?$XE`TVe*m(E
z_ux3qZbGJzHm%OIZ!dU7Jkk4sQ60N$*OEo(D?Agt!?2X;;8Zp&#he)NOW=VsDv01q
z`@VG3oin2mT=gCv1h;C{rFtW018c+5%8|9=Q(fB??;U;bYxg@GEvUoN%h9xBqt__h
zZT3-jzoNs2vl}PaASd5HwA&C#@HFUBhxhEzH7eFVa&TnK%M<E0jrUzMD5kf2<y0HW
zd2~yn!>iMkAh}6{Pt(-*l(UcS3Vq<_om0r=luLAU&oUl>Zoz(5ET#&vG4So|MDHPT
zfv^!<w?6r_^W3j8xy#)R)j=Wfo+1~3ed17yLvHp{*zYf>^&aIX!q?rQ2*YvqiLoxS
zDg@~#b?AtQ6HW~m1CQ(+LNvd#_VZ^!9aq>MGzS~nO24hR0k{~JWR3<j8C-n)#;x~3
znhr}aC#<ENmers?xVaO2ZJU@J4$pnq;OxH1vvrG7pwK@pG`wFh)rtV28@ny)9e4h6
zy(Wka@2PPHw2(~)-mnt*^qq%JAiF&oZh(Uw(cZ=r?jY!JsyVp?9CPNWwi|relIT4w
z&afJ7T{0!+e-Fi=C&_JWt3K|U@nc(rt*96zff(54#)w$nsL0Mpm*q-7r>rKD6M8WH
zTwrVv;%kN9k8%-Jd!Q9_ue=cmN#XWEy1J9>m`DmsJ4Z1A4ok-lda;I`l9Ixb&IxEU
zCCz#+JNVEk$@>{oeaXbw81u_w^2X<j&lj{0rjx=_&IwKvHrQ(|ersD9<ZI8?z_1*g
zT7AAeOFlb}lfqKZk>My$uQ^@uZDe*>X+vOxJDrn%w7QC*)sB`yKLIV~sybmpV9x$C
z=gL;!Qj!kbe<pbkk<;1^`3BJjaAWx>dH4!scUWmd*ln<eIKC#w^~v@YK<lYJIBs1x
zXS(}LKS0B<)N`Ot9UY!8kKLswg(aLL*nlow^<QIu-nYkowmQjspj;qV<kdxr98P9*
zHVZTT`U}00L;qBNkQA1LPTq$^R(0k#h}XcZ7Uy1<gOx~O6R5ID@_raq{}nXJNBj|y
zP|%;Kus32AV18JlI_E~$Rm3O`)jzeP6>XCW8$R-6zRsb;M_#^FC%Wv&Tl#)UE%aN<
z>;LW^UF+)*Rto5y+G!AJWMo5S7L2vO76DJXB!#84>+bvo>oj1;z}P*=`(Y&liER&^
zEs;EP4yg93J@(23cJ16#ZP-VkzIp5G^mvr!lK#YW^jpIoEC-n;EQKAIrd0Lys-r=&
z<;|e;UHl7J^fueTQ!~J8WJzI3><C)C2WmRw(VwqpbCr@>Tzd=bbXN=Lrp`NAma|v=
zJhc>B%CPncetgsVmj6vW1LB%Di%$7mK9p->AG$xjDySS`>Fk8l-ErFvyh>U#(=AFQ
z)2Vvsj#rI$ke)(MS`EvLjG5&g?x<u{<cD_}phXRb?yq(mRMMH66?mdX#ec<?uT}%f
ztD`9|%G(Y8v76aSfI=FU;!aL{qe3mm^%{k=$(87$z$ame@8ll{GT}VkpLqu$e3b`-
ztfxjKAHIm1!WNN!IQH~5`vxS*`^{Dp-;DD*r_S9*o)4$pmxjwG#;@U3(U{b|;$Hh4
zBFS5nr&&%b3J=kXzEb)F`z9nQEKwc`m$5UFz)X-N-WWSyW=VmYw_fG4v;;YeH^@#$
z2HkGH?>?%7f+QT`r_k6bJxGZ0D;Lc9%~hpqTY42Ep&1Y7(7auB<3><0!xG`8h-M0G
zVb7JU3Wj<mg(boh(BL$%@$TXi!RqnG*!fpaAOow@9x0n-Ut=YOHOEeFBCG~~&5@_x
z1aT3T1}_Dv7rHl&1~=bHVae}Op!n|p2FxmgO!jQ*wXBh1?p*2c<k!ci|A|&GoK9W<
z!w;TLWn8fX8SPor1B^DV)XC_5<7T9|{L{LHuw-`@sUJ;<_|1K?UL&<?&Ado$pHoi#
z47})=6qd>^1>Si7*lYibAX$W^vLo3L(8B%I<rw(dJ}E4bodX@<VOqA>e`kD&tX7?p
zcT+&nAQAP>_z+x~CWR%mBk0m76HVJSP3q{WY-`~bme|e#2Oj_wiQF^@IVCJ+3(LVl
zU5$YQvm@xRxGkW;twi*S(Q%-Qi4Tj~0vZac${)CnPDkRys@nn_o$qI?`p-i*b!aSC
z-u7ZSINUz{MXriqR~MGfj^abu3+mt(`~L5L2wi=k%VUi|2V$-MM{hR;F%p*Gj%+s$
zMTze7JKbK23=fy?R9x&+kxD!E0gZlASgJcR9F&)qmvip}M<QX(sT0t8*GT@z^HRnp
zpwxz?xf2Nlw$XjQS^@@aBzZsLs+U@U4N_~Jhv{x0v%{h~K?CdyzwbYeqAx6_3vA=Q
zmwNOuo0c8}L|3`blj!!g{Ed90z>K=2uyl8{f*@Bf%A0F6@Upk^&R9S+ZR)w&HHrZ*
zho!tDvq2rG5qT4}k6}sg2-+NFLVUS9I!AHj61B}@BtC&{mI1<kn9#i&$W37>@W^g~
z4K|+T?(83m9ImPi&vJiKB{1iP?Ca&*Q@{<Gw**f+D5Lkt)^7qgWSvLe0-xk3g{8qG
zuYjD|bi{|{K*JE00?&aqGAnWY&fm-41FgHtP+nZOTGex@wf+PpK)bbPt)N)~mK<EO
z8HBWUQOJWO@uxE!TpcV$C-lhy_RC>St4rxCZe*fNtA9y+H3PCbtU@l3skt$+OT4-u
z0bz$la)C`Obg&gy;)Wf3ld$RBTI<`rC)Vj)p<A%^?xC{6{`G?<a{e<V5gpr;;sMx4
zN0oP>)j}5SmNP#%#PinPX{CS;9!+;VF>lOx3J~Lr-Fsf0ZgS1?{u6fPjA=b@rxLjX
z)tO02o@G1`*}iKea-aTa#ap0|D{N14+pSpRW)U60@pM?iJMuQV5}@+(UfB&#fcw#~
z6nF|>#kLBP7sq{^8?Zer9iINQh+53E`BD}UW5_>RWP5Ay^u?^d=6IvCjnfpWU%#v|
zAmfSp^Tq(eho!?K!%;G6cJ%H>a7mS{&Tzcbs}CDVr-!9md<CtlC+9U{61=Em0^XF8
zQ`{uwY0??AC1EM@`lR#~x9U`a&0M>z#L+)d%&0oaa1WtdnRZBnH-96?8<Gj{2VC`-
zIeO%jh?%zw2gVGgfT)c#a=P*wCCUrT0AzX)QC^Df2*PVt^sjn$O3~QwnNsY%!GojE
z-mx2;<ghe(a_ORlEJ`<+;-Xr%>}TzKl^m8T&jm-3eYnpL4eZEH4ojY=@KL^soLI2G
zP0i%6M0&ozK!*XQgC@0|xd6e3(?+=P{!T(=+bz%Enr|nq<gk=_;_wA--J9RLdJ|!X
zlT`>CZF4H#TmL$8i`oTyGv0@dt_82ZetQps4=16}C+Z?!(a=zHQBOQO_Aa87B0j@<
z_X~I(oN~bLnZ8?N-`Z;xI%E!j=fsQ3Ppbn~GAz*^xdT0sbaixvz90jHrQ8!!eyWPc
zJ}a6t!YISc894h3kO9Jy?n!*XPVpDOR|(zz$ln}!C!Ae`_zU98XZvBwvQMW?uqPBH
zhb7r_QB@~&cWCNJvY7m$I-z85m7ZSJzJ7U3>?XI#SJ(|td|RHV6WB5*dr!YJume75
zQVHvgzt%;ga0!R_@@X_mS>V`sca;ynK#Lg;^CiB&nNYSDp7+LnkX2&Bp}h~=taU{E
z+_j3Ibejov1E4j|9>lk<`L-_UISx=KEPbA`7nT22A8x1$yd9QC&-n{>lKnUD`@`%@
z+T^f=dJ@}7uqwhcW=bnVgqBickGD)ui|~@i%9T>PZxtd%=f9a~t8|jX(&-I!G<wc!
zYkGB{ba<pk&fY{#gPvgx!t?!spi|&J?NsU^C~slO_1wSVtDVaGk>_^Sp`AqFW<S|m
zucv$e|0z4mu&SE24TGX$cOXb8f{LOjDk!32Vk>qR2DTU|c06KWw_<moVk;IlCUzGp
zDt5Q;9&qoumfY)Q?jP$tKA+<|PVQ@F&Y4+j&tBWLaP-;Q6W+Qfc`f6IL5r^tin891
z_qTMz@vbBbe`vc()rr}wBx?pp?B0Y2A=tZO3h-IIJ(5`a<w}&y6hM6()v=B{F(O$f
z_Wrg=qD@${7?D$}T{=pP7S@Tq0ex!u)vsroa^+~5Q6udpVzeax&O96~r@y58{ADaL
zT6z~+Nt}B1WF6M~Te@M9{<mQ&#(jH83>MZK^u&(q@7^fMX`v5=>rNr2ch-Tuzx>3#
zQTKlnSpA;;i~0+kJAl7`L2TBEuQbH1xYSGZwzyy}W}V+l*p(W;ZXl=PIP(?6=dhlv
z1AGI9^z}E5N{N0HbBuV!pl2!0G?0K!xOc%;7n49#;Rn-*NkHB)CN~KreFkuFZ+dT{
znOSG}5(?J7WI*U&pov!oVwAJa@D1$S*S~+E#NS6vYz;XBM4LbBB4z;bH(-P$f0EBM
z157#ZUTRy(DOVeseQ@9V&qKdWU$$*b`drJCah6ZK_oJNQqJB)*vf%t;6kT>@a`%a?
zx|ee^kjWErfyG1i+8bI$T-Y*74;77HHZnY|G<cb?*C=YAcs}@_6WPA|(pFFUts_sh
zU#K<y88^cpNqi<v-L5Y!R_v3bA%(awiPBAh@lPb2+7wyDx$K0WkCtELlj^p8e5W3<
ze@gzBYQ>{c<DW{H)5;~jdRpw{|7o$GecZB%U&7V?8m_0>DZnn>dk!$j@b?UA!e1;*
z{s6s=$Hc9~?Skz6WTuHEv%SsLYnO?#)lLO!%QmcrhIS!e9aXUR+kwP>MD2ti^;iCF
zeaq6z*Vr3cUtBPl)XoVKe?XkY`R5pinD@ep)i0a$8-Jdq<zDUoxJ~>SxK)v(b$Z(l
zL#RKZG=XUUNWv;<7)Zq8P}s+l5M1pPA^As=46QHs+Wn&bgwjUh@1IDVK8!*nkuD;x
z$P;Sxs?8yZ(k1?hzb!>}$hZG|CMEr(!c*;dVd6JOg&3yu6SAw1jk|w@xZPDdTWBQz
z`yywtotRZJ)|=Q)$fi$jo=EyB<-uicen~$F_EbApXsneOiH_g%51_b8Ckhj|23d&-
z`Tn^F+la>$YG(;0mmCpG%2atv)vPoRB(f7eb^CW3bNwA2NQ^YKV}z1RwDPU2>(5cG
zAy<z7GjmBY*%}#Y?43%rh8%7Gk8PM~#ZLzkJs4VhWF)bHRXau~X7EIA!cF%-tF_I?
zQLa=&D?Ks%i|$_3o_O_C?2NOgsiKu`6D0ZH9g~nc`@yXl3902|mz>l|mw{n{r%Dj*
zpmv7PSS_hv!?8Bih;6Xi5ke%B`_rDiPjn<6`KTQtG}48F^sD7;ny#Be*rIlj5b=bG
z$NToTC2UFlJ$_;{Dh{2AAC@F+xg0dI6U9|C+{8_?jGv8~N}TQREURYsUoJUBx<4u7
zLacttpB@w~k+^I-ByJ7<vHNS_!s1j@DB1lNoUkGIhuddRi^arKFSTQXiQI&nF7XpK
zn!Sv$`%0+{7YMs$&HvYK@;85D(%d^mY`fLY4Pw22e|G0@&GJ6|)0WM>gogjzrzd}c
zP~4}VI$hK?reT9xwTd>nl<@O4?-Fm+CEmPb=u^?&|KgMV-Y(+LTxizl;(r&Dy!J9^
z`iX>NV&V_LErW;B8veI&#9e2S&J;HauRb*SP{05d7s8eH@CX+z->bubPTl+i6K~l6
zeN<BDan-U^7bL6wKW%iW@z$M9%>H(P+@X%JtMi<2H2K&1Nk<Ei2MumyoVu4-C)Lgs
zCbm!lSUj=+N7Kb?FB3n)?3w)0!hdQeK51NXw|N-V97?OZvFd-%MhN?NM09CG+}KNQ
zGWI9=95Ax*!kI+-!m*<Nvnhj0P3<eSypgZPCSu6JX$2iL47sMK&J=GbUd`Jt$;Ua4
z9k(<wPK4kNd?u=chwl4#NVKpybb^?<lRrj?OmV0s;So*3c$4k1xIpWKUu_pV1}r#P
z*`YnICFr;9-$#|lr$5O|j5oD2gnxU{@SV-1=d-KX?DC?(N~^jACw={K%}W>4B|WR|
zsdi{kg8w~FUbpUzNUC1BJSIOVDpK!nY2Y=h5Ai5F`NM)RG7{cV0`HzMPhp!faS9b`
zSKD}erlnzMh$~&f@ozITbHo3=YP8{h%nT1Y{M-G#*G*-XQfU6q!NCT#1ut>93Es~X
zhYyJs7R`}f!>eQBm2e#pG@wc2{|A%>p6-{;)7Z9J;BpgCp+X5<ImOTPeFZJ>s|omb
z4gY@?%E+!3cXEmoHDXhz1=cmRWMUKkUAO-qP*!L?IMXcS4p9qSZUX+*_x}N9g{v&5
z_o6%HiwXF5N&bI8S>cRepLn`c>ZCA6{wwSM1Ih{)c4{<+u5hIZ`1e-w{{dx%Te6I@
zpey`p0{+!g4R~^0jhn`)L)$6!QyL@xT@clPbwA|~F`lf|nzzabWDUc0MT?ZDhv8=v
zk7Zt1yRQf6VOY!JZ(`%In*WzrcJhK7{@v+LUS<L+M3$YrY2)rUbSHl@0a@mSU)lFw
zY#zj=?c_SCjFA=0lNHX%P&*?%YSx>8Eb~%X*Sl_fa-ps8w+YBHFP(Qt3h{}$co?n)
zwoGk|%rdWH-In8wPu8`-eI_8wyamIDIMP7tG{y>9=CxaOWuS4`Xw4gD1hPg=*G@T2
zKa;IZe96RPnO80E+<4<D2QARWuudneD8|DqYUbti{V+~^#wb3y(E=x%fGqRu%Q>Vl
zehj1qzA^z7+EC67^|lQ47dsvCL_iB{kk%NPW#0ae88R9>Sqls|0Ts-X6;7RSZ!$f5
zr84-Q*eMF;$+;mea_>QUZfI!&vdo*;!=W=hVQ(=3S?0z5ZhfC_!&HXb!NkZc^S+f^
zcHMaRSZiKuBT%7}WuIINo!Wx#lPxBmf_W17>}j1{G|<BEt=WXc#&ab9&pg@5W9M(4
zLw9lu6Od(I)+*O)(VZM_0<z3=ERpIgy>GBE+~_7oR_GKN`JU_g+w`buZUVB*i*FO$
zhVGOtCLqha{#DFc(aXGrVMmr2S;0IxY-*IabXVNLC*3!6FacTST?s7kgRU^r1Z0`F
z#J#3BZJw3kKPN<H^~poCcf;w#Jxx3X^W><B@mgM)7UiS~$hyzVklLaty;HI={GG(a
z3g*d9_8fTaqIilTpxPBB$OKd{Pev{|`=L3#vAJXdDwroLOcPgX0=<_jWtcJ&BP;Z>
ztZ??KsO5Bp;s!Mls9>I~aQXEt&UA$zO+W?nWQCR5eaJ5G;?j0XW5XPjSRu>2_iZvn
z(0i}VCLqha;a4v&7Ef2irCswf8a~`isF2l!CtdF)9G@0NY7@6G@mS{di|n(S-plPV
z0Ts-Xom}<8fdcey)7tR=l$cn-JlV;QUN5g}{HRD9dAJFvV4ke-dRX8YdbfGU1XM6j
zRycF}2oK}Uytcw}hAAU4GRr*IVQCr|)^js)X@Q|8pu(_`6?$jMT8OUjo(ae@@8Dt|
zYZ~ZgSQru`v&?f!xvnG~d7KHzGOyKyxNSzD*1W4mAS>~k36(d{i3=LmgoMP#vk7XO
z!#?S=EueuxCZK|OvXjT|{&0&1o-qMg=H+a^%97q~+8VYeiIEk|lNE-&ZkfjLpu$XC
z+CCXz1hNLr!qd&#8E&%8#HHmOF!ESq#@yr34CCiJ88pwYEe#V!LSQ%J7uD4|IcR#P
z`$l3$4Y3svm1k`60j~Lz0j9V0X3`+HAW|~L#}DL#`^1hB%=e3}ABdfexU|f)hN;&W
z-1s$mLv#gZiUaea#g0i_T4pz7$`Pr+tTNoYxN)DTWgbVS9Fz*oeTSlajM`|K`3$S9
zDZ5+|6qtP)rN}_n8Hh}|C@3%^4)?OB>pX)@xh^O$cVwEF*}>31;?ib!FzozH+2us3
z!0g#4?_xUpBxFj_6`1xXcO^VL7F=zekB}*4PlhQztomwG;w7zSIm7<Nm|b}W78;FQ
z<eHTp@>3DXQqy<9VF%+mIBoQJWXd{|i7x8=mGM<LU1xQ}UeFYsrRKHKHN;+m(0wH`
zS!%BEcI+(fGsUINF22lQs*|PWhl0*x13)m_B9o=&lCNE-i~Xgzv~@-zlci>*wM}E_
ze$QhM*;#5X$TY*wxS(t63`8bN&B3)s_|tWsMJ7wl$aAMF8jqZ4S50TbOl9nMIXrbg
znwBfvHuEmF#^+Mn=tB_6QnTf~k(KFgzl=<lnhmcX457QIxZ#J2Owna_1>Nsmk2pei
zQ3x_wYPLRcB`3{{MJ7wlf!Aw~p_$%>(`u&dEHyv;Uh$mnqXo!hsp;kQXpHf3nszLG
zLMBViqPgo$rL)&Dd=1T%ou%fsy%DwO>}!$9QgeNpQf=r}Gi5<pryNQOYA)WFqYbTQ
zGeok~oP8kgLAr~!A(N$MrIFJH(`s5eL3Eay`)pF~Fh1(l4y6vrl<ldjyXfe|SD%&}
z^g7|?nMqg8BgkZ_=^R#a5#64)&X8R}O<89KtD-+ejY)4h1|m~IP02JL-0`~Dg(S^>
z8JP-dN@niU{R+{{5``c;OU)Gztc%jSrBGzD)GR!?eQ#RL7r>O=uAt_WM%kXxWqKEu
z(T(5RR=Y1;o$`(8%ir1|zX+KuHNz}oO47sg3o==1?(!`@gw9^C2xM1KQ|?0YzNpll
zW^P2L>?2*>CG+T*ZrA7yt)&apsi3B07LG~vj9!hpAX7n2$s9STYh60~5o9W;DVZLF
zLn3LWZBfXspr+Kl_l10I#lHksJ3fPv$x`!I{#oMVPs15pafu1vc+m1XFl84hs2P~5
z^I<x=OEDSU_-$!5HS>jxF{d>OL8gM5vN>~{-rt&@<?kbtrRJ-uzgmb-K*Xi(q6)5%
zouy{&^8u}C<}zfm)J!+O#|!aUh`6+MrYsJ1%6?bSeP{Wisf-_oXqnxRsi3CpBab74
zrV6I`!m^ebjZ6hKCG*a(E^cCcCSBc&mVoREYD(RsEo)t%r@D#AWU1M!%!FIUsZOhA
z957{bDyV5y<FM)XWVFp$*-b__emz-D%?%;tve41Pkg1@iY|hIs;xf?8AIM~>+2cdw
ztzr;}OPjq#NyyGpvvb<srh`LT=1yd?)U^2dXqd6vwag5qpiY*WC+cRJO1EcMWXiFm
zpnD6CY-tUT^%K5mrmgchG8NR6{hr;oa4`L}-^m@aE2t@Tx45*gtze32L|f;0WU|z}
z@^Fna{TS#mFlBTFHIH~S3Z?J2%9NJT;e$MdE_#`&U}gHga4s@gYSt~(c$48CJ>eBJ
z+U9(NOqQC}s|R$Zhf=FDke#Jw+pdkLiCJD;+BzeV$x?HVS;ZpaLBF`POsld`CrizD
ze>yjy`=}o>S!z}{OBqj3A<@W`<5OWQ`L5rXnXa>-2V_@JQ|eydqeB%Ts<^c6IRcq1
zH5-opSu=4n`|pPK7BFR*3TiId;&y~C)74W(H-1A{ZPhIP#@UDNqDjbPsX5}K;|H4g
z1eq)~O9recWNc1t7gZ_;*;#64+cdckt>zqLvec}0{b5CVg?o=omYVB(m<^+u4a!4y
zmYS`73S6W6C>)tAHUIl@v@6}7X}zFMIp!5~uQO}(R{Dmk3o==1#$?<QY#dA44ebG7
zN~D6C)lOClq1DV<K}I)zfmcn<tXVd`r@OruGFfW6wcI_OzK1)5OqQBw?JkX_yU5iW
zva{5D@}sdhpqTJINv-bVk;zhXRJyaCbbH=Mrh=NHrxTwf@9|7MS7cAR5?81Q*;#6S
zbDQlc?uW&t%|08M3TnzaXD+F{Oth!i*=d>IkjYZh-2BvMdd&M(g6z_xWONrt4o2^I
zxx%QX_I%M6$&@2L88Zd(&XTm%=q+-J%BCufFV;7RnG8}K4#<@`MG-o9V??q(j<F0{
zR+?sRMW&3NOk;{Vv+UirOLTbBPS4;2(OI&arODikuCpgH6=WBbM2W2CRI(N8hLBS`
zI8PyyCHv=dxe}gHioc>|7OVo<6=av&#G%ug^rk0}(a2=U?rEJiKh3<4Oa<9xomode
ztwu8|RE6v;+2fa%IBqydl<+-BZF??4CQJ5Fxi&=`W!J95e}E~6yn>p$t)K0tw;+Di
zWOUG7L8D!>T280eqOHi3bt*8uEIOLL6RB;^bk(6w1vRBc+2d|k5_hjjA24)5rh=Ms
zC<ToBn2kPCcM_Q_HLu-sc_|)*h)bJ2Uk%94QnP8>7WN`{((J>K$x^dw#E((*RCf=V
zEHy7&S~ZHkdo5QJva{5@+rDZ9J?3X2lclEF!av_=HQxeL4o?L&iyZfwPIr4%Um4x_
zTNi3u<h1z~KBSo|k;ziC)s5jj=`C`KT2QCVuAuv~s*zLZF7ihvOU<9RHw~hhQOIPe
zx$|zOOmutN)rRaWHMjlD8AR7P0+}o|uWl$XjNT&OMkY(m_gQ+z(#%SAAUjLV1v@6S
zv^Pvk;?hoatC7i4v*WiZ*=RL0)|GY2p`@T@zwq~6=-IOaB3T>S{mxlE>25!YOqQB=
z{u^16erRD|52CZwEc0r41A52@BU84gg6>m;Tbk1wuv^GvsX5;J+6g+lM}5f7QZr^%
z?mToK%|a$i%`Z(Jb)a`kZ;{DTGeu}b3wnIkY5>_;YQD1dzC-K237IT4Hx|kfOW$i|
zZ7A!M-L9*q+|-Q<w09Q6GwH^r6CxGVl*}wo0yBsePVDEkvr-f?71Wf>kCs0Ze#KY}
zdo8nIBZ$sYbBRZ_ne_eZXk@a~ES9I&ZkqWJnX-=*be}hRs`$DWai3k;53;k=%$@OW
zF`Bs?nJhJXPjNGSYhK$&=8d6FmYNkSea=MR7j{4<OU=2v@;K4DA4euj&GRi|Q_!oX
za}$|ec9E`{^4_Sxt`pJXeoI{1<_t!pf|`=~$n4z%dgZu-Oa(P1^Tfi?E%Z<-*A$|&
z)NFs`gDt&DUWiPVnqDnqPud&WQe4{h{Dn-GnipQ@GyQsqmg(ONvdex~(0ylz1#$H7
zj7BC)&AhpT`_ZdW(dJMmOHH@TRjufLpMgx4nqFJ|iqm8M9Wq&J*1NXVjaIW!3z=Ou
zr-GUT2et1(56?A-WT}~b{DEGynrT}?nJhKOl<K#E-h6gNCQHpjHYu~x!}A0(S!(9*
zGP5#0lnS+i>?}3YpPd#?_fZHk71WfwkY)>4)e`NQbY~NfOgWZxb(hS0Tf9DrA)l04
zt2Jb2skygU&T@2nZbT+a&0VKfi?1RRJH_;EpiY*WE1T^fO>by>0aHfTRZ})+>z5lH
z#VJY$!=;^(4<VAJW{oOKhSJUH)K*3}{(Qmzd$c6$%r&iiO4042NwszUhfJ256>9JF
z62mCzP>Mq)OU;}2<2unA)ousb71Wg3zok81kj@^COa(RNE~I&(&{)9~m$p4Kw}(0v
z)RfGe8`u7(nSGHd$EU9Dk~y*V^+R-f#vqfWX7v5ZA84j~2guG+)9&2%QS_=g516t{
zT{UHN=QQua=rZFG$x?H+^UXapvtCCT-T0#e|4&U>=byp>vuNfvWU|zB=sNPSn3BY$
z9iBNlL7fU}N{#ZJ+LN#vC7nWsBa@}(=5?*S#A6`w*hX9D9b~f9%-^kfMOve>ogq6*
z&5=K&($PDc`N(9cdEDP&CC&VTOgZKibg%Zjzs{!;P5mJ|OU<Q~A8e=9+zCvHR8Vtj
zw)Z-RoYQuZW%AA!?O)ckvKU55hf)ACSsU6M@B2B>U33zeEH!_ZxaULP8##4_><Vhi
zDP;DD{MqO_CnHlqP05VA-OcpAI<1;7kjYZhvG%wB=$npu-5@(l&CSOHPtm$>LMBVi
zbp@}+&{J~8?ocO7%}(+0tLQ%Ji%jWJGP;Y?Ksl#B2{V44tvz3KK{Dm&OvX$>?AK)H
zlC%bk#HBsNP$0mR96r@d1}V<%yv(@y3*DH3h*VgI<ythsqCk+?A}3vot|5~p`-NLY
z%g}X}=>gGYb0*V4B76A_mvhp0F$<8%lKo7Ib;sy|^aGhJ*=KfH)P&y3x9kboS+cKf
z)ovs$=0Rk#WRE|+Zvvg&t{2qFl0C+z-V?gtM<7!{b~!$)wkg=!$uK^P7%uJP`4E{b
z*@qO#`;%6)es7sw4tWJNcfOyL@bmVfNwsAzMWlk7=?nxjGcn|=Oe^_|Uf+HrQ`V`g
zk!;SLzST<$jYKzT>+IAAqO;U|+^E_(y4#N<Q$bBx=gMmp>xnv(-Vqn-3w5&8%(>R>
zBt7IOA(N%%oV<Ig&`%hiBa@|OxbMJtG33Ri?IYiQke#LG+WxCA*&2A_(lU1=Q$bBR
zK3}dI5k^l-`T9ehEHyVwzj&2?urvaga(F7JIWoG=$oz)b;?hRHh)9;2nezG!q-XhZ
zfigP$%!jU;vN^k0M~<e4(h_9K?7B>;QE2eF0I^L>IxYQ1rh=NX&Mg-PJ)&3Q)&n5B
zf||0<EuZVRrFS6*k;ziCbA?iYwC=V8p-z^X)|tlWOm)MN$x`$7o~6@ijUFIVK~347
z4>uQ2C)!hRwPU{WAjr;Avxv>ur?i^OfhmWQu9~vU4MkGtr@Q?FA{Eq>%+9-;bP+>d
zaJA9>2FvL1J0J=gjXn83jIMJVGFfW&Kh)fst}|;8)G6Cjw@#_%;4F(%3Z}TU+4~?<
zK~2eAeeqa#dU&2gCQHrUtp|tDQ;6#j$j(x;u=~hh(MRIaW}l8smYQ7`yxdD?e~U~7
zHD!DDJ<#nNy{l_D6tc6_^uDro8?ELpV9IXSRa2I^KYi#@dWEwLmSytZUzGk&Rc|_a
zPh=`=Xl0#CmqyN~yFCV(3TjGbwFYnQ)5Ftk7-UyaQ%+0H4=%=vO>)u=?JQ)<K2p&A
zcIjO&>Gu4LOqQB+*H6&-^tIJ+$gZHK%)W5kstt7ZgUDp5*(1F8MB_c2R(FRHP$x^x
zj_a0R7NbC1T4sM_veaA_^~A<lr}i<>F<{CrQc!bJ%`GP^4JC?8TV{@tGCJ@5MgI-G
zIMFzRXqlan$x^fV^L$gp{f4--%-zUjsd+yA`J;3f<r@Xr71Wfv*P9UbmS*-rCQHpR
zWzAO6eRKqwvfmYSUp;U|=`4n}6qmL=vyO)B3Tn#ic8ix(rn7fPCQHqwS<dyRnfsB+
zQnN(5H3>f=lk_u*jAI}>OU;>sPc1i&d99iOz?99YpysPNwYz6FbdR{ST@;B(g$=Fj
zq9gkT*P@x($I9qsSZc;*yq(whNtCwE0A#Y%taUI&k8FnA;?gn?A(N%%^yLG7(AllV
zL3Wm!wk?0}p*8A@OqQClkAJ5(ete+KehQg#EGg(7@omOBx=!2ike#Jw$$?ReXyzbf
zveb-U)UZ39{X8;RYOXs_YXrS&I{qiK%jgPf#y*;9MMociNS2x{mUvyDhv!*jveazV
zDn~V1%>ol3I!jGI$NkPUGYFY1H61skY(r;1hfJ25tDGA2rkRc*ke#Jwr;RT+(ad0E
zvef($-q`d7Wv%X)kSWKfg6<z;eypSW$ax}UXQ^qs^s?#K>$G(aLncejDi7utpjXYy
zz?5YwsJSHjsEl+M6`Ula^WI-nYhPf(&pHe4KhcrNQuC>mjSF4pWn{9{>@uf*9-3KX
zGGtd!Q{HdcINZ-J&H{=5qRl=UnJhJDjVXVL9-eoQ$x?H73cH1LcDE^zou%g04n6zP
z%n)R<)O_sjG=R>2ADME@E9gEXDrE<{PWMpA&QkMe&ofzQH75g8A{EqpS$kqGI{IBi
zvR2J?P5ff%=q0Dh=$<S!3*9ukNHZrQlci?24J+meg_3IY0GSGE%FX=T6*(Tzb$U&M
z>?}2ZoE)$7Dy&(^WT|<iT(jbIzrR2xOHJ3AS%1;lD^7>(EH$fq8MT>a&P66m&EZbz
z{AuPZWJ-^c(OsMdYJYaZiVTLalz52;md4juSDj(XE=N)_W(uNP>7Q$jMD5+{Tp&s@
zb&+!282Y@&An~uHA0IqNq+})&TpVI3Jbc?PdfQ!XrVP&eeYCgPo293jVaR03ex}Rn
zlr-}bGG!MjWVe3g7eo)Fy0aiVOZM_scRJE_u0keD_T0aY6{73>iA<L47gGCJiam(9
zw0jW0*^r$jdvK*iQ;qAJmKlyrmh6EQ-Cxp7^Epr_OZM8YX1@?qzPPk%HU_3#-*nZK
z>&BBQk9_F)cr_wfYWkaP>qj%cBU9F?Fy#B4n&U(>>(7<V>BdrX!}T*6=q_4?OqQBO
zTUl17A6k4tCQHpqMH;3v&dA!~S$7^}XQ^p6z`Y|~=W=AS)QpMk{D5YDK_*Mh(q`2w
ziwA$=`X~E*$j(yJBY3I<J(kuYlci?Z+*!MgeWX?MCotvkR8VtY`uKzN@T|W;Mu(HW
z3L1@x%BZ8}3S_d>Oi{0`&J^+mnKHXVo!8<v>)aXDSqRx#YTjz@a*S@z<;Y~IIkak2
zXL=}oL?%nk@26%oqnW;oAUjLV)iV|tezsctboIX)EkPzrO?S)CO>~{_kjYZ>@qnJG
zjT&inuf7<vv((I&_wYC)Q>*4eV9KGSpyrdWjZN=e(U$oNk*rno{)V=X=;o{xCZnsI
zFOsYK#C;X^(abr>WU2Z7<E|m}EdK(TvON`aziv6{3Ozh4ErIMTHOE+g`a)-)g-n*3
zgRHJKrn5goCQHrh&NfSo!&5t!yq7|DmYViycV?jLoQX`9nss|Rwx*fSkjYZB%FOa1
z^oG`ZnanP`T|v#LY|G!%WllpROU(&~Ld()a=?OAftLBSaHeG3Ex#bX@rDidY;$E~y
z(~!whGctN)MY_&M$drAgpnKz14+@A!72?tk`LZh@J4?;W;hPrG{XP$wEH(EJEa^<E
z`3jjVHMhIosY=&bc_n0LscHAS*?O8e51A}A>zE%cZOpD+HD3W!c9DXbpBqgsY(#3i
zz0xWfop-*d%i>8p>FBeO$x<`Aj(KyM`2v|NHJcvV@P=kqS`FD*YTjEFJ&%55GZ&dG
zHLd4oe@NH)8kw@+6?D%L`QoCLL3MFy`@QNK$j(yp`Q+Ty=_zD2GFfVV8lCY!`f*jN
zwNNKZP3tH9>eI~D$YiN`HgvjaldM&9J1}K)DyZ41LBUq^ET4LvjL!RgwB6Nh+tJZm
zA(N$Mmza8YX=Vg6S!&iOoBAcKQQGy8ou%gGg9o3{8g)P>OU-gAJx9=W?nWj{&3)4X
z>e9^28z8$JOA5MQ9#X9fJ(jv6lcna^Bjuv$evd>ZOU*`218UOD>>D9FOU+65FXlGx
zz_e-x08>U+P;>9c7whRVBN55k&<20lFq!V6?3-kCmG>8=GtB9U-zt6f=DE&+gKo%V
zsTmpVn~%<Z2$?K3vvhaTITVs>Gh}C}Ss-iEW^|pskjYZBXRg6IkAaRMlcnag2+taH
zomSzHU5-x$-P;!Iew=3ZMJ7wld+W=6rkN*^$x<^*{CJ17hOsIxt(vx5WOiAmf|@5<
zOvzzHYBx5$5y?_>-ihWeSq&wMOUpcjOxCJdZGOaBdX~?#6{54${5@b)D!PmMB9o=&
zjYlrGY34~}vec}){lhSNCAQrL*%j23pJ(qaakrxQSI#7TGys__H8W@3*@f<-i^ycD
zxjQVZDczohA|SgQ^9s5@4E>#nW{yNAOHHR?htkli<~3kSq=K5=?Am3a%Ph2AM(4f1
zsM+@e*5Y$0acR{YiA<K7%Po5P(Zlm5GFfUmgj8%#GmGzl>?}2Bwtj6+-@A`TCQHq}
zv%F&HI&UIVK~1>}d283_5zQ>V6SA|^9B=#5K}^Tu()Rm!WU|z}+RWz`JwERtlcnaj
zpb_6_X6ap!U3!#^?&37i-cpl7jqRy@f6)}ll)avenS!|H?MruB_6I<eYi2S?aTciC
z^m0{bF-z_?1$QqYnaKnf%ypfH>)ahoK_*Lf>-W_=8yizQkYbU^l0AFq^VBrca}Q)^
z$$rSMfE&FQO+%*ac7^ur(7N<6dT_=elO?-Tn_HnY(|a#uXUV=MX5vAbIR}|6+4~0#
z4WXGYk;#(%-tC<8X=asukewxap4mmJ827W<E%HKO$|0|yX68E8^3r9#KqO1eS1bLa
zXlCX8GP;|rQ(<^cpVzVh&76-+mYP|t({`enZ;;7Sv-;Kh&c-g%P9fDJAv;UWLz{xT
z(NoAgWU|yuzrC`~@O*_#mYO9_Y@bfIXVn9couy{326^hy%tgp#shRKH#gsJjJu+Ep
zeu;lGo?bP556bLvcq*t_`{DLhbeW3~$x`#k$-#m2%JCkVEH%GJj1Q)nwGKganO#Bm
z0`@J>(AifYlci?8YG)SF%x}nKshOwAx}!9+!C}bGQuFN;*U#egthlsO$XaBw)Z80*
z-Si9BT4stPP$x^xHw8OI<~GzQE-kYeGFfVt>yhyg{or#KGFfU4?i#s^Rx^E+%r1wL
zf||Akoo9%L3*yp7Z-Ypdn(=$W9qDf0hfJ25olm$-qM135LUfjz-D}RiPp?LOkty3#
zLHAM3uD+w|Jb_G>nr65Ei=vqh#~?dP&F9BXzNE7cL#Be7;_+1Cj~(Y-X7wwV;a}p@
zQteo}giMy2C$>-3Y0nbJA-jT_vd+RK+pQGsDgKML&dJDRsk!xq*#KJ2r@)lmuApY2
z>C?v34?;Xn$mqQH7wx%!tPS1mQ;^A0)5C9GZ<_fCnJhJbM2s6sPfH#rAv;UW7rWBV
zr<rq*Df>u4_Y8;E<rG6+T-u@Z9+@mP$2A$-kgl`ADafv%rhHhHas1sq;!uRRv~_Mq
zCQHrOd2=Vw*)yGnIu+EEb(UDSqbHrcCo*|z+8z%#-pFY0HBSRmc9DXbskgiAq&Ey!
z(K0&kd{OB9&kgb#x<_2vE($^>OU-<J7DU+?c;eDBZy}SVW{Hijed(d(eFn0#)O>m}
ze^F~gjpEYQxfGc!HN$S5bfB}RI16>kepk?aQ=9zJbe&z0$x^fP=|0mP47tUn&3+o0
zEHzK(cpGVF;E7AiEO`#Hv(y}Ya==&m(dPnWvedNk?bDfFH9r7THm8D`WtudyrtjgZ
zotM#h=Zk_H+|$`8h9Q%sX49+rkI{90KqgDg@2S=orkS-bKz5dzWd?WE`RHUNGFfUC
z-~HzXUFSDsvedlLWTg+iax}aM+2vSL(7n%qeSPSScQ`UxYUcM#*@0%Jje$B@YIb^j
z)0xiR8JR3K7a#X(Myq)Qm@>M8nit#~Mbl+wza*oVW!-C@xsv56J(T()lci>bA)ZC)
zM<J(>$x`!O;V4_0X?Gd2v(#KUKhsZR7inktLC9pOIk`_ao%33!k;zgseQfzX^rH~l
zE0CR~rk#u38=4u2OgTOkbRXLHoekZdr;y1~b9+eNKXjeeS0Ot~%{?6g&e9v&zQB}a
zDyZ4f&VD#u=3zv#)SMo6CZ4`8%y~^l=lwofsi>J#=zHQG$YiM*8S&*5UFRWWveYbp
zpu%gq&YagFJ4?-81=rT1>+Ft9mYN&wyZO@neh8T?HKSY1aG*8HaRaim)J!urO$)lt
zuE>;QUP1Q>nHvYt%t&Oi)I4{uqRt!Uv)+{1B~n4nC@1eKbaQq>BumYJO)=p#a~CpM
ztL96G2|BZU+FKBvrDovTenIp-M_XjF)a<$Wip~nR2bnB2_gFX|podb%+mM~5W{$Nr
zH`C0H$YiP6bEnl>x;=LzlclEfeGi>)zh=Dy*;#51EVI(|8Zhn7rVBEqN6F|eP6K%!
zx_QtzeQM7a?UhW~L&=yah;<wF)cK{CjCW1R;UQ2mNO2Zu@~~!cbf>pNBun=6Z!NCS
z%pJ&N$?h;N$B#6IhYRA;c2L@T5S=Ca`Wm6@j2)z9Hb*8)_P!1+cF@dlWU^#Ga=}JN
zOpE)FT@IyW2B+xv@B3b_ru(P`GFh_UDOyeElhSZxvSi=pd&PyWGvx!w&XRqSms0_n
z*&LZH*%$m+YI<#g_L=WyV9Ft{pk`c)-GOwOe-O!1bKf%?oi8voekhxhcfRPx{-6%@
zkYA5XmYQZEKU<44sp8VA`3IRSHMjeH_)NEF^GA@KrDo3<x2-gDGcs9fRt~CEmfp&z
zh=n>8)D)jLCVo;{VUI_`TY{6eXH#Ud)I9Pry9Hh6W@NI|99GV}YdS;K;?nlJ`D4h=
zQuAWnR9EP`S3h9N;i;hJ^fy^{($QBUlBH&rPF4P+nO~48rx4v)UUqxo9j8`^hd@cY
zz4jB?oF!#;U8d-e#4p2jvOJrb9`Y-Y$x_p|$?rY%!>TXHWT|;K>%==Wv))t4&QddC
z>Edy8_SMK#P*b*Nzlf)2={mn7lclEp`X|F_X2Uqh&Qfzl=%d|YWQj|w<~n4u)GXcn
z?FZv+p?1}@cqZ$VLrFo+YNexE(9xSBlBH(4(|)(<Zr_Yd1vO>2=WsppjIJ}qbBNAT
zbAwm*#&n%6kSW_!LHF=^K00cKBa@}(wXl0j=<KOpKz5dzO|ypTyw$cfGFfU)`0s9U
zy3Xy$WU2Y&N%%3EnJyl(v(!9r^Lz;1?;ViIQgi2(m4|6HcL7s&yMmg&)sI}Eqg%d|
z(Rt^KcCP90f{xw}nJhKu$IQ_AZs87Ovee9d{?1(ECPX`Xrhf(5S!%wH_VcDc-fE3Z
z*+&Yx+vd8g^WC7m$YiNmu#-b2y5F<BhU_dgbMCg*`HpT^WU|!E9>29J{n6e*WU|z(
zWi#&_ojunZ$j(ypM#&AkjAKc=YW4!A>>?F4cRcw{e@J`)k*rlSs%GDBG&9dz8ND=1
z&7$qPuAuKV1Chy6bE3b~Hd>?8$YiOx>9YF_x=yEeke#LG>6=A%(HpQ~$dvuApu2ay
z^Ec?5jvL5iscCbon=?J+i@t~KEH!_fDr---=U8Mas3~ubLMC|T6U?MHM>mnlQuFbJ
zW&P+?v-k&@T{fqJn!~Gh&Q3=kjYyW7rR(_Br&rDE$YiNGA?{o;oo@dK(OGI{U%Ahh
zW{yQBOU;+7Hf^D^-$Eu!%|m8ab#6L}e}e2RHG9t+uk*%;|Bxxil7jAY*VmmxkEOfF
zWT|=n?CvV`s#)qYWLHpA-W;u6ckT_{?~{?qQnPcF4?eV-kANwoE2x=1{fa+yneJa?
zbl&-*TZ`Z8+`3OjCQHq*uzXYKIv*jErRL9|DfwuPJikJAmYQzf{TI`9PDLh5&2145
zTWIDJWU|!!n5Mu;I=k05$j(x8u}dADm!{4@rW~INy3b#E(1XtY6qzhFXE%;bMQ5+@
z9kR33Ol?1EJ+0<UV9GKT)bw?Ky^oIm7?G@1)1_HhLz-Fshm6iUUljZ3_e#1sXCjlO
zW_(z~BQ!G(nJhK0y?OVR&hGUSva{5j=QC}!@jga-Pdp2mEH%5H$?%R|jUFSDrKa2M
zKI>_w*DuJ<Qqz0fe>z_xpN&j8<`s1Jdzkwa-AD1rWU0Aj-0m#KKGNQ6`uvvJB~n4n
z@i&S*p__9iB3WvltFbpd9sLC|S*zyflC^cd>t6W}L}#gaJ5?c_@A=P1CQHp3!LJ6>
zy1zjtOU(y;Z|Mxrs%GY9UAp)5Z|7E`v?oi=*8>A`(tWfDnJhK0n$6dFi{g7^veYzR
zWoAxql6}n~J4?;G75X=%$NW-cN{^D!U7QB$w!P3{<Gs7~e9;%ll&zVJnS!`s?3=yx
zI_#UmlpMavk_=LuGuhfa)|?K$2$3w=bCvz(K{G!fQ$cq5Fu;9kmI}EH4+C;1`E;vx
zN{G&qJ+ykB_VnSm^~hw&em~DJXPTMP0_tSR{y6(mS9-v=K_*M~&P&fGJX}fS<}tLY
z@yGkNBU28~WCpw#OXJ3DX>A<v+WkV>RFIt|d+Bi(HtA$XCQJ66mW!9t%<afz$zCLL
z<Rn_nw5erwIph`8ERtiA&MUiGA(EwLlzV?yx{J0UQ`V`_?X_lq-%mGZsx%OtrRLMB
z{hHFuR>)+jIW7Acd!6jaWU0B-X_L+o{8W~Zouy`}&(3RgvLlnF=7gTRri$mNNuQ-|
zLncejAnRPS=xIJ(TFA~)vrxtY$7yCqWU|y;`y)?(dW*adm~wb3s5z|Jl~;6`>C(yQ
zyx&KQ?`@&;u&N_6S!%j{>>MZNc5!KE<h{t0*%fp@-+S;AdU#r;hwKV!%GLeH>f1fU
zswqB>($?7rnJhIoOp0)!bw7<vmYU(O)0CsL=gR=uS!$;6o^qXL1|pNCX58lV1$D9`
zlci>G>xO6OI`d_O>?}2da~vv9ubP3tltW2D&FfQcIniYvM<i?29QrZ%G0n8jB%||w
zAMI404xi~6xgRoFYSu1z=^Wkd(a4nTsi6BKt1|6`sN&M9X`30cv((HxAbokdJ%=Kb
zrRJ_xqps1+i^ycD8UN^*mza{0PD@T%AUjLV)G2x#rTb_!GFfU~IMF7W&VCh{EH!`3
ze`!gp>5^4um))+Q=8R7h)6qkII3ihUF7UU1LEmp(Lndq03>s~(^EQGK*&sSg&24`!
zgwl0}Ad{u$^o!rl(rP|JrtBjH-91iJn@=;nvqN^4nq{Y*uSjdO5Sc7B-&`)K^Gdl-
z$YiORw||vy^g)vbIUqYr%^qV~x1-hEj7*lAn}*LQYJ8xmede1or>s+Uk%F4rZca=^
zcTqD$vea~1{iGosJp!35HUH$h=uA%`mboB0OHJ2Pp}WOnrKFFRIv|s!X7k;-Q_&h7
zMkY(m2DMwAr|Y!I4cTSCE9h?KzTt*=tR^n)>K=?tmYQipJ2a-5H<8Iw^K{X=W9ac&
zHV<THskx>6ndbD((M)8r)GS&j_gQ+?d=E_7oC<2*`FwXZeXm*7N=ApLz6#xLle%yO
zy&5e>CQHq0B{yFZCq%@h9ZH{($x<^{n|0TXGo6-MGcROkso5j$g1x1oMsaDGVaQ~u
zInn%XHDkAHnXiz^QZvhev2E$>m8>DV97_uQK6FM@6x~O2kjYZB-S3ly>5q-#kjYZ>
zd%hX(=sLY^AUjJ<vwOe2jP0piHKzkpMpsZXw|CFEbo9rFWUZQ==C}8uhiCbGGCJ?~
z(Ke=@S&44W$;f1>=`!g^AkDmsOqQB=-oMp(BYJUL$j(wTEM0jIW4CM7{12HdHQ(Mn
z+l%h^+sI_8x%|Whov*`{w1ez&d@AT(<zbrV^wKdAnJhK?oG%|uGan+8rRJzcn=>2x
zNUNr&z05AlR8aF^iyk%UGD8u`QnOfrRys$ko*<L8Y94F(>?=K#$~i!EmYP+s?bmt3
z{0wBW)GXNgqt5ZSXUJr!+30Mu$#nJ#`5`+?&CqMslZ-=2tNUzZveX<A+hZMF=W}GT
z)EvKl$1}RlN(CUh9P<jg2j4wqL)SS6nJhIOOYJee7)Yz;OJGW*f|||Vf2>HC>Fp?^
z^L`&~W}WWtbaT!@CQHqltM^o=>wJMsmYNGoooGteS-Bu&XQ^4a-u4yrR5uryEH%%0
z7V@C);a($?rKb7F9~SiUfI3c)ou%e(pFDl&_FREXmYR)IPj5{3`xj)g)b#9RZb38a
zIYV~oQ8KzGoG)5+E3>gZwdadgOQuYojG2NM;~Rd^*qU0|zX4IMnaLo<nGgp@`)qXZ
zx`j-^%kq97?LwQ^&*>ZYRmfz?p8uN5M_M9_!cZqm_Ab-kjH4d{wMHgO_N;I7>ipdA
z9%Qm)_jhR0+BlH3Yi8ymkewyFZOYm@@2vMnCQJ7B?}NJ04}qePDTjPA5{dD7+12j@
z&CKTl*%f3LJ)QV6mup`$M~LxhmE;LS5HeY^H$46;lveWwFy)X}P;=JD%_)pXZMPRK
zDx<qe-4&WMd(dw;nmHPovQ7nNnyt5V-idS#nJhI|Z#rT6_PjQ`OEJjKQgid=?knhr
zKqHXJQgi6ICm-qdj6o(#&F_}GPSQ*#SIEv%v&~`Guk;iWj7*lA?>bd}Ml)lOsi3BK
zPLcR>oPKYz-KLq&#UVRO&A0E`?=>>DtLAWE%HgS?rv1mP0Y;>DcwRyzOU>>3Hy@_E
zy-*1my(CM`oa5L0qKEu&WXkLcy4&T6x=7b~5t%GC&rh4#h-MaagX}Cd>!m!>fo2Xx
zCQHqoeV_KH+w%f4S!%9cUU?K<Xa16qou%f1%)UCW;~b1kmYN^;`RFVi(a2<}dH!Op
zOvb|&S~cxT$?S3{DX4k1fRpK5gjUV|h-9gGxAnvTy4#N<lcna}jd$13-JZuCqO;U2
z5cKK+{jpImWXkqb(7lcG)H!sWCy~igbHj_-rcdFtePmM_va{5j6*sdtU1uL;veeAp
z<47Btc?_8>H7C73nN@5&lWsn(%0PCOnwdJ=%{6MIZO@^|WU1M@QRel=B~Gj6d0@(J
zS5R|iC5K#ea~3Eoqx0Th6lVFy+E}JGdJr;MYF@AV>I8kSc^;W8H3#p`pYRiQ;$B8u
zr;`U{XQ>&UKDH^{?W2(?`$$3e*Xhis)9rZ`nJhI|1m1i@_q&THWM`>)BXB|<dP*LJ
zOqQDKC%d$ynU|5tQuE%+Tsq^^sT^cysd?vK>xITX(yD2A{ipHEg=J+IDX95m!DF45
zq{JYSwQA;k8rI)frgq3XmxnT0YHmDLM(51|!;#5Sb4BS%`RO_@A(N$ML;uRVX*COZ
zL3Wm!Q9Hl?qU#)nOxf=Wy7%_)mxX3tLMBVisSDTn)6-|63Xq+prj5_ny>xqyLMBVi
z+-WvtptD~=CQHo|Tb}eZ)~Qvqh_}oxn^Qr}{nwoz(q#@uBuh=#=zJIHr)rmx$x?I5
zl<Di~C&{iAAv#OV)-D_N(#-M5WU1-wI7R2HYj=>zQZpcB>E?7Fm8=BWS!ymG(C#(8
zQ4B$*97_tipZEP_L4R!Y9GNUN7aq5IMnCPZQ5mwc)I4#d+id!z?^<NC)C@h|&c)bA
zS~V?vWSug)f|@xC1z6J?n-+*<srjG7>L7Z^ha;1vX0u(NzSGQ9RUkS`&8~Y67pG_W
z*2rY38RtIBhGy<SCQHq!Rr2qphf;>Bke#Jw#G28s==SW6OqQCPN35<&kEO%Nl;cxD
z_t*ntTGMsrtOnUxYIbsq=|eMnB9o<NM&As1Xf=-lQ<kZqrlnnq19X{rs>|peEHyJu
zesYHHqCUuEsd+P`k<MX@W5{Hw*}}p+1D)Nv24rWc8M^s>IhxrYnJhJzk2!BeGfyLv
zrDm@i1-H?CWM31qv($XM;GE9+qJhX{so6K@l0|g(v&fWVUP1S~y*+Z%*$enWc9xoX
z20b;M*V3+<LBNzq1vL*|9n)SXIwDzWX3IKnpicB!GP);A%|1St9?^9MA(N%%g!ryU
zjo)?G-V<LyCQHqRJLf#4>$I;8*;#6OU9{LnGY2D+rDnzUzIEt6I*&}2nkxov=ug*K
zpblhbsd*uL`TR6<C^A`UJ|92*C(VpOrt~No-Nk93XN4wu8COm1`JzH~P1$9Y$(SjK
zi~R?`Gd=**%03K;Qp{wK;{3)-hi6`N@bie2%w&QK=6Lg+Iv-{itS5t)P>@}o328Q|
zWq{Zw5?{1JCQJ4UTUVu~x3f2p$&!82lWh)kdzPpV*;%s3FWs%foPbOP*=2hc>L2YY
zo-m02qMhjOA(JKhxoV@k&|7)W29TX4`^BZTUKl0P);SlMQX_@&*&w^sO`7=<nJn3N
zT%EYkIC*N-^l2!w%OS6z=G7Jr3eyjP<|2}%W~QINYv(m|xwy2=`3{+~PKD+SsuMQD
z_)Ja9^lJpsS!$YF=Iusz(OP7()Eqs|w-wF&g-n*3=SNO(rH8zqA7ochQ=YNOHGIV~
zp=DAvw<43J=Hn9Ie$mrXhQ?4QOU>HZTb3{md2PRULMBViQ+CJi(RJ=YCQD8C7Pr<L
z>(r{5xrxj!ho^#?ReFBXIS<nbkt{VASe($gao>YXmYM<G+ux;!eCDPQU1nF%z0}A_
zkLXp?ADJvQJLbA@h_3ShGFfVN>^#wrt}}Zx$j(yp(X(6aX=V>(vef)hu3Sdr@YHH_
z6qzhFKUABebF4p4bI8t8bMx3oIu9v(A(N%%?7TN-(Hq)hz?4HtLCt_nZ9V82Bv%U=
zy%bALzpYmv&|TCEnJhJPm+P>Bt}_amEH&rtD!G7WTD64ivON`aFTZ%-S2}xNWU|zJ
z6B&MpuJbrDS!$Mw&1u?zX*IHG1=(3@db|9tK-bw1nJhIAuHBr8W}ZSOOU*mS?meNI
zcC8^hOHF^Dn|X}=u3a?;0aJFnf|_sRADy7fj7B6&&E;<&4yKt7ZDe$JmYQk0y1%6#
z0tF$HrDn5jJ#>EY<1{i^YW6&~Adb#%-xjjVK2p%#e7WUrnmHJmEH#VH?cqo>&m&Vo
zO?m%1q*m@GVkJ)cLe7HiAUjJ<+vbBJ={koalci>0g}9eA^9nLqYCbtX$@H7yS~XqT
z%j~j?6x0k@R$vN!uQ?KtEHz!t+JB%wc)o>9mYM<fkKfSmFDlmoqO;U=D$!sqeJXbr
zGFfWoxg61j-q5~6CQHrv?H)FvnN>PMcG>T`x=W3=<*xNyw5RBM?W(x|nF?yk``4&Z
zKXcO01KuN(rRM3Xk96K3S-lfvXQ}CXYMaiBLl+~HrDpyrWuDWk=6hhu=2TGgQ$7Dr
z^dpAqon>^D_ZP`-cQ4}ARJ;l+=^^Kp$YiM*TQE}$eI6!-Kh()m^X>X$esuOu$YiNG
zs8xnn^lQKlBa@|O$s)_g(b?^~Kz0Q+rA9U0-#tp#ISQF_Ea~blnYmZj-9S&t_mRm`
zvtzWyS(;g~D`aP>xv1W|k#xT=MJ7v4ujyq+(D#}@fhnUasJW+8tHE@)*Xt&u^L`)g
zM){MQtPN_4OFJWPK_*Mh6DgYPcQEk8rDbO84t28BJm{4s)YiZgmzEifOqQC(w))1|
z8+hW<G9Mz7rDnT^Wp?H>@WiEM`UXIDmYV+eFKwiE4B^ORsoCT8##;2FCCeUAryQRO
zx~DtyRc9B{9+@mP)AznThpuxMGFfV7>X|N@UNtlIl-XsO3Tm!B*dT~5vm+u|8`>H#
zE9-nHu@9LnHSgUC?M&C1r58kJso6h6>WMV78!}mHwz^#Q1bu^W7?~_JJ73Culb+?R
zdqZ}Xnzm(zl%knI$YiOR!FG(!k8fQ?CQHpTyU)9c{g}A4(^AnskX?>>1>FzV8{$dd
zYla|GLCwUSqBwH!W>bbKVl0W91ns@%ePBwYf|{!qZ)#**h_%tn^p(+h?=Sk5+ga!6
z-$Z1x)EvHOfX<W8d&p#|+1;<f7UN8(&0eY>WM`>4F#XSqbbE#%lcnbH0e%rQ^ENVB
zYR-=L%0y>(?GM>mYCcT;su6upJQkTOHS4Y(<3lrVB9o=&xxz91XlC(1$Syt7)m^ID
ztYd~dVizK&W$pQ*@scTt$(Si*cYibA#@Opx+3x~Tu9?Xo#aW=3&Gkmm4+Dx1Fa`JI
zy}!uj;OGx@V~#~8OZL0Xozv2T^CmJ`viJK@(~4%g4utG1+20MeE<!WMB9kTixi+Py
z8M|FODcwLOOZK>4UjpblT?RpRmhAr5?{uW=9ED7l?7h|nn$gV5$YjZWept6(batn~
zkX@>&D|_OdyHK;;;IzR;rdG{hV9Ft{pk}FK7Ojm)ZMR=Qq|`l`GKKD|vh~urJ8%q=
z(cNU73e1LU2k)lq9EMDmnz?4Q(D@Ez3^G}2_U;__HH~2|7MHd?3lD+pEHz`-x3Hq8
zx*%k-)a>bQ)|DRe=aI=$Gh64(PIMnR42A40HEUgp+CVQIgOJHm^KPvDMVc9nOqQDW
zf3&P=%&t|_Hdtnt!&5=cv(x=_nzKJ5S!&K6Kk9?AOzrSIiA<K7quh?vr-!G_Fo-U*
zE9kzlTdB2l7xhObOHG%@?Pt@>6Ubz#d1_h4E@FNbm$p6g4u|Y4HD{hZs&nVw6PYYE
zhyLlL^IK-ekjYXrWY(7t^aHRwBOp6V&F_IFa?yR%ADJvQ(>Gc_!Z_x&YMub597+mm
z=F42v(TMz~+egaiyz@oJ;w~SfnSGGSQuA<&OgHF<0mqQZQgen+#_lxJdK6@r?Wv&q
zc=H1z=m#PFk;zi?<W`IO^aHT-$YiPMZ0;3BPjybCAv;UWxf|2;rt2JrOqQC>hgWMu
z_t6z(veX=Ke)~6ie7cN*>?}1~AN^us+=Xb>90g3-?FwpsyjP?y9sLp_S*vEpnsdBq
zX5q0iI`4eZmGU13(akvunJhK!hHcnH*LfA0EH!s@E0uw+v*<X;F8fG9_sHCfbzTED
z8ksCLcRlQ4NoT)?OqQAj?{|Aif3#O@JY;97d1m?OQ*?VyMJ7wlubT@WrnAQ)lcna`
zcPC7Jq*b%re=@u5A_X;%-gDic6CIH(H4B#;;-eECnXFZ_>9Deu>7#$;CO~wSnie<f
zU7=_B$;f1>S#qYE&Wl%Kk;zgshsDCKbbFQyf$Xy16?AvJxJ>7}nlq5eQnSX^(K<i$
z{0x~aHOIG%8b<d~#fgxerRL>Y%N=RvJY=%ebRIs(^u|N2ns0z9n^Qr}dJTMY(q&ee
zB%`aGFOug>iuI@;K@X)x$YiOx_VtYM^e21ok;ziC&9TZlZ-1*l8M3p~yjwF{A$p^@
z8ksCLue3c-lfF0lflQW~Q~a_npzEwZ1+vSrq^o=4M-t-k-%!5@OTkQfDt9$9S!!mu
z@3Vof^9M3nYL*FK8cu(j-7plgv(#)H*}MzAq1^;b8C^lmPBp8opojc#L@KPBvWtA|
za%UI1C+(tEQ)P7C@1yM+H7Fge`*viq)J%Kj%whTwL%L~DCriyt@fCD#5IQ51rDnUg
z-a2m%*pEz>n!PXN-%d}-*``Bw1vTZA99ObOQCgz_WXkcWtGi^rse7y*%{+`umYQ=f
z3_3-RrCc*0J4?+$UFN<t?mo4vW-nmMG8NP;@@ecPBU1Yq=m;Ve)RfIxuBVmGBb!_^
zWpoeLs+oUM(XDiyy^zULGyaEfOS+4qkjYYW)AuzSX{OaI$j(yJti|d5G_x-<S!#~D
zx-f)ho<t@~%`qc;R;2sLb~a>ZsoBscT4zcQM5Y|`3c8Pv_tbe;NHj88YJPrk{Jt@}
zR!xUFGP^`7sJZ@FDm%K11|pKB=A)vUsu|1F>V6iPEH#7tnuO7HI?RRWEH&pW+!jmM
z8H7xhnq4id9@BN6LncejxR6@cX{O^m$j(yp+S|_k>3jEJWU|yWPnBjJy%L{ACQHp*
z4SVSPN~`01$j(x8nVW?x-JZe7lpZCcyEt;N=ERdW#+wf9`JziECj7clGG+?m?1{Tf
zzcQ$m-Eo02xf`4XN(L$JI9#_iULv-#Nw>2>h-Aq=pkz(c`@6NW#~_m>`-T!72GAYk
zybz+ZWRFd`;Q_t<8i7of>~~XTyiE`IE68NY?jHJc4b3dN2(q(eKb))jcslzyWU^$R
z8u?1+yTrGU$&x+x<}hcv-`y5Nc9!hj+a4@M-x`G=lO=nBbk$5h=%rQj5isSDS5VXA
zPMewZO}2ZOj1DtMGINs9J@b!j*J<W7WXd`fm~%q*&ZCFY3uLm?%xUpr70s-)1hOlr
zDev6B76_gy{w1CWXs4yQ$YiOR;@#k^f+;R7^F1;Z)Rc8@YCdDC@m#8wS#K$1XQ|nH
z=AE;~wMffchfJ25RqdYVr2FV6GFfUCe!VJ)UXB_qgX}CdJ&N2kojA~{xe=Ihcq*uQ
zY}P&}I{F_(Dy*8a+uzQP{w1OdJ+)obWVwva`+c-l(>Ce6zbG7;GP{EAg&fTf(nHB&
z1=Ojaro3}6pZQJ-x;>jClcnao`_10a%y48Xs4468Pq}BSPWF|Mou#HvFLPVE&gRHu
zsX1^@g+;VR;mBmES#a5#D0&x?W));-sp&HCh3O|NwQ9BlrW{HNY7X3WYc^fxHbg3@
zDZAa_WwA(_nRc~|UW&D9-b#B&=V4U`WU|zp>|Looy&CO7rfg3I-4A_gsPp5zIo3dS
zmYS6o9@$T86o5>Ynxk$!nn(}%gUDp5`JnmCrZhA6TFA~)v-FE&YiVX*WU|z}KhR+;
zJ%yY`CQHrd2PT?+zfY^C-8z|FcDsU_fvY$4rppXOBumYA)w|f!&3PJ`EH%@e9IW%h
zPWjhEbe5Xw`?P68XAeRqOU=RYey`~4=aDJ<NJ01IrI(u?T4;A6&Kn>*OU)i{ijASO
z2P0EKO}SeNnsxZG*vKb+pK%N_S!$lFxTX(Xr|U+@&QkMbwmg3HR5uQpEH%5k-7@`T
zrB=-wz?5C2pyt6g!GU!2qMKy&(kwNzg}z-vGshs4rRI(Er*hFN+zn*1)QpdCTulFH
zko#uH&Qdcbd{jsJljoVpWT_eA>NkjfZ1Dz}vfmYSe|ci)eENBSZ#ZOEP*d)f@>&gj
zO85IJWU|z3=6&=T&HRo`mYQu#rp`q7QG+dzouy{S3oG^-KR?i_xfz(UITh6GaU<I~
zdU%>|m1XkI7nSOe-JO2tOgm(<)Qq=voI|U52$?K33uLuQMQ69(2H9C^R=>9VCjDNZ
zA;@H@8B@{Lj#l#qGFfUaI5K1~-A5%OAiEq(3c9<v&y1yC<}wqR3Tn!g_+h@F0-}$^
zX<zM*;R`ZZYToEnGaLQXx5;+M&Qi1gVCOiU^F_dv(G}F}-K2aQx;cL%lC^3USo-@M
z9lg^I8J%~&Xt4M1ZS+QQA2L~LR-L-_5zWlL6Y6BC86P<y4bAL{Oa(RN@N5|y;4Fq_
z()Sk~M<z?n)pqW4>0beG+6CEJY97CHtt~x$h9FapPX*n>|J0jBukMeL$x^dqRMA>=
zA6489*;#6y?|Dw=4fFGXDa%w)GeyAuc)HA&h-9hRt?US$_r+G*Bct=q7ga2pttzei
zVq~(^oS4;nGrbypKqgDg{q9-9=|^C7_d<3BHRVR}W$|GdY36EVveYa+{+iD3kpDua
zf|_y)IlguMQ!#}keWhIUeUP1{=9t>^<LK3WFEZtrSJ2%jzpW*`v$5I_b+Xi~_h5<X
zwcy$fZ4fXeQbEm}w{|<w`|h)dWU1NyYyY(LMzL_DjL!Rgw23zFm(dzcKqgB~t6dhm
z>9_tpM5cn8a(D(VoPVg0VR#l!vH`1c0J5{x^a)vINe|E6$YiP6xx>sV^i-GoAk?X#
zrkp}b4gLLqX7)xVOU+Y}LmtxoejJ%BHEnhdwxd^fyF-v&dX$Xr38#T}ZK)|*LR{MO
zMZuCOZ{d<LQxJz*hK#4T$Y+2k#Y_e%4ji1AonkFL$LBk23XW%%k_j%DGp6;npqT@a
zDWfYemu#=Rg5D~fLncf1u2~Crq9?jSM<6>(_Djd>OcxWKnCG>3TjP<bAiJDErp8{L
zBp$Aa{gRd$i%gd6eU`UvM^AK~QIMS_`&X;{b!jn|B9kTi(rim@>3;u)OqT4`KhIuI
zFGh`zLUxwyc0a;&-dP_3OgZEg)XaGGc?2Cj^)Xo{?|jj~kD<NjZFdJ`$~qO)44c^L
z3|;3wWGbjBhy1vu^D>AnolTM<pYu3mS5Q-~MSg*Ouh4V+AY>}2DVcRGE}fy7mypR)
zb95~`4|;gIo`CEuHO)`dNl!DUAd{tLgS++j(aaafWT|<vq0K~^S@R@hXQ{b#@OhnI
zdRYTZIXo5ATw3n&DtgF&N2FYd6*Ri=wPGcDHEME7M(3R`8eO;ge!9*GWXkLcb#`ji
zpaETH#?w$IOU;QTpWmeG3_vDJ&4{yRm*_f=Ba@|O$x40?X=eUt$j(wTS4WQ?^b|4@
znJhK0pF4kn*621eS!!D5TsVNP)AI~uXQ}zASmEQwkBzi<uXBJYhmwMt!M&H?r=!0>
zBuh=RfYLgjYSug}qw~%eZTR-C4PECdWU|!UzOA#)FKeba2X)H!RM6e`T<4T@oo$iH
zQgic(6Nl)b6p2ihnydGAze_XooQLczHJhJ){*cZ-0GTW`|8#e}M^AN^kjYZ>>GNgR
z>1nCh1<1})Gxg$#F~)-tS~VvDQ+B(8nzd?OI7ydz7m+MAqfadUNHfb_l+k(bFM8gg
zu+B5edB|j`x#;fFYIL3Nk;zgs-_f^D^pLL~1KDLCDd@f-IzE&h@*9!KQZwa_MxJz?
zX)i&YEHzVi9~VZ~>5oj7n*Tky9!@ilB2z(4k=D{oJPTPl!u5n;iidUDdv}M+ke#Jw
zi>cMG(yQi3V9GAiRa2IEW@8U;@rhZ|`>iX8WU1MEU=J(0Im=v;(Mz-LHM0iH-cLXG
zoQ+JDngO#Pccaz(h)e}FWqa0mRjrPA1eCPf8(xL%EHz7KAHA1u&#lOm{jQ*Ug`Tdr
zX=bKtP$x^xbSE9N(e2q2nJhK!kH^Q;b)H71f|~N)Jyo^WFX(B>`8s50sd+O+PSe>c
z?W#Ezn6f!_)s$rh?OxrO-Z0!iBuh<?nQ5cwE-H0HMlZusv-hEOh3Pt{Ba@}(@gn{@
zPiW(jsi3B8&$b0DYSG<Z^Co0xsrh8W_a!uQ6*5_BZrz?zXX9;l3+j|(NkR8KkNsWg
zK5C0hmYNkdZ5Tw4rM<{xsoCaNCx5y<bKQpQEHyL5=6gVIX!`?GMpsaC$DOQC>2oH>
z5vic22%ETJn3?I$FY)9v>F<s?-;vRI=ZjVxF8-CSGX$9|HQN?<`A*NsFObPn^V71a
z`RLWX=3U6nQq$VIQ#HEIb;x9?nPurlOPZPb9@NQFb8e^0gJ@=FWXkcWp!=ZZCsWYO
zC}gtK?9wX6iS8r&`;eWbW{6d;X7q-36fk9(3Tj#peBvrJ5|?)0eHD=kYRZ*kU6!R)
z>DjZ)0~wunzGzq13ax173}mv@EEVa0nVvmgB9o=&-AB`1=%G~eA!JujQ%-gH;?_K-
zZ#vc>lcnb60rol{bXY!uI$3J&&9O0@9`ap~$x?G%#k_rJ<_ToVF|VL|sUaC=(<`x4
zEM!+uGqI1vk%Qf1CnbEiC;rPn8(LsWq=K4$Mb5sa%e;$7mYQM5mVKj#XSv5RI`4c@
zFCVW%be;2&$x<`ju4dNs5wK6lWU1LCr1?NPd*dgNT|rGb)m46Y^cX!nBaq2bv)S$X
z!)a!=r%)$L&88DP%F)^TBa@|O&9@5+(#(s<<f-|mRZ}{<YaC>k9wno@P&1wXq`Jlp
zt@eD;RLPX1GZ`}l(Q;0;&h$F`0EkjdU8J1j2NikaA=Y5~B<pbLXQtpK;hjjy1Q*ZL
z7X9h6S^NcYY1j6-$YkBU9_rHiJT2yXWXk4LsMEIe^eXf@sD{rWJ4^Oevo<uL2j_ZZ
zvSdHsXmK|2;4kUJzceqPPL}Me*4CRy-*WUorh@EpEIm%)bVH1#q;;M{CQJ5}<JY~X
zzaruq57`xDmvy%2_NtDMUF6q}&soT1$$stFRXh5NYaf6qhrF(ua*lsxweKN4C)Ic<
zqw~%e&8skKIQ{G1Ymq7IRM4o9>wh2VEpob7P$x^x?=QAl&}+LtGFfUKtn@NF&5S}O
zOU+X+XO5z?+r5VDEH!U+{^~*3ITV=+YRa+n{o>#QH1j$#S!(V+IK4g1bbkZc71We<
zKK0(HGtJLHCQHqzwl!|ir*hu{Qw~oBHLK;^dX!#`eBR3FCFM%2pwXtUN9NJ1=5l1R
z)Qp%}`8nN1zmO@j>((h}&jS+<JBk%9>Fn9^9b{*z+4Xad<Mh*jJ;-FKIeh!H$#i>K
zy@xtkY7U&eeG%R71CgnqrfknaSKm(((|poz$6P@sOU)X#V|&;enBvl|aPA)<J4?;=
z*G3MZ$I@bCveX>fbzf$B)%*rbIg}LC^v%&DBVA_Qk1{&%_t7c^*J(lz&ke|AskyyU
zz(#rlmi`mesi3BuJ&)9P@usu)LZ)m_UEL+KP1$eD=@l*-nJhJX-EaGwuCw50$j(x8
zQ`y-~=$*|NWGbjBv!^|JN@q2Cf=rg04bJv*q^FRoUm!b6&0cYLp3uyd$YiM*?eJ_5
zy=tcTD(jTpuArv5ZT5<Ew>L&4Yt<}OW7`5c`Zi>;)ZAFjBM*HKm*pEoXQ_E6%hcI)
zoxPFCQgck>wbST2&mmLxk*@A?HS#<9C1Ls$T<yx?@*T3X)C~PqIN>8RF@<WGA;@H@
z*=F6~IrPoZb7ZpA{59|De!7o*e?WGYnmhbUcclAh9Wq&JZhZS9lwLJc|CDvgE>ckQ
z!HVgj^eo>Jkt{XW6&moI{%+w;WGbjBhv%xpzrw`hfTW+kX7~lsS!xy-I&40@y7xmS
zOU)0JDxag7myoHTrd*9WmCdd5Y`WBM$S(U`S9i(Gobi5cddSa2CQHqTHs!P18Tv?E
zTHW6vlci>*pBokzG4RBtWj6l<*;#4^H9fkNW=12ErKZcUy$5MEz06XWb?M&Iznz;~
zN!gqVYQDQaQs=A0(-Fy1bN7EKZqVN@e2Yv4HRVuhbF|SF`YB~obBNAT)AmMHTY4z%
zLncej731=T(kq8U3aFE%W}%fkgIo+lQ(W5NIU1QPHFI~Ey3E<Y6PK3x5t(u<>FO@0
z&sOiB{t-7FN$)i~rG)G(H6NTTXh%;W$C1fW(=6bK&iHh+fI3-fzI>Nz7_H_cV9MwU
zYCd?}Vim2?Jw&q9{BXf}kiDUc#HH=_s;OjjmGeci+vm*lD<;%TIwNmFCQHqUSF+ru
zSNANbp-z^Xk#}yipueEp6`3qG`@PHFkKWlFK_*Mh0$CjM&>tMxq=D=TYRc(z*qOUA
z#``U8zYjpB9G|+nOJ;i4T-z)S{Vpyo^CU7^YJQ(yC|3LhacP;kEg?Hg&5j$>G%;q^
z9%ASYOj)LanoGxz8$;h~?nfj`O{cm2bY2IQC#{UmJ6{x@|3D@os<^bx8Hh{;HKp$F
zf2O`BhP=qHWnMrgOU;whuIPNLv`9M0uAru@^X$B1o^+iPkjYZ>+v8k1he949lclCl
zg#R9T3aOYLvMZ=5v*#PKV2zmSlJ@&TWXdtGpnIWowe1BjDf1&TS!z~l6ws4iH5+7*
z*(Fj}O&R?{(GQpCZeN8+mYUz&IW(qq|AS104Xv!xKc|b2xQ9!+S!$gTqARE=XXFN5
zz8#~VQXW92f||0<qXjJ=(RJEqf;tt{ly!b?daE;C=V)ZI)Xb8rdrw-U$H-JrQ)XY-
zzH?TwnNRv*RK?7You%fXpQ(1yyQQVbWT`o6+Vv9jjZDfcP^a`L8QsNcph?efj-byM
z1xThGNxEhx_PQV*zUSGFmOT=PQcPW>>>#VNPPypD%#zg<ycF+zQPD#mr_+r&0GSH1
z%K`6{!!ew`i@A+V1=(fxDe)fhLZYM(tIB1A?6QlJ>2z_nYVZ6Pz35wxFk~voF6&$}
zp-8moqol9+Oqm_(WXZnq<JUU$xt*@aRFGZv(JQlsyXZ;&EHYWL-w3Q(f?kXY=YZ@i
z**mUTbf2E+#vzj>d%%@-W$7*QePGHVudAkP&ivjpzllL0F6}naEvJmGa=u6orQCHZ
zjik3Vp~#eVDh&CZ>7qN+-5!TbmYSo6<atDQd(~W!ou%gF4wjSYI+r4orRKqGw=&Xo
z{zN8A&D3M2>73VUmK(CO)LfOT^L2VGMIe)<<_!N`4e7CzDG$`Cpr#z32iCuOO1Eb>
zWU|zpalG7XdeuA%OgTJt)s$uK9Wx`I-qPi^lF@nRi;5g+e~#YL1tC*GO<AX1L_}@6
z&fCb8*%fqe>@?P%o;|(tLUxv#Ycl=JMIW}9hfJ25vxd7)r?;NpkjYYWLeri*>77jr
zYsjvkrtG7Lf(J{{JFvsZR8Uhc9S&XU=cMa&w1GNVYUaopHjA!vGBR0eX7%lUmsax)
zFy&BEP}96nRKoWa#b!~vYF5c7qw~%eWxC(jo!-<fM<z?n@|#vf(3{URwooTa&9Ha7
zeH{$B#ih+2fK1t*y1L8Zxo(XA1(7`|^D;77YNpv)pfkOp^|XWREHww%_t`<enK2BR
z3TjG?W{!W=jedsy8JR3Kn`ic$N7q@`9<nQ_DeGML-6tJg=Ne?P)I9!RVLYwoFJQ`U
z*Hu%NnKnlQCpvmV2N~U6-oNS&PsyA(KV?puxdE99YD%WR<0GA)#Y>qV>SU>z-tuiz
z`Xh<f$W%~M)*1Wsq=)hAMq1r>AXD~{LVK>=xU@Q5XSxEAou#I;^Vxwkvm-KDYQ`_<
z){@S?51A}A2YFpMM%S6e5wf$?{JeGX7n<1(nJhI^d_7s5zSleqOxZ;WYEHF?@uM}$
zR!~Og{XW|D*{iS9vr-RaveeAK_Fxsd&M0KE)Lh~6sxQs7c7p6IHSfo#+ev31fJ~N}
zA4<GFLf3f)nX=y%bPtR?@SbKmIzx7rnprG@m(tAP$YiP6zs5Hkx;?KUlci?l+8op9
zI*S#8>?}3ASNZgVUN!#%rfg0HHN9MFMABv6LL_U|9O}_@1l^pa3d`uc_ZRglQ8go7
z=OkpZ)O;10+nZ*_B9o=2x!LF8G}EgHWM`?F->T0MdX}GqOqQBscc$^7SGZTmlw(Oj
z_o@5LV(2=nxIlK6nwiS@J))V5kjYYWa`ZZTI{OD?vebNjVa+L8P2Zw2yNs@&X1ihy
z{OIUmh-9gGe|gIGH1iWOS*zxUlpnLwL%wb?h|W^;PU&6?=_zClGFfW2TeirYuJac%
zS!&)dda5MNZ0ZWxS!!OX74?<Qz6F^)HOrnEOV^pYIMgY}r-JU8_Rrr+Gut7PrDooW
znf>YPdyvUeGu?!4b?FUl<`OcyEK@<vJzw^3G}^AcH|l^$mYTa3w;xDH--S$;nq{(-
zs!lUAx<Pc7np;D1oTjsPMkY(muIWpBq3hg>OqQB)6FMEEnORCgc9xpy%a55rGrJ;_
zrDnf+BXf(V=;G3jrGv<1skvodNGQF+*_DFqa?C5}ZriJTN8^D5ZJh&=$x?IAmDNLx
zV@Z4T?=&zaQbEm>?r~vs^nC6zx+hD`v3que)676*vee9#ZMNZer^Ihh{oC!Qk;zi?
z(#qX-be;K1Lw1&$jfy`mN;3nI$x`!y^|mpzMyHX<QuEi-4>^oONjp64%RqLPnsxTv
zn@QI>5Sc7B&$@>$r<rGw$x`#vg4ToR>;=j~cIi<vx{K35i%**s5f1~!rG0-<kYvhU
zPsU6^^l1LMma$5$?5BVz#Y_e%&clQipPGekOdAhVaChGMqI@gw7ND7d$YjYr!rHnX
z&5TASOZMiax7;^2r*^<QctUoT?3eZoXiL{Q2${0mlNm^&j~cl<_oA8Skjaw0K`pZb
zbauybkewy_*p-9d&~*+$CQJ4{c5^q;%!|lm$^PGex%1K!vU7RJ&XT=l`SHt*?Wt9B
zI56dqS5R|=_m4dE`WAyosk_2ZDpD{g9UZ-(myGTv>r`NFSnuLVGlP-IQgcw{#zS?o
zBa@}(kBCAcbe#n&Kz5dz!QR39X=X4oS!#ya%sxyH`50uf)cjndd<*07)J}DUydgVF
zO}9foF4A=lM<z?nZKc-5(#$K!WT`paZD2fo_v%tnW|zZLLCxPDv&+-XIUJEJH6Ik(
z*ocmP37IT4+pqfCfo2x21kq)71>JjfFQaozZxk|FYNma>z>|Iuau=B_HAn0@6hI#*
zEK?b>v(#L+bHO?K3wE=R$x?I6D92ZH_E*ScscEw;!zr3s-3PL>)co=3PeJ-z*-~V(
z)cidE#Wtfy+Ew#AFy&BEP;>e9u8Zg{s#iru=bbOIUXpPZ-JI)?$x`!1{t=Jq<}|Mg
zb+Xhvv#P`iy3W?fl<ldYd(gN%u{3ihGFfVd&F+<l&Yr0nWM`>)tjnwzy5GAalcna!
zeO7zu>_?HwQuAPympVTMX;U4tE2t^YfK@(JEkLxVnC`Tz`(R|U)Ety!?-*LmOTd)f
zuAt_+*4N@i(c;pU=~P2T=bbOwlHycudMJ%Srh=NXIi2raZ$>xgU1YM<JohU9ayq+5
zO~}qt^NiCSFFN~dWXe8L(7jiD%`ke%zd<HT&3k9s>u6Nd7qYX|oE+kpn$Er)nJhJ%
z<{AE)o<e>iQ$bC62JGgi4m#6k(^`<7rRKnTw<gjX+AYA8U8JIByGtkO<}|M@%jBIe
zN_(O8E_x`nMy7(AvN`v?8KAQg??fg`%~#Kll&7<2ssq_sYL;3*aTPt3x+9aN=7E@j
zI-9zq$dvuAp!<36O5f@1HgzF8OU+_+=RKhNeK0avYOc7yc`|(?a}k*=HAlbx`j)QK
zxgKO^sp*_~UnzRk90g3-oC<21ciecCF7pZ^S@)V7mZi{nwOFzGGCJ>kQG+4t`qOoe
zLnceji=Tc}rkQt<$x_qHH*X4>S*8JGXQ}xsD7r6wC}bKkS!(t;HrJYdv=oO-IhGW3
z|NSE8QTm>^LPN;TQnTUh)j9`a79x|SW=ylsItO>&Ba@}(+Of|Kzwjb{<>lXBda2b&
zW|z?w)a<n1a|qo<OAyIYb5xyAI>)s>B9pahnjK!FbF8e6A4F%VdA)n#G_*#mkjYXr
z?)(#XdY1o%OqQC#(baR)bvAAc*;#7-sGif2W^P6%OU*aiYBi;^r)~mu%JHe7`-V2T
z=FoMvK_*MhA~Dt0(9B)PWU0CQ{j{lR4O)sz`xq#5Q<+_ssi3BB_pxW_GTR}NrKV55
zy?^K~+Jj7%nopu%-lpr!+zg_#)by`@=o!uIhD?^4?rkDl(99#qWU09$=1l<2%-bBY
zv(#+fD^p>b8Hh}ln*XEhyyJR$-#;!RWRtzh$jp{KlRc81l@%!=D_aPWJ(C%Vtn9tA
zqmoVb#~vX&%FpqAyj`#J>pG9_>yQ56kLTlho%?#;_x(Qa`+d%Jw@xqk)%`LuMQUbR
z-nkFIbd=}@*{SChboY*^ZSY%`amW;@xn-`^TVBnpz$B!Cn%|qc8T^c=m@`F}oiEzb
zbFjfrn8qPfq-LmRW(U5Nt|C*U=G&pRWBDnhTzAMWQqw%LUnjoKsmK(mIipb}SDqP*
zOp%&TvrjF^XRp=+vWwL0a?|B0U*{ZTiqtH<@WCpc`4pKVHKQupoj2Hc_k`@^Q3|?i
zr-5SQ??#)xBiElVT1iYAp%l#2h-XGP7vgU$y#*qznJFN(vnzuacS_F>di`Gif>)QF
zFPdIump?y1OOYv(J?-%)CwOKYGDWiYeVbr#6uVh($S#t-)27E+`8wAiQzZM1GP~>X
z%x}n~R!X5cwQ;Ytw8JEx>F5I4MY30o`0<QihqoY8BzyJW!Ik)R*sKrKDUyAy+p;fw
zon4SAlD*0Aj0V3c-3d%;c?C6#K0AAkFVn0qMOS%#5#67yHzlJJe>uA$lj>AxrM5}u
z#_)CSM5aj1D6geWcxL*3kX@wa)qO7G`IhgEOp%%urxrfQPoD>oDN=J%o^0-Xo!R<B
zc9EJ%D|>Y1nS+oiQgf$I?^itY6f#9>R?L$5F3&750J4kJ>}-D4+0;w=Pp>0@N$shi
zX6t<s2lz505J@Ysf=093HyXjWQgK&`UPYwlqdc2J_&UcSld>z+>9X?c5}tVtnIbi(
zR*1{NXD>exvWwKL?DM50U*|MriqxEZz<e(M6vcbU6sg&BS2Kf;2XzKPc9EI|VqLvV
zEwBG3e+e>0YIfS@+LB*7-Xc?^reh6TZ+=7D*p0GND=DbC-#cSpgXoA9scHAwxjoN(
zi%gN4J+ECX&0o$YgCV*|%@_SFuJLuQL?&HN1>JY<b}%^l7mrMlnk9<g_`>Vn${n(c
z)J&73tig??AY_WvoVI#w0e%YkiA<52<$H`<&S&rF0og@rUY#*+D_`eUWQx=rHsE1q
z{>D<;Ayg*~yMmfd7G+lOWp+fQf|_&|$T{L}xb_8k@}pJTkttI1OT$;4_%GcvctUiM
znnBlkj^Pg+^h2gd&7@J;*YRhTjv<rANJ00JMc>5ob><%m*+pu$tiJ9UU*`y9DyT{0
zUUzHr-~6~oBU7a2!v2Yq_;D{g46=*V3_SDnHJ{xVnIbiREonT6Uo{^ClZMDpO}d<)
zey{P?{+0Z-cvXi}blLeLi#xfh@%Pl`BU3?5s&j4SsrLM^zeT1<%?1MouI5|5nHOXi
zsabYnVpD$D*CSIwP0IfK%AIC>_C#dTxGU&hXlnP5eD<y*AiIK^bdO<Mj@sw=?7NXE
zQnTOsjOF;HBkM@0Q>138Odad;%z?-hsW~BEj_$mgCxJ<q(@;&ioaucFr{c@ZIf|m&
zDXf~rw6ECE;7fORWGbjhOusb~_w%iE2ALu?69*=_^KX|dG8(dr)O@>j`Zj)+pMXpS
zH7R@VIoter<}G9@s7botZ=ctR*S*RZ$WFbap!>RkpGNX(&PAq3&93{l|9#zwR;&KA
z<||~1)J&SOY%#xdH1US)A~n4W4D;kSwCjOM(G}F3HGjcOe%L=EQlw^`od<(>X6vyO
zUG{#oBb9uI@~sqtOp%&rZ>F!$w^HhHP^U=Ex(g5e;IsEarbx{dFVgPdTj>xo71Si%
zoqXMQ^HW`(@sM4l=HpHF%X#K7WKw@B=zi(c%+LH7MIck8=JUYDm-#wvCO~$Pnzm_j
zzUEiWDZr#M71Vs0$Gkcp{VF0wYTB)z9Kc7fFp;9m-jC+%)8#17oP|u0n%mdqzQ|{P
zf=mT9HA;q5+V_PnAt!Tcb!vL*XZiY*AiGG-sV6$W;Ipqlrbx|sW0qv#v&SP-q-OAs
z%hCKTo3@i7yG+fZ-nORGuKMe_37ORM3c6c3Z+OVpnSe}@n%n0$y2Gp4ehOtLq=K5W
zZ+>{om$?CvA~jFD+-k>P&IDwNHng#kpL+6jw)27LA~m}=TIb0#gORDACap#X5*yj_
z%tU00)I2pZbrb&XbjPWXU8H7IgqfG=JdD2OLy;*`bI7eB9r-$wkSS90UHAF}d1l9H
zkX@waxqUmb8)Qc&d6a_g+G(Kfll*>}nELZYNyMb9nSz;rpI?-&i-*=%+MoWLQpf54
zlEWv>6p-4wakOE*oBYLGk4Ta1buW89<C))(DU!X%eXr8IL~VQ_x=8kUSt~8#C#8+Z
z6v_T!QsJ6>oj;H%l6_cw+e|#uaRy`;$!`6s&0(Gyf=p`96dGRZrS$`f`0>mnWQt@D
zzkmBF&+If4vWsLdci+R{VJ_Q{DU#jV(Xp^ecD<Trv#3sLc?C5+Cms0ANAHM8k(zPw
zPtWtrt;nQ06^6Zd&}oB*xuo`k=pr>wym~R3ud@p>MQUEV)5)A??m(tU&6fjKU*o5`
zbh9D5NX;Dqr!tsYNxu$vN2W;4Cg<W$^L6e-rbx{*E!ThGnd#<0c9ELF&pihlWJjh*
z&Gq-vR4_61YVHIkwWorbx$l4U;-jbbr|7cxqgmhWGMI1AuE-Rr>AUm0!4vv+B9pQ!
z=zhrEBA&ltlXfm-7pXaSY|U|e_CClIshQ=Adkda<5Sb!1=U(Yz@YKI-^B}uO&3k?8
zT;l8Ok4%x8KQF|k;lGnOf=rQ`o!)<m;m6%_K4cfES!vw&to(*{I54S|6x8f-HO(SE
zdN?9Qt7gUN!3OPFZ~;ZHDpK>qaF3~conFWksW~jM!7iS837K>~6?8B4Gh;r!JxeTv
z>>@SS4<1^TuX8*yMQXOWInUrNH`kFVQnQYKmH+tjTDFTIyGYH$nJS*)mkwWKiqy=z
zA?r!L&RArM)ckNh)mnblth$)8)37V3xqIZ4U_SZ`M2ggGdN9jyKKeamiqt$;tyg27
zS#1eK7pWQi_1GxB<^7Q<QgiUqxU;;P&yY!Dq@cS+r>g__I_oZl>>@R1-|;bc-`rAU
ziq!1;x={$9Jr0>7HDkl4zTmSvEQ9PKHM_Tsxz01!AXB8~uvQ(m@oIhpCJm8-nl-=X
zJ;ayUaydnpoiB=Rx;raBL>rJPQgcZs?=5_t3CI+wX?dsIN}kza1!NbgdA?R*4?g=g
zWQx>u2rq4L#wJYw)Jfy6p!?aj<MZ*^dmvM!W|{bv-FfCdWQx?xxqACZeoD@|60(cb
zyxaBtaeg^+MW#s2+#gO|HI2Lev*uA?(&bc8^LYL6{(SVDffOC?`YH^2{oM<@@XW!;
z6sdW&RKt7x<qSurNX?;J7Cq<d%(n`%i`0By^3)BUISiR1HDf=nsKK}V1!RiU>{HEV
zmZ_EWw}GrzLw4#Vg>fI_^sN+Mr#CW1YJPjL(UNDzAXB8KTPwfUeD<<yAiGG-r*)kl
z@ZXgB0F$CCs2O}VWD_6#8X`p-TALQ1m+{Q<Ybm<Q`6BuT(tdzhBmUfuFET}HcFWo_
zj<53(GDT{>xX|k>KkT*EL3WXvU$&P_;_F<1Op%(StVc)k%vZ=1srmlE$0dCB#_J(F
z^{0aFC2EhFz}FdoOp%%!_uI7NneoUJsd=*XiOT%Zzg9t%oyt^Dv$@6j%zT-Fh!m;$
zrM}r{e&zU#Owp?Ov{KRc{Hob{14Ngpx!Ti}uQLdlA~o;isMm>SCLmL!=G%5*2JZ-S
z+6dW2YR<B#|CFzDGcrYLW|%SL7SBwz3F;K7d3n*mR{Y)6uE?aGSI~V!+0PmIp5KQ|
zk($ldR*&LW&8)$cosbG@2HnYHaAV#Dks>v-`32_ZqaQ$~NX_}_E|le&*+U?@NX^jT
zL*@8c-VK=|HG3^uv6-*)Br-*6)+^iVEYHlp8M2GiOmETB;GJt;$P}r$(690hzRrut
z6segbUEk+Cv)C5ME>bhwsArG(aUYLN@+bw}wbMWc!Uvr&-3HR1FS<%hN}ht58u3Cd
z*F;|S5~2T+*B~)dKx$_~8W!o(g}<1i5lPGxf@{o^i>mbJnbF7;$zHy~HG@w^rME(K
zk?i*>u6fL_8$QSs$v(Z`!=?Ow;SMrIvVTYw6wcRKaT{b8$?jih*f+k;naC8$zP{l4
z5qzEZkx4DD&`Z|K;~VnK>f0f^NcIP|F|GLioQq76>=&wL@4#=7p97OxUO~+*-Vf69
zbCTT-iY|M8k=MNA2KWBvB9rP=7^3*p?*{Rg^Eom_YOYT|+?CJXU?*f3sktG4+#SBo
zWyln%S@%c$WB$1Odt{2#3>%Sa4}UkHRTyL!srfX^iu(M6SAvl#QuFx99tJ-ZNVf~>
zR8W(CCh>W~-irLsB>Eszq-Or<c9Z#4^9V4hJr&gK{5;5#|K&xN-4tDRzUcP)D1%?z
z3`C}anshlAMm8M4U(VCWr0fd1R|((WfX`ld4`dgqS$;{(7{2AlAXB7f{ugOJ^31Eq
z6sb8YLl=Xm8QboK>>@Q=?h9?ePjxepDN@rm=ci`;RCgbl3To0#N^9H4Y5D7Ew-2(5
z)O?U}_Ay?~g}|g%Qc!bEmDs*~^#2ek+R&ERTJsXmth=A0%gz^VEam>4XD&siNX@bH
zzmMdHC=Qu)Jr#7nA3U=HUuTO0kX@wa+%B!E@O1_uQ>12tC*xP}(^4WbMQS#VNN4a1
zrY;8|yGYG1bqBTJujdYAiqsqxR%aZ~On(UK6shTQ==X7cL+b)e8g>OW8^ks)!4FXw
zB1LKjWWH<gcrA;=6up|ls!225SEuO)=ZpFwQ>5mODG{IemOp|_k(#I6y`S>eGtUvo
zPGh8?d&@8OE%`c!AycI0<QWSu^UO=g6sh^PyuHE8jckrWc9EK)V~)4tSK`UY6sg(5
z?u7@h=1pXZ)bt8{ww+%!D;}flG(-w&Hfuei7C%Hjh!m-rkSE$;rn`qsk(v$Xmp6F#
zR`uf$U8Ls8G?TCKLo^SWA~lP~4Q|0-&lkuPsd;GX;&gnSjZZ*!8g~WV-`L&B#@88$
zOp%(-9p+!<r=_pR6sZ}MAx9ZrO~;dvU8Ls1d=m_IiXq4psTpsxe+{o@s#8=aT}}lx
zb1bRYo*#B6M2ggO9=zX^AEK?u6seh5Iw~h$XS#5RE>g4g#)K#Q-M?PQ6sdXPan~rm
z<@X~~q~^xE{yX^Vnd3BM7pZwJZ->86X4GocpD%JpCiRkn?&;>OU&+^b4w)h~zpZt9
z$=_PCIs@57Y9^IS9nC+tYBDlKY7RQ*c#q%E-UlW{S5VXZ*T}Q{<+MFZ(cudjg(1rD
ztk_n*<!2&Oq-O1|{|(}2&xgnqshLpeNk3k9yK|6Tq~^6c^)m9;b3QUfYQA04=?tI!
z6*5I?wjJhV!)I@J9<qznbXooUJD)uOnbe;Oz2tGqZVKN^pO7h1bIOj@7x?Sh>H=gJ
zskx!vK7*G(1Ob!ER8VuRPo6UT5Pe3ZXw@vxx=8_k<!Ez}qRXCNbf)UI)BF%^My5#3
z&hL*^<y$FL1k@=~^K|<1O?aj=GDT{J#N9DCaIhDdA~h@2%;w9Fd!|c}U8LspjL+iu
zmhX>Dk(!%3UNG3qA3-Mdyn^m^_O33<_owA$$SzXzTfW?7`3>z*U=mV6%~?zK)#l4Q
zg-DT_ua3Ir;E!t+ilpeZM62e7THieQ@Ak$bQ>5nn(7k>5>^G39peB9E6XE{iipJFP
z>o<y(q9D6S&E5<As_}KsL8eH}w_)pZ@XY7P6sbA?{^#=ixHpQ1>>@R{&q`y%kNX;A
ziqw2FZ=JzywFG36M=9v8od(MCe$NS$n)>raov!@LPF1F0rbbNly1^NKiyRC@64MY#
z&AH8D)H}X8zao;DDFoNf7d>u1;T=Cf?PDl-C6Vki6264+>)Uo@ie&#7_rl=3XZov9
zr%3kj7IAJ`o!T|k%kF|qk?f_4wco_AnTL_7AUlow=#0I}^L6IB2H8cjKY8%jpC6+k
z$P~%mDqp}BKKprOl17I8N!dfb7bwnWx4I75MY4B4GOo5scKr|6#sQOB-cU{YnqySe
z)Ft@2^D-huYPKvtKAIn*GB+rCWvWx*a_;KBub|fM+6C6P{4`{W)GV>5gu&YW0GSGE
z()IM{djCJZm1^IF>>@RLI!zwLPj!otsh}p+={{&jMt&WBk4%x8S+fK_=X<H;EyylX
z^K!b9^>}6oG8NRM?3WAqXW;uY?QN)2q-Jc5G8uU_djXT$Q$fvAi}yM5!ybl6k($F#
z_N&3)Q_FmZqRZZomhI3>gCDL9MkZx9)SZTCOU4Iz_+dYbOp%%;F3z^%vlqJy*+pu)
zo4G{tbxuL1OwFq9zxejNk4%x82Zj|Z!1q#(Sja9?GuqGcFn`x#F)~GJI;@-8u;`yD
zUi;He^KXzTQZvKS1;PA=*6AK)r&dx>v+%|SEA#y+QTx-E8H7lYnk|DnIq=NX_n}OM
zRg*NbXuQsiXZA&=NX>~ozfR(r;mD-xsi3>Nm7T!~SL^{~7pWO@r|(d{<tHIiq-Lse
zxr*`3yT}x&IX~{POMyRqr2Xl8$?hR!S5Q-{?0*j$zwPt>?<*FQGglx}q^4Kw!xDU*
z-;gO%b9VW%2l-XA+at<O!>*v_;EK+P{5Mfs5h+shl>ewpe9K!rhB8HJPG~=}3g1eD
zkttGhY3X6d_&U!aQ>5nBP1kDj*VE<+WT!Dw(EaOJm!dq=7nve8Yp=Z<&oiGQQ>12e
z$4ZCzF|z*;vMZ=bQ?gTs-E;X}$XaBI)GTm!NEpvdM5aj1L8mQTcs08}rR+3B3Ti&M
zIlM4m=5|Di)SOa&Z#tft=^2zMQZs{%({R3(+>j|!^U(QY{dwjEWQx>0oVRKro>}TS
zWEZLFGb$<vKZVRdCXKs-?t8Mt=HticIWiU0q!n&|T+x%-##`g+SIs6bAiGG-3C<(W
z^4D`cGDT`un^5}*|2aF=OQ=(%=H%jYQ}G+x?!ctWsi5Y=t<w!=rLBk*skyW1>OB00
zA>%8GZYNUndzr;Qd8Ruu71X3w^7!etTO0P|o25u(iqxE8Zq+>hAEx%FZ_o0tA-hP;
z+s}Xe;M;R9GDT`yHER~ke|~+7OzI^C-E;gm^D<v&i#L#6q~-$qR!0i{xt7|W{(5dk
zrbx}H8Oy%lr@BmUp-z#SXIush<5x|0U{Z7iH5a?(GuSL0L!?N}gyLRK{KlrxJBluQ
ze$m2F(L?!J-W!<;YSLz@!^GixdFD-Iiqssjz|Df6k*mc)c9ELL-#)*^YcwC3A~n5p
z98AYgA#af>Qu9XcD!2JtHf`QRcIr<B-7`!YT9nVe37H}_@7OLV!;gFF4^XE_%_eW{
z?0Gd^fJtR4sQIpFf$aS6=XWDgq~^uEZ}*$Z)X#JoK2mhy`J&Lr4*WY*x+7DhW?uJU
zcIp4j#@e60&M;(()bxz{I-aldH!?+PZd!RO9nb6-57$$qrr((p&-p223o=D&PVw#7
zjMpgbC#X}T=Fc-R+xgv6A7oO`E9gG+#5gCu&eO;gsX3-cvA+C<*6K55C#0d8w5c2Z
za>r=?>(^n36sej1Tf<fSuty+Mw4r@dWXx%vS@H`+7pXaJb`ygyPo^MKq-N*oOZW1}
z-|iz*q~^KF&Exs()xJV@k(#ewcizdj=X_*})ZD%B>}Y;9dW%evn(6irH+UFn%Wsff
zq-Ha>ZKL_?xdEBvQ3|?ir-7Dr7@pgtrv7|U5;2KrXy*U+bQ*DoyHA3tlk|re+I;_)
zycUU>0#Z8*RAYOp$p*m@Nz4?2Ys^N|x;^2)$WKD1NcKWE1JCo@?k+zdx=8knb+Q^9
ze%pggk?iBQRmja>&+G|Mr%3j|kfP6ciQJJXlKsQ$1AX~AFCtSU`|{FD3_cN;_zBrX
zvM(Jl#fz`g2bm(-M`zubiJ$21A(PZhq31O<%UdQbH0?e0YS#Ki*{S6f)co!ADU2_3
z4kATrj%s_);HkDRkx6x?5M9&VK4xxi{!8~pi4a|+X1ce5?fGF3M5aj1lUvLjc;;7R
ziqzb4`;|4%Y@Y<#MQT1gpZ*fh+=fh%nn`!3CGpJkzoAZ%n(-MUfALdtUu25Z^ysl>
zG{1BlN2W;467KCk@oMHxl_r&|o5z6Ol`Gex_Eb=FR<9s?UQIVdiqtd@54p+@(K%#_
z)Qq<-f0JK1tj!=gWmnLB!TTn~`C*@oOp%)HeLF<(b;cr7q~^&fzd!KITB#wsf|~Tv
zs8-upKkX)vHr?qzxi3eiNX=8fs;uEZWxq$JNX^jR6+iR$e4C_!>>@RnR%y7AuQLRh
zA~lmDi^Q6k`c?B6FsYRk)GV=ZQ#JnHpJQ5zUR9*#(+m3z&h6|%rbx{l4O$u8^UaYC
z>J+Kj{kY9kehL|iOuC*5x-U6Dq%%L&MIck8X6NW@b9rVdbI7isCf)B|cJ4`ieit$w
znIbiNmU}UppXweUQ$bCdLdteZT}_*ow6A&eQ%LRfkX@u^<~MGo`0Kd>nIbhOHEQ#c
zSMv)nY1kFi3@NkP;ND-03>3YZf|_(W-&CI;r2R{aufLodkttHsyUvd*{N+rQ5$Y7F
zS-4u?zcnVWvnMh|YMPZW`^JA;co>;9Muxi6^&Hyi&_=C2lYje~-vY9W)XW$aa)7UM
z3^GM(_TOsvf@j`Drh=L@g>10Nor@p$>X{(BNX=7qo_FJ!i;yW&bFiP=30}?jz@#BE
zRFj5%c2I%8KM70Tp7xn3y6pXEMLkB$<yYdh$P}r$y?01Ke%MoGfjUKM)^8u<#xr{(
zQ>5mmeP-Qx=5b_-)O_7?*<@{eG_HQCE1VUw)3_VzPAxxm*u1g)=dE$b6sh?j<ZULN
zc@3E&HB0WSAHZu=J{x2gsTnx6{u6$;<cCa=nu*hP<l;YTJ_ROSPD3?mh_YUI`;9+q
zVV9kv3*V16|6DWvv(YkSiqvdzanLSpLec*8?fDs*A~pS*+85-rJLZ7wA~g>c-krD5
zpBlA4eVt**R8W(~=+2@Z<M``onG@<1skx^^k)C|Zdm)p0NkR81;~qETuV*we71X4q
z<9C^Q=e6t_SARV#=7Q`ZH9baM>}dL;L(iOxOp%)B%9`)wSIwuur05E2PRyF;Zkj)_
zwLg8CH7zN+?D<8}J+fca8cX}rGp8X_q-OBzeetF@Y3P|Zkg1?14SUUpr~bY@Ci$(9
zGPxnUNX<(54_D-;kg3R2P?PE$l-l|4JJ+-oNuT`zGDT|6akF^Ft64n{WEZJvf3x^#
z{y@wkWKw@B=<c!H>bj}r_1Rw{Q>13^ESGASzSYz->*a;)A~l-^cUontQ-2$19x$m)
z1vPI3&RWUOAWsmf@L7{)`G_>{44$f1D<4IdoiEB6n(hFv=5l0;)U4ai&q>o#Yf=3W
zy+Ni(%`_RNX5m}jAwOhSP?N6bF=y|W{6;YdnF?x>?onI3Cu(<Slk5HynIbhWI<)w~
z*V&-}WEZLFebemUi*)s4v<;cm^9s7#Z}@bV@A)(Zp-z#SUw)Yl=Qp&@z$B!Cnlo3H
z+t0WBHbjcl^f}nDG9NuvA&M@0eo?s9WG|lC1(^zJQp;EAZJvu~?m(tU%`?Z&7(A3R
zU17*BQgdp>x<C1r?~P0aH7R?u*Czw`6SN1Bsh}q59#k<fj@LbV5y&o5Gr-x+;QeTW
zkSS6#&F5w#_|^RsGRdP9bk~j?tZ#j9r%6ry`J%i<P1)fUDk+$$5%V7FY|F31gMdh4
zrhxo=IH2Lw@BE-2MI<p(2(B?}&%IQfZ%#`q3NCwoQONS*22bA|f=mV3sX0$qe*A`C
zhtDBXBzuNkVKq%dq+d6ztRcHd_9n4s3|>Gr3Yj9=9h>F6&yRZ)G8JT}3FOVD=LQcN
zw<!kMMY2Ea-{&zuAx}o8NcL<+P6hMKo5&Q&zPxg}BBpWIZ;@?_Q+E1PsGw$4LBEXr
z5cwcdq-JxkCV6-@?;w-vRM5Rd1<ya*SZyo&|F^SMN<ef4HK~=Ht|SiDMAiQE8qGqc
zNX<?$Il}ntPmw87^WMQaU3q4`l8{}b=5?pl`FQ3sWQx>mnI->P{@d60$P}qLGBBwg
z|4Flj4P+Oo*|lx2Ui>}ZmB<vS>ErqNlBqxSYJLGGwWorb)6dm5_+-?w6h(){T|uK?
z@tHpGL$m>zA~jExoi@)jE9o^#L?&fdsB=`Pr<*3K_NQk$m4@shH5at|ZO-4H-H1$)
zntRU1cIB^U>M~HLNX@j_FJ0iLr5?ysP?L5cmIVur(CXCMUVl9gB2%R1TK8@~{C(t{
zWg)vr&D&KR0{CCtcp+1yrv02ozfB)C^=e)RCbg1+nqT}Jn)9n>sd5xucE0GxhB^kH
zG$$idre^d*dw%x3iA<52@d?XY^BR>Z583H@8tP8%+4`(`ZH<}yTTNeNiqx#=yDx}u
z&;O7qQuAf*S^fEOx3`7t3To0W#JhfdgJ&WIB2%Phe)lH9{Iv89nIbhkpA8<uZ)n?B
zfb1eQZ6gC?`Bif>FlpEo)SUh<*N7s2T1orU&vc216m4j$_xEbc-}mfSk)q4qkM{g*
z#8Limz)56^)ZD%(u^>O}MJqv_3Tje&My+Z-im!7lGHHwyboZ@wJwdyk$#uVtOa(P*
z3JE*qbB||MuMF8mYR=wb(}dq7FG8kB&He6W=klxj8)Pb|N!jmQYH?K4NYhi_^UbP2
zc9EK`KF6)*SIyPHq#;sJ^UjWU_xa2D0g)m#-ESZH$<InHs#5goqE&NdW&e#la~(28
zYL57Pe<Yv%8!|;|x~!OQ#c#YFt3h@JHA(jv>-WF-?3<8D<8G)sF^@Kxw2f!}LZ(Q~
zi?>@1<yYbk)gik`&Gb<f(wkNzy+&J+sh}ohFB&u>JwNVdc2K8C&0o%!x|!<KZ)lx?
zNtaVW%{3LQGVo>YM5IVf&)tur_zhTw8Wdgj{G$3NQdi;Y9E41fngMT`+~YU2r;sU9
zb5r-Lf4_ayYSp(=(VCE5q~?YC_KtjZZ)A$pT;}+&Cck5dK_>N*q3*OAHC$ZBUVHv*
zv1HlH)q?B_Y7(<Txcyarg<FJ7k(%M<M$YA@rI*MQsX5{1iov{^4Qf+%imssM&bH6)
z^JOkUq)5$sb-GsKH+652DOxpmt=*NDZ_k!>Ai7A+iSs?}_*s4fGDT_@9O+%3zx($S
znIbip)X95;AEVB7A-hP;AH8Py^33hXR8W&vqsvRLyYbgEZ9S-y`qNN%VkY$|U6DWG
z-2<5-HRtCY|CH~gW5^V#`Cw|1{HEQKe$~uVpR!Y#3Tn=1eziWommiEsk(#~C-^cR9
zeh!%;HIv3BwB|2o;RX<0q~_b)g;())jz*?}nl#I&`c?KcKg&lVQ>5mQfFq0fI*T`i
z>>@QIGX!kmnd6WtQuEuM8I|~6ib1AGO*^la_Pp-4jUYSqyn^oQ9JV*&>-0sYNX>)G
zYc4hQr(Vs+z$B!Cnw{Ua2;_&TR%40|k4aI8{&UlwN~SXPo4N(a6sg(%_p|_>`3jjL
zHNT%6dy^mb#`ch1K~0+FKb^H|#$V5s$P}qLbW96_-<^C!rbx{~N!_>dKYDK21hR|N
zEaw#J!)M=)Oa(P*syo=@-Y0&lOX~o2DyT`!=Eon5&~`T3|LFVE8JXl!3O%o#2C_am
ze-(eeXdf}D<5MtGBen^Rs$e4OWjAm7FL`BJGgClnXMx)FnI6ka)D@A$Od+_&Y*>AE
zW7Bp)e=&C<lcFmyFT@sz=jTrIW)NK@d+~#rPw~y!7nvg2+umQjkY^r3rbzZvpY7lC
z_t3L9hwLKRT{fSs%TIJekSUTq>|}?V{5Ozik*Od%O`c{ESGV!~S*itOSCE~Ud+u1h
z;h9sADU#jGdU!@t&+FB^159dp1vN{?dQaeQ0@=2t=%BlyMl{d41=eY)4SVu0v*#j{
z>NI51<y@QQ)j|G7$TMV$)NEC|nIGTs4O&5Vk(wE;M!w~TeHAhl)THZq$UReU{@d3t
z$P}qrA%BM#{Ppb68nTPjY*(y7RsOEUc4UgwoZT(W-*29^{Q7A=a~r5rq-NSx377e4
zX)rQHYQ}FbR-0Ed9GKLe3Th5rKe7-%M0wg$blLf${qr--;iC^jrbtb@3XY%nVZVS(
z%C4Y$jWj!^^L3VL2iZkx{;aq51+V*LWGbjh)6()q{>S+`?;%s9rsI_T^Z7cfIYM@k
znrDAD*~j<NLS!naNz+o(hyPvBb|Knyr&se0GDT|oHJaJUbbnUQY}_8Qi_~<u(Wf=P
zp<Mw?Y9$3VGmq}!&ky@+M2a@F-_CYh&aWJeohW)$k(#Mj&3(Xc6a$edQuF<XK~4Fu
zW8#rX*Hc0Fti3OE<%iv|17sJe8G2w;5Pu&z7?~n9V+WOP$7^KP5$Y7FdCB7bCw`2&
zBU3?5nwGrByS+87MtY5QBU7a2l107t@XYj`AiGG-4g0O<n3(zvZ4Y45uq&wf<6HE9
zCZs-k7$QY#di%DY#H*REGewu3FRFRce6DF$(%0DwnIbjAr`CJJXWxZPk(vQ(s`fRV
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
Y#aY>ak<0MI{)hcP;L%G*ff^YY02c_`{{R30

literal 2827397
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%0A;ROD?WLU~I&j+6
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%0Diy
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
Up&W-ChrIlEp7`hghlL9LA9!SSMgRZ+

diff --git a/testdata/examples.txt b/testdata/examples.txt
index 9c18442e4..e4f6d36c8 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -2041,7 +2041,6 @@
 0.5 < 1 || ok
 0.5 < f32 && ok
 0.5 < f32 || ok
-0.5 <= 0.5 ? half : trimPrefix(nil)
 0.5 <= f64 ? i : i64
 0.5 <= f64 || ok
 0.5 == 1 and ok
@@ -3144,7 +3143,6 @@ all(reduce(array, array), # > #)
 all(reduce(array, list), ok)
 all(true ? list : false, not true)
 any(["bar"], # not endsWith #)
-any([foo], # != i64)
 any([greet], ok)
 any(array, !(i32 <= #))
 any(array, "foo" >= "foo")
@@ -6261,7 +6259,6 @@ findLast(map(list, #), greet == nil)
 findLast(map(list, #), ok)
 findLast(map(list, ok), # ? # : #)
 findLastIndex(1 .. 1, i64 < #)
-findLastIndex([false], 0.5 == #)
 findLastIndex([i64, half], ok)
 findLastIndex(array, "bar" not matches "foo")
 findLastIndex(array, "bar" startsWith "foo")
@@ -7231,7 +7228,6 @@ get(false ? f64 : 1, ok)
 get(false ? f64 : score, add)
 get(false ? false : f32, i)
 get(false ? i32 : list, i64)
-get(false ? i64 : foo, Bar)
 get(false ? i64 : true, f64)
 get(false ? score : ok, trimSuffix("bar", "bar"))
 get(filter(list, true), i)
@@ -7370,27 +7366,19 @@ get(map(list, i32), i64)
 get(map(list, i64), i64)
 get(ok ? "bar" : false, array)
 get(ok ? 1 : "bar", f32)
-get(ok ? 1 : add, String)
 get(ok ? add : f32, array)
-get(ok ? array : i, Bar)
-get(ok ? f32 : list, get(half, nil))
 get(ok ? f64 : div, i64)
-get(ok ? f64 : list, half in Bar)?.array()
 get(ok ? false : list, f32 > i)
 get(ok ? foo : 0.5, div)
-get(ok ? greet : "bar", get(add, String))
 get(ok ? half : i32, i)
 get(ok ? half : ok, f64)
 get(ok ? i : 0.5, half)
-get(ok ? i : half, String)
 get(ok ? i32 : half, f64)
 get(ok ? i64 : foo, f32)
 get(ok ? list : "foo", add)
 get(ok ? list : i32, f32)
 get(ok ? ok : div, greet)
-get(ok ? score : 1, Qux?.i)
 get(ok ? score : f64, i)
-get(ok ? score : foo, String?.foo())
 get(ok ? score : i64, foo)
 get(reduce(list, array), i32)
 get(sort(array), i32)
@@ -7398,19 +7386,14 @@ get(take(list, i), i64)
 get(true ? "bar" : ok, score(i))
 get(true ? "foo" : half, list)
 get(true ? 0.5 : i32, array)
-get(true ? 1 : array, Bar)?.f64
 get(true ? f32 : 0.5, ok)
 get(true ? false : foo, i64 > 0.5)
-get(true ? greet : false, Bar)
 get(true ? greet : i32, score)
-get(true ? half : 0.5, Qux)
 get(true ? half : f32, greet)
 get(true ? half : list, add)
 get(true ? i64 : greet, i32)
 get(true ? score : true, half)?.half
-get(true ? true : add, Qux)
 get(true ? true : i, f64)
-get({"bar": true, "foo": greet}.i, String)
 get({"foo": foo, "bar": false}, type(i))
 greet
 greet != add
@@ -12465,7 +12448,6 @@ map(1 .. i64, # ^ #)
 map(1 .. i64, #)
 map(1 .. i64, half)
 map(1 .. i64, i32)
-map([1], get(#, 1))
 map([f64], half)
 map([false], ok)
 map([half], #)
@@ -12475,7 +12457,6 @@ map([i32], foo)
 map([i32], greet)
 map([i32], half)
 map([list, 1, foo], i32)
-map([nil], #?.f32(ok, #, false))
 map([nil], foo)
 map([score, "bar"], f32)
 map([true, i32, 1], #)
@@ -14870,7 +14851,6 @@ ok ? array : foo
 ok ? array : foo.String
 ok ? array : foo?.String
 ok ? array : greet
-ok ? array : greet(nil)
 ok ? array : i
 ok ? array : i32
 ok ? array : list
@@ -14890,7 +14870,6 @@ ok ? div : ok
 ok ? div : score
 ok ? f32 != i32 : f32
 ok ? f32 ** i64 : score
-ok ? f32 : "foo" endsWith lower(nil)
 ok ? f32 : -0.5
 ok ? f32 : add
 ok ? f32 : array
@@ -15104,7 +15083,6 @@ ok or f64 <= 1
 ok or false ? ok : 1
 ok or false and false
 ok or foo != foo
-ok or fromJSON(nil)?.ok
 ok or half != add
 ok or half == div
 ok or i < 1
@@ -15340,29 +15318,15 @@ reduce(1 .. i64, greet)
 reduce(1 .. i64, half)
 reduce(["foo"], f32)
 reduce([0.5], f64)
-reduce([1], .Qux)
 reduce([div, "foo"], i32)
-reduce([div], # >= 0.5)
-reduce([div], list == #)
 reduce([f32, f64], f32)
-reduce([f32], .f64)
-reduce([f64], # or #)
-reduce([f64], .greet)
-reduce([false], # ** #)
 reduce([foo], ok)
-reduce([greet], # % 1)
 reduce([i32], list)
 reduce([i64, half], "bar" not startsWith "foo")
 reduce([i], # < #)
-reduce([i], #[array])
 reduce([i], ok)
-reduce([list], # - #)
-reduce([list], # or #)
 reduce([list], f64)
 reduce([nil], # in array)
-reduce([ok], #?.half)
-reduce([true], #?.score())
-reduce([true], 0.5 > #)
 reduce(array, !false)
 reduce(array, "foo" endsWith "foo")
 reduce(array, "foo") not in foo

From efa006a99a374f5240196daf74cecf5973f80528 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 1 Jun 2024 14:57:15 +0200
Subject: [PATCH 343/506] Remove Node.Kind() method

---
 ast/node.go          | 10 ----------
 compiler/compiler.go |  4 ++--
 2 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index 191ab1886..dfdf715fc 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -17,7 +17,6 @@ type Node interface {
 	SetLocation(file.Location)
 	Nature() nature.Nature
 	SetNature(nature.Nature)
-	Kind() reflect.Kind
 	Type() reflect.Type
 	SetType(reflect.Type)
 	String() string
@@ -57,15 +56,6 @@ func (n *base) SetNature(nature nature.Nature) {
 	n.nature = nature
 }
 
-// Kind returns the kind of the node.
-// If the type is nil (meaning unknown) then it returns reflect.Interface.
-func (n *base) Kind() reflect.Kind {
-	if n.nature.Type == nil {
-		return reflect.Interface
-	}
-	return n.nature.Type.Kind()
-}
-
 // Type returns the type of the node.
 func (n *base) Type() reflect.Type {
 	if n.nature.Type == nil {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index b4ec6dbd4..5e993540d 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -377,7 +377,7 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) {
 }
 
 func (c *compiler) FloatNode(node *ast.FloatNode) {
-	switch node.Kind() {
+	switch node.Type().Kind() {
 	case reflect.Float32:
 		c.emitPush(float32(node.Value))
 	case reflect.Float64:
@@ -1199,7 +1199,7 @@ func (c *compiler) PairNode(node *ast.PairNode) {
 }
 
 func (c *compiler) derefInNeeded(node ast.Node) {
-	switch node.Kind() {
+	switch node.Type().Kind() {
 	case reflect.Ptr, reflect.Interface:
 		c.emit(OpDeref)
 	}

From a31b1fefd615fdad63555dbe0f7a63445bdb178e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 4 Jun 2024 00:08:01 +0200
Subject: [PATCH 344/506] Refactor types table (#667)

---
 ast/node.go                        |   4 +-
 ast/print.go                       |   2 +-
 ast/visitor.go                     |   2 +-
 checker/checker.go                 | 186 +++++++++++++----------------
 checker/checker_test.go            |  61 ++++++----
 checker/info.go                    |  22 ++--
 checker/nature/nature.go           | 133 +++++++++++++++++----
 checker/nature/of.go               |  47 ++++++++
 checker/nature/types.go            |  13 --
 checker/nature/utils.go            |  76 ++++++++++++
 checker/types.go                   |  46 ++-----
 compiler/compiler.go               |  40 ++++---
 conf/config.go                     |  58 ++++-----
 conf/types_table.go                | 121 -------------------
 docgen/docgen.go                   |  13 +-
 docgen/docgen_test.go              |  16 ++-
 expr.go                            |   2 +-
 expr_test.go                       |  40 ++++++-
 optimizer/filter_map.go            |   4 +-
 optimizer/fold.go                  |   4 +-
 optimizer/optimizer_test.go        |  20 ++--
 optimizer/predicate_combination.go |  10 +-
 optimizer/sum_map_test.go          |   2 +-
 parser/parser.go                   |  48 ++++----
 parser/parser_test.go              |  14 +--
 patcher/operator_override.go       |   9 +-
 types/types.go                     |   5 +
 27 files changed, 544 insertions(+), 454 deletions(-)
 create mode 100644 checker/nature/of.go
 delete mode 100644 checker/nature/types.go
 create mode 100644 checker/nature/utils.go
 delete mode 100644 conf/types_table.go
 create mode 100644 types/types.go

diff --git a/ast/node.go b/ast/node.go
index dfdf715fc..6d98090b8 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -183,13 +183,13 @@ type BuiltinNode struct {
 	Map       Node   // Used by optimizer to fold filter() and map() builtins.
 }
 
-// ClosureNode represents a predicate.
+// PredicateNode represents a predicate.
 // Example:
 //
 //	filter(foo, .bar == 1)
 //
 // The predicate is ".bar == 1".
-type ClosureNode struct {
+type PredicateNode struct {
 	base
 	Node Node // Node of the predicate body.
 }
diff --git a/ast/print.go b/ast/print.go
index 6a7d698a9..f59377153 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -162,7 +162,7 @@ func (n *BuiltinNode) String() string {
 	return fmt.Sprintf("%s(%s)", n.Name, strings.Join(arguments, ", "))
 }
 
-func (n *ClosureNode) String() string {
+func (n *PredicateNode) String() string {
 	return n.Node.String()
 }
 
diff --git a/ast/visitor.go b/ast/visitor.go
index 90bc9f1d0..03d72d11d 100644
--- a/ast/visitor.go
+++ b/ast/visitor.go
@@ -45,7 +45,7 @@ func Walk(node *Node, v Visitor) {
 		for i := range n.Arguments {
 			Walk(&n.Arguments[i], v)
 		}
-	case *ClosureNode:
+	case *PredicateNode:
 		Walk(&n.Node, v)
 	case *PointerNode:
 	case *VariableDeclaratorNode:
diff --git a/checker/checker.go b/checker/checker.go
index fae8f5a16..0ad22f4e1 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -152,8 +152,8 @@ func (v *checker) visit(node ast.Node) Nature {
 		nt = v.CallNode(n)
 	case *ast.BuiltinNode:
 		nt = v.BuiltinNode(n)
-	case *ast.ClosureNode:
-		nt = v.ClosureNode(n)
+	case *ast.PredicateNode:
+		nt = v.PredicateNode(n)
 	case *ast.PointerNode:
 		nt = v.PointerNode(n)
 	case *ast.VariableDeclaratorNode:
@@ -194,19 +194,14 @@ func (v *checker) IdentifierNode(node *ast.IdentifierNode) Nature {
 	if node.Value == "$env" {
 		return unknown
 	}
-	return v.ident(node, node.Value, true, true)
+
+	return v.ident(node, node.Value, v.config.Env.Strict, true)
 }
 
 // ident method returns type of environment variable, builtin or function.
 func (v *checker) ident(node ast.Node, name string, strict, builtins bool) Nature {
-	if t, ok := v.config.Types[name]; ok {
-		if t.Ambiguous {
-			return v.error(node, "ambiguous identifier %v", name)
-		}
-		if t.Type == nil {
-			return nilNature
-		}
-		return Nature{Type: t.Type, Method: t.Method}
+	if nt, ok := v.config.Env.Get(name); ok {
+		return nt
 	}
 	if builtins {
 		if fn, ok := v.config.Functions[name]; ok {
@@ -219,9 +214,6 @@ func (v *checker) ident(node ast.Node, name string, strict, builtins bool) Natur
 	if v.config.Strict && strict {
 		return v.error(node, "unknown name %v", name)
 	}
-	if v.config.DefaultType != nil {
-		return Nature{Type: v.config.DefaultType}
-	}
 	return unknown
 }
 
@@ -419,16 +411,10 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature {
 
 	case "..":
 		if isInteger(l) && isInteger(r) {
-			return Nature{
-				Type:    arrayType,
-				SubType: Array{Of: integerNature},
-			}
+			return arrayOf(integerNature)
 		}
 		if or(l, r, isInteger) {
-			return Nature{
-				Type:    arrayType,
-				SubType: Array{Of: integerNature},
-			}
+			return arrayOf(integerNature)
 		}
 
 	case "??":
@@ -501,6 +487,13 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature {
 		if !prop.AssignableTo(base.Key()) && !isUnknown(prop) {
 			return v.error(node.Property, "cannot use %v to get an element from %v", prop, base)
 		}
+		if prop, ok := node.Property.(*ast.StringNode); ok {
+			if field, ok := base.Fields[prop.Value]; ok {
+				return field
+			} else if base.Strict {
+				return v.error(node.Property, "unknown field %v", prop.Value)
+			}
+		}
 		return base.Elem()
 
 	case reflect.Array, reflect.Slice:
@@ -512,7 +505,7 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature {
 	case reflect.Struct:
 		if name, ok := node.Property.(*ast.StringNode); ok {
 			propertyName := name.Value
-			if field, ok := fetchField(base, propertyName); ok {
+			if field, ok := base.FieldByName(propertyName); ok {
 				return Nature{Type: field.Type}
 			}
 			if node.Method {
@@ -625,15 +618,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 		v.begin(collection)
-		closure := v.visit(node.Arguments[1])
+		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(closure) &&
-			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
+		if isFunc(predicate) &&
+			predicate.NumOut() == 1 &&
+			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
 
-			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
+			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
 			}
 			return boolNature
 		}
@@ -646,23 +639,20 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 		v.begin(collection)
-		closure := v.visit(node.Arguments[1])
+		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(closure) &&
-			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
+		if isFunc(predicate) &&
+			predicate.NumOut() == 1 &&
+			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
 
-			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
+			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
 			}
 			if isUnknown(collection) {
 				return arrayNature
 			}
-			return Nature{
-				Type:    arrayType,
-				SubType: Array{Of: collection.Elem()},
-			}
+			return arrayOf(collection.Elem())
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
@@ -673,17 +663,14 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 		v.begin(collection, scopeVar{"index", integerNature})
-		closure := v.visit(node.Arguments[1])
+		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(closure) &&
-			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
+		if isFunc(predicate) &&
+			predicate.NumOut() == 1 &&
+			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
 
-			return Nature{
-				Type:    arrayType,
-				SubType: Array{Of: closure.Out(0)},
-			}
+			return arrayOf(*predicate.PredicateOut)
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
@@ -698,14 +685,14 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 		v.begin(collection)
-		closure := v.visit(node.Arguments[1])
+		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(closure) &&
-			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
-			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
+		if isFunc(predicate) &&
+			predicate.NumOut() == 1 &&
+			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
+			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
 			}
 
 			return integerNature
@@ -720,13 +707,13 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 
 		if len(node.Arguments) == 2 {
 			v.begin(collection)
-			closure := v.visit(node.Arguments[1])
+			predicate := v.visit(node.Arguments[1])
 			v.end()
 
-			if isFunc(closure) &&
-				closure.NumOut() == 1 &&
-				closure.NumIn() == 1 && isUnknown(closure.In(0)) {
-				return closure.Out(0)
+			if isFunc(predicate) &&
+				predicate.NumOut() == 1 &&
+				predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
+				return predicate.Out(0)
 			}
 		} else {
 			if isUnknown(collection) {
@@ -742,15 +729,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 		v.begin(collection)
-		closure := v.visit(node.Arguments[1])
+		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(closure) &&
-			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
+		if isFunc(predicate) &&
+			predicate.NumOut() == 1 &&
+			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
 
-			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
+			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
 			}
 			if isUnknown(collection) {
 				return unknown
@@ -766,15 +753,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 		v.begin(collection)
-		closure := v.visit(node.Arguments[1])
+		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(closure) &&
-			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
+		if isFunc(predicate) &&
+			predicate.NumOut() == 1 &&
+			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
 
-			if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
+			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
 			}
 			return integerNature
 		}
@@ -787,14 +774,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 		v.begin(collection)
-		closure := v.visit(node.Arguments[1])
+		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(closure) &&
-			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
+		if isFunc(predicate) &&
+			predicate.NumOut() == 1 &&
+			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
 
-			return Nature{Type: reflect.TypeOf(map[any][]any{})}
+			groups := arrayOf(collection.Elem())
+			return Nature{Type: reflect.TypeOf(map[any][]any{}), ArrayOf: &groups}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
@@ -805,18 +793,18 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 		v.begin(collection)
-		closure := v.visit(node.Arguments[1])
+		predicate := v.visit(node.Arguments[1])
 		v.end()
 
 		if len(node.Arguments) == 3 {
 			_ = v.visit(node.Arguments[2])
 		}
 
-		if isFunc(closure) &&
-			closure.NumOut() == 1 &&
-			closure.NumIn() == 1 && isUnknown(closure.In(0)) {
+		if isFunc(predicate) &&
+			predicate.NumOut() == 1 &&
+			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
 
-			return Nature{Type: reflect.TypeOf([]any{})}
+			return collection
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
@@ -827,15 +815,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 		v.begin(collection, scopeVar{"index", integerNature}, scopeVar{"acc", unknown})
-		closure := v.visit(node.Arguments[1])
+		predicate := v.visit(node.Arguments[1])
 		v.end()
 
 		if len(node.Arguments) == 3 {
 			_ = v.visit(node.Arguments[2])
 		}
 
-		if isFunc(closure) && closure.NumOut() == 1 {
-			return closure.Out(0)
+		if isFunc(predicate) && predicate.NumOut() == 1 {
+			return *predicate.PredicateOut
 		}
 		return v.error(node.Arguments[1], "predicate should has two input and one output param")
 
@@ -879,7 +867,9 @@ func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) Nature {
 
 	if id, ok := node.Arguments[0].(*ast.IdentifierNode); ok && id.Value == "$env" {
 		if s, ok := node.Arguments[1].(*ast.StringNode); ok {
-			return Nature{Type: v.config.Types[s.Value].Type}
+			if nt, ok := v.config.Env.Get(s.Value); ok {
+				return nt
+			}
 		}
 		return unknown
 	}
@@ -1106,24 +1096,23 @@ func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newNature Na
 	}
 }
 
-func (v *checker) ClosureNode(node *ast.ClosureNode) Nature {
+func (v *checker) PredicateNode(node *ast.PredicateNode) Nature {
 	nt := v.visit(node.Node)
-	var out reflect.Type
+	var out []reflect.Type
 	if isUnknown(nt) {
-		out = anyType
-	} else {
-		out = nt.Type
+		out = append(out, anyType)
+	} else if !isNil(nt) {
+		out = append(out, nt.Type)
+	}
+	return Nature{
+		Type:         reflect.FuncOf([]reflect.Type{anyType}, out, false),
+		PredicateOut: &nt,
 	}
-	return Nature{Type: reflect.FuncOf(
-		[]reflect.Type{anyType},
-		[]reflect.Type{out},
-		false,
-	)}
 }
 
 func (v *checker) PointerNode(node *ast.PointerNode) Nature {
 	if len(v.predicateScopes) == 0 {
-		return v.error(node, "cannot use pointer accessor outside closure")
+		return v.error(node, "cannot use pointer accessor outside predicate")
 	}
 	scope := v.predicateScopes[len(v.predicateScopes)-1]
 	if node.Name == "" {
@@ -1145,7 +1134,7 @@ func (v *checker) PointerNode(node *ast.PointerNode) Nature {
 }
 
 func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Nature {
-	if _, ok := v.config.Types[node.Name]; ok {
+	if _, ok := v.config.Env.Get(node.Name); ok {
 		return v.error(node, "cannot redeclare %v", node.Name)
 	}
 	if _, ok := v.config.Functions[node.Name]; ok {
@@ -1210,10 +1199,7 @@ func (v *checker) ArrayNode(node *ast.ArrayNode) Nature {
 		prev = curr
 	}
 	if allElementsAreSameType {
-		return Nature{
-			Type:    arrayNature.Type,
-			SubType: Array{Of: prev},
-		}
+		return arrayOf(prev)
 	}
 	return arrayNature
 }
diff --git a/checker/checker_test.go b/checker/checker_test.go
index ae42392c0..0639f1f43 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/expr-lang/expr/internal/testify/assert"
 	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/types"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
@@ -758,26 +759,6 @@ func TestCheck_TaggedFieldName(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-func TestCheck_Ambiguous(t *testing.T) {
-	type A struct {
-		Ambiguous bool
-	}
-	type B struct {
-		Ambiguous int
-	}
-	type Env struct {
-		A
-		B
-	}
-
-	tree, err := parser.Parse(`Ambiguous == 1`)
-	require.NoError(t, err)
-
-	_, err = checker.Check(tree, conf.New(Env{}))
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "ambiguous identifier Ambiguous")
-}
-
 func TestCheck_NoConfig(t *testing.T) {
 	tree, err := parser.Parse(`any`)
 	require.NoError(t, err)
@@ -831,7 +812,7 @@ func TestCheck_AllowUndefinedVariables_OptionalChaining(t *testing.T) {
 func TestCheck_PointerNode(t *testing.T) {
 	_, err := checker.Check(&parser.Tree{Node: &ast.PointerNode{}}, nil)
 	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "cannot use pointer accessor outside closure")
+	assert.Contains(t, err.Error(), "cannot use pointer accessor outside predicate")
 }
 
 func TestCheck_TypeWeights(t *testing.T) {
@@ -1088,3 +1069,41 @@ func TestCheck_builtin_without_call(t *testing.T) {
 		})
 	}
 }
+
+func TestCheck_types(t *testing.T) {
+	env := types.Map{
+		"foo": types.StrictMap{
+			"bar": types.Map{
+				"baz": "",
+			},
+		},
+	}
+
+	noerr := "no error"
+	tests := []struct {
+		code string
+		err  string
+	}{
+		{`unknown`, noerr},
+		{`foo.bar.baz > 0`, `invalid operation: > (mismatched types string and int)`},
+		{`foo.unknown.baz`, `unknown field unknown (1:5)`},
+		{`foo.bar.unknown`, noerr},
+		{`[foo] | map(.unknown)`, `unknown field unknown`},
+		{`[foo] | map(.bar) | filter(.baz)`, `predicate should return boolean (got string)`},
+	}
+
+	for _, test := range tests {
+		t.Run(test.code, func(t *testing.T) {
+			tree, err := parser.Parse(test.code)
+			require.NoError(t, err)
+
+			_, err = checker.Check(tree, conf.New(env))
+			if test.err == noerr {
+				require.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), test.err)
+			}
+		})
+	}
+}
diff --git a/checker/info.go b/checker/info.go
index 3c9396fd5..f1cc92ebe 100644
--- a/checker/info.go
+++ b/checker/info.go
@@ -4,15 +4,17 @@ import (
 	"reflect"
 
 	"github.com/expr-lang/expr/ast"
-	"github.com/expr-lang/expr/conf"
+	. "github.com/expr-lang/expr/checker/nature"
 	"github.com/expr-lang/expr/vm"
 )
 
-func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) {
+func FieldIndex(env Nature, node ast.Node) (bool, []int, string) {
 	switch n := node.(type) {
 	case *ast.IdentifierNode:
-		if t, ok := types[n.Value]; ok && len(t.FieldIndex) > 0 {
-			return true, t.FieldIndex, n.Value
+		if env.Kind() == reflect.Struct {
+			if field, ok := env.Get(n.Value); ok && len(field.FieldIndex) > 0 {
+				return true, field.FieldIndex, n.Value
+			}
 		}
 	case *ast.MemberNode:
 		base := n.Node.Nature()
@@ -20,8 +22,8 @@ func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) {
 		if base.Kind() == reflect.Struct {
 			if prop, ok := n.Property.(*ast.StringNode); ok {
 				name := prop.Value
-				if field, ok := fetchField(base, name); ok {
-					return true, field.Index, name
+				if field, ok := base.FieldByName(name); ok {
+					return true, field.FieldIndex, name
 				}
 			}
 		}
@@ -29,11 +31,13 @@ func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) {
 	return false, nil, ""
 }
 
-func MethodIndex(types conf.TypesTable, node ast.Node) (bool, int, string) {
+func MethodIndex(env Nature, node ast.Node) (bool, int, string) {
 	switch n := node.(type) {
 	case *ast.IdentifierNode:
-		if t, ok := types[n.Value]; ok {
-			return t.Method, t.MethodIndex, n.Value
+		if env.Kind() == reflect.Struct {
+			if m, ok := env.Get(n.Value); ok {
+				return m.Method, m.MethodIndex, n.Value
+			}
 		}
 	case *ast.MemberNode:
 		if name, ok := n.Property.(*ast.StringNode); ok {
diff --git a/checker/nature/nature.go b/checker/nature/nature.go
index a7365998c..a385521c5 100644
--- a/checker/nature/nature.go
+++ b/checker/nature/nature.go
@@ -12,16 +12,19 @@ var (
 )
 
 type Nature struct {
-	Type    reflect.Type
-	SubType SubType
-	Func    *builtin.Function
-	Method  bool
+	Type         reflect.Type      // Type of the value. If nil, then value is unknown.
+	Func         *builtin.Function // Used to pass function type from callee to CallNode.
+	ArrayOf      *Nature           // Elem nature of array type (usually Type is []any, but ArrayOf can be any nature).
+	PredicateOut *Nature           // Out nature of predicate.
+	Fields       map[string]Nature // Fields of map type.
+	Strict       bool              // If map is types.StrictMap.
+	Nil          bool              // If value is nil.
+	Method       bool              // If value retrieved from method. Usually used to determine amount of in arguments.
+	MethodIndex  int               // Index of method in type.
+	FieldIndex   []int             // Index of field in type.
 }
 
 func (n Nature) String() string {
-	if n.SubType != nil {
-		return n.SubType.String()
-	}
 	if n.Type != nil {
 		return n.Type.String()
 	}
@@ -54,8 +57,8 @@ func (n Nature) Elem() Nature {
 	case reflect.Map, reflect.Ptr:
 		return Nature{Type: n.Type.Elem()}
 	case reflect.Array, reflect.Slice:
-		if array, ok := n.SubType.(Array); ok {
-			return array.Of
+		if n.ArrayOf != nil {
+			return *n.ArrayOf
 		}
 		return Nature{Type: n.Type.Elem()}
 	}
@@ -63,6 +66,12 @@ func (n Nature) Elem() Nature {
 }
 
 func (n Nature) AssignableTo(nt Nature) bool {
+	if n.Nil {
+		// Untyped nil is assignable to any interface, but implements only the empty interface.
+		if nt.Type != nil && nt.Type.Kind() == reflect.Interface {
+			return true
+		}
+	}
 	if n.Type == nil || nt.Type == nil {
 		return false
 	}
@@ -88,24 +97,14 @@ func (n Nature) MethodByName(name string) (Nature, bool) {
 		// the same interface.
 		return Nature{Type: method.Type}, true
 	} else {
-		return Nature{Type: method.Type, Method: true}, true
+		return Nature{
+			Type:        method.Type,
+			Method:      true,
+			MethodIndex: method.Index,
+		}, true
 	}
 }
 
-func (n Nature) NumField() int {
-	if n.Type == nil {
-		return 0
-	}
-	return n.Type.NumField()
-}
-
-func (n Nature) Field(i int) reflect.StructField {
-	if n.Type == nil {
-		return reflect.StructField{}
-	}
-	return n.Type.Field(i)
-}
-
 func (n Nature) NumIn() int {
 	if n.Type == nil {
 		return 0
@@ -140,3 +139,89 @@ func (n Nature) IsVariadic() bool {
 	}
 	return n.Type.IsVariadic()
 }
+
+func (n Nature) FieldByName(name string) (Nature, bool) {
+	if n.Type == nil {
+		return unknown, false
+	}
+	field, ok := fetchField(n.Type, name)
+	return Nature{Type: field.Type, FieldIndex: field.Index}, ok
+}
+
+func (n Nature) IsFastMap() bool {
+	if n.Type == nil {
+		return false
+	}
+	if n.Type.Kind() == reflect.Map &&
+		n.Type.Key().Kind() == reflect.String &&
+		n.Type.Elem().Kind() == reflect.Interface {
+		return true
+	}
+	return false
+}
+
+func (n Nature) Get(name string) (Nature, bool) {
+	if n.Type == nil {
+		return unknown, false
+	}
+
+	if m, ok := n.MethodByName(name); ok {
+		return m, true
+	}
+
+	t := deref.Type(n.Type)
+
+	switch t.Kind() {
+	case reflect.Struct:
+		if f, ok := fetchField(t, name); ok {
+			return Nature{
+				Type:       f.Type,
+				FieldIndex: f.Index,
+			}, true
+		}
+	case reflect.Map:
+		if f, ok := n.Fields[name]; ok {
+			return f, true
+		}
+	}
+	return unknown, false
+}
+
+func (n Nature) All() map[string]Nature {
+	table := make(map[string]Nature)
+
+	if n.Type == nil {
+		return table
+	}
+
+	for i := 0; i < n.Type.NumMethod(); i++ {
+		method := n.Type.Method(i)
+		table[method.Name] = Nature{
+			Type:        method.Type,
+			Method:      true,
+			MethodIndex: method.Index,
+		}
+	}
+
+	t := deref.Type(n.Type)
+
+	switch t.Kind() {
+	case reflect.Struct:
+		for name, nt := range StructFields(t) {
+			if _, ok := table[name]; ok {
+				continue
+			}
+			table[name] = nt
+		}
+
+	case reflect.Map:
+		for key, nt := range n.Fields {
+			if _, ok := table[key]; ok {
+				continue
+			}
+			table[key] = nt
+		}
+	}
+
+	return table
+}
diff --git a/checker/nature/of.go b/checker/nature/of.go
new file mode 100644
index 000000000..93235f9cd
--- /dev/null
+++ b/checker/nature/of.go
@@ -0,0 +1,47 @@
+package nature
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/expr-lang/expr/types"
+)
+
+func Of(value any) Nature {
+	if value == nil {
+		return Nature{Nil: true}
+	}
+
+	v := reflect.ValueOf(value)
+
+	switch v.Kind() {
+	case reflect.Map:
+		_, strict := value.(types.StrictMap)
+		fields := make(map[string]Nature, v.Len())
+		for _, key := range v.MapKeys() {
+			elem := v.MapIndex(key)
+			if !elem.IsValid() || !elem.CanInterface() {
+				panic(fmt.Sprintf("invalid map value: %s", key))
+			}
+			face := elem.Interface()
+			switch face.(type) {
+			case types.Map, types.StrictMap:
+				fields[key.String()] = Of(face)
+			default:
+				if face == nil {
+					fields[key.String()] = Nature{Nil: true}
+					continue
+				}
+				fields[key.String()] = Nature{Type: reflect.TypeOf(face)}
+
+			}
+		}
+		return Nature{
+			Type:   v.Type(),
+			Fields: fields,
+			Strict: strict,
+		}
+	}
+
+	return Nature{Type: v.Type()}
+}
diff --git a/checker/nature/types.go b/checker/nature/types.go
deleted file mode 100644
index 1f9955e92..000000000
--- a/checker/nature/types.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package nature
-
-type SubType interface {
-	String() string
-}
-
-type Array struct {
-	Of Nature
-}
-
-func (a Array) String() string {
-	return "[]" + a.Of.String()
-}
diff --git a/checker/nature/utils.go b/checker/nature/utils.go
new file mode 100644
index 000000000..c242f91a6
--- /dev/null
+++ b/checker/nature/utils.go
@@ -0,0 +1,76 @@
+package nature
+
+import (
+	"reflect"
+
+	"github.com/expr-lang/expr/internal/deref"
+)
+
+func fieldName(field reflect.StructField) string {
+	if taggedName := field.Tag.Get("expr"); taggedName != "" {
+		return taggedName
+	}
+	return field.Name
+}
+
+func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
+	// First check all structs fields.
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		// Search all fields, even embedded structs.
+		if fieldName(field) == name {
+			return field, true
+		}
+	}
+
+	// Second check fields of embedded structs.
+	for i := 0; i < t.NumField(); i++ {
+		anon := t.Field(i)
+		if anon.Anonymous {
+			anonType := anon.Type
+			if anonType.Kind() == reflect.Pointer {
+				anonType = anonType.Elem()
+			}
+			if field, ok := fetchField(anonType, name); ok {
+				field.Index = append(anon.Index, field.Index...)
+				return field, true
+			}
+		}
+	}
+
+	return reflect.StructField{}, false
+}
+
+func StructFields(t reflect.Type) map[string]Nature {
+	table := make(map[string]Nature)
+
+	t = deref.Type(t)
+	if t == nil {
+		return table
+	}
+
+	switch t.Kind() {
+	case reflect.Struct:
+		for i := 0; i < t.NumField(); i++ {
+			f := t.Field(i)
+
+			if f.Anonymous {
+				for name, typ := range StructFields(f.Type) {
+					if _, ok := table[name]; ok {
+						continue
+					}
+					typ.FieldIndex = append(f.Index, typ.FieldIndex...)
+					table[name] = typ
+				}
+			}
+
+			table[fieldName(f)] = Nature{
+				Type:       f.Type,
+				FieldIndex: f.Index,
+			}
+
+		}
+	}
+
+	return table
+}
diff --git a/checker/types.go b/checker/types.go
index 2eb5392e0..ef93cf03d 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -5,12 +5,11 @@ import (
 	"time"
 
 	. "github.com/expr-lang/expr/checker/nature"
-	"github.com/expr-lang/expr/conf"
 )
 
 var (
 	unknown        = Nature{}
-	nilNature      = Nature{Type: reflect.TypeOf(Nil{})}
+	nilNature      = Nature{Nil: true}
 	boolNature     = Nature{Type: reflect.TypeOf(true)}
 	integerNature  = Nature{Type: reflect.TypeOf(0)}
 	floatNature    = Nature{Type: reflect.TypeOf(float64(0))}
@@ -28,14 +27,15 @@ var (
 	arrayType    = reflect.TypeOf([]any{})
 )
 
-// Nil is a special type to represent nil.
-type Nil struct{}
+func arrayOf(nt Nature) Nature {
+	return Nature{
+		Type:    arrayType,
+		ArrayOf: &nt,
+	}
+}
 
 func isNil(nt Nature) bool {
-	if nt.Type == nil {
-		return false
-	}
-	return nt.Type == nilNature.Type
+	return nt.Nil
 }
 
 func combined(l, r Nature) Nature {
@@ -72,7 +72,7 @@ func or(l, r Nature, fns ...func(Nature) bool) bool {
 
 func isUnknown(nt Nature) bool {
 	switch {
-	case nt.Type == nil:
+	case nt.Type == nil && !nt.Nil:
 		return true
 	case nt.Kind() == reflect.Interface:
 		return true
@@ -166,34 +166,6 @@ func isFunc(nt Nature) bool {
 	return false
 }
 
-func fetchField(nt Nature, name string) (reflect.StructField, bool) {
-	// First check all structs fields.
-	for i := 0; i < nt.NumField(); i++ {
-		field := nt.Field(i)
-		// Search all fields, even embedded structs.
-		if conf.FieldName(field) == name {
-			return field, true
-		}
-	}
-
-	// Second check fields of embedded structs.
-	for i := 0; i < nt.NumField(); i++ {
-		anon := nt.Field(i)
-		if anon.Anonymous {
-			anonType := anon.Type
-			if anonType.Kind() == reflect.Pointer {
-				anonType = anonType.Elem()
-			}
-			if field, ok := fetchField(Nature{Type: anonType}, name); ok {
-				field.Index = append(anon.Index, field.Index...)
-				return field, true
-			}
-		}
-	}
-
-	return reflect.StructField{}, false
-}
-
 func kind(t reflect.Type) reflect.Kind {
 	if t == nil {
 		return reflect.Invalid
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 5e993540d..68eae5ea1 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -9,6 +9,7 @@ import (
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/checker"
+	. "github.com/expr-lang/expr/checker/nature"
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/parser"
@@ -259,8 +260,8 @@ func (c *compiler) compile(node ast.Node) {
 		c.CallNode(n)
 	case *ast.BuiltinNode:
 		c.BuiltinNode(n)
-	case *ast.ClosureNode:
-		c.ClosureNode(n)
+	case *ast.PredicateNode:
+		c.PredicateNode(n)
 	case *ast.PointerNode:
 		c.PointerNode(n)
 	case *ast.VariableDeclaratorNode:
@@ -292,21 +293,19 @@ func (c *compiler) IdentifierNode(node *ast.IdentifierNode) {
 		return
 	}
 
-	var mapEnv bool
-	var types conf.TypesTable
+	var env Nature
 	if c.config != nil {
-		mapEnv = c.config.MapEnv
-		types = c.config.Types
+		env = c.config.Env
 	}
 
-	if mapEnv {
+	if env.IsFastMap() {
 		c.emit(OpLoadFast, c.addConstant(node.Value))
-	} else if ok, index, name := checker.FieldIndex(types, node); ok {
+	} else if ok, index, name := checker.FieldIndex(env, node); ok {
 		c.emit(OpLoadField, c.addConstant(&runtime.Field{
 			Index: index,
 			Path:  []string{name},
 		}))
-	} else if ok, index, name := checker.MethodIndex(types, node); ok {
+	} else if ok, index, name := checker.MethodIndex(env, node); ok {
 		c.emit(OpLoadMethod, c.addConstant(&runtime.Method{
 			Name:  name,
 			Index: index,
@@ -647,12 +646,12 @@ func (c *compiler) ChainNode(node *ast.ChainNode) {
 }
 
 func (c *compiler) MemberNode(node *ast.MemberNode) {
-	var types conf.TypesTable
+	var env Nature
 	if c.config != nil {
-		types = c.config.Types
+		env = c.config.Env
 	}
 
-	if ok, index, name := checker.MethodIndex(types, node); ok {
+	if ok, index, name := checker.MethodIndex(env, node); ok {
 		c.compile(node.Node)
 		c.emit(OpMethod, c.addConstant(&runtime.Method{
 			Name:  name,
@@ -663,14 +662,14 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 	op := OpFetch
 	base := node.Node
 
-	ok, index, nodeName := checker.FieldIndex(types, node)
+	ok, index, nodeName := checker.FieldIndex(env, node)
 	path := []string{nodeName}
 
 	if ok {
 		op = OpFetchField
 		for !node.Optional {
 			if ident, isIdent := base.(*ast.IdentifierNode); isIdent {
-				if ok, identIndex, name := checker.FieldIndex(types, ident); ok {
+				if ok, identIndex, name := checker.FieldIndex(env, ident); ok {
 					index = append(identIndex, index...)
 					path = append([]string{name}, path...)
 					c.emitLocation(ident.Location(), OpLoadField, c.addConstant(
@@ -681,7 +680,7 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 			}
 
 			if member, isMember := base.(*ast.MemberNode); isMember {
-				if ok, memberIndex, name := checker.FieldIndex(types, member); ok {
+				if ok, memberIndex, name := checker.FieldIndex(env, member); ok {
 					index = append(memberIndex, index...)
 					path = append([]string{name}, path...)
 					node = member
@@ -730,7 +729,7 @@ func (c *compiler) SliceNode(node *ast.SliceNode) {
 
 func (c *compiler) CallNode(node *ast.CallNode) {
 	fn := node.Callee.Type()
-	if kind(fn) == reflect.Func {
+	if fn.Kind() == reflect.Func {
 		fnInOffset := 0
 		fnNumIn := fn.NumIn()
 		switch callee := node.Callee.(type) {
@@ -742,7 +741,7 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 				}
 			}
 		case *ast.IdentifierNode:
-			if t, ok := c.config.Types[callee.Value]; ok && t.Method {
+			if t, ok := c.config.Env.MethodByName(callee.Value); ok && t.Method {
 				fnInOffset = 1
 				fnNumIn--
 			}
@@ -777,7 +776,7 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 	}
 	c.compile(node.Callee)
 
-	isMethod, _, _ := checker.MethodIndex(c.config.Types, node.Callee)
+	isMethod, _, _ := checker.MethodIndex(c.config.Env, node.Callee)
 	if index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok {
 		c.emit(OpCallTyped, index)
 		return
@@ -1117,7 +1116,7 @@ func (c *compiler) emitLoopBackwards(body func()) {
 	c.patchJump(end)
 }
 
-func (c *compiler) ClosureNode(node *ast.ClosureNode) {
+func (c *compiler) PredicateNode(node *ast.PredicateNode) {
 	c.compile(node.Node)
 }
 
@@ -1199,6 +1198,9 @@ func (c *compiler) PairNode(node *ast.PairNode) {
 }
 
 func (c *compiler) derefInNeeded(node ast.Node) {
+	if node.Nature().Nil {
+		return
+	}
 	switch node.Type().Kind() {
 	case reflect.Ptr, reflect.Interface:
 		c.emit(OpDeref)
diff --git a/conf/config.go b/conf/config.go
index 01a407a10..77bb2a67b 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -6,33 +6,32 @@ import (
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/checker/nature"
+	"github.com/expr-lang/expr/types"
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
 type FunctionsTable map[string]*builtin.Function
 
 type Config struct {
-	Env         any
-	Types       TypesTable
-	MapEnv      bool
-	DefaultType reflect.Type
-	Expect      reflect.Kind
-	ExpectAny   bool
-	Optimize    bool
-	Strict      bool
-	Profile     bool
-	ConstFns    map[string]reflect.Value
-	Visitors    []ast.Visitor
-	Functions   FunctionsTable
-	Builtins    FunctionsTable
-	Disabled    map[string]bool // disabled builtins
+	EnvObject any
+	Env       nature.Nature
+	Expect    reflect.Kind
+	ExpectAny bool
+	Optimize  bool
+	Strict    bool
+	Profile   bool
+	ConstFns  map[string]reflect.Value
+	Visitors  []ast.Visitor
+	Functions FunctionsTable
+	Builtins  FunctionsTable
+	Disabled  map[string]bool // disabled builtins
 }
 
 // CreateNew creates new config with default values.
 func CreateNew() *Config {
 	c := &Config{
 		Optimize:  true,
-		Types:     make(TypesTable),
 		ConstFns:  make(map[string]reflect.Value),
 		Functions: make(map[string]*builtin.Function),
 		Builtins:  make(map[string]*builtin.Function),
@@ -52,31 +51,20 @@ func New(env any) *Config {
 }
 
 func (c *Config) WithEnv(env any) {
-	var mapEnv bool
-	var mapValueType reflect.Type
-	if _, ok := env.(map[string]any); ok {
-		mapEnv = true
-	} else {
-		if reflect.ValueOf(env).Kind() == reflect.Map {
-			mapValueType = reflect.TypeOf(env).Elem()
-		}
-	}
-
-	c.Env = env
-	types := CreateTypesTable(env)
-	for name, t := range types {
-		c.Types[name] = t
-	}
-	c.MapEnv = mapEnv
-	c.DefaultType = mapValueType
 	c.Strict = true
+	c.EnvObject = env
+	c.Env = nature.Of(env)
+	c.Env.Strict = true // To keep backward compatibility with expr.AllowUndefinedVariables()
+	if _, ok := env.(types.Map); ok {
+		c.Env.Strict = false
+	}
 }
 
 func (c *Config) ConstExpr(name string) {
-	if c.Env == nil {
+	if c.EnvObject == nil {
 		panic("no environment is specified for ConstExpr()")
 	}
-	fn := reflect.ValueOf(runtime.Fetch(c.Env, name))
+	fn := reflect.ValueOf(runtime.Fetch(c.EnvObject, name))
 	if fn.Kind() != reflect.Func {
 		panic(fmt.Errorf("const expression %q must be a function", name))
 	}
@@ -99,7 +87,7 @@ func (c *Config) IsOverridden(name string) bool {
 	if _, ok := c.Functions[name]; ok {
 		return true
 	}
-	if _, ok := c.Types[name]; ok {
+	if _, ok := c.Env.Get(name); ok {
 		return true
 	}
 	return false
diff --git a/conf/types_table.go b/conf/types_table.go
deleted file mode 100644
index a42a42874..000000000
--- a/conf/types_table.go
+++ /dev/null
@@ -1,121 +0,0 @@
-package conf
-
-import (
-	"reflect"
-
-	"github.com/expr-lang/expr/internal/deref"
-)
-
-type TypesTable map[string]Tag
-
-type Tag struct {
-	Type        reflect.Type
-	Ambiguous   bool
-	FieldIndex  []int
-	Method      bool
-	MethodIndex int
-}
-
-// CreateTypesTable creates types table for type checks during parsing.
-// If struct is passed, all fields will be treated as variables,
-// as well as all fields of embedded structs and struct itself.
-//
-// If map is passed, all items will be treated as variables
-// (key as name, value as type).
-func CreateTypesTable(i any) TypesTable {
-	if i == nil {
-		return nil
-	}
-
-	types := make(TypesTable)
-	v := reflect.ValueOf(i)
-	t := reflect.TypeOf(i)
-
-	d := t
-	if t.Kind() == reflect.Ptr {
-		d = t.Elem()
-	}
-
-	switch d.Kind() {
-	case reflect.Struct:
-		types = FieldsFromStruct(d)
-
-		// Methods of struct should be gathered from original struct with pointer,
-		// as methods maybe declared on pointer receiver. Also this method retrieves
-		// all embedded structs methods as well, no need to recursion.
-		for i := 0; i < t.NumMethod(); i++ {
-			m := t.Method(i)
-			types[m.Name] = Tag{
-				Type:        m.Type,
-				Method:      true,
-				MethodIndex: i,
-			}
-		}
-
-	case reflect.Map:
-		for _, key := range v.MapKeys() {
-			value := v.MapIndex(key)
-			if key.Kind() == reflect.String && value.IsValid() && value.CanInterface() {
-				if key.String() == "$env" { // Could check for all keywords here
-					panic("attempt to misuse env keyword as env map key")
-				}
-				types[key.String()] = Tag{Type: reflect.TypeOf(value.Interface())}
-			}
-		}
-
-		// A map may have method too.
-		for i := 0; i < t.NumMethod(); i++ {
-			m := t.Method(i)
-			types[m.Name] = Tag{
-				Type:        m.Type,
-				Method:      true,
-				MethodIndex: i,
-			}
-		}
-	}
-
-	return types
-}
-
-func FieldsFromStruct(t reflect.Type) TypesTable {
-	types := make(TypesTable)
-	t = deref.Type(t)
-	if t == nil {
-		return types
-	}
-
-	switch t.Kind() {
-	case reflect.Struct:
-		for i := 0; i < t.NumField(); i++ {
-			f := t.Field(i)
-
-			if f.Anonymous {
-				for name, typ := range FieldsFromStruct(f.Type) {
-					if _, ok := types[name]; ok {
-						types[name] = Tag{Ambiguous: true}
-					} else {
-						typ.FieldIndex = append(f.Index, typ.FieldIndex...)
-						types[name] = typ
-					}
-				}
-			}
-			if fn := FieldName(f); fn == "$env" { // Could check for all keywords here
-				panic("attempt to misuse env keyword as env struct field tag")
-			} else {
-				types[FieldName(f)] = Tag{
-					Type:       f.Type,
-					FieldIndex: f.Index,
-				}
-			}
-		}
-	}
-
-	return types
-}
-
-func FieldName(field reflect.StructField) string {
-	if taggedName := field.Tag.Get("expr"); taggedName != "" {
-		return taggedName
-	}
-	return field.Name
-}
diff --git a/docgen/docgen.go b/docgen/docgen.go
index aed0f48f0..d9abcf0e4 100644
--- a/docgen/docgen.go
+++ b/docgen/docgen.go
@@ -5,7 +5,7 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/checker/nature"
 	"github.com/expr-lang/expr/internal/deref"
 )
 
@@ -84,8 +84,8 @@ func CreateDoc(i any) *Context {
 		PkgPath:   deref.Type(reflect.TypeOf(i)).PkgPath(),
 	}
 
-	for name, t := range conf.CreateTypesTable(i) {
-		if t.Ambiguous {
+	for name, t := range nature.Of(i).All() {
+		if _, ok := c.Variables[Identifier(name)]; ok {
 			continue
 		}
 		c.Variables[Identifier(name)] = c.use(t.Type, fromMethod(t.Method))
@@ -220,8 +220,11 @@ appendix:
 			c.Types[name] = a
 		}
 
-		for name, field := range conf.FieldsFromStruct(t) {
-			if isPrivate(name) || isProtobuf(name) || field.Ambiguous {
+		for name, field := range nature.StructFields(t) {
+			if isPrivate(name) || isProtobuf(name) {
+				continue
+			}
+			if _, ok := a.Fields[Identifier(name)]; ok {
 				continue
 			}
 			a.Fields[Identifier(name)] = c.use(field.Type)
diff --git a/docgen/docgen_test.go b/docgen/docgen_test.go
index 26cf4f7a9..2532a0c76 100644
--- a/docgen/docgen_test.go
+++ b/docgen/docgen_test.go
@@ -131,7 +131,7 @@ func TestCreateDoc(t *testing.T) {
 		PkgPath: "github.com/expr-lang/expr/docgen_test",
 	}
 
-	assert.EqualValues(t, expected, doc)
+	assert.Equal(t, expected.Markdown(), doc.Markdown())
 }
 
 type A struct {
@@ -160,6 +160,9 @@ func TestCreateDoc_Ambiguous(t *testing.T) {
 				Kind: "struct",
 				Name: "A",
 			},
+			"AmbiguousField": {
+				Kind: "int",
+			},
 			"B": {
 				Kind: "struct",
 				Name: "B",
@@ -189,16 +192,17 @@ func TestCreateDoc_Ambiguous(t *testing.T) {
 			"C": {
 				Kind: "struct",
 				Fields: map[Identifier]*Type{
-					"A":       {Kind: "struct", Name: "A"},
-					"B":       {Kind: "struct", Name: "B"},
-					"OkField": {Kind: "int"},
+					"A":              {Kind: "struct", Name: "A"},
+					"AmbiguousField": {Kind: "int"},
+					"B":              {Kind: "struct", Name: "B"},
+					"OkField":        {Kind: "int"},
 				},
 			},
 		},
 		PkgPath: "github.com/expr-lang/expr/docgen_test",
 	}
 
-	assert.EqualValues(t, expected, doc)
+	assert.Equal(t, expected.Markdown(), doc.Markdown())
 }
 
 func TestCreateDoc_FromMap(t *testing.T) {
@@ -247,7 +251,7 @@ func TestCreateDoc_FromMap(t *testing.T) {
 		},
 	}
 
-	require.EqualValues(t, expected, doc)
+	require.EqualValues(t, expected.Markdown(), doc.Markdown())
 }
 
 func TestContext_Markdown(t *testing.T) {
diff --git a/expr.go b/expr.go
index 8c619e1c4..5e60791e1 100644
--- a/expr.go
+++ b/expr.go
@@ -45,7 +45,7 @@ func Operator(operator string, fn ...string) Option {
 		p := &patcher.OperatorOverloading{
 			Operator:  operator,
 			Overloads: fn,
-			Types:     c.Types,
+			Env:       &c.Env,
 			Functions: c.Functions,
 		}
 		c.Visitors = append(c.Visitors, p)
diff --git a/expr_test.go b/expr_test.go
index 3724467fc..e71393f39 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -12,6 +12,7 @@ import (
 
 	"github.com/expr-lang/expr/internal/testify/assert"
 	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/types"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
@@ -1673,10 +1674,6 @@ func TestIssue105(t *testing.T) {
 
 	_, err := expr.Compile(code, expr.Env(Env{}))
 	require.NoError(t, err)
-
-	_, err = expr.Compile(`Field == ''`, expr.Env(Env{}))
-	require.Error(t, err)
-	require.Contains(t, err.Error(), "ambiguous identifier Field")
 }
 
 func TestIssue_nested_closures(t *testing.T) {
@@ -2704,3 +2701,38 @@ func TestExpr_nil_op_str(t *testing.T) {
 		})
 	}
 }
+
+func TestExpr_env_types_map(t *testing.T) {
+	envTypes := types.Map{
+		"foo": types.StrictMap{
+			"bar": "value",
+		},
+	}
+
+	program, err := expr.Compile(`foo.bar`, expr.Env(envTypes))
+	require.NoError(t, err)
+
+	env := map[string]any{
+		"foo": map[string]any{
+			"bar": "value",
+		},
+	}
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, "value", output)
+}
+
+func TestExpr_env_types_map_error(t *testing.T) {
+	envTypes := types.Map{
+		"foo": types.StrictMap{
+			"bar": "value",
+		},
+	}
+
+	program, err := expr.Compile(`foo.bar`, expr.Env(envTypes))
+	require.NoError(t, err)
+
+	_, err = expr.Run(program, envTypes)
+	require.Error(t, err)
+}
diff --git a/optimizer/filter_map.go b/optimizer/filter_map.go
index e916dd75b..c6de6c73e 100644
--- a/optimizer/filter_map.go
+++ b/optimizer/filter_map.go
@@ -10,14 +10,14 @@ func (*filterMap) Visit(node *Node) {
 	if mapBuiltin, ok := (*node).(*BuiltinNode); ok &&
 		mapBuiltin.Name == "map" &&
 		len(mapBuiltin.Arguments) == 2 {
-		if closure, ok := mapBuiltin.Arguments[1].(*ClosureNode); ok {
+		if predicate, ok := mapBuiltin.Arguments[1].(*PredicateNode); ok {
 			if filter, ok := mapBuiltin.Arguments[0].(*BuiltinNode); ok &&
 				filter.Name == "filter" &&
 				filter.Map == nil /* not already optimized */ {
 				patchCopyType(node, &BuiltinNode{
 					Name:      "filter",
 					Arguments: filter.Arguments,
-					Map:       closure.Node,
+					Map:       predicate.Node,
 				})
 			}
 		}
diff --git a/optimizer/fold.go b/optimizer/fold.go
index 2f4562c22..bb40eab93 100644
--- a/optimizer/fold.go
+++ b/optimizer/fold.go
@@ -298,8 +298,8 @@ func (fold *fold) Visit(node *Node) {
 						base.Arguments[0],
 						&BinaryNode{
 							Operator: "&&",
-							Left:     base.Arguments[1].(*ClosureNode).Node,
-							Right:    n.Arguments[1].(*ClosureNode).Node,
+							Left:     base.Arguments[1].(*PredicateNode).Node,
+							Right:    n.Arguments[1].(*PredicateNode).Node,
 						},
 					},
 				})
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 56a890492..7830c0e78 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -184,7 +184,7 @@ func TestOptimize_filter_len(t *testing.T) {
 		Name: "count",
 		Arguments: []ast.Node{
 			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
+			&ast.PredicateNode{
 				Node: &ast.BinaryNode{
 					Operator: "==",
 					Left: &ast.MemberNode{
@@ -211,7 +211,7 @@ func TestOptimize_filter_0(t *testing.T) {
 		Name: "find",
 		Arguments: []ast.Node{
 			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
+			&ast.PredicateNode{
 				Node: &ast.BinaryNode{
 					Operator: "==",
 					Left: &ast.MemberNode{
@@ -239,7 +239,7 @@ func TestOptimize_filter_first(t *testing.T) {
 		Name: "find",
 		Arguments: []ast.Node{
 			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
+			&ast.PredicateNode{
 				Node: &ast.BinaryNode{
 					Operator: "==",
 					Left: &ast.MemberNode{
@@ -267,7 +267,7 @@ func TestOptimize_filter_minus_1(t *testing.T) {
 		Name: "findLast",
 		Arguments: []ast.Node{
 			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
+			&ast.PredicateNode{
 				Node: &ast.BinaryNode{
 					Operator: "==",
 					Left: &ast.MemberNode{
@@ -295,7 +295,7 @@ func TestOptimize_filter_last(t *testing.T) {
 		Name: "findLast",
 		Arguments: []ast.Node{
 			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
+			&ast.PredicateNode{
 				Node: &ast.BinaryNode{
 					Operator: "==",
 					Left: &ast.MemberNode{
@@ -323,7 +323,7 @@ func TestOptimize_filter_map(t *testing.T) {
 		Name: "filter",
 		Arguments: []ast.Node{
 			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
+			&ast.PredicateNode{
 				Node: &ast.BinaryNode{
 					Operator: "==",
 					Left: &ast.MemberNode{
@@ -354,7 +354,7 @@ func TestOptimize_filter_map_first(t *testing.T) {
 		Name: "find",
 		Arguments: []ast.Node{
 			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
+			&ast.PredicateNode{
 				Node: &ast.BinaryNode{
 					Operator: "==",
 					Left: &ast.MemberNode{
@@ -402,7 +402,7 @@ func TestOptimize_predicate_combination(t *testing.T) {
 				Name: tt.fn,
 				Arguments: []ast.Node{
 					&ast.IdentifierNode{Value: "users"},
-					&ast.ClosureNode{
+					&ast.PredicateNode{
 						Node: &ast.BinaryNode{
 							Operator: tt.wantOp,
 							Left: &ast.BinaryNode{
@@ -452,7 +452,7 @@ func TestOptimize_predicate_combination_nested(t *testing.T) {
 		Name: "all",
 		Arguments: []ast.Node{
 			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
+			&ast.PredicateNode{
 				Node: &ast.BuiltinNode{
 					Name: "all",
 					Arguments: []ast.Node{
@@ -460,7 +460,7 @@ func TestOptimize_predicate_combination_nested(t *testing.T) {
 							Node:     &ast.PointerNode{},
 							Property: &ast.StringNode{Value: "Friends"},
 						},
-						&ast.ClosureNode{
+						&ast.PredicateNode{
 							Node: &ast.BinaryNode{
 								Operator: "&&",
 								Left: &ast.BinaryNode{
diff --git a/optimizer/predicate_combination.go b/optimizer/predicate_combination.go
index 62e296d1f..65f88e348 100644
--- a/optimizer/predicate_combination.go
+++ b/optimizer/predicate_combination.go
@@ -21,19 +21,19 @@ func (v *predicateCombination) Visit(node *Node) {
 			if combinedOp, ok := combinedOperator(left.Name, op.Operator); ok {
 				if right, ok := op.Right.(*BuiltinNode); ok && right.Name == left.Name {
 					if left.Arguments[0].Type() == right.Arguments[0].Type() && left.Arguments[0].String() == right.Arguments[0].String() {
-						closure := &ClosureNode{
+						predicate := &PredicateNode{
 							Node: &BinaryNode{
 								Operator: combinedOp,
-								Left:     left.Arguments[1].(*ClosureNode).Node,
-								Right:    right.Arguments[1].(*ClosureNode).Node,
+								Left:     left.Arguments[1].(*PredicateNode).Node,
+								Right:    right.Arguments[1].(*PredicateNode).Node,
 							},
 						}
-						v.Visit(&closure.Node)
+						v.Visit(&predicate.Node)
 						patchCopyType(node, &BuiltinNode{
 							Name: left.Name,
 							Arguments: []Node{
 								left.Arguments[0],
-								closure,
+								predicate,
 							},
 						})
 					}
diff --git a/optimizer/sum_map_test.go b/optimizer/sum_map_test.go
index 96bdcfd35..2d0ffeb77 100644
--- a/optimizer/sum_map_test.go
+++ b/optimizer/sum_map_test.go
@@ -22,7 +22,7 @@ func TestOptimize_sum_map(t *testing.T) {
 		Name: "sum",
 		Arguments: []ast.Node{
 			&ast.IdentifierNode{Value: "users"},
-			&ast.ClosureNode{
+			&ast.PredicateNode{
 				Node: &ast.MemberNode{
 					Node:     &ast.PointerNode{},
 					Property: &ast.StringNode{Value: "Age"},
diff --git a/parser/parser.go b/parser/parser.go
index 77b2a700a..0817f6e4b 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -19,7 +19,7 @@ type arg byte
 
 const (
 	expr arg = 1 << iota
-	closure
+	predicate
 )
 
 const optional arg = 1 << 7
@@ -27,21 +27,21 @@ const optional arg = 1 << 7
 var predicates = map[string]struct {
 	args []arg
 }{
-	"all":           {[]arg{expr, closure}},
-	"none":          {[]arg{expr, closure}},
-	"any":           {[]arg{expr, closure}},
-	"one":           {[]arg{expr, closure}},
-	"filter":        {[]arg{expr, closure}},
-	"map":           {[]arg{expr, closure}},
-	"count":         {[]arg{expr, closure | optional}},
-	"sum":           {[]arg{expr, closure | optional}},
-	"find":          {[]arg{expr, closure}},
-	"findIndex":     {[]arg{expr, closure}},
-	"findLast":      {[]arg{expr, closure}},
-	"findLastIndex": {[]arg{expr, closure}},
-	"groupBy":       {[]arg{expr, closure}},
-	"sortBy":        {[]arg{expr, closure, expr | optional}},
-	"reduce":        {[]arg{expr, closure, expr | optional}},
+	"all":           {[]arg{expr, predicate}},
+	"none":          {[]arg{expr, predicate}},
+	"any":           {[]arg{expr, predicate}},
+	"one":           {[]arg{expr, predicate}},
+	"filter":        {[]arg{expr, predicate}},
+	"map":           {[]arg{expr, predicate}},
+	"count":         {[]arg{expr, predicate | optional}},
+	"sum":           {[]arg{expr, predicate | optional}},
+	"find":          {[]arg{expr, predicate}},
+	"findIndex":     {[]arg{expr, predicate}},
+	"findLast":      {[]arg{expr, predicate}},
+	"findLastIndex": {[]arg{expr, predicate}},
+	"groupBy":       {[]arg{expr, predicate}},
+	"sortBy":        {[]arg{expr, predicate, expr | optional}},
+	"reduce":        {[]arg{expr, predicate, expr | optional}},
 }
 
 type parser struct {
@@ -49,7 +49,7 @@ type parser struct {
 	current Token
 	pos     int
 	err     *file.Error
-	depth   int // closure call depth
+	depth   int // predicate call depth
 	config  *conf.Config
 }
 
@@ -298,7 +298,7 @@ func (p *parser) parsePrimary() Node {
 		}
 	} else {
 		if token.Is(Operator, "#") || token.Is(Operator, ".") {
-			p.error("cannot use pointer accessor outside closure")
+			p.error("cannot use pointer accessor outside predicate")
 		}
 	}
 
@@ -448,8 +448,8 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 			switch {
 			case arg&expr == expr:
 				node = p.parseExpression(0)
-			case arg&closure == closure:
-				node = p.parseClosure()
+			case arg&predicate == predicate:
+				node = p.parsePredicate()
 			}
 			arguments = append(arguments, node)
 		}
@@ -497,7 +497,7 @@ func (p *parser) parseArguments(arguments []Node) []Node {
 	return arguments
 }
 
-func (p *parser) parseClosure() Node {
+func (p *parser) parsePredicate() Node {
 	startToken := p.current
 	expectClosingBracket := false
 	if p.current.Is(Bracket, "{") {
@@ -512,11 +512,11 @@ func (p *parser) parseClosure() Node {
 	if expectClosingBracket {
 		p.expect(Bracket, "}")
 	}
-	closure := &ClosureNode{
+	predicateNode := &PredicateNode{
 		Node: node,
 	}
-	closure.SetLocation(startToken.Location)
-	return closure
+	predicateNode.SetLocation(startToken.Location)
+	return predicateNode
 }
 
 func (p *parser) parseArrayExpression(token Token) Node {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 3c6ee5b2b..a280bf39a 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -427,7 +427,7 @@ world`},
 				Name: "all",
 				Arguments: []Node{
 					&IdentifierNode{Value: "Tickets"},
-					&ClosureNode{
+					&PredicateNode{
 						Node: &PointerNode{},
 					}}},
 		},
@@ -437,7 +437,7 @@ world`},
 				Name: "all",
 				Arguments: []Node{
 					&IdentifierNode{Value: "Tickets"},
-					&ClosureNode{
+					&PredicateNode{
 						Node: &BinaryNode{
 							Operator: ">",
 							Left: &MemberNode{Node: &PointerNode{},
@@ -450,7 +450,7 @@ world`},
 				Name: "one",
 				Arguments: []Node{
 					&IdentifierNode{Value: "Tickets"},
-					&ClosureNode{
+					&PredicateNode{
 						Node: &BinaryNode{
 							Operator: ">",
 							Left: &MemberNode{
@@ -463,7 +463,7 @@ world`},
 			"filter(Prices, {# > 100})",
 			&BuiltinNode{Name: "filter",
 				Arguments: []Node{&IdentifierNode{Value: "Prices"},
-					&ClosureNode{Node: &BinaryNode{Operator: ">",
+					&PredicateNode{Node: &BinaryNode{Operator: ">",
 						Left:  &PointerNode{},
 						Right: &IntegerNode{Value: 100}}}}},
 		},
@@ -550,7 +550,7 @@ world`},
 				Name: "map",
 				Arguments: []Node{
 					&ArrayNode{},
-					&ClosureNode{
+					&PredicateNode{
 						Node: &PointerNode{Name: "index"},
 					},
 				},
@@ -694,7 +694,7 @@ a map key must be a quoted string, a number, a identifier, or an expression encl
  | .....^
 
 .foo
-cannot use pointer accessor outside closure (1:1)
+cannot use pointer accessor outside predicate (1:1)
  | .foo
  | ^
 
@@ -904,7 +904,7 @@ func TestParse_pipe_operator(t *testing.T) {
 						Name: "map",
 						Arguments: []Node{
 							&IdentifierNode{Value: "arr"},
-							&ClosureNode{
+							&PredicateNode{
 								Node: &MemberNode{
 									Node:     &PointerNode{},
 									Property: &StringNode{Value: "foo"},
diff --git a/patcher/operator_override.go b/patcher/operator_override.go
index 551fe09bb..b2d20ec4b 100644
--- a/patcher/operator_override.go
+++ b/patcher/operator_override.go
@@ -6,13 +6,14 @@ import (
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/checker/nature"
 	"github.com/expr-lang/expr/conf"
 )
 
 type OperatorOverloading struct {
 	Operator  string              // Operator token to overload.
 	Overloads []string            // List of function names to replace operator with.
-	Types     conf.TypesTable     // Env types.
+	Env       *nature.Nature      // Env type.
 	Functions conf.FunctionsTable // Env functions.
 	applied   bool                // Flag to indicate if any changes were made to the tree.
 }
@@ -56,7 +57,7 @@ func (p *OperatorOverloading) FindSuitableOperatorOverload(l, r reflect.Type) (r
 
 func (p *OperatorOverloading) findSuitableOperatorOverloadInTypes(l, r reflect.Type) (reflect.Type, string, bool) {
 	for _, fn := range p.Overloads {
-		fnType, ok := p.Types[fn]
+		fnType, ok := p.Env.Get(fn)
 		if !ok {
 			continue
 		}
@@ -103,7 +104,7 @@ func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex
 
 func (p *OperatorOverloading) Check() {
 	for _, fn := range p.Overloads {
-		fnType, foundType := p.Types[fn]
+		fnType, foundType := p.Env.Get(fn)
 		fnFunc, foundFunc := p.Functions[fn]
 		if !foundFunc && (!foundType || fnType.Type.Kind() != reflect.Func) {
 			panic(fmt.Errorf("function %s for %s operator does not exist in the environment", fn, p.Operator))
@@ -119,7 +120,7 @@ func (p *OperatorOverloading) Check() {
 	}
 }
 
-func checkType(fnType conf.Tag, fn string, operator string) {
+func checkType(fnType nature.Nature, fn string, operator string) {
 	requiredNumIn := 2
 	if fnType.Method {
 		requiredNumIn = 3 // As first argument of method is receiver.
diff --git a/types/types.go b/types/types.go
new file mode 100644
index 000000000..9057d14aa
--- /dev/null
+++ b/types/types.go
@@ -0,0 +1,5 @@
+package types
+
+type Map map[string]any
+
+type StrictMap map[string]any

From ac6e5a388a6973c85e98c0f344f308765fcd00b8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 5 Jun 2024 01:14:25 +0200
Subject: [PATCH 345/506] Improve types pkg (#668)

---
 checker/checker_test.go |  2 +-
 checker/nature/of.go    | 47 --------------------------
 conf/config.go          |  7 +---
 conf/env.go             | 73 +++++++++++++++++++++++++++++++++++++++++
 docgen/docgen.go        |  3 +-
 expr_test.go            |  4 +--
 types/types.go          | 73 +++++++++++++++++++++++++++++++++++++++--
 7 files changed, 150 insertions(+), 59 deletions(-)
 delete mode 100644 checker/nature/of.go
 create mode 100644 conf/env.go

diff --git a/checker/checker_test.go b/checker/checker_test.go
index 0639f1f43..e5691b76d 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -1074,7 +1074,7 @@ func TestCheck_types(t *testing.T) {
 	env := types.Map{
 		"foo": types.StrictMap{
 			"bar": types.Map{
-				"baz": "",
+				"baz": types.String,
 			},
 		},
 	}
diff --git a/checker/nature/of.go b/checker/nature/of.go
deleted file mode 100644
index 93235f9cd..000000000
--- a/checker/nature/of.go
+++ /dev/null
@@ -1,47 +0,0 @@
-package nature
-
-import (
-	"fmt"
-	"reflect"
-
-	"github.com/expr-lang/expr/types"
-)
-
-func Of(value any) Nature {
-	if value == nil {
-		return Nature{Nil: true}
-	}
-
-	v := reflect.ValueOf(value)
-
-	switch v.Kind() {
-	case reflect.Map:
-		_, strict := value.(types.StrictMap)
-		fields := make(map[string]Nature, v.Len())
-		for _, key := range v.MapKeys() {
-			elem := v.MapIndex(key)
-			if !elem.IsValid() || !elem.CanInterface() {
-				panic(fmt.Sprintf("invalid map value: %s", key))
-			}
-			face := elem.Interface()
-			switch face.(type) {
-			case types.Map, types.StrictMap:
-				fields[key.String()] = Of(face)
-			default:
-				if face == nil {
-					fields[key.String()] = Nature{Nil: true}
-					continue
-				}
-				fields[key.String()] = Nature{Type: reflect.TypeOf(face)}
-
-			}
-		}
-		return Nature{
-			Type:   v.Type(),
-			Fields: fields,
-			Strict: strict,
-		}
-	}
-
-	return Nature{Type: v.Type()}
-}
diff --git a/conf/config.go b/conf/config.go
index 77bb2a67b..8a6ee70e2 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -7,7 +7,6 @@ import (
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/checker/nature"
-	"github.com/expr-lang/expr/types"
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
@@ -53,11 +52,7 @@ func New(env any) *Config {
 func (c *Config) WithEnv(env any) {
 	c.Strict = true
 	c.EnvObject = env
-	c.Env = nature.Of(env)
-	c.Env.Strict = true // To keep backward compatibility with expr.AllowUndefinedVariables()
-	if _, ok := env.(types.Map); ok {
-		c.Env.Strict = false
-	}
+	c.Env = Env(env)
 }
 
 func (c *Config) ConstExpr(name string) {
diff --git a/conf/env.go b/conf/env.go
new file mode 100644
index 000000000..82e6a93d9
--- /dev/null
+++ b/conf/env.go
@@ -0,0 +1,73 @@
+package conf
+
+import (
+	"fmt"
+	"reflect"
+
+	. "github.com/expr-lang/expr/checker/nature"
+	"github.com/expr-lang/expr/internal/deref"
+	"github.com/expr-lang/expr/types"
+)
+
+func Env(env any) Nature {
+	if env == nil {
+		return Nature{
+			Type:   reflect.TypeOf(map[string]any{}),
+			Strict: true,
+		}
+	}
+
+	switch env := env.(type) {
+	case types.Map:
+		return env.Nature()
+
+	case types.StrictMap:
+		return env.Nature()
+	}
+
+	v := reflect.ValueOf(env)
+	d := deref.Value(v)
+
+	switch d.Kind() {
+	case reflect.Struct:
+		return Nature{
+			Type:   v.Type(),
+			Strict: true,
+		}
+
+	case reflect.Map:
+		n := Nature{
+			Type:   v.Type(),
+			Fields: make(map[string]Nature, v.Len()),
+		}
+
+		for _, key := range v.MapKeys() {
+			elem := v.MapIndex(key)
+			if !elem.IsValid() || !elem.CanInterface() {
+				panic(fmt.Sprintf("invalid map value: %s", key))
+			}
+
+			face := elem.Interface()
+
+			switch face.(type) {
+			case types.Map:
+				n.Fields[key.String()] = face.(types.Map).Nature()
+
+			case types.StrictMap:
+				n.Fields[key.String()] = face.(types.StrictMap).Nature()
+
+			default:
+				if face == nil {
+					n.Fields[key.String()] = Nature{Nil: true}
+					continue
+				}
+				n.Fields[key.String()] = Nature{Type: reflect.TypeOf(face)}
+			}
+
+		}
+
+		return n
+	}
+
+	panic(fmt.Sprintf("unknown type %T", env))
+}
diff --git a/docgen/docgen.go b/docgen/docgen.go
index d9abcf0e4..1844f23b5 100644
--- a/docgen/docgen.go
+++ b/docgen/docgen.go
@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/expr-lang/expr/checker/nature"
+	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/internal/deref"
 )
 
@@ -84,7 +85,7 @@ func CreateDoc(i any) *Context {
 		PkgPath:   deref.Type(reflect.TypeOf(i)).PkgPath(),
 	}
 
-	for name, t := range nature.Of(i).All() {
+	for name, t := range conf.Env(i).All() {
 		if _, ok := c.Variables[Identifier(name)]; ok {
 			continue
 		}
diff --git a/expr_test.go b/expr_test.go
index e71393f39..4f2f829df 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2705,7 +2705,7 @@ func TestExpr_nil_op_str(t *testing.T) {
 func TestExpr_env_types_map(t *testing.T) {
 	envTypes := types.Map{
 		"foo": types.StrictMap{
-			"bar": "value",
+			"bar": types.String,
 		},
 	}
 
@@ -2726,7 +2726,7 @@ func TestExpr_env_types_map(t *testing.T) {
 func TestExpr_env_types_map_error(t *testing.T) {
 	envTypes := types.Map{
 		"foo": types.StrictMap{
-			"bar": "value",
+			"bar": types.String,
 		},
 	}
 
diff --git a/types/types.go b/types/types.go
index 9057d14aa..e707e18c0 100644
--- a/types/types.go
+++ b/types/types.go
@@ -1,5 +1,74 @@
 package types
 
-type Map map[string]any
+import (
+	"reflect"
 
-type StrictMap map[string]any
+	. "github.com/expr-lang/expr/checker/nature"
+)
+
+func TypeOf(v any) Type {
+	return rtype{t: reflect.TypeOf(v)}
+}
+
+var (
+	Int     = TypeOf(0)
+	Int8    = TypeOf(int8(0))
+	Int16   = TypeOf(int16(0))
+	Int32   = TypeOf(int32(0))
+	Int64   = TypeOf(int64(0))
+	Uint    = TypeOf(uint(0))
+	Uint8   = TypeOf(uint8(0))
+	Uint16  = TypeOf(uint16(0))
+	Uint32  = TypeOf(uint32(0))
+	Uint64  = TypeOf(uint64(0))
+	Float   = TypeOf(float32(0))
+	Float64 = TypeOf(float64(0))
+	String  = TypeOf("")
+	Bool    = TypeOf(true)
+	Nil     = nilType{}
+)
+
+type Type interface {
+	Nature() Nature
+}
+
+type nilType struct{}
+
+func (nilType) Nature() Nature {
+	return Nature{Nil: true}
+}
+
+type rtype struct {
+	t reflect.Type
+}
+
+func (r rtype) Nature() Nature {
+	return Nature{Type: r.t}
+}
+
+type Map map[string]Type
+
+func (m Map) Nature() Nature {
+	nt := Nature{
+		Type:   reflect.TypeOf(map[string]any{}),
+		Fields: make(map[string]Nature, len(m)),
+	}
+	for k, v := range m {
+		nt.Fields[k] = v.Nature()
+	}
+	return nt
+}
+
+type StrictMap map[string]Type
+
+func (m StrictMap) Nature() Nature {
+	nt := Nature{
+		Type:   reflect.TypeOf(map[string]any{}),
+		Fields: make(map[string]Nature, len(m)),
+		Strict: true,
+	}
+	for k, v := range m {
+		nt.Fields[k] = v.Nature()
+	}
+	return nt
+}

From 55f453b5769b8448261464c683e2ee8e42397e8f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 5 Jun 2024 15:48:40 +0200
Subject: [PATCH 346/506] Add types.Array()

---
 checker/checker_test.go |  5 +++++
 types/types.go          | 23 +++++++++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/checker/checker_test.go b/checker/checker_test.go
index e5691b76d..fad56eb28 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -1077,6 +1077,9 @@ func TestCheck_types(t *testing.T) {
 				"baz": types.String,
 			},
 		},
+		"arr": types.Array(types.StrictMap{
+			"value": types.String,
+		}),
 	}
 
 	noerr := "no error"
@@ -1090,6 +1093,8 @@ func TestCheck_types(t *testing.T) {
 		{`foo.bar.unknown`, noerr},
 		{`[foo] | map(.unknown)`, `unknown field unknown`},
 		{`[foo] | map(.bar) | filter(.baz)`, `predicate should return boolean (got string)`},
+		{`arr | filter(.value > 0)`, `invalid operation: > (mismatched types string and int)`},
+		{`arr | filter(.value contains "a") | filter(.value == 0)`, `invalid operation: == (mismatched types string and int)`},
 	}
 
 	for _, test := range tests {
diff --git a/types/types.go b/types/types.go
index e707e18c0..71dc8b5a9 100644
--- a/types/types.go
+++ b/types/types.go
@@ -28,6 +28,7 @@ var (
 	Nil     = nilType{}
 )
 
+// Type is a type that can be used to represent a value.
 type Type interface {
 	Nature() Nature
 }
@@ -46,6 +47,8 @@ func (r rtype) Nature() Nature {
 	return Nature{Type: r.t}
 }
 
+// Map returns a type that represents a map of the given type.
+// The map is not strict, meaning that it can contain keys not defined in the map.
 type Map map[string]Type
 
 func (m Map) Nature() Nature {
@@ -59,6 +62,8 @@ func (m Map) Nature() Nature {
 	return nt
 }
 
+// StrictMap returns a type that represents a map of the given type.
+// The map is strict, meaning that it can only contain keys defined in the map.
 type StrictMap map[string]Type
 
 func (m StrictMap) Nature() Nature {
@@ -72,3 +77,21 @@ func (m StrictMap) Nature() Nature {
 	}
 	return nt
 }
+
+// Array returns a type that represents an array of the given type.
+func Array(of Type) Type {
+	return array{of}
+}
+
+type array struct {
+	of Type
+}
+
+func (a array) Nature() Nature {
+	of := a.of.Nature()
+	return Nature{
+		Type:    reflect.TypeOf([]any{}),
+		Fields:  make(map[string]Nature, 1),
+		ArrayOf: &of,
+	}
+}

From 0c7f72008524679a9dbd9b6022d7fa73b1197f20 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 14 Jun 2024 09:23:26 +0200
Subject: [PATCH 347/506] Add types.Equal

---
 types/types.go      | 99 ++++++++++++++++++++++++++++++++++++++++++---
 types/types_test.go | 47 +++++++++++++++++++++
 2 files changed, 141 insertions(+), 5 deletions(-)
 create mode 100644 types/types_test.go

diff --git a/types/types.go b/types/types.go
index 71dc8b5a9..52b8d9b5c 100644
--- a/types/types.go
+++ b/types/types.go
@@ -1,13 +1,18 @@
 package types
 
 import (
+	"fmt"
 	"reflect"
+	"strings"
 
 	. "github.com/expr-lang/expr/checker/nature"
 )
 
-func TypeOf(v any) Type {
-	return rtype{t: reflect.TypeOf(v)}
+// Type is a type that can be used to represent a value.
+type Type interface {
+	Nature() Nature
+	Equal(Type) bool
+	String() string
 }
 
 var (
@@ -28,9 +33,11 @@ var (
 	Nil     = nilType{}
 )
 
-// Type is a type that can be used to represent a value.
-type Type interface {
-	Nature() Nature
+func TypeOf(v any) Type {
+	if v == nil {
+		return Nil
+	}
+	return rtype{t: reflect.TypeOf(v)}
 }
 
 type nilType struct{}
@@ -39,6 +46,14 @@ func (nilType) Nature() Nature {
 	return Nature{Nil: true}
 }
 
+func (nilType) Equal(t Type) bool {
+	return t == Nil
+}
+
+func (nilType) String() string {
+	return "nil"
+}
+
 type rtype struct {
 	t reflect.Type
 }
@@ -47,6 +62,17 @@ func (r rtype) Nature() Nature {
 	return Nature{Type: r.t}
 }
 
+func (r rtype) Equal(t Type) bool {
+	if rt, ok := t.(rtype); ok {
+		return r.t.String() == rt.t.String()
+	}
+	return false
+}
+
+func (r rtype) String() string {
+	return r.t.String()
+}
+
 // Map returns a type that represents a map of the given type.
 // The map is not strict, meaning that it can contain keys not defined in the map.
 type Map map[string]Type
@@ -62,6 +88,30 @@ func (m Map) Nature() Nature {
 	return nt
 }
 
+func (m Map) Equal(t Type) bool {
+	mt, ok := t.(Map)
+	if !ok {
+		return false
+	}
+	if len(m) != len(mt) {
+		return false
+	}
+	for k, v := range m {
+		if !v.Equal(mt[k]) {
+			return false
+		}
+	}
+	return true
+}
+
+func (m Map) String() string {
+	pairs := make([]string, 0, len(m))
+	for k, v := range m {
+		pairs = append(pairs, fmt.Sprintf("%s: %s", k, v.String()))
+	}
+	return fmt.Sprintf("Map{%s}", strings.Join(pairs, ", "))
+}
+
 // StrictMap returns a type that represents a map of the given type.
 // The map is strict, meaning that it can only contain keys defined in the map.
 type StrictMap map[string]Type
@@ -78,6 +128,30 @@ func (m StrictMap) Nature() Nature {
 	return nt
 }
 
+func (m StrictMap) Equal(t Type) bool {
+	mt, ok := t.(StrictMap)
+	if !ok {
+		return false
+	}
+	if len(m) != len(mt) {
+		return false
+	}
+	for k, v := range m {
+		if !v.Equal(mt[k]) {
+			return false
+		}
+	}
+	return true
+}
+
+func (m StrictMap) String() string {
+	pairs := make([]string, 0, len(m))
+	for k, v := range m {
+		pairs = append(pairs, fmt.Sprintf("%s: %s", k, v.String()))
+	}
+	return fmt.Sprintf("StrictMap{%s}", strings.Join(pairs, ", "))
+}
+
 // Array returns a type that represents an array of the given type.
 func Array(of Type) Type {
 	return array{of}
@@ -95,3 +169,18 @@ func (a array) Nature() Nature {
 		ArrayOf: &of,
 	}
 }
+
+func (a array) Equal(t Type) bool {
+	at, ok := t.(array)
+	if !ok {
+		return false
+	}
+	if a.of.Equal(at.of) {
+		return true
+	}
+	return false
+}
+
+func (a array) String() string {
+	return fmt.Sprintf("Array{%s}", a.of.String())
+}
diff --git a/types/types_test.go b/types/types_test.go
new file mode 100644
index 000000000..52b6c86a1
--- /dev/null
+++ b/types/types_test.go
@@ -0,0 +1,47 @@
+package types_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr/internal/testify/require"
+	. "github.com/expr-lang/expr/types"
+)
+
+func TestType_Equal(t *testing.T) {
+	tests := []struct {
+		index string
+		a, b  Type
+		want  bool
+	}{
+		{"1", Int, Int, true},
+		{"2", Int, Int8, false},
+		{"3", Int, Uint, false},
+		{"4", Int, Float, false},
+		{"5", Int, String, false},
+		{"6", Int, Bool, false},
+		{"7", Int, Nil, false},
+		{"8", Int, Array(Int), false},
+		{"9", Int, Map{"foo": Int}, false},
+		{"10", Int, StrictMap{"foo": Int}, false},
+		{"11", Int, Array(Int), false},
+		{"12", Array(Int), Array(Int), true},
+		{"13", Array(Int), Array(Float), false},
+		{"14", Map{"foo": Int}, Map{"foo": Int}, true},
+		{"15", Map{"foo": Int}, Map{"foo": Float}, false},
+		{"16", Map{"foo": Int}, StrictMap{"foo": Int}, false},
+		{"17", StrictMap{"foo": Int}, StrictMap{"foo": Int}, true},
+		{"18", StrictMap{"foo": Int}, StrictMap{"foo": Float}, false},
+		{"19", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Int}}, true},
+		{"20", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Float}}, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.index, func(t *testing.T) {
+			if tt.want {
+				require.True(t, tt.a.Equal(tt.b), tt.a.String()+" == "+tt.b.String())
+			} else {
+				require.False(t, tt.a.Equal(tt.b), tt.a.String()+" == "+tt.b.String())
+			}
+		})
+	}
+}

From b24c7f3a1066a712181f1ddd27a0d6911d193542 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 14 Jun 2024 09:32:52 +0200
Subject: [PATCH 348/506] Add any type

---
 types/types.go      | 30 ++++++++++++++++++++++++++++++
 types/types_test.go |  9 +++++++++
 2 files changed, 39 insertions(+)

diff --git a/types/types.go b/types/types.go
index 52b8d9b5c..92923f9a3 100644
--- a/types/types.go
+++ b/types/types.go
@@ -31,6 +31,7 @@ var (
 	String  = TypeOf("")
 	Bool    = TypeOf(true)
 	Nil     = nilType{}
+	Any     = anyType{}
 )
 
 func TypeOf(v any) Type {
@@ -40,6 +41,20 @@ func TypeOf(v any) Type {
 	return rtype{t: reflect.TypeOf(v)}
 }
 
+type anyType struct{}
+
+func (anyType) Nature() Nature {
+	return Nature{Type: nil}
+}
+
+func (anyType) Equal(t Type) bool {
+	return true
+}
+
+func (anyType) String() string {
+	return "any"
+}
+
 type nilType struct{}
 
 func (nilType) Nature() Nature {
@@ -47,6 +62,9 @@ func (nilType) Nature() Nature {
 }
 
 func (nilType) Equal(t Type) bool {
+	if t == Any {
+		return true
+	}
 	return t == Nil
 }
 
@@ -63,6 +81,9 @@ func (r rtype) Nature() Nature {
 }
 
 func (r rtype) Equal(t Type) bool {
+	if t == Any {
+		return true
+	}
 	if rt, ok := t.(rtype); ok {
 		return r.t.String() == rt.t.String()
 	}
@@ -89,6 +110,9 @@ func (m Map) Nature() Nature {
 }
 
 func (m Map) Equal(t Type) bool {
+	if t == Any {
+		return true
+	}
 	mt, ok := t.(Map)
 	if !ok {
 		return false
@@ -129,6 +153,9 @@ func (m StrictMap) Nature() Nature {
 }
 
 func (m StrictMap) Equal(t Type) bool {
+	if t == Any {
+		return true
+	}
 	mt, ok := t.(StrictMap)
 	if !ok {
 		return false
@@ -171,6 +198,9 @@ func (a array) Nature() Nature {
 }
 
 func (a array) Equal(t Type) bool {
+	if t == Any {
+		return true
+	}
 	at, ok := t.(array)
 	if !ok {
 		return false
diff --git a/types/types_test.go b/types/types_test.go
index 52b6c86a1..eacfef221 100644
--- a/types/types_test.go
+++ b/types/types_test.go
@@ -33,6 +33,15 @@ func TestType_Equal(t *testing.T) {
 		{"18", StrictMap{"foo": Int}, StrictMap{"foo": Float}, false},
 		{"19", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Int}}, true},
 		{"20", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Float}}, false},
+		{"21", Any, Any, true},
+		{"22", Any, Int, true},
+		{"23", Int, Any, true},
+		{"24", Any, Map{"foo": Int}, true},
+		{"25", Map{"foo": Int}, Any, true},
+		{"26", Any, StrictMap{"foo": Int}, true},
+		{"27", StrictMap{"foo": Int}, Any, true},
+		{"28", Any, Array(Int), true},
+		{"29", Array(Int), Any, true},
 	}
 
 	for _, tt := range tests {

From 971388017260b2241784c4ed216f8e6eb91ef7f5 Mon Sep 17 00:00:00 2001
From: zhuliquan <zlqlovecode@foxmail.com>
Date: Mon, 24 Jun 2024 03:20:41 +0800
Subject: [PATCH 349/506] Fix unary node print for conditional expr (#676)

* feat: extract code for compiling equal operator

* fix: fix unary node inside condition node print
---
 ast/print.go      | 11 +++++++----
 ast/print_test.go |  1 +
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/ast/print.go b/ast/print.go
index f59377153..b79048b2c 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -45,13 +45,16 @@ func (n *ConstantNode) String() string {
 }
 
 func (n *UnaryNode) String() string {
-	op := ""
+	op := n.Operator
 	if n.Operator == "not" {
 		op = fmt.Sprintf("%s ", n.Operator)
-	} else {
-		op = fmt.Sprintf("%s", n.Operator)
 	}
-	if _, ok := n.Node.(*BinaryNode); ok {
+	wrap := false
+	switch n.Node.(type) {
+	case *BinaryNode, *ConditionalNode:
+		wrap = true
+	}
+	if wrap {
 		return fmt.Sprintf("%s(%s)", op, n.Node.String())
 	}
 	return fmt.Sprintf("%s%s", op, n.Node.String())
diff --git a/ast/print_test.go b/ast/print_test.go
index 51edd63f5..a4b20b0a1 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -77,6 +77,7 @@ func TestPrint(t *testing.T) {
 		{`(nil ?? 1) > 0`, `(nil ?? 1) > 0`},
 		{`{("a" + "b"): 42}`, `{("a" + "b"): 42}`},
 		{`(One == 1 ? true : false) && Two == 2`, `(One == 1 ? true : false) && Two == 2`},
+		{`not (a == 1 ? b > 1 : b < 2)`, `not (a == 1 ? b > 1 : b < 2)`},
 	}
 
 	for _, tt := range tests {

From c42572b9c7d8471776ed9a8b5bade850cff73d26 Mon Sep 17 00:00:00 2001
From: Arik Cohen <me@arikcohen.com>
Date: Thu, 4 Jul 2024 17:49:14 -0400
Subject: [PATCH 350/506] Add Tork to its list of users (#682)

Signed-off-by: Arik Cohen <me@arikcohen.com>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 6c56c67b6..71ec78764 100644
--- a/README.md
+++ b/README.md
@@ -165,6 +165,7 @@ func main() {
 * [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products.
 * [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery.
 * [Melrōse](https://melrōse.org) uses Expr to implement its music programming language.
+* [Tork](https://www.tork.run/) integrates Expr into its workflow execution.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From 5e3d5a2e7d97cc6be84d181cbbee4d319853a940 Mon Sep 17 00:00:00 2001
From: Simon Waldherr <git@simon.waldherr.eu>
Date: Sun, 14 Jul 2024 09:07:58 +0200
Subject: [PATCH 351/506] Fix typos (#686)

---
 internal/spew/internalunsafe_test.go | 2 +-
 test/operator/operator_test.go       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/internal/spew/internalunsafe_test.go b/internal/spew/internalunsafe_test.go
index 2b547c41c..aa8fa00b1 100644
--- a/internal/spew/internalunsafe_test.go
+++ b/internal/spew/internalunsafe_test.go
@@ -47,7 +47,7 @@ func changeKind(v *reflect.Value, readOnly bool) {
 	*flags |= flagKindMask
 }
 
-// TestAddedReflectValue tests functionaly of the dump and formatter code which
+// TestAddedReflectValue tests functionality of the dump and formatter code which
 // falls back to the standard fmt library for new types that might get added to
 // the language.
 func TestAddedReflectValue(t *testing.T) {
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index 2ebb176f8..ec7da8724 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -148,7 +148,7 @@ func TestOperator_FunctionOverTypesPrecedence(t *testing.T) {
 		expr.Env(env),
 		expr.Operator("+", "Add"),
 		expr.Function("Add", func(args ...interface{}) (interface{}, error) {
-			// Wierd function that returns 100 + a + b in testing purposes.
+			// Weird function that returns 100 + a + b for testing purposes.
 			return args[0].(int) + args[1].(int) + 100, nil
 		},
 			new(func(_ int, __ int) int),

From 5e660e753e47a4f3a3a9e234f625dc210b5a331e Mon Sep 17 00:00:00 2001
From: OlgaNovg <75758884+OlgaNovg@users.noreply.github.com>
Date: Mon, 15 Jul 2024 11:19:33 +0200
Subject: [PATCH 352/506] Add flatten builtin (#684)

---
 builtin/builtin.go          | 31 +++++++++++++++++++++++++++++++
 builtin/builtin_test.go     |  5 +++++
 builtin/lib.go              | 14 ++++++++++++++
 docs/language-definition.md |  8 ++++++++
 4 files changed, 58 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index cc6f197cd..0107d276c 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -873,6 +873,37 @@ var Builtins = []*Function{
 			return arrayType, nil
 		},
 	},
+	{
+		Name: "flatten",
+		Safe: func(args ...any) (any, uint, error) {
+			var size uint
+			if len(args) != 1 {
+				return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			v := reflect.ValueOf(deref.Deref(args[0]))
+			if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
+				return nil, size, fmt.Errorf("cannot flatten %s", v.Kind())
+			}
+			ret := flatten(v)
+			size = uint(len(ret))
+			return ret, size, nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+
+			for _, arg := range args {
+				switch kind(deref.Type(arg)) {
+				case reflect.Interface, reflect.Slice, reflect.Array:
+				default:
+					return anyType, fmt.Errorf("cannot flatten %s", arg)
+				}
+			}
+
+			return arrayType, nil
+		},
+	},
 	{
 		Name: "sort",
 		Safe: func(args ...any) (any, uint, error) {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 97f249896..ddfb4a494 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -152,6 +152,9 @@ func TestBuiltin(t *testing.T) {
 		{`reduce([], 5, 0)`, 0},
 		{`concat(ArrayOfString, ArrayOfInt)`, []any{"foo", "bar", "baz", 1, 2, 3}},
 		{`concat(PtrArrayWithNil, [nil])`, []any{42, nil}},
+		{`flatten([["a", "b"], [1, 2]])`, []any{"a", "b", 1, 2}},
+		{`flatten([["a", "b"], [1, 2, [3, 4]]])`, []any{"a", "b", 1, 2, 3, 4}},
+		{`flatten([["a", "b"], [1, 2, [3, [[[["c", "d"], "e"]]], 4]]])`, []any{"a", "b", 1, 2, 3, "c", "d", "e", 4}},
 	}
 
 	for _, test := range tests {
@@ -236,6 +239,8 @@ func TestBuiltin_errors(t *testing.T) {
 		{`now(nil)`, "invalid number of arguments (expected 0, got 1)"},
 		{`date(nil)`, "interface {} is nil, not string (1:1)"},
 		{`timezone(nil)`, "cannot use nil as argument (type string) to call timezone (1:10)"},
+		{`flatten([1, 2], [3, 4])`, "invalid number of arguments (expected 1, got 2)"},
+		{`flatten(1)`, "cannot flatten int"},
 	}
 	for _, test := range errorTests {
 		t.Run(test.input, func(t *testing.T) {
diff --git a/builtin/lib.go b/builtin/lib.go
index e3cd61b96..13c7d207e 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -359,3 +359,17 @@ func median(args ...any) ([]float64, error) {
 	}
 	return values, nil
 }
+
+func flatten(arg reflect.Value) []any {
+	ret := []any{}
+	for i := 0; i < arg.Len(); i++ {
+		v := deref.Value(arg.Index(i))
+		if v.Kind() == reflect.Array || v.Kind() == reflect.Slice {
+			x := flatten(v)
+			ret = append(ret, x...)
+		} else {
+			ret = append(ret, v.Interface())
+		}
+	}
+	return ret
+}
diff --git a/docs/language-definition.md b/docs/language-definition.md
index c8709aa04..9c277e9a2 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -689,6 +689,14 @@ Concatenates two or more arrays.
 concat([1, 2], [3, 4]) == [1, 2, 3, 4]
 ```
 
+### flatten(array) {#flatten}
+
+Flattens given array into one-dimentional array.
+
+```expr
+flatten([1, 2, [3, 4]]) == [1, 2, 3, 4]
+```
+
 ### join(array[, delimiter]) {#join}
 
 Joins an array of strings into a single string with the given delimiter.

From c72da7bf4db186bd6ca94ca58dc8da83d3bf3495 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 28 Aug 2024 22:47:47 +0200
Subject: [PATCH 353/506] Drop types.StrictMap and add types.Extra to define
 additional keys

---
 checker/checker_test.go | 11 +++++----
 conf/env.go             |  6 -----
 expr_test.go            |  4 ++--
 types/types.go          | 53 +++++++----------------------------------
 types/types_test.go     |  8 +------
 5 files changed, 18 insertions(+), 64 deletions(-)

diff --git a/checker/checker_test.go b/checker/checker_test.go
index fad56eb28..602fe4b7a 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -1072,14 +1072,16 @@ func TestCheck_builtin_without_call(t *testing.T) {
 
 func TestCheck_types(t *testing.T) {
 	env := types.Map{
-		"foo": types.StrictMap{
+		"foo": types.Map{
 			"bar": types.Map{
-				"baz": types.String,
+				"baz":       types.String,
+				types.Extra: types.String,
 			},
 		},
-		"arr": types.Array(types.StrictMap{
+		"arr": types.Array(types.Map{
 			"value": types.String,
 		}),
+		types.Extra: types.Any,
 	}
 
 	noerr := "no error"
@@ -1102,7 +1104,8 @@ func TestCheck_types(t *testing.T) {
 			tree, err := parser.Parse(test.code)
 			require.NoError(t, err)
 
-			_, err = checker.Check(tree, conf.New(env))
+			config := conf.New(env)
+			_, err = checker.Check(tree, config)
 			if test.err == noerr {
 				require.NoError(t, err)
 			} else {
diff --git a/conf/env.go b/conf/env.go
index 82e6a93d9..494bb5b74 100644
--- a/conf/env.go
+++ b/conf/env.go
@@ -20,9 +20,6 @@ func Env(env any) Nature {
 	switch env := env.(type) {
 	case types.Map:
 		return env.Nature()
-
-	case types.StrictMap:
-		return env.Nature()
 	}
 
 	v := reflect.ValueOf(env)
@@ -53,9 +50,6 @@ func Env(env any) Nature {
 			case types.Map:
 				n.Fields[key.String()] = face.(types.Map).Nature()
 
-			case types.StrictMap:
-				n.Fields[key.String()] = face.(types.StrictMap).Nature()
-
 			default:
 				if face == nil {
 					n.Fields[key.String()] = Nature{Nil: true}
diff --git a/expr_test.go b/expr_test.go
index 4f2f829df..ced182a9f 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2704,7 +2704,7 @@ func TestExpr_nil_op_str(t *testing.T) {
 
 func TestExpr_env_types_map(t *testing.T) {
 	envTypes := types.Map{
-		"foo": types.StrictMap{
+		"foo": types.Map{
 			"bar": types.String,
 		},
 	}
@@ -2725,7 +2725,7 @@ func TestExpr_env_types_map(t *testing.T) {
 
 func TestExpr_env_types_map_error(t *testing.T) {
 	envTypes := types.Map{
-		"foo": types.StrictMap{
+		"foo": types.Map{
 			"bar": types.String,
 		},
 	}
diff --git a/types/types.go b/types/types.go
index 92923f9a3..d10d2fbc1 100644
--- a/types/types.go
+++ b/types/types.go
@@ -94,16 +94,22 @@ func (r rtype) String() string {
 	return r.t.String()
 }
 
-// Map returns a type that represents a map of the given type.
-// The map is not strict, meaning that it can contain keys not defined in the map.
+// Map represents a map[string]any type with defined keys.
 type Map map[string]Type
 
+const Extra = "[[__extra_keys__]]"
+
 func (m Map) Nature() Nature {
 	nt := Nature{
 		Type:   reflect.TypeOf(map[string]any{}),
 		Fields: make(map[string]Nature, len(m)),
+		Strict: true,
 	}
 	for k, v := range m {
+		if k == Extra {
+			nt.Strict = false
+			continue
+		}
 		nt.Fields[k] = v.Nature()
 	}
 	return nt
@@ -136,49 +142,6 @@ func (m Map) String() string {
 	return fmt.Sprintf("Map{%s}", strings.Join(pairs, ", "))
 }
 
-// StrictMap returns a type that represents a map of the given type.
-// The map is strict, meaning that it can only contain keys defined in the map.
-type StrictMap map[string]Type
-
-func (m StrictMap) Nature() Nature {
-	nt := Nature{
-		Type:   reflect.TypeOf(map[string]any{}),
-		Fields: make(map[string]Nature, len(m)),
-		Strict: true,
-	}
-	for k, v := range m {
-		nt.Fields[k] = v.Nature()
-	}
-	return nt
-}
-
-func (m StrictMap) Equal(t Type) bool {
-	if t == Any {
-		return true
-	}
-	mt, ok := t.(StrictMap)
-	if !ok {
-		return false
-	}
-	if len(m) != len(mt) {
-		return false
-	}
-	for k, v := range m {
-		if !v.Equal(mt[k]) {
-			return false
-		}
-	}
-	return true
-}
-
-func (m StrictMap) String() string {
-	pairs := make([]string, 0, len(m))
-	for k, v := range m {
-		pairs = append(pairs, fmt.Sprintf("%s: %s", k, v.String()))
-	}
-	return fmt.Sprintf("StrictMap{%s}", strings.Join(pairs, ", "))
-}
-
 // Array returns a type that represents an array of the given type.
 func Array(of Type) Type {
 	return array{of}
diff --git a/types/types_test.go b/types/types_test.go
index eacfef221..15a6ca77a 100644
--- a/types/types_test.go
+++ b/types/types_test.go
@@ -9,7 +9,7 @@ import (
 
 func TestType_Equal(t *testing.T) {
 	tests := []struct {
-		index string
+		index string // Index added for IDEA to show green test marker per test.
 		a, b  Type
 		want  bool
 	}{
@@ -22,15 +22,11 @@ func TestType_Equal(t *testing.T) {
 		{"7", Int, Nil, false},
 		{"8", Int, Array(Int), false},
 		{"9", Int, Map{"foo": Int}, false},
-		{"10", Int, StrictMap{"foo": Int}, false},
 		{"11", Int, Array(Int), false},
 		{"12", Array(Int), Array(Int), true},
 		{"13", Array(Int), Array(Float), false},
 		{"14", Map{"foo": Int}, Map{"foo": Int}, true},
 		{"15", Map{"foo": Int}, Map{"foo": Float}, false},
-		{"16", Map{"foo": Int}, StrictMap{"foo": Int}, false},
-		{"17", StrictMap{"foo": Int}, StrictMap{"foo": Int}, true},
-		{"18", StrictMap{"foo": Int}, StrictMap{"foo": Float}, false},
 		{"19", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Int}}, true},
 		{"20", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Float}}, false},
 		{"21", Any, Any, true},
@@ -38,8 +34,6 @@ func TestType_Equal(t *testing.T) {
 		{"23", Int, Any, true},
 		{"24", Any, Map{"foo": Int}, true},
 		{"25", Map{"foo": Int}, Any, true},
-		{"26", Any, StrictMap{"foo": Int}, true},
-		{"27", StrictMap{"foo": Int}, Any, true},
 		{"28", Any, Array(Int), true},
 		{"29", Array(Int), Any, true},
 	}

From da04c55bcbb2709417c056c62531de2f434595f2 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 28 Aug 2024 23:00:18 +0200
Subject: [PATCH 354/506] Add default map value type

---
 checker/checker_test.go  |  2 ++
 checker/nature/nature.go | 28 +++++++++++++++++-----------
 types/types.go           |  2 ++
 3 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/checker/checker_test.go b/checker/checker_test.go
index 602fe4b7a..17ec886e4 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -1090,9 +1090,11 @@ func TestCheck_types(t *testing.T) {
 		err  string
 	}{
 		{`unknown`, noerr},
+		{`[unknown + 42, another_unknown + "foo"]`, noerr},
 		{`foo.bar.baz > 0`, `invalid operation: > (mismatched types string and int)`},
 		{`foo.unknown.baz`, `unknown field unknown (1:5)`},
 		{`foo.bar.unknown`, noerr},
+		{`foo.bar.unknown + 42`, `invalid operation: + (mismatched types string and int)`},
 		{`[foo] | map(.unknown)`, `unknown field unknown`},
 		{`[foo] | map(.bar) | filter(.baz)`, `predicate should return boolean (got string)`},
 		{`arr | filter(.value > 0)`, `invalid operation: > (mismatched types string and int)`},
diff --git a/checker/nature/nature.go b/checker/nature/nature.go
index a385521c5..2b09353b5 100644
--- a/checker/nature/nature.go
+++ b/checker/nature/nature.go
@@ -12,16 +12,17 @@ var (
 )
 
 type Nature struct {
-	Type         reflect.Type      // Type of the value. If nil, then value is unknown.
-	Func         *builtin.Function // Used to pass function type from callee to CallNode.
-	ArrayOf      *Nature           // Elem nature of array type (usually Type is []any, but ArrayOf can be any nature).
-	PredicateOut *Nature           // Out nature of predicate.
-	Fields       map[string]Nature // Fields of map type.
-	Strict       bool              // If map is types.StrictMap.
-	Nil          bool              // If value is nil.
-	Method       bool              // If value retrieved from method. Usually used to determine amount of in arguments.
-	MethodIndex  int               // Index of method in type.
-	FieldIndex   []int             // Index of field in type.
+	Type            reflect.Type      // Type of the value. If nil, then value is unknown.
+	Func            *builtin.Function // Used to pass function type from callee to CallNode.
+	ArrayOf         *Nature           // Elem nature of array type (usually Type is []any, but ArrayOf can be any nature).
+	PredicateOut    *Nature           // Out nature of predicate.
+	Fields          map[string]Nature // Fields of map type.
+	DefaultMapValue *Nature           // Default value of map type.
+	Strict          bool              // If map is types.StrictMap.
+	Nil             bool              // If value is nil.
+	Method          bool              // If value retrieved from method. Usually used to determine amount of in arguments.
+	MethodIndex     int               // Index of method in type.
+	FieldIndex      []int             // Index of field in type.
 }
 
 func (n Nature) String() string {
@@ -54,7 +55,12 @@ func (n Nature) Key() Nature {
 
 func (n Nature) Elem() Nature {
 	switch n.Kind() {
-	case reflect.Map, reflect.Ptr:
+	case reflect.Ptr:
+		return Nature{Type: n.Type.Elem()}
+	case reflect.Map:
+		if n.DefaultMapValue != nil {
+			return *n.DefaultMapValue
+		}
 		return Nature{Type: n.Type.Elem()}
 	case reflect.Array, reflect.Slice:
 		if n.ArrayOf != nil {
diff --git a/types/types.go b/types/types.go
index d10d2fbc1..bb1cbe5fa 100644
--- a/types/types.go
+++ b/types/types.go
@@ -108,6 +108,8 @@ func (m Map) Nature() Nature {
 	for k, v := range m {
 		if k == Extra {
 			nt.Strict = false
+			natureOfDefaultValue := v.Nature()
+			nt.DefaultMapValue = &natureOfDefaultValue
 			continue
 		}
 		nt.Fields[k] = v.Nature()

From 3a58a8b0016a4d00d46c7a99c94d8b4dd3641e69 Mon Sep 17 00:00:00 2001
From: OlgaNovg <75758884+OlgaNovg@users.noreply.github.com>
Date: Wed, 4 Sep 2024 16:59:48 +0200
Subject: [PATCH 355/506] Add uniq() function (#705)

---
 builtin/builtin.go      | 51 +++++++++++++++++++++++++++++++++++++++++
 builtin/builtin_test.go |  2 ++
 2 files changed, 53 insertions(+)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 0107d276c..35a9f687e 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -830,6 +830,57 @@ var Builtins = []*Function{
 			}
 		},
 	},
+
+	{
+		Name: "uniq",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+
+			v := reflect.ValueOf(deref.Deref(args[0]))
+			if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
+				return nil, fmt.Errorf("cannot uniq %s", v.Kind())
+			}
+
+			size := v.Len()
+			ret := []any{}
+
+			eq := func(i int) bool {
+				for _, r := range ret {
+					if runtime.Equal(v.Index(i).Interface(), r) {
+						return true
+					}
+				}
+
+				return false
+			}
+
+			for i := 0; i < size; i += 1 {
+				if eq(i) {
+					continue
+				}
+
+				ret = append(ret, v.Index(i).Interface())
+			}
+
+			return ret, nil
+		},
+
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+				return arrayType, nil
+			default:
+				return anyType, fmt.Errorf("cannot uniq %s", args[0])
+			}
+		},
+	},
+
 	{
 		Name: "concat",
 		Safe: func(args ...any) (any, uint, error) {
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index ddfb4a494..499a838b7 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -155,6 +155,8 @@ func TestBuiltin(t *testing.T) {
 		{`flatten([["a", "b"], [1, 2]])`, []any{"a", "b", 1, 2}},
 		{`flatten([["a", "b"], [1, 2, [3, 4]]])`, []any{"a", "b", 1, 2, 3, 4}},
 		{`flatten([["a", "b"], [1, 2, [3, [[[["c", "d"], "e"]]], 4]]])`, []any{"a", "b", 1, 2, 3, "c", "d", "e", 4}},
+		{`uniq([1, 15, "a", 2, 3, 5, 2, "a", 2, "b"])`, []any{1, 15, "a", 2, 3, 5, "b"}},
+		{`uniq([[1, 2], "a", 2, 3, [1, 2], [1, 3]])`, []any{[]any{1, 2}, "a", 2, 3, []any{1, 3}}},
 	}
 
 	for _, test := range tests {

From 24a21b287f64d30a3893934a998a503bf23556d2 Mon Sep 17 00:00:00 2001
From: Steve Cosman <scosman@users.noreply.github.com>
Date: Wed, 18 Sep 2024 06:22:56 -0400
Subject: [PATCH 356/506] Add CM to Readme (#712)

Signed-off-by: Steve Cosman <scosman@users.noreply.github.com>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 71ec78764..9cc398f21 100644
--- a/README.md
+++ b/README.md
@@ -166,6 +166,7 @@ func main() {
 * [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery.
 * [Melrōse](https://melrōse.org) uses Expr to implement its music programming language.
 * [Tork](https://www.tork.run/) integrates Expr into its workflow execution.
+* [Critical Moments](https://criticalmoments.io) uses Expr for it's mobile realtime conditional targeting system.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From fe88af516dfc698aa65c074e1ba11914676d5e88 Mon Sep 17 00:00:00 2001
From: 6543 <6543@obermui.de>
Date: Wed, 13 Nov 2024 07:02:42 +0100
Subject: [PATCH 357/506] Mention WoodpeckerCI in README (#728)

[WoodpeckerCI](https://woodpecker-ci.org) uses this lib, so mention it :)

Signed-off-by: 6543 <6543@obermui.de>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 9cc398f21..98989a6f9 100644
--- a/README.md
+++ b/README.md
@@ -167,6 +167,7 @@ func main() {
 * [Melrōse](https://melrōse.org) uses Expr to implement its music programming language.
 * [Tork](https://www.tork.run/) integrates Expr into its workflow execution.
 * [Critical Moments](https://criticalmoments.io) uses Expr for it's mobile realtime conditional targeting system.
+* [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate).
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From fb6792b2486778dd8a3eb5ab2e7550f5b1dad150 Mon Sep 17 00:00:00 2001
From: Nguyen Ngoc Phuong <nguyenngocphuongnb@gmail.com>
Date: Tue, 24 Dec 2024 05:08:32 +0700
Subject: [PATCH 358/506] Add FastSchema to Readme (#737)

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 98989a6f9..14b8bf19f 100644
--- a/README.md
+++ b/README.md
@@ -168,6 +168,7 @@ func main() {
 * [Tork](https://www.tork.run/) integrates Expr into its workflow execution.
 * [Critical Moments](https://criticalmoments.io) uses Expr for it's mobile realtime conditional targeting system.
 * [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate).
+* [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From 33f614f92a503a2a1faaabebae782656fde9b889 Mon Sep 17 00:00:00 2001
From: Nathan Baulch <nathan.baulch@gmail.com>
Date: Thu, 9 Jan 2025 23:33:28 +1100
Subject: [PATCH 359/506] Fix typos (#745)

---
 README.md                            | 4 ++--
 docs/language-definition.md          | 2 +-
 internal/spew/common.go              | 4 ++--
 internal/spew/common_test.go         | 6 +++---
 internal/spew/config.go              | 4 ++--
 internal/spew/doc.go                 | 2 +-
 internal/spew/dumpcgo_test.go        | 4 ++--
 internal/spew/format.go              | 4 ++--
 internal/spew/internal_test.go       | 2 +-
 internal/spew/internalunsafe_test.go | 2 +-
 internal/spew/testdata/dumpcgo.go    | 4 ++--
 test/deref/deref_test.go             | 2 +-
 12 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/README.md b/README.md
index 14b8bf19f..afc8d43f7 100644
--- a/README.md
+++ b/README.md
@@ -162,11 +162,11 @@ func main() {
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
-* [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products.
+* [Span Digital](https://spandigital.com/) uses Expr in its Knowledge Management products.
 * [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery.
 * [Melrōse](https://melrōse.org) uses Expr to implement its music programming language.
 * [Tork](https://www.tork.run/) integrates Expr into its workflow execution.
-* [Critical Moments](https://criticalmoments.io) uses Expr for it's mobile realtime conditional targeting system.
+* [Critical Moments](https://criticalmoments.io) uses Expr for its mobile realtime conditional targeting system.
 * [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate).
 * [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system.
 
diff --git a/docs/language-definition.md b/docs/language-definition.md
index 9c277e9a2..2ceeab72c 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -691,7 +691,7 @@ concat([1, 2], [3, 4]) == [1, 2, 3, 4]
 
 ### flatten(array) {#flatten}
 
-Flattens given array into one-dimentional array.
+Flattens given array into one-dimensional array.
 
 ```expr
 flatten([1, 2, [3, 4]]) == [1, 2, 3, 4]
diff --git a/internal/spew/common.go b/internal/spew/common.go
index 1be8ce945..047e581fb 100644
--- a/internal/spew/common.go
+++ b/internal/spew/common.go
@@ -78,7 +78,7 @@ func catchPanic(w io.Writer, v reflect.Value) {
 }
 
 // handleMethods attempts to call the Error and String methods on the underlying
-// type the passed reflect.Value represents and outputes the result to Writer w.
+// type the passed reflect.Value represents and outputs the result to Writer w.
 //
 // It handles panics in any called methods by catching and displaying the error
 // as the formatted value.
@@ -100,7 +100,7 @@ func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool)
 	// Choose whether or not to do error and Stringer interface lookups against
 	// the base type or a pointer to the base type depending on settings.
 	// Technically calling one of these methods with a pointer receiver can
-	// mutate the value, however, types which choose to satisify an error or
+	// mutate the value, however, types which choose to satisfy an error or
 	// Stringer interface with a pointer receiver should not be mutating their
 	// state inside these interface methods.
 	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
diff --git a/internal/spew/common_test.go b/internal/spew/common_test.go
index a312057e1..958d45e9f 100644
--- a/internal/spew/common_test.go
+++ b/internal/spew/common_test.go
@@ -154,7 +154,7 @@ func helpTestSortValues(tests []sortTestCase, cs *spew.ConfigState, t *testing.T
 	}
 }
 
-// TestSortValues ensures the sort functionality for relect.Value based sorting
+// TestSortValues ensures the sort functionality for reflect.Value based sorting
 // works as intended.
 func TestSortValues(t *testing.T) {
 	v := reflect.ValueOf
@@ -228,7 +228,7 @@ func TestSortValues(t *testing.T) {
 	helpTestSortValues(tests, &cs, t)
 }
 
-// TestSortValuesWithMethods ensures the sort functionality for relect.Value
+// TestSortValuesWithMethods ensures the sort functionality for reflect.Value
 // based sorting works as intended when using string methods.
 func TestSortValuesWithMethods(t *testing.T) {
 	v := reflect.ValueOf
@@ -263,7 +263,7 @@ func TestSortValuesWithMethods(t *testing.T) {
 	helpTestSortValues(tests, &cs, t)
 }
 
-// TestSortValuesWithSpew ensures the sort functionality for relect.Value
+// TestSortValuesWithSpew ensures the sort functionality for reflect.Value
 // based sorting works as intended when using spew to stringify keys.
 func TestSortValuesWithSpew(t *testing.T) {
 	v := reflect.ValueOf
diff --git a/internal/spew/config.go b/internal/spew/config.go
index 161895fc6..73b09b145 100644
--- a/internal/spew/config.go
+++ b/internal/spew/config.go
@@ -59,7 +59,7 @@ type ConfigState struct {
 	//
 	// NOTE: This might be an unsafe action since calling one of these methods
 	// with a pointer receiver could technically mutate the value, however,
-	// in practice, types which choose to satisify an error or Stringer
+	// in practice, types which choose to satisfy an error or Stringer
 	// interface with a pointer receiver should not be mutating their state
 	// inside these interface methods.  As a result, this option relies on
 	// access to the unsafe package, so it will not have any effect when
@@ -228,7 +228,7 @@ types similar to the standard %v format specifier.
 
 The custom formatter only responds to the %v (most compact), %+v (adds pointer
 addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
+combinations.  Any other verbs such as %x and %q will be sent to the
 standard fmt package for formatting.  In addition, the custom formatter ignores
 the width and precision arguments (however they will still work on the format
 specifiers not handled by the custom formatter).
diff --git a/internal/spew/doc.go b/internal/spew/doc.go
index 722e9aa79..a689c9f97 100644
--- a/internal/spew/doc.go
+++ b/internal/spew/doc.go
@@ -169,7 +169,7 @@ standard %v format specifier.
 
 The custom formatter only responds to the %v (most compact), %+v (adds pointer
 addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
+combinations.  Any other verbs such as %x and %q will be sent to the
 standard fmt package for formatting.  In addition, the custom formatter ignores
 the width and precision arguments (however they will still work on the format
 specifiers not handled by the custom formatter).
diff --git a/internal/spew/dumpcgo_test.go b/internal/spew/dumpcgo_test.go
index 1bf71fafb..a376ed71a 100644
--- a/internal/spew/dumpcgo_test.go
+++ b/internal/spew/dumpcgo_test.go
@@ -15,7 +15,7 @@
 // NOTE: Due to the following build constraints, this file will only be compiled
 // when both cgo is supported and "-tags testcgo" is added to the go test
 // command line.  This means the cgo tests are only added (and hence run) when
-// specifially requested.  This configuration is used because spew itself
+// specifically requested.  This configuration is used because spew itself
 // does not require cgo to run even though it does handle certain cgo types
 // specially.  Rather than forcing all clients to require cgo and an external
 // C compiler just to run the tests, this scheme makes them optional.
@@ -90,7 +90,7 @@ func addCgoDumpTests() {
 	addDumpTest(v5, "("+v5t+") "+v5s+"\n", "("+v5t2+") "+v5s+"\n")
 
 	// C typedefed unsigned char array.
-	v6, v6l, v6c := testdata.GetCgoTypdefedUnsignedCharArray()
+	v6, v6l, v6c := testdata.GetCgoTypedefedUnsignedCharArray()
 	v6Len := fmt.Sprintf("%d", v6l)
 	v6Cap := fmt.Sprintf("%d", v6c)
 	v6t := "[6]testdata._Ctype_custom_uchar_t"
diff --git a/internal/spew/format.go b/internal/spew/format.go
index b04edb7d7..77f300396 100644
--- a/internal/spew/format.go
+++ b/internal/spew/format.go
@@ -121,7 +121,7 @@ func (f *formatState) formatPtr(v reflect.Value) {
 	// Keep list of all dereferenced pointers to possibly show later.
 	pointerChain := make([]uintptr, 0)
 
-	// Figure out how many levels of indirection there are by derferencing
+	// Figure out how many levels of indirection there are by dereferencing
 	// pointers and unpacking interfaces down the chain while detecting circular
 	// references.
 	nilFound := false
@@ -405,7 +405,7 @@ types similar to the standard %v format specifier.
 
 The custom formatter only responds to the %v (most compact), %+v (adds pointer
 addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
+combinations.  Any other verbs such as %x and %q will be sent to the
 standard fmt package for formatting.  In addition, the custom formatter ignores
 the width and precision arguments (however they will still work on the format
 specifiers not handled by the custom formatter).
diff --git a/internal/spew/internal_test.go b/internal/spew/internal_test.go
index e312b4fad..570fbd009 100644
--- a/internal/spew/internal_test.go
+++ b/internal/spew/internal_test.go
@@ -15,7 +15,7 @@
  */
 
 /*
-This test file is part of the spew package rather than than the spew_test
+This test file is part of the spew package rather than the spew_test
 package because it needs access to internals to properly test certain cases
 which are not possible via the public interface since they should never happen.
 */
diff --git a/internal/spew/internalunsafe_test.go b/internal/spew/internalunsafe_test.go
index aa8fa00b1..051e04572 100644
--- a/internal/spew/internalunsafe_test.go
+++ b/internal/spew/internalunsafe_test.go
@@ -20,7 +20,7 @@
 // +build !js,!appengine,!safe,!disableunsafe,go1.4
 
 /*
-This test file is part of the spew package rather than than the spew_test
+This test file is part of the spew package rather than the spew_test
 package because it needs access to internals to properly test certain cases
 which are not possible via the public interface since they should never happen.
 */
diff --git a/internal/spew/testdata/dumpcgo.go b/internal/spew/testdata/dumpcgo.go
index 368ead024..9008b84b7 100644
--- a/internal/spew/testdata/dumpcgo.go
+++ b/internal/spew/testdata/dumpcgo.go
@@ -76,8 +76,8 @@ func GetCgoUint8tArray() (interface{}, int, int) {
 	return C.ui8ta, len(C.ui8ta), cap(C.ui8ta)
 }
 
-// GetCgoTypdefedUnsignedCharArray returns a typedefed unsigned char array via
+// GetCgoTypedefedUnsignedCharArray returns a typedefed unsigned char array via
 // cgo and the array's len and cap.  This is only used for tests.
-func GetCgoTypdefedUnsignedCharArray() (interface{}, int, int) {
+func GetCgoTypedefedUnsignedCharArray() (interface{}, int, int) {
 	return C.tuca, len(C.tuca), cap(C.tuca)
 }
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 4bfb76168..0b3ea5837 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -204,7 +204,7 @@ func TestDeref_nil_in_pointer_of_interface(t *testing.T) {
 	})
 }
 
-func TestDeref_сommutative(t *testing.T) {
+func TestDeref_commutative(t *testing.T) {
 	a := "ok"
 	b := "ok"
 

From 192ab82e6c5e483def6b1abd82e14bdfc1379fc5 Mon Sep 17 00:00:00 2001
From: Jens Neuse <jens.neuse@gmx.de>
Date: Fri, 10 Jan 2025 11:41:46 +0100
Subject: [PATCH 360/506] add WunderGraph Cosmo to uses section in README
 (#748)

Signed-off-by: Jens Neuse <jens.neuse@gmx.de>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index afc8d43f7..ab4f2baaa 100644
--- a/README.md
+++ b/README.md
@@ -169,6 +169,7 @@ func main() {
 * [Critical Moments](https://criticalmoments.io) uses Expr for its mobile realtime conditional targeting system.
 * [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate).
 * [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system.
+* [WunderGraph Cosmo](https://github.com/wundergraph/cosmo) - GraphQL Federeration Router uses Expr to customize Middleware behaviour
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From 6ef04ecee9673982be2169ab8c2acb1e60219aa3 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Mon, 27 Jan 2025 12:26:26 +0200
Subject: [PATCH 361/506] test: add comprehensive VM opcode tests (#750)

Add extensive test coverage for VM opcodes including:

- Basic operations (OpLoadEnv, OpTrue, OpFalse, OpNil)
- Arithmetic operations (OpNegate, OpExponent)
- String operations (OpEqualString, OpMatches)
- Collection operations (OpIn, OpLen)
- Type operations (OpCast)
- Control flow (OpThrow)
- Function calls (OpCall0-3, OpCallN)
- Index and count manipulation (OpGetIndex, OpSetIndex)
- Profiling operations (OpProfileStart, OpProfileEnd)

Also add high-level expression tests for:
- Arithmetic expressions
- String operations
- Data structure operations
- Group and sort operations

Each test case includes detailed comments and covers both success and error cases.

These tests combined with a debugger helped me navigate the VM internals
significantly.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 vm/vm_test.go | 932 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 932 insertions(+)

diff --git a/vm/vm_test.go b/vm/vm_test.go
index 3ed57d75b..d45ef2d6c 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -259,3 +259,935 @@ func TestRun_OpInvalid(t *testing.T) {
 	_, err := vm.Run(program, nil)
 	require.EqualError(t, err, "invalid opcode")
 }
+
+func TestVM_OpcodeOperations(t *testing.T) {
+	tests := []struct {
+		name        string
+		expr        string
+		env         map[string]any
+		want        any
+		expectError string
+	}{
+		// Arithmetic Operations
+		{
+			name: "basic addition",
+			expr: "2 + 3",
+			want: 5,
+		},
+		{
+			name: "mixed type arithmetic",
+			expr: "2.5 + 3",
+			want: 5.5,
+		},
+		{
+			name: "chained arithmetic",
+			expr: "1 + 2 * 3 - 4 / 2",
+			want: 5.0,
+		},
+		{
+			name: "modulo operation",
+			expr: "5 % 2",
+			want: 1,
+		},
+		{
+			name: "exponent operation",
+			expr: "2 ^ 3",
+			want: 8.0,
+		},
+		{
+			name: "negation",
+			expr: "-5",
+			want: -5,
+		},
+
+		// String Operations
+		{
+			name: "string concatenation",
+			expr: `"hello" + " " + "world"`,
+			want: "hello world",
+		},
+		{
+			name: "string starts with",
+			expr: `"hello world" startsWith "hello"`,
+			want: true,
+		},
+		{
+			name: "string ends with",
+			expr: `"hello world" endsWith "world"`,
+			want: true,
+		},
+		{
+			name: "string contains",
+			expr: `"hello world" contains "lo wo"`,
+			want: true,
+		},
+		{
+			name: "string matches regex",
+			expr: `"hello123" matches "^hello\\d+$"`,
+			want: true,
+		},
+
+		// Data Structure Operations
+		{
+			name: "array creation and access",
+			expr: "[1, 2, 3][1]",
+			want: 2,
+		},
+		{
+			name: "map creation and access",
+			expr: `{"a": 1, "b": 2}.b`,
+			want: 2,
+		},
+		{
+			name: "array length",
+			expr: "len([1, 2, 3])",
+			want: 3,
+		},
+		{
+			name: "array slice",
+			expr: "[1, 2, 3, 4][1:3]",
+			want: []any{2, 3},
+		},
+		{
+			name: "array range",
+			expr: "1..5",
+			want: []int{1, 2, 3, 4, 5},
+		},
+
+		// Error Cases
+		{
+			name:        "invalid array index",
+			expr:        "[1,2,3][5]",
+			expectError: "index out of range",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr, expr.Env(tt.env))
+			require.NoError(t, err)
+
+			testVM := &vm.VM{}
+			got, err := testVM.Run(program, tt.env)
+
+			if tt.expectError != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.expectError)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func TestVM_GroupAndSortOperations(t *testing.T) {
+	tests := []struct {
+		name        string
+		expr        string
+		env         map[string]any
+		want        any
+		expectError string
+	}{
+		{
+			name: "group by single field",
+			expr: `groupBy([{"id": 1, "type": "a"}, {"id": 2, "type": "b"}, {"id": 3, "type": "a"}], #.type)`,
+			want: map[any][]any{
+				"a": {
+					map[string]any{"id": 1, "type": "a"},
+					map[string]any{"id": 3, "type": "a"},
+				},
+				"b": {
+					map[string]any{"id": 2, "type": "b"},
+				},
+			},
+		},
+		{
+			name: "sort by field ascending",
+			expr: `sortBy([{"id": 3}, {"id": 1}, {"id": 2}], #.id)`,
+			want: []any{
+				map[string]any{"id": 1},
+				map[string]any{"id": 2},
+				map[string]any{"id": 3},
+			},
+		},
+		{
+			name: "sort by field descending",
+			expr: `sortBy([{"id": 3}, {"id": 1}, {"id": 2}], #.id, "desc")`,
+			want: []any{
+				map[string]any{"id": 3},
+				map[string]any{"id": 2},
+				map[string]any{"id": 1},
+			},
+		},
+		{
+			name: "sort by computed value",
+			expr: `sortBy([1, 2, 3, 4], # % 2)`,
+			want: []any{2, 4, 1, 3},
+		},
+		{
+			name: "group by with complex key",
+			expr: `groupBy([1, 2, 3, 4, 5, 6], # % 2 == 0 ? "even" : "odd")`,
+			want: map[any][]any{
+				"even": {2, 4, 6},
+				"odd":  {1, 3, 5},
+			},
+		},
+		{
+			name:        "invalid sort order",
+			expr:        `sortBy([1, 2, 3], #, "invalid")`,
+			expectError: "unknown order",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr, expr.Env(tt.env))
+			require.NoError(t, err)
+
+			testVM := &vm.VM{}
+			got, err := testVM.Run(program, tt.env)
+
+			if tt.expectError != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.expectError)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
+// TestVM_ProfileOperations tests the profiling opcodes
+func TestVM_ProfileOperations(t *testing.T) {
+	program := &vm.Program{
+		Bytecode: []vm.Opcode{
+			vm.OpProfileStart,
+			vm.OpPush,
+			vm.OpProfileEnd,
+		},
+		Arguments: []int{0, 0, 0},
+		Constants: []any{
+			&vm.Span{},
+		},
+	}
+
+	testVM := &vm.VM{}
+	_, err := testVM.Run(program, nil)
+	require.NoError(t, err)
+
+	span := program.Constants[0].(*vm.Span)
+	require.True(t, span.Duration > 0, "Profile duration should be greater than 0")
+}
+
+// TestVM_IndexOperations tests the index manipulation opcodes
+func TestVM_IndexOperations(t *testing.T) {
+	tests := []struct {
+		name string
+		expr string
+		want any
+	}{
+		{
+			name: "decrement index in loop",
+			expr: "reduce([1,2,3], #acc + #, 0)",
+			want: 6,
+		},
+		{
+			name: "set index in loop",
+			expr: "map([1,2,3], # * 2)",
+			want: []any{2, 4, 6},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr)
+			require.NoError(t, err)
+
+			testVM := &vm.VM{}
+			got, err := testVM.Run(program, nil)
+			require.NoError(t, err)
+			require.Equal(t, tt.want, got)
+		})
+	}
+}
+
+// TestVM_DirectCallOpcodes tests the specialized call opcodes directly
+func TestVM_DirectCallOpcodes(t *testing.T) {
+	tests := []struct {
+		name     string
+		bytecode []vm.Opcode
+		args     []int
+		consts   []any
+		funcs    []vm.Function
+		want     any
+		wantErr  bool
+	}{
+		{
+			name:     "OpCall0",
+			bytecode: []vm.Opcode{vm.OpCall0},
+			args:     []int{0},
+			funcs: []vm.Function{
+				func(args ...any) (any, error) {
+					return 42, nil
+				},
+			},
+			want: 42,
+		},
+		{
+			name: "OpCall1",
+			bytecode: []vm.Opcode{
+				vm.OpPush,
+				vm.OpCall1,
+			},
+			args:   []int{0, 0},
+			consts: []any{10},
+			funcs: []vm.Function{
+				func(args ...any) (any, error) {
+					return args[0].(int) * 2, nil
+				},
+			},
+			want: 20,
+		},
+		{
+			name: "OpCall2",
+			bytecode: []vm.Opcode{
+				vm.OpPush,
+				vm.OpPush,
+				vm.OpCall2,
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{10, 5},
+			funcs: []vm.Function{
+				func(args ...any) (any, error) {
+					return args[0].(int) + args[1].(int), nil
+				},
+			},
+			want: 15,
+		},
+		{
+			name: "OpCall3",
+			bytecode: []vm.Opcode{
+				vm.OpPush,
+				vm.OpPush,
+				vm.OpPush,
+				vm.OpCall3,
+			},
+			args:   []int{0, 1, 2, 0},
+			consts: []any{10, 5, 2},
+			funcs: []vm.Function{
+				func(args ...any) (any, error) {
+					return args[0].(int) + args[1].(int) + args[2].(int), nil
+				},
+			},
+			want: 17,
+		},
+		{
+			name: "OpCallN with error",
+			bytecode: []vm.Opcode{
+				vm.OpLoadFunc,
+				vm.OpCallN,
+			},
+			args: []int{0, 0}, // Function index, number of args (0)
+			funcs: []vm.Function{
+				func(args ...any) (any, error) {
+					return nil, fmt.Errorf("test error")
+				},
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program := vm.NewProgram(
+				nil, // source
+				nil, // node
+				nil, // locations
+				0,   // variables
+				tt.consts,
+				tt.bytecode,
+				tt.args,
+				tt.funcs,
+				nil, // debugInfo
+				nil, // span
+			)
+			vm := &vm.VM{}
+			got, err := vm.Run(program, nil)
+			if tt.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func TestVM_CallN(t *testing.T) {
+	input := `fn(1, 2, 3)`
+
+	tree, err := parser.Parse(input)
+	require.NoError(t, err)
+
+	env := map[string]any{
+		"fn": func(args ...any) (any, error) {
+			sum := 0
+			for _, arg := range args {
+				sum += arg.(int)
+			}
+			return sum, nil
+		},
+	}
+
+	config := conf.New(env)
+	program, err := compiler.Compile(tree, config)
+	require.NoError(t, err)
+
+	out, err := vm.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 6, out)
+}
+
+// TestVM_IndexAndCountOperations tests the index and count manipulation opcodes directly
+func TestVM_IndexAndCountOperations(t *testing.T) {
+	tests := []struct {
+		name     string
+		bytecode []vm.Opcode
+		args     []int
+		consts   []any
+		want     any
+		wantErr  bool
+	}{
+		{
+			name: "GetIndex",
+			bytecode: []vm.Opcode{
+				vm.OpPush,     // Push array to stack
+				vm.OpBegin,    // Start scope
+				vm.OpGetIndex, // Get current index
+			},
+			args:   []int{0, 0, 0},
+			consts: []any{[]any{1, 2, 3}}, // Array for scope
+			want:   0,                     // Initial index is 0
+		},
+		{
+			name: "DecrementIndex",
+			bytecode: []vm.Opcode{
+				vm.OpPush,           // Push array to stack
+				vm.OpBegin,          // Start scope
+				vm.OpDecrementIndex, // Decrement index
+				vm.OpGetIndex,       // Get current index
+			},
+			args:   []int{0, 0, 0, 0},
+			consts: []any{[]any{1, 2, 3}}, // Array for scope
+			want:   -1,                    // After decrement
+		},
+		{
+			name: "GetCount",
+			bytecode: []vm.Opcode{
+				vm.OpPush,     // Push array to stack
+				vm.OpBegin,    // Start scope
+				vm.OpGetCount, // Get current count
+			},
+			args:   []int{0, 0, 0},
+			consts: []any{[]any{1, 2, 3}}, // Array for scope
+			want:   0,                     // Initial count is 0
+		},
+		{
+			name: "IncrementCount",
+			bytecode: []vm.Opcode{
+				vm.OpPush,           // Push array to stack
+				vm.OpBegin,          // Start scope
+				vm.OpIncrementCount, // Increment count
+				vm.OpGetCount,       // Get current count
+			},
+			args:   []int{0, 0, 0, 0},
+			consts: []any{[]any{1, 2, 3}}, // Array for scope
+			want:   1,                     // After increment
+		},
+		{
+			name: "Multiple operations",
+			bytecode: []vm.Opcode{
+				vm.OpPush,           // Push array to stack
+				vm.OpBegin,          // Start scope
+				vm.OpIncrementCount, // Count = 1
+				vm.OpIncrementCount, // Count = 2
+				vm.OpDecrementIndex, // Index = -1
+				vm.OpDecrementIndex, // Index = -2
+				vm.OpGetCount,       // Push count (2)
+				vm.OpGetIndex,       // Push index (-2)
+				vm.OpAdd,            // Add them together
+			},
+			args:   []int{0, 0, 0, 0, 0, 0, 0, 0, 0},
+			consts: []any{[]any{1, 2, 3}}, // Array for scope
+			want:   0,                     // 2 + (-2) = 0
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program := vm.NewProgram(
+				nil, // source
+				nil, // node
+				nil, // locations
+				0,   // variables
+				tt.consts,
+				tt.bytecode,
+				tt.args,
+				nil, // functions
+				nil, // debugInfo
+				nil, // span
+			)
+			vm := &vm.VM{}
+			got, err := vm.Run(program, nil)
+			if tt.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
+// TestVM_DirectBasicOpcodes tests basic opcodes directly
+func TestVM_DirectBasicOpcodes(t *testing.T) {
+	tests := []struct {
+		name     string
+		bytecode []vm.Opcode
+		args     []int
+		consts   []any
+		env      any
+		want     any
+		wantErr  bool
+	}{
+		{
+			name: "OpLoadEnv",
+			bytecode: []vm.Opcode{
+				vm.OpLoadEnv, // Load entire environment
+			},
+			args: []int{0},
+			env:  map[string]any{"key": "value"},
+			want: map[string]any{"key": "value"},
+		},
+		{
+			name: "OpTrue",
+			bytecode: []vm.Opcode{
+				vm.OpTrue,
+			},
+			args: []int{0},
+			want: true,
+		},
+		{
+			name: "OpFalse",
+			bytecode: []vm.Opcode{
+				vm.OpFalse,
+			},
+			args: []int{0},
+			want: false,
+		},
+		{
+			name: "OpNil",
+			bytecode: []vm.Opcode{
+				vm.OpNil,
+			},
+			args: []int{0},
+			want: nil,
+		},
+		{
+			name: "OpNegate int",
+			bytecode: []vm.Opcode{
+				vm.OpPush,   // Push number
+				vm.OpNegate, // Negate it
+			},
+			args:   []int{0, 0},
+			consts: []any{42},
+			want:   -42,
+		},
+		{
+			name: "OpNegate float",
+			bytecode: []vm.Opcode{
+				vm.OpPush,   // Push number
+				vm.OpNegate, // Negate it
+			},
+			args:   []int{0, 0},
+			consts: []any{42.5},
+			want:   -42.5,
+		},
+		{
+			name: "OpNot true",
+			bytecode: []vm.Opcode{
+				vm.OpTrue, // Push true
+				vm.OpNot,  // Negate it
+			},
+			args: []int{0, 0},
+			want: false,
+		},
+		{
+			name: "OpNot false",
+			bytecode: []vm.Opcode{
+				vm.OpFalse, // Push false
+				vm.OpNot,   // Negate it
+			},
+			args: []int{0, 0},
+			want: true,
+		},
+		{
+			name: "OpNot error",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push non-bool
+				vm.OpNot,  // Try to negate it
+			},
+			args:    []int{0, 0},
+			consts:  []any{"not a bool"},
+			wantErr: true,
+		},
+		{
+			name: "OpEqualString equal",
+			bytecode: []vm.Opcode{
+				vm.OpPush,        // Push first string
+				vm.OpPush,        // Push second string
+				vm.OpEqualString, // Compare strings
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{"hello", "hello"},
+			want:   true,
+		},
+		{
+			name: "OpEqualString not equal",
+			bytecode: []vm.Opcode{
+				vm.OpPush,        // Push first string
+				vm.OpPush,        // Push second string
+				vm.OpEqualString, // Compare strings
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{"hello", "world"},
+			want:   false,
+		},
+		{
+			name: "OpEqualString with empty strings",
+			bytecode: []vm.Opcode{
+				vm.OpPush,        // Push first string
+				vm.OpPush,        // Push second string
+				vm.OpEqualString, // Compare strings
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{"", ""},
+			want:   true,
+		},
+		{
+			name: "OpEqualString type error",
+			bytecode: []vm.Opcode{
+				vm.OpPush,        // Push non-string
+				vm.OpPush,        // Push string
+				vm.OpEqualString, // Try to compare
+			},
+			args:    []int{0, 1, 0},
+			consts:  []any{42, "hello"},
+			wantErr: true,
+		},
+		{
+			name: "OpInt",
+			bytecode: []vm.Opcode{
+				vm.OpInt, // Push int directly from args
+			},
+			args:   []int{42}, // The value 42 is passed directly in args
+			consts: []any{},   // No constants needed
+			want:   42,
+		},
+		{
+			name: "OpInt negative",
+			bytecode: []vm.Opcode{
+				vm.OpInt, // Push negative int directly from args
+			},
+			args:   []int{-42}, // The value -42 is passed directly in args
+			consts: []any{},    // No constants needed
+			want:   -42,
+		},
+		{
+			name: "OpInt zero",
+			bytecode: []vm.Opcode{
+				vm.OpInt, // Push zero directly from args
+			},
+			args:   []int{0}, // The value 0 is passed directly in args
+			consts: []any{},  // No constants needed
+			want:   0,
+		},
+		{
+			name: "OpIn array true",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push element
+				vm.OpPush, // Push array
+				vm.OpIn,   // Check if element is in array
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{2, []any{1, 2, 3}},
+			want:   true,
+		},
+		{
+			name: "OpIn array false",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push element
+				vm.OpPush, // Push array
+				vm.OpIn,   // Check if element is in array
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{4, []any{1, 2, 3}},
+			want:   false,
+		},
+		{
+			name: "OpIn map true",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push key
+				vm.OpPush, // Push map
+				vm.OpIn,   // Check if key is in map
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{"b", map[string]any{"a": 1, "b": 2}},
+			want:   true,
+		},
+		{
+			name: "OpIn map false",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push key
+				vm.OpPush, // Push map
+				vm.OpIn,   // Check if key is in map
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{"c", map[string]any{"a": 1, "b": 2}},
+			want:   false,
+		},
+		{
+			name: "OpExponent integers",
+			bytecode: []vm.Opcode{
+				vm.OpPush,     // Push base
+				vm.OpPush,     // Push exponent
+				vm.OpExponent, // Calculate power
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{2, 3},
+			want:   8.0,
+		},
+		{
+			name: "OpExponent floats",
+			bytecode: []vm.Opcode{
+				vm.OpPush,     // Push base
+				vm.OpPush,     // Push exponent
+				vm.OpExponent, // Calculate power
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{2.0, 3.0},
+			want:   8.0,
+		},
+		{
+			name: "OpExponent negative exponent",
+			bytecode: []vm.Opcode{
+				vm.OpPush,     // Push base
+				vm.OpPush,     // Push exponent
+				vm.OpExponent, // Calculate power
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{2.0, -2.0},
+			want:   0.25,
+		},
+		{
+			name: "OpMatches valid regex",
+			bytecode: []vm.Opcode{
+				vm.OpPush,    // Push string
+				vm.OpPush,    // Push pattern
+				vm.OpMatches, // Match string against pattern
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{"hello123", "^hello\\d+$"},
+			want:   true,
+		},
+		{
+			name: "OpMatches non-matching regex",
+			bytecode: []vm.Opcode{
+				vm.OpPush,    // Push string
+				vm.OpPush,    // Push pattern
+				vm.OpMatches, // Match string against pattern
+			},
+			args:   []int{0, 1, 0},
+			consts: []any{"hello", "^\\d+$"},
+			want:   false,
+		},
+		{
+			name: "OpMatches invalid regex",
+			bytecode: []vm.Opcode{
+				vm.OpPush,    // Push string
+				vm.OpPush,    // Push pattern
+				vm.OpMatches, // Match string against pattern
+			},
+			args:    []int{0, 1, 0},
+			consts:  []any{"hello", "[invalid"},
+			wantErr: true,
+		},
+		{
+			name: "OpMatches type error",
+			bytecode: []vm.Opcode{
+				vm.OpPush,    // Push non-string
+				vm.OpPush,    // Push pattern
+				vm.OpMatches, // Match against pattern
+			},
+			args:    []int{0, 1, 0},
+			consts:  []any{42, "^\\d+$"},
+			wantErr: true,
+		},
+		{
+			name: "OpCast int to float64",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push int
+				vm.OpCast, // Cast to float64
+			},
+			args:   []int{0, 2},
+			consts: []any{42},
+			want:   float64(42),
+		},
+		{
+			name: "OpCast int32 to int64",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push int32
+				vm.OpCast, // Cast to int64
+			},
+			args:   []int{0, 1},
+			consts: []any{int32(42)},
+			want:   int64(42),
+		},
+		{
+			name: "OpCast invalid type",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push string
+				vm.OpCast, // Try to cast to float64
+			},
+			args:    []int{0, 0},
+			consts:  []any{"not a number"},
+			wantErr: true,
+		},
+		{
+			name: "OpLen array",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push array
+				vm.OpLen,  // Get length
+			},
+			args:   []int{0, 0},
+			consts: []any{[]any{1, 2, 3}},
+			want:   3,
+		},
+		{
+			name: "OpLen empty array",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push empty array
+				vm.OpLen,  // Get length
+			},
+			args:   []int{0, 0},
+			consts: []any{[]any{}},
+			want:   0,
+		},
+		{
+			name: "OpLen string",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push string
+				vm.OpLen,  // Get length
+			},
+			args:   []int{0, 0},
+			consts: []any{"hello"},
+			want:   5,
+		},
+		{
+			name: "OpLen empty string",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push empty string
+				vm.OpLen,  // Get length
+			},
+			args:   []int{0, 0},
+			consts: []any{""},
+			want:   0,
+		},
+		{
+			name: "OpLen map",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push map
+				vm.OpLen,  // Get length
+			},
+			args:   []int{0, 0},
+			consts: []any{map[string]any{"a": 1, "b": 2, "c": 3}},
+			want:   3,
+		},
+		{
+			name: "OpLen empty map",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push empty map
+				vm.OpLen,  // Get length
+			},
+			args:   []int{0, 0},
+			consts: []any{map[string]any{}},
+			want:   0,
+		},
+		{
+			name: "OpLen invalid type",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push number
+				vm.OpLen,  // Try to get length
+			},
+			args:    []int{0, 0},
+			consts:  []any{42},
+			wantErr: true,
+		},
+		{
+			name: "OpThrow with string",
+			bytecode: []vm.Opcode{
+				vm.OpPush,  // Push error message
+				vm.OpThrow, // Throw error
+			},
+			args:    []int{0, 0},
+			consts:  []any{"test error"},
+			wantErr: true,
+		},
+		{
+			name: "OpThrow with error",
+			bytecode: []vm.Opcode{
+				vm.OpPush,  // Push error
+				vm.OpThrow, // Throw error
+			},
+			args:    []int{0, 0},
+			consts:  []any{fmt.Errorf("test error")},
+			wantErr: true,
+		},
+		{
+			name: "OpDefault",
+			bytecode: []vm.Opcode{
+				vm.OpEnd + 1, // OpEnd is always last, this is anunknown opcode
+			},
+			args:    []int{0, 0},
+			consts:  []any{fmt.Errorf("test error")},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program := vm.NewProgram(
+				nil, // source
+				nil, // node
+				nil, // locations
+				0,   // variables
+				tt.consts,
+				tt.bytecode,
+				tt.args,
+				nil, // functions
+				nil, // debugInfo
+				nil, // span
+			)
+			vm := &vm.VM{}
+			got, err := vm.Run(program, tt.env)
+			if tt.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}

From a3b6cd227b56cb9aa8293ef5ab09d5e65bd7a990 Mon Sep 17 00:00:00 2001
From: Olga Novgorodova <75758884+OlgaNovg@users.noreply.github.com>
Date: Sun, 23 Feb 2025 14:19:51 +0100
Subject: [PATCH 362/506] Add if-else conditional (#736)

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 docs/language-definition.md |  2 +-
 expr_test.go                | 15 +++++++++++++++
 parser/lexer/lexer_test.go  | 36 ++++++++++++++++++++++++++++++++++++
 parser/lexer/state.go       |  4 +---
 parser/parser.go            | 22 ++++++++++++++++++++++
 parser/parser_test.go       | 11 +++++++++++
 6 files changed, 86 insertions(+), 4 deletions(-)

diff --git a/docs/language-definition.md b/docs/language-definition.md
index 2ceeab72c..640c7d63b 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -97,7 +97,7 @@ Backticks strings are raw strings, they do not support escape sequences.
     <tr>
         <td><strong>Conditional</strong></td>
         <td>
-            <code>?:</code> (ternary), <code>??</code> (nil coalescing)
+            <code>?:</code> (ternary), <code>??</code> (nil coalescing), <code>if {} else {}</code> (multiline)
         </td>
     </tr>
     <tr>
diff --git a/expr_test.go b/expr_test.go
index ced182a9f..bda5551cc 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1291,6 +1291,21 @@ func TestExpr(t *testing.T) {
 			`1 < 2 < 3 == true`,
 			true,
 		},
+		{
+			`if 1 > 2 { 333 * 2 + 1 } else { 444 }`,
+			444,
+		},
+		{
+			`let a = 3;
+			let b = 2;
+			if a>b {let c = Add(a, b); c+1} else {Add(10, b)}
+			`,
+			6,
+		},
+		{
+			`if "a" < "b" {let x = "a"; x} else {"abc"}`,
+			"a",
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index 5edcbe5c4..f1cb3f28f 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -239,6 +239,42 @@ func TestLex(t *testing.T) {
 				{Kind: EOF},
 			},
 		},
+		{
+			`if a>b {x1+x2} else {x2}`,
+			[]Token{
+				{Kind: Operator, Value: "if"},
+				{Kind: Identifier, Value: "a"},
+				{Kind: Operator, Value: ">"},
+				{Kind: Identifier, Value: "b"},
+				{Kind: Bracket, Value: "{"},
+				{Kind: Identifier, Value: "x1"},
+				{Kind: Operator, Value: "+"},
+				{Kind: Identifier, Value: "x2"},
+				{Kind: Bracket, Value: "}"},
+				{Kind: Operator, Value: "else"},
+				{Kind: Bracket, Value: "{"},
+				{Kind: Identifier, Value: "x2"},
+				{Kind: Bracket, Value: "}"},
+				{Kind: EOF},
+			},
+		},
+		{
+			`a>b if {x1} else {x2}`,
+			[]Token{
+				{Kind: Identifier, Value: "a"},
+				{Kind: Operator, Value: ">"},
+				{Kind: Identifier, Value: "b"},
+				{Kind: Operator, Value: "if"},
+				{Kind: Bracket, Value: "{"},
+				{Kind: Identifier, Value: "x1"},
+				{Kind: Bracket, Value: "}"},
+				{Kind: Operator, Value: "else"},
+				{Kind: Bracket, Value: "{"},
+				{Kind: Identifier, Value: "x2"},
+				{Kind: Bracket, Value: "}"},
+				{Kind: EOF},
+			},
+		},
 	}
 
 	for _, test := range tests {
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index d351e2f5c..c694a2ca0 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -129,9 +129,7 @@ loop:
 			switch l.word() {
 			case "not":
 				return not
-			case "in", "or", "and", "matches", "contains", "startsWith", "endsWith":
-				l.emit(Operator)
-			case "let":
+			case "in", "or", "and", "matches", "contains", "startsWith", "endsWith", "let", "if", "else":
 				l.emit(Operator)
 			default:
 				l.emit(Identifier)
diff --git a/parser/parser.go b/parser/parser.go
index 0817f6e4b..917e0db4f 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -132,6 +132,9 @@ func (p *parser) parseExpression(precedence int) Node {
 	if precedence == 0 && p.current.Is(Operator, "let") {
 		return p.parseVariableDeclaration()
 	}
+	if p.current.Is(Operator, "if") {
+		return p.parseConditionalIf()
+	}
 
 	nodeLeft := p.parsePrimary()
 
@@ -235,6 +238,25 @@ func (p *parser) parseVariableDeclaration() Node {
 	return let
 }
 
+func (p *parser) parseConditionalIf() Node {
+	p.next()
+	nodeCondition := p.parseExpression(0)
+	p.expect(Bracket, "{")
+	expr1 := p.parseExpression(0)
+	p.expect(Bracket, "}")
+	p.expect(Operator, "else")
+	p.expect(Bracket, "{")
+	expr2 := p.parseExpression(0)
+	p.expect(Bracket, "}")
+
+	return &ConditionalNode{
+		Cond: nodeCondition,
+		Exp1: expr1,
+		Exp2: expr2,
+	}
+
+}
+
 func (p *parser) parseConditional(node Node) Node {
 	var expr1, expr2 Node
 	for p.current.Is(Operator, "?") && p.err == nil {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index a280bf39a..6bb17e604 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -647,6 +647,17 @@ world`},
 				Right: &BoolNode{Value: true},
 			},
 		},
+		{
+			"if a>b {true} else {x}",
+			&ConditionalNode{
+				Cond: &BinaryNode{
+					Operator: ">",
+					Left:     &IdentifierNode{Value: "a"},
+					Right:    &IdentifierNode{Value: "b"},
+				},
+				Exp1: &BoolNode{Value: true},
+				Exp2: &IdentifierNode{Value: "x"}},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {

From b4606bdf394042aba0458a15780683a8cb45f62e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 1 Mar 2025 20:00:54 +0100
Subject: [PATCH 363/506] Create .gitattributes

Signed-off-by: Anton Medvedev <anton@medv.io>
---
 .gitattributes | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .gitattributes

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 000000000..86cc5e2c9
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+*[generated].go linguist-generated

From 829454b8783e3ab7d74f6fd777575871753afbe1 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 1 Mar 2025 20:03:27 +0100
Subject: [PATCH 364/506] Update .gitattributes

Signed-off-by: Anton Medvedev <anton@medv.io>
---
 .gitattributes | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitattributes b/.gitattributes
index 86cc5e2c9..05ac79c1f 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1 @@
-*[generated].go linguist-generated
+*[generated].go linguist-language=txt

From 0bb9c140269c6efae4ac4d41141e3e86c9350221 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 1 Mar 2025 20:03:45 +0100
Subject: [PATCH 365/506] Update .gitattributes

Signed-off-by: Anton Medvedev <anton@medv.io>
---
 .gitattributes | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitattributes b/.gitattributes
index 05ac79c1f..9be6de810 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1 @@
-*[generated].go linguist-language=txt
+vm/func_types[generated].go linguist-language=txt

From c3c5c4db9fee84bd35af721a38e534b0f7782284 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 1 Mar 2025 20:05:02 +0100
Subject: [PATCH 366/506] Update .gitattributes (#759)

Signed-off-by: Anton Medvedev <anton@medv.io>
---
 .gitattributes | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitattributes b/.gitattributes
index 9be6de810..84536852d 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1,2 @@
 vm/func_types[generated].go linguist-language=txt
+vm/opcodes.go linguist-language=txt

From ac42ea0cddafcc72355508252cfe2f6d96c2939d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 1 Mar 2025 20:05:51 +0100
Subject: [PATCH 367/506] Update .gitattributes

Signed-off-by: Anton Medvedev <anton@medv.io>
---
 .gitattributes | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.gitattributes b/.gitattributes
index 84536852d..ca2d51c62 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,2 +1 @@
-vm/func_types[generated].go linguist-language=txt
-vm/opcodes.go linguist-language=txt
+vm/func_types\[generated\].go linguist-language=txt

From 867dca6d78cd5ff67b814727b8a48b2d85511e3f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 1 Mar 2025 20:10:40 +0100
Subject: [PATCH 368/506] Update .gitattributes

Signed-off-by: Anton Medvedev <anton@medv.io>
---
 .gitattributes | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitattributes b/.gitattributes
index ca2d51c62..efd30300a 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1 @@
-vm/func_types\[generated\].go linguist-language=txt
+*\[generated\].go linguist-language=txt

From 82281483d791a925f8930dcf60bf07d1d5ccf079 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sat, 1 Mar 2025 23:11:57 +0200
Subject: [PATCH 369/506] ci: pin benchstat version and update GitHub Actions
 (#761)

Fix CI workflow compatibility issues and update dependencies:

- Pin benchstat to specific commit (884df5) compatible with Go 1.18
  instead of using @latest which now requires Go 1.23+
- Add explanatory comment about benchstat version constraints
- Upgrade actions/upload-artifact from v3 to v4 in fuzz.yml
- Upgrade github/codeql-action from v2 to v3 in fuzz.yml

These changes ensure the CI pipeline remains compatible with Go 1.18
while benefiting from the latest improvements in GitHub Actions.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 .github/workflows/diff.yml | 4 +++-
 .github/workflows/fuzz.yml | 4 ++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml
index d9fd20c59..3a81ba2e1 100644
--- a/.github/workflows/diff.yml
+++ b/.github/workflows/diff.yml
@@ -13,7 +13,9 @@ jobs:
         with:
           go-version: 1.18
       - name: Install benchstat
-        run: go install golang.org/x/perf/cmd/benchstat@latest
+        # NOTE: benchstat@latest requires go 1.23 since 2025-02-14 - this is the last go 1.18 ref
+        # https://cs.opensource.google/go/x/perf/+/c95ad7d5b636f67d322a7e4832e83103d0fdd292
+        run: go install golang.org/x/perf/cmd/benchstat@884df5810d2850d775c2cb4885a7ea339128a17d
 
       - uses: actions/checkout@v3
       - name: Benchmark new code
diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
index b883b8393..34e77d6be 100644
--- a/.github/workflows/fuzz.yml
+++ b/.github/workflows/fuzz.yml
@@ -21,14 +21,14 @@ jobs:
           fuzz-seconds: 600
           output-sarif: true
       - name: Upload Crash
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         if: failure() && steps.build.outcome == 'success'
         with:
           name: artifacts
           path: ./out/artifacts
       - name: Upload Sarif
         if: always() && steps.build.outcome == 'success'
-        uses: github/codeql-action/upload-sarif@v2
+        uses: github/codeql-action/upload-sarif@v3
         with:
           # Path to SARIF file relative to the root of the repository
           sarif_file: cifuzz-sarif/results.sarif

From 77e876bb7cda24c5aeedbfd1a0efa1465fb503bb Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sun, 2 Mar 2025 10:31:59 +0200
Subject: [PATCH 370/506] ci: add Go 1.23/1.24 testing and fix example test
 names (#760)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Expand test coverage to newer Go versions and fix compatibility issues:

- Add Go 1.23 and 1.24 to test matrix in test.yml
- Add Go 1.24 to build matrix in build.yml
- Fix example test names to match Go conventions:
  * ExampleOperator_Decimal → ExampleOperator_with_decimal
  * ExampleWithTimezone → ExampleTimezone
  * ExampleGetUnifiedDiffCode → ExampleGetUnifiedDiffString
  * ExampleGetContextDiffCode → ExampleGetContextDiffString
  * ExampleGetContextDiffString → ExampleGetContextDiffString_second

These changes maintain compatibility with Go 1.18 (as specified in
go.mod) while ensuring the codebase works correctly with the latest
Go versions, which enforce stricter naming conventions for example
tests.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 .github/workflows/build.yml      | 2 +-
 .github/workflows/test.yml       | 2 +-
 expr_test.go                     | 4 ++--
 internal/difflib/difflib_test.go | 6 +++---
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index d2e6518ca..854ca5348 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.22' ]
+        go-versions: [ '1.18', '1.22', '1.24' ]
         go-arch: [ '386' ]
     steps:
       - uses: actions/checkout@v3
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index dc197eb1f..5d0b0744e 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22' ]
+        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22', '1.23', '1.24' ]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Go ${{ matrix.go-version }}
diff --git a/expr_test.go b/expr_test.go
index bda5551cc..f10350b22 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -312,7 +312,7 @@ func ExampleOperator() {
 	// Output: true
 }
 
-func ExampleOperator_Decimal() {
+func ExampleOperator_with_decimal() {
 	type Decimal struct{ N float64 }
 	code := `A + B - C`
 
@@ -585,7 +585,7 @@ func ExampleWithContext() {
 	// Output: 42
 }
 
-func ExampleWithTimezone() {
+func ExampleTimezone() {
 	program, err := expr.Compile(`now().Location().String()`, expr.Timezone("Asia/Kamchatka"))
 	if err != nil {
 		fmt.Printf("%v", err)
diff --git a/internal/difflib/difflib_test.go b/internal/difflib/difflib_test.go
index d72511962..60fb1f9cb 100644
--- a/internal/difflib/difflib_test.go
+++ b/internal/difflib/difflib_test.go
@@ -102,7 +102,7 @@ group
 	}
 }
 
-func ExampleGetUnifiedDiffCode() {
+func ExampleGetUnifiedDiffString() {
 	a := `one
 two
 three
@@ -135,7 +135,7 @@ four`
 	// -fmt.Printf("%s,%T",a,b)
 }
 
-func ExampleGetContextDiffCode() {
+func ExampleGetContextDiffString() {
 	a := `one
 two
 three
@@ -172,7 +172,7 @@ four`
 	//   four
 }
 
-func ExampleGetContextDiffString() {
+func ExampleGetContextDiffString_second() {
 	a := `one
 two
 three

From 0d19441454426d2f58edb22c31f3ba5f99c7a26e Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Fri, 7 Mar 2025 15:09:41 +0200
Subject: [PATCH 371/506] feat: add node budget and memory limits (#762)

* feat: add node budget and memory limits

Implement compile-time and runtime safeguards against deeply nested expressions:

- Add MaxNodes limit to track and limit AST node count during parsing
- Move MemoryBudget from VM to Config for better configurability
- Add node creation tracking in parser to enforce node budget
- Refactor node creation to check limits before allocation
- Add RunWithConfig to VM for passing memory budget settings
- Set reasonable defaults in Config (10000 nodes, 1M memory)
- Add comprehensive tests for both node and memory limits

This prevents stack overflows from malicious or poorly written expressions
by failing fast with clear error messages during compilation or runtime.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>

* Update parser.go

Signed-off-by: Anton Medvedev <anton@medv.io>

---------

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Signed-off-by: Anton Medvedev <anton@medv.io>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 conf/config.go        |  46 ++++++---
 parser/parser.go      | 234 ++++++++++++++++++++++++++++++------------
 parser/parser_test.go |  76 ++++++++++++++
 vm/utils.go           |   3 -
 vm/vm.go              |  23 ++++-
 vm/vm_test.go         | 164 ++++++++++++++++++++++++++++-
 6 files changed, 452 insertions(+), 94 deletions(-)

diff --git a/conf/config.go b/conf/config.go
index 8a6ee70e2..270438b9d 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -10,31 +10,43 @@ import (
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
+const (
+	// DefaultMemoryBudget represents an upper limit of memory usage
+	DefaultMemoryBudget uint = 1e6
+
+	// DefaultMaxNodes represents an upper limit of AST nodes
+	DefaultMaxNodes uint = 10000
+)
+
 type FunctionsTable map[string]*builtin.Function
 
 type Config struct {
-	EnvObject any
-	Env       nature.Nature
-	Expect    reflect.Kind
-	ExpectAny bool
-	Optimize  bool
-	Strict    bool
-	Profile   bool
-	ConstFns  map[string]reflect.Value
-	Visitors  []ast.Visitor
-	Functions FunctionsTable
-	Builtins  FunctionsTable
-	Disabled  map[string]bool // disabled builtins
+	EnvObject    any
+	Env          nature.Nature
+	Expect       reflect.Kind
+	ExpectAny    bool
+	Optimize     bool
+	Strict       bool
+	Profile      bool
+	MaxNodes     uint
+	MemoryBudget uint
+	ConstFns     map[string]reflect.Value
+	Visitors     []ast.Visitor
+	Functions    FunctionsTable
+	Builtins     FunctionsTable
+	Disabled     map[string]bool // disabled builtins
 }
 
 // CreateNew creates new config with default values.
 func CreateNew() *Config {
 	c := &Config{
-		Optimize:  true,
-		ConstFns:  make(map[string]reflect.Value),
-		Functions: make(map[string]*builtin.Function),
-		Builtins:  make(map[string]*builtin.Function),
-		Disabled:  make(map[string]bool),
+		Optimize:     true,
+		MaxNodes:     DefaultMaxNodes,
+		MemoryBudget: DefaultMemoryBudget,
+		ConstFns:     make(map[string]reflect.Value),
+		Functions:    make(map[string]*builtin.Function),
+		Builtins:     make(map[string]*builtin.Function),
+		Disabled:     make(map[string]bool),
 	}
 	for _, f := range builtin.Builtins {
 		c.Builtins[f.Name] = f
diff --git a/parser/parser.go b/parser/parser.go
index 917e0db4f..086554223 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -45,12 +45,47 @@ var predicates = map[string]struct {
 }
 
 type parser struct {
-	tokens  []Token
-	current Token
-	pos     int
-	err     *file.Error
-	depth   int // predicate call depth
-	config  *conf.Config
+	tokens    []Token
+	current   Token
+	pos       int
+	err       *file.Error
+	depth     int // predicate call depth
+	config    *conf.Config
+	nodeCount uint // tracks number of AST nodes created
+}
+
+// checkNodeLimit verifies that adding a new node won't exceed configured limits
+func (p *parser) checkNodeLimit() error {
+	p.nodeCount++
+	if p.config.MaxNodes > 0 && p.nodeCount > p.config.MaxNodes {
+		p.error("compilation failed: expression exceeds maximum allowed nodes")
+		return nil
+	}
+	return nil
+}
+
+// createNode handles creation of regular nodes
+func (p *parser) createNode(n Node, loc file.Location) Node {
+	if err := p.checkNodeLimit(); err != nil {
+		return nil
+	}
+	if n == nil || p.err != nil {
+		return nil
+	}
+	n.SetLocation(loc)
+	return n
+}
+
+// createMemberNode handles creation of member nodes
+func (p *parser) createMemberNode(n *MemberNode, loc file.Location) *MemberNode {
+	if err := p.checkNodeLimit(); err != nil {
+		return nil
+	}
+	if n == nil || p.err != nil {
+		return nil
+	}
+	n.SetLocation(loc)
+	return n
 }
 
 type Tree struct {
@@ -129,6 +164,10 @@ func (p *parser) expect(kind Kind, values ...string) {
 // parse functions
 
 func (p *parser) parseExpression(precedence int) Node {
+	if p.err != nil {
+		return nil
+	}
+
 	if precedence == 0 && p.current.Is(Operator, "let") {
 		return p.parseVariableDeclaration()
 	}
@@ -190,19 +229,23 @@ func (p *parser) parseExpression(precedence int) Node {
 				nodeRight = p.parseExpression(op.Precedence)
 			}
 
-			nodeLeft = &BinaryNode{
+			nodeLeft = p.createNode(&BinaryNode{
 				Operator: opToken.Value,
 				Left:     nodeLeft,
 				Right:    nodeRight,
+			}, opToken.Location)
+			if nodeLeft == nil {
+				return nil
 			}
-			nodeLeft.SetLocation(opToken.Location)
 
 			if negate {
-				nodeLeft = &UnaryNode{
+				nodeLeft = p.createNode(&UnaryNode{
 					Operator: "not",
 					Node:     nodeLeft,
+				}, notToken.Location)
+				if nodeLeft == nil {
+					return nil
 				}
-				nodeLeft.SetLocation(notToken.Location)
 			}
 
 			goto next
@@ -229,13 +272,11 @@ func (p *parser) parseVariableDeclaration() Node {
 	value := p.parseExpression(0)
 	p.expect(Operator, ";")
 	node := p.parseExpression(0)
-	let := &VariableDeclaratorNode{
+	return p.createNode(&VariableDeclaratorNode{
 		Name:  variableName.Value,
 		Value: value,
 		Expr:  node,
-	}
-	let.SetLocation(variableName.Location)
-	return let
+	}, variableName.Location)
 }
 
 func (p *parser) parseConditionalIf() Node {
@@ -272,10 +313,13 @@ func (p *parser) parseConditional(node Node) Node {
 			expr2 = p.parseExpression(0)
 		}
 
-		node = &ConditionalNode{
+		node = p.createNode(&ConditionalNode{
 			Cond: node,
 			Exp1: expr1,
 			Exp2: expr2,
+		}, p.current.Location)
+		if node == nil {
+			return nil
 		}
 	}
 	return node
@@ -288,11 +332,13 @@ func (p *parser) parsePrimary() Node {
 		if op, ok := operator.Unary[token.Value]; ok {
 			p.next()
 			expr := p.parseExpression(op.Precedence)
-			node := &UnaryNode{
+			node := p.createNode(&UnaryNode{
 				Operator: token.Value,
 				Node:     expr,
+			}, token.Location)
+			if node == nil {
+				return nil
 			}
-			node.SetLocation(token.Location)
 			return p.parsePostfixExpression(node)
 		}
 	}
@@ -314,8 +360,10 @@ func (p *parser) parsePrimary() Node {
 					p.next()
 				}
 			}
-			node := &PointerNode{Name: name}
-			node.SetLocation(token.Location)
+			node := p.createNode(&PointerNode{Name: name}, token.Location)
+			if node == nil {
+				return nil
+			}
 			return p.parsePostfixExpression(node)
 		}
 	} else {
@@ -344,23 +392,31 @@ func (p *parser) parseSecondary() Node {
 		p.next()
 		switch token.Value {
 		case "true":
-			node := &BoolNode{Value: true}
-			node.SetLocation(token.Location)
+			node = p.createNode(&BoolNode{Value: true}, token.Location)
+			if node == nil {
+				return nil
+			}
 			return node
 		case "false":
-			node := &BoolNode{Value: false}
-			node.SetLocation(token.Location)
+			node = p.createNode(&BoolNode{Value: false}, token.Location)
+			if node == nil {
+				return nil
+			}
 			return node
 		case "nil":
-			node := &NilNode{}
-			node.SetLocation(token.Location)
+			node = p.createNode(&NilNode{}, token.Location)
+			if node == nil {
+				return nil
+			}
 			return node
 		default:
 			if p.current.Is(Bracket, "(") {
 				node = p.parseCall(token, []Node{}, true)
 			} else {
-				node = &IdentifierNode{Value: token.Value}
-				node.SetLocation(token.Location)
+				node = p.createNode(&IdentifierNode{Value: token.Value}, token.Location)
+				if node == nil {
+					return nil
+				}
 			}
 		}
 
@@ -407,8 +463,10 @@ func (p *parser) parseSecondary() Node {
 		return node
 	case String:
 		p.next()
-		node = &StringNode{Value: token.Value}
-		node.SetLocation(token.Location)
+		node = p.createNode(&StringNode{Value: token.Value}, token.Location)
+		if node == nil {
+			return nil
+		}
 
 	default:
 		if token.Is(Bracket, "[") {
@@ -428,7 +486,7 @@ func (p *parser) toIntegerNode(number int64) Node {
 		p.error("integer literal is too large")
 		return nil
 	}
-	return &IntegerNode{Value: int(number)}
+	return p.createNode(&IntegerNode{Value: int(number)}, p.current.Location)
 }
 
 func (p *parser) toFloatNode(number float64) Node {
@@ -436,7 +494,7 @@ func (p *parser) toFloatNode(number float64) Node {
 		p.error("float literal is too large")
 		return nil
 	}
-	return &FloatNode{Value: number}
+	return p.createNode(&FloatNode{Value: number}, p.current.Location)
 }
 
 func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) Node {
@@ -478,25 +536,34 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 
 		p.expect(Bracket, ")")
 
-		node = &BuiltinNode{
+		node = p.createNode(&BuiltinNode{
 			Name:      token.Value,
 			Arguments: arguments,
+		}, token.Location)
+		if node == nil {
+			return nil
 		}
-		node.SetLocation(token.Location)
 	} else if _, ok := builtin.Index[token.Value]; ok && !p.config.Disabled[token.Value] && !isOverridden {
-		node = &BuiltinNode{
+		node = p.createNode(&BuiltinNode{
 			Name:      token.Value,
 			Arguments: p.parseArguments(arguments),
+		}, token.Location)
+		if node == nil {
+			return nil
 		}
-		node.SetLocation(token.Location)
+
 	} else {
-		callee := &IdentifierNode{Value: token.Value}
-		callee.SetLocation(token.Location)
-		node = &CallNode{
+		callee := p.createNode(&IdentifierNode{Value: token.Value}, token.Location)
+		if callee == nil {
+			return nil
+		}
+		node = p.createNode(&CallNode{
 			Callee:    callee,
 			Arguments: p.parseArguments(arguments),
+		}, token.Location)
+		if node == nil {
+			return nil
 		}
-		node.SetLocation(token.Location)
 	}
 	return node
 }
@@ -534,10 +601,12 @@ func (p *parser) parsePredicate() Node {
 	if expectClosingBracket {
 		p.expect(Bracket, "}")
 	}
-	predicateNode := &PredicateNode{
+	predicateNode := p.createNode(&PredicateNode{
 		Node: node,
+	}, startToken.Location)
+	if predicateNode == nil {
+		return nil
 	}
-	predicateNode.SetLocation(startToken.Location)
 	return predicateNode
 }
 
@@ -558,8 +627,10 @@ func (p *parser) parseArrayExpression(token Token) Node {
 end:
 	p.expect(Bracket, "]")
 
-	node := &ArrayNode{Nodes: nodes}
-	node.SetLocation(token.Location)
+	node := p.createNode(&ArrayNode{Nodes: nodes}, token.Location)
+	if node == nil {
+		return nil
+	}
 	return node
 }
 
@@ -585,8 +656,10 @@ func (p *parser) parseMapExpression(token Token) Node {
 		//  * identifier, which is equivalent to a string
 		//  * expression, which must be enclosed in parentheses -- (1 + 2)
 		if p.current.Is(Number) || p.current.Is(String) || p.current.Is(Identifier) {
-			key = &StringNode{Value: p.current.Value}
-			key.SetLocation(token.Location)
+			key = p.createNode(&StringNode{Value: p.current.Value}, p.current.Location)
+			if key == nil {
+				return nil
+			}
 			p.next()
 		} else if p.current.Is(Bracket, "(") {
 			key = p.parseExpression(0)
@@ -597,16 +670,20 @@ func (p *parser) parseMapExpression(token Token) Node {
 		p.expect(Operator, ":")
 
 		node := p.parseExpression(0)
-		pair := &PairNode{Key: key, Value: node}
-		pair.SetLocation(token.Location)
+		pair := p.createNode(&PairNode{Key: key, Value: node}, token.Location)
+		if pair == nil {
+			return nil
+		}
 		nodes = append(nodes, pair)
 	}
 
 end:
 	p.expect(Bracket, "}")
 
-	node := &MapNode{Pairs: nodes}
-	node.SetLocation(token.Location)
+	node := p.createNode(&MapNode{Pairs: nodes}, token.Location)
+	if node == nil {
+		return nil
+	}
 	return node
 }
 
@@ -631,8 +708,10 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 				p.error("expected name")
 			}
 
-			property := &StringNode{Value: propertyToken.Value}
-			property.SetLocation(propertyToken.Location)
+			property := p.createNode(&StringNode{Value: propertyToken.Value}, propertyToken.Location)
+			if property == nil {
+				return nil
+			}
 
 			chainNode, isChain := node.(*ChainNode)
 			optional := postfixToken.Value == "?."
@@ -641,26 +720,33 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 				node = chainNode.Node
 			}
 
-			memberNode := &MemberNode{
+			memberNode := p.createMemberNode(&MemberNode{
 				Node:     node,
 				Property: property,
 				Optional: optional,
+			}, propertyToken.Location)
+			if memberNode == nil {
+				return nil
 			}
-			memberNode.SetLocation(propertyToken.Location)
 
 			if p.current.Is(Bracket, "(") {
 				memberNode.Method = true
-				node = &CallNode{
+				node = p.createNode(&CallNode{
 					Callee:    memberNode,
 					Arguments: p.parseArguments([]Node{}),
+				}, propertyToken.Location)
+				if node == nil {
+					return nil
 				}
-				node.SetLocation(propertyToken.Location)
 			} else {
 				node = memberNode
 			}
 
 			if isChain || optional {
-				node = &ChainNode{Node: node}
+				node = p.createNode(&ChainNode{Node: node}, propertyToken.Location)
+				if node == nil {
+					return nil
+				}
 			}
 
 		} else if postfixToken.Value == "[" {
@@ -674,11 +760,13 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 					to = p.parseExpression(0)
 				}
 
-				node = &SliceNode{
+				node = p.createNode(&SliceNode{
 					Node: node,
 					To:   to,
+				}, postfixToken.Location)
+				if node == nil {
+					return nil
 				}
-				node.SetLocation(postfixToken.Location)
 				p.expect(Bracket, "]")
 
 			} else {
@@ -692,25 +780,32 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 						to = p.parseExpression(0)
 					}
 
-					node = &SliceNode{
+					node = p.createNode(&SliceNode{
 						Node: node,
 						From: from,
 						To:   to,
+					}, postfixToken.Location)
+					if node == nil {
+						return nil
 					}
-					node.SetLocation(postfixToken.Location)
 					p.expect(Bracket, "]")
 
 				} else {
 					// Slice operator [:] was not found,
 					// it should be just an index node.
-					node = &MemberNode{
+					node = p.createNode(&MemberNode{
 						Node:     node,
 						Property: from,
 						Optional: optional,
+					}, postfixToken.Location)
+					if node == nil {
+						return nil
 					}
-					node.SetLocation(postfixToken.Location)
 					if optional {
-						node = &ChainNode{Node: node}
+						node = p.createNode(&ChainNode{Node: node}, postfixToken.Location)
+						if node == nil {
+							return nil
+						}
 					}
 					p.expect(Bracket, "]")
 				}
@@ -722,26 +817,29 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 	}
 	return node
 }
-
 func (p *parser) parseComparison(left Node, token Token, precedence int) Node {
 	var rootNode Node
 	for {
 		comparator := p.parseExpression(precedence + 1)
-		cmpNode := &BinaryNode{
+		cmpNode := p.createNode(&BinaryNode{
 			Operator: token.Value,
 			Left:     left,
 			Right:    comparator,
+		}, token.Location)
+		if cmpNode == nil {
+			return nil
 		}
-		cmpNode.SetLocation(token.Location)
 		if rootNode == nil {
 			rootNode = cmpNode
 		} else {
-			rootNode = &BinaryNode{
+			rootNode = p.createNode(&BinaryNode{
 				Operator: "&&",
 				Left:     rootNode,
 				Right:    cmpNode,
+			}, token.Location)
+			if rootNode == nil {
+				return nil
 			}
-			rootNode.SetLocation(token.Location)
 		}
 
 		left = comparator
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 6bb17e604..efae1f413 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -5,6 +5,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/internal/testify/assert"
 	"github.com/expr-lang/expr/internal/testify/require"
 
@@ -925,3 +926,78 @@ func TestParse_pipe_operator(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, Dump(expect), Dump(actual.Node))
 }
+
+func TestNodeBudget(t *testing.T) {
+	tests := []struct {
+		name        string
+		expr        string
+		maxNodes    uint
+		shouldError bool
+	}{
+		{
+			name:        "simple expression equal to limit",
+			expr:        "a + b",
+			maxNodes:    3,
+			shouldError: false,
+		},
+		{
+			name:        "medium expression under limit",
+			expr:        "a + b * c / d",
+			maxNodes:    20,
+			shouldError: false,
+		},
+		{
+			name:        "deeply nested expression over limit",
+			expr:        "1 + (2 + (3 + (4 + (5 + (6 + (7 + 8))))))",
+			maxNodes:    10,
+			shouldError: true,
+		},
+		{
+			name:        "array expression over limit",
+			expr:        "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+			maxNodes:    5,
+			shouldError: true,
+		},
+		{
+			name:        "disabled node budget",
+			expr:        "1 + (2 + (3 + (4 + (5 + (6 + (7 + 8))))))",
+			maxNodes:    0,
+			shouldError: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			config := conf.CreateNew()
+			config.MaxNodes = tt.maxNodes
+			config.Disabled = make(map[string]bool, 0)
+
+			_, err := parser.ParseWithConfig(tt.expr, config)
+			hasError := err != nil && strings.Contains(err.Error(), "exceeds maximum allowed nodes")
+
+			if hasError != tt.shouldError {
+				t.Errorf("ParseWithConfig(%q) error = %v, shouldError %v", tt.expr, err, tt.shouldError)
+			}
+
+			// Verify error message format when expected
+			if tt.shouldError && err != nil {
+				expected := "compilation failed: expression exceeds maximum allowed nodes"
+				if !strings.Contains(err.Error(), expected) {
+					t.Errorf("Expected error message to contain %q, got %q", expected, err.Error())
+				}
+			}
+		})
+	}
+}
+
+func TestNodeBudgetDisabled(t *testing.T) {
+	config := conf.CreateNew()
+	config.MaxNodes = 0 // Disable node budget
+
+	expr := strings.Repeat("a + ", 1000) + "b"
+	_, err := parser.ParseWithConfig(expr, config)
+
+	if err != nil && strings.Contains(err.Error(), "exceeds maximum allowed nodes") {
+		t.Error("Node budget check should be disabled when MaxNodes is 0")
+	}
+}
diff --git a/vm/utils.go b/vm/utils.go
index fc2f5e7b8..11005137c 100644
--- a/vm/utils.go
+++ b/vm/utils.go
@@ -11,9 +11,6 @@ type (
 )
 
 var (
-	// MemoryBudget represents an upper limit of memory usage.
-	MemoryBudget uint = 1e6
-
 	errorType = reflect.TypeOf((*error)(nil)).Elem()
 )
 
diff --git a/vm/vm.go b/vm/vm.go
index fa1223b42..62c6511f4 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/expr-lang/expr/builtin"
+	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/internal/deref"
 	"github.com/expr-lang/expr/vm/runtime"
@@ -20,11 +21,23 @@ func Run(program *Program, env any) (any, error) {
 	if program == nil {
 		return nil, fmt.Errorf("program is nil")
 	}
-
 	vm := VM{}
 	return vm.Run(program, env)
 }
 
+func RunWithConfig(program *Program, env any, config *conf.Config) (any, error) {
+	if program == nil {
+		return nil, fmt.Errorf("program is nil")
+	}
+	if config == nil {
+		return nil, fmt.Errorf("config is nil")
+	}
+	vm := VM{
+		MemoryBudget: config.MemoryBudget,
+	}
+	return vm.Run(program, env)
+}
+
 func Debug() *VM {
 	vm := &VM{
 		debug: true,
@@ -38,9 +51,9 @@ type VM struct {
 	Stack        []any
 	Scopes       []*Scope
 	Variables    []any
+	MemoryBudget uint
 	ip           int
 	memory       uint
-	memoryBudget uint
 	debug        bool
 	step         chan struct{}
 	curr         chan int
@@ -76,7 +89,9 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		vm.Variables = make([]any, program.variables)
 	}
 
-	vm.memoryBudget = MemoryBudget
+	if vm.MemoryBudget == 0 {
+		vm.MemoryBudget = conf.DefaultMemoryBudget
+	}
 	vm.memory = 0
 	vm.ip = 0
 
@@ -599,7 +614,7 @@ func (vm *VM) pop() any {
 
 func (vm *VM) memGrow(size uint) {
 	vm.memory += size
-	if vm.memory >= vm.memoryBudget {
+	if vm.memory >= vm.MemoryBudget {
 		panic("memory budget exceeded")
 	}
 }
diff --git a/vm/vm_test.go b/vm/vm_test.go
index d45ef2d6c..aec358ab7 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"strings"
 	"testing"
 
 	"github.com/expr-lang/expr/internal/testify/require"
@@ -17,8 +18,35 @@ import (
 )
 
 func TestRun_NilProgram(t *testing.T) {
-	_, err := vm.Run(nil, nil)
-	require.Error(t, err)
+	t.Run("run with nil program", func(t *testing.T) {
+		newVM, err := vm.Run(nil, nil)
+		require.Error(t, err)
+		require.Nil(t, newVM)
+	})
+	t.Run("run with nil program and nil config", func(t *testing.T) {
+		newVM, err := vm.RunWithConfig(nil, nil, nil)
+		require.Error(t, err)
+		require.Nil(t, newVM)
+	})
+	t.Run("run with nil config", func(t *testing.T) {
+		program, err := expr.Compile("1")
+		require.Nil(t, err)
+		newVM, err := vm.RunWithConfig(program, nil, nil)
+		require.Error(t, err)
+		require.Nil(t, newVM)
+	})
+	t.Run("run with config", func(t *testing.T) {
+		program, err := expr.Compile("1")
+		require.Nil(t, err)
+		config := conf.New(nil)
+		env := map[string]any{
+			"a": 1,
+		}
+		config.MemoryBudget = 100
+		newVM, err := vm.RunWithConfig(program, env, config)
+		require.Nil(t, err)
+		require.Equal(t, newVM, 1)
+	})
 }
 
 func TestRun_ReuseVM(t *testing.T) {
@@ -1191,3 +1219,135 @@ func TestVM_DirectBasicOpcodes(t *testing.T) {
 		})
 	}
 }
+
+func TestVM_MemoryBudget(t *testing.T) {
+	tests := []struct {
+		name        string
+		expr        string
+		memBudget   uint
+		expectError string
+	}{
+		{
+			name:      "under budget",
+			expr:      "map(1..10, #)",
+			memBudget: 100,
+		},
+		{
+			name:        "exceeds budget",
+			expr:        "map(1..1000, #)",
+			memBudget:   10,
+			expectError: "memory budget exceeded",
+		},
+		{
+			name:      "zero budget uses default",
+			expr:      "map(1..10, #)",
+			memBudget: 0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			node, err := parser.Parse(tt.expr)
+			require.NoError(t, err)
+
+			program, err := compiler.Compile(node, nil)
+			require.NoError(t, err)
+
+			vm := vm.VM{MemoryBudget: tt.memBudget}
+			out, err := vm.Run(program, nil)
+
+			if tt.expectError != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.expectError)
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, out)
+			}
+		})
+	}
+}
+
+// Helper functions for creating deeply nested expressions
+func createNestedArithmeticExpr(t *testing.T, depth int) string {
+	t.Helper()
+	if depth == 0 {
+		return "a"
+	}
+	return fmt.Sprintf("(%s + %d)", createNestedArithmeticExpr(t, depth-1), depth)
+}
+
+func createNestedMapExpr(t *testing.T, depth int) string {
+	t.Helper()
+	if depth == 0 {
+		return `{"value": 1}`
+	}
+	return fmt.Sprintf(`{"nested": %s}`, createNestedMapExpr(t, depth-1))
+}
+
+func TestVM_Limits(t *testing.T) {
+	tests := []struct {
+		name         string
+		expr         string
+		memoryBudget uint
+		maxNodes     uint
+		env          map[string]any
+		expectError  string
+	}{
+		{
+			name:         "nested arithmetic allowed with max nodes and memory budget",
+			expr:         createNestedArithmeticExpr(t, 100),
+			env:          map[string]any{"a": 1},
+			maxNodes:     1000,
+			memoryBudget: 1, // arithmetic expressions not counted towards memory budget
+		},
+		{
+			name:         "nested arithmetic blocked by max nodes",
+			expr:         createNestedArithmeticExpr(t, 10000),
+			env:          map[string]any{"a": 1},
+			maxNodes:     100,
+			memoryBudget: 1, // arithmetic expressions not counted towards memory budget
+			expectError:  "compilation failed: expression exceeds maximum allowed nodes",
+		},
+		{
+			name:         "nested map blocked by memory budget",
+			expr:         createNestedMapExpr(t, 100),
+			env:          map[string]any{},
+			maxNodes:     1000,
+			memoryBudget: 10, // Small memory budget to trigger limit
+			expectError:  "memory budget exceeded",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var options []expr.Option
+			options = append(options, expr.Env(test.env))
+			if test.maxNodes > 0 {
+				options = append(options, func(c *conf.Config) {
+					c.MaxNodes = test.maxNodes
+				})
+			}
+
+			program, err := expr.Compile(test.expr, options...)
+			if err != nil {
+				if test.expectError != "" && strings.Contains(err.Error(), test.expectError) {
+					return
+				}
+				t.Fatal(err)
+			}
+
+			testVM := &vm.VM{
+				MemoryBudget: test.memoryBudget,
+			}
+
+			_, err = testVM.Run(program, test.env)
+
+			if test.expectError == "" {
+				require.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), test.expectError)
+			}
+		})
+	}
+}

From bc77b4b3cd7665412e84f7e421798d2b91de0be7 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 7 Mar 2025 15:06:45 +0100
Subject: [PATCH 372/506] Remove additional run API (RunWithConfig) from VM

This API was introduced in previous PR, but we do not want to expose it.
---
 vm/vm.go      | 13 -------------
 vm/vm_test.go | 31 ++-----------------------------
 2 files changed, 2 insertions(+), 42 deletions(-)

diff --git a/vm/vm.go b/vm/vm.go
index 62c6511f4..5c40f26cd 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -25,19 +25,6 @@ func Run(program *Program, env any) (any, error) {
 	return vm.Run(program, env)
 }
 
-func RunWithConfig(program *Program, env any, config *conf.Config) (any, error) {
-	if program == nil {
-		return nil, fmt.Errorf("program is nil")
-	}
-	if config == nil {
-		return nil, fmt.Errorf("config is nil")
-	}
-	vm := VM{
-		MemoryBudget: config.MemoryBudget,
-	}
-	return vm.Run(program, env)
-}
-
 func Debug() *VM {
 	vm := &VM{
 		debug: true,
diff --git a/vm/vm_test.go b/vm/vm_test.go
index aec358ab7..615b0a442 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -18,35 +18,8 @@ import (
 )
 
 func TestRun_NilProgram(t *testing.T) {
-	t.Run("run with nil program", func(t *testing.T) {
-		newVM, err := vm.Run(nil, nil)
-		require.Error(t, err)
-		require.Nil(t, newVM)
-	})
-	t.Run("run with nil program and nil config", func(t *testing.T) {
-		newVM, err := vm.RunWithConfig(nil, nil, nil)
-		require.Error(t, err)
-		require.Nil(t, newVM)
-	})
-	t.Run("run with nil config", func(t *testing.T) {
-		program, err := expr.Compile("1")
-		require.Nil(t, err)
-		newVM, err := vm.RunWithConfig(program, nil, nil)
-		require.Error(t, err)
-		require.Nil(t, newVM)
-	})
-	t.Run("run with config", func(t *testing.T) {
-		program, err := expr.Compile("1")
-		require.Nil(t, err)
-		config := conf.New(nil)
-		env := map[string]any{
-			"a": 1,
-		}
-		config.MemoryBudget = 100
-		newVM, err := vm.RunWithConfig(program, env, config)
-		require.Nil(t, err)
-		require.Equal(t, newVM, 1)
-	})
+	_, err := vm.Run(nil, nil)
+	require.Error(t, err)
 }
 
 func TestRun_ReuseVM(t *testing.T) {

From ed9de341c58b43d844af11244f315300d419e381 Mon Sep 17 00:00:00 2001
From: Ryan Bullock <ryan@piratel.com>
Date: Fri, 7 Mar 2025 06:27:19 -0800
Subject: [PATCH 373/506] Separate patching phases for patchers that require
 multiple passes. (#659)

* Reset tracking of applied operator overloads before every walk of the ast tree.

* Remove limit on operator overload resolution

* Do separate patcher phase for those that require multiple passes (Currently only need for Operator overloading). This patcher phase is run after other patchers.

* Add test to track how many times a patcher is run. Used to detect if patching phases is erroneously applying the patcher multiple times.

---------

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 checker/checker.go             | 58 +++++++++++++++++++++-----------
 patcher/operator_override.go   |  5 +++
 test/patch/patch_count_test.go | 61 ++++++++++++++++++++++++++++++++++
 3 files changed, 105 insertions(+), 19 deletions(-)
 create mode 100644 test/patch/patch_count_test.go

diff --git a/checker/checker.go b/checker/checker.go
index 0ad22f4e1..e71f1d7e0 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -13,6 +13,40 @@ import (
 	"github.com/expr-lang/expr/parser"
 )
 
+// Run visitors in a given config over the given tree
+// runRepeatable controls whether to filter for only vistors that require multiple passes or not
+func runVisitors(tree *parser.Tree, config *conf.Config, runRepeatable bool) {
+	for {
+		more := false
+		for _, v := range config.Visitors {
+			// We need to perform types check, because some visitors may rely on
+			// types information available in the tree.
+			_, _ = Check(tree, config)
+
+			r, repeatable := v.(interface {
+				Reset()
+				ShouldRepeat() bool
+			})
+
+			if repeatable {
+				if runRepeatable {
+					r.Reset()
+					ast.Walk(&tree.Node, v)
+					more = more || r.ShouldRepeat()
+				}
+			} else {
+				if !runRepeatable {
+					ast.Walk(&tree.Node, v)
+				}
+			}
+		}
+
+		if !more {
+			break
+		}
+	}
+}
+
 // ParseCheck parses input expression and checks its types. Also, it applies
 // all provided patchers. In case of error, it returns error with a tree.
 func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) {
@@ -22,25 +56,11 @@ func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) {
 	}
 
 	if len(config.Visitors) > 0 {
-		for i := 0; i < 1000; i++ {
-			more := false
-			for _, v := range config.Visitors {
-				// We need to perform types check, because some visitors may rely on
-				// types information available in the tree.
-				_, _ = Check(tree, config)
-
-				ast.Walk(&tree.Node, v)
-
-				if v, ok := v.(interface {
-					ShouldRepeat() bool
-				}); ok {
-					more = more || v.ShouldRepeat()
-				}
-			}
-			if !more {
-				break
-			}
-		}
+		// Run all patchers that dont support being run repeatedly first
+		runVisitors(tree, config, false)
+
+		// Run patchers that require multiple passes next (currently only Operator patching)
+		runVisitors(tree, config, true)
 	}
 	_, err = Check(tree, config)
 	if err != nil {
diff --git a/patcher/operator_override.go b/patcher/operator_override.go
index b2d20ec4b..308cbdba3 100644
--- a/patcher/operator_override.go
+++ b/patcher/operator_override.go
@@ -43,6 +43,11 @@ func (p *OperatorOverloading) Visit(node *ast.Node) {
 	}
 }
 
+// Tracking must be reset before every walk over the AST tree
+func (p *OperatorOverloading) Reset() {
+	p.applied = false
+}
+
 func (p *OperatorOverloading) ShouldRepeat() bool {
 	return p.applied
 }
diff --git a/test/patch/patch_count_test.go b/test/patch/patch_count_test.go
new file mode 100644
index 000000000..e877de4a2
--- /dev/null
+++ b/test/patch/patch_count_test.go
@@ -0,0 +1,61 @@
+package patch_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr/internal/testify/require"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/test/mock"
+)
+
+// This patcher tracks how many nodes it patches which can 
+// be used to verify if it was run too many times or not at all
+type countingPatcher struct {
+	PatchCount int
+}
+
+func (c *countingPatcher) Visit(node *ast.Node) {
+	switch (*node).(type) {
+	case *ast.IntegerNode:
+		c.PatchCount++
+	}
+}
+
+// Test over a simple expression
+func TestPatch_Count(t *testing.T) {
+	patcher := countingPatcher{}
+
+	_, err := expr.Compile(
+		`5 + 5`,
+		expr.Env(mock.Env{}),
+		expr.Patch(&patcher),
+	)
+	require.NoError(t, err)
+
+	require.Equal(t, 2, patcher.PatchCount, "Patcher run an unexpected number of times during compile")
+}
+
+// Test with operator overloading
+func TestPatchOperator_Count(t *testing.T) {
+	patcher := countingPatcher{}
+
+	_, err := expr.Compile(
+		`5 + 5`,
+		expr.Env(mock.Env{}),
+		expr.Patch(&patcher),
+		expr.Operator("+", "_intAdd"),
+		expr.Function(
+			"_intAdd",
+			func(params ...any) (any, error) {
+				return params[0].(int) + params[1].(int), nil
+			},
+			new(func(int, int) int),
+		),
+	)
+
+	require.NoError(t, err)
+
+	require.Equal(t, 2, patcher.PatchCount, "Patcher run an unexpected number of times during compile")
+}

From 4544adfce5320ef71b5503982249357ac8310fcb Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 7 Mar 2025 15:56:31 +0100
Subject: [PATCH 374/506] Exclude pro from go coverage.mjs

---
 .github/scripts/coverage.mjs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs
index c00242894..1e15806bd 100755
--- a/.github/scripts/coverage.mjs
+++ b/.github/scripts/coverage.mjs
@@ -9,6 +9,7 @@ const exclude = [
   'internal/difflib',
   'internal/spew',
   'internal/testify',
+  'pro',
 ]
 
 cd(path.resolve(__dirname, '..', '..'))

From 156e73d03928799d932a465439a67a6379e94d05 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 7 Mar 2025 16:24:24 +0100
Subject: [PATCH 375/506] Add coverage.mjs comments

---
 .github/scripts/coverage.mjs | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs
index 1e15806bd..3bc381313 100755
--- a/.github/scripts/coverage.mjs
+++ b/.github/scripts/coverage.mjs
@@ -2,14 +2,15 @@
 
 const expected = 90
 const exclude = [
-  'expr/test',
-  'checker/mock',
-  'vm/func_types',
-  'vm/runtime/helpers',
-  'internal/difflib',
-  'internal/spew',
-  'internal/testify',
-  'pro',
+  'expr/test', // We do not need to test the test package.
+  'checker/mock', // Mocks only used for testing.
+  'vm/func_types', // Generated files.
+  'vm/runtime/helpers', // Generated files.
+  'internal/difflib', // Test dependency. This is vendored dependency, and ideally we also have good tests for it.
+  'internal/spew', // Test dependency.
+  'internal/testify', // Test dependency.
+  'patcher/value', // Contains a lot of repeating code. Ideally we should have a test for it.
+  'pro', // Expr Pro is not a part of the main codebase.
 ]
 
 cd(path.resolve(__dirname, '..', '..'))

From af32277333478cfafabf95dcf5a0ddf68d4a1d87 Mon Sep 17 00:00:00 2001
From: zhuliquan <zlqlovecode@foxmail.com>
Date: Fri, 7 Mar 2025 23:34:41 +0800
Subject: [PATCH 376/506] Fix print with precedence (#678)

* feat: extract code for compiling equal operator

* fix: fix unary and binary node print

consider the precedence of operators and their associative law when printing unary and binary nodes

---------

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 ast/print.go      | 25 +++++++++++++++++++++++--
 ast/print_test.go |  5 +++++
 2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/ast/print.go b/ast/print.go
index b79048b2c..0fd2fa58a 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -50,8 +50,13 @@ func (n *UnaryNode) String() string {
 		op = fmt.Sprintf("%s ", n.Operator)
 	}
 	wrap := false
-	switch n.Node.(type) {
-	case *BinaryNode, *ConditionalNode:
+	switch b := n.Node.(type) {
+	case *BinaryNode:
+		if operator.Binary[b.Operator].Precedence <
+			operator.Unary[n.Operator].Precedence {
+			wrap = true
+		}
+	case *ConditionalNode:
 		wrap = true
 	}
 	if wrap {
@@ -68,10 +73,21 @@ func (n *BinaryNode) String() string {
 	var lhs, rhs string
 	var lwrap, rwrap bool
 
+	if l, ok := n.Left.(*UnaryNode); ok {
+		if operator.Unary[l.Operator].Precedence <
+			operator.Binary[n.Operator].Precedence {
+			lwrap = true
+		}
+	}
 	if lb, ok := n.Left.(*BinaryNode); ok {
 		if operator.Less(lb.Operator, n.Operator) {
 			lwrap = true
 		}
+		if operator.Binary[lb.Operator].Precedence == 
+			operator.Binary[n.Operator].Precedence && 
+			operator.Binary[n.Operator].Associativity == operator.Right {
+			lwrap = true
+		}
 		if lb.Operator == "??" {
 			lwrap = true
 		}
@@ -83,6 +99,11 @@ func (n *BinaryNode) String() string {
 		if operator.Less(rb.Operator, n.Operator) {
 			rwrap = true
 		}
+		if operator.Binary[rb.Operator].Precedence == 
+			operator.Binary[n.Operator].Precedence && 
+			operator.Binary[n.Operator].Associativity == operator.Left {
+			rwrap = true
+		}
 		if operator.IsBoolean(rb.Operator) && n.Operator != rb.Operator {
 			rwrap = true
 		}
diff --git a/ast/print_test.go b/ast/print_test.go
index a4b20b0a1..8f950e276 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -78,6 +78,11 @@ func TestPrint(t *testing.T) {
 		{`{("a" + "b"): 42}`, `{("a" + "b"): 42}`},
 		{`(One == 1 ? true : false) && Two == 2`, `(One == 1 ? true : false) && Two == 2`},
 		{`not (a == 1 ? b > 1 : b < 2)`, `not (a == 1 ? b > 1 : b < 2)`},
+		{`(-(1+1)) ** 2`, `(-(1 + 1)) ** 2`},
+		{`2 ** (-(1+1))`, `2 ** -(1 + 1)`},
+		{`(2 ** 2) ** 3`, `(2 ** 2) ** 3`},
+		{`(3 + 5) / (5 % 3)`, `(3 + 5) / (5 % 3)`},
+		{`(-(1+1)) == 2`, `-(1 + 1) == 2`},
 	}
 
 	for _, tt := range tests {

From 9dc8bb93cc9032381661d74fce640912416b0d4c Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Fri, 7 Mar 2025 17:42:00 +0200
Subject: [PATCH 377/506] refactor(conf): avoid type assertion in map case
 branch (#749)

Simplifies the code by using the type switch variable binding instead of
performing an additional type assertion.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 conf/env.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/conf/env.go b/conf/env.go
index 494bb5b74..99e2f4626 100644
--- a/conf/env.go
+++ b/conf/env.go
@@ -46,9 +46,9 @@ func Env(env any) Nature {
 
 			face := elem.Interface()
 
-			switch face.(type) {
+			switch face := face.(type) {
 			case types.Map:
-				n.Fields[key.String()] = face.(types.Map).Nature()
+				n.Fields[key.String()] = face.Nature()
 
 			default:
 				if face == nil {

From 79b11706b9759282a07eb27bdb98eaa23c3fbbf1 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 7 Mar 2025 16:44:02 +0100
Subject: [PATCH 378/506] Add +build comments

---
 vm/debug.go      | 1 +
 vm/debug_off.go  | 1 +
 vm/debug_test.go | 1 +
 3 files changed, 3 insertions(+)

diff --git a/vm/debug.go b/vm/debug.go
index ab95bf9a0..470bf90e2 100644
--- a/vm/debug.go
+++ b/vm/debug.go
@@ -1,4 +1,5 @@
 //go:build expr_debug
+// +build expr_debug
 
 package vm
 
diff --git a/vm/debug_off.go b/vm/debug_off.go
index e0f2955a1..8a9e965e2 100644
--- a/vm/debug_off.go
+++ b/vm/debug_off.go
@@ -1,4 +1,5 @@
 //go:build !expr_debug
+// +build !expr_debug
 
 package vm
 
diff --git a/vm/debug_test.go b/vm/debug_test.go
index 7360e5833..ca7a28d89 100644
--- a/vm/debug_test.go
+++ b/vm/debug_test.go
@@ -1,4 +1,5 @@
 //go:build expr_debug
+// +build expr_debug
 
 package vm_test
 

From e8bd7f8689348614b47d71af8a8aef709d2fe8c7 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 7 Mar 2025 16:58:35 +0100
Subject: [PATCH 379/506] Make len() return runes count for string

Fixes #746
---
 builtin/lib.go |  5 ++++-
 expr_test.go   | 12 ++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/builtin/lib.go b/builtin/lib.go
index 13c7d207e..07e631e07 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -5,6 +5,7 @@ import (
 	"math"
 	"reflect"
 	"strconv"
+	"unicode/utf8"
 
 	"github.com/expr-lang/expr/internal/deref"
 )
@@ -12,8 +13,10 @@ import (
 func Len(x any) any {
 	v := reflect.ValueOf(x)
 	switch v.Kind() {
-	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
+	case reflect.Array, reflect.Slice, reflect.Map:
 		return v.Len()
+	case reflect.String:
+		return utf8.RuneCountInString(v.String())
 	default:
 		panic(fmt.Sprintf("invalid argument for len (type %T)", x))
 	}
diff --git a/expr_test.go b/expr_test.go
index f10350b22..bebe23a30 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -871,6 +871,18 @@ func TestExpr(t *testing.T) {
 			`len("hello, world")`,
 			12,
 		},
+		{
+			`len('北京')`,
+			2,
+		},
+		{
+			`len('👍🏻')`, // one grapheme cluster, two code points
+			2,
+		},
+		{
+			`len('👍')`, // one grapheme cluster, one code point
+			1,
+		},
 		{
 			`len(ArrayOfInt)`,
 			5,

From 35bdb68a944c8e8306ba8ac4db97e8400b3fe51a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 7 Mar 2025 20:39:53 +0100
Subject: [PATCH 380/506] Do not optimize filter_map if #index used

Fixes #758
---
 expr_test.go                 | 21 ++++++++++
 optimizer/filter_map.go      | 10 ++++-
 optimizer/filter_map_test.go | 74 ++++++++++++++++++++++++++++++++++++
 optimizer/optimizer_test.go  | 31 ---------------
 4 files changed, 104 insertions(+), 32 deletions(-)
 create mode 100644 optimizer/filter_map_test.go

diff --git a/expr_test.go b/expr_test.go
index bebe23a30..d1a93cd0c 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2763,3 +2763,24 @@ func TestExpr_env_types_map_error(t *testing.T) {
 	_, err = expr.Run(program, envTypes)
 	require.Error(t, err)
 }
+
+func TestIssue758_FilterMapIndex(t *testing.T) {
+	env := map[string]interface{}{}
+
+	exprStr := `
+        let a_map = 0..5 | filter(# % 2 == 0) | map(#index);
+        let b_filter = 0..5 | filter(# % 2 == 0);
+        let b_map = b_filter | map(#index);
+        [a_map, b_map]
+    `
+
+	result, err := expr.Eval(exprStr, env)
+	require.NoError(t, err)
+
+	expected := []interface{}{
+		[]interface{}{0, 1, 2},
+		[]interface{}{0, 1, 2},
+	}
+
+	require.Equal(t, expected, result)
+}
diff --git a/optimizer/filter_map.go b/optimizer/filter_map.go
index c6de6c73e..17659a914 100644
--- a/optimizer/filter_map.go
+++ b/optimizer/filter_map.go
@@ -9,7 +9,8 @@ type filterMap struct{}
 func (*filterMap) Visit(node *Node) {
 	if mapBuiltin, ok := (*node).(*BuiltinNode); ok &&
 		mapBuiltin.Name == "map" &&
-		len(mapBuiltin.Arguments) == 2 {
+		len(mapBuiltin.Arguments) == 2 &&
+		Find(mapBuiltin.Arguments[1], isIndexPointer) == nil {
 		if predicate, ok := mapBuiltin.Arguments[1].(*PredicateNode); ok {
 			if filter, ok := mapBuiltin.Arguments[0].(*BuiltinNode); ok &&
 				filter.Name == "filter" &&
@@ -23,3 +24,10 @@ func (*filterMap) Visit(node *Node) {
 		}
 	}
 }
+
+func isIndexPointer(node Node) bool {
+	if pointer, ok := node.(*PointerNode); ok && pointer.Name == "index" {
+		return true
+	}
+	return false
+}
diff --git a/optimizer/filter_map_test.go b/optimizer/filter_map_test.go
new file mode 100644
index 000000000..d6d423f4e
--- /dev/null
+++ b/optimizer/filter_map_test.go
@@ -0,0 +1,74 @@
+package optimizer_test
+
+import (
+	"testing"
+
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
+)
+
+func TestOptimize_filter_map(t *testing.T) {
+	tree, err := parser.Parse(`map(filter(users, .Name == "Bob"), .Age)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &BuiltinNode{
+		Name: "filter",
+		Arguments: []Node{
+			&IdentifierNode{Value: "users"},
+			&PredicateNode{
+				Node: &BinaryNode{
+					Operator: "==",
+					Left: &MemberNode{
+						Node:     &PointerNode{},
+						Property: &StringNode{Value: "Name"},
+					},
+					Right: &StringNode{Value: "Bob"},
+				},
+			},
+		},
+		Map: &MemberNode{
+			Node:     &PointerNode{},
+			Property: &StringNode{Value: "Age"},
+		},
+	}
+
+	assert.Equal(t, Dump(expected), Dump(tree.Node))
+}
+
+func TestOptimize_filter_map_with_index_pointer(t *testing.T) {
+	tree, err := parser.Parse(`map(filter(users, true), #index)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &BuiltinNode{
+		Name: "map",
+		Arguments: []Node{
+			&BuiltinNode{
+				Name: "filter",
+				Arguments: []Node{
+					&IdentifierNode{Value: "users"},
+					&PredicateNode{
+						Node: &BoolNode{Value: true},
+					},
+				},
+				Throws: false,
+				Map:    nil,
+			},
+			&PredicateNode{
+				Node: &PointerNode{Name: "index"},
+			},
+		},
+		Throws: false,
+		Map:    nil,
+	}
+
+	assert.Equal(t, Dump(expected), Dump(tree.Node))
+}
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 7830c0e78..03458689f 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -312,37 +312,6 @@ func TestOptimize_filter_last(t *testing.T) {
 	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
 }
 
-func TestOptimize_filter_map(t *testing.T) {
-	tree, err := parser.Parse(`map(filter(users, .Name == "Bob"), .Age)`)
-	require.NoError(t, err)
-
-	err = optimizer.Optimize(&tree.Node, nil)
-	require.NoError(t, err)
-
-	expected := &ast.BuiltinNode{
-		Name: "filter",
-		Arguments: []ast.Node{
-			&ast.IdentifierNode{Value: "users"},
-			&ast.PredicateNode{
-				Node: &ast.BinaryNode{
-					Operator: "==",
-					Left: &ast.MemberNode{
-						Node:     &ast.PointerNode{},
-						Property: &ast.StringNode{Value: "Name"},
-					},
-					Right: &ast.StringNode{Value: "Bob"},
-				},
-			},
-		},
-		Map: &ast.MemberNode{
-			Node:     &ast.PointerNode{},
-			Property: &ast.StringNode{Value: "Age"},
-		},
-	}
-
-	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
-}
-
 func TestOptimize_filter_map_first(t *testing.T) {
 	tree, err := parser.Parse(`first(map(filter(users, .Name == "Bob"), .Age))`)
 	require.NoError(t, err)

From 579de74b421df8d8231f3ed09beb84279bbed3ce Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 7 Mar 2025 20:40:02 +0100
Subject: [PATCH 381/506] Add ast.Find

---
 ast/find.go      | 18 ++++++++++++++++++
 ast/find_test.go | 31 +++++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 ast/find.go
 create mode 100644 ast/find_test.go

diff --git a/ast/find.go b/ast/find.go
new file mode 100644
index 000000000..247ff6c00
--- /dev/null
+++ b/ast/find.go
@@ -0,0 +1,18 @@
+package ast
+
+func Find(node Node, fn func(node Node) bool) Node {
+	v := &finder{fn: fn}
+	Walk(&node, v)
+	return v.node
+}
+
+type finder struct {
+	node Node
+	fn   func(node Node) bool
+}
+
+func (f *finder) Visit(node *Node) {
+	if f.fn(*node) {
+		f.node = *node
+	}
+}
diff --git a/ast/find_test.go b/ast/find_test.go
new file mode 100644
index 000000000..e4894c48f
--- /dev/null
+++ b/ast/find_test.go
@@ -0,0 +1,31 @@
+package ast_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr/internal/testify/require"
+
+	"github.com/expr-lang/expr/ast"
+)
+
+func TestFind(t *testing.T) {
+	left := &ast.IdentifierNode{
+		Value: "a",
+	}
+	var root ast.Node = &ast.BinaryNode{
+		Operator: "+",
+		Left:     left,
+		Right: &ast.IdentifierNode{
+			Value: "b",
+		},
+	}
+
+	x := ast.Find(root, func(node ast.Node) bool {
+		if n, ok := node.(*ast.IdentifierNode); ok {
+			return n.Value == "a"
+		}
+		return false
+	})
+
+	require.Equal(t, left, x)
+}

From 8f1e8804a632cbad0e5c5f8458875d10532d0ba4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 7 Mar 2025 21:52:14 +0100
Subject: [PATCH 382/506] Add more tests for filter_map optimization

---
 expr_test.go                 |  2 +-
 optimizer/filter_map_test.go | 40 ++++++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/expr_test.go b/expr_test.go
index d1a93cd0c..446fc6a71 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2764,7 +2764,7 @@ func TestExpr_env_types_map_error(t *testing.T) {
 	require.Error(t, err)
 }
 
-func TestIssue758_FilterMapIndex(t *testing.T) {
+func TestIssue758_filter_map_index(t *testing.T) {
 	env := map[string]interface{}{}
 
 	exprStr := `
diff --git a/optimizer/filter_map_test.go b/optimizer/filter_map_test.go
index d6d423f4e..b45fbdead 100644
--- a/optimizer/filter_map_test.go
+++ b/optimizer/filter_map_test.go
@@ -72,3 +72,43 @@ func TestOptimize_filter_map_with_index_pointer(t *testing.T) {
 
 	assert.Equal(t, Dump(expected), Dump(tree.Node))
 }
+
+func TestOptimize_filter_map_with_index_pointer_with_index_pointer_in_first_argument(t *testing.T) {
+	tree, err := parser.Parse(`1..2 | map(map(filter([#index], true), 42))`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &BuiltinNode{
+		Name: "map",
+		Arguments: []Node{
+			&BinaryNode{
+				Operator: "..",
+				Left:     &IntegerNode{Value: 1},
+				Right:    &IntegerNode{Value: 2},
+			},
+			&PredicateNode{
+				Node: &BuiltinNode{
+					Name: "filter",
+					Arguments: []Node{
+						&ArrayNode{
+							Nodes: []Node{
+								&PointerNode{Name: "index"},
+							},
+						},
+						&PredicateNode{
+							Node: &BoolNode{Value: true},
+						},
+					},
+					Throws: false,
+					Map:    &IntegerNode{Value: 42},
+				},
+			},
+		},
+		Throws: false,
+		Map:    nil,
+	}
+
+	assert.Equal(t, Dump(expected), Dump(tree.Node))
+}

From 8bb9ab77182b96698fd1e6dc46ee2611ac055fc5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 7 Mar 2025 22:56:41 +0100
Subject: [PATCH 383/506] Properly check if interface is any

Fixes #744
---
 checker/checker.go                            |  8 ++++
 checker/checker_test.go                       |  2 +-
 checker/nature/nature.go                      |  9 ++++-
 checker/nature/utils.go                       |  4 ++
 checker/types.go                              |  6 ++-
 .../interface_method_test.go                  |  2 +-
 test/interface/interface_test.go              | 40 +++++++++++++++++++
 7 files changed, 67 insertions(+), 4 deletions(-)
 rename test/{interface_method => interface}/interface_method_test.go (96%)
 create mode 100644 test/interface/interface_test.go

diff --git a/checker/checker.go b/checker/checker.go
index e71f1d7e0..0d316c0d7 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -535,6 +535,14 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature {
 		}
 	}
 
+	// Not found.
+
+	if name, ok := node.Property.(*ast.StringNode); ok {
+		if node.Method {
+			return v.error(node, "type %v has no method %v", base, name.Value)
+		}
+		return v.error(node, "type %v has no field %v", base, name.Value)
+	}
 	return v.error(node, "type %v[%v] is undefined", base, prop)
 }
 
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 17ec886e4..89f8e10b8 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -1055,7 +1055,7 @@ func TestCheck_builtin_without_call(t *testing.T) {
 		err   string
 	}{
 		{`len + 1`, "invalid operation: + (mismatched types func(...interface {}) (interface {}, error) and int) (1:5)\n | len + 1\n | ....^"},
-		{`string.A`, "type func(interface {}) string[string] is undefined (1:8)\n | string.A\n | .......^"},
+		{`string.A`, "type func(interface {}) string has no field A (1:8)\n | string.A\n | .......^"},
 	}
 
 	for _, test := range tests {
diff --git a/checker/nature/nature.go b/checker/nature/nature.go
index 2b09353b5..01f8b9e49 100644
--- a/checker/nature/nature.go
+++ b/checker/nature/nature.go
@@ -74,7 +74,7 @@ func (n Nature) Elem() Nature {
 func (n Nature) AssignableTo(nt Nature) bool {
 	if n.Nil {
 		// Untyped nil is assignable to any interface, but implements only the empty interface.
-		if nt.Type != nil && nt.Type.Kind() == reflect.Interface {
+		if isAny(nt) {
 			return true
 		}
 	}
@@ -84,6 +84,13 @@ func (n Nature) AssignableTo(nt Nature) bool {
 	return n.Type.AssignableTo(nt.Type)
 }
 
+func (n Nature) NumMethods() int {
+	if n.Type == nil {
+		return 0
+	}
+	return n.Type.NumMethod()
+}
+
 func (n Nature) MethodByName(name string) (Nature, bool) {
 	if n.Type == nil {
 		return unknown, false
diff --git a/checker/nature/utils.go b/checker/nature/utils.go
index c242f91a6..8d07ce48c 100644
--- a/checker/nature/utils.go
+++ b/checker/nature/utils.go
@@ -6,6 +6,10 @@ import (
 	"github.com/expr-lang/expr/internal/deref"
 )
 
+func isAny(nt Nature) bool {
+	return nt.Kind() == reflect.Interface && nt.NumMethods() == 0
+}
+
 func fieldName(field reflect.StructField) string {
 	if taggedName := field.Tag.Get("expr"); taggedName != "" {
 		return taggedName
diff --git a/checker/types.go b/checker/types.go
index ef93cf03d..2fd5cf80e 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -74,12 +74,16 @@ func isUnknown(nt Nature) bool {
 	switch {
 	case nt.Type == nil && !nt.Nil:
 		return true
-	case nt.Kind() == reflect.Interface:
+	case isAny(nt):
 		return true
 	}
 	return false
 }
 
+func isAny(nt Nature) bool {
+	return nt.Kind() == reflect.Interface && nt.NumMethods() == 0
+}
+
 func isInteger(nt Nature) bool {
 	switch nt.Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
diff --git a/test/interface_method/interface_method_test.go b/test/interface/interface_method_test.go
similarity index 96%
rename from test/interface_method/interface_method_test.go
rename to test/interface/interface_method_test.go
index 716b390e7..a27215035 100644
--- a/test/interface_method/interface_method_test.go
+++ b/test/interface/interface_method_test.go
@@ -1,4 +1,4 @@
-package interface_method_test
+package interface_test
 
 import (
 	"testing"
diff --git a/test/interface/interface_test.go b/test/interface/interface_test.go
new file mode 100644
index 000000000..45ce1c427
--- /dev/null
+++ b/test/interface/interface_test.go
@@ -0,0 +1,40 @@
+package interface_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/assert"
+)
+
+type StoreInterface interface {
+	Get(string) int
+}
+
+type StoreImpt struct{}
+
+func (f StoreImpt) Get(s string) int {
+	return 42
+}
+
+func (f StoreImpt) Set(s string, i int) bool {
+	return true
+}
+
+type Env struct {
+	Store StoreInterface `expr:"store"`
+}
+
+func TestInterfaceHide(t *testing.T) {
+	var env Env
+	p, err := expr.Compile(`store.Get("foo")`, expr.Env(env))
+	assert.NoError(t, err)
+
+	out, err := expr.Run(p, Env{Store: StoreImpt{}})
+	assert.NoError(t, err)
+	assert.Equal(t, 42, out)
+
+	_, err = expr.Compile(`store.Set("foo", 100)`, expr.Env(env))
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "type interface_test.StoreInterface has no method Set")
+}

From e750878fa17c0d496210576b1801dc666498890e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 09:27:09 +0100
Subject: [PATCH 384/506] Add SequenceNode

Fixes #717
---
 ast/node.go           |  7 +++++++
 ast/print.go          | 16 +++++++++++----
 ast/visitor.go        |  4 ++++
 parser/parser.go      | 37 +++++++++++++++++++++++++--------
 parser/parser_test.go | 48 +++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 99 insertions(+), 13 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index 6d98090b8..02923ac52 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -216,6 +216,13 @@ type VariableDeclaratorNode struct {
 	Expr  Node   // Expression of the variable. Like "foo + 1" in "let foo = 1; foo + 1".
 }
 
+// SequenceNode represents a sequence of nodes separated by semicolons.
+// All nodes are executed, only the last node will be returned.
+type SequenceNode struct {
+	base
+	Nodes []Node
+}
+
 // ArrayNode represents an array.
 type ArrayNode struct {
 	base
diff --git a/ast/print.go b/ast/print.go
index 0fd2fa58a..e4e45f0fa 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -83,8 +83,8 @@ func (n *BinaryNode) String() string {
 		if operator.Less(lb.Operator, n.Operator) {
 			lwrap = true
 		}
-		if operator.Binary[lb.Operator].Precedence == 
-			operator.Binary[n.Operator].Precedence && 
+		if operator.Binary[lb.Operator].Precedence ==
+			operator.Binary[n.Operator].Precedence &&
 			operator.Binary[n.Operator].Associativity == operator.Right {
 			lwrap = true
 		}
@@ -99,8 +99,8 @@ func (n *BinaryNode) String() string {
 		if operator.Less(rb.Operator, n.Operator) {
 			rwrap = true
 		}
-		if operator.Binary[rb.Operator].Precedence == 
-			operator.Binary[n.Operator].Precedence && 
+		if operator.Binary[rb.Operator].Precedence ==
+			operator.Binary[n.Operator].Precedence &&
 			operator.Binary[n.Operator].Associativity == operator.Left {
 			rwrap = true
 		}
@@ -198,6 +198,14 @@ func (n *VariableDeclaratorNode) String() string {
 	return fmt.Sprintf("let %s = %s; %s", n.Name, n.Value.String(), n.Expr.String())
 }
 
+func (n *SequenceNode) String() string {
+	nodes := make([]string, len(n.Nodes))
+	for i, node := range n.Nodes {
+		nodes[i] = node.String()
+	}
+	return strings.Join(nodes, "; ")
+}
+
 func (n *ConditionalNode) String() string {
 	var cond, exp1, exp2 string
 	if _, ok := n.Cond.(*ConditionalNode); ok {
diff --git a/ast/visitor.go b/ast/visitor.go
index 03d72d11d..72cd6366b 100644
--- a/ast/visitor.go
+++ b/ast/visitor.go
@@ -51,6 +51,10 @@ func Walk(node *Node, v Visitor) {
 	case *VariableDeclaratorNode:
 		Walk(&n.Value, v)
 		Walk(&n.Expr, v)
+	case *SequenceNode:
+		for i := range n.Nodes {
+			Walk(&n.Nodes[i], v)
+		}
 	case *ConditionalNode:
 		Walk(&n.Cond, v)
 		Walk(&n.Exp1, v)
diff --git a/parser/parser.go b/parser/parser.go
index 086554223..060d76046 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -49,12 +49,11 @@ type parser struct {
 	current   Token
 	pos       int
 	err       *file.Error
-	depth     int // predicate call depth
 	config    *conf.Config
+	depth     int  // predicate call depth
 	nodeCount uint // tracks number of AST nodes created
 }
 
-// checkNodeLimit verifies that adding a new node won't exceed configured limits
 func (p *parser) checkNodeLimit() error {
 	p.nodeCount++
 	if p.config.MaxNodes > 0 && p.nodeCount > p.config.MaxNodes {
@@ -64,7 +63,6 @@ func (p *parser) checkNodeLimit() error {
 	return nil
 }
 
-// createNode handles creation of regular nodes
 func (p *parser) createNode(n Node, loc file.Location) Node {
 	if err := p.checkNodeLimit(); err != nil {
 		return nil
@@ -76,7 +74,6 @@ func (p *parser) createNode(n Node, loc file.Location) Node {
 	return n
 }
 
-// createMemberNode handles creation of member nodes
 func (p *parser) createMemberNode(n *MemberNode, loc file.Location) *MemberNode {
 	if err := p.checkNodeLimit(); err != nil {
 		return nil
@@ -163,6 +160,27 @@ func (p *parser) expect(kind Kind, values ...string) {
 
 // parse functions
 
+func (p *parser) parseSequenceExpression() Node {
+	nodes := []Node{p.parseExpression(0)}
+
+	for p.current.Is(Operator, ";") && p.err == nil {
+		p.next()
+		// If a trailing semicolon is present, break out.
+		if p.current.Is(EOF) {
+			break
+		}
+		nodes = append(nodes, p.parseExpression(0))
+	}
+
+	if len(nodes) == 1 {
+		return nodes[0]
+	}
+
+	return p.createNode(&SequenceNode{
+		Nodes: nodes,
+	}, nodes[0].Location())
+}
+
 func (p *parser) parseExpression(precedence int) Node {
 	if p.err != nil {
 		return nil
@@ -171,6 +189,7 @@ func (p *parser) parseExpression(precedence int) Node {
 	if precedence == 0 && p.current.Is(Operator, "let") {
 		return p.parseVariableDeclaration()
 	}
+
 	if p.current.Is(Operator, "if") {
 		return p.parseConditionalIf()
 	}
@@ -283,11 +302,11 @@ func (p *parser) parseConditionalIf() Node {
 	p.next()
 	nodeCondition := p.parseExpression(0)
 	p.expect(Bracket, "{")
-	expr1 := p.parseExpression(0)
+	expr1 := p.parseSequenceExpression()
 	p.expect(Bracket, "}")
 	p.expect(Operator, "else")
 	p.expect(Bracket, "{")
-	expr2 := p.parseExpression(0)
+	expr2 := p.parseSequenceExpression()
 	p.expect(Bracket, "}")
 
 	return &ConditionalNode{
@@ -304,13 +323,13 @@ func (p *parser) parseConditional(node Node) Node {
 		p.next()
 
 		if !p.current.Is(Operator, ":") {
-			expr1 = p.parseExpression(0)
+			expr1 = p.parseSequenceExpression()
 			p.expect(Operator, ":")
-			expr2 = p.parseExpression(0)
+			expr2 = p.parseSequenceExpression()
 		} else {
 			p.next()
 			expr1 = node
-			expr2 = p.parseExpression(0)
+			expr2 = p.parseSequenceExpression()
 		}
 
 		node = p.createNode(&ConditionalNode{
diff --git a/parser/parser_test.go b/parser/parser_test.go
index efae1f413..b1af5d0c1 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -659,6 +659,54 @@ world`},
 				Exp1: &BoolNode{Value: true},
 				Exp2: &IdentifierNode{Value: "x"}},
 		},
+		{
+			"true ? 1; 2; 3 : 4",
+			&ConditionalNode{
+				Cond: &BoolNode{Value: true},
+				Exp1: &SequenceNode{
+					Nodes: []Node{
+						&IntegerNode{Value: 1},
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3}}},
+				Exp2: &IntegerNode{Value: 4}},
+		},
+		{
+			"true ? 1 : 2; 3 ; 4",
+			&ConditionalNode{
+				Cond: &BoolNode{Value: true},
+				Exp1: &IntegerNode{Value: 1},
+				Exp2: &SequenceNode{
+					Nodes: []Node{
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3},
+						&IntegerNode{Value: 4}}}},
+		},
+		{
+			"true ?: 1; 2; 3",
+			&ConditionalNode{
+				Cond: &BoolNode{Value: true},
+				Exp1: &BoolNode{Value: true},
+				Exp2: &SequenceNode{
+					Nodes: []Node{
+						&IntegerNode{Value: 1},
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3}}}},
+		},
+		{
+			"if true { 1; 2; 3 } else { 4; 5; 6 }",
+			&ConditionalNode{
+				Cond: &BoolNode{Value: true},
+				Exp1: &SequenceNode{
+					Nodes: []Node{
+						&IntegerNode{Value: 1},
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3}}},
+				Exp2: &SequenceNode{
+					Nodes: []Node{
+						&IntegerNode{Value: 4},
+						&IntegerNode{Value: 5},
+						&IntegerNode{Value: 6}}}},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {

From bc0ce17d0e389098a783cbc024937aace912a166 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 09:49:28 +0100
Subject: [PATCH 385/506] Refactor TestParse_error tests

---
 parser/parser_test.go | 158 +++++++++++++++---------------------------
 1 file changed, 57 insertions(+), 101 deletions(-)

diff --git a/parser/parser_test.go b/parser/parser_test.go
index b1af5d0c1..39f6ad7b0 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -717,131 +717,87 @@ world`},
 	}
 }
 
-const errorTests = `
-foo.
-unexpected end of expression (1:4)
+func TestParse_error(t *testing.T) {
+	var tests = []struct {
+		input string
+		err   string
+	}{
+		{`foo.`, `unexpected end of expression (1:4)
  | foo.
- | ...^
-
-a+
-unexpected token EOF (1:2)
+ | ...^`},
+		{`a+`, `unexpected token EOF (1:2)
  | a+
- | .^
-
-a ? (1+2) c
-unexpected token Identifier("c") (1:11)
+ | .^`},
+		{`a ? (1+2) c`, `unexpected token Identifier("c") (1:11)
  | a ? (1+2) c
- | ..........^
-
-[a b]
-unexpected token Identifier("b") (1:4)
+ | ..........^`},
+		{`[a b]`, `unexpected token Identifier("b") (1:4)
  | [a b]
- | ...^
-
-foo.bar(a b)
-unexpected token Identifier("b") (1:11)
+ | ...^`},
+		{`foo.bar(a b)`, `unexpected token Identifier("b") (1:11)
  | foo.bar(a b)
- | ..........^
-
-{-}
-a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator("-")) (1:2)
+ | ..........^`},
+		{`{-}`, `a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator("-")) (1:2)
  | {-}
- | .^
-
-foo({.bar})
-a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(".")) (1:6)
+ | .^`},
+		{`foo({.bar})`, `a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(".")) (1:6)
  | foo({.bar})
- | .....^
-
-.foo
-cannot use pointer accessor outside predicate (1:1)
+ | .....^`},
+		{`.foo`, `cannot use pointer accessor outside predicate (1:1)
  | .foo
- | ^
-
-[1, 2, 3,,]
-unexpected token Operator(",") (1:10)
+ | ^`},
+		{`[1, 2, 3,,]`, `unexpected token Operator(",") (1:10)
  | [1, 2, 3,,]
- | .........^
-
-[,]
-unexpected token Operator(",") (1:2)
+ | .........^`},
+		{`[,]`, `unexpected token Operator(",") (1:2)
  | [,]
- | .^
-
-{,}
-a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(",")) (1:2)
+ | .^`},
+		{`{,}`, `a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(",")) (1:2)
  | {,}
- | .^
-
-{foo:1, bar:2, ,}
-unexpected token Operator(",") (1:16)
+ | .^`},
+		{`{foo:1, bar:2, ,}`, `unexpected token Operator(",") (1:16)
  | {foo:1, bar:2, ,}
- | ...............^
-
-foo ?? bar || baz
-Operator (||) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses. (1:12)
+ | ...............^`},
+		{`foo ?? bar || baz`, `Operator (||) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses. (1:12)
  | foo ?? bar || baz
- | ...........^
-
-0b15
-bad number syntax: "0b15" (1:4)
+ | ...........^`},
+		{`0b15`, `bad number syntax: "0b15" (1:4)
  | 0b15
- | ...^
-
-0X10G
-bad number syntax: "0X10G" (1:5)
+ | ...^`},
+		{`0X10G`, `bad number syntax: "0X10G" (1:5)
  | 0X10G
- | ....^
-
-0o1E
-invalid float literal: strconv.ParseFloat: parsing "0o1E": invalid syntax (1:4)
+ | ....^`},
+		{`0o1E`, `invalid float literal: strconv.ParseFloat: parsing "0o1E": invalid syntax (1:4)
  | 0o1E
- | ...^
-
-0b1E
-invalid float literal: strconv.ParseFloat: parsing "0b1E": invalid syntax (1:4)
+ | ...^`},
+		{`0b1E`, `invalid float literal: strconv.ParseFloat: parsing "0b1E": invalid syntax (1:4)
  | 0b1E
- | ...^
-
-0b1E+6
-bad number syntax: "0b1E+6" (1:6)
+ | ...^`},
+		{`0b1E+6`, `bad number syntax: "0b1E+6" (1:6)
  | 0b1E+6
- | .....^
-
-0b1E+1
-invalid float literal: strconv.ParseFloat: parsing "0b1E+1": invalid syntax (1:6)
+ | .....^`},
+		{`0b1E+1`, `invalid float literal: strconv.ParseFloat: parsing "0b1E+1": invalid syntax (1:6)
  | 0b1E+1
- | .....^
-
-0o1E+1
-invalid float literal: strconv.ParseFloat: parsing "0o1E+1": invalid syntax (1:6)
+ | .....^`},
+		{`0o1E+1`, `invalid float literal: strconv.ParseFloat: parsing "0o1E+1": invalid syntax (1:6)
  | 0o1E+1
- | .....^
-
-1E
-invalid float literal: strconv.ParseFloat: parsing "1E": invalid syntax (1:2)
+ | .....^`},
+		{`1E`, `invalid float literal: strconv.ParseFloat: parsing "1E": invalid syntax (1:2)
  | 1E
- | .^
-
-1 not == [1, 2, 5]
-unexpected token Operator("==") (1:7)
+ | .^`},
+		{`1 not == [1, 2, 5]`, `unexpected token Operator("==") (1:7)
  | 1 not == [1, 2, 5]
- | ......^
-`
+ | ......^`},
+	}
 
-func TestParse_error(t *testing.T) {
-	tests := strings.Split(strings.Trim(errorTests, "\n"), "\n\n")
 	for _, test := range tests {
-		input := strings.SplitN(test, "\n", 2)
-		if len(input) != 2 {
-			t.Errorf("syntax error in test: %q", test)
-			break
-		}
-		_, err := parser.Parse(input[0])
-		if err == nil {
-			err = fmt.Errorf("<nil>")
-		}
-		assert.Equal(t, input[1], err.Error(), input[0])
+		t.Run(test.input, func(t *testing.T) {
+			_, err := parser.Parse(test.input)
+			if err == nil {
+				err = fmt.Errorf("<nil>")
+			}
+			assert.Equal(t, test.err, err.Error(), test.input)
+		})
 	}
 }
 

From c9f620ee4840b2fce467942b13b1b7fe9e8f8d69 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 12:02:09 +0100
Subject: [PATCH 386/506] Only allow if on precedence == 0

---
 parser/parser.go      |  21 +++---
 parser/parser_test.go | 153 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 166 insertions(+), 8 deletions(-)

diff --git a/parser/parser.go b/parser/parser.go
index 060d76046..3761919d6 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -110,7 +110,7 @@ func ParseWithConfig(input string, config *conf.Config) (*Tree, error) {
 		config:  config,
 	}
 
-	node := p.parseExpression(0)
+	node := p.parseSequenceExpression()
 
 	if !p.current.Is(EOF) {
 		p.error("unexpected token %v", p.current)
@@ -190,7 +190,7 @@ func (p *parser) parseExpression(precedence int) Node {
 		return p.parseVariableDeclaration()
 	}
 
-	if p.current.Is(Operator, "if") {
+	if precedence == 0 && p.current.Is(Operator, "if") {
 		return p.parseConditionalIf()
 	}
 
@@ -290,7 +290,7 @@ func (p *parser) parseVariableDeclaration() Node {
 	p.expect(Operator, "=")
 	value := p.parseExpression(0)
 	p.expect(Operator, ";")
-	node := p.parseExpression(0)
+	node := p.parseSequenceExpression()
 	return p.createNode(&VariableDeclaratorNode{
 		Name:  variableName.Value,
 		Value: value,
@@ -364,7 +364,7 @@ func (p *parser) parsePrimary() Node {
 
 	if token.Is(Bracket, "(") {
 		p.next()
-		expr := p.parseExpression(0)
+		expr := p.parseSequenceExpression()
 		p.expect(Bracket, ")") // "an opened parenthesis is not properly closed"
 		return p.parsePostfixExpression(expr)
 	}
@@ -607,17 +607,22 @@ func (p *parser) parseArguments(arguments []Node) []Node {
 
 func (p *parser) parsePredicate() Node {
 	startToken := p.current
-	expectClosingBracket := false
+	withBrackets := false
 	if p.current.Is(Bracket, "{") {
 		p.next()
-		expectClosingBracket = true
+		withBrackets = true
 	}
 
 	p.depth++
-	node := p.parseExpression(0)
+	var node Node
+	if withBrackets {
+		node = p.parseSequenceExpression()
+	} else {
+		node = p.parseExpression(0)
+	}
 	p.depth--
 
-	if expectClosingBracket {
+	if withBrackets {
 		p.expect(Bracket, "}")
 	}
 	predicateNode := p.createNode(&PredicateNode{
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 39f6ad7b0..7fcceb3ec 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -659,6 +659,29 @@ world`},
 				Exp1: &BoolNode{Value: true},
 				Exp2: &IdentifierNode{Value: "x"}},
 		},
+		{
+			"1; 2; 3",
+			&SequenceNode{
+				Nodes: []Node{
+					&IntegerNode{Value: 1},
+					&IntegerNode{Value: 2},
+					&IntegerNode{Value: 3},
+				},
+			},
+		},
+		{
+			"1; (2; 3)",
+			&SequenceNode{
+				Nodes: []Node{
+					&IntegerNode{Value: 1},
+					&SequenceNode{
+						Nodes: []Node{
+							&IntegerNode{Value: 2},
+							&IntegerNode{Value: 3}},
+					},
+				},
+			},
+		},
 		{
 			"true ? 1; 2; 3 : 4",
 			&ConditionalNode{
@@ -707,6 +730,115 @@ world`},
 						&IntegerNode{Value: 5},
 						&IntegerNode{Value: 6}}}},
 		},
+		{
+			`all(ls, if true { 1 } else { 2 })`,
+			&BuiltinNode{
+				Name: "all",
+				Arguments: []Node{
+					&IdentifierNode{Value: "ls"},
+					&PredicateNode{
+						Node: &ConditionalNode{
+							Cond: &BoolNode{Value: true},
+							Exp1: &IntegerNode{Value: 1},
+							Exp2: &IntegerNode{Value: 2}}}}},
+		},
+		{
+			`let x = if true { 1 } else { 2 }; x`,
+			&VariableDeclaratorNode{
+				Name: "x",
+				Value: &ConditionalNode{
+					Cond: &BoolNode{Value: true},
+					Exp1: &IntegerNode{Value: 1},
+					Exp2: &IntegerNode{Value: 2}},
+				Expr: &IdentifierNode{Value: "x"}},
+		},
+		{
+			`call(if true { 1 } else { 2 })`,
+			&CallNode{
+				Callee: &IdentifierNode{Value: "call"},
+				Arguments: []Node{
+					&ConditionalNode{
+						Cond: &BoolNode{Value: true},
+						Exp1: &IntegerNode{Value: 1},
+						Exp2: &IntegerNode{Value: 2}}}},
+		},
+		{
+			`[if true { 1 } else { 2 }]`,
+			&ArrayNode{
+				Nodes: []Node{
+					&ConditionalNode{
+						Cond: &BoolNode{Value: true},
+						Exp1: &IntegerNode{Value: 1},
+						Exp2: &IntegerNode{Value: 2}}}},
+		},
+		{
+			`map(ls, { 1; 2; 3 })`,
+			&BuiltinNode{
+				Name: "map",
+				Arguments: []Node{
+					&IdentifierNode{Value: "ls"},
+					&PredicateNode{
+						Node: &SequenceNode{
+							Nodes: []Node{
+								&IntegerNode{Value: 1},
+								&IntegerNode{Value: 2},
+								&IntegerNode{Value: 3},
+							},
+						},
+					},
+				}},
+		},
+		{
+			`let x = 1; 2; 3 + x`,
+			&VariableDeclaratorNode{
+				Name:  "x",
+				Value: &IntegerNode{Value: 1},
+				Expr: &SequenceNode{
+					Nodes: []Node{
+						&IntegerNode{Value: 2},
+						&BinaryNode{
+							Operator: "+",
+							Left:     &IntegerNode{Value: 3},
+							Right:    &IdentifierNode{Value: "x"},
+						},
+					},
+				},
+			},
+		},
+		{
+			`let x = 1; let y = 2; 3; 4; x + y`,
+			&VariableDeclaratorNode{
+				Name:  "x",
+				Value: &IntegerNode{Value: 1},
+				Expr: &VariableDeclaratorNode{
+					Name:  "y",
+					Value: &IntegerNode{Value: 2},
+					Expr: &SequenceNode{
+						Nodes: []Node{
+							&IntegerNode{Value: 3},
+							&IntegerNode{Value: 4},
+							&BinaryNode{
+								Operator: "+",
+								Left:     &IdentifierNode{Value: "x"},
+								Right:    &IdentifierNode{Value: "y"},
+							},
+						},
+					}}},
+		},
+		{
+			`let x = (1; 2; 3); x`,
+			&VariableDeclaratorNode{
+				Name: "x",
+				Value: &SequenceNode{
+					Nodes: []Node{
+						&IntegerNode{Value: 1},
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3},
+					},
+				},
+				Expr: &IdentifierNode{Value: "x"},
+			},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
@@ -788,6 +920,27 @@ func TestParse_error(t *testing.T) {
 		{`1 not == [1, 2, 5]`, `unexpected token Operator("==") (1:7)
  | 1 not == [1, 2, 5]
  | ......^`},
+		{`foo(1; 2; 3)`, `unexpected token Operator(";") (1:6)
+ | foo(1; 2; 3)
+ | .....^`},
+		{
+			`map(ls, 1; 2; 3)`,
+			`unexpected token Operator(";") (1:10)
+ | map(ls, 1; 2; 3)
+ | .........^`,
+		},
+		{
+			`[1; 2; 3]`,
+			`unexpected token Operator(";") (1:3)
+ | [1; 2; 3]
+ | ..^`,
+		},
+		{
+			`1 + if true { 2 } else { 3 }`,
+			`unexpected token Operator("if") (1:5)
+ | 1 + if true { 2 } else { 3 }
+ | ....^`,
+		},
 	}
 
 	for _, test := range tests {

From fdba92bdadc2c10d017125bb518164717c89232f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 12:14:13 +0100
Subject: [PATCH 387/506] Better error message for predicate with sequence

---
 parser/parser.go      | 3 +++
 parser/parser_test.go | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/parser/parser.go b/parser/parser.go
index 3761919d6..febfb051a 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -619,6 +619,9 @@ func (p *parser) parsePredicate() Node {
 		node = p.parseSequenceExpression()
 	} else {
 		node = p.parseExpression(0)
+		if p.current.Is(Operator, ";") {
+			p.error("wrap predicate with brackets { and }")
+		}
 	}
 	p.depth--
 
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 7fcceb3ec..3a7bb461a 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -925,7 +925,7 @@ func TestParse_error(t *testing.T) {
  | .....^`},
 		{
 			`map(ls, 1; 2; 3)`,
-			`unexpected token Operator(";") (1:10)
+			`wrap predicate with brackets { and } (1:10)
  | map(ls, 1; 2; 3)
  | .........^`,
 		},

From 3df78d9f57e0f0f786647778b3d4d4b89d128a98 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 12:31:51 +0100
Subject: [PATCH 388/506] Add print test for if

---
 ast/print_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ast/print_test.go b/ast/print_test.go
index 8f950e276..d0859606f 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -83,6 +83,7 @@ func TestPrint(t *testing.T) {
 		{`(2 ** 2) ** 3`, `(2 ** 2) ** 3`},
 		{`(3 + 5) / (5 % 3)`, `(3 + 5) / (5 % 3)`},
 		{`(-(1+1)) == 2`, `-(1 + 1) == 2`},
+		{`if true { 1 } else { 2 }`, `true ? 1 : 2`},
 	}
 
 	for _, tt := range tests {

From 80767230400514bdde27226c923f13766280c9cd Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 12:36:18 +0100
Subject: [PATCH 389/506] Add SequenceNode to type checker

---
 checker/checker.go      | 13 +++++++++++++
 checker/checker_test.go |  8 ++++++++
 2 files changed, 21 insertions(+)

diff --git a/checker/checker.go b/checker/checker.go
index 0d316c0d7..66888e857 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -178,6 +178,8 @@ func (v *checker) visit(node ast.Node) Nature {
 		nt = v.PointerNode(n)
 	case *ast.VariableDeclaratorNode:
 		nt = v.VariableDeclaratorNode(n)
+	case *ast.SequenceNode:
+		nt = v.SequenceNode(n)
 	case *ast.ConditionalNode:
 		nt = v.ConditionalNode(n)
 	case *ast.ArrayNode:
@@ -1181,6 +1183,17 @@ func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Natur
 	return exprNature
 }
 
+func (v *checker) SequenceNode(node *ast.SequenceNode) Nature {
+	if len(node.Nodes) == 0 {
+		return v.error(node, "empty sequence expression")
+	}
+	var last Nature
+	for _, node := range node.Nodes {
+		last = v.visit(node)
+	}
+	return last
+}
+
 func (v *checker) lookupVariable(name string) (varScope, bool) {
 	for i := len(v.varScopes) - 1; i >= 0; i-- {
 		if v.varScopes[i].name == name {
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 89f8e10b8..4950c1a8e 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -669,6 +669,14 @@ invalid operation: == (mismatched types int and string) (1:33)
 invalid operation: > (mismatched types string and int) (1:30)
  | 1..3 | map("str") | filter(# > 1)
  | .............................^
+`,
+		},
+		{
+			`1; 2 + true; 3`,
+			`
+invalid operation: + (mismatched types int and bool) (1:6)
+ | 1; 2 + true; 3
+ | .....^
 `,
 		},
 	}

From 4ae7e34df82f82bc11f13a6893c340b79aa17e2e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 12:46:59 +0100
Subject: [PATCH 390/506] Add SequenceNode to compiler

---
 compiler/compiler.go      | 11 +++++++++++
 compiler/compiler_test.go | 18 ++++++++++++++++++
 expr_test.go              |  8 ++++++++
 3 files changed, 37 insertions(+)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 68eae5ea1..ca2750c18 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -266,6 +266,8 @@ func (c *compiler) compile(node ast.Node) {
 		c.PointerNode(n)
 	case *ast.VariableDeclaratorNode:
 		c.VariableDeclaratorNode(n)
+	case *ast.SequenceNode:
+		c.SequenceNode(n)
 	case *ast.ConditionalNode:
 		c.ConditionalNode(n)
 	case *ast.ArrayNode:
@@ -1142,6 +1144,15 @@ func (c *compiler) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) {
 	c.endScope()
 }
 
+func (c *compiler) SequenceNode(node *ast.SequenceNode) {
+	for i, n := range node.Nodes {
+		c.compile(n)
+		if i < len(node.Nodes)-1 {
+			c.emit(OpPop)
+		}
+	}
+}
+
 func (c *compiler) beginScope(name string, index int) {
 	c.scopes = append(c.scopes, scope{name, index})
 }
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index 526c5d67d..b683b82d6 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -377,6 +377,24 @@ func TestCompile(t *testing.T) {
 				Arguments: []int{0, 0, 1, 12},
 			},
 		},
+		{
+			`1; 2; 3`,
+			vm.Program{
+				Constants: []any{
+					1,
+					2,
+					3,
+				},
+				Bytecode: []vm.Opcode{
+					vm.OpPush,
+					vm.OpPop,
+					vm.OpPush,
+					vm.OpPop,
+					vm.OpPush,
+				},
+				Arguments: []int{0, 0, 1, 0, 2},
+			},
+		},
 	}
 
 	for _, test := range tests {
diff --git a/expr_test.go b/expr_test.go
index 446fc6a71..ff30b1224 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1318,6 +1318,14 @@ func TestExpr(t *testing.T) {
 			`if "a" < "b" {let x = "a"; x} else {"abc"}`,
 			"a",
 		},
+		{
+			`1; 2; 3`,
+			3,
+		},
+		{
+			`let a = 1; Add(2, 2); let b = 2; a + b`,
+			3,
+		},
 	}
 
 	for _, tt := range tests {

From e437d57d2051816200cb25732c9d0a6b38f9f7ac Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 13:49:10 +0100
Subject: [PATCH 391/506] Make TestVM_ProfileOperations more robust

---
 vm/vm_test.go | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/vm/vm_test.go b/vm/vm_test.go
index 615b0a442..91752a419 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -6,6 +6,7 @@ import (
 	"reflect"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/expr-lang/expr/internal/testify/require"
 
@@ -466,11 +467,16 @@ func TestVM_ProfileOperations(t *testing.T) {
 		Bytecode: []vm.Opcode{
 			vm.OpProfileStart,
 			vm.OpPush,
+			vm.OpCall,
 			vm.OpProfileEnd,
 		},
-		Arguments: []int{0, 0, 0},
+		Arguments: []int{0, 1, 0, 0},
 		Constants: []any{
 			&vm.Span{},
+			func() (any, error) {
+				time.Sleep(time.Millisecond * 10)
+				return nil, nil
+			},
 		},
 	}
 
@@ -479,7 +485,7 @@ func TestVM_ProfileOperations(t *testing.T) {
 	require.NoError(t, err)
 
 	span := program.Constants[0].(*vm.Span)
-	require.True(t, span.Duration > 0, "Profile duration should be greater than 0")
+	require.Greater(t, span.Duration, time.Millisecond)
 }
 
 // TestVM_IndexOperations tests the index manipulation opcodes

From d63c3b5a6c78b8186909edc00cff4bedb3dde5f5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 13:54:55 +0100
Subject: [PATCH 392/506] Fix func calls with nil types value

Fixes #688
---
 test/issues/688/issue_test.go | 52 +++++++++++++++++++++++++++++++++++
 vm/vm.go                      |  6 ++--
 2 files changed, 54 insertions(+), 4 deletions(-)
 create mode 100644 test/issues/688/issue_test.go

diff --git a/test/issues/688/issue_test.go b/test/issues/688/issue_test.go
new file mode 100644
index 000000000..837978c13
--- /dev/null
+++ b/test/issues/688/issue_test.go
@@ -0,0 +1,52 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+type Foo interface {
+	Add(a int, b *int) int
+}
+
+type FooImpl struct {
+}
+
+func (*FooImpl) Add(a int, b *int) int {
+	return 0
+}
+
+type Env struct {
+	Foo Foo `expr:"foo"`
+}
+
+func (Env) Any(x any) any {
+	return x
+}
+
+func TestNoInterfaceMethodWithNil(t *testing.T) {
+	program, err := expr.Compile(`foo.Add(1, nil)`)
+	require.NoError(t, err)
+
+	_, err = expr.Run(program, Env{Foo: &FooImpl{}})
+	require.NoError(t, err)
+}
+
+func TestNoInterfaceMethodWithNil_with_env(t *testing.T) {
+	program, err := expr.Compile(`foo.Add(1, nil)`, expr.Env(Env{}))
+	require.NoError(t, err)
+
+	_, err = expr.Run(program, Env{Foo: &FooImpl{}})
+	require.NoError(t, err)
+}
+
+func TestNoInterfaceMethodWithNil_with_any(t *testing.T) {
+	program, err := expr.Compile(`Any(nil)`, expr.Env(Env{}))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, Env{Foo: &FooImpl{}})
+	require.NoError(t, err)
+	require.Equal(t, nil, out)
+}
diff --git a/vm/vm.go b/vm/vm.go
index 5c40f26cd..fb1d772c1 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -334,10 +334,8 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			in := make([]reflect.Value, size)
 			for i := int(size) - 1; i >= 0; i-- {
 				param := vm.pop()
-				if param == nil && reflect.TypeOf(param) == nil {
-					// In case of nil value and nil type use this hack,
-					// otherwise reflect.Call will panic on zero value.
-					in[i] = reflect.ValueOf(&param).Elem()
+				if param == nil {
+					in[i] = reflect.Zero(fn.Type().In(i))
 				} else {
 					in[i] = reflect.ValueOf(param)
 				}

From 6fa83ad539f5c89d0f4bf95a42c28aca68397560 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 15:33:37 +0100
Subject: [PATCH 393/506] Improve type checker for named types

---
 builtin/builtin.go            |  2 +-
 builtin/builtin_test.go       | 13 +++++
 builtin/lib.go                |  2 +-
 checker/checker.go            | 22 ++++++++-
 checker/nature/nature.go      |  7 +++
 checker/types.go              | 24 ++++++---
 expr_test.go                  | 84 ++-----------------------------
 test/issues/461/issue_test.go | 93 +++++++++++++++++++++++++++++++++++
 test/issues/730/issue_test.go | 60 ++++++++++++++++++++++
 9 files changed, 215 insertions(+), 92 deletions(-)
 create mode 100644 test/issues/461/issue_test.go
 create mode 100644 test/issues/730/issue_test.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 35a9f687e..f4a14ce58 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -164,7 +164,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			switch kind(args[0]) {
+			switch kind(deref.Type(args[0])) {
 			case reflect.Interface:
 				return integerType, nil
 			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 499a838b7..6427c1aec 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -638,3 +638,16 @@ func Test_int_unwraps_underlying_value(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, true, out)
 }
+
+func TestBuiltin_int_with_deref(t *testing.T) {
+	x := 42
+	env := map[string]any{
+		"x": &x,
+	}
+	program, err := expr.Compile(`int(x)`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, 42, out)
+}
diff --git a/builtin/lib.go b/builtin/lib.go
index 07e631e07..34131dfc0 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -180,7 +180,7 @@ func Round(x any) any {
 }
 
 func Int(x any) any {
-	switch x := x.(type) {
+	switch x := deref.Deref(x).(type) {
 	case float32:
 		return int(x)
 	case float64:
diff --git a/checker/checker.go b/checker/checker.go
index 66888e857..b04d3f135 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -319,7 +319,10 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature {
 		if isTime(l) && isTime(r) {
 			return boolNature
 		}
-		if or(l, r, isNumber, isString, isTime) {
+		if isDuration(l) && isDuration(r) {
+			return boolNature
+		}
+		if or(l, r, isNumber, isString, isTime, isDuration) {
 			return boolNature
 		}
 
@@ -333,6 +336,9 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature {
 		if isTime(l) && isDuration(r) {
 			return timeNature
 		}
+		if isDuration(l) && isDuration(r) {
+			return durationNature
+		}
 		if or(l, r, isNumber, isTime, isDuration) {
 			return unknown
 		}
@@ -341,7 +347,16 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature {
 		if isNumber(l) && isNumber(r) {
 			return combined(l, r)
 		}
-		if or(l, r, isNumber) {
+		if isNumber(l) && isDuration(r) {
+			return durationNature
+		}
+		if isDuration(l) && isNumber(r) {
+			return durationNature
+		}
+		if isDuration(l) && isDuration(r) {
+			return durationNature
+		}
+		if or(l, r, isNumber, isDuration) {
 			return unknown
 		}
 
@@ -382,6 +397,9 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature {
 		if isDuration(l) && isTime(r) {
 			return timeNature
 		}
+		if isDuration(l) && isDuration(r) {
+			return durationNature
+		}
 		if or(l, r, isNumber, isString, isTime, isDuration) {
 			return unknown
 		}
diff --git a/checker/nature/nature.go b/checker/nature/nature.go
index 01f8b9e49..6720acb4c 100644
--- a/checker/nature/nature.go
+++ b/checker/nature/nature.go
@@ -161,6 +161,13 @@ func (n Nature) FieldByName(name string) (Nature, bool) {
 	return Nature{Type: field.Type, FieldIndex: field.Index}, ok
 }
 
+func (n Nature) PkgPath() string {
+	if n.Type == nil {
+		return ""
+	}
+	return n.Type.PkgPath()
+}
+
 func (n Nature) IsFastMap() bool {
 	if n.Type == nil {
 		return false
diff --git a/checker/types.go b/checker/types.go
index 2fd5cf80e..7912931c5 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -89,7 +89,7 @@ func isInteger(nt Nature) bool {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		fallthrough
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return true
+		return nt.PkgPath() == ""
 	}
 	return false
 }
@@ -97,7 +97,7 @@ func isInteger(nt Nature) bool {
 func isFloat(nt Nature) bool {
 	switch nt.Kind() {
 	case reflect.Float32, reflect.Float64:
-		return true
+		return nt.PkgPath() == ""
 	}
 	return false
 }
@@ -178,15 +178,23 @@ func kind(t reflect.Type) reflect.Kind {
 }
 
 func isComparable(l, r Nature) bool {
-	switch {
-	case l.Kind() == r.Kind():
+	if isUnknown(l) || isUnknown(r) {
+		return true
+	}
+	if isNil(l) || isNil(r) {
 		return true
-	case isNumber(l) && isNumber(r):
+	}
+	if isNumber(l) && isNumber(r) {
+		return true
+	}
+	if isDuration(l) && isDuration(r) {
 		return true
-	case isNil(l) || isNil(r):
+	}
+	if isTime(l) && isTime(r) {
 		return true
-	case isUnknown(l) || isUnknown(r):
+	}
+	if isArray(l) && isArray(r) {
 		return true
 	}
-	return false
+	return l.AssignableTo(r)
 }
diff --git a/expr_test.go b/expr_test.go
index ff30b1224..1fc7a524f 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1119,6 +1119,10 @@ func TestExpr(t *testing.T) {
 			`duration("1h") + duration("1m")`,
 			time.Hour + time.Minute,
 		},
+		{
+			`duration("1h") - duration("1m")`,
+			time.Hour - time.Minute,
+		},
 		{
 			`7 * duration("1h")`,
 			7 * time.Hour,
@@ -2328,86 +2332,6 @@ func TestIssue432(t *testing.T) {
 	assert.Equal(t, float64(10), out)
 }
 
-func TestIssue461(t *testing.T) {
-	type EnvStr string
-	type EnvField struct {
-		S   EnvStr
-		Str string
-	}
-	type Env struct {
-		S        EnvStr
-		Str      string
-		EnvField EnvField
-	}
-	var tests = []struct {
-		input string
-		env   Env
-		want  bool
-	}{
-		{
-			input: "Str == S",
-			env:   Env{S: "string", Str: "string"},
-			want:  false,
-		},
-		{
-			input: "Str == Str",
-			env:   Env{Str: "string"},
-			want:  true,
-		},
-		{
-			input: "S == S",
-			env:   Env{Str: "string"},
-			want:  true,
-		},
-		{
-			input: `Str == "string"`,
-			env:   Env{Str: "string"},
-			want:  true,
-		},
-		{
-			input: `S == "string"`,
-			env:   Env{Str: "string"},
-			want:  false,
-		},
-		{
-			input: "EnvField.Str == EnvField.S",
-			env:   Env{EnvField: EnvField{S: "string", Str: "string"}},
-			want:  false,
-		},
-		{
-			input: "EnvField.Str == EnvField.Str",
-			env:   Env{EnvField: EnvField{Str: "string"}},
-			want:  true,
-		},
-		{
-			input: "EnvField.S == EnvField.S",
-			env:   Env{EnvField: EnvField{Str: "string"}},
-			want:  true,
-		},
-		{
-			input: `EnvField.Str == "string"`,
-			env:   Env{EnvField: EnvField{Str: "string"}},
-			want:  true,
-		},
-		{
-			input: `EnvField.S == "string"`,
-			env:   Env{EnvField: EnvField{Str: "string"}},
-			want:  false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			program, err := expr.Compile(tt.input, expr.Env(tt.env), expr.AsBool())
-
-			out, err := expr.Run(program, tt.env)
-			require.NoError(t, err)
-
-			require.Equal(t, tt.want, out)
-		})
-	}
-}
-
 func TestIssue462(t *testing.T) {
 	env := map[string]any{
 		"foo": func() (string, error) {
diff --git a/test/issues/461/issue_test.go b/test/issues/461/issue_test.go
new file mode 100644
index 000000000..81202562e
--- /dev/null
+++ b/test/issues/461/issue_test.go
@@ -0,0 +1,93 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue461(t *testing.T) {
+	type EnvStr string
+	type EnvField struct {
+		S   EnvStr
+		Str string
+	}
+	type Env struct {
+		S        EnvStr
+		Str      string
+		EnvField EnvField
+	}
+	var tests = []struct {
+		input string
+		env   Env
+		want  bool
+		err   string
+	}{
+		{
+			input: "Str == S",
+			env:   Env{S: "string", Str: "string"},
+			err:   "invalid operation: == (mismatched types string and issue_test.EnvStr)",
+		},
+		{
+			input: "Str == Str",
+			env:   Env{Str: "string"},
+			want:  true,
+		},
+		{
+			input: "S == S",
+			env:   Env{Str: "string"},
+			want:  true,
+		},
+		{
+			input: `Str == "string"`,
+			env:   Env{Str: "string"},
+			want:  true,
+		},
+		{
+			input: `S == "string"`,
+			env:   Env{Str: "string"},
+			err:   "invalid operation: == (mismatched types issue_test.EnvStr and string)",
+		},
+		{
+			input: "EnvField.Str == EnvField.S",
+			env:   Env{EnvField: EnvField{S: "string", Str: "string"}},
+			err:   "invalid operation: == (mismatched types string and issue_test.EnvStr)",
+		},
+		{
+			input: "EnvField.Str == EnvField.Str",
+			env:   Env{EnvField: EnvField{Str: "string"}},
+			want:  true,
+		},
+		{
+			input: "EnvField.S == EnvField.S",
+			env:   Env{EnvField: EnvField{Str: "string"}},
+			want:  true,
+		},
+		{
+			input: `EnvField.Str == "string"`,
+			env:   Env{EnvField: EnvField{Str: "string"}},
+			want:  true,
+		},
+		{
+			input: `EnvField.S == "string"`,
+			env:   Env{EnvField: EnvField{Str: "string"}},
+			err:   "invalid operation: == (mismatched types issue_test.EnvStr and string)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			program, err := expr.Compile(tt.input, expr.Env(tt.env), expr.AsBool())
+
+			if tt.err != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.err)
+			} else {
+				out, err := expr.Run(program, tt.env)
+				require.NoError(t, err)
+				require.Equal(t, tt.want, out)
+			}
+		})
+	}
+}
diff --git a/test/issues/730/issue_test.go b/test/issues/730/issue_test.go
new file mode 100644
index 000000000..864421bc0
--- /dev/null
+++ b/test/issues/730/issue_test.go
@@ -0,0 +1,60 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+type ModeEnum int
+
+const (
+	ModeEnumA ModeEnum = 1
+)
+
+type Env struct {
+	Mode *ModeEnum
+}
+
+func TestIssue730(t *testing.T) {
+	code := `int(Mode) == 1`
+
+	tmp := ModeEnumA
+
+	env := map[string]any{
+		"Mode": &tmp,
+	}
+
+	program, err := expr.Compile(code, expr.Env(env))
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.True(t, output.(bool))
+}
+
+func TestIssue730_warn_about_different_types(t *testing.T) {
+	code := `Mode == 1`
+
+	_, err := expr.Compile(code, expr.Env(Env{}))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "invalid operation: == (mismatched types issue_test.ModeEnum and int)")
+}
+
+func TestIssue730_eval(t *testing.T) {
+	code := `Mode == 1`
+
+	tmp := ModeEnumA
+
+	env := map[string]any{
+		"Mode": &tmp,
+	}
+
+	// Golang also does not allow this:
+	// _ = ModeEnumA == int(1) // will not compile
+
+	out, err := expr.Eval(code, env)
+	require.NoError(t, err)
+	require.False(t, out.(bool))
+}

From 4a3a8b6bc5167d87d4f152cdc3eb4d32599ee645 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 15:40:47 +0100
Subject: [PATCH 394/506] Add -update flag to gen tests

---
 test/gen/gen_test.go  |  47 +++++-
 testdata/examples.txt | 338 ------------------------------------------
 2 files changed, 43 insertions(+), 342 deletions(-)

diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go
index 6ac07c4f8..ef4a30bc8 100644
--- a/test/gen/gen_test.go
+++ b/test/gen/gen_test.go
@@ -1,27 +1,66 @@
 package main
 
 import (
+	"bufio"
+	"flag"
 	"os"
 	"strings"
 	"testing"
 
-	"github.com/expr-lang/expr/internal/testify/require"
-
 	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
 )
 
+var updateFlag = flag.Bool("update", false, "Drop failing lines from examples.txt")
+
 func TestGenerated(t *testing.T) {
+	flag.Parse()
+
 	b, err := os.ReadFile("../../testdata/examples.txt")
 	require.NoError(t, err)
 
 	examples := strings.TrimSpace(string(b))
+	var validLines []string
+
 	for _, line := range strings.Split(examples, "\n") {
+		line := line
 		t.Run(line, func(t *testing.T) {
 			program, err := expr.Compile(line, expr.Env(env))
-			require.NoError(t, err)
+			if err != nil {
+				if !*updateFlag {
+					t.Errorf("Compilation failed: %v", err)
+				}
+				return
+			}
 
 			_, err = expr.Run(program, env)
-			require.NoError(t, err)
+			if err != nil {
+				if !*updateFlag {
+					t.Errorf("Execution failed: %v", err)
+				}
+				return
+			}
+
+			validLines = append(validLines, line)
 		})
 	}
+
+	if *updateFlag {
+		file, err := os.Create("../../testdata/examples.txt")
+		if err != nil {
+			t.Fatalf("Failed to update examples.txt: %v", err)
+		}
+		defer func(file *os.File) {
+			_ = file.Close()
+		}(file)
+
+		writer := bufio.NewWriter(file)
+		for _, line := range validLines {
+			_, err := writer.WriteString(line + "\n")
+			if err != nil {
+				t.Fatalf("Failed to write to examples.txt: %v", err)
+			}
+		}
+		_ = writer.Flush()
+	}
 }
diff --git a/testdata/examples.txt b/testdata/examples.txt
index e4f6d36c8..a7d574275 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -155,16 +155,10 @@
 !(1 not in array)
 !(add != add)
 !(add != div)
-!(add != greet)
-!(add != half)
 !(add != nil)
-!(add != score)
 !(add == add)
 !(add == div)
-!(add == greet)
-!(add == half)
 !(add == nil)
-!(add == score)
 !(array != array)
 !(array != list)
 !(array != nil)
@@ -173,15 +167,9 @@
 !(array == nil)
 !(div != add)
 !(div != div)
-!(div != greet)
-!(div != half)
 !(div != nil)
-!(div != score)
 !(div == add)
 !(div == div)
-!(div == greet)
-!(div == half)
-!(div == score)
 !(f32 != 0.5)
 !(f32 != 1)
 !(f32 != f32)
@@ -296,29 +284,14 @@
 !(foo == reduce(list, #))
 !(foo in list)
 !(foo not in list)
-!(greet != add)
-!(greet != div)
 !(greet != greet)
-!(greet != half)
 !(greet != nil)
-!(greet != score)
-!(greet == add)
 !(greet == greet)
-!(greet == half)
 !(greet == nil)
-!(greet == score)
-!(half != add)
-!(half != div)
-!(half != greet)
 !(half != half)
 !(half != nil)
-!(half != score)
-!(half == add)
-!(half == div)
-!(half == greet)
 !(half == half)
 !(half == nil)
-!(half == score)
 !(i != 0.5)
 !(i != 1)
 !(i != f32)
@@ -524,16 +497,8 @@
 !(ok || false)
 !(ok || ok)
 !(ok || true)
-!(score != add)
-!(score != div)
-!(score != greet)
-!(score != half)
 !(score != nil)
 !(score != score)
-!(score == add)
-!(score == div)
-!(score == greet)
-!(score == half)
 !(score == nil)
 !(score == score)
 !(true != false)
@@ -580,7 +545,6 @@
 !false ? add : i64
 !false ? array : add
 !false ? array : ok
-!false ? div != half : map(list, i32)
 !false ? div : array
 !false ? div : greet
 !false ? div : half
@@ -618,8 +582,6 @@
 !not ("bar" == nil)
 !not (1 <= 1)
 !not (1 > 0.5)
-!not (greet != score)
-!not (greet == div)
 !not (greet == nil)
 !not (i32 == f64)
 !not false
@@ -2316,7 +2278,6 @@
 1 / i64 > f64
 1 / i64 >= f64
 1 < 1 == ok
-1 < 1 and half == div
 1 < 1 and ok
 1 < array[get(array, i32)]
 1 < array[i32]
@@ -2341,7 +2302,6 @@
 1 == i64 == ok
 1 == nil ? ok : half
 1 > 0.5 == ok
-1 > 1 || add != greet
 1 > array[i64]
 1 > f32 && ok
 1 > f32 == reduce(array, ok)
@@ -2916,44 +2876,17 @@ add != add == nil
 add != div
 add != div != false
 add != div == true
-add != foo.Qux
-add != foo.String
-add != foo?.Qux
-add != foo?.String
-add != greet
-add != greet == ok
-add != greet ? array : 1
-add != greet ? greet : ok
-add != half
-add != half == ok
-add != half || nil != add
 add != nil ? f64 : i64
 add != reduce(list, add)
-add != reduce(list, greet)
-add != score
 add == add
 add == add != nil
 add == add == nil
 add == add ? 1 : i64
 add == div
 add == div ? f64 : list
-add == foo.Qux
-add == foo.String
-add == foo?.Qux
-add == foo?.String
-add == greet
-add == half
-add == half != ok
-add == half ? nil : f32
 add == nil ? false : i32
 add == nil ? greet : i32
 add == nil ? nil : nil
-add == reduce(list, score)
-add == score
-add == score != ok
-add == score != true
-add == score == true
-add == score or ok
 add in sort(array)
 add(1, i) < i
 add(i, 1) ** f32
@@ -3100,7 +3033,6 @@ all(list, f64 != f32)
 all(list, f64 < i32)
 all(list, f64 > i64)
 all(list, false ? i : true)
-all(list, greet == half)
 all(list, i < f32)
 all(list, i <= 1)
 all(list, i <= i32)
@@ -3125,8 +3057,6 @@ all(list, none(array, 1 > #))
 all(list, not true)
 all(list, ok)
 all(list, reduce(array, true))
-all(list, score != add)
-all(list, score != div)
 all(list, type(i) not endsWith .Bar)
 all(map(array, #), ok && false)
 all(map(array, #), ok)
@@ -3201,7 +3131,6 @@ any(array, 1 > #)
 any(array, 1 > 1)
 any(array, 1 >= #)
 any(array, 1 >= f64)
-any(array, add == greet)
 any(array, all(list, false))
 any(array, f32 < i)
 any(array, f32 > #)
@@ -3234,8 +3163,6 @@ any(array, ok != true)
 any(array, ok)
 any(array, one(array, # <= 0.5))
 any(array, one(array, ok))
-any(array, score != add)
-any(array, score == half)
 any(array, score == nil)
 any(i32 .. i, half == half)
 any(list, !ok)
@@ -3254,7 +3181,6 @@ any(list, 0.5 < f64)
 any(list, 0.5 == i64)
 any(list, 1 >= f64)
 any(list, 1 >= i32)
-any(list, add == score)
 any(list, any(list, false))
 any(list, any(list, ok))
 any(list, array == nil)
@@ -4008,8 +3934,6 @@ count(list, 0.5 > f32)
 count(list, 1 != i)
 count(list, 1 >= 0.5)
 count(list, 1 >= f32)
-count(list, add != half)
-count(list, div == score)
 count(list, f32 == i64)
 count(list, f32 >= f32)
 count(list, false && false)
@@ -4017,7 +3941,6 @@ count(list, false) + -1
 count(list, false) / f64
 count(list, false) > f32
 count(list, foo == #)
-count(list, greet != score)
 count(list, i != i64)
 count(list, i < 0.5)
 count(list, i <= i64)
@@ -4065,39 +3988,14 @@ div != div
 div != div != ok
 div != div && ok
 div != div ? "bar" : "foo"
-div != foo.Qux
-div != foo.String
-div != foo?.Qux
-div != foo?.String
-div != greet
-div != greet != ok
-div != greet or ok
-div != half
-div != half != true
-div != half ? false : div
-div != half ? greet : true
 div != nil == ok
 div != nil || f32 < 0.5
 div != reduce(array, div)
-div != score
-div != score != true
 div == add
 div == add ? 1 : ok
 div == div
-div == foo.Qux
-div == foo.String
-div == foo?.Qux
-div == foo?.String
-div == greet
-div == greet == nil
-div == greet ? 1 : 1
-div == half
-div == half != false
 div == nil ? f32 : half
 div == nil ? false : 1
-div == score
-div == score ? "bar" : true
-div == score or f32 != f64
 div(-i, array[i64])
 div(-i, i)
 div(1, i) + i
@@ -5511,7 +5409,6 @@ false ? add : 1 / i ^ 0.5
 false ? add : i64 - i
 false ? div : i64 ** i
 false ? f32 : foo.Qux
-false ? f32 : half != score
 false ? f64 : 0.5 != i32
 false ? f64 : 0.5 ** i32
 false ? f64 : 1 >= i
@@ -5599,7 +5496,6 @@ filter(array, 1 >= #)
 filter(array, add == add)
 filter(array, add == nil)
 filter(array, any(list, ok))
-filter(array, div != score)
 filter(array, f32 != #)
 filter(array, f32 < #)
 filter(array, f32 <= #)
@@ -5698,7 +5594,6 @@ filter(list, ok == nil)
 filter(list, ok and false)
 filter(list, ok)
 filter(list, ok)[i]
-filter(list, score == half)
 filter(list, true == ok)
 filter(list, true || true)
 filter(list, true) == list
@@ -5780,7 +5675,6 @@ find(array, 1 == #)
 find(array, 1 > #)
 find(array, 1 >= #)
 find(array, div != nil)
-find(array, div == half)
 find(array, f32 != #)
 find(array, f32 != f32)
 find(array, f32 < #)
@@ -5799,7 +5693,6 @@ find(array, false ? # : false)
 find(array, false) != f64
 find(array, floor(#) > #)
 find(array, greet != greet)
-find(array, half == score)
 find(array, i % # != f64)
 find(array, i < 0.5)
 find(array, i <= #)
@@ -5865,7 +5758,6 @@ find(list, false && true)
 find(list, false)?.Bar
 find(list, foo != #)
 find(list, foo == #)
-find(list, greet != div)
 find(list, i != 1)
 find(list, i != f64)
 find(list, i != i32)
@@ -6012,7 +5904,6 @@ findIndex(array, ok) / f64
 findIndex(array, ok) / i
 findIndex(array, ok) <= f32
 findIndex(array, one(list, false))
-findIndex(array, score == greet)
 findIndex(array, true) + f64
 findIndex(array, true) - f64
 findIndex(array, true) .. i
@@ -6099,7 +5990,6 @@ findIndex(true ? "foo" : ok, # == greet)
 findLast(1 .. i, # <= #)
 findLast(1 .. i32, 1 >= #)
 findLast(1 .. i64, ok)
-findLast([1, f64], half == add)
 findLast([false], #)
 findLast(array, !false)
 findLast(array, !ok)
@@ -6177,7 +6067,6 @@ findLast(array, ok and true)
 findLast(array, ok)
 findLast(array, ok) == i64
 findLast(array, reduce(list, ok))
-findLast(array, score != div)
 findLast(array, score != nil)
 findLast(array, true) % i64
 findLast(groupBy(array, #).i32, #)
@@ -6328,7 +6217,6 @@ findLastIndex(array, f64 > #)
 findLastIndex(array, false ? # : false)
 findLastIndex(array, foo != foo)
 findLastIndex(array, greet == greet)
-findLastIndex(array, half == greet)
 findLastIndex(array, i - # >= #)
 findLastIndex(array, i < #)
 findLastIndex(array, i <= #)
@@ -6388,9 +6276,6 @@ findLastIndex(list, f32 != 1)
 findLastIndex(list, f32 != f64)
 findLastIndex(list, f64 > 0.5)
 findLastIndex(list, foo == #)
-findLastIndex(list, half != div)
-findLastIndex(list, half == greet)
-findLastIndex(list, half == score)
 findLastIndex(list, i <= 1)
 findLastIndex(list, i32 > 1)
 findLastIndex(list, i32 > f32)
@@ -7092,13 +6977,6 @@ foo.Bar <= foo.Bar
 foo.Bar matches foo.Bar
 foo.Bar matches trimPrefix("foo")
 foo.Qux
-foo.Qux != greet
-foo.Qux != half
-foo.Qux == add
-foo.Qux == div
-foo.Qux == greet
-foo.Qux == half
-foo.Qux == score
 foo.Qux("foo" + "foo")
 foo.Qux(foo.Bar)
 foo.Qux(foo.String())
@@ -7109,12 +6987,6 @@ foo.Qux(type("bar"))
 foo.Qux(type(f64))
 foo.Qux(type(half))
 foo.String
-foo.String != div
-foo.String != greet
-foo.String != half
-foo.String == add
-foo.String == div
-foo.String == half
 foo.String()
 foo.String() != foo?.String()
 foo.String() in foo
@@ -7126,27 +6998,12 @@ foo?.Bar matches toJSON(f64)
 foo?.Bar not endsWith foo.Bar
 foo?.Bar not endsWith toJSON(foo)
 foo?.Qux
-foo?.Qux != add
-foo?.Qux != greet
-foo?.Qux != half
-foo?.Qux != score
-foo?.Qux == add
-foo?.Qux == div
-foo?.Qux == greet
-foo?.Qux == half
-foo?.Qux == score
 foo?.Qux(foo?.Bar)
 foo?.Qux(string(i32))
 foo?.Qux(toJSON(1))
 foo?.Qux(toJSON(i32))
 foo?.Qux(upper("bar"))
 foo?.String
-foo?.String != greet
-foo?.String != half
-foo?.String != score
-foo?.String == greet
-foo?.String == half
-foo?.String == score
 foo?.String()
 foo?.String() contains string("foo")
 fromBase64(string(ok))
@@ -7396,47 +7253,18 @@ get(true ? score : true, half)?.half
 get(true ? true : i, f64)
 get({"foo": foo, "bar": false}, type(i))
 greet
-greet != add
-greet != div
-greet != div and ok
-greet != foo.Qux
-greet != foo.String
-greet != foo?.Qux
-greet != foo?.String
 greet != greet
 greet != greet != ok
-greet != half
 greet != nil ? "bar" : add
 greet != nil ? 0.5 : false
 greet != nil ? list : false
-greet != score
-greet != score != false
-greet != score or ok
-greet == add
-greet == add ? i : list
-greet == add or ok
-greet == div
-greet == div || ok
-greet == foo.Qux
-greet == foo.String
-greet == foo?.Qux
-greet == foo?.String
 greet == greet
 greet == greet ? 0.5 : "bar"
 greet == greet and ok
-greet == half
-greet == half ? 1 : ok
 greet == nil == ok
 greet == nil ? i64 : ok
-greet == reduce(list, div)
-greet == reduce(list, half)
-greet == score
-greet == score ? 1 : ok
-greet == score ? add : nil
 greet in groupBy(array, f64).f32
 greet in groupBy(list, #).score
-greet not in map(array, score)
-greet not in map(list, div)
 greet not in sort(array)
 greet("bar" + "bar")
 greet("foo" + "foo")
@@ -7896,8 +7724,6 @@ groupBy(array, bitushr(#, #))
 groupBy(array, ceil(#))
 groupBy(array, ceil(i))
 groupBy(array, ceil(i32))
-groupBy(array, div != score)
-groupBy(array, div == half)
 groupBy(array, div(#, #))
 groupBy(array, f32 != #)
 groupBy(array, f32 ** 0.5)
@@ -8067,7 +7893,6 @@ groupBy(array, foo?.Bar)
 groupBy(array, get(array, #))
 groupBy(array, get(list, #))
 groupBy(array, get(list, i32))
-groupBy(array, half != add)
 groupBy(array, half(1))
 groupBy(array, half(f64))
 groupBy(array, half(f64))?.i64
@@ -8282,7 +8107,6 @@ groupBy(array, reduce(array, #))
 groupBy(array, reduce(array, foo))
 groupBy(array, reduce(list, #))
 groupBy(array, round(#))
-groupBy(array, score == div)
 groupBy(array, score(#))
 groupBy(array, score(#, #))
 groupBy(array, score(#, #, #, 1))
@@ -8751,7 +8575,6 @@ groupBy(list, foo.Bar)
 groupBy(list, foo.String())
 groupBy(list, foo?.String())
 groupBy(list, greet != greet)
-groupBy(list, greet == add)
 groupBy(list, greet("bar"))
 groupBy(list, i * i)
 groupBy(list, i / f64)
@@ -9059,20 +8882,6 @@ groupBy(true ? "foo" : 1, foo)
 groupBy(true ? "foo" : false, # / #)
 groupBy(true ? "foo" : score, #)
 half
-half != add
-half != add ? add : array
-half != add ? true : 1
-half != add || ok
-half != div
-half != div ? i32 : f64
-half != div ? nil : greet
-half != foo.Qux
-half != foo.String
-half != foo?.Qux
-half != foo?.String
-half != greet
-half != greet == ok
-half != greet ? score : true
 half != half
 half != half != nil
 half != half and "bar" in foo
@@ -9081,29 +8890,10 @@ half != nil ? "bar" : div
 half != nil ? "bar" : false
 half != nil ? true : div
 half != reduce(list, half)
-half != score
-half != score && i32 > 1
-half == add
-half == add == nil
-half == add ? list : add
-half == add or ok
-half == div
-half == foo.Qux
-half == foo.String
-half == foo?.Qux
-half == foo?.String
-half == greet
-half == greet != ok
-half == greet ? half : div
-half == greet ? i64 : ok
-half == greet || true ? i : list
 half == half
 half == nil && ok
 half == nil ? array : 0.5
 half == nil ? foo : false
-half == score
-half == score ? f32 : nil
-half == score ? foo : "bar"
 half(-(0.5 + 1))
 half(-(f64 + 1))
 half(-(i64 - 0.5))
@@ -12591,7 +12381,6 @@ map(array, 1 == #)
 map(array, 1 ^ #)
 map(array, abs(#))
 map(array, abs(i64))
-map(array, add == greet)
 map(array, add == nil)
 map(array, add(#, #))
 map(array, add(#, i))
@@ -12843,7 +12632,6 @@ map(list, [#])
 map(list, [foo, 0.5, #])
 map(list, [score])
 map(list, abs(f32))
-map(list, add == score)
 map(list, add)
 map(list, array)
 map(list, ceil(0.5))
@@ -12881,7 +12669,6 @@ map(list, greet)
 map(list, groupBy(array, #))
 map(list, groupBy(array, i))
 map(list, groupBy(list, #))
-map(list, half == greet)
 map(list, half(0.5))
 map(list, half(f64))
 map(list, half)
@@ -12933,7 +12720,6 @@ map(list, ok)
 map(list, reduce(array, half))
 map(list, reduce(list, foo))
 map(list, reduce(list, half))
-map(list, score != add)
 map(list, score(1))
 map(list, score)
 map(list, score)[i64]
@@ -13897,8 +13683,6 @@ none(array, f64 != 1)
 none(array, f64 == #)
 none(array, f64 > #)
 none(array, f64 >= #)
-none(array, greet != div)
-none(array, greet != half)
 none(array, i != #)
 none(array, i < #)
 none(array, i < f64)
@@ -13956,7 +13740,6 @@ none(list, 1 != nil)
 none(list, 1 == f32)
 none(list, 1 > 0.5)
 none(list, all(array, ok))
-none(list, div == #?.Qux)
 none(list, f32 != 1 ** f64)
 none(list, f32 >= 0.5)
 none(list, f32 in array)
@@ -14162,15 +13945,9 @@ not (1 >= i64)
 not (1 in array)
 not (1 not in array)
 not (add != add)
-not (add != greet)
-not (add != half)
 not (add != nil)
-not (add != score)
 not (add == div)
-not (add == greet)
-not (add == half)
 not (add == nil)
-not (add == score)
 not (array != array)
 not (array != list)
 not (array != nil)
@@ -14180,17 +13957,10 @@ not (array == nil)
 not (array[i32] > i64)
 not (div != add)
 not (div != div)
-not (div != foo?.Qux)
-not (div != greet)
-not (div != half)
 not (div != nil)
-not (div != score)
 not (div == add)
 not (div == div)
-not (div == greet)
-not (div == half)
 not (div == nil)
-not (div == score)
 not (f32 != 0.5)
 not (f32 != 1)
 not (f32 != f32)
@@ -14305,31 +14075,14 @@ not (foo == foo)
 not (foo == nil)
 not (foo in list)
 not (foo not in list)
-not (greet != add)
-not (greet != div)
 not (greet != greet)
-not (greet != half)
 not (greet != nil)
-not (greet != score)
-not (greet == add)
-not (greet == div)
 not (greet == greet)
-not (greet == half)
 not (greet == nil)
-not (greet == score)
-not (half != add)
-not (half != div)
-not (half != greet)
 not (half != half)
 not (half != nil)
-not (half != score)
-not (half == add)
-not (half == div)
-not (half == foo?.String)
-not (half == greet)
 not (half == half)
 not (half == nil)
-not (half == score)
 not (i != 0.5)
 not (i != 1)
 not (i != f32)
@@ -14539,16 +14292,8 @@ not (ok or ok)
 not (ok or true)
 not (ok || ok)
 not (ok || true)
-not (score != add)
-not (score != div)
-not (score != greet)
-not (score != half)
 not (score != nil)
 not (score != score)
-not (score == add)
-not (score == div)
-not (score == greet)
-not (score == half)
 not (score == nil)
 not (score == score)
 not (true != false)
@@ -14777,7 +14522,6 @@ ok && 1 <= f64
 ok && 1 == 0.5
 ok && 1 == nil
 ok && 1 >= f64
-ok && add != greet
 ok && f32 != i
 ok && f32 >= i64
 ok && f64 <= 0.5
@@ -14830,7 +14574,6 @@ ok ? 1 + i : i32
 ok ? 1 / i64 : greet
 ok ? 1 : foo.Bar
 ok ? 1 : foo?.Qux
-ok ? 1 : score != greet
 ok ? abs(i64) : i64
 ok ? add : abs(f32)
 ok ? add : add
@@ -15029,10 +14772,8 @@ ok and 1 < i64
 ok and 1 == 1
 ok and 1 == i64
 ok and add == nil
-ok and div == half
 ok and f32 != 1
 ok and f32 >= 1
-ok and greet != div
 ok and greet == greet
 ok and i == 0.5
 ok and i32 < f32
@@ -15073,9 +14814,7 @@ ok or 0.5 == i
 ok or 1 != f32
 ok or 1 <= 1
 ok or 1 <= i
-ok or div != half
 ok or div != nil
-ok or div != score
 ok or f32 != f32
 ok or f32 == 0.5
 ok or f32 == f32
@@ -15083,8 +14822,6 @@ ok or f64 <= 1
 ok or false ? ok : 1
 ok or false and false
 ok or foo != foo
-ok or half != add
-ok or half == div
 ok or i < 1
 ok or i == 0.5
 ok or i == f32
@@ -15122,7 +14859,6 @@ ok || f64 > f64
 ok || f64 >= i64
 ok || false ? half : i64
 ok || foo == foo
-ok || greet == half
 ok || i == i
 ok || i32 < f32
 ok || i32 <= 0.5
@@ -15204,7 +14940,6 @@ one(array, 1 > 0.5)
 one(array, 1 >= #)
 one(array, add == div)
 one(array, all(array, true))
-one(array, div != score)
 one(array, f32 <= #)
 one(array, f32 <= 0.5)
 one(array, f32 >= #)
@@ -15235,9 +14970,6 @@ one(array, nil != i64)
 one(array, not ok)
 one(array, ok)
 one(array, one(list, false))
-one(array, score != add)
-one(array, score != greet)
-one(array, score == div)
 one(array, true != false)
 one(array, true == nil)
 one(array, true) ? greet : add
@@ -15574,7 +15306,6 @@ reduce(array, get(array, 1))
 reduce(array, get(list, #))
 reduce(array, greet("bar"))
 reduce(array, greet)
-reduce(array, greet) != score != nil
 reduce(array, groupBy(array, #))
 reduce(array, groupBy(list, #))
 reduce(array, groupBy(list, #)?.f32)
@@ -15760,10 +15491,8 @@ reduce(list, 1) + f32
 reduce(list, 1) - i
 reduce(list, add)
 reduce(list, add) != div
-reduce(list, add) in map(array, greet)
 reduce(list, array != array)
 reduce(list, array)
-reduce(list, div == greet)
 reduce(list, div)
 reduce(list, f32 / 0.5)
 reduce(list, f32 < i32)
@@ -15869,7 +15598,6 @@ reduce(list, nil != #)
 reduce(list, nil != add)
 reduce(list, nil != half)
 reduce(list, nil == #)
-reduce(list, not (half != score))
 reduce(list, not false)
 reduce(list, not ok)
 reduce(list, not true)
@@ -15884,7 +15612,6 @@ reduce(list, reduce(list, #))
 reduce(list, reduce(list, 1))
 reduce(list, reduce(list, add))
 reduce(list, reduce(list, i32))
-reduce(list, score != half)
 reduce(list, score(i))
 reduce(list, score)
 reduce(list, string(greet))
@@ -16289,19 +16016,6 @@ round(score(i))
 round(sum(array))
 round(true ? i : ok)
 score
-score != add
-score != add == ok
-score != add ? 0.5 : div
-score != div
-score != foo.Qux
-score != foo.String
-score != foo?.Qux
-score != foo?.String
-score != greet
-score != greet ? add : i64
-score != greet ? div : i
-score != half
-score != half || ok
 score != nil != ok
 score != nil ? half : f64
 score != nil or i32 > 0.5
@@ -16309,28 +16023,13 @@ score != nil || ok
 score != score
 score != score != ok
 score != score ? i32 : i32
-score == add
-score == div
-score == div != nil
-score == div == ok
-score == foo.Qux
-score == foo.String
-score == foo?.Qux
-score == foo?.String
-score == greet
-score == greet != ok
-score == half
-score == half ? 1 : add
-score == half ? half : f64
 score == nil != nil
 score == nil && ok
 score == nil ? 0.5 : "bar"
-score == reduce(array, half)
 score == score
 score == score == true
 score == score ? 0.5 : score
 score in groupBy(list, #)?.array
-score in map(list, add)
 score in sort(array)
 score(-1)
 score(-1, i)
@@ -16713,11 +16412,8 @@ string(abs(i))
 string(abs(i32))
 string(add != add)
 string(add != div)
-string(add != score)
 string(add == div)
-string(add == greet)
 string(add == nil)
-string(add == score)
 string(add)
 string(add) in foo ? i64 : i32
 string(add) not endsWith foo.Bar
@@ -16740,12 +16436,9 @@ string(ceil(f64))
 string(ceil(i))
 string(ceil(i64))
 string(div != div)
-string(div != greet)
 string(div != nil)
-string(div != score)
 string(div == add)
 string(div == div)
-string(div == greet)
 string(div)
 string(f32 != 0.5)
 string(f32 != f64)
@@ -16867,11 +16560,9 @@ string(get(array, i64))
 string(get(list, 1))
 string(get(list, i32))
 string(get(list, i64))
-string(greet != add)
 string(greet != nil)
 string(greet == greet)
 string(greet == nil)
-string(greet == score)
 string(greet("bar"))
 string(greet("foo"))
 string(greet)
@@ -16888,7 +16579,6 @@ string(groupBy(list, f64))
 string(groupBy(list, false))
 string(groupBy(list, i))
 string(half != nil)
-string(half != score)
 string(half == nil)
 string(half(0.5))
 string(half(1))
@@ -17123,11 +16813,7 @@ string(round(1))
 string(round(ceil(i32)))
 string(round(f64))
 string(round(i64))
-string(score != div)
-string(score != greet)
-string(score != half)
 string(score != nil)
-string(score == greet)
 string(score == nil)
 string(score(1 % 1))
 string(score(1))
@@ -17437,10 +17123,7 @@ toJSON(abs(f64))
 toJSON(abs(i))
 toJSON(abs(i32))
 toJSON(abs(i64))
-toJSON(add != greet)
-toJSON(add != half)
 toJSON(add == add)
-toJSON(add == score)
 toJSON(any(array, false))
 toJSON(array == array)
 toJSON(array == list)
@@ -17461,7 +17144,6 @@ toJSON(ceil(i32))
 toJSON(ceil(i64))
 toJSON(count(array, ok))
 toJSON(div != div)
-toJSON(div != score)
 toJSON(div == div)
 toJSON(f32 != 0.5)
 toJSON(f32 != 1 || ok)
@@ -17553,12 +17235,8 @@ toJSON(get(list, i))
 toJSON(get(list, i32))
 toJSON(get(list, i64))
 toJSON(greet != nil)
-toJSON(greet != score)
-toJSON(greet == div)
 toJSON(greet == greet)
-toJSON(greet == half)
 toJSON(greet == nil)
-toJSON(greet == score)
 toJSON(greet("bar"))
 toJSON(greet("foo"))
 toJSON(groupBy(array, #)?.div)
@@ -17791,10 +17469,7 @@ toJSON(reduce(list, true))
 toJSON(round(1))
 toJSON(round(f64))
 toJSON(round(i32))
-toJSON(score != add)
-toJSON(score != div)
 toJSON(score != score)
-toJSON(score == half)
 toJSON(score(1))
 toJSON(score(1, 1))
 toJSON(score(i))
@@ -18074,11 +17749,9 @@ true ? greet : ok == ok
 true ? half : 0.5 / i32
 true ? half : foo.String
 true ? i : 1 * i64
-true ? i : greet == half
 true ? i32 : i32 - f32
 true ? i32 : i32 >= f32
 true ? i64 : f64 != i
-true ? list : div != greet
 true ? list : f32 != i
 true ? nil : foo.String
 true ? nil : foo?.String
@@ -18220,8 +17893,6 @@ type(abs(f64))
 type(abs(i))
 type(abs(i32))
 type(abs(i64))
-type(add != greet)
-type(add != half)
 type(add)
 type(all(array, ok))
 type(all(list, ok))
@@ -18248,7 +17919,6 @@ type(ceil(f64))
 type(ceil(i64))
 type(count(array, true))
 type(div != div)
-type(div != half)
 type(div == div)
 type(div)
 type(f32 != 0.5)
@@ -18356,8 +18026,6 @@ type(get(list, 1))
 type(get(list, i))
 type(get(list, i32))
 type(get(list, i64))
-type(greet != div)
-type(greet == div)
 type(greet("bar"))
 type(greet("foo"))
 type(greet)
@@ -18374,9 +18042,6 @@ type(groupBy(list, #)?.Bar)
 type(groupBy(list, 1))
 type(groupBy(list, i64))
 type(groupBy(list, true))
-type(half != div)
-type(half != greet)
-type(half != score)
 type(half(0.5))
 type(half(1))
 type(half(f64))
@@ -18594,8 +18259,6 @@ type(round(f64))
 type(round(i))
 type(round(i64))
 type(score != score)
-type(score == div)
-type(score == greet)
 type(score == nil)
 type(score(1))
 type(score(1, 1))
@@ -19286,7 +18949,6 @@ values({"foo": ok})
 {"bar": one(list, false)}
 {"bar": reduce(array, i)}.i64
 {"bar": reduce(list, half)}
-{"bar": score != add}
 {"bar": score(i)}
 {"bar": score, "bar": "bar", "bar": "foo"}?.f32
 {"bar": score, "bar": add}.String

From 8f0751dbdf0c232bce740244a5c62bebc19bbd52 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 16:19:30 +0100
Subject: [PATCH 395/506] Update fuzz tests

---
 checker/checker.go        |     2 +-
 conf/config.go            |     2 +-
 conf/env.go               |     1 +
 expr_test.go              |     8 +
 test/fuzz/fuzz_corpus.txt | 23290 ++++++++++++++++++++----------------
 test/fuzz/fuzz_test.go    |     3 +
 6 files changed, 13268 insertions(+), 10038 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index b04d3f135..d410b9549 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -217,7 +217,7 @@ func (v *checker) IdentifierNode(node *ast.IdentifierNode) Nature {
 		return unknown
 	}
 
-	return v.ident(node, node.Value, v.config.Env.Strict, true)
+	return v.ident(node, node.Value, v.config.Strict, true)
 }
 
 // ident method returns type of environment variable, builtin or function.
diff --git a/conf/config.go b/conf/config.go
index 270438b9d..d629958e5 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -62,9 +62,9 @@ func New(env any) *Config {
 }
 
 func (c *Config) WithEnv(env any) {
-	c.Strict = true
 	c.EnvObject = env
 	c.Env = Env(env)
+	c.Strict = c.Env.Strict
 }
 
 func (c *Config) ConstExpr(name string) {
diff --git a/conf/env.go b/conf/env.go
index 99e2f4626..8b13df1e1 100644
--- a/conf/env.go
+++ b/conf/env.go
@@ -36,6 +36,7 @@ func Env(env any) Nature {
 		n := Nature{
 			Type:   v.Type(),
 			Fields: make(map[string]Nature, v.Len()),
+			Strict: true,
 		}
 
 		for _, key := range v.MapKeys() {
diff --git a/expr_test.go b/expr_test.go
index 1fc7a524f..4ebe6d4de 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2716,3 +2716,11 @@ func TestIssue758_filter_map_index(t *testing.T) {
 
 	require.Equal(t, expected, result)
 }
+
+func TestExpr_wierd_cases(t *testing.T) {
+	env := map[string]any{}
+
+	_, err := expr.Compile(`A(A)`, expr.Env(env))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "unknown name A")
+}
diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
index 59349d3d5..a7d574275 100644
--- a/test/fuzz/fuzz_corpus.txt
+++ b/test/fuzz/fuzz_corpus.txt
@@ -1,18 +1,15 @@
-!!!true
-!!(f32 > f64)
-!!(half != greet)
-!!(nil == add)
-!!(ok or true)
+!!!false
+!!(1 <= f64)
+!!(1 > 0.5)
+!!(i64 != f64)
+!!all(array, ok)
 !!false
-!!not false
 !!ok
 !!true
 !("bar" != "bar")
 !("bar" != "foo")
 !("bar" != nil)
-!("bar" < "bar")
 !("bar" < "foo")
-!("bar" <= "bar")
 !("bar" <= "foo")
 !("bar" == "bar")
 !("bar" == "foo")
@@ -21,32 +18,32 @@
 !("bar" > "foo")
 !("bar" >= "bar")
 !("bar" >= "foo")
+!("bar" contains "bar")
 !("bar" contains "foo")
+!("bar" endsWith "bar")
+!("bar" endsWith "foo")
 !("bar" in foo)
 !("bar" matches "foo")
 !("bar" not contains "bar")
-!("bar" not contains "foo")
+!("bar" not endsWith "bar")
 !("bar" not endsWith "foo")
 !("bar" not in foo)
-!("bar" not matches "foo")
+!("bar" not matches "bar")
 !("bar" not startsWith "bar")
 !("bar" not startsWith "foo")
 !("bar" startsWith "bar")
 !("foo" != "bar")
-!("foo" != "foo")
 !("foo" != nil)
-!("foo" < "bar")
+!("foo" < "foo")
 !("foo" <= "bar")
 !("foo" <= "foo")
-!("foo" == "foo")
+!("foo" == "bar")
 !("foo" == nil)
 !("foo" > "bar")
 !("foo" > "foo")
 !("foo" >= "bar")
-!("foo" >= "foo")
 !("foo" contains "bar")
 !("foo" contains "foo")
-!("foo" endsWith "bar")
 !("foo" endsWith "foo")
 !("foo" in foo)
 !("foo" matches "bar")
@@ -54,14 +51,15 @@
 !("foo" not contains "bar")
 !("foo" not contains "foo")
 !("foo" not endsWith "bar")
-!("foo" not endsWith "foo")
-!("foo" not in foo)
 !("foo" not matches "bar")
 !("foo" not matches "foo")
 !("foo" not startsWith "bar")
 !("foo" not startsWith "foo")
 !("foo" startsWith "bar")
 !("foo" startsWith "foo")
+!(-f32 < f32)
+!(-i < i32)
+!(-i32 >= i)
 !(0.5 != 0.5)
 !(0.5 != 1)
 !(0.5 != f32)
@@ -70,7 +68,6 @@
 !(0.5 != i32)
 !(0.5 != i64)
 !(0.5 != nil)
-!(0.5 / i32 > i)
 !(0.5 < 0.5)
 !(0.5 < 1)
 !(0.5 < f32)
@@ -81,6 +78,7 @@
 !(0.5 <= 0.5)
 !(0.5 <= 1)
 !(0.5 <= f32)
+!(0.5 <= f64)
 !(0.5 <= i)
 !(0.5 <= i32)
 !(0.5 <= i64)
@@ -106,7 +104,8 @@
 !(0.5 >= i)
 !(0.5 >= i32)
 !(0.5 >= i64)
-!(0.5 ^ i64 < i64)
+!(0.5 in array)
+!(0.5 not in array)
 !(1 != 0.5)
 !(1 != 1)
 !(1 != f32)
@@ -115,6 +114,7 @@
 !(1 != i32)
 !(1 != i64)
 !(1 != nil)
+!(1 / i64 == i64)
 !(1 < 0.5)
 !(1 < 1)
 !(1 < f32)
@@ -139,6 +139,7 @@
 !(1 == nil)
 !(1 > 0.5)
 !(1 > 1)
+!(1 > f32)
 !(1 > f64)
 !(1 > i)
 !(1 > i32)
@@ -154,39 +155,29 @@
 !(1 not in array)
 !(add != add)
 !(add != div)
-!(add != greet)
-!(add != half)
 !(add != nil)
-!(add != score)
 !(add == add)
 !(add == div)
-!(add == half)
 !(add == nil)
-!(add == score)
 !(array != array)
+!(array != list)
 !(array != nil)
 !(array == array)
 !(array == list)
 !(array == nil)
 !(div != add)
 !(div != div)
-!(div != greet)
-!(div != half)
 !(div != nil)
-!(div != score)
 !(div == add)
 !(div == div)
-!(div == greet)
-!(div == half)
-!(div == nil)
-!(div == score)
 !(f32 != 0.5)
 !(f32 != 1)
 !(f32 != f32)
+!(f32 != f64)
+!(f32 != i)
 !(f32 != i32)
 !(f32 != i64)
 !(f32 != nil)
-!(f32 + i == 0.5 * i)
 !(f32 < 0.5)
 !(f32 < 1)
 !(f32 < f32)
@@ -198,7 +189,6 @@
 !(f32 <= 1)
 !(f32 <= f32)
 !(f32 <= f64)
-!(f32 <= i)
 !(f32 <= i32)
 !(f32 <= i64)
 !(f32 == 0.5)
@@ -219,39 +209,44 @@
 !(f32 >= 0.5)
 !(f32 >= 1)
 !(f32 >= f32)
-!(f32 >= f64)
 !(f32 >= i)
+!(f32 >= i32)
 !(f32 >= i64)
+!(f32 in array)
+!(f32 not in array)
 !(f64 != 0.5)
 !(f64 != 1)
 !(f64 != f32)
 !(f64 != f64)
+!(f64 != i)
 !(f64 != i32)
 !(f64 != i64)
 !(f64 != nil)
+!(f64 < 0.5 + 1)
 !(f64 < 0.5)
 !(f64 < 1)
-!(f64 < f32)
 !(f64 < f64)
 !(f64 < i)
 !(f64 < i32)
 !(f64 < i64)
+!(f64 < max(1))
 !(f64 <= 0.5)
 !(f64 <= 1)
-!(f64 <= f32)
-!(f64 <= f64)
-!(f64 <= i)
 !(f64 <= i32)
 !(f64 <= i64)
 !(f64 == 0.5)
 !(f64 == 1)
 !(f64 == f32)
+!(f64 == f64)
+!(f64 == i)
 !(f64 == i32)
 !(f64 == i64)
 !(f64 == nil)
 !(f64 > 0.5)
 !(f64 > 1)
+!(f64 > f32)
 !(f64 > f64)
+!(f64 > i)
 !(f64 > i32)
 !(f64 > i64)
 !(f64 >= 0.5)
@@ -261,18 +256,24 @@
 !(f64 >= i)
 !(f64 >= i32)
 !(f64 >= i64)
+!(f64 in array)
+!(f64 not in array)
 !(false != false)
 !(false != nil)
 !(false != ok)
 !(false != true)
 !(false && false)
 !(false && ok)
+!(false && true)
 !(false == false)
 !(false == nil)
 !(false == ok)
+!(false == true)
+!(false and false)
 !(false and ok)
+!(false and true)
+!(false or false)
 !(false or ok)
-!(false or true)
 !(false || false)
 !(false || ok)
 !(false || true)
@@ -280,31 +281,17 @@
 !(foo != nil)
 !(foo == foo)
 !(foo == nil)
+!(foo == reduce(list, #))
 !(foo in list)
 !(foo not in list)
-!(greet != div)
 !(greet != greet)
-!(greet != half)
 !(greet != nil)
-!(greet != score)
-!(greet == add)
-!(greet == div)
 !(greet == greet)
-!(greet == half)
 !(greet == nil)
-!(greet == score)
-!(half != add)
-!(half != div)
-!(half != greet)
 !(half != half)
 !(half != nil)
-!(half != score)
-!(half == add)
-!(half == div)
-!(half == greet)
 !(half == half)
 !(half == nil)
-!(half == score)
 !(i != 0.5)
 !(i != 1)
 !(i != f32)
@@ -315,7 +302,6 @@
 !(i != nil)
 !(i < 0.5)
 !(i < 1)
-!(i < f32)
 !(i < f64)
 !(i < i)
 !(i < i32)
@@ -324,9 +310,7 @@
 !(i <= 1)
 !(i <= f32)
 !(i <= f64)
-!(i <= i)
 !(i <= i32)
-!(i <= i64)
 !(i == 0.5)
 !(i == 1)
 !(i == f32)
@@ -343,20 +327,23 @@
 !(i > i32)
 !(i > i64)
 !(i >= 0.5)
+!(i >= 1 * i64)
 !(i >= 1)
 !(i >= f32)
 !(i >= f64)
+!(i >= i)
 !(i >= i32)
 !(i >= i64)
 !(i in array)
+!(i not in array)
 !(i32 != 0.5)
 !(i32 != 1)
+!(i32 != f32)
 !(i32 != f64)
 !(i32 != i)
 !(i32 != i32)
 !(i32 != i64)
 !(i32 != nil)
-!(i32 * 0.5 != i32)
 !(i32 < 0.5)
 !(i32 < 1)
 !(i32 < f32)
@@ -373,6 +360,7 @@
 !(i32 <= i64)
 !(i32 == 0.5)
 !(i32 == 1)
+!(i32 == f32)
 !(i32 == f64)
 !(i32 == i)
 !(i32 == i32)
@@ -380,10 +368,10 @@
 !(i32 == nil)
 !(i32 > 0.5)
 !(i32 > 1)
+!(i32 > f32)
 !(i32 > f64)
 !(i32 > i)
 !(i32 > i32)
-!(i32 > i64)
 !(i32 >= 0.5)
 !(i32 >= 1)
 !(i32 >= f32)
@@ -399,12 +387,14 @@
 !(i64 != f64)
 !(i64 != i)
 !(i64 != i32)
+!(i64 != i64)
 !(i64 != nil)
 !(i64 < 0.5)
 !(i64 < 1)
 !(i64 < f32)
 !(i64 < f64)
 !(i64 < i)
+!(i64 < i32 + i64)
 !(i64 < i32)
 !(i64 < i64)
 !(i64 <= 0.5)
@@ -418,8 +408,8 @@
 !(i64 == 1)
 !(i64 == f32)
 !(i64 == f64)
-!(i64 == i)
 !(i64 == i32)
+!(i64 == i64)
 !(i64 == nil)
 !(i64 > 0.5)
 !(i64 > 1)
@@ -434,8 +424,9 @@
 !(i64 >= f64)
 !(i64 >= i)
 !(i64 >= i32)
+!(i64 >= i64)
 !(i64 in array)
-!(i64 not in array)
+!(len("bar") <= i)
 !(list != array)
 !(list != list)
 !(list != nil)
@@ -467,10 +458,12 @@
 !(nil == "foo")
 !(nil == 0.5)
 !(nil == 1)
+!(nil == add)
 !(nil == array)
 !(nil == div)
 !(nil == f32)
 !(nil == f64)
+!(nil == false)
 !(nil == foo)
 !(nil == greet)
 !(nil == half)
@@ -493,25 +486,21 @@
 !(ok && false)
 !(ok && ok)
 !(ok && true)
-!(ok == false)
 !(ok == nil)
 !(ok == ok)
+!(ok == true)
 !(ok and ok)
 !(ok and true)
+!(ok or false)
 !(ok or ok)
+!(ok or true)
 !(ok || false)
 !(ok || ok)
-!(score != add)
-!(score != div)
-!(score != greet)
-!(score != half)
+!(ok || true)
 !(score != nil)
 !(score != score)
-!(score == add)
-!(score == div)
-!(score == greet)
-!(score == half)
 !(score == nil)
+!(score == score)
 !(true != false)
 !(true != nil)
 !(true != ok)
@@ -523,10 +512,11 @@
 !(true == nil)
 !(true == ok)
 !(true == true)
-!(true and false)
 !(true and ok)
 !(true and true)
+!(true or ok)
 !(true or true)
+!(true || false)
 !(true || ok)
 !(true || true)
 !all(array, false)
@@ -535,445 +525,495 @@
 !all(list, false)
 !all(list, ok)
 !all(list, true)
-!any(array, false)
+!any(array, i == #)
 !any(array, ok)
 !any(array, true)
-!any(list, # != #)
+!any(list, false)
 !any(list, ok)
-!false && ok
-!false ? "bar" : i
-!false ? "foo" : false
-!false ? 0.5 : "bar"
-!false ? 0.5 : 1
-!false ? 0.5 : div
-!false ? 0.5 : i64
-!false ? 1 : add
-!false ? 1 : true
-!false ? add : array
-!false ? add : nil
-!false ? array : array
-!false ? div : 0.5
-!false ? div : foo
-!false ? div : map(list, #)
-!false ? div : nil
-!false ? f32 : 0.5
-!false ? f32 : greet
-!false ? f64 : 1
-!false ? f64 : half
-!false ? false : f32
-!false ? false : false
-!false ? foo : 1
-!false ? foo : i64
-!false ? greet : array
-!false ? greet : i32
-!false ? half : nil
-!false ? half : ok
-!false ? i : foo
-!false ? i32 : "foo"
-!false ? i64 : f32
-!false ? i64 : nil
-!false ? list : list
-!false ? nil : 1
+!any(list, true)
+!false != not true
+!false != ok
+!false && 0.5 == 1
+!false == ok
+!false ? "foo" : 0.5
+!false ? "foo" : f32
+!false ? 0.5 : "foo"
+!false ? 0.5 : f32
+!false ? 1 : half
+!false ? 1 : i
+!false ? add : f32
+!false ? add : i64
+!false ? array : add
+!false ? array : ok
+!false ? div : array
+!false ? div : greet
+!false ? div : half
+!false ? f32 : add
+!false ? f32 : false
+!false ? f64 : "foo"
+!false ? foo : "bar"
+!false ? half : 1
+!false ? half : add
+!false ? half : list
+!false ? half : true
+!false ? i : nil
+!false ? i32 : list
+!false ? i64 : foo
+!false ? i64 : i64
 !false ? nil : add
 !false ? nil : f64
 !false ? nil : foo
-!false ? ok : ok
-!false ? true : array
-!false and (true or false)
-!false and ok
-!false or 0.5 != 1
-!false || not false
-!hasSuffix("bar", "bar")
+!false ? nil : half
+!false ? ok : 1
+!false ? score : "bar"
+!false ? score : foo
+!false ? score : ok
+!false ? true : "foo"
+!false or 0.5 > i32
+!false or ok
+!false || ok
+!hasPrefix("foo", "foo")
+!none(array, # > #)
+!none(array, # >= #)
 !none(array, false)
-!none(array, true)
-!none(list, false)
+!none(array, ok)
 !none(list, ok)
 !none(list, true)
-!not (1 != i)
-!not (i64 != 0.5)
-!not any(list, ok)
+!not ("bar" == nil)
+!not (1 <= 1)
+!not (1 > 0.5)
+!not (greet == nil)
+!not (i32 == f64)
 !not false
+!not none(list, true)
 !not ok
 !not true
-!not true ? i64 : true
 !ok
+!ok != !true
 !ok != ok
-!ok && (ok || ok)
-!ok == !ok
+!ok && ok
 !ok == ok
-!ok ? "bar" : 0.5
-!ok ? "foo" : nil
-!ok ? 0.5 : "foo"
-!ok ? 1 : 0.5
-!ok ? 1 : 1
+!ok ? "bar" : "foo"
+!ok ? "bar" : foo
+!ok ? "foo" : 0.5
+!ok ? "foo" : list
+!ok ? 0.5 : 1
+!ok ? 0.5 : i
+!ok ? 1 : array
 !ok ? 1 : div
-!ok ? 1 : foo
-!ok ? 1 : greet
+!ok ? 1 : f64
+!ok ? 1 : list
 !ok ? 1 : ok
-!ok ? add : f32
-!ok ? add : false
-!ok ? add : i
-!ok ? add : score
-!ok ? f32 : "foo"
-!ok ? f32 : 1
-!ok ? f64 : i
-!ok ? false : "foo"
-!ok ? false : half
-!ok ? greet : "bar"
-!ok ? greet : add
-!ok ? greet : false
-!ok ? half : array
+!ok ? add : 0.5
+!ok ? array : div
+!ok ? array : f32
+!ok ? array : foo
+!ok ? array : i
+!ok ? array : i32
+!ok ? div : "foo"
+!ok ? div : 1
+!ok ? div : i
+!ok ? f32 : "bar"
+!ok ? f32 : add
+!ok ? f32 : false
+!ok ? f32 : greet
+!ok ? f64 : "bar"
+!ok ? f64 : "foo"
+!ok ? f64 : 0.5
+!ok ? f64 : half
+!ok ? f64 : score
+!ok ? false : ok
+!ok ? foo : "foo"
+!ok ? foo : f32
+!ok ? foo : false
+!ok ? foo : i32
+!ok ? greet : div
+!ok ? greet : list
+!ok ? greet : nil
+!ok ? half : f64
+!ok ? i : "bar"
+!ok ? i : array
+!ok ? i : div
 !ok ? i : foo
-!ok ? i : greet
-!ok ? i : true
-!ok ? i64 : list
-!ok ? list : "foo"
-!ok ? list : true
-!ok ? nil : i
-!ok ? nil : true
-!ok ? ok : 1
-!ok ? ok : i64
-!ok ? ok : score
-!ok ? score : array
-!ok ? score : i
-!ok ? true : greet
-!ok and i != f32
+!ok ? i32 : 0.5
+!ok ? i32 : f32
+!ok ? i32 : greet
+!ok ? i32 : nil
+!ok ? i64 : 0.5
+!ok ? i64 : 1
+!ok ? i64 : f32
+!ok ? i64 : true
+!ok ? list : f32
+!ok ? list : i
+!ok ? nil : 1
+!ok ? nil : array
+!ok ? ok : f32
+!ok ? ok : list
 !ok and ok
-!ok or none(array, ok)
+!ok or f32 < i64
+!ok or false or false
+!ok or ok
+!ok || ok
+!one(array, false)
 !one(array, ok)
 !one(array, true)
 !one(list, false)
 !one(list, ok)
 !one(list, true)
-!true != false ? ok : 0.5
-!true != nil == nil
-!true != ok
-!true && ok
-!true == ok
-!true ? "bar" : false
-!true ? "bar" : i
-!true ? "foo" : ok
-!true ? 0.5 : 1
-!true ? 0.5 : div
-!true ? 0.5 : i
-!true ? add : div
-!true ? add : greet
-!true ? array : foo
-!true ? array : i
-!true ? array : i64
-!true ? array : score
-!true ? div : f32
-!true ? div : ok
-!true ? f32 : 0.5
-!true ? f32 : add
-!true ? f32 : foo
-!true ? f32 : i32
-!true ? f64 : "bar"
+!reduce(array, false)
+!reduce(array, ok)
+!reduce(array, true)
+!reduce(list, # != #)
+!reduce(list, false)
+!reduce(list, ok)
+!reduce(list, true)
+!true != all(array, ok)
+!true ? "bar" : "foo"
+!true ? "bar" : true
+!true ? "foo" : "foo"
+!true ? "foo" : 0.5
+!true ? "foo" : i
+!true ? 1 : "foo"
+!true ? 1 : i64
+!true ? add : 0.5
+!true ? add : score
+!true ? array : f64
+!true ? array : list
+!true ? div : add
+!true ? f32 : false
 !true ? f64 : f64
-!true ? f64 : i32
 !true ? foo : 1
-!true ? greet : array
-!true ? greet : list
-!true ? half : add
-!true ? half : greet
-!true ? i32 : i64
-!true ? i64 : score
-!true ? list : div
+!true ? foo : array
+!true ? greet : ok
+!true ? greet : score
+!true ? greet : true
+!true ? half : f64
+!true ? i : 1
+!true ? i : add
+!true ? i : ok
+!true ? i32 : 1
+!true ? i64 : false
+!true ? i64 : i64
+!true ? i64 : list
+!true ? list : 0.5
+!true ? list : nil
 !true ? list : score
 !true ? nil : 0.5
-!true ? nil : f32
-!true ? nil : f64
-!true ? nil : foo
-!true ? nil : half
-!true ? nil : i
-!true ? ok : list
-!true ? score : array
-!true ? score : nil
-!true and ok
-!true or !false
-!true or nil != ok
+!true ? nil : false
+!true ? nil : ok
+!true ? ok : add
+!true ? ok : div
+!true ? score : false
+!true ? true : f32
+!true ? true : half
+!true and foo != nil
 !true || ok
+"bar" != "bar" || ok
 "bar" != foo.Bar
 "bar" != foo?.Bar
-"bar" != foo?.String()
-"bar" != nil and true ? i64 : 0.5
-"bar" + "foo" not endsWith greet("bar")
+"bar" + "bar" not in foo
 "bar" + foo.Bar
 "bar" + foo?.Bar
-"bar" + foo?.String()
 "bar" < foo.Bar
 "bar" < foo?.Bar
+"bar" < foo?.String()
 "bar" <= foo.Bar
 "bar" <= foo.String()
 "bar" <= foo?.Bar
 "bar" == foo.Bar
 "bar" == foo?.Bar
+"bar" == foo?.String()
+"bar" > "bar" or ok ? f32 : i64
 "bar" > foo.Bar
-"bar" > foo.String()
-"bar" > foo?.Bar
-"bar" contains "bar" == ok
-"bar" contains "foo" ? array : f64
+"bar" > foo?.String()
+"bar" >= foo.Bar
+"bar" >= foo.String()
+"bar" >= foo?.Bar
 "bar" contains foo.Bar
+"bar" contains foo.String()
 "bar" contains foo?.Bar
-"bar" contains foo?.String()
 "bar" endsWith foo.Bar
 "bar" endsWith foo?.Bar
 "bar" endsWith foo?.String()
-"bar" in foo || ok
-"bar" matches "bar" != ok
+"bar" matches "bar" and ok
 "bar" matches foo.Bar
+"bar" matches foo.String()
 "bar" matches foo?.Bar
+"bar" matches foo?.String()
 "bar" not contains foo.Bar
-"bar" not contains foo.String()
 "bar" not contains foo?.Bar
 "bar" not endsWith foo.Bar
 "bar" not endsWith foo?.Bar
 "bar" not endsWith foo?.String()
-"bar" not in list[i]
-"bar" not matches "foo" ? i32 < 0.5 : ok
 "bar" not matches foo.Bar
 "bar" not matches foo.String()
 "bar" not matches foo?.Bar
-"bar" not startsWith "foo" ? add : ok
+"bar" not matches foo?.String()
 "bar" not startsWith foo.Bar
 "bar" not startsWith foo?.Bar
+"bar" not startsWith foo?.String()
+"bar" startsWith "foo" or list == array
 "bar" startsWith foo.Bar
-"bar" startsWith foo?.Bar
-"foo" != "bar" != ok
+"bar" startsWith foo.String()
+"foo" != "foo" ? f64 : array
+"foo" != "foo" or ok
 "foo" != foo.Bar
+"foo" != foo.String()
 "foo" != foo?.Bar
 "foo" != foo?.String()
-"foo" + "foo" not in foo
+"foo" + "bar" not in foo
 "foo" + foo.Bar
-"foo" + foo.String()
 "foo" + foo?.Bar
 "foo" + foo?.String()
-"foo" < "bar" and i32 != 0.5
-"foo" < "foo" ? list : f32
+"foo" < "bar" and ok
 "foo" < foo.Bar
 "foo" < foo?.Bar
+"foo" < foo?.String()
 "foo" <= foo.Bar
 "foo" <= foo?.Bar
-"foo" == "foo" && i32 > 1
+"foo" == "bar" != ok
+"foo" == "bar" and ok
 "foo" == foo.Bar
-"foo" == foo.String()
+"foo" == foo?.Bar
 "foo" == foo?.String()
-"foo" == nil ? foo : f64
-"foo" > "bar" && ok
-"foo" > "foo" == not false
+"foo" > foo.Bar
+"foo" > foo.String()
 "foo" > foo?.Bar
-"foo" > foo?.String()
 "foo" >= foo.Bar
+"foo" >= foo.String()
 "foo" >= foo?.Bar
-"foo" contains foo.Bar
+"foo" >= foo?.String()
+"foo" contains "bar" == ok
 "foo" contains foo?.Bar
 "foo" endsWith foo.Bar
-"foo" endsWith foo.String()
 "foo" endsWith foo?.Bar
-"foo" endsWith foo?.String()
-"foo" in foo && nil == 1
-"foo" matches "bar" ? f64 > f64 : half
+"foo" matches "bar" ? add : div
+"foo" matches "foo" || true ? greet : "bar"
 "foo" matches foo.Bar
 "foo" matches foo.String()
 "foo" matches foo?.Bar
 "foo" not contains foo.Bar
 "foo" not contains foo?.Bar
+"foo" not contains foo?.String()
 "foo" not endsWith foo.Bar
 "foo" not endsWith foo?.Bar
-"foo" not endsWith foo?.String()
 "foo" not matches foo.Bar
-"foo" not matches foo.String()
 "foo" not matches foo?.Bar
+"foo" not matches foo?.String()
 "foo" not startsWith foo.Bar
+"foo" not startsWith foo?.Bar
 "foo" not startsWith foo?.String()
 "foo" startsWith foo.Bar
 "foo" startsWith foo?.Bar
-"foo" startsWith foo?.String()
-("bar" not endsWith "bar") and i64 < i32
-("bar" not endsWith "foo") == ok
-("bar" not in foo) == ok
-("foo" not matches "bar") and false ? f64 : array
-(0.5 * 0.5) ** f32
+("bar" not endsWith "bar") != ok
+("bar" not endsWith "foo") != ok
+("bar" not endsWith "foo") && false != nil
+("bar" not matches "foo") || reduce(list, ok)
+("foo" not matches "bar") == ok
 (0.5 * 0.5) ** i
-(0.5 * 0.5) ** i64
 (0.5 * 0.5) ^ f32
-(0.5 * 0.5) ^ i32
-(0.5 * f32) ** i
+(0.5 * 1) ** f64
+(0.5 * 1) ** i
+(0.5 * 1) ^ i32
 (0.5 * f64) ^ f32
-(0.5 * i32) ** f32
-(0.5 + 1) * i
-(0.5 + 1) ** i64
-(0.5 + 1) / i
+(0.5 * i) ^ i
+(0.5 + 0.5) * f32
+(0.5 + 0.5) ^ i32
+(0.5 + 1) ^ i
+(0.5 + f64) * f64
+(0.5 + f64) / i32
+(0.5 + i) ** i
+(0.5 + i) ^ i
+(0.5 + i64) ** f32
 (0.5 + i64) / f32
-(0.5 - 0.5) ^ half(f64)
-(0.5 - 1) * i64
-(0.5 - 1) ** i64
-(0.5 - f32) ** (0.5 * f64)
-(0.5 - f64) * f64
+(0.5 + i64) / i
+(0.5 - 0.5) * (i32 - 0.5)
+(0.5 - 0.5) * i64
+(0.5 - 0.5) ** f32
+(0.5 - 1) * i32
+(0.5 - 1) ** f64
+(0.5 - 1) ^ i64
+(0.5 - f32) ** i
+(0.5 - f64) * i
 (0.5 - f64) / f32
+(0.5 - f64) / f64
 (0.5 - i) ^ f32
-(0.5 - i32) ** i64
-(0.5 - i32) ^ f64
+(0.5 - i32) ** (i32 * 1)
+(0.5 - i32) / f64
+(0.5 - i32) ^ f32
+(0.5 - i64) * i
+(0.5 - i64) / f64
+(0.5 - i64) / i64
+(0.5 / 0.5) ** f32
+(0.5 / 0.5) ** i32
 (0.5 / 0.5) ^ f64
-(0.5 / f32) ** f32
-(0.5 / f32) ^ i32
-(0.5 / f64) ** i
-(0.5 / f64) ** i32
+(0.5 / 1) ^ f32
+(0.5 / i) ** f64
+(0.5 / i) ** i
 (0.5 / i32) ** i
-(0.5 / i64) ** f32
-(1 % i) ** f32
-(1 % i) ^ i
-(1 % i64) ** f32
-(1 * 1) ** f64
-(1 * 1) ^ i
-(1 * f32) ** f32
-(1 * i32) ** i
-(1 * i64) ** i32
-(1 + 0.5) * f64
-(1 + 0.5) ^ i32
-(1 + 1) / i32
-(1 + 1) ^ i
-(1 + f32) / f32 / i64
-(1 + f64) ** i64
-(1 + f64) / i32
-(1 + f64) ^ f64
-(1 + i32) / f32
-(1 + i64) / f64
-(1 - 0.5) / f64
-(1 - 0.5) ^ i32
-(1 - 1) * i
-(1 - 1) * i32
-(1 - 1) ** f32
-(1 - 1) / i
-(1 - f64) * 1 * i
-(1 - f64) ^ i32
-(1 - i) ** i
-(1 - i) / i64
-(1 - i32) ** i ^ 0.5
-(1 - i64) % i64
-(1 / 0.5) ^ f32
-(1 / 0.5) ^ f64
-(1 / 1) ** i32
-(1 / 1) ^ i32
-(1 / f64) ** f64
-(1 / i) ** i64
-(1 not in array) and none(list, true)
-(f32 * 1) ** f32
-(f32 * 1) ** i64
-(f32 * i) ^ i64
-(f32 * i32) ** i
-(f32 * i64) ** i64
-(f32 * i64) ^ i
-(f32 + 0.5) / 0.5 ** 0.5
-(f32 + 1) ** i
-(f32 + 1) / i
-(f32 + 1) / i64
-(f32 + i32) ** i64
-(f32 + i64) ** i32
-(f32 - 0.5) * f64
-(f32 - 0.5) * i
-(f32 - f32) ** f32
-(f32 - i) / f64
-(f32 - i) ^ i64
-(f32 - i64) * i64
-(f32 - i64) ** i64
-(f32 - i64) / i64
-(f32 / f64) ^ f32
-(f32 / f64) ^ i
-(f32 / i32) ^ i32
-(f64 * 0.5) ^ i
-(f64 * f64) ** i32
+(0.5 / i32) ^ f32
+(1 * 0.5) ** (f64 * 1)
+(1 * 0.5) ** i32
+(1 * 0.5) ^ f64
+(1 * 1) ^ -1
+(1 * 1) ^ f32
+(1 * f32) ^ i32
+(1 * i) ** i32
+(1 * i32) ^ i
+(1 * i64) ** i64
+(1 + 0.5) ** i
+(1 + 1) * i64
+(1 + 1) / i
+(1 + f32) ^ i
+(1 + f64) ^ i
+(1 + f64) ^ i32
+(1 + i) ** f32
+(1 + i) / f64
+(1 + i) ^ i64
+(1 + i32) * f64
+(1 + i32) ^ f64
+(1 - 0.5) * f32 ^ 1
+(1 - 0.5) * i64
+(1 - 0.5) / i
+(1 - 0.5) ^ min(f32)
+(1 - f32) * f32
+(1 - f64) ** f64
+(1 - i) * -i32
+(1 - i32) ^ f32
+(1 - i32) ^ i
+(1 - i64) ** f32
+(1 - i64) / f64
+(1 - i64) / i64
+(1 / 0.5) ** f32
+(1 / 0.5) ^ i32
+(1 / 1) ** (f64 * 0.5)
+(1 / 1) ^ ceil(i64)
+(1 / 1) ^ max(0.5)
+(1 / f32) ^ f32
+(1 / i) ^ f32
+(1 / i32) ^ i
+(1 / i64) ** i64
+(f32 * 0.5) ** f64
+(f32 * 0.5) ^ i32
+(f32 * f32) ^ -f32
+(f32 * f32) ^ i
+(f32 * i) ^ -1
+(f32 * i64) ** i
+(f32 + f64) * i
+(f32 + i) ^ f64
+(f32 - 0.5) / f64
+(f32 - 0.5) ^ f32
+(f32 - 1) / f64
+(f32 - 1) ^ f64
+(f32 - f32) / i64
+(f32 - i32) * i64
+(f32 / 0.5) ^ f32
+(f32 / i64) ^ f64
+(f64 * 0.5) ** f32
+(f64 * 0.5) ** i64
+(f64 * f32) ** f64
+(f64 * i64) ** f64
 (f64 * i64) ** i32
-(f64 + f32) ** i64
-(f64 + i32) * f32
-(f64 + i64) / i32
-(f64 - 0.5) * -i
-(f64 - 0.5) * i
-(f64 - 0.5) / f32
-(f64 - 0.5) / i64
-(f64 - 0.5) ^ i
-(f64 - 0.5) ^ i64
-(f64 - 1) * f32
-(f64 - f32) * i64
-(f64 - f64) / i32
-(f64 - i) * i32 ** 1
-(f64 - i64) / i64
-(f64 / 0.5) ** f64
-(f64 / i) ^ i64
-(false || ok) and ok
-(i % 1) ** -f32
-(i % 1) ** f64
-(i % i) ** f32
-(i * 1) ** i
-(i * f32) ** i32
-(i * f32) ^ f64
-(i * i) ^ count(array, true)
-(i + 0.5) ** i32
-(i + 0.5) ^ f32
-(i + 1) % i32
+(f64 + 0.5) * f32
+(f64 + 0.5) * i64
+(f64 + f32) ** get(array, i)
+(f64 + f32) ** i32
+(f64 + f64) * (i64 - i64)
+(f64 + f64) ^ f64
+(f64 + i) * (0.5 + i64)
+(f64 + i32) ^ i64
+(f64 + i64) ^ i
+(f64 - 0.5) ** f64
+(f64 - 1) ** i64
+(f64 - 1) ^ i32
+(f64 - f32) ** i
+(f64 - f32) ^ i64
+(f64 - i) * i32
+(f64 - i32) / i
+(f64 - i64) ** i
+(f64 - i64) / f32
+(f64 - i64) / f64
+(f64 / 1) ** i64
+(f64 / f32) ^ i
+(f64 / f64) ** i32
+(f64 / f64) ^ i32 ** 0.5
+(false || ok) == ok
+(i % i) ^ i
+(i % i32) ^ (1 - i32)
+(i % i64) ^ f64
+(i * 0.5) ** f32
+(i * 1) ^ f64
+(i * 1) ^ i
+(i * i64) ** f32
+(i + 0.5) ** half(f64)
+(i + 1) % i64
 (i + 1) / i64
-(i + f64) ^ (f32 * f64)
-(i + i) * -f64
-(i + i32) ^ i64
-(i - 0.5) / f32
-(i - 0.5) ^ f64
-(i - 1) ** i64
-(i - 1) / f32
-(i - 1) ^ f64
-(i - i64) ** f64
-(i - i64) ^ i
-(i / 0.5) ^ i32
-(i / 1) ** f64
-(i / 1) ** i64
-(i / i32) ^ f32
-(i < i32 ? nil : f64) ** f64
-(i32 * 1) ** f32
-(i32 * f32) ^ i64
-(i32 * i) ^ i
-(i32 * i32) ** f64
-(i32 + 0.5) / f64
-(i32 + 0.5) ^ i64
-(i32 + 1) * f64
-(i32 + 1) ** float(1)
-(i32 + 1) / i
-(i32 + 1) / i64
-(i32 + f32) ** f32
-(i32 + f64) ** i
-(i32 + i32) * i32
-(i32 + i32) / i64
-(i32 + i64) ^ i
-(i32 - 0.5) * i64
-(i32 - f32) * i32
-(i32 - i32) ** i
-(i32 - i32) ** i64
-(i32 / 0.5) ^ i32
-(i32 / i32) ^ f32
-(i32 / i32) ^ i
-(i64 * 0.5) ^ f32
-(i64 * 1) ** i64
-(i64 * 1) ^ f32
-(i64 * 1) ^ f64
-(i64 * f32) ** findIndex(list, ok)
-(i64 + 1) * i32
-(i64 + f32) ^ f64
-(i64 + f64) / 1 * 1
-(i64 + f64) ^ f64
-(i64 + i) ^ i64
-(i64 + i32) * f32
-(i64 - 0.5) * i64
-(i64 - 0.5) / i32
-(i64 - i) % i32
-(i64 - i32) / len(array)
-(i64 - i64) / i64
-(i64 / f64) ** f32
-(i64 / i32) ** f32
-(i64 / i32) ** i
-(i64 / i32) ^ -1
-(i64 not in array) && ok
-(ok && ok) == ok
-(ok or false) and ok
-(ok or ok) == not false
-(ok || true) && i32 >= f64
+(i + i) ^ i64
+(i + i32) * i64 ^ f64
+(i + i32) / i32
+(i + i32) ^ f32
+(i + i64) ^ i32
+(i - 0.5) / i64
+(i - 1) ^ i64
+(i / 0.5) ** f32
+(i / f32) ^ f64
+(i32 % 1) ** f32
+(i32 % i) ** f32
+(i32 % i32) ** i32
+(i32 % i32) ^ i32
+(i32 * 0.5) ^ f32
+(i32 * 1) ^ i32
+(i32 + 0.5) ** i64
+(i32 + f32) * i64
+(i32 + f64) / i
+(i32 + i) / i
+(i32 + i32) ^ i32
+(i32 - 0.5) * f64
+(i32 - 0.5) / i64
+(i32 - 1) ^ f64
+(i32 - f32) / i64
+(i32 - i) % i64
+(i32 - i) / f32
+(i32 - i32) ^ (i32 * i)
+(i32 - i64) * i32
+(i32 - i64) * i32 * i64
+(i32 / i) ** f32
+(i32 / i) ^ i64
+(i32 < f64 ? nil : i) .. i32
+(i32 not in array) and ok
+(i64 % i) ** f32
+(i64 * 0.5) ^ f64
+(i64 * f32) ^ i64
+(i64 * f64) ^ i32
+(i64 * i) ** score(1)
+(i64 * i64) ** i ** 0.5
+(i64 * i64) ^ i
+(i64 + 0.5) * f32
+(i64 + 0.5) ** i64
+(i64 + 1) % i
+(i64 + 1) ^ i
+(i64 + f32) * -i32
+(i64 + f32) ** i32
+(i64 + f32) / f64
+(i64 + f32) / i
+(i64 + f32) / i32
+(i64 + f64) * i32
+(i64 + i) % i64
+(i64 + i) / f64
+(i64 + i32) * i64
+(i64 + i64) / i64
+(i64 - 0.5) / f64
+(i64 - 0.5) ^ i64
+(i64 - 1) ^ i32
+(i64 - f32) ** f64
+(i64 - f32) ^ i64
+(i64 - i) ** i
+(i64 - i32) * i64
+(i64 / 1) ** f32
+(i64 / f64) ** i32
+(nil not in array) || ok
+(ok || true) && (ok or true)
+-((i64 + 1) % i32)
 -(0.5 * 0.5)
 -(0.5 * 1)
 -(0.5 * f32)
@@ -1003,7 +1043,6 @@
 -(0.5 - i32)
 -(0.5 - i64)
 -(0.5 / 0.5)
--(0.5 / 0.5) < i32
 -(0.5 / 1)
 -(0.5 / f32)
 -(0.5 / f64)
@@ -1024,6 +1063,7 @@
 -(1 * 0.5)
 -(1 * 1)
 -(1 * f32)
+-(1 * f64)
 -(1 * i)
 -(1 * i32)
 -(1 * i64)
@@ -1081,12 +1121,10 @@
 -(f32 + f32)
 -(f32 + f64)
 -(f32 + i)
--(f32 + i32)
 -(f32 + i64)
 -(f32 - 0.5)
 -(f32 - 1)
--(f32 - f64)
--(f32 - i - f32)
+-(f32 - f32)
 -(f32 - i)
 -(f32 - i32)
 -(f32 - i64)
@@ -1100,6 +1138,7 @@
 -(f32 ^ 0.5)
 -(f32 ^ 1)
 -(f32 ^ f32)
+-(f32 ^ f64)
 -(f32 ^ i)
 -(f32 ^ i32)
 -(f32 ^ i64)
@@ -1116,7 +1155,6 @@
 -(f64 ** f64)
 -(f64 ** i)
 -(f64 ** i32)
--(f64 ** i32) > i32
 -(f64 ** i64)
 -(f64 + 0.5)
 -(f64 + 1)
@@ -1129,14 +1167,12 @@
 -(f64 - f32)
 -(f64 - f64)
 -(f64 - i)
--(f64 - i32)
 -(f64 - i64)
 -(f64 / 0.5)
 -(f64 / 1)
 -(f64 / f32)
 -(f64 / f64)
 -(f64 / i)
--(f64 / i32)
 -(f64 / i64)
 -(f64 ^ 0.5)
 -(f64 ^ 1)
@@ -1149,7 +1185,6 @@
 -(i % i)
 -(i % i32)
 -(i % i64)
--(i % score(1))
 -(i * 0.5)
 -(i * 1)
 -(i * f32)
@@ -1157,37 +1192,38 @@
 -(i * i)
 -(i * i32)
 -(i * i64)
+-(i ** 0.5)
 -(i ** 1)
--(i ** f32)
 -(i ** f64)
 -(i ** i)
 -(i ** i32)
 -(i ** i64)
--(i ** int(i))
 -(i + 0.5)
 -(i + 1)
--(i + f32)
--(i + f64)
--(i + i)
+-(i + i32)
 -(i + i64)
 -(i - 0.5)
 -(i - 1)
 -(i - f32)
 -(i - f64)
+-(i - i ** 1)
 -(i - i)
 -(i - i32)
+-(i - i64)
 -(i / 0.5)
 -(i / 1)
 -(i / f32)
 -(i / f64)
 -(i / i)
 -(i / i32)
+-(i / i64)
 -(i ^ 0.5)
 -(i ^ 1)
 -(i ^ f32)
 -(i ^ f64)
 -(i ^ i)
--(i32 % 1 % i)
+-(i ^ i32)
+-(i ^ i64)
 -(i32 % 1)
 -(i32 % i)
 -(i32 % i32)
@@ -1202,11 +1238,11 @@
 -(i32 ** 0.5)
 -(i32 ** 1)
 -(i32 ** f32)
+-(i32 ** f64)
 -(i32 ** i)
 -(i32 ** i32)
 -(i32 ** i64)
 -(i32 + 0.5)
--(i32 + 1 ^ i64)
 -(i32 + 1)
 -(i32 + f32)
 -(i32 + f64)
@@ -1222,7 +1258,6 @@
 -(i32 - i64)
 -(i32 / 0.5)
 -(i32 / 1)
--(i32 / f32)
 -(i32 / f64)
 -(i32 / i)
 -(i32 / i32)
@@ -1232,6 +1267,8 @@
 -(i32 ^ f32)
 -(i32 ^ f64)
 -(i32 ^ i)
+-(i32 ^ i32)
+-(i32 ^ i64)
 -(i64 % 1)
 -(i64 % i)
 -(i64 % i32)
@@ -1254,17 +1291,16 @@
 -(i64 + 1)
 -(i64 + f32)
 -(i64 + f64)
--(i64 + i)
 -(i64 + i32)
 -(i64 + i64)
 -(i64 - 0.5)
 -(i64 - 1)
+-(i64 - f32)
 -(i64 - f64)
 -(i64 - i)
 -(i64 - i32)
 -(i64 - i64)
 -(i64 / 0.5)
--(i64 / 1 / 1)
 -(i64 / 1)
 -(i64 / f32)
 -(i64 / f64)
@@ -1278,248 +1314,285 @@
 -(i64 ^ i)
 -(i64 ^ i32)
 -(i64 ^ i64)
--(max(0.5) + i64)
---(1 * i64)
---(i64 * 1)
----1
----i
+-(max(f32) ^ i32)
+-(min(0.5) ^ i32)
+--(f64 ** 0.5)
+--(i64 ** i64)
 --0.5
 --1
---abs(f64)
+--ceil(1)
 --f32
 --f64
+--f64 ** i64
+--float(f64)
 --i
 --i32
 --i64
---max(0.5)
--0.5 != 1 ? array : f64
 -0.5 != f32
--0.5 != f64 ** 0.5
 -0.5 != i32
--0.5 != max(i64)
+-0.5 * 1 ** 1
+-0.5 * f32
 -0.5 * f64
--0.5 * i
 -0.5 * i32
 -0.5 * i64
--0.5 * len(array)
+-0.5 ** -1
+-0.5 ** ceil(i)
 -0.5 ** f32
+-0.5 ** f64
 -0.5 ** i
 -0.5 ** i32
 -0.5 ** i64
--0.5 + f32
 -0.5 + f64
--0.5 + f64 / f64
 -0.5 + i
 -0.5 + i32
--0.5 - -i32
--0.5 - 1 + 1
+-0.5 + i64
+-0.5 - abs(i)
 -0.5 - f32
 -0.5 - f64
 -0.5 - i
 -0.5 - i32
--0.5 - i32 * i
--0.5 / (f32 + 0.5)
--0.5 / -i32
+-0.5 - i64
 -0.5 / f32
--0.5 / f64
--0.5 / float(f64)
 -0.5 / i
--0.5 / i64
--0.5 / i64 ** 1
--0.5 < f32
--0.5 < f64
+-0.5 / i32
 -0.5 < i32
--0.5 < i32 ? false : "bar"
--0.5 < i32 ^ f64
--0.5 <= 1 == false
+-0.5 < i64
+-0.5 <= 0.5 + 0.5
 -0.5 <= f32
--0.5 <= f64
--0.5 <= f64 + f32
+-0.5 <= i
+-0.5 <= i32
 -0.5 <= i64
 -0.5 == f32
--0.5 == f64 / 0.5
+-0.5 == f64
 -0.5 == i
 -0.5 == i32
+-0.5 == i32 ^ i32
 -0.5 == i64
 -0.5 > f32
--0.5 > f64
--0.5 > i32
--0.5 > i64
+-0.5 > i
+-0.5 >= f32
+-0.5 >= f32 ? f32 : i32
 -0.5 >= f64
 -0.5 >= i
 -0.5 >= i32
 -0.5 >= i64
 -0.5 ^ f32
 -0.5 ^ f64
--0.5 ^ i
+-0.5 ^ float(f64)
 -0.5 ^ i32
 -0.5 ^ i64
+-0.5 in array
+-0.5 not in sort(array)
+-1 != -i
+-1 != f32
 -1 != f64
--1 != i
+-1 != i32
 -1 != i64
--1 != i64 * f32
+-1 % i
 -1 % i32
--1 % i64
--1 * 1 ** i64
+-1 * array[i]
 -1 * f32
+-1 * f64
+-1 * i
 -1 * i32
 -1 * i64
+-1 ** (f32 + f32)
+-1 ** (i + i64)
+-1 ** ceil(0.5)
 -1 ** f32
+-1 ** f64
 -1 ** i
--1 ** i64
--1 + 1 + 0.5
+-1 ** i64 ^ 1
+-1 + -i32
 -1 + f32
--1 + half(f64)
+-1 + f64
 -1 + i
+-1 + i32
 -1 + i64
--1 - f32
+-1 + reduce(array, #)
+-1 + reduce(list, f32)
+-1 - f64
 -1 - i
+-1 - i % i32
 -1 - i32
 -1 - i64
 -1 .. i
--1 .. i32
 -1 .. i64
--1 / 1 * 1
 -1 / f32
+-1 / f64
+-1 / i
 -1 / i32
--1 < 0.5 ^ i64
--1 < f32
--1 < f64 * 1
--1 < i32
+-1 < f64
+-1 < i
 -1 < i64
--1 <= f32
--1 <= f32 == true
+-1 <= -1
 -1 <= f64
+-1 <= i
 -1 <= i32
+-1 <= i64
 -1 == f32
 -1 == f64
--1 == nil != nil
--1 > -i32
+-1 == floor(f64)
+-1 == i
+-1 == i32
+-1 == i64
 -1 > f32
--1 > half(0.5)
 -1 > i
--1 > i32
 -1 > i64
--1 > i64 ? array : nil
--1 >= 0.5 * 0.5
--1 >= f32
+-1 >= f32 * f32
 -1 >= f64
 -1 >= i32
--1 >= i32 - 1
 -1 >= i64
 -1 ^ f32
 -1 ^ f64
+-1 ^ i32
 -1 ^ i64
 -1 in array
 -1 not in array
--abs(0.5 * f64)
 -abs(0.5)
 -abs(1)
--abs(1) .. i
 -abs(f32)
 -abs(f64)
 -abs(i)
 -abs(i32)
 -abs(i64)
--add(1, 1)
 -add(i, 1)
+-add(i, i)
 -array[1]
 -array[i32]
 -array[i64]
 -array[i]
+-bitand(i64, i32)
+-bitnand(1, i)
+-bitnot(1)
+-bitnot(i)
+-bitnot(i32)
+-bitnot(i64)
+-bitor(1, i64)
+-bitor(i, i32)
+-bitshl(i, 1)
+-bitshl(i, i32)
+-bitshl(i, i64)
+-bitshl(i64, i32)
+-bitshr(i, i)
+-bitshr(i64, i32)
+-bitushr(i, i32)
+-bitxor(1, 1)
+-bitxor(i, i32)
+-ceil(0.5)
+-ceil(1)
+-ceil(f32)
+-ceil(f64)
+-ceil(i)
+-ceil(i32)
+-ceil(i64)
 -count(array, false)
 -count(array, ok)
 -count(array, true)
 -count(list, ok)
 -count(list, true)
 -div(1, 1)
--div(1, i)
--div(i, i)
 -f32
--f32 != 1 / i
--f32 != f32
--f32 != f64
--f32 != i64
--f32 * 1 ** i32
--f32 * f32
+-f32 != i32
+-f32 * i64
+-f32 ** (i + 1)
 -f32 ** f32
--f32 ** f32 ** 1
+-f32 ** f64
+-f32 ** i
+-f32 ** i32
 -f32 ** i64
--f32 + f32
 -f32 + i32
--f32 + i64
--f32 - f32
--f32 - f64
 -f32 - i
--f32 - i32
--f32 - i64
+-f32 - round(i)
 -f32 / f32
--f32 / i32
--f32 / i64
+-f32 / f64
+-f32 / i
+-f32 < f32 ** 0.5
 -f32 < f64
+-f32 < i
 -f32 < i32
--f32 < i64
+-f32 <= f32
 -f32 <= i
 -f32 <= i32
+-f32 <= i64
 -f32 == f32
 -f32 == f64
--f32 == i
--f32 == i32
--f32 == i64
+-f32 > 0.5 ? f32 : "bar"
 -f32 > f32
 -f32 > f64
--f32 > i
--f32 > i64
--f32 >= 1 / f32
 -f32 >= f32
 -f32 >= f64
 -f32 >= i64
--f32 ^ f32
--f32 ^ f64
+-f32 ^ i
+-f32 ^ i32
 -f32 ^ i64
--f32 ^ min(f64)
+-f32 in array
+-f32 not in array
 -f64
+-f64 != f32
 -f64 != f64
 -f64 != i
--f64 != i64
+-f64 != i32
+-f64 * -1
+-f64 * -f64
+-f64 * f32
 -f64 * f64
+-f64 * i
+-f64 * i32
+-f64 * i64
+-f64 ** 0.5 ** f32
 -f64 ** f32
+-f64 ** i
 -f64 ** i32
--f64 ** i64
 -f64 + f32
--f64 + i32
 -f64 + i64
--f64 - 0.5 / i32
--f64 - f64
+-f64 - 0.5 / i64
+-f64 - f32
+-f64 - i
 -f64 - i32
+-f64 - i64
+-f64 - int(f64)
+-f64 / f32
 -f64 / f64
 -f64 / i
+-f64 / i32
 -f64 / i64
--f64 < f32
+-f64 < 0.5 ^ f32
+-f64 < f64
+-f64 < f64 ** 1
+-f64 < half(0.5)
+-f64 < half(f64)
 -f64 < i
+-f64 < i ^ f32
+-f64 < i32
+-f64 < i64
 -f64 <= f32
 -f64 <= f64
--f64 <= i32
--f64 == f32
+-f64 == f64
 -f64 == i
 -f64 == i32
+-f64 == i64
+-f64 > f32
+-f64 > f32 ? false : array
 -f64 > f64
 -f64 > i32
 -f64 > i64
+-f64 >= f32
+-f64 >= f32 / f64
 -f64 >= f64
--f64 >= f64 ^ 0.5
--f64 >= i
--f64 ^ 0.5 ** i64
+-f64 >= i32
 -f64 ^ f32
 -f64 ^ f64
--f64 ^ i
--f64 ^ i32
 -f64 ^ i64
+-f64 not in array
 -find(array, ok)
 -find(array, true)
+-findIndex(array, # <= #)
 -findIndex(array, ok)
 -findIndex(array, true)
 -findIndex(list, ok)
+-findIndex(list, true)
+-findLast(array, # <= #)
 -findLast(array, ok)
 -findLast(array, true)
 -findLastIndex(array, ok)
@@ -1527,847 +1600,968 @@
 -findLastIndex(list, ok)
 -findLastIndex(list, true)
 -first(array)
--float(-1)
+-float(0.5 ** 0.5)
+-float(0.5 ^ 0.5)
 -float(0.5)
 -float(1)
--float(f32 ** 0.5)
+-float(bitnot(i64))
 -float(f32)
 -float(f64)
 -float(i)
 -float(i32)
 -float(i64)
+-floor(0.5)
+-floor(1)
+-floor(f32)
+-floor(f64)
+-floor(i)
+-floor(i32)
+-floor(i64)
 -get(array, 1)
 -get(array, i)
 -get(array, i32)
 -get(array, i64)
+-half(-0.5)
 -half(-1)
 -half(0.5)
+-half(1)
+-half(f32 + i64)
 -half(f64)
+-half(median(array))
 -i
+-i != f32
 -i != f64
+-i != f64 ? foo : 1
+-i != i
+-i != i + f64
 -i != i32
--i != i32 * 1
 -i != i64
--i % i
 -i % i32
 -i % i64
--i * f32
+-i * abs(0.5)
 -i * f64
--i * i32
+-i * i
 -i * i64
+-i * reduce(array, 0.5)
 -i ** f32
 -i ** f64
--i ** i32
--i ** i64
+-i ** i
 -i + f32
--i + i
+-i + f64
 -i + i32
--i + i64
+-i + i64 * 1
 -i - f32
--i - f64
--i - i
 -i - i64
--i .. i32
--i / f64
--i / i
--i / i32
+-i .. i
+-i .. i64
+-i / f32
 -i / i64
 -i < f32
+-i < half(1)
+-i < i
 -i < i64
+-i <= 0.5 ? half : "bar"
+-i <= 1 - 0.5
 -i <= f32
+-i <= i
 -i <= i32
--i == -0.5
--i == 1 ** f64
--i == 1 + 0.5
+-i <= i64
+-i <= i64 ** 0.5
+-i == f32
+-i == f64
+-i == f64 ^ f32
+-i == i
+-i == i32
 -i > f32
 -i > i
 -i > i32
 -i >= f32
--i >= i32
--i ^ -i
+-i >= f64
+-i >= i
+-i >= i64
+-i >= score(1)
+-i ^ 0.5 ** 0.5
+-i ^ f32
+-i ^ f32 ^ 0.5
 -i ^ f64
--i ^ i32
+-i ^ i
+-i ^ i64
+-i in array
 -i not in array
 -i32
 -i32 != f32
--i32 != f64
 -i32 != i
+-i32 != i32 ** 1
 -i32 != i64
+-i32 % i
 -i32 % i32
 -i32 % i64
--i32 * f32
--i32 * f64
 -i32 * i
 -i32 * i32
+-i32 * i64
+-i32 ** f32
 -i32 ** f64
--i32 ** i32
 -i32 ** i64
--i32 + 1 + i
 -i32 + f32
--i32 + f64
 -i32 + i
 -i32 + i32
--i32 - i32
--i32 - i64
--i32 .. i
--i32 .. i64
--i32 / (i32 - f64)
--i32 / f64
--i32 / i
--i32 < 0.5 * 1
--i32 < f32
--i32 < f64 - f64
+-i32 - f32
+-i32 .. i32
+-i32 / i32
+-i32 / i64
+-i32 < i
 -i32 < i32
 -i32 < i64
--i32 <= 0.5 ? f64 : 1
--i32 <= f32
+-i32 < round(f64)
 -i32 <= f64
--i32 <= f64 + i
+-i32 <= i
+-i32 <= i32
+-i32 <= i64
+-i32 == 1 % i
 -i32 == f32
--i32 == i32
+-i32 == f64
+-i32 == i64
+-i32 == max(1)
+-i32 > f32
+-i32 > f64
 -i32 > i
+-i32 > i ** 0.5
 -i32 > i32
 -i32 > i64
--i32 >= f32
 -i32 >= f64
--i32 >= i64
--i32 ^ (i - 0.5)
--i32 ^ i
+-i32 >= i
+-i32 >= i == nil
+-i32 >= i32
+-i32 ^ f32
 -i32 ^ i32
 -i32 ^ i64
--i32 ^ i64 ** i32
+-i32 ^ score(1)
 -i32 in array
--i32 not in array
 -i64
--i64 != i
--i64 != i ? i : foo
+-i64 != f32
+-i64 != f64
+-i64 != i32
 -i64 != i64
--i64 % i
--i64 % i32
+-i64 != i64 ? score : foo
+-i64 * (1 + f64)
 -i64 * f32
--i64 * f64
 -i64 * i
 -i64 * i32
 -i64 * i64
--i64 ** f64
--i64 ** i64
--i64 + 0.5 * i32
--i64 + f64
+-i64 * indexOf("foo", "bar")
+-i64 ** i
+-i64 ** i32
+-i64 + f32
 -i64 + i
+-i64 + i32
+-i64 + i64
 -i64 - f32
--i64 - f64
+-i64 - i
 -i64 - i32
--i64 - i64
 -i64 .. i
 -i64 .. i32
--i64 / f32
--i64 / i
--i64 / i64
--i64 / i64 * f32
--i64 < -0.5
+-i64 .. i64
+-i64 / f64
+-i64 / i32
 -i64 < f32
 -i64 < f64
--i64 < i
+-i64 < half(f64)
 -i64 < i32
 -i64 < i64
+-i64 <= i
 -i64 <= i32
--i64 <= i64
+-i64 == 1 ^ i64
 -i64 == f32
+-i64 == f64
 -i64 == i
 -i64 == i32
--i64 == i64
 -i64 > f32
 -i64 > f64
+-i64 > i
 -i64 > i32
+-i64 >= f32
 -i64 >= i
 -i64 >= i32
--i64 >= i64
 -i64 ^ f64
+-i64 ^ float(i)
+-i64 ^ i
 -i64 ^ i32
 -i64 ^ i64
+-i64 in array
 -i64 not in array
--i64 not in sort(array)
 -int(0.5)
 -int(1)
 -int(f32)
 -int(f64)
 -int(i)
 -int(i32)
--int(i64 - i)
 -int(i64)
--int(int(1))
 -last(array)
 -len("bar")
 -len("foo")
--len([foo])
 -len(array)
--len(false ? greet : "foo")
 -len(list)
--max(0.5 * i)
 -max(0.5)
--max(0.5, 1)
+-max(0.5, 0.5, f64)
 -max(1)
 -max(f32)
--max(f32, 0.5, f32)
--max(f32, i64)
 -max(f64)
 -max(i)
--max(i, 1)
--max(i, i64)
+-max(i, 0.5)
+-max(i32 - 1)
 -max(i32)
--max(i32, 0.5)
+-max(i32, f32)
+-max(i64 * 0.5)
 -max(i64)
--max(score(1))
+-max(i64, f64)
+-max(i64, i)
+-mean(array)
+-median(array)
+-min(-1)
 -min(0.5)
--min(0.5, 1)
--min(0.5, i32)
 -min(1)
--min(1, f32)
+-min(1, 0.5)
 -min(f32)
--min(f32, 0.5)
+-min(f32, 1)
 -min(f64)
--min(f64, 0.5)
--min(f64, f32)
--min(f64, i64)
+-min(float(0.5))
 -min(i)
--min(i, i)
+-min(i, 1)
 -min(i32)
--min(i32, 1)
--min(i32, f64)
+-min(i32, 0.5)
 -min(i64)
--min(i64, f32)
--min(i64, f64)
+-min(i64, i, 0.5)
+-reduce(array, #)
+-reduce(array, -#)
+-reduce(array, 0.5)
+-reduce(array, 1)
+-reduce(array, 1) - f32
+-reduce(array, f64)
+-reduce(array, i)
+-reduce(array, i32)
+-reduce(array, i64)
+-reduce(list, 0.5)
+-reduce(list, 1)
+-reduce(list, f32)
+-reduce(list, f64)
+-reduce(list, i)
+-reduce(list, i32)
+-round(0.5)
+-round(1)
+-round(f32)
+-round(f64)
+-round(i)
+-round(i32)
+-round(i64)
 -score(1)
 -score(1, 1)
 -score(1, i)
 -score(i)
--score(i, 1)
--score(i32 * i)
-0.5 != 0.5 ? f64 : half
-0.5 != 0.5 ? i64 : f64
-0.5 != 0.5 ? list : array
-0.5 != 0.5 or ok
-0.5 != f32 || 0.5 > 0.5
-0.5 != i && i64 > 1
-0.5 != i64 != ok
-0.5 != i64 ? -f32 : add
-0.5 != nil or ok
-0.5 * 0.5 != i / 1
-0.5 * 0.5 * i
-0.5 * 0.5 * i32
-0.5 * 0.5 + i32
-0.5 * 0.5 - i
+-score(i32 + i)
+-score(int(i))
+-sum(array)
+-sum(i .. 1)
+0.5 != 0.5 == ok
+0.5 != f64 ? list : f32
+0.5 != f64 and !true
+0.5 != f64 and ok
+0.5 != i == ok
+0.5 != i32 && ok
+0.5 != i32 == ok
+0.5 != i32 ? ok : ok
+0.5 != i32 and 1 > f64
+0.5 != nil == ok
+0.5 * 0.5 * f64
+0.5 * 0.5 / f32
 0.5 * 0.5 / f64
-0.5 * 0.5 / i32
-0.5 * 0.5 < f32
-0.5 * 0.5 < i
-0.5 * 0.5 > i32
-0.5 * 1 + f32
-0.5 * 1 + half(f64)
-0.5 * 1 < f64
-0.5 * 1 > f64
+0.5 * 0.5 < f64
+0.5 * 0.5 >= i64
+0.5 * 1 * i64
+0.5 * 1 <= f32
 0.5 * 1 > i32
-0.5 * f32 / i64
+0.5 * 1 not in array
+0.5 * f32 * f32
+0.5 * f32 * i32
+0.5 * f32 + f32
+0.5 * f32 - f64
+0.5 * f32 / half(1)
 0.5 * f32 == i32
-0.5 * f64 * f64
-0.5 * f64 + i64
-0.5 * f64 > i
-0.5 * f64 >= i
-0.5 * f64 >= i64
-0.5 * i - i
-0.5 * i / i64
-0.5 * i / i64 ^ 0.5
-0.5 * i == f32
-0.5 * i32 < i32
-0.5 * i32 in [f64]
-0.5 * i64 != f32
-0.5 * i64 != i
-0.5 * i64 + f32
-0.5 * i64 <= i64
-0.5 ** 0.5 != i
-0.5 ** 0.5 ** f32
-0.5 ** 0.5 / f32
-0.5 ** 0.5 / i
-0.5 ** 0.5 < i / i32
-0.5 ** 0.5 == f32
-0.5 ** 0.5 == i32
-0.5 ** 1 + i64
-0.5 ** 1 / f32
-0.5 ** f32 < 1 / f64
-0.5 ** f32 < i
-0.5 ** f32 < i32
-0.5 ** f32 < min(i64)
-0.5 ** f32 == f64
-0.5 ** f32 ^ f32
-0.5 ** f32 ^ i64
-0.5 ** f64 * f32
-0.5 ** f64 + -i
-0.5 ** i * 0.5 ** i
-0.5 ** i < f32
-0.5 ** i <= i32
-0.5 ** i > f32
-0.5 ** i ^ f64
-0.5 ** i32 != f64
-0.5 ** i32 <= i32
-0.5 ** i32 ^ f32
-0.5 ** i64 != f32
-0.5 ** i64 - f32
-0.5 ** i64 - i64
-0.5 ** i64 ^ min(i)
-0.5 + 0.5 != i32
-0.5 + 0.5 - f32
-0.5 + 0.5 - i64
-0.5 + 0.5 < 1 ? f32 : score
-0.5 + 0.5 <= f32
-0.5 + 0.5 == f64
-0.5 + 0.5 > i64
-0.5 + 0.5 >= i64
-0.5 + 1 != i
-0.5 + 1 < f32
-0.5 + 1 >= i
-0.5 + f32 != i
-0.5 + f32 != i + i64
-0.5 + f32 >= i
-0.5 + f64 == i32
-0.5 + f64 > f64
-0.5 + i > f32
-0.5 + i32 + i64
-0.5 + i32 < f32
-0.5 + i64 + f64
-0.5 + i64 < f64
-0.5 + i64 <= 0.5 + 1
-0.5 + i64 == i32
-0.5 + i64 >= i64
-0.5 - 0.5 != i64
-0.5 - 0.5 + i32
-0.5 - 0.5 - f64
-0.5 - 0.5 < 0.5 * f32
-0.5 - 0.5 == f32
-0.5 - 1 != i ? "foo" : div
-0.5 - 1 + f32
-0.5 - 1 - f64
-0.5 - 1 <= i32
-0.5 - 1 <= i64
-0.5 - f32 + i
-0.5 - f64 <= i32
-0.5 - i - i32
-0.5 - i > f64
-0.5 - i > i
-0.5 - i32 + 0.5 ^ i
-0.5 - i32 + f32
-0.5 - i32 < i
-0.5 - i32 <= i64
-0.5 - i64 == f64
-0.5 - i64 > f32
-0.5 - i64 >= f64
-0.5 - i64 >= i
-0.5 / 0.5 != i32
-0.5 / 0.5 / i
-0.5 / 0.5 / i32
-0.5 / 0.5 < i
-0.5 / 0.5 == i
-0.5 / 0.5 >= i32
-0.5 / 0.5 >= min(i32)
-0.5 / 1 != i32 == nil
-0.5 / 1 - i
-0.5 / 1 < f32
-0.5 / 1 < i32
-0.5 / 1 == i64
-0.5 / 1 > 1 ** 0.5
-0.5 / f32 != i32
+0.5 * f32 > i
+0.5 * f64 != i64
+0.5 * f64 < i
+0.5 * f64 <= i
+0.5 * i + i
+0.5 * i + mean(array)
+0.5 * i - i32
+0.5 * i == 0.5 ? ok : ok
+0.5 * i32 / f32
+0.5 * i64 < f64
+0.5 * i64 == 1 ** i64
+0.5 ** 0.5 != i64
+0.5 ** 0.5 * max(1)
+0.5 ** 0.5 ** i64
+0.5 ** 0.5 + -f32
+0.5 ** 0.5 < f64
+0.5 ** 0.5 == i
+0.5 ** 0.5 ^ f32
+0.5 ** 0.5 not in array
+0.5 ** 1 != i
+0.5 ** 1 != i32
+0.5 ** 1 - f64
+0.5 ** 1 / f64
+0.5 ** 1 / i32
+0.5 ** 1 ^ i64
+0.5 ** f32 + f32 / i64
+0.5 ** f32 <= f32
+0.5 ** f32 ^ i
+0.5 ** f64 * f64
+0.5 ** f64 > f64 ? 1 : nil
+0.5 ** f64 >= i64
+0.5 ** i / i
+0.5 ** i > i
+0.5 ** i32 * i32
+0.5 ** i32 > f64
+0.5 ** i32 >= mean(array)
+0.5 + 0.5 != i
+0.5 + 0.5 == i32
+0.5 + 0.5 > f32
+0.5 + 1 != f64
+0.5 + 1 + i32
+0.5 + 1 - i32
+0.5 + 1 < float(1)
+0.5 + 1 == f32
+0.5 + f32 - i64
+0.5 + f32 <= ceil(f32)
+0.5 + f32 <= i32
+0.5 + f32 > f32
+0.5 + f64 != i64
+0.5 + f64 <= i32
+0.5 + f64 == 1 / 0.5
+0.5 + i + i
+0.5 + i > i64
+0.5 + i in array
+0.5 + i32 - i64
+0.5 + i32 <= f32
+0.5 + i64 - i
+0.5 + i64 > i64 * 0.5
+0.5 - 0.5 - i32
+0.5 - 0.5 >= f32
+0.5 - 0.5 >= i
+0.5 - 0.5 >= i32
+0.5 - 1 + i
+0.5 - 1 + i / i
+0.5 - 1 <= f64
+0.5 - f32 != i64
+0.5 - f32 >= i64
+0.5 - f64 - f32
+0.5 - f64 < i
+0.5 - f64 in array
+0.5 - i != i64
+0.5 - i + i
+0.5 - i > f32
+0.5 - i32 != f32
+0.5 - i64 + -f64
+0.5 - i64 == i
+0.5 - i64 not in array
+0.5 / 0.5 + i
+0.5 / 0.5 - i
+0.5 / 0.5 - i32
+0.5 / 0.5 - i64
+0.5 / 0.5 / half(0.5)
+0.5 / 0.5 < i32
+0.5 / 0.5 == i64
+0.5 / 0.5 >= f32
+0.5 / 0.5 >= f64
+0.5 / 1 * i
+0.5 / 1 / f64
+0.5 / 1 < f64
+0.5 / 1 == i
+0.5 / 1 > f32
+0.5 / 1 >= i32
+0.5 / 1 not in array
 0.5 / f32 * f64
-0.5 / f64 / i
-0.5 / f64 <= f64
-0.5 / f64 == i
-0.5 / f64 == i64
-0.5 / f64 >= f64 ^ 1
-0.5 / i < f64 ? i64 : i64
+0.5 / f64 + f64
+0.5 / f64 - i
+0.5 / f64 / f64
+0.5 / f64 < i
+0.5 / f64 == f32
+0.5 / i != i64
+0.5 / i * i64
+0.5 / i / i32
 0.5 / i <= i
-0.5 / i == i64 - f32
-0.5 / i32 + i32
-0.5 / i32 < f32
+0.5 / i32 + i64
+0.5 / i32 > i ^ i
+0.5 / i32 > i64
+0.5 / i32 >= f64
+0.5 / i64 != f64
+0.5 / i64 != i
+0.5 / i64 != min(f32)
 0.5 / i64 * i32
-0.5 < 0.5 == nil ? true : foo
-0.5 < 0.5 || ok
-0.5 < 1 and ok
-0.5 < 1 or fromJSON("foo")?.Bar
-0.5 < f32 ? map(list, i32) : i
-0.5 < f64 != false ? f32 : score
-0.5 < f64 ? list : greet
-0.5 < f64 || ok
-0.5 < i ? f64 : foo
-0.5 < i32 or i32 == 1
-0.5 < i64 or ok
-0.5 <= 0.5 and ok
-0.5 <= 1 ? half : greet
-0.5 <= array[i32]
-0.5 <= f32 or ok
-0.5 <= f64 and !true
-0.5 <= f64 or ok
-0.5 <= i == ok
-0.5 <= i and nil == list
-0.5 <= i32 and i < i64
-0.5 <= i64 && f64 >= f64
-0.5 == 0.5 ? score : i
-0.5 == 1 == ok
-0.5 == 1 == ok ? "foo" : div
-0.5 == 1 or ok
-0.5 == 1 || nil != score
-0.5 == f32 ? score : i32
-0.5 == f64 && ok
-0.5 == nil || div != score
+0.5 < 0.5 ? f32 : array
+0.5 < 0.5 ? foo : greet
+0.5 < 1 == ok
+0.5 < 1 || ok
+0.5 < f32 && ok
+0.5 < f32 || ok
+0.5 <= f64 ? i : i64
+0.5 <= f64 || ok
+0.5 == 1 and ok
+0.5 == 1 || ok
+0.5 == array[ok ? 0.5 : score]
+0.5 == f32 and i64 == i32
+0.5 == f64 ? i : (false ? i : i64)
+0.5 == f64 and i64 == 0.5
+0.5 == i or ok
+0.5 == i32 and ok
+0.5 == i64 and ok
+0.5 == nil or "foo" endsWith "bar"
+0.5 == nil or ok
 0.5 == nil || ok
-0.5 > 1 == ok
-0.5 > 1 or ok
-0.5 > f32 or !true
-0.5 > f64 != ok
-0.5 >= 0.5 == ok
-0.5 >= 0.5 || ok
-0.5 >= 1 != ok
-0.5 >= 1 and ok
-0.5 >= i32 && i > f32
-0.5 >= i64 and ok
-0.5 ^ 0.5 != i32
-0.5 ^ 0.5 + i32
-0.5 ^ 0.5 / i
-0.5 ^ 0.5 < f64
-0.5 ^ 0.5 > i
-0.5 ^ 0.5 > i64
+0.5 > 0.5 == ok
+0.5 > array[i64]
+0.5 > f32 and ok
+0.5 > i && 0.5 < i64
+0.5 > i64 ? -i : array
+0.5 >= 0.5 ? array[i64] : f32
+0.5 >= 0.5 and ok
+0.5 >= i && 1 < 0.5
+0.5 >= i32 == ok
+0.5 >= i32 and ok
+0.5 ^ 0.5 == f64
 0.5 ^ 0.5 >= i32
-0.5 ^ 1 * f64
-0.5 ^ 1 * i
-0.5 ^ 1 + i64
-0.5 ^ 1 - -i
-0.5 ^ 1 / i
-0.5 ^ 1 == f32
-0.5 ^ 1 == i32
-0.5 ^ f32 + i32
+0.5 ^ 0.5 >= i64
+0.5 ^ 1 ** i64
+0.5 ^ 1 - f32
+0.5 ^ 1 < f32
+0.5 ^ 1 < i
+0.5 ^ 1 <= i32
+0.5 ^ 1 > f64 / 1
+0.5 ^ 1 >= i
+0.5 ^ f32 * i
+0.5 ^ f32 ** i64
 0.5 ^ f32 <= i32
-0.5 ^ f32 > f64 ? array : nil
-0.5 ^ f32 >= f64
-0.5 ^ f32 ^ i32
-0.5 ^ f64 - i32
-0.5 ^ f64 > f32
-0.5 ^ f64 >= f32
-0.5 ^ f64 >= f64
-0.5 ^ f64 >= i
-0.5 ^ f64 ^ i64
-0.5 ^ i == i64
-0.5 ^ i >= i32
-0.5 ^ i32 * i
-0.5 ^ i32 * score(i)
-0.5 ^ i32 / i
-0.5 ^ i32 == i
-0.5 ^ i64 < i
-0.5 ^ i64 <= f32
-0.5 ^ i64 == f64
-0.5 ^ i64 > f64
-0.5 ^ i64 > i
+0.5 ^ f32 > i64
+0.5 ^ f32 >= i
+0.5 ^ f64 - i64
+0.5 ^ f64 / f32
+0.5 ^ f64 < f32
+0.5 ^ f64 > i32
+0.5 ^ i != f64
+0.5 ^ i * reduce(array, i)
+0.5 ^ i ** floor(0.5)
+0.5 ^ i / (0.5 + i32)
+0.5 ^ i < -f64
+0.5 ^ i <= i32
+0.5 ^ i >= i64
+0.5 ^ i32 * reduce(list, f64)
+0.5 ^ i32 ** f32
+0.5 ^ i32 < f32 ? ok : i32
+0.5 ^ i32 == i64
+0.5 ^ i32 ^ f64
+0.5 ^ i32 in array
+0.5 ^ i64 * i
+0.5 ^ i64 ** i
+0.5 ^ i64 ** i64
 0.5 ^ i64 > i32
-0.5 ^ i64 >= f32
-1 != 1 != hasPrefix("bar", "bar")
-1 != array[i - 1]
-1 != f32 && i32 <= 0.5
-1 != f32 == ok
-1 != f32 ? i64 : foo
-1 != f32 and i in array
-1 != f64 != ok
-1 != i32 ? score : greet
-1 != i64 && ok
-1 != i64 ? f32 : greet
+0.5 in array != ok
+0.5 in array && ok
+1 != 0.5 != ok
+1 != 0.5 and 1 == 1
+1 != 1 && ok
+1 != 1 ? f64 : 0.5 > i
+1 != 1 ? list : score
+1 != f32 != ok
+1 != f32 ? ok : half
+1 != i or ok
+1 != i64 ? add : div
 1 != nil && ok
-1 != nil ? half : foo
-1 % 1 != f64
-1 % 1 * f32
-1 % 1 < f32
-1 % 1 > f32
-1 % 1 > i
-1 % 1 >= i64
-1 % i / i32
-1 % i < f64
+1 != nil == ok
+1 != nil or not false
+1 % 1 != i
+1 % 1 != i32
+1 % 1 % i
+1 % 1 / f32
+1 % 1 / i32
+1 % 1 < f64
+1 % 1 < i
+1 % 1 == f64
+1 % 1 == i ? nil : 0.5
+1 % 1 == i32
+1 % array[i32]
+1 % array[i]
+1 % i != -i64
+1 % i != 1 != nil
+1 % i - i64
 1 % i < i32
-1 % i == f32
-1 % i32 * i64
-1 % i32 < max(i64)
-1 % i64 != f32
-1 % i64 * f64
-1 % i64 + f32
-1 % i64 .. i64
-1 % i64 <= i64
+1 % i >= f64
+1 % i >= i
+1 % i not in array
+1 % i32 != i
+1 % i32 <= f32
+1 % i32 > i64
+1 % i32 >= f64
+1 % i64 - f32
+1 % i64 < score(i)
 1 % i64 > f32
-1 % i64 > i32
-1 * 0.5 + i
-1 * 0.5 - -i
-1 * 0.5 <= f32
-1 * 0.5 > f32
-1 * 1 % i
-1 * 1 + i32
-1 * 1 <= f64
-1 * array[i64]
-1 * f32 < i
-1 * f32 < i32
-1 * f32 <= i32
-1 * f64 * -i
-1 * f64 * f32
-1 * f64 + i
-1 * i % i
-1 * i + f32
-1 * i < int(1)
-1 * i <= 1 % 1
-1 * i > f32
+1 * 0.5 + f64
+1 * 0.5 + i32
+1 * 0.5 + round(f64)
+1 * 0.5 / i
+1 * 0.5 / i64
+1 * 0.5 < i64
+1 * 0.5 == f32
+1 * 0.5 >= f32
+1 * 1 - i32
+1 * 1 <= int(i)
+1 * 1 >= f32
+1 * f32 != f64 - 0.5
+1 * f32 <= reduce(array, #)
+1 * f32 >= f64
+1 * f64 * i64
+1 * f64 <= i64
+1 * f64 > i
+1 * f64 >= f64
+1 * i * f32
+1 * i - i32
+1 * i / f64
+1 * i < f32
+1 * i > i32
 1 * i not in array
-1 * i32 % i64
-1 * i32 * i32
-1 * i32 / i32
-1 * i32 > f32
-1 * i64 + f64
-1 * i64 == i32
-1 * i64 > i64
-1 ** 0.5 * f64
-1 ** 0.5 - i
-1 ** 0.5 > i32
+1 * i32 + i32
+1 * i32 - i
+1 * i32 < i
+1 * i64 * f32
+1 * i64 + i
+1 * i64 - f64
+1 * i64 / f64
+1 * i64 <= f64
+1 * i64 in array
+1 ** 0.5 * i
+1 ** 0.5 ** f32
+1 ** 0.5 ** f64
+1 ** 0.5 ** i64
+1 ** 0.5 - f32
+1 ** 0.5 - i32
+1 ** 0.5 - i64
+1 ** 0.5 < -f32
+1 ** 0.5 > i
+1 ** 0.5 > i64
 1 ** 0.5 ^ f64
-1 ** 1 != i
-1 ** 1 != i64
-1 ** 1 - i
-1 ** 1 / i64
-1 ** 1 < i64
-1 ** 1 == i32
+1 ** 1 ** f64
+1 ** 1 + f64
+1 ** 1 + i64
+1 ** 1 - round(0.5)
+1 ** 1 / f64
+1 ** 1 < f32
+1 ** 1 == 0.5 + i32
 1 ** 1 >= i
-1 ** f32 != i64
-1 ** f32 / i
-1 ** f64 != i64
-1 ** f64 ** i64
-1 ** f64 + i
-1 ** f64 / f32
-1 ** f64 < i
-1 ** i != i
-1 ** i ** i64
-1 ** i < f64
-1 ** i < i32
-1 ** i > f64
-1 ** i32 ** (1 / 1)
-1 ** i32 == i
-1 ** i32 > i
-1 ** i64 ** f64
-1 ** i64 - f64
-1 + 0.5 != i
-1 + 0.5 <= f64 / f32
-1 + 0.5 <= i32
-1 + 1 - i32
+1 ** 1 >= i32
+1 ** 1 ^ i
+1 ** 1 ^ i32
+1 ** 1 in array
+1 ** array[i32]
+1 ** f32 / i32
+1 ** f32 / i64
+1 ** f32 <= f32
+1 ** f32 <= i64
+1 ** f32 == i64 ? i32 : array
+1 ** f32 >= f32
+1 ** f32 >= i
+1 ** f32 ^ f32
+1 ** f32 ^ i64
+1 ** i + i32
+1 ** i >= i
+1 ** i32 != i32
+1 ** i32 + f32
+1 ** i32 + i64
+1 ** i64 <= f32
+1 ** i64 <= f64
+1 ** i64 <= i32
+1 ** i64 > f32
+1 + 0.5 != i32
+1 + 0.5 + i
+1 + 0.5 - i64
+1 + 0.5 < f32
+1 + 0.5 < i
+1 + 0.5 == f64
+1 + 0.5 == f64 != nil
+1 + 0.5 > i64
+1 + 0.5 not in array
+1 + 1 != 0.5 ? 0.5 : half
+1 + 1 - f32
+1 + 1 - i
 1 + 1 < i
-1 + 1 == f64
-1 + 1 == i64
-1 + 1 >= i64
-1 + f32 != i
-1 + f32 > i
-1 + f64 != f64
-1 + f64 - i
-1 + f64 >= i32
+1 + 1 == f64 * i64
+1 + 1 > f32
+1 + 1 >= half(0.5)
+1 + 1 >= i
+1 + f32 != i32
+1 + f32 < i32
+1 + f32 <= i
+1 + f32 > i64
+1 + f64 == i64
+1 + f64 >= f64
+1 + i .. i32
+1 + i <= ceil(f32)
 1 + i <= f64
-1 + i in map(list, i32)
-1 + i32 - i64
-1 + i32 < i
-1 + i64 >= f32
-1 - 0.5 != half(0.5)
+1 + i >= min(i64)
+1 + i32 != i32
+1 + i32 - f64
+1 + i32 < f32
+1 + i32 < i32
+1 + i32 <= f64
+1 + i32 > reduce(array, #)
+1 + i32 >= f64
+1 + i64 != i32
+1 + i64 != i64
+1 + i64 < i32
+1 + i64 <= i64
+1 - 0.5 != f32
 1 - 0.5 + i
-1 - 0.5 + i32
-1 - 0.5 - i64
-1 - 0.5 <= f64
-1 - 0.5 == i64
-1 - 1 .. i64
-1 - 1 < i64
+1 - 0.5 - f32
+1 - 0.5 <= i32
+1 - 0.5 <= i64
+1 - 1 < i64 ? 0.5 : "foo"
+1 - 1 <= i32 + i64
 1 - 1 == f64
-1 - 1 > -f32
-1 - f32 != i
-1 - f32 <= f64
-1 - f32 <= i32
-1 - f64 - f32
-1 - f64 - f64
-1 - f64 < i64
+1 - 1 > i32 / i32
+1 - f32 != f32
+1 - f32 <= i64
+1 - f64 != f32
+1 - f64 + f32
+1 - f64 + i - 0.5
 1 - f64 <= i
-1 - i .. i64
-1 - i < min(f64)
-1 - i32 < f64
-1 - i32 <= f64
-1 - i32 <= i32
-1 - i32 >= f64
-1 - i64 + i
-1 - i64 - f32
-1 .. 1 == list
-1 .. array[i]
-1 .. i == list
-1 .. i64 == list
-1 / 0.5 + f64
-1 / 0.5 - array[i64]
-1 / 0.5 < f64
-1 / 1 + -0.5
-1 / 1 + i32
-1 / 1 - -0.5
-1 / 1 / f64
-1 / 1 < f32
-1 / 1 <= f32
-1 / 1 <= i
-1 / 1 == f64
-1 / 1 == i
-1 / 1 == i32
-1 / 1 > f32
-1 / 1 > i64
-1 / f32 + -1
-1 / f64 * i
-1 / f64 * i32
-1 / f64 + i32
-1 / f64 / f32
-1 / f64 == f32
-1 / f64 == i
-1 / f64 > i
-1 / i * i
-1 / i < f64 ? ok : add
-1 / i32 <= f32
-1 / i32 == i
-1 / i32 == i64
-1 / i32 > i
-1 / i64 + i64
-1 / i64 == i64
-1 / i64 > i
-1 / i64 >= i32
-1 < array[i64]
-1 < f64 != ok
-1 < i32 and 1 == nil
-1 < i64 ? "foo" not endsWith "foo" : i
-1 <= 0.5 and i32 == 1
-1 <= 0.5 || ok
-1 <= 1 && greet != greet
-1 <= 1 and ok
-1 <= f32 != ok
-1 <= f32 == !ok
-1 <= f64 ? add : f64
-1 <= i64 or nil == f32
-1 == array[i]
-1 > 0.5 != ok
-1 > 1 and ok
-1 > 1 || ok
-1 > f32 and ok
-1 > f64 == ok
-1 > f64 and ok
-1 > i32 == ok
-1 > i64 || i32 < i
-1 >= 1 || ok
-1 >= i || ok
-1 >= i64 or nil in list
-1 ^ 0.5 - f32
-1 ^ 0.5 <= f32
-1 ^ 0.5 <= i64
-1 ^ 0.5 ^ i32
-1 ^ 1 - f64
-1 ^ 1 - i32
-1 ^ 1 - i64
-1 ^ 1 / f32
-1 ^ 1 < f32
-1 ^ 1 < i64 / f32
-1 ^ 1 <= 1 ** f64
-1 ^ 1 == f64
-1 ^ 1 >= f32
-1 ^ 1 >= i64
-1 ^ f32 == i64
-1 ^ f32 > max(f32)
-1 ^ f64 != i32
-1 ^ f64 * f32
-1 ^ f64 ** f64
-1 ^ i != findLast(array, false)
-1 ^ i != i
-1 ^ i * f64
-1 ^ i < i32
-1 ^ i <= f32
-1 ^ i == abs(1)
-1 ^ i32 + i
-1 ^ i32 < i
-1 ^ i32 < i64
+1 - f64 in array
+1 - f64 not in array
+1 - i > f64
+1 - i > i
+1 - i > i32
+1 - i >= i64
+1 - i not in array
+1 - i32 < i32
+1 - i32 < i64
+1 - i32 == i32
+1 - i64 <= i32
+1 .. i != list
+1 / 0.5 <= abs(f32)
+1 / 0.5 <= i32
+1 / 0.5 == f64
+1 / 0.5 > f32
+1 / 0.5 >= i
+1 / 0.5 >= i - i
+1 / 0.5 >= i32
+1 / 1 != i32
+1 / 1 * f32
+1 / 1 <= f64
+1 / 1 in array
+1 / f32 != f64
+1 / f32 / i64
+1 / f32 <= f32
+1 / f32 <= f64
+1 / f32 == i32
+1 / f32 == i32 / i
+1 / f32 > f32
+1 / f32 >= f64
+1 / f64 + f64
+1 / f64 < f32
+1 / f64 == f64
+1 / i * f32
+1 / i / f64
+1 / i < i
+1 / i == f64
+1 / i >= i32
+1 / i in map(list, 1)
+1 / i32 > f32
+1 / i32 >= i64
+1 / i64 * i
+1 / i64 > f32 / f64
+1 / i64 > f64
+1 / i64 >= f64
+1 < 1 == ok
+1 < 1 and ok
+1 < array[get(array, i32)]
+1 < array[i32]
+1 < f32 != not true
+1 < f64 || ok
+1 < i ? array : foo
+1 < i32 || 1 >= f32
+1 < i64 == ok
+1 < i64 ? ok : list
+1 <= 1 == ok
+1 <= 1 || add == add
+1 <= f32 && ok
+1 <= f64 || ok
+1 <= i32 ? foo : f32
+1 == 0.5 ? i32 : greet
+1 == 0.5 and ok
+1 == 1 || ok
+1 == f64 && 0.5 != nil
+1 == f64 || ok
+1 == i32 && ok
+1 == i32 == ok
+1 == i64 == ok
+1 == nil ? ok : half
+1 > 0.5 == ok
+1 > array[i64]
+1 > f32 && ok
+1 > f32 == reduce(array, ok)
+1 > f64 != ok
+1 > i == ok
+1 > i64 or i != 1
+1 >= 1 != (nil not in list)
+1 >= f32 ? i64 : half
+1 >= f64 ? ok : half
+1 >= i and ok
+1 ^ 0.5 != f32
+1 ^ 0.5 != i
+1 ^ 0.5 ** f32
+1 ^ 0.5 ** i32
+1 ^ 0.5 - i32
+1 ^ 0.5 < i32
+1 ^ 0.5 <= f64
+1 ^ 0.5 == i
+1 ^ 0.5 ^ f32
+1 ^ 0.5 ^ i64
+1 ^ 1 != f64
+1 ^ 1 != i64
+1 ^ 1 ** i
+1 ^ 1 + f64
+1 ^ 1 / i
+1 ^ 1 < i
+1 ^ 1 < i64
+1 ^ 1 >= i
+1 ^ 1 >= i32
+1 ^ f32 < i32
+1 ^ f32 <= f64
+1 ^ f64 / f64
+1 ^ f64 == f32
+1 ^ f64 > f32
+1 ^ f64 >= 1 / f64
+1 ^ i != i * f32
+1 ^ i - i32
+1 ^ i < i
+1 ^ i32 * i32
+1 ^ i32 ** i64
+1 ^ i32 / i
 1 ^ i32 >= i32
-1 ^ i64 ** f64
-1 ^ i64 ** i32
-1 ^ i64 + i
-1 ^ i64 <= i
-1 ^ i64 <= i32
+1 ^ i32 >= i64
+1 ^ i64 * i64
+1 ^ i64 ** reduce(list, 1)
+1 ^ i64 - i64
+1 ^ i64 / f64
 1 ^ i64 > i
-1 ^ i64 >= i64
+1 ^ i64 >= i32 + i32
+1 in array ? f32 : foo
 [!false]
 [!ok]
-["foo" != nil]
-["foo" endsWith "bar"]
+[!true]
+["bar" + "foo"]
+["bar" < "bar"]
+["bar" not contains "bar"]
 [-0.5]
+[-1]
 [-f32]
 [-f64]
-[-i32]
-[-i64, add]
 [-i64]
-[0.5 * 1]
-[0.5 + 0.5]
-[0.5 / i]
-[0.5 <= f64]
-[0.5 <= i, -1]
-[0.5 >= i]
-[0.5 ^ 1]
+[0.5 != f32]
+[0.5 != i]
+[0.5 * 0.5]
+[0.5 * f32]
+[0.5 ** i]
+[0.5 - 0.5]
+[0.5 - i]
+[0.5 / i32]
+[0.5 <= i32, half]
+[0.5 > 1]
+[0.5 > f32]
+[0.5 > i64]
+[0.5 >= f64]
+[0.5 ^ 0.5]
 [1 != 1]
-[1 % 1, !true]
-[1 < 0.5]
+[1 * 0.5]
+[1 ** 0.5]
+[1 + i64, add]
+[1 == i64]
 [1 == i]
-[abs(0.5)]
-[add != div]
-[add == nil]
-[add, array]
+[[f32]]
+[add != nil]
+[add, add]
 [add, f32]
-[add, f64]
-[add, greet]
-[add, half]
-[add, i64]
-[add, score]
-[add, toJSON(array)]
+[add, i]
 [add]
-[array == list]
+[all(list, false)]
+[any(list, ok)]
+[array, add]
+[array, array]
 [array, f32]
-[array, f64]
 [array, greet]
-[array, half]
+[array, i64]
+[array, i]
 [array, list]
-[array, ok]
-[array, score]
-[array[1]]
-[array[i64]]
+[array, ok, add]
+[array, string(nil)]
 [array]
-[div == half]
-[div, f32]
-[div, greet]
-[div, map(list, half)]
-[div, ok]
-[div, score]
+[bitnot(1)]
+[ceil(i32)]
+[div(1, 1)]
+[div, add]
+[div, foo]
+[div, i32]
+[div, i64, array]
 [div]
-[f32 + 1]
-[f32 - 0.5]
-[f32 < i]
-[f32 ^ 0.5]
-[f32 ^ f64]
+[f32 * i]
+[f32 + f64]
+[f32 >= i]
 [f32, f64]
-[f32, half]
-[f32, max(f64)]
+[f32, foo, greet]
+[f32, greet]
+[f32, i32]
+[f32, list]
+[f32, ok]
+[f32, score]
 [f32]
-[f64 != 1]
-[f64 != i32]
-[f64 * f64]
+[f64 + f64]
+[f64 / f64]
+[f64 < 0.5]
 [f64 < f32]
-[f64 >= 1]
+[f64 < i64]
+[f64 <= 1]
+[f64 in array]
+[f64, add]
 [f64, f64]
-[f64, foo]
-[f64, i32]
+[f64, half]
 [f64, i64]
-[f64, list]
-[f64, score]
 [f64]
-[false ? f64 : f32]
-[findIndex(array, true)]
-[first(array)]
-[float(i64)]
+[f64] == array
+[find(array, true)]
+[findIndex(list, false)]
+[findLast(list, ok)]
+[float(0.5)]
+[float(1)]
 [foo, add]
-[foo, f32]
-[foo, foo]
+[foo, array]
+[foo, half]
 [foo, i]
-[foo, list]
+[foo, ok]
+[foo, reduce(array, #)]
+[foo.Bar]
 [foo.Qux]
-[foo.String(), greet]
-[foo.String()]
+[foo?.Bar, f32, f64]
+[foo?.Bar, i32]
 [foo?.Bar]
 [foo?.Qux]
+[foo?.String()]
 [foo]
+[greet != nil]
+[greet, array]
 [greet, div]
-[greet, f32 ^ 0.5]
-[greet, f32]
-[greet, f64]
+[greet, foo]
+[greet, greet]
 [greet, half]
-[greet, i32]
 [greet, i64]
 [greet, list]
 [greet]
+[greet] == list
+[groupBy(array, "bar")]
+[groupBy(array, #), half]
+[groupBy(array, #)]
+[groupBy(array, f64)]
+[groupBy(list, #)?.Qux]
+[half(0.5)]
+[half(f64)]
+[half(i64 ^ 1)]
+[half, array]
 [half, div]
-[half, foo]
-[half, greet]
+[half, f64]
+[half, i64 < f64]
+[half, list]
 [half]
 [i != i64]
-[i != i]
-[i - 1]
 [i .. 1]
-[i / 0.5]
-[i < f32]
-[i > f64]
-[i, add]
-[i, half]
-[i32 * 1]
-[i32 <= 0.5]
-[i32 == 0.5]
+[i / i]
+[i < i64, score]
+[i <= 0.5]
+[i == i32]
+[i >= i32]
+[i ^ 1]
+[i, array, list]
+[i, array]
+[i, greet("bar")]
+[i, greet]
+[i, i32]
+[i, i]
+[i, list]
+[i32 < i]
 [i32 > 1]
-[i32 > f32]
-[i32, i]
-[i32, score]
+[i32, -1]
+[i32, div]
+[i32, f64]
+[i32, i32]
+[i32, list]
+[i32, type(greet)]
 [i32]
+[i64 != f64]
+[i64 + 0.5]
 [i64 / f64]
-[i64 == i32]
+[i64 <= i64]
 [i64 >= 1]
-[i64 ^ i, i32]
-[i64, add]
+[i64 ^ 1]
 [i64, div]
 [i64, foo]
-[i64, i32]
-[i64, ok]
+[i64, half]
+[i64, score]
 [i64]
-[i64] == array
 [i]
-[int(1)]
-[len(array)]
-[list == list]
+[list != nil]
 [list, div]
-[list, f64]
+[list, f32]
+[list, greet]
+[list, half]
 [list, i]
+[list, ok]
 [list]
 [map(array, #)]
-[map(array, 1 >= i32)]
+[map(array, add)]
+[map(array, f64)]
 [map(array, foo)]
-[map(list, #)]
-[map(list, half)]
-[map(list, ok)]
 [max(1)]
-[max(i32)]
-[min(0.5)]
-[min(f64)]
-[min(i32)]
-[nil != ok, foo]
-[nil == 0.5]
-[nil not in list]
+[nil != 0.5]
 [not false]
-[not ok]
-[not true]
-[ok && ok]
+[ok ? 1 : greet]
 [ok, f32]
 [ok, half]
-[ok, score]
+[ok, i64]
+[ok, i]
+[ok, list, 0.5] == list
+[ok, ok]
 [ok]
-[score != add]
-[score(1)]
-[score(i)]
-[score, array, foo]
+[reduce(array, foo)]
+[reduce(list, #)]
+[reduce(list, div)]
+[score == nil]
+[score, div]
 [score, f32]
 [score, f64]
 [score, greet]
+[score, half]
+[score, one(array, # > i32)]
+[score, score]
 [score]
-[string(0.5), foo]
-[string(f64)]
-[string(i32)]
-[toJSON(1)]
-[toJSON(nil)]
-[type(0.5)]
+[string(0.5)]
+[string(1)]
+[string(foo)]
+[string(i)]
+[string(i64)]
+[toJSON(list)]
+[trimPrefix("bar")]
+[true ? add : f64]
+[true and ok]
+[true || ok]
 [type(1)]
 [type(add)]
-[type(false)]
-[type(i32)]
-[{"foo": foo}]
+[type(div)]
+[type(greet)]
+[type(nil)]
 abs(-0.5)
 abs(-1)
 abs(-f32)
@@ -2377,159 +2571,153 @@ abs(-i32)
 abs(-i64)
 abs(0.5 * 0.5)
 abs(0.5 * 1)
-abs(0.5 * f64)
-abs(0.5 * i32)
+abs(0.5 * i)
 abs(0.5 * i64)
 abs(0.5 ** 0.5)
 abs(0.5 ** 1)
-abs(0.5 ** f32)
-abs(0.5 ** f64)
-abs(0.5 ** i64)
+abs(0.5 ** i32)
 abs(0.5 + 0.5)
+abs(0.5 + 1)
 abs(0.5 + f32)
 abs(0.5 + i)
 abs(0.5 + i64)
 abs(0.5 - 0.5)
-abs(0.5 - f32)
+abs(0.5 - 1)
 abs(0.5 - i)
+abs(0.5 - i32)
 abs(0.5 - i64)
 abs(0.5 / 0.5)
 abs(0.5 / 1)
-abs(0.5 / f32)
 abs(0.5 / f64)
-abs(0.5 / i)
-abs(0.5 / i64)
 abs(0.5 ^ 0.5)
 abs(0.5 ^ 1)
-abs(0.5 ^ f64)
-abs(0.5 ^ i32)
-abs(0.5) * i
-abs(0.5) - i
-abs(0.5) - i64
-abs(0.5) / i32
-abs(0.5) < f32
-abs(0.5) == i32
-abs(0.5) > f32
-abs(0.5) >= f32
-abs(0.5) >= i
-abs(0.5) >= i32
-abs(0.5) ^ f64
-abs(1 % 1)
-abs(1 % i)
-abs(1 * 0.5)
-abs(1 * 1)
+abs(0.5 ^ f32)
+abs(0.5) - i32
+abs(0.5) / f32
+abs(0.5) < f64
+abs(0.5) < i32
+abs(0.5) <= i64
+abs(0.5) == -0.5
+abs(0.5) == half(1)
+abs(0.5) > i32
+abs(0.5) >= f64
+abs(0.5) ^ i64
+abs(0.5) not in array
 abs(1 * f32)
+abs(1 * f64)
+abs(1 * i32)
+abs(1 ** 0.5)
 abs(1 ** 1)
 abs(1 ** i)
 abs(1 + 1)
-abs(1 + f64)
+abs(1 + i)
+abs(1 + i64)
 abs(1 - 0.5)
-abs(1 - i)
-abs(1 - i32)
+abs(1 - 1)
+abs(1 - i64)
 abs(1 / 0.5)
 abs(1 / 1)
-abs(1 / f32)
-abs(1 / f64)
+abs(1 / i)
 abs(1 / i32)
-abs(1 / i64)
-abs(1 ^ 0.5)
-abs(1 ^ 1)
-abs(1 ^ f64)
-abs(1) * f64
-abs(1) * i
-abs(1) ** f64
-abs(1) + f64
-abs(1) + i
-abs(1) - f64
+abs(1 ^ f32)
+abs(1 ^ i)
+abs(1 ^ i32)
+abs(1) - i32
 abs(1) .. i
-abs(1) / f32
-abs(1) < f32
-abs(1) < i
-abs(1) == f64 ? 1 : foo
-abs(1) > i
-abs(1) ^ f32
-abs(1) ^ i32
+abs(1) / f64
+abs(1) / i64
+abs(1) < i64
+abs(1) <= i32
+abs(1) == i32
+abs(1) >= i
+abs(1) ^ f64
 abs(abs(0.5))
 abs(abs(1))
-abs(abs(abs(i)))
-abs(abs(f32))
 abs(abs(f64))
-abs(abs(i))
 abs(abs(i32))
 abs(abs(i64))
-abs(array[1])
-abs(array[i])
-abs(count(list, true))
+abs(add(i, 1))
+abs(bitand(i64, i32))
+abs(bitnand(i64, i))
+abs(bitnot(1))
+abs(bitnot(i))
+abs(bitnot(i32))
+abs(bitnot(i64))
+abs(bitushr(1, 1))
+abs(ceil(0.5))
+abs(ceil(1))
+abs(ceil(f32))
+abs(ceil(i))
+abs(ceil(i32))
+abs(ceil(i64))
+abs(count(array, ok))
+abs(count(array, true))
+abs(count(list, false))
+abs(div(i, i))
 abs(f32 * 0.5)
-abs(f32 * 1)
-abs(f32 * f64)
-abs(f32 ** 0.5)
 abs(f32 ** 1)
+abs(f32 ** f32)
 abs(f32 ** i32)
 abs(f32 + 0.5)
 abs(f32 + 1)
-abs(f32 + f32)
-abs(f32 + f64)
 abs(f32 + i)
 abs(f32 + i32)
 abs(f32 - 0.5)
 abs(f32 - 1)
-abs(f32 - f32)
+abs(f32 - i32)
+abs(f32 - i64)
+abs(f32 / 0.5)
 abs(f32 / 1)
 abs(f32 / f32)
 abs(f32 / f64)
 abs(f32 / i32)
-abs(f32 ^ 1)
-abs(f32 ^ f64)
-abs(f32 ^ i32)
+abs(f32 ^ i)
 abs(f32 ^ i64)
 abs(f32)
-abs(f32) != i64 / i64
-abs(f32) * i32
-abs(f32) + i32
-abs(f32) <= i64
-abs(f32) == i
-abs(f32) ^ f64
-abs(f64 * 1)
+abs(f32) ** f32
+abs(f32) ** i
+abs(f32) + i64
+abs(f32) - i32
+abs(f32) / f64
+abs(f32) < f64
+abs(f32) >= 0.5 / 1
+abs(f32) ^ f32
 abs(f64 * f32)
-abs(f64 * i32)
+abs(f64 * f64)
 abs(f64 ** 1)
-abs(f64 ** f32)
-abs(f64 ** i32)
 abs(f64 + 0.5)
 abs(f64 + 1)
-abs(f64 + i32)
-abs(f64 + i64)
-abs(f64 - 0.5)
+abs(f64 + f64)
 abs(f64 - 1)
 abs(f64 - f32)
-abs(f64 - i32)
 abs(f64 / 0.5)
+abs(f64 / 1)
 abs(f64 / f64)
 abs(f64 / i)
-abs(f64 / i64)
-abs(f64 ^ i32)
+abs(f64 ^ 0.5)
+abs(f64 ^ f32)
+abs(f64 ^ i)
+abs(f64 ^ i64)
 abs(f64)
-abs(f64) * i64
-abs(f64) - f32
-abs(f64) - i64 - i32
-abs(f64) / i
-abs(f64) / i64
-abs(f64) < f64
-abs(f64) <= abs(i32)
-abs(f64) <= i
-abs(f64) <= i32
-abs(f64) == i
-abs(false ? 1 : f32)
-abs(false ? f64 : 0.5)
-abs(false ? false : i64)
-abs(findIndex(array, # > i32))
-abs(findIndex(array, ok))
-abs(findIndex(array, true))
+abs(f64) + f32
+abs(f64) + f64
+abs(f64) + i32
+abs(f64) + i64 / i
+abs(f64) - i
+abs(f64) < i32
+abs(f64) <= f64
+abs(f64) > i64
+abs(f64) ^ f32
+abs(f64) ^ i64
+abs(f64) in array
+abs(false ? f32 : 1)
+abs(false ? half : 0.5)
+abs(false ? list : 1)
+abs(find(array, ok))
+abs(find(array, true))
+abs(findIndex(list, ok))
 abs(findIndex(list, true))
 abs(findLastIndex(array, ok))
-abs(findLastIndex(array, true))
-abs(findLastIndex(list, ok))
 abs(first(array))
 abs(float(0.5))
 abs(float(1))
@@ -2537,383 +2725,363 @@ abs(float(f32))
 abs(float(f64))
 abs(float(i))
 abs(float(i32))
-abs(float(i64))
+abs(floor(0.5))
+abs(floor(f32))
+abs(floor(i32))
+abs(get(array, 1))
+abs(get(array, i))
 abs(get(array, i32))
 abs(get(array, i64))
 abs(half(0.5))
+abs(half(1))
 abs(half(f64))
-abs(i % i64)
 abs(i * 1)
-abs(i * i)
-abs(i * i32)
-abs(i ** 0.5)
+abs(i * f32)
 abs(i ** 1)
+abs(i ** f32)
 abs(i ** i32)
-abs(i + 1)
-abs(i + i32)
+abs(i + 0.5)
+abs(i + f64)
 abs(i - 0.5)
 abs(i - 1)
-abs(i / 1)
+abs(i - f32)
+abs(i - f64)
+abs(i - i32)
+abs(i / 0.5)
+abs(i / f64)
+abs(i / i)
 abs(i / i32)
+abs(i / i64)
 abs(i ^ 0.5)
-abs(i ^ f32)
+abs(i ^ f64)
+abs(i ^ i)
 abs(i ^ i32)
+abs(i ^ i64)
 abs(i)
-abs(i) != float(0.5)
-abs(i) % i64
-abs(i) * f32
-abs(i) ** i
-abs(i) ** max(1)
-abs(i) / i64
-abs(i) <= i32
+abs(i) % i
+abs(i) * i32
+abs(i) ** f32
+abs(i) + f64
+abs(i) - f32
+abs(i) .. i
+abs(i) .. i32
+abs(i) / f32
+abs(i) < f64
 abs(i) <= i64
-abs(i) > f64
+abs(i) == 0.5 / i
+abs(i) > i64
+abs(i) ^ f64
+abs(i) ^ half(1)
+abs(i) ^ i
+abs(i) ^ i32
+abs(i32 % i32)
 abs(i32 % i64)
-abs(i32 * 0.5)
-abs(i32 * 1)
+abs(i32 * f64)
 abs(i32 * i32)
-abs(i32 * i64)
 abs(i32 ** 0.5)
 abs(i32 ** 1)
-abs(i32 ** f64)
-abs(i32 ** i)
-abs(i32 ** i64)
+abs(i32 ** i32)
 abs(i32 + 0.5)
+abs(i32 + 1)
 abs(i32 + f64)
+abs(i32 + i)
 abs(i32 + i32)
-abs(i32 - 1)
-abs(i32 - f32)
-abs(i32 - f64)
+abs(i32 - 0.5)
 abs(i32 - i64)
-abs(i32 / 1)
+abs(i32 / 0.5)
 abs(i32 / i)
-abs(i32 / i32)
-abs(i32 ^ 0.5)
-abs(i32 ^ 1)
-abs(i32 ^ i)
-abs(i32 ^ i64)
+abs(i32 / i64)
 abs(i32)
-abs(i32) % i32
-abs(i32) ** i64
-abs(i32) / -f32
-abs(i32) < f32
-abs(i32) > min(i64, f64, i32)
-abs(i32) ^ f64
-abs(i32) not in array
-abs(i64 % 1)
-abs(i64 % i32)
-abs(i64 * 1)
+abs(i32) != f64
+abs(i32) * f32
+abs(i32) * i
+abs(i32) ** i
+abs(i32) - i32
+abs(i32) / -1
+abs(i32) / i32 ** f64
+abs(i32) < i64 == false
+abs(i32) <= i
+abs(i32) <= i32
+abs(i32) == i32
+abs(i32) ^ i64
+abs(i32) in array
+abs(i64 * 0.5)
 abs(i64 * f32)
-abs(i64 * i)
 abs(i64 * i32)
-abs(i64 * i64)
 abs(i64 ** 0.5)
-abs(i64 ** 1)
+abs(i64 ** f64)
 abs(i64 ** i64)
 abs(i64 + 0.5)
 abs(i64 + 1)
+abs(i64 + f32)
+abs(i64 + f64)
 abs(i64 + i)
-abs(i64 + i32)
-abs(i64 + i64)
-abs(i64 - 1)
-abs(i64 - f64)
-abs(i64 - i32)
+abs(i64 - 0.5)
+abs(i64 - i)
+abs(i64 / f32)
 abs(i64 / i32)
-abs(i64 ^ i64)
+abs(i64 ^ f64)
+abs(i64 ^ i)
+abs(i64 ^ i32)
 abs(i64)
-abs(i64) != f64
-abs(i64) - f64
-abs(i64) - i64
-abs(i64) .. i64
-abs(i64) == f32
-abs(i64) == i
-abs(i64) == i32
-abs(i64) == nil ? i : f64
-abs(i64) > i64
-abs(i64) >= f64
-abs(i64) in array
+abs(i64) * i32
+abs(i64) ** i
+abs(i64) + f32
+abs(i64) / i
+abs(i64) > i32
+abs(i64) ^ i32
+abs(i64) not in array
 abs(int(0.5))
 abs(int(1))
-abs(int(f32))
-abs(int(f64))
 abs(int(i))
 abs(int(i32))
 abs(int(i64))
 abs(last(array))
-abs(len("bar"))
 abs(len("foo"))
-abs(len(array))
 abs(len(list))
 abs(max(0.5))
-abs(max(1))
-abs(max(1, 1))
-abs(max(1, i64, f64))
 abs(max(f32))
 abs(max(f64))
-abs(max(i))
 abs(max(i32))
 abs(max(i64))
+abs(mean(array))
+abs(median(array))
 abs(min(0.5))
-abs(min(0.5, 1))
 abs(min(1))
-abs(min(1, f32))
 abs(min(f32))
 abs(min(f64))
 abs(min(i))
 abs(min(i32))
-abs(min(i64))
 abs(ok ? 1 : "foo")
-abs(ok ? f32 : 1)
-abs(ok ? i : "bar")
+abs(ok ? f32 : 0.5)
+abs(ok ? f32 : nil)
+abs(ok ? f64 : ok)
+abs(ok ? i32 : foo)
+abs(reduce(array, #))
+abs(reduce(array, i))
+abs(reduce(list, 1))
+abs(reduce(list, i32))
+abs(round(0.5))
+abs(round(1))
+abs(round(f32))
+abs(round(i))
+abs(round(i64))
 abs(score(1))
 abs(score(i))
-abs(true ? f32 : "bar")
-abs(true ? f64 : i32)
+abs(sum(array))
+abs(true ? 1 : ok)
 add
 add != add
+add != add == nil
 add != div
-add != div ? foo : i64
-add != div and ok
-add != foo.Qux
-add != foo.String
-add != foo?.Qux
-add != foo?.String
-add != greet
-add != greet ? score : f32
-add != half
-add != half == nil
-add != half ? 0.5 : ok
-add != nil == nil
-add != nil ? "bar" : f32
-add != nil ? half : f32
-add != score
+add != div != false
+add != div == true
+add != nil ? f64 : i64
+add != reduce(list, add)
 add == add
-add == add == ok
+add == add != nil
+add == add == nil
+add == add ? 1 : i64
 add == div
-add == div ? i32 : f64
-add == div or ok
-add == foo.Qux
-add == foo.String
-add == foo?.Qux
-add == foo?.String
-add == greet
-add == greet ? 1 : 1
-add == half
-add == nil && ok
-add == nil ? "foo" : list
-add == nil ? add : half
-add == nil ? add : score
-add == nil ? i32 : div
-add == nil ? score : i64
-add == nil || ok
-add == score
-add == score != true
-add == score and i32 >= 1
-add == score or 0.5 < 1
-add in [div]
-add not in sort(array)
-add(1, 1) ** i
-add(1, 1) ^ i
-add(1, i) .. i64
-add(i, 1 - i32)
-add(i, abs(i))
+add == div ? f64 : list
+add == nil ? false : i32
+add == nil ? greet : i32
+add == nil ? nil : nil
+add in sort(array)
+add(1, i) < i
+add(i, 1) ** f32
 add(i, i)
-add(i, i64 % 1)
-add(i, min(i))
-add(min(1, 1), i32 * 1)
-add(score(i, i), i)
-all(1 .. i32, ok)
-all(array, !(# <= #))
-all(array, !false)
+add(i, i32 + 1)
+all(1 .. i64, ok)
+all(["bar"], # >= #)
+all(["foo"], # not matches #)
+all([false], # && false)
+all([false], #)
+all(array, !(# >= f64))
 all(array, !ok)
-all(array, !true or 0.5 < #)
-all(array, "bar" in foo)
-all(array, "bar" matches "bar")
+all(array, !true)
+all(array, "foo" < "bar")
 all(array, # != #)
 all(array, # != 1)
 all(array, # != f32)
 all(array, # != f64)
-all(array, # != i64)
+all(array, # != i32)
 all(array, # != nil)
-all(array, # + # >= 0.5 + i)
 all(array, # < #)
 all(array, # < 0.5)
 all(array, # < 1)
+all(array, # < f64)
+all(array, # < i)
+all(array, # < i64)
 all(array, # <= #)
 all(array, # <= 0.5)
-all(array, # <= f64)
 all(array, # <= i)
+all(array, # == # + #)
 all(array, # == #)
 all(array, # == 0.5)
+all(array, # == 1)
+all(array, # == f64)
+all(array, # == i)
 all(array, # == i32)
 all(array, # == i64)
-all(array, # == nil)
 all(array, # > #)
 all(array, # > 0.5)
 all(array, # > 1)
-all(array, # > f32)
 all(array, # > f64)
 all(array, # > i)
+all(array, # > i32)
 all(array, # > i64)
 all(array, # >= #)
 all(array, # >= 0.5)
+all(array, # >= f32)
 all(array, # >= f64)
-all(array, # >= i)
-all(array, # ^ # == i64)
+all(array, # >= i32)
+all(array, # >= i64)
 all(array, # in array)
-all(array, # not in array)
 all(array, 0.5 != #)
-all(array, 0.5 != f32)
-all(array, 0.5 + 0.5 >= #)
 all(array, 0.5 < #)
-all(array, 0.5 < 1)
-all(array, 0.5 < i64)
+all(array, 0.5 < f32)
 all(array, 0.5 <= #)
-all(array, 0.5 == #)
-all(array, 0.5 == f32)
-all(array, 0.5 > #)
-all(array, 0.5 > 1)
+all(array, 0.5 <= f32)
+all(array, 0.5 <= i)
+all(array, 0.5 > f32)
+all(array, 0.5 > f64)
+all(array, 0.5 > i32)
 all(array, 0.5 >= #)
+all(array, 0.5 >= 0.5)
+all(array, 0.5 in array)
 all(array, 1 != #)
-all(array, 1 != i)
-all(array, 1 != i64)
-all(array, 1 != nil)
+all(array, 1 != f32)
 all(array, 1 < #)
-all(array, 1 <= #)
+all(array, 1 < f32)
 all(array, 1 == #)
 all(array, 1 > #)
-all(array, 1 in array)
-all(array, all(array, add != score))
-all(array, all(array, false))
-all(array, all(list, false))
+all(array, 1 > i64)
+all(array, 1 >= #)
+all(array, 1 >= 1)
+all(array, 1 >= i64)
+all(array, f32 < #)
+all(array, f32 <= #)
+all(array, f32 <= f32)
+all(array, f32 > i)
 all(array, f32 >= #)
 all(array, f64 != #)
-all(array, f64 != i32)
-all(array, f64 < #)
 all(array, f64 <= #)
+all(array, f64 <= f32)
 all(array, f64 == #)
-all(array, f64 > #)
-all(array, false or ok)
-all(array, i != f32)
+all(array, f64 == 0.5)
+all(array, f64 == i64)
+all(array, f64 >= i64)
+all(array, false && true)
+all(array, false ? 1 : true)
+all(array, i != 0.5)
+all(array, i <= 0.5)
+all(array, i <= f32)
+all(array, i <= i32)
 all(array, i == #)
-all(array, i > #)
-all(array, i >= #)
+all(array, i32 != #)
 all(array, i32 != i64)
-all(array, i32 < #)
-all(array, i32 <= #)
-all(array, i32 <= i32)
-all(array, i32 > #)
-all(array, i32 >= 1 % #)
-all(array, i64 < #)
-all(array, i64 < 1)
-all(array, i64 < i64)
-all(array, i64 == #)
-all(array, i64 == 0.5)
+all(array, i32 < i)
+all(array, i32 >= #)
+all(array, i64 != #)
+all(array, i64 != i64)
+all(array, i64 == i32)
 all(array, i64 > #)
-all(array, list != list)
+all(array, i64 > 0.5)
+all(array, i64 >= #)
+all(array, nil != "bar")
 all(array, nil != #)
-all(array, nil != i)
+all(array, nil != list)
+all(array, nil != ok)
 all(array, nil == "foo")
-all(array, nil == div)
-all(array, nil in list)
-all(array, not (nil in array))
+all(array, nil == i32)
+all(array, nil == list)
+all(array, none(list, true))
 all(array, not false)
 all(array, not true)
 all(array, ok)
-all(array, one(array, ok))
-all(array, score == add)
-all(array, score(#) > f32)
-all(array, true || false)
-all(array, true) or ok
-all(false ? greet : "foo", # == i32)
-all(filter(array, ok), # < #)
+all(false ? add : "bar", ok)
 all(filter(array, true), ok)
-all(i32 .. 1, 0.5 < i32)
-all(i64 .. i64, # != #)
-all(list, !any(array, false))
+all(groupBy(array, f32).score, 0.5 in #?.f64)
+all(groupBy(list, #).i, #?.half() not in # + #)
+all(i32 .. 1, ok)
 all(list, !false)
-all(list, !ok)
+all(list, "bar" in #)
 all(list, "bar" not in #)
-all(list, "foo" >= "foo")
+all(list, "foo" > "foo")
 all(list, # != #)
-all(list, # != foo)
+all(list, # != nil)
+all(list, # == # || f64 != i64)
 all(list, # == #)
 all(list, # == foo)
-all(list, 0.5 != f64)
-all(list, 0.5 != nil)
-all(list, 0.5 <= f64)
-all(list, 0.5 > 1)
-all(list, 1 != 0.5)
-all(list, 1 != i)
-all(list, 1 < f32)
-all(list, 1 < i)
-all(list, 1 <= 0.5)
-all(list, 1 == 1)
-all(list, 1 > f32)
-all(list, 1 >= i64)
-all(list, all(array, true))
-all(list, array != nil)
-all(list, div != div)
-all(list, f32 != 0.5)
-all(list, f32 == f64)
-all(list, f64 < 1)
-all(list, f64 <= 1)
-all(list, f64 <= i)
-all(list, f64 <= i32)
-all(list, f64 >= 1)
-all(list, false) or 0.5 <= 1
-all(list, foo != #)
-all(list, greet != half)
-all(list, greet == score)
-all(list, i <= i64)
-all(list, i32 != i64)
-all(list, i32 < i64)
+all(list, # in list)
+all(list, # not in list)
+all(list, 0.5 < f64)
+all(list, 0.5 < i64)
+all(list, 0.5 <= i64)
+all(list, 0.5 >= i)
+all(list, 0.5 >= i32)
+all(list, 1 != 1)
+all(list, 1 <= 1)
+all(list, 1 > i32)
+all(list, 1 >= f64)
+all(list, add == div)
+all(list, all(array, ok))
+all(list, div != nil)
+all(list, f64 != 0.5)
+all(list, f64 != f32)
+all(list, f64 < i32)
+all(list, f64 > i64)
+all(list, false ? i : true)
+all(list, i < f32)
+all(list, i <= 1)
+all(list, i <= i32)
+all(list, i > f64)
+all(list, i > i32)
+all(list, i >= 1)
+all(list, i32 < 1)
 all(list, i32 <= 0.5)
-all(list, i32 <= f64)
-all(list, int(i32) != i32)
+all(list, i32 == f32)
+all(list, i64 != nil)
+all(list, i64 <= 0.5)
+all(list, i64 > 1)
 all(list, list != nil)
 all(list, nil != 1)
-all(list, nil != foo)
+all(list, nil != i64)
+all(list, nil != nil)
+all(list, nil != score)
 all(list, nil == #)
-all(list, nil == greet)
-all(list, nil in list)
-all(list, none(array, ok))
-all(list, not false)
-all(list, not ok)
+all(list, nil == score)
+all(list, nil in array)
+all(list, none(array, 1 > #))
 all(list, not true)
-all(list, ok and false)
 all(list, ok)
-all(list, ok) or ok
-all(list, true != false)
-all(list, true != true)
-all(list, true ? true : 1)
-all(list[i64:i32], !false)
-all(map(array, #), # != #)
-all(map(array, #), # != 0.5)
-all(map(array, #), # >= #)
-all(map(array, #), i64 == #)
-all(map(array, #), true or false)
-all(map(array, 1), ok)
-all(map(array, i), f64 > #)
-all(map(array, ok), #)
-all(map(list, "bar"), ok)
-all(map(list, #), "bar" not in #)
-all(map(list, #), f32 > 1)
-all(map(list, 1), ok)
-all(map(list, false), #)
-all(map(list, i64), # <= #)
+all(list, reduce(array, true))
+all(list, type(i) not endsWith .Bar)
+all(map(array, #), ok && false)
+all(map(array, #), ok)
+all(map(array, f32), !ok)
+all(map(array, false), #)
+all(map(array, score), # != #)
+all(map(array, score), ok)
+all(map(list, "bar" not in #), #)
+all(map(list, 0.5), 0.5 <= #)
+all(map(list, i), # == 0.5)
+all(map(list, list), 1 == 0.5)
 all(map(list, ok), #)
-all(map(list, true), # == #)
-all(map(list, true), #)
-all(map(list, true), ok)
-any([0.5, add, 0.5], # == #)
-any([1], i64 >= #)
-any(array, !false)
-any(array, "foo" <= "foo")
+all(reduce(array, array), # > #)
+all(reduce(array, list), ok)
+all(true ? list : false, not true)
+any(["bar"], # not endsWith #)
+any([greet], ok)
+any(array, !(i32 <= #))
+any(array, "foo" >= "foo")
+any(array, "foo" not endsWith "bar")
+any(array, # != # or # > #)
 any(array, # != #)
 any(array, # != 0.5)
-any(array, # != 1)
-any(array, # != i)
+any(array, # != f32)
+any(array, # != f64)
 any(array, # != i32)
 any(array, # != i64)
 any(array, # != nil)
@@ -2926,259 +3094,734 @@ any(array, # < i)
 any(array, # < i32)
 any(array, # <= #)
 any(array, # <= 0.5)
-any(array, # <= 1 ^ #)
 any(array, # <= 1)
+any(array, # <= f32)
 any(array, # <= i)
 any(array, # <= i32)
+any(array, # <= i64)
 any(array, # == #)
+any(array, # == 0.5)
 any(array, # == 1)
-any(array, # == f64)
-any(array, # == i)
 any(array, # == i32)
 any(array, # == i64)
-any(array, # == nil)
 any(array, # > #)
+any(array, # > 0.5)
 any(array, # > 1)
+any(array, # > f64)
 any(array, # > i32)
-any(array, # > i64)
 any(array, # >= #)
 any(array, # >= 0.5)
 any(array, # >= 1)
-any(array, # >= f64)
-any(array, # >= i)
+any(array, # >= f32)
 any(array, # >= i32)
+any(array, # >= i64)
 any(array, # in array)
-any(array, # not in array)
 any(array, 0.5 != #)
-any(array, 0.5 != f64)
-any(array, 0.5 != i)
-any(array, 0.5 < 0.5)
-any(array, 0.5 <= #)
 any(array, 0.5 == #)
-any(array, 0.5 == 0.5)
+any(array, 0.5 == i32)
 any(array, 0.5 > #)
-any(array, 0.5 > f32)
+any(array, 0.5 > f64)
+any(array, 0.5 >= #)
+any(array, 1 != i64)
 any(array, 1 < #)
-any(array, 1 <= i64)
+any(array, 1 < 0.5)
+any(array, 1 <= #)
 any(array, 1 == #)
-any(array, 1 > f64)
-any(array, 1 >= i)
-any(array, 1 >= i32)
-any(array, all(list, true))
-any(array, array == array)
-any(array, div != nil)
-any(array, f32 < #)
+any(array, 1 > #)
+any(array, 1 > 1)
+any(array, 1 >= #)
+any(array, 1 >= f64)
+any(array, all(list, false))
+any(array, f32 < i)
 any(array, f32 > #)
+any(array, f32 > 0.5)
+any(array, f32 >= #)
 any(array, f64 != #)
-any(array, f64 != 1)
-any(array, f64 < #)
-any(array, f64 <= 0.5)
-any(array, f64 <= f32)
+any(array, f64 < i)
+any(array, f64 <= #)
 any(array, f64 == #)
 any(array, f64 > #)
 any(array, f64 > 0.5)
-any(array, f64 >= i64)
-any(array, false != nil)
-any(array, false) and f32 != f32
-any(array, greet != half)
-any(array, half != div)
-any(array, half != nil)
-any(array, i != 1)
-any(array, i < # ** #)
-any(array, i <= #)
-any(array, i == #)
-any(array, i == i)
+any(array, false && false)
+any(array, greet == greet)
+any(array, i != #)
+any(array, i < #)
 any(array, i > #)
 any(array, i >= #)
-any(array, i32 != #)
-any(array, i32 != i64)
-any(array, i32 <= #)
-any(array, i32 == #)
-any(array, i32 > #)
-any(array, i32 >= i64)
-any(array, i64 != #)
-any(array, i64 != i64)
-any(array, i64 <= 0.5)
-any(array, i64 == #)
-any(array, i64 > #)
-any(array, i64 > 1)
-any(array, i64 > f32)
-any(array, i64 >= i)
+any(array, i32 > i64)
+any(array, i64 < #)
+any(array, i64 == f64)
+any(array, i64 >= #)
 any(array, nil != #)
-any(array, nil != f64)
-any(array, nil != greet)
+any(array, nil != 1)
+any(array, nil != i)
+any(array, nil != ok)
+any(array, nil == "foo")
 any(array, nil == #)
 any(array, nil == 1)
-any(array, not ok)
-any(array, not true)
+any(array, ok != true)
 any(array, ok)
-any(array, one(list, false))
-any(array, true ? ok : f32)
-any(array, true) and ok
-any(filter(array, ok), ok)
-any(filter(list, false), ok)
-any(filter(list, true), # == #)
+any(array, one(array, # <= 0.5))
+any(array, one(array, ok))
+any(array, score == nil)
+any(i32 .. i, half == half)
+any(list, !ok)
 any(list, !true)
-any(list, "bar" contains "foo")
-any(list, "bar" matches "foo")
+any(list, "bar" < "foo")
 any(list, "bar" not in #)
 any(list, "bar" not startsWith "foo")
+any(list, "foo" not in foo)
 any(list, # != #)
-any(list, # != foo)
-any(list, # != nil)
 any(list, # == #)
+any(list, # == foo)
 any(list, # == nil)
-any(list, # in list)
-any(list, # not in list)
+any(list, 0.5 != 1)
 any(list, 0.5 < 1)
-any(list, 0.5 <= f32)
-any(list, 0.5 == 0.5)
-any(list, 0.5 >= 0.5)
-any(list, 0.5 >= f32)
-any(list, 0.5 >= i64)
-any(list, 1 <= 0.5)
-any(list, 1 == f32)
-any(list, f32 != i)
-any(list, f32 == nil)
-any(list, f32 >= i)
-any(list, f64 <= 1)
-any(list, f64 > 0.5)
-any(list, false ? nil : false)
-any(list, foo == foo)
-any(list, greet == div)
-any(list, half != nil)
-any(list, i != 1)
-any(list, i < f32)
-any(list, i < f64)
+any(list, 0.5 < f64)
+any(list, 0.5 == i64)
+any(list, 1 >= f64)
+any(list, 1 >= i32)
+any(list, any(list, false))
+any(list, any(list, ok))
+any(list, array == nil)
+any(list, f32 < 1)
+any(list, f32 <= i64)
+any(list, f32 > 1)
+any(list, f32 > i64)
+any(list, f32 >= i32)
+any(list, f64 != i64)
+any(list, f64 >= 1)
+any(list, false) == (foo not in list)
+any(list, false) || false ? nil : add
 any(list, i > i64)
-any(list, i32 != i32)
-any(list, i32 < 0.5)
-any(list, i32 == f64)
-any(list, i64 < 1)
-any(list, i64 < f64)
-any(list, i64 < i64)
-any(list, i64 <= i32)
-any(list, i64 >= 1)
-any(list, i64 >= f32)
-any(list, list != nil)
-any(list, nil != #)
-any(list, nil != #?.String())
-any(list, nil != nil)
-any(list, nil == #)
-any(list, nil == 1)
-any(list, nil == i64)
+any(list, i >= 0.5)
+any(list, i32 != 0.5)
+any(list, i64 <= 1)
+any(list, i64 == 0.5)
+any(list, i64 == i)
+any(list, i64 >= i32)
+any(list, i64 not in array)
+any(list, nil == false)
 any(list, nil == nil)
-any(list, not false)
+any(list, none(array, false))
 any(list, not ok)
-any(list, ok and foo != #)
+any(list, ok || # == #)
 any(list, ok)
-any(list, ok) && i <= 1
-any(list, ok) ? array : foo
-any(list, true or ok)
-any(list, true) ? f64 : foo.Bar
-any(map(array, #), # == #)
+any(list, reduce(list, true))
+any(list, true ? false : f64)
+any(map(array, #), # >= #)
 any(map(array, #), ok)
-any(map(array, 0.5), # <= #)
-any(map(array, f64), # < #)
 any(map(array, false), #)
+any(map(array, ok), # and #)
 any(map(array, ok), #)
-any(map(list, #), i == f64)
-any(map(list, #), ok)
-any(map(list, 1), # != #)
-any(map(list, array), ok)
-any(map(list, foo), # != #)
-any(map(list, greet), # == #)
-any(ok ? "bar" : half, ok)
-any(splitAfter("bar", "foo"), # not startsWith #)
+any(map(list, #), nil == #)
+any(map(list, false), nil == i32)
+any(map(list, ok), #)
+any(ok ? "foo" : 1, ok)
+any(ok ? "foo" : f32, i > #)
+any(reduce(array, array), 1 == #)
 array
-array != [array]
 array != array
-array != filter(list, true)
+array != array ? 1 : false
+array != array ? score : i32
 array != list
-array != map(array, i)
-array != nil != ok
-array != nil ? 0.5 : i32
-array != nil ? true : nil
-array != nil or nil == f32
-array != nil || ok
-array != sort(array)
-array != {"bar": f32, "foo": 1}.ok
+array != list ? list : f64
+array != map(array, #)
+array != map(array, 1)
+array != map(list, #)
+array != map(list, true)
+array != nil ? add : 0.5
 array == array
-array == array ? "foo" : 0.5
+array == array ? half : false
 array == list
-array == list ? i : half
-array == map(array, #)
-array == map(array, add)
-array == nil != nil
-array == nil != true ? 0.5 : 0.5
-array == nil && (false || ok)
-array[-1]
+array == map(array, score)
+array == map(list, #)
+array == nil ? list : float(f32)
+array not in sort(array)
 array[-i32]
 array[-i64]
 array[-i]
-array[1 % 1]
-array[1 % i:i64]
-array[1] != f32
-array[1] != score(i)
-array[1] <= f64
-array[1] == f32
-array[1] == i64
-array[1] ^ 0.5 ^ f64
-array[1] ^ i32
-array[false ? half : 0.5]
-array[false ? i : i32]
-array[i - i64]
-array[i32:i32]
+array[1 % i64]
+array[1 + 1]
+array[1] * i32
+array[1] * i64
+array[1] - f64
+array[1] / i32
+array[1] == -i
+array[1] > i
+array[1] ^ i
+array[abs(1)]
+array[array[i32]]
+array[bitnot(1)]
+array[bitor(1, i)]
+array[count(list, ok)]
+array[get(array, 1)]
+array[i32 * 1]
+array[i32:i]
 array[i32]
+array[i32] != i
+array[i32] % i32
+array[i32] * f64
+array[i32] ** i32
+array[i32] + i64
 array[i32] - f64
-array[i32] .. i32
-array[i64 % 1]
-array[i64:i32]
-array[i64:i]
+array[i32] / f32
+array[i32] == i32
+array[i32] == i64
+array[i32] > f64
+array[i32] >= f32
+array[i64:i64]
 array[i64]
-array[i64] ** f32
-array[i64] / i
-array[i64] < i
-array[i64] == f64
-array[i64] > f32
-array[i64] >= -i64
+array[i64] .. i32
+array[i64] == floor(0.5)
+array[i64] == i
+array[i64] > half(f64)
+array[i64] ^ f64
+array[i:i32]
 array[i:i64]
-array[i:i]
 array[i]
-array[i] ** i64
+array[i] * f64
 array[i] + f32
-array[i] < i
-array[i] == min(i32, i)
-array[i] > i32
-array[int(1)]
-array[int(i32)]
-array[max(i64)]
-array[min(1)]
-array[min(i32)]
-array[min(i64)]
+array[i] - f32
+array[i] / f64
+array[i] < round(i)
+array[i] == i32
+array[i] > f64
+array[i] >= 0.5 ** i
+array[max(1)]
+array[reduce(list, 1)]
+array[score(1):i]
 array[score(1)]
 array[score(i)]
-count([list], false or ok)
+bitand(1 * i64, i)
+bitand(1, 1) != i
+bitand(1, i64) == f64
+bitand(i, i)
+bitand(i, i32)
+bitand(i, i64)
+bitand(i32, 1) != f32
+bitand(i32, i)
+bitand(i32, i) - i32
+bitand(i32, i32 * i)
+bitand(i32, i32)
+bitand(i32, i64)
+bitand(i64, 1) <= i32
+bitand(i64, i + i64)
+bitand(i64, i)
+bitand(i64, i) ^ f64
+bitand(i64, i32)
+bitand(i64, i64)
+bitand(int(i32), i64)
+bitnand(1, i64) != int(i64)
+bitnand(i, i)
+bitnand(i, i32 + i32)
+bitnand(i, i32)
+bitnand(i, i64)
+bitnand(i32, bitnot(1))
+bitnand(i32, i)
+bitnand(i32, i32)
+bitnand(i32, i64)
+bitnand(i64 + i, i32)
+bitnand(i64 + i64, i64)
+bitnand(i64, -1)
+bitnand(i64, 1) + i64 + 1
+bitnand(i64, i)
+bitnand(i64, i32)
+bitnand(i64, i32) > f64
+bitnand(i64, i64)
+bitnot(-1)
+bitnot(-i)
+bitnot(-i32)
+bitnot(-i64)
+bitnot(1 % 1)
+bitnot(1 % i32)
+bitnot(1 % i64)
+bitnot(1 * 1)
+bitnot(1 * i64)
+bitnot(1 + 1)
+bitnot(1 - i)
+bitnot(1 - i32)
+bitnot(1) * i % 1
+bitnot(1) ** f32
+bitnot(1) ** i
+bitnot(1) + i32
+bitnot(1) - i
+bitnot(1) - i32
+bitnot(1) / min(i)
+bitnot(1) < i32
+bitnot(1) < i64
+bitnot(1) == i32
+bitnot(1) > f64
+bitnot(1) >= i
+bitnot(1) >= i64
+bitnot(abs(1))
+bitnot(abs(i32))
+bitnot(abs(i64))
+bitnot(array[1])
+bitnot(array[i64])
+bitnot(array[i])
+bitnot(bitnot(i))
+bitnot(bitushr(1, 1))
+bitnot(bitushr(i32, 1))
+bitnot(bitxor(i, i64))
+bitnot(count(array, false))
+bitnot(findLast(array, ok))
+bitnot(first(array))
+bitnot(get(array, 1))
+bitnot(get(array, i))
+bitnot(i % i64)
+bitnot(i * i)
+bitnot(i * i32)
+bitnot(i + 1)
+bitnot(i - 1)
+bitnot(i - i64)
+bitnot(i)
+bitnot(i) % i32
+bitnot(i) * i
+bitnot(i) + f64
+bitnot(i) .. i64
+bitnot(i) == 1 - i
+bitnot(i) > i
+bitnot(i) >= i32
+bitnot(i) ^ f32
+bitnot(i) ^ f64
+bitnot(i) in array
+bitnot(i32 % 1)
+bitnot(i32 % i64)
+bitnot(i32 + i)
+bitnot(i32 + i32)
+bitnot(i32 - 1)
+bitnot(i32 - i32)
+bitnot(i32)
+bitnot(i32) != f64
+bitnot(i32) != i32
+bitnot(i32) * i
+bitnot(i32) * i64
+bitnot(i32) ** f32
+bitnot(i32) - i32
+bitnot(i32) / f64
+bitnot(i32) == i64
+bitnot(i32) > 1 != true
+bitnot(i32) >= f32
+bitnot(i64 % 1)
+bitnot(i64 % i)
+bitnot(i64 % i32)
+bitnot(i64 * 1)
+bitnot(i64 * i)
+bitnot(i64 * i32)
+bitnot(i64 * i64)
+bitnot(i64 - 1)
+bitnot(i64 - i)
+bitnot(i64 - i64)
+bitnot(i64)
+bitnot(i64) % i32
+bitnot(i64) * f32
+bitnot(i64) < f32
+bitnot(i64) > f64
+bitnot(i64) > i % i
+bitnot(i64) >= i32 ^ f32
+bitnot(i64) ^ f64
+bitnot(i64) not in array
+bitnot(int(f32))
+bitnot(int(f64))
+bitnot(int(i))
+bitnot(int(i32))
+bitnot(int(i64))
+bitnot(last(array))
+bitnot(len("bar"))
+bitnot(len("foo"))
+bitnot(len(list))
+bitnot(max(1))
+bitnot(max(1, i64))
+bitnot(max(i))
+bitnot(max(i32))
+bitnot(min(1))
+bitnot(min(i32))
+bitnot(min(i64))
+bitnot(ok ? 1 : array)
+bitnot(ok ? 1 : ok)
+bitnot(ok ? i : add)
+bitnot(reduce(array, #))
+bitnot(reduce(array, 1))
+bitnot(reduce(list, 1))
+bitnot(score(1))
+bitnot(score(i))
+bitnot(sum(array))
+bitor(1, 1) < i
+bitor(1, 1) == i
+bitor(1, i32) != i64
+bitor(i, -i64)
+bitor(i, i)
+bitor(i, i64)
+bitor(i32, i)
+bitor(i32, i32)
+bitor(i32, i64)
+bitor(i64 % 1, i32)
+bitor(i64, i)
+bitor(i64, i32)
+bitor(i64, i64)
+bitor(min(i64), i)
+bitor(score(i), i64)
+bitshl(bitnot(i), i)
+bitshl(i, i)
+bitshl(i, i32)
+bitshl(i, i64)
+bitshl(i32, i)
+bitshl(i32, i32)
+bitshl(i32, i64)
+bitshl(i64, i32)
+bitshl(i64, i64)
+bitshl(len(array), i)
+bitshl(score(i), i32)
+bitshr(i % 1, i32)
+bitshr(i, 1) - i64
+bitshr(i, i32)
+bitshr(i, i64)
+bitshr(i32, i)
+bitshr(i32, i) - f32
+bitshr(i32, i32)
+bitshr(i32, i64)
+bitshr(i64, i32)
+bitshr(i64, i64)
+bitushr(-i64, i64)
+bitushr(1 % i, i)
+bitushr(1, i) * i
+bitushr(abs(1), i32)
+bitushr(i, i)
+bitushr(i, i) % i64
+bitushr(i, i32)
+bitushr(i, i64)
+bitushr(i32, i)
+bitushr(i32, i32)
+bitushr(i32, i64)
+bitushr(i64, i)
+bitushr(i64, i32)
+bitushr(i64, i64)
+bitxor(-i, i64)
+bitxor(1, i) * i
+bitxor(bitnot(1), -i)
+bitxor(i, i32)
+bitxor(i, i64)
+bitxor(i32, 1) > i64
+bitxor(i32, i)
+bitxor(i32, i) ** f64
+bitxor(i32, i32)
+bitxor(i32, i64)
+bitxor(i32, i64) ** i32
+bitxor(i64, i)
+bitxor(i64, i32)
+bitxor(i64, i64)
+bitxor(score(1), i)
+ceil(-0.5)
+ceil(-1)
+ceil(-f32)
+ceil(-f64)
+ceil(-i)
+ceil(-i32)
+ceil(-i64)
+ceil(0.5 * 0.5)
+ceil(0.5 * 1)
+ceil(0.5 * f64)
+ceil(0.5 * i)
+ceil(0.5 ** 1)
+ceil(0.5 ** f64)
+ceil(0.5 ** i)
+ceil(0.5 + 0.5)
+ceil(0.5 + 1)
+ceil(0.5 + f32)
+ceil(0.5 + f64)
+ceil(0.5 + i)
+ceil(0.5 + i32)
+ceil(0.5 + i64)
+ceil(0.5 - 0.5)
+ceil(0.5 - f64)
+ceil(0.5 - i)
+ceil(0.5 / 0.5)
+ceil(0.5 / 1)
+ceil(0.5 / f32)
+ceil(0.5 / i)
+ceil(0.5 / i32)
+ceil(0.5 ^ 1)
+ceil(0.5 ^ f32)
+ceil(0.5 ^ i32)
+ceil(0.5 ^ i64)
+ceil(0.5) != 0.5 * 0.5
+ceil(0.5) != i
+ceil(0.5) != nil ? score : "foo"
+ceil(0.5) ** round(f32)
+ceil(0.5) - i
+ceil(0.5) < i
+ceil(0.5) == f32
+ceil(0.5) == i ? div : half
+ceil(0.5) == i64
+ceil(0.5) > f64
+ceil(0.5) >= i
+ceil(0.5) >= i64
+ceil(0.5) ^ i64
+ceil(1 % i64)
+ceil(1 * 0.5)
+ceil(1 * 1)
+ceil(1 ** 1)
+ceil(1 + 0.5)
+ceil(1 + 1)
+ceil(1 + f64)
+ceil(1 + i)
+ceil(1 - 0.5)
+ceil(1 - f64)
+ceil(1 / 0.5)
+ceil(1 / 1)
+ceil(1 / f64)
+ceil(1 / i64)
+ceil(1 ^ f64)
+ceil(1 ^ i)
+ceil(1 ^ i64)
+ceil(1) ** f32
+ceil(1) + i32
+ceil(1) / i
+ceil(1) < f32 ^ i
+ceil(1) <= f32
+ceil(1) <= i64
+ceil(1) == f32
+ceil(1) > f32
+ceil(1) >= f32
+ceil(1) >= i64 ** 0.5
+ceil(1) ^ i
+ceil(abs(0.5))
+ceil(abs(1))
+ceil(abs(f32))
+ceil(abs(f64))
+ceil(abs(i32))
+ceil(abs(i64))
+ceil(add(1, 1))
+ceil(array[1])
+ceil(array[i64])
+ceil(array[i])
+ceil(bitnot(1))
+ceil(bitnot(i))
+ceil(ceil(0.5))
+ceil(ceil(f64))
+ceil(ceil(i))
+ceil(ceil(i32))
+ceil(count(list, ok))
+ceil(f32 * 0.5)
+ceil(f32 * i)
+ceil(f32 * i32)
+ceil(f32 ** i)
+ceil(f32 ** i32)
+ceil(f32 + 1)
+ceil(f32 + i64)
+ceil(f32 - f32)
+ceil(f32 - i)
+ceil(f32 - i32)
+ceil(f32 - i64)
+ceil(f32 / 0.5)
+ceil(f32 / f64)
+ceil(f32 / i32)
+ceil(f32 ^ 0.5)
+ceil(f32 ^ 1)
+ceil(f32 ^ i64)
+ceil(f32)
+ceil(f32) != i64
+ceil(f32) * i64
+ceil(f32) ** -1
+ceil(f32) ** i
+ceil(f32) + i
+ceil(f32) + i64
+ceil(f32) - i32
+ceil(f32) / i64
+ceil(f32) < i
+ceil(f32) < i32
+ceil(f64 * 1)
+ceil(f64 * i)
+ceil(f64 ** i)
+ceil(f64 ** i64)
+ceil(f64 + 1)
+ceil(f64 + f32)
+ceil(f64 - 0.5)
+ceil(f64 - f32)
+ceil(f64 - f64)
+ceil(f64 - i32)
+ceil(f64 / 0.5)
+ceil(f64 / f64)
+ceil(f64 / i32)
+ceil(f64 / i64)
+ceil(f64 ^ 0.5)
+ceil(f64 ^ f32)
+ceil(f64 ^ f64)
+ceil(f64 ^ i32)
+ceil(f64 ^ i64)
+ceil(f64)
+ceil(f64) != i
+ceil(f64) != i64
+ceil(f64) * f32
+ceil(f64) ** f32
+ceil(f64) - i32
+ceil(f64) / f64
+ceil(f64) / i / i64
+ceil(f64) in array
+ceil(false ? add : 0.5)
+ceil(find(array, ok))
+ceil(findLast(array, true))
+ceil(findLastIndex(list, ok))
+ceil(findLastIndex(list, true))
+ceil(first(array))
+ceil(float(0.5))
+ceil(float(1))
+ceil(float(f64))
+ceil(float(i))
+ceil(float(i32))
+ceil(float(i64))
+ceil(floor(0.5))
+ceil(floor(1))
+ceil(floor(f64))
+ceil(floor(i))
+ceil(floor(i32))
+ceil(floor(i64))
+ceil(get(array, 1))
+ceil(get(array, i))
+ceil(half(0.5))
+ceil(half(1))
+ceil(half(f64))
+ceil(i % i)
+ceil(i * 0.5)
+ceil(i * i)
+ceil(i ** f64)
+ceil(i ** i)
+ceil(i + 0.5)
+ceil(i + 1)
+ceil(i + f32)
+ceil(i + i64)
+ceil(i - i)
+ceil(i / f32)
+ceil(i / i)
+ceil(i / i64)
+ceil(i ^ i)
+ceil(i ^ i32)
+ceil(i)
+ceil(i) != i32
+ceil(i) * f64
+ceil(i) * i64
+ceil(i) ** f64
+ceil(i) + i
+ceil(i) - f32
+ceil(i) / f32
+ceil(i) <= f64
+ceil(i) == i32
+ceil(i) > i64
+ceil(i32 * i)
+ceil(i32 * i32)
+ceil(i32 ** i32)
+ceil(i32 + 0.5)
+ceil(i32 + i32)
+ceil(i32 - 0.5)
+ceil(i32 - 1)
+ceil(i32 - i)
+ceil(i32 - i64)
+ceil(i32 / 0.5)
+ceil(i32 / f32)
+ceil(i32 / i)
+ceil(i32 / i32)
+ceil(i32 ^ 0.5)
+ceil(i32 ^ i64)
+ceil(i32)
+ceil(i32) * 1 ^ i32
+ceil(i32) * i32
+ceil(i32) ** max(i)
+ceil(i32) + f32
+ceil(i32) + i
+ceil(i32) + i32
+ceil(i32) <= i64
+ceil(i32) not in array
+ceil(i64 % 1)
+ceil(i64 % i32)
+ceil(i64 * f32)
+ceil(i64 * f64)
+ceil(i64 ** i32)
+ceil(i64 ** i64)
+ceil(i64 + 0.5)
+ceil(i64 + f64)
+ceil(i64 + i32)
+ceil(i64 - 0.5)
+ceil(i64 - f64)
+ceil(i64 / 0.5)
+ceil(i64 / 1)
+ceil(i64 / f64)
+ceil(i64 ^ 0.5)
+ceil(i64 ^ i)
+ceil(i64 ^ i32)
+ceil(i64 ^ i64)
+ceil(i64)
+ceil(i64) - -1
+ceil(i64) - f32
+ceil(i64) - i32
+ceil(i64) / (0.5 - f32)
+ceil(i64) >= f32
+ceil(i64) ^ i32
+ceil(int(0.5))
+ceil(int(f32))
+ceil(int(f64))
+ceil(int(i))
+ceil(int(i64))
+ceil(len("bar"))
+ceil(len(array))
+ceil(len(list))
+ceil(max(1, i))
+ceil(max(f32, 0.5))
+ceil(max(f64))
+ceil(max(i))
+ceil(mean(array))
+ceil(median(array))
+ceil(min(0.5, f32))
+ceil(min(1))
+ceil(min(f32))
+ceil(min(f64))
+ceil(min(i))
+ceil(min(i64))
+ceil(ok ? f32 : nil)
+ceil(ok ? i32 : "bar")
+ceil(ok ? i32 : i64)
+ceil(reduce(array, #))
+ceil(reduce(array, 0.5))
+ceil(reduce(list, 1))
+ceil(round(0.5))
+ceil(round(1))
+ceil(round(f32))
+ceil(round(f64))
+ceil(round(i))
+ceil(round(i32))
+ceil(round(i64))
+ceil(score(1))
+ceil(score(i))
+ceil(true ? 1 : half)
+ceil(true ? 1 : nil)
+ceil(true ? f64 : nil)
+count(["bar", score, i], 1 != #)
+count(["bar"], # startsWith #)
+count([0.5], ok)
+count([greet], ok)
+count([i32], f32 != #)
+count([list, 0.5], # not in list)
+count([nil], ok)
 count(array, !ok)
-count(array, "bar" != "bar")
+count(array, !true)
+count(array, "bar" <= "bar")
 count(array, "bar" not endsWith "bar")
+count(array, "foo" matches "foo")
 count(array, # != #)
-count(array, # != f32)
-count(array, # != i32)
+count(array, # != 0.5)
+count(array, # != i)
+count(array, # != i64)
+count(array, # != nil)
 count(array, # < #)
-count(array, # < 0.5)
-count(array, # < 1)
-count(array, # < f32)
-count(array, # < f64)
 count(array, # < i)
-count(array, # < i64)
+count(array, # < i32)
 count(array, # <= #)
 count(array, # <= 0.5)
-count(array, # <= f32)
-count(array, # <= f64)
+count(array, # <= 1)
 count(array, # <= i)
 count(array, # <= i32)
 count(array, # == #)
+count(array, # == 0.5)
 count(array, # == 1)
 count(array, # == f32)
 count(array, # == i)
@@ -3188,2511 +3831,2520 @@ count(array, # > #)
 count(array, # > 0.5)
 count(array, # > i)
 count(array, # > i64)
-count(array, # >= # / #)
 count(array, # >= #)
 count(array, # >= 0.5)
 count(array, # >= 1)
-count(array, # >= f64)
+count(array, # >= f32)
 count(array, # >= i)
-count(array, # >= i64)
+count(array, # in array)
+count(array, # not in array)
 count(array, 0.5 != #)
+count(array, 0.5 < #)
 count(array, 0.5 <= #)
+count(array, 0.5 <= f32)
+count(array, 0.5 <= f64)
 count(array, 0.5 == #)
+count(array, 0.5 == f32)
+count(array, 0.5 == i)
 count(array, 0.5 > #)
-count(array, 0.5 > 1)
-count(array, 0.5 >= #)
-count(array, 0.5 >= 0.5)
-count(array, 0.5 >= i)
 count(array, 1 != #)
+count(array, 1 != 0.5)
 count(array, 1 < #)
-count(array, 1 < 0.5)
-count(array, 1 < 1)
 count(array, 1 <= #)
-count(array, 1 > #)
+count(array, 1 == #)
 count(array, 1 >= #)
-count(array, add == half)
-count(array, f32 != i)
-count(array, f32 < # ? true : half)
-count(array, f32 < #)
-count(array, f32 < 0.5)
+count(array, any(array, true))
+count(array, div(#, 1) >= #)
 count(array, f32 <= #)
-count(array, f32 <= 1)
-count(array, f32 <= i)
 count(array, f32 == #)
-count(array, f32 == 1)
-count(array, f64 != #)
 count(array, f64 < #)
+count(array, f64 < f32)
 count(array, f64 <= #)
+count(array, f64 <= 1)
 count(array, f64 == #)
-count(array, f64 > #)
-count(array, false == true)
-count(array, false) != f64
-count(array, false) / i
-count(array, false) >= f32
+count(array, false) ** i32
+count(array, false) + f32
+count(array, false) - i64
+count(array, false) / f64
+count(array, false) > i64 * i64
+count(array, foo in list)
 count(array, foo not in list)
-count(array, greet != greet)
-count(array, greet == score)
-count(array, i != f32)
-count(array, i == nil)
-count(array, i > #)
+count(array, i != #)
+count(array, i < #)
+count(array, i < 0.5)
+count(array, i <= #)
+count(array, i == #)
+count(array, i > i64)
 count(array, i >= #)
-count(array, i32 != 1)
+count(array, i32 != #)
+count(array, i32 != i)
 count(array, i32 < #)
-count(array, i32 < 0.5)
+count(array, i32 < 1)
+count(array, i32 <= #)
+count(array, i32 <= f32)
 count(array, i32 == #)
-count(array, i32 > i)
+count(array, i32 == 0.5)
+count(array, i32 > #)
 count(array, i32 >= #)
-count(array, i32 >= 1)
-count(array, i64 != #)
+count(array, i32 >= f32)
+count(array, i32 >= i32)
+count(array, i64 != i32)
+count(array, i64 != i64)
 count(array, i64 < #)
-count(array, i64 <= 1)
-count(array, i64 <= f64)
+count(array, i64 <= #)
 count(array, i64 == #)
 count(array, i64 == i64)
 count(array, i64 > 1)
-count(array, i64 > f32)
-count(array, nil != #)
-count(array, nil == #)
-count(array, nil == foo)
-count(array, not ok)
+count(array, list != array)
+count(array, list != nil)
+count(array, nil != "foo")
+count(array, nil != f64)
+count(array, nil == 1)
+count(array, nil == list)
+count(array, nil == nil)
+count(array, none(array, false))
+count(array, not false)
+count(array, ok or false)
 count(array, ok)
-count(array, ok) + i64
-count(array, ok) - i64
-count(array, ok) .. i64
-count(array, one(array, false))
-count(array, true ? false : 0.5)
-count(array, true) != 1 ^ f32
-count(array, true) ** f32
-count(array, true) / int(0.5)
-count(array, true) >= f64 / 0.5
-count(filter(list, false), ok)
-count(i .. 1, # > #)
-count(i .. i32, # > #)
-count(i32 .. 1, # == #)
-count(i64 .. i, div == nil)
-count(i64 .. i, ok)
+count(array, ok) * i32
+count(array, ok) ^ i
+count(array, reduce(list, false))
+count(array, true == ok)
+count(array, true) / f64
+count(filter(list, true), ok)
+count(groupBy(list, #).String, .div?.array)
+count(i .. 1, # == i)
+count(i .. i, ok)
+count(i32 .. i, # >= #)
+count(i64 .. 1, nil != f32)
 count(list, !false)
-count(list, !ok)
-count(list, "bar" == "bar")
-count(list, "bar" in #)
-count(list, "bar" matches "foo")
-count(list, "bar" not in #)
+count(list, !true)
+count(list, "bar" not matches "bar")
 count(list, "foo" in #)
-count(list, "foo" not in #)
 count(list, # != #)
-count(list, # != nil)
 count(list, # == #)
 count(list, # == nil)
-count(list, 0.5 == f32)
+count(list, # in list)
+count(list, 0.5 < f32)
+count(list, 0.5 <= 0.5)
+count(list, 0.5 <= i64)
 count(list, 0.5 > 0.5)
-count(list, 0.5 >= i32)
-count(list, 1 != 1)
-count(list, 1 != f32)
-count(list, 1 < 0.5)
-count(list, 1 <= i)
+count(list, 0.5 > 1)
+count(list, 0.5 > f32)
+count(list, 1 != i)
+count(list, 1 >= 0.5)
 count(list, 1 >= f32)
-count(list, 1 >= i32)
-count(list, all(list, true))
-count(list, f32 <= i32)
-count(list, f64 != i)
-count(list, false ? # : ok)
-count(list, false or ok)
-count(list, false || false)
-count(list, false) .. i32
-count(list, false) > i64
-count(list, foo != #)
-count(list, half == div)
-count(list, i == i64)
-count(list, i32 == i)
-count(list, i32 == i32)
-count(list, list == array)
+count(list, f32 == i64)
+count(list, f32 >= f32)
+count(list, false && false)
+count(list, false) + -1
+count(list, false) / f64
+count(list, false) > f32
+count(list, foo == #)
+count(list, i != i64)
+count(list, i < 0.5)
+count(list, i <= i64)
+count(list, i > 1)
+count(list, i32 < f32)
+count(list, i32 < i64)
+count(list, i64 not in array)
 count(list, nil != #)
-count(list, nil != score)
-count(list, nil == #)
-count(list, nil == add)
-count(list, nil == true)
-count(list, none(list, ok))
+count(list, nil != false)
+count(list, nil == list)
 count(list, not false)
-count(list, not ok)
-count(list, not true)
-count(list, ok == nil)
 count(list, ok)
-count(list, ok) - i32
-count(list, ok) < f64
-count(list, ok) > -0.5
-count(list, ok) >= i
-count(list, true and ok)
-count(list, true) ** i64
-count(list, true) == f64
-count(list, true) ^ i64
-count(map(array, #), # != #)
-count(map(array, #), # > #)
-count(map(array, #), i == #)
+count(list, ok) % i64
+count(list, ok) / half(1)
+count(list, ok) / i
+count(list, ok) >= i32
+count(list, ok) ^ i
+count(list, ok) ^ i64
+count(list, true or ok)
+count(list, true || true)
+count(list, true) * f32
+count(list, true) == i
+count(map(array, #), # == i32)
+count(map(array, #), not true)
 count(map(array, #), ok)
-count(map(array, add), ok)
-count(map(array, div), ok)
-count(map(array, foo), ok)
-count(map(array, i32), 0.5 == f32)
-count(map(array, i32), 1 != #)
-count(map(array, i64), # == 0.5)
-count(map(array, true), #)
-count(map(list, #), "bar" in #)
-count(map(list, #), # == #)
-count(map(list, #), # == nil)
-count(map(list, 0.5), # != nil)
-count(map(list, f32), # <= #)
-count(map(list, true), #)
-count(sort(array), foo == #)
-count(sort(array), ok)
-date("bar", "bar")?.String
+count(map(array, false), #)
+count(map(array, i), ok)
+count(map(array, i32), 1 == #)
+count(map(array, i64), f64 != nil)
+count(map(array, ok), !#)
+count(map(list, 0.5), "bar" == "foo")
+count(map(list, div), ok)
+count(map(list, f32), # == #)
+count(map(list, greet), ok)
+count(map(list, i32), # != i64)
+count(map(list, ok), #)
+count(map(list, ok), 0.5 <= i64)
+count(ok ? array : i64, # > 0.5)
+count(sort(array), 1 <= #)
 div
 div != add
-div != add != ok
+div != add != nil
+div != add == ok
 div != div
-div != div ? score : 0.5
-div != div or half != greet
-div != foo.Qux
-div != foo.String
-div != foo?.Qux
-div != greet
-div != half
-div != half ? f32 : ok
-div != half and !ok
-div != nil != ok
-div != nil ? array : add
-div != nil ? i : i64
-div != score
+div != div != ok
+div != div && ok
+div != div ? "bar" : "foo"
+div != nil == ok
+div != nil || f32 < 0.5
+div != reduce(array, div)
 div == add
+div == add ? 1 : ok
 div == div
-div == div ? 0.5 : half
-div == div ? nil : i
-div == div || true ? f32 : add
-div == foo.Qux
-div == foo.String
-div == foo?.Qux
-div == foo?.String
-div == greet
-div == greet != ok
-div == greet || !false
-div == half
-div == nil ? greet : foo
-div == nil ? half : half
-div == nil ? score : i64
-div == nil || ok
-div == score
-div == score == ok
-div == score ? true : "bar"
-div in map(list, add)
-div not in [add]
-div not in [half, f32, false]
-div not in map(array, div)
-div(-1, i)
-div(1, 1) > i64
-div(1, i) >= i64
-div(i, 1) / f32
-div(i, 1) == i
+div == nil ? f32 : half
+div == nil ? false : 1
+div(-i, array[i64])
+div(-i, i)
+div(1, i) + i
+div(findLast(array, true), i)
+div(i, -1)
 div(i, i)
+div(last(array), 1 * i32)
+div(score(1), bitnot(1))
 f32
-f32 != --f64
+f32 != -0.5
 f32 != -1
-f32 != 0.5 * f32
-f32 != 0.5 + i64
-f32 != 0.5 / i64
+f32 != -f32
+f32 != 0.5 != false
+f32 != 0.5 * 1
+f32 != 0.5 * i64
+f32 != 0.5 ** f32
+f32 != 0.5 + 1
+f32 != 0.5 - i64
+f32 != 0.5 / 0.5
+f32 != 0.5 / i32
 f32 != 0.5 == ok
-f32 != 0.5 ? array : ok
-f32 != 0.5 ? list : 1
-f32 != 0.5 ^ i32
-f32 != 1 % i32
-f32 != 1 * 1
-f32 != 1 * i64
-f32 != 1 ** 0.5
-f32 != 1 - i
-f32 != 1 ? "foo" : foo
-f32 != 1 ^ f32
-f32 != abs(i64)
+f32 != 0.5 == true
+f32 != 0.5 ? array : score
+f32 != 0.5 ? foo : f64
+f32 != 0.5 ? true : i32
+f32 != 0.5 ^ 1
+f32 != 0.5 ^ f32
+f32 != 1 && ok
+f32 != 1 * i
+f32 != 1 + i64
 f32 != f32
-f32 != f32 + f64
-f32 != f32 - f64
+f32 != f32 / 0.5
+f32 != f32 / f32
 f32 != f64
-f32 != f64 ** i32
-f32 != f64 + i32
-f32 != f64 - f32
-f32 != f64 ^ i32
-f32 != findIndex(list, ok)
-f32 != float(i)
+f32 != findLast(array, ok)
+f32 != findLastIndex(array, ok)
+f32 != floor(0.5)
+f32 != half(0.5)
 f32 != i
-f32 != i * i64
-f32 != i - f64
+f32 != i != true
+f32 != i % 1
+f32 != i % i
+f32 != i ** i64
+f32 != i / f64
 f32 != i32
+f32 != i32 % i
+f32 != i32 * i32
+f32 != i32 + 0.5
 f32 != i64
-f32 != i64 * 1
-f32 != i64 ? f64 : f32
+f32 != i64 != nil
+f32 != i64 != true
+f32 != i64 ? 0.5 : f64
+f32 != i64 ^ i32
+f32 != int(f32)
+f32 != int(i32)
 f32 != len(array)
-f32 != max(i)
-f32 != min(1)
-f32 != min(f64)
-f32 != nil ? half : greet
+f32 != nil ? true : score
+f32 != nil || ok
+f32 != round(i)
 f32 != score(1)
-f32 * (1 - f32)
-f32 * (i + 1)
-f32 * (i32 + f32)
-f32 * (i64 + f32)
-f32 * (i64 - i64)
+f32 != score(1, i)
+f32 * (0.5 + f64)
+f32 * (0.5 + i32)
+f32 * (0.5 - f32)
+f32 * (f64 + f64)
+f32 * (f64 + i64)
+f32 * (f64 - i)
 f32 * -0.5
-f32 * -f32
+f32 * -1
 f32 * -f64
-f32 * -i32
-f32 * 0.5 != f32
-f32 * 0.5 ** f32
-f32 * 0.5 - f32
-f32 * 0.5 < f64
-f32 * 0.5 < i32
-f32 * 0.5 <= f32
-f32 * 0.5 <= f32 ? "bar" : array
-f32 * 0.5 <= i64
+f32 * -i
+f32 * -i64
+f32 * -len(array)
+f32 * 0.5 * 0.5
+f32 * 0.5 * i
+f32 * 0.5 * i32
+f32 * 0.5 - i32
+f32 * 0.5 / i
+f32 * 0.5 <= i
+f32 * 0.5 ^ f32
+f32 * 0.5 not in array
 f32 * 1 != f32
-f32 * 1 * 1
-f32 * 1 ** f64
-f32 * 1 + i
-f32 * 1 - i
-f32 * 1 / i64
-f32 * 1 < f64
-f32 * 1 <= f32
-f32 * 1 >= i32
-f32 * array[i64]
-f32 * count(array, ok)
+f32 * 1 * f64
+f32 * 1 * i32
+f32 * 1 ** 0.5
+f32 * 1 + f64
+f32 * 1 < i64
+f32 * 1 >= i64
+f32 * 1 ^ i64
+f32 * ceil(i)
 f32 * f32
-f32 * f32 * i
-f32 * f32 ^ i64
+f32 * f32 * 0.5
+f32 * f32 < i32
+f32 * f32 <= i64
+f32 * f32 > f32 - 1
+f32 * f32 ^ 0.5
+f32 * f32 in array
 f32 * f64
-f32 * f64 * i64
-f32 * f64 + f32
-f32 * f64 - i
-f32 * f64 ^ f32
-f32 * findIndex(list, true)
-f32 * float(0.5)
+f32 * f64 + f64
+f32 * f64 + i32
+f32 * f64 / i64
+f32 * f64 >= 1 - i
+f32 * float(i)
+f32 * float(i32)
+f32 * floor(0.5)
+f32 * floor(i)
+f32 * half(0.5)
+f32 * half(1)
+f32 * half(f64)
 f32 * i
-f32 * i < f64
-f32 * i <= -i64
-f32 * i <= min(0.5, f64)
+f32 * i != i32
+f32 * i - i
+f32 * i / f64
+f32 * i == i64
 f32 * i32
-f32 * i32 ** 1
-f32 * i32 - i64
+f32 * i32 != max(i)
+f32 * i32 * i32
+f32 * i32 ** 0.5
+f32 * i32 >= i
 f32 * i64
-f32 * i64 ** 0.5
-f32 * i64 ** i64
-f32 * i64 < f64
-f32 * i64 < half(f64)
-f32 * i64 ^ i
-f32 * i64 ^ i64
-f32 * int(f64)
-f32 * max(f32)
-f32 * min(0.5)
-f32 * min(f64)
-f32 * score(1)
-f32 ** (0.5 + i)
-f32 ** (0.5 - 0.5)
-f32 ** (1 - i64)
-f32 ** (1 / 0.5)
-f32 ** (f32 * i)
-f32 ** (f32 + 0.5)
-f32 ** (f32 + i64)
-f32 ** (f32 - 1)
-f32 ** (f64 - i32)
-f32 ** (i32 * 1)
-f32 ** (i32 * i)
+f32 * i64 != f64
+f32 * i64 ** i
+f32 * int(i64)
+f32 * min(i64)
+f32 * reduce(array, 1)
+f32 * reduce(list, 1)
+f32 * round(f64)
+f32 ** (0.5 + 0.5)
+f32 ** (0.5 - 1)
+f32 ** (0.5 / f32)
+f32 ** (1 / f64)
+f32 ** (f32 - 0.5)
+f32 ** (f64 - i64)
+f32 ** (i % 1)
+f32 ** (i64 * i32)
+f32 ** (i64 + 0.5)
+f32 ** (i64 - 1)
 f32 ** -0.5
-f32 ** -1
+f32 ** -f32
 f32 ** -f64
 f32 ** -i
-f32 ** -i32
-f32 ** -i64
-f32 ** 0.5 >= i64
+f32 ** 0.5 != f32
+f32 ** 0.5 + f32
+f32 ** 0.5 >= -i64
+f32 ** 0.5 ^ (f32 / f64)
 f32 ** 0.5 ^ i64
-f32 ** 1 * f32
-f32 ** 1 ** 0.5
-f32 ** 1 / i32
-f32 ** 1 <= i
-f32 ** array[i64]
+f32 ** 1 + i64
+f32 ** 1 / i
+f32 ** 1 < f64
+f32 ** 1 < i64
+f32 ** 1 <= i64
+f32 ** ceil(i64)
 f32 ** f32
-f32 ** f32 * i ^ f64
-f32 ** f32 + f32
-f32 ** f32 - 0.5 + 1
-f32 ** f32 ^ 1
-f32 ** f32 ^ i
+f32 ** f32 * f32
+f32 ** f32 ** f32
+f32 ** f32 < f64
+f32 ** f32 ^ f32
+f32 ** f32 ^ f64
 f32 ** f64
-f32 ** f64 + i64
+f32 ** f64 ** 1
 f32 ** f64 <= f64
-f32 ** f64 >= f32
-f32 ** float(i64)
-f32 ** half(f64)
+f32 ** f64 >= i
+f32 ** float(f32)
+f32 ** float(f64)
+f32 ** half(0.5)
+f32 ** half(1)
 f32 ** i
-f32 ** i * f64
-f32 ** i / f64
-f32 ** i == score(i)
+f32 ** i != half(1)
+f32 ** i ** f64
+f32 ** i ** i32
+f32 ** i <= i64
 f32 ** i32
-f32 ** i32 ** i32
-f32 ** i32 >= i32
+f32 ** i32 / i32
+f32 ** i32 == f64
+f32 ** i32 ^ f32
 f32 ** i64
-f32 ** i64 * i32
-f32 ** i64 + i64
-f32 ** i64 / i64
-f32 ** int(0.5)
-f32 ** int(1)
+f32 ** i64 / f32
+f32 ** i64 == i32
+f32 ** i64 > i32
+f32 ** int(f64)
 f32 ** len("foo")
-f32 ** len(list)
 f32 ** max(f32)
-f32 ** max(f64)
-f32 ** max(i64)
+f32 ** max(i32)
+f32 ** median(array)
+f32 ** reduce(array, 0.5)
+f32 ** round(f64)
 f32 + -0.5
 f32 + -1
 f32 + -f32
 f32 + -i
-f32 + -i64
-f32 + 0.5 + 1
-f32 + 0.5 + f32
+f32 + 0.5 ** f32
+f32 + 0.5 + i32
+f32 + 0.5 - i
+f32 + 0.5 - i32
+f32 + 0.5 / f32
+f32 + 0.5 == i
+f32 + 0.5 > i64
+f32 + 0.5 ^ 0.5
 f32 + 1 * 0.5
-f32 + 1 * i32
-f32 + 1 ** f64
-f32 + 1 - f32
+f32 + 1 * 1
+f32 + 1 + i
+f32 + 1 - f64
 f32 + 1 - i64
-f32 + 1 < i32
-f32 + abs(0.5)
-f32 + abs(f32)
-f32 + count(array, true)
+f32 + 1 / f64
+f32 + 1 < f32
+f32 + 1 < i
+f32 + 1 >= ceil(0.5)
+f32 + bitnot(i64)
+f32 + ceil(-1)
+f32 + ceil(1)
+f32 + ceil(f32)
 f32 + f32
-f32 + f32 + i32
-f32 + f32 == 0.5 ^ i
+f32 + f32 * 0.5
+f32 + f32 ** i64
+f32 + f32 - i32
+f32 + f32 / 1
+f32 + f32 > i32
+f32 + f32 ^ 0.5
 f32 + f64
-f32 + f64 - 0.5
-f32 + f64 - f32
-f32 + f64 / f64
-f32 + f64 < f32
-f32 + f64 ^ f32
-f32 + find(array, ok)
-f32 + float(f64)
-f32 + half(0.5)
+f32 + f64 in array
+f32 + findIndex(array, true)
+f32 + first(array)
+f32 + float(i)
+f32 + floor(1)
+f32 + floor(i64)
+f32 + half(1)
+f32 + half(f64)
 f32 + i
-f32 + i != i
-f32 + i - i
-f32 + i ^ f64
+f32 + i != i64
+f32 + i + 1
+f32 + i + i
+f32 + i - i32
+f32 + i == f64
 f32 + i32
-f32 + i32 * 0.5
-f32 + i32 + 0.5
-f32 + i32 >= f32
+f32 + i32 != f32
+f32 + i32 % i
+f32 + i32 / f32
+f32 + i32 <= i
+f32 + i32 ^ 0.5
 f32 + i64
-f32 + i64 % 1
-f32 + i64 - 1
-f32 + i64 - f32
+f32 + i64 != f32
+f32 + i64 + 0.5
+f32 + i64 < f32
+f32 + i64 <= i32
+f32 + i64 >= i
+f32 + i64 >= i32
 f32 + int(1)
 f32 + int(f64)
-f32 + int(i32)
-f32 + len(array)
 f32 + max(0.5)
 f32 + max(f64)
-f32 + max(i64)
-f32 + min(1)
-f32 + min(f32)
-f32 + min(i32)
-f32 + min(i64, 1, 1)
+f32 + reduce(array, #)
+f32 + round(1)
+f32 + round(i32)
 f32 + score(1)
 f32 + score(i)
-f32 - -0.5
 f32 - -1
 f32 - -f64
 f32 - -i
-f32 - -i32
+f32 - 0.5 ** i64
+f32 - 0.5 + 0.5
 f32 - 0.5 + f64
-f32 - 0.5 - i32
 f32 - 0.5 - i64
-f32 - 0.5 <= f64
+f32 - 0.5 < i
+f32 - 0.5 <= i32
 f32 - 0.5 <= i64
-f32 - 0.5 >= i64
-f32 - 0.5 ^ f64
-f32 - 0.5 ^ i32
-f32 - 1 != i64
-f32 - 1 % 1
+f32 - 0.5 > f64
 f32 - 1 % i64
+f32 - 1 * i64
 f32 - 1 + 1
-f32 - 1 + i32 % i
-f32 - 1 - f32
+f32 - 1 / 0.5
+f32 - 1 < i32
+f32 - 1 <= i32
+f32 - 1 == f32
+f32 - 1 >= f64
 f32 - abs(i32)
-f32 - array[i]
+f32 - abs(i64)
+f32 - bitshl(i, i32)
+f32 - ceil(f64)
 f32 - f32
-f32 - f32 - f64
-f32 - f32 - i32
+f32 - f32 ** i32
+f32 - f32 + i
 f32 - f32 == i
-f32 - f32 == min(1)
-f32 - f32 >= i
 f32 - f64
-f32 - f64 * 1
-f32 - f64 ** i32
-f32 - f64 + f32
-f32 - f64 + i64
-f32 - f64 - f32
+f32 - f64 + f64
 f32 - f64 - i
 f32 - f64 <= f32
-f32 - f64 ^ 1
-f32 - float(0.5)
-f32 - float(1)
-f32 - float(i32)
-f32 - half(0.5)
 f32 - i
-f32 - i % 1
-f32 - i * f32
-f32 - i + i32 % 1
-f32 - i + i32 ** 0.5
-f32 - i - 0.5
+f32 - i >= f32
 f32 - i32
-f32 - i32 * 1
-f32 - i32 ** f32
-f32 - i32 ** i32
-f32 - i32 + 1
-f32 - i32 >= i
-f32 - i32 ^ i
+f32 - i32 * 0.5
+f32 - i32 * f64
+f32 - i32 ** 1
+f32 - i32 <= f32
+f32 - i32 <= i32
+f32 - i32 >= abs(0.5)
 f32 - i64
-f32 - i64 - 1
-f32 - i64 <= i32
-f32 - i64 ^ 1
-f32 - int(0.5)
-f32 - int(i64)
-f32 - len("bar")
-f32 - len(list)
-f32 - max(i32)
-f32 - min(1)
-f32 - min(i64)
+f32 - i64 ** 0.5
+f32 - len(array)
+f32 - max(1)
+f32 - min(0.5)
+f32 - min(0.5, 0.5)
+f32 - reduce(array, #)
+f32 - score(1)
 f32 - score(i)
-f32 / (0.5 + i64)
-f32 / (1 - i)
-f32 / (i64 - f64)
-f32 / -0.5
-f32 / -f32
+f32 / (0.5 - i32)
+f32 / (1 + i)
+f32 / (f64 - 0.5)
+f32 / (i - i32)
+f32 / (i32 + 1)
+f32 / -1
 f32 / -f64
-f32 / -i
-f32 / -i32
-f32 / 0.5 * 0.5
-f32 / 0.5 * i
-f32 / 0.5 - f64
-f32 / 0.5 - i
-f32 / 0.5 - i64
-f32 / 0.5 > f64
-f32 / 1 != f64
-f32 / 1 * i64
-f32 / 1 ** f32
-f32 / 1 - f64 - i64
+f32 / -i64
+f32 / 0.5 ** f64
+f32 / 0.5 / i
+f32 / 0.5 <= i64
+f32 / 0.5 ^ f64
+f32 / 1 * i32
+f32 / 1 <= f32
+f32 / 1 >= 0.5 ? f64 : foo
 f32 / 1 >= f32
-f32 / 1 ^ 0.5
-f32 / 1 ^ i
-f32 / abs(1)
-f32 / abs(f32)
+f32 / 1 >= i32
+f32 / array[1]
+f32 / array[i32]
+f32 / bitnot(i)
+f32 / ceil(1)
+f32 / ceil(f32)
+f32 / count(list, false)
 f32 / f32
-f32 / f32 / f32
-f32 / f32 < f32
+f32 / f32 / 0.5
+f32 / f32 ^ 1
 f32 / f64
-f32 / f64 ^ 0.5
+f32 / f64 * i32
+f32 / f64 + f32
+f32 / f64 - i32
+f32 / f64 / 1
+f32 / f64 / f64
+f32 / f64 / i64
+f32 / f64 < i
+f32 / float(1)
+f32 / float(i32)
 f32 / float(i64)
-f32 / get(array, 1)
+f32 / floor(i)
 f32 / half(0.5)
+f32 / half(1)
+f32 / half(f64)
 f32 / i
-f32 / i <= i64
+f32 / i * 0.5
+f32 / i / 0.5
+f32 / i <= i
+f32 / i == i32
+f32 / i > f64
 f32 / i32
-f32 / i32 != i
-f32 / i32 ** i
-f32 / i32 / f64
-f32 / i32 >= i
+f32 / i32 * 1
+f32 / i32 * f32
+f32 / i32 ** f32
+f32 / i32 + i
+f32 / i32 + i64
+f32 / i32 < f64 + 0.5
+f32 / i32 >= i32
 f32 / i64
-f32 / i64 * i64
-f32 / i64 > i32
-f32 / i64 ^ 1
-f32 / i64 ^ i
-f32 / int(f32)
-f32 / int(f64)
-f32 / int(i)
-f32 / int(i32)
-f32 / last(array)
+f32 / i64 - f64
+f32 / i64 ^ 0.5
+f32 / int(0.5)
+f32 / int(1 * i64)
 f32 / max(0.5)
-f32 / max(1)
-f32 / min(f32)
+f32 / min(i32)
+f32 / reduce(array, #)
+f32 / reduce(list, 1)
+f32 / score(i)
 f32 < -0.5
-f32 < -f32
 f32 < -f64
-f32 < -i32
+f32 < -i
 f32 < -i64
-f32 < 0.5 != true
-f32 < 0.5 ? array : array
-f32 < 0.5 ? false : score
-f32 < 0.5 ? i64 : i32
-f32 < 0.5 ? ok : f32
+f32 < 0.5 + 0.5
+f32 < 0.5 + 1
 f32 < 0.5 ^ f32
-f32 < 1 != ok
-f32 < 1 * f32
-f32 < 1 ** 1
-f32 < 1 ** i
-f32 < 1 - i
-f32 < 1 / 0.5
-f32 < 1 ? f32 : i64
-f32 < 1 ? foo : i
-f32 < 1 ? i64 : foo
-f32 < 1 || not ok
-f32 < abs(1)
-f32 < abs(i)
-f32 < array[i64]
-f32 < array[i]
-f32 < div(1, 1)
+f32 < 0.5 ^ i64
+f32 < 1 % 1
+f32 < 1 + f64
+f32 < 1 ? f64 : i
+f32 < 1 and ok
+f32 < abs(0.5)
+f32 < ceil(0.5)
+f32 < ceil(f64)
+f32 < count(array, ok)
+f32 < count(list, ok)
 f32 < f32
-f32 < f32 ** 1
-f32 < f32 ^ 0.5
+f32 < f32 / 1
+f32 < f32 ^ f64
 f32 < f64
-f32 < f64 != ok
-f32 < f64 / f64
-f32 < f64 == nil
-f32 < f64 == true
-f32 < f64 ? "foo" : half
-f32 < float(f32)
-f32 < float(i64)
-f32 < half(f64)
+f32 < f64 ** 1
+f32 < f64 + 0.5
+f32 < f64 + i
+f32 < f64 / i64
+f32 < f64 ? 0.5 : array
+f32 < f64 ? div : i32
+f32 < f64 and ok
+f32 < floor(0.5)
+f32 < floor(i)
+f32 < half(0.5)
+f32 < half(1)
 f32 < i
-f32 < i * 1
-f32 < i - i32
-f32 < i ? greet : "foo"
+f32 < i != ok
+f32 < i / 1
+f32 < i ? 1 : i
 f32 < i32
-f32 < i32 ** 0.5
+f32 < i32 ** i64
+f32 < i32 ? f64 : i
+f32 < i32 ? greet : i32
 f32 < i32 or ok
-f32 < i32 || ok
 f32 < i64
-f32 < i64 != nil
-f32 < i64 && ok
-f32 < i64 * i32
-f32 < i64 - f32
-f32 < int(f64)
-f32 < max(1)
-f32 < score(1)
-f32 < score(i)
+f32 < i64 - i32
+f32 < i64 / 0.5
+f32 < i64 ? foo : i32
+f32 < i64 ? foo?.Bar : div
+f32 < i64 ^ 0.5
+f32 < max(i)
+f32 < max(i32, 1)
+f32 < min(0.5)
+f32 < reduce(array, #)
+f32 < reduce(list, 1)
+f32 < round(i64)
 f32 <= -0.5
 f32 <= -1
-f32 <= -f32
 f32 <= -f64
-f32 <= -i
 f32 <= -i64
-f32 <= -min(i64)
+f32 <= 0.5 != true
 f32 <= 0.5 * 0.5
-f32 <= 0.5 ** i32
-f32 <= 0.5 - 1
-f32 <= 0.5 / 0.5
-f32 <= 0.5 == ok
-f32 <= 0.5 == true
-f32 <= 1 != nil
-f32 <= 1 % i
-f32 <= 1 * 0.5
-f32 <= 1 * i32
-f32 <= 1 == ok
-f32 <= abs(1)
+f32 <= 0.5 + i
+f32 <= 0.5 / i64
+f32 <= 0.5 ? i64 : i
+f32 <= 1 - 0.5
+f32 <= 1 == nil
+f32 <= 1 ? f64 : add
+f32 <= 1 ? i64 : i64 % 1
+f32 <= 1 ? list : div
+f32 <= 1 || ok
 f32 <= f32
-f32 <= f32 ** i64
-f32 <= f32 ? 0.5 : foo
+f32 <= f32 * 1
+f32 <= f32 + f64
+f32 <= f32 + i
+f32 <= f32 ? greet : half
 f32 <= f64
-f32 <= f64 ? ok : f64
-f32 <= f64 ^ f32
-f32 <= f64 and ok
-f32 <= findIndex(list, ok)
-f32 <= first(array)
+f32 <= findIndex(list, ok) * f64
+f32 <= float(1)
+f32 <= float(i)
+f32 <= float(i64)
+f32 <= float(toJSON(1))
+f32 <= floor(0.5)
 f32 <= half(0.5)
+f32 <= half(1)
+f32 <= half(f64)
 f32 <= i
-f32 <= i != nil
-f32 <= i % i64
-f32 <= i ** i32
-f32 <= i - 0.5
-f32 <= i / f32
-f32 <= i == ok
+f32 <= i == nil
+f32 <= i and i32 <= f32
 f32 <= i32
-f32 <= i32 * i64
 f32 <= i32 ** i32
-f32 <= i32 + i32
-f32 <= i32 - 1
+f32 <= i32 + 1
 f32 <= i32 / 1
-f32 <= i32 ? 0.5 : i32
-f32 <= i32 and ok
 f32 <= i64
-f32 <= i64 * i
-f32 <= i64 ? true : array
-f32 <= i64 or ok
-f32 <= int(0.5)
-f32 <= int(i)
-f32 <= len("foo")
-f32 <= max(f32)
-f32 <= max(i64)
-f32 <= min(i64, i32)
+f32 <= i64 ** i64
+f32 <= i64 - f32
+f32 <= i64 ? f64 : f64
+f32 <= i64 ^ i32
+f32 <= i64 || nil in array
+f32 <= last(array)
+f32 <= min(0.5)
+f32 <= min(1)
+f32 <= min(f64)
+f32 <= round(0.5)
 f32 <= score(1)
-f32 <= score(i)
-f32 == --f64
 f32 == -0.5
 f32 == -1
 f32 == -f32
 f32 == -i32
 f32 == -i64
-f32 == 0.5 && i32 == i32
-f32 == 0.5 * i32
-f32 == 0.5 ** 1
-f32 == 0.5 and ok
-f32 == 1 && ok ? add : f32
-f32 == 1 ^ i
-f32 == abs(1)
-f32 == array[1]
-f32 == count(array, ok)
+f32 == 0.5 != ok
+f32 == 0.5 * 0.5
+f32 == 0.5 * 1
+f32 == 0.5 ** i32
+f32 == 0.5 + 1
+f32 == 0.5 / i32
+f32 == 0.5 / i64
+f32 == 0.5 ? array : greet
+f32 == 0.5 ? true : score
+f32 == 0.5 ^ 0.5
+f32 == 0.5 || f64 >= 1
+f32 == 1 != nil
+f32 == 1 + f32
+f32 == 1 - 1
+f32 == 1 - i
+f32 == 1 == ok
+f32 == 1 ? foo : f32
+f32 == 1 ? ok : add != nil
+f32 == add(i, 1)
+f32 == array[i32]
+f32 == bitnot(i)
+f32 == ceil(1)
+f32 == ceil(i32)
+f32 == ceil(i64)
 f32 == f32
-f32 == f32 ** f32
-f32 == f32 - i32
-f32 == f32 ? 1 : greet
-f32 == f32 ? list : "bar"
+f32 == f32 ? f32 : list
+f32 == f32 and ok
 f32 == f64
-f32 == f64 - 1
-f32 == f64 - f64
-f32 == f64 ? ok : i64
-f32 == find(array, ok)
-f32 == findLast(array, ok)
-f32 == findLastIndex(list, true)
-f32 == get(array, 1)
+f32 == f64 + f64
+f32 == f64 ^ 1
+f32 == findLastIndex(array, ok)
+f32 == first(array)
+f32 == float(0.5)
+f32 == float(1)
+f32 == floor(f64)
+f32 == half(1)
+f32 == half(f64)
 f32 == i
-f32 == i * i64
-f32 == i + f64 + 0.5
-f32 == i - f64
-f32 == i - i32
-f32 == i / 0.5
-f32 == i ? "foo" : i64
-f32 == i ? i : 0.5
+f32 == i != nil
+f32 == i - 0.5
+f32 == i - i64
 f32 == i32
-f32 == i32 % 1
-f32 == i32 - 0.5
+f32 == i32 + i32
+f32 == i32 ? 0.5 : array
+f32 == i32 ? i64 : i64
+f32 == i32 ? true : half
+f32 == i32 ^ i32
+f32 == i32 or ok
 f32 == i64
-f32 == i64 % i
-f32 == i64 * 0.5
-f32 == int(1)
-f32 == max(0.5, 1)
-f32 == max(i)
+f32 == i64 * i64
+f32 == i64 + 0.5
+f32 == i64 - 0.5
+f32 == i64 - 1
+f32 == i64 ? div : 0.5
+f32 == last(array)
+f32 == max(f64)
 f32 == min(0.5)
-f32 == min(i64)
-f32 == nil ? "foo" : div
-f32 == nil ? i32 : greet
+f32 == min(f32)
+f32 == nil ? array : add
+f32 == nil ? i : div
+f32 == round(1)
 f32 == score(1)
+f32 == score(i)
+f32 > -(0.5 / 1)
 f32 > -0.5
-f32 > -f64
-f32 > -i
+f32 > -f32
 f32 > -i32
-f32 > -i64
-f32 > 0.5 != false
-f32 > 0.5 != ok
-f32 > 0.5 - 0.5
-f32 > 0.5 / 0.5
-f32 > 0.5 ? foo : f64
-f32 > 0.5 ? greet : half
-f32 > 1 % 1
-f32 > 1 ** 0.5
-f32 > 1 + f32
-f32 > 1 / i64
-f32 > 1 == true
-f32 > 1 ? nil : half
-f32 > 1 ^ i32
-f32 > array[i32]
+f32 > 0.5 / f32
+f32 > 0.5 / i32
+f32 > 0.5 == true ? i32 : array
+f32 > 0.5 ? half : false
+f32 > 0.5 ^ f64
+f32 > 1 ** i
+f32 > 1 ? 1 : false
+f32 > 1 ? list : "foo"
+f32 > abs(1)
+f32 > abs(f32)
+f32 > abs(f64)
+f32 > count(array, ok)
 f32 > f32
-f32 > f32 ** f32
-f32 > f32 - i
-f32 > f32 == true
+f32 > f32 + f32
+f32 > f32 - f32
+f32 > f32 == nil
 f32 > f64
-f32 > f64 - i32
-f32 > f64 / i64
-f32 > f64 ? array : false
-f32 > f64 ? true : array
-f32 > f64 or ok
+f32 > f64 * i
+f32 > f64 ** 0.5
+f32 > float(0.5)
+f32 > float(i32)
+f32 > floor(1)
+f32 > half(1)
+f32 > half(f64)
 f32 > i
-f32 > i * 0.5
-f32 > i + f32
+f32 > i != ok
+f32 > i * 1
+f32 > i ? array : 1
+f32 > i ? foo : list
 f32 > i32
-f32 > i32 != ok
-f32 > i32 * i
+f32 > i32 != nil
+f32 > i32 * f64
+f32 > i32 ? 0.5 : greet
+f32 > i32 and ok
 f32 > i64
-f32 > i64 ? 1 : f64
-f32 > i64 ? ok : greet
-f32 > int(0.5)
-f32 > int(f64)
-f32 > max(i32)
-f32 > max(i32, 1)
-f32 > min(f64)
-f32 > score(1)
-f32 > score(i)
+f32 > i64 % i64
+f32 > i64 ** i
+f32 > i64 + 0.5
+f32 > i64 - i64
+f32 > i64 ? i : 0.5
+f32 > mean(array)
+f32 > min(f32)
+f32 > min(i64)
+f32 > reduce(array, #)
+f32 > reduce(array, i64)
+f32 > reduce(list, f32)
+f32 > round(0.5)
+f32 > score(1, 1)
+f32 >= -0.5
+f32 >= -f32
 f32 >= -f64
-f32 >= -i
-f32 >= -i32
-f32 >= -i64
-f32 >= 0.5 ** f64
-f32 >= 0.5 - 0.5
-f32 >= 0.5 == ok
-f32 >= 1 != ok
-f32 >= 1 != true
-f32 >= 1 % 1
-f32 >= 1 % i
-f32 >= 1 - 1
-f32 >= 1 - i
-f32 >= 1 - i64
-f32 >= 1 ? "foo" endsWith "foo" : f64
-f32 >= abs(1)
+f32 >= 0.5 * f64
+f32 >= 0.5 / i64
+f32 >= 0.5 ? i64 : nil
+f32 >= 0.5 ^ i64
+f32 >= 1 == false
+f32 >= 1 == ok ? add : array
+f32 >= 1 ? i : 1
+f32 >= abs(0.5)
+f32 >= abs(f32)
+f32 >= abs(i)
+f32 >= array[1]
+f32 >= array[i32]
+f32 >= bitnot(i32)
+f32 >= count(list, false)
 f32 >= f32
 f32 >= f32 ** 1
-f32 >= f32 ** f32
-f32 >= f32 + i32
+f32 >= f32 - i64
+f32 >= f32 ? half : greet
+f32 >= f32 or nil != ok
 f32 >= f64
-f32 >= f64 + i32
-f32 >= first(array)
-f32 >= float(i32)
-f32 >= float(i64)
+f32 >= f64 && ok
+f32 >= f64 ** 0.5
+f32 >= f64 ** i32
+f32 >= f64 - f64
+f32 >= f64 / i64
+f32 >= f64 or ok
+f32 >= float(0.5)
 f32 >= half(f64)
 f32 >= i
-f32 >= i != true
-f32 >= i * 0.5
-f32 >= i ** 0.5
-f32 >= i ** i32
-f32 >= i + f64
-f32 >= i ? "bar" : nil
-f32 >= i ? ok : i
+f32 >= i - f32
+f32 >= i ? 1 : nil
+f32 >= i ^ i
 f32 >= i32
-f32 >= i32 * 0.5
-f32 >= i32 ? array : foo
-f32 >= i32 ^ i32
+f32 >= i32 % i
+f32 >= i32 - f32
+f32 >= i32 / i64
+f32 >= i32 ? f32 : 0.5
+f32 >= i32 or not ok
 f32 >= i64
-f32 >= i64 % i64
-f32 >= i64 ** 0.5
-f32 >= i64 ? 1 : i32
-f32 >= i64 ? i64 : add
-f32 >= i64 || ok
-f32 >= len("foo")
+f32 >= i64 * i32
+f32 >= i64 + f64
+f32 >= i64 / 1
+f32 >= len("bar")
 f32 >= max(i)
-f32 >= min(i)
+f32 >= max(i64)
+f32 >= reduce(array, #)
 f32 >= score(1)
-f32 ^ (1 * f32)
-f32 ^ (1 + 1)
-f32 ^ (1 - 0.5)
-f32 ^ (f32 * 0.5)
-f32 ^ (f32 / 1)
-f32 ^ (i + i)
-f32 ^ (i32 % 1)
-f32 ^ (i32 % i64)
-f32 ^ (i32 / 1)
-f32 ^ (i32 / f64)
+f32 >= sum(array)
+f32 ^ (0.5 * f64)
+f32 ^ (0.5 / 1)
+f32 ^ (0.5 / i)
+f32 ^ (1 * i)
+f32 ^ (1 + f64)
+f32 ^ (f32 * i64)
+f32 ^ (f64 * f64)
+f32 ^ (f64 - 1)
+f32 ^ (f64 / i)
+f32 ^ (i64 * f64)
+f32 ^ (i64 * i32)
+f32 ^ (i64 * i64)
+f32 ^ (i64 + i64)
 f32 ^ (i64 - f32)
 f32 ^ -0.5
 f32 ^ -1
-f32 ^ -f32
-f32 ^ -i
 f32 ^ -i32
-f32 ^ -i64
-f32 ^ 0.5 != i64
-f32 ^ 0.5 + f32
-f32 ^ 0.5 + i64
-f32 ^ 0.5 - f64
-f32 ^ 0.5 <= 0.5 ^ 0.5
-f32 ^ 0.5 ^ f32
-f32 ^ 1 - i
-f32 ^ 1 - i32
-f32 ^ 1 <= 1 * 1
-f32 ^ 1 <= i32
-f32 ^ 1 ^ 0.5
+f32 ^ 0.5 ** i32
+f32 ^ 0.5 - f32
+f32 ^ 0.5 - i32
+f32 ^ 0.5 == i64
+f32 ^ 0.5 ^ 0.5
+f32 ^ 1 != i64
+f32 ^ 1 / f32
+f32 ^ 1 >= -0.5
+f32 ^ abs(1)
+f32 ^ abs(f32)
+f32 ^ array[i64]
+f32 ^ array[i]
+f32 ^ bitnot(1)
+f32 ^ bitor(1, i32)
 f32 ^ f32
-f32 ^ f32 ** i
-f32 ^ f32 + f32
-f32 ^ f32 / f32
+f32 ^ f32 ^ 0.5
+f32 ^ f32 in array
 f32 ^ f64
-f32 ^ f64 < f64
-f32 ^ f64 < i64
-f32 ^ f64 <= f64
-f32 ^ f64 == f64
-f32 ^ f64 > i
+f32 ^ f64 ** f64
+f32 ^ f64 / 1 * 1
+f32 ^ f64 / f64
+f32 ^ f64 == i64
+f32 ^ f64 not in array
+f32 ^ floor(0.5)
+f32 ^ floor(1)
+f32 ^ half(1)
 f32 ^ half(f64)
 f32 ^ i
-f32 ^ i ** i32
+f32 ^ i - f64
+f32 ^ i <= i
+f32 ^ i >= f64
+f32 ^ i ^ f32
 f32 ^ i32
-f32 ^ i32 + f32
+f32 ^ i32 ** i64
 f32 ^ i64
-f32 ^ last(array)
-f32 ^ max(0.5)
-f32 ^ max(f32)
-f32 ^ max(i64)
+f32 ^ i64 ** 1
+f32 ^ i64 + i64
+f32 ^ i64 - f32
+f32 ^ i64 >= f64
+f32 ^ i64 ^ f32
+f32 ^ int(i32)
+f32 ^ len("foo")
+f32 ^ len(array)
 f32 ^ min(1)
-f32 ^ min(1, 1)
+f32 ^ min(f64)
+f32 ^ min(i)
+f32 ^ reduce(array, 1)
+f32 ^ round(i)
+f32 ^ round(i32)
 f32 ^ score(i)
-f32 in [false, list]
+f32 ^ score(reduce(array, #))
+f32 in [i]
 f32 in [nil]
-f32 not in sort(array)
+f32 in array
+f32 in array == nil
+f32 in array ? 1 : i
+f32 in array ? false : 0.5
+f32 in array ? nil : "bar"
+f32 in groupBy(array, #)
+f32 in groupBy(list, #)
+f32 in groupBy(list, ok)
+f32 in map(array, #)
+f32 not in [f32, "bar"]
+f32 not in array
+f32 not in array ? foo : i
+f32 not in array ? i32 : div
 f64
-f64 != -(0.5 ** 0.5)
+f64 != -0.5
 f64 != -1
-f64 != -f64
+f64 != -f32
 f64 != -i
-f64 != -i32
-f64 != 0.5 && ok
-f64 != 0.5 + 1
-f64 != 0.5 + f64
-f64 != 0.5 == nil
-f64 != 0.5 == true
-f64 != 0.5 ? false : array
-f64 != 0.5 and ok
-f64 != 1 ? list : false
-f64 != 1 ^ i64
-f64 != abs(f32)
-f64 != array[i64]
+f64 != -i64
+f64 != 0.5 != false
+f64 != 0.5 ** 1
+f64 != 0.5 ** f64
+f64 != 0.5 + f32
+f64 != 0.5 ^ 0.5
+f64 != 1 - 1
+f64 != 1 / 0.5
+f64 != 1 ? half : div
+f64 != 1 ^ i
+f64 != abs(i32)
+f64 != bitnot(i64)
+f64 != ceil(i)
 f64 != f32
-f64 != f32 * i32
+f64 != f32 != nil
+f64 != f32 + 0.5
+f64 != f32 + i32
+f64 != f32 - i32
+f64 != f32 ? array : nil
+f64 != f32 ? i32 : "bar"
+f64 != f32 ? ok : i
+f64 != f32 or greet == nil
 f64 != f64
 f64 != f64 * f32
-f64 != f64 ^ 1
-f64 != findLastIndex(list, ok)
+f64 != f64 ? f64 : true
 f64 != first(array)
-f64 != get(array, i32)
+f64 != floor(1)
 f64 != half(0.5)
-f64 != half(f64)
+f64 != half(1)
 f64 != i
-f64 != i && ok
-f64 != i + 1
+f64 != i * 0.5
+f64 != i / 1
+f64 != i / f32
+f64 != i ^ f64
 f64 != i32
-f64 != i32 + f64
-f64 != i32 ? "bar" : nil
-f64 != i32 ? add : 1
-f64 != i32 ^ 0.5
+f64 != i32 * f32
+f64 != i32 == ok
+f64 != i32 ? f64 : ok
+f64 != i32 ? foo : ok
+f64 != i32 ^ i32
 f64 != i64
-f64 != i64 ** 0.5
+f64 != i64 * f64
+f64 != i64 - i32
+f64 != i64 or ok
 f64 != int(i64)
-f64 != max(i64)
-f64 != min(1)
-f64 != min(i32)
-f64 != nil == ok
-f64 != score(1)
-f64 != score(i)
-f64 * (0.5 - f32)
-f64 * (0.5 - i64)
-f64 * (f32 + i32)
-f64 * (i32 - 0.5)
-f64 * (i64 - f64)
+f64 != min(f64)
+f64 != nil != ok
+f64 != nil && f64 > 0.5
+f64 != nil == true
+f64 != nil ? array : foo
+f64 != nil ? f64 : half
+f64 != nil ? i64 : 0.5
+f64 != nil ? nil : half
+f64 != round(1)
+f64 * (0.5 - 1)
+f64 * (i64 + 0.5)
 f64 * -1
 f64 * -f32
 f64 * -f64
-f64 * -i32
-f64 * -i64
-f64 * 0.5 * 0.5 ^ i64
+f64 * 0.5 * 1
+f64 * 0.5 * i64
+f64 * 0.5 ** 0.5
+f64 * 0.5 / 0.5
+f64 * 0.5 / f32
 f64 * 0.5 / i32
+f64 * 0.5 < f32
+f64 * 0.5 <= i
+f64 * 0.5 == f64
 f64 * 0.5 ^ 1
-f64 * 1 ** 0.5
-f64 * 1 + i64
-f64 * 1 / i32
-f64 * 1 < 0.5 * 0.5
-f64 * abs(i)
+f64 * 1 * f64
+f64 * 1 * i32
+f64 * 1 ** 1
+f64 * 1 + f64
+f64 * 1 - i32
+f64 * 1 <= 1 + 1
+f64 * 1 == i64
+f64 * 1 > f32
+f64 * 1 > f64
+f64 * 1 >= f64
+f64 * bitnot(i64)
+f64 * ceil(i)
+f64 * ceil(i64)
 f64 * f32
-f64 * f32 * f32
-f64 * f32 - f32
-f64 * f32 - f64
-f64 * f32 / f64
-f64 * f32 >= f64
+f64 * f32 != i
+f64 * f32 / i64
+f64 * f32 > f64
+f64 * f32 > i
 f64 * f64
-f64 * f64 / i
-f64 * f64 < f64
-f64 * f64 >= score(1)
-f64 * float(i)
+f64 * f64 * f64
+f64 * f64 / 1
+f64 * f64 <= f64
+f64 * f64 > f64
+f64 * f64 in array
+f64 * float(f32)
+f64 * floor(0.5)
+f64 * get(array, 1)
+f64 * half(f64)
 f64 * i
-f64 * i != i
-f64 * i * 0.5
-f64 * i * i
-f64 * i * i64
-f64 * i - f64
+f64 * i / f64
 f64 * i32
-f64 * i32 * 1
-f64 * i32 > f64
+f64 * i32 != i64 * f64
+f64 * i32 - i32
 f64 * i64
-f64 * i64 + f32
-f64 * i64 + i
-f64 * i64 - f32
+f64 * i64 ** i
+f64 * i64 == i
+f64 * i64 > i32
 f64 * i64 ^ i32
-f64 * int(0.5)
-f64 * int(f32)
-f64 * int(f64)
-f64 * last(array)
-f64 * len(list)
-f64 * max(i64)
-f64 * min(i32)
-f64 * score(1)
-f64 * score(i)
-f64 ** (0.5 * i32)
-f64 ** (0.5 + 1)
-f64 ** (0.5 + i)
-f64 ** (1 + 1)
-f64 ** (1 + f64)
-f64 ** (1 - 1)
-f64 ** (1 / i64)
-f64 ** (f32 * i)
-f64 ** (f64 + 0.5)
-f64 ** (f64 + f64)
-f64 ** (f64 + i)
-f64 ** (i % 1)
-f64 ** (i % i32)
-f64 ** (i32 * 1)
-f64 ** (i32 + 0.5)
-f64 ** (i32 - f32)
-f64 ** (i64 * 1)
+f64 * median(array)
+f64 * min(1)
+f64 * min(f64)
+f64 * min(i)
+f64 * round(1)
+f64 * round(i64)
+f64 ** (0.5 - i)
+f64 ** (0.5 / i64)
+f64 ** (1 * i)
+f64 ** (f64 * i32)
+f64 ** (f64 / 1)
+f64 ** (i * 1)
+f64 ** (i * i64)
+f64 ** (i32 * i)
+f64 ** (i32 + i32)
+f64 ** (i32 - f64)
+f64 ** (i32 / i64)
+f64 ** (i64 % 1)
 f64 ** (i64 + 0.5)
-f64 ** (i64 / i)
+f64 ** (i64 + i64)
+f64 ** (i64 - i32)
+f64 ** (i64 / 0.5)
 f64 ** -0.5
 f64 ** -1
-f64 ** -f32
-f64 ** -f64
 f64 ** -i
-f64 ** -i32
-f64 ** -i64
-f64 ** 0.5 ** i64
-f64 ** 0.5 <= 1 - 1
-f64 ** 1 ** 0.5 ** 0.5
-f64 ** 1 < 1 - i64
-f64 ** 1 == f64 + f32
-f64 ** 1 ^ i
-f64 ** 1 ^ i64
-f64 ** abs(1)
-f64 ** abs(f64)
+f64 ** 0.5 ** f32
+f64 ** 0.5 == i32
+f64 ** 1 + f64
+f64 ** 1 / i
+f64 ** 1 < f32
+f64 ** 1 > i32
+f64 ** 1 ^ f32
+f64 ** abs(i)
+f64 ** bitand(1, 1)
+f64 ** ceil(0.5)
+f64 ** ceil(f64)
 f64 ** f32
-f64 ** f32 ** 0.5
-f64 ** f32 == i64
+f64 ** f32 != f64
+f64 ** f32 ** f64
+f64 ** f32 > f64
 f64 ** f64
-f64 ** f64 != f32
-f64 ** f64 ** 0.5
-f64 ** f64 / f32
-f64 ** f64 < f64
-f64 ** f64 <= f64
-f64 ** f64 ^ f64
-f64 ** f64 ^ i32
-f64 ** float(i32)
-f64 ** get(array, i64)
+f64 ** f64 - f32
+f64 ** f64 / min(1)
+f64 ** f64 <= f32
+f64 ** f64 <= i64
+f64 ** f64 ^ 0.5
 f64 ** half(0.5)
 f64 ** i
-f64 ** i != i
-f64 ** i - i32
-f64 ** i / f32
-f64 ** i >= i32
-f64 ** i ^ i32
+f64 ** i * f64
+f64 ** i ** i
+f64 ** i + -i32
+f64 ** i + f32
 f64 ** i32
-f64 ** i32 != max(f64, 0.5)
-f64 ** i32 ** 1
-f64 ** i32 ^ 1
+f64 ** i32 != f64
+f64 ** i32 > f64
 f64 ** i64
-f64 ** i64 ** i64
-f64 ** i64 / f64
-f64 ** i64 ^ i
-f64 ** int(0.5)
-f64 ** int(1)
-f64 ** max(i32)
-f64 ** min(1)
+f64 ** i64 + f32
+f64 ** i64 <= f32
+f64 ** i64 not in map(array, 0.5)
+f64 ** last(array)
+f64 ** len("bar")
+f64 ** max(i)
 f64 ** min(f32)
-f64 ** score(1, 1)
+f64 ** reduce(array, #)
+f64 ** reduce(list, i32)
+f64 ** score(i)
 f64 + -0.5
+f64 + -1
 f64 + -f64
 f64 + -i
 f64 + -i32
-f64 + -i64
-f64 + 0.5 * 1
-f64 + 0.5 * i32
 f64 + 0.5 / f32
-f64 + 0.5 == i64
-f64 + 1 != f64
-f64 + 1 + f64
-f64 + 1 - 0.5
-f64 + 1 < i64
-f64 + 1 > 0.5 ? 1 : 0.5
-f64 + 1 > i64
-f64 + 1 >= f32
-f64 + abs(i)
-f64 + abs(i64)
-f64 + array[1]
-f64 + array[i64]
-f64 + count(array, ok)
+f64 + 0.5 < i32
+f64 + 0.5 <= f64
+f64 + 0.5 <= float(f32)
+f64 + 0.5 <= i
+f64 + 0.5 > f64
+f64 + 0.5 ^ i
+f64 + 0.5 ^ i64
+f64 + 1 % i
+f64 + 1 * 0.5
+f64 + 1 * 1
+f64 + 1 * f64
+f64 + 1 ** 0.5
+f64 + 1 + i32
+f64 + 1 / i64
+f64 + 1 ^ i
+f64 + 1 not in map(array, #)
+f64 + ceil(0.5)
+f64 + count(list, true)
 f64 + f32
-f64 + f32 * i32
-f64 + f32 - i64
+f64 + f32 == i != true
 f64 + f64
-f64 + f64 + i64
-f64 + f64 == i32
-f64 + f64 > i32
-f64 + f64 ^ 0.5
-f64 + float(i64)
+f64 + f64 < f32
+f64 + f64 <= i32
+f64 + f64 ^ i32
+f64 + float(f64)
+f64 + floor(f64)
+f64 + get(array, i32)
 f64 + half(0.5)
-f64 + half(f64)
+f64 + half(1)
 f64 + i
-f64 + i ** 0.5
-f64 + i + 1
+f64 + i + 0.5
 f64 + i / 0.5
+f64 + i / i32
+f64 + i > 0.5 != true
+f64 + i > f64
+f64 + i >= f64
 f64 + i32
-f64 + i32 ** i64
-f64 + i32 + i32
-f64 + i32 / 1
-f64 + i32 <= i
-f64 + i32 >= i64
+f64 + i32 != i64
+f64 + i32 % i32
+f64 + i32 ** 1
+f64 + i32 > i64
 f64 + i64
-f64 + i64 - f64
-f64 + i64 ^ f32
-f64 + int(0.5)
-f64 + int(i32)
-f64 + len(array)
-f64 + min(0.5, 0.5)
-f64 + min(f32)
-f64 + score(i)
+f64 + i64 + i64
+f64 + i64 / f64
+f64 + i64 > i32 / i
+f64 + i64 > i64
+f64 + i64 ^ i32
+f64 + reduce(array, #)
+f64 + reduce(list, f32)
+f64 + score(1)
 f64 - -0.5
 f64 - -1
 f64 - -f64
 f64 - -i
-f64 - -i32
 f64 - -i64
-f64 - 0.5 != f64
-f64 - 0.5 * 0.5
-f64 - 0.5 ** i
-f64 - 0.5 + f32
-f64 - 0.5 + i
-f64 - 0.5 + i32
-f64 - 0.5 >= -0.5
-f64 - 1 * f32
-f64 - 1 ** f32
-f64 - 1 ** i32
-f64 - 1 + 1
+f64 - 0.5 - 0.5
+f64 - 0.5 - 1
+f64 - 0.5 - i32
+f64 - 0.5 >= f64
+f64 - 0.5 ^ i64
+f64 - 1 * i32
+f64 - 1 + i64
 f64 - 1 - f64
-f64 - 1 / 0.5
+f64 - 1 / i64
 f64 - 1 < f32
-f64 - 1 ^ 0.5
-f64 - 1 ^ 1
-f64 - abs(0.5)
-f64 - abs(i)
-f64 - array[i64]
+f64 - 1 < f32 ? i64 : false
+f64 - 1 >= len(array)
+f64 - 1 ^ i64
 f64 - f32
-f64 - f32 * f64
-f64 - f32 + 1 + 0.5
-f64 - f32 - f64
+f64 - f32 != i64
+f64 - f32 + f32
 f64 - f32 < f64
-f64 - f32 >= i32
+f64 - f32 ^ f32
 f64 - f64
-f64 - f64 - 0.5
-f64 - f64 - i32
-f64 - f64 <= i
-f64 - f64 == f64
-f64 - f64 > f32
-f64 - f64 >= get(array, i64)
-f64 - get(array, i)
-f64 - half(0.5)
+f64 - f64 + -1
+f64 - f64 < f64
+f64 - float(f32)
+f64 - floor(1)
+f64 - half(1)
 f64 - i
-f64 - i % i32
+f64 - i + 0.5
 f64 - i + 1
-f64 - i / 1
-f64 - i < i32
-f64 - i < i64
-f64 - i == i
-f64 - i == i64
-f64 - i > f64
+f64 - i + i32
+f64 - i / i
+f64 - i ^ f32
 f64 - i32
-f64 - i32 + i
-f64 - i32 - i64
-f64 - i32 >= i32
+f64 - i32 / 0.5
+f64 - i32 >= i64
+f64 - i32 ^ 0.5
 f64 - i64
-f64 - i64 * 0.5
-f64 - i64 * 1
-f64 - i64 - f32
-f64 - int(0.5)
+f64 - i64 ** i32
+f64 - int(i)
 f64 - int(i32)
-f64 - max(1)
-f64 - min(1)
-f64 - min(i32, i64)
+f64 - reduce(array, -#)
+f64 - round(1)
 f64 - score(i)
-f64 / (0.5 + f32)
-f64 / (0.5 - 0.5)
-f64 / (0.5 - f64)
-f64 / (0.5 - i32)
-f64 / (1 + i32)
-f64 / (1 - 1)
-f64 / (i32 + f64)
-f64 / (i32 - 1)
-f64 / (i64 - i64)
+f64 / (0.5 - 1)
+f64 / (0.5 - i64)
+f64 / (f32 + 1)
+f64 / (i + 0.5)
+f64 / (i32 + i64)
 f64 / -0.5
 f64 / -1
-f64 / -f32
+f64 / -f64
 f64 / -i
 f64 / -i32
-f64 / 0.5 * i
-f64 / 0.5 ** 0.5
-f64 / 0.5 ** f64
-f64 / 0.5 / f64
-f64 / 0.5 / i64
-f64 / 0.5 > f64
-f64 / 0.5 ^ i
+f64 / -i64
+f64 / 0.5 != f64
+f64 / 0.5 * f32
+f64 / 0.5 + f64
+f64 / 0.5 / 1
+f64 / 0.5 < i32
+f64 / 0.5 == i32
+f64 / 0.5 >= i64
 f64 / 1 != i
-f64 / 1 * abs(i64)
-f64 / 1 * i
-f64 / 1 ** 0.5
-f64 / 1 ^ i64
-f64 / array[i32]
-f64 / array[i]
+f64 / 1 * i32
+f64 / 1 ** 1
+f64 / 1 / i
+f64 / 1 <= i64
+f64 / 1 ^ i
+f64 / abs(f64)
+f64 / array[1]
+f64 / array[i64]
+f64 / ceil(i32)
 f64 / f32
-f64 / f32 != f64
 f64 / f32 * i
-f64 / f32 > f64
-f64 / f32 ^ i32
-f64 / f32 in [f32]
+f64 / f32 * i64
+f64 / f32 / 0.5
+f64 / f32 == f32
+f64 / f32 ^ 0.5
 f64 / f64
-f64 / f64 != f32
-f64 / f64 * f32
-f64 / f64 - f32
-f64 / f64 - f64
-f64 / get(array, i64)
+f64 / f64 / 0.5
+f64 / f64 >= f64
+f64 / f64 >= i32
+f64 / f64 >= i64
+f64 / float(1)
+f64 / float(f64)
+f64 / floor(i64)
+f64 / get(array, 1)
+f64 / get(array, i32)
 f64 / half(0.5)
+f64 / half(1)
 f64 / i
-f64 / i * i32
+f64 / i != f64
 f64 / i ** 0.5
-f64 / i ** i32
-f64 / i + i64
-f64 / i < f64
-f64 / i > 1 ** 1
-f64 / i > f64
-f64 / i >= f64
+f64 / i ** f32
+f64 / i + i32
+f64 / i == i64
+f64 / i >= i
 f64 / i32
-f64 / i32 / i32
-f64 / i32 < f64
+f64 / i32 != 0.5 - i64
+f64 / i32 == f64 ** i
+f64 / i32 == i32
+f64 / i32 >= f32
 f64 / i64
-f64 / i64 * i64 ^ i
-f64 / i64 - f32
-f64 / i64 / 0.5
-f64 / i64 / i64
-f64 / i64 <= f64
-f64 / i64 > i
+f64 / i64 < f64
 f64 / int(f32)
-f64 / int(i64)
+f64 / last(array)
 f64 / max(i)
-f64 / min(0.5)
-f64 / score(i)
+f64 / reduce(array, #)
+f64 / reduce(array, f64)
+f64 / reduce(list, f32)
+f64 / round(1)
+f64 / round(i64)
+f64 / score(1)
 f64 < -0.5
-f64 < -1
 f64 < -i32
 f64 < -i64
-f64 < 0.5 ** f32
+f64 < 0.5 + i64
+f64 < 0.5 / 0.5
+f64 < 0.5 / i
 f64 < 0.5 == true
-f64 < 0.5 ? 0.5 : foo
-f64 < 0.5 ? 1 : array
-f64 < 0.5 ? greet : false
-f64 < 0.5 ^ 1
-f64 < 0.5 or ok
-f64 < 1 == not ok
-f64 < 1 ? 1 : half
-f64 < 1 ? 1 : i
-f64 < 1 ? ok : i
-f64 < 1 and nil == i32
+f64 < 0.5 ? f64 : array
+f64 < 1 % 1
+f64 < 1 * 0.5
+f64 < 1 ** i32
+f64 < 1 / f32
+f64 < 1 == false
+f64 < 1 ? i : "foo"
 f64 < abs(1)
-f64 < abs(i32)
-f64 < array[i32]
-f64 < count(list, true)
+f64 < abs(f32)
+f64 < array[i64]
+f64 < bitnot(1)
+f64 < ceil(f64)
+f64 < count(array, false)
 f64 < f32
-f64 < f32 * 0.5
-f64 < f32 * f64
-f64 < f32 ** i32
-f64 < f32 - 1
-f64 < f32 ? array : 0.5
+f64 < f32 * i
+f64 < f32 / i64
+f64 < f32 ^ 1
+f64 < f32 ^ f64
 f64 < f64
-f64 < f64 * f32
+f64 < f64 == ok
+f64 < floor(i64)
 f64 < get(array, i)
-f64 < half(0.5)
 f64 < i
-f64 < i - f64
-f64 < i == ok
-f64 < i ? false : nil
+f64 < i && "bar" < "bar"
+f64 < i && ok
+f64 < i ** i32
+f64 < i + 1
+f64 < i ? 0.5 : "bar"
+f64 < i ? div : nil
 f64 < i32
-f64 < i32 % i32
-f64 < i32 % i64
-f64 < i32 == ok
-f64 < i32 and ok
+f64 < i32 * f64
+f64 < i32 * i
+f64 < i32 ** f32
+f64 < i32 ** i64
+f64 < i32 + f32
+f64 < i32 + f64
+f64 < i32 + i64
+f64 < i32 ? false : ok
+f64 < i32 ? true : 1
+f64 < i32 ^ 1
+f64 < i32 ^ i32
 f64 < i64
-f64 < i64 * i
+f64 < i64 * f64
+f64 < i64 ^ i
 f64 < int(0.5)
-f64 < max(1, i64)
-f64 < min(1)
-f64 < min(f64)
-f64 < min(i64)
+f64 < max(1)
+f64 < max(f64, i32)
+f64 < min(0.5, i64)
+f64 < min(f32)
+f64 < min(f64, f32)
+f64 < min(i32)
+f64 < round(0.5)
+f64 < score(1)
 f64 <= -0.5
 f64 <= -1
-f64 <= -f32
 f64 <= -i
 f64 <= -i32
-f64 <= 0.5 != ok
-f64 <= 0.5 - 1
-f64 <= 0.5 / 0.5
-f64 <= 0.5 == true
-f64 <= 0.5 ? foo : list
-f64 <= 0.5 ? nil : add
-f64 <= 1 != true
-f64 <= 1 ** 0.5
+f64 <= 0.5 != false
+f64 <= 0.5 + 0.5
+f64 <= 0.5 / f32
+f64 <= 0.5 ? greet : f64
+f64 <= 0.5 ? score : array
+f64 <= 1 * i32
 f64 <= 1 + 0.5
-f64 <= 1 == false
-f64 <= 1 ? array : foo
-f64 <= 1 ^ i64
-f64 <= abs(f32)
+f64 <= 1 / i
+f64 <= 1 == nil
+f64 <= 1 ? "bar" : array
+f64 <= 1 ? half : list
+f64 <= 1 ^ f64
+f64 <= abs(0.5)
 f64 <= abs(i)
-f64 <= array[i]
+f64 <= array[i64]
+f64 <= ceil(i)
 f64 <= f32
-f64 <= f32 + f64
-f64 <= f32 - 0.5
-f64 <= f32 ? false : "foo"
-f64 <= f32 ? false : i
-f64 <= f32 ? i64 : false
+f64 <= f32 ** 0.5
+f64 <= f32 - i64
+f64 <= f32 ? f64 : div
+f64 <= f32 ^ f32
 f64 <= f64
+f64 <= f64 != ok
 f64 <= f64 + f64
-f64 <= f64 - 0.5
-f64 <= f64 - f64
-f64 <= f64 ^ 0.5
-f64 <= find(array, true)
-f64 <= float(f64)
+f64 <= f64 + i32
+f64 <= f64 - 1
+f64 <= f64 ^ i
+f64 <= float(i)
+f64 <= float(i64)
 f64 <= half(0.5)
+f64 <= half(1)
 f64 <= i
-f64 <= i * i32
-f64 <= i ? false : false
-f64 <= i ? foo : false
+f64 <= i * i64
+f64 <= i - 1
+f64 <= i - f32
+f64 <= i ^ f64
 f64 <= i32
-f64 <= i32 == true
-f64 <= i32 ? "bar" : nil
-f64 <= i32 ? add : ok
-f64 <= i32 ? i32 : false
+f64 <= i32 ** 1
+f64 <= i32 ? div : foo
+f64 <= i32 or all(list, ok)
 f64 <= i64
-f64 <= i64 % 1
-f64 <= i64 - f32
-f64 <= i64 - i64
-f64 <= i64 ^ 1
-f64 <= i64 and ok
-f64 <= int(1)
-f64 <= int(f64)
-f64 <= int(i)
-f64 <= max(f32)
-f64 <= min(0.5)
-f64 <= score(1)
+f64 <= i64 + 1
+f64 <= i64 - 0.5
+f64 <= int(f32)
+f64 <= max(i)
+f64 <= max(i64, i32)
+f64 <= min(i32)
+f64 <= min(i64)
+f64 <= reduce(array, #)
 f64 == -0.5
 f64 == -1
 f64 == -f32
 f64 == -f64
 f64 == -i
-f64 == -i32
-f64 == 0.5 != ok
+f64 == -i64
 f64 == 0.5 ** 0.5
-f64 == 0.5 ** i32
-f64 == 0.5 / i
-f64 == 0.5 / i32
-f64 == 0.5 ? i64 : div
-f64 == 1 * f64
-f64 == 1 == nil
-f64 == 1 ? false : "foo"
-f64 == abs(1)
-f64 == abs(i32)
-f64 == array[i32]
-f64 == array[i64]
+f64 == 0.5 - i
+f64 == 0.5 ? 0.5 : i64
+f64 == 0.5 ? 1 : 1
+f64 == 1 != ok
+f64 == 1 % 1
+f64 == 1 * i64
+f64 == 1 ** 0.5
+f64 == 1 == false
+f64 == abs(0.5)
+f64 == abs(i64)
+f64 == ceil(i)
 f64 == f32
-f64 == f32 + i64
-f64 == f32 - 1
-f64 == f32 / 0.5
+f64 == f32 && ok
+f64 == f32 + len(array)
+f64 == f32 ? 0.5 : i
+f64 == f32 ^ i32
 f64 == f64
-f64 == f64 ** i32
-f64 == f64 - 1
-f64 == f64 / 1
+f64 == f64 ** i
+f64 == f64 - f64
 f64 == float(0.5)
-f64 == float(i)
-f64 == get(array, i64)
+f64 == floor(0.5)
+f64 == half(0.5)
 f64 == half(f64)
 f64 == i
-f64 == i ** f32
-f64 == i + 0.5
-f64 == i / i32
-f64 == i ? false : f32
-f64 == i ^ f32
+f64 == i != false
+f64 == i * 1
+f64 == i ? i32 : score
 f64 == i32
-f64 == i32 * 1
-f64 == i32 + f64
-f64 == i32 / 1
-f64 == i32 ? greet : array
+f64 == i32 == ok ? 1 : list
+f64 == i32 == true
+f64 == i32 || ok
 f64 == i64
-f64 == i64 - f32
-f64 == i64 == true
-f64 == int(0.5)
+f64 == i64 / i
+f64 == i64 ? 1 : 0.5
+f64 == i64 ? greet : i32
 f64 == int(f32)
-f64 == min(0.5)
-f64 == min(i64)
-f64 == nil == ok
-f64 == nil ? i32 : div
-f64 == nil ? nil : 0.5
-f64 == score(1)
+f64 == max(0.5)
+f64 == max(i)
+f64 == min(i32)
+f64 == nil && ok
+f64 == nil ? 0.5 : add
+f64 == nil ? foo : "foo"
+f64 == reduce(list, i32)
+f64 == round(i)
+f64 == score(i, 1)
 f64 > -0.5
 f64 > -1
-f64 > -f32
 f64 > -f64
 f64 > -i
 f64 > -i32
-f64 > 0.5 - f64
-f64 > 0.5 / 0.5
-f64 > 0.5 ? 0.5 : nil
-f64 > 0.5 ? score(1, 1) : nil == nil
-f64 > 0.5 ^ 1
-f64 > 0.5 || ok
-f64 > 1 != ok
-f64 > 1 != true
-f64 > 1 % i
-f64 > 1 * 0.5
-f64 > 1 - 0.5
-f64 > 1 - i32
-f64 > 1 / 0.5
-f64 > 1 / f64
-f64 > 1 ? 0.5 : ok
-f64 > 1 ? false : true
-f64 > 1 ^ 1
-f64 > abs(0.5)
-f64 > abs(1)
-f64 > abs(i)
-f64 > abs(i32)
-f64 > count(array, true)
+f64 > 0.5 ** f32
+f64 > 0.5 / i
+f64 > 0.5 ^ i
+f64 > 0.5 or i <= 0.5
+f64 > 1 + f32
+f64 > 1 + i32
+f64 > 1 ? div : i32
+f64 > 1 ^ i32
+f64 > array[i64]
+f64 > ceil(0.5)
+f64 > ceil(1)
+f64 > ceil(f32)
 f64 > f32
-f64 > f32 - 0.5
+f64 > f32 / 1
 f64 > f64
-f64 > f64 ** 0.5
-f64 > f64 ? f64 : list
-f64 > f64 ^ 0.5
-f64 > findIndex(array, ok)
-f64 > float(1)
-f64 > float(f32)
+f64 > f64 - 0.5
+f64 > float(0.5 * i64)
+f64 > floor(f64)
+f64 > get(array, 1)
 f64 > half(0.5)
+f64 > half(1)
+f64 > half(f64)
 f64 > i
-f64 > i != ok
-f64 > i ** i32
-f64 > i - i32
+f64 > i - 0.5
 f64 > i32
-f64 > i32 ** f32
-f64 > i32 - f32
 f64 > i32 == ok
-f64 > i32 ? i : 0.5
+f64 > i32 ? f32 : array
+f64 > i32 ? list : half
+f64 > i32 ^ i32
+f64 > i32 ^ i64
 f64 > i64
-f64 > i64 ** i64
-f64 > int(0.5)
-f64 > int(i64)
+f64 > i64 - 1
+f64 > i64 ? array : half
+f64 > i64 ? list : div
+f64 > i64 || ok or ok
+f64 > int(f32)
+f64 > last(array)
 f64 > max(0.5)
-f64 > max(i64)
-f64 > min(1)
-f64 > min(f64)
-f64 > min(i)
-f64 > min(i32)
-f64 > score(i)
+f64 > max(0.5, i64)
+f64 > max(f32)
+f64 > median(array)
+f64 > min(f32)
 f64 >= -0.5
 f64 >= -1
-f64 >= -f64
-f64 >= -i32
 f64 >= -i64
-f64 >= 0.5 * 1
-f64 >= 0.5 ** 0.5
-f64 >= 0.5 ** i32
-f64 >= 0.5 + 0.5
-f64 >= 0.5 + i
-f64 >= 0.5 - i
-f64 >= 0.5 - i32
-f64 >= 0.5 ? nil : 0.5
-f64 >= 0.5 ^ 0.5
-f64 >= 1 * i
-f64 >= 1 - 0.5
-f64 >= 1 / i64
-f64 >= 1 == ok
-f64 >= 1 ^ 1
-f64 >= 1 || ok
-f64 >= abs(1)
-f64 >= abs(f32)
-f64 >= abs(f64)
-f64 >= count(list, true)
+f64 >= 0.5 + i32
+f64 >= 0.5 - 1
+f64 >= 0.5 - f32
+f64 >= 0.5 / i64
+f64 >= 0.5 ? list : i32
+f64 >= 0.5 ^ i64
+f64 >= array[1]
 f64 >= f32
-f64 >= f32 != true
-f64 >= f32 - f32
-f64 >= f32 ? true : nil
+f64 >= f32 - i32
+f64 >= f32 ^ 1
 f64 >= f64
-f64 >= f64 * 0.5
-f64 >= f64 ? nil : f64
-f64 >= f64 ? score : f32
-f64 >= half(f64)
+f64 >= f64 != nil
+f64 >= f64 != ok
+f64 >= findIndex(array, ok)
+f64 >= floor(f32)
+f64 >= floor(i)
+f64 >= half(0.5)
+f64 >= half(1)
 f64 >= i
-f64 >= i - 1
+f64 >= i * 0.5
+f64 >= i ** 0.5
+f64 >= i ** i32
+f64 >= i / i32
+f64 >= i ^ 1
 f64 >= i32
-f64 >= i32 != nil
-f64 >= i32 ** 0.5
-f64 >= i32 + f32
-f64 >= i32 + i64
-f64 >= i32 ^ f32
+f64 >= i32 - f64
+f64 >= i32 ? ok : add
+f64 >= i32 ^ 1
 f64 >= i64
-f64 >= i64 * 0.5
-f64 >= i64 * f64
-f64 >= i64 * i64
-f64 >= i64 ? list : i >= f32
-f64 >= i64 ? ok : true
-f64 >= i64 || ok
-f64 >= max(f64)
-f64 >= min(0.5)
-f64 >= score(1)
+f64 >= i64 + f64
+f64 >= i64 ? 0.5 : score
+f64 >= i64 ? 1 : f32
+f64 >= max(1)
+f64 >= median(array)
+f64 >= reduce(array, #)
+f64 >= reduce(array, i32)
 f64 >= score(i)
-f64 ^ (0.5 * 1)
-f64 ^ (0.5 * f32)
-f64 ^ (0.5 / i)
-f64 ^ (1 + i)
-f64 ^ (1 - f32)
-f64 ^ (1 / 0.5)
-f64 ^ (1 / i64)
-f64 ^ -1
-f64 ^ 0.5 != f32
-f64 ^ 0.5 * i64
-f64 ^ 0.5 + f64
-f64 ^ 0.5 < 0.5 ^ 0.5
-f64 ^ 0.5 <= i64
-f64 ^ 0.5 > i == nil
-f64 ^ 0.5 >= i32 / i64
-f64 ^ 1 != i
+f64 ^ (0.5 * i)
+f64 ^ (0.5 + 1)
+f64 ^ (1 * f64)
+f64 ^ (1 - 1)
+f64 ^ (f32 + 1)
+f64 ^ (f32 - 0.5)
+f64 ^ (f32 - i)
+f64 ^ (f32 / -f64)
+f64 ^ (i32 - 1)
+f64 ^ (i32 / f32)
+f64 ^ (i64 - 1)
+f64 ^ -0.5
+f64 ^ -i32
+f64 ^ 0.5 * f64
+f64 ^ 0.5 ** f32
+f64 ^ 0.5 ** i32
+f64 ^ 0.5 > ceil(f32)
+f64 ^ 0.5 > i
+f64 ^ 0.5 >= f64
+f64 ^ 0.5 >= i32
+f64 ^ 0.5 ^ i32
+f64 ^ 0.5 not in array
 f64 ^ 1 ** i
-f64 ^ 1 + i
-f64 ^ 1 / f32
-f64 ^ 1 / i64
-f64 ^ 1 <= i32
+f64 ^ 1 ** i64
 f64 ^ 1 ^ i
-f64 ^ abs(i32)
-f64 ^ count(array, true)
+f64 ^ abs(0.5)
+f64 ^ array[i64]
 f64 ^ f32
-f64 ^ f32 != i32
-f64 ^ f32 * f32
-f64 ^ f32 ** i
-f64 ^ f32 + f64
-f64 ^ f32 / i64
-f64 ^ f32 < i
-f64 ^ f32 >= i64
-f64 ^ f32 ^ i64
+f64 ^ f32 ** 1
+f64 ^ f32 < score(1)
+f64 ^ f32 >= i32
 f64 ^ f64
-f64 ^ f64 != f32
-f64 ^ f64 * i
-f64 ^ f64 + int(0.5)
-f64 ^ float(i64)
-f64 ^ half(0.5)
+f64 ^ f64 - -i
+f64 ^ f64 == i32
+f64 ^ f64 > f64
+f64 ^ f64 ^ i
+f64 ^ f64 ^ i64
+f64 ^ findIndex(array, true)
+f64 ^ float(abs(i))
+f64 ^ floor(f64)
+f64 ^ half(1)
 f64 ^ half(f64)
 f64 ^ i
-f64 ^ i ** i32
-f64 ^ i / i
-f64 ^ i <= f32
+f64 ^ i ** 1
+f64 ^ i + f32
+f64 ^ i + i32
+f64 ^ i <= i32
+f64 ^ i ^ i64
 f64 ^ i32
-f64 ^ i32 ** i
-f64 ^ i32 + f64
+f64 ^ i32 / f64
+f64 ^ i32 <= i32
 f64 ^ i32 >= i
-f64 ^ i32 ^ f64
 f64 ^ i64
-f64 ^ i64 + i64
-f64 ^ i64 - i
-f64 ^ i64 < i
-f64 ^ i64 >= i32
+f64 ^ i64 ** i64
+f64 ^ int(0.5)
 f64 ^ int(f64)
 f64 ^ last(array)
 f64 ^ len(list)
-f64 ^ max(0.5)
+f64 ^ min(1)
+f64 ^ reduce(array, #)
+f64 ^ round(i)
 f64 ^ score(1)
-false != true || 1 > f64
-false && ok or ok
-false ? "bar" : 0.5 == f32
-false ? "bar" : 1 != i
-false ? "bar" : foo.Qux
-false ? 0.5 : foo.Qux
-false ? 1 : half != div
-false ? 1 : true != ok
-false ? add : foo?.Bar
-false ? f32 : foo.Bar
-false ? f32 : foo?.String()
-false ? f32 : i .. i32
-false ? f64 : 0.5 >= f64
-false ? f64 : f32 / f32
-false ? false : 0.5 + i32
-false ? false : i64 >= i
-false ? foo : foo.Qux
-false ? greet : i64 != i
-false ? half : 0.5 > 1 + i64
-false ? half : f32 > min(0.5)
-false ? i : 1 != i
-false ? i32 : 1 >= f64
-false ? i64 : "foo" < toJSON(f64)
-false ? i64 : foo?.Qux
-false ? list : 1 < f32
-false ? list : f32 ** i32
-false ? list : foo.Bar
-false ? nil : 1 >= get(array, 1)
+f64 in array
+f64 in array != nil
+f64 in groupBy(list, i64)
+f64 not in array
+f64 not in array != ok
+f64 not in array != true
+f64 not in array == true
+f64 not in groupBy(array, #)
+f64 not in groupBy(array, bitnand(#, 1))
+f64 not in i .. i32
+f64 not in map(array, #)
+false != false ? foo : greet
+false && i not in array
+false && nil not in array
+false && nil not in list
+false == nil ? i32 : f64
+false == nil ? i32 : i32
+false ? "bar" : 0.5 - i
+false ? "foo" : f32 * i
+false ? "foo" : f32 / i32
+false ? "foo" : foo.Qux
+false ? add : 1 / i ^ 0.5
+false ? add : i64 - i
+false ? div : i64 ** i
+false ? f32 : foo.Qux
+false ? f64 : 0.5 != i32
+false ? f64 : 0.5 ** i32
+false ? f64 : 1 >= i
+false ? f64 : foo?.Qux
+false ? f64 : i ^ f32
+false ? false : foo?.Qux
+false ? foo : i32 - i
+false ? half : 0.5 == f32
+false ? half : i ^ i64
+false ? i : foo?.Qux
+false ? i : nil in list
+false ? i32 : 1 <= i32
+false ? i32 : foo.Qux
+false ? i64 : 1 <= f32
+false ? i64 : foo.Qux
+false ? i64 : i64 ** i64
+false ? list : list == list
 false ? nil : foo?.Qux
-false ? ok : foo.String
-false ? score : 0.5 == i
-false ? score : 1 / i64
-false ? score : f64 - -f32
-false ? true : 0.5 == f32
-false or ok ? string(1) : f64 == f32
-filter(1 .. 1, # == 0.5)
-filter(1 .. i64, ok)
-filter([div], any(array, true))
-filter([i32, i], # <= f64)
-filter(array, !false)
-filter(array, !ok)
-filter(array, "bar" == "bar")
-filter(array, "bar" matches "bar")
-filter(array, "foo" not matches "bar")
+false ? nil : i32 > i32
+false ? ok : foo.String()
+false ? ok : i64 < i64
+false and false || 0.5 > f32
+false or 1 not in array
+false or true or ok
+false or true || ok
+filter(1 .. 1, # > i)
+filter(1 .. i, i >= #)
+filter([0.5], # > 0.5)
+filter([nil], # != false)
+filter(array, !true)
+filter(array, "bar" != "foo")
+filter(array, "foo" == nil)
 filter(array, # != #)
+filter(array, # != f32)
 filter(array, # != f64)
 filter(array, # != i)
-filter(array, # != i32)
 filter(array, # != i64)
 filter(array, # < #)
-filter(array, # < 1)
-filter(array, # < f32)
 filter(array, # < f64)
-filter(array, # < i)
-filter(array, # < i32)
 filter(array, # <= #)
-filter(array, # <= 0.5)
 filter(array, # <= 1)
-filter(array, # <= f64)
+filter(array, # <= bitshr(#, #))
 filter(array, # <= i)
-filter(array, # <= i32)
+filter(array, # <= i64)
 filter(array, # == #)
-filter(array, # == 1)
+filter(array, # == 0.5)
 filter(array, # == f32)
 filter(array, # == f64)
 filter(array, # == i)
+filter(array, # == i32)
+filter(array, # == i64)
 filter(array, # == nil)
 filter(array, # > #)
+filter(array, # > 0.5)
 filter(array, # > 1)
 filter(array, # > i)
+filter(array, # > i32)
 filter(array, # >= #)
+filter(array, # >= 0.5)
 filter(array, # >= 1)
 filter(array, # >= f32)
-filter(array, # >= f64)
+filter(array, # >= i)
 filter(array, # >= i32)
-filter(array, # in array)
-filter(array, # not in array)
+filter(array, # >= i64)
 filter(array, 0.5 != #)
+filter(array, 0.5 != f64)
+filter(array, 0.5 != i)
 filter(array, 0.5 < #)
-filter(array, 0.5 < f32)
 filter(array, 0.5 < f64)
+filter(array, 0.5 < i32)
+filter(array, 0.5 <= #)
+filter(array, 0.5 <= i)
+filter(array, 0.5 <= i32)
 filter(array, 0.5 == #)
-filter(array, 0.5 > 0.5)
+filter(array, 0.5 == f64)
+filter(array, 0.5 > #)
 filter(array, 0.5 >= #)
 filter(array, 1 != #)
-filter(array, 1 != f32)
-filter(array, 1 < #)
-filter(array, 1 < f64)
-filter(array, 1 <= #)
+filter(array, 1 < i)
 filter(array, 1 == #)
-filter(array, 1 > #)
-filter(array, 1 > 0.5)
-filter(array, add == div)
-filter(array, all(list, ok))
+filter(array, 1 == 0.5)
+filter(array, 1 == i)
+filter(array, 1 > i)
+filter(array, 1 >= #)
+filter(array, add == add)
+filter(array, add == nil)
+filter(array, any(list, ok))
 filter(array, f32 != #)
-filter(array, f32 < i32)
-filter(array, f32 <= f32)
+filter(array, f32 < #)
+filter(array, f32 <= #)
 filter(array, f32 == #)
-filter(array, f32 > 1)
+filter(array, f32 == i64)
+filter(array, f32 > #)
 filter(array, f32 >= #)
-filter(array, f64 != #)
-filter(array, f64 != 0.5)
+filter(array, f64 < #)
 filter(array, f64 <= #)
-filter(array, f64 == #)
-filter(array, f64 > #)
-filter(array, f64 >= 1)
-filter(array, foo == nil)
-filter(array, greet == add)
-filter(array, greet == half)
-filter(array, i <= 1)
-filter(array, i <= f64)
-filter(array, i == f32)
-filter(array, i >= 1)
-filter(array, i >= f64 != false)
-filter(array, i32 != #)
-filter(array, i32 <= #)
-filter(array, i32 == #)
-filter(array, i32 == 1)
-filter(array, i32 > # % #)
+filter(array, f64 == i32)
+filter(array, f64 >= #)
+filter(array, half != nil)
+filter(array, half == half)
+filter(array, half(1) >= # ^ i)
+filter(array, i != #)
+filter(array, i != f64)
+filter(array, i <= i32)
+filter(array, i == #)
+filter(array, i > #)
+filter(array, i > f32)
+filter(array, i32 != i64)
+filter(array, i32 < 0.5)
 filter(array, i32 > #)
-filter(array, i32 > 0.5)
-filter(array, i32 >= #)
-filter(array, i64 != #)
 filter(array, i64 < #)
-filter(array, i64 < 1)
 filter(array, i64 < i64)
-filter(array, i64 <= #)
-filter(array, i64 == 1)
+filter(array, i64 == #)
+filter(array, i64 == i32)
+filter(array, i64 >= #)
 filter(array, nil != #)
 filter(array, nil != greet)
 filter(array, nil == #)
-filter(array, nil == f32)
-filter(array, nil in list)
-filter(array, none(array, ok))
+filter(array, nil == 1)
+filter(array, nil == i32)
+filter(array, not false)
+filter(array, not ok)
+filter(array, not true)
+filter(array, ok && true)
 filter(array, ok)
-filter(array, score(#) != #)
-filter(array, true && ok)
-filter(array, true or false)
-filter(array, true)[i:i32]
-filter(filter(array, true), i >= f32)
-filter(filter(list, false), "bar" in #)
-filter(filter(list, ok), ok)
-filter(i .. 1, not ok)
-filter(i32 .. i32, nil == true)
-filter(i32 .. i64, ok)
-filter(list, !false)
+filter(array, ok)[i64]
+filter(array, score == nil)
+filter(array, true == true)
+filter(array, true and true)
+filter(false ? ok : array, # == nil)
+filter(filter(list, true), ok)
+filter(groupBy(list, #).f64, # not matches #?.foo)
+filter(i .. i64, ok)
 filter(list, !ok)
 filter(list, !true)
-filter(list, "bar" not in #)
+filter(list, "bar" < "foo")
 filter(list, "bar" not matches "foo")
-filter(list, "bar" startsWith "bar")
+filter(list, "foo" == "foo")
 filter(list, "foo" in #)
-filter(list, "foo" not in #)
+filter(list, "foo" not endsWith "bar")
+filter(list, "foo" startsWith "bar")
 filter(list, # != #)
 filter(list, # != foo)
 filter(list, # != nil)
 filter(list, # == #)
 filter(list, # == foo)
-filter(list, # == nil)
-filter(list, 0.5 != f64)
-filter(list, 0.5 != i)
-filter(list, 0.5 > f32)
-filter(list, 1 != 0.5)
-filter(list, 1 != i32)
-filter(list, 1 != nil)
-filter(list, 1 < 0.5)
+filter(list, # in list)
+filter(list, 0.5 < 1)
+filter(list, 0.5 <= 0.5)
+filter(list, 0.5 >= 1)
+filter(list, 0.5 >= i)
+filter(list, 0.5 >= i64)
 filter(list, 1 < 1)
-filter(list, all(array, false))
-filter(list, all(array, true))
-filter(list, div == half)
-filter(list, f32 < 0.5)
-filter(list, f32 <= f32)
-filter(list, f32 == i64)
-filter(list, f32 >= 1)
-filter(list, f64 >= 0.5)
-filter(list, false == ok)
-filter(list, foo != #)
+filter(list, 1 <= f32)
+filter(list, any(array, ok))
+filter(list, any(list, true))
+filter(list, div != div)
+filter(list, f32 <= 1)
+filter(list, f32 == f64)
+filter(list, f32 > i)
+filter(list, f64 <= 1)
+filter(list, f64 == 0.5)
+filter(list, false != false)
+filter(list, false or ok)
 filter(list, foo == #)
-filter(list, foo == foo)
-filter(list, foo in list)
-filter(list, greet != nil)
-filter(list, half != half)
-filter(list, i <= 0.5)
-filter(list, i <= i)
-filter(list, i == f32)
-filter(list, i == i32)
-filter(list, i == i64)
-filter(list, i >= i32)
-filter(list, i32 != 1)
-filter(list, i32 != nil)
-filter(list, i32 < i64)
-filter(list, i32 <= i32)
-filter(list, i32 == i)
-filter(list, i64 > f32)
-filter(list, nil != f64)
-filter(list, nil != score)
-filter(list, nil != true)
+filter(list, i < 0.5)
+filter(list, i < f32)
+filter(list, i >= 0.5)
+filter(list, i64 > 0.5)
+filter(list, nil != "foo")
+filter(list, nil != #)
+filter(list, nil != #?.Bar)
+filter(list, nil != add)
+filter(list, nil != greet)
+filter(list, nil != i64)
 filter(list, nil == #)
-filter(list, not ok)
-filter(list, ok or true)
-filter(list, ok || true)
+filter(list, nil == 0.5)
+filter(list, nil == f32)
+filter(list, nil == half)
+filter(list, nil == i32)
+filter(list, nil == score)
+filter(list, ok == nil)
+filter(list, ok and false)
 filter(list, ok)
-filter(list, true == nil)
-filter(map(array, "bar"), # >= #)
-filter(map(array, "foo"), ok)
-filter(map(array, #), # != 0.5)
-filter(map(array, #), ok)
-filter(map(array, 0.5 >= #), ok)
-filter(map(list, "bar"), i >= i)
-filter(map(list, "foo"), "bar" not matches #)
-filter(map(list, #), # != #)
+filter(list, ok)[i]
+filter(list, true == ok)
+filter(list, true || true)
+filter(list, true) == list
+filter(map(array, #), # == 1)
+filter(map(array, #), # > #)
+filter(map(array, 1), ok)
+filter(map(array, greet), ok)
+filter(map(array, i32), ok)
+filter(map(array, i64), nil == div)
+filter(map(array, ok), true || ok)
+filter(map(array, score), # != nil)
+filter(map(list, #), # == #)
+filter(map(list, #), half != nil)
 filter(map(list, #), ok)
-filter(map(list, 1), f32 != #)
+filter(map(list, array), # == #)
+filter(map(list, f32), # == #)
+filter(map(list, f32), ok)
 filter(map(list, false), #)
-filter(sort(array), ok)
-filter(split("foo", "bar"), ok)
-find(1 .. 1, # <= #)
-find([nil], 0.5 == 0.5)
+filter(map(list, i32), i64 <= i32)
+filter(map(list, ok), #)
+filter(map(list, true), #)
+filter(ok ? "foo" : 0.5, # <= i64)
+filter(true ? list : score, # != #)
+find(1 .. i, ok)
 find([ok], #)
+find([score, score], # == #)
+find(array, !(# <= i32))
 find(array, !ok)
 find(array, !true)
-find(array, "bar" startsWith "foo")
+find(array, "bar" not startsWith "foo")
+find(array, "foo" not contains "bar")
 find(array, # != #)
-find(array, # != 0.5)
-find(array, # != f32)
+find(array, # != 1)
+find(array, # != i)
 find(array, # != i32)
-find(array, # - # != #)
+find(array, # != nil)
+find(array, # - i != #)
 find(array, # < #)
 find(array, # < 0.5)
 find(array, # < 1)
 find(array, # < f32)
-find(array, # < f64)
+find(array, # < i)
 find(array, # < i32)
+find(array, # < i64)
 find(array, # <= #)
 find(array, # <= 0.5)
 find(array, # <= 1)
-find(array, # <= f32)
-find(array, # <= i)
+find(array, # <= i32)
 find(array, # == #)
 find(array, # == 0.5)
 find(array, # == 1)
-find(array, # == f32)
-find(array, # == f64)
 find(array, # == i)
-find(array, # == i32)
+find(array, # == i64)
 find(array, # == nil)
 find(array, # > #)
-find(array, # > 0.5)
-find(array, # > i)
+find(array, # > 1)
+find(array, # > i32)
 find(array, # > i64)
 find(array, # >= #)
 find(array, # >= 1)
+find(array, # >= f64)
 find(array, # >= i)
-find(array, # >= i32)
-find(array, 0.5 < i64)
+find(array, # not in array)
+find(array, 0.5 != 1)
+find(array, 0.5 / i64 <= #)
+find(array, 0.5 < #)
+find(array, 0.5 < f64)
 find(array, 0.5 <= #)
-find(array, 0.5 == #)
-find(array, 0.5 > #)
-find(array, 0.5 > 1)
+find(array, 0.5 >= #)
+find(array, 0.5 >= 0.5)
+find(array, 0.5 >= f64)
+find(array, 1 != #)
+find(array, 1 < #)
+find(array, 1 < i32)
+find(array, 1 < i64)
 find(array, 1 <= #)
-find(array, 1 <= 0.5)
-find(array, 1 == f32)
-find(array, 1 == i64)
+find(array, 1 <= i)
+find(array, 1 == #)
 find(array, 1 > #)
-find(array, 1 > 0.5)
-find(array, 1 > i32)
-find(array, 1 > i64)
 find(array, 1 >= #)
-find(array, 1 >= i)
-find(array, add != div)
-find(array, add != nil)
-find(array, any(array, true))
-find(array, array == list)
-find(array, div == half)
+find(array, div != nil)
+find(array, f32 != #)
+find(array, f32 != f32)
+find(array, f32 < #)
 find(array, f32 <= #)
+find(array, f32 == #)
+find(array, f32 == i32)
 find(array, f32 > #)
-find(array, f32 > 0.5)
 find(array, f32 >= #)
-find(array, f32 >= 1)
 find(array, f64 != #)
-find(array, f64 != i32)
-find(array, f64 != nil)
 find(array, f64 < #)
-find(array, f64 == nil)
-find(array, f64 >= 0.5)
-find(array, false == false)
-find(array, false) != i32
-find(array, i < #)
+find(array, f64 < 1)
+find(array, f64 <= #)
+find(array, f64 == #)
+find(array, f64 == i64)
+find(array, false ? # : false)
+find(array, false) != f64
+find(array, floor(#) > #)
+find(array, greet != greet)
+find(array, i % # != f64)
+find(array, i < 0.5)
 find(array, i <= #)
-find(array, i == #)
-find(array, i > #)
+find(array, i > 0.5)
 find(array, i >= #)
-find(array, i >= i64)
+find(array, i >= 1)
 find(array, i32 != #)
-find(array, i32 != 1)
-find(array, i32 < #)
-find(array, i32 <= #)
-find(array, i32 <= f32)
-find(array, i32 <= f64)
+find(array, i32 != i32)
 find(array, i32 == #)
-find(array, i32 == 1)
-find(array, i32 == f64)
 find(array, i32 > #)
+find(array, i32 >= #)
 find(array, i64 != #)
+find(array, i64 != 1)
 find(array, i64 < #)
-find(array, nil != "bar")
-find(array, nil != #)
+find(array, i64 <= #)
+find(array, i64 == #)
+find(array, i64 > #)
+find(array, nil != nil)
 find(array, nil == #)
-find(array, nil not in array)
-find(array, not false)
-find(array, not true)
-find(array, ok && ok)
+find(array, nil == 0.5)
+find(array, nil == i32)
+find(array, none(array, true))
+find(array, not (# == #))
 find(array, ok == nil)
+find(array, ok and false)
 find(array, ok)
-find(array, ok) * f64
-find(array, ok) ** i64
-find(array, ok) ^ i32
-find(array, score(#) >= #)
-find(array, true) / get(array, i64)
-find(array, true) > i
-find(array, true) ^ i32
-find(filter(array, ok), # >= #)
-find(filter(array, true), # != #)
-find(i32 .. 1, # > 0.5)
-find(i64 .. 1, ok)
-find(list, !true)
-find(list, "bar" startsWith "foo")
-find(list, "foo" < "foo")
-find(list, "foo" in #)
-find(list, "foo" not in #)
+find(array, ok) % i32
+find(array, ok) ** i
+find(array, ok) >= i32
+find(array, true) > f64
+find(array, true) > i64
+find(filter(list, false), i64 not in array)
+find(groupBy(array, #).Qux, .String?.f32)
+find(groupBy(array, #).ok, first(#[1]))
+find(i .. i64, ok)
+find(i64 .. i32, # != #)
+find(list, !false)
+find(list, !ok)
+find(list, "bar" not in #)
+find(list, "foo" contains "foo")
 find(list, # != #)
+find(list, # != nil)
 find(list, # == #)
+find(list, # == foo)
 find(list, # == nil)
-find(list, # not in list)
-find(list, 0.5 < f64)
-find(list, 0.5 <= i64)
-find(list, 0.5 > i)
-find(list, 1 < 0.5)
-find(list, 1 <= 0.5)
+find(list, 0.5 != 1)
+find(list, 0.5 <= 0.5)
+find(list, 1 != 0.5)
+find(list, 1 < 1)
+find(list, 1 < i64)
+find(list, 1 == f64)
+find(list, 1 > 0.5)
 find(list, 1 > i)
-find(list, add == add)
-find(list, f32 != f32)
-find(list, f32 < f64)
-find(list, f32 <= f32)
+find(list, 1 > i64)
+find(list, f32 < 1)
+find(list, f32 <= 0.5)
 find(list, f32 <= i32)
-find(list, f32 == f32)
-find(list, f64 != f32)
-find(list, f64 <= i64)
-find(list, f64 >= f32)
+find(list, f32 == i64)
+find(list, f32 > f64)
+find(list, f32 not in array)
+find(list, f64 < f64)
+find(list, false && true)
 find(list, false)?.Bar
 find(list, foo != #)
 find(list, foo == #)
-find(list, i < 1)
-find(list, i >= f64)
-find(list, i32 <= f32)
-find(list, i64 != f64)
-find(list, i64 >= 0.5)
-find(list, list != array)
+find(list, i != 1)
+find(list, i != f64)
+find(list, i != i32)
+find(list, i32 != 1)
+find(list, i32 != f64)
+find(list, i32 < i)
+find(list, i32 == i32)
 find(list, nil != #)
-find(list, nil != greet)
-find(list, nil != half)
 find(list, nil != ok)
-find(list, nil == #)
-find(list, nil == half)
-find(list, nil == score)
-find(list, nil not in array)
-find(list, nil not in list)
-find(list, not ok)
-find(list, ok or ok)
+find(list, nil == array)
+find(list, nil == div)
+find(list, not false)
+find(list, ok != false)
 find(list, ok)
-find(list, ok).Bar
-find(list, ok).Qux
 find(list, ok).String
+find(list, ok).String()
+find(list, ok)?.Bar
 find(list, ok)?.Qux
 find(list, ok)?.String
-find(list, score != add)
-find(list, score != greet)
+find(list, score == score)
+find(list, true != nil)
+find(list, true == true)
+find(list, true or false)
 find(list, true).Bar
 find(list, true).Qux
 find(list, true).String
 find(list, true)?.Bar
-find(list, true)?.Qux
 find(list, true)?.String
-find(list, true)?.String()
-find(map(array, #), # == #)
+find(map(array, #), # != f32)
+find(map(array, #), # <= 1)
+find(map(array, #), # == 0.5)
 find(map(array, #), ok)
-find(map(array, i), ok)
-find(map(array, true), #)
-find(map(list, "foo"), ok)
+find(map(array, false), #)
+find(map(array, foo), ok)
+find(map(array, ok), #)
 find(map(list, #), # != #)
-find(map(list, 0.5), # >= #)
-find(map(list, ok), ok)
+find(map(list, #), ok)
+find(map(list, 0.5), # != #)
+find(map(list, add), 0.5 >= i64)
+find(map(list, div), # == #)
+find(map(list, f32), # > 0.5)
+find(map(list, false), #)
+find(map(list, i), # == i64)
+find(map(list, ok), #)
 find(map(list, true), #)
-find(ok ? "bar" : 0.5, # != i32)
-find(sort(array), ok)
-find(true ? array : false, 0.5 > #)?.list
-findIndex(["bar"], ok)
-findIndex(["foo"], 0.5 > i64)
-findIndex(["foo"], ok)
-findIndex([1], # < #)
-findIndex([f64, greet], 1 > f64)
-findIndex([false], #)
-findIndex(array, !(# != #))
-findIndex(array, !(# == 1))
-findIndex(array, !false)
+find(ok ? "foo" : f64, f32 >= #)
 findIndex(array, !ok)
-findIndex(array, !true)
-findIndex(array, "bar" not endsWith "bar")
-findIndex(array, "bar" not startsWith "foo")
+findIndex(array, "bar" == "foo")
+findIndex(array, "foo" > "foo")
+findIndex(array, "foo" in foo)
 findIndex(array, # != #)
 findIndex(array, # != 0.5)
 findIndex(array, # != f32)
 findIndex(array, # != f64)
-findIndex(array, # != i32)
+findIndex(array, # != i)
 findIndex(array, # != i64)
 findIndex(array, # != nil)
-findIndex(array, # ** # > #)
 findIndex(array, # < #)
 findIndex(array, # < 1)
-findIndex(array, # < f64)
-findIndex(array, # < i)
 findIndex(array, # < i32)
-findIndex(array, # < i64)
 findIndex(array, # <= #)
+findIndex(array, # <= 0.5)
 findIndex(array, # <= 1)
-findIndex(array, # <= i)
-findIndex(array, # <= i32)
 findIndex(array, # == #)
+findIndex(array, # == 0.5)
 findIndex(array, # == 1)
-findIndex(array, # == f64)
 findIndex(array, # == i32)
+findIndex(array, # == nil)
 findIndex(array, # > #)
 findIndex(array, # > 0.5)
 findIndex(array, # > 1)
-findIndex(array, # > f32)
 findIndex(array, # > f64)
-findIndex(array, # > i64 - i)
+findIndex(array, # > i)
 findIndex(array, # > i64)
 findIndex(array, # >= #)
+findIndex(array, # >= 0.5)
 findIndex(array, # >= 1)
 findIndex(array, # >= f32)
+findIndex(array, # >= f64)
 findIndex(array, # >= i)
 findIndex(array, # >= i32)
-findIndex(array, # in array)
-findIndex(array, # not in array)
-findIndex(array, 0.5 < #)
-findIndex(array, 0.5 <= 1)
-findIndex(array, 0.5 <= f32)
+findIndex(array, # >= i64)
+findIndex(array, 0.5 != #)
+findIndex(array, 0.5 != 1)
+findIndex(array, 0.5 < 1)
+findIndex(array, 0.5 <= #)
 findIndex(array, 0.5 == #)
-findIndex(array, 0.5 > i64)
-findIndex(array, 0.5 >= #)
-findIndex(array, 0.5 >= i)
+findIndex(array, 0.5 == i64)
+findIndex(array, 0.5 > #)
+findIndex(array, 0.5 > 0.5)
+findIndex(array, 0.5 > i)
+findIndex(array, 0.5 > i32)
+findIndex(array, 0.5 >= 0.5)
+findIndex(array, 0.5 >= 1)
+findIndex(array, 0.5 not in array)
 findIndex(array, 1 != #)
+findIndex(array, 1 != i64)
+findIndex(array, 1 != nil)
 findIndex(array, 1 < #)
-findIndex(array, 1 < f32)
-findIndex(array, 1 < i64)
 findIndex(array, 1 <= #)
-findIndex(array, 1 == #)
 findIndex(array, 1 > #)
+findIndex(array, 1 > i)
 findIndex(array, 1 >= #)
-findIndex(array, add != half)
-findIndex(array, any(array, f32 < #))
-findIndex(array, f32 <= #)
+findIndex(array, add != div)
+findIndex(array, add != nil)
+findIndex(array, f32 != #)
+findIndex(array, f32 != 1)
+findIndex(array, f32 < #)
 findIndex(array, f32 == #)
-findIndex(array, f32 == nil)
-findIndex(array, f32 > #)
 findIndex(array, f32 >= #)
-findIndex(array, f64 <= #)
-findIndex(array, f64 <= i64)
-findIndex(array, f64 == #)
-findIndex(array, f64 > #)
+findIndex(array, f32 >= i32)
 findIndex(array, f64 >= #)
-findIndex(array, f64 >= 1)
-findIndex(array, half != greet)
-findIndex(array, i != #)
-findIndex(array, i < 0.5)
+findIndex(array, f64 >= i32)
+findIndex(array, false) == -f64
+findIndex(array, i != f64)
+findIndex(array, i < #)
+findIndex(array, i < i32)
 findIndex(array, i <= #)
-findIndex(array, i <= i32)
+findIndex(array, i <= 0.5)
 findIndex(array, i == #)
-findIndex(array, i == i)
-findIndex(array, i > #)
 findIndex(array, i >= i)
+findIndex(array, i >= i32)
 findIndex(array, i32 != #)
 findIndex(array, i32 < #)
-findIndex(array, i32 < f64)
-findIndex(array, i32 < i)
-findIndex(array, i32 <= #)
 findIndex(array, i32 == #)
-findIndex(array, i32 == nil)
-findIndex(array, i32 > #)
+findIndex(array, i32 > f32)
 findIndex(array, i64 != #)
-findIndex(array, i64 == #)
+findIndex(array, i64 != nil)
+findIndex(array, i64 < 0.5)
+findIndex(array, i64 <= #)
+findIndex(array, i64 <= i64)
 findIndex(array, i64 > #)
 findIndex(array, i64 >= #)
-findIndex(array, nil != #)
-findIndex(array, nil != 1)
-findIndex(array, nil != list)
-findIndex(array, nil == foo)
-findIndex(array, nil == i)
-findIndex(array, not ok)
+findIndex(array, i64 >= f64)
+findIndex(array, i64 >= i32)
+findIndex(array, nil != half)
+findIndex(array, nil != ok)
+findIndex(array, nil == #)
+findIndex(array, nil == 1)
+findIndex(array, nil == nil)
+findIndex(array, not false)
 findIndex(array, ok)
-findIndex(array, ok) * f64
-findIndex(array, ok) - i32
 findIndex(array, ok) / f64
-findIndex(array, ok) >= f64
-findIndex(array, score == greet)
-findIndex(array, true or false)
-findIndex(false ? div : list, ok)
+findIndex(array, ok) / i
+findIndex(array, ok) <= f32
+findIndex(array, one(list, false))
+findIndex(array, true) + f64
+findIndex(array, true) - f64
+findIndex(array, true) .. i
+findIndex(filter(array, false), # > 1)
+findIndex(filter(array, true), # not in array)
+findIndex(filter(list, false), 1 <= i64)
+findIndex(groupBy(array, #).f64, .Bar(half(add, half, div, greet, f64)))
+findIndex(groupBy(array, false).String, #?.i64())
+findIndex(groupBy(array, foo).String, #)
+findIndex(groupBy(list, #).Qux, #)
+findIndex(i32 .. 1, # >= #)
 findIndex(list, !false)
+findIndex(list, !ok)
 findIndex(list, !true)
-findIndex(list, "bar" == "bar")
-findIndex(list, "foo" != "bar")
-findIndex(list, "foo" contains "bar")
-findIndex(list, "foo" matches "bar")
+findIndex(list, "bar" > "foo")
+findIndex(list, "bar" in #)
+findIndex(list, "bar" not in #)
 findIndex(list, # != #)
-findIndex(list, # != foo)
 findIndex(list, # != nil)
 findIndex(list, # == #)
-findIndex(list, # == nil)
+findIndex(list, # == foo)
 findIndex(list, # in list)
-findIndex(list, 0.5 < i)
-findIndex(list, 0.5 <= f64)
-findIndex(list, 0.5 <= i64)
-findIndex(list, 0.5 > f64)
-findIndex(list, 0.5 >= f32)
-findIndex(list, 1 == nil)
-findIndex(list, array != list)
-findIndex(list, f32 < f64)
-findIndex(list, f64 <= f32)
-findIndex(list, f64 <= f64)
-findIndex(list, f64 == nil)
-findIndex(list, f64 > f64)
-findIndex(list, false && true)
+findIndex(list, #?.Bar not in #)
+findIndex(list, 0.5 != i)
+findIndex(list, 0.5 > 1)
+findIndex(list, 0.5 >= i)
+findIndex(list, 1 != i32)
+findIndex(list, 1 < f64)
+findIndex(list, 1 < i32)
+findIndex(list, 1 == f32)
+findIndex(list, 1 > 0.5)
+findIndex(list, 1 > i32)
+findIndex(list, 1 >= 1)
+findIndex(list, 1 >= i)
+findIndex(list, f32 != f32)
+findIndex(list, f32 != i)
+findIndex(list, f32 < i32)
+findIndex(list, f32 == bitshl(i, i64))
+findIndex(list, f32 > 1)
+findIndex(list, f64 != 0.5)
+findIndex(list, f64 < 1)
+findIndex(list, f64 < i)
+findIndex(list, f64 > 1)
+findIndex(list, f64 >= f64)
+findIndex(list, false != nil)
+findIndex(list, false || ok)
 findIndex(list, foo != #)
-findIndex(list, foo == #)
-findIndex(list, greet != half)
-findIndex(list, half == add)
-findIndex(list, i32 == i)
-findIndex(list, i32 > f64)
-findIndex(list, i32 >= i32)
-findIndex(list, i64 < 0.5)
-findIndex(list, i64 > f64)
-findIndex(list, nil != #)
-findIndex(list, nil != f64)
-findIndex(list, nil != false)
-findIndex(list, nil == #)
-findIndex(list, nil == 0.5)
-findIndex(list, nil == ok)
-findIndex(list, nil in list)
-findIndex(list, not false)
+findIndex(list, greet == nil)
+findIndex(list, i < 0.5)
+findIndex(list, i <= i32)
+findIndex(list, i32 == 1)
+findIndex(list, i32 >= i64)
+findIndex(list, i64 != f32)
+findIndex(list, nil != 0.5)
+findIndex(list, nil != f32)
+findIndex(list, nil != i64)
+findIndex(list, nil == "foo")
+findIndex(list, nil == f64)
 findIndex(list, not ok)
-findIndex(list, ok != ok)
-findIndex(list, ok or ok)
+findIndex(list, not true)
 findIndex(list, ok)
-findIndex(list, ok) + f32
-findIndex(list, ok) / i
-findIndex(list, ok) > i32
-findIndex(list, one(list, ok))
-findIndex(list, true ? true : true)
-findIndex(list, true) .. i
-findIndex(list, true) == 0.5 ^ i32
-findIndex(list, true) > i32 ** f32
-findIndex(list, true) not in array
-findIndex(map(array, #), # > #)
-findIndex(map(array, #), # >= f32)
-findIndex(map(array, 1), # != #)
-findIndex(map(array, add), i64 >= i64)
-findIndex(map(array, div), # == #)
-findIndex(map(array, false), #)
-findIndex(map(array, i64), ok)
-findIndex(map(list, #), !ok)
-findIndex(map(list, #), div == div)
-findIndex(map(list, #), ok)
-findIndex(map(list, f32), i32 == f64)
-findIndex(map(list, list), ok)
-findIndex(map(list, ok), # == ok)
-findIndex(sort(array), # < #)
-findIndex(true ? "bar" : i32, # < #)
-findIndex(true ? "bar" : true, ok)
-findLast([0.5], i64 != 0.5)
+findIndex(list, ok) * i
+findIndex(list, ok) ** i
+findIndex(list, ok) >= f64
+findIndex(list, ok) ^ i32
+findIndex(list, true ? ok : #)
+findIndex(list, true) % i64
+findIndex(map(array, #), # < #)
+findIndex(map(array, #), # >= #)
+findIndex(map(array, #), i > #)
+findIndex(map(array, f32), i32 == #)
+findIndex(map(array, i), # != #)
+findIndex(map(array, i), ok)
+findIndex(map(list, #), # != #)
+findIndex(map(list, #), # == #)
+findIndex(map(list, i64), # == 0.5)
+findIndex(map(list, i64), i64 < #)
+findIndex(map(list, true), #)
+findIndex(map(list, true), ok)
+findIndex(ok ? "foo" : greet, !ok)
+findIndex(ok ? "foo" : i, # == #)
+findIndex(sort(array), i32 == #)
+findIndex(true ? "foo" : ok, # == greet)
+findLast(1 .. i, # <= #)
+findLast(1 .. i32, 1 >= #)
+findLast(1 .. i64, ok)
+findLast([false], #)
 findLast(array, !false)
-findLast(array, !true)
-findLast(array, "bar" > "bar")
-findLast(array, "foo" startsWith "foo")
+findLast(array, !ok)
+findLast(array, "foo" > "bar")
 findLast(array, # != #)
+findLast(array, # != 0.5)
+findLast(array, # != 1)
+findLast(array, # != f32)
 findLast(array, # != f64)
-findLast(array, # != nil)
+findLast(array, # != i)
 findLast(array, # < #)
 findLast(array, # < 0.5)
-findLast(array, # < 1)
 findLast(array, # < f32)
 findLast(array, # < f64)
-findLast(array, # < i)
+findLast(array, # < i + #)
 findLast(array, # <= #)
 findLast(array, # <= 0.5)
 findLast(array, # <= 1)
 findLast(array, # <= f32)
-findLast(array, # <= f64)
-findLast(array, # <= i)
 findLast(array, # <= i64)
 findLast(array, # == #)
 findLast(array, # == 0.5)
-findLast(array, # == f64)
-findLast(array, # == i64)
+findLast(array, # == nil)
 findLast(array, # > #)
 findLast(array, # > 0.5)
+findLast(array, # > 1)
 findLast(array, # > i)
 findLast(array, # > i32)
 findLast(array, # > i64)
 findLast(array, # >= #)
 findLast(array, # >= 0.5)
-findLast(array, # >= f64)
-findLast(array, # >= i)
+findLast(array, # >= 1)
+findLast(array, # >= f32)
 findLast(array, # >= i32)
-findLast(array, # not in array)
-findLast(array, 0.5 != #)
-findLast(array, 0.5 != 0.5)
-findLast(array, 0.5 != i)
-findLast(array, 0.5 < #)
-findLast(array, 0.5 < i64)
 findLast(array, 0.5 <= #)
-findLast(array, 0.5 == #)
-findLast(array, 0.5 > 0.5)
+findLast(array, 0.5 <= i64)
+findLast(array, 0.5 > #)
+findLast(array, 0.5 >= #)
 findLast(array, 0.5 >= 1)
-findLast(array, 0.5 >= f64)
 findLast(array, 1 != #)
-findLast(array, 1 != i64)
-findLast(array, 1 < #)
 findLast(array, 1 <= #)
-findLast(array, 1 <= 0.5)
-findLast(array, 1 <= f32)
 findLast(array, 1 == #)
-findLast(array, 1 == nil)
-findLast(array, 1 > #)
-findLast(array, 1 >= #)
-findLast(array, 1 >= 1)
-findLast(array, add != greet)
-findLast(array, array == array)
-findLast(array, div != score)
-findLast(array, f32 != nil)
-findLast(array, f32 < #)
 findLast(array, f32 >= #)
-findLast(array, f32 >= 1)
-findLast(array, f64 != i)
-findLast(array, f64 < i64)
-findLast(array, f64 >= #)
-findLast(array, foo != nil)
-findLast(array, half == nil)
-findLast(array, i != i32)
+findLast(array, f64 != #)
+findLast(array, f64 != nil)
+findLast(array, f64 <= #)
+findLast(array, f64 <= 1)
+findLast(array, f64 == #)
+findLast(array, f64 == nil)
+findLast(array, f64 >= 1)
+findLast(array, f64 >= i64)
+findLast(array, false != true)
+findLast(array, false or true)
+findLast(array, greet != nil)
 findLast(array, i < #)
-findLast(array, i <= #)
-findLast(array, i >= #)
-findLast(array, i32 != #)
-findLast(array, i32 <= f32)
-findLast(array, i32 == 1)
+findLast(array, i == i32)
+findLast(array, i > #)
+findLast(array, i >= 0.5)
+findLast(array, i32 < #)
+findLast(array, i32 == 0.5)
 findLast(array, i32 > #)
 findLast(array, i32 >= #)
-findLast(array, i32 >= 0.5)
+findLast(array, i32 >= i32)
 findLast(array, i64 != #)
-findLast(array, i64 != 1)
 findLast(array, i64 < #)
 findLast(array, i64 <= #)
-findLast(array, i64 <= 0.5)
 findLast(array, i64 == #)
-findLast(array, i64 == nil)
-findLast(array, i64 >= #)
-findLast(array, i64 >= i32)
-findLast(array, nil != #)
-findLast(array, nil != nil)
-findLast(array, nil == #)
-findLast(array, nil == nil)
+findLast(array, i64 > 0.5)
+findLast(array, list != nil)
+findLast(array, nil != array)
+findLast(array, not (array == array))
 findLast(array, not false)
-findLast(array, not true)
+findLast(array, not ok)
+findLast(array, ok and true)
 findLast(array, ok)
-findLast(array, ok) < f64
-findLast(array, true) + i
-findLast(array, true) + i32
-findLast(array, true) <= f64
-findLast(array, true) > i
-findLast(i .. 1, # > f32)
-findLast(i32 .. 1, # >= #)
-findLast(i32 .. i32, ok)
-findLast(i64 .. 1, f32 <= #)
-findLast(list, !true)
-findLast(list, "bar" in #)
-findLast(list, "bar" not contains "bar")
-findLast(list, "bar" not in #)
-findLast(list, "bar" not matches "bar")
-findLast(list, "foo" == "foo")
-findLast(list, "foo" > "foo")
+findLast(array, ok) == i64
+findLast(array, reduce(list, ok))
+findLast(array, score != nil)
+findLast(array, true) % i64
+findLast(groupBy(array, #).i32, #)
+findLast(groupBy(list, "bar").div, #?.f32?.half())
+findLast(groupBy(list, #)[ok], .ok)
+findLast(groupBy(list, f64).foo, .f32(#, #)?.Qux(#?.i64(add, nil)))
+findLast(i .. 1, # < #)
+findLast(i .. i32, # != i64)
+findLast(i .. i32, ok)
+findLast(i32 .. i64, # >= i)
+findLast(i64 .. 1, # < #)
+findLast(list, !false)
+findLast(list, !ok)
 findLast(list, "foo" in #)
-findLast(list, "foo" not in #)
 findLast(list, # != #)
+findLast(list, # != nil)
 findLast(list, # == #)
 findLast(list, # == foo)
-findLast(list, # == nil)
+findLast(list, # in list)
 findLast(list, # not in list)
-findLast(list, 0.5 == nil)
-findLast(list, 0.5 > f32)
-findLast(list, 1 != 0.5)
-findLast(list, 1 != 1)
-findLast(list, 1 <= i)
-findLast(list, 1 > 1)
-findLast(list, 1 > i)
-findLast(list, 1 >= 0.5)
-findLast(list, 1 >= 1)
-findLast(list, add == nil)
-findLast(list, all(list, false))
-findLast(list, f32 < f64)
+findLast(list, 0.5 != i64)
+findLast(list, 0.5 <= 1)
+findLast(list, 0.5 == i64)
+findLast(list, 1 != f32)
+findLast(list, 1 != nil)
+findLast(list, 1 <= 1)
+findLast(list, 1 > f32)
+findLast(list, 1 >= f64)
+findLast(list, f32 != i)
+findLast(list, f32 > f32)
+findLast(list, f32 >= 1)
+findLast(list, f64 <= i)
+findLast(list, f64 in array)
 findLast(list, false)?.Bar
-findLast(list, foo != #)?.Bar
-findLast(list, foo == #)
-findLast(list, greet == half)
-findLast(list, i != 1)
-findLast(list, i != i64)
-findLast(list, i >= f32)
-findLast(list, i32 == 1)
-findLast(list, i64 <= 0.5)
-findLast(list, i64 <= i)
-findLast(list, i64 == i32)
-findLast(list, i64 > 0.5)
+findLast(list, foo != #)
+findLast(list, foo in list)
+findLast(list, i != i)
+findLast(list, i <= 1)
+findLast(list, i <= i)
+findLast(list, i == i32)
+findLast(list, i >= i)
+findLast(list, i32 != f32)
+findLast(list, i64 > f32)
 findLast(list, i64 > i)
-findLast(list, i64 >= i32)
-findLast(list, nil != "bar")
+findLast(list, i64 >= 1)
 findLast(list, nil != #)
-findLast(list, nil != add)
-findLast(list, nil != false)
-findLast(list, nil != foo)
-findLast(list, nil != nil)
-findLast(list, nil != ok)
-findLast(list, nil == #)
-findLast(list, nil == i32)
-findLast(list, nil == i64)
-findLast(list, nil == list)
-findLast(list, nil == nil)
-findLast(list, not ok)
-findLast(list, ok ? ok : nil)
+findLast(list, nil not in array)
+findLast(list, nil not in list)
+findLast(list, none(array, ok))
+findLast(list, not false)
+findLast(list, not true)
+findLast(list, ok or true)
 findLast(list, ok)
+findLast(list, ok) not in list
 findLast(list, ok).Bar
 findLast(list, ok).Qux
 findLast(list, ok).String
-findLast(list, ok).String()
 findLast(list, ok)?.Bar
 findLast(list, ok)?.Qux
 findLast(list, ok)?.String
-findLast(list, one(list, true))
-findLast(list, true != nil)
+findLast(list, true or ok)
 findLast(list, true).Bar
 findLast(list, true).Qux
 findLast(list, true).String
 findLast(list, true)?.Bar
 findLast(list, true)?.Qux
 findLast(list, true)?.String
-findLast(map(array, #), # > f32)
-findLast(map(array, #), # >= #)
+findLast(map(array, #), # < #)
+findLast(map(array, #), # < i32)
+findLast(map(array, #), # <= 1)
+findLast(map(array, #), # == f64)
+findLast(map(array, #), 0.5 != 0.5)
 findLast(map(array, #), i32 == #)
 findLast(map(array, #), ok)
-findLast(map(array, f64), # <= #)
-findLast(map(array, i), # <= #)
-findLast(map(array, ok), #)
-findLast(map(array, ok), not #)
-findLast(map(array, true), #)
-findLast(map(list, #), # != #)
-findLast(map(list, array), # == #)
-findLast(map(list, i), # >= #)
-findLast(map(list, list), ok)
-findLast(map(list, score), 0.5 > f32)
-findLast(ok ? array : div, # >= #)
-findLast(sort(array), # && false)
-findLastIndex([i32], # >= 0.5)
-findLastIndex(array, !false)
-findLastIndex(array, !ok)
-findLastIndex(array, !true)
-findLastIndex(array, "bar" != "bar")
+findLast(map(array, f64 * #), # + # > f32)
+findLast(map(array, score), ok)
+findLast(map(list, #), # == #)
+findLast(map(list, #), greet == nil)
+findLast(map(list, #), ok)
+findLast(map(list, ok), # ? # : #)
+findLastIndex(1 .. 1, i64 < #)
+findLastIndex([i64, half], ok)
+findLastIndex(array, "bar" not matches "foo")
+findLastIndex(array, "bar" startsWith "foo")
+findLastIndex(array, "foo" == nil)
+findLastIndex(array, "foo" >= "foo")
+findLastIndex(array, "foo" contains "foo")
 findLastIndex(array, # != #)
-findLastIndex(array, # != 0.5)
+findLastIndex(array, # != 1)
+findLastIndex(array, # != f32)
+findLastIndex(array, # != f64)
+findLastIndex(array, # != i32)
 findLastIndex(array, # != i64)
 findLastIndex(array, # != nil)
-findLastIndex(array, # / f32 == #)
-findLastIndex(array, # < # ** i32)
 findLastIndex(array, # < #)
-findLastIndex(array, # < 0.5)
 findLastIndex(array, # < 1)
-findLastIndex(array, # < f32)
 findLastIndex(array, # < f64)
 findLastIndex(array, # < i)
 findLastIndex(array, # < i64)
 findLastIndex(array, # <= #)
 findLastIndex(array, # <= 0.5)
-findLastIndex(array, # <= 1)
-findLastIndex(array, # <= f32)
-findLastIndex(array, # <= f64)
-findLastIndex(array, # <= i)
-findLastIndex(array, # <= i32)
 findLastIndex(array, # <= i64)
 findLastIndex(array, # == #)
 findLastIndex(array, # == 0.5)
 findLastIndex(array, # == 1)
-findLastIndex(array, # == i32)
+findLastIndex(array, # == f64)
+findLastIndex(array, # == i64)
 findLastIndex(array, # == nil)
 findLastIndex(array, # > #)
 findLastIndex(array, # > 0.5)
-findLastIndex(array, # > 1)
+findLastIndex(array, # > f32)
+findLastIndex(array, # > f64)
 findLastIndex(array, # > i)
-findLastIndex(array, # > i64)
 findLastIndex(array, # >= #)
+findLastIndex(array, # >= 0.5)
 findLastIndex(array, # >= 1)
-findLastIndex(array, # >= f64)
-findLastIndex(array, # in array)
+findLastIndex(array, # >= f32)
+findLastIndex(array, # >= i32)
+findLastIndex(array, # ^ # >= #)
 findLastIndex(array, # not in array)
 findLastIndex(array, 0.5 != #)
-findLastIndex(array, 0.5 != 0.5)
+findLastIndex(array, 0.5 != i64)
 findLastIndex(array, 0.5 < #)
-findLastIndex(array, 0.5 < i)
+findLastIndex(array, 0.5 < i32)
 findLastIndex(array, 0.5 <= #)
-findLastIndex(array, 0.5 <= 0.5)
-findLastIndex(array, 0.5 == #)
 findLastIndex(array, 0.5 > #)
-findLastIndex(array, 0.5 > i)
-findLastIndex(array, 0.5 >= #)
-findLastIndex(array, 0.5 >= f32)
+findLastIndex(array, 0.5 >= 0.5)
+findLastIndex(array, 0.5 >= f64)
 findLastIndex(array, 1 != #)
-findLastIndex(array, 1 < #)
 findLastIndex(array, 1 <= #)
-findLastIndex(array, 1 <= i)
-findLastIndex(array, 1 <= i64)
 findLastIndex(array, 1 == #)
-findLastIndex(array, 1 > #)
-findLastIndex(array, 1 > 1)
-findLastIndex(array, 1 >= #)
-findLastIndex(array, 1 in array)
-findLastIndex(array, add != add)
-findLastIndex(array, any(list, false))
+findLastIndex(array, 1 == f64)
+findLastIndex(array, 1 >= i32)
+findLastIndex(array, array == nil)
 findLastIndex(array, f32 != #)
+findLastIndex(array, f32 != f32)
 findLastIndex(array, f32 < #)
-findLastIndex(array, f32 <= f64)
-findLastIndex(array, f32 == f64)
+findLastIndex(array, f32 == #)
+findLastIndex(array, f32 == nil)
 findLastIndex(array, f32 > #)
-findLastIndex(array, f32 >= f64)
 findLastIndex(array, f64 != #)
 findLastIndex(array, f64 < #)
+findLastIndex(array, f64 <= #)
+findLastIndex(array, f64 <= i32)
 findLastIndex(array, f64 == #)
-findLastIndex(array, f64 > i)
-findLastIndex(array, f64 >= #)
-findLastIndex(array, i == #)
-findLastIndex(array, i > #)
-findLastIndex(array, i > 1)
-findLastIndex(array, i >= #)
-findLastIndex(array, i32 != #)
-findLastIndex(array, i32 < #)
-findLastIndex(array, i32 <= 0.5)
-findLastIndex(array, i32 == #)
-findLastIndex(array, i32 == i32)
-findLastIndex(array, i32 > #)
-findLastIndex(array, i64 != #)
-findLastIndex(array, i64 != f32)
-findLastIndex(array, i64 >= #)
-findLastIndex(array, list != nil)
-findLastIndex(array, nil != "foo")
+findLastIndex(array, f64 == 0.5)
+findLastIndex(array, f64 > #)
+findLastIndex(array, false ? # : false)
+findLastIndex(array, foo != foo)
+findLastIndex(array, greet == greet)
+findLastIndex(array, i - # >= #)
+findLastIndex(array, i < #)
+findLastIndex(array, i <= #)
+findLastIndex(array, i > 0.5)
+findLastIndex(array, i32 <= #)
+findLastIndex(array, i32 <= 1)
+findLastIndex(array, i32 <= f32)
+findLastIndex(array, i32 > 0.5)
+findLastIndex(array, i32 >= #)
+findLastIndex(array, i64 <= # + #)
+findLastIndex(array, i64 > #)
+findLastIndex(array, min(1, #) <= i32 + #)
 findLastIndex(array, nil != #)
-findLastIndex(array, nil != 0.5)
-findLastIndex(array, nil != foo)
-findLastIndex(array, nil != nil)
+findLastIndex(array, nil != add)
+findLastIndex(array, nil != i32)
 findLastIndex(array, nil == #)
-findLastIndex(array, nil == i)
-findLastIndex(array, nil not in list)
-findLastIndex(array, none(array, true))
-findLastIndex(array, not (# != #))
-findLastIndex(array, not false)
+findLastIndex(array, not (i32 != 0.5))
+findLastIndex(array, not ok)
+findLastIndex(array, ok && true)
 findLastIndex(array, ok)
-findLastIndex(array, ok) * f64
-findLastIndex(array, ok) / i64
-findLastIndex(array, ok) <= i64
-findLastIndex(array, ok) ^ f32
-findLastIndex(array, true ? ok : 1)
+findLastIndex(array, ok) % i64
+findLastIndex(array, ok) + f64
+findLastIndex(array, one(list, ok))
+findLastIndex(array, score == nil)
+findLastIndex(array, true == false)
 findLastIndex(array, true) / f32
-findLastIndex(array, true) <= i64
-findLastIndex(array, true) > f64
-findLastIndex(false ? i : "bar", ok)
-findLastIndex(filter(list, true), ok)
-findLastIndex(i .. i32, # == 1)
-findLastIndex(i32 .. i, ok)
-findLastIndex(i32 .. i64, f64 == nil)
-findLastIndex(i64 .. 1, # != nil)
-findLastIndex(i64 .. 1, add == nil)
+findLastIndex(array, true) not in array
+findLastIndex(filter(array, false), ok)
+findLastIndex(groupBy(list, #).ok, #)
+findLastIndex(groupBy(list, 0.5).Bar, #?.String endsWith .f32(list))
+findLastIndex(i32 .. i32, ok)
+findLastIndex(i64 .. 1, ok)
+findLastIndex(list, !(nil != #))
+findLastIndex(list, !false)
 findLastIndex(list, !ok)
 findLastIndex(list, !true)
 findLastIndex(list, "bar" in #)
-findLastIndex(list, "foo" matches "bar")
+findLastIndex(list, "bar" matches "foo")
+findLastIndex(list, "bar" not endsWith "foo")
+findLastIndex(list, "bar" not matches "bar")
+findLastIndex(list, "foo" <= "bar")
+findLastIndex(list, "foo" not in #)
 findLastIndex(list, # != #)
 findLastIndex(list, # != foo)
-findLastIndex(list, # != nil)
 findLastIndex(list, # == #)
+findLastIndex(list, # == foo)
 findLastIndex(list, # == nil)
 findLastIndex(list, # in list)
-findLastIndex(list, 0.5 != i)
-findLastIndex(list, 0.5 <= 0.5)
-findLastIndex(list, 0.5 <= f32)
-findLastIndex(list, 1 != 0.5)
-findLastIndex(list, 1 != f64)
-findLastIndex(list, 1 != i64)
-findLastIndex(list, 1 < i32)
-findLastIndex(list, 1 <= f32)
-findLastIndex(list, 1 <= i)
-findLastIndex(list, array != list)
+findLastIndex(list, # not in list)
+findLastIndex(list, 1 != f32)
+findLastIndex(list, 1 != nil)
+findLastIndex(list, 1 > 1)
+findLastIndex(list, 1 >= 0.5)
 findLastIndex(list, array != nil)
-findLastIndex(list, array == list)
-findLastIndex(list, div == add)
-findLastIndex(list, div == score)
-findLastIndex(list, f32 != 0.5)
-findLastIndex(list, f32 < f64)
-findLastIndex(list, f32 < i32)
-findLastIndex(list, f32 <= i64)
-findLastIndex(list, f32 == i32)
-findLastIndex(list, f32 > f32)
-findLastIndex(list, f64 <= 1)
-findLastIndex(list, f64 == f64)
-findLastIndex(list, false == false)
-findLastIndex(list, false and false)
-findLastIndex(list, false and ok)
-findLastIndex(list, foo != #)
-findLastIndex(list, foo == foo)
-findLastIndex(list, greet != half)
-findLastIndex(list, greet == nil)
-findLastIndex(list, half != nil)
-findLastIndex(list, i < i64)
-findLastIndex(list, i <= i)
-findLastIndex(list, i32 != nil)
-findLastIndex(list, i32 < f64)
-findLastIndex(list, i32 <= i32)
-findLastIndex(list, i32 >= 0.5)
-findLastIndex(list, i32 >= i)
-findLastIndex(list, i64 < f64)
-findLastIndex(list, i64 == f32)
-findLastIndex(list, i64 >= i)
+findLastIndex(list, div != nil)
+findLastIndex(list, f32 != 1)
+findLastIndex(list, f32 != f64)
+findLastIndex(list, f64 > 0.5)
+findLastIndex(list, foo == #)
+findLastIndex(list, i <= 1)
+findLastIndex(list, i32 > 1)
+findLastIndex(list, i32 > f32)
+findLastIndex(list, i64 == i64)
+findLastIndex(list, i64 >= 0.5)
 findLastIndex(list, i64 not in array)
+findLastIndex(list, nil != "bar")
 findLastIndex(list, nil != #)
+findLastIndex(list, nil != f64)
 findLastIndex(list, nil == #)
-findLastIndex(list, none(array, ok))
-findLastIndex(list, not ok)
+findLastIndex(list, nil == 1)
+findLastIndex(list, nil == half)
+findLastIndex(list, not false)
 findLastIndex(list, not true)
-findLastIndex(list, ok != nil)
+findLastIndex(list, ok ? ok : 0.5)
+findLastIndex(list, ok and false)
 findLastIndex(list, ok)
-findLastIndex(list, ok) ** f32
-findLastIndex(list, ok) ** f64
-findLastIndex(list, ok) - i
-findLastIndex(list, ok) >= i64
-findLastIndex(list, true == nil)
-findLastIndex(list, true) ** i64
-findLastIndex(list, true) + i
-findLastIndex(list, true) .. i64
-findLastIndex(list, true) < i
-findLastIndex(list, true) > f32
-findLastIndex(list, true) >= f32
-findLastIndex(list, true) in array
-findLastIndex(map(array, "foo"), # == #)
-findLastIndex(map(array, #), i < #)
-findLastIndex(map(array, #), nil != half)
+findLastIndex(list, ok) != i64
+findLastIndex(list, ok) > f32
+findLastIndex(list, ok) > i64
+findLastIndex(list, one(array, true))
+findLastIndex(list, true && ok)
+findLastIndex(list, true) * i32
+findLastIndex(list, true) - i32
+findLastIndex(list, true) < i64
+findLastIndex(list, true) > i64
+findLastIndex(list, true) ^ f64
+findLastIndex(map(array, "bar"), # not endsWith #)
+findLastIndex(map(array, #), # < f64)
+findLastIndex(map(array, #), # <= #)
 findLastIndex(map(array, #), ok)
-findLastIndex(map(array, 0.5), ok)
-findLastIndex(map(array, array), 1 != i)
-findLastIndex(map(array, false), #)
-findLastIndex(map(array, true), #)
-findLastIndex(map(list, #), !ok)
-findLastIndex(map(list, #), 0.5 < f32)
-findLastIndex(map(list, 0.5), # <= #)
-findLastIndex(map(list, f32), # == #)
-findLastIndex(map(list, f32), # >= #)
-findLastIndex(map(list, f32), ok)
+findLastIndex(map(array, div), 0.5 <= 0.5)
+findLastIndex(map(array, f32), nil == nil)
+findLastIndex(map(array, list), ok)
+findLastIndex(map(array, ok), # and #)
+findLastIndex(map(list, "bar"), # >= #)
+findLastIndex(map(list, #), !true)
+findLastIndex(map(list, #), nil == 0.5)
 findLastIndex(map(list, false), #)
-findLastIndex(map(list, half), ok)
-findLastIndex(map(list, ok), # or #)
-findLastIndex(map(list, ok), #)
-findLastIndex(sort(array), ok)
-first(1 .. i)
-first(1 .. i32)
+findLastIndex(map(list, foo), ok)
+findLastIndex(map(list, i32), # >= #)
+findLastIndex(map(list, i64), ok)
+findLastIndex(ok ? "bar" : add, not false)
+findLastIndex(true ? "foo" : 1, # and false)
+first(1 .. 1)
+first(1 .. i64)
 first([f32])
-first([f64])
-first([false, list])
-first([i64, nil])
-first([list, i32])
-first([not false])
+first([foo])
+first([ok])
 first(array)
 first(array) * i
-first(array) ** i32
-first(array) ** i64
-first(array) + i32
-first(array) / 1 * 0.5
-first(array) <= i32
-first(array) <= i64
+first(array) * i64
+first(array) + f32
+first(array) <= i
+first(array) == f32
+first(array) == f64
 first(array) == i64
-first(array) > i32
+first(array) > 0.5 ** i
 first(array) > i64
-first(array) in array
-first(false ? f64 : true)
-first(false ? greet : i)
-first(filter(array, false))
-first(filter(list, ok))
-first(i .. 1)
+first(array) ^ f64
+first(array[1:1])
+first(false ? foo : 1)
+first(false ? greet : foo)
+first(get(groupBy(array, #), i))
+first(groupBy(array, #).greet)
+first(groupBy(list, #)?.div)
 first(i .. i)
-first(i .. i32)
-first(i32 .. 1)
-first(i32 .. i)
-first(i32 .. i64)
 first(i64 .. i32)
+first(i64 .. i64)
 first(list)
 first(list) not in list
 first(list).Bar
@@ -5703,44 +6355,33 @@ first(list)?.Bar
 first(list)?.Qux
 first(list)?.String
 first(list)?.String()
-first(map(array, "bar"))
 first(map(array, #))
 first(map(array, 0.5))
 first(map(array, 1))
 first(map(array, add))
-first(map(array, f32))
-first(map(array, f64))
-first(map(array, foo))
-first(map(array, greet))
+first(map(array, array))
+first(map(array, div))
 first(map(array, half))
 first(map(array, i))
-first(map(array, list))
+first(map(array, i32))
+first(map(array, i64))
 first(map(array, ok))
-first(map(array, score))
 first(map(list, #))
 first(map(list, 0.5))
-first(map(list, add))
-first(map(list, array))
-first(map(list, div))
 first(map(list, f32))
-first(map(list, f64))
-first(map(list, i32))
+first(map(list, greet))
+first(map(list, i))
 first(map(list, list))
 first(map(list, score))
-first(ok ? "bar" : 0.5)
-first(ok ? 1 : "foo")
-first(ok ? add : f32)
-first(ok ? array : "bar")
-first(ok ? list : nil)
-first(ok ? ok : array)
-first(ok ? ok : foo)
-first(ok ? ok : score)
+first(ok ? 0.5 : false)
+first(ok ? array : add)
+first(ok ? greet : i64)
+first(ok ? list : ok)
+first(reduce(list, array))
 first(sort(array))
-first(true ? 0.5 : i64)
-first(true ? add : ok)
-first(true ? array : false)
-first(true ? ok : div)
-float(-(1 / i32))
+first(true ? f32 : div)
+first(true ? greet : div)
+first(true ? score : div)
 float(-0.5)
 float(-1)
 float(-f32)
@@ -5749,184 +6390,149 @@ float(-i)
 float(-i32)
 float(-i64)
 float(0.5 * 0.5)
+float(0.5 * 1)
 float(0.5 * f32)
-float(0.5 * i)
-float(0.5 * i32)
 float(0.5 * i64)
 float(0.5 ** 0.5)
-float(0.5 ** 1)
 float(0.5 ** f32)
-float(0.5 ** i32)
 float(0.5 + 1)
-float(0.5 + f32)
-float(0.5 + i)
+float(0.5 + i32)
 float(0.5 + i64)
 float(0.5 - 0.5)
 float(0.5 - 1)
-float(0.5 - f32)
-float(0.5 - i)
-float(0.5 - i32)
 float(0.5 - i64)
 float(0.5 / 0.5)
-float(0.5 / 1)
-float(0.5 / f32)
-float(0.5 / f64)
-float(0.5 / i)
-float(0.5 ^ 0.5)
+float(0.5 / i32)
+float(0.5 / i64)
 float(0.5 ^ 1)
-float(0.5 ^ f64)
-float(0.5 ^ i32)
-float(0.5 ^ i64)
+float(0.5 ^ i)
+float(0.5) != f32
 float(0.5) != i32
-float(0.5) ** (1 % 1)
-float(0.5) + 0.5 - f64
-float(0.5) + f32
-float(0.5) + i32
-float(0.5) - -f32
-float(0.5) - f32
+float(0.5) * f32
+float(0.5) * i32
+float(0.5) * i64
+float(0.5) ** f64
+float(0.5) ** i
+float(0.5) ** i32
+float(0.5) - i
+float(0.5) - i64
 float(0.5) / f32
-float(0.5) < i32
-float(0.5) >= i32
-float(1 % 1)
-float(1 % i)
-float(1 % i32)
+float(0.5) / f64
+float(0.5) / i32
+float(0.5) == i32 * 0.5
+float(0.5) ^ i64
+float(0.5) in array
 float(1 % i64)
 float(1 * 0.5)
-float(1 * 1)
+float(1 * f32)
 float(1 * i)
-float(1 * i32)
 float(1 * i64)
 float(1 ** 0.5)
+float(1 ** 1)
+float(1 ** f64)
 float(1 ** i)
-float(1 + 0.5)
-float(1 + 1)
-float(1 + f32)
 float(1 + f64)
-float(1 + i)
+float(1 + i32)
 float(1 - 0.5)
-float(1 - 1)
-float(1 - f32)
-float(1 - i)
 float(1 / 0.5)
-float(1 / 1)
-float(1 / f64)
-float(1 / i)
-float(1 ^ 1)
-float(1 ^ f32)
 float(1 ^ f64)
-float(1 ^ i)
-float(1 ^ i32)
-float(1 ^ i64)
-float(1) != abs(f32)
-float(1) != {"foo": i32}?.add
+float(1) * f32
+float(1) * i64
+float(1) ** i
 float(1) ** i64
-float(1) - i64
-float(1) / i
-float(1) / i64
-float(1) < i32
+float(1) - f64
 float(1) <= i64
-float(1) == int(0.5)
-float(1) > i
-float(1) >= f32
-float(1) >= i - i
-float(abs(0.5))
-float(abs(1))
+float(1) == i64
+float(1) > -0.5
+float(1) > i64
+float(1) >= f64
+float(1) >= i
 float(abs(f32))
+float(abs(f64))
 float(abs(i))
 float(abs(i32))
-float(abs(i64))
-float(add(i, 1))
-float(array[1])
+float(add(1, 1))
 float(array[i32])
 float(array[i64])
 float(array[i])
-float(count(array, true))
-float(count(list, false) * (i - 1))
-float(count(list, false))
-float(div(1, i))
-float(div(i, 1))
-float(f32 * 0.5)
-float(f32 * f32)
+float(bitnot(1))
+float(bitnot(i))
+float(bitnot(i32))
+float(bitnot(i64))
+float(ceil(0.5))
+float(ceil(f32))
+float(ceil(f64))
+float(ceil(i32))
+float(ceil(i64))
+float(count(array, false))
+float(count(array, ok))
+float(count(list, i32 == 0.5))
+float(f32 * f64)
+float(f32 * i)
 float(f32 * i32)
-float(f32 * i64)
-float(f32 ** 0.5)
 float(f32 ** 1)
+float(f32 ** f32)
 float(f32 ** i)
 float(f32 ** i64)
 float(f32 + 0.5)
 float(f32 + 1)
-float(f32 + f32)
+float(f32 + f64)
 float(f32 + i32)
+float(f32 + i64)
 float(f32 - 0.5)
-float(f32 - 1)
 float(f32 - f64)
-float(f32 - i)
+float(f32 - i64)
 float(f32 / 0.5)
 float(f32 / 1)
-float(f32 / f32)
 float(f32 / i)
-float(f32 / i64)
 float(f32 ^ 0.5)
+float(f32 ^ 1)
 float(f32 ^ f32)
-float(f32 ^ f64)
-float(f32 ^ i64)
+float(f32 ^ i)
+float(f32 ^ i32)
 float(f32)
-float(f32) * f32
-float(f32) + f32
-float(f32) - f32
-float(f32) - f64
-float(f32) - i64
-float(f32) / f64
 float(f32) < i32
 float(f32) <= f32
-float(f32) >= f32
-float(f32) >= f32 ** f32
+float(f32) <= f64 / f32
+float(f32) <= i
+float(f32) > i
+float(f32) >= i64
 float(f32) ^ f64
-float(f32) ^ i32
+float(f32) ^ i64
 float(f64 * 0.5)
+float(f64 * 1)
 float(f64 * f32)
-float(f64 * i)
+float(f64 * f64)
 float(f64 * i32)
-float(f64 ** 1)
 float(f64 ** f32)
-float(f64 + 0.5)
 float(f64 + 1)
 float(f64 + i)
-float(f64 - 0.5)
+float(f64 + i32)
+float(f64 - 1)
 float(f64 - i)
-float(f64 - i32)
-float(f64 - i32) / i
-float(f64 / -i32)
+float(f64 / 0.5)
 float(f64 / 1)
-float(f64 / f32)
-float(f64 / i32)
-float(f64 ^ 0.5)
-float(f64 ^ 1)
+float(f64 / i64)
 float(f64 ^ f32)
-float(f64 ^ f64)
 float(f64)
-float(f64) != int(i32)
-float(f64) * i32
-float(f64) / f32
-float(f64) / f64
-float(f64) / i64
-float(f64) < i
-float(f64) < i32
-float(f64) <= f32
-float(f64) <= i64
-float(f64) == i32
-float(f64) > i32
-float(f64) >= f64
+float(f64) * f32
+float(f64) * i
+float(f64) / -i32
+float(f64) / i
+float(f64) == f64
+float(f64) > f64
+float(f64) > i64
+float(f64) >= f32
 float(f64) >= i
-float(f64) >= i32
-float(f64) ^ i
-float(false ? div : i32)
-float(false ? f32 : 0.5)
+float(f64) >= i64
+float(f64) ^ i64
+float(false ? f64 : 0.5)
+float(false ? half : f64)
+float(false ? list : f64)
 float(find(array, ok))
-float(find(array, true))
-float(findIndex(list, true))
-float(findLast(array, ok))
-float(findLast(array, true))
+float(findIndex(array, ok))
+float(findLastIndex(array, ok))
+float(findLastIndex(list, true))
 float(first(array))
 float(float(0.5))
 float(float(1))
@@ -5934,351 +6540,619 @@ float(float(f32))
 float(float(f64))
 float(float(i))
 float(float(i32))
-float(float(i64))
+float(floor(0.5))
+float(floor(1))
+float(floor(f32))
+float(floor(f64))
+float(floor(i32))
+float(floor(i64))
 float(get(array, 1))
 float(get(array, i))
-float(get(array, i64))
-float(half(-f64))
 float(half(0.5))
+float(half(1))
 float(half(f64))
-float(i % 1)
+float(i % i32)
 float(i * 0.5)
-float(i * 1)
 float(i * f64)
-float(i * i)
-float(i * i32 * i32)
-float(i * i32)
 float(i * i64)
-float(i ** 1)
-float(i ** f64)
+float(i ** f32)
 float(i ** i32)
 float(i + 0.5)
-float(i + f64)
+float(i + 1)
 float(i + i64)
-float(i - 0.5)
 float(i - 1)
-float(i - findIndex(array, true))
+float(i - f64)
+float(i / 0.5)
 float(i / 1)
-float(i / f64)
-float(i / i64)
-float(i ^ f32)
-float(i ^ f64)
-float(i ^ i64)
+float(i ^ 0.5)
+float(i ^ i32)
 float(i)
-float(i) != f32
-float(i) != i32
-float(i) != i64
-float(i) ** f32
-float(i) / i32
-float(i) < f32
-float(i) < i64
-float(i) <= f32
-float(i) == i32
+float(i) != 1 ? nil : foo
+float(i) != f64
+float(i) + f32
+float(i) + f64
+float(i) < i
+float(i) == f32
+float(i) == i
 float(i) > f64
-float(i) ^ f64
-float(i) ^ i64
-float(i32 % 1)
 float(i32 % i)
-float(i32 * 1)
-float(i32 * f32)
-float(i32 ** 0.5)
-float(i32 ** f64)
-float(i32 ** i32)
-float(i32 ** i64)
-float(i32 + 1)
-float(i32 + f32)
-float(i32 - 0.5)
-float(i32 - f64)
-float(i32 - i)
-float(i32 - i32)
-float(i32 / 0.5)
+float(i32 % i64)
+float(i32 * f64)
+float(i32 * i32)
+float(i32 ** 1)
+float(i32 + f64)
+float(i32 + i64)
 float(i32 / 1)
-float(i32 / 1) > f64
-float(i32 / i)
-float(i32 ^ 1)
+float(i32 / f32)
+float(i32 / i32)
 float(i32 ^ f64)
-float(i32 ^ i)
+float(i32 ^ i32)
 float(i32)
 float(i32) != f64
-float(i32) * i64
-float(i32) + i
-float(i32) + i64
-float(i32) - i64
-float(i32) / i
-float(i32) / i32
-float(i32) < -0.5
-float(i32) == f32
-float(i32) == i32
-float(i32) > f32
+float(i32) ** f32
+float(i32) ** i
 float(i32) > i32
-float(i32) >= f32
-float(i32) >= f64
-float(i32) ^ f32
-float(i32) ^ f64
-float(i32) ^ i32
-float(i64 % i)
-float(i64 % i32)
-float(i64 * 0.5)
-float(i64 * 1)
-float(i64 ** f64)
-float(i64 ** i64)
-float(i64 + 0.5)
-float(i64 + f64)
+float(i32) >= i
+float(i64 % i64)
+float(i64 * i64)
+float(i64 ** 1)
+float(i64 + f32)
+float(i64 + i)
+float(i64 - 0.5)
 float(i64 - 1)
 float(i64 - f32)
-float(i64 - f64)
-float(i64 - i32)
-float(i64 - i64)
-float(i64 / 0.5)
 float(i64 / 1)
-float(i64 / f32)
-float(i64 ^ f64)
+float(i64 ^ f32)
 float(i64)
-float(i64) ** i
+float(i64) != i
+float(i64) ** max(f64)
+float(i64) + i32
+float(i64) - 0.5 ^ f32
+float(i64) - f64
 float(i64) / i32
-float(i64) > f64 ^ f32
-float(i64) >= i
-float(i64) >= i64
+float(i64) < i32
+float(i64) == i
+float(i64) == i64
+float(i64) > i
+float(i64) ^ f32
 float(int(0.5))
 float(int(1))
 float(int(f32))
-float(int(f64))
 float(int(i))
 float(int(i32))
-float(int(i64))
+float(last(array))
 float(len("bar"))
-float(len("foo"))
 float(len(array))
 float(len(list))
 float(max(0.5))
-float(max(0.5, i32))
+float(max(0.5, i64))
 float(max(1))
-float(max(1, i))
-float(max(1, i64))
+float(max(1, 1))
+float(max(f32))
 float(max(f64))
 float(max(i))
 float(max(i32))
 float(max(i64))
-float(min(0.5))
+float(mean(array))
 float(min(1))
-float(min(f32))
 float(min(f64))
-float(min(i))
+float(min(f64, i64))
 float(min(i32))
 float(min(i64))
-float(ok ? f64 : half)
-float(ok ? i : greet)
+float(ok ? 0.5 : foo)
+float(ok ? 0.5 : list)
+float(reduce(array, #))
+float(reduce(array, 0.5))
+float(reduce(array, f64))
+float(reduce(array, i32))
+float(reduce(list, i64))
+float(round(0.5))
+float(round(1))
+float(round(i32))
+float(round(i64))
 float(score(1))
+float(score(1, 1))
 float(score(i))
-float(score(i, i)) <= f32
-float(score(score(i)))
 float(string(0.5))
 float(string(1))
-float(string(f32))
-float(string(f64))
+float(string(f64 - 0.5))
 float(string(i))
+float(string(i32))
 float(string(i64))
+float(sum(array))
 float(toJSON(0.5))
 float(toJSON(1))
 float(toJSON(f32))
 float(toJSON(f64))
-float(toJSON(i))
 float(toJSON(i32))
-float(true ? 1 : div)
-float(true ? 1 : i64)
-float(true ? f64 : div)
+float(toJSON(i64))
+float(true ? f32 : "foo")
+floor(-0.5)
+floor(-1)
+floor(-f32)
+floor(-f64)
+floor(-i)
+floor(-i32)
+floor(-i64)
+floor(0.5 * 0.5)
+floor(0.5 * 1)
+floor(0.5 * i32)
+floor(0.5 ** 1)
+floor(0.5 ** f64)
+floor(0.5 ** i)
+floor(0.5 + 1)
+floor(0.5 + f32)
+floor(0.5 + i)
+floor(0.5 + i32)
+floor(0.5 + i64)
+floor(0.5 - 1)
+floor(0.5 - f32)
+floor(0.5 - i)
+floor(0.5 / 0.5)
+floor(0.5 / 1)
+floor(0.5 / i32)
+floor(0.5 ^ 0.5)
+floor(0.5 ^ 1)
+floor(0.5 ^ f32)
+floor(0.5 ^ f64)
+floor(0.5 ^ i)
+floor(0.5) != i64
+floor(0.5) ** f32
+floor(0.5) - i
+floor(0.5) - i64
+floor(0.5) / i
+floor(0.5) <= i64
+floor(0.5) > i32
+floor(0.5) > i64 != ok
+floor(0.5) >= f32
+floor(0.5) ^ i
+floor(1 % 1)
+floor(1 % i)
+floor(1 * 0.5)
+floor(1 * 1)
+floor(1 ** 1)
+floor(1 ** f64)
+floor(1 ** i32)
+floor(1 + 0.5)
+floor(1 + 1)
+floor(1 + f32)
+floor(1 + f64)
+floor(1 + i32)
+floor(1 - 0.5)
+floor(1 - 1)
+floor(1 - i)
+floor(1 - i32)
+floor(1 - i64)
+floor(1 / 0.5)
+floor(1 / 1)
+floor(1 / i)
+floor(1 / i64)
+floor(1 ^ i)
+floor(1 ^ i32)
+floor(1 ^ i64)
+floor(1) * i64
+floor(1) - f32
+floor(1) - i
+floor(1) <= f32
+floor(1) >= half(0.5)
+floor(abs(0.5))
+floor(abs(1))
+floor(abs(f32))
+floor(abs(f64))
+floor(abs(i32))
+floor(abs(i64))
+floor(array[1])
+floor(array[i32])
+floor(array[i64])
+floor(array[i])
+floor(bitnot(1))
+floor(bitnot(i))
+floor(bitnot(i32))
+floor(bitnot(i64))
+floor(ceil(0.5))
+floor(ceil(1))
+floor(ceil(f64))
+floor(ceil(i))
+floor(ceil(i32))
+floor(ceil(i64))
+floor(count(array, false))
+floor(count(array, ok))
+floor(count(list, ok))
+floor(f32 ** 1)
+floor(f32 ** f64)
+floor(f32 ** i32)
+floor(f32 + f32)
+floor(f32 + i32)
+floor(f32 + i64)
+floor(f32 - 0.5)
+floor(f32 - f64)
+floor(f32 / 0.5)
+floor(f32 / f64)
+floor(f32 / i)
+floor(f32 / i32)
+floor(f32 / i64)
+floor(f32 ^ 0.5)
+floor(f32 ^ f64)
+floor(f32 ^ i)
+floor(f32)
+floor(f32) != -i32
+floor(f32) * i32
+floor(f32) + f32
+floor(f32) / f32
+floor(f32) / f64
+floor(f32) == i64
+floor(f32) > i32
+floor(f32) >= f32
+floor(f32) >= i
+floor(f32) ^ f32
+floor(f64 * f32)
+floor(f64 ** 0.5)
+floor(f64 ** 1)
+floor(f64 ** i32)
+floor(f64 + 0.5)
+floor(f64 + 1)
+floor(f64 + i32)
+floor(f64 - 0.5)
+floor(f64 - i32)
+floor(f64 / 0.5)
+floor(f64 / 1)
+floor(f64 / f32)
+floor(f64 / f64)
+floor(f64 / i)
+floor(f64 ^ 1)
+floor(f64)
+floor(f64) * i32
+floor(f64) ** f64
+floor(f64) / f32
+floor(f64) < i32
+floor(f64) <= f64
+floor(f64) <= i64
+floor(f64) == f64 ** i
+floor(f64) == i
+floor(f64) > i32
+floor(f64) >= 1 * 1
+floor(f64) >= f32
+floor(false ? div : 0.5)
+floor(find(array, true))
+floor(findIndex(array, ok))
+floor(findLastIndex(array, ok))
+floor(float(0.5))
+floor(float(1))
+floor(float(f64))
+floor(float(i32))
+floor(floor(0.5))
+floor(floor(1))
+floor(floor(f32))
+floor(floor(f64))
+floor(floor(i))
+floor(floor(i32))
+floor(floor(i64))
+floor(get(array, 1))
+floor(get(array, i))
+floor(get(array, i64))
+floor(half(0.5))
+floor(half(1))
+floor(half(f64))
+floor(i % 1)
+floor(i % i)
+floor(i % i32)
+floor(i % i64)
+floor(i * 1)
+floor(i * f64)
+floor(i ** 0.5)
+floor(i ** f32)
+floor(i ** i32)
+floor(i ** i64)
+floor(i + 0.5)
+floor(i + f64)
+floor(i - 0.5)
+floor(i - f32)
+floor(i - i32)
+floor(i / 0.5)
+floor(i / 1)
+floor(i / f64)
+floor(i ^ i32)
+floor(i)
+floor(i) != i
+floor(i) * f64
+floor(i) ^ i
+floor(i32 % i32)
+floor(i32 * 1)
+floor(i32 * f32)
+floor(i32 * f64)
+floor(i32 * i32)
+floor(i32 ** i)
+floor(i32 ** i64)
+floor(i32 + 0.5)
+floor(i32 + f64)
+floor(i32 - 1)
+floor(i32 - f32)
+floor(i32 - i)
+floor(i32 - i32)
+floor(i32 - i64)
+floor(i32 ^ 0.5)
+floor(i32 ^ 1)
+floor(i32 ^ f64)
+floor(i32 ^ i)
+floor(i32 ^ i32)
+floor(i32 ^ i64)
+floor(i32)
+floor(i32) != f32
+floor(i32) * f64
+floor(i32) * i
+floor(i32) * i64
+floor(i32) > i32
+floor(i32) > i64
+floor(i32) >= i32
+floor(i32) ^ i32
+floor(i64 % i)
+floor(i64 * 0.5)
+floor(i64 * f32)
+floor(i64 * i)
+floor(i64 ** 0.5)
+floor(i64 ** 1)
+floor(i64 ** i)
+floor(i64 ** i32)
+floor(i64 + 0.5)
+floor(i64 + f64)
+floor(i64 + i64)
+floor(i64 - f64)
+floor(i64 - i)
+floor(i64 / f32)
+floor(i64 ^ 0.5)
+floor(i64 ^ f32)
+floor(i64 ^ i64)
+floor(i64)
+floor(i64) * i64
+floor(i64) / (i64 - i)
+floor(i64) / f64
+floor(i64) / i32
+floor(i64) < f32
+floor(i64) <= i64
+floor(i64) ^ f32
+floor(int(0.5))
+floor(int(1))
+floor(int(i32))
+floor(int(i64))
+floor(len("foo"))
+floor(len(array))
+floor(len(list))
+floor(max(0.5))
+floor(max(1))
+floor(max(f32))
+floor(max(f64))
+floor(max(i32))
+floor(min(0.5))
+floor(min(f64) ^ i64)
+floor(min(i, i64))
+floor(min(i32))
+floor(ok ? 1 : 1)
+floor(ok ? f32 : "foo")
+floor(ok ? i64 : f64)
+floor(reduce(array, #))
+floor(reduce(array, i))
+floor(reduce(array, i64))
+floor(reduce(list, 1))
+floor(reduce(list, f32))
+floor(reduce(list, i64))
+floor(round(0.5))
+floor(round(f32))
+floor(round(f64))
+floor(round(i))
+floor(round(i32))
+floor(score(1))
+floor(score(1, 1))
+floor(score(i))
+floor(true ? 0.5 : false)
+floor(true ? 1 : true)
+floor(true ? f64 : 0.5)
+floor(true ? f64 : array)
 foo
-foo != first(list)
 foo != foo
-foo != foo ? 1 : 1
-foo != get(list, i)
-foo != last(list)
-foo != nil ? half : nil
+foo != nil != nil
+foo != reduce(list, #)
 foo == foo
-foo == foo ? i : score
-foo == last(list)
-foo == nil == nil
-foo == nil || ok
+foo == foo and 0.5 != f64
+foo == get(list, 1)
+foo == list[i]
+foo == nil ? i : i32
+foo == nil ? i64 : i
+foo == reduce(list, #)
 foo in filter(list, false)
+foo in groupBy(array, #)
+foo in groupBy(list, #)
 foo in list
-foo in list ? nil : i32
-foo in map(list, #)
+foo in list != ok
+foo not in groupBy(array, #)
+foo not in groupBy(array, f64).foo
+foo not in groupBy(list, #).i
+foo not in groupBy(list, f32)
+foo not in groupBy(list, ok)
 foo not in list
+foo not in list and ok
+foo not in list or false
+foo not in map(list, #)
 foo.Bar
-foo.Bar != string(i64)
-foo.Bar + type(greet)
-foo.Bar < toJSON(0.5)
-foo.Bar == type(0.5)
-foo.Bar not matches string(half)
-foo.Bar not startsWith foo.String()
+foo.Bar <= foo.Bar
+foo.Bar matches foo.Bar
+foo.Bar matches trimPrefix("foo")
 foo.Qux
-foo.Qux != add
-foo.Qux != half
-foo.Qux != score
-foo.Qux == div
-foo.Qux == foo?.Qux
-foo.Qux(foo?.String())
-foo.Qux(greet("bar"))
-foo.Qux(toJSON(0.5))
+foo.Qux("foo" + "foo")
+foo.Qux(foo.Bar)
+foo.Qux(foo.String())
+foo.Qux(greet("foo"))
+foo.Qux(string("foo"))
 foo.Qux(toJSON(i))
-foo.Qux(toJSON(nil))
-foo.Qux(trimSuffix("foo"))
 foo.Qux(type("bar"))
-foo.Qux(type(i))
+foo.Qux(type(f64))
+foo.Qux(type(half))
 foo.String
-foo.String != div
-foo.String == add
-foo.String == greet
-foo.String == half
-foo.String == score
 foo.String()
+foo.String() != foo?.String()
+foo.String() in foo
+foo.String() not in foo
 foo?.Bar
-foo?.Bar + type(score)
+foo?.Bar != foo?.Bar
 foo?.Bar in foo
-foo?.Bar not endsWith "bar" ? score : array
+foo?.Bar matches toJSON(f64)
+foo?.Bar not endsWith foo.Bar
+foo?.Bar not endsWith toJSON(foo)
 foo?.Qux
-foo?.Qux != div
-foo?.Qux != greet
-foo?.Qux != half
-foo?.Qux != score
-foo?.Qux == add
-foo?.Qux == greet
-foo?.Qux == half
-foo?.Qux == score
 foo?.Qux(foo?.Bar)
-foo?.Qux(string(0.5))
-foo?.Qux(type(0.5))
+foo?.Qux(string(i32))
+foo?.Qux(toJSON(1))
+foo?.Qux(toJSON(i32))
 foo?.Qux(upper("bar"))
 foo?.String
-foo?.String != div
-foo?.String != greet
-foo?.String != half
-foo?.String != nil ? half : list
-foo?.String != score
-foo?.String == add
-foo?.String == half
 foo?.String()
-foo?.String() + type(list)
-foo?.String() < string(i32)
-foo?.String() < toJSON(nil)
-foo?.String() matches toBase64("bar")
+foo?.String() contains string("foo")
 fromBase64(string(ok))
-fromBase64(string(true))
-fromBase64(toBase64("foo"))
-fromBase64(toBase64(toJSON(nil)))
-fromBase64(toJSON(nil))
-fromBase64(toJSON(ok))
-fromBase64(toJSON(true))
+fromBase64(toBase64("bar"))
+fromBase64(type(1 == 0.5))
 fromBase64(type(add))
 fromBase64(type(div))
 fromBase64(type(false))
 fromBase64(type(greet))
 fromBase64(type(half))
-fromBase64(type(nil == score))
 fromBase64(type(ok))
 fromBase64(type(score))
 fromBase64(type(true))
-fromJSON("foo") not in list && false
-fromJSON(string(0.5))
 fromJSON(string(1))
 fromJSON(string(f32))
 fromJSON(string(f64))
-fromJSON(string(false))
 fromJSON(string(i))
 fromJSON(string(i32))
 fromJSON(string(i64))
-fromJSON(string(i64)) ** f64
 fromJSON(string(ok))
 fromJSON(string(true))
-fromJSON(toJSON("foo"))
-fromJSON(toJSON(0.5 ** 0.5))
-fromJSON(toJSON(1))
-fromJSON(toJSON(abs(1)))
+fromJSON(toJSON("bar"))
+fromJSON(toJSON(0.5))
 fromJSON(toJSON(array))
-fromJSON(toJSON(f32))
 fromJSON(toJSON(f64))
+fromJSON(toJSON(false))
+fromJSON(toJSON(foo))
 fromJSON(toJSON(i))
 fromJSON(toJSON(i32))
-fromJSON(toJSON(i64))
 fromJSON(toJSON(list))
 fromJSON(toJSON(nil))
-fromJSON(toJSON(ok))
 fromJSON(toJSON(true))
-get(1 .. i32, i)
-get(1 .. i64, abs(1))
-get(1 .. i64, i)
-get(1 .. i64, i32)
-get(["bar"], i64)
-get([array], i)
-get([greet], i)
-get([nil, half], i)
-get([score, 0.5, score], i64)
+fromPairs(filter(array, false))
+fromPairs(filter(list, false))
+fromPairs(groupBy(array, #).String)
+get(["foo"], i32)
 get(array, -1)
-get(array, -i)
 get(array, -i32)
-get(array, 1 % 1)
-get(array, 1 % i64)
-get(array, 1 - 1)
-get(array, 1 - i)
-get(array, 1) * f64
+get(array, -i64)
+get(array, -score(1))
+get(array, 1 * 1)
+get(array, 1 * i)
+get(array, 1) ** f32
 get(array, 1) < f32
-get(array, 1) <= i32
-get(array, 1) > i
-get(array, 1) ^ f64
-get(array, 1) ^ i
-get(array, array[1])
-get(array, count(list, true))
-get(array, false ? div : false)
-get(array, first(array))
-get(array, i % i64)
-get(array, i * 1)
+get(array, 1) > i32
+get(array, 1) > i64
+get(array, bitnot(1))
+get(array, count(array, ok))
+get(array, false ? "foo" : 0.5)
 get(array, i)
-get(array, i) + i
-get(array, i) > i32
-get(array, i) ^ f32
-get(array, i32 * i64)
+get(array, i) != f32
+get(array, i) != i32
+get(array, i) * i32
+get(array, i) - i
+get(array, i) / i64
+get(array, i) > f64
+get(array, i) >= f64
+get(array, i) >= i64
+get(array, i) ^ half(0.5)
+get(array, i32 % i32)
 get(array, i32)
-get(array, i32) ** f32
-get(array, i32) == i32
-get(array, i32) > f64
+get(array, i32) / f64
+get(array, i32) < i
+get(array, i64 - 1)
 get(array, i64)
-get(array, i64) ** i
-get(array, i64) ** i64
-get(array, i64) .. i32
-get(array, i64) <= -i32
-get(array, i64) <= f64 / f32
-get(array, i64) <= i
-get(array, i64) == i64
-get(array, int(1))
-get(array, int(f32))
-get(array, int(f64))
-get(array, int(i32))
-get(array, len(array))
-get(array, max(1))
+get(array, i64) > f64
+get(array, last(array))
 get(array, min(i))
-get(array, min(i32))
+get(array, reduce(array, #))
+get(array, reduce(list, i64))
 get(array, score(1))
-get(array, true ? i : 1)
-get(false ? "bar" : f64, list)
-get(false ? "bar" : i32, greet)
-get(false ? "foo" : i, ok)
-get(false ? 1 : greet, ok)
-get(false ? greet : score, score)
-get(false ? half : list, i32)
-get(false ? list : 1, i32)
-get(false ? list : i64, i >= f64)
-get(false ? score : 0.5, add)
-get(false ? score : 0.5, half)
-get(false ? score : f64, half)
-get(filter(list, ok), i32)
-get(filter(list, ok), i64)
-get(i .. i, i)
-get(i32 .. 1, i)
+get(array, score(abs(1)))
+get(array, score(i))
+get(array, sum(array))
+get(false ? 0.5 : greet, list)
+get(false ? add : array, f64)
+get(false ? add : score, ok)
+get(false ? f64 : 1, ok)
+get(false ? f64 : score, add)
+get(false ? false : f32, i)
+get(false ? i32 : list, i64)
+get(false ? i64 : true, f64)
+get(false ? score : ok, trimSuffix("bar", "bar"))
+get(filter(list, true), i)
+get(groupBy(array, "bar"), add)
+get(groupBy(array, "bar"), i)
+get(groupBy(array, "bar"), ok)
+get(groupBy(array, "foo"), half)
+get(groupBy(array, #), add)
+get(groupBy(array, #), array)
+get(groupBy(array, #), f32)
+get(groupBy(array, #), f64)
+get(groupBy(array, #), foo)
+get(groupBy(array, #), greet)
+get(groupBy(array, #), half)
+get(groupBy(array, #), i)
+get(groupBy(array, #), i64 * 0.5)
+get(groupBy(array, #), i64)
+get(groupBy(array, #)?.String, i64)
+get(groupBy(array, 0.5), add)
+get(groupBy(array, 0.5), div)
+get(groupBy(array, 0.5), ok)
+get(groupBy(array, 1), add)
+get(groupBy(array, 1), f32)
+get(groupBy(array, f64), i64)
+get(groupBy(array, false), findIndex(array, ok))
+get(groupBy(array, i), ok)
+get(groupBy(array, i), score)
+get(groupBy(array, i64), add)
+get(groupBy(array, ok), add)
+get(groupBy(array, true), i32)
+get(groupBy(list, "bar"), i32)
+get(groupBy(list, "foo"), greet)
+get(groupBy(list, #), div)
+get(groupBy(list, #), f32 <= f64)
+get(groupBy(list, #), f32)
+get(groupBy(list, #), foo)
+get(groupBy(list, #), greet)
+get(groupBy(list, #), half)
+get(groupBy(list, #), i)
+get(groupBy(list, #), i32)
+get(groupBy(list, #), i64)
+get(groupBy(list, #), int(f32))
+get(groupBy(list, #), list)
+get(groupBy(list, #), reduce(array, foo))
+get(groupBy(list, #), score(1))
+get(groupBy(list, #), score)
+get(groupBy(list, 0.5), array)
+get(groupBy(list, 0.5), div)
+get(groupBy(list, 0.5), ok)
+get(groupBy(list, 1), i32)
+get(groupBy(list, f32), greet)
+get(groupBy(list, foo), add)
+get(groupBy(list, foo), i32)
+get(groupBy(list, ok), greet)
+get(groupBy(list, ok), list)
+get(i .. 1, 1 * 1)
+get(i .. i32, i)
+get(i32 .. i, i64)
 get(i64 .. 1, i32)
+get(i64 .. i, i32)
+get(i64 .. i64, i64)
+get(list, -1)
 get(list, -i)
-get(list, -i32)
 get(list, -i64)
-get(list, 1 * i)
+get(list, 1 * 1)
+get(list, 1 - 1)
+get(list, 1 - i)
+get(list, 1) != foo
 get(list, 1).Bar
 get(list, 1).Qux
 get(list, 1).String
@@ -6287,11 +7161,12 @@ get(list, 1)?.Bar
 get(list, 1)?.Qux
 get(list, 1)?.String
 get(list, 1)?.String()
-get(list, abs(i))
-get(list, abs(i32))
+get(list, bitshr(i, i32))
+get(list, first(array))
+get(list, get(array, 1))
+get(list, get(array, i64))
+get(list, i % 1)
 get(list, i)
-get(list, i) != foo
-get(list, i) == foo
 get(list, i).Bar
 get(list, i).Qux
 get(list, i).String
@@ -6299,122 +7174,104 @@ get(list, i)?.Bar
 get(list, i)?.Qux
 get(list, i)?.String
 get(list, i)?.String()
+get(list, i32 * i32)
+get(list, i32 - i32)
 get(list, i32)
 get(list, i32).Bar
 get(list, i32).Qux
 get(list, i32).String
-get(list, i32).String()
 get(list, i32)?.Bar
 get(list, i32)?.Qux
 get(list, i32)?.String
 get(list, i32)?.String()
-get(list, i64 * i32)
+get(list, i64 * 1)
+get(list, i64 * i)
+get(list, i64 - 1)
 get(list, i64)
 get(list, i64).Bar
 get(list, i64).Qux
 get(list, i64).String
-get(list, i64).String()
 get(list, i64)?.Bar
 get(list, i64)?.Qux
 get(list, i64)?.String
 get(list, i64)?.String()
-get(list, int(1) > 0.5 ? div : 0.5)
-get(list, int(i))
-get(list, int(i32))
-get(list, int(i64))
-get(list, last(array))
-get(list, max(1, i64, i64))
+get(list, int(1))
+get(list, max(i32))
 get(list, min(i32))
 get(list, min(i64))
+get(list, ok ? 0.5 : "foo")
+get(list, ok ? array : "foo")
+get(list, reduce(list, i64))
 get(list, score(1))
-get(list[i32:i], i64)
+get(list, score(i))
+get(list, true ? i : i32)
+get(list, {"foo": i32}?.i)
+get(list[i64:1], i)
 get(map(array, #), i)
+get(map(array, #), i32)
 get(map(array, #), i64)
-get(map(array, #), last(array))
-get(map(array, 0.5), i)
-get(map(array, 1), i)
-get(map(array, i32), i64)
-get(map(array, ok), i)
-get(map(array, ok), i64)
+get(map(array, add), i32)
+get(map(array, array), i)
+get(map(array, greet), i64)
+get(map(array, half), i64)
+get(map(list, "foo"), i64)
 get(map(list, #), i)
-get(map(list, #), i32)
 get(map(list, #), i64)
-get(map(list, 0.5), i64)
+get(map(list, 1), i32)
 get(map(list, array), i)
-get(map(list, div), i32)
 get(map(list, i32), i64)
-get(map(list, ok), i32)
-get(map(list, true), i64)
-get(ok ? 0.5 : add, f32)
-get(ok ? add : 0.5, ok)
-get(ok ? add : false, div)
-get(ok ? array : i, add)
-get(ok ? i : f64, greet)?.f64
-get(ok ? i32 : "foo", score)
-get(ok ? i32 : add, div)
-get(ok ? list : "foo", f32)
-get(ok ? ok : half, array)
-get(ok ? true : i32, f32)
+get(map(list, i64), i64)
+get(ok ? "bar" : false, array)
+get(ok ? 1 : "bar", f32)
+get(ok ? add : f32, array)
+get(ok ? f64 : div, i64)
+get(ok ? false : list, f32 > i)
+get(ok ? foo : 0.5, div)
+get(ok ? half : i32, i)
+get(ok ? half : ok, f64)
+get(ok ? i : 0.5, half)
+get(ok ? i32 : half, f64)
+get(ok ? i64 : foo, f32)
+get(ok ? list : "foo", add)
+get(ok ? list : i32, f32)
+get(ok ? ok : div, greet)
+get(ok ? score : f64, i)
+get(ok ? score : i64, foo)
+get(reduce(list, array), i32)
 get(sort(array), i32)
-get(true ? 0.5 : score, foo)
-get(true ? 1 : f64, foo)
-get(true ? 1 : greet, greet)?.foo
-get(true ? add : score, i)
-get(true ? array : 1, half)
-get(true ? array : i64, ok)
-get(true ? div : foo, list)
-get(true ? f32 : 1, greet)
-get(true ? i : f64, add)
-get(true ? i64 : score, i)
-get(true ? list : ok, ok)
-get({"bar": i32}.i32, ok)
+get(take(list, i), i64)
+get(true ? "bar" : ok, score(i))
+get(true ? "foo" : half, list)
+get(true ? 0.5 : i32, array)
+get(true ? f32 : 0.5, ok)
+get(true ? false : foo, i64 > 0.5)
+get(true ? greet : i32, score)
+get(true ? half : f32, greet)
+get(true ? half : list, add)
+get(true ? i64 : greet, i32)
+get(true ? score : true, half)?.half
+get(true ? true : i, f64)
+get({"foo": foo, "bar": false}, type(i))
 greet
-greet != add
-greet != div
-greet != div != nil
-greet != foo.Qux
-greet != foo.String
-greet != foo?.Qux
-greet != foo?.String
 greet != greet
-greet != greet != nil
-greet != greet or 0.5 == i
-greet != half
-greet != half ? 1 : ok
-greet != half ? array : 0.5
-greet != half ? false : f64
-greet != half ? greet : greet
-greet != nil ? i64 : 0.5
-greet != score
-greet == add
-greet == add == ok
-greet == add ? div == greet : i64
-greet == div
-greet == div ? add : i32
-greet == foo.Qux
-greet == foo.String
-greet == foo?.Qux
-greet == foo?.String
+greet != greet != ok
+greet != nil ? "bar" : add
+greet != nil ? 0.5 : false
+greet != nil ? list : false
 greet == greet
-greet == half
-greet == nil != nil
-greet == nil && ok
+greet == greet ? 0.5 : "bar"
+greet == greet and ok
 greet == nil == ok
-greet == score
-greet in [nil]
+greet == nil ? i64 : ok
+greet in groupBy(array, f64).f32
+greet in groupBy(list, #).score
+greet not in sort(array)
 greet("bar" + "bar")
-greet("bar" + "foo")
-greet("bar") != foo.String()
-greet("bar") != nil != false
-greet("bar") in foo
-greet("foo" + "bar")
 greet("foo" + "foo")
-greet("foo") >= string(foo)
-greet("foo") not contains "bar" ? array : half
-greet("foo") startsWith greet("bar")
-greet(false ? f32 : "foo")
-greet(false ? i : "bar")
+greet("foo") startsWith type(f64)
+greet(false ? i64 : "bar")
 greet(foo.Bar)
+greet(foo.Qux("foo"))
 greet(foo.String())
 greet(foo?.Bar)
 greet(foo?.String())
@@ -6422,14 +7279,20 @@ greet(greet("bar"))
 greet(greet("foo"))
 greet(lower("bar"))
 greet(lower("foo"))
-greet(ok ? "bar" : div)
+greet(ok ? "bar" : 1)
+greet(ok ? "bar" : i64)
+greet(ok ? "foo" : 0.5)
+greet(ok ? "foo" : div)
+greet(ok ? "foo" : true)
+greet(reduce(array, "bar"))
+greet(reduce(array, "foo"))
+greet(reduce(list, "foo"))
+greet(repeat("bar", 1))
+greet(repeat(foo?.String(), i32))
 greet(string("bar"))
 greet(string("foo"))
-greet(string(-i64))
-greet(string(0.5 == 1))
 greet(string(0.5))
 greet(string(1))
-greet(string([0.5]))
 greet(string(add))
 greet(string(array))
 greet(string(div))
@@ -6437,20 +7300,18 @@ greet(string(f32))
 greet(string(f64))
 greet(string(false))
 greet(string(foo))
-greet(string(foo?.Qux))
 greet(string(greet))
 greet(string(half))
 greet(string(i))
 greet(string(i32))
 greet(string(i64))
 greet(string(list))
-greet(string(nil != false))
 greet(string(nil))
 greet(string(ok))
 greet(string(score))
 greet(string(true))
 greet(toBase64("bar"))
-greet(toBase64("foo"))
+greet(toBase64(trimPrefix("bar")))
 greet(toJSON("bar"))
 greet(toJSON("foo"))
 greet(toJSON(0.5))
@@ -6466,27 +7327,26 @@ greet(toJSON(i64))
 greet(toJSON(list))
 greet(toJSON(nil))
 greet(toJSON(ok))
-greet(toJSON(string(array)))
 greet(toJSON(true))
 greet(trim("bar"))
 greet(trim("foo"))
-greet(trim(string(array)))
 greet(trimPrefix("bar"))
 greet(trimPrefix("foo"))
 greet(trimSuffix("bar"))
 greet(trimSuffix("foo"))
-greet(trimSuffix("foo", "foo"))
-greet(true ? "foo" : 0.5)
+greet(trimSuffix(foo.String()))
+greet(trimSuffix(foo?.Bar))
+greet(true ? "bar" : i64)
+greet(true ? "bar" : ok)
+greet(true ? "foo" : foo)
 greet(type("bar"))
 greet(type("foo"))
 greet(type(0.5))
 greet(type(1))
-greet(type(abs(f32)))
 greet(type(add))
 greet(type(array))
 greet(type(div))
 greet(type(f32))
-greet(type(f64 / i))
 greet(type(f64))
 greet(type(false))
 greet(type(foo))
@@ -6502,46 +7362,1543 @@ greet(type(score))
 greet(type(true))
 greet(upper("bar"))
 greet(upper("foo"))
+groupBy(1 .. 1, #).f64
+groupBy(1 .. i, #)
+groupBy(1 .. i, i32)?.score
+groupBy(1 .. i32, #)
+groupBy(1 .. i32, ok)
+groupBy(1 .. i64, i32)
+groupBy([0.5, f64], nil == "foo")
+groupBy([1], # <= #)
+groupBy([f32 ^ i64], #)
+groupBy([f32], f64)
+groupBy([f64], # >= f32)
+groupBy([half], f32)
+groupBy([i32], array[#])
+groupBy([nil], foo)
+groupBy([true], #)
+groupBy(array, !false)
+groupBy(array, !true)
+groupBy(array, "bar" in foo).String
+groupBy(array, "bar").Bar
+groupBy(array, "bar").Qux
+groupBy(array, "bar").String
+groupBy(array, "bar").add
+groupBy(array, "bar").array
+groupBy(array, "bar").div
+groupBy(array, "bar").f32
+groupBy(array, "bar").f64
+groupBy(array, "bar").foo
+groupBy(array, "bar").greet
+groupBy(array, "bar").half
+groupBy(array, "bar").i
+groupBy(array, "bar").i32
+groupBy(array, "bar").i64
+groupBy(array, "bar").list
+groupBy(array, "bar").ok
+groupBy(array, "bar").score
+groupBy(array, "bar")?.Bar
+groupBy(array, "bar")?.Qux
+groupBy(array, "bar")?.String
+groupBy(array, "bar")?.add
+groupBy(array, "bar")?.array
+groupBy(array, "bar")?.div
+groupBy(array, "bar")?.f32
+groupBy(array, "bar")?.f64
+groupBy(array, "bar")?.foo
+groupBy(array, "bar")?.greet
+groupBy(array, "bar")?.half
+groupBy(array, "bar")?.i
+groupBy(array, "bar")?.i64
+groupBy(array, "bar")?.list
+groupBy(array, "bar")?.ok
+groupBy(array, "bar")?.score
+groupBy(array, "bar")[f32 > f32]
+groupBy(array, "foo").Bar
+groupBy(array, "foo").Qux
+groupBy(array, "foo").String
+groupBy(array, "foo").add
+groupBy(array, "foo").array
+groupBy(array, "foo").div
+groupBy(array, "foo").f32
+groupBy(array, "foo").f64
+groupBy(array, "foo").foo
+groupBy(array, "foo").greet
+groupBy(array, "foo").half
+groupBy(array, "foo").i
+groupBy(array, "foo").i32
+groupBy(array, "foo").i64
+groupBy(array, "foo").list
+groupBy(array, "foo").ok
+groupBy(array, "foo").score
+groupBy(array, "foo")?.Bar
+groupBy(array, "foo")?.String
+groupBy(array, "foo")?.add
+groupBy(array, "foo")?.array
+groupBy(array, "foo")?.div
+groupBy(array, "foo")?.f32
+groupBy(array, "foo")?.f64
+groupBy(array, "foo")?.foo
+groupBy(array, "foo")?.greet
+groupBy(array, "foo")?.half
+groupBy(array, "foo")?.i
+groupBy(array, "foo")?.i32
+groupBy(array, "foo")?.i64
+groupBy(array, "foo")?.list
+groupBy(array, "foo")?.ok
+groupBy(array, "foo")?.score
+groupBy(array, # != #)
+groupBy(array, # != #).Qux
+groupBy(array, # != #)?.array
+groupBy(array, # != 0.5)
+groupBy(array, # != 1)
+groupBy(array, # != f32)
+groupBy(array, # != f64)
+groupBy(array, # != f64)?.String
+groupBy(array, # != i64)
+groupBy(array, # != nil)
+groupBy(array, # % #)
+groupBy(array, # % 1)
+groupBy(array, # % i32)
+groupBy(array, # * #)
+groupBy(array, # * #)?.Qux
+groupBy(array, # * 0.5)
+groupBy(array, # * 1)
+groupBy(array, # * i)
+groupBy(array, # * i32)
+groupBy(array, # * i64)
+groupBy(array, # ** #)
+groupBy(array, # ** #).add
+groupBy(array, # ** 0.5)
+groupBy(array, # ** 0.5)?.foo
+groupBy(array, # ** 0.5)?.greet
+groupBy(array, # ** 1)
+groupBy(array, # ** f64)
+groupBy(array, # ** i)
+groupBy(array, # ** i32)
+groupBy(array, # ** i64)
+groupBy(array, # + #)
+groupBy(array, # + 1)
+groupBy(array, # + f32)
+groupBy(array, # + i)
+groupBy(array, # - #)
+groupBy(array, # - 0.5)
+groupBy(array, # - 1)
+groupBy(array, # - f32)
+groupBy(array, # - f64)
+groupBy(array, # - i)
+groupBy(array, # - i32)
+groupBy(array, # / #)
+groupBy(array, # / 0.5)
+groupBy(array, # / 0.5)?.foo
+groupBy(array, # / 1)
+groupBy(array, # / i)
+groupBy(array, # / i32)
+groupBy(array, # / i64)
+groupBy(array, # < # || 0.5 > f64)
+groupBy(array, # < #)
+groupBy(array, # < 0.5)
+groupBy(array, # < 1)
+groupBy(array, # < i32)
+groupBy(array, # < i64)
+groupBy(array, # <= #)
+groupBy(array, # <= #)?.Bar
+groupBy(array, # <= #)?.Qux
+groupBy(array, # <= 0.5)
+groupBy(array, # <= 1)
+groupBy(array, # <= f32)
+groupBy(array, # <= f64)
+groupBy(array, # <= i)
+groupBy(array, # <= i64)
+groupBy(array, # == #)
+groupBy(array, # == #).String
+groupBy(array, # == #)?.half
+groupBy(array, # == 0.5)
+groupBy(array, # == 1)
+groupBy(array, # == f32)
+groupBy(array, # == f32).half
+groupBy(array, # == f64)
+groupBy(array, # == i)
+groupBy(array, # == i64)
+groupBy(array, # == nil)
+groupBy(array, # > #)
+groupBy(array, # > 0.5)
+groupBy(array, # > 1)
+groupBy(array, # > 1).Bar
+groupBy(array, # > i)?.i64
+groupBy(array, # > i64)
+groupBy(array, # >= #)
+groupBy(array, # >= f64)
+groupBy(array, # >= i)
+groupBy(array, # >= i32)
+groupBy(array, # >= i64)
+groupBy(array, # ^ #)
+groupBy(array, # ^ 0.5)
+groupBy(array, # ^ f32)
+groupBy(array, # ^ i)
+groupBy(array, # ^ i32)
+groupBy(array, # in array)
+groupBy(array, #)
+groupBy(array, #).Bar
+groupBy(array, #).Qux
+groupBy(array, #).String
+groupBy(array, #).add
+groupBy(array, #).array
+groupBy(array, #).div
+groupBy(array, #).f32
+groupBy(array, #).f64
+groupBy(array, #).foo
+groupBy(array, #).greet
+groupBy(array, #).half
+groupBy(array, #).i
+groupBy(array, #).i32
+groupBy(array, #).i64
+groupBy(array, #).list
+groupBy(array, #).ok
+groupBy(array, #).score
+groupBy(array, #)?.Bar
+groupBy(array, #)?.Qux
+groupBy(array, #)?.String
+groupBy(array, #)?.add
+groupBy(array, #)?.array
+groupBy(array, #)?.div
+groupBy(array, #)?.f32
+groupBy(array, #)?.f64
+groupBy(array, #)?.foo
+groupBy(array, #)?.greet
+groupBy(array, #)?.half
+groupBy(array, #)?.i
+groupBy(array, #)?.i32
+groupBy(array, #)?.i64
+groupBy(array, #)?.list
+groupBy(array, #)?.ok
+groupBy(array, #)?.score
+groupBy(array, #)[1 / i]
+groupBy(array, #)[f32]
+groupBy(array, #)[f64]
+groupBy(array, #)[foo]
+groupBy(array, #)[i32]
+groupBy(array, #)[i64]
+groupBy(array, #)[i]
+groupBy(array, #)[ok]
+groupBy(array, #)[reduce(list, #)]
+groupBy(array, -# * # * 0.5)
+groupBy(array, -#)
+groupBy(array, -#).Qux
+groupBy(array, -0.5)
+groupBy(array, -1)
+groupBy(array, -f32)
+groupBy(array, -i)?.score
+groupBy(array, -i32)
+groupBy(array, -i64)
+groupBy(array, 0.5 != #)
+groupBy(array, 0.5 * #)
+groupBy(array, 0.5 * 0.5)
+groupBy(array, 0.5 * f64)
+groupBy(array, 0.5 ** #)
+groupBy(array, 0.5 ** 1)
+groupBy(array, 0.5 ** i64)
+groupBy(array, 0.5 + #)?.score
+groupBy(array, 0.5 + f32)
+groupBy(array, 0.5 - 1)
+groupBy(array, 0.5 / #).array
+groupBy(array, 0.5 / f64)
+groupBy(array, 0.5 / i64)
+groupBy(array, 0.5 < 0.5)
+groupBy(array, 0.5 <= f32)
+groupBy(array, 0.5 == #)
+groupBy(array, 0.5 >= #)
+groupBy(array, 0.5 >= i32)
+groupBy(array, 0.5 >= i64)
+groupBy(array, 0.5 ^ f32)
+groupBy(array, 0.5 ^ i64)
+groupBy(array, 0.5).Bar
+groupBy(array, 0.5).Qux
+groupBy(array, 0.5).String
+groupBy(array, 0.5).add
+groupBy(array, 0.5).array
+groupBy(array, 0.5).div
+groupBy(array, 0.5).f32
+groupBy(array, 0.5).f64
+groupBy(array, 0.5).foo
+groupBy(array, 0.5).greet
+groupBy(array, 0.5).half
+groupBy(array, 0.5).i
+groupBy(array, 0.5).i32
+groupBy(array, 0.5).i64
+groupBy(array, 0.5).list
+groupBy(array, 0.5).ok
+groupBy(array, 0.5).score
+groupBy(array, 0.5)?.Bar
+groupBy(array, 0.5)?.Qux
+groupBy(array, 0.5)?.String
+groupBy(array, 0.5)?.add
+groupBy(array, 0.5)?.array
+groupBy(array, 0.5)?.div
+groupBy(array, 0.5)?.f32
+groupBy(array, 0.5)?.f64
+groupBy(array, 0.5)?.foo
+groupBy(array, 0.5)?.greet
+groupBy(array, 0.5)?.half
+groupBy(array, 0.5)?.i
+groupBy(array, 0.5)?.i32
+groupBy(array, 0.5)?.i64
+groupBy(array, 0.5)?.list
+groupBy(array, 0.5)?.ok
+groupBy(array, 0.5)?.score
+groupBy(array, 1 != #)?.String
+groupBy(array, 1 != 0.5)
+groupBy(array, 1 != f32)
+groupBy(array, 1 % #)
+groupBy(array, 1 % i)
+groupBy(array, 1 * 0.5)
+groupBy(array, 1 * i)
+groupBy(array, 1 + #)
+groupBy(array, 1 + 1)
+groupBy(array, 1 - #)
+groupBy(array, 1 - 1)
+groupBy(array, 1 / #)
+groupBy(array, 1 < #)
+groupBy(array, 1 < i32)?.array
+groupBy(array, 1 < i64)?.ok
+groupBy(array, 1 <= #)
+groupBy(array, 1 == #)
+groupBy(array, 1 == #).add
+groupBy(array, 1 == i32)
+groupBy(array, 1 == nil)
+groupBy(array, 1 > i)
+groupBy(array, 1 >= #)
+groupBy(array, 1 ^ #)
+groupBy(array, 1 not in array)
+groupBy(array, 1).Bar
+groupBy(array, 1).Qux
+groupBy(array, 1).String
+groupBy(array, 1).add
+groupBy(array, 1).array
+groupBy(array, 1).div
+groupBy(array, 1).f64
+groupBy(array, 1).foo
+groupBy(array, 1).greet
+groupBy(array, 1).half
+groupBy(array, 1).i
+groupBy(array, 1).i32
+groupBy(array, 1).i64
+groupBy(array, 1).list
+groupBy(array, 1).ok
+groupBy(array, 1).score
+groupBy(array, 1)?.Bar
+groupBy(array, 1)?.Qux
+groupBy(array, 1)?.String
+groupBy(array, 1)?.add
+groupBy(array, 1)?.array
+groupBy(array, 1)?.div
+groupBy(array, 1)?.f32
+groupBy(array, 1)?.f64
+groupBy(array, 1)?.foo
+groupBy(array, 1)?.greet
+groupBy(array, 1)?.half
+groupBy(array, 1)?.i
+groupBy(array, 1)?.i32
+groupBy(array, 1)?.i64
+groupBy(array, 1)?.list
+groupBy(array, 1)?.ok
+groupBy(array, 1)?.score
+groupBy(array, abs(#))
+groupBy(array, abs(0.5))
+groupBy(array, abs(1))
+groupBy(array, abs(f32))
+groupBy(array, abs(f64))
+groupBy(array, abs(i))
+groupBy(array, abs(i64))
+groupBy(array, add(#, #))
+groupBy(array, add(#, 1))?.i64
+groupBy(array, bitnand(1, #))
+groupBy(array, bitnot(#))
+groupBy(array, bitnot(1))
+groupBy(array, bitor(#, #))
+groupBy(array, bitor(1, #))
+groupBy(array, bitor(i32, #))
+groupBy(array, bitshl(1, #))
+groupBy(array, bitshr(i, #))
+groupBy(array, bitushr(#, #))
+groupBy(array, ceil(#))
+groupBy(array, ceil(i))
+groupBy(array, ceil(i32))
+groupBy(array, div(#, #))
+groupBy(array, f32 != #)
+groupBy(array, f32 ** 0.5)
+groupBy(array, f32 - #)
+groupBy(array, f32 - f64)
+groupBy(array, f32 / #)
+groupBy(array, f32 < #)
+groupBy(array, f32 <= #)
+groupBy(array, f32 == #)
+groupBy(array, f32 > 0.5)
+groupBy(array, f32 > i32)
+groupBy(array, f32 ^ i)
+groupBy(array, f32)
+groupBy(array, f32).Bar
+groupBy(array, f32).Qux
+groupBy(array, f32).String
+groupBy(array, f32).add
+groupBy(array, f32).array
+groupBy(array, f32).div
+groupBy(array, f32).f64
+groupBy(array, f32).greet
+groupBy(array, f32).half
+groupBy(array, f32).i
+groupBy(array, f32).i32
+groupBy(array, f32).i64
+groupBy(array, f32).list
+groupBy(array, f32).ok
+groupBy(array, f32).score
+groupBy(array, f32)?.Bar
+groupBy(array, f32)?.Qux
+groupBy(array, f32)?.String
+groupBy(array, f32)?.add
+groupBy(array, f32)?.array
+groupBy(array, f32)?.div
+groupBy(array, f32)?.f32
+groupBy(array, f32)?.f64
+groupBy(array, f32)?.greet
+groupBy(array, f32)?.half
+groupBy(array, f32)?.i32
+groupBy(array, f32)?.i64
+groupBy(array, f32)?.list
+groupBy(array, f32)?.ok
+groupBy(array, f32)?.score
+groupBy(array, f32)[foo]
+groupBy(array, f64 != #)
+groupBy(array, f64 != i64)
+groupBy(array, f64 ** #)
+groupBy(array, f64 - #)
+groupBy(array, f64 - #).i32
+groupBy(array, f64 < #)
+groupBy(array, f64 == #)
+groupBy(array, f64 > #)
+groupBy(array, f64 >= #)
+groupBy(array, f64 >= 0.5)
+groupBy(array, f64)
+groupBy(array, f64).Bar
+groupBy(array, f64).Qux
+groupBy(array, f64).String
+groupBy(array, f64).add
+groupBy(array, f64).array
+groupBy(array, f64).div
+groupBy(array, f64).f32
+groupBy(array, f64).f64
+groupBy(array, f64).foo
+groupBy(array, f64).greet
+groupBy(array, f64).half
+groupBy(array, f64).i
+groupBy(array, f64).i32
+groupBy(array, f64).i64
+groupBy(array, f64).list
+groupBy(array, f64).ok
+groupBy(array, f64).score
+groupBy(array, f64)?.Bar
+groupBy(array, f64)?.Qux
+groupBy(array, f64)?.String
+groupBy(array, f64)?.add
+groupBy(array, f64)?.array
+groupBy(array, f64)?.div
+groupBy(array, f64)?.f32
+groupBy(array, f64)?.f64
+groupBy(array, f64)?.foo
+groupBy(array, f64)?.greet
+groupBy(array, f64)?.half
+groupBy(array, f64)?.i
+groupBy(array, f64)?.i32
+groupBy(array, f64)?.i64
+groupBy(array, f64)?.list
+groupBy(array, f64)?.ok
+groupBy(array, f64)?.score
+groupBy(array, f64)[i32]
+groupBy(array, false ? # : #)
+groupBy(array, false || ok)
+groupBy(array, false).Bar
+groupBy(array, false).Qux
+groupBy(array, false).String
+groupBy(array, false).add
+groupBy(array, false).array
+groupBy(array, false).div
+groupBy(array, false).f32
+groupBy(array, false).f64
+groupBy(array, false).greet
+groupBy(array, false).half
+groupBy(array, false).i
+groupBy(array, false).i32
+groupBy(array, false).i64
+groupBy(array, false).list
+groupBy(array, false).ok
+groupBy(array, false).score
+groupBy(array, false)?.Bar
+groupBy(array, false)?.Qux
+groupBy(array, false)?.String
+groupBy(array, false)?.add
+groupBy(array, false)?.array
+groupBy(array, false)?.div
+groupBy(array, false)?.f32
+groupBy(array, false)?.f64
+groupBy(array, false)?.foo
+groupBy(array, false)?.greet
+groupBy(array, false)?.half
+groupBy(array, false)?.i
+groupBy(array, false)?.i32
+groupBy(array, false)?.i64
+groupBy(array, false)?.list
+groupBy(array, false)?.ok
+groupBy(array, false)?.score
+groupBy(array, findLastIndex(list, true))
+groupBy(array, float(#))
+groupBy(array, floor(#))
+groupBy(array, floor(i32))
+groupBy(array, foo)
+groupBy(array, foo).Bar
+groupBy(array, foo).Qux
+groupBy(array, foo).String
+groupBy(array, foo).add
+groupBy(array, foo).array
+groupBy(array, foo).div
+groupBy(array, foo).f32
+groupBy(array, foo).f64
+groupBy(array, foo).foo
+groupBy(array, foo).greet
+groupBy(array, foo).half
+groupBy(array, foo).i
+groupBy(array, foo).i32
+groupBy(array, foo).i64
+groupBy(array, foo).list
+groupBy(array, foo).ok
+groupBy(array, foo).score
+groupBy(array, foo)?.Bar
+groupBy(array, foo)?.Qux
+groupBy(array, foo)?.String
+groupBy(array, foo)?.add
+groupBy(array, foo)?.array
+groupBy(array, foo)?.div
+groupBy(array, foo)?.f32
+groupBy(array, foo)?.f64
+groupBy(array, foo)?.foo
+groupBy(array, foo)?.greet
+groupBy(array, foo)?.half
+groupBy(array, foo)?.i
+groupBy(array, foo)?.i32
+groupBy(array, foo)?.i64
+groupBy(array, foo)?.list
+groupBy(array, foo)?.ok
+groupBy(array, foo)?.score
+groupBy(array, foo.Bar)
+groupBy(array, foo?.Bar)
+groupBy(array, get(array, #))
+groupBy(array, get(list, #))
+groupBy(array, get(list, i32))
+groupBy(array, half(1))
+groupBy(array, half(f64))
+groupBy(array, half(f64))?.i64
+groupBy(array, i != #)
+groupBy(array, i % #)
+groupBy(array, i * #)
+groupBy(array, i * #)?.f64
+groupBy(array, i ** #)
+groupBy(array, i + #)
+groupBy(array, i - f64).array
+groupBy(array, i / #)
+groupBy(array, i < #)
+groupBy(array, i <= #)
+groupBy(array, i <= f64)
+groupBy(array, i > i)
+groupBy(array, i ^ #)
+groupBy(array, i ^ 0.5)
+groupBy(array, i)
+groupBy(array, i).Bar
+groupBy(array, i).Qux
+groupBy(array, i).String
+groupBy(array, i).add
+groupBy(array, i).array
+groupBy(array, i).div
+groupBy(array, i).f32
+groupBy(array, i).f64
+groupBy(array, i).foo
+groupBy(array, i).greet
+groupBy(array, i).half
+groupBy(array, i).i
+groupBy(array, i).i32
+groupBy(array, i).i64
+groupBy(array, i).list
+groupBy(array, i).ok
+groupBy(array, i).score
+groupBy(array, i)?.Bar
+groupBy(array, i)?.String
+groupBy(array, i)?.add
+groupBy(array, i)?.array
+groupBy(array, i)?.div
+groupBy(array, i)?.f32
+groupBy(array, i)?.f64
+groupBy(array, i)?.foo
+groupBy(array, i)?.greet
+groupBy(array, i)?.half
+groupBy(array, i)?.i
+groupBy(array, i)?.i32
+groupBy(array, i)?.i64
+groupBy(array, i)?.list
+groupBy(array, i)?.ok
+groupBy(array, i)?.score
+groupBy(array, i)[f64]
+groupBy(array, i)[false ? i32 : ok]
+groupBy(array, i32 * f64)
+groupBy(array, i32 ** # <= i32)
+groupBy(array, i32 ** f64)
+groupBy(array, i32 ** i)
+groupBy(array, i32 ** i64)
+groupBy(array, i32 + #)
+groupBy(array, i32 - 1)?.foo
+groupBy(array, i32 - i64)
+groupBy(array, i32 / #)
+groupBy(array, i32 / f32)
+groupBy(array, i32 < #)
+groupBy(array, i32 < f64)
+groupBy(array, i32 <= 1)
+groupBy(array, i32 == #)
+groupBy(array, i32 == i)
+groupBy(array, i32 > #)
+groupBy(array, i32 >= #).Bar
+groupBy(array, i32 ^ #)
+groupBy(array, i32)
+groupBy(array, i32).Bar
+groupBy(array, i32).Qux
+groupBy(array, i32).String
+groupBy(array, i32).add
+groupBy(array, i32).array
+groupBy(array, i32).div
+groupBy(array, i32).f32
+groupBy(array, i32).f64
+groupBy(array, i32).greet
+groupBy(array, i32).half
+groupBy(array, i32).i
+groupBy(array, i32).i32
+groupBy(array, i32).i64
+groupBy(array, i32).list
+groupBy(array, i32).ok
+groupBy(array, i32).score
+groupBy(array, i32)?.Bar
+groupBy(array, i32)?.Qux
+groupBy(array, i32)?.String
+groupBy(array, i32)?.add
+groupBy(array, i32)?.array
+groupBy(array, i32)?.div
+groupBy(array, i32)?.f32
+groupBy(array, i32)?.f64
+groupBy(array, i32)?.foo
+groupBy(array, i32)?.greet
+groupBy(array, i32)?.half
+groupBy(array, i32)?.i
+groupBy(array, i32)?.i32
+groupBy(array, i32)?.i64
+groupBy(array, i32)?.list
+groupBy(array, i32)?.ok
+groupBy(array, i32)?.score
+groupBy(array, i32)[i]
+groupBy(array, i64 != i)
+groupBy(array, i64 % #)
+groupBy(array, i64 * f32)
+groupBy(array, i64 ** #)
+groupBy(array, i64 ** i)
+groupBy(array, i64 + #)
+groupBy(array, i64 - #)
+groupBy(array, i64 / #)?.Qux
+groupBy(array, i64 / 0.5)
+groupBy(array, i64 < #)
+groupBy(array, i64 <= #).foo
+groupBy(array, i64 >= #)
+groupBy(array, i64 ^ #)
+groupBy(array, i64)
+groupBy(array, i64).Bar
+groupBy(array, i64).Qux
+groupBy(array, i64).String
+groupBy(array, i64).add
+groupBy(array, i64).array
+groupBy(array, i64).div
+groupBy(array, i64).f32
+groupBy(array, i64).f64
+groupBy(array, i64).foo
+groupBy(array, i64).greet
+groupBy(array, i64).half
+groupBy(array, i64).i
+groupBy(array, i64).i32
+groupBy(array, i64).i64
+groupBy(array, i64).list
+groupBy(array, i64).ok
+groupBy(array, i64).score
+groupBy(array, i64)?.Bar
+groupBy(array, i64)?.Qux
+groupBy(array, i64)?.String
+groupBy(array, i64)?.add
+groupBy(array, i64)?.array
+groupBy(array, i64)?.div
+groupBy(array, i64)?.f32
+groupBy(array, i64)?.f64
+groupBy(array, i64)?.foo
+groupBy(array, i64)?.greet
+groupBy(array, i64)?.half
+groupBy(array, i64)?.i
+groupBy(array, i64)?.i32
+groupBy(array, i64)?.i64
+groupBy(array, i64)?.list
+groupBy(array, i64)?.ok
+groupBy(array, i64)?.score
+groupBy(array, int(f64)).i32
+groupBy(array, max(#))
+groupBy(array, max(#, #, #)).ok
+groupBy(array, max(0.5, #))
+groupBy(array, max(1))
+groupBy(array, max(f64))
+groupBy(array, min(#))
+groupBy(array, min(0.5))
+groupBy(array, min(f32))
+groupBy(array, min(i, #, i32))
+groupBy(array, nil != #)
+groupBy(array, nil != f64)
+groupBy(array, nil != foo)
+groupBy(array, nil != half)
+groupBy(array, nil == #)
+groupBy(array, nil == 0.5)
+groupBy(array, none(array, false))
+groupBy(array, none(array, ok))
+groupBy(array, not ok)?.Bar
+groupBy(array, not true)
+groupBy(array, ok == ok)
+groupBy(array, ok ? # : #)
+groupBy(array, ok)
+groupBy(array, ok).Bar
+groupBy(array, ok).Qux
+groupBy(array, ok).String
+groupBy(array, ok).add
+groupBy(array, ok).array
+groupBy(array, ok).div
+groupBy(array, ok).f32
+groupBy(array, ok).f64
+groupBy(array, ok).foo
+groupBy(array, ok).greet
+groupBy(array, ok).half
+groupBy(array, ok).i
+groupBy(array, ok).i32
+groupBy(array, ok).i64
+groupBy(array, ok).list
+groupBy(array, ok).ok
+groupBy(array, ok).score
+groupBy(array, ok)?.Bar
+groupBy(array, ok)?.Qux
+groupBy(array, ok)?.String
+groupBy(array, ok)?.array
+groupBy(array, ok)?.div
+groupBy(array, ok)?.f32
+groupBy(array, ok)?.f64
+groupBy(array, ok)?.foo
+groupBy(array, ok)?.greet
+groupBy(array, ok)?.half
+groupBy(array, ok)?.i32
+groupBy(array, ok)?.i64
+groupBy(array, ok)?.list
+groupBy(array, ok)?.ok
+groupBy(array, ok)?.score
+groupBy(array, one(array, ok))
+groupBy(array, reduce(array, #))
+groupBy(array, reduce(array, foo))
+groupBy(array, reduce(list, #))
+groupBy(array, round(#))
+groupBy(array, score(#))
+groupBy(array, score(#, #))
+groupBy(array, score(#, #, #, 1))
+groupBy(array, score(#, 1)).list
+groupBy(array, score(1))
+groupBy(array, score(i))
+groupBy(array, string(#))
+groupBy(array, string(div))
+groupBy(array, string(i32))
+groupBy(array, toJSON("bar"))
+groupBy(array, toJSON(#))
+groupBy(array, toJSON(1 .. i))
+groupBy(array, toJSON(foo))
+groupBy(array, trimPrefix("foo"))
+groupBy(array, true == nil)
+groupBy(array, true ? # : #)
+groupBy(array, true ? # : 1)
+groupBy(array, true ? nil : "foo")
+groupBy(array, true).Bar
+groupBy(array, true).Qux
+groupBy(array, true).add
+groupBy(array, true).div
+groupBy(array, true).f64
+groupBy(array, true).foo
+groupBy(array, true).greet
+groupBy(array, true).half
+groupBy(array, true).i
+groupBy(array, true).i32
+groupBy(array, true).i64
+groupBy(array, true).list
+groupBy(array, true).ok
+groupBy(array, true).score
+groupBy(array, true)?.Bar
+groupBy(array, true)?.Qux
+groupBy(array, true)?.String
+groupBy(array, true)?.add
+groupBy(array, true)?.array
+groupBy(array, true)?.div
+groupBy(array, true)?.f32
+groupBy(array, true)?.f64
+groupBy(array, true)?.half
+groupBy(array, true)?.i
+groupBy(array, true)?.i32
+groupBy(array, true)?.i64
+groupBy(array, true)?.list
+groupBy(array, true)?.ok
+groupBy(array, true)?.score
+groupBy(array, true)[i32]
+groupBy(array, type(# <= #))
+groupBy(array, type(#)).i64
+groupBy(array, type(-f64))
+groupBy(array, type(f32))
+groupBy(false ? 0.5 : "bar", #)
+groupBy(filter(array, false), #)
+groupBy(filter(array, false), add)
+groupBy(filter(array, false), f32)
+groupBy(filter(array, false), nil == #)
+groupBy(filter(array, ok), half(1))
+groupBy(filter(array, true), #)
+groupBy(filter(array, true), f64)
+groupBy(filter(list, ok), #)
+groupBy(groupBy(array, "foo").list, #)
+groupBy(groupBy(array, #).i32, add)
+groupBy(groupBy(array, ok).Bar, #?.array not matches #)
+groupBy(groupBy(array, true).f64, #[#])
+groupBy(i .. 1, !ok)?.f64
+groupBy(i .. 1, # % #)
+groupBy(i .. i, i64)
+groupBy(i .. i32, #)
+groupBy(i .. i32, f64 * #)
+groupBy(i .. i64, f64)?.score
+groupBy(i .. i64, foo)
+groupBy(i .. len(array), #)
+groupBy(i32 .. 1, # - #)
+groupBy(i32 .. 1, #)?.f32
+groupBy(i32 .. i, #)
+groupBy(i32 .. i32, i)
+groupBy(i32 .. i32, i32)
+groupBy(i32 .. i32, i64)
+groupBy(i32 .. i32, list[i])
+groupBy(i32 .. i32, ok)
+groupBy(i32 .. i64, #)
+groupBy(i32 .. i64, get(array, #))
+groupBy(i64 .. 1, -0.5)
+groupBy(i64 .. 1, i)
+groupBy(i64 .. i, -#)
+groupBy(i64 .. i, i32)
+groupBy(i64 .. i32, i)
+groupBy(i64 .. i64, i32)
+groupBy(list, !("foo" in #))
+groupBy(list, !false)
+groupBy(list, !ok)
+groupBy(list, !true)
+groupBy(list, "bar" contains "foo")?.ok
+groupBy(list, "bar" endsWith "bar")
+groupBy(list, "bar" not in #)
+groupBy(list, "bar").Bar
+groupBy(list, "bar").Qux
+groupBy(list, "bar").String
+groupBy(list, "bar").add
+groupBy(list, "bar").array
+groupBy(list, "bar").div
+groupBy(list, "bar").f32
+groupBy(list, "bar").f64
+groupBy(list, "bar").foo
+groupBy(list, "bar").greet
+groupBy(list, "bar").i
+groupBy(list, "bar").i32
+groupBy(list, "bar").i64
+groupBy(list, "bar").list
+groupBy(list, "bar").ok
+groupBy(list, "bar").score
+groupBy(list, "bar")?.Bar
+groupBy(list, "bar")?.Qux
+groupBy(list, "bar")?.String
+groupBy(list, "bar")?.add
+groupBy(list, "bar")?.array
+groupBy(list, "bar")?.div
+groupBy(list, "bar")?.f32
+groupBy(list, "bar")?.f64
+groupBy(list, "bar")?.foo
+groupBy(list, "bar")?.greet
+groupBy(list, "bar")?.half
+groupBy(list, "bar")?.i
+groupBy(list, "bar")?.i32
+groupBy(list, "bar")?.i64
+groupBy(list, "bar")?.list
+groupBy(list, "bar")?.ok
+groupBy(list, "bar")?.score
+groupBy(list, "foo" not in #)?.foo
+groupBy(list, "foo").Bar
+groupBy(list, "foo").Qux
+groupBy(list, "foo").String
+groupBy(list, "foo").add
+groupBy(list, "foo").array
+groupBy(list, "foo").div
+groupBy(list, "foo").f32
+groupBy(list, "foo").f64
+groupBy(list, "foo").foo
+groupBy(list, "foo").greet
+groupBy(list, "foo").half
+groupBy(list, "foo").i
+groupBy(list, "foo").i32
+groupBy(list, "foo").i64
+groupBy(list, "foo").list
+groupBy(list, "foo").ok
+groupBy(list, "foo").score
+groupBy(list, "foo")?.Bar
+groupBy(list, "foo")?.Qux
+groupBy(list, "foo")?.String
+groupBy(list, "foo")?.add
+groupBy(list, "foo")?.array
+groupBy(list, "foo")?.div
+groupBy(list, "foo")?.f32
+groupBy(list, "foo")?.f64
+groupBy(list, "foo")?.foo
+groupBy(list, "foo")?.greet
+groupBy(list, "foo")?.half
+groupBy(list, "foo")?.i
+groupBy(list, "foo")?.i32
+groupBy(list, "foo")?.i64
+groupBy(list, "foo")?.list
+groupBy(list, "foo")?.ok
+groupBy(list, "foo")?.score
+groupBy(list, # != #)
+groupBy(list, # != foo)
+groupBy(list, # != foo)?.i
+groupBy(list, # != nil)
+groupBy(list, # == #)
+groupBy(list, # == #).div
+groupBy(list, # in list)
+groupBy(list, # not in list)
+groupBy(list, #)
+groupBy(list, #).Bar
+groupBy(list, #).Qux
+groupBy(list, #).String
+groupBy(list, #).add
+groupBy(list, #).array
+groupBy(list, #).div
+groupBy(list, #).f32
+groupBy(list, #).f64
+groupBy(list, #).foo
+groupBy(list, #).greet
+groupBy(list, #).half
+groupBy(list, #).i
+groupBy(list, #).i32
+groupBy(list, #).i64
+groupBy(list, #).list
+groupBy(list, #).ok
+groupBy(list, #).score
+groupBy(list, #)?.Bar
+groupBy(list, #)?.Qux
+groupBy(list, #)?.String
+groupBy(list, #)?.add
+groupBy(list, #)?.array
+groupBy(list, #)?.div
+groupBy(list, #)?.f32
+groupBy(list, #)?.f64
+groupBy(list, #)?.foo
+groupBy(list, #)?.greet
+groupBy(list, #)?.half
+groupBy(list, #)?.i
+groupBy(list, #)?.i32
+groupBy(list, #)?.i64
+groupBy(list, #)?.list
+groupBy(list, #)?.ok
+groupBy(list, #)?.score
+groupBy(list, #)[-i64]
+groupBy(list, #)[1 == i32]
+groupBy(list, #)[f32]
+groupBy(list, #)[foo]
+groupBy(list, #)[i == i64]
+groupBy(list, #)[i32]
+groupBy(list, #)[i64]
+groupBy(list, #)[ok]
+groupBy(list, #?.Bar)
+groupBy(list, #?.String())
+groupBy(list, #?.String())?.score
+groupBy(list, -0.5)
+groupBy(list, -1)
+groupBy(list, -f32)
+groupBy(list, -i)
+groupBy(list, .Bar)
+groupBy(list, .Bar).f32
+groupBy(list, .String())
+groupBy(list, .String())?.score
+groupBy(list, 0.5 != f32)
+groupBy(list, 0.5 != f64)
+groupBy(list, 0.5 * f32)
+groupBy(list, 0.5 ** i64)
+groupBy(list, 0.5 / i)
+groupBy(list, 0.5).Bar
+groupBy(list, 0.5).Qux
+groupBy(list, 0.5).String
+groupBy(list, 0.5).add
+groupBy(list, 0.5).array
+groupBy(list, 0.5).div
+groupBy(list, 0.5).f32
+groupBy(list, 0.5).f64
+groupBy(list, 0.5).greet
+groupBy(list, 0.5).half
+groupBy(list, 0.5).i
+groupBy(list, 0.5).i32
+groupBy(list, 0.5).i64
+groupBy(list, 0.5).list
+groupBy(list, 0.5).ok
+groupBy(list, 0.5).score
+groupBy(list, 0.5)?.Bar
+groupBy(list, 0.5)?.Qux
+groupBy(list, 0.5)?.String
+groupBy(list, 0.5)?.add
+groupBy(list, 0.5)?.array
+groupBy(list, 0.5)?.div
+groupBy(list, 0.5)?.f32
+groupBy(list, 0.5)?.f64
+groupBy(list, 0.5)?.foo
+groupBy(list, 0.5)?.greet
+groupBy(list, 0.5)?.half
+groupBy(list, 0.5)?.i
+groupBy(list, 0.5)?.i32
+groupBy(list, 0.5)?.i64
+groupBy(list, 0.5)?.list
+groupBy(list, 0.5)?.ok
+groupBy(list, 0.5)?.score
+groupBy(list, 1 * f64).f32
+groupBy(list, 1 + i)
+groupBy(list, 1 - 0.5)
+groupBy(list, 1 ^ 0.5)
+groupBy(list, 1 ^ 1)
+groupBy(list, 1 ^ i)
+groupBy(list, 1).Bar
+groupBy(list, 1).Qux
+groupBy(list, 1).String
+groupBy(list, 1).add
+groupBy(list, 1).array
+groupBy(list, 1).div
+groupBy(list, 1).f32
+groupBy(list, 1).f64
+groupBy(list, 1).foo
+groupBy(list, 1).greet
+groupBy(list, 1).half
+groupBy(list, 1).i
+groupBy(list, 1).i32
+groupBy(list, 1).i64
+groupBy(list, 1).list
+groupBy(list, 1).ok
+groupBy(list, 1).score
+groupBy(list, 1)?.Bar
+groupBy(list, 1)?.Qux
+groupBy(list, 1)?.String
+groupBy(list, 1)?.add
+groupBy(list, 1)?.array
+groupBy(list, 1)?.div
+groupBy(list, 1)?.f32
+groupBy(list, 1)?.f64
+groupBy(list, 1)?.foo
+groupBy(list, 1)?.greet
+groupBy(list, 1)?.half
+groupBy(list, 1)?.i
+groupBy(list, 1)?.i32
+groupBy(list, 1)?.i64
+groupBy(list, 1)?.list
+groupBy(list, 1)?.ok
+groupBy(list, 1)?.score
+groupBy(list, 1)[i]
+groupBy(list, 1)[reduce(list, "foo")]
+groupBy(list, abs(1))
+groupBy(list, abs(i))
+groupBy(list, abs(i64))
+groupBy(list, all(list, ok))
+groupBy(list, ceil(0.5))
+groupBy(list, ceil(f64))
+groupBy(list, f32 ** 0.5)
+groupBy(list, f32 ** 1)
+groupBy(list, f32 < f32)
+groupBy(list, f32 == i64)
+groupBy(list, f32 >= 1)
+groupBy(list, f32)
+groupBy(list, f32).Bar
+groupBy(list, f32).Qux
+groupBy(list, f32).String
+groupBy(list, f32).add
+groupBy(list, f32).array
+groupBy(list, f32).div
+groupBy(list, f32).f32
+groupBy(list, f32).f64
+groupBy(list, f32).foo
+groupBy(list, f32).half
+groupBy(list, f32).i
+groupBy(list, f32).i32
+groupBy(list, f32).i64
+groupBy(list, f32).list
+groupBy(list, f32).ok
+groupBy(list, f32)?.Bar
+groupBy(list, f32)?.Qux
+groupBy(list, f32)?.String
+groupBy(list, f32)?.add
+groupBy(list, f32)?.array
+groupBy(list, f32)?.div
+groupBy(list, f32)?.f32
+groupBy(list, f32)?.f64
+groupBy(list, f32)?.foo
+groupBy(list, f32)?.greet
+groupBy(list, f32)?.half
+groupBy(list, f32)?.i
+groupBy(list, f32)?.i32
+groupBy(list, f32)?.i64
+groupBy(list, f32)?.list
+groupBy(list, f32)?.ok
+groupBy(list, f32)?.score
+groupBy(list, f32)[add == nil]
+groupBy(list, f32)[toJSON(true)]
+groupBy(list, f64 * 0.5)
+groupBy(list, f64 * 1)
+groupBy(list, f64 - 1)
+groupBy(list, f64 < f64)
+groupBy(list, f64)
+groupBy(list, f64).Bar
+groupBy(list, f64).Qux
+groupBy(list, f64).String
+groupBy(list, f64).add
+groupBy(list, f64).array
+groupBy(list, f64).div
+groupBy(list, f64).f32
+groupBy(list, f64).f64
+groupBy(list, f64).foo
+groupBy(list, f64).greet
+groupBy(list, f64).half
+groupBy(list, f64).i
+groupBy(list, f64).i32
+groupBy(list, f64).i64
+groupBy(list, f64).list
+groupBy(list, f64).ok
+groupBy(list, f64).score
+groupBy(list, f64)?.Bar
+groupBy(list, f64)?.Qux
+groupBy(list, f64)?.String
+groupBy(list, f64)?.add
+groupBy(list, f64)?.array
+groupBy(list, f64)?.div
+groupBy(list, f64)?.f32
+groupBy(list, f64)?.f64
+groupBy(list, f64)?.foo
+groupBy(list, f64)?.greet
+groupBy(list, f64)?.half
+groupBy(list, f64)?.i
+groupBy(list, f64)?.i32
+groupBy(list, f64)?.i64
+groupBy(list, f64)?.list
+groupBy(list, f64)?.ok
+groupBy(list, f64)?.score
+groupBy(list, false == ok)
+groupBy(list, false ? score : #)
+groupBy(list, false).Bar
+groupBy(list, false).add
+groupBy(list, false).array
+groupBy(list, false).div
+groupBy(list, false).f32
+groupBy(list, false).foo
+groupBy(list, false).greet
+groupBy(list, false).half
+groupBy(list, false).i
+groupBy(list, false).i32
+groupBy(list, false).i64
+groupBy(list, false).list
+groupBy(list, false).ok
+groupBy(list, false)?.Bar
+groupBy(list, false)?.Qux
+groupBy(list, false)?.String
+groupBy(list, false)?.add
+groupBy(list, false)?.div
+groupBy(list, false)?.f32
+groupBy(list, false)?.f64
+groupBy(list, false)?.greet
+groupBy(list, false)?.half
+groupBy(list, false)?.i
+groupBy(list, false)?.i32
+groupBy(list, false)?.i64
+groupBy(list, false)?.list
+groupBy(list, false)?.ok
+groupBy(list, false)?.score
+groupBy(list, findLastIndex(array, ok))
+groupBy(list, findLastIndex(list, false))
+groupBy(list, first(array))
+groupBy(list, float(-1))
+groupBy(list, float(0.5))
+groupBy(list, floor(i))
+groupBy(list, floor(i64))
+groupBy(list, foo != #)
+groupBy(list, foo)
+groupBy(list, foo).Bar
+groupBy(list, foo).Qux
+groupBy(list, foo).String
+groupBy(list, foo).add
+groupBy(list, foo).array
+groupBy(list, foo).div
+groupBy(list, foo).f32
+groupBy(list, foo).f64
+groupBy(list, foo).foo
+groupBy(list, foo).greet
+groupBy(list, foo).half
+groupBy(list, foo).i
+groupBy(list, foo).i32
+groupBy(list, foo).i64
+groupBy(list, foo).list
+groupBy(list, foo).ok
+groupBy(list, foo).score
+groupBy(list, foo)?.Bar
+groupBy(list, foo)?.Qux
+groupBy(list, foo)?.String
+groupBy(list, foo)?.add
+groupBy(list, foo)?.array
+groupBy(list, foo)?.div
+groupBy(list, foo)?.f32
+groupBy(list, foo)?.f64
+groupBy(list, foo)?.foo
+groupBy(list, foo)?.half
+groupBy(list, foo)?.i
+groupBy(list, foo)?.i32
+groupBy(list, foo)?.i64
+groupBy(list, foo)?.list
+groupBy(list, foo)?.ok
+groupBy(list, foo)?.score
+groupBy(list, foo)[i32]
+groupBy(list, foo.Bar)
+groupBy(list, foo.String())
+groupBy(list, foo?.String())
+groupBy(list, greet != greet)
+groupBy(list, greet("bar"))
+groupBy(list, i * i)
+groupBy(list, i / f64)
+groupBy(list, i <= i)
+groupBy(list, i ^ i)
+groupBy(list, i)
+groupBy(list, i).Bar
+groupBy(list, i).Qux
+groupBy(list, i).String
+groupBy(list, i).add
+groupBy(list, i).array
+groupBy(list, i).div
+groupBy(list, i).f32
+groupBy(list, i).f64
+groupBy(list, i).foo
+groupBy(list, i).half
+groupBy(list, i).i
+groupBy(list, i).i32
+groupBy(list, i).i64
+groupBy(list, i).list
+groupBy(list, i).ok
+groupBy(list, i).score
+groupBy(list, i)?.Bar
+groupBy(list, i)?.Qux
+groupBy(list, i)?.String
+groupBy(list, i)?.add
+groupBy(list, i)?.array
+groupBy(list, i)?.div
+groupBy(list, i)?.f32
+groupBy(list, i)?.f64
+groupBy(list, i)?.foo
+groupBy(list, i)?.greet
+groupBy(list, i)?.half
+groupBy(list, i)?.i
+groupBy(list, i)?.i32
+groupBy(list, i)?.i64
+groupBy(list, i)?.list
+groupBy(list, i)?.ok
+groupBy(list, i)?.score
+groupBy(list, i32 != f32)?.foo
+groupBy(list, i32 * 0.5)
+groupBy(list, i32 ** 0.5)
+groupBy(list, i32 ** f32)
+groupBy(list, i32 > i)
+groupBy(list, i32 ^ i)
+groupBy(list, i32)
+groupBy(list, i32).Bar
+groupBy(list, i32).Qux
+groupBy(list, i32).add
+groupBy(list, i32).array
+groupBy(list, i32).div
+groupBy(list, i32).f32
+groupBy(list, i32).f64
+groupBy(list, i32).foo
+groupBy(list, i32).greet
+groupBy(list, i32).half
+groupBy(list, i32).i
+groupBy(list, i32).i32
+groupBy(list, i32).i64
+groupBy(list, i32).list
+groupBy(list, i32).ok
+groupBy(list, i32).score
+groupBy(list, i32)?.Bar
+groupBy(list, i32)?.Qux
+groupBy(list, i32)?.String
+groupBy(list, i32)?.add
+groupBy(list, i32)?.array
+groupBy(list, i32)?.div
+groupBy(list, i32)?.f32
+groupBy(list, i32)?.f64
+groupBy(list, i32)?.foo
+groupBy(list, i32)?.greet
+groupBy(list, i32)?.half
+groupBy(list, i32)?.i
+groupBy(list, i32)?.i32
+groupBy(list, i32)?.i64
+groupBy(list, i32)?.list
+groupBy(list, i32)?.ok
+groupBy(list, i32)?.score
+groupBy(list, i64 != i32)
+groupBy(list, i64 != nil)
+groupBy(list, i64 - 0.5)
+groupBy(list, i64 < 1)
+groupBy(list, i64 <= 1)
+groupBy(list, i64 == 1)
+groupBy(list, i64 == nil)
+groupBy(list, i64)
+groupBy(list, i64).Bar
+groupBy(list, i64).Qux
+groupBy(list, i64).String
+groupBy(list, i64).add
+groupBy(list, i64).array
+groupBy(list, i64).div
+groupBy(list, i64).f32
+groupBy(list, i64).f64
+groupBy(list, i64).foo
+groupBy(list, i64).greet
+groupBy(list, i64).half
+groupBy(list, i64).i
+groupBy(list, i64).i32
+groupBy(list, i64).list
+groupBy(list, i64).ok
+groupBy(list, i64).score
+groupBy(list, i64)?.Bar
+groupBy(list, i64)?.Qux
+groupBy(list, i64)?.String
+groupBy(list, i64)?.add
+groupBy(list, i64)?.array
+groupBy(list, i64)?.div
+groupBy(list, i64)?.f32
+groupBy(list, i64)?.f64
+groupBy(list, i64)?.foo
+groupBy(list, i64)?.greet
+groupBy(list, i64)?.half
+groupBy(list, i64)?.i
+groupBy(list, i64)?.i32
+groupBy(list, i64)?.i64
+groupBy(list, i64)?.list
+groupBy(list, i64)?.ok
+groupBy(list, i64)?.score
+groupBy(list, i64)[max(i)]
+groupBy(list, i64)[ok]
+groupBy(list, int(1))
+groupBy(list, list == array)
+groupBy(list, lower("foo"))
+groupBy(list, max(f64))
+groupBy(list, max(i))
+groupBy(list, nil != #)
+groupBy(list, nil != div)
+groupBy(list, nil != true)
+groupBy(list, nil == #)
+groupBy(list, nil == #).i
+groupBy(list, nil in list)
+groupBy(list, not false)
+groupBy(list, not ok)
+groupBy(list, ok != false)
+groupBy(list, ok ? # : true)
+groupBy(list, ok)
+groupBy(list, ok).Bar
+groupBy(list, ok).Qux
+groupBy(list, ok).String
+groupBy(list, ok).add
+groupBy(list, ok).array
+groupBy(list, ok).div
+groupBy(list, ok).f32
+groupBy(list, ok).f64
+groupBy(list, ok).foo
+groupBy(list, ok).greet
+groupBy(list, ok).half
+groupBy(list, ok).i
+groupBy(list, ok).i32
+groupBy(list, ok).i64
+groupBy(list, ok).list
+groupBy(list, ok).ok
+groupBy(list, ok).score
+groupBy(list, ok)?.Bar
+groupBy(list, ok)?.Qux
+groupBy(list, ok)?.String
+groupBy(list, ok)?.add
+groupBy(list, ok)?.array
+groupBy(list, ok)?.div
+groupBy(list, ok)?.f32
+groupBy(list, ok)?.f64
+groupBy(list, ok)?.foo
+groupBy(list, ok)?.greet
+groupBy(list, ok)?.half
+groupBy(list, ok)?.i
+groupBy(list, ok)?.i32
+groupBy(list, ok)?.i64
+groupBy(list, ok)?.list
+groupBy(list, ok)?.ok
+groupBy(list, ok)?.score
+groupBy(list, reduce(array, #))
+groupBy(list, reduce(list, #)).i32
+groupBy(list, reduce(list, f64))
+groupBy(list, reduce(list, i32))
+groupBy(list, reduce(map(list, i64), #))
+groupBy(list, round(0.5))
+groupBy(list, round(1))
+groupBy(list, round(f64))
+groupBy(list, score(1))
+groupBy(list, score(i))
+groupBy(list, string(#))
+groupBy(list, string(add))
+groupBy(list, string(half))
+groupBy(list, string(i32))
+groupBy(list, string(true))
+groupBy(list, toBase64("foo"))
+groupBy(list, toJSON(#))
+groupBy(list, toJSON(1))
+groupBy(list, toJSON(array))
+groupBy(list, toJSON(foo))
+groupBy(list, true && false)
+groupBy(list, true ? # : 1)
+groupBy(list, true ? 1 : #)
+groupBy(list, true).Qux
+groupBy(list, true).String
+groupBy(list, true).add
+groupBy(list, true).array
+groupBy(list, true).div
+groupBy(list, true).f32
+groupBy(list, true).f64
+groupBy(list, true).foo
+groupBy(list, true).greet
+groupBy(list, true).half
+groupBy(list, true).i
+groupBy(list, true).i32
+groupBy(list, true).i64
+groupBy(list, true).list
+groupBy(list, true).ok
+groupBy(list, true).score
+groupBy(list, true)?.Bar
+groupBy(list, true)?.Qux
+groupBy(list, true)?.String
+groupBy(list, true)?.add
+groupBy(list, true)?.array
+groupBy(list, true)?.div
+groupBy(list, true)?.f32
+groupBy(list, true)?.f64
+groupBy(list, true)?.foo
+groupBy(list, true)?.greet
+groupBy(list, true)?.half
+groupBy(list, true)?.i
+groupBy(list, true)?.i32
+groupBy(list, true)?.i64
+groupBy(list, true)?.list
+groupBy(list, true)?.ok
+groupBy(list, true)?.score
+groupBy(list, type("foo"))
+groupBy(list, type(#))
+groupBy(list, type(false))
+groupBy(list[i32:1], i64)
+groupBy(list[i32:i32], foo)
+groupBy(list[i64:1], i32)
+groupBy(list[i:1], f64)
+groupBy(map(array, #), # <= #)
+groupBy(map(array, #), # == #)
+groupBy(map(array, #), # >= #)
+groupBy(map(array, #), #)
+groupBy(map(array, #), 0.5 < 0.5)
+groupBy(map(array, #), foo)
+groupBy(map(array, #), i)
+groupBy(map(array, #), i64)
+groupBy(map(array, #), min(1))
+groupBy(map(array, #), ok)
+groupBy(map(array, 0.5), # != 0.5)
+groupBy(map(array, 0.5), # / #)
+groupBy(map(array, 0.5), #)
+groupBy(map(array, 0.5), f64)
+groupBy(map(array, 1), 0.5 / #)
+groupBy(map(array, 1), f64)
+groupBy(map(array, 1), max(#))
+groupBy(map(array, 1), ok)
+groupBy(map(array, div), div != #)
+groupBy(map(array, f32), # - 0.5)
+groupBy(map(array, f32), min(#))
+groupBy(map(array, f64), #)
+groupBy(map(array, false), f64)
+groupBy(map(array, false), i)
+groupBy(map(array, foo), #).add
+groupBy(map(array, foo), i)
+groupBy(map(array, foo), ok)
+groupBy(map(array, i), #)
+groupBy(map(array, i32), # % i)
+groupBy(map(array, i32), #)
+groupBy(map(array, ok), i64)
+groupBy(map(list, "bar"), #)
+groupBy(map(list, "foo"), #)
+groupBy(map(list, #), "bar" == "bar")
+groupBy(map(list, #), #)
+groupBy(map(list, #), #)?.array
+groupBy(map(list, #), f32)
+groupBy(map(list, #), f64)
+groupBy(map(list, #), i32)
+groupBy(map(list, #), i64)
+groupBy(map(list, #), ok)
+groupBy(map(list, 0.5), # * i64)
+groupBy(map(list, 0.5), # ** #)
+groupBy(map(list, 0.5), #)
+groupBy(map(list, 0.5), i32)
+groupBy(map(list, 1), #)
+groupBy(map(list, 1), get(list, #)).i64
+groupBy(map(list, 1), i64)
+groupBy(map(list, f32), # ** #).array
+groupBy(map(list, f64), #)
+groupBy(map(list, f64), #).half
+groupBy(map(list, f64), f32)
+groupBy(map(list, f64), i)
+groupBy(map(list, i), #)
+groupBy(map(list, i32), # == #)
+groupBy(map(list, i64), #)?.i32
+groupBy(map(list, i64), i)
+groupBy(map(list, list), foo)
+groupBy(map(list, ok), #)
+groupBy(ok ? "foo" : greet, # <= #)
+groupBy(reduce(array, # .. i64), add)
+groupBy(reduce(array, array), foo)
+groupBy(reduce(array, array), i)
+groupBy(reduce(list, array), # / #)
+groupBy(reduce(list, array), true ? true : nil)
+groupBy(sort(array), #)
+groupBy(sort(array), foo)
+groupBy(true ? "foo" : 1, # > 0.5)
+groupBy(true ? "foo" : 1, foo)
+groupBy(true ? "foo" : false, # / #)
+groupBy(true ? "foo" : score, #)
 half
-half != add
-half != add ? ok : half
-half != div
-half != div == true
-half != foo.Qux
-half != foo.String
-half != foo?.Qux
-half != foo?.String
-half != greet
 half != half
-half != score
-half == add
-half == add ? "bar" : half
-half == div
-half == div ? add : 0.5
-half == div and 1 >= 1
-half == foo.Qux
-half == foo.String
-half == foo?.Qux
-half == foo?.String
-half == greet
-half == greet == nil
-half == greet ? ok : foo
-half == greet || ok
+half != half != nil
+half != half and "bar" in foo
+half != nil == false
+half != nil ? "bar" : div
+half != nil ? "bar" : false
+half != nil ? true : div
+half != reduce(list, half)
 half == half
-half == half && i >= 0.5
-half == half ? score : "bar"
-half == half and ok
-half == nil == true
-half == nil ? 1 : 0.5
-half == nil ? 1 : score
-half == score
-half not in [list, i64, ok]
-half not in {"bar": list, "foo": 0.5}.ok
-half(-(f32 - 0.5))
-half(--1)
+half == nil && ok
+half == nil ? array : 0.5
+half == nil ? foo : false
+half(-(0.5 + 1))
+half(-(f64 + 1))
+half(-(i64 - 0.5))
 half(-0.5)
 half(-1)
-half(-f32 ^ i)
 half(-f64)
 half(0.5 * 0.5)
 half(0.5 * 1)
@@ -6557,9 +8914,11 @@ half(0.5 ** i)
 half(0.5 ** i32)
 half(0.5 ** i64)
 half(0.5 + 0.5)
+half(0.5 + 1 + i64)
 half(0.5 + 1)
 half(0.5 + f32)
 half(0.5 + f64)
+half(0.5 + i)
 half(0.5 + i32)
 half(0.5 + i64)
 half(0.5 - 0.5)
@@ -6574,7 +8933,6 @@ half(0.5 / 1)
 half(0.5 / f32)
 half(0.5 / f64)
 half(0.5 / i)
-half(0.5 / i32)
 half(0.5 / i64)
 half(0.5 ^ 0.5)
 half(0.5 ^ 1)
@@ -6583,38 +8941,49 @@ half(0.5 ^ f64)
 half(0.5 ^ i)
 half(0.5 ^ i32)
 half(0.5 ^ i64)
-half(0.5) != f32
+half(0.5) != -i64
+half(0.5) != 0.5 ^ i
+half(0.5) != i32
 half(0.5) != i64
 half(0.5) * f32
+half(0.5) * i
+half(0.5) * i32
+half(0.5) * i64
 half(0.5) ** f32
-half(0.5) ** f64
-half(0.5) + 1 * f64
+half(0.5) ** i
+half(0.5) ** i32
+half(0.5) ** i64
+half(0.5) ** max(1)
+half(0.5) + 1 / 1
+half(0.5) + f32
 half(0.5) + f64
 half(0.5) + i32
 half(0.5) + i64
-half(0.5) - f32
-half(0.5) - f64
-half(0.5) - i
-half(0.5) - i32
+half(0.5) - i64
+half(0.5) / -0.5
+half(0.5) / f64
 half(0.5) / i
-half(0.5) / i32
 half(0.5) / i64
-half(0.5) < i32
-half(0.5) <= i
-half(0.5) == f32 != true
-half(0.5) == i
-half(0.5) == i32
+half(0.5) < f64
+half(0.5) <= f32 ? f64 : 1
+half(0.5) <= f64
+half(0.5) <= i32
+half(0.5) <= i64 + i32
+half(0.5) <= int(0.5)
+half(0.5) == f32
+half(0.5) == i32 / i
 half(0.5) == i64
+half(0.5) > f32
+half(0.5) > f64
 half(0.5) > i
-half(0.5) > i32
 half(0.5) > i64
-half(0.5) >= f32
-half(0.5) >= f64
-half(0.5) >= i
 half(0.5) >= i32
-half(0.5) >= i64
-half(0.5) ^ (i32 - 1)
+half(0.5) ^ (1 * i32)
+half(0.5) ^ f32
+half(0.5) ^ f64
+half(0.5) ^ i
 half(0.5) ^ i32
+half(0.5) ^ i64
 half(1 * 0.5)
 half(1 * 1)
 half(1 * f32)
@@ -6656,22 +9025,77 @@ half(1 ^ f32)
 half(1 ^ f64)
 half(1 ^ i)
 half(1 ^ i32)
+half(1 ^ i64)
+half(1) != f32
+half(1) != f64
+half(1) != f64 ** f32
+half(1) != f64 ^ 0.5
+half(1) != i32
+half(1) != i64
+half(1) * i32 * i64
+half(1) ** (i64 * f32)
+half(1) ** f32
+half(1) ** i
+half(1) ** i32
+half(1) ** i64
+half(1) + f32
+half(1) + f32 / 0.5
+half(1) + i
+half(1) + i32
+half(1) + i64 + i32
+half(1) - f32
+half(1) - i < i64
+half(1) - i32
+half(1) - i64
+half(1) / -1
+half(1) / 0.5 / i
+half(1) / i
+half(1) / i32
+half(1) < f64
+half(1) < i
+half(1) < i64
+half(1) <= f32
+half(1) <= i32
+half(1) <= i64
+half(1) == -1
+half(1) == 1 ^ i64
+half(1) == f32
+half(1) == i32
+half(1) > i
+half(1) > i32
+half(1) > i64
+half(1) >= f32
+half(1) >= i
+half(1) >= i32
+half(1) >= i64
+half(1) >= max(1)
+half(1) >= mean(array)
+half(1) ^ f32
+half(1) ^ findIndex(list, true)
+half(1) ^ i64
+half(1) in array
+half(1) not in array
 half(abs(0.5))
 half(abs(f64))
-half(abs(f64)) - i
+half(ceil(0.5))
+half(ceil(1))
+half(ceil(f32))
+half(ceil(f64))
+half(ceil(i))
+half(ceil(i32))
+half(ceil(i64))
 half(f32 * 0.5)
 half(f32 * 1)
 half(f32 * f64)
 half(f32 * i)
 half(f32 * i32)
-half(f32 * i64)
 half(f32 ** 0.5)
 half(f32 ** f32)
 half(f32 ** f64)
+half(f32 ** i64)
 half(f32 + 0.5)
 half(f32 + 1)
 half(f32 + f64)
-half(f32 + i)
 half(f32 + i32)
 half(f32 + i64)
 half(f32 - 0.5)
@@ -6684,84 +9108,85 @@ half(f32 / 0.5)
 half(f32 / 1)
 half(f32 / f32)
 half(f32 / f64)
+half(f32 / i)
 half(f32 / i32)
 half(f32 / i64)
 half(f32 ^ 0.5)
+half(f32 ^ 1)
 half(f32 ^ f32)
 half(f32 ^ f64)
+half(f32 ^ i)
 half(f32 ^ i32)
 half(f32 ^ i64)
 half(f64 * 0.5)
-half(f64 * 1)
 half(f64 * f32)
+half(f64 * f64)
 half(f64 * i)
 half(f64 * i32)
+half(f64 * i64)
 half(f64 ** 0.5)
 half(f64 ** 1)
 half(f64 ** f32)
-half(f64 ** f64)
 half(f64 ** i)
 half(f64 ** i32)
+half(f64 + 0.5)
 half(f64 + 1)
-half(f64 + f32)
+half(f64 + f64)
 half(f64 + i)
-half(f64 + i32)
+half(f64 + i64)
 half(f64 - 0.5)
 half(f64 - 1)
 half(f64 - f32)
 half(f64 - f64)
 half(f64 - i)
-half(f64 - i32)
 half(f64 - i64)
+half(f64 / 0.5)
 half(f64 / 1)
 half(f64 / f32)
 half(f64 / f64)
+half(f64 / i)
 half(f64 / i32)
-half(f64 / i64)
 half(f64 ^ 0.5)
 half(f64 ^ 1)
 half(f64 ^ f32)
-half(f64 ^ i)
+half(f64 ^ f64)
 half(f64 ^ i32)
-half(f64 ^ i64)
 half(f64)
-half(f64) != f32
-half(f64) != f64
+half(f64) != f64 != false
+half(f64) != i32
 half(f64) != i64
-half(f64) * f32
-half(f64) * i64
-half(f64) ** (i32 * 0.5)
-half(f64) ** 0.5 ** i
 half(f64) ** f64
-half(f64) ** i64
-half(f64) + 1 + f64
-half(f64) + f64
-half(f64) + i
+half(f64) ** i
+half(f64) ** i32
 half(f64) + i32
 half(f64) + i64
 half(f64) - f64
 half(f64) - i32
-half(f64) / f32
 half(f64) / f64
 half(f64) / i32
-half(f64) / i64
-half(f64) < f64
 half(f64) < i
 half(f64) < i32
-half(f64) < i64
-half(f64) <= 0.5 + f64
-half(f64) <= f64
-half(f64) <= i64
+half(f64) <= f32
+half(f64) <= i32
+half(f64) == f32
+half(f64) == f64
+half(f64) == i
+half(f64) == i32
 half(f64) == i64
-half(f64) > abs(i)
-half(f64) > f32 * 0.5
-half(f64) > max(i64)
-half(f64) >= f32
+half(f64) > f32
+half(f64) > f64
+half(f64) > i
+half(f64) > i32
+half(f64) > i64
 half(f64) >= i
 half(f64) >= i64
-half(f64) ^ f32
-half(false ? 0.5 : 0.5)
-half(float(-f64))
+half(f64) ^ i
+half(f64) not in array
+half(false ? f64 : 0.5)
+half(false ? i32 : 0.5)
+half(false ? ok : 0.5)
+half(false ? score : 0.5)
+half(false ? true : f64)
 half(float(0.5))
 half(float(1))
 half(float(f32))
@@ -6769,37 +9194,43 @@ half(float(f64))
 half(float(i))
 half(float(i32))
 half(float(i64))
-half(greet == div ? "bar" : 0.5)
+half(floor(0.5))
+half(floor(1))
+half(floor(f32))
+half(floor(f64))
+half(floor(i))
+half(floor(i32))
+half(floor(i64))
 half(half(0.5))
+half(half(1))
+half(half(ceil(i)))
+half(half(f64 - 0.5))
 half(half(f64))
-half(half(i - 0.5))
 half(i * 0.5)
 half(i * 1)
-half(i * f32)
 half(i * f64)
 half(i ** 0.5)
 half(i ** 1)
 half(i ** f32)
 half(i ** f64)
 half(i ** i)
+half(i ** i32)
 half(i ** i64)
 half(i + 0.5)
 half(i + 1)
 half(i + f32)
 half(i + f64)
-half(i - 0.5)
 half(i - 1)
+half(i - f32)
 half(i - f64)
 half(i / 0.5)
 half(i / 1)
-half(i / f32)
 half(i / f64)
 half(i / i)
 half(i / i32)
-half(i / i64)
 half(i ^ 0.5)
 half(i ^ 1)
-half(i ^ f32)
+half(i ^ i)
 half(i ^ i32)
 half(i ^ i64)
 half(i32 * 0.5)
@@ -6808,2450 +9239,2668 @@ half(i32 * f32)
 half(i32 * f64)
 half(i32 ** 0.5)
 half(i32 ** 1)
-half(i32 ** f32)
 half(i32 ** f64)
 half(i32 ** i)
 half(i32 ** i32)
 half(i32 ** i64)
 half(i32 + 0.5)
 half(i32 + 1)
+half(i32 + f32)
 half(i32 + f64)
 half(i32 - 0.5)
 half(i32 - 1)
 half(i32 - f32)
-half(i32 - f64)
 half(i32 / 0.5)
 half(i32 / 1)
 half(i32 / f32)
 half(i32 / f64)
 half(i32 / i)
+half(i32 / i32 / f32 / f64)
 half(i32 / i32)
 half(i32 / i64)
 half(i32 ^ 0.5)
 half(i32 ^ 1)
 half(i32 ^ f32)
+half(i32 ^ f64)
 half(i32 ^ i)
 half(i32 ^ i32)
+half(i32 ^ i64 ^ i)
 half(i32 ^ i64)
+half(i64 != i ? true : 0.5)
 half(i64 * 0.5)
 half(i64 * 1)
 half(i64 * f64)
 half(i64 ** 0.5)
 half(i64 ** 1)
-half(i64 ** f32)
 half(i64 ** f64)
+half(i64 ** i)
+half(i64 ** i32)
 half(i64 ** i64)
 half(i64 + 0.5)
-half(i64 + 1)
 half(i64 + f32)
 half(i64 + f64)
 half(i64 - 0.5)
 half(i64 - 1)
 half(i64 - f32)
+half(i64 - f64)
 half(i64 / 0.5)
 half(i64 / 1)
 half(i64 / f32)
 half(i64 / f64)
 half(i64 / i)
 half(i64 / i32)
-half(i64 / i64)
 half(i64 ^ 0.5)
 half(i64 ^ 1)
 half(i64 ^ f32)
 half(i64 ^ f64)
+half(i64 ^ i)
 half(i64 ^ i32)
-half(i64 ^ i64)
 half(max(0.5))
-half(max(0.5, f32))
+half(max(0.5)) ** i
 half(max(f64))
+half(mean(array))
+half(median(array))
 half(min(0.5))
-half(min(0.5, 0.5))
-half(min(1, 0.5, 1))
+half(min(0.5, f32))
+half(min(0.5, i32))
 half(min(f64))
-half(ok ? 0.5 : f32)
-half(ok ? 0.5 : false)
-half(ok ? 0.5 : foo)
-half(true ? 0.5 : 0.5)
-hasPrefix("bar", "foo") != ok
-hasSuffix("foo", "foo") or 0.5 <= i
+half(min(i, 0.5))
+half(reduce(array, 0.5))
+half(reduce(array, f64))
+half(reduce(list, 0.5))
+half(reduce(list, f64))
+half(round(0.5))
+half(round(1))
+half(round(f32))
+half(round(f64))
+half(round(i))
+half(round(i32))
+half(round(i64))
+half(score(1) ^ i64)
+half(true ? 0.5 : i64)
+half(true ? f64 : nil)
 i
 i != -0.5
 i != -1
 i != -f32
 i != -f64
 i != -i
-i != -i64
-i != 0.5 / 0.5
-i != 0.5 == ok
-i != 0.5 ? 1 : array
-i != 0.5 ? i32 : 0.5
-i != 0.5 ? score : score
-i != 1 % i64
-i != 1 * i
-i != 1 + 1
-i != 1 - 0.5
-i != 1 - 1
-i != 1 - i64
-i != 1 == ok
-i != 1 ? ok : i64
-i != 1 or i64 != 1
+i != -i32
+i != 0.5 + 0.5
+i != 0.5 - 1
+i != 0.5 / 1
+i != 0.5 ? 1 : div
+i != 0.5 ? false : i32
+i != 0.5 ^ 0.5
+i != 0.5 ^ 1
+i != 0.5 ^ f32
+i != 1 != nil
+i != 1 / 1
+i != 1 ? f64 : score
+i != ceil(1)
+i != ceil(f32)
+i != ceil(i64)
 i != f32
-i != f32 + i
-i != f32 / 1
-i != f32 ? div : list
+i != f32 ** i64
+i != f32 + i64
+i != f32 == ok
 i != f64
-i != f64 * 0.5
-i != f64 + 1
-i != f64 / 0.5
-i != f64 ? 0.5 : nil
-i != f64 ? array : div
-i != f64 ? half : 1
-i != f64 || ok
-i != first(array)
-i != float(1)
-i != float(f32)
-i != float(f64)
+i != f64 + i32
+i != f64 == true
+i != f64 ^ f32
+i != f64 ^ i64
+i != float(0.5)
+i != float(i)
 i != half(0.5)
+i != half(f64)
 i != i
-i != i != nil
-i != i ^ f64
+i != i * 1
+i != i * i32
+i != i - i32
+i != i ? i : false
 i != i32
-i != i32 % i32
-i != i32 * f64
-i != i32 - i64
-i != i32 / i64
-i != i32 ? 1 : i
-i != i32 ? list : i
-i != i32 || half != nil
+i != i32 != nil ? greet : score
+i != i32 * 0.5
+i != i32 * f32
+i != i32 and ok
 i != i64
-i != i64 - f32
-i != i64 ? true : "foo"
-i != i64 ^ f64
+i != i64 ** i
+i != i64 ? add : i64
+i != i64 ? f32 : nil
+i != i64 ^ 1
 i != int(1)
-i != max(i32)
-i != min(1)
-i != nil != true
-i != nil ? ok : "bar"
+i != min(i64)
+i != nil != ok
+i != nil ? ok : f64
+i != reduce(array, #)
+i != reduce(array, 0.5)
+i != reduce(list, 1)
+i != round(f64)
+i != score(1)
 i != score(i)
+i != {"foo": score}?.f32
+i % (1 + i32)
+i % (i32 + i32)
+i % (i64 + 1)
 i % -1
 i % -i
 i % -i32
-i % -i64
-i % 1 != i64
-i % 1 .. i32
-i % 1 / i
+i % 1 % i32
+i % 1 % i64
+i % 1 * i32
+i % 1 + i64
+i % 1 .. i
+i % 1 / 0.5
+i % 1 / f32
+i % 1 <= i64
 i % 1 >= i
-i % 1 >= i32
-i % array[i]
-i % first(array)
-i % get(array, i64)
+i % abs(1)
+i % abs(i)
+i % array[1]
+i % array[i64]
 i % i
-i % i % i32
-i % i + i32
-i % i == i
-i % i in array
+i % i / i
 i % i32
+i % i32 != i32
+i % i32 * 1
+i % i32 * f64
 i % i32 / i32
-i % i32 <= f32
+i % i32 <= f64
 i % i64
-i % i64 != i
-i % int(i64)
-i % len(array)
-i % score(1)
+i % i64 != i ? f64 : list
+i % i64 <= i
+i % min(1)
+i % min(i64)
+i % reduce(array, #)
 i % score(i)
-i * (0.5 + 0.5)
-i * (f32 + f32)
-i * (i32 + 0.5)
-i * (i32 - f64)
-i * (i64 + 1)
-i * -1
-i * -f32
-i * -i
+i * (1 + 1)
+i * (f32 + 0.5)
+i * (f32 + 1)
+i * (f64 + i)
+i * (f64 - i32)
+i * -i32
 i * -i64
 i * 0.5 * f64
 i * 0.5 + i
-i * 0.5 - i
-i * 0.5 < i
-i * 0.5 <= i64 ** f64
-i * 1 % i
-i * 1 ** i32
-i * 1 / f64
-i * 1 / i64
-i * 1 <= f32
-i * abs(0.5)
-i * add(1, 1)
-i * array[i32]
+i * 0.5 / i
+i * 0.5 < i32
+i * 0.5 > i32 * f32
+i * 0.5 ^ 1
+i * 1 % i64
+i * 1 ** 1
+i * 1 < f64
+i * 1 < i32
+i * 1 == i32
+i * bitnand(i64, i64)
+i * bitnot(i64)
+i * ceil(1)
 i * f32
-i * f32 != f32
-i * f32 ** 0.5
-i * f32 >= f32
+i * f32 <= f64
+i * f32 ^ 0.5
+i * f32 ^ 1
 i * f32 ^ f32
 i * f64
-i * f64 * 1
-i * float(f64)
+i * f64 != i
+i * f64 * f32 > i
+i * f64 * i
+i * f64 ** i32
+i * float(f32)
+i * floor(f32)
+i * floor(i)
+i * floor(i32)
+i * floor(i64)
+i * half(0.5)
+i * half(1)
 i * half(f64)
 i * i
-i * i != i64
-i * i / f32
-i * i / f64
-i * i / i32
-i * i / i64
+i * i % i
+i * i * 0.5
+i * i * f32
+i * i ** 0.5
+i * i - f32
+i * i .. i
+i * i == f32
 i * i32
-i * i32 ** f64
-i * i32 ** i32
-i * i32 - i
-i * i32 / i32
-i * i32 <= i32
+i * i32 * i
+i * i32 .. i32
+i * i32 / min(1)
+i * i32 == f32
+i * i32 in array
 i * i64
-i * i64 % i32
-i * i64 * 0.5
-i * i64 + f32
-i * i64 >= i32
-i * i64 ^ i64
-i * int(f64)
-i * int(i)
-i * int(i64)
-i * max(0.5)
-i * min(i64)
+i * i64 < f64
+i * int(1)
+i * max(1)
+i * max(f64, f32)
+i * max(i)
+i * min(f64, i)
+i * reduce(array, #)
 i * score(1)
-i ** (0.5 + f64)
-i ** (0.5 + i64)
-i ** (1 * 1)
-i ** (1 - 0.5)
-i ** (i32 % i64)
-i ** (i32 - 1)
+i * score(i)
+i * sum(array)
+i ** (0.5 * f64)
+i ** (0.5 + 0.5)
+i ** (0.5 - 1)
+i ** (0.5 - f64)
+i ** (0.5 / i32)
+i ** (f32 + 0.5)
+i ** (f32 + f32)
+i ** (i * 0.5)
+i ** (i * 1)
+i ** (i + f64)
+i ** (i - i32 + i32)
+i ** (i32 - i64)
+i ** (i32 / 1)
+i ** (i64 - 0.5)
 i ** -0.5
-i ** -i
+i ** -1
+i ** -f32
 i ** -i32
 i ** -i64
-i ** 0.5 ** 0.5
-i ** 0.5 ** 1
+i ** 0.5 ** f32
+i ** 0.5 ** reduce(array, #)
+i ** 0.5 < bitnot(i64)
 i ** 0.5 < f32
-i ** 0.5 <= i64 ^ i32
-i ** 1 != f64
+i ** 0.5 < f64
+i ** 0.5 <= i64
+i ** 0.5 ^ i
+i ** 0.5 ^ i64
 i ** 1 ** 1
-i ** 1 ** f64
-i ** 1 ** i
-i ** 1 == f32
+i ** 1 / i
+i ** 1 < -f32
+i ** 1 >= f64
+i ** 1 ^ i
+i ** 1 ^ i32
+i ** abs(0.5)
+i ** array[i64]
+i ** bitnand(i32, 1)
+i ** bitshl(i64, i32)
+i ** ceil(1)
 i ** f32
-i ** f32 ** 0.5
-i ** f32 ** f64
-i ** f32 + f64
-i ** f32 <= f32
-i ** f32 <= i32 ? 1 : f32
-i ** f32 >= float(i64)
+i ** f32 * i32
+i ** f32 ** 1
+i ** f32 ^ f64
+i ** f32 ^ i64
 i ** f64
-i ** f64 != f64
-i ** f64 < 1 / 0.5
-i ** float(0.5)
-i ** float(f32)
-i ** float(i32)
+i ** f64 != i32
+i ** f64 ** f64
+i ** f64 > i64 ? 1 : ok
+i ** f64 >= i
+i ** first(array)
+i ** floor(f64)
+i ** half(1)
 i ** half(f64)
+i ** half(i + f32)
 i ** i
-i ** i + f64
-i ** i <= i
-i ** i ^ i
+i ** i != i == ok
+i ** i ^ 0.5
 i ** i32
-i ** i32 != i
-i ** i32 != i32
-i ** i32 + i32
+i ** i32 == f32
+i ** i32 > i64
 i ** i64
-i ** i64 ** 1
-i ** i64 ** f64
-i ** i64 ** i64
-i ** i64 - f64
+i ** i64 ** i
+i ** i64 < i
+i ** i64 == i32
 i ** i64 >= i
-i ** i64 >= i32
-i ** i64 ^ 1
-i ** int(1)
-i ** max(f32)
-i ** min(0.5, 1)
-i ** min(f32)
-i ** min(i)
+i ** i64 ^ i64
+i ** i64 not in array
+i ** len("foo")
+i ** len(array)
+i ** min(1)
 i ** min(i32)
+i ** reduce(array, #)
 i ** score(1)
+i ** score(i)
+i + -0.5
 i + -1
 i + -f32
 i + -f64
-i + -i
-i + 0.5 != i
-i + 0.5 ** i32
-i + 0.5 - i
-i + 0.5 < 1 + f32
-i + 0.5 <= i32
-i + 0.5 > f32
-i + 1 / array[i32]
+i + 0.5 ** 0.5
+i + 0.5 + i
+i + 0.5 / 1
+i + 1 + f32
 i + 1 / f32
-i + 1 <= f32
-i + 1 > i64
-i + 1 >= f64
-i + array[i32]
-i + count(list, false)
+i + 1 > f64
+i + 1 ^ 1
+i + 1 ^ f32
+i + abs(0.5)
+i + array[i64]
+i + array[i]
+i + count(list, true)
 i + f32
-i + f32 != f64
-i + f32 * i
 i + f32 ** i
+i + f32 / f64
+i + f32 / i32
+i + f32 < i64
 i + f64
-i + f64 <= i64
-i + f64 == f64
+i + f64 - i32
+i + f64 < i64
+i + f64 == i32
+i + f64 > f64
 i + float(0.5)
-i + float(f32)
-i + get(array, i64)
-i + half(0.5)
+i + float(i32)
+i + get(array, i)
+i + half(1)
 i + half(f64)
 i + i
-i + i + f32
-i + i - i32
+i + i * i64
+i + i ^ 1
 i + i32
-i + i32 != i64
-i + i32 - 0.5
+i + i32 .. -i64
 i + i32 .. i
-i + i32 > f32
+i + i32 <= f32
+i + i32 == i64
+i + i32 > min(i)
+i + i32 >= i32 == nil
+i + i32 in array
 i + i64
-i + i64 + f64
-i + i64 ^ 1
+i + i64 - f64
+i + i64 / 0.5
+i + i64 / f64
+i + i64 > f32
 i + int(f32)
-i + int(i64)
-i + last(array)
 i + len("bar")
-i + max(0.5)
-i + max(f32)
+i + reduce(array, #)
+i + reduce(array, f32)
+i + reduce(list, i32)
+i + score(i)
+i - -0.5
 i - -1
 i - -f32
-i - -i
+i - -f64
 i - -i64
-i - 0.5 * 0.5
-i - 0.5 * 1
-i - 0.5 / 1
-i - 1 * 1
-i - 1 * i32
-i - 1 - i
+i - 0.5 + i64
+i - 0.5 - 1
+i - 0.5 < f64
+i - 0.5 > i
+i - 0.5 not in array
+i - 1 + i
+i - 1 - i64
+i - 1 .. i64
+i - 1 < i32
+i - 1 <= f64
+i - 1 <= i
+i - 1 > 0.5 - 0.5
 i - 1 ^ 0.5
-i - 1 ^ i32
-i - abs(0.5)
-i - abs(f32)
-i - abs(i32)
+i - bitxor(i, i)
+i - ceil(f64)
 i - f32
-i - f32 * i32
-i - f32 ** 1
-i - f32 + f64
-i - f32 - 1
-i - f32 / 0.5
-i - f32 / f32
-i - f32 / i32
-i - f32 ^ i64
+i - f32 * f32
+i - f32 - i32
+i - f32 / i
+i - f32 ^ 0.5
 i - f64
-i - findIndex(list, ok)
-i - half(0.5)
+i - f64 + i32
+i - f64 + i32 - f64
+i - f64 / i32
+i - f64 ^ i64
+i - find(array, true)
+i - float(0.5)
+i - floor(1)
+i - half(f64)
 i - i
-i - i * 1
-i - i < i + f64
-i - i <= i
-i - i <= i32
-i - i >= f32
-i - i not in array
+i - i + f32
 i - i32
-i - i32 > len(array)
-i - i32 ^ 0.5
+i - i32 + 0.5
+i - i32 - f32
+i - i32 - i32
 i - i64
-i - i64 ** 1
-i - i64 + i32
-i - i64 - 1 / 1
-i - i64 - f64
-i - int(1)
-i - int(f32)
-i - int(i)
-i - last(array)
-i - max(0.5)
+i - i64 .. i32
+i - i64 / i
+i - i64 <= i32
+i - i64 ^ f32
+i - i64 ^ f64
+i - int(i32)
 i - max(i64)
-i - min(f32)
+i - median(array)
+i - round(i32)
 i - score(1)
-i - score(i)
+i .. -i
 i .. -i32
-i .. 1 % i32
-i .. 1 == array
+i .. -i64
 i .. abs(1)
-i .. abs(i32)
 i .. i
-i .. i % 1
 i .. i32
-i .. i32 == array
 i .. i64
-i .. i64 + i
-i .. i64 == list
-i .. int(i64)
-i .. last(array)
-i .. len(list)
-i .. min(1)
+i .. i64 * 1
+i .. i64 + 1
+i .. int(0.5)
+i .. max(1)
+i .. max(i)
+i .. min(i)
+i .. reduce(list, i64)
+i .. score(1)
 i .. score(i)
-i / (f32 + f64)
-i / (f64 + f32)
-i / (i32 + f32)
-i / -0.5
+i / (0.5 + 1)
+i / (0.5 + f64)
+i / (0.5 + i)
+i / (0.5 - f32)
+i / (i + f32)
 i / -1
+i / -f32
+i / -f64
 i / -i32
-i / -i64
-i / 0.5 * f32
+i / 0.5 * 1
 i / 0.5 * f64
-i / 0.5 ** f32
-i / 0.5 / i32
-i / 0.5 < i64
-i / 0.5 <= i64
-i / 0.5 == 0.5 - f64
-i / 0.5 >= i64
-i / 1 ** 1
-i / 1 / i64
-i / 1 == f64
-i / 1 ^ 1
-i / 1 ^ i64
-i / abs(i64)
+i / 0.5 / f64
+i / 0.5 == nil != false
+i / 0.5 >= f32
+i / 0.5 ^ i32
+i / 1 ** i32
+i / 1 <= i64
+i / 1 > i
+i / abs(i)
+i / bitnot(i64)
+i / count(array, false)
 i / f32
-i / f32 != f32
-i / f32 ** i64
-i / f32 / i
+i / f32 != i64 ? 1 : list
+i / f32 >= len(array)
 i / f64
-i / f64 * f32
-i / f64 - f32
-i / float(i32)
-i / half(0.5)
-i / half(f64)
+i / f64 * f64
+i / f64 ^ i32
+i / float(0.5)
+i / float(1)
+i / float(f64)
+i / floor(1)
+i / floor(i32)
 i / i
-i / i != i64
-i / i > i32
-i / i > i64
+i / i ** 1
+i / i / i
+i / i < i32
+i / i ^ 1
 i / i32
-i / i32 - i
-i / i32 / i
-i / i32 / i64
-i / i32 ^ f32
+i / i32 / 1
 i / i64
-i / i64 != i
-i / i64 ** f32
-i / i64 < i % 1
-i / i64 >= i32 ? div : div
-i / len("bar")
-i / len(list)
-i / max(1 / i)
-i / min(0.5)
-i / min(f64)
-i / min(i32)
+i / i64 * f32
+i / i64 / f64
+i / max(0.5)
+i / mean(array)
+i / min(f32)
+i / min(i64)
 i / score(1)
-i / score(i)
-i < -(f32 - 1)
-i < -1
-i < -f32
-i < -i
+i < -(f32 * 1)
+i < --f64
 i < -i32
-i < 0.5 != false
-i < 0.5 != ok
-i < 0.5 * i
-i < 0.5 + 0.5
+i < -i64
+i < 0.5 != nil
+i < 0.5 + f64
 i < 0.5 == ok
-i < 0.5 ? "bar" : "bar"
-i < 0.5 ? f32 : array
-i < 0.5 ? f32 : half
-i < 1 * 1
-i < 1 ** f32
-i < 1 == ok
-i < 1 ? false : nil
-i < abs(f64)
+i < 1 / 0.5
+i < 1 == nil
+i < 1 ? array : score
+i < 1 ^ i64
+i < abs(i32)
 i < f32
-i < f32 * i
-i < f32 ^ f32
+i < f32 && ok
+i < f32 * 0.5
+i < f32 * i64
+i < f32 ** i
+i < f32 ** i32
+i < f32 + 1
+i < f32 + array[i64]
+i < f32 / 0.5
+i < f32 ? "bar" : div
+i < f32 || ok
 i < f64
-i < f64 * f64
-i < findIndex(list, ok)
-i < half(f32 ^ i64)
+i < f64 - 1
+i < float(f64)
+i < floor(f32)
+i < half(0.5)
+i < half(1)
 i < half(f64)
 i < i
-i < i % 1
-i < i / 1
-i < i ? i32 : add
-i < i ^ 0.5
-i < i ^ i32
+i < i != true
+i < i ** 1
+i < i / i64
+i < i ? score : list
 i < i32
-i < i32 ** 0.5
-i < i32 - f32
-i < i32 == nil
+i < i32 * f32
+i < i32 + 1
 i < i64
-i < i64 && ok
-i < i64 - f64
-i < i64 - i32
-i < i64 ? nil : "foo"
-i < i64 ^ 0.5
-i < int(0.5)
-i < int(i64)
-i < len(array)
-i < len(list)
-i < min(i64)
-i < score(1)
-i < score(i)
-i <= -f32
+i < i64 ^ f32
+i < max(0.5)
+i < reduce(array, #)
+i <= -0.5
+i <= -1
+i <= -f64
 i <= -i
+i <= -i32
 i <= -i64
-i <= 0.5 ** 0.5
-i <= 0.5 ** f32
-i <= 0.5 == nil
-i <= 0.5 ? score : array
-i <= 1 != all(array, true)
+i <= 0.5 * f32
+i <= 0.5 + 0.5
+i <= 0.5 / 1
+i <= 0.5 / f64
+i <= 0.5 == ok
+i <= 0.5 ? i : ok
+i <= 0.5 ? nil : i32
+i <= 0.5 ^ f32
 i <= 1 != nil
-i <= 1 % i
-i <= 1 + 1
-i <= 1 - f64
-i <= 1 ? ok : 1
-i <= abs(1)
-i <= abs(i32)
-i <= add(1, 1)
+i <= 1 && ok
+i <= 1 * 0.5
+i <= 1 ** i
+i <= 1 + f64
+i <= 1 - f32
+i <= 1 ? 0.5 : f32
+i <= 1 ? 0.5 : list
+i <= 1 ? list : div
+i <= 1 ^ f32
+i <= abs(0.5)
+i <= ceil(1)
 i <= f32
-i <= f32 != nil
-i <= f32 * 0.5
-i <= f32 / f32
-i <= f32 ? ok : 1
-i <= f32 or ok
+i <= f32 - 0.5
+i <= f32 ? array : nil
 i <= f64
-i <= f64 * 1
-i <= f64 == nil
-i <= f64 ? foo : div
-i <= f64 or add == greet
-i <= float(f64)
-i <= float(i)
-i <= float(i32)
-i <= half(-1)
-i <= half(0.5)
+i <= float(0.5)
+i <= float(f32)
+i <= half(1)
+i <= half(f64)
 i <= i
-i <= i ** 1
-i <= i == true
+i <= i != nil
+i <= i * f32
+i <= i ** f64
+i <= i - 0.5
+i <= i - 1
+i <= i / i
+i <= i ^ 1
 i <= i32
-i <= i32 - f32
-i <= i32 - i64
+i <= i32 - f64
+i <= i32 - i
+i <= i32 == ok
+i <= i32 ? array : false
+i <= i32 ? greet : foo
+i <= i32 || false ? f32 : i32
 i <= i64
-i <= i64 % i32
-i <= i64 / 1
-i <= i64 ? ok : 1
-i <= int(1)
-i <= int(i32)
-i <= len("bar")
-i <= len(array)
-i <= max(i)
-i <= min(f32)
-i <= min(f64)
-i <= min(i)
-i <= min(i64)
-i == -0.5
-i == -1
+i <= i64 * i
+i <= i64 + f64
+i <= len(list)
+i <= max(0.5)
+i <= max(f32, i32)
+i <= round(f32)
+i <= round(i32)
+i <= score(1)
 i == -f32
 i == -f64
 i == -i
 i == -i32
 i == -i64
-i == 0.5 + f32
-i == 0.5 - i32
+i == 0.5 ** f64
 i == 0.5 == ok
-i == 0.5 ? false : true
-i == 0.5 ? list : i32
-i == 0.5 ^ 0.5
-i == 1 != true
-i == 1 % i
-i == 1 * f32
-i == 1 ** 1
-i == 1 ? foo : list
-i == 1 || ok
-i == abs(0.5)
-i == abs(1)
-i == div(1, i)
+i == 0.5 ? "foo" : f64
+i == 1 * 0.5
+i == 1 ** i64
+i == 1 / 0.5
+i == 1 / f32
+i == 1 ? f32 : 1
+i == 1 ? f64 : f64
+i == 1 ? greet : score
+i == abs(i64)
+i == bitnot(1)
 i == f32
-i == f32 * i64
+i == f32 + i
+i == f32 == nil
+i == f32 ? foo : foo
+i == f32 ^ i32
 i == f64
-i == f64 != nil
-i == f64 + i64
-i == f64 == ok
+i == f64 + i32
+i == f64 - i
+i == f64 ? i64 : div
+i == f64 ? score : foo
+i == f64 and ok
+i == findIndex(list, true)
+i == float(0.5)
+i == floor(f32)
+i == floor(i32)
+i == half(0.5)
+i == half(f64)
 i == i
-i == i - f64
-i == i / i32
-i == i ? ok : score
-i == i ^ i
+i == i + 0.5
+i == i - i32
+i == i == true
+i == i ? add : i32
+i == i ? i32 : add
+i == i and ok
 i == i32
-i == i32 ** f32
-i == i32 ** i
-i == i32 ? list : foo
+i == i32 * 0.5
+i == i32 ** 0.5
+i == i32 + 0.5
+i == i32 + i64
+i == i32 ^ f32
 i == i64
-i == i64 != ok
-i == i64 + i32
-i == i64 ? array : 0.5
-i == i64 ? score : 1
-i == i64 ^ f64
-i == int(f64)
-i == len(array)
-i == max(0.5)
-i == max(i64)
-i == min(i)
-i == nil ? false : 1
+i == i64 * 0.5
+i == i64 * f32
+i == i64 ** 0.5
+i == i64 == nil
+i == i64 == ok
+i == i64 ? list : div
+i == len("bar")
+i == nil ? 0.5 : div
+i == nil ? div : i32
+i == nil and add != nil
+i == reduce(array, #)
+i == reduce(array, 0.5)
 i == score(1)
-i > -i64
-i > 0.5 * f64
-i > 0.5 ** 0.5
-i > 0.5 / 0.5
-i > 0.5 / 1
-i > 0.5 == nil
-i > 0.5 ^ 0.5
-i > 1 ? greet : "bar"
-i > 1 ? greet : f64
-i > abs(i64)
-i > array[i]
+i == score(i)
+i > -f32
+i > -f64
+i > -i
+i > -i32
+i > 0.5 - 0.5
+i > 0.5 ^ i64
+i > 0.5 or ok
+i > 0.5 || ok
+i > 1 != ok
+i > 1 % i64
+i > 1 ** i32
+i > 1 == ok
+i > 1 ? greet : nil
+i > 1 ? score : 0.5
+i > 1 ? true : greet
+i > bitnot(1)
+i > bitor(1, i32)
+i > count(array, true)
 i > f32
+i > f32 ** i32
+i > f32 - f64
+i > f32 ^ 1
 i > f64
-i > f64 + 0.5
-i > float(1)
-i > half(f64)
+i > f64 != ok
+i > f64 * 1
+i > f64 * f32
+i > f64 ** i32
+i > f64 ? foo : array
+i > f64 ? greet : "bar"
+i > first(array)
+i > floor(f64)
 i > i
-i > i ** i32
-i > i ** i64
-i > i / i
-i > i or ok
+i > i % i32
+i > i ** i
+i > i + i
+i > i ? f32 : i32
 i > i32
-i > i32 ? 1 : true
-i > i32 ? foo : score
-i > i32 ^ i
+i > i32 * 1
+i > i32 * i32
+i > i32 + 1
+i > i32 == ok
 i > i64
-i > int(0.5)
-i > int(i)
-i > int(i32)
-i > max(f32)
-i > max(i)
-i > min(0.5)
-i > score(i)
-i > score(len(array))
+i > i64 && f32 < 0.5
+i > i64 + 0.5
+i > i64 - 0.5
+i > i64 - i
+i > int(f32)
+i > len("bar")
+i > reduce(list, i32)
 i >= -0.5
 i >= -1
+i >= -f32
+i >= -i
 i >= -i32
 i >= -i64
-i >= 0.5 ** f64
-i >= 0.5 + i32
-i >= 0.5 - 1
-i >= 0.5 == nil
-i >= 0.5 ? div : i
-i >= 0.5 ? score : f64
-i >= 1 / i
-i >= 1 ? nil : 0.5
-i >= abs(0.5)
-i >= abs(i64)
+i >= 0.5 / 1
+i >= 0.5 ? i64 : array
+i >= 0.5 ? nil : ok
+i >= 0.5 ^ i
+i >= 1 * i64
+i >= 1 + f32
+i >= 1 == nil
+i >= 1 ? f32 : nil
+i >= 1 ? ok : false
+i >= 1 ^ f64
+i >= bitnot(i)
 i >= f32
-i >= f32 ** f64
-i >= f32 - i
-i >= f32 ? "bar" : array
-i >= f32 ? score : half
+i >= f32 ? f32 : i
+i >= f32 ? true : list
 i >= f64
-i >= f64 * i32
-i >= f64 + i32
-i >= f64 - i
+i >= f64 * 0.5
+i >= f64 - 1
+i >= first(array)
+i >= float(0.5)
+i >= float(1)
+i >= get(array, i64)
+i >= half(f64)
 i >= i
-i >= i ** 0.5
-i >= i / 1
-i >= i / i
-i >= i == nil
-i >= i == ok
+i >= i * 1
+i >= i ** f32
+i >= i ? foo : div
 i >= i32
-i >= i32 ** 0.5
-i >= i32 - f64
-i >= i32 ? f64 : div
+i >= i32 ** i64
+i >= i32 ? f32 : div
+i >= i32 ^ 1
 i >= i64
-i >= i64 * i
-i >= i64 ^ 0.5
-i >= int(i32)
-i >= len("foo")
-i >= min(f32 ^ i64)
+i >= int(0.5)
+i >= min(0.5)
+i >= reduce(array, f64)
+i >= reduce(array, i)
+i >= reduce(list, 1)
+i >= round(1)
+i >= score(1)
 i >= score(i)
-i ^ (0.5 * 1)
-i ^ (0.5 - 0.5)
-i ^ (f32 * 1)
-i ^ (f32 * f32)
-i ^ (f32 * f64)
-i ^ (f32 / f64)
-i ^ (i * 1)
-i ^ (i - i64)
-i ^ (i32 % 1)
-i ^ (i32 + i)
-i ^ (i32 / 0.5)
-i ^ (i64 / 0.5)
-i ^ (i64 / 1)
-i ^ --f32
+i ^ (1 % i)
+i ^ (1 * f64)
+i ^ (1 - 0.5)
+i ^ (f32 - f64)
+i ^ (f64 - 1)
+i ^ (i + 0.5)
+i ^ (i + i64)
+i ^ (i - f32)
+i ^ (i32 * i32)
+i ^ (i32 + 1)
+i ^ (i32 / f32)
+i ^ (i32 / i)
+i ^ (i64 * 1)
 i ^ -1
+i ^ -f32
+i ^ -f64
 i ^ -i
-i ^ -i32
-i ^ -i64
-i ^ 0.5 != 1 + i
-i ^ 0.5 * f32
-i ^ 0.5 - i
-i ^ 0.5 / f64
-i ^ 0.5 <= f32
-i ^ 0.5 > i64
+i ^ 0.5 ** 0.5
+i ^ 0.5 + i32
+i ^ 0.5 < f64
+i ^ 0.5 < i
+i ^ 0.5 <= i64
+i ^ 0.5 > f64
+i ^ 0.5 >= f32
+i ^ 0.5 >= reduce(array, #)
 i ^ 0.5 ^ f32
-i ^ 1 != f32
-i ^ 1 * f32
-i ^ 1 ** i
-i ^ 1 - f32
-i ^ 1 / i32
-i ^ 1 ^ i64
-i ^ abs(1)
-i ^ abs(f32)
-i ^ abs(i64)
-i ^ add(1, 1)
-i ^ array[i]
+i ^ 0.5 ^ i64
+i ^ 1 * f64
+i ^ 1 / i
+i ^ 1 >= f32
+i ^ 1 ^ i
+i ^ 1 not in array
+i ^ bitnot(i64 + 1)
+i ^ bitnot(min(i))
+i ^ ceil(0.5)
 i ^ f32
-i ^ f32 != 1 - i
-i ^ f32 != i64 ? list : i32
-i ^ f32 + f64
-i ^ f32 / i
+i ^ f32 ** 1
 i ^ f32 < i
-i ^ f32 >= i32
+i ^ f32 <= -f32
 i ^ f64
-i ^ f64 * i
-i ^ f64 >= f64
-i ^ find(array, true)
-i ^ float(f64)
+i ^ f64 ** 0.5
+i ^ f64 - f64
+i ^ f64 / i32
+i ^ f64 <= f32
+i ^ f64 == i
+i ^ f64 > f32
+i ^ find(array, ok)
+i ^ floor(i32)
+i ^ half(0.5)
+i ^ half(1)
+i ^ half(f64)
 i ^ i
-i ^ i ** f64
-i ^ i + i32
-i ^ i >= f64
+i ^ i * i
+i ^ i * i64
+i ^ i ** i
+i ^ i / i
 i ^ i32
-i ^ i32 - f32
-i ^ i32 == i64 * i
-i ^ i32 >= f64
-i ^ i32 >= max(i64)
+i ^ i32 / f64
+i ^ i32 in array
 i ^ i64
-i ^ i64 * i64
-i ^ i64 ** i
-i ^ i64 == f32
-i ^ i64 >= i64 ^ f32
-i ^ i64 ^ f64
-i ^ int(f32)
-i ^ max(1)
-i ^ min(i32)
+i ^ i64 != f32 + 1
+i ^ i64 ** f32
+i ^ last(array)
+i ^ median(array)
+i ^ min(i32, 1)
+i ^ reduce(array, #)
+i ^ round(i32)
 i ^ score(1)
+i in 1 .. i
 i in array
-i in array == ok
-i in array ? f32 : greet
-i in array ? foo : false
-i in array || ok
+i in array != nil
+i in array ? nil : 1
+i in groupBy(list, #)
+i in groupBy(list, foo)
+i in map(array, #)
+i in map(array, i64)
+i not in 1 .. 1
 i not in array
-i not in array ? foo : list
-i not in array and true
+i not in groupBy(array, #)
+i not in groupBy(list, #)
 i not in i64 .. 1
+i not in i64 .. i64
 i not in map(array, #)
-i not in {"foo": 1}.div
+i not in map(list, i32)
 i32
 i32 != -0.5
 i32 != -1
 i32 != -f32
 i32 != -i
-i32 != 0.5 && nil == i64
+i32 != -i32
+i32 != -i64
+i32 != 0.5 - 0.5
+i32 != 0.5 - i32
+i32 != 0.5 / f32
+i32 != 0.5 ^ 0.5
+i32 != 0.5 ^ i64
+i32 != 0.5 || ok
+i32 != 1 % i64
 i32 != 1 && ok
-i32 != 1 * i64
-i32 != 1 + 1
-i32 != 1 / 1
-i32 != 1 ? 0.5 : greet
-i32 != 1 ? false : i64
-i32 != 1 ? greet : half
-i32 != 1 ? greet : ok
-i32 != abs(i64)
-i32 != array[i]
-i32 != count(array, ok)
+i32 != 1 * f32
+i32 != 1 ? "foo" : array
+i32 != 1 ? greet : "foo"
+i32 != array[i64]
+i32 != bitnot(i)
+i32 != bitnot(i64)
+i32 != ceil(1)
+i32 != ceil(f64)
+i32 != count(array, false)
 i32 != f32
-i32 != f32 && ok
-i32 != f32 / f64
-i32 != f32 ? f64 : i32
-i32 != f32 and ok
+i32 != f32 == true
+i32 != f32 ? false : 0.5
+i32 != f32 ? i : 0.5
 i32 != f64
-i32 != f64 == true
-i32 != findIndex(list, false)
-i32 != first(array)
-i32 != float(i)
-i32 != get(array, i64)
-i32 != half(f64)
+i32 != f64 ** i
+i32 != f64 - 1
+i32 != f64 ? 1 : add
+i32 != findLastIndex(array, false)
+i32 != get(array, 1)
+i32 != half(1)
 i32 != i
-i32 != i ** 1
-i32 != i ** f64
+i32 != i + 1
 i32 != i32
-i32 != i32 * 1
-i32 != i32 - 0.5
-i32 != i32 ? array : add
+i32 != i32 ** 0.5
+i32 != i32 + 0.5
+i32 != i32 ^ i64
 i32 != i64
-i32 != i64 % i32
-i32 != i64 * 0.5
-i32 != i64 ? div : nil
-i32 != i64 ? true : nil
-i32 != int(f32)
-i32 != max(1)
-i32 != max(f64, 0.5)
-i32 != min(1, 0.5, f64)
-i32 != min(i)
-i32 != nil ? half : 1
-i32 % -i
+i32 != i64 * i64
+i32 != i64 / 0.5
+i32 != i64 / f32
+i32 != len(list)
+i32 != max(f64)
+i32 != min(1)
+i32 != min(i32)
+i32 != nil != false
+i32 != nil ? f64 : "foo"
+i32 != reduce(array, #)
+i32 != reduce(array, i)
+i32 != reduce(list, f32)
+i32 != round(1)
+i32 % -1
 i32 % -i32
-i32 % 1 != i64
-i32 % 1 % (i64 + i64)
-i32 % 1 % i64
-i32 % 1 * f64
-i32 % 1 + f64
+i32 % 1 % i32
+i32 % 1 * f32
+i32 % 1 * i
+i32 % 1 * i32
+i32 % 1 .. i
+i32 % 1 / 0.5
+i32 % 1 / i32
 i32 % 1 > i
-i32 % add(1, 1)
-i32 % count(list, ok)
+i32 % array[i64]
+i32 % get(array, 1)
 i32 % i
-i32 % i != f32
+i32 % i != i
+i32 % i < i
 i32 % i32
-i32 % i32 != i
-i32 % i32 * f32
-i32 % i32 * i
+i32 % i32 != f64
+i32 % i32 * i64
+i32 % i32 == i32
+i32 % i32 >= i64
 i32 % i64
-i32 % i64 != f32
-i32 % i64 / i32
-i32 % i64 == i
-i32 % i64 >= i64
-i32 % min(1, i64)
-i32 % min(i)
+i32 % i64 % i
+i32 % i64 * i64
+i32 % i64 + i
+i32 % i64 .. i
+i32 % i64 / i
+i32 % i64 == f64
+i32 % max(i32)
+i32 % reduce(array, #)
+i32 % score(1)
+i32 * (1 + f32)
+i32 * (1 + f64)
 i32 * (f32 + 1)
-i32 * (f32 + f32)
-i32 * (f32 + i)
-i32 * (f64 - f32)
-i32 * (i32 - 0.5)
+i32 * (f32 - i)
+i32 * (f64 + 0.5)
+i32 * (f64 + i)
+i32 * (i - f32)
+i32 * (i32 + i64)
+i32 * (i32 - 1)
 i32 * (i32 - f64)
-i32 * (i32 - i64)
+i32 * -0.5
+i32 * -1
 i32 * -f32
-i32 * -f64
-i32 * -i
-i32 * 0.5 ** 0.5
-i32 * 0.5 + f64
-i32 * 0.5 <= f32
-i32 * 1 % i64
-i32 * 1 * f32
-i32 * 1 * i32
-i32 * 1 < i
-i32 * array[i32]
-i32 * count(array, true)
+i32 * -i32
+i32 * -i64
+i32 * 0.5 * 0.5
+i32 * 0.5 / 0.5
+i32 * 0.5 / 1
+i32 * 0.5 / i32
+i32 * 0.5 == f64
+i32 * 0.5 == i64
+i32 * 0.5 ^ f64
+i32 * 0.5 ^ i32
+i32 * 1 * i
+i32 * 1 ** i64
+i32 * 1 + f64
+i32 * 1 - i64
+i32 * 1 > half(0.5)
+i32 * 1 ^ 1
+i32 * abs(i32)
+i32 * bitnot(i32)
+i32 * ceil(1)
 i32 * f32
-i32 * f32 != i
+i32 * f32 + f32
+i32 * f32 / i
+i32 * f32 <= f64
+i32 * f32 <= i32
+i32 * f32 ^ f32
 i32 * f64
-i32 * f64 * i
-i32 * f64 + f32
-i32 * f64 / i
-i32 * f64 > i32
+i32 * f64 * 1
+i32 * f64 >= f32
+i32 * first(array)
+i32 * float(f32)
+i32 * float(f64)
+i32 * floor(f64)
+i32 * half(0.5)
+i32 * half(1)
 i32 * i
-i32 * i != i32
-i32 * i * 0.5
-i32 * i .. i
-i32 * i / array[i32]
-i32 * i / i32
+i32 * i / -i
+i32 * i / f32
 i32 * i / i64
+i32 * i < f32
 i32 * i32
-i32 * i32 % i32
-i32 * i32 * 0.5
-i32 * i32 ** 1
-i32 * i32 - f32
-i32 * i32 == i32
+i32 * i32 != f64
+i32 * i32 % i64 / i
+i32 * i32 / i64
+i32 * i32 < i64
+i32 * i32 >= f32
 i32 * i64
 i32 * i64 % 1
-i32 * i64 .. i
-i32 * i64 / 1
-i32 * i64 / i32
-i32 * int(f32)
-i32 * max(f64)
+i32 * i64 % 1 % 1
+i32 * i64 ** i64
+i32 * i64 / f32
+i32 * i64 < i
+i32 * len("foo")
+i32 * max(i32)
 i32 * max(i64)
-i32 * min(1)
-i32 ** (0.5 * 0.5)
-i32 ** (0.5 + 0.5)
-i32 ** (0.5 + i32)
-i32 ** (0.5 / f64)
-i32 ** (f32 / i)
-i32 ** (f64 + 0.5)
-i32 ** (i + 1)
-i32 ** (i64 - i)
-i32 ** -1 ^ i32
-i32 ** -f32
-i32 ** -i32
+i32 * median(array)
+i32 * min(0.5)
+i32 * min(i)
+i32 * reduce(array, #)
+i32 * round(i)
+i32 * score(1)
+i32 * score(i)
+i32 ** (0.5 - i32)
+i32 ** (1 * i64)
+i32 ** (1 / 0.5)
+i32 ** (f32 * i64)
+i32 ** (i % i32)
+i32 ** (i - i)
+i32 ** (i - i32)
+i32 ** (i / 0.5)
+i32 ** (i32 / i64)
+i32 ** (i64 + 0.5)
+i32 ** (i64 - 1)
+i32 ** -1
+i32 ** -f64
+i32 ** -i
 i32 ** -i64
-i32 ** 0.5 / f32
-i32 ** 0.5 <= i32
+i32 ** 0.5 * i64
+i32 ** 0.5 - f64
+i32 ** 0.5 / reduce(array, #)
 i32 ** 0.5 ^ i
 i32 ** 1 ** i64
-i32 ** 1 + f64
-i32 ** 1 + i64
-i32 ** 1 - f32
-i32 ** 1 >= i64 * 0.5
-i32 ** 1 ^ f64
-i32 ** array[i]
+i32 ** 1 + f32
+i32 ** 1 / i64
+i32 ** 1 <= i
+i32 ** 1 ^ i64
+i32 ** 1 in array
+i32 ** array[1]
+i32 ** array[i64]
+i32 ** bitnot(i64)
+i32 ** ceil(1)
+i32 ** ceil(f64)
 i32 ** f32
-i32 ** f32 ** i
-i32 ** f32 == i64
+i32 ** f32 / score(1)
+i32 ** f32 < f32
+i32 ** f32 <= i
+i32 ** f32 == f32
 i32 ** f64
-i32 ** f64 != i64 ? i : half
-i32 ** f64 + f64
-i32 ** f64 >= i
-i32 ** f64 ^ f32
-i32 ** float(1)
-i32 ** float(f64)
+i32 ** f64 == f32
+i32 ** f64 > i
+i32 ** find(array, ok)
+i32 ** float(i32)
 i32 ** half(0.5)
+i32 ** half(1)
+i32 ** half(f64)
 i32 ** i
-i32 ** i ** 0.5
-i32 ** i ^ 0.5
+i32 ** i * f64
+i32 ** i ** i
+i32 ** i ^ i
 i32 ** i32
+i32 ** i32 ^ i64
 i32 ** i64
-i32 ** i64 != 0.5 == true
-i32 ** i64 - f64
-i32 ** i64 / f64
-i32 ** i64 / i
-i32 ** i64 > i
-i32 ** i64 ^ 1
-i32 ** i64 ^ i
-i32 ** int(0.5)
-i32 ** int(f64)
-i32 ** len(array)
-i32 ** min(f64)
-i32 ** min(i32)
-i32 ** score(1)
-i32 ** score(i)
+i32 ** int(1)
+i32 ** int(i32)
+i32 ** len("foo")
+i32 ** len(list)
+i32 ** max(f32, i32)
+i32 ** min(0.5)
+i32 ** min(i64)
+i32 ** reduce(array, 1)
+i32 ** reduce(array, i64)
+i32 ** reduce(list, i64)
+i32 ** round(i64)
+i32 ** sum(array)
 i32 + -0.5
 i32 + -1
-i32 + -f32
-i32 + -f64
 i32 + -i
 i32 + -i32
-i32 + 0.5 * 0.5
-i32 + 0.5 * i32
+i32 + -i64
+i32 + 0.5 != f32
+i32 + 0.5 != i32
+i32 + 0.5 * i
+i32 + 0.5 + 0.5
 i32 + 0.5 + 1
+i32 + 0.5 + f32
+i32 + 0.5 + f64
+i32 + 0.5 + i
 i32 + 0.5 + i64
-i32 + 0.5 - 0.5
-i32 + 0.5 - f32
-i32 + 0.5 <= i
-i32 + 0.5 > i % 1
-i32 + 0.5 >= i
-i32 + 1 / f64
-i32 + 1 < i32
-i32 + 1 ^ i
-i32 + 1 ^ i32
-i32 + abs(i32)
-i32 + count(array, false)
+i32 + 0.5 / i64
+i32 + 0.5 <= -f32
+i32 + 1 % 1
+i32 + 1 + i64
+i32 + 1 - f32
+i32 + 1 - i
+i32 + 1 - i64
+i32 + 1 / i
+i32 + 1 ^ f32
+i32 + abs(f32)
+i32 + array[i64]
+i32 + bitnot(i32)
+i32 + ceil(i)
 i32 + f32
+i32 + f32 / i
+i32 + f32 < i32
+i32 + f32 <= i64
 i32 + f64
 i32 + f64 * 1
-i32 + f64 * f64
-i32 + f64 ** 0.5
-i32 + f64 - f32 * 0.5
-i32 + f64 == i32
-i32 + f64 >= i
+i32 + f64 * i32
+i32 + f64 > i32
+i32 + f64 ^ 0.5
 i32 + f64 ^ i32
-i32 + find(array, ok)
+i32 + findIndex(list, true)
+i32 + floor(0.5)
+i32 + floor(f64)
 i32 + i
-i32 + i * 1
-i32 + i - f32
-i32 + i > half(f64)
-i32 + i >= -1
+i32 + i + f64
+i32 + i + i64
+i32 + i - 0.5
+i32 + i - i64
+i32 + i <= i32
+i32 + i > i64
 i32 + i32
-i32 + i32 ** 0.5
-i32 + i32 >= f32
-i32 + i32 ^ i64
+i32 + i32 + f64
+i32 + i32 <= i + i64
+i32 + i32 > i
+i32 + i32 > i32
 i32 + i64
-i32 + i64 + i64
-i32 + i64 / f64
-i32 + i64 <= f32
-i32 + i64 ^ f32
-i32 + i64 not in array
-i32 + int(f64)
-i32 + last(array)
-i32 + len("foo")
-i32 + len(list)
-i32 + min(0.5, i32)
-i32 + min(1, i)
-i32 + min(i)
-i32 + min(i, i32)
+i32 + i64 % i32
+i32 + i64 ** 1
+i32 + i64 - 0.5
+i32 + i64 - f32
+i32 + i64 / 0.5
+i32 + i64 ^ 1
+i32 + int(i64)
+i32 + len("bar")
+i32 + min(i32)
+i32 + reduce(array, #)
+i32 + round(f32)
+i32 + round(i32)
 i32 + score(i)
 i32 - -0.5
 i32 - -1
 i32 - -f32
-i32 - -i32
-i32 - -i64
-i32 - 0.5 * 0.5
-i32 - 0.5 * i64
-i32 - 0.5 + i
-i32 - 0.5 + i32
-i32 - 0.5 - f32
-i32 - 0.5 < i32
-i32 - 0.5 <= f64
-i32 - 1 != f32
-i32 - 1 * f32
-i32 - 1 ** i32
-i32 - 1 / 0.5
-i32 - 1 <= i64
-i32 - 1 not in array
-i32 - array[1]
+i32 - -i
+i32 - 0.5 * f32
+i32 - 0.5 + half(0.5)
+i32 - 0.5 - i32
+i32 - 0.5 <= f32
+i32 - 0.5 ^ 0.5
+i32 - 1 ** i
+i32 - 1 + 0.5
+i32 - 1 > -i64
+i32 - abs(i32)
+i32 - abs(i64)
+i32 - array[i]
+i32 - bitushr(i32, i64)
+i32 - div(1, i)
+i32 - div(i, i)
 i32 - f32
-i32 - f32 * f32
-i32 - f32 ** f64
-i32 - f32 + 0.5
-i32 - f32 / f64
+i32 - f32 * 0.5
+i32 - f32 + i32
+i32 - f32 - int(f64)
+i32 - f32 / i32
+i32 - f32 < i64
+i32 - f32 <= f32
+i32 - f32 <= i32
+i32 - f32 > i
+i32 - f32 >= f32
 i32 - f64
-i32 - f64 ** f64
-i32 - f64 + 0.5
-i32 - f64 - i64
-i32 - f64 / i64
-i32 - f64 < i64
-i32 - first(array)
-i32 - float(i)
-i32 - get(array, i64)
+i32 - f64 + f32
+i32 - float(0.5)
+i32 - float(1)
+i32 - float(f64)
+i32 - floor(1)
+i32 - floor(f64)
+i32 - get(array, i)
+i32 - half(0.5)
+i32 - half(f64)
 i32 - i
-i32 - i % i
-i32 - i + f32
-i32 - i - 1
-i32 - i / i
-i32 - i <= i64
-i32 - i == i
+i32 - i ** i64
+i32 - i + i32
+i32 - i / 0.5
+i32 - i == f32
 i32 - i > f64
-i32 - i >= f64
+i32 - i > i
+i32 - i >= i64
 i32 - i32
-i32 - i32 ** 0.5
-i32 - i32 <= i32 + i64
-i32 - i32 ^ 1
+i32 - i32 != i64
+i32 - i32 * 1
+i32 - i32 * i32
+i32 - i32 + 1
+i32 - i32 < i32
+i32 - i32 > i64
+i32 - i32 > i64 / i
 i32 - i64
-i32 - i64 % i
-i32 - i64 % i64
-i32 - i64 .. i
-i32 - i64 <= i
-i32 - i64 ^ 0.5
-i32 - i64 ^ f64
-i32 - int(1)
-i32 - int(f64)
-i32 - max(i64)
-i32 - max(i64, i)
-i32 - min(0.5)
-i32 - score(i)
-i32 .. -1
-i32 .. -i
-i32 .. -i32
+i32 - i64 != -f32
+i32 - i64 / 1
+i32 - i64 == f64
+i32 - len(array)
+i32 - len(list)
+i32 - max(f32)
+i32 - score(1)
 i32 .. -i64
-i32 .. 1 - 1
-i32 .. abs(i)
-i32 .. array[i32]
-i32 .. count(array, ok)
+i32 .. abs(i64)
+i32 .. bitnot(i64)
+i32 .. bitushr(i, 1)
+i32 .. count(array, true)
+i32 .. div(i, 1)
 i32 .. i
-i32 .. i - 1
 i32 .. i32
-i32 .. i32 != list
 i32 .. i64
-i32 .. i64 - i32
-i32 .. int(0.5)
-i32 .. len(list)
-i32 .. min(1)
-i32 .. min(1, 0.5)
-i32 .. min(i32)
-i32 .. min(i64)
+i32 .. int(f32)
+i32 .. len("foo")
+i32 .. max(1)
+i32 .. max(i32)
+i32 .. max(i32, 0.5)
 i32 .. score(i)
-i32 / (0.5 + i32)
-i32 / (1 + f32)
-i32 / (1 - f32)
-i32 / (1 - i)
-i32 / (f32 + i)
-i32 / (f32 - f64)
-i32 / (f64 + 0.5)
-i32 / (f64 - 1)
-i32 / (i32 - 1)
+i32 / (1 + 1)
+i32 / (1 + i64)
+i32 / (f64 - i64)
+i32 / (i32 + i64)
+i32 / (i64 + 0.5)
 i32 / -0.5
-i32 / -1
 i32 / -f32
 i32 / -i
 i32 / -i32
+i32 / -i64
 i32 / 0.5 * i
+i32 / 0.5 * i / 1
+i32 / 0.5 + i64
+i32 / 0.5 - i32
+i32 / 0.5 / i32
 i32 / 0.5 / i64
-i32 / 0.5 >= f64
-i32 / 1 != f64
-i32 / 1 < i32
+i32 / 0.5 >= i64
+i32 / 0.5 ^ 1
+i32 / 0.5 ^ f64
+i32 / 1 != i
+i32 / 1 * i64
+i32 / 1 ** 1
+i32 / 1 ^ 0.5
 i32 / abs(0.5)
+i32 / abs(1)
+i32 / abs(f64)
+i32 / abs(i32)
+i32 / array[1]
+i32 / ceil(i32)
 i32 / f32
+i32 / f32 ** 1
+i32 / f32 / i64
+i32 / f32 <= i32
+i32 / f32 <= i64
+i32 / f32 >= i32 == false
 i32 / f64
-i32 / f64 * i32
+i32 / f64 != f64
+i32 / f64 != i64
+i32 / f64 * 1
+i32 / f64 - i32
+i32 / f64 == i64
 i32 / f64 >= f32
-i32 / half(f64)
+i32 / find(array, ok)
+i32 / float(f32)
+i32 / floor(1)
+i32 / floor(f64)
+i32 / half(0.5)
 i32 / i
-i32 / i <= i
+i32 / i * i32
+i32 / i ^ i32
 i32 / i32
-i32 / i32 * 1
-i32 / i32 / f32 / f64
+i32 / i32 * f64
 i32 / i32 / i64
+i32 / i32 <= i64
 i32 / i64
-i32 / i64 != i64
-i32 / i64 * i
-i32 / i64 / i
-i32 / i64 == f32
-i32 / i64 == f64
-i32 / int(i)
-i32 / len("bar")
+i32 / i64 ** f32
+i32 / i64 ^ 0.5
+i32 / int(1)
 i32 / len("foo")
-i32 / max(i32)
+i32 / max(1)
+i32 / max(i)
 i32 / min(f32)
-i32 / min(f64)
-i32 / min(i)
-i32 / min(i32)
-i32 < -(i - f32)
-i32 < -0.5
+i32 / reduce(array, #)
+i32 / score(i)
 i32 < -f32
+i32 < -f64
 i32 < -i32
 i32 < 0.5 ** i32
+i32 < 0.5 - 1
 i32 < 0.5 - f32
-i32 < 0.5 ^ 1
-i32 < 1 % 1
-i32 < 1 ** 1
-i32 < 1 + 0.5
-i32 < 1 + 1
-i32 < 1 ? "foo" : i32
-i32 < 1 ? 1 : 0.5
-i32 < 1 ^ i32
-i32 < abs(i64)
-i32 < div(1, 1)
+i32 < 0.5 / 1
+i32 < 0.5 == nil
+i32 < 0.5 ? "foo" : half
+i32 < 0.5 ? foo : 1
+i32 < 0.5 or ok
+i32 < 0.5 || ok
+i32 < 1 * f32
+i32 < 1 + i64
+i32 < 1 / f32
+i32 < 1 ^ i
+i32 < abs(f64)
 i32 < f32
-i32 < f32 == nil
-i32 < f32 ? div : true
-i32 < f32 || i64 != f32
+i32 < f32 * i
+i32 < f32 - 0.5
+i32 < f32 - 1
 i32 < f64
-i32 < f64 != nil
-i32 < f64 != true
-i32 < f64 * f32
-i32 < f64 == nil
-i32 < f64 ? f32 : half
-i32 < f64 ? greet : false
-i32 < f64 ? list : i32
-i32 < f64 ^ f32
-i32 < f64 || 1 < 1
-i32 < float(i)
-i32 < float(i32)
-i32 < half(0.5)
+i32 < f64 * i64
+i32 < float(reduce(array, f32))
+i32 < get(array, i32)
+i32 < get(array, i64)
+i32 < half(1)
+i32 < half(f64)
 i32 < i
-i32 < i != true
-i32 < i ^ 0.5
+i32 < i ** i64
+i32 < i + 0.5
+i32 < i / i32
+i32 < i ? score : score
 i32 < i32
-i32 < i32 != ok
-i32 < i32 * f32
-i32 < i32 / i32
-i32 < i32 ? ok : 1
+i32 < i32 % i
+i32 < i32 ** 1
+i32 < i32 - f32
+i32 < i32 ^ i64
 i32 < i64
-i32 < i64 - 0.5
-i32 < i64 ^ f64
+i32 < i64 ** 0.5
+i32 < i64 + f32
+i32 < i64 / f64
 i32 < int(0.5)
-i32 < int(i32)
-i32 < int(i64)
-i32 < max(0.5)
-i32 < max(1)
-i32 < min(1, i32)
+i32 < last(array)
+i32 < min(1)
 i32 < min(f64)
-i32 < min(i)
-i32 < min(i64)
+i32 < min(i32)
 i32 < score(1)
+i32 < score(i)
 i32 <= -0.5
 i32 <= -f32
 i32 <= -i
 i32 <= -i32
-i32 <= 0.5 != nil
-i32 <= 0.5 != ok
-i32 <= 0.5 * 0.5
-i32 <= 0.5 * i
-i32 <= 0.5 + i64
-i32 <= 1 ? i : f32
-i32 <= 1 ? true : true
-i32 <= 1 or 0.5 == 0.5
-i32 <= abs(i32)
-i32 <= count(list, ok)
+i32 <= -i64
+i32 <= 0.5 - f64
+i32 <= 0.5 == nil
+i32 <= 0.5 ? i32 : greet
+i32 <= 0.5 ? i32 : half
+i32 <= 0.5 ^ i64
+i32 <= 0.5 and ok
+i32 <= 1 + i32
+i32 <= 1 + i64
+i32 <= 1 ^ 0.5
+i32 <= 1 and ok
+i32 <= 1 || i32 >= i32
+i32 <= abs(1)
 i32 <= f32
-i32 <= f32 * i64
-i32 <= f32 / 0.5
-i32 <= f32 ^ i64
+i32 <= f32 != ok
 i32 <= f64
+i32 <= f64 != ok
 i32 <= f64 * i
-i32 <= f64 ^ 1
-i32 <= float(i)
+i32 <= f64 == ok
+i32 <= f64 ^ f64
+i32 <= findIndex(array, true)
+i32 <= float(i32)
+i32 <= floor(0.5)
 i32 <= half(0.5)
+i32 <= half(1)
+i32 <= half(f64)
 i32 <= i
-i32 <= i % i64
+i32 <= i * 1
+i32 <= i * i64
+i32 <= i - 0.5
 i32 <= i32
-i32 <= i32 != nil
-i32 <= i32 % 1
-i32 <= i32 ** f64
+i32 <= i32 != true
 i32 <= i64
-i32 <= i64 != false
-i32 <= i64 != ok
-i32 <= i64 + f32
-i32 <= i64 ? div : nil
-i32 <= last(array)
-i32 <= len(array)
-i32 <= len(list)
-i32 <= max(f64)
-i32 <= min(i)
+i32 <= i64 / 1
+i32 <= len("foo")
+i32 <= max(i64)
+i32 <= mean(array)
+i32 <= round(0.5)
 i32 <= score(1)
 i32 <= score(i)
 i32 == -0.5
 i32 == -1
+i32 == -f32
 i32 == -f64
 i32 == -i
-i32 == -i64
-i32 == 0.5 / f64
-i32 == 0.5 ? half : array
-i32 == 0.5 ^ i
-i32 == 0.5 ^ i64
-i32 == 1 ** 1
-i32 == 1 ** i
-i32 == 1 || f32 < f64
+i32 == 0.5 != false
+i32 == 0.5 * f32
+i32 == 0.5 / 0.5
+i32 == 1 % 1
+i32 == 1 + f32
+i32 == 1 - i
+i32 == 1 ? div : div
+i32 == 1 ^ 0.5
+i32 == 1 ^ f64
+i32 == abs(f64)
+i32 == abs(i)
+i32 == bitnot(1)
+i32 == bitnot(i)
+i32 == ceil(1)
+i32 == count(list, ok)
 i32 == f32
-i32 == f32 ? f32 : nil
-i32 == f32 ? half : "bar"
-i32 == f32 ? score : false
-i32 == f32 or ok
+i32 == f32 * i32
+i32 == f32 ** 1
+i32 == f32 - f32
+i32 == f32 ? f64 : list
+i32 == f32 ? i64 : true
+i32 == f32 ? score : "bar"
 i32 == f64
-i32 == f64 != ok
-i32 == f64 * 0.5
-i32 == f64 ** f32
-i32 == f64 ** i64
-i32 == f64 ? add : half
-i32 == findLastIndex(array, ok)
-i32 == float(i)
-i32 == half(0.5)
+i32 == f64 ** 0.5
+i32 == find(array, 0.5 == i64)
+i32 == first(array)
+i32 == floor(f64)
+i32 == half(f64)
 i32 == i
-i32 == i % i64
-i32 == i ? "foo" : greet
-i32 == i ? type(false) : array
-i32 == i ^ f64
-i32 == i and ok
-i32 == i || ok
+i32 == i ** f64
+i32 == i ? half : 1
+i32 == i ? i : "bar"
 i32 == i32
-i32 == i32 ? add : add
-i32 == i32 ? f32 : f64
-i32 == i32 ^ 1
+i32 == i32 && i == i
+i32 == i32 - 1
+i32 == i32 - i64
 i32 == i64
-i32 == i64 + f32
-i32 == i64 ? foo : list
-i32 == len(list)
-i32 == max(0.5)
-i32 == min(f32)
-i32 == min(i32)
-i32 == nil ? f32 : add
-i32 == nil and ok
-i32 == {"foo": f32, "foo": list}?.String?.Qux
+i32 == i64 * f32
+i32 == i64 ? "foo" : 1
+i32 == i64 or ok
+i32 == int(f64)
+i32 == int(i)
+i32 == nil ? f32 : 0.5
+i32 == reduce(array, #)
+i32 == round(i32)
+i32 == round(i64)
+i32 == score(1)
 i32 > -0.5
-i32 > -1
-i32 > -f32
 i32 > -f64
-i32 > -i
 i32 > -i32
-i32 > -i64
-i32 > 0.5 != ok
 i32 > 0.5 != true
 i32 > 0.5 * f64
-i32 > 0.5 ** f32
+i32 > 0.5 ** 0.5
+i32 > 0.5 ** 1
 i32 > 0.5 ** i
-i32 > 0.5 + 0.5
-i32 > 0.5 + 1
-i32 > 0.5 - 1
-i32 > 0.5 / i64
-i32 > 0.5 == nil
-i32 > 0.5 ? greet : f32
-i32 > 0.5 ? ok : false
-i32 > 0.5 ^ f32
-i32 > 1 ** f64
-i32 > 1 - i
-i32 > 1 / 1
-i32 > 1 ? i : add
-i32 > 1 || ok
-i32 > abs(1)
-i32 > abs(f64)
-i32 > array[1]
-i32 > array[i32]
+i32 > 0.5 - i
+i32 > 0.5 / 1
+i32 > 0.5 == ok
+i32 > 0.5 ^ 1
+i32 > 0.5 || ok
+i32 > 1 * f64
+i32 > 1 * i32
+i32 > 1 + i64
+i32 > 1 ? f32 : f64
+i32 > 1 ? i : "bar"
+i32 > 1 ? i64 : div
+i32 > ceil(0.5)
+i32 > ceil(1)
+i32 > count(array, ok)
 i32 > f32
-i32 > f32 != ok
-i32 > f32 && "bar" == nil
 i32 > f32 * i64
-i32 > f32 ? "bar" : half
+i32 > f32 + 0.5
+i32 > f32 + 1
+i32 > f32 - f32
+i32 > f32 - i32
+i32 > f32 ^ 0.5
 i32 > f64
-i32 > f64 * 0.5
-i32 > f64 - 1
-i32 > f64 / 1
-i32 > f64 / i32
-i32 > f64 == nil
-i32 > f64 == ok
-i32 > f64 == true
-i32 > f64 ? 0.5 : add
-i32 > f64 ^ i64
-i32 > float(i)
-i32 > float(i32)
-i32 > half(0.5)
-i32 > half(f64)
+i32 > f64 ** i32
+i32 > f64 + f64
+i32 > get(array, i32)
+i32 > half(1)
+i32 > half(half(1))
 i32 > i
+i32 > i != ok
 i32 > i + f32
-i32 > i / f32
+i32 > i ? i : i
 i32 > i ^ i32
 i32 > i32
-i32 > i32 - 0.5
-i32 > i32 ? "bar" : div
-i32 > i32 ? array : 0.5
-i32 > i32 ? foo : 1
+i32 > i32 - i
+i32 > i32 == nil ? score : i
+i32 > i32 ? score : 1
+i32 > i32 ^ 1
+i32 > i32 ^ i32
 i32 > i64
+i32 > i64 != false
 i32 > i64 ** f32
-i32 > i64 + f64
-i32 > i64 - i
-i32 > i64 ? list : list
-i32 > int(i)
+i32 > i64 / 1
+i32 > i64 == ok
+i32 > i64 || ok
+i32 > int(1)
 i32 > int(i64)
-i32 > max(i)
-i32 > min(0.5)
-i32 > score(1)
-i32 >= -0.5
+i32 > min(i32)
+i32 > reduce(array, #)
+i32 > round(i64)
+i32 > score(i)
 i32 >= -1
+i32 >= -f32
+i32 >= -f64
 i32 >= -i
-i32 >= 0.5 ** 0.5
-i32 >= 0.5 ^ f32
-i32 >= 0.5 || ok
-i32 >= 1 && ok
-i32 >= abs(i)
-i32 >= abs(i64)
-i32 >= array[i]
+i32 >= -i64
+i32 >= 0.5 != not true
+i32 >= 0.5 == true
+i32 >= 0.5 ? 0.5 : half
+i32 >= 0.5 ^ 0.5
+i32 >= 0.5 ^ i32
+i32 >= 1 % i
+i32 >= 1 * 0.5
+i32 >= 1 * i32
+i32 >= 1 + i64
+i32 >= 1 - 1
+i32 >= 1 == ok
+i32 >= 1 ? 1 : false
+i32 >= 1 ? add : 1
+i32 >= abs(0.5)
+i32 >= abs(f32)
+i32 >= bitnot(1 + i)
+i32 >= bitnot(i64)
+i32 >= ceil(1)
+i32 >= ceil(f32)
+i32 >= count(list, true)
 i32 >= f32
-i32 >= f32 != true
-i32 >= f32 - 0.5
-i32 >= f32 ^ 0.5
+i32 >= f32 ** f32
+i32 >= f32 ^ 1
 i32 >= f64
-i32 >= f64 && nil == 0.5
-i32 >= f64 - f64
-i32 >= f64 / 1
-i32 >= f64 ? f32 : list
-i32 >= f64 ^ 1
-i32 >= float(1)
+i32 >= f64 != false
+i32 >= f64 ** f64
+i32 >= f64 / i64
+i32 >= f64 ? half : f64
+i32 >= f64 ^ f64
+i32 >= float(0.5)
+i32 >= floor(1)
+i32 >= floor(f32)
 i32 >= half(0.5)
-i32 >= half(f64)
 i32 >= i
+i32 >= i % 1
 i32 >= i % i64
-i32 >= i ** i32
-i32 >= i / i
-i32 >= i ? div : list
-i32 >= i ? foo : 0.5
+i32 >= i / i32
+i32 >= i / i64
+i32 >= i == ok
 i32 >= i32
+i32 >= i32 ** i32
 i32 >= i64
-i32 >= i64 != ok
-i32 >= i64 ** i64
-i32 >= i64 / i64
-i32 >= i64 ? list : greet
-i32 >= i64 ^ i32
+i32 >= i64 != false
+i32 >= i64 - i64
+i32 >= i64 / i32
+i32 >= i64 ? 0.5 : 0.5
+i32 >= i64 ? div : half
+i32 >= i64 ? half : i64
+i32 >= i64 and ok
 i32 >= int(i64)
 i32 >= last(array)
-i32 >= len(array)
 i32 >= min(i32)
+i32 >= reduce(array, #)
+i32 >= reduce(array, i64)
+i32 >= reduce(list, i32)
+i32 >= round(f32)
 i32 >= score(1)
-i32 >= score(i)
-i32 ^ (f32 + i64)
-i32 ^ (f64 + 0.5)
-i32 ^ (i - f64)
-i32 ^ (i32 + f32)
-i32 ^ (i64 % i)
-i32 ^ (i64 * 0.5)
-i32 ^ (i64 + f32)
-i32 ^ (i64 - f64)
-i32 ^ --0.5
+i32 ^ (0.5 + 1)
+i32 ^ (1 - i)
+i32 ^ (i + 1)
+i32 ^ (i / f64)
+i32 ^ (i32 + 0.5)
+i32 ^ (i32 - f32)
+i32 ^ (i64 + i)
 i32 ^ -0.5
+i32 ^ -1
 i32 ^ -f64
+i32 ^ -i
 i32 ^ -i32
-i32 ^ 0.5 ** i
-i32 ^ 0.5 + i32
-i32 ^ 0.5 - i
-i32 ^ 0.5 < i
+i32 ^ -i64
+i32 ^ 0.5 != f32
+i32 ^ 0.5 != f64
+i32 ^ 0.5 * i
+i32 ^ 0.5 ** i64
+i32 ^ 0.5 - f32
+i32 ^ 0.5 / i32
 i32 ^ 0.5 == i64
-i32 ^ abs(1)
+i32 ^ 0.5 >= f64
+i32 ^ 1 ** i32
+i32 ^ 1 + i32
+i32 ^ 1 - f64
+i32 ^ 1 < f64
+i32 ^ 1 ^ (1 + i64)
+i32 ^ 1 ^ f32
+i32 ^ array[i64]
 i32 ^ f32
-i32 ^ f32 * i64
-i32 ^ f32 ** 0.5
-i32 ^ f32 ** i
-i32 ^ f32 < 0.5 * i
-i32 ^ f32 ^ i
+i32 ^ f32 / bitnot(1)
+i32 ^ f32 >= max(f64)
 i32 ^ f64
-i32 ^ f64 ^ 1
-i32 ^ float(f32)
-i32 ^ half(0.5)
-i32 ^ half(f64)
+i32 ^ f64 + i
+i32 ^ find(array, true)
+i32 ^ first(array)
+i32 ^ float(i64)
 i32 ^ i
-i32 ^ i + i32
-i32 ^ i - f32
+i32 ^ i * f64
+i32 ^ i + i64
 i32 ^ i <= f32
-i32 ^ i ^ 1
 i32 ^ i32
-i32 ^ i32 ** f32
-i32 ^ i32 ** f64
-i32 ^ i32 + i32
-i32 ^ i32 + i64
-i32 ^ i32 <= i64
+i32 ^ i32 * f64
+i32 ^ i32 ** i
 i32 ^ i64
-i32 ^ i64 - f32
-i32 ^ max(0.5)
-i32 ^ max(1)
-i32 ^ max(i)
-i32 ^ min(f32)
-i32 ^ score(1)
+i32 ^ i64 == f64
+i32 ^ i64 > -f64
+i32 ^ len(list)
+i32 ^ mean(array)
+i32 ^ min(i)
+i32 ^ reduce(array, #)
+i32 ^ reduce(list, 1)
+i32 in [0.5]
 i32 in array
+i32 in array || ok
+i32 in groupBy(array, #)
+i32 in groupBy(array, f32)
+i32 in groupBy(list, #)
+i32 in groupBy(list, #?.Bar)
+i32 in groupBy(list, foo).i
+i32 in i32 .. 1
+i32 in i32 .. i64
 i32 in map(array, #)
+i32 in map(list, 0.5)
+i32 in map(list, i32)
+i32 not in 1 .. i
 i32 not in array
-i32 not in array ? score : score
-i32 not in map(array, #)
-i32 not in map(array, 1)
+i32 not in array ? array : array
+i32 not in filter(array, ok)
+i32 not in groupBy(list, #)
 i64
-i64 != -0.5
 i64 != -1
-i64 != -f32
-i64 != -f64
 i64 != -i
-i64 != 0.5 != nil
-i64 != 0.5 != ok
-i64 != 0.5 != true
-i64 != 0.5 * 1
-i64 != 0.5 ? false : i64
-i64 != 0.5 ^ 1
-i64 != 0.5 and f64 == 1
-i64 != 1 || f64 < i
-i64 != 1 || ok
+i64 != -i64
+i64 != 0.5 && ok
+i64 != 0.5 * 0.5
+i64 != 0.5 * i
+i64 != 0.5 + 0.5
+i64 != 0.5 + i
+i64 != 0.5 - 0.5
+i64 != 0.5 / i64
+i64 != 0.5 ? i : 1
+i64 != 0.5 ^ i32
+i64 != 1 * f64
+i64 != 1 - 1
 i64 != abs(f64)
+i64 != array[i64]
+i64 != bitnot(i32)
 i64 != f32
-i64 != f32 + f32
-i64 != f32 / f32
-i64 != f32 ? div : 1
-i64 != f32 ? f64 : i64
-i64 != f32 ^ i
+i64 != f32 + i64
 i64 != f64
-i64 != f64 != false
-i64 != f64 - i32
-i64 != f64 / i32
-i64 != f64 / i64
-i64 != f64 ? 0.5 : score
-i64 != f64 ? i64 : true
-i64 != findLast(array, false)
-i64 != first(array)
-i64 != float(i32)
-i64 != get(array, i64)
+i64 != f64 * 1
+i64 != f64 == true
+i64 != f64 or i64 <= f32
+i64 != findIndex(array, ok)
+i64 != float(1)
+i64 != floor(i)
+i64 != get(array, i)
 i64 != half(0.5)
-i64 != half(f64)
+i64 != half(1)
 i64 != i
-i64 != i == nil
-i64 != i ? array : f32
-i64 != i and ok
+i64 != i % 1
+i64 != i + 1
+i64 != i / 0.5
+i64 != i ? f32 : true
 i64 != i32
-i64 != i32 ? 1 : f32
+i64 != i32 ? 0.5 : nil
+i64 != i32 ? f64 : greet
+i64 != i32 ^ i
+i64 != i32 || ok
 i64 != i64
-i64 != i64 ? true : score
-i64 != last(array)
-i64 != len("foo")
-i64 != min(0.5)
+i64 != i64 - 0.5
+i64 != len("bar")
+i64 != len(list)
+i64 != max(0.5)
+i64 != min(1)
+i64 != min(1, f32)
 i64 != min(f32)
-i64 != min(f64)
-i64 != min(i64)
-i64 != nil && ok
+i64 != min(i)
+i64 != nil != ok
+i64 != nil ? div : 1
+i64 != nil ? greet : i
+i64 != nil ? i : i
+i64 != nil ? i64 : false
 i64 != score(1)
-i64 % -1
+i64 != score(i)
 i64 % -i
-i64 % -i32
-i64 % 1 * i32
-i64 % 1 .. i
-i64 % 1 / 0.5
-i64 % 1 / f64
+i64 % 1 % 1
+i64 % 1 * i
 i64 % 1 < i32
-i64 % 1 <= -i32
-i64 % 1 == 0.5 + 0.5
-i64 % 1 not in array
-i64 % abs(i64)
-i64 % array[1]
-i64 % find(array, true)
-i64 % first(array)
+i64 % 1 >= f64
+i64 % 1 >= i32
+i64 % abs(i32)
+i64 % array[i32]
 i64 % i
-i64 % i .. i32
-i64 % i not in array
+i64 % i * i
+i64 % i >= i
 i64 % i32
-i64 % i32 != f64
-i64 % i32 * f32
-i64 % i32 == i
-i64 % i32 > f64 ^ i32
+i64 % i32 / f64
+i64 % i32 <= f64
 i64 % i64
-i64 % i64 * 1
-i64 % i64 * f32
-i64 % i64 + -i64
-i64 % max(i32)
-i64 % min(i)
+i64 % i64 % 1
+i64 % i64 .. i64
+i64 % i64 == i64
+i64 % int(i32)
+i64 % len("bar")
+i64 % max(i)
+i64 % min(1)
 i64 % score(1)
-i64 * (0.5 + i64)
-i64 * (0.5 - 1)
-i64 * (1 + 1)
+i64 * (0.5 + f64)
+i64 * (1 - i64)
+i64 * (f32 - f32)
 i64 * (f64 + f32)
-i64 * (f64 - i)
-i64 * (i - 1)
-i64 * (i64 + 0.5)
-i64 * --f64
+i64 * (i + 0.5)
+i64 * (i + f64)
+i64 * (i32 + f64)
 i64 * -0.5
 i64 * -1
 i64 * -f32
-i64 * -f64
-i64 * 0.5 != f64
+i64 * -i32
 i64 * 0.5 * i32
+i64 * 0.5 ** 0.5
 i64 * 0.5 - f32
-i64 * 0.5 < f32
-i64 * 0.5 == min(i64)
+i64 * 0.5 / 1
 i64 * 0.5 >= f32
-i64 * 0.5 ^ i
-i64 * 1 * 1
+i64 * 1 % 1
+i64 * 1 * 0.5
+i64 * 1 * f64
+i64 * 1 ** 1
+i64 * 1 - i64
 i64 * 1 .. i32
-i64 * 1 <= i64
-i64 * 1 == i32
-i64 * 1 >= i32
-i64 * array[i32]
+i64 * 1 / i64
+i64 * 1 <= f64
+i64 * 1 == 0.5 != true
+i64 * 1 == f32
+i64 * 1 > 1 - i64
+i64 * 1 > f64
+i64 * 1 ^ i32
+i64 * add(1, 1)
+i64 * ceil(1)
+i64 * ceil(i)
+i64 * ceil(i64)
+i64 * count(array, false)
 i64 * f32
-i64 * f32 - f32
-i64 * f32 / f64
-i64 * f32 >= i64
-i64 * f32 ^ i
-i64 * f32 ^ i32
+i64 * f32 * f32
+i64 * f32 ** 1
+i64 * f32 / f32
+i64 * f32 / i
+i64 * f32 / i32
+i64 * f32 not in array
 i64 * f64
-i64 * f64 * i32
-i64 * f64 ^ f64
+i64 * f64 + i32
+i64 * f64 - f64
+i64 * f64 / f64
+i64 * f64 < f64
+i64 * f64 > f64
+i64 * f64 ^ i32
+i64 * findIndex(array, ok)
+i64 * float(i)
 i64 * float(i64)
-i64 * get(array, i64)
-i64 * half(f64)
+i64 * half(0.5)
 i64 * i
-i64 * i * i64
-i64 * i == i32
-i64 * i ^ i64
+i64 * i - -f64
+i64 * i <= f64
 i64 * i32
-i64 * i32 ** f32
-i64 * i32 >= f64
-i64 * i32 >= i64
-i64 * i32 ^ 1
+i64 * i32 != i32
+i64 * i32 * 1
+i64 * i32 * i
+i64 * i32 / 0.5
+i64 * i32 ^ i
 i64 * i64
-i64 * i64 ** 1
-i64 * i64 ** f32
-i64 * i64 - f64
-i64 * i64 in array
+i64 * i64 % i64
+i64 * i64 * i64
+i64 * i64 ** i
+i64 * i64 / f32
+i64 * i64 > i32
 i64 * int(1)
-i64 * min(f32, 0.5)
+i64 * int(i)
+i64 * max(1)
+i64 * max(i64)
+i64 * min(1)
+i64 * min(i32)
+i64 * reduce(array, #)
+i64 * reduce(list, 0.5)
+i64 * reduce(list, 1)
+i64 * round(i)
 i64 * score(1)
-i64 ** (0.5 * i64)
-i64 ** (0.5 + 1)
-i64 ** (1 % i)
-i64 ** (f64 / i)
-i64 ** (i * 0.5)
-i64 ** (i - i)
-i64 ** (i32 + i)
+i64 ** (0.5 + 0.5)
+i64 ** (0.5 / 1)
+i64 ** (1 % 1)
+i64 ** (1 * 1)
+i64 ** (1 - f32)
+i64 ** (f32 + 1)
+i64 ** (f32 / 0.5)
+i64 ** (f64 - 0.5)
+i64 ** (i * i64)
+i64 ** (i / 1)
+i64 ** (i64 % i)
+i64 ** (i64 / i)
+i64 ** -0.5
 i64 ** -1
-i64 ** -i
-i64 ** -i32
-i64 ** 0.5 * f64
-i64 ** 0.5 + f32
-i64 ** 0.5 + f32 - 1
-i64 ** 0.5 - i
-i64 ** 0.5 ^ 1
-i64 ** 0.5 ^ f32
-i64 ** 1 != i
-i64 ** 1 ** f32
-i64 ** 1 ** float(1)
-i64 ** 1 / f64
-i64 ** 1 / i
-i64 ** 1 == i64
-i64 ** 1 ^ i64
-i64 ** abs(f32)
-i64 ** abs(i64)
+i64 ** -f32
+i64 ** 0.5 != i32
+i64 ** 0.5 <= f32
+i64 ** 0.5 <= i
+i64 ** 1 + i32
+i64 ** 1 - f32
+i64 ** 1 / i64
+i64 ** 1 >= f32
+i64 ** bitnot(i32)
+i64 ** ceil(i32)
+i64 ** count(array, false)
 i64 ** f32
-i64 ** f32 != f64
-i64 ** f32 != i64
-i64 ** f32 ** i32
-i64 ** f32 / i64 / 1
-i64 ** f32 <= i64
-i64 ** f32 > f32
+i64 ** f32 * min(0.5)
 i64 ** f64
-i64 ** f64 / i
-i64 ** f64 <= f32
-i64 ** f64 > f64
-i64 ** f64 >= f64
-i64 ** f64 >= i32
-i64 ** float(1)
-i64 ** half(0.5)
+i64 ** f64 ** f64
+i64 ** f64 not in array
+i64 ** f64 not in array ? f32 : greet
+i64 ** floor(f32)
+i64 ** half(1)
 i64 ** i
+i64 ** i != f32
+i64 ** i * f32
+i64 ** i <= -i
+i64 ** i == f64
+i64 ** i ^ f32
 i64 ** i32
-i64 ** i32 != f32
-i64 ** i32 <= f64
-i64 ** i32 <= min(0.5)
+i64 ** i32 != i64
+i64 ** i32 * i ^ i
+i64 ** i32 not in array
 i64 ** i64
-i64 ** i64 / f64
-i64 ** i64 >= f64
-i64 ** int(0.5)
-i64 ** int(f64)
-i64 ** len("foo")
+i64 ** i64 - i64
+i64 ** i64 in array
+i64 ** max(1)
 i64 ** min(0.5)
-i64 ** score(1)
-i64 + -(f32 / i)
-i64 + -0.5
-i64 + -f32
-i64 + -f64
+i64 ** min(1)
+i64 ** min(i32, 1)
+i64 ** reduce(array, #)
+i64 + -1
 i64 + -i
 i64 + -i64
-i64 + 0.5 * i
-i64 + 0.5 ** 1
-i64 + 0.5 + 1
+i64 + 0.5 ** f32
 i64 + 0.5 + i32
-i64 + 1 % i
-i64 + 1 ** i
-i64 + 1 + i32
-i64 + 1 - f64
-i64 + 1 - i32
-i64 + 1 .. i
-i64 + 1 < i32
-i64 + 1 < i64
-i64 + 1 <= i
-i64 + 1 == i
-i64 + abs(1)
+i64 + 0.5 + i64
+i64 + 0.5 - f64
+i64 + 0.5 <= bitnand(1, 1)
+i64 + 0.5 <= f64
+i64 + 0.5 == f32
+i64 + 1 != f64
+i64 + 1 % i64
+i64 + 1 + f64
+i64 + 1 <= f32
+i64 + array[i64]
+i64 + array[i]
 i64 + f32
-i64 + f32 ** 1
-i64 + f32 >= f64
+i64 + f32 * f64
+i64 + f32 / i64
 i64 + f64
-i64 + f64 != f32
-i64 + f64 + i
-i64 + f64 <= f32
-i64 + f64 == i32
-i64 + findIndex(list, ok)
-i64 + first(array)
-i64 + get(array, i32)
+i64 + f64 * 0.5
+i64 + f64 ** 0.5
+i64 + f64 > f32
+i64 + float(f32)
+i64 + float(i32)
 i64 + half(0.5)
-i64 + half(f64)
 i64 + i
-i64 + i + i
-i64 + i - f64
-i64 + i / 1
+i64 + i % 1
+i64 + i * 0.5
+i64 + i + f32
+i64 + i - i32
+i64 + i / i32
+i64 + i == 0.5 - i32
+i64 + i ^ f32
+i64 + i ^ f64
 i64 + i32
-i64 + i32 * 1
-i64 + i32 * i
-i64 + i32 < f64
-i64 + i32 >= f32
-i64 + i32 in array
+i64 + i32 % i64
+i64 + i32 - 0.5
+i64 + i32 == f64
 i64 + i64
-i64 + i64 % i64
-i64 + i64 ** f32
-i64 + i64 + 0.5
-i64 + i64 - int(f64)
-i64 + i64 ^ i
-i64 + max(f32)
-i64 + min(0.5)
-i64 + min(1)
-i64 + min(f32)
-i64 + min(i32)
+i64 + i64 - 0.5
+i64 + reduce(array, #)
 i64 + score(i)
 i64 - -1
 i64 - -f32
 i64 - -i32
 i64 - -i64
-i64 - 0.5 != i32
-i64 - 0.5 * 1
 i64 - 0.5 + f32
-i64 - 0.5 + f64
-i64 - 0.5 / f64
-i64 - 0.5 == -0.5
-i64 - 0.5 ^ i32
-i64 - 1 - 0.5
-i64 - 1 - f32
-i64 - 1 - i32
+i64 - 0.5 / i64
+i64 - 0.5 <= i
+i64 - 0.5 ^ f32
+i64 - 1 ** 1
+i64 - 1 < i
 i64 - 1 == i32
-i64 - 1 >= f64
+i64 - 1 > f32
 i64 - 1 >= i
-i64 - abs(1)
-i64 - abs(i32)
-i64 - array[i64]
+i64 - 1 not in array
+i64 - ceil(1)
 i64 - f32
-i64 - f32 != score(i)
-i64 - f32 * i32
+i64 - f32 != f32
 i64 - f32 - 1
-i64 - f32 <= f64
-i64 - f32 ^ f32
+i64 - f32 - i
+i64 - f32 / 1
+i64 - f32 < i64
+i64 - f32 >= f64
 i64 - f64
-i64 - f64 ** 0.5
+i64 - f64 != i
+i64 - f64 ** f32
+i64 - f64 ** i32
+i64 - f64 + f32
+i64 - f64 + i32
+i64 - f64 >= f64
 i64 - float(0.5)
-i64 - float(f32)
-i64 - float(i)
+i64 - half(1)
+i64 - half(f64)
 i64 - i
-i64 - i != i32
-i64 - i * i64
-i64 - i + i32
-i64 - i - i64
-i64 - i > f64 - 0.5
-i64 - i >= i
+i64 - i * 1
+i64 - i + i64
+i64 - i - 1
+i64 - i .. i64
+i64 - i < i32
+i64 - i > 1 - 0.5
+i64 - i >= f64
 i64 - i ^ i64
+i64 - i not in array
 i64 - i32
-i64 - i32 % i32
-i64 - i32 + i32
-i64 - i32 <= i
+i64 - i32 - i64
+i64 - i32 .. i64
+i64 - i32 > i
+i64 - i32 >= i
 i64 - i64
-i64 - i64 + i32
-i64 - i64 .. i64
-i64 - i64 / i32
-i64 - max(f64)
-i64 - min(1, 0.5)
+i64 - i64 > f32
+i64 - int(i)
+i64 - len("foo")
+i64 - max(0.5)
+i64 - min(f32)
+i64 - min(f64)
+i64 - min(i)
+i64 - reduce(array, #)
+i64 - reduce(array, i64)
+i64 - round(1)
 i64 - score(1)
+i64 - score(i)
 i64 .. -1
+i64 .. -i
+i64 .. -i32
 i64 .. -i64
-i64 .. 1 == list
-i64 .. findIndex(list, ok)
+i64 .. 1 * i64
+i64 .. 1 - 1
+i64 .. 1 - i
+i64 .. 1 - i64
+i64 .. abs(i)
+i64 .. bitnot(i32)
+i64 .. count(array, false)
 i64 .. get(array, 1)
 i64 .. i
+i64 .. i * i
+i64 .. i + 1
+i64 .. i == list
 i64 .. i32
-i64 .. i32 * i
+i64 .. i32 * 1
 i64 .. i64
-i64 .. i64 + 1
+i64 .. i64 * i32
+i64 .. i64 + i
+i64 .. i64 - i
+i64 .. int(0.5)
 i64 .. int(f32)
-i64 .. int(i32)
-i64 .. last(array)
-i64 .. len(list)
+i64 .. int(i64)
+i64 .. min(i32)
+i64 .. min(i64, 0.5)
+i64 .. reduce(array, #)
 i64 .. score(1)
-i64 / (0.5 + f64)
-i64 / (1 - 0.5)
-i64 / (i32 - 1)
+i64 / (f32 + i64)
+i64 / (f32 - i)
+i64 / (i + 1)
+i64 / (i32 + 0.5)
+i64 / (i64 - i)
 i64 / -0.5
 i64 / -1
 i64 / -f32
 i64 / -f64
 i64 / -i
-i64 / -i64
-i64 / 0.5 < f64
-i64 / 0.5 == f32
-i64 / 0.5 ^ f64
-i64 / 1 ** 1
-i64 / 1 - f32
-i64 / 1 - min(0.5)
-i64 / 1 / 0.5
-i64 / abs(i64)
-i64 / array[i]
+i64 / 0.5 * f64
+i64 / 0.5 - i64
+i64 / 0.5 / i
+i64 / 0.5 == i
+i64 / 1 ** i64
+i64 / 1 / i32
+i64 / 1 / i64
+i64 / 1 < i
+i64 / 1 == f32
+i64 / ceil(i)
 i64 / f32
-i64 / f32 ** i
-i64 / f32 <= i
+i64 / f32 - i
+i64 / f32 / i64
+i64 / f32 > i
+i64 / f32 ^ 1
+i64 / f32 ^ i
 i64 / f64
-i64 / f64 * 1
-i64 / f64 ** 0.5
-i64 / f64 ** f64
-i64 / f64 + i32
-i64 / f64 <= f32
-i64 / f64 <= i64
-i64 / float(f32)
-i64 / float(f64)
-i64 / float(i)
-i64 / float(i64)
-i64 / half(0.5)
-i64 / half(f64)
+i64 / f64 * i64
+i64 / f64 - min(i64)
+i64 / f64 / f32
+i64 / f64 / i * 0.5
+i64 / f64 / i32
+i64 / f64 in array
+i64 / float(1)
+i64 / get(array, i32)
+i64 / half(1)
 i64 / i
-i64 / i != i64
-i64 / i * 0.5
-i64 / i * f32
-i64 / i - i32
-i64 / i ^ i64
+i64 / i * i64
+i64 / i - f64
 i64 / i32
-i64 / i32 * i
+i64 / i32 != f32
+i64 / i32 * f64
+i64 / i32 == f64
+i64 / i32 > 1 + 1
+i64 / i32 >= f32
+i64 / i32 >= f64
+i64 / i32 ^ f32
 i64 / i64
-i64 / i64 ** f32
-i64 / i64 - f64
-i64 / i64 / i64
-i64 / i64 < f32
-i64 / int(0.5)
-i64 / min(f32)
+i64 / i64 + f64
+i64 / i64 < i32
+i64 / i64 <= f32
+i64 / i64 == i32
+i64 / int(1)
+i64 / len(list)
+i64 / max(1)
+i64 / reduce(array, #)
+i64 / reduce(array, 1)
+i64 / round(0.5)
+i64 / round(i)
 i64 / score(1)
+i64 / score(i)
+i64 < -0.5
 i64 < -1
+i64 < -f32
+i64 < -f64
+i64 < -i
 i64 < -i32
 i64 < -i64
-i64 < 1 != true
-i64 < 1 * f64
+i64 < 0.5 * 0.5
+i64 < 0.5 + i
+i64 < 0.5 - 1
+i64 < 0.5 / 0.5
+i64 < 0.5 / 1
+i64 < 0.5 == ok
+i64 < 0.5 || false ? 1 : nil
+i64 < 1 * i32
+i64 < 1 ** 0.5
+i64 < 1 + 0.5
 i64 < 1 + i64
-i64 < 1 / i32
-i64 < 1 ? half : ok
-i64 < 1 ^ f64
-i64 < abs(f32)
-i64 < array[1]
+i64 < 1 / f32
+i64 < ceil(i64)
 i64 < f32
-i64 < f32 * i32
-i64 < f32 ? "bar" : ok
-i64 < f32 ^ 0.5
+i64 < f32 * 0.5
+i64 < f32 - i64
+i64 < f32 ^ f32
 i64 < f64
-i64 < f64 + f64
-i64 < f64 - f32
-i64 < f64 - i
-i64 < f64 ? i64 : score
-i64 < f64 or ok
-i64 < float(f64)
-i64 < half(0.5)
+i64 < f64 && ok
+i64 < f64 - f64
+i64 < f64 ? score : add
+i64 < float(0.5)
+i64 < float(i32)
+i64 < floor(0.5)
+i64 < floor(i32)
+i64 < half(1)
 i64 < i
-i64 < i != false
+i64 < i % i64
+i64 < i ^ 0.5
+i64 < i || ok
 i64 < i32
-i64 < i32 * 1
-i64 < i32 + i64
-i64 < i32 - 0.5
-i64 < i32 - f32
-i64 < i32 ? greet : 1
-i64 < i32 ? nil : array
-i64 < i32 ? true : "bar"
+i64 < i32 + 1
+i64 < i32 + i32
+i64 < i32 / f32
+i64 < i32 ? foo : i
 i64 < i64
-i64 < i64 + 1
-i64 < i64 ? f32 : foo
-i64 < i64 ? half : i
-i64 < int(i64)
-i64 < max(0.5)
-i64 < min(0.5)
-i64 < min(i)
-i64 < score(1)
-i64 < score(1) * i64
+i64 < i64 != nil
+i64 < i64 * 1
+i64 < i64 * i64
+i64 < i64 / f32
+i64 < i64 / i
+i64 < i64 ^ 1
+i64 < i64 ^ i
+i64 < int(f64)
+i64 < len("bar")
+i64 < len("foo")
+i64 <= -0.5
 i64 <= -1
 i64 <= -f32
-i64 <= -i
-i64 <= -i32
+i64 <= -f64
 i64 <= -i64
-i64 <= 0.5 != true
-i64 <= 0.5 + i
-i64 <= 0.5 - 1
-i64 <= 0.5 == nil
-i64 <= 0.5 ? 0.5 : "foo"
-i64 <= 1 != true
-i64 <= 1 ** f64
+i64 <= 0.5 && ok
+i64 <= 0.5 * 0.5
+i64 <= 0.5 + 1
+i64 <= 0.5 ? i : i32
+i64 <= 1 ** i32
+i64 <= 1 + 1
+i64 <= 1 - 0.5
+i64 <= 1 - 1
+i64 <= 1 / 1
 i64 <= 1 == ok
-i64 <= 1 ? array : ok
-i64 <= 1 and ok
-i64 <= array[i32]
+i64 <= 1 ? add : div
+i64 <= 1 ? f32 : greet
+i64 <= 1 ? i64 : true
+i64 <= 1 ^ 1
+i64 <= array[i64]
+i64 <= array[i]
+i64 <= bitnot(1)
 i64 <= f32
-i64 <= f32 && ok
-i64 <= f32 + 1
-i64 <= f32 / f32
-i64 <= f32 ^ i32
+i64 <= f32 ** i
+i64 <= f32 ** i64
+i64 <= f32 == ok
 i64 <= f64
 i64 <= f64 + 1
-i64 <= f64 - f32
-i64 <= half(0.5)
+i64 <= f64 + f32
+i64 <= f64 / 1
+i64 <= f64 ? nil : i32
+i64 <= float(1)
+i64 <= floor(i)
+i64 <= floor(i32)
+i64 <= half(min(0.5, 1, i64))
 i64 <= i
-i64 <= i != true
 i64 <= i * 1
-i64 <= i + 1
-i64 <= i / i64
-i64 <= i ? i32 : list
-i64 <= i ^ 0.5
+i64 <= i * f32
+i64 <= i ** i32
+i64 <= i ? greet : add
 i64 <= i32
-i64 <= i32 && ok
-i64 <= i32 ? f64 : i < 1
+i64 <= i32 ** i32
+i64 <= i32 ? list : half
+i64 <= i32 ^ -1
 i64 <= i64
-i64 <= i64 - 0.5
-i64 <= i64 ? greet : div
-i64 <= int(i64)
-i64 <= last(array)
+i64 <= i64 * i
+i64 <= len(list)
+i64 <= max(f32)
 i64 <= min(0.5)
-i64 <= min(f64)
-i64 <= score(1)
-i64 <= score(i)
-i64 == -0.5
+i64 <= min(i32)
+i64 <= reduce(array, i32)
+i64 <= reduce(list, i64)
+i64 <= round(0.5)
 i64 == -1
+i64 == -f32
 i64 == -f64
 i64 == -i
+i64 == -i32
+i64 == 0.5 * 1
+i64 == 0.5 - f64
 i64 == 0.5 == ok
-i64 == 0.5 ? 1 : list
-i64 == 0.5 ? div : i64
-i64 == 0.5 ? foo : f32
-i64 == 0.5 ^ 0.5
-i64 == 0.5 ^ i
-i64 == 1 % i64
-i64 == 1 && ok
+i64 == 0.5 ? 0.5 : f64
 i64 == 1 ** f64
-i64 == 1 + f32
-i64 == 1 - f64
-i64 == abs(0.5)
-i64 == abs(i32)
-i64 == count(array, true)
-i64 == count(list, true)
+i64 == 1 + 0.5
+i64 == 1 / i
+i64 == 1 == ok
+i64 == 1 ? "foo" : i
+i64 == array[1]
+i64 == bitnot(i64)
+i64 == ceil(i64)
 i64 == f32
+i64 == f32 != true
+i64 == f32 + i
+i64 == f32 - f32
+i64 == f32 == ok
 i64 == f64
-i64 == f64 != ok
-i64 == f64 != true
-i64 == f64 - i
-i64 == f64 ? f64 : add
-i64 == findIndex(array, false)
+i64 == f64 * f64
+i64 == f64 ? 1 : nil
+i64 == f64 ^ 0.5
+i64 == f64 ^ f32
+i64 == f64 and not true
+i64 == findIndex(list, f64 <= f64)
+i64 == floor(0.5)
+i64 == get(array, 1)
+i64 == half(1)
 i64 == i
-i64 == i * f32
-i64 == i == false
-i64 == i == ok
-i64 == i ^ 1
+i64 == i != nil
+i64 == i + i32
+i64 == i ? i64 : foo
 i64 == i32
-i64 == i32 ** 0.5
-i64 == i32 / f64
 i64 == i64
-i64 == i64 ^ 0.5
+i64 == i64 * f32
+i64 == i64 / i64
+i64 == i64 ? add : 0.5
+i64 == i64 ? add : greet
+i64 == int(0.5)
 i64 == int(1)
-i64 == int(f32)
-i64 == last(array)
-i64 == max(0.5)
-i64 == nil ? true : ok
+i64 == int(i)
+i64 == len("foo")
+i64 == nil != nil
+i64 == reduce(array, #)
 i64 == score(1)
-i64 == score(i)
 i64 > -0.5
-i64 > -1
 i64 > -f32
 i64 > -f64
-i64 > -i
-i64 > -i32
-i64 > -i64
-i64 > 0.5 * 1
-i64 > 0.5 ** 0.5
-i64 > 0.5 == true
-i64 > 0.5 ? f64 : greet
-i64 > 0.5 ? foo : add
-i64 > 1 ** 0.5
-i64 > 1 - 0.5
-i64 > 1 ? false : array
-i64 > 1 ? half : i64
-i64 > abs(1)
-i64 > abs(f64)
-i64 > array[i64]
+i64 > 0.5 + f32
+i64 > 0.5 - f64
+i64 > 0.5 - i32
+i64 > 0.5 ? array : 1
+i64 > 0.5 ? f32 : nil
+i64 > 0.5 ? ok : nil
+i64 > 0.5 ? score : foo
+i64 > 0.5 or ok
+i64 > 1 != true
+i64 > 1 ** 1
+i64 > 1 == false
+i64 > 1 ? nil : 1
+i64 > 1 ^ f32
+i64 > 1 ^ i32
 i64 > f32
-i64 > f32 - 1
-i64 > f32 ? div : false
+i64 > f32 * 0.5
+i64 > f32 + f64
+i64 > f32 / f32
+i64 > f32 ? "foo" : greet
+i64 > f32 ? 1 : i32
 i64 > f64
-i64 > f64 == nil
-i64 > f64 and 1 > i64
+i64 > f64 * i
+i64 > f64 - 0.5
+i64 > f64 - f32
 i64 > first(array)
-i64 > float(f32)
-i64 > half(f64)
+i64 > half(0.5)
 i64 > i
-i64 > i % i32
-i64 > i * f64
-i64 > i ** 1
-i64 > i + i
-i64 > i + i32
-i64 > i ^ i32
+i64 > i != nil
+i64 > i == true
 i64 > i32
-i64 > i32 && ok
-i64 > i32 ** 0.5
-i64 > i32 ** i
+i64 > i32 ? div : f32
+i64 > i32 ^ f32
 i64 > i64
-i64 > i64 % i32
-i64 > i64 - i64
-i64 > int(f32)
-i64 > int(i32)
-i64 > int(i64)
+i64 > i64 - i
+i64 > i64 - i32
+i64 > i64 / f64
+i64 > i64 == false
+i64 > len(list)
+i64 > max(0.5)
+i64 > min(1)
+i64 > min(i32)
+i64 > reduce(array, #)
+i64 > reduce(array, 1)
+i64 > round(0.5)
+i64 > round(i32)
 i64 > score(i)
 i64 >= -0.5
 i64 >= -1
-i64 >= -f64
 i64 >= -i
-i64 >= 0.5 * f64
-i64 >= 0.5 ** f32
-i64 >= 0.5 + f32
+i64 >= -i64
+i64 >= 0.5 / i
 i64 >= 0.5 == nil
-i64 >= 0.5 == true
-i64 >= 0.5 ? array : array
-i64 >= 0.5 ? i32 : nil
-i64 >= 0.5 ^ 0.5
-i64 >= 0.5 and f32 != nil
-i64 >= 1 + f64
-i64 >= 1 + i32
-i64 >= 1 ? i : false
-i64 >= 1 ? i : string(array)
-i64 >= 1 ? true : i
+i64 >= 0.5 ? 0.5 : f64
+i64 >= 0.5 ^ i
+i64 >= 1 % i64
+i64 >= 1 * f64
+i64 >= 1 * i64
+i64 >= abs(i64)
+i64 >= array[i32]
+i64 >= bitnot(1)
 i64 >= f32
-i64 >= f32 * f32
-i64 >= f32 ** f64
-i64 >= f32 ** i32
-i64 >= f32 / f64
+i64 >= f32 + f32
+i64 >= f32 - f32
+i64 >= f32 ? array : i
+i64 >= f32 ? f32 : i32
+i64 >= f32 ? list : f32
 i64 >= f64
-i64 >= f64 + i
-i64 >= f64 / i64
-i64 >= f64 == ok
-i64 >= f64 and ok
-i64 >= find(array, ok)
+i64 >= f64 + 0.5
+i64 >= first(array)
+i64 >= float(0.5)
 i64 >= float(f32)
-i64 >= float(i)
-i64 >= float(i32)
+i64 >= floor(1)
+i64 >= floor(i64)
 i64 >= half(0.5)
+i64 >= half(half(f64))
 i64 >= i
-i64 >= i and ok
+i64 >= i / 0.5
+i64 >= i ? true : i32
 i64 >= i32
-i64 >= i32 % i64
+i64 >= i32 * i
+i64 >= i32 / f32
+i64 >= i32 == false
+i64 >= i32 || f64 == 1
 i64 >= i64
-i64 >= i64 % i
-i64 >= i64 && i64 > f32
-i64 >= i64 / i32
-i64 >= i64 == nil
-i64 >= i64 in {"foo": f64}.half
-i64 >= max(f64)
+i64 >= i64 + 1
+i64 >= i64 ? foo : foo
+i64 >= i64 or ok
+i64 >= int(f64)
+i64 >= last(array)
 i64 >= max(i64)
-i64 >= min(f32)
+i64 >= min(1)
+i64 >= min(f64)
+i64 >= round(1)
+i64 >= round(i)
 i64 >= score(1)
-i64 ^ (0.5 + 1)
-i64 ^ (0.5 / i32)
-i64 ^ (1 * f32)
-i64 ^ (1 / i)
-i64 ^ (1 / i64)
-i64 ^ (f32 + f32)
-i64 ^ (f32 - f32)
-i64 ^ (f64 * f32)
-i64 ^ (i % i32)
-i64 ^ (i - 0.5)
-i64 ^ (i32 - f32)
-i64 ^ (i64 + i32)
-i64 ^ (i64 / f64)
+i64 ^ (0.5 * i32)
+i64 ^ (0.5 / i64)
+i64 ^ (1 * f64)
+i64 ^ (1 - i)
+i64 ^ (f32 / 1)
+i64 ^ (i % i)
+i64 ^ (i32 * f64)
+i64 ^ (i32 - f64)
+i64 ^ (i64 + 0.5)
+i64 ^ (i64 + 1)
+i64 ^ (i64 - f32)
 i64 ^ -0.5
-i64 ^ -i32
-i64 ^ 0.5 ** f32
-i64 ^ 0.5 <= i
-i64 ^ 0.5 >= f32
-i64 ^ 0.5 >= f64
-i64 ^ 0.5 >= i64
-i64 ^ 0.5 ^ 0.5
-i64 ^ 1 != i
-i64 ^ 1 != i32
+i64 ^ -1
+i64 ^ -f32
+i64 ^ -i64
+i64 ^ 0.5 != i64
+i64 ^ 0.5 ** 0.5
+i64 ^ 0.5 / f32
+i64 ^ 0.5 <= i64
+i64 ^ 0.5 == i
+i64 ^ 0.5 ^ f32
+i64 ^ 0.5 ^ i64
+i64 ^ 1 * i64
+i64 ^ 1 * round(0.5)
+i64 ^ 1 ** f64
 i64 ^ 1 ** i32
-i64 ^ 1 + f32
-i64 ^ 1 < f32
-i64 ^ 1 <= i
+i64 ^ 1 - f32
+i64 ^ 1 < f64
+i64 ^ 1 >= f32
+i64 ^ 1 >= half(1)
+i64 ^ 1 ^ f32
+i64 ^ 1 ^ i32
 i64 ^ abs(1)
-i64 ^ abs(i)
-i64 ^ array[i64]
+i64 ^ array[i]
 i64 ^ f32
-i64 ^ f32 - f32
+i64 ^ f32 * i32
+i64 ^ f32 ** f64
+i64 ^ f32 - f64
+i64 ^ f32 / i - i32
+i64 ^ f32 < f32
+i64 ^ f32 <= i64
+i64 ^ f32 ^ 1
 i64 ^ f64
-i64 ^ f64 * i32
-i64 ^ f64 ** i
-i64 ^ f64 + f32
-i64 ^ f64 < f32
-i64 ^ f64 == i64
-i64 ^ f64 > 1 + i64
+i64 ^ f64 * i
+i64 ^ f64 ** 1
+i64 ^ f64 > i64
 i64 ^ f64 ^ f32
-i64 ^ get(array, i)
-i64 ^ half(f64)
+i64 ^ float(i32)
+i64 ^ floor(i32)
+i64 ^ floor(i64)
+i64 ^ half(0.5)
+i64 ^ half(1)
 i64 ^ i
-i64 ^ i ** f32
-i64 ^ i ** i64
+i64 ^ i * i
+i64 ^ i ** i32
+i64 ^ i + i % 1
+i64 ^ i + i64
+i64 ^ i - f32 ^ 1
+i64 ^ i - f64
+i64 ^ i / i
+i64 ^ i < f32
+i64 ^ i ^ i32
 i64 ^ i32
-i64 ^ i32 != f32
-i64 ^ i32 != i32
-i64 ^ i32 ** i
-i64 ^ i32 + f32
-i64 ^ i32 + f64
-i64 ^ i32 / f32
+i64 ^ i32 * i
+i64 ^ i32 + i32
+i64 ^ i32 + i64
 i64 ^ i64
-i64 ^ i64 * f64
 i64 ^ i64 * i64
-i64 ^ i64 ** f64
-i64 ^ i64 ^ f32
-i64 ^ i64 ^ f64
-i64 ^ i64 ^ i
-i64 ^ int(i64)
-i64 ^ last(array)
-i64 ^ len(array)
+i64 ^ i64 + i
+i64 ^ i64 == i64
+i64 ^ i64 ^ 1
+i64 ^ i64 in array
+i64 ^ int(1)
 i64 ^ max(0.5)
-i64 ^ max(1)
-i64 ^ max(f32)
+i64 ^ reduce(array, #)
+i64 ^ round(i64)
 i64 ^ score(1)
-i64 ^ score(1, 1)
-i64 ^ score(i)
 i64 in array
-i64 in array == nil
-i64 in array ? false : greet
+i64 in array == ok
+i64 in groupBy(array, 0.5)
+i64 in groupBy(array, foo)
+i64 in groupBy(list, "bar")
+i64 in groupBy(list, i)
+i64 in i64 .. i32
 i64 in map(array, #)
+i64 in map(list, 1)
+i64 in map(list, i)
+i64 not in 1 .. i
 i64 not in array
-indexOf("bar", "bar") + i64
-indexOf(foo.Bar, string(i32))
-int(-(i * 0.5))
+i64 not in array ? f32 : i32
+i64 not in array ? ok : f32
+i64 not in map(array, #)
+i64 not in map(list, 0.5)
 int(-0.5)
 int(-1)
-int(-abs(f64))
 int(-f32)
 int(-f64)
 int(-i)
 int(-i32)
-int(-i32) != i
 int(-i64)
 int(0.5 * 0.5)
-int(0.5 * 1)
 int(0.5 * f32)
-int(0.5 * i)
+int(0.5 * f64)
 int(0.5 * i32)
-int(0.5 * i64)
 int(0.5 ** 0.5)
 int(0.5 ** 1)
 int(0.5 ** f32)
 int(0.5 ** f64)
-int(0.5 ** i64)
-int(0.5 + f32)
+int(0.5 ** i32)
+int(0.5 + 0.5)
+int(0.5 + 1)
 int(0.5 + f64)
-int(0.5 + i)
 int(0.5 + i32)
-int(0.5 - 0.5)
+int(0.5 + i64)
 int(0.5 - f32)
+int(0.5 - i)
 int(0.5 - i32)
-int(0.5 / 0.5)
-int(0.5 / 1)
-int(0.5 / f32)
-int(0.5 / f64)
-int(0.5 / i32)
+int(0.5 - i64)
+int(0.5 / i)
 int(0.5 / i64)
-int(0.5 ^ 0.5)
-int(0.5 ^ 1)
-int(0.5 ^ f32)
 int(0.5 ^ i)
-int(0.5) ** i64
-int(0.5) ** int(i64)
-int(0.5) + f32
-int(0.5) + f64
-int(0.5) + i64
-int(0.5) - i
-int(0.5) - i64
-int(0.5) .. i32
-int(0.5) < int(f64)
+int(0.5 ^ i64)
+int(0.5) * -i
+int(0.5) ** f64
+int(0.5) ** i32
+int(0.5) + i
+int(0.5) / i32
+int(0.5) < 0.5 * f64
+int(0.5) <= i
+int(0.5) <= i32
 int(0.5) == f32
-int(0.5) == i
-int(0.5) > -1
-int(0.5) >= i - i64
+int(0.5) > -i64
+int(0.5) > i
+int(0.5) >= f32
+int(0.5) >= i32
+int(0.5) >= max(0.5)
 int(0.5) ^ i32
-int(0.5) ^ i64
-int(0.5) in array
-int(0.5) not in array
-int(1 % 1)
 int(1 % i)
-int(1 % i32)
-int(1 * 0.5)
 int(1 * f32)
-int(1 * f64)
 int(1 * i)
-int(1 * i64)
-int(1 ** 0.5)
-int(1 ** 1)
-int(1 ** f32)
-int(1 ** i32)
-int(1 ** i64)
-int(1 + 0.5)
+int(1 * i32)
+int(1 ** i)
 int(1 + 1)
+int(1 + f32)
 int(1 + f64)
-int(1 + i)
+int(1 + i32)
 int(1 - 0.5)
-int(1 - 1)
+int(1 - f32)
+int(1 - f64)
+int(1 - i32)
 int(1 - i64)
+int(1 / 0.5)
 int(1 / 1)
-int(1 / f64)
-int(1 / i32)
-int(1 / i64)
 int(1 ^ 0.5)
-int(1 ^ 1)
-int(1 ^ i32)
 int(1 ^ i64)
-int(1) * f64
-int(1) * i
+int(1) != i64
 int(1) ** f32
-int(1) ** i64
-int(1) + 0.5 + 1
+int(1) ** i32
+int(1) + f32
 int(1) + i64
-int(1) - f64
-int(1) - i64
-int(1) .. i
-int(1) / f32
-int(1) / i
+int(1) + reduce(array, #)
+int(1) - i
 int(1) < f64
-int(1) <= f32
-int(1) <= f64
-int(1) == i
-int(1) == i64
-int(1) > f64
-int(1) > float(1)
-int(1) > i32
-int(1) >= f32
-int(1) >= f64
-int(1) >= half(0.5)
-int(1) ^ f32
+int(1) < i64 * 0.5
+int(1) == i32
 int(1) ^ f64
-int(1) ^ i
-int(1) ^ i32
-int(1) in array
 int(abs(0.5))
-int(abs(f32))
+int(abs(1))
 int(abs(f64))
 int(abs(i))
 int(abs(i32))
 int(abs(i64))
-int(array[1])
-int(array[i32])
+int(add(1, 1))
 int(array[i64])
-int(count(list, ok))
-int(div(1, i))
-int(f32 * f32)
-int(f32 * i64)
+int(bitnot(1))
+int(bitnot(i32))
+int(bitnot(i64))
+int(bitshl(1, i))
+int(bitxor(1, i32) + i)
+int(bitxor(i32, i))
+int(ceil(0.5))
+int(ceil(1))
+int(ceil(f32))
+int(ceil(half(1)))
+int(ceil(i))
+int(ceil(i32))
+int(count(array, ok))
+int(count(list, false))
+int(f32 * 1)
+int(f32 * i)
 int(f32 ** 0.5)
-int(f32 ** f64)
-int(f32 ** i32)
+int(f32 ** i64)
 int(f32 + f32)
-int(f32 + i64)
 int(f32 - 0.5)
-int(f32 - f32)
-int(f32 - i)
+int(f32 - i64)
+int(f32 / 0.5)
+int(f32 / 1)
 int(f32 / f64)
-int(f32 ^ 1)
+int(f32 / i32)
+int(f32 / i64)
 int(f32 ^ f32)
-int(f32 ^ i)
-int(f32 ^ i64)
+int(f32 ^ i32)
 int(f32)
-int(f32) != f32
-int(f32) % i
-int(f32) * f64
-int(f32) .. i32
-int(f32) / f32
-int(f32) / i
-int(f32) == 0.5 != nil
-int(f32) == i
-int(f32) > i
-int(f32) >= i32
-int(f32) ^ i64
-int(f32) in array
+int(f32) != i
+int(f32) != i64
+int(f32) ** f64
+int(f32) + i32
+int(f32) - f32
+int(f32) < i
+int(f32) <= i32
+int(f32) == i ? list : add
 int(f64 * 0.5)
-int(f64 * 1)
-int(f64 * f32)
-int(f64 * f64)
-int(f64 * i32)
-int(f64 * i64)
-int(f64 ** 0.5)
 int(f64 ** 1)
-int(f64 ** f32)
 int(f64 ** i)
 int(f64 ** i32)
-int(f64 ** i64)
-int(f64 + f32)
-int(f64 + i64)
+int(f64 + 0.5)
+int(f64 + 1)
+int(f64 + i)
 int(f64 - 0.5)
-int(f64 - 1)
-int(f64 - f64)
-int(f64 / 1)
-int(f64 / i)
+int(f64 - f32)
+int(f64 / 0.5)
+int(f64 / i64)
 int(f64 ^ 0.5)
 int(f64 ^ 1)
-int(f64 ^ f32)
+int(f64 ^ f64)
+int(f64 ^ i64)
 int(f64)
-int(f64) != i32
-int(f64) * i32
-int(f64) ** i64
-int(f64) - i
+int(f64) % i64
+int(f64) * f64
+int(f64) + f64
 int(f64) < i32
-int(f64) <= i32
-int(f64) == float(i32)
-int(f64) ^ i32
-int(f64) ^ i64
-int(f64) not in array
-int(false ? add : 0.5)
-int(false ? f32 : 0.5)
-int(false ? f64 : i32)
-int(find(array, true))
-int(findIndex(array, ok))
-int(findIndex(array, true))
-int(findIndex(list, # == foo))
+int(f64) == f32
+int(f64) == f64
+int(f64) > i
+int(f64) > i64
+int(false ? 0.5 : 0.5)
+int(false ? i : 0.5)
 int(findIndex(list, ok))
-int(findLastIndex(array, ok))
-int(findLastIndex(array, true))
-int(findLastIndex(list, true))
+int(findLastIndex(list, ok))
 int(first(array))
 int(float(0.5))
 int(float(1))
 int(float(f32))
-int(float(f64) ** i64)
 int(float(f64))
-int(float(i))
+int(float(i32 ** i))
 int(float(i32))
-int(float(i64))
-int(get(array, 1))
+int(floor(f64))
+int(floor(i))
+int(floor(i32))
 int(get(array, i64))
 int(half(0.5))
-int(half(1 / f32))
+int(half(1))
 int(half(f64))
 int(i % 1)
+int(i % i32)
 int(i % i64)
 int(i * 0.5)
 int(i * 1)
-int(i * f32)
 int(i * f64)
-int(i ** 0.5)
 int(i ** f32)
 int(i ** f64)
 int(i ** i64)
-int(i + 0.5)
 int(i + f32)
-int(i + i32)
-int(i + i64)
-int(i - f64)
+int(i + f64)
+int(i + i)
+int(i - 0.5)
+int(i - f32)
+int(i - i32)
 int(i - i64)
-int(i / 1) <= i32
-int(i / f64)
+int(i / 0.5)
+int(i / 1)
 int(i / i)
-int(i ^ f32)
-int(i ^ f64)
-int(i ^ i)
+int(i / i32)
+int(i ^ 0.5)
+int(i ^ 1)
 int(i ^ i32)
 int(i)
-int(i) != i
-int(i) + f32
-int(i) + i32
-int(i) - i32
+int(i) != i32
+int(i) * f64
+int(i) * i64
+int(i) - i
 int(i) .. i64
-int(i) / i
-int(i) < f32
-int(i) < f64
-int(i) <= f64
-int(i) == f32
-int(i) > i32
-int(i) > i64
-int(i) > int(i)
-int(i) >= i
-int(i) ^ i64
-int(i32 % i64)
 int(i32 * 0.5)
 int(i32 * 1)
-int(i32 * f64)
-int(i32 ** i)
+int(i32 * i64)
+int(i32 ** 0.5)
+int(i32 ** 1)
 int(i32 + 0.5)
 int(i32 + 1)
-int(i32 + f32)
-int(i32 - 0.5)
+int(i32 + f64)
+int(i32 + i64)
 int(i32 - 1)
-int(i32 - f64)
 int(i32 - i)
-int(i32 - i64)
 int(i32 / 0.5)
+int(i32 / 1)
 int(i32 / f64)
 int(i32 ^ 0.5)
-int(i32 ^ f32)
 int(i32 ^ f64)
-int(i32 ^ i)
-int(i32 ^ i64)
+int(i32 ^ i32)
 int(i32)
 int(i32) != f32
-int(i32) % i64
-int(i32) ** -0.5
-int(i32) + i
-int(i32) - f32
-int(i32) .. i32
+int(i32) - i
+int(i32) / f32
 int(i32) / i
-int(i32) / i32
+int(i32) / i64
 int(i32) < i64
-int(i32) <= f32
-int(i32) == -i32
-int(i32) == f64
-int(i32) > f64
-int(i64 % i32)
-int(i64 * f32)
-int(i64 * f64)
-int(i64 * i)
-int(i64 ** i)
-int(i64 + 1)
+int(i32) > half(0.5)
+int(i64 * 1)
+int(i64 ** 0.5)
+int(i64 ** f64)
+int(i64 ** i64)
 int(i64 + i)
-int(i64 + i64)
+int(i64 + i32)
+int(i64 - 0.5)
 int(i64 - f32)
-int(i64 - f64)
-int(i64 - i32)
-int(i64 / f32)
-int(i64 / f64)
-int(i64 / i)
-int(i64 / i64)
-int(i64 ^ 0.5)
+int(i64 - i)
+int(i64 - i64)
+int(i64 / 1)
 int(i64 ^ f64)
 int(i64 ^ i32)
 int(i64 ^ i64)
 int(i64)
-int(i64) != f64
-int(i64) != i
-int(i64) != nil ? 1 : half
-int(i64) % i
-int(i64) % i32
-int(i64) ** f64
-int(i64) - i32
+int(i64) != i64
+int(i64) - i64
 int(i64) .. i32
+int(i64) / i
 int(i64) <= i
-int(i64) <= i64
-int(i64) == min(i)
-int(i64) > f64
-int(i64) > i32
-int(i64) >= f64
-int(i64) ^ f32
-int(i64) ^ i32
-int(i64) in array
-int(i64) not in array
+int(i64) == f32
+int(i64) > i64
+int(i64) ^ i
 int(int(0.5))
 int(int(1))
-int(int(f32))
 int(int(f64))
-int(int(i32))
-int(int(i64))
-int(last(array))
 int(len("bar"))
 int(len(array))
-int(len(list))
 int(max(0.5))
+int(max(0.5, i64))
 int(max(1))
+int(max(f32))
 int(max(f64))
 int(max(i))
 int(max(i64))
+int(mean(array))
 int(min(0.5))
 int(min(1))
+int(min(1, i64))
 int(min(f32))
-int(min(f32, i32))
-int(min(f64))
-int(min(f64, 1))
 int(min(i))
 int(min(i32))
 int(min(i64))
-int(min(i64, 1))
-int(ok ? 0.5 : i64)
-int(ok ? 1 : div)
-int(ok ? i32 : add)
+int(ok ? i : div)
+int(ok ? i : i64)
+int(ok ? i64 : list)
+int(reduce(array, #))
+int(reduce(array, f32))
+int(reduce(array, i32))
+int(reduce(list, 0.5))
+int(reduce(list, 1))
+int(reduce(list, i64))
+int(round(0.5))
+int(round(1))
+int(round(f32))
+int(round(f64))
+int(round(i))
 int(score(1))
+int(score(1, i))
 int(score(i))
 int(string(1))
 int(string(i))
 int(string(i32))
 int(string(i64))
-int(toJSON(1))
+int(sum(array))
 int(toJSON(i))
 int(toJSON(i32))
 int(toJSON(i64))
-int(true ? f64 : 0.5)
-int(true ? f64 : 1)
-join(["bar"])
-join(map(array, "bar"))
+int(true ? 1 : foo)
+int(true ? f64 : greet)
 join(map(array, "foo"))
-join(map(list, "bar"))
-keys({"bar": i64})
-keys({"foo": 0.5})
-keys({"foo": f32})
-keys({"foo": i})
-last(1 .. i32)
+join(map(list, "foo"))
+keys(groupBy(array, "foo"))
+keys(groupBy(array, # ** 0.5))
+keys(groupBy(array, #))
+keys(groupBy(array, f32 != f64))
+keys(groupBy(array, foo))
+keys(groupBy(array, i32))
+keys(groupBy(array, ok))
+keys(groupBy(list, "bar"))
+keys(groupBy(list, #))
+keys(groupBy(list, false))
+keys(groupBy(list, i32))
+keys({"bar": 1})
+keys({"bar": array, "foo": "bar"})
+keys({"bar": f32})
+keys({"foo": array, "bar": f64})
+keys({"foo": array})
+last(1 .. 1)
+last(1 .. i)
 last([0.5])
-last([array])
-last([f64])
-last([half, i32])
+last([f32, list])
+last([list, list])
 last(array)
-last(array) != f32
-last(array) != i32
-last(array) % i32
-last(array) * i32
-last(array) + f32
-last(array) + i
+last(array) != int(i64)
+last(array) + f64
 last(array) - f32
 last(array) - i64
-last(array) - score(i)
-last(array) .. max(i)
-last(array) / f64
-last(array) > f64
-last(array) > max(1)
-last(array) >= f32
+last(array) .. i32
+last(array) / f32
+last(array) <= i32
+last(array) == f32
+last(array) > f32 * i64
 last(array) >= f64
-last(false ? 0.5 : greet)
-last(false ? div : 1)
-last(false ? f32 : 1)
-last(false ? list : 1)?.add
-last(false ? list : add)
+last(false ? "foo" : true)
+last(false ? 0.5 : "bar")
+last(false ? 1 : foo)?.div
+last(false ? div : score)
+last(false ? f64 : false)
 last(filter(array, false))
 last(filter(array, ok))
 last(filter(list, true))
-last(i .. i32)
-last(i32 .. i32)
+last(groupBy(array, foo).Qux)
+last(groupBy(array, i32).Qux)
+last(groupBy(list, #).list)
+last(groupBy(list, #)?.Qux)
+last(groupBy(list, #)?.ok)
+last(i32 .. 1)
 last(i32 .. i64)
-last(i64 .. i)
+last(i64 .. 1)
 last(list)
-last(list) == foo
-last(list) not in list
 last(list).Bar
 last(list).Qux
 last(list).String
@@ -9260,181 +11909,155 @@ last(list)?.Bar
 last(list)?.Qux
 last(list)?.String
 last(list)?.String()
-last(map(array, "bar"))
+last(list[1:i64])
 last(map(array, #))
+last(map(array, 1))
 last(map(array, array))
-last(map(array, i64))
-last(map(list, "bar"))
+last(map(array, foo))
+last(map(array, i))
 last(map(list, "foo"))
 last(map(list, #))
-last(map(list, 0.5))
-last(map(list, add))
-last(map(list, f32))
-last(map(list, foo))
-last(map(list, i))
+last(map(list, 1))
+last(map(list, false))
+last(map(list, half))
 last(map(list, i32))
-last(map(list, true))
-last(ok ? 0.5 : score)
-last(ok ? array : false)
-last(ok ? foo : add != half)
-last(ok ? nil : list)
-last(ok ? ok : i32)
-last(true ? 1 : list)?.String
-last(true ? foo : half)
-last(true ? half : 1)
-last(true ? i32 : ok)
-last(true ? i64 : 1)
-last(true ? ok : f64)
-lastIndexOf("bar", "foo") < f32 ^ f64
-len("bar" + "foo")
-len("bar") != f32
-len("bar") % score(i)
-len("bar") * i32
-len("bar") ** f64
-len("bar") ** i32
-len("bar") <= i64
-len("bar") > i32
-len("bar") >= 0.5 ^ 0.5
-len("bar") >= f32
-len("bar") >= f64
-len("foo" + foo.Bar)
-len("foo") * i32
-len("foo") * i64
+last(map(list, i64))
+last(map(list, ok))
+last(ok ? "bar" : true)
+last(ok ? "foo" : f64)
+last(ok ? 0.5 : "foo")
+last(ok ? 0.5 : list)
+last(ok ? 1 : add)
+last(ok ? 1 : half)
+last(ok ? array : array)
+last(ok ? array : ok)
+last(ok ? f32 : 0.5)
+last(ok ? greet : 1)
+last(ok ? i32 : array)
+last(ok ? i64 : add)
+last(ok ? ok : 0.5)
+last(reduce(array, list))
+last(reduce(list, array))
+last(sort(array))
+last(true ? "bar" : half)
+last(true ? add : list)
+last(true ? foo : 1)
+last(true ? greet : true)
+last(true ? ok : 1)
+len("bar") ** i64
+len("bar") + i64 - i64
+len("bar") / i64
+len("bar") >= i
+len("bar") in array
+len("foo") ** i32
+len("foo") ** i64
 len("foo") - i
-len("foo") .. i
-len("foo") < f32
-len("foo") <= f32
-len("foo") <= f64
-len("foo") == i
-len("foo") == i32
-len("foo") == i64
-len("foo") > f64
-len("foo") not in array
-len([f64])
-len([false, add, half])
-len([false, foo, false])
-len([false])
+len("foo") - i32
+len("foo") >= i
+len(1 .. 1)
+len([f32])
+len([foo])
+len([half])
 len(array)
-len(array) != i
-len(array) != i32
-len(array) * i
-len(array) ** i
-len(array) .. 1 - 1
-len(array) / f32
-len(array) < f32
-len(array) <= i
-len(array) >= f32
+len(array) != f32
+len(array) + i64
+len(array) < f64
+len(array) <= i32
+len(array) == f32
 len(array) >= f64
-len(array) >= i64
-len(false ? 1 : list)
-len(false ? nil : "foo")
+len(array) ^ i32
+len(array) not in array
+len(filter(list, false))
+len(filter(list, ok))
 len(foo.Bar)
 len(foo.String())
 len(foo?.Bar)
+len(foo?.Qux("bar"))
 len(foo?.String())
 len(greet("bar"))
 len(greet("foo"))
-len(i .. 1)
-len(i32 .. 1)
-len(i32 .. i)
-len(i32 .. i32)
-len(i32 .. i64)
+len(groupBy(array, #))
+len(groupBy(array, 0.5))
+len(groupBy(array, f32))
+len(groupBy(array, false))
+len(groupBy(array, i64))
+len(groupBy(array, true))
+len(groupBy(list, #))
+len(groupBy(list, #).ok)
+len(groupBy(list, 0.5))
+len(groupBy(list, false))
+len(groupBy(list, foo).list)
+len(groupBy(list, i32))
+len(groupBy(list, i64))
 len(i64 .. 1)
 len(i64 .. i)
 len(list)
-len(list) != i64
-len(list) * f32
-len(list) ** i
-len(list) / f64
-len(list) <= f64
-len(list) == f32
-len(list) == i
+len(list) % i32
+len(list) % i64
+len(list) .. i64
+len(list) / i32
+len(list) <= i
 len(list) > i
-len(list) > i64 - i
-len(list) >= i
-len(list) not in map(array, #)
+len(list) ^ f64
+len(list[1:i])
+len(lower("bar"))
 len(lower("foo"))
-len(lower(toBase64("foo")))
-len(lower(type(list)))
 len(map(array, "bar"))
 len(map(array, #))
-len(map(array, 0.5))
-len(map(array, array))
-len(map(array, f64))
-len(map(array, foo))
-len(map(array, half))
+len(map(array, add))
+len(map(array, f32))
+len(map(array, greet))
 len(map(array, i))
-len(map(array, i64))
-len(map(array, list))
-len(map(array, ok))
+len(map(array, list)[i64])
 len(map(array, score))
-len(map(list, "bar"))
-len(map(list, "foo"))
 len(map(list, #))
-len(map(list, 0.5))
 len(map(list, 1))
+len(map(list, f32))
 len(map(list, f64))
-len(map(list, false))
-len(map(list, greet))
-len(map(list, half))
-len(map(list, i))
-len(map(list, score))
+len(map(list, foo))
+len(map(list, i64))
+len(map(list, ok))
 len(map(list, true))
+len(ok ? list : score)
 len(sort(array))
 len(string("bar"))
 len(string("foo"))
 len(string(0.5))
 len(string(1))
 len(string(add))
-len(string(array))
-len(string(div))
-len(string(f32))
 len(string(f64))
 len(string(foo))
-len(string(greet))
 len(string(half))
+len(string(i))
 len(string(i32))
 len(string(i64))
 len(string(list))
 len(string(nil))
-len(string(ok))
 len(string(score))
-len(string(true))
+len(string(string(list)))
 len(toJSON("bar"))
 len(toJSON("foo"))
 len(toJSON(0.5))
-len(toJSON(1 <= i32))
 len(toJSON(1))
 len(toJSON(array))
 len(toJSON(f32))
-len(toJSON(f64))
 len(toJSON(false))
-len(toJSON(foo))
-len(toJSON(foo.Bar))
 len(toJSON(i))
 len(toJSON(i32))
-len(toJSON(i64))
 len(toJSON(list))
 len(toJSON(nil))
 len(toJSON(ok))
 len(toJSON(true))
-len(trim("bar"))
 len(trim("foo"))
-len(trimPrefix("bar"))
 len(trimPrefix("foo"))
 len(trimSuffix("bar"))
-len(trimSuffix("foo"))
+len(type("foo"))
 len(type(0.5))
 len(type(1))
+len(type(add))
 len(type(array))
 len(type(div))
-len(type(f32))
-len(type(f64))
-len(type(false))
-len(type(foo))
-len(type(greet))
 len(type(half))
-len(type(half)) > f32
 len(type(i))
 len(type(i32))
 len(type(i64))
@@ -9444,46 +12067,48 @@ len(type(ok))
 len(type(score))
 len(upper("bar"))
 len(upper("foo"))
-len({"bar": 1})
-len({"bar": add})
-len({"bar": f64, "bar": i})
-len({"bar": greet, "bar": greet})
-len({"foo": "foo"})
+len({"bar": array})
+len({"bar": f64})
+len({"bar": score})
+len({"foo": 1})
+len({"foo": add, "foo": "foo"})
+len({"foo": i64})
 list
+list != 1 .. 1
+list != ["foo"]
+list != [i, 0.5]
+list != [i]
 list != array
-list != array == ok
-list != array ? 0.5 : "bar"
-list != filter(list, true)
+list != filter(array, ok)
+list != filter(array, true)
 list != list
+list != list ? 0.5 : div
+list != list ? half : div
 list != map(array, #)
-list != map(array, 1)
-list != map(array, div)
-list != map(list, #)
-list != map(list, div)
-list != map(list, list)
-list == [add]
+list != map(list, 1)
+list != map(list, i64)
+list != nil && i32 <= 1
+list != nil ? false : 1
+list != nil ? i : 1
+list != sort(array)
+list == [div, nil]
+list == [i]
 list == array
-list == array ? div : i
+list == array == nil
 list == list
-list == list == nil
-list == list ? f64 : array
-list == list or add != nil
-list == map(list, f32)
-list == map(list, i64)
-list == nil == nil
-list == nil == ok
-list == nil or i == 0.5
-list == sort(array)
-list == {"bar": half, "foo": "foo"}?.i32
+list == list != false
+list == list ? i32 : i
+list == map(list, #)
+list == nil && ok
+list == nil ? nil : "foo"
+list == nil or f64 == f64
+list not in groupBy(list, #).i
 list[-1]
 list[-i32]
 list[-i64]
-list[-i64].String
 list[-i]
-list[-i].String
-list[1 % i32]
-list[1 * i64]
-list[1:i] == list
+list[1 - 1]
+list[1] not in list
 list[1].Bar
 list[1].Qux
 list[1].String
@@ -9492,35 +12117,35 @@ list[1]?.Bar
 list[1]?.Qux
 list[1]?.String
 list[1]?.String()
-list[false ? add : 1]
-list[false ? nil : i]
-list[false ? true : f64]
-list[findIndex(list, ok)]
-list[i * i32]
+list[bitnot(i)]
+list[bitshr(i32, i32)]
+list[findIndex(array, true)]
+list[first(array)]
+list[i * i64]
 list[i32:i32]
-list[i32:i64]
 list[i32:i]
 list[i32]
+list[i32] in list
 list[i32].Bar
 list[i32].Qux
 list[i32].String
-list[i32].String()
 list[i32]?.Bar
 list[i32]?.Qux
 list[i32]?.String
-list[i64 % 1]
-list[i64:i32]
+list[i32]?.String()
+list[i64:i32 - i]
 list[i64:i64]
-list[i64:i]
 list[i64]
+list[i64] in list
 list[i64].Bar
 list[i64].Qux
 list[i64].String
-list[i64].String()
 list[i64]?.Bar
 list[i64]?.Qux
 list[i64]?.String
-list[i:false ? false : i64]
+list[i:i32]
+list[i:i64]
+list[i:i64] == nil != nil
 list[i:i]
 list[i]
 list[i].Bar
@@ -9529,17 +12154,22 @@ list[i].String
 list[i].String()
 list[i]?.Bar
 list[i]?.Qux
+list[i]?.String
 list[i]?.String()
-list[int(0.5)]
+list[int(f32)]
 list[int(f64)]
 list[int(i)]
-list[max(i)]
+list[int(i64)]
+list[max(i64, 1)]
 list[min(i)]
-list[ok ? f32 : add]
+list[min(i32)]
+list[ok ? 1 : half]
 list[score(1)]
 list[score(i)]
-list[true ? f64 : true]
 lower("bar" + "bar")
+lower("bar") == trimSuffix("bar")
+lower("foo" + "bar")
+lower(false ? foo : "bar")
 lower(foo.Bar)
 lower(foo.String())
 lower(foo?.Bar)
@@ -9547,106 +12177,87 @@ lower(foo?.String())
 lower(greet("bar"))
 lower(greet("foo"))
 lower(lower("bar"))
-lower(lower(trimSuffix("bar")))
-lower(string("bar"))
+lower(lower("foo"))
+lower(reduce(array, "bar"))
+lower(reduce(list, "bar"))
 lower(string("foo"))
 lower(string(0.5))
 lower(string(add))
-lower(string(array))
-lower(string(div))
 lower(string(f32))
 lower(string(f64))
-lower(string(false))
 lower(string(foo))
 lower(string(greet))
-lower(string(half))
 lower(string(i))
 lower(string(i32))
 lower(string(i64))
 lower(string(list))
 lower(string(nil))
-lower(string(ok))
 lower(string(score))
-lower(string(true))
-lower(toBase64("bar" + "bar"))
-lower(toBase64("bar"))
 lower(toBase64("foo"))
+lower(toBase64(string(i)))
 lower(toJSON("bar"))
 lower(toJSON("foo"))
 lower(toJSON(0.5))
 lower(toJSON(1))
-lower(toJSON(array))
-lower(toJSON(f32))
 lower(toJSON(f64))
-lower(toJSON(false))
 lower(toJSON(foo))
-lower(toJSON(i))
-lower(toJSON(i32))
-lower(toJSON(i64))
 lower(toJSON(list))
 lower(toJSON(nil))
 lower(toJSON(ok))
 lower(toJSON(true))
+lower(trim("bar"))
 lower(trim("foo"))
 lower(trimPrefix("bar"))
+lower(trimPrefix("foo"))
 lower(trimSuffix("bar"))
-lower(trimSuffix("foo"))
-lower(trimSuffix(foo?.String()))
 lower(type("bar"))
 lower(type("foo"))
-lower(type(0.5 * i64))
 lower(type(0.5))
 lower(type(1))
-lower(type(array))
+lower(type(add))
 lower(type(div))
 lower(type(f32))
-lower(type(f64))
-lower(type(false))
-lower(type(foo))
-lower(type(greet))
 lower(type(half))
 lower(type(i))
+lower(type(i32))
 lower(type(i64))
-lower(type(nil))
+lower(type(list))
 lower(type(ok))
-lower(type(score))
 lower(type(true))
 lower(upper("bar"))
 lower(upper("foo"))
-map(1 .. 1, # .. #)
-map(1 .. 1, # == f64)
-map(1 .. i, #)
+map(1 .. 1, f32)
+map(1 .. 1, foo)
+map(1 .. 1, score)
 map(1 .. i, foo)
-map(1 .. i, greet)
 map(1 .. i32, #)
-map(1 .. i32, ok)
-map(1 .. i64, f64 ^ 1)
-map(1 .. i64, foo)
-map(1 .. i64, list)
-map(["bar"], # == #)
-map(["foo"], #)
-map([1, i], #)
-map([add], foo)
-map([f32], f64)
-map([false], score)
-map([greet, i32], #)
-map([greet], #)
+map(1 .. i32, 0.5 / f64)
+map(1 .. i32, div)
+map(1 .. i32, reduce(array, #))
+map(1 .. i64, # ^ #)
+map(1 .. i64, #)
+map(1 .. i64, half)
+map(1 .. i64, i32)
+map([f64], half)
+map([false], ok)
 map([half], #)
+map([i * i32], score)
+map([i32, foo, score], #)
 map([i32], foo)
-map([i64], #)
-map([i], max(#))
-map([list, nil], i64)
-map([list], #)
-map([score, "bar"], #)
-map([score], #)
-map([score], array)
-map(array, !false)
-map(array, !true)
-map(array, "bar" != "foo")
-map(array, "bar" contains "foo")
-map(array, "bar")[i64]
-map(array, # != # ? # : array)
+map([i32], greet)
+map([i32], half)
+map([list, 1, foo], i32)
+map([nil], foo)
+map([score, "bar"], f32)
+map([true, i32, 1], #)
+map(array, !(# == #))
+map(array, !(nil in list))
+map(array, !ok)
+map(array, "bar" in foo)
+map(array, "foo" not endsWith "bar")
+map(array, "foo") == array
 map(array, # != #)
+map(array, # != 0.5)
 map(array, # != 1)
 map(array, # != f64)
 map(array, # != i32)
@@ -9654,1222 +12265,1146 @@ map(array, # != nil)
 map(array, # % #)
 map(array, # % 1)
 map(array, # % i)
-map(array, # % i32)
 map(array, # % i64)
 map(array, # * #)
 map(array, # * 0.5)
+map(array, # * 1)
+map(array, # * f32)
 map(array, # * f64)
-map(array, # * i32)
-map(array, # * i64)
+map(array, # * i)
 map(array, # ** #)
-map(array, # ** 0.5)
+map(array, # ** 1)
+map(array, # ** f32)
 map(array, # ** i)
-map(array, # ** i32)
 map(array, # ** i64)
 map(array, # + #)
 map(array, # + 0.5)
 map(array, # + 1)
-map(array, # + f64)
+map(array, # + f32)
 map(array, # + i)
 map(array, # + i32)
-map(array, # + i64)
 map(array, # - #)
 map(array, # - 0.5)
 map(array, # - 1)
 map(array, # - f32)
+map(array, # - f64)
 map(array, # - i)
 map(array, # - i32)
 map(array, # .. #)
 map(array, # .. 1)
-map(array, # .. i)
-map(array, # .. i32)
-map(array, # .. i64)
 map(array, # / #)
 map(array, # / 0.5)
+map(array, # / 1)
+map(array, # / f32)
 map(array, # / f64)
 map(array, # / i)
-map(array, # / i32)
 map(array, # / i64)
 map(array, # < #)
-map(array, # < 0.5)
 map(array, # < 1)
 map(array, # < f32)
-map(array, # < f64)
+map(array, # < i32)
+map(array, # < i64)
 map(array, # <= #)
-map(array, # <= 1)
-map(array, # <= i64)
+map(array, # <= f32)
+map(array, # <= i)
+map(array, # <= i32)
 map(array, # == #)
-map(array, # == 1)
-map(array, # == i64)
+map(array, # == f32)
+map(array, # == f64)
+map(array, # == nil)
 map(array, # > #)
+map(array, # > 0.5)
 map(array, # > 1)
 map(array, # > f32)
-map(array, # > i32)
-map(array, # > i64)
+map(array, # > f64)
 map(array, # >= #)
-map(array, # >= 0.5)
 map(array, # >= 1)
-map(array, # >= f64)
-map(array, # >= i)
+map(array, # >= f32)
 map(array, # >= i32)
+map(array, # >= i64)
 map(array, # ^ #)
 map(array, # ^ 0.5)
+map(array, # ^ 1)
 map(array, # ^ i)
 map(array, # ^ i32)
-map(array, # ^ i64)
-map(array, # in array)
+map(array, # not in array)
 map(array, #)
 map(array, #) != array
 map(array, #) != list
-map(array, #) != nil == nil
+map(array, #) == array
+map(array, #) == list
 map(array, #)[i64]
 map(array, #)[i]
 map(array, -#)
-map(array, -(# ** f64))
+map(array, --#)
 map(array, -0.5)
 map(array, -1)
 map(array, -f64)
 map(array, -i)
+map(array, -i32)
 map(array, -i64)
 map(array, 0.5 != #)
 map(array, 0.5 != 0.5)
-map(array, 0.5 != i32)
 map(array, 0.5 * #)
-map(array, 0.5 ** #)
+map(array, 0.5 * f64)
+map(array, 0.5 ** f32)
+map(array, 0.5 ** i64)
 map(array, 0.5 + #)
+map(array, 0.5 + 1)
 map(array, 0.5 - #)
-map(array, 0.5 / #)
+map(array, 0.5 - 0.5)
+map(array, 0.5 / i)
 map(array, 0.5 < #)
-map(array, 0.5 < 1)
-map(array, 0.5 <= f32)
-map(array, 0.5 == #)
-map(array, 0.5 == i32)
+map(array, 0.5 < i32)
 map(array, 0.5 > #)
+map(array, 0.5 > i64)
+map(array, 0.5 >= #)
 map(array, 0.5 ^ #)
+map(array, 0.5)[i]
 map(array, 1 != #)
-map(array, 1 != 1)
 map(array, 1 != f32)
 map(array, 1 % #)
-map(array, 1 % i)
-map(array, 1 * #)
-map(array, 1 * f32)
 map(array, 1 ** #)
-map(array, 1 ** 1)
-map(array, 1 ** i32)
+map(array, 1 ** i)
+map(array, 1 ** i64)
 map(array, 1 + #)
+map(array, 1 + f64)
+map(array, 1 - #)
 map(array, 1 .. #)
 map(array, 1 / #)
-map(array, 1 / 1)
-map(array, 1 < 0.5)
+map(array, 1 / i32)
+map(array, 1 < #)
 map(array, 1 <= #)
+map(array, 1 <= 1)
+map(array, 1 <= f32)
 map(array, 1 == #)
-map(array, 1 == nil)
-map(array, 1 >= #)
-map(array, 1 >= f64)
 map(array, 1 ^ #)
-map(array, 1 ^ 1)
-map(array, 1 in array)
-map(array, 1)[i64]
-map(array, 1)[i]
-map(array, [array])
-map(array, [i32, foo])
 map(array, abs(#))
-map(array, abs(0.5))
+map(array, abs(i64))
+map(array, add == nil)
 map(array, add(#, #))
 map(array, add(#, i))
-map(array, add(1, #))
 map(array, add)
-map(array, add) != list
-map(array, all(array, true))
-map(array, array != nil)
 map(array, array)
-map(array, array) == array
+map(array, array)[bitnot(i32)]
+map(array, array)[i64]
 map(array, array[#:#])
-map(array, array[1])
+map(array, bitand(#, 1))
+map(array, bitnand(#, 1))
+map(array, bitnot(#))
+map(array, bitnot(1))
+map(array, bitshl(#, #))
+map(array, bitshr(#, #))
+map(array, bitshr(#, i64))
+map(array, bitushr(1, #))
+map(array, ceil(#))
+map(array, ceil(0.5))
+map(array, ceil(f32))
 map(array, div(#, #))
 map(array, div)
+map(array, f32 * #)
+map(array, f32 * f64)
 map(array, f32 ** #)
-map(array, f32 ** f64)
 map(array, f32 + #)
-map(array, f32 - f64)
 map(array, f32 / #)
 map(array, f32 < #)
-map(array, f32 <= #)
-map(array, f32 <= 1)
 map(array, f32 == #)
 map(array, f32 > #)
+map(array, f32 >= #)
+map(array, f32 >= i)
+map(array, f32 ^ #)
 map(array, f32)
+map(array, f32)[min(i32)]
 map(array, f64 != #)
 map(array, f64 != 0.5)
-map(array, f64 * 1)
+map(array, f64 * #)
 map(array, f64 ** #)
-map(array, f64 - #)
-map(array, f64 / 1)
-map(array, f64 <= f64)
-map(array, f64 > #)
+map(array, f64 ** 0.5)
+map(array, f64 / #)
+map(array, f64 < #)
+map(array, f64 < f64)
+map(array, f64 <= #)
+map(array, f64 == #)
+map(array, f64 >= #)
+map(array, f64 >= i32)
+map(array, f64 ^ #)
 map(array, f64)
-map(array, f64) != list
-map(array, f64) == i .. 1
-map(array, false ? "foo" : #)
-map(array, false ? 0.5 : #)
-map(array, false)[i]
-map(array, findLast(array, true))
-map(array, float(# * f64))
+map(array, false && false)
+map(array, false ? # : f64)
+map(array, false ? greet : i)
+map(array, false)[i32]
+map(array, find(array, true))
+map(array, findIndex(list, ok))
+map(array, float(# + #))
 map(array, float(#))
-map(array, float(1))
-map(array, float(i64))
+map(array, floor(#))
+map(array, foo == foo)
 map(array, foo)
 map(array, foo.Bar)
 map(array, foo.Qux)
 map(array, foo.String())
 map(array, foo.String)
-map(array, foo?.Qux)
+map(array, foo?.Bar)
 map(array, foo?.String)
 map(array, get(array, #))
-map(array, get(list, #))
-map(array, greet != half)
 map(array, greet("bar"))
 map(array, greet("foo"))
 map(array, greet)
-map(array, greet) == list
+map(array, groupBy(array, #))
+map(array, groupBy(array, f32))
+map(array, groupBy(list, #))
+map(array, groupBy(list, f64))
+map(array, groupBy(list, i))
+map(array, half != half)
+map(array, half != nil)
 map(array, half(0.5))
+map(array, half(1))
+map(array, half(f64))
+map(array, half(i - 0.5))
 map(array, half)
-map(array, i != #)
-map(array, i != f64)
-map(array, i % i)
-map(array, i * 0.5)
-map(array, i ** #)
-map(array, i ** 0.5)
-map(array, i .. #)
-map(array, i / #)
+map(array, i % #)
+map(array, i + #)
+map(array, i - i32)
+map(array, i / 0.5)
+map(array, i <= #)
+map(array, i <= f32)
+map(array, i <= f64)
 map(array, i == #)
-map(array, i > #)
-map(array, i >= f64)
-map(array, i ^ #)
+map(array, i == f64)
+map(array, i > i32)
+map(array, i >= #)
 map(array, i)
-map(array, i)[i64]
-map(array, i32 % #)
-map(array, i32 % i)
+map(array, i)[i]
 map(array, i32 * #)
-map(array, i32 + 0.5)
-map(array, i32 + i64)
-map(array, i32 - #)
-map(array, i32 / #)
-map(array, i32 < 0.5)
+map(array, i32 ** #)
+map(array, i32 ** f64)
+map(array, i32 / f32)
+map(array, i32 < #)
+map(array, i32 < f64)
 map(array, i32 == #)
-map(array, i32 == 0.5)
-map(array, i32 == nil)
+map(array, i32 == 1)
 map(array, i32 > #)
-map(array, i32 >= f32)
 map(array, i32 ^ #)
+map(array, i32 not in array)
 map(array, i32)
+map(array, i32) == array
+map(array, i32) == list
 map(array, i64 != #)
+map(array, i64 % #)
 map(array, i64 * #)
-map(array, i64 ** #)
-map(array, i64 + #)
+map(array, i64 * 0.5)
+map(array, i64 + 0.5)
 map(array, i64 - #)
 map(array, i64 .. #)
-map(array, i64 / #)
-map(array, i64 <= 1)
-map(array, i64 == #)
-map(array, i64 == f64)
+map(array, i64 < #)
+map(array, i64 <= #)
+map(array, i64 <= f64)
+map(array, i64 <= i64)
 map(array, i64 > #)
-map(array, i64 >= i64)
-map(array, i64 ^ #)
-map(array, i64 ^ i32)
 map(array, i64)
-map(array, i64)[i32]
 map(array, int(#))
 map(array, int(0.5))
-map(array, int(f64))
-map(array, last(array))
-map(array, len(array))
+map(array, len("foo"))
+map(array, list != array)
 map(array, list)
-map(array, map(array, #))
-map(array, map(array, true))
-map(array, map(list, #))
-map(array, map(list, f64))
+map(array, map(array, f64))
+map(array, map(list, greet))
 map(array, max(#))
-map(array, max(#, #, #))
-map(array, max(0.5))
-map(array, max(0.5, #))
-map(array, max(i64, #, i))
-map(array, min(# ^ #))
-map(array, min(#))
-map(array, min(#, #, #, #))
-map(array, min(#, 1))
-map(array, min(#, 1, #))
-map(array, min(#, 1, f64))
-map(array, min(#, f32))
-map(array, min(#, f64))
-map(array, nil != #)
+map(array, max(f32, 1))
+map(array, max(f64))
+map(array, mean(array))
+map(array, min(#, #))
 map(array, nil == #)
-map(array, nil == half)
-map(array, not (# < 1))
-map(array, not false)
+map(array, nil == ok)
+map(array, nil not in list)
+map(array, not ok)
 map(array, not true)
-map(array, ok ? # : i64)
-map(array, ok ? f32 : div)
 map(array, ok || ok)
 map(array, ok)
-map(array, one(array, ok))
-map(array, one(array, true))
-map(array, score != nil)
+map(array, ok)[i64]
+map(array, reduce(array, "bar"))
+map(array, reduce(array, #))
+map(array, reduce(list, add))
+map(array, reduce(list, half))
+map(array, round(#))
 map(array, score(#))
 map(array, score(#, #))
-map(array, score(#, #, 1))
 map(array, score(1))
 map(array, score)
-map(array, sort(array))
-map(array, string("bar"))
-map(array, string(# ** f64))
-map(array, string(#))
-map(array, string(array))
+map(array, string(add))
 map(array, string(foo))
-map(array, string(list))
-map(array, string(score))
+map(array, string(i64))
+map(array, take(array, #))
+map(array, toBase64("foo"))
 map(array, toJSON(#))
-map(array, toJSON(array))
-map(array, toJSON(ok))
-map(array, true ? # : #)
-map(array, true ? f32 : i)
-map(array, true ? nil : #)
-map(array, true)[i]
+map(array, toJSON(foo))
+map(array, toJSON(list))
+map(array, true != nil)
+map(array, true ? 0.5 : #)
+map(array, true ? 0.5 : 1)
+map(array, true ? f32 : div)
+map(array, true ? i : true)
 map(array, type(#))
-map(array, type(half))
-map(array, type(i))
-map(array, upper("foo"))
-map(array[i64:1], array)
-map(array[i64:i64], #)
-map(array[i:1], i > #)
-map(false ? 0.5 : "bar", greet)
-map(false ? 1 : list, half)
-map(false ? array : "foo", i64 / 1)
-map(false ? true : array, #)
+map(array, type(f32))
+map(array[1:i32], list)
+map(false ? i32 : list, ok)
 map(filter(array, false), foo)
-map(filter(array, ok), # <= #)
-map(filter(array, ok), #)
-map(filter(array, ok), i32 + #)
-map(filter(array, ok), score)
-map(filter(array, true), f64)
-map(filter(array, true), i)
+map(filter(array, ok), 1 * #)
+map(filter(list, # != #), #)
 map(filter(list, false), #)
-map(filter(list, true), score)
-map(i .. 1, # > #)
-map(i .. 1, -i64)
-map(i .. 1, f64)
-map(i .. i32, #)
-map(i .. i32, score)
-map(i .. i64, #)
-map(i .. i64, f64)
-map(i .. i64, score)
-map(i32 .. 1, #)
-map(i32 .. 1, list)
-map(i32 .. i, add)
-map(i32 .. i, half)
-map(i32 .. i32, #)
-map(i32 .. i32, greet)
-map(i32 .. i64, abs(#))
-map(i32 .. i64, f64)
-map(i64 .. i, #)
-map(i64 .. i, i)
+map(filter(list, ok), #)
+map(filter(list, ok), i)
+map(filter(list, true), i64)
+map(groupBy(array, #).String, i32)
+map(groupBy(array, #).greet, foo.Qux(.f32))
+map(groupBy(array, #).greet, score)
+map(groupBy(array, #).score, #?.list())
+map(groupBy(list, i32).i, #)
+map(i .. 1, -#)
+map(i .. 1, 0.5 ^ #)
+map(i .. 1, f32)
+map(i .. 1, i)
+map(i .. i, add(#, #))
+map(i .. i, div)
+map(i .. i, i32)
+map(i .. i32, half)
+map(i .. i64, min(#, #, #))
+map(i32 .. 1, half)
+map(i32 .. i, f32)
+map(i32 .. i32, array)
+map(i32 .. i64, div)
+map(i32 .. i64, list)
+map(i64 .. 1, #)
+map(i64 .. 1, 1 ^ #)
+map(i64 .. 1, array)
+map(i64 .. 1, f32)
+map(i64 .. 1, f64)
 map(i64 .. i32, #)
+map(i64 .. i64, # - #)
+map(i64 .. i64, #)
 map(list, !false)
-map(list, !true)
-map(list, "bar" in #)
-map(list, "bar" not in #)
+map(list, !ok)
+map(list, "bar" not matches "foo")
 map(list, "bar") != list
-map(list, "foo" + "foo")
-map(list, "foo" in #)
-map(list, "foo" not matches "bar")
-map(list, "foo") == list
+map(list, "bar")[i64]
+map(list, "foo" not in foo)
+map(list, "foo" not matches #.Bar)
 map(list, # != #)
-map(list, # != foo)
 map(list, # != nil)
 map(list, # == #)
-map(list, # == foo)
-map(list, # not in list)
+map(list, # in list)
 map(list, #)
-map(list, #) == array
+map(list, #) != array
 map(list, #) == list
-map(list, #)[i32]
 map(list, #)[i64]
 map(list, #)[i]
 map(list, #?.Bar)
-map(list, #?.Qux("bar"))
 map(list, #?.Qux)
 map(list, #?.String())
 map(list, #?.String)
 map(list, -0.5)
-map(list, -1)
-map(list, -f64)
+map(list, -f32)
 map(list, -i)
-map(list, .Bar not in # != true)
+map(list, -i32)
 map(list, .Bar)
 map(list, .Qux)
 map(list, .String())
 map(list, .String)
-map(list, 0.5 - i64)
-map(list, 0.5 < f32)
-map(list, 0.5 <= f32)
-map(list, 0.5 <= i64)
-map(list, 0.5 >= 1)
-map(list, 0.5 ^ 1)
-map(list, 1 + i)
-map(list, 1 - f64)
-map(list, 1 .. 1)
-map(list, 1 .. i64)
-map(list, 1 / 1)
-map(list, 1 / f32)
-map(list, 1 < i32)
-map(list, 1 > i32)
-map(list, 1 >= f64)
-map(list, [1])
-map(list, [false])
-map(list, abs(0.5))
-map(list, abs(1))
+map(list, 0.5 != 0.5)
+map(list, 0.5 != i64)
+map(list, 0.5 + i64)
+map(list, 0.5 - 0.5)
+map(list, 0.5 <= 0.5)
+map(list, 0.5 == i32)
+map(list, 0.5 in array)
+map(list, 0.5) != array
+map(list, 0.5) == array
+map(list, 1 % i)
+map(list, 1 ** 0.5)
+map(list, 1 ** f32)
+map(list, 1 + 1)
+map(list, 1 / f64)
+map(list, 1 / i64)
+map(list, 1 < 0.5)
+map(list, 1 <= i32)
+map(list, 1 ^ i32)
+map(list, [#])
+map(list, [foo, 0.5, #])
+map(list, [score])
+map(list, abs(f32))
 map(list, add)
 map(list, array)
-map(list, div != greet)
-map(list, div == div)
+map(list, ceil(0.5))
+map(list, count(array, true))
 map(list, div)
-map(list, div) != list
-map(list, f32 != f32)
-map(list, f32 ** f32)
-map(list, f32 / i32)
-map(list, f32 < 0.5)
-map(list, f32 <= 1)
+map(list, f32 != i32)
+map(list, f32 ** 1)
+map(list, f32 + i64)
+map(list, f32 < f32)
+map(list, f32 == 0.5)
+map(list, f32 > i64)
+map(list, f32 >= i)
+map(list, f32 >= i32)
+map(list, f32 ^ i)
 map(list, f32)
-map(list, f64 * 0.5)
-map(list, f64 * f32)
-map(list, f64 ** i32)
-map(list, f64 + 1)
-map(list, f64 + i32)
-map(list, f64 - 0.5)
-map(list, f64 < f64)
-map(list, f64 ^ i64)
+map(list, f64 < 0.5)
+map(list, f64 < f32)
+map(list, f64 <= 1)
+map(list, f64 > 1)
+map(list, f64 >= 0.5)
+map(list, f64 >= f32)
 map(list, f64)
-map(list, f64) != list
-map(list, false ? # : nil)
-map(list, false ? f32 : #)
-map(list, false ? f32 : foo)
-map(list, false and true)
-map(list, filter(list, false))
-map(list, first(list))
-map(list, float(0.5))
-map(list, float(1))
-map(list, float(f32))
-map(list, float(i64))
+map(list, f64)[i]
+map(list, false ? # : list)
+map(list, false) != array
+map(list, float(f64))
+map(list, float(i))
+map(list, float(i32))
 map(list, foo == #)
 map(list, foo)
-map(list, foo.Bar)
-map(list, foo.String)
-map(list, foo?.String())
+map(list, foo.Qux)
+map(list, foo.String())
 map(list, foo?.String)
-map(list, greet == greet)
-map(list, greet("foo"))
 map(list, greet)
-map(list, greet) != array ? 0.5 : 1
-map(list, half != score)
+map(list, groupBy(array, #))
+map(list, groupBy(array, i))
+map(list, groupBy(list, #))
 map(list, half(0.5))
+map(list, half(f64))
 map(list, half)
-map(list, i * 1)
-map(list, i * i64)
-map(list, i + i)
-map(list, i >= f64)
-map(list, i >= i64)
-map(list, i ^ f32)
-map(list, i ^ i64)
+map(list, i ** 1)
+map(list, i + i64)
+map(list, i .. i)
+map(list, i < 0.5)
+map(list, i == 1)
 map(list, i)
-map(list, i32 * f32)
-map(list, i32 == i64)
-map(list, i32 == nil)
-map(list, i32 > i)
-map(list, i32 ^ 0.5)
+map(list, i)[i64]
+map(list, i32 % i64)
+map(list, i32 ** 0.5)
+map(list, i32 + f32)
+map(list, i32 - i32)
+map(list, i32 / f64)
+map(list, i32 < 1)
+map(list, i32 < i32)
+map(list, i32 <= 1)
+map(list, i32 >= 1)
 map(list, i32)
-map(list, i64 == 1)
-map(list, i64 == f32)
-map(list, i64 ^ (i + i32))
+map(list, i64 * i)
+map(list, i64 + i64)
+map(list, i64 <= i64)
+map(list, i64 == nil)
 map(list, i64)
-map(list, int(1))
-map(list, len(array))
+map(list, i64)[i64]
+map(list, i64)[i]
+map(list, last(array))
 map(list, list)
-map(list, map(array, score))
-map(list, map(list, #))
-map(list, min(i64))
+map(list, list)[i]
+map(list, map(array, #))
+map(list, map(array, 1))
+map(list, map(array, div))
+map(list, map(array, i64))
+map(list, map(list, "foo"))
+map(list, max(f32))
+map(list, min(0.5))
+map(list, min(f64))
 map(list, nil != #)
-map(list, nil != 1)
-map(list, nil != array)
-map(list, nil != i)
-map(list, nil != nil)
+map(list, nil != i64)
 map(list, nil == #)
-map(list, nil == div)
-map(list, nil == foo)
-map(list, nil == i32)
-map(list, nil not in array)
-map(list, not false)
+map(list, nil == ok)
+map(list, nil not in list)
+map(list, none(array, true))
 map(list, not ok)
-map(list, not true)
-map(list, ok ? i64 : i64)
+map(list, ok ? # : #)
+map(list, ok || ok)
 map(list, ok)
-map(list, ok) != array
-map(list, score != greet)
-map(list, score(i))
+map(list, reduce(array, half))
+map(list, reduce(list, foo))
+map(list, reduce(list, half))
+map(list, score(1))
 map(list, score)
+map(list, score)[i64]
 map(list, string(#))
-map(list, string(foo))
-map(list, string(nil))
-map(list, toBase64("foo"))
+map(list, string(1))
+map(list, string(add))
+map(list, string(i32))
 map(list, toJSON(#))
-map(list, toJSON(1))
-map(list, toJSON(foo))
-map(list, toJSON(i))
-map(list, trimPrefix("bar"))
-map(list, trimSuffix("foo"))
-map(list, true ? false : score)
-map(list, true ? nil : #)
+map(list, toJSON([#]))
+map(list, toJSON(false))
+map(list, toJSON(ok))
+map(list, true ? i : f32)
+map(list, true ? i32 : #)
+map(list, true ? list : div)
 map(list, true)[i32]
+map(list, type("bar"))
 map(list, type(#))
-map(list, type(greet))
-map(list, type(half))
-map(list, type(i))
-map(list, type(i64))
-map(list[i:i], i)
-map(map(array, "bar"), #)
-map(map(array, # >= #), add)
-map(map(array, #), # < #)
-map(map(array, #), # ^ i32)
+map(list, type(i32))
+map(list, type(true))
+map(list[i64:i32], greet)
+map(map(array, #), # - i32)
+map(map(array, #), # == #)
+map(map(array, #), # >= #)
 map(map(array, #), #)
 map(map(array, #), add)
-map(map(array, #), div)
-map(map(array, #), f32)
-map(map(array, #), f64)
+map(map(array, #), bitand(#, #))
 map(map(array, #), foo)
-map(map(array, #), foo.Qux)
 map(map(array, #), greet)
 map(map(array, #), half)
+map(map(array, #), i % i64)
 map(map(array, #), i)
+map(map(array, #), i32)
 map(map(array, #), i64)
-map(map(array, #), int(#))
-map(map(array, #), nil != half)
-map(map(array, #), score(i))
-map(map(array, #), score)
-map(map(array, 0.5), # != #)
+map(map(array, #), list)
 map(map(array, 0.5), #)
-map(map(array, 0.5), -1)
-map(map(array, 0.5), list)
-map(map(array, 1), #)
-map(map(array, 1), ok)
-map(map(array, 1), score)
-map(map(array, add), #)
-map(map(array, add), list)
-map(map(array, array), add)
-map(map(array, array), f64)
+map(map(array, 0.5), ok)
+map(map(array, 1), greet)
+map(map(array, array), i32 ^ i32)
+map(map(array, array), i64)
+map(map(array, array), reduce(#, array))
+map(map(array, div), i)
+map(map(array, div), list)
 map(map(array, f32), #)
-map(map(array, f64), add)
-map(map(array, f64), nil == nil)
-map(map(array, foo), #)
-map(map(array, foo), f64)
-map(map(array, foo), greet)
-map(map(array, half), div)
+map(map(array, f32), array)
+map(map(array, f32), f64)
+map(map(array, f64), # > #)
+map(map(array, f64), f64)
+map(map(array, f64), greet)
+map(map(array, foo), div)
+map(map(array, greet), foo)
+map(map(array, greet), list)
+map(map(array, half), array)
+map(map(array, i), #)
+map(map(array, i32), #)
+map(map(array, i64), array)
 map(map(array, i64), f64)
-map(map(array, list), #)
-map(map(array, true), #)
-map(map(array, true), div)
-map(map(array, true), foo)
-map(map(list, "foo"), add)
-map(map(list, "foo"), div)
-map(map(list, "foo"), i32)
-map(map(list, #), "bar" + "foo")
+map(map(array, list), foo)
+map(map(array, ok), !#)
+map(map(array, ok), -f32)
+map(map(array, true), # != nil)
+map(map(array, true), i64)
 map(map(list, #), # != #)
 map(map(list, #), #)
-map(map(list, #), array)
+map(map(list, #), #?.Qux)
+map(map(list, #), .Bar)
 map(map(list, #), div)
 map(map(list, #), f32)
 map(map(list, #), f64)
 map(map(list, #), greet)
-map(map(list, #), i)
-map(map(list, #), i32)
-map(map(list, #), i64 < i32)
-map(map(list, #), i64)
-map(map(list, #), nil != i)
+map(map(list, #), half)
+map(map(list, #), list)
 map(map(list, #), ok)
 map(map(list, #), score)
-map(map(list, 0.5), # / #)
 map(map(list, 0.5), #)
-map(map(list, 0.5), greet)
-map(map(list, 0.5), list)
-map(map(list, 0.5), score)
-map(map(list, 1), # <= #)
-map(map(list, 1), foo)
-map(map(list, add), [#, #])
-map(map(list, add), f64)
-map(map(list, f32), #)
-map(map(list, f32), greet)
-map(map(list, f32), true ? "foo" : "foo")
-map(map(list, f64), #)
-map(map(list, false), array)
-map(map(list, false), f64)
-map(map(list, false), i32)
-map(map(list, false), list)
+map(map(list, 0.5), div)
+map(map(list, 1), # * #)
+map(map(list, 1), f32)
+map(map(list, add), #)
+map(map(list, add), i)
+map(map(list, array), f64)
+map(map(list, array), findIndex(#, ok))
+map(map(list, f64), f32)
+map(map(list, f64), i32)
+map(map(list, false), 0.5 / f64)
 map(map(list, foo), #)
-map(map(list, foo), ok)
-map(map(list, greet), "bar" != "foo")
-map(map(list, greet), # == #)
-map(map(list, greet), #)
-map(map(list, greet), ["foo", 1])
-map(map(list, greet), half)
-map(map(list, half), #)
-map(map(list, i), i32)
-map(map(list, i32), half)
-map(map(list, i32), list)
+map(map(list, foo), list)
+map(map(list, greet), "bar" <= "foo")
+map(map(list, i64), # >= f64)
 map(map(list, i64), #)
-map(map(list, i64), array)
-map(map(list, i64), div)
-map(map(list, i64), f64)
-map(map(list, i64), list)
+map(map(list, i64), i64)
 map(map(list, list), #)
-map(map(list, list), div)
-map(map(list, list), i)
-map(map(list, ok), #)
-map(map(list, score), #)
-map(map(list, score), ok)
-map(map(list, true), #)
-map(ok ? "foo" : 0.5, #)
-map(ok ? "foo" : greet, f32)
-map(ok ? array : "bar", ok)
-map(ok ? array : foo, # / 1)
-map(sort(array), # > #)
-map(sort(array), i32 > #)
-map(true ? "bar" : true, #)
-map(true ? "foo" : add, i64)
-map(true ? array : f64, #)
-map(true ? array : true, #)
-max(--1)
+map(map(list, ok), f64 > i64)
+map(map(list, ok), foo)
+map(map(list, true), f64)
+map(map(list, true), list)
+map(ok ? "bar" : i64, ok)
+map(ok ? "bar" : ok, i64)
+map(ok ? "bar" : score, 1 .. #)
+map(ok ? array : foo, foo)
+map(ok ? array : i64, list)
+map(ok ? list : i64, #)
+map(ok ? list : list, add)
+map(reduce(array, array), # <= #)
+map(reduce(array, array), #)
+map(reduce(list, array), -i32)
+map(reduce(list, array), foo)
+map(reduce(list, array), half)
+map(reduce(list, list), #)
+map(sort(array), # / 0.5)
+map(sort(array), #)
+map(sort(array), greet)
+map(split("foo", "bar"), #)
+map(true ? "foo" : 0.5, # * #)
+map(true ? array : "foo", f32 + #)
+map(true ? list : greet, greet)
+map(true ? list : list, #)
 max(-0.5)
 max(-1)
-max(-1, i)
-max(-count(list, false), i64)
 max(-f32)
 max(-f64)
+max(-findIndex(array, ok))
 max(-i)
-max(-i, i32, i)
+max(-i, f32)
 max(-i32)
 max(-i64)
-max(-i64, 0.5 / f64)
-max(0.5 * 0.5)
-max(0.5 * f64)
+max(-reduce(array, #))
+max(0.5 * f32)
 max(0.5 * i)
-max(0.5 * i, i32)
-max(0.5 * i32)
+max(0.5 * i64)
 max(0.5 ** 0.5)
 max(0.5 ** 1)
 max(0.5 ** f32)
-max(0.5 ** f64)
+max(0.5 ** f64 ^ reduce(array, f64))
 max(0.5 ** i)
-max(0.5 ** i64)
-max(0.5 + 0.5)
+max(0.5 ** i32)
 max(0.5 + 1)
-max(0.5 + i)
-max(0.5 + i32)
-max(0.5 + i64)
 max(0.5 - 0.5)
-max(0.5 - 1)
-max(0.5 - i)
-max(0.5 - i32)
-max(0.5 - i64)
+max(0.5 - f32)
+max(0.5 - f64)
 max(0.5 / 0.5)
-max(0.5 / f32)
+max(0.5 / 1)
 max(0.5 / f64)
-max(0.5 / f64, f64)
-max(0.5 / i)
+max(0.5 / i32)
 max(0.5 / i64)
 max(0.5 ^ 0.5)
 max(0.5 ^ 1)
-max(0.5 ^ f32)
 max(0.5 ^ i)
 max(0.5 ^ i32)
 max(0.5 ^ i64)
-max(0.5) != i == ok
-max(0.5) * f32
-max(0.5) * f64
+max(0.5) != f32
+max(0.5) != i
+max(0.5) + f64
 max(0.5) + i
-max(0.5) - f32
-max(0.5) - f64
-max(0.5) < f64
-max(0.5) <= 0.5 - 0.5
-max(0.5) <= f64
-max(0.5) == f32
-max(0.5) == i64
-max(0.5) > f32
-max(0.5) >= i32
-max(0.5) ^ i32
-max(0.5, 1) <= i32
+max(0.5) - i32
+max(0.5) / i64
+max(0.5) <= i
+max(0.5) > f64
+max(0.5) > i
+max(0.5) > i64
+max(0.5) >= i64
+max(0.5, 0.5) != i
+max(0.5, i) ** i32
 max(1 % 1)
-max(1 % i)
-max(1 % i32)
 max(1 % i64)
 max(1 * 0.5)
 max(1 * 1)
+max(1 * f64)
+max(1 * i32)
 max(1 ** 0.5)
 max(1 ** 1)
-max(1 ** f64)
+max(1 ** f32)
 max(1 ** i64)
-max(1 + f32, f64)
+max(1 + f32)
 max(1 + i64)
-max(1 - 1)
-max(1 - i32)
-max(1 - i64)
-max(1 / 0.5)
+max(1 - f32)
+max(1 - f64)
 max(1 / 1)
 max(1 / f32)
+max(1 / f32, i64)
 max(1 / f64)
+max(1 / i)
+max(1 / i32)
+max(1 / i64)
+max(1 ^ 0.5)
 max(1 ^ 1)
+max(1 ^ f32)
+max(1 ^ f64)
 max(1 ^ i32)
-max(1) != i
-max(1) * i
+max(1 ^ i64)
+max(1) != 1 ? foo : "bar"
+max(1) + f32
 max(1) - f64
-max(1) - i64
-max(1) .. i32
+max(1) .. i
 max(1) / i
-max(1) / i64
-max(1) <= f32
-max(1) <= i
-max(1) <= i32
-max(1) <= i64
-max(1) == f32
-max(1) > f32
+max(1) == i64
 max(1) > f64
-max(1) > i
-max(1) > i64
-max(1, i32, f32) != i64
+max(1) > i32
+max(1, i) not in array
 max(abs(0.5))
 max(abs(1))
 max(abs(f32))
 max(abs(f64))
 max(abs(i))
 max(abs(i32))
-max(abs(i64))
+max(add(1, i))
 max(array[1])
 max(array[i64])
-max(array[i])
-max(count(array, false))
-max(count(list, false))
-max(div(1, 1))
-max(f32 * 0.5)
+max(bitnand(i32, 1))
+max(bitnot(1))
+max(bitnot(i))
+max(bitnot(i64))
+max(bitshr(1, i32))
+max(bitxor(1, 1))
+max(ceil(0.5), f64 / i64)
+max(ceil(f32))
+max(ceil(i32))
 max(f32 * 1)
-max(f32 * f32)
-max(f32 * i32)
-max(f32 ** 0.5)
+max(f32 * f64)
+max(f32 * i64)
 max(f32 ** 1)
-max(f32 ** i32)
-max(f32 ** i64)
+max(f32 ** f64)
 max(f32 + 1)
 max(f32 + f64)
+max(f32 + i)
 max(f32 + i64)
-max(f32 - f64)
-max(f32 - i)
-max(f32 - i32)
+max(f32 - 1)
+max(f32 - i64)
 max(f32 / 0.5)
 max(f32 / f32)
-max(f32 ^ 0.5)
 max(f32 ^ 1)
 max(f32 ^ f32)
-max(f32 ^ i32)
+max(f32 ^ f64)
 max(f32 ^ i64)
 max(f32)
-max(f32) != -i32
-max(f32) != i32
-max(f32) + i64
-max(f32) - f32
-max(f32) <= i
-max(f32) <= max(f64)
-max(f32) >= i64
+max(f32) * i64
+max(f32) ** i
+max(f32) + f32
+max(f32) + f64
+max(f32) - f64
+max(f32) / i32
+max(f32) < i
+max(f32) == i
 max(f32) ^ f32
-max(f32) ^ i32
-max(f32, -f32)
-max(f32, 1) > i32
 max(f32, f32)
 max(f32, f64)
+max(f32, f64) in array
 max(f32, i)
 max(f32, i32)
+max(f32, i32) ** i64
 max(f32, i64)
-max(f32, min(i))
-max(f64 * 0.5)
+max(f64 * 1)
 max(f64 * f64)
-max(f64 * i, f32)
-max(f64 * i32)
-max(f64 ** 1)
+max(f64 ** 0.5)
+max(f64 ** f64)
 max(f64 ** i)
-max(f64 ** i64)
-max(f64 + 0.5)
-max(f64 - i32)
-max(f64 - i64)
-max(f64 / 0.5)
-max(f64 / f32)
-max(f64 / i32)
+max(f64 + 1)
+max(f64 + f32)
+max(f64 + f64)
+max(f64 - 0.5)
+max(f64 - i)
 max(f64 ^ 0.5)
-max(f64 ^ i32)
-max(f64 ^ i64)
+max(f64 ^ 1)
+max(f64 ^ f32)
+max(f64 ^ f64)
 max(f64)
-max(f64) != i
-max(f64) + f32
-max(f64) + i64
-max(f64) - f32
-max(f64) / f32
-max(f64) / i32
-max(f64) == f64
-max(f64) == i32
-max(f64) > f32
-max(f64) > f64
-max(f64) > i64
-max(f64) ^ 1 ^ i64
-max(f64) ^ i
-max(f64) ^ min(i32, 1)
-max(f64, -1)
-max(f64, 0.5 ** i64)
-max(f64, 1) <= f64
-max(f64, 1) == i32
+max(f64) != f64
+max(f64) < i32
+max(f64) <= f32
+max(f64) == f32
+max(f64) == i
+max(f64) == round(i)
+max(f64) ^ f32
+max(f64) ^ i64
 max(f64, f32)
-max(f64, f32, i32)
-max(f64, f32, i64)
+max(f64, f32) <= int(f64)
 max(f64, f64)
-max(f64, f64, score(1))
-max(f64, float(i))
-max(f64, half(f64))
 max(f64, i)
+max(f64, i) - 1 ^ i
+max(f64, i) < i
+max(f64, i) > f64
 max(f64, i32)
 max(f64, i64)
-max(false ? 1 : 0.5)
-max(false ? 1 : nil)
-max(false ? add : ok)
-max(false ? i : nil)
-max(false ? i32 : score)
-max(false ? true : 1)
-max(find(array, ok))
-max(find(array, true))
-max(findIndex(array, ok))
-max(findIndex(array, true))
+max(f64, i64) ^ f32
+max(false ? 0.5 : array)
+max(false ? add : f64)
+max(false ? div : half)
+max(false ? div : i64)
+max(false ? ok : 0.5)
+max(find(array, false))
+max(findIndex(list, false))
 max(findIndex(list, ok))
-max(findIndex(list, true))
 max(findLast(array, false))
-max(findLast(array, true))
-max(findLastIndex(array, false))
-max(findLastIndex(list, true))
-max(first(array))
 max(float(0.5))
 max(float(1))
-max(float(f32))
-max(float(f64))
-max(float(i))
+max(float(1), i)
+max(float(i32))
 max(float(i64))
-max(float(i64), f64)
+max(float(score(i)))
+max(floor(0.5))
+max(floor(1))
+max(floor(f32))
+max(floor(i))
+max(floor(i32))
+max(floor(len(array)))
 max(get(array, 1))
 max(get(array, i))
 max(get(array, i32))
 max(get(array, i64))
-max(half(-0.5))
 max(half(0.5))
+max(half(1))
+max(half(1), i64)
 max(half(f64))
-max(i % i)
-max(i % i32)
-max(i % i64)
+max(i % 1)
 max(i * 0.5)
-max(i * 1)
 max(i * f32)
-max(i * i32)
-max(i ** 0.5)
-max(i ** 1)
+max(i * i)
+max(i * i64)
 max(i ** f64)
-max(i ** i)
-max(i ** i64)
-max(i + 0.5)
+max(i ** score(1))
 max(i + 1)
-max(i + f32)
-max(i + f64)
-max(i + i)
 max(i - 1)
-max(i - i32)
-max(i - i32, f32)
+max(i - i)
 max(i - i64)
-max(i / 0.5)
-max(i / f32)
-max(i / i32, f64)
-max(i ^ 0.5)
-max(i ^ 1)
-max(i ^ f32)
 max(i ^ f64)
 max(i)
-max(i) != f64
-max(i) ** f64
-max(i) + f32
-max(i) + i64
-max(i) - f32
-max(i) - f64
-max(i) - i32
-max(i) - i64
-max(i) / f64
-max(i) >= i64
-max(i) ^ (i * i)
-max(i) ^ f32
-max(i, -f32)
+max(i) != i32
+max(i) != i64
+max(i) % (i64 + i)
+max(i) % array[i32]
+max(i) ** (1 / i32)
+max(i) + f64
+max(i) - i
+max(i) / f32
+max(i) / i
+max(i) < 0.5 - f64
+max(i) < f32
+max(i) < i32
+max(i) <= f64
+max(i) == f64
+max(i) >= i
 max(i, f32)
-max(i, f32, f32)
 max(i, f64)
 max(i, i)
 max(i, i32)
 max(i, i64)
-max(i, i64, i64)
+max(i, i64, i32)
 max(i32 % 1)
-max(i32 % i32)
 max(i32 * 0.5)
 max(i32 * 1)
 max(i32 * f32)
+max(i32 * i)
 max(i32 * i64)
-max(i32 + 0.5, f64)
-max(i32 + f64)
-max(i32 + i)
-max(i32 + i32)
+max(i32 ** f32)
+max(i32 ** i)
+max(i32 ** i32)
+max(i32 + 0.5)
+max(i32 + i64)
+max(i32 - 0.5)
+max(i32 - 1)
+max(i32 - f64)
 max(i32 - i)
-max(i32 - i64)
-max(i32 / f32)
-max(i32 / f64)
-max(i32 / i64)
-max(i32 ^ 0.5)
-max(i32 ^ 1)
-max(i32 ^ f32)
+max(i32 / 1)
 max(i32 ^ i)
-max(i32 ^ i32)
+max(i32 ^ i, f32)
 max(i32)
-max(i32) != min(i64)
-max(i32) - f32
-max(i32) - i64
+max(i32) * i32
 max(i32) / f32
-max(i32) >= i32
-max(i32) ^ i64
-max(i32, 1) == i32
-max(i32, abs(f64))
+max(i32) / i
+max(i32) <= f32
+max(i32) ^ f32
+max(i32) in array
 max(i32, f32)
-max(i32, f32) != i32
 max(i32, f64)
-max(i32, f64) - f32
 max(i32, i)
-max(i32, i, i)
 max(i32, i32)
-max(i32, i32, i)
 max(i32, i64)
 max(i64 % i)
-max(i64 % i32)
 max(i64 * 0.5)
-max(i64 * 1)
-max(i64 * f32)
-max(i64 * i32)
-max(i64 ** 1)
+max(i64 * i64)
+max(i64 ** 0.5)
+max(i64 ** f32)
 max(i64 ** i64)
-max(i64 + 0.5)
-max(i64 + f32)
-max(i64 + i32)
+max(i64 + i)
+max(i64 + i64)
 max(i64 - 0.5)
 max(i64 - 1)
-max(i64 - f32)
 max(i64 - f64)
-max(i64 - i)
-max(i64 / 1)
 max(i64 / f64)
-max(i64 / i)
+max(i64 / i32)
 max(i64 / i64)
 max(i64 ^ 0.5)
 max(i64 ^ 1)
 max(i64 ^ i)
-max(i64 ^ i64)
 max(i64)
-max(i64) != f32
-max(i64) != i32
-max(i64) * i32
-max(i64) * i64
-max(i64) ** i64
-max(i64) + f32
-max(i64) + i64
-max(i64) / f32
-max(i64) / i
-max(i64) / i64
+max(i64) ** (1 + 1)
+max(i64) ** f32
+max(i64) + i32
+max(i64) - i32
+max(i64) - i64
+max(i64) .. i32
 max(i64) < f32
-max(i64) < i64
-max(i64) <= i
-max(i64) == f32
-max(i64) == f64
-max(i64) >= i32
-max(i64) ^ (i64 / f32)
-max(i64) in array
-max(i64, 1) * i32
+max(i64) >= f32
+max(i64) ^ i
+max(i64, 0.5 + 1)
+max(i64, 0.5, i64) ** i32
 max(i64, f32)
 max(i64, f64)
+max(i64, half(1))
 max(i64, i)
+max(i64, i) + i32
 max(i64, i32)
+max(i64, i32) == f64
 max(i64, i64)
 max(int(0.5))
-max(int(1))
 max(int(f32))
-max(int(f64))
-max(int(i))
 max(int(i32))
 max(int(i64))
-max(last(array))
-max(len("bar"))
 max(len("foo"))
 max(len(array))
 max(len(list))
-max(len(list), 0.5 - i)
 max(max(0.5))
-max(max(0.5, 0.5))
+max(max(0.5, f64))
 max(max(1))
-max(max(f32))
-max(max(f64))
 max(max(i))
 max(max(i32))
 max(max(i64))
-max(min(0.5))
-max(min(0.5, i))
+max(mean(array))
+max(median(array))
+max(min(0.5, 0.5))
 max(min(1))
-max(min(1, i64, 1))
-max(min(f32))
-max(min(f64))
-max(min(f64, i64))
+max(min(1, f64))
+max(min(f32, i64, i32))
 max(min(i))
 max(min(i32))
-max(min(i32, i))
-max(ok ? 1 : foo)
+max(ok ? "foo" : f64)
+max(ok ? 0.5 : i64)
 max(ok ? 1 : i)
-max(ok ? 1 : i32)
-max(ok ? div : foo)
-max(ok ? div : i64)
-max(ok ? i : true)
-max(ok ? ok : i64)
-max(ok ? true : 0.5)
+max(ok ? array : true)
+max(ok ? foo : greet)
+max(ok ? half : f32)
+max(ok ? half : list)
+max(ok ? i : 1)
+max(ok ? i : nil)
+max(reduce(array, # % #))
+max(reduce(array, #))
+max(reduce(array, 1))
+max(reduce(array, f32))
+max(reduce(array, f64))
+max(reduce(list, 0.5))
+max(reduce(list, f32), i64)
+max(reduce(list, i64))
+max(round(1))
+max(round(f32))
+max(round(f64))
+max(round(i))
+max(round(i32))
 max(score(1))
-max(score(1), i64)
-max(score(i))
-max(score(i, i))
-max(true ? 0.5 : half)
-max(true ? 1 : i64)
-max(true ? add : list)
-max(true ? foo : add)
-max(true ? foo : f32)
-max(true ? i : ok)
-max(true ? i64 : "bar")
-min(-(0.5 + i))
-min(-(f32 + i64))
+max(score(i), i)
+max(true ? f32 : f32)
+max(true ? foo : array)
+max(true ? greet : 1)
+max({"bar": list}.String)
+max({"foo": array}?.f32)
+max({"foo": half}?.f32)
+mean(1 .. 1)
+mean(1 .. i)
+mean([f64, 0.5])
+mean([i])
+mean(array)
+mean(array) * i
+mean(array) + i
+mean(array) - min(i)
+mean(array) / i
+mean(array) / i64
+mean(array) < f32
+mean(array) < f64
+mean(array) <= i64
+mean(array) > f32
+mean(array) >= f32
+mean(array) >= i64
+mean(array) ^ i
+mean(array) ^ i32
+mean(filter(array, true))
+mean(groupBy(array, i64).score)
+mean(i .. 1)
+mean(i .. i)
+mean(map(array, #))
+mean(map(array, -#))
+mean(map(array, f32))
+mean(map(array, i))
+mean(map(array, i32))
+mean(map(list, 1))
+mean(map(list, f32))
+mean(map(list, i))
+mean(map(list, i32))
+mean(sort(array))
+median(1 .. i)
+median(array)
+median(array) != f32
+median(array) * 1 * f32
+median(array) * i32
+median(array) ** i64
+median(array) + f32
+median(array) >= i32
+median(array) ^ i32
+median(array) ^ i64
+median(array) not in array
+median(array[1:1])
+median(filter(array, ok))
+median(groupBy(list, #).i32)
+median(i .. i)
+median(i .. i64)
+median(i64 .. i64)
+median(map(array, #))
+median(map(array, 1))
+median(map(list, 0.5))
+median(map(list, f32))
+median(map(list, i32))
+median(reduce(array, array))
+median(reduce(list, array))
+median(sort(array))
 min(-0.5)
 min(-0.5, i)
 min(-1)
-min(-1, i)
-min(-1, i64)
 min(-f32)
-min(-f32, i64)
 min(-f64)
-min(-f64, i32)
+min(-half(0.5))
 min(-i)
 min(-i32)
 min(-i64)
 min(0.5 * 0.5)
 min(0.5 * 1)
+min(0.5 * f32, i32 ** i32)
 min(0.5 * f64)
 min(0.5 * i32)
-min(0.5 ** 0.5)
-min(0.5 ** f64)
+min(0.5 * i64)
+min(0.5 ** i)
 min(0.5 ** i64)
-min(0.5 + 1)
-min(0.5 + f32)
 min(0.5 + f64)
 min(0.5 + i)
+min(0.5 + i32)
 min(0.5 - 0.5)
 min(0.5 - 1)
+min(0.5 - f32)
 min(0.5 - f64)
 min(0.5 - i)
 min(0.5 / 0.5)
-min(0.5 / f64)
-min(0.5 ^ 1)
+min(0.5 / i64)
+min(0.5 / i64, i64)
+min(0.5 ^ 0.5)
 min(0.5 ^ f32)
 min(0.5 ^ i)
-min(0.5) != i32
-min(0.5) * 0.5 ** i64
+min(0.5 ^ i32)
+min(0.5) != i64
+min(0.5) * i32
+min(0.5) ** f64
 min(0.5) ** i
-min(0.5) + i
-min(0.5) + i32
-min(0.5) + i64
-min(0.5) < f32
-min(0.5) <= i ? f32 : 1
-min(0.5) <= i64
-min(0.5) == i - 0.5
-min(0.5) > i64
-min(0.5) >= i
-min(0.5, 0.5) == f32
-min(0.5, 1) >= i64
-min(0.5, i) == i64
-min(0.5, i32, f32) + f32
+min(0.5) + f64 ^ i64
+min(0.5) - f32
+min(0.5) - f64
+min(0.5) / i32
+min(0.5) < i32
+min(0.5) == f32 / f32
+min(0.5) == i
+min(0.5) >= i64
+min(0.5) ^ (f32 - i64)
+min(0.5, 0.5) < f32 + f64
+min(1 % 1)
+min(1 % i)
 min(1 % i32)
 min(1 % i64)
 min(1 * 0.5)
 min(1 * 1)
+min(1 * f32)
 min(1 * i)
 min(1 * i32)
-min(1 * i64)
-min(1 ** 0.5)
-min(1 ** f32)
-min(1 ** f64)
-min(1 ** i32)
+min(1 ** i)
 min(1 + 0.5)
 min(1 + 1)
 min(1 + f32)
-min(1 + i32)
 min(1 + i64)
 min(1 - 1)
 min(1 - f64)
 min(1 - i)
 min(1 - i32)
-min(1 / 1)
+min(1 - i64)
+min(1 / 0.5)
+min(1 / f32)
 min(1 / i)
 min(1 / i32)
-min(1 / i32, f64)
 min(1 / i64)
+min(1 ^ 0.5)
 min(1 ^ 1)
 min(1 ^ f32)
-min(1 ^ f64)
-min(1) != 1 ? list : f64
+min(1 ^ i)
+min(1 ^ i32)
+min(1 ^ i64)
 min(1) != i
-min(1) % i64
-min(1) * -0.5
-min(1) * 1 ** 1
-min(1) - i64 ^ 0.5
-min(1) .. i
-min(1) .. i64
-min(1) / f64
-min(1) / i
-min(1) < i
-min(1) == f64
-min(1) == i32
+min(1) - i
+min(1) .. i32
+min(1) <= f32
+min(1) <= f64
+min(1) > i64
+min(1) >= i
 min(1) >= i64
-min(1) ^ f32
+min(1) ^ f64
 min(abs(0.5))
 min(abs(1))
 min(abs(f32))
 min(abs(f64))
-min(abs(i * 1))
 min(abs(i))
 min(abs(i32))
-min(abs(i64))
-min(abs(i64), f64)
-min(add(1, i))
-min(add(i, i))
 min(array[1])
+min(array[i32])
 min(array[i])
+min(bitnand(1, i32))
+min(bitnot(1))
+min(bitnot(i))
+min(bitnot(i32))
+min(bitnot(i32), i64)
+min(bitnot(i64))
+min(ceil(0.5))
+min(ceil(1))
+min(ceil(f32))
+min(ceil(f64))
+min(ceil(i))
 min(count(array, false))
-min(count(array, ok))
-min(count(array, true))
 min(count(list, ok))
 min(f32 * 1)
-min(f32 * f32)
-min(f32 * i32)
-min(f32 ** i32)
-min(f32 ** i64)
-min(f32 ** i64, f32)
-min(f32 + f64)
-min(f32 + i)
-min(f32 + i32)
-min(f32 + i64)
-min(f32 - f32)
+min(f32 * i64)
+min(f32 ** 0.5)
+min(f32 - 0.5)
+min(f32 - 1)
+min(f32 - f64)
 min(f32 - i)
-min(f32 - i32)
 min(f32 - i64)
-min(f32 / 0.5)
-min(f32 / f64)
-min(f32 / i)
-min(f32 / i32)
+min(f32 / 1)
 min(f32 / i64)
-min(f32 ^ 1)
-min(f32 ^ f32)
-min(f32 ^ i)
 min(f32 ^ i32)
 min(f32)
-min(f32) * f32
-min(f32) * f64
-min(f32) + i
-min(f32) + i32
-min(f32) + i64
-min(f32) - f32
-min(f32) < i64
+min(f32) * i64
+min(f32) / f64
+min(f32) / i32
 min(f32) == i
-min(f32) == i32 * i32
-min(f32) == i64
-min(f32) > i32
-min(f32) ^ f64
-min(f32, 0.5 ^ 0.5)
-min(f32, 0.5) <= i64
+min(f32) >= f64
+min(f32, -0.5)
+min(f32, ceil(1))
 min(f32, f32)
 min(f32, f64)
-min(f32, f64) >= i
-min(f32, get(array, i64))
 min(f32, i)
 min(f32, i32)
 min(f32, i64)
-min(f32, len(array))
-min(f32, len(list))
-min(f64 * 0.5)
 min(f64 * 1)
 min(f64 * f64)
-min(f64 * i)
-min(f64 * i32)
-min(f64 ** 1)
+min(f64 ** f32)
 min(f64 ** f64)
-min(f64 ** i)
-min(f64 ** i32)
-min(f64 ** i64)
-min(f64 + 1)
-min(f64 + i)
+min(f64 + 0.5)
+min(f64 + f32)
 min(f64 + i64)
-min(f64 - 0.5)
+min(f64 - 1)
 min(f64 - i)
 min(f64 - i32)
-min(f64 - i64)
-min(f64 / 1)
+min(f64 / 0.5)
 min(f64 / f32)
 min(f64 / i)
-min(f64 / i32)
 min(f64 / i64)
-min(f64 ^ 0.5)
-min(f64 ^ f64)
-min(f64 ^ i32)
+min(f64 ^ 1)
 min(f64)
-min(f64) + f64
-min(f64) + i32
-min(f64) + i64
-min(f64) / f32
-min(f64) ^ 1 ^ 1
-min(f64) ^ i32
-min(f64) ^ i64
-min(f64, 0.5 ** 1)
-min(f64, 0.5, i) <= f64
-min(f64, 1 ** i)
-min(f64, 1) < i64
+min(f64) * f64
+min(f64) * i32
+min(f64) / i
+min(f64) >= f64
+min(f64, 0.5 ** i64)
+min(f64, 0.5) == f64
 min(f64, f32)
 min(f64, f64)
-min(f64, f64, i64)
 min(f64, i)
 min(f64, i32)
 min(f64, i64)
-min(false ? 1 : add)
-min(false ? f64 : false)
-min(false ? f64 : score)
-min(false ? foo : 1)
-min(false ? greet : i)
-min(false ? i32 : "foo")
-min(false ? i32 : i64)
-min(false ? true : 0.5)
+min(false ? foo : i32)
+min(false ? greet : f32)
 min(find(array, false))
 min(find(array, ok))
-min(findIndex(list, ok))
-min(findLast(array, true))
-min(findLastIndex(array, false))
+min(findIndex(array, false))
+min(findLastIndex(array, i32 > #))
 min(findLastIndex(array, ok))
 min(findLastIndex(array, true))
 min(findLastIndex(list, ok))
@@ -10879,220 +13414,188 @@ min(float(1))
 min(float(f32))
 min(float(f64))
 min(float(i))
-min(float(i32))
-min(float(i64))
-min(get(array, i))
-min(get(array, i64))
-min(half(0.5 ^ i32))
+min(float(i64), i)
+min(floor(0.5))
+min(floor(1))
+min(floor(f32))
+min(floor(i))
+min(floor(i32))
+min(floor(i64))
 min(half(0.5))
-min(half(0.5), f32)
+min(half(1))
+min(half(1), -1)
+min(half(f64 - 0.5))
 min(half(f64))
 min(i % 1)
-min(i % i32)
 min(i % i64)
-min(i * 0.5)
-min(i * 1)
 min(i * i)
-min(i * i64)
 min(i ** 0.5)
-min(i ** f32)
-min(i ** f64)
 min(i ** i)
-min(i ** i64)
-min(i + 0.5)
-min(i + f32)
-min(i + f64)
-min(i + i)
+min(i + 1)
 min(i - 0.5)
-min(i - 1)
-min(i - i)
-min(i / 0.5)
-min(i / i64)
-min(i / i64, i)
-min(i ^ 0.5)
-min(i ^ i, i32)
+min(i - f64)
+min(i - i32)
+min(i / 1) + f64
+min(i / f64)
+min(i ^ f32)
+min(i ^ f64)
+min(i ^ i)
 min(i)
-min(i) != i32
-min(i) % i
 min(i) * f32
-min(i) ** i
-min(i) .. i
+min(i) ** i64
 min(i) / f64
-min(i) < f32
-min(i) <= i64
+min(i) / i
+min(i) < f64
+min(i) < i32
+min(i) >= i32
+min(i) ^ f32
 min(i, f32)
+min(i, f32, i) + i32
 min(i, f64)
 min(i, i)
-min(i, i32 - i)
 min(i, i32)
-min(i, i64 * f32)
 min(i, i64)
-min(i32 % i)
-min(i32 * 1)
-min(i32 * f64)
-min(i32 * i32)
-min(i32 ** 1 ^ i64)
-min(i32 ** f32)
-min(i32 ** i)
-min(i32 ** i64)
-min(i32 + 0.5)
-min(i32 + 1)
-min(i32 + f32)
+min(i, last(array))
+min(i32 % 1)
+min(i32 * f32)
+min(i32 * i)
+min(i32 ** 0.5)
+min(i32 ** i32)
+min(i32 + i32)
+min(i32 + i64)
 min(i32 - 0.5)
-min(i32 - 1)
-min(i32 - i32)
-min(i32 / 1)
-min(i32 / i)
-min(i32 / i64)
-min(i32 / i64, score(1))
-min(i32 ^ 1)
+min(i32 - i64)
+min(i32 / 0.5)
+min(i32 / f64)
+min(i32 ^ 0.5)
+min(i32 ^ f32)
 min(i32 ^ f64)
-min(i32 ^ i)
 min(i32 ^ i64)
 min(i32)
-min(i32) != i64
-min(i32) + f32
-min(i32) - i64
-min(i32) / f32
-min(i32) < i32
-min(i32) == f32
-min(i32) == i32
-min(i32) >= i32
-min(i32) ^ f64
-min(i32, 0.5) .. i32
+min(i32) - i
+min(i32) .. i32
+min(i32) / i
+min(i32) < i
+min(i32) <= f32
+min(i32) <= i
+min(i32) > f32
+min(i32) > i64 + f64
+min(i32) >= i
+min(i32) ^ f32
+min(i32) ^ i64
 min(i32, f32)
+min(i32, f64 * 0.5)
 min(i32, f64)
 min(i32, i)
 min(i32, i32)
-min(i32, i32, i)
 min(i32, i64)
-min(i32, i64) .. i
-min(i32, i64) <= f64
-min(i32, min(i))
-min(i64 % i32)
-min(i64 * 1, f32)
-min(i64 * f64)
+min(i64 % 1)
+min(i64 * 0.5)
+min(i64 * 1)
+min(i64 * bitnot(i64))
+min(i64 * i)
 min(i64 * i32)
+min(i64 * i64)
 min(i64 ** 0.5)
-min(i64 ** 1)
+min(i64 ** f64)
 min(i64 ** i)
-min(i64 + 0.5)
-min(i64 + 1)
+min(i64 ** i32)
 min(i64 + f32)
-min(i64 + i)
-min(i64 + i32)
-min(i64 - 0.5)
-min(i64 - f32)
 min(i64 - f64)
-min(i64 - i)
-min(i64 - i64)
-min(i64 / 0.5)
-min(i64 / f64)
+min(i64 - i32)
+min(i64 / 1)
+min(i64 / f32)
 min(i64 / i)
+min(i64 / i32)
 min(i64 / i64)
+min(i64 ^ 0.5)
 min(i64 ^ 1)
+min(i64 ^ f64)
 min(i64 ^ i32)
-min(i64 ^ i64)
 min(i64)
-min(i64) != i64
-min(i64) % i32
-min(i64) ** -1
-min(i64) ** -f64
-min(i64) ** i
-min(i64) + i32
-min(i64) .. i
-min(i64) .. i64
-min(i64) <= f32
-min(i64) == i
-min(i64) ^ f32
-min(i64) ^ f64
-min(i64) in array
-min(i64, 1 ** 0.5)
-min(i64, 1) <= f64
+min(i64) / f32
+min(i64) < i32
+min(i64) >= f64
+min(i64) not in array
 min(i64, f32)
 min(i64, f64)
-min(i64, f64) != f64
-min(i64, f64) * i32
-min(i64, f64, i32)
 min(i64, i)
 min(i64, i32)
-min(i64, i32, i)
 min(i64, i64)
-min(i64, i64, f32)
+min(i64, i64) < i64
 min(int(0.5))
 min(int(1))
 min(int(f32))
 min(int(f64))
 min(int(i))
+min(int(i32))
 min(int(i64))
+min(last(1 .. 1))
 min(last(array))
-min(len("bar"))
-min(len("foo"))
 min(len(array))
 min(len(list))
-min(len(list), f64)
 min(max(0.5))
-min(max(1))
 min(max(1, 0.5))
-min(max(1, f32))
-min(max(1, i32))
 min(max(f32))
 min(max(f64))
-min(max(i), i64)
-min(max(i32))
-min(min(0.5))
-min(min(0.5, 1))
+min(max(i))
+min(max(i64, 1))
+min(mean(array))
 min(min(1))
-min(min(f32))
-min(min(f32, i, i32))
-min(min(f64))
+min(min(1, 1, 1))
+min(min(1, i, f32))
 min(min(i))
 min(min(i32))
-min(min(i64))
-min(ok ? add : 0.5)
-min(ok ? f32 : "foo")
-min(ok ? f64 : true)
-min(ok ? foo : 1)
-min(ok ? true : 1)
+min(min(reduce(list, f32)))
+min(ok ? array : false)
+min(ok ? f64 : i)
+min(ok ? half : ok)
+min(ok ? i : f32)
+min(ok ? array : score)
+min(ok ? true : div)
+min(reduce(array, #))
+min(reduce(array, 0.5))
+min(reduce(array, 1))
+min(reduce(list, 1))
+min(round(0.5))
+min(round(1))
+min(round(f32))
+min(round(i32))
+min(round(i64))
 min(score(1))
 min(score(i))
-min(true ? 0.5 : ok)
-min(true ? 1 : greet)
-min(true ? add : greet)
-min(true ? f32 : i)
-min(true ? foo : 0.5)
-min(true ? foo : half)
-min(true ? i : 1)
-min(true ? i32 : score)
-nil != "bar" ? i64 : 0.5 - i
-nil != 0.5 && 0.5 != f32
-nil != 1 && ok
-nil != 1 or any(list, false)
-nil != 1 || ok
-nil != f32 || ok
-nil != f64 && ok
-nil != f64 or ok
-nil != f64 || array != array
-nil != false and not true
-nil != false and ok
-nil != false || ok
-nil != foo == ok
-nil != foo || ok
+min(sum(array))
+min(true ? i : "foo")
+min(true ? i : i32)
+min(true ? i64 : "foo")
+nil != array != nil ? add : half
+nil != array && ok
+nil != div == reduce(array, ok)
+nil != f64 || ok || false
+nil != false && ok
+nil != false or i == nil
+nil != foo and ok
 nil != foo.Bar
 nil != foo.Qux
 nil != foo.String
+nil != foo.String()
 nil != foo?.Bar
 nil != foo?.Qux
 nil != foo?.String
-nil != greet ? half : half
-nil != greet or f32 < i
-nil != i32 or f32 >= 1
-nil != i64 or i >= 1
-nil != ok == not true
-nil != true == ok
-nil == 1 != nil ? "bar" : i32
-nil == add == ("bar" not endsWith "foo")
-nil == f32 && i64 < f64
+nil != foo?.String()
+nil != nil ? score : div
+nil != true || i < 1
+nil == "foo" != ok
+nil == "foo" && 0.5 < f64
+nil == 0.5 and reduce(list, true)
+nil == add && 0.5 >= 0.5
+nil == add || f32 >= i64
+nil == array and ok
+nil == array or ok
+nil == array[i64]
+nil == div ? f64 : ok
+nil == false && nil != true
+nil == false ? i64 : toBase64("bar")
 nil == foo.Bar
 nil == foo.Qux
 nil == foo.String
@@ -11100,28 +13603,30 @@ nil == foo.String()
 nil == foo?.Bar
 nil == foo?.Qux
 nil == foo?.String
-nil == foo?.String()
-nil == i64 ? add : add
-nil == nil == ok
-nil == true ? i64 ^ f32 : foo
-nil == true || ok
-nil in array || ok
-nil in array[i32:i64]
-nil in list and ok
-none(array, !ok)
+nil == greet ? i : greet("bar")
+nil == list || f32 == i
+nil == list[i32]
+nil == nil and ok
+nil in array || score == nil
+nil in list != not false
+none(1 .. i, # < #)
+none(1 .. i32, # <= #)
+none([foo, list, 1 >= i], ok)
+none([greet], ok)
+none([true], #)
+none(array, !(i32 != i32))
+none(array, !false)
 none(array, !true)
-none(array, "bar" == "bar")
+none(array, "bar" endsWith "foo")
 none(array, # != #)
+none(array, # != 0.5)
 none(array, # != 1)
 none(array, # != f32)
 none(array, # != f64)
-none(array, # != i32)
-none(array, # != i64)
+none(array, # != i)
 none(array, # < #)
 none(array, # < 0.5)
-none(array, # < 1)
 none(array, # < f32)
-none(array, # < i)
 none(array, # < i32)
 none(array, # < i64)
 none(array, # <= #)
@@ -11130,155 +13635,164 @@ none(array, # <= 1)
 none(array, # <= f32)
 none(array, # <= i)
 none(array, # <= i32)
+none(array, # <= i64)
 none(array, # == #)
 none(array, # == 0.5)
-none(array, # == 1)
-none(array, # == i)
+none(array, # == f32)
+none(array, # == i32)
+none(array, # == i64)
 none(array, # == nil)
 none(array, # > #)
 none(array, # > 0.5)
-none(array, # > f32)
-none(array, # > f64)
 none(array, # > i)
-none(array, # > i32)
 none(array, # >= #)
 none(array, # >= 0.5)
 none(array, # >= 1)
 none(array, # >= f32)
 none(array, # >= f64)
+none(array, # >= i32)
+none(array, # >= i64)
 none(array, # in array)
-none(array, # not in array)
 none(array, 0.5 != #)
-none(array, 0.5 != f32)
+none(array, 0.5 != 1)
 none(array, 0.5 < #)
-none(array, 0.5 <= 0.5)
+none(array, 0.5 < i64)
+none(array, 0.5 <= #)
 none(array, 0.5 <= 1)
-none(array, 0.5 <= i)
-none(array, 0.5 > #)
+none(array, 0.5 <= f64)
+none(array, 0.5 == #)
+none(array, 0.5 > 0.5)
+none(array, 0.5 > 1)
+none(array, 0.5 > f32)
 none(array, 0.5 >= #)
-none(array, 1 != #)
+none(array, 0.5 >= 1)
 none(array, 1 < #)
-none(array, 1 < 0.5)
-none(array, 1 < i)
-none(array, 1 < i64)
-none(array, 1 <= 1)
-none(array, 1 == #)
-none(array, 1 == f64)
+none(array, 1 <= #)
+none(array, 1 == 1)
 none(array, 1 > #)
-none(array, 1 > f64)
-none(array, 1 >= i)
-none(array, add != greet)
-none(array, all(array, true))
-none(array, div == greet)
+none(array, any(array, true))
 none(array, f32 != #)
-none(array, f32 != nil)
-none(array, f32 <= #)
+none(array, f32 < 0.5)
+none(array, f32 < 1)
+none(array, f32 == 1)
+none(array, f32 > #)
 none(array, f32 >= #)
-none(array, f64 != #)
+none(array, f32 >= 1)
+none(array, f32 >= f32)
+none(array, f64 != 1)
 none(array, f64 == #)
-none(array, f64 >= 0.5)
-none(array, half != nil)
+none(array, f64 > #)
+none(array, f64 >= #)
+none(array, i != #)
 none(array, i < #)
-none(array, i < 1)
+none(array, i < f64)
 none(array, i <= #)
-none(array, i == i64)
-none(array, i not in array)
+none(array, i > #)
+none(array, i >= #)
+none(array, i >= 0.5)
+none(array, i >= i32)
 none(array, i32 != #)
-none(array, i32 != f64)
+none(array, i32 != i)
 none(array, i32 != nil)
 none(array, i32 < #)
 none(array, i32 > #)
-none(array, i32 >= #)
-none(array, i64 < #)
-none(array, i64 < f64)
+none(array, i64 != #)
+none(array, i64 != 0.5)
+none(array, i64 > i64)
 none(array, i64 >= #)
-none(array, nil != 0.5)
-none(array, nil != div)
+none(array, nil != "bar")
+none(array, nil != #)
+none(array, nil != false)
+none(array, nil != greet)
 none(array, nil == #)
 none(array, nil == 1)
-none(array, nil == div)
-none(array, none(array, !true))
-none(array, not ok)
-none(array, ok == nil)
+none(array, nil == f32)
+none(array, nil == greet)
+none(array, nil == half)
+none(array, not (# == #))
+none(array, not (# >= 1))
+none(array, not false)
 none(array, ok)
-none(array, ok) != ok
-none(array, ok) ? f32 : !ok
-none(array, score == nil)
-none(array, score == score)
-none(array, true ? ok : f64)
-none(array, true or true)
-none(i64 .. i32, # > #)
-none(list, "bar" not in #)
+none(array, reduce(array, true))
+none(filter(array, # >= f64), ok)
+none(groupBy(array, #).f64, # or #.Bar)
+none(groupBy(list, #).div, ok)
+none(groupBy(list, #).greet, #)
+none(groupBy(list, 0.5).i, ok)
+none(i .. i, ok)
+none(i .. i32, # <= #)
+none(list, !false)
+none(list, !ok)
+none(list, "bar" contains "bar")
 none(list, # != #)
 none(list, # != foo)
 none(list, # != nil)
 none(list, # == #)
-none(list, # == nil)
-none(list, 0.5 != i)
-none(list, 0.5 <= 1)
-none(list, 0.5 <= f64)
-none(list, 0.5 == nil)
-none(list, 1 < i32)
+none(list, # == foo)
+none(list, # in list)
+none(list, # not in list)
+none(list, (0.5 not in array) || ok)
+none(list, 0.5 != i32)
+none(list, 0.5 > f64)
+none(list, 0.5 > i)
+none(list, 1 != i64)
+none(list, 1 != nil)
 none(list, 1 == f32)
-none(list, any(list, ok))
-none(list, array == nil)
-none(list, f32 > i)
-none(list, f64 == i32)
-none(list, false && false)
-none(list, false) or f64 >= i64
+none(list, 1 > 0.5)
+none(list, all(array, ok))
+none(list, f32 != 1 ** f64)
+none(list, f32 >= 0.5)
+none(list, f32 in array)
+none(list, f32 not in array)
+none(list, f64 <= i32)
+none(list, f64 >= 1)
+none(list, false) ? ok : half
+none(list, false) || ok
 none(list, foo != #)
-none(list, foo == #)
-none(list, greet != add)
-none(list, greet != half)
-none(list, i <= i64)
-none(list, i >= 1)
-none(list, i >= f64)
-none(list, i not in array)
-none(list, i32 != nil)
-none(list, i32 == f64)
-none(list, i32 == nil)
-none(list, i32 >= 1)
-none(list, i32 >= f32)
-none(list, i64 < f64)
-none(list, i64 <= f64)
-none(list, i64 > f64)
+none(list, foo == foo)
+none(list, i != i)
+none(list, i != i64)
+none(list, i >= f32)
+none(list, i32 == f32)
+none(list, i32 > 1)
+none(list, i32 > i64)
+none(list, i32 not in array)
+none(list, i64 != 0.5)
 none(list, i64 > i64)
-none(list, nil != array)
-none(list, nil != true)
-none(list, nil == foo)
+none(list, nil != #)
+none(list, nil != greet)
+none(list, nil != i64)
+none(list, nil == #)
+none(list, nil == list)
 none(list, not false)
-none(list, not ok)
 none(list, ok)
-none(list, one(array, false))
-none(list, score != nil)
-none(list, score == add)
+none(list, one(array, true))
 none(list, true && ok)
-none(list, true == ok)
-none(list, true) ? div : array
-none(map(array, "bar"), # not endsWith #)
-none(map(array, "foo"), # not endsWith #)
+none(list, true) and ok
 none(map(array, #), ok)
-none(map(array, 0.5), # == #)
-none(map(array, 1), # >= #)
-none(map(array, half), # == #)
-none(map(array, ok), #)
-none(map(list, "bar"), # not startsWith #)
-none(map(list, "bar"), # startsWith #)
-none(map(list, #), # != #)
+none(map(array, div), # != #)
+none(map(array, f64 == #), ok)
+none(map(list, "bar"), # endsWith #)
+none(map(list, #), nil == list)
 none(map(list, #), ok)
-none(map(list, i32), f64 > #)
-none(map(list, true), # != #)
-none(ok ? "bar" : ok, # >= f64)
-not !("foo" not matches "foo")
-not !(0.5 > 1)
-not !(f64 >= i32)
-not !(false && ok)
-not !(i >= i32)
+none(map(list, 1), i > #)
+none(map(list, ok), # ? true : #)
+none(map(list, ok), #)
+none(map(list, score), ok)
+none(sort(filter(array, false)), #?.div > greet(#))
+not !(0.5 != i64)
+not !(i < 1)
+not !(i >= 0.5)
+not !(i32 != i32)
+not !(nil != false)
 not !false
+not !not false
 not !ok
 not !true
+not ("bar" != "bar")
 not ("bar" != "foo")
 not ("bar" != nil)
+not ("bar" < "bar")
 not ("bar" < "foo")
 not ("bar" <= "bar")
 not ("bar" <= "foo")
@@ -11295,6 +13809,7 @@ not ("bar" endsWith "bar")
 not ("bar" endsWith "foo")
 not ("bar" in foo)
 not ("bar" matches "bar")
+not ("bar" matches "foo")
 not ("bar" not contains "bar")
 not ("bar" not contains "foo")
 not ("bar" not endsWith "bar")
@@ -11302,6 +13817,8 @@ not ("bar" not endsWith "foo")
 not ("bar" not in foo)
 not ("bar" not matches "bar")
 not ("bar" not matches "foo")
+not ("bar" not startsWith "bar")
+not ("bar" not startsWith "foo")
 not ("bar" startsWith "bar")
 not ("bar" startsWith "foo")
 not ("foo" != "bar")
@@ -11316,7 +13833,9 @@ not ("foo" == "foo")
 not ("foo" == nil)
 not ("foo" > "bar")
 not ("foo" > "foo")
+not ("foo" >= "bar")
 not ("foo" >= "foo")
+not ("foo" contains "bar")
 not ("foo" contains "foo")
 not ("foo" endsWith "bar")
 not ("foo" endsWith "foo")
@@ -11328,13 +13847,13 @@ not ("foo" not contains "foo")
 not ("foo" not endsWith "bar")
 not ("foo" not endsWith "foo")
 not ("foo" not in foo)
-not ("foo" not matches "bar")
 not ("foo" not matches "foo")
-not ("foo" not startsWith "bar")
 not ("foo" not startsWith "foo")
+not ("foo" startsWith "bar")
 not ("foo" startsWith "foo")
 not (0.5 != 0.5)
 not (0.5 != 1)
+not (0.5 != f32)
 not (0.5 != f64)
 not (0.5 != i)
 not (0.5 != i32)
@@ -11358,6 +13877,7 @@ not (0.5 == 0.5)
 not (0.5 == 1)
 not (0.5 == f32)
 not (0.5 == f64)
+not (0.5 == i && i32 != i32)
 not (0.5 == i)
 not (0.5 == i32)
 not (0.5 == i64)
@@ -11376,6 +13896,8 @@ not (0.5 >= f64)
 not (0.5 >= i)
 not (0.5 >= i32)
 not (0.5 >= i64)
+not (0.5 in array)
+not (0.5 not in array)
 not (1 != 0.5)
 not (1 != 1)
 not (1 != f32)
@@ -11384,7 +13906,6 @@ not (1 != i)
 not (1 != i32)
 not (1 != i64)
 not (1 != nil)
-not (1 + i > 0.5 ** i32)
 not (1 < 0.5)
 not (1 < 1)
 not (1 < f32)
@@ -11404,6 +13925,7 @@ not (1 == 1)
 not (1 == f32)
 not (1 == f64)
 not (1 == i)
+not (1 == i32)
 not (1 == i64)
 not (1 == nil)
 not (1 > 0.5)
@@ -11420,40 +13942,25 @@ not (1 >= f64)
 not (1 >= i)
 not (1 >= i32)
 not (1 >= i64)
-not (1 ^ f32 != i64)
 not (1 in array)
 not (1 not in array)
-not (abs(i) <= i)
 not (add != add)
-not (add != div)
-not (add != greet)
-not (add != half)
 not (add != nil)
-not (add != score)
-not (add == add)
 not (add == div)
-not (add == greet)
-not (add == half)
 not (add == nil)
-not (add == score)
 not (array != array)
 not (array != list)
 not (array != nil)
 not (array == array)
 not (array == list)
 not (array == nil)
+not (array[i32] > i64)
 not (div != add)
 not (div != div)
-not (div != greet)
-not (div != half)
 not (div != nil)
-not (div != score)
 not (div == add)
 not (div == div)
-not (div == greet)
-not (div == half)
 not (div == nil)
-not (div == score)
 not (f32 != 0.5)
 not (f32 != 1)
 not (f32 != f32)
@@ -11464,7 +13971,6 @@ not (f32 != i64)
 not (f32 != nil)
 not (f32 < 0.5)
 not (f32 < 1)
-not (f32 < abs(0.5))
 not (f32 < f32)
 not (f32 < f64)
 not (f32 < i)
@@ -11472,7 +13978,6 @@ not (f32 < i32)
 not (f32 < i64)
 not (f32 <= 0.5)
 not (f32 <= 1)
-not (f32 <= f32)
 not (f32 <= f64)
 not (f32 <= i)
 not (f32 <= i32)
@@ -11481,6 +13986,7 @@ not (f32 == 0.5)
 not (f32 == 1)
 not (f32 == f32)
 not (f32 == f64)
+not (f32 == i)
 not (f32 == i32)
 not (f32 == i64)
 not (f32 == nil)
@@ -11488,15 +13994,19 @@ not (f32 > 0.5)
 not (f32 > 1)
 not (f32 > f32)
 not (f32 > f64)
+not (f32 > i)
 not (f32 > i32)
+not (f32 > i64)
 not (f32 >= 0.5)
 not (f32 >= 1)
 not (f32 >= f32)
 not (f32 >= f64)
 not (f32 >= i)
+not (f32 >= i32)
 not (f32 >= i64)
+not (f32 in array)
+not (f32 not in array)
 not (f64 != 0.5)
-not (f64 != 1 * 0.5)
 not (f64 != 1)
 not (f64 != f32)
 not (f64 != f64)
@@ -11508,28 +14018,29 @@ not (f64 < 0.5)
 not (f64 < 1)
 not (f64 < f32)
 not (f64 < f64)
-not (f64 < i)
 not (f64 < i32)
 not (f64 < i64)
+not (f64 <= -0.5)
 not (f64 <= 0.5)
 not (f64 <= 1)
 not (f64 <= f32)
 not (f64 <= f64)
+not (f64 <= i)
 not (f64 <= i32)
 not (f64 <= i64)
 not (f64 == 0.5)
 not (f64 == 1)
-not (f64 == f32)
 not (f64 == f64)
 not (f64 == i)
 not (f64 == i32)
-not (f64 == i64 - f32)
+not (f64 == i64)
 not (f64 == nil)
 not (f64 > 0.5)
 not (f64 > 1)
 not (f64 > f32)
 not (f64 > f64)
 not (f64 > i)
+not (f64 > i32)
 not (f64 > i64)
 not (f64 >= 0.5)
 not (f64 >= 1)
@@ -11538,16 +14049,18 @@ not (f64 >= f64)
 not (f64 >= i)
 not (f64 >= i32)
 not (f64 >= i64)
+not (f64 in array)
+not (f64 not in array)
 not (false != false)
 not (false != nil)
 not (false != ok)
 not (false != true)
+not (false && false)
 not (false && ok)
-not (false && true)
-not (false == false)
 not (false == nil)
-not (false == true)
+not (false == ok)
 not (false and false)
+not (false and ok)
 not (false and true)
 not (false or false)
 not (false or ok)
@@ -11555,35 +14068,21 @@ not (false or true)
 not (false || false)
 not (false || ok)
 not (false || true)
+not (findIndex(list, ok) != i ^ f64)
 not (foo != foo)
 not (foo != nil)
 not (foo == foo)
 not (foo == nil)
 not (foo in list)
 not (foo not in list)
-not (greet != add)
-not (greet != div)
 not (greet != greet)
-not (greet != half)
 not (greet != nil)
-not (greet != score)
-not (greet == add)
-not (greet == div)
 not (greet == greet)
-not (greet == half)
 not (greet == nil)
-not (greet == score)
-not (half != add)
-not (half != div)
-not (half != greet)
+not (half != half)
 not (half != nil)
-not (half != score)
-not (half == add)
-not (half == div)
-not (half == greet)
 not (half == half)
 not (half == nil)
-not (half == score)
 not (i != 0.5)
 not (i != 1)
 not (i != f32)
@@ -11603,27 +14102,31 @@ not (i <= 0.5)
 not (i <= 1)
 not (i <= f32)
 not (i <= f64)
+not (i <= i)
 not (i <= i32)
 not (i <= i64)
 not (i == 0.5)
 not (i == 1)
+not (i == ceil(f64))
 not (i == f32)
 not (i == f64)
 not (i == i)
 not (i == i32)
+not (i == i64)
 not (i == nil)
 not (i > 0.5)
 not (i > 1)
 not (i > f32)
 not (i > f64)
 not (i > i)
+not (i > i32)
 not (i > i64)
 not (i >= 0.5)
 not (i >= 1)
-not (i >= div(1, 1))
 not (i >= f32)
 not (i >= f64)
 not (i >= i)
+not (i >= i32)
 not (i >= i64)
 not (i in array)
 not (i not in array)
@@ -11632,10 +14135,13 @@ not (i32 != 1)
 not (i32 != f32)
 not (i32 != f64)
 not (i32 != i)
+not (i32 != i32)
 not (i32 != i64)
 not (i32 != nil)
 not (i32 < 0.5)
 not (i32 < 1)
+not (i32 < f32 ** 0.5)
+not (i32 < f32)
 not (i32 < f64)
 not (i32 < i)
 not (i32 < i32)
@@ -11647,6 +14153,7 @@ not (i32 <= f64)
 not (i32 <= i)
 not (i32 <= i32)
 not (i32 <= i64)
+not (i32 == -i)
 not (i32 == 0.5)
 not (i32 == 1)
 not (i32 == f32)
@@ -11670,6 +14177,7 @@ not (i32 >= i)
 not (i32 >= i32)
 not (i32 >= i64)
 not (i32 in array)
+not (i32 not in array)
 not (i64 != 0.5)
 not (i64 != 1)
 not (i64 != f32)
@@ -11685,12 +14193,12 @@ not (i64 < f64)
 not (i64 < i)
 not (i64 < i32)
 not (i64 < i64)
-not (i64 < int(f64))
 not (i64 <= 0.5)
 not (i64 <= 1)
 not (i64 <= f32)
 not (i64 <= f64)
 not (i64 <= i)
+not (i64 <= i32)
 not (i64 <= i64)
 not (i64 == 0.5)
 not (i64 == 1)
@@ -11702,6 +14210,7 @@ not (i64 == i64)
 not (i64 == nil)
 not (i64 > 0.5)
 not (i64 > 1)
+not (i64 > f32)
 not (i64 > f64)
 not (i64 > i)
 not (i64 > i32)
@@ -11712,8 +14221,7 @@ not (i64 >= f32)
 not (i64 >= f64)
 not (i64 >= i)
 not (i64 >= i32)
-not (i64 >= max(i))
-not (i64 in array)
+not (i64 >= i64)
 not (i64 not in array)
 not (list != array)
 not (list != list)
@@ -11732,7 +14240,6 @@ not (nil != f32)
 not (nil != f64)
 not (nil != false)
 not (nil != foo)
-not (nil != greet)
 not (nil != half)
 not (nil != i)
 not (nil != i32)
@@ -11767,7 +14274,6 @@ not (nil in array)
 not (nil in list)
 not (nil not in array)
 not (nil not in list)
-not (ok != false)
 not (ok != nil)
 not (ok != ok)
 not (ok != true)
@@ -11786,24 +14292,17 @@ not (ok or ok)
 not (ok or true)
 not (ok || ok)
 not (ok || true)
-not (score != add)
-not (score != div)
-not (score != greet)
-not (score != half)
 not (score != nil)
 not (score != score)
-not (score == add)
-not (score == div)
-not (score == greet)
-not (score == half)
 not (score == nil)
 not (score == score)
 not (true != false)
 not (true != nil)
 not (true != ok)
 not (true != true)
-not (true && ok)
+not (true && false)
 not (true && true)
+not (true == false)
 not (true == nil)
 not (true == ok)
 not (true == true)
@@ -11812,707 +14311,1729 @@ not (true and ok)
 not (true and true)
 not (true or false)
 not (true or ok)
+not (true or true)
 not (true || false)
+not (true || ok)
+not (true || true)
+not all(array, false)
 not all(array, ok)
 not all(array, true)
-not all(list, false)
+not all(list, nil == #)
 not all(list, ok)
 not all(list, true)
 not any(array, false)
 not any(array, ok)
 not any(array, true)
-not any(list, # != #)
 not any(list, false)
 not any(list, ok)
 not any(list, true)
+not false && nil == f64
 not false && ok
-not false && ok ? list : array
-not false ? "bar" : 0.5
-not false ? "bar" : foo
-not false ? "foo" : 0.5
-not false ? 0.5 : greet
-not false ? 1 : div
-not false ? 1 : i32
-not false ? add : i
-not false ? array : "foo"
-not false ? array : array
-not false ? array : greet
-not false ? array : ok
-not false ? div : greet
-not false ? foo : 1
-not false ? foo : array
-not false ? greet : ok
-not false ? half : 0.5
-not false ? half : i32
-not false ? i : i64
-not false ? i : score
-not false ? i32 : 0.5
-not false ? i32 : add
-not false ? i32 : f32
-not false ? i32 : true
+not false == ok
+not false ? "foo" : "foo"
+not false ? 0.5 : "foo"
+not false ? 0.5 : array
+not false ? 0.5 : div
+not false ? 0.5 : foo
+not false ? 0.5 : i64
+not false ? 0.5 : nil
+not false ? 1 : 0.5
+not false ? add : array
+not false ? array : 0.5
+not false ? array : 1
+not false ? array : f64
+not false ? array : i
+not false ? array : true
+not false ? div : 0.5
+not false ? div : f64
+not false ? f32 : 0.5
+not false ? f32 : 1
+not false ? f32 : i
+not false ? f32 : nil
+not false ? f32 : score
+not false ? f64 : "foo"
+not false ? f64 : f64
+not false ? false : half
+not false ? false : list
+not false ? foo : f64
+not false ? greet : 1
+not false ? i : "bar"
+not false ? i : 1
+not false ? i : array
+not false ? i : i
+not false ? i32 : greet
 not false ? i64 : list
-not false ? list : i32
-not false ? nil : greet
-not false ? nil : i32
-not false ? nil : nil
-not false ? ok : "bar"
+not false ? list : i
+not false ? list : true
+not false ? nil : f32
+not false ? nil : half
+not false ? nil : ok
 not false ? ok : 1
-not false ? ok : list
-not false ? score : "foo"
-not false ? score : array
-not false ? score : score
-not false ? score : true
-not false ? true : 0.5
-not false ? true : 1
+not false ? score : ok
+not false ? true : f64
 not false ? true : nil
-not false or "foo" > "bar"
-not none(array, # == #)
+not false or false == false
+not false or ok
+not false || ok
+not none(array, # > f32)
 not none(array, false)
 not none(array, ok)
 not none(array, true)
 not none(list, false)
 not none(list, ok)
 not none(list, true)
-not not ("bar" >= "foo")
-not not (1 < i)
-not not (add == nil)
-not not (half == nil)
+not not (f64 <= 1)
+not not (i32 < i64)
+not not (i64 >= f64)
+not not (nil != greet)
+not not (ok or ok)
 not not false
 not not ok
 not not true
 not ok
+not ok != ok
+not ok && 1 > 0.5
 not ok && ok
-not ok == ok
-not ok ? "bar" : 1
-not ok ? "bar" : f32
-not ok ? 0.5 + f64 : half
-not ok ? 0.5 : "foo"
+not ok ? "bar" : list
+not ok ? "foo" : 0.5
+not ok ? "foo" : 1
+not ok ? 0.5 : "bar"
 not ok ? 0.5 : 0.5
-not ok ? 0.5 : div
-not ok ? 0.5 : f32
-not ok ? 0.5 : greet
-not ok ? 1 : 1
-not ok ? add : 0.5
-not ok ? array : f64
-not ok ? array : true
-not ok ? div : 1
-not ok ? div : add
-not ok ? f32 : div
-not ok ? f64 : 1
+not ok ? 0.5 : i
+not ok ? 1 : f64
+not ok ? 1 : nil
+not ok ? add : array
+not ok ? add : groupBy(array, #)
+not ok ? array : 1
+not ok ? array : f32
+not ok ? div : f64
+not ok ? f32 : f32
+not ok ? f64 : f64
 not ok ? f64 : half
-not ok ? false : f32
-not ok ? false : i
-not ok ? false : true
-not ok ? foo : add
-not ok ? foo : false
-not ok ? foo : i64
-not ok ? greet : add
-not ok ? half : true
-not ok ? i : div
-not ok ? i : true
-not ok ? i32 : nil
-not ok ? i64 : add
+not ok ? foo : foo
+not ok ? greet : 0.5
+not ok ? half : half
+not ok ? i : 1
+not ok ? i : add
+not ok ? i32 : 1
+not ok ? i32 : i
+not ok ? i64 : f32
+not ok ? i64 : f64
+not ok ? nil : "bar"
 not ok ? nil : 0.5
-not ok ? nil : div
 not ok ? nil : foo
-not ok ? nil : half
+not ok ? nil : greet
 not ok ? nil : i
-not ok ? score : div
-not ok ? score : i
-not ok ? score : true
-not ok ? true : f32
-not ok ? true : false
-not ok ? true : score
-not ok and not ok
+not ok ? ok : false
+not ok ? ok : list
+not ok ? score : "foo"
+not ok ? score : score
+not ok ? true : 1
+not ok ? true : div
+not ok ? true : half
+not ok ? true : i64
+not ok ? true : nil
+not ok and "foo" == "foo"
+not ok and i32 > 0.5
+not ok and ok
+not ok or 1 != i
 not ok or ok
-not ok or one(array, true)
+not ok || array == list
 not ok || ok
-not ok || true ? 0.5 : 1
-not one(array, # > f32)
 not one(array, false)
 not one(array, ok)
 not one(array, true)
 not one(list, false)
 not one(list, ok)
 not one(list, true)
-not true && i32 <= i32
-not true ? "foo" : i
-not true ? 1 : i64
-not true ? add : add
-not true ? add : foo
-not true ? array : 1
-not true ? array : add
-not true ? array : array
-not true ? array : i32
-not true ? array : i64
-not true ? div : nil
-not true ? f64 : i64
-not true ? foo : foo
-not true ? greet : "bar"
-not true ? greet : add
-not true ? greet : foo
-not true ? greet : i32
+not reduce(array, false)
+not reduce(array, ok)
+not reduce(array, true)
+not reduce(list, false)
+not reduce(list, ok)
+not reduce(list, true)
+not true != ok
+not true && ok
+not true == ok
+not true ? "bar" : array
+not true ? "bar" : i32
+not true ? "foo" : f32
+not true ? "foo" : f64
+not true ? 0.5 : foo
+not true ? 0.5 : greet
+not true ? 0.5 : i
+not true ? 0.5 : i64
+not true ? 1 : f32
+not true ? add : i32
+not true ? add : ok
+not true ? array : nil
+not true ? f32 : 0.5
+not true ? f32 : div
+not true ? f64 : 1
+not true ? f64 : array
+not true ? foo : greet
+not true ? foo : ok
+not true ? greet : 1
+not true ? greet : i64
+not true ? greet : list
+not true ? greet : true
 not true ? half : half
-not true ? i : 1
-not true ? i : i
-not true ? i32 : 0.5
-not true ? i64 : 1
+not true ? i : f64
+not true ? i64 : "foo"
+not true ? i64 : array
+not true ? i64 : i64
 not true ? list : "bar"
-not true ? list : 0.5
-not true ? list : 1
-not true ? list : array
-not true ? list : type(add)
-not true ? nil : list
-not true ? score : 1
-not true ? score : list
-not true ? score : true
+not true ? list : f64
+not true ? list : foo
+not true ? nil : div
+not true ? ok : nil
+not true ? score : f32
+not true ? score : score
+not true ? true : 1
+not true and ok ? i : half
 not true || ok
 ok
 ok != !ok
-ok != !true
+ok != (0.5 not in array)
 ok != false != ok
-ok != false ? 1 : i
+ok != false ? f32 : list
 ok != nil == nil
-ok != none(list, ok)
-ok != not !ok
+ok != nil ? f32 : greet
+ok != nil ? nil : array
 ok != not ok
 ok != ok
-ok != ok || ok
-ok && !ok ? f32 : 0.5
-ok && !true
-ok && "bar" >= "bar"
-ok && "foo" <= "bar"
-ok && 0.5 != nil
-ok && 0.5 == 0.5
-ok && 0.5 >= f32
-ok && 1 != f64
+ok != ok ? false : "bar"
+ok && !false
+ok && !ok
+ok && "foo" matches "bar"
+ok && ("bar" not endsWith "bar")
+ok && (false || ok)
+ok && (ok or false)
+ok && (true || true)
+ok && 0.5 < 1
+ok && 0.5 < f64
+ok && 0.5 <= 1
+ok && 0.5 == nil
+ok && 0.5 > i64
+ok && 1 != 0.5
 ok && 1 != i32
-ok && 1 < 1
-ok && 1 <= 0.5
-ok && 1 == f64
-ok && 1 >= f32
-ok && div == half
-ok && f32 != 0.5
-ok && f32 < 0.5
-ok && f32 == f32
-ok && f32 == i64
-ok && f64 < 1
-ok && f64 < i32
-ok && f64 == i32
-ok && f64 >= i32
-ok && false == false
-ok && i != i
-ok && i32 != 0.5
-ok && i32 < f32
-ok && i32 <= i64
-ok && i32 == 1
-ok && i32 >= 1
-ok && i64 < i32
-ok && i64 <= i32
-ok && i64 > 1
-ok && list != array
-ok && nil != f64
-ok && nil == add
-ok && nil == i32
-ok && nil == true
+ok && 1 <= 1
+ok && 1 <= f64
+ok && 1 == 0.5
+ok && 1 == nil
+ok && 1 >= f64
+ok && f32 != i
+ok && f32 >= i64
+ok && f64 <= 0.5
+ok && false != ok
+ok && false ? i : list
+ok && false ? ok : ok
+ok && i < 0.5
+ok && i < i64
+ok && i == 0.5
+ok && i > f64
+ok && i32 > 0.5
+ok && i32 >= i64
+ok && i64 != i
+ok && i64 == 0.5
+ok && nil != 0.5
+ok && nil != 1
+ok && nil == ok
+ok && not false
+ok && not true
 ok && ok
-ok && score != add
-ok && true != ok
-ok && true == nil
+ok && ok ? nil : div
+ok && ok and false
+ok && true != false
+ok && true && 1 >= i64
 ok == !false
-ok == !ok
-ok == (false or true)
-ok == (ok and ok)
-ok == any(list, ok)
-ok == false == nil
-ok == nil ? false : add
-ok == nil ? score : array
+ok == !true
+ok == ("bar" not endsWith "foo")
+ok == (0.5 not in array)
+ok == (false and ok)
+ok == (i32 not in array)
+ok == (nil not in list)
+ok == false ? f64 : 1
+ok == false ? score : 1
+ok == nil ? i64 : add
+ok == nil ? nil : f64
+ok == none(array, true)
 ok == not false
-ok == not true
 ok == ok
-ok ? "bar" : i == f32
-ok ? "bar" : i32 < i32
-ok ? "foo" : foo.String
-ok ? -0.5 : foo
-ok ? -f32 : i64 + 1
-ok ? -f64 : score
-ok ? -i64 : ok
-ok ? 0.5 * array[i64] : greet
-ok ? 0.5 : f64 < i64
-ok ? 0.5 : half != add
-ok ? 0.5 : i .. i
-ok ? 0.5 < i32 : score
-ok ? 0.5 == 0.5 : half
-ok ? 1 : 1 + i64 + i32
+ok == ok != false
+ok == true && ok
+ok ? "bar" : f64 <= f32
+ok ? "foo" : foo.Bar
+ok ? -0.5 : add
+ok ? -f64 : list
+ok ? -i32 : i
+ok ? 0.5 / 0.5 : f64
+ok ? 0.5 : i32 >= i64
+ok ? 0.5 > 1 : 0.5 * i64
+ok ? 1 + i : i32
+ok ? 1 / i64 : greet
 ok ? 1 : foo.Bar
-ok ? 1 : foo.String
+ok ? 1 : foo?.Qux
+ok ? abs(i64) : i64
+ok ? add : abs(f32)
 ok ? add : add
 ok ? add : array
-ok ? add : div
-ok ? add : f32
+ok ? add : f64
+ok ? add : foo
+ok ? add : foo?.String
 ok ? add : greet
+ok ? add : half
 ok ? add : i
-ok ? add : i32
 ok ? add : i64
 ok ? add : list
 ok ? add : ok
-ok ? array : div
-ok ? array : f64
-ok ? array : float(i32)
+ok ? array : array
+ok ? array : f32
+ok ? array : f64 + f64
 ok ? array : foo
-ok ? array : foo?.Bar
+ok ? array : foo.String
+ok ? array : foo?.String
+ok ? array : greet
+ok ? array : i
 ok ? array : i32
-ok ? array : i64
 ok ? array : list
-ok ? array : ok in map(array, ok)
+ok ? array : ok
+ok ? array : score
+ok ? div : add
+ok ? div : array
 ok ? div : div
-ok ? div : f32
 ok ? div : f64
-ok ? div : foo?.String
+ok ? div : foo
+ok ? div : foo.Bar
 ok ? div : greet
 ok ? div : half
-ok ? div : half(1)
-ok ? div : i32
-ok ? div : i64
-ok ? div : list
-ok ? div : list == array
+ok ? div : i32 > reduce(array, #)
+ok ? div : nil == true
+ok ? div : ok
 ok ? div : score
-ok ? div : score(i)
+ok ? f32 != i32 : f32
+ok ? f32 ** i64 : score
+ok ? f32 : -0.5
 ok ? f32 : add
 ok ? f32 : array
 ok ? f32 : div
 ok ? f32 : f32
 ok ? f32 : f64
 ok ? f32 : foo
-ok ? f32 : foo?.Bar
 ok ? f32 : half
-ok ? f32 : i != i64
 ok ? f32 : i32
+ok ? f32 : i64
+ok ? f32 : ok
+ok ? f32 : score
+ok ? f64 : add
 ok ? f64 : array
+ok ? f64 : div
+ok ? f64 : f64 - f64
+ok ? f64 : false != true
+ok ? f64 : foo
+ok ? f64 : foo.String
 ok ? f64 : greet
-ok ? f64 : half
-ok ? f64 : i64
+ok ? f64 : i32
+ok ? f64 : i32 % i32
+ok ? f64 : i32 >= -i64
+ok ? f64 : ok
 ok ? f64 : score
-ok ? false : foo?.String()
-ok ? foo : add
+ok ? false : foo.Bar
+ok ? foo : div
+ok ? foo : f32
 ok ? foo : foo
-ok ? foo : foo?.Bar
 ok ? foo : greet
-ok ? foo : i
-ok ? foo : i == i32
+ok ? foo : half
 ok ? foo : i32
+ok ? foo : i32 > i32
 ok ? foo : i64
-ok ? foo : i64 ^ f32
 ok ? foo : list
-ok ? get(array, i32) : ok
+ok ? foo : ok
+ok ? foo : score
+ok ? foo.Qux : ok
+ok ? greet : 0.5 > i
+ok ? greet : 1 <= 0.5
 ok ? greet : add
 ok ? greet : div
-ok ? greet : f64 == i64
-ok ? greet : greet
+ok ? greet : f32
+ok ? greet : f64
+ok ? greet : foo
 ok ? greet : half
-ok ? greet : i / i32
-ok ? greet : i32
-ok ? greet : i64 % i64
+ok ? greet : i64
 ok ? greet : list
-ok ? greet : type(f64)
-ok ? half : 0.5 ^ i32
+ok ? greet : map(list, i)
+ok ? greet : ok
+ok ? greet : score
 ok ? half : add
-ok ? half : array
-ok ? half : div
-ok ? half : f32 == f64
+ok ? half : f32
 ok ? half : f64
-ok ? half : f64 <= i
 ok ? half : foo
-ok ? half : foo?.Bar
+ok ? half : foo?.Qux
 ok ? half : greet
 ok ? half : half
-ok ? half : i
-ok ? half : i32
 ok ? half : list
+ok ? half : nil in list
 ok ? half : ok
-ok ? half : type(add)
-ok ? i : -i32
-ok ? i : 0.5 * i64
-ok ? i : 1 ** f64
+ok ? half : reduce(list, "bar")
+ok ? half : string(array)
+ok ? half(1) : add
+ok ? i : 1 / i64
+ok ? i : add
 ok ? i : array
-ok ? i : div
-ok ? i : f32
-ok ? i : f64
-ok ? i : foo.Bar
+ok ? i : f32 <= 0.5
+ok ? i : foo
+ok ? i : half
 ok ? i : i
 ok ? i : i32
+ok ? i : i64
+ok ? i : list
 ok ? i : ok
 ok ? i : score
-ok ? i32 + f32 : half
-ok ? i32 : -i32
-ok ? i32 : 1 not in array
+ok ? i32 : 1 - f64
 ok ? i32 : add
-ok ? i32 : array
+ok ? i32 : div
 ok ? i32 : f32
+ok ? i32 : f32 + 0.5
+ok ? i32 : f64
+ok ? i32 : foo
 ok ? i32 : foo.Qux
-ok ? i32 : foo?.Qux
-ok ? i32 : half
+ok ? i32 : greet
 ok ? i32 : i
 ok ? i32 : i32
+ok ? i32 : i32 + i32
 ok ? i32 : list
 ok ? i32 : ok
-ok ? i32 >= f64 : f32
-ok ? i64 : array
+ok ? i32 : score
+ok ? i64 : (ok ? list : half)
 ok ? i64 : div
 ok ? i64 : f32
-ok ? i64 : f64
+ok ? i64 : foo
+ok ? i64 : foo.String
 ok ? i64 : half
+ok ? i64 : i
 ok ? i64 : i32
 ok ? i64 : i64
+ok ? i64 : list
 ok ? i64 : ok
-ok ? int(1) : div
-ok ? list : -1
+ok ? i64 ^ f32 : foo
+ok ? list : 0.5 * f64
 ok ? list : add
 ok ? list : array
 ok ? list : div
+ok ? list : div(i64, 1)
 ok ? list : f32
-ok ? list : i32
+ok ? list : foo.String
+ok ? list : greet
+ok ? list : half
+ok ? list : i
+ok ? list : i - f32
 ok ? list : i64
 ok ? list : list
-ok ? list : nil in array
-ok ? list : ok
+ok ? list : list != array
+ok ? list : not ok
 ok ? list : score
-ok ? lower("foo") : f32
-ok ? map(array, #) : duration("foo")
-ok ? map(list, #) : score
-ok ? min(f32) : score
-ok ? min(i) : score
+ok ? map(list, #) : add
+ok ? nil : 0.5 <= f64
+ok ? nil : foo.Qux
 ok ? nil : foo?.Bar
-ok ? ok : -f32
-ok ? ok : 0.5 + i
+ok ? not false : i32
+ok ? ok : 0.5 ** i32
+ok ? ok : add
 ok ? ok : array
-ok ? ok : f64
+ok ? ok : div
+ok ? ok : f32
+ok ? ok : f64 ** int(f64)
 ok ? ok : foo
+ok ? ok : foo.String
 ok ? ok : greet
+ok ? ok : half
+ok ? ok : i32
 ok ? ok : i64
 ok ? ok : list
-ok ? ok : score
-ok ? score : add
-ok ? score : array
+ok ? ok : ok
+ok ? reduce(array, false) : score
+ok ? reduce(list, #) : list
+ok ? score : 1 == i32
+ok ? score : div
 ok ? score : f32
-ok ? score : foo.String
-ok ? score : foo?.String
+ok ? score : f64
 ok ? score : greet
 ok ? score : half
 ok ? score : i
 ok ? score : i32
-ok ? score : list
-ok ? score : nil != div
-ok ? score : ok
+ok ? score : min(i64)
 ok ? score : score
-ok ? string(half) : array
-ok ? toJSON("foo") : i32
-ok ? true : foo?.Qux
+ok ? score : true == nil
+ok ? toJSON(i64) : div
 ok and !ok
-ok and "bar" not endsWith foo?.Bar
-ok and "foo" endsWith "foo"
-ok and 0.5 <= f32
-ok and 0.5 > f64
-ok and 0.5 >= f64
-ok and 1 != 1
-ok and 1 != nil
+ok and "bar" < "foo"
+ok and ("foo" not contains "bar")
 ok and 1 < i64
 ok and 1 == 1
-ok and add == add
-ok and any(list, false)
+ok and 1 == i64
+ok and add == nil
+ok and f32 != 1
 ok and f32 >= 1
-ok and f64 != i
-ok and f64 != nil
-ok and f64 > 1
-ok and false != true
-ok and i > i32
-ok and i >= f64
-ok and i >= i64
-ok and i32 != nil
-ok and i32 == 0.5
-ok and i32 >= f64
-ok and i64 != nil
-ok and i64 <= i
+ok and greet == greet
+ok and i == 0.5
+ok and i32 < f32
+ok and i32 <= i64
+ok and i32 > i32
+ok and i64 < i32
+ok and i64 <= i64
 ok and i64 > 1
-ok and list == list
-ok and nil != i
-ok and nil != true
-ok and none(list, ok)
+ok and i64 >= i
+ok and i64 in array
+ok and list != nil
+ok and nil == array
+ok and nil == nil
+ok and nil in array
+ok and nil in list
+ok and nil not in array
 ok and not ok
 ok and not true
 ok and ok
-ok not in sort(array)
-ok or !false
+ok and ok && ok
+ok and true ? f64 : add
+ok and true ? greet : i
+ok in groupBy(array, "bar")
+ok in groupBy(list, #)
+ok in groupBy(list, i32)
+ok in {"bar": true}?.greet
+ok not in groupBy(array, # != i32)
+ok not in groupBy(array, 0.5)
+ok not in groupBy(array, f64)
+ok not in groupBy(list, #)?.f64
+ok not in groupBy(list, f64)?.Bar
 ok or !ok
 ok or !true
-ok or "bar" < "bar"
-ok or "foo" != nil
-ok or 0.5 != i32
-ok or 0.5 != i64
-ok or 0.5 <= 0.5
-ok or 0.5 == 1
-ok or 0.5 >= i
-ok or 1 != i32
-ok or 1 >= 0.5
-ok or f64 < f32
-ok or f64 < i64
-ok or fromJSON("bar")
-ok or greet != add
-ok or half == nil
-ok or half == score
-ok or i != 0.5
+ok or "bar" endsWith "foo"
+ok or 0.5 != f32
+ok or 0.5 != nil
+ok or 0.5 == i
+ok or 1 != f32
+ok or 1 <= 1
+ok or 1 <= i
+ok or div != nil
+ok or f32 != f32
+ok or f32 == 0.5
+ok or f32 == f32
+ok or f64 <= 1
+ok or false ? ok : 1
+ok or false and false
+ok or foo != foo
 ok or i < 1
-ok or i32 < 0.5
-ok or i32 == f64
-ok or i32 > 0.5
-ok or i64 != f32
-ok or i64 == 1
-ok or list == array
-ok or nil != 0.5
+ok or i == 0.5
+ok or i == f32
+ok or i32 < 1
+ok or i32 > f64
+ok or i64 != i32
+ok or i64 > i64
+ok or i64 >= 0.5
+ok or i64 not in array
+ok or nil != "foo"
+ok or nil != f64
+ok or nil != foo
+ok or nil != greet
+ok or nil != ok
+ok or nil == div
 ok or not false
 ok or not ok
-ok or not true
 ok or ok
-ok or ok || false
-ok or one(array, true)
-ok || "bar" not contains string(true)
-ok || 0.5 < i32
-ok || 0.5 <= 0.5
-ok || 0.5 == i64
-ok || 1 != 0.5
-ok || 1 != 1
+ok or ok == true
+ok or true || true
+ok or {"foo": false}.String
+ok || !ok
+ok || (nil not in list)
+ok || 0.5 < f32
+ok || 0.5 > 0.5
+ok || 0.5 > 1
+ok || 0.5 >= f64
 ok || 1 != nil
-ok || 1 < 0.5
-ok || 1 <= 1
-ok || add != score
-ok || all(array, ok)
-ok || div == nil
-ok || f32 <= 0.5
-ok || f32 <= 1
-ok || f32 > i64
-ok || f32 >= f64
-ok || false && ok
-ok || i != f64
-ok || i <= 0.5
-ok || i32 != 0.5
-ok || i32 < 0.5
-ok || i32 > 1
-ok || i64 > 0.5
+ok || 1 < i32
+ok || 1 == i
+ok || f32 >= 1
+ok || f64 < 1
+ok || f64 == i
+ok || f64 > f64
+ok || f64 >= i64
+ok || false ? half : i64
+ok || foo == foo
+ok || i == i
+ok || i32 < f32
+ok || i32 <= 0.5
+ok || i32 == i
+ok || i32 > 0.5
+ok || i32 >= i32
+ok || i64 != i32
+ok || i64 == 0.5
+ok || list == list
+ok || nil == 0.5
+ok || nil == array
+ok || nil == nil
+ok || nil not in array
+ok || not false
+ok || not ok
 ok || ok
-ok || score != score
-ok || toJSON(f64) > trimSuffix("bar")
-one([1], ok)
-one([i32], i32 >= #)
-one([score, greet], # == #)
-one([score], ok)
-one(array, "bar" matches "foo")
-one(array, "bar" not in foo)
-one(array, "foo" != "foo")
-one(array, "foo" > "foo")
+ok || ok ? f64 : i64
+ok || ok ? ok : score
+ok || ok or ok
+ok || reduce(array, false)
+ok || true ? add : ok
+one(1 .. i64, ok)
+one([div], nil == i32)
+one([false], i64 != i32)
+one(array, !(# <= 0.5))
+one(array, !false)
+one(array, !ok)
+one(array, !true)
+one(array, "bar" matches "bar")
 one(array, # != #)
 one(array, # != 0.5)
+one(array, # != 1)
+one(array, # != f32)
 one(array, # != f64)
+one(array, # != i)
 one(array, # != i32)
 one(array, # != nil)
-one(array, # % # <= #)
+one(array, # / i >= f64)
 one(array, # < #)
 one(array, # < 0.5)
 one(array, # < 1)
 one(array, # < f32)
-one(array, # < f64)
-one(array, # < i)
-one(array, # < i32)
+one(array, # < i64)
 one(array, # <= #)
+one(array, # <= 0.5)
+one(array, # <= 1)
 one(array, # <= f32)
 one(array, # <= f64)
-one(array, # <= i)
 one(array, # <= i32)
 one(array, # == #)
 one(array, # == 0.5)
 one(array, # == 1)
-one(array, # == f64)
-one(array, # == i)
-one(array, # == i32)
-one(array, # == i64)
+one(array, # == nil)
 one(array, # > #)
+one(array, # > f32)
 one(array, # > f64)
 one(array, # > i32)
-one(array, # > i64)
 one(array, # >= #)
 one(array, # >= 0.5)
 one(array, # >= 1)
-one(array, # >= f32)
-one(array, # >= i)
-one(array, # >= i32)
-one(array, # in array)
+one(array, # >= f64)
 one(array, 0.5 != #)
+one(array, 0.5 != i64)
 one(array, 0.5 < #)
+one(array, 0.5 < 0.5)
 one(array, 0.5 <= #)
 one(array, 0.5 == #)
+one(array, 0.5 == 0.5)
 one(array, 0.5 > #)
-one(array, 0.5 > f32)
+one(array, 0.5 > 1)
 one(array, 0.5 >= #)
 one(array, 1 != #)
-one(array, 1 < 0.5)
-one(array, 1 < i)
+one(array, 1 != i64)
+one(array, 1 != nil)
+one(array, 1 < #)
+one(array, 1 < f64)
 one(array, 1 <= #)
-one(array, 1 <= 0.5)
-one(array, 1 == #)
-one(array, 1 == i32)
-one(array, 1 > #)
+one(array, 1 > 0.5)
 one(array, 1 >= #)
-one(array, 1 >= f32)
-one(array, f32 < 1)
+one(array, add == div)
+one(array, all(array, true))
 one(array, f32 <= #)
-one(array, f32 <= i64)
-one(array, f32 == #)
-one(array, f32 == 0.5)
-one(array, f32 == 1)
+one(array, f32 <= 0.5)
 one(array, f32 >= #)
-one(array, f64 != #)
-one(array, f64 != 1)
-one(array, f64 != i)
-one(array, f64 != nil)
+one(array, f64 < #)
 one(array, f64 == #)
-one(array, f64 > #)
-one(array, false == nil)
-one(array, greet == score)
-one(array, i != 0.5)
-one(array, i < i32)
-one(array, i <= #)
-one(array, i == #)
+one(array, f64 >= #)
+one(array, f64 >= 1)
+one(array, f64 >= i32)
+one(array, f64 in array)
+one(array, false || true)
+one(array, i < #)
+one(array, i > 0.5)
 one(array, i > f64)
-one(array, i >= #)
-one(array, i >= f32)
 one(array, i32 != #)
+one(array, i32 < #)
 one(array, i32 <= #)
-one(array, i32 == #)
-one(array, i32 == i)
 one(array, i32 > #)
-one(array, i64 <= #)
+one(array, i32 >= #)
+one(array, i64 != #)
+one(array, i64 < #)
 one(array, i64 == #)
-one(array, i64 > #)
-one(array, i64 > 1)
+one(array, i64 == f32)
+one(array, i64 >= #)
+one(array, i64 >= f64)
+one(array, list != array)
 one(array, nil != #)
-one(array, nil != foo)
-one(array, nil == i64)
+one(array, nil != i64)
 one(array, not ok)
-one(array, not true)
-one(array, ok && true)
 one(array, ok)
-one(array, one(array, false))
-one(array, score != greet)
-one(array, score == div)
-one(array, true || ok)
-one(array, true || true)
-one(filter(list, true), ok)
-one(i32 .. i32, ok)
-one(i32 .. i64, # >= #)
+one(array, one(list, false))
+one(array, true != false)
+one(array, true == nil)
+one(array, true) ? greet : add
+one(array, true) or 1 != nil
+one(false ? greet : "bar", f64 != #)
+one(groupBy(array, f64).array, .i(nil).ok)
+one(groupBy(list, ok).foo, .add?.array)
+one(i32 .. 1, # == #)
+one(i32 .. i32, not ok)
+one(i64 .. 1, # >= 1)
+one(i64 .. i32, # != #)
+one(i64 .. i32, # >= #)
+one(list, !(i64 != 1))
+one(list, !false)
 one(list, !ok)
-one(list, !true)
-one(list, "bar" not in #)
-one(list, "foo" != "bar")
-one(list, "foo" < "foo")
+one(list, "foo" < "bar")
+one(list, "foo" not endsWith "bar")
 one(list, "foo" not in #)
+one(list, "foo" startsWith "bar")
 one(list, # != #)
-one(list, # != nil)
+one(list, # != foo)
 one(list, # == #)
-one(list, # == foo)
-one(list, # == nil)
 one(list, # in list)
-one(list, 0.5 != f32)
-one(list, 0.5 > 0.5)
-one(list, 1 < 1)
-one(list, any(array, true))
-one(list, any(list, ok))
+one(list, # not in list)
+one(list, 0.5 < 1)
+one(list, 0.5 <= 0.5)
+one(list, 0.5 == f64)
+one(list, 1 > i)
+one(list, add != nil)
+one(list, all(array, true))
 one(list, any(list, true))
-one(list, f32 == 0.5)
-one(list, f32 == f64)
-one(list, f32 > f32)
-one(list, f64 != nil)
-one(list, f64 == f32)
-one(list, f64 >= 0.5)
+one(list, div != nil)
+one(list, f32 == nil)
+one(list, f32 > i)
+one(list, f32 >= 1)
 one(list, f64 >= 1)
+one(list, false == nil)
+one(list, foo != #)
+one(list, foo != nil)
 one(list, foo == #)
-one(list, greet != nil)
-one(list, greet == score)
-one(list, half != add)
-one(list, i != nil)
-one(list, i == i64)
-one(list, i64 != f32)
-one(list, i64 < 1)
-one(list, i64 <= 0.5)
-one(list, i64 > 0.5)
-one(list, i64 > 1)
-one(list, list != nil)
-one(list, nil != nil)
-one(list, nil != score)
+one(list, greet == nil)
+one(list, half == nil)
+one(list, i <= i64)
+one(list, i > f64)
+one(list, i > i32)
+one(list, i32 != f32)
+one(list, i64 == 1)
+one(list, nil != #)
+one(list, nil != half)
 one(list, nil == #)
-one(list, none(array, ok))
-one(list, none(list, ok))
-one(list, not false)
-one(list, not ok)
-one(list, not true)
+one(list, nil == f64)
+one(list, ok or true)
 one(list, ok)
-one(list, ok) and ok
-one(list, one(list, ok))
-one(list, score == half)
-one(list, true) && ok ? i : i64
-one(map(array, "foo"), # matches #)
+one(list, ok) or 0.5 == nil
+one(list, score != nil)
+one(list, true == nil)
+one(list[i64:i32], i != i)
+one(map(array, "bar"), not false)
 one(map(array, #), # != #)
-one(map(array, #), # < #)
-one(map(array, #), # <= #)
-one(map(array, #), # > #)
-one(map(array, #), # > 1)
-one(map(array, #), f64 <= 0.5)
-one(map(array, #), ok)
-one(map(array, div), # == nil)
-one(map(array, i64), ok)
+one(map(array, #), # >= #)
+one(map(array, #), i32 == #)
+one(map(array, 1), ok)
+one(map(array, div), # == #)
+one(map(array, f64), # < 0.5)
+one(map(array, false), #)
+one(map(array, i), ok)
+one(map(array, list), ok)
 one(map(array, true), #)
-one(map(list, "bar"), ok)
-one(map(list, #), nil != #)
-one(map(list, 1), # < 0.5)
-one(map(list, f64), # <= #)
-one(map(list, false), #)
-one(map(list, i), ok)
-one(map(list, list), ok)
 one(map(list, ok), #)
-repeat(toJSON(nil), i)
+one(map(list, score), # != #)
+one(ok ? "foo" : false, # > #)
+one(reduce(array, array), ok)
+one(true ? array : 1, # <= #)
+reduce(1 .. 1, #)
+reduce(1 .. 1, f32 >= i)
+reduce(1 .. i64, array)
+reduce(1 .. i64, greet)
+reduce(1 .. i64, half)
+reduce(["foo"], f32)
+reduce([0.5], f64)
+reduce([div, "foo"], i32)
+reduce([f32, f64], f32)
+reduce([foo], ok)
+reduce([i32], list)
+reduce([i64, half], "bar" not startsWith "foo")
+reduce([i], # < #)
+reduce([i], ok)
+reduce([list], f64)
+reduce([nil], # in array)
+reduce(array, !false)
+reduce(array, "foo" endsWith "foo")
+reduce(array, "foo") not in foo
+reduce(array, # != #)
+reduce(array, # != 1)
+reduce(array, # != i32)
+reduce(array, # != nil)
+reduce(array, # % #)
+reduce(array, # % i64)
+reduce(array, # * #)
+reduce(array, # * 0.5)
+reduce(array, # * 1)
+reduce(array, # * f32)
+reduce(array, # * i)
+reduce(array, # * i32)
+reduce(array, # * i64)
+reduce(array, # ** #)
+reduce(array, # ** f32)
+reduce(array, # ** i32)
+reduce(array, # + #)
+reduce(array, # + 0.5)
+reduce(array, # + 1)
+reduce(array, # + i)
+reduce(array, # + i64)
+reduce(array, # - #)
+reduce(array, # - 0.5)
+reduce(array, # - 1)
+reduce(array, # - i)
+reduce(array, # - i32)
+reduce(array, # - i64)
+reduce(array, # .. #)
+reduce(array, # .. i32)
+reduce(array, # / #)
+reduce(array, # / 0.5)
+reduce(array, # / 1)
+reduce(array, # / f32)
+reduce(array, # / i32)
+reduce(array, # < #)
+reduce(array, # < 0.5)
+reduce(array, # < 1)
+reduce(array, # < i32)
+reduce(array, # <= #)
+reduce(array, # <= 0.5)
+reduce(array, # <= f32)
+reduce(array, # <= i32)
+reduce(array, # == #)
+reduce(array, # == 0.5)
+reduce(array, # == 1)
+reduce(array, # == f32)
+reduce(array, # == i32)
+reduce(array, # == i64)
+reduce(array, # == nil)
+reduce(array, # > #)
+reduce(array, # > 1)
+reduce(array, # > f64)
+reduce(array, # > i)
+reduce(array, # >= #)
+reduce(array, # >= f32)
+reduce(array, # >= f64)
+reduce(array, # >= i32)
+reduce(array, # >= i64)
+reduce(array, # ^ #)
+reduce(array, # ^ 0.5)
+reduce(array, # ^ f32)
+reduce(array, # ^ f64)
+reduce(array, # ^ i64)
+reduce(array, # in array)
+reduce(array, # not in array)
+reduce(array, #)
+reduce(array, #) != 0.5 == true
+reduce(array, #) != 0.5 ? ok : nil
+reduce(array, #) != f32
+reduce(array, #) != i32
+reduce(array, #) != i64
+reduce(array, #) % i
+reduce(array, #) % i32
+reduce(array, #) % i64
+reduce(array, #) * i
+reduce(array, #) * i32
+reduce(array, #) * len("foo")
+reduce(array, #) ** f64
+reduce(array, #) ** min(1, i32)
+reduce(array, #) + i
+reduce(array, #) + i64
+reduce(array, #) + reduce(array, #)
+reduce(array, #) - f64
+reduce(array, #) - i
+reduce(array, #) - max(f32)
+reduce(array, #) .. i
+reduce(array, #) .. i32
+reduce(array, #) .. i64
+reduce(array, #) / f32
+reduce(array, #) / f64
+reduce(array, #) / i32
+reduce(array, #) / i64
+reduce(array, #) < f32
+reduce(array, #) < f32 / 0.5
+reduce(array, #) < f64
+reduce(array, #) < i
+reduce(array, #) <= -1
+reduce(array, #) <= f32
+reduce(array, #) <= f64
+reduce(array, #) <= f64 * 0.5
+reduce(array, #) <= i
+reduce(array, #) == f64
+reduce(array, #) == i64
+reduce(array, #) > i32
+reduce(array, #) >= f32
+reduce(array, #) >= f64
+reduce(array, #) >= i32
+reduce(array, #) >= i64
+reduce(array, #) ^ f32 ** 0.5
+reduce(array, #) ^ i32
+reduce(array, #) not in array
+reduce(array, #) not in map(array, #)
+reduce(array, (0.5 + #) * f32)
+reduce(array, -#)
+reduce(array, -(# - #))
+reduce(array, -0.5)
+reduce(array, -1)
+reduce(array, -f32)
+reduce(array, -f64)
+reduce(array, -i)
+reduce(array, -i32)
+reduce(array, -i64)
+reduce(array, 0.5 != #)
+reduce(array, 0.5 != 0.5)
+reduce(array, 0.5 * #)
+reduce(array, 0.5 ** #)
+reduce(array, 0.5 ** 1)
+reduce(array, 0.5 + #)
+reduce(array, 0.5 - #)
+reduce(array, 0.5 - i64)
+reduce(array, 0.5 / #)
+reduce(array, 0.5 / f32)
+reduce(array, 0.5 < #)
+reduce(array, 0.5 < 1)
+reduce(array, 0.5 <= #)
+reduce(array, 0.5 <= 1)
+reduce(array, 0.5 == #)
+reduce(array, 0.5 == f64)
+reduce(array, 0.5 == i64)
+reduce(array, 0.5 > #)
+reduce(array, 0.5 > 0.5)
+reduce(array, 0.5 >= 0.5)
+reduce(array, 0.5 >= 1)
+reduce(array, 0.5 ^ #)
+reduce(array, 0.5 ^ 0.5)
+reduce(array, 0.5) * f32
+reduce(array, 0.5) - i
+reduce(array, 0.5) > i64 ? 1 : 0.5
+reduce(array, 1 != #)
+reduce(array, 1 * f64)
+reduce(array, 1 ** #)
+reduce(array, 1 + #)
+reduce(array, 1 - #)
+reduce(array, 1 - 1)
+reduce(array, 1 / i32)
+reduce(array, 1 < #)
+reduce(array, 1 >= #)
+reduce(array, 1 ^ #)
+reduce(array, 1 ^ 0.5)
+reduce(array, 1 ^ i32)
+reduce(array, 1) % i32
+reduce(array, 1) ** f32
+reduce(array, 1) + f64
+reduce(array, 1) / f64
+reduce(array, 1) / i32
+reduce(array, 1) <= i32
+reduce(array, 1) ^ i
+reduce(array, 1) not in array
+reduce(array, [#])
+reduce(array, abs(#))
+reduce(array, abs(f64))
+reduce(array, abs(i64))
+reduce(array, add(#, #))
+reduce(array, add)
+reduce(array, all(list, ok))
+reduce(array, array)
+reduce(array, array)[i32]
+reduce(array, array[#:#])
+reduce(array, array[i64:#])
+reduce(array, bitand(i32, i32))
+reduce(array, bitnot(#))
+reduce(array, bitor(#, #))
+reduce(array, bitshr(#, #))
+reduce(array, bitushr(#, #))
+reduce(array, ceil(#))
+reduce(array, div(#, #))
+reduce(array, div)
+reduce(array, f32 ** #)
+reduce(array, f32 + #)
+reduce(array, f32 / #)
+reduce(array, f32 <= #)
+reduce(array, f32 == #)
+reduce(array, f32 == i)
+reduce(array, f32 >= #)
+reduce(array, f32 >= 0.5)
+reduce(array, f32 ^ #)
+reduce(array, f32 ^ f32)
+reduce(array, f32 ^ i32)
+reduce(array, f32)
+reduce(array, f32) ** (0.5 * f64)
+reduce(array, f32) <= f32
+reduce(array, f32) not in array
+reduce(array, f64 ** #)
+reduce(array, f64 + #)
+reduce(array, f64 + i32)
+reduce(array, f64 - #)
+reduce(array, f64 / 1)
+reduce(array, f64 < #)
+reduce(array, f64 == #)
+reduce(array, f64 ^ 1)
+reduce(array, f64)
+reduce(array, f64) != i32
+reduce(array, f64) * i
+reduce(array, f64) / f64
+reduce(array, f64) <= f32
+reduce(array, f64) <= first(array)
+reduce(array, f64) == i
+reduce(array, f64) >= i
+reduce(array, f64) ^ f64
+reduce(array, false ? f64 : #)
+reduce(array, false ? score : #)
+reduce(array, false) ? i64 : f32
+reduce(array, false) || ok
+reduce(array, findLastIndex(list, false))
+reduce(array, findLastIndex(list, reduce(array, true)))
+reduce(array, float(#))
+reduce(array, floor(i64))
+reduce(array, foo)
+reduce(array, foo).Bar
+reduce(array, foo).Qux
+reduce(array, foo).String
+reduce(array, foo).String()
+reduce(array, foo)?.Bar
+reduce(array, foo)?.Qux
+reduce(array, foo)?.String
+reduce(array, foo)?.String()
+reduce(array, foo.Bar)
+reduce(array, foo.String)
+reduce(array, foo?.String())
+reduce(array, foo?.String)
+reduce(array, get(array, 1))
+reduce(array, get(list, #))
+reduce(array, greet("bar"))
+reduce(array, greet)
+reduce(array, groupBy(array, #))
+reduce(array, groupBy(list, #))
+reduce(array, groupBy(list, #)?.f32)
+reduce(array, half(1))
+reduce(array, half)
+reduce(array, i != #)
+reduce(array, i % #)
+reduce(array, i * #)
+reduce(array, i ** f64)
+reduce(array, i + 0.5)
+reduce(array, i - #)
+reduce(array, i / #)
+reduce(array, i <= #)
+reduce(array, i <= i64)
+reduce(array, i > i32)
+reduce(array, i ^ #)
+reduce(array, i)
+reduce(array, i) % i32
+reduce(array, i) + i32
+reduce(array, i) - f32
+reduce(array, i) == 0.5 ** 1
+reduce(array, i32 != #)
+reduce(array, i32 != i32)
+reduce(array, i32 + 0.5)
+reduce(array, i32 - #)
+reduce(array, i32 .. #)
+reduce(array, i32 < #)
+reduce(array, i32 < 1)
+reduce(array, i32 > #)
+reduce(array, i32 >= #)
+reduce(array, i32)
+reduce(array, i32) * 1 * 0.5
+reduce(array, i64 != #)
+reduce(array, i64 % i)
+reduce(array, i64 % i32)
+reduce(array, i64 * #)
+reduce(array, i64 + i32)
+reduce(array, i64 - #)
+reduce(array, i64 .. #)
+reduce(array, i64 .. 1)
+reduce(array, i64 / f64)
+reduce(array, i64 <= #)
+reduce(array, i64 == 1)
+reduce(array, i64 == nil)
+reduce(array, i64 ^ #)
+reduce(array, i64 ^ f64)
+reduce(array, i64)
+reduce(array, i64) + i
+reduce(array, i64) / f64
+reduce(array, i64) < i
+reduce(array, i64) == f32
+reduce(array, int(f64))
+reduce(array, len(array))
+reduce(array, list)
+reduce(array, list) != map(list, half)
+reduce(array, map(array, div))
+reduce(array, map(array, score))
+reduce(array, map(list, 1))
+reduce(array, max(#, #, #))
+reduce(array, max(0.5))
+reduce(array, min(#))
+reduce(array, min(#, #, 0.5))
+reduce(array, min(0.5))
+reduce(array, min(1, 1))
+reduce(array, nil != "bar")
+reduce(array, nil != #)
+reduce(array, nil != 1)
+reduce(array, not ok)
+reduce(array, ok ? "foo" : "bar")
+reduce(array, ok ? # : array)
+reduce(array, ok ? # : i)
+reduce(array, ok || true)
+reduce(array, ok)
+reduce(array, ok) and ok
+reduce(array, reduce(array, 1))
+reduce(array, reduce(list, 0.5))
+reduce(array, round(0.5))
+reduce(array, score(#))
+reduce(array, score(1, #))
+reduce(array, score)
+reduce(array, string(0.5))
+reduce(array, string(1))
+reduce(array, string(foo))
+reduce(array, string(i32))
+reduce(array, toJSON(i))
+reduce(array, trimPrefix("bar"))
+reduce(array, true && true)
+reduce(array, true ? add : #)
+reduce(array, true) != ok
+reduce(array, true) and ok
+reduce(array, type(#))
+reduce(array, type(1))
+reduce(array, type(add))
+reduce(array, type(greet))
+reduce(array, type(score))
+reduce(array, upper("bar"))
+reduce(false ? 0.5 : "bar", # and false)
+reduce(false ? i32 : array, toJSON(#))
+reduce(false ? nil : list, #)
+reduce(filter(array, ok), foo)
+reduce(filter(list, ok), foo.Bar)
+reduce(filter(list, true), i)
+reduce(i .. 1, f64)
+reduce(i .. 1, score)
+reduce(i .. i, #)
+reduce(i .. i, foo)
+reduce(i .. i32, add)
+reduce(i32 .. 1, #)
+reduce(i32 .. 1, foo)
+reduce(i32 .. i, 0.5 - #)
+reduce(i32 .. i32, i64)
+reduce(i32 .. i64, abs(f64))
+reduce(i64 .. 1, -#)
+reduce(i64 .. i, #)
+reduce(i64 .. i, -0.5)
+reduce(i64 .. i, false ? "bar" : #)
+reduce(i64 .. i, i)
+reduce(i64 .. i, ok)
+reduce(i64 .. i, round(i32))
+reduce(i64 .. i64, i64)
+reduce(list, !true)
+reduce(list, "bar" <= "bar")
+reduce(list, "bar" in #)
+reduce(list, "foo" not in #)
+reduce(list, # != #)
+reduce(list, # != foo)
+reduce(list, # != nil)
+reduce(list, # == #)
+reduce(list, # == foo)
+reduce(list, # == nil)
+reduce(list, # in list)
+reduce(list, # not in list)
+reduce(list, #)
+reduce(list, #) != foo
+reduce(list, #) not in groupBy(array, i)
+reduce(list, #) not in list
+reduce(list, #).Bar
+reduce(list, #).Qux
+reduce(list, #).String
+reduce(list, #).String()
+reduce(list, #)?.Bar
+reduce(list, #)?.Qux
+reduce(list, #)?.String
+reduce(list, #)?.String()
+reduce(list, #?.Bar not in # ? # : #)
+reduce(list, #?.Bar)
+reduce(list, #?.Qux("foo"))
+reduce(list, #?.Qux)
+reduce(list, #?.String())
+reduce(list, #?.String)
+reduce(list, -0.5)
+reduce(list, -f64)
+reduce(list, -i)
+reduce(list, -i32)
+reduce(list, .Bar)
+reduce(list, .Qux)
+reduce(list, .String())
+reduce(list, .String)
+reduce(list, 0.5 != f64)
+reduce(list, 0.5 != nil)
+reduce(list, 0.5 == i64)
+reduce(list, 0.5 >= 0.5)
+reduce(list, 0.5) != i
+reduce(list, 0.5) / i64
+reduce(list, 0.5) < f32
+reduce(list, 0.5) < i
+reduce(list, 0.5) < i32
+reduce(list, 0.5) < i64
+reduce(list, 0.5) <= f32
+reduce(list, 0.5) >= f64
+reduce(list, 0.5) >= i64
+reduce(list, 1 != nil)
+reduce(list, 1 + f64)
+reduce(list, 1 - 0.5)
+reduce(list, 1 / 0.5)
+reduce(list, 1 < f64)
+reduce(list, 1 <= 1)
+reduce(list, 1 == 0.5)
+reduce(list, 1 == nil)
+reduce(list, 1 ^ 1)
+reduce(list, 1) * f64
+reduce(list, 1) + f32
+reduce(list, 1) - i
+reduce(list, add)
+reduce(list, add) != div
+reduce(list, array != array)
+reduce(list, array)
+reduce(list, div)
+reduce(list, f32 / 0.5)
+reduce(list, f32 < i32)
+reduce(list, f32 <= f32)
+reduce(list, f32)
+reduce(list, f32) == f32
+reduce(list, f64 != nil)
+reduce(list, f64 + 0.5)
+reduce(list, f64 + 1)
+reduce(list, f64 / i32)
+reduce(list, f64 <= i32)
+reduce(list, f64 == f32)
+reduce(list, f64 > f32)
+reduce(list, f64 >= 0.5)
+reduce(list, f64)
+reduce(list, f64) * i64
+reduce(list, false == false)
+reduce(list, false ? "foo" : list)
+reduce(list, false ? # : #)
+reduce(list, false || true)
+reduce(list, filter(list, ok))
+reduce(list, findIndex(array, true))
+reduce(list, findLastIndex(list, false))
+reduce(list, float(i))
+reduce(list, floor(0.5))
+reduce(list, foo != #)
+reduce(list, foo)
+reduce(list, foo) == foo
+reduce(list, foo).Bar
+reduce(list, foo).Qux
+reduce(list, foo).String
+reduce(list, foo).String()
+reduce(list, foo)?.Bar
+reduce(list, foo)?.Qux
+reduce(list, foo)?.String
+reduce(list, foo)?.String()
+reduce(list, foo.Bar)
+reduce(list, foo.String)
+reduce(list, foo?.Bar)
+reduce(list, foo?.Qux)
+reduce(list, foo?.String)
+reduce(list, get(list, i))
+reduce(list, greet != nil)
+reduce(list, greet("bar"))
+reduce(list, greet)
+reduce(list, groupBy(array, 1))
+reduce(list, groupBy(list, "bar"))
+reduce(list, groupBy(list, #))
+reduce(list, half(1))
+reduce(list, half)
+reduce(list, i * i64)
+reduce(list, i + 1)
+reduce(list, i - f64)
+reduce(list, i .. 1)
+reduce(list, i == 0.5)
+reduce(list, i > i64)
+reduce(list, i >= 0.5)
+reduce(list, i)
+reduce(list, i) * i64
+reduce(list, i) .. 1 % 1
+reduce(list, i) .. i
+reduce(list, i) / f64
+reduce(list, i) / i32
+reduce(list, i) < f32
+reduce(list, i) == f32
+reduce(list, i) > f32
+reduce(list, i) ^ f32
+reduce(list, i32 != nil)
+reduce(list, i32 - i32)
+reduce(list, i32 .. 1)
+reduce(list, i32 / 0.5)
+reduce(list, i32 < i)
+reduce(list, i32 <= i)
+reduce(list, i32 == f64)
+reduce(list, i32 >= f32)
+reduce(list, i32)
+reduce(list, i32) != f64
+reduce(list, i32) % i
+reduce(list, i32) - f32
+reduce(list, i32) >= i
+reduce(list, i64 .. 1)
+reduce(list, i64 < i64)
+reduce(list, i64 > i64)
+reduce(list, i64 >= 0.5)
+reduce(list, i64)
+reduce(list, i64) * f64
+reduce(list, i64) ** i32
+reduce(list, i64) <= i64
+reduce(list, int(i64))
+reduce(list, len(array))
+reduce(list, list != nil)
+reduce(list, list == nil)
+reduce(list, list)
+reduce(list, map(array, "bar"))
+reduce(list, map(array, #))
+reduce(list, map(list, 1))
+reduce(list, max(0.5))
+reduce(list, max(f32))
+reduce(list, min(0.5))
+reduce(list, min(1))
+reduce(list, min(f32))
+reduce(list, nil != #)
+reduce(list, nil != add)
+reduce(list, nil != half)
+reduce(list, nil == #)
+reduce(list, not false)
+reduce(list, not ok)
+reduce(list, not true)
+reduce(list, ok ? # : #)
+reduce(list, ok ? # : score)
+reduce(list, ok ? greet : add)
+reduce(list, ok ? score : #)
+reduce(list, ok)
+reduce(list, reduce(array, ok))
+reduce(list, reduce(array, score))
+reduce(list, reduce(list, #))
+reduce(list, reduce(list, 1))
+reduce(list, reduce(list, add))
+reduce(list, reduce(list, i32))
+reduce(list, score(i))
+reduce(list, score)
+reduce(list, string(greet))
+reduce(list, toBase64("bar"))
+reduce(list, toBase64("foo"))
+reduce(list, toJSON(array))
+reduce(list, toJSON(list))
+reduce(list, toJSON(nil))
+reduce(list, true == nil)
+reduce(list, true ? foo : f64)
+reduce(list, type(#))
+reduce(map(array, "bar"), # not endsWith #)
+reduce(map(array, "bar"), add)
+reduce(map(array, "foo"), half(f64))
+reduce(map(array, #), # != i)
+reduce(map(array, #), # .. #)
+reduce(map(array, #), #)
+reduce(map(array, #), abs(#))
+reduce(map(array, #), i)
+reduce(map(array, #), i32 * #)
+reduce(map(array, #), not ok)
+reduce(map(array, 0.5), add)
+reduce(map(array, 0.5), div)
+reduce(map(array, 0.5), f32)
+reduce(map(array, 1), # ^ 0.5)
+reduce(map(array, 1), #)
+reduce(map(array, 1), foo)
+reduce(map(array, add), #)
+reduce(map(array, add), f32)
+reduce(map(array, add), list)
+reduce(map(array, array), f64)
+reduce(map(array, div), #)
+reduce(map(array, div), div)
+reduce(map(array, div), i32 * i)
+reduce(map(array, f32), f32)
+reduce(map(array, f32), i)
+reduce(map(array, f32), i32)
+reduce(map(array, f64), #)
+reduce(map(array, f64), f32 < #)
+reduce(map(array, false), # and true)
+reduce(map(array, false), f32)
+reduce(map(array, foo), # == nil)
+reduce(map(array, i), # / 1)
+reduce(map(array, i), #)
+reduce(map(array, i), add)
+reduce(map(array, i), f64 + 1)
+reduce(map(array, i32), array)
+reduce(map(array, i32), list)
+reduce(map(array, i64), # <= #)
+reduce(map(array, i64), #)
+reduce(map(array, list), filter(#, false))
+reduce(map(array, ok), i)
+reduce(map(array, score), i32)
+reduce(map(list, "bar"), #)
+reduce(map(list, "foo"), #)
+reduce(map(list, #), #)
+reduce(map(list, #), .Qux)
+reduce(map(list, #), add)
+reduce(map(list, #), array)
+reduce(map(list, #), f32)
+reduce(map(list, #), f64)
+reduce(map(list, #), half)
+reduce(map(list, #), i64)
+reduce(map(list, #), ok)
+reduce(map(list, 0.5), #)
+reduce(map(list, 0.5), foo)
+reduce(map(list, 1), # > #)
+reduce(map(list, 1), #)
+reduce(map(list, 1), list)
+reduce(map(list, array), div)
+reduce(map(list, div), add)
+reduce(map(list, f64), #)
+reduce(map(list, f64), ok)
+reduce(map(list, false), div)
+reduce(map(list, greet), #)
+reduce(map(list, i), #)
+reduce(map(list, i), [i32])
+reduce(map(list, i), f32)
+reduce(map(list, i), score(#))
+reduce(map(list, i32), #)
+reduce(map(list, i32), foo)
+reduce(map(list, i64), #)
+reduce(map(list, i64), i32)
+reduce(map(list, list), ok)
+reduce(map(list, score), #)
+reduce(map(list, score), f64)
+reduce(map(list, true), #)
+reduce(map(list, true), add)
+reduce(map(list, true), half)
+reduce(ok ? "bar" : i32, #)
+reduce(ok ? "foo" : list, #)
+reduce(ok ? array : half, f32)
+reduce(ok ? list : i, #)
+reduce(reduce(array, array), f64 != #)
+reduce(reduce(array, list), get(array, i32))
+reduce(reduce(list, array), f64)
+reduce(sort(array), #)
+reduce(sort(array), foo)
+reduce(sort(array), greet)
+reduce(sort(array), ok)
+reduce(true ? array : 1, array)
+reduce(true ? array : array, #)
+repeat(type(ok), i)
+round(-0.5)
+round(-1)
+round(-f32)
+round(-f64)
+round(-i)
+round(-i32)
+round(-i64)
+round(0.5 * 1)
+round(0.5 * f64)
+round(0.5 * i32)
+round(0.5 ** 0.5)
+round(0.5 ** 1)
+round(0.5 ** i)
+round(0.5 ** i32)
+round(0.5 ** i64)
+round(0.5 + 1)
+round(0.5 + f64)
+round(0.5 + i)
+round(0.5 + i32)
+round(0.5 - 0.5)
+round(0.5 - 1)
+round(0.5 - i32)
+round(0.5 / 0.5)
+round(0.5 / 1)
+round(0.5 / f64)
+round(0.5 / i32)
+round(0.5 ^ f64)
+round(0.5 ^ i)
+round(0.5 ^ i64)
+round(0.5) * f32
+round(0.5) ** i32
+round(0.5) + -f32
+round(0.5) - i64 ^ i
+round(0.5) < f64
+round(0.5) <= i64
+round(0.5) == i32
+round(0.5) == i64
+round(0.5) == max(i, i64)
+round(0.5) > -1
+round(0.5) > i
+round(0.5) >= i
+round(0.5) in array
+round(1 % i)
+round(1 % i64)
+round(1 * 0.5)
+round(1 * f32)
+round(1 * i64)
+round(1 ** 0.5)
+round(1 ** 1)
+round(1 ** f32)
+round(1 ** f64)
+round(1 ** i)
+round(1 + 0.5)
+round(1 + 1)
+round(1 + i64)
+round(1 - 0.5)
+round(1 - 1)
+round(1 - i)
+round(1 - i32)
+round(1 - i64)
+round(1 / 0.5)
+round(1 / 1)
+round(1 / f32)
+round(1 / i)
+round(1 / i64)
+round(1 ^ 0.5)
+round(1 ^ 1)
+round(1 ^ f32)
+round(1 ^ i)
+round(1 ^ i64)
+round(1) != ceil(i32)
+round(1) * i32
+round(1) + i64
+round(1) - i64
+round(1) / i32
+round(1) / i64
+round(1) < i64
+round(1) <= i
+round(1) == i
+round(1) >= f64
+round(1) >= i32
+round(1) >= i64
+round(1) ^ f64
+round(1) not in array
+round(abs(0.5))
+round(abs(1))
+round(abs(f64))
+round(abs(i))
+round(abs(i64))
+round(add(1, i))
+round(array[1])
+round(array[i32])
+round(array[i64])
+round(bitnot(i))
+round(bitnot(i32))
+round(bitnot(i64))
+round(ceil(1))
+round(ceil(f64))
+round(ceil(i32))
+round(ceil(i64))
+round(count(list, true))
+round(div(1, 1))
+round(f32 * 0.5)
+round(f32 * 1)
+round(f32 * f64)
+round(f32 * i32 ^ f32)
+round(f32 * i64)
+round(f32 ** 0.5)
+round(f32 ** 1)
+round(f32 + f64)
+round(f32 + i32)
+round(f32 - 0.5)
+round(f32 - i)
+round(f32 / i32)
+round(f32 ^ 0.5)
+round(f32 ^ f32)
+round(f32 ^ i)
+round(f32 ^ i64)
+round(f32)
+round(f32) * i32
+round(f32) - i32
+round(f32) / f32
+round(f32) == i32
+round(f64 * 0.5)
+round(f64 * i)
+round(f64 ** 0.5)
+round(f64 ** 1)
+round(f64 ** f32)
+round(f64 ** i)
+round(f64 + f64)
+round(f64 + i)
+round(f64 + i32)
+round(f64 - 0.5)
+round(f64 - 1)
+round(f64 - i32)
+round(f64 / f64)
+round(f64 / i)
+round(f64 / i32)
+round(f64 / i64)
+round(f64 ^ 1)
+round(f64 ^ f64)
+round(f64)
+round(f64) * f32
+round(f64) ** i32
+round(f64) + f64
+round(f64) <= f64
+round(f64) > i
+round(f64) > i32
+round(f64) >= i64
+round(f64) not in array
+round(false ? f32 : f64)
+round(false ? f64 : 1)
+round(false ? nil : 1)
+round(findIndex(array, # <= #))
+round(findIndex(list, ok))
+round(findLast(array, ok))
+round(findLast(array, true))
+round(findLastIndex(array, ok))
+round(findLastIndex(list, ok))
+round(float(0.5))
+round(float(1))
+round(float(f32))
+round(float(i))
+round(floor(0.5))
+round(floor(1))
+round(floor(f64))
+round(floor(i32))
+round(floor(i64))
+round(get(array, i))
+round(get(array, i32))
+round(get(array, i64))
+round(half(-1))
+round(half(0.5))
+round(half(1))
+round(half(f64))
+round(i % i32)
+round(i % i64)
+round(i * 1)
+round(i * f64)
+round(i * i32)
+round(i ** 1)
+round(i ** i64)
+round(i + 0.5)
+round(i + 1)
+round(i + f64)
+round(i + i)
+round(i + i32)
+round(i + i64)
+round(i - i)
+round(i - i32)
+round(i / 1)
+round(i / i)
+round(i / i64)
+round(i ^ 0.5) > f32
+round(i ^ 1)
+round(i ^ f32)
+round(i)
+round(i) * f32
+round(i) * i
+round(i) / f64
+round(i) < i
+round(i) < i32
+round(i) > i
+round(i) > i64 != ok
+round(i) >= f32
+round(i) >= i64
+round(i) ^ i32
+round(i32 % 1)
+round(i32 * 1)
+round(i32 ** 1)
+round(i32 ** f32)
+round(i32 ** f64)
+round(i32 + 0.5)
+round(i32 + 1)
+round(i32 + i32)
+round(i32 - 1)
+round(i32 - f32)
+round(i32 - f64)
+round(i32 / 0.5)
+round(i32 / 1)
+round(i32 ^ f64)
+round(i32)
+round(i32) != i
+round(i32) * f32
+round(i32) ** f64
+round(i32) - i
+round(i32) < i32
+round(i32) <= ceil(1)
+round(i32) <= f64
+round(i32) <= i64
+round(i32) >= f64
+round(i32) >= i32
+round(i32) ^ f64
+round(i64 % i)
+round(i64 % i32)
+round(i64 * 0.5)
+round(i64 * i)
+round(i64 ** 1)
+round(i64 ** f64)
+round(i64 ** i64)
+round(i64 + f32)
+round(i64 - 0.5)
+round(i64 - 1)
+round(i64 - i)
+round(i64 / 0.5)
+round(i64 / 1)
+round(i64 ^ 1)
+round(i64 ^ i32)
+round(i64 ^ i64)
+round(i64)
+round(i64) != f64
+round(i64) * i64
+round(i64) ** i32
+round(i64) - bitnot(1)
+round(i64) - f32
+round(i64) < f64
+round(i64) ^ f64
+round(int(0.5))
+round(int(1))
+round(int(f32))
+round(int(f64))
+round(int(i))
+round(int(i32))
+round(int(i64))
+round(last(array))
+round(len("bar"))
+round(len("foo"))
+round(len(array))
+round(len(list))
+round(max(0.5))
+round(max(1))
+round(max(i))
+round(max(i32))
+round(max(i64))
+round(max(i64, f32))
+round(mean(array))
+round(median(array))
+round(min(0.5))
+round(min(1))
+round(min(f32))
+round(min(f64))
+round(min(i32))
+round(min(i64))
+round(reduce(array, #))
+round(reduce(array, 0.5))
+round(reduce(array, 1))
+round(reduce(array, i64))
+round(reduce(list, 0.5))
+round(reduce(list, f32))
+round(round(0.5))
+round(round(1))
+round(round(f32))
+round(round(f64))
+round(round(i))
+round(round(i32))
+round(round(i64))
+round(score(1))
+round(score(i))
+round(sum(array))
+round(true ? i : ok)
 score
-score != add
-score != add != true
-score != add ? i64 : "foo"
-score != div
-score != div ? i : f32
-score != div and ok
-score != foo.Qux
-score != foo.String
-score != foo?.Qux
-score != foo?.String
-score != greet
-score != greet ? score : array
-score != half
+score != nil != ok
+score != nil ? half : f64
+score != nil or i32 > 0.5
+score != nil || ok
 score != score
-score != score ? 1 : i
-score == add
-score == add == false
-score == add ? f64 : not false
-score == div
-score == div || foo == foo
-score == foo.Qux
-score == foo.String
-score == foo?.Qux
-score == foo?.String
-score == greet
-score == greet ? half : f64
-score == greet and ok
-score == half
+score != score != ok
+score != score ? i32 : i32
+score == nil != nil
+score == nil && ok
+score == nil ? 0.5 : "bar"
 score == score
-score == score ? 0.5 : foo
-score == score ? nil : i32
-score == score or ok
-score == {"bar": 0.5}.f32
+score == score == true
+score == score ? 0.5 : score
+score in groupBy(list, #)?.array
+score in sort(array)
 score(-1)
+score(-1, i)
+score(-get(array, i))
 score(-i)
 score(-i, i)
 score(1 % 1)
@@ -12520,7 +16041,6 @@ score(1 % i)
 score(1 % i32)
 score(1 % i64)
 score(1 * 1)
-score(1 * 1, i)
 score(1 * i)
 score(1 * i32)
 score(1 * i64)
@@ -12531,73 +16051,81 @@ score(1 + i64)
 score(1 - 1)
 score(1 - i)
 score(1 - i32)
-score(1 - i64)
-score(1) != -0.5
-score(1) != f32
-score(1) != float(f64)
+score(1) != -f32
 score(1) != i
-score(1) % i32
+score(1) != i32
+score(1) % -1
+score(1) % i
+score(1) % i64
 score(1) * f32
-score(1) * f64
+score(1) * i
 score(1) * i64
-score(1) ** -1
-score(1) ** f32
-score(1) ** i64
-score(1) + f32
+score(1) ** i32
 score(1) + f64
+score(1) + i32
 score(1) - f32
 score(1) - i
+score(1) - i32
+score(1) - int(0.5)
+score(1) .. i
+score(1) .. i32
 score(1) .. i64
-score(1) / f64
-score(1) / i
+score(1) .. score(1)
+score(1) / f32
 score(1) / i32
-score(1) / i64
+score(1) < i
 score(1) < i32
 score(1) < i64
-score(1) <= i32
+score(1) < i64 - 0.5
+score(1) <= 0.5 * 1
+score(1) <= i
 score(1) <= i64
-score(1) == 1 ^ 1
-score(1) == f64
-score(1) == i ** f64
 score(1) == i32
 score(1) == i64
+score(1) > bitshr(i64, 1)
+score(1) > f32
 score(1) > i64
+score(1) >= 0.5 + f64
 score(1) >= f32
-score(1) >= f64
 score(1) >= i
-score(1) >= i32
-score(1) >= i64
-score(1) ^ f32
+score(1) >= sum(array)
 score(1) ^ f64
 score(1) ^ i
+score(1) ^ i32
 score(1) in array
-score(1, i) > f32
+score(1) not in groupBy(list, false)
+score(1, 1) < i
+score(1, i) < f64
+score(1, i) ^ f32
 score(abs(1))
 score(abs(i))
-score(add(1, 1))
 score(add(1, i))
 score(array[1])
-score(array[i32])
 score(array[i64])
 score(array[i])
-score(count(array, f64 < 1))
+score(bitnand(1, i64))
+score(bitnand(i64, i32))
+score(bitnot(1))
+score(bitnot(i))
+score(bitnot(i32))
+score(bitnot(i64))
+score(bitshl(i32, i))
+score(bitshr(1, i64))
+score(bitshr(i32, i64))
+score(bitushr(1, i))
 score(count(array, false))
 score(count(array, ok))
 score(count(array, true))
-score(count(list, false))
 score(count(list, ok))
-score(count(list, true))
-score(div(1, 1))
-score(div(i, 1))
-score(false ? true : i)
+score(false ? f64 : 1)
+score(false ? foo : 1)
+score(find(array, i != #))
 score(find(array, ok))
+score(find(array, true))
 score(findIndex(array, ok))
 score(findIndex(array, true))
-score(findIndex(list, ok))
 score(findIndex(list, true))
-score(findLast(array, 0.5 != #))
-score(findLast(array, ok))
-score(findLastIndex(array, ok))
+score(findLast(array, true))
 score(findLastIndex(array, true))
 score(findLastIndex(list, ok))
 score(findLastIndex(list, true))
@@ -12606,76 +16134,95 @@ score(get(array, 1))
 score(get(array, i))
 score(get(array, i32))
 score(get(array, i64))
+score(i % 1)
 score(i % i)
-score(i % i32)
+score(i % i64)
+score(i * 1 * i)
 score(i * 1)
+score(i * i)
 score(i * i32)
 score(i * i64)
 score(i + 1)
 score(i + i)
 score(i + i32)
-score(i + i64)
 score(i - 1)
 score(i - i)
 score(i - i32)
-score(i - i64)
 score(i)
-score(i) != 1 == true
-score(i) != float(i32)
-score(i) != i
-score(i) != i32
-score(i) % i32 % i64
-score(i) % i64
-score(i) * f64
+score(i) != f32
+score(i) != f64
+score(i) % i
+score(i) % i * f64
+score(i) * f32
 score(i) * i32
-score(i) * i64
-score(i) ** f64
+score(i) ** (0.5 / 0.5)
+score(i) ** -0.5
 score(i) ** i32
-score(i) + f32
-score(i) + i
-score(i) + i32
-score(i) + i64
-score(i) - f32
-score(i) - i
+score(i) ** i64
+score(i) + f64
+score(i) - f64
 score(i) - i32
-score(i) / f32
-score(i) / i
+score(i) / i64
+score(i) < 1 != ok
 score(i) < f32
+score(i) < f64 / 0.5
 score(i) < i32
-score(i) <= f32 - f32
+score(i) < i64
+score(i) <= 0.5 / f32
+score(i) <= f32
+score(i) <= f64
+score(i) <= i
+score(i) <= i32
 score(i) == f32
-score(i) == i32
-score(i) == i64
+score(i) > f32
+score(i) > i
+score(i) > i64
 score(i) >= f32
-score(i) ^ f64
-score(i) ^ i
-score(i, i + i)
+score(i) >= f64
+score(i) >= i
+score(i) >= i32
+score(i) >= i64
+score(i) ^ f32
+score(i) ^ i32
+score(i) ^ i64
+score(i) ^ score(1)
+score(i, 1) + -1
+score(i, 1) .. i64
+score(i, 1) <= f32
 score(i, i)
-score(i, i) >= i
-score(i, int(i64))
-score(i, score(i)) - i32
+score(i, i) ** f32
+score(i32 % 1)
 score(i32 % i)
-score(i32 % i64)
+score(i32 % i32)
 score(i32 * 1)
 score(i32 * i)
+score(i32 * i32)
+score(i32 * i64)
+score(i32 + 1)
 score(i32 + i)
+score(i32 + i32)
 score(i32 + i64)
 score(i32 - 1)
 score(i32 - i)
+score(i32 - i32)
+score(i32 - i64)
 score(i64 % 1)
 score(i64 % i)
+score(i64 % i32)
+score(i64 % i64)
 score(i64 * 1)
-score(i64 * i)
 score(i64 * i32)
+score(i64 * i64)
 score(i64 + 1)
+score(i64 + i)
+score(i64 + i32)
 score(i64 - 1)
-score(i64 - i)
-score(i64 - i32)
+score(i64 - i64)
 score(int(0.5))
 score(int(1))
-score(int(f32 * i))
 score(int(f32))
 score(int(f64))
+score(int(float(0.5)))
 score(int(i))
 score(int(i32))
 score(int(i64))
@@ -12683,72 +16230,74 @@ score(last(array))
 score(len("bar"))
 score(len("foo"))
 score(len(array))
-score(len(i32 .. i64))
 score(len(list))
 score(max(1))
-score(max(1, 1))
+score(max(1, i32, 0.5))
 score(max(i))
-score(max(i, 1))
+score(max(i, i32))
 score(min(1))
-score(min(1, i64))
 score(min(i))
+score(min(i, i32))
+score(ok ? 1 : "bar")
+score(ok ? 1 : list)
+score(reduce(array, #))
+score(reduce(array, i))
+score(reduce(list, 1))
+score(reduce(list, i))
 score(score(1))
-score(score(1, 1))
 score(score(i))
-score(score(i32 % 1))
-score(true ? 1 : true)
-score(true ? i : i64)
+score(score(i32 + i))
+score(sum(array))
 sort(1 .. 1)
-sort(1 .. i64)
-sort([0.5])
-sort([1])
-sort([i32])
+sort(1 .. i)
+sort([add])
+sort([greet])
+sort([half])
 sort([i64])
-sort([nil])
+sort([list])
 sort(array)
-sort(array) != list
-sort(false ? i64 : array)
-sort(filter(array, false))
-sort(filter(array, true))
-sort(filter(list, false))
-sort(i .. 1)
+sort(array) == array
+sort(false ? greet : array)
+sort(groupBy(list, #)?.foo)
+sort(groupBy(list, i32).half)
+sort(i .. i32)
 sort(i .. i64)
 sort(i32 .. 1)
-sort(i32 .. i32)
+sort(i64 .. 1)
 sort(map(array, "bar"))
 sort(map(array, "foo"))
 sort(map(array, #))
 sort(map(array, 1))
-sort(map(array, i32))
-sort(map(list, "foo")) != list
-sort(map(list, i))
-sort(sort(array))
-string(!(i <= f32))
+sort(map(array, f64))
+sort(map(array, i))
+sort(map(array, i64))
+sort(reduce(array, array))
+sortBy(array, string(true))
+string(!!false)
 string(!false)
 string(!ok)
 string(!true)
-string("bar" != "bar")
-string("bar" < "bar")
+string("bar" != nil)
+string("bar" <= "bar")
 string("bar" == "bar")
-string("bar" > "bar")
-string("bar" contains "foo")
-string("bar" endsWith "bar")
+string("bar" > "foo")
+string("bar" >= "bar")
 string("bar" not endsWith "bar")
-string("bar" not matches "foo")
+string("bar" not matches "bar")
 string("bar" not startsWith "foo")
-string("bar" startsWith "bar")
-string("bar") >= type(score)
-string("bar") endsWith "foo" + "foo"
-string("bar") in foo
+string("bar" startsWith "foo")
+string("bar") > type(i64)
+string("bar") >= toJSON("bar")
 string("foo" != nil)
-string("foo" <= "foo")
-string("foo" >= "bar")
-string("foo" matches "foo")
-string("foo" not endsWith "foo")
+string("foo" == "foo")
+string("foo" == nil)
+string("foo" > "bar")
+string("foo" in foo)
+string("foo" matches "bar")
+string("foo" not contains "bar")
+string("foo" not contains "foo")
 string("foo" not in foo)
-string("foo" not matches "foo")
-string("foo" startsWith "bar")
-string(-(0.5 + f64))
+string(--i)
 string(-0.5)
 string(-1)
 string(-f32)
@@ -12757,292 +16306,245 @@ string(-i)
 string(-i32)
 string(-i64)
 string(0.5 != 0.5)
-string(0.5 != 1)
-string(0.5 != f32)
 string(0.5 != f64)
 string(0.5 != i)
-string(0.5 != nil)
+string(0.5 != i32)
 string(0.5 * 0.5)
-string(0.5 * f32)
 string(0.5 * i)
 string(0.5 * i32)
-string(0.5 ** 0.5)
-string(0.5 ** 1)
+string(0.5 ** f32)
 string(0.5 ** i32)
-string(0.5 ** i64)
-string(0.5 + 0.5)
-string(0.5 + 1)
-string(0.5 + f32)
 string(0.5 + f64)
+string(0.5 + i)
 string(0.5 + i64)
-string(0.5 - 0.5)
-string(0.5 - 1)
+string(0.5 - f32)
+string(0.5 - f64)
 string(0.5 / 0.5)
-string(0.5 / f64)
+string(0.5 / 1)
+string(0.5 / f32)
 string(0.5 / i)
+string(0.5 < 0.5)
 string(0.5 < 1)
-string(0.5 < f32)
-string(0.5 < i)
-string(0.5 < i32)
+string(0.5 < i64)
+string(0.5 <= 0.5)
 string(0.5 <= f64)
 string(0.5 <= i)
-string(0.5 <= i64)
+string(0.5 <= i32)
 string(0.5 == 0.5)
 string(0.5 == 1)
-string(0.5 == f32)
-string(0.5 == f64)
-string(0.5 == i)
-string(0.5 == i32)
 string(0.5 == i64)
 string(0.5 == nil)
 string(0.5 > 0.5)
 string(0.5 > 1)
+string(0.5 > i)
 string(0.5 > i64)
 string(0.5 >= 0.5)
 string(0.5 >= 1)
 string(0.5 >= f32)
-string(0.5 >= f64)
-string(0.5 >= i)
 string(0.5 >= i32)
-string(0.5 ^ 0.5)
-string(0.5 ^ 1)
+string(0.5 >= i64)
 string(0.5 ^ f32)
 string(0.5 ^ i)
 string(0.5 ^ i32)
-string(0.5) not endsWith type(1)
+string(0.5 ^ i64)
+string(0.5 in array)
+string(0.5 not in array)
+string(1 != 0.5)
 string(1 != 1)
-string(1 != f32)
-string(1 != f64)
 string(1 != i)
-string(1 != i32)
+string(1 != i64)
 string(1 != nil)
 string(1 % 1)
 string(1 % i)
 string(1 % i32)
-string(1 % i64)
-string(1 * 1)
-string(1 * i)
-string(1 * i64)
+string(1 * 0.5)
+string(1 * f32)
+string(1 * f64)
 string(1 ** 0.5)
 string(1 ** 1)
-string(1 ** f64)
 string(1 ** i)
-string(1 ** i32)
+string(1 ** i64)
 string(1 + 0.5)
-string(1 + f32)
+string(1 + 1)
 string(1 + f64)
-string(1 + i64)
+string(1 - 0.5)
 string(1 - f32)
-string(1 - i)
+string(1 - i32)
 string(1 - i64)
 string(1 .. 1)
-string(1 .. i)
 string(1 .. i32)
+string(1 .. i64)
 string(1 / 0.5)
-string(1 / 1)
-string(1 / f32)
+string(1 / f64)
 string(1 / i)
-string(1 < i)
-string(1 < i32)
-string(1 < i64)
-string(1 <= 0.5)
+string(1 / i32)
+string(1 / i64)
+string(1 < 0.5)
 string(1 <= 1)
 string(1 <= f32)
-string(1 <= f64)
+string(1 <= i)
 string(1 <= i32)
-string(1 == 0.5)
+string(1 <= i64)
 string(1 == 1)
-string(1 == f64)
-string(1 == i)
-string(1 == i64)
-string(1 == nil)
+string(1 == f32)
+string(1 == i32)
+string(1 > 0.5)
 string(1 > 1)
-string(1 > f32)
-string(1 >= 0.5)
-string(1 >= 1)
+string(1 > i64)
 string(1 >= f32)
-string(1 >= f64)
 string(1 >= i)
-string(1 >= i32)
-string(1 >= i64)
+string(1 ^ 0.5)
 string(1 ^ 1)
 string(1 ^ f32)
 string(1 ^ f64)
-string(1 ^ i)
-string(1 ^ i32)
 string(1 ^ i64)
-string(1 in array)
 string(1 not in array)
-string(1)[i64:i64]
-string([0.5, f32])
-string([add])
-string([f32])
-string([greet])
-string([i32, half])
-string([i32])
-string([i])
-string([ok])
+string([0.5])
+string([div])
+string([f64])
+string([list])
 string([score])
+string([true])
 string(abs(0.5))
 string(abs(1))
 string(abs(f32))
-string(abs(f64))
-string(abs(half(0.5)))
 string(abs(i))
-string(abs(i64))
+string(abs(i32))
 string(add != add)
-string(add != half)
-string(add != nil)
-string(add != score)
-string(add == greet)
+string(add != div)
+string(add == div)
+string(add == nil)
 string(add)
-string(add) contains type(list)
-string(add) not in foo
-string(all(array, false))
+string(add) in foo ? i64 : i32
+string(add) not endsWith foo.Bar
+string(all(array, ok))
 string(all(array, true))
-string(any(array, false))
-string(any(list, true))
+string(any(array, ok))
+string(any(list, false))
+string(any(list, ok))
 string(array != array)
-string(array == nil)
+string(array != nil)
 string(array)
-string(array) not in foo
-string(array[1:i])
-string(array[1])
-string(array[i64])
-string(count(array, # <= #))
-string(count(array, ok))
-string(div != greet)
+string(array[i32])
+string(bitnot(1))
+string(bitnot(i32))
+string(bitnot(i64))
+string(ceil(0.5))
+string(ceil(1))
+string(ceil(f32))
+string(ceil(f64))
+string(ceil(i))
+string(ceil(i64))
+string(div != div)
 string(div != nil)
-string(div == nil)
-string(div == score)
+string(div == add)
+string(div == div)
 string(div)
 string(f32 != 0.5)
-string(f32 != 1)
-string(f32 != f32)
 string(f32 != f64)
+string(f32 != i)
 string(f32 != nil)
 string(f32 * 0.5)
+string(f32 * 1)
 string(f32 * f64)
 string(f32 * i)
 string(f32 * i32)
 string(f32 ** 1)
-string(f32 ** i64)
-string(f32 + 1)
+string(f32 ** f64)
 string(f32 + f32)
-string(f32 - i)
-string(f32 / 1)
-string(f32 / i)
+string(f32 + f64)
+string(f32 + i32)
+string(f32 + i64)
+string(f32 - 0.5)
+string(f32 - 1)
+string(f32 - i64)
+string(f32 / 0.5)
+string(f32 / f64)
 string(f32 / i64)
-string(f32 < 0.5)
-string(f32 < f64)
-string(f32 < i32)
-string(f32 <= 0.5)
-string(f32 <= 1)
-string(f32 <= f32)
+string(f32 < f32)
 string(f32 <= i)
 string(f32 <= i32)
 string(f32 == 0.5)
-string(f32 == 1)
-string(f32 == i64)
-string(f32 == nil)
-string(f32 > 1)
-string(f32 > f32)
+string(f32 == i)
+string(f32 > 0.5)
 string(f32 > f64)
-string(f32 > i)
-string(f32 > i32)
-string(f32 >= 0.5)
-string(f32 >= f32)
-string(f32 >= f64)
-string(f32 >= i32)
-string(f32 ^ 1)
-string(f32 ^ f32)
-string(f32 ^ f64)
-string(f32 ^ i)
-string(f32 ^ i64)
 string(f32)
-string(f32) matches trim("bar")
+string(f32) in foo
 string(f64 != 1)
-string(f64 != f32)
+string(f64 != i)
+string(f64 != nil)
 string(f64 * 0.5)
-string(f64 * 1)
-string(f64 * f32)
-string(f64 * f64)
 string(f64 * i)
+string(f64 * i32)
+string(f64 * i64)
 string(f64 ** 0.5)
-string(f64 ** 1)
 string(f64 ** f64)
-string(f64 ** i32)
+string(f64 ** i)
 string(f64 + 0.5)
 string(f64 + 1)
 string(f64 + f32)
-string(f64 + i)
-string(f64 + i32)
-string(f64 + i64)
 string(f64 - 0.5)
-string(f64 - f64)
-string(f64 - i32)
+string(f64 - 1)
+string(f64 - i)
 string(f64 / 0.5)
-string(f64 / f64)
-string(f64 / i64)
-string(f64 < 1)
-string(f64 < f64)
-string(f64 < i32)
+string(f64 < f32)
+string(f64 < i)
+string(f64 <= 1)
+string(f64 <= f32)
 string(f64 <= f64)
-string(f64 <= i)
-string(f64 == 0.5)
 string(f64 == 1)
 string(f64 == f32)
-string(f64 == f64)
 string(f64 == i)
-string(f64 == i32)
 string(f64 == i64)
-string(f64 > 0.5)
 string(f64 > 1)
-string(f64 > f32)
-string(f64 > f64)
-string(f64 > i64)
-string(f64 >= 1)
 string(f64 >= f32)
 string(f64 >= i)
-string(f64 >= i64)
 string(f64 ^ 0.5)
+string(f64 ^ f32)
 string(f64 ^ i)
-string(f64 ^ i32)
-string(f64 ^ i64)
+string(f64 in array)
+string(f64 not in array)
 string(f64)
-string(false && false)
-string(false ? 0.5 : i32)
-string(false ? 1 : "bar")
-string(false ? 1 : f32)
-string(false ? 1 : score)
-string(false ? div : "foo")
-string(false ? f32 : foo)
-string(false and true)
-string(false) <= foo.Bar
-string(false) > string(add)
-string(filter(list, ok))
+string(false != nil)
+string(false != ok)
+string(false != true)
+string(false ? array : 0.5)
+string(false ? f64 : i32)
+string(false ? false : i)
+string(false ? greet : f64)
+string(false ? half : "bar")
+string(false ? half : i)
+string(false ? i : i)
+string(false ? nil : nil)
+string(false and ok)
+string(false) endsWith toBase64("foo")
+string(filter(array, false))
+string(filter(array, ok))
+string(filter(array, true))
+string(filter(list, false))
 string(find(array, ok))
+string(find(array, true))
+string(find(list, ok))
 string(findIndex(array, true))
-string(findIndex(list, ok))
-string(findLast(array, # >= #))
 string(findLast(array, false))
 string(findLast(array, ok))
-string(findLast(list, ok))
-string(findLastIndex(array, not false))
+string(findLast(array, true))
 string(findLastIndex(array, ok))
-string(findLastIndex(array, true))
-string(findLastIndex(list, false))
-string(findLastIndex(list, ok))
-string(findLastIndex(list, true))
 string(first(array))
 string(first(list))
 string(float(0.5))
 string(float(1))
-string(float(f32))
 string(float(f64))
 string(float(i))
 string(float(i64))
-string(foo != nil)
+string(floor(0.5))
+string(floor(f32))
+string(floor(f64))
+string(floor(i))
+string(floor(i32))
+string(floor(i64))
+string(foo == foo)
+string(foo == nil)
 string(foo not in list)
 string(foo)
 string(foo.Bar)
@@ -13053,367 +16555,330 @@ string(foo?.Bar)
 string(foo?.Qux)
 string(foo?.String())
 string(foo?.String)
-string(get(array, 1))
 string(get(array, i))
-string(get(list, i))
+string(get(array, i64))
+string(get(list, 1))
+string(get(list, i32))
 string(get(list, i64))
-string(greet != add)
-string(greet != greet)
 string(greet != nil)
-string(greet != score)
-string(greet == add)
 string(greet == greet)
-string(greet == half)
 string(greet == nil)
-string(greet == score)
 string(greet("bar"))
 string(greet("foo"))
 string(greet)
-string(greet)[i64:i]
-string(half != add)
-string(half != div)
-string(half != half)
-string(half == greet)
+string(greet) == nil ? 0.5 : i
+string(groupBy(array, #))
+string(groupBy(array, 1))
+string(groupBy(array, f32))
+string(groupBy(array, false))
+string(groupBy(array, i32))
+string(groupBy(list, #))
+string(groupBy(list, 0.5))
+string(groupBy(list, 1))
+string(groupBy(list, f64))
+string(groupBy(list, false))
+string(groupBy(list, i))
+string(half != nil)
 string(half == nil)
-string(half == score)
-string(half(-1))
 string(half(0.5))
+string(half(1))
 string(half(f64))
 string(half)
-string(half) > toJSON(nil)
-string(half) not endsWith type("foo")
-string(i != 0.5)
-string(i != f32)
-string(i != f64)
+string(i != 1)
+string(i != i64)
 string(i % 1)
 string(i % i32)
-string(i * i32)
-string(i * i64)
-string(i ** 1)
+string(i % i64)
+string(i * 1)
+string(i * f64)
 string(i ** f32)
-string(i + 1)
+string(i ** f64)
+string(i ** i64)
+string(i + 0.5)
 string(i + i)
-string(i + i32)
-string(i + i64)
 string(i - f32)
-string(i - i64)
 string(i .. 1)
 string(i .. i)
-string(i .. i64)
+string(i .. i32)
 string(i / 1)
 string(i / f32)
-string(i / i)
+string(i / f64)
 string(i / i32)
 string(i / i64)
+string(i < 0.5)
 string(i < 1)
-string(i < f32)
 string(i < i32)
-string(i <= 0.5)
-string(i <= 1)
-string(i == 0.5)
-string(i == f32)
-string(i == i32)
+string(i <= f32)
+string(i <= i)
+string(i == 1)
+string(i == i)
 string(i > 0.5)
 string(i > 1)
-string(i > f64)
-string(i > i64)
-string(i >= 1)
-string(i >= f64)
-string(i ^ 0.5)
+string(i > f32)
+string(i >= 0.5)
+string(i >= i64)
 string(i ^ 1)
+string(i ^ f32)
 string(i ^ i)
-string(i in array)
-string(i not in array)
+string(i ^ i64)
 string(i)
+string(i) in foo
+string(i32 != 0.5)
+string(i32 != 1)
 string(i32 != f64)
-string(i32 != i)
+string(i32 != i32)
 string(i32 != nil)
-string(i32 * 0.5)
+string(i32 % 1)
+string(i32 % i)
+string(i32 % i64)
 string(i32 * 1)
 string(i32 * f32)
 string(i32 * f64)
-string(i32 * i64)
+string(i32 * i)
 string(i32 ** 0.5)
 string(i32 ** f64)
-string(i32 ** i)
-string(i32 + f64)
-string(i32 + i32)
+string(i32 + 0.5)
+string(i32 - 0.5)
+string(i32 - 1)
 string(i32 - f32)
 string(i32 - f64)
+string(i32 - i32)
+string(i32 - i64)
 string(i32 .. 1)
-string(i32 .. i32)
-string(i32 .. i64)
+string(i32 .. i)
 string(i32 / 0.5)
-string(i32 / i64)
-string(i32 < 0.5)
-string(i32 < f32)
-string(i32 < i)
-string(i32 < i32)
+string(i32 < 1)
+string(i32 < f64)
 string(i32 < i64)
-string(i32 <= f64)
-string(i32 <= i64)
-string(i32 == 1)
 string(i32 == f32)
-string(i32 == f64)
-string(i32 == i)
+string(i32 == i64)
 string(i32 == nil)
 string(i32 > 1)
-string(i32 > f64)
+string(i32 > i)
 string(i32 >= 0.5)
 string(i32 >= 1)
-string(i32 >= f64)
 string(i32 >= i)
-string(i32 >= i64)
-string(i32 ^ 1)
+string(i32 ^ f32)
 string(i32 ^ f64)
 string(i32 ^ i32)
-string(i32 ^ i64)
 string(i32 in array)
 string(i32 not in array)
 string(i32)
-string(i32) == type("bar")
-string(i64 != 0.5)
+string(i32) not startsWith trimSuffix("foo")
 string(i64 != 1)
 string(i64 != i)
 string(i64 != i32)
 string(i64 != i64)
-string(i64 != nil)
-string(i64 % 1)
-string(i64 % i64)
+string(i64 % i32)
 string(i64 * 1)
 string(i64 * f32)
-string(i64 * i32)
-string(i64 * i64)
+string(i64 * i)
 string(i64 ** 0.5)
-string(i64 ** f32)
-string(i64 ** i)
-string(i64 ** i32)
-string(i64 + 0.5)
-string(i64 + f32)
-string(i64 + f64)
-string(i64 + i)
-string(i64 + i32)
-string(i64 - f32)
+string(i64 + i64)
 string(i64 - i)
-string(i64 / 0.5)
-string(i64 / 1)
-string(i64 / f32)
+string(i64 - i32)
+string(i64 - i64)
+string(i64 .. 1)
+string(i64 .. i)
+string(i64 .. i32)
 string(i64 / f64)
 string(i64 / i)
 string(i64 / i64)
-string(i64 < 1)
-string(i64 <= 0.5)
-string(i64 <= f32)
-string(i64 <= i)
-string(i64 <= i32)
+string(i64 < 0.5)
+string(i64 < i)
 string(i64 <= i64)
-string(i64 == 1)
+string(i64 == 0.5)
 string(i64 == i)
-string(i64 == i32)
-string(i64 == nil)
-string(i64 > 1)
-string(i64 > f32)
-string(i64 > f64)
-string(i64 > i)
-string(i64 > i32)
+string(i64 > 0.5)
 string(i64 > i64)
-string(i64 >= f64)
-string(i64 >= i64)
+string(i64 >= 0.5)
+string(i64 >= 1)
 string(i64 ^ 0.5)
 string(i64 ^ f64)
-string(i64 ^ i)
 string(i64 in array)
 string(i64)
-string(i64) >= foo.Bar
+string(i64) matches greet("bar")
 string(i64) not in foo
 string(int(0.5))
 string(int(1))
-string(int(f32 - i))
-string(int(f32))
-string(int(f64))
-string(int(i))
 string(int(i32))
 string(int(i64))
 string(last(array))
-string(last(list))
+string(last(list).String())
+string(len("bar"))
 string(len(array))
 string(len(list))
-string(len(string("foo")))
+string(list != nil)
 string(list == array)
 string(list == list)
 string(list == nil)
 string(list)
-string(list) != toJSON(i64)
 string(list[1])
+string(list[i32])
 string(list[i64])
-string(list[i64].String)
-string(lower("bar"))
-string(lower("foo"))
-string(map(array, "bar"))
+string(list[i])
 string(map(array, #))
 string(map(array, 0.5))
-string(map(array, 1))
-string(map(array, array))
+string(map(array, add))
 string(map(array, div))
-string(map(array, greet))
 string(map(array, i))
 string(map(array, i32))
-string(map(array, ok))
 string(map(array, true))
 string(map(list, "bar"))
 string(map(list, "foo"))
 string(map(list, #))
 string(map(list, 0.5))
 string(map(list, 1))
-string(map(list, add))
-string(map(list, f32))
-string(map(list, f64))
-string(map(list, false))
-string(map(list, greet))
+string(map(list, array))
+string(map(list, half))
+string(map(list, i32))
 string(map(list, i64))
-string(map(list, list))
 string(max(0.5))
+string(max(0.5, f32))
 string(max(1))
-string(max(1, 0.5))
-string(max(1, f32))
 string(max(f32))
 string(max(f64))
 string(max(i))
-string(max(i32))
-string(max(i32, 1, i64))
 string(max(i64))
+string(mean(array))
 string(min(0.5))
-string(min(0.5, f64, f32))
-string(min(1))
 string(min(f32))
-string(min(f64))
 string(min(i))
 string(min(i32))
-string(min(i32, i64))
 string(min(i64))
-string(nil != "foo")
-string(nil != 0.5)
-string(nil != 1)
-string(nil != array)
+string(nil != "bar")
 string(nil != div)
-string(nil != f64)
 string(nil != false)
 string(nil != greet)
+string(nil != half)
 string(nil != i)
-string(nil != i64)
-string(nil != nil)
-string(nil != score)
-string(nil == "foo")
+string(nil != ok)
+string(nil == "bar")
+string(nil == 0.5)
 string(nil == 1)
-string(nil == add)
-string(nil == f32)
-string(nil == f64)
-string(nil == false)
+string(nil == div)
+string(nil == foo)
 string(nil == list)
+string(nil == nil)
 string(nil == ok)
-string(nil == true)
-string(nil in array)
+string(nil == score)
 string(nil in list)
-string(nil) > string(1)
-string(nil) >= string(greet)
-string(nil) in foo
+string(nil not in list)
+string(nil) <= list[i].Bar
 string(none(array, ok))
-string(none(list, true))
+string(none(list, false))
+string(none(list, ok))
+string(not !false)
+string(not (i64 == 0.5))
 string(not false)
 string(not ok)
 string(not true)
-string(ok && false)
-string(ok && ok)
-string(ok == nil)
-string(ok == true)
-string(ok ? 0.5 : "foo")
+string(ok != nil)
+string(ok != true)
+string(ok ? 0.5 : nil)
 string(ok ? 0.5 : true)
-string(ok ? true : i32)
+string(ok ? 1 : array)
+string(ok ? 1 : f32)
+string(ok ? array : add)
+string(ok ? div : array)
+string(ok ? half : score)
+string(ok ? i : 1)
+string(ok ? nil : half)
+string(ok ? nil : list)
 string(ok or false)
-string(ok or ok)
-string(ok || ok)
+string(ok || false)
 string(ok)
-string(one(array, false))
-string(one(array, ok))
 string(one(array, true))
 string(one(list, true))
+string(reduce(array, #))
+string(reduce(array, 0.5))
+string(reduce(array, 1))
+string(reduce(array, f64))
+string(reduce(array, greet))
+string(reduce(array, half))
+string(reduce(array, i64))
+string(reduce(array, list))
+string(reduce(array, score))
+string(reduce(list, "bar"))
+string(reduce(list, #))
+string(reduce(list, 1))
+string(reduce(list, add))
+string(reduce(list, div))
+string(reduce(list, foo))
+string(reduce(list, i))
+string(reduce(list, i64))
+string(reduce(list, list))
+string(round(0.5))
+string(round(1))
+string(round(ceil(i32)))
+string(round(f64))
+string(round(i64))
 string(score != nil)
-string(score == div)
 string(score == nil)
+string(score(1 % 1))
 string(score(1))
 string(score(i))
-string(score(score(i)))
 string(score)
-string(score) < string(ok)
-string(score) not in foo
 string(sort(array))
+string(sortBy(array, "foo"))
 string(string("bar"))
 string(string("foo"))
 string(string(0.5))
 string(string(1))
-string(string(add))
 string(string(array))
 string(string(div))
+string(string(f32))
 string(string(f64))
 string(string(false))
-string(string(foo))
 string(string(greet))
 string(string(half))
 string(string(i))
-string(string(i32))
 string(string(i64))
-string(string(list))
 string(string(nil))
 string(string(ok))
 string(string(score))
-string(string(true))
+string(sum(array))
+string(toBase64("foo"))
 string(toJSON("bar"))
-string(toJSON("foo"))
 string(toJSON(0.5))
 string(toJSON(1))
 string(toJSON(array))
 string(toJSON(f32))
 string(toJSON(f64))
 string(toJSON(false))
-string(toJSON(foo))
 string(toJSON(i))
+string(toJSON(i32))
 string(toJSON(i64))
 string(toJSON(list))
 string(toJSON(nil))
 string(toJSON(ok))
 string(toJSON(true))
-string(trim("foo"))
-string(trim(toJSON(0.5)))
-string(trimPrefix("bar"))
+string(trim("bar"))
+string(trim(type(nil)))
 string(trimPrefix("foo"))
-string(trimPrefix(type(f32)))
-string(trimSuffix("bar"))
-string(true != true)
+string(trimSuffix("foo"))
+string(true != false)
+string(true && ok)
 string(true == nil)
-string(true == ok)
-string(true ? 1 : true)
-string(true ? array : f32)
-string(true ? div : i64)
-string(true ? i32 : "foo")
-string(true ? i32 : greet)
-string(true ? score : 0.5)
-string(true ? true : i32)
+string(true ? 0.5 : true)
+string(true ? f64 : score)
+string(true ? false : nil)
+string(true ? greet : i)
+string(true ? list : ok)
 string(true and false)
-string(true or true)
-string(true || false)
-string(true) endsWith string(i64)
-string(true) not in foo
+string(true or false)
+string(true or ok)
+string(true || true)
+string(type("bar"))
 string(type("foo"))
+string(type(-i64))
 string(type(0.5))
-string(type(1 < f64))
 string(type(1))
-string(type(add))
 string(type(array))
-string(type(div))
 string(type(f32))
 string(type(f64))
-string(type(false))
 string(type(foo))
+string(type(greet))
 string(type(half))
 string(type(i))
 string(type(i32))
@@ -13421,116 +16886,131 @@ string(type(i64))
 string(type(list))
 string(type(nil))
 string(type(ok))
-string(type(score(1)))
 string(type(score))
-string(type(true))
-string(type(type(false)))
-string(upper("bar"))
 string(upper("foo"))
-string({"bar": 0.5})
-string({"bar": i32, "foo": i64})
-string({"foo": f64})
-string({"foo": true})
+string({"bar": "foo", "foo": half})
+string({"bar": f32, "foo": i32})
+string({"bar": f32})
+string({"bar": true})
+string({"foo": add})
+string({"foo": array, "foo": list})
+sum(1 .. 1)
+sum(1 .. i)
+sum(1 .. i32)
+sum(1 .. i64)
+sum([0.5])
+sum([f32])
+sum(array)
+sum(array) != f32
+sum(array) % i
+sum(array) % i64
+sum(array) - f32
+sum(array) / -f64
+sum(array) < i
+sum(array) == i64 - i
+sum(array) ^ f64
+sum(array) not in array
+sum(filter(array, ok))
+sum(groupBy(array, i32).String)
+sum(i32 .. 1)
+sum(i64 .. i32)
+sum(i64 .. i64)
+sum(list[i:1])
+sum(map(array, #))
+sum(map(array, f32))
+sum(map(list, 0.5))
+sum(map(list, f32))
+sum(map(list, i32))
+sum(ok ? array : i64)
+sum(reduce(array, array))
+sum(reduce(list, array))
+sum(sort(array))
+sum(true ? array : i32)
+take(array, i)
+take(array, i32)
+take(array, i64)
+take(list, i)
+take(list, i32)
+take(list, i64)
+take(map(array, #), i)
+toBase64("bar" + "bar")
+toBase64("bar" + "foo")
+toBase64("bar") startsWith type(score)
+toBase64("foo" + "bar")
 toBase64(foo.Bar)
 toBase64(foo.String())
 toBase64(foo?.Bar)
 toBase64(foo?.String())
 toBase64(greet("bar"))
 toBase64(greet("foo"))
-toBase64(greet(string(array)))
 toBase64(lower("bar"))
 toBase64(lower("foo"))
-toBase64(lower(type(i32)))
-toBase64(ok ? "foo" : 1)
-toBase64(ok ? "foo" : foo)
-toBase64(string("bar"))
+toBase64(ok ? "bar" : f64)
+toBase64(reduce(list, "bar"))
 toBase64(string("foo"))
 toBase64(string(0.5))
 toBase64(string(1))
+toBase64(string(add))
 toBase64(string(array))
-toBase64(string(f32 <= i32))
 toBase64(string(f32))
 toBase64(string(f64))
-toBase64(string(false))
 toBase64(string(foo))
 toBase64(string(greet))
 toBase64(string(half))
 toBase64(string(i))
-toBase64(string(i32))
-toBase64(string(i64))
 toBase64(string(list))
-toBase64(string(nil))
 toBase64(string(ok))
-toBase64(string(score))
-toBase64(string(true))
 toBase64(toBase64("bar"))
-toBase64(toBase64("foo"))
 toBase64(toJSON("bar"))
-toBase64(toJSON("foo"))
 toBase64(toJSON(0.5))
 toBase64(toJSON(1))
-toBase64(toJSON(array))
 toBase64(toJSON(f32))
 toBase64(toJSON(f64))
-toBase64(toJSON(false))
 toBase64(toJSON(foo))
-toBase64(toJSON(i))
-toBase64(toJSON(i32))
 toBase64(toJSON(i64))
 toBase64(toJSON(list))
 toBase64(toJSON(nil))
 toBase64(toJSON(ok))
 toBase64(toJSON(true))
 toBase64(trim("bar"))
-toBase64(trim("foo"))
 toBase64(trimPrefix("foo"))
-toBase64(trimSuffix("bar"))
 toBase64(trimSuffix("foo"))
-toBase64(true ? "bar" : ok)
-toBase64(type("bar"))
-toBase64(type("foo"))
 toBase64(type(0.5))
 toBase64(type(1))
 toBase64(type(add))
-toBase64(type(array))
 toBase64(type(div))
 toBase64(type(f32))
 toBase64(type(f64))
 toBase64(type(false))
 toBase64(type(foo))
-toBase64(type(get(array, i)))
 toBase64(type(greet))
+toBase64(type(half))
 toBase64(type(i))
 toBase64(type(i32))
 toBase64(type(i64))
 toBase64(type(list))
-toBase64(type(ok))
-toBase64(type(true))
-toBase64(upper("bar"))
+toBase64(type(nil))
+toBase64(type(score))
 toBase64(upper("foo"))
-toBase64(upper(foo.Bar))
 toJSON(!false)
 toJSON(!ok)
 toJSON(!true)
-toJSON("bar" != "foo")
-toJSON("bar" + "bar")
-toJSON("bar" + "foo")
-toJSON("bar" <= "foo")
-toJSON("bar" >= "foo")
-toJSON("bar" contains "bar")
-toJSON("bar" matches "bar")
+toJSON("bar" < "foo")
+toJSON("bar" >= "bar")
+toJSON("bar" endsWith "bar")
+toJSON("bar" matches "foo")
+toJSON("bar" not in foo)
 toJSON("bar" not matches "bar")
-toJSON("bar" not matches "foo")
+toJSON("bar" not startsWith "foo")
+toJSON("bar" startsWith "bar")
+toJSON("bar") not in foo
 toJSON("foo" != "bar")
-toJSON("foo" + "bar")
-toJSON("foo" <= "bar")
-toJSON("foo" == nil)
-toJSON("foo" contains "bar")
-toJSON("foo" matches "foo")
-toJSON("foo" not in foo)
-toJSON("foo" not matches "bar")
-toJSON("foo") > foo?.Bar
-toJSON("foo") not in foo
+toJSON("foo" != "foo")
+toJSON("foo" < "foo")
+toJSON("foo" == "bar")
+toJSON("foo" > "foo")
+toJSON("foo" >= "foo")
+toJSON("foo" startsWith "bar")
 toJSON(-0.5)
 toJSON(-1)
 toJSON(-f32)
@@ -13538,133 +17018,104 @@ toJSON(-f64)
 toJSON(-i)
 toJSON(-i32)
 toJSON(-i64)
-toJSON(0.5 != 0.5)
 toJSON(0.5 != 1)
-toJSON(0.5 != f32)
 toJSON(0.5 != f64)
-toJSON(0.5 != i)
-toJSON(0.5 != i32)
-toJSON(0.5 * 0.5)
+toJSON(0.5 != nil)
 toJSON(0.5 * i)
 toJSON(0.5 * i32)
+toJSON(0.5 * i64)
+toJSON(0.5 ** 0.5)
+toJSON(0.5 ** 1)
+toJSON(0.5 ** f32)
 toJSON(0.5 ** f64)
 toJSON(0.5 ** i)
-toJSON(0.5 ** i64)
+toJSON(0.5 ** i32)
 toJSON(0.5 + 0.5)
+toJSON(0.5 + 1)
 toJSON(0.5 + f32)
 toJSON(0.5 - 0.5)
 toJSON(0.5 - 1)
 toJSON(0.5 - f32)
 toJSON(0.5 - f64)
-toJSON(0.5 / 0.5)
+toJSON(0.5 - i)
+toJSON(0.5 - i32)
 toJSON(0.5 / 1)
 toJSON(0.5 / f32)
 toJSON(0.5 / f64)
-toJSON(0.5 / i)
 toJSON(0.5 / i32)
-toJSON(0.5 / i64)
-toJSON(0.5 < 0.5)
 toJSON(0.5 < 1)
 toJSON(0.5 < f32)
+toJSON(0.5 < f64)
 toJSON(0.5 < i)
+toJSON(0.5 <= 0.5)
 toJSON(0.5 <= 1)
 toJSON(0.5 <= f32)
-toJSON(0.5 <= f64)
-toJSON(0.5 <= i)
+toJSON(0.5 <= i64)
 toJSON(0.5 == 0.5)
-toJSON(0.5 == 1)
-toJSON(0.5 == f32)
+toJSON(0.5 == f64)
 toJSON(0.5 == i)
+toJSON(0.5 == i32)
 toJSON(0.5 == i64)
-toJSON(0.5 > 1)
-toJSON(0.5 > f32)
-toJSON(0.5 > f64)
-toJSON(0.5 > i32)
 toJSON(0.5 >= 0.5)
 toJSON(0.5 >= 1)
 toJSON(0.5 >= f32)
-toJSON(0.5 >= f64)
-toJSON(0.5 >= i)
-toJSON(0.5 >= i32)
-toJSON(0.5 >= i64)
-toJSON(0.5 ^ 0.5)
-toJSON(0.5 ^ 1)
 toJSON(0.5 ^ f32)
-toJSON(0.5 ^ f64)
-toJSON(0.5 ^ i)
 toJSON(0.5 ^ i32)
 toJSON(0.5 ^ i64)
-toJSON(0.5) contains "bar" ? "bar" : array
+toJSON(0.5) not in foo
 toJSON(1 != 0.5)
 toJSON(1 != f32)
 toJSON(1 != nil)
 toJSON(1 % 1)
+toJSON(1 % i)
 toJSON(1 % i32)
-toJSON(1 * 0.5)
-toJSON(1 * f32)
 toJSON(1 * f64)
 toJSON(1 * i32)
 toJSON(1 * i64)
 toJSON(1 ** 0.5)
 toJSON(1 ** 1)
-toJSON(1 ** f32)
-toJSON(1 ** f64)
-toJSON(1 ** i >= f64)
 toJSON(1 ** i32)
 toJSON(1 + 0.5)
-toJSON(1 + f32)
+toJSON(1 + 1)
 toJSON(1 + f64)
-toJSON(1 + i64)
-toJSON(1 - 0.5)
-toJSON(1 - 1)
-toJSON(1 - f32)
-toJSON(1 - f64)
+toJSON(1 + i)
+toJSON(1 + i32)
+toJSON(1 - i)
 toJSON(1 - i32)
-toJSON(1 .. 1)
-toJSON(1 .. i)
+toJSON(1 .. i32)
 toJSON(1 .. i64)
-toJSON(1 / 0.5)
 toJSON(1 / 1)
-toJSON(1 / f32)
-toJSON(1 / i32)
+toJSON(1 / f64)
+toJSON(1 / i64)
 toJSON(1 < 0.5)
 toJSON(1 < 1)
-toJSON(1 < f32)
 toJSON(1 < f64)
 toJSON(1 < i)
 toJSON(1 <= 0.5)
-toJSON(1 <= 1)
-toJSON(1 <= i)
-toJSON(1 <= i32)
-toJSON(1 <= i64)
+toJSON(1 <= f32)
+toJSON(1 <= f64)
 toJSON(1 == 0.5)
-toJSON(1 == f32)
+toJSON(1 == 1)
+toJSON(1 == f64)
 toJSON(1 == i)
 toJSON(1 == i32)
-toJSON(1 == i64)
 toJSON(1 == nil)
-toJSON(1 > 0.5)
-toJSON(1 > f64)
+toJSON(1 > f32)
 toJSON(1 > i)
-toJSON(1 > i32)
-toJSON(1 > i64)
-toJSON(1 >= 0.5)
 toJSON(1 >= 1)
 toJSON(1 >= f32)
 toJSON(1 >= i32)
-toJSON(1 ^ 0.5)
 toJSON(1 ^ 1)
 toJSON(1 ^ f32)
-toJSON(1 ^ f64)
 toJSON(1 ^ i32)
 toJSON(1 ^ i64)
-toJSON(1 in array)
-toJSON(1) == nil == true
-toJSON(1) in foo
-toJSON(1) not in foo
-toJSON(1) startsWith foo.String()
-toJSON([1])
-toJSON([i64])
+toJSON(1) > reduce(list, "bar")
+toJSON(1) not contains string(true)
+toJSON([f64])
+toJSON([false])
+toJSON([foo])
+toJSON([nil])
+toJSON([true])
 toJSON(abs(0.5))
 toJSON(abs(1))
 toJSON(abs(f32))
@@ -13672,143 +17123,92 @@ toJSON(abs(f64))
 toJSON(abs(i))
 toJSON(abs(i32))
 toJSON(abs(i64))
-toJSON(add != nil)
-toJSON(add != score)
-toJSON(add == div)
-toJSON(add == half)
-toJSON(add == nil)
-toJSON(add == score)
-toJSON(all(list, false))
-toJSON(all(list, ok))
-toJSON(all(list, true))
+toJSON(add == add)
 toJSON(any(array, false))
-toJSON(any(array, true))
-toJSON(array != array)
-toJSON(array != nil)
+toJSON(array == array)
+toJSON(array == list)
+toJSON(array == nil)
 toJSON(array)
-toJSON(array) != toJSON(ok)
-toJSON(array) > "bar" != false
-toJSON(array) endsWith greet("foo")
-toJSON(array) endsWith string(i32)
-toJSON(array) in foo
-toJSON(array) not startsWith greet("foo")
-toJSON(array[1:1])
-toJSON(array[i32])
+toJSON(array[1:i64])
+toJSON(array[1])
 toJSON(array[i])
-toJSON(count(array, false))
+toJSON(bitnot(1))
+toJSON(bitnot(i))
+toJSON(bitnot(i32))
+toJSON(bitnot(i64))
+toJSON(bitshl(i, i32))
+toJSON(ceil(1))
+toJSON(ceil(f64))
+toJSON(ceil(i))
+toJSON(ceil(i32))
+toJSON(ceil(i64))
 toJSON(count(array, ok))
 toJSON(div != div)
-toJSON(div != greet)
-toJSON(div != score)
 toJSON(div == div)
-toJSON(div == half)
-toJSON(div == nil)
-toJSON(div == score)
-toJSON(f32 != 1)
-toJSON(f32 * 0.5)
-toJSON(f32 * 1)
+toJSON(f32 != 0.5)
+toJSON(f32 != 1 || ok)
+toJSON(f32 != f32)
+toJSON(f32 != i32)
 toJSON(f32 * f32)
-toJSON(f32 * f64)
-toJSON(f32 * i32)
-toJSON(f32 ** f32)
+toJSON(f32 ** 0.5)
+toJSON(f32 ** 1)
+toJSON(f32 ** f64)
 toJSON(f32 ** i32)
-toJSON(f32 ** i64)
-toJSON(f32 + 1)
-toJSON(f32 + i)
-toJSON(f32 + i32)
+toJSON(f32 + 0.5)
+toJSON(f32 + f32)
+toJSON(f32 - 0.5)
+toJSON(f32 - f32)
 toJSON(f32 - f64)
-toJSON(f32 - i32)
-toJSON(f32 / 0.5)
-toJSON(f32 / 1)
+toJSON(f32 - i64)
 toJSON(f32 < 0.5)
-toJSON(f32 < f32)
-toJSON(f32 < f64)
-toJSON(f32 <= f32)
-toJSON(f32 == 1)
+toJSON(f32 < i)
+toJSON(f32 < i64)
+toJSON(f32 <= 0.5)
+toJSON(f32 <= 1)
+toJSON(f32 <= i64)
 toJSON(f32 == f64)
 toJSON(f32 == i)
 toJSON(f32 == nil)
-toJSON(f32 > 0.5)
-toJSON(f32 > f64)
 toJSON(f32 > i)
-toJSON(f32 >= 1)
-toJSON(f32 >= f32)
-toJSON(f32 ^ 0.5)
-toJSON(f32 ^ 1)
-toJSON(f32 ^ f64)
-toJSON(f32 ^ i)
+toJSON(f32 > i32)
+toJSON(f32 >= 0.5)
 toJSON(f32 ^ i64)
 toJSON(f32)
-toJSON(f64 != 1)
+toJSON(f32) in foo
+toJSON(f64 != 0.5)
 toJSON(f64 != f32)
-toJSON(f64 != f64)
 toJSON(f64 != i)
-toJSON(f64 != i32 / i32)
 toJSON(f64 != i32)
 toJSON(f64 != nil)
-toJSON(f64 * 0.5)
+toJSON(f64 * 1)
 toJSON(f64 * f64)
-toJSON(f64 * i)
 toJSON(f64 * i64)
 toJSON(f64 ** 0.5)
 toJSON(f64 ** f32)
-toJSON(f64 ** i)
-toJSON(f64 ** i64)
-toJSON(f64 + 1)
+toJSON(f64 + 0.5)
 toJSON(f64 + f32)
-toJSON(f64 + i)
 toJSON(f64 + i32)
-toJSON(f64 - 1)
 toJSON(f64 - f64)
 toJSON(f64 - i)
-toJSON(f64 - i32)
-toJSON(f64 / 0.5)
-toJSON(f64 / f32)
-toJSON(f64 / i32)
-toJSON(f64 < 1)
-toJSON(f64 < f32)
-toJSON(f64 < i32)
-toJSON(f64 < i64)
+toJSON(f64 - i64)
+toJSON(f64 / 1)
+toJSON(f64 < f64)
 toJSON(f64 <= 0.5)
-toJSON(f64 <= 1)
-toJSON(f64 <= i32)
-toJSON(f64 == 1)
-toJSON(f64 == i64)
-toJSON(f64 == nil)
-toJSON(f64 > 1)
-toJSON(f64 > f64)
-toJSON(f64 >= 0.5)
-toJSON(f64 >= i64)
-toJSON(f64 ^ 1)
-toJSON(f64 ^ f64)
-toJSON(f64 ^ i)
+toJSON(f64 == f64)
+toJSON(f64 >= 1)
+toJSON(f64 >= f64)
+toJSON(f64 ^ f32)
 toJSON(f64)
-toJSON(false != nil)
-toJSON(false && false)
-toJSON(false == false)
-toJSON(false ? 0.5 : nil)
-toJSON(false ? 1 : f32)
-toJSON(false ? f32 : list)
-toJSON(false ? false : i32)
-toJSON(false ? greet : 1)
-toJSON(false ? greet : i32)
-toJSON(false ? nil : f64)
-toJSON(false and ok)
-toJSON(false and true)
-toJSON(filter(array, ok))
-toJSON(filter(list, false))
+toJSON(false != ok)
+toJSON(false ? 0.5 : "foo")
+toJSON(false ? add : f64)
+toJSON(false ? array : 1)
+toJSON(false ? false : foo)
+toJSON(false ? nil : ok)
+toJSON(false ? ok : i32)
 toJSON(filter(list, true))
-toJSON(find(array, false))
-toJSON(find(array, ok))
-toJSON(findIndex(array, ok))
-toJSON(findIndex(array, true))
-toJSON(findIndex(list, ok))
-toJSON(findIndex(list, true))
-toJSON(findLast(array, false))
-toJSON(findLast(list, true))
-toJSON(findLastIndex(array, true))
-toJSON(findLastIndex(list, false))
-toJSON(findLastIndex(list, ok))
+toJSON(find(list, ok))
+toJSON(findIndex(map(array, list), ok))
 toJSON(first(array))
 toJSON(first(list))
 toJSON(float(0.5))
@@ -13816,297 +17216,272 @@ toJSON(float(1))
 toJSON(float(f32))
 toJSON(float(f64))
 toJSON(float(i))
-toJSON(float(i32))
 toJSON(float(i64))
-toJSON(foo != foo)
+toJSON(floor(0.5))
+toJSON(floor(f64))
+toJSON(floor(i))
+toJSON(floor(i32))
 toJSON(foo != nil)
-toJSON(foo == foo)
-toJSON(foo == nil)
 toJSON(foo in list)
 toJSON(foo)
 toJSON(foo.Bar)
 toJSON(foo.String())
 toJSON(foo?.Bar)
 toJSON(foo?.String())
-toJSON(get(array, 1))
+toJSON(get(array, i32))
 toJSON(get(array, i64))
 toJSON(get(list, 1))
 toJSON(get(list, i))
+toJSON(get(list, i32))
 toJSON(get(list, i64))
-toJSON(greet != div)
-toJSON(greet != greet)
-toJSON(greet != half)
-toJSON(greet == add)
-toJSON(greet == div)
+toJSON(greet != nil)
 toJSON(greet == greet)
-toJSON(greet == half)
+toJSON(greet == nil)
 toJSON(greet("bar"))
 toJSON(greet("foo"))
-toJSON(half != greet)
-toJSON(half != nil)
-toJSON(half != score)
-toJSON(half == add)
-toJSON(half == div)
-toJSON(half == greet)
-toJSON(half == nil)
-toJSON(half == score)
+toJSON(groupBy(array, #)?.div)
+toJSON(groupBy(array, ok)?.foo)
+toJSON(groupBy(list, #)?.foo)
 toJSON(half(0.5))
+toJSON(half(1))
 toJSON(half(f64))
+toJSON(i != 0.5)
 toJSON(i != 1)
-toJSON(i != f32)
-toJSON(i != i)
-toJSON(i != i32)
-toJSON(i % 1)
-toJSON(i % i64)
+toJSON(i % i)
+toJSON(i % i32)
 toJSON(i * 0.5)
 toJSON(i * 1)
 toJSON(i * f32)
+toJSON(i * i)
 toJSON(i * i32)
-toJSON(i ** 0.5)
 toJSON(i ** f32)
-toJSON(i ** i32)
+toJSON(i ** i)
 toJSON(i + 0.5)
 toJSON(i + 1)
-toJSON(i + f32)
-toJSON(i + f64)
 toJSON(i + i)
 toJSON(i - 1)
-toJSON(i .. 1)
+toJSON(i - f32)
 toJSON(i .. i)
-toJSON(i / f32)
+toJSON(i .. i32)
+toJSON(i / i64)
+toJSON(i < f32)
+toJSON(i < f64)
+toJSON(i < i)
 toJSON(i < i32)
-toJSON(i < i64)
 toJSON(i <= 1)
 toJSON(i <= f32)
 toJSON(i <= f64)
 toJSON(i <= i)
 toJSON(i <= i32)
+toJSON(i <= i64)
+toJSON(i == 0.5)
+toJSON(i == 1)
 toJSON(i == i32)
-toJSON(i == i64)
 toJSON(i == nil)
 toJSON(i > 0.5)
-toJSON(i > 1)
-toJSON(i > f32)
-toJSON(i >= 0.5)
-toJSON(i >= 1)
-toJSON(i >= f32)
-toJSON(i >= i)
-toJSON(i ^ 1)
-toJSON(i ^ f64)
+toJSON(i > i)
+toJSON(i > i32)
+toJSON(i > i64)
+toJSON(i >= f64)
+toJSON(i >= i32)
+toJSON(i ^ i64)
+toJSON(i not in array)
 toJSON(i)
-toJSON(i) != string(1)
-toJSON(i32 != f32)
+toJSON(i) matches string("bar")
 toJSON(i32 != i)
+toJSON(i32 != i64)
 toJSON(i32 % 1)
-toJSON(i32 % i64)
+toJSON(i32 * 0.5)
 toJSON(i32 * i)
+toJSON(i32 * i32)
 toJSON(i32 * i64)
+toJSON(i32 ** f64)
 toJSON(i32 ** i64)
+toJSON(i32 + 0.5)
+toJSON(i32 + 1)
 toJSON(i32 + f64)
-toJSON(i32 + i)
-toJSON(i32 + i32)
-toJSON(i32 + i64)
-toJSON(i32 - 0.5)
-toJSON(i32 - 1)
-toJSON(i32 - f32)
-toJSON(i32 - f64)
-toJSON(i32 - i)
 toJSON(i32 .. i)
 toJSON(i32 .. i64)
 toJSON(i32 / 0.5)
 toJSON(i32 / f32)
-toJSON(i32 / i)
+toJSON(i32 / f64)
 toJSON(i32 / i64)
 toJSON(i32 < 0.5)
-toJSON(i32 < f32)
+toJSON(i32 < 1)
+toJSON(i32 < i)
+toJSON(i32 < i32)
 toJSON(i32 <= 0.5)
-toJSON(i32 <= i32)
-toJSON(i32 == 1)
-toJSON(i32 == f32)
-toJSON(i32 == i)
-toJSON(i32 == nil ? i32 : i32)
-toJSON(i32 == nil)
-toJSON(i32 > 0.5)
 toJSON(i32 > f64)
 toJSON(i32 > i)
-toJSON(i32 >= 0.5)
-toJSON(i32 >= 1)
-toJSON(i32 >= f32)
+toJSON(i32 > i32)
 toJSON(i32 >= f64)
-toJSON(i32 >= i)
-toJSON(i32 ^ 1)
+toJSON(i32 ^ 0.5)
+toJSON(i32 ^ f32)
 toJSON(i32 ^ f64)
-toJSON(i32 ^ i)
+toJSON(i32 ^ i32)
 toJSON(i32 in array)
 toJSON(i32 not in array)
 toJSON(i32)
-toJSON(i32) < string(i64)
-toJSON(i64 != 0.5)
+toJSON(i32) contains foo.Bar
 toJSON(i64 != 1)
-toJSON(i64 != f32)
 toJSON(i64 != i)
 toJSON(i64 != i32)
-toJSON(i64 != nil)
-toJSON(i64 % 1)
-toJSON(i64 % i)
 toJSON(i64 % i32)
-toJSON(i64 % i64)
-toJSON(i64 * i)
-toJSON(i64 + 0.5)
-toJSON(i64 + i)
-toJSON(i64 + i64)
-toJSON(i64 - 0.5)
-toJSON(i64 - 1)
-toJSON(i64 - i64)
+toJSON(i64 * 0.5)
+toJSON(i64 * f64)
+toJSON(i64 ** f64)
+toJSON(i64 ** i)
+toJSON(i64 ** i32)
+toJSON(i64 + 1)
+toJSON(i64 - i32)
 toJSON(i64 .. 1)
-toJSON(i64 / 1)
-toJSON(i64 / f32)
+toJSON(i64 .. i32)
+toJSON(i64 / f64)
 toJSON(i64 / i)
 toJSON(i64 / i64)
-toJSON(i64 < 0.5)
+toJSON(i64 < 1)
+toJSON(i64 < f64)
 toJSON(i64 < i32)
-toJSON(i64 <= 0.5)
 toJSON(i64 <= 1)
-toJSON(i64 <= f32)
 toJSON(i64 <= i64)
 toJSON(i64 == 0.5)
-toJSON(i64 == 1)
-toJSON(i64 == i32)
-toJSON(i64 == nil)
-toJSON(i64 > f32)
+toJSON(i64 > 0.5)
+toJSON(i64 > 1)
 toJSON(i64 > i)
-toJSON(i64 >= 0.5)
+toJSON(i64 > i32)
+toJSON(i64 > i64)
 toJSON(i64 >= 1)
+toJSON(i64 >= i)
 toJSON(i64 >= i64)
-toJSON(i64 ^ i)
+toJSON(i64 ^ 0.5)
+toJSON(i64 ^ f32)
+toJSON(i64 ^ i32)
+toJSON(i64 in array)
 toJSON(i64)
 toJSON(int(0.5))
 toJSON(int(1))
-toJSON(int(f32))
-toJSON(int(f64))
 toJSON(int(i))
 toJSON(int(i32))
-toJSON(last(list))
+toJSON(int(i64))
 toJSON(len("bar"))
-toJSON(len("foo"))
 toJSON(len(array))
+toJSON(len(greet("foo")))
 toJSON(len(list))
-toJSON(list != list)
-toJSON(list == nil)
+toJSON(list != array)
+toJSON(list != nil)
+toJSON(list == array)
+toJSON(list == list)
 toJSON(list)
-toJSON(list) <= foo?.Bar
 toJSON(list[1])
-toJSON(list[i32])
-toJSON(list[i64:1])
-toJSON(list[i64])
-toJSON(list[i])
 toJSON(lower("bar"))
-toJSON(lower("foo"))
 toJSON(map(array, #))
-toJSON(map(array, 0.5))
-toJSON(map(array, 1))
+toJSON(map(array, -#))
+toJSON(map(array, array))
 toJSON(map(array, false))
 toJSON(map(array, i))
-toJSON(map(array, i32))
+toJSON(map(array, i64))
 toJSON(map(array, list))
-toJSON(map(array, true))
-toJSON(map(list, "foo"))
 toJSON(map(list, #))
+toJSON(map(list, 0.5))
 toJSON(map(list, 1))
-toJSON(map(list, f32))
-toJSON(map(list, f64))
+toJSON(map(list, foo))
+toJSON(map(list, i32))
+toJSON(map(list, i64))
 toJSON(map(list, list))
-toJSON(max(0.5))
+toJSON(map(list, ok))
 toJSON(max(1))
 toJSON(max(f32))
 toJSON(max(f64))
-toJSON(max(i))
 toJSON(max(i32))
-toJSON(max(i64))
+toJSON(mean(array))
+toJSON(median(array))
 toJSON(min(0.5))
-toJSON(min(0.5, f32))
 toJSON(min(1))
-toJSON(min(1, 1))
 toJSON(min(f32))
 toJSON(min(f64))
+toJSON(min(f64, f64))
 toJSON(min(i))
-toJSON(min(i32) / f32)
 toJSON(min(i32))
 toJSON(min(i64))
-toJSON(nil != "bar")
-toJSON(nil != "foo")
 toJSON(nil != 0.5)
+toJSON(nil != 1)
 toJSON(nil != add)
+toJSON(nil != array)
 toJSON(nil != f32)
-toJSON(nil != f64)
+toJSON(nil != false)
 toJSON(nil != foo)
-toJSON(nil != i32)
-toJSON(nil != list)
-toJSON(nil != nil)
-toJSON(nil != score)
-toJSON(nil != true)
+toJSON(nil != greet)
+toJSON(nil != half)
 toJSON(nil == 0.5)
 toJSON(nil == 1)
-toJSON(nil == add)
 toJSON(nil == div)
-toJSON(nil == f32)
 toJSON(nil == f64)
-toJSON(nil == false)
-toJSON(nil == foo)
+toJSON(nil == half)
 toJSON(nil == i)
 toJSON(nil == i64)
 toJSON(nil == list)
+toJSON(nil == nil)
 toJSON(nil == ok)
-toJSON(nil == score)
-toJSON(nil == true)
 toJSON(nil in array)
-toJSON(nil not in array)
-toJSON(nil not in list)
-toJSON(nil) + string("bar")
-toJSON(nil) == toJSON(1)
-toJSON(nil) == type(nil)
-toJSON(nil) in foo
+toJSON(nil) + foo.Bar
+toJSON(none(array, ok))
 toJSON(none(array, true))
-toJSON(none(list, true))
+toJSON(none(list, false))
+toJSON(none(list, ok))
 toJSON(not ("foo" not in foo))
+toJSON(not (f32 != 1))
 toJSON(not false)
 toJSON(not ok)
 toJSON(not true)
 toJSON(ok != false)
-toJSON(ok != nil)
-toJSON(ok != ok)
-toJSON(ok && true)
+toJSON(ok && false)
+toJSON(ok && ok)
 toJSON(ok == nil)
 toJSON(ok == ok)
-toJSON(ok ? 1 : half)
-toJSON(ok ? f32 : div)
-toJSON(ok ? false : i32)
-toJSON(ok ? nil : f32)
+toJSON(ok ? "foo" : f32)
+toJSON(ok ? 0.5 : f32)
+toJSON(ok ? f64 : 0.5)
+toJSON(ok ? i : false)
+toJSON(ok ? nil : i)
+toJSON(ok ? nil : true)
+toJSON(ok ? true : greet)
+toJSON(ok and ok)
 toJSON(ok or true)
-toJSON(ok || ok)
 toJSON(ok)
-toJSON(one(array, i32 < #))
-toJSON(score != div)
-toJSON(score != greet)
-toJSON(score != nil)
+toJSON(one(array, false))
+toJSON(one(array, true))
+toJSON(reduce(array, #))
+toJSON(reduce(array, 0.5))
+toJSON(reduce(array, array))
+toJSON(reduce(array, foo))
+toJSON(reduce(array, i64))
+toJSON(reduce(array, list))
+toJSON(reduce(array, score(i32 * i64)))
+toJSON(reduce(list, #))
+toJSON(reduce(list, 1))
+toJSON(reduce(list, f32))
+toJSON(reduce(list, false))
+toJSON(reduce(list, i))
+toJSON(reduce(list, i32))
+toJSON(reduce(list, list))
+toJSON(reduce(list, ok))
+toJSON(reduce(list, true))
+toJSON(round(1))
+toJSON(round(f64))
+toJSON(round(i32))
 toJSON(score != score)
-toJSON(score == add)
-toJSON(score == div)
-toJSON(score == nil)
 toJSON(score(1))
+toJSON(score(1, 1))
 toJSON(score(i))
-toJSON(score(i, i))
+toJSON(sort(array))
 toJSON(string("bar"))
-toJSON(string("foo"))
 toJSON(string(0.5))
 toJSON(string(1))
 toJSON(string(array))
-toJSON(string(div))
 toJSON(string(f32))
 toJSON(string(f64))
 toJSON(string(false))
 toJSON(string(foo))
-toJSON(string(greet))
 toJSON(string(half))
 toJSON(string(i))
 toJSON(string(i32))
@@ -14115,11 +17490,11 @@ toJSON(string(list))
 toJSON(string(nil))
 toJSON(string(ok))
 toJSON(string(score))
+toJSON(string(true))
+toJSON(sum(array))
+toJSON(take(array, i32))
 toJSON(toBase64("bar"))
-toJSON(toBase64("foo"))
 toJSON(toJSON("bar"))
-toJSON(toJSON("foo"))
-toJSON(toJSON(1))
 toJSON(toJSON(array))
 toJSON(toJSON(f32))
 toJSON(toJSON(f64))
@@ -14131,50 +17506,58 @@ toJSON(toJSON(i64))
 toJSON(toJSON(list))
 toJSON(toJSON(nil))
 toJSON(toJSON(ok))
-toJSON(toJSON(true))
 toJSON(trim("bar"))
-toJSON(trim("foo"))
 toJSON(trimPrefix("foo"))
-toJSON(trimSuffix("foo"))
-toJSON(true && true)
-toJSON(true ? array : nil)
-toJSON(true ? i32 : div)
-toJSON(true ? list : true)
-toJSON(true ? nil : array)
-toJSON(true ? ok : list)
-toJSON(true ? true : f64)
-toJSON(true and ok)
+toJSON(trimSuffix("bar"))
+toJSON(true != true)
+toJSON(true && ok)
+toJSON(true == ok)
+toJSON(true ? "bar" : "bar")
+toJSON(true ? nil : score)
+toJSON(true and false)
+toJSON(true and true)
 toJSON(true) in foo
-toJSON(type("bar"))
 toJSON(type("foo"))
-toJSON(type(0.5))
-toJSON(type(1))
 toJSON(type(add))
 toJSON(type(array))
 toJSON(type(f32))
 toJSON(type(f64))
 toJSON(type(false))
 toJSON(type(foo))
-toJSON(type(greet))
-toJSON(type(half))
 toJSON(type(i))
 toJSON(type(i32))
 toJSON(type(i64))
 toJSON(type(list))
-toJSON(type(nil))
 toJSON(type(ok))
 toJSON(type(score))
 toJSON(type(true))
 toJSON(upper("bar"))
-toJSON(upper("foo"))
-toJSON({"bar": 0.5, "bar": array})
-toJSON({"foo": "foo"})
-toJSON({"foo": 0.5})
+toJSON({"bar": 1, "bar": array})
+toJSON({"bar": 1})
+toJSON({"bar": f64})
+toJSON({"bar": list})
+toJSON({"foo": i})
 toJSON({"foo": nil})
-toJSON({"foo": ok, "bar": 0.5})
-trim("bar") in foo
-trim("foo" + "foo")
-trim(false ? greet : "bar")
+toPairs(groupBy(array, # / #))
+toPairs(groupBy(array, #))
+toPairs(groupBy(array, 0.5))
+toPairs(groupBy(array, 1))
+toPairs(groupBy(array, false))
+toPairs(groupBy(array, foo))
+toPairs(groupBy(array, i))
+toPairs(groupBy(array, i32))
+toPairs(groupBy(array, ok))
+toPairs(groupBy(array, true))
+toPairs(groupBy(list, #))
+toPairs(groupBy(list, 1))
+toPairs(groupBy(list, f32))
+toPairs(groupBy(list, i))
+toPairs(groupBy(list, ok))
+toPairs({"bar": f32})
+toPairs({"foo": i32, "bar": score})
+toPairs({"foo": nil})
+trim("bar") not in foo
+trim(false ? "bar" : "bar")
 trim(foo.Bar)
 trim(foo.String())
 trim(foo?.Bar)
@@ -14182,84 +17565,58 @@ trim(foo?.String())
 trim(greet("bar"))
 trim(greet("foo"))
 trim(lower("bar"))
-trim(lower(toJSON(0.5)))
-trim(ok ? "bar" : i32)
-trim(string("foo"))
+trim(lower("foo"))
+trim(reduce(list, "bar"))
+trim(string("bar"))
+trim(string(-f64))
 trim(string(0.5))
 trim(string(1))
 trim(string(add))
-trim(string(div))
+trim(string(array))
 trim(string(f32))
-trim(string(f64))
-trim(string(false))
 trim(string(foo))
-trim(string(greet))
-trim(string(half))
-trim(string(i))
-trim(string(i32))
 trim(string(i64))
 trim(string(list))
 trim(string(nil))
-trim(string(ok))
-trim(string(score))
-trim(string(true))
-trim(toBase64("bar"))
-trim(toBase64("foo"))
-trim(toJSON("foo"))
-trim(toJSON(0.5))
+trim(toJSON("bar"))
 trim(toJSON(1))
-trim(toJSON(array))
 trim(toJSON(f32))
-trim(toJSON(f64))
 trim(toJSON(false))
 trim(toJSON(foo))
-trim(toJSON(i))
 trim(toJSON(i32))
 trim(toJSON(i64))
-trim(toJSON(list))
-trim(toJSON(nil))
 trim(toJSON(ok))
 trim(toJSON(true))
 trim(trim("bar"))
-trim(trimPrefix("bar"))
 trim(trimPrefix("foo"))
-trim(trimPrefix(string(i)))
 trim(trimSuffix("bar"))
-trim(trimSuffix("foo"))
+trim(true ? "foo" : greet)
+trim(type("bar"))
 trim(type("foo"))
 trim(type(0.5))
 trim(type(1))
 trim(type(add))
-trim(type(array))
 trim(type(div))
 trim(type(f32))
 trim(type(f64))
-trim(type(false))
-trim(type(foo))
 trim(type(greet))
-trim(type(half))
 trim(type(i))
-trim(type(i32))
-trim(type(i64))
 trim(type(list))
-trim(type(nil != list))
 trim(type(nil))
 trim(type(ok))
 trim(type(score))
-trim(type(toJSON(1)))
 trim(type(true))
-trim(upper("bar"))
-trimPrefix("foo" + "foo")
+trimPrefix("bar" + "foo")
+trimPrefix("foo" + "bar")
+trimPrefix(false ? 1 : "bar")
 trimPrefix(foo.Bar)
 trimPrefix(foo.String())
 trimPrefix(foo?.Bar)
 trimPrefix(foo?.String())
 trimPrefix(greet("bar"))
 trimPrefix(greet("foo"))
-trimPrefix(greet(foo.String()))
+trimPrefix(greet(type(0.5)))
 trimPrefix(lower("bar"))
-trimPrefix(lower("foo"))
-trimPrefix(ok ? "bar" : i64)
 trimPrefix(string("foo"))
 trimPrefix(string(0.5))
 trimPrefix(string(1))
@@ -14267,50 +17624,35 @@ trimPrefix(string(add))
 trimPrefix(string(array))
 trimPrefix(string(div))
 trimPrefix(string(f32))
+trimPrefix(string(f64))
 trimPrefix(string(foo))
 trimPrefix(string(greet))
 trimPrefix(string(half))
 trimPrefix(string(i))
 trimPrefix(string(i32))
 trimPrefix(string(i64))
-trimPrefix(string(list))
 trimPrefix(string(nil))
-trimPrefix(string(ok))
 trimPrefix(string(score))
+trimPrefix(string(true))
+trimPrefix(string({"bar": greet}))
 trimPrefix(toBase64("bar"))
-trimPrefix(toBase64("foo"))
-trimPrefix(toJSON("bar"))
 trimPrefix(toJSON("foo"))
-trimPrefix(toJSON(0.5))
 trimPrefix(toJSON(1))
 trimPrefix(toJSON(array))
 trimPrefix(toJSON(f32))
-trimPrefix(toJSON(f64))
-trimPrefix(toJSON(false))
 trimPrefix(toJSON(foo))
-trimPrefix(toJSON(i))
 trimPrefix(toJSON(i32))
 trimPrefix(toJSON(i64))
+trimPrefix(toJSON(list))
 trimPrefix(toJSON(nil))
 trimPrefix(toJSON(true))
-trimPrefix(trim("bar"))
-trimPrefix(trim("foo"))
-trimPrefix(trimPrefix("bar"))
 trimPrefix(trimPrefix("foo"))
-trimPrefix(trimSuffix("bar"))
-trimPrefix(trimSuffix("foo"))
 trimPrefix(type("bar"))
-trimPrefix(type(0.5 == 0.5))
 trimPrefix(type(0.5))
-trimPrefix(type(1 == f64))
 trimPrefix(type(1))
-trimPrefix(type(add))
 trimPrefix(type(array))
-trimPrefix(type(div))
 trimPrefix(type(f32))
 trimPrefix(type(f64))
-trimPrefix(type(false))
-trimPrefix(type(foo))
 trimPrefix(type(greet))
 trimPrefix(type(half))
 trimPrefix(type(i))
@@ -14319,142 +17661,125 @@ trimPrefix(type(i64))
 trimPrefix(type(list))
 trimPrefix(type(nil))
 trimPrefix(type(ok))
-trimPrefix(type(score))
+trimPrefix(type(true))
+trimPrefix(upper("bar"))
 trimPrefix(upper("foo"))
-trimSuffix("bar" + "bar")
-trimSuffix("foo") <= trimPrefix("foo")
+trimSuffix("bar" + "foo")
+trimSuffix("bar") not contains reduce(list, "bar")
+trimSuffix("foo" + "bar")
+trimSuffix(false ? i64 : "foo")
 trimSuffix(foo.Bar)
 trimSuffix(foo.String())
 trimSuffix(foo?.Bar)
-trimSuffix(foo?.Qux("bar"))
 trimSuffix(foo?.String())
 trimSuffix(greet("bar"))
 trimSuffix(greet("foo"))
-trimSuffix(greet(toJSON(i64)))
 trimSuffix(lower("bar"))
-trimSuffix(lower("foo"))
-trimSuffix(repeat("foo", i))
+trimSuffix(reduce(array, "foo"))
+trimSuffix(reduce(list, #)?.Bar)
 trimSuffix(string("bar"))
+trimSuffix(string("foo"))
 trimSuffix(string(0.5))
-trimSuffix(string(1))
 trimSuffix(string(add))
 trimSuffix(string(array))
-trimSuffix(string(f32))
+trimSuffix(string(div))
 trimSuffix(string(f64))
 trimSuffix(string(false))
 trimSuffix(string(foo))
-trimSuffix(string(greet))
 trimSuffix(string(half))
 trimSuffix(string(i))
 trimSuffix(string(i32))
 trimSuffix(string(i64))
 trimSuffix(string(list))
 trimSuffix(string(nil))
-trimSuffix(string(score))
-trimSuffix(string(type("foo")))
+trimSuffix(string(ok))
+trimSuffix(string(true))
 trimSuffix(toBase64("bar"))
-trimSuffix(toJSON("bar"))
-trimSuffix(toJSON(0.5))
+trimSuffix(toBase64("foo"))
+trimSuffix(toJSON(1 > f64))
 trimSuffix(toJSON(1))
-trimSuffix(toJSON(array))
+trimSuffix(toJSON(f32))
 trimSuffix(toJSON(f64))
 trimSuffix(toJSON(false))
-trimSuffix(toJSON(first(array)))
 trimSuffix(toJSON(foo))
 trimSuffix(toJSON(i))
 trimSuffix(toJSON(i32))
 trimSuffix(toJSON(i64))
 trimSuffix(toJSON(list))
 trimSuffix(toJSON(nil))
-trimSuffix(toJSON(ok))
+trimSuffix(toJSON(true))
 trimSuffix(trim("bar"))
 trimSuffix(trim("foo"))
 trimSuffix(trimPrefix("bar"))
 trimSuffix(trimPrefix("foo"))
-trimSuffix(trimSuffix("foo"))
-trimSuffix(type("bar"))
-trimSuffix(type("foo"))
-trimSuffix(type(0.5))
+trimSuffix(trimSuffix("bar"))
 trimSuffix(type(1))
 trimSuffix(type(add))
 trimSuffix(type(array))
 trimSuffix(type(div))
 trimSuffix(type(f32))
-trimSuffix(type(f64))
-trimSuffix(type(false))
 trimSuffix(type(foo))
+trimSuffix(type(greet))
 trimSuffix(type(half))
-trimSuffix(type(i))
 trimSuffix(type(i32))
-trimSuffix(type(i64))
 trimSuffix(type(list))
 trimSuffix(type(nil))
 trimSuffix(type(ok))
-trimSuffix(type(true))
-trimSuffix(upper("bar"))
 trimSuffix(upper("foo"))
-true != nil || true != nil
-true == nil && ok
-true ? "bar" : 0.5 ^ i
-true ? "bar" : 1 <= 1 / 1
-true ? "bar" : i != i32
-true ? "foo" : foo?.Bar
-true ? 0.5 : foo.Qux
-true ? 1 : f64 + f32
-true ? 1 : nil == array
-true ? array : foo.Qux
+true != nil || true == true
+true != ok != ok
+true == ok == ok
+true ? 0.5 : i <= f32
+true ? 1 : foo?.Bar
+true ? 1 : ok or i64 == 0.5
+true ? add : foo?.Bar
+true ? array : 0.5 >= i32
 true ? array : foo.String
-true ? array : i32 / i32
-true ? array : nil != map(list, #)
-true ? array : nil != ok
-true ? f32 : f64 == i32
-true ? f64 : foo?.String
-true ? greet : 0.5 == i
-true ? i : 0.5 + i64
-true ? i : 0.5 >= i64
-true ? i32 : foo.Bar
-true ? i64 : foo.Bar
-true ? list : f64 / f64
-true ? nil : 0.5 != i32
-true ? nil : foo.Qux
+true ? array : foo?.Bar
+true ? array : foo?.String
+true ? array : i32 ** f64
+true ? div : i64 ** 1 ^ i32
+true ? false : 0.5 > i
+true ? false : foo.Qux
+true ? foo : 0.5 + -1
+true ? foo : foo.Bar
+true ? foo : i64 / f32
+true ? greet : foo.Bar
+true ? greet : ok == ok
+true ? half : 0.5 / i32
+true ? half : foo.String
+true ? i : 1 * i64
+true ? i32 : i32 - f32
+true ? i32 : i32 >= f32
+true ? i64 : f64 != i
+true ? list : f32 != i
 true ? nil : foo.String
-true ? nil : i32 .. i
-true ? nil : i64 ** -i
-true ? ok : f32 / f32
-true ? ok : f64 + f64
-true ? score : foo.Qux
-true ? true : f32 >= i64
-true ? true : foo?.String
-true and ok and ok
-true || 1 not in array
+true ? nil : foo?.String
+true ? nil : i32 != f64 + 1
+true ? ok : foo.Qux
+true ? ok : foo?.String
+true ? score : ok or f64 < f32
+true and nil not in list
+true and ok or ok
+true and true || ok
+true or 0.5 not in array
+true || f32 not in groupBy(list, #)
+true || false ? half : half
 type(!false)
 type(!ok)
 type(!true)
-type("bar" != nil)
-type("bar" + "foo")
-type("bar" < "bar")
+type("bar" != "bar")
+type("bar" < "foo")
 type("bar" <= "bar")
-type("bar" <= "foo")
-type("bar" == nil)
-type("bar" > "foo")
-type("bar" endsWith "foo")
-type("bar" matches "bar")
-type("bar" matches "foo")
-type("bar" not contains "bar")
-type("bar" not endsWith "bar")
+type("bar" == "foo")
+type("bar" >= "bar")
 type("bar" not endsWith "foo")
-type("bar" startsWith "foo")
-type("bar") == string(array)
-type("foo" != "bar")
-type("foo" == "foo")
-type("foo" > "bar")
-type("foo" contains "foo")
-type("foo" endsWith "foo")
-type("foo" in foo)
-type("foo" not endsWith "bar")
-type("foo" not endsWith "foo")
-type("foo" startsWith "foo")
-type("foo" startsWith foo.Bar)
+type("bar" startsWith "bar")
+type("bar") startsWith greet("bar")
+type("foo" != nil)
+type("foo" + "bar")
+type("foo" not startsWith "bar")
+type("foo") not in foo
 type(-0.5)
 type(-1)
 type(-f32)
@@ -14462,288 +17787,231 @@ type(-f64)
 type(-i)
 type(-i32)
 type(-i64)
-type(0.5 != 0.5)
-type(0.5 != 1)
-type(0.5 != i)
+type(-int(f64))
+type(0.5 != f64)
 type(0.5 != i32)
 type(0.5 != nil)
 type(0.5 * 0.5)
-type(0.5 * 1)
-type(0.5 * i)
-type(0.5 * i32)
+type(0.5 * f32)
+type(0.5 * f64)
 type(0.5 * i64)
 type(0.5 ** 0.5)
 type(0.5 ** 1)
 type(0.5 ** f32)
+type(0.5 ** f64)
 type(0.5 ** i)
 type(0.5 ** i32)
-type(0.5 ** i64)
+type(0.5 + 0.5)
+type(0.5 + 1)
 type(0.5 + f32)
-type(0.5 + i32)
+type(0.5 + f64)
+type(0.5 + i)
 type(0.5 + i64)
-type(0.5 - 0.5)
-type(0.5 - i)
-type(0.5 / 0.5)
+type(0.5 - 1)
+type(0.5 - f64)
+type(0.5 - i32)
 type(0.5 / 1)
-type(0.5 / f64)
+type(0.5 / f32)
 type(0.5 / i)
+type(0.5 / i32)
+type(0.5 / i64)
 type(0.5 < 1)
-type(0.5 < f64)
-type(0.5 < i)
+type(0.5 < f32)
+type(0.5 < i32)
 type(0.5 < i64)
 type(0.5 <= 1)
 type(0.5 <= f32)
-type(0.5 <= i)
 type(0.5 <= i64)
-type(0.5 == 1)
-type(0.5 == i)
-type(0.5 == nil)
+type(0.5 == 0.5)
+type(0.5 == f32)
+type(0.5 == f64)
+type(0.5 == i32)
 type(0.5 > 0.5)
-type(0.5 > 1)
-type(0.5 > f64)
+type(0.5 > f32)
 type(0.5 > i)
+type(0.5 > i32)
+type(0.5 > i64)
 type(0.5 >= 0.5)
-type(0.5 >= 1)
-type(0.5 >= f64)
 type(0.5 >= i)
 type(0.5 >= i32)
 type(0.5 ^ 0.5)
-type(0.5 ^ 1)
-type(0.5 ^ f32)
-type(0.5 ^ f64)
 type(0.5 ^ i)
-type(0.5) not contains trimPrefix("bar")
-type(0.5) not in foo
-type(0.5) startsWith "bar" == nil
-type(0.5)[i32:i64]
-type(1 != 0.5)
-type(1 != 1)
-type(1 != f32)
+type(0.5 ^ i32)
+type(0.5 ^ i64)
+type(0.5 not in array)
+type(0.5) in foo
 type(1 != i32)
 type(1 != nil)
 type(1 % 1)
 type(1 % i)
-type(1 % i32)
-type(1 % i64)
-type(1 * 1)
+type(1 * 0.5)
 type(1 * f32)
 type(1 * i)
-type(1 * i64)
+type(1 * i32)
 type(1 ** 0.5)
-type(1 ** 1)
 type(1 ** f64)
-type(1 ** i32)
+type(1 ** i)
 type(1 ** i64)
 type(1 + 0.5)
+type(1 + 1)
 type(1 + f32)
-type(1 + f64)
 type(1 + i64)
 type(1 - 0.5)
 type(1 - 1)
-type(1 - f64)
-type(1 - i32)
+type(1 - i64)
 type(1 .. 1)
-type(1 .. i)
 type(1 .. i64)
-type(1 / 1)
-type(1 / f32)
 type(1 / f64)
-type(1 < 1)
-type(1 < f32)
-type(1 < i)
-type(1 <= f32)
+type(1 / i)
+type(1 < i32)
+type(1 < i64)
+type(1 <= 0.5)
+type(1 <= 1)
 type(1 <= f64)
-type(1 <= i32)
-type(1 <= i64)
-type(1 == 1)
+type(1 <= i)
+type(1 == f32)
+type(1 == f64)
 type(1 == i)
+type(1 == i32)
 type(1 == i64)
-type(1 == nil)
-type(1 > 0.5)
-type(1 > 1)
-type(1 > f32)
-type(1 > f64)
+type(1 > i)
 type(1 >= 0.5)
-type(1 >= 1)
-type(1 >= f64)
 type(1 >= i)
-type(1 >= i32)
 type(1 >= i64)
-type(1 ^ 0.5)
-type(1 ^ f32)
+type(1 ^ 1)
+type(1 ^ i)
 type(1 ^ i64)
-type(1 in array)
-type(1 not in array)
-type(1) != toJSON(0.5)
-type(1) == nil ? 1 : f64
-type(1) endsWith greet("foo")
-type(1) in foo
-type(1) in foo != true
-type(1) not contains type(nil)
-type(1) not endsWith toJSON(ok)
-type([half, 1])
-type([nil])
+type(1) endsWith foo.Bar
+type(1) in reduce(list, #)
+type(1) not endsWith "bar" ? i64 : nil
+type(1) not startsWith string(0.5)
+type([div])
+type([f32])
 type(abs(0.5))
-type(abs(1))
+type(abs(f32))
 type(abs(f64))
 type(abs(i))
 type(abs(i32))
 type(abs(i64))
-type(add != add)
-type(add != greet)
-type(add != half)
-type(add == half)
-type(add == nil)
-type(add(1, 1))
 type(add)
-type(add) in foo
-type(all(array, true))
-type(all(list, false))
+type(all(array, ok))
+type(all(list, ok))
+type(all(list, true))
 type(any(array, false))
-type(any(list, true))
+type(any(array, ok))
+type(any(list, false))
+type(array != list)
+type(array != nil)
 type(array == array)
-type(array == list)
 type(array)
-type(array) in foo
-type(array) not in foo
+type(array) >= trimPrefix("foo")
 type(array[1])
 type(array[i32])
 type(array[i])
-type(count(list, ok))
-type(count(list, true))
+type(bitand(1, i))
+type(bitnot(i))
+type(bitnot(i32))
+type(bitnot(i64))
+type(bitxor(i64, 1))
+type(ceil(0.5))
+type(ceil(f32))
+type(ceil(f64))
+type(ceil(i64))
+type(count(array, true))
 type(div != div)
-type(div != half)
-type(div != nil)
-type(div == add)
-type(div == greet)
-type(div == half)
+type(div == div)
 type(div)
-type(div) not in foo
 type(f32 != 0.5)
 type(f32 != 1)
-type(f32 != f32)
-type(f32 != i32)
-type(f32 * 0.5)
 type(f32 * 1)
-type(f32 * f32)
-type(f32 * f64)
 type(f32 * i)
-type(f32 * i64)
-type(f32 ** 0.5)
-type(f32 ** 1)
+type(f32 * i32)
 type(f32 ** f32)
-type(f32 ** i)
-type(f32 ** i32)
-type(f32 + 0.5)
 type(f32 + 1)
-type(f32 + f64)
 type(f32 + i)
-type(f32 + i64)
-type(f32 - 0.5)
-type(f32 - 1)
 type(f32 - f32)
-type(f32 - i)
 type(f32 - i32)
-type(f32 - i64)
+type(f32 / 1)
+type(f32 / f32)
 type(f32 < 1)
-type(f32 < f64)
-type(f32 < i32)
-type(f32 <= 0.5)
-type(f32 <= 1)
-type(f32 <= i64)
+type(f32 < f32)
+type(f32 <= f64)
 type(f32 == 0.5)
-type(f32 == 1)
+type(f32 == f64)
+type(f32 == i)
 type(f32 == i32)
+type(f32 == i64)
 type(f32 > 1)
-type(f32 > f32)
-type(f32 > f64)
-type(f32 >= 0.5)
-type(f32 ^ 0.5)
-type(f32 ^ f32)
-type(f32 ^ f64)
-type(f32 ^ i32)
+type(f32 >= f32)
+type(f32 >= i)
+type(f32 >= i32)
 type(f32 ^ i64)
+type(f32 not in array)
 type(f32)
-type(f64 != f64)
-type(f64 != i64)
+type(f64 != 0.5)
+type(f64 != i)
 type(f64 * 0.5)
 type(f64 * 1)
-type(f64 * i32)
-type(f64 * i64)
-type(f64 ** 0.5)
+type(f64 * f32)
 type(f64 ** 1)
-type(f64 ** f32)
-type(f64 ** i)
-type(f64 ** i32)
-type(f64 + 0.5)
-type(f64 + f64)
-type(f64 + i)
+type(f64 + f32)
+type(f64 + i32)
 type(f64 - 0.5)
-type(f64 - f32)
+type(f64 - 1)
 type(f64 - f64)
 type(f64 - i)
 type(f64 / 1)
-type(f64 / i)
+type(f64 / f32)
+type(f64 / i64)
 type(f64 < 0.5)
-type(f64 < 1)
+type(f64 < f32)
 type(f64 < f64)
+type(f64 < i32)
 type(f64 < i64)
 type(f64 <= 0.5)
-type(f64 <= i)
-type(f64 <= i32)
-type(f64 == 1)
-type(f64 == f64)
+type(f64 <= f64)
+type(f64 <= i64)
+type(f64 == 0.5)
+type(f64 == f32)
+type(f64 == i64)
 type(f64 == nil)
-type(f64 > 1)
-type(f64 > f64)
 type(f64 > i)
 type(f64 > i32)
 type(f64 >= 0.5)
-type(f64 >= 1)
-type(f64 ^ 1)
-type(f64 ^ f64)
-type(f64 ^ i)
-type(f64 ^ i32)
-type(f64 ^ i64)
+type(f64 >= i)
+type(f64 ^ 0.5)
+type(f64 not in array)
 type(f64)
 type(false != nil)
+type(false != ok)
 type(false && true)
-type(false == ok)
-type(false ? add : div)
-type(false ? half : i)
-type(false ? half : i32)
-type(false ? i32 : 1)
-type(false ? i32 : true)
-type(false ? list : "foo")
-type(false || ok)
-type(false) not contains toJSON(i)
-type(filter(array, true))
-type(filter(list, false))
-type(find([f64], "foo" == nil))
+type(false ? "bar" : score)
+type(false ? div : f64)
+type(false ? half : greet)
+type(false ? true : foo)
+type(false || true)
+type(false) startsWith "bar" ? ok : f32
 type(find(array, false))
-type(find(list, false))
-type(findIndex(array, false))
-type(findIndex(list, ok))
-type(findIndex(list, true))
+type(find(array, true))
+type(find(list, true))
+type(findIndex(array, ok))
 type(findLast(array, false))
 type(findLast(array, ok))
-type(findLast(list, false))
-type(findLastIndex(array, ok))
-type(findLastIndex(array, true))
+type(findLastIndex(array, false))
+type(findLastIndex(list, false))
 type(findLastIndex(list, ok))
-type(first(array))
+type(findLastIndex(list, true))
 type(first(list))
-type(float(0.5))
-type(float(1))
 type(float(f32))
-type(float(f64))
-type(float(i))
 type(float(i32))
-type(float(i64))
+type(floor(0.5))
+type(floor(1))
+type(floor(f64))
+type(floor(i64))
 type(foo != foo)
+type(foo != nil)
 type(foo in list)
 type(foo)
-type(foo) in foo
 type(foo.Bar)
 type(foo.Qux)
 type(foo.String())
@@ -14753,182 +18021,142 @@ type(foo?.Qux)
 type(foo?.String())
 type(foo?.String)
 type(get(array, 1))
-type(get(array, i))
-type(get(array, i32))
+type(get(array, i64))
 type(get(list, 1))
+type(get(list, i))
 type(get(list, i32))
-type(greet != div)
-type(greet != half)
-type(greet != score)
-type(greet == div)
-type(greet == greet)
-type(greet == half)
+type(get(list, i64))
 type(greet("bar"))
 type(greet("foo"))
-type(greet(lower("foo")))
 type(greet)
-type(greet) not in foo
-type(half != add)
-type(half != nil)
-type(half == add)
-type(half == div)
+type(groupBy(array, #))
+type(groupBy(array, #).score)
+type(groupBy(array, 0.5))
+type(groupBy(array, false)?.add)
+type(groupBy(array, i))
+type(groupBy(array, i32))
+type(groupBy(array, i64))
+type(groupBy(list, "bar"))
+type(groupBy(list, #))
+type(groupBy(list, #)?.Bar)
+type(groupBy(list, 1))
+type(groupBy(list, i64))
+type(groupBy(list, true))
 type(half(0.5))
+type(half(1))
 type(half(f64))
 type(half)
-type(half) endsWith toJSON(1)
-type(i != 0.5)
-type(i != 1)
-type(i != f32)
-type(i != i64)
+type(half) not in foo
 type(i % 1)
+type(i % i32)
 type(i * 0.5)
-type(i * i64)
-type(i ** 0.5)
-type(i ** 1)
+type(i * i32)
 type(i ** f32)
 type(i ** f64)
 type(i ** i)
-type(i ** i32)
-type(i + 1)
-type(i + i)
 type(i + i32)
-type(i .. i64)
+type(i - 0.5)
+type(i - 1)
+type(i - i)
+type(i - i64)
+type(i .. i)
 type(i / 0.5)
-type(i / 1)
-type(i < f32)
-type(i < i64)
-type(i == f32)
-type(i == i32)
-type(i == i64)
-type(i > f64)
-type(i >= 1)
-type(i >= f32)
-type(i >= f64)
-type(i ^ 0.5)
+type(i / i32)
+type(i < 0.5)
+type(i < 1)
+type(i <= 0.5)
+type(i <= 1)
+type(i == 1)
+type(i > 0.5)
+type(i > 1)
+type(i > f32)
+type(i > i64)
+type(i >= i32)
 type(i ^ 1)
-type(i ^ f32)
-type(i ^ f64)
+type(i ^ i)
+type(i ^ i32)
 type(i ^ i64)
-type(i not in array)
 type(i)
-type(i) not endsWith greet("foo")
-type(i32 != 0.5)
+type(i) + foo.Bar
 type(i32 != 1)
-type(i32 != nil)
-type(i32 % 1)
-type(i32 % i64)
+type(i32 != f64)
 type(i32 * 0.5)
-type(i32 * 1)
-type(i32 * i32)
-type(i32 * i64)
-type(i32 ** f32)
+type(i32 * i)
+type(i32 ** 0.5)
 type(i32 ** f64)
 type(i32 ** i)
 type(i32 + 1)
-type(i32 + f32)
-type(i32 + f64)
-type(i32 + i)
-type(i32 + i32)
-type(i32 + i64)
-type(i32 - f32)
-type(i32 - i32)
-type(i32 .. 1)
-type(i32 .. i)
+type(i32 - 1)
+type(i32 .. i32)
+type(i32 / 0.5)
 type(i32 / f64)
-type(i32 / i32)
-type(i32 < 1)
-type(i32 < f32)
-type(i32 < i)
-type(i32 < i64)
+type(i32 < 0.5)
+type(i32 <= 0.5)
 type(i32 <= f64)
 type(i32 <= i32)
-type(i32 <= i64)
-type(i32 == 0.5)
 type(i32 == 1)
-type(i32 == f32)
-type(i32 == f64)
-type(i32 == i)
-type(i32 == i64)
+type(i32 == nil)
 type(i32 > 0.5)
-type(i32 > 1)
 type(i32 > f64)
-type(i32 > i32)
+type(i32 > i64)
 type(i32 >= 1)
 type(i32 >= f32)
-type(i32 >= i)
-type(i32 >= i32)
-type(i32 ^ 0.5)
+type(i32 >= i64)
+type(i32 ^ 1)
+type(i32 ^ f32)
+type(i32 ^ f64)
 type(i32 ^ i)
-type(i32 ^ i32)
-type(i32 ^ i64)
-type(i32 in array)
+type(i32 not in array)
 type(i32)
-type(i32) startsWith greet("foo")
+type(i32) in foo
+type(i32) not matches trim("foo")
 type(i64 != 1)
-type(i64 != array[i32])
-type(i64 != f32)
-type(i64 != i)
-type(i64 != nil)
-type(i64 % i)
-type(i64 % i64)
-type(i64 * 0.5)
+type(i64 != f64)
+type(i64 % 1)
 type(i64 * f32)
-type(i64 * f64)
 type(i64 * i64)
-type(i64 ** 1)
+type(i64 ** 0.5)
+type(i64 ** f64)
+type(i64 ** i32)
 type(i64 + 0.5)
-type(i64 + f64)
-type(i64 + i)
+type(i64 + 1)
 type(i64 + i64)
 type(i64 - 0.5)
-type(i64 .. 1)
+type(i64 - f32)
+type(i64 - f64)
+type(i64 - i32)
 type(i64 .. i32)
-type(i64 .. i64)
 type(i64 / 0.5)
-type(i64 / 1)
-type(i64 / i)
+type(i64 / f32)
 type(i64 / i64)
-type(i64 < 1)
+type(i64 < 0.5)
+type(i64 < f32)
 type(i64 < f64)
 type(i64 < i)
 type(i64 < i64)
+type(i64 <= 0.5)
 type(i64 <= 1)
 type(i64 <= f32)
-type(i64 <= i64)
-type(i64 == i32)
-type(i64 == nil)
-type(i64 > f64)
-type(i64 >= 0.5)
-type(i64 >= f32)
-type(i64 >= i)
-type(i64 >= i64)
-type(i64 ^ 0.5)
-type(i64 ^ 1)
-type(i64 ^ f32)
+type(i64 <= i)
+type(i64 == 1)
+type(i64 == f64)
+type(i64 > i64)
+type(i64 >= 1)
 type(i64 ^ f64)
 type(i64 ^ i)
-type(i64 ^ i32)
-type(i64 in array)
 type(i64 not in array)
 type(i64)
-type(i64) != foo?.Bar
-type(i64) contains string(foo) ? i : array
-type(i64) not in foo
-type(i64) not startsWith lower("foo")
 type(int(0.5))
-type(int(1))
 type(int(f32))
 type(int(f64))
 type(int(i))
 type(int(i32))
-type(int(i64) <= f32)
 type(int(i64))
 type(last(array))
 type(last(list))
-type(len("bar"))
-type(len("foo"))
 type(len(array))
 type(len(list))
+type(list != nil)
 type(list == array)
 type(list == nil)
 type(list)
@@ -14936,1423 +18164,1413 @@ type(list[1])
 type(list[i32])
 type(list[i64])
 type(list[i])
-type(lower("bar"))
-type(lower("foo"))
-type(lower(string(nil)))
+type(map(array, "bar"))
 type(map(array, "foo"))
 type(map(array, #))
-type(map(array, 0.5))
-type(map(array, add))
-type(map(array, array))
-type(map(array, false))
+type(map(array, 1))
+type(map(array, div))
+type(map(array, f32))
 type(map(array, foo))
-type(map(array, half))
-type(map(array, i))
-type(map(array, i64))
+type(map(array, greet))
 type(map(array, ok))
-type(map(i .. i32, i64))
+type(map(array, true))
+type(map(list, "bar"))
 type(map(list, #))
-type(map(list, 0.5))
-type(map(list, 1))
 type(map(list, array))
-type(map(list, f32))
-type(map(list, f64))
-type(map(list, foo))
 type(map(list, greet))
-type(map(list, i))
+type(map(list, i64))
 type(map(list, list))
 type(map(list, ok))
 type(max(0.5))
+type(max(0.5, f64))
 type(max(1))
-type(max(f32))
-type(max(f32, i32))
+type(max(1, i32))
 type(max(f64))
-type(max(f64, 0.5))
-type(max(i))
-type(max(i32))
-type(max(i32, i64))
 type(max(i64))
-type(min(0.5))
+type(median(array))
 type(min(1))
-type(min(1, 0.5))
-type(min(1, 1, f32))
 type(min(f32))
-type(min(f64))
 type(min(i))
-type(min(i, 1))
 type(min(i32))
-type(min(i32, 0.5))
 type(min(i64))
-type(nil != "bar")
+type(nil != "foo")
 type(nil != 0.5)
 type(nil != 1)
-type(nil != div)
-type(nil != f64)
-type(nil != false)
-type(nil != foo)
 type(nil != greet)
+type(nil != half)
 type(nil != i32)
+type(nil != i64)
 type(nil != nil)
-type(nil != ok)
-type(nil == "bar")
+type(nil != score)
 type(nil == "foo")
-type(nil == 0.5)
-type(nil == 1)
-type(nil == add)
 type(nil == array)
 type(nil == f32)
-type(nil == f64)
-type(nil == i)
-type(nil == i32)
+type(nil == false)
+type(nil == foo)
+type(nil == greet)
 type(nil == nil)
-type(nil == ok)
 type(nil == score)
-type(nil == true)
 type(nil in array)
+type(nil in list)
 type(nil not in array)
-type(nil) != type(1)
-type(none(array, ok))
-type(none(array, true))
+type(nil not in list)
 type(none(list, ok))
 type(none(list, true))
+type(not (f64 <= i))
 type(not false)
 type(not ok)
 type(not true)
+type(ok != false)
 type(ok != nil)
-type(ok == false)
-type(ok ? 0.5 : i32)
-type(ok ? 0.5 : list)
-type(ok ? 1 : f32)
-type(ok ? add : "bar")
-type(ok ? false : i64)
-type(ok ? foo : false)
-type(ok ? half : half)
-type(ok ? i32 : f64)
-type(ok ? i64 : "bar")
-type(ok ? list : "foo")
-type(ok ? ok : half)
-type(ok ? true : false)
+type(ok != true)
+type(ok && false)
+type(ok == nil)
+type(ok ? "bar" : half)
+type(ok ? 1 : "bar")
+type(ok ? array : i64)
+type(ok ? array : score)
+type(ok ? i : "bar")
+type(ok ? i : nil)
+type(ok ? nil : 0.5)
+type(ok ? nil : div)
 type(ok and ok)
-type(ok and true)
 type(ok or false)
-type(ok or true)
-type(ok || true)
+type(ok || false)
 type(ok)
-type(ok) in foo
-type(ok) not matches string(i64)
-type(ok) not startsWith lower("bar")
-type(score != div)
-type(score != greet)
-type(score != half)
-type(score != nil)
-type(score == add)
-type(score == foo.String)
-type(score == greet)
-type(score == half)
+type(one(array, false))
+type(one(array, true))
+type(one(list, false))
+type(one(list, true))
+type(reduce(array, "bar"))
+type(reduce(array, #))
+type(reduce(array, 1))
+type(reduce(array, foo))
+type(reduce(array, greet))
+type(reduce(array, i))
+type(reduce(array, ok))
+type(reduce(list, "foo"))
+type(reduce(list, #))
+type(reduce(list, array))
+type(reduce(list, i64))
+type(reduce(list, ok))
+type(round(0.5))
+type(round(1))
+type(round(f64))
+type(round(i))
+type(round(i64))
+type(score != score)
 type(score == nil)
-type(score == score)
 type(score(1))
+type(score(1, 1))
 type(score(i))
-type(score(i, 1))
 type(score)
-type(score) < foo?.Bar
-type(score) > string(score)
-type(score) in foo
-type(score) not contains type(1)
 type(sort(array))
-type(string("bar"))
-type(string("foo"))
 type(string(0.5))
 type(string(1))
 type(string(add))
-type(string(array))
 type(string(div))
+type(string(f32))
 type(string(f64))
 type(string(false))
-type(string(foo))
 type(string(greet))
-type(string(half))
-type(string(i <= i32))
-type(string(i))
+type(string(i32))
 type(string(i64))
 type(string(list))
 type(string(nil))
 type(string(ok))
 type(string(score))
-type(toBase64("foo"))
+type(toBase64("bar"))
 type(toJSON("bar"))
 type(toJSON("foo"))
-type(toJSON(0.5 < i))
 type(toJSON(0.5))
 type(toJSON(1))
 type(toJSON(array))
-type(toJSON(f32))
-type(toJSON(f64))
 type(toJSON(false))
-type(toJSON(foo))
+type(toJSON(i))
 type(toJSON(i32))
 type(toJSON(i64))
 type(toJSON(list))
 type(toJSON(nil))
-type(toJSON(ok))
-type(toJSON(true))
-type(trim("bar"))
 type(trim("foo"))
-type(trimPrefix("foo"))
-type(trimPrefix(toJSON(true)))
-type(trimSuffix("bar"))
+type(trimPrefix("bar"))
+type(true != nil)
 type(true == false)
 type(true == nil)
-type(true ? "bar" : 0.5)
-type(true ? div : 0.5)
-type(true ? f64 : array)
-type(true ? foo : foo)
-type(true ? foo : true)
-type(true ? greet : "foo")
-type(true ? list : ok)
-type(true ? nil : list)
-type(true ? nil : ok)
-type(true ? true : 1)
+type(true ? array : false)
+type(true ? array : half)
+type(true ? div : add)
+type(true ? f64 : i32)
+type(true ? ok : 1)
+type(true and false)
 type(true and true)
-type(true) endsWith toBase64("foo")
-type(type("bar"))
-type(type("foo"))
+type(true or true)
+type(true || ok)
+type(true || true)
+type(true) in foo
+type(true) matches string(list)
 type(type(0.5))
 type(type(1))
 type(type(add))
-type(type(array))
 type(type(div))
-type(type(f32))
-type(type(f64))
-type(type(false))
 type(type(foo))
+type(type(greet))
 type(type(half))
 type(type(i))
 type(type(i32))
 type(type(i64))
-type(type(list))
 type(type(nil))
 type(type(ok))
-type(type(score))
 type(type(true))
-type(upper("bar"))
 type(upper("foo"))
-type({"bar": 0.5})
 type({"bar": 1})
-type({"bar": greet})
-type({"foo": 0.5, "bar": foo})
-type({"foo": div})
-type({"foo": i64})
-type({"foo": nil})
-upper("bar" + "foo")
-upper("bar") <= type(nil)
-upper("bar") contains lower("foo")
-upper("foo" + "bar")
-upper(false ? 0.5 : "foo")
+type({"bar": array})
+type({"foo": "foo"})
+type({"foo": f64})
+type({"foo": false, "foo": foo}.Bar)
+upper("bar") not in foo
+upper("foo" + "foo")
+upper("foo") == toJSON("bar")
 upper(foo.Bar)
 upper(foo.String())
 upper(foo?.Bar)
 upper(foo?.String())
+upper(greet("bar"))
 upper(greet("foo"))
-upper(greet(string(ok)))
+upper(last(list).Bar)
 upper(lower("bar"))
-upper(ok ? "bar" : i)
-upper(string("bar"))
+upper(lower("foo"))
+upper(reduce(list, #)?.Bar)
 upper(string("foo"))
 upper(string(0.5))
 upper(string(1))
+upper(string(add))
 upper(string(array))
-upper(string(div))
 upper(string(f32))
-upper(string(f64))
-upper(string(foo))
-upper(string(greet))
-upper(string(half))
-upper(string(i))
 upper(string(i32))
 upper(string(i64))
 upper(string(list))
 upper(string(nil))
-upper(string(ok))
 upper(string(score))
-upper(string(string(0.5)))
 upper(string(true))
+upper(toBase64("bar"))
 upper(toBase64("foo"))
 upper(toJSON("foo"))
-upper(toJSON(0.5))
 upper(toJSON(1))
-upper(toJSON(array))
 upper(toJSON(f32))
-upper(toJSON(f64))
 upper(toJSON(false))
 upper(toJSON(foo))
 upper(toJSON(i))
 upper(toJSON(i32))
-upper(toJSON(i64))
 upper(toJSON(list))
 upper(toJSON(nil))
-upper(toJSON(ok))
 upper(toJSON(true))
 upper(trim("bar"))
-upper(trim("bar", "bar"))
 upper(trim("foo"))
-upper(trimPrefix("bar"))
-upper(trimPrefix("foo"))
 upper(trimSuffix("bar"))
 upper(trimSuffix("foo"))
-upper(true ? "bar" : f32)
-upper(true ? "foo" : i32)
 upper(type("bar"))
 upper(type("foo"))
-upper(type(0.5))
-upper(type(1))
-upper(type(add))
+upper(type(array))
 upper(type(div))
 upper(type(f32))
-upper(type(f64))
-upper(type(false))
-upper(type(foo))
+upper(type(foo.Bar))
 upper(type(greet))
-upper(type(half))
 upper(type(i))
-upper(type(i64))
+upper(type(i32))
 upper(type(list))
 upper(type(nil))
+upper(type(ok))
 upper(type(score))
 upper(type(true))
-upper(upper("bar"))
-values({"bar": f32})
-values({"bar": greet})
-values({"bar": i64})
-values({"foo": 1})
-values({"foo": div})
-values({"foo": false})
-values({"foo": foo, "foo": ok})
-values({"foo": list, "bar": 1})
-{"bar": !false}
-{"bar": !true}
-{"bar": "bar", "foo": nil}?.String
-{"bar": "bar", "foo": score}.i
-{"bar": "bar", "foo": true}?.i?.foo
-{"bar": "bar"}.add
+upper(upper("foo"))
+values(groupBy(array, "bar"))
+values(groupBy(array, "foo"))
+values(groupBy(array, #))
+values(groupBy(array, 0.5))
+values(groupBy(array, 1))
+values(groupBy(array, foo))
+values(groupBy(array, i))
+values(groupBy(list, #))
+values(groupBy(list, 1))
+values(groupBy(list, i))
+values(groupBy(list, i32))
+values(groupBy(list, true))
+values({"bar": "bar"})
+values({"bar": array})
+values({"foo": add, "bar": div})
+values({"foo": ok})
+{"bar": "bar" <= "foo"}
+{"bar": "bar", "bar": half}.add
+{"bar": "bar", "bar": i}.Qux
+{"bar": "bar", "bar": i}.String
+{"bar": "bar", "foo": 0.5}.i64
+{"bar": "bar", "foo": i64}?.Qux
+{"bar": "bar", "foo": score}.f32
+{"bar": "bar"}.String?.foo
 {"bar": "bar"}.array
-{"bar": "bar"}.f32
 {"bar": "bar"}.f64
+{"bar": "bar"}.greet
 {"bar": "bar"}.list
 {"bar": "bar"}.ok
-{"bar": "bar"}?.Bar
-{"bar": "bar"}?.greet
+{"bar": "bar"}?.Qux
+{"bar": "bar"}?.array
 {"bar": "bar"}?.half
-{"bar": "bar"}?.i
-{"bar": "foo", "foo": 0.5}.add
-{"bar": "foo", "foo": 1}.String?.ok
-{"bar": "foo", "foo": greet}.half
-{"bar": "foo", "foo": ok, "bar": f64}?.Bar
-{"bar": "foo", "foo": ok}.Qux
-{"bar": "foo", "foo": true}.ok
-{"bar": "foo"}.Qux
-{"bar": "foo"}.String
-{"bar": "foo"}.add
-{"bar": "foo"}.array
-{"bar": "foo"}.div
+{"bar": "bar"}?.list
+{"bar": "foo", "bar": div}.half
+{"bar": "foo", "foo": f32}.String
+{"bar": "foo", "foo": i64}.ok?.f64
+{"bar": "foo", "foo": ok}?.i64
+{"bar": "foo"}.Bar
 {"bar": "foo"}.f32
+{"bar": "foo"}.foo
+{"bar": "foo"}.half
 {"bar": "foo"}.i
 {"bar": "foo"}.i64
-{"bar": "foo"}.score
-{"bar": "foo"}?.Qux
-{"bar": "foo"}?.Qux?.score
 {"bar": "foo"}?.String
-{"bar": "foo"}?.div
+{"bar": "foo"}?.f32
 {"bar": "foo"}?.foo
+{"bar": "foo"}?.greet
+{"bar": "foo"}?.i
 {"bar": "foo"}?.i32
-{"bar": "foo"}?.i64
+{"bar": "foo"}?.i?.String()
+{"bar": "foo"}?.list
+{"bar": "foo"}?.ok
 {"bar": -0.5}
-{"bar": -1}
-{"bar": -1}?.array
 {"bar": -f32}
-{"bar": 0.5 * f64}
-{"bar": 0.5 + 1}
-{"bar": 0.5 - i32}
-{"bar": 0.5 - i64}
-{"bar": 0.5 < i64}
-{"bar": 0.5 == nil}
-{"bar": 0.5 > 1}.Qux
-{"bar": 0.5, "bar": "bar"}.ok
-{"bar": 0.5, "bar": 0.5}.f32
-{"bar": 0.5, "bar": 1}?.half
-{"bar": 0.5, "foo": array}?.ok
-{"bar": 0.5, "foo": i32, "bar": add}?.Bar
-{"bar": 0.5}.Bar
+{"bar": -f64}
+{"bar": -i32}
+{"bar": 0.5 != nil}
+{"bar": 0.5 * 1}.foo
+{"bar": 0.5, "bar": 0.5}.half
+{"bar": 0.5, "bar": add, "foo": i32}.list
+{"bar": 0.5, "bar": i}?.add
+{"bar": 0.5, "bar": list}?.div
+{"bar": 0.5, "bar": nil, "bar": nil}.i32
+{"bar": 0.5, "bar": ok, "foo": 1}?.String
+{"bar": 0.5, "bar": true}.score
+{"bar": 0.5, "foo": 0.5}?.f32
+{"bar": 0.5, "foo": array}?.list
+{"bar": 0.5, "foo": f32}.i32?.Bar
+{"bar": 0.5, "foo": ok}?.array
 {"bar": 0.5}.Qux
 {"bar": 0.5}.String
 {"bar": 0.5}.add
-{"bar": 0.5}.div
-{"bar": 0.5}.div?.array.foo
+{"bar": 0.5}.array
 {"bar": 0.5}.f32
 {"bar": 0.5}.f64
-{"bar": 0.5}.foo
-{"bar": 0.5}.greet
+{"bar": 0.5}.half
+{"bar": 0.5}.i
 {"bar": 0.5}.i32
+{"bar": 0.5}.i64
 {"bar": 0.5}.ok
-{"bar": 0.5}.score
 {"bar": 0.5}?.Bar
+{"bar": 0.5}?.Qux
 {"bar": 0.5}?.String
-{"bar": 0.5}?.add
-{"bar": 0.5}?.array
 {"bar": 0.5}?.div
-{"bar": 0.5}?.f32
 {"bar": 0.5}?.foo
-{"bar": 0.5}?.greet?.i32
+{"bar": 0.5}?.greet
 {"bar": 0.5}?.half
 {"bar": 0.5}?.i
 {"bar": 0.5}?.i32
-{"bar": 0.5}?.i32?.i32
 {"bar": 0.5}?.i64
-{"bar": 1 * i32}
+{"bar": 0.5}?.list
+{"bar": 0.5}?.score
 {"bar": 1 * i}
-{"bar": 1 + i32}
-{"bar": 1 - f32}
+{"bar": 1 ** 0.5}
 {"bar": 1 / 0.5}
-{"bar": 1 < f32}
-{"bar": 1 <= 1}
-{"bar": 1, "bar": "bar"}.i32
-{"bar": 1, "bar": array}?.f32
-{"bar": 1, "bar": false}.array
-{"bar": 1, "bar": greet, "foo": "bar"}?.i64
-{"bar": 1, "bar": i64}?.array
-{"bar": 1, "foo": 0.5}?.String
-{"bar": 1, "foo": add, "foo": f32}?.i
-{"bar": 1, "foo": foo}.div
-{"bar": 1, "foo": i64}.i64
-{"bar": 1}.Bar
-{"bar": 1}.Qux
+{"bar": 1 / f32}
+{"bar": 1 ^ 1}
+{"bar": 1, "bar": add, "foo": "bar"}?.add
+{"bar": 1, "bar": add}.div
+{"bar": 1, "bar": f32}?.Bar
+{"bar": 1, "bar": f64, "foo": array}.ok
+{"bar": 1, "foo": "bar"}.half
+{"bar": 1, "foo": array, "bar": score}?.i
+{"bar": 1, "foo": i}?.list
+{"bar": 1, "foo": i}?.ok
+{"bar": 1, "foo": ok}?.f32
+{"bar": 1, "foo": score}.f64
 {"bar": 1}.String
 {"bar": 1}.add
-{"bar": 1}.div
-{"bar": 1}.f64
+{"bar": 1}.f32
+{"bar": 1}.foo
 {"bar": 1}.greet
 {"bar": 1}.half
 {"bar": 1}.i
-{"bar": 1}.ok
-{"bar": 1}?.Bar
+{"bar": 1}.i32
+{"bar": 1}.list
+{"bar": 1}.score
+{"bar": 1}?.Qux
 {"bar": 1}?.add
-{"bar": 1}?.add?.i32
-{"bar": 1}?.div?.list
+{"bar": 1}?.div
 {"bar": 1}?.f32
 {"bar": 1}?.f64
 {"bar": 1}?.i
 {"bar": 1}?.i32
+{"bar": 1}?.i64
+{"bar": 1}?.list
 {"bar": 1}?.ok
-{"bar": ["bar", score]}
-{"bar": add, "bar": "foo"}.String?.array
-{"bar": add, "bar": 1}?.i64
-{"bar": add, "bar": div}?.f32
-{"bar": add, "bar": foo}
-{"bar": add, "bar": list}.Bar
-{"bar": add, "bar": score}.f64?.f64
-{"bar": add, "foo": "foo"}.i64
-{"bar": add, "foo": f64}?.score
-{"bar": add, "foo": i32}?.half
-{"bar": add, "foo": ok}
-{"bar": add, "foo": score}
+{"bar": add, "bar": half}.div
+{"bar": add, "bar": i, "bar": ok}?.foo
+{"bar": add, "bar": list}
+{"bar": add, "bar": ok, "foo": 1}?.ok
+{"bar": add, "foo": "foo"}?.f64
 {"bar": add}
 {"bar": add}.Qux
 {"bar": add}.String
-{"bar": add}.f64
-{"bar": add}.foo
-{"bar": add}.greet
-{"bar": add}.i32
-{"bar": add}.list
+{"bar": add}.add
+{"bar": add}.array
+{"bar": add}.div
+{"bar": add}.half
+{"bar": add}?.Qux
 {"bar": add}?.String
 {"bar": add}?.add
+{"bar": add}?.array
 {"bar": add}?.div
-{"bar": add}?.i
-{"bar": add}?.i64
-{"bar": add}?.score
-{"bar": any(array, false)}
-{"bar": any(list, ok)}
-{"bar": array, "bar": f64}
-{"bar": array, "bar": false, "bar": i}?.Qux
-{"bar": array, "bar": false}.Qux
-{"bar": array, "bar": half}.i32
-{"bar": array, "bar": i64}.i64
-{"bar": array, "bar": score}
-{"bar": array, "foo": "foo"}?.array
-{"bar": array, "foo": add == add}
-{"bar": array, "foo": count(list, true)}.add
+{"bar": add}?.f64
+{"bar": add}?.f64 != half
+{"bar": add}?.half
+{"bar": add}?.ok
+{"bar": add}?.score?.div
+{"bar": array, "bar": "bar"}?.i
+{"bar": array, "bar": array}?.foo
+{"bar": array, "bar": f32}
+{"bar": array, "bar": nil}.i64
+{"bar": array, "foo": f32}?.String
+{"bar": array, "foo": f64}
+{"bar": array, "foo": half}?.add
+{"bar": array, "foo": i32}
+{"bar": array, "foo": score}
 {"bar": array}
 {"bar": array}.Bar
-{"bar": array}.Qux
-{"bar": array}.String
-{"bar": array}.add
-{"bar": array}.f32
-{"bar": array}.half?.foo
+{"bar": array}.div
+{"bar": array}.div?.Qux
+{"bar": array}.greet
 {"bar": array}.i
 {"bar": array}.i64
-{"bar": array}?.Bar
+{"bar": array}.list
+{"bar": array}.score
+{"bar": array}?.add?.ok
 {"bar": array}?.div
+{"bar": array}?.f64
 {"bar": array}?.greet
 {"bar": array}?.half
-{"bar": array}?.i32
 {"bar": array}?.i64
 {"bar": array}?.ok
-{"bar": div != greet}
-{"bar": div, "bar": "bar", "bar": foo}.greet
-{"bar": div, "bar": "bar", "foo": 1}?.div
-{"bar": div, "bar": greet}?.i32
-{"bar": div, "bar": i32}?.array
-{"bar": div, "foo": div}?.list
-{"bar": div, "foo": greet, "foo": 1}?.score?.Qux
-{"bar": div, "foo": i}?.i
-{"bar": div, "foo": list}.f64
-{"bar": div, "foo": ok}?.i64
+{"bar": div, "bar": array, "bar": 0.5}.i64
+{"bar": div, "bar": div}?.f32
+{"bar": div, "bar": foo}.foo
+{"bar": div, "bar": ok}
+{"bar": div, "foo": 1, "bar": ok}.Qux
+{"bar": div, "foo": false}?.String
+{"bar": div, "foo": foo, "foo": score}.Bar
+{"bar": div, "foo": greet}.i
+{"bar": div, "foo": greet}?.ok
 {"bar": div, "foo": score}
 {"bar": div}
-{"bar": div}.add
-{"bar": div}.div
+{"bar": div}.array
 {"bar": div}.f32
-{"bar": div}.f32?.score
-{"bar": div}.half
-{"bar": div}.i32
-{"bar": div}.i64
-{"bar": div}.score
-{"bar": div}?.div
-{"bar": div}?.div?.f32
-{"bar": div}?.foo
+{"bar": div}.f64
+{"bar": div}.i64?.Qux
+{"bar": div}.list
+{"bar": div}.ok
+{"bar": div}?.Bar
+{"bar": div}?.array
+{"bar": div}?.f64
+{"bar": div}?.greet
 {"bar": div}?.half
-{"bar": div}?.i
-{"bar": div}?.i64
 {"bar": div}?.list
 {"bar": div}?.ok
-{"bar": f32 ** 1}
-{"bar": f32 - i32}
-{"bar": f32, "bar": true, "bar": list}?.Bar
-{"bar": f32, "foo": i32}
-{"bar": f32, "foo": ok, "foo": f32}.half
-{"bar": f32, "foo": score}?.greet
+{"bar": div}?.score
+{"bar": f32 ** i}
+{"bar": f32 - 0.5}
+{"bar": f32 >= 0.5}
+{"bar": f32 ^ 1}
+{"bar": f32, "bar": "foo"}.add
+{"bar": f32, "bar": false}?.Bar
+{"bar": f32, "bar": true}?.String
+{"bar": f32, "foo": add, "foo": false}?.String
+{"bar": f32, "foo": f32}.ok
+{"bar": f32, "foo": f64}
+{"bar": f32, "foo": half, "foo": ok}
+{"bar": f32, "foo": half}
+{"bar": f32, "foo": list}?.f32
+{"bar": f32, "foo": nil}?.f64?.foo
 {"bar": f32}
-{"bar": f32}.Bar
-{"bar": f32}.Qux?.i64
-{"bar": f32}.String
-{"bar": f32}.add
-{"bar": f32}.half
-{"bar": f32}.list
-{"bar": f32}?.String?.score
+{"bar": f32}.Qux
+{"bar": f32}.div
+{"bar": f32}.f64
+{"bar": f32}.greet
+{"bar": f32}.i
+{"bar": f32}.i32
+{"bar": f32}.i64
+{"bar": f32}?.Bar
+{"bar": f32}?.String
+{"bar": f32}?.array
 {"bar": f32}?.f64
-{"bar": f32}?.foo
-{"bar": f32}?.i32
-{"bar": f32}?.i64
+{"bar": f32}?.half
 {"bar": f32}?.list
-{"bar": f32}?.score
-{"bar": f64, "bar": 0.5}.div
-{"bar": f64, "bar": i}
-{"bar": f64, "bar": nil}?.f64
-{"bar": f64, "foo": "foo"}?.half
-{"bar": f64, "foo": 0.5, "bar": foo}?.half
-{"bar": f64, "foo": f64}.foo
-{"bar": f64, "foo": i32}
+{"bar": f64 + 1}
+{"bar": f64 == i32}
+{"bar": f64 > 0.5}
+{"bar": f64 ^ i32}
+{"bar": f64, "bar": "bar"}.i
+{"bar": f64, "bar": foo}?.i
+{"bar": f64, "bar": i64}?.i64
+{"bar": f64, "bar": i}.f64
+{"bar": f64, "bar": true}?.i
+{"bar": f64, "foo": 0.5, "foo": score}.ok
+{"bar": f64, "foo": 1}.f32
+{"bar": f64, "foo": f64}?.score
+{"bar": f64, "foo": i}?.Qux?.f64
 {"bar": f64}
-{"bar": f64}.String
-{"bar": f64}.div?.String()
-{"bar": f64}.f32
+{"bar": f64}.array
+{"bar": f64}.f32?.Bar
 {"bar": f64}.f64
-{"bar": f64}.f64?.list
-{"bar": f64}.greet
-{"bar": f64}.half
+{"bar": f64}.foo
 {"bar": f64}.i
+{"bar": f64}.i32
 {"bar": f64}.ok
 {"bar": f64}?.Bar
-{"bar": f64}?.Qux
-{"bar": f64}?.f64
-{"bar": f64}?.half
-{"bar": f64}?.i32
+{"bar": f64}?.Bar?.Qux
+{"bar": f64}?.add
+{"bar": f64}?.div
+{"bar": f64}?.f32
+{"bar": f64}?.foo
+{"bar": f64}?.i
 {"bar": f64}?.i64
-{"bar": f64}?.score
-{"bar": false, "bar": 0.5, "bar": foo}.add
-{"bar": false, "foo": greet, "foo": i64}.div
-{"bar": false}.add
-{"bar": false}.div
+{"bar": f64}?.list
+{"bar": f64}?.ok
+{"bar": false, "bar": array}?.list
+{"bar": false, "bar": i32}?.div
+{"bar": false, "bar": i}?.i64
+{"bar": false, "bar": nil}.ok
+{"bar": false}.Bar
+{"bar": false}.Qux
+{"bar": false}.array
+{"bar": false}.f32
 {"bar": false}.f64
-{"bar": false}.foo
-{"bar": false}.greet
 {"bar": false}.half
+{"bar": false}.i
 {"bar": false}.i32
-{"bar": false}.list
 {"bar": false}.ok
 {"bar": false}.score
+{"bar": false}?.Bar
 {"bar": false}?.array
-{"bar": false}?.greet
-{"bar": false}?.i32
-{"bar": false}?.ok?.Qux?.score()
-{"bar": false}?.score
-{"bar": first(list)}
-{"bar": float(f32)}
-{"bar": foo, "bar": 0.5}.div
-{"bar": foo, "bar": div}.array
-{"bar": foo, "bar": half}
-{"bar": foo, "bar": list}.f32
-{"bar": foo, "foo": greet}?.div
-{"bar": foo, "foo": i32}.score
-{"bar": foo, "foo": true}?.f32
+{"bar": false}?.div
+{"bar": false}?.foo
+{"bar": false}?.half
+{"bar": false}?.i
+{"bar": false}?.list
+{"bar": false}?.ok
+{"bar": filter(list, ok)}
+{"bar": float(0.5)}
+{"bar": floor(0.5)}.score
+{"bar": floor(i32)}
+{"bar": foo != nil, "foo": array}
+{"bar": foo, "bar": "foo", "bar": score}?.score
+{"bar": foo, "bar": 1, "bar": score}?.ok
+{"bar": foo, "bar": greet}
+{"bar": foo, "bar": i}?.i
+{"bar": foo, "bar": score}?.ok
+{"bar": foo, "foo": 0.5, "foo": ok}?.half
+{"bar": foo, "foo": 0.5}.score
+{"bar": foo, "foo": 1, "foo": i}?.add
+{"bar": foo, "foo": f64}
+{"bar": foo, "foo": f64}.Bar
 {"bar": foo.Bar}
 {"bar": foo.String()}
-{"bar": foo?.Qux}?.foo
+{"bar": foo?.Qux, "bar": f32}
 {"bar": foo?.String}
 {"bar": foo}
-{"bar": foo}.Qux
-{"bar": foo}.String
+{"bar": foo}.Bar
 {"bar": foo}.array
-{"bar": foo}.div
-{"bar": foo}.f64
+{"bar": foo}.f32
 {"bar": foo}.half
-{"bar": foo}.half?.list(i32).array
 {"bar": foo}.i
 {"bar": foo}.list
 {"bar": foo}.ok
-{"bar": foo}?.div
-{"bar": foo}?.f64
+{"bar": foo}?.Bar
+{"bar": foo}?.add
 {"bar": foo}?.greet
 {"bar": foo}?.i
+{"bar": foo}?.i32
 {"bar": foo}?.i64
 {"bar": foo}?.list
-{"bar": greet, "bar": foo}
-{"bar": greet, "bar": nil}.f64
-{"bar": greet, "foo": foo}
+{"bar": foo}?.ok
+{"bar": foo}?.score
+{"bar": get(list, i32)}
+{"bar": greet("foo")}
+{"bar": greet, "bar": 0.5}.i32
+{"bar": greet, "bar": 1}.Bar
+{"bar": greet, "bar": f32}.Bar
+{"bar": greet, "bar": i32}
+{"bar": greet, "bar": not ok}
+{"bar": greet, "foo": "bar"}.ok
+{"bar": greet, "foo": f64}
+{"bar": greet, "foo": false, "bar": ok}.i32
+{"bar": greet, "foo": i32}
 {"bar": greet}
-{"bar": greet}.Qux
-{"bar": greet}.add
+{"bar": greet}.Bar
 {"bar": greet}.array
-{"bar": greet}.div
-{"bar": greet}.foo
-{"bar": greet}.i
-{"bar": greet}.i32
-{"bar": greet}.ok
-{"bar": greet}.score
-{"bar": greet}?.Bar
-{"bar": greet}?.String
-{"bar": greet}?.add
+{"bar": greet}.f32
+{"bar": greet}.greet
+{"bar": greet}.half
+{"bar": greet}.list
+{"bar": greet}?.Qux
+{"bar": greet}?.div
 {"bar": greet}?.f32
-{"bar": greet}?.foo?.foo
+{"bar": greet}?.f64
+{"bar": greet}?.greet
 {"bar": greet}?.half
-{"bar": greet}?.i
-{"bar": greet}?.list
+{"bar": greet}?.i32
 {"bar": greet}?.ok
-{"bar": half(0.5), "bar": ok}
-{"bar": half(0.5)}
-{"bar": half(0.5)}?.array
-{"bar": half, "bar": "foo", "bar": ok}?.String
-{"bar": half, "bar": array}?.div?.i32
-{"bar": half, "bar": div}
-{"bar": half, "bar": f32}
-{"bar": half, "bar": greet}?.i64
+{"bar": greet}?.score
+{"bar": groupBy(array, f32)}
+{"bar": half == nil}
+{"bar": half(f64)}
+{"bar": half, "bar": add, "bar": f64}?.i32
+{"bar": half, "bar": foo}
 {"bar": half, "bar": list}
-{"bar": half, "bar": score, "bar": i == f32}
 {"bar": half, "bar": score}
-{"bar": half, "foo": array}
-{"bar": half, "foo": f64 == i64}
-{"bar": half, "foo": greet}
-{"bar": half, "foo": i64}.array
-{"bar": half, "foo": list}?.list?.ok
+{"bar": half, "foo": 1}?.i64
+{"bar": half, "foo": list}
+{"bar": half, "foo": ok, "bar": i}
+{"bar": half, "foo": ok}.Qux
+{"bar": half, "foo": true}?.String
 {"bar": half}
+{"bar": half}.Bar?.i
+{"bar": half}.Qux
 {"bar": half}.String
-{"bar": half}.String?.score
+{"bar": half}.div?.i
+{"bar": half}.f32
+{"bar": half}.foo
 {"bar": half}.half
 {"bar": half}.i32
-{"bar": half}.i64
-{"bar": half}.ok
-{"bar": half}.score
-{"bar": half}?.Qux
-{"bar": half}?.Qux?.f32
-{"bar": half}?.div
+{"bar": half}.list
+{"bar": half}.list?.String()
+{"bar": half}?.Bar
+{"bar": half}?.String
+{"bar": half}?.array
 {"bar": half}?.f32
-{"bar": half}?.foo?.f32()
-{"bar": half}?.half
-{"bar": half}?.half?.f32
-{"bar": half}?.i
-{"bar": i ** 0.5}
-{"bar": i + i64}
-{"bar": i .. i32}
-{"bar": i .. i}
-{"bar": i > i32}
-{"bar": i >= 0.5, "bar": array}
-{"bar": i >= i}
-{"bar": i, "bar": 0.5}?.Qux
-{"bar": i, "bar": foo}.foo
-{"bar": i, "bar": nil}?.f32
-{"bar": i, "foo": 1 >= f64}
-{"bar": i, "foo": array}.array
-{"bar": i, "foo": f64}.i64
-{"bar": i, "foo": greet}?.foo
-{"bar": i32 + 0.5}
-{"bar": i32 < i32}
-{"bar": i32 <= f64}
-{"bar": i32, "bar": "foo"}?.half
-{"bar": i32, "foo": f64}?.foo
-{"bar": i32, "foo": foo, "foo": i32}?.i32?.String()
-{"bar": i32, "foo": i64, "bar": true}?.i64
-{"bar": i32, "foo": i64}.half
-{"bar": i32, "foo": list}
-{"bar": i32, "foo": score, "foo": 1}.array
-{"bar": i32, "foo": score, "foo": greet}.add
-{"bar": i32, "foo": score, "foo": ok}.foo
+{"bar": half}?.greet
+{"bar": half}?.i32
+{"bar": half}?.list
+{"bar": i % i32}
+{"bar": i ** f64}
+{"bar": i < 1}?.half
+{"bar": i, "bar": 1}.add
+{"bar": i, "bar": 1}?.i64
+{"bar": i, "bar": array}?.half
+{"bar": i, "bar": div}.ok
+{"bar": i, "bar": f64, "bar": "foo"}?.foo
+{"bar": i, "bar": f64, "bar": nil}.i32
+{"bar": i, "bar": score}
+{"bar": i, "foo": half}
+{"bar": i, "foo": i32}?.score
+{"bar": i, "foo": nil}?.String
+{"bar": i32 ^ 0.5}
+{"bar": i32 ^ f64}
+{"bar": i32, "bar": list}
+{"bar": i32, "foo": "bar"}.i64
+{"bar": i32, "foo": array}.div
+{"bar": i32, "foo": f64, "foo": add}.f64
+{"bar": i32, "foo": foo}?.add
+{"bar": i32, "foo": ok}.ok
 {"bar": i32}
-{"bar": i32}.Bar
+{"bar": i32}.Qux
+{"bar": i32}.f64
 {"bar": i32}.i
-{"bar": i32}.i64
+{"bar": i32}.i32
 {"bar": i32}.list
-{"bar": i32}.score?.f32
-{"bar": i32}?.String
+{"bar": i32}.ok
+{"bar": i32}.score
+{"bar": i32}?.Qux
+{"bar": i32}?.add
+{"bar": i32}?.array
 {"bar": i32}?.div
 {"bar": i32}?.f32
-{"bar": i32}?.foo
-{"bar": i32}?.greet
-{"bar": i32}?.half
-{"bar": i32}?.i
-{"bar": i32}?.list?.list
+{"bar": i32}?.i32
+{"bar": i32}?.list
 {"bar": i32}?.ok
-{"bar": i32}?.score
-{"bar": i64 != f32, "bar": score}
-{"bar": i64 ** f64}
-{"bar": i64 / f64}
-{"bar": i64, "bar": "bar", "foo": i64}.array
-{"bar": i64, "bar": foo}.list
-{"bar": i64, "bar": greet, "foo": score}.array
-{"bar": i64, "bar": half}?.f64
-{"bar": i64, "bar": i64}?.Qux?.array()
-{"bar": i64, "bar": list}
-{"bar": i64, "foo": "foo"}.Bar
-{"bar": i64, "foo": 0.5, "foo": list}.i64
-{"bar": i64, "foo": f32, "foo": nil}.i32
-{"bar": i64, "foo": f32}?.half
-{"bar": i64, "foo": i, "foo": greet}.array
-{"bar": i64, "foo": nil}.add
-{"bar": i64, "foo": nil}?.Qux
+{"bar": i64 + 1}
+{"bar": i64 <= 0.5}
+{"bar": i64 == 0.5}
+{"bar": i64 in array}
+{"bar": i64, "bar": !ok}
+{"bar": i64, "bar": 0.5}.f32
+{"bar": i64, "bar": greet}.array
+{"bar": i64, "bar": score}.ok
+{"bar": i64, "foo": nil}?.i32
+{"bar": i64, "foo": ok}
+{"bar": i64, "foo": ok}?.f32
 {"bar": i64}
-{"bar": i64}.add
-{"bar": i64}.array
+{"bar": i64}.array?.Bar
 {"bar": i64}.div
-{"bar": i64}.div?.i64
 {"bar": i64}.f32
-{"bar": i64}.foo
-{"bar": i64}.greet
-{"bar": i64}.i64
+{"bar": i64}.f64
+{"bar": i64}.i
 {"bar": i64}.list
 {"bar": i64}.ok
-{"bar": i64}?.Qux
-{"bar": i64}?.String
-{"bar": i64}?.array
-{"bar": i64}?.array?.foo
+{"bar": i64}.score
 {"bar": i64}?.div
 {"bar": i64}?.f32
-{"bar": i64}?.i64
+{"bar": i64}?.f64
+{"bar": i64}?.half
+{"bar": i64}?.i
+{"bar": i64}?.i32
+{"bar": i64}?.i?.ok
 {"bar": i64}?.list
-{"bar": i64}?.ok
-{"bar": i64}?.score
+{"bar": int(f64)}
 {"bar": i}
-{"bar": i}.Bar
-{"bar": i}.String
+{"bar": i}.add
 {"bar": i}.array
-{"bar": i}.div
+{"bar": i}.div?.Qux.div
 {"bar": i}.f64
-{"bar": i}.foo
-{"bar": i}.greet
 {"bar": i}.half
 {"bar": i}.i
-{"bar": i}.i32
 {"bar": i}.i64
-{"bar": i}.list?.list
-{"bar": i}?.Qux
+{"bar": i}.list
 {"bar": i}?.String
-{"bar": i}?.add
+{"bar": i}?.array
+{"bar": i}?.f64
 {"bar": i}?.foo
 {"bar": i}?.greet
-{"bar": i}?.list
-{"bar": list, "bar": 1}?.f64
-{"bar": list, "bar": div}
-{"bar": list, "bar": f32, "bar": i64}.Bar
-{"bar": list, "bar": f32, "bar": ok}.add
-{"bar": list, "bar": f64}.foo
-{"bar": list, "bar": false, "bar": 1}?.f32
-{"bar": list, "bar": i32}.half
-{"bar": list, "bar": ok}
-{"bar": list, "foo": div, "foo": ok}?.i64
-{"bar": list, "foo": f64, "foo": list}.half
-{"bar": list, "foo": half}?.Qux
-{"bar": list, "foo": i}
-{"bar": list, "foo": list}
-{"bar": list, "foo": ok, "foo": f64}?.half
+{"bar": i}?.i
+{"bar": i}?.i32
+{"bar": i}?.i64
+{"bar": i}?.score
+{"bar": list == nil}
+{"bar": list, "bar": half}?.Bar
+{"bar": list, "bar": score}
+{"bar": list, "foo": "foo"}.String
+{"bar": list, "foo": 1, "foo": nil}.score
+{"bar": list, "foo": 1, "foo": score}?.array
+{"bar": list, "foo": array}?.i64
+{"bar": list, "foo": f64}.div?.Qux
+{"bar": list, "foo": f64}.list
+{"bar": list, "foo": half}?.f32
+{"bar": list, "foo": i64}?.array
+{"bar": list, "foo": nil}.i64
+{"bar": list[i32:i32]}
 {"bar": list}
-{"bar": list}.Bar
+{"bar": list}.String
 {"bar": list}.add
-{"bar": list}.f32
+{"bar": list}.array
+{"bar": list}.array?.i64
 {"bar": list}.f64
 {"bar": list}.greet
-{"bar": list}.score
+{"bar": list}.i
+{"bar": list}.list
+{"bar": list}?.Bar
+{"bar": list}?.Qux
 {"bar": list}?.add
-{"bar": list}?.add?.array
 {"bar": list}?.div
-{"bar": list}?.half
-{"bar": list}?.i32
-{"bar": list}?.list
+{"bar": list}?.f64
+{"bar": list}?.i64
 {"bar": list}?.score
-{"bar": map(list, i32)}
-{"bar": min(0.5)}
-{"bar": min(f32)}
+{"bar": lower("bar")}
+{"bar": map(array, #)}
+{"bar": map(array, i)}
+{"bar": map(list, #)}
 {"bar": nil != "bar"}
-{"bar": nil != false}
-{"bar": nil == "foo"}
-{"bar": nil == 1}
-{"bar": nil == f64}
-{"bar": nil, "bar": div}.f32
-{"bar": nil, "bar": greet, "foo": "bar"}?.i64
-{"bar": nil, "bar": greet}.score
-{"bar": nil, "bar": i}.f64
-{"bar": nil, "foo": 0.5}?.array
-{"bar": nil, "foo": f64}?.add
-{"bar": nil, "foo": half}?.foo
-{"bar": nil}.String
+{"bar": nil != nil}
+{"bar": nil == 0.5}
+{"bar": nil == nil}
+{"bar": nil, "bar": "bar"}?.i32
+{"bar": nil, "bar": add, "bar": i}.add
+{"bar": nil, "bar": foo}?.list
+{"bar": nil, "foo": "foo"}.f64
+{"bar": nil, "foo": 1, "foo": add}.ok
+{"bar": nil, "foo": foo}?.add
+{"bar": nil, "foo": i}?.f64
+{"bar": nil, "foo": list}?.f32
+{"bar": nil}.Bar
 {"bar": nil}.add
-{"bar": nil}.array
+{"bar": nil}.div
 {"bar": nil}.f32
 {"bar": nil}.foo
+{"bar": nil}.greet
 {"bar": nil}.half
-{"bar": nil}?.Bar
+{"bar": nil}.i
+{"bar": nil}.i32
+{"bar": nil}.i32?.greet
+{"bar": nil}.i64
+{"bar": nil}.i?.f64
+{"bar": nil}.list
+{"bar": nil}.ok
+{"bar": nil}?.Qux
+{"bar": nil}?.String
 {"bar": nil}?.add
-{"bar": nil}?.array
+{"bar": nil}?.div
 {"bar": nil}?.f32
 {"bar": nil}?.f64
-{"bar": nil}?.foo
-{"bar": nil}?.foo?.i32
-{"bar": nil}?.greet
 {"bar": nil}?.half
+{"bar": nil}?.i
 {"bar": nil}?.i32
-{"bar": nil}?.i64
 {"bar": nil}?.list
 {"bar": nil}?.ok
-{"bar": ok or ok}
-{"bar": ok || ok}
-{"bar": ok, "bar": list}
-{"bar": ok, "bar": nil == half}.f64
-{"bar": ok, "foo": div, "bar": "bar"}.Qux
-{"bar": ok, "foo": i32, "bar": 1}.score
+{"bar": none(list, ok)}
+{"bar": not true}
+{"bar": ok ? "bar" : i}
+{"bar": ok ? i32 : "foo"}
+{"bar": ok ? nil : greet}
+{"bar": ok, "bar": 1, "foo": f64}.half
+{"bar": ok, "bar": array}
+{"bar": ok, "bar": i64, "foo": 1}?.Qux
+{"bar": ok, "bar": i}
+{"bar": ok, "bar": list}?.div
+{"bar": ok, "bar": ok}.f32
+{"bar": ok, "foo": 0.5}?.score
+{"bar": ok, "foo": 1}.i
+{"bar": ok, "foo": greet}
+{"bar": ok, "foo": half}
+{"bar": ok, "foo": list}
+{"bar": ok, "foo": list}?.f64
+{"bar": ok, "foo": nil}?.i32
+{"bar": ok, "foo": ok}.div
 {"bar": ok}
-{"bar": ok}.String
-{"bar": ok}.add
-{"bar": ok}.array
-{"bar": ok}.i
+{"bar": ok}.Bar
+{"bar": ok}.div
+{"bar": ok}.f32
+{"bar": ok}.greet
+{"bar": ok}.i32
 {"bar": ok}.i64
+{"bar": ok}.list
 {"bar": ok}.ok
+{"bar": ok}.score
 {"bar": ok}?.Qux
-{"bar": ok}?.array
-{"bar": ok}?.f64
-{"bar": ok}?.foo
-{"bar": ok}?.greet
-{"bar": ok}?.i
+{"bar": ok}?.add
+{"bar": ok}?.f32
 {"bar": ok}?.i32
 {"bar": ok}?.i64
-{"bar": score != score}
-{"bar": score, "bar": 0.5}?.Bar
-{"bar": score, "bar": div}
-{"bar": score, "bar": foo}
-{"bar": score, "bar": i64}.div
-{"bar": score, "bar": i}
-{"bar": score, "foo": greet}
+{"bar": ok}?.list
+{"bar": ok}?.score
+{"bar": one(list, false)}
+{"bar": reduce(array, i)}.i64
+{"bar": reduce(list, half)}
+{"bar": score(i)}
+{"bar": score, "bar": "bar", "bar": "foo"}?.f32
+{"bar": score, "bar": add}.String
+{"bar": score, "bar": i64}.f32
+{"bar": score, "bar": nil}.i
+{"bar": score, "foo": div}
+{"bar": score, "foo": foo}.i
+{"bar": score, "foo": half, "foo": i}?.array
+{"bar": score, "foo": half}
+{"bar": score, "foo": score}?.greet
 {"bar": score}
-{"bar": score}.Bar
 {"bar": score}.add
 {"bar": score}.array
 {"bar": score}.div
 {"bar": score}.f64
-{"bar": score}.i32
-{"bar": score}.i64
+{"bar": score}.foo
+{"bar": score}.half
 {"bar": score}.list
-{"bar": score}.ok
-{"bar": score}.score
+{"bar": score}?.String
+{"bar": score}?.array
 {"bar": score}?.f32
-{"bar": score}?.f64
+{"bar": score}?.foo
+{"bar": score}?.half
+{"bar": score}?.i
 {"bar": score}?.i32
 {"bar": score}?.list
 {"bar": score}?.score
-{"bar": string(array)}
-{"bar": toJSON(array)}
-{"bar": toJSON(i)}.i64?.i64
-{"bar": toJSON(i32)}
-{"bar": true, "bar": false}.Bar
-{"bar": true, "bar": foo}?.String
-{"bar": true, "foo": 0.5}?.i
-{"bar": true, "foo": div}.score
-{"bar": true, "foo": foo}.div
+{"bar": string(0.5)}
+{"bar": string(i64)}
+{"bar": string(ok)}
+{"bar": toJSON(list)}
+{"bar": true == false}
+{"bar": true, "bar": f64}?.score
+{"bar": true, "bar": i32}.array
+{"bar": true, "foo": nil}?.f32
 {"bar": true}.Bar
-{"bar": true}.Qux?.greet()
-{"bar": true}.f32
-{"bar": true}.f64
+{"bar": true}.Qux
+{"bar": true}.String
+{"bar": true}.div
 {"bar": true}.half
-{"bar": true}.i
-{"bar": true}.list?.String()
-{"bar": true}.score
+{"bar": true}.i32
 {"bar": true}?.Bar
+{"bar": true}?.add
+{"bar": true}?.array
+{"bar": true}?.div
+{"bar": true}?.half
+{"bar": true}?.i32
 {"bar": true}?.i64
-{"bar": true}?.list
-{"bar": type(f64)}
-{"bar": type(greet)}
-{"bar": {"foo": "bar", "bar": "bar", "bar": nil}}
-{"foo": "bar", "bar": i32}.half
-{"foo": "bar", "bar": nil}?.add?.i64
+{"bar": type(greet)}.Bar
+{"bar": type(half)}
+{"bar": type(score)}
+{"foo": !ok}
+{"foo": "bar" < "bar"}
+{"foo": "bar" > "bar"}
+{"foo": "bar", "bar": list}.div
+{"foo": "bar", "bar": nil}.f64
+{"foo": "bar", "foo": 0.5}?.add
+{"foo": "bar", "foo": 0.5}?.list
+{"foo": "bar", "foo": array}?.f64?.list()
+{"foo": "bar", "foo": list}.list
 {"foo": "bar"}.Bar
 {"foo": "bar"}.Qux
 {"foo": "bar"}.String
-{"foo": "bar"}.array
-{"foo": "bar"}.f64
+{"foo": "bar"}.foo
 {"foo": "bar"}.half
 {"foo": "bar"}.i
 {"foo": "bar"}.i64
-{"foo": "bar"}.list
-{"foo": "bar"}.ok
+{"foo": "bar"}?.Bar
+{"foo": "bar"}?.String
 {"foo": "bar"}?.add
-{"foo": "bar"}?.div?.ok
+{"foo": "bar"}?.array
+{"foo": "bar"}?.div
+{"foo": "bar"}?.f32
 {"foo": "bar"}?.f64
 {"foo": "bar"}?.foo
 {"foo": "bar"}?.half
-{"foo": "foo" != "bar"}
-{"foo": "foo", "bar": nil}?.String
-{"foo": "foo", "foo": add, "foo": "foo"}?.i
-{"foo": "foo", "foo": div}.i64
-{"foo": "foo", "foo": greet}.array
-{"foo": "foo", "foo": i, "bar": greet}?.score
-{"foo": "foo", "foo": i32, "bar": f32}.greet
-{"foo": "foo", "foo": i}?.foo
-{"foo": "foo", "foo": list}.f32
-{"foo": "foo"}.Bar
-{"foo": "foo"}.array
+{"foo": "bar"}?.i32
+{"foo": "bar"}?.score
+{"foo": "foo" <= "foo"}
+{"foo": "foo" endsWith "foo"}
+{"foo": "foo", "bar": false}.greet
+{"foo": "foo", "bar": half}?.String
+{"foo": "foo", "bar": list, "bar": div}?.String
+{"foo": "foo", "foo": add}?.f32
+{"foo": "foo"}.Qux
+{"foo": "foo"}.div
 {"foo": "foo"}.f32
-{"foo": "foo"}.foo
-{"foo": "foo"}.greet
-{"foo": "foo"}.i64
-{"foo": "foo"}?.Bar
-{"foo": "foo"}?.add
+{"foo": "foo"}.i
+{"foo": "foo"}.i32
+{"foo": "foo"}.list
 {"foo": "foo"}?.div
-{"foo": "foo"}?.greet
-{"foo": "foo"}?.half
+{"foo": "foo"}?.f32
+{"foo": "foo"}?.foo
+{"foo": "foo"}?.i
+{"foo": "foo"}?.i32
 {"foo": "foo"}?.score
+{"foo": -0.5}
 {"foo": -1}
+{"foo": -f64}
 {"foo": -i64}
-{"foo": -i}
-{"foo": 0.5 ** i64}
-{"foo": 0.5 - 0.5}
+{"foo": 0.5 != 0.5}
+{"foo": 0.5 ** f64}
+{"foo": 0.5 < i64}.div
 {"foo": 0.5 <= 0.5}
-{"foo": 0.5 > i64}
-{"foo": 0.5, "bar": 1}.half
-{"foo": 0.5, "bar": add}.Bar
-{"foo": 0.5, "bar": div}.array
-{"foo": 0.5, "bar": i32}?.String
-{"foo": 0.5, "bar": score, "foo": score}.half
-{"foo": 0.5, "foo": 1, "foo": list}.div
-{"foo": 0.5, "foo": nil}?.div
-{"foo": 0.5, "foo": nil}?.i64
-{"foo": 0.5}.Bar
-{"foo": 0.5}.Qux
+{"foo": 0.5, "bar": 0.5}.String
+{"foo": 0.5, "bar": 0.5}.foo
+{"foo": 0.5, "bar": 0.5}?.score
+{"foo": 0.5, "bar": 1}?.div
+{"foo": 0.5, "bar": i64}.i32
+{"foo": 0.5, "bar": list}?.i64
+{"foo": 0.5, "foo": 1}.Qux
+{"foo": 0.5, "foo": array}.i64
+{"foo": 0.5, "foo": f64}.i
+{"foo": 0.5, "foo": false, "bar": list}.add
+{"foo": 0.5, "foo": greet}.i32
+{"foo": 0.5, "foo": score}.foo
+{"foo": 0.5}.Qux?.half
+{"foo": 0.5}.String
+{"foo": 0.5}.add
 {"foo": 0.5}.array
+{"foo": 0.5}.div
 {"foo": 0.5}.f32
-{"foo": 0.5}.f64
-{"foo": 0.5}.greet
 {"foo": 0.5}.half
-{"foo": 0.5}.i
 {"foo": 0.5}.i64
 {"foo": 0.5}.list
-{"foo": 0.5}.ok
-{"foo": 0.5}?.Bar?.i
+{"foo": 0.5}.score
+{"foo": 0.5}?.Bar
 {"foo": 0.5}?.String
-{"foo": 0.5}?.add
-{"foo": 0.5}?.array
-{"foo": 0.5}?.array?.score
-{"foo": 0.5}?.foo
-{"foo": 0.5}?.greet
+{"foo": 0.5}?.div
+{"foo": 0.5}?.f32
+{"foo": 0.5}?.f64
 {"foo": 0.5}?.half
-{"foo": 0.5}?.i64
+{"foo": 0.5}?.i
+{"foo": 0.5}?.list
 {"foo": 0.5}?.ok
-{"foo": 1 + 0.5}
-{"foo": 1 / 0.5}
 {"foo": 1 / i64}
-{"foo": 1 < i32}?.i64
-{"foo": 1 not in array}
-{"foo": 1, "bar": 0.5}.array
-{"foo": 1, "bar": div}.f32
-{"foo": 1, "bar": f32}.Qux?.half?.list
-{"foo": 1, "bar": i64, "foo": 0.5}.list
-{"foo": 1, "bar": i64}?.ok
-{"foo": 1, "bar": score}.foo
-{"foo": 1, "foo": 0.5}.f32
-{"foo": 1, "foo": array}?.array
-{"foo": 1, "foo": ok}.add
-{"foo": 1, "foo": true}?.Qux
+{"foo": 1 == f32}
+{"foo": 1, "bar": nil}?.add
+{"foo": 1, "bar": score}.greet
+{"foo": 1, "foo": 1}.f64
+{"foo": 1, "foo": f64}.i
+{"foo": 1, "foo": false}?.f32
+{"foo": 1, "foo": half}?.f32
+{"foo": 1, "foo": ok}.Bar
+{"foo": 1, "foo": ok}.f32
+{"foo": 1, "foo": ok}.i32
+{"foo": 1, "foo": score}.half
+{"foo": 1}.Bar
 {"foo": 1}.add
+{"foo": 1}.div
 {"foo": 1}.f32
+{"foo": 1}.f64
 {"foo": 1}.foo
 {"foo": 1}.greet
 {"foo": 1}.half
+{"foo": 1}.i
 {"foo": 1}.i64
 {"foo": 1}.list
-{"foo": 1}.ok
-{"foo": 1}?.Bar
+{"foo": 1}?.String
 {"foo": 1}?.add
-{"foo": 1}?.div
-{"foo": 1}?.f32
-{"foo": 1}?.foo
+{"foo": 1}?.f64
 {"foo": 1}?.greet
 {"foo": 1}?.half
-{"foo": 1}?.i
-{"foo": 1}?.i32
-{"foo": 1}?.score
-{"foo": abs(0.5)}
-{"foo": add, "bar": 0.5}.i
-{"foo": add, "bar": nil}.score
-{"foo": add, "bar": ok}
-{"foo": add, "bar": score}.half
-{"foo": add, "foo": "bar"}?.String
-{"foo": add, "foo": half, "foo": div}?.greet
-{"foo": add, "foo": i32}.foo
-{"foo": add, "foo": nil}?.list
+{"foo": 1}?.list
+{"foo": 1}?.ok
+{"foo": abs(i64)}
+{"foo": add, "bar": half}
+{"foo": add, "bar": nil}.i
+{"foo": add, "bar": nil}?.i
+{"foo": add, "bar": ok, "foo": array}?.i32
+{"foo": add, "foo": 1, "bar": i32}.add
+{"foo": add, "foo": array}?.f32
+{"foo": add, "foo": foo}?.i64
+{"foo": add, "foo": half}
+{"foo": add, "foo": score, "bar": i32}.list
 {"foo": add}
-{"foo": add}.Bar
+{"foo": add}.array
 {"foo": add}.div
+{"foo": add}.f32
 {"foo": add}.foo
 {"foo": add}.half
 {"foo": add}.i
-{"foo": add}.i64
+{"foo": add}.i32
+{"foo": add}.i?.score
 {"foo": add}.list
-{"foo": add}.ok
+{"foo": add}?.Bar
+{"foo": add}?.Qux
 {"foo": add}?.String
-{"foo": add}?.array
 {"foo": add}?.div
+{"foo": add}?.f32
+{"foo": add}?.foo
 {"foo": add}?.greet
 {"foo": add}?.half
-{"foo": add}?.i32
-{"foo": add}?.ok
-{"foo": array, "bar": "foo"}?.f32
-{"foo": array, "bar": f64}
-{"foo": array, "bar": greet}
-{"foo": array, "bar": list}?.f32
-{"foo": array, "bar": ok}
-{"foo": array, "foo": add}
-{"foo": array, "foo": greet}
-{"foo": array, "foo": true}?.i
+{"foo": add}?.i
+{"foo": add}?.i64
+{"foo": add}?.score
+{"foo": array, "bar": "bar"}.add
+{"foo": array, "bar": 0.5}?.div
+{"foo": array, "bar": add}.ok
+{"foo": array, "bar": array}.f32
+{"foo": array, "bar": i64}?.add
+{"foo": array, "bar": list}
+{"foo": array, "bar": nil}.half
+{"foo": array, "bar": ok, "bar": i}
+{"foo": array, "foo": "foo"}.array
+{"foo": array, "foo": array}
+{"foo": array, "foo": f32, "foo": half}.ok
+{"foo": array, "foo": f64}
+{"foo": array, "foo": list}
 {"foo": array}
+{"foo": array}.Bar
 {"foo": array}.Qux
-{"foo": array}.Qux?.String
-{"foo": array}.String
-{"foo": array}.f64
+{"foo": array}.f32
+{"foo": array}.foo
 {"foo": array}.greet
+{"foo": array}.i
 {"foo": array}.i32
-{"foo": array}.ok
-{"foo": array}?.Bar
-{"foo": array}?.String
+{"foo": array}.i64
+{"foo": array}.score
+{"foo": array}?.Qux
 {"foo": array}?.add
 {"foo": array}?.array
-{"foo": array}?.div
-{"foo": array}?.f64
-{"foo": array}?.half
+{"foo": array}?.greet
+{"foo": array}?.i64?.add
+{"foo": array}?.list
 {"foo": array}?.ok
-{"foo": div, "bar": 1}?.add
-{"foo": div, "bar": add}
-{"foo": div, "bar": div}
-{"foo": div, "bar": half}.half
-{"foo": div, "bar": list, "bar": 0.5}?.Qux
-{"foo": div, "foo": array}.Bar
-{"foo": div, "foo": true}?.Qux
+{"foo": div, "bar": "foo"}.array
+{"foo": div, "bar": array}
+{"foo": div, "bar": foo, "foo": true}?.i64
+{"foo": div, "bar": half}
+{"foo": div, "bar": i64}
+{"foo": div, "foo": array}
+{"foo": div, "foo": f32}
+{"foo": div, "foo": greet}?.i64
 {"foo": div}
 {"foo": div}.Qux
 {"foo": div}.array
 {"foo": div}.div
-{"foo": div}.foo
-{"foo": div}.greet
+{"foo": div}.f32
+{"foo": div}.greet?.i
+{"foo": div}.i32
+{"foo": div}.i64
 {"foo": div}?.Bar
 {"foo": div}?.Qux
 {"foo": div}?.String
-{"foo": div}?.add
-{"foo": div}?.f64
+{"foo": div}?.div
+{"foo": div}?.greet
 {"foo": div}?.half
-{"foo": div}?.i
+{"foo": div}?.i32
 {"foo": div}?.i64
 {"foo": div}?.list
-{"foo": div}?.ok
-{"foo": f32 != i}
-{"foo": f32 - f32}
-{"foo": f32 == 0.5}
-{"foo": f32, "bar": "bar"}?.String
-{"foo": f32, "bar": 0.5}.f32
-{"foo": f32, "bar": i32}
-{"foo": f32, "bar": list}
-{"foo": f32, "foo": 1, "foo": i32}?.i32
-{"foo": f32, "foo": div}
-{"foo": f32, "foo": i}
-{"foo": f32, "foo": ok}?.i
-{"foo": f32, "foo": type("bar")}
+{"foo": div}?.score
+{"foo": f32 > 1}
+{"foo": f32 >= 1}
+{"foo": f32, "bar": 0.5}.list
+{"foo": f32, "bar": div}
+{"foo": f32, "bar": f32}
+{"foo": f32, "bar": f64}
+{"foo": f32, "bar": greet}.greet
+{"foo": f32, "bar": half}
+{"foo": f32, "bar": ok}?.add
+{"foo": f32, "bar": score}?.i64
+{"foo": f32, "foo": "foo"}.ok
+{"foo": f32, "foo": add}?.half?.f64()
+{"foo": f32, "foo": foo}?.half
 {"foo": f32}
-{"foo": f32}.String
+{"foo": f32}.Qux
 {"foo": f32}.add
-{"foo": f32}.array
 {"foo": f32}.f32
 {"foo": f32}.foo
 {"foo": f32}.greet
 {"foo": f32}.half
 {"foo": f32}.i
 {"foo": f32}.i32
+{"foo": f32}.i64
 {"foo": f32}.list
+{"foo": f32}.score?.greet
 {"foo": f32}?.Bar
-{"foo": f32}?.Qux
-{"foo": f32}?.add
-{"foo": f32}?.f32
-{"foo": f32}?.f64
-{"foo": f32}?.half
-{"foo": f32}?.i32
-{"foo": f32}?.score
-{"foo": f64 * i}
-{"foo": f64 / 1}
-{"foo": f64 == 0.5}
-{"foo": f64 >= 1}
-{"foo": f64 ^ f32}
-{"foo": f64, "bar": "foo"}.Qux
-{"foo": f64, "bar": "foo"}.add
-{"foo": f64, "bar": 0.5}.div
-{"foo": f64, "bar": div}
-{"foo": f64, "bar": greet}
-{"foo": f64, "bar": half}?.list
-{"foo": f64, "bar": ok}.half
-{"foo": f64, "foo": foo, "bar": greet}.String
-{"foo": f64, "foo": foo, "foo": "foo"}.Bar
-{"foo": f64, "foo": greet}
-{"foo": f64, "foo": ok, "foo": i64}?.f64
+{"foo": f32}?.String
+{"foo": f32}?.array
+{"foo": f32}?.f64?.i
+{"foo": f32}?.i
+{"foo": f32}?.ok
+{"foo": f64 < f64}
+{"foo": f64 > f32}
+{"foo": f64 >= 0.5}
+{"foo": f64 >= f32}
+{"foo": f64 in array}
+{"foo": f64, "bar": 0.5}.greet
+{"foo": f64, "bar": add, "foo": greet}.Bar
+{"foo": f64, "bar": list}.i64
+{"foo": f64, "bar": sum(array)}
+{"foo": f64, "bar": true}?.greet
+{"foo": f64, "foo": list, "foo": i}?.add
 {"foo": f64}
+{"foo": f64}.Bar
 {"foo": f64}.Qux
-{"foo": f64}.String?.f32
-{"foo": f64}.String?.i64
-{"foo": f64}.add
-{"foo": f64}.array
+{"foo": f64}.div
+{"foo": f64}.f32
 {"foo": f64}.f64
-{"foo": f64}.foo
 {"foo": f64}.greet
-{"foo": f64}.i
+{"foo": f64}.i32
 {"foo": f64}.list
-{"foo": f64}?.Bar
+{"foo": f64}.ok
 {"foo": f64}?.String
-{"foo": f64}?.div
 {"foo": f64}?.f32
 {"foo": f64}?.f64
 {"foo": f64}?.foo
 {"foo": f64}?.greet
-{"foo": f64}?.i
+{"foo": f64}?.i32
+{"foo": f64}?.i64
 {"foo": f64}?.ok
-{"foo": false, "foo": greet}?.add
-{"foo": false, "foo": ok}.score
-{"foo": false}.Bar
+{"foo": f64}?.ok?.ok
+{"foo": f64}?.score
+{"foo": false or false}.array
+{"foo": false, "bar": 0.5, "foo": add}.score
+{"foo": false, "foo": foo, "bar": half}.array
+{"foo": false, "foo": score, "foo": nil}?.div
+{"foo": false, "foo": true}?.i32
 {"foo": false}.array
-{"foo": false}.div
-{"foo": false}.half
 {"foo": false}.i
-{"foo": false}?.array
+{"foo": false}.ok
 {"foo": false}?.f32
 {"foo": false}?.f64
-{"foo": false}?.foo
-{"foo": false}?.i64
 {"foo": false}?.list
-{"foo": foo, "bar": add, "foo": foo}.Bar
-{"foo": foo, "bar": ok, "foo": array}.String
-{"foo": foo, "foo": foo}
-{"foo": foo, "foo": list, "foo": greet}.i
-{"foo": foo, "foo": nil}?.f32
-{"foo": foo, "foo": true}?.array
+{"foo": foo == nil}
+{"foo": foo, "bar": div}
+{"foo": foo, "bar": foo}
+{"foo": foo, "bar": ok}.i32
+{"foo": foo, "bar": {"foo": 1}}
+{"foo": foo, "foo": add}
+{"foo": foo, "foo": half}
+{"foo": foo, "foo": i}
+{"foo": foo, "foo": ok}
+{"foo": foo, "foo": score, "foo": f64}.i
+{"foo": foo.Bar}
+{"foo": foo.String, "bar": foo}
+{"foo": foo.String}
+{"foo": foo?.Bar}
 {"foo": foo?.Qux}
+{"foo": foo?.String()}
+{"foo": foo?.String}
 {"foo": foo}
-{"foo": foo}.div
-{"foo": foo}.f64
+{"foo": foo}.Bar?.Bar
+{"foo": foo}.Qux
+{"foo": foo}.String
+{"foo": foo}.String?.String
+{"foo": foo}.f32
 {"foo": foo}.greet
-{"foo": foo}.list
-{"foo": foo}.ok
-{"foo": foo}.score
-{"foo": foo}?.String
+{"foo": foo}.half
+{"foo": foo}.i64
+{"foo": foo}?.Qux
+{"foo": foo}?.add
 {"foo": foo}?.array
-{"foo": foo}?.div
-{"foo": foo}?.f32
-{"foo": foo}?.foo
+{"foo": foo}?.array?.Bar
+{"foo": foo}?.f64
 {"foo": foo}?.greet
-{"foo": foo}?.half
+{"foo": foo}?.i32
 {"foo": foo}?.list
 {"foo": foo}?.ok
-{"foo": get(array, i32)}?.i64
-{"foo": greet, "bar": 0.5, "bar": "foo"}?.half
-{"foo": greet, "bar": 0.5}.Bar
-{"foo": greet, "bar": f64}
-{"foo": greet, "bar": f64}.list
-{"foo": greet, "bar": i, "foo": foo}?.f32
-{"foo": greet, "foo": "bar", "foo": score}.i
-{"foo": greet, "foo": f32}
+{"foo": greet("foo")}
+{"foo": greet, "bar": "bar"}?.i32
+{"foo": greet, "bar": i64}
+{"foo": greet, "bar": i}.list
+{"foo": greet, "foo": add}.String
+{"foo": greet, "foo": nil}?.add
 {"foo": greet}
+{"foo": greet}.Bar
 {"foo": greet}.Qux
 {"foo": greet}.String
 {"foo": greet}.add
 {"foo": greet}.array
-{"foo": greet}.f32?.greet
-{"foo": greet}.half?.greet
+{"foo": greet}.f32
+{"foo": greet}.i
+{"foo": greet}.i32
 {"foo": greet}.i64
-{"foo": greet}.list
+{"foo": greet}.i64?.greet
 {"foo": greet}.ok
-{"foo": greet}?.add
+{"foo": greet}.score
+{"foo": greet}?.Qux
 {"foo": greet}?.array
+{"foo": greet}?.div
 {"foo": greet}?.f32
-{"foo": greet}?.half
+{"foo": greet}?.f64
 {"foo": greet}?.i32
 {"foo": greet}?.i64
 {"foo": greet}?.list
+{"foo": greet}?.ok
 {"foo": greet}?.score
-{"foo": half(0.5)}
-{"foo": half(f64)}
-{"foo": half, "bar": 1}?.half
-{"foo": half, "bar": add}?.foo
-{"foo": half, "bar": f32}.i32
-{"foo": half, "bar": foo}
-{"foo": half, "bar": half}
-{"foo": half, "bar": i64, "bar": i32}.foo
-{"foo": half, "bar": i64}
-{"foo": half, "bar": nil}?.ok
-{"foo": half, "foo": 1}?.ok
-{"foo": half, "foo": div}
-{"foo": half, "foo": greet, "bar": f32}?.add
-{"foo": half, "foo": true}.f64
+{"foo": groupBy(array, 1)}
+{"foo": groupBy(list, #)}
+{"foo": half, "bar": "foo"}?.half
+{"foo": half, "bar": add, "foo": true}?.array
+{"foo": half, "bar": array}.half
+{"foo": half, "bar": greet}?.half
+{"foo": half, "bar": half}?.i
+{"foo": half, "bar": list, "foo": 1}?.f64
+{"foo": half, "bar": list}
+{"foo": half, "bar": true}?.Qux
+{"foo": half, "foo": 1}?.i32
+{"foo": half, "foo": div, "foo": array}?.i32
+{"foo": half, "foo": f64}
+{"foo": half, "foo": list, "foo": half}.half
+{"foo": half, "foo": score, "foo": list}.String
 {"foo": half}
 {"foo": half}.Bar
 {"foo": half}.String
+{"foo": half}.add
 {"foo": half}.div
-{"foo": half}.f64
-{"foo": half}.greet
+{"foo": half}.f32
+{"foo": half}.foo
 {"foo": half}.half
 {"foo": half}.i
-{"foo": half}.i32
+{"foo": half}.i64
 {"foo": half}.ok
+{"foo": half}.score
 {"foo": half}?.Bar
 {"foo": half}?.Qux
-{"foo": half}?.add
-{"foo": half}?.f64
+{"foo": half}?.String
+{"foo": half}?.div
+{"foo": half}?.f32
 {"foo": half}?.foo
-{"foo": half}?.greet
-{"foo": half}?.half
-{"foo": half}?.list
+{"foo": half}?.i32
+{"foo": half}?.i64
 {"foo": half}?.score
-{"foo": hasPrefix("bar", "foo")}
-{"foo": i < f64}
-{"foo": i > 0.5}
-{"foo": i, "bar": score}
-{"foo": i, "foo": i}.i64
-{"foo": i, "foo": ok}
-{"foo": i, "foo": ok}?.ok
-{"foo": i32, "bar": 0.5, "foo": array}.Bar
-{"foo": i32, "bar": i32}.i64
-{"foo": i32, "bar": nil}?.i64
-{"foo": i32, "foo": 0.5}.i
-{"foo": i32, "foo": add}
-{"foo": i32, "foo": div, "foo": nil}.Bar
-{"foo": i32, "foo": foo}
-{"foo": i32, "foo": greet}?.foo
-{"foo": i32, "foo": i32}?.score
-{"foo": i32, "foo": ok, "bar": true}.f32
-{"foo": i32, "foo": ok}?.i32
+{"foo": i != 1}
+{"foo": i - f64}
+{"foo": i / 1}
+{"foo": i ^ 1}
+{"foo": i, "bar": 0.5}?.half
+{"foo": i, "bar": f32}
+{"foo": i, "bar": foo}
+{"foo": i, "bar": list}.foo
+{"foo": i, "foo": "bar"}?.div?.f32
+{"foo": i, "foo": 1}.list
+{"foo": i, "foo": 1}?.list
+{"foo": i, "foo": add}
+{"foo": i, "foo": array, "bar": 0.5}?.f32
+{"foo": i, "foo": half}?.list
+{"foo": i, "foo": score}
+{"foo": i, "foo": score}?.f32
+{"foo": i32 != i}
+{"foo": i32 * 0.5}
+{"foo": i32 + 1}
+{"foo": i32 - f32}.foo
+{"foo": i32 - f64}
+{"foo": i32 / 1}
+{"foo": i32 < 1}
+{"foo": i32, "bar": 0.5, "bar": foo}.i64
+{"foo": i32, "bar": foo}?.score
+{"foo": i32, "bar": nil}?.ok
+{"foo": i32, "foo": false, "bar": f32}?.foo
+{"foo": i32, "foo": greet}?.greet
 {"foo": i32}
-{"foo": i32}.Bar
-{"foo": i32}.Qux
-{"foo": i32}.i64
-{"foo": i32}.list
+{"foo": i32}.i
 {"foo": i32}.ok
-{"foo": i32}.score
 {"foo": i32}?.Bar
-{"foo": i32}?.Qux
+{"foo": i32}?.String
 {"foo": i32}?.add
-{"foo": i32}?.div
 {"foo": i32}?.f32
-{"foo": i32}?.greet
-{"foo": i32}?.half
+{"foo": i32}?.f64
 {"foo": i32}?.i
+{"foo": i32}?.i32
 {"foo": i32}?.i64
+{"foo": i32}?.list
 {"foo": i32}?.score
-{"foo": i64 * f64, "foo": i64}
-{"foo": i64 <= 0.5}
-{"foo": i64 ^ i32}
-{"foo": i64, "bar": "bar"}.Qux
-{"foo": i64, "bar": array}.add
-{"foo": i64, "bar": div}
-{"foo": i64, "bar": f64, "bar": greet}.f32
-{"foo": i64, "bar": list}
-{"foo": i64, "foo": 0.5, "bar": 0.5}.half
-{"foo": i64, "foo": div}
-{"foo": i64, "foo": i32}
+{"foo": i64 % 1}
+{"foo": i64 * f32}
+{"foo": i64 .. i64}
+{"foo": i64, "bar": array}
+{"foo": i64, "foo": array}.f32
+{"foo": i64, "foo": f32}
+{"foo": i64, "foo": i32}?.foo
+{"foo": i64, "foo": i64, "bar": f64}.foo
+{"foo": i64, "foo": i64}
+{"foo": i64, "foo": i64}.greet
+{"foo": i64, "foo": i64}?.foo
 {"foo": i64}
-{"foo": i64}.Qux
-{"foo": i64}.add
+{"foo": i64}.Bar
 {"foo": i64}.array
+{"foo": i64}.div
+{"foo": i64}.foo
+{"foo": i64}.greet
+{"foo": i64}.half
+{"foo": i64}.i
+{"foo": i64}.i32
+{"foo": i64}.list
 {"foo": i64}?.Qux
-{"foo": i64}?.String
+{"foo": i64}?.add
+{"foo": i64}?.array
 {"foo": i64}?.f32
-{"foo": i64}?.foo
-{"foo": i64}?.greet
+{"foo": i64}?.f64
+{"foo": i64}?.half
 {"foo": i64}?.i32
-{"foo": i64}?.list
-{"foo": i64}?.score
+{"foo": i64}?.i32?.f32
+{"foo": i64}?.i64
+{"foo": i64}?.score?.list
+{"foo": int(i)}
+{"foo": int(i32)}
+{"foo": int(i64)}
 {"foo": i}
 {"foo": i}.Bar
 {"foo": i}.String
-{"foo": i}.div
-{"foo": i}.foo
+{"foo": i}.add
+{"foo": i}.array
+{"foo": i}.f64
 {"foo": i}.greet
-{"foo": i}.i32?.add
+{"foo": i}.i
 {"foo": i}.ok
-{"foo": i}.score
-{"foo": i}?.Bar
-{"foo": i}?.array
 {"foo": i}?.div
-{"foo": i}?.f64
-{"foo": i}?.foo
-{"foo": i}?.half
+{"foo": i}?.greet
+{"foo": i}?.i
+{"foo": i}?.i32
 {"foo": i}?.i64
 {"foo": i}?.score
-{"foo": list == list}.f32
-{"foo": list, "bar": f32, "foo": i32}.i32
-{"foo": list, "bar": foo}?.list
-{"foo": list, "bar": i64}
-{"foo": list, "bar": score}
-{"foo": list, "foo": score}
+{"foo": last(list)}
+{"foo": len(list)}
+{"foo": list, "bar": add}
+{"foo": list, "bar": all(list, false)}
+{"foo": list, "bar": array}
+{"foo": list, "bar": f32}.f64
+{"foo": list, "bar": half}
+{"foo": list, "bar": i32, "bar": score}.array
+{"foo": list, "bar": true}?.foo
 {"foo": list}
-{"foo": list}.Bar
+{"foo": list}.Qux
 {"foo": list}.String
 {"foo": list}.add
 {"foo": list}.div
-{"foo": list}.foo
+{"foo": list}.f32
+{"foo": list}.greet
 {"foo": list}.half
+{"foo": list}.i
 {"foo": list}.i32
-{"foo": list}.score
-{"foo": list}?.add
+{"foo": list}?.String
 {"foo": list}?.div
+{"foo": list}?.f32
+{"foo": list}?.foo
 {"foo": list}?.i
+{"foo": list}?.i32
 {"foo": list}?.i64
 {"foo": list}?.ok
+{"foo": list}?.score
 {"foo": map(array, #)}
-{"foo": map(array, 0.5)}
-{"foo": map(array, foo)}
-{"foo": map(array, ok), "bar": i32}
-{"foo": map(list, 0.5)}
-{"foo": map(list, score)}
-{"foo": min(0.5)}
-{"foo": min(1)}?.f32
-{"foo": nil == 0.5}
-{"foo": nil, "bar": 0.5}.score
-{"foo": nil, "bar": add}?.array
-{"foo": nil, "bar": div}.Bar
-{"foo": nil, "bar": f64, "foo": div}.i32
-{"foo": nil, "bar": greet}?.add
-{"foo": nil, "bar": i64}?.i64
-{"foo": nil, "bar": list}?.i32
-{"foo": nil, "foo": "foo"}.add
-{"foo": nil, "foo": 1}.score
-{"foo": nil, "foo": false}?.add
-{"foo": nil, "foo": i64}.add
-{"foo": nil}.Bar
-{"foo": nil}.Qux
-{"foo": nil}.String
-{"foo": nil}.array
+{"foo": map(array, i64)}
+{"foo": nil, "bar": 0.5}.ok
+{"foo": nil, "bar": add, "bar": f32}?.list
+{"foo": nil, "bar": div, "bar": 1}.i64
+{"foo": nil, "bar": f32}.score
+{"foo": nil, "bar": foo}?.String
+{"foo": nil, "bar": score}?.ok?.div
+{"foo": nil, "foo": "foo"}.Bar
+{"foo": nil, "foo": greet}.String
+{"foo": nil, "foo": half}.f64
+{"foo": nil, "foo": i64, "bar": f64}?.list
+{"foo": nil, "foo": i}.div
+{"foo": nil, "foo": list}.add
+{"foo": nil, "foo": list}?.array
+{"foo": nil, "foo": nil}.ok
+{"foo": nil}.array?.half()
 {"foo": nil}.div
 {"foo": nil}.f32
 {"foo": nil}.f64
-{"foo": nil}.greet?.i()
-{"foo": nil}.greet?.i32
 {"foo": nil}.half
 {"foo": nil}.i
-{"foo": nil}.i64
+{"foo": nil}.i32
+{"foo": nil}.i64?.Bar()
 {"foo": nil}.list
+{"foo": nil}.ok
+{"foo": nil}.score
 {"foo": nil}?.Bar
-{"foo": nil}?.Qux
-{"foo": nil}?.String
+{"foo": nil}?.Bar?.score
+{"foo": nil}?.add
 {"foo": nil}?.array
-{"foo": nil}?.div
-{"foo": nil}?.f32?.ok
-{"foo": nil}?.greet
+{"foo": nil}?.f64
+{"foo": nil}?.foo
+{"foo": nil}?.half
 {"foo": nil}?.i32
-{"foo": nil}?.i?.half
+{"foo": nil}?.i64
 {"foo": nil}?.list
-{"foo": nil}?.list?.greet()
-{"foo": nil}?.score
-{"foo": not false}
-{"foo": not ok}
-{"foo": ok && ok}
-{"foo": ok == nil}
-{"foo": ok ? true : div}
+{"foo": ok == false}
+{"foo": ok, "bar": "foo"}?.i64
+{"foo": ok, "bar": add}.String
 {"foo": ok, "bar": f32}
-{"foo": ok, "bar": i, "foo": greet}.i32
-{"foo": ok, "bar": i32}
-{"foo": ok, "foo": 0.5}?.array
-{"foo": ok, "foo": 1}.Qux
-{"foo": ok, "foo": half, "bar": div}.score
-{"foo": ok, "foo": i64}
-{"foo": ok, "foo": i64}.i
-{"foo": ok, "foo": nil}?.add
+{"foo": ok, "foo": half}.ok
+{"foo": ok, "foo": list}
 {"foo": ok}
 {"foo": ok}.Bar
-{"foo": ok}.add
+{"foo": ok}.Bar?.i
+{"foo": ok}.String
+{"foo": ok}.array
 {"foo": ok}.div
 {"foo": ok}.f64
-{"foo": ok}.greet
-{"foo": ok}.i
-{"foo": ok}.score
+{"foo": ok}.foo
+{"foo": ok}.i32
+{"foo": ok}.i64
+{"foo": ok}.ok
 {"foo": ok}?.Qux
 {"foo": ok}?.String
-{"foo": ok}?.div
+{"foo": ok}?.String?.Bar
+{"foo": ok}?.array
 {"foo": ok}?.f32
+{"foo": ok}?.foo
 {"foo": ok}?.greet
-{"foo": ok}?.half?.half
+{"foo": ok}?.half
 {"foo": ok}?.i32
 {"foo": ok}?.i64
 {"foo": ok}?.list
-{"foo": score(1)}
-{"foo": score, "bar": 0.5}.list
-{"foo": score, "bar": 1 ^ 1}
-{"foo": score, "bar": i32}
-{"foo": score, "bar": i64}
-{"foo": score, "foo": 0.5}.add
-{"foo": score, "foo": 1}?.div
-{"foo": score, "foo": add, "bar": ok}
-{"foo": score, "foo": f32, "bar": false}.div
-{"foo": score, "foo": f32}?.i32
-{"foo": score, "foo": i}?.f32
-{"foo": score}
-{"foo": score}.Bar
-{"foo": score}.array
-{"foo": score}.list
-{"foo": score}?.Bar
-{"foo": score}?.String
-{"foo": score}?.add
-{"foo": score}?.f32
-{"foo": score}?.greet
-{"foo": score}?.half
-{"foo": score}?.i
-{"foo": score}?.list
-{"foo": score}?.score
-{"foo": string(i32)}
-{"foo": string(list)}
-{"foo": toBase64("bar")}
-{"foo": toJSON(f32)}
-{"foo": toJSON(i64)}?.i32
-{"foo": toJSON(nil)}
-{"foo": true, "bar": false}?.array
-{"foo": true, "bar": nil}?.div
-{"foo": true, "bar": true}.f64
-{"foo": true, "foo": array, "bar": i32}?.ok
-{"foo": true, "foo": i32}.i64
-{"foo": true, "foo": ok, "foo": add}.foo
-{"foo": true}.String
-{"foo": true}.f32
-{"foo": true}.foo
-{"foo": true}.i
-{"foo": true}.i64
-{"foo": true}?.String
-{"foo": true}?.greet
-{"foo": true}?.i32
-{"foo": type(1)}
-{"foo": type(list)}
-{"foo": type(nil)}
-{"foo": type(ok)}
+{"foo": reduce(array, "foo")}
+{"foo": reduce(array, #)}
+{"foo": reduce(list, #).String()}
+{"foo": reduce(list, #)}
+{"foo": reduce(list, #)}?.list
+{"foo": score, "bar": add}.add
+{"foo": score, "bar": div}
+{"foo": score, "bar": f64}
+{"foo": score, "bar": false}?.array
+{"foo": score, "bar": false}?.i
+{"foo": score, "bar": true}.div?.i
+{"foo": score, "foo": 0.5}?.String
+{"foo": score, "foo": 1}.array
+{"foo": score, "foo": add}
+{"foo": score, "foo": array}.array
+{"foo": score, "foo": f32}
+{"foo": score, "foo": greet}
diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index f1844b2f7..78f910db9 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -51,6 +51,9 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`cannot parse .* as .*`),
 		regexp.MustCompile(`operator "in" not defined on .*`),
 		regexp.MustCompile(`cannot sum .*`),
+		regexp.MustCompile(`index out of range: .* \(array length is .*\)`),
+		regexp.MustCompile(`cannot use <nil> as argument \(type .*\) to call .*`),
+		regexp.MustCompile(`illegal base64 data at input byte .*`),
 	}
 
 	env := NewEnv()

From 29dff34ad1fcc78c2d6081471433fbfb0d0827e9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 17:01:31 +0100
Subject: [PATCH 396/506] Make all builtins working with deref

Fixes #730
---
 builtin/builtin.go      | 41 ++++++++++++++++++++-----------------
 builtin/builtin_test.go | 45 ++++++++++++++++++++++++++++++++++-------
 builtin/lib.go          | 23 +++++++--------------
 builtin/utils.go        |  3 +++
 internal/deref/deref.go |  4 ++++
 5 files changed, 74 insertions(+), 42 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index f4a14ce58..27400a25b 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -164,7 +164,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			switch kind(deref.Type(args[0])) {
+			switch kind(args[0]) {
 			case reflect.Interface:
 				return integerType, nil
 			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
@@ -642,18 +642,21 @@ var Builtins = []*Function{
 			if len(args) != 2 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 2, got %d)", len(args))
 			}
-			v := reflect.ValueOf(args[0])
+			v := deref.ValueOf(args[0])
 			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
 				return nil, fmt.Errorf("cannot take from %s", v.Kind())
 			}
-			n := reflect.ValueOf(args[1])
+			n := deref.ValueOf(args[1])
 			if !n.CanInt() {
 				return nil, fmt.Errorf("cannot take %s elements", n.Kind())
 			}
+			to := 0
 			if n.Int() > int64(v.Len()) {
-				return args[0], nil
+				to = v.Len()
+			} else {
+				to = int(n.Int())
 			}
-			return v.Slice(0, int(n.Int())).Interface(), nil
+			return v.Slice(0, to).Interface(), nil
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			if len(args) != 2 {
@@ -678,7 +681,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := reflect.ValueOf(args[0])
+			v := deref.ValueOf(args[0])
 			if v.Kind() != reflect.Map {
 				return nil, fmt.Errorf("cannot get keys from %s", v.Kind())
 			}
@@ -708,7 +711,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := reflect.ValueOf(args[0])
+			v := deref.ValueOf(args[0])
 			if v.Kind() != reflect.Map {
 				return nil, fmt.Errorf("cannot get values from %s", v.Kind())
 			}
@@ -738,7 +741,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := reflect.ValueOf(args[0])
+			v := deref.ValueOf(args[0])
 			if v.Kind() != reflect.Map {
 				return nil, fmt.Errorf("cannot transform %s to pairs", v.Kind())
 			}
@@ -766,7 +769,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := reflect.ValueOf(args[0])
+			v := deref.ValueOf(args[0])
 			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
 				return nil, fmt.Errorf("cannot transform %s from pairs", v)
 			}
@@ -798,14 +801,14 @@ var Builtins = []*Function{
 	},
 	{
 		Name: "reverse",
-		Func: func(args ...any) (any, error) {
+		Safe: func(args ...any) (any, uint, error) {
 			if len(args) != 1 {
-				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+				return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 
-			v := reflect.ValueOf(args[0])
+			v := deref.ValueOf(args[0])
 			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
-				return nil, fmt.Errorf("cannot reverse %s", v.Kind())
+				return nil, 0, fmt.Errorf("cannot reverse %s", v.Kind())
 			}
 
 			size := v.Len()
@@ -815,7 +818,7 @@ var Builtins = []*Function{
 				arr[i] = v.Index(size - i - 1).Interface()
 			}
 
-			return arr, nil
+			return arr, uint(size), nil
 
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
@@ -838,7 +841,7 @@ var Builtins = []*Function{
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 
-			v := reflect.ValueOf(deref.Deref(args[0]))
+			v := deref.ValueOf(deref.Deref(args[0]))
 			if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
 				return nil, fmt.Errorf("cannot uniq %s", v.Kind())
 			}
@@ -892,7 +895,7 @@ var Builtins = []*Function{
 			var arr []any
 
 			for _, arg := range args {
-				v := reflect.ValueOf(deref.Deref(arg))
+				v := deref.ValueOf(deref.Deref(arg))
 
 				if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
 					return nil, 0, fmt.Errorf("cannot concat %s", v.Kind())
@@ -914,7 +917,7 @@ var Builtins = []*Function{
 			}
 
 			for _, arg := range args {
-				switch kind(deref.Type(arg)) {
+				switch kind(arg) {
 				case reflect.Interface, reflect.Slice, reflect.Array:
 				default:
 					return anyType, fmt.Errorf("cannot concat %s", arg)
@@ -931,7 +934,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := reflect.ValueOf(deref.Deref(args[0]))
+			v := deref.ValueOf(deref.Deref(args[0]))
 			if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
 				return nil, size, fmt.Errorf("cannot flatten %s", v.Kind())
 			}
@@ -945,7 +948,7 @@ var Builtins = []*Function{
 			}
 
 			for _, arg := range args {
-				switch kind(deref.Type(arg)) {
+				switch kind(arg) {
 				case reflect.Interface, reflect.Slice, reflect.Array:
 				default:
 					return anyType, fmt.Errorf("cannot flatten %s", arg)
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 6427c1aec..0620f0c45 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -639,15 +639,46 @@ func Test_int_unwraps_underlying_value(t *testing.T) {
 	assert.Equal(t, true, out)
 }
 
-func TestBuiltin_int_with_deref(t *testing.T) {
+func TestBuiltin_with_deref(t *testing.T) {
 	x := 42
+	arr := []any{1, 2, 3}
+	m := map[string]any{"a": 1, "b": 2}
 	env := map[string]any{
-		"x": &x,
+		"x":   &x,
+		"arr": &arr,
+		"m":   &m,
 	}
-	program, err := expr.Compile(`int(x)`, expr.Env(env))
-	require.NoError(t, err)
 
-	out, err := expr.Run(program, env)
-	require.NoError(t, err)
-	assert.Equal(t, 42, out)
+	tests := []struct {
+		input string
+		want  any
+	}{
+		{`int(x)`, 42},
+		{`float(x)`, 42.0},
+		{`abs(x)`, 42},
+		{`first(arr)`, 1},
+		{`last(arr)`, 3},
+		{`take(arr, 1)`, []any{1}},
+		{`take(arr, x)`, []any{1, 2, 3}},
+		{`'a' in keys(m)`, true},
+		{`1 in values(m)`, true},
+		{`len(arr)`, 3},
+		{`type(arr)`, "array"},
+		{`type(m)`, "map"},
+		{`reverse(arr)`, []any{3, 2, 1}},
+		{`uniq(arr)`, []any{1, 2, 3}},
+		{`concat(arr, arr)`, []any{1, 2, 3, 1, 2, 3}},
+		{`flatten([arr, [arr]])`, []any{1, 2, 3, 1, 2, 3}},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			program, err := expr.Compile(test.input, expr.Env(env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, env)
+			require.NoError(t, err)
+			assert.Equal(t, test.want, out)
+		})
+	}
 }
diff --git a/builtin/lib.go b/builtin/lib.go
index 34131dfc0..5547bc094 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -11,7 +11,7 @@ import (
 )
 
 func Len(x any) any {
-	v := reflect.ValueOf(x)
+	v := deref.ValueOf(x)
 	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.Map:
 		return v.Len()
@@ -26,16 +26,7 @@ func Type(arg any) any {
 	if arg == nil {
 		return "nil"
 	}
-	v := reflect.ValueOf(arg)
-	for {
-		if v.Kind() == reflect.Ptr {
-			v = v.Elem()
-		} else if v.Kind() == reflect.Interface {
-			v = v.Elem()
-		} else {
-			break
-		}
-	}
+	v := deref.ValueOf(arg)
 	if v.Type().Name() != "" && v.Type().PkgPath() != "" {
 		return fmt.Sprintf("%s.%s", v.Type().PkgPath(), v.Type().Name())
 	}
@@ -66,7 +57,7 @@ func Type(arg any) any {
 }
 
 func Abs(x any) any {
-	switch x := x.(type) {
+	switch x := deref.Deref(x).(type) {
 	case float32:
 		if x < 0 {
 			return -x
@@ -221,7 +212,7 @@ func Int(x any) any {
 }
 
 func Float(x any) any {
-	switch x := x.(type) {
+	switch x := deref.Deref(x).(type) {
 	case float32:
 		return float64(x)
 	case float64:
@@ -264,7 +255,7 @@ func String(arg any) any {
 func minMax(name string, fn func(any, any) bool, args ...any) (any, error) {
 	var val any
 	for _, arg := range args {
-		rv := reflect.ValueOf(deref.Deref(arg))
+		rv := deref.ValueOf(arg)
 		switch rv.Kind() {
 		case reflect.Array, reflect.Slice:
 			size := rv.Len()
@@ -307,7 +298,7 @@ func mean(args ...any) (int, float64, error) {
 	var count int
 
 	for _, arg := range args {
-		rv := reflect.ValueOf(deref.Deref(arg))
+		rv := deref.ValueOf(arg)
 		switch rv.Kind() {
 		case reflect.Array, reflect.Slice:
 			size := rv.Len()
@@ -339,7 +330,7 @@ func median(args ...any) ([]float64, error) {
 	var values []float64
 
 	for _, arg := range args {
-		rv := reflect.ValueOf(deref.Deref(arg))
+		rv := deref.ValueOf(arg)
 		switch rv.Kind() {
 		case reflect.Array, reflect.Slice:
 			size := rv.Len()
diff --git a/builtin/utils.go b/builtin/utils.go
index 29a95731a..262bb379d 100644
--- a/builtin/utils.go
+++ b/builtin/utils.go
@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"reflect"
 	"time"
+
+	"github.com/expr-lang/expr/internal/deref"
 )
 
 var (
@@ -20,6 +22,7 @@ func kind(t reflect.Type) reflect.Kind {
 	if t == nil {
 		return reflect.Invalid
 	}
+	t = deref.Type(t)
 	return t.Kind()
 }
 
diff --git a/internal/deref/deref.go b/internal/deref/deref.go
index acdc89811..5e0e0b04e 100644
--- a/internal/deref/deref.go
+++ b/internal/deref/deref.go
@@ -45,3 +45,7 @@ func Value(v reflect.Value) reflect.Value {
 	}
 	return v
 }
+
+func ValueOf(v any) reflect.Value {
+	return Value(reflect.ValueOf(v))
+}

From 4511e92881c25d58ffb257c58ba427ea257c7e43 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 17:11:49 +0100
Subject: [PATCH 397/506] Remove pointer accessor check in parser

---
 parser/parser.go      | 4 ----
 parser/parser_test.go | 3 ---
 2 files changed, 7 deletions(-)

diff --git a/parser/parser.go b/parser/parser.go
index febfb051a..af2776c89 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -385,10 +385,6 @@ func (p *parser) parsePrimary() Node {
 			}
 			return p.parsePostfixExpression(node)
 		}
-	} else {
-		if token.Is(Operator, "#") || token.Is(Operator, ".") {
-			p.error("cannot use pointer accessor outside predicate")
-		}
 	}
 
 	if token.Is(Operator, "::") {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 3a7bb461a..4e373ff50 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -875,9 +875,6 @@ func TestParse_error(t *testing.T) {
 		{`foo({.bar})`, `a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(".")) (1:6)
  | foo({.bar})
  | .....^`},
-		{`.foo`, `cannot use pointer accessor outside predicate (1:1)
- | .foo
- | ^`},
 		{`[1, 2, 3,,]`, `unexpected token Operator(",") (1:10)
  | [1, 2, 3,,]
  | .........^`},

From 435b79df38cd6c7687a5b70f7bb66c99a45ab31d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 8 Mar 2025 17:28:39 +0100
Subject: [PATCH 398/506] Make sure get() returns nil for map[string]string on
 missing keys

Fixes #723
---
 builtin/builtin.go            |  9 +----
 builtin/lib.go                | 67 +++++++++++++++++++++++++++++++++++
 test/fuzz/fuzz_corpus.txt     | 31 ----------------
 test/issues/723/issue_test.go | 24 +++++++++++++
 testdata/examples.txt         | 31 ----------------
 5 files changed, 92 insertions(+), 70 deletions(-)
 create mode 100644 test/issues/723/issue_test.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 27400a25b..58ce5e4ca 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -627,14 +627,7 @@ var Builtins = []*Function{
 	},
 	{
 		Name: "get",
-		Func: func(args ...any) (out any, err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					return
-				}
-			}()
-			return runtime.Fetch(args[0], args[1]), nil
-		},
+		Func: get,
 	},
 	{
 		Name: "take",
diff --git a/builtin/lib.go b/builtin/lib.go
index 5547bc094..6c1979d3b 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -8,6 +8,7 @@ import (
 	"unicode/utf8"
 
 	"github.com/expr-lang/expr/internal/deref"
+	"github.com/expr-lang/expr/vm/runtime"
 )
 
 func Len(x any) any {
@@ -367,3 +368,69 @@ func flatten(arg reflect.Value) []any {
 	}
 	return ret
 }
+
+func get(params ...any) (out any, err error) {
+	from := params[0]
+	i := params[1]
+	v := reflect.ValueOf(from)
+
+	if v.Kind() == reflect.Invalid {
+		panic(fmt.Sprintf("cannot fetch %v from %T", i, from))
+	}
+
+	// Methods can be defined on any type.
+	if v.NumMethod() > 0 {
+		if methodName, ok := i.(string); ok {
+			method := v.MethodByName(methodName)
+			if method.IsValid() {
+				return method.Interface(), nil
+			}
+		}
+	}
+
+	v = deref.Value(v)
+	i = deref.Deref(i)
+
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.String:
+		index := runtime.ToInt(i)
+		l := v.Len()
+		if index < 0 {
+			index = l + index
+		}
+		if 0 <= index && index < l {
+			value := v.Index(index)
+			if value.IsValid() {
+				return value.Interface(), nil
+			}
+		}
+
+	case reflect.Map:
+		var value reflect.Value
+		if i == nil {
+			value = v.MapIndex(reflect.Zero(v.Type().Key()))
+		} else {
+			value = v.MapIndex(reflect.ValueOf(i))
+		}
+		if value.IsValid() {
+			return value.Interface(), nil
+		}
+
+	case reflect.Struct:
+		fieldName := i.(string)
+		value := v.FieldByNameFunc(func(name string) bool {
+			field, _ := v.Type().FieldByName(name)
+			if field.Tag.Get("expr") == fieldName {
+				return true
+			}
+			return name == fieldName
+		})
+		if value.IsValid() {
+			return value.Interface(), nil
+		}
+	}
+
+	// Main difference from runtime.Fetch
+	// is that we return `nil` instead of panic.
+	return nil, nil
+}
diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
index a7d574275..72afdf6ce 100644
--- a/test/fuzz/fuzz_corpus.txt
+++ b/test/fuzz/fuzz_corpus.txt
@@ -7088,58 +7088,33 @@ get(false ? i32 : list, i64)
 get(false ? i64 : true, f64)
 get(false ? score : ok, trimSuffix("bar", "bar"))
 get(filter(list, true), i)
-get(groupBy(array, "bar"), add)
 get(groupBy(array, "bar"), i)
 get(groupBy(array, "bar"), ok)
-get(groupBy(array, "foo"), half)
-get(groupBy(array, #), add)
-get(groupBy(array, #), array)
 get(groupBy(array, #), f32)
 get(groupBy(array, #), f64)
 get(groupBy(array, #), foo)
-get(groupBy(array, #), greet)
-get(groupBy(array, #), half)
 get(groupBy(array, #), i)
 get(groupBy(array, #), i64 * 0.5)
 get(groupBy(array, #), i64)
-get(groupBy(array, #)?.String, i64)
-get(groupBy(array, 0.5), add)
-get(groupBy(array, 0.5), div)
 get(groupBy(array, 0.5), ok)
-get(groupBy(array, 1), add)
 get(groupBy(array, 1), f32)
 get(groupBy(array, f64), i64)
 get(groupBy(array, false), findIndex(array, ok))
 get(groupBy(array, i), ok)
-get(groupBy(array, i), score)
-get(groupBy(array, i64), add)
-get(groupBy(array, ok), add)
 get(groupBy(array, true), i32)
 get(groupBy(list, "bar"), i32)
-get(groupBy(list, "foo"), greet)
-get(groupBy(list, #), div)
 get(groupBy(list, #), f32 <= f64)
 get(groupBy(list, #), f32)
 get(groupBy(list, #), foo)
-get(groupBy(list, #), greet)
-get(groupBy(list, #), half)
 get(groupBy(list, #), i)
 get(groupBy(list, #), i32)
 get(groupBy(list, #), i64)
 get(groupBy(list, #), int(f32))
-get(groupBy(list, #), list)
 get(groupBy(list, #), reduce(array, foo))
 get(groupBy(list, #), score(1))
-get(groupBy(list, #), score)
-get(groupBy(list, 0.5), array)
-get(groupBy(list, 0.5), div)
 get(groupBy(list, 0.5), ok)
 get(groupBy(list, 1), i32)
-get(groupBy(list, f32), greet)
-get(groupBy(list, foo), add)
 get(groupBy(list, foo), i32)
-get(groupBy(list, ok), greet)
-get(groupBy(list, ok), list)
 get(i .. 1, 1 * 1)
 get(i .. i32, i)
 get(i32 .. i, i64)
@@ -7200,12 +7175,10 @@ get(list, max(i32))
 get(list, min(i32))
 get(list, min(i64))
 get(list, ok ? 0.5 : "foo")
-get(list, ok ? array : "foo")
 get(list, reduce(list, i64))
 get(list, score(1))
 get(list, score(i))
 get(list, true ? i : i32)
-get(list, {"foo": i32}?.i)
 get(list[i64:1], i)
 get(map(array, #), i)
 get(map(array, #), i32)
@@ -7221,18 +7194,15 @@ get(map(list, 1), i32)
 get(map(list, array), i)
 get(map(list, i32), i64)
 get(map(list, i64), i64)
-get(ok ? "bar" : false, array)
 get(ok ? 1 : "bar", f32)
 get(ok ? add : f32, array)
 get(ok ? f64 : div, i64)
 get(ok ? false : list, f32 > i)
-get(ok ? foo : 0.5, div)
 get(ok ? half : i32, i)
 get(ok ? half : ok, f64)
 get(ok ? i : 0.5, half)
 get(ok ? i32 : half, f64)
 get(ok ? i64 : foo, f32)
-get(ok ? list : "foo", add)
 get(ok ? list : i32, f32)
 get(ok ? ok : div, greet)
 get(ok ? score : f64, i)
@@ -7241,7 +7211,6 @@ get(reduce(list, array), i32)
 get(sort(array), i32)
 get(take(list, i), i64)
 get(true ? "bar" : ok, score(i))
-get(true ? "foo" : half, list)
 get(true ? 0.5 : i32, array)
 get(true ? f32 : 0.5, ok)
 get(true ? false : foo, i64 > 0.5)
diff --git a/test/issues/723/issue_test.go b/test/issues/723/issue_test.go
new file mode 100644
index 000000000..c1dd6585d
--- /dev/null
+++ b/test/issues/723/issue_test.go
@@ -0,0 +1,24 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue723(t *testing.T) {
+	emptyMap := make(map[string]string)
+	env := map[string]interface{}{
+		"empty_map": emptyMap,
+	}
+
+	code := `get(empty_map, "non_existing_key")`
+
+	program, err := expr.Compile(code, expr.Env(env))
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, nil, output)
+}
diff --git a/testdata/examples.txt b/testdata/examples.txt
index a7d574275..72afdf6ce 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -7088,58 +7088,33 @@ get(false ? i32 : list, i64)
 get(false ? i64 : true, f64)
 get(false ? score : ok, trimSuffix("bar", "bar"))
 get(filter(list, true), i)
-get(groupBy(array, "bar"), add)
 get(groupBy(array, "bar"), i)
 get(groupBy(array, "bar"), ok)
-get(groupBy(array, "foo"), half)
-get(groupBy(array, #), add)
-get(groupBy(array, #), array)
 get(groupBy(array, #), f32)
 get(groupBy(array, #), f64)
 get(groupBy(array, #), foo)
-get(groupBy(array, #), greet)
-get(groupBy(array, #), half)
 get(groupBy(array, #), i)
 get(groupBy(array, #), i64 * 0.5)
 get(groupBy(array, #), i64)
-get(groupBy(array, #)?.String, i64)
-get(groupBy(array, 0.5), add)
-get(groupBy(array, 0.5), div)
 get(groupBy(array, 0.5), ok)
-get(groupBy(array, 1), add)
 get(groupBy(array, 1), f32)
 get(groupBy(array, f64), i64)
 get(groupBy(array, false), findIndex(array, ok))
 get(groupBy(array, i), ok)
-get(groupBy(array, i), score)
-get(groupBy(array, i64), add)
-get(groupBy(array, ok), add)
 get(groupBy(array, true), i32)
 get(groupBy(list, "bar"), i32)
-get(groupBy(list, "foo"), greet)
-get(groupBy(list, #), div)
 get(groupBy(list, #), f32 <= f64)
 get(groupBy(list, #), f32)
 get(groupBy(list, #), foo)
-get(groupBy(list, #), greet)
-get(groupBy(list, #), half)
 get(groupBy(list, #), i)
 get(groupBy(list, #), i32)
 get(groupBy(list, #), i64)
 get(groupBy(list, #), int(f32))
-get(groupBy(list, #), list)
 get(groupBy(list, #), reduce(array, foo))
 get(groupBy(list, #), score(1))
-get(groupBy(list, #), score)
-get(groupBy(list, 0.5), array)
-get(groupBy(list, 0.5), div)
 get(groupBy(list, 0.5), ok)
 get(groupBy(list, 1), i32)
-get(groupBy(list, f32), greet)
-get(groupBy(list, foo), add)
 get(groupBy(list, foo), i32)
-get(groupBy(list, ok), greet)
-get(groupBy(list, ok), list)
 get(i .. 1, 1 * 1)
 get(i .. i32, i)
 get(i32 .. i, i64)
@@ -7200,12 +7175,10 @@ get(list, max(i32))
 get(list, min(i32))
 get(list, min(i64))
 get(list, ok ? 0.5 : "foo")
-get(list, ok ? array : "foo")
 get(list, reduce(list, i64))
 get(list, score(1))
 get(list, score(i))
 get(list, true ? i : i32)
-get(list, {"foo": i32}?.i)
 get(list[i64:1], i)
 get(map(array, #), i)
 get(map(array, #), i32)
@@ -7221,18 +7194,15 @@ get(map(list, 1), i32)
 get(map(list, array), i)
 get(map(list, i32), i64)
 get(map(list, i64), i64)
-get(ok ? "bar" : false, array)
 get(ok ? 1 : "bar", f32)
 get(ok ? add : f32, array)
 get(ok ? f64 : div, i64)
 get(ok ? false : list, f32 > i)
-get(ok ? foo : 0.5, div)
 get(ok ? half : i32, i)
 get(ok ? half : ok, f64)
 get(ok ? i : 0.5, half)
 get(ok ? i32 : half, f64)
 get(ok ? i64 : foo, f32)
-get(ok ? list : "foo", add)
 get(ok ? list : i32, f32)
 get(ok ? ok : div, greet)
 get(ok ? score : f64, i)
@@ -7241,7 +7211,6 @@ get(reduce(list, array), i32)
 get(sort(array), i32)
 get(take(list, i), i64)
 get(true ? "bar" : ok, score(i))
-get(true ? "foo" : half, list)
 get(true ? 0.5 : i32, array)
 get(true ? f32 : 0.5, ok)
 get(true ? false : foo, i64 > 0.5)

From 8f8320313179e1da0d18589d00d4d8cde9be3301 Mon Sep 17 00:00:00 2001
From: zhuliquan <zlqlovecode@foxmail.com>
Date: Sun, 9 Mar 2025 17:45:17 +0800
Subject: [PATCH 399/506] Allow tailing comma in arguments (#623)

* feat: extract code for compiling equal operator

* feat: support last argument append with comma

---------

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 parser/parser.go      |  7 +++++++
 parser/parser_test.go | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/parser/parser.go b/parser/parser.go
index af2776c89..5ba16d2a2 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -549,6 +549,10 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 			arguments = append(arguments, node)
 		}
 
+		// skip last comma
+		if p.current.Is(Operator, ",") {
+			p.next()
+		}
 		p.expect(Bracket, ")")
 
 		node = p.createNode(&BuiltinNode{
@@ -593,6 +597,9 @@ func (p *parser) parseArguments(arguments []Node) []Node {
 		if len(arguments) > offset {
 			p.expect(Operator, ",")
 		}
+		if p.current.Is(Bracket, ")") {
+			break
+		}
 		node := p.parseExpression(0)
 		arguments = append(arguments, node)
 	}
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 4e373ff50..51dc0ac06 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -839,6 +839,42 @@ world`},
 				Expr: &IdentifierNode{Value: "x"},
 			},
 		},
+		{
+			`all(
+				[
+				  true,
+				  false,
+				],
+				#,
+			)`,
+			&BuiltinNode{
+				Name: "all",
+				Arguments: []Node{
+					&ArrayNode{
+						Nodes: []Node{
+							&BoolNode{Value: true},
+							&BoolNode{Value: false},
+						},
+					},
+					&PredicateNode{
+						Node: &PointerNode{},
+					},
+				},
+			},
+		},
+		{
+			`func(
+				parameter1,
+				parameter2,
+			)`,
+			&CallNode{
+				Callee: &IdentifierNode{Value: "func"},
+				Arguments: []Node{
+					&IdentifierNode{Value: "parameter1"},
+					&IdentifierNode{Value: "parameter2"},
+				},
+			},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {

From 2d9f6165d887633bb922b51190e12d6aa7cec8fc Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 9 Mar 2025 10:48:37 +0100
Subject: [PATCH 400/506] Add more tailing comma tests

---
 parser/parser_test.go | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/parser/parser_test.go b/parser/parser_test.go
index 51dc0ac06..9c707856d 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -862,6 +862,18 @@ world`},
 				},
 			},
 		},
+		{
+			`list | all(#,)`,
+			&BuiltinNode{
+				Name: "all",
+				Arguments: []Node{
+					&IdentifierNode{Value: "list"},
+					&PredicateNode{
+						Node: &PointerNode{},
+					},
+				},
+			},
+		},
 		{
 			`func(
 				parameter1,
@@ -974,6 +986,12 @@ func TestParse_error(t *testing.T) {
  | 1 + if true { 2 } else { 3 }
  | ....^`,
 		},
+		{
+			`list | all(#,,)`,
+			`unexpected token Operator(",") (1:14)
+ | list | all(#,,)
+ | .............^`,
+		},
 	}
 
 	for _, test := range tests {

From 80f0ea62ea6935a06d6562c5844a801362bf57a1 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 9 Mar 2025 13:07:38 +0100
Subject: [PATCH 401/506] Correctly add OpDeref if needed

Fixes #739
---
 builtin/builtin.go            |  9 ++++++++
 builtin/builtin_test.go       | 16 ++++++++++---
 builtin/function.go           |  1 +
 checker/checker.go            |  8 +++++++
 checker/nature/nature.go      | 18 +++++++++++++++
 compiler/compiler.go          | 43 ++++++++++++++++++++++++++---------
 expr.go                       |  1 +
 patcher/value/value_test.go   |  1 -
 test/deref/deref_test.go      | 17 ++++++++++++++
 test/issues/739/issue_test.go | 19 ++++++++++++++++
 10 files changed, 118 insertions(+), 15 deletions(-)
 create mode 100644 test/issues/739/issue_test.go

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 58ce5e4ca..33febb09a 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -493,6 +493,9 @@ var Builtins = []*Function{
 			}
 			return anyType, fmt.Errorf("invalid number of arguments (expected 0, got %d)", len(args))
 		},
+		Deref: func(i int, arg reflect.Type) bool {
+			return false
+		},
 	},
 	{
 		Name: "duration",
@@ -567,6 +570,12 @@ var Builtins = []*Function{
 			}
 			return timeType, nil
 		},
+		Deref: func(i int, arg reflect.Type) bool {
+			if arg.AssignableTo(locationType) {
+				return false
+			}
+			return true
+		},
 	},
 	{
 		Name: "timezone",
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 0620f0c45..75e279631 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -642,11 +642,17 @@ func Test_int_unwraps_underlying_value(t *testing.T) {
 func TestBuiltin_with_deref(t *testing.T) {
 	x := 42
 	arr := []any{1, 2, 3}
+	arrStr := []string{"1", "2", "3"}
 	m := map[string]any{"a": 1, "b": 2}
+	jsonString := `["1"]`
+	str := "1,2,3"
 	env := map[string]any{
-		"x":   &x,
-		"arr": &arr,
-		"m":   &m,
+		"x":      &x,
+		"arr":    &arr,
+		"arrStr": &arrStr,
+		"m":      &m,
+		"json":   &jsonString,
+		"str":    &str,
 	}
 
 	tests := []struct {
@@ -669,6 +675,10 @@ func TestBuiltin_with_deref(t *testing.T) {
 		{`uniq(arr)`, []any{1, 2, 3}},
 		{`concat(arr, arr)`, []any{1, 2, 3, 1, 2, 3}},
 		{`flatten([arr, [arr]])`, []any{1, 2, 3, 1, 2, 3}},
+		{`toJSON(arr)`, "[\n  1,\n  2,\n  3\n]"},
+		{`fromJSON(json)`, []any{"1"}},
+		{`split(str, ",")`, []string{"1", "2", "3"}},
+		{`join(arrStr, ",")`, "1,2,3"},
 	}
 
 	for _, test := range tests {
diff --git a/builtin/function.go b/builtin/function.go
index d4d78b1ce..6634ac3f8 100644
--- a/builtin/function.go
+++ b/builtin/function.go
@@ -11,6 +11,7 @@ type Function struct {
 	Safe      func(args ...any) (any, uint, error)
 	Types     []reflect.Type
 	Validate  func(args []reflect.Type) (reflect.Type, error)
+	Deref     func(i int, arg reflect.Type) bool
 	Predicate bool
 }
 
diff --git a/checker/checker.go b/checker/checker.go
index d410b9549..fc01746fe 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -975,6 +975,14 @@ func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []
 			lastErr = err
 			continue
 		}
+
+		// As we found the correct function overload, we can stop the loop.
+		// Also, we need to set the correct nature of the callee so compiler,
+		// can correctly handle OpDeref opcode.
+		if callNode, ok := node.(*ast.CallNode); ok {
+			callNode.Callee.SetType(t)
+		}
+
 		return outNature
 	}
 	if lastErr != nil {
diff --git a/checker/nature/nature.go b/checker/nature/nature.go
index 6720acb4c..e25fbf219 100644
--- a/checker/nature/nature.go
+++ b/checker/nature/nature.go
@@ -25,6 +25,24 @@ type Nature struct {
 	FieldIndex      []int             // Index of field in type.
 }
 
+func (n Nature) IsNil() bool {
+	return n.Nil
+}
+
+func (n Nature) IsAny() bool {
+	return n.Kind() == reflect.Interface && n.NumMethods() == 0
+}
+
+func (n Nature) IsUnknown() bool {
+	switch {
+	case n.Type == nil && !n.Nil:
+		return true
+	case isAny(n):
+		return true
+	}
+	return false
+}
+
 func (n Nature) String() string {
 	if n.Type != nil {
 		return n.Type.String()
diff --git a/compiler/compiler.go b/compiler/compiler.go
index ca2750c18..7f0371216 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -750,17 +750,15 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 		}
 		for i, arg := range node.Arguments {
 			c.compile(arg)
-			if k := kind(arg.Type()); k == reflect.Ptr || k == reflect.Interface {
-				var in reflect.Type
-				if fn.IsVariadic() && i >= fnNumIn-1 {
-					in = fn.In(fn.NumIn() - 1).Elem()
-				} else {
-					in = fn.In(i + fnInOffset)
-				}
-				if k = kind(in); k != reflect.Ptr && k != reflect.Interface {
-					c.emit(OpDeref)
-				}
+
+			var in reflect.Type
+			if fn.IsVariadic() && i >= fnNumIn-1 {
+				in = fn.In(fn.NumIn() - 1).Elem()
+			} else {
+				in = fn.In(i + fnInOffset)
 			}
+
+			c.derefParam(in, arg)
 		}
 	} else {
 		for _, arg := range node.Arguments {
@@ -1059,8 +1057,19 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	if id, ok := builtin.Index[node.Name]; ok {
 		f := builtin.Builtins[id]
-		for _, arg := range node.Arguments {
+		for i, arg := range node.Arguments {
 			c.compile(arg)
+			argType := arg.Type()
+			if argType.Kind() == reflect.Ptr || arg.Nature().IsUnknown() {
+				if f.Deref == nil {
+					// By default, builtins expect arguments to be dereferenced.
+					c.emit(OpDeref)
+				} else {
+					if f.Deref(i, argType) {
+						c.emit(OpDeref)
+					}
+				}
+			}
 		}
 
 		if f.Fast != nil {
@@ -1218,6 +1227,18 @@ func (c *compiler) derefInNeeded(node ast.Node) {
 	}
 }
 
+func (c *compiler) derefParam(in reflect.Type, param ast.Node) {
+	if param.Nature().Nil {
+		return
+	}
+	if param.Type().AssignableTo(in) {
+		return
+	}
+	if in.Kind() != reflect.Ptr && param.Type().Kind() == reflect.Ptr {
+		c.emit(OpDeref)
+	}
+}
+
 func (c *compiler) optimize() {
 	for i, op := range c.bytecode {
 		switch op {
diff --git a/expr.go b/expr.go
index 5e60791e1..0325f81f8 100644
--- a/expr.go
+++ b/expr.go
@@ -244,6 +244,7 @@ func Eval(input string, env any) (any, error) {
 	if err != nil {
 		return nil, err
 	}
+	println(program.Disassemble())
 
 	output, err := Run(program, env)
 	if err != nil {
diff --git a/patcher/value/value_test.go b/patcher/value/value_test.go
index 30c8a56ad..d04a4120a 100644
--- a/patcher/value/value_test.go
+++ b/patcher/value/value_test.go
@@ -88,7 +88,6 @@ func Test_valueAddInt(t *testing.T) {
 
 	program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter)
 	require.NoError(t, err)
-
 	out, err := vm.Run(program, env)
 
 	require.NoError(t, err)
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 0b3ea5837..8df682faf 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -320,3 +320,20 @@ func TestDeref_ignore_struct_func_args(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, "UTC", out)
 }
+
+func TestDeref_keep_pointer_if_arg_in_interface(t *testing.T) {
+	x := 42
+	env := map[string]any{
+		"x": &x,
+		"fn": func(p any) int {
+			return *p.(*int) + 1
+		},
+	}
+
+	program, err := expr.Compile(`fn(x)`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 43, out)
+}
diff --git a/test/issues/739/issue_test.go b/test/issues/739/issue_test.go
new file mode 100644
index 000000000..c58633fe8
--- /dev/null
+++ b/test/issues/739/issue_test.go
@@ -0,0 +1,19 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue739(t *testing.T) {
+	jsonString := `{"Num": 1}`
+	env := map[string]any{
+		"aJSONString": &jsonString,
+	}
+
+	result, err := expr.Eval("fromJSON(aJSONString)", env)
+	require.NoError(t, err)
+	require.Contains(t, result, "Num")
+}

From 7d564c003e90a5fdab6e453dd74974bb085bb34e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 9 Mar 2025 23:39:16 +0100
Subject: [PATCH 402/506] Remove print

---
 expr.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/expr.go b/expr.go
index 0325f81f8..5e60791e1 100644
--- a/expr.go
+++ b/expr.go
@@ -244,7 +244,6 @@ func Eval(input string, env any) (any, error) {
 	if err != nil {
 		return nil, err
 	}
-	println(program.Disassemble())
 
 	output, err := Run(program, env)
 	if err != nil {

From f4bbea526036057a4ae0ddc8df6615084cde007e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 10 Mar 2025 13:38:02 +0100
Subject: [PATCH 403/506] Add support deref in all builtins

---
 builtin/builtin_test.go | 29 ++++++++++++++++++++++++++---
 checker/checker.go      | 20 ++++++++++----------
 compiler/compiler.go    | 16 ++++++++++++++++
 3 files changed, 52 insertions(+), 13 deletions(-)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 75e279631..c0b2842f7 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -641,7 +641,7 @@ func Test_int_unwraps_underlying_value(t *testing.T) {
 
 func TestBuiltin_with_deref(t *testing.T) {
 	x := 42
-	arr := []any{1, 2, 3}
+	arr := []int{1, 2, 3}
 	arrStr := []string{"1", "2", "3"}
 	m := map[string]any{"a": 1, "b": 2}
 	jsonString := `["1"]`
@@ -659,13 +659,31 @@ func TestBuiltin_with_deref(t *testing.T) {
 		input string
 		want  any
 	}{
+		{`all(arr, # > 0)`, true},
+		{`none(arr, # < 0)`, true},
+		{`any(arr, # > 0)`, true},
+		{`one(arr, # > 2)`, true},
+		{`filter(arr, # > 0)`, []any{1, 2, 3}},
+		{`map(arr, # * #)`, []any{1, 4, 9}},
+		{`count(arr, # > 0)`, 3},
+		{`sum(arr)`, 6},
+		{`find(arr, # > 0)`, 1},
+		{`findIndex(arr, # > 1)`, 1},
+		{`findLast(arr, # > 0)`, 3},
+		{`findLastIndex(arr, # > 0)`, 2},
+		{`groupBy(arr, # % 2 == 0)`, map[any][]any{false: {1, 3}, true: {2}}},
+		{`sortBy(arr, -#)`, []any{3, 2, 1}},
+		{`reduce(arr, # + #acc, x)`, 6 + 42},
+		{`ceil(x)`, 42.0},
+		{`floor(x)`, 42.0},
+		{`round(x)`, 42.0},
 		{`int(x)`, 42},
 		{`float(x)`, 42.0},
 		{`abs(x)`, 42},
 		{`first(arr)`, 1},
 		{`last(arr)`, 3},
-		{`take(arr, 1)`, []any{1}},
-		{`take(arr, x)`, []any{1, 2, 3}},
+		{`take(arr, 1)`, []int{1}},
+		{`take(arr, x)`, []int{1, 2, 3}},
 		{`'a' in keys(m)`, true},
 		{`1 in values(m)`, true},
 		{`len(arr)`, 3},
@@ -685,10 +703,15 @@ func TestBuiltin_with_deref(t *testing.T) {
 		t.Run(test.input, func(t *testing.T) {
 			program, err := expr.Compile(test.input, expr.Env(env))
 			require.NoError(t, err)
+			println(program.Disassemble())
 
 			out, err := expr.Run(program, env)
 			require.NoError(t, err)
 			assert.Equal(t, test.want, out)
+
+			out, err = expr.Eval(test.input, env)
+			require.NoError(t, err)
+			assert.Equal(t, test.want, out)
 		})
 	}
 }
diff --git a/checker/checker.go b/checker/checker.go
index fc01746fe..f49234137 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -660,7 +660,7 @@ func (v *checker) functionReturnType(node *ast.CallNode) Nature {
 func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 	switch node.Name {
 	case "all", "none", "any", "one":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
@@ -681,7 +681,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "filter":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
@@ -705,7 +705,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "map":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
@@ -723,7 +723,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "count":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
@@ -748,7 +748,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "sum":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
@@ -771,7 +771,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		}
 
 	case "find", "findLast":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
@@ -795,7 +795,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "findIndex", "findLastIndex":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
@@ -816,7 +816,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "groupBy":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
@@ -835,7 +835,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "sortBy":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
@@ -857,7 +857,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "reduce":
-		collection := v.visit(node.Arguments[0])
+		collection := v.visit(node.Arguments[0]).Deref()
 		if !isArray(collection) && !isUnknown(collection) {
 			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
 		}
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 7f0371216..90e54e54b 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -791,6 +791,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 	switch node.Name {
 	case "all":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		var loopBreak int
 		c.emitLoop(func() {
@@ -805,6 +806,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "none":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		var loopBreak int
 		c.emitLoop(func() {
@@ -820,6 +822,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "any":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		var loopBreak int
 		c.emitLoop(func() {
@@ -834,6 +837,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "one":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		c.emitLoop(func() {
 			c.compile(node.Arguments[1])
@@ -849,6 +853,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "filter":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		c.emitLoop(func() {
 			c.compile(node.Arguments[1])
@@ -868,6 +873,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "map":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		c.emitLoop(func() {
 			c.compile(node.Arguments[1])
@@ -879,6 +885,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "count":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		c.emitLoop(func() {
 			if len(node.Arguments) == 2 {
@@ -896,6 +903,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "sum":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		c.emit(OpInt, 0)
 		c.emit(OpSetAcc)
@@ -915,6 +923,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "find":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		var loopBreak int
 		c.emitLoop(func() {
@@ -942,6 +951,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "findIndex":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		var loopBreak int
 		c.emitLoop(func() {
@@ -960,6 +970,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "findLast":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		var loopBreak int
 		c.emitLoopBackwards(func() {
@@ -987,6 +998,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "findLastIndex":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		var loopBreak int
 		c.emitLoopBackwards(func() {
@@ -1005,6 +1017,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "groupBy":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		c.emit(OpCreate, 1)
 		c.emit(OpSetAcc)
@@ -1018,6 +1031,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "sortBy":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		if len(node.Arguments) == 3 {
 			c.compile(node.Arguments[2])
@@ -1036,9 +1050,11 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 
 	case "reduce":
 		c.compile(node.Arguments[0])
+		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
 		if len(node.Arguments) == 3 {
 			c.compile(node.Arguments[2])
+			c.derefInNeeded(node.Arguments[2])
 			c.emit(OpSetAcc)
 		} else {
 			c.emit(OpPointer)

From 2bc0eed148d3313a42c33e7f5a91778d94c85ca7 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 10 Mar 2025 13:52:54 +0100
Subject: [PATCH 404/506] Remove duplicated dereferences

---
 builtin/builtin.go           | 20 ++++++++++----------
 builtin/builtin_test.go      |  1 +
 builtin/lib.go               | 19 ++++++++-----------
 internal/deref/deref.go      |  6 +-----
 internal/deref/deref_test.go |  8 ++++----
 vm/vm.go                     |  2 +-
 6 files changed, 25 insertions(+), 31 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 33febb09a..c23daf468 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -644,11 +644,11 @@ var Builtins = []*Function{
 			if len(args) != 2 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 2, got %d)", len(args))
 			}
-			v := deref.ValueOf(args[0])
+			v := reflect.ValueOf(args[0])
 			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
 				return nil, fmt.Errorf("cannot take from %s", v.Kind())
 			}
-			n := deref.ValueOf(args[1])
+			n := reflect.ValueOf(args[1])
 			if !n.CanInt() {
 				return nil, fmt.Errorf("cannot take %s elements", n.Kind())
 			}
@@ -683,7 +683,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := deref.ValueOf(args[0])
+			v := reflect.ValueOf(args[0])
 			if v.Kind() != reflect.Map {
 				return nil, fmt.Errorf("cannot get keys from %s", v.Kind())
 			}
@@ -713,7 +713,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := deref.ValueOf(args[0])
+			v := reflect.ValueOf(args[0])
 			if v.Kind() != reflect.Map {
 				return nil, fmt.Errorf("cannot get values from %s", v.Kind())
 			}
@@ -743,7 +743,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := deref.ValueOf(args[0])
+			v := reflect.ValueOf(args[0])
 			if v.Kind() != reflect.Map {
 				return nil, fmt.Errorf("cannot transform %s to pairs", v.Kind())
 			}
@@ -771,7 +771,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := deref.ValueOf(args[0])
+			v := reflect.ValueOf(args[0])
 			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
 				return nil, fmt.Errorf("cannot transform %s from pairs", v)
 			}
@@ -808,7 +808,7 @@ var Builtins = []*Function{
 				return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 
-			v := deref.ValueOf(args[0])
+			v := reflect.ValueOf(args[0])
 			if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
 				return nil, 0, fmt.Errorf("cannot reverse %s", v.Kind())
 			}
@@ -843,7 +843,7 @@ var Builtins = []*Function{
 				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
 
-			v := deref.ValueOf(deref.Deref(args[0]))
+			v := reflect.ValueOf(args[0])
 			if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
 				return nil, fmt.Errorf("cannot uniq %s", v.Kind())
 			}
@@ -897,7 +897,7 @@ var Builtins = []*Function{
 			var arr []any
 
 			for _, arg := range args {
-				v := deref.ValueOf(deref.Deref(arg))
+				v := reflect.ValueOf(arg)
 
 				if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
 					return nil, 0, fmt.Errorf("cannot concat %s", v.Kind())
@@ -936,7 +936,7 @@ var Builtins = []*Function{
 			if len(args) != 1 {
 				return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
 			}
-			v := deref.ValueOf(deref.Deref(args[0]))
+			v := reflect.ValueOf(args[0])
 			if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
 				return nil, size, fmt.Errorf("cannot flatten %s", v.Kind())
 			}
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index c0b2842f7..71f775a49 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -693,6 +693,7 @@ func TestBuiltin_with_deref(t *testing.T) {
 		{`uniq(arr)`, []any{1, 2, 3}},
 		{`concat(arr, arr)`, []any{1, 2, 3, 1, 2, 3}},
 		{`flatten([arr, [arr]])`, []any{1, 2, 3, 1, 2, 3}},
+		{`flatten(arr)`, []any{1, 2, 3}},
 		{`toJSON(arr)`, "[\n  1,\n  2,\n  3\n]"},
 		{`fromJSON(json)`, []any{"1"}},
 		{`split(str, ",")`, []string{"1", "2", "3"}},
diff --git a/builtin/lib.go b/builtin/lib.go
index 6c1979d3b..5a70a6b91 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -12,7 +12,7 @@ import (
 )
 
 func Len(x any) any {
-	v := deref.ValueOf(x)
+	v := reflect.ValueOf(x)
 	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.Map:
 		return v.Len()
@@ -27,7 +27,7 @@ func Type(arg any) any {
 	if arg == nil {
 		return "nil"
 	}
-	v := deref.ValueOf(arg)
+	v := reflect.ValueOf(arg)
 	if v.Type().Name() != "" && v.Type().PkgPath() != "" {
 		return fmt.Sprintf("%s.%s", v.Type().PkgPath(), v.Type().Name())
 	}
@@ -58,7 +58,7 @@ func Type(arg any) any {
 }
 
 func Abs(x any) any {
-	switch x := deref.Deref(x).(type) {
+	switch x := x.(type) {
 	case float32:
 		if x < 0 {
 			return -x
@@ -172,7 +172,7 @@ func Round(x any) any {
 }
 
 func Int(x any) any {
-	switch x := deref.Deref(x).(type) {
+	switch x := x.(type) {
 	case float32:
 		return int(x)
 	case float64:
@@ -213,7 +213,7 @@ func Int(x any) any {
 }
 
 func Float(x any) any {
-	switch x := deref.Deref(x).(type) {
+	switch x := x.(type) {
 	case float32:
 		return float64(x)
 	case float64:
@@ -256,7 +256,7 @@ func String(arg any) any {
 func minMax(name string, fn func(any, any) bool, args ...any) (any, error) {
 	var val any
 	for _, arg := range args {
-		rv := deref.ValueOf(arg)
+		rv := reflect.ValueOf(arg)
 		switch rv.Kind() {
 		case reflect.Array, reflect.Slice:
 			size := rv.Len()
@@ -299,7 +299,7 @@ func mean(args ...any) (int, float64, error) {
 	var count int
 
 	for _, arg := range args {
-		rv := deref.ValueOf(arg)
+		rv := reflect.ValueOf(arg)
 		switch rv.Kind() {
 		case reflect.Array, reflect.Slice:
 			size := rv.Len()
@@ -331,7 +331,7 @@ func median(args ...any) ([]float64, error) {
 	var values []float64
 
 	for _, arg := range args {
-		rv := deref.ValueOf(arg)
+		rv := reflect.ValueOf(arg)
 		switch rv.Kind() {
 		case reflect.Array, reflect.Slice:
 			size := rv.Len()
@@ -388,9 +388,6 @@ func get(params ...any) (out any, err error) {
 		}
 	}
 
-	v = deref.Value(v)
-	i = deref.Deref(i)
-
 	switch v.Kind() {
 	case reflect.Array, reflect.Slice, reflect.String:
 		index := runtime.ToInt(i)
diff --git a/internal/deref/deref.go b/internal/deref/deref.go
index 5e0e0b04e..da3e28ce6 100644
--- a/internal/deref/deref.go
+++ b/internal/deref/deref.go
@@ -5,7 +5,7 @@ import (
 	"reflect"
 )
 
-func Deref(p any) any {
+func Interface(p any) any {
 	if p == nil {
 		return nil
 	}
@@ -45,7 +45,3 @@ func Value(v reflect.Value) reflect.Value {
 	}
 	return v
 }
-
-func ValueOf(v any) reflect.Value {
-	return Value(reflect.ValueOf(v))
-}
diff --git a/internal/deref/deref_test.go b/internal/deref/deref_test.go
index 5f812bee5..d7896b33b 100644
--- a/internal/deref/deref_test.go
+++ b/internal/deref/deref_test.go
@@ -15,7 +15,7 @@ func TestDeref(t *testing.T) {
 	c := &b
 	d := &c
 
-	got := deref.Deref(d)
+	got := deref.Interface(d)
 	assert.Equal(t, uint(42), got)
 }
 
@@ -25,14 +25,14 @@ func TestDeref_mix_ptr_with_interface(t *testing.T) {
 	var c any = &b
 	d := &c
 
-	got := deref.Deref(d)
+	got := deref.Interface(d)
 	assert.Equal(t, uint(42), got)
 }
 
 func TestDeref_nil(t *testing.T) {
 	var a *int
-	assert.Nil(t, deref.Deref(a))
-	assert.Nil(t, deref.Deref(nil))
+	assert.Nil(t, deref.Interface(a))
+	assert.Nil(t, deref.Interface(nil))
 }
 
 func TestType(t *testing.T) {
diff --git a/vm/vm.go b/vm/vm.go
index fb1d772c1..de13cade1 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -457,7 +457,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 
 		case OpDeref:
 			a := vm.pop()
-			vm.push(deref.Deref(a))
+			vm.push(deref.Interface(a))
 
 		case OpIncrementIndex:
 			vm.scope().Index++

From a9cda30aa51cf1f44fa02356c025473b18f5cef7 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 10 Mar 2025 15:00:21 +0100
Subject: [PATCH 405/506] Test for issue 756

Fixes #756
---
 test/issues/756/issue_test.go | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 test/issues/756/issue_test.go

diff --git a/test/issues/756/issue_test.go b/test/issues/756/issue_test.go
new file mode 100644
index 000000000..93180a27a
--- /dev/null
+++ b/test/issues/756/issue_test.go
@@ -0,0 +1,31 @@
+package issue_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+type X struct{}
+
+func (x *X) HelloCtx(ctx context.Context, text string) error {
+	return nil
+}
+
+func TestIssue756(t *testing.T) {
+	env := map[string]any{
+		"_goctx_": context.TODO(),
+		"_g_": map[string]*X{
+			"rpc": {},
+		},
+		"text": "еуче",
+	}
+	exprStr := `let v = _g_.rpc.HelloCtx(text); v`
+	program, err := expr.Compile(exprStr, expr.Env(env), expr.WithContext("_goctx_"))
+	require.NoError(t, err)
+
+	_, err = expr.Run(program, env)
+	require.NoError(t, err)
+}

From 25690fe0143fb89027f0d6a01cafcc437472a464 Mon Sep 17 00:00:00 2001
From: 2pac <tarasyaremabcn@gmail.com>
Date: Thu, 13 Mar 2025 14:10:14 +0100
Subject: [PATCH 406/506] chore: Added SOLO to the companies list (#769)

Signed-off-by: 2pac <tarasyaremabcn@gmail.com>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index ab4f2baaa..c0778a84d 100644
--- a/README.md
+++ b/README.md
@@ -170,6 +170,7 @@ func main() {
 * [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate).
 * [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system.
 * [WunderGraph Cosmo](https://github.com/wundergraph/cosmo) - GraphQL Federeration Router uses Expr to customize Middleware behaviour
+* [SOLO](https://solo.one) uses Expr interally to allow dynamic code execution with custom defined functions.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From 3be6386f86a53e713a5b083e33582d94710653cc Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 15 Mar 2025 16:41:40 +0100
Subject: [PATCH 407/506] Code style: remove repeated helper functions

---
 checker/nature/nature.go |  8 ++------
 checker/nature/utils.go  |  4 ----
 checker/types.go         | 12 +-----------
 3 files changed, 3 insertions(+), 21 deletions(-)

diff --git a/checker/nature/nature.go b/checker/nature/nature.go
index e25fbf219..993c9fcf8 100644
--- a/checker/nature/nature.go
+++ b/checker/nature/nature.go
@@ -25,10 +25,6 @@ type Nature struct {
 	FieldIndex      []int             // Index of field in type.
 }
 
-func (n Nature) IsNil() bool {
-	return n.Nil
-}
-
 func (n Nature) IsAny() bool {
 	return n.Kind() == reflect.Interface && n.NumMethods() == 0
 }
@@ -37,7 +33,7 @@ func (n Nature) IsUnknown() bool {
 	switch {
 	case n.Type == nil && !n.Nil:
 		return true
-	case isAny(n):
+	case n.IsAny():
 		return true
 	}
 	return false
@@ -92,7 +88,7 @@ func (n Nature) Elem() Nature {
 func (n Nature) AssignableTo(nt Nature) bool {
 	if n.Nil {
 		// Untyped nil is assignable to any interface, but implements only the empty interface.
-		if isAny(nt) {
+		if nt.IsAny() {
 			return true
 		}
 	}
diff --git a/checker/nature/utils.go b/checker/nature/utils.go
index 8d07ce48c..c242f91a6 100644
--- a/checker/nature/utils.go
+++ b/checker/nature/utils.go
@@ -6,10 +6,6 @@ import (
 	"github.com/expr-lang/expr/internal/deref"
 )
 
-func isAny(nt Nature) bool {
-	return nt.Kind() == reflect.Interface && nt.NumMethods() == 0
-}
-
 func fieldName(field reflect.StructField) string {
 	if taggedName := field.Tag.Get("expr"); taggedName != "" {
 		return taggedName
diff --git a/checker/types.go b/checker/types.go
index 7912931c5..09896de5d 100644
--- a/checker/types.go
+++ b/checker/types.go
@@ -71,17 +71,7 @@ func or(l, r Nature, fns ...func(Nature) bool) bool {
 }
 
 func isUnknown(nt Nature) bool {
-	switch {
-	case nt.Type == nil && !nt.Nil:
-		return true
-	case isAny(nt):
-		return true
-	}
-	return false
-}
-
-func isAny(nt Nature) bool {
-	return nt.Kind() == reflect.Interface && nt.NumMethods() == 0
+	return nt.IsUnknown()
 }
 
 func isInteger(nt Nature) bool {

From 1598c621e1813e22893ea731c0b8b2e6ee357bcd Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 16 Mar 2025 10:35:06 +0100
Subject: [PATCH 408/506] Update language-definition.md

---
 docs/language-definition.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/docs/language-definition.md b/docs/language-definition.md
index 640c7d63b..5e530a57d 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -697,6 +697,14 @@ Flattens given array into one-dimensional array.
 flatten([1, 2, [3, 4]]) == [1, 2, 3, 4]
 ```
 
+### uniq(array) {#uniq}
+
+Removes duplicates from an array.
+
+```expr
+uniq([1, 2, 3, 2, 1]) == [1, 2, 3]
+```
+
 ### join(array[, delimiter]) {#join}
 
 Joins an array of strings into a single string with the given delimiter.

From 8419ba4a916cd5036c6a847ae810f63485ead0f9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 17 Mar 2025 10:10:42 +0100
Subject: [PATCH 409/506] Update SECURITY.md

---
 SECURITY.md | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/SECURITY.md b/SECURITY.md
index 8d692a398..e18771f5d 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -11,11 +11,8 @@ unless this is not possible or feasible with a reasonable effort.
 
 | Version | Supported          |
 |---------|--------------------|
-| 1.16    | :white_check_mark: |
-| 1.15    | :white_check_mark: |
-| 1.14    | :white_check_mark: |
-| 1.13    | :white_check_mark: |
-| < 1.13  | :x:                |
+| 1.x     | :white_check_mark: |
+| 0.x     | :x:                |
 
 ## Reporting a Vulnerability
 

From 0f99b19176217bbe49ba348b7120c486f1560d9e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 17 Mar 2025 14:28:04 +0100
Subject: [PATCH 410/506] Update docs

---
 docs/configuration.md   | 29 ++++++++++++++---------------
 docs/environment.md     | 20 ++++++++++++++++++--
 docs/functions.md       |  3 +++
 docs/getting-started.md | 16 ++++++----------
 docs/patch.md           | 23 +++++++++++++++++------
 docs/visitor.md         | 13 +++++++++++--
 6 files changed, 69 insertions(+), 35 deletions(-)

diff --git a/docs/configuration.md b/docs/configuration.md
index 511ebd48b..0aaaf99dd 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -6,15 +6,15 @@ Usually, the return type of expression is anything. But we can instruct type che
 expression.
 For example, in filter expressions, we expect the return type to be a boolean.
 
-```go 
+```go
 program, err := expr.Compile(code, expr.AsBool())
 if err != nil {
-panic(err)
+    panic(err)
 }
 
 output, err := expr.Run(program, env)
 if err != nil {
-panic(err)
+    panic(err)
 }
 
 ok := output.(bool) // It is safe to assert the output to bool, if the expression is type checked as bool.
@@ -82,6 +82,9 @@ Function `expr.WithContext()` takes the name of context variable. The context va
 ```go
 env := map[string]any{
     "ctx": context.Background(),
+    "customFunc": func(ctx context.Context, a int) int {
+        return a
+    },
 }
 
 program, err := expr.Compile(code, expr.Env(env), expr.WithContext("ctx"))
@@ -116,20 +119,16 @@ fib(12+12) // will be transformed to 267914296 during the compilation
 fib(x)     // will **not** be transformed and will be evaluated at runtime
 ```
 
-## Options
+## Timezone
 
-Compiler options can be defined as an array:
+By default, the timezone is set to `time.Local`. We can change the timezone via the [`Timezone`](https://pkg.go.dev/github.com/expr-lang/expr#Timezone) option.
 
 ```go
-options := []expr.Option{
-    expr.Env(Env{})
-    expr.AsInt(),
-    expr.WarnOnAny(),
-    expr.WithContext("ctx"),
-    expr.ConstExpr("fib"),
-}
-
-program, err := expr.Compile(code, options...)
+program, err := expr.Compile(code, expr.Timezone(time.UTC))
 ```
 
-Full list of available options can be found in the [pkg.go.dev](https://pkg.go.dev/github.com/expr-lang/expr#Option) documentation.
+The timezone is used for the following functions:
+```expr
+date("2024-11-23 12:00:00") // parses the date in the specified timezone
+now() // returns the current time in the specified timezone
+```
diff --git a/docs/environment.md b/docs/environment.md
index 2ae2f0af6..450e9e30c 100644
--- a/docs/environment.md
+++ b/docs/environment.md
@@ -84,12 +84,28 @@ is the value's type.
 env := map[string]any{
     "object": map[string]any{
         "field": 42,
-    }, 
+    },
+    "struct": struct {
+        Field int `expr:"field"`
+    }{42},
 }
 ```
 
 Expr will infer the type of the `object` variable as `map[string]any`.
+Accessing fields of the `object` and `struct` variables will return the following results.
 
-By default, Expr will return an error if unknown variables are used in the expression.
+```expr
+object.field   // 42
+object.unknown // nil (no error)
+
+struct.field   // 42
+struct.unknown // error (unknown field)
+
+foobar         // error (unknown variable)
+```
 
+:::note
+The `foobar` variable is not defined in the environment.
+By default, Expr will return an error if unknown variables are used in the expression.
 You can disable this behavior by passing [`AllowUndefinedVariables`](https://pkg.go.dev/github.com/expr-lang/expr#AllowUndefinedVariables) option to the compiler.
+:::
diff --git a/docs/functions.md b/docs/functions.md
index 03b5b9641..0e2783ed3 100644
--- a/docs/functions.md
+++ b/docs/functions.md
@@ -49,6 +49,7 @@ atoi := expr.Function(
     func(params ...any) (any, error) {
         return strconv.Atoi(params[0].(string))
     },
+    // highlight-next-line
     new(func(string) int),
 )
 ```
@@ -80,7 +81,9 @@ toInt := expr.Function(
         }
         return nil, fmt.Errorf("invalid type")
     },
+    // highlight-start
     new(func(float64) int),
     new(func(string) int),
+    // highlight-end
 )
 ```
diff --git a/docs/getting-started.md b/docs/getting-started.md
index 8ee14fd49..6ff7fc852 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -72,6 +72,7 @@ env := map[string]any{
 
 program, err := expr.Compile(`name + age`, expr.Env(env))
 if err != nil {
+    // highlight-next-line
     panic(err) // Will panic with "invalid operation: string + int"
 }
 ```
@@ -85,9 +86,7 @@ env := map[string]any{
     "sprintf": fmt.Sprintf,
 }
 
-code := `sprintf(greet, names[0])`
-
-program, err := expr.Compile(code, expr.Env(env))
+program, err := expr.Compile(`sprintf(greet, names[0])`, expr.Env(env))
 if err != nil {
     panic(err)
 }
@@ -100,17 +99,14 @@ if err != nil {
 fmt.Print(output) // Hello, world!
 ```
 
-Also, Expr can use a struct as an environment. Methods defined on the struct become functions.
-The struct fields can be renamed with the `expr` tag. 
-
-Here is an example:
+Also, Expr can use a struct as an environment. Here is an example:
 
 ```go
 type Env struct {
     Posts []Post `expr:"posts"`
 }
 
-func (Env) Format(t time.Time) string { 
+func (Env) Format(t time.Time) string { // Methods defined on the struct become functions. 
     return t.Format(time.RFC822) 
 }
 
@@ -122,7 +118,7 @@ type Post struct {
 func main() {
     code := `map(posts, Format(.Date) + ": " + .Body)`
     
-    program, err := expr.Compile(code, expr.Env(Env{}))
+    program, err := expr.Compile(code, expr.Env(Env{})) // Pass the struct as an environment.
     if err != nil {
         panic(err)
     }
@@ -172,7 +168,7 @@ if err != nil {
 fmt.Print(output) // 7
 ```
 
-:::tip
+:::info Eval = Compile + Run
 For one-off expressions, you can use the `expr.Eval` function. It compiles and runs the expression in one step.
 ```go
 output, err := expr.Eval(`2 + 2`, env)
diff --git a/docs/patch.md b/docs/patch.md
index 835e78f6a..b3df6648c 100644
--- a/docs/patch.md
+++ b/docs/patch.md
@@ -1,8 +1,8 @@
 # Patch
 
 Sometimes it may be necessary to modify an expression before the compilation.
-Expr provides a powerful mechanism to modify the expression using
-the [`Patch`](https://pkg.go.dev/github.com/expr-lang/expr#Patch) option.
+For example, you may want to replace a variable with a constant, transform an expression into a function call, 
+or even modify the expression to use a different operator.
 
 ## Simple example
 
@@ -19,12 +19,15 @@ type FooPatcher struct{}
 
 func (FooPatcher) Visit(node *ast.Node) {
     if n, ok := (*node).(*ast.IdentifierNode); ok && n.Value == "foo" {
+        // highlight-next-line
         ast.Patch(node, &ast.IntegerNode{Value: 42})
     }
 }
 ```
 
-Now we can use the `FooPatcher` to modify the expression:
+We used the [ast.Patch](https://pkg.go.dev/github.com/expr-lang/expr/ast#Patch) function to replace the `foo` variable with an integer node.
+
+Now we can use the `FooPatcher` to modify the expression on compilation via the [expr.Patch](https://pkg.go.dev/github.com/expr-lang/expr#Patch) option:
 
 ```go
 program, err := expr.Compile(`foo + bar`, expr.Patch(FooPatcher{}))
@@ -61,17 +64,24 @@ var decimalType = reflect.TypeOf(Decimal{})
 
 func (DecimalPatcher) Visit(node *ast.Node) {
     if n, ok := (*node).(*ast.BinaryNode); ok && n.Operator == "+" {
+        
         if !n.Left.Type().AssignableTo(decimalType) {
             return // skip, left side is not a Decimal
         }
+		
         if !n.Right.Type().AssignableTo(decimalType) {
             return // skip, right side is not a Decimal
         }
-        ast.Patch(node, &ast.CallNode{
+		
+        // highlight-start
+        callNode := &ast.CallNode{
             Callee:    &ast.IdentifierNode{Value: "add"},
             Arguments: []ast.Node{n.Left, n.Right},
-        })
-        (*node).SetType(decimalType) // set the type, so patcher can be used multiple times
+        }
+        ast.Patch(node, callNode)
+        // highlight-end
+		
+        (*node).SetType(decimalType) // set the type, so the patcher can be applied recursively
     }
 }
 ```
@@ -97,6 +107,7 @@ env := map[string]interface{}{
 
 code := `a + b + c`
 
+// highlight-next-line
 program, err := expr.Compile(code, expr.Env(env), expr.Patch(DecimalPatcher{}))
 if err != nil {
     panic(err)
diff --git a/docs/visitor.md b/docs/visitor.md
index 24532d3da..f771c62ef 100644
--- a/docs/visitor.md
+++ b/docs/visitor.md
@@ -1,11 +1,13 @@
 # Visitor
 
-Expr provides an interface to traverse the AST of the expression before the compilation.
+Expr provides an interface to traverse the <span title="Abstract Syntax Tree" style={{borderBottom: "1px dotted currentColor"}}>AST</span> of the expression before the compilation.
 The `Visitor` interface allows you to collect information about the expression, modify the expression, or even generate
 a new expression.
 
 Let's start with an [ast.Visitor](https://pkg.go.dev/github.com/expr-lang/expr/ast#Visitor) implementation which will 
-collect all variables used in the expression:
+collect all variables used in the expression.
+
+Visitor must implement a single method `Visit(*ast.Node)`, which will be called for each node in the AST.
 
 ```go
 type Visitor struct {
@@ -30,6 +32,7 @@ if err != nil {
 }
 
 v := &Visitor{}
+// highlight-next-line
 ast.Walk(&tree.Node, v)
 
 fmt.Println(v.Identifiers) // [foo, bar]
@@ -40,6 +43,12 @@ fmt.Println(v.Identifiers) // [foo, bar]
 Although it is possible to access the AST of compiled program, it may be already be modified by patchers, optimizers, etc.
 
 ```go
+program, err := expr.Compile(`foo + bar`)
+if err != nil {
+    panic(err)
+}
+
+// highlight-next-line
 node := program.Node()
 
 v := &Visitor{}

From e135bda12b39f28b59545530229fbcab51efbaf4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 18 Mar 2025 10:49:13 +0100
Subject: [PATCH 411/506] Fix parsing of variable declaration nodes combined
 with sequence node (#773)

Fixes #772
---
 parser/parser.go      |  6 ++--
 parser/parser_test.go | 72 +++++++++++++++++++++++++++++++------------
 2 files changed, 56 insertions(+), 22 deletions(-)

diff --git a/parser/parser.go b/parser/parser.go
index 5ba16d2a2..91c0fa8f8 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -323,13 +323,13 @@ func (p *parser) parseConditional(node Node) Node {
 		p.next()
 
 		if !p.current.Is(Operator, ":") {
-			expr1 = p.parseSequenceExpression()
+			expr1 = p.parseExpression(0)
 			p.expect(Operator, ":")
-			expr2 = p.parseSequenceExpression()
+			expr2 = p.parseExpression(0)
 		} else {
 			p.next()
 			expr1 = node
-			expr2 = p.parseSequenceExpression()
+			expr2 = p.parseExpression(0)
 		}
 
 		node = p.createNode(&ConditionalNode{
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 9c707856d..16dac6b79 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -683,18 +683,20 @@ world`},
 			},
 		},
 		{
-			"true ? 1; 2; 3 : 4",
-			&ConditionalNode{
-				Cond: &BoolNode{Value: true},
-				Exp1: &SequenceNode{
-					Nodes: []Node{
-						&IntegerNode{Value: 1},
-						&IntegerNode{Value: 2},
-						&IntegerNode{Value: 3}}},
-				Exp2: &IntegerNode{Value: 4}},
+			"true ? 1 : 2; 3 ; 4",
+			&SequenceNode{
+				Nodes: []Node{
+					&ConditionalNode{
+						Cond: &BoolNode{Value: true},
+						Exp1: &IntegerNode{Value: 1},
+						Exp2: &IntegerNode{Value: 2}},
+					&IntegerNode{Value: 3},
+					&IntegerNode{Value: 4},
+				},
+			},
 		},
 		{
-			"true ? 1 : 2; 3 ; 4",
+			"true ? 1 : ( 2; 3; 4 )",
 			&ConditionalNode{
 				Cond: &BoolNode{Value: true},
 				Exp1: &IntegerNode{Value: 1},
@@ -702,18 +704,50 @@ world`},
 					Nodes: []Node{
 						&IntegerNode{Value: 2},
 						&IntegerNode{Value: 3},
-						&IntegerNode{Value: 4}}}},
+						&IntegerNode{Value: 4},
+					},
+				},
+			},
 		},
 		{
 			"true ?: 1; 2; 3",
-			&ConditionalNode{
-				Cond: &BoolNode{Value: true},
-				Exp1: &BoolNode{Value: true},
-				Exp2: &SequenceNode{
-					Nodes: []Node{
-						&IntegerNode{Value: 1},
-						&IntegerNode{Value: 2},
-						&IntegerNode{Value: 3}}}},
+			&SequenceNode{
+				Nodes: []Node{
+					&ConditionalNode{
+						Cond: &BoolNode{Value: true},
+						Exp1: &BoolNode{Value: true},
+						Exp2: &IntegerNode{Value: 1}},
+					&IntegerNode{Value: 2},
+					&IntegerNode{Value: 3},
+				},
+			},
+		},
+		{
+			`let x = true ? 1 : 2; x`,
+			&VariableDeclaratorNode{
+				Name: "x",
+				Value: &ConditionalNode{
+					Cond: &BoolNode{Value: true},
+					Exp1: &IntegerNode{Value: 1},
+					Exp2: &IntegerNode{Value: 2}},
+				Expr: &IdentifierNode{Value: "x"}},
+		},
+		{
+			"let x = true ? 1 : ( 2; 3; 4 ); x",
+			&VariableDeclaratorNode{
+				Name: "x",
+				Value: &ConditionalNode{
+					Cond: &BoolNode{Value: true},
+					Exp1: &IntegerNode{Value: 1},
+					Exp2: &SequenceNode{
+						Nodes: []Node{
+							&IntegerNode{Value: 2},
+							&IntegerNode{Value: 3},
+							&IntegerNode{Value: 4},
+						},
+					},
+				},
+				Expr: &IdentifierNode{Value: "x"}},
 		},
 		{
 			"if true { 1; 2; 3 } else { 4; 5; 6 }",

From 437bc8e5730238db5d30184a57a239507a533c86 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 18 Mar 2025 23:08:02 +0100
Subject: [PATCH 412/506] Refactor random code get

---
 test/gen/env.go      |  47 +++++++
 test/gen/gen.go      | 298 ++++++++++++++++++++-----------------------
 test/gen/gen_test.go |   4 +-
 test/gen/utils.go    |  36 ++----
 4 files changed, 195 insertions(+), 190 deletions(-)
 create mode 100644 test/gen/env.go

diff --git a/test/gen/env.go b/test/gen/env.go
new file mode 100644
index 000000000..a2a7b0ce1
--- /dev/null
+++ b/test/gen/env.go
@@ -0,0 +1,47 @@
+package main
+
+var Env = map[string]any{
+	"ok":        true,
+	"i":         1,
+	"str":       "str",
+	"f64":       .5,
+	"f32":       float32(.5),
+	"i64":       int64(1),
+	"i32":       int32(2),
+	"u64":       uint64(4),
+	"u32":       uint32(5),
+	"u16":       uint16(6),
+	"u8":        uint8(7),
+	"array":     []int{1, 2, 3, 4, 5},
+	"foo":       Foo{"foo"},
+	"bar":       Bar{42, "bar"},
+	"listOfFoo": []Foo{{"bar"}, {"baz"}},
+	"add":       func(a, b int) int { return a + b },
+	"div":       func(a, b int) int { return a / b },
+	"half":      func(a float64) float64 { return a / 2 },
+	"sumUp": func(a int, x ...int) int {
+		s := a
+		for _, n := range x {
+			s += n
+		}
+		return s
+	},
+	"greet": func(name string) string { return "Hello, " + name },
+}
+
+type Foo struct {
+	Bar string
+}
+
+func (f Foo) String() string {
+	return "foo"
+}
+
+func (f Foo) Qux(s string) string {
+	return f.Bar + s
+}
+
+type Bar struct {
+	I   int    `expr:"i"`
+	Str string `expr:"str"`
+}
diff --git a/test/gen/gen.go b/test/gen/gen.go
index 1eb36c9bf..4e184621d 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -2,50 +2,14 @@ package main
 
 import (
 	"fmt"
-	"math/rand"
 	"reflect"
 	"runtime/debug"
+	"strings"
 
 	"github.com/expr-lang/expr"
-	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
 )
 
-var env = map[string]any{
-	"ok":    true,
-	"f64":   .5,
-	"f32":   float32(.5),
-	"i":     1,
-	"i64":   int64(1),
-	"i32":   int32(1),
-	"array": []int{1, 2, 3, 4, 5},
-	"list":  []Foo{{"bar"}, {"baz"}},
-	"foo":   Foo{"bar"},
-	"add":   func(a, b int) int { return a + b },
-	"div":   func(a, b int) int { return a / b },
-	"half":  func(a float64) float64 { return a / 2 },
-	"score": func(a int, x ...int) int {
-		s := a
-		for _, n := range x {
-			s += n
-		}
-		return s
-	},
-	"greet": func(name string) string { return "Hello, " + name },
-}
-
-type Foo struct {
-	Bar string
-}
-
-func (f Foo) String() string {
-	return "foo"
-}
-
-func (f Foo) Qux(s string) string {
-	return f.Bar + s
-}
-
 var (
 	dict       []string
 	predicates []string
@@ -83,7 +47,7 @@ var (
 )
 
 func init() {
-	for name, x := range env {
+	for name, x := range Env {
 		dict = append(dict, name)
 		v := reflect.ValueOf(x)
 		if v.Kind() == reflect.Struct {
@@ -121,7 +85,7 @@ func main() {
 	var corpus = map[string]struct{}{}
 
 	for {
-		code = node(weightedRandomInt([]intWeight{
+		code = node(oneOf(list[int]{
 			{3, 100},
 			{4, 40},
 			{5, 50},
@@ -130,13 +94,13 @@ func main() {
 			{8, 10},
 			{9, 5},
 			{10, 5},
-		})).String()
+		}))
 
-		program, err := expr.Compile(code, expr.Env(env))
+		program, err := expr.Compile(code, expr.Env(Env))
 		if err != nil {
 			continue
 		}
-		_, err = expr.Run(program, env)
+		_, err = expr.Run(program, Env)
 		if err != nil {
 			continue
 		}
@@ -149,9 +113,11 @@ func main() {
 	}
 }
 
-func node(depth int) ast.Node {
+type fn func(depth int) string
+
+func node(depth int) string {
 	if depth <= 0 {
-		return weightedRandom([]fnWeight{
+		return oneOf(list[fn]{
 			{nilNode, 1},
 			{floatNode, 1},
 			{integerNode, 1},
@@ -161,7 +127,7 @@ func node(depth int) ast.Node {
 			{pointerNode, 10},
 		})(depth - 1)
 	}
-	return weightedRandom([]fnWeight{
+	return oneOf(list[fn]{
 		{arrayNode, 1},
 		{mapNode, 1},
 		{identifierNode, 1000},
@@ -169,6 +135,7 @@ func node(depth int) ast.Node {
 		{unaryNode, 100},
 		{binaryNode, 2000},
 		{callNode, 2000},
+		{pipeNode, 1000},
 		{builtinNode, 500},
 		{predicateNode, 1000},
 		{pointerNode, 500},
@@ -177,183 +144,192 @@ func node(depth int) ast.Node {
 	})(depth - 1)
 }
 
-func nilNode(_ int) ast.Node {
-	return &ast.NilNode{}
+func nilNode(_ int) string {
+	return "nil"
 }
 
-func floatNode(_ int) ast.Node {
-	return &ast.FloatNode{
-		Value: .5,
-	}
+func floatNode(_ int) string {
+	return oneOf(list[string]{
+		{"1.0", 1},
+		{".5", 1},
+		{"0.0", 1},
+		{"-1.0", 1},
+		{"1e+10", 1},
+		{"1e-10", 1},
+	})
 }
 
-func integerNode(_ int) ast.Node {
-	return &ast.IntegerNode{
-		Value: 1,
-	}
+func integerNode(_ int) string {
+	return oneOf(list[string]{
+		{"1", 1},
+		{"2", 1},
+		{"-1", 1},
+		{"0", 1},
+	})
 }
 
-func stringNode(_ int) ast.Node {
-	words := []string{
-		"foo",
-		"bar",
-	}
-	return &ast.StringNode{
-		Value: words[rand.Intn(len(words))],
-	}
+func stringNode(_ int) string {
+	return oneOf(list[string]{
+		{"foo", 1},
+		{"bar", 1},
+		{"str", 1},
+	})
 }
 
-func booleanNode(_ int) ast.Node {
-	return &ast.BoolNode{
-		Value: maybe(),
+func booleanNode(_ int) string {
+	if maybe() {
+		return "true"
 	}
+	return "false"
 }
 
-func identifierNode(_ int) ast.Node {
-	return &ast.IdentifierNode{
-		Value: dict[rand.Intn(len(dict))],
-	}
+func identifierNode(_ int) string {
+	return random(dict)
 }
 
-func memberNode(depth int) ast.Node {
-	return &ast.MemberNode{
-		Node: node(depth - 1),
-		Property: weightedRandom([]fnWeight{
-			{func(_ int) ast.Node { return &ast.StringNode{Value: dict[rand.Intn(len(dict))]} }, 5},
-			{node, 1},
-		})(depth - 1),
-		Optional: maybe(),
+func memberNode(depth int) string {
+	dot := "."
+	if maybe() {
+		dot = "?."
 	}
+	prop := oneOf(list[fn]{
+		{func(_ int) string { return random(dict) }, 5},
+		{node, 1},
+	})(depth - 1)
+	if maybe() {
+		return fmt.Sprintf("%v%v%v", node(depth-1), dot, prop)
+	}
+	return fmt.Sprintf("%v%v[%v]", node(depth-1), dot, prop)
 }
 
-func unaryNode(depth int) ast.Node {
-	cases := []string{"-", "!", "not"}
-	return &ast.UnaryNode{
-		Operator: cases[rand.Intn(len(cases))],
-		Node:     node(depth - 1),
-	}
+func unaryNode(depth int) string {
+	return random([]string{"-", "!", "not"})
 }
 
-func binaryNode(depth int) ast.Node {
-	return &ast.BinaryNode{
-		Operator: operators[rand.Intn(len(operators))],
-		Left:     node(depth - 1),
-		Right:    node(depth - 1),
-	}
+func binaryNode(depth int) string {
+	return fmt.Sprintf("%v %v %v", node(depth-1), random(operators), node(depth-1))
 }
 
-func methodNode(depth int) ast.Node {
-	return &ast.MemberNode{
-		Node:     node(depth - 1),
-		Property: &ast.StringNode{Value: dict[rand.Intn(len(dict))]},
-		Optional: maybe(),
+func methodNode(depth int) string {
+	dot := "."
+	if maybe() {
+		dot = "?."
+	}
+	method := random(dict)
+	if maybe() {
+		return fmt.Sprintf("%v%v%v", node(depth-1), dot, method)
 	}
+	return fmt.Sprintf("%v%v[%v]", node(depth-1), dot, method)
 }
 
-func funcNode(_ int) ast.Node {
-	return &ast.IdentifierNode{
-		Value: dict[rand.Intn(len(dict))],
-	}
+func funcNode(_ int) string {
+	return random(dict)
 }
 
-func callNode(depth int) ast.Node {
-	var args []ast.Node
-	max := weightedRandomInt([]intWeight{
+func callNode(depth int) string {
+	var args []string
+	for i := 0; i < oneOf(list[int]{
 		{0, 100},
 		{1, 100},
 		{2, 50},
 		{3, 25},
 		{4, 10},
 		{5, 5},
-	})
-	for i := 0; i < max; i++ {
+	}); i++ {
 		args = append(args, node(depth-1))
 	}
-	return &ast.CallNode{
-		Callee: weightedRandom([]fnWeight{
-			{methodNode, 2},
-			{funcNode, 2},
-		})(depth - 1),
-		Arguments: args,
-	}
+
+	fn := oneOf(list[fn]{
+		{methodNode, 2},
+		{funcNode, 2},
+	})(depth - 1)
+
+	return fmt.Sprintf("%v(%v)", fn, strings.Join(args, ", "))
+}
+
+func pipeNode(depth int) string {
+	a := node(depth - 1)
+	b := oneOf(list[fn]{
+		{callNode, 2},
+		{builtinNode, 5},
+		{predicateNode, 10},
+	})(depth - 1)
+
+	return fmt.Sprintf("%v | %v", a, b)
 }
 
-func builtinNode(depth int) ast.Node {
-	var args []ast.Node
-	max := weightedRandomInt([]intWeight{
+func builtinNode(depth int) string {
+	var args []string
+	for i := 0; i < oneOf(list[int]{
 		{1, 100},
 		{2, 50},
 		{3, 50},
 		{4, 10},
-	})
-	for i := 0; i < max; i++ {
+	}); i++ {
 		args = append(args, node(depth-1))
 	}
-	return &ast.BuiltinNode{
-		Name:      builtins[rand.Intn(len(builtins))],
-		Arguments: args,
-	}
+	return fmt.Sprintf("%v(%v)", random(builtins), strings.Join(args, ", "))
 }
 
-func predicateNode(depth int) ast.Node {
-	return &ast.BuiltinNode{
-		Name: predicates[rand.Intn(len(predicates))],
-		Arguments: []ast.Node{
-			node(depth - 1),
-			node(depth - 1),
-		},
+func predicateNode(depth int) string {
+	var args []string
+	for i := 0; i < oneOf(list[int]{
+		{1, 100},
+		{2, 50},
+		{3, 50},
+	}); i++ {
+		args = append(args, node(depth-1))
 	}
+	return fmt.Sprintf("%v(%v)", random(builtins), strings.Join(args, ", "))
 }
 
-func pointerNode(_ int) ast.Node {
-	return &ast.PointerNode{}
+func pointerNode(_ int) string {
+	return oneOf(list[string]{
+		{"#", 100},
+		{"#." + random(dict), 100},
+		{"." + random(dict), 100},
+		{"#acc", 10},
+		{"#index", 10},
+	})
 }
 
-func arrayNode(depth int) ast.Node {
-	var items []ast.Node
-	max := weightedRandomInt([]intWeight{
+func arrayNode(depth int) string {
+	var items []string
+	for i := 0; i < oneOf(list[int]{
 		{1, 100},
 		{2, 50},
 		{3, 25},
-	})
-	for i := 0; i < max; i++ {
+	}); i++ {
 		items = append(items, node(depth-1))
 	}
-	return &ast.ArrayNode{
-		Nodes: items,
-	}
+	return fmt.Sprintf("[%v]", strings.Join(items, ", "))
 }
 
-func mapNode(depth int) ast.Node {
-	var items []ast.Node
-	max := weightedRandomInt([]intWeight{
+func mapNode(depth int) string {
+	var items []string
+	for i := 0; i < oneOf(list[int]{
 		{1, 100},
 		{2, 50},
 		{3, 25},
-	})
-	for i := 0; i < max; i++ {
-		items = append(items, &ast.PairNode{
-			Key:   stringNode(depth - 1),
-			Value: node(depth - 1),
-		})
-	}
-	return &ast.MapNode{
-		Pairs: items,
+	}); i++ {
+		items = append(items, fmt.Sprintf("%v: %v", stringNode(depth-1), node(depth-1)))
 	}
+	return fmt.Sprintf("{%v}", strings.Join(items, ", "))
 }
 
-func sliceNode(depth int) ast.Node {
-	return &ast.SliceNode{
-		Node: node(depth - 1),
-		From: node(depth - 1),
-		To:   node(depth - 1),
-	}
+func sliceNode(depth int) string {
+	return oneOf(list[string]{
+		{fmt.Sprintf("%v[%v:%v]", node(depth-1), node(depth-1), node(depth-1)), 100},
+		{fmt.Sprintf("%v[%v:]", node(depth-1), node(depth-1)), 100},
+		{fmt.Sprintf("%v[:%v]", node(depth-1), node(depth-1)), 100},
+		{fmt.Sprintf("%v[:]", node(depth-1)), 1},
+	})
 }
 
-func conditionalNode(depth int) ast.Node {
-	return &ast.ConditionalNode{
-		Cond: node(depth - 1),
-		Exp1: node(depth - 1),
-		Exp2: node(depth - 1),
-	}
+func conditionalNode(depth int) string {
+	return oneOf(list[string]{
+		{fmt.Sprintf("if %v { %v } else { %v }", node(depth-1), node(depth-1), node(depth-1)), 100},
+		{fmt.Sprintf("%v ? %v : %v", node(depth-1), node(depth-1), node(depth-1)), 100},
+		{fmt.Sprintf("%v ?: %v", node(depth-1), node(depth-1)), 20},
+	})
 }
diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go
index ef4a30bc8..cb6c08e00 100644
--- a/test/gen/gen_test.go
+++ b/test/gen/gen_test.go
@@ -25,7 +25,7 @@ func TestGenerated(t *testing.T) {
 	for _, line := range strings.Split(examples, "\n") {
 		line := line
 		t.Run(line, func(t *testing.T) {
-			program, err := expr.Compile(line, expr.Env(env))
+			program, err := expr.Compile(line, expr.Env(Env))
 			if err != nil {
 				if !*updateFlag {
 					t.Errorf("Compilation failed: %v", err)
@@ -33,7 +33,7 @@ func TestGenerated(t *testing.T) {
 				return
 			}
 
-			_, err = expr.Run(program, env)
+			_, err = expr.Run(program, Env)
 			if err != nil {
 				if !*updateFlag {
 					t.Errorf("Execution failed: %v", err)
diff --git a/test/gen/utils.go b/test/gen/utils.go
index b485fd1a1..3ef76d0e1 100644
--- a/test/gen/utils.go
+++ b/test/gen/utils.go
@@ -2,27 +2,25 @@ package main
 
 import (
 	"math/rand"
-
-	"github.com/expr-lang/expr/ast"
 )
 
 func maybe() bool {
 	return rand.Intn(2) == 0
 }
 
-type fn func(int) ast.Node
+type list[T any] []element[T]
 
-type fnWeight struct {
-	value  fn
+type element[T any] struct {
+	value  T
 	weight int
 }
 
-func weightedRandom(cases []fnWeight) fn {
-	totalWeight := 0
+func oneOf[T any](cases []element[T]) T {
+	total := 0
 	for _, c := range cases {
-		totalWeight += c.weight
+		total += c.weight
 	}
-	r := rand.Intn(totalWeight)
+	r := rand.Intn(total)
 	for _, c := range cases {
 		if r < c.weight {
 			return c.value
@@ -32,22 +30,6 @@ func weightedRandom(cases []fnWeight) fn {
 	return cases[0].value
 }
 
-type intWeight struct {
-	value  int
-	weight int
-}
-
-func weightedRandomInt(cases []intWeight) int {
-	totalWeight := 0
-	for _, c := range cases {
-		totalWeight += c.weight
-	}
-	r := rand.Intn(totalWeight)
-	for _, c := range cases {
-		if r < c.weight {
-			return c.value
-		}
-		r -= c.weight
-	}
-	return cases[0].value
+func random[T any](array []T) T {
+	return array[rand.Intn(len(array))]
 }

From dc7c30218dc15f496c259431cf6ffd1e545836b0 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 18 Mar 2025 23:20:00 +0100
Subject: [PATCH 413/506] gen: use all cpus

---
 test/gen/gen.go | 93 ++++++++++++++++++++++++++++++-------------------
 1 file changed, 57 insertions(+), 36 deletions(-)

diff --git a/test/gen/gen.go b/test/gen/gen.go
index 4e184621d..184ae46ed 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -3,8 +3,10 @@ package main
 import (
 	"fmt"
 	"reflect"
+	"runtime"
 	"runtime/debug"
 	"strings"
+	"sync"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/builtin"
@@ -74,43 +76,62 @@ func init() {
 }
 
 func main() {
-	var code string
-	defer func() {
-		if r := recover(); r != nil {
-			fmt.Printf("==========================\n%s\n==========================\n%s\n==========================\n", code, r)
-			debug.PrintStack()
-		}
-	}()
-
-	var corpus = map[string]struct{}{}
-
-	for {
-		code = node(oneOf(list[int]{
-			{3, 100},
-			{4, 40},
-			{5, 50},
-			{6, 30},
-			{7, 20},
-			{8, 10},
-			{9, 5},
-			{10, 5},
-		}))
-
-		program, err := expr.Compile(code, expr.Env(Env))
-		if err != nil {
-			continue
-		}
-		_, err = expr.Run(program, Env)
-		if err != nil {
-			continue
-		}
-
-		if _, ok := corpus[code]; ok {
-			continue
-		}
-		corpus[code] = struct{}{}
-		fmt.Println(code)
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	var corpus = make(map[string]struct{})
+	var corpusMutex sync.Mutex
+
+	numWorkers := runtime.NumCPU()
+	var wg sync.WaitGroup
+	wg.Add(numWorkers)
+
+	for i := 0; i < numWorkers; i++ {
+		go func(workerID int) {
+			defer func() {
+				if r := recover(); r != nil {
+					fmt.Printf("Worker %d recovered from panic: %v\n", workerID, r)
+					debug.PrintStack()
+				}
+			}()
+
+			defer wg.Done()
+			for {
+				var code string
+
+				code = node(oneOf(list[int]{
+					{3, 100},
+					{4, 40},
+					{5, 50},
+					{6, 30},
+					{7, 20},
+					{8, 10},
+					{9, 5},
+					{10, 5},
+				}))
+
+				program, err := expr.Compile(code, expr.Env(Env))
+				if err != nil {
+					continue
+				}
+				_, err = expr.Run(program, Env)
+				if err != nil {
+					continue
+				}
+
+				corpusMutex.Lock()
+				if _, exists := corpus[code]; exists {
+					corpusMutex.Unlock()
+					continue
+				}
+				corpus[code] = struct{}{}
+				corpusMutex.Unlock()
+
+				fmt.Println(code)
+			}
+		}(i)
 	}
+
+	wg.Wait()
 }
 
 type fn func(depth int) string

From a81f28a14747aa1f64eb5be4ec306253e497cf5d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 18 Mar 2025 23:38:28 +0100
Subject: [PATCH 414/506] gen: simplify search

---
 test/gen/env.go | 42 ++++++++----------------------------------
 test/gen/gen.go | 22 +++-------------------
 2 files changed, 11 insertions(+), 53 deletions(-)

diff --git a/test/gen/env.go b/test/gen/env.go
index a2a7b0ce1..077575280 100644
--- a/test/gen/env.go
+++ b/test/gen/env.go
@@ -1,31 +1,14 @@
 package main
 
 var Env = map[string]any{
-	"ok":        true,
-	"i":         1,
-	"str":       "str",
-	"f64":       .5,
-	"f32":       float32(.5),
-	"i64":       int64(1),
-	"i32":       int32(2),
-	"u64":       uint64(4),
-	"u32":       uint32(5),
-	"u16":       uint16(6),
-	"u8":        uint8(7),
-	"array":     []int{1, 2, 3, 4, 5},
-	"foo":       Foo{"foo"},
-	"bar":       Bar{42, "bar"},
-	"listOfFoo": []Foo{{"bar"}, {"baz"}},
-	"add":       func(a, b int) int { return a + b },
-	"div":       func(a, b int) int { return a / b },
-	"half":      func(a float64) float64 { return a / 2 },
-	"sumUp": func(a int, x ...int) int {
-		s := a
-		for _, n := range x {
-			s += n
-		}
-		return s
-	},
+	"ok":    true,
+	"i":     1,
+	"str":   "str",
+	"f64":   .5,
+	"array": []int{1, 2, 3, 4, 5},
+	"foo":   Foo{"foo"},
+	"list":  []Foo{{"bar"}, {"baz"}},
+	"add":   func(a, b int) int { return a + b },
 	"greet": func(name string) string { return "Hello, " + name },
 }
 
@@ -36,12 +19,3 @@ type Foo struct {
 func (f Foo) String() string {
 	return "foo"
 }
-
-func (f Foo) Qux(s string) string {
-	return f.Bar + s
-}
-
-type Bar struct {
-	I   int    `expr:"i"`
-	Str string `expr:"str"`
-}
diff --git a/test/gen/gen.go b/test/gen/gen.go
index 184ae46ed..02d4cdbef 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -170,38 +170,22 @@ func nilNode(_ int) string {
 }
 
 func floatNode(_ int) string {
-	return oneOf(list[string]{
-		{"1.0", 1},
-		{".5", 1},
-		{"0.0", 1},
-		{"-1.0", 1},
-		{"1e+10", 1},
-		{"1e-10", 1},
-	})
+	return "1.0"
 }
 
 func integerNode(_ int) string {
 	return oneOf(list[string]{
 		{"1", 1},
-		{"2", 1},
-		{"-1", 1},
 		{"0", 1},
 	})
 }
 
 func stringNode(_ int) string {
-	return oneOf(list[string]{
-		{"foo", 1},
-		{"bar", 1},
-		{"str", 1},
-	})
+	return "foo"
 }
 
 func booleanNode(_ int) string {
-	if maybe() {
-		return "true"
-	}
-	return "false"
+	return random([]string{"true", "false"})
 }
 
 func identifierNode(_ int) string {

From ccfad1d322f591b004bd2f56c14028426f4f0bc8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 18 Mar 2025 23:45:05 +0100
Subject: [PATCH 415/506] gen: add vars

---
 test/gen/gen.go | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/test/gen/gen.go b/test/gen/gen.go
index 02d4cdbef..4825c348b 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -149,8 +149,10 @@ func node(depth int) string {
 		})(depth - 1)
 	}
 	return oneOf(list[fn]{
-		{arrayNode, 1},
-		{mapNode, 1},
+		{sequenceNode, 1},
+		{variableNode, 1},
+		{arrayNode, 10},
+		{mapNode, 10},
 		{identifierNode, 1000},
 		{memberNode, 1500},
 		{unaryNode, 100},
@@ -189,6 +191,9 @@ func booleanNode(_ int) string {
 }
 
 func identifierNode(_ int) string {
+	if maybe() {
+		return "x"
+	}
 	return random(dict)
 }
 
@@ -338,3 +343,21 @@ func conditionalNode(depth int) string {
 		{fmt.Sprintf("%v ?: %v", node(depth-1), node(depth-1)), 20},
 	})
 }
+
+func sequenceNode(depth int) string {
+	var items []string
+	for i := 0; i < oneOf(list[int]{
+		{2, 50},
+		{3, 25},
+	}); i++ {
+		items = append(items, node(depth-1))
+	}
+	if maybe() {
+		return strings.Join(items, "; ")
+	}
+	return fmt.Sprintf("(%v)", strings.Join(items, ", "))
+}
+
+func variableNode(depth int) string {
+	return fmt.Sprintf("let x = %v; %v", node(depth-1), node(depth-1))
+}

From 0a4ba824070233a518d47c066a7e8519116c9731 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 18 Mar 2025 23:54:38 +0100
Subject: [PATCH 416/506] gen: add $env

---
 test/gen/gen.go | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/test/gen/gen.go b/test/gen/gen.go
index 4825c348b..9b8b788df 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -140,6 +140,7 @@ func node(depth int) string {
 	if depth <= 0 {
 		return oneOf(list[fn]{
 			{nilNode, 1},
+			{envNode, 1},
 			{floatNode, 1},
 			{integerNode, 1},
 			{stringNode, 1},
@@ -171,6 +172,10 @@ func nilNode(_ int) string {
 	return "nil"
 }
 
+func envNode(_ int) string {
+	return "$env"
+}
+
 func floatNode(_ int) string {
 	return "1.0"
 }
@@ -192,7 +197,7 @@ func booleanNode(_ int) string {
 
 func identifierNode(_ int) string {
 	if maybe() {
-		return "x"
+		return "foobar"
 	}
 	return random(dict)
 }
@@ -359,5 +364,12 @@ func sequenceNode(depth int) string {
 }
 
 func variableNode(depth int) string {
-	return fmt.Sprintf("let x = %v; %v", node(depth-1), node(depth-1))
+	e := node(depth - 1)
+	if e == "foobar" {
+		return "~!@"
+	}
+	if !strings.Contains(e, "foobar") {
+		return "~!@"
+	}
+	return fmt.Sprintf("let foobar = %v; %v", node(depth-1), e)
 }

From 253a4a111873689b6a3e0e8c83c45e29e47da56e Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 18 Mar 2025 23:57:51 +0100
Subject: [PATCH 417/506] gen: less string vars

---
 test/gen/gen.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/test/gen/gen.go b/test/gen/gen.go
index 9b8b788df..2bd06fadd 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -365,9 +365,6 @@ func sequenceNode(depth int) string {
 
 func variableNode(depth int) string {
 	e := node(depth - 1)
-	if e == "foobar" {
-		return "~!@"
-	}
 	if !strings.Contains(e, "foobar") {
 		return "~!@"
 	}

From 27604cf508c84ba0db613db4cdb94544a3539ecc Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 19 Mar 2025 12:32:03 +0100
Subject: [PATCH 418/506] gen: fix predicate generator

---
 test/gen/gen.go | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/test/gen/gen.go b/test/gen/gen.go
index 2bd06fadd..a13a8f810 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -150,21 +150,21 @@ func node(depth int) string {
 		})(depth - 1)
 	}
 	return oneOf(list[fn]{
-		{sequenceNode, 1},
-		{variableNode, 1},
-		{arrayNode, 10},
-		{mapNode, 10},
-		{identifierNode, 1000},
-		{memberNode, 1500},
-		{unaryNode, 100},
-		{binaryNode, 2000},
-		{callNode, 2000},
-		{pipeNode, 1000},
-		{builtinNode, 500},
+		//{sequenceNode, 1},
+		//{variableNode, 1},
+		//{arrayNode, 10},
+		//{mapNode, 10},
+		//{identifierNode, 1000},
+		//{memberNode, 1500},
+		//{unaryNode, 100},
+		//{binaryNode, 2000},
+		//{callNode, 2000},
+		//{pipeNode, 1000},
+		//{builtinNode, 500},
 		{predicateNode, 1000},
-		{pointerNode, 500},
-		{sliceNode, 100},
-		{conditionalNode, 100},
+		//{pointerNode, 500},
+		//{sliceNode, 100},
+		//{conditionalNode, 100},
 	})(depth - 1)
 }
 
@@ -295,7 +295,7 @@ func predicateNode(depth int) string {
 	}); i++ {
 		args = append(args, node(depth-1))
 	}
-	return fmt.Sprintf("%v(%v)", random(builtins), strings.Join(args, ", "))
+	return fmt.Sprintf("%v(%v)", random(predicates), strings.Join(args, ", "))
 }
 
 func pointerNode(_ int) string {

From 6565f13d2a596119bacadd7a4049f30bff1df2d6 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 19 Mar 2025 12:32:26 +0100
Subject: [PATCH 419/506] gen: fix

---
 test/gen/gen.go | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/test/gen/gen.go b/test/gen/gen.go
index a13a8f810..b43b677c0 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -150,21 +150,21 @@ func node(depth int) string {
 		})(depth - 1)
 	}
 	return oneOf(list[fn]{
-		//{sequenceNode, 1},
-		//{variableNode, 1},
-		//{arrayNode, 10},
-		//{mapNode, 10},
-		//{identifierNode, 1000},
-		//{memberNode, 1500},
-		//{unaryNode, 100},
-		//{binaryNode, 2000},
-		//{callNode, 2000},
-		//{pipeNode, 1000},
-		//{builtinNode, 500},
+		{sequenceNode, 1},
+		{variableNode, 1},
+		{arrayNode, 10},
+		{mapNode, 10},
+		{identifierNode, 1000},
+		{memberNode, 1500},
+		{unaryNode, 100},
+		{binaryNode, 2000},
+		{callNode, 2000},
+		{pipeNode, 1000},
+		{builtinNode, 500},
 		{predicateNode, 1000},
-		//{pointerNode, 500},
-		//{sliceNode, 100},
-		//{conditionalNode, 100},
+		{pointerNode, 500},
+		{sliceNode, 100},
+		{conditionalNode, 100},
 	})(depth - 1)
 }
 

From ac5b2c7313f4757672d4a0783ca21225b4f5c44a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Wed, 19 Mar 2025 15:29:59 +0100
Subject: [PATCH 420/506] Update examples.txt

---
 testdata/examples.txt | 38936 +++++++++++++++++++++-------------------
 1 file changed, 20875 insertions(+), 18061 deletions(-)

diff --git a/testdata/examples.txt b/testdata/examples.txt
index 72afdf6ce..557fa9511 100644
--- a/testdata/examples.txt
+++ b/testdata/examples.txt
@@ -1,19545 +1,22359 @@
-!!!false
-!!(1 <= f64)
-!!(1 > 0.5)
-!!(i64 != f64)
-!!all(array, ok)
-!!false
-!!ok
-!!true
-!("bar" != "bar")
-!("bar" != "foo")
-!("bar" != nil)
-!("bar" < "foo")
-!("bar" <= "foo")
-!("bar" == "bar")
-!("bar" == "foo")
-!("bar" == nil)
-!("bar" > "bar")
-!("bar" > "foo")
-!("bar" >= "bar")
-!("bar" >= "foo")
-!("bar" contains "bar")
-!("bar" contains "foo")
-!("bar" endsWith "bar")
-!("bar" endsWith "foo")
-!("bar" in foo)
-!("bar" matches "foo")
-!("bar" not contains "bar")
-!("bar" not endsWith "bar")
-!("bar" not endsWith "foo")
-!("bar" not in foo)
-!("bar" not matches "bar")
-!("bar" not startsWith "bar")
-!("bar" not startsWith "foo")
-!("bar" startsWith "bar")
-!("foo" != "bar")
-!("foo" != nil)
-!("foo" < "foo")
-!("foo" <= "bar")
-!("foo" <= "foo")
-!("foo" == "bar")
-!("foo" == nil)
-!("foo" > "bar")
-!("foo" > "foo")
-!("foo" >= "bar")
-!("foo" contains "bar")
-!("foo" contains "foo")
-!("foo" endsWith "foo")
-!("foo" in foo)
-!("foo" matches "bar")
-!("foo" matches "foo")
-!("foo" not contains "bar")
-!("foo" not contains "foo")
-!("foo" not endsWith "bar")
-!("foo" not matches "bar")
-!("foo" not matches "foo")
-!("foo" not startsWith "bar")
-!("foo" not startsWith "foo")
-!("foo" startsWith "bar")
-!("foo" startsWith "foo")
-!(-f32 < f32)
-!(-i < i32)
-!(-i32 >= i)
-!(0.5 != 0.5)
-!(0.5 != 1)
-!(0.5 != f32)
-!(0.5 != f64)
-!(0.5 != i)
-!(0.5 != i32)
-!(0.5 != i64)
-!(0.5 != nil)
-!(0.5 < 0.5)
-!(0.5 < 1)
-!(0.5 < f32)
-!(0.5 < f64)
-!(0.5 < i)
-!(0.5 < i32)
-!(0.5 < i64)
-!(0.5 <= 0.5)
-!(0.5 <= 1)
-!(0.5 <= f32)
-!(0.5 <= f64)
-!(0.5 <= i)
-!(0.5 <= i32)
-!(0.5 <= i64)
-!(0.5 == 0.5)
-!(0.5 == 1)
-!(0.5 == f32)
-!(0.5 == f64)
-!(0.5 == i)
-!(0.5 == i32)
-!(0.5 == i64)
-!(0.5 == nil)
-!(0.5 > 0.5)
-!(0.5 > 1)
-!(0.5 > f32)
-!(0.5 > f64)
-!(0.5 > i)
-!(0.5 > i32)
-!(0.5 > i64)
-!(0.5 >= 0.5)
-!(0.5 >= 1)
-!(0.5 >= f32)
-!(0.5 >= f64)
-!(0.5 >= i)
-!(0.5 >= i32)
-!(0.5 >= i64)
-!(0.5 in array)
-!(0.5 not in array)
-!(1 != 0.5)
-!(1 != 1)
-!(1 != f32)
-!(1 != f64)
-!(1 != i)
-!(1 != i32)
-!(1 != i64)
-!(1 != nil)
-!(1 / i64 == i64)
-!(1 < 0.5)
-!(1 < 1)
-!(1 < f32)
-!(1 < f64)
-!(1 < i)
-!(1 < i32)
-!(1 < i64)
-!(1 <= 0.5)
-!(1 <= 1)
-!(1 <= f32)
-!(1 <= f64)
-!(1 <= i)
-!(1 <= i32)
-!(1 <= i64)
-!(1 == 0.5)
-!(1 == 1)
-!(1 == f32)
-!(1 == f64)
-!(1 == i)
-!(1 == i32)
-!(1 == i64)
-!(1 == nil)
-!(1 > 0.5)
-!(1 > 1)
-!(1 > f32)
-!(1 > f64)
-!(1 > i)
-!(1 > i32)
-!(1 > i64)
-!(1 >= 0.5)
-!(1 >= 1)
-!(1 >= f32)
-!(1 >= f64)
-!(1 >= i)
-!(1 >= i32)
-!(1 >= i64)
-!(1 in array)
-!(1 not in array)
-!(add != add)
-!(add != div)
-!(add != nil)
-!(add == add)
-!(add == div)
-!(add == nil)
-!(array != array)
-!(array != list)
-!(array != nil)
-!(array == array)
-!(array == list)
-!(array == nil)
-!(div != add)
-!(div != div)
-!(div != nil)
-!(div == add)
-!(div == div)
-!(f32 != 0.5)
-!(f32 != 1)
-!(f32 != f32)
-!(f32 != f64)
-!(f32 != i)
-!(f32 != i32)
-!(f32 != i64)
-!(f32 != nil)
-!(f32 < 0.5)
-!(f32 < 1)
-!(f32 < f32)
-!(f32 < f64)
-!(f32 < i)
-!(f32 < i32)
-!(f32 < i64)
-!(f32 <= 0.5)
-!(f32 <= 1)
-!(f32 <= f32)
-!(f32 <= f64)
-!(f32 <= i32)
-!(f32 <= i64)
-!(f32 == 0.5)
-!(f32 == 1)
-!(f32 == f32)
-!(f32 == f64)
-!(f32 == i)
-!(f32 == i32)
-!(f32 == i64)
-!(f32 == nil)
-!(f32 > 0.5)
-!(f32 > 1)
-!(f32 > f32)
-!(f32 > f64)
-!(f32 > i)
-!(f32 > i32)
-!(f32 > i64)
-!(f32 >= 0.5)
-!(f32 >= 1)
-!(f32 >= f32)
-!(f32 >= i)
-!(f32 >= i32)
-!(f32 >= i64)
-!(f32 in array)
-!(f32 not in array)
-!(f64 != 0.5)
-!(f64 != 1)
-!(f64 != f32)
-!(f64 != f64)
-!(f64 != i)
-!(f64 != i32)
-!(f64 != i64)
-!(f64 != nil)
-!(f64 < 0.5 + 1)
-!(f64 < 0.5)
-!(f64 < 1)
-!(f64 < f64)
-!(f64 < i)
-!(f64 < i32)
-!(f64 < i64)
-!(f64 < max(1))
-!(f64 <= 0.5)
-!(f64 <= 1)
-!(f64 <= i32)
-!(f64 <= i64)
-!(f64 == 0.5)
-!(f64 == 1)
-!(f64 == f32)
-!(f64 == f64)
-!(f64 == i)
-!(f64 == i32)
-!(f64 == i64)
-!(f64 == nil)
-!(f64 > 0.5)
-!(f64 > 1)
-!(f64 > f32)
-!(f64 > f64)
-!(f64 > i)
-!(f64 > i32)
-!(f64 > i64)
-!(f64 >= 0.5)
-!(f64 >= 1)
-!(f64 >= f32)
-!(f64 >= f64)
-!(f64 >= i)
-!(f64 >= i32)
-!(f64 >= i64)
-!(f64 in array)
-!(f64 not in array)
-!(false != false)
-!(false != nil)
-!(false != ok)
-!(false != true)
-!(false && false)
-!(false && ok)
-!(false && true)
-!(false == false)
-!(false == nil)
-!(false == ok)
-!(false == true)
-!(false and false)
-!(false and ok)
-!(false and true)
-!(false or false)
-!(false or ok)
-!(false || false)
-!(false || ok)
-!(false || true)
-!(foo != foo)
-!(foo != nil)
-!(foo == foo)
-!(foo == nil)
-!(foo == reduce(list, #))
-!(foo in list)
-!(foo not in list)
-!(greet != greet)
-!(greet != nil)
-!(greet == greet)
-!(greet == nil)
-!(half != half)
-!(half != nil)
-!(half == half)
-!(half == nil)
-!(i != 0.5)
-!(i != 1)
-!(i != f32)
-!(i != f64)
-!(i != i)
-!(i != i32)
-!(i != i64)
-!(i != nil)
-!(i < 0.5)
-!(i < 1)
-!(i < f64)
-!(i < i)
-!(i < i32)
-!(i < i64)
-!(i <= 0.5)
-!(i <= 1)
-!(i <= f32)
-!(i <= f64)
-!(i <= i32)
-!(i == 0.5)
-!(i == 1)
-!(i == f32)
-!(i == f64)
-!(i == i)
-!(i == i32)
-!(i == i64)
-!(i == nil)
-!(i > 0.5)
-!(i > 1)
-!(i > f32)
-!(i > f64)
-!(i > i)
-!(i > i32)
-!(i > i64)
-!(i >= 0.5)
-!(i >= 1 * i64)
-!(i >= 1)
-!(i >= f32)
-!(i >= f64)
-!(i >= i)
-!(i >= i32)
-!(i >= i64)
-!(i in array)
-!(i not in array)
-!(i32 != 0.5)
-!(i32 != 1)
-!(i32 != f32)
-!(i32 != f64)
-!(i32 != i)
-!(i32 != i32)
-!(i32 != i64)
-!(i32 != nil)
-!(i32 < 0.5)
-!(i32 < 1)
-!(i32 < f32)
-!(i32 < f64)
-!(i32 < i)
-!(i32 < i32)
-!(i32 < i64)
-!(i32 <= 0.5)
-!(i32 <= 1)
-!(i32 <= f32)
-!(i32 <= f64)
-!(i32 <= i)
-!(i32 <= i32)
-!(i32 <= i64)
-!(i32 == 0.5)
-!(i32 == 1)
-!(i32 == f32)
-!(i32 == f64)
-!(i32 == i)
-!(i32 == i32)
-!(i32 == i64)
-!(i32 == nil)
-!(i32 > 0.5)
-!(i32 > 1)
-!(i32 > f32)
-!(i32 > f64)
-!(i32 > i)
-!(i32 > i32)
-!(i32 >= 0.5)
-!(i32 >= 1)
-!(i32 >= f32)
-!(i32 >= f64)
-!(i32 >= i)
-!(i32 >= i32)
-!(i32 >= i64)
-!(i32 in array)
-!(i32 not in array)
-!(i64 != 0.5)
-!(i64 != 1)
-!(i64 != f32)
-!(i64 != f64)
-!(i64 != i)
-!(i64 != i32)
-!(i64 != i64)
-!(i64 != nil)
-!(i64 < 0.5)
-!(i64 < 1)
-!(i64 < f32)
-!(i64 < f64)
-!(i64 < i)
-!(i64 < i32 + i64)
-!(i64 < i32)
-!(i64 < i64)
-!(i64 <= 0.5)
-!(i64 <= 1)
-!(i64 <= f32)
-!(i64 <= f64)
-!(i64 <= i)
-!(i64 <= i32)
-!(i64 <= i64)
-!(i64 == 0.5)
-!(i64 == 1)
-!(i64 == f32)
-!(i64 == f64)
-!(i64 == i32)
-!(i64 == i64)
-!(i64 == nil)
-!(i64 > 0.5)
-!(i64 > 1)
-!(i64 > f32)
-!(i64 > f64)
-!(i64 > i)
-!(i64 > i32)
-!(i64 > i64)
-!(i64 >= 0.5)
-!(i64 >= 1)
-!(i64 >= f32)
-!(i64 >= f64)
-!(i64 >= i)
-!(i64 >= i32)
-!(i64 >= i64)
-!(i64 in array)
-!(len("bar") <= i)
-!(list != array)
-!(list != list)
-!(list != nil)
-!(list == array)
-!(list == list)
-!(list == nil)
-!(nil != "bar")
-!(nil != "foo")
-!(nil != 0.5)
-!(nil != 1)
-!(nil != add)
-!(nil != array)
-!(nil != div)
-!(nil != f32)
-!(nil != f64)
-!(nil != false)
-!(nil != foo)
-!(nil != greet)
-!(nil != half)
-!(nil != i)
-!(nil != i32)
-!(nil != i64)
-!(nil != list)
-!(nil != nil)
-!(nil != ok)
-!(nil != score)
-!(nil != true)
-!(nil == "bar")
-!(nil == "foo")
-!(nil == 0.5)
-!(nil == 1)
-!(nil == add)
-!(nil == array)
-!(nil == div)
-!(nil == f32)
-!(nil == f64)
-!(nil == false)
-!(nil == foo)
-!(nil == greet)
-!(nil == half)
-!(nil == i)
-!(nil == i32)
-!(nil == i64)
-!(nil == list)
-!(nil == nil)
-!(nil == ok)
-!(nil == score)
-!(nil == true)
-!(nil in array)
-!(nil in list)
-!(nil not in array)
-!(nil not in list)
-!(ok != false)
-!(ok != nil)
-!(ok != ok)
-!(ok != true)
-!(ok && false)
-!(ok && ok)
-!(ok && true)
-!(ok == nil)
-!(ok == ok)
-!(ok == true)
-!(ok and ok)
-!(ok and true)
-!(ok or false)
-!(ok or ok)
-!(ok or true)
-!(ok || false)
-!(ok || ok)
-!(ok || true)
-!(score != nil)
-!(score != score)
-!(score == nil)
-!(score == score)
-!(true != false)
-!(true != nil)
-!(true != ok)
-!(true != true)
-!(true && false)
-!(true && ok)
-!(true && true)
-!(true == false)
-!(true == nil)
-!(true == ok)
-!(true == true)
-!(true and ok)
-!(true and true)
-!(true or ok)
-!(true or true)
-!(true || false)
-!(true || ok)
-!(true || true)
-!all(array, false)
-!all(array, ok)
-!all(array, true)
-!all(list, false)
-!all(list, ok)
-!all(list, true)
-!any(array, i == #)
-!any(array, ok)
-!any(array, true)
-!any(list, false)
-!any(list, ok)
-!any(list, true)
-!false != not true
-!false != ok
-!false && 0.5 == 1
-!false == ok
-!false ? "foo" : 0.5
-!false ? "foo" : f32
-!false ? 0.5 : "foo"
-!false ? 0.5 : f32
-!false ? 1 : half
-!false ? 1 : i
-!false ? add : f32
-!false ? add : i64
-!false ? array : add
-!false ? array : ok
-!false ? div : array
-!false ? div : greet
-!false ? div : half
-!false ? f32 : add
-!false ? f32 : false
-!false ? f64 : "foo"
-!false ? foo : "bar"
-!false ? half : 1
-!false ? half : add
-!false ? half : list
-!false ? half : true
-!false ? i : nil
-!false ? i32 : list
-!false ? i64 : foo
-!false ? i64 : i64
-!false ? nil : add
-!false ? nil : f64
-!false ? nil : foo
-!false ? nil : half
-!false ? ok : 1
-!false ? score : "bar"
-!false ? score : foo
-!false ? score : ok
-!false ? true : "foo"
-!false or 0.5 > i32
-!false or ok
-!false || ok
-!hasPrefix("foo", "foo")
-!none(array, # > #)
-!none(array, # >= #)
-!none(array, false)
-!none(array, ok)
-!none(list, ok)
-!none(list, true)
-!not ("bar" == nil)
-!not (1 <= 1)
-!not (1 > 0.5)
-!not (greet == nil)
-!not (i32 == f64)
-!not false
-!not none(list, true)
-!not ok
-!not true
-!ok
-!ok != !true
-!ok != ok
-!ok && ok
-!ok == ok
-!ok ? "bar" : "foo"
-!ok ? "bar" : foo
-!ok ? "foo" : 0.5
-!ok ? "foo" : list
-!ok ? 0.5 : 1
-!ok ? 0.5 : i
-!ok ? 1 : array
-!ok ? 1 : div
-!ok ? 1 : f64
-!ok ? 1 : list
-!ok ? 1 : ok
-!ok ? add : 0.5
-!ok ? array : div
-!ok ? array : f32
-!ok ? array : foo
-!ok ? array : i
-!ok ? array : i32
-!ok ? div : "foo"
-!ok ? div : 1
-!ok ? div : i
-!ok ? f32 : "bar"
-!ok ? f32 : add
-!ok ? f32 : false
-!ok ? f32 : greet
-!ok ? f64 : "bar"
-!ok ? f64 : "foo"
-!ok ? f64 : 0.5
-!ok ? f64 : half
-!ok ? f64 : score
-!ok ? false : ok
-!ok ? foo : "foo"
-!ok ? foo : f32
-!ok ? foo : false
-!ok ? foo : i32
-!ok ? greet : div
-!ok ? greet : list
-!ok ? greet : nil
-!ok ? half : f64
-!ok ? i : "bar"
-!ok ? i : array
-!ok ? i : div
-!ok ? i : foo
-!ok ? i32 : 0.5
-!ok ? i32 : f32
-!ok ? i32 : greet
-!ok ? i32 : nil
-!ok ? i64 : 0.5
-!ok ? i64 : 1
-!ok ? i64 : f32
-!ok ? i64 : true
-!ok ? list : f32
-!ok ? list : i
-!ok ? nil : 1
-!ok ? nil : array
-!ok ? ok : f32
-!ok ? ok : list
-!ok and ok
-!ok or f32 < i64
-!ok or false or false
-!ok or ok
-!ok || ok
-!one(array, false)
-!one(array, ok)
-!one(array, true)
-!one(list, false)
-!one(list, ok)
-!one(list, true)
-!reduce(array, false)
-!reduce(array, ok)
-!reduce(array, true)
-!reduce(list, # != #)
-!reduce(list, false)
-!reduce(list, ok)
-!reduce(list, true)
-!true != all(array, ok)
-!true ? "bar" : "foo"
-!true ? "bar" : true
-!true ? "foo" : "foo"
-!true ? "foo" : 0.5
-!true ? "foo" : i
-!true ? 1 : "foo"
-!true ? 1 : i64
-!true ? add : 0.5
-!true ? add : score
-!true ? array : f64
-!true ? array : list
-!true ? div : add
-!true ? f32 : false
-!true ? f64 : f64
-!true ? foo : 1
-!true ? foo : array
-!true ? greet : ok
-!true ? greet : score
-!true ? greet : true
-!true ? half : f64
-!true ? i : 1
-!true ? i : add
-!true ? i : ok
-!true ? i32 : 1
-!true ? i64 : false
-!true ? i64 : i64
-!true ? i64 : list
-!true ? list : 0.5
-!true ? list : nil
-!true ? list : score
-!true ? nil : 0.5
-!true ? nil : false
-!true ? nil : ok
-!true ? ok : add
-!true ? ok : div
-!true ? score : false
-!true ? true : f32
-!true ? true : half
-!true and foo != nil
-!true || ok
-"bar" != "bar" || ok
-"bar" != foo.Bar
-"bar" != foo?.Bar
-"bar" + "bar" not in foo
-"bar" + foo.Bar
-"bar" + foo?.Bar
-"bar" < foo.Bar
-"bar" < foo?.Bar
-"bar" < foo?.String()
-"bar" <= foo.Bar
-"bar" <= foo.String()
-"bar" <= foo?.Bar
-"bar" == foo.Bar
-"bar" == foo?.Bar
-"bar" == foo?.String()
-"bar" > "bar" or ok ? f32 : i64
-"bar" > foo.Bar
-"bar" > foo?.String()
-"bar" >= foo.Bar
-"bar" >= foo.String()
-"bar" >= foo?.Bar
-"bar" contains foo.Bar
-"bar" contains foo.String()
-"bar" contains foo?.Bar
-"bar" endsWith foo.Bar
-"bar" endsWith foo?.Bar
-"bar" endsWith foo?.String()
-"bar" matches "bar" and ok
-"bar" matches foo.Bar
-"bar" matches foo.String()
-"bar" matches foo?.Bar
-"bar" matches foo?.String()
-"bar" not contains foo.Bar
-"bar" not contains foo?.Bar
-"bar" not endsWith foo.Bar
-"bar" not endsWith foo?.Bar
-"bar" not endsWith foo?.String()
-"bar" not matches foo.Bar
-"bar" not matches foo.String()
-"bar" not matches foo?.Bar
-"bar" not matches foo?.String()
-"bar" not startsWith foo.Bar
-"bar" not startsWith foo?.Bar
-"bar" not startsWith foo?.String()
-"bar" startsWith "foo" or list == array
-"bar" startsWith foo.Bar
-"bar" startsWith foo.String()
-"foo" != "foo" ? f64 : array
-"foo" != "foo" or ok
-"foo" != foo.Bar
-"foo" != foo.String()
-"foo" != foo?.Bar
-"foo" != foo?.String()
-"foo" + "bar" not in foo
-"foo" + foo.Bar
-"foo" + foo?.Bar
-"foo" + foo?.String()
-"foo" < "bar" and ok
-"foo" < foo.Bar
-"foo" < foo?.Bar
-"foo" < foo?.String()
-"foo" <= foo.Bar
-"foo" <= foo?.Bar
-"foo" == "bar" != ok
-"foo" == "bar" and ok
-"foo" == foo.Bar
-"foo" == foo?.Bar
-"foo" == foo?.String()
-"foo" > foo.Bar
-"foo" > foo.String()
-"foo" > foo?.Bar
-"foo" >= foo.Bar
-"foo" >= foo.String()
-"foo" >= foo?.Bar
-"foo" >= foo?.String()
-"foo" contains "bar" == ok
-"foo" contains foo?.Bar
-"foo" endsWith foo.Bar
-"foo" endsWith foo?.Bar
-"foo" matches "bar" ? add : div
-"foo" matches "foo" || true ? greet : "bar"
-"foo" matches foo.Bar
-"foo" matches foo.String()
-"foo" matches foo?.Bar
-"foo" not contains foo.Bar
-"foo" not contains foo?.Bar
-"foo" not contains foo?.String()
-"foo" not endsWith foo.Bar
-"foo" not endsWith foo?.Bar
-"foo" not matches foo.Bar
-"foo" not matches foo?.Bar
-"foo" not matches foo?.String()
-"foo" not startsWith foo.Bar
-"foo" not startsWith foo?.Bar
-"foo" not startsWith foo?.String()
-"foo" startsWith foo.Bar
-"foo" startsWith foo?.Bar
-("bar" not endsWith "bar") != ok
-("bar" not endsWith "foo") != ok
-("bar" not endsWith "foo") && false != nil
-("bar" not matches "foo") || reduce(list, ok)
-("foo" not matches "bar") == ok
-(0.5 * 0.5) ** i
-(0.5 * 0.5) ^ f32
-(0.5 * 1) ** f64
-(0.5 * 1) ** i
-(0.5 * 1) ^ i32
-(0.5 * f64) ^ f32
-(0.5 * i) ^ i
-(0.5 + 0.5) * f32
-(0.5 + 0.5) ^ i32
-(0.5 + 1) ^ i
-(0.5 + f64) * f64
-(0.5 + f64) / i32
-(0.5 + i) ** i
-(0.5 + i) ^ i
-(0.5 + i64) ** f32
-(0.5 + i64) / f32
-(0.5 + i64) / i
-(0.5 - 0.5) * (i32 - 0.5)
-(0.5 - 0.5) * i64
-(0.5 - 0.5) ** f32
-(0.5 - 1) * i32
-(0.5 - 1) ** f64
-(0.5 - 1) ^ i64
-(0.5 - f32) ** i
-(0.5 - f64) * i
-(0.5 - f64) / f32
-(0.5 - f64) / f64
-(0.5 - i) ^ f32
-(0.5 - i32) ** (i32 * 1)
-(0.5 - i32) / f64
-(0.5 - i32) ^ f32
-(0.5 - i64) * i
-(0.5 - i64) / f64
-(0.5 - i64) / i64
-(0.5 / 0.5) ** f32
-(0.5 / 0.5) ** i32
-(0.5 / 0.5) ^ f64
-(0.5 / 1) ^ f32
-(0.5 / i) ** f64
-(0.5 / i) ** i
-(0.5 / i32) ** i
-(0.5 / i32) ^ f32
-(1 * 0.5) ** (f64 * 1)
-(1 * 0.5) ** i32
-(1 * 0.5) ^ f64
-(1 * 1) ^ -1
-(1 * 1) ^ f32
-(1 * f32) ^ i32
-(1 * i) ** i32
-(1 * i32) ^ i
-(1 * i64) ** i64
-(1 + 0.5) ** i
-(1 + 1) * i64
-(1 + 1) / i
-(1 + f32) ^ i
-(1 + f64) ^ i
-(1 + f64) ^ i32
-(1 + i) ** f32
-(1 + i) / f64
-(1 + i) ^ i64
-(1 + i32) * f64
-(1 + i32) ^ f64
-(1 - 0.5) * f32 ^ 1
-(1 - 0.5) * i64
-(1 - 0.5) / i
-(1 - 0.5) ^ min(f32)
-(1 - f32) * f32
-(1 - f64) ** f64
-(1 - i) * -i32
-(1 - i32) ^ f32
-(1 - i32) ^ i
-(1 - i64) ** f32
-(1 - i64) / f64
-(1 - i64) / i64
-(1 / 0.5) ** f32
-(1 / 0.5) ^ i32
-(1 / 1) ** (f64 * 0.5)
-(1 / 1) ^ ceil(i64)
-(1 / 1) ^ max(0.5)
-(1 / f32) ^ f32
-(1 / i) ^ f32
-(1 / i32) ^ i
-(1 / i64) ** i64
-(f32 * 0.5) ** f64
-(f32 * 0.5) ^ i32
-(f32 * f32) ^ -f32
-(f32 * f32) ^ i
-(f32 * i) ^ -1
-(f32 * i64) ** i
-(f32 + f64) * i
-(f32 + i) ^ f64
-(f32 - 0.5) / f64
-(f32 - 0.5) ^ f32
-(f32 - 1) / f64
-(f32 - 1) ^ f64
-(f32 - f32) / i64
-(f32 - i32) * i64
-(f32 / 0.5) ^ f32
-(f32 / i64) ^ f64
-(f64 * 0.5) ** f32
-(f64 * 0.5) ** i64
-(f64 * f32) ** f64
-(f64 * i64) ** f64
-(f64 * i64) ** i32
-(f64 + 0.5) * f32
-(f64 + 0.5) * i64
-(f64 + f32) ** get(array, i)
-(f64 + f32) ** i32
-(f64 + f64) * (i64 - i64)
-(f64 + f64) ^ f64
-(f64 + i) * (0.5 + i64)
-(f64 + i32) ^ i64
-(f64 + i64) ^ i
-(f64 - 0.5) ** f64
-(f64 - 1) ** i64
-(f64 - 1) ^ i32
-(f64 - f32) ** i
-(f64 - f32) ^ i64
-(f64 - i) * i32
-(f64 - i32) / i
-(f64 - i64) ** i
-(f64 - i64) / f32
-(f64 - i64) / f64
-(f64 / 1) ** i64
-(f64 / f32) ^ i
-(f64 / f64) ** i32
-(f64 / f64) ^ i32 ** 0.5
-(false || ok) == ok
-(i % i) ^ i
-(i % i32) ^ (1 - i32)
-(i % i64) ^ f64
-(i * 0.5) ** f32
-(i * 1) ^ f64
-(i * 1) ^ i
-(i * i64) ** f32
-(i + 0.5) ** half(f64)
-(i + 1) % i64
-(i + 1) / i64
-(i + i) ^ i64
-(i + i32) * i64 ^ f64
-(i + i32) / i32
-(i + i32) ^ f32
-(i + i64) ^ i32
-(i - 0.5) / i64
-(i - 1) ^ i64
-(i / 0.5) ** f32
-(i / f32) ^ f64
-(i32 % 1) ** f32
-(i32 % i) ** f32
-(i32 % i32) ** i32
-(i32 % i32) ^ i32
-(i32 * 0.5) ^ f32
-(i32 * 1) ^ i32
-(i32 + 0.5) ** i64
-(i32 + f32) * i64
-(i32 + f64) / i
-(i32 + i) / i
-(i32 + i32) ^ i32
-(i32 - 0.5) * f64
-(i32 - 0.5) / i64
-(i32 - 1) ^ f64
-(i32 - f32) / i64
-(i32 - i) % i64
-(i32 - i) / f32
-(i32 - i32) ^ (i32 * i)
-(i32 - i64) * i32
-(i32 - i64) * i32 * i64
-(i32 / i) ** f32
-(i32 / i) ^ i64
-(i32 < f64 ? nil : i) .. i32
-(i32 not in array) and ok
-(i64 % i) ** f32
-(i64 * 0.5) ^ f64
-(i64 * f32) ^ i64
-(i64 * f64) ^ i32
-(i64 * i) ** score(1)
-(i64 * i64) ** i ** 0.5
-(i64 * i64) ^ i
-(i64 + 0.5) * f32
-(i64 + 0.5) ** i64
-(i64 + 1) % i
-(i64 + 1) ^ i
-(i64 + f32) * -i32
-(i64 + f32) ** i32
-(i64 + f32) / f64
-(i64 + f32) / i
-(i64 + f32) / i32
-(i64 + f64) * i32
-(i64 + i) % i64
-(i64 + i) / f64
-(i64 + i32) * i64
-(i64 + i64) / i64
-(i64 - 0.5) / f64
-(i64 - 0.5) ^ i64
-(i64 - 1) ^ i32
-(i64 - f32) ** f64
-(i64 - f32) ^ i64
-(i64 - i) ** i
-(i64 - i32) * i64
-(i64 / 1) ** f32
-(i64 / f64) ** i32
-(nil not in array) || ok
-(ok || true) && (ok or true)
--((i64 + 1) % i32)
--(0.5 * 0.5)
--(0.5 * 1)
--(0.5 * f32)
--(0.5 * f64)
--(0.5 * i)
--(0.5 * i32)
--(0.5 * i64)
--(0.5 ** 0.5)
--(0.5 ** 1)
--(0.5 ** f32)
--(0.5 ** f64)
--(0.5 ** i)
--(0.5 ** i32)
--(0.5 ** i64)
--(0.5 + 0.5)
--(0.5 + 1)
--(0.5 + f32)
--(0.5 + f64)
--(0.5 + i)
--(0.5 + i32)
--(0.5 + i64)
--(0.5 - 0.5)
--(0.5 - 1)
--(0.5 - f32)
--(0.5 - f64)
--(0.5 - i)
--(0.5 - i32)
--(0.5 - i64)
--(0.5 / 0.5)
--(0.5 / 1)
--(0.5 / f32)
--(0.5 / f64)
--(0.5 / i)
--(0.5 / i32)
--(0.5 / i64)
--(0.5 ^ 0.5)
--(0.5 ^ 1)
--(0.5 ^ f32)
--(0.5 ^ f64)
--(0.5 ^ i)
--(0.5 ^ i32)
--(0.5 ^ i64)
--(1 % 1)
--(1 % i)
--(1 % i32)
--(1 % i64)
--(1 * 0.5)
--(1 * 1)
--(1 * f32)
--(1 * f64)
--(1 * i)
--(1 * i32)
--(1 * i64)
--(1 ** 0.5)
--(1 ** 1)
--(1 ** f32)
--(1 ** f64)
--(1 ** i)
--(1 ** i32)
--(1 ** i64)
--(1 + 0.5)
--(1 + 1)
--(1 + f32)
--(1 + f64)
--(1 + i)
--(1 + i32)
--(1 + i64)
--(1 - 0.5)
--(1 - 1)
--(1 - f32)
--(1 - f64)
--(1 - i)
--(1 - i32)
--(1 - i64)
--(1 / 0.5)
--(1 / 1)
--(1 / f32)
--(1 / f64)
--(1 / i)
--(1 / i32)
--(1 / i64)
--(1 ^ 0.5)
--(1 ^ 1)
--(1 ^ f32)
--(1 ^ f64)
--(1 ^ i)
--(1 ^ i32)
--(1 ^ i64)
--(f32 * 0.5)
--(f32 * 1)
--(f32 * f32)
--(f32 * f64)
--(f32 * i)
--(f32 * i32)
--(f32 * i64)
--(f32 ** 0.5)
--(f32 ** 1)
--(f32 ** f32)
--(f32 ** f64)
--(f32 ** i)
--(f32 ** i32)
--(f32 ** i64)
--(f32 + 0.5)
--(f32 + 1)
--(f32 + f32)
--(f32 + f64)
--(f32 + i)
--(f32 + i64)
--(f32 - 0.5)
--(f32 - 1)
--(f32 - f32)
--(f32 - i)
--(f32 - i32)
--(f32 - i64)
--(f32 / 0.5)
--(f32 / 1)
--(f32 / f32)
--(f32 / f64)
--(f32 / i)
--(f32 / i32)
--(f32 / i64)
--(f32 ^ 0.5)
--(f32 ^ 1)
--(f32 ^ f32)
--(f32 ^ f64)
--(f32 ^ i)
--(f32 ^ i32)
--(f32 ^ i64)
--(f64 * 0.5)
--(f64 * 1)
--(f64 * f32)
--(f64 * f64)
--(f64 * i)
--(f64 * i32)
--(f64 * i64)
--(f64 ** 0.5)
--(f64 ** 1)
--(f64 ** f32)
--(f64 ** f64)
--(f64 ** i)
--(f64 ** i32)
--(f64 ** i64)
--(f64 + 0.5)
--(f64 + 1)
--(f64 + f32)
--(f64 + i)
--(f64 + i32)
--(f64 + i64)
--(f64 - 0.5)
--(f64 - 1)
--(f64 - f32)
--(f64 - f64)
--(f64 - i)
--(f64 - i64)
--(f64 / 0.5)
--(f64 / 1)
--(f64 / f32)
--(f64 / f64)
--(f64 / i)
--(f64 / i64)
--(f64 ^ 0.5)
--(f64 ^ 1)
--(f64 ^ f32)
--(f64 ^ f64)
--(f64 ^ i)
--(f64 ^ i32)
--(f64 ^ i64)
--(i % 1)
--(i % i)
--(i % i32)
--(i % i64)
--(i * 0.5)
--(i * 1)
--(i * f32)
--(i * f64)
--(i * i)
--(i * i32)
--(i * i64)
--(i ** 0.5)
--(i ** 1)
--(i ** f64)
--(i ** i)
--(i ** i32)
--(i ** i64)
--(i + 0.5)
--(i + 1)
--(i + i32)
--(i + i64)
--(i - 0.5)
--(i - 1)
--(i - f32)
--(i - f64)
--(i - i ** 1)
--(i - i)
--(i - i32)
--(i - i64)
--(i / 0.5)
--(i / 1)
--(i / f32)
--(i / f64)
--(i / i)
--(i / i32)
--(i / i64)
--(i ^ 0.5)
--(i ^ 1)
--(i ^ f32)
--(i ^ f64)
--(i ^ i)
--(i ^ i32)
--(i ^ i64)
--(i32 % 1)
--(i32 % i)
--(i32 % i32)
--(i32 % i64)
--(i32 * 0.5)
--(i32 * 1)
--(i32 * f32)
--(i32 * f64)
--(i32 * i)
--(i32 * i32)
--(i32 * i64)
--(i32 ** 0.5)
--(i32 ** 1)
--(i32 ** f32)
--(i32 ** f64)
--(i32 ** i)
--(i32 ** i32)
--(i32 ** i64)
--(i32 + 0.5)
--(i32 + 1)
--(i32 + f32)
--(i32 + f64)
--(i32 + i)
--(i32 + i32)
--(i32 + i64)
--(i32 - 0.5)
--(i32 - 1)
--(i32 - f32)
--(i32 - f64)
--(i32 - i)
--(i32 - i32)
--(i32 - i64)
--(i32 / 0.5)
--(i32 / 1)
--(i32 / f64)
--(i32 / i)
--(i32 / i32)
--(i32 / i64)
--(i32 ^ 0.5)
--(i32 ^ 1)
--(i32 ^ f32)
--(i32 ^ f64)
--(i32 ^ i)
--(i32 ^ i32)
--(i32 ^ i64)
--(i64 % 1)
--(i64 % i)
--(i64 % i32)
--(i64 % i64)
--(i64 * 0.5)
--(i64 * 1)
--(i64 * f32)
--(i64 * f64)
--(i64 * i)
--(i64 * i32)
--(i64 * i64)
--(i64 ** 0.5)
--(i64 ** 1)
--(i64 ** f32)
--(i64 ** f64)
--(i64 ** i)
--(i64 ** i32)
--(i64 ** i64)
--(i64 + 0.5)
--(i64 + 1)
--(i64 + f32)
--(i64 + f64)
--(i64 + i32)
--(i64 + i64)
--(i64 - 0.5)
--(i64 - 1)
--(i64 - f32)
--(i64 - f64)
--(i64 - i)
--(i64 - i32)
--(i64 - i64)
--(i64 / 0.5)
--(i64 / 1)
--(i64 / f32)
--(i64 / f64)
--(i64 / i)
--(i64 / i32)
--(i64 / i64)
--(i64 ^ 0.5)
--(i64 ^ 1)
--(i64 ^ f32)
--(i64 ^ f64)
--(i64 ^ i)
--(i64 ^ i32)
--(i64 ^ i64)
--(max(f32) ^ i32)
--(min(0.5) ^ i32)
---(f64 ** 0.5)
---(i64 ** i64)
---0.5
---1
---ceil(1)
---f32
---f64
---f64 ** i64
---float(f64)
---i
---i32
---i64
--0.5 != f32
--0.5 != i32
--0.5 * 1 ** 1
--0.5 * f32
--0.5 * f64
--0.5 * i32
--0.5 * i64
--0.5 ** -1
--0.5 ** ceil(i)
--0.5 ** f32
--0.5 ** f64
--0.5 ** i
--0.5 ** i32
--0.5 ** i64
--0.5 + f64
--0.5 + i
--0.5 + i32
--0.5 + i64
--0.5 - abs(i)
--0.5 - f32
--0.5 - f64
--0.5 - i
--0.5 - i32
--0.5 - i64
--0.5 / f32
--0.5 / i
--0.5 / i32
--0.5 < i32
--0.5 < i64
--0.5 <= 0.5 + 0.5
--0.5 <= f32
--0.5 <= i
--0.5 <= i32
--0.5 <= i64
--0.5 == f32
--0.5 == f64
--0.5 == i
--0.5 == i32
--0.5 == i32 ^ i32
--0.5 == i64
--0.5 > f32
--0.5 > i
--0.5 >= f32
--0.5 >= f32 ? f32 : i32
--0.5 >= f64
--0.5 >= i
--0.5 >= i32
--0.5 >= i64
--0.5 ^ f32
--0.5 ^ f64
--0.5 ^ float(f64)
--0.5 ^ i32
--0.5 ^ i64
--0.5 in array
--0.5 not in sort(array)
--1 != -i
--1 != f32
--1 != f64
--1 != i32
--1 != i64
--1 % i
--1 % i32
--1 * array[i]
--1 * f32
--1 * f64
--1 * i
--1 * i32
--1 * i64
--1 ** (f32 + f32)
--1 ** (i + i64)
--1 ** ceil(0.5)
--1 ** f32
--1 ** f64
--1 ** i
--1 ** i64 ^ 1
--1 + -i32
--1 + f32
--1 + f64
--1 + i
--1 + i32
--1 + i64
--1 + reduce(array, #)
--1 + reduce(list, f32)
--1 - f64
--1 - i
--1 - i % i32
--1 - i32
--1 - i64
--1 .. i
--1 .. i64
--1 / f32
--1 / f64
--1 / i
--1 / i32
--1 < f64
--1 < i
--1 < i64
--1 <= -1
--1 <= f64
--1 <= i
--1 <= i32
--1 <= i64
--1 == f32
--1 == f64
--1 == floor(f64)
--1 == i
--1 == i32
--1 == i64
--1 > f32
--1 > i
--1 > i64
--1 >= f32 * f32
--1 >= f64
--1 >= i32
--1 >= i64
--1 ^ f32
--1 ^ f64
--1 ^ i32
--1 ^ i64
--1 in array
--1 not in array
--abs(0.5)
--abs(1)
--abs(f32)
--abs(f64)
--abs(i)
--abs(i32)
--abs(i64)
--add(i, 1)
--add(i, i)
--array[1]
--array[i32]
--array[i64]
--array[i]
--bitand(i64, i32)
--bitnand(1, i)
--bitnot(1)
--bitnot(i)
--bitnot(i32)
--bitnot(i64)
--bitor(1, i64)
--bitor(i, i32)
--bitshl(i, 1)
--bitshl(i, i32)
--bitshl(i, i64)
--bitshl(i64, i32)
--bitshr(i, i)
--bitshr(i64, i32)
--bitushr(i, i32)
--bitxor(1, 1)
--bitxor(i, i32)
--ceil(0.5)
--ceil(1)
--ceil(f32)
--ceil(f64)
--ceil(i)
--ceil(i32)
--ceil(i64)
--count(array, false)
--count(array, ok)
--count(array, true)
--count(list, ok)
--count(list, true)
--div(1, 1)
--f32
--f32 != i32
--f32 * i64
--f32 ** (i + 1)
--f32 ** f32
--f32 ** f64
--f32 ** i
--f32 ** i32
--f32 ** i64
--f32 + i32
--f32 - i
--f32 - round(i)
--f32 / f32
--f32 / f64
--f32 / i
--f32 < f32 ** 0.5
--f32 < f64
--f32 < i
--f32 < i32
--f32 <= f32
--f32 <= i
--f32 <= i32
--f32 <= i64
--f32 == f32
--f32 == f64
--f32 > 0.5 ? f32 : "bar"
--f32 > f32
--f32 > f64
--f32 >= f32
--f32 >= f64
--f32 >= i64
--f32 ^ i
--f32 ^ i32
--f32 ^ i64
--f32 in array
--f32 not in array
--f64
--f64 != f32
--f64 != f64
--f64 != i
--f64 != i32
--f64 * -1
--f64 * -f64
--f64 * f32
--f64 * f64
--f64 * i
--f64 * i32
--f64 * i64
--f64 ** 0.5 ** f32
--f64 ** f32
--f64 ** i
--f64 ** i32
--f64 + f32
--f64 + i64
--f64 - 0.5 / i64
--f64 - f32
--f64 - i
--f64 - i32
--f64 - i64
--f64 - int(f64)
--f64 / f32
--f64 / f64
--f64 / i
--f64 / i32
--f64 / i64
--f64 < 0.5 ^ f32
--f64 < f64
--f64 < f64 ** 1
--f64 < half(0.5)
--f64 < half(f64)
--f64 < i
--f64 < i ^ f32
--f64 < i32
--f64 < i64
--f64 <= f32
--f64 <= f64
--f64 == f64
--f64 == i
--f64 == i32
--f64 == i64
--f64 > f32
--f64 > f32 ? false : array
--f64 > f64
--f64 > i32
--f64 > i64
--f64 >= f32
--f64 >= f32 / f64
--f64 >= f64
--f64 >= i32
--f64 ^ f32
--f64 ^ f64
--f64 ^ i64
--f64 not in array
--find(array, ok)
--find(array, true)
--findIndex(array, # <= #)
--findIndex(array, ok)
--findIndex(array, true)
--findIndex(list, ok)
--findIndex(list, true)
--findLast(array, # <= #)
--findLast(array, ok)
--findLast(array, true)
--findLastIndex(array, ok)
--findLastIndex(array, true)
--findLastIndex(list, ok)
--findLastIndex(list, true)
--first(array)
--float(0.5 ** 0.5)
--float(0.5 ^ 0.5)
--float(0.5)
--float(1)
--float(bitnot(i64))
--float(f32)
--float(f64)
--float(i)
--float(i32)
--float(i64)
--floor(0.5)
--floor(1)
--floor(f32)
--floor(f64)
--floor(i)
--floor(i32)
--floor(i64)
--get(array, 1)
--get(array, i)
--get(array, i32)
--get(array, i64)
--half(-0.5)
--half(-1)
--half(0.5)
--half(1)
--half(f32 + i64)
--half(f64)
--half(median(array))
--i
--i != f32
--i != f64
--i != f64 ? foo : 1
--i != i
--i != i + f64
--i != i32
--i != i64
--i % i32
--i % i64
--i * abs(0.5)
--i * f64
--i * i
--i * i64
--i * reduce(array, 0.5)
--i ** f32
--i ** f64
--i ** i
--i + f32
--i + f64
--i + i32
--i + i64 * 1
--i - f32
--i - i64
--i .. i
--i .. i64
--i / f32
--i / i64
--i < f32
--i < half(1)
--i < i
--i < i64
--i <= 0.5 ? half : "bar"
--i <= 1 - 0.5
--i <= f32
--i <= i
--i <= i32
--i <= i64
--i <= i64 ** 0.5
--i == f32
--i == f64
--i == f64 ^ f32
--i == i
--i == i32
--i > f32
--i > i
--i > i32
--i >= f32
--i >= f64
--i >= i
--i >= i64
--i >= score(1)
--i ^ 0.5 ** 0.5
--i ^ f32
--i ^ f32 ^ 0.5
--i ^ f64
--i ^ i
--i ^ i64
--i in array
--i not in array
--i32
--i32 != f32
--i32 != i
--i32 != i32 ** 1
--i32 != i64
--i32 % i
--i32 % i32
--i32 % i64
--i32 * i
--i32 * i32
--i32 * i64
--i32 ** f32
--i32 ** f64
--i32 ** i64
--i32 + f32
--i32 + i
--i32 + i32
--i32 - f32
--i32 .. i32
--i32 / i32
--i32 / i64
--i32 < i
--i32 < i32
--i32 < i64
--i32 < round(f64)
--i32 <= f64
--i32 <= i
--i32 <= i32
--i32 <= i64
--i32 == 1 % i
--i32 == f32
--i32 == f64
--i32 == i64
--i32 == max(1)
--i32 > f32
--i32 > f64
--i32 > i
--i32 > i ** 0.5
--i32 > i32
--i32 > i64
--i32 >= f64
--i32 >= i
--i32 >= i == nil
--i32 >= i32
--i32 ^ f32
--i32 ^ i32
--i32 ^ i64
--i32 ^ score(1)
--i32 in array
--i64
--i64 != f32
--i64 != f64
--i64 != i32
--i64 != i64
--i64 != i64 ? score : foo
--i64 * (1 + f64)
--i64 * f32
--i64 * i
--i64 * i32
--i64 * i64
--i64 * indexOf("foo", "bar")
--i64 ** i
--i64 ** i32
--i64 + f32
--i64 + i
--i64 + i32
--i64 + i64
--i64 - f32
--i64 - i
--i64 - i32
--i64 .. i
--i64 .. i32
--i64 .. i64
--i64 / f64
--i64 / i32
--i64 < f32
--i64 < f64
--i64 < half(f64)
--i64 < i32
--i64 < i64
--i64 <= i
--i64 <= i32
--i64 == 1 ^ i64
--i64 == f32
--i64 == f64
--i64 == i
--i64 == i32
--i64 > f32
--i64 > f64
--i64 > i
--i64 > i32
--i64 >= f32
--i64 >= i
--i64 >= i32
--i64 ^ f64
--i64 ^ float(i)
--i64 ^ i
--i64 ^ i32
--i64 ^ i64
--i64 in array
--i64 not in array
--int(0.5)
--int(1)
--int(f32)
--int(f64)
--int(i)
--int(i32)
--int(i64)
--last(array)
--len("bar")
--len("foo")
--len(array)
--len(list)
--max(0.5)
--max(0.5, 0.5, f64)
--max(1)
--max(f32)
--max(f64)
--max(i)
--max(i, 0.5)
--max(i32 - 1)
--max(i32)
--max(i32, f32)
--max(i64 * 0.5)
--max(i64)
--max(i64, f64)
--max(i64, i)
--mean(array)
--median(array)
--min(-1)
--min(0.5)
--min(1)
--min(1, 0.5)
--min(f32)
--min(f32, 1)
--min(f64)
--min(float(0.5))
--min(i)
--min(i, 1)
--min(i32)
--min(i32, 0.5)
--min(i64)
--min(i64, i, 0.5)
--reduce(array, #)
--reduce(array, -#)
--reduce(array, 0.5)
--reduce(array, 1)
--reduce(array, 1) - f32
--reduce(array, f64)
--reduce(array, i)
--reduce(array, i32)
--reduce(array, i64)
--reduce(list, 0.5)
--reduce(list, 1)
--reduce(list, f32)
--reduce(list, f64)
--reduce(list, i)
--reduce(list, i32)
--round(0.5)
--round(1)
--round(f32)
--round(f64)
--round(i)
--round(i32)
--round(i64)
--score(1)
--score(1, 1)
--score(1, i)
--score(i)
--score(i32 + i)
--score(int(i))
--sum(array)
--sum(i .. 1)
-0.5 != 0.5 == ok
-0.5 != f64 ? list : f32
-0.5 != f64 and !true
-0.5 != f64 and ok
-0.5 != i == ok
-0.5 != i32 && ok
-0.5 != i32 == ok
-0.5 != i32 ? ok : ok
-0.5 != i32 and 1 > f64
-0.5 != nil == ok
-0.5 * 0.5 * f64
-0.5 * 0.5 / f32
-0.5 * 0.5 / f64
-0.5 * 0.5 < f64
-0.5 * 0.5 >= i64
-0.5 * 1 * i64
-0.5 * 1 <= f32
-0.5 * 1 > i32
-0.5 * 1 not in array
-0.5 * f32 * f32
-0.5 * f32 * i32
-0.5 * f32 + f32
-0.5 * f32 - f64
-0.5 * f32 / half(1)
-0.5 * f32 == i32
-0.5 * f32 > i
-0.5 * f64 != i64
-0.5 * f64 < i
-0.5 * f64 <= i
-0.5 * i + i
-0.5 * i + mean(array)
-0.5 * i - i32
-0.5 * i == 0.5 ? ok : ok
-0.5 * i32 / f32
-0.5 * i64 < f64
-0.5 * i64 == 1 ** i64
-0.5 ** 0.5 != i64
-0.5 ** 0.5 * max(1)
-0.5 ** 0.5 ** i64
-0.5 ** 0.5 + -f32
-0.5 ** 0.5 < f64
-0.5 ** 0.5 == i
-0.5 ** 0.5 ^ f32
-0.5 ** 0.5 not in array
-0.5 ** 1 != i
-0.5 ** 1 != i32
-0.5 ** 1 - f64
-0.5 ** 1 / f64
-0.5 ** 1 / i32
-0.5 ** 1 ^ i64
-0.5 ** f32 + f32 / i64
-0.5 ** f32 <= f32
-0.5 ** f32 ^ i
-0.5 ** f64 * f64
-0.5 ** f64 > f64 ? 1 : nil
-0.5 ** f64 >= i64
-0.5 ** i / i
-0.5 ** i > i
-0.5 ** i32 * i32
-0.5 ** i32 > f64
-0.5 ** i32 >= mean(array)
-0.5 + 0.5 != i
-0.5 + 0.5 == i32
-0.5 + 0.5 > f32
-0.5 + 1 != f64
-0.5 + 1 + i32
-0.5 + 1 - i32
-0.5 + 1 < float(1)
-0.5 + 1 == f32
-0.5 + f32 - i64
-0.5 + f32 <= ceil(f32)
-0.5 + f32 <= i32
-0.5 + f32 > f32
-0.5 + f64 != i64
-0.5 + f64 <= i32
-0.5 + f64 == 1 / 0.5
-0.5 + i + i
-0.5 + i > i64
-0.5 + i in array
-0.5 + i32 - i64
-0.5 + i32 <= f32
-0.5 + i64 - i
-0.5 + i64 > i64 * 0.5
-0.5 - 0.5 - i32
-0.5 - 0.5 >= f32
-0.5 - 0.5 >= i
-0.5 - 0.5 >= i32
-0.5 - 1 + i
-0.5 - 1 + i / i
-0.5 - 1 <= f64
-0.5 - f32 != i64
-0.5 - f32 >= i64
-0.5 - f64 - f32
-0.5 - f64 < i
-0.5 - f64 in array
-0.5 - i != i64
-0.5 - i + i
-0.5 - i > f32
-0.5 - i32 != f32
-0.5 - i64 + -f64
-0.5 - i64 == i
-0.5 - i64 not in array
-0.5 / 0.5 + i
-0.5 / 0.5 - i
-0.5 / 0.5 - i32
-0.5 / 0.5 - i64
-0.5 / 0.5 / half(0.5)
-0.5 / 0.5 < i32
-0.5 / 0.5 == i64
-0.5 / 0.5 >= f32
-0.5 / 0.5 >= f64
-0.5 / 1 * i
-0.5 / 1 / f64
-0.5 / 1 < f64
-0.5 / 1 == i
-0.5 / 1 > f32
-0.5 / 1 >= i32
-0.5 / 1 not in array
-0.5 / f32 * f64
-0.5 / f64 + f64
-0.5 / f64 - i
-0.5 / f64 / f64
-0.5 / f64 < i
-0.5 / f64 == f32
-0.5 / i != i64
-0.5 / i * i64
-0.5 / i / i32
-0.5 / i <= i
-0.5 / i32 + i64
-0.5 / i32 > i ^ i
-0.5 / i32 > i64
-0.5 / i32 >= f64
-0.5 / i64 != f64
-0.5 / i64 != i
-0.5 / i64 != min(f32)
-0.5 / i64 * i32
-0.5 < 0.5 ? f32 : array
-0.5 < 0.5 ? foo : greet
-0.5 < 1 == ok
-0.5 < 1 || ok
-0.5 < f32 && ok
-0.5 < f32 || ok
-0.5 <= f64 ? i : i64
-0.5 <= f64 || ok
-0.5 == 1 and ok
-0.5 == 1 || ok
-0.5 == array[ok ? 0.5 : score]
-0.5 == f32 and i64 == i32
-0.5 == f64 ? i : (false ? i : i64)
-0.5 == f64 and i64 == 0.5
-0.5 == i or ok
-0.5 == i32 and ok
-0.5 == i64 and ok
-0.5 == nil or "foo" endsWith "bar"
-0.5 == nil or ok
-0.5 == nil || ok
-0.5 > 0.5 == ok
-0.5 > array[i64]
-0.5 > f32 and ok
-0.5 > i && 0.5 < i64
-0.5 > i64 ? -i : array
-0.5 >= 0.5 ? array[i64] : f32
-0.5 >= 0.5 and ok
-0.5 >= i && 1 < 0.5
-0.5 >= i32 == ok
-0.5 >= i32 and ok
-0.5 ^ 0.5 == f64
-0.5 ^ 0.5 >= i32
-0.5 ^ 0.5 >= i64
-0.5 ^ 1 ** i64
-0.5 ^ 1 - f32
-0.5 ^ 1 < f32
-0.5 ^ 1 < i
-0.5 ^ 1 <= i32
-0.5 ^ 1 > f64 / 1
-0.5 ^ 1 >= i
-0.5 ^ f32 * i
-0.5 ^ f32 ** i64
-0.5 ^ f32 <= i32
-0.5 ^ f32 > i64
-0.5 ^ f32 >= i
-0.5 ^ f64 - i64
-0.5 ^ f64 / f32
-0.5 ^ f64 < f32
-0.5 ^ f64 > i32
-0.5 ^ i != f64
-0.5 ^ i * reduce(array, i)
-0.5 ^ i ** floor(0.5)
-0.5 ^ i / (0.5 + i32)
-0.5 ^ i < -f64
-0.5 ^ i <= i32
-0.5 ^ i >= i64
-0.5 ^ i32 * reduce(list, f64)
-0.5 ^ i32 ** f32
-0.5 ^ i32 < f32 ? ok : i32
-0.5 ^ i32 == i64
-0.5 ^ i32 ^ f64
-0.5 ^ i32 in array
-0.5 ^ i64 * i
-0.5 ^ i64 ** i
-0.5 ^ i64 ** i64
-0.5 ^ i64 > i32
-0.5 in array != ok
-0.5 in array && ok
-1 != 0.5 != ok
-1 != 0.5 and 1 == 1
-1 != 1 && ok
-1 != 1 ? f64 : 0.5 > i
-1 != 1 ? list : score
-1 != f32 != ok
-1 != f32 ? ok : half
-1 != i or ok
-1 != i64 ? add : div
-1 != nil && ok
-1 != nil == ok
-1 != nil or not false
-1 % 1 != i
-1 % 1 != i32
-1 % 1 % i
-1 % 1 / f32
-1 % 1 / i32
-1 % 1 < f64
-1 % 1 < i
-1 % 1 == f64
-1 % 1 == i ? nil : 0.5
-1 % 1 == i32
-1 % array[i32]
-1 % array[i]
-1 % i != -i64
-1 % i != 1 != nil
-1 % i - i64
-1 % i < i32
-1 % i >= f64
-1 % i >= i
-1 % i not in array
-1 % i32 != i
-1 % i32 <= f32
-1 % i32 > i64
-1 % i32 >= f64
-1 % i64 - f32
-1 % i64 < score(i)
-1 % i64 > f32
-1 * 0.5 + f64
-1 * 0.5 + i32
-1 * 0.5 + round(f64)
-1 * 0.5 / i
-1 * 0.5 / i64
-1 * 0.5 < i64
-1 * 0.5 == f32
-1 * 0.5 >= f32
-1 * 1 - i32
-1 * 1 <= int(i)
-1 * 1 >= f32
-1 * f32 != f64 - 0.5
-1 * f32 <= reduce(array, #)
-1 * f32 >= f64
-1 * f64 * i64
-1 * f64 <= i64
-1 * f64 > i
-1 * f64 >= f64
-1 * i * f32
-1 * i - i32
-1 * i / f64
-1 * i < f32
-1 * i > i32
-1 * i not in array
-1 * i32 + i32
-1 * i32 - i
-1 * i32 < i
-1 * i64 * f32
-1 * i64 + i
-1 * i64 - f64
-1 * i64 / f64
-1 * i64 <= f64
-1 * i64 in array
-1 ** 0.5 * i
-1 ** 0.5 ** f32
-1 ** 0.5 ** f64
-1 ** 0.5 ** i64
-1 ** 0.5 - f32
-1 ** 0.5 - i32
-1 ** 0.5 - i64
-1 ** 0.5 < -f32
-1 ** 0.5 > i
-1 ** 0.5 > i64
-1 ** 0.5 ^ f64
-1 ** 1 ** f64
-1 ** 1 + f64
-1 ** 1 + i64
-1 ** 1 - round(0.5)
-1 ** 1 / f64
-1 ** 1 < f32
-1 ** 1 == 0.5 + i32
-1 ** 1 >= i
-1 ** 1 >= i32
-1 ** 1 ^ i
-1 ** 1 ^ i32
-1 ** 1 in array
-1 ** array[i32]
-1 ** f32 / i32
-1 ** f32 / i64
-1 ** f32 <= f32
-1 ** f32 <= i64
-1 ** f32 == i64 ? i32 : array
-1 ** f32 >= f32
-1 ** f32 >= i
-1 ** f32 ^ f32
-1 ** f32 ^ i64
-1 ** i + i32
-1 ** i >= i
-1 ** i32 != i32
-1 ** i32 + f32
-1 ** i32 + i64
-1 ** i64 <= f32
-1 ** i64 <= f64
-1 ** i64 <= i32
-1 ** i64 > f32
-1 + 0.5 != i32
-1 + 0.5 + i
-1 + 0.5 - i64
-1 + 0.5 < f32
-1 + 0.5 < i
-1 + 0.5 == f64
-1 + 0.5 == f64 != nil
-1 + 0.5 > i64
-1 + 0.5 not in array
-1 + 1 != 0.5 ? 0.5 : half
-1 + 1 - f32
-1 + 1 - i
-1 + 1 < i
-1 + 1 == f64 * i64
-1 + 1 > f32
-1 + 1 >= half(0.5)
-1 + 1 >= i
-1 + f32 != i32
-1 + f32 < i32
-1 + f32 <= i
-1 + f32 > i64
-1 + f64 == i64
-1 + f64 >= f64
-1 + i .. i32
-1 + i <= ceil(f32)
-1 + i <= f64
-1 + i >= min(i64)
-1 + i32 != i32
-1 + i32 - f64
-1 + i32 < f32
-1 + i32 < i32
-1 + i32 <= f64
-1 + i32 > reduce(array, #)
-1 + i32 >= f64
-1 + i64 != i32
-1 + i64 != i64
-1 + i64 < i32
-1 + i64 <= i64
-1 - 0.5 != f32
-1 - 0.5 + i
-1 - 0.5 - f32
-1 - 0.5 <= i32
-1 - 0.5 <= i64
-1 - 1 < i64 ? 0.5 : "foo"
-1 - 1 <= i32 + i64
-1 - 1 == f64
-1 - 1 > i32 / i32
-1 - f32 != f32
-1 - f32 <= i64
-1 - f64 != f32
-1 - f64 + f32
-1 - f64 + i - 0.5
-1 - f64 <= i
-1 - f64 in array
-1 - f64 not in array
-1 - i > f64
+$env != $env == ok
+$env != $env ?: greet
+$env != $env.add
+$env != $env.array
+$env != $env.f64
+$env != $env.foo
+$env != $env.greet
+$env != $env.i
+$env != $env.list
+$env != $env.ok
+$env != $env.str
+$env != $env?.Bar
+$env != $env?.Bar?.add
+$env != $env?.Bar?.list
+$env != $env?.String
+$env != $env?.[Bar]
+$env != $env?.[Bar]?.sum(foobar matches Bar)
+$env != $env?.[String]
+$env != $env?.[String]?.[array]
+$env != $env?.[String]?.greet
+$env != $env?.[foobar]
+$env != $env?.[str]
+$env != $env?.add
+$env != $env?.array
+$env != $env?.f64
+$env != $env?.foo
+$env != $env?.foobar
+$env != $env?.foobar?.greet
+$env != $env?.greet
+$env != $env?.i
+$env != $env?.list
+$env != $env?.ok
+$env != $env?.str
+$env != 0 != ok
+$env != 0 && 1.0 != nil
+$env != 0 ?: $env?.[f64]
+$env != 1 / f64
+$env != 1.0 * i
+$env != 1.0 + f64
+$env != 1.0 - f64
+$env != 1.0 / i
+$env != 1.0 || abs($env)
+$env != add ? add : ok ?: array
+$env != array?.[i]
+$env != f64 / f64
+$env != false != ok
+$env != foo == $env?.[String]
+$env != foo and ok
+$env != foo.Bar
+$env != foo.String
+$env != foo.String()
+$env != foo?.Bar
+$env != foo?.String
+$env != foo?.String()
+$env != i not in toPairs($env)
+$env != list or ok
+$env != list?.[i]
+$env != nil != ok
+$env != str && ok
+$env != str + str
+$env != str || 1 in $env
+$env != true and nil != nil
+$env && false and $env matches $env
+$env && false or ok
+$env * 1 || true == true
+$env - 1.0 not startsWith $env && false
+$env .. $env in $env || true
+$env == $env && nil in list
+$env == $env ?: i != $env
+$env == $env and ok
+$env == $env or $env?.Bar()
+$env == $env.add
+$env == $env.array
+$env == $env.f64
+$env == $env.foo
+$env == $env.greet
+$env == $env.i
+$env == $env.list
+$env == $env.list?.[i]
+$env == $env.ok
+$env == $env.str
+$env == $env?.Bar
+$env == $env?.String
+$env == $env?.String?.foo
+$env == $env?.String?.foobar?.[array]
+$env == $env?.[Bar]
+$env == $env?.[Bar]?.[ok]?.[array]
+$env == $env?.[Bar]?.foo
+$env == $env?.[Bar]?.i
+$env == $env?.[String]
+$env == $env?.[str]
+$env == $env?.add
+$env == $env?.array
+$env == $env?.f64
+$env == $env?.f64 / i
+$env == $env?.foo
+$env == $env?.foobar
+$env == $env?.greet
+$env == $env?.i
+$env == $env?.list
+$env == $env?.ok
+$env == $env?.str
+$env == 0 ^ f64
+$env == 0 and take($env, 0)
+$env == 1 ?: array
+$env == 1.0 && $env != greet
+$env == 1.0 && map($env, false)?.[i]
+$env == 1.0 ** 1 ?: 1
+$env == 1.0 == none(array, true)
+$env == 1.0 ?: $env?.greet
+$env == 1.0 ^ $env?.f64
+$env == 1.0 ^ f64
+$env == 1.0 and add != add
+$env == add and $env[foo:]
+$env == array and ok
+$env == array?.[i]
+$env == f64 * f64
+$env == false not in $env?.[Bar]
+$env == false not in $env?.[String]
+$env == foo && ok
+$env == foo.Bar
+$env == foo.String
+$env == foo.String()
+$env == foo?.Bar
+$env == foo?.String
+$env == foo?.String()
+$env == i ** f64
+$env == i || ok
+$env == list && $env not in list
+$env == list && findLast($env, .array)
+$env == list?.[i]
+$env == list[i:]
+$env == nil && 1.0 > i
+$env == ok and $env in foo
+$env == str && ok or $env
+$env == str || ok
+$env >= 1.0 == $env or true
+$env contains $env?.Bar
+$env contains $env?.String
+$env contains $env?.[Bar]
+$env contains $env?.[Bar]?.[f64]
+$env contains $env?.[String]
+$env contains $env?.[str[:1.0]]
+$env contains $env?.foobar
+$env contains $env?.nil?.[list]
+$env endsWith $env?.Bar
+$env endsWith $env?.String
+$env endsWith $env?.[Bar]
+$env endsWith $env?.[Bar]?.str
+$env endsWith $env?.[String]
+$env endsWith $env?.[foobar?.[add]]
+$env endsWith $env?.foobar
+$env in $env.array
+$env in $env.list
+$env in $env?.Bar
+$env in $env?.Bar?.foo
+$env in $env?.String
+$env in $env?.String?.list
+$env in $env?.[Bar]
+$env in $env?.[String?.[str]]
+$env in $env?.[String]
+$env in $env?.array
+$env in $env?.foobar
+$env in $env?.foobar?.foo
+$env in $env?.list
+$env in $env?.true?.f64(foobar)
+$env in 0 .. i
+$env in 1 .. i
+$env in array or ok
+$env in i .. $env.i
+$env in list && $env and $env
+$env in list and $env?.[f64]
+$env matches $env && ok or true
+$env matches $env?.$env?.add
+$env matches $env?.Bar
+$env matches $env?.String
+$env matches $env?.[Bar]
+$env matches $env?.[Bar]?.[f64]
+$env matches $env?.[String]
+$env matches $env?.[String]?.ok()
+$env matches $env?.[foobar]
+$env matches $env?.foobar
+$env matches $env?.foobar?.Bar(foobar, foobar)
+$env matches $env?.foobar?.greet()
+$env not contains $env?.Bar
+$env not contains $env?.String
+$env not contains $env?.String?.[str]
+$env not contains $env?.String?.array
+$env not contains $env?.[Bar]
+$env not contains $env?.[Bar]?.add()
+$env not contains $env?.[Bar]?.ok
+$env not contains $env?.[String]
+$env not contains $env?.[first(foobar, greet)]
+$env not contains $env?.[foobar]
+$env not contains $env?.[toJSON(foobar)]
+$env not contains $env?.foobar
+$env not contains $env?.foobar?.[ok]
+$env not contains $env?.foobar?.greet()
+$env not endsWith $env?.Bar
+$env not endsWith $env?.Bar?.[list]
+$env not endsWith $env?.String
+$env not endsWith $env?.[Bar]
+$env not endsWith $env?.[String]
+$env not endsWith $env?.[foobar]
+$env not endsWith $env?.foobar
+$env not in $env.array
+$env not in $env.list
+$env not in $env?.Bar
+$env not in $env?.Bar?.[ok]
+$env not in $env?.String
+$env not in $env?.String?.f64
+$env not in $env?.[Bar]
+$env not in $env?.[String]
+$env not in $env?.[foobar]
+$env not in $env?.array
+$env not in $env?.list
+$env not in array && ok
+$env not in array == $env || false
+$env not in array == $env?.[String]
+$env not in array[:i]
+$env not in list or ok
+$env not matches $env?.Bar
+$env not matches $env?.Bar?.[add]
+$env not matches $env?.Bar?.array
+$env not matches $env?.String
+$env not matches $env?.String?.[add]
+$env not matches $env?.String?.[ok]
+$env not matches $env?.[Bar]
+$env not matches $env?.[String?.[Bar]]
+$env not matches $env?.[String]
+$env not matches $env?.[foobar]
+$env not startsWith $env?.Bar
+$env not startsWith $env?.Bar?.[greet]
+$env not startsWith $env?.String
+$env not startsWith $env?.[Bar]
+$env not startsWith $env?.[Bar]?.f64
+$env not startsWith $env?.[String]
+$env not startsWith $env?.[foobar]
+$env not startsWith $env?.foobar
+$env not startsWith $env?.foobar?.[foo]
+$env not startsWith $env?.foobar?.add
+$env or nil != nil || true
+$env or nil == list and false
+$env or true ?: greet
+$env startsWith $env?.Bar
+$env startsWith $env?.String
+$env startsWith $env?.[Bar]
+$env startsWith $env?.[String]
+$env startsWith $env?.[foobar]
+$env startsWith $env?.[foobar]?.[i]
+$env startsWith $env?.foobar
+$env startsWith $env?.foobar?.Bar()
+$env | any(false) != ok
+$env | filter(#.f64) | filter(false)
+$env | filter(false) | count(.i.greet)
+$env | filter(false) | find($env)
+$env | filter(false) | findIndex(.foo)
+$env | filter(false) | findLast(.greet)
+$env | filter(false) | findLast(.ok)
+$env | filter(false) | findLastIndex(.i)
+$env | filter(false) | map(#)
+$env | filter(false) | one(#)
+$env | filter(false) | sum(.greet)
+$env | filter(true) | map($env)
+$env | find(.add) startsWith str || true
+$env | findLast(false) == str or true
+$env | findLastIndex(true) - i
+$env | map(#index) | groupBy(f64)
+$env | map(#index) | map(i)
+$env | map(#index) | reduce(f64, nil)
+$env | map($env) | find(#.ok)
+$env | map($env) | map(list)
+$env | map($env) | sortBy(#.i)
+$env | map($env) | sortBy(.i)
+$env | map($env) | sortBy(i)
+$env | map(0) | groupBy(1)
+$env | map(0) | sortBy(#)
+$env | map(0) | sortBy(1.0)
+$env | map(1) | sum(#)
+$env | map(1.0) | filter(true)
+$env | map(1.0) | findLastIndex(ok)
+$env | map(1.0) | groupBy(foo)
+$env | map(1.0) | mean(0)
+$env | map(1.0) | none(true)
+$env | map(1.0) | reduce(1.0)
+$env | map(1.0) | reduce(false, list)
+$env | map(1.0) | sortBy(#)
+$env | map(false) | map(f64)
+$env | map(false) | reduce(str)
+$env | map(foo) | any(false)
+$env | map(foo) | findIndex(true)
+$env | map(foo) | groupBy(1)
+$env | map(foo) | reduce(#acc)
+$env | map(foo) | sum(1)
+$env | map(greet) | map(array)
+$env | map(i) | count(false)
+$env | map(list) | reduce(ok)
+$env | map(ok) | findLast(ok)
+$env | map(ok) | map($env)
+$env | map(ok) | none(#)
+$env | map(ok) | one(#)
+$env | map(ok) | reduce(0)
+$env | map(ok) | reduce(false)
+$env | map(str) | groupBy(foo)
+$env | map(true) | all(#)
+$env | map(true) | findLastIndex(#)
+$env | map(true) | map($env)
+$env | none(true) && ok
+$env | one(ok) || ok
+$env | reduce(#, nil) > $env and false
+$env | reduce($env, $env) | count(ok)
+$env | reduce($env, 1) | sum(0)
+$env | reduce(1.0, 1) <= f64
+$env | reduce(false, $env); list
+$env | reduce(ok, 1) ?: greet
+$env | sortBy(#, 0) * $env && false
+$env | sum(1.0) in array
+$env | sum(f64) > f64
+$env | sum(i) / bitnot(i)
+$env || true || $env < 1
+$env.add == $env.add
+$env.add == $env?.add
+$env.add == add
+$env.array != array
+$env.array != list
+$env.array == $env?.array
+$env.array == array
+$env.array == list
+$env.array | any($env?.ok)
+$env.array | any(false)
+$env.array | any(ok)
+$env.array | concat(array)
+$env.array | concat(list)
+$env.array | count(false)
+$env.array | filter(false)
+$env.array | filter(ok)
+$env.array | filter(true)
+$env.array | find(false)
+$env.array | find(ok)
+$env.array | find(true)
+$env.array | findIndex(false)
+$env.array | findIndex(nil == list)
+$env.array | findIndex(ok)
+$env.array | findIndex(true)
+$env.array | findLast(ok)
+$env.array | findLast(true)
+$env.array | findLastIndex(false)
+$env.array | findLastIndex(ok)
+$env.array | findLastIndex(true)
+$env.array | groupBy(#)
+$env.array | groupBy(0)
+$env.array | groupBy(1)
+$env.array | groupBy(1.0)
+$env.array | groupBy(f64)
+$env.array | groupBy(foo)
+$env.array | groupBy(i)
+$env.array | groupBy(ok)
+$env.array | map(#)
+$env.array | map(#index)
+$env.array | map($env)
+$env.array | map(1)
+$env.array | map(array)
+$env.array | map(f64)
+$env.array | map(false)
+$env.array | map(foo)
+$env.array | map(greet)
+$env.array | map(i)
+$env.array | map(list)
+$env.array | map(ok)
+$env.array | map(str)
+$env.array | map(true)
+$env.array | mean(1.0)
+$env.array | mean(f64)
+$env.array | mean(i)
+$env.array | median(0, array)
+$env.array | median(1)
+$env.array | none(ok)
+$env.array | none(true)
+$env.array | one(ok)
+$env.array | reduce(#)
+$env.array | reduce(#, 0)
+$env.array | reduce(#, foo)
+$env.array | reduce($env)
+$env.array | reduce(1)
+$env.array | reduce(1.0, greet)
+$env.array | reduce(add)
+$env.array | reduce(array)
+$env.array | reduce(f64)
+$env.array | reduce(false)
+$env.array | reduce(foo)
+$env.array | reduce(foo, 1)
+$env.array | reduce(foo, 1.0)
+$env.array | reduce(foo, array)
+$env.array | reduce(greet)
+$env.array | reduce(i)
+$env.array | reduce(i, true)
+$env.array | reduce(list)
+$env.array | reduce(ok)
+$env.array | reduce(str)
+$env.array | reduce(str, false)
+$env.array | reduce(true)
+$env.array | reduce(true, false)
+$env.array | reduce(true, true)
+$env.array | sortBy(#)
+$env.array | sortBy(1)
+$env.array | sortBy(1.0)
+$env.array | sortBy(f64)
+$env.array | sortBy(str)
+$env.array | sum(#)
+$env.array | sum(0)
+$env.array | sum(1)
+$env.array | sum(1.0)
+$env.array | take(0)
+$env.array?.[i]
+$env.array[:]
+$env.array[:i]
+$env.f64 != $env.i
+$env.f64 != 0 % i
+$env.f64 != abs(f64)
+$env.f64 != i
+$env.f64 * 0 >= 1.0
+$env.f64 * array?.[i]
+$env.f64 * f64
+$env.f64 * i
+$env.f64 ** i
+$env.f64 ** sum(array)
+$env.f64 + f64 == 1
+$env.f64 + i
+$env.f64 - 1 >= f64
+$env.f64 - 1.0 > 0
+$env.f64 - f64
+$env.f64 - i
+$env.f64 / f64
+$env.f64 / i
+$env.f64 < 1.0 || ok
+$env.f64 < f64
+$env.f64 < i
+$env.f64 <= f64
+$env.f64 <= i
+$env.f64 == f64
+$env.f64 > $env.f64
+$env.f64 > f64
+$env.f64 > i
+$env.f64 > sum($env, f64)
+$env.f64 >= 1.0 - 1.0
+$env.f64 >= abs(1.0)
+$env.f64 >= i
+$env.f64 ^ 0 / 0
+$env.f64 ^ f64
+$env.f64 ^ i
+$env.f64 ^ i != $env
+$env.f64 in array
+$env.f64 not in first($env)
+$env.f64 | max(f64)
+$env.f64 | mean(1)
+$env.f64 | mean(f64)
+$env.f64 | median(i)
+$env.foo != foo
+$env.foo == $env?.foo
+$env.foo == foo
+$env.foo == nil == $env
+$env.foo == nil and ok
+$env.foo in list
+$env.foo not in list
+$env.foo.Bar
+$env.foo.String
+$env.foo.String()
+$env.foo?.Bar
+$env.foo?.String
+$env.foo?.String()
+$env.greet != greet
+$env.greet == greet
+$env.greet($env.str)
+$env.greet($env?.[str])
+$env.greet(foo.Bar)
+$env.greet(foo.String())
+$env.greet(foo?.String())
+$env.greet(greet(str))
+$env.greet(str)
+$env.greet(string($env))
+$env.i != $env?.Bar
+$env.i != $env?.[Bar]?.foo()
+$env.i != 1 / 1
+$env.i % i
+$env.i * f64
+$env.i * i
+$env.i ** f64
+$env.i ** i
+$env.i ** mean(1.0)
+$env.i - f64
+$env.i / $env.f64
+$env.i / f64
+$env.i / find(array, true)
+$env.i < 1.0 or $env
+$env.i < i
+$env.i < i / i
+$env.i <= f64
+$env.i == f64
+$env.i == i
+$env.i > $env.i
+$env.i > f64
+$env.i >= f64
+$env.i >= i
+$env.i ^ f64
+$env.i ^ i
+$env.i in array
+$env.i in array != nil
+$env.i not in $env?.[String]
+$env.i not in $env?.array
+$env.i | add(i)
+$env.i | bitnand(i)
+$env.i | bitor(1)
+$env.i | bitshl(0)
+$env.i | bitshr(i)
+$env.i | bitushr(1)
+$env.i | bitushr(i)
+$env.i | bitxor(0)
+$env.i | max(1.0)
+$env.i | mean(i)
+$env.list != array
+$env.list != list
+$env.list == $env?.Bar
+$env.list == array
+$env.list == list
+$env.list == nil || $env
+$env.list | all(false)
+$env.list | all(ok)
+$env.list | all(true)
+$env.list | any(false)
+$env.list | any(ok)
+$env.list | any(true)
+$env.list | concat(array)
+$env.list | count(false)
+$env.list | count(true)
+$env.list | filter(false)
+$env.list | filter(true)
+$env.list | find(false)
+$env.list | find(nil not in list)
+$env.list | find(ok)
+$env.list | findIndex(false)
+$env.list | findIndex(ok)
+$env.list | findIndex(true)
+$env.list | findLast(true)
+$env.list | findLastIndex(true)
+$env.list | groupBy(#)
+$env.list | groupBy(.Bar)
+$env.list | groupBy(0)
+$env.list | groupBy(1)
+$env.list | groupBy(1.0)
+$env.list | groupBy(f64)
+$env.list | groupBy(false != false)
+$env.list | groupBy(false)
+$env.list | groupBy(foo)
+$env.list | map(#)
+$env.list | map(#.Bar)
+$env.list | map(#.String)
+$env.list | map(#index)
+$env.list | map($env)
+$env.list | map(.Bar)
+$env.list | map(0)
+$env.list | map(1)
+$env.list | map(1.0)
+$env.list | map(add)
+$env.list | map(array)
+$env.list | map(f64)
+$env.list | map(foo)
+$env.list | map(greet)
+$env.list | map(i)
+$env.list | map(list)
+$env.list | map(ok)
+$env.list | map(str)
+$env.list | map(true)
+$env.list | one(false)
+$env.list | one(true)
+$env.list | reduce(#)
+$env.list | reduce(#, nil)
+$env.list | reduce(#.Bar)
+$env.list | reduce($env)
+$env.list | reduce(.Bar, 1)
+$env.list | reduce(.String)
+$env.list | reduce(0)
+$env.list | reduce(1)
+$env.list | reduce(1.0)
+$env.list | reduce(1.0, f64)
+$env.list | reduce(1.0, false)
+$env.list | reduce(add)
+$env.list | reduce(add, nil)
+$env.list | reduce(array)
+$env.list | reduce(f64)
+$env.list | reduce(foo == #)
+$env.list | reduce(foo)
+$env.list | reduce(foo, 0)
+$env.list | reduce(foo, foo)
+$env.list | reduce(foo, nil)
+$env.list | reduce(foo, str)
+$env.list | reduce(i)
+$env.list | reduce(i, 1.0)
+$env.list | reduce(list)
+$env.list | reduce(str)
+$env.list | reduce(true, 1)
+$env.list | sortBy(#.Bar)
+$env.list | sortBy(.Bar)
+$env.list | sortBy(1.0)
+$env.list | sum(0)
+$env.list | sum(1)
+$env.list | sum(1.0)
+$env.list | sum(i)
+$env.list?.[i]
+$env.list?.[i].Bar
+$env.list?.[i].String()
+$env.list[:sum(array, #)]
+$env.list[i:]
+$env.ok != ok
+$env.ok && $env?.[nil]
+$env.ok && ok
+$env.ok == ok
+$env.ok ? list : date(1)
+$env.ok ?: array
+$env.ok ?: f64
+$env.ok and $env?.[foobar]
+$env.ok and $env?.[nil]
+$env.ok and ok
+$env.ok in $env?.[nil]
+$env.ok in keys($env)
+$env.ok not in $env?.$env
+$env.ok or ok
+$env.ok || ok
+$env.str != str
+$env.str + str
+$env.str + type($env)
+$env.str < $env?.[str]
+$env.str < foo.Bar
+$env.str <= str
+$env.str > str
+$env.str > type(nil)
+$env.str >= greet(str)
+$env.str >= str
+$env.str contains $env?.String
+$env.str contains str
+$env.str endsWith str
+$env.str in foo
+$env.str matches str
+$env.str matches str ?: 1.0
+$env.str matches string(1.0)
+$env.str not contains $env.str
+$env.str not contains str
+$env.str not endsWith str
+$env.str not in $env ? foo : 0
+$env.str not in foo
+$env.str not matches str
+$env.str not startsWith str
+$env.str | greet()
+$env.str | hasSuffix(str)
+$env.str | split(str)
+$env.str[:]
+$env.str[i:]
+$env; $env.add
+$env; $env?.foo
+$env; $env?.i
+$env; $env?.str
+$env; false; $env?.foo
+$env?.$env != $env.array
+$env?.$env != foo
+$env?.$env != i
+$env?.$env == add
+$env?.$env not contains str
+$env?.$env?.Bar
+$env?.$env?.Bar?.foo
+$env?.$env?.String
+$env?.$env?.String()
+$env?.$env?.[add]
+$env?.$env?.[array]
+$env?.$env?.[f64]
+$env?.$env?.[f64]?.str
+$env?.$env?.[foo]
+$env?.$env?.[foo].ok
+$env?.$env?.[greet]
+$env?.$env?.[i]
+$env?.$env?.[i].f64
+$env?.$env?.[i].str
+$env?.$env?.[i]?.[ok]
+$env?.$env?.[list]
+$env?.$env?.[ok]
+$env?.$env?.[str]
+$env?.$env?.[str]?.[foo]?.str
+$env?.$env?.add
+$env?.$env?.add()
+$env?.$env?.add?.ok
+$env?.$env?.array
+$env?.$env?.array()
+$env?.$env?.array.i
+$env?.$env?.array?.[ok]
+$env?.$env?.f64
+$env?.$env?.f64()
+$env?.$env?.f64.String
+$env?.$env?.filter(1.0, foo)
+$env?.$env?.foo
+$env?.$env?.foobar.i(foo)
+$env?.$env?.greet
+$env?.$env?.greet()
+$env?.$env?.greet.foo()
+$env?.$env?.greet?.i()
+$env?.$env?.i
+$env?.$env?.i()
+$env?.$env?.i()?.list
+$env?.$env?.i(str, foobar?.f64)
+$env?.$env?.i?.greet
+$env?.$env?.list
+$env?.$env?.list()
+$env?.$env?.list?.foo
+$env?.$env?.ok
+$env?.$env?.ok()
+$env?.$env?.ok(String)
+$env?.$env?.ok?.String
+$env?.$env?.str
+$env?.$env?.str()
+$env?.$env?.str()?.[add]
+$env?.$env?.str(foobar)
+$env?.$env?.sum(0, list)
+$env?.Bar != $env.add
+$env?.Bar != add
+$env?.Bar != f64
+$env?.Bar != foo
+$env?.Bar != greet
+$env?.Bar != i
+$env?.Bar != list
+$env?.Bar != min(1)
+$env?.Bar != ok
+$env?.Bar != str
+$env?.Bar != type(1.0)
+$env?.Bar + 1.0 or true
+$env?.Bar == $env?.f64
+$env?.Bar == 1.0 / f64
+$env?.Bar == add
+$env?.Bar == array
+$env?.Bar == f64
+$env?.Bar == greet
+$env?.Bar == greet(str)
+$env?.Bar == i
+$env?.Bar == map(list, 1.0)
+$env?.Bar == ok
+$env?.Bar == ok or true
+$env?.Bar == string(list)
+$env?.Bar contains $env?.$env
+$env?.Bar contains str
+$env?.Bar endsWith str
+$env?.Bar endsWith str ? foo : 1
+$env?.Bar in array
+$env?.Bar matches str
+$env?.Bar matches string(i)
+$env?.Bar not contains str
+$env?.Bar not endsWith foo.Bar
+$env?.Bar not in $env?.String
+$env?.Bar not in [f64, $env]
+$env?.Bar not in array
+$env?.Bar not in list
+$env?.Bar not in list and $env
+$env?.Bar not matches str
+$env?.Bar not startsWith $env?.str
+$env?.Bar not startsWith str
+$env?.Bar startsWith $env?.[String]
+$env?.Bar startsWith str
+$env?.Bar?.Bar
+$env?.Bar?.Bar()
+$env?.Bar?.Bar().Bar
+$env?.Bar?.Bar()?.[f64]
+$env?.Bar?.Bar(foobar)
+$env?.Bar?.Bar(foobar?.String)
+$env?.Bar?.Bar.add
+$env?.Bar?.Bar.i
+$env?.Bar?.Bar.ok
+$env?.Bar?.Bar?.Bar
+$env?.Bar?.Bar?.Bar().greet
+$env?.Bar?.Bar?.String
+$env?.Bar?.Bar?.[f64]
+$env?.Bar?.Bar?.i
+$env?.Bar?.Bar?.ok
+$env?.Bar?.Bar?.str
+$env?.Bar?.String
+$env?.Bar?.String()
+$env?.Bar?.String(foo)
+$env?.Bar?.String(foobar)
+$env?.Bar?.String(foobar)?.[add]
+$env?.Bar?.String(foobar)?.[ok]?.[str]
+$env?.Bar?.String(foobar)?.str
+$env?.Bar?.String(foobar?.Bar?.[f64])
+$env?.Bar?.String(foobar?.[true])
+$env?.Bar?.String(greet)
+$env?.Bar?.String(i)
+$env?.Bar?.String(str | toBase64(foobar), foobar)
+$env?.Bar?.String.i
+$env?.Bar?.String?.String
+$env?.Bar?.String?.[i]
+$env?.Bar?.String?.[str]
+$env?.Bar?.String?.foo
+$env?.Bar?.String?.str()
+$env?.Bar?.[$env.i]
+$env?.Bar?.[$env?.[add]].Bar
+$env?.Bar?.[add]
+$env?.Bar?.[add].add
+$env?.Bar?.[add].foo
+$env?.Bar?.[add].i
+$env?.Bar?.[add]?.foo
+$env?.Bar?.[add]?.ok
+$env?.Bar?.[add]?.str
+$env?.Bar?.[array]
+$env?.Bar?.[array].ok()
+$env?.Bar?.[array]?.Bar
+$env?.Bar?.[array]?.add
+$env?.Bar?.[array]?.foo
+$env?.Bar?.[array]?.list
+$env?.Bar?.[f64]
+$env?.Bar?.[f64].Bar
+$env?.Bar?.[f64].list
+$env?.Bar?.[f64]?.Bar
+$env?.Bar?.[f64]?.[greet]
+$env?.Bar?.[f64]?.[list]
+$env?.Bar?.[f64]?.array()
+$env?.Bar?.[false != $env]
+$env?.Bar?.[foo]
+$env?.Bar?.[foo].add
+$env?.Bar?.[foo].array()
+$env?.Bar?.[foo].greet
+$env?.Bar?.[foo]?.Bar
+$env?.Bar?.[foo]?.String
+$env?.Bar?.[foo]?.[greet]
+$env?.Bar?.[foo]?.[ok]
+$env?.Bar?.[foo]?.str
+$env?.Bar?.[greet]
+$env?.Bar?.[greet].add
+$env?.Bar?.[greet].f64
+$env?.Bar?.[greet].foo
+$env?.Bar?.[greet].i
+$env?.Bar?.[greet].ok
+$env?.Bar?.[greet]?.f64
+$env?.Bar?.[groupBy(list, #)]
+$env?.Bar?.[i]
+$env?.Bar?.[i].foo
+$env?.Bar?.[i].ok
+$env?.Bar?.[i]?.Bar
+$env?.Bar?.[i]?.String
+$env?.Bar?.[i]?.[greet]
+$env?.Bar?.[i]?.[ok]
+$env?.Bar?.[i]?.f64
+$env?.Bar?.[i]?.foo
+$env?.Bar?.[i]?.str()
+$env?.Bar?.[list]
+$env?.Bar?.[list].Bar
+$env?.Bar?.[list].add
+$env?.Bar?.[list].f64
+$env?.Bar?.[list].greet
+$env?.Bar?.[list].i(foobar)
+$env?.Bar?.[list].str()
+$env?.Bar?.[list]?.String
+$env?.Bar?.[list]?.[foo]
+$env?.Bar?.[list]?.[i]
+$env?.Bar?.[list]?.array.list
+$env?.Bar?.[list]?.f64
+$env?.Bar?.[list]?.list()
+$env?.Bar?.[list]?.str()
+$env?.Bar?.[median(0)]
+$env?.Bar?.[ok]
+$env?.Bar?.[ok].Bar
+$env?.Bar?.[ok].String
+$env?.Bar?.[ok].f64
+$env?.Bar?.[ok]?.String
+$env?.Bar?.[ok]?.[i]
+$env?.Bar?.[ok]?.[str]
+$env?.Bar?.[ok]?.add
+$env?.Bar?.[ok]?.array
+$env?.Bar?.[ok]?.array()
+$env?.Bar?.[ok]?.f64()
+$env?.Bar?.[ok]?.greet.array(foobar?.[str])
+$env?.Bar?.[ok]?.ok
+$env?.Bar?.[str]
+$env?.Bar?.[str].i
+$env?.Bar?.[str]?.[array]
+$env?.Bar?.[str]?.[foo]
+$env?.Bar?.[str]?.[i]
+$env?.Bar?.add
+$env?.Bar?.add not contains $env
+$env?.Bar?.add($env.foo).String
+$env?.Bar?.add()
+$env?.Bar?.add().f64
+$env?.Bar?.add().f64(foobar)
+$env?.Bar?.add()?.i()
+$env?.Bar?.add(add)
+$env?.Bar?.add(foobar)
+$env?.Bar?.add(foobar?.Bar?.[list])
+$env?.Bar?.add.i
+$env?.Bar?.add.list
+$env?.Bar?.add.ok()
+$env?.Bar?.add?.[add]
+$env?.Bar?.add?.[greet]
+$env?.Bar?.any(str)
+$env?.Bar?.array
+$env?.Bar?.array($env)
+$env?.Bar?.array()
+$env?.Bar?.array(array)
+$env?.Bar?.array(f64)
+$env?.Bar?.array(foobar)
+$env?.Bar?.array(foobar?.foo).ok
+$env?.Bar?.array(list)
+$env?.Bar?.array(ok)
+$env?.Bar?.array(reduce(list, foobar))?.Bar
+$env?.Bar?.array(str)
+$env?.Bar?.array.Bar
+$env?.Bar?.array.array
+$env?.Bar?.array.list(string(list) endsWith foobar?.String)
+$env?.Bar?.array.str
+$env?.Bar?.array?.[array]
+$env?.Bar?.array?.[f64]
+$env?.Bar?.array?.[foo]
+$env?.Bar?.array?.[str]
+$env?.Bar?.array?.array
+$env?.Bar?.array?.foo
+$env?.Bar?.bitand(foobar)
+$env?.Bar?.bitnand(i, f64)
+$env?.Bar?.bitshl(str, foobar)
+$env?.Bar?.bitshr(foobar)
+$env?.Bar?.f64
+$env?.Bar?.f64()
+$env?.Bar?.f64().add()
+$env?.Bar?.f64(1)
+$env?.Bar?.f64(Bar?.[ok])
+$env?.Bar?.f64(foobar)
+$env?.Bar?.f64(foobar, foobar?.str())
+$env?.Bar?.f64.Bar(0)
+$env?.Bar?.f64.array()
+$env?.Bar?.f64.list
+$env?.Bar?.f64?.Bar()
+$env?.Bar?.f64?.[f64]
+$env?.Bar?.f64?.[i]
+$env?.Bar?.f64?.f64
+$env?.Bar?.f64?.list()
+$env?.Bar?.f64?.str
+$env?.Bar?.false?.[foo]
+$env?.Bar?.false?.list
+$env?.Bar?.findIndex(false)
+$env?.Bar?.findLastIndex(1, foobar)
+$env?.Bar?.foo
+$env?.Bar?.foo not contains $env
+$env?.Bar?.foo($env matches foobar)
+$env?.Bar?.foo()
+$env?.Bar?.foo().greet.str
+$env?.Bar?.foo(foobar)
+$env?.Bar?.foo(foobar, foobar)
+$env?.Bar?.foo(i)
+$env?.Bar?.foo(list)
+$env?.Bar?.foo.Bar
+$env?.Bar?.foo.array
+$env?.Bar?.foo.i
+$env?.Bar?.foo?.Bar
+$env?.Bar?.foo?.[ok]
+$env?.Bar?.foo?.str
+$env?.Bar?.foobar
+$env?.Bar?.foobar.add
+$env?.Bar?.foobar.foobar
+$env?.Bar?.foobar.i
+$env?.Bar?.foobar.list
+$env?.Bar?.foobar.str()?.ok
+$env?.Bar?.foobar?.[i].String
+$env?.Bar?.foobar?.[list]
+$env?.Bar?.foobar?.i
+$env?.Bar?.foobar?.list
+$env?.Bar?.fromPairs(0)
+$env?.Bar?.greet
+$env?.Bar?.greet()
+$env?.Bar?.greet()?.String
+$env?.Bar?.greet(array)
+$env?.Bar?.greet(foo)
+$env?.Bar?.greet(foobar startsWith foobar)
+$env?.Bar?.greet(foobar)
+$env?.Bar?.greet(foobar?.ok())
+$env?.Bar?.greet(ok)
+$env?.Bar?.greet.add()
+$env?.Bar?.greet.f64
+$env?.Bar?.greet.foo
+$env?.Bar?.greet?.[array]
+$env?.Bar?.greet?.foo
+$env?.Bar?.greet?.i()
+$env?.Bar?.groupBy(add)
+$env?.Bar?.i
+$env?.Bar?.i()
+$env?.Bar?.i(String)
+$env?.Bar?.i(foobar?.[str])
+$env?.Bar?.i(list)
+$env?.Bar?.i.array()
+$env?.Bar?.i?.[add]
+$env?.Bar?.i?.[greet]?.[array]
+$env?.Bar?.i?.array
+$env?.Bar?.i?.foo
+$env?.Bar?.i?.ok
+$env?.Bar?.len(greet)
+$env?.Bar?.list
+$env?.Bar?.list()
+$env?.Bar?.list().ok
+$env?.Bar?.list()?.ok
+$env?.Bar?.list(f64)
+$env?.Bar?.list(foobar)
+$env?.Bar?.list(list)?.str
+$env?.Bar?.list(type(foobar))
+$env?.Bar?.list.Bar
+$env?.Bar?.list.foobar
+$env?.Bar?.list?.String
+$env?.Bar?.list?.[foo]?.String()?.list
+$env?.Bar?.list?.[list]
+$env?.Bar?.list?.add
+$env?.Bar?.list?.f64
+$env?.Bar?.list?.foo
+$env?.Bar?.list?.i
+$env?.Bar?.map(foobar)
+$env?.Bar?.map(foobar, greet, String)
+$env?.Bar?.median(true, $env)
+$env?.Bar?.nil.array()
+$env?.Bar?.none(foobar)
+$env?.Bar?.ok
+$env?.Bar?.ok()
+$env?.Bar?.ok().greet
+$env?.Bar?.ok()?.f64
+$env?.Bar?.ok()?.list
+$env?.Bar?.ok(f64)
+$env?.Bar?.ok(foobar)
+$env?.Bar?.ok(greet)
+$env?.Bar?.ok(list)
+$env?.Bar?.ok(str)
+$env?.Bar?.ok.String()
+$env?.Bar?.ok.greet
+$env?.Bar?.ok.str
+$env?.Bar?.ok?.Bar
+$env?.Bar?.ok?.String
+$env?.Bar?.ok?.[array]
+$env?.Bar?.ok?.[f64]
+$env?.Bar?.ok?.f64
+$env?.Bar?.ok?.foo
+$env?.Bar?.ok?.str
+$env?.Bar?.reduce(foobar, foobar)
+$env?.Bar?.reduce(true)
+$env?.Bar?.round(foobar)
+$env?.Bar?.sortBy($env, false)
+$env?.Bar?.sortBy(nil)
+$env?.Bar?.split(false)
+$env?.Bar?.str
+$env?.Bar?.str != ok
+$env?.Bar?.str()
+$env?.Bar?.str()?.f64
+$env?.Bar?.str()?.greet
+$env?.Bar?.str(1, foobar)
+$env?.Bar?.str(add)
+$env?.Bar?.str(foobar)
+$env?.Bar?.str.foo
+$env?.Bar?.str?.[foo]
+$env?.Bar?.str?.[greet]
+$env?.Bar?.str?.[ok]
+$env?.Bar?.str?.[str]
+$env?.Bar?.str?.i()
+$env?.Bar?.string(foobar)
+$env?.String != $env ? ok : true
+$env?.String != foo
+$env?.String != greet
+$env?.String != list
+$env?.String != str
+$env?.String == array
+$env?.String == f64
+$env?.String == greet
+$env?.String == i
+$env?.String == list
+$env?.String == str
+$env?.String contains str
+$env?.String endsWith $env && $env
+$env?.String endsWith str
+$env?.String in $env ? 1 : true
+$env?.String in array
+$env?.String in list
+$env?.String matches $env?.nil
+$env?.String matches str
+$env?.String not contains str
+$env?.String not endsWith $env and $env
+$env?.String not endsWith $env.str
+$env?.String not in $env?.Bar?.array
+$env?.String not in array
+$env?.String not in list
+$env?.String not matches $env?.[String]
+$env?.String not startsWith str
+$env?.String startsWith str
+$env?.String?.$env != true
+$env?.String?.Bar
+$env?.String?.Bar()
+$env?.String?.Bar(String)
+$env?.String?.Bar(add)
+$env?.String?.Bar(foobar)
+$env?.String?.Bar(ok)
+$env?.String?.Bar.String
+$env?.String?.Bar.add
+$env?.String?.Bar.add()
+$env?.String?.Bar.i
+$env?.String?.Bar.list
+$env?.String?.Bar.str
+$env?.String?.Bar?.String
+$env?.String?.Bar?.[greet]
+$env?.String?.Bar?.[ok]
+$env?.String?.Bar?.i
+$env?.String?.Bar?.str
+$env?.String?.String
+$env?.String?.String()
+$env?.String?.String(foobar)
+$env?.String?.String(str)
+$env?.String?.String.add.f64
+$env?.String?.String.f64
+$env?.String?.String.i
+$env?.String?.String.ok
+$env?.String?.String?.[foo]
+$env?.String?.String?.f64
+$env?.String?.String?.foo
+$env?.String?.String?.greet
+$env?.String?.String?.one(foobar?.list)
+$env?.String?.[$env?.[f64]]
+$env?.String?.[add]
+$env?.String?.[add] != greet
+$env?.String?.[add].array
+$env?.String?.[add].i
+$env?.String?.[add]?.Bar?.array
+$env?.String?.[add]?.[f64]
+$env?.String?.[add]?.[i]
+$env?.String?.[add]?.[list]
+$env?.String?.[array]
+$env?.String?.[array].f64
+$env?.String?.[array].f64()
+$env?.String?.[array].str
+$env?.String?.[array]?.array
+$env?.String?.[array]?.foo()
+$env?.String?.[f64]
+$env?.String?.[f64].add
+$env?.String?.[f64].foobar
+$env?.String?.[f64]?.Bar
+$env?.String?.[f64]?.String
+$env?.String?.[f64]?.[str]
+$env?.String?.[f64]?.array
+$env?.String?.[f64]?.greet
+$env?.String?.[f64]?.list
+$env?.String?.[foo]
+$env?.String?.[foo].array
+$env?.String?.[foo].f64()
+$env?.String?.[foo].i
+$env?.String?.[foo]?.[foo]
+$env?.String?.[foo]?.[i]
+$env?.String?.[foo]?.add
+$env?.String?.[foo]?.foo
+$env?.String?.[foo]?.i
+$env?.String?.[foo]?.list
+$env?.String?.[foo]?.ok
+$env?.String?.[greet]
+$env?.String?.[greet].add
+$env?.String?.[greet].any(foobar).str
+$env?.String?.[greet].array
+$env?.String?.[greet]?.[list]
+$env?.String?.[greet]?.f64
+$env?.String?.[greet]?.list
+$env?.String?.[i]
+$env?.String?.[i].f64
+$env?.String?.[i].f64()
+$env?.String?.[i].foo
+$env?.String?.[i].list
+$env?.String?.[i]?.[array]
+$env?.String?.[i]?.[foo]
+$env?.String?.[i]?.[greet]
+$env?.String?.[i]?.add
+$env?.String?.[i]?.array
+$env?.String?.[i]?.foo
+$env?.String?.[i]?.str()
+$env?.String?.[list]
+$env?.String?.[list].array
+$env?.String?.[list].foo
+$env?.String?.[list].list
+$env?.String?.[list].ok()
+$env?.String?.[list]?.[list]
+$env?.String?.[list]?.[str]
+$env?.String?.[list]?.add
+$env?.String?.[list]?.list(foobar)
+$env?.String?.[ok]
+$env?.String?.[ok].Bar
+$env?.String?.[ok].add
+$env?.String?.[ok]?.Bar.str
+$env?.String?.[ok]?.[i]
+$env?.String?.[ok]?.[ok]
+$env?.String?.[ok]?.[str]
+$env?.String?.[ok]?.greet
+$env?.String?.[ok]?.ok
+$env?.String?.[str]
+$env?.String?.[str].foo
+$env?.String?.[str].str()
+$env?.String?.[str]?.[array]
+$env?.String?.[str]?.[list]
+$env?.String?.[str]?.array
+$env?.String?.[str]?.f64
+$env?.String?.[str]?.str(str)
+$env?.String?.add
+$env?.String?.add()
+$env?.String?.add()?.[i]
+$env?.String?.add(Bar)
+$env?.String?.add(f64 not endsWith nil)
+$env?.String?.add.ok()
+$env?.String?.add?.[f64]
+$env?.String?.add?.[ok]
+$env?.String?.add?.array
+$env?.String?.add?.greet
+$env?.String?.add?.i(f64)
+$env?.String?.add?.list
+$env?.String?.add?.ok
+$env?.String?.add?.str?.array
+$env?.String?.all(1.0, true)
+$env?.String?.all(foobar)
+$env?.String?.all(nil, nil)
+$env?.String?.all(ok, nil)
+$env?.String?.any(foo)
+$env?.String?.array
+$env?.String?.array not endsWith str
+$env?.String?.array()
+$env?.String?.array()?.[f64]
+$env?.String?.array(String)
+$env?.String?.array(array matches nil)
+$env?.String?.array(i)
+$env?.String?.array(str not in String)
+$env?.String?.array.Bar
+$env?.String?.array.String
+$env?.String?.array.f64
+$env?.String?.array.foo
+$env?.String?.array.list
+$env?.String?.array?.String
+$env?.String?.array?.array()
+$env?.String?.array?.f64
+$env?.String?.array?.f64.list()
+$env?.String?.array?.ok
+$env?.String?.bitshl(String)
+$env?.String?.bitshr(nil, f64)
+$env?.String?.bitushr(str, foobar)
+$env?.String?.bitxor(String)
+$env?.String?.duration(foobar)
+$env?.String?.f64
+$env?.String?.f64()
+$env?.String?.f64()?.[i]
+$env?.String?.f64()?.[str]
+$env?.String?.f64(foobar)
+$env?.String?.f64(foobar, foobar)
+$env?.String?.f64(i)
+$env?.String?.f64(list)
+$env?.String?.f64(nil == f64)
+$env?.String?.f64.f64
+$env?.String?.f64.list
+$env?.String?.f64.ok
+$env?.String?.f64.str(foobar, foobar)?.[add]
+$env?.String?.f64?.[array]
+$env?.String?.f64?.[greet]
+$env?.String?.f64?.list?.[str]
+$env?.String?.f64?.ok
+$env?.String?.findIndex($env)
+$env?.String?.findIndex(f64, foobar)
+$env?.String?.findIndex(foobar)
+$env?.String?.findLast(greet, nil)
+$env?.String?.foo
+$env?.String?.foo($env)
+$env?.String?.foo()
+$env?.String?.foo()?.[i]
+$env?.String?.foo(foo)
+$env?.String?.foo(greet)
+$env?.String?.foo(list, 1)
+$env?.String?.foo(ok)
+$env?.String?.foo.i
+$env?.String?.foo?.[f64]
+$env?.String?.foo?.[i]
+$env?.String?.foo?.[ok]
+$env?.String?.foo?.[ok].f64()
+$env?.String?.foo?.greet
+$env?.String?.foobar
+$env?.String?.foobar in array
+$env?.String?.foobar.f64
+$env?.String?.foobar.foo
+$env?.String?.foobar.greet
+$env?.String?.foobar?.[add]
+$env?.String?.foobar?.[list]
+$env?.String?.foobar?.add()
+$env?.String?.foobar?.foo()
+$env?.String?.get(nil)
+$env?.String?.greet
+$env?.String?.greet()
+$env?.String?.greet().Bar
+$env?.String?.greet().foo
+$env?.String?.greet()?.[i]
+$env?.String?.greet(foobar == String)
+$env?.String?.greet(foobar or true)
+$env?.String?.greet(foobar)
+$env?.String?.greet.add
+$env?.String?.greet.i
+$env?.String?.greet?.[array]
+$env?.String?.greet?.[list]
+$env?.String?.greet?.[ok]
+$env?.String?.greet?.foo
+$env?.String?.greet?.i
+$env?.String?.greet?.list
+$env?.String?.i
+$env?.String?.i()
+$env?.String?.i(0).f64
+$env?.String?.i(1)
+$env?.String?.i(String?.$env)
+$env?.String?.i(array)
+$env?.String?.i(f64)
+$env?.String?.i(foobar)
+$env?.String?.i.add
+$env?.String?.i.foo
+$env?.String?.i.foobar
+$env?.String?.i.str
+$env?.String?.i?.String
+$env?.String?.i?.[f64]
+$env?.String?.i?.ok
+$env?.String?.int(add, foobar, greet)
+$env?.String?.join(true, f64)
+$env?.String?.list
+$env?.String?.list()
+$env?.String?.list(false)
+$env?.String?.list(ok)
+$env?.String?.list.array()
+$env?.String?.list?.[i]
+$env?.String?.list?.[str]
+$env?.String?.list?.f64
+$env?.String?.list?.list
+$env?.String?.list?.str
+$env?.String?.map(nil, String)
+$env?.String?.nil endsWith str
+$env?.String?.not
+$env?.String?.ok
+$env?.String?.ok()
+$env?.String?.ok(foobar not endsWith add)
+$env?.String?.ok(foobar)
+$env?.String?.ok(nil)
+$env?.String?.ok.Bar()
+$env?.String?.ok.array
+$env?.String?.ok.f64
+$env?.String?.ok.foo
+$env?.String?.ok.greet
+$env?.String?.ok.list
+$env?.String?.ok?.Bar
+$env?.String?.ok?.[array]
+$env?.String?.ok?.[list]
+$env?.String?.ok?.[ok]
+$env?.String?.ok?.str
+$env?.String?.round(foobar, foobar)
+$env?.String?.sortBy(foobar)
+$env?.String?.str
+$env?.String?.str()
+$env?.String?.str(foobar)
+$env?.String?.str.Bar
+$env?.String?.str.add()
+$env?.String?.str.list
+$env?.String?.str.str
+$env?.String?.str?.Bar
+$env?.String?.str?.String
+$env?.String?.str?.[greet]
+$env?.String?.str?.[str]
+$env?.String?.str?.i
+$env?.String?.str?.ok
+$env?.String?.sum(1.0)
+$env?.String?.toPairs(Bar)
+$env?.String?.true.array
+$env?.[1.0]?.foobar and false
+$env?.[Bar] != 1.0 + 1.0
+$env?.[Bar] != add
+$env?.[Bar] != array
+$env?.[Bar] != foo
+$env?.[Bar] != greet
+$env?.[Bar] != i
+$env?.[Bar] != list
+$env?.[Bar] != ok
+$env?.[Bar] != str
+$env?.[Bar] != str != true
+$env?.[Bar] != string(false)
+$env?.[Bar] < i || true
+$env?.[Bar] == $env.array
+$env?.[Bar] == add
+$env?.[Bar] == array
+$env?.[Bar] == foo
+$env?.[Bar] == greet ? 0 : true
+$env?.[Bar] == list
+$env?.[Bar] == ok
+$env?.[Bar] and true and false
+$env?.[Bar] contains last($env)
+$env?.[Bar] contains str
+$env?.[Bar] endsWith str
+$env?.[Bar] in $env?.nil?.add
+$env?.[Bar] in array
+$env?.[Bar] in list
+$env?.[Bar] matches $env?.str
+$env?.[Bar] matches str
+$env?.[Bar] not contains $env.str
+$env?.[Bar] not contains $env?.Bar
+$env?.[Bar] not contains str
+$env?.[Bar] not in list
+$env?.[Bar] not matches str
+$env?.[Bar] not startsWith $env?.[String]
+$env?.[Bar] not startsWith foo.Bar
+$env?.[Bar] not startsWith str
+$env?.[Bar] not startsWith str != nil
+$env?.[Bar] startsWith str
+$env?.[Bar]?.$env?.[f64]
+$env?.[Bar]?.$env?.[foo].Bar
+$env?.[Bar]?.Bar
+$env?.[Bar]?.Bar($env)
+$env?.[Bar]?.Bar()
+$env?.[Bar]?.Bar(0)?.foo
+$env?.[Bar]?.Bar(Bar not contains f64)
+$env?.[Bar]?.Bar(foo)
+$env?.[Bar]?.Bar(foobar)
+$env?.[Bar]?.Bar.add
+$env?.[Bar]?.Bar.greet
+$env?.[Bar]?.Bar?.list
+$env?.[Bar]?.String
+$env?.[Bar]?.String()
+$env?.[Bar]?.String(f64)
+$env?.[Bar]?.String(foobar not contains foobar?.String)
+$env?.[Bar]?.String(foobar)
+$env?.[Bar]?.String(str)
+$env?.[Bar]?.String.greet
+$env?.[Bar]?.String.i
+$env?.[Bar]?.String?.Bar
+$env?.[Bar]?.String?.[f64]
+$env?.[Bar]?.String?.[foo]
+$env?.[Bar]?.String?.[greet]
+$env?.[Bar]?.String?.[str]
+$env?.[Bar]?.String?.add
+$env?.[Bar]?.String?.add(foobar)
+$env?.[Bar]?.String?.array
+$env?.[Bar]?.String?.foo
+$env?.[Bar]?.String?.greet?.String(foobar)?.greet
+$env?.[Bar]?.String?.i()
+$env?.[Bar]?.String?.i(false)
+$env?.[Bar]?.String?.list
+$env?.[Bar]?.String?.ok
+$env?.[Bar]?.[$env?.array]
+$env?.[Bar]?.[add]
+$env?.[Bar]?.[add].Bar()
+$env?.[Bar]?.[add].f64
+$env?.[Bar]?.[add].foo
+$env?.[Bar]?.[add].greet
+$env?.[Bar]?.[add].ok
+$env?.[Bar]?.[add].str
+$env?.[Bar]?.[add]?.[list]
+$env?.[Bar]?.[add]?.[ok]
+$env?.[Bar]?.[add]?.i
+$env?.[Bar]?.[add]?.list
+$env?.[Bar]?.[array]
+$env?.[Bar]?.[array].String
+$env?.[Bar]?.[array].String()
+$env?.[Bar]?.[array].add()
+$env?.[Bar]?.[array].f64
+$env?.[Bar]?.[array].foo
+$env?.[Bar]?.[array].greet
+$env?.[Bar]?.[array].i
+$env?.[Bar]?.[array]?.f64
+$env?.[Bar]?.[array]?.foo
+$env?.[Bar]?.[count($env)]
+$env?.[Bar]?.[count(list)]
+$env?.[Bar]?.[f64]
+$env?.[Bar]?.[f64] != i
+$env?.[Bar]?.[f64].array
+$env?.[Bar]?.[f64].f64
+$env?.[Bar]?.[f64].str
+$env?.[Bar]?.[f64]?.Bar
+$env?.[Bar]?.[f64]?.[add]
+$env?.[Bar]?.[f64]?.[ok]
+$env?.[Bar]?.[f64]?.array
+$env?.[Bar]?.[f64]?.f64()
+$env?.[Bar]?.[f64]?.foo()
+$env?.[Bar]?.[f64]?.none(foobar)
+$env?.[Bar]?.[foo == foo]
+$env?.[Bar]?.[foo]
+$env?.[Bar]?.[foo].foo()
+$env?.[Bar]?.[foo].greet
+$env?.[Bar]?.[foo].i
+$env?.[Bar]?.[foo]?.[f64]
+$env?.[Bar]?.[foo]?.[foo]
+$env?.[Bar]?.[foo]?.[list]
+$env?.[Bar]?.[foo]?.ok()
+$env?.[Bar]?.[foo]?.str
+$env?.[Bar]?.[greet]
+$env?.[Bar]?.[greet].array
+$env?.[Bar]?.[greet].array()
+$env?.[Bar]?.[greet].i
+$env?.[Bar]?.[greet].i()
+$env?.[Bar]?.[greet].str
+$env?.[Bar]?.[greet]?.String
+$env?.[Bar]?.[greet]?.add()
+$env?.[Bar]?.[greet]?.array()
+$env?.[Bar]?.[greet]?.i
+$env?.[Bar]?.[greet]?.str
+$env?.[Bar]?.[groupBy($env, #)]?.[str]
+$env?.[Bar]?.[i]
+$env?.[Bar]?.[i].Bar
+$env?.[Bar]?.[i].Bar()
+$env?.[Bar]?.[i].str
+$env?.[Bar]?.[i]?.String
+$env?.[Bar]?.[i]?.[list]
+$env?.[Bar]?.[i]?.[ok]
+$env?.[Bar]?.[i]?.array
+$env?.[Bar]?.[i]?.i
+$env?.[Bar]?.[i]?.str
+$env?.[Bar]?.[list]
+$env?.[Bar]?.[list] in list
+$env?.[Bar]?.[list].String
+$env?.[Bar]?.[list].add()
+$env?.[Bar]?.[list].array
+$env?.[Bar]?.[list].foo
+$env?.[Bar]?.[list].greet
+$env?.[Bar]?.[list].ok
+$env?.[Bar]?.[list].ok()
+$env?.[Bar]?.[list]?.String
+$env?.[Bar]?.[list]?.[array]
+$env?.[Bar]?.[list]?.[greet]?.list
+$env?.[Bar]?.[list]?.[i]
+$env?.[Bar]?.[list]?.[list]
+$env?.[Bar]?.[list]?.f64
+$env?.[Bar]?.[list]?.foo
+$env?.[Bar]?.[list]?.i
+$env?.[Bar]?.[ok]
+$env?.[Bar]?.[ok].f64
+$env?.[Bar]?.[ok].foo()
+$env?.[Bar]?.[ok]?.[i]
+$env?.[Bar]?.[ok]?.foo()
+$env?.[Bar]?.[ok]?.i
+$env?.[Bar]?.[ok]?.ok
+$env?.[Bar]?.[str]
+$env?.[Bar]?.[str].ok
+$env?.[Bar]?.[str]?.[array]
+$env?.[Bar]?.[str]?.ok()
+$env?.[Bar]?.abs(nil, ok)?.[ok]
+$env?.[Bar]?.add
+$env?.[Bar]?.add()
+$env?.[Bar]?.add().str
+$env?.[Bar]?.add()?.[f64]
+$env?.[Bar]?.add(1)
+$env?.[Bar]?.add(Bar)
+$env?.[Bar]?.add(add)
+$env?.[Bar]?.add(array)
+$env?.[Bar]?.add(foo)
+$env?.[Bar]?.add(foobar)
+$env?.[Bar]?.add.String()
+$env?.[Bar]?.add.add
+$env?.[Bar]?.add.greet
+$env?.[Bar]?.add.i
+$env?.[Bar]?.add.not
+$env?.[Bar]?.add.ok
+$env?.[Bar]?.add.str
+$env?.[Bar]?.add?.Bar()
+$env?.[Bar]?.add?.[add]
+$env?.[Bar]?.add?.[foo]
+$env?.[Bar]?.add?.[ok]
+$env?.[Bar]?.add?.join(foobar, str)
+$env?.[Bar]?.any(foo)
+$env?.[Bar]?.any(foobar, foobar)
+$env?.[Bar]?.array
+$env?.[Bar]?.array()
+$env?.[Bar]?.array().ok
+$env?.[Bar]?.array()?.list
+$env?.[Bar]?.array(Bar, array)
+$env?.[Bar]?.array(add) == greet
+$env?.[Bar]?.array(foobar)
+$env?.[Bar]?.array(foobar, f64, i)
+$env?.[Bar]?.array(foobar?.ok)
+$env?.[Bar]?.array(sort(foobar))
+$env?.[Bar]?.array.String()
+$env?.[Bar]?.array.add
+$env?.[Bar]?.array.list()
+$env?.[Bar]?.array?.[add]
+$env?.[Bar]?.array?.[array]
+$env?.[Bar]?.array?.[list]
+$env?.[Bar]?.bitxor(ok)
+$env?.[Bar]?.concat(i, 0)
+$env?.[Bar]?.f64
+$env?.[Bar]?.f64()
+$env?.[Bar]?.f64()?.ok
+$env?.[Bar]?.f64(add)
+$env?.[Bar]?.f64(foobar in foobar)?.[add]
+$env?.[Bar]?.f64.String
+$env?.[Bar]?.f64.foo
+$env?.[Bar]?.f64.foo()
+$env?.[Bar]?.f64.greet
+$env?.[Bar]?.f64.i
+$env?.[Bar]?.f64.i()
+$env?.[Bar]?.f64?.[add]
+$env?.[Bar]?.f64?.[greet]
+$env?.[Bar]?.f64?.list()
+$env?.[Bar]?.false.foo
+$env?.[Bar]?.find(Bar)
+$env?.[Bar]?.findLast(1)
+$env?.[Bar]?.findLast(1, i)
+$env?.[Bar]?.findLastIndex(nil)
+$env?.[Bar]?.foo
+$env?.[Bar]?.foo($env)
+$env?.[Bar]?.foo()
+$env?.[Bar]?.foo().list
+$env?.[Bar]?.foo(foobar)
+$env?.[Bar]?.foo(foobar, foobar)
+$env?.[Bar]?.foo(foobar?.true startsWith foobar contains foobar)
+$env?.[Bar]?.foo.i
+$env?.[Bar]?.foo.ok()
+$env?.[Bar]?.foo.str
+$env?.[Bar]?.foo?.Bar
+$env?.[Bar]?.foo?.String
+$env?.[Bar]?.foo?.[greet].list()
+$env?.[Bar]?.foo?.[list]
+$env?.[Bar]?.foo?.f64
+$env?.[Bar]?.foo?.foo()
+$env?.[Bar]?.foo?.ok
+$env?.[Bar]?.foobar
+$env?.[Bar]?.foobar not endsWith str
+$env?.[Bar]?.foobar.String
+$env?.[Bar]?.foobar.array
+$env?.[Bar]?.foobar.list(nil)
+$env?.[Bar]?.foobar.str
+$env?.[Bar]?.foobar?.[f64]
+$env?.[Bar]?.foobar?.[i]
+$env?.[Bar]?.foobar?.ok
+$env?.[Bar]?.fromPairs(foobar, foo)
+$env?.[Bar]?.greet
+$env?.[Bar]?.greet == ok
+$env?.[Bar]?.greet($env endsWith foobar)
+$env?.[Bar]?.greet()
+$env?.[Bar]?.greet().add
+$env?.[Bar]?.greet()?.[i]
+$env?.[Bar]?.greet()?.f64
+$env?.[Bar]?.greet(0)
+$env?.[Bar]?.greet(foo)
+$env?.[Bar]?.greet(foobar)
+$env?.[Bar]?.greet(foobar)?.String
+$env?.[Bar]?.greet(list)
+$env?.[Bar]?.greet(str)
+$env?.[Bar]?.greet.f64
+$env?.[Bar]?.greet.f64(foobar)
+$env?.[Bar]?.greet?.[add]
+$env?.[Bar]?.greet?.[i]
+$env?.[Bar]?.greet?.[list]
+$env?.[Bar]?.greet?.f64
+$env?.[Bar]?.greet?.ok
+$env?.[Bar]?.i
+$env?.[Bar]?.i($env not matches foobar, Bar)?.foo
+$env?.[Bar]?.i($env)
+$env?.[Bar]?.i()
+$env?.[Bar]?.i(foobar)
+$env?.[Bar]?.i(foobar, str | reduce($env, f64))
+$env?.[Bar]?.i(greet, foobar)
+$env?.[Bar]?.i(list, foobar)
+$env?.[Bar]?.i.str
+$env?.[Bar]?.i?.[foo]
+$env?.[Bar]?.i?.[greet]
+$env?.[Bar]?.i?.array
+$env?.[Bar]?.i?.greet
+$env?.[Bar]?.i?.i
+$env?.[Bar]?.i?.str
+$env?.[Bar]?.keys(Bar, false)
+$env?.[Bar]?.list
+$env?.[Bar]?.list()
+$env?.[Bar]?.list()?.[ok]
+$env?.[Bar]?.list()?.str
+$env?.[Bar]?.list(foo.String)
+$env?.[Bar]?.list(foobar)
+$env?.[Bar]?.list(foobar).f64
+$env?.[Bar]?.list(foobar)?.[str]
+$env?.[Bar]?.list(foobar?.list)
+$env?.[Bar]?.list.Bar
+$env?.[Bar]?.list.add
+$env?.[Bar]?.list.f64
+$env?.[Bar]?.list.foobar
+$env?.[Bar]?.list?.Bar(foo, f64)
+$env?.[Bar]?.list?.[greet]
+$env?.[Bar]?.list?.[list]
+$env?.[Bar]?.list?.foo
+$env?.[Bar]?.list?.str
+$env?.[Bar]?.lower(nil)
+$env?.[Bar]?.map(nil)
+$env?.[Bar]?.nil?.i?.f64
+$env?.[Bar]?.none(list)
+$env?.[Bar]?.none(ok)
+$env?.[Bar]?.not.ok
+$env?.[Bar]?.now(foobar, foobar, $env)
+$env?.[Bar]?.ok
+$env?.[Bar]?.ok()
+$env?.[Bar]?.ok().list
+$env?.[Bar]?.ok()?.add
+$env?.[Bar]?.ok(add)
+$env?.[Bar]?.ok.String
+$env?.[Bar]?.ok.list
+$env?.[Bar]?.ok?.[greet]
+$env?.[Bar]?.ok?.foo
+$env?.[Bar]?.reduce(1.0)
+$env?.[Bar]?.str
+$env?.[Bar]?.str($env == foobar)
+$env?.[Bar]?.str($env)
+$env?.[Bar]?.str()
+$env?.[Bar]?.str().add.i
+$env?.[Bar]?.str()?.[list]
+$env?.[Bar]?.str(f64)
+$env?.[Bar]?.str(f64, array)
+$env?.[Bar]?.str(list | first(true, foobar))
+$env?.[Bar]?.str(nil)
+$env?.[Bar]?.str.Bar
+$env?.[Bar]?.str.foo
+$env?.[Bar]?.str.ok
+$env?.[Bar]?.str?.[add]
+$env?.[Bar]?.str?.[array]
+$env?.[Bar]?.str?.[list]
+$env?.[Bar]?.str?.[str]
+$env?.[Bar]?.sum(foobar)
+$env?.[Bar]?.true?.[ok]
+$env?.[Bar]?.values(foobar, foobar)
+$env?.[String] != 1 ? f64 : f64
+$env?.[String] != add
+$env?.[String] != array
+$env?.[String] != f64
+$env?.[String] != foo
+$env?.[String] != foo ? foo : 0
+$env?.[String] != i
+$env?.[String] != list
+$env?.[String] != ok
+$env?.[String] != str
+$env?.[String] == $env.i
+$env?.[String] == add
+$env?.[String] == greet
+$env?.[String] == i && $env
+$env?.[String] == list
+$env?.[String] == str
+$env?.[String] contains str
+$env?.[String] endsWith $env?.[str]
+$env?.[String] in list
+$env?.[String] matches str
+$env?.[String] not contains str
+$env?.[String] not in array
+$env?.[String] not in list
+$env?.[String] not matches str
+$env?.[String] not startsWith str
+$env?.[String] startsWith min($env)
+$env?.[String] startsWith str
+$env?.[String]?.$env.list
+$env?.[String]?.$env?.[foo]
+$env?.[String]?.$env?.[ok]
+$env?.[String]?.$env?.array
+$env?.[String]?.Bar
+$env?.[String]?.Bar()
+$env?.[String]?.Bar().foo
+$env?.[String]?.Bar(f64)
+$env?.[String]?.Bar(foobar)
+$env?.[String]?.Bar.String
+$env?.[String]?.Bar.greet
+$env?.[String]?.Bar.str
+$env?.[String]?.Bar?.Bar()
+$env?.[String]?.Bar?.[foo]
+$env?.[String]?.Bar?.[greet]
+$env?.[String]?.Bar?.[str]
+$env?.[String]?.Bar?.add
+$env?.[String]?.Bar?.i
+$env?.[String]?.Bar?.list()
+$env?.[String]?.String
+$env?.[String]?.String()
+$env?.[String]?.String().list
+$env?.[String]?.String(String)
+$env?.[String]?.String(add)
+$env?.[String]?.String(foobar, $env)
+$env?.[String]?.String(foobar?.[list])?.str()
+$env?.[String]?.String(greet)
+$env?.[String]?.String(ok && foobar)
+$env?.[String]?.String.split(false, add).str.array
+$env?.[String]?.String?.Bar
+$env?.[String]?.String?.[foo]
+$env?.[String]?.String?.[greet]
+$env?.[String]?.String?.[list]
+$env?.[String]?.String?.array
+$env?.[String]?.String?.foo?.foo
+$env?.[String]?.String?.list
+$env?.[String]?.[$env == true]
+$env?.[String]?.[$env.foo]
+$env?.[String]?.[$env?.[greet]]
+$env?.[String]?.[$env?.array]
+$env?.[String]?.[add]
+$env?.[String]?.[add].str
+$env?.[String]?.[add]?.[list]
+$env?.[String]?.[add]?.add
+$env?.[String]?.[add]?.greet
+$env?.[String]?.[array]
+$env?.[String]?.[array] == list
+$env?.[String]?.[array].Bar
+$env?.[String]?.[array].ok
+$env?.[String]?.[array]?.Bar()
+$env?.[String]?.[array]?.[ok]
+$env?.[String]?.[array]?.add
+$env?.[String]?.[array]?.f64
+$env?.[String]?.[array]?.list?.[add]
+$env?.[String]?.[f64]
+$env?.[String]?.[f64].list
+$env?.[String]?.[f64].list()
+$env?.[String]?.[f64]?.Bar
+$env?.[String]?.[f64]?.Bar()
+$env?.[String]?.[f64]?.[f64]
+$env?.[String]?.[f64]?.array()
+$env?.[String]?.[f64]?.greet
+$env?.[String]?.[f64]?.ok
+$env?.[String]?.[foo != nil]
+$env?.[String]?.[foo]
+$env?.[String]?.[foo].String
+$env?.[String]?.[foo].f64
+$env?.[String]?.[foo].i
+$env?.[String]?.[foo]?.String
+$env?.[String]?.[foo]?.[ok]
+$env?.[String]?.[foo]?.[ok]?.[f64]
+$env?.[String]?.[foo]?.add
+$env?.[String]?.[foo]?.f64()
+$env?.[String]?.[greet]
+$env?.[String]?.[greet].String
+$env?.[String]?.[greet].str
+$env?.[String]?.[greet]?.[ok]
+$env?.[String]?.[greet]?.i
+$env?.[String]?.[greet]?.list(foobar)
+$env?.[String]?.[greet]?.str
+$env?.[String]?.[i]
+$env?.[String]?.[i].Bar
+$env?.[String]?.[i].f64
+$env?.[String]?.[i].foo
+$env?.[String]?.[i].list
+$env?.[String]?.[i].ok
+$env?.[String]?.[i]?.array
+$env?.[String]?.[list]
+$env?.[String]?.[list].array()
+$env?.[String]?.[list].greet
+$env?.[String]?.[list].ok
+$env?.[String]?.[list]?.String()
+$env?.[String]?.[list]?.[add]
+$env?.[String]?.[list]?.greet
+$env?.[String]?.[ok and ok]
+$env?.[String]?.[ok not in $env]
+$env?.[String]?.[ok]
+$env?.[String]?.[ok].add
+$env?.[String]?.[ok].ok
+$env?.[String]?.[ok]?.Bar
+$env?.[String]?.[ok]?.[f64]
+$env?.[String]?.[ok]?.greet
+$env?.[String]?.[ok]?.i
+$env?.[String]?.[str]
+$env?.[String]?.[str].f64
+$env?.[String]?.[str]?.[f64]
+$env?.[String]?.[str]?.foo
+$env?.[String]?.add
+$env?.[String]?.add()
+$env?.[String]?.add()?.[foo]
+$env?.[String]?.add()?.f64()
+$env?.[String]?.add(1)
+$env?.[String]?.add(foobar)
+$env?.[String]?.add.Bar
+$env?.[String]?.add.String
+$env?.[String]?.add?.[add]
+$env?.[String]?.add?.[greet]
+$env?.[String]?.add?.greet
+$env?.[String]?.add?.greet()
+$env?.[String]?.all(ok)
+$env?.[String]?.any(foobar, ok)
+$env?.[String]?.array
+$env?.[String]?.array()
+$env?.[String]?.array()?.f64(list)
+$env?.[String]?.array(String)
+$env?.[String]?.array(add)
+$env?.[String]?.array(f64)
+$env?.[String]?.array(foobar not startsWith foo)
+$env?.[String]?.array(foobar)
+$env?.[String]?.array(i)
+$env?.[String]?.array(str)
+$env?.[String]?.array.String
+$env?.[String]?.array.array(String, foo)
+$env?.[String]?.array.i
+$env?.[String]?.array.i()
+$env?.[String]?.array.ok
+$env?.[String]?.array?.Bar
+$env?.[String]?.array?.[greet]
+$env?.[String]?.array?.f64
+$env?.[String]?.array?.foo
+$env?.[String]?.array?.list(i)
+$env?.[String]?.bitshl(foobar)
+$env?.[String]?.bitushr(foobar)
+$env?.[String]?.ceil(nil)
+$env?.[String]?.f64
+$env?.[String]?.f64()
+$env?.[String]?.f64().Bar
+$env?.[String]?.f64()?.f64
+$env?.[String]?.f64(String?.[array])
+$env?.[String]?.f64(foobar)
+$env?.[String]?.f64.Bar()
+$env?.[String]?.f64.i
+$env?.[String]?.f64.ok
+$env?.[String]?.f64?.String
+$env?.[String]?.f64?.[add]
+$env?.[String]?.f64?.[ok]?.str
+$env?.[String]?.f64?.foo()
+$env?.[String]?.f64?.greet()
+$env?.[String]?.f64?.i
+$env?.[String]?.f64?.ok()
+$env?.[String]?.false?.str
+$env?.[String]?.find(foobar)
+$env?.[String]?.foo
+$env?.[String]?.foo()
+$env?.[String]?.foo()?.str
+$env?.[String]?.foo(f64, foobar)
+$env?.[String]?.foo(foobar)
+$env?.[String]?.foo.String
+$env?.[String]?.foo.foo
+$env?.[String]?.foo.greet
+$env?.[String]?.foo.ok
+$env?.[String]?.foo.str
+$env?.[String]?.foo?.Bar
+$env?.[String]?.foo?.String
+$env?.[String]?.foo?.[add]
+$env?.[String]?.foo?.[array]
+$env?.[String]?.foo?.[f64]
+$env?.[String]?.foo?.[foo]
+$env?.[String]?.foo?.array
+$env?.[String]?.foo?.i
+$env?.[String]?.foo?.list
+$env?.[String]?.foo?.str
+$env?.[String]?.foo?.str()
+$env?.[String]?.foobar
+$env?.[String]?.foobar.f64
+$env?.[String]?.foobar.str()
+$env?.[String]?.foobar?.[list]
+$env?.[String]?.foobar?.[ok]
+$env?.[String]?.foobar?.array
+$env?.[String]?.foobar?.foo
+$env?.[String]?.foobar?.i
+$env?.[String]?.foobar?.i()
+$env?.[String]?.fromJSON(foobar)
+$env?.[String]?.fromPairs(false)
+$env?.[String]?.get(str)
+$env?.[String]?.greet
+$env?.[String]?.greet != str
+$env?.[String]?.greet()
+$env?.[String]?.greet().Bar
+$env?.[String]?.greet()?.[list]
+$env?.[String]?.greet()?.[str]
+$env?.[String]?.greet(add)
+$env?.[String]?.greet(foobar)
+$env?.[String]?.greet(greet)
+$env?.[String]?.greet.add
+$env?.[String]?.greet.array()
+$env?.[String]?.greet.foo
+$env?.[String]?.greet.i
+$env?.[String]?.greet.list
+$env?.[String]?.greet?.Bar
+$env?.[String]?.greet?.[array]
+$env?.[String]?.greet?.[str]
+$env?.[String]?.greet?.list.str
+$env?.[String]?.groupBy(1.0)
+$env?.[String]?.groupBy(foobar)
+$env?.[String]?.groupBy(str)
+$env?.[String]?.hasPrefix(nil)?.String
+$env?.[String]?.i
+$env?.[String]?.i()
+$env?.[String]?.i()?.[array]
+$env?.[String]?.i()?.[greet]
+$env?.[String]?.i(foo)
+$env?.[String]?.i(foobar)
+$env?.[String]?.i(ok)
+$env?.[String]?.i(str)
+$env?.[String]?.i(true)
+$env?.[String]?.i.String
+$env?.[String]?.i.greet
+$env?.[String]?.i.list
+$env?.[String]?.i?.[greet]
+$env?.[String]?.i?.[ok]
+$env?.[String]?.i?.foo
+$env?.[String]?.i?.foo()
+$env?.[String]?.i?.greet
+$env?.[String]?.i?.list
+$env?.[String]?.i?.ok.f64
+$env?.[String]?.int(foo)
+$env?.[String]?.len(false)
+$env?.[String]?.list
+$env?.[String]?.list()
+$env?.[String]?.list(1.0)
+$env?.[String]?.list(Bar)
+$env?.[String]?.list(foobar)
+$env?.[String]?.list(foobar).greet
+$env?.[String]?.list(greet)
+$env?.[String]?.list(nil in foobar or foobar)
+$env?.[String]?.list(ok)
+$env?.[String]?.list(true, true)
+$env?.[String]?.list.add()
+$env?.[String]?.list.foo
+$env?.[String]?.list.list
+$env?.[String]?.list?.[ok]
+$env?.[String]?.list?.add?.list
+$env?.[String]?.list?.array
+$env?.[String]?.list?.foobar
+$env?.[String]?.list?.i
+$env?.[String]?.nil.String
+$env?.[String]?.not
+$env?.[String]?.ok
+$env?.[String]?.ok()
+$env?.[String]?.ok()?.list
+$env?.[String]?.ok(f64, foobar)
+$env?.[String]?.ok(foobar?.[1.0])
+$env?.[String]?.ok(toJSON(foo)).f64
+$env?.[String]?.ok.add
+$env?.[String]?.ok.foo
+$env?.[String]?.ok.i
+$env?.[String]?.ok.str
+$env?.[String]?.ok?.[f64]
+$env?.[String]?.ok?.[foo]
+$env?.[String]?.ok?.[list]
+$env?.[String]?.ok?.[ok]
+$env?.[String]?.ok?.add
+$env?.[String]?.ok?.f64
+$env?.[String]?.ok?.ok
+$env?.[String]?.one($env)
+$env?.[String]?.one(foobar)?.[f64]
+$env?.[String]?.reduce(1.0)
+$env?.[String]?.reduce(foobar)
+$env?.[String]?.splitAfter(true)
+$env?.[String]?.str
+$env?.[String]?.str not startsWith str
+$env?.[String]?.str()
+$env?.[String]?.str().list
+$env?.[String]?.str()?.array
+$env?.[String]?.str(foo)
+$env?.[String]?.str(foobar)
+$env?.[String]?.str(foobar?.array)
+$env?.[String]?.str.add
+$env?.[String]?.str.array
+$env?.[String]?.str?.Bar
+$env?.[String]?.str?.String
+$env?.[String]?.str?.[add]
+$env?.[String]?.str?.add
+$env?.[String]?.str?.f64()
+$env?.[String]?.str?.f64(false)?.greet
+$env?.[String]?.sum(add)
+$env?.[String]?.take(String)?.str
+$env?.[String]?.trimPrefix(add)
+$env?.[String]?.true not in array
+$env?.[add] != 1.0 && false
+$env?.[add] * f64 && false
+$env?.[foo] != 1.0 || true
+$env?.[foobar] != $env.i
+$env?.[foobar] != foo
+$env?.[foobar] != greet
+$env?.[foobar] != i
+$env?.[foobar] != list
+$env?.[foobar] == array
+$env?.[foobar] == f64
+$env?.[foobar] == foo
+$env?.[foobar] == list != $env
+$env?.[foobar] == ok
+$env?.[foobar] contains str
+$env?.[foobar] in $env?.[String]
+$env?.[foobar] in list
+$env?.[foobar] not in array
+$env?.[foobar] not in list
+$env?.[foobar] not matches str
+$env?.[foobar] not startsWith foo?.String()
+$env?.[foobar] not startsWith trim(str)
+$env?.[foobar] startsWith $env or $env
+$env?.[foobar]?.$env == nil
+$env?.[foobar]?.Bar
+$env?.[foobar]?.Bar()
+$env?.[foobar]?.Bar()?.foobar
+$env?.[foobar]?.Bar(foobar)
+$env?.[foobar]?.Bar(list)
+$env?.[foobar]?.Bar.foo()
+$env?.[foobar]?.Bar.str(foobar)
+$env?.[foobar]?.Bar?.[str]
+$env?.[foobar]?.Bar?.f64
+$env?.[foobar]?.Bar?.foo
+$env?.[foobar]?.String
+$env?.[foobar]?.String()
+$env?.[foobar]?.String(Bar)
+$env?.[foobar]?.String(add).String
+$env?.[foobar]?.String.ok
+$env?.[foobar]?.String?.[i]
+$env?.[foobar]?.String?.[str]?.[f64]?.ok
+$env?.[foobar]?.String?.array
+$env?.[foobar]?.String?.i
+$env?.[foobar]?.[add]
+$env?.[foobar]?.[add].f64
+$env?.[foobar]?.[add].greet
+$env?.[foobar]?.[add]?.[foo]
+$env?.[foobar]?.[add]?.[greet]
+$env?.[foobar]?.[array]
+$env?.[foobar]?.[array]?.Bar
+$env?.[foobar]?.[array]?.f64
+$env?.[foobar]?.[array]?.list()?.[add]
+$env?.[foobar]?.[f64]
+$env?.[foobar]?.[f64].f64
+$env?.[foobar]?.[f64].f64()
+$env?.[foobar]?.[f64].greet
+$env?.[foobar]?.[f64].ok()
+$env?.[foobar]?.[foo]
+$env?.[foobar]?.[foo].Bar
+$env?.[foobar]?.[foo].String()
+$env?.[foobar]?.[foo]?.[str]
+$env?.[foobar]?.[foo]?.i
+$env?.[foobar]?.[greet]
+$env?.[foobar]?.[greet].array.array
+$env?.[foobar]?.[greet].f64
+$env?.[foobar]?.[greet]?.[i].array
+$env?.[foobar]?.[greet]?.[ok]
+$env?.[foobar]?.[greet]?.str
+$env?.[foobar]?.[i]
+$env?.[foobar]?.[i].Bar
+$env?.[foobar]?.[i].greet
+$env?.[foobar]?.[i].str
+$env?.[foobar]?.[i]?.[list]
+$env?.[foobar]?.[i]?.[ok]
+$env?.[foobar]?.[i]?.ok
+$env?.[foobar]?.[list]
+$env?.[foobar]?.[list].foo
+$env?.[foobar]?.[list]?.[f64]
+$env?.[foobar]?.[list]?.[str]
+$env?.[foobar]?.[list]?.f64()
+$env?.[foobar]?.[list]?.ok
+$env?.[foobar]?.[ok]
+$env?.[foobar]?.[ok].Bar
+$env?.[foobar]?.[ok]?.[add]
+$env?.[foobar]?.[ok]?.[f64]
+$env?.[foobar]?.[ok]?.ok
+$env?.[foobar]?.[sortBy($env, f64)]
+$env?.[foobar]?.[str]
+$env?.[foobar]?.[str].i
+$env?.[foobar]?.[str]?.[f64]
+$env?.[foobar]?.add
+$env?.[foobar]?.add()
+$env?.[foobar]?.add()?.[array]
+$env?.[foobar]?.add(foobar)
+$env?.[foobar]?.add?.greet
+$env?.[foobar]?.add?.i
+$env?.[foobar]?.all(foobar, greet, $env)
+$env?.[foobar]?.any(1, foobar)
+$env?.[foobar]?.any(f64, nil)
+$env?.[foobar]?.any(i).f64
+$env?.[foobar]?.array
+$env?.[foobar]?.array()
+$env?.[foobar]?.array.f64
+$env?.[foobar]?.array?.[i]
+$env?.[foobar]?.array?.add()
+$env?.[foobar]?.array?.i
+$env?.[foobar]?.f64
+$env?.[foobar]?.f64()
+$env?.[foobar]?.f64()?.[ok]
+$env?.[foobar]?.f64()?.array
+$env?.[foobar]?.f64(String)
+$env?.[foobar]?.f64.ok
+$env?.[foobar]?.f64?.Bar
+$env?.[foobar]?.f64?.ok
+$env?.[foobar]?.filter(foo)
+$env?.[foobar]?.foo
+$env?.[foobar]?.foo()
+$env?.[foobar]?.foo()?.array
+$env?.[foobar]?.foo()?.f64
+$env?.[foobar]?.foo(foobar)
+$env?.[foobar]?.foo(foobar, foobar)
+$env?.[foobar]?.foo.foobar
+$env?.[foobar]?.foo?.[array]
+$env?.[foobar]?.foo?.[foo]
+$env?.[foobar]?.foo?.[i]
+$env?.[foobar]?.foo?.foo
+$env?.[foobar]?.foo?.foo?.array
+$env?.[foobar]?.foobar
+$env?.[foobar]?.foobar.str
+$env?.[foobar]?.greet
+$env?.[foobar]?.greet()
+$env?.[foobar]?.greet()?.String
+$env?.[foobar]?.greet(Bar)
+$env?.[foobar]?.greet(String)
+$env?.[foobar]?.greet(foobar, foo)
+$env?.[foobar]?.greet(greet)
+$env?.[foobar]?.greet.foo
+$env?.[foobar]?.greet.i
+$env?.[foobar]?.i
+$env?.[foobar]?.i()
+$env?.[foobar]?.i()?.greet
+$env?.[foobar]?.i(Bar)
+$env?.[foobar]?.i(foo)
+$env?.[foobar]?.i(foobar)
+$env?.[foobar]?.i.array
+$env?.[foobar]?.i.foo
+$env?.[foobar]?.i?.[array]
+$env?.[foobar]?.i?.[greet]
+$env?.[foobar]?.i?.f64
+$env?.[foobar]?.lastIndexOf(nil, foobar)
+$env?.[foobar]?.list
+$env?.[foobar]?.list()
+$env?.[foobar]?.list(f64)
+$env?.[foobar]?.list(foobar)
+$env?.[foobar]?.list.list
+$env?.[foobar]?.list?.[array]
+$env?.[foobar]?.list?.[i]
+$env?.[foobar]?.list?.[list]
+$env?.[foobar]?.max(foo)
+$env?.[foobar]?.nil?.[foo]
+$env?.[foobar]?.none(foobar)
+$env?.[foobar]?.none(nil, foobar)
+$env?.[foobar]?.now(1)
+$env?.[foobar]?.ok
+$env?.[foobar]?.ok()
+$env?.[foobar]?.ok(Bar?.[greet])?.greet
+$env?.[foobar]?.ok(list)
+$env?.[foobar]?.ok.add()
+$env?.[foobar]?.ok.i
+$env?.[foobar]?.ok?.i
+$env?.[foobar]?.str
+$env?.[foobar]?.str($env)
+$env?.[foobar]?.str()
+$env?.[foobar]?.str()?.str
+$env?.[foobar]?.str(foobar)
+$env?.[foobar]?.str(foobar?.greet(nil))
+$env?.[foobar]?.str.ok
+$env?.[foobar]?.str?.[list]
+$env?.[foobar]?.str?.foo
+$env?.[foobar]?.str?.i()
+$env?.[foobar]?.str?.list
+$env?.[foobar]?.sum($env)
+$env?.[foobar]?.trimSuffix(f64, foobar)
+$env?.[greet]?.foobar or true
+$env?.[i].i and false
+$env?.[list] contains str && false
+$env?.[list] || false or true
+$env?.[nil] == array?.[0]
+$env?.[nil] == ok
+$env?.[nil] == str
+$env?.[nil]?.Bar
+$env?.[nil]?.Bar()
+$env?.[nil]?.Bar?.[add]
+$env?.[nil]?.String
+$env?.[nil]?.String()
+$env?.[nil]?.[add]
+$env?.[nil]?.[add]?.[add]
+$env?.[nil]?.[array]
+$env?.[nil]?.[array].count(i)
+$env?.[nil]?.[array]?.f64()
+$env?.[nil]?.[f64]
+$env?.[nil]?.[f64].list
+$env?.[nil]?.[f64]?.Bar
+$env?.[nil]?.[foo]
+$env?.[nil]?.[foo]?.i()
+$env?.[nil]?.[greet]
+$env?.[nil]?.[greet]?.array()
+$env?.[nil]?.[i]
+$env?.[nil]?.[list]
+$env?.[nil]?.[ok]
+$env?.[nil]?.[str]
+$env?.[nil]?.[str]?.[array]
+$env?.[nil]?.add
+$env?.[nil]?.add()
+$env?.[nil]?.array
+$env?.[nil]?.array(add)
+$env?.[nil]?.array(list)
+$env?.[nil]?.f64
+$env?.[nil]?.f64.add
+$env?.[nil]?.f64.f64
+$env?.[nil]?.f64.i
+$env?.[nil]?.foo
+$env?.[nil]?.foo()
+$env?.[nil]?.foo?.String
+$env?.[nil]?.foobar.String()
+$env?.[nil]?.greet
+$env?.[nil]?.greet()
+$env?.[nil]?.greet(foobar)
+$env?.[nil]?.greet.f64
+$env?.[nil]?.i
+$env?.[nil]?.i()
+$env?.[nil]?.i(true or $env >= ok)
+$env?.[nil]?.i?.f64
+$env?.[nil]?.list
+$env?.[nil]?.list($env?.foo)
+$env?.[nil]?.list?.array
+$env?.[nil]?.list?.i
+$env?.[nil]?.ok
+$env?.[nil]?.ok()
+$env?.[nil]?.ok?.[str]
+$env?.[nil]?.str
+$env?.[nil]?.str()
+$env?.[nil]?.str(String)
+$env?.[nil]?.str(foobar)
+$env?.[str] != add
+$env?.[str] != f64
+$env?.[str] != greet
+$env?.[str] != i
+$env?.[str] != ok
+$env?.[str] != str
+$env?.[str] + str
+$env?.[str] < str
+$env?.[str] <= str
+$env?.[str] == 1.0 == $env
+$env?.[str] == array
+$env?.[str] == foo
+$env?.[str] == greet
+$env?.[str] == i
+$env?.[str] == ok
+$env?.[str] == str
+$env?.[str] > str
+$env?.[str] >= str
+$env?.[str] contains str
+$env?.[str] endsWith $env?.str
+$env?.[str] endsWith str
+$env?.[str] in list
+$env?.[str] matches str
+$env?.[str] not endsWith str
+$env?.[str] not in $env == ok
+$env?.[str] not in $env.list
+$env?.[str] not in $env?.[Bar]
+$env?.[str] not in $env?.array
+$env?.[str] not in array
+$env?.[str] not matches foo?.String()
+$env?.[str] not matches str
+$env?.[str] not startsWith str
+$env?.[str] startsWith $env?.[String]
+$env?.[str] startsWith foo?.Bar
+$env?.[str] startsWith str
+$env?.[str] | all(false)
+$env?.[str] | all(ok)
+$env?.[str] | all(true)
+$env?.[str] | any(any(list, true))
+$env?.[str] | any(true)
+$env?.[str] | count(false)
+$env?.[str] | count(i != 0)
+$env?.[str] | count(ok)
+$env?.[str] | filter(false)
+$env?.[str] | find(0 >= #)
+$env?.[str] | find(false)
+$env?.[str] | find(ok)
+$env?.[str] | find(true)
+$env?.[str] | findIndex(1 != 0)
+$env?.[str] | findIndex(add != #)
+$env?.[str] | findIndex(false)
+$env?.[str] | findIndex(ok)
+$env?.[str] | findIndex(true)
+$env?.[str] | findLast(false)
+$env?.[str] | findLast(ok)
+$env?.[str] | findLastIndex(false)
+$env?.[str] | findLastIndex(true)
+$env?.[str] | greet()
+$env?.[str] | groupBy(#)
+$env?.[str] | groupBy(0)
+$env?.[str] | groupBy(1.0)
+$env?.[str] | groupBy(f64)
+$env?.[str] | groupBy(false)
+$env?.[str] | groupBy(foo)
+$env?.[str] | groupBy(i)
+$env?.[str] | groupBy(ok)
+$env?.[str] | groupBy(str)
+$env?.[str] | groupBy(true)
+$env?.[str] | hasPrefix(str)
+$env?.[str] | indexOf(str)
+$env?.[str] | map(#)
+$env?.[str] | map(1)
+$env?.[str] | map(1.0)
+$env?.[str] | map(add)
+$env?.[str] | map(foo)
+$env?.[str] | map(greet)
+$env?.[str] | map(i)
+$env?.[str] | map(str)
+$env?.[str] | map(true)
+$env?.[str] | none(false)
+$env?.[str] | none(ok)
+$env?.[str] | none(true)
+$env?.[str] | one(false)
+$env?.[str] | one(true)
+$env?.[str] | reduce(#)
+$env?.[str] | reduce(#, array)
+$env?.[str] | reduce(#, false)
+$env?.[str] | reduce(#, ok)
+$env?.[str] | reduce($env)
+$env?.[str] | reduce(0)
+$env?.[str] | reduce(0, nil)
+$env?.[str] | reduce(1, 1.0)
+$env?.[str] | reduce(1.0)
+$env?.[str] | reduce(1.0, $env)
+$env?.[str] | reduce(1.0, nil)
+$env?.[str] | reduce(add)
+$env?.[str] | reduce(add, nil)
+$env?.[str] | reduce(array)
+$env?.[str] | reduce(f64)
+$env?.[str] | reduce(false)
+$env?.[str] | reduce(false, greet)
+$env?.[str] | reduce(foo)
+$env?.[str] | reduce(foo, true)
+$env?.[str] | reduce(greet)
+$env?.[str] | reduce(greet, foo)
+$env?.[str] | reduce(i)
+$env?.[str] | reduce(ok)
+$env?.[str] | reduce(ok, $env)
+$env?.[str] | reduce(str)
+$env?.[str] | reduce(true)
+$env?.[str] | reduce(true, f64)
+$env?.[str] | repeat(1)
+$env?.[str] | sortBy(#)
+$env?.[str] | sortBy(0)
+$env?.[str] | sortBy(1)
+$env?.[str] | sortBy(1.0)
+$env?.[str] | sortBy(f64)
+$env?.[str] | sortBy(i)
+$env?.[str] | sortBy(str)
+$env?.[str] | sum(#)
+$env?.[str] | sum(1)
+$env?.[str] | sum(1.0)
+$env?.[str] | sum(f64)
+$env?.[str] | sum(i)
+$env?.[str] | trimSuffix(str)
+$env?.[str]?.[f64]
+$env?.[str]?.[f64] * f64
+$env?.[str]?.[i]
+$env?.[str][:]
+$env?.[str][:i]
+$env?.[str][array?.[f64]:]
+$env?.[str][f64:]
+$env?.add == add
+$env?.array != array
+$env?.array != array || $env
+$env?.array != list
+$env?.array == array
+$env?.array == list
+$env?.array | all(false)
+$env?.array | all(ok)
+$env?.array | all(true)
+$env?.array | any(# == 0)
+$env?.array | any(ok)
+$env?.array | count(ok)
+$env?.array | count(true)
+$env?.array | filter(false)
+$env?.array | filter(true)
+$env?.array | find(false)
+$env?.array | find(ok)
+$env?.array | find(true)
+$env?.array | findIndex(ok)
+$env?.array | findIndex(true)
+$env?.array | findLast(false)
+$env?.array | findLast(ok)
+$env?.array | findLast(true)
+$env?.array | findLastIndex(false)
+$env?.array | findLastIndex(true)
+$env?.array | get(1)
+$env?.array | groupBy(#)
+$env?.array | groupBy(0)
+$env?.array | groupBy(1)
+$env?.array | groupBy(1.0)
+$env?.array | groupBy(false)
+$env?.array | groupBy(foo)
+$env?.array | groupBy(ok)
+$env?.array | groupBy(str)
+$env?.array | groupBy(true)
+$env?.array | map(#)
+$env?.array | map($env)
+$env?.array | map(0)
+$env?.array | map(1.0)
+$env?.array | map(add)
+$env?.array | map(array)
+$env?.array | map(f64)
+$env?.array | map(foo)
+$env?.array | map(ok)
+$env?.array | map(true)
+$env?.array | mean(1.0)
+$env?.array | none(ok)
+$env?.array | none(true)
+$env?.array | one(false)
+$env?.array | one(ok)
+$env?.array | one(true)
+$env?.array | reduce(#)
+$env?.array | reduce(#, $env)
+$env?.array | reduce(#, 1)
+$env?.array | reduce(#, foo)
+$env?.array | reduce(#, true)
+$env?.array | reduce(#acc)
+$env?.array | reduce($env)
+$env?.array | reduce($env, add)
+$env?.array | reduce($env, nil)
+$env?.array | reduce(0, foo)
+$env?.array | reduce(1)
+$env?.array | reduce(1, 1)
+$env?.array | reduce(1, list)
+$env?.array | reduce(1.0)
+$env?.array | reduce(add)
+$env?.array | reduce(add, 1.0)
+$env?.array | reduce(add, nil)
+$env?.array | reduce(array)
+$env?.array | reduce(f64)
+$env?.array | reduce(false)
+$env?.array | reduce(foo)
+$env?.array | reduce(i, 1.0)
+$env?.array | reduce(ok)
+$env?.array | reduce(true)
+$env?.array | sortBy(#)
+$env?.array | sortBy(0)
+$env?.array | sortBy(1)
+$env?.array | sortBy(1.0)
+$env?.array | sortBy(f64)
+$env?.array | sortBy(i)
+$env?.array | sortBy(str)
+$env?.array | sum(#)
+$env?.array | sum(1)
+$env?.array | sum(1.0)
+$env?.array | sum(i)
+$env?.array | take(0)
+$env?.array; i
+$env?.array?.[first(array)]
+$env?.array?.[i]
+$env?.array[:]
+$env?.f64 != i
+$env?.f64 * 1.0 == 1.0
+$env?.f64 * f64
+$env?.f64 ** 0 / f64
+$env?.f64 ** f64
+$env?.f64 ** i
+$env?.f64 ** int(f64)
+$env?.f64 + 0 < 1.0
+$env?.f64 + f64
+$env?.f64 + i
+$env?.f64 - 1.0 == 1.0
+$env?.f64 - f64
+$env?.f64 / f64
+$env?.f64 / i
+$env?.f64 / len($env)
+$env?.f64 < 0 % i
+$env?.f64 < 1.0 - 1.0
+$env?.f64 < f64
+$env?.f64 < i
+$env?.f64 == f64
+$env?.f64 == i
+$env?.f64 > f64
+$env?.f64 > i
+$env?.f64 >= f64
+$env?.f64 >= round(f64)
+$env?.f64 ^ i
+$env?.f64 in array
+$env?.f64 not in $env?.String
+$env?.f64 not in array
+$env?.f64 | mean(1.0)
+$env?.f64 | median(f64)
+$env?.false != add
+$env?.false != ok
+$env?.false == add
+$env?.false contains $env?.String
+$env?.false endsWith str
+$env?.false?.Bar
+$env?.false?.Bar()
+$env?.false?.Bar.String
+$env?.false?.String
+$env?.false?.[add]
+$env?.false?.[array]
+$env?.false?.[array]?.String
+$env?.false?.[f64]
+$env?.false?.[foo]
+$env?.false?.[greet]
+$env?.false?.[i]
+$env?.false?.[list]
+$env?.false?.[ok]
+$env?.false?.[str]
+$env?.false?.add
+$env?.false?.add()
+$env?.false?.add?.[f64]
+$env?.false?.array
+$env?.false?.array()
+$env?.false?.array(f64)
+$env?.false?.array(foobar)
+$env?.false?.array?.array
+$env?.false?.f64
+$env?.false?.f64()
+$env?.false?.foo
+$env?.false?.foo()
+$env?.false?.foo(foobar, i .. f64)
+$env?.false?.foobar
+$env?.false?.greet
+$env?.false?.greet()
+$env?.false?.i
+$env?.false?.i.str
+$env?.false?.list
+$env?.false?.list()
+$env?.false?.list?.Bar
+$env?.false?.ok
+$env?.false?.ok()
+$env?.false?.str
+$env?.false?.str()
+$env?.false?.str.foo
+$env?.false?.str?.add
+$env?.foo in list
+$env?.foo not in list
+$env?.foo.Bar
+$env?.foo.String
+$env?.foo.String()
+$env?.foo?.Bar
+$env?.foo?.String
+$env?.foo?.String()
+$env?.foobar != f64
+$env?.foobar != str
+$env?.foobar == $env.i
+$env?.foobar == [1.0]
+$env?.foobar == add
+$env?.foobar == array
+$env?.foobar == foo
+$env?.foobar == greet
+$env?.foobar == list
+$env?.foobar == ok
+$env?.foobar == reduce(list, false)
+$env?.foobar contains str
+$env?.foobar endsWith str
+$env?.foobar in array
+$env?.foobar in groupBy(array, 1.0)
+$env?.foobar matches str
+$env?.foobar not contains str
+$env?.foobar?.$env?.[f64]
+$env?.foobar?.Bar
+$env?.foobar?.Bar()
+$env?.foobar?.Bar().str
+$env?.foobar?.Bar.str
+$env?.foobar?.Bar?.[list]
+$env?.foobar?.Bar?.list()
+$env?.foobar?.String
+$env?.foobar?.String()
+$env?.foobar?.String(foo)
+$env?.foobar?.String(foobar)
+$env?.foobar?.[add]
+$env?.foobar?.[add]?.[array]
+$env?.foobar?.[add]?.[f64]
+$env?.foobar?.[add]?.f64
+$env?.foobar?.[add]?.greet()
+$env?.foobar?.[array]
+$env?.foobar?.[count($env)]
+$env?.foobar?.[f64]
+$env?.foobar?.[f64]?.Bar
+$env?.foobar?.[f64]?.add
+$env?.foobar?.[f64]?.f64(foobar)
+$env?.foobar?.[foo]
+$env?.foobar?.[foo].str
+$env?.foobar?.[foo]?.[i]
+$env?.foobar?.[foo]?.ok
+$env?.foobar?.[greet]
+$env?.foobar?.[greet]?.add
+$env?.foobar?.[greet]?.array
+$env?.foobar?.[i]
+$env?.foobar?.[i]?.[ok]
+$env?.foobar?.[i]?.foo()
+$env?.foobar?.[i]?.i
+$env?.foobar?.[i]?.list
+$env?.foobar?.[list]
+$env?.foobar?.[list] != ok
+$env?.foobar?.[list].Bar
+$env?.foobar?.[list].list
+$env?.foobar?.[list]?.[f64]
+$env?.foobar?.[list]?.add
+$env?.foobar?.[ok]
+$env?.foobar?.[ok]?.str
+$env?.foobar?.[str]
+$env?.foobar?.[str].String
+$env?.foobar?.[str].list(foobar?.[i].ok)
+$env?.foobar?.[str]?.f64
+$env?.foobar?.[str]?.list
+$env?.foobar?.add
+$env?.foobar?.add()
+$env?.foobar?.add(1.0)
+$env?.foobar?.add(foobar)
+$env?.foobar?.add.array
+$env?.foobar?.add?.[greet]
+$env?.foobar?.add?.[i]
+$env?.foobar?.add?.[str]
+$env?.foobar?.add?.add
+$env?.foobar?.add?.f64
+$env?.foobar?.add?.foo
+$env?.foobar?.add?.greet()
+$env?.foobar?.add?.i
+$env?.foobar?.add?.ok
+$env?.foobar?.all(str)
+$env?.foobar?.array
+$env?.foobar?.array()
+$env?.foobar?.array().list
+$env?.foobar?.array(Bar)
+$env?.foobar?.array(foobar)
+$env?.foobar?.array.foo
+$env?.foobar?.array.ok
+$env?.foobar?.array?.String(i)
+$env?.foobar?.array?.array
+$env?.foobar?.array?.list
+$env?.foobar?.count($env)
+$env?.foobar?.count(foo, foo)
+$env?.foobar?.f64
+$env?.foobar?.f64()
+$env?.foobar?.f64()?.greet
+$env?.foobar?.f64(add)?.String(list)
+$env?.foobar?.f64.f64
+$env?.foobar?.f64.i
+$env?.foobar?.f64?.[array].Bar
+$env?.foobar?.f64?.[foo]?.[greet]
+$env?.foobar?.f64?.array()
+$env?.foobar?.f64?.foo
+$env?.foobar?.false?.i()
+$env?.foobar?.findIndex(array)
+$env?.foobar?.findLast($env, $env)
+$env?.foobar?.findLastIndex(foo, f64, array)
+$env?.foobar?.findLastIndex(true)
+$env?.foobar?.foo
+$env?.foobar?.foo()
+$env?.foobar?.foo(array)
+$env?.foobar?.foo(foobar | string($env))
+$env?.foobar?.foo(foobar)?.[i]
+$env?.foobar?.foo.ok
+$env?.foobar?.foo?.String
+$env?.foobar?.foo?.[add]
+$env?.foobar?.foo?.[foo]
+$env?.foobar?.foo?.str
+$env?.foobar?.foobar
+$env?.foobar?.foobar?.[greet]
+$env?.foobar?.greet
+$env?.foobar?.greet()
+$env?.foobar?.greet(array)
+$env?.foobar?.greet.Bar
+$env?.foobar?.greet.array
+$env?.foobar?.greet?.add
+$env?.foobar?.greet?.array()
+$env?.foobar?.greet?.foo
+$env?.foobar?.i
+$env?.foobar?.i()
+$env?.foobar?.i(foobar)
+$env?.foobar?.i(list not endsWith foobar)
+$env?.foobar?.i?.f64
+$env?.foobar?.i?.greet
+$env?.foobar?.i?.ok
+$env?.foobar?.list
+$env?.foobar?.list()
+$env?.foobar?.list().ok
+$env?.foobar?.list()?.f64
+$env?.foobar?.list?.[greet]
+$env?.foobar?.list?.foo
+$env?.foobar?.min(foobar, 1.0)
+$env?.foobar?.none(array)
+$env?.foobar?.not
+$env?.foobar?.not?.[ok]
+$env?.foobar?.ok
+$env?.foobar?.ok()
+$env?.foobar?.ok(foobar not contains foobar)
+$env?.foobar?.ok(ok)
+$env?.foobar?.ok.array
+$env?.foobar?.ok?.[str]
+$env?.foobar?.ok?.i
+$env?.foobar?.one(foobar)
+$env?.foobar?.replace(str)
+$env?.foobar?.split(1.0)
+$env?.foobar?.str
+$env?.foobar?.str()
+$env?.foobar?.str().String
+$env?.foobar?.str(String?.[i])
+$env?.foobar?.str(foo)
+$env?.foobar?.str.array
+$env?.foobar?.str.i
+$env?.foobar?.str?.[str]
+$env?.foobar?.str?.add
+$env?.foobar?.str?.i
+$env?.foobar?.string($env)
+$env?.foobar?.timezone(str)
+$env?.foobar?.true?.str
+$env?.greet != greet
+$env?.greet == find($env, false)
+$env?.greet == greet
+$env?.greet($env?.str)
+$env?.greet(foo.Bar)
+$env?.greet(foo.String())
+$env?.greet(foo?.String())
+$env?.greet(greet(str))
+$env?.greet(str)
+$env?.greet(str) startsWith str
+$env?.greet(string(0))
+$env?.greet(toJSON(false))
+$env?.greet(type(true))
+$env?.i != f64
+$env?.i != i
+$env?.i % i
+$env?.i * 1 != $env
+$env?.i * f64
+$env?.i * i
+$env?.i ** 1.0 >= i
+$env?.i ** f64
+$env?.i ** i
+$env?.i + f64
+$env?.i + findIndex($env, ok)
+$env?.i - ceil(i)
+$env?.i - i
+$env?.i .. 1 | groupBy(f64)
+$env?.i .. i
+$env?.i / f64
+$env?.i / i
+$env?.i / max(1.0)
+$env?.i < f64
+$env?.i < i
+$env?.i <= f64
+$env?.i <= i
+$env?.i == f64
+$env?.i == first($env)
+$env?.i == i
+$env?.i == len(list)
+$env?.i == max($env)
+$env?.i > f64
+$env?.i > i
+$env?.i >= $env?.f64
+$env?.i >= 0 or $env
+$env?.i >= 1.0 ** 1
+$env?.i >= f64
+$env?.i >= floor(1.0)
+$env?.i >= i
+$env?.i ^ i
+$env?.i ^ i not in array
+$env?.i in array
+$env?.i not in $env?.[Bar]
+$env?.i not in array
+$env?.i | bitnand(0)
+$env?.i | bitnand(1)
+$env?.i | bitor(i)
+$env?.i | bitshl(0)
+$env?.i | mean(i)
+$env?.i | median(f64)
+$env?.list != [1.0]
+$env?.list != array
+$env?.list != list
+$env?.list == [foo, 0]
+$env?.list == list
+$env?.list == nil || $env
+$env?.list | all(false)
+$env?.list | all(ok)
+$env?.list | all(true)
+$env?.list | any(false)
+$env?.list | any(ok)
+$env?.list | concat(list)
+$env?.list | count(false)
+$env?.list | count(ok)
+$env?.list | count(true)
+$env?.list | filter(ok)
+$env?.list | filter(true)
+$env?.list | find(false)
+$env?.list | find(ok)
+$env?.list | find(true)
+$env?.list | findIndex(ok)
+$env?.list | findLastIndex(#.Bar in #)
+$env?.list | groupBy(#)
+$env?.list | groupBy(.Bar)
+$env?.list | groupBy(0)
+$env?.list | groupBy(1)
+$env?.list | groupBy(1.0)
+$env?.list | groupBy(f64)
+$env?.list | groupBy(false)
+$env?.list | groupBy(foo)
+$env?.list | groupBy(i)
+$env?.list | groupBy(ok)
+$env?.list | groupBy(str)
+$env?.list | groupBy(true)
+$env?.list | map(#)
+$env?.list | map(#.Bar)
+$env?.list | map(#index)
+$env?.list | map($env)
+$env?.list | map(.Bar)
+$env?.list | map(.String)
+$env?.list | map(0)
+$env?.list | map(1)
+$env?.list | map(1.0)
+$env?.list | map(add)
+$env?.list | map(array)
+$env?.list | map(false)
+$env?.list | map(foo)
+$env?.list | map(greet)
+$env?.list | map(i)
+$env?.list | map(list)
+$env?.list | map(ok)
+$env?.list | map(str)
+$env?.list | map(true)
+$env?.list | none(.Bar not startsWith #.Bar)
+$env?.list | none(ok)
+$env?.list | none(true)
+$env?.list | one(false)
+$env?.list | one(ok)
+$env?.list | reduce(#)
+$env?.list | reduce(#, false)
+$env?.list | reduce(#.Bar)
+$env?.list | reduce(#.Bar, 0)
+$env?.list | reduce(#acc)
+$env?.list | reduce(#acc, 1)
+$env?.list | reduce(#acc, true)
+$env?.list | reduce(#index)
+$env?.list | reduce($env)
+$env?.list | reduce($env, greet)
+$env?.list | reduce($env, true)
+$env?.list | reduce(.Bar)
+$env?.list | reduce(.String, $env)
+$env?.list | reduce(0)
+$env?.list | reduce(1)
+$env?.list | reduce(1.0)
+$env?.list | reduce(add)
+$env?.list | reduce(array)
+$env?.list | reduce(array, $env)
+$env?.list | reduce(foo)
+$env?.list | reduce(foo, nil)
+$env?.list | reduce(foo, str)
+$env?.list | reduce(greet)
+$env?.list | reduce(list)
+$env?.list | reduce(ok)
+$env?.list | reduce(str)
+$env?.list | reduce(true)
+$env?.list | reduce(true, i)
+$env?.list | sortBy(#.Bar)
+$env?.list | sortBy(.Bar)
+$env?.list | sortBy(0)
+$env?.list | sortBy(1)
+$env?.list | sortBy(1.0)
+$env?.list | sortBy(str)
+$env?.list | sum(1)
+$env?.list | sum(1.0)
+$env?.list | sum(f64)
+$env?.list | sum(i)
+$env?.list?.[i]
+$env?.list?.[i].String
+$env?.list[:]
+$env?.nil != array
+$env?.nil != greet
+$env?.nil == foo.Bar
+$env?.nil contains $env?.[nil]
+$env?.nil matches str
+$env?.nil not in array
+$env?.nil?.Bar
+$env?.nil?.Bar()
+$env?.nil?.Bar(list)
+$env?.nil?.Bar?.String(Bar)
+$env?.nil?.Bar?.[i]
+$env?.nil?.String
+$env?.nil?.String()
+$env?.nil?.String?.ok()
+$env?.nil?.[add]
+$env?.nil?.[add]?.[greet]
+$env?.nil?.[add]?.str
+$env?.nil?.[array]
+$env?.nil?.[array].Bar
+$env?.nil?.[array]?.String
+$env?.nil?.[f64]
+$env?.nil?.[foo]
+$env?.nil?.[greet]
+$env?.nil?.[greet]?.ok
+$env?.nil?.[i]
+$env?.nil?.[list]
+$env?.nil?.[ok]
+$env?.nil?.[str]
+$env?.nil?.[str]?.str
+$env?.nil?.add
+$env?.nil?.add()
+$env?.nil?.array
+$env?.nil?.array()
+$env?.nil?.array(str)
+$env?.nil?.f64
+$env?.nil?.f64()
+$env?.nil?.filter(1.0)
+$env?.nil?.foo
+$env?.nil?.foo()
+$env?.nil?.foo.i
+$env?.nil?.foo?.[add].array
+$env?.nil?.foo?.[f64]
+$env?.nil?.foo?.f64(Bar)
+$env?.nil?.foobar
+$env?.nil?.greet
+$env?.nil?.greet()
+$env?.nil?.i
+$env?.nil?.list
+$env?.nil?.list()
+$env?.nil?.ok
+$env?.nil?.ok()
+$env?.nil?.ok(add)
+$env?.nil?.one(foobar, foobar)
+$env?.nil?.round(1.0)
+$env?.nil?.str
+$env?.nil?.str()
+$env?.ok && $env?.Bar
+$env?.ok && $env?.[str]
+$env?.ok && ok
+$env?.ok == ok
+$env?.ok ? foo == nil : i
+$env?.ok ?: foo
+$env?.ok and $env?.[String]
+$env?.ok and foo != foo
+$env?.ok and ok
+$env?.ok not in $env && false
+$env?.ok or i != 1.0
+$env?.ok or ok
+$env?.ok || $env?.Bar()
+$env?.ok || ok
+$env?.ok || sum($env)
+$env?.str + str
+$env?.str < type(add)
+$env?.str <= foo.Bar
+$env?.str <= str
+$env?.str <= string(str)
+$env?.str == str
+$env?.str > str
+$env?.str > str == nil
+$env?.str > toJSON(nil)
+$env?.str >= foo?.Bar
+$env?.str contains foo?.Bar
+$env?.str contains str
+$env?.str endsWith $env and false
+$env?.str endsWith str
+$env?.str in $env ? 1.0 : nil
+$env?.str in foo
+$env?.str matches $env?.[String]
+$env?.str matches str
+$env?.str not contains str
+$env?.str not endsWith str
+$env?.str not in $env?.[String]
+$env?.str not in foo
+$env?.str not matches foo.Bar
+$env?.str not matches str
+$env?.str not startsWith foo?.Bar
+$env?.str | date(str)
+$env?.str | greet()
+$env?.str | trimPrefix(str)
+$env?.str[:]
+$env?.str[:i]
+$env?.str[i:]
+$env?.true != ok
+$env?.true == foo
+$env?.true == i
+$env?.true not endsWith str
+$env?.true?.Bar
+$env?.true?.Bar()
+$env?.true?.String
+$env?.true?.String()
+$env?.true?.[add]
+$env?.true?.[array]
+$env?.true?.[array].Bar
+$env?.true?.[f64]
+$env?.true?.[foo]
+$env?.true?.[greet]
+$env?.true?.[i]
+$env?.true?.[list]
+$env?.true?.[ok]
+$env?.true?.[ok]?.[ok]
+$env?.true?.[str]
+$env?.true?.[str].foo
+$env?.true?.add
+$env?.true?.add.foo
+$env?.true?.array
+$env?.true?.f64
+$env?.true?.f64()
+$env?.true?.f64(foobar)
+$env?.true?.find(foobar, foobar)
+$env?.true?.foo
+$env?.true?.foo()
+$env?.true?.foo?.[ok]
+$env?.true?.foobar
+$env?.true?.greet
+$env?.true?.greet()
+$env?.true?.greet?.ok
+$env?.true?.i
+$env?.true?.i()
+$env?.true?.list
+$env?.true?.list()
+$env?.true?.list.foo
+$env?.true?.ok
+$env?.true?.ok()
+$env?.true?.str
+$env?.true?.str()
+$env[$env:] - f64 and false
+- + $env || true
+- + $env.f64
+- + $env.i
+- + $env?.f64
+- + $env?.i
+- + 1 != f64
+- + 1 < 1.0
+- + 1 ^ 1
+- + 1.0 != 1.0
+- + abs(i)
+- + ceil(0)
+- + f64
+- + f64 + f64
+- + f64 - 1.0
+- + f64 > 0
+- + i
+- + i < 1
+- + i in $env.array
+- + int(0)
+- + median(f64)
+- + min(f64)
+- + sum(array)
+- + {foo: 1}.foo
+- - $env?.f64
+- - $env?.i
+- - 0 <= 1.0
+- - 0 >= 1.0
+- - 0 ^ 0
+- - 0 ^ 1
+- - 1 == 1.0
+- - 1.0 != nil
+- - 1.0 ** 1.0
+- - 1.0 < 1
+- - 1.0 == 0
+- - abs(1)
+- - array?.[i]
+- - ceil(1.0)
+- - f64
+- - i
+- - i != $env
+- - len($env)
+- - max(1.0)
+- - sum(array)
+-.0 ** 0
+-.0 / 1
+0 != $env.f64
+0 != $env.i
+0 != $env?.Bar
+0 != $env?.Bar?.foo()
+0 != $env?.String
+0 != $env?.[Bar]
+0 != $env?.[String]
+0 != $env?.[foobar]
+0 != $env?.[str]
+0 != $env?.f64
+0 != $env?.foobar?.foo
+0 != $env?.i
+0 != $env?.not
+0 != 0 ?: array
+0 != 1.0 * $env.f64
+0 != 1.0 + f64 ** 1.0
+0 != 1.0 / i * 1.0
+0 != 1.0 || $env - i
+0 != array?.[i]
+0 != f64 / f64
+0 != f64 == $env?.Bar
+0 != f64 ^ 1.0 or $env
+0 != f64 || ok
+0 != i ** i
+0 != i ^ f64
+0 != nil != ok
+0 != nil || $env?.[String]
+0 % $env.i
+0 % $env?.i
+0 % 1 * i
+0 % 1 + i >= 0
+0 % 1 > count(array, false)
+0 % 1 >= i
+0 % 1 | median(f64)
+0 % array?.[i]
+0 * $env.f64
+0 * $env.i
+0 * $env?.f64
+0 * $env?.i
+0 * 0 != f64
+0 * 0 == i
+0 * 1 != i
+0 * 1 + f64
+0 * 1.0 != nil or ok
+0 * 1.0 ** i
+0 * array?.[i]
+0 * f64 + i
+0 * f64 <= f64
+0 * i != i
+0 * i ^ f64
+0 ** $env.f64
+0 ** $env.i
+0 ** $env?.f64
+0 ** $env?.i
+0 ** 0 != $env?.i
+0 ** 0 + $env.i
+0 ** 1.0 ** f64
+0 ** 1.0 / f64
+0 ** 1.0 < i
+0 ** 1.0 == i
+0 ** 1.0 > i
+0 ** array?.[i]
+0 ** f64 >= $env?.f64
+0 ** i != f64
+0 + $env.f64
+0 + $env.i
+0 + $env?.[str]?.[i]
+0 + $env?.f64
+0 + $env?.i
+0 + 0 - f64
+0 + 0 / i
+0 + 0 >= f64 <= $env
+0 + 1 <= $env.i
+0 + 1 <= f64
+0 + 1 | min(0)
+0 + 1.0 + i
+0 + array?.[i]
+0 + f64 > i
+0 + i * f64
+0 - $env.f64
+0 - $env.i
+0 - $env?.f64
+0 - $env?.i
+0 - 0 < f64
+0 - 0 == i
+0 - 1 ** f64
+0 - 1 < $env.i
+0 - array?.[i]
+0 - f64 >= f64 * i
+0 .. $env.i
+0 .. $env?.i
+0 .. 0 | find(ok)
+0 .. 0 | map(#)
+0 .. 0 | max(1.0)
+0 .. 0 | reduce(str)
+0 .. 1 | get(1)
+0 .. 1 | map(array)
+0 .. 1 | map(foo)
+0 .. 1 | reduce(#)
+0 .. 1 | reduce($env)
+0 .. 1 | reduce(add)
+0 .. 1 | sortBy(#)
+0 .. array?.[i]
+0 .. i | groupBy(foo)
+0 .. i | map(str)
+0 .. i | sortBy(1)
+0 / $env != 1 and false
+0 / $env.f64
+0 / $env.i
+0 / $env?.f64
+0 / $env?.i
+0 / 0 * i
+0 / 0 + ceil(1.0)
+0 / 1 / f64
+0 / 1.0 + $env.i
+0 / array?.[i]
+0 / f64 <= f64
+0 / i + i
+0 < $env.f64
+0 < $env.i
+0 < $env?.[str]?.[f64]
+0 < $env?.f64
+0 < $env?.i
+0 < 0 + len(str)
+0 < 1 % i
+0 < 1 - i
+0 < 1 ^ median(1.0)
+0 < 1.0 - f64
+0 < 1.0 / i
+0 < 1.0 <= i
+0 < array?.[i]
+0 < f64 || $env?.ok
+0 < i <= reduce(array, #)
+0 <= $env.f64
+0 <= $env.i
+0 <= $env?.f64
+0 <= $env?.i
+0 <= 1 * i
+0 <= 1 <= f64
+0 <= 1 ^ f64
+0 <= 1 or $env != 1
+0 <= 1.0 * f64
+0 <= array?.[i]
+0 <= i % i
+0 == $env || ok
+0 == $env.f64
+0 == $env.i
+0 == $env?.Bar
+0 == $env?.Bar?.foo
+0 == $env?.String
+0 == $env?.String?.str
+0 == $env?.[Bar]
+0 == $env?.[String]
+0 == $env?.[foobar]
+0 == $env?.[str]
+0 == $env?.f64
+0 == $env?.i
+0 == 0 not in $env?.foobar
+0 == 1.0 && f64 + $env
+0 == 1.0 / i
+0 == array?.[i]
+0 == f64 ?: add
+0 == i and $env?.[foo]
+0 > $env.f64
+0 > $env.i
+0 > $env?.[str]?.[f64]
+0 > $env?.f64
+0 > $env?.i
+0 > 0 * f64
+0 > 0 / i
+0 > 0 > ceil($env)
+0 > 0 or foo == nil
+0 > 1 - i
+0 > 1.0 ^ f64
+0 > array?.[i]
+0 > f64 > $env?.[Bar]
+0 > f64 > f64
+0 >= $env.f64
+0 >= $env.i
+0 >= $env?.f64
+0 >= $env?.i
+0 >= 0 ** i
+0 >= 1 >= i
+0 >= 1.0 and ok
+0 >= 1.0 or ok
+0 >= f64 ** f64
+0 >= f64 + f64
+0 ^ $env.f64
+0 ^ $env.i
+0 ^ $env?.f64
+0 ^ $env?.i
+0 ^ 1 * i
+0 ^ 1 / f64
+0 ^ 1.0 != i
+0 ^ 1.0 + f64
+0 ^ 1.0 / f64
+0 ^ 1.0 in array
+0 ^ array?.[i]
+0 ^ i == i
+0 in $env.array
+0 in $env?.Bar
+0 in $env?.Bar?.greet
+0 in $env?.String
+0 in $env?.[Bar]
+0 in $env?.[String]
+0 in $env?.array
+0 in array != ok
+0 not in $env.array
+0 not in $env?.Bar
+0 not in $env?.String
+0 not in $env?.[Bar]
+0 not in $env?.[String]
+0 not in $env?.[foobar]
+0 not in $env?.array
+0 | bitor($env) == 1 and false
+0 | bitshl(1) / f64
+0 | bitxor(0) in array
+0 | max(0) in array
+0 | max(array, 1.0) - floor(i)
+0..array?.[i]
+0..i | map(list)
+0.0 + 0 == $env
+0.1 != floor(1.0)
+0.1 | mean(f64)
+0; $env?.add
+1 != $env not in [true]
+1 != $env.f64
+1 != $env.i
+1 != $env?.Bar
+1 != $env?.String
+1 != $env?.String?.f64
+1 != $env?.[Bar]
+1 != $env?.[Bar]?.f64
+1 != $env?.[String]
+1 != $env?.[foobar]
+1 != $env?.[str]
+1 != $env?.f64
+1 != $env?.foobar
+1 != $env?.i
+1 != 0 * f64
+1 != 1 - f64
+1 != 1.0 + i
+1 != array?.[i]
+1 != f64 && $env?.[str]
+1 != f64 || ok
+1 != i != ok
+1 != nil or ok
+1 % $env.i
+1 % $env?.i
+1 % 1 > f64
+1 % array?.[i]
+1 * $env.f64
+1 * $env.i
+1 * $env.i + f64
+1 * $env?.f64
+1 * $env?.i
+1 * 0 / f64
+1 * 0 == {foo: 1.0}?.array
+1 * 0 | bitushr(0)
+1 * 1 | bitnand(0)
+1 * 1 | min(f64)
+1 * 1.0 ** $env.i
+1 * 1.0 < f64
+1 * array?.[i]
+1 * f64 ^ f64 - 1
+1 * f64 | mean(1)
+1 * i / i
+1 * i | bitxor(i)
+1 ** $env.f64
+1 ** $env.i
+1 ** $env?.f64
+1 ** $env?.i
+1 ** 0 ** i
+1 ** 1 != i
+1 ** 1 ** i
+1 ** 1.0 != f64
+1 ** array?.[i]
+1 ** i + f64
+1 + $env.f64
+1 + $env.i
+1 + $env?.f64
+1 + $env?.i
+1 + 0 ** i
+1 + 1 % i
+1 + 1 not in array
+1 + 1.0 != i
+1 + 1.0 - i
+1 + 1.0 < f64
+1 + 1.0 ^ i
+1 + f64 ^ i ** 1
+1 + f64 in array
+1 + f64 | max(array)
+1 + f64 | median(array)
+1 + i < f64
+1 + i < i
+1 + i..i
+1 - $env.f64
+1 - $env.i
+1 - $env?.f64
+1 - $env?.i
+1 - 1.0 in array
+1 - 1.0 not in array
+1 - array?.[i]
+1 - f64 >= 1.0 < 1
+1 - f64 | min(array)
+1 - i / f64
 1 - i > i
-1 - i > i32
-1 - i >= i64
-1 - i not in array
-1 - i32 < i32
-1 - i32 < i64
-1 - i32 == i32
-1 - i64 <= i32
-1 .. i != list
-1 / 0.5 <= abs(f32)
-1 / 0.5 <= i32
-1 / 0.5 == f64
-1 / 0.5 > f32
-1 / 0.5 >= i
-1 / 0.5 >= i - i
-1 / 0.5 >= i32
-1 / 1 != i32
-1 / 1 * f32
-1 / 1 <= f64
-1 / 1 in array
-1 / f32 != f64
-1 / f32 / i64
-1 / f32 <= f32
-1 / f32 <= f64
-1 / f32 == i32
-1 / f32 == i32 / i
-1 / f32 > f32
-1 / f32 >= f64
-1 / f64 + f64
-1 / f64 < f32
-1 / f64 == f64
-1 / i * f32
-1 / i / f64
-1 / i < i
-1 / i == f64
-1 / i >= i32
-1 / i in map(list, 1)
-1 / i32 > f32
-1 / i32 >= i64
-1 / i64 * i
-1 / i64 > f32 / f64
-1 / i64 > f64
-1 / i64 >= f64
-1 < 1 == ok
-1 < 1 and ok
-1 < array[get(array, i32)]
-1 < array[i32]
-1 < f32 != not true
-1 < f64 || ok
-1 < i ? array : foo
-1 < i32 || 1 >= f32
-1 < i64 == ok
-1 < i64 ? ok : list
-1 <= 1 == ok
-1 <= 1 || add == add
-1 <= f32 && ok
-1 <= f64 || ok
-1 <= i32 ? foo : f32
-1 == 0.5 ? i32 : greet
-1 == 0.5 and ok
-1 == 1 || ok
-1 == f64 && 0.5 != nil
-1 == f64 || ok
-1 == i32 && ok
-1 == i32 == ok
-1 == i64 == ok
-1 == nil ? ok : half
-1 > 0.5 == ok
-1 > array[i64]
-1 > f32 && ok
-1 > f32 == reduce(array, ok)
-1 > f64 != ok
-1 > i == ok
-1 > i64 or i != 1
-1 >= 1 != (nil not in list)
-1 >= f32 ? i64 : half
-1 >= f64 ? ok : half
-1 >= i and ok
-1 ^ 0.5 != f32
-1 ^ 0.5 != i
-1 ^ 0.5 ** f32
-1 ^ 0.5 ** i32
-1 ^ 0.5 - i32
-1 ^ 0.5 < i32
-1 ^ 0.5 <= f64
-1 ^ 0.5 == i
-1 ^ 0.5 ^ f32
-1 ^ 0.5 ^ i64
-1 ^ 1 != f64
-1 ^ 1 != i64
-1 ^ 1 ** i
-1 ^ 1 + f64
-1 ^ 1 / i
-1 ^ 1 < i
-1 ^ 1 < i64
-1 ^ 1 >= i
-1 ^ 1 >= i32
-1 ^ f32 < i32
-1 ^ f32 <= f64
-1 ^ f64 / f64
-1 ^ f64 == f32
-1 ^ f64 > f32
-1 ^ f64 >= 1 / f64
-1 ^ i != i * f32
-1 ^ i - i32
-1 ^ i < i
-1 ^ i32 * i32
-1 ^ i32 ** i64
-1 ^ i32 / i
-1 ^ i32 >= i32
-1 ^ i32 >= i64
-1 ^ i64 * i64
-1 ^ i64 ** reduce(list, 1)
-1 ^ i64 - i64
-1 ^ i64 / f64
-1 ^ i64 > i
-1 ^ i64 >= i32 + i32
-1 in array ? f32 : foo
-[!false]
-[!ok]
-[!true]
-["bar" + "foo"]
-["bar" < "bar"]
-["bar" not contains "bar"]
-[-0.5]
-[-1]
-[-f32]
-[-f64]
-[-i64]
-[0.5 != f32]
-[0.5 != i]
-[0.5 * 0.5]
-[0.5 * f32]
-[0.5 ** i]
-[0.5 - 0.5]
-[0.5 - i]
-[0.5 / i32]
-[0.5 <= i32, half]
-[0.5 > 1]
-[0.5 > f32]
-[0.5 > i64]
-[0.5 >= f64]
-[0.5 ^ 0.5]
-[1 != 1]
-[1 * 0.5]
-[1 ** 0.5]
-[1 + i64, add]
-[1 == i64]
+1 - i ^ i
+1 - i | min(1.0)
+1 .. $env.i
+1 .. $env?.i
+1 .. 0 | groupBy(#)
+1 .. 0 | groupBy(foo)
+1 .. 0 | one($env)
+1 .. 0 | sortBy($env)
+1 .. 0 | sortBy(str)
+1 .. 0 | sum(greet)
+1 .. 1 | filter(ok)
+1 .. array?.[i]
+1 .. i - i
+1 .. i | groupBy(#)
+1 .. i | groupBy(foo)
+1 .. i | groupBy(ok)
+1 .. i | reduce(foo)
+1 / $env.array?.[i]
+1 / $env.f64
+1 / $env.i
+1 / $env?.f64
+1 / $env?.i
+1 / 1 * f64
+1 / 1 > f64
+1 / 1 ^ i
+1 / 1 in [nil]
+1 / 1.0 * $env?.f64
+1 / 1.0 ** i
+1 / 1.0 == i || ok
+1 / array?.[i]
+1 / f64 - f64
+1 < $env.f64
+1 < $env.i
+1 < $env?.f64
+1 < $env?.f64 && ok
+1 < $env?.i
+1 < 0 <= $env?.[str]
+1 < 0 ^ i ** 1.0
+1 < 1 ?: array
+1 < 1.0 < i
+1 < 1.0 > $env?.[false]
+1 < i or min($env)
+1 <= $env.f64
+1 <= $env.i
+1 <= $env?.f64
+1 <= $env?.i
+1 <= 0 - i
+1 <= 0 ?: greet
+1 <= 1 / f64
+1 <= 1 == true or true
+1 <= 1.0 == $env?.[Bar]
+1 <= array?.[i]
+1 <= i / i
+1 <= i ^ i
+1 == $env || ok
+1 == $env.f64
+1 == $env.i
+1 == $env?.Bar
+1 == $env?.Bar?.Bar
+1 == $env?.String
+1 == $env?.String?.[greet]
+1 == $env?.[Bar]
+1 == $env?.[String]
+1 == $env?.[foobar]
+1 == $env?.[foobar]?.[greet]
+1 == $env?.[str]
+1 == $env?.f64
+1 == $env?.i
+1 == $env?.not
+1 == 1 ^ i
+1 == 1.0 - $env.i
+1 == 1.0 - i
+1 == array?.[i]
+1 == f64 && list == $env
+1 == f64 * f64 ** 1.0
+1 == f64 ?: greet
+1 == f64 ^ f64
+1 == i - f64
+1 > $env.f64
+1 > $env.i
+1 > $env?.f64
+1 > $env?.i
+1 > 0 != ok
+1 > 0 <= i or $env
+1 > 1.0 / i
+1 > 1.0 <= i
+1 > 1.0 >= $env.i
+1 > 1.0 ^ min(array)
+1 > array?.[i]
+1 > i % i
+1 > i - i
+1 > i <= f64
+1 >= $env.f64
+1 >= $env.i
+1 >= $env?.f64
+1 >= $env?.i
+1 >= 0 == ok
+1 >= 1 <= f64
+1 >= 1 <= i
+1 >= 1.0 > float(1)
+1 >= 1.0 or $env.ok
+1 >= array?.[i]
+1 ^ $env.f64
+1 ^ $env.i
+1 ^ $env?.f64
+1 ^ $env?.i
+1 ^ 0 ** i
+1 ^ 1 > f64
+1 ^ 1.0 + f64
+1 ^ 1.0 == i
+1 ^ 1.0 ^ int(1.0)
+1 ^ 1.0 ^ round(0)
+1 ^ array?.[i]
+1 ^ f64 != $env.f64
+1 ^ f64 - ceil(1.0)
+1 in $env.array
+1 in $env?.Bar
+1 in $env?.String
+1 in $env?.[Bar]
+1 in $env?.[String]
+1 in $env?.array
+1 in $env?.foobar
+1 in array || false ? 1 : foo
+1 in array || ok
+1 not in $env.array
+1 not in $env?.Bar
+1 not in $env?.Bar?.[i]
+1 not in $env?.String
+1 not in $env?.[Bar]
+1 not in $env?.[String]
+1 not in $env?.[String]?.f64
+1 not in $env?.[foobar]
+1 not in $env?.array
+1 not in $env?.foobar
+1 | bitshl(0) != f64
+1 | bitxor(1) >= i
+1 | min(1.0) + i
+1..array?.[i]
+1..i | map(#)
+1..i | map(0)
+1..i | reduce(array)
+1.0 != $env.f64
+1.0 != $env.i
+1.0 != $env?.Bar
+1.0 != $env?.Bar?.[array]
+1.0 != $env?.Bar?.str
+1.0 != $env?.String
+1.0 != $env?.String?.[i]
+1.0 != $env?.String?.[ok]
+1.0 != $env?.[Bar]
+1.0 != $env?.[String]
+1.0 != $env?.[foobar?.add($env)]?.greet
+1.0 != $env?.[foobar?.add]
+1.0 != $env?.[foobar]
+1.0 != $env?.[foobar]?.[array]
+1.0 != $env?.[str]
+1.0 != $env?.f64
+1.0 != $env?.foobar
+1.0 != $env?.foobar?.list
+1.0 != $env?.i
+1.0 != $env?.not
+1.0 != 0 != ok
+1.0 != 0 / abs(1.0)
+1.0 != 1 / i
+1.0 != 1 ?: foo
+1.0 != 1.0 ** i
+1.0 != 1.0 ^ $env.f64
+1.0 != 1.0 ^ f64
+1.0 != 1.0 and $env not endsWith $env
+1.0 != array?.[i]
+1.0 != f64 && ok
+1.0 != i % i
+1.0 * $env.f64
+1.0 * $env.i
+1.0 * $env?.f64
+1.0 * $env?.i
+1.0 * 0 >= i
+1.0 * 1.0 <= f64
+1.0 * 1.0 > f64
+1.0 * 1.0 > i
+1.0 * 1.0 >= 0 == nil
+1.0 * 1.0 | mean(array)
+1.0 * array?.[i]
+1.0 * f64 - max(1, array)
+1.0 * f64 == f64
+1.0 * f64 == sum(array)
+1.0 * i >= 1.0 ^ 1
+1.0 * i not in array
+1.0 ** $env.f64
+1.0 ** $env.i
+1.0 ** $env?.f64
+1.0 ** $env?.i
+1.0 ** 0 / i
+1.0 ** 0 < i
+1.0 ** 0 == i
+1.0 ** 0 > i
+1.0 ** 0 | median(1)
+1.0 ** 1.0 != i
+1.0 ** 1.0 * i
+1.0 ** 1.0 < 0 != false
+1.0 ** 1.0 | median(1.0)
+1.0 ** array?.[i]
+1.0 ** f64 * f64
+1.0 ** f64 | median(i)
+1.0 ** f64 | min(1)
+1.0 ** i - float(f64)
+1.0 + $env.f64
+1.0 + $env.i
+1.0 + $env?.f64
+1.0 + $env?.i
+1.0 + 0 != i
+1.0 + 0 + f64
+1.0 + 1 | median(1.0)
+1.0 + 1.0 <= i
+1.0 + 1.0 ^ f64
+1.0 + 1.0 ^ i
+1.0 + 1.0 | mean(1)
+1.0 + 1.0 | median(1.0)
+1.0 + array?.[i]
+1.0 + f64 / f64
+1.0 + f64 / i
+1.0 + f64 >= f64
+1.0 + i < f64
+1.0 - $env.f64
+1.0 - $env.i
+1.0 - $env?.f64
+1.0 - $env?.i
+1.0 - 0 != f64
+1.0 - 1 + 1.0 == nil
+1.0 - 1 - i
+1.0 - 1 - min(1.0)
+1.0 - 1 / i
+1.0 - 1.0 ** f64
+1.0 - 1.0 + f64
+1.0 - 1.0 < f64
+1.0 - 1.0 == i
+1.0 - 1.0 > f64
+1.0 - 1.0 >= f64
+1.0 - 1.0 in array
+1.0 - array?.[i]
+1.0 - f64 - f64
+1.0 - f64 / i
+1.0 - i * $env.i
+1.0 - i < i
+1.0 / $env.f64
+1.0 / $env.i
+1.0 / $env?.f64
+1.0 / $env?.i
+1.0 / 0 != i
+1.0 / 0 * $env?.f64
+1.0 / 0 <= 1 + f64
+1.0 / 0 == i
+1.0 / 0 > $env?.f64
+1.0 / 1 * f64
+1.0 / 1 ** i
+1.0 / 1.0 + i
+1.0 / 1.0 - f64
+1.0 / 1.0 == i
+1.0 / 1.0 >= f64
+1.0 / array?.[i]
+1.0 / f64 * i
+1.0 / f64 <= f64 || true
+1.0 / f64 ^ i
+1.0 / f64 in array
+1.0 / i < f64
+1.0 / i <= i
+1.0 < $env.f64
+1.0 < $env.i
+1.0 < $env?.f64
+1.0 < $env?.i
+1.0 < 1.0 != ok
+1.0 < 1.0 && $env?.String(foobar, i)
+1.0 < 1.0 && $env?.[ok]
+1.0 < 1.0 ** f64
+1.0 < 1.0 / round(1.0)
+1.0 < 1.0 <= $env?.String
+1.0 < 1.0 ? foo != nil : str
+1.0 < 1.0 ^ f64
+1.0 < 1.0 || ok
+1.0 < array?.[i]
+1.0 < f64 + $env.i
+1.0 < f64 ?: i
+1.0 < f64 ^ f64
+1.0 < i != ok
+1.0 < i > f64
+1.0 < i > i
+1.0 < i ?: 1 == i
+1.0 < i ?: list
+1.0 <= $env.f64
+1.0 <= $env.i
+1.0 <= $env?.f64
+1.0 <= $env?.i
+1.0 <= 0 % i
+1.0 <= 0 / f64
+1.0 <= 0 < f64 <= f64
+1.0 <= 0 >= i
+1.0 <= 0 ? f64 : greet
+1.0 <= 1 ** i
+1.0 <= 1 / $env?.i
+1.0 <= 1 / i
+1.0 <= 1 or none($env, $env)
+1.0 <= 1.0 != ok
+1.0 <= 1.0 ** 1 and false
+1.0 <= 1.0 - f64
+1.0 <= 1.0 / mean(f64)
+1.0 <= 1.0 < f64
+1.0 <= 1.0 >= f64
+1.0 <= 1.0 or ok
+1.0 <= 1.0 || ok
+1.0 <= array?.[i]
+1.0 <= f64 != ok
+1.0 <= f64 && ok
+1.0 <= f64 <= f64
+1.0 <= f64 >= f64
+1.0 <= i * i
+1.0 <= i / i
+1.0 == $env && ok != false
+1.0 == $env.f64
+1.0 == $env.i
+1.0 == $env?.Bar
+1.0 == $env?.String
+1.0 == $env?.[Bar]
+1.0 == $env?.[Bar]?.foo
+1.0 == $env?.[String]
+1.0 == $env?.[foobar?.[f64]]
+1.0 == $env?.[str]
+1.0 == $env?.f64
+1.0 == $env?.i
+1.0 == $env?.true != $env
+1.0 == 0 or $env?.ok
+1.0 == 1 != ok
+1.0 == 1 % i
+1.0 == 1 - f64
+1.0 == 1 - i
+1.0 == 1 == ok
+1.0 == 1.0 != ok
+1.0 == 1.0 * f64
+1.0 == 1.0 - i
+1.0 == 1.0 / f64
+1.0 == 1.0 and ok
+1.0 == 1.0 || ok
+1.0 == array?.[i]
+1.0 == f64 != ok
+1.0 == i * i
+1.0 == i + f64
+1.0 == nil ?: array
+1.0 == nil and $env.ok
+1.0 == nil or ok
+1.0 > $env.f64
+1.0 > $env.i
+1.0 > $env?.f64
+1.0 > $env?.i
+1.0 > 0 / i
+1.0 > 0 < f64
+1.0 > 0 < i
+1.0 > 1 ?: {foo: add, foo: ok}?.foo
+1.0 > 1.0 * array?.[i]
+1.0 > 1.0 > i
+1.0 > array?.[i]
+1.0 > f64 * f64
+1.0 > f64 + f64
+1.0 > f64 / i
+1.0 > f64 < f64
+1.0 > f64 > round(1.0)
+1.0 > f64 or none($env, .f64)
+1.0 > i && ok
+1.0 > i + 1.0
+1.0 > i >= $env?.[String]
+1.0 >= $env.f64
+1.0 >= $env.i
+1.0 >= $env?.f64
+1.0 >= $env?.i
+1.0 >= 0 / i
+1.0 >= 1 > i
+1.0 >= 1 > i >= i
+1.0 >= 1.0 * f64 or ok
+1.0 >= 1.0 + f64
+1.0 >= 1.0 / i
+1.0 >= 1.0 / sum(array)
+1.0 >= 1.0 == {foo: $env, foo: $env}.foo
+1.0 >= 1.0 ?: list
+1.0 >= 1.0 ^ f64
+1.0 >= array?.[i]
+1.0 >= f64 ** $env?.i
+1.0 >= f64 ** 0 > 1.0
+1.0 >= f64 / i
+1.0 >= i * f64
+1.0 >= i * i
+1.0 >= i + 1.0 >= $env
+1.0 >= i - i
+1.0 >= i < $env?.i
+1.0 ^ $env.f64
+1.0 ^ $env.i
+1.0 ^ $env?.f64
+1.0 ^ $env?.i
+1.0 ^ 0 - i
+1.0 ^ 0 > i ? array : foo
+1.0 ^ 0 ^ f64
+1.0 ^ 1 * i
+1.0 ^ 1 - sum(array)
+1.0 ^ 1 == i
+1.0 ^ 1 >= 1 || false
+1.0 ^ 1.0 + 1.0 in array
+1.0 ^ 1.0 == $env?.i
+1.0 ^ 1.0 > i
+1.0 ^ 1.0 >= f64
+1.0 ^ array?.[i]
+1.0 ^ f64 * i
+1.0 ^ f64 <= i and $env
+1.0 ^ i * i
+1.0 ^ i < f64 < 1.0
+1.0 ^ i <= int(1.0)
+1.0 ^ i > i
+1.0 ^ i in array
+1.0 ^ i not in array
+1.0 in $env.array
+1.0 in $env?.Bar
+1.0 in $env?.String
+1.0 in $env?.String?.f64
+1.0 in $env?.[Bar]
+1.0 in $env?.[Bar]?.[add]
+1.0 in $env?.[Bar]?.array
+1.0 in $env?.[String]
+1.0 in $env?.[String]?.[i]
+1.0 in $env?.[String]?.[str]
+1.0 in $env?.[foobar?.[foo]]
+1.0 in $env?.array
+1.0 in $env?.foobar
+1.0 in 0 .. i
+1.0 in array or ok
+1.0 not in $env.array
+1.0 not in $env?.Bar
+1.0 not in $env?.String
+1.0 not in $env?.[Bar]
+1.0 not in $env?.[String]
+1.0 not in $env?.[String]?.[array]
+1.0 not in $env?.[foobar?.str]
+1.0 not in $env?.[foobar]
+1.0 not in $env?.array
+1.0 not in $env?.foobar
+1.0 not in $env?.nil?.[list].array()
+1.0 | max(1.0, f64) < f64
+1.0 | max(array) <= i
+1.0 | mean(f64) != i
+1.0 | median(0) ^ i
+1.0 | median(array) | get(foo)
+1.0 | min(1.0) ** i
+1.0; $env.i
+1.0; $env?.Bar
+1.0; $env?.list
+1.0; 1.0 < f64
+[$env != $env]
+[$env != 0]
+[$env != 1.0]
+[$env != 1]
+[$env != add]
+[$env != f64]
+[$env != false]
+[$env != foo]
+[$env != list]
+[$env != nil]
+[$env && true]
+[$env == $env]
+[$env == 0]
+[$env == 1.0]
+[$env == 1]
+[$env == add]
+[$env == false]
+[$env == foo]
+[$env == greet]
+[$env == i, f64]
+[$env == i]
+[$env == list]
+[$env == nil]
+[$env == ok]
+[$env == str]
+[$env == true]
+[$env and false]
+[$env and true]
+[$env in list]
+[$env not in array]
+[$env not in list, f64]
+[$env not in list]
+[$env or false, list]
+[$env or false]
+[$env | all(false)]
+[$env | all(true)]
+[$env | any(false)]
+[$env | any(ok)]
+[$env | any(true)]
+[$env | filter(false), f64]
+[$env | findLast(false)]
+[$env | findLastIndex(false)]
+[$env | map(1.0)]
+[$env | map(add)]
+[$env | map(array)]
+[$env | map(false)]
+[$env | map(foo)]
+[$env | map(greet)]
+[$env | map(i)]
+[$env | map(list)]
+[$env | map(ok)]
+[$env | map(str)]
+[$env | none(false)]
+[$env | one(false)]
+[$env | one(ok)]
+[$env | sum(0)]
+[$env | sum(1)]
+[$env | sum(1.0)]
+[$env | sum(f64)]
+[$env, $env]?.[i]
+[$env, 0] | any(.ok)
+[$env, 1.0] | find(true)
+[$env, 1.0] | map(true)
+[$env, 1.0]?.[i]
+[$env, 1] | reduce(i, nil)
+[$env, false, i]?.[i]
+[$env, false] | reduce(#)
+[$env, foo] | groupBy(f64)
+[$env, foo] | reduce($env)
+[$env, ok]?.[i]
+[$env, true] | groupBy(foo)
+[$env, true] | map(foo)
+[$env.add, foo]
+[$env.add, list]
+[$env.add]
+[$env.array, i]
+[$env.array]
+[$env.f64, greet]
+[$env.f64, round(1.0)]
+[$env.f64, string($env)]
+[$env.f64]
+[$env.foo, foo]
+[$env.foo?.String()]
+[$env.foo]
+[$env.greet, 1 >= 1]
+[$env.greet, foo]
+[$env.greet]
+[$env.i, greet]
+[$env.i]
+[$env.list, add]
+[$env.list]
+[$env.ok]
+[$env.str, max(1.0)]
+[$env.str]
+[$env?.$env]
+[$env?.Bar]
+[$env?.String, add]
+[$env?.String, f64]
+[$env?.String]
+[$env?.[Bar], array]
+[$env?.[Bar], foo]
+[$env?.[Bar]]
+[$env?.[String], str]
+[$env?.[String]?.[foo]]
+[$env?.[String]]
+[$env?.[foobar]?.add?.add]
+[$env?.[foobar]]
+[$env?.[nil]]
+[$env?.[str], f64]
+[$env?.[str]]
+[$env?.add, foo]
+[$env?.add]
+[$env?.array | map(str)]
+[$env?.array, $env?.list]
+[$env?.array, array != $env]
+[$env?.array]
+[$env?.f64]
+[$env?.foo]
+[$env?.foobar, $env.add]
+[$env?.foobar?.ok]
+[$env?.foobar]
+[$env?.greet]
+[$env?.i, i < f64]
+[$env?.i]
+[$env?.list | map(#)]
+[$env?.list]
+[$env?.nil]
+[$env?.ok]
+[$env?.str]
+[$env] != list
+[$env] == 0 .. 1
+[$env] | any(#.ok)
+[$env] | concat(array)
+[$env] | count(#.ok)
+[$env] | count(ok)
+[$env] | filter(.ok)
+[$env] | filter(ok)
+[$env] | find(#.ok != .Bar)
+[$env] | find(#.ok)
+[$env] | findLastIndex(false)
+[$env] | groupBy(.add == ok)
+[$env] | groupBy(1)
+[$env] | groupBy(i)
+[$env] | map(#.String)
+[$env] | map($env)
+[$env] | map(.greet)
+[$env] | map(.str)
+[$env] | map(1)
+[$env] | map(1.0)
+[$env] | map(array)
+[$env] | map(foo)
+[$env] | map(true)
+[$env] | reduce(#)
+[$env] | reduce(#.add)
+[$env] | reduce(#.add?.[false])
+[$env] | reduce(#.f64 | map(#.str))
+[$env] | reduce(#.greet, greet)
+[$env] | reduce(#.greet?.[foo])
+[$env] | reduce(#.ok)
+[$env] | reduce($env)
+[$env] | reduce(.Bar, 0)
+[$env] | reduce(1)
+[$env] | reduce(1.0)
+[$env] | reduce(array)
+[$env] | reduce(foo)
+[$env] | reduce(i)
+[$env] | reduce(list, i)
+[$env] | reduce(ok)
+[$env] | reduce(str)
+[$env] | sortBy(#.list)
+[$env] | sortBy(#?.[.String])
+[$env] | sortBy(.array)
+[$env] | sortBy(1)
+[$env] | sortBy(array)
+[$env] | sortBy(false)
+[$env] | sortBy(foo)
+[$env] | sortBy(greet)
+[$env] | sortBy(list)
+[$env] | sum(#.f64)
+[$env] | sum(.f64)
+[$env] | sum(1.0)
+[$env][len(list):]
+[0 != $env]
+[0 != 0]
+[0 != 1.0]
+[0 != i]
+[0 != nil]
+[0 * 0]
+[0 * 1]
+[0 * f64]
+[0 ** 1.0]
+[0 ** 1]
+[0 + 1.0]
+[0 + f64]
+[0 - 0]
+[0 / f64]
+[0 / i]
+[0 < 0]
+[0 < 1.0]
+[0 < f64]
+[0 <= 0]
+[0 <= f64]
+[0 <= i]
+[0 == $env]
+[0 == 0]
+[0 == 1.0]
+[0 == i]
+[0 == nil]
+[0 > 0]
+[0 > 1]
+[0 > f64]
+[0 > i]
+[0 >= 1.0]
+[0 >= 1]
+[0 >= f64]
+[0 ^ 1]
+[0 in array]
+[0 not in array]
+[0 | median(1.0)]
+[0, $env] | count(false || true)
+[0, $env] | sortBy(1.0)
+[0, 0] | reduce(1.0, $env)
+[0, 1.0]?.[i]
+[0, add] | findLastIndex(ok)
+[0, foo][:]
+[0, greet]?.[i]
+[0, i] | any(false)
+[0, i]?.[i]
+[0, list]?.[i]
+[0, ok]?.[i]
+[0, str] | map(#)
+[0, true]?.[i]
+[0.0]
+[0.1]
+[0] | all(false)
+[0] | any(false)
+[0] | count(ok)
+[0] | findIndex(ok)
+[0] | groupBy(i)
+[0] | groupBy(true)
+[0] | map(#)
+[0] | map(array)
+[0] | map(f64)
+[0] | map(foo)
+[0] | reduce(#)
+[0] | reduce(0, nil)
+[0] | reduce(i)
+[0] | sortBy(#)
+[0] | sortBy(1.0)
+[0] | sortBy(foo)
+[0] | sortBy(str)
+[0] | sum(i)
+[1 != $env]
+[1 != 1.0]
+[1 != f64]
+[1 != nil]
+[1 * 0]
+[1 * 1.0]
+[1 * 1]
+[1 * f64]
+[1 ** f64]
+[1 + 0]
+[1 + 1.0]
+[1 + 1]
+[1 + f64]
+[1 - 0]
+[1 - 1.0]
+[1 - f64]
+[1 .. 1]
+[1 / 1.0]
+[1 / i]
+[1 < 0]
+[1 < 1.0, foo]
+[1 < 1.0]
+[1 < 1]
+[1 <= 1.0]
+[1 <= 1]
+[1 == $env]
+[1 == 1.0]
+[1 == 1]
+[1 == f64]
 [1 == i]
-[[f32]]
+[1 > 1.0]
+[1 >= 1.0]
+[1 >= i]
+[1 ^ f64]
+[1 | max(1.0)]
+[1 | median(1.0)]
+[1, $env]?.[i]
+[1, 1]?.[i]
+[1, false] | all(false)
+[1, false] | groupBy(true)
+[1, foo]?.[i]
+[1, greet] | reduce(#acc, 0)
+[1, nil] | reduce(add, array)
+[1, str, 0] | findLastIndex($env?.ok)
+[1, true] | findLastIndex(#)
+[1.0 != $env]
+[1.0 != 0]
+[1.0 != 1.0]
+[1.0 != 1]
+[1.0 != f64]
+[1.0 != i]
+[1.0 != nil]
+[1.0 * 0]
+[1.0 * 1.0]
+[1.0 * 1]
+[1.0 * i]
+[1.0 ** 1.0]
+[1.0 ** f64]
+[1.0 ** i]
+[1.0 + 0]
+[1.0 + 1.0]
+[1.0 + f64]
+[1.0 + i]
+[1.0 - 0]
+[1.0 - 1.0]
+[1.0 - 1]
+[1.0 - i]
+[1.0 / 0]
+[1.0 / 1]
+[1.0 / f64]
+[1.0 / i]
+[1.0 < 1.0]
+[1.0 < f64]
+[1.0 < i]
+[1.0 <= 1.0, foo]
+[1.0 <= 1.0]
+[1.0 <= 1]
+[1.0 <= f64]
+[1.0 <= i]
+[1.0 == $env]
+[1.0 == 0]
+[1.0 == 1.0]
+[1.0 == 1]
+[1.0 == f64]
+[1.0 == i]
+[1.0 == nil]
+[1.0 > 0]
+[1.0 > 1.0]
+[1.0 > 1]
+[1.0 >= 1.0]
+[1.0 >= 1]
+[1.0 >= f64]
+[1.0 >= i]
+[1.0 ^ 0]
+[1.0 ^ 1]
+[1.0 ^ f64]
+[1.0 ^ i]
+[1.0 in array, list]
+[1.0 | max(f64)]
+[1.0 | mean(f64)]
+[1.0, $env] | map(str)
+[1.0, $env] | reduce(array)
+[1.0, 0] | map(#)
+[1.0, 1.0] | sortBy(#)
+[1.0, f64] | reduce(#)
+[1.0, foo]?.[i]
+[1.0, greet] | reduce($env, list)
+[1.0, nil] | reduce(true)
+[1.0, nil] | sum(f64)
+[1.0, ok] | findLastIndex(true)
+[1.0, ok]?.[i]
+[1.0]
+[1.0] == list
+[1.0] | all(true)
+[1.0] | any(true)
+[1.0] | filter(ok)
+[1.0] | find(false)
+[1.0] | findLastIndex(false)
+[1.0] | groupBy(#)
+[1.0] | groupBy(0)
+[1.0] | groupBy(1)
+[1.0] | groupBy(f64)
+[1.0] | groupBy(foo)
+[1.0] | map(#index)
+[1.0] | map($env)
+[1.0] | map(1.0)
+[1.0] | map(add)
+[1.0] | map(foo)
+[1.0] | map(i)
+[1.0] | map(str)
+[1.0] | median(1.0)
+[1.0] | one(false)
+[1.0] | one(ok)
+[1.0] | one(true)
+[1.0] | reduce(#)
+[1.0] | reduce(#acc)
+[1.0] | reduce(#acc, foo)
+[1.0] | reduce($env)
+[1.0] | reduce(1.0)
+[1.0] | reduce(array)
+[1.0] | reduce(f64)
+[1.0] | sortBy(1)
+[1.0] | sortBy(false)
+[1.0] | sortBy(greet)
+[1.0] | sum(0)
+[1.0] | sum(1.0)
+[1.0][:]
+[1.1]
+[1] | filter(false)
+[1] | findIndex(true)
+[1] | groupBy(#)
+[1] | groupBy(foo)
+[1] | map(#)
+[1] | map(1.0)
+[1] | map(foo)
+[1] | reduce(#, foo)
+[1] | sortBy(#)
+[1] | sortBy(1.0)
+[1] | sortBy(array)
+[1] | sortBy(true)
+[1] | sum(#)
+[1] | sum(1.0)
+[[$env]]
+[[0]]
+[[1, ok]]
+[[1, true, true]]
+[[1.0, foo]]
+[[1.0], 1 / 1.0]
+[[1.0]]
+[[1]]
+[[add]]
+[[array]]
+[[f64, foo]]
+[[f64]]
+[[false, add]]
+[[false]]
+[[foo, 1]]
+[[foo, array]]
+[[foo], i]
+[[foo]]
+[[greet], $env?.String]
+[[greet]]
+[[i]]
+[[list, ok, foo]]
+[[list]]
+[[nil], i]
+[[nil]]
+[[ok, 0]]
+[[ok]]
+[[str]]
+[[true]]
+[[{foo: false, foo: add}]]
+[abs(0)]
+[abs(1)]
+[abs(1.0)]
+[abs(f64)]
+[abs(i)]
+[add != $env]
 [add != nil]
+[add == $env]
+[add == nil]
+[add(1, i)]
+[add(i, 1)]
+[add, $env != 1]
+[add, $env.foo]
+[add, $env?.[String]]
+[add, $env?.[str]]
+[add, $env?.greet]
+[add, 0] | map(add)
+[add, 1.0]?.[i]
+[add, [$env]]
 [add, add]
-[add, f32]
+[add, array]
+[add, f64]
+[add, false]?.[i]
+[add, foo]
+[add, foo] | groupBy(foo)
+[add, greet]
 [add, i]
+[add, list]
+[add, ok]
+[add, ok] | none(ok)
+[add, ok]?.[i]
+[add, str]
+[add, true]?.[i]
 [add]
-[all(list, false)]
-[any(list, ok)]
+[add] | all(true)
+[add] | findLastIndex(false)
+[add] | groupBy(true)
+[add] | map(#)
+[add] | map($env)
+[add] | map(1.0)
+[add] | map(add)
+[add] | map(ok)
+[add] | none(ok)
+[add] | reduce(#)
+[add] | reduce(#, add)
+[add] | reduce(#acc)
+[add] | reduce(foo, foo)
+[add] | sortBy($env)
+[add] | sum(1.0)
+[all($env, ok)]
+[all($env, true)]
+[all(list, ok)]
+[any(list, false)]
+[array != $env]
+[array != array]
+[array != nil]
+[array == $env]
+[array | findLast(false)]
+[array | groupBy(#)]
+[array | map(#)]
+[array | map(1)]
+[array | map(1.0)]
+[array | map(ok)]
+[array | one(false)]
+[array | one(true)]
+[array | reduce(#)]
+[array | reduce(#, false)]
+[array | reduce(#index)]
+[array | reduce(0)]
+[array | reduce(add)]
+[array | reduce(f64)]
+[array | reduce(foo, true)]
+[array | reduce(ok)]
+[array | sortBy(#)]
+[array | sortBy(1.0)]
+[array | sortBy(f64)]
+[array | sum(#), foo]
+[array | sum(1)]
+[array, $env.array]
+[array, $env?.[Bar]]
+[array, 0 == $env]
+[array, 1.0]?.[i]
 [array, add]
 [array, array]
-[array, f32]
+[array, f64]
+[array, f64] | findIndex(ok)
+[array, f64] | reduce(str)
+[array, f64]?.[i]
+[array, false, ok] | findLastIndex(#)
+[array, foo]
 [array, greet]
-[array, i64]
 [array, i]
+[array, i]?.[i]
 [array, list]
-[array, ok, add]
-[array, string(nil)]
+[array, nil] | sum(0)
+[array, ok]
+[array, ok] | reduce(true)
+[array, ok]?.[i]
+[array, str, ok]
+[array, str]
+[array?.[i]]
+[array[i:]]
 [array]
+[array] | map(#)
+[array] | reduce(#)
+[array] | reduce(#, 1.0)
+[array] | reduce(0)
+[array] | reduce(1.0)
+[array] | sortBy(#)
+[array] | sortBy(i)
+[array] | sum(0)
+[array] | sum(1.0)
+[array][:i]
+[bitnot(0)]
 [bitnot(1)]
-[ceil(i32)]
-[div(1, 1)]
-[div, add]
-[div, foo]
-[div, i32]
-[div, i64, array]
-[div]
-[f32 * i]
-[f32 + f64]
-[f32 >= i]
-[f32, f64]
-[f32, foo, greet]
-[f32, greet]
-[f32, i32]
-[f32, list]
-[f32, ok]
-[f32, score]
-[f32]
-[f64 + f64]
+[bitnot(i)]
+[ceil(0)]
+[ceil(1.0)]
+[ceil(f64)]
+[ceil(i)]
+[concat(array)]
+[concat(list)]
+[count($env, false)]
+[count(list, false)]
+[f64 != 0]
+[f64 != 1.0]
+[f64 != nil]
+[f64 * 1]
+[f64 * f64]
+[f64 * i]
+[f64 ** 0]
+[f64 ** 1]
+[f64 ** i]
+[f64 + 1.0]
+[f64 - 1]
+[f64 / 1]
 [f64 / f64]
-[f64 < 0.5]
-[f64 < f32]
-[f64 < i64]
-[f64 <= 1]
-[f64 in array]
+[f64 < 0]
+[f64 < 1.0]
+[f64 < f64]
+[f64 < i]
+[f64 <= f64]
+[f64 == $env]
+[f64 == 0]
+[f64 == f64]
+[f64 == i]
+[f64 == nil]
+[f64 > 1.0]
+[f64 > f64]
+[f64 >= 0]
+[f64 >= 1.0]
+[f64 ^ 1]
+[f64 not in array]
+[f64 | median(1.0)]
+[f64, $env == 1.0]
+[f64, $env.add]
+[f64, $env.list]
+[f64, $env?.String]
+[f64, 1.0 ^ i]
+[f64, 1.0] | map(0)
 [f64, add]
+[f64, array]
 [f64, f64]
-[f64, half]
-[f64, i64]
+[f64, foo]
+[f64, foo] | reduce(#)
+[f64, greet]
+[f64, i]
+[f64, i] | take(i)
+[f64, list]
+[f64, nil != foo]
+[f64, nil]?.[i]
+[f64, ok]
+[f64, str]
+[f64, str] | findLast(ok)
+[f64, {foo: 0}]
 [f64]
-[f64] == array
+[f64] | map(#)
+[f64] | map(1.0)
+[f64] | map(false)
+[f64] | map(foo)
+[f64] | map(greet)
+[f64] | reduce(1)
+[f64] | reduce(1.0)
+[f64] | reduce(f64)
+[f64] | reduce(false)
+[f64] | reduce(greet, true)
+[f64] | sortBy($env)
+[f64] | sortBy(0)
+[f64] | sum(#)
+[f64] | sum(1.0)
+[f64][:]
+[false != $env]
+[false != false]
+[false != nil]
+[false != true]
+[false && $env]
+[false && false]
+[false && true]
+[false == $env]
+[false == false]
+[false == nil]
+[false == ok]
+[false == true]
+[false ? 1.0 : foo]
+[false ?: 1.0]
+[false ?: foo]
+[false and $env]
+[false and ok]
+[false and true]
+[false or $env]
+[false or false]
+[false || $env]
+[false || false, list]
+[false, $env] | findIndex(true)
+[false, $env] | groupBy(1.0)
+[false, 1] != nil ? 1.0 : $env[add(false) == greet():]
+[false, 1]?.[i]
+[false, array] | reduce(0)
+[false, f64]?.[i]
+[false, greet]?.[i]
+[false, str] | groupBy(foo)
+[false] == $env?.Bar
+[false] | all(#)
+[false] | count(false)
+[false] | find(#)
+[false] | findLast(true)
+[false] | groupBy(#)
+[false] | groupBy(i)
+[false] | map(foo)
+[false] | map(list)
+[false] | none(#)
+[false] | reduce(false, add)
+[false] | reduce(list, foo)
+[false] | sortBy(false)
+[false] | sortBy(true)
+[false][:]
+[false][i:]
+[filter($env, false)]
+[filter(array, false)]
+[find(array, false)]
 [find(array, true)]
-[findIndex(list, false)]
-[findLast(list, ok)]
-[float(0.5)]
+[find(list, false)]
+[find(list, true)]
+[findIndex($env, true)]
+[findIndex(list, ok)]
+[findIndex(list, true)]
+[findLast(array, true)]
+[findLast(list, false), i]
+[findLastIndex($env, ok)]
+[findLastIndex(array, true)]
+[findLastIndex(list, true)]
+[first($env)]
+[first(array)]
+[first(list)]
+[flatten(array)]
+[flatten(list)]
+[float(0)]
 [float(1)]
+[float(1.0)]
+[float(f64)]
+[float(i)]
+[floor(0)]
+[floor(1), f64]
+[floor(1)]
+[floor(1.0)]
+[floor(f64)]
+[floor(i)]
+[foo != $env]
+[foo != foo, add]
+[foo != foo]
+[foo != nil]
+[foo == $env, list]
+[foo == $env]
+[foo == foo]
+[foo == nil]
+[foo not in list]
+[foo, $env] | map(1.0)
+[foo, $env]?.[i]
+[foo, 1.0, $env]?.[i]
+[foo, 1.0] | groupBy(1)
+[foo, 1.0] | one(ok)
+[foo, 1.0]?.[i]
+[foo, 1]?.[i]
+[foo, add, $env] | findLastIndex(ok)
+[foo, add, f64]
 [foo, add]
+[foo, add]?.[i]
 [foo, array]
-[foo, half]
+[foo, array] | reduce(i)
+[foo, array]?.[i]
+[foo, f64]
+[foo, f64] | count(false)
+[foo, false] | map(#)
+[foo, false]?.[i]
+[foo, foo != $env]
+[foo, foo]
+[foo, foo] | reduce(1.0)
+[foo, foo]?.[i]
+[foo, greet(str)]
+[foo, greet]
 [foo, i]
+[foo, i]?.[i]
+[foo, list]
+[foo, list]?.[i]
+[foo, mean(1)]
+[foo, nil, list] | map(#)
+[foo, nil]?.[i]
 [foo, ok]
-[foo, reduce(array, #)]
+[foo, str]
+[foo, true]?.[i]
+[foo, values($env)]
+[foo.Bar, ok]
 [foo.Bar]
-[foo.Qux]
-[foo?.Bar, f32, f64]
-[foo?.Bar, i32]
+[foo.String()]
+[foo.String, f64]
+[foo.String]
 [foo?.Bar]
-[foo?.Qux]
 [foo?.String()]
+[foo?.String, $env?.String]
+[foo?.String]
 [foo]
+[foo] in [nil]
+[foo] | all(ok)
+[foo] | all(true)
+[foo] | any(ok)
+[foo] | count(false)
+[foo] | filter(ok)
+[foo] | filter(true)
+[foo] | find(ok)
+[foo] | findLast(false)
+[foo] | findLastIndex(ok)
+[foo] | groupBy(#)
+[foo] | groupBy(#.Bar)
+[foo] | groupBy(foo)
+[foo] | map(#)
+[foo] | map(.String)
+[foo] | map(i)
+[foo] | map(list)
+[foo] | map(ok)
+[foo] | none(true)
+[foo] | reduce(#)
+[foo] | reduce(#, ok)
+[foo] | reduce(#index)
+[foo] | reduce(.Bar, 0)
+[foo] | reduce(0)
+[foo] | reduce(1)
+[foo] | reduce(1.0)
+[foo] | reduce(foo)
+[foo] | reduce(foo, list)
+[foo] | reduce(greet)
+[foo] | sortBy(#)
+[foo] | sortBy(#.String)
+[foo] | sortBy(.Bar)
+[foo] | sortBy(add)
+[foo] | sortBy(greet)
+[foo] | sortBy(i)
+[foo] | sortBy(str)
+[foo] | sum(i)
+[foo][:]
+[get($env, nil)]
+[get($env, str)]
 [greet != nil]
+[greet == $env]
+[greet == nil, array]
+[greet == nil]
+[greet(str), array]
+[greet(str)]
+[greet, $env.array]
+[greet, $env.greet]
+[greet, 1.0]?.[i]
+[greet, [array]]
+[greet, abs(1.0)]
+[greet, add]
+[greet, add] | reduce($env)
 [greet, array]
-[greet, div]
+[greet, f64]
+[greet, foo == $env]
 [greet, foo]
+[greet, foo] | none(true)
+[greet, foo]?.[i]
 [greet, greet]
-[greet, half]
-[greet, i64]
+[greet, i]
 [greet, list]
+[greet, nil]?.[i]
+[greet, ok]
+[greet, str]
+[greet, true]?.[i]
 [greet]
-[greet] == list
-[groupBy(array, "bar")]
-[groupBy(array, #), half]
+[greet] | any(false)
+[greet] | count(false)
+[greet] | groupBy(1)
+[greet] | groupBy(foo)
+[greet] | groupBy(true)
+[greet] | map($env)
+[greet] | map(i)
+[greet] | map(str)
+[greet] | reduce(#, array)
+[greet] | reduce(greet)
+[greet] | reduce(ok)
+[greet] | sum(f64)
+[greet][:i]
 [groupBy(array, #)]
-[groupBy(array, f64)]
-[groupBy(list, #)?.Qux]
-[half(0.5)]
-[half(f64)]
-[half(i64 ^ 1)]
-[half, array]
-[half, div]
-[half, f64]
-[half, i64 < f64]
-[half, list]
-[half]
-[i != i64]
-[i .. 1]
-[i / i]
-[i < i64, score]
-[i <= 0.5]
-[i == i32]
-[i >= i32]
+[groupBy(list, #)]
+[groupBy(list, 1.0)?.[i]]
+[groupBy(list, false)]
+[groupBy(list, foo)]
+[i != $env]
+[i != 0]
+[i != 1.0]
+[i != 1]
+[i != f64]
+[i % 1]
+[i % i]
+[i * 0]
+[i * 1]
+[i ** 0]
+[i ** 1.0]
+[i + 1.0]
+[i - f64]
+[i .. i]
+[i / 1]
+[i < 1.0]
+[i <= 1.0]
+[i <= 1]
+[i == $env]
+[i == 0]
+[i == 1]
+[i == f64]
+[i == nil]
+[i > f64]
+[i >= 1]
+[i ^ 1.0]
 [i ^ 1]
-[i, array, list]
+[i | max(array, i)]
+[i, $env?.String]
+[i, $env?.foobar]
+[i, 1.0]?.[i]
+[i, add]
 [i, array]
-[i, greet("bar")]
+[i, f64 > i]
+[i, f64]
+[i, f64] != array
+[i, foo?.String]
+[i, foo]
 [i, greet]
-[i, i32]
 [i, i]
 [i, list]
-[i32 < i]
-[i32 > 1]
-[i32, -1]
-[i32, div]
-[i32, f64]
-[i32, i32]
-[i32, list]
-[i32, type(greet)]
-[i32]
-[i64 != f64]
-[i64 + 0.5]
-[i64 / f64]
-[i64 <= i64]
-[i64 >= 1]
-[i64 ^ 1]
-[i64, div]
-[i64, foo]
-[i64, half]
-[i64, score]
-[i64]
+[i, nil in $env]
+[i, nil] | groupBy(1.0)
+[i, ok]
+[i, str]
+[i, sum(array)]
+[i, toJSON(0)]
+[i, true] | groupBy(true)
+[i..i]
 [i]
+[i] != list
+[i] == array
+[i] == list
+[i] | any(ok)
+[i] | find(false)
+[i] | groupBy(1)
+[i] | groupBy(1.0)
+[i] | map(#)
+[i] | map(false)
+[i] | reduce(add, i)
+[i] | reduce(str)
+[i] | sortBy(#)
+[i] | sortBy($env)
+[i] | sortBy(1.0)
+[i] | sum(#)
+[if false { $env } else { 1.0 }]
+[if false { $env } else { greet }]
+[if false { 1.0 } else { true }]
+[if false { foo } else { 1 }]
+[if false { foo } else { true }]
+[if ok { 1.0 } else { foo }]
+[if ok { false } else { 1.0 }]
+[if ok { nil } else { nil }]
+[if ok { true } else { 1.0 }, $env.f64]
+[if true { 0 } else { ok }]
+[if true { 1 } else { 0 }]
+[if true { f64 } else { 1 }]
+[if true { foo } else { 1 }]
+[if true { foo } else { add }]
+[if true { foo } else { ok }]
+[if true { nil } else { array }]
+[int(0)]
+[int(1)]
+[int(1.0)]
+[int(f64), foo]
+[int(f64)]
+[int(i)]
+[keys($env)]
+[last($env)]
+[last(array)]
+[last(list)]
+[len($env)]
+[len(array)]
+[len(list)]
+[len(str)]
+[len({foo: list})]
+[let foobar = 1.0; foobar]
+[list != list]
 [list != nil]
-[list, div]
-[list, f32]
+[list | findLast(false)]
+[list | groupBy(#)]
+[list | groupBy(1.0)]
+[list | groupBy(f64)]
+[list | map(#)]
+[list | map(foo)]
+[list | reduce(#)]
+[list | reduce(#, 0)]
+[list | reduce(#.String)]
+[list | reduce(#index, greet)]
+[list | reduce($env)]
+[list | reduce($env, foo)]
+[list | reduce(1.0, greet)]
+[list | reduce(array)]
+[list | reduce(foo)]
+[list | reduce(i)]
+[list | sortBy(1)]
+[list | sortBy(1.0)]
+[list, $env.foo]
+[list, $env?.String]
+[list, $env?.list]
+[list, 0 * i]
+[list, 0 ^ 1.0]
+[list, 0] | find(false)
+[list, 1.0 + 1.0]
+[list, 1.0]?.[i]
+[list, add]
+[list, add] | map(#)
+[list, add]?.[i]
+[list, array]
+[list, f64]
+[list, f64]?.[i]
+[list, false, 1] | reduce(foo)
+[list, foo]
+[list, foo] | groupBy(foo)
 [list, greet]
-[list, half]
+[list, i ^ 1.0]
 [list, i]
+[list, list]
 [list, ok]
+[list, str, str]
+[list, str]
+[list, toJSON(nil)]
+[list, true != $env]
+[list?.[0]]
+[list?.[i]]
 [list]
+[list] != list
+[list] == array
+[list] | filter(ok)
+[list] | findIndex(ok)
+[list] | findLast(false)
+[list] | groupBy($env.foo)
+[list] | map(add)
+[list] | map(i)
+[list] | map(true)
+[list] | none(ok)
+[list] | one(true)
+[list] | reduce(1)
+[list] | reduce(foo)
+[list] | reduce(foo, false)
+[list] | sortBy(#)
+[list] | sortBy(add)
+[list] | sortBy(foo)
+[list] | sortBy(i)
+[list] | sortBy(str)
+[lower(str)]
+[map($env, $env)]
+[map($env, list)]
+[map($env, str)]
 [map(array, #)]
-[map(array, add)]
-[map(array, f64)]
-[map(array, foo)]
-[max(1)]
-[nil != 0.5]
-[not false]
+[map(array, $env)]
+[map(array, 1)]
+[map(array, 1.0), foo]
+[map(array, false)]
+[map(array, str), ok]
+[map(array, str)]
+[map(list, #)]
+[map(list, $env)]
+[map(list, 0)]
+[map(list, ok)]
+[map(list, str)]
+[max($env), f64]
+[max($env)]
+[max(0)]
+[max(1.0)]
+[max(array) ^ f64]
+[max(array)]
+[max(array, 1.0)]
+[max(f64)]
+[mean(0)]
+[mean(1)]
+[mean(1.0)]
+[mean(array)]
+[mean(f64)]
+[mean(i)]
+[median(0)]
+[median(1)]
+[median(1.0)]
+[median(array)]
+[median(f64)]
+[median(floor(0))]
+[median(i)]
+[min($env)]
+[min(0)]
+[min(1)]
+[min(1.0)]
+[min(array)]
+[min(f64)]
+[nil != $env]
+[nil != 0]
+[nil != 1.0]
+[nil != f64]
+[nil != foo]
+[nil != greet]
+[nil != list]
+[nil != nil]
+[nil != ok]
+[nil != str]
+[nil != true]
+[nil == $env, foo]
+[nil == 0]
+[nil == 1.0]
+[nil == add]
+[nil == array]
+[nil == f64]
+[nil == false, str]
+[nil == false]
+[nil == foo]
+[nil == greet]
+[nil == list]
+[nil == nil]
+[nil == ok]
+[nil == str]
+[nil == true]
+[nil in $env]
+[nil in list]
+[nil not in $env]
+[nil not in list]
+[nil, 0]?.[i]
+[nil, 1.0] | none(true)
+[nil, 1.0] | reduce(#)
+[nil, 1.0]?.[i]
+[nil, 1]?.[i]
+[nil, add] | none(false)
+[nil, add]?.[i]
+[nil, f64] | groupBy(str)
+[nil, foo] | findLast(ok)
+[nil, foo]?.[i]
+[nil, nil, $env]?.[i]
+[nil, nil, array]?.[i]
+[nil, str, 1.0] | map(#)
+[nil, true]?.[i]
+[nil] == list
+[nil] | count(ok)
+[nil] | findIndex(true)
+[nil] | findLast(false)
+[nil] | groupBy(0)
+[nil] | groupBy(str)
+[nil] | map(1.0)
+[nil] | map(f64)
+[nil] | one(ok)
+[nil] | reduce(0)
+[nil] | reduce(array)
+[nil] | reduce(array, array)
+[nil] | reduce(false)
+[nil] | reduce(i)
+[nil] | reduce(ok)
+[nil] | reduce(true)
+[nil] | sortBy(0)
+[nil] | sortBy(false)
+[nil] | sortBy(foo)
+[nil] | sortBy(true)
+[nil] | sum(1)
+[nil] | sum(1.0)
+[none($env, true)]
+[none(array, false)]
+[ok != $env]
+[ok != nil]
+[ok && ok]
+[ok == $env]
+[ok == false]
+[ok == nil]
+[ok == true]
 [ok ? 1 : greet]
-[ok, f32]
-[ok, half]
-[ok, i64]
+[ok ? str : i, add]
+[ok ?: 0]
+[ok and $env]
+[ok and ok, ok]
+[ok and true]
+[ok or $env]
+[ok or false]
+[ok or ok]
+[ok or true]
+[ok || $env]
+[ok || false]
+[ok, $env?.[str]]
+[ok, $env?.str]
+[ok, $env] | find(#)
+[ok, $env] | map(false)
+[ok, 1.0 == 1.0]
+[ok, 1] | map(1.0)
+[ok, add]
+[ok, array]
+[ok, array]?.[i]
+[ok, f64]
+[ok, floor(0)]
+[ok, foo not in list]
+[ok, foo?.String]
+[ok, foo]
+[ok, foo] | map(f64)
+[ok, foo]?.[i]
+[ok, greet]
 [ok, i]
-[ok, list, 0.5] == list
+[ok, int(f64)]
+[ok, list]
+[ok, list] | findIndex(false)
+[ok, list]?.[i]
+[ok, nil] | find(#)
 [ok, ok]
+[ok, reduce(list, str)]
+[ok, str]
+[ok, str] | reduce(foo)
+[ok, string(add)]
 [ok]
+[ok] != array
+[ok] | all(#)
+[ok] | any(#)
+[ok] | count(#)
+[ok] | findLast(false)
+[ok] | reduce(1.0)
+[ok] | reduce(foo)
+[ok] | sortBy(f64)
+[ok] | sum(f64)
+[one($env, false)]
+[one($env, ok)]
+[reduce(array, #)]
+[reduce(array, $env)]
+[reduce(array, $env, f64)]
+[reduce(array, array)]
+[reduce(array, false)]
 [reduce(array, foo)]
-[reduce(list, #)]
-[reduce(list, div)]
-[score == nil]
-[score, div]
-[score, f32]
-[score, f64]
-[score, greet]
-[score, half]
-[score, one(array, # > i32)]
-[score, score]
-[score]
-[string(0.5)]
+[reduce(array, true)]
+[reduce(list, .String)]
+[reduce(list, add)]
+[reduce(list, foo)]
+[reduce(list, i)]
+[reduce(list, list)]
+[reverse(array)]
+[round(0)]
+[round(1)]
+[round(1.0)]
+[round(f64)]
+[round(i)]
+[sort($env)?.[i], foo]
+[sort($env)]
+[sort(array)]
+[sortBy(array, 1.0)]
+[sortBy(array, i)]
+[sortBy(list, 1)]
+[str != nil]
+[str < str]
+[str <= str]
+[str contains str]
+[str in $env]
+[str in foo]
+[str not contains str]
+[str not in $env]
+[str not in foo]
+[str not matches str]
+[str not startsWith str]
+[str | greet()]
+[str, $env == false]
+[str, $env?.[Bar]]
+[str, $env?.ok]
+[str, 0] | reduce(false, foo)
+[str, 1]?.[i]
+[str, add]
+[str, array]
+[str, f64 ** 1]
+[str, f64 > i]
+[str, f64]
+[str, false != nil]
+[str, false]?.[i]
+[str, foo.Bar]
+[str, foo]
+[str, greet]
+[str, i]
+[str, list | findLastIndex(true)]
+[str, list]
+[str, list] | any(false)
+[str, map(list, $env)]
+[str, nil]?.[i]
+[str, ok]
+[str, str, 0]?.[i]
+[str, str]
+[str[1:]]
+[str]
+[str] == array
+[str] | all(false)
+[str] | any(ok)
+[str] | count(true)
+[str] | filter(ok)
+[str] | findLastIndex(false)
+[str] | groupBy(#)
+[str] | one(ok)
+[str] | one(true)
+[str] | reduce(#)
+[str] | reduce(#acc)
+[str] | reduce(false)
+[str] | sortBy($env)
+[str] | sortBy(1.0)
+[str] | sortBy(foo)
+[str] | sum(abs(0))
+[str][i:]
+[string($env)]
+[string($env.f64)]
+[string(0)]
 [string(1)]
+[string(1.0)]
+[string(add)]
+[string(array)]
+[string(f64)]
+[string(false)]
+[string(foo), add]
 [string(foo)]
+[string(greet)]
 [string(i)]
-[string(i64)]
+[string(list) not in $env?.foobar]
+[string(list)]
+[string(nil)]
+[sum(array)]
+[sum(array, #)]
+[sum(array, 1)]
+[sum(array, i)]
+[toBase64(str)]
+[toBase64(string(1.0))]
+[toJSON($env.foo)]
+[toJSON(0)]
+[toJSON(1)]
+[toJSON(1.0)]
+[toJSON(array)]
+[toJSON(false), str]
+[toJSON(false)]
+[toJSON(foo)]
+[toJSON(i)]
 [toJSON(list)]
-[trimPrefix("bar")]
-[true ? add : f64]
-[true and ok]
-[true || ok]
-[type(1)]
+[toJSON(nil), foo.Bar]
+[toJSON(nil)]
+[toJSON(ok)]
+[toJSON(true)]
+[toPairs($env)]
+[trim(str)]
+[trimPrefix(str)]
+[true != false]
+[true != nil]
+[true && $env, list]
+[true && $env]
+[true && false, array]
+[true == $env]
+[true == nil]
+[true ? $env : 1.0]
+[true ?: 1]
+[true ?: array]
+[true ?: list]
+[true and $env]
+[true and true]
+[true or true]
+[true || $env]
+[true || true]
+[true, 1] == $env?.array
+[true, add] | findLast(true)
+[true, add] | reduce(array, greet)
+[true, add]?.[i]
+[true, foo] | find(#)
+[true, foo]?.[i]
+[true, list]?.[i]
+[true, nil]?.[i]
+[true, ok] | find(true)
+[true, ok]?.[i]
+[true] != [array]
+[true] in $env?.foobar
+[true] | all(#)
+[true] | any(#)
+[true] | any(false)
+[true] | findIndex(#)
+[true] | findLastIndex(false)
+[true] | groupBy(1.0)
+[true] | map(1.0)
+[true] | none(true)
+[true] | one(false)
+[true] | reduce($env)
+[true] | reduce($env, str)
+[true] | reduce(1.0)
+[true] | sortBy(#)
+[true] | sortBy(greet)
+[true] | sortBy(true)
+[true] | sum(1)
+[true] | sum(1.0)
+[type($env)]
+[type(0)]
+[type(1.0)]
 [type(add)]
-[type(div)]
+[type(array)]
+[type(f64)]
+[type(false)]
+[type(foo)]
 [type(greet)]
-[type(nil)]
-abs(-0.5)
-abs(-1)
-abs(-f32)
-abs(-f64)
-abs(-i)
-abs(-i32)
-abs(-i64)
-abs(0.5 * 0.5)
-abs(0.5 * 1)
-abs(0.5 * i)
-abs(0.5 * i64)
-abs(0.5 ** 0.5)
-abs(0.5 ** 1)
-abs(0.5 ** i32)
-abs(0.5 + 0.5)
-abs(0.5 + 1)
-abs(0.5 + f32)
-abs(0.5 + i)
-abs(0.5 + i64)
-abs(0.5 - 0.5)
-abs(0.5 - 1)
-abs(0.5 - i)
-abs(0.5 - i32)
-abs(0.5 - i64)
-abs(0.5 / 0.5)
-abs(0.5 / 1)
-abs(0.5 / f64)
-abs(0.5 ^ 0.5)
-abs(0.5 ^ 1)
-abs(0.5 ^ f32)
-abs(0.5) - i32
-abs(0.5) / f32
-abs(0.5) < f64
-abs(0.5) < i32
-abs(0.5) <= i64
-abs(0.5) == -0.5
-abs(0.5) == half(1)
-abs(0.5) > i32
-abs(0.5) >= f64
-abs(0.5) ^ i64
-abs(0.5) not in array
-abs(1 * f32)
+[type(list), array]
+[type(list)]
+[type(ok)]
+[type(str), foo]?.[i]
+[type(str)]
+[type(true)]
+[uniq(array)]
+[uniq(list)]
+[upper(str)]
+[values($env)]
+[{foo: $env, foo: nil}]
+[{foo: $env}]
+[{foo: 0, foo: 1.0}]
+[{foo: 0, foo: nil}]
+[{foo: 0, foo: true}]
+[{foo: 0}]
+[{foo: 1.0}.add]
+[{foo: 1.0}]
+[{foo: 1}]
+[{foo: add, foo: i}]
+[{foo: add, foo: str}]
+[{foo: add}]
+[{foo: array}]
+[{foo: f64}]
+[{foo: false, foo: 0}]
+[{foo: false}]
+[{foo: foo, foo: false}]
+[{foo: foo}]
+[{foo: greet, foo: f64, foo: 0}]
+[{foo: greet}]
+[{foo: i, foo: $env}]
+[{foo: i}]
+[{foo: list, foo: foo}]
+[{foo: list}]
+[{foo: nil, foo: 1.0}]
+[{foo: nil, foo: i}]
+[{foo: nil, foo: str}]
+[{foo: nil}]
+[{foo: ok}?.foo]
+[{foo: ok}]
+[{foo: str}]
+[{foo: true}]
+abs($env | count(true))
+abs($env | sum(1))
+abs($env | sum(1.0))
+abs($env.f64)
+abs($env.i)
+abs($env?.f64)
+abs($env?.i)
+abs(0 * 1.0)
+abs(0 ** f64)
+abs(0 + 0)
+abs(0 + 1.0)
+abs(0 + i)
+abs(0 - 1.0)
+abs(0 - f64)
+abs(0 - i)
+abs(0 / 0)
+abs(0 ^ 1.0)
+abs(0 | mean(i, i))
+abs(0) * f64
+abs(0) - i
+abs(0) / f64
+abs(0) in array
+abs(0.1)
+abs(1 % 1)
+abs(1 % i)
 abs(1 * f64)
-abs(1 * i32)
-abs(1 ** 0.5)
 abs(1 ** 1)
-abs(1 ** i)
-abs(1 + 1)
-abs(1 + i)
-abs(1 + i64)
-abs(1 - 0.5)
+abs(1 ** 1.0)
+abs(1 ** f64)
+abs(1 + 0)
 abs(1 - 1)
-abs(1 - i64)
-abs(1 / 0.5)
-abs(1 / 1)
+abs(1 - 1.0)
+abs(1 - f64)
 abs(1 / i)
-abs(1 / i32)
-abs(1 ^ f32)
+abs(1 ^ 0)
+abs(1 ^ 1)
 abs(1 ^ i)
-abs(1 ^ i32)
-abs(1) - i32
-abs(1) .. i
-abs(1) / f64
-abs(1) / i64
-abs(1) < i64
-abs(1) <= i32
-abs(1) == i32
+abs(1 | max(array))
+abs(1) + f64
+abs(1) < f64
+abs(1) < i
 abs(1) >= i
-abs(1) ^ f64
-abs(abs(0.5))
-abs(abs(1))
+abs(1) | mean(i)
+abs(1.0 * 0)
+abs(1.0 * 1)
+abs(1.0 * 1.0)
+abs(1.0 * i)
+abs(1.0 ** 0)
+abs(1.0 ** 1)
+abs(1.0 ** 1.0)
+abs(1.0 ** i)
+abs(1.0 + 1)
+abs(1.0 + 1.0)
+abs(1.0 + f64)
+abs(1.0 - 1)
+abs(1.0 - 1.0)
+abs(1.0 - i)
+abs(1.0 / 0)
+abs(1.0 / 1)
+abs(1.0 / 1.0)
+abs(1.0 ^ 0)
+abs(1.0 ^ 1)
+abs(1.0 ^ 1.0)
+abs(1.0 ^ f64)
+abs(1.0 ^ i)
+abs(1.0 | mean(array))
+abs(1.0) != f64
+abs(1.0) * i
+abs(1.0) ** f64
+abs(1.0) + count(list, false)
+abs(1.0) - f64
+abs(1.0) / 0 in array
+abs(1.0) / f64
+abs(1.0) <= reduce(array, #)
+abs(1.0) == i
+abs(1.0) ^ f64 > 0
+abs(1.0) ^ i
+abs(1.0) in $env?.[String]
+abs(1.0) in array
+abs(abs(1.0))
 abs(abs(f64))
-abs(abs(i32))
-abs(abs(i64))
-abs(add(i, 1))
-abs(bitand(i64, i32))
-abs(bitnand(i64, i))
+abs(add(1, 1))
+abs(array | count(true))
+abs(array | find(ok))
+abs(array | findLast(true))
+abs(array | reduce(#))
+abs(array | reduce(#acc))
+abs(array | reduce(#index))
+abs(array | reduce(0))
+abs(array | reduce(0, array))
+abs(array | reduce(1.0))
+abs(array | reduce(1.0, foo))
+abs(array?.[i])
+abs(bitnot(0))
 abs(bitnot(1))
 abs(bitnot(i))
-abs(bitnot(i32))
-abs(bitnot(i64))
-abs(bitushr(1, 1))
-abs(ceil(0.5))
+abs(bitor(0, 0))
+abs(ceil(0))
 abs(ceil(1))
-abs(ceil(f32))
-abs(ceil(i))
-abs(ceil(i32))
-abs(ceil(i64))
-abs(count(array, ok))
-abs(count(array, true))
-abs(count(list, false))
-abs(div(i, i))
-abs(f32 * 0.5)
-abs(f32 ** 1)
-abs(f32 ** f32)
-abs(f32 ** i32)
-abs(f32 + 0.5)
-abs(f32 + 1)
-abs(f32 + i)
-abs(f32 + i32)
-abs(f32 - 0.5)
-abs(f32 - 1)
-abs(f32 - i32)
-abs(f32 - i64)
-abs(f32 / 0.5)
-abs(f32 / 1)
-abs(f32 / f32)
-abs(f32 / f64)
-abs(f32 / i32)
-abs(f32 ^ i)
-abs(f32 ^ i64)
-abs(f32)
-abs(f32) ** f32
-abs(f32) ** i
-abs(f32) + i64
-abs(f32) - i32
-abs(f32) / f64
-abs(f32) < f64
-abs(f32) >= 0.5 / 1
-abs(f32) ^ f32
-abs(f64 * f32)
+abs(count($env, false))
+abs(count($env, true))
+abs(f64 * 1)
+abs(f64 * 1.0)
 abs(f64 * f64)
+abs(f64 * i)
+abs(f64 ** 0)
 abs(f64 ** 1)
-abs(f64 + 0.5)
-abs(f64 + 1)
+abs(f64 ** 1.0)
+abs(f64 + 0)
+abs(f64 + 1.0)
 abs(f64 + f64)
 abs(f64 - 1)
-abs(f64 - f32)
-abs(f64 / 0.5)
-abs(f64 / 1)
+abs(f64 - i)
 abs(f64 / f64)
-abs(f64 / i)
-abs(f64 ^ 0.5)
-abs(f64 ^ f32)
+abs(f64 ^ 0)
+abs(f64 ^ 1.0)
 abs(f64 ^ i)
-abs(f64 ^ i64)
 abs(f64)
-abs(f64) + f32
-abs(f64) + f64
-abs(f64) + i32
-abs(f64) + i64 / i
-abs(f64) - i
-abs(f64) < i32
-abs(f64) <= f64
-abs(f64) > i64
-abs(f64) ^ f32
-abs(f64) ^ i64
-abs(f64) in array
-abs(false ? f32 : 1)
-abs(false ? half : 0.5)
-abs(false ? list : 1)
-abs(find(array, ok))
-abs(find(array, true))
-abs(findIndex(list, ok))
-abs(findIndex(list, true))
-abs(findLastIndex(array, ok))
+abs(f64) != f64
+abs(f64) != i
+abs(f64) + i
+abs(f64) - f64
+abs(f64) / i
+abs(findIndex($env, true))
 abs(first(array))
-abs(float(0.5))
-abs(float(1))
-abs(float(f32))
+abs(float(0))
+abs(float(1.0))
 abs(float(f64))
-abs(float(i))
-abs(float(i32))
-abs(floor(0.5))
-abs(floor(f32))
-abs(floor(i32))
-abs(get(array, 1))
-abs(get(array, i))
-abs(get(array, i32))
-abs(get(array, i64))
-abs(half(0.5))
-abs(half(1))
-abs(half(f64))
-abs(i * 1)
-abs(i * f32)
-abs(i ** 1)
-abs(i ** f32)
-abs(i ** i32)
-abs(i + 0.5)
-abs(i + f64)
-abs(i - 0.5)
-abs(i - 1)
-abs(i - f32)
-abs(i - f64)
-abs(i - i32)
-abs(i / 0.5)
-abs(i / f64)
+abs(floor(1))
+abs(floor(1.0))
+abs(i % i)
+abs(i * 0)
+abs(i * f64)
+abs(i ** 0)
+abs(i ** 1.0)
+abs(i + 0)
+abs(i + i)
+abs(i - 1.0)
+abs(i / 1.0)
 abs(i / i)
-abs(i / i32)
-abs(i / i64)
-abs(i ^ 0.5)
-abs(i ^ f64)
-abs(i ^ i)
-abs(i ^ i32)
-abs(i ^ i64)
+abs(i ^ 1.0)
+abs(i | bitshl(0))
 abs(i)
-abs(i) % i
-abs(i) * i32
-abs(i) ** f32
 abs(i) + f64
-abs(i) - f32
-abs(i) .. i
-abs(i) .. i32
-abs(i) / f32
-abs(i) < f64
-abs(i) <= i64
-abs(i) == 0.5 / i
-abs(i) > i64
-abs(i) ^ f64
-abs(i) ^ half(1)
 abs(i) ^ i
-abs(i) ^ i32
-abs(i32 % i32)
-abs(i32 % i64)
-abs(i32 * f64)
-abs(i32 * i32)
-abs(i32 ** 0.5)
-abs(i32 ** 1)
-abs(i32 ** i32)
-abs(i32 + 0.5)
-abs(i32 + 1)
-abs(i32 + f64)
-abs(i32 + i)
-abs(i32 + i32)
-abs(i32 - 0.5)
-abs(i32 - i64)
-abs(i32 / 0.5)
-abs(i32 / i)
-abs(i32 / i64)
-abs(i32)
-abs(i32) != f64
-abs(i32) * f32
-abs(i32) * i
-abs(i32) ** i
-abs(i32) - i32
-abs(i32) / -1
-abs(i32) / i32 ** f64
-abs(i32) < i64 == false
-abs(i32) <= i
-abs(i32) <= i32
-abs(i32) == i32
-abs(i32) ^ i64
-abs(i32) in array
-abs(i64 * 0.5)
-abs(i64 * f32)
-abs(i64 * i32)
-abs(i64 ** 0.5)
-abs(i64 ** f64)
-abs(i64 ** i64)
-abs(i64 + 0.5)
-abs(i64 + 1)
-abs(i64 + f32)
-abs(i64 + f64)
-abs(i64 + i)
-abs(i64 - 0.5)
-abs(i64 - i)
-abs(i64 / f32)
-abs(i64 / i32)
-abs(i64 ^ f64)
-abs(i64 ^ i)
-abs(i64 ^ i32)
-abs(i64)
-abs(i64) * i32
-abs(i64) ** i
-abs(i64) + f32
-abs(i64) / i
-abs(i64) > i32
-abs(i64) ^ i32
-abs(i64) not in array
-abs(int(0.5))
+abs(i) not in array
+abs(i) | bitshr(0)
+abs(if false { array } else { 1 })
+abs(if false { array } else { i })
+abs(if true { i } else { i })
+abs(int(0))
 abs(int(1))
+abs(int(1.0))
 abs(int(i))
-abs(int(i32))
-abs(int(i64))
 abs(last(array))
-abs(len("foo"))
-abs(len(list))
-abs(max(0.5))
-abs(max(f32))
+abs(len($env))
+abs(len(str))
+abs(list | findIndex(ok))
+abs(list | findIndex(true))
+abs(list | reduce(1))
+abs(list | sum(1.0))
+abs(max(0))
+abs(max(1))
+abs(max(1.0))
+abs(max(array))
 abs(max(f64))
-abs(max(i32))
-abs(max(i64))
+abs(max(f64, f64))
+abs(max(i))
+abs(mean(0))
+abs(mean(1))
+abs(mean(1.0))
 abs(mean(array))
+abs(mean(f64))
+abs(mean(i))
+abs(median(0))
+abs(median(1))
+abs(median(1.0))
 abs(median(array))
-abs(min(0.5))
-abs(min(1))
-abs(min(f32))
-abs(min(f64))
+abs(median(f64))
+abs(median(f64, array))
+abs(median(i))
+abs(min(0))
+abs(min(1.0))
+abs(min(array))
 abs(min(i))
-abs(min(i32))
-abs(ok ? 1 : "foo")
-abs(ok ? f32 : 0.5)
-abs(ok ? f32 : nil)
-abs(ok ? f64 : ok)
-abs(ok ? i32 : foo)
 abs(reduce(array, #))
+abs(reduce(array, #, nil))
 abs(reduce(array, i))
+abs(reduce(list, 0))
 abs(reduce(list, 1))
-abs(reduce(list, i32))
-abs(round(0.5))
+abs(round(0))
 abs(round(1))
-abs(round(f32))
-abs(round(i))
-abs(round(i64))
-abs(score(1))
-abs(score(i))
+abs(round(1.0))
+abs(sum($env, 1.0))
 abs(sum(array))
-abs(true ? 1 : ok)
+abs(sum(array, #))
+abs(sum(array, 0))
+abs(sum(array, f64))
+abs(sum(list, 1.0))
 add
+add != $env && $env?.ok
+add != $env == $env
+add != $env or ok
+add != $env.add
+add != $env?.Bar
+add != $env?.String
+add != $env?.[Bar]
+add != $env?.[String]
+add != $env?.[foobar?.[foobar]]
+add != $env?.[foobar]
+add != $env?.[str]
+add != $env?.add
+add != $env?.add ?: foo
+add != $env?.foobar
+add != $env?.foobar?.[array]
 add != add
-add != add == nil
-add != div
-add != div != false
-add != div == true
-add != nil ? f64 : i64
-add != reduce(list, add)
+add != nil && $env
+add != nil ?: false
+add != nil || true
+add == $env ? 0 : 1
+add == $env ? array : ok
+add == $env.add
+add == $env?.Bar
+add == $env?.Bar?.[str]
+add == $env?.String
+add == $env?.String?.ok()
+add == $env?.[Bar]
+add == $env?.[String]
+add == $env?.[foobar]
+add == $env?.[str]
+add == $env?.add
+add == $env?.foobar
 add == add
-add == add != nil
-add == add == nil
-add == add ? 1 : i64
-add == div
-add == div ? f64 : list
-add == nil ? false : i32
-add == nil ? greet : i32
-add == nil ? nil : nil
-add in sort(array)
-add(1, i) < i
-add(i, 1) ** f32
+add == last($env)
+add == max($env)
+add == nil != $env?.[Bar]
+add == nil && $env[foobar:foobar]
+add == nil || $env
+add == nil || false
+add in $env?.Bar
+add in $env?.String
+add in $env?.[Bar]
+add in $env?.[String]
+add in $env?.[String]?.add
+add in $env?.[String]?.array
+add in $env?.[foobar]
+add in $env?.foobar
+add in $env?.foobar?.str()?.greet
+add in [$env, $env]
+add in keys($env)
+add in values($env)
+add in {foo: add}?.add
+add not in $env?.Bar
+add not in $env?.String
+add not in $env?.[Bar]
+add not in $env?.[String]
+add not in $env?.[foobar]
+add not in $env?.foobar
+add not in $env?.foobar == false
+add not in $env?.foobar?.[str]
+add not in $env?.true?.[greet]
+add not in first($env)
+add not in keys($env)
+add not in reverse(list)
+add not in {foo: 1}?.array
+add($env.i, i)
+add(0, 1) * f64
+add(i, 1) >= f64 > i
+add(i, array?.[i])
 add(i, i)
-add(i, i32 + 1)
-all(1 .. i64, ok)
-all(["bar"], # >= #)
-all(["foo"], # not matches #)
-all([false], # && false)
-all([false], #)
-all(array, !(# >= f64))
-all(array, !ok)
-all(array, !true)
-all(array, "foo" < "bar")
-all(array, # != #)
-all(array, # != 1)
-all(array, # != f32)
-all(array, # != f64)
-all(array, # != i32)
-all(array, # != nil)
+add(i, list | sum(i))
+add(min(0, i), i)
+add(sum(array), i)
+add; $env.array
+add; add
+add; greet
+add; list
+add; ok
+add; {foo: f64}
+all($env | filter(false), #[.ok:$env])
+all($env, true) and ok
+all($env.array, 1 > #)
+all($env.list, $env == #)
+all($env?.list, nil == $env)
+all([$env], ok)
+all([list], 1.0 < 1.0)
 all(array, # < #)
-all(array, # < 0.5)
-all(array, # < 1)
-all(array, # < f64)
-all(array, # < i)
-all(array, # < i64)
 all(array, # <= #)
-all(array, # <= 0.5)
-all(array, # <= i)
-all(array, # == # + #)
 all(array, # == #)
-all(array, # == 0.5)
-all(array, # == 1)
-all(array, # == f64)
-all(array, # == i)
-all(array, # == i32)
-all(array, # == i64)
+all(array, # == $env)
+all(array, # == 0)
 all(array, # > #)
-all(array, # > 0.5)
-all(array, # > 1)
-all(array, # > f64)
-all(array, # > i)
-all(array, # > i32)
-all(array, # > i64)
 all(array, # >= #)
-all(array, # >= 0.5)
-all(array, # >= f32)
-all(array, # >= f64)
-all(array, # >= i32)
-all(array, # >= i64)
-all(array, # in array)
-all(array, 0.5 != #)
-all(array, 0.5 < #)
-all(array, 0.5 < f32)
-all(array, 0.5 <= #)
-all(array, 0.5 <= f32)
-all(array, 0.5 <= i)
-all(array, 0.5 > f32)
-all(array, 0.5 > f64)
-all(array, 0.5 > i32)
-all(array, 0.5 >= #)
-all(array, 0.5 >= 0.5)
-all(array, 0.5 in array)
-all(array, 1 != #)
-all(array, 1 != f32)
-all(array, 1 < #)
-all(array, 1 < f32)
-all(array, 1 == #)
-all(array, 1 > #)
-all(array, 1 > i64)
-all(array, 1 >= #)
-all(array, 1 >= 1)
-all(array, 1 >= i64)
-all(array, f32 < #)
-all(array, f32 <= #)
-all(array, f32 <= f32)
-all(array, f32 > i)
-all(array, f32 >= #)
-all(array, f64 != #)
-all(array, f64 <= #)
-all(array, f64 <= f32)
-all(array, f64 == #)
-all(array, f64 == 0.5)
-all(array, f64 == i64)
-all(array, f64 >= i64)
-all(array, false && true)
-all(array, false ? 1 : true)
-all(array, i != 0.5)
-all(array, i <= 0.5)
-all(array, i <= f32)
-all(array, i <= i32)
-all(array, i == #)
-all(array, i32 != #)
-all(array, i32 != i64)
-all(array, i32 < i)
-all(array, i32 >= #)
-all(array, i64 != #)
-all(array, i64 != i64)
-all(array, i64 == i32)
-all(array, i64 > #)
-all(array, i64 > 0.5)
-all(array, i64 >= #)
-all(array, nil != "bar")
-all(array, nil != #)
-all(array, nil != list)
-all(array, nil != ok)
-all(array, nil == "foo")
-all(array, nil == i32)
-all(array, nil == list)
-all(array, none(list, true))
-all(array, not false)
-all(array, not true)
+all(array, $env != #)
+all(array, $env == #)
+all(array, 1.0 > 0)
+all(array, i >= 1)
+all(array, list | one(true))
+all(array, nil != nil)
+all(array, nil == true)
 all(array, ok)
-all(false ? add : "bar", ok)
-all(filter(array, true), ok)
-all(groupBy(array, f32).score, 0.5 in #?.f64)
-all(groupBy(list, #).i, #?.half() not in # + #)
-all(i32 .. 1, ok)
-all(list, !false)
-all(list, "bar" in #)
-all(list, "bar" not in #)
-all(list, "foo" > "foo")
+all(array, ok) || $env?.Bar
+all(array, str == nil)
+all(array, str startsWith str)
+all(array, true or $env)
+all(list | map(true), #)
 all(list, # != #)
-all(list, # != nil)
-all(list, # == # || f64 != i64)
-all(list, # == #)
-all(list, # == foo)
 all(list, # in list)
-all(list, # not in list)
-all(list, 0.5 < f64)
-all(list, 0.5 < i64)
-all(list, 0.5 <= i64)
-all(list, 0.5 >= i)
-all(list, 0.5 >= i32)
-all(list, 1 != 1)
-all(list, 1 <= 1)
-all(list, 1 > i32)
-all(list, 1 >= f64)
-all(list, add == div)
-all(list, all(array, ok))
-all(list, div != nil)
-all(list, f64 != 0.5)
-all(list, f64 != f32)
-all(list, f64 < i32)
-all(list, f64 > i64)
-all(list, false ? i : true)
-all(list, i < f32)
-all(list, i <= 1)
-all(list, i <= i32)
-all(list, i > f64)
-all(list, i > i32)
-all(list, i >= 1)
-all(list, i32 < 1)
-all(list, i32 <= 0.5)
-all(list, i32 == f32)
-all(list, i64 != nil)
-all(list, i64 <= 0.5)
-all(list, i64 > 1)
-all(list, list != nil)
-all(list, nil != 1)
-all(list, nil != i64)
-all(list, nil != nil)
-all(list, nil != score)
-all(list, nil == #)
-all(list, nil == score)
-all(list, nil in array)
-all(list, none(array, 1 > #))
-all(list, not true)
+all(list, #.Bar >= str)
+all(list, $env != 0)
+all(list, 0 < 1.0)
+all(list, array | any(ok))
+all(list, f64 <= 1.0)
+all(list, foo == #)
+all(list, nil == nil)
+all(list, nil not in $env)
 all(list, ok)
-all(list, reduce(array, true))
-all(list, type(i) not endsWith .Bar)
-all(map(array, #), ok && false)
-all(map(array, #), ok)
-all(map(array, f32), !ok)
-all(map(array, false), #)
-all(map(array, score), # != #)
-all(map(array, score), ok)
-all(map(list, "bar" not in #), #)
-all(map(list, 0.5), 0.5 <= #)
-all(map(list, i), # == 0.5)
-all(map(list, list), 1 == 0.5)
-all(map(list, ok), #)
-all(reduce(array, array), # > #)
-all(reduce(array, list), ok)
-all(true ? list : false, not true)
-any(["bar"], # not endsWith #)
-any([greet], ok)
-any(array, !(i32 <= #))
-any(array, "foo" >= "foo")
-any(array, "foo" not endsWith "bar")
-any(array, # != # or # > #)
+all(list, true and ok)
+all(sort($env), #)
+all(sort($env), .f64 | reduce(#, foo))
+all(sort($env), .f64)
+all(sort($env), .ok?.array)
+all(sort($env), 1.0 >= #)
+all(sort($env), sortBy(#, ok))
+all(toPairs($env), ok)
+any($env, ok) || $env == foo
+any($env, true) || $env?.[str]
+any($env.list, ok)
+any($env?.[str], true and true)
+any($env?.array, # == #)
+any($env?.list, ok)
 any(array, # != #)
-any(array, # != 0.5)
-any(array, # != f32)
-any(array, # != f64)
-any(array, # != i32)
-any(array, # != i64)
-any(array, # != nil)
-any(array, # < #)
-any(array, # < 0.5)
-any(array, # < 1)
-any(array, # < f32)
-any(array, # < f64)
-any(array, # < i)
-any(array, # < i32)
+any(array, # != $env)
+any(array, # < 0)
 any(array, # <= #)
-any(array, # <= 0.5)
-any(array, # <= 1)
-any(array, # <= f32)
-any(array, # <= i)
-any(array, # <= i32)
-any(array, # <= i64)
-any(array, # == #)
-any(array, # == 0.5)
-any(array, # == 1)
-any(array, # == i32)
-any(array, # == i64)
-any(array, # > #)
-any(array, # > 0.5)
-any(array, # > 1)
-any(array, # > f64)
-any(array, # > i32)
-any(array, # >= #)
-any(array, # >= 0.5)
-any(array, # >= 1)
-any(array, # >= f32)
-any(array, # >= i32)
-any(array, # >= i64)
-any(array, # in array)
-any(array, 0.5 != #)
-any(array, 0.5 == #)
-any(array, 0.5 == i32)
-any(array, 0.5 > #)
-any(array, 0.5 > f64)
-any(array, 0.5 >= #)
-any(array, 1 != i64)
-any(array, 1 < #)
-any(array, 1 < 0.5)
-any(array, 1 <= #)
-any(array, 1 == #)
-any(array, 1 > #)
-any(array, 1 > 1)
-any(array, 1 >= #)
-any(array, 1 >= f64)
-any(array, all(list, false))
-any(array, f32 < i)
-any(array, f32 > #)
-any(array, f32 > 0.5)
-any(array, f32 >= #)
-any(array, f64 != #)
-any(array, f64 < i)
-any(array, f64 <= #)
-any(array, f64 == #)
-any(array, f64 > #)
-any(array, f64 > 0.5)
-any(array, false && false)
-any(array, greet == greet)
+any(array, $env != #)
+any(array, $env != add)
+any(array, $env | all(true))
+any(array, $env?.ok)
+any(array, 0 == #)
+any(array, 1 == 1.0)
+any(array, array == array)
+any(array, foo == nil)
 any(array, i != #)
-any(array, i < #)
-any(array, i > #)
-any(array, i >= #)
-any(array, i32 > i64)
-any(array, i64 < #)
-any(array, i64 == f64)
-any(array, i64 >= #)
-any(array, nil != #)
-any(array, nil != 1)
-any(array, nil != i)
-any(array, nil != ok)
-any(array, nil == "foo")
-any(array, nil == #)
-any(array, nil == 1)
-any(array, ok != true)
+any(array, i <= i)
+any(array, ok != ok)
+any(array, ok or $env)
 any(array, ok)
-any(array, one(array, # <= 0.5))
-any(array, one(array, ok))
-any(array, score == nil)
-any(i32 .. i, half == half)
-any(list, !ok)
-any(list, !true)
-any(list, "bar" < "foo")
-any(list, "bar" not in #)
-any(list, "bar" not startsWith "foo")
-any(list, "foo" not in foo)
+any(array, str >= str)
+any(keys($env), ok)
 any(list, # != #)
 any(list, # == #)
-any(list, # == foo)
-any(list, # == nil)
-any(list, 0.5 != 1)
-any(list, 0.5 < 1)
-any(list, 0.5 < f64)
-any(list, 0.5 == i64)
-any(list, 1 >= f64)
-any(list, 1 >= i32)
-any(list, any(list, false))
-any(list, any(list, ok))
-any(list, array == nil)
-any(list, f32 < 1)
-any(list, f32 <= i64)
-any(list, f32 > 1)
-any(list, f32 > i64)
-any(list, f32 >= i32)
-any(list, f64 != i64)
-any(list, f64 >= 1)
-any(list, false) == (foo not in list)
-any(list, false) || false ? nil : add
-any(list, i > i64)
-any(list, i >= 0.5)
-any(list, i32 != 0.5)
-any(list, i64 <= 1)
-any(list, i64 == 0.5)
-any(list, i64 == i)
-any(list, i64 >= i32)
-any(list, i64 not in array)
-any(list, nil == false)
+any(list, # in list)
+any(list, $env != false)
+any(list, $env && false)
+any(list, $env == 1.0)
+any(list, $env == list)
+any(list, $env == str)
+any(list, $env?.ok)
+any(list, i ^ i == 1.0)
+any(list, list != array)
+any(list, nil != 1)
 any(list, nil == nil)
-any(list, none(array, false))
-any(list, not ok)
-any(list, ok || # == #)
 any(list, ok)
-any(list, reduce(list, true))
-any(list, true ? false : f64)
-any(map(array, #), # >= #)
-any(map(array, #), ok)
-any(map(array, false), #)
-any(map(array, ok), # and #)
-any(map(array, ok), #)
-any(map(list, #), nil == #)
-any(map(list, false), nil == i32)
-any(map(list, ok), #)
-any(ok ? "foo" : 1, ok)
-any(ok ? "foo" : f32, i > #)
-any(reduce(array, array), 1 == #)
+any(map(array, add), ok)
+any(sortBy(list, i), ok)
+any(values($env), # != 1.0)
 array
+array != $env && false
+array != $env == false
+array != $env == ok
+array != $env and $env
+array != $env and $env?.[Bar]
+array != $env or true
+array != $env.array
+array != $env.list
+array != $env?.Bar
+array != $env?.Bar?.i
+array != $env?.String
+array != $env?.String?.foo()
+array != $env?.[Bar]
+array != $env?.[String]
+array != $env?.[String]?.[greet]
+array != $env?.[str]
+array != $env?.array
+array != $env?.foobar
+array != $env?.list
+array != [1.0 + f64]
+array != [f64]
+array != [foo]
 array != array
-array != array ? 1 : false
-array != array ? score : i32
+array != array && true
+array != array or ok
+array != flatten(array)
 array != list
-array != list ? list : f64
-array != map(array, #)
-array != map(array, 1)
+array != list != false
+array != list && 1.0 > 0
+array != list || ok
+array != map($env, 1.0)
 array != map(list, #)
-array != map(list, true)
-array != nil ? add : 0.5
+array != map(list, 1.0)
+array != min($env)
+array != nil == $env
+array != nil ? list : greet
+array != nil and ok
+array != values($env)
+array != {foo: $env}?.str
+array == $env != ok
+array == $env && false
+array == $env and $env
+array == $env.array
+array == $env.list
+array == $env?.Bar
+array == $env?.String
+array == $env?.[Bar]
+array == $env?.[String]
+array == $env?.[foobar]
+array == $env?.[str]
+array == $env?.array
+array == $env?.foobar
+array == $env?.list
+array == [1.0]
+array == [1]
+array == [foo]
+array == [nil]
+array == [ok, 1.0]
+array == [str]
 array == array
-array == array ? half : false
+array == array != ok
+array == keys($env)
 array == list
-array == map(array, score)
-array == map(list, #)
-array == nil ? list : float(f32)
-array not in sort(array)
-array[-i32]
-array[-i64]
-array[-i]
-array[1 % i64]
-array[1 + 1]
-array[1] * i32
-array[1] * i64
-array[1] - f64
-array[1] / i32
-array[1] == -i
-array[1] > i
-array[1] ^ i
-array[abs(1)]
-array[array[i32]]
-array[bitnot(1)]
-array[bitor(1, i)]
-array[count(list, ok)]
-array[get(array, 1)]
-array[i32 * 1]
-array[i32:i]
-array[i32]
-array[i32] != i
-array[i32] % i32
-array[i32] * f64
-array[i32] ** i32
-array[i32] + i64
-array[i32] - f64
-array[i32] / f32
-array[i32] == i32
-array[i32] == i64
-array[i32] > f64
-array[i32] >= f32
-array[i64:i64]
-array[i64]
-array[i64] .. i32
-array[i64] == floor(0.5)
-array[i64] == i
-array[i64] > half(f64)
-array[i64] ^ f64
-array[i:i32]
-array[i:i64]
-array[i]
-array[i] * f64
-array[i] + f32
-array[i] - f32
-array[i] / f64
-array[i] < round(i)
-array[i] == i32
-array[i] > f64
-array[i] >= 0.5 ** i
-array[max(1)]
-array[reduce(list, 1)]
-array[score(1):i]
-array[score(1)]
-array[score(i)]
-bitand(1 * i64, i)
-bitand(1, 1) != i
-bitand(1, i64) == f64
+array == list != false
+array == list[:]
+array == map(array, #)
+array == max($env)?.greet
+array == min(array)
+array == nil && $env
+array in $env?.Bar
+array in $env?.String
+array in $env?.String?.array
+array in $env?.[Bar]
+array in $env?.[String]
+array in $env?.[String]?.[greet]
+array in $env?.[foobar]?.[i]
+array in $env?.foobar
+array in [array]
+array in [f64, list]
+array in [list]
+array in [str, $env]
+array in flatten(array)
+array in last($env)
+array in reverse(list)
+array in uniq(array)
+array not in $env?.Bar
+array not in $env?.String
+array not in $env?.[Bar]
+array not in $env?.[String]
+array not in $env?.[String]?.f64
+array not in $env?.[String]?.list
+array not in $env?.[foobar?.String]
+array not in $env?.[foobar]
+array not in $env?.foobar
+array not in [array]
+array not in map(array, array)
+array not in toPairs($env)
+array not in uniq(array)
+array not in {foo: foo}.add
+array | all(# != nil)
+array | all(# == f64)
+array | all(# >= i)
+array | all($env == #)
+array | all($env == foo)
+array | all(0 < 1.0)
+array | all(0 == #)
+array | all(false)
+array | all(foo == foo)
+array | all(i != f64)
+array | all(i > #)
+array | all(ok)
+array | all(true && true)
+array | all(true)
+array | any(# < #)
+array | any(# <= #)
+array | any(# == $env.i)
+array | any($env != #)
+array | any($env == foo)
+array | any($env?.ok)
+array | any(1 < #)
+array | any(1.0 <= 1)
+array | any(false)
+array | any(i <= #)
+array | any(ok ?: nil)
+array | any(ok)
+array | any(true)
+array | concat(array)
+array | concat(array) | find(ok)
+array | concat(list)
+array | count(# != #)
+array | count(# != $env)
+array | count(# != nil)
+array | count(# <= 0)
+array | count($env != foo)
+array | count($env == #)
+array | count($env == array)
+array | count($env?.ok)
+array | count(0 <= #)
+array | count(1.0 == #)
+array | count(false)
+array | count(i >= #)
+array | count(ok)
+array | count(true)
+array | count(true) ** i
+array | filter(# < 1.0)
+array | filter(# <= #)
+array | filter(# <= f64)
+array | filter($env == #)
+array | filter($env == i)
+array | filter($env.ok)
+array | filter(1 != #)
+array | filter(false)
+array | filter(false) | sortBy(#)
+array | filter(foo != foo)
+array | filter(nil == #)
+array | filter(nil == foo)
+array | filter(ok)
+array | filter(ok) | sum(1)
+array | filter(true)
+array | filter(true) | groupBy(#)
+array | find(# >= 1.0)
+array | find($env != $env)
+array | find($env not in list)
+array | find(0 < 1)
+array | find(1.0 < #)
+array | find(1.0 == 0)
+array | find(false)
+array | find(foo in list)
+array | find(ok)
+array | find(true)
+array | find(true) >= float(f64)
+array | findIndex(# != 0)
+array | findIndex(# == #)
+array | findIndex(# > f64)
+array | findIndex(# >= 1.0)
+array | findIndex($env != false)
+array | findIndex($env?.ok)
+array | findIndex(1.0 < 1.0)
+array | findIndex(1.0 <= #)
+array | findIndex(f64 == $env)
+array | findIndex(f64 >= 1.0)
+array | findIndex(false and false)
+array | findIndex(false)
+array | findIndex(i != $env)
+array | findIndex(ok)
+array | findIndex(true)
+array | findIndex(true) + i
+array | findLast(# > #)
+array | findLast(1.0 < #)
+array | findLast(1.0 >= i)
+array | findLast(f64 >= #)
+array | findLast(false)
+array | findLast(greet != nil)
+array | findLast(nil != #)
+array | findLast(nil not in $env)
+array | findLast(ok)
+array | findLast(true ?: add)
+array | findLast(true)
+array | findLastIndex(# != $env)
+array | findLastIndex(# < #)
+array | findLastIndex(# <= #)
+array | findLastIndex($env | any(false))
+array | findLastIndex(0 <= 0)
+array | findLastIndex(1 <= i)
+array | findLastIndex(1.0 <= #)
+array | findLastIndex(1.0 <= 1.0)
+array | findLastIndex(false ?: ok)
+array | findLastIndex(false)
+array | findLastIndex(foo in list)
+array | findLastIndex(ok)
+array | findLastIndex(ok) < f64
+array | findLastIndex(true)
+array | findLastIndex(true) - i
+array | get(0)
+array | get(1)
+array | get(i)
+array | groupBy(# != #)
+array | groupBy(# - #)
+array | groupBy(# / 1.0)
+array | groupBy(# == #)
+array | groupBy(# > #)
+array | groupBy(# >= #)
+array | groupBy(# ^ #)
+array | groupBy(#)
+array | groupBy($env != 0)
+array | groupBy($env && false)
+array | groupBy($env.foo)
+array | groupBy($env?.[str])
+array | groupBy($env?.foo)
+array | groupBy($env?.str)
+array | groupBy(0 ** 1.0)
+array | groupBy(0)
+array | groupBy(1)
+array | groupBy(1.0 != #)
+array | groupBy(1.0 ** 1)
+array | groupBy(1.0 ** f64)
+array | groupBy(1.0)
+array | groupBy(f64)
+array | groupBy(false != false)
+array | groupBy(false)
+array | groupBy(foo)
+array | groupBy(foo.Bar)
+array | groupBy(i)
+array | groupBy(list?.[i])
+array | groupBy(ok)
+array | groupBy(round(#))
+array | groupBy(round(1.0))
+array | groupBy(str)
+array | groupBy(string(1))
+array | groupBy(trimPrefix(str))
+array | groupBy(true)
+array | map(# != 0)
+array | map(# ** i)
+array | map(# - #)
+array | map(# .. #index)
+array | map(# > #)
+array | map(# >= #)
+array | map(# >= i)
+array | map(# ^ #)
+array | map(#)
+array | map(#) | any(ok)
+array | map(#) | map(1.0)
+array | map(#) | one(ok)
+array | map(#) | one(true)
+array | map(#) | reduce(#)
+array | map(#) | reduce(ok)
+array | map(#) | sum(1.0)
+array | map(#) | take(0)
+array | map(#index % i)
+array | map(#index - 1.0)
+array | map(#index)
+array | map(#index) | map(false)
+array | map($env != str)
+array | map($env)
+array | map($env) | any(.ok)
+array | map($env.list)
+array | map($env.ok)
+array | map($env?.Bar)
+array | map($env?.list)
+array | map(0)
+array | map(0) | reduce(#)
+array | map(0) | sum(#)
+array | map(0) | sum(f64)
+array | map(1 >= 1)
+array | map(1)
+array | map(1) | find(ok)
+array | map(1) | groupBy(#)
+array | map(1) | reduce($env, array)
+array | map(1.0 + #index)
+array | map(1.0 - 1.0)
+array | map(1.0 <= #)
+array | map(1.0 > #)
+array | map(1.0)
+array | map(1.0) | map(0)
+array | map(1.0) | reduce(foo)
+array | map(1.0) | sortBy(#)
+array | map([#])
+array | map([$env])
+array | map(add(#, #))
+array | map(add)
+array | map(array)
+array | map(array) == array
+array | map(array) | any(false)
+array | map(f64 ^ #)
+array | map(f64)
+array | map(f64) | one(array == $env)
+array | map(f64) | sortBy(i)
+array | map(false)
+array | map(false) != list
+array | map(false) | none(#)
+array | map(foo)
+array | map(foo) != array
+array | map(foo) | map(#)
+array | map(foo) | reduce(#)
+array | map(foo) | reduce(1.0)
+array | map(foo?.Bar)
+array | map(greet)
+array | map(greet) | groupBy(true)
+array | map(i <= 1)
+array | map(i)
+array | map(i) | filter(ok)
+array | map(i) | groupBy(f64)
+array | map(if false { 0 } else { foo })
+array | map(let foobar = greet; foobar)
+array | map(list)
+array | map(mean(#))
+array | map(median(#))
+array | map(nil == greet)
+array | map(ok)
+array | map(ok) | any(#)
+array | map(ok) | groupBy(ok)
+array | map(str)
+array | map(str) | groupBy(#)
+array | map(str) | map(#)
+array | map(toJSON(f64))
+array | map(true)
+array | map(true) | reduce(foo)
+array | max(0)
+array | max(0, 1)
+array | max(0, 1.0)
+array | max(1)
+array | max(1, 0)
+array | max(1, 1.0)
+array | max(1.0)
+array | max(array)
+array | max(f64)
+array | max(f64, 1.0)
+array | max(f64, f64)
+array | max(i)
+array | max(i, i)
+array | max(map($env, #index))
+array | mean(0 / 1)
+array | mean(0)
+array | mean(0, 1.0, array)
+array | mean(1)
+array | mean(1, 0)
+array | mean(1.0)
+array | mean(1.0, 1)
+array | mean(1.0, 1.0)
+array | mean(array)
+array | mean(array, 0) <= i
+array | mean(array, array)
+array | mean(f64)
+array | mean(f64, 1)
+array | mean(i)
+array | mean(i, f64)
+array | median($env.array)
+array | median($env?.array)
+array | median(0)
+array | median(1 - 1.0)
+array | median(1)
+array | median(1.0)
+array | median(1.0, 1.0)
+array | median(1.0, f64)
+array | median([array])
+array | median(array)
+array | median(f64)
+array | median(i)
+array | min(0)
+array | min(0, array)
+array | min(0, f64)
+array | min(1)
+array | min(1.0)
+array | min(array)
+array | min(f64)
+array | min(i)
+array | min(i, i)
+array | none(# != $env)
+array | none(# != 1)
+array | none(# < #)
+array | none(# == #)
+array | none(# == $env)
+array | none(# == nil)
+array | none($env != 1.0)
+array | none($env.ok)
+array | none(1.0 < #)
+array | none(1.0 > #)
+array | none(false)
+array | none(ok)
+array | none(true == $env)
+array | none(true)
+array | one(# == #)
+array | one(# > #)
+array | one(# > 1.0)
+array | one(# not in array)
+array | one($env != $env)
+array | one($env != foo)
+array | one($env.ok)
+array | one(false)
+array | one(i == nil)
+array | one(nil == 1)
+array | one(nil == foo)
+array | one(ok)
+array | one(true)
+array | reduce(# != #)
+array | reduce(# * #)
+array | reduce(# + #)
+array | reduce(# - f64)
+array | reduce(# > #index)
+array | reduce(#)
+array | reduce(#, $env)
+array | reduce(#, 0)
+array | reduce(#, 1)
+array | reduce(#, 1.0)
+array | reduce(#, add)
+array | reduce(#, array)
+array | reduce(#, f64)
+array | reduce(#, false)
+array | reduce(#, foo)
+array | reduce(#, greet)
+array | reduce(#, i)
+array | reduce(#, list)
+array | reduce(#, nil)
+array | reduce(#, ok)
+array | reduce(#, str)
+array | reduce(#, true)
+array | reduce(#acc)
+array | reduce(#acc) == greet
+array | reduce(#acc, 0)
+array | reduce(#acc, 1.0) in [str, foo]
+array | reduce(#acc, add)
+array | reduce(#acc, array)
+array | reduce(#acc, foo)
+array | reduce(#acc, greet)
+array | reduce(#acc, i)
+array | reduce(#acc, nil)
+array | reduce(#index)
+array | reduce(#index, false)
+array | reduce(#index, foo)
+array | reduce(#index, i)
+array | reduce(#index, list)
+array | reduce(#index, ok)
+array | reduce(#index, str)
+array | reduce($env != array)
+array | reduce($env)
+array | reduce($env) | findLastIndex(true)
+array | reduce($env) | reduce($env, nil)
+array | reduce($env, $env)
+array | reduce($env, 0)
+array | reduce($env, 1)
+array | reduce($env, 1.0)
+array | reduce($env, add)
+array | reduce($env, array)
+array | reduce($env, f64)
+array | reduce($env, false)
+array | reduce($env, foo)
+array | reduce($env, greet)
+array | reduce($env, list)
+array | reduce($env, nil)
+array | reduce($env, ok)
+array | reduce($env.ok)
+array | reduce($env?.Bar)
+array | reduce($env?.[Bar])
+array | reduce($env?.[String]?.foo())
+array | reduce($env?.list, foo?.String)
+array | reduce(0 + i)
+array | reduce(0 .. #)
+array | reduce(0 == #)
+array | reduce(0)
+array | reduce(0, 0)
+array | reduce(0, 1.0)
+array | reduce(0, foo)
+array | reduce(0, i)
+array | reduce(0, list)
+array | reduce(0, true)
+array | reduce(1)
+array | reduce(1, 0)
+array | reduce(1, 1.0)
+array | reduce(1, add)
+array | reduce(1, false)
+array | reduce(1, foo)
+array | reduce(1, nil)
+array | reduce(1, ok)
+array | reduce(1, str)
+array | reduce(1.0 * 1)
+array | reduce(1.0 > 1.0)
+array | reduce(1.0)
+array | reduce(1.0) != f64
+array | reduce(1.0) / f64
+array | reduce(1.0) < i <= f64
+array | reduce(1.0, $env)
+array | reduce(1.0, 0)
+array | reduce(1.0, 1)
+array | reduce(1.0, 1.0)
+array | reduce(1.0, array)
+array | reduce(1.0, f64)
+array | reduce(1.0, false)
+array | reduce(1.0, foo)
+array | reduce(1.0, list)
+array | reduce(1.0, nil)
+array | reduce(1.0, ok)
+array | reduce(1.0, true)
+array | reduce(add)
+array | reduce(add, $env)
+array | reduce(add, 0)
+array | reduce(add, 1.0)
+array | reduce(add, array)
+array | reduce(add, f64)
+array | reduce(add, false)
+array | reduce(add, list)
+array | reduce(add, nil)
+array | reduce(add, ok)
+array | reduce(add, str)
+array | reduce(array)
+array | reduce(array) | reduce(false)
+array | reduce(array, $env)
+array | reduce(array, 0)
+array | reduce(array, 1.0)
+array | reduce(array, f64)
+array | reduce(array, foo)
+array | reduce(array, greet)
+array | reduce(array, list)
+array | reduce(array, nil)
+array | reduce(array, ok)
+array | reduce(f64)
+array | reduce(f64, 0)
+array | reduce(f64, 1)
+array | reduce(f64, 1.0)
+array | reduce(f64, array)
+array | reduce(f64, f64)
+array | reduce(f64, false)
+array | reduce(f64, foo)
+array | reduce(f64, i)
+array | reduce(f64, list)
+array | reduce(f64, nil)
+array | reduce(f64, true)
+array | reduce(false)
+array | reduce(false, $env)
+array | reduce(false, 1)
+array | reduce(false, 1.0)
+array | reduce(false, add)
+array | reduce(false, false)
+array | reduce(false, foo)
+array | reduce(false, i)
+array | reduce(false, list)
+array | reduce(false, nil)
+array | reduce(false, true)
+array | reduce(foo)
+array | reduce(foo, $env)
+array | reduce(foo, 0)
+array | reduce(foo, 1)
+array | reduce(foo, 1.0)
+array | reduce(foo, add)
+array | reduce(foo, array)
+array | reduce(foo, f64)
+array | reduce(foo, foo)
+array | reduce(foo, i)
+array | reduce(foo, list)
+array | reduce(foo, nil)
+array | reduce(foo, ok)
+array | reduce(foo, str)
+array | reduce(foo, true)
+array | reduce(greet)
+array | reduce(greet, 1.0)
+array | reduce(greet, array)
+array | reduce(greet, false)
+array | reduce(greet, foo)
+array | reduce(greet, greet)
+array | reduce(greet, i)
+array | reduce(greet, str)
+array | reduce(greet, true)
+array | reduce(i > 1)
+array | reduce(i)
+array | reduce(i, $env)
+array | reduce(i, 0)
+array | reduce(i, 1)
+array | reduce(i, 1.0)
+array | reduce(i, false)
+array | reduce(i, foo)
+array | reduce(i, list)
+array | reduce(i, nil)
+array | reduce(i, ok)
+array | reduce(list)
+array | reduce(list, $env)
+array | reduce(list, 0)
+array | reduce(list, 1.0)
+array | reduce(list, foo)
+array | reduce(list, i)
+array | reduce(list, list)
+array | reduce(list, nil)
+array | reduce(list, ok)
+array | reduce(list, ok) | all(true)
+array | reduce(list, true)
+array | reduce(median(0))
+array | reduce(nil != #)
+array | reduce(ok)
+array | reduce(ok, $env)
+array | reduce(ok, 0)
+array | reduce(ok, 1.0)
+array | reduce(ok, add)
+array | reduce(ok, false)
+array | reduce(ok, foo)
+array | reduce(ok, greet)
+array | reduce(ok, list)
+array | reduce(ok, nil)
+array | reduce(ok, true)
+array | reduce(str)
+array | reduce(str) | greet()
+array | reduce(str, $env)
+array | reduce(str, 1)
+array | reduce(str, 1.0)
+array | reduce(str, abs(1))
+array | reduce(str, add)
+array | reduce(str, foo)
+array | reduce(str, greet)
+array | reduce(str, i)
+array | reduce(str, list)
+array | reduce(str, nil)
+array | reduce(string(add))
+array | reduce(true and true)
+array | reduce(true)
+array | reduce(true, $env)
+array | reduce(true, 1)
+array | reduce(true, 1.0)
+array | reduce(true, array)
+array | reduce(true, foo)
+array | reduce(true, i)
+array | reduce(true, nil)
+array | reduce(true, ok)
+array | reduce(true, true)
+array | sortBy(# + #)
+array | sortBy(# + i)
+array | sortBy(# / #)
+array | sortBy(# ^ 1.0)
+array | sortBy(# ^ f64)
+array | sortBy(#)
+array | sortBy(#) | all(ok)
+array | sortBy(#) | map(#)
+array | sortBy(#) | map(foo)
+array | sortBy($env?.[str])
+array | sortBy($env?.i)
+array | sortBy(0 ^ #)
+array | sortBy(0)
+array | sortBy(0) | median(1.0)
+array | sortBy(1)
+array | sortBy(1.0)
+array | sortBy(1.0) != list
+array | sortBy(1.0) | one(true)
+array | sortBy(1.0) | sortBy(#)
+array | sortBy(array | reduce(1.0))
+array | sortBy(array?.[i])
+array | sortBy(bitnot(i))
+array | sortBy(f64)
+array | sortBy(f64) | map(#)
+array | sortBy(f64) | sortBy(1.0)
+array | sortBy(f64) | sortBy(i)
+array | sortBy(floor(#))
+array | sortBy(foo.String())
+array | sortBy(i)
+array | sortBy(i) | sortBy(#)
+array | sortBy(reduce(array, str, foo))
+array | sortBy(str + str)
+array | sortBy(str)
+array | sum(# ** #)
+array | sum(# - #)
+array | sum(# ^ 1)
+array | sum(# ^ i)
+array | sum(#)
+array | sum(#) < 1.0 ^ 1.0
+array | sum(0)
+array | sum(0.1)
+array | sum(1 + 1.0)
+array | sum(1)
+array | sum(1.0 * #)
+array | sum(1.0 ** #)
+array | sum(1.0 - 1.0)
+array | sum(1.0)
+array | sum(bitshl(#, #))
+array | sum(f64)
+array | sum(float(f64))
+array | sum(i + 0)
+array | sum(i)
+array | sum(int(#))
+array | sum(max(#, 1))
+array | sum(median(#))
+array | sum(round(1.0))
+array | take(0)
+array | take(1)
+array | take(i)
+array; $env.ok
+array; add
+array; array
+array; foo.String
+array; greet
+array; i
+array; list
+array?.[$env.i]
+array?.[$env?.i]
+array?.[0 % i]
+array?.[1] % i
+array?.[1] .. i
+array?.[1] / f64
+array?.[array?.[i]]
+array?.[bitnot(i)]
+array?.[i]
+array?.[i] != 1.0 ?: 1.0
+array?.[i] != f64
+array?.[i] != i * 1.0
+array?.[i] * i
+array?.[i] ** i
+array?.[i] - f64
+array?.[i] - i
+array?.[i] .. i
+array?.[i] / i
+array?.[i] < 0 + 1.0
+array?.[i] < f64
+array?.[i] <= f64
+array?.[i] == f64
+array?.[i] > f64
+array?.[i] >= f64
+array?.[i] >= i
+array?.[i] ^ f64
+array?.[i] ^ i
+array?.[i] not in array
+array?.[i] | add(i)
+array?.[i] | bitshr(0)
+array?.[i] | min(0)
+array?.[int(1.0)]
+array?.[len(list)]
+array?.[list | count(ok)]
+array?.[mean(1)]
+array?.[mean(i)]
+array?.[median(1)]
+array[$env?.i:]
+array[0:] | reduce(#)
+array[0:] | reduce(str)
+array[0:] | sortBy(#)
+array[0:]?.[i]
+array[1:] == list
+array[1:] | any(ok)
+array[1:] | findLast(false)
+array[1:] | reduce(foo)
+array[1:] | sum(#)
+array[1:]?.[i]
+array[:$env.i]
+array[:0] | sortBy(#)
+array[:0] | sum(str)
+array[:1] | findLastIndex(false)
+array[:1] | sum(#)
+array[:]
+array[:] | reduce(f64)
+array[:]?.[i]
+array[:i]
+array[:i] | map(f64)
+array[:i] | reduce($env)
+array[:i] | sortBy(array)
+array[:int(1.0)]
+array[:reduce(array, 1)]
+array[array?.[i]:]
+array[bitnot(1):]
+array[i % 1:]
+array[i:]
+array[i:] | findIndex(false)
+array[i:] | groupBy(1)
+array[len($env):]
+array[sum(array):]
+bitand(1, i) * i
+bitand(i, 0) + f64
 bitand(i, i)
-bitand(i, i32)
-bitand(i, i64)
-bitand(i32, 1) != f32
-bitand(i32, i)
-bitand(i32, i) - i32
-bitand(i32, i32 * i)
-bitand(i32, i32)
-bitand(i32, i64)
-bitand(i64, 1) <= i32
-bitand(i64, i + i64)
-bitand(i64, i)
-bitand(i64, i) ^ f64
-bitand(i64, i32)
-bitand(i64, i64)
-bitand(int(i32), i64)
-bitnand(1, i64) != int(i64)
+bitand(i, sum(array))
+bitnand($env.i, i)
 bitnand(i, i)
-bitnand(i, i32 + i32)
-bitnand(i, i32)
-bitnand(i, i64)
-bitnand(i32, bitnot(1))
-bitnand(i32, i)
-bitnand(i32, i32)
-bitnand(i32, i64)
-bitnand(i64 + i, i32)
-bitnand(i64 + i64, i64)
-bitnand(i64, -1)
-bitnand(i64, 1) + i64 + 1
-bitnand(i64, i)
-bitnand(i64, i32)
-bitnand(i64, i32) > f64
-bitnand(i64, i64)
-bitnot(-1)
-bitnot(-i)
-bitnot(-i32)
-bitnot(-i64)
-bitnot(1 % 1)
-bitnot(1 % i32)
-bitnot(1 % i64)
-bitnot(1 * 1)
-bitnot(1 * i64)
-bitnot(1 + 1)
+bitnot($env | findIndex(true))
+bitnot($env | findLastIndex(ok))
+bitnot($env.i)
+bitnot($env?.[str]?.[i])
+bitnot($env?.i)
+bitnot(0 * 1)
+bitnot(0 * i)
+bitnot(0 - 0)
+bitnot(0 - 1)
+bitnot(0 | min(0))
+bitnot(0) < f64
+bitnot(0) == $env?.[Bar]
+bitnot(0) in array
+bitnot(0) | min(array, 0)
+bitnot(1 % i)
+bitnot(1 * 0)
 bitnot(1 - i)
-bitnot(1 - i32)
-bitnot(1) * i % 1
-bitnot(1) ** f32
-bitnot(1) ** i
-bitnot(1) + i32
-bitnot(1) - i
-bitnot(1) - i32
-bitnot(1) / min(i)
-bitnot(1) < i32
-bitnot(1) < i64
-bitnot(1) == i32
-bitnot(1) > f64
-bitnot(1) >= i
-bitnot(1) >= i64
-bitnot(abs(1))
-bitnot(abs(i32))
-bitnot(abs(i64))
-bitnot(array[1])
-bitnot(array[i64])
-bitnot(array[i])
+bitnot(1 | min(i))
+bitnot(1) != i && false
+bitnot(1) == f64
+bitnot(abs(i))
+bitnot(array | count(false))
+bitnot(array | count(ok))
+bitnot(array | sum(#))
+bitnot(array | sum(i))
+bitnot(array?.[0])
+bitnot(array?.[i])
+bitnot(bitand(1, 0))
+bitnot(bitnot(0))
+bitnot(bitnot(1))
 bitnot(bitnot(i))
-bitnot(bitushr(1, 1))
-bitnot(bitushr(i32, 1))
-bitnot(bitxor(i, i64))
 bitnot(count(array, false))
-bitnot(findLast(array, ok))
+bitnot(count(list, ok))
+bitnot(false ? nil : 1)
+bitnot(false ?: 1)
+bitnot(findIndex($env, ok))
+bitnot(findIndex(array, ok))
+bitnot(findLastIndex(array, true))
 bitnot(first(array))
-bitnot(get(array, 1))
-bitnot(get(array, i))
-bitnot(i % i64)
-bitnot(i * i)
-bitnot(i * i32)
-bitnot(i + 1)
-bitnot(i - 1)
-bitnot(i - i64)
+bitnot(i % i)
+bitnot(i * 0)
+bitnot(i * 1)
+bitnot(i + 0)
+bitnot(i | add(i))
+bitnot(i | min(1.0))
 bitnot(i)
-bitnot(i) % i32
-bitnot(i) * i
-bitnot(i) + f64
-bitnot(i) .. i64
-bitnot(i) == 1 - i
-bitnot(i) > i
-bitnot(i) >= i32
-bitnot(i) ^ f32
-bitnot(i) ^ f64
-bitnot(i) in array
-bitnot(i32 % 1)
-bitnot(i32 % i64)
-bitnot(i32 + i)
-bitnot(i32 + i32)
-bitnot(i32 - 1)
-bitnot(i32 - i32)
-bitnot(i32)
-bitnot(i32) != f64
-bitnot(i32) != i32
-bitnot(i32) * i
-bitnot(i32) * i64
-bitnot(i32) ** f32
-bitnot(i32) - i32
-bitnot(i32) / f64
-bitnot(i32) == i64
-bitnot(i32) > 1 != true
-bitnot(i32) >= f32
-bitnot(i64 % 1)
-bitnot(i64 % i)
-bitnot(i64 % i32)
-bitnot(i64 * 1)
-bitnot(i64 * i)
-bitnot(i64 * i32)
-bitnot(i64 * i64)
-bitnot(i64 - 1)
-bitnot(i64 - i)
-bitnot(i64 - i64)
-bitnot(i64)
-bitnot(i64) % i32
-bitnot(i64) * f32
-bitnot(i64) < f32
-bitnot(i64) > f64
-bitnot(i64) > i % i
-bitnot(i64) >= i32 ^ f32
-bitnot(i64) ^ f64
-bitnot(i64) not in array
-bitnot(int(f32))
+bitnot(i) + i
+bitnot(i) - i
+bitnot(if false { f64 } else { 0 })
+bitnot(if true { 1 } else { foo })
+bitnot(int(1))
+bitnot(int(1.0))
 bitnot(int(f64))
-bitnot(int(i))
-bitnot(int(i32))
-bitnot(int(i64))
 bitnot(last(array))
-bitnot(len("bar"))
-bitnot(len("foo"))
-bitnot(len(list))
+bitnot(len($env))
+bitnot(len(array))
+bitnot(len(str))
+bitnot(list | findLastIndex(ok))
+bitnot(list | findLastIndex(true))
+bitnot(max(0))
 bitnot(max(1))
-bitnot(max(1, i64))
+bitnot(max(1, 0))
+bitnot(max(array, 0))
 bitnot(max(i))
-bitnot(max(i32))
-bitnot(min(1))
-bitnot(min(i32))
-bitnot(min(i64))
-bitnot(ok ? 1 : array)
-bitnot(ok ? 1 : ok)
-bitnot(ok ? i : add)
+bitnot(min(0))
+bitnot(min(array))
+bitnot(min(i))
+bitnot(min(i, 0))
 bitnot(reduce(array, #))
-bitnot(reduce(array, 1))
-bitnot(reduce(list, 1))
-bitnot(score(1))
-bitnot(score(i))
+bitnot(reduce(array, 0))
+bitnot(reduce(list, i))
 bitnot(sum(array))
-bitor(1, 1) < i
-bitor(1, 1) == i
-bitor(1, i32) != i64
-bitor(i, -i64)
+bitnot(sum(array, #))
+bitnot(sum(list, 0))
+bitor($env.i, i)
+bitor(i, array?.[i])
 bitor(i, i)
-bitor(i, i64)
-bitor(i32, i)
-bitor(i32, i32)
-bitor(i32, i64)
-bitor(i64 % 1, i32)
-bitor(i64, i)
-bitor(i64, i32)
-bitor(i64, i64)
-bitor(min(i64), i)
-bitor(score(i), i64)
-bitshl(bitnot(i), i)
+bitor(i, len(list))
+bitshl(i, $env?.i)
 bitshl(i, i)
-bitshl(i, i32)
-bitshl(i, i64)
-bitshl(i32, i)
-bitshl(i32, i32)
-bitshl(i32, i64)
-bitshl(i64, i32)
-bitshl(i64, i64)
-bitshl(len(array), i)
-bitshl(score(i), i32)
-bitshr(i % 1, i32)
-bitshr(i, 1) - i64
-bitshr(i, i32)
-bitshr(i, i64)
-bitshr(i32, i)
-bitshr(i32, i) - f32
-bitshr(i32, i32)
-bitshr(i32, i64)
-bitshr(i64, i32)
-bitshr(i64, i64)
-bitushr(-i64, i64)
-bitushr(1 % i, i)
-bitushr(1, i) * i
-bitushr(abs(1), i32)
+bitshr(i, $env?.i)
+bitshr(i, i)
+bitshr(i, sum(array))
 bitushr(i, i)
-bitushr(i, i) % i64
-bitushr(i, i32)
-bitushr(i, i64)
-bitushr(i32, i)
-bitushr(i32, i32)
-bitushr(i32, i64)
-bitushr(i64, i)
-bitushr(i64, i32)
-bitushr(i64, i64)
-bitxor(-i, i64)
-bitxor(1, i) * i
-bitxor(bitnot(1), -i)
-bitxor(i, i32)
-bitxor(i, i64)
-bitxor(i32, 1) > i64
-bitxor(i32, i)
-bitxor(i32, i) ** f64
-bitxor(i32, i32)
-bitxor(i32, i64)
-bitxor(i32, i64) ** i32
-bitxor(i64, i)
-bitxor(i64, i32)
-bitxor(i64, i64)
-bitxor(score(1), i)
-ceil(-0.5)
-ceil(-1)
-ceil(-f32)
-ceil(-f64)
-ceil(-i)
-ceil(-i32)
-ceil(-i64)
-ceil(0.5 * 0.5)
-ceil(0.5 * 1)
-ceil(0.5 * f64)
-ceil(0.5 * i)
-ceil(0.5 ** 1)
-ceil(0.5 ** f64)
-ceil(0.5 ** i)
-ceil(0.5 + 0.5)
-ceil(0.5 + 1)
-ceil(0.5 + f32)
-ceil(0.5 + f64)
-ceil(0.5 + i)
-ceil(0.5 + i32)
-ceil(0.5 + i64)
-ceil(0.5 - 0.5)
-ceil(0.5 - f64)
-ceil(0.5 - i)
-ceil(0.5 / 0.5)
-ceil(0.5 / 1)
-ceil(0.5 / f32)
-ceil(0.5 / i)
-ceil(0.5 / i32)
-ceil(0.5 ^ 1)
-ceil(0.5 ^ f32)
-ceil(0.5 ^ i32)
-ceil(0.5 ^ i64)
-ceil(0.5) != 0.5 * 0.5
-ceil(0.5) != i
-ceil(0.5) != nil ? score : "foo"
-ceil(0.5) ** round(f32)
-ceil(0.5) - i
-ceil(0.5) < i
-ceil(0.5) == f32
-ceil(0.5) == i ? div : half
-ceil(0.5) == i64
-ceil(0.5) > f64
-ceil(0.5) >= i
-ceil(0.5) >= i64
-ceil(0.5) ^ i64
-ceil(1 % i64)
-ceil(1 * 0.5)
-ceil(1 * 1)
-ceil(1 ** 1)
-ceil(1 + 0.5)
-ceil(1 + 1)
+bitxor(i, i)
+ceil($env | sum(0))
+ceil($env | sum(f64))
+ceil($env | sum(i))
+ceil($env.f64)
+ceil($env.i)
+ceil($env?.[str] | sum(1.0))
+ceil($env?.array | findLast(ok))
+ceil($env?.f64)
+ceil($env?.i)
+ceil($env?.i) < f64
+ceil(0 * 1)
+ceil(0 * 1.0)
+ceil(0 ** 1)
+ceil(0 ** 1.0)
+ceil(0 ** f64)
+ceil(0 + 1)
+ceil(0 + 1.0)
+ceil(0 + i)
+ceil(0 - 0)
+ceil(0 - 1.0)
+ceil(0 - i)
+ceil(0 / 1)
+ceil(0 / 1.0)
+ceil(0 ^ 0)
+ceil(0 ^ 1.0)
+ceil(0 ^ f64)
+ceil(0 ^ i)
+ceil(0 | add(i))
+ceil(0 | bitshl(i))
+ceil(0 | median(1.0))
+ceil(0) != f64
+ceil(0) <= f64
+ceil(0.0)
+ceil(1 % 1)
+ceil(1 * f64)
+ceil(1 ** 1.0)
+ceil(1 ** f64)
 ceil(1 + f64)
 ceil(1 + i)
-ceil(1 - 0.5)
-ceil(1 - f64)
-ceil(1 / 0.5)
-ceil(1 / 1)
-ceil(1 / f64)
-ceil(1 / i64)
-ceil(1 ^ f64)
-ceil(1 ^ i)
-ceil(1 ^ i64)
-ceil(1) ** f32
-ceil(1) + i32
-ceil(1) / i
-ceil(1) < f32 ^ i
-ceil(1) <= f32
-ceil(1) <= i64
-ceil(1) == f32
-ceil(1) > f32
-ceil(1) >= f32
-ceil(1) >= i64 ** 0.5
+ceil(1 - 1.0)
+ceil(1 ^ 1.0)
+ceil(1 | bitor(0))
+ceil(1) != i
+ceil(1) > f64
 ceil(1) ^ i
-ceil(abs(0.5))
-ceil(abs(1))
-ceil(abs(f32))
+ceil(1) | median(1.0, 1)
+ceil(1) | min(array)
+ceil(1.0 * 0)
+ceil(1.0 * 1)
+ceil(1.0 * 1.0)
+ceil(1.0 * i)
+ceil(1.0 ** i)
+ceil(1.0 + 0)
+ceil(1.0 + 1)
+ceil(1.0 + 1.0)
+ceil(1.0 + i)
+ceil(1.0 - 0)
+ceil(1.0 - 1)
+ceil(1.0 - 1.0)
+ceil(1.0 - f64)
+ceil(1.0 - i)
+ceil(1.0 / 1)
+ceil(1.0 / 1.0)
+ceil(1.0 / f64)
+ceil(1.0 ^ 0)
+ceil(1.0 ^ 1.0)
+ceil(1.0 ^ f64)
+ceil(1.0 | min(1))
+ceil(1.0) == nil ? foo : str
+ceil(1.0) >= f64
+ceil(1.0) not in array
+ceil(1.0) | mean(1)
+ceil(abs(0))
 ceil(abs(f64))
-ceil(abs(i32))
-ceil(abs(i64))
-ceil(add(1, 1))
-ceil(array[1])
-ceil(array[i64])
-ceil(array[i])
+ceil(abs(i))
+ceil(array?.[i])
+ceil(bitnot(0))
 ceil(bitnot(1))
-ceil(bitnot(i))
-ceil(ceil(0.5))
+ceil(ceil(0))
+ceil(ceil(1))
+ceil(ceil(1.0))
 ceil(ceil(f64))
-ceil(ceil(i))
-ceil(ceil(i32))
-ceil(count(list, ok))
-ceil(f32 * 0.5)
-ceil(f32 * i)
-ceil(f32 * i32)
-ceil(f32 ** i)
-ceil(f32 ** i32)
-ceil(f32 + 1)
-ceil(f32 + i64)
-ceil(f32 - f32)
-ceil(f32 - i)
-ceil(f32 - i32)
-ceil(f32 - i64)
-ceil(f32 / 0.5)
-ceil(f32 / f64)
-ceil(f32 / i32)
-ceil(f32 ^ 0.5)
-ceil(f32 ^ 1)
-ceil(f32 ^ i64)
-ceil(f32)
-ceil(f32) != i64
-ceil(f32) * i64
-ceil(f32) ** -1
-ceil(f32) ** i
-ceil(f32) + i
-ceil(f32) + i64
-ceil(f32) - i32
-ceil(f32) / i64
-ceil(f32) < i
-ceil(f32) < i32
-ceil(f64 * 1)
-ceil(f64 * i)
+ceil(count($env, false))
+ceil(f64 * 0)
+ceil(f64 ** 0)
+ceil(f64 ** 1)
+ceil(f64 ** 1.0)
 ceil(f64 ** i)
-ceil(f64 ** i64)
-ceil(f64 + 1)
-ceil(f64 + f32)
-ceil(f64 - 0.5)
-ceil(f64 - f32)
-ceil(f64 - f64)
-ceil(f64 - i32)
-ceil(f64 / 0.5)
+ceil(f64 + 1.0)
+ceil(f64 + f64)
+ceil(f64 - 1)
+ceil(f64 / 1)
+ceil(f64 / 1.0)
 ceil(f64 / f64)
-ceil(f64 / i32)
-ceil(f64 / i64)
-ceil(f64 ^ 0.5)
-ceil(f64 ^ f32)
-ceil(f64 ^ f64)
-ceil(f64 ^ i32)
-ceil(f64 ^ i64)
+ceil(f64 / i)
+ceil(f64 ^ 1.0)
+ceil(f64 ^ i)
+ceil(f64 | min(1.0))
 ceil(f64)
 ceil(f64) != i
-ceil(f64) != i64
-ceil(f64) * f32
-ceil(f64) ** f32
-ceil(f64) - i32
-ceil(f64) / f64
-ceil(f64) / i / i64
-ceil(f64) in array
-ceil(false ? add : 0.5)
-ceil(find(array, ok))
-ceil(findLast(array, true))
-ceil(findLastIndex(list, ok))
-ceil(findLastIndex(list, true))
+ceil(f64) * f64
+ceil(f64) * i
+ceil(f64) == f64
+ceil(f64) == i
+ceil(f64) ^ i
+ceil(f64) | median(1.0, i, i)
+ceil(false ?: 0)
+ceil(false ?: 1)
+ceil(findIndex($env, true))
+ceil(findIndex(array, true))
+ceil(findLastIndex($env, true))
 ceil(first(array))
-ceil(float(0.5))
-ceil(float(1))
+ceil(float(1.0))
 ceil(float(f64))
 ceil(float(i))
-ceil(float(i32))
-ceil(float(i64))
-ceil(floor(0.5))
+ceil(floor(0))
 ceil(floor(1))
+ceil(floor(1.0))
 ceil(floor(f64))
 ceil(floor(i))
-ceil(floor(i32))
-ceil(floor(i64))
-ceil(get(array, 1))
-ceil(get(array, i))
-ceil(half(0.5))
-ceil(half(1))
-ceil(half(f64))
 ceil(i % i)
-ceil(i * 0.5)
-ceil(i * i)
-ceil(i ** f64)
-ceil(i ** i)
-ceil(i + 0.5)
+ceil(i * 1)
+ceil(i * 1.0)
+ceil(i ** 0)
+ceil(i ** 1)
+ceil(i ** 1.0)
 ceil(i + 1)
-ceil(i + f32)
-ceil(i + i64)
+ceil(i + i)
+ceil(i - 0)
+ceil(i - 1.0)
 ceil(i - i)
-ceil(i / f32)
+ceil(i / 1)
+ceil(i / 1.0)
+ceil(i / f64)
 ceil(i / i)
-ceil(i / i64)
+ceil(i ^ 0)
+ceil(i ^ f64)
 ceil(i ^ i)
-ceil(i ^ i32)
+ceil(i | min(0))
+ceil(i | min(1.0))
 ceil(i)
-ceil(i) != i32
-ceil(i) * f64
-ceil(i) * i64
-ceil(i) ** f64
-ceil(i) + i
-ceil(i) - f32
-ceil(i) / f32
-ceil(i) <= f64
-ceil(i) == i32
-ceil(i) > i64
-ceil(i32 * i)
-ceil(i32 * i32)
-ceil(i32 ** i32)
-ceil(i32 + 0.5)
-ceil(i32 + i32)
-ceil(i32 - 0.5)
-ceil(i32 - 1)
-ceil(i32 - i)
-ceil(i32 - i64)
-ceil(i32 / 0.5)
-ceil(i32 / f32)
-ceil(i32 / i)
-ceil(i32 / i32)
-ceil(i32 ^ 0.5)
-ceil(i32 ^ i64)
-ceil(i32)
-ceil(i32) * 1 ^ i32
-ceil(i32) * i32
-ceil(i32) ** max(i)
-ceil(i32) + f32
-ceil(i32) + i
-ceil(i32) + i32
-ceil(i32) <= i64
-ceil(i32) not in array
-ceil(i64 % 1)
-ceil(i64 % i32)
-ceil(i64 * f32)
-ceil(i64 * f64)
-ceil(i64 ** i32)
-ceil(i64 ** i64)
-ceil(i64 + 0.5)
-ceil(i64 + f64)
-ceil(i64 + i32)
-ceil(i64 - 0.5)
-ceil(i64 - f64)
-ceil(i64 / 0.5)
-ceil(i64 / 1)
-ceil(i64 / f64)
-ceil(i64 ^ 0.5)
-ceil(i64 ^ i)
-ceil(i64 ^ i32)
-ceil(i64 ^ i64)
-ceil(i64)
-ceil(i64) - -1
-ceil(i64) - f32
-ceil(i64) - i32
-ceil(i64) / (0.5 - f32)
-ceil(i64) >= f32
-ceil(i64) ^ i32
-ceil(int(0.5))
-ceil(int(f32))
+ceil(i) != 0 ?: 1.0
+ceil(i) == i
+ceil(i) > i
+ceil(i) >= f64
+ceil(if false { false } else { f64 })
+ceil(if true { 1.0 } else { 1.0 })
+ceil(if true { 1.0 } else { f64 })
+ceil(if true { i } else { foo })
+ceil(indexOf(str, str))
+ceil(int(0))
+ceil(int(1))
+ceil(int(1.0))
 ceil(int(f64))
 ceil(int(i))
-ceil(int(i64))
-ceil(len("bar"))
+ceil(last(array))
+ceil(len($env))
 ceil(len(array))
 ceil(len(list))
-ceil(max(1, i))
-ceil(max(f32, 0.5))
+ceil(len(str))
+ceil(let foobar = 1.0; foobar)
+ceil(list | reduce(0))
+ceil(list | reduce(0, 1.0))
+ceil(list | reduce(f64))
+ceil(list | sum(i))
+ceil(max(0))
+ceil(max(1))
+ceil(max(1.0))
+ceil(max(array))
 ceil(max(f64))
 ceil(max(i))
+ceil(mean(1))
+ceil(mean(1.0 ^ 1.0))
+ceil(mean(1.0))
 ceil(mean(array))
+ceil(mean(f64))
+ceil(mean(f64, 1))
+ceil(mean(i))
+ceil(mean(i, i, 0))
+ceil(median(0))
+ceil(median(1.0))
+ceil(median(1.0, 0))
+ceil(median(1.0, i))
 ceil(median(array))
-ceil(min(0.5, f32))
+ceil(median(f64))
+ceil(median(i))
+ceil(median(i, 1.0))
+ceil(min(0))
 ceil(min(1))
-ceil(min(f32))
+ceil(min(1.0))
+ceil(min(1.0, f64))
+ceil(min(1.0, i))
+ceil(min(array))
 ceil(min(f64))
-ceil(min(i))
-ceil(min(i64))
-ceil(ok ? f32 : nil)
-ceil(ok ? i32 : "bar")
-ceil(ok ? i32 : i64)
 ceil(reduce(array, #))
-ceil(reduce(array, 0.5))
-ceil(reduce(list, 1))
-ceil(round(0.5))
-ceil(round(1))
-ceil(round(f32))
-ceil(round(f64))
+ceil(reduce(array, #acc))
+ceil(reduce(array, 1.0))
+ceil(reduce(list, 0))
+ceil(round(0))
+ceil(round(1.0))
 ceil(round(i))
-ceil(round(i32))
-ceil(round(i64))
-ceil(score(1))
-ceil(score(i))
-ceil(true ? 1 : half)
-ceil(true ? 1 : nil)
-ceil(true ? f64 : nil)
-count(["bar", score, i], 1 != #)
-count(["bar"], # startsWith #)
-count([0.5], ok)
-count([greet], ok)
-count([i32], f32 != #)
-count([list, 0.5], # not in list)
-count([nil], ok)
-count(array, !ok)
-count(array, !true)
-count(array, "bar" <= "bar")
-count(array, "bar" not endsWith "bar")
-count(array, "foo" matches "foo")
-count(array, # != #)
-count(array, # != 0.5)
+ceil(sum(array))
+ceil(sum(list, 1.0))
+concat($env | map(1.0))
+concat($env | map(1.0))[:i]
+concat($env | map(add))
+concat($env | map(array))
+concat($env | map(foo))
+concat($env.array)
+concat($env.list)
+concat($env?.array)
+concat($env?.list)
+concat(0 .. i)
+concat(1 .. 0)
+concat(1 .. 1)
+concat(1..i)
+concat([$env, 1])
+concat([$env, nil])
+concat([$env])
+concat([0])
+concat([1, foo])
+concat([1.0 - 1.0])
+concat([1.0, $env])
+concat([1.0])
+concat([1])
+concat([array])
+concat([f64, foo])
+concat([false, $env])
+concat([false])
+concat([foo, array])
+concat([foo])
+concat([greet, 0])
+concat([greet])
+concat([i, 1.0])
+concat([list])
+concat([nil])
+concat([ok, $env])
+concat([ok])
+concat([str])
+concat([true])
+concat([true], array)
+concat(array | map(#))
+concat(array | map(foo))
+concat(array | sortBy(#))
+concat(array | sortBy(f64))
+concat(array | sortBy(i))
+concat(array | take(0))
+concat(array)
+concat(array) | groupBy(1.0)
+concat(array) | map(list)
+concat(array) | reduce(#)
+concat(array) | reduce(str)
+concat(array) | sortBy(f64)
+concat(array)?.[i]
+concat(array, [greet])
+concat(array, array)
+concat(array, array)?.[i]
+concat(array, list)
+concat(array[0:])
+concat(array[:1])
+concat(array[:])
+concat(array[i:])
+concat(concat(array))
+concat(concat(array, array))
+concat(false ?: array)
+concat(false ?: list)
+concat(filter($env, false))
+concat(flatten(array))
+concat(flatten(list))
+concat(keys($env))
+concat(list | filter(ok))
+concat(list | map(#))
+concat(list | map(1))
+concat(list | map(1.0))
+concat(list)
+concat(list) | count(false)
+concat(list) | groupBy(#)
+concat(list) | groupBy(1.0)
+concat(list) | map(0)
+concat(list) | map(add)
+concat(list) | map(foo)
+concat(list) | none(ok)
+concat(list) | reduce(#)
+concat(list) | reduce(1.0, foo)
+concat(list) | reduce(i, str)
+concat(list) | sum(1)
+concat(list) | sum(i)
+concat(list)?.[i]
+concat(list, array)
+concat(list, list | sortBy(i))
+concat(list, list)
+concat(list, list) | any(true)
+concat(map($env, #index))
+concat(map($env, $env))
+concat(map($env, array), list)
+concat(map($env, foo))
+concat(map(array, #))
+concat(map(array, $env))
+concat(map(array, 1))
+concat(map(array, 1.0))
+concat(map(array, f64))
+concat(map(list, #))
+concat(map(list, $env))
+concat(map(list, 0))
+concat(map(list, 1.0))
+concat(map(list, greet))
+concat(map(list, i))
+concat(reduce(list, array))
+concat(reverse(array))
+concat(reverse(list))
+concat(sort($env))
+concat(sort(array))
+concat(sortBy(array, #))
+concat(toPairs($env))
+concat(toPairs({foo: false, foo: add}))
+concat(uniq(array))
+concat(values($env))
+count($env | filter(false))
+count($env | map(foo), ok)
+count($env | map(ok))
+count($env | map(true))
+count($env, false) ^ i
+count($env, true) ** i
+count($env.list, foo != foo)
+count($env.list, ok)
+count($env?.[str], true != nil)
+count($env?.array, ok)
+count($env?.list, ok)
+count(1 .. 0)
+count([$env && false])
+count([false, false])
+count([false])
+count([false], #)
+count([ok])
+count([true])
+count(array | map(false))
+count(array | map(ok))
 count(array, # != i)
-count(array, # != i64)
-count(array, # != nil)
-count(array, # < #)
-count(array, # < i)
-count(array, # < i32)
-count(array, # <= #)
-count(array, # <= 0.5)
-count(array, # <= 1)
-count(array, # <= i)
-count(array, # <= i32)
-count(array, # == #)
-count(array, # == 0.5)
-count(array, # == 1)
-count(array, # == f32)
-count(array, # == i)
-count(array, # == i64)
-count(array, # == nil)
 count(array, # > #)
-count(array, # > 0.5)
-count(array, # > i)
-count(array, # > i64)
-count(array, # >= #)
-count(array, # >= 0.5)
-count(array, # >= 1)
-count(array, # >= f32)
 count(array, # >= i)
-count(array, # in array)
 count(array, # not in array)
-count(array, 0.5 != #)
-count(array, 0.5 < #)
-count(array, 0.5 <= #)
-count(array, 0.5 <= f32)
-count(array, 0.5 <= f64)
-count(array, 0.5 == #)
-count(array, 0.5 == f32)
-count(array, 0.5 == i)
-count(array, 0.5 > #)
-count(array, 1 != #)
-count(array, 1 != 0.5)
-count(array, 1 < #)
-count(array, 1 <= #)
-count(array, 1 == #)
-count(array, 1 >= #)
-count(array, any(array, true))
-count(array, div(#, 1) >= #)
-count(array, f32 <= #)
-count(array, f32 == #)
-count(array, f64 < #)
-count(array, f64 < f32)
-count(array, f64 <= #)
-count(array, f64 <= 1)
-count(array, f64 == #)
-count(array, false) ** i32
-count(array, false) + f32
-count(array, false) - i64
-count(array, false) / f64
-count(array, false) > i64 * i64
+count(array, $env != #)
+count(array, $env.ok)
+count(array, $env?.false != nil and ok)
+count(array, 1 != nil)
+count(array, 1.0 != #)
+count(array, array | none(true))
+count(array, false and $env)
+count(array, false) <= 1 ^ i
+count(array, false) ^ f64
 count(array, foo in list)
-count(array, foo not in list)
-count(array, i != #)
-count(array, i < #)
-count(array, i < 0.5)
-count(array, i <= #)
-count(array, i == #)
-count(array, i > i64)
 count(array, i >= #)
-count(array, i32 != #)
-count(array, i32 != i)
-count(array, i32 < #)
-count(array, i32 < 1)
-count(array, i32 <= #)
-count(array, i32 <= f32)
-count(array, i32 == #)
-count(array, i32 == 0.5)
-count(array, i32 > #)
-count(array, i32 >= #)
-count(array, i32 >= f32)
-count(array, i32 >= i32)
-count(array, i64 != i32)
-count(array, i64 != i64)
-count(array, i64 < #)
-count(array, i64 <= #)
-count(array, i64 == #)
-count(array, i64 == i64)
-count(array, i64 > 1)
-count(array, list != array)
-count(array, list != nil)
-count(array, nil != "foo")
-count(array, nil != f64)
-count(array, nil == 1)
-count(array, nil == list)
-count(array, nil == nil)
-count(array, none(array, false))
-count(array, not false)
-count(array, ok or false)
+count(array, nil == $env)
 count(array, ok)
-count(array, ok) * i32
-count(array, ok) ^ i
-count(array, reduce(list, false))
-count(array, true == ok)
-count(array, true) / f64
-count(filter(list, true), ok)
-count(groupBy(list, #).String, .div?.array)
-count(i .. 1, # == i)
-count(i .. i, ok)
-count(i32 .. i, # >= #)
-count(i64 .. 1, nil != f32)
-count(list, !false)
-count(list, !true)
-count(list, "bar" not matches "bar")
-count(list, "foo" in #)
-count(list, # != #)
-count(list, # == #)
-count(list, # == nil)
-count(list, # in list)
-count(list, 0.5 < f32)
-count(list, 0.5 <= 0.5)
-count(list, 0.5 <= i64)
-count(list, 0.5 > 0.5)
-count(list, 0.5 > 1)
-count(list, 0.5 > f32)
-count(list, 1 != i)
-count(list, 1 >= 0.5)
-count(list, 1 >= f32)
-count(list, f32 == i64)
-count(list, f32 >= f32)
-count(list, false && false)
-count(list, false) + -1
-count(list, false) / f64
-count(list, false) > f32
-count(list, foo == #)
-count(list, i != i64)
-count(list, i < 0.5)
-count(list, i <= i64)
-count(list, i > 1)
-count(list, i32 < f32)
-count(list, i32 < i64)
-count(list, i64 not in array)
-count(list, nil != #)
-count(list, nil != false)
-count(list, nil == list)
-count(list, not false)
+count(array, ok) ^ f64
+count(array, true) in array
+count(array[:0])
+count(filter($env, false))
+count(filter(list, # != #))
+count(i .. 0)
+count(list | filter(false))
+count(list | map(false))
+count(list | map(true))
+count(list, # != foo)
+count(list, # != nil)
+count(list, #.Bar == nil)
+count(list, $env == $env)
+count(list, $env in array)
+count(list, 0 != nil)
+count(list, 0 <= f64)
+count(list, 0 == i)
+count(list, 1 < i)
+count(list, 1.0 < 1.0)
+count(list, [#] | all(true))
+count(list, add == $env)
+count(list, f64 == nil)
+count(list, foo != $env)
+count(list, nil != 1.0)
+count(list, nil != true)
 count(list, ok)
-count(list, ok) % i64
-count(list, ok) / half(1)
-count(list, ok) / i
-count(list, ok) >= i32
-count(list, ok) ^ i
-count(list, ok) ^ i64
-count(list, true or ok)
-count(list, true || true)
-count(list, true) * f32
-count(list, true) == i
-count(map(array, #), # == i32)
-count(map(array, #), not true)
-count(map(array, #), ok)
-count(map(array, false), #)
-count(map(array, i), ok)
-count(map(array, i32), 1 == #)
-count(map(array, i64), f64 != nil)
-count(map(array, ok), !#)
-count(map(list, 0.5), "bar" == "foo")
-count(map(list, div), ok)
-count(map(list, f32), # == #)
-count(map(list, greet), ok)
-count(map(list, i32), # != i64)
-count(map(list, ok), #)
-count(map(list, ok), 0.5 <= i64)
-count(ok ? array : i64, # > 0.5)
-count(sort(array), 1 <= #)
-div
-div != add
-div != add != nil
-div != add == ok
-div != div
-div != div != ok
-div != div && ok
-div != div ? "bar" : "foo"
-div != nil == ok
-div != nil || f32 < 0.5
-div != reduce(array, div)
-div == add
-div == add ? 1 : ok
-div == div
-div == nil ? f32 : half
-div == nil ? false : 1
-div(-i, array[i64])
-div(-i, i)
-div(1, i) + i
-div(findLast(array, true), i)
-div(i, -1)
-div(i, i)
-div(last(array), 1 * i32)
-div(score(1), bitnot(1))
-f32
-f32 != -0.5
-f32 != -1
-f32 != -f32
-f32 != 0.5 != false
-f32 != 0.5 * 1
-f32 != 0.5 * i64
-f32 != 0.5 ** f32
-f32 != 0.5 + 1
-f32 != 0.5 - i64
-f32 != 0.5 / 0.5
-f32 != 0.5 / i32
-f32 != 0.5 == ok
-f32 != 0.5 == true
-f32 != 0.5 ? array : score
-f32 != 0.5 ? foo : f64
-f32 != 0.5 ? true : i32
-f32 != 0.5 ^ 1
-f32 != 0.5 ^ f32
-f32 != 1 && ok
-f32 != 1 * i
-f32 != 1 + i64
-f32 != f32
-f32 != f32 / 0.5
-f32 != f32 / f32
-f32 != f64
-f32 != findLast(array, ok)
-f32 != findLastIndex(array, ok)
-f32 != floor(0.5)
-f32 != half(0.5)
-f32 != i
-f32 != i != true
-f32 != i % 1
-f32 != i % i
-f32 != i ** i64
-f32 != i / f64
-f32 != i32
-f32 != i32 % i
-f32 != i32 * i32
-f32 != i32 + 0.5
-f32 != i64
-f32 != i64 != nil
-f32 != i64 != true
-f32 != i64 ? 0.5 : f64
-f32 != i64 ^ i32
-f32 != int(f32)
-f32 != int(i32)
-f32 != len(array)
-f32 != nil ? true : score
-f32 != nil || ok
-f32 != round(i)
-f32 != score(1)
-f32 != score(1, i)
-f32 * (0.5 + f64)
-f32 * (0.5 + i32)
-f32 * (0.5 - f32)
-f32 * (f64 + f64)
-f32 * (f64 + i64)
-f32 * (f64 - i)
-f32 * -0.5
-f32 * -1
-f32 * -f64
-f32 * -i
-f32 * -i64
-f32 * -len(array)
-f32 * 0.5 * 0.5
-f32 * 0.5 * i
-f32 * 0.5 * i32
-f32 * 0.5 - i32
-f32 * 0.5 / i
-f32 * 0.5 <= i
-f32 * 0.5 ^ f32
-f32 * 0.5 not in array
-f32 * 1 != f32
-f32 * 1 * f64
-f32 * 1 * i32
-f32 * 1 ** 0.5
-f32 * 1 + f64
-f32 * 1 < i64
-f32 * 1 >= i64
-f32 * 1 ^ i64
-f32 * ceil(i)
-f32 * f32
-f32 * f32 * 0.5
-f32 * f32 < i32
-f32 * f32 <= i64
-f32 * f32 > f32 - 1
-f32 * f32 ^ 0.5
-f32 * f32 in array
-f32 * f64
-f32 * f64 + f64
-f32 * f64 + i32
-f32 * f64 / i64
-f32 * f64 >= 1 - i
-f32 * float(i)
-f32 * float(i32)
-f32 * floor(0.5)
-f32 * floor(i)
-f32 * half(0.5)
-f32 * half(1)
-f32 * half(f64)
-f32 * i
-f32 * i != i32
-f32 * i - i
-f32 * i / f64
-f32 * i == i64
-f32 * i32
-f32 * i32 != max(i)
-f32 * i32 * i32
-f32 * i32 ** 0.5
-f32 * i32 >= i
-f32 * i64
-f32 * i64 != f64
-f32 * i64 ** i
-f32 * int(i64)
-f32 * min(i64)
-f32 * reduce(array, 1)
-f32 * reduce(list, 1)
-f32 * round(f64)
-f32 ** (0.5 + 0.5)
-f32 ** (0.5 - 1)
-f32 ** (0.5 / f32)
-f32 ** (1 / f64)
-f32 ** (f32 - 0.5)
-f32 ** (f64 - i64)
-f32 ** (i % 1)
-f32 ** (i64 * i32)
-f32 ** (i64 + 0.5)
-f32 ** (i64 - 1)
-f32 ** -0.5
-f32 ** -f32
-f32 ** -f64
-f32 ** -i
-f32 ** 0.5 != f32
-f32 ** 0.5 + f32
-f32 ** 0.5 >= -i64
-f32 ** 0.5 ^ (f32 / f64)
-f32 ** 0.5 ^ i64
-f32 ** 1 + i64
-f32 ** 1 / i
-f32 ** 1 < f64
-f32 ** 1 < i64
-f32 ** 1 <= i64
-f32 ** ceil(i64)
-f32 ** f32
-f32 ** f32 * f32
-f32 ** f32 ** f32
-f32 ** f32 < f64
-f32 ** f32 ^ f32
-f32 ** f32 ^ f64
-f32 ** f64
-f32 ** f64 ** 1
-f32 ** f64 <= f64
-f32 ** f64 >= i
-f32 ** float(f32)
-f32 ** float(f64)
-f32 ** half(0.5)
-f32 ** half(1)
-f32 ** i
-f32 ** i != half(1)
-f32 ** i ** f64
-f32 ** i ** i32
-f32 ** i <= i64
-f32 ** i32
-f32 ** i32 / i32
-f32 ** i32 == f64
-f32 ** i32 ^ f32
-f32 ** i64
-f32 ** i64 / f32
-f32 ** i64 == i32
-f32 ** i64 > i32
-f32 ** int(f64)
-f32 ** len("foo")
-f32 ** max(f32)
-f32 ** max(i32)
-f32 ** median(array)
-f32 ** reduce(array, 0.5)
-f32 ** round(f64)
-f32 + -0.5
-f32 + -1
-f32 + -f32
-f32 + -i
-f32 + 0.5 ** f32
-f32 + 0.5 + i32
-f32 + 0.5 - i
-f32 + 0.5 - i32
-f32 + 0.5 / f32
-f32 + 0.5 == i
-f32 + 0.5 > i64
-f32 + 0.5 ^ 0.5
-f32 + 1 * 0.5
-f32 + 1 * 1
-f32 + 1 + i
-f32 + 1 - f64
-f32 + 1 - i64
-f32 + 1 / f64
-f32 + 1 < f32
-f32 + 1 < i
-f32 + 1 >= ceil(0.5)
-f32 + bitnot(i64)
-f32 + ceil(-1)
-f32 + ceil(1)
-f32 + ceil(f32)
-f32 + f32
-f32 + f32 * 0.5
-f32 + f32 ** i64
-f32 + f32 - i32
-f32 + f32 / 1
-f32 + f32 > i32
-f32 + f32 ^ 0.5
-f32 + f64
-f32 + f64 in array
-f32 + findIndex(array, true)
-f32 + first(array)
-f32 + float(i)
-f32 + floor(1)
-f32 + floor(i64)
-f32 + half(1)
-f32 + half(f64)
-f32 + i
-f32 + i != i64
-f32 + i + 1
-f32 + i + i
-f32 + i - i32
-f32 + i == f64
-f32 + i32
-f32 + i32 != f32
-f32 + i32 % i
-f32 + i32 / f32
-f32 + i32 <= i
-f32 + i32 ^ 0.5
-f32 + i64
-f32 + i64 != f32
-f32 + i64 + 0.5
-f32 + i64 < f32
-f32 + i64 <= i32
-f32 + i64 >= i
-f32 + i64 >= i32
-f32 + int(1)
-f32 + int(f64)
-f32 + max(0.5)
-f32 + max(f64)
-f32 + reduce(array, #)
-f32 + round(1)
-f32 + round(i32)
-f32 + score(1)
-f32 + score(i)
-f32 - -1
-f32 - -f64
-f32 - -i
-f32 - 0.5 ** i64
-f32 - 0.5 + 0.5
-f32 - 0.5 + f64
-f32 - 0.5 - i64
-f32 - 0.5 < i
-f32 - 0.5 <= i32
-f32 - 0.5 <= i64
-f32 - 0.5 > f64
-f32 - 1 % i64
-f32 - 1 * i64
-f32 - 1 + 1
-f32 - 1 / 0.5
-f32 - 1 < i32
-f32 - 1 <= i32
-f32 - 1 == f32
-f32 - 1 >= f64
-f32 - abs(i32)
-f32 - abs(i64)
-f32 - bitshl(i, i32)
-f32 - ceil(f64)
-f32 - f32
-f32 - f32 ** i32
-f32 - f32 + i
-f32 - f32 == i
-f32 - f64
-f32 - f64 + f64
-f32 - f64 - i
-f32 - f64 <= f32
-f32 - i
-f32 - i >= f32
-f32 - i32
-f32 - i32 * 0.5
-f32 - i32 * f64
-f32 - i32 ** 1
-f32 - i32 <= f32
-f32 - i32 <= i32
-f32 - i32 >= abs(0.5)
-f32 - i64
-f32 - i64 ** 0.5
-f32 - len(array)
-f32 - max(1)
-f32 - min(0.5)
-f32 - min(0.5, 0.5)
-f32 - reduce(array, #)
-f32 - score(1)
-f32 - score(i)
-f32 / (0.5 - i32)
-f32 / (1 + i)
-f32 / (f64 - 0.5)
-f32 / (i - i32)
-f32 / (i32 + 1)
-f32 / -1
-f32 / -f64
-f32 / -i64
-f32 / 0.5 ** f64
-f32 / 0.5 / i
-f32 / 0.5 <= i64
-f32 / 0.5 ^ f64
-f32 / 1 * i32
-f32 / 1 <= f32
-f32 / 1 >= 0.5 ? f64 : foo
-f32 / 1 >= f32
-f32 / 1 >= i32
-f32 / array[1]
-f32 / array[i32]
-f32 / bitnot(i)
-f32 / ceil(1)
-f32 / ceil(f32)
-f32 / count(list, false)
-f32 / f32
-f32 / f32 / 0.5
-f32 / f32 ^ 1
-f32 / f64
-f32 / f64 * i32
-f32 / f64 + f32
-f32 / f64 - i32
-f32 / f64 / 1
-f32 / f64 / f64
-f32 / f64 / i64
-f32 / f64 < i
-f32 / float(1)
-f32 / float(i32)
-f32 / float(i64)
-f32 / floor(i)
-f32 / half(0.5)
-f32 / half(1)
-f32 / half(f64)
-f32 / i
-f32 / i * 0.5
-f32 / i / 0.5
-f32 / i <= i
-f32 / i == i32
-f32 / i > f64
-f32 / i32
-f32 / i32 * 1
-f32 / i32 * f32
-f32 / i32 ** f32
-f32 / i32 + i
-f32 / i32 + i64
-f32 / i32 < f64 + 0.5
-f32 / i32 >= i32
-f32 / i64
-f32 / i64 - f64
-f32 / i64 ^ 0.5
-f32 / int(0.5)
-f32 / int(1 * i64)
-f32 / max(0.5)
-f32 / min(i32)
-f32 / reduce(array, #)
-f32 / reduce(list, 1)
-f32 / score(i)
-f32 < -0.5
-f32 < -f64
-f32 < -i
-f32 < -i64
-f32 < 0.5 + 0.5
-f32 < 0.5 + 1
-f32 < 0.5 ^ f32
-f32 < 0.5 ^ i64
-f32 < 1 % 1
-f32 < 1 + f64
-f32 < 1 ? f64 : i
-f32 < 1 and ok
-f32 < abs(0.5)
-f32 < ceil(0.5)
-f32 < ceil(f64)
-f32 < count(array, ok)
-f32 < count(list, ok)
-f32 < f32
-f32 < f32 / 1
-f32 < f32 ^ f64
-f32 < f64
-f32 < f64 ** 1
-f32 < f64 + 0.5
-f32 < f64 + i
-f32 < f64 / i64
-f32 < f64 ? 0.5 : array
-f32 < f64 ? div : i32
-f32 < f64 and ok
-f32 < floor(0.5)
-f32 < floor(i)
-f32 < half(0.5)
-f32 < half(1)
-f32 < i
-f32 < i != ok
-f32 < i / 1
-f32 < i ? 1 : i
-f32 < i32
-f32 < i32 ** i64
-f32 < i32 ? f64 : i
-f32 < i32 ? greet : i32
-f32 < i32 or ok
-f32 < i64
-f32 < i64 - i32
-f32 < i64 / 0.5
-f32 < i64 ? foo : i32
-f32 < i64 ? foo?.Bar : div
-f32 < i64 ^ 0.5
-f32 < max(i)
-f32 < max(i32, 1)
-f32 < min(0.5)
-f32 < reduce(array, #)
-f32 < reduce(list, 1)
-f32 < round(i64)
-f32 <= -0.5
-f32 <= -1
-f32 <= -f64
-f32 <= -i64
-f32 <= 0.5 != true
-f32 <= 0.5 * 0.5
-f32 <= 0.5 + i
-f32 <= 0.5 / i64
-f32 <= 0.5 ? i64 : i
-f32 <= 1 - 0.5
-f32 <= 1 == nil
-f32 <= 1 ? f64 : add
-f32 <= 1 ? i64 : i64 % 1
-f32 <= 1 ? list : div
-f32 <= 1 || ok
-f32 <= f32
-f32 <= f32 * 1
-f32 <= f32 + f64
-f32 <= f32 + i
-f32 <= f32 ? greet : half
-f32 <= f64
-f32 <= findIndex(list, ok) * f64
-f32 <= float(1)
-f32 <= float(i)
-f32 <= float(i64)
-f32 <= float(toJSON(1))
-f32 <= floor(0.5)
-f32 <= half(0.5)
-f32 <= half(1)
-f32 <= half(f64)
-f32 <= i
-f32 <= i == nil
-f32 <= i and i32 <= f32
-f32 <= i32
-f32 <= i32 ** i32
-f32 <= i32 + 1
-f32 <= i32 / 1
-f32 <= i64
-f32 <= i64 ** i64
-f32 <= i64 - f32
-f32 <= i64 ? f64 : f64
-f32 <= i64 ^ i32
-f32 <= i64 || nil in array
-f32 <= last(array)
-f32 <= min(0.5)
-f32 <= min(1)
-f32 <= min(f64)
-f32 <= round(0.5)
-f32 <= score(1)
-f32 == -0.5
-f32 == -1
-f32 == -f32
-f32 == -i32
-f32 == -i64
-f32 == 0.5 != ok
-f32 == 0.5 * 0.5
-f32 == 0.5 * 1
-f32 == 0.5 ** i32
-f32 == 0.5 + 1
-f32 == 0.5 / i32
-f32 == 0.5 / i64
-f32 == 0.5 ? array : greet
-f32 == 0.5 ? true : score
-f32 == 0.5 ^ 0.5
-f32 == 0.5 || f64 >= 1
-f32 == 1 != nil
-f32 == 1 + f32
-f32 == 1 - 1
-f32 == 1 - i
-f32 == 1 == ok
-f32 == 1 ? foo : f32
-f32 == 1 ? ok : add != nil
-f32 == add(i, 1)
-f32 == array[i32]
-f32 == bitnot(i)
-f32 == ceil(1)
-f32 == ceil(i32)
-f32 == ceil(i64)
-f32 == f32
-f32 == f32 ? f32 : list
-f32 == f32 and ok
-f32 == f64
-f32 == f64 + f64
-f32 == f64 ^ 1
-f32 == findLastIndex(array, ok)
-f32 == first(array)
-f32 == float(0.5)
-f32 == float(1)
-f32 == floor(f64)
-f32 == half(1)
-f32 == half(f64)
-f32 == i
-f32 == i != nil
-f32 == i - 0.5
-f32 == i - i64
-f32 == i32
-f32 == i32 + i32
-f32 == i32 ? 0.5 : array
-f32 == i32 ? i64 : i64
-f32 == i32 ? true : half
-f32 == i32 ^ i32
-f32 == i32 or ok
-f32 == i64
-f32 == i64 * i64
-f32 == i64 + 0.5
-f32 == i64 - 0.5
-f32 == i64 - 1
-f32 == i64 ? div : 0.5
-f32 == last(array)
-f32 == max(f64)
-f32 == min(0.5)
-f32 == min(f32)
-f32 == nil ? array : add
-f32 == nil ? i : div
-f32 == round(1)
-f32 == score(1)
-f32 == score(i)
-f32 > -(0.5 / 1)
-f32 > -0.5
-f32 > -f32
-f32 > -i32
-f32 > 0.5 / f32
-f32 > 0.5 / i32
-f32 > 0.5 == true ? i32 : array
-f32 > 0.5 ? half : false
-f32 > 0.5 ^ f64
-f32 > 1 ** i
-f32 > 1 ? 1 : false
-f32 > 1 ? list : "foo"
-f32 > abs(1)
-f32 > abs(f32)
-f32 > abs(f64)
-f32 > count(array, ok)
-f32 > f32
-f32 > f32 + f32
-f32 > f32 - f32
-f32 > f32 == nil
-f32 > f64
-f32 > f64 * i
-f32 > f64 ** 0.5
-f32 > float(0.5)
-f32 > float(i32)
-f32 > floor(1)
-f32 > half(1)
-f32 > half(f64)
-f32 > i
-f32 > i != ok
-f32 > i * 1
-f32 > i ? array : 1
-f32 > i ? foo : list
-f32 > i32
-f32 > i32 != nil
-f32 > i32 * f64
-f32 > i32 ? 0.5 : greet
-f32 > i32 and ok
-f32 > i64
-f32 > i64 % i64
-f32 > i64 ** i
-f32 > i64 + 0.5
-f32 > i64 - i64
-f32 > i64 ? i : 0.5
-f32 > mean(array)
-f32 > min(f32)
-f32 > min(i64)
-f32 > reduce(array, #)
-f32 > reduce(array, i64)
-f32 > reduce(list, f32)
-f32 > round(0.5)
-f32 > score(1, 1)
-f32 >= -0.5
-f32 >= -f32
-f32 >= -f64
-f32 >= 0.5 * f64
-f32 >= 0.5 / i64
-f32 >= 0.5 ? i64 : nil
-f32 >= 0.5 ^ i64
-f32 >= 1 == false
-f32 >= 1 == ok ? add : array
-f32 >= 1 ? i : 1
-f32 >= abs(0.5)
-f32 >= abs(f32)
-f32 >= abs(i)
-f32 >= array[1]
-f32 >= array[i32]
-f32 >= bitnot(i32)
-f32 >= count(list, false)
-f32 >= f32
-f32 >= f32 ** 1
-f32 >= f32 - i64
-f32 >= f32 ? half : greet
-f32 >= f32 or nil != ok
-f32 >= f64
-f32 >= f64 && ok
-f32 >= f64 ** 0.5
-f32 >= f64 ** i32
-f32 >= f64 - f64
-f32 >= f64 / i64
-f32 >= f64 or ok
-f32 >= float(0.5)
-f32 >= half(f64)
-f32 >= i
-f32 >= i - f32
-f32 >= i ? 1 : nil
-f32 >= i ^ i
-f32 >= i32
-f32 >= i32 % i
-f32 >= i32 - f32
-f32 >= i32 / i64
-f32 >= i32 ? f32 : 0.5
-f32 >= i32 or not ok
-f32 >= i64
-f32 >= i64 * i32
-f32 >= i64 + f64
-f32 >= i64 / 1
-f32 >= len("bar")
-f32 >= max(i)
-f32 >= max(i64)
-f32 >= reduce(array, #)
-f32 >= score(1)
-f32 >= sum(array)
-f32 ^ (0.5 * f64)
-f32 ^ (0.5 / 1)
-f32 ^ (0.5 / i)
-f32 ^ (1 * i)
-f32 ^ (1 + f64)
-f32 ^ (f32 * i64)
-f32 ^ (f64 * f64)
-f32 ^ (f64 - 1)
-f32 ^ (f64 / i)
-f32 ^ (i64 * f64)
-f32 ^ (i64 * i32)
-f32 ^ (i64 * i64)
-f32 ^ (i64 + i64)
-f32 ^ (i64 - f32)
-f32 ^ -0.5
-f32 ^ -1
-f32 ^ -i32
-f32 ^ 0.5 ** i32
-f32 ^ 0.5 - f32
-f32 ^ 0.5 - i32
-f32 ^ 0.5 == i64
-f32 ^ 0.5 ^ 0.5
-f32 ^ 1 != i64
-f32 ^ 1 / f32
-f32 ^ 1 >= -0.5
-f32 ^ abs(1)
-f32 ^ abs(f32)
-f32 ^ array[i64]
-f32 ^ array[i]
-f32 ^ bitnot(1)
-f32 ^ bitor(1, i32)
-f32 ^ f32
-f32 ^ f32 ^ 0.5
-f32 ^ f32 in array
-f32 ^ f64
-f32 ^ f64 ** f64
-f32 ^ f64 / 1 * 1
-f32 ^ f64 / f64
-f32 ^ f64 == i64
-f32 ^ f64 not in array
-f32 ^ floor(0.5)
-f32 ^ floor(1)
-f32 ^ half(1)
-f32 ^ half(f64)
-f32 ^ i
-f32 ^ i - f64
-f32 ^ i <= i
-f32 ^ i >= f64
-f32 ^ i ^ f32
-f32 ^ i32
-f32 ^ i32 ** i64
-f32 ^ i64
-f32 ^ i64 ** 1
-f32 ^ i64 + i64
-f32 ^ i64 - f32
-f32 ^ i64 >= f64
-f32 ^ i64 ^ f32
-f32 ^ int(i32)
-f32 ^ len("foo")
-f32 ^ len(array)
-f32 ^ min(1)
-f32 ^ min(f64)
-f32 ^ min(i)
-f32 ^ reduce(array, 1)
-f32 ^ round(i)
-f32 ^ round(i32)
-f32 ^ score(i)
-f32 ^ score(reduce(array, #))
-f32 in [i]
-f32 in [nil]
-f32 in array
-f32 in array == nil
-f32 in array ? 1 : i
-f32 in array ? false : 0.5
-f32 in array ? nil : "bar"
-f32 in groupBy(array, #)
-f32 in groupBy(list, #)
-f32 in groupBy(list, ok)
-f32 in map(array, #)
-f32 not in [f32, "bar"]
-f32 not in array
-f32 not in array ? foo : i
-f32 not in array ? i32 : div
+count(list, ok) .. 1 | take(1)
+count(list, str != $env)
+count(list, true != nil)
+count(list[:0])
+count(map($env, $env), ok == $env)
+count(map($env, false))
+count(map($env, ok))
+count(map($env, true))
+count(map($env, true)) >= f64
+count(map(array, false))
+count(map(list, false))
+count(map(list, ok))
+count(sort($env))
+count(sort($env), # < #.str)
+count(sort($env), #)
+count(sort($env), #.str && #)
+count(toPairs($env), 0 in #)
+date(str, str)
+duration(string(0))
+duration(toJSON(0))
 f64
-f64 != -0.5
-f64 != -1
-f64 != -f32
-f64 != -i
-f64 != -i64
-f64 != 0.5 != false
-f64 != 0.5 ** 1
-f64 != 0.5 ** f64
-f64 != 0.5 + f32
-f64 != 0.5 ^ 0.5
-f64 != 1 - 1
-f64 != 1 / 0.5
-f64 != 1 ? half : div
-f64 != 1 ^ i
-f64 != abs(i32)
-f64 != bitnot(i64)
-f64 != ceil(i)
-f64 != f32
-f64 != f32 != nil
-f64 != f32 + 0.5
-f64 != f32 + i32
-f64 != f32 - i32
-f64 != f32 ? array : nil
-f64 != f32 ? i32 : "bar"
-f64 != f32 ? ok : i
-f64 != f32 or greet == nil
+f64 != $env == false
+f64 != $env ?: false
+f64 != $env or $env
+f64 != $env or ok
+f64 != $env || $env
+f64 != $env || false
+f64 != $env.f64
+f64 != $env.i
+f64 != $env?.$env
+f64 != $env?.Bar
+f64 != $env?.Bar?.[ok]
+f64 != $env?.Bar?.list()
+f64 != $env?.String
+f64 != $env?.[Bar]
+f64 != $env?.[Bar]?.String
+f64 != $env?.[Bar]?.add
+f64 != $env?.[String]
+f64 != $env?.[foobar]
+f64 != $env?.[str]
+f64 != $env?.f64
+f64 != $env?.foobar
+f64 != $env?.i
+f64 != $env?.nil
+f64 != $env?.true
+f64 != 0 != true
+f64 != 0 + i
+f64 != 0 - i
+f64 != 0 == $env
+f64 != 0 == nil
+f64 != 1 / i
+f64 != 1 and $env
+f64 != 1 || $env
+f64 != 1.0 != $env
+f64 != 1.0 != nil
+f64 != 1.0 - 0
+f64 != 1.0 - 1
+f64 != 1.0 - i
+f64 != 1.0 == true
+f64 != 1.0 ?: add
+f64 != 1.0 and false
+f64 != 1.0 or $env
+f64 != array?.[i]
 f64 != f64
-f64 != f64 * f32
-f64 != f64 ? f64 : true
-f64 != first(array)
-f64 != floor(1)
-f64 != half(0.5)
-f64 != half(1)
+f64 != f64 && $env
+f64 != f64 and true
+f64 != float(i)
+f64 != floor(f64)
+f64 != floor(i)
 f64 != i
-f64 != i * 0.5
-f64 != i / 1
-f64 != i / f32
-f64 != i ^ f64
-f64 != i32
-f64 != i32 * f32
-f64 != i32 == ok
-f64 != i32 ? f64 : ok
-f64 != i32 ? foo : ok
-f64 != i32 ^ i32
-f64 != i64
-f64 != i64 * f64
-f64 != i64 - i32
-f64 != i64 or ok
-f64 != int(i64)
-f64 != min(f64)
-f64 != nil != ok
-f64 != nil && f64 > 0.5
-f64 != nil == true
-f64 != nil ? array : foo
-f64 != nil ? f64 : half
-f64 != nil ? i64 : 0.5
-f64 != nil ? nil : half
-f64 != round(1)
-f64 * (0.5 - 1)
-f64 * (i64 + 0.5)
-f64 * -1
-f64 * -f32
-f64 * -f64
-f64 * 0.5 * 1
-f64 * 0.5 * i64
-f64 * 0.5 ** 0.5
-f64 * 0.5 / 0.5
-f64 * 0.5 / f32
-f64 * 0.5 / i32
-f64 * 0.5 < f32
-f64 * 0.5 <= i
-f64 * 0.5 == f64
-f64 * 0.5 ^ 1
-f64 * 1 * f64
-f64 * 1 * i32
-f64 * 1 ** 1
-f64 * 1 + f64
-f64 * 1 - i32
-f64 * 1 <= 1 + 1
-f64 * 1 == i64
-f64 * 1 > f32
-f64 * 1 > f64
-f64 * 1 >= f64
-f64 * bitnot(i64)
-f64 * ceil(i)
-f64 * ceil(i64)
-f64 * f32
-f64 * f32 != i
-f64 * f32 / i64
-f64 * f32 > f64
-f64 * f32 > i
+f64 != i != false
+f64 != i && $env
+f64 != i * f64
+f64 != i and $env
+f64 != i and nil not in array
+f64 != i and true
+f64 != int(1.0)
+f64 != last($env)
+f64 != len($env)
+f64 != mean(0)
+f64 != mean(1.0)
+f64 != mean(array)
+f64 != median(1.0)
+f64 != nil != false
+f64 != nil && $env
+f64 != nil or $env
+f64 != round(1.0)
+f64 * $env.f64
+f64 * $env.i
+f64 * $env?.f64
+f64 * $env?.i
+f64 * 0 * 1.0
+f64 * 0 + 1
+f64 * 0 - 1.0
+f64 * 1 != nil
+f64 * 1 * 0
+f64 * 1 * i
+f64 * 1 <= i
+f64 * 1 == nil
+f64 * 1 in array
+f64 * 1.0
+f64 * 1.0 != i
+f64 * 1.0 * 1.0
+f64 * 1.0 * f64
+f64 * 1.0 ** f64
+f64 * 1.0 < 0
+f64 * 1.0 < 1
+f64 * 1.0 | max(0)
+f64 * abs(1.0)
+f64 * array?.[1]
+f64 * array?.[i]
+f64 * bitnot(0)
 f64 * f64
-f64 * f64 * f64
-f64 * f64 / 1
-f64 * f64 <= f64
-f64 * f64 > f64
-f64 * f64 in array
-f64 * float(f32)
-f64 * floor(0.5)
-f64 * get(array, 1)
-f64 * half(f64)
+f64 * f64 * i
+f64 * f64 / i
+f64 * f64 > 1
+f64 * float(0)
+f64 * float(f64)
+f64 * float(i)
 f64 * i
-f64 * i / f64
-f64 * i32
-f64 * i32 != i64 * f64
-f64 * i32 - i32
-f64 * i64
-f64 * i64 ** i
-f64 * i64 == i
-f64 * i64 > i32
-f64 * i64 ^ i32
-f64 * median(array)
-f64 * min(1)
-f64 * min(f64)
-f64 * min(i)
-f64 * round(1)
-f64 * round(i64)
-f64 ** (0.5 - i)
-f64 ** (0.5 / i64)
-f64 ** (1 * i)
-f64 ** (f64 * i32)
-f64 ** (f64 / 1)
-f64 ** (i * 1)
-f64 ** (i * i64)
-f64 ** (i32 * i)
-f64 ** (i32 + i32)
-f64 ** (i32 - f64)
-f64 ** (i32 / i64)
-f64 ** (i64 % 1)
-f64 ** (i64 + 0.5)
-f64 ** (i64 + i64)
-f64 ** (i64 - i32)
-f64 ** (i64 / 0.5)
-f64 ** -0.5
-f64 ** -1
-f64 ** -i
-f64 ** 0.5 ** f32
-f64 ** 0.5 == i32
-f64 ** 1 + f64
-f64 ** 1 / i
-f64 ** 1 < f32
-f64 ** 1 > i32
-f64 ** 1 ^ f32
-f64 ** abs(i)
-f64 ** bitand(1, 1)
-f64 ** ceil(0.5)
-f64 ** ceil(f64)
-f64 ** f32
-f64 ** f32 != f64
-f64 ** f32 ** f64
-f64 ** f32 > f64
+f64 * i != $env?.i
+f64 * i != sum(array)
+f64 * i ** 1.0
+f64 * i == nil
+f64 * i > $env?.f64
+f64 * int(1)
+f64 * int(1.0)
+f64 * len($env)
+f64 * len(foo.Bar)
+f64 * len(str)
+f64 * min(array)
+f64 * sum(array | sortBy(#))
+f64 ** $env.f64
+f64 ** $env.i
+f64 ** $env?.f64
+f64 ** $env?.i
+f64 ** 0 ** f64
+f64 ** 0 >= 1.0
+f64 ** 1 != nil
+f64 ** 1 - i
+f64 ** 1 / 0
+f64 ** 1 < f64
+f64 ** 1.0 != $env
+f64 ** 1.0 != f64
+f64 ** 1.0 * 1.0
+f64 ** 1.0 + 0
+f64 ** 1.0 / i
+f64 ** 1.0 > 1
+f64 ** 1.0 ^ 1.0
+f64 ** 1.0 not in array
+f64 ** abs(mean(1.0))
+f64 ** array?.[i]
+f64 ** bitnot(0)
 f64 ** f64
-f64 ** f64 - f32
-f64 ** f64 / min(1)
-f64 ** f64 <= f32
-f64 ** f64 <= i64
-f64 ** f64 ^ 0.5
-f64 ** half(0.5)
+f64 ** f64 * 0
+f64 ** f64 * i
+f64 ** f64 + 1.0
+f64 ** f64 - 1.0
+f64 ** f64 ^ i
+f64 ** f64 | median(0)
+f64 ** float(1.0)
 f64 ** i
-f64 ** i * f64
-f64 ** i ** i
-f64 ** i + -i32
-f64 ** i + f32
-f64 ** i32
-f64 ** i32 != f64
-f64 ** i32 > f64
-f64 ** i64
-f64 ** i64 + f32
-f64 ** i64 <= f32
-f64 ** i64 not in map(array, 0.5)
-f64 ** last(array)
-f64 ** len("bar")
-f64 ** max(i)
-f64 ** min(f32)
-f64 ** reduce(array, #)
-f64 ** reduce(list, i32)
-f64 ** score(i)
-f64 + -0.5
-f64 + -1
-f64 + -f64
-f64 + -i
-f64 + -i32
-f64 + 0.5 / f32
-f64 + 0.5 < i32
-f64 + 0.5 <= f64
-f64 + 0.5 <= float(f32)
-f64 + 0.5 <= i
-f64 + 0.5 > f64
-f64 + 0.5 ^ i
-f64 + 0.5 ^ i64
-f64 + 1 % i
-f64 + 1 * 0.5
-f64 + 1 * 1
-f64 + 1 * f64
-f64 + 1 ** 0.5
-f64 + 1 + i32
-f64 + 1 / i64
-f64 + 1 ^ i
-f64 + 1 not in map(array, #)
-f64 + ceil(0.5)
-f64 + count(list, true)
-f64 + f32
-f64 + f32 == i != true
+f64 ** i >= i
+f64 ** i ^ i
+f64 ** mean(1.0)
+f64 ** mean(f64)
+f64 ** min(1.0)
+f64 ** min(f64)
+f64 ** round(f64)
+f64 ** sum(array)
+f64 + $env.f64
+f64 + $env.i
+f64 + $env?.f64
+f64 + $env?.i
+f64 + 0 * f64
+f64 + 0 ^ 1.0
+f64 + 0 ^ f64
+f64 + 1 * 0
+f64 + 1 * i
+f64 + 1 / 1.0
+f64 + 1 < 1.0
+f64 + 1 > $env and false
+f64 + 1 ^ f64
+f64 + 1.0 != f64
+f64 + 1.0 < 1.0
+f64 + 1.0 < int(0)
+f64 + 1.0 <= $env.i
+f64 + 1.0 <= 0
+f64 + 1.0 == 0
+f64 + 1.0 == nil
+f64 + 1.0 ^ 0
+f64 + 1.0 ^ 1.0
+f64 + 1.0 not in array
+f64 + 1.0 | max(1.0)
+f64 + abs(i)
+f64 + array?.[i]
+f64 + bitnot(i)
+f64 + ceil(1)
+f64 + count($env, true)
 f64 + f64
-f64 + f64 < f32
-f64 + f64 <= i32
-f64 + f64 ^ i32
-f64 + float(f64)
-f64 + floor(f64)
-f64 + get(array, i32)
-f64 + half(0.5)
-f64 + half(1)
+f64 + f64 ** 1.0
+f64 + f64 ^ i
 f64 + i
-f64 + i + 0.5
-f64 + i / 0.5
-f64 + i / i32
-f64 + i > 0.5 != true
-f64 + i > f64
-f64 + i >= f64
-f64 + i32
-f64 + i32 != i64
-f64 + i32 % i32
-f64 + i32 ** 1
-f64 + i32 > i64
-f64 + i64
-f64 + i64 + i64
-f64 + i64 / f64
-f64 + i64 > i32 / i
-f64 + i64 > i64
-f64 + i64 ^ i32
-f64 + reduce(array, #)
-f64 + reduce(list, f32)
-f64 + score(1)
-f64 - -0.5
-f64 - -1
-f64 - -f64
-f64 - -i
-f64 - -i64
-f64 - 0.5 - 0.5
-f64 - 0.5 - 1
-f64 - 0.5 - i32
-f64 - 0.5 >= f64
-f64 - 0.5 ^ i64
-f64 - 1 * i32
-f64 - 1 + i64
-f64 - 1 - f64
-f64 - 1 / i64
-f64 - 1 < f32
-f64 - 1 < f32 ? i64 : false
-f64 - 1 >= len(array)
-f64 - 1 ^ i64
-f64 - f32
-f64 - f32 != i64
-f64 - f32 + f32
-f64 - f32 < f64
-f64 - f32 ^ f32
+f64 + i != 0
+f64 + i ** 1
+f64 + i - 1
+f64 + i / i
+f64 + i == i
+f64 + i > 1.0
+f64 + i in array
+f64 + int(i)
+f64 + min(f64)
+f64 + sum(array)
+f64 + sum(list, 1)
+f64 - $env.f64
+f64 - $env.i
+f64 - $env?.f64
+f64 - $env?.i
+f64 - 0 / 1
+f64 - 0 / f64
+f64 - 0 < 0
+f64 - 0 < 1
+f64 - 0 > 0
+f64 - 0 > f64
+f64 - 1 != $env
+f64 - 1 <= 1 + f64
+f64 - 1 > i
+f64 - 1 not in $env?.[Bar]
+f64 - 1 | mean(1.0)
+f64 - 1.0 - 0
+f64 - 1.0 - 1.0
+f64 - 1.0 / i
+f64 - 1.0 == f64
+f64 - 1.0 > 1
+f64 - array?.[i]
+f64 - bitxor(i, i)
+f64 - ceil(f64)
 f64 - f64
-f64 - f64 + -1
-f64 - f64 < f64
-f64 - float(f32)
-f64 - floor(1)
-f64 - half(1)
+f64 - f64 < i
+f64 - f64 <= f64
+f64 - floor(0)
 f64 - i
-f64 - i + 0.5
-f64 - i + 1
-f64 - i + i32
-f64 - i / i
-f64 - i ^ f32
-f64 - i32
-f64 - i32 / 0.5
-f64 - i32 >= i64
-f64 - i32 ^ 0.5
-f64 - i64
-f64 - i64 ** i32
-f64 - int(i)
-f64 - int(i32)
-f64 - reduce(array, -#)
-f64 - round(1)
-f64 - score(i)
-f64 / (0.5 - 1)
-f64 / (0.5 - i64)
-f64 / (f32 + 1)
-f64 / (i + 0.5)
-f64 / (i32 + i64)
-f64 / -0.5
-f64 / -1
-f64 / -f64
-f64 / -i
-f64 / -i32
-f64 / -i64
-f64 / 0.5 != f64
-f64 / 0.5 * f32
-f64 / 0.5 + f64
-f64 / 0.5 / 1
-f64 / 0.5 < i32
-f64 / 0.5 == i32
-f64 / 0.5 >= i64
-f64 / 1 != i
-f64 / 1 * i32
-f64 / 1 ** 1
+f64 - i >= 1
+f64 - i >= i
+f64 - i | median(1.0)
+f64 - last(array)
+f64 - len(str)
+f64 - max(array)
+f64 - max(f64)
+f64 - median(1.0)
+f64 - median(array)
+f64 - min(1.0, array)
+f64 / $env.f64
+f64 / $env.i
+f64 / $env?.f64
+f64 / $env?.i
+f64 / 0 != 1.0
+f64 / 0 + i
+f64 / 0 - 1.0
+f64 / 1 / 1.0
 f64 / 1 / i
-f64 / 1 <= i64
-f64 / 1 ^ i
-f64 / abs(f64)
-f64 / array[1]
-f64 / array[i64]
-f64 / ceil(i32)
-f64 / f32
-f64 / f32 * i
-f64 / f32 * i64
-f64 / f32 / 0.5
-f64 / f32 == f32
-f64 / f32 ^ 0.5
+f64 / 1 <= 0
+f64 / 1.0 != 1
+f64 / 1.0 != f64
+f64 / 1.0 ** 1.0
+f64 / 1.0 - 1
+f64 / 1.0 <= 1.0
+f64 / 1.0 >= 0
+f64 / 1.0 ^ 1.0
+f64 / 1.0 ^ f64
+f64 / abs(1.0)
+f64 / abs(i)
+f64 / add(i, 1)
+f64 / array?.[i]
+f64 / ceil(1.0)
 f64 / f64
-f64 / f64 / 0.5
-f64 / f64 >= f64
-f64 / f64 >= i32
-f64 / f64 >= i64
-f64 / float(1)
-f64 / float(f64)
-f64 / floor(i64)
-f64 / get(array, 1)
-f64 / get(array, i32)
-f64 / half(0.5)
-f64 / half(1)
+f64 / f64 ** i
+f64 / f64 / 1.0
+f64 / f64 <= f64
+f64 / first(array)
+f64 / float(1.0)
 f64 / i
-f64 / i != f64
-f64 / i ** 0.5
-f64 / i ** f32
-f64 / i + i32
-f64 / i == i64
-f64 / i >= i
-f64 / i32
-f64 / i32 != 0.5 - i64
-f64 / i32 == f64 ** i
-f64 / i32 == i32
-f64 / i32 >= f32
-f64 / i64
-f64 / i64 < f64
-f64 / int(f32)
-f64 / last(array)
-f64 / max(i)
-f64 / reduce(array, #)
-f64 / reduce(array, f64)
-f64 / reduce(list, f32)
-f64 / round(1)
-f64 / round(i64)
-f64 / score(1)
-f64 < -0.5
-f64 < -i32
-f64 < -i64
-f64 < 0.5 + i64
-f64 < 0.5 / 0.5
-f64 < 0.5 / i
-f64 < 0.5 == true
-f64 < 0.5 ? f64 : array
+f64 / i >= 1.0
+f64 / len($env)
+f64 / max(1)
+f64 / max(f64, f64)
+f64 / mean(1)
+f64 / mean(array)
+f64 < $env.f64
+f64 < $env.i
+f64 < $env?.f64
+f64 < $env?.i
+f64 < 0 % 1
+f64 < 0 ** f64
+f64 < 0 + 1.0
+f64 < 0 + i
+f64 < 0 < $env > $env
+f64 < 0 <= $env?.[array]
+f64 < 0 == false
+f64 < 0 or true
 f64 < 1 % 1
-f64 < 1 * 0.5
-f64 < 1 ** i32
-f64 < 1 / f32
-f64 < 1 == false
-f64 < 1 ? i : "foo"
+f64 < 1 / 0
+f64 < 1 <= f64
+f64 < 1 or ok
+f64 < 1 or true
+f64 < 1.0 && $env
+f64 < 1.0 - 1.0
+f64 < 1.0 - f64
+f64 < 1.0 / 1
+f64 < 1.0 / 1.0
+f64 < 1.0 / f64
+f64 < 1.0 < 1.0
+f64 < 1.0 <= i
+f64 < 1.0 == false
+f64 < 1.0 >= 1.0 == true
+f64 < 1.0 ?: true
 f64 < abs(1)
-f64 < abs(f32)
-f64 < array[i64]
-f64 < bitnot(1)
-f64 < ceil(f64)
-f64 < count(array, false)
-f64 < f32
-f64 < f32 * i
-f64 < f32 / i64
-f64 < f32 ^ 1
-f64 < f32 ^ f64
+f64 < array?.[i]
+f64 < ceil(1.0)
+f64 < count(list, true)
 f64 < f64
-f64 < f64 == ok
-f64 < floor(i64)
-f64 < get(array, i)
+f64 < f64 > 0
+f64 < f64 ?: ok
+f64 < f64 in $env?.String
+f64 < float(1)
+f64 < floor(1)
+f64 < floor(f64)
 f64 < i
-f64 < i && "bar" < "bar"
-f64 < i && ok
-f64 < i ** i32
-f64 < i + 1
-f64 < i ? 0.5 : "bar"
-f64 < i ? div : nil
-f64 < i32
-f64 < i32 * f64
-f64 < i32 * i
-f64 < i32 ** f32
-f64 < i32 ** i64
-f64 < i32 + f32
-f64 < i32 + f64
-f64 < i32 + i64
-f64 < i32 ? false : ok
-f64 < i32 ? true : 1
-f64 < i32 ^ 1
-f64 < i32 ^ i32
-f64 < i64
-f64 < i64 * f64
-f64 < i64 ^ i
-f64 < int(0.5)
-f64 < max(1)
-f64 < max(f64, i32)
-f64 < min(0.5, i64)
-f64 < min(f32)
-f64 < min(f64, f32)
-f64 < min(i32)
-f64 < round(0.5)
-f64 < score(1)
-f64 <= -0.5
-f64 <= -1
-f64 <= -i
-f64 <= -i32
-f64 <= 0.5 != false
-f64 <= 0.5 + 0.5
-f64 <= 0.5 / f32
-f64 <= 0.5 ? greet : f64
-f64 <= 0.5 ? score : array
-f64 <= 1 * i32
-f64 <= 1 + 0.5
-f64 <= 1 / i
-f64 <= 1 == nil
-f64 <= 1 ? "bar" : array
-f64 <= 1 ? half : list
-f64 <= 1 ^ f64
-f64 <= abs(0.5)
-f64 <= abs(i)
-f64 <= array[i64]
-f64 <= ceil(i)
-f64 <= f32
-f64 <= f32 ** 0.5
-f64 <= f32 - i64
-f64 <= f32 ? f64 : div
-f64 <= f32 ^ f32
+f64 < i != nil
+f64 < i % i
+f64 < i >= f64
+f64 < i || true
+f64 < max(array)
+f64 < max(f64)
+f64 < mean(f64)
+f64 < median(array)
+f64 < min(0)
+f64 < min(1.0)
+f64 < min(i)
+f64 < round(1.0)
+f64 < sum(array)
+f64 <= $env.f64
+f64 <= $env.i
+f64 <= $env?.f64
+f64 <= $env?.i
+f64 <= 0 ** 1.0
+f64 <= 0 > i
+f64 <= 0.1
+f64 <= 1 - i
+f64 <= 1 / f64
+f64 <= 1 >= f64
+f64 <= 1 ^ 0
+f64 <= 1 or true
+f64 <= 1 || $env
+f64 <= 1.0 != nil
+f64 <= 1.0 && $env
+f64 <= 1.0 && true
+f64 <= 1.0 * $env?.i
+f64 <= 1.0 * min(i)
+f64 <= 1.0 <= f64
+f64 <= 1.0 <= mean(1.0)
+f64 <= 1.0 > 1
+f64 <= 1.0 ^ 1.0
+f64 <= 1.0 and $env
+f64 <= 1.0 and ok
+f64 <= 1.1 <= 1
+f64 <= abs(0)
+f64 <= abs(f64)
+f64 <= add(i, i)
+f64 <= array?.[i]
+f64 <= bitnand(i, 1)
 f64 <= f64
-f64 <= f64 != ok
-f64 <= f64 + f64
-f64 <= f64 + i32
-f64 <= f64 - 1
-f64 <= f64 ^ i
-f64 <= float(i)
-f64 <= float(i64)
-f64 <= half(0.5)
-f64 <= half(1)
+f64 <= f64 && $env
+f64 <= f64 - 0
+f64 <= f64 and $env
+f64 <= floor(1.0)
 f64 <= i
-f64 <= i * i64
-f64 <= i - 1
-f64 <= i - f32
-f64 <= i ^ f64
-f64 <= i32
-f64 <= i32 ** 1
-f64 <= i32 ? div : foo
-f64 <= i32 or all(list, ok)
-f64 <= i64
-f64 <= i64 + 1
-f64 <= i64 - 0.5
-f64 <= int(f32)
-f64 <= max(i)
-f64 <= max(i64, i32)
-f64 <= min(i32)
-f64 <= min(i64)
-f64 <= reduce(array, #)
-f64 == -0.5
-f64 == -1
-f64 == -f32
-f64 == -f64
-f64 == -i
-f64 == -i64
-f64 == 0.5 ** 0.5
-f64 == 0.5 - i
-f64 == 0.5 ? 0.5 : i64
-f64 == 0.5 ? 1 : 1
+f64 <= i + f64
+f64 <= i == $env?.Bar
+f64 <= i > i
+f64 <= int(1.0)
+f64 <= len(list)
+f64 <= mean(i)
+f64 <= median(1.0)
+f64 <= min(f64)
+f64 <= sum(array)
+f64 <= sum(array, #)
+f64 == $env && true
+f64 == $env == $env
+f64 == $env ? add : $env
+f64 == $env or $env
+f64 == $env.f64
+f64 == $env.i
+f64 == $env?.Bar
+f64 == $env?.String
+f64 == $env?.[Bar]
+f64 == $env?.[String]
+f64 == $env?.[str]
+f64 == $env?.f64
+f64 == $env?.foobar
+f64 == $env?.foobar?.str
+f64 == $env?.i
+f64 == 0 && $env?.[add]
+f64 == 0 && sum($env)
+f64 == 0 or ok
 f64 == 1 != ok
-f64 == 1 % 1
-f64 == 1 * i64
-f64 == 1 ** 0.5
-f64 == 1 == false
-f64 == abs(0.5)
-f64 == abs(i64)
-f64 == ceil(i)
-f64 == f32
-f64 == f32 && ok
-f64 == f32 + len(array)
-f64 == f32 ? 0.5 : i
-f64 == f32 ^ i32
+f64 == 1 * i
+f64 == 1 - 1.0
+f64 == 1 - f64
+f64 == 1.0 ** 0
+f64 == 1.0 + f64
+f64 == 1.0 == ok
+f64 == 1.0 ?: nil
+f64 == 1.0 and true
+f64 == 1.0 || $env
+f64 == abs(1.0)
+f64 == array?.[i]
+f64 == bitor(i, 1)
+f64 == count(array, ok)
 f64 == f64
-f64 == f64 ** i
-f64 == f64 - f64
-f64 == float(0.5)
-f64 == floor(0.5)
-f64 == half(0.5)
-f64 == half(f64)
+f64 == f64 ^ i
+f64 == findLastIndex($env, true)
 f64 == i
-f64 == i != false
-f64 == i * 1
-f64 == i ? i32 : score
-f64 == i32
-f64 == i32 == ok ? 1 : list
-f64 == i32 == true
-f64 == i32 || ok
-f64 == i64
-f64 == i64 / i
-f64 == i64 ? 1 : 0.5
-f64 == i64 ? greet : i32
-f64 == int(f32)
-f64 == max(0.5)
-f64 == max(i)
-f64 == min(i32)
-f64 == nil && ok
-f64 == nil ? 0.5 : add
-f64 == nil ? foo : "foo"
-f64 == reduce(list, i32)
-f64 == round(i)
-f64 == score(i, 1)
-f64 > -0.5
-f64 > -1
-f64 > -f64
-f64 > -i
-f64 > -i32
-f64 > 0.5 ** f32
-f64 > 0.5 / i
-f64 > 0.5 ^ i
-f64 > 0.5 or i <= 0.5
-f64 > 1 + f32
-f64 > 1 + i32
-f64 > 1 ? div : i32
-f64 > 1 ^ i32
-f64 > array[i64]
-f64 > ceil(0.5)
-f64 > ceil(1)
-f64 > ceil(f32)
-f64 > f32
-f64 > f32 / 1
+f64 == i / i
+f64 == int(f64)
+f64 == mean(1.0)
+f64 == median(i)
+f64 == min($env)
+f64 == min(1.0)
+f64 == nil != nil
+f64 == nil != ok
+f64 == nil ?: list
+f64 == nil || max(array)
+f64 == nil || true
+f64 > $env.f64
+f64 > $env.i
+f64 > $env?.[str]?.[f64]
+f64 > $env?.f64
+f64 > $env?.i
+f64 > 0 + 1.0
+f64 > 0 >= 0
+f64 > 0 >= 1.0
+f64 > 0 ? 1 : 1.0
+f64 > 0 and $env?.String
+f64 > 0 or true
+f64 > 1 ** i
+f64 > 1 / f64
+f64 > 1 / i
+f64 > 1 <= i
+f64 > 1 >= f64
+f64 > 1 >= i
+f64 > 1 ? array : false
+f64 > 1 or true
+f64 > 1.0 * i
+f64 > 1.0 ** f64
+f64 > 1.0 / 0
+f64 > 1.0 <= f64
+f64 > 1.0 == true
+f64 > 1.0 > $env
+f64 > 1.0 > median(list, 1)
+f64 > 1.0 ? i : false
+f64 > 1.0 and true
+f64 > array?.[i]
+f64 > ceil(0)
 f64 > f64
-f64 > f64 - 0.5
-f64 > float(0.5 * i64)
-f64 > floor(f64)
-f64 > get(array, 1)
-f64 > half(0.5)
-f64 > half(1)
-f64 > half(f64)
+f64 > f64 != true
+f64 > f64 * f64
+f64 > f64 - 1
+f64 > f64 >= 1.0
+f64 > float(1.0)
 f64 > i
-f64 > i - 0.5
-f64 > i32
-f64 > i32 == ok
-f64 > i32 ? f32 : array
-f64 > i32 ? list : half
-f64 > i32 ^ i32
-f64 > i32 ^ i64
-f64 > i64
-f64 > i64 - 1
-f64 > i64 ? array : half
-f64 > i64 ? list : div
-f64 > i64 || ok or ok
-f64 > int(f32)
-f64 > last(array)
-f64 > max(0.5)
-f64 > max(0.5, i64)
-f64 > max(f32)
-f64 > median(array)
-f64 > min(f32)
-f64 >= -0.5
-f64 >= -1
-f64 >= -i64
-f64 >= 0.5 + i32
-f64 >= 0.5 - 1
-f64 >= 0.5 - f32
-f64 >= 0.5 / i64
-f64 >= 0.5 ? list : i32
-f64 >= 0.5 ^ i64
-f64 >= array[1]
-f64 >= f32
-f64 >= f32 - i32
-f64 >= f32 ^ 1
+f64 > i < f64 ?: $env
+f64 > i == $env
+f64 > i ^ 1
+f64 > max(array)
+f64 > mean(1.0)
+f64 > median(f64)
+f64 > round(1)
+f64 > round(i)
+f64 > sum($env | filter(false))
+f64 > sum($env, f64)
+f64 >= $env && false
+f64 >= $env || true
+f64 >= $env.f64
+f64 >= $env.i
+f64 >= $env?.f64
+f64 >= $env?.i
+f64 >= 0 != $env
+f64 >= 0 >= f64
+f64 >= 0 ? greet : 1
+f64 >= 0 || ok
+f64 >= 1 != true
+f64 >= 1 < i
+f64 >= 1 ? 0 : foo
+f64 >= 1 ? foo : str
+f64 >= 1.0 != nil
+f64 >= 1.0 ** i < f64
+f64 >= 1.0 + 1.0
+f64 >= 1.0 > i
+f64 >= 1.0 ?: list
+f64 >= 1.0 and $env in str
+f64 >= 1.0 and $env?.[str]
+f64 >= array?.[i]
+f64 >= bitnot(i)
+f64 >= ceil(0)
+f64 >= ceil(i)
 f64 >= f64
-f64 >= f64 != nil
-f64 >= f64 != ok
-f64 >= findIndex(array, ok)
-f64 >= floor(f32)
-f64 >= floor(i)
-f64 >= half(0.5)
-f64 >= half(1)
+f64 >= f64 == ok
+f64 >= f64 ^ f64
+f64 >= float(0)
+f64 >= float(1)
+f64 >= float(1.0)
 f64 >= i
-f64 >= i * 0.5
-f64 >= i ** 0.5
-f64 >= i ** i32
-f64 >= i / i32
-f64 >= i ^ 1
-f64 >= i32
-f64 >= i32 - f64
-f64 >= i32 ? ok : add
-f64 >= i32 ^ 1
-f64 >= i64
-f64 >= i64 + f64
-f64 >= i64 ? 0.5 : score
-f64 >= i64 ? 1 : f32
-f64 >= max(1)
-f64 >= median(array)
-f64 >= reduce(array, #)
-f64 >= reduce(array, i32)
-f64 >= score(i)
-f64 ^ (0.5 * i)
-f64 ^ (0.5 + 1)
-f64 ^ (1 * f64)
-f64 ^ (1 - 1)
-f64 ^ (f32 + 1)
-f64 ^ (f32 - 0.5)
-f64 ^ (f32 - i)
-f64 ^ (f32 / -f64)
-f64 ^ (i32 - 1)
-f64 ^ (i32 / f32)
-f64 ^ (i64 - 1)
-f64 ^ -0.5
-f64 ^ -i32
-f64 ^ 0.5 * f64
-f64 ^ 0.5 ** f32
-f64 ^ 0.5 ** i32
-f64 ^ 0.5 > ceil(f32)
-f64 ^ 0.5 > i
-f64 ^ 0.5 >= f64
-f64 ^ 0.5 >= i32
-f64 ^ 0.5 ^ i32
-f64 ^ 0.5 not in array
-f64 ^ 1 ** i
-f64 ^ 1 ** i64
-f64 ^ 1 ^ i
-f64 ^ abs(0.5)
-f64 ^ array[i64]
-f64 ^ f32
-f64 ^ f32 ** 1
-f64 ^ f32 < score(1)
-f64 ^ f32 >= i32
+f64 >= i != $env
+f64 >= i * f64
+f64 >= i + 1.0
+f64 >= mean(1)
+f64 >= mean(1.0)
+f64 >= sum(array)
+f64 ^ $env.f64
+f64 ^ $env.i
+f64 ^ $env?.f64
+f64 ^ $env?.i
+f64 ^ 0 - 1.0
+f64 ^ 0 / i
+f64 ^ 0 < 0
+f64 ^ 0 >= 1.0 ?: greet
+f64 ^ 1 + 1.0
+f64 ^ 1.0
+f64 ^ 1.0 != 1.0
+f64 ^ 1.0 != f64
+f64 ^ 1.0 ** 1.0
+f64 ^ 1.0 > 1
+f64 ^ 1.0 >= i
+f64 ^ array?.[i]
 f64 ^ f64
-f64 ^ f64 - -i
-f64 ^ f64 == i32
-f64 ^ f64 > f64
-f64 ^ f64 ^ i
-f64 ^ f64 ^ i64
-f64 ^ findIndex(array, true)
-f64 ^ float(abs(i))
-f64 ^ floor(f64)
-f64 ^ half(1)
-f64 ^ half(f64)
+f64 ^ f64 != $env
+f64 ^ f64 ** i
+f64 ^ f64 + 1.0
+f64 ^ find(array, ok)
+f64 ^ float(i)
 f64 ^ i
-f64 ^ i ** 1
-f64 ^ i + f32
-f64 ^ i + i32
-f64 ^ i <= i32
-f64 ^ i ^ i64
-f64 ^ i32
-f64 ^ i32 / f64
-f64 ^ i32 <= i32
-f64 ^ i32 >= i
-f64 ^ i64
-f64 ^ i64 ** i64
-f64 ^ int(0.5)
-f64 ^ int(f64)
-f64 ^ last(array)
-f64 ^ len(list)
-f64 ^ min(1)
-f64 ^ reduce(array, #)
-f64 ^ round(i)
-f64 ^ score(1)
+f64 ^ i ** 1.0
+f64 ^ i ** i
+f64 ^ i >= 0 || $env
+f64 ^ i not in array
+f64 ^ len($env)
+f64 ^ median(0)
+f64 ^ sum(array)
+f64 in $env && false
+f64 in $env.array
+f64 in $env?.Bar
+f64 in $env?.String
+f64 in $env?.[$env?.[String]]
+f64 in $env?.[Bar]
+f64 in $env?.[String]
+f64 in $env?.[foobar]
+f64 in $env?.array
+f64 in $env?.foobar
+f64 in $env?.foobar?.[add]
+f64 in $env?.nil
+f64 in [1.0]
+f64 in [foo, 1.0]
+f64 in [foo, i]
+f64 in [list, 1.0]
+f64 in [nil]
 f64 in array
-f64 in array != nil
-f64 in groupBy(list, i64)
+f64 in array or false
+f64 in reverse(array)
+f64 not in $env or true
+f64 not in $env.array
+f64 not in $env?.Bar
+f64 not in $env?.String
+f64 not in $env?.[Bar]
+f64 not in $env?.[String]
+f64 not in $env?.[String]?.foo
+f64 not in $env?.[foobar]
+f64 not in $env?.array
+f64 not in $env?.foobar
+f64 not in [$env]
+f64 not in [1.0]
+f64 not in [array | groupBy(#), i]
 f64 not in array
-f64 not in array != ok
-f64 not in array != true
-f64 not in array == true
-f64 not in groupBy(array, #)
-f64 not in groupBy(array, bitnand(#, 1))
-f64 not in i .. i32
-f64 not in map(array, #)
-false != false ? foo : greet
-false && i not in array
-false && nil not in array
-false && nil not in list
-false == nil ? i32 : f64
-false == nil ? i32 : i32
-false ? "bar" : 0.5 - i
-false ? "foo" : f32 * i
-false ? "foo" : f32 / i32
-false ? "foo" : foo.Qux
-false ? add : 1 / i ^ 0.5
-false ? add : i64 - i
-false ? div : i64 ** i
-false ? f32 : foo.Qux
-false ? f64 : 0.5 != i32
-false ? f64 : 0.5 ** i32
-false ? f64 : 1 >= i
-false ? f64 : foo?.Qux
-false ? f64 : i ^ f32
-false ? false : foo?.Qux
-false ? foo : i32 - i
-false ? half : 0.5 == f32
-false ? half : i ^ i64
-false ? i : foo?.Qux
-false ? i : nil in list
-false ? i32 : 1 <= i32
-false ? i32 : foo.Qux
-false ? i64 : 1 <= f32
-false ? i64 : foo.Qux
-false ? i64 : i64 ** i64
-false ? list : list == list
-false ? nil : foo?.Qux
-false ? nil : i32 > i32
-false ? ok : foo.String()
-false ? ok : i64 < i64
-false and false || 0.5 > f32
-false or 1 not in array
-false or true or ok
-false or true || ok
-filter(1 .. 1, # > i)
-filter(1 .. i, i >= #)
-filter([0.5], # > 0.5)
-filter([nil], # != false)
-filter(array, !true)
-filter(array, "bar" != "foo")
-filter(array, "foo" == nil)
+f64 not in i .. i
+f64 not in keys($env)
+f64 not in map($env, $env)
+f64 not in map(array, 1)
+f64 | max(0)
+f64 | max(0, 1)
+f64 | max(1)
+f64 | max(1.0)
+f64 | max(array)
+f64 | max(array, 1)
+f64 | max(bitnot(1))
+f64 | max(f64)
+f64 | max(i)
+f64 | max(i, 1.0)
+f64 | mean(0)
+f64 | mean(0, 0)
+f64 | mean(0, 1.0)
+f64 | mean(0, array)
+f64 | mean(1)
+f64 | mean(1.0)
+f64 | mean(1.0, 1.0)
+f64 | mean(1.0, array)
+f64 | mean(array)
+f64 | mean(array, 0)
+f64 | mean(f64)
+f64 | mean(f64, array) != add
+f64 | mean(f64, f64)
+f64 | mean(i)
+f64 | median(0)
+f64 | median(0, 0)
+f64 | median(0, array)
+f64 | median(0, i)
+f64 | median(1)
+f64 | median(1.0)
+f64 | median(array)
+f64 | median(array) >= f64
+f64 | median(array, 1.0)
+f64 | median(f64)
+f64 | median(i)
+f64 | min($env?.array)
+f64 | min($env?.f64)
+f64 | min(0)
+f64 | min(0, i)
+f64 | min(1)
+f64 | min(1, f64)
+f64 | min(1.0)
+f64 | min(1.0, 0)
+f64 | min(array)
+f64 | min(array, 1)
+f64 | min(array, i)
+f64 | min(f64)
+f64 | min(f64, 1.0)
+f64 | min(i)
+f64; $env?.list
+f64; f64
+f64; foo?.String
+f64; i
+f64; str
+false != $env and ok
+false != $env.ok
+false != $env?.Bar
+false != $env?.String
+false != $env?.[Bar]
+false != $env?.[String]
+false != $env?.[foobar]
+false != $env?.[str]
+false != $env?.foobar
+false != $env?.ok
+false != nil == ok
+false && $env == count(array)
+false && $env > findLastIndex($env, #)
+false && $env >= sum($env)?.[array]
+false && $env in str
+false && $env not in list
+false && $env or ok
+false && $env.ok
+false && $env?.Bar
+false && $env?.String
+false && $env?.String()
+false && $env?.String(foobar.Bar)
+false && $env?.[Bar]
+false && $env?.[String]
+false && $env?.[add]
+false && $env?.[add].array
+false && $env?.[array]
+false && $env?.[array]?.[ok]
+false && $env?.[f64 > str]
+false && $env?.[f64]
+false && $env?.[f64]?.array
+false && $env?.[foo]
+false && $env?.[foobar - foobar]
+false && $env?.[foobar.add]
+false && $env?.[foobar]
+false && $env?.[greet]
+false && $env?.[greet].i
+false && $env?.[i]
+false && $env?.[list]
+false && $env?.[ok]
+false && $env?.[ok].add
+false && $env?.[str]
+false && $env?.[str].String
+false && $env?.foobar
+false && $env?.ok
+false && $env[:Bar < 0]
+false && $env[:ok()]
+false && $env[foobar:Bar]
+false && $env[foobar:foobar?.[String]]
+false && $env[foobar?.ok(foobar):]
+false && $env[i:]
+false && $env[ok.String:all(foobar, #.foo)]
+false && 0 >= i
+false && 0 not in map($env, i)
+false && 1 == 1 ** $env
+false && 1.0 == i
+false && 1.0 == int(1)
+false && 1.0 > $env[:ok]
+false && 1.0 > i
+false && f64 < i
+false && i < f64
+false && i in array
+false && nil != greet
+false && nil == ok
+false && nil in reduce($env, #)
+false && ok || ok
+false == $env && ok
+false == $env.ok
+false == $env?.Bar
+false == $env?.String
+false == $env?.[Bar]
+false == $env?.[String]
+false == $env?.[String]?.[f64]
+false == $env?.[String]?.greet
+false == $env?.[foobar]?.[str]
+false == $env?.[str]
+false == $env?.ok
+false == nil && ok
+false ? $env : $env.greet
+false ? $env : $env.list
+false ? $env : $env?.[str]
+false ? $env : $env?.add
+false ? $env : foo.Bar
+false ? $env : foo?.Bar
+false ? 0 : array?.[i]
+false ? 0 : foo?.Bar
+false ? 1 : $env?.f64
+false ? 1 : $env?.i
+false ? 1 : $env?.ok
+false ? 1.0 : $env.greet
+false ? 1.0 : $env?.[Bar]
+false ? 1.0 : $env?.greet
+false ? 1.0 : $env?.list
+false ? 1.0 : $env?.ok
+false ? 1.0 : foo?.Bar
+false ? 1.0 : foo?.String()
+false ? 1.0 : str contains str
+false ? add : $env.array
+false ? add : list | reduce(true)
+false ? add : nil not in array
+false ? array : $env.f64
+false ? array : $env?.f64
+false ? array : $env?.list
+false ? array : 1 * f64
+false ? array : nil != str
+false ? f64 : $env.array
+false ? f64 : $env.f64
+false ? f64 : $env.list
+false ? f64 : $env.ok
+false ? f64 : $env?.[String]
+false ? f64 : $env?.greet
+false ? f64 : $env?.str
+false ? f64 : list | groupBy(#)
+false ? false : $env?.list
+false ? foo : $env?.String
+false ? foo : $env?.[Bar]
+false ? foo : $env?.[String]
+false ? foo : $env?.add
+false ? foo : $env?.f64
+false ? foo : $env?.i
+false ? foo : $env?.ok
+false ? foo : array | map(0)
+false ? foo : foo.Bar
+false ? foo : foo?.Bar
+false ? foo : foo?.String
+false ? greet : $env | map(1.0)
+false ? greet : $env?.greet
+false ? i : $env.str
+false ? i : $env?.[String]
+false ? list : $env.array
+false ? list : $env?.foo
+false ? list : foo.Bar
+false ? nil : $env.foo
+false ? nil : $env?.greet
+false ? nil : $env?.str
+false ? nil : foo.String
+false ? ok : $env.str
+false ? ok : $env?.[Bar]
+false ? ok : $env?.array
+false ? ok : list | groupBy(i)
+false ? str : $env != str
+false ? str : $env.add
+false ? str : $env.f64
+false ? str : $env.list
+false ? str : $env?.Bar
+false ? str : foo?.Bar
+false ? true : $env.add
+false ? true : $env?.String
+false ? true : foo.Bar
+false ? true : foo?.Bar
+false ?: $env.add
+false ?: $env.greet
+false ?: $env.i
+false ?: $env.ok
+false ?: $env.str
+false ?: $env?.Bar
+false ?: $env?.String
+false ?: $env?.[foobar]
+false ?: $env?.add
+false ?: $env?.i
+false ?: $env?.list
+false ?: $env?.str
+false ?: array | sum(1.0)
+false ?: f64 - i
+false ?: foo.Bar
+false ?: foo?.String
+false ?: foo?.String()
+false ?: i | mean(1)
+false ?: list | map(foo)
+false and $env != f64
+false and $env <= $env[foobar:foobar]
+false and $env == add
+false and $env >= str
+false and $env not contains str
+false and $env not in array
+false and $env not in foo || true
+false and $env || ok
+false and $env.ok
+false and $env?.$env?.ok
+false and $env?.Bar
+false and $env?.Bar != foo
+false and $env?.Bar(array, foobar)
+false and $env?.String
+false and $env?.String()
+false and $env?.String?.greet(str)
+false and $env?.[Bar]
+false and $env?.[Bar]?.[add]
+false and $env?.[String]
+false and $env?.[add]
+false and $env?.[array]
+false and $env?.[array]?.[array]
+false and $env?.[f64()] not matches str
+false and $env?.[f64]
+false and $env?.[findLast(String, $env)]
+false and $env?.[foo.list]
+false and $env?.[foo]
+false and $env?.[foobar]
+false and $env?.[greet]
+false and $env?.[i]
+false and $env?.[i].array
+false and $env?.[list]
+false and $env?.[list].array
+false and $env?.[ok(foobar)]
+false and $env?.[ok]
+false and $env?.[str]
+false and $env?.[str]?.list(filter(String / foobar, f64 >= 1.0))
+false and $env?.all(foobar, foo)
+false and $env?.none(foobar)
+false and $env?.ok
+false and $env?.repeat(nil)
+false and $env[$env .. add:foo ? true : foobar]?.greet
+false and $env[$env[array:foo]:]
+false and $env[:foobar?.Bar]
+false and $env[Bar(foo):]
+false and $env[array():]
+false and $env[foobar:]
+false and $env[greet(str):true in list]
+false and $env[i():]
+false and 0 == i
+false and 1 != f64
+false and 1 <= f64
+false and 1 not in $env?.array
+false and 1.0 ** 1.0 == nil
+false and 1.0 <= f64 / f64
+false and 1.0 == i
+false and f64 in array
+false and i == median(list)
+false and nil == str
+false and ok and ok
+false and str >= foo?.Bar
+false and true ?: add
+false in $env?.Bar
+false in $env?.String
+false in $env?.[Bar]
+false in $env?.[String]
+false in $env?.[foobar]?.[array]
+false not in $env?.Bar
+false not in $env?.String
+false not in $env?.[Bar]
+false not in $env?.[String]
+false not in $env?.[String]?.Bar
+false not in $env?.[first(foobar)]
+false not in $env?.[foobar]
+false or $env in $env?.[foobar]
+false or $env startsWith $env?.[Bar]
+false or $env.ok
+false or $env?.Bar
+false or $env?.Bar?.[i]
+false or $env?.String
+false or $env?.[Bar]
+false or $env?.[Bar]?.list
+false or $env?.[String]
+false or $env?.[String]?.[list]
+false or $env?.[foobar | toJSON(nil)]
+false or $env?.[foobar?.[0]]
+false or $env?.[str]
+false or $env?.foobar
+false or $env?.ok
+false or 0 not in array
+false or 1.0 >= i
+false or array == list
+false or false ?: ok
+false or greet == greet
+false or i == i
+false or nil != array
+false or nil != f64
+false or nil == foo
+false or ok == ok
+false or str != str
+false or str not matches str
+false || $env != f64 and $env
+false || $env == i
+false || $env in list
+false || $env.ok
+false || $env?.Bar
+false || $env?.Bar?.foo
+false || $env?.String
+false || $env?.String?.foo()
+false || $env?.[Bar]
+false || $env?.[String]
+false || $env?.[str]
+false || $env?.false?.array
+false || $env?.ok
+false || 1 == array?.[i]
+false || 1 > f64
+false || 1 in array
+false || 1.0 <= 1.0 ?: 1
+false || 1.0 <= i
+false || add != add
+false || array != list
+false || foo in list
+false || i >= i
+false || nil != i
+false || nil == greet
+false || str not endsWith str
+false || true == ok
+false; $env?.Bar
+false; $env?.String
+false; $env?.[Bar]
+filter($env, #.list) | filter(false)
+filter($env, .f64) | filter(false)
+filter($env, .ok) | filter(false)
+filter($env, false) | all(#)
+filter($env, false) | all(#.str not matches .str)
+filter($env, false) | all(false)
+filter($env, false) | find(true)
+filter($env, false) | groupBy(#)
+filter($env, false) | reduce(#.list, str)
+filter($env, false) | reduce(true, nil)
+filter($env, false) | sortBy(foo)
+filter($env, false) | sum(greet)
+filter($env, ok) | map(foo)
+filter($env.array, foo != foo)
+filter($env.array, i == 1)
+filter($env.list, ok)
+filter($env.list, true || true)
+filter($env?.[str], ok)
+filter($env?.array, ok)
+filter($env?.list, ok)
+filter([0], ok)
+filter([1], # != 1.0)
+filter([true, $env], 1 < 1)
 filter(array, # != #)
-filter(array, # != f32)
-filter(array, # != f64)
-filter(array, # != i)
-filter(array, # != i64)
-filter(array, # < #)
-filter(array, # < f64)
 filter(array, # <= #)
-filter(array, # <= 1)
-filter(array, # <= bitshr(#, #))
-filter(array, # <= i)
-filter(array, # <= i64)
-filter(array, # == #)
-filter(array, # == 0.5)
-filter(array, # == f32)
-filter(array, # == f64)
-filter(array, # == i)
-filter(array, # == i32)
-filter(array, # == i64)
-filter(array, # == nil)
-filter(array, # > #)
-filter(array, # > 0.5)
-filter(array, # > 1)
-filter(array, # > i)
-filter(array, # > i32)
-filter(array, # >= #)
-filter(array, # >= 0.5)
-filter(array, # >= 1)
-filter(array, # >= f32)
-filter(array, # >= i)
-filter(array, # >= i32)
-filter(array, # >= i64)
-filter(array, 0.5 != #)
-filter(array, 0.5 != f64)
-filter(array, 0.5 != i)
-filter(array, 0.5 < #)
-filter(array, 0.5 < f64)
-filter(array, 0.5 < i32)
-filter(array, 0.5 <= #)
-filter(array, 0.5 <= i)
-filter(array, 0.5 <= i32)
-filter(array, 0.5 == #)
-filter(array, 0.5 == f64)
-filter(array, 0.5 > #)
-filter(array, 0.5 >= #)
-filter(array, 1 != #)
-filter(array, 1 < i)
-filter(array, 1 == #)
-filter(array, 1 == 0.5)
-filter(array, 1 == i)
-filter(array, 1 > i)
+filter(array, $env != $env)
+filter(array, $env and false)
 filter(array, 1 >= #)
-filter(array, add == add)
-filter(array, add == nil)
-filter(array, any(list, ok))
-filter(array, f32 != #)
-filter(array, f32 < #)
-filter(array, f32 <= #)
-filter(array, f32 == #)
-filter(array, f32 == i64)
-filter(array, f32 > #)
-filter(array, f32 >= #)
-filter(array, f64 < #)
+filter(array, 1.0 <= f64)
+filter(array, 1.0 == $env)
+filter(array, 1.0 > 1.0)
 filter(array, f64 <= #)
-filter(array, f64 == i32)
-filter(array, f64 >= #)
-filter(array, half != nil)
-filter(array, half == half)
-filter(array, half(1) >= # ^ i)
-filter(array, i != #)
-filter(array, i != f64)
-filter(array, i <= i32)
-filter(array, i == #)
-filter(array, i > #)
-filter(array, i > f32)
-filter(array, i32 != i64)
-filter(array, i32 < 0.5)
-filter(array, i32 > #)
-filter(array, i64 < #)
-filter(array, i64 < i64)
-filter(array, i64 == #)
-filter(array, i64 == i32)
-filter(array, i64 >= #)
-filter(array, nil != #)
-filter(array, nil != greet)
-filter(array, nil == #)
-filter(array, nil == 1)
-filter(array, nil == i32)
-filter(array, not false)
-filter(array, not ok)
-filter(array, not true)
-filter(array, ok && true)
+filter(array, false) | all($env[1.0:])
+filter(array, false) | sortBy($env)
+filter(array, false) | sortBy(add)
 filter(array, ok)
-filter(array, ok)[i64]
-filter(array, score == nil)
-filter(array, true == true)
-filter(array, true and true)
-filter(false ? ok : array, # == nil)
-filter(filter(list, true), ok)
-filter(groupBy(list, #).f64, # not matches #?.foo)
-filter(i .. i64, ok)
-filter(list, !ok)
-filter(list, !true)
-filter(list, "bar" < "foo")
-filter(list, "bar" not matches "foo")
-filter(list, "foo" == "foo")
-filter(list, "foo" in #)
-filter(list, "foo" not endsWith "bar")
-filter(list, "foo" startsWith "bar")
-filter(list, # != #)
-filter(list, # != foo)
-filter(list, # != nil)
-filter(list, # == #)
-filter(list, # == foo)
-filter(list, # in list)
-filter(list, 0.5 < 1)
-filter(list, 0.5 <= 0.5)
-filter(list, 0.5 >= 1)
-filter(list, 0.5 >= i)
-filter(list, 0.5 >= i64)
-filter(list, 1 < 1)
-filter(list, 1 <= f32)
-filter(list, any(array, ok))
-filter(list, any(list, true))
-filter(list, div != div)
-filter(list, f32 <= 1)
-filter(list, f32 == f64)
-filter(list, f32 > i)
-filter(list, f64 <= 1)
-filter(list, f64 == 0.5)
-filter(list, false != false)
-filter(list, false or ok)
-filter(list, foo == #)
-filter(list, i < 0.5)
-filter(list, i < f32)
-filter(list, i >= 0.5)
-filter(list, i64 > 0.5)
-filter(list, nil != "foo")
-filter(list, nil != #)
-filter(list, nil != #?.Bar)
-filter(list, nil != add)
-filter(list, nil != greet)
-filter(list, nil != i64)
-filter(list, nil == #)
-filter(list, nil == 0.5)
-filter(list, nil == f32)
-filter(list, nil == half)
-filter(list, nil == i32)
-filter(list, nil == score)
-filter(list, ok == nil)
-filter(list, ok and false)
+filter(array, ok) | findIndex(false)
+filter(array, ok) | sortBy(0)
+filter(array, ok)?.[i]
+filter(array, str in foo)
+filter(array, true) | findLast(ok)
+filter(array, true) | none(true)
+filter(array, true)?.[i]
+filter(concat(array), #.greet || true)
+filter(keys($env), ok)
+filter(list, # == $env)
+filter(list, # not in list)
+filter(list, #.Bar in #)
+filter(list, #.Bar not in foo)
+filter(list, $env != #)
+filter(list, $env != str)
+filter(list, $env == #)
+filter(list, $env?.ok)
+filter(list, 1.0 == nil)
+filter(list, f64 <= 1.0)
+filter(list, false) | sum($env)
+filter(list, false) | sum(foo)
+filter(list, foo != nil)
 filter(list, ok)
-filter(list, ok)[i]
-filter(list, true == ok)
-filter(list, true || true)
-filter(list, true) == list
-filter(map(array, #), # == 1)
-filter(map(array, #), # > #)
-filter(map(array, 1), ok)
-filter(map(array, greet), ok)
-filter(map(array, i32), ok)
-filter(map(array, i64), nil == div)
-filter(map(array, ok), true || ok)
-filter(map(array, score), # != nil)
-filter(map(list, #), # == #)
-filter(map(list, #), half != nil)
-filter(map(list, #), ok)
-filter(map(list, array), # == #)
-filter(map(list, f32), # == #)
-filter(map(list, f32), ok)
-filter(map(list, false), #)
-filter(map(list, i32), i64 <= i32)
-filter(map(list, ok), #)
-filter(map(list, true), #)
-filter(ok ? "foo" : 0.5, # <= i64)
-filter(true ? list : score, # != #)
-find(1 .. i, ok)
-find([ok], #)
-find([score, score], # == #)
-find(array, !(# <= i32))
-find(array, !ok)
-find(array, !true)
-find(array, "bar" not startsWith "foo")
-find(array, "foo" not contains "bar")
-find(array, # != #)
-find(array, # != 1)
-find(array, # != i)
-find(array, # != i32)
-find(array, # != nil)
-find(array, # - i != #)
-find(array, # < #)
-find(array, # < 0.5)
-find(array, # < 1)
-find(array, # < f32)
-find(array, # < i)
-find(array, # < i32)
-find(array, # < i64)
-find(array, # <= #)
-find(array, # <= 0.5)
-find(array, # <= 1)
-find(array, # <= i32)
-find(array, # == #)
-find(array, # == 0.5)
+filter(list, ok) | findIndex(true)
+filter(list, ok)?.[i]
+filter(list, str != $env)
+filter(list, true) | all(true)
+filter(list, true) | reduce(#acc)
+filter(list, true) | reduce(i)
+filter(map($env, foo), # != #)
+filter(sort($env), #.foo?.String)
+filter(sort($env), #.i || #)
+filter(sort($env), nil not in .list)
+find($env | filter(false), # endsWith .Bar)
+find($env, false)?.Bar
+find($env, false)?.String
+find($env, false)?.[add]
+find($env, false)?.[array]
+find($env, false)?.[f64]
+find($env, false)?.[foo]
+find($env, false)?.[greet].i()
+find($env, false)?.[greet].str
+find($env, false)?.[i]?.foo
+find($env, false)?.[list]
+find($env, false)?.[ok]
+find($env, false)?.[{foo: false}]
+find($env, false)?.add
+find($env, false)?.array
+find($env, false)?.bitxor(ok, nil, 1)
+find($env, false)?.f64
+find($env, false)?.foo
+find($env, false)?.foo()
+find($env, false)?.greet
+find($env, false)?.greet(foobar)
+find($env, false)?.i
+find($env, false)?.i()
+find($env, false)?.list
+find($env, false)?.ok
+find($env.array, i != 1.0)
+find($env.array, ok)
+find($env.list, ok)
+find($env?.[str], 1 > 0)
+find($env?.[str], ok or .ok)
+find($env?.[str], ok)
+find($env?.list, f64 != 0)
+find($env?.list, ok)
+find([str], ok)
+find(array, # != 0)
+find(array, # < 0)
+find(array, # <= 0)
+find(array, # <= i)
 find(array, # == 1)
-find(array, # == i)
-find(array, # == i64)
-find(array, # == nil)
-find(array, # > #)
-find(array, # > 1)
-find(array, # > i32)
-find(array, # > i64)
-find(array, # >= #)
-find(array, # >= 1)
-find(array, # >= f64)
-find(array, # >= i)
-find(array, # not in array)
-find(array, 0.5 != 1)
-find(array, 0.5 / i64 <= #)
-find(array, 0.5 < #)
-find(array, 0.5 < f64)
-find(array, 0.5 <= #)
-find(array, 0.5 >= #)
-find(array, 0.5 >= 0.5)
-find(array, 0.5 >= f64)
-find(array, 1 != #)
-find(array, 1 < #)
-find(array, 1 < i32)
-find(array, 1 < i64)
-find(array, 1 <= #)
-find(array, 1 <= i)
-find(array, 1 == #)
-find(array, 1 > #)
-find(array, 1 >= #)
-find(array, div != nil)
-find(array, f32 != #)
-find(array, f32 != f32)
-find(array, f32 < #)
-find(array, f32 <= #)
-find(array, f32 == #)
-find(array, f32 == i32)
-find(array, f32 > #)
-find(array, f32 >= #)
-find(array, f64 != #)
-find(array, f64 < #)
-find(array, f64 < 1)
-find(array, f64 <= #)
-find(array, f64 == #)
-find(array, f64 == i64)
-find(array, false ? # : false)
-find(array, false) != f64
-find(array, floor(#) > #)
-find(array, greet != greet)
-find(array, i % # != f64)
-find(array, i < 0.5)
-find(array, i <= #)
-find(array, i > 0.5)
-find(array, i >= #)
-find(array, i >= 1)
-find(array, i32 != #)
-find(array, i32 != i32)
-find(array, i32 == #)
-find(array, i32 > #)
-find(array, i32 >= #)
-find(array, i64 != #)
-find(array, i64 != 1)
-find(array, i64 < #)
-find(array, i64 <= #)
-find(array, i64 == #)
-find(array, i64 > #)
-find(array, nil != nil)
-find(array, nil == #)
-find(array, nil == 0.5)
-find(array, nil == i32)
-find(array, none(array, true))
-find(array, not (# == #))
-find(array, ok == nil)
-find(array, ok and false)
+find(array, $env == foo)
+find(array, $env | any(false))
+find(array, 0 != f64)
+find(array, 0 <= 1)
+find(array, 1.0 != #)
+find(array, 1.0 != nil)
+find(array, 1.0 == nil)
+find(array, array | one(true))
+find(array, nil != true)
+find(array, ok or false)
 find(array, ok)
-find(array, ok) % i32
-find(array, ok) ** i
-find(array, ok) >= i32
-find(array, true) > f64
-find(array, true) > i64
-find(filter(list, false), i64 not in array)
-find(groupBy(array, #).Qux, .String?.f32)
-find(groupBy(array, #).ok, first(#[1]))
-find(i .. i64, ok)
-find(i64 .. i32, # != #)
-find(list, !false)
-find(list, !ok)
-find(list, "bar" not in #)
-find(list, "foo" contains "foo")
 find(list, # != #)
-find(list, # != nil)
-find(list, # == #)
-find(list, # == foo)
-find(list, # == nil)
-find(list, 0.5 != 1)
-find(list, 0.5 <= 0.5)
-find(list, 1 != 0.5)
-find(list, 1 < 1)
-find(list, 1 < i64)
-find(list, 1 == f64)
-find(list, 1 > 0.5)
-find(list, 1 > i)
-find(list, 1 > i64)
-find(list, f32 < 1)
-find(list, f32 <= 0.5)
-find(list, f32 <= i32)
-find(list, f32 == i64)
-find(list, f32 > f64)
-find(list, f32 not in array)
-find(list, f64 < f64)
-find(list, false && true)
+find(list, #.String == .String)
+find(list, $env != list)
+find(list, $env == nil)
+find(list, $env not in array)
+find(list, 0 > i)
+find(list, 1 == 1.0)
+find(list, array != $env)
+find(list, array == list)
 find(list, false)?.Bar
 find(list, foo != #)
-find(list, foo == #)
-find(list, i != 1)
-find(list, i != f64)
-find(list, i != i32)
-find(list, i32 != 1)
-find(list, i32 != f64)
-find(list, i32 < i)
-find(list, i32 == i32)
-find(list, nil != #)
-find(list, nil != ok)
-find(list, nil == array)
-find(list, nil == div)
-find(list, not false)
-find(list, ok != false)
+find(list, foo != nil)
+find(list, nil == str)
 find(list, ok)
-find(list, ok).String
-find(list, ok).String()
+find(list, ok).Bar
 find(list, ok)?.Bar
-find(list, ok)?.Qux
 find(list, ok)?.String
-find(list, score == score)
-find(list, true != nil)
-find(list, true == true)
-find(list, true or false)
+find(list, str == $env)
 find(list, true).Bar
-find(list, true).Qux
 find(list, true).String
-find(list, true)?.Bar
 find(list, true)?.String
-find(map(array, #), # != f32)
-find(map(array, #), # <= 1)
-find(map(array, #), # == 0.5)
-find(map(array, #), ok)
-find(map(array, false), #)
-find(map(array, foo), ok)
-find(map(array, ok), #)
-find(map(list, #), # != #)
-find(map(list, #), ok)
-find(map(list, 0.5), # != #)
-find(map(list, add), 0.5 >= i64)
-find(map(list, div), # == #)
-find(map(list, f32), # > 0.5)
-find(map(list, false), #)
-find(map(list, i), # == i64)
-find(map(list, ok), #)
-find(map(list, true), #)
-find(ok ? "foo" : f64, f32 >= #)
-findIndex(array, !ok)
-findIndex(array, "bar" == "foo")
-findIndex(array, "foo" > "foo")
-findIndex(array, "foo" in foo)
+find(max($env), $env == i)
+find(sort($env), #.f64 not startsWith .String)
+find(sort($env), .str?.ok)?.[ok]
+find(toPairs($env), $env.ok)
+findIndex($env?.[str], 1.0 == nil)
+findIndex($env?.array, # < #)
+findIndex($env?.list, ok)
+findIndex([0], # <= 1)
+findIndex([1.0], # > 1.0)
+findIndex([add], ok)
+findIndex([array], ok)
+findIndex([f64], ok)
+findIndex([false], #)
+findIndex([foo], ok)
+findIndex([list], $env == add)
+findIndex([str], $env?.ok)
+findIndex([true], #)
+findIndex(array | sortBy(1.0), ok)
 findIndex(array, # != #)
-findIndex(array, # != 0.5)
-findIndex(array, # != f32)
-findIndex(array, # != f64)
-findIndex(array, # != i)
-findIndex(array, # != i64)
 findIndex(array, # != nil)
-findIndex(array, # < #)
-findIndex(array, # < 1)
-findIndex(array, # < i32)
-findIndex(array, # <= #)
-findIndex(array, # <= 0.5)
-findIndex(array, # <= 1)
-findIndex(array, # == #)
-findIndex(array, # == 0.5)
-findIndex(array, # == 1)
-findIndex(array, # == i32)
-findIndex(array, # == nil)
 findIndex(array, # > #)
-findIndex(array, # > 0.5)
-findIndex(array, # > 1)
-findIndex(array, # > f64)
-findIndex(array, # > i)
-findIndex(array, # > i64)
 findIndex(array, # >= #)
-findIndex(array, # >= 0.5)
-findIndex(array, # >= 1)
-findIndex(array, # >= f32)
-findIndex(array, # >= f64)
-findIndex(array, # >= i)
-findIndex(array, # >= i32)
-findIndex(array, # >= i64)
-findIndex(array, 0.5 != #)
-findIndex(array, 0.5 != 1)
-findIndex(array, 0.5 < 1)
-findIndex(array, 0.5 <= #)
-findIndex(array, 0.5 == #)
-findIndex(array, 0.5 == i64)
-findIndex(array, 0.5 > #)
-findIndex(array, 0.5 > 0.5)
-findIndex(array, 0.5 > i)
-findIndex(array, 0.5 > i32)
-findIndex(array, 0.5 >= 0.5)
-findIndex(array, 0.5 >= 1)
-findIndex(array, 0.5 not in array)
-findIndex(array, 1 != #)
-findIndex(array, 1 != i64)
-findIndex(array, 1 != nil)
-findIndex(array, 1 < #)
+findIndex(array, $env != true)
+findIndex(array, $env.ok)
+findIndex(array, $env?.ok)
+findIndex(array, 0 == #)
 findIndex(array, 1 <= #)
-findIndex(array, 1 > #)
-findIndex(array, 1 > i)
-findIndex(array, 1 >= #)
-findIndex(array, add != div)
-findIndex(array, add != nil)
-findIndex(array, f32 != #)
-findIndex(array, f32 != 1)
-findIndex(array, f32 < #)
-findIndex(array, f32 == #)
-findIndex(array, f32 >= #)
-findIndex(array, f32 >= i32)
-findIndex(array, f64 >= #)
-findIndex(array, f64 >= i32)
-findIndex(array, false) == -f64
-findIndex(array, i != f64)
-findIndex(array, i < #)
-findIndex(array, i < i32)
-findIndex(array, i <= #)
-findIndex(array, i <= 0.5)
-findIndex(array, i == #)
-findIndex(array, i >= i)
-findIndex(array, i >= i32)
-findIndex(array, i32 != #)
-findIndex(array, i32 < #)
-findIndex(array, i32 == #)
-findIndex(array, i32 > f32)
-findIndex(array, i64 != #)
-findIndex(array, i64 != nil)
-findIndex(array, i64 < 0.5)
-findIndex(array, i64 <= #)
-findIndex(array, i64 <= i64)
-findIndex(array, i64 > #)
-findIndex(array, i64 >= #)
-findIndex(array, i64 >= f64)
-findIndex(array, i64 >= i32)
-findIndex(array, nil != half)
-findIndex(array, nil != ok)
-findIndex(array, nil == #)
-findIndex(array, nil == 1)
-findIndex(array, nil == nil)
-findIndex(array, not false)
+findIndex(array, 1.0 != $env)
+findIndex(array, 1.0 < #)
+findIndex(array, 1.0 >= #)
+findIndex(array, add == nil)
+findIndex(array, false || ok)
+findIndex(array, foo == nil)
+findIndex(array, nil != foo)
 findIndex(array, ok)
-findIndex(array, ok) / f64
-findIndex(array, ok) / i
-findIndex(array, ok) <= f32
-findIndex(array, one(list, false))
-findIndex(array, true) + f64
-findIndex(array, true) - f64
-findIndex(array, true) .. i
-findIndex(filter(array, false), # > 1)
-findIndex(filter(array, true), # not in array)
-findIndex(filter(list, false), 1 <= i64)
-findIndex(groupBy(array, #).f64, .Bar(half(add, half, div, greet, f64)))
-findIndex(groupBy(array, false).String, #?.i64())
-findIndex(groupBy(array, foo).String, #)
-findIndex(groupBy(list, #).Qux, #)
-findIndex(i32 .. 1, # >= #)
-findIndex(list, !false)
-findIndex(list, !ok)
-findIndex(list, !true)
-findIndex(list, "bar" > "foo")
-findIndex(list, "bar" in #)
-findIndex(list, "bar" not in #)
-findIndex(list, # != #)
-findIndex(list, # != nil)
+findIndex(array, true) | min(array)
+findIndex(filter($env, false), #.list(foobar))
+findIndex(flatten(list), .String != ok)
 findIndex(list, # == #)
-findIndex(list, # == foo)
-findIndex(list, # in list)
-findIndex(list, #?.Bar not in #)
-findIndex(list, 0.5 != i)
-findIndex(list, 0.5 > 1)
-findIndex(list, 0.5 >= i)
-findIndex(list, 1 != i32)
-findIndex(list, 1 < f64)
-findIndex(list, 1 < i32)
-findIndex(list, 1 == f32)
-findIndex(list, 1 > 0.5)
-findIndex(list, 1 > i32)
-findIndex(list, 1 >= 1)
-findIndex(list, 1 >= i)
-findIndex(list, f32 != f32)
-findIndex(list, f32 != i)
-findIndex(list, f32 < i32)
-findIndex(list, f32 == bitshl(i, i64))
-findIndex(list, f32 > 1)
-findIndex(list, f64 != 0.5)
-findIndex(list, f64 < 1)
-findIndex(list, f64 < i)
-findIndex(list, f64 > 1)
-findIndex(list, f64 >= f64)
-findIndex(list, false != nil)
-findIndex(list, false || ok)
-findIndex(list, foo != #)
+findIndex(list, # == nil)
+findIndex(list, $env != .String)
+findIndex(list, $env == false)
+findIndex(list, .Bar == $env)
+findIndex(list, f64 == 1.0)
+findIndex(list, foo != $env)
 findIndex(list, greet == nil)
-findIndex(list, i < 0.5)
-findIndex(list, i <= i32)
-findIndex(list, i32 == 1)
-findIndex(list, i32 >= i64)
-findIndex(list, i64 != f32)
-findIndex(list, nil != 0.5)
-findIndex(list, nil != f32)
-findIndex(list, nil != i64)
-findIndex(list, nil == "foo")
-findIndex(list, nil == f64)
-findIndex(list, not ok)
-findIndex(list, not true)
+findIndex(list, nil != $env)
 findIndex(list, ok)
-findIndex(list, ok) * i
-findIndex(list, ok) ** i
-findIndex(list, ok) >= f64
-findIndex(list, ok) ^ i32
-findIndex(list, true ? ok : #)
-findIndex(list, true) % i64
-findIndex(map(array, #), # < #)
-findIndex(map(array, #), # >= #)
-findIndex(map(array, #), i > #)
-findIndex(map(array, f32), i32 == #)
-findIndex(map(array, i), # != #)
-findIndex(map(array, i), ok)
-findIndex(map(list, #), # != #)
-findIndex(map(list, #), # == #)
-findIndex(map(list, i64), # == 0.5)
-findIndex(map(list, i64), i64 < #)
-findIndex(map(list, true), #)
-findIndex(map(list, true), ok)
-findIndex(ok ? "foo" : greet, !ok)
-findIndex(ok ? "foo" : i, # == #)
-findIndex(sort(array), i32 == #)
-findIndex(true ? "foo" : ok, # == greet)
-findLast(1 .. i, # <= #)
-findLast(1 .. i32, 1 >= #)
-findLast(1 .. i64, ok)
-findLast([false], #)
-findLast(array, !false)
-findLast(array, !ok)
-findLast(array, "foo" > "bar")
-findLast(array, # != #)
-findLast(array, # != 0.5)
-findLast(array, # != 1)
-findLast(array, # != f32)
-findLast(array, # != f64)
-findLast(array, # != i)
-findLast(array, # < #)
-findLast(array, # < 0.5)
-findLast(array, # < f32)
+findIndex(list, ok) * f64
+findIndex(list, str in #)
+findIndex(list, str not contains str)
+findIndex(sort($env), #.String?.list(foobar))
+findIndex(sort($env), .array)
+findIndex(sort($env), list not in .Bar)
+findLast($env, false) == greet
+findLast($env, false)?.Bar
+findLast($env, false)?.String
+findLast($env, false)?.[add]
+findLast($env, false)?.[foo]
+findLast($env, false)?.[greet]
+findLast($env, false)?.[greet]?.Bar
+findLast($env, false)?.[i]
+findLast($env, false)?.[list]
+findLast($env, false)?.[ok]
+findLast($env, false)?.[str]
+findLast($env, false)?.add()
+findLast($env, false)?.array
+findLast($env, false)?.f64
+findLast($env, false)?.f64()
+findLast($env, false)?.f64?.[str]
+findLast($env, false)?.foo
+findLast($env, false)?.greet()
+findLast($env, false)?.i
+findLast($env, false)?.i()
+findLast($env, false)?.list()
+findLast($env, false)?.ok
+findLast($env, false)?.ok()
+findLast($env, false)?.str
+findLast($env.array, # >= #)
+findLast($env.array, str in $env)
+findLast($env.list, ok)
+findLast($env?.[str], # not in array)
+findLast($env?.[str], false == #)
+findLast($env?.array, $env.ok)
+findLast($env?.array, i in array)
+findLast($env?.array, ok)
+findLast($env?.list, ok)
+findLast([$env], $env != nil).array
+findLast([1.0], ok)
+findLast([false], $env | none(true))
+findLast([ok], ok)
+findLast([true], ok)
+findLast(array | map(#index), ok)
 findLast(array, # < f64)
-findLast(array, # < i + #)
 findLast(array, # <= #)
-findLast(array, # <= 0.5)
-findLast(array, # <= 1)
-findLast(array, # <= f32)
-findLast(array, # <= i64)
-findLast(array, # == #)
-findLast(array, # == 0.5)
-findLast(array, # == nil)
-findLast(array, # > #)
-findLast(array, # > 0.5)
-findLast(array, # > 1)
-findLast(array, # > i)
-findLast(array, # > i32)
-findLast(array, # > i64)
-findLast(array, # >= #)
-findLast(array, # >= 0.5)
-findLast(array, # >= 1)
-findLast(array, # >= f32)
-findLast(array, # >= i32)
-findLast(array, 0.5 <= #)
-findLast(array, 0.5 <= i64)
-findLast(array, 0.5 > #)
-findLast(array, 0.5 >= #)
-findLast(array, 0.5 >= 1)
+findLast(array, # > 1.0)
+findLast(array, $env?.ok)
 findLast(array, 1 != #)
-findLast(array, 1 <= #)
-findLast(array, 1 == #)
-findLast(array, f32 >= #)
-findLast(array, f64 != #)
-findLast(array, f64 != nil)
-findLast(array, f64 <= #)
-findLast(array, f64 <= 1)
-findLast(array, f64 == #)
-findLast(array, f64 == nil)
-findLast(array, f64 >= 1)
-findLast(array, f64 >= i64)
-findLast(array, false != true)
-findLast(array, false or true)
-findLast(array, greet != nil)
-findLast(array, i < #)
-findLast(array, i == i32)
-findLast(array, i > #)
-findLast(array, i >= 0.5)
-findLast(array, i32 < #)
-findLast(array, i32 == 0.5)
-findLast(array, i32 > #)
-findLast(array, i32 >= #)
-findLast(array, i32 >= i32)
-findLast(array, i64 != #)
-findLast(array, i64 < #)
-findLast(array, i64 <= #)
-findLast(array, i64 == #)
-findLast(array, i64 > 0.5)
-findLast(array, list != nil)
-findLast(array, nil != array)
-findLast(array, not (array == array))
-findLast(array, not false)
-findLast(array, not ok)
-findLast(array, ok and true)
+findLast(array, 1 < 1)
+findLast(array, 1.0 >= 1.0)
+findLast(array, f64 < 0)
+findLast(array, f64 < f64)
+findLast(array, f64 > #)
+findLast(array, f64 >= 1.0)
+findLast(array, f64 >= i)
+findLast(array, false || true)
+findLast(array, nil != #)
+findLast(array, nil != nil)
+findLast(array, ok ?: 1.0)
 findLast(array, ok)
-findLast(array, ok) == i64
-findLast(array, reduce(list, ok))
-findLast(array, score != nil)
-findLast(array, true) % i64
-findLast(groupBy(array, #).i32, #)
-findLast(groupBy(list, "bar").div, #?.f32?.half())
-findLast(groupBy(list, #)[ok], .ok)
-findLast(groupBy(list, f64).foo, .f32(#, #)?.Qux(#?.i64(add, nil)))
-findLast(i .. 1, # < #)
-findLast(i .. i32, # != i64)
-findLast(i .. i32, ok)
-findLast(i32 .. i64, # >= i)
-findLast(i64 .. 1, # < #)
-findLast(list, !false)
-findLast(list, !ok)
-findLast(list, "foo" in #)
-findLast(list, # != #)
-findLast(list, # != nil)
-findLast(list, # == #)
+findLast(array, ok) >= f64
+findLast(array, ok) in array
+findLast(array, str not in foo)
+findLast(filter(list, false), $env?.[array])
+findLast(keys($env), foo == foo)
+findLast(list | sortBy(0), # == #)
 findLast(list, # == foo)
-findLast(list, # in list)
-findLast(list, # not in list)
-findLast(list, 0.5 != i64)
-findLast(list, 0.5 <= 1)
-findLast(list, 0.5 == i64)
-findLast(list, 1 != f32)
-findLast(list, 1 != nil)
-findLast(list, 1 <= 1)
-findLast(list, 1 > f32)
-findLast(list, 1 >= f64)
-findLast(list, f32 != i)
-findLast(list, f32 > f32)
-findLast(list, f32 >= 1)
-findLast(list, f64 <= i)
-findLast(list, f64 in array)
+findLast(list, #.Bar in #)
+findLast(list, #.String != nil)
+findLast(list, $env != true)
+findLast(list, $env == false)
+findLast(list, $env == foo.String())
+findLast(list, $env or true)
+findLast(list, $env.ok)
+findLast(list, 0 != 1.0)
+findLast(list, 1 >= 1.0)
+findLast(list, 1.0 <= f64)
+findLast(list, 1.0 == 1)
+findLast(list, 1.0 >= 1.0)
+findLast(list, f64 == f64)
 findLast(list, false)?.Bar
-findLast(list, foo != #)
-findLast(list, foo in list)
-findLast(list, i != i)
-findLast(list, i <= 1)
-findLast(list, i <= i)
-findLast(list, i == i32)
-findLast(list, i >= i)
-findLast(list, i32 != f32)
-findLast(list, i64 > f32)
-findLast(list, i64 > i)
-findLast(list, i64 >= 1)
-findLast(list, nil != #)
-findLast(list, nil not in array)
-findLast(list, nil not in list)
-findLast(list, none(array, ok))
-findLast(list, not false)
-findLast(list, not true)
-findLast(list, ok or true)
+findLast(list, foo == #)
+findLast(list, i > 0)
+findLast(list, nil == #)
+findLast(list, nil == greet)
 findLast(list, ok)
-findLast(list, ok) not in list
 findLast(list, ok).Bar
-findLast(list, ok).Qux
-findLast(list, ok).String
-findLast(list, ok)?.Bar
-findLast(list, ok)?.Qux
-findLast(list, ok)?.String
-findLast(list, true or ok)
-findLast(list, true).Bar
-findLast(list, true).Qux
+findLast(list, ok).String()
+findLast(list, true && false)
 findLast(list, true).String
 findLast(list, true)?.Bar
-findLast(list, true)?.Qux
-findLast(list, true)?.String
-findLast(map(array, #), # < #)
-findLast(map(array, #), # < i32)
-findLast(map(array, #), # <= 1)
-findLast(map(array, #), # == f64)
-findLast(map(array, #), 0.5 != 0.5)
-findLast(map(array, #), i32 == #)
-findLast(map(array, #), ok)
-findLast(map(array, f64 * #), # + # > f32)
-findLast(map(array, score), ok)
-findLast(map(list, #), # == #)
-findLast(map(list, #), greet == nil)
-findLast(map(list, #), ok)
-findLast(map(list, ok), # ? # : #)
-findLastIndex(1 .. 1, i64 < #)
-findLastIndex([i64, half], ok)
-findLastIndex(array, "bar" not matches "foo")
-findLastIndex(array, "bar" startsWith "foo")
-findLastIndex(array, "foo" == nil)
-findLastIndex(array, "foo" >= "foo")
-findLastIndex(array, "foo" contains "foo")
-findLastIndex(array, # != #)
-findLastIndex(array, # != 1)
-findLastIndex(array, # != f32)
-findLastIndex(array, # != f64)
-findLastIndex(array, # != i32)
-findLastIndex(array, # != i64)
-findLastIndex(array, # != nil)
+findLast(min($env), .array and false)
+findLast(sort($env), .array)
+findLast(sort($env), .f64 != #.i)
+findLast(sort($env), .list?.list)
+findLast(sort($env), 1.0 != #.list)
+findLastIndex($env, ok) > i
+findLastIndex($env, ok) ^ f64
+findLastIndex($env, true) <= f64
+findLastIndex($env, true) | bitor(1)
+findLastIndex($env, true) | bitshl(1)
+findLastIndex($env?.[str], 1.0 > #)
+findLastIndex($env?.array, ok)
+findLastIndex([false, true, $env], #.greet != true)
+findLastIndex([list], foo not in #)
+findLastIndex([true], str < str)
 findLastIndex(array, # < #)
-findLastIndex(array, # < 1)
-findLastIndex(array, # < f64)
 findLastIndex(array, # < i)
-findLastIndex(array, # < i64)
 findLastIndex(array, # <= #)
-findLastIndex(array, # <= 0.5)
-findLastIndex(array, # <= i64)
-findLastIndex(array, # == #)
-findLastIndex(array, # == 0.5)
-findLastIndex(array, # == 1)
-findLastIndex(array, # == f64)
-findLastIndex(array, # == i64)
-findLastIndex(array, # == nil)
 findLastIndex(array, # > #)
-findLastIndex(array, # > 0.5)
-findLastIndex(array, # > f32)
-findLastIndex(array, # > f64)
-findLastIndex(array, # > i)
-findLastIndex(array, # >= #)
-findLastIndex(array, # >= 0.5)
-findLastIndex(array, # >= 1)
-findLastIndex(array, # >= f32)
-findLastIndex(array, # >= i32)
-findLastIndex(array, # ^ # >= #)
-findLastIndex(array, # not in array)
-findLastIndex(array, 0.5 != #)
-findLastIndex(array, 0.5 != i64)
-findLastIndex(array, 0.5 < #)
-findLastIndex(array, 0.5 < i32)
-findLastIndex(array, 0.5 <= #)
-findLastIndex(array, 0.5 > #)
-findLastIndex(array, 0.5 >= 0.5)
-findLastIndex(array, 0.5 >= f64)
-findLastIndex(array, 1 != #)
-findLastIndex(array, 1 <= #)
-findLastIndex(array, 1 == #)
-findLastIndex(array, 1 == f64)
-findLastIndex(array, 1 >= i32)
-findLastIndex(array, array == nil)
-findLastIndex(array, f32 != #)
-findLastIndex(array, f32 != f32)
-findLastIndex(array, f32 < #)
-findLastIndex(array, f32 == #)
-findLastIndex(array, f32 == nil)
-findLastIndex(array, f32 > #)
-findLastIndex(array, f64 != #)
-findLastIndex(array, f64 < #)
-findLastIndex(array, f64 <= #)
-findLastIndex(array, f64 <= i32)
-findLastIndex(array, f64 == #)
-findLastIndex(array, f64 == 0.5)
-findLastIndex(array, f64 > #)
-findLastIndex(array, false ? # : false)
-findLastIndex(array, foo != foo)
-findLastIndex(array, greet == greet)
-findLastIndex(array, i - # >= #)
-findLastIndex(array, i < #)
-findLastIndex(array, i <= #)
-findLastIndex(array, i > 0.5)
-findLastIndex(array, i32 <= #)
-findLastIndex(array, i32 <= 1)
-findLastIndex(array, i32 <= f32)
-findLastIndex(array, i32 > 0.5)
-findLastIndex(array, i32 >= #)
-findLastIndex(array, i64 <= # + #)
-findLastIndex(array, i64 > #)
-findLastIndex(array, min(1, #) <= i32 + #)
-findLastIndex(array, nil != #)
-findLastIndex(array, nil != add)
-findLastIndex(array, nil != i32)
-findLastIndex(array, nil == #)
-findLastIndex(array, not (i32 != 0.5))
-findLastIndex(array, not ok)
-findLastIndex(array, ok && true)
+findLastIndex(array, $env == 1.0)
+findLastIndex(array, $env.ok)
+findLastIndex(array, 0 == $env)
+findLastIndex(array, 1 >= 1.0)
+findLastIndex(array, add == nil)
+findLastIndex(array, any($env, false))
+findLastIndex(array, false) != 1.0 + 1.0
+findLastIndex(array, nil == ok)
 findLastIndex(array, ok)
-findLastIndex(array, ok) % i64
-findLastIndex(array, ok) + f64
-findLastIndex(array, one(list, ok))
-findLastIndex(array, score == nil)
-findLastIndex(array, true == false)
-findLastIndex(array, true) / f32
-findLastIndex(array, true) not in array
-findLastIndex(filter(array, false), ok)
-findLastIndex(groupBy(list, #).ok, #)
-findLastIndex(groupBy(list, 0.5).Bar, #?.String endsWith .f32(list))
-findLastIndex(i32 .. i32, ok)
-findLastIndex(i64 .. 1, ok)
-findLastIndex(list, !(nil != #))
-findLastIndex(list, !false)
-findLastIndex(list, !ok)
-findLastIndex(list, !true)
-findLastIndex(list, "bar" in #)
-findLastIndex(list, "bar" matches "foo")
-findLastIndex(list, "bar" not endsWith "foo")
-findLastIndex(list, "bar" not matches "bar")
-findLastIndex(list, "foo" <= "bar")
-findLastIndex(list, "foo" not in #)
-findLastIndex(list, # != #)
-findLastIndex(list, # != foo)
+findLastIndex(array, str in foo)
+findLastIndex(array, str not in $env)
+findLastIndex(array, true) * f64
+findLastIndex(false ? nil : $env, ok)
+findLastIndex(flatten(array), ok)
 findLastIndex(list, # == #)
-findLastIndex(list, # == foo)
-findLastIndex(list, # == nil)
-findLastIndex(list, # in list)
-findLastIndex(list, # not in list)
-findLastIndex(list, 1 != f32)
-findLastIndex(list, 1 != nil)
-findLastIndex(list, 1 > 1)
-findLastIndex(list, 1 >= 0.5)
-findLastIndex(list, array != nil)
-findLastIndex(list, div != nil)
-findLastIndex(list, f32 != 1)
-findLastIndex(list, f32 != f64)
-findLastIndex(list, f64 > 0.5)
-findLastIndex(list, foo == #)
-findLastIndex(list, i <= 1)
-findLastIndex(list, i32 > 1)
-findLastIndex(list, i32 > f32)
-findLastIndex(list, i64 == i64)
-findLastIndex(list, i64 >= 0.5)
-findLastIndex(list, i64 not in array)
-findLastIndex(list, nil != "bar")
-findLastIndex(list, nil != #)
-findLastIndex(list, nil != f64)
-findLastIndex(list, nil == #)
+findLastIndex(list, #.Bar == nil)
+findLastIndex(list, $env.ok)
+findLastIndex(list, 0 != 1)
+findLastIndex(list, 0 > 1.0)
+findLastIndex(list, foo != #)
+findLastIndex(list, foo != $env)
+findLastIndex(list, foo not in list)
+findLastIndex(list, nil != nil)
 findLastIndex(list, nil == 1)
-findLastIndex(list, nil == half)
-findLastIndex(list, not false)
-findLastIndex(list, not true)
-findLastIndex(list, ok ? ok : 0.5)
-findLastIndex(list, ok and false)
 findLastIndex(list, ok)
-findLastIndex(list, ok) != i64
-findLastIndex(list, ok) > f32
-findLastIndex(list, ok) > i64
-findLastIndex(list, one(array, true))
-findLastIndex(list, true && ok)
-findLastIndex(list, true) * i32
-findLastIndex(list, true) - i32
-findLastIndex(list, true) < i64
-findLastIndex(list, true) > i64
-findLastIndex(list, true) ^ f64
-findLastIndex(map(array, "bar"), # not endsWith #)
-findLastIndex(map(array, #), # < f64)
-findLastIndex(map(array, #), # <= #)
-findLastIndex(map(array, #), ok)
-findLastIndex(map(array, div), 0.5 <= 0.5)
-findLastIndex(map(array, f32), nil == nil)
-findLastIndex(map(array, list), ok)
-findLastIndex(map(array, ok), # and #)
-findLastIndex(map(list, "bar"), # >= #)
-findLastIndex(map(list, #), !true)
-findLastIndex(map(list, #), nil == 0.5)
-findLastIndex(map(list, false), #)
-findLastIndex(map(list, foo), ok)
-findLastIndex(map(list, i32), # >= #)
-findLastIndex(map(list, i64), ok)
-findLastIndex(ok ? "bar" : add, not false)
-findLastIndex(true ? "foo" : 1, # and false)
-first(1 .. 1)
-first(1 .. i64)
-first([f32])
+findLastIndex(list, ok) < i
+findLastIndex(list, str == $env)
+findLastIndex(list, str not in #)
+findLastIndex(list, true) > f64
+findLastIndex(map(array, ok), #)
+findLastIndex(map(list, add), ok)
+findLastIndex(sort($env), #.foo?.greet)
+findLastIndex(sort($env), $env ?: #.i)
+first($env | findLast(false))
+first($env | map($env))
+first($env | map($env))?.foo
+first($env) != foo
+first($env) != i
+first($env) == str
+first($env) not contains str
+first($env) not in array
+first($env) not matches str
+first($env) not startsWith str
+first($env) startsWith str
+first($env)?.$env?.array()
+first($env)?.Bar
+first($env)?.Bar()
+first($env)?.Bar(add)
+first($env)?.String
+first($env)?.String()
+first($env)?.String?.array
+first($env)?.[add]
+first($env)?.[add]?.[foo]
+first($env)?.[array]
+first($env)?.[f64]
+first($env)?.[f64]?.String
+first($env)?.[foo]
+first($env)?.[foo]?.[greet].String
+first($env)?.[greet]
+first($env)?.[greet]?.[greet]
+first($env)?.[greet]?.str
+first($env)?.[i]
+first($env)?.[i]?.add
+first($env)?.[i]?.str
+first($env)?.[list]
+first($env)?.[ok]
+first($env)?.[ok].add()
+first($env)?.[str]
+first($env)?.[str]?.f64
+first($env)?.[str]?.ok
+first($env)?.add
+first($env)?.add()
+first($env)?.add?.[greet]
+first($env)?.array
+first($env)?.array()
+first($env)?.array(foobar)
+first($env)?.f64
+first($env)?.f64()
+first($env)?.f64(f64)
+first($env)?.f64(foobar)
+first($env)?.f64.String
+first($env)?.findIndex(add)
+first($env)?.foo
+first($env)?.foo()
+first($env)?.foo(foobar not contains foobar)
+first($env)?.foo(foobar)
+first($env)?.foo?.[greet]
+first($env)?.foobar not in $env
+first($env)?.foobar.greet
+first($env)?.foobar?.[greet]
+first($env)?.greet
+first($env)?.greet()
+first($env)?.greet(foobar not startsWith foobar)
+first($env)?.greet(foobar, foobar)
+first($env)?.greet(true)
+first($env)?.greet?.[i]
+first($env)?.greet?.str
+first($env)?.i
+first($env)?.i()
+first($env)?.i?.add
+first($env)?.list
+first($env)?.list()
+first($env)?.list(foo)
+first($env)?.list(foobar?.[Bar])
+first($env)?.list.str
+first($env)?.list?.add
+first($env)?.map(add)
+first($env)?.ok
+first($env)?.ok()
+first($env)?.ok(foobar)
+first($env)?.str
+first($env)?.str()
+first($env)?.str(f64)
+first($env.array)
+first($env.list)
+first($env?.$env)
+first($env?.Bar)
+first($env?.Bar)?.array
+first($env?.Bar?.[array])
+first($env?.Bar?.f64)
+first($env?.String)
+first($env?.String)?.String()
+first($env?.[Bar])
+first($env?.[Bar])?.[i]
+first($env?.[Bar])?.str
+first($env?.[Bar]?.String)
+first($env?.[Bar]?.f64)
+first($env?.[String])
+first($env?.[String]?.foo)
+first($env?.[foobar])
+first($env?.[foobar])?.Bar
+first($env?.[nil]?.ok)
+first($env?.[str])
+first($env?.array)
+first($env?.false)
+first($env?.foobar)
+first($env?.foobar)?.Bar()
+first($env?.foobar)?.i()
+first($env?.list)
+first($env?.nil)
+first($env?.nil)?.f64
+first(0..i)
+first(1 .. i)
+first(1 | median(array))
+first(1.0 | min(array))
+first([$env?.array])
+first([$env])
+first([0])
+first([1.0])
+first([1])
+first([add, $env, greet])
+first([add])
+first([array])
+first([f64])
+first([false])
 first([foo])
+first([greet])
+first([i])
+first([list])
+first([nil])
 first([ok])
+first([str])
+first([true])
+first(array | map($env))
+first(array | map(0))
+first(array | map(foo))
+first(array | sortBy(#))
+first(array | sortBy(1.0))
+first(array | take(1))
 first(array)
-first(array) * i
-first(array) * i64
-first(array) + f32
-first(array) <= i
-first(array) == f32
-first(array) == f64
-first(array) == i64
-first(array) > 0.5 ** i
-first(array) > i64
-first(array) ^ f64
-first(array[1:1])
-first(false ? foo : 1)
-first(false ? greet : foo)
-first(get(groupBy(array, #), i))
-first(groupBy(array, #).greet)
-first(groupBy(list, #)?.div)
-first(i .. i)
-first(i64 .. i32)
-first(i64 .. i64)
+first(array) != i
+first(array) == i
+first(array) > 1.0 > $env
+first(array) | bitand(1)
+first(array[:0])
+first(array[:1])
+first(concat(array))
+first(concat(list))
+first(filter(list, ok))
+first(first($env))
+first(flatten(array))
+first(flatten(list))
+first(i .. 1)
+first(i..i)
+first(if false { 0 } else { foo })
+first(if true { 0 } else { foo })?.add
+first(if true { ok } else { 1 })
+first(if true { ok } else { 1.0 })
+first(keys($env))
+first(last($env))
+first(let foobar = list; foobar)
+first(list | map(#))
+first(list | map(0))
+first(list | map(add))
+first(list | map(true))
+first(list | reduce(list))
+first(list | sortBy(#.Bar))
 first(list)
-first(list) not in list
+first(list) == $env?.String
 first(list).Bar
-first(list).Qux
 first(list).String
 first(list).String()
 first(list)?.Bar
-first(list)?.Qux
 first(list)?.String
 first(list)?.String()
+first(list[:i])
+first(map($env, $env))
+first(map($env, 0))
+first(map($env, array))
+first(map($env, f64))
+first(map($env, i))
 first(map(array, #))
-first(map(array, 0.5))
-first(map(array, 1))
-first(map(array, add))
-first(map(array, array))
-first(map(array, div))
-first(map(array, half))
-first(map(array, i))
-first(map(array, i32))
-first(map(array, i64))
-first(map(array, ok))
+first(map(array, 0))
+first(map(array, 1.0))
+first(map(array, false))
+first(map(array, greet))
+first(map(array, str))
+first(map(array, true))
 first(map(list, #))
-first(map(list, 0.5))
-first(map(list, f32))
-first(map(list, greet))
-first(map(list, i))
-first(map(list, list))
-first(map(list, score))
-first(ok ? 0.5 : false)
-first(ok ? array : add)
-first(ok ? greet : i64)
-first(ok ? list : ok)
-first(reduce(list, array))
-first(sort(array))
-first(true ? f32 : div)
-first(true ? greet : div)
-first(true ? score : div)
-float(-0.5)
-float(-1)
-float(-f32)
-float(-f64)
-float(-i)
-float(-i32)
-float(-i64)
-float(0.5 * 0.5)
-float(0.5 * 1)
-float(0.5 * f32)
-float(0.5 * i64)
-float(0.5 ** 0.5)
-float(0.5 ** f32)
-float(0.5 + 1)
-float(0.5 + i32)
-float(0.5 + i64)
-float(0.5 - 0.5)
-float(0.5 - 1)
-float(0.5 - i64)
-float(0.5 / 0.5)
-float(0.5 / i32)
-float(0.5 / i64)
-float(0.5 ^ 1)
-float(0.5 ^ i)
-float(0.5) != f32
-float(0.5) != i32
-float(0.5) * f32
-float(0.5) * i32
-float(0.5) * i64
-float(0.5) ** f64
-float(0.5) ** i
-float(0.5) ** i32
-float(0.5) - i
-float(0.5) - i64
-float(0.5) / f32
-float(0.5) / f64
-float(0.5) / i32
-float(0.5) == i32 * 0.5
-float(0.5) ^ i64
-float(0.5) in array
-float(1 % i64)
-float(1 * 0.5)
-float(1 * f32)
-float(1 * i)
-float(1 * i64)
-float(1 ** 0.5)
+first(map(list, 0))
+first(map(list, foo))
+first(max($env))
+first(max(array))
+first(mean(array))
+first(median(array))
+first(min($env))
+first(min(array))
+first(ok ? 0 : 1.0)
+first(ok ?: $env)
+first(ok ?: add)
+first(ok ?: list)
+first(reduce(array, $env))
+first(reverse(list))
+first(sort($env))
+first(sortBy(array, #))
+first(sortBy(array, f64))
+first(sortBy(list, .Bar))
+first(toPairs($env))
+first(true ? 1.0 : foo)
+first(true ?: 1.0)?.str
+first(uniq(array))
+first(uniq(list))
+first(values($env))
+first({foo: 1.0}.f64)
+first({foo: greet, foo: nil}.ok)
+flatten($env | map(array))
+flatten($env | map(foo))
+flatten($env | map(i))
+flatten($env.array)
+flatten($env.list)
+flatten($env?.array)
+flatten($env?.list)
+flatten($env?.list)?.[i]
+flatten(0 .. i)
+flatten(1 .. 1)
+flatten(1 .. i)
+flatten([$env])
+flatten([0 <= 1])
+flatten([0, 1.0])
+flatten([0])
+flatten([1.0, foo])
+flatten([1.0])
+flatten([1])
+flatten([add, greet])
+flatten([add])
+flatten([array, ok])
+flatten([array])
+flatten([f64])
+flatten([false, list])
+flatten([false])
+flatten([foo, 1.0])
+flatten([foo])
+flatten([greet])
+flatten([i, list])
+flatten([i])
+flatten([list])
+flatten([nil])
+flatten([ok, true])
+flatten([ok])
+flatten([str])
+flatten(array | map(#))
+flatten(array | map(1.0))
+flatten(array | map(false))
+flatten(array | sortBy(#))
+flatten(array | sortBy(1.0))
+flatten(array)
+flatten(array) | groupBy(#)
+flatten(array) | map(#)
+flatten(array) | one(true)
+flatten(array) | reduce(1.0)
+flatten(array) | sum(#)
+flatten(array)?.[i]
+flatten(array)[i:]
+flatten(array[0:])
+flatten(array[:1])
+flatten(concat(array))
+flatten(concat(list))
+flatten(filter(list, false))
+flatten(flatten(array))
+flatten(groupBy(list, #).i)
+flatten(i .. 0)
+flatten(i..i)
+flatten(if true { array } else { add })
+flatten(keys($env))
+flatten(list | map(#))
+flatten(list | map(i))
+flatten(list | sortBy(f64))
+flatten(list | sortBy(str))
+flatten(list)
+flatten(list) == list
+flatten(list) | filter(true)
+flatten(list) | findLastIndex(false)
+flatten(list) | groupBy(foo)
+flatten(list) | map(f64)
+flatten(list) | map(false)
+flatten(list) | map(foo)
+flatten(list) | map(ok)
+flatten(list) | reduce(#)
+flatten(list) | reduce($env, $env)
+flatten(list) | sortBy(0)
+flatten(list) | sortBy(str)
+flatten(list)?.[i]
+flatten(list)[:]
+flatten(map($env, $env))
+flatten(map($env, 0))
+flatten(map($env, 1.0))
+flatten(map(array, true))
+flatten(map(list, #))
+flatten(map(list, $env))
+flatten(map(list, .Bar))
+flatten(map(list, ok))
+flatten(reduce(array, array))
+flatten(reverse(array))
+flatten(reverse(list))
+flatten(sort(array))
+flatten(sortBy(array, #))
+flatten(sortBy(array, 1))
+flatten(sortBy(array, 1.0))
+flatten(sortBy(array, f64))
+flatten(toPairs($env))
+flatten(uniq(array))
+flatten(uniq(list))
+flatten(values($env))
+float($env | findLastIndex(ok))
+float($env | findLastIndex(true))
+float($env | sum(1.0))
+float($env | sum(f64))
+float($env.f64)
+float($env.i)
+float($env?.f64)
+float($env?.i)
+float(0 % 1)
+float(0 % i)
+float(0 * 1)
+float(0 * 1.0)
+float(0 * f64)
+float(0 ** 1.0)
+float(0 ** f64)
+float(0 ** i)
+float(0 + 1)
+float(0 + i)
+float(0 - 1.0)
+float(0 - i)
+float(0 / 0)
+float(0 / 1.0)
+float(0 / i)
+float(0 ^ 1.0)
+float(0 ^ i)
+float(0) > f64
+float(0) > i
+float(0) ^ f64
+float(1 % i)
+float(1 * 1.0)
 float(1 ** 1)
 float(1 ** f64)
 float(1 ** i)
-float(1 + f64)
-float(1 + i32)
-float(1 - 0.5)
-float(1 / 0.5)
-float(1 ^ f64)
-float(1) * f32
-float(1) * i64
-float(1) ** i
-float(1) ** i64
+float(1 + 1)
+float(1 + 1.0)
+float(1 + i)
+float(1 - 1.0)
+float(1 - f64)
+float(1 / 1)
+float(1 / 1.0)
+float(1 ^ 0)
+float(1 ^ 1.0)
+float(1 ^ i)
 float(1) - f64
-float(1) <= i64
-float(1) == i64
-float(1) > -0.5
-float(1) > i64
-float(1) >= f64
-float(1) >= i
-float(abs(f32))
+float(1) < f64
+float(1) == i
+float(1) in [add, true]
+float(1.0 * 0)
+float(1.0 * 1)
+float(1.0 * 1.0)
+float(1.0 * f64)
+float(1.0 * i)
+float(1.0 ** 1)
+float(1.0 ** 1.0)
+float(1.0 ** f64)
+float(1.0 + 0)
+float(1.0 + 1.0)
+float(1.0 + f64)
+float(1.0 + i)
+float(1.0 - 0)
+float(1.0 - 1)
+float(1.0 - 1.0)
+float(1.0 - f64)
+float(1.0 - i)
+float(1.0 / 1.0)
+float(1.0 / f64)
+float(1.0 / i)
+float(1.0 ^ 1)
+float(1.0 ^ 1.0)
+float(1.0 ^ f64)
+float(1.0 ^ i)
+float(1.0 | min(f64))
+float(1.0) != $env?.[str]
+float(1.0) * max(f64)
+float(1.0) - f64
+float(1.0) / i
+float(1.0) == 0 % 1
+float(1.0) == i
+float(1.0) == i != false
+float(1.0) > f64
+float(1.0) >= last(array)
+float(abs(0))
+float(abs(1.0))
 float(abs(f64))
 float(abs(i))
-float(abs(i32))
-float(add(1, 1))
-float(array[i32])
-float(array[i64])
-float(array[i])
-float(bitnot(1))
+float(add(0, i))
+float(array | max(1))
+float(array | reduce(#index, 1.0))
+float(array | sum(#))
+float(array | sum(1.0))
+float(array?.[i])
+float(bitand(0, i))
+float(bitnot(0))
 float(bitnot(i))
-float(bitnot(i32))
-float(bitnot(i64))
-float(ceil(0.5))
-float(ceil(f32))
+float(bitor(0, i))
+float(bitshl(i, 0))
+float(bitshr(0, 0))
+float(bitshr(i, 1))
+float(ceil(0))
+float(ceil(1))
+float(ceil(1.0))
 float(ceil(f64))
-float(ceil(i32))
-float(ceil(i64))
-float(count(array, false))
-float(count(array, ok))
-float(count(list, i32 == 0.5))
-float(f32 * f64)
-float(f32 * i)
-float(f32 * i32)
-float(f32 ** 1)
-float(f32 ** f32)
-float(f32 ** i)
-float(f32 ** i64)
-float(f32 + 0.5)
-float(f32 + 1)
-float(f32 + f64)
-float(f32 + i32)
-float(f32 + i64)
-float(f32 - 0.5)
-float(f32 - f64)
-float(f32 - i64)
-float(f32 / 0.5)
-float(f32 / 1)
-float(f32 / i)
-float(f32 ^ 0.5)
-float(f32 ^ 1)
-float(f32 ^ f32)
-float(f32 ^ i)
-float(f32 ^ i32)
-float(f32)
-float(f32) < i32
-float(f32) <= f32
-float(f32) <= f64 / f32
-float(f32) <= i
-float(f32) > i
-float(f32) >= i64
-float(f32) ^ f64
-float(f32) ^ i64
-float(f64 * 0.5)
-float(f64 * 1)
-float(f64 * f32)
-float(f64 * f64)
-float(f64 * i32)
-float(f64 ** f32)
-float(f64 + 1)
+float(ceil(i))
+float(count($env, false))
+float(count(list, false))
+float(count(list, ok))
+float(f64 * 1.0)
+float(f64 ** 0)
+float(f64 ** 1)
+float(f64 ** 1.0)
+float(f64 + f64)
 float(f64 + i)
-float(f64 + i32)
-float(f64 - 1)
-float(f64 - i)
-float(f64 / 0.5)
-float(f64 / 1)
-float(f64 / i64)
-float(f64 ^ f32)
+float(f64 - 1.0)
+float(f64 / 1.0)
+float(f64 / i)
+float(f64 ^ 0)
+float(f64 ^ 1.0)
 float(f64)
-float(f64) * f32
-float(f64) * i
-float(f64) / -i32
-float(f64) / i
-float(f64) == f64
-float(f64) > f64
-float(f64) > i64
-float(f64) >= f32
-float(f64) >= i
-float(f64) >= i64
-float(f64) ^ i64
-float(false ? f64 : 0.5)
-float(false ? half : f64)
-float(false ? list : f64)
-float(find(array, ok))
-float(findIndex(array, ok))
-float(findLastIndex(array, ok))
-float(findLastIndex(list, true))
-float(first(array))
-float(float(0.5))
+float(f64) != f64
+float(f64) == i
+float(false ? i : 1.0)
+float(false ? str : 1.0)
+float(false ?: 1.0)
+float(false ?: i)
+float(findIndex($env, ok))
+float(findIndex(array, true))
+float(findLastIndex($env, true))
 float(float(1))
-float(float(f32))
 float(float(f64))
-float(float(i))
-float(float(i32))
-float(floor(0.5))
 float(floor(1))
-float(floor(f32))
+float(floor(1.0))
 float(floor(f64))
-float(floor(i32))
-float(floor(i64))
-float(get(array, 1))
-float(get(array, i))
-float(half(0.5))
-float(half(1))
-float(half(f64))
-float(i % i32)
-float(i * 0.5)
-float(i * f64)
-float(i * i64)
-float(i ** f32)
-float(i ** i32)
-float(i + 0.5)
+float(i % 1)
+float(i * 1.0)
+float(i ** 1.0)
 float(i + 1)
-float(i + i64)
+float(i - 0)
 float(i - 1)
 float(i - f64)
-float(i / 0.5)
+float(i - i)
 float(i / 1)
-float(i ^ 0.5)
-float(i ^ i32)
+float(i / 1.0)
 float(i)
-float(i) != 1 ? nil : foo
-float(i) != f64
-float(i) + f32
-float(i) + f64
-float(i) < i
-float(i) == f32
-float(i) == i
-float(i) > f64
-float(i32 % i)
-float(i32 % i64)
-float(i32 * f64)
-float(i32 * i32)
-float(i32 ** 1)
-float(i32 + f64)
-float(i32 + i64)
-float(i32 / 1)
-float(i32 / f32)
-float(i32 / i32)
-float(i32 ^ f64)
-float(i32 ^ i32)
-float(i32)
-float(i32) != f64
-float(i32) ** f32
-float(i32) ** i
-float(i32) > i32
-float(i32) >= i
-float(i64 % i64)
-float(i64 * i64)
-float(i64 ** 1)
-float(i64 + f32)
-float(i64 + i)
-float(i64 - 0.5)
-float(i64 - 1)
-float(i64 - f32)
-float(i64 / 1)
-float(i64 ^ f32)
-float(i64)
-float(i64) != i
-float(i64) ** max(f64)
-float(i64) + i32
-float(i64) - 0.5 ^ f32
-float(i64) - f64
-float(i64) / i32
-float(i64) < i32
-float(i64) == i
-float(i64) == i64
-float(i64) > i
-float(i64) ^ f32
-float(int(0.5))
+float(i) + first(array)
+float(if false { 1.0 } else { 1 })
+float(if false { greet } else { 1 })
+float(if false { greet } else { 1.0 })
+float(if true { 0 } else { $env })
+float(int(0))
 float(int(1))
-float(int(f32))
+float(int(1.0))
+float(int(f64))
 float(int(i))
-float(int(i32))
-float(last(array))
-float(len("bar"))
+float(lastIndexOf(str, str))
+float(len($env))
 float(len(array))
 float(len(list))
-float(max(0.5))
-float(max(0.5, i64))
-float(max(1))
-float(max(1, 1))
-float(max(f32))
-float(max(f64))
+float(len(str))
+float(let foobar = i; foobar)
+float(list | findIndex(ok))
+float(list | reduce(i))
+float(list | sum(f64))
+float(max(0))
+float(max(1.0))
 float(max(i))
-float(max(i32))
-float(max(i64))
+float(mean(0))
+float(mean(1))
+float(mean(1.0 - 1.0))
+float(mean(1.0))
 float(mean(array))
-float(min(1))
-float(min(f64))
-float(min(f64, i64))
-float(min(i32))
-float(min(i64))
-float(ok ? 0.5 : foo)
-float(ok ? 0.5 : list)
-float(reduce(array, #))
-float(reduce(array, 0.5))
-float(reduce(array, f64))
-float(reduce(array, i32))
-float(reduce(list, i64))
-float(round(0.5))
+float(mean(f64))
+float(mean(i))
+float(median(0))
+float(median(1.0))
+float(median(1.0, 0, 0))
+float(median(1.0, i))
+float(median(f64))
+float(median(i))
+float(min($env?.array))
+float(min(0))
+float(min(1.0))
+float(min(array))
+float(min(i))
+float(reduce($env, 1.0, 1.0))
+float(reduce(list, 0))
+float(reduce(list, 1))
+float(reduce(list, i))
 float(round(1))
-float(round(i32))
-float(round(i64))
-float(score(1))
-float(score(1, 1))
-float(score(i))
-float(string(0.5))
+float(round(1.0))
+float(round(f64))
+float(round(i))
+float(string(0))
 float(string(1))
-float(string(f64 - 0.5))
-float(string(i))
-float(string(i32))
-float(string(i64))
+float(string(1.0))
+float(string(f64))
+float(sum($env, 0))
+float(sum($env, 1))
+float(sum($env?.array))
 float(sum(array))
-float(toJSON(0.5))
+float(sum(array, #))
+float(sum(array, 1))
+float(sum(array, i))
+float(sum(list, 1))
 float(toJSON(1))
-float(toJSON(f32))
-float(toJSON(f64))
-float(toJSON(i32))
-float(toJSON(i64))
-float(true ? f32 : "foo")
-floor(-0.5)
-floor(-1)
-floor(-f32)
-floor(-f64)
-floor(-i)
-floor(-i32)
-floor(-i64)
-floor(0.5 * 0.5)
-floor(0.5 * 1)
-floor(0.5 * i32)
-floor(0.5 ** 1)
-floor(0.5 ** f64)
-floor(0.5 ** i)
-floor(0.5 + 1)
-floor(0.5 + f32)
-floor(0.5 + i)
-floor(0.5 + i32)
-floor(0.5 + i64)
-floor(0.5 - 1)
-floor(0.5 - f32)
-floor(0.5 - i)
-floor(0.5 / 0.5)
-floor(0.5 / 1)
-floor(0.5 / i32)
-floor(0.5 ^ 0.5)
-floor(0.5 ^ 1)
-floor(0.5 ^ f32)
-floor(0.5 ^ f64)
-floor(0.5 ^ i)
-floor(0.5) != i64
-floor(0.5) ** f32
-floor(0.5) - i
-floor(0.5) - i64
-floor(0.5) / i
-floor(0.5) <= i64
-floor(0.5) > i32
-floor(0.5) > i64 != ok
-floor(0.5) >= f32
-floor(0.5) ^ i
-floor(1 % 1)
-floor(1 % i)
-floor(1 * 0.5)
+float(toJSON(i))
+float(toJSON(min(1.0)))
+float(true ? 1.0 : ok)
+float(true ? f64 : foo)
+float(true ? f64 : str)
+floor($env | findIndex(ok))
+floor($env.f64)
+floor($env.i)
+floor($env?.f64)
+floor($env?.i)
+floor(0 % i)
+floor(0 * 1)
+floor(0 * 1.0)
+floor(0 * i)
+floor(0 + 1.0)
+floor(0 + f64)
+floor(0 - 0)
+floor(0 - 1)
+floor(0 - 1.0)
+floor(0 - i)
+floor(0 / 1)
+floor(0 / f64)
+floor(0 ^ 0)
+floor(0 ^ 1.0)
+floor(0 | min(1.0))
+floor(0) * i
+floor(0) <= f64
 floor(1 * 1)
+floor(1 * 1.0)
+floor(1 * f64)
+floor(1 * i)
+floor(1 ** 0)
 floor(1 ** 1)
-floor(1 ** f64)
-floor(1 ** i32)
-floor(1 + 0.5)
-floor(1 + 1)
-floor(1 + f32)
-floor(1 + f64)
-floor(1 + i32)
-floor(1 - 0.5)
-floor(1 - 1)
+floor(1 ** i)
+floor(1 + 1.0)
+floor(1 + i)
 floor(1 - i)
-floor(1 - i32)
-floor(1 - i64)
-floor(1 / 0.5)
-floor(1 / 1)
-floor(1 / i)
-floor(1 / i64)
+floor(1 / 0)
+floor(1 / 1.0)
+floor(1 / f64)
+floor(1 ^ 0)
+floor(1 ^ 1.0)
+floor(1 ^ f64)
 floor(1 ^ i)
-floor(1 ^ i32)
-floor(1 ^ i64)
-floor(1) * i64
-floor(1) - f32
-floor(1) - i
-floor(1) <= f32
-floor(1) >= half(0.5)
-floor(abs(0.5))
+floor(1) != f64
+floor(1) * f64
+floor(1) + $env?.f64
+floor(1) <= i
+floor(1) in array
+floor(1.0 * 1)
+floor(1.0 * 1.0)
+floor(1.0 * f64)
+floor(1.0 ** 1)
+floor(1.0 ** 1.0)
+floor(1.0 ** f64)
+floor(1.0 ** i)
+floor(1.0 + 1)
+floor(1.0 + 1.0)
+floor(1.0 + f64)
+floor(1.0 - 0)
+floor(1.0 - 1.0)
+floor(1.0 - f64)
+floor(1.0 - i)
+floor(1.0 / 0)
+floor(1.0 / 1.0)
+floor(1.0 / f64)
+floor(1.0 ^ 0)
+floor(1.0 ^ 1.0)
+floor(1.0 ^ i)
+floor(1.0 | max(f64))
+floor(1.0 | mean(array))
+floor(1.0) != $env?.f64
+floor(1.0) + f64
+floor(1.0) - $env.i
+floor(1.0) == f64
+floor(1.0) > i
+floor(1.0) | median(0)
+floor(abs(0))
 floor(abs(1))
-floor(abs(f32))
+floor(abs(1.0))
 floor(abs(f64))
-floor(abs(i32))
-floor(abs(i64))
-floor(array[1])
-floor(array[i32])
-floor(array[i64])
-floor(array[i])
+floor(abs(i))
+floor(add(i, i))
+floor(array | findLast(ok))
+floor(array | mean(1))
+floor(array | mean(f64))
+floor(array | reduce(#))
+floor(array | sum(f64))
+floor(array?.[i])
+floor(bitnot(0))
 floor(bitnot(1))
-floor(bitnot(i))
-floor(bitnot(i32))
-floor(bitnot(i64))
-floor(ceil(0.5))
 floor(ceil(1))
-floor(ceil(f64))
+floor(ceil(1.0))
 floor(ceil(i))
-floor(ceil(i32))
-floor(ceil(i64))
-floor(count(array, false))
-floor(count(array, ok))
+floor(count($env, true))
 floor(count(list, ok))
-floor(f32 ** 1)
-floor(f32 ** f64)
-floor(f32 ** i32)
-floor(f32 + f32)
-floor(f32 + i32)
-floor(f32 + i64)
-floor(f32 - 0.5)
-floor(f32 - f64)
-floor(f32 / 0.5)
-floor(f32 / f64)
-floor(f32 / i)
-floor(f32 / i32)
-floor(f32 / i64)
-floor(f32 ^ 0.5)
-floor(f32 ^ f64)
-floor(f32 ^ i)
-floor(f32)
-floor(f32) != -i32
-floor(f32) * i32
-floor(f32) + f32
-floor(f32) / f32
-floor(f32) / f64
-floor(f32) == i64
-floor(f32) > i32
-floor(f32) >= f32
-floor(f32) >= i
-floor(f32) ^ f32
-floor(f64 * f32)
-floor(f64 ** 0.5)
-floor(f64 ** 1)
-floor(f64 ** i32)
-floor(f64 + 0.5)
-floor(f64 + 1)
-floor(f64 + i32)
-floor(f64 - 0.5)
-floor(f64 - i32)
-floor(f64 / 0.5)
-floor(f64 / 1)
-floor(f64 / f32)
+floor(f64 * 1.0)
+floor(f64 ** 1.0)
+floor(f64 ** i)
+floor(f64 + 0)
+floor(f64 + 1.0)
+floor(f64 - 1)
+floor(f64 - 1.0)
+floor(f64 - i)
 floor(f64 / f64)
-floor(f64 / i)
-floor(f64 ^ 1)
+floor(f64 ^ 1.0)
+floor(f64 ^ i)
 floor(f64)
-floor(f64) * i32
-floor(f64) ** f64
-floor(f64) / f32
-floor(f64) < i32
-floor(f64) <= f64
-floor(f64) <= i64
-floor(f64) == f64 ** i
-floor(f64) == i
-floor(f64) > i32
-floor(f64) >= 1 * 1
-floor(f64) >= f32
-floor(false ? div : 0.5)
-floor(find(array, true))
-floor(findIndex(array, ok))
-floor(findLastIndex(array, ok))
-floor(float(0.5))
+floor(f64) < f64
+floor(f64) >= f64
+floor(f64) >= i ^ f64
+floor(f64) in array
+floor(false ?: 1)
+floor(findIndex($env, ok))
+floor(findIndex(list, true))
+floor(findLast(array, ok))
+floor(findLastIndex(array, true))
+floor(first(array))
+floor(float(0))
 floor(float(1))
+floor(float(1.0))
 floor(float(f64))
-floor(float(i32))
-floor(floor(0.5))
+floor(floor(0))
 floor(floor(1))
-floor(floor(f32))
-floor(floor(f64))
-floor(floor(i))
-floor(floor(i32))
-floor(floor(i64))
-floor(get(array, 1))
-floor(get(array, i))
-floor(get(array, i64))
-floor(half(0.5))
-floor(half(1))
-floor(half(f64))
-floor(i % 1)
-floor(i % i)
-floor(i % i32)
-floor(i % i64)
-floor(i * 1)
-floor(i * f64)
-floor(i ** 0.5)
-floor(i ** f32)
-floor(i ** i32)
-floor(i ** i64)
-floor(i + 0.5)
-floor(i + f64)
-floor(i - 0.5)
-floor(i - f32)
-floor(i - i32)
-floor(i / 0.5)
+floor(floor(1.0))
+floor(i * 1.0)
+floor(i * i)
+floor(i ** 1)
+floor(i ** 1.0)
+floor(i ** i)
+floor(i + 1.0)
+floor(i + i)
+floor(i - f64)
+floor(i / 0)
 floor(i / 1)
+floor(i / 1.0)
 floor(i / f64)
-floor(i ^ i32)
+floor(i ^ 0)
+floor(i ^ 1.0)
+floor(i ^ i)
+floor(i | min(0))
 floor(i)
-floor(i) != i
-floor(i) * f64
-floor(i) ^ i
-floor(i32 % i32)
-floor(i32 * 1)
-floor(i32 * f32)
-floor(i32 * f64)
-floor(i32 * i32)
-floor(i32 ** i)
-floor(i32 ** i64)
-floor(i32 + 0.5)
-floor(i32 + f64)
-floor(i32 - 1)
-floor(i32 - f32)
-floor(i32 - i)
-floor(i32 - i32)
-floor(i32 - i64)
-floor(i32 ^ 0.5)
-floor(i32 ^ 1)
-floor(i32 ^ f64)
-floor(i32 ^ i)
-floor(i32 ^ i32)
-floor(i32 ^ i64)
-floor(i32)
-floor(i32) != f32
-floor(i32) * f64
-floor(i32) * i
-floor(i32) * i64
-floor(i32) > i32
-floor(i32) > i64
-floor(i32) >= i32
-floor(i32) ^ i32
-floor(i64 % i)
-floor(i64 * 0.5)
-floor(i64 * f32)
-floor(i64 * i)
-floor(i64 ** 0.5)
-floor(i64 ** 1)
-floor(i64 ** i)
-floor(i64 ** i32)
-floor(i64 + 0.5)
-floor(i64 + f64)
-floor(i64 + i64)
-floor(i64 - f64)
-floor(i64 - i)
-floor(i64 / f32)
-floor(i64 ^ 0.5)
-floor(i64 ^ f32)
-floor(i64 ^ i64)
-floor(i64)
-floor(i64) * i64
-floor(i64) / (i64 - i)
-floor(i64) / f64
-floor(i64) / i32
-floor(i64) < f32
-floor(i64) <= i64
-floor(i64) ^ f32
-floor(int(0.5))
+floor(i) ** 1.0 >= 1.0
+floor(i) ** i
+floor(i) - f64
+floor(i) / sum(array)
+floor(i) == $env != ok
+floor(i) == i
+floor(i) ^ f64
+floor(i) | max(1.0)
+floor(if ok { i } else { $env })
+floor(int(0))
 floor(int(1))
-floor(int(i32))
-floor(int(i64))
-floor(len("foo"))
+floor(int(1.0))
+floor(int(f64))
+floor(int(i))
+floor(last(array))
+floor(len($env))
 floor(len(array))
 floor(len(list))
-floor(max(0.5))
+floor(len(str))
+floor(let foobar = 1.0; foobar)
+floor(list | sum(1))
+floor(max(0))
 floor(max(1))
-floor(max(f32))
+floor(max(1.0))
 floor(max(f64))
-floor(max(i32))
-floor(min(0.5))
-floor(min(f64) ^ i64)
-floor(min(i, i64))
-floor(min(i32))
-floor(ok ? 1 : 1)
-floor(ok ? f32 : "foo")
-floor(ok ? i64 : f64)
+floor(max(i))
+floor(mean(0))
+floor(mean(0, 1.0))
+floor(mean(1))
+floor(mean(1.0))
+floor(mean(array))
+floor(mean(f64))
+floor(mean(i))
+floor(median(0))
+floor(median(1))
+floor(median(1.0))
+floor(median(array))
+floor(median(f64))
+floor(median(i))
+floor(min(1))
+floor(min(1.0))
+floor(min(1.0, 0))
+floor(min(array))
+floor(min(i))
+floor(ok ? 1.0 : nil)
+floor(ok ? i : greet)
 floor(reduce(array, #))
-floor(reduce(array, i))
-floor(reduce(array, i64))
-floor(reduce(list, 1))
-floor(reduce(list, f32))
-floor(reduce(list, i64))
-floor(round(0.5))
-floor(round(f32))
+floor(reduce(array, 1))
+floor(round(1))
+floor(round(1.0))
 floor(round(f64))
-floor(round(i))
-floor(round(i32))
-floor(score(1))
-floor(score(1, 1))
-floor(score(i))
-floor(true ? 0.5 : false)
-floor(true ? 1 : true)
-floor(true ? f64 : 0.5)
-floor(true ? f64 : array)
+floor(sum($env, 1.0))
+floor(sum(array))
+floor(sum(array, #))
+floor(sum(array, 1.0))
+floor(sum(list, 1.0))
 foo
+foo != $env != ok
+foo != $env && ok and ok
+foo != $env == true
+foo != $env ? $env : nil
+foo != $env.foo
+foo != $env?.Bar
+foo != $env?.Bar?.[i]
+foo != $env?.Bar?.array
+foo != $env?.Bar?.list
+foo != $env?.String
+foo != $env?.String?.[greet]
+foo != $env?.String?.greet
+foo != $env?.[Bar]
+foo != $env?.[String]
+foo != $env?.[String]?.add
+foo != $env?.[foobar]
+foo != $env?.[str]
+foo != $env?.foo
+foo != $env?.foobar
+foo != $env?.not
+foo != first(list)
 foo != foo
-foo != nil != nil
-foo != reduce(list, #)
+foo != foo != $env
+foo != foo && $env.ok
+foo != foo && get($env, 1)
+foo != foo == $env || false
+foo != foo == false
+foo != foo == true
+foo != foo or ok
+foo != list?.[i]
+foo != nil != $env
+foo != nil ? 1.0 : $env
+foo != nil ? str : foo
+foo != nil || sum($env, $env)
+foo == $env != nil
+foo == $env in $env?.foobar
+foo == $env or $env.ok
+foo == $env || $env
+foo == $env.foo
+foo == $env?.Bar
+foo == $env?.Bar?.[i]
+foo == $env?.String
+foo == $env?.[Bar]
+foo == $env?.[String]
+foo == $env?.[String]?.[f64]
+foo == $env?.[foobar?.greet]
+foo == $env?.[foobar]
+foo == $env?.[str]
+foo == $env?.foo
+foo == $env?.foobar
+foo == $env?.foobar?.array()
+foo == $env?.nil
+foo == $env?.not
 foo == foo
-foo == foo and 0.5 != f64
-foo == get(list, 1)
-foo == list[i]
-foo == nil ? i : i32
-foo == nil ? i64 : i
-foo == reduce(list, #)
-foo in filter(list, false)
-foo in groupBy(array, #)
-foo in groupBy(list, #)
+foo == foo != ok
+foo == foo == ok
+foo == foo ? $env : $env
+foo == foo ?: f64
+foo == foo ?: i
+foo == foo or $env?.[greet]
+foo == foo or ok
+foo == foo || ok
+foo == last($env)
+foo == last(list)
+foo == list?.[i]
+foo == nil != $env
+foo == nil != nil
+foo == nil && $env or $env
+foo == nil && f64 >= 1.0
+foo == nil == $env
+foo == nil ? foo : i
+foo == nil ? true : i
+foo == nil and ok
+foo == nil || false
+foo in $env.list
+foo in $env?.Bar
+foo in $env?.Bar?.[add]?.[str]
+foo in $env?.String
+foo in $env?.String?.[ok]
+foo in $env?.[Bar]
+foo in $env?.[Bar]?.[i]
+foo in $env?.[String]
+foo in $env?.[String]?.[array]
+foo in $env?.[String]?.[foo]
+foo in $env?.[foobar?.foo]
+foo in $env?.[foobar]
+foo in $env?.[foobar]?.list
+foo in $env?.foobar
+foo in $env?.foobar?.list()
+foo in $env?.list
+foo in $env?.true?.[greet]
+foo in [nil]
+foo in flatten(array)
+foo in keys($env)
 foo in list
+foo in list != nil && $env
 foo in list != ok
-foo not in groupBy(array, #)
-foo not in groupBy(array, f64).foo
-foo not in groupBy(list, #).i
-foo not in groupBy(list, f32)
-foo not in groupBy(list, ok)
+foo in list == $env?.ok
+foo in list || false
+foo in list[0:]
+foo in map(list, foo)
+foo in toPairs($env)
+foo in uniq(list)
+foo not in $env.list
+foo not in $env?.Bar
+foo not in $env?.String
+foo not in $env?.[Bar]
+foo not in $env?.[Bar]?.String
+foo not in $env?.[String]
+foo not in $env?.[String]?.[list]
+foo not in $env?.[foobar?.f64]
+foo not in $env?.[foobar]
+foo not in $env?.[nil | last(foobar)]
+foo not in $env?.[nil]
+foo not in $env?.foobar
+foo not in $env?.foobar?.greet(foobar)
+foo not in $env?.list
+foo not in $env?.nil?.[ok]
+foo not in [$env]
+foo not in flatten(array)
+foo not in keys($env)
 foo not in list
-foo not in list and ok
-foo not in list or false
-foo not in map(list, #)
+foo not in list != false
+foo not in list && ok
 foo.Bar
-foo.Bar <= foo.Bar
-foo.Bar matches foo.Bar
-foo.Bar matches trimPrefix("foo")
-foo.Qux
-foo.Qux("foo" + "foo")
-foo.Qux(foo.Bar)
-foo.Qux(foo.String())
-foo.Qux(greet("foo"))
-foo.Qux(string("foo"))
-foo.Qux(toJSON(i))
-foo.Qux(type("bar"))
-foo.Qux(type(f64))
-foo.Qux(type(half))
+foo.Bar != foo?.Bar
+foo.Bar != str
+foo.Bar + str
+foo.Bar < foo.Bar
+foo.Bar <= str
+foo.Bar == $env?.Bar
+foo.Bar == foo?.Bar
+foo.Bar == str
+foo.Bar > foo.String()
+foo.Bar > str
+foo.Bar >= str
+foo.Bar >= type(ok)
+foo.Bar contains $env?.String
+foo.Bar contains str
+foo.Bar endsWith str
+foo.Bar in $env
+foo.Bar in foo
+foo.Bar matches str
+foo.Bar not contains str
+foo.Bar not endsWith str
+foo.Bar not in foo
+foo.Bar not in {foo: nil, foo: 1}
+foo.Bar not matches str
+foo.Bar not matches toJSON(i)
+foo.Bar not startsWith foo?.Bar
+foo.Bar not startsWith str
+foo.Bar startsWith $env?.String?.f64()
+foo.Bar startsWith $env?.[Bar]
+foo.Bar startsWith str
+foo.Bar | greet()
+foo.Bar | hasPrefix(str)
+foo.Bar | indexOf(str)
+foo.Bar | repeat(0)
+foo.Bar | split($env?.str)
+foo.Bar | trimSuffix(str)
+foo.Bar[:]
+foo.Bar[:i]
+foo.Bar[i:]
 foo.String
+foo.String != $env?.foobar
+foo.String == $env?.[String]
 foo.String()
-foo.String() != foo?.String()
-foo.String() in foo
+foo.String() != str
+foo.String() <= $env.str
+foo.String() <= str
+foo.String() > foo.Bar
+foo.String() >= $env?.[str]
+foo.String() >= str
+foo.String() contains str
+foo.String() endsWith str
 foo.String() not in foo
+foo.String() not in foo == false
+foo.String() | greet()
+foo.String()[:]
+foo.String()[i:]
+foo; $env?.foo
+foo; $env?.ok
+foo; $env?.str
+foo; 1.0; $env?.ok
+foo; f64
+foo; foo; nil != ok
+foo; foo?.Bar
+foo; i
+foo; list
+foo; str
 foo?.Bar
-foo?.Bar != foo?.Bar
+foo?.Bar != nil == $env
+foo?.Bar != str
+foo?.Bar != type(f64)
+foo?.Bar + str
+foo?.Bar + type(i)
+foo?.Bar < str
+foo?.Bar < string(0)
+foo?.Bar <= str
+foo?.Bar == $env.str
+foo?.Bar == nil and false
+foo?.Bar == str
+foo?.Bar > str
+foo?.Bar > type(false)
+foo?.Bar >= $env.str
+foo?.Bar >= str
+foo?.Bar >= toJSON(foo)
+foo?.Bar contains $env?.Bar
+foo?.Bar contains $env?.[Bar]
+foo?.Bar endsWith $env?.String
+foo?.Bar endsWith first($env)
+foo?.Bar endsWith str
 foo?.Bar in foo
-foo?.Bar matches toJSON(f64)
-foo?.Bar not endsWith foo.Bar
-foo?.Bar not endsWith toJSON(foo)
-foo?.Qux
-foo?.Qux(foo?.Bar)
-foo?.Qux(string(i32))
-foo?.Qux(toJSON(1))
-foo?.Qux(toJSON(i32))
-foo?.Qux(upper("bar"))
+foo?.Bar in {foo: array}
+foo?.Bar in {foo: str}
+foo?.Bar matches str
+foo?.Bar matches toJSON(array)
+foo?.Bar not contains str
+foo?.Bar not endsWith $env?.[String]
+foo?.Bar not endsWith $env?.foobar
+foo?.Bar not endsWith str
+foo?.Bar not in $env
+foo?.Bar not in $env?.[Bar]
+foo?.Bar not in foo
+foo?.Bar not matches $env?.[foobar]
+foo?.Bar not matches $env?.[str]
+foo?.Bar not matches str
+foo?.Bar not startsWith $env.str
+foo?.Bar not startsWith $env?.Bar
+foo?.Bar not startsWith str
+foo?.Bar not startsWith toJSON(nil)
+foo?.Bar not startsWith type(str)
+foo?.Bar startsWith str
+foo?.Bar | greet()
+foo?.Bar | hasSuffix(str)
+foo?.Bar[:]
 foo?.String
+foo?.String != $env?.[Bar]
+foo?.String != $env?.[str]
+foo?.String == $env or $env
+foo?.String == $env?.[String]
 foo?.String()
-foo?.String() contains string("foo")
+foo?.String() != str
+foo?.String() < str
+foo?.String() == str
+foo?.String() > str
+foo?.String() >= toJSON(f64)
+foo?.String() in foo
+foo?.String() matches str
+foo?.String() not contains $env?.[str]
+foo?.String() not endsWith $env?.Bar
+foo?.String() not endsWith $env?.[foobar]
+foo?.String() not in foo
+foo?.String() not startsWith str
+foo?.String() not startsWith type(foo)
+foo?.String() | greet()
+foo?.String() | hasSuffix(str)
+foo?.String()[:]
 fromBase64(string(ok))
-fromBase64(toBase64("bar"))
-fromBase64(type(1 == 0.5))
+fromBase64(toBase64(str))
+fromBase64(toJSON(nil))
+fromBase64(toJSON(ok))
+fromBase64(toJSON(true))
 fromBase64(type(add))
-fromBase64(type(div))
-fromBase64(type(false))
 fromBase64(type(greet))
-fromBase64(type(half))
 fromBase64(type(ok))
-fromBase64(type(score))
-fromBase64(type(true))
+fromJSON(string(0))
 fromJSON(string(1))
-fromJSON(string(f32))
+fromJSON(string(1.0))
 fromJSON(string(f64))
+fromJSON(string(false))
 fromJSON(string(i))
-fromJSON(string(i32))
-fromJSON(string(i64))
 fromJSON(string(ok))
 fromJSON(string(true))
-fromJSON(toJSON("bar"))
-fromJSON(toJSON(0.5))
+fromJSON(toJSON(0))
+fromJSON(toJSON(1))
+fromJSON(toJSON(1.0))
 fromJSON(toJSON(array))
 fromJSON(toJSON(f64))
 fromJSON(toJSON(false))
 fromJSON(toJSON(foo))
-fromJSON(toJSON(i))
-fromJSON(toJSON(i32))
+fromJSON(toJSON(foo)).add
 fromJSON(toJSON(list))
 fromJSON(toJSON(nil))
+fromJSON(toJSON(nil))?.[i].i()
+fromJSON(toJSON(ok))
+fromJSON(toJSON(str))
+fromJSON(toJSON(str)) contains str
 fromJSON(toJSON(true))
-fromPairs(filter(array, false))
-fromPairs(filter(list, false))
-fromPairs(groupBy(array, #).String)
-get(["foo"], i32)
-get(array, -1)
-get(array, -i32)
-get(array, -i64)
-get(array, -score(1))
-get(array, 1 * 1)
-get(array, 1 * i)
-get(array, 1) ** f32
-get(array, 1) < f32
-get(array, 1) > i32
-get(array, 1) > i64
-get(array, bitnot(1))
-get(array, count(array, ok))
-get(array, false ? "foo" : 0.5)
+fromJSON(toJSON(type(ok)))
+fromPairs([list])
+fromPairs(list[:0])
+fromPairs(sort($env))
+fromPairs(toPairs($env))
+fromPairs(toPairs($env)).ok
+get($env, nil) != array
+get($env, nil)?.[add]
+get($env, nil)?.[add].add
+get($env, nil)?.[f64]
+get($env, nil)?.[i]
+get($env, nil)?.[ok]
+get($env, nil)?.add
+get($env, nil)?.f64
+get($env, nil)?.foo
+get($env, nil)?.greet().add
+get($env, str) | reduce($env)
+get($env, str)?.[f64]
+get(array, $env.i)
 get(array, i)
-get(array, i) != f32
-get(array, i) != i32
-get(array, i) * i32
-get(array, i) - i
-get(array, i) / i64
-get(array, i) > f64
-get(array, i) >= f64
-get(array, i) >= i64
-get(array, i) ^ half(0.5)
-get(array, i32 % i32)
-get(array, i32)
-get(array, i32) / f64
-get(array, i32) < i
-get(array, i64 - 1)
-get(array, i64)
-get(array, i64) > f64
-get(array, last(array))
-get(array, min(i))
-get(array, reduce(array, #))
-get(array, reduce(list, i64))
-get(array, score(1))
-get(array, score(abs(1)))
-get(array, score(i))
-get(array, sum(array))
-get(false ? 0.5 : greet, list)
-get(false ? add : array, f64)
-get(false ? add : score, ok)
-get(false ? f64 : 1, ok)
-get(false ? f64 : score, add)
-get(false ? false : f32, i)
-get(false ? i32 : list, i64)
-get(false ? i64 : true, f64)
-get(false ? score : ok, trimSuffix("bar", "bar"))
-get(filter(list, true), i)
-get(groupBy(array, "bar"), i)
-get(groupBy(array, "bar"), ok)
-get(groupBy(array, #), f32)
-get(groupBy(array, #), f64)
-get(groupBy(array, #), foo)
-get(groupBy(array, #), i)
-get(groupBy(array, #), i64 * 0.5)
-get(groupBy(array, #), i64)
-get(groupBy(array, 0.5), ok)
-get(groupBy(array, 1), f32)
-get(groupBy(array, f64), i64)
-get(groupBy(array, false), findIndex(array, ok))
-get(groupBy(array, i), ok)
-get(groupBy(array, true), i32)
-get(groupBy(list, "bar"), i32)
-get(groupBy(list, #), f32 <= f64)
-get(groupBy(list, #), f32)
-get(groupBy(list, #), foo)
-get(groupBy(list, #), i)
-get(groupBy(list, #), i32)
-get(groupBy(list, #), i64)
-get(groupBy(list, #), int(f32))
-get(groupBy(list, #), reduce(array, foo))
-get(groupBy(list, #), score(1))
-get(groupBy(list, 0.5), ok)
-get(groupBy(list, 1), i32)
-get(groupBy(list, foo), i32)
-get(i .. 1, 1 * 1)
-get(i .. i32, i)
-get(i32 .. i, i64)
-get(i64 .. 1, i32)
-get(i64 .. i, i32)
-get(i64 .. i64, i64)
-get(list, -1)
-get(list, -i)
-get(list, -i64)
-get(list, 1 * 1)
-get(list, 1 - 1)
-get(list, 1 - i)
-get(list, 1) != foo
-get(list, 1).Bar
-get(list, 1).Qux
-get(list, 1).String
-get(list, 1).String()
-get(list, 1)?.Bar
-get(list, 1)?.Qux
-get(list, 1)?.String
-get(list, 1)?.String()
-get(list, bitshr(i, i32))
-get(list, first(array))
-get(list, get(array, 1))
-get(list, get(array, i64))
-get(list, i % 1)
+get(if ok { i } else { array }, list)
 get(list, i)
-get(list, i).Bar
-get(list, i).Qux
 get(list, i).String
-get(list, i)?.Bar
-get(list, i)?.Qux
-get(list, i)?.String
-get(list, i)?.String()
-get(list, i32 * i32)
-get(list, i32 - i32)
-get(list, i32)
-get(list, i32).Bar
-get(list, i32).Qux
-get(list, i32).String
-get(list, i32)?.Bar
-get(list, i32)?.Qux
-get(list, i32)?.String
-get(list, i32)?.String()
-get(list, i64 * 1)
-get(list, i64 * i)
-get(list, i64 - 1)
-get(list, i64)
-get(list, i64).Bar
-get(list, i64).Qux
-get(list, i64).String
-get(list, i64)?.Bar
-get(list, i64)?.Qux
-get(list, i64)?.String
-get(list, i64)?.String()
-get(list, int(1))
-get(list, max(i32))
-get(list, min(i32))
-get(list, min(i64))
-get(list, ok ? 0.5 : "foo")
-get(list, reduce(list, i64))
-get(list, score(1))
-get(list, score(i))
-get(list, true ? i : i32)
-get(list[i64:1], i)
-get(map(array, #), i)
-get(map(array, #), i32)
-get(map(array, #), i64)
-get(map(array, add), i32)
-get(map(array, array), i)
-get(map(array, greet), i64)
-get(map(array, half), i64)
-get(map(list, "foo"), i64)
-get(map(list, #), i)
-get(map(list, #), i64)
-get(map(list, 1), i32)
-get(map(list, array), i)
-get(map(list, i32), i64)
-get(map(list, i64), i64)
-get(ok ? 1 : "bar", f32)
-get(ok ? add : f32, array)
-get(ok ? f64 : div, i64)
-get(ok ? false : list, f32 > i)
-get(ok ? half : i32, i)
-get(ok ? half : ok, f64)
-get(ok ? i : 0.5, half)
-get(ok ? i32 : half, f64)
-get(ok ? i64 : foo, f32)
-get(ok ? list : i32, f32)
-get(ok ? ok : div, greet)
-get(ok ? score : f64, i)
-get(ok ? score : i64, foo)
-get(reduce(list, array), i32)
-get(sort(array), i32)
-get(take(list, i), i64)
-get(true ? "bar" : ok, score(i))
-get(true ? 0.5 : i32, array)
-get(true ? f32 : 0.5, ok)
-get(true ? false : foo, i64 > 0.5)
-get(true ? greet : i32, score)
-get(true ? half : f32, greet)
-get(true ? half : list, add)
-get(true ? i64 : greet, i32)
-get(true ? score : true, half)?.half
-get(true ? true : i, f64)
-get({"foo": foo, "bar": false}, type(i))
+get(median(array), true && $env)
 greet
+greet != $env != nil
+greet != $env && $env
+greet != $env == nil
+greet != $env and $env
+greet != $env or sum(array, true)
+greet != $env.greet
+greet != $env?.Bar
+greet != $env?.String
+greet != $env?.String?.add()
+greet != $env?.[Bar]
+greet != $env?.[String]
+greet != $env?.[foobar]
+greet != $env?.[str]
+greet != $env?.greet
+greet != $env?.true
+greet != get($env, str)
 greet != greet
+greet != greet != nil
 greet != greet != ok
-greet != nil ? "bar" : add
-greet != nil ? 0.5 : false
-greet != nil ? list : false
+greet != greet && true
+greet != greet || false
+greet != nil and $env
+greet != {foo: str}.foobar
+greet == $env and false
+greet == $env.greet
+greet == $env?.Bar
+greet == $env?.String
+greet == $env?.[Bar]
+greet == $env?.[String]
+greet == $env?.[foobar]
+greet == $env?.[str]
+greet == $env?.foobar
+greet == $env?.foobar?.String
+greet == $env?.greet
 greet == greet
-greet == greet ? 0.5 : "bar"
-greet == greet and ok
-greet == nil == ok
-greet == nil ? i64 : ok
-greet in groupBy(array, f64).f32
-greet in groupBy(list, #).score
-greet not in sort(array)
-greet("bar" + "bar")
-greet("foo" + "foo")
-greet("foo") startsWith type(f64)
-greet(false ? i64 : "bar")
+greet == greet == ok
+greet == greet ? 1.0 : foo
+greet == min($env)
+greet == nil == true
+greet == nil or $env
+greet == nil || true
+greet in $env?.Bar
+greet in $env?.String
+greet in $env?.[Bar]
+greet in $env?.[Bar] && ok
+greet in $env?.[String]
+greet in $env?.[foobar?.[i]]
+greet in $env?.foobar?.[foo]
+greet in $env?.nil
+greet in $env?.true
+greet in [nil]
+greet in sort($env)
+greet in toPairs($env)
+greet not in $env?.Bar
+greet not in $env?.String
+greet not in $env?.String?.str
+greet not in $env?.[Bar]
+greet not in $env?.[String]
+greet not in $env?.[foobar]
+greet not in last($env)
+greet not in toPairs($env)
+greet not in {foo: foo}.list and ok
+greet($env.greet(str))
+greet($env.str)
+greet($env?.[str])
+greet($env?.greet(str))
+greet($env?.str)
 greet(foo.Bar)
-greet(foo.Qux("foo"))
 greet(foo.String())
 greet(foo?.Bar)
+greet(foo?.Bar) not endsWith str
 greet(foo?.String())
-greet(greet("bar"))
-greet(greet("foo"))
-greet(lower("bar"))
-greet(lower("foo"))
-greet(ok ? "bar" : 1)
-greet(ok ? "bar" : i64)
-greet(ok ? "foo" : 0.5)
-greet(ok ? "foo" : div)
-greet(ok ? "foo" : true)
-greet(reduce(array, "bar"))
-greet(reduce(array, "foo"))
-greet(reduce(list, "foo"))
-greet(repeat("bar", 1))
-greet(repeat(foo?.String(), i32))
-greet(string("bar"))
-greet(string("foo"))
-greet(string(0.5))
+greet(greet($env?.[str]))
+greet(greet(foo.String()))
+greet(greet(str))
+greet(greet(str[:i]))
+greet(greet(type($env)))
+greet(greet(type(true)))
+greet(if false { 1.0 } else { str })
+greet(if ok { str } else { nil })
+greet(join($env | map(str)))
+greet(keys($env)?.[i])
+greet(last(list).Bar)
+greet(list | reduce(#.Bar))
+greet(list | reduce(str))
+greet(list | reduce(str, str))
+greet(list?.[i].Bar)
+greet(lower(greet(str)))
+greet(lower(str))
+greet(ok ? str : 1)
+greet(reduce(array, str))
+greet(reduce(list, str))
+greet(str + str)
+greet(str | greet())
+greet(str | repeat(0))
+greet(str | trim(str))
+greet(str)
+greet(str) != $env && $env
+greet(str) != str
+greet(str) < str
+greet(str) <= str
+greet(str) == nil ? foo : nil
+greet(str) > type(0)
+greet(str) >= str
+greet(str) contains str
+greet(str) contains string(true)
+greet(str) endsWith $env?.[str]
+greet(str) endsWith str
+greet(str) matches str
+greet(str) not contains str
+greet(str) not endsWith string(foo)
+greet(str) not endsWith type(nil)
+greet(str) not in foo
+greet(str) not startsWith $env?.Bar
+greet(str) | greet()
+greet(str)[:]
+greet(str)[:i]
+greet(str)[i:]
+greet(str[0:])
+greet(str[1:0])
+greet(str[1:])
+greet(str[:1])
+greet(str[:])
+greet(str[:i])
+greet(str[i:])
+greet(str[i:i])
+greet(string($env))
+greet(string($env?.Bar))
+greet(string(0))
 greet(string(1))
+greet(string(1.0))
 greet(string(add))
+greet(string(array | sortBy(str)))
 greet(string(array))
-greet(string(div))
-greet(string(f32))
 greet(string(f64))
 greet(string(false))
 greet(string(foo))
 greet(string(greet))
-greet(string(half))
+greet(string(groupBy(list, ok)))
 greet(string(i))
-greet(string(i32))
-greet(string(i64))
+greet(string(last(array)))
 greet(string(list))
 greet(string(nil))
 greet(string(ok))
-greet(string(score))
+greet(string(str))
 greet(string(true))
-greet(toBase64("bar"))
-greet(toBase64(trimPrefix("bar")))
-greet(toJSON("bar"))
-greet(toJSON("foo"))
-greet(toJSON(0.5))
+greet(toBase64(str))
+greet(toJSON(0))
 greet(toJSON(1))
+greet(toJSON(1.0 + 1.0))
+greet(toJSON(1.0))
+greet(toJSON(array | sum(#)))
 greet(toJSON(array))
-greet(toJSON(f32))
 greet(toJSON(f64))
 greet(toJSON(false))
+greet(toJSON(foo) | greet())
 greet(toJSON(foo))
+greet(toJSON(foo?.Bar))
 greet(toJSON(i))
-greet(toJSON(i32))
-greet(toJSON(i64))
 greet(toJSON(list))
 greet(toJSON(nil))
 greet(toJSON(ok))
+greet(toJSON(str))
 greet(toJSON(true))
-greet(trim("bar"))
-greet(trim("foo"))
-greet(trimPrefix("bar"))
-greet(trimPrefix("foo"))
-greet(trimSuffix("bar"))
-greet(trimSuffix("foo"))
+greet(trim(str))
+greet(trimPrefix(str))
 greet(trimSuffix(foo.String()))
-greet(trimSuffix(foo?.Bar))
-greet(true ? "bar" : i64)
-greet(true ? "bar" : ok)
-greet(true ? "foo" : foo)
-greet(type("bar"))
-greet(type("foo"))
-greet(type(0.5))
+greet(trimSuffix(str))
+greet(true ? str : i)
+greet(true ? str : nil)
+greet(type($env))
+greet(type($env.ok))
+greet(type(0))
 greet(type(1))
+greet(type(1.0))
 greet(type(add))
 greet(type(array))
-greet(type(div))
-greet(type(f32))
 greet(type(f64))
 greet(type(false))
 greet(type(foo))
 greet(type(greet))
-greet(type(half))
 greet(type(i))
-greet(type(i32))
-greet(type(i64))
 greet(type(list))
+greet(type(map(array, ok)))
+greet(type(nil == f64))
 greet(type(nil))
 greet(type(ok))
-greet(type(score))
+greet(type(str))
 greet(type(true))
-greet(upper("bar"))
-greet(upper("foo"))
-groupBy(1 .. 1, #).f64
-groupBy(1 .. i, #)
-groupBy(1 .. i, i32)?.score
-groupBy(1 .. i32, #)
-groupBy(1 .. i32, ok)
-groupBy(1 .. i64, i32)
-groupBy([0.5, f64], nil == "foo")
-groupBy([1], # <= #)
-groupBy([f32 ^ i64], #)
-groupBy([f32], f64)
-groupBy([f64], # >= f32)
-groupBy([half], f32)
-groupBy([i32], array[#])
-groupBy([nil], foo)
-groupBy([true], #)
-groupBy(array, !false)
-groupBy(array, !true)
-groupBy(array, "bar" in foo).String
-groupBy(array, "bar").Bar
-groupBy(array, "bar").Qux
-groupBy(array, "bar").String
-groupBy(array, "bar").add
-groupBy(array, "bar").array
-groupBy(array, "bar").div
-groupBy(array, "bar").f32
-groupBy(array, "bar").f64
-groupBy(array, "bar").foo
-groupBy(array, "bar").greet
-groupBy(array, "bar").half
-groupBy(array, "bar").i
-groupBy(array, "bar").i32
-groupBy(array, "bar").i64
-groupBy(array, "bar").list
-groupBy(array, "bar").ok
-groupBy(array, "bar").score
-groupBy(array, "bar")?.Bar
-groupBy(array, "bar")?.Qux
-groupBy(array, "bar")?.String
-groupBy(array, "bar")?.add
-groupBy(array, "bar")?.array
-groupBy(array, "bar")?.div
-groupBy(array, "bar")?.f32
-groupBy(array, "bar")?.f64
-groupBy(array, "bar")?.foo
-groupBy(array, "bar")?.greet
-groupBy(array, "bar")?.half
-groupBy(array, "bar")?.i
-groupBy(array, "bar")?.i64
-groupBy(array, "bar")?.list
-groupBy(array, "bar")?.ok
-groupBy(array, "bar")?.score
-groupBy(array, "bar")[f32 > f32]
-groupBy(array, "foo").Bar
-groupBy(array, "foo").Qux
-groupBy(array, "foo").String
-groupBy(array, "foo").add
-groupBy(array, "foo").array
-groupBy(array, "foo").div
-groupBy(array, "foo").f32
-groupBy(array, "foo").f64
-groupBy(array, "foo").foo
-groupBy(array, "foo").greet
-groupBy(array, "foo").half
-groupBy(array, "foo").i
-groupBy(array, "foo").i32
-groupBy(array, "foo").i64
-groupBy(array, "foo").list
-groupBy(array, "foo").ok
-groupBy(array, "foo").score
-groupBy(array, "foo")?.Bar
-groupBy(array, "foo")?.String
-groupBy(array, "foo")?.add
-groupBy(array, "foo")?.array
-groupBy(array, "foo")?.div
-groupBy(array, "foo")?.f32
-groupBy(array, "foo")?.f64
-groupBy(array, "foo")?.foo
-groupBy(array, "foo")?.greet
-groupBy(array, "foo")?.half
-groupBy(array, "foo")?.i
-groupBy(array, "foo")?.i32
-groupBy(array, "foo")?.i64
-groupBy(array, "foo")?.list
-groupBy(array, "foo")?.ok
-groupBy(array, "foo")?.score
-groupBy(array, # != #)
-groupBy(array, # != #).Qux
-groupBy(array, # != #)?.array
-groupBy(array, # != 0.5)
-groupBy(array, # != 1)
-groupBy(array, # != f32)
-groupBy(array, # != f64)
-groupBy(array, # != f64)?.String
-groupBy(array, # != i64)
-groupBy(array, # != nil)
+greet(upper(str))
+greet; $env?.[Bar]
+greet; add
+greet; array
+greet; f64
+greet; foo
+greet; foo; i
+greet; greet
+greet; i
+greet; ok
+groupBy($env | map(i), ok)
+groupBy($env.array, #)
+groupBy($env.array, 0 * 1.0)
+groupBy($env.array, foo)
+groupBy($env.array, i / #)
+groupBy($env.list, #)
+groupBy($env.list, foo)
+groupBy($env.list, nil != #.String)
+groupBy($env?.[str], #)
+groupBy($env?.[str], 1.0 <= i)
+groupBy($env?.[str], f64)
+groupBy($env?.[str], i)
+groupBy($env?.[str], mean(#))
+groupBy($env?.[str], ok)
+groupBy($env?.[str], ok)?.add
+groupBy($env?.array, #)
+groupBy($env?.array, $env?.i)
+groupBy($env?.array, f64)
+groupBy($env?.array, i)
+groupBy($env?.array, str)
+groupBy($env?.list, $env?.i)
+groupBy($env?.list, 0 == $env)
+groupBy(1 .. 1, ok)
+groupBy([1.0], # / f64)
+groupBy([1.0], foo)
+groupBy([1], #)
+groupBy([false, str], ok)
+groupBy([false], #)
+groupBy([foo], 0 >= i)
+groupBy([foo], i)
+groupBy([i], foo)
+groupBy([list], abs(1.0))
+groupBy([str], str)
+groupBy(array | filter(false), greet)
+groupBy(array | map($env), #.ok)
+groupBy(array, # != 1.0)
 groupBy(array, # % #)
-groupBy(array, # % 1)
-groupBy(array, # % i32)
-groupBy(array, # * #)
-groupBy(array, # * #)?.Qux
-groupBy(array, # * 0.5)
-groupBy(array, # * 1)
 groupBy(array, # * i)
-groupBy(array, # * i32)
-groupBy(array, # * i64)
-groupBy(array, # ** #)
-groupBy(array, # ** #).add
-groupBy(array, # ** 0.5)
-groupBy(array, # ** 0.5)?.foo
-groupBy(array, # ** 0.5)?.greet
-groupBy(array, # ** 1)
-groupBy(array, # ** f64)
-groupBy(array, # ** i)
-groupBy(array, # ** i32)
-groupBy(array, # ** i64)
 groupBy(array, # + #)
-groupBy(array, # + 1)
-groupBy(array, # + f32)
-groupBy(array, # + i)
-groupBy(array, # - #)
-groupBy(array, # - 0.5)
-groupBy(array, # - 1)
-groupBy(array, # - f32)
-groupBy(array, # - f64)
-groupBy(array, # - i)
-groupBy(array, # - i32)
 groupBy(array, # / #)
-groupBy(array, # / 0.5)
-groupBy(array, # / 0.5)?.foo
-groupBy(array, # / 1)
-groupBy(array, # / i)
-groupBy(array, # / i32)
-groupBy(array, # / i64)
-groupBy(array, # < # || 0.5 > f64)
-groupBy(array, # < #)
-groupBy(array, # < 0.5)
-groupBy(array, # < 1)
-groupBy(array, # < i32)
-groupBy(array, # < i64)
-groupBy(array, # <= #)
-groupBy(array, # <= #)?.Bar
-groupBy(array, # <= #)?.Qux
-groupBy(array, # <= 0.5)
-groupBy(array, # <= 1)
-groupBy(array, # <= f32)
-groupBy(array, # <= f64)
-groupBy(array, # <= i)
-groupBy(array, # <= i64)
 groupBy(array, # == #)
-groupBy(array, # == #).String
-groupBy(array, # == #)?.half
-groupBy(array, # == 0.5)
-groupBy(array, # == 1)
-groupBy(array, # == f32)
-groupBy(array, # == f32).half
-groupBy(array, # == f64)
-groupBy(array, # == i)
-groupBy(array, # == i64)
-groupBy(array, # == nil)
 groupBy(array, # > #)
-groupBy(array, # > 0.5)
-groupBy(array, # > 1)
-groupBy(array, # > 1).Bar
-groupBy(array, # > i)?.i64
-groupBy(array, # > i64)
-groupBy(array, # >= #)
-groupBy(array, # >= f64)
-groupBy(array, # >= i)
-groupBy(array, # >= i32)
-groupBy(array, # >= i64)
+groupBy(array, # >= #).String
+groupBy(array, # >= 0)
 groupBy(array, # ^ #)
-groupBy(array, # ^ 0.5)
-groupBy(array, # ^ f32)
-groupBy(array, # ^ i)
-groupBy(array, # ^ i32)
-groupBy(array, # in array)
 groupBy(array, #)
 groupBy(array, #).Bar
-groupBy(array, #).Qux
 groupBy(array, #).String
 groupBy(array, #).add
 groupBy(array, #).array
-groupBy(array, #).div
-groupBy(array, #).f32
 groupBy(array, #).f64
 groupBy(array, #).foo
 groupBy(array, #).greet
-groupBy(array, #).half
 groupBy(array, #).i
-groupBy(array, #).i32
-groupBy(array, #).i64
 groupBy(array, #).list
 groupBy(array, #).ok
-groupBy(array, #).score
+groupBy(array, #).str
 groupBy(array, #)?.Bar
-groupBy(array, #)?.Qux
 groupBy(array, #)?.String
+groupBy(array, #)?.[f64]
+groupBy(array, #)?.[foo]
+groupBy(array, #)?.[i]
+groupBy(array, #)?.[ok]
+groupBy(array, #)?.[str]
 groupBy(array, #)?.add
 groupBy(array, #)?.array
-groupBy(array, #)?.div
-groupBy(array, #)?.f32
 groupBy(array, #)?.f64
 groupBy(array, #)?.foo
+groupBy(array, #)?.foobar
 groupBy(array, #)?.greet
-groupBy(array, #)?.half
 groupBy(array, #)?.i
-groupBy(array, #)?.i32
-groupBy(array, #)?.i64
 groupBy(array, #)?.list
 groupBy(array, #)?.ok
-groupBy(array, #)?.score
-groupBy(array, #)[1 / i]
-groupBy(array, #)[f32]
-groupBy(array, #)[f64]
-groupBy(array, #)[foo]
-groupBy(array, #)[i32]
-groupBy(array, #)[i64]
-groupBy(array, #)[i]
-groupBy(array, #)[ok]
-groupBy(array, #)[reduce(list, #)]
-groupBy(array, -# * # * 0.5)
-groupBy(array, -#)
-groupBy(array, -#).Qux
-groupBy(array, -0.5)
-groupBy(array, -1)
-groupBy(array, -f32)
-groupBy(array, -i)?.score
-groupBy(array, -i32)
-groupBy(array, -i64)
-groupBy(array, 0.5 != #)
-groupBy(array, 0.5 * #)
-groupBy(array, 0.5 * 0.5)
-groupBy(array, 0.5 * f64)
-groupBy(array, 0.5 ** #)
-groupBy(array, 0.5 ** 1)
-groupBy(array, 0.5 ** i64)
-groupBy(array, 0.5 + #)?.score
-groupBy(array, 0.5 + f32)
-groupBy(array, 0.5 - 1)
-groupBy(array, 0.5 / #).array
-groupBy(array, 0.5 / f64)
-groupBy(array, 0.5 / i64)
-groupBy(array, 0.5 < 0.5)
-groupBy(array, 0.5 <= f32)
-groupBy(array, 0.5 == #)
-groupBy(array, 0.5 >= #)
-groupBy(array, 0.5 >= i32)
-groupBy(array, 0.5 >= i64)
-groupBy(array, 0.5 ^ f32)
-groupBy(array, 0.5 ^ i64)
-groupBy(array, 0.5).Bar
-groupBy(array, 0.5).Qux
-groupBy(array, 0.5).String
-groupBy(array, 0.5).add
-groupBy(array, 0.5).array
-groupBy(array, 0.5).div
-groupBy(array, 0.5).f32
-groupBy(array, 0.5).f64
-groupBy(array, 0.5).foo
-groupBy(array, 0.5).greet
-groupBy(array, 0.5).half
-groupBy(array, 0.5).i
-groupBy(array, 0.5).i32
-groupBy(array, 0.5).i64
-groupBy(array, 0.5).list
-groupBy(array, 0.5).ok
-groupBy(array, 0.5).score
-groupBy(array, 0.5)?.Bar
-groupBy(array, 0.5)?.Qux
-groupBy(array, 0.5)?.String
-groupBy(array, 0.5)?.add
-groupBy(array, 0.5)?.array
-groupBy(array, 0.5)?.div
-groupBy(array, 0.5)?.f32
-groupBy(array, 0.5)?.f64
-groupBy(array, 0.5)?.foo
-groupBy(array, 0.5)?.greet
-groupBy(array, 0.5)?.half
-groupBy(array, 0.5)?.i
-groupBy(array, 0.5)?.i32
-groupBy(array, 0.5)?.i64
-groupBy(array, 0.5)?.list
-groupBy(array, 0.5)?.ok
-groupBy(array, 0.5)?.score
-groupBy(array, 1 != #)?.String
-groupBy(array, 1 != 0.5)
-groupBy(array, 1 != f32)
-groupBy(array, 1 % #)
-groupBy(array, 1 % i)
-groupBy(array, 1 * 0.5)
-groupBy(array, 1 * i)
-groupBy(array, 1 + #)
-groupBy(array, 1 + 1)
-groupBy(array, 1 - #)
-groupBy(array, 1 - 1)
-groupBy(array, 1 / #)
-groupBy(array, 1 < #)
-groupBy(array, 1 < i32)?.array
-groupBy(array, 1 < i64)?.ok
-groupBy(array, 1 <= #)
-groupBy(array, 1 == #)
-groupBy(array, 1 == #).add
-groupBy(array, 1 == i32)
-groupBy(array, 1 == nil)
-groupBy(array, 1 > i)
-groupBy(array, 1 >= #)
-groupBy(array, 1 ^ #)
-groupBy(array, 1 not in array)
-groupBy(array, 1).Bar
-groupBy(array, 1).Qux
+groupBy(array, #)?.str
+groupBy(array, $env == foo)
+groupBy(array, $env | sum(1.0))
+groupBy(array, $env.f64)
+groupBy(array, $env.foo)
+groupBy(array, $env.ok)
+groupBy(array, $env.str)
+groupBy(array, $env?.[foobar])
+groupBy(array, $env?.[str])
+groupBy(array, $env?.f64)
+groupBy(array, $env?.i)
+groupBy(array, $env?.str)
+groupBy(array, 0 + #)
+groupBy(array, 0 == 1.0)
+groupBy(array, 0).Bar
+groupBy(array, 0).String
+groupBy(array, 0).add
+groupBy(array, 0).array
+groupBy(array, 0).foo
+groupBy(array, 0).str
+groupBy(array, 0)?.Bar
+groupBy(array, 0)?.String
+groupBy(array, 0)?.[f64]
+groupBy(array, 0)?.[foo]
+groupBy(array, 0)?.[i]
+groupBy(array, 0)?.[str]
+groupBy(array, 0)?.add
+groupBy(array, 0)?.array
+groupBy(array, 0)?.foo
+groupBy(array, 0)?.foobar
+groupBy(array, 0)?.greet
+groupBy(array, 0)?.i
+groupBy(array, 0)?.list
 groupBy(array, 1).String
 groupBy(array, 1).add
 groupBy(array, 1).array
-groupBy(array, 1).div
 groupBy(array, 1).f64
 groupBy(array, 1).foo
 groupBy(array, 1).greet
-groupBy(array, 1).half
 groupBy(array, 1).i
-groupBy(array, 1).i32
-groupBy(array, 1).i64
 groupBy(array, 1).list
-groupBy(array, 1).ok
-groupBy(array, 1).score
 groupBy(array, 1)?.Bar
-groupBy(array, 1)?.Qux
-groupBy(array, 1)?.String
+groupBy(array, 1)?.[i]
+groupBy(array, 1)?.[ok]
+groupBy(array, 1)?.[str]
 groupBy(array, 1)?.add
-groupBy(array, 1)?.array
-groupBy(array, 1)?.div
-groupBy(array, 1)?.f32
 groupBy(array, 1)?.f64
-groupBy(array, 1)?.foo
-groupBy(array, 1)?.greet
-groupBy(array, 1)?.half
-groupBy(array, 1)?.i
-groupBy(array, 1)?.i32
-groupBy(array, 1)?.i64
 groupBy(array, 1)?.list
 groupBy(array, 1)?.ok
-groupBy(array, 1)?.score
+groupBy(array, 1.0 != $env)
+groupBy(array, 1.0 - 1.0)
+groupBy(array, 1.0 < 0)?.ok
+groupBy(array, 1.0 ^ #)
+groupBy(array, 1.0) == $env?.Bar
+groupBy(array, 1.0).Bar
+groupBy(array, 1.0).add
+groupBy(array, 1.0).array
+groupBy(array, 1.0).f64
+groupBy(array, 1.0).foo
+groupBy(array, 1.0).greet
+groupBy(array, 1.0).i
+groupBy(array, 1.0).list
+groupBy(array, 1.0).ok
+groupBy(array, 1.0).str
+groupBy(array, 1.0)?.Bar
+groupBy(array, 1.0)?.String
+groupBy(array, 1.0)?.[f64]
+groupBy(array, 1.0)?.[foo]
+groupBy(array, 1.0)?.[ok]
+groupBy(array, 1.0)?.[str]
+groupBy(array, 1.0)?.add
+groupBy(array, 1.0)?.f64
+groupBy(array, 1.0)?.foo
+groupBy(array, 1.0)?.greet
+groupBy(array, 1.0)?.i
+groupBy(array, 1.0)?.list
+groupBy(array, 1.0)?.ok
+groupBy(array, 1.0)?.str
 groupBy(array, abs(#))
-groupBy(array, abs(0.5))
-groupBy(array, abs(1))
-groupBy(array, abs(f32))
-groupBy(array, abs(f64))
-groupBy(array, abs(i))
-groupBy(array, abs(i64))
-groupBy(array, add(#, #))
-groupBy(array, add(#, 1))?.i64
-groupBy(array, bitnand(1, #))
-groupBy(array, bitnot(#))
-groupBy(array, bitnot(1))
-groupBy(array, bitor(#, #))
-groupBy(array, bitor(1, #))
-groupBy(array, bitor(i32, #))
-groupBy(array, bitshl(1, #))
-groupBy(array, bitshr(i, #))
-groupBy(array, bitushr(#, #))
-groupBy(array, ceil(#))
-groupBy(array, ceil(i))
-groupBy(array, ceil(i32))
-groupBy(array, div(#, #))
-groupBy(array, f32 != #)
-groupBy(array, f32 ** 0.5)
-groupBy(array, f32 - #)
-groupBy(array, f32 - f64)
-groupBy(array, f32 / #)
-groupBy(array, f32 < #)
-groupBy(array, f32 <= #)
-groupBy(array, f32 == #)
-groupBy(array, f32 > 0.5)
-groupBy(array, f32 > i32)
-groupBy(array, f32 ^ i)
-groupBy(array, f32)
-groupBy(array, f32).Bar
-groupBy(array, f32).Qux
-groupBy(array, f32).String
-groupBy(array, f32).add
-groupBy(array, f32).array
-groupBy(array, f32).div
-groupBy(array, f32).f64
-groupBy(array, f32).greet
-groupBy(array, f32).half
-groupBy(array, f32).i
-groupBy(array, f32).i32
-groupBy(array, f32).i64
-groupBy(array, f32).list
-groupBy(array, f32).ok
-groupBy(array, f32).score
-groupBy(array, f32)?.Bar
-groupBy(array, f32)?.Qux
-groupBy(array, f32)?.String
-groupBy(array, f32)?.add
-groupBy(array, f32)?.array
-groupBy(array, f32)?.div
-groupBy(array, f32)?.f32
-groupBy(array, f32)?.f64
-groupBy(array, f32)?.greet
-groupBy(array, f32)?.half
-groupBy(array, f32)?.i32
-groupBy(array, f32)?.i64
-groupBy(array, f32)?.list
-groupBy(array, f32)?.ok
-groupBy(array, f32)?.score
-groupBy(array, f32)[foo]
-groupBy(array, f64 != #)
-groupBy(array, f64 != i64)
-groupBy(array, f64 ** #)
-groupBy(array, f64 - #)
-groupBy(array, f64 - #).i32
+groupBy(array, bitshr(#, 0))
+groupBy(array, f64 - 1)
+groupBy(array, f64 / #)
 groupBy(array, f64 < #)
-groupBy(array, f64 == #)
-groupBy(array, f64 > #)
-groupBy(array, f64 >= #)
-groupBy(array, f64 >= 0.5)
 groupBy(array, f64)
 groupBy(array, f64).Bar
-groupBy(array, f64).Qux
 groupBy(array, f64).String
 groupBy(array, f64).add
 groupBy(array, f64).array
-groupBy(array, f64).div
-groupBy(array, f64).f32
 groupBy(array, f64).f64
-groupBy(array, f64).foo
-groupBy(array, f64).greet
-groupBy(array, f64).half
 groupBy(array, f64).i
-groupBy(array, f64).i32
-groupBy(array, f64).i64
-groupBy(array, f64).list
 groupBy(array, f64).ok
-groupBy(array, f64).score
+groupBy(array, f64).str
 groupBy(array, f64)?.Bar
-groupBy(array, f64)?.Qux
-groupBy(array, f64)?.String
+groupBy(array, f64)?.[i]
+groupBy(array, f64)?.[ok]
+groupBy(array, f64)?.[str]
 groupBy(array, f64)?.add
-groupBy(array, f64)?.array
-groupBy(array, f64)?.div
-groupBy(array, f64)?.f32
-groupBy(array, f64)?.f64
 groupBy(array, f64)?.foo
-groupBy(array, f64)?.greet
-groupBy(array, f64)?.half
-groupBy(array, f64)?.i
-groupBy(array, f64)?.i32
-groupBy(array, f64)?.i64
 groupBy(array, f64)?.list
 groupBy(array, f64)?.ok
-groupBy(array, f64)?.score
-groupBy(array, f64)[i32]
-groupBy(array, false ? # : #)
-groupBy(array, false || ok)
+groupBy(array, f64)?.str
+groupBy(array, false and $env)
+groupBy(array, false or true)
 groupBy(array, false).Bar
-groupBy(array, false).Qux
 groupBy(array, false).String
 groupBy(array, false).add
-groupBy(array, false).array
-groupBy(array, false).div
-groupBy(array, false).f32
 groupBy(array, false).f64
+groupBy(array, false).foo
 groupBy(array, false).greet
-groupBy(array, false).half
-groupBy(array, false).i
-groupBy(array, false).i32
-groupBy(array, false).i64
 groupBy(array, false).list
-groupBy(array, false).ok
-groupBy(array, false).score
+groupBy(array, false).str
 groupBy(array, false)?.Bar
-groupBy(array, false)?.Qux
 groupBy(array, false)?.String
+groupBy(array, false)?.[f64]
+groupBy(array, false)?.[foo]
+groupBy(array, false)?.[i]
+groupBy(array, false)?.[str]
 groupBy(array, false)?.add
-groupBy(array, false)?.array
-groupBy(array, false)?.div
-groupBy(array, false)?.f32
 groupBy(array, false)?.f64
 groupBy(array, false)?.foo
 groupBy(array, false)?.greet
-groupBy(array, false)?.half
-groupBy(array, false)?.i
-groupBy(array, false)?.i32
-groupBy(array, false)?.i64
-groupBy(array, false)?.list
 groupBy(array, false)?.ok
-groupBy(array, false)?.score
-groupBy(array, findLastIndex(list, true))
-groupBy(array, float(#))
-groupBy(array, floor(#))
-groupBy(array, floor(i32))
+groupBy(array, false)?.str
+groupBy(array, foo not in list)
 groupBy(array, foo)
 groupBy(array, foo).Bar
-groupBy(array, foo).Qux
 groupBy(array, foo).String
 groupBy(array, foo).add
 groupBy(array, foo).array
-groupBy(array, foo).div
-groupBy(array, foo).f32
-groupBy(array, foo).f64
 groupBy(array, foo).foo
 groupBy(array, foo).greet
-groupBy(array, foo).half
 groupBy(array, foo).i
-groupBy(array, foo).i32
-groupBy(array, foo).i64
 groupBy(array, foo).list
 groupBy(array, foo).ok
-groupBy(array, foo).score
-groupBy(array, foo)?.Bar
-groupBy(array, foo)?.Qux
+groupBy(array, foo).str
 groupBy(array, foo)?.String
+groupBy(array, foo)?.[f64]
+groupBy(array, foo)?.[foo]
+groupBy(array, foo)?.[i]
+groupBy(array, foo)?.[ok]
 groupBy(array, foo)?.add
 groupBy(array, foo)?.array
-groupBy(array, foo)?.div
-groupBy(array, foo)?.f32
 groupBy(array, foo)?.f64
-groupBy(array, foo)?.foo
 groupBy(array, foo)?.greet
-groupBy(array, foo)?.half
 groupBy(array, foo)?.i
-groupBy(array, foo)?.i32
-groupBy(array, foo)?.i64
 groupBy(array, foo)?.list
 groupBy(array, foo)?.ok
-groupBy(array, foo)?.score
+groupBy(array, foo)?.str
 groupBy(array, foo.Bar)
-groupBy(array, foo?.Bar)
-groupBy(array, get(array, #))
-groupBy(array, get(list, #))
-groupBy(array, get(list, i32))
-groupBy(array, half(1))
-groupBy(array, half(f64))
-groupBy(array, half(f64))?.i64
-groupBy(array, i != #)
-groupBy(array, i % #)
-groupBy(array, i * #)
-groupBy(array, i * #)?.f64
-groupBy(array, i ** #)
-groupBy(array, i + #)
-groupBy(array, i - f64).array
-groupBy(array, i / #)
-groupBy(array, i < #)
-groupBy(array, i <= #)
-groupBy(array, i <= f64)
-groupBy(array, i > i)
-groupBy(array, i ^ #)
-groupBy(array, i ^ 0.5)
+groupBy(array, greet == $env)
+groupBy(array, greet(str))
+groupBy(array, i | bitand(#))?.list
 groupBy(array, i)
-groupBy(array, i).Bar
-groupBy(array, i).Qux
-groupBy(array, i).String
 groupBy(array, i).add
 groupBy(array, i).array
-groupBy(array, i).div
-groupBy(array, i).f32
 groupBy(array, i).f64
 groupBy(array, i).foo
 groupBy(array, i).greet
-groupBy(array, i).half
 groupBy(array, i).i
-groupBy(array, i).i32
-groupBy(array, i).i64
-groupBy(array, i).list
 groupBy(array, i).ok
-groupBy(array, i).score
+groupBy(array, i).str
 groupBy(array, i)?.Bar
-groupBy(array, i)?.String
+groupBy(array, i)?.[f64]
+groupBy(array, i)?.[ok]
+groupBy(array, i)?.[str]
 groupBy(array, i)?.add
 groupBy(array, i)?.array
-groupBy(array, i)?.div
-groupBy(array, i)?.f32
 groupBy(array, i)?.f64
-groupBy(array, i)?.foo
-groupBy(array, i)?.greet
-groupBy(array, i)?.half
-groupBy(array, i)?.i
-groupBy(array, i)?.i32
-groupBy(array, i)?.i64
-groupBy(array, i)?.list
 groupBy(array, i)?.ok
-groupBy(array, i)?.score
-groupBy(array, i)[f64]
-groupBy(array, i)[false ? i32 : ok]
-groupBy(array, i32 * f64)
-groupBy(array, i32 ** # <= i32)
-groupBy(array, i32 ** f64)
-groupBy(array, i32 ** i)
-groupBy(array, i32 ** i64)
-groupBy(array, i32 + #)
-groupBy(array, i32 - 1)?.foo
-groupBy(array, i32 - i64)
-groupBy(array, i32 / #)
-groupBy(array, i32 / f32)
-groupBy(array, i32 < #)
-groupBy(array, i32 < f64)
-groupBy(array, i32 <= 1)
-groupBy(array, i32 == #)
-groupBy(array, i32 == i)
-groupBy(array, i32 > #)
-groupBy(array, i32 >= #).Bar
-groupBy(array, i32 ^ #)
-groupBy(array, i32)
-groupBy(array, i32).Bar
-groupBy(array, i32).Qux
-groupBy(array, i32).String
-groupBy(array, i32).add
-groupBy(array, i32).array
-groupBy(array, i32).div
-groupBy(array, i32).f32
-groupBy(array, i32).f64
-groupBy(array, i32).greet
-groupBy(array, i32).half
-groupBy(array, i32).i
-groupBy(array, i32).i32
-groupBy(array, i32).i64
-groupBy(array, i32).list
-groupBy(array, i32).ok
-groupBy(array, i32).score
-groupBy(array, i32)?.Bar
-groupBy(array, i32)?.Qux
-groupBy(array, i32)?.String
-groupBy(array, i32)?.add
-groupBy(array, i32)?.array
-groupBy(array, i32)?.div
-groupBy(array, i32)?.f32
-groupBy(array, i32)?.f64
-groupBy(array, i32)?.foo
-groupBy(array, i32)?.greet
-groupBy(array, i32)?.half
-groupBy(array, i32)?.i
-groupBy(array, i32)?.i32
-groupBy(array, i32)?.i64
-groupBy(array, i32)?.list
-groupBy(array, i32)?.ok
-groupBy(array, i32)?.score
-groupBy(array, i32)[i]
-groupBy(array, i64 != i)
-groupBy(array, i64 % #)
-groupBy(array, i64 * f32)
-groupBy(array, i64 ** #)
-groupBy(array, i64 ** i)
-groupBy(array, i64 + #)
-groupBy(array, i64 - #)
-groupBy(array, i64 / #)?.Qux
-groupBy(array, i64 / 0.5)
-groupBy(array, i64 < #)
-groupBy(array, i64 <= #).foo
-groupBy(array, i64 >= #)
-groupBy(array, i64 ^ #)
-groupBy(array, i64)
-groupBy(array, i64).Bar
-groupBy(array, i64).Qux
-groupBy(array, i64).String
-groupBy(array, i64).add
-groupBy(array, i64).array
-groupBy(array, i64).div
-groupBy(array, i64).f32
-groupBy(array, i64).f64
-groupBy(array, i64).foo
-groupBy(array, i64).greet
-groupBy(array, i64).half
-groupBy(array, i64).i
-groupBy(array, i64).i32
-groupBy(array, i64).i64
-groupBy(array, i64).list
-groupBy(array, i64).ok
-groupBy(array, i64).score
-groupBy(array, i64)?.Bar
-groupBy(array, i64)?.Qux
-groupBy(array, i64)?.String
-groupBy(array, i64)?.add
-groupBy(array, i64)?.array
-groupBy(array, i64)?.div
-groupBy(array, i64)?.f32
-groupBy(array, i64)?.f64
-groupBy(array, i64)?.foo
-groupBy(array, i64)?.greet
-groupBy(array, i64)?.half
-groupBy(array, i64)?.i
-groupBy(array, i64)?.i32
-groupBy(array, i64)?.i64
-groupBy(array, i64)?.list
-groupBy(array, i64)?.ok
-groupBy(array, i64)?.score
-groupBy(array, int(f64)).i32
-groupBy(array, max(#))
-groupBy(array, max(#, #, #)).ok
-groupBy(array, max(0.5, #))
-groupBy(array, max(1))
-groupBy(array, max(f64))
-groupBy(array, min(#))
-groupBy(array, min(0.5))
-groupBy(array, min(f32))
-groupBy(array, min(i, #, i32))
-groupBy(array, nil != #)
-groupBy(array, nil != f64)
-groupBy(array, nil != foo)
-groupBy(array, nil != half)
-groupBy(array, nil == #)
-groupBy(array, nil == 0.5)
-groupBy(array, none(array, false))
-groupBy(array, none(array, ok))
-groupBy(array, not ok)?.Bar
-groupBy(array, not true)
-groupBy(array, ok == ok)
-groupBy(array, ok ? # : #)
+groupBy(array, i)?.str
+groupBy(array, if true { nil } else { f64 })
+groupBy(array, max(i))
+groupBy(array, mean(1.0))
+groupBy(array, nil == $env)
 groupBy(array, ok)
 groupBy(array, ok).Bar
-groupBy(array, ok).Qux
 groupBy(array, ok).String
 groupBy(array, ok).add
-groupBy(array, ok).array
-groupBy(array, ok).div
-groupBy(array, ok).f32
 groupBy(array, ok).f64
 groupBy(array, ok).foo
 groupBy(array, ok).greet
-groupBy(array, ok).half
-groupBy(array, ok).i
-groupBy(array, ok).i32
-groupBy(array, ok).i64
-groupBy(array, ok).list
-groupBy(array, ok).ok
-groupBy(array, ok).score
-groupBy(array, ok)?.Bar
-groupBy(array, ok)?.Qux
+groupBy(array, ok).str
 groupBy(array, ok)?.String
+groupBy(array, ok)?.[foo]
+groupBy(array, ok)?.[i]
+groupBy(array, ok)?.[ok]
+groupBy(array, ok)?.[str]
 groupBy(array, ok)?.array
-groupBy(array, ok)?.div
-groupBy(array, ok)?.f32
-groupBy(array, ok)?.f64
 groupBy(array, ok)?.foo
-groupBy(array, ok)?.greet
-groupBy(array, ok)?.half
-groupBy(array, ok)?.i32
-groupBy(array, ok)?.i64
 groupBy(array, ok)?.list
 groupBy(array, ok)?.ok
-groupBy(array, ok)?.score
-groupBy(array, one(array, ok))
-groupBy(array, reduce(array, #))
-groupBy(array, reduce(array, foo))
-groupBy(array, reduce(list, #))
-groupBy(array, round(#))
-groupBy(array, score(#))
-groupBy(array, score(#, #))
-groupBy(array, score(#, #, #, 1))
-groupBy(array, score(#, 1)).list
-groupBy(array, score(1))
-groupBy(array, score(i))
-groupBy(array, string(#))
-groupBy(array, string(div))
-groupBy(array, string(i32))
-groupBy(array, toJSON("bar"))
-groupBy(array, toJSON(#))
-groupBy(array, toJSON(1 .. i))
-groupBy(array, toJSON(foo))
-groupBy(array, trimPrefix("foo"))
-groupBy(array, true == nil)
-groupBy(array, true ? # : #)
-groupBy(array, true ? # : 1)
-groupBy(array, true ? nil : "foo")
+groupBy(array, round(i))
+groupBy(array, str)
+groupBy(array, str).Bar
+groupBy(array, str).String
+groupBy(array, str).add
+groupBy(array, str).foo
+groupBy(array, str).list
+groupBy(array, str).str
+groupBy(array, str)?.String
+groupBy(array, str)?.[i]
+groupBy(array, str)?.[ok]
+groupBy(array, str)?.array
+groupBy(array, str)?.f64
+groupBy(array, str)?.i
+groupBy(array, str)?.list
+groupBy(array, str)?.not
+groupBy(array, str)?.ok
+groupBy(array, str)?.str
+groupBy(array, sum(array))
+groupBy(array, toJSON(array))
+groupBy(array, true && true)
 groupBy(array, true).Bar
-groupBy(array, true).Qux
 groupBy(array, true).add
-groupBy(array, true).div
+groupBy(array, true).array
 groupBy(array, true).f64
 groupBy(array, true).foo
-groupBy(array, true).greet
-groupBy(array, true).half
 groupBy(array, true).i
-groupBy(array, true).i32
-groupBy(array, true).i64
 groupBy(array, true).list
-groupBy(array, true).ok
-groupBy(array, true).score
-groupBy(array, true)?.Bar
-groupBy(array, true)?.Qux
-groupBy(array, true)?.String
+groupBy(array, true).str
+groupBy(array, true)?.[f64]
+groupBy(array, true)?.[foo]
+groupBy(array, true)?.[i]
+groupBy(array, true)?.[ok]
+groupBy(array, true)?.[str]
 groupBy(array, true)?.add
-groupBy(array, true)?.array
-groupBy(array, true)?.div
-groupBy(array, true)?.f32
 groupBy(array, true)?.f64
-groupBy(array, true)?.half
 groupBy(array, true)?.i
-groupBy(array, true)?.i32
-groupBy(array, true)?.i64
 groupBy(array, true)?.list
 groupBy(array, true)?.ok
-groupBy(array, true)?.score
-groupBy(array, true)[i32]
-groupBy(array, type(# <= #))
-groupBy(array, type(#)).i64
-groupBy(array, type(-f64))
-groupBy(array, type(f32))
-groupBy(false ? 0.5 : "bar", #)
-groupBy(filter(array, false), #)
-groupBy(filter(array, false), add)
-groupBy(filter(array, false), f32)
-groupBy(filter(array, false), nil == #)
-groupBy(filter(array, ok), half(1))
-groupBy(filter(array, true), #)
-groupBy(filter(array, true), f64)
-groupBy(filter(list, ok), #)
-groupBy(groupBy(array, "foo").list, #)
-groupBy(groupBy(array, #).i32, add)
-groupBy(groupBy(array, ok).Bar, #?.array not matches #)
-groupBy(groupBy(array, true).f64, #[#])
-groupBy(i .. 1, !ok)?.f64
-groupBy(i .. 1, # % #)
-groupBy(i .. i, i64)
-groupBy(i .. i32, #)
-groupBy(i .. i32, f64 * #)
-groupBy(i .. i64, f64)?.score
-groupBy(i .. i64, foo)
-groupBy(i .. len(array), #)
-groupBy(i32 .. 1, # - #)
-groupBy(i32 .. 1, #)?.f32
-groupBy(i32 .. i, #)
-groupBy(i32 .. i32, i)
-groupBy(i32 .. i32, i32)
-groupBy(i32 .. i32, i64)
-groupBy(i32 .. i32, list[i])
-groupBy(i32 .. i32, ok)
-groupBy(i32 .. i64, #)
-groupBy(i32 .. i64, get(array, #))
-groupBy(i64 .. 1, -0.5)
-groupBy(i64 .. 1, i)
-groupBy(i64 .. i, -#)
-groupBy(i64 .. i, i32)
-groupBy(i64 .. i32, i)
-groupBy(i64 .. i64, i32)
-groupBy(list, !("foo" in #))
-groupBy(list, !false)
-groupBy(list, !ok)
-groupBy(list, !true)
-groupBy(list, "bar" contains "foo")?.ok
-groupBy(list, "bar" endsWith "bar")
-groupBy(list, "bar" not in #)
-groupBy(list, "bar").Bar
-groupBy(list, "bar").Qux
-groupBy(list, "bar").String
-groupBy(list, "bar").add
-groupBy(list, "bar").array
-groupBy(list, "bar").div
-groupBy(list, "bar").f32
-groupBy(list, "bar").f64
-groupBy(list, "bar").foo
-groupBy(list, "bar").greet
-groupBy(list, "bar").i
-groupBy(list, "bar").i32
-groupBy(list, "bar").i64
-groupBy(list, "bar").list
-groupBy(list, "bar").ok
-groupBy(list, "bar").score
-groupBy(list, "bar")?.Bar
-groupBy(list, "bar")?.Qux
-groupBy(list, "bar")?.String
-groupBy(list, "bar")?.add
-groupBy(list, "bar")?.array
-groupBy(list, "bar")?.div
-groupBy(list, "bar")?.f32
-groupBy(list, "bar")?.f64
-groupBy(list, "bar")?.foo
-groupBy(list, "bar")?.greet
-groupBy(list, "bar")?.half
-groupBy(list, "bar")?.i
-groupBy(list, "bar")?.i32
-groupBy(list, "bar")?.i64
-groupBy(list, "bar")?.list
-groupBy(list, "bar")?.ok
-groupBy(list, "bar")?.score
-groupBy(list, "foo" not in #)?.foo
-groupBy(list, "foo").Bar
-groupBy(list, "foo").Qux
-groupBy(list, "foo").String
-groupBy(list, "foo").add
-groupBy(list, "foo").array
-groupBy(list, "foo").div
-groupBy(list, "foo").f32
-groupBy(list, "foo").f64
-groupBy(list, "foo").foo
-groupBy(list, "foo").greet
-groupBy(list, "foo").half
-groupBy(list, "foo").i
-groupBy(list, "foo").i32
-groupBy(list, "foo").i64
-groupBy(list, "foo").list
-groupBy(list, "foo").ok
-groupBy(list, "foo").score
-groupBy(list, "foo")?.Bar
-groupBy(list, "foo")?.Qux
-groupBy(list, "foo")?.String
-groupBy(list, "foo")?.add
-groupBy(list, "foo")?.array
-groupBy(list, "foo")?.div
-groupBy(list, "foo")?.f32
-groupBy(list, "foo")?.f64
-groupBy(list, "foo")?.foo
-groupBy(list, "foo")?.greet
-groupBy(list, "foo")?.half
-groupBy(list, "foo")?.i
-groupBy(list, "foo")?.i32
-groupBy(list, "foo")?.i64
-groupBy(list, "foo")?.list
-groupBy(list, "foo")?.ok
-groupBy(list, "foo")?.score
-groupBy(list, # != #)
-groupBy(list, # != foo)
-groupBy(list, # != foo)?.i
-groupBy(list, # != nil)
+groupBy(array, true)?.str
+groupBy(array, type(#))
+groupBy(array, type(i))
+groupBy(filter($env, false), .ok.greet())
+groupBy(flatten(array), #)
+groupBy(flatten(list), #)
+groupBy(groupBy(array, ok).i, #?.[ok][.f64:])
+groupBy(i..i, #)
+groupBy(list | map(#), f64)
+groupBy(list | map(#), ok)
+groupBy(list | map(array), $env?.f64)
 groupBy(list, # == #)
-groupBy(list, # == #).div
-groupBy(list, # in list)
-groupBy(list, # not in list)
 groupBy(list, #)
 groupBy(list, #).Bar
-groupBy(list, #).Qux
 groupBy(list, #).String
 groupBy(list, #).add
 groupBy(list, #).array
-groupBy(list, #).div
-groupBy(list, #).f32
 groupBy(list, #).f64
 groupBy(list, #).foo
 groupBy(list, #).greet
-groupBy(list, #).half
 groupBy(list, #).i
-groupBy(list, #).i32
-groupBy(list, #).i64
 groupBy(list, #).list
 groupBy(list, #).ok
-groupBy(list, #).score
+groupBy(list, #).str
 groupBy(list, #)?.Bar
-groupBy(list, #)?.Qux
 groupBy(list, #)?.String
+groupBy(list, #)?.[f64]
+groupBy(list, #)?.[foo]
+groupBy(list, #)?.[i]
+groupBy(list, #)?.[ok]
+groupBy(list, #)?.[str]
 groupBy(list, #)?.add
 groupBy(list, #)?.array
-groupBy(list, #)?.div
-groupBy(list, #)?.f32
 groupBy(list, #)?.f64
 groupBy(list, #)?.foo
 groupBy(list, #)?.greet
-groupBy(list, #)?.half
 groupBy(list, #)?.i
-groupBy(list, #)?.i32
-groupBy(list, #)?.i64
 groupBy(list, #)?.list
 groupBy(list, #)?.ok
-groupBy(list, #)?.score
-groupBy(list, #)[-i64]
-groupBy(list, #)[1 == i32]
-groupBy(list, #)[f32]
-groupBy(list, #)[foo]
-groupBy(list, #)[i == i64]
-groupBy(list, #)[i32]
-groupBy(list, #)[i64]
-groupBy(list, #)[ok]
+groupBy(list, #)?.str
+groupBy(list, #.Bar)
+groupBy(list, #.Bar).Bar
+groupBy(list, #.Bar).array
+groupBy(list, #.Bar).f64
+groupBy(list, #.Bar).foo
+groupBy(list, #.Bar).ok
+groupBy(list, #.Bar).str
+groupBy(list, #.Bar)?.String
+groupBy(list, #.Bar)?.[f64]
+groupBy(list, #.Bar)?.[ok]
+groupBy(list, #.Bar)?.array
+groupBy(list, #.Bar)?.f64
+groupBy(list, #.Bar)?.foo
+groupBy(list, #.Bar)?.i
 groupBy(list, #?.Bar)
+groupBy(list, #?.Bar)?.[f64]
 groupBy(list, #?.String())
-groupBy(list, #?.String())?.score
-groupBy(list, -0.5)
-groupBy(list, -1)
-groupBy(list, -f32)
-groupBy(list, -i)
+groupBy(list, $env != f64)
+groupBy(list, $env == add)
+groupBy(list, $env == greet)
+groupBy(list, $env.f64)
+groupBy(list, $env.foo)
+groupBy(list, $env.i)
+groupBy(list, $env.str)
+groupBy(list, $env?.[String])
+groupBy(list, $env?.f64)
+groupBy(list, $env?.foo)
+groupBy(list, $env?.foobar)
 groupBy(list, .Bar)
-groupBy(list, .Bar).f32
-groupBy(list, .String())
-groupBy(list, .String())?.score
-groupBy(list, 0.5 != f32)
-groupBy(list, 0.5 != f64)
-groupBy(list, 0.5 * f32)
-groupBy(list, 0.5 ** i64)
-groupBy(list, 0.5 / i)
-groupBy(list, 0.5).Bar
-groupBy(list, 0.5).Qux
-groupBy(list, 0.5).String
-groupBy(list, 0.5).add
-groupBy(list, 0.5).array
-groupBy(list, 0.5).div
-groupBy(list, 0.5).f32
-groupBy(list, 0.5).f64
-groupBy(list, 0.5).greet
-groupBy(list, 0.5).half
-groupBy(list, 0.5).i
-groupBy(list, 0.5).i32
-groupBy(list, 0.5).i64
-groupBy(list, 0.5).list
-groupBy(list, 0.5).ok
-groupBy(list, 0.5).score
-groupBy(list, 0.5)?.Bar
-groupBy(list, 0.5)?.Qux
-groupBy(list, 0.5)?.String
-groupBy(list, 0.5)?.add
-groupBy(list, 0.5)?.array
-groupBy(list, 0.5)?.div
-groupBy(list, 0.5)?.f32
-groupBy(list, 0.5)?.f64
-groupBy(list, 0.5)?.foo
-groupBy(list, 0.5)?.greet
-groupBy(list, 0.5)?.half
-groupBy(list, 0.5)?.i
-groupBy(list, 0.5)?.i32
-groupBy(list, 0.5)?.i64
-groupBy(list, 0.5)?.list
-groupBy(list, 0.5)?.ok
-groupBy(list, 0.5)?.score
-groupBy(list, 1 * f64).f32
-groupBy(list, 1 + i)
-groupBy(list, 1 - 0.5)
-groupBy(list, 1 ^ 0.5)
-groupBy(list, 1 ^ 1)
-groupBy(list, 1 ^ i)
+groupBy(list, .Bar).String
+groupBy(list, .Bar).add
+groupBy(list, .Bar).greet
+groupBy(list, .Bar)?.Bar
+groupBy(list, .Bar)?.[f64]
+groupBy(list, .Bar)?.[foo]
+groupBy(list, .Bar)?.[ok]
+groupBy(list, .Bar)?.f64
+groupBy(list, .Bar)?.greet
+groupBy(list, .Bar)?.i
+groupBy(list, 0 + 1)
+groupBy(list, 0 == 1)
+groupBy(list, 0).String
+groupBy(list, 0).f64
+groupBy(list, 0).foo
+groupBy(list, 0).list
+groupBy(list, 0)?.Bar
+groupBy(list, 0)?.[f64]
+groupBy(list, 0)?.[i]
+groupBy(list, 0)?.[str]
+groupBy(list, 0)?.add
+groupBy(list, 0)?.array
+groupBy(list, 0)?.f64
+groupBy(list, 0)?.foo
+groupBy(list, 0)?.greet
+groupBy(list, 0)?.i
+groupBy(list, 0.1)
+groupBy(list, 1 * i)
 groupBy(list, 1).Bar
-groupBy(list, 1).Qux
 groupBy(list, 1).String
-groupBy(list, 1).add
-groupBy(list, 1).array
-groupBy(list, 1).div
-groupBy(list, 1).f32
 groupBy(list, 1).f64
 groupBy(list, 1).foo
+groupBy(list, 1).foobar
 groupBy(list, 1).greet
-groupBy(list, 1).half
-groupBy(list, 1).i
-groupBy(list, 1).i32
-groupBy(list, 1).i64
-groupBy(list, 1).list
-groupBy(list, 1).ok
-groupBy(list, 1).score
+groupBy(list, 1).str
 groupBy(list, 1)?.Bar
-groupBy(list, 1)?.Qux
 groupBy(list, 1)?.String
+groupBy(list, 1)?.[f64]
+groupBy(list, 1)?.[foo]
+groupBy(list, 1)?.[ok]
+groupBy(list, 1)?.[str]
 groupBy(list, 1)?.add
 groupBy(list, 1)?.array
-groupBy(list, 1)?.div
-groupBy(list, 1)?.f32
 groupBy(list, 1)?.f64
-groupBy(list, 1)?.foo
 groupBy(list, 1)?.greet
-groupBy(list, 1)?.half
-groupBy(list, 1)?.i
-groupBy(list, 1)?.i32
-groupBy(list, 1)?.i64
-groupBy(list, 1)?.list
-groupBy(list, 1)?.ok
-groupBy(list, 1)?.score
-groupBy(list, 1)[i]
-groupBy(list, 1)[reduce(list, "foo")]
-groupBy(list, abs(1))
-groupBy(list, abs(i))
-groupBy(list, abs(i64))
-groupBy(list, all(list, ok))
-groupBy(list, ceil(0.5))
-groupBy(list, ceil(f64))
-groupBy(list, f32 ** 0.5)
-groupBy(list, f32 ** 1)
-groupBy(list, f32 < f32)
-groupBy(list, f32 == i64)
-groupBy(list, f32 >= 1)
-groupBy(list, f32)
-groupBy(list, f32).Bar
-groupBy(list, f32).Qux
-groupBy(list, f32).String
-groupBy(list, f32).add
-groupBy(list, f32).array
-groupBy(list, f32).div
-groupBy(list, f32).f32
-groupBy(list, f32).f64
-groupBy(list, f32).foo
-groupBy(list, f32).half
-groupBy(list, f32).i
-groupBy(list, f32).i32
-groupBy(list, f32).i64
-groupBy(list, f32).list
-groupBy(list, f32).ok
-groupBy(list, f32)?.Bar
-groupBy(list, f32)?.Qux
-groupBy(list, f32)?.String
-groupBy(list, f32)?.add
-groupBy(list, f32)?.array
-groupBy(list, f32)?.div
-groupBy(list, f32)?.f32
-groupBy(list, f32)?.f64
-groupBy(list, f32)?.foo
-groupBy(list, f32)?.greet
-groupBy(list, f32)?.half
-groupBy(list, f32)?.i
-groupBy(list, f32)?.i32
-groupBy(list, f32)?.i64
-groupBy(list, f32)?.list
-groupBy(list, f32)?.ok
-groupBy(list, f32)?.score
-groupBy(list, f32)[add == nil]
-groupBy(list, f32)[toJSON(true)]
-groupBy(list, f64 * 0.5)
-groupBy(list, f64 * 1)
-groupBy(list, f64 - 1)
-groupBy(list, f64 < f64)
+groupBy(list, 1.0 > 1.0)?.[f64]
+groupBy(list, 1.0 ^ 1.0)
+groupBy(list, 1.0) | get(1)
+groupBy(list, 1.0).String
+groupBy(list, 1.0).add
+groupBy(list, 1.0).f64
+groupBy(list, 1.0).foo
+groupBy(list, 1.0).foobar
+groupBy(list, 1.0).greet
+groupBy(list, 1.0).i
+groupBy(list, 1.0).list
+groupBy(list, 1.0).str
+groupBy(list, 1.0)?.Bar
+groupBy(list, 1.0)?.String
+groupBy(list, 1.0)?.[f64]
+groupBy(list, 1.0)?.[foo]
+groupBy(list, 1.0)?.[i]
+groupBy(list, 1.0)?.[ok]
+groupBy(list, 1.0)?.[str]
+groupBy(list, 1.0)?.add
+groupBy(list, 1.0)?.array
+groupBy(list, 1.0)?.f64
+groupBy(list, 1.0)?.foo
+groupBy(list, 1.0)?.greet
+groupBy(list, 1.0)?.i
+groupBy(list, 1.0)?.ok
+groupBy(list, 1.0)?.str
+groupBy(list, add != add)
+groupBy(list, array | sum(1))
 groupBy(list, f64)
-groupBy(list, f64).Bar
-groupBy(list, f64).Qux
 groupBy(list, f64).String
-groupBy(list, f64).add
 groupBy(list, f64).array
-groupBy(list, f64).div
-groupBy(list, f64).f32
 groupBy(list, f64).f64
 groupBy(list, f64).foo
 groupBy(list, f64).greet
-groupBy(list, f64).half
 groupBy(list, f64).i
-groupBy(list, f64).i32
-groupBy(list, f64).i64
-groupBy(list, f64).list
 groupBy(list, f64).ok
-groupBy(list, f64).score
 groupBy(list, f64)?.Bar
-groupBy(list, f64)?.Qux
-groupBy(list, f64)?.String
-groupBy(list, f64)?.add
+groupBy(list, f64)?.[f64]
+groupBy(list, f64)?.[foo]
+groupBy(list, f64)?.[i]
+groupBy(list, f64)?.[ok]
+groupBy(list, f64)?.[str]
 groupBy(list, f64)?.array
-groupBy(list, f64)?.div
-groupBy(list, f64)?.f32
 groupBy(list, f64)?.f64
 groupBy(list, f64)?.foo
-groupBy(list, f64)?.greet
-groupBy(list, f64)?.half
-groupBy(list, f64)?.i
-groupBy(list, f64)?.i32
-groupBy(list, f64)?.i64
-groupBy(list, f64)?.list
 groupBy(list, f64)?.ok
-groupBy(list, f64)?.score
-groupBy(list, false == ok)
-groupBy(list, false ? score : #)
+groupBy(list, f64)?.str
 groupBy(list, false).Bar
+groupBy(list, false).String
 groupBy(list, false).add
-groupBy(list, false).array
-groupBy(list, false).div
-groupBy(list, false).f32
+groupBy(list, false).f64
 groupBy(list, false).foo
-groupBy(list, false).greet
-groupBy(list, false).half
+groupBy(list, false).foobar
 groupBy(list, false).i
-groupBy(list, false).i32
-groupBy(list, false).i64
 groupBy(list, false).list
-groupBy(list, false).ok
-groupBy(list, false)?.Bar
-groupBy(list, false)?.Qux
+groupBy(list, false).str
 groupBy(list, false)?.String
+groupBy(list, false)?.[i]
+groupBy(list, false)?.[ok]
 groupBy(list, false)?.add
-groupBy(list, false)?.div
-groupBy(list, false)?.f32
+groupBy(list, false)?.array
 groupBy(list, false)?.f64
 groupBy(list, false)?.greet
-groupBy(list, false)?.half
-groupBy(list, false)?.i
-groupBy(list, false)?.i32
-groupBy(list, false)?.i64
-groupBy(list, false)?.list
 groupBy(list, false)?.ok
-groupBy(list, false)?.score
-groupBy(list, findLastIndex(array, ok))
-groupBy(list, findLastIndex(list, false))
-groupBy(list, first(array))
-groupBy(list, float(-1))
-groupBy(list, float(0.5))
-groupBy(list, floor(i))
-groupBy(list, floor(i64))
-groupBy(list, foo != #)
+groupBy(list, false)?.str
+groupBy(list, foo != nil)
+groupBy(list, foo == #)
 groupBy(list, foo)
 groupBy(list, foo).Bar
-groupBy(list, foo).Qux
 groupBy(list, foo).String
 groupBy(list, foo).add
 groupBy(list, foo).array
-groupBy(list, foo).div
-groupBy(list, foo).f32
 groupBy(list, foo).f64
 groupBy(list, foo).foo
 groupBy(list, foo).greet
-groupBy(list, foo).half
 groupBy(list, foo).i
-groupBy(list, foo).i32
-groupBy(list, foo).i64
 groupBy(list, foo).list
 groupBy(list, foo).ok
-groupBy(list, foo).score
+groupBy(list, foo).str
 groupBy(list, foo)?.Bar
-groupBy(list, foo)?.Qux
 groupBy(list, foo)?.String
+groupBy(list, foo)?.[f64]
+groupBy(list, foo)?.[foo]
+groupBy(list, foo)?.[ok]
+groupBy(list, foo)?.[str]
 groupBy(list, foo)?.add
 groupBy(list, foo)?.array
-groupBy(list, foo)?.div
-groupBy(list, foo)?.f32
 groupBy(list, foo)?.f64
 groupBy(list, foo)?.foo
-groupBy(list, foo)?.half
+groupBy(list, foo)?.greet
 groupBy(list, foo)?.i
-groupBy(list, foo)?.i32
-groupBy(list, foo)?.i64
 groupBy(list, foo)?.list
 groupBy(list, foo)?.ok
-groupBy(list, foo)?.score
-groupBy(list, foo)[i32]
+groupBy(list, foo)?.str
 groupBy(list, foo.Bar)
-groupBy(list, foo.String())
-groupBy(list, foo?.String())
-groupBy(list, greet != greet)
-groupBy(list, greet("bar"))
-groupBy(list, i * i)
-groupBy(list, i / f64)
-groupBy(list, i <= i)
-groupBy(list, i ^ i)
+groupBy(list, foo?.Bar)
+groupBy(list, greet(.Bar))
+groupBy(list, i + i)
 groupBy(list, i)
-groupBy(list, i).Bar
-groupBy(list, i).Qux
-groupBy(list, i).String
 groupBy(list, i).add
 groupBy(list, i).array
-groupBy(list, i).div
-groupBy(list, i).f32
 groupBy(list, i).f64
 groupBy(list, i).foo
-groupBy(list, i).half
 groupBy(list, i).i
-groupBy(list, i).i32
-groupBy(list, i).i64
 groupBy(list, i).list
 groupBy(list, i).ok
-groupBy(list, i).score
-groupBy(list, i)?.Bar
-groupBy(list, i)?.Qux
-groupBy(list, i)?.String
+groupBy(list, i).str
+groupBy(list, i)?.[ok]
 groupBy(list, i)?.add
 groupBy(list, i)?.array
-groupBy(list, i)?.div
-groupBy(list, i)?.f32
 groupBy(list, i)?.f64
 groupBy(list, i)?.foo
 groupBy(list, i)?.greet
-groupBy(list, i)?.half
-groupBy(list, i)?.i
-groupBy(list, i)?.i32
-groupBy(list, i)?.i64
-groupBy(list, i)?.list
 groupBy(list, i)?.ok
-groupBy(list, i)?.score
-groupBy(list, i32 != f32)?.foo
-groupBy(list, i32 * 0.5)
-groupBy(list, i32 ** 0.5)
-groupBy(list, i32 ** f32)
-groupBy(list, i32 > i)
-groupBy(list, i32 ^ i)
-groupBy(list, i32)
-groupBy(list, i32).Bar
-groupBy(list, i32).Qux
-groupBy(list, i32).add
-groupBy(list, i32).array
-groupBy(list, i32).div
-groupBy(list, i32).f32
-groupBy(list, i32).f64
-groupBy(list, i32).foo
-groupBy(list, i32).greet
-groupBy(list, i32).half
-groupBy(list, i32).i
-groupBy(list, i32).i32
-groupBy(list, i32).i64
-groupBy(list, i32).list
-groupBy(list, i32).ok
-groupBy(list, i32).score
-groupBy(list, i32)?.Bar
-groupBy(list, i32)?.Qux
-groupBy(list, i32)?.String
-groupBy(list, i32)?.add
-groupBy(list, i32)?.array
-groupBy(list, i32)?.div
-groupBy(list, i32)?.f32
-groupBy(list, i32)?.f64
-groupBy(list, i32)?.foo
-groupBy(list, i32)?.greet
-groupBy(list, i32)?.half
-groupBy(list, i32)?.i
-groupBy(list, i32)?.i32
-groupBy(list, i32)?.i64
-groupBy(list, i32)?.list
-groupBy(list, i32)?.ok
-groupBy(list, i32)?.score
-groupBy(list, i64 != i32)
-groupBy(list, i64 != nil)
-groupBy(list, i64 - 0.5)
-groupBy(list, i64 < 1)
-groupBy(list, i64 <= 1)
-groupBy(list, i64 == 1)
-groupBy(list, i64 == nil)
-groupBy(list, i64)
-groupBy(list, i64).Bar
-groupBy(list, i64).Qux
-groupBy(list, i64).String
-groupBy(list, i64).add
-groupBy(list, i64).array
-groupBy(list, i64).div
-groupBy(list, i64).f32
-groupBy(list, i64).f64
-groupBy(list, i64).foo
-groupBy(list, i64).greet
-groupBy(list, i64).half
-groupBy(list, i64).i
-groupBy(list, i64).i32
-groupBy(list, i64).list
-groupBy(list, i64).ok
-groupBy(list, i64).score
-groupBy(list, i64)?.Bar
-groupBy(list, i64)?.Qux
-groupBy(list, i64)?.String
-groupBy(list, i64)?.add
-groupBy(list, i64)?.array
-groupBy(list, i64)?.div
-groupBy(list, i64)?.f32
-groupBy(list, i64)?.f64
-groupBy(list, i64)?.foo
-groupBy(list, i64)?.greet
-groupBy(list, i64)?.half
-groupBy(list, i64)?.i
-groupBy(list, i64)?.i32
-groupBy(list, i64)?.i64
-groupBy(list, i64)?.list
-groupBy(list, i64)?.ok
-groupBy(list, i64)?.score
-groupBy(list, i64)[max(i)]
-groupBy(list, i64)[ok]
-groupBy(list, int(1))
-groupBy(list, list == array)
-groupBy(list, lower("foo"))
-groupBy(list, max(f64))
-groupBy(list, max(i))
-groupBy(list, nil != #)
-groupBy(list, nil != div)
-groupBy(list, nil != true)
-groupBy(list, nil == #)
-groupBy(list, nil == #).i
-groupBy(list, nil in list)
-groupBy(list, not false)
-groupBy(list, not ok)
-groupBy(list, ok != false)
-groupBy(list, ok ? # : true)
+groupBy(list, i)?.str
+groupBy(list, if true { # } else { false })
+groupBy(list, nil != 0)
+groupBy(list, nil == 1.0)
+groupBy(list, none($env, true))
+groupBy(list, ok and ok)
 groupBy(list, ok)
-groupBy(list, ok).Bar
-groupBy(list, ok).Qux
 groupBy(list, ok).String
 groupBy(list, ok).add
-groupBy(list, ok).array
-groupBy(list, ok).div
-groupBy(list, ok).f32
 groupBy(list, ok).f64
 groupBy(list, ok).foo
-groupBy(list, ok).greet
-groupBy(list, ok).half
 groupBy(list, ok).i
-groupBy(list, ok).i32
-groupBy(list, ok).i64
 groupBy(list, ok).list
 groupBy(list, ok).ok
-groupBy(list, ok).score
 groupBy(list, ok)?.Bar
-groupBy(list, ok)?.Qux
-groupBy(list, ok)?.String
+groupBy(list, ok)?.[f64]
+groupBy(list, ok)?.[foo]
+groupBy(list, ok)?.[i]
+groupBy(list, ok)?.[ok]
 groupBy(list, ok)?.add
-groupBy(list, ok)?.array
-groupBy(list, ok)?.div
-groupBy(list, ok)?.f32
-groupBy(list, ok)?.f64
 groupBy(list, ok)?.foo
-groupBy(list, ok)?.greet
-groupBy(list, ok)?.half
-groupBy(list, ok)?.i
-groupBy(list, ok)?.i32
-groupBy(list, ok)?.i64
 groupBy(list, ok)?.list
-groupBy(list, ok)?.ok
-groupBy(list, ok)?.score
-groupBy(list, reduce(array, #))
-groupBy(list, reduce(list, #)).i32
-groupBy(list, reduce(list, f64))
-groupBy(list, reduce(list, i32))
-groupBy(list, reduce(map(list, i64), #))
-groupBy(list, round(0.5))
-groupBy(list, round(1))
-groupBy(list, round(f64))
-groupBy(list, score(1))
-groupBy(list, score(i))
+groupBy(list, ok)?.str
+groupBy(list, str == nil)
+groupBy(list, str)
+groupBy(list, str).add
+groupBy(list, str).array
+groupBy(list, str).foo
+groupBy(list, str).greet
+groupBy(list, str).list
+groupBy(list, str).ok
+groupBy(list, str).str
+groupBy(list, str)?.[f64]
+groupBy(list, str)?.[foo]
+groupBy(list, str)?.[i]
+groupBy(list, str)?.[ok]
+groupBy(list, str)?.add
+groupBy(list, str)?.f64
+groupBy(list, str)?.foo
+groupBy(list, str)?.foobar
+groupBy(list, str)?.greet
+groupBy(list, str)?.i
+groupBy(list, str)?.list
+groupBy(list, str)?.ok
 groupBy(list, string(#))
-groupBy(list, string(add))
-groupBy(list, string(half))
-groupBy(list, string(i32))
-groupBy(list, string(true))
-groupBy(list, toBase64("foo"))
-groupBy(list, toJSON(#))
-groupBy(list, toJSON(1))
-groupBy(list, toJSON(array))
-groupBy(list, toJSON(foo))
-groupBy(list, true && false)
-groupBy(list, true ? # : 1)
-groupBy(list, true ? 1 : #)
-groupBy(list, true).Qux
-groupBy(list, true).String
+groupBy(list, string(add)).str
+groupBy(list, string(false))
+groupBy(list, true).Bar
 groupBy(list, true).add
 groupBy(list, true).array
-groupBy(list, true).div
-groupBy(list, true).f32
 groupBy(list, true).f64
 groupBy(list, true).foo
 groupBy(list, true).greet
-groupBy(list, true).half
 groupBy(list, true).i
-groupBy(list, true).i32
-groupBy(list, true).i64
 groupBy(list, true).list
 groupBy(list, true).ok
-groupBy(list, true).score
 groupBy(list, true)?.Bar
-groupBy(list, true)?.Qux
 groupBy(list, true)?.String
+groupBy(list, true)?.[f64]
+groupBy(list, true)?.[i]
+groupBy(list, true)?.[ok]
+groupBy(list, true)?.[str]
 groupBy(list, true)?.add
-groupBy(list, true)?.array
-groupBy(list, true)?.div
-groupBy(list, true)?.f32
 groupBy(list, true)?.f64
-groupBy(list, true)?.foo
 groupBy(list, true)?.greet
-groupBy(list, true)?.half
-groupBy(list, true)?.i
-groupBy(list, true)?.i32
-groupBy(list, true)?.i64
 groupBy(list, true)?.list
-groupBy(list, true)?.ok
-groupBy(list, true)?.score
-groupBy(list, type("foo"))
-groupBy(list, type(#))
-groupBy(list, type(false))
-groupBy(list[i32:1], i64)
-groupBy(list[i32:i32], foo)
-groupBy(list[i64:1], i32)
-groupBy(list[i:1], f64)
-groupBy(map(array, #), # <= #)
-groupBy(map(array, #), # == #)
-groupBy(map(array, #), # >= #)
-groupBy(map(array, #), #)
-groupBy(map(array, #), 0.5 < 0.5)
-groupBy(map(array, #), foo)
-groupBy(map(array, #), i)
-groupBy(map(array, #), i64)
-groupBy(map(array, #), min(1))
-groupBy(map(array, #), ok)
-groupBy(map(array, 0.5), # != 0.5)
-groupBy(map(array, 0.5), # / #)
-groupBy(map(array, 0.5), #)
-groupBy(map(array, 0.5), f64)
-groupBy(map(array, 1), 0.5 / #)
-groupBy(map(array, 1), f64)
-groupBy(map(array, 1), max(#))
-groupBy(map(array, 1), ok)
-groupBy(map(array, div), div != #)
-groupBy(map(array, f32), # - 0.5)
-groupBy(map(array, f32), min(#))
-groupBy(map(array, f64), #)
-groupBy(map(array, false), f64)
-groupBy(map(array, false), i)
-groupBy(map(array, foo), #).add
-groupBy(map(array, foo), i)
-groupBy(map(array, foo), ok)
-groupBy(map(array, i), #)
-groupBy(map(array, i32), # % i)
-groupBy(map(array, i32), #)
-groupBy(map(array, ok), i64)
-groupBy(map(list, "bar"), #)
-groupBy(map(list, "foo"), #)
-groupBy(map(list, #), "bar" == "bar")
-groupBy(map(list, #), #)
-groupBy(map(list, #), #)?.array
-groupBy(map(list, #), f32)
-groupBy(map(list, #), f64)
-groupBy(map(list, #), i32)
-groupBy(map(list, #), i64)
-groupBy(map(list, #), ok)
-groupBy(map(list, 0.5), # * i64)
-groupBy(map(list, 0.5), # ** #)
-groupBy(map(list, 0.5), #)
-groupBy(map(list, 0.5), i32)
-groupBy(map(list, 1), #)
-groupBy(map(list, 1), get(list, #)).i64
-groupBy(map(list, 1), i64)
-groupBy(map(list, f32), # ** #).array
-groupBy(map(list, f64), #)
-groupBy(map(list, f64), #).half
-groupBy(map(list, f64), f32)
-groupBy(map(list, f64), i)
-groupBy(map(list, i), #)
-groupBy(map(list, i32), # == #)
-groupBy(map(list, i64), #)?.i32
-groupBy(map(list, i64), i)
-groupBy(map(list, list), foo)
-groupBy(map(list, ok), #)
-groupBy(ok ? "foo" : greet, # <= #)
-groupBy(reduce(array, # .. i64), add)
-groupBy(reduce(array, array), foo)
-groupBy(reduce(array, array), i)
-groupBy(reduce(list, array), # / #)
-groupBy(reduce(list, array), true ? true : nil)
-groupBy(sort(array), #)
-groupBy(sort(array), foo)
-groupBy(true ? "foo" : 1, # > 0.5)
-groupBy(true ? "foo" : 1, foo)
-groupBy(true ? "foo" : false, # / #)
-groupBy(true ? "foo" : score, #)
-half
-half != half
-half != half != nil
-half != half and "bar" in foo
-half != nil == false
-half != nil ? "bar" : div
-half != nil ? "bar" : false
-half != nil ? true : div
-half != reduce(list, half)
-half == half
-half == nil && ok
-half == nil ? array : 0.5
-half == nil ? foo : false
-half(-(0.5 + 1))
-half(-(f64 + 1))
-half(-(i64 - 0.5))
-half(-0.5)
-half(-1)
-half(-f64)
-half(0.5 * 0.5)
-half(0.5 * 1)
-half(0.5 * f64)
-half(0.5 * i)
-half(0.5 * i32)
-half(0.5 * i64)
-half(0.5 ** 0.5)
-half(0.5 ** 1)
-half(0.5 ** f32)
-half(0.5 ** f64)
-half(0.5 ** i)
-half(0.5 ** i32)
-half(0.5 ** i64)
-half(0.5 + 0.5)
-half(0.5 + 1 + i64)
-half(0.5 + 1)
-half(0.5 + f32)
-half(0.5 + f64)
-half(0.5 + i)
-half(0.5 + i32)
-half(0.5 + i64)
-half(0.5 - 0.5)
-half(0.5 - 1)
-half(0.5 - f32)
-half(0.5 - f64)
-half(0.5 - i)
-half(0.5 - i32)
-half(0.5 - i64)
-half(0.5 / 0.5)
-half(0.5 / 1)
-half(0.5 / f32)
-half(0.5 / f64)
-half(0.5 / i)
-half(0.5 / i64)
-half(0.5 ^ 0.5)
-half(0.5 ^ 1)
-half(0.5 ^ f32)
-half(0.5 ^ f64)
-half(0.5 ^ i)
-half(0.5 ^ i32)
-half(0.5 ^ i64)
-half(0.5) != -i64
-half(0.5) != 0.5 ^ i
-half(0.5) != i32
-half(0.5) != i64
-half(0.5) * f32
-half(0.5) * i
-half(0.5) * i32
-half(0.5) * i64
-half(0.5) ** f32
-half(0.5) ** i
-half(0.5) ** i32
-half(0.5) ** i64
-half(0.5) ** max(1)
-half(0.5) + 1 / 1
-half(0.5) + f32
-half(0.5) + f64
-half(0.5) + i32
-half(0.5) + i64
-half(0.5) - i64
-half(0.5) / -0.5
-half(0.5) / f64
-half(0.5) / i
-half(0.5) / i64
-half(0.5) < f64
-half(0.5) <= f32 ? f64 : 1
-half(0.5) <= f64
-half(0.5) <= i32
-half(0.5) <= i64 + i32
-half(0.5) <= int(0.5)
-half(0.5) == f32
-half(0.5) == i32 / i
-half(0.5) == i64
-half(0.5) > f32
-half(0.5) > f64
-half(0.5) > i
-half(0.5) > i64
-half(0.5) >= i32
-half(0.5) ^ (1 * i32)
-half(0.5) ^ f32
-half(0.5) ^ f64
-half(0.5) ^ i
-half(0.5) ^ i32
-half(0.5) ^ i64
-half(1 * 0.5)
-half(1 * 1)
-half(1 * f32)
-half(1 * f64)
-half(1 * i)
-half(1 * i32)
-half(1 * i64)
-half(1 ** 0.5)
-half(1 ** 1)
-half(1 ** f32)
-half(1 ** f64)
-half(1 ** i)
-half(1 ** i32)
-half(1 ** i64)
-half(1 + 0.5)
-half(1 + 1)
-half(1 + f32)
-half(1 + f64)
-half(1 + i)
-half(1 + i32)
-half(1 + i64)
-half(1 - 0.5)
-half(1 - 1)
-half(1 - f32)
-half(1 - f64)
-half(1 - i)
-half(1 - i32)
-half(1 - i64)
-half(1 / 0.5)
-half(1 / 1)
-half(1 / f32)
-half(1 / f64)
-half(1 / i)
-half(1 / i32)
-half(1 / i64)
-half(1 ^ 0.5)
-half(1 ^ 1)
-half(1 ^ f32)
-half(1 ^ f64)
-half(1 ^ i)
-half(1 ^ i32)
-half(1 ^ i64)
-half(1) != f32
-half(1) != f64
-half(1) != f64 ** f32
-half(1) != f64 ^ 0.5
-half(1) != i32
-half(1) != i64
-half(1) * i32 * i64
-half(1) ** (i64 * f32)
-half(1) ** f32
-half(1) ** i
-half(1) ** i32
-half(1) ** i64
-half(1) + f32
-half(1) + f32 / 0.5
-half(1) + i
-half(1) + i32
-half(1) + i64 + i32
-half(1) - f32
-half(1) - i < i64
-half(1) - i32
-half(1) - i64
-half(1) / -1
-half(1) / 0.5 / i
-half(1) / i
-half(1) / i32
-half(1) < f64
-half(1) < i
-half(1) < i64
-half(1) <= f32
-half(1) <= i32
-half(1) <= i64
-half(1) == -1
-half(1) == 1 ^ i64
-half(1) == f32
-half(1) == i32
-half(1) > i
-half(1) > i32
-half(1) > i64
-half(1) >= f32
-half(1) >= i
-half(1) >= i32
-half(1) >= i64
-half(1) >= max(1)
-half(1) >= mean(array)
-half(1) ^ f32
-half(1) ^ findIndex(list, true)
-half(1) ^ i64
-half(1) in array
-half(1) not in array
-half(abs(0.5))
-half(abs(f64))
-half(ceil(0.5))
-half(ceil(1))
-half(ceil(f32))
-half(ceil(f64))
-half(ceil(i))
-half(ceil(i32))
-half(ceil(i64))
-half(f32 * 0.5)
-half(f32 * 1)
-half(f32 * f64)
-half(f32 * i)
-half(f32 * i32)
-half(f32 ** 0.5)
-half(f32 ** f32)
-half(f32 ** f64)
-half(f32 ** i64)
-half(f32 + 0.5)
-half(f32 + 1)
-half(f32 + f64)
-half(f32 + i32)
-half(f32 + i64)
-half(f32 - 0.5)
-half(f32 - 1)
-half(f32 - f64)
-half(f32 - i)
-half(f32 - i32)
-half(f32 - i64)
-half(f32 / 0.5)
-half(f32 / 1)
-half(f32 / f32)
-half(f32 / f64)
-half(f32 / i)
-half(f32 / i32)
-half(f32 / i64)
-half(f32 ^ 0.5)
-half(f32 ^ 1)
-half(f32 ^ f32)
-half(f32 ^ f64)
-half(f32 ^ i)
-half(f32 ^ i32)
-half(f32 ^ i64)
-half(f64 * 0.5)
-half(f64 * f32)
-half(f64 * f64)
-half(f64 * i)
-half(f64 * i32)
-half(f64 * i64)
-half(f64 ** 0.5)
-half(f64 ** 1)
-half(f64 ** f32)
-half(f64 ** i)
-half(f64 ** i32)
-half(f64 + 0.5)
-half(f64 + 1)
-half(f64 + f64)
-half(f64 + i)
-half(f64 + i64)
-half(f64 - 0.5)
-half(f64 - 1)
-half(f64 - f32)
-half(f64 - f64)
-half(f64 - i)
-half(f64 - i64)
-half(f64 / 0.5)
-half(f64 / 1)
-half(f64 / f32)
-half(f64 / f64)
-half(f64 / i)
-half(f64 / i32)
-half(f64 ^ 0.5)
-half(f64 ^ 1)
-half(f64 ^ f32)
-half(f64 ^ f64)
-half(f64 ^ i32)
-half(f64)
-half(f64) != f64 != false
-half(f64) != i32
-half(f64) != i64
-half(f64) ** f64
-half(f64) ** i
-half(f64) ** i32
-half(f64) + i32
-half(f64) + i64
-half(f64) - f64
-half(f64) - i32
-half(f64) / f64
-half(f64) / i32
-half(f64) < i
-half(f64) < i32
-half(f64) <= f32
-half(f64) <= i32
-half(f64) == f32
-half(f64) == f64
-half(f64) == i
-half(f64) == i32
-half(f64) == i64
-half(f64) > f32
-half(f64) > f64
-half(f64) > i
-half(f64) > i32
-half(f64) > i64
-half(f64) >= i
-half(f64) >= i64
-half(f64) ^ i
-half(f64) not in array
-half(false ? f64 : 0.5)
-half(false ? i32 : 0.5)
-half(false ? ok : 0.5)
-half(false ? score : 0.5)
-half(false ? true : f64)
-half(float(0.5))
-half(float(1))
-half(float(f32))
-half(float(f64))
-half(float(i))
-half(float(i32))
-half(float(i64))
-half(floor(0.5))
-half(floor(1))
-half(floor(f32))
-half(floor(f64))
-half(floor(i))
-half(floor(i32))
-half(floor(i64))
-half(half(0.5))
-half(half(1))
-half(half(ceil(i)))
-half(half(f64 - 0.5))
-half(half(f64))
-half(i * 0.5)
-half(i * 1)
-half(i * f64)
-half(i ** 0.5)
-half(i ** 1)
-half(i ** f32)
-half(i ** f64)
-half(i ** i)
-half(i ** i32)
-half(i ** i64)
-half(i + 0.5)
-half(i + 1)
-half(i + f32)
-half(i + f64)
-half(i - 1)
-half(i - f32)
-half(i - f64)
-half(i / 0.5)
-half(i / 1)
-half(i / f64)
-half(i / i)
-half(i / i32)
-half(i ^ 0.5)
-half(i ^ 1)
-half(i ^ i)
-half(i ^ i32)
-half(i ^ i64)
-half(i32 * 0.5)
-half(i32 * 1)
-half(i32 * f32)
-half(i32 * f64)
-half(i32 ** 0.5)
-half(i32 ** 1)
-half(i32 ** f64)
-half(i32 ** i)
-half(i32 ** i32)
-half(i32 ** i64)
-half(i32 + 0.5)
-half(i32 + 1)
-half(i32 + f32)
-half(i32 + f64)
-half(i32 - 0.5)
-half(i32 - 1)
-half(i32 - f32)
-half(i32 / 0.5)
-half(i32 / 1)
-half(i32 / f32)
-half(i32 / f64)
-half(i32 / i)
-half(i32 / i32 / f32 / f64)
-half(i32 / i32)
-half(i32 / i64)
-half(i32 ^ 0.5)
-half(i32 ^ 1)
-half(i32 ^ f32)
-half(i32 ^ f64)
-half(i32 ^ i)
-half(i32 ^ i32)
-half(i32 ^ i64 ^ i)
-half(i32 ^ i64)
-half(i64 != i ? true : 0.5)
-half(i64 * 0.5)
-half(i64 * 1)
-half(i64 * f64)
-half(i64 ** 0.5)
-half(i64 ** 1)
-half(i64 ** f64)
-half(i64 ** i)
-half(i64 ** i32)
-half(i64 ** i64)
-half(i64 + 0.5)
-half(i64 + f32)
-half(i64 + f64)
-half(i64 - 0.5)
-half(i64 - 1)
-half(i64 - f32)
-half(i64 - f64)
-half(i64 / 0.5)
-half(i64 / 1)
-half(i64 / f32)
-half(i64 / f64)
-half(i64 / i)
-half(i64 / i32)
-half(i64 ^ 0.5)
-half(i64 ^ 1)
-half(i64 ^ f32)
-half(i64 ^ f64)
-half(i64 ^ i)
-half(i64 ^ i32)
-half(max(0.5))
-half(max(0.5)) ** i
-half(max(f64))
-half(mean(array))
-half(median(array))
-half(min(0.5))
-half(min(0.5, f32))
-half(min(0.5, i32))
-half(min(f64))
-half(min(i, 0.5))
-half(reduce(array, 0.5))
-half(reduce(array, f64))
-half(reduce(list, 0.5))
-half(reduce(list, f64))
-half(round(0.5))
-half(round(1))
-half(round(f32))
-half(round(f64))
-half(round(i))
-half(round(i32))
-half(round(i64))
-half(score(1) ^ i64)
-half(true ? 0.5 : i64)
-half(true ? f64 : nil)
+groupBy(list, true)?.str
+groupBy(list, type(foo))
+groupBy(map($env, 1.0), sum(array))
+groupBy(map(array, list), $env?.[str])
+groupBy(map(list, #index), #)
+groupBy(reverse(array), foo)
+groupBy(reverse(array), i + f64)
+groupBy(reverse(array), ok)
+groupBy(sort($env), # != .array)
+groupBy(sort($env), #.add not contains str)
+groupBy(sort($env), i)
+groupBy(sort($env), max(#))
+groupBy(toPairs($env), 1 <= 1.0)
+groupBy(values($env), foo)
+groupBy(values($env), i)
+hasPrefix(str, str)
+hasSuffix(foo.String(), str)
+hasSuffix(str, greet(str))
+hasSuffix(str, str)
 i
-i != -0.5
-i != -1
-i != -f32
-i != -f64
-i != -i
-i != -i32
-i != 0.5 + 0.5
-i != 0.5 - 1
-i != 0.5 / 1
-i != 0.5 ? 1 : div
-i != 0.5 ? false : i32
-i != 0.5 ^ 0.5
-i != 0.5 ^ 1
-i != 0.5 ^ f32
-i != 1 != nil
+i != $env != $env
+i != $env != true
+i != $env || $env
+i != $env.f64
+i != $env.i
+i != $env?.$env?.list(add, nil)
+i != $env?.Bar
+i != $env?.Bar?.[f64]
+i != $env?.String
+i != $env?.[Bar]
+i != $env?.[Bar]?.[i]
+i != $env?.[String]
+i != $env?.[String]?.[array]
+i != $env?.[str]
+i != $env?.f64
+i != $env?.i
+i != $env?.true
+i != 0 != $env
+i != 0 ^ 0
+i != 0 or true
 i != 1 / 1
-i != 1 ? f64 : score
-i != ceil(1)
-i != ceil(f32)
-i != ceil(i64)
-i != f32
-i != f32 ** i64
-i != f32 + i64
-i != f32 == ok
+i != 1 or ok
+i != 1.0 * 1.0
+i != 1.0 * array?.[i]
+i != 1.0 ** 0
+i != 1.0 + 1.0
+i != 1.0 + i
+i != 1.0 - 1.0
+i != 1.0 == ok
+i != 1.0 || $env
+i != abs(i)
+i != array?.[i]
 i != f64
-i != f64 + i32
-i != f64 == true
-i != f64 ^ f32
-i != f64 ^ i64
-i != float(0.5)
-i != float(i)
-i != half(0.5)
-i != half(f64)
+i != f64 && false
+i != f64 + 1.0
+i != float(1.0)
+i != floor(0)
+i != floor(1)
 i != i
-i != i * 1
-i != i * i32
-i != i - i32
-i != i ? i : false
-i != i32
-i != i32 != nil ? greet : score
-i != i32 * 0.5
-i != i32 * f32
-i != i32 and ok
-i != i64
-i != i64 ** i
-i != i64 ? add : i64
-i != i64 ? f32 : nil
-i != i64 ^ 1
-i != int(1)
-i != min(i64)
+i != i != $env.ok
+i != i * f64
+i != last($env)
+i != max(1.0)
+i != mean(f64)
+i != median(1.0)
+i != min($env)
+i != min(i)
+i != nil != $env
 i != nil != ok
-i != nil ? ok : f64
-i != reduce(array, #)
-i != reduce(array, 0.5)
-i != reduce(list, 1)
-i != round(f64)
-i != score(1)
-i != score(i)
-i != {"foo": score}?.f32
-i % (1 + i32)
-i % (i32 + i32)
-i % (i64 + 1)
-i % -1
-i % -i
-i % -i32
-i % 1 % i32
-i % 1 % i64
-i % 1 * i32
-i % 1 + i64
-i % 1 .. i
-i % 1 / 0.5
-i % 1 / f32
-i % 1 <= i64
-i % 1 >= i
-i % abs(1)
-i % abs(i)
-i % array[1]
-i % array[i64]
+i != sum(array)
+i % $env.i
+i % $env?.i
+i % 1 != 1.0
+i % 1 == i
+i % array?.[i]
 i % i
-i % i / i
-i % i32
-i % i32 != i32
-i % i32 * 1
-i % i32 * f64
-i % i32 / i32
-i % i32 <= f64
-i % i64
-i % i64 != i ? f64 : list
-i % i64 <= i
-i % min(1)
-i % min(i64)
-i % reduce(array, #)
-i % score(i)
-i * (1 + 1)
-i * (f32 + 0.5)
-i * (f32 + 1)
-i * (f64 + i)
-i * (f64 - i32)
-i * -i32
-i * -i64
-i * 0.5 * f64
-i * 0.5 + i
-i * 0.5 / i
-i * 0.5 < i32
-i * 0.5 > i32 * f32
-i * 0.5 ^ 1
-i * 1 % i64
-i * 1 ** 1
-i * 1 < f64
-i * 1 < i32
-i * 1 == i32
-i * bitnand(i64, i64)
-i * bitnot(i64)
-i * ceil(1)
-i * f32
-i * f32 <= f64
-i * f32 ^ 0.5
-i * f32 ^ 1
-i * f32 ^ f32
+i % i < i
+i % i <= 1
+i % i <= 1.0
+i % i == i ^ i
+i % len(str)
+i * $env.f64
+i * $env.i
+i * $env?.f64
+i * $env?.i
+i * - - f64
+i * 0 != f64
+i * 0 != nil
+i * 1 != 0
+i * 1 | bitshl(i)
+i * 1.0 + 1.0
+i * 1.0 + f64
+i * 1.0 - i
+i * 1.0 <= 0
+i * 1.0 == 0
+i * array?.[i]
 i * f64
-i * f64 != i
-i * f64 * f32 > i
-i * f64 * i
-i * f64 ** i32
-i * float(f32)
-i * floor(f32)
-i * floor(i)
-i * floor(i32)
-i * floor(i64)
-i * half(0.5)
-i * half(1)
-i * half(f64)
+i * f64 ^ i
+i * floor(0)
 i * i
+i * i != i
 i * i % i
-i * i * 0.5
-i * i * f32
-i * i ** 0.5
-i * i - f32
-i * i .. i
-i * i == f32
-i * i32
-i * i32 * i
-i * i32 .. i32
-i * i32 / min(1)
-i * i32 == f32
-i * i32 in array
-i * i64
-i * i64 < f64
-i * int(1)
-i * max(1)
-i * max(f64, f32)
-i * max(i)
-i * min(f64, i)
-i * reduce(array, #)
-i * score(1)
-i * score(i)
+i * i ** 1.0
+i * i / 1.0
+i * i <= i
+i * i == 0
+i * int(0)
+i * int(1.0)
+i * mean(array)
+i * mean(i)
+i * median(f64)
+i * median(i)
+i * min(i)
+i * sum($env, 0)
 i * sum(array)
-i ** (0.5 * f64)
-i ** (0.5 + 0.5)
-i ** (0.5 - 1)
-i ** (0.5 - f64)
-i ** (0.5 / i32)
-i ** (f32 + 0.5)
-i ** (f32 + f32)
-i ** (i * 0.5)
-i ** (i * 1)
-i ** (i + f64)
-i ** (i - i32 + i32)
-i ** (i32 - i64)
-i ** (i32 / 1)
-i ** (i64 - 0.5)
-i ** -0.5
-i ** -1
-i ** -f32
-i ** -i32
-i ** -i64
-i ** 0.5 ** f32
-i ** 0.5 ** reduce(array, #)
-i ** 0.5 < bitnot(i64)
-i ** 0.5 < f32
-i ** 0.5 < f64
-i ** 0.5 <= i64
-i ** 0.5 ^ i
-i ** 0.5 ^ i64
-i ** 1 ** 1
-i ** 1 / i
-i ** 1 < -f32
-i ** 1 >= f64
-i ** 1 ^ i
-i ** 1 ^ i32
-i ** abs(0.5)
-i ** array[i64]
-i ** bitnand(i32, 1)
-i ** bitshl(i64, i32)
-i ** ceil(1)
-i ** f32
-i ** f32 * i32
-i ** f32 ** 1
-i ** f32 ^ f64
-i ** f32 ^ i64
+i ** $env.f64
+i ** $env.i
+i ** $env?.f64
+i ** $env?.i
+i ** 0 - abs(i)
+i ** 1 ^ 1.0
+i ** 1.0 + 1.0
+i ** 1.0 - i
+i ** 1.0 / i
+i ** 1.0 == $env
+i ** 1.0 >= f64 <= f64
+i ** 1.0 ^ 1
+i ** 1.0 ^ i
+i ** 1.0 | max(1)
+i ** abs(1.0)
+i ** array?.[i]
 i ** f64
-i ** f64 != i32
-i ** f64 ** f64
-i ** f64 > i64 ? 1 : ok
-i ** f64 >= i
-i ** first(array)
-i ** floor(f64)
-i ** half(1)
-i ** half(f64)
-i ** half(i + f32)
+i ** f64 * 1.0
+i ** f64 == nil
 i ** i
-i ** i != i == ok
-i ** i ^ 0.5
-i ** i32
-i ** i32 == f32
-i ** i32 > i64
-i ** i64
-i ** i64 ** i
-i ** i64 < i
-i ** i64 == i32
-i ** i64 >= i
-i ** i64 ^ i64
-i ** i64 not in array
-i ** len("foo")
-i ** len(array)
+i ** i ** 1.0
+i ** i + f64
+i ** i / 1.0
+i ** i < 1
+i ** i > 0
+i ** i >= i
+i ** int(i)
+i ** len($env)
+i ** max(1)
+i ** mean(1, array)
 i ** min(1)
-i ** min(i32)
-i ** reduce(array, #)
-i ** score(1)
-i ** score(i)
-i + -0.5
-i + -1
-i + -f32
-i + -f64
-i + 0.5 ** 0.5
-i + 0.5 + i
-i + 0.5 / 1
-i + 1 + f32
-i + 1 / f32
-i + 1 > f64
-i + 1 ^ 1
-i + 1 ^ f32
-i + abs(0.5)
-i + array[i64]
-i + array[i]
-i + count(list, true)
-i + f32
-i + f32 ** i
-i + f32 / f64
-i + f32 / i32
-i + f32 < i64
+i ** min(1.0)
+i ** min(1.0, array)
+i ** min(array)
+i ** sum($env, 1.0)
+i + $env != str || true
+i + $env.f64
+i + $env.i
+i + $env?.f64
+i + $env?.i
+i + 0 ** f64
+i + 1 != 1.0
+i + 1 .. i
+i + 1 < 0
+i + 1 in array
+i + 1.0 != nil
+i + 1.0 ** f64
+i + 1.0 <= 1.0
+i + 1.0 == f64
+i + abs(1)
+i + array?.[i]
+i + bitnot(0)
+i + ceil($env.i)
 i + f64
-i + f64 - i32
-i + f64 < i64
-i + f64 == i32
-i + f64 > f64
-i + float(0.5)
-i + float(i32)
-i + get(array, i)
-i + half(1)
-i + half(f64)
+i + f64 ** i
+i + f64 <= i
+i + float(1.0)
 i + i
-i + i * i64
-i + i ^ 1
-i + i32
-i + i32 .. -i64
-i + i32 .. i
-i + i32 <= f32
-i + i32 == i64
-i + i32 > min(i)
-i + i32 >= i32 == nil
-i + i32 in array
-i + i64
-i + i64 - f64
-i + i64 / 0.5
-i + i64 / f64
-i + i64 > f32
-i + int(f32)
-i + len("bar")
-i + reduce(array, #)
-i + reduce(array, f32)
-i + reduce(list, i32)
-i + score(i)
-i - -0.5
-i - -1
-i - -f32
-i - -f64
-i - -i64
-i - 0.5 + i64
-i - 0.5 - 1
-i - 0.5 < f64
-i - 0.5 > i
-i - 0.5 not in array
-i - 1 + i
-i - 1 - i64
-i - 1 .. i64
-i - 1 < i32
-i - 1 <= f64
-i - 1 <= i
-i - 1 > 0.5 - 0.5
-i - 1 ^ 0.5
-i - bitxor(i, i)
-i - ceil(f64)
-i - f32
-i - f32 * f32
-i - f32 - i32
-i - f32 / i
-i - f32 ^ 0.5
+i + i / 0
+i + i > i <= 0
+i + i | add(1)
+i + len($env)
+i + max(array, array)
+i + mean(0)
+i + mean(1.0)
+i + mean(i)
+i + reduce(list, 1.0)
+i - $env and false and ok
+i - $env.f64
+i - $env.i
+i - $env?.f64
+i - $env?.i
+i - 0 ** f64
+i - 0 ** i
+i - 0 | mean(1.0)
+i - 1 ** 1.0 ^ 1
+i - 1 / f64
+i - 1 ^ f64
+i - 1.0 != $env?.String
+i - 1.0 != 1.0
+i - 1.0 ** i
+i - 1.0 + 1
+i - 1.0 - 1.0
+i - 1.0 < f64
+i - 1.0 == $env
+i - 1.0 ^ i
+i - 1.0 not in array
+i - array?.[i]
+i - ceil(1)
+i - ceil(1.0)
 i - f64
-i - f64 + i32
-i - f64 + i32 - f64
-i - f64 / i32
-i - f64 ^ i64
-i - find(array, true)
-i - float(0.5)
-i - floor(1)
-i - half(f64)
+i - f64 != 1
+i - f64 != 1.0
+i - f64 >= f64
+i - f64 >= i
+i - f64 ^ 1.0 == 0
+i - float(f64)
+i - floor(1.0)
+i - floor(f64)
 i - i
-i - i + f32
-i - i32
-i - i32 + 0.5
-i - i32 - f32
-i - i32 - i32
-i - i64
-i - i64 .. i32
-i - i64 / i
-i - i64 <= i32
-i - i64 ^ f32
-i - i64 ^ f64
-i - int(i32)
-i - max(i64)
-i - median(array)
-i - round(i32)
-i - score(1)
-i .. -i
-i .. -i32
-i .. -i64
-i .. abs(1)
+i - i != i
+i - i ** i
+i - i == 1.0
+i - i >= i
+i - i not in $env?.String
+i - int(0)
+i - len(array)
+i - max(1.0)
+i - max(array)
+i - mean(1.0)
+i - reduce($env, #acc, i)
+i - reduce(array, #index)
+i .. $env.i
+i .. $env?.i
+i .. 0 * i
+i .. 0 == list
+i .. 0 | all($env[.Bar:])
+i .. 0 | count($env)
+i .. 0 | groupBy(greet)
+i .. 0 | map(#)
+i .. 0 | median(f64)
+i .. 0 | sum(1)
+i .. 0 | sum(foo)
+i .. 0 | sum(str)
+i .. 1 | groupBy(#)
+i .. 1 | map(#)
+i .. 1 | sortBy(1)
+i .. 1 | sortBy(foo.Bar)
+i .. abs(i)
+i .. array?.[i]
 i .. i
-i .. i32
-i .. i64
-i .. i64 * 1
-i .. i64 + 1
-i .. int(0.5)
-i .. max(1)
-i .. max(i)
-i .. min(i)
-i .. reduce(list, i64)
-i .. score(1)
-i .. score(i)
-i / (0.5 + 1)
-i / (0.5 + f64)
-i / (0.5 + i)
-i / (0.5 - f32)
-i / (i + f32)
-i / -1
-i / -f32
-i / -f64
-i / -i32
-i / 0.5 * 1
-i / 0.5 * f64
-i / 0.5 / f64
-i / 0.5 == nil != false
-i / 0.5 >= f32
-i / 0.5 ^ i32
-i / 1 ** i32
-i / 1 <= i64
-i / 1 > i
-i / abs(i)
-i / bitnot(i64)
+i .. i % 1
+i .. i | groupBy(#)
+i .. i | reduce(#)
+i .. i | reduce(false)
+i .. int(0)
+i .. len(array)
+i .. max(0)
+i .. median(i)
+i .. min(1)
+i / $env.f64
+i / $env.i
+i / $env?.f64
+i / $env?.i
+i / 0 + f64 == i
+i / 0 - f64
+i / 0 < 1
+i / 0 == 1.0
+i / 1 * i
+i / 1 ** f64
+i / 1.0 != 1
+i / 1.0 != 1.0
+i / 1.0 * ceil(1.0)
+i / 1.0 + f64
+i / 1.0 - 0
+i / 1.0 - f64
+i / 1.0 < 0
+i / 1.0 < i
+i / 1.0 > 1.0
+i / 1.0 in array
+i / array?.[i]
+i / bitnot(0)
 i / count(array, false)
-i / f32
-i / f32 != i64 ? 1 : list
-i / f32 >= len(array)
 i / f64
-i / f64 * f64
-i / f64 ^ i32
-i / float(0.5)
-i / float(1)
-i / float(f64)
-i / floor(1)
-i / floor(i32)
+i / f64 < 1.0
+i / floor(1.0)
 i / i
-i / i ** 1
-i / i / i
-i / i < i32
-i / i ^ 1
-i / i32
-i / i32 / 1
-i / i64
-i / i64 * f32
-i / i64 / f64
-i / max(0.5)
-i / mean(array)
-i / min(f32)
-i / min(i64)
-i / score(1)
-i < -(f32 * 1)
-i < --f64
-i < -i32
-i < -i64
-i < 0.5 != nil
-i < 0.5 + f64
-i < 0.5 == ok
-i < 1 / 0.5
-i < 1 == nil
-i < 1 ? array : score
-i < 1 ^ i64
-i < abs(i32)
-i < f32
-i < f32 && ok
-i < f32 * 0.5
-i < f32 * i64
-i < f32 ** i
-i < f32 ** i32
-i < f32 + 1
-i < f32 + array[i64]
-i < f32 / 0.5
-i < f32 ? "bar" : div
-i < f32 || ok
+i / i + 1.0
+i / i < 0
+i / i <= 0
+i / i == 1.0
+i / i == i
+i / i in array
+i / len($env)
+i / mean(1.0, 1.0)
+i / sum(array)
+i / sum(list, f64)
+i < $env && false
+i < $env || true
+i < $env.f64
+i < $env.i
+i < $env?.f64
+i < $env?.i
+i < 0 && false
+i < 0 / i
+i < 0 < i
+i < 0 <= f64
+i < 0 > 0
+i < 0 || $env
+i < 1 ** i
+i < 1 + 1.0
+i < 1 / 1.0
+i < 1 < f64
+i < 1 <= $env?.[foo]
+i < 1 <= 1
+i < 1 <= sum($env, #)
+i < 1 ? array : add
+i < 1 || $env
+i < 1.0 != ok
+i < 1.0 ** 0
+i < 1.0 < $env?.f64
+i < 1.0 < 1.0
+i < 1.0 <= 1
+i < 1.0 <= 1.0
+i < 1.0 <= f64
+i < 1.0 == true
+i < 1.0 || ok
+i < abs(1.0)
+i < array?.[i]
+i < bitnot(i)
+i < ceil(f64)
 i < f64
-i < f64 - 1
-i < float(f64)
-i < floor(f32)
-i < half(0.5)
-i < half(1)
-i < half(f64)
+i < f64 != ok
+i < f64 ** ceil(1.0)
+i < f64 < 0
+i < f64 < f64 < i
+i < f64 >= $env
+i < f64 ? 1 : foo
+i < findIndex($env, ok)
+i < first(array)
+i < float(i)
+i < floor(0)
 i < i
-i < i != true
-i < i ** 1
-i < i / i64
-i < i ? score : list
-i < i32
-i < i32 * f32
-i < i32 + 1
-i < i64
-i < i64 ^ f32
-i < max(0.5)
-i < reduce(array, #)
-i <= -0.5
-i <= -1
-i <= -f64
-i <= -i
-i <= -i32
-i <= -i64
-i <= 0.5 * f32
-i <= 0.5 + 0.5
-i <= 0.5 / 1
-i <= 0.5 / f64
-i <= 0.5 == ok
-i <= 0.5 ? i : ok
-i <= 0.5 ? nil : i32
-i <= 0.5 ^ f32
-i <= 1 != nil
-i <= 1 && ok
-i <= 1 * 0.5
-i <= 1 ** i
-i <= 1 + f64
-i <= 1 - f32
-i <= 1 ? 0.5 : f32
-i <= 1 ? 0.5 : list
-i <= 1 ? list : div
-i <= 1 ^ f32
-i <= abs(0.5)
-i <= ceil(1)
-i <= f32
-i <= f32 - 0.5
-i <= f32 ? array : nil
+i < i + i
+i < i ^ 0
+i < int(0)
+i < max(f64)
+i < min(1.0)
+i < round(1.0)
+i < sum(array)
+i <= $env.f64
+i <= $env.i
+i <= $env?.f64
+i <= $env?.i
+i <= 0 && $env
+i <= 0 * i
+i <= 0 < $env
+i <= 0 and $env
+i <= 0 or false
+i <= 1 / 1
+i <= 1 >= 1
+i <= 1 || ok
+i <= 1.0 && ok
+i <= 1.0 * i
+i <= 1.0 < 0
+i <= 1.0 <= 1
+i <= 1.0 or ok
+i <= 1.0 || $env.ok
+i <= bitnot(1)
+i <= ceil(1.0)
 i <= f64
-i <= float(0.5)
-i <= float(f32)
-i <= half(1)
-i <= half(f64)
+i <= f64 < 1.0
+i <= f64 > $env
+i <= f64 in $env?.String
+i <= floor(1)
 i <= i
-i <= i != nil
-i <= i * f32
-i <= i ** f64
-i <= i - 0.5
-i <= i - 1
-i <= i / i
-i <= i ^ 1
-i <= i32
-i <= i32 - f64
-i <= i32 - i
-i <= i32 == ok
-i <= i32 ? array : false
-i <= i32 ? greet : foo
-i <= i32 || false ? f32 : i32
-i <= i64
-i <= i64 * i
-i <= i64 + f64
-i <= len(list)
-i <= max(0.5)
-i <= max(f32, i32)
-i <= round(f32)
-i <= round(i32)
-i <= score(1)
-i == -f32
-i == -f64
-i == -i
-i == -i32
-i == -i64
-i == 0.5 ** f64
-i == 0.5 == ok
-i == 0.5 ? "foo" : f64
-i == 1 * 0.5
-i == 1 ** i64
-i == 1 / 0.5
-i == 1 / f32
-i == 1 ? f32 : 1
-i == 1 ? f64 : f64
-i == 1 ? greet : score
-i == abs(i64)
-i == bitnot(1)
-i == f32
-i == f32 + i
-i == f32 == nil
-i == f32 ? foo : foo
-i == f32 ^ i32
+i <= i + i
+i <= i / 1
+i <= i <= 1
+i <= i == nil
+i <= i >= i
+i <= i ?: add
+i <= i ^ i
+i <= mean(1.0)
+i <= median(1.0)
+i == $env != $env
+i == $env != ok
+i == $env ?: 1.0
+i == $env || false
+i == $env.f64
+i == $env.i
+i == $env?.Bar
+i == $env?.String
+i == $env?.String?.[f64]?.foo
+i == $env?.[Bar]
+i == $env?.[String]
+i == $env?.[foobar]
+i == $env?.[str]
+i == $env?.f64
+i == $env?.foobar
+i == $env?.i
+i == 0 != ok
+i == 0 ** i
+i == 0 - 1.0
+i == 0 - f64 && false
+i == 0 ?: $env
+i == 0 or $env
+i == 0 or ok
+i == 0 || $env
+i == 1 != false
+i == 1 ** 1.0
+i == 1 - 1.0
+i == 1 / f64
+i == 1 == false
+i == 1 and true
+i == 1.0 != ok ?: foo
+i == 1.0 ** 1.0
+i == 1.0 + 1.0
+i == 1.0 - 1
+i == 1.0 == true
+i == 1.0 ^ 1.0
+i == 1.0 || max($env)
+i == abs(i)
+i == array?.[i]
+i == ceil(1.0)
 i == f64
-i == f64 + i32
-i == f64 - i
-i == f64 ? i64 : div
-i == f64 ? score : foo
-i == f64 and ok
-i == findIndex(list, true)
-i == float(0.5)
-i == floor(f32)
-i == floor(i32)
-i == half(0.5)
-i == half(f64)
+i == f64 != $env
+i == f64 && $env
+i == f64 * 0
+i == f64 * f64
+i == f64 / f64
+i == f64 ? f64 : foo
+i == f64 ?: array
+i == float(1.0)
 i == i
-i == i + 0.5
-i == i - i32
-i == i == true
-i == i ? add : i32
-i == i ? i32 : add
-i == i and ok
-i == i32
-i == i32 * 0.5
-i == i32 ** 0.5
-i == i32 + 0.5
-i == i32 + i64
-i == i32 ^ f32
-i == i64
-i == i64 * 0.5
-i == i64 * f32
-i == i64 ** 0.5
-i == i64 == nil
-i == i64 == ok
-i == i64 ? list : div
-i == len("bar")
-i == nil ? 0.5 : div
-i == nil ? div : i32
-i == nil and add != nil
-i == reduce(array, #)
-i == reduce(array, 0.5)
-i == score(1)
-i == score(i)
-i > -f32
-i > -f64
-i > -i
-i > -i32
-i > 0.5 - 0.5
-i > 0.5 ^ i64
-i > 0.5 or ok
-i > 0.5 || ok
-i > 1 != ok
-i > 1 % i64
-i > 1 ** i32
-i > 1 == ok
-i > 1 ? greet : nil
-i > 1 ? score : 0.5
-i > 1 ? true : greet
-i > bitnot(1)
-i > bitor(1, i32)
-i > count(array, true)
-i > f32
-i > f32 ** i32
-i > f32 - f64
-i > f32 ^ 1
+i == i == $env
+i == i ^ 0
+i == int(i)
+i == max(array)
+i == max(i)
+i == median(f64)
+i == min($env)
+i == min(f64)
+i == nil == $env
+i == nil ? $env?.[i] : list
+i == nil ?: foo
+i == sum(array)
+i > $env.f64
+i > $env.i
+i > $env?.f64
+i > $env?.i
+i > 0 + 1
+i > 0 + i
+i > 0 / f64
+i > 0 <= 1.0
+i > 0 == nil
+i > 0 ?: ok
+i > 0.0
+i > 1 && ok
+i > 1 - 0
+i > 1 - 1.0
+i > 1 < 1.0
+i > 1 or ok
+i > 1.0 ** f64
+i > 1.0 / 1
+i > 1.0 == $env
+i > 1.0 > $env
+i > 1.0 > 1.0
+i > 1.0 >= 1.0
+i > 1.0 or $env
+i > array?.[i]
+i > ceil(1.0)
 i > f64
+i > f64 != nil
 i > f64 != ok
-i > f64 * 1
-i > f64 * f32
-i > f64 ** i32
-i > f64 ? foo : array
-i > f64 ? greet : "bar"
-i > first(array)
-i > floor(f64)
+i > f64 && $env
+i > f64 ** i
+i > f64 + 1
+i > f64 >= 1
+i > f64 >= 1.0
+i > find(array, ok)
+i > floor(1.0)
 i > i
-i > i % i32
-i > i ** i
-i > i + i
-i > i ? f32 : i32
-i > i32
-i > i32 * 1
-i > i32 * i32
-i > i32 + 1
-i > i32 == ok
-i > i64
-i > i64 && f32 < 0.5
-i > i64 + 0.5
-i > i64 - 0.5
-i > i64 - i
-i > int(f32)
-i > len("bar")
-i > reduce(list, i32)
-i >= -0.5
-i >= -1
-i >= -f32
-i >= -i
-i >= -i32
-i >= -i64
-i >= 0.5 / 1
-i >= 0.5 ? i64 : array
-i >= 0.5 ? nil : ok
-i >= 0.5 ^ i
-i >= 1 * i64
-i >= 1 + f32
-i >= 1 == nil
-i >= 1 ? f32 : nil
-i >= 1 ? ok : false
-i >= 1 ^ f64
-i >= bitnot(i)
-i >= f32
-i >= f32 ? f32 : i
-i >= f32 ? true : list
+i > i ** f64
+i > i + 0
+i > i and $env
+i > last(array)
+i > len($env)
+i > max(1.0)
+i > mean(1.0)
+i > median(f64)
+i > sum(array)
+i >= $env or true
+i >= $env.f64
+i >= $env.i
+i >= $env?.f64
+i >= $env?.i
+i >= 0 / max(1.0)
+i >= 0 <= i
+i >= 0 >= 1
+i >= 0 ^ 1
+i >= 0 or $env
+i >= 0 || $env
+i >= 0.0
+i >= 1 && ok
+i >= 1 ** f64
+i >= 1 - 1.0
+i >= 1 < f64
+i >= 1 > 1.0
+i >= 1 and $env
+i >= 1 and $env?.[str]
+i >= 1.0 && true
+i >= 1.0 * 0
+i >= 1.0 ** i
+i >= 1.0 + 1.0
+i >= 1.0 ^ i
+i >= 1.0 and $env
+i >= 1.0 or $env
+i >= array?.[i]
+i >= ceil(0)
 i >= f64
-i >= f64 * 0.5
-i >= f64 - 1
-i >= first(array)
-i >= float(0.5)
+i >= f64 * 0
+i >= f64 ** f64
+i >= f64 ** i
+i >= f64 + 1
+i >= f64 < i
+i >= f64 > 1.0
+i >= f64 || $env
 i >= float(1)
-i >= get(array, i64)
-i >= half(f64)
+i >= floor(i)
 i >= i
-i >= i * 1
-i >= i ** f32
-i >= i ? foo : div
-i >= i32
-i >= i32 ** i64
-i >= i32 ? f32 : div
-i >= i32 ^ 1
-i >= i64
-i >= int(0.5)
-i >= min(0.5)
-i >= reduce(array, f64)
-i >= reduce(array, i)
-i >= reduce(list, 1)
-i >= round(1)
-i >= score(1)
-i >= score(i)
-i ^ (1 % i)
-i ^ (1 * f64)
-i ^ (1 - 0.5)
-i ^ (f32 - f64)
-i ^ (f64 - 1)
-i ^ (i + 0.5)
-i ^ (i + i64)
-i ^ (i - f32)
-i ^ (i32 * i32)
-i ^ (i32 + 1)
-i ^ (i32 / f32)
-i ^ (i32 / i)
-i ^ (i64 * 1)
-i ^ -1
-i ^ -f32
-i ^ -f64
-i ^ -i
-i ^ 0.5 ** 0.5
-i ^ 0.5 + i32
-i ^ 0.5 < f64
-i ^ 0.5 < i
-i ^ 0.5 <= i64
-i ^ 0.5 > f64
-i ^ 0.5 >= f32
-i ^ 0.5 >= reduce(array, #)
-i ^ 0.5 ^ f32
-i ^ 0.5 ^ i64
-i ^ 1 * f64
-i ^ 1 / i
-i ^ 1 >= f32
-i ^ 1 ^ i
-i ^ 1 not in array
-i ^ bitnot(i64 + 1)
-i ^ bitnot(min(i))
-i ^ ceil(0.5)
-i ^ f32
-i ^ f32 ** 1
-i ^ f32 < i
-i ^ f32 <= -f32
+i >= i ** 0
+i >= i - i
+i >= i / 1.0
+i >= int(1.0)
+i >= min(1.0)
+i >= reduce($env, 0, 0)
+i >= round(i)
+i ^ $env.f64
+i ^ $env.i
+i ^ $env?.f64
+i ^ $env?.i
+i ^ 0 != 1.0
+i ^ 0 < i
+i ^ 0 not in array
+i ^ 1 == 0
+i ^ 1.0 != i
+i ^ 1.0 != nil
+i ^ 1.0 - 0
+i ^ 1.0 < 1
+i ^ 1.0 <= 0
+i ^ 1.0 == 0
+i ^ 1.0 > 1.0
+i ^ 1.0 > f64
+i ^ 1.0 > i
+i ^ 1.0 > max(0)
+i ^ 1.0 | max(0)
+i ^ abs(0)
+i ^ array?.[i]
+i ^ ceil(1)
+i ^ count($env, false)
 i ^ f64
-i ^ f64 ** 0.5
-i ^ f64 - f64
-i ^ f64 / i32
-i ^ f64 <= f32
-i ^ f64 == i
-i ^ f64 > f32
-i ^ find(array, ok)
-i ^ floor(i32)
-i ^ half(0.5)
-i ^ half(1)
-i ^ half(f64)
+i ^ f64 * 0
+i ^ f64 ** f64
+i ^ f64 >= 1
+i ^ f64 ^ 1.0
+i ^ first(array)
+i ^ float(1.0)
+i ^ floor(1.0)
 i ^ i
 i ^ i * i
-i ^ i * i64
-i ^ i ** i
-i ^ i / i
-i ^ i32
-i ^ i32 / f64
-i ^ i32 in array
-i ^ i64
-i ^ i64 != f32 + 1
-i ^ i64 ** f32
-i ^ last(array)
-i ^ median(array)
-i ^ min(i32, 1)
-i ^ reduce(array, #)
-i ^ round(i32)
-i ^ score(1)
-i in 1 .. i
+i ^ i / f64
+i ^ i == nil
+i ^ i >= i
+i ^ i not in array
+i ^ int(1)
+i ^ int(1.0)
+i ^ len($env)
+i ^ max(array)
+i ^ mean(1.0)
+i ^ mean(array)
+i ^ mean(f64)
+i ^ min(1.0)
+i ^ min(i)
+i ^ sum(array)
+i in $env and false
+i in $env.array
+i in $env?.Bar
+i in $env?.String
+i in $env?.[Bar]
+i in $env?.[String]
+i in $env?.array
 i in array
-i in array != nil
-i in array ? nil : 1
-i in groupBy(list, #)
-i in groupBy(list, foo)
-i in map(array, #)
-i in map(array, i64)
-i not in 1 .. 1
+i in array and $env
+i in array or ok
+i in concat(array)
+i in concat(list, list)
+i in flatten(list)
+i in groupBy(list, #)?.i
+i in last($env)
+i in {foo: 1.0}.greet
+i not in $env.array
+i not in $env?.Bar
+i not in $env?.String
+i not in $env?.[Bar]
+i not in $env?.[Bar]?.array
+i not in $env?.[String]
+i not in $env?.[String]?.[list]
+i not in $env?.array
+i not in 1 .. i
+i not in [1.0]
+i not in [1]
+i not in [true, nil]
 i not in array
-i not in groupBy(array, #)
-i not in groupBy(list, #)
-i not in i64 .. 1
-i not in i64 .. i64
-i not in map(array, #)
-i not in map(list, i32)
-i32
-i32 != -0.5
-i32 != -1
-i32 != -f32
-i32 != -i
-i32 != -i32
-i32 != -i64
-i32 != 0.5 - 0.5
-i32 != 0.5 - i32
-i32 != 0.5 / f32
-i32 != 0.5 ^ 0.5
-i32 != 0.5 ^ i64
-i32 != 0.5 || ok
-i32 != 1 % i64
-i32 != 1 && ok
-i32 != 1 * f32
-i32 != 1 ? "foo" : array
-i32 != 1 ? greet : "foo"
-i32 != array[i64]
-i32 != bitnot(i)
-i32 != bitnot(i64)
-i32 != ceil(1)
-i32 != ceil(f64)
-i32 != count(array, false)
-i32 != f32
-i32 != f32 == true
-i32 != f32 ? false : 0.5
-i32 != f32 ? i : 0.5
-i32 != f64
-i32 != f64 ** i
-i32 != f64 - 1
-i32 != f64 ? 1 : add
-i32 != findLastIndex(array, false)
-i32 != get(array, 1)
-i32 != half(1)
-i32 != i
-i32 != i + 1
-i32 != i32
-i32 != i32 ** 0.5
-i32 != i32 + 0.5
-i32 != i32 ^ i64
-i32 != i64
-i32 != i64 * i64
-i32 != i64 / 0.5
-i32 != i64 / f32
-i32 != len(list)
-i32 != max(f64)
-i32 != min(1)
-i32 != min(i32)
-i32 != nil != false
-i32 != nil ? f64 : "foo"
-i32 != reduce(array, #)
-i32 != reduce(array, i)
-i32 != reduce(list, f32)
-i32 != round(1)
-i32 % -1
-i32 % -i32
-i32 % 1 % i32
-i32 % 1 * f32
-i32 % 1 * i
-i32 % 1 * i32
-i32 % 1 .. i
-i32 % 1 / 0.5
-i32 % 1 / i32
-i32 % 1 > i
-i32 % array[i64]
-i32 % get(array, 1)
-i32 % i
-i32 % i != i
-i32 % i < i
-i32 % i32
-i32 % i32 != f64
-i32 % i32 * i64
-i32 % i32 == i32
-i32 % i32 >= i64
-i32 % i64
-i32 % i64 % i
-i32 % i64 * i64
-i32 % i64 + i
-i32 % i64 .. i
-i32 % i64 / i
-i32 % i64 == f64
-i32 % max(i32)
-i32 % reduce(array, #)
-i32 % score(1)
-i32 * (1 + f32)
-i32 * (1 + f64)
-i32 * (f32 + 1)
-i32 * (f32 - i)
-i32 * (f64 + 0.5)
-i32 * (f64 + i)
-i32 * (i - f32)
-i32 * (i32 + i64)
-i32 * (i32 - 1)
-i32 * (i32 - f64)
-i32 * -0.5
-i32 * -1
-i32 * -f32
-i32 * -i32
-i32 * -i64
-i32 * 0.5 * 0.5
-i32 * 0.5 / 0.5
-i32 * 0.5 / 1
-i32 * 0.5 / i32
-i32 * 0.5 == f64
-i32 * 0.5 == i64
-i32 * 0.5 ^ f64
-i32 * 0.5 ^ i32
-i32 * 1 * i
-i32 * 1 ** i64
-i32 * 1 + f64
-i32 * 1 - i64
-i32 * 1 > half(0.5)
-i32 * 1 ^ 1
-i32 * abs(i32)
-i32 * bitnot(i32)
-i32 * ceil(1)
-i32 * f32
-i32 * f32 + f32
-i32 * f32 / i
-i32 * f32 <= f64
-i32 * f32 <= i32
-i32 * f32 ^ f32
-i32 * f64
-i32 * f64 * 1
-i32 * f64 >= f32
-i32 * first(array)
-i32 * float(f32)
-i32 * float(f64)
-i32 * floor(f64)
-i32 * half(0.5)
-i32 * half(1)
-i32 * i
-i32 * i / -i
-i32 * i / f32
-i32 * i / i64
-i32 * i < f32
-i32 * i32
-i32 * i32 != f64
-i32 * i32 % i64 / i
-i32 * i32 / i64
-i32 * i32 < i64
-i32 * i32 >= f32
-i32 * i64
-i32 * i64 % 1
-i32 * i64 % 1 % 1
-i32 * i64 ** i64
-i32 * i64 / f32
-i32 * i64 < i
-i32 * len("foo")
-i32 * max(i32)
-i32 * max(i64)
-i32 * median(array)
-i32 * min(0.5)
-i32 * min(i)
-i32 * reduce(array, #)
-i32 * round(i)
-i32 * score(1)
-i32 * score(i)
-i32 ** (0.5 - i32)
-i32 ** (1 * i64)
-i32 ** (1 / 0.5)
-i32 ** (f32 * i64)
-i32 ** (i % i32)
-i32 ** (i - i)
-i32 ** (i - i32)
-i32 ** (i / 0.5)
-i32 ** (i32 / i64)
-i32 ** (i64 + 0.5)
-i32 ** (i64 - 1)
-i32 ** -1
-i32 ** -f64
-i32 ** -i
-i32 ** -i64
-i32 ** 0.5 * i64
-i32 ** 0.5 - f64
-i32 ** 0.5 / reduce(array, #)
-i32 ** 0.5 ^ i
-i32 ** 1 ** i64
-i32 ** 1 + f32
-i32 ** 1 / i64
-i32 ** 1 <= i
-i32 ** 1 ^ i64
-i32 ** 1 in array
-i32 ** array[1]
-i32 ** array[i64]
-i32 ** bitnot(i64)
-i32 ** ceil(1)
-i32 ** ceil(f64)
-i32 ** f32
-i32 ** f32 / score(1)
-i32 ** f32 < f32
-i32 ** f32 <= i
-i32 ** f32 == f32
-i32 ** f64
-i32 ** f64 == f32
-i32 ** f64 > i
-i32 ** find(array, ok)
-i32 ** float(i32)
-i32 ** half(0.5)
-i32 ** half(1)
-i32 ** half(f64)
-i32 ** i
-i32 ** i * f64
-i32 ** i ** i
-i32 ** i ^ i
-i32 ** i32
-i32 ** i32 ^ i64
-i32 ** i64
-i32 ** int(1)
-i32 ** int(i32)
-i32 ** len("foo")
-i32 ** len(list)
-i32 ** max(f32, i32)
-i32 ** min(0.5)
-i32 ** min(i64)
-i32 ** reduce(array, 1)
-i32 ** reduce(array, i64)
-i32 ** reduce(list, i64)
-i32 ** round(i64)
-i32 ** sum(array)
-i32 + -0.5
-i32 + -1
-i32 + -i
-i32 + -i32
-i32 + -i64
-i32 + 0.5 != f32
-i32 + 0.5 != i32
-i32 + 0.5 * i
-i32 + 0.5 + 0.5
-i32 + 0.5 + 1
-i32 + 0.5 + f32
-i32 + 0.5 + f64
-i32 + 0.5 + i
-i32 + 0.5 + i64
-i32 + 0.5 / i64
-i32 + 0.5 <= -f32
-i32 + 1 % 1
-i32 + 1 + i64
-i32 + 1 - f32
-i32 + 1 - i
-i32 + 1 - i64
-i32 + 1 / i
-i32 + 1 ^ f32
-i32 + abs(f32)
-i32 + array[i64]
-i32 + bitnot(i32)
-i32 + ceil(i)
-i32 + f32
-i32 + f32 / i
-i32 + f32 < i32
-i32 + f32 <= i64
-i32 + f64
-i32 + f64 * 1
-i32 + f64 * i32
-i32 + f64 > i32
-i32 + f64 ^ 0.5
-i32 + f64 ^ i32
-i32 + findIndex(list, true)
-i32 + floor(0.5)
-i32 + floor(f64)
-i32 + i
-i32 + i + f64
-i32 + i + i64
-i32 + i - 0.5
-i32 + i - i64
-i32 + i <= i32
-i32 + i > i64
-i32 + i32
-i32 + i32 + f64
-i32 + i32 <= i + i64
-i32 + i32 > i
-i32 + i32 > i32
-i32 + i64
-i32 + i64 % i32
-i32 + i64 ** 1
-i32 + i64 - 0.5
-i32 + i64 - f32
-i32 + i64 / 0.5
-i32 + i64 ^ 1
-i32 + int(i64)
-i32 + len("bar")
-i32 + min(i32)
-i32 + reduce(array, #)
-i32 + round(f32)
-i32 + round(i32)
-i32 + score(i)
-i32 - -0.5
-i32 - -1
-i32 - -f32
-i32 - -i
-i32 - 0.5 * f32
-i32 - 0.5 + half(0.5)
-i32 - 0.5 - i32
-i32 - 0.5 <= f32
-i32 - 0.5 ^ 0.5
-i32 - 1 ** i
-i32 - 1 + 0.5
-i32 - 1 > -i64
-i32 - abs(i32)
-i32 - abs(i64)
-i32 - array[i]
-i32 - bitushr(i32, i64)
-i32 - div(1, i)
-i32 - div(i, i)
-i32 - f32
-i32 - f32 * 0.5
-i32 - f32 + i32
-i32 - f32 - int(f64)
-i32 - f32 / i32
-i32 - f32 < i64
-i32 - f32 <= f32
-i32 - f32 <= i32
-i32 - f32 > i
-i32 - f32 >= f32
-i32 - f64
-i32 - f64 + f32
-i32 - float(0.5)
-i32 - float(1)
-i32 - float(f64)
-i32 - floor(1)
-i32 - floor(f64)
-i32 - get(array, i)
-i32 - half(0.5)
-i32 - half(f64)
-i32 - i
-i32 - i ** i64
-i32 - i + i32
-i32 - i / 0.5
-i32 - i == f32
-i32 - i > f64
-i32 - i > i
-i32 - i >= i64
-i32 - i32
-i32 - i32 != i64
-i32 - i32 * 1
-i32 - i32 * i32
-i32 - i32 + 1
-i32 - i32 < i32
-i32 - i32 > i64
-i32 - i32 > i64 / i
-i32 - i64
-i32 - i64 != -f32
-i32 - i64 / 1
-i32 - i64 == f64
-i32 - len(array)
-i32 - len(list)
-i32 - max(f32)
-i32 - score(1)
-i32 .. -i64
-i32 .. abs(i64)
-i32 .. bitnot(i64)
-i32 .. bitushr(i, 1)
-i32 .. count(array, true)
-i32 .. div(i, 1)
-i32 .. i
-i32 .. i32
-i32 .. i64
-i32 .. int(f32)
-i32 .. len("foo")
-i32 .. max(1)
-i32 .. max(i32)
-i32 .. max(i32, 0.5)
-i32 .. score(i)
-i32 / (1 + 1)
-i32 / (1 + i64)
-i32 / (f64 - i64)
-i32 / (i32 + i64)
-i32 / (i64 + 0.5)
-i32 / -0.5
-i32 / -f32
-i32 / -i
-i32 / -i32
-i32 / -i64
-i32 / 0.5 * i
-i32 / 0.5 * i / 1
-i32 / 0.5 + i64
-i32 / 0.5 - i32
-i32 / 0.5 / i32
-i32 / 0.5 / i64
-i32 / 0.5 >= i64
-i32 / 0.5 ^ 1
-i32 / 0.5 ^ f64
-i32 / 1 != i
-i32 / 1 * i64
-i32 / 1 ** 1
-i32 / 1 ^ 0.5
-i32 / abs(0.5)
-i32 / abs(1)
-i32 / abs(f64)
-i32 / abs(i32)
-i32 / array[1]
-i32 / ceil(i32)
-i32 / f32
-i32 / f32 ** 1
-i32 / f32 / i64
-i32 / f32 <= i32
-i32 / f32 <= i64
-i32 / f32 >= i32 == false
-i32 / f64
-i32 / f64 != f64
-i32 / f64 != i64
-i32 / f64 * 1
-i32 / f64 - i32
-i32 / f64 == i64
-i32 / f64 >= f32
-i32 / find(array, ok)
-i32 / float(f32)
-i32 / floor(1)
-i32 / floor(f64)
-i32 / half(0.5)
-i32 / i
-i32 / i * i32
-i32 / i ^ i32
-i32 / i32
-i32 / i32 * f64
-i32 / i32 / i64
-i32 / i32 <= i64
-i32 / i64
-i32 / i64 ** f32
-i32 / i64 ^ 0.5
-i32 / int(1)
-i32 / len("foo")
-i32 / max(1)
-i32 / max(i)
-i32 / min(f32)
-i32 / reduce(array, #)
-i32 / score(i)
-i32 < -f32
-i32 < -f64
-i32 < -i32
-i32 < 0.5 ** i32
-i32 < 0.5 - 1
-i32 < 0.5 - f32
-i32 < 0.5 / 1
-i32 < 0.5 == nil
-i32 < 0.5 ? "foo" : half
-i32 < 0.5 ? foo : 1
-i32 < 0.5 or ok
-i32 < 0.5 || ok
-i32 < 1 * f32
-i32 < 1 + i64
-i32 < 1 / f32
-i32 < 1 ^ i
-i32 < abs(f64)
-i32 < f32
-i32 < f32 * i
-i32 < f32 - 0.5
-i32 < f32 - 1
-i32 < f64
-i32 < f64 * i64
-i32 < float(reduce(array, f32))
-i32 < get(array, i32)
-i32 < get(array, i64)
-i32 < half(1)
-i32 < half(f64)
-i32 < i
-i32 < i ** i64
-i32 < i + 0.5
-i32 < i / i32
-i32 < i ? score : score
-i32 < i32
-i32 < i32 % i
-i32 < i32 ** 1
-i32 < i32 - f32
-i32 < i32 ^ i64
-i32 < i64
-i32 < i64 ** 0.5
-i32 < i64 + f32
-i32 < i64 / f64
-i32 < int(0.5)
-i32 < last(array)
-i32 < min(1)
-i32 < min(f64)
-i32 < min(i32)
-i32 < score(1)
-i32 < score(i)
-i32 <= -0.5
-i32 <= -f32
-i32 <= -i
-i32 <= -i32
-i32 <= -i64
-i32 <= 0.5 - f64
-i32 <= 0.5 == nil
-i32 <= 0.5 ? i32 : greet
-i32 <= 0.5 ? i32 : half
-i32 <= 0.5 ^ i64
-i32 <= 0.5 and ok
-i32 <= 1 + i32
-i32 <= 1 + i64
-i32 <= 1 ^ 0.5
-i32 <= 1 and ok
-i32 <= 1 || i32 >= i32
-i32 <= abs(1)
-i32 <= f32
-i32 <= f32 != ok
-i32 <= f64
-i32 <= f64 != ok
-i32 <= f64 * i
-i32 <= f64 == ok
-i32 <= f64 ^ f64
-i32 <= findIndex(array, true)
-i32 <= float(i32)
-i32 <= floor(0.5)
-i32 <= half(0.5)
-i32 <= half(1)
-i32 <= half(f64)
-i32 <= i
-i32 <= i * 1
-i32 <= i * i64
-i32 <= i - 0.5
-i32 <= i32
-i32 <= i32 != true
-i32 <= i64
-i32 <= i64 / 1
-i32 <= len("foo")
-i32 <= max(i64)
-i32 <= mean(array)
-i32 <= round(0.5)
-i32 <= score(1)
-i32 <= score(i)
-i32 == -0.5
-i32 == -1
-i32 == -f32
-i32 == -f64
-i32 == -i
-i32 == 0.5 != false
-i32 == 0.5 * f32
-i32 == 0.5 / 0.5
-i32 == 1 % 1
-i32 == 1 + f32
-i32 == 1 - i
-i32 == 1 ? div : div
-i32 == 1 ^ 0.5
-i32 == 1 ^ f64
-i32 == abs(f64)
-i32 == abs(i)
-i32 == bitnot(1)
-i32 == bitnot(i)
-i32 == ceil(1)
-i32 == count(list, ok)
-i32 == f32
-i32 == f32 * i32
-i32 == f32 ** 1
-i32 == f32 - f32
-i32 == f32 ? f64 : list
-i32 == f32 ? i64 : true
-i32 == f32 ? score : "bar"
-i32 == f64
-i32 == f64 ** 0.5
-i32 == find(array, 0.5 == i64)
-i32 == first(array)
-i32 == floor(f64)
-i32 == half(f64)
-i32 == i
-i32 == i ** f64
-i32 == i ? half : 1
-i32 == i ? i : "bar"
-i32 == i32
-i32 == i32 && i == i
-i32 == i32 - 1
-i32 == i32 - i64
-i32 == i64
-i32 == i64 * f32
-i32 == i64 ? "foo" : 1
-i32 == i64 or ok
-i32 == int(f64)
-i32 == int(i)
-i32 == nil ? f32 : 0.5
-i32 == reduce(array, #)
-i32 == round(i32)
-i32 == round(i64)
-i32 == score(1)
-i32 > -0.5
-i32 > -f64
-i32 > -i32
-i32 > 0.5 != true
-i32 > 0.5 * f64
-i32 > 0.5 ** 0.5
-i32 > 0.5 ** 1
-i32 > 0.5 ** i
-i32 > 0.5 - i
-i32 > 0.5 / 1
-i32 > 0.5 == ok
-i32 > 0.5 ^ 1
-i32 > 0.5 || ok
-i32 > 1 * f64
-i32 > 1 * i32
-i32 > 1 + i64
-i32 > 1 ? f32 : f64
-i32 > 1 ? i : "bar"
-i32 > 1 ? i64 : div
-i32 > ceil(0.5)
-i32 > ceil(1)
-i32 > count(array, ok)
-i32 > f32
-i32 > f32 * i64
-i32 > f32 + 0.5
-i32 > f32 + 1
-i32 > f32 - f32
-i32 > f32 - i32
-i32 > f32 ^ 0.5
-i32 > f64
-i32 > f64 ** i32
-i32 > f64 + f64
-i32 > get(array, i32)
-i32 > half(1)
-i32 > half(half(1))
-i32 > i
-i32 > i != ok
-i32 > i + f32
-i32 > i ? i : i
-i32 > i ^ i32
-i32 > i32
-i32 > i32 - i
-i32 > i32 == nil ? score : i
-i32 > i32 ? score : 1
-i32 > i32 ^ 1
-i32 > i32 ^ i32
-i32 > i64
-i32 > i64 != false
-i32 > i64 ** f32
-i32 > i64 / 1
-i32 > i64 == ok
-i32 > i64 || ok
-i32 > int(1)
-i32 > int(i64)
-i32 > min(i32)
-i32 > reduce(array, #)
-i32 > round(i64)
-i32 > score(i)
-i32 >= -1
-i32 >= -f32
-i32 >= -f64
-i32 >= -i
-i32 >= -i64
-i32 >= 0.5 != not true
-i32 >= 0.5 == true
-i32 >= 0.5 ? 0.5 : half
-i32 >= 0.5 ^ 0.5
-i32 >= 0.5 ^ i32
-i32 >= 1 % i
-i32 >= 1 * 0.5
-i32 >= 1 * i32
-i32 >= 1 + i64
-i32 >= 1 - 1
-i32 >= 1 == ok
-i32 >= 1 ? 1 : false
-i32 >= 1 ? add : 1
-i32 >= abs(0.5)
-i32 >= abs(f32)
-i32 >= bitnot(1 + i)
-i32 >= bitnot(i64)
-i32 >= ceil(1)
-i32 >= ceil(f32)
-i32 >= count(list, true)
-i32 >= f32
-i32 >= f32 ** f32
-i32 >= f32 ^ 1
-i32 >= f64
-i32 >= f64 != false
-i32 >= f64 ** f64
-i32 >= f64 / i64
-i32 >= f64 ? half : f64
-i32 >= f64 ^ f64
-i32 >= float(0.5)
-i32 >= floor(1)
-i32 >= floor(f32)
-i32 >= half(0.5)
-i32 >= i
-i32 >= i % 1
-i32 >= i % i64
-i32 >= i / i32
-i32 >= i / i64
-i32 >= i == ok
-i32 >= i32
-i32 >= i32 ** i32
-i32 >= i64
-i32 >= i64 != false
-i32 >= i64 - i64
-i32 >= i64 / i32
-i32 >= i64 ? 0.5 : 0.5
-i32 >= i64 ? div : half
-i32 >= i64 ? half : i64
-i32 >= i64 and ok
-i32 >= int(i64)
-i32 >= last(array)
-i32 >= min(i32)
-i32 >= reduce(array, #)
-i32 >= reduce(array, i64)
-i32 >= reduce(list, i32)
-i32 >= round(f32)
-i32 >= score(1)
-i32 ^ (0.5 + 1)
-i32 ^ (1 - i)
-i32 ^ (i + 1)
-i32 ^ (i / f64)
-i32 ^ (i32 + 0.5)
-i32 ^ (i32 - f32)
-i32 ^ (i64 + i)
-i32 ^ -0.5
-i32 ^ -1
-i32 ^ -f64
-i32 ^ -i
-i32 ^ -i32
-i32 ^ -i64
-i32 ^ 0.5 != f32
-i32 ^ 0.5 != f64
-i32 ^ 0.5 * i
-i32 ^ 0.5 ** i64
-i32 ^ 0.5 - f32
-i32 ^ 0.5 / i32
-i32 ^ 0.5 == i64
-i32 ^ 0.5 >= f64
-i32 ^ 1 ** i32
-i32 ^ 1 + i32
-i32 ^ 1 - f64
-i32 ^ 1 < f64
-i32 ^ 1 ^ (1 + i64)
-i32 ^ 1 ^ f32
-i32 ^ array[i64]
-i32 ^ f32
-i32 ^ f32 / bitnot(1)
-i32 ^ f32 >= max(f64)
-i32 ^ f64
-i32 ^ f64 + i
-i32 ^ find(array, true)
-i32 ^ first(array)
-i32 ^ float(i64)
-i32 ^ i
-i32 ^ i * f64
-i32 ^ i + i64
-i32 ^ i <= f32
-i32 ^ i32
-i32 ^ i32 * f64
-i32 ^ i32 ** i
-i32 ^ i64
-i32 ^ i64 == f64
-i32 ^ i64 > -f64
-i32 ^ len(list)
-i32 ^ mean(array)
-i32 ^ min(i)
-i32 ^ reduce(array, #)
-i32 ^ reduce(list, 1)
-i32 in [0.5]
-i32 in array
-i32 in array || ok
-i32 in groupBy(array, #)
-i32 in groupBy(array, f32)
-i32 in groupBy(list, #)
-i32 in groupBy(list, #?.Bar)
-i32 in groupBy(list, foo).i
-i32 in i32 .. 1
-i32 in i32 .. i64
-i32 in map(array, #)
-i32 in map(list, 0.5)
-i32 in map(list, i32)
-i32 not in 1 .. i
-i32 not in array
-i32 not in array ? array : array
-i32 not in filter(array, ok)
-i32 not in groupBy(list, #)
-i64
-i64 != -1
-i64 != -i
-i64 != -i64
-i64 != 0.5 && ok
-i64 != 0.5 * 0.5
-i64 != 0.5 * i
-i64 != 0.5 + 0.5
-i64 != 0.5 + i
-i64 != 0.5 - 0.5
-i64 != 0.5 / i64
-i64 != 0.5 ? i : 1
-i64 != 0.5 ^ i32
-i64 != 1 * f64
-i64 != 1 - 1
-i64 != abs(f64)
-i64 != array[i64]
-i64 != bitnot(i32)
-i64 != f32
-i64 != f32 + i64
-i64 != f64
-i64 != f64 * 1
-i64 != f64 == true
-i64 != f64 or i64 <= f32
-i64 != findIndex(array, ok)
-i64 != float(1)
-i64 != floor(i)
-i64 != get(array, i)
-i64 != half(0.5)
-i64 != half(1)
-i64 != i
-i64 != i % 1
-i64 != i + 1
-i64 != i / 0.5
-i64 != i ? f32 : true
-i64 != i32
-i64 != i32 ? 0.5 : nil
-i64 != i32 ? f64 : greet
-i64 != i32 ^ i
-i64 != i32 || ok
-i64 != i64
-i64 != i64 - 0.5
-i64 != len("bar")
-i64 != len(list)
-i64 != max(0.5)
-i64 != min(1)
-i64 != min(1, f32)
-i64 != min(f32)
-i64 != min(i)
-i64 != nil != ok
-i64 != nil ? div : 1
-i64 != nil ? greet : i
-i64 != nil ? i : i
-i64 != nil ? i64 : false
-i64 != score(1)
-i64 != score(i)
-i64 % -i
-i64 % 1 % 1
-i64 % 1 * i
-i64 % 1 < i32
-i64 % 1 >= f64
-i64 % 1 >= i32
-i64 % abs(i32)
-i64 % array[i32]
-i64 % i
-i64 % i * i
-i64 % i >= i
-i64 % i32
-i64 % i32 / f64
-i64 % i32 <= f64
-i64 % i64
-i64 % i64 % 1
-i64 % i64 .. i64
-i64 % i64 == i64
-i64 % int(i32)
-i64 % len("bar")
-i64 % max(i)
-i64 % min(1)
-i64 % score(1)
-i64 * (0.5 + f64)
-i64 * (1 - i64)
-i64 * (f32 - f32)
-i64 * (f64 + f32)
-i64 * (i + 0.5)
-i64 * (i + f64)
-i64 * (i32 + f64)
-i64 * -0.5
-i64 * -1
-i64 * -f32
-i64 * -i32
-i64 * 0.5 * i32
-i64 * 0.5 ** 0.5
-i64 * 0.5 - f32
-i64 * 0.5 / 1
-i64 * 0.5 >= f32
-i64 * 1 % 1
-i64 * 1 * 0.5
-i64 * 1 * f64
-i64 * 1 ** 1
-i64 * 1 - i64
-i64 * 1 .. i32
-i64 * 1 / i64
-i64 * 1 <= f64
-i64 * 1 == 0.5 != true
-i64 * 1 == f32
-i64 * 1 > 1 - i64
-i64 * 1 > f64
-i64 * 1 ^ i32
-i64 * add(1, 1)
-i64 * ceil(1)
-i64 * ceil(i)
-i64 * ceil(i64)
-i64 * count(array, false)
-i64 * f32
-i64 * f32 * f32
-i64 * f32 ** 1
-i64 * f32 / f32
-i64 * f32 / i
-i64 * f32 / i32
-i64 * f32 not in array
-i64 * f64
-i64 * f64 + i32
-i64 * f64 - f64
-i64 * f64 / f64
-i64 * f64 < f64
-i64 * f64 > f64
-i64 * f64 ^ i32
-i64 * findIndex(array, ok)
-i64 * float(i)
-i64 * float(i64)
-i64 * half(0.5)
-i64 * i
-i64 * i - -f64
-i64 * i <= f64
-i64 * i32
-i64 * i32 != i32
-i64 * i32 * 1
-i64 * i32 * i
-i64 * i32 / 0.5
-i64 * i32 ^ i
-i64 * i64
-i64 * i64 % i64
-i64 * i64 * i64
-i64 * i64 ** i
-i64 * i64 / f32
-i64 * i64 > i32
-i64 * int(1)
-i64 * int(i)
-i64 * max(1)
-i64 * max(i64)
-i64 * min(1)
-i64 * min(i32)
-i64 * reduce(array, #)
-i64 * reduce(list, 0.5)
-i64 * reduce(list, 1)
-i64 * round(i)
-i64 * score(1)
-i64 ** (0.5 + 0.5)
-i64 ** (0.5 / 1)
-i64 ** (1 % 1)
-i64 ** (1 * 1)
-i64 ** (1 - f32)
-i64 ** (f32 + 1)
-i64 ** (f32 / 0.5)
-i64 ** (f64 - 0.5)
-i64 ** (i * i64)
-i64 ** (i / 1)
-i64 ** (i64 % i)
-i64 ** (i64 / i)
-i64 ** -0.5
-i64 ** -1
-i64 ** -f32
-i64 ** 0.5 != i32
-i64 ** 0.5 <= f32
-i64 ** 0.5 <= i
-i64 ** 1 + i32
-i64 ** 1 - f32
-i64 ** 1 / i64
-i64 ** 1 >= f32
-i64 ** bitnot(i32)
-i64 ** ceil(i32)
-i64 ** count(array, false)
-i64 ** f32
-i64 ** f32 * min(0.5)
-i64 ** f64
-i64 ** f64 ** f64
-i64 ** f64 not in array
-i64 ** f64 not in array ? f32 : greet
-i64 ** floor(f32)
-i64 ** half(1)
-i64 ** i
-i64 ** i != f32
-i64 ** i * f32
-i64 ** i <= -i
-i64 ** i == f64
-i64 ** i ^ f32
-i64 ** i32
-i64 ** i32 != i64
-i64 ** i32 * i ^ i
-i64 ** i32 not in array
-i64 ** i64
-i64 ** i64 - i64
-i64 ** i64 in array
-i64 ** max(1)
-i64 ** min(0.5)
-i64 ** min(1)
-i64 ** min(i32, 1)
-i64 ** reduce(array, #)
-i64 + -1
-i64 + -i
-i64 + -i64
-i64 + 0.5 ** f32
-i64 + 0.5 + i32
-i64 + 0.5 + i64
-i64 + 0.5 - f64
-i64 + 0.5 <= bitnand(1, 1)
-i64 + 0.5 <= f64
-i64 + 0.5 == f32
-i64 + 1 != f64
-i64 + 1 % i64
-i64 + 1 + f64
-i64 + 1 <= f32
-i64 + array[i64]
-i64 + array[i]
-i64 + f32
-i64 + f32 * f64
-i64 + f32 / i64
-i64 + f64
-i64 + f64 * 0.5
-i64 + f64 ** 0.5
-i64 + f64 > f32
-i64 + float(f32)
-i64 + float(i32)
-i64 + half(0.5)
-i64 + i
-i64 + i % 1
-i64 + i * 0.5
-i64 + i + f32
-i64 + i - i32
-i64 + i / i32
-i64 + i == 0.5 - i32
-i64 + i ^ f32
-i64 + i ^ f64
-i64 + i32
-i64 + i32 % i64
-i64 + i32 - 0.5
-i64 + i32 == f64
-i64 + i64
-i64 + i64 - 0.5
-i64 + reduce(array, #)
-i64 + score(i)
-i64 - -1
-i64 - -f32
-i64 - -i32
-i64 - -i64
-i64 - 0.5 + f32
-i64 - 0.5 / i64
-i64 - 0.5 <= i
-i64 - 0.5 ^ f32
-i64 - 1 ** 1
-i64 - 1 < i
-i64 - 1 == i32
-i64 - 1 > f32
-i64 - 1 >= i
-i64 - 1 not in array
-i64 - ceil(1)
-i64 - f32
-i64 - f32 != f32
-i64 - f32 - 1
-i64 - f32 - i
-i64 - f32 / 1
-i64 - f32 < i64
-i64 - f32 >= f64
-i64 - f64
-i64 - f64 != i
-i64 - f64 ** f32
-i64 - f64 ** i32
-i64 - f64 + f32
-i64 - f64 + i32
-i64 - f64 >= f64
-i64 - float(0.5)
-i64 - half(1)
-i64 - half(f64)
-i64 - i
-i64 - i * 1
-i64 - i + i64
-i64 - i - 1
-i64 - i .. i64
-i64 - i < i32
-i64 - i > 1 - 0.5
-i64 - i >= f64
-i64 - i ^ i64
-i64 - i not in array
-i64 - i32
-i64 - i32 - i64
-i64 - i32 .. i64
-i64 - i32 > i
-i64 - i32 >= i
-i64 - i64
-i64 - i64 > f32
-i64 - int(i)
-i64 - len("foo")
-i64 - max(0.5)
-i64 - min(f32)
-i64 - min(f64)
-i64 - min(i)
-i64 - reduce(array, #)
-i64 - reduce(array, i64)
-i64 - round(1)
-i64 - score(1)
-i64 - score(i)
-i64 .. -1
-i64 .. -i
-i64 .. -i32
-i64 .. -i64
-i64 .. 1 * i64
-i64 .. 1 - 1
-i64 .. 1 - i
-i64 .. 1 - i64
-i64 .. abs(i)
-i64 .. bitnot(i32)
-i64 .. count(array, false)
-i64 .. get(array, 1)
-i64 .. i
-i64 .. i * i
-i64 .. i + 1
-i64 .. i == list
-i64 .. i32
-i64 .. i32 * 1
-i64 .. i64
-i64 .. i64 * i32
-i64 .. i64 + i
-i64 .. i64 - i
-i64 .. int(0.5)
-i64 .. int(f32)
-i64 .. int(i64)
-i64 .. min(i32)
-i64 .. min(i64, 0.5)
-i64 .. reduce(array, #)
-i64 .. score(1)
-i64 / (f32 + i64)
-i64 / (f32 - i)
-i64 / (i + 1)
-i64 / (i32 + 0.5)
-i64 / (i64 - i)
-i64 / -0.5
-i64 / -1
-i64 / -f32
-i64 / -f64
-i64 / -i
-i64 / 0.5 * f64
-i64 / 0.5 - i64
-i64 / 0.5 / i
-i64 / 0.5 == i
-i64 / 1 ** i64
-i64 / 1 / i32
-i64 / 1 / i64
-i64 / 1 < i
-i64 / 1 == f32
-i64 / ceil(i)
-i64 / f32
-i64 / f32 - i
-i64 / f32 / i64
-i64 / f32 > i
-i64 / f32 ^ 1
-i64 / f32 ^ i
-i64 / f64
-i64 / f64 * i64
-i64 / f64 - min(i64)
-i64 / f64 / f32
-i64 / f64 / i * 0.5
-i64 / f64 / i32
-i64 / f64 in array
-i64 / float(1)
-i64 / get(array, i32)
-i64 / half(1)
-i64 / i
-i64 / i * i64
-i64 / i - f64
-i64 / i32
-i64 / i32 != f32
-i64 / i32 * f64
-i64 / i32 == f64
-i64 / i32 > 1 + 1
-i64 / i32 >= f32
-i64 / i32 >= f64
-i64 / i32 ^ f32
-i64 / i64
-i64 / i64 + f64
-i64 / i64 < i32
-i64 / i64 <= f32
-i64 / i64 == i32
-i64 / int(1)
-i64 / len(list)
-i64 / max(1)
-i64 / reduce(array, #)
-i64 / reduce(array, 1)
-i64 / round(0.5)
-i64 / round(i)
-i64 / score(1)
-i64 / score(i)
-i64 < -0.5
-i64 < -1
-i64 < -f32
-i64 < -f64
-i64 < -i
-i64 < -i32
-i64 < -i64
-i64 < 0.5 * 0.5
-i64 < 0.5 + i
-i64 < 0.5 - 1
-i64 < 0.5 / 0.5
-i64 < 0.5 / 1
-i64 < 0.5 == ok
-i64 < 0.5 || false ? 1 : nil
-i64 < 1 * i32
-i64 < 1 ** 0.5
-i64 < 1 + 0.5
-i64 < 1 + i64
-i64 < 1 / f32
-i64 < ceil(i64)
-i64 < f32
-i64 < f32 * 0.5
-i64 < f32 - i64
-i64 < f32 ^ f32
-i64 < f64
-i64 < f64 && ok
-i64 < f64 - f64
-i64 < f64 ? score : add
-i64 < float(0.5)
-i64 < float(i32)
-i64 < floor(0.5)
-i64 < floor(i32)
-i64 < half(1)
-i64 < i
-i64 < i % i64
-i64 < i ^ 0.5
-i64 < i || ok
-i64 < i32
-i64 < i32 + 1
-i64 < i32 + i32
-i64 < i32 / f32
-i64 < i32 ? foo : i
-i64 < i64
-i64 < i64 != nil
-i64 < i64 * 1
-i64 < i64 * i64
-i64 < i64 / f32
-i64 < i64 / i
-i64 < i64 ^ 1
-i64 < i64 ^ i
-i64 < int(f64)
-i64 < len("bar")
-i64 < len("foo")
-i64 <= -0.5
-i64 <= -1
-i64 <= -f32
-i64 <= -f64
-i64 <= -i64
-i64 <= 0.5 && ok
-i64 <= 0.5 * 0.5
-i64 <= 0.5 + 1
-i64 <= 0.5 ? i : i32
-i64 <= 1 ** i32
-i64 <= 1 + 1
-i64 <= 1 - 0.5
-i64 <= 1 - 1
-i64 <= 1 / 1
-i64 <= 1 == ok
-i64 <= 1 ? add : div
-i64 <= 1 ? f32 : greet
-i64 <= 1 ? i64 : true
-i64 <= 1 ^ 1
-i64 <= array[i64]
-i64 <= array[i]
-i64 <= bitnot(1)
-i64 <= f32
-i64 <= f32 ** i
-i64 <= f32 ** i64
-i64 <= f32 == ok
-i64 <= f64
-i64 <= f64 + 1
-i64 <= f64 + f32
-i64 <= f64 / 1
-i64 <= f64 ? nil : i32
-i64 <= float(1)
-i64 <= floor(i)
-i64 <= floor(i32)
-i64 <= half(min(0.5, 1, i64))
-i64 <= i
-i64 <= i * 1
-i64 <= i * f32
-i64 <= i ** i32
-i64 <= i ? greet : add
-i64 <= i32
-i64 <= i32 ** i32
-i64 <= i32 ? list : half
-i64 <= i32 ^ -1
-i64 <= i64
-i64 <= i64 * i
-i64 <= len(list)
-i64 <= max(f32)
-i64 <= min(0.5)
-i64 <= min(i32)
-i64 <= reduce(array, i32)
-i64 <= reduce(list, i64)
-i64 <= round(0.5)
-i64 == -1
-i64 == -f32
-i64 == -f64
-i64 == -i
-i64 == -i32
-i64 == 0.5 * 1
-i64 == 0.5 - f64
-i64 == 0.5 == ok
-i64 == 0.5 ? 0.5 : f64
-i64 == 1 ** f64
-i64 == 1 + 0.5
-i64 == 1 / i
-i64 == 1 == ok
-i64 == 1 ? "foo" : i
-i64 == array[1]
-i64 == bitnot(i64)
-i64 == ceil(i64)
-i64 == f32
-i64 == f32 != true
-i64 == f32 + i
-i64 == f32 - f32
-i64 == f32 == ok
-i64 == f64
-i64 == f64 * f64
-i64 == f64 ? 1 : nil
-i64 == f64 ^ 0.5
-i64 == f64 ^ f32
-i64 == f64 and not true
-i64 == findIndex(list, f64 <= f64)
-i64 == floor(0.5)
-i64 == get(array, 1)
-i64 == half(1)
-i64 == i
-i64 == i != nil
-i64 == i + i32
-i64 == i ? i64 : foo
-i64 == i32
-i64 == i64
-i64 == i64 * f32
-i64 == i64 / i64
-i64 == i64 ? add : 0.5
-i64 == i64 ? add : greet
-i64 == int(0.5)
-i64 == int(1)
-i64 == int(i)
-i64 == len("foo")
-i64 == nil != nil
-i64 == reduce(array, #)
-i64 == score(1)
-i64 > -0.5
-i64 > -f32
-i64 > -f64
-i64 > 0.5 + f32
-i64 > 0.5 - f64
-i64 > 0.5 - i32
-i64 > 0.5 ? array : 1
-i64 > 0.5 ? f32 : nil
-i64 > 0.5 ? ok : nil
-i64 > 0.5 ? score : foo
-i64 > 0.5 or ok
-i64 > 1 != true
-i64 > 1 ** 1
-i64 > 1 == false
-i64 > 1 ? nil : 1
-i64 > 1 ^ f32
-i64 > 1 ^ i32
-i64 > f32
-i64 > f32 * 0.5
-i64 > f32 + f64
-i64 > f32 / f32
-i64 > f32 ? "foo" : greet
-i64 > f32 ? 1 : i32
-i64 > f64
-i64 > f64 * i
-i64 > f64 - 0.5
-i64 > f64 - f32
-i64 > first(array)
-i64 > half(0.5)
-i64 > i
-i64 > i != nil
-i64 > i == true
-i64 > i32
-i64 > i32 ? div : f32
-i64 > i32 ^ f32
-i64 > i64
-i64 > i64 - i
-i64 > i64 - i32
-i64 > i64 / f64
-i64 > i64 == false
-i64 > len(list)
-i64 > max(0.5)
-i64 > min(1)
-i64 > min(i32)
-i64 > reduce(array, #)
-i64 > reduce(array, 1)
-i64 > round(0.5)
-i64 > round(i32)
-i64 > score(i)
-i64 >= -0.5
-i64 >= -1
-i64 >= -i
-i64 >= -i64
-i64 >= 0.5 / i
-i64 >= 0.5 == nil
-i64 >= 0.5 ? 0.5 : f64
-i64 >= 0.5 ^ i
-i64 >= 1 % i64
-i64 >= 1 * f64
-i64 >= 1 * i64
-i64 >= abs(i64)
-i64 >= array[i32]
-i64 >= bitnot(1)
-i64 >= f32
-i64 >= f32 + f32
-i64 >= f32 - f32
-i64 >= f32 ? array : i
-i64 >= f32 ? f32 : i32
-i64 >= f32 ? list : f32
-i64 >= f64
-i64 >= f64 + 0.5
-i64 >= first(array)
-i64 >= float(0.5)
-i64 >= float(f32)
-i64 >= floor(1)
-i64 >= floor(i64)
-i64 >= half(0.5)
-i64 >= half(half(f64))
-i64 >= i
-i64 >= i / 0.5
-i64 >= i ? true : i32
-i64 >= i32
-i64 >= i32 * i
-i64 >= i32 / f32
-i64 >= i32 == false
-i64 >= i32 || f64 == 1
-i64 >= i64
-i64 >= i64 + 1
-i64 >= i64 ? foo : foo
-i64 >= i64 or ok
-i64 >= int(f64)
-i64 >= last(array)
-i64 >= max(i64)
-i64 >= min(1)
-i64 >= min(f64)
-i64 >= round(1)
-i64 >= round(i)
-i64 >= score(1)
-i64 ^ (0.5 * i32)
-i64 ^ (0.5 / i64)
-i64 ^ (1 * f64)
-i64 ^ (1 - i)
-i64 ^ (f32 / 1)
-i64 ^ (i % i)
-i64 ^ (i32 * f64)
-i64 ^ (i32 - f64)
-i64 ^ (i64 + 0.5)
-i64 ^ (i64 + 1)
-i64 ^ (i64 - f32)
-i64 ^ -0.5
-i64 ^ -1
-i64 ^ -f32
-i64 ^ -i64
-i64 ^ 0.5 != i64
-i64 ^ 0.5 ** 0.5
-i64 ^ 0.5 / f32
-i64 ^ 0.5 <= i64
-i64 ^ 0.5 == i
-i64 ^ 0.5 ^ f32
-i64 ^ 0.5 ^ i64
-i64 ^ 1 * i64
-i64 ^ 1 * round(0.5)
-i64 ^ 1 ** f64
-i64 ^ 1 ** i32
-i64 ^ 1 - f32
-i64 ^ 1 < f64
-i64 ^ 1 >= f32
-i64 ^ 1 >= half(1)
-i64 ^ 1 ^ f32
-i64 ^ 1 ^ i32
-i64 ^ abs(1)
-i64 ^ array[i]
-i64 ^ f32
-i64 ^ f32 * i32
-i64 ^ f32 ** f64
-i64 ^ f32 - f64
-i64 ^ f32 / i - i32
-i64 ^ f32 < f32
-i64 ^ f32 <= i64
-i64 ^ f32 ^ 1
-i64 ^ f64
-i64 ^ f64 * i
-i64 ^ f64 ** 1
-i64 ^ f64 > i64
-i64 ^ f64 ^ f32
-i64 ^ float(i32)
-i64 ^ floor(i32)
-i64 ^ floor(i64)
-i64 ^ half(0.5)
-i64 ^ half(1)
-i64 ^ i
-i64 ^ i * i
-i64 ^ i ** i32
-i64 ^ i + i % 1
-i64 ^ i + i64
-i64 ^ i - f32 ^ 1
-i64 ^ i - f64
-i64 ^ i / i
-i64 ^ i < f32
-i64 ^ i ^ i32
-i64 ^ i32
-i64 ^ i32 * i
-i64 ^ i32 + i32
-i64 ^ i32 + i64
-i64 ^ i64
-i64 ^ i64 * i64
-i64 ^ i64 + i
-i64 ^ i64 == i64
-i64 ^ i64 ^ 1
-i64 ^ i64 in array
-i64 ^ int(1)
-i64 ^ max(0.5)
-i64 ^ reduce(array, #)
-i64 ^ round(i64)
-i64 ^ score(1)
-i64 in array
-i64 in array == ok
-i64 in groupBy(array, 0.5)
-i64 in groupBy(array, foo)
-i64 in groupBy(list, "bar")
-i64 in groupBy(list, i)
-i64 in i64 .. i32
-i64 in map(array, #)
-i64 in map(list, 1)
-i64 in map(list, i)
-i64 not in 1 .. i
-i64 not in array
-i64 not in array ? f32 : i32
-i64 not in array ? ok : f32
-i64 not in map(array, #)
-i64 not in map(list, 0.5)
-int(-0.5)
-int(-1)
-int(-f32)
-int(-f64)
-int(-i)
-int(-i32)
-int(-i64)
-int(0.5 * 0.5)
-int(0.5 * f32)
-int(0.5 * f64)
-int(0.5 * i32)
-int(0.5 ** 0.5)
-int(0.5 ** 1)
-int(0.5 ** f32)
-int(0.5 ** f64)
-int(0.5 ** i32)
-int(0.5 + 0.5)
-int(0.5 + 1)
-int(0.5 + f64)
-int(0.5 + i32)
-int(0.5 + i64)
-int(0.5 - f32)
-int(0.5 - i)
-int(0.5 - i32)
-int(0.5 - i64)
-int(0.5 / i)
-int(0.5 / i64)
-int(0.5 ^ i)
-int(0.5 ^ i64)
-int(0.5) * -i
-int(0.5) ** f64
-int(0.5) ** i32
-int(0.5) + i
-int(0.5) / i32
-int(0.5) < 0.5 * f64
-int(0.5) <= i
-int(0.5) <= i32
-int(0.5) == f32
-int(0.5) > -i64
-int(0.5) > i
-int(0.5) >= f32
-int(0.5) >= i32
-int(0.5) >= max(0.5)
-int(0.5) ^ i32
-int(1 % i)
-int(1 * f32)
-int(1 * i)
-int(1 * i32)
+i not in array == true
+i not in flatten(array)
+i not in flatten(list)
+i not in map(list, 1)
+i | add(0)
+i | add(1)
+i | add(i)
+i | bitand(0)
+i | bitand(1)
+i | bitand(1) + i
+i | bitand(i)
+i | bitnand(0)
+i | bitnand(1)
+i | bitnand(i)
+i | bitor(0)
+i | bitor(1 % 1)
+i | bitor(1)
+i | bitor(i)
+i | bitshl($env.i)
+i | bitshl(0)
+i | bitshl(1)
+i | bitshl(i)
+i | bitshr(0)
+i | bitshr(0) != 1.0 || false
+i | bitshr(1)
+i | bitshr(i)
+i | bitushr(0)
+i | bitushr(1)
+i | bitushr(i)
+i | bitxor(0)
+i | bitxor(1)
+i | bitxor(i)
+i | max($env.i)
+i | max(0)
+i | max(0, 1.0)
+i | max(1)
+i | max(1.0)
+i | max(1.0, array)
+i | max(1.0, f64)
+i | max(array)
+i | max(f64)
+i | max(f64, 0)
+i | max(f64, f64)
+i | max(i)
+i | max(i, array)
+i | mean(0)
+i | mean(1)
+i | mean(1, array)
+i | mean(1.0)
+i | mean(array)
+i | mean(f64)
+i | mean(f64, 1)
+i | mean(i)
+i | mean(i, f64)
+i | median(0)
+i | median(0, 0)
+i | median(1)
+i | median(1, 1)
+i | median(1.0)
+i | median(1.0, i)
+i | median(array)
+i | median(f64)
+i | median(i)
+i | median(i) != f64
+i | median(i, 1.0)
+i | min(0)
+i | min(0) | median(1.0)
+i | min(0, f64)
+i | min(1)
+i | min(1.0)
+i | min(array)
+i | min(f64)
+i | min(f64, array)
+i | min(i)
+i | min(i, 1)
+i..array?.[i]
+i..i
+i..i - 0
+i..i == $env
+i..i == nil
+i..i | map(#)
+i..i | reduce(foo)
+i; 1.0; $env.foo
+i; ceil(1.0)
+i; f64
+i; greet
+i; i; greet(str)
+i; list
+i; str
+i; {foo: false}
+if $env != f64 { add } else { foo }
+if $env != foo { greet } else { str }
+if $env == 1.0 { list } else { add }
+if $env?.ok { foo?.String } else { greet }
+if 0 > 1 { list } else { false ? ok : ok }
+if 1.0 >= 0 { foo } else { ok }
+if f64 not in array { map(list, list) } else { add }
+if i > $env?.i { greet } else { list }
+if nil != str { greet } else { array }
+if ok or false { str } else { greet }
+if ok { $env.foo } else { foo.Bar }
+if ok { 0 != i } else { ok }
+if ok { 1 > 1.0 } else { f64 }
+if ok { add } else { add }
+if ok { add } else { f64 }
+if ok { add } else { foo }
+if ok { add } else { greet }
+if ok { add } else { i }
+if ok { add } else { ok }
+if ok { array } else { foo }
+if ok { array } else { foo?.Bar }
+if ok { f64 } else { f64 }
+if ok { f64 } else { findLastIndex($env, $env) }
+if ok { f64 } else { foo }
+if ok { f64 } else { ok }
+if ok { false && true } else { false == nil }
+if ok { foo } else { $env ?: f64 }
+if ok { foo } else { $env?.str }
+if ok { foo } else { f64 }
+if ok { foo } else { foo }
+if ok { foo } else { greet }
+if ok { foo } else { ok }
+if ok { foo.Bar } else { 1 == 1.0 }
+if ok { greet } else { array }
+if ok { greet } else { f64 }
+if ok { greet } else { i }
+if ok { greet } else { str }
+if ok { i } else { date($env) }
+if ok { i } else { type(nil) }
+if ok { list } else { i }
+if ok { list } else { nil == true }
+if ok { list } else { ok }
+if ok { list } else { str }
+if ok { nil == false } else { greet }
+if ok { ok } else { $env.add }
+if ok { ok } else { array }
+if ok { ok } else { foo }
+if ok { ok } else { greet }
+if ok { str } else { array }
+if ok { str } else { i }
+if ok { str } else { ok }
+if ok { type(f64) } else { foo }
+if str == $env { foo?.String() } else { $env.foo }
+if str > str { str } else { find(array, ok) }
+if true && ok { array } else { greet }
+indexOf($env?.[str], str)
+indexOf(str, str)
+indexOf(toJSON(1.0), toJSON(true))
+int($env | count(ok))
+int($env | findIndex(ok))
+int($env | findIndex(true))
+int($env | sum(i))
+int($env.f64)
+int($env.i)
+int($env?.f64)
+int($env?.i)
+int(0 % 1)
+int(0 % i)
+int(0 * 1)
+int(0 * 1.0)
+int(0 ** 1.0)
+int(0 + 1)
+int(0 + 1.0)
+int(0 - 1.0)
+int(0 / 0)
+int(0 / 1)
+int(0 / i)
+int(0 ^ 0)
+int(0 ^ 1.0)
+int(0 ^ i)
+int(0 | bitshl(0))
+int(0 | bitshr(i))
+int(0 | bitxor(i))
+int(0 | min(1.0, 1))
+int(0) % count(array, true)
+int(0) * i
+int(0) + i
+int(0) - i
+int(0) .. i
+int(0) == i
+int(0) > 1.0 > 1
+int(0) ^ i
+int(0) | mean(i)
+int(0) | median(array)
+int(0)..i
+int(1 % 1)
+int(1 * 0)
+int(1 * 1.0)
+int(1 ** 1.0)
 int(1 ** i)
-int(1 + 1)
-int(1 + f32)
 int(1 + f64)
-int(1 + i32)
-int(1 - 0.5)
-int(1 - f32)
+int(1 - 1.0)
 int(1 - f64)
-int(1 - i32)
-int(1 - i64)
-int(1 / 0.5)
-int(1 / 1)
-int(1 ^ 0.5)
-int(1 ^ i64)
-int(1) != i64
-int(1) ** f32
-int(1) ** i32
-int(1) + f32
-int(1) + i64
-int(1) + reduce(array, #)
-int(1) - i
-int(1) < f64
-int(1) < i64 * 0.5
-int(1) == i32
+int(1 - i)
+int(1 / 1.0)
+int(1 / f64)
+int(1 ^ 0)
+int(1 ^ 1.0)
+int(1 | max(i))
+int(1) != i
+int(1) <= f64
+int(1) == f64
+int(1) == i
 int(1) ^ f64
-int(abs(0.5))
+int(1) not in array
+int(1.0 * 1)
+int(1.0 * 1.0)
+int(1.0 * f64)
+int(1.0 ** 0)
+int(1.0 ** 1.0)
+int(1.0 ** f64)
+int(1.0 + 0)
+int(1.0 + 1)
+int(1.0 - 1)
+int(1.0 / 0)
+int(1.0 / 1)
+int(1.0 / 1.0)
+int(1.0 ^ 1)
+int(1.0 ^ 1.0)
+int(1.0 ^ f64)
+int(1.0 ^ i)
+int(1.0 | min(f64))
+int(1.0)
+int(1.0) != 1.0 ^ i
+int(1.0) != f64
+int(1.0) != i
+int(1.0) * i
+int(1.0) ** f64
+int(1.0) / i
+int(1.0) == f64
+int(1.0) == i
+int(1.0) >= f64
+int(1.0) in array
+int(1.0) | median(array)
+int(1.0)..i
+int(abs(0))
 int(abs(1))
 int(abs(f64))
 int(abs(i))
-int(abs(i32))
-int(abs(i64))
-int(add(1, 1))
-int(array[i64])
+int(array | min(1.0))
+int(array | reduce(#))
+int(array | reduce(#index))
+int(array | sum(#))
+int(array?.[1])
+int(array?.[i])
+int(bitnot(0))
 int(bitnot(1))
-int(bitnot(i32))
-int(bitnot(i64))
-int(bitshl(1, i))
-int(bitxor(1, i32) + i)
-int(bitxor(i32, i))
-int(ceil(0.5))
+int(bitnot(i))
+int(bitshr(0, i))
+int(ceil($env?.i))
+int(ceil(0))
 int(ceil(1))
-int(ceil(f32))
-int(ceil(half(1)))
+int(ceil(f64))
 int(ceil(i))
-int(ceil(i32))
-int(count(array, ok))
+int(count($env, true))
 int(count(list, false))
-int(f32 * 1)
-int(f32 * i)
-int(f32 ** 0.5)
-int(f32 ** i64)
-int(f32 + f32)
-int(f32 - 0.5)
-int(f32 - i64)
-int(f32 / 0.5)
-int(f32 / 1)
-int(f32 / f64)
-int(f32 / i32)
-int(f32 / i64)
-int(f32 ^ f32)
-int(f32 ^ i32)
-int(f32)
-int(f32) != i
-int(f32) != i64
-int(f32) ** f64
-int(f32) + i32
-int(f32) - f32
-int(f32) < i
-int(f32) <= i32
-int(f32) == i ? list : add
-int(f64 * 0.5)
+int(count(list, ok))
+int(f64 * 0)
+int(f64 * 1)
+int(f64 * 1.0)
+int(f64 * f64)
 int(f64 ** 1)
 int(f64 ** i)
-int(f64 ** i32)
-int(f64 + 0.5)
-int(f64 + 1)
 int(f64 + i)
-int(f64 - 0.5)
-int(f64 - f32)
-int(f64 / 0.5)
-int(f64 / i64)
-int(f64 ^ 0.5)
-int(f64 ^ 1)
-int(f64 ^ f64)
-int(f64 ^ i64)
+int(f64 - 0)
+int(f64 - 1)
+int(f64 - 1.0)
+int(f64 - i)
+int(f64 / 0)
+int(f64 ^ 0)
+int(f64 ^ i)
+int(f64 | mean(i))
+int(f64 | min(1.0))
 int(f64)
-int(f64) % i64
-int(f64) * f64
-int(f64) + f64
-int(f64) < i32
-int(f64) == f32
-int(f64) == f64
-int(f64) > i
-int(f64) > i64
-int(false ? 0.5 : 0.5)
-int(false ? i : 0.5)
-int(findIndex(list, ok))
-int(findLastIndex(list, ok))
-int(first(array))
-int(float(0.5))
+int(f64) <= ceil(1.0)
+int(f64) <= f64
+int(f64) == i
+int(f64) in array
+int(findLast(array, true))
+int(findLastIndex($env, ok))
+int(float(0))
 int(float(1))
-int(float(f32))
+int(float(1.0))
 int(float(f64))
-int(float(i32 ** i))
-int(float(i32))
+int(float(i))
+int(floor(1.0))
 int(floor(f64))
 int(floor(i))
-int(floor(i32))
-int(get(array, i64))
-int(half(0.5))
-int(half(1))
-int(half(f64))
-int(i % 1)
-int(i % i32)
-int(i % i64)
-int(i * 0.5)
-int(i * 1)
-int(i * f64)
-int(i ** f32)
-int(i ** f64)
-int(i ** i64)
-int(i + f32)
-int(i + f64)
-int(i + i)
-int(i - 0.5)
-int(i - f32)
-int(i - i32)
-int(i - i64)
-int(i / 0.5)
-int(i / 1)
-int(i / i)
-int(i / i32)
-int(i ^ 0.5)
-int(i ^ 1)
-int(i ^ i32)
+int(i % i)
+int(i ** 1)
+int(i ** 1.0)
+int(i ** i)
+int(i + 0)
+int(i + 1)
+int(i + 1.0)
+int(i - 1)
+int(i - 1.0)
+int(i - i)
+int(i / 1.0)
+int(i | bitxor(1))
 int(i)
-int(i) != i32
-int(i) * f64
-int(i) * i64
-int(i) - i
-int(i) .. i64
-int(i32 * 0.5)
-int(i32 * 1)
-int(i32 * i64)
-int(i32 ** 0.5)
-int(i32 ** 1)
-int(i32 + 0.5)
-int(i32 + 1)
-int(i32 + f64)
-int(i32 + i64)
-int(i32 - 1)
-int(i32 - i)
-int(i32 / 0.5)
-int(i32 / 1)
-int(i32 / f64)
-int(i32 ^ 0.5)
-int(i32 ^ f64)
-int(i32 ^ i32)
-int(i32)
-int(i32) != f32
-int(i32) - i
-int(i32) / f32
-int(i32) / i
-int(i32) / i64
-int(i32) < i64
-int(i32) > half(0.5)
-int(i64 * 1)
-int(i64 ** 0.5)
-int(i64 ** f64)
-int(i64 ** i64)
-int(i64 + i)
-int(i64 + i32)
-int(i64 - 0.5)
-int(i64 - f32)
-int(i64 - i)
-int(i64 - i64)
-int(i64 / 1)
-int(i64 ^ f64)
-int(i64 ^ i32)
-int(i64 ^ i64)
-int(i64)
-int(i64) != i64
-int(i64) - i64
-int(i64) .. i32
-int(i64) / i
-int(i64) <= i
-int(i64) == f32
-int(i64) > i64
-int(i64) ^ i
-int(int(0.5))
+int(i) != f64
+int(i) * i
+int(i) .. i
+int(i) < i
+int(i) == sum(array)
+int(i) | min(array)
+int(if true { 1.0 } else { $env })
+int(int(0))
 int(int(1))
-int(int(f64))
-int(len("bar"))
+int(int(1.0))
+int(int(i))
+int(last(array))
+int(len($env))
+int(len(0 .. i))
 int(len(array))
-int(max(0.5))
-int(max(0.5, i64))
-int(max(1))
-int(max(f32))
+int(len(list))
+int(let foobar = 1.0; foobar)
+int(list | findLastIndex(ok))
+int(list | reduce(#index))
+int(list | reduce(0))
+int(list | reduce(1.0))
+int(list | sum(f64))
+int(max(0))
+int(max(1.0))
+int(max(array))
 int(max(f64))
 int(max(i))
-int(max(i64))
+int(mean(0))
+int(mean(1))
+int(mean(1.0))
+int(mean(1.0, f64))
 int(mean(array))
-int(min(0.5))
+int(median(0))
+int(median(1))
+int(median(1.0))
+int(median(array))
+int(median(f64))
+int(median(i))
+int(min(0))
 int(min(1))
-int(min(1, i64))
-int(min(f32))
+int(min(1.0))
+int(min(array))
 int(min(i))
-int(min(i32))
-int(min(i64))
-int(ok ? i : div)
-int(ok ? i : i64)
-int(ok ? i64 : list)
-int(reduce(array, #))
-int(reduce(array, f32))
-int(reduce(array, i32))
-int(reduce(list, 0.5))
-int(reduce(list, 1))
-int(reduce(list, i64))
-int(round(0.5))
+int(ok ? 1.0 : greet)
+int(ok ? f64 : list)
+int(reduce(list, 1.0))
 int(round(1))
-int(round(f32))
+int(round(1.0))
 int(round(f64))
 int(round(i))
-int(score(1))
-int(score(1, i))
-int(score(i))
-int(string(1))
-int(string(i))
-int(string(i32))
-int(string(i64))
+int(string(0))
+int(string(1.0))
+int(sum($env, i))
 int(sum(array))
-int(toJSON(i))
-int(toJSON(i32))
-int(toJSON(i64))
-int(true ? 1 : foo)
-int(true ? f64 : greet)
-join(map(array, "foo"))
-join(map(list, "foo"))
-keys(groupBy(array, "foo"))
-keys(groupBy(array, # ** 0.5))
-keys(groupBy(array, #))
-keys(groupBy(array, f32 != f64))
-keys(groupBy(array, foo))
-keys(groupBy(array, i32))
-keys(groupBy(array, ok))
-keys(groupBy(list, "bar"))
+int(sum(array, #))
+int(sum(array, f64))
+int(toJSON(0))
+int(toJSON(1))
+int(toJSON(1.0))
+int(toPairs($env) | reduce(i))
+int(true ? 1.0 : $env)
+int(true ? f64 : foo)
+join([str])
+join(array | map(str))
+join(keys($env))
+join(map(list, #.Bar))
+join(sort($env))
+keys($env) != array
+keys($env) == nil && true
+keys($env) | count(true)
+keys($env) | find(false)
+keys($env) | groupBy(#)
+keys($env) | groupBy($env?.i)
+keys($env) | map(#)
+keys($env) | map(1)
+keys($env) | map(1.0)
+keys($env) | map(add)
+keys($env) | map(f64)
+keys($env) | map(str)
+keys($env) | reduce(#)
+keys($env) | reduce(1.0)
+keys($env) | reduce(ok)
+keys($env) | sortBy(str)
+keys($env)?.[i]
+keys(array | reduce($env))
 keys(groupBy(list, #))
-keys(groupBy(list, false))
-keys(groupBy(list, i32))
-keys({"bar": 1})
-keys({"bar": array, "foo": "bar"})
-keys({"bar": f32})
-keys({"foo": array, "bar": f64})
-keys({"foo": array})
+keys(groupBy(list, foo))
+keys(max($env))
+keys(min($env))
+keys(reduce(list, $env))
+keys({foo: $env})
+keys({foo: 0})
+keys({foo: 1, foo: 0})
+keys({foo: 1, foo: false})
+keys({foo: 1.0})
+keys({foo: 1})
+keys({foo: add})
+keys({foo: array})
+keys({foo: f64})
+keys({foo: false})
+keys({foo: foo, foo: 0})
+keys({foo: foo, foo: 1.0})
+keys({foo: foo})
+keys({foo: greet})
+keys({foo: i, foo: true})
+keys({foo: i})
+keys({foo: nil})
+keys({foo: ok})
+keys({foo: str})
+keys({foo: true, foo: list})
+keys({foo: true})
+last($env | map(#index))
+last($env | map(1))
+last($env | map(add))
+last($env | map(foo))
+last($env | map(greet))
+last($env) == i
+last($env) == ok
+last($env) contains foo.Bar
+last($env) in array
+last($env) not contains foo.Bar
+last($env) not in array
+last($env) startsWith str
+last($env)?.Bar
+last($env)?.Bar()
+last($env)?.Bar()?.foo
+last($env)?.Bar(foobar)
+last($env)?.Bar?.[i]
+last($env)?.Bar?.greet
+last($env)?.String
+last($env)?.String()
+last($env)?.String().add
+last($env)?.[add]
+last($env)?.[array]
+last($env)?.[array].i
+last($env)?.[f64]
+last($env)?.[f64]?.f64(foobar, greet)
+last($env)?.[f64]?.foo()
+last($env)?.[foo]
+last($env)?.[foo].Bar
+last($env)?.[foo]?.foo
+last($env)?.[greet]
+last($env)?.[greet]?.[i]
+last($env)?.[greet]?.[ok]
+last($env)?.[i]
+last($env)?.[list]
+last($env)?.[list].greet
+last($env)?.[ok]
+last($env)?.[ok] != i
+last($env)?.[ok].ok()
+last($env)?.[str]
+last($env)?.[str]?.[foo]
+last($env)?.[str]?.i
+last($env)?.add
+last($env)?.add()
+last($env)?.add(f64)
+last($env)?.add.add()
+last($env)?.add.i
+last($env)?.add?.[ok]
+last($env)?.array
+last($env)?.array()
+last($env)?.array.list()
+last($env)?.f64
+last($env)?.f64()
+last($env)?.f64(greet(foobar))
+last($env)?.f64(list)
+last($env)?.f64?.[list]
+last($env)?.findLast(foo, foobar)
+last($env)?.foo
+last($env)?.foo()
+last($env)?.foo(String, foobar?.greet)
+last($env)?.foo?.[foo]
+last($env)?.foo?.[greet]
+last($env)?.greet
+last($env)?.greet()
+last($env)?.greet?.i
+last($env)?.i
+last($env)?.i()
+last($env)?.i.foo
+last($env)?.i?.greet
+last($env)?.i?.i
+last($env)?.list
+last($env)?.list()
+last($env)?.list.array
+last($env)?.none(foobar)?.String()
+last($env)?.ok
+last($env)?.ok()
+last($env)?.str
+last($env)?.str()
+last($env)?.str(foobar)
+last($env)?.str?.[list]
+last($env)?.toJSON(str)
+last($env.array)
+last($env.list)
+last($env?.$env)
+last($env?.Bar)
+last($env?.Bar)?.[add]
+last($env?.Bar)?.[f64]
+last($env?.Bar)?.[ok]
+last($env?.Bar)?.add()
+last($env?.Bar?.String)
+last($env?.Bar?.[list])
+last($env?.Bar?.[ok])
+last($env?.String)
+last($env?.String?.[add])
+last($env?.[Bar])
+last($env?.[Bar]?.[str])
+last($env?.[Bar]?.array)
+last($env?.[String])
+last($env?.[String])?.Bar
+last($env?.[String])?.[add]
+last($env?.[String])?.[foo]
+last($env?.[String]?.[foo])
+last($env?.[foobar])
+last($env?.[foobar])?.[f64]
+last($env?.[foobar])?.f64()
+last($env?.[foobar]?.str)
+last($env?.[nil])
+last($env?.[str])
+last($env?.array)
+last($env?.false)
+last($env?.foobar)
+last($env?.foobar)?.ok
+last($env?.foobar?.[greet])
+last($env?.list)
+last($env?.nil)
+last($env?.true)
+last(0 .. 0)
+last(0 .. 1)
+last(1 .. 0)
 last(1 .. 1)
 last(1 .. i)
-last([0.5])
-last([f32, list])
-last([list, list])
+last([$env, true])
+last([$env])
+last([$env]).i
+last([0])
+last([1, 0])
+last([1, nil])
+last([1.0])
+last([1])
+last([add])
+last([array, 0])
+last([array])
+last([f64])
+last([false, 0])
+last([false])
+last([foo, str])
+last([foo])
+last([greet])
+last([i])
+last([list])
+last([nil])
+last([ok])
+last([str])
+last(array | map(f64))
+last(array | map(false))
+last(array | reduce(#acc))
 last(array)
-last(array) != int(i64)
-last(array) + f64
-last(array) - f32
-last(array) - i64
-last(array) .. i32
-last(array) / f32
-last(array) <= i32
-last(array) == f32
-last(array) > f32 * i64
-last(array) >= f64
-last(false ? "foo" : true)
-last(false ? 0.5 : "bar")
-last(false ? 1 : foo)?.div
-last(false ? div : score)
-last(false ? f64 : false)
-last(filter(array, false))
-last(filter(array, ok))
+last(array) != i
+last(array) % i
+last(array) >= i
+last(false ? $env : $env)
+last(false ? $env : greet)
+last(false ? add : greet)
+last(false ? false : 1)
+last(false ? foo : greet)
+last(false ?: $env)
+last(false ?: add)
+last(filter($env, false))
+last(filter(array, true))
 last(filter(list, true))
-last(groupBy(array, foo).Qux)
-last(groupBy(array, i32).Qux)
-last(groupBy(list, #).list)
-last(groupBy(list, #)?.Qux)
-last(groupBy(list, #)?.ok)
-last(i32 .. 1)
-last(i32 .. i64)
-last(i64 .. 1)
+last(first($env))
+last(flatten(array))
+last(flatten(list))
+last(groupBy(list, f64)?.[ok])
+last(if ok { false } else { $env })
+last(if ok { foo } else { true })
+last(if ok { list } else { $env })
+last(if true { $env } else { 1.0 })
+last(if true { 1.0 } else { 1 })
+last(if true { add } else { ok })
+last(if true { list } else { array })
+last(keys($env))
+last(last($env))
+last(last($env)?.[list])
+last(list | map(foo))
+last(list | map(greet))
+last(list | map(ok))
+last(list | map(str))
+last(list | reduce(array))
+last(list | sortBy(0))
 last(list)
+last(list) == foo
 last(list).Bar
-last(list).Qux
 last(list).String
 last(list).String()
 last(list)?.Bar
-last(list)?.Qux
 last(list)?.String
 last(list)?.String()
-last(list[1:i64])
+last(list[1:])
+last(map($env, $env))
+last(map($env, f64))
+last(map($env, foo))
 last(map(array, #))
-last(map(array, 1))
-last(map(array, array))
-last(map(array, foo))
-last(map(array, i))
-last(map(list, "foo"))
+last(map(array, false))
 last(map(list, #))
-last(map(list, 1))
-last(map(list, false))
-last(map(list, half))
-last(map(list, i32))
-last(map(list, i64))
-last(map(list, ok))
-last(ok ? "bar" : true)
-last(ok ? "foo" : f64)
-last(ok ? 0.5 : "foo")
-last(ok ? 0.5 : list)
-last(ok ? 1 : add)
-last(ok ? 1 : half)
-last(ok ? array : array)
-last(ok ? array : ok)
-last(ok ? f32 : 0.5)
-last(ok ? greet : 1)
-last(ok ? i32 : array)
-last(ok ? i64 : add)
-last(ok ? ok : 0.5)
-last(reduce(array, list))
-last(reduce(list, array))
+last(map(list, 1.0))
+last(map(list, i))
+last(max($env))
+last(max($env?.Bar))
+last(max(0, array))
+last(max(array))
+last(mean(array))
+last(median(array))
+last(median(i, array))
+last(min($env))
+last(min(array))
+last(min(array, 1.0))
+last(min(if true { $env } else { f64 }))
+last(reduce(list, #acc))
+last(reduce(list, list, foo))
+last(reverse(array))
+last(reverse(list))
+last(sort($env))
 last(sort(array))
-last(true ? "bar" : half)
-last(true ? add : list)
-last(true ? foo : 1)
-last(true ? greet : true)
-last(true ? ok : 1)
-len("bar") ** i64
-len("bar") + i64 - i64
-len("bar") / i64
-len("bar") >= i
-len("bar") in array
-len("foo") ** i32
-len("foo") ** i64
-len("foo") - i
-len("foo") - i32
-len("foo") >= i
-len(1 .. 1)
-len([f32])
+last(sortBy(array, 0))
+last(toPairs($env))
+last(true ? 1.0 : greet)
+last(true ? array : 0)
+last(true ? foo : array)
+last(true ? list : 1)
+last(true ? str : 1.0)
+last(uniq(array))
+last(uniq(list))
+last(values($env))
+last({foo: $env}?.foobar?.add)
+last({foo: f64, foo: str}.foo)
+last({foo: foo, foo: 1}?.[str])
+last({foo: foo}.greet)
+lastIndexOf(str, str)
+len($env | filter(ok))
+len($env | map(1.0))
+len($env | map(foo))
+len($env | map(i))
+len($env | map(true))
+len($env) != f64
+len($env) ** int(f64)
+len($env) + i
+len($env) ^ 1.0 < f64
+len($env) ^ max(f64)
+len($env) ^ min(f64)
+len($env.array)
+len($env.list)
+len($env.str)
+len($env?.[str])
+len($env?.array)
+len($env?.list)
+len($env?.str)
+len(0 .. 0)
+len(0 .. i)
+len(1 .. 0)
+len([$env, 1.0])
+len([$env])
+len([0, str])
+len([1.0])
+len([1])
+len([add, i])
+len([add])
+len([f64, 0])
+len([f64])
+len([false])
+len([foo, 1])
+len([foo, foo])
+len([foo, i])
 len([foo])
-len([half])
+len([greet])
+len([list, f64])
+len([list])
+len([nil, foo, add])
+len([nil, nil])
+len([nil])
+len([ok])
+len([str])
+len([true])
+len(array | filter(false))
+len(array | groupBy(1))
+len(array | groupBy(true))
+len(array | map(#))
+len(array | sortBy(#))
 len(array)
-len(array) != f32
-len(array) + i64
-len(array) < f64
-len(array) <= i32
-len(array) == f32
-len(array) >= f64
-len(array) ^ i32
-len(array) not in array
-len(filter(list, false))
-len(filter(list, ok))
+len(array) * i
+len(array) - i
+len(array) == nil && false
+len(array) > findIndex(list, true)
+len(array[1:])
+len(array[:0])
+len(array[:1])
+len(array[:i])
+len(concat(array))
+len(concat(list))
+len(filter($env, ok))
+len(flatten(array))
+len(flatten(list))
+len(flatten(map($env, $env)))
 len(foo.Bar)
 len(foo.String())
 len(foo?.Bar)
-len(foo?.Qux("bar"))
 len(foo?.String())
-len(greet("bar"))
-len(greet("foo"))
-len(groupBy(array, #))
-len(groupBy(array, 0.5))
-len(groupBy(array, f32))
-len(groupBy(array, false))
-len(groupBy(array, i64))
-len(groupBy(array, true))
+len(greet(greet(str)))
+len(greet(str))
+len(groupBy(array, 1.0))
+len(groupBy(array, f64))
+len(groupBy(array, foo))
+len(groupBy(array, i))
 len(groupBy(list, #))
-len(groupBy(list, #).ok)
-len(groupBy(list, 0.5))
-len(groupBy(list, false))
-len(groupBy(list, foo).list)
-len(groupBy(list, i32))
-len(groupBy(list, i64))
-len(i64 .. 1)
-len(i64 .. i)
+len(groupBy(list, foo))
+len(if true { str } else { nil })
+len(keys($env))
+len(list | filter(false))
+len(list | filter(true))
+len(list | groupBy(#))
+len(list | groupBy(str))
+len(list | map(#.String))
+len(list | map($env))
+len(list | map(1))
+len(list | map(1.0))
+len(list | map(str))
+len(list | reduce(#.Bar))
 len(list)
-len(list) % i32
-len(list) % i64
-len(list) .. i64
-len(list) / i32
-len(list) <= i
+len(list) % i
+len(list) ** i
+len(list) == f64
 len(list) > i
 len(list) ^ f64
-len(list[1:i])
-len(lower("bar"))
-len(lower("foo"))
-len(map(array, "bar"))
+len(list)..i
+len(list[:])
+len(lower(str))
+len(map($env, 1))
+len(map($env, 1.0))
+len(map($env, array))
+len(map($env, f64))
+len(map($env, foo))
+len(map($env, str))
 len(map(array, #))
-len(map(array, add))
-len(map(array, f32))
-len(map(array, greet))
-len(map(array, i))
-len(map(array, list)[i64])
-len(map(array, score))
+len(map(array, $env))
+len(map(array, 1))
+len(map(array, foo))
 len(map(list, #))
-len(map(list, 1))
-len(map(list, f32))
 len(map(list, f64))
-len(map(list, foo))
-len(map(list, i64))
-len(map(list, ok))
-len(map(list, true))
-len(ok ? list : score)
-len(sort(array))
-len(string("bar"))
-len(string("foo"))
-len(string(0.5))
+len(max($env))
+len(min($env))
+len(reduce(array, $env))
+len(reduce(array, array))
+len(reduce(list, $env, foo))
+len(reverse(array))
+len(sort($env))
+len(sortBy(list, #.Bar))
+len(sortBy(list, .Bar))
+len(sortBy(list, 1))
+len(str)
+len(str) + 1.0 - i
+len(str) .. 0 | find($env)
+len(str) .. i
+len(str) == i
+len(str) >= f64
+len(str) | bitnand(1)
+len(str) | bitor(1)
+len(str) | mean(i)
+len(str) | median(1.0)
+len(str) | min(1.0)
+len(str[0:])
+len(str[1:])
+len(str[:1])
+len(string($env))
 len(string(1))
-len(string(add))
-len(string(f64))
+len(string(1.0))
+len(string(array))
+len(string(false))
 len(string(foo))
-len(string(half))
+len(string(greet))
 len(string(i))
-len(string(i32))
-len(string(i64))
 len(string(list))
 len(string(nil))
-len(string(score))
-len(string(string(list)))
-len(toJSON("bar"))
-len(toJSON("foo"))
-len(toJSON(0.5))
+len(string(ok))
+len(toBase64(str))
+len(toJSON(0))
 len(toJSON(1))
-len(toJSON(array))
-len(toJSON(f32))
 len(toJSON(false))
-len(toJSON(i))
-len(toJSON(i32))
+len(toJSON(foo))
 len(toJSON(list))
 len(toJSON(nil))
 len(toJSON(ok))
+len(toJSON(str))
 len(toJSON(true))
-len(trim("foo"))
-len(trimPrefix("foo"))
-len(trimSuffix("bar"))
-len(type("foo"))
-len(type(0.5))
+len(toPairs($env))
+len(trim(str))
+len(trimPrefix(str))
+len(trimSuffix(str))
+len(type($env))
+len(type(0))
 len(type(1))
+len(type(1.0))
 len(type(add))
 len(type(array))
-len(type(div))
-len(type(half))
+len(type(foo))
+len(type(greet))
 len(type(i))
-len(type(i32))
-len(type(i64))
 len(type(list))
 len(type(nil))
-len(type(ok))
-len(type(score))
-len(upper("bar"))
-len(upper("foo"))
-len({"bar": array})
-len({"bar": f64})
-len({"bar": score})
-len({"foo": 1})
-len({"foo": add, "foo": "foo"})
-len({"foo": i64})
+len(type(str))
+len(type(true))
+len(uniq(array))
+len(uniq(list))
+len(upper(str))
+len(values($env))
+len({foo: $env, foo: $env})
+len({foo: $env})
+len({foo: 0})
+len({foo: 1, foo: false})
+len({foo: 1.0, foo: f64})
+len({foo: 1.0})
+len({foo: 1})
+len({foo: add})
+len({foo: array, foo: 1.0})
+len({foo: array, foo: str})
+len({foo: array})
+len({foo: f64})
+len({foo: false})
+len({foo: foo, foo: 1.0})
+len({foo: foo, foo: foo})
+len({foo: foo, foo: nil})
+len({foo: foo})
+len({foo: greet, foo: str})
+len({foo: i, foo: $env})
+len({foo: i})
+len({foo: list})
+len({foo: nil})
+len({foo: ok, foo: $env})
+len({foo: ok})
+len({foo: str, foo: str})
+len({foo: str})
+len({foo: true})
+let foobar = $env not in array; foobar
+let foobar = $env.f64; i < foobar
+let foobar = $env.list; foobar
+let foobar = $env.str; foobar
+let foobar = $env; foobar == foobar
+let foobar = $env; foobar.Bar
+let foobar = $env; foobar.String
+let foobar = $env; foobar.add
+let foobar = $env; foobar.greet
+let foobar = $env; foobar.ok
+let foobar = $env; foobar.str
+let foobar = $env; foobar?.[str]
+let foobar = $env; foobar?.add
+let foobar = $env; foobar?.foobar
+let foobar = $env; foobar?.greet
+let foobar = $env; foobar?.i
+let foobar = $env; foobar?.list
+let foobar = $env; foobar?.str
+let foobar = $env?.[Bar]; foobar?.list
+let foobar = $env?.[String]; foobar
+let foobar = $env?.[String]; foobar?.[str]
+let foobar = $env?.f64; foobar > foobar
+let foobar = 0 + f64; foobar
+let foobar = 0; foobar <= foobar
+let foobar = 1 * 1.0; foobar
+let foobar = 1.0 != 1.0; foobar
+let foobar = 1.0; foobar * foobar
+let foobar = 1; foobar % foobar
+let foobar = 1; foobar < float(foobar)
+let foobar = add; $env != foobar
+let foobar = add; foobar
+let foobar = array | sortBy(1.0); foobar
+let foobar = array; foobar
+let foobar = array; foobar?.[0]
+let foobar = array; foobar?.[i]
+let foobar = array?.[i]; f64 + foobar
+let foobar = f64; foobar
+let foobar = f64; foobar ** f64
+let foobar = f64; foobar + foobar
+let foobar = f64; foobar == foobar
+let foobar = false; foobar != foobar
+let foobar = foo != nil; foobar || false
+let foobar = foo; foobar
+let foobar = foo; foobar.Bar
+let foobar = foo; foobar?.Bar
+let foobar = foo; foobar?.String
+let foobar = foo?.Bar; foobar
+let foobar = foo?.String; foobar
+let foobar = greet; foobar
+let foobar = greet; {foo: foobar}
+let foobar = i <= i; foobar
+let foobar = i; 1.0 == foobar
+let foobar = i; foobar
+let foobar = i; foobar != 0
+let foobar = i; foobar ** foobar / foobar
+let foobar = i; foobar == f64
+let foobar = i; foobar ^ foobar
+let foobar = i; {foo: foobar, foo: nil}
+let foobar = last(array); foobar
+let foobar = list; foobar
+let foobar = list; foobar != list
+let foobar = list; foobar?.[i]
+let foobar = list; reduce(foobar, foobar, $env)
+let foobar = map($env, 1); foobar
+let foobar = ok ? nil : $env; foobar?.Bar
+let foobar = ok; foobar
+let foobar = ok; foobar == foobar
+let foobar = str != $env; foobar
+let foobar = str != nil; foobar
+let foobar = str; foobar
+let foobar = str; {foo: foobar}
+let foobar = sum(array); foobar
+let foobar = toPairs($env); foobar
+let foobar = trimSuffix(str); foobar
+let foobar = {foo: 0}; foobar.ok
 list
-list != 1 .. 1
-list != ["foo"]
-list != [i, 0.5]
-list != [i]
+list != $env != false
+list != $env ? list : i
+list != $env or 1.0 > f64
+list != $env or false
+list != $env or ok
+list != $env.array
+list != $env.list
+list != $env?.Bar
+list != $env?.String
+list != $env?.[Bar]
+list != $env?.[String]
+list != $env?.[str]
+list != $env?.array
+list != $env?.foobar
+list != $env?.list
+list != $env?.nil
+list != [0]
 list != array
-list != filter(array, ok)
-list != filter(array, true)
+list != array and ok
+list != array or false
+list != array || $env
+list != flatten(list)
+list != i .. i
+list != keys($env)
 list != list
-list != list ? 0.5 : div
-list != list ? half : div
-list != map(array, #)
-list != map(list, 1)
-list != map(list, i64)
-list != nil && i32 <= 1
-list != nil ? false : 1
-list != nil ? i : 1
-list != sort(array)
-list == [div, nil]
-list == [i]
+list != list != ok
+list != list && true
+list != list and false
+list != map(list, str)
+list != min(array)
+list != nil ? ok : 1.0
+list != nil ?: list
+list != nil || false
+list != reverse($env.list)
+list != reverse(array)
+list == $env == nil
+list == $env == ok
+list == $env and false
+list == $env || $env
+list == $env.array
+list == $env.list
+list == $env?.$env
+list == $env?.Bar
+list == $env?.String
+list == $env?.[Bar]
+list == $env?.[String]
+list == $env?.[foobar?.list]
+list == $env?.[foobar?.str()]
+list == $env?.[foobar]
+list == $env?.[nil]
+list == $env?.[str]
+list == $env?.array
+list == $env?.foobar
+list == $env?.list
+list == 0 .. 1
+list == [0]
+list == [false]
+list == [foo]
+list == [greet, 0]
+list == [list]
+list == [nil]
+list == [str]
 list == array
-list == array == nil
+list == array ? nil : foo
+list == array ?: list
+list == array or ok
+list == array[:i]
+list == flatten(array)
+list == keys($env)
 list == list
-list == list != false
-list == list ? i32 : i
-list == map(list, #)
-list == nil && ok
-list == nil ? nil : "foo"
-list == nil or f64 == f64
-list not in groupBy(list, #).i
-list[-1]
-list[-i32]
-list[-i64]
-list[-i]
-list[1 - 1]
-list[1] not in list
-list[1].Bar
-list[1].Qux
-list[1].String
-list[1].String()
-list[1]?.Bar
-list[1]?.Qux
-list[1]?.String
-list[1]?.String()
-list[bitnot(i)]
-list[bitshr(i32, i32)]
-list[findIndex(array, true)]
-list[first(array)]
-list[i * i64]
-list[i32:i32]
-list[i32:i]
-list[i32]
-list[i32] in list
-list[i32].Bar
-list[i32].Qux
-list[i32].String
-list[i32]?.Bar
-list[i32]?.Qux
-list[i32]?.String
-list[i32]?.String()
-list[i64:i32 - i]
-list[i64:i64]
-list[i64]
-list[i64] in list
-list[i64].Bar
-list[i64].Qux
-list[i64].String
-list[i64]?.Bar
-list[i64]?.Qux
-list[i64]?.String
-list[i:i32]
-list[i:i64]
-list[i:i64] == nil != nil
+list == list and true
+list == map($env, str)
+list == nil && false
+list == nil == nil
+list == nil ? add : $env
+list == nil or $env
+list == reverse(array)
+list == toPairs($env)
+list == values($env)
+list in $env?.Bar
+list in $env?.String
+list in $env?.String?.f64
+list in $env?.[Bar]
+list in $env?.[Bar]?.[array]
+list in $env?.[String]
+list in $env?.[foobar]
+list in $env?.foobar
+list in [$env, 1.0]
+list in [$env, nil]
+list in [nil, $env]
+list in concat(list)
+list in last($env)
+list not in $env?.Bar
+list not in $env?.String
+list not in $env?.String?.[add]
+list not in $env?.String?.add
+list not in $env?.[Bar]
+list not in $env?.[String]
+list not in $env?.foobar
+list not in [array, true]
+list not in toPairs($env)
+list | all(# == nil)
+list | all($env | any(true))
+list | all(.Bar not in #)
+list | all(0 == nil)
+list | all(1.0 != f64)
+list | all(false && $env)
+list | all(false)
+list | all(false) ?: f64
+list | all(list != array)
+list | all(ok)
+list | all(true)
+list | any($env != #)
+list | any($env != 1.0)
+list | any($env == $env)
+list | any(.Bar in foo)
+list | any(false)
+list | any(nil == i)
+list | any(ok != nil)
+list | any(ok)
+list | any(true ?: nil)
+list | any(true)
+list | concat(array)
+list | concat(list)
+list | count(# != nil)
+list | count($env == #)
+list | count(1.0 != $env)
+list | count(1.0 != nil)
+list | count(false)
+list | count(false) | bitxor(i)
+list | count(ok)
+list | count(true != true)
+list | count(true and false)
+list | count(true)
+list | filter(# == #)
+list | filter(false)
+list | filter(i <= 1)
+list | filter(list == $env)
+list | filter(nil != #.String)
+list | filter(ok == nil)
+list | filter(ok)
+list | filter(ok) | sum(1.0)
+list | filter(str not startsWith .Bar)
+list | filter(true)
+list | filter(true) | groupBy(ok)
+list | filter(true) | sum(1.0)
+list | find(# != $env)
+list | find(# == #)
+list | find(# == $env)
+list | find(0 < 0)
+list | find(1.0 > 0)
+list | find(array | one(true))
+list | find(f64 > 1.0)
+list | find(false)
+list | find(foo == #)
+list | find(foo == foo)
+list | find(nil != $env?.f64)
+list | find(nil != foo)
+list | find(nil == foo)
+list | find(ok)
+list | find(true)
+list | findIndex(# != #)
+list | findIndex(# != foo)
+list | findIndex(false && $env)
+list | findIndex(false)
+list | findIndex(nil == .Bar)
+list | findIndex(ok == true)
+list | findIndex(ok)
+list | findIndex(true == ok)
+list | findIndex(true)
+list | findLast($env == $env)
+list | findLast($env == 0)
+list | findLast($env.ok)
+list | findLast(.Bar in foo)
+list | findLast(1.0 <= 1)
+list | findLast(f64 < 0)
+list | findLast(false)
+list | findLast(nil != str)
+list | findLast(ok)
+list | findLast(true)
+list | findLastIndex(# == #)
+list | findLastIndex(# == $env)
+list | findLastIndex($env != nil)
+list | findLastIndex(array == $env)
+list | findLastIndex(false or true)
+list | findLastIndex(false)
+list | findLastIndex(foo == #)
+list | findLastIndex(greet != $env)
+list | findLastIndex(nil not in list)
+list | findLastIndex(ok)
+list | findLastIndex(true)
+list | get(0)
+list | get(1)
+list | get(i)
+list | groupBy(# != nil)
+list | groupBy(#)
+list | groupBy(#.Bar)
+list | groupBy($env?.f64)
+list | groupBy(.Bar)
+list | groupBy(0 > i)
+list | groupBy(0)
+list | groupBy(1 / 1.0)
+list | groupBy(1)
+list | groupBy(1.0 >= 1.0)
+list | groupBy(1.0 in array)
+list | groupBy(1.0)
+list | groupBy(f64 + 1)
+list | groupBy(f64)
+list | groupBy(false && $env)
+list | groupBy(false)
+list | groupBy(foo)
+list | groupBy(i)
+list | groupBy(i) | get(true)
+list | groupBy(list?.[i])
+list | groupBy(ok)
+list | groupBy(ok) | get(str)
+list | groupBy(str)
+list | groupBy(string(#))
+list | groupBy(string(str))
+list | groupBy(toJSON(array))
+list | groupBy(true && ok)
+list | groupBy(true && true)
+list | groupBy(true)
+list | map(# != foo)
+list | map(#)
+list | map(#) == array
+list | map(#) | all(true)
+list | map(#) | findIndex(false)
+list | map(#) | get(0)
+list | map(#) | map(#)
+list | map(#) | one(false)
+list | map(#) | reduce(#)
+list | map(#.Bar)
+list | map(#.Bar) | reduce(#, nil)
+list | map(#.String())
+list | map(#.String)
+list | map(#index)
+list | map($env)
+list | map($env) == list
+list | map($env) | all(#.ok)
+list | map($env) | all(.ok)
+list | map($env) | any(true)
+list | map($env) | findLastIndex(#.ok)
+list | map($env) | groupBy(0)
+list | map($env) | map(#.i)
+list | map($env) | map(.ok)
+list | map($env) | reduce(str)
+list | map($env?.Bar)
+list | map($env?.String)
+list | map($env?.[Bar])
+list | map($env?.[String])
+list | map($env?.f64)
+list | map($env?.list)
+list | map($env?.str)
+list | map(.Bar)
+list | map(.String)
+list | map(.String) == array
+list | map(0)
+list | map(0) | map(array)
+list | map(1 > 1)
+list | map(1)
+list | map(1.0 * f64)
+list | map(1.0)
+list | map(1.0) | any(true)
+list | map(1.0) | map(str)
+list | map(1.0) | reduce(1.0)
+list | map([.Bar, str])
+list | map(add)
+list | map(array == nil)
+list | map(array)
+list | map(array) == array
+list | map(bitnot(i))
+list | map(f64)
+list | map(f64) | sum(#)
+list | map(false)
+list | map(false) | map(#)
+list | map(false) | sum(f64)
+list | map(foo == #)
+list | map(foo == $env)
+list | map(foo)
+list | map(foo) | groupBy(#)
+list | map(foo) | groupBy(true)
+list | map(foo) | reduce(#acc)
+list | map(foo.Bar)
+list | map(foo?.String)
+list | map(get($env, str))
+list | map(greet)
+list | map(greet) != array
+list | map(greet) | sortBy(i)
+list | map(i != 1.0)
+list | map(i / f64)
+list | map(i)
+list | map(if true { 1.0 } else { # })
+list | map(let foobar = str; foobar)
+list | map(list)
+list | map(list) | none(ok)
+list | map(nil != 1)
+list | map(ok)
+list | map(ok) | reduce(1.0, 0)
+list | map(sortBy(array, #))
+list | map(str)
+list | map(str) | groupBy(foo)
+list | map(str) | sortBy(f64)
+list | map(true || ok)
+list | map(true)
+list | map(true) | find(true)
+list | map(type(#))
+list | none(# != #)
+list | none(# == $env)
+list | none(#.Bar in foo)
+list | none($env != $env)
+list | none($env == #)
+list | none($env?.ok)
+list | none(1.0 <= 1)
+list | none(f64 <= f64)
+list | none(false)
+list | none(false) || ok
+list | none(foo != #)
+list | none(foo == #)
+list | none(i == 0)
+list | none(list | any(ok))
+list | none(nil == add)
+list | none(ok)
+list | none(true)
+list | one(# != foo)
+list | one(# != nil)
+list | one($env == $env)
+list | one($env == false)
+list | one(.Bar not endsWith str)
+list | one(0 != 1.0)
+list | one(add == nil)
+list | one(false)
+list | one(i == i)
+list | one(ok ?: 0)
+list | one(ok)
+list | one(str == str)
+list | one(true)
+list | reduce(#)
+list | reduce(#, $env)
+list | reduce(#, 0)
+list | reduce(#, 1)
+list | reduce(#, 1.0)
+list | reduce(#, add)
+list | reduce(#, array)
+list | reduce(#, f64)
+list | reduce(#, false)
+list | reduce(#, foo)
+list | reduce(#, greet)
+list | reduce(#, i)
+list | reduce(#, list)
+list | reduce(#, nil)
+list | reduce(#, ok)
+list | reduce(#, str)
+list | reduce(#, true)
+list | reduce(#.Bar)
+list | reduce(#.Bar, $env)
+list | reduce(#.Bar, 0)
+list | reduce(#.Bar, 1)
+list | reduce(#.Bar, array)
+list | reduce(#.Bar, f64)
+list | reduce(#.Bar, foo)
+list | reduce(#.Bar, greet)
+list | reduce(#.Bar, i)
+list | reduce(#.Bar, list)
+list | reduce(#.Bar, nil)
+list | reduce(#.Bar, ok)
+list | reduce(#.String == nil)
+list | reduce(#.String)
+list | reduce(#.String, $env)
+list | reduce(#.String, 1)
+list | reduce(#.String, f64)
+list | reduce(#.String, i)
+list | reduce(#.String, nil)
+list | reduce(#.String, true)
+list | reduce(#?.Bar)
+list | reduce(#?.String)
+list | reduce(#acc)
+list | reduce(#acc, $env)
+list | reduce(#acc, 1)
+list | reduce(#acc, 1.0)
+list | reduce(#acc, add)
+list | reduce(#acc, f64)
+list | reduce(#acc, foo)
+list | reduce(#acc, nil)
+list | reduce(#acc, str)
+list | reduce(#acc, true)
+list | reduce(#index - 0)
+list | reduce(#index <= 1)
+list | reduce(#index)
+list | reduce(#index, $env)
+list | reduce(#index, 1.0)
+list | reduce(#index, false)
+list | reduce(#index, foo)
+list | reduce(#index, list)
+list | reduce(#index, nil)
+list | reduce($env != #)
+list | reduce($env not in array)
+list | reduce($env)
+list | reduce($env, $env)
+list | reduce($env, 1)
+list | reduce($env, 1.0)
+list | reduce($env, add)
+list | reduce($env, f64)
+list | reduce($env, foo)
+list | reduce($env, greet)
+list | reduce($env, i)
+list | reduce($env, list)
+list | reduce($env, nil)
+list | reduce($env, ok)
+list | reduce($env, str)
+list | reduce($env, true)
+list | reduce($env.i)
+list | reduce($env?.String)
+list | reduce($env?.[String])
+list | reduce($env?.[foobar])
+list | reduce($env?.[str])
+list | reduce($env?.add)
+list | reduce($env?.greet, max(1))
+list | reduce(.Bar not in $env)
+list | reduce(.Bar)
+list | reduce(.Bar, 0)
+list | reduce(.Bar, 1.0)
+list | reduce(.Bar, i)
+list | reduce(.Bar, nil)
+list | reduce(.Bar, ok)
+list | reduce(.Bar, true)
+list | reduce(.String)
+list | reduce(.String, $env)
+list | reduce(.String, 0)
+list | reduce(.String, 1.0)
+list | reduce(.String, array)
+list | reduce(.String, foo)
+list | reduce(.String, greet)
+list | reduce(.String, i)
+list | reduce(.String, list)
+list | reduce(.String, nil)
+list | reduce(.String, ok)
+list | reduce(0 == f64)
+list | reduce(0)
+list | reduce(0) ^ f64
+list | reduce(0) | median(1.0)
+list | reduce(0, $env)
+list | reduce(0, 1.0)
+list | reduce(0, array)
+list | reduce(0, false)
+list | reduce(0, foo)
+list | reduce(0, i)
+list | reduce(0, list)
+list | reduce(0, nil)
+list | reduce(0, ok)
+list | reduce(0, true)
+list | reduce(1 ** #index) <= i
+list | reduce(1)
+list | reduce(1, $env)
+list | reduce(1, 1)
+list | reduce(1, 1.0)
+list | reduce(1, add)
+list | reduce(1, array)
+list | reduce(1, false)
+list | reduce(1, foo)
+list | reduce(1, greet)
+list | reduce(1, i)
+list | reduce(1, list)
+list | reduce(1, nil)
+list | reduce(1, ok)
+list | reduce(1, str)
+list | reduce(1, true)
+list | reduce(1.0 <= i)
+list | reduce(1.0 == 0)
+list | reduce(1.0)
+list | reduce(1.0, $env)
+list | reduce(1.0, 0)
+list | reduce(1.0, 1)
+list | reduce(1.0, array)
+list | reduce(1.0, f64)
+list | reduce(1.0, false)
+list | reduce(1.0, foo)
+list | reduce(1.0, greet)
+list | reduce(1.0, i)
+list | reduce(1.0, list)
+list | reduce(1.0, nil)
+list | reduce(1.0, str)
+list | reduce(1.0, true)
+list | reduce([ok, foo])
+list | reduce([true, #])
+list | reduce(add)
+list | reduce(add, $env)
+list | reduce(add, 1)
+list | reduce(add, 1.0)
+list | reduce(add, array)
+list | reduce(add, f64)
+list | reduce(add, false)
+list | reduce(add, foo)
+list | reduce(add, nil)
+list | reduce(array)
+list | reduce(array) | none(ok)
+list | reduce(array) | reduce(array)
+list | reduce(array, $env)
+list | reduce(array, 0)
+list | reduce(array, 1)
+list | reduce(array, 1.0)
+list | reduce(array, add)
+list | reduce(array, array)
+list | reduce(array, f64)
+list | reduce(array, false)
+list | reduce(array, foo)
+list | reduce(array, greet)
+list | reduce(array, i)
+list | reduce(array, nil)
+list | reduce(array, ok)
+list | reduce(array, str)
+list | reduce(f64 != nil)
+list | reduce(f64 <= 1.0)
+list | reduce(f64)
+list | reduce(f64, $env)
+list | reduce(f64, 0)
+list | reduce(f64, 1.0)
+list | reduce(f64, array)
+list | reduce(f64, f64)
+list | reduce(f64, false)
+list | reduce(f64, foo)
+list | reduce(f64, greet)
+list | reduce(f64, list)
+list | reduce(f64, nil)
+list | reduce(f64, str)
+list | reduce(false || $env)
+list | reduce(false)
+list | reduce(false, $env)
+list | reduce(false, 1)
+list | reduce(false, 1.0)
+list | reduce(false, array)
+list | reduce(false, f64)
+list | reduce(false, false)
+list | reduce(false, foo)
+list | reduce(false, greet)
+list | reduce(false, i)
+list | reduce(false, ok)
+list | reduce(false, true)
+list | reduce(first($env))
+list | reduce(float(1.0))
+list | reduce(foo == foo)
+list | reduce(foo)
+list | reduce(foo, $env)
+list | reduce(foo, $env.array)
+list | reduce(foo, 0)
+list | reduce(foo, 1)
+list | reduce(foo, 1.0)
+list | reduce(foo, add)
+list | reduce(foo, array)
+list | reduce(foo, f64)
+list | reduce(foo, foo)
+list | reduce(foo, greet)
+list | reduce(foo, i)
+list | reduce(foo, list)
+list | reduce(foo, nil)
+list | reduce(foo, ok)
+list | reduce(foo, str)
+list | reduce(foo, true)
+list | reduce(foo.Bar)
+list | reduce(greet)
+list | reduce(greet, $env)
+list | reduce(greet, 1.0)
+list | reduce(greet, add)
+list | reduce(greet, array)
+list | reduce(greet, false)
+list | reduce(greet, foo)
+list | reduce(greet, greet)
+list | reduce(greet, list)
+list | reduce(greet, nil)
+list | reduce(greet, str)
+list | reduce(greet, true)
+list | reduce(i ^ i)
+list | reduce(i)
+list | reduce(i, 0)
+list | reduce(i, 1.0)
+list | reduce(i, add)
+list | reduce(i, false)
+list | reduce(i, foo)
+list | reduce(i, greet)
+list | reduce(i, i)
+list | reduce(i, list) != $env?.String
+list | reduce(i, nil)
+list | reduce(i, str)
+list | reduce(list)
+list | reduce(list) | groupBy(0)
+list | reduce(list, $env)
+list | reduce(list, 1.0)
+list | reduce(list, add)
+list | reduce(list, array)
+list | reduce(list, foo)
+list | reduce(list, greet)
+list | reduce(list, i)
+list | reduce(list, nil)
+list | reduce(list, ok)
+list | reduce(list, str)
+list | reduce(ok and #acc)
+list | reduce(ok)
+list | reduce(ok, $env)
+list | reduce(ok, add)
+list | reduce(ok, false)
+list | reduce(ok, foo)
+list | reduce(ok, i)
+list | reduce(ok, list)
+list | reduce(ok, nil)
+list | reduce(ok, ok)
+list | reduce(reduce(list, .Bar), ok)
+list | reduce(str)
+list | reduce(str) >= foo.Bar
+list | reduce(str) contains str
+list | reduce(str, $env)
+list | reduce(str, 0)
+list | reduce(str, 1.0)
+list | reduce(str, add)
+list | reduce(str, array)
+list | reduce(str, f64)
+list | reduce(str, foo)
+list | reduce(str, i)
+list | reduce(str, list)
+list | reduce(str, ok)
+list | reduce(str, str)
+list | reduce(trim(str))
+list | reduce(true and ok)
+list | reduce(true)
+list | reduce(true, 0)
+list | reduce(true, array)
+list | reduce(true, f64)
+list | reduce(true, false)
+list | reduce(true, foo)
+list | reduce(true, i)
+list | reduce(true, ok)
+list | reduce(type(#))
+list | reduce(values($env))
+list | sortBy(#.Bar)
+list | sortBy(#.String())
+list | sortBy(#?.Bar)
+list | sortBy($env?.i)
+list | sortBy(.Bar)
+list | sortBy(0)
+list | sortBy(1)
+list | sortBy(1) | map(str)
+list | sortBy(1.0 ** 0)
+list | sortBy(1.0)
+list | sortBy(1.0) | filter(false)
+list | sortBy(1.0) | groupBy(true)
+list | sortBy(1.0) | map(.String)
+list | sortBy(1.0) | reduce($env)
+list | sortBy(f64 ** 0)
+list | sortBy(f64)
+list | sortBy(f64) == array
+list | sortBy(float(1))
+list | sortBy(greet(.Bar))
+list | sortBy(i)
+list | sortBy(i) | groupBy(0)
+list | sortBy(last(array))
+list | sortBy(str)
+list | sortBy(str) | count(ok)
+list | sum($env.i)
+list | sum(0 - 1.0)
+list | sum(0)
+list | sum(0) != i
+list | sum(0) >= 1.0 == false
+list | sum(1)
+list | sum(1) / 0 ** 1
+list | sum(1) | median(array)
+list | sum(1.0)
+list | sum(array | findLastIndex(true))
+list | sum(f64 * 1.0)
+list | sum(f64)
+list | sum(f64) in array
+list | sum(i)
+list | sum(int(i))
+list | take(0)
+list | take(1)
+list | take(1) | sum(0)
+list | take(i)
+list; $env.i
+list; add
+list; foo; $env.array
+list; foo?.Bar
+list; greet
+list; list
+list; nil == nil
+list; nil; foo?.String
+list; ok
+list; str
+list?.[$env.i]
+list?.[0 % 1]
+list?.[0]
+list?.[0].Bar
+list?.[0].String
+list?.[0]?.Bar
+list?.[0]?.String
+list?.[1 + 0]
+list?.[1]
+list?.[1].Bar
+list?.[1].String
+list?.[1].String()
+list?.[1]?.Bar
+list?.[array?.[0]]
+list?.[i]
+list?.[i] != foo && $env
+list?.[i] == foo
+list?.[i] == nil && $env
+list?.[i] not in list
+list?.[i].Bar
+list?.[i].String
+list?.[i].String()
+list?.[i]?.Bar
+list?.[i]?.String
+list?.[i]?.String()
+list?.[max(i)]
+list[$env.i:]
+list[$env?.i:]
+list[0:] | reduce(1.0)
+list[0:] | reduce(str)
+list[0:]?.[i]
+list[1 + 0:]
+list[1:] | findLast(true)
+list[1:] | map(0)
+list[1:] | map(ok)
+list[1:] | reduce(foo)
+list[:$env?.i]
+list[:0 * 0]
+list[:0] | findIndex(nil != foo)
+list[:1] | groupBy(ok)
+list[:]
+list[:] | map(#index)
+list[:]?.[i]
+list[:bitnot(1)]
+list[:i]
+list[:i] | filter(true)
+list[:i] | sum(f64)
+list[:mean(i)]
+list[:median(array)]
+list[:min(i)]
+list[:sum(array)]
+list[add(1, 0):]
+list[array?.[i]:]
+list[i:]
+list[i:] | groupBy(true)
+list[i:] | sortBy(0)
 list[i:i]
-list[i]
-list[i].Bar
-list[i].Qux
-list[i].String
-list[i].String()
-list[i]?.Bar
-list[i]?.Qux
-list[i]?.String
-list[i]?.String()
-list[int(f32)]
-list[int(f64)]
-list[int(i)]
-list[int(i64)]
-list[max(i64, 1)]
-list[min(i)]
-list[min(i32)]
-list[ok ? 1 : half]
-list[score(1)]
-list[score(i)]
-lower("bar" + "bar")
-lower("bar") == trimSuffix("bar")
-lower("foo" + "bar")
-lower(false ? foo : "bar")
+list[int(1.0):]
+list[min(array):]
+lower($env | reduce(str, 1.0))
+lower($env.str)
+lower($env?.[str])
+lower($env?.str)
+lower(false ? array : str)
 lower(foo.Bar)
 lower(foo.String())
 lower(foo?.Bar)
 lower(foo?.String())
-lower(greet("bar"))
-lower(greet("foo"))
-lower(lower("bar"))
-lower(lower("foo"))
-lower(reduce(array, "bar"))
-lower(reduce(list, "bar"))
-lower(string("foo"))
-lower(string(0.5))
+lower(greet(str))
+lower(greet(string(nil)))
+lower(greet(toJSON(array)))
+lower(list?.[i]?.Bar)
+lower(lower(str))
+lower(reduce(array, str))
+lower(str + str)
+lower(str | greet())
+lower(str)
+lower(str) == str
+lower(str) | greet()
+lower(str[1:])
+lower(string($env))
+lower(string(1))
+lower(string(1.0))
 lower(string(add))
-lower(string(f32))
+lower(string(array))
 lower(string(f64))
+lower(string(false))
 lower(string(foo))
-lower(string(greet))
-lower(string(i))
-lower(string(i32))
-lower(string(i64))
 lower(string(list))
 lower(string(nil))
-lower(string(score))
-lower(toBase64("foo"))
-lower(toBase64(string(i)))
-lower(toJSON("bar"))
-lower(toJSON("foo"))
-lower(toJSON(0.5))
-lower(toJSON(1))
+lower(string(ok))
+lower(string(str))
+lower(string(true))
+lower(toBase64(str))
+lower(toJSON(0))
+lower(toJSON(1.0))
+lower(toJSON(array))
 lower(toJSON(f64))
+lower(toJSON(false))
 lower(toJSON(foo))
+lower(toJSON(i))
 lower(toJSON(list))
 lower(toJSON(nil))
 lower(toJSON(ok))
+lower(toJSON(str))
 lower(toJSON(true))
-lower(trim("bar"))
-lower(trim("foo"))
-lower(trimPrefix("bar"))
-lower(trimPrefix("foo"))
-lower(trimSuffix("bar"))
-lower(type("bar"))
-lower(type("foo"))
-lower(type(0.5))
+lower(trimPrefix(str))
+lower(trimSuffix(str))
+lower(type($env))
 lower(type(1))
+lower(type(1.0))
 lower(type(add))
-lower(type(div))
-lower(type(f32))
-lower(type(half))
+lower(type(false))
+lower(type(foo))
 lower(type(i))
-lower(type(i32))
-lower(type(i64))
 lower(type(list))
+lower(type(nil))
 lower(type(ok))
+lower(type(str))
 lower(type(true))
-lower(upper("bar"))
-lower(upper("foo"))
-map(1 .. 1, f32)
-map(1 .. 1, foo)
-map(1 .. 1, score)
-map(1 .. i, foo)
-map(1 .. i32, #)
-map(1 .. i32, 0.5 / f64)
-map(1 .. i32, div)
-map(1 .. i32, reduce(array, #))
-map(1 .. i64, # ^ #)
-map(1 .. i64, #)
-map(1 .. i64, half)
-map(1 .. i64, i32)
-map([f64], half)
-map([false], ok)
-map([half], #)
-map([i * i32], score)
-map([i32, foo, score], #)
-map([i32], foo)
-map([i32], greet)
-map([i32], half)
-map([list, 1, foo], i32)
-map([nil], foo)
-map([score, "bar"], f32)
-map([true, i32, 1], #)
-map(array, !(# == #))
-map(array, !(nil in list))
-map(array, !ok)
-map(array, "bar" in foo)
-map(array, "foo" not endsWith "bar")
-map(array, "foo") == array
-map(array, # != #)
-map(array, # != 0.5)
-map(array, # != 1)
-map(array, # != f64)
-map(array, # != i32)
-map(array, # != nil)
-map(array, # % #)
-map(array, # % 1)
-map(array, # % i)
-map(array, # % i64)
-map(array, # * #)
-map(array, # * 0.5)
-map(array, # * 1)
-map(array, # * f32)
-map(array, # * f64)
-map(array, # * i)
-map(array, # ** #)
-map(array, # ** 1)
-map(array, # ** f32)
-map(array, # ** i)
-map(array, # ** i64)
-map(array, # + #)
-map(array, # + 0.5)
+map($env | map(foo), #.String)
+map($env, #index) | filter(false)
+map($env, #index) | map(greet)
+map($env, #index) | reduce(0, $env)
+map($env, $env) | count(ok)
+map($env, $env) | findLast(ok)
+map($env, $env) | map(array)
+map($env, $env) | map(foo)
+map($env, $env) | reduce($env)
+map($env, $env) | reduce(0)
+map($env, $env)?.[i]
+map($env, 0) != i .. 0
+map($env, 0) | map(str)
+map($env, 0) | reduce(ok, i)
+map($env, 0) | sortBy(1.0)
+map($env, 1) | count(ok)
+map($env, 1) | reduce(foo)
+map($env, 1) | sum(#)
+map($env, 1)?.[i]
+map($env, 1.0) | all(true)
+map($env, 1.0) | map(str)
+map($env, 1.0)?.[i]
+map($env, add) | map(false)
+map($env, add) | reduce(add, false)
+map($env, add) | sum(f64)
+map($env, add)?.[i]
+map($env, array) | findIndex(ok)
+map($env, array) | reduce(f64)
+map($env, f64) | count(ok)
+map($env, f64) | reduce(#)
+map($env, f64) | reduce(foo)
+map($env, f64) | sortBy(#)
+map($env, f64) | sum(#)
+map($env, f64)?.[i]
+map($env, false) | filter(false)
+map($env, false) | map(#)
+map($env, false) | map(greet)
+map($env, false) | reduce(str, nil)
+map($env, false)?.[i]
+map($env, foo) not in [add, f64]
+map($env, foo) | get(1)
+map($env, foo) | map(f64)
+map($env, foo) | map(greet)
+map($env, foo) | map(list)
+map($env, foo) | none(true)
+map($env, foo) | sortBy(str)
+map($env, foo)?.[i]
+map($env, greet) | map(greet)
+map($env, greet) | reduce(list)
+map($env, greet) | sortBy(i)
+map($env, greet)?.[i]
+map($env, i) | any(true)
+map($env, i)?.[i]
+map($env, list) | filter(false)
+map($env, list) | reduce(1.0)
+map($env, list) | reduce(list)
+map($env, list)?.[i]
+map($env, ok)?.[i]
+map($env, str) | find(ok)
+map($env, str) | find(true)
+map($env, str) | findIndex(false)
+map($env, str) | groupBy(#)
+map($env, str)?.[i]
+map($env, true) | any(#)
+map($env, true) | find(#)
+map($env, true) | map(#)
+map($env, true)?.[i]
+map($env.array, #)
+map($env.array, #index - 1.0)
+map($env.array, #index)
+map($env.array, add)
+map($env.array, foo)
+map($env.array, list)
+map($env.array, mean(0))
+map($env.list, #)
+map($env.list, #index)
+map($env.list, .String)
+map($env.list, array)
+map($env.list, f64 ^ f64)
+map($env.list, greet)
+map($env.list, list)
+map($env.list, ok)
+map($env.list, str)
+map($env?.[str], # ** #)
+map($env?.[str], #)
+map($env?.[str], array)
+map($env?.[str], greet)
+map($env?.[str], i != f64)
+map($env?.[str], list)
+map($env?.[str], median(0))
+map($env?.[str], nil != false)
+map($env?.[str], ok)
+map($env?.[str], str)
+map($env?.array, #)
+map($env?.array, $env?.i)
+map($env?.array, add)
+map($env?.array, all(list, true))
+map($env?.array, array)
+map($env?.array, f64)
+map($env?.array, list)
+map($env?.array, str)
+map($env?.list, # != $env)
+map($env?.list, #)
+map($env?.list, $env?.[String])
+map($env?.list, foo)
+map($env?.list, greet)
+map(1 .. 1, list)
+map([$env], #)
+map([$env], #.Bar not in #.array)
+map([$env], #?.f64)
+map([$env], 1 ^ 1.0)
+map([$env], add)
+map([$env], false != #)
+map([$env], greet)
+map([0], #)
+map([1.0], #)
+map([1.0], greet)
+map([1.0], ok)
+map([1], greet)
+map([false], list)
+map([foo], #)
+map([foo], #?.Bar)
+map([foo], add)
+map([foo], f64)
+map([foo], foo)
+map([foo], str)
+map([i, 1.0], #)
+map([i], str)
+map([list], f64 + 1.0)
+map([list], f64)
+map([nil], 1.0 <= 1)
+map([nil], list)
+map([nil], ok)
+map([ok], #)
+map([str], greet)
+map([true], foo)
+map(array | reduce($env), list)
+map(array, # ** 1.0)
 map(array, # + 1)
-map(array, # + f32)
-map(array, # + i)
-map(array, # + i32)
-map(array, # - #)
-map(array, # - 0.5)
-map(array, # - 1)
-map(array, # - f32)
-map(array, # - f64)
-map(array, # - i)
-map(array, # - i32)
 map(array, # .. #)
-map(array, # .. 1)
-map(array, # / #)
-map(array, # / 0.5)
-map(array, # / 1)
-map(array, # / f32)
-map(array, # / f64)
-map(array, # / i)
-map(array, # / i64)
-map(array, # < #)
-map(array, # < 1)
-map(array, # < f32)
-map(array, # < i32)
-map(array, # < i64)
 map(array, # <= #)
-map(array, # <= f32)
-map(array, # <= i)
-map(array, # <= i32)
+map(array, # <= 1.0)
 map(array, # == #)
-map(array, # == f32)
-map(array, # == f64)
-map(array, # == nil)
-map(array, # > #)
-map(array, # > 0.5)
-map(array, # > 1)
-map(array, # > f32)
-map(array, # > f64)
+map(array, # > 0)
 map(array, # >= #)
-map(array, # >= 1)
-map(array, # >= f32)
-map(array, # >= i32)
-map(array, # >= i64)
 map(array, # ^ #)
-map(array, # ^ 0.5)
-map(array, # ^ 1)
-map(array, # ^ i)
-map(array, # ^ i32)
-map(array, # not in array)
+map(array, # ^ 1.0)
 map(array, #)
-map(array, #) != array
-map(array, #) != list
-map(array, #) == array
-map(array, #) == list
-map(array, #)[i64]
-map(array, #)[i]
-map(array, -#)
-map(array, --#)
-map(array, -0.5)
-map(array, -1)
-map(array, -f64)
-map(array, -i)
-map(array, -i32)
-map(array, -i64)
-map(array, 0.5 != #)
-map(array, 0.5 != 0.5)
-map(array, 0.5 * #)
-map(array, 0.5 * f64)
-map(array, 0.5 ** f32)
-map(array, 0.5 ** i64)
-map(array, 0.5 + #)
-map(array, 0.5 + 1)
-map(array, 0.5 - #)
-map(array, 0.5 - 0.5)
-map(array, 0.5 / i)
-map(array, 0.5 < #)
-map(array, 0.5 < i32)
-map(array, 0.5 > #)
-map(array, 0.5 > i64)
-map(array, 0.5 >= #)
-map(array, 0.5 ^ #)
-map(array, 0.5)[i]
+map(array, #) | findLastIndex(true)
+map(array, #) | groupBy(#)
+map(array, #) | map($env)
+map(array, #) | map(bitnot(1))
+map(array, #) | map(foo)
+map(array, #) | sortBy(#)
+map(array, #)?.[i]
+map(array, #index)
+map(array, #index) | groupBy(ok)
+map(array, #index)?.[i]
+map(array, $env && true)
+map(array, $env == #)
+map(array, $env == true)
+map(array, $env)?.[i]
+map(array, $env.f64)
+map(array, $env.foo)
+map(array, $env.greet)
+map(array, $env.list)
+map(array, $env.str)
+map(array, $env?.String)
+map(array, $env?.[foobar])
+map(array, $env?.[str])
+map(array, $env?.add)
+map(array, $env?.greet)
+map(array, $env?.list)
+map(array, 0 != #)
+map(array, 0 - #)
+map(array, 0 | bitxor(#))
+map(array, 0) | find(false)
+map(array, 0) | map(array)
+map(array, 0) | sortBy(f64)
 map(array, 1 != #)
-map(array, 1 != f32)
-map(array, 1 % #)
-map(array, 1 ** #)
-map(array, 1 ** i)
-map(array, 1 ** i64)
-map(array, 1 + #)
-map(array, 1 + f64)
-map(array, 1 - #)
-map(array, 1 .. #)
-map(array, 1 / #)
-map(array, 1 / i32)
-map(array, 1 < #)
-map(array, 1 <= #)
-map(array, 1 <= 1)
-map(array, 1 <= f32)
-map(array, 1 == #)
-map(array, 1 ^ #)
-map(array, abs(#))
-map(array, abs(i64))
-map(array, add == nil)
-map(array, add(#, #))
-map(array, add(#, i))
+map(array, 1) | map(1)
+map(array, 1)?.[i]
+map(array, 1.0 != 1.0)
+map(array, 1.0 + #)
+map(array, 1.0 + 1.0)
+map(array, 1.0 == #)
+map(array, 1.0) | reduce(1.0)
+map(array, 1.0) | take(1)
+map(array, 1.0)?.[i]
+map(array, [#])
+map(array, [0, $env])
 map(array, add)
+map(array, add) | groupBy(foo)
 map(array, array)
-map(array, array)[bitnot(i32)]
-map(array, array)[i64]
-map(array, array[#:#])
-map(array, bitand(#, 1))
-map(array, bitnand(#, 1))
+map(array, array)?.[i]
 map(array, bitnot(#))
-map(array, bitnot(1))
-map(array, bitshl(#, #))
-map(array, bitshr(#, #))
-map(array, bitshr(#, i64))
-map(array, bitushr(1, #))
-map(array, ceil(#))
-map(array, ceil(0.5))
-map(array, ceil(f32))
-map(array, div(#, #))
-map(array, div)
-map(array, f32 * #)
-map(array, f32 * f64)
-map(array, f32 ** #)
-map(array, f32 + #)
-map(array, f32 / #)
-map(array, f32 < #)
-map(array, f32 == #)
-map(array, f32 > #)
-map(array, f32 >= #)
-map(array, f32 >= i)
-map(array, f32 ^ #)
-map(array, f32)
-map(array, f32)[min(i32)]
-map(array, f64 != #)
-map(array, f64 != 0.5)
-map(array, f64 * #)
-map(array, f64 ** #)
-map(array, f64 ** 0.5)
-map(array, f64 / #)
-map(array, f64 < #)
-map(array, f64 < f64)
-map(array, f64 <= #)
-map(array, f64 == #)
-map(array, f64 >= #)
-map(array, f64 >= i32)
-map(array, f64 ^ #)
+map(array, f64 - 1.0)
 map(array, f64)
-map(array, false && false)
-map(array, false ? # : f64)
-map(array, false ? greet : i)
-map(array, false)[i32]
-map(array, find(array, true))
-map(array, findIndex(list, ok))
-map(array, float(# + #))
+map(array, f64) != list
+map(array, f64)?.[i]
+map(array, false) | count(false)
+map(array, false) | reduce(greet)
+map(array, false) | sortBy(str)
+map(array, false)?.[i]
+map(array, flatten(array))
+map(array, flatten(list))
 map(array, float(#))
-map(array, floor(#))
+map(array, foo != $env)
 map(array, foo == foo)
 map(array, foo)
-map(array, foo.Bar)
-map(array, foo.Qux)
-map(array, foo.String())
+map(array, foo) != array
+map(array, foo) | count(true)
+map(array, foo) | findLastIndex(false)
+map(array, foo) | map(#.Bar)
+map(array, foo) | map(ok)
+map(array, foo) | reduce(list)
+map(array, foo) | reduce(str, f64)
+map(array, foo)?.[i]
+map(array, foo)[:]
 map(array, foo.String)
-map(array, foo?.Bar)
 map(array, foo?.String)
-map(array, get(array, #))
-map(array, greet("bar"))
-map(array, greet("foo"))
 map(array, greet)
-map(array, groupBy(array, #))
-map(array, groupBy(array, f32))
-map(array, groupBy(list, #))
-map(array, groupBy(list, f64))
-map(array, groupBy(list, i))
-map(array, half != half)
-map(array, half != nil)
-map(array, half(0.5))
-map(array, half(1))
-map(array, half(f64))
-map(array, half(i - 0.5))
-map(array, half)
-map(array, i % #)
-map(array, i + #)
-map(array, i - i32)
-map(array, i / 0.5)
-map(array, i <= #)
-map(array, i <= f32)
-map(array, i <= f64)
-map(array, i == #)
-map(array, i == f64)
-map(array, i > i32)
-map(array, i >= #)
+map(array, greet)?.[i]
+map(array, i < 0)
+map(array, i == #index)
 map(array, i)
-map(array, i)[i]
-map(array, i32 * #)
-map(array, i32 ** #)
-map(array, i32 ** f64)
-map(array, i32 / f32)
-map(array, i32 < #)
-map(array, i32 < f64)
-map(array, i32 == #)
-map(array, i32 == 1)
-map(array, i32 > #)
-map(array, i32 ^ #)
-map(array, i32 not in array)
-map(array, i32)
-map(array, i32) == array
-map(array, i32) == list
-map(array, i64 != #)
-map(array, i64 % #)
-map(array, i64 * #)
-map(array, i64 * 0.5)
-map(array, i64 + 0.5)
-map(array, i64 - #)
-map(array, i64 .. #)
-map(array, i64 < #)
-map(array, i64 <= #)
-map(array, i64 <= f64)
-map(array, i64 <= i64)
-map(array, i64 > #)
-map(array, i64)
-map(array, int(#))
-map(array, int(0.5))
-map(array, len("foo"))
-map(array, list != array)
+map(array, i) | find(ok)
+map(array, i)?.[i]
+map(array, int(#index))
+map(array, len($env))
+map(array, list == $env)
+map(array, list == list)
 map(array, list)
-map(array, map(array, f64))
-map(array, map(list, greet))
-map(array, max(#))
-map(array, max(f32, 1))
-map(array, max(f64))
-map(array, mean(array))
-map(array, min(#, #))
-map(array, nil == #)
-map(array, nil == ok)
-map(array, nil not in list)
-map(array, not ok)
-map(array, not true)
-map(array, ok || ok)
+map(array, list)?.[i]
+map(array, median(#))
+map(array, median(1.0))
+map(array, min(0))
+map(array, ok != true)
+map(array, ok || false)
 map(array, ok)
-map(array, ok)[i64]
-map(array, reduce(array, "bar"))
-map(array, reduce(array, #))
-map(array, reduce(list, add))
-map(array, reduce(list, half))
-map(array, round(#))
-map(array, score(#))
-map(array, score(#, #))
-map(array, score(1))
-map(array, score)
-map(array, string(add))
-map(array, string(foo))
-map(array, string(i64))
-map(array, take(array, #))
-map(array, toBase64("foo"))
-map(array, toJSON(#))
-map(array, toJSON(foo))
-map(array, toJSON(list))
-map(array, true != nil)
-map(array, true ? 0.5 : #)
-map(array, true ? 0.5 : 1)
-map(array, true ? f32 : div)
-map(array, true ? i : true)
-map(array, type(#))
-map(array, type(f32))
-map(array[1:i32], list)
-map(false ? i32 : list, ok)
-map(filter(array, false), foo)
-map(filter(array, ok), 1 * #)
-map(filter(list, # != #), #)
-map(filter(list, false), #)
-map(filter(list, ok), #)
-map(filter(list, ok), i)
-map(filter(list, true), i64)
-map(groupBy(array, #).String, i32)
-map(groupBy(array, #).greet, foo.Qux(.f32))
-map(groupBy(array, #).greet, score)
-map(groupBy(array, #).score, #?.list())
-map(groupBy(list, i32).i, #)
-map(i .. 1, -#)
-map(i .. 1, 0.5 ^ #)
-map(i .. 1, f32)
-map(i .. 1, i)
-map(i .. i, add(#, #))
-map(i .. i, div)
-map(i .. i, i32)
-map(i .. i32, half)
-map(i .. i64, min(#, #, #))
-map(i32 .. 1, half)
-map(i32 .. i, f32)
-map(i32 .. i32, array)
-map(i32 .. i64, div)
-map(i32 .. i64, list)
-map(i64 .. 1, #)
-map(i64 .. 1, 1 ^ #)
-map(i64 .. 1, array)
-map(i64 .. 1, f32)
-map(i64 .. 1, f64)
-map(i64 .. i32, #)
-map(i64 .. i64, # - #)
-map(i64 .. i64, #)
-map(list, !false)
-map(list, !ok)
-map(list, "bar" not matches "foo")
-map(list, "bar") != list
-map(list, "bar")[i64]
-map(list, "foo" not in foo)
-map(list, "foo" not matches #.Bar)
+map(array, ok) | count(1 >= 1.0)
+map(array, ok) | map(1)
+map(array, ok) | one(true)
+map(array, ok) | sum(1.0)
+map(array, reduce(array, foo, #index))
+map(array, sort(array))
+map(array, str == nil)
+map(array, str)
+map(array, str) == list
+map(array, str) | groupBy(#)
+map(array, str) | map(list)
+map(array, str) | reduce(#)
+map(array, str)?.[i]
+map(array, true) != array
+map(array, true)?.[i]
+map(array, type(1.0))
+map(concat(array), # == f64)
+map(concat(array), greet)
+map(false ? foo : list, $env.ok)
+map(filter(array, true), greet)
+map(flatten(array), #)
+map(flatten(array), i)
+map(list | map($env), #)
+map(list | map(.Bar), #)
+map(list | sortBy(1.0), .String)
+map(list | sortBy(1.0), string(#))
 map(list, # != #)
-map(list, # != nil)
 map(list, # == #)
-map(list, # in list)
+map(list, # == foo)
 map(list, #)
-map(list, #) != array
-map(list, #) == list
-map(list, #)[i64]
-map(list, #)[i]
-map(list, #?.Bar)
-map(list, #?.Qux)
-map(list, #?.String())
+map(list, #) | any(false)
+map(list, #) | any(ok)
+map(list, #) | findIndex(ok)
+map(list, #) | findLastIndex(ok)
+map(list, #) | groupBy(#)
+map(list, #) | groupBy(1.0)
+map(list, #) | groupBy(foo)
+map(list, #) | map(#)
+map(list, #) | map(1.0)
+map(list, #) | map(true)
+map(list, #) | one(true)
+map(list, #) | reduce(#.String, foo)
+map(list, #) | reduce(#acc, 1)
+map(list, #) | sortBy(1.0)
+map(list, #)?.[i]
+map(list, #.Bar <= #.Bar)
+map(list, #.Bar)
+map(list, #.String)
+map(list, #.String)?.[i]
 map(list, #?.String)
-map(list, -0.5)
-map(list, -f32)
-map(list, -i)
-map(list, -i32)
+map(list, #index + i)
+map(list, #index - 1)
+map(list, #index | add(i))
+map(list, #index)
+map(list, #index)?.[i]
+map(list, $env != nil)
+map(list, $env) | findIndex(.ok)
+map(list, $env) | findLastIndex(#.foo != #)
+map(list, $env) | map(1.0)
+map(list, $env)?.[i]
+map(list, $env.add)
+map(list, $env.f64)
+map(list, $env.foo)
+map(list, $env.greet)
+map(list, $env?.[.Bar])
+map(list, $env?.[Bar])
+map(list, $env?.add)
+map(list, $env?.array)
+map(list, $env?.greet)
+map(list, $env?.i)
+map(list, $env?.ok)
 map(list, .Bar)
-map(list, .Qux)
-map(list, .String())
 map(list, .String)
-map(list, 0.5 != 0.5)
-map(list, 0.5 != i64)
-map(list, 0.5 + i64)
-map(list, 0.5 - 0.5)
-map(list, 0.5 <= 0.5)
-map(list, 0.5 == i32)
-map(list, 0.5 in array)
-map(list, 0.5) != array
-map(list, 0.5) == array
-map(list, 1 % i)
-map(list, 1 ** 0.5)
-map(list, 1 ** f32)
-map(list, 1 + 1)
-map(list, 1 / f64)
-map(list, 1 / i64)
-map(list, 1 < 0.5)
-map(list, 1 <= i32)
-map(list, 1 ^ i32)
-map(list, [#])
-map(list, [foo, 0.5, #])
-map(list, [score])
-map(list, abs(f32))
+map(list, .String) | map(#)
+map(list, .String)?.[i]
+map(list, 0 <= 1.0)
+map(list, 0 > 1)
+map(list, 0) | groupBy(foo)
+map(list, 0) | sum(#)
+map(list, 1 == 1.0)
+map(list, 1) | groupBy(#)
+map(list, 1)?.[i]
+map(list, 1.0 / i)
+map(list, 1.0) | findLast(true)
+map(list, 1.0) | groupBy(#)
+map(list, 1.0) | reduce(foo)
+map(list, 1.0) | sortBy(#)
+map(list, 1.0)?.[i]
+map(list, [$env, nil, add])
+map(list, abs(1.0))
 map(list, add)
+map(list, add)?.[i]
 map(list, array)
-map(list, ceil(0.5))
-map(list, count(array, true))
-map(list, div)
-map(list, f32 != i32)
-map(list, f32 ** 1)
-map(list, f32 + i64)
-map(list, f32 < f32)
-map(list, f32 == 0.5)
-map(list, f32 > i64)
-map(list, f32 >= i)
-map(list, f32 >= i32)
-map(list, f32 ^ i)
-map(list, f32)
-map(list, f64 < 0.5)
-map(list, f64 < f32)
-map(list, f64 <= 1)
-map(list, f64 > 1)
-map(list, f64 >= 0.5)
-map(list, f64 >= f32)
+map(list, array) | one(ok)
+map(list, array) | one(true)
+map(list, bitnot(0))
+map(list, bitnot(i))
+map(list, ceil(1.0))
+map(list, f64 / 1.0)
 map(list, f64)
-map(list, f64)[i]
-map(list, false ? # : list)
-map(list, false) != array
-map(list, float(f64))
-map(list, float(i))
-map(list, float(i32))
-map(list, foo == #)
+map(list, f64) | groupBy(#)
+map(list, f64) | map($env)
+map(list, f64) | reduce(1)
+map(list, false) | map(#)
+map(list, floor(1.0))
 map(list, foo)
-map(list, foo.Qux)
-map(list, foo.String())
-map(list, foo?.String)
+map(list, foo) | reduce(#.String)
+map(list, foo) | reduce(1)
+map(list, foo) | sum(0)
+map(list, foo)?.[i]
+map(list, foo.Bar)
+map(list, foo.String)
+map(list, foo?.Bar)
+map(list, foo?.String())
+map(list, greet(#.Bar))
+map(list, greet(str))
 map(list, greet)
-map(list, groupBy(array, #))
-map(list, groupBy(array, i))
-map(list, groupBy(list, #))
-map(list, half(0.5))
-map(list, half(f64))
-map(list, half)
-map(list, i ** 1)
-map(list, i + i64)
-map(list, i .. i)
-map(list, i < 0.5)
-map(list, i == 1)
+map(list, greet) | findIndex(true)
+map(list, i >= 0)
 map(list, i)
-map(list, i)[i64]
-map(list, i32 % i64)
-map(list, i32 ** 0.5)
-map(list, i32 + f32)
-map(list, i32 - i32)
-map(list, i32 / f64)
-map(list, i32 < 1)
-map(list, i32 < i32)
-map(list, i32 <= 1)
-map(list, i32 >= 1)
-map(list, i32)
-map(list, i64 * i)
-map(list, i64 + i64)
-map(list, i64 <= i64)
-map(list, i64 == nil)
-map(list, i64)
-map(list, i64)[i64]
-map(list, i64)[i]
-map(list, last(array))
+map(list, i) | groupBy(# < #)
+map(list, i) | sortBy(#)
+map(list, i)?.[i]
 map(list, list)
-map(list, list)[i]
-map(list, map(array, #))
-map(list, map(array, 1))
-map(list, map(array, div))
-map(list, map(array, i64))
-map(list, map(list, "foo"))
-map(list, max(f32))
-map(list, min(0.5))
-map(list, min(f64))
-map(list, nil != #)
-map(list, nil != i64)
-map(list, nil == #)
-map(list, nil == ok)
-map(list, nil not in list)
-map(list, none(array, true))
-map(list, not ok)
-map(list, ok ? # : #)
-map(list, ok || ok)
+map(list, list) | sum(f64)
+map(list, list)?.[i]
+map(list, max(f64))
+map(list, nil != add)
+map(list, none($env, true))
+map(list, ok or ok)
 map(list, ok)
-map(list, reduce(array, half))
-map(list, reduce(list, foo))
-map(list, reduce(list, half))
-map(list, score(1))
-map(list, score)
-map(list, score)[i64]
+map(list, round(f64))
+map(list, str not in #)
+map(list, str)
+map(list, str) | findLast(false)
+map(list, str) | map(#)
+map(list, str) | reduce(#)
 map(list, string(#))
-map(list, string(1))
-map(list, string(add))
-map(list, string(i32))
-map(list, toJSON(#))
-map(list, toJSON([#]))
-map(list, toJSON(false))
-map(list, toJSON(ok))
-map(list, true ? i : f32)
-map(list, true ? i32 : #)
-map(list, true ? list : div)
-map(list, true)[i32]
-map(list, type("bar"))
+map(list, sum(array))
+map(list, trim(str))
+map(list, true ? array : f64)
+map(list, true)?.[i]
 map(list, type(#))
-map(list, type(i32))
-map(list, type(true))
-map(list[i64:i32], greet)
-map(map(array, #), # - i32)
-map(map(array, #), # == #)
-map(map(array, #), # >= #)
+map(list, type($env))
+map(list, upper(#.Bar))
 map(map(array, #), #)
-map(map(array, #), add)
-map(map(array, #), bitand(#, #))
-map(map(array, #), foo)
-map(map(array, #), greet)
-map(map(array, #), half)
-map(map(array, #), i % i64)
-map(map(array, #), i)
-map(map(array, #), i32)
-map(map(array, #), i64)
-map(map(array, #), list)
-map(map(array, 0.5), #)
-map(map(array, 0.5), ok)
-map(map(array, 1), greet)
-map(map(array, array), i32 ^ i32)
-map(map(array, array), i64)
-map(map(array, array), reduce(#, array))
-map(map(array, div), i)
-map(map(array, div), list)
-map(map(array, f32), #)
-map(map(array, f32), array)
-map(map(array, f32), f64)
-map(map(array, f64), # > #)
-map(map(array, f64), f64)
-map(map(array, f64), greet)
-map(map(array, foo), div)
-map(map(array, greet), foo)
-map(map(array, greet), list)
-map(map(array, half), array)
-map(map(array, i), #)
-map(map(array, i32), #)
-map(map(array, i64), array)
-map(map(array, i64), f64)
-map(map(array, list), foo)
-map(map(array, ok), !#)
-map(map(array, ok), -f32)
-map(map(array, true), # != nil)
-map(map(array, true), i64)
-map(map(list, #), # != #)
-map(map(list, #), #)
-map(map(list, #), #?.Qux)
-map(map(list, #), .Bar)
-map(map(list, #), div)
-map(map(list, #), f32)
-map(map(list, #), f64)
-map(map(list, #), greet)
-map(map(list, #), half)
-map(map(list, #), list)
-map(map(list, #), ok)
-map(map(list, #), score)
-map(map(list, 0.5), #)
-map(map(list, 0.5), div)
-map(map(list, 1), # * #)
-map(map(list, 1), f32)
-map(map(list, add), #)
-map(map(list, add), i)
-map(map(list, array), f64)
-map(map(list, array), findIndex(#, ok))
-map(map(list, f64), f32)
-map(map(list, f64), i32)
-map(map(list, false), 0.5 / f64)
-map(map(list, foo), #)
-map(map(list, foo), list)
-map(map(list, greet), "bar" <= "foo")
-map(map(list, i64), # >= f64)
-map(map(list, i64), #)
-map(map(list, i64), i64)
-map(map(list, list), #)
-map(map(list, ok), f64 > i64)
-map(map(list, ok), foo)
-map(map(list, true), f64)
-map(map(list, true), list)
-map(ok ? "bar" : i64, ok)
-map(ok ? "bar" : ok, i64)
-map(ok ? "bar" : score, 1 .. #)
-map(ok ? array : foo, foo)
-map(ok ? array : i64, list)
-map(ok ? list : i64, #)
-map(ok ? list : list, add)
-map(reduce(array, array), # <= #)
-map(reduce(array, array), #)
-map(reduce(list, array), -i32)
-map(reduce(list, array), foo)
-map(reduce(list, array), half)
-map(reduce(list, list), #)
-map(sort(array), # / 0.5)
-map(sort(array), #)
-map(sort(array), greet)
-map(split("foo", "bar"), #)
-map(true ? "foo" : 0.5, # * #)
-map(true ? array : "foo", f32 + #)
-map(true ? list : greet, greet)
-map(true ? list : list, #)
-max(-0.5)
-max(-1)
-max(-f32)
-max(-f64)
-max(-findIndex(array, ok))
-max(-i)
-max(-i, f32)
-max(-i32)
-max(-i64)
-max(-reduce(array, #))
-max(0.5 * f32)
-max(0.5 * i)
-max(0.5 * i64)
-max(0.5 ** 0.5)
-max(0.5 ** 1)
-max(0.5 ** f32)
-max(0.5 ** f64 ^ reduce(array, f64))
-max(0.5 ** i)
-max(0.5 ** i32)
-max(0.5 + 1)
-max(0.5 - 0.5)
-max(0.5 - f32)
-max(0.5 - f64)
-max(0.5 / 0.5)
-max(0.5 / 1)
-max(0.5 / f64)
-max(0.5 / i32)
-max(0.5 / i64)
-max(0.5 ^ 0.5)
-max(0.5 ^ 1)
-max(0.5 ^ i)
-max(0.5 ^ i32)
-max(0.5 ^ i64)
-max(0.5) != f32
-max(0.5) != i
-max(0.5) + f64
-max(0.5) + i
-max(0.5) - i32
-max(0.5) / i64
-max(0.5) <= i
-max(0.5) > f64
-max(0.5) > i
-max(0.5) > i64
-max(0.5) >= i64
-max(0.5, 0.5) != i
-max(0.5, i) ** i32
-max(1 % 1)
-max(1 % i64)
-max(1 * 0.5)
-max(1 * 1)
-max(1 * f64)
-max(1 * i32)
-max(1 ** 0.5)
-max(1 ** 1)
-max(1 ** f32)
-max(1 ** i64)
-max(1 + f32)
-max(1 + i64)
-max(1 - f32)
-max(1 - f64)
-max(1 / 1)
-max(1 / f32)
-max(1 / f32, i64)
-max(1 / f64)
-max(1 / i)
-max(1 / i32)
-max(1 / i64)
-max(1 ^ 0.5)
-max(1 ^ 1)
-max(1 ^ f32)
-max(1 ^ f64)
-max(1 ^ i32)
-max(1 ^ i64)
-max(1) != 1 ? foo : "bar"
-max(1) + f32
-max(1) - f64
+map(map(array, list), str)
+map(map(list, f64), ok)
+map(min($env), f64)
+map(reduce(array, $env), foo.String())
+map(reverse(array), str)
+map(sort($env), #.greet?.Bar(Bar))
+map(sort($env), lower(#))
+map(sort(array), ok)
+map(sortBy(array, str), # >= #index)
+map(uniq(list), reduce(list, foo))
+map(values($env), #)
+max($env | find(false))
+max($env | findIndex(ok))
+max($env | findLastIndex(ok))
+max($env | map(#index))
+max($env | map(0))
+max($env | sum(i))
+max($env) != $env?.array
+max($env) != greet
+max($env) == $env?.foo
+max($env) == list
+max($env) == ok
+max($env) | count($env.ok)
+max($env) | count(false)
+max($env) | count(true)
+max($env) | find(false)
+max($env) | map(1.0)
+max($env) | map(add)
+max($env) | map(f64)
+max($env) | map(greet)
+max($env) | map(i)
+max($env) | map(str)
+max($env) | sum(1.0)
+max($env).Bar
+max($env).Bar?.i().str
+max($env).String
+max($env).add
+max($env).array
+max($env).f64
+max($env).foo
+max($env).foobar?.[greet]
+max($env).foobar?.str
+max($env).greet
+max($env).greet(foobar)
+max($env).i
+max($env).list
+max($env).not
+max($env).ok
+max($env).str
+max($env)?.Bar
+max($env)?.String
+max($env)?.[str]
+max($env)?.[str]?.[i]
+max($env)?.add
+max($env)?.array
+max($env)?.array not in list
+max($env)?.f64
+max($env)?.foo
+max($env)?.foobar?.[greet]
+max($env)?.greet
+max($env)?.greet(foobar)
+max($env)?.i
+max($env)?.list
+max($env)?.list?.[f64]
+max($env)?.not
+max($env)?.ok
+max($env)?.str
+max($env.array)
+max($env.array, array)
+max($env.f64)
+max($env.i)
+max($env?.$env)
+max($env?.Bar)
+max($env?.Bar)?.[foo]
+max($env?.Bar)?.foo
+max($env?.Bar)?.list
+max($env?.String)
+max($env?.String)?.[i]
+max($env?.[Bar])
+max($env?.[String])
+max($env?.[String])?.[i]
+max($env?.[String]?.[f64])
+max($env?.[String]?.ok)
+max($env?.[foobar])
+max($env?.[nil])
+max($env?.[str])
+max($env?.[str]) | reduce(ceil(#))
+max($env?.array)
+max($env?.f64 ^ i)
+max($env?.f64)
+max($env?.f64, i)
+max($env?.false)
+max($env?.foobar)
+max($env?.i)
+max($env?.nil)
+max($env?.true)
+max(0 % 1)
+max(0 % i)
+max(0 * 0)
+max(0 * 1)
+max(0 * 1.0)
+max(0 ** f64)
+max(0 + 1)
+max(0 - 0)
+max(0 - 1.0)
+max(0 - f64)
+max(0 - i)
+max(0 .. 1, i)
+max(0 .. i)
+max(0 / 0)
+max(0 / 1)
+max(0 ^ 1)
+max(0 ^ 1.0)
+max(0 ^ f64)
+max(0 | min(1.0, 1.0))
+max(0) != 0 || ok
+max(0) - i
+max(0..i)
+max(0.1)
+max(1 ** 1.0)
+max(1 + 0)
+max(1 - 1.0)
+max(1 .. 1)
+max(1 / 1.0)
+max(1 ^ 0)
+max(1 ^ 1.0)
+max(1 | max(1.0))
+max(1) ** f64
 max(1) .. i
 max(1) / i
-max(1) == i64
-max(1) > f64
-max(1) > i32
-max(1, i) not in array
-max(abs(0.5))
+max(1, 1.0) in array
+max(1.0 * 0)
+max(1.0 * 1)
+max(1.0 * 1.0)
+max(1.0 * f64)
+max(1.0 * i)
+max(1.0 ** 0)
+max(1.0 ** 1.0)
+max(1.0 + 0)
+max(1.0 + 1)
+max(1.0 + 1.0)
+max(1.0 - 0)
+max(1.0 - 1.0)
+max(1.0 - f64)
+max(1.0 - i)
+max(1.0 / 0)
+max(1.0 / 1.0)
+max(1.0 ^ 0)
+max(1.0 ^ f64)
+max(1.0 ^ i)
+max(1.0)
+max(1.0) ** i
+max(1.0) < i
+max(1.0) <= $env.f64
+max(1.0) <= i
+max(1.0) > f64
+max(1.0) >= i
+max(1.0) ^ f64
+max(1.0) | min(array)
+max([1.0])
+max([1])
+max([array])
+max([i])
+max(abs(0))
 max(abs(1))
-max(abs(f32))
+max(abs(1.0))
 max(abs(f64))
 max(abs(i))
-max(abs(i32))
-max(add(1, i))
-max(array[1])
-max(array[i64])
-max(bitnand(i32, 1))
+max(array | get(i))
+max(array | map(1.0))
+max(array | map(i))
+max(array | reduce(#index))
+max(array | reduce($env, 0))
+max(array | reduce(1.0, foo))
+max(array | sortBy(#))
+max(array | sortBy(0))
+max(array | sortBy(f64))
+max(array | sum(0))
+max(array)
+max(array) != array
+max(array) - f64
+max(array) / median(1)
+max(array) == i
+max(array) == str
+max(array) > f64
+max(array, abs(i))
+max(array, array)
+max(array, f64)
+max(array, i)
+max(array?.[1])
+max(array?.[i])
+max(array[:])
+max(bitnot(0))
 max(bitnot(1))
 max(bitnot(i))
-max(bitnot(i64))
-max(bitshr(1, i32))
-max(bitxor(1, 1))
-max(ceil(0.5), f64 / i64)
-max(ceil(f32))
-max(ceil(i32))
-max(f32 * 1)
-max(f32 * f64)
-max(f32 * i64)
-max(f32 ** 1)
-max(f32 ** f64)
-max(f32 + 1)
-max(f32 + f64)
-max(f32 + i)
-max(f32 + i64)
-max(f32 - 1)
-max(f32 - i64)
-max(f32 / 0.5)
-max(f32 / f32)
-max(f32 ^ 1)
-max(f32 ^ f32)
-max(f32 ^ f64)
-max(f32 ^ i64)
-max(f32)
-max(f32) * i64
-max(f32) ** i
-max(f32) + f32
-max(f32) + f64
-max(f32) - f64
-max(f32) / i32
-max(f32) < i
-max(f32) == i
-max(f32) ^ f32
-max(f32, f32)
-max(f32, f64)
-max(f32, f64) in array
-max(f32, i)
-max(f32, i32)
-max(f32, i32) ** i64
-max(f32, i64)
-max(f64 * 1)
+max(ceil(0))
+max(ceil(1))
+max(ceil(1.0))
+max(concat(array))
+max(count(list, false))
+max(count(list, ok))
 max(f64 * f64)
-max(f64 ** 0.5)
-max(f64 ** f64)
-max(f64 ** i)
+max(f64 * i)
+max(f64 ** 1)
+max(f64 + 0)
 max(f64 + 1)
-max(f64 + f32)
-max(f64 + f64)
-max(f64 - 0.5)
-max(f64 - i)
-max(f64 ^ 0.5)
-max(f64 ^ 1)
-max(f64 ^ f32)
-max(f64 ^ f64)
+max(f64 ^ 1.0)
 max(f64)
 max(f64) != f64
-max(f64) < i32
-max(f64) <= f32
-max(f64) == f32
-max(f64) == i
-max(f64) == round(i)
-max(f64) ^ f32
-max(f64) ^ i64
-max(f64, f32)
-max(f64, f32) <= int(f64)
+max(f64) < i
+max(f64) <= 0 * f64
+max(f64) <= f64
+max(f64) >= f64
+max(f64) not in array
+max(f64, array)
+max(f64, array, array)
 max(f64, f64)
 max(f64, i)
-max(f64, i) - 1 ^ i
-max(f64, i) < i
-max(f64, i) > f64
-max(f64, i32)
-max(f64, i64)
-max(f64, i64) ^ f32
-max(false ? 0.5 : array)
-max(false ? add : f64)
-max(false ? div : half)
-max(false ? div : i64)
-max(false ? ok : 0.5)
-max(find(array, false))
-max(findIndex(list, false))
-max(findIndex(list, ok))
-max(findLast(array, false))
-max(float(0.5))
+max(false ? foo : 0)
+max(false ? nil : $env)
+max(false ?: foo)
+max(findLastIndex(array, false))
+max(findLastIndex(array, ok))
+max(findLastIndex(array, true))
+max(first($env))
+max(flatten(array))
+max(float(0))
 max(float(1))
-max(float(1), i)
-max(float(i32))
-max(float(i64))
-max(float(score(i)))
-max(floor(0.5))
+max(float(1.0))
+max(float(f64))
+max(float(i))
 max(floor(1))
-max(floor(f32))
 max(floor(i))
-max(floor(i32))
-max(floor(len(array)))
-max(get(array, 1))
-max(get(array, i))
-max(get(array, i32))
-max(get(array, i64))
-max(half(0.5))
-max(half(1))
-max(half(1), i64)
-max(half(f64))
 max(i % 1)
-max(i * 0.5)
-max(i * f32)
-max(i * i)
-max(i * i64)
+max(i % i)
+max(i * 1.0)
+max(i * i, i)
+max(i ** 1.0)
 max(i ** f64)
-max(i ** score(1))
-max(i + 1)
+max(i + 0)
+max(i + f64)
 max(i - 1)
-max(i - i)
-max(i - i64)
-max(i ^ f64)
+max(i - 1.0)
+max(i .. 0)
+max(i / 1)
+max(i / 1.0)
+max(i / i)
+max(i ^ 0)
+max(i ^ i)
+max(i | bitor(i))
+max(i | min(f64))
 max(i)
-max(i) != i32
-max(i) != i64
-max(i) % (i64 + i)
-max(i) % array[i32]
-max(i) ** (1 / i32)
-max(i) + f64
-max(i) - i
-max(i) / f32
-max(i) / i
-max(i) < 0.5 - f64
-max(i) < f32
-max(i) < i32
+max(i) < f64
 max(i) <= f64
-max(i) == f64
-max(i) >= i
-max(i, f32)
+max(i) not in array
+max(i) | bitxor(0)
+max(i, array)
 max(i, f64)
 max(i, i)
-max(i, i32)
-max(i, i64)
-max(i, i64, i32)
-max(i32 % 1)
-max(i32 * 0.5)
-max(i32 * 1)
-max(i32 * f32)
-max(i32 * i)
-max(i32 * i64)
-max(i32 ** f32)
-max(i32 ** i)
-max(i32 ** i32)
-max(i32 + 0.5)
-max(i32 + i64)
-max(i32 - 0.5)
-max(i32 - 1)
-max(i32 - f64)
-max(i32 - i)
-max(i32 / 1)
-max(i32 ^ i)
-max(i32 ^ i, f32)
-max(i32)
-max(i32) * i32
-max(i32) / f32
-max(i32) / i
-max(i32) <= f32
-max(i32) ^ f32
-max(i32) in array
-max(i32, f32)
-max(i32, f64)
-max(i32, i)
-max(i32, i32)
-max(i32, i64)
-max(i64 % i)
-max(i64 * 0.5)
-max(i64 * i64)
-max(i64 ** 0.5)
-max(i64 ** f32)
-max(i64 ** i64)
-max(i64 + i)
-max(i64 + i64)
-max(i64 - 0.5)
-max(i64 - 1)
-max(i64 - f64)
-max(i64 / f64)
-max(i64 / i32)
-max(i64 / i64)
-max(i64 ^ 0.5)
-max(i64 ^ 1)
-max(i64 ^ i)
-max(i64)
-max(i64) ** (1 + 1)
-max(i64) ** f32
-max(i64) + i32
-max(i64) - i32
-max(i64) - i64
-max(i64) .. i32
-max(i64) < f32
-max(i64) >= f32
-max(i64) ^ i
-max(i64, 0.5 + 1)
-max(i64, 0.5, i64) ** i32
-max(i64, f32)
-max(i64, f64)
-max(i64, half(1))
-max(i64, i)
-max(i64, i) + i32
-max(i64, i32)
-max(i64, i32) == f64
-max(i64, i64)
-max(int(0.5))
-max(int(f32))
-max(int(i32))
-max(int(i64))
-max(len("foo"))
-max(len(array))
+max(if false { ok } else { 1.0 })
+max(if ok { foo } else { 1.0 })
+max(if ok { ok } else { 0 })
+max(if true { $env } else { f64 })
+max(int(0))
+max(int(1))
+max(int(1.0))
+max(int(f64))
+max(int(i))
+max(last($env))
+max(last($env)?.ok)
+max(last(array))
+max(len($env))
 max(len(list))
-max(max(0.5))
-max(max(0.5, f64))
+max(len(str))
+max(let foobar = f64; foobar)
+max(list | count(ok))
+max(list | map(f64))
+max(list | reduce($env))
+max(list) startsWith str and false
+max(map($env, #index))
+max(map(array, 1))
+max(map(array, array))
+max(map(array, f64))
+max(map(list, 1))
+max(map(list, i))
+max(max($env))
+max(max(0))
 max(max(1))
+max(max(1.0))
+max(max(array))
+max(max(array?.[i]))
+max(max(f64))
 max(max(i))
-max(max(i32))
-max(max(i64))
+max(mean(0))
+max(mean(1))
+max(mean(1.0))
+max(mean(1.0, 1.0))
 max(mean(array))
+max(mean(f64))
+max(mean(i))
+max(mean(i), array)
+max(median(0))
+max(median(1.0))
 max(median(array))
-max(min(0.5, 0.5))
+max(median(array, 1))
+max(median(f64))
+max(median(i))
+max(min(0))
 max(min(1))
-max(min(1, f64))
-max(min(f32, i64, i32))
+max(min(1.0))
+max(min(array))
+max(min(f64))
 max(min(i))
-max(min(i32))
-max(ok ? "foo" : f64)
-max(ok ? 0.5 : i64)
-max(ok ? 1 : i)
-max(ok ? array : true)
-max(ok ? foo : greet)
-max(ok ? half : f32)
-max(ok ? half : list)
-max(ok ? i : 1)
-max(ok ? i : nil)
-max(reduce(array, # % #))
+max(ok ? 1.0 : nil)
+max(ok ? f64 : $env)
+max(reduce($env, i, foo))
 max(reduce(array, #))
-max(reduce(array, 1))
-max(reduce(array, f32))
-max(reduce(array, f64))
-max(reduce(list, 0.5))
-max(reduce(list, f32), i64)
-max(reduce(list, i64))
-max(round(1))
-max(round(f32))
-max(round(f64))
+max(reduce(array, #acc))
+max(reduce(array, $env))
+max(reduce(array, 1.0))
+max(reduce(list, 0))
+max(reduce(list, 1.0))
+max(reverse(array))
+max(round(1.0))
 max(round(i))
-max(round(i32))
-max(score(1))
-max(score(i), i)
-max(true ? f32 : f32)
-max(true ? foo : array)
-max(true ? greet : 1)
-max({"bar": list}.String)
-max({"foo": array}?.f32)
-max({"foo": half}?.f32)
-mean(1 .. 1)
-mean(1 .. i)
-mean([f64, 0.5])
+max(sort($env))
+max(sort(array))
+max(sortBy(array, #))
+max(sortBy(array, 1))
+max(sum($env, f64))
+max(sum(array))
+max(sum(array, #))
+max(sum(array, 1.0))
+max(sum(list, f64))
+max(true ? array : false)
+max(true ?: list)
+max(uniq(array))
+max({foo: $env}?.add)
+max({foo: true, foo: str}?.list)
+mean($env | map(0))
+mean($env | reduce(1.0, greet))
+mean($env | reduce(i, nil))
+mean($env.array)
+mean($env.array, median(0))
+mean($env.f64)
+mean($env.i)
+mean($env.i, i)
+mean($env.i, sort(array))
+mean($env?.array)
+mean($env?.f64)
+mean($env?.f64, array)
+mean($env?.f64, f64)
+mean($env?.i)
+mean($env?.i, mean(f64))
+mean(0 % 1)
+mean(0 * 1)
+mean(0 * 1.0)
+mean(0 ** 0)
+mean(0 ** 1)
+mean(0 ** f64)
+mean(0 ** f64, i)
+mean(0 + f64)
+mean(0 + i)
+mean(0 - 0)
+mean(0 - 1.0)
+mean(0 / 1)
+mean(0 / i)
+mean(0 ^ f64)
+mean(0) <= i
+mean(0) == f64
+mean(0) | max(f64)
+mean(0, 1.0) >= 1 == nil
+mean(1 % 1)
+mean(1 % i)
+mean(1 ** 0)
+mean(1 + 1)
+mean(1 + 1.0)
+mean(1 + f64)
+mean(1 .. 0)
+mean(1 / 0)
+mean(1 / 1.0)
+mean(1 ^ 1.0)
+mean(1 ^ f64)
+mean(1) * i
+mean(1) ** i
+mean(1) ^ bitnot(1)
+mean(1) not in array
+mean(1, 1) * f64
+mean(1, 1.0) < i
+mean(1, f64) / f64
+mean(1..i)
+mean(1.0 * 0)
+mean(1.0 * 1)
+mean(1.0 * i)
+mean(1.0 ** 0)
+mean(1.0 ** 1)
+mean(1.0 ** i)
+mean(1.0 + 1.0)
+mean(1.0 + i)
+mean(1.0 - 0)
+mean(1.0 - 1)
+mean(1.0 - 1.0)
+mean(1.0 - i)
+mean(1.0 / 1)
+mean(1.0 / 1.0)
+mean(1.0 / f64)
+mean(1.0 ^ 0)
+mean(1.0 ^ 1.0)
+mean(1.0 ^ f64)
+mean(1.0 ^ i)
+mean(1.0 | max(1.0))
+mean(1.0) * i
+mean(1.0) + i
+mean(1.0) / f64
+mean(1.0) >= i || true
+mean(1.0) ^ i
+mean(1.0) | max(array)
+mean([0, array])
+mean([0])
+mean([1.0])
+mean([1])
+mean([array])
+mean([f64, i])
+mean([i, 1.0])
 mean([i])
+mean(abs(0))
+mean(abs(1))
+mean(abs(1.0))
+mean(abs(f64))
+mean(abs(i), f64)
+mean(array | count(true))
+mean(array | findLastIndex(ok))
+mean(array | map(#index))
+mean(array | max(0))
+mean(array | max(1.0))
+mean(array | mean(array))
+mean(array | sortBy(#))
+mean(array | sortBy(1))
 mean(array)
-mean(array) * i
-mean(array) + i
-mean(array) - min(i)
-mean(array) / i
-mean(array) / i64
-mean(array) < f32
-mean(array) < f64
-mean(array) <= i64
-mean(array) > f32
-mean(array) >= f32
-mean(array) >= i64
-mean(array) ^ i
-mean(array) ^ i32
-mean(filter(array, true))
-mean(groupBy(array, i64).score)
+mean(array) != add
+mean(array) not in array
+mean(array) | median(array)
+mean(array, array)
+mean(array, f64)
+mean(array, f64, i)
+mean(array, i)
+mean(array?.[i])
+mean(array[:0])
+mean(bitnot(1))
+mean(bitnot(1)) ** f64
+mean(bitnot(i))
+mean(bitor(0, 0))
+mean(bitushr(1, 1))
+mean(ceil(0))
+mean(ceil(1))
+mean(ceil(1.0))
+mean(ceil(f64))
+mean(ceil(i))
+mean(concat(array))
+mean(f64 * 0)
+mean(f64 * 1.0)
+mean(f64 ** 1.0)
+mean(f64 ** i)
+mean(f64 + 1.0)
+mean(f64 - 1.0)
+mean(f64 - i)
+mean(f64 / 1.0)
+mean(f64 ^ 0)
+mean(f64 | min(1.0))
+mean(f64)
+mean(f64) * i
+mean(f64) - f64
+mean(f64) > i
+mean(f64) in $env?.array
+mean(f64, 0) | median(1)
+mean(f64, array)
+mean(f64, f64)
+mean(f64, i)
+mean(f64, sum(array))
+mean(false ? add : 1.0)
+mean(false ?: 1)
+mean(find(array, ok))
+mean(findIndex($env, true))
+mean(findLastIndex($env, true))
+mean(findLastIndex(array, true))
+mean(first(array), i * i)
+mean(flatten(array))
+mean(float(0))
+mean(float(1.0))
+mean(float(f64))
+mean(float(float(f64)))
+mean(float(i))
+mean(floor(0))
+mean(floor(1))
+mean(floor(1.0))
+mean(floor(f64))
+mean(floor(i))
+mean(floor(len(str)))
+mean(i * 1)
+mean(i * 1.0)
+mean(i ** 0)
+mean(i ** 1.0)
+mean(i ** i)
+mean(i + 1)
+mean(i + 1.0)
+mean(i - 1.0)
 mean(i .. 1)
 mean(i .. i)
+mean(i / 1)
+mean(i / i)
+mean(i ^ 1.0)
+mean(i | max(1, 1.0))
+mean(i | mean(1.0))
+mean(i)
+mean(i) ^ f64
+mean(i) in array
+mean(i, array)
+mean(i, f64)
+mean(i, float(f64))
+mean(i, i)
+mean(i, int(0))
+mean(if ok { 0 } else { foo })
+mean(int(0))
+mean(int(1))
+mean(int(1.0))
+mean(int(i))
+mean(last(array))
+mean(len(array))
+mean(list | filter(false))
+mean(list | reduce(1))
+mean(list | reduce(array))
+mean(list | reduce(f64))
+mean(map($env, 1))
+mean(map($env, array))
+mean(map($env, f64))
 mean(map(array, #))
-mean(map(array, -#))
-mean(map(array, f32))
-mean(map(array, i))
-mean(map(array, i32))
-mean(map(list, 1))
-mean(map(list, f32))
-mean(map(list, i))
-mean(map(list, i32))
-mean(sort(array))
-median(1 .. i)
+mean(map(array, 0))
+mean(map(array, f64))
+mean(map(list, 0))
+mean(map(list, array))
+mean(map(list, f64))
+mean(max(0))
+mean(max(1.0))
+mean(max(array))
+mean(max(f64))
+mean(max(i))
+mean(max(i), i)
+mean(mean(0))
+mean(mean(1))
+mean(mean(1.0))
+mean(mean(1.0, 0))
+mean(mean(array))
+mean(mean(f64))
+mean(mean(f64, f64))
+mean(mean(i))
+mean(median(0))
+mean(median(0, f64))
+mean(median(1))
+mean(median(1, 0))
+mean(median(1.0))
+mean(median(1.0, f64))
+mean(median(f64))
+mean(median(i))
+mean(min(1))
+mean(min(1, 1.0))
+mean(min(1.0))
+mean(min(1.0, array))
+mean(min(array))
+mean(min(i))
+mean(reduce($env, i, greet))
+mean(reduce(array, #))
+mean(reduce(array, 1.0))
+mean(reduce(list, 1))
+mean(reduce(list, array))
+mean(round(1))
+mean(round(1.0))
+mean(sort($env))
+mean(sortBy(array, #))
+mean(sortBy(array, 1.0))
+mean(sum($env, 1))
+mean(sum($env, 1.0))
+mean(sum($env, f64))
+mean(sum(array))
+mean(sum(array, #))
+mean(sum(array, 1.0))
+mean(true ? 0 : str)
+mean(uniq(array))
+median($env | findIndex(true))
+median($env | findLastIndex(ok))
+median($env | sum(0))
+median($env | sum(1.0))
+median($env.array)
+median($env.array, f64)
+median($env.f64)
+median($env.i)
+median($env.i, i)
+median($env?.array)
+median($env?.f64)
+median($env?.i)
+median($env?.i, $env.i)
+median(0 % 1)
+median(0 * 1)
+median(0 * 1.0)
+median(0 * f64)
+median(0 * i)
+median(0 ** 0)
+median(0 ** i)
+median(0 + 1)
+median(0 + 1.0)
+median(0 + i)
+median(0 - 0)
+median(0 - 1)
+median(0 - 1.0)
+median(0 .. 0)
+median(0 / 1.0)
+median(0 / i)
+median(0 ^ 1)
+median(0 | max(1))
+median(0) * i
+median(0) / f64
+median(0) >= i
+median(0) not in [nil]
+median(1 * 1)
+median(1 * 1.0)
+median(1 * i)
+median(1 ** i)
+median(1 + 0)
+median(1 + 1)
+median(1 + f64)
+median(1 + i)
+median(1 - 0)
+median(1 - 1)
+median(1 - 1.0)
+median(1 - f64)
+median(1 .. 0)
+median(1 / 1.0)
+median(1 ^ 0)
+median(1 ^ 0, f64)
+median(1 ^ i)
+median(1 | max(array), i)
+median(1) != 1.0 && ok
+median(1) ^ $env?.f64
+median(1.0 * f64)
+median(1.0 * i)
+median(1.0 ** 1.0)
+median(1.0 ** f64)
+median(1.0 ** i)
+median(1.0 + 0)
+median(1.0 + 1.0)
+median(1.0 + f64)
+median(1.0 + i)
+median(1.0 - 1)
+median(1.0 - 1.0)
+median(1.0 - i)
+median(1.0 / 1)
+median(1.0 / 1.0)
+median(1.0 / f64)
+median(1.0 / i)
+median(1.0 ^ 1)
+median(1.0 ^ f64)
+median(1.0 ^ i)
+median(1.0 | mean(i))
+median(1.0) + 1.0 != f64
+median(1.0) + i
+median(1.0) - f64
+median(1.0) / f64
+median(1.0) <= f64
+median(1.0) <= i / 0
+median(1.0) > 1.0 ? greet : list
+median(1.0) >= f64
+median(1.0) in array
+median(1.0) not in array
+median(1.0) | max(i)
+median(1.0, 0) ** f64
+median(1.1)
+median([0])
+median([1 % i])
+median([1, 1.0])
+median([1.0])
+median([1])
+median([1], $env.f64)
+median([array])
+median([i])
+median(abs(0))
+median(abs(1))
+median(abs(1.0))
+median(abs(f64))
+median(abs(i))
+median(add(1, 0))
+median(array | find(ok))
+median(array | map(#))
+median(array | reduce(1.0))
+median(array | reduce(i, foo))
+median(array | sortBy(#))
+median(array | sortBy(i))
+median(array | sum(#))
 median(array)
-median(array) != f32
-median(array) * 1 * f32
-median(array) * i32
-median(array) ** i64
-median(array) + f32
-median(array) >= i32
-median(array) ^ i32
-median(array) ^ i64
-median(array) not in array
-median(array[1:1])
-median(filter(array, ok))
-median(groupBy(list, #).i32)
+median(array) != ok
+median(array) / f64
+median(array) < i
+median(array) >= i
+median(array) ^ f64
+median(array, $env?.i)
+median(array, array)
+median(array, f64)
+median(array, i .. 0)
+median(array, i)
+median(array?.[i])
+median(array[0:])
+median(array[1:])
+median(bitand(1, 1))
+median(bitnot(0))
+median(bitnot(1))
+median(bitnot(i))
+median(ceil($env.i))
+median(ceil(0))
+median(ceil(1.0))
+median(ceil(f64))
+median(ceil(i))
+median(concat(array))
+median(count(array[0:0]))
+median(f64 * $env?.f64)
+median(f64 * f64)
+median(f64 ** $env?.i)
+median(f64 ** 1.0)
+median(f64 + 1.0)
+median(f64 + f64)
+median(f64 - 1.0)
+median(f64 - i)
+median(f64 / 1.0)
+median(f64 / f64)
+median(f64 ^ 1)
+median(f64 ^ f64)
+median(f64 | min(1.0))
+median(f64)
+median(f64) + i
+median(f64) < f64
+median(f64, array)
+median(f64, array) / 0 == 0
+median(f64, f64)
+median(f64, i)
+median(f64, i) + i
+median(f64, i, 1 - 0)
+median(f64, list | sum(i))
+median(filter(list, false))
+median(findIndex($env, true))
+median(first(array))
+median(flatten(array))
+median(float(0))
+median(float(1))
+median(float(1.0))
+median(float(f64))
+median(float(i))
+median(floor(0))
+median(floor(1))
+median(floor(1.0))
+median(floor(f64))
+median(floor(i))
+median(i % i)
+median(i * 0)
+median(i * 1)
+median(i * 1.0)
+median(i ** 0)
+median(i + 1)
+median(i - 1.0)
+median(i - i)
 median(i .. i)
-median(i .. i64)
-median(i64 .. i64)
-median(map(array, #))
-median(map(array, 1))
-median(map(list, 0.5))
-median(map(list, f32))
-median(map(list, i32))
-median(reduce(array, array))
-median(reduce(list, array))
+median(i / 0)
+median(i / 1.0)
+median(i ^ 1.0)
+median(i ^ f64)
+median(i ^ i)
+median(i | bitnand(i))
+median(i)
+median(i) | median(array)
+median(i) | min(f64)
+median(i, array)
+median(i, f64)
+median(i, floor(1))
+median(i, i)
+median(i..i)
+median(if false { $env } else { 1 })
+median(if false { 1.0 } else { i })
+median(int(1))
+median(int(1.0))
+median(int(1.0), array)
+median(int(f64))
+median(int(i))
+median(last(array))
+median(len($env))
+median(list | map(array))
+median(list | reduce(i))
+median(map($env, 1))
+median(map($env, f64))
+median(map(list, 1.0))
+median(max(0))
+median(max(1))
+median(max(1.0))
+median(max(1.0, i))
+median(max(i))
+median(mean(0))
+median(mean(1))
+median(mean(1.0))
+median(mean(1.0, i))
+median(mean(array))
+median(mean(f64))
+median(mean(i))
+median(median(0))
+median(median(1, 1.0))
+median(median(1.0))
+median(median(array))
+median(median(f64, i))
+median(median(i))
+median(min(0 * 1))
+median(min(0))
+median(min(1))
+median(min(array))
+median(min(f64))
+median(min(i))
+median(reduce(array, #))
+median(reduce(array, i))
+median(reduce(list, #index))
+median(reduce(list, 1.0))
+median(reverse(array))
+median(round(0))
+median(round(1))
+median(round(1.0))
+median(round(f64))
+median(round(i))
+median(sort($env))
 median(sort(array))
-min(-0.5)
-min(-0.5, i)
-min(-1)
-min(-f32)
-min(-f64)
-min(-half(0.5))
-min(-i)
-min(-i32)
-min(-i64)
-min(0.5 * 0.5)
-min(0.5 * 1)
-min(0.5 * f32, i32 ** i32)
-min(0.5 * f64)
-min(0.5 * i32)
-min(0.5 * i64)
-min(0.5 ** i)
-min(0.5 ** i64)
-min(0.5 + f64)
-min(0.5 + i)
-min(0.5 + i32)
-min(0.5 - 0.5)
-min(0.5 - 1)
-min(0.5 - f32)
-min(0.5 - f64)
-min(0.5 - i)
-min(0.5 / 0.5)
-min(0.5 / i64)
-min(0.5 / i64, i64)
-min(0.5 ^ 0.5)
-min(0.5 ^ f32)
-min(0.5 ^ i)
-min(0.5 ^ i32)
-min(0.5) != i64
-min(0.5) * i32
-min(0.5) ** f64
-min(0.5) ** i
-min(0.5) + f64 ^ i64
-min(0.5) - f32
-min(0.5) - f64
-min(0.5) / i32
-min(0.5) < i32
-min(0.5) == f32 / f32
-min(0.5) == i
-min(0.5) >= i64
-min(0.5) ^ (f32 - i64)
-min(0.5, 0.5) < f32 + f64
-min(1 % 1)
-min(1 % i)
-min(1 % i32)
-min(1 % i64)
-min(1 * 0.5)
+median(sum($env, 1.0))
+median(sum(array))
+median(sum(array), f64)
+median(sum(array, #))
+median(sum(list, i))
+median(true ? 0 : 1.0, f64)
+median(uniq(array))
+min($env | findIndex(false))
+min($env | map(1))
+min($env | map(1.0))
+min($env | reduce(array, 1))
+min($env | sum(1.0))
+min($env | sum(f64))
+min($env) != array
+min($env) == greet
+min($env) == i
+min($env) | all(false)
+min($env) | any(false)
+min($env) | count(ok)
+min($env) | map(f64)
+min($env) | reduce(0, 1)
+min($env) | sum(0)
+min($env).Bar
+min($env).String
+min($env).add
+min($env).array
+min($env).f64
+min($env).false?.f64
+min($env).foo
+min($env).foobar
+min($env).foobar?.ok
+min($env).greet
+min($env).i
+min($env).list
+min($env).nil?.foobar
+min($env).ok
+min($env).str
+min($env)?.Bar
+min($env)?.Bar?.foobar.foo().list
+min($env)?.String
+min($env)?.[str]
+min($env)?.add
+min($env)?.array
+min($env)?.f64
+min($env)?.foo
+min($env)?.foobar
+min($env)?.foobar?.foo.i
+min($env)?.greet
+min($env)?.i
+min($env)?.list
+min($env)?.not
+min($env)?.ok
+min($env)?.str
+min($env.array)
+min($env.array, sum(array))
+min($env.f64)
+min($env.i)
+min($env?.$env)
+min($env?.Bar)
+min($env?.String)
+min($env?.[Bar])
+min($env?.[Bar])?.add()
+min($env?.[Bar]?.Bar)
+min($env?.[Bar]?.[greet])
+min($env?.[String])
+min($env?.[String])?.f64
+min($env?.[foobar])
+min($env?.[str])
+min($env?.array)
+min($env?.f64)
+min($env?.f64, i)
+min($env?.false)
+min($env?.foobar)
+min($env?.i)
+min($env?.nil)
+min($env?.true)
+min(0 * 1)
+min(0 * 1.0)
+min(0 * f64)
+min(0 ** 0)
+min(0 ** 1.0)
+min(0 ** i)
+min(0 + f64)
+min(0 - 1.0)
+min(0 - f64)
+min(0 - i)
+min(0 .. i)
+min(0 / 0)
+min(0 ^ 1)
+min(0 | bitshl(1))
+min(0) * 0 < f64
+min(0) * f64
+min(0) ** f64
+min(0) + i
+min(0) - ceil(i)
+min(0) ^ f64
+min(0) in array
+min(0) | max(0)
+min(0.0)
 min(1 * 1)
-min(1 * f32)
-min(1 * i)
-min(1 * i32)
+min(1 ** 0)
+min(1 ** 1.0)
 min(1 ** i)
-min(1 + 0.5)
-min(1 + 1)
-min(1 + f32)
-min(1 + i64)
-min(1 - 1)
+min(1 + 1.0)
 min(1 - f64)
-min(1 - i)
-min(1 - i32)
-min(1 - i64)
-min(1 / 0.5)
-min(1 / f32)
+min(1 / 0)
+min(1 / 1)
+min(1 / 1.0)
 min(1 / i)
-min(1 / i32)
-min(1 / i64)
-min(1 ^ 0.5)
-min(1 ^ 1)
-min(1 ^ f32)
-min(1 ^ i)
-min(1 ^ i32)
-min(1 ^ i64)
-min(1) != i
-min(1) - i
-min(1) .. i32
-min(1) <= f32
-min(1) <= f64
-min(1) > i64
-min(1) >= i
-min(1) >= i64
-min(1) ^ f64
-min(abs(0.5))
+min(1 ^ 0)
+min(1 | min(1.0))
+min(1) % i
+min(1) < f64
+min(1) < i
+min(1) <= i
+min(1, 1.0) in array
+min(1..i)
+min(1.0 * 1.0)
+min(1.0 * f64)
+min(1.0 ** 0)
+min(1.0 ** 1)
+min(1.0 ** i)
+min(1.0 + 0)
+min(1.0 + 1)
+min(1.0 + 1.0)
+min(1.0 + i)
+min(1.0 - 0)
+min(1.0 - 1)
+min(1.0 - f64)
+min(1.0 - i)
+min(1.0 / 1)
+min(1.0 / 1.0)
+min(1.0 / f64)
+min(1.0 ^ 1)
+min(1.0 ^ 1.0)
+min(1.0 ^ f64)
+min(1.0 | max(array))
+min(1.0 | min(1.0))
+min(1.0) ** i
+min(1.0) - f64
+min(1.0) <= 1.0 + 0
+min(1.0) > i
+min(1.0) >= i
+min(1.0) not in array
+min(1.0, 0) + i
+min(1.1)
+min([0])
+min([1.0])
+min([1])
+min([array])
+min([f64, 0])
+min([f64])
+min([i])
+min(abs(0))
 min(abs(1))
-min(abs(f32))
+min(abs(1.0))
 min(abs(f64))
-min(abs(i))
-min(abs(i32))
-min(array[1])
-min(array[i32])
-min(array[i])
-min(bitnand(1, i32))
+min(add(0, 0))
+min(array | find(ok))
+min(array | findIndex(false))
+min(array | findIndex(ok))
+min(array | map(#))
+min(array | reduce(#))
+min(array | reduce(0))
+min(array | reduce(1.0))
+min(array | sortBy(0))
+min(array | sortBy(1.0))
+min(array | sum(#))
+min(array | sum(1.0))
+min(array)
+min(array) .. i
+min(array) / i
+min(array) < 1.0 - i
+min(array) | bitushr(0)
+min(array) | get(str)
+min(array) | median(0)
+min(array, 1 - 0)
+min(array, array)
+min(array, ceil(0))
+min(array, f64)
+min(array, float(1.0))
+min(array, i)
+min(array, int(0))
+min(array, sortBy(array, #))
+min(array?.[i])
+min(array[:0])?.[greet]
+min(array[min(1):])
 min(bitnot(1))
 min(bitnot(i))
-min(bitnot(i32))
-min(bitnot(i32), i64)
-min(bitnot(i64))
-min(ceil(0.5))
 min(ceil(1))
-min(ceil(f32))
+min(ceil(1.0))
 min(ceil(f64))
 min(ceil(i))
-min(count(array, false))
-min(count(list, ok))
-min(f32 * 1)
-min(f32 * i64)
-min(f32 ** 0.5)
-min(f32 - 0.5)
-min(f32 - 1)
-min(f32 - f64)
-min(f32 - i)
-min(f32 - i64)
-min(f32 / 1)
-min(f32 / i64)
-min(f32 ^ i32)
-min(f32)
-min(f32) * i64
-min(f32) / f64
-min(f32) / i32
-min(f32) == i
-min(f32) >= f64
-min(f32, -0.5)
-min(f32, ceil(1))
-min(f32, f32)
-min(f32, f64)
-min(f32, i)
-min(f32, i32)
-min(f32, i64)
-min(f64 * 1)
+min(count($env, false))
+min(count($env, ok))
 min(f64 * f64)
-min(f64 ** f32)
+min(f64 ** 1)
+min(f64 ** 1.0)
 min(f64 ** f64)
-min(f64 + 0.5)
-min(f64 + f32)
-min(f64 + i64)
-min(f64 - 1)
+min(f64 + 0)
+min(f64 + 1.0)
+min(f64 + f64)
+min(f64 - 0)
+min(f64 - 1.0)
 min(f64 - i)
-min(f64 - i32)
-min(f64 / 0.5)
-min(f64 / f32)
-min(f64 / i)
-min(f64 / i64)
+min(f64 / 1)
+min(f64 / 1.0)
+min(f64 ^ 0)
 min(f64 ^ 1)
+min(f64 ^ 1.0)
+min(f64 ^ f64)
+min(f64 ^ i)
 min(f64)
-min(f64) * f64
-min(f64) * i32
-min(f64) / i
-min(f64) >= f64
-min(f64, 0.5 ** i64)
-min(f64, 0.5) == f64
-min(f64, f32)
+min(f64) <= $env.i
+min(f64) not in array
+min(f64, 1.0 / 1.0)
+min(f64, abs(f64))
+min(f64, array)
 min(f64, f64)
 min(f64, i)
-min(f64, i32)
-min(f64, i64)
-min(false ? foo : i32)
-min(false ? greet : f32)
-min(find(array, false))
-min(find(array, ok))
-min(findIndex(array, false))
-min(findLastIndex(array, i32 > #))
-min(findLastIndex(array, ok))
-min(findLastIndex(array, true))
-min(findLastIndex(list, ok))
+min(f64, min(1.0))
+min(false ? 0 : greet)
+min(false ? 0 : nil)
+min(false ? array : nil)
+min(false ? greet : foo)
+min(findLast(array, false))
+min(findLastIndex($env, true))
+min(first($env))
 min(first(array))
-min(float(0.5))
+min(flatten(array))
 min(float(1))
-min(float(f32))
+min(float(1.0))
 min(float(f64))
 min(float(i))
-min(float(i64), i)
-min(floor(0.5))
-min(floor(1))
-min(floor(f32))
+min(floor(1.0 + i))
+min(floor(1.0))
+min(floor(f64))
 min(floor(i))
-min(floor(i32))
-min(floor(i64))
-min(half(0.5))
-min(half(1))
-min(half(1), -1)
-min(half(f64 - 0.5))
-min(half(f64))
-min(i % 1)
-min(i % i64)
+min(groupBy(array, #)?.array)
+min(i % i)
+min(i * f64)
 min(i * i)
-min(i ** 0.5)
-min(i ** i)
-min(i + 1)
-min(i - 0.5)
+min(i + 1.0)
+min(i + i)
+min(i - 0)
 min(i - f64)
-min(i - i32)
-min(i / 1) + f64
-min(i / f64)
-min(i ^ f32)
-min(i ^ f64)
-min(i ^ i)
+min(i - i)
+min(i .. 0)
+min(i / 1.0)
+min(i ^ 1.0)
+min(i | bitor(0))
+min(i | bitshr(1))
+min(i | min(0))
 min(i)
-min(i) * f32
-min(i) ** i64
-min(i) / f64
-min(i) / i
-min(i) < f64
-min(i) < i32
-min(i) >= i32
-min(i) ^ f32
-min(i, f32)
-min(i, f32, i) + i32
+min(i) != $env?.i
+min(i) % i
+min(i) < i
+min(i) <= f64
+min(i, array)
+min(i, array) .. i
 min(i, f64)
 min(i, i)
-min(i, i32)
-min(i, i64)
-min(i, last(array))
-min(i32 % 1)
-min(i32 * f32)
-min(i32 * i)
-min(i32 ** 0.5)
-min(i32 ** i32)
-min(i32 + i32)
-min(i32 + i64)
-min(i32 - 0.5)
-min(i32 - i64)
-min(i32 / 0.5)
-min(i32 / f64)
-min(i32 ^ 0.5)
-min(i32 ^ f32)
-min(i32 ^ f64)
-min(i32 ^ i64)
-min(i32)
-min(i32) - i
-min(i32) .. i32
-min(i32) / i
-min(i32) < i
-min(i32) <= f32
-min(i32) <= i
-min(i32) > f32
-min(i32) > i64 + f64
-min(i32) >= i
-min(i32) ^ f32
-min(i32) ^ i64
-min(i32, f32)
-min(i32, f64 * 0.5)
-min(i32, f64)
-min(i32, i)
-min(i32, i32)
-min(i32, i64)
-min(i64 % 1)
-min(i64 * 0.5)
-min(i64 * 1)
-min(i64 * bitnot(i64))
-min(i64 * i)
-min(i64 * i32)
-min(i64 * i64)
-min(i64 ** 0.5)
-min(i64 ** f64)
-min(i64 ** i)
-min(i64 ** i32)
-min(i64 + f32)
-min(i64 - f64)
-min(i64 - i32)
-min(i64 / 1)
-min(i64 / f32)
-min(i64 / i)
-min(i64 / i32)
-min(i64 / i64)
-min(i64 ^ 0.5)
-min(i64 ^ 1)
-min(i64 ^ f64)
-min(i64 ^ i32)
-min(i64)
-min(i64) / f32
-min(i64) < i32
-min(i64) >= f64
-min(i64) not in array
-min(i64, f32)
-min(i64, f64)
-min(i64, i)
-min(i64, i32)
-min(i64, i64)
-min(i64, i64) < i64
-min(int(0.5))
+min(i, max(sum(array)))
+min(if false { nil } else { 0 })
+min(if false { ok } else { array })
+min(if true { 1 } else { $env })
+min(if true { 1.0 } else { true })
+min(if true { false } else { foo })
+min(if true { greet } else { 1.0 })
+min(int(0))
 min(int(1))
-min(int(f32))
-min(int(f64))
+min(int(1.0))
 min(int(i))
-min(int(i32))
-min(int(i64))
-min(last(1 .. 1))
+min(last($env))
 min(last(array))
+min(len($env))
 min(len(array))
 min(len(list))
-min(max(0.5))
-min(max(1, 0.5))
-min(max(f32))
+min(len(str))
+min(list | count(false))
+min(list | count(true))
+min(list | findIndex(false))
+min(list | reduce(1))
+min(list | reduce(1.0))
+min(list | reduce(array))
+min(list | sum(1))
+min(list[1:1])
+min(map($env, 0))
+min(map($env, array))
+min(map(array, #))
+min(map(array, #index))
+min(map(array, 1.0))
+min(map(list, f64))
+min(max($env))
+min(max(0))
+min(max(0, 1))
+min(max(0, 1.0, 0))
+min(max(1))
+min(max(1.0))
+min(max(1.0, 1.0))
+min(max(array))
 min(max(f64))
 min(max(i))
-min(max(i64, 1))
+min(mean(0))
+min(mean(1))
+min(mean(1.0))
 min(mean(array))
-min(min(1))
-min(min(1, 1, 1))
-min(min(1, i, f32))
+min(mean(f64))
+min(mean(i))
+min(median(0))
+min(median(1))
+min(median(1.0))
+min(median(array))
+min(median(f64))
+min(min($env))
+min(min(0))
+min(min(1.0))
+min(min(1.0, 1))
+min(min(f64))
+min(min(f64, 1.0))
 min(min(i))
-min(min(i32))
-min(min(reduce(list, f32)))
-min(ok ? array : false)
-min(ok ? f64 : i)
-min(ok ? half : ok)
-min(ok ? i : f32)
-min(ok ? array : score)
-min(ok ? true : div)
-min(reduce(array, #))
-min(reduce(array, 0.5))
-min(reduce(array, 1))
-min(reduce(list, 1))
-min(round(0.5))
+min(ok ?: 1.0)
+min(reduce(array, i))
+min(reduce(list, f64))
+min(reduce(list, f64), $env?.array)
+min(reverse(array))
+min(round(0))
+min(round(0), array)
 min(round(1))
-min(round(f32))
-min(round(i32))
-min(round(i64))
-min(score(1))
-min(score(i))
+min(round(1.0))
+min(round(f64))
+min(sort(array))
+min(sortBy(array, f64))
+min(sum($env, 1))
+min(sum($env, 1.0))
 min(sum(array))
-min(true ? i : "foo")
-min(true ? i : i32)
-min(true ? i64 : "foo")
-nil != array != nil ? add : half
-nil != array && ok
-nil != div == reduce(array, ok)
-nil != f64 || ok || false
-nil != false && ok
-nil != false or i == nil
-nil != foo and ok
+min(sum(array), array)
+min(sum(array, #))
+min(sum(array, 1.0))
+min(sum(list, 1))
+min(sum(list, f64))
+min(true ? 1.0 : str)
+min(true ? nil : i)
+min(true ?: add)
+min(uniq(array))
+min({foo: 0}.foo)
+min({foo: add}.i)
+min({foo: i}?.i)
+min({foo: nil}?.i)
+min({foo: sum(array)}.array)
+nil != $env.add
+nil != $env.array
+nil != $env.f64
+nil != $env.foo
+nil != $env.greet
+nil != $env.i
+nil != $env.list
+nil != $env.ok
+nil != $env.str
+nil != $env?.Bar
+nil != $env?.String
+nil != $env?.[1.0 | first(nil)]
+nil != $env?.[Bar]
+nil != $env?.[String]
+nil != $env?.[foobar]
+nil != $env?.[greet(foobar)]
+nil != $env?.[str]
+nil != $env?.add
+nil != $env?.array
+nil != $env?.f64
+nil != $env?.foo
+nil != $env?.greet
+nil != $env?.i
+nil != $env?.list
+nil != $env?.ok
+nil != $env?.str
+nil != 0 - i
+nil != 0 / f64
+nil != 0 ?: array
+nil != 0 ^ $env?.i
+nil != 1 % i
+nil != 1.0 ?: reduce($env, #.String, true)
+nil != 1.0 ^ f64
+nil != 1.0 or 1.0 == 1
+nil != add and ok
+nil != array?.[i]
+nil != f64 / f64 && ok
+nil != f64 or i == i
+nil != false || $env > $env
+nil != foo ?: greet
+nil != foo ?: list
 nil != foo.Bar
-nil != foo.Qux
 nil != foo.String
 nil != foo.String()
 nil != foo?.Bar
-nil != foo?.Qux
 nil != foo?.String
 nil != foo?.String()
-nil != nil ? score : div
-nil != true || i < 1
-nil == "foo" != ok
-nil == "foo" && 0.5 < f64
-nil == 0.5 and reduce(list, true)
-nil == add && 0.5 >= 0.5
-nil == add || f32 >= i64
-nil == array and ok
-nil == array or ok
-nil == array[i64]
-nil == div ? f64 : ok
-nil == false && nil != true
-nil == false ? i64 : toBase64("bar")
+nil != greet ?: i
+nil != list?.[i]
+nil != list?.[i]?.Bar
+nil != list?.[i]?.String
+nil != list[:]
+nil != nil && $env?.[array]
+nil != ok || abs($env)
+nil != str && get($env, nil)
+nil != true || $env == 1.0
+nil == $env or f64 < 1.0
+nil == $env.add
+nil == $env.array
+nil == $env.f64
+nil == $env.foo
+nil == $env.greet
+nil == $env.i
+nil == $env.list
+nil == $env.ok
+nil == $env.str
+nil == $env?.Bar
+nil == $env?.String
+nil == $env?.String?.[list]
+nil == $env?.[Bar]
+nil == $env?.[String]
+nil == $env?.[foo.Bar]
+nil == $env?.[foobar?.[i]]
+nil == $env?.[foobar]
+nil == $env?.[str]
+nil == $env?.add
+nil == $env?.array
+nil == $env?.f64
+nil == $env?.foo
+nil == $env?.foobar
+nil == $env?.foobar?.add(foobar, foobar)
+nil == $env?.greet
+nil == $env?.i
+nil == $env?.list
+nil == $env?.ok
+nil == $env?.str
+nil == 0 ** 1.0 ? nil : nil
+nil == 0 || ok
+nil == 1 * i
+nil == 1 and find($env, #.add)?.[i]
+nil == 1.0 ?: i
+nil == 1.0 ^ f64
+nil == array?.[i]
+nil == f64 * f64
+nil == foo != ok
+nil == foo and ok
 nil == foo.Bar
-nil == foo.Qux
 nil == foo.String
 nil == foo.String()
 nil == foo?.Bar
-nil == foo?.Qux
 nil == foo?.String
-nil == greet ? i : greet("bar")
-nil == list || f32 == i
-nil == list[i32]
+nil == foo?.String()
+nil == greet != $env?.Bar
+nil == greet and $env?.[list]
+nil == greet or ok
+nil == i + i
+nil == i and ok
+nil == i in $env?.[String]
+nil == list?.[i]
+nil == nil != $env?.[String]
+nil == nil != nil || false
 nil == nil and ok
-nil in array || score == nil
-nil in list != not false
-none(1 .. i, # < #)
-none(1 .. i32, # <= #)
-none([foo, list, 1 >= i], ok)
-none([greet], ok)
-none([true], #)
-none(array, !(i32 != i32))
-none(array, !false)
-none(array, !true)
-none(array, "bar" endsWith "foo")
+nil == ok != ok
+nil == str != false || true
+nil in $env.array
+nil in $env.list
+nil in $env?.Bar
+nil in $env?.String
+nil in $env?.[Bar]
+nil in $env?.[String]
+nil in $env?.array
+nil in $env?.foobar?.i(false)
+nil in $env?.list
+nil in list && ok
+nil in list and $env == foo
+nil in list or ok
+nil not in $env or ok
+nil not in $env || 0 <= $env
+nil not in $env.array
+nil not in $env.list
+nil not in $env?.$env?.ok
+nil not in $env?.Bar
+nil not in $env?.Bar?.str
+nil not in $env?.String
+nil not in $env?.String?.greet
+nil not in $env?.[Bar]
+nil not in $env?.[String]
+nil not in $env?.[foobar]
+nil not in $env?.array
+nil not in $env?.foobar?.[list]
+nil not in $env?.foobar?.add(nil, f64)
+nil not in $env?.list
+nil not in array ?: i
+nil not in list[i:]
+nil; $env.greet
+nil; $env.ok
+none($env | map($env), .f64 != foo)
+none($env, false) && ok == true
+none($env.array, str not in $env)
+none($env?.[str], 1 > f64)
+none($env?.[str], ok)
+none(1 .. 0, $env < $env)
+none(1 .. 0, $env | all(ok))
+none([$env, foo], false != #)
+none([$env], .f64 in #.String)
+none([1.0], ok)
+none([greet, 1.0], ok)
+none([nil, foo], ok)
 none(array, # != #)
-none(array, # != 0.5)
-none(array, # != 1)
-none(array, # != f32)
-none(array, # != f64)
-none(array, # != i)
-none(array, # < #)
-none(array, # < 0.5)
-none(array, # < f32)
-none(array, # < i32)
-none(array, # < i64)
+none(array, # != 0)
+none(array, # != nil)
+none(array, # < 1)
 none(array, # <= #)
-none(array, # <= 0.5)
-none(array, # <= 1)
-none(array, # <= f32)
-none(array, # <= i)
-none(array, # <= i32)
-none(array, # <= i64)
-none(array, # == #)
-none(array, # == 0.5)
-none(array, # == f32)
-none(array, # == i32)
-none(array, # == i64)
-none(array, # == nil)
-none(array, # > #)
-none(array, # > 0.5)
-none(array, # > i)
+none(array, # == 0)
 none(array, # >= #)
-none(array, # >= 0.5)
-none(array, # >= 1)
-none(array, # >= f32)
-none(array, # >= f64)
-none(array, # >= i32)
-none(array, # >= i64)
-none(array, # in array)
-none(array, 0.5 != #)
-none(array, 0.5 != 1)
-none(array, 0.5 < #)
-none(array, 0.5 < i64)
-none(array, 0.5 <= #)
-none(array, 0.5 <= 1)
-none(array, 0.5 <= f64)
-none(array, 0.5 == #)
-none(array, 0.5 > 0.5)
-none(array, 0.5 > 1)
-none(array, 0.5 > f32)
-none(array, 0.5 >= #)
-none(array, 0.5 >= 1)
-none(array, 1 < #)
-none(array, 1 <= #)
-none(array, 1 == 1)
-none(array, 1 > #)
-none(array, any(array, true))
-none(array, f32 != #)
-none(array, f32 < 0.5)
-none(array, f32 < 1)
-none(array, f32 == 1)
-none(array, f32 > #)
-none(array, f32 >= #)
-none(array, f32 >= 1)
-none(array, f32 >= f32)
-none(array, f64 != 1)
+none(array, $env == foo)
+none(array, $env.ok)
+none(array, 0 <= 0)
+none(array, 1 == #)
+none(array, add == add)
 none(array, f64 == #)
-none(array, f64 > #)
-none(array, f64 >= #)
 none(array, i != #)
 none(array, i < #)
-none(array, i < f64)
-none(array, i <= #)
-none(array, i > #)
-none(array, i >= #)
-none(array, i >= 0.5)
-none(array, i >= i32)
-none(array, i32 != #)
-none(array, i32 != i)
-none(array, i32 != nil)
-none(array, i32 < #)
-none(array, i32 > #)
-none(array, i64 != #)
-none(array, i64 != 0.5)
-none(array, i64 > i64)
-none(array, i64 >= #)
-none(array, nil != "bar")
-none(array, nil != #)
-none(array, nil != false)
-none(array, nil != greet)
-none(array, nil == #)
-none(array, nil == 1)
-none(array, nil == f32)
-none(array, nil == greet)
-none(array, nil == half)
-none(array, not (# == #))
-none(array, not (# >= 1))
-none(array, not false)
+none(array, nil == i)
+none(array, ok && false)
 none(array, ok)
-none(array, reduce(array, true))
-none(filter(array, # >= f64), ok)
-none(groupBy(array, #).f64, # or #.Bar)
-none(groupBy(list, #).div, ok)
-none(groupBy(list, #).greet, #)
-none(groupBy(list, 0.5).i, ok)
-none(i .. i, ok)
-none(i .. i32, # <= #)
-none(list, !false)
-none(list, !ok)
-none(list, "bar" contains "bar")
-none(list, # != #)
+none(concat(array), f64 >= #)
+none(flatten(array), ok)
+none(list | map($env), #.ok)
+none(list | map(str), ok)
 none(list, # != foo)
-none(list, # != nil)
 none(list, # == #)
-none(list, # == foo)
-none(list, # in list)
-none(list, # not in list)
-none(list, (0.5 not in array) || ok)
-none(list, 0.5 != i32)
-none(list, 0.5 > f64)
-none(list, 0.5 > i)
-none(list, 1 != i64)
-none(list, 1 != nil)
-none(list, 1 == f32)
-none(list, 1 > 0.5)
-none(list, all(array, ok))
-none(list, f32 != 1 ** f64)
-none(list, f32 >= 0.5)
-none(list, f32 in array)
-none(list, f32 not in array)
-none(list, f64 <= i32)
-none(list, f64 >= 1)
-none(list, false) ? ok : half
-none(list, false) || ok
-none(list, foo != #)
+none(list, $env != $env)
+none(list, $env != i)
+none(list, $env != nil)
+none(list, $env.ok)
+none(list, 1 == f64)
+none(list, 1.0 > 1.0)
+none(list, array == $env)
+none(list, f64 != $env)
+none(list, false != true)
+none(list, foo != foo)
+none(list, foo == #)
 none(list, foo == foo)
-none(list, i != i)
-none(list, i != i64)
-none(list, i >= f32)
-none(list, i32 == f32)
-none(list, i32 > 1)
-none(list, i32 > i64)
-none(list, i32 not in array)
-none(list, i64 != 0.5)
-none(list, i64 > i64)
-none(list, nil != #)
-none(list, nil != greet)
-none(list, nil != i64)
-none(list, nil == #)
-none(list, nil == list)
-none(list, not false)
+none(list, ok == $env)
 none(list, ok)
-none(list, one(array, true))
-none(list, true && ok)
-none(list, true) and ok
-none(map(array, #), ok)
-none(map(array, div), # != #)
-none(map(array, f64 == #), ok)
-none(map(list, "bar"), # endsWith #)
-none(map(list, #), nil == list)
-none(map(list, #), ok)
-none(map(list, 1), i > #)
-none(map(list, ok), # ? true : #)
-none(map(list, ok), #)
-none(map(list, score), ok)
-none(sort(filter(array, false)), #?.div > greet(#))
-not !(0.5 != i64)
-not !(i < 1)
-not !(i >= 0.5)
-not !(i32 != i32)
-not !(nil != false)
-not !false
-not !not false
-not !ok
-not !true
-not ("bar" != "bar")
-not ("bar" != "foo")
-not ("bar" != nil)
-not ("bar" < "bar")
-not ("bar" < "foo")
-not ("bar" <= "bar")
-not ("bar" <= "foo")
-not ("bar" == "bar")
-not ("bar" == "foo")
-not ("bar" == nil)
-not ("bar" > "bar")
-not ("bar" > "foo")
-not ("bar" >= "bar")
-not ("bar" >= "foo")
-not ("bar" contains "bar")
-not ("bar" contains "foo")
-not ("bar" endsWith "bar")
-not ("bar" endsWith "foo")
-not ("bar" in foo)
-not ("bar" matches "bar")
-not ("bar" matches "foo")
-not ("bar" not contains "bar")
-not ("bar" not contains "foo")
-not ("bar" not endsWith "bar")
-not ("bar" not endsWith "foo")
-not ("bar" not in foo)
-not ("bar" not matches "bar")
-not ("bar" not matches "foo")
-not ("bar" not startsWith "bar")
-not ("bar" not startsWith "foo")
-not ("bar" startsWith "bar")
-not ("bar" startsWith "foo")
-not ("foo" != "bar")
-not ("foo" != "foo")
-not ("foo" != nil)
-not ("foo" < "bar")
-not ("foo" < "foo")
-not ("foo" <= "bar")
-not ("foo" <= "foo")
-not ("foo" == "bar")
-not ("foo" == "foo")
-not ("foo" == nil)
-not ("foo" > "bar")
-not ("foo" > "foo")
-not ("foo" >= "bar")
-not ("foo" >= "foo")
-not ("foo" contains "bar")
-not ("foo" contains "foo")
-not ("foo" endsWith "bar")
-not ("foo" endsWith "foo")
-not ("foo" in foo)
-not ("foo" matches "bar")
-not ("foo" matches "foo")
-not ("foo" not contains "bar")
-not ("foo" not contains "foo")
-not ("foo" not endsWith "bar")
-not ("foo" not endsWith "foo")
-not ("foo" not in foo)
-not ("foo" not matches "foo")
-not ("foo" not startsWith "foo")
-not ("foo" startsWith "bar")
-not ("foo" startsWith "foo")
-not (0.5 != 0.5)
-not (0.5 != 1)
-not (0.5 != f32)
-not (0.5 != f64)
-not (0.5 != i)
-not (0.5 != i32)
-not (0.5 != i64)
-not (0.5 != nil)
-not (0.5 < 0.5)
-not (0.5 < 1)
-not (0.5 < f32)
-not (0.5 < f64)
-not (0.5 < i)
-not (0.5 < i32)
-not (0.5 < i64)
-not (0.5 <= 0.5)
-not (0.5 <= 1)
-not (0.5 <= f32)
-not (0.5 <= f64)
-not (0.5 <= i)
-not (0.5 <= i32)
-not (0.5 <= i64)
-not (0.5 == 0.5)
-not (0.5 == 1)
-not (0.5 == f32)
-not (0.5 == f64)
-not (0.5 == i && i32 != i32)
-not (0.5 == i)
-not (0.5 == i32)
-not (0.5 == i64)
-not (0.5 == nil)
-not (0.5 > 0.5)
-not (0.5 > 1)
-not (0.5 > f32)
-not (0.5 > f64)
-not (0.5 > i)
-not (0.5 > i32)
-not (0.5 > i64)
-not (0.5 >= 0.5)
-not (0.5 >= 1)
-not (0.5 >= f32)
-not (0.5 >= f64)
-not (0.5 >= i)
-not (0.5 >= i32)
-not (0.5 >= i64)
-not (0.5 in array)
-not (0.5 not in array)
-not (1 != 0.5)
-not (1 != 1)
-not (1 != f32)
-not (1 != f64)
-not (1 != i)
-not (1 != i32)
-not (1 != i64)
-not (1 != nil)
-not (1 < 0.5)
-not (1 < 1)
-not (1 < f32)
-not (1 < f64)
-not (1 < i)
-not (1 < i32)
-not (1 < i64)
-not (1 <= 0.5)
-not (1 <= 1)
-not (1 <= f32)
-not (1 <= f64)
-not (1 <= i)
-not (1 <= i32)
-not (1 <= i64)
-not (1 == 0.5)
-not (1 == 1)
-not (1 == f32)
-not (1 == f64)
-not (1 == i)
-not (1 == i32)
-not (1 == i64)
-not (1 == nil)
-not (1 > 0.5)
-not (1 > 1)
-not (1 > f32)
-not (1 > f64)
-not (1 > i)
-not (1 > i32)
-not (1 > i64)
-not (1 >= 0.5)
-not (1 >= 1)
-not (1 >= f32)
-not (1 >= f64)
-not (1 >= i)
-not (1 >= i32)
-not (1 >= i64)
-not (1 in array)
-not (1 not in array)
-not (add != add)
-not (add != nil)
-not (add == div)
-not (add == nil)
-not (array != array)
-not (array != list)
-not (array != nil)
-not (array == array)
-not (array == list)
-not (array == nil)
-not (array[i32] > i64)
-not (div != add)
-not (div != div)
-not (div != nil)
-not (div == add)
-not (div == div)
-not (div == nil)
-not (f32 != 0.5)
-not (f32 != 1)
-not (f32 != f32)
-not (f32 != f64)
-not (f32 != i)
-not (f32 != i32)
-not (f32 != i64)
-not (f32 != nil)
-not (f32 < 0.5)
-not (f32 < 1)
-not (f32 < f32)
-not (f32 < f64)
-not (f32 < i)
-not (f32 < i32)
-not (f32 < i64)
-not (f32 <= 0.5)
-not (f32 <= 1)
-not (f32 <= f64)
-not (f32 <= i)
-not (f32 <= i32)
-not (f32 <= i64)
-not (f32 == 0.5)
-not (f32 == 1)
-not (f32 == f32)
-not (f32 == f64)
-not (f32 == i)
-not (f32 == i32)
-not (f32 == i64)
-not (f32 == nil)
-not (f32 > 0.5)
-not (f32 > 1)
-not (f32 > f32)
-not (f32 > f64)
-not (f32 > i)
-not (f32 > i32)
-not (f32 > i64)
-not (f32 >= 0.5)
-not (f32 >= 1)
-not (f32 >= f32)
-not (f32 >= f64)
-not (f32 >= i)
-not (f32 >= i32)
-not (f32 >= i64)
-not (f32 in array)
-not (f32 not in array)
-not (f64 != 0.5)
-not (f64 != 1)
-not (f64 != f32)
-not (f64 != f64)
-not (f64 != i)
-not (f64 != i32)
-not (f64 != i64)
-not (f64 != nil)
-not (f64 < 0.5)
-not (f64 < 1)
-not (f64 < f32)
-not (f64 < f64)
-not (f64 < i32)
-not (f64 < i64)
-not (f64 <= -0.5)
-not (f64 <= 0.5)
-not (f64 <= 1)
-not (f64 <= f32)
-not (f64 <= f64)
-not (f64 <= i)
-not (f64 <= i32)
-not (f64 <= i64)
-not (f64 == 0.5)
-not (f64 == 1)
-not (f64 == f64)
-not (f64 == i)
-not (f64 == i32)
-not (f64 == i64)
-not (f64 == nil)
-not (f64 > 0.5)
-not (f64 > 1)
-not (f64 > f32)
-not (f64 > f64)
-not (f64 > i)
-not (f64 > i32)
-not (f64 > i64)
-not (f64 >= 0.5)
-not (f64 >= 1)
-not (f64 >= f32)
-not (f64 >= f64)
-not (f64 >= i)
-not (f64 >= i32)
-not (f64 >= i64)
-not (f64 in array)
-not (f64 not in array)
-not (false != false)
-not (false != nil)
-not (false != ok)
-not (false != true)
-not (false && false)
-not (false && ok)
-not (false == nil)
-not (false == ok)
-not (false and false)
-not (false and ok)
-not (false and true)
-not (false or false)
-not (false or ok)
-not (false or true)
-not (false || false)
-not (false || ok)
-not (false || true)
-not (findIndex(list, ok) != i ^ f64)
-not (foo != foo)
-not (foo != nil)
-not (foo == foo)
-not (foo == nil)
-not (foo in list)
-not (foo not in list)
-not (greet != greet)
-not (greet != nil)
-not (greet == greet)
-not (greet == nil)
-not (half != half)
-not (half != nil)
-not (half == half)
-not (half == nil)
-not (i != 0.5)
-not (i != 1)
-not (i != f32)
-not (i != f64)
-not (i != i)
-not (i != i32)
-not (i != i64)
-not (i != nil)
-not (i < 0.5)
-not (i < 1)
-not (i < f32)
-not (i < f64)
-not (i < i)
-not (i < i32)
-not (i < i64)
-not (i <= 0.5)
-not (i <= 1)
-not (i <= f32)
-not (i <= f64)
-not (i <= i)
-not (i <= i32)
-not (i <= i64)
-not (i == 0.5)
-not (i == 1)
-not (i == ceil(f64))
-not (i == f32)
-not (i == f64)
-not (i == i)
-not (i == i32)
-not (i == i64)
-not (i == nil)
-not (i > 0.5)
-not (i > 1)
-not (i > f32)
-not (i > f64)
-not (i > i)
-not (i > i32)
-not (i > i64)
-not (i >= 0.5)
-not (i >= 1)
-not (i >= f32)
-not (i >= f64)
-not (i >= i)
-not (i >= i32)
-not (i >= i64)
-not (i in array)
-not (i not in array)
-not (i32 != 0.5)
-not (i32 != 1)
-not (i32 != f32)
-not (i32 != f64)
-not (i32 != i)
-not (i32 != i32)
-not (i32 != i64)
-not (i32 != nil)
-not (i32 < 0.5)
-not (i32 < 1)
-not (i32 < f32 ** 0.5)
-not (i32 < f32)
-not (i32 < f64)
-not (i32 < i)
-not (i32 < i32)
-not (i32 < i64)
-not (i32 <= 0.5)
-not (i32 <= 1)
-not (i32 <= f32)
-not (i32 <= f64)
-not (i32 <= i)
-not (i32 <= i32)
-not (i32 <= i64)
-not (i32 == -i)
-not (i32 == 0.5)
-not (i32 == 1)
-not (i32 == f32)
-not (i32 == f64)
-not (i32 == i)
-not (i32 == i32)
-not (i32 == i64)
-not (i32 == nil)
-not (i32 > 0.5)
-not (i32 > 1)
-not (i32 > f32)
-not (i32 > f64)
-not (i32 > i)
-not (i32 > i32)
-not (i32 > i64)
-not (i32 >= 0.5)
-not (i32 >= 1)
-not (i32 >= f32)
-not (i32 >= f64)
-not (i32 >= i)
-not (i32 >= i32)
-not (i32 >= i64)
-not (i32 in array)
-not (i32 not in array)
-not (i64 != 0.5)
-not (i64 != 1)
-not (i64 != f32)
-not (i64 != f64)
-not (i64 != i)
-not (i64 != i32)
-not (i64 != i64)
-not (i64 != nil)
-not (i64 < 0.5)
-not (i64 < 1)
-not (i64 < f32)
-not (i64 < f64)
-not (i64 < i)
-not (i64 < i32)
-not (i64 < i64)
-not (i64 <= 0.5)
-not (i64 <= 1)
-not (i64 <= f32)
-not (i64 <= f64)
-not (i64 <= i)
-not (i64 <= i32)
-not (i64 <= i64)
-not (i64 == 0.5)
-not (i64 == 1)
-not (i64 == f32)
-not (i64 == f64)
-not (i64 == i)
-not (i64 == i32)
-not (i64 == i64)
-not (i64 == nil)
-not (i64 > 0.5)
-not (i64 > 1)
-not (i64 > f32)
-not (i64 > f64)
-not (i64 > i)
-not (i64 > i32)
-not (i64 > i64)
-not (i64 >= 0.5)
-not (i64 >= 1)
-not (i64 >= f32)
-not (i64 >= f64)
-not (i64 >= i)
-not (i64 >= i32)
-not (i64 >= i64)
-not (i64 not in array)
-not (list != array)
-not (list != list)
-not (list != nil)
-not (list == array)
-not (list == list)
-not (list == nil)
-not (nil != "bar")
-not (nil != "foo")
-not (nil != 0.5)
-not (nil != 1)
-not (nil != add)
-not (nil != array)
-not (nil != div)
-not (nil != f32)
-not (nil != f64)
-not (nil != false)
-not (nil != foo)
-not (nil != half)
-not (nil != i)
-not (nil != i32)
-not (nil != i64)
-not (nil != list)
-not (nil != nil)
-not (nil != ok)
-not (nil != score)
-not (nil != true)
-not (nil == "bar")
-not (nil == "foo")
-not (nil == 0.5)
-not (nil == 1)
-not (nil == add)
-not (nil == array)
-not (nil == div)
-not (nil == f32)
-not (nil == f64)
-not (nil == false)
-not (nil == foo)
-not (nil == greet)
-not (nil == half)
-not (nil == i)
-not (nil == i32)
-not (nil == i64)
-not (nil == list)
-not (nil == nil)
-not (nil == ok)
-not (nil == score)
-not (nil == true)
-not (nil in array)
-not (nil in list)
-not (nil not in array)
-not (nil not in list)
-not (ok != nil)
-not (ok != ok)
-not (ok != true)
-not (ok && false)
-not (ok && ok)
-not (ok && true)
-not (ok == false)
-not (ok == nil)
-not (ok == ok)
-not (ok == true)
-not (ok and false)
-not (ok and ok)
-not (ok and true)
-not (ok or false)
-not (ok or ok)
-not (ok or true)
-not (ok || ok)
-not (ok || true)
-not (score != nil)
-not (score != score)
-not (score == nil)
-not (score == score)
-not (true != false)
-not (true != nil)
-not (true != ok)
-not (true != true)
-not (true && false)
-not (true && true)
-not (true == false)
-not (true == nil)
-not (true == ok)
-not (true == true)
-not (true and false)
-not (true and ok)
-not (true and true)
-not (true or false)
-not (true or ok)
-not (true or true)
-not (true || false)
-not (true || ok)
-not (true || true)
-not all(array, false)
-not all(array, ok)
-not all(array, true)
-not all(list, nil == #)
-not all(list, ok)
-not all(list, true)
-not any(array, false)
-not any(array, ok)
-not any(array, true)
-not any(list, false)
-not any(list, ok)
-not any(list, true)
-not false && nil == f64
-not false && ok
-not false == ok
-not false ? "foo" : "foo"
-not false ? 0.5 : "foo"
-not false ? 0.5 : array
-not false ? 0.5 : div
-not false ? 0.5 : foo
-not false ? 0.5 : i64
-not false ? 0.5 : nil
-not false ? 1 : 0.5
-not false ? add : array
-not false ? array : 0.5
-not false ? array : 1
-not false ? array : f64
-not false ? array : i
-not false ? array : true
-not false ? div : 0.5
-not false ? div : f64
-not false ? f32 : 0.5
-not false ? f32 : 1
-not false ? f32 : i
-not false ? f32 : nil
-not false ? f32 : score
-not false ? f64 : "foo"
-not false ? f64 : f64
-not false ? false : half
-not false ? false : list
-not false ? foo : f64
-not false ? greet : 1
-not false ? i : "bar"
-not false ? i : 1
-not false ? i : array
-not false ? i : i
-not false ? i32 : greet
-not false ? i64 : list
-not false ? list : i
-not false ? list : true
-not false ? nil : f32
-not false ? nil : half
-not false ? nil : ok
-not false ? ok : 1
-not false ? score : ok
-not false ? true : f64
-not false ? true : nil
-not false or false == false
-not false or ok
-not false || ok
-not none(array, # > f32)
-not none(array, false)
-not none(array, ok)
-not none(array, true)
-not none(list, false)
-not none(list, ok)
-not none(list, true)
-not not (f64 <= 1)
-not not (i32 < i64)
-not not (i64 >= f64)
-not not (nil != greet)
-not not (ok or ok)
-not not false
-not not ok
-not not true
-not ok
-not ok != ok
-not ok && 1 > 0.5
-not ok && ok
-not ok ? "bar" : list
-not ok ? "foo" : 0.5
-not ok ? "foo" : 1
-not ok ? 0.5 : "bar"
-not ok ? 0.5 : 0.5
-not ok ? 0.5 : i
-not ok ? 1 : f64
-not ok ? 1 : nil
-not ok ? add : array
-not ok ? add : groupBy(array, #)
-not ok ? array : 1
-not ok ? array : f32
-not ok ? div : f64
-not ok ? f32 : f32
-not ok ? f64 : f64
-not ok ? f64 : half
-not ok ? foo : foo
-not ok ? greet : 0.5
-not ok ? half : half
-not ok ? i : 1
-not ok ? i : add
-not ok ? i32 : 1
-not ok ? i32 : i
-not ok ? i64 : f32
-not ok ? i64 : f64
-not ok ? nil : "bar"
-not ok ? nil : 0.5
-not ok ? nil : foo
-not ok ? nil : greet
-not ok ? nil : i
-not ok ? ok : false
-not ok ? ok : list
-not ok ? score : "foo"
-not ok ? score : score
-not ok ? true : 1
-not ok ? true : div
-not ok ? true : half
-not ok ? true : i64
-not ok ? true : nil
-not ok and "foo" == "foo"
-not ok and i32 > 0.5
-not ok and ok
-not ok or 1 != i
-not ok or ok
-not ok || array == list
-not ok || ok
-not one(array, false)
-not one(array, ok)
-not one(array, true)
-not one(list, false)
-not one(list, ok)
-not one(list, true)
-not reduce(array, false)
-not reduce(array, ok)
-not reduce(array, true)
-not reduce(list, false)
-not reduce(list, ok)
-not reduce(list, true)
-not true != ok
-not true && ok
-not true == ok
-not true ? "bar" : array
-not true ? "bar" : i32
-not true ? "foo" : f32
-not true ? "foo" : f64
-not true ? 0.5 : foo
-not true ? 0.5 : greet
-not true ? 0.5 : i
-not true ? 0.5 : i64
-not true ? 1 : f32
-not true ? add : i32
-not true ? add : ok
-not true ? array : nil
-not true ? f32 : 0.5
-not true ? f32 : div
-not true ? f64 : 1
-not true ? f64 : array
-not true ? foo : greet
-not true ? foo : ok
-not true ? greet : 1
-not true ? greet : i64
-not true ? greet : list
-not true ? greet : true
-not true ? half : half
-not true ? i : f64
-not true ? i64 : "foo"
-not true ? i64 : array
-not true ? i64 : i64
-not true ? list : "bar"
-not true ? list : f64
-not true ? list : foo
-not true ? nil : div
-not true ? ok : nil
-not true ? score : f32
-not true ? score : score
-not true ? true : 1
-not true and ok ? i : half
-not true || ok
+none(list, str < .Bar)
+none(list, true == $env)
+none(map($env, 1.0), ok)
+none(map(list, $env), ok)
+none(sort($env), #.add?.greet(foo))
 ok
-ok != !ok
-ok != (0.5 not in array)
-ok != false != ok
-ok != false ? f32 : list
-ok != nil == nil
-ok != nil ? f32 : greet
-ok != nil ? nil : array
-ok != not ok
+ok != $env and $env
+ok != $env.ok
+ok != $env?.Bar
+ok != $env?.String
+ok != $env?.[Bar]
+ok != $env?.[String]
+ok != $env?.[str]
+ok != $env?.foobar
+ok != $env?.foobar?.greet
+ok != $env?.ok
+ok != any($env, ok)
+ok != any(array, false)
+ok != false && $env
+ok != false or false
+ok != nil && ok
+ok != nil == ok and ok
+ok != nil ? f64 : 1
+ok != nil and $env
 ok != ok
-ok != ok ? false : "bar"
-ok && !false
-ok && !ok
-ok && "foo" matches "bar"
-ok && ("bar" not endsWith "bar")
-ok && (false || ok)
-ok && (ok or false)
-ok && (true || true)
-ok && 0.5 < 1
-ok && 0.5 < f64
-ok && 0.5 <= 1
-ok && 0.5 == nil
-ok && 0.5 > i64
-ok && 1 != 0.5
-ok && 1 != i32
-ok && 1 <= 1
-ok && 1 <= f64
-ok && 1 == 0.5
-ok && 1 == nil
-ok && 1 >= f64
-ok && f32 != i
-ok && f32 >= i64
-ok && f64 <= 0.5
-ok && false != ok
-ok && false ? i : list
-ok && false ? ok : ok
-ok && i < 0.5
-ok && i < i64
-ok && i == 0.5
-ok && i > f64
-ok && i32 > 0.5
-ok && i32 >= i64
-ok && i64 != i
-ok && i64 == 0.5
-ok && nil != 0.5
-ok && nil != 1
-ok && nil == ok
-ok && not false
-ok && not true
+ok != sum($env?.[str])
+ok != true != nil
+ok != true != true
+ok != true && ok
+ok && $env != array
+ok && $env != str
+ok && $env == foo
+ok && $env == greet
+ok && $env not in array
+ok && $env.ok
+ok && $env?.Bar
+ok && $env?.String
+ok && $env?.String?.String
+ok && $env?.String?.list
+ok && $env?.[Bar]
+ok && $env?.[Bar]?.add
+ok && $env?.[String]
+ok && $env?.[foobar?.Bar]
+ok && $env?.[foobar]
+ok && $env?.[str]
+ok && $env?.foobar
+ok && $env?.ok
+ok && 0 < 0
+ok && 1 != i
+ok && 1 == 1
+ok && 1 == f64
+ok && 1.0 != $env
+ok && 1.0 != 1.0
+ok && 1.0 != f64
+ok && 1.0 < f64
+ok && 1.0 > 1
+ok && add != $env
+ok && add != $env?.String
+ok && f64 > 1 or $env
+ok && f64 > 1.0
+ok && foo != foo
+ok && foo != nil
+ok && i <= f64
+ok && i >= 1
+ok && i not in array
+ok && max($env)
+ok && median(array)
+ok && nil != $env
+ok && nil == i
+ok && nil == true
+ok && nil in array
 ok && ok
-ok && ok ? nil : div
-ok && ok and false
-ok && true != false
-ok && true && 1 >= i64
-ok == !false
-ok == !true
-ok == ("bar" not endsWith "foo")
-ok == (0.5 not in array)
-ok == (false and ok)
-ok == (i32 not in array)
-ok == (nil not in list)
-ok == false ? f64 : 1
-ok == false ? score : 1
-ok == nil ? i64 : add
-ok == nil ? nil : f64
-ok == none(array, true)
-ok == not false
+ok && ok && $env?.[str]
+ok && ok == ok
+ok && ok and $env
+ok && ok or false
+ok && ok || false
+ok && one(list, false)
+ok && str endsWith str
+ok && true || $env?.String
+ok == $env && ok
+ok == $env || ok
+ok == $env.ok
+ok == $env?.Bar
+ok == $env?.String
+ok == $env?.String?.[greet]
+ok == $env?.[Bar]
+ok == $env?.[Bar]?.[array]
+ok == $env?.[String]
+ok == $env?.[str]
+ok == $env?.foobar
+ok == $env?.nil
+ok == $env?.ok
+ok == false != nil
+ok == mean(array)
+ok == min($env)
+ok == nil != true
+ok == nil ? 1.0 : $env
 ok == ok
-ok == ok != false
-ok == true && ok
-ok ? "bar" : f64 <= f32
-ok ? "foo" : foo.Bar
-ok ? -0.5 : add
-ok ? -f64 : list
-ok ? -i32 : i
-ok ? 0.5 / 0.5 : f64
-ok ? 0.5 : i32 >= i64
-ok ? 0.5 > 1 : 0.5 * i64
-ok ? 1 + i : i32
-ok ? 1 / i64 : greet
-ok ? 1 : foo.Bar
-ok ? 1 : foo?.Qux
-ok ? abs(i64) : i64
-ok ? add : abs(f32)
+ok == ok ? nil : $env
+ok == true && $env
+ok ? $env : $env >= 1.0 | date(ok, true)
+ok ? $env : $env | find(.f64)
+ok ? $env : $env?.Bar
+ok ? $env : $env?.String()
+ok ? $env : $env?.[String]
+ok ? $env : $env?.[str]
+ok ? $env : $env?.array
+ok ? $env : $env?.ok
+ok ? $env : foo.Bar
+ok ? $env : foo?.Bar
+ok ? 0 : $env.list
+ok ? 0 : foo?.Bar
+ok ? 1 : $env.add
+ok ? 1 : $env?.[f64]
+ok ? 1 : $env[timezone(array):]
+ok ? 1.0 : $env | groupBy(#.str)
+ok ? 1.0 : $env.array
+ok ? 1.0 : $env.list
+ok ? 1.0 : $env?.Bar
+ok ? 1.0 : $env?.[array]
+ok ? 1.0 : $env?.greet
+ok ? 1.0 : $env?.list
+ok ? 1.0 : list | groupBy($env)
+ok ? add : $env | groupBy(#.list)
+ok ? add : $env | map(foo)
+ok ? add : $env | none(#)
+ok ? add : $env.array
+ok ? add : $env.f64
+ok ? add : $env.greet
+ok ? add : $env?.[greet]
+ok ? add : $env?.ok
 ok ? add : add
-ok ? add : array
 ok ? add : f64
-ok ? add : foo
-ok ? add : foo?.String
-ok ? add : greet
-ok ? add : half
-ok ? add : i
-ok ? add : i64
-ok ? add : list
-ok ? add : ok
-ok ? array : array
-ok ? array : f32
-ok ? array : f64 + f64
+ok ? add : list | reduce(#)
+ok ? add : str
+ok ? array : $env | sum(#)
+ok ? array : add
 ok ? array : foo
-ok ? array : foo.String
-ok ? array : foo?.String
-ok ? array : greet
-ok ? array : i
-ok ? array : i32
-ok ? array : list
+ok ? array : list | min(i)
 ok ? array : ok
-ok ? array : score
-ok ? div : add
-ok ? div : array
-ok ? div : div
-ok ? div : f64
-ok ? div : foo
-ok ? div : foo.Bar
-ok ? div : greet
-ok ? div : half
-ok ? div : i32 > reduce(array, #)
-ok ? div : nil == true
-ok ? div : ok
-ok ? div : score
-ok ? f32 != i32 : f32
-ok ? f32 ** i64 : score
-ok ? f32 : -0.5
-ok ? f32 : add
-ok ? f32 : array
-ok ? f32 : div
-ok ? f32 : f32
-ok ? f32 : f64
-ok ? f32 : foo
-ok ? f32 : half
-ok ? f32 : i32
-ok ? f32 : i64
-ok ? f32 : ok
-ok ? f32 : score
-ok ? f64 : add
-ok ? f64 : array
-ok ? f64 : div
-ok ? f64 : f64 - f64
-ok ? f64 : false != true
+ok ? array : sum(array)
+ok ? f64 : $env.foo
+ok ? f64 : $env.i
+ok ? f64 : $env.ok
+ok ? f64 : $env[bitxor(foobar):]
+ok ? f64 : f64
 ok ? f64 : foo
-ok ? f64 : foo.String
-ok ? f64 : greet
-ok ? f64 : i32
-ok ? f64 : i32 % i32
-ok ? f64 : i32 >= -i64
-ok ? f64 : ok
-ok ? f64 : score
+ok ? f64 : foo?.String()
+ok ? f64 : uniq($env)
+ok ? false : $env.foo
+ok ? false : $env?.[add]
+ok ? false : $env?.list
 ok ? false : foo.Bar
-ok ? foo : div
-ok ? foo : f32
+ok ? false : list?.[i]
+ok ? foo : $env not endsWith $env?.true
+ok ? foo : $env | groupBy(.list)
+ok ? foo : $env | groupBy(i)
+ok ? foo : $env.add
+ok ? foo : $env.greet
+ok ? foo : $env?.[f64]
+ok ? foo : $env?.[find(foobar, .f64)]
+ok ? foo : $env?.add
+ok ? foo : $env?.array
+ok ? foo : $env?.foobar?.String()
+ok ? foo : $env?.greet
+ok ? foo : add
+ok ? foo : array?.[i]
 ok ? foo : foo
-ok ? foo : greet
-ok ? foo : half
-ok ? foo : i32
-ok ? foo : i32 > i32
-ok ? foo : i64
+ok ? foo : foo?.Bar
+ok ? foo : foo?.String
 ok ? foo : list
-ok ? foo : ok
-ok ? foo : score
-ok ? foo.Qux : ok
-ok ? greet : 0.5 > i
-ok ? greet : 1 <= 0.5
-ok ? greet : add
-ok ? greet : div
-ok ? greet : f32
+ok ? foo not in list : array
+ok ? greet : array
 ok ? greet : f64
 ok ? greet : foo
-ok ? greet : half
-ok ? greet : i64
-ok ? greet : list
-ok ? greet : map(list, i)
-ok ? greet : ok
-ok ? greet : score
-ok ? half : add
-ok ? half : f32
-ok ? half : f64
-ok ? half : foo
-ok ? half : foo?.Qux
-ok ? half : greet
-ok ? half : half
-ok ? half : list
-ok ? half : nil in list
-ok ? half : ok
-ok ? half : reduce(list, "bar")
-ok ? half : string(array)
-ok ? half(1) : add
-ok ? i : 1 / i64
-ok ? i : add
-ok ? i : array
-ok ? i : f32 <= 0.5
+ok ? greet : groupBy($env, greet)?.[i]
+ok ? greet : i
+ok ? greet : list | mean(nil)
+ok ? greet : sortBy($env, 1)
+ok ? greet : str
+ok ? greet : {foo: true}
+ok ? i : $env?.[greet]
 ok ? i : foo
-ok ? i : half
-ok ? i : i
-ok ? i : i32
-ok ? i : i64
 ok ? i : list
-ok ? i : ok
-ok ? i : score
-ok ? i32 : 1 - f64
-ok ? i32 : add
-ok ? i32 : div
-ok ? i32 : f32
-ok ? i32 : f32 + 0.5
-ok ? i32 : f64
-ok ? i32 : foo
-ok ? i32 : foo.Qux
-ok ? i32 : greet
-ok ? i32 : i
-ok ? i32 : i32
-ok ? i32 : i32 + i32
-ok ? i32 : list
-ok ? i32 : ok
-ok ? i32 : score
-ok ? i64 : (ok ? list : half)
-ok ? i64 : div
-ok ? i64 : f32
-ok ? i64 : foo
-ok ? i64 : foo.String
-ok ? i64 : half
-ok ? i64 : i
-ok ? i64 : i32
-ok ? i64 : i64
-ok ? i64 : list
-ok ? i64 : ok
-ok ? i64 ^ f32 : foo
-ok ? list : 0.5 * f64
-ok ? list : add
-ok ? list : array
-ok ? list : div
-ok ? list : div(i64, 1)
-ok ? list : f32
-ok ? list : foo.String
-ok ? list : greet
-ok ? list : half
-ok ? list : i
-ok ? list : i - f32
-ok ? list : i64
-ok ? list : list
-ok ? list : list != array
-ok ? list : not ok
-ok ? list : score
-ok ? map(list, #) : add
-ok ? nil : 0.5 <= f64
-ok ? nil : foo.Qux
-ok ? nil : foo?.Bar
-ok ? not false : i32
-ok ? ok : 0.5 ** i32
-ok ? ok : add
-ok ? ok : array
-ok ? ok : div
-ok ? ok : f32
-ok ? ok : f64 ** int(f64)
+ok ? i : list?.[i]
+ok ? list : $env.i
+ok ? list : f64
+ok ? list : foo
+ok ? list : str
+ok ? nil : $env not matches $env?.[i]
+ok ? nil : $env.foo
+ok ? nil : $env?.String
+ok ? nil : $env?.[String]
+ok ? nil : $env?.[greet]
+ok ? nil : $env?.[ok]
+ok ? nil : $env?.i
+ok ? nil : $env?.ok
+ok ? nil : $env?.str
+ok ? nil : foo.String
+ok ? ok : $env | filter(one(array, ok))
+ok ? ok : $env.list
+ok ? ok : $env?.[array]
+ok ? ok : false and ok
 ok ? ok : foo
-ok ? ok : foo.String
-ok ? ok : greet
-ok ? ok : half
-ok ? ok : i32
-ok ? ok : i64
-ok ? ok : list
-ok ? ok : ok
-ok ? reduce(array, false) : score
-ok ? reduce(list, #) : list
-ok ? score : 1 == i32
-ok ? score : div
-ok ? score : f32
-ok ? score : f64
-ok ? score : greet
-ok ? score : half
-ok ? score : i
-ok ? score : i32
-ok ? score : min(i64)
-ok ? score : score
-ok ? score : true == nil
-ok ? toJSON(i64) : div
-ok and !ok
-ok and "bar" < "foo"
-ok and ("foo" not contains "bar")
-ok and 1 < i64
-ok and 1 == 1
-ok and 1 == i64
-ok and add == nil
-ok and f32 != 1
-ok and f32 >= 1
-ok and greet == greet
-ok and i == 0.5
-ok and i32 < f32
-ok and i32 <= i64
-ok and i32 > i32
-ok and i64 < i32
-ok and i64 <= i64
-ok and i64 > 1
-ok and i64 >= i
-ok and i64 in array
-ok and list != nil
-ok and nil == array
-ok and nil == nil
-ok and nil in array
-ok and nil in list
+ok ? ok : foo | date(list)
+ok ? reduce($env, $env, true) : foo?.Bar
+ok ? str : $env?.String(i)?.ok
+ok ? str : $env?.foo
+ok ? str : $env?.ok
+ok ? str : f64
+ok ? str : foo
+ok ? str : ok
+ok ? true : foo?.String
+ok ? true ?: 0 : str
+ok ?: $env not endsWith str
+ok ?: $env | any(.Bar)
+ok ?: $env | filter(.Bar)
+ok ?: $env | find(#.str)
+ok ?: $env | one(#.Bar)
+ok ?: $env | reduce(#)
+ok ?: $env | sortBy(.i != #)
+ok ?: $env | sortBy(foo)
+ok ?: $env.add
+ok ?: $env.array
+ok ?: $env.f64
+ok ?: $env.foo
+ok ?: $env.ok
+ok ?: $env.str
+ok ?: $env?.[Bar]
+ok ?: $env?.[Bar]?.str
+ok ?: $env?.[String]
+ok ?: $env?.[add]
+ok ?: $env?.[array]
+ok ?: $env?.[greet]
+ok ?: $env?.[i]
+ok ?: $env?.[ok]
+ok ?: $env?.[str]
+ok ?: $env?.array
+ok ?: $env?.f64
+ok ?: $env?.foo
+ok ?: $env?.greet
+ok ?: $env?.i
+ok ?: $env?.list
+ok ?: $env[foobar not in list:]
+ok ?: $env[foobar:]
+ok ?: 1 % 1
+ok ?: 1.0 | date($env)
+ok ?: add
+ok ?: array
+ok ?: array | sum(greet)
+ok ?: array?.[i]
+ok ?: ceil(f64)
+ok ?: count($env)
+ok ?: count(array)
+ok ?: count(list)
+ok ?: date(false)
+ok ?: f64
+ok ?: foo
+ok ?: foo not in $env
+ok ?: foo?.Bar
+ok ?: foo?.String
+ok ?: foo?.String()
+ok ?: fromJSON(str)
+ok ?: greet
+ok ?: greet($env)
+ok ?: i
+ok ?: i == 1
+ok ?: i >= i
+ok ?: int(1.0)
+ok ?: list
+ok ?: list | findIndex($env)
+ok ?: max(list)
+ok ?: nil in $env
+ok ?: ok
+ok ?: str
+ok ?: str startsWith $env
+ok ?: sum($env)
+ok and $env != 0
+ok and $env != 1.0
+ok and $env != false
+ok and $env != list
+ok and $env == list
+ok and $env in array
+ok and $env.ok
+ok and $env?.Bar
+ok and $env?.Bar?.foobar
+ok and $env?.String
+ok and $env?.[Bar]
+ok and $env?.[Bar]?.array
+ok and $env?.[String]
+ok and $env?.[String]?.[add]
+ok and $env?.[foobar]
+ok and $env?.[str]
+ok and $env?.foobar
+ok and $env?.nil?.f64
+ok and $env?.ok
+ok and 0 != nil
+ok and 0 < i
+ok and 1.0 != i
+ok and 1.0 <= i
+ok and 1.0 not in array
+ok and add == $env
+ok and array != array
+ok and f64 not in array
+ok and false && $env
+ok and false ? $env : $env
+ok and foo != foo
+ok and foo == nil
+ok and i < i
+ok and i == f64
+ok and last($env)
+ok and nil != ok
+ok and nil == $env
 ok and nil not in array
-ok and not ok
-ok and not true
 ok and ok
-ok and ok && ok
-ok and true ? f64 : add
-ok and true ? greet : i
-ok in groupBy(array, "bar")
-ok in groupBy(list, #)
-ok in groupBy(list, i32)
-ok in {"bar": true}?.greet
-ok not in groupBy(array, # != i32)
-ok not in groupBy(array, 0.5)
-ok not in groupBy(array, f64)
-ok not in groupBy(list, #)?.f64
-ok not in groupBy(list, f64)?.Bar
-ok or !ok
-ok or !true
-ok or "bar" endsWith "foo"
-ok or 0.5 != f32
-ok or 0.5 != nil
-ok or 0.5 == i
-ok or 1 != f32
-ok or 1 <= 1
+ok and ok ? add : i
+ok and str not startsWith str
+ok and true != false
+ok and true && $env
+ok and true || $env.ok
+ok and {foo: i}?.foo
+ok in $env && false
+ok in $env?.Bar
+ok in $env?.String
+ok in $env?.[Bar]
+ok in $env?.[String]
+ok in $env?.[foobar]
+ok in $env?.foobar
+ok in [false]
+ok in [ok]
+ok in concat(array)
+ok in sort(array)
+ok not in $env || true
+ok not in $env?.Bar
+ok not in $env?.Bar?.list
+ok not in $env?.String
+ok not in $env?.[Bar]
+ok not in $env?.[Bar]?.[foo]
+ok not in $env?.[Bar]?.ok()
+ok not in $env?.[String]
+ok not in $env?.[String]?.String
+ok not in $env?.[foobar]
+ok not in $env?.false?.[i]
+ok not in [0, nil]
+ok not in [false]
+ok not in [true]
+ok not in groupBy(list, i)
+ok not in last($env)
+ok not in map($env, false)
+ok or $env != 1
+ok or $env * f64
+ok or $env == $env
+ok or $env == $env?.foo
+ok or $env == array
+ok or $env == list
+ok or $env == ok
+ok or $env > str
+ok or $env >= i
+ok or $env ?: ok
+ok or $env and $env?.String
+ok or $env not startsWith str
+ok or $env or $env
+ok or $env || true
+ok or $env.ok
+ok or $env?.Bar
+ok or $env?.Bar()
+ok or $env?.Bar(list())
+ok or $env?.Bar(list)
+ok or $env?.Bar(one(foobar, false))
+ok or $env?.String
+ok or $env?.String(1.0, i)?.f64
+ok or $env?.[$env]?.ok(foobar?.str)
+ok or $env?.[1.0 not matches f64]
+ok or $env?.[Bar]
+ok or $env?.[Bar]?.[list]
+ok or $env?.[String]
+ok or $env?.[String].list
+ok or $env?.[add]
+ok or $env?.[array]
+ok or $env?.[array].ok
+ok or $env?.[f64]
+ok or $env?.[f64].i
+ok or $env?.[foo not in foobar]
+ok or $env?.[foo]
+ok or $env?.[foobar]
+ok or $env?.[greet()]
+ok or $env?.[greet]
+ok or $env?.[i]
+ok or $env?.[list]
+ok or $env?.[list]?.add()
+ok or $env?.[ok | reduce(foo)]
+ok or $env?.[ok()]
+ok or $env?.[ok]
+ok or $env?.[str]
+ok or $env?.[str]?.[f64]
+ok or $env?.ok
+ok or $env?.upper(1.0, 0, foo)
+ok or $env[$env:foobar]?.[foo]?.[foo]
+ok or $env[:nil .. add]
+ok or $env[add.Bar():]
+ok or $env[foobar.foo(nil):f64?.[foo]]
+ok or $env[foobar:]
+ok or $env[nil matches i:foobar not startsWith foobar]
+ok or $env[ok():]
+ok or $env[ok:]
+ok or 0 == nil
+ok or 0 == nil ? 0 : array
+ok or 1 <= 1.0
 ok or 1 <= i
-ok or div != nil
-ok or f32 != f32
-ok or f32 == 0.5
-ok or f32 == f32
-ok or f64 <= 1
-ok or false ? ok : 1
-ok or false and false
-ok or foo != foo
-ok or i < 1
-ok or i == 0.5
-ok or i == f32
-ok or i32 < 1
-ok or i32 > f64
-ok or i64 != i32
-ok or i64 > i64
-ok or i64 >= 0.5
-ok or i64 not in array
-ok or nil != "foo"
-ok or nil != f64
+ok or 1 >= 1.0
+ok or 1.0 < 0
+ok or 1.0 < 1.0
+ok or 1.0 <= $env
+ok or 1.0 <= f64
+ok or 1.0 <= f64 + 1
+ok or 1.0 == $env
+ok or 1.0 >= $env
+ok or 1.0 >= 1
+ok or 1.0 in $env
+ok or abs($env)
+ok or array != nil
+ok or f64 <= i
+ok or f64 == nil
+ok or f64 > $env
+ok or f64 > 1
+ok or f64 > f64
+ok or f64 >= 0
+ok or false ? foo : foo
+ok or false or ok
+ok or false || false
+ok or find($env, .greet)
+ok or find($env, .str)
+ok or foo != $env.foo
+ok or foo in $env
+ok or foo in list
+ok or foo in sum($env)
+ok or foo not in groupBy($env, 1)
+ok or fromJSON($env)
+ok or greet != $env
+ok or greet not in $env
+ok or i == nil
+ok or mean(array)
+ok or nil != $env
 ok or nil != foo
-ok or nil != greet
-ok or nil != ok
-ok or nil == div
-ok or not false
-ok or not ok
+ok or nil != str
+ok or nil == add
+ok or nil == array
+ok or none($env, #)
 ok or ok
-ok or ok == true
-ok or true || true
-ok or {"foo": false}.String
-ok || !ok
-ok || (nil not in list)
-ok || 0.5 < f32
-ok || 0.5 > 0.5
-ok || 0.5 > 1
-ok || 0.5 >= f64
-ok || 1 != nil
-ok || 1 < i32
-ok || 1 == i
-ok || f32 >= 1
-ok || f64 < 1
-ok || f64 == i
-ok || f64 > f64
-ok || f64 >= i64
-ok || false ? half : i64
-ok || foo == foo
-ok || i == i
-ok || i32 < f32
-ok || i32 <= 0.5
-ok || i32 == i
-ok || i32 > 0.5
-ok || i32 >= i32
-ok || i64 != i32
-ok || i64 == 0.5
-ok || list == list
-ok || nil == 0.5
-ok || nil == array
-ok || nil == nil
+ok or ok == false
+ok or ok or ok
+ok or reduce($env, ok)
+ok or sortBy($env, 1.0)
+ok or sortBy($env, true)?.array?.[array]
+ok or str + $env
+ok or str == $env
+ok or str not endsWith $env
+ok or str not in foo
+ok or sum($env)
+ok or true == $env?.[String]
+ok or true == nil
+ok or true or $env?.String(i)
+ok or true || ok
+ok or {foo: nil}?.i
+ok || $env != false
+ok || $env + i
+ok || $env < $env
+ok || $env <= 0
+ok || $env == $env
+ok || $env == list
+ok || $env >= str
+ok || $env matches $env
+ok || $env not contains str
+ok || $env not in str
+ok || $env or false
+ok || $env || $env
+ok || $env.ok
+ok || $env?.$env.str
+ok || $env?.Bar
+ok || $env?.Bar()
+ok || $env?.String
+ok || $env?.String()
+ok || $env?.String?.ok()?.array
+ok || $env?.[Bar]
+ok || $env?.[String]
+ok || $env?.[String]?.Bar
+ok || $env?.[add]
+ok || $env?.[all(foobar, foobar)]
+ok || $env?.[array]
+ok || $env?.[f64]
+ok || $env?.[f64].str(list?.[ok])
+ok || $env?.[foo]
+ok || $env?.[foobar startsWith foobar]
+ok || $env?.[foobar?.i]
+ok || $env?.[greet]
+ok || $env?.[greet]?.String
+ok || $env?.[greet]?.f64
+ok || $env?.[i]
+ok || $env?.[i].str
+ok || $env?.[i]?.[foo]
+ok || $env?.[list]
+ok || $env?.[nil endsWith list]
+ok || $env?.[ok]
+ok || $env?.[str()]
+ok || $env?.[str]
+ok || $env?.[str].list
+ok || $env?.foobar
+ok || $env?.ok
+ok || $env?.sortBy(nil)
+ok || $env?.toPairs(add, true)
+ok || $env[1.0:]
+ok || $env[:String()]
+ok || $env[:add()]
+ok || $env[:foo]
+ok || $env[:foobar]
+ok || $env[Bar(foo):add and foobar]
+ok || $env[add():]
+ok || $env[add:foobar]
+ok || $env[f64.ok:array(foobar, foobar, String)]
+ok || $env[f64:ok(true)]
+ok || $env[foo:foobar]
+ok || $env[foobar:]
+ok || $env[str?.add:groupBy(i, foobar)]
+ok || 0 == $env
+ok || 0 == 1
+ok || 0 == 1.0
+ok || 1 > 1
+ok || 1.0 != f64
+ok || 1.0 * $env
+ok || 1.0 - $env?.[ok]
+ok || 1.0 <= 1
+ok || 1.0 <= i
+ok || 1.0 == 1
+ok || 1.0 == 1.0
+ok || 1.0 in $env
+ok || add not in $env
+ok || any($env, #)
+ok || any($env, .list)
+ok || f64 != $env
+ok || f64 != f64
+ok || f64 + $env
+ok || f64 < $env
+ok || f64 > $env
+ok || f64 > 1
+ok || false ?: foo
+ok || false not in sum(list, $env)
+ok || foo == nil
+ok || foo not in list
+ok || fromJSON($env)
+ok || greet != nil
+ok || greet == $env
+ok || i * $env
+ok || i + $env
+ok || i < f64
+ok || i > i
+ok || list != list
+ok || mean(list)
+ok || median(array)
+ok || median(array, 1)
+ok || median(array, str)
+ok || min($env)
+ok || nil != add
+ok || nil != i
+ok || nil != true
+ok || nil == false
+ok || nil in $env?.String
+ok || nil in array
 ok || nil not in array
-ok || not false
-ok || not ok
 ok || ok
-ok || ok ? f64 : i64
-ok || ok ? ok : score
-ok || ok or ok
-ok || reduce(array, false)
-ok || true ? add : ok
-one(1 .. i64, ok)
-one([div], nil == i32)
-one([false], i64 != i32)
-one(array, !(# <= 0.5))
-one(array, !false)
-one(array, !ok)
-one(array, !true)
-one(array, "bar" matches "bar")
+ok || ok == ok
+ok || ok ?: foo
+ok || ok || $env
+ok || one($env, .add)
+ok || sortBy($env, array).str
+ok || sortBy($env, foo, 1)
+ok || sortBy($env, i, str)
+ok || str != $env
+ok || str != nil
+ok || str != str
+ok || str <= str
+ok || str contains $env
+ok || str endsWith str
+ok || sum($env)
+ok || true && $env
+ok || true and $env
+ok || true and true
+ok || {foo: nil}?.add
+ok; add
+ok; f64
+ok; foo?.String; groupBy(list, #)
+ok; greet
+ok; list
+ok; ok
+ok; str
+one($env | map(true), ok)
+one($env, true) ?: greet
+one($env, true) || $env?.Bar
+one($env.array, nil != true)
+one($env?.[str], ok)
+one($env?.array, ok)
+one($env?.list, 0 <= 1.0)
+one($env?.list, ok)
+one([$env], #.ok)
+one([$env], .array != add)
+one([false], 0 <= f64)
+one([foo], ok)
+one([i], ok)
+one([ok], #)
+one([str], none($env, false))
 one(array, # != #)
-one(array, # != 0.5)
-one(array, # != 1)
-one(array, # != f32)
-one(array, # != f64)
-one(array, # != i)
-one(array, # != i32)
-one(array, # != nil)
-one(array, # / i >= f64)
-one(array, # < #)
-one(array, # < 0.5)
-one(array, # < 1)
-one(array, # < f32)
-one(array, # < i64)
-one(array, # <= #)
-one(array, # <= 0.5)
+one(array, # <= 0)
 one(array, # <= 1)
-one(array, # <= f32)
-one(array, # <= f64)
-one(array, # <= i32)
-one(array, # == #)
-one(array, # == 0.5)
 one(array, # == 1)
-one(array, # == nil)
-one(array, # > #)
-one(array, # > f32)
-one(array, # > f64)
-one(array, # > i32)
 one(array, # >= #)
-one(array, # >= 0.5)
-one(array, # >= 1)
-one(array, # >= f64)
-one(array, 0.5 != #)
-one(array, 0.5 != i64)
-one(array, 0.5 < #)
-one(array, 0.5 < 0.5)
-one(array, 0.5 <= #)
-one(array, 0.5 == #)
-one(array, 0.5 == 0.5)
-one(array, 0.5 > #)
-one(array, 0.5 > 1)
-one(array, 0.5 >= #)
-one(array, 1 != #)
-one(array, 1 != i64)
-one(array, 1 != nil)
-one(array, 1 < #)
-one(array, 1 < f64)
-one(array, 1 <= #)
-one(array, 1 > 0.5)
-one(array, 1 >= #)
-one(array, add == div)
-one(array, all(array, true))
-one(array, f32 <= #)
-one(array, f32 <= 0.5)
-one(array, f32 >= #)
-one(array, f64 < #)
-one(array, f64 == #)
-one(array, f64 >= #)
-one(array, f64 >= 1)
-one(array, f64 >= i32)
-one(array, f64 in array)
-one(array, false || true)
-one(array, i < #)
-one(array, i > 0.5)
-one(array, i > f64)
-one(array, i32 != #)
-one(array, i32 < #)
-one(array, i32 <= #)
-one(array, i32 > #)
-one(array, i32 >= #)
-one(array, i64 != #)
-one(array, i64 < #)
-one(array, i64 == #)
-one(array, i64 == f32)
-one(array, i64 >= #)
-one(array, i64 >= f64)
-one(array, list != array)
-one(array, nil != #)
-one(array, nil != i64)
-one(array, not ok)
+one(array, $env && false)
+one(array, $env.ok)
+one(array, 0 >= 0)
+one(array, 1.0 < #)
+one(array, 1.0 <= #)
+one(array, f64 == i)
+one(array, false and $env?.[ok])
+one(array, false) != $env?.ok
+one(array, i != $env)
+one(array, i <= f64)
+one(array, list != $env)
+one(array, nil != add)
+one(array, nil in $env)
 one(array, ok)
-one(array, one(list, false))
-one(array, true != false)
-one(array, true == nil)
-one(array, true) ? greet : add
-one(array, true) or 1 != nil
-one(false ? greet : "bar", f64 != #)
-one(groupBy(array, f64).array, .i(nil).ok)
-one(groupBy(list, ok).foo, .add?.array)
-one(i32 .. 1, # == #)
-one(i32 .. i32, not ok)
-one(i64 .. 1, # >= 1)
-one(i64 .. i32, # != #)
-one(i64 .. i32, # >= #)
-one(list, !(i64 != 1))
-one(list, !false)
-one(list, !ok)
-one(list, "foo" < "bar")
-one(list, "foo" not endsWith "bar")
-one(list, "foo" not in #)
-one(list, "foo" startsWith "bar")
-one(list, # != #)
+one(array, str > str)
+one(array, true) == ok
+one(if ok { $env } else { add }, ok)
 one(list, # != foo)
 one(list, # == #)
-one(list, # in list)
-one(list, # not in list)
-one(list, 0.5 < 1)
-one(list, 0.5 <= 0.5)
-one(list, 0.5 == f64)
-one(list, 1 > i)
-one(list, add != nil)
-one(list, all(array, true))
-one(list, any(list, true))
-one(list, div != nil)
-one(list, f32 == nil)
-one(list, f32 > i)
-one(list, f32 >= 1)
-one(list, f64 >= 1)
-one(list, false == nil)
+one(list, $env != i)
+one(list, $env == foo)
+one(list, $env?.ok)
+one(list, 1 <= f64)
+one(list, 1.0 == $env)
+one(list, any(list, ok))
+one(list, f64 == 1)
 one(list, foo != #)
-one(list, foo != nil)
-one(list, foo == #)
 one(list, greet == nil)
-one(list, half == nil)
-one(list, i <= i64)
-one(list, i > f64)
-one(list, i > i32)
-one(list, i32 != f32)
-one(list, i64 == 1)
-one(list, nil != #)
-one(list, nil != half)
-one(list, nil == #)
-one(list, nil == f64)
-one(list, ok or true)
+one(list, i == 0)
+one(list, list != $env)
+one(list, nil == list)
+one(list, nil not in $env)
 one(list, ok)
-one(list, ok) or 0.5 == nil
-one(list, score != nil)
-one(list, true == nil)
-one(list[i64:i32], i != i)
-one(map(array, "bar"), not false)
-one(map(array, #), # != #)
-one(map(array, #), # >= #)
-one(map(array, #), i32 == #)
-one(map(array, 1), ok)
-one(map(array, div), # == #)
-one(map(array, f64), # < 0.5)
-one(map(array, false), #)
-one(map(array, i), ok)
-one(map(array, list), ok)
-one(map(array, true), #)
-one(map(list, ok), #)
-one(map(list, score), # != #)
-one(ok ? "foo" : false, # > #)
-one(reduce(array, array), ok)
-one(true ? array : 1, # <= #)
-reduce(1 .. 1, #)
-reduce(1 .. 1, f32 >= i)
-reduce(1 .. i64, array)
-reduce(1 .. i64, greet)
-reduce(1 .. i64, half)
-reduce(["foo"], f32)
-reduce([0.5], f64)
-reduce([div, "foo"], i32)
-reduce([f32, f64], f32)
+one(list, str < #.Bar)
+one(list, str >= str)
+one(list, true != $env)
+one(sort($env), $env == nil)
+one(sort($env), .greet[:.i])
+one(sort($env), ok)
+reduce($env | map(1.0), str)
+reduce($env, #.list) == 1 && false
+reduce($env, $env, $env).greet
+reduce($env, $env, $env)?.f64
+reduce($env, $env, $env)?.greet
+reduce($env, $env, 1)?.f64
+reduce($env, $env, 1.0)?.add
+reduce($env, $env, false).str
+reduce($env, $env, foo)?.str
+reduce($env, $env, greet).String
+reduce($env, $env, greet)?.greet
+reduce($env, $env, i)?.f64
+reduce($env, $env, list)?.add
+reduce($env, $env, nil)?.str
+reduce($env, array, 1.0) | all(false)
+reduce($env, array, false)?.[i]
+reduce($env, foo, 1).Bar
+reduce($env, foo, false).Bar
+reduce($env, foo, nil)?.Bar
+reduce($env.array, #)
+reduce($env.array, i)
+reduce($env.array, last($env))
+reduce($env.array, mean(f64, #))
+reduce($env.array, str)
+reduce($env.list, #)
+reduce($env.list, #.Bar)
+reduce($env.list, #?.Bar)
+reduce($env.list, 1.0 + 1.0)
+reduce($env.list, [nil])
+reduce($env.list, add)
+reduce($env.list, array)
+reduce($env.list, f64 ^ 1)
+reduce($env.list, greet)
+reduce($env.list, str)
+reduce($env?.[str], #)
+reduce($env?.[str], #index != #)
+reduce($env?.[str], foo)
+reduce($env?.[str], list)
+reduce($env?.[str], nil != list)
+reduce($env?.[str], ok)
+reduce($env?.[str], str)
+reduce($env?.array, # != f64)
+reduce($env?.array, # < #)
+reduce($env?.array, # >= 1.0)
+reduce($env?.array, #)
+reduce($env?.array, #acc ** #)
+reduce($env?.array, #acc)
+reduce($env?.array, add)
+reduce($env?.array, foo)
+reduce($env?.array, i != #)
+reduce($env?.array, list | groupBy(foo))
+reduce($env?.array, list)
+reduce($env?.list, #)
+reduce($env?.list, #.String)
+reduce($env?.list, #.String, array)
+reduce($env?.list, .Bar)
+reduce($env?.list, add)
+reduce($env?.list, i ^ 0)
+reduce($env?.list, i in array)
+reduce($env?.list, i)
+reduce($env?.list, ok)
+reduce(1 .. 1, #acc?.[foo])
+reduce([$env], #.Bar)
+reduce([$env], #.String != $env)
+reduce([$env], #.foo?.[list])
+reduce([$env], .str)
+reduce([$env], add)
+reduce([$env], f64 <= #.f64)
+reduce([$env], greet)
+reduce([$env], i)
+reduce([$env], round($env))
+reduce([0, $env], array)
+reduce([0], array)
+reduce([1.0, foo], #)
+reduce([1.0], $env[:#])
+reduce([foo], #)
+reduce([foo], #.Bar + #acc)
+reduce([foo], #index)
+reduce([foo], foo).String
+reduce([foo], greet)
 reduce([foo], ok)
-reduce([i32], list)
-reduce([i64, half], "bar" not startsWith "foo")
-reduce([i], # < #)
-reduce([i], ok)
-reduce([list], f64)
-reduce([nil], # in array)
-reduce(array, !false)
-reduce(array, "foo" endsWith "foo")
-reduce(array, "foo") not in foo
+reduce([greet, greet], str)
+reduce([i, 1.0], # != #)
+reduce([i, i], foo)
+reduce([list], #)
+reduce([list], greet)
+reduce([nil != true], list)
+reduce([ok], #)
+reduce([ok], add)
+reduce([str], i)
+reduce([true], foo.Bar)
+reduce(array | map(#), f64)
+reduce(array | map(#), foo)
+reduce(array | map($env), #index)
+reduce(array | map(foo), f64)
+reduce(array | sortBy(#), ok)
+reduce(array | sortBy(1), #acc)
 reduce(array, # != #)
-reduce(array, # != 1)
-reduce(array, # != i32)
-reduce(array, # != nil)
-reduce(array, # % #)
-reduce(array, # % i64)
+reduce(array, # % i)
 reduce(array, # * #)
-reduce(array, # * 0.5)
-reduce(array, # * 1)
-reduce(array, # * f32)
-reduce(array, # * i)
-reduce(array, # * i32)
-reduce(array, # * i64)
-reduce(array, # ** #)
-reduce(array, # ** f32)
-reduce(array, # ** i32)
-reduce(array, # + #)
-reduce(array, # + 0.5)
-reduce(array, # + 1)
-reduce(array, # + i)
-reduce(array, # + i64)
-reduce(array, # - #)
-reduce(array, # - 0.5)
-reduce(array, # - 1)
-reduce(array, # - i)
-reduce(array, # - i32)
-reduce(array, # - i64)
-reduce(array, # .. #)
-reduce(array, # .. i32)
+reduce(array, # + 0)
 reduce(array, # / #)
-reduce(array, # / 0.5)
-reduce(array, # / 1)
-reduce(array, # / f32)
-reduce(array, # / i32)
-reduce(array, # < #)
-reduce(array, # < 0.5)
-reduce(array, # < 1)
-reduce(array, # < i32)
 reduce(array, # <= #)
-reduce(array, # <= 0.5)
-reduce(array, # <= f32)
-reduce(array, # <= i32)
 reduce(array, # == #)
-reduce(array, # == 0.5)
-reduce(array, # == 1)
-reduce(array, # == f32)
-reduce(array, # == i32)
-reduce(array, # == i64)
-reduce(array, # == nil)
-reduce(array, # > #)
-reduce(array, # > 1)
-reduce(array, # > f64)
 reduce(array, # > i)
 reduce(array, # >= #)
-reduce(array, # >= f32)
-reduce(array, # >= f64)
-reduce(array, # >= i32)
-reduce(array, # >= i64)
 reduce(array, # ^ #)
-reduce(array, # ^ 0.5)
-reduce(array, # ^ f32)
-reduce(array, # ^ f64)
-reduce(array, # ^ i64)
 reduce(array, # in array)
-reduce(array, # not in array)
 reduce(array, #)
-reduce(array, #) != 0.5 == true
-reduce(array, #) != 0.5 ? ok : nil
-reduce(array, #) != f32
-reduce(array, #) != i32
-reduce(array, #) != i64
-reduce(array, #) % i
-reduce(array, #) % i32
-reduce(array, #) % i64
-reduce(array, #) * i
-reduce(array, #) * i32
-reduce(array, #) * len("foo")
-reduce(array, #) ** f64
-reduce(array, #) ** min(1, i32)
-reduce(array, #) + i
-reduce(array, #) + i64
-reduce(array, #) + reduce(array, #)
-reduce(array, #) - f64
-reduce(array, #) - i
-reduce(array, #) - max(f32)
-reduce(array, #) .. i
-reduce(array, #) .. i32
-reduce(array, #) .. i64
-reduce(array, #) / f32
-reduce(array, #) / f64
-reduce(array, #) / i32
-reduce(array, #) / i64
-reduce(array, #) < f32
-reduce(array, #) < f32 / 0.5
-reduce(array, #) < f64
-reduce(array, #) < i
-reduce(array, #) <= -1
-reduce(array, #) <= f32
-reduce(array, #) <= f64
-reduce(array, #) <= f64 * 0.5
-reduce(array, #) <= i
-reduce(array, #) == f64
-reduce(array, #) == i64
-reduce(array, #) > i32
-reduce(array, #) >= f32
-reduce(array, #) >= f64
-reduce(array, #) >= i32
-reduce(array, #) >= i64
-reduce(array, #) ^ f32 ** 0.5
-reduce(array, #) ^ i32
-reduce(array, #) not in array
-reduce(array, #) not in map(array, #)
-reduce(array, (0.5 + #) * f32)
-reduce(array, -#)
-reduce(array, -(# - #))
-reduce(array, -0.5)
-reduce(array, -1)
-reduce(array, -f32)
-reduce(array, -f64)
-reduce(array, -i)
-reduce(array, -i32)
-reduce(array, -i64)
-reduce(array, 0.5 != #)
-reduce(array, 0.5 != 0.5)
-reduce(array, 0.5 * #)
-reduce(array, 0.5 ** #)
-reduce(array, 0.5 ** 1)
-reduce(array, 0.5 + #)
-reduce(array, 0.5 - #)
-reduce(array, 0.5 - i64)
-reduce(array, 0.5 / #)
-reduce(array, 0.5 / f32)
-reduce(array, 0.5 < #)
-reduce(array, 0.5 < 1)
-reduce(array, 0.5 <= #)
-reduce(array, 0.5 <= 1)
-reduce(array, 0.5 == #)
-reduce(array, 0.5 == f64)
-reduce(array, 0.5 == i64)
-reduce(array, 0.5 > #)
-reduce(array, 0.5 > 0.5)
-reduce(array, 0.5 >= 0.5)
-reduce(array, 0.5 >= 1)
-reduce(array, 0.5 ^ #)
-reduce(array, 0.5 ^ 0.5)
-reduce(array, 0.5) * f32
-reduce(array, 0.5) - i
-reduce(array, 0.5) > i64 ? 1 : 0.5
-reduce(array, 1 != #)
-reduce(array, 1 * f64)
-reduce(array, 1 ** #)
-reduce(array, 1 + #)
-reduce(array, 1 - #)
-reduce(array, 1 - 1)
-reduce(array, 1 / i32)
-reduce(array, 1 < #)
-reduce(array, 1 >= #)
-reduce(array, 1 ^ #)
-reduce(array, 1 ^ 0.5)
-reduce(array, 1 ^ i32)
-reduce(array, 1) % i32
-reduce(array, 1) ** f32
-reduce(array, 1) + f64
-reduce(array, 1) / f64
-reduce(array, 1) / i32
-reduce(array, 1) <= i32
-reduce(array, 1) ^ i
-reduce(array, 1) not in array
-reduce(array, [#])
-reduce(array, abs(#))
-reduce(array, abs(f64))
-reduce(array, abs(i64))
-reduce(array, add(#, #))
+reduce(array, #) * f64
+reduce(array, #, add)
+reduce(array, #, array)
+reduce(array, #, i) | mean(array)
+reduce(array, #, ok)
+reduce(array, #acc)
+reduce(array, #acc, nil)?.list
+reduce(array, #index != f64)
+reduce(array, #index ** 1.0)
+reduce(array, #index ** f64)
+reduce(array, #index)
+reduce(array, $env != foo)
+reduce(array, $env == #)
+reduce(array, $env) | count(false)
+reduce(array, $env).Bar
+reduce(array, $env).String
+reduce(array, $env).add
+reduce(array, $env).array
+reduce(array, $env).f64
+reduce(array, $env).foobar
+reduce(array, $env).greet
+reduce(array, $env).i
+reduce(array, $env).list
+reduce(array, $env).str
+reduce(array, $env)?.Bar
+reduce(array, $env)?.String
+reduce(array, $env)?.[str]
+reduce(array, $env)?.add
+reduce(array, $env)?.array
+reduce(array, $env)?.f64
+reduce(array, $env)?.foo
+reduce(array, $env)?.greet
+reduce(array, $env)?.i
+reduce(array, $env)?.list
+reduce(array, $env)?.ok
+reduce(array, $env)?.str
+reduce(array, $env, $env)?.str
+reduce(array, $env, 0)?.String
+reduce(array, $env, f64)?.[str]
+reduce(array, $env, foo)?.ok
+reduce(array, $env, str)?.greet
+reduce(array, $env, true).array
+reduce(array, $env.array)
+reduce(array, $env.greet)
+reduce(array, $env.i)
+reduce(array, $env.str)
+reduce(array, $env?.add)
+reduce(array, $env?.f64)
+reduce(array, $env?.foo)
+reduce(array, $env?.greet)
+reduce(array, $env?.list, greet)
+reduce(array, $env?.str)
+reduce(array, 0) | min(1.0)
+reduce(array, 1 != $env)
+reduce(array, 1 != nil)
+reduce(array, 1.0 != #)
+reduce(array, 1.0 != 1)
+reduce(array, 1.0 * #)
+reduce(array, 1.0 ** #)
+reduce(array, 1.0 ** #index)
+reduce(array, 1.0 ** 1.0)
+reduce(array, 1.0 - #acc)
+reduce(array, 1.0 - i)
+reduce(array, 1.0 / #)
+reduce(array, 1.0 < #)
+reduce(array, 1.0 == i)
+reduce(array, 1.0 ^ #)
+reduce(array, 1.0) / $env?.i
+reduce(array, 1.0) == $env?.[str]
+reduce(array, 1.0) ^ $env?.f64
+reduce(array, [1.0])
+reduce(array, [flatten(list)])
+reduce(array, [foo])
 reduce(array, add)
-reduce(array, all(list, ok))
+reduce(array, add, f64)
 reduce(array, array)
-reduce(array, array)[i32]
-reduce(array, array[#:#])
-reduce(array, array[i64:#])
-reduce(array, bitand(i32, i32))
+reduce(array, array) | mean(1, i)
+reduce(array, array)?.[i]
+reduce(array, array[1:])
+reduce(array, bitnand(1, #acc))
 reduce(array, bitnot(#))
-reduce(array, bitor(#, #))
-reduce(array, bitshr(#, #))
-reduce(array, bitushr(#, #))
+reduce(array, bitnot(#)) % i
+reduce(array, bitor(i, #))
 reduce(array, ceil(#))
-reduce(array, div(#, #))
-reduce(array, div)
-reduce(array, f32 ** #)
-reduce(array, f32 + #)
-reduce(array, f32 / #)
-reduce(array, f32 <= #)
-reduce(array, f32 == #)
-reduce(array, f32 == i)
-reduce(array, f32 >= #)
-reduce(array, f32 >= 0.5)
-reduce(array, f32 ^ #)
-reduce(array, f32 ^ f32)
-reduce(array, f32 ^ i32)
-reduce(array, f32)
-reduce(array, f32) ** (0.5 * f64)
-reduce(array, f32) <= f32
-reduce(array, f32) not in array
-reduce(array, f64 ** #)
-reduce(array, f64 + #)
-reduce(array, f64 + i32)
-reduce(array, f64 - #)
-reduce(array, f64 / 1)
-reduce(array, f64 < #)
-reduce(array, f64 == #)
-reduce(array, f64 ^ 1)
+reduce(array, concat(list))
 reduce(array, f64)
-reduce(array, f64) != i32
-reduce(array, f64) * i
-reduce(array, f64) / f64
-reduce(array, f64) <= f32
-reduce(array, f64) <= first(array)
-reduce(array, f64) == i
-reduce(array, f64) >= i
-reduce(array, f64) ^ f64
-reduce(array, false ? f64 : #)
-reduce(array, false ? score : #)
-reduce(array, false) ? i64 : f32
-reduce(array, false) || ok
-reduce(array, findLastIndex(list, false))
-reduce(array, findLastIndex(list, reduce(array, true)))
-reduce(array, float(#))
-reduce(array, floor(i64))
+reduce(array, false) == $env?.String
+reduce(array, float(i))
+reduce(array, foo == $env)
 reduce(array, foo)
 reduce(array, foo).Bar
-reduce(array, foo).Qux
 reduce(array, foo).String
-reduce(array, foo).String()
 reduce(array, foo)?.Bar
-reduce(array, foo)?.Qux
 reduce(array, foo)?.String
 reduce(array, foo)?.String()
+reduce(array, foo, 1.0).Bar
+reduce(array, foo, greet)?.String()
+reduce(array, foo, i).Bar
+reduce(array, foo, list).Bar
 reduce(array, foo.Bar)
 reduce(array, foo.String)
-reduce(array, foo?.String())
+reduce(array, foo?.Bar)
 reduce(array, foo?.String)
-reduce(array, get(array, 1))
-reduce(array, get(list, #))
-reduce(array, greet("bar"))
+reduce(array, greet(str))
 reduce(array, greet)
-reduce(array, groupBy(array, #))
-reduce(array, groupBy(list, #))
-reduce(array, groupBy(list, #)?.f32)
-reduce(array, half(1))
-reduce(array, half)
-reduce(array, i != #)
-reduce(array, i % #)
-reduce(array, i * #)
-reduce(array, i ** f64)
-reduce(array, i + 0.5)
-reduce(array, i - #)
-reduce(array, i / #)
+reduce(array, greet, foo)
+reduce(array, i .. #, greet)
 reduce(array, i <= #)
-reduce(array, i <= i64)
-reduce(array, i > i32)
-reduce(array, i ^ #)
+reduce(array, i ^ #acc)
 reduce(array, i)
-reduce(array, i) % i32
-reduce(array, i) + i32
-reduce(array, i) - f32
-reduce(array, i) == 0.5 ** 1
-reduce(array, i32 != #)
-reduce(array, i32 != i32)
-reduce(array, i32 + 0.5)
-reduce(array, i32 - #)
-reduce(array, i32 .. #)
-reduce(array, i32 < #)
-reduce(array, i32 < 1)
-reduce(array, i32 > #)
-reduce(array, i32 >= #)
-reduce(array, i32)
-reduce(array, i32) * 1 * 0.5
-reduce(array, i64 != #)
-reduce(array, i64 % i)
-reduce(array, i64 % i32)
-reduce(array, i64 * #)
-reduce(array, i64 + i32)
-reduce(array, i64 - #)
-reduce(array, i64 .. #)
-reduce(array, i64 .. 1)
-reduce(array, i64 / f64)
-reduce(array, i64 <= #)
-reduce(array, i64 == 1)
-reduce(array, i64 == nil)
-reduce(array, i64 ^ #)
-reduce(array, i64 ^ f64)
-reduce(array, i64)
-reduce(array, i64) + i
-reduce(array, i64) / f64
-reduce(array, i64) < i
-reduce(array, i64) == f32
-reduce(array, int(f64))
-reduce(array, len(array))
+reduce(array, i, array) % i
+reduce(array, i, f64) not in $env?.array
+reduce(array, keys($env))
 reduce(array, list)
-reduce(array, list) != map(list, half)
-reduce(array, map(array, div))
-reduce(array, map(array, score))
-reduce(array, map(list, 1))
-reduce(array, max(#, #, #))
-reduce(array, max(0.5))
-reduce(array, min(#))
-reduce(array, min(#, #, 0.5))
-reduce(array, min(0.5))
-reduce(array, min(1, 1))
-reduce(array, nil != "bar")
-reduce(array, nil != #)
-reduce(array, nil != 1)
-reduce(array, not ok)
-reduce(array, ok ? "foo" : "bar")
-reduce(array, ok ? # : array)
-reduce(array, ok ? # : i)
-reduce(array, ok || true)
+reduce(array, list[:#])
+reduce(array, mean(#))
+reduce(array, median(#))
+reduce(array, ok ? ok : #index)
 reduce(array, ok)
-reduce(array, ok) and ok
-reduce(array, reduce(array, 1))
-reduce(array, reduce(list, 0.5))
-reduce(array, round(0.5))
-reduce(array, score(#))
-reduce(array, score(1, #))
-reduce(array, score)
-reduce(array, string(0.5))
-reduce(array, string(1))
-reduce(array, string(foo))
-reduce(array, string(i32))
-reduce(array, toJSON(i))
-reduce(array, trimPrefix("bar"))
-reduce(array, true && true)
-reduce(array, true ? add : #)
-reduce(array, true) != ok
-reduce(array, true) and ok
+reduce(array, ok, $env.ok)
+reduce(array, reduce(array, #))
+reduce(array, reduce(array, #, i))
+reduce(array, round(#))
+reduce(array, round(1))
+reduce(array, str not in foo)
+reduce(array, str)
+reduce(array, str) | greet()
+reduce(array, string(#))
+reduce(array, sum(array, 1.0))
+reduce(array, toJSON(#))
+reduce(array, toJSON(1.0))
+reduce(array, true and ok)
 reduce(array, type(#))
-reduce(array, type(1))
-reduce(array, type(add))
-reduce(array, type(greet))
-reduce(array, type(score))
-reduce(array, upper("bar"))
-reduce(false ? 0.5 : "bar", # and false)
-reduce(false ? i32 : array, toJSON(#))
-reduce(false ? nil : list, #)
-reduce(filter(array, ok), foo)
-reduce(filter(list, ok), foo.Bar)
-reduce(filter(list, true), i)
-reduce(i .. 1, f64)
-reduce(i .. 1, score)
-reduce(i .. i, #)
-reduce(i .. i, foo)
-reduce(i .. i32, add)
-reduce(i32 .. 1, #)
-reduce(i32 .. 1, foo)
-reduce(i32 .. i, 0.5 - #)
-reduce(i32 .. i32, i64)
-reduce(i32 .. i64, abs(f64))
-reduce(i64 .. 1, -#)
-reduce(i64 .. i, #)
-reduce(i64 .. i, -0.5)
-reduce(i64 .. i, false ? "bar" : #)
-reduce(i64 .. i, i)
-reduce(i64 .. i, ok)
-reduce(i64 .. i, round(i32))
-reduce(i64 .. i64, i64)
-reduce(list, !true)
-reduce(list, "bar" <= "bar")
-reduce(list, "bar" in #)
-reduce(list, "foo" not in #)
-reduce(list, # != #)
-reduce(list, # != foo)
-reduce(list, # != nil)
+reduce(array, uniq(list))
+reduce(array[0:], list)
+reduce(flatten(array), array)
+reduce(flatten(array), foo)
+reduce(flatten(list), #)
+reduce(keys($env), sum(#))
+reduce(let foobar = array; foobar, #)
+reduce(list | map(1), $env?.f64)
+reduce(list | sortBy(1.0), greet)
 reduce(list, # == #)
-reduce(list, # == foo)
-reduce(list, # == nil)
-reduce(list, # in list)
-reduce(list, # not in list)
 reduce(list, #)
-reduce(list, #) != foo
-reduce(list, #) not in groupBy(array, i)
-reduce(list, #) not in list
 reduce(list, #).Bar
-reduce(list, #).Qux
 reduce(list, #).String
 reduce(list, #).String()
 reduce(list, #)?.Bar
-reduce(list, #)?.Qux
 reduce(list, #)?.String
 reduce(list, #)?.String()
-reduce(list, #?.Bar not in # ? # : #)
-reduce(list, #?.Bar)
-reduce(list, #?.Qux("foo"))
-reduce(list, #?.Qux)
-reduce(list, #?.String())
+reduce(list, #, 1.0)?.Bar
+reduce(list, #, array)?.String
+reduce(list, #, f64).String
+reduce(list, #, nil).String
+reduce(list, #, ok)?.Bar
+reduce(list, #.Bar != nil)
+reduce(list, #.Bar)
+reduce(list, #.String)
 reduce(list, #?.String)
-reduce(list, -0.5)
-reduce(list, -f64)
-reduce(list, -i)
-reduce(list, -i32)
+reduce(list, #acc == 0)
+reduce(list, #acc)
+reduce(list, #acc)?.Bar
+reduce(list, #acc, foo).String
+reduce(list, #index)
+reduce(list, $env && true)
+reduce(list, $env).Bar
+reduce(list, $env).String
+reduce(list, $env).add
+reduce(list, $env).array
+reduce(list, $env).array?.[i]
+reduce(list, $env).f64
+reduce(list, $env).foo
+reduce(list, $env).greet
+reduce(list, $env).i
+reduce(list, $env).list
+reduce(list, $env).ok
+reduce(list, $env).str
+reduce(list, $env)?.Bar
+reduce(list, $env)?.String
+reduce(list, $env)?.[str]
+reduce(list, $env)?.add
+reduce(list, $env)?.f64
+reduce(list, $env)?.foobar
+reduce(list, $env)?.greet
+reduce(list, $env)?.i
+reduce(list, $env)?.list
+reduce(list, $env)?.ok
+reduce(list, $env)?.str
+reduce(list, $env, $env)?.i
+reduce(list, $env, add).array
+reduce(list, $env, add).foo
+reduce(list, $env, add)?.list
+reduce(list, $env, foo).ok
+reduce(list, $env, greet)?.Bar?.str
+reduce(list, $env, nil)?.greet
+reduce(list, $env.f64)
+reduce(list, $env.list)
+reduce(list, $env?.[#.Bar])
+reduce(list, $env?.[foobar])
+reduce(list, $env?.add)
+reduce(list, $env?.f64)
+reduce(list, $env?.foo)
+reduce(list, $env?.list)
+reduce(list, $env?.ok)
+reduce(list, $env?.str)
+reduce(list, .Bar not in foo, {foo: str})
 reduce(list, .Bar)
-reduce(list, .Qux)
-reduce(list, .String())
 reduce(list, .String)
-reduce(list, 0.5 != f64)
-reduce(list, 0.5 != nil)
-reduce(list, 0.5 == i64)
-reduce(list, 0.5 >= 0.5)
-reduce(list, 0.5) != i
-reduce(list, 0.5) / i64
-reduce(list, 0.5) < f32
-reduce(list, 0.5) < i
-reduce(list, 0.5) < i32
-reduce(list, 0.5) < i64
-reduce(list, 0.5) <= f32
-reduce(list, 0.5) >= f64
-reduce(list, 0.5) >= i64
-reduce(list, 1 != nil)
-reduce(list, 1 + f64)
-reduce(list, 1 - 0.5)
-reduce(list, 1 / 0.5)
-reduce(list, 1 < f64)
-reduce(list, 1 <= 1)
-reduce(list, 1 == 0.5)
-reduce(list, 1 == nil)
-reduce(list, 1 ^ 1)
-reduce(list, 1) * f64
-reduce(list, 1) + f32
-reduce(list, 1) - i
+reduce(list, 0) != i
+reduce(list, 1) * i
+reduce(list, 1) / i
+reduce(list, 1.0 * f64)
+reduce(list, 1.0 + 1)
+reduce(list, 1.0) * i
+reduce(list, 1.0) == i
+reduce(list, [$env, 0])
+reduce(list, [f64, false])
+reduce(list, add == $env)
 reduce(list, add)
-reduce(list, add) != div
-reduce(list, array != array)
 reduce(list, array)
-reduce(list, div)
-reduce(list, f32 / 0.5)
-reduce(list, f32 < i32)
-reduce(list, f32 <= f32)
-reduce(list, f32)
-reduce(list, f32) == f32
-reduce(list, f64 != nil)
-reduce(list, f64 + 0.5)
-reduce(list, f64 + 1)
-reduce(list, f64 / i32)
-reduce(list, f64 <= i32)
-reduce(list, f64 == f32)
-reduce(list, f64 > f32)
-reduce(list, f64 >= 0.5)
+reduce(list, array) | map(foo)
+reduce(list, array) | sum(#)
+reduce(list, array)?.[i]
+reduce(list, array, add)
+reduce(list, bitnot(1))
+reduce(list, f64 != $env)
+reduce(list, f64 * f64)
+reduce(list, f64 / f64)
 reduce(list, f64)
-reduce(list, f64) * i64
-reduce(list, false == false)
-reduce(list, false ? "foo" : list)
-reduce(list, false ? # : #)
-reduce(list, false || true)
-reduce(list, filter(list, ok))
-reduce(list, findIndex(array, true))
-reduce(list, findLastIndex(list, false))
-reduce(list, float(i))
-reduce(list, floor(0.5))
-reduce(list, foo != #)
+reduce(list, f64, f64)
+reduce(list, false ?: foo)
+reduce(list, false) ? f64 : [false]
+reduce(list, first(#acc))
 reduce(list, foo)
-reduce(list, foo) == foo
 reduce(list, foo).Bar
-reduce(list, foo).Qux
 reduce(list, foo).String
-reduce(list, foo).String()
 reduce(list, foo)?.Bar
-reduce(list, foo)?.Qux
 reduce(list, foo)?.String
-reduce(list, foo)?.String()
-reduce(list, foo.Bar)
+reduce(list, foo, foo)
+reduce(list, foo, i)?.String
+reduce(list, foo, str)
+reduce(list, foo.Bar, list)
 reduce(list, foo.String)
-reduce(list, foo?.Bar)
-reduce(list, foo?.Qux)
+reduce(list, foo?.String())
 reduce(list, foo?.String)
-reduce(list, get(list, i))
-reduce(list, greet != nil)
-reduce(list, greet("bar"))
+reduce(list, greet(#.Bar))
 reduce(list, greet)
-reduce(list, groupBy(array, 1))
-reduce(list, groupBy(list, "bar"))
-reduce(list, groupBy(list, #))
-reduce(list, half(1))
-reduce(list, half)
-reduce(list, i * i64)
-reduce(list, i + 1)
-reduce(list, i - f64)
-reduce(list, i .. 1)
-reduce(list, i == 0.5)
-reduce(list, i > i64)
-reduce(list, i >= 0.5)
+reduce(list, greet, greet)
+reduce(list, i ^ 0)
 reduce(list, i)
-reduce(list, i) * i64
-reduce(list, i) .. 1 % 1
-reduce(list, i) .. i
-reduce(list, i) / f64
-reduce(list, i) / i32
-reduce(list, i) < f32
-reduce(list, i) == f32
-reduce(list, i) > f32
-reduce(list, i) ^ f32
-reduce(list, i32 != nil)
-reduce(list, i32 - i32)
-reduce(list, i32 .. 1)
-reduce(list, i32 / 0.5)
-reduce(list, i32 < i)
-reduce(list, i32 <= i)
-reduce(list, i32 == f64)
-reduce(list, i32 >= f32)
-reduce(list, i32)
-reduce(list, i32) != f64
-reduce(list, i32) % i
-reduce(list, i32) - f32
-reduce(list, i32) >= i
-reduce(list, i64 .. 1)
-reduce(list, i64 < i64)
-reduce(list, i64 > i64)
-reduce(list, i64 >= 0.5)
-reduce(list, i64)
-reduce(list, i64) * f64
-reduce(list, i64) ** i32
-reduce(list, i64) <= i64
-reduce(list, int(i64))
-reduce(list, len(array))
-reduce(list, list != nil)
-reduce(list, list == nil)
+reduce(list, i, $env?.list[:])
+reduce(list, i, 1.0) == i
+reduce(list, i, list)
+reduce(list, int(#index))
+reduce(list, int(0))
+reduce(list, list | any(ok))
+reduce(list, list | map($env))
 reduce(list, list)
-reduce(list, map(array, "bar"))
-reduce(list, map(array, #))
-reduce(list, map(list, 1))
-reduce(list, max(0.5))
-reduce(list, max(f32))
-reduce(list, min(0.5))
-reduce(list, min(1))
-reduce(list, min(f32))
-reduce(list, nil != #)
-reduce(list, nil != add)
-reduce(list, nil != half)
-reduce(list, nil == #)
-reduce(list, not false)
-reduce(list, not ok)
-reduce(list, not true)
-reduce(list, ok ? # : #)
-reduce(list, ok ? # : score)
-reduce(list, ok ? greet : add)
-reduce(list, ok ? score : #)
+reduce(list, list)?.[i]
+reduce(list, list, i)
+reduce(list, nil != $env)
 reduce(list, ok)
-reduce(list, reduce(array, ok))
-reduce(list, reduce(array, score))
-reduce(list, reduce(list, #))
-reduce(list, reduce(list, 1))
-reduce(list, reduce(list, add))
-reduce(list, reduce(list, i32))
-reduce(list, score(i))
-reduce(list, score)
-reduce(list, string(greet))
-reduce(list, toBase64("bar"))
-reduce(list, toBase64("foo"))
-reduce(list, toJSON(array))
-reduce(list, toJSON(list))
-reduce(list, toJSON(nil))
-reduce(list, true == nil)
-reduce(list, true ? foo : f64)
-reduce(list, type(#))
-reduce(map(array, "bar"), # not endsWith #)
-reduce(map(array, "bar"), add)
-reduce(map(array, "foo"), half(f64))
-reduce(map(array, #), # != i)
-reduce(map(array, #), # .. #)
-reduce(map(array, #), #)
-reduce(map(array, #), abs(#))
-reduce(map(array, #), i)
-reduce(map(array, #), i32 * #)
-reduce(map(array, #), not ok)
-reduce(map(array, 0.5), add)
-reduce(map(array, 0.5), div)
-reduce(map(array, 0.5), f32)
-reduce(map(array, 1), # ^ 0.5)
-reduce(map(array, 1), #)
-reduce(map(array, 1), foo)
-reduce(map(array, add), #)
-reduce(map(array, add), f32)
-reduce(map(array, add), list)
-reduce(map(array, array), f64)
-reduce(map(array, div), #)
-reduce(map(array, div), div)
-reduce(map(array, div), i32 * i)
-reduce(map(array, f32), f32)
-reduce(map(array, f32), i)
-reduce(map(array, f32), i32)
-reduce(map(array, f64), #)
-reduce(map(array, f64), f32 < #)
-reduce(map(array, false), # and true)
-reduce(map(array, false), f32)
-reduce(map(array, foo), # == nil)
-reduce(map(array, i), # / 1)
-reduce(map(array, i), #)
-reduce(map(array, i), add)
-reduce(map(array, i), f64 + 1)
-reduce(map(array, i32), array)
-reduce(map(array, i32), list)
-reduce(map(array, i64), # <= #)
-reduce(map(array, i64), #)
-reduce(map(array, list), filter(#, false))
-reduce(map(array, ok), i)
-reduce(map(array, score), i32)
-reduce(map(list, "bar"), #)
-reduce(map(list, "foo"), #)
-reduce(map(list, #), #)
-reduce(map(list, #), .Qux)
-reduce(map(list, #), add)
-reduce(map(list, #), array)
-reduce(map(list, #), f32)
-reduce(map(list, #), f64)
-reduce(map(list, #), half)
-reduce(map(list, #), i64)
-reduce(map(list, #), ok)
-reduce(map(list, 0.5), #)
-reduce(map(list, 0.5), foo)
-reduce(map(list, 1), # > #)
-reduce(map(list, 1), #)
-reduce(map(list, 1), list)
-reduce(map(list, array), div)
-reduce(map(list, div), add)
-reduce(map(list, f64), #)
-reduce(map(list, f64), ok)
-reduce(map(list, false), div)
-reduce(map(list, greet), #)
+reduce(list, ok, f64)
+reduce(list, reduce(array, greet, foo))
+reduce(list, str)
+reduce(list, str) == str
+reduce(list, string(ok))
+reduce(list, toBase64(#.Bar))
+reduce(list, true != $env)
+reduce(list, true != ok)
+reduce(list, true || false)
+reduce(list, true || true)
+reduce(list, type(i))
+reduce(list, type(list))
+reduce(list[:1], [$env])
+reduce(map($env, 1.0), #)
+reduce(map($env, foo), str)
+reduce(map(array, foo), foo?.Bar)
+reduce(map(array, list), list)
+reduce(map(list, #), $env?.add)
 reduce(map(list, i), #)
-reduce(map(list, i), [i32])
-reduce(map(list, i), f32)
-reduce(map(list, i), score(#))
-reduce(map(list, i32), #)
-reduce(map(list, i32), foo)
-reduce(map(list, i64), #)
-reduce(map(list, i64), i32)
-reduce(map(list, list), ok)
-reduce(map(list, score), #)
-reduce(map(list, score), f64)
-reduce(map(list, true), #)
-reduce(map(list, true), add)
-reduce(map(list, true), half)
-reduce(ok ? "bar" : i32, #)
-reduce(ok ? "foo" : list, #)
-reduce(ok ? array : half, f32)
-reduce(ok ? list : i, #)
-reduce(reduce(array, array), f64 != #)
-reduce(reduce(array, list), get(array, i32))
-reduce(reduce(list, array), f64)
-reduce(sort(array), #)
-reduce(sort(array), foo)
-reduce(sort(array), greet)
-reduce(sort(array), ok)
-reduce(true ? array : 1, array)
-reduce(true ? array : array, #)
-repeat(type(ok), i)
-round(-0.5)
-round(-1)
-round(-f32)
-round(-f64)
-round(-i)
-round(-i32)
-round(-i64)
-round(0.5 * 1)
-round(0.5 * f64)
-round(0.5 * i32)
-round(0.5 ** 0.5)
-round(0.5 ** 1)
-round(0.5 ** i)
-round(0.5 ** i32)
-round(0.5 ** i64)
-round(0.5 + 1)
-round(0.5 + f64)
-round(0.5 + i)
-round(0.5 + i32)
-round(0.5 - 0.5)
-round(0.5 - 1)
-round(0.5 - i32)
-round(0.5 / 0.5)
-round(0.5 / 1)
-round(0.5 / f64)
-round(0.5 / i32)
-round(0.5 ^ f64)
-round(0.5 ^ i)
-round(0.5 ^ i64)
-round(0.5) * f32
-round(0.5) ** i32
-round(0.5) + -f32
-round(0.5) - i64 ^ i
-round(0.5) < f64
-round(0.5) <= i64
-round(0.5) == i32
-round(0.5) == i64
-round(0.5) == max(i, i64)
-round(0.5) > -1
-round(0.5) > i
-round(0.5) >= i
-round(0.5) in array
-round(1 % i)
-round(1 % i64)
-round(1 * 0.5)
-round(1 * f32)
-round(1 * i64)
-round(1 ** 0.5)
+reduce(reduce(array, list), #index)
+reduce(reverse(array), $env.ok)
+reduce(reverse(array), $env?.ok)
+reduce(reverse(list), str)
+reduce(sort(array), str)
+reduce(values($env), #)
+repeat(str, i)
+repeat(str, i) not startsWith str
+repeat(type(1), i)
+reverse($env | filter(false))
+reverse($env | map($env))
+reverse($env | map(0))
+reverse($env | map(1.0))
+reverse($env | map(false))
+reverse($env | map(true))
+reverse($env.array)
+reverse($env.list)
+reverse($env?.array)
+reverse($env?.list)
+reverse(0 .. 1)
+reverse(0 .. i)
+reverse(1 .. 1)
+reverse([$env, 0])
+reverse([$env, f64])
+reverse([$env])
+reverse([0, $env, foo])
+reverse([0])
+reverse([1 .. 1])
+reverse([1, true])
+reverse([1.0, list])
+reverse([1.0])
+reverse([1])
+reverse([add, list])
+reverse([array, array])
+reverse([array, greet])
+reverse([array])
+reverse([f64, nil])
+reverse([f64])
+reverse([false])
+reverse([foo, 1.0])
+reverse([foo, str])
+reverse([foo])
+reverse([greet])
+reverse([i, 1])
+reverse([i])
+reverse([list])
+reverse([nil, list])
+reverse([nil, nil])
+reverse([nil])
+reverse([ok])
+reverse([str, ok])
+reverse([str])
+reverse([true])
+reverse(array | map($env))
+reverse(array | map(ok))
+reverse(array | map(str))
+reverse(array | reduce(array, foo))
+reverse(array | sortBy(1))
+reverse(array)
+reverse(array) | findIndex(ok)
+reverse(array) | findLastIndex(false)
+reverse(array) | map(#)
+reverse(array) | one(ok)
+reverse(array) | reduce(#)
+reverse(array) | reduce(#, greet)
+reverse(array) | reduce($env)
+reverse(array) | reduce(foo)
+reverse(array) | reduce(str)
+reverse(array) | sortBy(1)
+reverse(array) | sortBy(i)
+reverse(array) | sum(#)
+reverse(array)?.[i]
+reverse(array[i:1])
+reverse(concat(array))
+reverse(concat(list))
+reverse(filter($env, false))
+reverse(flatten(list))
+reverse(if false { $env } else { array })
+reverse(keys($env))
+reverse(let foobar = array; foobar)
+reverse(let foobar = list; foobar)
+reverse(list | filter(true))
+reverse(list | map(#))
+reverse(list | map(i))
+reverse(list | map(str))
+reverse(list | map(true))
+reverse(list | sortBy(1.0))
+reverse(list)
+reverse(list) != list
+reverse(list) == array
+reverse(list) | any(true)
+reverse(list) | count(true)
+reverse(list) | groupBy(#)
+reverse(list) | groupBy(foo)
+reverse(list) | reduce(0)
+reverse(list) | reduce(f64)
+reverse(list) | reduce(foo)
+reverse(list) | reduce(greet)
+reverse(list) | reduce(true)
+reverse(list)?.[i]
+reverse(map($env, 0))
+reverse(map($env, 1.0))
+reverse(map($env, array))
+reverse(map($env, f64))
+reverse(map($env, list))
+reverse(map($env, str))
+reverse(map(array, #))
+reverse(map(array, #index))
+reverse(map(array, foo))
+reverse(map(list, #))
+reverse(map(list, #.Bar))
+reverse(map(list, $env))
+reverse(reduce(array, list))
+reverse(reverse(list))
+reverse(sort($env))
+reverse(sort(array))
+reverse(sortBy(array, #))
+reverse(sortBy(array, 1.0))
+reverse(sortBy(array, str))
+reverse(sortBy(list, 1.0))
+reverse(toPairs($env))
+reverse(uniq(array))
+reverse(uniq(list))
+round($env | findIndex(true))
+round($env | reduce(0, foo))
+round($env | sum(1.0))
+round($env.f64)
+round($env.f64) != i
+round($env.i)
+round($env?.f64)
+round($env?.i)
+round(0 * 1.0)
+round(0 * f64)
+round(0 ** 0)
+round(0 ** f64)
+round(0 ** i)
+round(0 + 0)
+round(0 + 1)
+round(0 + 1.0)
+round(0 + i)
+round(0 - 1)
+round(0 / 0)
+round(0 / 1.0)
+round(0 / f64)
+round(0 ^ 1.0)
+round(0 ^ f64)
+round(0) / f64
+round(0) < i
+round(0) ^ f64
+round(0) ^ i
+round(0.1)
+round(1 * 0)
+round(1 ** 0)
 round(1 ** 1)
-round(1 ** f32)
-round(1 ** f64)
 round(1 ** i)
-round(1 + 0.5)
-round(1 + 1)
-round(1 + i64)
-round(1 - 0.5)
-round(1 - 1)
+round(1 + 0)
+round(1 + 1.0)
+round(1 + i)
+round(1 - 0)
+round(1 - 1.0)
 round(1 - i)
-round(1 - i32)
-round(1 - i64)
-round(1 / 0.5)
 round(1 / 1)
-round(1 / f32)
 round(1 / i)
-round(1 / i64)
-round(1 ^ 0.5)
-round(1 ^ 1)
-round(1 ^ f32)
-round(1 ^ i)
-round(1 ^ i64)
-round(1) != ceil(i32)
-round(1) * i32
-round(1) + i64
-round(1) - i64
-round(1) / i32
-round(1) / i64
-round(1) < i64
-round(1) <= i
-round(1) == i
-round(1) >= f64
-round(1) >= i32
-round(1) >= i64
-round(1) ^ f64
+round(1 ^ 0)
+round(1 ^ 1.0)
+round(1 ^ f64)
+round(1 | bitnand(0))
+round(1) / f64
+round(1) ^ sum(array)
 round(1) not in array
-round(abs(0.5))
-round(abs(1))
-round(abs(f64))
+round(1.0 * 0)
+round(1.0 * 1)
+round(1.0 * 1.0)
+round(1.0 * f64)
+round(1.0 * i)
+round(1.0 ** 0)
+round(1.0 ** 1.0)
+round(1.0 ** i)
+round(1.0 + 0)
+round(1.0 - 1)
+round(1.0 - 1.0)
+round(1.0 - f64)
+round(1.0 - i)
+round(1.0 / 1)
+round(1.0 / 1.0)
+round(1.0 / i)
+round(1.0 ^ $env.i)
+round(1.0 ^ 0)
+round(1.0 ^ 1.0)
+round(1.0 ^ f64)
+round(1.0 ^ i)
+round(1.0 | max(i))
+round(1.0 | mean(0))
+round(1.0)
+round(1.0) * $env and false
+round(1.0) * f64
+round(1.0) ** 1.0 != 1
+round(1.0) ** f64
+round(1.0) + f64
+round(1.0) + mean(1.0, f64)
+round(1.0) / i
+round(1.0) <= i
+round(1.0) > i
+round(1.0) >= f64
+round(1.0) ^ f64
+round(1.0) ^ i
+round(1.0) ^ sum($env, 1)
+round(1.0) | median(array)
+round(1.1)
+round(abs(1.0))
 round(abs(i))
-round(abs(i64))
-round(add(1, i))
-round(array[1])
-round(array[i32])
-round(array[i64])
+round(array | reduce(#))
+round(array | sum(#))
+round(array | sum(1))
+round(array?.[0])
+round(array?.[i])
 round(bitnot(i))
-round(bitnot(i32))
-round(bitnot(i64))
-round(ceil(1))
+round(ceil(1.0))
 round(ceil(f64))
-round(ceil(i32))
-round(ceil(i64))
-round(count(list, true))
-round(div(1, 1))
-round(f32 * 0.5)
-round(f32 * 1)
-round(f32 * f64)
-round(f32 * i32 ^ f32)
-round(f32 * i64)
-round(f32 ** 0.5)
-round(f32 ** 1)
-round(f32 + f64)
-round(f32 + i32)
-round(f32 - 0.5)
-round(f32 - i)
-round(f32 / i32)
-round(f32 ^ 0.5)
-round(f32 ^ f32)
-round(f32 ^ i)
-round(f32 ^ i64)
-round(f32)
-round(f32) * i32
-round(f32) - i32
-round(f32) / f32
-round(f32) == i32
-round(f64 * 0.5)
+round(f64 * 0)
+round(f64 * 1)
+round(f64 * 1.0)
 round(f64 * i)
-round(f64 ** 0.5)
-round(f64 ** 1)
-round(f64 ** f32)
-round(f64 ** i)
-round(f64 + f64)
-round(f64 + i)
-round(f64 + i32)
-round(f64 - 0.5)
-round(f64 - 1)
-round(f64 - i32)
+round(f64 ** 0)
+round(f64 + 1.0)
+round(f64 - 0)
+round(f64 - i)
+round(f64 / 0)
+round(f64 / 1.0)
 round(f64 / f64)
-round(f64 / i)
-round(f64 / i32)
-round(f64 / i64)
 round(f64 ^ 1)
+round(f64 ^ 1.0)
 round(f64 ^ f64)
 round(f64)
-round(f64) * f32
-round(f64) ** i32
 round(f64) + f64
-round(f64) <= f64
-round(f64) > i
-round(f64) > i32
-round(f64) >= i64
-round(f64) not in array
-round(false ? f32 : f64)
-round(false ? f64 : 1)
-round(false ? nil : 1)
-round(findIndex(array, # <= #))
-round(findIndex(list, ok))
+round(f64) + f64 < 0
+round(f64) <= i
+round(f64) >= i
+round(false ? 0 : 1.0)
+round(false ?: 1)
 round(findLast(array, ok))
-round(findLast(array, true))
-round(findLastIndex(array, ok))
-round(findLastIndex(list, ok))
-round(float(0.5))
+round(findLastIndex($env, true))
+round(first(array))
+round(float(0))
 round(float(1))
-round(float(f32))
+round(float(1.0))
+round(float(f64))
 round(float(i))
-round(floor(0.5))
+round(floor(0))
 round(floor(1))
+round(floor(1.0))
 round(floor(f64))
-round(floor(i32))
-round(floor(i64))
-round(get(array, i))
-round(get(array, i32))
-round(get(array, i64))
-round(half(-1))
-round(half(0.5))
-round(half(1))
-round(half(f64))
-round(i % i32)
-round(i % i64)
-round(i * 1)
-round(i * f64)
-round(i * i32)
+round(floor(i))
+round(i % 1)
+round(i * 1.0)
+round(i * i)
+round(i ** 0)
 round(i ** 1)
-round(i ** i64)
-round(i + 0.5)
-round(i + 1)
-round(i + f64)
-round(i + i)
-round(i + i32)
-round(i + i64)
-round(i - i)
-round(i - i32)
-round(i / 1)
+round(i ** 1.0)
+round(i - 1)
+round(i - f64)
+round(i / 1.0)
+round(i / f64)
 round(i / i)
-round(i / i64)
-round(i ^ 0.5) > f32
-round(i ^ 1)
-round(i ^ f32)
+round(i ^ 0)
+round(i ^ 1.0)
 round(i)
-round(i) * f32
-round(i) * i
-round(i) / f64
-round(i) < i
-round(i) < i32
-round(i) > i
-round(i) > i64 != ok
-round(i) >= f32
-round(i) >= i64
-round(i) ^ i32
-round(i32 % 1)
-round(i32 * 1)
-round(i32 ** 1)
-round(i32 ** f32)
-round(i32 ** f64)
-round(i32 + 0.5)
-round(i32 + 1)
-round(i32 + i32)
-round(i32 - 1)
-round(i32 - f32)
-round(i32 - f64)
-round(i32 / 0.5)
-round(i32 / 1)
-round(i32 ^ f64)
-round(i32)
-round(i32) != i
-round(i32) * f32
-round(i32) ** f64
-round(i32) - i
-round(i32) < i32
-round(i32) <= ceil(1)
-round(i32) <= f64
-round(i32) <= i64
-round(i32) >= f64
-round(i32) >= i32
-round(i32) ^ f64
-round(i64 % i)
-round(i64 % i32)
-round(i64 * 0.5)
-round(i64 * i)
-round(i64 ** 1)
-round(i64 ** f64)
-round(i64 ** i64)
-round(i64 + f32)
-round(i64 - 0.5)
-round(i64 - 1)
-round(i64 - i)
-round(i64 / 0.5)
-round(i64 / 1)
-round(i64 ^ 1)
-round(i64 ^ i32)
-round(i64 ^ i64)
-round(i64)
-round(i64) != f64
-round(i64) * i64
-round(i64) ** i32
-round(i64) - bitnot(1)
-round(i64) - f32
-round(i64) < f64
-round(i64) ^ f64
-round(int(0.5))
+round(i) + i
+round(i) / i
+round(i) == i
+round(i) > $env?.i
+round(i) > f64
+round(if false { foo } else { 0 })
+round(if true { 0 } else { greet })
+round(int(0))
 round(int(1))
-round(int(f32))
 round(int(f64))
-round(int(i))
-round(int(i32))
-round(int(i64))
+round(int(string(1.0)))
 round(last(array))
-round(len("bar"))
-round(len("foo"))
-round(len(array))
 round(len(list))
-round(max(0.5))
-round(max(1))
+round(len(str))
+round(list | count(ok))
+round(list | reduce(1.0, 1.0))
+round(list | reduce(f64))
+round(max(1.0 * 0))
+round(max(1.0))
+round(max(array))
+round(max(array, array))
+round(max(f64))
 round(max(i))
-round(max(i32))
-round(max(i64))
-round(max(i64, f32))
+round(mean(0))
+round(mean(1))
+round(mean(1, 1.0))
+round(mean(1.0))
 round(mean(array))
+round(mean(f64))
+round(mean(f64, f64))
+round(mean(i))
+round(median(0))
+round(median(1))
 round(median(array))
-round(min(0.5))
+round(median(f64))
+round(median(f64, i))
+round(median(i))
 round(min(1))
-round(min(f32))
+round(min(1.0))
+round(min(array))
 round(min(f64))
-round(min(i32))
-round(min(i64))
+round(min(i))
+round(ok ? i : 0)
 round(reduce(array, #))
-round(reduce(array, 0.5))
-round(reduce(array, 1))
-round(reduce(array, i64))
-round(reduce(list, 0.5))
-round(reduce(list, f32))
-round(round(0.5))
+round(reduce(array, #, nil))
+round(reduce(list, #index, nil))
 round(round(1))
-round(round(f32))
-round(round(f64))
-round(round(i))
-round(round(i32))
-round(round(i64))
-round(score(1))
-round(score(i))
+round(round(1.0))
+round(sum($env, 0))
+round(sum($env, 1))
+round(sum($env, f64))
 round(sum(array))
-round(true ? i : ok)
-score
-score != nil != ok
-score != nil ? half : f64
-score != nil or i32 > 0.5
-score != nil || ok
-score != score
-score != score != ok
-score != score ? i32 : i32
-score == nil != nil
-score == nil && ok
-score == nil ? 0.5 : "bar"
-score == score
-score == score == true
-score == score ? 0.5 : score
-score in groupBy(list, #)?.array
-score in sort(array)
-score(-1)
-score(-1, i)
-score(-get(array, i))
-score(-i)
-score(-i, i)
-score(1 % 1)
-score(1 % i)
-score(1 % i32)
-score(1 % i64)
-score(1 * 1)
-score(1 * i)
-score(1 * i32)
-score(1 * i64)
-score(1 + 1)
-score(1 + i)
-score(1 + i32)
-score(1 + i64)
-score(1 - 1)
-score(1 - i)
-score(1 - i32)
-score(1) != -f32
-score(1) != i
-score(1) != i32
-score(1) % -1
-score(1) % i
-score(1) % i64
-score(1) * f32
-score(1) * i
-score(1) * i64
-score(1) ** i32
-score(1) + f64
-score(1) + i32
-score(1) - f32
-score(1) - i
-score(1) - i32
-score(1) - int(0.5)
-score(1) .. i
-score(1) .. i32
-score(1) .. i64
-score(1) .. score(1)
-score(1) / f32
-score(1) / i32
-score(1) < i
-score(1) < i32
-score(1) < i64
-score(1) < i64 - 0.5
-score(1) <= 0.5 * 1
-score(1) <= i
-score(1) <= i64
-score(1) == i32
-score(1) == i64
-score(1) > bitshr(i64, 1)
-score(1) > f32
-score(1) > i64
-score(1) >= 0.5 + f64
-score(1) >= f32
-score(1) >= i
-score(1) >= sum(array)
-score(1) ^ f64
-score(1) ^ i
-score(1) ^ i32
-score(1) in array
-score(1) not in groupBy(list, false)
-score(1, 1) < i
-score(1, i) < f64
-score(1, i) ^ f32
-score(abs(1))
-score(abs(i))
-score(add(1, i))
-score(array[1])
-score(array[i64])
-score(array[i])
-score(bitnand(1, i64))
-score(bitnand(i64, i32))
-score(bitnot(1))
-score(bitnot(i))
-score(bitnot(i32))
-score(bitnot(i64))
-score(bitshl(i32, i))
-score(bitshr(1, i64))
-score(bitshr(i32, i64))
-score(bitushr(1, i))
-score(count(array, false))
-score(count(array, ok))
-score(count(array, true))
-score(count(list, ok))
-score(false ? f64 : 1)
-score(false ? foo : 1)
-score(find(array, i != #))
-score(find(array, ok))
-score(find(array, true))
-score(findIndex(array, ok))
-score(findIndex(array, true))
-score(findIndex(list, true))
-score(findLast(array, true))
-score(findLastIndex(array, true))
-score(findLastIndex(list, ok))
-score(findLastIndex(list, true))
-score(first(array))
-score(get(array, 1))
-score(get(array, i))
-score(get(array, i32))
-score(get(array, i64))
-score(i % 1)
-score(i % i)
-score(i % i64)
-score(i * 1 * i)
-score(i * 1)
-score(i * i)
-score(i * i32)
-score(i * i64)
-score(i + 1)
-score(i + i)
-score(i + i32)
-score(i - 1)
-score(i - i)
-score(i - i32)
-score(i)
-score(i) != f32
-score(i) != f64
-score(i) % i
-score(i) % i * f64
-score(i) * f32
-score(i) * i32
-score(i) ** (0.5 / 0.5)
-score(i) ** -0.5
-score(i) ** i32
-score(i) ** i64
-score(i) + f64
-score(i) - f64
-score(i) - i32
-score(i) / i64
-score(i) < 1 != ok
-score(i) < f32
-score(i) < f64 / 0.5
-score(i) < i32
-score(i) < i64
-score(i) <= 0.5 / f32
-score(i) <= f32
-score(i) <= f64
-score(i) <= i
-score(i) <= i32
-score(i) == f32
-score(i) > f32
-score(i) > i
-score(i) > i64
-score(i) >= f32
-score(i) >= f64
-score(i) >= i
-score(i) >= i32
-score(i) >= i64
-score(i) ^ f32
-score(i) ^ i32
-score(i) ^ i64
-score(i) ^ score(1)
-score(i, 1) + -1
-score(i, 1) .. i64
-score(i, 1) <= f32
-score(i, i)
-score(i, i) ** f32
-score(i32 % 1)
-score(i32 % i)
-score(i32 % i32)
-score(i32 * 1)
-score(i32 * i)
-score(i32 * i32)
-score(i32 * i64)
-score(i32 + 1)
-score(i32 + i)
-score(i32 + i32)
-score(i32 + i64)
-score(i32 - 1)
-score(i32 - i)
-score(i32 - i32)
-score(i32 - i64)
-score(i64 % 1)
-score(i64 % i)
-score(i64 % i32)
-score(i64 % i64)
-score(i64 * 1)
-score(i64 * i32)
-score(i64 * i64)
-score(i64 + 1)
-score(i64 + i)
-score(i64 + i32)
-score(i64 - 1)
-score(i64 - i64)
-score(int(0.5))
-score(int(1))
-score(int(f32))
-score(int(f64))
-score(int(float(0.5)))
-score(int(i))
-score(int(i32))
-score(int(i64))
-score(last(array))
-score(len("bar"))
-score(len("foo"))
-score(len(array))
-score(len(list))
-score(max(1))
-score(max(1, i32, 0.5))
-score(max(i))
-score(max(i, i32))
-score(min(1))
-score(min(i))
-score(min(i, i32))
-score(ok ? 1 : "bar")
-score(ok ? 1 : list)
-score(reduce(array, #))
-score(reduce(array, i))
-score(reduce(list, 1))
-score(reduce(list, i))
-score(score(1))
-score(score(i))
-score(score(i32 + i))
-score(sum(array))
-sort(1 .. 1)
-sort(1 .. i)
+sort($env | map(#index))
+sort($env | map(0))
+sort($env) | all(#.Bar)
+sort($env) | all(#.add)
+sort($env) | all(#.ok)
+sort($env) | all(.str)
+sort($env) | all(true)
+sort($env) | any(#)
+sort($env) | any(#.f64)
+sort($env) | any(.String)
+sort($env) | any(.array)
+sort($env) | concat(list)
+sort($env) | count(#)
+sort($env) | count(#.foo)
+sort($env) | count(#.i == 0)
+sort($env) | count($env)
+sort($env) | filter(#)
+sort($env) | filter(#.i)
+sort($env) | find(#)
+sort($env) | find(#.Bar)
+sort($env) | find(#.list)
+sort($env) | find(false)
+sort($env) | findIndex(#)
+sort($env) | findIndex(#.add)
+sort($env) | findIndex(#.array)
+sort($env) | findIndex(.String)
+sort($env) | findIndex(.foo)
+sort($env) | findIndex(.ok)
+sort($env) | findIndex(ok)
+sort($env) | findLast(#)
+sort($env) | findLast(#.array)
+sort($env) | findLast(#.list?.foo(#))
+sort($env) | findLastIndex(#)
+sort($env) | findLastIndex(#.list)
+sort($env) | findLastIndex(.Bar)
+sort($env) | groupBy(#)
+sort($env) | groupBy(#.add)
+sort($env) | groupBy(#.greet)
+sort($env) | groupBy(#?.foo(i))
+sort($env) | groupBy(.array)
+sort($env) | groupBy(add)
+sort($env) | groupBy(i)
+sort($env) | map(#)
+sort($env) | map(#.f64)
+sort($env) | map(.foo)
+sort($env) | map(.list)
+sort($env) | map(1.0)
+sort($env) | map(i)
+sort($env) | map(true)
+sort($env) | mean(1.0)
+sort($env) | none(#)
+sort($env) | none(#.ok)
+sort($env) | none($env)
+sort($env) | none(.String)
+sort($env) | none(.array)
+sort($env) | one(#.f64)
+sort($env) | one(#.list)
+sort($env) | one(#.ok)
+sort($env) | one(#.ok.nil)
+sort($env) | one($env)
+sort($env) | one(.f64)
+sort($env) | one(.f64?.[.greet])
+sort($env) | one(.list)
+sort($env) | one(ok)
+sort($env) | reduce(#.String, nil)
+sort($env) | reduce(foo, foo)
+sort($env) | sortBy(#)
+sort($env) | sortBy(1.0)
+sort($env) | sortBy(i)
+sort($env) | sortBy(str)
+sort($env) | sum(#.greet)
+sort($env) | sum(#.str?.String)
+sort($env) | sum(.array)
+sort($env) | sum(false)
+sort($env) | sum(foo)
+sort($env)?.[i]
+sort($env)?.[i].add()
+sort($env)[:]
+sort($env.array)
+sort($env?.Bar)
+sort($env?.Bar?.greet)
+sort($env?.String)
+sort($env?.[Bar])
+sort($env?.[Bar]?.[array])
+sort($env?.[String])
+sort($env?.[foobar])
+sort($env?.[nil])
+sort($env?.[str])
+sort($env?.array)
+sort($env?.false)
+sort($env?.foobar)
+sort($env?.foobar?.greet)
+sort($env?.list | reduce(#acc))
+sort($env?.nil)
+sort(1..i)
+sort([$env])
+sort([0 .. 0])
+sort([0])
+sort([1.0])
+sort([1])
 sort([add])
-sort([greet])
-sort([half])
-sort([i64])
+sort([array])
+sort([false])
+sort([foo])
+sort([i])
 sort([list])
+sort([nil])
+sort([ok])
+sort([str])
+sort([true])
+sort(array | map(#))
+sort(array | sortBy(#))
 sort(array)
-sort(array) == array
-sort(false ? greet : array)
-sort(groupBy(list, #)?.foo)
-sort(groupBy(list, i32).half)
-sort(i .. i32)
-sort(i .. i64)
-sort(i32 .. 1)
-sort(i64 .. 1)
-sort(map(array, "bar"))
-sort(map(array, "foo"))
+sort(array) == list
+sort(array) | find(true)
+sort(array) | findIndex($env?.ok)
+sort(array) | findLastIndex(false)
+sort(array) | get(i)
+sort(array) | groupBy(#)
+sort(array) | groupBy(str)
+sort(array) | map(#)
+sort(array) | map(0)
+sort(array) | map(1.0)
+sort(array) | map(list)
+sort(array) | one(false)
+sort(array) | reduce($env)
+sort(array) | reduce(foo)
+sort(array) | reduce(true, 1.0)
+sort(array) | sortBy(1)
+sort(array)?.[i]
+sort(array[0:])
+sort(concat(array))
+sort(false ? true : 0)
+sort(false ?: 1.0)
+sort(false ?: i)
+sort(filter($env, false))
+sort(first($env))
+sort(if false { 1 } else { 1.0 })
+sort(if false { 1.0 } else { 1 })
+sort(if ok { ok } else { 1.0 })
+sort(if true { add } else { str })
+sort(if true { f64 } else { $env })
+sort(if true { greet } else { 1 })
+sort(keys($env))
+sort(last($env))
+sort(list | map(#.Bar))
 sort(map(array, #))
-sort(map(array, 1))
-sort(map(array, f64))
-sort(map(array, i))
-sort(map(array, i64))
+sort(map(array, 0))
+sort(map(array, 1.0))
+sort(map(list, str))
+sort(max($env))
+sort(max(array))
+sort(max(array, 1.0))
+sort(mean(array))
+sort(median(array))
+sort(min($env))
+sort(min(array))
+sort(min(array, 1.0))
+sort(ok ? 1.0 : $env)
+sort(ok ? list : str)
+sort(ok ?: 1.0)
+sort(ok ?: list)
 sort(reduce(array, array))
-sortBy(array, string(true))
-string(!!false)
-string(!false)
-string(!ok)
-string(!true)
-string("bar" != nil)
-string("bar" <= "bar")
-string("bar" == "bar")
-string("bar" > "foo")
-string("bar" >= "bar")
-string("bar" not endsWith "bar")
-string("bar" not matches "bar")
-string("bar" not startsWith "foo")
-string("bar" startsWith "foo")
-string("bar") > type(i64)
-string("bar") >= toJSON("bar")
-string("foo" != nil)
-string("foo" == "foo")
-string("foo" == nil)
-string("foo" > "bar")
-string("foo" in foo)
-string("foo" matches "bar")
-string("foo" not contains "bar")
-string("foo" not contains "foo")
-string("foo" not in foo)
-string(--i)
-string(-0.5)
-string(-1)
-string(-f32)
-string(-f64)
-string(-i)
-string(-i32)
-string(-i64)
-string(0.5 != 0.5)
-string(0.5 != f64)
-string(0.5 != i)
-string(0.5 != i32)
-string(0.5 * 0.5)
-string(0.5 * i)
-string(0.5 * i32)
-string(0.5 ** f32)
-string(0.5 ** i32)
-string(0.5 + f64)
-string(0.5 + i)
-string(0.5 + i64)
-string(0.5 - f32)
-string(0.5 - f64)
-string(0.5 / 0.5)
-string(0.5 / 1)
-string(0.5 / f32)
-string(0.5 / i)
-string(0.5 < 0.5)
-string(0.5 < 1)
-string(0.5 < i64)
-string(0.5 <= 0.5)
-string(0.5 <= f64)
-string(0.5 <= i)
-string(0.5 <= i32)
-string(0.5 == 0.5)
-string(0.5 == 1)
-string(0.5 == i64)
-string(0.5 == nil)
-string(0.5 > 0.5)
-string(0.5 > 1)
-string(0.5 > i)
-string(0.5 > i64)
-string(0.5 >= 0.5)
-string(0.5 >= 1)
-string(0.5 >= f32)
-string(0.5 >= i32)
-string(0.5 >= i64)
-string(0.5 ^ f32)
-string(0.5 ^ i)
-string(0.5 ^ i32)
-string(0.5 ^ i64)
-string(0.5 in array)
-string(0.5 not in array)
-string(1 != 0.5)
-string(1 != 1)
-string(1 != i)
-string(1 != i64)
+sort(reverse(array))
+sort(sort($env))
+sort(sort(array))
+sort(sortBy(array, 1.0))
+sort(toPairs($env))
+sort(true ? i : 1.0)
+sort({foo: 1.0}.add)
+sort({foo: str}.greet)
+sortBy($env.array, #)
+sortBy($env.array, f64)
+sortBy($env.list, #.Bar)
+sortBy($env.list, f64)
+sortBy($env?.[str], $env?.i)
+sortBy($env?.[str], f64)
+sortBy($env?.array, #)
+sortBy($env?.list, f64)
+sortBy(0 .. 0, #)
+sortBy(0 .. 1, #)
+sortBy(0 .. i, # ^ i)
+sortBy([$env], #)
+sortBy([$env], #?.add)
+sortBy([$env], .list)
+sortBy([0], $env.ok)
+sortBy([0], $env?.Bar)
+sortBy([0], add)
+sortBy([0], greet)
+sortBy([1.0], $env?.ok)
+sortBy([1.0], f64)
+sortBy([1], 0 >= #)
+sortBy([array], f64)
+sortBy([f64], add)
+sortBy([false], list)
+sortBy([foo], #)
+sortBy([foo], add)
+sortBy([foo], array)
+sortBy([foo], foo)
+sortBy([list], #)
+sortBy([nil], array)
+sortBy([true], f64)
+sortBy([true], i)
+sortBy(array, # * #)
+sortBy(array, # ** #)
+sortBy(array, # + #)
+sortBy(array, # ^ #)
+sortBy(array, #)
+sortBy(array, #) | findIndex(false)
+sortBy(array, #) | groupBy(true)
+sortBy(array, #) | map(0)
+sortBy(array, #) | reduce(#)
+sortBy(array, #) | reduce($env)
+sortBy(array, #)?.[i]
+sortBy(array, $env.i)
+sortBy(array, $env?.[str])
+sortBy(array, $env?.i)
+sortBy(array, 0 * #)
+sortBy(array, 0 - 1)
+sortBy(array, 0) | map(#)
+sortBy(array, 0)?.[i]
+sortBy(array, 1 ** f64)
+sortBy(array, 1 / #)
+sortBy(array, 1 ^ #)
+sortBy(array, 1) | groupBy(#)
+sortBy(array, 1) | reduce($env)
+sortBy(array, 1)?.[i]
+sortBy(array, 1.0 ^ #)
+sortBy(array, 1.0)?.[i]
+sortBy(array, abs(#))
+sortBy(array, bitnot(#))
+sortBy(array, f64 ** #)
+sortBy(array, f64)
+sortBy(array, f64)?.[i]
+sortBy(array, findLast(array, ok))
+sortBy(array, findLastIndex($env, ok))
+sortBy(array, float(1))
+sortBy(array, i ** #)
+sortBy(array, i)
+sortBy(array, i)?.[i]
+sortBy(array, max(#))
+sortBy(array, mean(#))
+sortBy(array, round(#))
+sortBy(array, round(i))
+sortBy(array, str)
+sortBy(array, str) | map(list)
+sortBy(array, str) | none(ok)
+sortBy(array, str)?.[i]
+sortBy(array, toJSON(foo))
+sortBy(array, toJSON(nil))
+sortBy(array[:i], str)
+sortBy(concat(array), #)
+sortBy(concat(array), round(i))
+sortBy(filter($env, false), #.foo)
+sortBy(flatten(list), f64)
+sortBy(let foobar = array; foobar, # * 1.0)
+sortBy(list | map(i), # ^ #)
+sortBy(list, #.Bar)
+sortBy(list, #.Bar)?.[i]
+sortBy(list, #.String())
+sortBy(list, #?.Bar)
+sortBy(list, $env.f64)
+sortBy(list, $env.i)
+sortBy(list, $env?.i)
+sortBy(list, .Bar)
+sortBy(list, .Bar) | sum(f64)
+sortBy(list, 0)?.[i]
+sortBy(list, 1)?.[i]
+sortBy(list, 1.0 ** f64)
+sortBy(list, 1.0)?.[$env?.i]
+sortBy(list, abs(0))
+sortBy(list, bitnand(0, 1))
+sortBy(list, bitnot(1))
+sortBy(list, f64)
+sortBy(list, f64) | filter(true)
+sortBy(list, f64) | map($env)
+sortBy(list, f64) | reduce(#)
+sortBy(list, f64) | sum(0)
+sortBy(list, f64)?.[i]
+sortBy(list, greet(#.Bar))
+sortBy(list, greet(.Bar))
+sortBy(list, greet(str))
+sortBy(list, i)
+sortBy(list, i) == list
+sortBy(list, i) | reduce($env)
+sortBy(list, len(#.Bar))
+sortBy(list, reduce(array, i))
+sortBy(list, str)
+sortBy(list, str) | reduce(true)
+sortBy(list, str)?.[i]
+sortBy(list, string(1.0))
+sortBy(list, string(greet))
+sortBy(list, string(ok))
+sortBy(list, toBase64(str))
+sortBy(list, toJSON(#.Bar))
+sortBy(list, toJSON(i))
+sortBy(list, type(add))
+sortBy(list, type(false))
+sortBy(list, type(list))
+sortBy(map($env, greet), type(f64))
+sortBy(sort($env), #)
+sortBy(sort($env), #.array .. .f64)
+sortBy(sort($env), map(#.list, array))
+sortBy(sortBy(array, i), #)
+sortBy(take(list, 1), #)
+split(str, $env?.[str])
+split(str, str)
+split(str, string($env))
+split(str, toBase64(str))
+splitAfter(foo?.Bar, str)
+splitAfter(str, foo?.String())
+splitAfter(str, str)
+splitAfter(str, toJSON(nil))
+str
+str != $env == $env
+str != $env ? 1.0 : $env
+str != $env and ok
+str != $env or $env
+str != $env.str
+str != $env?.Bar
+str != $env?.String
+str != $env?.[Bar]
+str != $env?.[String]
+str != $env?.[nil]
+str != $env?.[str]
+str != $env?.str
+str != foo.Bar
+str != foo.String()
+str != foo?.Bar
+str != foo?.String()
+str != greet(str)
+str != median(array)
+str != min(array, array)
+str != nil && $env
+str != nil ? foo : f64
+str != nil or $env
+str != nil or $env?.[Bar]
+str != nil or ok
+str != nil || $env
+str != reduce(array, #acc, foo)
+str != reduce(list, .Bar, false)
+str != str
+str != str && $env?.String.i()
+str != str && true
+str != str ? 0 : 1.0
+str != str ? foo : true
+str != string(f64)
+str != string(list)
+str != toJSON(false)
+str != toJSON(foo)
+str != trim(str)
+str != type(foo)
+str != type(str)
+str + $env not endsWith $env and false
+str + $env.str
+str + $env?.[str]
+str + $env?.str
+str + foo.Bar
+str + foo.String()
+str + foo?.Bar
+str + foo?.String()
+str + greet(str)
+str + str
+str + str != $env
+str + string($env)
+str + string(add)
+str + string(f64)
+str + string(str)
+str + toBase64(str)
+str + toJSON(i)
+str + toJSON(list)
+str + toJSON(nil)
+str + toJSON(str)
+str + type($env)
+str < $env && false
+str < $env.str
+str < $env?.[str]
+str < $env?.str
+str < foo.Bar
+str < foo.String()
+str < foo?.Bar
+str < foo?.String()
+str < greet(str)
+str < str
+str < str && false
+str < str || ok
+str < string(add)
+str < string(foo)
+str < type(array)
+str < type(nil)
+str < type(true)
+str <= $env.str
+str <= $env?.[str]
+str <= $env?.foobar and false
+str <= $env?.str
+str <= foo.Bar
+str <= foo.String()
+str <= foo?.Bar
+str <= foo?.String()
+str <= greet(str)
+str <= str
+str <= str ?: str
+str <= str[:i]
+str <= string($env)
+str <= string(0)
+str <= string(list)
+str <= string(nil)
+str <= toJSON(nil)
+str <= type(1.0)
+str <= type(true)
+str == $env or $env
+str == $env || $env?.[Bar]
+str == $env.str
+str == $env?.Bar
+str == $env?.String
+str == $env?.[Bar]
+str == $env?.[Bar]?.[array]
+str == $env?.[String]
+str == $env?.[String]?.array
+str == $env?.[foobar]
+str == $env?.[str]
+str == $env?.foo.Bar
+str == $env?.foobar
+str == $env?.not
+str == $env?.str
+str == $env?.true
+str == first($env)
+str == foo.Bar
+str == foo.String()
+str == foo?.Bar
+str == foo?.String()
+str == greet(str)
+str == max($env)
+str == nil or true || $env
+str == reduce(array, str)
+str == str
+str == str || true
+str == string(add)
+str == string(foo)
+str == toBase64(str | repeat(0))
+str == toJSON(0)
+str == toJSON(1.0)
+str == trim(str)
+str == type(add)
+str == type(foo)
+str == type(greet)
+str == {foo: 1}.array
+str > $env or true
+str > $env || true
+str > $env.str
+str > $env?.[str]
+str > $env?.str
+str > foo.Bar
+str > foo.String()
+str > foo?.Bar
+str > foo?.String()
+str > str
+str > str + str
+str > str ?: 1
+str > str and true
+str > str[1:]
+str > string($env)
+str > toJSON(ok)
+str > trimSuffix(str)
+str > type(1)
+str > type(1.0)
+str > type(add)
+str > type(nil)
+str >= $env && false
+str >= $env or true
+str >= $env.str
+str >= $env?.[str]
+str >= $env?.str
+str >= foo.Bar
+str >= foo.String()
+str >= foo?.Bar
+str >= foo?.String()
+str >= greet(str)
+str >= str
+str >= string(1)
+str >= string(1.0)
+str >= toJSON(false)
+str >= type(list)
+str contains $env.str
+str contains $env?.Bar
+str contains $env?.String
+str contains $env?.String?.list
+str contains $env?.[Bar]
+str contains $env?.[Bar]?.foo
+str contains $env?.[String]
+str contains $env?.[String]?.[i]
+str contains $env?.[foobar]
+str contains $env?.[str]
+str contains $env?.false
+str contains $env?.foobar
+str contains $env?.str
+str contains foo.Bar
+str contains foo.String()
+str contains foo?.Bar
+str contains foo?.String()
+str contains greet(str)
+str contains str
+str contains string(ok)
+str contains string(str)
+str contains toJSON(f64)
+str contains toJSON(ok)
+str contains type(foo)
+str contains type(nil)
+str contains type(ok)
+str endsWith $env.str
+str endsWith $env?.Bar
+str endsWith $env?.String
+str endsWith $env?.[Bar]
+str endsWith $env?.[String]
+str endsWith $env?.[String]?.[add]
+str endsWith $env?.[foobar]
+str endsWith $env?.[str]
+str endsWith $env?.str
+str endsWith foo.Bar
+str endsWith foo.String()
+str endsWith foo?.Bar
+str endsWith foo?.String()
+str endsWith greet(str)
+str endsWith str
+str endsWith string(foo)
+str endsWith string(nil)
+str endsWith string(ok)
+str endsWith toJSON(0)
+str endsWith toJSON(foo)
+str endsWith toJSON(i)
+str endsWith toJSON(true)
+str endsWith trimPrefix($env.str)
+str endsWith type(list)
+str endsWith {foo: f64}.f64
+str endsWith {foo: nil, foo: $env}?.f64
+str in $env && $env
+str in $env == ok
+str in $env || $env
+str in $env.foo
+str in $env?.Bar
+str in $env?.String
+str in $env?.[Bar]
+str in $env?.[Bar]?.[str]
+str in $env?.[String]
+str in $env?.[String]?.str()
+str in $env?.[foobar?.[str]]
+str in $env?.foo
+str in $env?.foobar
+str in $env?.foobar?.greet
+str in [$env, nil]
+str in [nil]
+str in concat(array)
+str in find(list, true)
+str in foo
+str in foo and false
+str in foo || $env
+str in list?.[i]
+str in {foo: 1}
+str in {foo: f64}
+str in {foo: foo}
+str in {foo: i, foo: 1}
+str in {foo: nil, foo: 1.0}
+str in {foo: nil}
+str matches $env and false
+str matches $env.str
+str matches $env?.Bar
+str matches $env?.String
+str matches $env?.String?.list
+str matches $env?.[Bar]
+str matches $env?.[Bar]?.f64
+str matches $env?.[String]
+str matches $env?.[foobar]
+str matches $env?.[foobar]?.str
+str matches $env?.[str]
+str matches $env?.foobar?.[ok]
+str matches $env?.str
+str matches foo.Bar
+str matches foo.String()
+str matches foo?.Bar
+str matches foo?.String()
+str matches str
+str matches string($env?.[String])
+str matches string(1)
+str matches string(1.0)
+str matches string(add)
+str matches toJSON(nil)
+str matches type(0)
+str matches type(foo)
+str matches type(i)
+str matches type(str)
+str matches type(true)
+str not contains $env.str
+str not contains $env?.Bar
+str not contains $env?.Bar?.[f64]
+str not contains $env?.String
+str not contains $env?.String?.String
+str not contains $env?.[Bar]
+str not contains $env?.[Bar]?.Bar()
+str not contains $env?.[String]
+str not contains $env?.[foobar]
+str not contains $env?.[str]
+str not contains $env?.foobar
+str not contains $env?.nil
+str not contains $env?.str
+str not contains foo.Bar
+str not contains foo.String()
+str not contains foo?.Bar
+str not contains foo?.String()
+str not contains greet(str)
+str not contains last($env)?.add
+str not contains str
+str not contains str + str
+str not contains str[:1]
+str not contains string(str)
+str not contains toJSON(0)
+str not contains type(0)
+str not contains type(foo)
+str not contains type(list)
+str not contains type(str)
+str not contains upper(str)
+str not contains {foo: foo}.String
+str not endsWith $env.str
+str not endsWith $env?.Bar
+str not endsWith $env?.String
+str not endsWith $env?.[Bar]
+str not endsWith $env?.[String]
+str not endsWith $env?.[String]?.String
+str not endsWith $env?.[foobar?.foo($env)]
+str not endsWith $env?.[str]
+str not endsWith $env?.false
+str not endsWith $env?.not
+str not endsWith $env?.str
+str not endsWith first($env)
+str not endsWith first($env)?.[greet]
+str not endsWith foo.Bar
+str not endsWith foo.String()
+str not endsWith foo?.Bar
+str not endsWith foo?.String()
+str not endsWith greet(str)
+str not endsWith str
+str not endsWith str && $env?.String
+str not endsWith str || true
+str not endsWith string(1)
+str not endsWith type(i)
+str not endsWith type(list)
+str not in $env.foo
+str not in $env?.Bar
+str not in $env?.String
+str not in $env?.String?.[ok]
+str not in $env?.[Bar]
+str not in $env?.[Bar]?.list
+str not in $env?.[String]
+str not in $env?.[String]?.add()
+str not in $env?.[foobar]
+str not in $env?.[foobar]?.[ok]
+str not in $env?.[nil]
+str not in $env?.foo
+str not in $env?.foobar
+str not in [nil, greet]
+str not in [nil]
+str not in foo
+str not in foo && $env
+str not in foo and false
+str not in foo and ok
+str not in foo || $env
+str not in foo || ok
+str not in foo || true
+str not in groupBy(list, #)
+str not in list?.[i]
+str not in reduce($env, $env, list)
+str not in {foo: 0, foo: add}
+str not in {foo: 1.0}
+str not in {foo: add}
+str not in {foo: foo, foo: list, foo: $env}
+str not in {foo: foo}
+str not in {foo: nil}
+str not matches $env.str
+str not matches $env?.Bar
+str not matches $env?.String
+str not matches $env?.[Bar]
+str not matches $env?.[String]
+str not matches $env?.[foobar]
+str not matches $env?.[str]
+str not matches $env?.foobar
+str not matches $env?.str
+str not matches foo.Bar
+str not matches foo.String()
+str not matches foo?.Bar
+str not matches foo?.String()
+str not matches str
+str not matches str || ok
+str not matches string(foo)
+str not matches toJSON(1.0)
+str not matches toJSON(f64)
+str not matches toJSON(i)
+str not matches toJSON(nil)
+str not matches type(false)
+str not matches type(true)
+str not startsWith $env.str
+str not startsWith $env?.$env?.[add]
+str not startsWith $env?.Bar
+str not startsWith $env?.String
+str not startsWith $env?.[Bar]
+str not startsWith $env?.[Bar]?.[i]
+str not startsWith $env?.[String]
+str not startsWith $env?.[nil]
+str not startsWith $env?.[str]
+str not startsWith $env?.nil
+str not startsWith $env?.str
+str not startsWith foo.Bar
+str not startsWith foo.String()
+str not startsWith foo?.Bar
+str not startsWith foo?.String()
+str not startsWith greet(str)
+str not startsWith lower(str)
+str not startsWith str
+str not startsWith str ?: 1.0
+str not startsWith str ?: ok
+str not startsWith string(nil)
+str not startsWith toJSON(foo)
+str not startsWith toJSON(true)
+str not startsWith trimSuffix(string(foo))
+str not startsWith type(0)
+str not startsWith type(add)
+str not startsWith type(f64)
+str not startsWith type(ok)
+str startsWith $env.str
+str startsWith $env?.Bar
+str startsWith $env?.String
+str startsWith $env?.String?.[greet]
+str startsWith $env?.[Bar]
+str startsWith $env?.[String]
+str startsWith $env?.[foobar]
+str startsWith $env?.[str]
+str startsWith $env?.foobar
+str startsWith $env?.str
+str startsWith first($env)
+str startsWith foo.Bar
+str startsWith foo.String()
+str startsWith foo?.Bar
+str startsWith greet(str)
+str startsWith str
+str startsWith str && ok
+str startsWith str[1:]
+str startsWith toJSON(1.0)
+str startsWith toJSON(list)
+str startsWith toJSON(true)
+str | date(str)
+str | greet()
+str | greet() != $env?.$env
+str | greet() not in foo
+str | hasPrefix($env?.[str])
+str | hasPrefix(str)
+str | hasSuffix(str)
+str | indexOf(str)
+str | lastIndexOf(str)
+str | repeat(0)
+str | repeat(1)
+str | repeat(i)
+str | split(str)
+str | splitAfter(str)
+str | splitAfter(str, 1)
+str | trim(str)
+str | trimPrefix(str)
+str | trimPrefix(toJSON(ok))
+str | trimPrefix(type(i))
+str | trimSuffix(str)
+str; add
+str; foo
+str; greet
+str; i
+str; ok
+str; str
+str; uniq(array)
+str[$env?.i:]
+str[1:] endsWith str
+str[1:] not contains str
+str[1:] | greet()
+str[:$env.i]
+str[:$env?.i]
+str[:]
+str[:array | reduce(#)]
+str[:array?.[i]]
+str[:i]
+str[:median(1, 1.0)]
+str[:min(0)]
+str[first(array):]
+str[i:]
+str[i:] not endsWith str
+str[i:i]
+string($env != 0)
+string($env != 1)
+string($env != 1.0)
+string($env != add)
+string($env != f64)
+string($env != foo)
+string($env != i)
+string($env != nil)
+string($env != ok)
+string($env != str)
+string($env != true)
+string($env && false)
+string($env && true)
+string($env == $env)
+string($env == array)
+string($env == false)
+string($env == foo)
+string($env == greet)
+string($env == nil)
+string($env and true)
+string($env in $env?.[Bar])
+string($env in array)
+string($env not in array)
+string($env | all(false))
+string($env | all(ok))
+string($env | count(false))
+string($env | findIndex(ok))
+string($env | findIndex(true))
+string($env | findLastIndex(true))
+string($env | map(#index))
+string($env | map($env))
+string($env | map(1))
+string($env | map(array))
+string($env | map(greet))
+string($env | none(ok))
+string($env | one(true))
+string($env | reduce(f64, 1.0))
+string($env | sum(0))
+string($env | sum(1))
+string($env | sum(1.0))
+string($env || false)
+string($env) matches str
+string($env) not startsWith str
+string($env) | greet()
+string($env)[i:]
+string($env.add)
+string($env.array)
+string($env.f64)
+string($env.foo)
+string($env.greet)
+string($env.i)
+string($env.list)
+string($env.ok)
+string($env.str)
+string($env?.$env)
+string($env?.Bar)
+string($env?.Bar?.[str])
+string($env?.String)
+string($env?.String?.Bar)
+string($env?.String?.String)
+string($env?.[Bar])
+string($env?.[Bar]?.[i])
+string($env?.[String])
+string($env?.[foobar])
+string($env?.[str])
+string($env?.add)
+string($env?.array)
+string($env?.f64)
+string($env?.false)
+string($env?.foo)
+string($env?.foobar)
+string($env?.greet)
+string($env?.i)
+string($env?.list)
+string($env?.ok)
+string($env?.str)
+string(0 != 0)
+string(0 != 1.0)
+string(0 != nil)
+string(0 % 1)
+string(0 * 0)
+string(0 * 1)
+string(0 * f64)
+string(0 * i)
+string(0 ** 0)
+string(0 ** 1)
+string(0 ** 1.0)
+string(0 ** f64)
+string(0 + 1.0)
+string(0 - 1)
+string(0 .. i)
+string(0 < 0)
+string(0 < 1)
+string(0 < 1.0)
+string(0 < f64)
+string(0 <= 0)
+string(0 <= f64)
+string(0 <= i)
+string(0 == $env)
+string(0 == 1)
+string(0 == i)
+string(0 == nil)
+string(0 > f64)
+string(0 > i)
+string(0 >= 1)
+string(0 >= i)
+string(0) >= str
+string(1 != f64)
 string(1 != nil)
 string(1 % 1)
-string(1 % i)
-string(1 % i32)
-string(1 * 0.5)
-string(1 * f32)
+string(1 * 0)
+string(1 * 1.0)
 string(1 * f64)
-string(1 ** 0.5)
+string(1 * i)
+string(1 ** 0)
 string(1 ** 1)
-string(1 ** i)
-string(1 ** i64)
-string(1 + 0.5)
-string(1 + 1)
-string(1 + f64)
-string(1 - 0.5)
-string(1 - f32)
-string(1 - i32)
-string(1 - i64)
+string(1 ** 1.0)
+string(1 ** f64)
+string(1 + i)
+string(1 - 1)
+string(1 - 1.0)
+string(1 - f64)
+string(1 .. 0)
 string(1 .. 1)
-string(1 .. i32)
-string(1 .. i64)
-string(1 / 0.5)
+string(1 / 0)
+string(1 / 1.0)
 string(1 / f64)
-string(1 / i)
-string(1 / i32)
-string(1 / i64)
-string(1 < 0.5)
-string(1 <= 1)
-string(1 <= f32)
+string(1 < 0)
+string(1 < 1.0)
+string(1 <= 1.0)
+string(1 <= f64)
 string(1 <= i)
-string(1 <= i32)
-string(1 <= i64)
-string(1 == 1)
-string(1 == f32)
-string(1 == i32)
-string(1 > 0.5)
-string(1 > 1)
-string(1 > i64)
-string(1 >= f32)
+string(1 == $env)
+string(1 == i)
+string(1 == nil)
+string(1 > $env?.i)
+string(1 > 0)
+string(1 >= 1)
+string(1 >= 1.0)
+string(1 >= f64)
 string(1 >= i)
-string(1 ^ 0.5)
 string(1 ^ 1)
-string(1 ^ f32)
-string(1 ^ f64)
-string(1 ^ i64)
-string(1 not in array)
-string([0.5])
-string([div])
+string(1 ^ 1.0)
+string(1 ^ i)
+string(1 | min(1.0))
+string(1) != str
+string(1) < foo?.Bar
+string(1) == $env?.[Bar]
+string(1) not in foo
+string(1) not startsWith toJSON(1)
+string(1) | greet()
+string(1..i)
+string(1.0 != $env)
+string(1.0 != 0)
+string(1.0 != 1.0)
+string(1.0 != nil)
+string(1.0 * 0)
+string(1.0 * 1)
+string(1.0 * 1.0)
+string(1.0 * f64)
+string(1.0 * i)
+string(1.0 ** 0)
+string(1.0 ** 1)
+string(1.0 ** 1.0)
+string(1.0 ** f64)
+string(1.0 ** i)
+string(1.0 + 1.0)
+string(1.0 + f64)
+string(1.0 + i)
+string(1.0 - 0)
+string(1.0 - 1)
+string(1.0 - 1.0)
+string(1.0 - i)
+string(1.0 / 0)
+string(1.0 / 1)
+string(1.0 / 1.0)
+string(1.0 / f64)
+string(1.0 < 1)
+string(1.0 <= 1)
+string(1.0 <= 1.0)
+string(1.0 == 1)
+string(1.0 == 1.0)
+string(1.0 == f64)
+string(1.0 == i)
+string(1.0 == nil)
+string(1.0 > 0)
+string(1.0 > 1)
+string(1.0 > 1.0)
+string(1.0 > i)
+string(1.0 >= 1)
+string(1.0 >= 1.0)
+string(1.0 ^ 0)
+string(1.0 ^ 1)
+string(1.0 ^ 1.0)
+string(1.0 ^ f64)
+string(1.0 ^ i)
+string(1.0 in array)
+string(1.0)
+string(1.0) != str
+string(1.0) not startsWith toJSON(false)
+string(1.0) startsWith str
+string(1.0) startsWith type(foo)
+string(1.0) | greet()
+string([$env, foo])
+string([$env, ok])
+string([$env])
+string([0, nil])
+string([1, true])
+string([1.0])
+string([1])
+string([add])
+string([array])
+string([f64, f64])
 string([f64])
-string([list])
-string([score])
+string([false, 1])
+string([false])
+string([foo])
+string([greet, i])
+string([greet])
+string([nil])
+string([ok, 1])
+string([ok, list])
+string([ok, nil])
+string([ok])
+string([str])
+string([true, list])
 string([true])
-string(abs(0.5))
+string(abs(0))
 string(abs(1))
-string(abs(f32))
-string(abs(i))
-string(abs(i32))
-string(add != add)
-string(add != div)
-string(add == div)
+string(abs(1.0))
+string(abs(f64))
 string(add == nil)
+string(add(1, 0))
+string(add(1, 1))
 string(add)
-string(add) in foo ? i64 : i32
-string(add) not endsWith foo.Bar
-string(all(array, ok))
-string(all(array, true))
+string(add) in foo
+string(add) matches str
+string(add) | greet()
 string(any(array, ok))
-string(any(list, false))
-string(any(list, ok))
+string(array != $env)
 string(array != array)
 string(array != nil)
+string(array == $env)
+string(array == array)
+string(array == list)
+string(array == nil)
+string(array | any(ok))
+string(array | map($env))
+string(array | map(f64))
+string(array | one(true))
+string(array | reduce(#acc))
+string(array | reduce(add))
+string(array | sortBy(#))
+string(array | sum(#))
+string(array | sum(f64))
 string(array)
-string(array[i32])
+string(array) > str
+string(array) >= foo.Bar
+string(array) not in foo
+string(array) not startsWith str
+string(array) | greet()
+string(array)[:i]
+string(array?.[i])
+string(array[i:])
+string(bitnot(0))
 string(bitnot(1))
-string(bitnot(i32))
-string(bitnot(i64))
-string(ceil(0.5))
+string(bitnot(i))
+string(ceil(0))
 string(ceil(1))
-string(ceil(f32))
+string(ceil(1.0))
 string(ceil(f64))
-string(ceil(i))
-string(ceil(i64))
-string(div != div)
-string(div != nil)
-string(div == add)
-string(div == div)
-string(div)
-string(f32 != 0.5)
-string(f32 != f64)
-string(f32 != i)
-string(f32 != nil)
-string(f32 * 0.5)
-string(f32 * 1)
-string(f32 * f64)
-string(f32 * i)
-string(f32 * i32)
-string(f32 ** 1)
-string(f32 ** f64)
-string(f32 + f32)
-string(f32 + f64)
-string(f32 + i32)
-string(f32 + i64)
-string(f32 - 0.5)
-string(f32 - 1)
-string(f32 - i64)
-string(f32 / 0.5)
-string(f32 / f64)
-string(f32 / i64)
-string(f32 < f32)
-string(f32 <= i)
-string(f32 <= i32)
-string(f32 == 0.5)
-string(f32 == i)
-string(f32 > 0.5)
-string(f32 > f64)
-string(f32)
-string(f32) in foo
-string(f64 != 1)
-string(f64 != i)
+string(concat(array))
+string(count($env, false))
+string(f64 != $env)
+string(f64 != f64)
 string(f64 != nil)
-string(f64 * 0.5)
-string(f64 * i)
-string(f64 * i32)
-string(f64 * i64)
-string(f64 ** 0.5)
-string(f64 ** f64)
-string(f64 ** i)
-string(f64 + 0.5)
+string(f64 * 1)
+string(f64 * f64)
+string(f64 ** 0)
+string(f64 ** 1.0)
 string(f64 + 1)
-string(f64 + f32)
-string(f64 - 0.5)
+string(f64 + 1.0)
+string(f64 + f64)
 string(f64 - 1)
-string(f64 - i)
-string(f64 / 0.5)
-string(f64 < f32)
-string(f64 < i)
-string(f64 <= 1)
-string(f64 <= f32)
-string(f64 <= f64)
-string(f64 == 1)
-string(f64 == f32)
-string(f64 == i)
-string(f64 == i64)
+string(f64 < 1.0)
+string(f64 < f64)
+string(f64 == $env)
+string(f64 == 1.0)
+string(f64 == nil)
+string(f64 > 0)
 string(f64 > 1)
-string(f64 >= f32)
+string(f64 > 1.0)
+string(f64 > f64)
+string(f64 >= 0)
+string(f64 >= 1.0)
 string(f64 >= i)
-string(f64 ^ 0.5)
-string(f64 ^ f32)
+string(f64 ^ 1.0)
 string(f64 ^ i)
-string(f64 in array)
-string(f64 not in array)
 string(f64)
-string(false != nil)
-string(false != ok)
+string(f64) + str
+string(f64) < str
+string(false != $env)
+string(false != false)
 string(false != true)
-string(false ? array : 0.5)
-string(false ? f64 : i32)
-string(false ? false : i)
-string(false ? greet : f64)
-string(false ? half : "bar")
-string(false ? half : i)
-string(false ? i : i)
-string(false ? nil : nil)
-string(false and ok)
-string(false) endsWith toBase64("foo")
-string(filter(array, false))
-string(filter(array, ok))
-string(filter(array, true))
-string(filter(list, false))
-string(find(array, ok))
-string(find(array, true))
-string(find(list, ok))
-string(findIndex(array, true))
-string(findLast(array, false))
-string(findLast(array, ok))
-string(findLast(array, true))
-string(findLastIndex(array, ok))
+string(false && $env)
+string(false && ok)
+string(false == $env)
+string(false == nil)
+string(false ? foo : 1)
+string(false ?: i)
+string(false and false)
+string(false or $env)
+string(false or false)
+string(false or ok)
+string(false || $env)
+string(false) not contains str
+string(false) | greet()
+string(find(array, false))
+string(find(list, true))
+string(findIndex($env, true))
+string(findIndex(list, false))
+string(findLast(list, ok))
+string(findLastIndex($env, false))
+string(findLastIndex(list, false))
+string(findLastIndex(list, ok))
+string(first($env))
 string(first(array))
 string(first(list))
-string(float(0.5))
-string(float(1))
+string(flatten(list))
+string(float(0))
+string(float(1.0))
 string(float(f64))
 string(float(i))
-string(float(i64))
-string(floor(0.5))
-string(floor(f32))
+string(floor(0))
+string(floor(1))
+string(floor(1.0))
 string(floor(f64))
 string(floor(i))
-string(floor(i32))
-string(floor(i64))
+string(foo != $env)
+string(foo != foo)
+string(foo != nil)
+string(foo == $env)
 string(foo == foo)
 string(foo == nil)
+string(foo in list)
 string(foo not in list)
 string(foo)
+string(foo) != $env?.Bar
+string(foo) != $env?.foobar
+string(foo) < str
+string(foo) > str
+string(foo) contains str
+string(foo) not endsWith type(str)
+string(foo) startsWith str
+string(foo) | greet()
 string(foo.Bar)
-string(foo.Qux)
 string(foo.String())
 string(foo.String)
 string(foo?.Bar)
-string(foo?.Qux)
+string(foo?.Bar) not in foo
 string(foo?.String())
 string(foo?.String)
-string(get(array, i))
-string(get(array, i64))
-string(get(list, 1))
-string(get(list, i32))
-string(get(list, i64))
-string(greet != nil)
-string(greet == greet)
-string(greet == nil)
-string(greet("bar"))
-string(greet("foo"))
+string(greet(str))
 string(greet)
-string(greet) == nil ? 0.5 : i
-string(groupBy(array, #))
-string(groupBy(array, 1))
-string(groupBy(array, f32))
-string(groupBy(array, false))
-string(groupBy(array, i32))
-string(groupBy(list, #))
-string(groupBy(list, 0.5))
-string(groupBy(list, 1))
-string(groupBy(list, f64))
-string(groupBy(list, false))
-string(groupBy(list, i))
-string(half != nil)
-string(half == nil)
-string(half(0.5))
-string(half(1))
-string(half(f64))
-string(half)
+string(greet) not matches str
+string(groupBy(list, ok)?.greet)
+string(groupBy(list, str))
+string(i != 0)
 string(i != 1)
-string(i != i64)
+string(i != 1.0)
+string(i != nil)
 string(i % 1)
-string(i % i32)
-string(i % i64)
-string(i * 1)
-string(i * f64)
-string(i ** f32)
-string(i ** f64)
-string(i ** i64)
-string(i + 0.5)
-string(i + i)
-string(i - f32)
+string(i * 1.0)
+string(i ** 1.0)
+string(i + 0)
+string(i + 1)
+string(i + 1.0)
+string(i + f64)
+string(i - 1)
+string(i - 1.0)
+string(i - f64)
+string(i - i)
 string(i .. 1)
-string(i .. i)
-string(i .. i32)
-string(i / 1)
-string(i / f32)
+string(i / 0)
 string(i / f64)
-string(i / i32)
-string(i / i64)
-string(i < 0.5)
-string(i < 1)
-string(i < i32)
-string(i <= f32)
-string(i <= i)
-string(i == 1)
-string(i == i)
-string(i > 0.5)
-string(i > 1)
-string(i > f32)
-string(i >= 0.5)
-string(i >= i64)
+string(i <= f64)
+string(i == $env)
+string(i == f64)
+string(i > 0)
+string(i >= 1.0)
 string(i ^ 1)
-string(i ^ f32)
+string(i ^ f64)
 string(i ^ i)
-string(i ^ i64)
+string(i not in array)
+string(i | bitshr(i))
+string(i | min(1.0, 1.0))
 string(i)
-string(i) in foo
-string(i32 != 0.5)
-string(i32 != 1)
-string(i32 != f64)
-string(i32 != i32)
-string(i32 != nil)
-string(i32 % 1)
-string(i32 % i)
-string(i32 % i64)
-string(i32 * 1)
-string(i32 * f32)
-string(i32 * f64)
-string(i32 * i)
-string(i32 ** 0.5)
-string(i32 ** f64)
-string(i32 + 0.5)
-string(i32 - 0.5)
-string(i32 - 1)
-string(i32 - f32)
-string(i32 - f64)
-string(i32 - i32)
-string(i32 - i64)
-string(i32 .. 1)
-string(i32 .. i)
-string(i32 / 0.5)
-string(i32 < 1)
-string(i32 < f64)
-string(i32 < i64)
-string(i32 == f32)
-string(i32 == i64)
-string(i32 == nil)
-string(i32 > 1)
-string(i32 > i)
-string(i32 >= 0.5)
-string(i32 >= 1)
-string(i32 >= i)
-string(i32 ^ f32)
-string(i32 ^ f64)
-string(i32 ^ i32)
-string(i32 in array)
-string(i32 not in array)
-string(i32)
-string(i32) not startsWith trimSuffix("foo")
-string(i64 != 1)
-string(i64 != i)
-string(i64 != i32)
-string(i64 != i64)
-string(i64 % i32)
-string(i64 * 1)
-string(i64 * f32)
-string(i64 * i)
-string(i64 ** 0.5)
-string(i64 + i64)
-string(i64 - i)
-string(i64 - i32)
-string(i64 - i64)
-string(i64 .. 1)
-string(i64 .. i)
-string(i64 .. i32)
-string(i64 / f64)
-string(i64 / i)
-string(i64 / i64)
-string(i64 < 0.5)
-string(i64 < i)
-string(i64 <= i64)
-string(i64 == 0.5)
-string(i64 == i)
-string(i64 > 0.5)
-string(i64 > i64)
-string(i64 >= 0.5)
-string(i64 >= 1)
-string(i64 ^ 0.5)
-string(i64 ^ f64)
-string(i64 in array)
-string(i64)
-string(i64) matches greet("bar")
-string(i64) not in foo
-string(int(0.5))
+string(i) not in foo
+string(i) | indexOf(str)
+string(if false { foo } else { false })
+string(if false { ok } else { i })
+string(if ok { 1 } else { 1.0 })
+string(if true { 1 } else { $env })
+string(if true { 1.0 } else { foo })
+string(if true { list } else { 0 })
+string(int(0))
 string(int(1))
-string(int(i32))
-string(int(i64))
+string(int(1.0))
+string(int(f64))
+string(int(i))
+string(keys($env))
+string(last($env))
 string(last(array))
-string(last(list).String())
-string(len("bar"))
+string(last(list))
+string(len($env))
 string(len(array))
 string(len(list))
+string(len(str))
+string(list != $env)
+string(list != list)
 string(list != nil)
 string(list == array)
 string(list == list)
-string(list == nil)
+string(list | count(true))
+string(list | groupBy(#))
+string(list | groupBy(1))
+string(list | map(.Bar))
+string(list | map(greet))
+string(list | map(i))
+string(list | one(false))
+string(list | reduce(#))
+string(list | reduce(#index))
+string(list | reduce(.String))
+string(list | reduce(1))
+string(list | reduce(false))
+string(list | sortBy(1.0))
 string(list)
-string(list[1])
-string(list[i32])
-string(list[i64])
-string(list[i])
-string(map(array, #))
-string(map(array, 0.5))
+string(list) not contains str
+string(list) startsWith str
+string(list?.[0])
+string(list?.[i])
+string(list[1:])
+string(list[:0])
+string(list[i:])
+string(lower(str))
+string(map($env, $env))
+string(map($env, 1.0))
+string(map($env, add))
+string(map($env, f64))
+string(map($env, false))
+string(map($env, foo))
+string(map($env, i))
+string(map($env, true))
 string(map(array, add))
-string(map(array, div))
-string(map(array, i))
-string(map(array, i32))
-string(map(array, true))
-string(map(list, "bar"))
-string(map(list, "foo"))
-string(map(list, #))
-string(map(list, 0.5))
-string(map(list, 1))
-string(map(list, array))
-string(map(list, half))
-string(map(list, i32))
-string(map(list, i64))
-string(max(0.5))
-string(max(0.5, f32))
+string(map(array, f64))
+string(map(array, greet))
+string(map(list, $env))
+string(map(list, greet))
+string(map(list, list))
+string(max($env))
+string(max(0))
 string(max(1))
-string(max(f32))
-string(max(f64))
+string(max(1.0))
+string(max(array))
 string(max(i))
-string(max(i64))
+string(mean(0))
+string(mean(1.0))
 string(mean(array))
-string(min(0.5))
-string(min(f32))
+string(mean(i))
+string(median(0))
+string(median(1.0))
+string(median(array))
+string(median(f64))
+string(median(i))
+string(min($env))
+string(min(0))
+string(min(0, 1.0))
+string(min(1))
+string(min(1.0, 0))
+string(min(array))
+string(min(f64))
 string(min(i))
-string(min(i32))
-string(min(i64))
-string(nil != "bar")
-string(nil != div)
-string(nil != false)
-string(nil != greet)
-string(nil != half)
-string(nil != i)
+string(nil != $env)
+string(nil != 0)
+string(nil != 1.0)
+string(nil != foo)
 string(nil != ok)
-string(nil == "bar")
-string(nil == 0.5)
-string(nil == 1)
-string(nil == div)
+string(nil != str)
+string(nil == 0)
+string(nil == array)
+string(nil == f64)
 string(nil == foo)
+string(nil == greet)
 string(nil == list)
 string(nil == nil)
-string(nil == ok)
-string(nil == score)
-string(nil in list)
+string(nil == nil) <= str
+string(nil == true)
+string(nil in $env)
+string(nil in array)
+string(nil not in $env)
 string(nil not in list)
-string(nil) <= list[i].Bar
-string(none(array, ok))
-string(none(list, false))
-string(none(list, ok))
-string(not !false)
-string(not (i64 == 0.5))
-string(not false)
-string(not ok)
-string(not true)
-string(ok != nil)
-string(ok != true)
-string(ok ? 0.5 : nil)
-string(ok ? 0.5 : true)
-string(ok ? 1 : array)
-string(ok ? 1 : f32)
-string(ok ? array : add)
-string(ok ? div : array)
-string(ok ? half : score)
-string(ok ? i : 1)
-string(ok ? nil : half)
-string(ok ? nil : list)
-string(ok or false)
+string(nil) != $env?.[String]
+string(nil) == toJSON(nil)
+string(nil) >= str
+string(nil) contains str
+string(nil) in foo
+string(nil) not matches greet(str)
+string(nil) not startsWith str
+string(nil) | greet()
+string(nil) | trimSuffix(str)
+string(nil)[i:]
+string(ok != ok)
+string(ok && $env)
+string(ok && ok)
+string(ok && true)
+string(ok == false)
+string(ok == nil)
+string(ok ? $env : str)
+string(ok ? foo : ok)
+string(ok ? true : $env)
+string(ok ?: add)
+string(ok ?: f64)
+string(ok and true)
+string(ok or ok)
+string(ok || $env)
 string(ok || false)
 string(ok)
-string(one(array, true))
-string(one(list, true))
+string(ok) >= str
+string(ok) contains str
+string(ok) in foo
+string(ok) matches str
+string(ok) | greet()
+string(ok) | indexOf(str)
+string(ok)[:]
+string(one($env, false))
 string(reduce(array, #))
-string(reduce(array, 0.5))
-string(reduce(array, 1))
-string(reduce(array, f64))
-string(reduce(array, greet))
-string(reduce(array, half))
-string(reduce(array, i64))
+string(reduce(array, foo))
 string(reduce(array, list))
-string(reduce(array, score))
-string(reduce(list, "bar"))
-string(reduce(list, #))
-string(reduce(list, 1))
-string(reduce(list, add))
-string(reduce(list, div))
 string(reduce(list, foo))
-string(reduce(list, i))
-string(reduce(list, i64))
-string(reduce(list, list))
-string(round(0.5))
+string(reduce(list, greet))
+string(reduce(list, ok, 1.0))
+string(round(0))
 string(round(1))
-string(round(ceil(i32)))
+string(round(1.0))
 string(round(f64))
-string(round(i64))
-string(score != nil)
-string(score == nil)
-string(score(1 % 1))
-string(score(1))
-string(score(i))
-string(score)
+string(round(i))
+string(sort($env))
 string(sort(array))
-string(sortBy(array, "foo"))
-string(string("bar"))
-string(string("foo"))
-string(string(0.5))
-string(string(1))
-string(string(array))
-string(string(div))
-string(string(f32))
-string(string(f64))
+string(sortBy(array, #))
+string(sortBy(list, f64))
+string(str <= str)
+string(str == $env)
+string(str == nil)
+string(str == str)
+string(str in $env)
+string(str in foo)
+string(str not in $env)
+string(str not in foo)
+string(str not matches str)
+string(str)
+string(str) + str
+string(str) contains str
+string(str) in foo
+string(str) matches str
+string(str) not contains str
+string(str)[:]
+string(str[:1])
+string(str[:i])
+string(string($env))
+string(string(0))
+string(string(1.0))
+string(string(add))
 string(string(false))
+string(string(foo))
 string(string(greet))
-string(string(half))
 string(string(i))
-string(string(i64))
-string(string(nil))
+string(string(list))
 string(string(ok))
-string(string(score))
+string(string(str))
+string(string(true))
+string(sum($env, 0))
+string(sum($env, 1.0))
 string(sum(array))
-string(toBase64("foo"))
-string(toJSON("bar"))
-string(toJSON(0.5))
+string(sum(list, 0))
+string(toBase64(str))
+string(toJSON(0))
 string(toJSON(1))
+string(toJSON(1.0))
 string(toJSON(array))
-string(toJSON(f32))
 string(toJSON(f64))
 string(toJSON(false))
-string(toJSON(i))
-string(toJSON(i32))
-string(toJSON(i64))
-string(toJSON(list))
+string(toJSON(foo))
 string(toJSON(nil))
 string(toJSON(ok))
+string(toJSON(str))
 string(toJSON(true))
-string(trim("bar"))
-string(trim(type(nil)))
-string(trimPrefix("foo"))
-string(trimSuffix("foo"))
+string(toPairs($env))
+string(trim(str))
+string(trimPrefix(str))
 string(true != false)
-string(true && ok)
+string(true != nil)
+string(true != ok)
+string(true != true)
+string(true && $env)
+string(true && false)
+string(true == false)
 string(true == nil)
-string(true ? 0.5 : true)
-string(true ? f64 : score)
-string(true ? false : nil)
-string(true ? greet : i)
-string(true ? list : ok)
-string(true and false)
-string(true or false)
+string(true ? $env : f64)
+string(true ? add : nil)
+string(true ? false : greet)
+string(true ? foo : $env)
+string(true ? str : add)
+string(true ?: $env)
+string(true and ok)
 string(true or ok)
+string(true || $env)
 string(true || true)
-string(type("bar"))
-string(type("foo"))
-string(type(-i64))
-string(type(0.5))
+string(true) + str
+string(type($env))
+string(type(0))
 string(type(1))
+string(type(1.0))
+string(type(add))
 string(type(array))
-string(type(f32))
-string(type(f64))
+string(type(false))
 string(type(foo))
 string(type(greet))
-string(type(half))
-string(type(i))
-string(type(i32))
-string(type(i64))
 string(type(list))
 string(type(nil))
 string(type(ok))
-string(type(score))
-string(upper("foo"))
-string({"bar": "foo", "foo": half})
-string({"bar": f32, "foo": i32})
-string({"bar": f32})
-string({"bar": true})
-string({"foo": add})
-string({"foo": array, "foo": list})
+string(type(str))
+string(type(true))
+string(uniq(array))
+string(upper(str))
+string(values($env))
+string({foo: $env, foo: nil})
+string({foo: 0})
+string({foo: 1.0, foo: list})
+string({foo: 1.0})
+string({foo: add})
+string({foo: array, foo: 1.0, foo: list})
+string({foo: f64, foo: 1.0, foo: foo})
+string({foo: f64, foo: 1.0})
+string({foo: f64})
+string({foo: false, foo: array})
+string({foo: false})
+string({foo: foo, foo: str})
+string({foo: foo})
+string({foo: greet, foo: 1.0})
+string({foo: greet, foo: foo})
+string({foo: greet})
+string({foo: i, foo: $env})
+string({foo: i})
+string({foo: list})
+string({foo: nil, foo: 1})
+string({foo: nil, foo: foo})
+string({foo: nil, foo: list})
+string({foo: nil, foo: ok})
+string({foo: nil})
+string({foo: ok, foo: ok, foo: array})
+string({foo: ok, foo: str})
+string({foo: ok})
+string({foo: str})
+string({foo: true})
+sum($env | filter(false))
+sum($env | filter(false), reduce(#, #))
+sum($env | map(#index))
+sum($env | map(0))
+sum($env | map(1))
+sum($env | map(1.0))
+sum($env | map(i))
+sum($env | reduce(array, 0))
+sum($env, 0) in array
+sum($env, 1) >= 1.0 >= 1.0
+sum($env, 1) >= i
+sum($env, 1.0) >= f64
+sum($env, f64) | max(i)
+sum($env.array)
+sum($env.array, # ** #)
+sum($env.array, #)
+sum($env.array, f64)
+sum($env.list, i)
+sum($env?.[str])
+sum($env?.[str], #)
+sum($env?.array)
+sum($env?.array, #)
+sum($env?.array, i)
+sum($env?.list, f64 + 1.0)
+sum(0 .. 0)
+sum(0 .. 1)
+sum(0 .. i)
+sum(0..i)
+sum(1 .. 0)
 sum(1 .. 1)
 sum(1 .. i)
-sum(1 .. i32)
-sum(1 .. i64)
-sum([0.5])
-sum([f32])
+sum(1..i)
+sum(1..i, f64)
+sum([$env, add], f64)
+sum([0])
+sum([1, 1.0])
+sum([1.0, 1])
+sum([1.0, 1], f64)
+sum([1.0, f64])
+sum([1.0])
+sum([1])
+sum([f64, 1.0])
+sum([f64])
+sum([f64], i)
+sum([foo], f64)
+sum([i])
+sum([ok], f64)
+sum([str, str])
+sum(array | filter(false))
+sum(array | filter(ok))
+sum(array | filter(true))
+sum(array | map(#))
+sum(array | map(0))
+sum(array | map(1.0))
+sum(array | map(f64))
+sum(array | sortBy(#))
+sum(array | sortBy(0))
+sum(array | sortBy(1))
+sum(array | sortBy(1.0))
+sum(array | sortBy(str))
+sum(array | take(0))
 sum(array)
-sum(array) != f32
+sum(array) != f64
+sum(array) != i
+sum(array) != i ** 1.0
 sum(array) % i
-sum(array) % i64
-sum(array) - f32
-sum(array) / -f64
+sum(array) * i
+sum(array) ** f64
+sum(array) + $env.f64
+sum(array) + f64
+sum(array) + i
+sum(array) - 0 > 1.0
+sum(array) - ceil(0)
+sum(array) - f64
+sum(array) - i
+sum(array) .. i
+sum(array) / f64
+sum(array) < f64
 sum(array) < i
-sum(array) == i64 - i
+sum(array) <= f64
+sum(array) <= i || $env
+sum(array) == f64
+sum(array) == i
+sum(array) > f64
+sum(array) >= f64 != true
 sum(array) ^ f64
+sum(array) ^ i
+sum(array) ^ round(1)
+sum(array) not in $env.array
 sum(array) not in array
-sum(filter(array, ok))
-sum(groupBy(array, i32).String)
-sum(i32 .. 1)
-sum(i64 .. i32)
-sum(i64 .. i64)
-sum(list[i:1])
+sum(array) | bitxor(0)
+sum(array) | mean(1)
+sum(array) | mean(1.0)
+sum(array)..i
+sum(array); f64
+sum(array, # % #)
+sum(array, # ** #)
+sum(array, # / f64)
+sum(array, #)
+sum(array, #) * i
+sum(array, #) ** f64
+sum(array, #) <= i
+sum(array, #) not in array
+sum(array, $env.f64)
+sum(array, $env.i)
+sum(array, $env?.f64)
+sum(array, $env?.i)
+sum(array, 0 ** f64)
+sum(array, 1 - #)
+sum(array, 1) .. array?.[i]
+sum(array, 1.0 ** #)
+sum(array, 1.0) - f64
+sum(array, 1.0) == f64
+sum(array, array | reduce(f64))
+sum(array, array?.[i])
+sum(array, bitnot(#))
+sum(array, bitshr(#, #))
+sum(array, ceil(f64))
+sum(array, f64)
+sum(array, f64) + int(i)
+sum(array, f64) > i
+sum(array, f64) ^ i
+sum(array, float(#))
+sum(array, float(1.0))
+sum(array, floor(f64))
+sum(array, i + 1.0)
+sum(array, i)
+sum(array, mean(array))
+sum(array, round(1.0))
+sum(array, sum(array, #))
+sum(array[0:])
+sum(array[1:])
+sum(array[:0])
+sum(array[:1])
+sum(array[:i])
+sum(array[i:])
+sum(concat(array))
+sum(false ? $env : $env, f64)
+sum(false ? $env : array)
+sum(false ? i : str)
+sum(false ? nil : array)
+sum(false ? str : array)
+sum(false ?: array)
+sum(false ?: str)
+sum(filter($env, false))
+sum(filter($env, false), .add?.str(false, false))
+sum(filter(array, false))
+sum(filter(array, ok), f64)
+sum(filter(array, ok), i)
+sum(filter(array, true))
+sum(flatten(array))
+sum(flatten(array), max(#))
+sum(get($env, str))
+sum(i .. 0)
+sum(i .. 1)
+sum(i..i)
+sum(if false { 1 } else { array })
+sum(if false { array } else { array })
+sum(if ok { str } else { f64 })
+sum(if true { array } else { 1.0 })
+sum(if true { array } else { list })
+sum(let foobar = array; foobar)
+sum(list | filter(false))
+sum(list | map(0))
+sum(list | map(1))
+sum(list | map(1.0))
+sum(list | map(greet), i)
+sum(list | reduce($env), i)
+sum(list | reduce(array))
+sum(list | sortBy(str), f64)
+sum(list, $env.f64)
+sum(list, $env.i)
+sum(list, $env?.f64)
+sum(list, $env?.i)
+sum(list, 0) ** f64
+sum(list, 1) | bitxor(0)
+sum(list, 1.0 / 1.0)
+sum(list, f64 * 0)
+sum(list, f64 ** 0)
+sum(list, f64 - f64)
+sum(list, f64)
+sum(list, i + 0)
+sum(list, i / 0)
+sum(list, i)
+sum(list, int(i))
+sum(list, len(str))
+sum(list, list | sum(1.0))
+sum(list, max(0))
+sum(map($env, #index))
+sum(map($env, $env), i)
+sum(map($env, 0) | sortBy(1.0))
+sum(map($env, 0))
+sum(map($env, 1))
+sum(map($env, 1.0))
+sum(map($env, f64))
+sum(map($env, i))
 sum(map(array, #))
-sum(map(array, f32))
-sum(map(list, 0.5))
-sum(map(list, f32))
-sum(map(list, i32))
-sum(ok ? array : i64)
+sum(map(array, #index))
+sum(map(array, 0))
+sum(map(array, 1))
+sum(map(array, 1.0))
+sum(map(array, f64))
+sum(map(list, 0))
+sum(map(list, 1.0))
+sum(map(list, f64))
+sum(min($env), f64)
+sum(ok ? array : foo)
+sum(reduce($env, array, $env))
 sum(reduce(array, array))
 sum(reduce(list, array))
+sum(reverse(array))
+sum(sort($env))
+sum(sort($env), #.add not in #.add)
+sum(sort($env), $env == #)
 sum(sort(array))
-sum(true ? array : i32)
+sum(sort(ok ? i : 1.0))
+sum(sortBy(array, #))
+sum(sortBy(array, 0))
+sum(sortBy(array, 1))
+sum(sortBy(array, 1.0))
+sum(sortBy(array, f64))
+sum(sortBy(array, i))
+sum(sortBy(array, str))
+sum(take(array, i))
+sum(toPairs($env), i)
+sum(true ? str : 1.0)
+sum(true ? str : add)
+sum(true ? str : foo)
+sum(uniq(array))
+sum(uniq(array), 1.0 - 0)
 take(array, i)
-take(array, i32)
-take(array, i64)
 take(list, i)
-take(list, i32)
-take(list, i64)
-take(map(array, #), i)
-toBase64("bar" + "bar")
-toBase64("bar" + "foo")
-toBase64("bar") startsWith type(score)
-toBase64("foo" + "bar")
+toBase64($env.foo?.Bar)
+toBase64($env.str)
+toBase64($env?.[str])
+toBase64($env?.str)
 toBase64(foo.Bar)
 toBase64(foo.String())
 toBase64(foo?.Bar)
 toBase64(foo?.String())
-toBase64(greet("bar"))
-toBase64(greet("foo"))
-toBase64(lower("bar"))
-toBase64(lower("foo"))
-toBase64(ok ? "bar" : f64)
-toBase64(reduce(list, "bar"))
-toBase64(string("foo"))
-toBase64(string(0.5))
+toBase64(greet(str))
+toBase64(lower(str))
+toBase64(str + str)
+toBase64(str)
+toBase64(str) > str
+toBase64(str) >= str
+toBase64(str) not contains $env?.str
+toBase64(str) not startsWith str
+toBase64(str) | greet()
+toBase64(str) | repeat(i)
+toBase64(str)[i:]
+toBase64(str[:0])
+toBase64(string($env))
+toBase64(string(0))
 toBase64(string(1))
-toBase64(string(add))
+toBase64(string(1.0))
 toBase64(string(array))
-toBase64(string(f32))
 toBase64(string(f64))
+toBase64(string(false))
 toBase64(string(foo))
 toBase64(string(greet))
-toBase64(string(half))
 toBase64(string(i))
 toBase64(string(list))
+toBase64(string(nil))
 toBase64(string(ok))
-toBase64(toBase64("bar"))
-toBase64(toJSON("bar"))
-toBase64(toJSON(0.5))
-toBase64(toJSON(1))
-toBase64(toJSON(f32))
+toBase64(string(str))
+toBase64(toBase64(str))
+toBase64(toJSON(0))
+toBase64(toJSON(1.0))
+toBase64(toJSON(array))
 toBase64(toJSON(f64))
+toBase64(toJSON(false))
 toBase64(toJSON(foo))
-toBase64(toJSON(i64))
+toBase64(toJSON(i / 1))
+toBase64(toJSON(i))
 toBase64(toJSON(list))
 toBase64(toJSON(nil))
 toBase64(toJSON(ok))
 toBase64(toJSON(true))
-toBase64(trim("bar"))
-toBase64(trimPrefix("foo"))
-toBase64(trimSuffix("foo"))
-toBase64(type(0.5))
+toBase64(trimPrefix(str))
+toBase64(trimSuffix(str))
+toBase64(type($env))
+toBase64(type(0))
 toBase64(type(1))
+toBase64(type(1.0 < 1.0))
+toBase64(type(1.0))
 toBase64(type(add))
-toBase64(type(div))
-toBase64(type(f32))
+toBase64(type(array))
 toBase64(type(f64))
 toBase64(type(false))
 toBase64(type(foo))
 toBase64(type(greet))
-toBase64(type(half))
 toBase64(type(i))
-toBase64(type(i32))
-toBase64(type(i64))
 toBase64(type(list))
 toBase64(type(nil))
-toBase64(type(score))
-toBase64(upper("foo"))
-toJSON(!false)
-toJSON(!ok)
-toJSON(!true)
-toJSON("bar" < "foo")
-toJSON("bar" >= "bar")
-toJSON("bar" endsWith "bar")
-toJSON("bar" matches "foo")
-toJSON("bar" not in foo)
-toJSON("bar" not matches "bar")
-toJSON("bar" not startsWith "foo")
-toJSON("bar" startsWith "bar")
-toJSON("bar") not in foo
-toJSON("foo" != "bar")
-toJSON("foo" != "foo")
-toJSON("foo" < "foo")
-toJSON("foo" == "bar")
-toJSON("foo" > "foo")
-toJSON("foo" >= "foo")
-toJSON("foo" startsWith "bar")
-toJSON(-0.5)
-toJSON(-1)
-toJSON(-f32)
-toJSON(-f64)
-toJSON(-i)
-toJSON(-i32)
-toJSON(-i64)
-toJSON(0.5 != 1)
-toJSON(0.5 != f64)
-toJSON(0.5 != nil)
-toJSON(0.5 * i)
-toJSON(0.5 * i32)
-toJSON(0.5 * i64)
-toJSON(0.5 ** 0.5)
-toJSON(0.5 ** 1)
-toJSON(0.5 ** f32)
-toJSON(0.5 ** f64)
-toJSON(0.5 ** i)
-toJSON(0.5 ** i32)
-toJSON(0.5 + 0.5)
-toJSON(0.5 + 1)
-toJSON(0.5 + f32)
-toJSON(0.5 - 0.5)
-toJSON(0.5 - 1)
-toJSON(0.5 - f32)
-toJSON(0.5 - f64)
-toJSON(0.5 - i)
-toJSON(0.5 - i32)
-toJSON(0.5 / 1)
-toJSON(0.5 / f32)
-toJSON(0.5 / f64)
-toJSON(0.5 / i32)
-toJSON(0.5 < 1)
-toJSON(0.5 < f32)
-toJSON(0.5 < f64)
-toJSON(0.5 < i)
-toJSON(0.5 <= 0.5)
-toJSON(0.5 <= 1)
-toJSON(0.5 <= f32)
-toJSON(0.5 <= i64)
-toJSON(0.5 == 0.5)
-toJSON(0.5 == f64)
-toJSON(0.5 == i)
-toJSON(0.5 == i32)
-toJSON(0.5 == i64)
-toJSON(0.5 >= 0.5)
-toJSON(0.5 >= 1)
-toJSON(0.5 >= f32)
-toJSON(0.5 ^ f32)
-toJSON(0.5 ^ i32)
-toJSON(0.5 ^ i64)
-toJSON(0.5) not in foo
-toJSON(1 != 0.5)
-toJSON(1 != f32)
+toBase64(type(ok))
+toBase64(type(true))
+toBase64(upper(str))
+toJSON($env != 0)
+toJSON($env != add)
+toJSON($env != array)
+toJSON($env != false)
+toJSON($env != foo)
+toJSON($env != greet)
+toJSON($env != list)
+toJSON($env != nil)
+toJSON($env != str)
+toJSON($env != true)
+toJSON($env == $env)
+toJSON($env == 0)
+toJSON($env == 1)
+toJSON($env == f64)
+toJSON($env == false)
+toJSON($env == foo)
+toJSON($env == list)
+toJSON($env == nil)
+toJSON($env == str)
+toJSON($env == true)
+toJSON($env in list)
+toJSON($env not in list)
+toJSON($env or true)
+toJSON($env | all(false))
+toJSON($env | count(false))
+toJSON($env | findIndex(ok))
+toJSON($env | map(array))
+toJSON($env | map(f64))
+toJSON($env | map(list))
+toJSON($env | map(str))
+toJSON($env | map(true))
+toJSON($env | reduce(#index, nil))
+toJSON($env | reduce(false, 1))
+toJSON($env | sum(0))
+toJSON($env | sum(1))
+toJSON($env | sum(1.0))
+toJSON($env || true)
+toJSON($env.array)
+toJSON($env.f64)
+toJSON($env.foo)
+toJSON($env.i)
+toJSON($env.list)
+toJSON($env.ok)
+toJSON($env.str)
+toJSON($env?.$env)
+toJSON($env?.Bar)
+toJSON($env?.Bar?.[greet])
+toJSON($env?.String)
+toJSON($env?.[Bar])
+toJSON($env?.[String])
+toJSON($env?.[foobar])
+toJSON($env?.[foobar]?.i())
+toJSON($env?.[nil])
+toJSON($env?.[str])
+toJSON($env?.array)
+toJSON($env?.f64)
+toJSON($env?.false)
+toJSON($env?.foo)
+toJSON($env?.foobar)
+toJSON($env?.i)
+toJSON($env?.list)
+toJSON($env?.nil)
+toJSON($env?.ok)
+toJSON($env?.str)
+toJSON(0 != $env)
+toJSON(0 != nil)
+toJSON(0 % 1)
+toJSON(0 % i)
+toJSON(0 * 1.0)
+toJSON(0 ** 1.0)
+toJSON(0 ** f64)
+toJSON(0 + 0)
+toJSON(0 + 1)
+toJSON(0 + 1.0)
+toJSON(0 - 1)
+toJSON(0 - 1.0)
+toJSON(0 - f64)
+toJSON(0 .. i)
+toJSON(0 / 1.0)
+toJSON(0 / f64)
+toJSON(0 < 1.0)
+toJSON(0 <= 1.0)
+toJSON(0 <= f64)
+toJSON(0 == 1.0)
+toJSON(0 == f64)
+toJSON(0 == nil)
+toJSON(0 > i)
+toJSON(0 >= 0)
+toJSON(0 >= 1)
+toJSON(0 >= 1.0)
+toJSON(0 ^ 1.0)
+toJSON(0 ^ f64)
+toJSON(0 ^ i)
+toJSON(0 in array)
+toJSON(0 not in array)
+toJSON(0 | bitshl(0))
+toJSON(0 | bitshr(0))
+toJSON(0) + str
+toJSON(0) > str
+toJSON(0) >= str
+toJSON(0..i)
+toJSON(0.0)
+toJSON(1 != $env)
+toJSON(1 != i)
 toJSON(1 != nil)
-toJSON(1 % 1)
-toJSON(1 % i)
-toJSON(1 % i32)
-toJSON(1 * f64)
-toJSON(1 * i32)
-toJSON(1 * i64)
-toJSON(1 ** 0.5)
-toJSON(1 ** 1)
-toJSON(1 ** i32)
-toJSON(1 + 0.5)
+toJSON(1 * 1.0)
+toJSON(1 * i)
+toJSON(1 ** i)
 toJSON(1 + 1)
+toJSON(1 + 1.0)
 toJSON(1 + f64)
-toJSON(1 + i)
-toJSON(1 + i32)
-toJSON(1 - i)
-toJSON(1 - i32)
-toJSON(1 .. i32)
-toJSON(1 .. i64)
-toJSON(1 / 1)
+toJSON(1 - f64)
+toJSON(1 .. 0)
+toJSON(1 .. 1)
+toJSON(1 .. i)
 toJSON(1 / f64)
-toJSON(1 / i64)
-toJSON(1 < 0.5)
-toJSON(1 < 1)
-toJSON(1 < f64)
-toJSON(1 < i)
-toJSON(1 <= 0.5)
-toJSON(1 <= f32)
-toJSON(1 <= f64)
-toJSON(1 == 0.5)
-toJSON(1 == 1)
-toJSON(1 == f64)
-toJSON(1 == i)
-toJSON(1 == i32)
+toJSON(1 / i)
+toJSON(1 < 0)
+toJSON(1 < 1.0)
+toJSON(1 <= 0)
+toJSON(1 <= 1)
+toJSON(1 <= i)
+toJSON(1 == 0)
+toJSON(1 == 1.0)
 toJSON(1 == nil)
-toJSON(1 > f32)
+toJSON(1 > 0)
+toJSON(1 > 1)
 toJSON(1 > i)
-toJSON(1 >= 1)
-toJSON(1 >= f32)
-toJSON(1 >= i32)
-toJSON(1 ^ 1)
-toJSON(1 ^ f32)
-toJSON(1 ^ i32)
-toJSON(1 ^ i64)
-toJSON(1) > reduce(list, "bar")
-toJSON(1) not contains string(true)
-toJSON([f64])
+toJSON(1 >= f64)
+toJSON(1 >= i)
+toJSON(1 ^ 1.0)
+toJSON(1 not in array)
+toJSON(1) != str
+toJSON(1) endsWith str
+toJSON(1) not contains str
+toJSON(1) not in $env?.true
+toJSON(1) | greet()
+toJSON(1.0 != $env)
+toJSON(1.0 != 0)
+toJSON(1.0 != 1)
+toJSON(1.0 != 1.0)
+toJSON(1.0 != i)
+toJSON(1.0 != nil)
+toJSON(1.0 * 1)
+toJSON(1.0 * 1.0)
+toJSON(1.0 * f64)
+toJSON(1.0 * i)
+toJSON(1.0 ** 1)
+toJSON(1.0 ** 1.0)
+toJSON(1.0 ** i)
+toJSON(1.0 + 0)
+toJSON(1.0 + 1)
+toJSON(1.0 + 1.0)
+toJSON(1.0 - 0)
+toJSON(1.0 - 1)
+toJSON(1.0 - 1.0)
+toJSON(1.0 - f64)
+toJSON(1.0 / 1)
+toJSON(1.0 / 1.0)
+toJSON(1.0 / i)
+toJSON(1.0 < i)
+toJSON(1.0 <= 0)
+toJSON(1.0 <= 1.0)
+toJSON(1.0 <= f64)
+toJSON(1.0 <= i)
+toJSON(1.0 == $env)
+toJSON(1.0 == 1)
+toJSON(1.0 == 1.0)
+toJSON(1.0 == f64)
+toJSON(1.0 > 0)
+toJSON(1.0 > 1.0)
+toJSON(1.0 > i)
+toJSON(1.0 >= 0)
+toJSON(1.0 >= 1)
+toJSON(1.0 >= 1.0)
+toJSON(1.0 >= i)
+toJSON(1.0 ^ 1)
+toJSON(1.0 ^ 1.0)
+toJSON(1.0 ^ f64)
+toJSON(1.0 ^ i)
+toJSON(1.0 in array)
+toJSON(1.0 not in array)
+toJSON(1.0) + str
+toJSON(1.0) <= str
+toJSON(1.0) matches str
+toJSON(1.0) not in foo
+toJSON(1.0) | greet()
+toJSON(1.0) | indexOf(str)
+toJSON([0])
+toJSON([1, 1])
+toJSON([1.0])
+toJSON([1])
+toJSON([array, 0])
+toJSON([array])
+toJSON([f64, nil])
 toJSON([false])
+toJSON([foo, list])
 toJSON([foo])
 toJSON([nil])
+toJSON([ok])
+toJSON([str])
 toJSON([true])
-toJSON(abs(0.5))
+toJSON(abs(0))
 toJSON(abs(1))
-toJSON(abs(f32))
+toJSON(abs(1.0))
 toJSON(abs(f64))
-toJSON(abs(i))
-toJSON(abs(i32))
-toJSON(abs(i64))
+toJSON(add != $env)
 toJSON(add == add)
+toJSON(add == nil)
+toJSON(all(list, true))
 toJSON(any(array, false))
+toJSON(array != $env)
+toJSON(array != array)
+toJSON(array != list)
 toJSON(array == array)
 toJSON(array == list)
-toJSON(array == nil)
+toJSON(array | count(ok))
+toJSON(array | count(true))
+toJSON(array | find(true))
+toJSON(array | map(#))
+toJSON(array | max(i))
+toJSON(array | min(i))
+toJSON(array | none(false))
+toJSON(array | sortBy(#))
+toJSON(array | sortBy(0))
+toJSON(array | sum(i))
 toJSON(array)
-toJSON(array[1:i64])
-toJSON(array[1])
-toJSON(array[i])
+toJSON(array) + str
+toJSON(array) < str
+toJSON(array) == greet(str)
+toJSON(array) not contains str
+toJSON(array) | greet()
+toJSON(array?.[0])
+toJSON(array?.[1])
+toJSON(array?.[i])
+toJSON(array[1:])
+toJSON(bitand(0, 0))
+toJSON(bitnot(0))
 toJSON(bitnot(1))
 toJSON(bitnot(i))
-toJSON(bitnot(i32))
-toJSON(bitnot(i64))
-toJSON(bitshl(i, i32))
+toJSON(ceil(0))
 toJSON(ceil(1))
+toJSON(ceil(1.0))
 toJSON(ceil(f64))
 toJSON(ceil(i))
-toJSON(ceil(i32))
-toJSON(ceil(i64))
-toJSON(count(array, ok))
-toJSON(div != div)
-toJSON(div == div)
-toJSON(f32 != 0.5)
-toJSON(f32 != 1 || ok)
-toJSON(f32 != f32)
-toJSON(f32 != i32)
-toJSON(f32 * f32)
-toJSON(f32 ** 0.5)
-toJSON(f32 ** 1)
-toJSON(f32 ** f64)
-toJSON(f32 ** i32)
-toJSON(f32 + 0.5)
-toJSON(f32 + f32)
-toJSON(f32 - 0.5)
-toJSON(f32 - f32)
-toJSON(f32 - f64)
-toJSON(f32 - i64)
-toJSON(f32 < 0.5)
-toJSON(f32 < i)
-toJSON(f32 < i64)
-toJSON(f32 <= 0.5)
-toJSON(f32 <= 1)
-toJSON(f32 <= i64)
-toJSON(f32 == f64)
-toJSON(f32 == i)
-toJSON(f32 == nil)
-toJSON(f32 > i)
-toJSON(f32 > i32)
-toJSON(f32 >= 0.5)
-toJSON(f32 ^ i64)
-toJSON(f32)
-toJSON(f32) in foo
-toJSON(f64 != 0.5)
-toJSON(f64 != f32)
-toJSON(f64 != i)
-toJSON(f64 != i32)
+toJSON(concat(array))
+toJSON(concat(list))
+toJSON(count(array, true))
+toJSON(count(list, false))
+toJSON(count(list, true))
+toJSON(f64 != 1)
+toJSON(f64 != 1.0)
+toJSON(f64 != f64)
 toJSON(f64 != nil)
-toJSON(f64 * 1)
+toJSON(f64 * 0)
 toJSON(f64 * f64)
-toJSON(f64 * i64)
-toJSON(f64 ** 0.5)
-toJSON(f64 ** f32)
-toJSON(f64 + 0.5)
-toJSON(f64 + f32)
-toJSON(f64 + i32)
-toJSON(f64 - f64)
-toJSON(f64 - i)
-toJSON(f64 - i64)
-toJSON(f64 / 1)
-toJSON(f64 < f64)
-toJSON(f64 <= 0.5)
-toJSON(f64 == f64)
-toJSON(f64 >= 1)
-toJSON(f64 >= f64)
-toJSON(f64 ^ f32)
+toJSON(f64 ** f64)
+toJSON(f64 + 1.0)
+toJSON(f64 - 1.0)
+toJSON(f64 / 1.0)
+toJSON(f64 < 0)
+toJSON(f64 < 1)
+toJSON(f64 < 1.0)
+toJSON(f64 <= 0)
+toJSON(f64 <= 1)
+toJSON(f64 <= 1.0)
+toJSON(f64 == $env)
+toJSON(f64 == 0)
+toJSON(f64 == 1.0)
+toJSON(f64 == nil)
+toJSON(f64 >= 1.0)
+toJSON(f64 >= i)
+toJSON(f64 ^ 0)
+toJSON(f64 ^ f64)
+toJSON(f64 ^ i)
+toJSON(f64 in array)
+toJSON(f64 | median(i))
 toJSON(f64)
+toJSON(f64) > str
+toJSON(f64) in reduce(array, $env, array)
+toJSON(f64) not in foo
+toJSON(false != $env)
+toJSON(false != false)
+toJSON(false != nil)
 toJSON(false != ok)
-toJSON(false ? 0.5 : "foo")
-toJSON(false ? add : f64)
-toJSON(false ? array : 1)
-toJSON(false ? false : foo)
-toJSON(false ? nil : ok)
-toJSON(false ? ok : i32)
-toJSON(filter(list, true))
-toJSON(find(list, ok))
-toJSON(findIndex(map(array, list), ok))
-toJSON(first(array))
+toJSON(false && $env)
+toJSON(false && $env?.[greet])
+toJSON(false == nil)
+toJSON(false == true)
+toJSON(false or false)
+toJSON(false || false)
+toJSON(false || ok)
+toJSON(false) not endsWith str
+toJSON(false) startsWith first($env)
+toJSON(findIndex($env, false))
+toJSON(findIndex($env, true))
+toJSON(findIndex(list, false))
+toJSON(findLastIndex($env, false))
+toJSON(first($env))
 toJSON(first(list))
-toJSON(float(0.5))
+toJSON(flatten(array))
+toJSON(flatten(list))
+toJSON(float(0))
 toJSON(float(1))
-toJSON(float(f32))
+toJSON(float(1.0))
 toJSON(float(f64))
 toJSON(float(i))
-toJSON(float(i64))
-toJSON(floor(0.5))
+toJSON(floor(0))
+toJSON(floor(1.0))
 toJSON(floor(f64))
 toJSON(floor(i))
-toJSON(floor(i32))
+toJSON(foo != $env)
+toJSON(foo != foo)
 toJSON(foo != nil)
+toJSON(foo == $env)
+toJSON(foo == foo)
+toJSON(foo == nil)
 toJSON(foo in list)
+toJSON(foo not in list)
 toJSON(foo)
+toJSON(foo) < str
+toJSON(foo) > str
+toJSON(foo) not in $env?.String
+toJSON(foo) not matches str
+toJSON(foo) | greet()
+toJSON(foo) | repeat(i)
 toJSON(foo.Bar)
 toJSON(foo.String())
 toJSON(foo?.Bar)
 toJSON(foo?.String())
-toJSON(get(array, i32))
-toJSON(get(array, i64))
-toJSON(get(list, 1))
-toJSON(get(list, i))
-toJSON(get(list, i32))
-toJSON(get(list, i64))
+toJSON(greet != $env)
+toJSON(greet != greet)
 toJSON(greet != nil)
-toJSON(greet == greet)
-toJSON(greet == nil)
-toJSON(greet("bar"))
-toJSON(greet("foo"))
-toJSON(groupBy(array, #)?.div)
-toJSON(groupBy(array, ok)?.foo)
-toJSON(groupBy(list, #)?.foo)
-toJSON(half(0.5))
-toJSON(half(1))
-toJSON(half(f64))
-toJSON(i != 0.5)
-toJSON(i != 1)
-toJSON(i % i)
-toJSON(i % i32)
-toJSON(i * 0.5)
+toJSON(greet == $env)
+toJSON(greet(str))
+toJSON(groupBy(array, 1.0)?.Bar)
+toJSON(i != 1.0)
+toJSON(i != f64)
+toJSON(i != i)
+toJSON(i != nil)
+toJSON(i % 1)
+toJSON(i * 0)
 toJSON(i * 1)
-toJSON(i * f32)
-toJSON(i * i)
-toJSON(i * i32)
-toJSON(i ** f32)
-toJSON(i ** i)
-toJSON(i + 0.5)
-toJSON(i + 1)
-toJSON(i + i)
-toJSON(i - 1)
-toJSON(i - f32)
-toJSON(i .. i)
-toJSON(i .. i32)
-toJSON(i / i64)
-toJSON(i < f32)
-toJSON(i < f64)
-toJSON(i < i)
-toJSON(i < i32)
+toJSON(i * 1.0)
+toJSON(i * f64)
+toJSON(i ** f64)
+toJSON(i + 1 .. 0)
+toJSON(i - i)
+toJSON(i .. 1)
+toJSON(i / f64)
+toJSON(i / i)
+toJSON(i < 1)
+toJSON(i < 1.0)
 toJSON(i <= 1)
-toJSON(i <= f32)
-toJSON(i <= f64)
-toJSON(i <= i)
-toJSON(i <= i32)
-toJSON(i <= i64)
-toJSON(i == 0.5)
-toJSON(i == 1)
-toJSON(i == i32)
+toJSON(i == 0)
+toJSON(i == 1.0)
 toJSON(i == nil)
-toJSON(i > 0.5)
-toJSON(i > i)
-toJSON(i > i32)
-toJSON(i > i64)
-toJSON(i >= f64)
-toJSON(i >= i32)
-toJSON(i ^ i64)
+toJSON(i == nil) <= str
+toJSON(i > f64)
+toJSON(i >= 0)
+toJSON(i >= i)
+toJSON(i ^ 0)
+toJSON(i ^ 1.0)
+toJSON(i in array)
 toJSON(i not in array)
 toJSON(i)
-toJSON(i) matches string("bar")
-toJSON(i32 != i)
-toJSON(i32 != i64)
-toJSON(i32 % 1)
-toJSON(i32 * 0.5)
-toJSON(i32 * i)
-toJSON(i32 * i32)
-toJSON(i32 * i64)
-toJSON(i32 ** f64)
-toJSON(i32 ** i64)
-toJSON(i32 + 0.5)
-toJSON(i32 + 1)
-toJSON(i32 + f64)
-toJSON(i32 .. i)
-toJSON(i32 .. i64)
-toJSON(i32 / 0.5)
-toJSON(i32 / f32)
-toJSON(i32 / f64)
-toJSON(i32 / i64)
-toJSON(i32 < 0.5)
-toJSON(i32 < 1)
-toJSON(i32 < i)
-toJSON(i32 < i32)
-toJSON(i32 <= 0.5)
-toJSON(i32 > f64)
-toJSON(i32 > i)
-toJSON(i32 > i32)
-toJSON(i32 >= f64)
-toJSON(i32 ^ 0.5)
-toJSON(i32 ^ f32)
-toJSON(i32 ^ f64)
-toJSON(i32 ^ i32)
-toJSON(i32 in array)
-toJSON(i32 not in array)
-toJSON(i32)
-toJSON(i32) contains foo.Bar
-toJSON(i64 != 1)
-toJSON(i64 != i)
-toJSON(i64 != i32)
-toJSON(i64 % i32)
-toJSON(i64 * 0.5)
-toJSON(i64 * f64)
-toJSON(i64 ** f64)
-toJSON(i64 ** i)
-toJSON(i64 ** i32)
-toJSON(i64 + 1)
-toJSON(i64 - i32)
-toJSON(i64 .. 1)
-toJSON(i64 .. i32)
-toJSON(i64 / f64)
-toJSON(i64 / i)
-toJSON(i64 / i64)
-toJSON(i64 < 1)
-toJSON(i64 < f64)
-toJSON(i64 < i32)
-toJSON(i64 <= 1)
-toJSON(i64 <= i64)
-toJSON(i64 == 0.5)
-toJSON(i64 > 0.5)
-toJSON(i64 > 1)
-toJSON(i64 > i)
-toJSON(i64 > i32)
-toJSON(i64 > i64)
-toJSON(i64 >= 1)
-toJSON(i64 >= i)
-toJSON(i64 >= i64)
-toJSON(i64 ^ 0.5)
-toJSON(i64 ^ f32)
-toJSON(i64 ^ i32)
-toJSON(i64 in array)
-toJSON(i64)
-toJSON(int(0.5))
+toJSON(i) + str
+toJSON(i) <= str
+toJSON(i) not contains string(0)
+toJSON(if false { add } else { ok })
+toJSON(if false { str } else { str })
+toJSON(if true { ok } else { f64 })
+toJSON(int(0))
 toJSON(int(1))
-toJSON(int(i))
-toJSON(int(i32))
-toJSON(int(i64))
-toJSON(len("bar"))
-toJSON(len(array))
-toJSON(len(greet("foo")))
+toJSON(int(1.0))
+toJSON(int(f64))
+toJSON(keys($env))
+toJSON(last($env))
+toJSON(last(list))
+toJSON(len($env))
 toJSON(len(list))
-toJSON(list != array)
+toJSON(len(str))
+toJSON(let foobar = array; foobar)
+toJSON(let foobar = false; foobar)
+toJSON(list != list)
 toJSON(list != nil)
+toJSON(list == $env)
+toJSON(list == $env.list)
 toJSON(list == array)
 toJSON(list == list)
+toJSON(list == nil)
+toJSON(list | all(false))
+toJSON(list | find(false))
+toJSON(list | find(ok))
+toJSON(list | findIndex(true))
+toJSON(list | map(#))
+toJSON(list | map(#.Bar))
+toJSON(list | map(0))
+toJSON(list | map(true))
+toJSON(list | none(true))
+toJSON(list | reduce(#))
+toJSON(list | reduce(0))
+toJSON(list | reduce(foo))
 toJSON(list)
-toJSON(list[1])
-toJSON(lower("bar"))
+toJSON(list) == str
+toJSON(list) startsWith str
+toJSON(list) | greet()
+toJSON(list?.[0])
+toJSON(list?.[i])
+toJSON(lower(str))
+toJSON(map($env, 0))
+toJSON(map($env, array))
+toJSON(map($env, foo))
+toJSON(map($env, list))
 toJSON(map(array, #))
-toJSON(map(array, -#))
-toJSON(map(array, array))
-toJSON(map(array, false))
-toJSON(map(array, i))
-toJSON(map(array, i64))
-toJSON(map(array, list))
+toJSON(map(array, 0))
 toJSON(map(list, #))
-toJSON(map(list, 0.5))
-toJSON(map(list, 1))
-toJSON(map(list, foo))
-toJSON(map(list, i32))
-toJSON(map(list, i64))
-toJSON(map(list, list))
-toJSON(map(list, ok))
+toJSON(map(list, .Bar))
+toJSON(map(list, f64))
+toJSON(max(0))
 toJSON(max(1))
-toJSON(max(f32))
+toJSON(max(1.0))
+toJSON(max(1.0, 0))
+toJSON(max(1.0, 1))
 toJSON(max(f64))
-toJSON(max(i32))
-toJSON(mean(array))
+toJSON(max(i))
+toJSON(mean(0))
+toJSON(mean(1))
+toJSON(mean(1.0))
+toJSON(mean(f64))
+toJSON(mean(i))
+toJSON(median(0))
+toJSON(median(1))
+toJSON(median(1, 0))
+toJSON(median(1.0))
 toJSON(median(array))
-toJSON(min(0.5))
+toJSON(median(array, array))
+toJSON(median(f64))
+toJSON(median(i))
+toJSON(min(0))
 toJSON(min(1))
-toJSON(min(f32))
+toJSON(min(1.0))
+toJSON(min(array))
 toJSON(min(f64))
-toJSON(min(f64, f64))
-toJSON(min(i))
-toJSON(min(i32))
-toJSON(min(i64))
-toJSON(nil != 0.5)
+toJSON(nil != $env)
+toJSON(nil != 0)
 toJSON(nil != 1)
+toJSON(nil != 1.0)
 toJSON(nil != add)
 toJSON(nil != array)
-toJSON(nil != f32)
 toJSON(nil != false)
-toJSON(nil != foo)
 toJSON(nil != greet)
-toJSON(nil != half)
-toJSON(nil == 0.5)
-toJSON(nil == 1)
-toJSON(nil == div)
-toJSON(nil == f64)
-toJSON(nil == half)
+toJSON(nil != i)
+toJSON(nil != nil)
+toJSON(nil != true)
+toJSON(nil == $env)
+toJSON(nil == 0)
+toJSON(nil == 1.0)
+toJSON(nil == array)
+toJSON(nil == foo)
+toJSON(nil == greet)
 toJSON(nil == i)
-toJSON(nil == i64)
 toJSON(nil == list)
 toJSON(nil == nil)
 toJSON(nil == ok)
 toJSON(nil in array)
-toJSON(nil) + foo.Bar
-toJSON(none(array, ok))
-toJSON(none(array, true))
+toJSON(nil in list)
+toJSON(nil not in $env)
+toJSON(nil not in list)
+toJSON(nil) < str
+toJSON(nil) <= str
+toJSON(nil) not matches foo?.Bar
+toJSON(nil) not startsWith str
+toJSON(nil) | greet()
+toJSON(none($env, true))
 toJSON(none(list, false))
-toJSON(none(list, ok))
-toJSON(not ("foo" not in foo))
-toJSON(not (f32 != 1))
-toJSON(not false)
-toJSON(not ok)
-toJSON(not true)
-toJSON(ok != false)
-toJSON(ok && false)
+toJSON(ok != nil)
+toJSON(ok != ok)
 toJSON(ok && ok)
-toJSON(ok == nil)
-toJSON(ok == ok)
-toJSON(ok ? "foo" : f32)
-toJSON(ok ? 0.5 : f32)
-toJSON(ok ? f64 : 0.5)
-toJSON(ok ? i : false)
-toJSON(ok ? nil : i)
-toJSON(ok ? nil : true)
-toJSON(ok ? true : greet)
-toJSON(ok and ok)
-toJSON(ok or true)
+toJSON(ok && true)
+toJSON(ok == false)
+toJSON(ok ? foo : ok)
+toJSON(ok ?: foo)
+toJSON(ok or false)
 toJSON(ok)
-toJSON(one(array, false))
-toJSON(one(array, true))
-toJSON(reduce(array, #))
-toJSON(reduce(array, 0.5))
-toJSON(reduce(array, array))
-toJSON(reduce(array, foo))
-toJSON(reduce(array, i64))
-toJSON(reduce(array, list))
-toJSON(reduce(array, score(i32 * i64)))
+toJSON(ok) not startsWith str
+toJSON(one($env, true))
+toJSON(one(list, ok))
+toJSON(reduce($env, 1.0, 0))
+toJSON(reduce(array, #index))
+toJSON(reduce(array, 0))
+toJSON(reduce(array, f64))
 toJSON(reduce(list, #))
-toJSON(reduce(list, 1))
-toJSON(reduce(list, f32))
-toJSON(reduce(list, false))
-toJSON(reduce(list, i))
-toJSON(reduce(list, i32))
-toJSON(reduce(list, list))
+toJSON(reduce(list, #.Bar))
+toJSON(reduce(list, 1.0))
+toJSON(reduce(list, foo))
 toJSON(reduce(list, ok))
-toJSON(reduce(list, true))
+toJSON(reverse(array))
+toJSON(reverse(list))
+toJSON(round(0))
 toJSON(round(1))
+toJSON(round(1.0))
 toJSON(round(f64))
-toJSON(round(i32))
-toJSON(score != score)
-toJSON(score(1))
-toJSON(score(1, 1))
-toJSON(score(i))
+toJSON(round(i))
+toJSON(sort($env))
 toJSON(sort(array))
-toJSON(string("bar"))
-toJSON(string(0.5))
+toJSON(sortBy(array, #))
+toJSON(sortBy(array, f64))
+toJSON(sortBy(list, 0))
+toJSON(sortBy(list, i))
+toJSON(str != nil)
+toJSON(str <= str)
+toJSON(str == nil)
+toJSON(str > str)
+toJSON(str contains str)
+toJSON(str in $env)
+toJSON(str in foo)
+toJSON(str not endsWith str)
+toJSON(str not in $env)
+toJSON(str not in [add, array, foo])
+toJSON(str not in foo)
+toJSON(str)
+toJSON(str) | greet()
+toJSON(str[0:])
+toJSON(str[:0])
+toJSON(string($env | one(true)))
+toJSON(string($env))
+toJSON(string($env?.[str]))
+toJSON(string(0))
 toJSON(string(1))
+toJSON(string(1.0))
+toJSON(string(add))
 toJSON(string(array))
-toJSON(string(f32))
 toJSON(string(f64))
 toJSON(string(false))
 toJSON(string(foo))
-toJSON(string(half))
-toJSON(string(i))
-toJSON(string(i32))
-toJSON(string(i64))
 toJSON(string(list))
 toJSON(string(nil))
-toJSON(string(ok))
-toJSON(string(score))
+toJSON(string(str))
 toJSON(string(true))
+toJSON(string(values($env)))
+toJSON(sum($env, 1.0))
 toJSON(sum(array))
-toJSON(take(array, i32))
-toJSON(toBase64("bar"))
-toJSON(toJSON("bar"))
+toJSON(sum(array, #))
+toJSON(toBase64(str))
+toJSON(toJSON(1))
+toJSON(toJSON(1.0))
 toJSON(toJSON(array))
-toJSON(toJSON(f32))
 toJSON(toJSON(f64))
 toJSON(toJSON(false))
 toJSON(toJSON(foo))
 toJSON(toJSON(i))
-toJSON(toJSON(i32))
-toJSON(toJSON(i64))
 toJSON(toJSON(list))
 toJSON(toJSON(nil))
 toJSON(toJSON(ok))
-toJSON(trim("bar"))
-toJSON(trimPrefix("foo"))
-toJSON(trimSuffix("bar"))
-toJSON(true != true)
+toJSON(toJSON(str))
+toJSON(toJSON(true))
+toJSON(trim(str))
+toJSON(trimPrefix($env?.[str]))
+toJSON(trimSuffix($env?.str))
+toJSON(trimSuffix(str))
+toJSON(true != $env)
+toJSON(true != nil)
+toJSON(true && false)
 toJSON(true && ok)
-toJSON(true == ok)
-toJSON(true ? "bar" : "bar")
-toJSON(true ? nil : score)
-toJSON(true and false)
+toJSON(true ? foo : 1.0)
+toJSON(true ? foo : f64)
+toJSON(true ? nil : false)
+toJSON(true ?: nil)
 toJSON(true and true)
-toJSON(true) in foo
-toJSON(type("foo"))
+toJSON(true or $env)
+toJSON(true or ok)
+toJSON(true || ok)
+toJSON(true || true)
+toJSON(true) + str | trimPrefix(str)
+toJSON(true) < str
+toJSON(true) > str
+toJSON(true) not endsWith greet(str)
+toJSON(true) not startsWith str
+toJSON(true) | greet()
+toJSON(true) | repeat(i)
+toJSON(true); f64
+toJSON(type($env))
+toJSON(type(0))
+toJSON(type(1.0))
 toJSON(type(add))
 toJSON(type(array))
-toJSON(type(f32))
 toJSON(type(f64))
 toJSON(type(false))
 toJSON(type(foo))
+toJSON(type(greet))
 toJSON(type(i))
-toJSON(type(i32))
-toJSON(type(i64))
 toJSON(type(list))
+toJSON(type(nil))
 toJSON(type(ok))
-toJSON(type(score))
-toJSON(type(true))
-toJSON(upper("bar"))
-toJSON({"bar": 1, "bar": array})
-toJSON({"bar": 1})
-toJSON({"bar": f64})
-toJSON({"bar": list})
-toJSON({"foo": i})
-toJSON({"foo": nil})
-toPairs(groupBy(array, # / #))
-toPairs(groupBy(array, #))
-toPairs(groupBy(array, 0.5))
-toPairs(groupBy(array, 1))
-toPairs(groupBy(array, false))
-toPairs(groupBy(array, foo))
-toPairs(groupBy(array, i))
-toPairs(groupBy(array, i32))
-toPairs(groupBy(array, ok))
-toPairs(groupBy(array, true))
+toJSON(type(str))
+toJSON(uniq(array))
+toJSON(uniq(list))
+toJSON(upper(str))
+toJSON({foo: 0, foo: f64}.i)
+toJSON({foo: 1, foo: true})
+toJSON({foo: 1.0})
+toJSON({foo: 1.0}.f64)
+toJSON({foo: 1})
+toJSON({foo: false})
+toJSON({foo: foo, foo: str})
+toJSON({foo: foo, foo: true})
+toJSON({foo: foo})
+toJSON({foo: i, foo: foo})
+toJSON({foo: i})
+toJSON({foo: list})
+toJSON({foo: nil, foo: 1.0})
+toJSON({foo: nil, foo: i})
+toJSON({foo: nil})
+toJSON({foo: ok})
+toJSON({foo: str})
+toJSON({foo: true})
+toPairs($env) != array
+toPairs($env) == array
+toPairs($env) == list
+toPairs($env) not in $env?.Bar
+toPairs($env) | concat(array)
+toPairs($env) | findLast(ok)
+toPairs($env) | findLastIndex(true)
+toPairs($env) | groupBy(1.0)
+toPairs($env) | groupBy(i)
+toPairs($env) | map(#)
+toPairs($env) | map(1.0)
+toPairs($env) | one(false)
+toPairs($env) | one(true)
+toPairs($env) | reduce(#)
+toPairs($env) | reduce(1.0)
+toPairs($env) | reduce(add)
+toPairs($env) | reduce(foo)
+toPairs($env) | reduce(greet)
+toPairs($env) | reduce(i)
+toPairs($env)?.[i]
+toPairs(array | groupBy(f64))
+toPairs(array | groupBy(ok))
+toPairs(false ? $env : $env)
+toPairs(groupBy(array, 1.0))
 toPairs(groupBy(list, #))
-toPairs(groupBy(list, 1))
-toPairs(groupBy(list, f32))
-toPairs(groupBy(list, i))
-toPairs(groupBy(list, ok))
-toPairs({"bar": f32})
-toPairs({"foo": i32, "bar": score})
-toPairs({"foo": nil})
-trim("bar") not in foo
-trim(false ? "bar" : "bar")
+toPairs(list | groupBy(#))
+toPairs(list | groupBy(false))
+toPairs(max($env))
+toPairs(min($env))
+toPairs(reduce(array, $env))
+toPairs({foo: $env, foo: true})
+toPairs({foo: $env})
+toPairs({foo: 0})
+toPairs({foo: 1, foo: $env})
+toPairs({foo: 1.0 - 1.0})
+toPairs({foo: 1.0, foo: 1})
+toPairs({foo: 1.0})
+toPairs({foo: 1})
+toPairs({foo: add, foo: add})
+toPairs({foo: add})
+toPairs({foo: array})
+toPairs({foo: f64})
+toPairs({foo: foo, foo: greet})
+toPairs({foo: foo, foo: ok})
+toPairs({foo: foo, foo: str})
+toPairs({foo: foo})
+toPairs({foo: greet})
+toPairs({foo: i})
+toPairs({foo: list})
+toPairs({foo: nil, foo: str})
+toPairs({foo: nil})
+toPairs({foo: ok})
+toPairs({foo: str})
+toPairs({foo: true})
+trim($env.str)
+trim($env?.[str])
+trim($env?.[str], str)
+trim($env?.str)
+trim(false ? foo : str)
 trim(foo.Bar)
 trim(foo.String())
 trim(foo?.Bar)
 trim(foo?.String())
-trim(greet("bar"))
-trim(greet("foo"))
-trim(lower("bar"))
-trim(lower("foo"))
-trim(reduce(list, "bar"))
-trim(string("bar"))
-trim(string(-f64))
-trim(string(0.5))
-trim(string(1))
-trim(string(add))
+trim(greet(foo?.Bar))
+trim(greet(str))
+trim(list | reduce(.Bar))
+trim(lower(str))
+trim(reduce($env, str, greet))
+trim(str | greet())
+trim(str)
+trim(str) >= str
+trim(str) matches str
+trim(str) not endsWith $env?.[str]
+trim(str) not in list?.[i]
+trim(str) not matches foo.String()
+trim(str) | greet()
+trim(str, foo.Bar)
+trim(str, str)
+trim(str, toJSON(ok))
+trim(str[0:])
+trim(string($env))
+trim(string($env.ok))
+trim(string($env?.Bar))
+trim(string(0))
+trim(string(1.0))
 trim(string(array))
-trim(string(f32))
+trim(string(f64))
+trim(string(false))
 trim(string(foo))
-trim(string(i64))
 trim(string(list))
 trim(string(nil))
-trim(toJSON("bar"))
+trim(string(ok))
+trim(string(str))
+trim(string(true))
+trim(string(upper(str)))
+trim(toBase64(str))
+trim(toJSON($env.list))
+trim(toJSON(0))
 trim(toJSON(1))
-trim(toJSON(f32))
-trim(toJSON(false))
+trim(toJSON(1.0))
+trim(toJSON(array))
+trim(toJSON(f64))
 trim(toJSON(foo))
-trim(toJSON(i32))
-trim(toJSON(i64))
+trim(toJSON(list))
+trim(toJSON(nil))
 trim(toJSON(ok))
 trim(toJSON(true))
-trim(trim("bar"))
-trim(trimPrefix("foo"))
-trim(trimSuffix("bar"))
-trim(true ? "foo" : greet)
-trim(type("bar"))
-trim(type("foo"))
-trim(type(0.5))
-trim(type(1))
-trim(type(add))
-trim(type(div))
-trim(type(f32))
-trim(type(f64))
+trim(trim(str))
+trim(trimPrefix(str))
+trim(trimSuffix(str))
+trim(type($env))
+trim(type(1.0))
+trim(type(array))
+trim(type(false))
+trim(type(foo))
 trim(type(greet))
 trim(type(i))
-trim(type(list))
 trim(type(nil))
-trim(type(ok))
-trim(type(score))
-trim(type(true))
-trimPrefix("bar" + "foo")
-trimPrefix("foo" + "bar")
-trimPrefix(false ? 1 : "bar")
+trim(type(str))
+trimPrefix($env.str)
+trimPrefix($env?.[str])
+trimPrefix($env?.str)
+trimPrefix($env?.str, str)
+trimPrefix(false ? greet : str)
 trimPrefix(foo.Bar)
 trimPrefix(foo.String())
 trimPrefix(foo?.Bar)
 trimPrefix(foo?.String())
-trimPrefix(greet("bar"))
-trimPrefix(greet("foo"))
-trimPrefix(greet(type(0.5)))
-trimPrefix(lower("bar"))
-trimPrefix(string("foo"))
-trimPrefix(string(0.5))
+trimPrefix(greet(str))
+trimPrefix(greet(toJSON(false)))
+trimPrefix(lower(str))
+trimPrefix(reduce(list, str))
+trimPrefix(str)
+trimPrefix(str) <= str
+trimPrefix(str, false ? i : str)
+trimPrefix(str, foo?.Bar)
+trimPrefix(str, str)
+trimPrefix(str, type(true))
+trimPrefix(str[0:])
+trimPrefix(str[:i])
+trimPrefix(string($env))
+trimPrefix(string(0))
 trimPrefix(string(1))
-trimPrefix(string(add))
+trimPrefix(string(1.0))
 trimPrefix(string(array))
-trimPrefix(string(div))
-trimPrefix(string(f32))
-trimPrefix(string(f64))
+trimPrefix(string(false))
 trimPrefix(string(foo))
 trimPrefix(string(greet))
-trimPrefix(string(half))
 trimPrefix(string(i))
-trimPrefix(string(i32))
-trimPrefix(string(i64))
+trimPrefix(string(list))
 trimPrefix(string(nil))
-trimPrefix(string(score))
+trimPrefix(string(ok))
+trimPrefix(string(str))
 trimPrefix(string(true))
-trimPrefix(string({"bar": greet}))
-trimPrefix(toBase64("bar"))
-trimPrefix(toJSON("foo"))
-trimPrefix(toJSON(1))
+trimPrefix(toBase64(str))
+trimPrefix(toJSON(0))
+trimPrefix(toJSON(1.0))
 trimPrefix(toJSON(array))
-trimPrefix(toJSON(f32))
+trimPrefix(toJSON(f64))
+trimPrefix(toJSON(false))
 trimPrefix(toJSON(foo))
-trimPrefix(toJSON(i32))
-trimPrefix(toJSON(i64))
-trimPrefix(toJSON(list))
+trimPrefix(toJSON(i))
 trimPrefix(toJSON(nil))
+trimPrefix(toJSON(ok))
+trimPrefix(toJSON(str))
 trimPrefix(toJSON(true))
-trimPrefix(trimPrefix("foo"))
-trimPrefix(type("bar"))
-trimPrefix(type(0.5))
-trimPrefix(type(1))
+trimPrefix(trim(str))
+trimPrefix(trimPrefix(str))
+trimPrefix(trimPrefix(str, str))
+trimPrefix(trimSuffix(str))
+trimPrefix(type($env))
+trimPrefix(type(0))
+trimPrefix(type(1.0))
+trimPrefix(type(add))
 trimPrefix(type(array))
-trimPrefix(type(f32))
 trimPrefix(type(f64))
-trimPrefix(type(greet))
-trimPrefix(type(half))
+trimPrefix(type(false))
+trimPrefix(type(foo))
 trimPrefix(type(i))
-trimPrefix(type(i32))
-trimPrefix(type(i64))
-trimPrefix(type(list))
 trimPrefix(type(nil))
-trimPrefix(type(ok))
 trimPrefix(type(true))
-trimPrefix(upper("bar"))
-trimPrefix(upper("foo"))
-trimSuffix("bar" + "foo")
-trimSuffix("bar") not contains reduce(list, "bar")
-trimSuffix("foo" + "bar")
-trimSuffix(false ? i64 : "foo")
+trimPrefix(upper(str))
+trimSuffix($env.str)
+trimSuffix($env?.[str])
+trimSuffix($env?.str)
+trimSuffix(array | reduce(str, foo))
 trimSuffix(foo.Bar)
 trimSuffix(foo.String())
 trimSuffix(foo?.Bar)
+trimSuffix(foo?.Bar, str)
 trimSuffix(foo?.String())
-trimSuffix(greet("bar"))
-trimSuffix(greet("foo"))
-trimSuffix(lower("bar"))
-trimSuffix(reduce(array, "foo"))
-trimSuffix(reduce(list, #)?.Bar)
-trimSuffix(string("bar"))
-trimSuffix(string("foo"))
-trimSuffix(string(0.5))
+trimSuffix(greet(foo?.String()))
+trimSuffix(greet(str))
+trimSuffix(greet(str), str)
+trimSuffix(greet(string(add)))
+trimSuffix(lower(str))
+trimSuffix(str | greet())
+trimSuffix(str)
+trimSuffix(str) != str
+trimSuffix(str) <= greet(str)
+trimSuffix(str) | greet()
+trimSuffix(str, str)
+trimSuffix(string($env), str)
+trimSuffix(string(0))
+trimSuffix(string(1.0))
 trimSuffix(string(add))
 trimSuffix(string(array))
-trimSuffix(string(div))
 trimSuffix(string(f64))
 trimSuffix(string(false))
 trimSuffix(string(foo))
-trimSuffix(string(half))
+trimSuffix(string(foo.Bar))
+trimSuffix(string(greet))
 trimSuffix(string(i))
-trimSuffix(string(i32))
-trimSuffix(string(i64))
 trimSuffix(string(list))
 trimSuffix(string(nil))
 trimSuffix(string(ok))
-trimSuffix(string(true))
-trimSuffix(toBase64("bar"))
-trimSuffix(toBase64("foo"))
-trimSuffix(toJSON(1 > f64))
-trimSuffix(toJSON(1))
-trimSuffix(toJSON(f32))
+trimSuffix(toBase64($env?.[str]))
+trimSuffix(toBase64($env?.str))
+trimSuffix(toBase64(str))
+trimSuffix(toJSON(1.0))
+trimSuffix(toJSON(array))
 trimSuffix(toJSON(f64))
 trimSuffix(toJSON(false))
 trimSuffix(toJSON(foo))
-trimSuffix(toJSON(i))
-trimSuffix(toJSON(i32))
-trimSuffix(toJSON(i64))
 trimSuffix(toJSON(list))
 trimSuffix(toJSON(nil))
+trimSuffix(toJSON(ok))
+trimSuffix(toJSON(str))
 trimSuffix(toJSON(true))
-trimSuffix(trim("bar"))
-trimSuffix(trim("foo"))
-trimSuffix(trimPrefix("bar"))
-trimSuffix(trimPrefix("foo"))
-trimSuffix(trimSuffix("bar"))
+trimSuffix(trim(str))
+trimSuffix(trimPrefix(str))
+trimSuffix(trimSuffix(str))
+trimSuffix(type($env))
+trimSuffix(type(0))
 trimSuffix(type(1))
+trimSuffix(type(1.0))
 trimSuffix(type(add))
 trimSuffix(type(array))
-trimSuffix(type(div))
-trimSuffix(type(f32))
+trimSuffix(type(false))
 trimSuffix(type(foo))
 trimSuffix(type(greet))
-trimSuffix(type(half))
-trimSuffix(type(i32))
+trimSuffix(type(i))
 trimSuffix(type(list))
 trimSuffix(type(nil))
 trimSuffix(type(ok))
-trimSuffix(upper("foo"))
-true != nil || true == true
-true != ok != ok
-true == ok == ok
-true ? 0.5 : i <= f32
-true ? 1 : foo?.Bar
-true ? 1 : ok or i64 == 0.5
-true ? add : foo?.Bar
-true ? array : 0.5 >= i32
+trimSuffix(type(str))
+trimSuffix(upper(str))
+true != $env || $env >= 1.0
+true != $env.ok
+true != $env?.Bar
+true != $env?.String
+true != $env?.String?.String
+true != $env?.[Bar]
+true != $env?.[String]
+true != $env?.[String]?.Bar
+true != $env?.[foobar?.[greet]]
+true != $env?.[foobar]
+true != $env?.[str]
+true != $env?.ok
+true != false == ok
+true != nil and ok
+true != true ?: foo
+true && $env != list
+true && $env == list?.[i]
+true && $env == str
+true && $env.ok
+true && $env?.Bar
+true && $env?.String
+true && $env?.[Bar]
+true && $env?.[Bar]?.str
+true && $env?.[String]
+true && $env?.[foobar]
+true && $env?.[str]
+true && $env?.foobar
+true && $env?.ok
+true && 0 * i < 1
+true && 1.0 == f64
+true && 1.0 >= f64
+true && false && ok
+true && greet == greet
+true && nil == ok
+true && nil == str
+true && ok ?: str
+true && str startsWith $env?.String
+true == $env == ok
+true == $env || $env != ok
+true == $env || 1.0 >= f64
+true == $env.ok
+true == $env?.Bar
+true == $env?.String
+true == $env?.[Bar]
+true == $env?.[String]
+true == $env?.[foobar]
+true == $env?.[str]
+true == $env?.ok
+true == nil == ok
+true == ok && ok
+true ? $env : $env.f64
+true ? $env : $env.foo
+true ? $env : $env.str
+true ? $env : $env?.Bar
+true ? $env : $env?.[array]
+true ? $env : foo.String
+true ? 0 : $env?.Bar?.greet
+true ? 0 : $env?.String
+true ? 0 : $env?.[Bar]
+true ? 0 : $env[:list(foobar)]
+true ? 1 : $env?.i
+true ? 1 : 1.0 / 1 == f64
+true ? 1.0 : $env.greet
+true ? 1.0 : $env.str
+true ? 1.0 : $env?.[i]
+true ? 1.0 : $env?.[str]
+true ? 1.0 : $env?.ok
+true ? 1.0 : str >= $env?.[Bar]
+true ? add : $env ^ 0 != $env
+true ? add : $env.f64
+true ? add : $env?.Bar
+true ? array : $env?.foo
 true ? array : foo.String
-true ? array : foo?.Bar
-true ? array : foo?.String
-true ? array : i32 ** f64
-true ? div : i64 ** 1 ^ i32
-true ? false : 0.5 > i
-true ? false : foo.Qux
-true ? foo : 0.5 + -1
-true ? foo : foo.Bar
-true ? foo : i64 / f32
-true ? greet : foo.Bar
-true ? greet : ok == ok
-true ? half : 0.5 / i32
-true ? half : foo.String
-true ? i : 1 * i64
-true ? i32 : i32 - f32
-true ? i32 : i32 >= f32
-true ? i64 : f64 != i
-true ? list : f32 != i
-true ? nil : foo.String
-true ? nil : foo?.String
-true ? nil : i32 != f64 + 1
-true ? ok : foo.Qux
-true ? ok : foo?.String
-true ? score : ok or f64 < f32
-true and nil not in list
-true and ok or ok
-true and true || ok
-true or 0.5 not in array
-true || f32 not in groupBy(list, #)
-true || false ? half : half
-type(!false)
-type(!ok)
-type(!true)
-type("bar" != "bar")
-type("bar" < "foo")
-type("bar" <= "bar")
-type("bar" == "foo")
-type("bar" >= "bar")
-type("bar" not endsWith "foo")
-type("bar" startsWith "bar")
-type("bar") startsWith greet("bar")
-type("foo" != nil)
-type("foo" + "bar")
-type("foo" not startsWith "bar")
-type("foo") not in foo
-type(-0.5)
-type(-1)
-type(-f32)
-type(-f64)
-type(-i)
-type(-i32)
-type(-i64)
-type(-int(f64))
-type(0.5 != f64)
-type(0.5 != i32)
-type(0.5 != nil)
-type(0.5 * 0.5)
-type(0.5 * f32)
-type(0.5 * f64)
-type(0.5 * i64)
-type(0.5 ** 0.5)
-type(0.5 ** 1)
-type(0.5 ** f32)
-type(0.5 ** f64)
-type(0.5 ** i)
-type(0.5 ** i32)
-type(0.5 + 0.5)
-type(0.5 + 1)
-type(0.5 + f32)
-type(0.5 + f64)
-type(0.5 + i)
-type(0.5 + i64)
-type(0.5 - 1)
-type(0.5 - f64)
-type(0.5 - i32)
-type(0.5 / 1)
-type(0.5 / f32)
-type(0.5 / i)
-type(0.5 / i32)
-type(0.5 / i64)
-type(0.5 < 1)
-type(0.5 < f32)
-type(0.5 < i32)
-type(0.5 < i64)
-type(0.5 <= 1)
-type(0.5 <= f32)
-type(0.5 <= i64)
-type(0.5 == 0.5)
-type(0.5 == f32)
-type(0.5 == f64)
-type(0.5 == i32)
-type(0.5 > 0.5)
-type(0.5 > f32)
-type(0.5 > i)
-type(0.5 > i32)
-type(0.5 > i64)
-type(0.5 >= 0.5)
-type(0.5 >= i)
-type(0.5 >= i32)
-type(0.5 ^ 0.5)
-type(0.5 ^ i)
-type(0.5 ^ i32)
-type(0.5 ^ i64)
-type(0.5 not in array)
-type(0.5) in foo
-type(1 != i32)
+true ? f64 : $env.add
+true ? f64 : $env?.[i]
+true ? f64 : $env?.greet
+true ? f64 : $env?.i
+true ? f64 : $env[foo?.[String]:]
+true ? false : $env | count($env)
+true ? false : $env?.f64
+true ? false : array != array
+true ? foo : $env.array
+true ? foo : $env.foo
+true ? foo : $env?.[String]
+true ? foo : $env?.[str]
+true ? foo : $env?.array
+true ? foo : $env?.str
+true ? foo : 1.0 + i
+true ? foo : foo?.Bar
+true ? foo : i .. i
+true ? greet : $env | sum(.greet)
+true ? greet : $env.greet
+true ? greet : $env?.[add].foo
+true ? greet : $env?.str
+true ? greet : nil != none($env, #)
+true ? i : $env?.[Bar]
+true ? list : $env?.String
+true ? list : $env?.[greet]
+true ? list : $env?.[ok]
+true ? list : $env?.ok
+true ? list : foo.Bar
+true ? list : foo?.Bar
+true ? list : foo?.String
+true ? nil : $env.str
+true ? nil : $env?.[f64]
+true ? nil : $env?.foo
+true ? nil : foo.Bar
+true ? ok : $env.foo
+true ? ok : $env?.[str]
+true ? ok : foo.String
+true ? str : foo?.Bar
+true ? str : i + i
+true ? true : $env?.String.str
+true ? true : $env?.greet
+true ? true : 1.0 == $env?.Bar
+true ? true : array | date(false, foo)
+true ? true : foo?.Bar
+true ? true : list | sum(#)
+true ?: $env != 0 ^ $env
+true ?: $env % i
+true ?: $env | count(.list)
+true ?: $env | find(#)
+true ?: $env | groupBy(1.0)
+true ?: $env | reduce(#.list)
+true ?: $env | reduce(1.0)
+true ?: $env.add
+true ?: $env.array
+true ?: $env.foo
+true ?: $env.greet
+true ?: $env.i
+true ?: $env.list
+true ?: $env.ok
+true ?: $env.str
+true ?: $env?.[Bar]
+true ?: $env?.[String()]
+true ?: $env?.[array]
+true ?: $env?.[i]
+true ?: $env?.[list]
+true ?: $env?.add
+true ?: $env?.array
+true ?: $env?.f64
+true ?: $env?.foo
+true ?: $env?.greet
+true ?: $env?.ok
+true ?: $env[:foobar]
+true ?: 1.0 == f64
+true ?: foo.Bar
+true ?: foo.String
+true ?: foo?.String
+true ?: nil != f64
+true ?: nil == $env?.str
+true and $env == f64
+true and $env startsWith $env?.Bar
+true and $env.ok
+true and $env?.Bar
+true and $env?.Bar?.Bar
+true and $env?.String
+true and $env?.String?.ok
+true and $env?.[Bar]
+true and $env?.[String]
+true and $env?.[str]
+true and $env?.foobar
+true and $env?.foobar?.array()
+true and $env?.ok
+true and 1 > f64
+true and 1 > i
+true and 1 in sort($env)
+true and 1.0 > f64
+true and array != list
+true and f64 < f64
+true and false || ok
+true and i == i
+true and nil != greet
+true and nil == greet
+true and str != str
+true and true || $env >= $env
+true in $env?.Bar
+true in $env?.String
+true in $env?.[Bar]
+true in $env?.[String]
+true in $env?.[foobar]
+true not in $env?.Bar
+true not in $env?.String
+true not in $env?.[Bar]
+true not in $env?.[Bar]?.String
+true not in $env?.[Bar]?.foo
+true not in $env?.[String]
+true not in $env?.[String]?.[list]
+true not in $env?.[foobar]
+true or $env in str
+true or $env startsWith str
+true or $env.ok
+true or $env?.Bar
+true or $env?.Bar()
+true or $env?.String
+true or $env?.String()
+true or $env?.String?.ok
+true or $env?.[0 | one(1.0)]
+true or $env?.[Bar]
+true or $env?.[String]
+true or $env?.[add]
+true or $env?.[add]?.str
+true or $env?.[array]
+true or $env?.[array]?.greet?.Bar
+true or $env?.[array]?.str()
+true or $env?.[f64]
+true or $env?.[foo]
+true or $env?.[greet]
+true or $env?.[greet]?.[add]
+true or $env?.[i.f64]
+true or $env?.[i]
+true or $env?.[list]
+true or $env?.[ok(foobar)]
+true or $env?.[ok]
+true or $env?.[str.greet]
+true or $env?.[str]
+true or $env?.[str].ok
+true or $env?.foobar
+true or $env?.min(1.0)
+true or $env?.ok
+true or $env?.sortBy(foo, 1.0)?.foo()
+true or $env[:1.0 or list]
+true or $env[:Bar]
+true or $env[:array ?: foo]
+true or $env[:bitnand(greet, foobar)]
+true or $env[:foobar?.String(foobar, foobar)]
+true or $env[:greet]
+true or $env[:true || foobar]
+true or $env[foobar?.[array]:]
+true or 0 < f64
+true or 0 <= $env?.[f64]?.[foo]
+true or 1 > f64
+true or 1 >= $env in $env
+true or 1.0 > i
+true or 1.0 >= f64
+true or f64 + $env?.[add]
+true or false ?: sum($env, .Bar)
+true or false or ok
+true or i not in $env * f64
+true or nil == str in $env
+true or nil not in list
+true or ok and foo == $env?.[String]
+true or str contains $env?.str
+true or str not in foo
+true || $env != 1.0 - $env
+true || $env != i
+true || $env == greet
+true || $env contains str
+true || $env in str
+true || $env not contains $env?.[foo]
+true || $env.ok
+true || $env?.Bar
+true || $env?.Bar()
+true || $env?.Bar?.i()
+true || $env?.String
+true || $env?.String()
+true || $env?.String(false > foobar, array(foobar))
+true || $env?.String(map(foobar | findIndex(#.str), .greet))
+true || $env?.String(reduce(foobar, #.list).i)
+true || $env?.String?.list
+true || $env?.[Bar(nil, 0)]
+true || $env?.[Bar]
+true || $env?.[String]
+true || $env?.[add]
+true || $env?.[add].f64
+true || $env?.[add].f64.list
+true || $env?.[array?.array()]
+true || $env?.[array]
+true || $env?.[f64]
+true || $env?.[foo]
+true || $env?.[foobar | findIndex(add)]
+true || $env?.[foobar]
+true || $env?.[greet]
+true || $env?.[i]
+true || $env?.[list]
+true || $env?.[ok]
+true || $env?.[ok]?.[ok]
+true || $env?.[str]
+true || $env?.foobar
+true || $env?.ok
+true || $env?.reduce($env)
+true || $env[:String == foo]
+true || $env[:foobar]
+true || $env[:ok ? false : add]
+true || $env[:str]
+true || $env[String.Bar(foobar):add()]
+true || $env[duration(String):]
+true || $env[false | bitand(str):]
+true || $env[foobar:]
+true || $env[foobar?.[str]:str()]
+true || $env[list endsWith str:foobar]
+true || 0 != $env?.f64
+true || 0 <= $env?.String(str)
+true || 1.0 < find($env, #)
+true || 1.0 <= i
+true || 1.0 > f64 == true
+true || add != add
+true || i > f64
+true || nil != f64
+true || nil == foo
+true || nil == ok
+type($env != $env)
+type($env != 0)
+type($env != add)
+type($env != f64)
+type($env != foo)
+type($env != greet)
+type($env != list)
+type($env != nil)
+type($env && true)
+type($env == $env)
+type($env == 1)
+type($env == 1.0)
+type($env == add)
+type($env == f64)
+type($env == false)
+type($env == foo)
+type($env == nil)
+type($env and true)
+type($env in array)
+type($env in list)
+type($env not in array)
+type($env not in list)
+type($env or true)
+type($env | all(true))
+type($env | any(ok))
+type($env | any(true))
+type($env | count(ok))
+type($env | findLastIndex(ok))
+type($env | map(#index))
+type($env | map(foo))
+type($env | none(true))
+type($env | one(false))
+type($env | sum(0))
+type($env | sum(1.0))
+type($env || false)
+type($env) != foo?.Bar
+type($env) not contains toJSON(true)
+type($env) not in foo
+type($env) not matches str
+type($env) | greet()
+type($env.add)
+type($env.array)
+type($env.f64)
+type($env.foo)
+type($env.greet)
+type($env.i)
+type($env.list)
+type($env.ok)
+type($env.str)
+type($env?.$env)
+type($env?.Bar)
+type($env?.String)
+type($env?.String?.add)
+type($env?.[Bar])
+type($env?.[Bar]) | trimPrefix(str)
+type($env?.[String])
+type($env?.[String]?.[i])
+type($env?.[String]?.i)
+type($env?.[foobar])
+type($env?.[nil])
+type($env?.[str])
+type($env?.add)
+type($env?.add) | greet()
+type($env?.array)
+type($env?.f64)
+type($env?.foo)
+type($env?.foobar)
+type($env?.greet)
+type($env?.i)
+type($env?.list)
+type($env?.nil)
+type($env?.ok)
+type($env?.str)
+type($env?.true)
+type(0 != $env)
+type(0 != 0)
+type(0 != 1.0)
+type(0 != f64)
+type(0 != i)
+type(0 != nil)
+type(0 % i)
+type(0 * 0)
+type(0 + 0)
+type(0 + 1)
+type(0 + i)
+type(0 - 1)
+type(0 - f64)
+type(0 .. 0)
+type(0 .. 1)
+type(0 .. i)
+type(0 / 1)
+type(0 / 1.0)
+type(0 / i)
+type(0 < 1.0)
+type(0 <= 1)
+type(0 <= i)
+type(0 == 1)
+type(0 == 1.0)
+type(0 == i)
+type(0 == nil)
+type(0 > 1.0)
+type(0 ^ 1.0)
+type(0 ^ i)
+type(0 | median(1, 1.0))
+type(0 | min(0))
+type(0 | min(i))
+type(0) != str
+type(0) in foo
+type(0) not startsWith str
+type(0)[i:]
+type(0..i)
+type(1 != $env)
+type(1 != f64)
 type(1 != nil)
 type(1 % 1)
-type(1 % i)
-type(1 * 0.5)
-type(1 * f32)
+type(1 * 0)
+type(1 * 1.0)
+type(1 * f64)
 type(1 * i)
-type(1 * i32)
-type(1 ** 0.5)
+type(1 ** 1.0)
 type(1 ** f64)
-type(1 ** i)
-type(1 ** i64)
-type(1 + 0.5)
+type(1 + 0)
 type(1 + 1)
-type(1 + f32)
-type(1 + i64)
-type(1 - 0.5)
-type(1 - 1)
-type(1 - i64)
-type(1 .. 1)
-type(1 .. i64)
-type(1 / f64)
+type(1 + 1.0)
+type(1 .. 0)
+type(1 / 1)
 type(1 / i)
-type(1 < i32)
-type(1 < i64)
-type(1 <= 0.5)
+type(1 <= 0)
 type(1 <= 1)
-type(1 <= f64)
+type(1 <= 1.0)
 type(1 <= i)
-type(1 == f32)
-type(1 == f64)
 type(1 == i)
-type(1 == i32)
-type(1 == i64)
-type(1 > i)
-type(1 >= 0.5)
+type(1 == nil)
+type(1 > 0)
+type(1 > 1)
+type(1 > 1.0)
+type(1 > f64)
+type(1 >= 0)
+type(1 >= 1.0)
 type(1 >= i)
-type(1 >= i64)
+type(1 ^ 0)
 type(1 ^ 1)
-type(1 ^ i)
-type(1 ^ i64)
-type(1) endsWith foo.Bar
-type(1) in reduce(list, #)
-type(1) not endsWith "bar" ? i64 : nil
-type(1) not startsWith string(0.5)
-type([div])
-type([f32])
-type(abs(0.5))
-type(abs(f32))
-type(abs(f64))
+type(1 ^ 1.0)
+type(1 in array)
+type(1 not in array)
+type(1) not in foo
+type(1) startsWith reduce(list, #.Bar)
+type(1) | greet()
+type(1.0 != $env)
+type(1.0 != $env?.i)
+type(1.0 != 1)
+type(1.0 != 1.0)
+type(1.0 != f64)
+type(1.0 != i)
+type(1.0 != nil)
+type(1.0 * 0)
+type(1.0 * 1)
+type(1.0 * 1.0)
+type(1.0 * f64)
+type(1.0 * i)
+type(1.0 ** 1)
+type(1.0 ** 1.0)
+type(1.0 ** f64)
+type(1.0 + 0)
+type(1.0 + 1)
+type(1.0 + 1.0)
+type(1.0 + i)
+type(1.0 - 0)
+type(1.0 - 1.0)
+type(1.0 - f64)
+type(1.0 - i)
+type(1.0 / 1)
+type(1.0 / 1.0)
+type(1.0 / f64)
+type(1.0 < 0)
+type(1.0 < 1)
+type(1.0 < 1.0)
+type(1.0 < i)
+type(1.0 <= 0)
+type(1.0 <= 1.0)
+type(1.0 == $env)
+type(1.0 == 1.0)
+type(1.0 == f64)
+type(1.0 == i)
+type(1.0 == nil)
+type(1.0 > 1.0)
+type(1.0 > i)
+type(1.0 >= 1)
+type(1.0 >= 1.0)
+type(1.0 >= i)
+type(1.0 ^ 0)
+type(1.0 ^ 1.0)
+type(1.0 ^ f64)
+type(1.0 | max(0))
+type(1.0 | mean(1.0))
+type(1.0)
+type(1.0) + str
+type(1.0) >= str
+type(1.0) contains str
+type(1.0) not endsWith foo.Bar
+type(1.0) not endsWith str
+type(1.0) not matches str
+type(1.0) startsWith str
+type(1.0) | greet()
+type(1.0)[:i]
+type([$env])
+type([0])
+type([1.0, foo])
+type([1.0])
+type([1])
+type([add])
+type([array])
+type([f64])
+type([false])
+type([foo, i])
+type([foo])
+type([greet])
+type([i])
+type([list, 1.0, true])
+type([list, ok])
+type([list])
+type([nil, foo])
+type([nil])
+type([ok, f64])
+type([ok])
+type([str])
+type([true, foo])
+type([true])
+type(abs(0))
+type(abs(1))
+type(abs(1.0))
 type(abs(i))
-type(abs(i32))
-type(abs(i64))
+type(add != $env)
+type(add != add)
+type(add == nil)
+type(add(i, 0))
 type(add)
-type(all(array, ok))
-type(all(list, ok))
+type(add) != str
+type(add) == foo.Bar
+type(add) matches str
+type(add) not matches str
+type(add) | greet()
+type(add)[:]
+type(all(array, false))
 type(all(list, true))
-type(any(array, false))
+type(any(array, 1 > #))
 type(any(array, ok))
-type(any(list, false))
-type(array != list)
-type(array != nil)
-type(array == array)
+type(array == $env)
+type(array == nil)
+type(array | find(false))
+type(array | findIndex(false))
+type(array | findIndex(ok))
+type(array | groupBy(ok))
+type(array | min(array))
+type(array | none(false))
+type(array | none(ok))
+type(array | reduce(#))
+type(array | reduce(#, foo))
+type(array | reduce(1.0, list))
+type(array | reduce(1.0, ok))
+type(array | reduce(false))
+type(array | reduce(foo))
+type(array | sortBy(#))
+type(array | sum(i))
 type(array)
-type(array) >= trimPrefix("foo")
-type(array[1])
-type(array[i32])
-type(array[i])
-type(bitand(1, i))
+type(array) < str
+type(array) == str
+type(array) endsWith $env?.[Bar]?.[str]
+type(array) in foo
+type(array) not in foo
+type(array) | repeat(1)
+type(array?.[i])
+type(array[1:])
+type(array[:0])
+type(bitnand(i, 0))
+type(bitnot(0))
+type(bitnot(1))
 type(bitnot(i))
-type(bitnot(i32))
-type(bitnot(i64))
-type(bitxor(i64, 1))
-type(ceil(0.5))
-type(ceil(f32))
+type(bitshr(i, 1))
+type(bitxor(i, i))
+type(ceil(0))
+type(ceil(1))
+type(ceil(1.0))
 type(ceil(f64))
-type(ceil(i64))
-type(count(array, true))
-type(div != div)
-type(div == div)
-type(div)
-type(f32 != 0.5)
-type(f32 != 1)
-type(f32 * 1)
-type(f32 * i)
-type(f32 * i32)
-type(f32 ** f32)
-type(f32 + 1)
-type(f32 + i)
-type(f32 - f32)
-type(f32 - i32)
-type(f32 / 1)
-type(f32 / f32)
-type(f32 < 1)
-type(f32 < f32)
-type(f32 <= f64)
-type(f32 == 0.5)
-type(f32 == f64)
-type(f32 == i)
-type(f32 == i32)
-type(f32 == i64)
-type(f32 > 1)
-type(f32 >= f32)
-type(f32 >= i)
-type(f32 >= i32)
-type(f32 ^ i64)
-type(f32 not in array)
-type(f32)
-type(f64 != 0.5)
-type(f64 != i)
-type(f64 * 0.5)
-type(f64 * 1)
-type(f64 * f32)
-type(f64 ** 1)
-type(f64 + f32)
-type(f64 + i32)
-type(f64 - 0.5)
-type(f64 - 1)
-type(f64 - f64)
-type(f64 - i)
-type(f64 / 1)
-type(f64 / f32)
-type(f64 / i64)
-type(f64 < 0.5)
-type(f64 < f32)
-type(f64 < f64)
-type(f64 < i32)
-type(f64 < i64)
-type(f64 <= 0.5)
-type(f64 <= f64)
-type(f64 <= i64)
-type(f64 == 0.5)
-type(f64 == f32)
-type(f64 == i64)
+type(ceil(i))
+type(concat(array))
+type(concat(list))
+type(count($env, ok))
+type(count([true]))
+type(f64 != 1)
+type(f64 != 1.0)
+type(f64 * 1.0)
+type(f64 * f64)
+type(f64 * i)
+type(f64 ** 1.0)
+type(f64 ** i)
+type(f64 + 1)
+type(f64 + 1.0)
+type(f64 + i)
+type(f64 - 0)
+type(f64 / 1.0)
+type(f64 < 1.0)
+type(f64 <= 1)
+type(f64 == 0)
+type(f64 == f64)
 type(f64 == nil)
+type(f64 > 1)
+type(f64 > 1.0)
+type(f64 > f64)
 type(f64 > i)
-type(f64 > i32)
-type(f64 >= 0.5)
-type(f64 >= i)
-type(f64 ^ 0.5)
+type(f64 >= 1.0)
+type(f64 ^ 1)
+type(f64 ^ 1.0)
+type(f64 ^ i)
 type(f64 not in array)
 type(f64)
-type(false != nil)
+type(f64) > str
+type(f64) not startsWith str
+type(false != false)
 type(false != ok)
-type(false && true)
-type(false ? "bar" : score)
-type(false ? div : f64)
-type(false ? half : greet)
-type(false ? true : foo)
-type(false || true)
-type(false) startsWith "bar" ? ok : f32
+type(false && $env)
+type(false == $env)
+type(false == false)
+type(false ? f64 : 1)
+type(false ? foo : add)
+type(false ? foo : list)
+type(false ? list : foo)
+type(false or true)
+type(false || $env)
+type(false || false)
+type(false) == str
+type(false) > str
+type(filter($env, false))
 type(find(array, false))
-type(find(array, true))
-type(find(list, true))
-type(findIndex(array, ok))
-type(findLast(array, false))
-type(findLast(array, ok))
-type(findLastIndex(array, false))
-type(findLastIndex(list, false))
-type(findLastIndex(list, ok))
-type(findLastIndex(list, true))
+type(findIndex($env, ok))
+type(findLast($env, false))
+type(findLast(list, ok))
+type(first($env))
+type(first(array))
 type(first(list))
-type(float(f32))
-type(float(i32))
-type(floor(0.5))
-type(floor(1))
+type(flatten(list))
+type(float(0))
+type(float(1))
+type(float(1.0))
+type(float(f64))
+type(float(i))
+type(floor(0))
+type(floor(1.0))
 type(floor(f64))
-type(floor(i64))
+type(foo != $env)
+type(foo != $env?.foo)
 type(foo != foo)
 type(foo != nil)
+type(foo == $env)
+type(foo == foo)
+type(foo == nil)
 type(foo in list)
 type(foo)
+type(foo) != $env?.foobar
+type(foo) <= str
+type(foo) matches $env?.String?.[greet]
+type(foo) matches str
+type(foo) not endsWith str
+type(foo) not in $env and false
+type(foo) not in foo and $env
+type(foo) not startsWith str
+type(foo) | greet()
+type(foo)[:]
 type(foo.Bar)
-type(foo.Qux)
 type(foo.String())
 type(foo.String)
 type(foo?.Bar)
-type(foo?.Qux)
 type(foo?.String())
 type(foo?.String)
-type(get(array, 1))
-type(get(array, i64))
-type(get(list, 1))
-type(get(list, i))
-type(get(list, i32))
-type(get(list, i64))
-type(greet("bar"))
-type(greet("foo"))
+type(greet != $env)
+type(greet != greet)
+type(greet == $env)
+type(greet == greet)
+type(greet == nil)
+type(greet(str))
 type(greet)
 type(groupBy(array, #))
-type(groupBy(array, #).score)
-type(groupBy(array, 0.5))
-type(groupBy(array, false)?.add)
-type(groupBy(array, i))
-type(groupBy(array, i32))
-type(groupBy(array, i64))
-type(groupBy(list, "bar"))
+type(groupBy(array, 0))
+type(groupBy(array, 1.0))
+type(groupBy(array, false))
+type(groupBy(array, foo))
 type(groupBy(list, #))
-type(groupBy(list, #)?.Bar)
-type(groupBy(list, 1))
-type(groupBy(list, i64))
-type(groupBy(list, true))
-type(half(0.5))
-type(half(1))
-type(half(f64))
-type(half)
-type(half) not in foo
-type(i % 1)
-type(i % i32)
-type(i * 0.5)
-type(i * i32)
-type(i ** f32)
-type(i ** f64)
-type(i ** i)
-type(i + i32)
-type(i - 0.5)
+type(groupBy(list, .Bar))
+type(groupBy(list, 1.0))
+type(groupBy(list, false))
+type(i != $env)
+type(i != array?.[i])
+type(i != i)
+type(i != nil)
+type(i * 0)
+type(i * 1)
+type(i * f64)
+type(i ** 1.0)
+type(i + 0)
+type(i + 1)
+type(i + 1.0)
+type(i + f64)
+type(i + i)
+type(i - 0)
 type(i - 1)
-type(i - i)
-type(i - i64)
+type(i .. 0)
 type(i .. i)
-type(i / 0.5)
-type(i / i32)
-type(i < 0.5)
-type(i < 1)
-type(i <= 0.5)
+type(i / 1.0)
+type(i < i)
+type(i <= 0)
 type(i <= 1)
-type(i == 1)
-type(i > 0.5)
-type(i > 1)
-type(i > f32)
-type(i > i64)
-type(i >= i32)
-type(i ^ 1)
+type(i <= 1.0 + 1.0 == $env)
+type(i <= 1.0)
+type(i <= f64)
+type(i <= i)
+type(i == $env)
+type(i == 1.0)
+type(i == nil)
+type(i > f64)
+type(i >= f64)
 type(i ^ i)
-type(i ^ i32)
-type(i ^ i64)
+type(i | bitushr(i))
 type(i)
-type(i) + foo.Bar
-type(i32 != 1)
-type(i32 != f64)
-type(i32 * 0.5)
-type(i32 * i)
-type(i32 ** 0.5)
-type(i32 ** f64)
-type(i32 ** i)
-type(i32 + 1)
-type(i32 - 1)
-type(i32 .. i32)
-type(i32 / 0.5)
-type(i32 / f64)
-type(i32 < 0.5)
-type(i32 <= 0.5)
-type(i32 <= f64)
-type(i32 <= i32)
-type(i32 == 1)
-type(i32 == nil)
-type(i32 > 0.5)
-type(i32 > f64)
-type(i32 > i64)
-type(i32 >= 1)
-type(i32 >= f32)
-type(i32 >= i64)
-type(i32 ^ 1)
-type(i32 ^ f32)
-type(i32 ^ f64)
-type(i32 ^ i)
-type(i32 not in array)
-type(i32)
-type(i32) in foo
-type(i32) not matches trim("foo")
-type(i64 != 1)
-type(i64 != f64)
-type(i64 % 1)
-type(i64 * f32)
-type(i64 * i64)
-type(i64 ** 0.5)
-type(i64 ** f64)
-type(i64 ** i32)
-type(i64 + 0.5)
-type(i64 + 1)
-type(i64 + i64)
-type(i64 - 0.5)
-type(i64 - f32)
-type(i64 - f64)
-type(i64 - i32)
-type(i64 .. i32)
-type(i64 / 0.5)
-type(i64 / f32)
-type(i64 / i64)
-type(i64 < 0.5)
-type(i64 < f32)
-type(i64 < f64)
-type(i64 < i)
-type(i64 < i64)
-type(i64 <= 0.5)
-type(i64 <= 1)
-type(i64 <= f32)
-type(i64 <= i)
-type(i64 == 1)
-type(i64 == f64)
-type(i64 > i64)
-type(i64 >= 1)
-type(i64 ^ f64)
-type(i64 ^ i)
-type(i64 not in array)
-type(i64)
-type(int(0.5))
-type(int(f32))
+type(i) <= str
+type(i) | splitAfter(str)
+type(if false { nil } else { foo })
+type(if false { nil } else { nil })
+type(if false { true } else { array })
+type(if ok { 1 } else { false })
+type(if ok { foo } else { foo })
+type(if ok { nil } else { str })
+type(int(1))
+type(int(1.0))
 type(int(f64))
 type(int(i))
-type(int(i32))
-type(int(i64))
+type(keys($env))
+type(last($env))
+type(last($env)?.String)
+type(last($env?.Bar))
 type(last(array))
-type(last(list))
+type(len($env))
 type(len(array))
 type(len(list))
+type(len(str))
+type(let foobar = 1; foobar)
+type(list != $env)
 type(list != nil)
-type(list == array)
+type(list == $env)
 type(list == nil)
+type(list | groupBy(#))
+type(list | groupBy(0))
+type(list | map(#))
+type(list | map(#index))
+type(list | map(0))
+type(list | map(greet))
+type(list | one(false))
+type(list | one(ok))
+type(list | reduce(#, nil))
+type(list | reduce(#.Bar))
+type(list | reduce(i))
+type(list | reduce(ok, add))
 type(list)
-type(list[1])
-type(list[i32])
-type(list[i64])
-type(list[i])
-type(map(array, "bar"))
-type(map(array, "foo"))
-type(map(array, #))
+type(list) == str
+type(list) >= string(0)
+type(list) | hasSuffix(str)
+type(list?.[i])
+type(list[0:])
+type(lower(str))
+type(map($env, $env))
+type(map($env, 1))
+type(map($env, add))
+type(map($env, f64))
+type(map($env, foo))
+type(map($env, i))
+type(map(array, 0))
 type(map(array, 1))
-type(map(array, div))
-type(map(array, f32))
-type(map(array, foo))
-type(map(array, greet))
-type(map(array, ok))
-type(map(array, true))
-type(map(list, "bar"))
+type(map(array, false))
 type(map(list, #))
-type(map(list, array))
-type(map(list, greet))
-type(map(list, i64))
-type(map(list, list))
-type(map(list, ok))
-type(max(0.5))
-type(max(0.5, f64))
+type(map(list, 1.0))
+type(map(list, foo))
+type(max($env))
+type(max(0))
+type(max(0, array))
 type(max(1))
-type(max(1, i32))
+type(max(1.0))
+type(max(array))
 type(max(f64))
-type(max(i64))
+type(mean(0))
+type(mean(1))
+type(mean(1.0))
+type(mean(array))
+type(mean(array, 1.0))
+type(mean(i))
+type(median($env.i))
+type(median(0))
+type(median(0, 1))
+type(median(1.0))
 type(median(array))
+type(median(i))
+type(median(min(f64)))
+type(min($env))
+type(min(0))
 type(min(1))
-type(min(f32))
+type(min(1.0))
+type(min(array))
+type(min(f64))
 type(min(i))
-type(min(i32))
-type(min(i64))
-type(nil != "foo")
-type(nil != 0.5)
+type(nil != $env)
+type(nil != 0)
 type(nil != 1)
+type(nil != 1.0)
+type(nil != add)
+type(nil != array)
+type(nil != false)
+type(nil != foo)
 type(nil != greet)
-type(nil != half)
-type(nil != i32)
-type(nil != i64)
+type(nil != i)
+type(nil != list)
 type(nil != nil)
-type(nil != score)
-type(nil == "foo")
+type(nil != str)
+type(nil == $env)
+type(nil == 0)
+type(nil == 1)
+type(nil == 1.0)
+type(nil == add)
 type(nil == array)
-type(nil == f32)
+type(nil == f64)
 type(nil == false)
 type(nil == foo)
-type(nil == greet)
+type(nil == list)
 type(nil == nil)
-type(nil == score)
+type(nil == ok)
+type(nil in $env)
 type(nil in array)
 type(nil in list)
-type(nil not in array)
-type(nil not in list)
+type(nil not in $env)
+type(nil) <= str
+type(nil) matches str
+type(nil) matches string(foo)
+type(nil) not in {foo: false}
+type(nil) | greet()
+type(nil)[:]
+type(none(list, false))
 type(none(list, ok))
-type(none(list, true))
-type(not (f64 <= i))
-type(not false)
-type(not ok)
-type(not true)
-type(ok != false)
 type(ok != nil)
-type(ok != true)
-type(ok && false)
+type(ok == $env)
 type(ok == nil)
-type(ok ? "bar" : half)
-type(ok ? 1 : "bar")
-type(ok ? array : i64)
-type(ok ? array : score)
-type(ok ? i : "bar")
-type(ok ? i : nil)
-type(ok ? nil : 0.5)
-type(ok ? nil : div)
-type(ok and ok)
+type(ok == true)
+type(ok ? 1 : 1.0)
+type(ok ? list : foo)
+type(ok ?: array)
+type(ok ?: greet)
+type(ok and $env)
+type(ok or $env)
 type(ok or false)
+type(ok or true)
 type(ok || false)
+type(ok || ok)
+type(ok || true)
 type(ok)
-type(one(array, false))
-type(one(array, true))
-type(one(list, false))
-type(one(list, true))
-type(reduce(array, "bar"))
+type(ok) contains str
+type(ok) in {foo: true}
+type(ok) | greet()
+type(one($env, false))
+type(one($env, true))
 type(reduce(array, #))
-type(reduce(array, 1))
+type(reduce(array, $env))
+type(reduce(array, add))
+type(reduce(array, f64))
 type(reduce(array, foo))
-type(reduce(array, greet))
-type(reduce(array, i))
 type(reduce(array, ok))
-type(reduce(list, "foo"))
 type(reduce(list, #))
-type(reduce(list, array))
-type(reduce(list, i64))
-type(reduce(list, ok))
-type(round(0.5))
+type(reduce(list, #.String))
+type(reduce(list, #index))
+type(reduce(list, 0))
+type(reduce(list, add))
+type(reverse(array))
+type(reverse(list))
+type(round(0))
 type(round(1))
+type(round(1.0))
 type(round(f64))
-type(round(i))
-type(round(i64))
-type(score != score)
-type(score == nil)
-type(score(1))
-type(score(1, 1))
-type(score(i))
-type(score)
-type(sort(array))
-type(string(0.5))
+type(sort($env))
+type(sortBy(array, #))
+type(sortBy(array, 0))
+type(sortBy(array, 1.0))
+type(sortBy(list, i))
+type(str <= str)
+type(str == $env)
+type(str > str)
+type(str >= str)
+type(str in $env)
+type(str in foo)
+type(str not in $env)
+type(str not in foo)
+type(str)
+type(str) <= trim(str)
+type(str) == str
+type(str) >= str
+type(str) contains $env?.String
+type(str[:])
+type(str[i:])
+type(string($env))
+type(string(0))
 type(string(1))
+type(string(1.0))
 type(string(add))
-type(string(div))
-type(string(f32))
+type(string(array))
 type(string(f64))
+type(string(false != nil))
 type(string(false))
+type(string(foo))
 type(string(greet))
-type(string(i32))
-type(string(i64))
 type(string(list))
-type(string(nil))
-type(string(ok))
-type(string(score))
-type(toBase64("bar"))
-type(toJSON("bar"))
-type(toJSON("foo"))
-type(toJSON(0.5))
+type(string(map($env, 1)))
+type(string(true))
+type(sum(array))
+type(sum(array, #))
+type(sum(array, 1))
+type(sum(list, 1.0))
+type(toJSON(0))
 type(toJSON(1))
+type(toJSON(1.0))
 type(toJSON(array))
+type(toJSON(f64))
 type(toJSON(false))
+type(toJSON(foo))
 type(toJSON(i))
-type(toJSON(i32))
-type(toJSON(i64))
 type(toJSON(list))
+type(toJSON(median(i)))
 type(toJSON(nil))
-type(trim("foo"))
-type(trimPrefix("bar"))
+type(toJSON(ok))
+type(toJSON(str))
+type(toJSON(true))
+type(toPairs($env))
+type(trimPrefix(str))
+type(trimSuffix(str))
 type(true != nil)
+type(true && $env)
 type(true == false)
-type(true == nil)
-type(true ? array : false)
-type(true ? array : half)
-type(true ? div : add)
-type(true ? f64 : i32)
-type(true ? ok : 1)
-type(true and false)
-type(true and true)
-type(true or true)
-type(true || ok)
+type(true == ok)
+type(true ? $env : add)
+type(true or false)
+type(true or ok)
+type(true || false)
 type(true || true)
-type(true) in foo
-type(true) matches string(list)
-type(type(0.5))
+type(true) <= str
+type(true) | greet()
+type(type($env))
+type(type(0))
 type(type(1))
+type(type(1.0))
 type(type(add))
-type(type(div))
+type(type(array))
+type(type(f64))
+type(type(false))
 type(type(foo))
 type(type(greet))
-type(type(half))
 type(type(i))
-type(type(i32))
-type(type(i64))
-type(type(nil))
-type(type(ok))
+type(type(list))
+type(type(str))
 type(type(true))
-type(upper("foo"))
-type({"bar": 1})
-type({"bar": array})
-type({"foo": "foo"})
-type({"foo": f64})
-type({"foo": false, "foo": foo}.Bar)
-upper("bar") not in foo
-upper("foo" + "foo")
-upper("foo") == toJSON("bar")
+type(uniq(array))
+type(uniq(list))
+type(upper(str))
+type(values($env))
+type({foo: $env})
+type({foo: 0, foo: 1.0})
+type({foo: 0, foo: false})
+type({foo: 0, foo: foo})
+type({foo: 0, foo: i})
+type({foo: 0})
+type({foo: 0}.greet)
+type({foo: 1, foo: str})
+type({foo: 1.0, foo: greet, foo: ok})
+type({foo: 1.0})
+type({foo: 1})
+type({foo: add})
+type({foo: array, foo: array | reduce(#, i)})
+type({foo: array, foo: foo})
+type({foo: array})
+type({foo: f64, foo: add})
+type({foo: f64})
+type({foo: false, foo: foo})
+type({foo: false})
+type({foo: foo, foo: 1})
+type({foo: foo, foo: foo})
+type({foo: foo, foo: i})
+type({foo: foo})
+type({foo: i, foo: ok})
+type({foo: i})
+type({foo: list})
+type({foo: nil})
+type({foo: ok, foo: 0})
+type({foo: ok})
+type({foo: str})
+type({foo: true})
+uniq($env | filter(false))
+uniq($env | map(#index))
+uniq($env | map(0))
+uniq($env | map(1.0))
+uniq($env | map(f64))
+uniq($env | map(ok))
+uniq($env | map(str))
+uniq($env.array)
+uniq($env.list)
+uniq($env?.array)
+uniq($env?.list)
+uniq($env?.list[i:])
+uniq(0 .. 0)
+uniq(0 .. i)
+uniq(1 .. 0)
+uniq([$env])
+uniq([0])
+uniq([1.0, ok])
+uniq([1.0])
+uniq([1])
+uniq([add, 1.0])
+uniq([add])
+uniq([array, true])
+uniq([array])
+uniq([f64])
+uniq([false, str])
+uniq([false, true])
+uniq([false])
+uniq([foo, foo])
+uniq([foo])
+uniq([i])
+uniq([list])
+uniq([nil])
+uniq([ok])
+uniq([str, 1.0])
+uniq([str, true])
+uniq([str])
+uniq([true])
+uniq(array | filter(ok))
+uniq(array | map(#))
+uniq(array | sortBy(1))
+uniq(array)
+uniq(array) == array
+uniq(array) | count(false)
+uniq(array) | groupBy(1)
+uniq(array) | groupBy(1.0)
+uniq(array) | groupBy(ok)
+uniq(array) | map(1)
+uniq(array) | map(true)
+uniq(array) | min(i)
+uniq(array) | reduce(1.0)
+uniq(array) | reduce(false)
+uniq(array) | reduce(greet)
+uniq(array) | reduce(i)
+uniq(array) | sortBy(#)
+uniq(array) | sortBy(1)
+uniq(array); str
+uniq(array)?.[i]
+uniq(array)[:i]
+uniq(array)[i:]
+uniq(array[1:i])
+uniq(array[:1])
+uniq(concat(list))
+uniq(false ? 0 : array)
+uniq(filter(array, true))
+uniq(filter(list, false))
+uniq(flatten(array))
+uniq(keys($env))
+uniq(list | map(1.0))
+uniq(list | map(add))
+uniq(list | sortBy(#.Bar))
+uniq(list | sortBy(1.0))
+uniq(list)
+uniq(list) != array
+uniq(list) | all(false)
+uniq(list) | all(true)
+uniq(list) | findIndex(false)
+uniq(list) | groupBy(ok)
+uniq(list) | map(#)
+uniq(list) | map(.String)
+uniq(list) | map(greet)
+uniq(list) | reduce(ok)
+uniq(list) | reduce(true, 1.0)
+uniq(list) | sortBy(0)
+uniq(list)?.[i]
+uniq(list)[$env.i:]
+uniq(list[i:])
+uniq(map($env, array))
+uniq(map($env, list))
+uniq(map($env, ok))
+uniq(map($env, str))
+uniq(map($env, true))
+uniq(map(array, #))
+uniq(map(array, 1.0))
+uniq(map(array, greet))
+uniq(map(array, ok))
+uniq(map(list, #))
+uniq(reverse(array))
+uniq(reverse(list))
+uniq(sort($env))
+uniq(sort(array))
+uniq(sortBy(array, #))
+uniq(sortBy(array, 0))
+uniq(sortBy(list, 1.0))
+uniq(toPairs($env))
+uniq(uniq(array))
+uniq(values($env))
+upper($env | reduce(str, nil))
+upper($env.str)
+upper($env?.[str])
+upper($env?.str)
+upper(array | reduce(str, list))
 upper(foo.Bar)
 upper(foo.String())
 upper(foo?.Bar)
 upper(foo?.String())
-upper(greet("bar"))
-upper(greet("foo"))
-upper(last(list).Bar)
-upper(lower("bar"))
-upper(lower("foo"))
-upper(reduce(list, #)?.Bar)
-upper(string("foo"))
-upper(string(0.5))
+upper(greet(str))
+upper(list | reduce(#.Bar))
+upper(lower(str))
+upper(str)
+upper(str) in foo
+upper(str) matches str
+upper(str) not endsWith str
+upper(str) not in foo
+upper(str[1:])
+upper(str[:0])
+upper(string($env))
+upper(string(0))
 upper(string(1))
 upper(string(add))
 upper(string(array))
-upper(string(f32))
-upper(string(i32))
-upper(string(i64))
+upper(string(f64))
+upper(string(foo))
+upper(string(foo.Bar))
+upper(string(i))
 upper(string(list))
 upper(string(nil))
-upper(string(score))
+upper(string(ok))
+upper(string(str))
 upper(string(true))
-upper(toBase64("bar"))
-upper(toBase64("foo"))
-upper(toJSON("foo"))
-upper(toJSON(1))
-upper(toJSON(f32))
+upper(toBase64(str))
+upper(toJSON(1.0))
+upper(toJSON(array))
+upper(toJSON(f64))
 upper(toJSON(false))
 upper(toJSON(foo))
 upper(toJSON(i))
-upper(toJSON(i32))
 upper(toJSON(list))
 upper(toJSON(nil))
+upper(toJSON(ok))
+upper(toJSON(str))
 upper(toJSON(true))
-upper(trim("bar"))
-upper(trim("foo"))
-upper(trimSuffix("bar"))
-upper(trimSuffix("foo"))
-upper(type("bar"))
-upper(type("foo"))
+upper(trim(str))
+upper(trimPrefix(str))
+upper(type(0))
+upper(type(1))
+upper(type(1.0))
+upper(type(add))
 upper(type(array))
-upper(type(div))
-upper(type(f32))
-upper(type(foo.Bar))
+upper(type(f64))
+upper(type(false))
+upper(type(foo))
 upper(type(greet))
-upper(type(i))
-upper(type(i32))
 upper(type(list))
 upper(type(nil))
 upper(type(ok))
-upper(type(score))
+upper(type(str))
 upper(type(true))
-upper(upper("foo"))
-values(groupBy(array, "bar"))
-values(groupBy(array, "foo"))
-values(groupBy(array, #))
-values(groupBy(array, 0.5))
-values(groupBy(array, 1))
+upper(upper(str))
+values($env) | findIndex(true)
+values($env) | findLast(ok)
+values($env) | findLastIndex(ok)
+values($env) | groupBy(f64)
+values($env) | groupBy(foo)
+values($env) | groupBy(str)
+values($env) | map(add)
+values($env) | map(f64)
+values($env) | map(greet)
+values($env) | one(true)
+values($env) | reduce(#)
+values($env) | reduce(#index)
+values($env) | reduce(1)
+values($env) | reduce(add, nil)
+values($env) | reduce(array)
+values($env) | reduce(foo, nil)
+values($env) | reduce(i)
+values($env) | sortBy(i)
+values($env) | sum(1)
+values($env)?.[i]
+values(array | groupBy(#))
+values(array | groupBy(0))
+values(array | groupBy(1))
+values(array | groupBy(false))
+values(groupBy(array, 0))
 values(groupBy(array, foo))
-values(groupBy(array, i))
-values(groupBy(list, #))
-values(groupBy(list, 1))
-values(groupBy(list, i))
-values(groupBy(list, i32))
-values(groupBy(list, true))
-values({"bar": "bar"})
-values({"bar": array})
-values({"foo": add, "bar": div})
-values({"foo": ok})
-{"bar": "bar" <= "foo"}
-{"bar": "bar", "bar": half}.add
-{"bar": "bar", "bar": i}.Qux
-{"bar": "bar", "bar": i}.String
-{"bar": "bar", "foo": 0.5}.i64
-{"bar": "bar", "foo": i64}?.Qux
-{"bar": "bar", "foo": score}.f32
-{"bar": "bar"}.String?.foo
-{"bar": "bar"}.array
-{"bar": "bar"}.f64
-{"bar": "bar"}.greet
-{"bar": "bar"}.list
-{"bar": "bar"}.ok
-{"bar": "bar"}?.Qux
-{"bar": "bar"}?.array
-{"bar": "bar"}?.half
-{"bar": "bar"}?.list
-{"bar": "foo", "bar": div}.half
-{"bar": "foo", "foo": f32}.String
-{"bar": "foo", "foo": i64}.ok?.f64
-{"bar": "foo", "foo": ok}?.i64
-{"bar": "foo"}.Bar
-{"bar": "foo"}.f32
-{"bar": "foo"}.foo
-{"bar": "foo"}.half
-{"bar": "foo"}.i
-{"bar": "foo"}.i64
-{"bar": "foo"}?.String
-{"bar": "foo"}?.f32
-{"bar": "foo"}?.foo
-{"bar": "foo"}?.greet
-{"bar": "foo"}?.i
-{"bar": "foo"}?.i32
-{"bar": "foo"}?.i?.String()
-{"bar": "foo"}?.list
-{"bar": "foo"}?.ok
-{"bar": -0.5}
-{"bar": -f32}
-{"bar": -f64}
-{"bar": -i32}
-{"bar": 0.5 != nil}
-{"bar": 0.5 * 1}.foo
-{"bar": 0.5, "bar": 0.5}.half
-{"bar": 0.5, "bar": add, "foo": i32}.list
-{"bar": 0.5, "bar": i}?.add
-{"bar": 0.5, "bar": list}?.div
-{"bar": 0.5, "bar": nil, "bar": nil}.i32
-{"bar": 0.5, "bar": ok, "foo": 1}?.String
-{"bar": 0.5, "bar": true}.score
-{"bar": 0.5, "foo": 0.5}?.f32
-{"bar": 0.5, "foo": array}?.list
-{"bar": 0.5, "foo": f32}.i32?.Bar
-{"bar": 0.5, "foo": ok}?.array
-{"bar": 0.5}.Qux
-{"bar": 0.5}.String
-{"bar": 0.5}.add
-{"bar": 0.5}.array
-{"bar": 0.5}.f32
-{"bar": 0.5}.f64
-{"bar": 0.5}.half
-{"bar": 0.5}.i
-{"bar": 0.5}.i32
-{"bar": 0.5}.i64
-{"bar": 0.5}.ok
-{"bar": 0.5}?.Bar
-{"bar": 0.5}?.Qux
-{"bar": 0.5}?.String
-{"bar": 0.5}?.div
-{"bar": 0.5}?.foo
-{"bar": 0.5}?.greet
-{"bar": 0.5}?.half
-{"bar": 0.5}?.i
-{"bar": 0.5}?.i32
-{"bar": 0.5}?.i64
-{"bar": 0.5}?.list
-{"bar": 0.5}?.score
-{"bar": 1 * i}
-{"bar": 1 ** 0.5}
-{"bar": 1 / 0.5}
-{"bar": 1 / f32}
-{"bar": 1 ^ 1}
-{"bar": 1, "bar": add, "foo": "bar"}?.add
-{"bar": 1, "bar": add}.div
-{"bar": 1, "bar": f32}?.Bar
-{"bar": 1, "bar": f64, "foo": array}.ok
-{"bar": 1, "foo": "bar"}.half
-{"bar": 1, "foo": array, "bar": score}?.i
-{"bar": 1, "foo": i}?.list
-{"bar": 1, "foo": i}?.ok
-{"bar": 1, "foo": ok}?.f32
-{"bar": 1, "foo": score}.f64
-{"bar": 1}.String
-{"bar": 1}.add
-{"bar": 1}.f32
-{"bar": 1}.foo
-{"bar": 1}.greet
-{"bar": 1}.half
-{"bar": 1}.i
-{"bar": 1}.i32
-{"bar": 1}.list
-{"bar": 1}.score
-{"bar": 1}?.Qux
-{"bar": 1}?.add
-{"bar": 1}?.div
-{"bar": 1}?.f32
-{"bar": 1}?.f64
-{"bar": 1}?.i
-{"bar": 1}?.i32
-{"bar": 1}?.i64
-{"bar": 1}?.list
-{"bar": 1}?.ok
-{"bar": add, "bar": half}.div
-{"bar": add, "bar": i, "bar": ok}?.foo
-{"bar": add, "bar": list}
-{"bar": add, "bar": ok, "foo": 1}?.ok
-{"bar": add, "foo": "foo"}?.f64
-{"bar": add}
-{"bar": add}.Qux
-{"bar": add}.String
-{"bar": add}.add
-{"bar": add}.array
-{"bar": add}.div
-{"bar": add}.half
-{"bar": add}?.Qux
-{"bar": add}?.String
-{"bar": add}?.add
-{"bar": add}?.array
-{"bar": add}?.div
-{"bar": add}?.f64
-{"bar": add}?.f64 != half
-{"bar": add}?.half
-{"bar": add}?.ok
-{"bar": add}?.score?.div
-{"bar": array, "bar": "bar"}?.i
-{"bar": array, "bar": array}?.foo
-{"bar": array, "bar": f32}
-{"bar": array, "bar": nil}.i64
-{"bar": array, "foo": f32}?.String
-{"bar": array, "foo": f64}
-{"bar": array, "foo": half}?.add
-{"bar": array, "foo": i32}
-{"bar": array, "foo": score}
-{"bar": array}
-{"bar": array}.Bar
-{"bar": array}.div
-{"bar": array}.div?.Qux
-{"bar": array}.greet
-{"bar": array}.i
-{"bar": array}.i64
-{"bar": array}.list
-{"bar": array}.score
-{"bar": array}?.add?.ok
-{"bar": array}?.div
-{"bar": array}?.f64
-{"bar": array}?.greet
-{"bar": array}?.half
-{"bar": array}?.i64
-{"bar": array}?.ok
-{"bar": div, "bar": array, "bar": 0.5}.i64
-{"bar": div, "bar": div}?.f32
-{"bar": div, "bar": foo}.foo
-{"bar": div, "bar": ok}
-{"bar": div, "foo": 1, "bar": ok}.Qux
-{"bar": div, "foo": false}?.String
-{"bar": div, "foo": foo, "foo": score}.Bar
-{"bar": div, "foo": greet}.i
-{"bar": div, "foo": greet}?.ok
-{"bar": div, "foo": score}
-{"bar": div}
-{"bar": div}.array
-{"bar": div}.f32
-{"bar": div}.f64
-{"bar": div}.i64?.Qux
-{"bar": div}.list
-{"bar": div}.ok
-{"bar": div}?.Bar
-{"bar": div}?.array
-{"bar": div}?.f64
-{"bar": div}?.greet
-{"bar": div}?.half
-{"bar": div}?.list
-{"bar": div}?.ok
-{"bar": div}?.score
-{"bar": f32 ** i}
-{"bar": f32 - 0.5}
-{"bar": f32 >= 0.5}
-{"bar": f32 ^ 1}
-{"bar": f32, "bar": "foo"}.add
-{"bar": f32, "bar": false}?.Bar
-{"bar": f32, "bar": true}?.String
-{"bar": f32, "foo": add, "foo": false}?.String
-{"bar": f32, "foo": f32}.ok
-{"bar": f32, "foo": f64}
-{"bar": f32, "foo": half, "foo": ok}
-{"bar": f32, "foo": half}
-{"bar": f32, "foo": list}?.f32
-{"bar": f32, "foo": nil}?.f64?.foo
-{"bar": f32}
-{"bar": f32}.Qux
-{"bar": f32}.div
-{"bar": f32}.f64
-{"bar": f32}.greet
-{"bar": f32}.i
-{"bar": f32}.i32
-{"bar": f32}.i64
-{"bar": f32}?.Bar
-{"bar": f32}?.String
-{"bar": f32}?.array
-{"bar": f32}?.f64
-{"bar": f32}?.half
-{"bar": f32}?.list
-{"bar": f64 + 1}
-{"bar": f64 == i32}
-{"bar": f64 > 0.5}
-{"bar": f64 ^ i32}
-{"bar": f64, "bar": "bar"}.i
-{"bar": f64, "bar": foo}?.i
-{"bar": f64, "bar": i64}?.i64
-{"bar": f64, "bar": i}.f64
-{"bar": f64, "bar": true}?.i
-{"bar": f64, "foo": 0.5, "foo": score}.ok
-{"bar": f64, "foo": 1}.f32
-{"bar": f64, "foo": f64}?.score
-{"bar": f64, "foo": i}?.Qux?.f64
-{"bar": f64}
-{"bar": f64}.array
-{"bar": f64}.f32?.Bar
-{"bar": f64}.f64
-{"bar": f64}.foo
-{"bar": f64}.i
-{"bar": f64}.i32
-{"bar": f64}.ok
-{"bar": f64}?.Bar
-{"bar": f64}?.Bar?.Qux
-{"bar": f64}?.add
-{"bar": f64}?.div
-{"bar": f64}?.f32
-{"bar": f64}?.foo
-{"bar": f64}?.i
-{"bar": f64}?.i64
-{"bar": f64}?.list
-{"bar": f64}?.ok
-{"bar": false, "bar": array}?.list
-{"bar": false, "bar": i32}?.div
-{"bar": false, "bar": i}?.i64
-{"bar": false, "bar": nil}.ok
-{"bar": false}.Bar
-{"bar": false}.Qux
-{"bar": false}.array
-{"bar": false}.f32
-{"bar": false}.f64
-{"bar": false}.half
-{"bar": false}.i
-{"bar": false}.i32
-{"bar": false}.ok
-{"bar": false}.score
-{"bar": false}?.Bar
-{"bar": false}?.array
-{"bar": false}?.div
-{"bar": false}?.foo
-{"bar": false}?.half
-{"bar": false}?.i
-{"bar": false}?.list
-{"bar": false}?.ok
-{"bar": filter(list, ok)}
-{"bar": float(0.5)}
-{"bar": floor(0.5)}.score
-{"bar": floor(i32)}
-{"bar": foo != nil, "foo": array}
-{"bar": foo, "bar": "foo", "bar": score}?.score
-{"bar": foo, "bar": 1, "bar": score}?.ok
-{"bar": foo, "bar": greet}
-{"bar": foo, "bar": i}?.i
-{"bar": foo, "bar": score}?.ok
-{"bar": foo, "foo": 0.5, "foo": ok}?.half
-{"bar": foo, "foo": 0.5}.score
-{"bar": foo, "foo": 1, "foo": i}?.add
-{"bar": foo, "foo": f64}
-{"bar": foo, "foo": f64}.Bar
-{"bar": foo.Bar}
-{"bar": foo.String()}
-{"bar": foo?.Qux, "bar": f32}
-{"bar": foo?.String}
-{"bar": foo}
-{"bar": foo}.Bar
-{"bar": foo}.array
-{"bar": foo}.f32
-{"bar": foo}.half
-{"bar": foo}.i
-{"bar": foo}.list
-{"bar": foo}.ok
-{"bar": foo}?.Bar
-{"bar": foo}?.add
-{"bar": foo}?.greet
-{"bar": foo}?.i
-{"bar": foo}?.i32
-{"bar": foo}?.i64
-{"bar": foo}?.list
-{"bar": foo}?.ok
-{"bar": foo}?.score
-{"bar": get(list, i32)}
-{"bar": greet("foo")}
-{"bar": greet, "bar": 0.5}.i32
-{"bar": greet, "bar": 1}.Bar
-{"bar": greet, "bar": f32}.Bar
-{"bar": greet, "bar": i32}
-{"bar": greet, "bar": not ok}
-{"bar": greet, "foo": "bar"}.ok
-{"bar": greet, "foo": f64}
-{"bar": greet, "foo": false, "bar": ok}.i32
-{"bar": greet, "foo": i32}
-{"bar": greet}
-{"bar": greet}.Bar
-{"bar": greet}.array
-{"bar": greet}.f32
-{"bar": greet}.greet
-{"bar": greet}.half
-{"bar": greet}.list
-{"bar": greet}?.Qux
-{"bar": greet}?.div
-{"bar": greet}?.f32
-{"bar": greet}?.f64
-{"bar": greet}?.greet
-{"bar": greet}?.half
-{"bar": greet}?.i32
-{"bar": greet}?.ok
-{"bar": greet}?.score
-{"bar": groupBy(array, f32)}
-{"bar": half == nil}
-{"bar": half(f64)}
-{"bar": half, "bar": add, "bar": f64}?.i32
-{"bar": half, "bar": foo}
-{"bar": half, "bar": list}
-{"bar": half, "bar": score}
-{"bar": half, "foo": 1}?.i64
-{"bar": half, "foo": list}
-{"bar": half, "foo": ok, "bar": i}
-{"bar": half, "foo": ok}.Qux
-{"bar": half, "foo": true}?.String
-{"bar": half}
-{"bar": half}.Bar?.i
-{"bar": half}.Qux
-{"bar": half}.String
-{"bar": half}.div?.i
-{"bar": half}.f32
-{"bar": half}.foo
-{"bar": half}.half
-{"bar": half}.i32
-{"bar": half}.list
-{"bar": half}.list?.String()
-{"bar": half}?.Bar
-{"bar": half}?.String
-{"bar": half}?.array
-{"bar": half}?.f32
-{"bar": half}?.greet
-{"bar": half}?.i32
-{"bar": half}?.list
-{"bar": i % i32}
-{"bar": i ** f64}
-{"bar": i < 1}?.half
-{"bar": i, "bar": 1}.add
-{"bar": i, "bar": 1}?.i64
-{"bar": i, "bar": array}?.half
-{"bar": i, "bar": div}.ok
-{"bar": i, "bar": f64, "bar": "foo"}?.foo
-{"bar": i, "bar": f64, "bar": nil}.i32
-{"bar": i, "bar": score}
-{"bar": i, "foo": half}
-{"bar": i, "foo": i32}?.score
-{"bar": i, "foo": nil}?.String
-{"bar": i32 ^ 0.5}
-{"bar": i32 ^ f64}
-{"bar": i32, "bar": list}
-{"bar": i32, "foo": "bar"}.i64
-{"bar": i32, "foo": array}.div
-{"bar": i32, "foo": f64, "foo": add}.f64
-{"bar": i32, "foo": foo}?.add
-{"bar": i32, "foo": ok}.ok
-{"bar": i32}
-{"bar": i32}.Qux
-{"bar": i32}.f64
-{"bar": i32}.i
-{"bar": i32}.i32
-{"bar": i32}.list
-{"bar": i32}.ok
-{"bar": i32}.score
-{"bar": i32}?.Qux
-{"bar": i32}?.add
-{"bar": i32}?.array
-{"bar": i32}?.div
-{"bar": i32}?.f32
-{"bar": i32}?.i32
-{"bar": i32}?.list
-{"bar": i32}?.ok
-{"bar": i64 + 1}
-{"bar": i64 <= 0.5}
-{"bar": i64 == 0.5}
-{"bar": i64 in array}
-{"bar": i64, "bar": !ok}
-{"bar": i64, "bar": 0.5}.f32
-{"bar": i64, "bar": greet}.array
-{"bar": i64, "bar": score}.ok
-{"bar": i64, "foo": nil}?.i32
-{"bar": i64, "foo": ok}
-{"bar": i64, "foo": ok}?.f32
-{"bar": i64}
-{"bar": i64}.array?.Bar
-{"bar": i64}.div
-{"bar": i64}.f32
-{"bar": i64}.f64
-{"bar": i64}.i
-{"bar": i64}.list
-{"bar": i64}.ok
-{"bar": i64}.score
-{"bar": i64}?.div
-{"bar": i64}?.f32
-{"bar": i64}?.f64
-{"bar": i64}?.half
-{"bar": i64}?.i
-{"bar": i64}?.i32
-{"bar": i64}?.i?.ok
-{"bar": i64}?.list
-{"bar": int(f64)}
-{"bar": i}
-{"bar": i}.add
-{"bar": i}.array
-{"bar": i}.div?.Qux.div
-{"bar": i}.f64
-{"bar": i}.half
-{"bar": i}.i
-{"bar": i}.i64
-{"bar": i}.list
-{"bar": i}?.String
-{"bar": i}?.array
-{"bar": i}?.f64
-{"bar": i}?.foo
-{"bar": i}?.greet
-{"bar": i}?.i
-{"bar": i}?.i32
-{"bar": i}?.i64
-{"bar": i}?.score
-{"bar": list == nil}
-{"bar": list, "bar": half}?.Bar
-{"bar": list, "bar": score}
-{"bar": list, "foo": "foo"}.String
-{"bar": list, "foo": 1, "foo": nil}.score
-{"bar": list, "foo": 1, "foo": score}?.array
-{"bar": list, "foo": array}?.i64
-{"bar": list, "foo": f64}.div?.Qux
-{"bar": list, "foo": f64}.list
-{"bar": list, "foo": half}?.f32
-{"bar": list, "foo": i64}?.array
-{"bar": list, "foo": nil}.i64
-{"bar": list[i32:i32]}
-{"bar": list}
-{"bar": list}.String
-{"bar": list}.add
-{"bar": list}.array
-{"bar": list}.array?.i64
-{"bar": list}.f64
-{"bar": list}.greet
-{"bar": list}.i
-{"bar": list}.list
-{"bar": list}?.Bar
-{"bar": list}?.Qux
-{"bar": list}?.add
-{"bar": list}?.div
-{"bar": list}?.f64
-{"bar": list}?.i64
-{"bar": list}?.score
-{"bar": lower("bar")}
-{"bar": map(array, #)}
-{"bar": map(array, i)}
-{"bar": map(list, #)}
-{"bar": nil != "bar"}
-{"bar": nil != nil}
-{"bar": nil == 0.5}
-{"bar": nil == nil}
-{"bar": nil, "bar": "bar"}?.i32
-{"bar": nil, "bar": add, "bar": i}.add
-{"bar": nil, "bar": foo}?.list
-{"bar": nil, "foo": "foo"}.f64
-{"bar": nil, "foo": 1, "foo": add}.ok
-{"bar": nil, "foo": foo}?.add
-{"bar": nil, "foo": i}?.f64
-{"bar": nil, "foo": list}?.f32
-{"bar": nil}.Bar
-{"bar": nil}.add
-{"bar": nil}.div
-{"bar": nil}.f32
-{"bar": nil}.foo
-{"bar": nil}.greet
-{"bar": nil}.half
-{"bar": nil}.i
-{"bar": nil}.i32
-{"bar": nil}.i32?.greet
-{"bar": nil}.i64
-{"bar": nil}.i?.f64
-{"bar": nil}.list
-{"bar": nil}.ok
-{"bar": nil}?.Qux
-{"bar": nil}?.String
-{"bar": nil}?.add
-{"bar": nil}?.div
-{"bar": nil}?.f32
-{"bar": nil}?.f64
-{"bar": nil}?.half
-{"bar": nil}?.i
-{"bar": nil}?.i32
-{"bar": nil}?.list
-{"bar": nil}?.ok
-{"bar": none(list, ok)}
-{"bar": not true}
-{"bar": ok ? "bar" : i}
-{"bar": ok ? i32 : "foo"}
-{"bar": ok ? nil : greet}
-{"bar": ok, "bar": 1, "foo": f64}.half
-{"bar": ok, "bar": array}
-{"bar": ok, "bar": i64, "foo": 1}?.Qux
-{"bar": ok, "bar": i}
-{"bar": ok, "bar": list}?.div
-{"bar": ok, "bar": ok}.f32
-{"bar": ok, "foo": 0.5}?.score
-{"bar": ok, "foo": 1}.i
-{"bar": ok, "foo": greet}
-{"bar": ok, "foo": half}
-{"bar": ok, "foo": list}
-{"bar": ok, "foo": list}?.f64
-{"bar": ok, "foo": nil}?.i32
-{"bar": ok, "foo": ok}.div
-{"bar": ok}
-{"bar": ok}.Bar
-{"bar": ok}.div
-{"bar": ok}.f32
-{"bar": ok}.greet
-{"bar": ok}.i32
-{"bar": ok}.i64
-{"bar": ok}.list
-{"bar": ok}.ok
-{"bar": ok}.score
-{"bar": ok}?.Qux
-{"bar": ok}?.add
-{"bar": ok}?.f32
-{"bar": ok}?.i32
-{"bar": ok}?.i64
-{"bar": ok}?.list
-{"bar": ok}?.score
-{"bar": one(list, false)}
-{"bar": reduce(array, i)}.i64
-{"bar": reduce(list, half)}
-{"bar": score(i)}
-{"bar": score, "bar": "bar", "bar": "foo"}?.f32
-{"bar": score, "bar": add}.String
-{"bar": score, "bar": i64}.f32
-{"bar": score, "bar": nil}.i
-{"bar": score, "foo": div}
-{"bar": score, "foo": foo}.i
-{"bar": score, "foo": half, "foo": i}?.array
-{"bar": score, "foo": half}
-{"bar": score, "foo": score}?.greet
-{"bar": score}
-{"bar": score}.add
-{"bar": score}.array
-{"bar": score}.div
-{"bar": score}.f64
-{"bar": score}.foo
-{"bar": score}.half
-{"bar": score}.list
-{"bar": score}?.String
-{"bar": score}?.array
-{"bar": score}?.f32
-{"bar": score}?.foo
-{"bar": score}?.half
-{"bar": score}?.i
-{"bar": score}?.i32
-{"bar": score}?.list
-{"bar": score}?.score
-{"bar": string(0.5)}
-{"bar": string(i64)}
-{"bar": string(ok)}
-{"bar": toJSON(list)}
-{"bar": true == false}
-{"bar": true, "bar": f64}?.score
-{"bar": true, "bar": i32}.array
-{"bar": true, "foo": nil}?.f32
-{"bar": true}.Bar
-{"bar": true}.Qux
-{"bar": true}.String
-{"bar": true}.div
-{"bar": true}.half
-{"bar": true}.i32
-{"bar": true}?.Bar
-{"bar": true}?.add
-{"bar": true}?.array
-{"bar": true}?.div
-{"bar": true}?.half
-{"bar": true}?.i32
-{"bar": true}?.i64
-{"bar": type(greet)}.Bar
-{"bar": type(half)}
-{"bar": type(score)}
-{"foo": !ok}
-{"foo": "bar" < "bar"}
-{"foo": "bar" > "bar"}
-{"foo": "bar", "bar": list}.div
-{"foo": "bar", "bar": nil}.f64
-{"foo": "bar", "foo": 0.5}?.add
-{"foo": "bar", "foo": 0.5}?.list
-{"foo": "bar", "foo": array}?.f64?.list()
-{"foo": "bar", "foo": list}.list
-{"foo": "bar"}.Bar
-{"foo": "bar"}.Qux
-{"foo": "bar"}.String
-{"foo": "bar"}.foo
-{"foo": "bar"}.half
-{"foo": "bar"}.i
-{"foo": "bar"}.i64
-{"foo": "bar"}?.Bar
-{"foo": "bar"}?.String
-{"foo": "bar"}?.add
-{"foo": "bar"}?.array
-{"foo": "bar"}?.div
-{"foo": "bar"}?.f32
-{"foo": "bar"}?.f64
-{"foo": "bar"}?.foo
-{"foo": "bar"}?.half
-{"foo": "bar"}?.i32
-{"foo": "bar"}?.score
-{"foo": "foo" <= "foo"}
-{"foo": "foo" endsWith "foo"}
-{"foo": "foo", "bar": false}.greet
-{"foo": "foo", "bar": half}?.String
-{"foo": "foo", "bar": list, "bar": div}?.String
-{"foo": "foo", "foo": add}?.f32
-{"foo": "foo"}.Qux
-{"foo": "foo"}.div
-{"foo": "foo"}.f32
-{"foo": "foo"}.i
-{"foo": "foo"}.i32
-{"foo": "foo"}.list
-{"foo": "foo"}?.div
-{"foo": "foo"}?.f32
-{"foo": "foo"}?.foo
-{"foo": "foo"}?.i
-{"foo": "foo"}?.i32
-{"foo": "foo"}?.score
-{"foo": -0.5}
-{"foo": -1}
-{"foo": -f64}
-{"foo": -i64}
-{"foo": 0.5 != 0.5}
-{"foo": 0.5 ** f64}
-{"foo": 0.5 < i64}.div
-{"foo": 0.5 <= 0.5}
-{"foo": 0.5, "bar": 0.5}.String
-{"foo": 0.5, "bar": 0.5}.foo
-{"foo": 0.5, "bar": 0.5}?.score
-{"foo": 0.5, "bar": 1}?.div
-{"foo": 0.5, "bar": i64}.i32
-{"foo": 0.5, "bar": list}?.i64
-{"foo": 0.5, "foo": 1}.Qux
-{"foo": 0.5, "foo": array}.i64
-{"foo": 0.5, "foo": f64}.i
-{"foo": 0.5, "foo": false, "bar": list}.add
-{"foo": 0.5, "foo": greet}.i32
-{"foo": 0.5, "foo": score}.foo
-{"foo": 0.5}.Qux?.half
-{"foo": 0.5}.String
-{"foo": 0.5}.add
-{"foo": 0.5}.array
-{"foo": 0.5}.div
-{"foo": 0.5}.f32
-{"foo": 0.5}.half
-{"foo": 0.5}.i64
-{"foo": 0.5}.list
-{"foo": 0.5}.score
-{"foo": 0.5}?.Bar
-{"foo": 0.5}?.String
-{"foo": 0.5}?.div
-{"foo": 0.5}?.f32
-{"foo": 0.5}?.f64
-{"foo": 0.5}?.half
-{"foo": 0.5}?.i
-{"foo": 0.5}?.list
-{"foo": 0.5}?.ok
-{"foo": 1 / i64}
-{"foo": 1 == f32}
-{"foo": 1, "bar": nil}?.add
-{"foo": 1, "bar": score}.greet
-{"foo": 1, "foo": 1}.f64
-{"foo": 1, "foo": f64}.i
-{"foo": 1, "foo": false}?.f32
-{"foo": 1, "foo": half}?.f32
-{"foo": 1, "foo": ok}.Bar
-{"foo": 1, "foo": ok}.f32
-{"foo": 1, "foo": ok}.i32
-{"foo": 1, "foo": score}.half
-{"foo": 1}.Bar
-{"foo": 1}.add
-{"foo": 1}.div
-{"foo": 1}.f32
-{"foo": 1}.f64
-{"foo": 1}.foo
-{"foo": 1}.greet
-{"foo": 1}.half
-{"foo": 1}.i
-{"foo": 1}.i64
-{"foo": 1}.list
-{"foo": 1}?.String
-{"foo": 1}?.add
-{"foo": 1}?.f64
-{"foo": 1}?.greet
-{"foo": 1}?.half
-{"foo": 1}?.list
-{"foo": 1}?.ok
-{"foo": abs(i64)}
-{"foo": add, "bar": half}
-{"foo": add, "bar": nil}.i
-{"foo": add, "bar": nil}?.i
-{"foo": add, "bar": ok, "foo": array}?.i32
-{"foo": add, "foo": 1, "bar": i32}.add
-{"foo": add, "foo": array}?.f32
-{"foo": add, "foo": foo}?.i64
-{"foo": add, "foo": half}
-{"foo": add, "foo": score, "bar": i32}.list
-{"foo": add}
-{"foo": add}.array
-{"foo": add}.div
-{"foo": add}.f32
-{"foo": add}.foo
-{"foo": add}.half
-{"foo": add}.i
-{"foo": add}.i32
-{"foo": add}.i?.score
-{"foo": add}.list
-{"foo": add}?.Bar
-{"foo": add}?.Qux
-{"foo": add}?.String
-{"foo": add}?.div
-{"foo": add}?.f32
-{"foo": add}?.foo
-{"foo": add}?.greet
-{"foo": add}?.half
-{"foo": add}?.i
-{"foo": add}?.i64
-{"foo": add}?.score
-{"foo": array, "bar": "bar"}.add
-{"foo": array, "bar": 0.5}?.div
-{"foo": array, "bar": add}.ok
-{"foo": array, "bar": array}.f32
-{"foo": array, "bar": i64}?.add
-{"foo": array, "bar": list}
-{"foo": array, "bar": nil}.half
-{"foo": array, "bar": ok, "bar": i}
-{"foo": array, "foo": "foo"}.array
-{"foo": array, "foo": array}
-{"foo": array, "foo": f32, "foo": half}.ok
-{"foo": array, "foo": f64}
-{"foo": array, "foo": list}
-{"foo": array}
-{"foo": array}.Bar
-{"foo": array}.Qux
-{"foo": array}.f32
-{"foo": array}.foo
-{"foo": array}.greet
-{"foo": array}.i
-{"foo": array}.i32
-{"foo": array}.i64
-{"foo": array}.score
-{"foo": array}?.Qux
-{"foo": array}?.add
-{"foo": array}?.array
-{"foo": array}?.greet
-{"foo": array}?.i64?.add
-{"foo": array}?.list
-{"foo": array}?.ok
-{"foo": div, "bar": "foo"}.array
-{"foo": div, "bar": array}
-{"foo": div, "bar": foo, "foo": true}?.i64
-{"foo": div, "bar": half}
-{"foo": div, "bar": i64}
-{"foo": div, "foo": array}
-{"foo": div, "foo": f32}
-{"foo": div, "foo": greet}?.i64
-{"foo": div}
-{"foo": div}.Qux
-{"foo": div}.array
-{"foo": div}.div
-{"foo": div}.f32
-{"foo": div}.greet?.i
-{"foo": div}.i32
-{"foo": div}.i64
-{"foo": div}?.Bar
-{"foo": div}?.Qux
-{"foo": div}?.String
-{"foo": div}?.div
-{"foo": div}?.greet
-{"foo": div}?.half
-{"foo": div}?.i32
-{"foo": div}?.i64
-{"foo": div}?.list
-{"foo": div}?.score
-{"foo": f32 > 1}
-{"foo": f32 >= 1}
-{"foo": f32, "bar": 0.5}.list
-{"foo": f32, "bar": div}
-{"foo": f32, "bar": f32}
-{"foo": f32, "bar": f64}
-{"foo": f32, "bar": greet}.greet
-{"foo": f32, "bar": half}
-{"foo": f32, "bar": ok}?.add
-{"foo": f32, "bar": score}?.i64
-{"foo": f32, "foo": "foo"}.ok
-{"foo": f32, "foo": add}?.half?.f64()
-{"foo": f32, "foo": foo}?.half
-{"foo": f32}
-{"foo": f32}.Qux
-{"foo": f32}.add
-{"foo": f32}.f32
-{"foo": f32}.foo
-{"foo": f32}.greet
-{"foo": f32}.half
-{"foo": f32}.i
-{"foo": f32}.i32
-{"foo": f32}.i64
-{"foo": f32}.list
-{"foo": f32}.score?.greet
-{"foo": f32}?.Bar
-{"foo": f32}?.String
-{"foo": f32}?.array
-{"foo": f32}?.f64?.i
-{"foo": f32}?.i
-{"foo": f32}?.ok
-{"foo": f64 < f64}
-{"foo": f64 > f32}
-{"foo": f64 >= 0.5}
-{"foo": f64 >= f32}
-{"foo": f64 in array}
-{"foo": f64, "bar": 0.5}.greet
-{"foo": f64, "bar": add, "foo": greet}.Bar
-{"foo": f64, "bar": list}.i64
-{"foo": f64, "bar": sum(array)}
-{"foo": f64, "bar": true}?.greet
-{"foo": f64, "foo": list, "foo": i}?.add
-{"foo": f64}
-{"foo": f64}.Bar
-{"foo": f64}.Qux
-{"foo": f64}.div
-{"foo": f64}.f32
-{"foo": f64}.f64
-{"foo": f64}.greet
-{"foo": f64}.i32
-{"foo": f64}.list
-{"foo": f64}.ok
-{"foo": f64}?.String
-{"foo": f64}?.f32
-{"foo": f64}?.f64
-{"foo": f64}?.foo
-{"foo": f64}?.greet
-{"foo": f64}?.i32
-{"foo": f64}?.i64
-{"foo": f64}?.ok
-{"foo": f64}?.ok?.ok
-{"foo": f64}?.score
-{"foo": false or false}.array
-{"foo": false, "bar": 0.5, "foo": add}.score
-{"foo": false, "foo": foo, "bar": half}.array
-{"foo": false, "foo": score, "foo": nil}?.div
-{"foo": false, "foo": true}?.i32
-{"foo": false}.array
-{"foo": false}.i
-{"foo": false}.ok
-{"foo": false}?.f32
-{"foo": false}?.f64
-{"foo": false}?.list
-{"foo": foo == nil}
-{"foo": foo, "bar": div}
-{"foo": foo, "bar": foo}
-{"foo": foo, "bar": ok}.i32
-{"foo": foo, "bar": {"foo": 1}}
-{"foo": foo, "foo": add}
-{"foo": foo, "foo": half}
-{"foo": foo, "foo": i}
-{"foo": foo, "foo": ok}
-{"foo": foo, "foo": score, "foo": f64}.i
-{"foo": foo.Bar}
-{"foo": foo.String, "bar": foo}
-{"foo": foo.String}
-{"foo": foo?.Bar}
-{"foo": foo?.Qux}
-{"foo": foo?.String()}
-{"foo": foo?.String}
-{"foo": foo}
-{"foo": foo}.Bar?.Bar
-{"foo": foo}.Qux
-{"foo": foo}.String
-{"foo": foo}.String?.String
-{"foo": foo}.f32
-{"foo": foo}.greet
-{"foo": foo}.half
-{"foo": foo}.i64
-{"foo": foo}?.Qux
-{"foo": foo}?.add
-{"foo": foo}?.array
-{"foo": foo}?.array?.Bar
-{"foo": foo}?.f64
-{"foo": foo}?.greet
-{"foo": foo}?.i32
-{"foo": foo}?.list
-{"foo": foo}?.ok
-{"foo": greet("foo")}
-{"foo": greet, "bar": "bar"}?.i32
-{"foo": greet, "bar": i64}
-{"foo": greet, "bar": i}.list
-{"foo": greet, "foo": add}.String
-{"foo": greet, "foo": nil}?.add
-{"foo": greet}
-{"foo": greet}.Bar
-{"foo": greet}.Qux
-{"foo": greet}.String
-{"foo": greet}.add
-{"foo": greet}.array
-{"foo": greet}.f32
-{"foo": greet}.i
-{"foo": greet}.i32
-{"foo": greet}.i64
-{"foo": greet}.i64?.greet
-{"foo": greet}.ok
-{"foo": greet}.score
-{"foo": greet}?.Qux
-{"foo": greet}?.array
-{"foo": greet}?.div
-{"foo": greet}?.f32
-{"foo": greet}?.f64
-{"foo": greet}?.i32
-{"foo": greet}?.i64
-{"foo": greet}?.list
-{"foo": greet}?.ok
-{"foo": greet}?.score
-{"foo": groupBy(array, 1)}
-{"foo": groupBy(list, #)}
-{"foo": half, "bar": "foo"}?.half
-{"foo": half, "bar": add, "foo": true}?.array
-{"foo": half, "bar": array}.half
-{"foo": half, "bar": greet}?.half
-{"foo": half, "bar": half}?.i
-{"foo": half, "bar": list, "foo": 1}?.f64
-{"foo": half, "bar": list}
-{"foo": half, "bar": true}?.Qux
-{"foo": half, "foo": 1}?.i32
-{"foo": half, "foo": div, "foo": array}?.i32
-{"foo": half, "foo": f64}
-{"foo": half, "foo": list, "foo": half}.half
-{"foo": half, "foo": score, "foo": list}.String
-{"foo": half}
-{"foo": half}.Bar
-{"foo": half}.String
-{"foo": half}.add
-{"foo": half}.div
-{"foo": half}.f32
-{"foo": half}.foo
-{"foo": half}.half
-{"foo": half}.i
-{"foo": half}.i64
-{"foo": half}.ok
-{"foo": half}.score
-{"foo": half}?.Bar
-{"foo": half}?.Qux
-{"foo": half}?.String
-{"foo": half}?.div
-{"foo": half}?.f32
-{"foo": half}?.foo
-{"foo": half}?.i32
-{"foo": half}?.i64
-{"foo": half}?.score
-{"foo": i != 1}
-{"foo": i - f64}
-{"foo": i / 1}
-{"foo": i ^ 1}
-{"foo": i, "bar": 0.5}?.half
-{"foo": i, "bar": f32}
-{"foo": i, "bar": foo}
-{"foo": i, "bar": list}.foo
-{"foo": i, "foo": "bar"}?.div?.f32
-{"foo": i, "foo": 1}.list
-{"foo": i, "foo": 1}?.list
-{"foo": i, "foo": add}
-{"foo": i, "foo": array, "bar": 0.5}?.f32
-{"foo": i, "foo": half}?.list
-{"foo": i, "foo": score}
-{"foo": i, "foo": score}?.f32
-{"foo": i32 != i}
-{"foo": i32 * 0.5}
-{"foo": i32 + 1}
-{"foo": i32 - f32}.foo
-{"foo": i32 - f64}
-{"foo": i32 / 1}
-{"foo": i32 < 1}
-{"foo": i32, "bar": 0.5, "bar": foo}.i64
-{"foo": i32, "bar": foo}?.score
-{"foo": i32, "bar": nil}?.ok
-{"foo": i32, "foo": false, "bar": f32}?.foo
-{"foo": i32, "foo": greet}?.greet
-{"foo": i32}
-{"foo": i32}.i
-{"foo": i32}.ok
-{"foo": i32}?.Bar
-{"foo": i32}?.String
-{"foo": i32}?.add
-{"foo": i32}?.f32
-{"foo": i32}?.f64
-{"foo": i32}?.i
-{"foo": i32}?.i32
-{"foo": i32}?.i64
-{"foo": i32}?.list
-{"foo": i32}?.score
-{"foo": i64 % 1}
-{"foo": i64 * f32}
-{"foo": i64 .. i64}
-{"foo": i64, "bar": array}
-{"foo": i64, "foo": array}.f32
-{"foo": i64, "foo": f32}
-{"foo": i64, "foo": i32}?.foo
-{"foo": i64, "foo": i64, "bar": f64}.foo
-{"foo": i64, "foo": i64}
-{"foo": i64, "foo": i64}.greet
-{"foo": i64, "foo": i64}?.foo
-{"foo": i64}
-{"foo": i64}.Bar
-{"foo": i64}.array
-{"foo": i64}.div
-{"foo": i64}.foo
-{"foo": i64}.greet
-{"foo": i64}.half
-{"foo": i64}.i
-{"foo": i64}.i32
-{"foo": i64}.list
-{"foo": i64}?.Qux
-{"foo": i64}?.add
-{"foo": i64}?.array
-{"foo": i64}?.f32
-{"foo": i64}?.f64
-{"foo": i64}?.half
-{"foo": i64}?.i32
-{"foo": i64}?.i32?.f32
-{"foo": i64}?.i64
-{"foo": i64}?.score?.list
-{"foo": int(i)}
-{"foo": int(i32)}
-{"foo": int(i64)}
-{"foo": i}
-{"foo": i}.Bar
-{"foo": i}.String
-{"foo": i}.add
-{"foo": i}.array
-{"foo": i}.f64
-{"foo": i}.greet
-{"foo": i}.i
-{"foo": i}.ok
-{"foo": i}?.div
-{"foo": i}?.greet
-{"foo": i}?.i
-{"foo": i}?.i32
-{"foo": i}?.i64
-{"foo": i}?.score
-{"foo": last(list)}
-{"foo": len(list)}
-{"foo": list, "bar": add}
-{"foo": list, "bar": all(list, false)}
-{"foo": list, "bar": array}
-{"foo": list, "bar": f32}.f64
-{"foo": list, "bar": half}
-{"foo": list, "bar": i32, "bar": score}.array
-{"foo": list, "bar": true}?.foo
-{"foo": list}
-{"foo": list}.Qux
-{"foo": list}.String
-{"foo": list}.add
-{"foo": list}.div
-{"foo": list}.f32
-{"foo": list}.greet
-{"foo": list}.half
-{"foo": list}.i
-{"foo": list}.i32
-{"foo": list}?.String
-{"foo": list}?.div
-{"foo": list}?.f32
-{"foo": list}?.foo
-{"foo": list}?.i
-{"foo": list}?.i32
-{"foo": list}?.i64
-{"foo": list}?.ok
-{"foo": list}?.score
-{"foo": map(array, #)}
-{"foo": map(array, i64)}
-{"foo": nil, "bar": 0.5}.ok
-{"foo": nil, "bar": add, "bar": f32}?.list
-{"foo": nil, "bar": div, "bar": 1}.i64
-{"foo": nil, "bar": f32}.score
-{"foo": nil, "bar": foo}?.String
-{"foo": nil, "bar": score}?.ok?.div
-{"foo": nil, "foo": "foo"}.Bar
-{"foo": nil, "foo": greet}.String
-{"foo": nil, "foo": half}.f64
-{"foo": nil, "foo": i64, "bar": f64}?.list
-{"foo": nil, "foo": i}.div
-{"foo": nil, "foo": list}.add
-{"foo": nil, "foo": list}?.array
-{"foo": nil, "foo": nil}.ok
-{"foo": nil}.array?.half()
-{"foo": nil}.div
-{"foo": nil}.f32
-{"foo": nil}.f64
-{"foo": nil}.half
-{"foo": nil}.i
-{"foo": nil}.i32
-{"foo": nil}.i64?.Bar()
-{"foo": nil}.list
-{"foo": nil}.ok
-{"foo": nil}.score
-{"foo": nil}?.Bar
-{"foo": nil}?.Bar?.score
-{"foo": nil}?.add
-{"foo": nil}?.array
-{"foo": nil}?.f64
-{"foo": nil}?.foo
-{"foo": nil}?.half
-{"foo": nil}?.i32
-{"foo": nil}?.i64
-{"foo": nil}?.list
-{"foo": ok == false}
-{"foo": ok, "bar": "foo"}?.i64
-{"foo": ok, "bar": add}.String
-{"foo": ok, "bar": f32}
-{"foo": ok, "foo": half}.ok
-{"foo": ok, "foo": list}
-{"foo": ok}
-{"foo": ok}.Bar
-{"foo": ok}.Bar?.i
-{"foo": ok}.String
-{"foo": ok}.array
-{"foo": ok}.div
-{"foo": ok}.f64
-{"foo": ok}.foo
-{"foo": ok}.i32
-{"foo": ok}.i64
-{"foo": ok}.ok
-{"foo": ok}?.Qux
-{"foo": ok}?.String
-{"foo": ok}?.String?.Bar
-{"foo": ok}?.array
-{"foo": ok}?.f32
-{"foo": ok}?.foo
-{"foo": ok}?.greet
-{"foo": ok}?.half
-{"foo": ok}?.i32
-{"foo": ok}?.i64
-{"foo": ok}?.list
-{"foo": reduce(array, "foo")}
-{"foo": reduce(array, #)}
-{"foo": reduce(list, #).String()}
-{"foo": reduce(list, #)}
-{"foo": reduce(list, #)}?.list
-{"foo": score, "bar": add}.add
-{"foo": score, "bar": div}
-{"foo": score, "bar": f64}
-{"foo": score, "bar": false}?.array
-{"foo": score, "bar": false}?.i
-{"foo": score, "bar": true}.div?.i
-{"foo": score, "foo": 0.5}?.String
-{"foo": score, "foo": 1}.array
-{"foo": score, "foo": add}
-{"foo": score, "foo": array}.array
-{"foo": score, "foo": f32}
-{"foo": score, "foo": greet}
+values(groupBy(list, ok))
+values(if ok { $env } else { str })
+values(list | groupBy(false))
+values(max($env))
+values(min($env))
+values(ok ? $env : nil)
+values(reduce(array, $env))
+values(reduce(list, $env))
+values({foo: $env})
+values({foo: $env}?.foo)
+values({foo: 0, foo: 0})
+values({foo: 0})
+values({foo: 1, foo: 0})
+values({foo: 1.0})
+values({foo: 1})
+values({foo: array, foo: foo})
+values({foo: array})
+values({foo: f64})
+values({foo: false, foo: false})
+values({foo: false})
+values({foo: foo, foo: list})
+values({foo: foo})
+values({foo: greet, foo: 0})
+values({foo: greet, foo: foo})
+values({foo: greet})
+values({foo: i})
+values({foo: list})
+values({foo: nil, foo: ok})
+values({foo: nil})
+values({foo: ok, foo: $env})
+values({foo: ok, foo: 1.0})
+values({foo: ok, foo: list})
+values({foo: ok})
+values({foo: str})
+{foo: $env != $env}
+{foo: $env != 0}
+{foo: $env != 1.0}
+{foo: $env != 1}
+{foo: $env != add}
+{foo: $env != f64, foo: foo}
+{foo: $env != foo}
+{foo: $env != greet}
+{foo: $env != greet}.Bar
+{foo: $env != list}
+{foo: $env != nil}
+{foo: $env != ok}
+{foo: $env != str}
+{foo: $env == $env}
+{foo: $env == 0}
+{foo: $env == 0}.array
+{foo: $env == 1.0}
+{foo: $env == 1}
+{foo: $env == add}
+{foo: $env == false}
+{foo: $env == foo}
+{foo: $env == foo}.i
+{foo: $env == greet}
+{foo: $env == i}
+{foo: $env == nil}
+{foo: $env == ok}
+{foo: $env == str}
+{foo: $env == true}
+{foo: $env and false}
+{foo: $env and true}
+{foo: $env in array}
+{foo: $env in list}
+{foo: $env or false}
+{foo: $env or true}
+{foo: $env | any(ok)}
+{foo: $env | any(true)}
+{foo: $env | map(#index)}
+{foo: $env | map($env)}
+{foo: $env | map(0)}
+{foo: $env | map(add), foo: i}
+{foo: $env | map(f64)}
+{foo: $env | map(foo)}
+{foo: $env | map(list)}
+{foo: $env | none(false)}
+{foo: $env | none(true)}
+{foo: $env | one(true)}
+{foo: $env | reduce($env, foo)}?.f64
+{foo: $env | reduce(1, $env)}
+{foo: $env | reduce(foo, 1.0)}
+{foo: $env | sum(0)}
+{foo: $env | sum(1.0)}
+{foo: $env || true}
+{foo: $env, foo: $env, foo: true}?.add
+{foo: $env, foo: $env}.Bar
+{foo: $env, foo: $env}.add
+{foo: $env, foo: $env}.f64
+{foo: $env, foo: $env}.greet
+{foo: $env, foo: $env}.i?.[ok]
+{foo: $env, foo: $env}?.String
+{foo: $env, foo: $env}?.array
+{foo: $env, foo: $env}?.foobar
+{foo: $env, foo: $env}?.ok
+{foo: $env, foo: 0}.Bar
+{foo: $env, foo: 0}.add
+{foo: $env, foo: 0}.greet
+{foo: $env, foo: 0}.ok
+{foo: $env, foo: 0}?.Bar
+{foo: $env, foo: 0}?.false?.ok
+{foo: $env, foo: 0}?.list
+{foo: $env, foo: 1.0, foo: foo}.ok
+{foo: $env, foo: 1.0}.String
+{foo: $env, foo: 1.0}.add
+{foo: $env, foo: 1.0}.greet
+{foo: $env, foo: 1.0}.list
+{foo: $env, foo: 1.0}?.array
+{foo: $env, foo: 1.0}?.foo
+{foo: $env, foo: 1.0}?.i
+{foo: $env, foo: 1.0}?.ok
+{foo: $env, foo: 1.0}?.str
+{foo: $env, foo: 1}.String
+{foo: $env, foo: 1}.f64
+{foo: $env, foo: 1}.ok
+{foo: $env, foo: 1}?.[str]
+{foo: $env, foo: 1}?.f64
+{foo: $env, foo: 1}?.greet
+{foo: $env, foo: 1}?.i
+{foo: $env, foo: add}.foo?.list
+{foo: $env, foo: add}.i
+{foo: $env, foo: add}.list
+{foo: $env, foo: add}.str
+{foo: $env, foo: add}?.add
+{foo: $env, foo: add}?.foo
+{foo: $env, foo: add}?.ok
+{foo: $env, foo: array}.array
+{foo: $env, foo: array}.foo
+{foo: $env, foo: array}.greet
+{foo: $env, foo: array}.i
+{foo: $env, foo: array}.list
+{foo: $env, foo: array}?.f64
+{foo: $env, foo: array}?.foo
+{foo: $env, foo: array}?.greet
+{foo: $env, foo: array}?.str
+{foo: $env, foo: f64}.String
+{foo: $env, foo: f64}.String?.array
+{foo: $env, foo: f64}?.foo
+{foo: $env, foo: f64}?.i
+{foo: $env, foo: false, foo: foo}?.str
+{foo: $env, foo: false}.add
+{foo: $env, foo: false}.array
+{foo: $env, foo: false}.str
+{foo: $env, foo: false}?.[str]
+{foo: $env, foo: false}?.array
+{foo: $env, foo: foo, foo: $env}?.greet
+{foo: $env, foo: foo, foo: list}.String
+{foo: $env, foo: foo}.String
+{foo: $env, foo: foo}.array
+{foo: $env, foo: foo}.foobar
+{foo: $env, foo: foo}.greet
+{foo: $env, foo: foo}.i
+{foo: $env, foo: foo}.list
+{foo: $env, foo: foo}.str
+{foo: $env, foo: foo}?.Bar
+{foo: $env, foo: foo}?.String
+{foo: $env, foo: foo}?.array
+{foo: $env, foo: foo}?.ok
+{foo: $env, foo: greet, foo: 0}.greet
+{foo: $env, foo: greet}.add
+{foo: $env, foo: greet}.foo
+{foo: $env, foo: greet}?.Bar
+{foo: $env, foo: greet}?.add
+{foo: $env, foo: greet}?.f64
+{foo: $env, foo: i}.greet
+{foo: $env, foo: i}?.add
+{foo: $env, foo: i}?.foo
+{foo: $env, foo: list, foo: 1}?.[str]
+{foo: $env, foo: list}.Bar
+{foo: $env, foo: list}.array
+{foo: $env, foo: list}.greet
+{foo: $env, foo: list}?.Bar?.greet
+{foo: $env, foo: list}?.[str]
+{foo: $env, foo: list}?.list
+{foo: $env, foo: nil}.Bar
+{foo: $env, foo: nil}.foo
+{foo: $env, foo: nil}.foobar?.i
+{foo: $env, foo: nil}.greet
+{foo: $env, foo: nil}.str
+{foo: $env, foo: nil}?.add
+{foo: $env, foo: nil}?.f64
+{foo: $env, foo: nil}?.foobar
+{foo: $env, foo: nil}?.list
+{foo: $env, foo: nil}?.str
+{foo: $env, foo: ok}.array
+{foo: $env, foo: ok}.f64
+{foo: $env, foo: str, foo: f64}?.i
+{foo: $env, foo: str}.array
+{foo: $env, foo: str}?.Bar
+{foo: $env, foo: str}?.greet
+{foo: $env, foo: true, foo: 1.0}?.list
+{foo: $env, foo: true}.foobar
+{foo: $env, foo: true}.list
+{foo: $env, foo: true}.str?.list
+{foo: $env, foo: true}?.[str]
+{foo: $env, foo: true}?.greet
+{foo: $env, foo: true}?.ok
+{foo: $env.add, foo: $env.ok}
+{foo: $env.add}
+{foo: $env.add}.String
+{foo: $env.add}.array
+{foo: $env.array, foo: add}
+{foo: $env.array, foo: {foo: array}}
+{foo: $env.array}
+{foo: $env.f64, foo: str}
+{foo: $env.f64}
+{foo: $env.f64}?.add
+{foo: $env.f64}?.array
+{foo: $env.foo, foo: f64}?.list
+{foo: $env.foo}
+{foo: $env.foo}?.String
+{foo: $env.greet, foo: array}
+{foo: $env.greet, foo: i}
+{foo: $env.greet}
+{foo: $env.i, foo: add}
+{foo: $env.i, foo: array}
+{foo: $env.i, foo: ok != $env}
+{foo: $env.i}
+{foo: $env.list, foo: 1.0 == 1.0}
+{foo: $env.list}
+{foo: $env.ok, foo: add}
+{foo: $env.ok}
+{foo: $env.ok}?.str
+{foo: $env.str}
+{foo: $env.str}.ok
+{foo: $env?.$env}
+{foo: $env?.Bar, foo: if false { foo } else { 0 }}
+{foo: $env?.Bar, foo: ok}
+{foo: $env?.Bar?.Bar}
+{foo: $env?.Bar?.[greet]}
+{foo: $env?.Bar?.list}
+{foo: $env?.Bar}
+{foo: $env?.Bar}.Bar
+{foo: $env?.Bar}?.list
+{foo: $env?.String}
+{foo: $env?.[Bar], foo: i}
+{foo: $env?.[Bar], foo: str}
+{foo: $env?.[Bar]?.Bar}
+{foo: $env?.[Bar]?.[add]}
+{foo: $env?.[Bar]}
+{foo: $env?.[Bar]}?.greet
+{foo: $env?.[Bar]}?.ok
+{foo: $env?.[String], foo: ok}
+{foo: $env?.[String]?.array}
+{foo: $env?.[String]}
+{foo: $env?.[String]}.f64
+{foo: $env?.[foobar]?.add}
+{foo: $env?.[foobar]}
+{foo: $env?.[nil]}
+{foo: $env?.[str]}
+{foo: $env?.[str]}?.add
+{foo: $env?.add, foo: add}
+{foo: $env?.add}
+{foo: $env?.add}.greet
+{foo: $env?.add}?.foo
+{foo: $env?.array, foo: add}
+{foo: $env?.array}
+{foo: $env?.array}.ok
+{foo: $env?.f64}
+{foo: $env?.f64}?.greet
+{foo: $env?.foo.String()}
+{foo: $env?.foobar, foo: greet}
+{foo: $env?.foobar}
+{foo: $env?.foo}
+{foo: $env?.foo}.str
+{foo: $env?.greet}
+{foo: $env?.greet}.foo
+{foo: $env?.greet}?.add
+{foo: $env?.i, foo: string(i)}
+{foo: $env?.i, foo: str}
+{foo: $env?.i}
+{foo: $env?.i}?.f64
+{foo: $env?.i}?.greet
+{foo: $env?.list, foo: [1.0]}
+{foo: $env?.list}
+{foo: $env?.list}.f64
+{foo: $env?.nil?.[add]}
+{foo: $env?.nil?.[i]}
+{foo: $env?.nil}
+{foo: $env?.ok}
+{foo: $env?.ok}.f64
+{foo: $env?.ok}?.foo
+{foo: $env?.ok}?.list
+{foo: $env?.str, foo: $env?.ok}
+{foo: $env?.str, foo: array}
+{foo: $env?.str}
+{foo: $env?.str}.f64
+{foo: $env?.str}?.Bar
+{foo: $env} == nil or false
+{foo: $env}.Bar
+{foo: $env}.Bar?.[str]
+{foo: $env}.Bar?.add
+{foo: $env}.String
+{foo: $env}.add
+{foo: $env}.add?.[array]
+{foo: $env}.add?.[foo]
+{foo: $env}.add?.[ok]
+{foo: $env}.add?.array
+{foo: $env}.add?.list
+{foo: $env}.array
+{foo: $env}.array?.i
+{foo: $env}.array?.str
+{foo: $env}.f64
+{foo: $env}.foo
+{foo: $env}.foo?.i
+{foo: $env}.foobar
+{foo: $env}.greet
+{foo: $env}.greet?.Bar
+{foo: $env}.i
+{foo: $env}.list
+{foo: $env}.list?.greet
+{foo: $env}.ok
+{foo: $env}.ok?.[ok]
+{foo: $env}.str
+{foo: $env}.str?.Bar
+{foo: $env}?.Bar
+{foo: $env}?.Bar?.i
+{foo: $env}?.String
+{foo: $env}?.String?.[add]
+{foo: $env}?.String?.str()
+{foo: $env}?.[str]
+{foo: $env}?.add
+{foo: $env}?.array
+{foo: $env}?.array?.[greet]
+{foo: $env}?.f64
+{foo: $env}?.foo
+{foo: $env}?.foo.Bar
+{foo: $env}?.foo.ok
+{foo: $env}?.foobar
+{foo: $env}?.foobar?.greet(nil)
+{foo: $env}?.greet
+{foo: $env}?.greet?.list()
+{foo: $env}?.greet?.ok
+{foo: $env}?.i
+{foo: $env}?.i?.[array]
+{foo: $env}?.list
+{foo: $env}?.list?.[foo]
+{foo: $env}?.list?.greet?.[i]
+{foo: $env}?.ok
+{foo: $env}?.ok?.[str]
+{foo: $env}?.str
+{foo: $env}?.str?.[ok]
+{foo: $env}?.str?.array
+{foo: $env}?.str?.foo
+{foo: 0 != $env.i}
+{foo: 0 != $env}
+{foo: 0 != 0}
+{foo: 0 != f64}
+{foo: 0 != nil}
+{foo: 0 % i}
+{foo: 0 * 0}
+{foo: 0 * 1.0}
+{foo: 0 * 1}
+{foo: 0 * i}
+{foo: 0 ** 1}
+{foo: 0 ** i}
+{foo: 0 + 1.0}
+{foo: 0 + f64}
+{foo: 0 - 1.0}
+{foo: 0 - 1}
+{foo: 0 - f64}
+{foo: 0 .. 1}
+{foo: 0 .. i}
+{foo: 0 / 0}
+{foo: 0 / 1.0}
+{foo: 0 < 0, foo: i}
+{foo: 0 < 1.0}
+{foo: 0 < 1}
+{foo: 0 < f64}
+{foo: 0 <= 0}
+{foo: 0 <= 1.0}
+{foo: 0 == 0}
+{foo: 0 == 1.0}
+{foo: 0 == i}
+{foo: 0 == nil}
+{foo: 0 > 1.0}
+{foo: 0 > 1}
+{foo: 0 >= 1}
+{foo: 0 ^ 0}
+{foo: 0 ^ 1.0}
+{foo: 0 ^ i}
+{foo: 0 in array}
+{foo: 0 | bitshl(i)}
+{foo: 0, foo: $env, foo: 1.0}?.greet
+{foo: 0, foo: $env}.String
+{foo: 0, foo: $env}.foo
+{foo: 0, foo: $env}.list
+{foo: 0, foo: $env}.str
+{foo: 0, foo: $env}?.add
+{foo: 0, foo: $env}?.array
+{foo: 0, foo: 0, foo: false}?.list
+{foo: 0, foo: 0}.String
+{foo: 0, foo: 0}.add
+{foo: 0, foo: 0}?.f64
+{foo: 0, foo: 0}?.ok
+{foo: 0, foo: 1.0}.Bar
+{foo: 0, foo: 1.0}.array
+{foo: 0, foo: 1.0}.ok
+{foo: 0, foo: 1.0}?.f64
+{foo: 0, foo: 1.0}?.i
+{foo: 0, foo: 1}.Bar
+{foo: 0, foo: 1}.array
+{foo: 0, foo: 1}.greet
+{foo: 0, foo: 1}?.ok
+{foo: 0, foo: add}.array
+{foo: 0, foo: add}?.[str]
+{foo: 0, foo: add}?.foobar
+{foo: 0, foo: add}?.greet
+{foo: 0, foo: array}.Bar
+{foo: 0, foo: array}.array
+{foo: 0, foo: array}?.foo
+{foo: 0, foo: array}?.not
+{foo: 0, foo: f64}.foo
+{foo: 0, foo: f64}.greet
+{foo: 0, foo: f64}?.foo
+{foo: 0, foo: false, foo: 1}.add
+{foo: 0, foo: false}?.f64
+{foo: 0, foo: false}?.foo
+{foo: 0, foo: foo, foo: add}.array
+{foo: 0, foo: foo, foo: false}?.greet
+{foo: 0, foo: foo}.Bar
+{foo: 0, foo: foo}.foobar
+{foo: 0, foo: foo}?.array
+{foo: 0, foo: foo}?.f64
+{foo: 0, foo: foo}?.ok
+{foo: 0, foo: greet}.f64
+{foo: 0, foo: greet}.greet
+{foo: 0, foo: greet}.ok
+{foo: 0, foo: greet}?.add
+{foo: 0, foo: greet}?.str
+{foo: 0, foo: i}.add
+{foo: 0, foo: i}.array
+{foo: 0, foo: i}.f64
+{foo: 0, foo: list}?.[str]
+{foo: 0, foo: nil}.Bar
+{foo: 0, foo: nil}.String?.i()
+{foo: 0, foo: nil}.array
+{foo: 0, foo: nil}.greet
+{foo: 0, foo: nil}.ok
+{foo: 0, foo: ok}.f64
+{foo: 0, foo: ok}.ok
+{foo: 0, foo: str}.Bar
+{foo: 0, foo: str}?.foo
+{foo: 0, foo: str}?.greet
+{foo: 0, foo: str}?.ok
+{foo: 0..i}
+{foo: 0}.Bar
+{foo: 0}.String
+{foo: 0}.String?.[f64]
+{foo: 0}.String?.ok()
+{foo: 0}.add
+{foo: 0}.array
+{foo: 0}.f64
+{foo: 0}.foo
+{foo: 0}.greet
+{foo: 0}.greet?.[list]
+{foo: 0}.i
+{foo: 0}.list
+{foo: 0}.list?.[foo].String
+{foo: 0}.ok
+{foo: 0}.ok?.[array]
+{foo: 0}.ok?.f64
+{foo: 0}.ok?.foo?.[i]
+{foo: 0}.str
+{foo: 0}.str?.String
+{foo: 0}?.Bar
+{foo: 0}?.String
+{foo: 0}?.[str]
+{foo: 0}?.add
+{foo: 0}?.array
+{foo: 0}?.f64
+{foo: 0}?.foo
+{foo: 0}?.foobar == foo
+{foo: 0}?.greet
+{foo: 0}?.i
+{foo: 0}?.list
+{foo: 0}?.ok
+{foo: 0}?.ok?.[str]
+{foo: 0}?.str
+{foo: 0}?.str?.Bar
+{foo: 0}?.str?.str
+{foo: 1 != $env}
+{foo: 1 != 1.0}
+{foo: 1 != 1}
+{foo: 1 != f64}
+{foo: 1 != f64}.f64
+{foo: 1 != i}
+{foo: 1 != nil}
+{foo: 1 % 1}
+{foo: 1 * 0}
+{foo: 1 * 1.0}
+{foo: 1 * 1}
+{foo: 1 * f64}
+{foo: 1 * i}
+{foo: 1 ** 0}
+{foo: 1 ** 1.0}.f64
+{foo: 1 ** 1.0}.i
+{foo: 1 ** 1}
+{foo: 1 + 0}
+{foo: 1 + i}
+{foo: 1 - 1.0}
+{foo: 1 - f64}
+{foo: 1 - i}
+{foo: 1 .. i}
+{foo: 1 / 1.0}
+{foo: 1 / 1}
+{foo: 1 / f64}
+{foo: 1 < 1.0}
+{foo: 1 < 1}
+{foo: 1 < i}
+{foo: 1 <= 1}
+{foo: 1 == $env}
+{foo: 1 == 0}
+{foo: 1 == 1.0}
+{foo: 1 == 1}
+{foo: 1 == nil}
+{foo: 1 > 0}
+{foo: 1 > 1.0}
+{foo: 1 > i}
+{foo: 1 >= 1}
+{foo: 1 >= f64}
+{foo: 1 >= i}
+{foo: 1 ^ 0}
+{foo: 1 ^ 1.0}
+{foo: 1 ^ f64}
+{foo: 1 in array}
+{foo: 1 not in $env?.array}
+{foo: 1, foo: $env, foo: add}?.ok
+{foo: 1, foo: $env}.String
+{foo: 1, foo: $env}.array
+{foo: 1, foo: $env}.greet
+{foo: 1, foo: $env}.str
+{foo: 1, foo: $env}?.greet
+{foo: 1, foo: $env}?.str
+{foo: 1, foo: 0, foo: add}?.array
+{foo: 1, foo: 0}.add
+{foo: 1, foo: 0}.foo
+{foo: 1, foo: 0}.list
+{foo: 1, foo: 1.0}.String
+{foo: 1, foo: 1.0}?.Bar
+{foo: 1, foo: 1.0}?.foobar
+{foo: 1, foo: 1.0}?.greet
+{foo: 1, foo: 1.0}?.str?.array()
+{foo: 1, foo: 1}.f64
+{foo: 1, foo: 1}.greet
+{foo: 1, foo: 1}?.f64
+{foo: 1, foo: add}.array
+{foo: 1, foo: add}.greet
+{foo: 1, foo: add}?.Bar
+{foo: 1, foo: add}?.list
+{foo: 1, foo: array}?.ok
+{foo: 1, foo: f64}?.f64
+{foo: 1, foo: f64}?.i
+{foo: 1, foo: false}.f64
+{foo: 1, foo: false}.foo
+{foo: 1, foo: false}.foobar?.foo()
+{foo: 1, foo: false}?.add
+{foo: 1, foo: false}?.ok
+{foo: 1, foo: foo, foo: $env}?.[str]
+{foo: 1, foo: foo}.Bar
+{foo: 1, foo: foo}.f64
+{foo: 1, foo: foo}.foo
+{foo: 1, foo: foo}?.[str]
+{foo: 1, foo: foo}?.foo
+{foo: 1, foo: foo}?.foobar
+{foo: 1, foo: foo}?.greet
+{foo: 1, foo: foo}?.list
+{foo: 1, foo: greet}.String
+{foo: 1, foo: greet}.greet
+{foo: 1, foo: greet}.i
+{foo: 1, foo: greet}.ok?.String
+{foo: 1, foo: greet}?.greet
+{foo: 1, foo: i, foo: list}?.[str]
+{foo: 1, foo: list}.f64
+{foo: 1, foo: list}?.Bar
+{foo: 1, foo: list}?.add
+{foo: 1, foo: nil, foo: greet}.foo
+{foo: 1, foo: nil}.i
+{foo: 1, foo: nil}.ok
+{foo: 1, foo: nil}?.Bar
+{foo: 1, foo: nil}?.String
+{foo: 1, foo: nil}?.add
+{foo: 1, foo: nil}?.list
+{foo: 1, foo: nil}?.str
+{foo: 1, foo: ok}.foo
+{foo: 1, foo: ok}.list
+{foo: 1, foo: ok}?.String
+{foo: 1, foo: ok}?.[str]
+{foo: 1, foo: ok}?.str
+{foo: 1, foo: str, foo: 0}.i
+{foo: 1, foo: str}.f64
+{foo: 1, foo: str}.list
+{foo: 1, foo: str}?.str
+{foo: 1, foo: true}.String
+{foo: 1, foo: true}.ok
+{foo: 1.0 != 1.0}
+{foo: 1.0 != 1}
+{foo: 1.0 != f64}
+{foo: 1.0 != i}
+{foo: 1.0 * 1.0}
+{foo: 1.0 * 1}
+{foo: 1.0 ** 1.0}
+{foo: 1.0 ** f64}
+{foo: 1.0 ** i}
+{foo: 1.0 + 1.0}
+{foo: 1.0 + 1}
+{foo: 1.0 + f64}
+{foo: 1.0 + i}
+{foo: 1.0 - 0}
+{foo: 1.0 - 1.0}
+{foo: 1.0 - 1}
+{foo: 1.0 - i}
+{foo: 1.0 / 0}
+{foo: 1.0 / 1.0}
+{foo: 1.0 / 1}
+{foo: 1.0 / f64}
+{foo: 1.0 / i}
+{foo: 1.0 < 1.0}
+{foo: 1.0 < 1.0}.String
+{foo: 1.0 <= 0}
+{foo: 1.0 <= 1.0}
+{foo: 1.0 <= 1}
+{foo: 1.0 <= f64}
+{foo: 1.0 <= i}
+{foo: 1.0 == $env}
+{foo: 1.0 == 0}
+{foo: 1.0 == 1.0}
+{foo: 1.0 == 1}
+{foo: 1.0 == f64}.foo
+{foo: 1.0 == i}
+{foo: 1.0 == nil}
+{foo: 1.0 == nil}?.String
+{foo: 1.0 > 1.0}
+{foo: 1.0 > 1}
+{foo: 1.0 > f64}
+{foo: 1.0 > f64}.array
+{foo: 1.0 > i}
+{foo: 1.0 >= 0}
+{foo: 1.0 >= 1.0}
+{foo: 1.0 >= 1}
+{foo: 1.0 >= f64}
+{foo: 1.0 >= i, foo: greet}
+{foo: 1.0 >= i}
+{foo: 1.0 ^ 0}
+{foo: 1.0 ^ 1.0}
+{foo: 1.0 ^ 1}
+{foo: 1.0 ^ i}
+{foo: 1.0 in array}
+{foo: 1.0 not in array}
+{foo: 1.0 | max(1.0)}
+{foo: 1.0 | min(1)}
+{foo: 1.0, foo: $env, foo: foo}.f64
+{foo: 1.0, foo: $env, foo: str}?.i?.[add]
+{foo: 1.0, foo: $env}.array
+{foo: 1.0, foo: $env}.foobar
+{foo: 1.0, foo: $env}.greet
+{foo: 1.0, foo: $env}?.add
+{foo: 1.0, foo: $env}?.greet
+{foo: 1.0, foo: $env}?.ok
+{foo: 1.0, foo: 0, foo: $env}?.i
+{foo: 1.0, foo: 0, foo: array}.String
+{foo: 1.0, foo: 0}.Bar
+{foo: 1.0, foo: 0}.String
+{foo: 1.0, foo: 0}.String?.String
+{foo: 1.0, foo: 0}.i
+{foo: 1.0, foo: 0}.list
+{foo: 1.0, foo: 0}?.foo
+{foo: 1.0, foo: 0}?.str
+{foo: 1.0, foo: 1.0}.Bar
+{foo: 1.0, foo: 1.0}.add
+{foo: 1.0, foo: 1.0}.array
+{foo: 1.0, foo: 1.0}.foo
+{foo: 1.0, foo: 1.0}.greet
+{foo: 1.0, foo: 1.0}.list
+{foo: 1.0, foo: 1.0}.ok
+{foo: 1.0, foo: 1.0}.str
+{foo: 1.0, foo: 1.0}?.add
+{foo: 1.0, foo: 1.0}?.f64
+{foo: 1.0, foo: 1.0}?.greet
+{foo: 1.0, foo: 1}.foo
+{foo: 1.0, foo: 1}?.Bar
+{foo: 1.0, foo: 1}?.add
+{foo: 1.0, foo: 1}?.greet
+{foo: 1.0, foo: 1}?.i
+{foo: 1.0, foo: add}.Bar
+{foo: 1.0, foo: add}?.String
+{foo: 1.0, foo: add}?.f64
+{foo: 1.0, foo: add}?.f64?.str?.[array]
+{foo: 1.0, foo: add}?.greet
+{foo: 1.0, foo: add}?.list
+{foo: 1.0, foo: array}.foo
+{foo: 1.0, foo: array}.str
+{foo: 1.0, foo: array}?.Bar
+{foo: 1.0, foo: array}?.f64
+{foo: 1.0, foo: array}?.list
+{foo: 1.0, foo: f64}.add
+{foo: 1.0, foo: f64}.greet
+{foo: 1.0, foo: f64}.list
+{foo: 1.0, foo: f64}.ok
+{foo: 1.0, foo: f64}.str
+{foo: 1.0, foo: f64}?.add
+{foo: 1.0, foo: false}.String
+{foo: 1.0, foo: false}.array
+{foo: 1.0, foo: false}.array?.add
+{foo: 1.0, foo: false}.i
+{foo: 1.0, foo: false}.str
+{foo: 1.0, foo: false}?.array
+{foo: 1.0, foo: false}?.list
+{foo: 1.0, foo: foo, foo: list}?.f64
+{foo: 1.0, foo: foo, foo: true}.Bar
+{foo: 1.0, foo: foo}.foo
+{foo: 1.0, foo: foo}.greet
+{foo: 1.0, foo: foo}.list
+{foo: 1.0, foo: foo}.ok
+{foo: 1.0, foo: foo}.str
+{foo: 1.0, foo: foo}?.Bar
+{foo: 1.0, foo: foo}?.String
+{foo: 1.0, foo: foo}?.add
+{foo: 1.0, foo: foo}?.f64
+{foo: 1.0, foo: foo}?.foo
+{foo: 1.0, foo: foo}?.greet
+{foo: 1.0, foo: foo}?.list
+{foo: 1.0, foo: foo}?.ok
+{foo: 1.0, foo: greet}.Bar
+{foo: 1.0, foo: greet}.array
+{foo: 1.0, foo: greet}.i
+{foo: 1.0, foo: greet}.list
+{foo: 1.0, foo: greet}?.[str]
+{foo: 1.0, foo: greet}?.foo
+{foo: 1.0, foo: greet}?.greet
+{foo: 1.0, foo: i}.String
+{foo: 1.0, foo: i}.ok
+{foo: 1.0, foo: i}?.Bar
+{foo: 1.0, foo: i}?.String
+{foo: 1.0, foo: i}?.add
+{foo: 1.0, foo: i}?.f64
+{foo: 1.0, foo: i}?.foobar
+{foo: 1.0, foo: i}?.greet
+{foo: 1.0, foo: i}?.i
+{foo: 1.0, foo: list}.f64
+{foo: 1.0, foo: list}.i
+{foo: 1.0, foo: list}.list
+{foo: 1.0, foo: list}?.array
+{foo: 1.0, foo: list}?.ok
+{foo: 1.0, foo: nil}.Bar
+{foo: 1.0, foo: nil}.array
+{foo: 1.0, foo: nil}.foo
+{foo: 1.0, foo: nil}.i
+{foo: 1.0, foo: nil}.ok
+{foo: 1.0, foo: nil}?.Bar
+{foo: 1.0, foo: nil}?.String
+{foo: 1.0, foo: nil}?.[str]
+{foo: 1.0, foo: nil}?.add
+{foo: 1.0, foo: nil}?.f64
+{foo: 1.0, foo: nil}?.foobar
+{foo: 1.0, foo: nil}?.str
+{foo: 1.0, foo: ok}.String
+{foo: 1.0, foo: ok}.add
+{foo: 1.0, foo: ok}.f64
+{foo: 1.0, foo: ok}.i
+{foo: 1.0, foo: ok}.str
+{foo: 1.0, foo: ok}?.String
+{foo: 1.0, foo: ok}?.f64
+{foo: 1.0, foo: ok}?.greet
+{foo: 1.0, foo: ok}?.list?.ok
+{foo: 1.0, foo: ok}?.str
+{foo: 1.0, foo: str}.array
+{foo: 1.0, foo: str}.str
+{foo: 1.0, foo: str}?.str
+{foo: 1.0, foo: true}.greet
+{foo: 1.0, foo: true}?.Bar
+{foo: 1.0, foo: true}?.array
+{foo: 1.0, foo: true}?.f64
+{foo: 1.0, foo: true}?.ok
+{foo: 1.0}
+{foo: 1.0} | get(str)
+{foo: 1.0}.Bar
+{foo: 1.0}.Bar?.str
+{foo: 1.0}.String
+{foo: 1.0}.String?.[foo]
+{foo: 1.0}.String?.foo
+{foo: 1.0}.add
+{foo: 1.0}.add?.Bar
+{foo: 1.0}.add?.f64
+{foo: 1.0}.add?.list
+{foo: 1.0}.array
+{foo: 1.0}.f64
+{foo: 1.0}.f64?.[add]
+{foo: 1.0}.f64?.greet()
+{foo: 1.0}.foo
+{foo: 1.0}.foobar
+{foo: 1.0}.foobar == 1.0
+{foo: 1.0}.greet
+{foo: 1.0}.greet?.foo
+{foo: 1.0}.i
+{foo: 1.0}.i == ok
+{foo: 1.0}.list
+{foo: 1.0}.list?.i
+{foo: 1.0}.ok
+{foo: 1.0}.str
+{foo: 1.0}.str?.[list]?.foo
+{foo: 1.0}?.$env?.[add]
+{foo: 1.0}?.Bar
+{foo: 1.0}?.Bar?.[ok]
+{foo: 1.0}?.Bar?.add
+{foo: 1.0}?.Bar?.list(array, ok)
+{foo: 1.0}?.Bar?.list(foobar)
+{foo: 1.0}?.String
+{foo: 1.0}?.String?.[f64].str
+{foo: 1.0}?.[str]
+{foo: 1.0}?.add
+{foo: 1.0}?.add?.[i]
+{foo: 1.0}?.array
+{foo: 1.0}?.array?.greet
+{foo: 1.0}?.f64
+{foo: 1.0}?.f64?.foo
+{foo: 1.0}?.foo
+{foo: 1.0}?.foobar
+{foo: 1.0}?.foobar?.String
+{foo: 1.0}?.greet
+{foo: 1.0}?.greet?.list
+{foo: 1.0}?.i
+{foo: 1.0}?.list
+{foo: 1.0}?.list?.[str]
+{foo: 1.0}?.not
+{foo: 1.0}?.ok
+{foo: 1.0}?.str
+{foo: 1} == $env?.[String]
+{foo: 1}.Bar
+{foo: 1}.String
+{foo: 1}.String?.[greet]
+{foo: 1}.add
+{foo: 1}.add?.str()
+{foo: 1}.array
+{foo: 1}.f64
+{foo: 1}.foo
+{foo: 1}.foobar
+{foo: 1}.greet
+{foo: 1}.greet?.[list]
+{foo: 1}.i
+{foo: 1}.list
+{foo: 1}.list?.foo
+{foo: 1}.ok
+{foo: 1}.ok?.add
+{foo: 1}.str
+{foo: 1}.str?.[f64]
+{foo: 1}?.Bar
+{foo: 1}?.String
+{foo: 1}?.String not startsWith $env
+{foo: 1}?.[str]
+{foo: 1}?.[str] startsWith str
+{foo: 1}?.[str]?.String
+{foo: 1}?.add
+{foo: 1}?.add?.[str]
+{foo: 1}?.array
+{foo: 1}?.f64
+{foo: 1}?.f64?.[ok]
+{foo: 1}?.foo
+{foo: 1}?.foobar
+{foo: 1}?.foobar?.i.array
+{foo: 1}?.greet
+{foo: 1}?.i
+{foo: 1}?.list
+{foo: 1}?.list?.[ok]
+{foo: 1}?.nil?.str(nil)
+{foo: 1}?.ok
+{foo: 1}?.str
+{foo: 1}?.str?.[i]
+{foo: 1}?.str?.[ok]
+{foo: [$env, false], foo: f64}
+{foo: [$env, ok]}
+{foo: [$env]}
+{foo: [$env]}?.String
+{foo: [0 + 0, list]}
+{foo: [0]}
+{foo: [1.0, $env]}
+{foo: [1.0], foo: greet}
+{foo: [1.0]}
+{foo: [1]}
+{foo: [1]}.list
+{foo: [add, 1]}
+{foo: [add]}
+{foo: [array]}
+{foo: [ceil(f64)]}
+{foo: [f64]}
+{foo: [false, f64]}
+{foo: [false]}
+{foo: [foo, $env]}
+{foo: [foo, i]}
+{foo: [foo, nil]}
+{foo: [foo]}
+{foo: [greet, array]}
+{foo: [greet]}
+{foo: [greet]}.Bar
+{foo: [i]}
+{foo: [list]}
+{foo: [nil, array]}
+{foo: [nil, nil]}
+{foo: [nil, true]}
+{foo: [nil]}
+{foo: [ok, foo]}
+{foo: [ok]}
+{foo: [str]}
+{foo: [true, nil]}.i
+{foo: [true]}
+{foo: abs(0)}
+{foo: abs(1)}
+{foo: abs(1.0)}
+{foo: abs(1.0)}?.str
+{foo: abs(f64)}
+{foo: abs(i)}
+{foo: add != $env}
+{foo: add != add}
+{foo: add != nil}
+{foo: add == $env}
+{foo: add(1, 0)}
+{foo: add(i, 0)}
+{foo: add(i, i)}
+{foo: add, foo: $env.f64}
+{foo: add, foo: $env}.$env == f64
+{foo: add, foo: $env}.ok
+{foo: add, foo: $env}?.Bar
+{foo: add, foo: $env}?.String
+{foo: add, foo: $env}?.foo
+{foo: add, foo: $env}?.i
+{foo: add, foo: 0, foo: 0}.ok
+{foo: add, foo: 0}.list
+{foo: add, foo: 1 ** i}
+{foo: add, foo: 1 < f64}
+{foo: add, foo: 1.0 / 1.0}
+{foo: add, foo: 1.0 > f64}
+{foo: add, foo: 1.0}.String
+{foo: add, foo: 1.0}.list
+{foo: add, foo: 1.0}.str
+{foo: add, foo: 1.0}?.Bar
+{foo: add, foo: 1.0}?.greet
+{foo: add, foo: 1.0}?.list
+{foo: add, foo: 1.0}?.ok
+{foo: add, foo: 1}.add
+{foo: add, foo: add}
+{foo: add, foo: add}.array
+{foo: add, foo: add}.foo
+{foo: add, foo: add}?.f64
+{foo: add, foo: add}?.i
+{foo: add, foo: add}?.ok
+{foo: add, foo: add}?.str
+{foo: add, foo: array}
+{foo: add, foo: array}.i
+{foo: add, foo: array}?.array
+{foo: add, foo: f64}
+{foo: add, foo: f64}.array
+{foo: add, foo: f64}.foo
+{foo: add, foo: f64}.greet
+{foo: add, foo: f64}.nil?.f64(foobar)
+{foo: add, foo: f64}?.[str]
+{foo: add, foo: f64}?.ok
+{foo: add, foo: false}.i
+{foo: add, foo: false}?.Bar
+{foo: add, foo: false}?.String
+{foo: add, foo: false}?.[str]
+{foo: add, foo: false}?.ok
+{foo: add, foo: false}?.str
+{foo: add, foo: foo.String()}
+{foo: add, foo: foo.String}
+{foo: add, foo: foo}
+{foo: add, foo: foo}.array
+{foo: add, foo: foo}.f64
+{foo: add, foo: foo}.greet
+{foo: add, foo: foo}.ok
+{foo: add, foo: foo}?.Bar
+{foo: add, foo: foo}?.f64
+{foo: add, foo: foo}?.foo
+{foo: add, foo: foo}?.i
+{foo: add, foo: foo}?.list
+{foo: add, foo: foo}?.ok
+{foo: add, foo: greet}
+{foo: add, foo: greet}.Bar?.String
+{foo: add, foo: greet}.String
+{foo: add, foo: greet}.greet
+{foo: add, foo: greet}?.f64
+{foo: add, foo: greet}?.greet
+{foo: add, foo: greet}?.str
+{foo: add, foo: i}
+{foo: add, foo: i}.array
+{foo: add, foo: i}.greet
+{foo: add, foo: i}.str
+{foo: add, foo: i}?.f64
+{foo: add, foo: i}?.str
+{foo: add, foo: list}
+{foo: add, foo: list}.str
+{foo: add, foo: list}?.list
+{foo: add, foo: nil}.greet
+{foo: add, foo: nil}.str
+{foo: add, foo: nil}?.[str]
+{foo: add, foo: nil}?.add
+{foo: add, foo: nil}?.greet
+{foo: add, foo: nil}?.list
+{foo: add, foo: nil}?.ok
+{foo: add, foo: nil}?.ok?.Bar
+{foo: add, foo: ok}
+{foo: add, foo: ok}?.String
+{foo: add, foo: ok}?.list
+{foo: add, foo: str}
+{foo: add, foo: str}.String
+{foo: add, foo: str}.foo
+{foo: add, foo: str}?.String
+{foo: add, foo: str}?.foo
+{foo: add, foo: true}.foo
+{foo: add, foo: true}.i
+{foo: add, foo: true}.list
+{foo: add, foo: true}?.f64
+{foo: add, foo: true}?.i
+{foo: add}
+{foo: add}.Bar
+{foo: add}.String
+{foo: add}.add
+{foo: add}.array
+{foo: add}.f64
+{foo: add}.foo
+{foo: add}.greet
+{foo: add}.greet?.i
+{foo: add}.i
+{foo: add}.i?.[greet]
+{foo: add}.i?.greet
+{foo: add}.list
+{foo: add}.list?.add()?.Bar
+{foo: add}.ok
+{foo: add}.ok?.Bar(ok)
+{foo: add}.str
+{foo: add}?.Bar
+{foo: add}?.Bar?.i(foobar)
+{foo: add}?.String
+{foo: add}?.String?.String
+{foo: add}?.[str]
+{foo: add}?.add
+{foo: add}?.array
+{foo: add}?.array?.[list]
+{foo: add}?.array?.find(nil, true).String
+{foo: add}?.f64
+{foo: add}?.f64?.[str]
+{foo: add}?.foo
+{foo: add}?.greet
+{foo: add}?.i
+{foo: add}?.list
+{foo: add}?.list?.[array].list
+{foo: add}?.list?.add
+{foo: add}?.list?.list
+{foo: add}?.ok
+{foo: add}?.str
+{foo: all(array, ok)}.Bar
+{foo: any($env, false)}
+{foo: any($env, ok)}
+{foo: any($env, true)}
+{foo: array != list}
+{foo: array != nil}
+{foo: array == $env}
+{foo: array == array}
+{foo: array == nil}
+{foo: array | all(false)}
+{foo: array | groupBy(1.0)}
+{foo: array | map(#)}
+{foo: array | map(1)}?.list
+{foo: array | map(false)}
+{foo: array | map(greet)}
+{foo: array | map(list)}
+{foo: array | mean(i)}
+{foo: array | min(f64)}
+{foo: array | one(ok)}
+{foo: array | reduce(#)}
+{foo: array | reduce(0)}
+{foo: array | reduce(foo)}
+{foo: array | reduce(i)}
+{foo: array | reduce(i, f64)}
+{foo: array | sum(i)}
+{foo: array, foo: $env.add}
+{foo: array, foo: $env}.String
+{foo: array, foo: $env}.foo
+{foo: array, foo: $env}?.Bar
+{foo: array, foo: $env}?.array
+{foo: array, foo: $env}?.foo
+{foo: array, foo: 0}.Bar
+{foo: array, foo: 0}?.ok
+{foo: array, foo: 1.0 <= 0}
+{foo: array, foo: 1.0}.String
+{foo: array, foo: 1.0}.add
+{foo: array, foo: 1.0}.list
+{foo: array, foo: 1.0}?.array
+{foo: array, foo: 1.0}?.greet
+{foo: array, foo: 1.0}?.list
+{foo: array, foo: 1.0}?.ok
+{foo: array, foo: 1.0}?.str
+{foo: array, foo: 1}.Bar
+{foo: array, foo: 1}.i?.ok
+{foo: array, foo: 1}.ok
+{foo: array, foo: 1}?.String
+{foo: array, foo: 1}?.[str]
+{foo: array, foo: add}
+{foo: array, foo: add}?.foo
+{foo: array, foo: array, foo: $env}.ok
+{foo: array, foo: array}
+{foo: array, foo: array}.Bar
+{foo: array, foo: array}.array?.Bar(nil)
+{foo: array, foo: array}.f64
+{foo: array, foo: array}.list
+{foo: array, foo: array}?.str
+{foo: array, foo: f64, foo: 1.0}?.f64
+{foo: array, foo: f64}
+{foo: array, foo: f64}.Bar
+{foo: array, foo: f64}.list
+{foo: array, foo: f64}.str
+{foo: array, foo: f64}?.foo
+{foo: array, foo: false}.f64
+{foo: array, foo: false}.foo
+{foo: array, foo: false}?.f64
+{foo: array, foo: foo}
+{foo: array, foo: foo}.add
+{foo: array, foo: foo}.i
+{foo: array, foo: foo}?.Bar
+{foo: array, foo: foo}?.String
+{foo: array, foo: foo}?.greet
+{foo: array, foo: foo}?.i
+{foo: array, foo: foo}?.list
+{foo: array, foo: foo}?.ok
+{foo: array, foo: greet}
+{foo: array, foo: greet}?.greet
+{foo: array, foo: greet}?.str
+{foo: array, foo: groupBy(list, false)}
+{foo: array, foo: i}
+{foo: array, foo: i}.list
+{foo: array, foo: i}?.String
+{foo: array, foo: list}
+{foo: array, foo: list}.String
+{foo: array, foo: list}.array
+{foo: array, foo: list}.false?.[i]
+{foo: array, foo: list}.list
+{foo: array, foo: list}?.String
+{foo: array, foo: list}?.add
+{foo: array, foo: list}?.foo
+{foo: array, foo: list}?.greet
+{foo: array, foo: list}?.list
+{foo: array, foo: list}?.ok
+{foo: array, foo: nil}.Bar
+{foo: array, foo: nil}.Bar?.[f64]
+{foo: array, foo: nil}.array
+{foo: array, foo: nil}.list
+{foo: array, foo: nil}.str
+{foo: array, foo: nil}?.add
+{foo: array, foo: nil}?.foo
+{foo: array, foo: nil}?.greet
+{foo: array, foo: nil}?.i
+{foo: array, foo: nil}?.list
+{foo: array, foo: nil}?.str
+{foo: array, foo: ok, foo: false}?.String?.String()
+{foo: array, foo: ok}
+{foo: array, foo: ok}?.Bar
+{foo: array, foo: ok}?.ok
+{foo: array, foo: reduce(array, #)}?.ok
+{foo: array, foo: str}
+{foo: array, foo: str}.Bar
+{foo: array, foo: str}.f64
+{foo: array, foo: toJSON(1.0)}
+{foo: array, foo: true}.str
+{foo: array, foo: true}?.Bar
+{foo: array?.[i], foo: list}
+{foo: array?.[i]}
+{foo: array[1:]}
+{foo: array[:]}
+{foo: array}
+{foo: array}.Bar
+{foo: array}.Bar?.[array]
+{foo: array}.Bar?.[i]
+{foo: array}.Bar?.[ok]
+{foo: array}.String
+{foo: array}.add
+{foo: array}.array
+{foo: array}.array?.add
+{foo: array}.array?.list
+{foo: array}.f64
+{foo: array}.f64?.[i]
+{foo: array}.foo
+{foo: array}.foobar
+{foo: array}.greet
+{foo: array}.i
+{foo: array}.i?.[list]
+{foo: array}.i?.[ok]
+{foo: array}.i?.foo
+{foo: array}.list
+{foo: array}.list?.[f64]
+{foo: array}.ok
+{foo: array}.str
+{foo: array}.str?.[greet]
+{foo: array}?.Bar
+{foo: array}?.Bar?.[array]
+{foo: array}?.String
+{foo: array}?.String?.[list]
+{foo: array}?.[str]
+{foo: array}?.[str]?.String()
+{foo: array}?.[str]?.[add]
+{foo: array}?.add
+{foo: array}?.array
+{foo: array}?.array?.foobar
+{foo: array}?.f64
+{foo: array}?.f64?.ok
+{foo: array}?.foo
+{foo: array}?.foobar
+{foo: array}?.foobar?.array
+{foo: array}?.greet
+{foo: array}?.i
+{foo: array}?.list
+{foo: array}?.list?.add
+{foo: array}?.ok
+{foo: array}?.ok?.ok()
+{foo: array}?.str
+{foo: array}?.str?.[f64]
+{foo: bitnand(i, 1)}
+{foo: bitnot(0)}
+{foo: bitnot(i)}
+{foo: bitor(0, 0)}
+{foo: bitor(i, i)}
+{foo: bitxor(i, 1)}
+{foo: ceil(0), foo: array}
+{foo: ceil(0)}
+{foo: ceil(1)}
+{foo: ceil(1.0)}
+{foo: ceil(f64)}
+{foo: ceil(i)}
+{foo: concat(array)}
+{foo: concat(list)}
+{foo: count($env, true), foo: f64}
+{foo: count(list, ok)}
+{foo: f64 != $env}
+{foo: f64 != 1.0}
+{foo: f64 != 1}
+{foo: f64 != f64}
+{foo: f64 != i}
+{foo: f64 != nil}
+{foo: f64 * 1.0}
+{foo: f64 ** i}
+{foo: f64 + 1.0}
+{foo: f64 + 1}
+{foo: f64 + f64}
+{foo: f64 / 0}
+{foo: f64 / f64}
+{foo: f64 / i}
+{foo: f64 < i}
+{foo: f64 <= 1.0}
+{foo: f64 <= i}
+{foo: f64 == 1.0}
+{foo: f64 == 1}
+{foo: f64 == nil}
+{foo: f64 > 0, foo: floor(1.0)}
+{foo: f64 > 0}
+{foo: f64 > f64}
+{foo: f64 >= 0}
+{foo: f64 >= 1}
+{foo: f64 ^ 1.0}
+{foo: f64 in array}
+{foo: f64 not in array}
+{foo: f64 not in array}.f64
+{foo: f64, foo: $env == array}
+{foo: f64, foo: $env?.[foobar]}
+{foo: f64, foo: $env?.list}
+{foo: f64, foo: $env}.String
+{foo: f64, foo: $env}?.i
+{foo: f64, foo: $env}?.ok
+{foo: f64, foo: 0, foo: 1.0}.f64
+{foo: f64, foo: 0}.Bar
+{foo: f64, foo: 0}.list
+{foo: f64, foo: 0}.str
+{foo: f64, foo: 0}?.foo
+{foo: f64, foo: 1 != $env}
+{foo: f64, foo: 1 / 0}
+{foo: f64, foo: 1, foo: $env}?.i
+{foo: f64, foo: 1, foo: nil}.String
+{foo: f64, foo: 1.0}.f64
+{foo: f64, foo: 1.0}.i
+{foo: f64, foo: 1.0}?.Bar
+{foo: f64, foo: 1.0}?.f64
+{foo: f64, foo: 1.0}?.ok
+{foo: f64, foo: 1.0}?.str
+{foo: f64, foo: 1}?.greet
+{foo: f64, foo: add}
+{foo: f64, foo: add}.add
+{foo: f64, foo: add}.foo
+{foo: f64, foo: add}?.f64
+{foo: f64, foo: add}?.foo
+{foo: f64, foo: add}?.greet
+{foo: f64, foo: array}
+{foo: f64, foo: array}.Bar
+{foo: f64, foo: array}.add
+{foo: f64, foo: array}?.str
+{foo: f64, foo: f64}
+{foo: f64, foo: f64}.String
+{foo: f64, foo: f64}.ok
+{foo: f64, foo: f64}?.Bar
+{foo: f64, foo: foo, foo: foo}?.add
+{foo: f64, foo: foo}
+{foo: f64, foo: foo}.array
+{foo: f64, foo: foo}.f64
+{foo: f64, foo: foo}.foo
+{foo: f64, foo: foo}.greet
+{foo: f64, foo: foo}.list
+{foo: f64, foo: foo}?.[str]
+{foo: f64, foo: foo}?.add
+{foo: f64, foo: foo}?.array
+{foo: f64, foo: foo}?.greet
+{foo: f64, foo: foo}?.i
+{foo: f64, foo: foo}?.str
+{foo: f64, foo: greet, foo: i}?.str
+{foo: f64, foo: greet}
+{foo: f64, foo: greet}.add
+{foo: f64, foo: greet}?.ok
+{foo: f64, foo: i, foo: add}.ok
+{foo: f64, foo: if ok { foo } else { nil }}.foo
+{foo: f64, foo: i}
+{foo: f64, foo: i}?.[str]
+{foo: f64, foo: list}
+{foo: f64, foo: list}.array
+{foo: f64, foo: list}.foo
+{foo: f64, foo: list}.list
+{foo: f64, foo: list}?.i?.[i]
+{foo: f64, foo: nil, foo: $env}?.f64
+{foo: f64, foo: nil, foo: 1.0}.array
+{foo: f64, foo: nil}.String
+{foo: f64, foo: nil}.array
+{foo: f64, foo: nil}.f64
+{foo: f64, foo: nil}.foobar
+{foo: f64, foo: nil}?.[str]
+{foo: f64, foo: nil}?.str
+{foo: f64, foo: ok, foo: 1.0}?.str
+{foo: f64, foo: ok}
+{foo: f64, foo: ok}?.String
+{foo: f64, foo: ok}?.f64?.[i]
+{foo: f64, foo: str}
+{foo: f64, foo: str}?.[str]
+{foo: f64, foo: str}?.add
+{foo: f64, foo: sum(array)}
+{foo: f64, foo: toJSON(1)}
+{foo: f64, foo: true}.add
+{foo: f64}
+{foo: f64}.Bar
+{foo: f64}.String
+{foo: f64}.String?.foo
+{foo: f64}.add
+{foo: f64}.array
+{foo: f64}.f64
+{foo: f64}.foo
+{foo: f64}.foobar
+{foo: f64}.greet
+{foo: f64}.i
+{foo: f64}.list
+{foo: f64}.list?.list()
+{foo: f64}.ok
+{foo: f64}.str
+{foo: f64}?.Bar
+{foo: f64}?.String
+{foo: f64}?.[str]
+{foo: f64}?.[str]?.Bar?.f64.String
+{foo: f64}?.add
+{foo: f64}?.add?.[array]
+{foo: f64}?.add?.add
+{foo: f64}?.array
+{foo: f64}?.f64
+{foo: f64}?.f64?.array
+{foo: f64}?.foo
+{foo: f64}?.foobar
+{foo: f64}?.greet
+{foo: f64}?.i
+{foo: f64}?.i?.add
+{foo: f64}?.list
+{foo: f64}?.ok
+{foo: f64}?.str
+{foo: f64}?.str?.i
+{foo: false != $env}
+{foo: false != false}
+{foo: false != nil}
+{foo: false && $env}
+{foo: false == false}
+{foo: false == nil}
+{foo: false == true}
+{foo: false ? foo : i}
+{foo: false ? foo : ok}
+{foo: false ? greet : nil}
+{foo: false ? list : 1}
+{foo: false ? list : f64}
+{foo: false ? ok : f64}
+{foo: false ?: foo}
+{foo: false and $env}
+{foo: false and false}
+{foo: false or $env}
+{foo: false or ok}
+{foo: false or true}
+{foo: false || $env}
+{foo: false, foo: $env, foo: true}.foo
+{foo: false, foo: $env}.String
+{foo: false, foo: $env}.foo
+{foo: false, foo: $env}.greet
+{foo: false, foo: $env}?.String
+{foo: false, foo: $env}?.[str]
+{foo: false, foo: $env}?.list
+{foo: false, foo: 0, foo: $env}?.list
+{foo: false, foo: 0, foo: 0}.str
+{foo: false, foo: 1.0, foo: $env}.add
+{foo: false, foo: 1.0}.Bar
+{foo: false, foo: 1.0}.array
+{foo: false, foo: 1.0}.greet
+{foo: false, foo: 1.0}?.String
+{foo: false, foo: 1.0}?.[str]
+{foo: false, foo: 1.0}?.ok
+{foo: false, foo: 1.0}?.str?.[f64]
+{foo: false, foo: 1}.add
+{foo: false, foo: 1}.i
+{foo: false, foo: 1}.list?.[greet]
+{foo: false, foo: 1}.ok
+{foo: false, foo: 1}?.String
+{foo: false, foo: 1}?.i
+{foo: false, foo: add}?.String
+{foo: false, foo: add}?.f64
+{foo: false, foo: add}?.foo
+{foo: false, foo: array, foo: foo}?.Bar
+{foo: false, foo: array}.foo
+{foo: false, foo: array}?.Bar
+{foo: false, foo: array}?.greet
+{foo: false, foo: array}?.ok
+{foo: false, foo: array}?.str?.greet
+{foo: false, foo: f64, foo: 1.0}.list
+{foo: false, foo: f64}.greet
+{foo: false, foo: f64}.i
+{foo: false, foo: f64}?.str?.f64
+{foo: false, foo: false, foo: foo}?.Bar
+{foo: false, foo: false}?.f64
+{foo: false, foo: false}?.foo
+{foo: false, foo: false}?.ok
+{foo: false, foo: foo, foo: foo}.str
+{foo: false, foo: foo, foo: greet}.f64
+{foo: false, foo: foo}.Bar
+{foo: false, foo: foo}.array
+{foo: false, foo: foo}.f64
+{foo: false, foo: foo}.i
+{foo: false, foo: foo}.list
+{foo: false, foo: foo}.str
+{foo: false, foo: foo}?.Bar
+{foo: false, foo: foo}?.[str]
+{foo: false, foo: foo}?.add
+{foo: false, foo: foo}?.foo
+{foo: false, foo: greet}.array
+{foo: false, foo: greet}.greet
+{foo: false, foo: greet}.str
+{foo: false, foo: greet}?.array
+{foo: false, foo: greet}?.foobar
+{foo: false, foo: greet}?.str
+{foo: false, foo: i}.str
+{foo: false, foo: i}?.Bar
+{foo: false, foo: i}?.greet
+{foo: false, foo: list, foo: list}?.array
+{foo: false, foo: list}.foobar
+{foo: false, foo: list}?.[str]
+{foo: false, foo: list}?.array?.foo
+{foo: false, foo: nil}.Bar
+{foo: false, foo: nil}.String
+{foo: false, foo: nil}.add
+{foo: false, foo: nil}.foobar?.str
+{foo: false, foo: nil}.greet
+{foo: false, foo: nil}?.String?.array
+{foo: false, foo: nil}?.add
+{foo: false, foo: nil}?.foo
+{foo: false, foo: nil}?.list
+{foo: false, foo: ok}.list
+{foo: false, foo: ok}?.String
+{foo: false, foo: ok}?.greet
+{foo: false, foo: str}.array
+{foo: false, foo: str}?.Bar
+{foo: false, foo: str}?.[str]
+{foo: false, foo: true}.Bar
+{foo: false, foo: true}.add
+{foo: false, foo: true}.ok
+{foo: false, foo: true}?.array
+{foo: false, foo: true}?.list
+{foo: false, foo: true}?.ok
+{foo: false}.Bar
+{foo: false}.String
+{foo: false}.String?.[i]
+{foo: false}.add
+{foo: false}.array
+{foo: false}.array?.greet(foobar)
+{foo: false}.f64
+{foo: false}.f64?.Bar
+{foo: false}.foo
+{foo: false}.foobar
+{foo: false}.greet
+{foo: false}.i
+{foo: false}.list
+{foo: false}.ok
+{foo: false}.ok == i
+{foo: false}.str
+{foo: false}?.$env?.array
+{foo: false}?.Bar
+{foo: false}?.String
+{foo: false}?.[str]
+{foo: false}?.add
+{foo: false}?.array
+{foo: false}?.f64
+{foo: false}?.foo
+{foo: false}?.foobar
+{foo: false}?.greet
+{foo: false}?.i
+{foo: false}?.list
+{foo: false}?.ok
+{foo: false}?.str
+{foo: false}?.str?.[list]
+{foo: filter($env, false)}
+{foo: filter(list, ok)}
+{foo: filter(list, true)}
+{foo: find(array, false)}
+{foo: find(array, true)}
+{foo: find(list, true), foo: foo}
+{foo: findIndex($env, ok)}
+{foo: findIndex($env, true)}
+{foo: findIndex(array, ok)}
+{foo: findIndex(list, true)}
+{foo: first($env)}
+{foo: first($env)}?.foo
+{foo: first(array)}
+{foo: first(list)}
+{foo: flatten(array)}
+{foo: flatten(list)}
+{foo: float(0)}
+{foo: float(1)}
+{foo: float(1.0)}
+{foo: float(1.0)}.i
+{foo: float(1.0)}?.String
+{foo: float(f64)}
+{foo: float(i)}
+{foo: floor(0)}
+{foo: floor(1)}
+{foo: floor(1.0)}
+{foo: floor(f64)}
+{foo: floor(f64)}.add
+{foo: floor(i)}
+{foo: foo != $env}
+{foo: foo != foo}
+{foo: foo != nil}
+{foo: foo == $env}
+{foo: foo == foo}
+{foo: foo == nil}
+{foo: foo not in list}
+{foo: foo, foo: $env, foo: ok}?.array
+{foo: foo, foo: $env.f64}.greet
+{foo: foo, foo: $env?.f64}
+{foo: foo, foo: $env}.Bar
+{foo: foo, foo: $env}.array
+{foo: foo, foo: $env}.foo
+{foo: foo, foo: $env}.list
+{foo: foo, foo: $env}.nil?.[foo]
+{foo: foo, foo: $env}.ok
+{foo: foo, foo: $env}?.Bar
+{foo: foo, foo: $env}?.String
+{foo: foo, foo: $env}?.[str]
+{foo: foo, foo: $env}?.array
+{foo: foo, foo: $env}?.f64
+{foo: foo, foo: $env}?.foo
+{foo: foo, foo: $env}?.i
+{foo: foo, foo: $env}?.ok
+{foo: foo, foo: $env}?.str != foo
+{foo: foo, foo: 0}.foo
+{foo: foo, foo: 0}?.Bar
+{foo: foo, foo: 0}?.add
+{foo: foo, foo: 0}?.f64
+{foo: foo, foo: 0}?.greet
+{foo: foo, foo: 1, foo: greet}?.str
+{foo: foo, foo: 1, foo: list}?.str
+{foo: foo, foo: 1.0, foo: array}.str
+{foo: foo, foo: 1.0}.Bar
+{foo: foo, foo: 1.0}.add
+{foo: foo, foo: 1.0}.array
+{foo: foo, foo: 1.0}.f64
+{foo: foo, foo: 1.0}.foo
+{foo: foo, foo: 1.0}.greet
+{foo: foo, foo: 1.0}.i
+{foo: foo, foo: 1.0}.list
+{foo: foo, foo: 1.0}.ok
+{foo: foo, foo: 1.0}.str
+{foo: foo, foo: 1.0}?.String
+{foo: foo, foo: 1.0}?.[str]
+{foo: foo, foo: 1.0}?.add
+{foo: foo, foo: 1.0}?.array
+{foo: foo, foo: 1.0}?.f64
+{foo: foo, foo: 1.0}?.foo
+{foo: foo, foo: 1.0}?.greet
+{foo: foo, foo: 1.0}?.list
+{foo: foo, foo: 1}.Bar
+{foo: foo, foo: 1}.String
+{foo: foo, foo: 1}.add
+{foo: foo, foo: 1}.f64
+{foo: foo, foo: 1}.foo
+{foo: foo, foo: 1}.i
+{foo: foo, foo: 1}.list
+{foo: foo, foo: 1}.ok
+{foo: foo, foo: 1}?.f64
+{foo: foo, foo: 1}?.str
+{foo: foo, foo: [$env?.add]}
+{foo: foo, foo: add, foo: nil}.f64
+{foo: foo, foo: add}
+{foo: foo, foo: add}.array
+{foo: foo, foo: add}.f64
+{foo: foo, foo: add}.i
+{foo: foo, foo: add}.list
+{foo: foo, foo: add}?.String
+{foo: foo, foo: add}?.f64
+{foo: foo, foo: array, foo: i}.f64
+{foo: foo, foo: array}
+{foo: foo, foo: array}.String
+{foo: foo, foo: array}.foo
+{foo: foo, foo: array}.greet
+{foo: foo, foo: array}.list
+{foo: foo, foo: array}?.String
+{foo: foo, foo: array}?.[str]
+{foo: foo, foo: array}?.foo
+{foo: foo, foo: array}?.greet
+{foo: foo, foo: array}?.i
+{foo: foo, foo: f64, foo: 1.0}?.array
+{foo: foo, foo: f64}
+{foo: foo, foo: f64}.String
+{foo: foo, foo: f64}.array
+{foo: foo, foo: f64}.list
+{foo: foo, foo: f64}.list?.[i]
+{foo: foo, foo: f64}?.add
+{foo: foo, foo: f64}?.f64
+{foo: foo, foo: f64}?.foo
+{foo: foo, foo: false}.String
+{foo: foo, foo: false}.f64
+{foo: foo, foo: false}.str
+{foo: foo, foo: false}?.foo
+{foo: foo, foo: false}?.i
+{foo: foo, foo: foo, foo: foo}.greet
+{foo: foo, foo: foo, foo: greet}
+{foo: foo, foo: foo, foo: ok}?.str
+{foo: foo, foo: foo.Bar}
+{foo: foo, foo: foo}
+{foo: foo, foo: foo}.Bar
+{foo: foo, foo: foo}.String
+{foo: foo, foo: foo}.add
+{foo: foo, foo: foo}.array
+{foo: foo, foo: foo}.f64
+{foo: foo, foo: foo}.foo
+{foo: foo, foo: foo}.greet
+{foo: foo, foo: foo}.list
+{foo: foo, foo: foo}.ok
+{foo: foo, foo: foo}.str
+{foo: foo, foo: foo}?.String
+{foo: foo, foo: foo}?.[str]
+{foo: foo, foo: foo}?.add
+{foo: foo, foo: foo}?.array
+{foo: foo, foo: foo}?.f64
+{foo: foo, foo: foo}?.greet
+{foo: foo, foo: foo}?.list?.f64
+{foo: foo, foo: foo}?.ok
+{foo: foo, foo: foo}?.str
+{foo: foo, foo: greet, foo: 1.0}.list
+{foo: foo, foo: greet}
+{foo: foo, foo: greet}.Bar
+{foo: foo, foo: greet}.String
+{foo: foo, foo: greet}.array
+{foo: foo, foo: greet}.foo
+{foo: foo, foo: greet}.greet
+{foo: foo, foo: greet}.i
+{foo: foo, foo: greet}.str
+{foo: foo, foo: greet}?.array
+{foo: foo, foo: greet}?.f64
+{foo: foo, foo: greet}?.foo
+{foo: foo, foo: greet}?.list
+{foo: foo, foo: i / f64}
+{foo: foo, foo: i, foo: 0}.ok
+{foo: foo, foo: i, foo: 1.0}.array
+{foo: foo, foo: i}
+{foo: foo, foo: i}.Bar
+{foo: foo, foo: i}.String
+{foo: foo, foo: i}.String?.String
+{foo: foo, foo: i}.add
+{foo: foo, foo: i}.foo
+{foo: foo, foo: i}?.[str]
+{foo: foo, foo: i}?.f64
+{foo: foo, foo: i}?.greet
+{foo: foo, foo: i}?.ok
+{foo: foo, foo: i}?.str
+{foo: foo, foo: list, foo: false and false}
+{foo: foo, foo: list, foo: greet}?.f64
+{foo: foo, foo: list}
+{foo: foo, foo: list}.add?.[i]
+{foo: foo, foo: list}.array
+{foo: foo, foo: list}.array?.Bar
+{foo: foo, foo: list}.f64
+{foo: foo, foo: list}.greet
+{foo: foo, foo: list}.ok
+{foo: foo, foo: list}.str
+{foo: foo, foo: list}?.Bar
+{foo: foo, foo: list}?.add
+{foo: foo, foo: list}?.greet
+{foo: foo, foo: list}?.list
+{foo: foo, foo: list}?.str
+{foo: foo, foo: nil in $env}
+{foo: foo, foo: nil, foo: 0}.f64
+{foo: foo, foo: nil, foo: 0}?.f64?.i()
+{foo: foo, foo: nil, foo: nil}.f64
+{foo: foo, foo: nil, foo: ok}?.list
+{foo: foo, foo: nil}.String
+{foo: foo, foo: nil}.add
+{foo: foo, foo: nil}.array
+{foo: foo, foo: nil}.f64
+{foo: foo, foo: nil}.foo
+{foo: foo, foo: nil}.i
+{foo: foo, foo: nil}.ok
+{foo: foo, foo: nil}.ok?.array()
+{foo: foo, foo: nil}.str
+{foo: foo, foo: nil}?.[str]
+{foo: foo, foo: nil}?.add
+{foo: foo, foo: nil}?.greet
+{foo: foo, foo: nil}?.i
+{foo: foo, foo: nil}?.list
+{foo: foo, foo: ok}
+{foo: foo, foo: ok}.add
+{foo: foo, foo: ok}?.String
+{foo: foo, foo: ok}?.[str]
+{foo: foo, foo: ok}?.add
+{foo: foo, foo: ok}?.array
+{foo: foo, foo: ok}?.f64
+{foo: foo, foo: str, foo: 1.0}.Bar
+{foo: foo, foo: str, foo: list}?.String
+{foo: foo, foo: str}
+{foo: foo, foo: str}.String
+{foo: foo, foo: str}.i
+{foo: foo, foo: str}.ok
+{foo: foo, foo: str}?.Bar
+{foo: foo, foo: str}?.add
+{foo: foo, foo: str}?.array
+{foo: foo, foo: str}?.f64?.ok
+{foo: foo, foo: str}?.foo
+{foo: foo, foo: str}?.greet
+{foo: foo, foo: str}?.str
+{foo: foo, foo: true, foo: $env}?.add
+{foo: foo, foo: true, foo: nil}?.Bar
+{foo: foo, foo: true, foo: nil}?.i
+{foo: foo, foo: true}.Bar
+{foo: foo, foo: true}.add
+{foo: foo, foo: true}.foo
+{foo: foo, foo: true}?.String
+{foo: foo, foo: true}?.[str]
+{foo: foo, foo: true}?.add
+{foo: foo, foo: true}?.f64
+{foo: foo, foo: true}?.list
+{foo: foo, foo: true}?.str?.i
+{foo: foo, foo: {foo: foo}}
+{foo: foo.Bar, foo: false ? foo : str}?.ok
+{foo: foo.Bar, foo: greet}
+{foo: foo.Bar}
+{foo: foo.Bar}.greet
+{foo: foo.Bar}?.f64
+{foo: foo.String() not matches str}
+{foo: foo.String()}
+{foo: foo.String, foo: ok}
+{foo: foo.String}
+{foo: foo.String}.String
+{foo: foo.String}.add
+{foo: foo.String}.array
+{foo: foo.String}.str
+{foo: foo?.Bar}
+{foo: foo?.Bar}?.list
+{foo: foo?.String()}
+{foo: foo?.String, foo: f64}
+{foo: foo?.String, foo: greet}
+{foo: foo?.String, foo: str}
+{foo: foo?.String}
+{foo: foo?.String}.array
+{foo: foo?.String}?.Bar
+{foo: foo}
+{foo: foo}.Bar
+{foo: foo}.String
+{foo: foo}.add
+{foo: foo}.array
+{foo: foo}.array?.[str]
+{foo: foo}.array?.greet()
+{foo: foo}.array?.i
+{foo: foo}.f64
+{foo: foo}.f64?.[array]
+{foo: foo}.f64?.i
+{foo: foo}.false?.f64
+{foo: foo}.foo
+{foo: foo}.foobar
+{foo: foo}.foobar?.greet
+{foo: foo}.greet
+{foo: foo}.greet != f64
+{foo: foo}.greet?.[f64]
+{foo: foo}.greet?.[ok]
+{foo: foo}.i
+{foo: foo}.list
+{foo: foo}.list?.[f64]
+{foo: foo}.list?.[str]?.foobar
+{foo: foo}.ok
+{foo: foo}.ok?.[add].add()
+{foo: foo}.ok?.f64
+{foo: foo}.str
+{foo: foo}?.Bar
+{foo: foo}?.String
+{foo: foo}?.String?.Bar
+{foo: foo}?.String?.String()
+{foo: foo}?.[str]
+{foo: foo}?.[str]?.String
+{foo: foo}?.add
+{foo: foo}?.add?.f64(foobar, foobar)
+{foo: foo}?.array
+{foo: foo}?.array?.i
+{foo: foo}?.f64
+{foo: foo}?.f64?.str
+{foo: foo}?.foo
+{foo: foo}?.foobar
+{foo: foo}?.foobar == foo
+{foo: foo}?.foobar?.greet(foobar)
+{foo: foo}?.greet
+{foo: foo}?.greet?.[f64]
+{foo: foo}?.greet?.[i]
+{foo: foo}?.i
+{foo: foo}?.list
+{foo: foo}?.list?.[add]?.str
+{foo: foo}?.ok
+{foo: foo}?.ok?.Bar
+{foo: foo}?.ok?.[i]
+{foo: foo}?.ok?.f64()
+{foo: foo}?.ok?.greet()?.f64()
+{foo: foo}?.ok?.ok
+{foo: foo}?.str
+{foo: foo}?.str?.add
+{foo: foo}?.str?.f64
+{foo: greet != $env}
+{foo: greet != nil}
+{foo: greet == $env}
+{foo: greet == greet}
+{foo: greet($env?.[str])}
+{foo: greet(str)}
+{foo: greet(str)}.str
+{foo: greet, foo: $env.f64}
+{foo: greet, foo: $env?.ok}
+{foo: greet, foo: $env?.str}
+{foo: greet, foo: $env}.String
+{foo: greet, foo: $env}.add
+{foo: greet, foo: $env}.str
+{foo: greet, foo: $env}?.String
+{foo: greet, foo: $env}?.array
+{foo: greet, foo: $env}?.greet
+{foo: greet, foo: $env}?.ok
+{foo: greet, foo: 0}.foo
+{foo: greet, foo: 0}?.Bar
+{foo: greet, foo: 0}?.add
+{foo: greet, foo: 0}?.f64
+{foo: greet, foo: 0}?.ok
+{foo: greet, foo: 1.0}.String
+{foo: greet, foo: 1.0}.i
+{foo: greet, foo: 1.0}.ok
+{foo: greet, foo: 1.0}.str
+{foo: greet, foo: 1.0}?.Bar
+{foo: greet, foo: 1.0}?.String
+{foo: greet, foo: 1.0}?.array
+{foo: greet, foo: 1.0}?.list
+{foo: greet, foo: 1.0}?.str
+{foo: greet, foo: 1}?.[str]
+{foo: greet, foo: 1}?.ok
+{foo: greet, foo: [$env]}
+{foo: greet, foo: add}
+{foo: greet, foo: add}.foo
+{foo: greet, foo: add}?.f64
+{foo: greet, foo: array}
+{foo: greet, foo: array}.array
+{foo: greet, foo: array}?.array
+{foo: greet, foo: f64}
+{foo: greet, foo: false, foo: foo}.String
+{foo: greet, foo: false}.f64
+{foo: greet, foo: false}.greet
+{foo: greet, foo: false}.str
+{foo: greet, foo: false}?.f64
+{foo: greet, foo: false}?.str
+{foo: greet, foo: float(f64)}
+{foo: greet, foo: foo != foo}
+{foo: greet, foo: foo, foo: array}
+{foo: greet, foo: foo, foo: greet}?.add
+{foo: greet, foo: foo}
+{foo: greet, foo: foo}.String
+{foo: greet, foo: foo}.add
+{foo: greet, foo: foo}.f64
+{foo: greet, foo: foo}.foo
+{foo: greet, foo: foo}.greet
+{foo: greet, foo: foo}.i
+{foo: greet, foo: foo}.list
+{foo: greet, foo: foo}.ok
+{foo: greet, foo: foo}?.add
+{foo: greet, foo: foo}?.foo
+{foo: greet, foo: foo}?.i
+{foo: greet, foo: foo}?.list
+{foo: greet, foo: greet}
+{foo: greet, foo: greet}?.str
+{foo: greet, foo: i == 1.0}
+{foo: greet, foo: i}
+{foo: greet, foo: i}?.String
+{foo: greet, foo: list}
+{foo: greet, foo: list}.list
+{foo: greet, foo: nil}?.[str]
+{foo: greet, foo: nil}?.greet
+{foo: greet, foo: nil}?.ok
+{foo: greet, foo: ok}
+{foo: greet, foo: ok}?.array
+{foo: greet, foo: ok}?.list
+{foo: greet, foo: ok}?.ok
+{foo: greet, foo: ok}?.str
+{foo: greet, foo: str}
+{foo: greet, foo: str}.Bar
+{foo: greet, foo: str}?.f64
+{foo: greet, foo: trimPrefix(str)}
+{foo: greet, foo: true}?.String
+{foo: greet, foo: true}?.greet
+{foo: greet}
+{foo: greet}.Bar
+{foo: greet}.Bar?.ok
+{foo: greet}.String
+{foo: greet}.String?.str()
+{foo: greet}.add
+{foo: greet}.array
+{foo: greet}.f64
+{foo: greet}.f64?.String
+{foo: greet}.foo
+{foo: greet}.foobar
+{foo: greet}.foobar?.[1.0]
+{foo: greet}.foobar?.[foo]
+{foo: greet}.greet
+{foo: greet}.greet?.i
+{foo: greet}.i
+{foo: greet}.list
+{foo: greet}.ok
+{foo: greet}.ok?.Bar
+{foo: greet}.ok?.add
+{foo: greet}.str
+{foo: greet}?.Bar
+{foo: greet}?.String
+{foo: greet}?.[str]
+{foo: greet}?.add
+{foo: greet}?.array
+{foo: greet}?.array?.[array]
+{foo: greet}?.f64
+{foo: greet}?.foo
+{foo: greet}?.foobar
+{foo: greet}?.foobar?.[foo]
+{foo: greet}?.foobar?.[ok]
+{foo: greet}?.greet
+{foo: greet}?.i
+{foo: greet}?.i?.[str]
+{foo: greet}?.list
+{foo: greet}?.list?.f64()
+{foo: greet}?.list?.i
+{foo: greet}?.ok
+{foo: greet}?.ok?.[foo]
+{foo: greet}?.str
+{foo: groupBy(array, #)}
+{foo: groupBy(array, f64)}
+{foo: groupBy(array, false)}
+{foo: groupBy(array, foo)}
+{foo: groupBy(list, #)}
+{foo: groupBy(list, foo)}
+{foo: groupBy(list, i)}
+{foo: groupBy(list, ok)}
+{foo: i != $env}?.String
+{foo: i != 1.0}
+{foo: i % 1}
+{foo: i * 0}
+{foo: i * 1.0}
+{foo: i * f64}
+{foo: i * i}
+{foo: i ** 1, foo: ok}.f64
+{foo: i ** 1.0}
+{foo: i ** 1}
+{foo: i ** f64}
+{foo: i + 0}
+{foo: i + f64}
+{foo: i - 1}
+{foo: i .. 1, foo: i}
+{foo: i .. i}
+{foo: i / 0}
+{foo: i / 1, foo: string(false)}
+{foo: i / 1.0}
+{foo: i < 0}
+{foo: i < 1.0}
+{foo: i < 1}
+{foo: i <= 1.0}
+{foo: i <= f64}
+{foo: i == $env}?.Bar
+{foo: i == nil}
+{foo: i > 0, foo: 1 >= f64}
+{foo: i >= 1.0}
+{foo: i >= 1}
+{foo: i >= f64}.str
+{foo: i ^ 0}
+{foo: i ^ 1.0}
+{foo: i ^ 1}
+{foo: i ^ i}
+{foo: i not in array}
+{foo: i not in array}?.greet
+{foo: i | bitnand(1)}
+{foo: i | bitor(i)}
+{foo: i | bitxor(i)}
+{foo: i, foo: $env != foo}
+{foo: i, foo: $env, foo: nil}?.add
+{foo: i, foo: $env?.[Bar]}
+{foo: i, foo: $env}.foo
+{foo: i, foo: $env}.ok
+{foo: i, foo: 0}.greet
+{foo: i, foo: 0}?.ok?.str
+{foo: i, foo: 1 - f64}
+{foo: i, foo: 1.0, foo: foo}?.[str]
+{foo: i, foo: 1.0, foo: foo}?.str
+{foo: i, foo: 1.0}.Bar
+{foo: i, foo: 1.0}.String
+{foo: i, foo: 1.0}.f64
+{foo: i, foo: 1.0}.f64?.ok
+{foo: i, foo: 1.0}.foobar?.ok
+{foo: i, foo: 1.0}.i
+{foo: i, foo: 1.0}.ok
+{foo: i, foo: 1.0}?.String
+{foo: i, foo: 1.0}?.f64
+{foo: i, foo: 1.0}?.str
+{foo: i, foo: 1}.f64
+{foo: i, foo: 1}?.array
+{foo: i, foo: add}
+{foo: i, foo: add}.i
+{foo: i, foo: add}.str
+{foo: i, foo: add}?.str
+{foo: i, foo: array}
+{foo: i, foo: array}.greet
+{foo: i, foo: array}.i
+{foo: i, foo: array}.list
+{foo: i, foo: array}.str
+{foo: i, foo: f64}
+{foo: i, foo: f64}.f64
+{foo: i, foo: f64}.foo
+{foo: i, foo: f64}.foobar?.f64(foo)
+{foo: i, foo: f64}?.i
+{foo: i, foo: false}.array
+{foo: i, foo: false}.str
+{foo: i, foo: false}?.Bar
+{foo: i, foo: false}?.String
+{foo: i, foo: false}?.str
+{foo: i, foo: foo, foo: $env}.ok
+{foo: i, foo: foo}
+{foo: i, foo: foo}.list
+{foo: i, foo: foo}?.String
+{foo: i, foo: foo}?.list
+{foo: i, foo: foo}?.list == foo
+{foo: i, foo: foo}?.str
+{foo: i, foo: greet(str)}
+{foo: i, foo: greet}
+{foo: i, foo: greet}.foo
+{foo: i, foo: i >= 1}
+{foo: i, foo: i}
+{foo: i, foo: i}.f64
+{foo: i, foo: i}.foo
+{foo: i, foo: i}?.[str]
+{foo: i, foo: list}
+{foo: i, foo: list}?.list
+{foo: i, foo: map(list, foo)}
+{foo: i, foo: nil}.array
+{foo: i, foo: nil}.foo
+{foo: i, foo: nil}.list
+{foo: i, foo: nil}?.Bar
+{foo: i, foo: nil}?.[str]
+{foo: i, foo: nil}?.foo
+{foo: i, foo: nil}?.list
+{foo: i, foo: ok, foo: 1.0}?.ok
+{foo: i, foo: ok}
+{foo: i, foo: str}
+{foo: i, foo: str}.array
+{foo: i, foo: str}.foo
+{foo: i, foo: str}.foobar?.i()
+{foo: i, foo: str}?.add?.[str]
+{foo: i, foo: str}?.f64
+{foo: i, foo: str}?.list
+{foo: i, foo: true}.foo
+{foo: i, foo: true}?.f64
+{foo: i, foo: {foo: str}}
+{foo: if false { foo } else { $env }}
+{foo: if false { str } else { array }}
+{foo: if true { $env } else { array }}
+{foo: if true { 1.0 } else { foo }}
+{foo: if true { foo } else { greet }}
+{foo: if true { ok } else { foo }}
+{foo: int(0)}
+{foo: int(1)}
+{foo: int(1.0)}
+{foo: int(f64)}
+{foo: int(f64)}?.foobar?.list()
+{foo: int(i)}
+{foo: i}
+{foo: i}.$env?.Bar(Bar)
+{foo: i}.Bar
+{foo: i}.String
+{foo: i}.String?.i
+{foo: i}.add
+{foo: i}.add?.add
+{foo: i}.array
+{foo: i}.array?.Bar
+{foo: i}.array?.[str]
+{foo: i}.f64
+{foo: i}.f64?.[foo]
+{foo: i}.f64?.[list]
+{foo: i}.foo
+{foo: i}.foobar
+{foo: i}.greet
+{foo: i}.greet?.add
+{foo: i}.i
+{foo: i}.list
+{foo: i}.nil?.array
+{foo: i}.not
+{foo: i}.ok
+{foo: i}.str
+{foo: i}?.Bar
+{foo: i}?.Bar?.String
+{foo: i}?.String
+{foo: i}?.[str]
+{foo: i}?.add
+{foo: i}?.array
+{foo: i}?.array?.[foo]
+{foo: i}?.array?.greet
+{foo: i}?.f64
+{foo: i}?.foo
+{foo: i}?.foo == add
+{foo: i}?.foobar
+{foo: i}?.greet
+{foo: i}?.greet?.ok
+{foo: i}?.i
+{foo: i}?.i?.f64
+{foo: i}?.list
+{foo: i}?.ok
+{foo: i}?.str
+{foo: keys($env), foo: list}
+{foo: keys($env)}
+{foo: keys($env)}?.list
+{foo: last($env)?.String}
+{foo: last($env)}
+{foo: last(array)}
+{foo: last(list)}
+{foo: len($env)}
+{foo: len(array)}
+{foo: len(list)}
+{foo: let foobar = false; foobar}
+{foo: let foobar = str; foobar}
+{foo: list != $env}
+{foo: list != list}
+{foo: list != nil}
+{foo: list == $env?.[str]}
+{foo: list == $env}
+{foo: list == list}
+{foo: list == nil}
+{foo: list | count(false)}
+{foo: list | findIndex(true)}.add
+{foo: list | groupBy(#)}
+{foo: list | groupBy(foo)}
+{foo: list | groupBy(ok)}
+{foo: list | groupBy(str)}
+{foo: list | one(false)}
+{foo: list | reduce(#.Bar, nil)}
+{foo: list | reduce(#.String, nil)}
+{foo: list | reduce(0)}
+{foo: list | reduce(false)}
+{foo: list | reduce(foo)}
+{foo: list | sortBy(.Bar)}
+{foo: list | sum(1.0)}
+{foo: list, foo: $env}.i
+{foo: list, foo: $env}.list
+{foo: list, foo: $env}.ok
+{foo: list, foo: $env}.str
+{foo: list, foo: $env}?.Bar
+{foo: list, foo: $env}?.add
+{foo: list, foo: $env}?.ok
+{foo: list, foo: $env}?.str
+{foo: list, foo: 0, foo: 0}?.add
+{foo: list, foo: 0, foo: nil}.add
+{foo: list, foo: 1.0 == 1.0}
+{foo: list, foo: 1.0}.foo
+{foo: list, foo: 1.0}.list
+{foo: list, foo: 1.0}?.[str]
+{foo: list, foo: 1.0}?.greet
+{foo: list, foo: 1.0}?.ok
+{foo: list, foo: 1}.list
+{foo: list, foo: 1}?.String
+{foo: list, foo: 1}?.foo
+{foo: list, foo: 1}?.greet
+{foo: list, foo: 1}?.i
+{foo: list, foo: add}
+{foo: list, foo: add}.array
+{foo: list, foo: add}.i
+{foo: list, foo: add}?.array
+{foo: list, foo: add}?.f64
+{foo: list, foo: array}
+{foo: list, foo: array}.greet
+{foo: list, foo: array}.i
+{foo: list, foo: array}?.array
+{foo: list, foo: array}?.ok
+{foo: list, foo: f64 - f64}
+{foo: list, foo: f64}
+{foo: list, foo: f64}.greet
+{foo: list, foo: f64}?.Bar
+{foo: list, foo: false}.foobar
+{foo: list, foo: false}?.add
+{foo: list, foo: false}?.f64
+{foo: list, foo: foo, foo: list}.Bar
+{foo: list, foo: foo?.String()}
+{foo: list, foo: foo}
+{foo: list, foo: foo}.add
+{foo: list, foo: foo}.array
+{foo: list, foo: foo}.f64
+{foo: list, foo: foo}?.Bar
+{foo: list, foo: foo}?.add
+{foo: list, foo: foo}?.foo
+{foo: list, foo: greet}
+{foo: list, foo: greet}.list
+{foo: list, foo: greet}?.greet
+{foo: list, foo: i, foo: 1.0}?.list
+{foo: list, foo: i}
+{foo: list, foo: i}.array
+{foo: list, foo: i}?.String?.add()
+{foo: list, foo: i}?.foo
+{foo: list, foo: i}?.list
+{foo: list, foo: list}
+{foo: list, foo: list}.Bar
+{foo: list, foo: list}.String
+{foo: list, foo: list}.foo
+{foo: list, foo: list}?.String
+{foo: list, foo: list}?.foo
+{foo: list, foo: list}?.list
+{foo: list, foo: list}?.ok
+{foo: list, foo: max(0)}
+{foo: list, foo: median(array)}
+{foo: list, foo: nil}.String
+{foo: list, foo: nil}.list
+{foo: list, foo: nil}?.[str]
+{foo: list, foo: nil}?.str
+{foo: list, foo: ok}
+{foo: list, foo: ok}.add
+{foo: list, foo: ok}?.Bar
+{foo: list, foo: ok}?.[str]
+{foo: list, foo: str}
+{foo: list, foo: str}.array
+{foo: list, foo: str}?.String
+{foo: list, foo: str}?.ok
+{foo: list, foo: sum(array)}
+{foo: list, foo: true, foo: add}?.ok
+{foo: list, foo: true, foo: foo}.list
+{foo: list, foo: true}.ok
+{foo: list, foo: true}?.array
+{foo: list?.[0]}
+{foo: list?.[1]}?.add
+{foo: list?.[i], foo: list}
+{foo: list?.[i], foo: ok}
+{foo: list?.[i]}
+{foo: list?.[i]}.ok
+{foo: list[:0]}
+{foo: list}
+{foo: list}.Bar
+{foo: list}.String
+{foo: list}.add
+{foo: list}.add?.str
+{foo: list}.array
+{foo: list}.array?.f64
+{foo: list}.f64
+{foo: list}.f64?.greet().list()
+{foo: list}.foo
+{foo: list}.foobar
+{foo: list}.foobar != true
+{foo: list}.greet
+{foo: list}.greet?.[str]
+{foo: list}.i
+{foo: list}.i?.[array]
+{foo: list}.list
+{foo: list}.list?.[greet]
+{foo: list}.ok
+{foo: list}.ok?.Bar
+{foo: list}.str
+{foo: list}?.Bar
+{foo: list}?.Bar?.[foo]
+{foo: list}?.Bar?.[list]
+{foo: list}?.String
+{foo: list}?.String?.list()
+{foo: list}?.[str]
+{foo: list}?.[str]?.[i]
+{foo: list}?.[str]?.list
+{foo: list}?.add
+{foo: list}?.array
+{foo: list}?.f64
+{foo: list}?.f64?.ok
+{foo: list}?.foo
+{foo: list}?.foobar
+{foo: list}?.greet
+{foo: list}?.greet?.list
+{foo: list}?.i
+{foo: list}?.list
+{foo: list}?.ok
+{foo: list}?.ok?.[ok]
+{foo: list}?.str
+{foo: list}?.str?.[list]
+{foo: lower(str)}
+{foo: map($env, $env)}
+{foo: map($env, 1)}
+{foo: map($env, 1.0)}
+{foo: map($env, array)}
+{foo: map($env, foo)}
+{foo: map($env, greet)}
+{foo: map($env, i)}
+{foo: map($env, i)}?.add
+{foo: map($env, list)}
+{foo: map($env, ok)}
+{foo: map(array, #)}
+{foo: map(array, $env)}
+{foo: map(array, 1)}
+{foo: map(array, array)}
+{foo: map(array, foo)}
+{foo: map(list, #)}
+{foo: map(list, #.Bar)}
+{foo: map(list, $env)}
+{foo: map(list, add)}
+{foo: map(list, foo)}
+{foo: map(list, greet)}
+{foo: map(list, ok)}
+{foo: max($env)}
+{foo: max($env)}.i
+{foo: max(1)}
+{foo: max(1.0)}
+{foo: max(array)}
+{foo: max(f64)}
+{foo: max(i)}
+{foo: mean(0)}
+{foo: mean(1.0 * 1.0)}
+{foo: mean(1.0), foo: array}
+{foo: mean(1.0)}
+{foo: mean(1.0)}.ok
+{foo: mean(array)}
+{foo: mean(array, array)}
+{foo: mean(array, i)}
+{foo: mean(f64)}
+{foo: mean(i)}
+{foo: median(0)}
+{foo: median(1)}
+{foo: median(1.0)}
+{foo: median(f64)}
+{foo: median(flatten(array))}
+{foo: median(i)}
+{foo: median(i, array)}.Bar
+{foo: min($env)?.String}
+{foo: min($env)}
+{foo: min(1), foo: ok}
+{foo: min(1)}
+{foo: min(1.0)}
+{foo: min(1.0)}?.String
+{foo: min(array)}
+{foo: min(f64)}
+{foo: min(i)}
+{foo: min(i)}.list
+{foo: nil != $env}
+{foo: nil != 0}
+{foo: nil != 1.0}
+{foo: nil != add}
+{foo: nil != array}
+{foo: nil != f64}
+{foo: nil != foo}
+{foo: nil != greet}
+{foo: nil != list}
+{foo: nil != nil, foo: list}
+{foo: nil != nil}
+{foo: nil != ok}
+{foo: nil != str}
+{foo: nil != true}
+{foo: nil == $env}
+{foo: nil == 0}
+{foo: nil == 1.0}
+{foo: nil == add}
+{foo: nil == array}
+{foo: nil == false}
+{foo: nil == foo}
+{foo: nil == list}?.Bar
+{foo: nil == nil}
+{foo: nil == ok}
+{foo: nil in $env}
+{foo: nil in array}
+{foo: nil in list}
+{foo: nil not in $env}
+{foo: nil, foo: $env}.Bar
+{foo: nil, foo: $env}.String
+{foo: nil, foo: $env}.add
+{foo: nil, foo: $env}.f64
+{foo: nil, foo: $env}.foo
+{foo: nil, foo: $env}.foobar
+{foo: nil, foo: $env}.greet
+{foo: nil, foo: $env}.list
+{foo: nil, foo: $env}?.Bar
+{foo: nil, foo: $env}?.Bar?.[f64]
+{foo: nil, foo: $env}?.String
+{foo: nil, foo: $env}?.foo
+{foo: nil, foo: $env}?.list
+{foo: nil, foo: $env}?.str
+{foo: nil, foo: 0, foo: 0}.greet
+{foo: nil, foo: 0, foo: true}?.[str]
+{foo: nil, foo: 0}.f64
+{foo: nil, foo: 0}.list
+{foo: nil, foo: 0}?.Bar
+{foo: nil, foo: 0}?.String?.[f64]
+{foo: nil, foo: 0}?.add
+{foo: nil, foo: 0}?.greet
+{foo: nil, foo: 1, foo: false}?.String
+{foo: nil, foo: 1, foo: foo}.ok
+{foo: nil, foo: 1.0}.array
+{foo: nil, foo: 1.0}.foo
+{foo: nil, foo: 1.0}.greet
+{foo: nil, foo: 1.0}.list
+{foo: nil, foo: 1.0}?.String
+{foo: nil, foo: 1.0}?.[str]
+{foo: nil, foo: 1.0}?.array
+{foo: nil, foo: 1.0}?.f64
+{foo: nil, foo: 1.0}?.greet
+{foo: nil, foo: 1.0}?.i
+{foo: nil, foo: 1.0}?.ok
+{foo: nil, foo: 1.0}?.str
+{foo: nil, foo: 1}.String
+{foo: nil, foo: 1}.array
+{foo: nil, foo: 1}.f64
+{foo: nil, foo: 1}.list
+{foo: nil, foo: 1}?.foo
+{foo: nil, foo: add}.i
+{foo: nil, foo: add}.list
+{foo: nil, foo: add}?.String
+{foo: nil, foo: add}?.foo
+{foo: nil, foo: add}?.i
+{foo: nil, foo: array, foo: add}?.add
+{foo: nil, foo: array}.str
+{foo: nil, foo: array}?.[str]
+{foo: nil, foo: array}?.array
+{foo: nil, foo: array}?.f64
+{foo: nil, foo: array}?.foobar
+{foo: nil, foo: array}?.greet
+{foo: nil, foo: f64}.String
+{foo: nil, foo: f64}.add
+{foo: nil, foo: f64}.greet
+{foo: nil, foo: f64}?.ok
+{foo: nil, foo: false}.Bar
+{foo: nil, foo: false}.f64
+{foo: nil, foo: false}?.f64
+{foo: nil, foo: false}?.greet
+{foo: nil, foo: false}?.i
+{foo: nil, foo: false}?.ok
+{foo: nil, foo: foo, foo: false}?.array
+{foo: nil, foo: foo, foo: i}?.i
+{foo: nil, foo: foo, foo: list}.Bar
+{foo: nil, foo: foo}.String
+{foo: nil, foo: foo}.add
+{foo: nil, foo: foo}.array
+{foo: nil, foo: foo}.foo
+{foo: nil, foo: foo}.ok
+{foo: nil, foo: foo}.str
+{foo: nil, foo: foo}?.Bar
+{foo: nil, foo: foo}?.[str]
+{foo: nil, foo: foo}?.f64
+{foo: nil, foo: foo}?.i
+{foo: nil, foo: foo}?.ok
+{foo: nil, foo: greet}.String
+{foo: nil, foo: greet}?.f64
+{foo: nil, foo: greet}?.foo
+{foo: nil, foo: greet}?.greet
+{foo: nil, foo: greet}?.str
+{foo: nil, foo: i, foo: greet}?.String
+{foo: nil, foo: i}.f64
+{foo: nil, foo: i}.foo
+{foo: nil, foo: i}.i
+{foo: nil, foo: i}.ok
+{foo: nil, foo: i}?.array
+{foo: nil, foo: list, foo: add}.Bar
+{foo: nil, foo: list, foo: nil}.f64
+{foo: nil, foo: list}.Bar
+{foo: nil, foo: list}.f64
+{foo: nil, foo: list}.f64?.str
+{foo: nil, foo: list}?.Bar
+{foo: nil, foo: nil, foo: greet}?.[str]
+{foo: nil, foo: nil, foo: true}?.greet
+{foo: nil, foo: nil}.array
+{foo: nil, foo: nil}.foo
+{foo: nil, foo: nil}.greet
+{foo: nil, foo: nil}.ok
+{foo: nil, foo: nil}?.Bar
+{foo: nil, foo: nil}?.String
+{foo: nil, foo: nil}?.add
+{foo: nil, foo: nil}?.foo
+{foo: nil, foo: nil}?.str
+{foo: nil, foo: ok, foo: nil}.String
+{foo: nil, foo: ok}.String
+{foo: nil, foo: ok}.array
+{foo: nil, foo: ok}.f64
+{foo: nil, foo: ok}.i
+{foo: nil, foo: ok}?.Bar?.[add]
+{foo: nil, foo: str}.String
+{foo: nil, foo: str}.f64
+{foo: nil, foo: str}.i
+{foo: nil, foo: str}.ok
+{foo: nil, foo: str}.str
+{foo: nil, foo: str}?.f64
+{foo: nil, foo: true}.String
+{foo: nil, foo: true}.f64
+{foo: nil, foo: true}.ok
+{foo: nil, foo: true}?.i
+{foo: nil, foo: true}?.ok
+{foo: nil}.Bar
+{foo: nil}.Bar?.f64
+{foo: nil}.String
+{foo: nil}.String?.[i]
+{foo: nil}.String?.array
+{foo: nil}.String?.greet
+{foo: nil}.add
+{foo: nil}.add?.[ok]
+{foo: nil}.array
+{foo: nil}.array?.[array]
+{foo: nil}.array?.[foo]
+{foo: nil}.array?.[str]
+{foo: nil}.array?.str
+{foo: nil}.f64
+{foo: nil}.foo
+{foo: nil}.foo?.[list]
+{foo: nil}.foobar?.i
+{foo: nil}.greet
+{foo: nil}.greet?.[foo]
+{foo: nil}.i
+{foo: nil}.list
+{foo: nil}.not
+{foo: nil}.ok
+{foo: nil}.str
+{foo: nil}?.Bar
+{foo: nil}?.String
+{foo: nil}?.[str]
+{foo: nil}?.[str]?.[list]
+{foo: nil}?.[str]?.[str]
+{foo: nil}?.[str]?.ok
+{foo: nil}?.add
+{foo: nil}?.array
+{foo: nil}?.f64
+{foo: nil}?.f64?.[i]
+{foo: nil}?.foo
+{foo: nil}?.foo?.[f64]
+{foo: nil}?.foo?.i
+{foo: nil}?.foobar?.add
+{foo: nil}?.greet
+{foo: nil}?.i
+{foo: nil}?.i?.[greet]
+{foo: nil}?.list
+{foo: nil}?.list?.f64(foobar)
+{foo: nil}?.ok
+{foo: nil}?.str
+{foo: none(list, ok)}
+{foo: ok != $env}
+{foo: ok != nil}
+{foo: ok && false}
+{foo: ok && ok}
+{foo: ok == $env}
+{foo: ok == $env}.String
+{foo: ok == nil}
+{foo: ok == true}
+{foo: ok ? add : f64}
+{foo: ok ? foo : 0}
+{foo: ok ? greet : list}
+{foo: ok ? nil : foo}
+{foo: ok ?: array}
+{foo: ok and $env}
+{foo: ok or $env}
+{foo: ok or false}
+{foo: ok || $env}
+{foo: ok, foo: $env.add}
+{foo: ok, foo: $env?.i, foo: str}
+{foo: ok, foo: $env}?.Bar
+{foo: ok, foo: $env}?.String
+{foo: ok, foo: $env}?.add
+{foo: ok, foo: $env}?.f64
+{foo: ok, foo: $env}?.str
+{foo: ok, foo: 0 > i}
+{foo: ok, foo: 0, foo: 1.0}.String
+{foo: ok, foo: 0}.Bar
+{foo: ok, foo: 0}.ok
+{foo: ok, foo: 0}?.list
+{foo: ok, foo: 0}?.str
+{foo: ok, foo: 1, foo: nil}?.str
+{foo: ok, foo: 1.0 - i}
+{foo: ok, foo: 1.0}.f64
+{foo: ok, foo: 1.0}.greet
+{foo: ok, foo: 1.0}.list
+{foo: ok, foo: 1.0}.ok
+{foo: ok, foo: 1.0}.str
+{foo: ok, foo: 1.0}?.Bar
+{foo: ok, foo: 1.0}?.foo
+{foo: ok, foo: 1.0}?.greet
+{foo: ok, foo: 1.0}?.ok
+{foo: ok, foo: 1}.array
+{foo: ok, foo: 1}?.[str]
+{foo: ok, foo: 1}?.add?.String
+{foo: ok, foo: add}
+{foo: ok, foo: add}.greet
+{foo: ok, foo: add}.i
+{foo: ok, foo: add}?.foo
+{foo: ok, foo: add}?.greet?.ok
+{foo: ok, foo: array}
+{foo: ok, foo: array}.String
+{foo: ok, foo: array}?.String
+{foo: ok, foo: array}?.foo
+{foo: ok, foo: array}?.list
+{foo: ok, foo: f64}
+{foo: ok, foo: f64}.greet
+{foo: ok, foo: f64}.i
+{foo: ok, foo: f64}?.Bar
+{foo: ok, foo: f64}?.array
+{foo: ok, foo: f64}?.f64
+{foo: ok, foo: f64}?.foo
+{foo: ok, foo: f64}?.greet
+{foo: ok, foo: false}?.String
+{foo: ok, foo: false}?.ok
+{foo: ok, foo: foo?.Bar}
+{foo: ok, foo: foo}
+{foo: ok, foo: foo}.Bar
+{foo: ok, foo: foo}.f64
+{foo: ok, foo: foo}.i
+{foo: ok, foo: foo}.ok
+{foo: ok, foo: foo}.str
+{foo: ok, foo: foo}?.Bar
+{foo: ok, foo: greet}
+{foo: ok, foo: greet}.i
+{foo: ok, foo: greet}?.greet
+{foo: ok, foo: i, foo: true}.foo
+{foo: ok, foo: i}
+{foo: ok, foo: i}.Bar
+{foo: ok, foo: i}?.list
+{foo: ok, foo: list}
+{foo: ok, foo: list}?.array
+{foo: ok, foo: list}?.foo
+{foo: ok, foo: mean(0)}
+{foo: ok, foo: nil, foo: $env}?.ok
+{foo: ok, foo: nil, foo: greet}.i
+{foo: ok, foo: nil, foo: greet}?.add
+{foo: ok, foo: nil}.add
+{foo: ok, foo: nil}.foo
+{foo: ok, foo: nil}.greet
+{foo: ok, foo: nil}.i
+{foo: ok, foo: nil}?.foo
+{foo: ok, foo: nil}?.ok
+{foo: ok, foo: nil}?.str
+{foo: ok, foo: ok}
+{foo: ok, foo: ok}.f64
+{foo: ok, foo: ok}?.list
+{foo: ok, foo: str}
+{foo: ok, foo: str}.f64
+{foo: ok, foo: str}?.f64
+{foo: ok, foo: str}?.list
+{foo: ok, foo: true}.true?.add
+{foo: ok, foo: true}?.Bar
+{foo: ok, foo: true}?.array?.greet
+{foo: ok, foo: true}?.list
+{foo: ok, foo: true}?.ok
+{foo: ok}
+{foo: ok}.Bar
+{foo: ok}.String
+{foo: ok}.add
+{foo: ok}.array
+{foo: ok}.f64
+{foo: ok}.foo
+{foo: ok}.foobar
+{foo: ok}.greet
+{foo: ok}.i
+{foo: ok}.i?.[list]
+{foo: ok}.list
+{foo: ok}.ok
+{foo: ok}.ok?.greet
+{foo: ok}.str
+{foo: ok}?.Bar
+{foo: ok}?.Bar?.[list]
+{foo: ok}?.String
+{foo: ok}?.String?.[i]
+{foo: ok}?.String?.[str]
+{foo: ok}?.[str]
+{foo: ok}?.add
+{foo: ok}?.add?.String?.ok
+{foo: ok}?.array
+{foo: ok}?.array?.i
+{foo: ok}?.array?.str
+{foo: ok}?.f64
+{foo: ok}?.foo
+{foo: ok}?.greet
+{foo: ok}?.i
+{foo: ok}?.i?.ok
+{foo: ok}?.list
+{foo: ok}?.ok
+{foo: ok}?.str
+{foo: one(array, true)}
+{foo: one(list, false)}
+{foo: one(list, ok)}
+{foo: reduce($env, #acc, foo)}
+{foo: reduce(array, #)}
+{foo: reduce(list, #)}
+{foo: reduce(list, #.String)}
+{foo: reduce(list, $env)}
+{foo: reduce(list, 1.0)}
+{foo: reduce(list, add)}
+{foo: reduce(list, f64)}
+{foo: reduce(list, false), foo: 1.0 * f64}
+{foo: reduce(list, foo)}
+{foo: reduce(list, str)}
+{foo: reverse(array)}
+{foo: round(0)}
+{foo: round(1)}
+{foo: round(1.0), foo: str}
+{foo: round(1.0)}
+{foo: round(f64)}
+{foo: round(i)}
+{foo: round(i)}?.ok
+{foo: sort($env)}
+{foo: sort(array)}
+{foo: sortBy(array, #)}
+{foo: sortBy(array, 0)}
+{foo: sortBy(array, 1.0)}
+{foo: sortBy(list, 1.0)}
+{foo: sortBy(list, i)}
+{foo: sortBy(list, str)}
+{foo: str != $env?.[Bar]}
+{foo: str == nil}
+{foo: str == str}
+{foo: str >= str, foo: str}
+{foo: str in $env}
+{foo: str in foo}
+{foo: str matches str}
+{foo: str not contains str}
+{foo: str not endsWith str}
+{foo: str not in $env}
+{foo: str not in foo}
+{foo: str not matches str}
+{foo: str startsWith str}
+{foo: str, foo: $env != 0}
+{foo: str, foo: $env, foo: nil}.str
+{foo: str, foo: $env.f64}
+{foo: str, foo: $env.greet}
+{foo: str, foo: $env}.foo
+{foo: str, foo: $env}.greet
+{foo: str, foo: $env}.list
+{foo: str, foo: $env}.str
+{foo: str, foo: $env}?.[str]
+{foo: str, foo: 0}.add
+{foo: str, foo: 0}?.array
+{foo: str, foo: 0}?.ok
+{foo: str, foo: 1.0}.foo
+{foo: str, foo: 1.0}.greet
+{foo: str, foo: 1.0}.i
+{foo: str, foo: 1.0}.str
+{foo: str, foo: 1.0}?.[str]
+{foo: str, foo: 1.0}?.add
+{foo: str, foo: 1.0}?.foo
+{foo: str, foo: 1.0}?.ok
+{foo: str, foo: 1.0}?.str
+{foo: str, foo: 1}.Bar
+{foo: str, foo: 1}.foo
+{foo: str, foo: 1}.str
+{foo: str, foo: 1}?.list
+{foo: str, foo: [f64]}
+{foo: str, foo: add, foo: f64}?.ok
+{foo: str, foo: add}
+{foo: str, foo: add}.Bar
+{foo: str, foo: add}.f64
+{foo: str, foo: add}.greet
+{foo: str, foo: add}.i
+{foo: str, foo: add}?.[str]
+{foo: str, foo: array}
+{foo: str, foo: array}.greet
+{foo: str, foo: array}.list
+{foo: str, foo: array}.ok
+{foo: str, foo: array}?.String
+{foo: str, foo: array}?.foo
+{foo: str, foo: array}?.i
+{foo: str, foo: f64}
+{foo: str, foo: f64}.add
+{foo: str, foo: f64}?.String
+{foo: str, foo: f64}?.add?.[add]
+{foo: str, foo: f64}?.list
+{foo: str, foo: false}.array
+{foo: str, foo: false}.f64
+{foo: str, foo: false}?.[str]
+{foo: str, foo: foo, foo: array}?.str
+{foo: str, foo: foo}
+{foo: str, foo: foo}.Bar
+{foo: str, foo: foo}.f64?.foo
+{foo: str, foo: foo}.ok
+{foo: str, foo: foo}.str
+{foo: str, foo: foo}?.[str]?.String()
+{foo: str, foo: foo}?.add
+{foo: str, foo: foo}?.f64
+{foo: str, foo: foo}?.f64?.f64
+{foo: str, foo: foo}?.greet
+{foo: str, foo: greet(str)}
+{foo: str, foo: greet}
+{foo: str, foo: greet}.Bar
+{foo: str, foo: greet}.ok
+{foo: str, foo: greet}?.add
+{foo: str, foo: i}
+{foo: str, foo: i}.Bar
+{foo: str, foo: i}.array
+{foo: str, foo: i}?.list
+{foo: str, foo: list}
+{foo: str, foo: list}.String
+{foo: str, foo: list}?.foo
+{foo: str, foo: map($env, 0)}
+{foo: str, foo: median(1.0)}
+{foo: str, foo: nil}.add
+{foo: str, foo: nil}?.Bar
+{foo: str, foo: nil}?.i
+{foo: str, foo: nil}?.list
+{foo: str, foo: ok, foo: array}
+{foo: str, foo: ok}
+{foo: str, foo: ok}.list
+{foo: str, foo: ok}?.Bar
+{foo: str, foo: str}
+{foo: str, foo: str}.add
+{foo: str, foo: str}.foo
+{foo: str, foo: str}?.greet
+{foo: str, foo: true}.array
+{foo: str, foo: true}.ok?.String
+{foo: str, foo: true}?.Bar
+{foo: str, foo: true}?.foo
+{foo: str, foo: true}?.i
+{foo: str[:1]}
+{foo: string($env), foo: list}
+{foo: string($env)}
+{foo: string(0)}
+{foo: string(1)}
+{foo: string(1.0)}
+{foo: string(array)}
+{foo: string(array)}.foo
+{foo: string(f64)}
+{foo: string(foo)}
+{foo: string(greet), foo: array}
+{foo: string(greet)}
+{foo: string(list), foo: i}
+{foo: string(nil)}
+{foo: string(ok)}
+{foo: string(str)}
+{foo: string(true)}
+{foo: str}
+{foo: str} != $env?.[Bar]
+{foo: str}.Bar
+{foo: str}.String
+{foo: str}.add
+{foo: str}.array
+{foo: str}.f64
+{foo: str}.f64?.[list]
+{foo: str}.foo
+{foo: str}.foobar?.Bar
+{foo: str}.greet
+{foo: str}.greet?.array
+{foo: str}.greet?.array?.i
+{foo: str}.i
+{foo: str}.list
+{foo: str}.ok
+{foo: str}.str
+{foo: str}?.Bar
+{foo: str}?.Bar?.String
+{foo: str}?.String
+{foo: str}?.String?.[i]
+{foo: str}?.[str]
+{foo: str}?.add
+{foo: str}?.array
+{foo: str}?.f64
+{foo: str}?.f64?.[f64]
+{foo: str}?.foo
+{foo: str}?.foobar
+{foo: str}?.greet
+{foo: str}?.greet?.Bar
+{foo: str}?.greet?.greet
+{foo: str}?.i
+{foo: str}?.i in array
+{foo: str}?.i?.[ok]
+{foo: str}?.list
+{foo: str}?.list?.[array]
+{foo: str}?.nil?.Bar(true)
+{foo: str}?.ok
+{foo: str}?.ok not endsWith $env
+{foo: str}?.ok?.[ok]
+{foo: str}?.str
+{foo: sum($env, 1)}
+{foo: sum($env, 1.0)}
+{foo: sum($env, f64)}
+{foo: sum(array), foo: list}
+{foo: sum(array), foo: ok}
+{foo: sum(array)}
+{foo: sum(array)}?.array
+{foo: sum(array, #)}
+{foo: sum(array, 1.0)}
+{foo: toBase64(str)}
+{foo: toJSON(0)}
+{foo: toJSON(1)}
+{foo: toJSON(1.0), foo: f64}
+{foo: toJSON(1.0)}
+{foo: toJSON(array)}
+{foo: toJSON(f64), foo: array}
+{foo: toJSON(f64)}
+{foo: toJSON(false)}
+{foo: toJSON(foo), foo: foo?.String}
+{foo: toJSON(foo)}
+{foo: toJSON(i), foo: add}
+{foo: toJSON(i)}
+{foo: toJSON(list)}
+{foo: toJSON(nil)}
+{foo: toJSON(ok)}
+{foo: toJSON(str)}
+{foo: toJSON(true)}
+{foo: toPairs($env), foo: list}
+{foo: toPairs($env)}
+{foo: trim(str)}
+{foo: trimPrefix(str)}
+{foo: trimSuffix(str)}
+{foo: trimSuffix(string(nil))}
+{foo: true != $env}
+{foo: true != false}
+{foo: true != nil}
+{foo: true && $env}
+{foo: true && true}
+{foo: true && true}.String
+{foo: true == $env}
+{foo: true == nil}
+{foo: true == true}
+{foo: true ? add : i}
+{foo: true ? ok : 0}
+{foo: true ?: foo}
+{foo: true or $env}
+{foo: true || $env}
+{foo: true || false}
+{foo: true || ok}
+{foo: true, foo: $env, foo: 1.0}?.greet
+{foo: true, foo: $env}.f64
+{foo: true, foo: $env}.i
+{foo: true, foo: $env}.list
+{foo: true, foo: $env}?.String
+{foo: true, foo: $env}?.add
+{foo: true, foo: $env}?.i
+{foo: true, foo: $env}?.ok
+{foo: true, foo: 0}?.array
+{foo: true, foo: 1.0, foo: nil}.list
+{foo: true, foo: 1.0}.Bar
+{foo: true, foo: 1.0}.array
+{foo: true, foo: 1.0}.i
+{foo: true, foo: 1.0}.ok
+{foo: true, foo: 1.0}?.i
+{foo: true, foo: 1.0}?.ok
+{foo: true, foo: 1}.Bar
+{foo: true, foo: 1}.array
+{foo: true, foo: 1}.foo
+{foo: true, foo: 1}.i
+{foo: true, foo: 1}?.[str]
+{foo: true, foo: 1}?.foo
+{foo: true, foo: 1}?.greet
+{foo: true, foo: add}.f64
+{foo: true, foo: add}?.Bar
+{foo: true, foo: add}?.String
+{foo: true, foo: add}?.array
+{foo: true, foo: add}?.greet
+{foo: true, foo: array}.add
+{foo: true, foo: array}.i
+{foo: true, foo: f64}.greet
+{foo: true, foo: f64}.i
+{foo: true, foo: false}.Bar
+{foo: true, foo: false}.i?.[ok]
+{foo: true, foo: false}?.foo
+{foo: true, foo: false}?.greet
+{foo: true, foo: foo}.String
+{foo: true, foo: foo}.greet
+{foo: true, foo: foo}.ok
+{foo: true, foo: foo}.str?.list()
+{foo: true, foo: foo}?.[str]
+{foo: true, foo: foo}?.add
+{foo: true, foo: foo}?.f64
+{foo: true, foo: foo}?.greet
+{foo: true, foo: foo}?.list
+{foo: true, foo: foo}?.ok
+{foo: true, foo: foo}?.str
+{foo: true, foo: greet}.Bar
+{foo: true, foo: greet}.f64
+{foo: true, foo: greet}.foo
+{foo: true, foo: greet}?.[str]
+{foo: true, foo: i}.String
+{foo: true, foo: i}.add
+{foo: true, foo: i}.i
+{foo: true, foo: i}.str
+{foo: true, foo: i}?.Bar
+{foo: true, foo: i}?.array
+{foo: true, foo: list}?.[str]
+{foo: true, foo: list}?.greet
+{foo: true, foo: nil, foo: list}?.[str]
+{foo: true, foo: nil}.add
+{foo: true, foo: nil}?.String
+{foo: true, foo: nil}?.add
+{foo: true, foo: ok}.Bar
+{foo: true, foo: ok}.foo
+{foo: true, foo: ok}.list
+{foo: true, foo: ok}?.[str]
+{foo: true, foo: str}.Bar
+{foo: true, foo: str}.array
+{foo: true, foo: str}.f64
+{foo: true, foo: str}.str
+{foo: true, foo: str}?.array
+{foo: true, foo: str}?.greet
+{foo: true, foo: str}?.ok
+{foo: true, foo: true}.list
+{foo: true} not in $env?.String
+{foo: true}.Bar
+{foo: true}.Bar?.[add]
+{foo: true}.String
+{foo: true}.String?.[foo]
+{foo: true}.add
+{foo: true}.add?.i
+{foo: true}.array
+{foo: true}.f64
+{foo: true}.f64?.add
+{foo: true}.false == add
+{foo: true}.foo
+{foo: true}.foo ? ok : nil
+{foo: true}.foobar
+{foo: true}.greet
+{foo: true}.i
+{foo: true}.list
+{foo: true}.list?.[str]
+{foo: true}.ok
+{foo: true}.ok?.array
+{foo: true}.str
+{foo: true}?.Bar
+{foo: true}?.Bar?.[list]
+{foo: true}?.Bar?.list
+{foo: true}?.String
+{foo: true}?.String?.[ok]
+{foo: true}?.[str]
+{foo: true}?.add
+{foo: true}?.add?.[foo]
+{foo: true}?.add?.ok
+{foo: true}?.array
+{foo: true}?.array?.[ok]
+{foo: true}?.f64
+{foo: true}?.foo
+{foo: true}?.greet
+{foo: true}?.greet?.[greet]
+{foo: true}?.greet?.greet
+{foo: true}?.i
+{foo: true}?.i?.Bar
+{foo: true}?.list
+{foo: true}?.list?.[greet]
+{foo: true}?.ok
+{foo: true}?.ok?.Bar
+{foo: true}?.str
+{foo: true}?.str?.greet
+{foo: type($env)}
+{foo: type(0)}
+{foo: type(1)}
+{foo: type(1.0)}
+{foo: type(1.0)}?.f64
+{foo: type(add)}
+{foo: type(array)}
+{foo: type(f64)}
+{foo: type(false)}
+{foo: type(foo), foo: f64}
+{foo: type(foo)}
+{foo: type(greet)}
+{foo: type(i)}
+{foo: type(list)}
+{foo: type(nil)}
+{foo: type(ok)}
+{foo: type(str)}
+{foo: type(true)}
+{foo: uniq(array)}
+{foo: uniq(list)}
+{foo: upper(str)}
+{foo: values($env)}
+{foo: {foo: $env}}
+{foo: {foo: 0, foo: 1.0}}
+{foo: {foo: 0, foo: nil}}
+{foo: {foo: 0}}
+{foo: {foo: 0}}?.array
+{foo: {foo: 0}}?.f64
+{foo: {foo: 1, foo: 0}}
+{foo: {foo: 1.0, foo: true}}
+{foo: {foo: 1.0}}
+{foo: {foo: 1}}
+{foo: {foo: add, foo: foo}}
+{foo: {foo: add, foo: greet}}
+{foo: {foo: array}}
+{foo: {foo: f64}}
+{foo: {foo: false, foo: $env}?.foo}
+{foo: {foo: false}}
+{foo: {foo: false}}.Bar
+{foo: {foo: foo, foo: 1.0}}
+{foo: {foo: foo}, foo: $env?.greet}
+{foo: {foo: foo}?.ok}
+{foo: {foo: foo}?.str}
+{foo: {foo: foo}}
+{foo: {foo: foo}}?.i
+{foo: {foo: greet, foo: 0}}
+{foo: {foo: greet, foo: i}}
+{foo: {foo: greet}}
+{foo: {foo: i, foo: array}}
+{foo: {foo: i}}
+{foo: {foo: list?.[0]}}
+{foo: {foo: list}}
+{foo: {foo: nil, foo: $env}}
+{foo: {foo: nil, foo: foo}}
+{foo: {foo: nil}}
+{foo: {foo: ok, foo: nil}}
+{foo: {foo: ok, foo: true}}
+{foo: {foo: ok}}
+{foo: {foo: ok}}.list
+{foo: {foo: str}}
+{foo: {foo: true}}

From 646c17c96211377b1bcbf5dc35a0bfde9aae0198 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 21 Mar 2025 18:09:09 +0100
Subject: [PATCH 421/506] Add examples testing

---
 test/examples/examples_test.go           |  55 ++++++++++
 test/gen/gen_test.go                     |   2 +-
 testdata/examples.md                     | 129 +++++++++++++++++++++++
 testdata/{examples.txt => generated.txt} |   0
 4 files changed, 185 insertions(+), 1 deletion(-)
 create mode 100644 test/examples/examples_test.go
 create mode 100644 testdata/examples.md
 rename testdata/{examples.txt => generated.txt} (100%)

diff --git a/test/examples/examples_test.go b/test/examples/examples_test.go
new file mode 100644
index 000000000..ee6d1a3cb
--- /dev/null
+++ b/test/examples/examples_test.go
@@ -0,0 +1,55 @@
+package main
+
+import (
+	"flag"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestExamples(t *testing.T) {
+	flag.Parse()
+
+	b, err := os.ReadFile("../../testdata/examples.md")
+	require.NoError(t, err)
+	examples := extractCodeBlocks(string(b))
+
+	for _, line := range examples {
+		line := line
+		t.Run(line, func(t *testing.T) {
+			program, err := expr.Compile(line, expr.Env(nil))
+			require.NoError(t, err)
+
+			_, err = expr.Run(program, nil)
+			require.NoError(t, err)
+		})
+	}
+}
+
+func extractCodeBlocks(markdown string) []string {
+	var blocks []string
+	var currentBlock []string
+	inBlock := false
+
+	lines := strings.Split(markdown, "\n")
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "```") {
+			if inBlock {
+				blocks = append(blocks, strings.Join(currentBlock, "\n"))
+				currentBlock = nil
+				inBlock = false
+			} else {
+				inBlock = true
+			}
+			continue
+		}
+		if inBlock {
+			currentBlock = append(currentBlock, line)
+		}
+	}
+	return blocks
+}
diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go
index cb6c08e00..4050fc6e9 100644
--- a/test/gen/gen_test.go
+++ b/test/gen/gen_test.go
@@ -16,7 +16,7 @@ var updateFlag = flag.Bool("update", false, "Drop failing lines from examples.tx
 func TestGenerated(t *testing.T) {
 	flag.Parse()
 
-	b, err := os.ReadFile("../../testdata/examples.txt")
+	b, err := os.ReadFile("../../testdata/generated.txt")
 	require.NoError(t, err)
 
 	examples := strings.TrimSpace(string(b))
diff --git a/testdata/examples.md b/testdata/examples.md
new file mode 100644
index 000000000..87b4fb1a8
--- /dev/null
+++ b/testdata/examples.md
@@ -0,0 +1,129 @@
+# Examples
+
+Character Frequency Grouping
+
+```
+let char = "0";
+1..100000
+| map(string(#))
+| groupBy(split(#, char) | len() - 1)
+| toPairs()
+| map({{
+    count: #[0], 
+    len: len(#[1]), 
+    examples: [first(#[1]), last(#[1])],
+ }})
+| sortBy(.len, 'desc')
+```
+
+Log Filtering and Aggregation
+
+```
+let logs = [
+  {timestamp: date("2023-08-14 08:30:00"), message: "User logged in", level: "info"},
+  {timestamp: date("2023-08-14 09:00:00"), message: "Error processing payment", level: "error"},
+  {timestamp: date("2023-08-14 10:15:00"), message: "User logged out", level: "info"},
+  {timestamp: date("2023-08-14 11:00:00"), message: "Error connecting to database", level: "error"}
+];
+
+logs
+| filter(.level == "error")
+| map({{
+    time: string(.timestamp),
+    detail: .message
+ }})
+| sortBy(.time)
+```
+
+Financial Data Analysis and Summary
+
+```
+let accounts = [
+  {name: "Alice", balance: 1234.56, transactions: [100, -50, 200]},
+  {name: "Bob", balance: 2345.67, transactions: [-200, 300, -150]},
+  {name: "Charlie", balance: 3456.78, transactions: [400, -100, 50]}
+];
+
+{
+  totalBalance: sum(accounts, .balance),
+  averageBalance: mean(map(accounts, .balance)),
+  totalTransactions: reduce(accounts, #acc + len(.transactions), 0),
+  accounts: map(accounts, {{
+      name: .name,
+      final: .balance + sum(.transactions),
+      transactionCount: len(.transactions)
+  }})
+}
+```
+
+Bitwise Operations and Flags Decoding
+
+```
+let flags = [
+  {name: "read", value: 0b0001},
+  {name: "write", value: 0b0010},
+  {name: "execute", value: 0b0100},
+  {name: "admin", value: 0b1000}
+];
+
+let userPermissions = 0b1011;
+
+flags
+| filter(userPermissions | bitand(.value) != 0)
+| map(.name)
+```
+
+Nested Predicates with Optional Chaining
+
+```
+let users = [
+  {id: 1, name: "Alice", posts: [{title: "Hello World", content: "Short post"}, {title: "Another Post", content: "This is a bit longer post"}]},
+  {id: 2, name: "Bob", posts: nil},
+  {id: 3, name: "Charlie", posts: [{title: "Quick Update", content: "Update content"}]}
+];
+
+users
+| filter(
+    // Check if any post has content length greater than 10.
+    any(.posts ?? [], len(.content) > 10)
+  )
+| map({{name: .name, postCount: len(.posts ?? [])}})
+```
+
+String Manipulation and Validation
+
+```
+"  Apple, banana, Apple, orange, banana, kiwi "
+| trim()
+| split(",")
+| map(trim(#))
+| map(lower(#))
+| uniq()
+| sort()
+| join(", ")
+```
+
+Date Difference
+
+```
+let startDate = date("2023-01-01");
+let endDate = date("2023-12-31");
+let diff = endDate - startDate;
+{
+  daysBetween: diff.Hours() / 24,
+  hoursBetween: diff.Hours()
+}
+```
+
+Phone number filtering
+
+```
+let phone = filter(split("123-456-78901", ""), # in map(0..9, string(#)))[:10];
+join(concat(["("], phone[:3], [")"], phone[3:6], ["-"], phone[6:]))
+```
+
+Prime numbers
+
+```
+2..1000 | filter(let N = #; none(2..N-1, N % # == 0))
+```
diff --git a/testdata/examples.txt b/testdata/generated.txt
similarity index 100%
rename from testdata/examples.txt
rename to testdata/generated.txt

From 3a0a1da527d97b1bf115ef1d17f3e3d34772d0d9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 24 Mar 2025 12:01:07 +0100
Subject: [PATCH 422/506] Refactor examples tests

---
 test/examples/examples_test.go | 47 +++++++--------------------
 test/examples/markdown.go      | 59 ++++++++++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 35 deletions(-)
 create mode 100644 test/examples/markdown.go

diff --git a/test/examples/examples_test.go b/test/examples/examples_test.go
index ee6d1a3cb..86de35d3f 100644
--- a/test/examples/examples_test.go
+++ b/test/examples/examples_test.go
@@ -1,26 +1,28 @@
 package main
 
 import (
-	"flag"
 	"os"
-	"strings"
 	"testing"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/internal/testify/require"
 )
 
-func TestExamples(t *testing.T) {
-	flag.Parse()
+var examples []CodeBlock
 
+func init() {
 	b, err := os.ReadFile("../../testdata/examples.md")
-	require.NoError(t, err)
-	examples := extractCodeBlocks(string(b))
+	if err != nil {
+		panic(err)
+	}
+	examples = extractCodeBlocksWithTitle(string(b))
+}
 
-	for _, line := range examples {
-		line := line
-		t.Run(line, func(t *testing.T) {
-			program, err := expr.Compile(line, expr.Env(nil))
+func TestExamples(t *testing.T) {
+	for _, code := range examples {
+		code := code
+		t.Run(code.Title, func(t *testing.T) {
+			program, err := expr.Compile(code.Content, expr.Env(nil))
 			require.NoError(t, err)
 
 			_, err = expr.Run(program, nil)
@@ -28,28 +30,3 @@ func TestExamples(t *testing.T) {
 		})
 	}
 }
-
-func extractCodeBlocks(markdown string) []string {
-	var blocks []string
-	var currentBlock []string
-	inBlock := false
-
-	lines := strings.Split(markdown, "\n")
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if strings.HasPrefix(trimmed, "```") {
-			if inBlock {
-				blocks = append(blocks, strings.Join(currentBlock, "\n"))
-				currentBlock = nil
-				inBlock = false
-			} else {
-				inBlock = true
-			}
-			continue
-		}
-		if inBlock {
-			currentBlock = append(currentBlock, line)
-		}
-	}
-	return blocks
-}
diff --git a/test/examples/markdown.go b/test/examples/markdown.go
new file mode 100644
index 000000000..c90bcb71b
--- /dev/null
+++ b/test/examples/markdown.go
@@ -0,0 +1,59 @@
+package main
+
+import (
+	"strings"
+)
+
+// CodeBlock holds the optional title and content of a code block.
+type CodeBlock struct {
+	Title   string
+	Content string
+}
+
+func extractCodeBlocksWithTitle(markdown string) []CodeBlock {
+	var blocks []CodeBlock
+	var currentBlock []string
+	var currentTitle string
+	inBlock := false
+
+	// Split the markdown into lines.
+	lines := strings.Split(markdown, "\n")
+	for i, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		// Check if the line starts with a code block fence.
+		if strings.HasPrefix(trimmed, "```") {
+			// If already inside a code block, this marks its end.
+			if inBlock {
+				blocks = append(blocks, CodeBlock{
+					Title:   currentTitle,
+					Content: strings.Join(currentBlock, "\n"),
+				})
+				currentBlock = nil
+				inBlock = false
+				currentTitle = ""
+			} else {
+				// Not in a block: starting a new code block.
+				// Look backwards for the closest non-empty line that is not a code fence.
+				title := ""
+				for j := i - 1; j >= 0; j-- {
+					prev := strings.TrimSpace(lines[j])
+					if prev == "" || strings.HasPrefix(prev, "```") {
+						continue
+					}
+					title = prev
+					break
+				}
+				currentTitle = title
+				inBlock = true
+			}
+			// Skip the fence line.
+			continue
+		}
+
+		// If inside a code block, add the line.
+		if inBlock {
+			currentBlock = append(currentBlock, line)
+		}
+	}
+	return blocks
+}

From 6121e25ba004896f054266209a7b4781822c1722 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 24 Mar 2025 14:48:41 +0100
Subject: [PATCH 423/506] Make expr.Eval faster (#775)

* Make expr.Eval faster

* Add bench_call_test.go

* Make parser config optional
---
 bench_test.go                 | 20 +++++++++++
 builtin/builtin_test.go       | 12 +++++--
 compiler/compiler.go          | 16 +++++----
 expr.go                       |  8 ++++-
 expr_test.go                  |  2 +-
 parser/lexer/lexer_test.go    | 14 ++++----
 parser/parser.go              | 18 +++++++---
 test/bench/bench_call_test.go | 63 +++++++++++++++++++++++++++++++++++
 8 files changed, 130 insertions(+), 23 deletions(-)
 create mode 100644 test/bench/bench_call_test.go

diff --git a/bench_test.go b/bench_test.go
index de159bed9..c9f2b7182 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -31,6 +31,26 @@ func Benchmark_expr(b *testing.B) {
 	require.True(b, out.(bool))
 }
 
+func Benchmark_expr_eval(b *testing.B) {
+	params := make(map[string]any)
+	params["Origin"] = "MOW"
+	params["Country"] = "RU"
+	params["Adults"] = 1
+	params["Value"] = 100
+
+	var out any
+	var err error
+
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = expr.Eval(`(Origin == "MOW" || Country == "RU") && (Value >= 100 || Adults == 1)`, params)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.True(b, out.(bool))
+}
+
 func Benchmark_expr_reuseVm(b *testing.B) {
 	params := make(map[string]any)
 	params["Origin"] = "MOW"
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 71f775a49..6ca1e8fdd 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -246,9 +246,15 @@ func TestBuiltin_errors(t *testing.T) {
 	}
 	for _, test := range errorTests {
 		t.Run(test.input, func(t *testing.T) {
-			_, err := expr.Eval(test.input, nil)
-			assert.Error(t, err)
-			assert.Contains(t, err.Error(), test.err)
+			program, err := expr.Compile(test.input)
+			if err != nil {
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), test.err)
+			} else {
+				_, err = expr.Run(program, nil)
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), test.err)
+			}
 		})
 	}
 }
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 90e54e54b..595355d28 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -776,12 +776,16 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 	}
 	c.compile(node.Callee)
 
-	isMethod, _, _ := checker.MethodIndex(c.config.Env, node.Callee)
-	if index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok {
-		c.emit(OpCallTyped, index)
-		return
-	} else if checker.IsFastFunc(node.Callee.Type(), isMethod) {
-		c.emit(OpCallFast, len(node.Arguments))
+	if c.config != nil {
+		isMethod, _, _ := checker.MethodIndex(c.config.Env, node.Callee)
+		if index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok {
+			c.emit(OpCallTyped, index)
+			return
+		} else if checker.IsFastFunc(node.Callee.Type(), isMethod) {
+			c.emit(OpCallFast, len(node.Arguments))
+		} else {
+			c.emit(OpCall, len(node.Arguments))
+		}
 	} else {
 		c.emit(OpCall, len(node.Arguments))
 	}
diff --git a/expr.go b/expr.go
index 5e60791e1..33b7cf354 100644
--- a/expr.go
+++ b/expr.go
@@ -13,6 +13,7 @@ import (
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
 	"github.com/expr-lang/expr/patcher"
 	"github.com/expr-lang/expr/vm"
 )
@@ -240,7 +241,12 @@ func Eval(input string, env any) (any, error) {
 		return nil, fmt.Errorf("misused expr.Eval: second argument (env) should be passed without expr.Env")
 	}
 
-	program, err := Compile(input)
+	tree, err := parser.Parse(input)
+	if err != nil {
+		return nil, err
+	}
+
+	program, err := compiler.Compile(tree, nil)
 	if err != nil {
 		return nil, err
 	}
diff --git a/expr_test.go b/expr_test.go
index 4ebe6d4de..4d3736a97 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1684,7 +1684,7 @@ func TestEval_exposed_error(t *testing.T) {
 
 	fileError, ok := err.(*file.Error)
 	require.True(t, ok, "error should be of type *file.Error")
-	require.Equal(t, "integer divide by zero (1:3)\n | 1 % 0\n | ..^", fileError.Error())
+	require.Equal(t, "runtime error: integer divide by zero (1:3)\n | 1 % 0\n | ..^", fileError.Error())
 	require.Equal(t, 2, fileError.Column)
 	require.Equal(t, 1, fileError.Line)
 }
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index f1cb3f28f..db02d2acf 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -311,13 +311,13 @@ func TestLex_location(t *testing.T) {
 	tokens, err := Lex(source)
 	require.NoError(t, err)
 	require.Equal(t, []Token{
-		{Location: file.Location{From: 0, To: 1}, Kind: "Number", Value: "1"},
-		{Location: file.Location{From: 1, To: 3}, Kind: "Operator", Value: ".."},
-		{Location: file.Location{From: 3, To: 4}, Kind: "Number", Value: "2"},
-		{Location: file.Location{From: 5, To: 6}, Kind: "Number", Value: "3"},
-		{Location: file.Location{From: 6, To: 8}, Kind: "Operator", Value: ".."},
-		{Location: file.Location{From: 8, To: 9}, Kind: "Number", Value: "4"},
-		{Location: file.Location{From: 8, To: 9}, Kind: "EOF", Value: ""},
+		{Location: file.Location{From: 0, To: 1}, Kind: Number, Value: "1"},
+		{Location: file.Location{From: 1, To: 3}, Kind: Operator, Value: ".."},
+		{Location: file.Location{From: 3, To: 4}, Kind: Number, Value: "2"},
+		{Location: file.Location{From: 5, To: 6}, Kind: Number, Value: "3"},
+		{Location: file.Location{From: 6, To: 8}, Kind: Operator, Value: ".."},
+		{Location: file.Location{From: 8, To: 9}, Kind: Number, Value: "4"},
+		{Location: file.Location{From: 8, To: 9}, Kind: EOF, Value: ""},
 	}, tokens)
 }
 
diff --git a/parser/parser.go b/parser/parser.go
index 91c0fa8f8..0a463fed5 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -56,6 +56,13 @@ type parser struct {
 
 func (p *parser) checkNodeLimit() error {
 	p.nodeCount++
+	if p.config == nil {
+		if p.nodeCount > conf.DefaultMaxNodes {
+			p.error("compilation failed: expression exceeds maximum allowed nodes")
+			return nil
+		}
+		return nil
+	}
 	if p.config.MaxNodes > 0 && p.nodeCount > p.config.MaxNodes {
 		p.error("compilation failed: expression exceeds maximum allowed nodes")
 		return nil
@@ -91,9 +98,7 @@ type Tree struct {
 }
 
 func Parse(input string) (*Tree, error) {
-	return ParseWithConfig(input, &conf.Config{
-		Disabled: map[string]bool{},
-	})
+	return ParseWithConfig(input, nil)
 }
 
 func ParseWithConfig(input string, config *conf.Config) (*Tree, error) {
@@ -515,7 +520,10 @@ func (p *parser) toFloatNode(number float64) Node {
 func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) Node {
 	var node Node
 
-	isOverridden := p.config.IsOverridden(token.Value)
+	isOverridden := false
+	if p.config != nil {
+		isOverridden = p.config.IsOverridden(token.Value)
+	}
 	isOverridden = isOverridden && checkOverrides
 
 	if b, ok := predicates[token.Value]; ok && !isOverridden {
@@ -562,7 +570,7 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 		if node == nil {
 			return nil
 		}
-	} else if _, ok := builtin.Index[token.Value]; ok && !p.config.Disabled[token.Value] && !isOverridden {
+	} else if _, ok := builtin.Index[token.Value]; ok && (p.config == nil || !p.config.Disabled[token.Value]) && !isOverridden {
 		node = p.createNode(&BuiltinNode{
 			Name:      token.Value,
 			Arguments: p.parseArguments(arguments),
diff --git a/test/bench/bench_call_test.go b/test/bench/bench_call_test.go
new file mode 100644
index 000000000..9c9c13226
--- /dev/null
+++ b/test/bench/bench_call_test.go
@@ -0,0 +1,63 @@
+package bench_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/vm"
+)
+
+type Env struct {
+	Fn func() bool
+}
+
+func BenchmarkCall_callTyped(b *testing.B) {
+	code := `Fn()`
+
+	p, err := expr.Compile(code, expr.Env(Env{}))
+	require.NoError(b, err)
+	require.Equal(b, p.Bytecode[1], vm.OpCallTyped)
+
+	env := Env{
+		Fn: func() bool {
+			return true
+		},
+	}
+
+	var out any
+
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		program, _ := expr.Compile(code, expr.Env(env))
+		out, err = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.True(b, out.(bool))
+}
+
+func BenchmarkCall_eval(b *testing.B) {
+	code := `Fn()`
+
+	p, err := expr.Compile(code)
+	require.NoError(b, err)
+	require.Equal(b, p.Bytecode[1], vm.OpCall)
+
+	env := Env{
+		Fn: func() bool {
+			return true
+		},
+	}
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = expr.Eval(code, env)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.True(b, out.(bool))
+}

From bb2a3e57f2482e427f994f4bbfca6af8de0d8809 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 28 Mar 2025 15:43:54 +0100
Subject: [PATCH 424/506] Add gotestfmt

---
 .github/workflows/test.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 5d0b0744e..e0dfb3d3e 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -18,8 +18,12 @@ jobs:
         uses: actions/setup-go@v4
         with:
           go-version: ${{ matrix.go-version }}
+      - name: Set up gotestfmt
+        run: go install github.com/gotesttools/gotestfmt/v2/cmd/gotestfmt@latest          
       - name: Test
-        run: go test ./...
+        run: |
+          set -euo pipefail 
+          go test ./... | gotestfmt
 
   debug:
     runs-on: ubuntu-latest

From d0b5b37a4a6871cc275bf85bc619a9676f65e7d5 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 28 Mar 2025 15:45:20 +0100
Subject: [PATCH 425/506] Update gotestfmt

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index e0dfb3d3e..171868ee8 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -23,7 +23,7 @@ jobs:
       - name: Test
         run: |
           set -euo pipefail 
-          go test ./... | gotestfmt
+          go test -json -v ./... 2>&1 | gotestfmt
 
   debug:
     runs-on: ubuntu-latest

From 57fe809870a564fc60cb2176d19e20f975c3cb2d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 28 Mar 2025 15:48:24 +0100
Subject: [PATCH 426/506] Update test.yml

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 171868ee8..27c536f65 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -23,7 +23,7 @@ jobs:
       - name: Test
         run: |
           set -euo pipefail 
-          go test -json -v ./... 2>&1 | gotestfmt
+          go test -json -v ./... 2>&1 | gotestfmt -hide all
 
   debug:
     runs-on: ubuntu-latest

From e190ea2e5dcab9c2e6b047876480bb014a45bb2f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 28 Mar 2025 15:49:42 +0100
Subject: [PATCH 427/506] Remove gotestfmt

---
 .github/workflows/test.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 27c536f65..c334b193c 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -18,12 +18,10 @@ jobs:
         uses: actions/setup-go@v4
         with:
           go-version: ${{ matrix.go-version }}
-      - name: Set up gotestfmt
-        run: go install github.com/gotesttools/gotestfmt/v2/cmd/gotestfmt@latest          
       - name: Test
         run: |
           set -euo pipefail 
-          go test -json -v ./... 2>&1 | gotestfmt -hide all
+          go test ./...
 
   debug:
     runs-on: ubuntu-latest

From 785630f7830056aa4fb84c989ead82e188ffe9e8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Fri, 28 Mar 2025 15:50:33 +0100
Subject: [PATCH 428/506] Update test.yml

---
 .github/workflows/test.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index c334b193c..5d0b0744e 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -19,9 +19,7 @@ jobs:
         with:
           go-version: ${{ matrix.go-version }}
       - name: Test
-        run: |
-          set -euo pipefail 
-          go test ./...
+        run: go test ./...
 
   debug:
     runs-on: ubuntu-latest

From 28d9b3d4575bc9bb3d4e92cb18a6f7924693a583 Mon Sep 17 00:00:00 2001
From: 2pac <tarasyaremabcn@gmail.com>
Date: Mon, 12 May 2025 18:32:48 +0200
Subject: [PATCH 429/506] fix(785): `get` to work when return is `nil` (#786)

* fix(785): `get` to work when return is `nil`

* improve testing
---
 builtin/lib.go                |  4 ++++
 expr_test.go                  | 21 +++++++++++++++++++
 test/issues/785/issue_test.go | 38 +++++++++++++++++++++++++++++++++++
 3 files changed, 63 insertions(+)
 create mode 100644 test/issues/785/issue_test.go

diff --git a/builtin/lib.go b/builtin/lib.go
index 5a70a6b91..579393161 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -374,6 +374,10 @@ func get(params ...any) (out any, err error) {
 	i := params[1]
 	v := reflect.ValueOf(from)
 
+	if from == nil {
+		return nil, nil
+	}
+
 	if v.Kind() == reflect.Invalid {
 		panic(fmt.Sprintf("cannot fetch %v from %T", i, from))
 	}
diff --git a/expr_test.go b/expr_test.go
index 4d3736a97..faa5cae6d 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2724,3 +2724,24 @@ func TestExpr_wierd_cases(t *testing.T) {
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "unknown name A")
 }
+
+func TestIssue785_get_nil(t *testing.T) {
+	exprStrs := []string{
+		`get(nil, "a")`,
+		`get({}, "a")`,
+		`get(nil, "a")`,
+		`get({}, "a")`,
+		`({} | get("a") | get("b"))`,
+	}
+
+	for _, exprStr := range exprStrs {
+		t.Run("get returns nil", func(t *testing.T) {
+			env := map[string]interface{}{}
+
+			result, err := expr.Eval(exprStr, env)
+			require.NoError(t, err)
+
+			require.Equal(t, nil, result)
+		})
+	}
+}
diff --git a/test/issues/785/issue_test.go b/test/issues/785/issue_test.go
new file mode 100644
index 000000000..4e4f9e53d
--- /dev/null
+++ b/test/issues/785/issue_test.go
@@ -0,0 +1,38 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue785(t *testing.T) {
+	emptyMap := map[string]any{}
+
+	env := map[string]interface{}{
+		"empty_map": emptyMap,
+	}
+
+	{
+		code := `get(empty_map, "non_existing_key") | get("some_key") | get("another_key") | get("yet_another_key") | get("last_key")`
+
+		program, err := expr.Compile(code, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, nil, output)
+	}
+
+	{
+		code := `{} | get("non_existing_key") | get("some_key") | get("another_key") | get("yet_another_key") | get("last_key")`
+
+		program, err := expr.Compile(code, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, nil, output)
+	}
+}

From f974b88d463eba42e73c92af7cd23aba88f4a7d6 Mon Sep 17 00:00:00 2001
From: Vincent Bernat <vincent@bernat.ch>
Date: Mon, 26 May 2025 10:03:53 +0200
Subject: [PATCH 430/506] Do not repeat patcher definition in ExamplePatch()
 (#792)

I suppose at some point, godoc was not smart enough to display the
definitions used in the body of examples in the documentation. This is
not the case anymore: https://pkg.go.dev/github.com/expr-lang/expr#example-Patch
---
 expr_test.go | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index faa5cae6d..241767a09 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -504,20 +504,6 @@ func (p *patcher) Visit(node *ast.Node) {
 }
 
 func ExamplePatch() {
-	/*
-		type patcher struct{}
-
-		func (p *patcher) Visit(node *ast.Node) {
-			switch n := (*node).(type) {
-			case *ast.MemberNode:
-				ast.Patch(node, &ast.CallNode{
-					Callee:    &ast.IdentifierNode{Value: "get"},
-					Arguments: []ast.Node{n.Node, n.Property},
-				})
-			}
-		}
-	*/
-
 	program, err := expr.Compile(
 		`greet.you.world + "!"`,
 		expr.Patch(&patcher{}),

From ebf0d8ba0eaee5e4a7631e014bc656fa280940bf Mon Sep 17 00:00:00 2001
From: Yigitkan Balci <yigitkan.balci@gmail.com>
Date: Tue, 27 May 2025 13:13:35 +0300
Subject: [PATCH 431/506] Add check for non struct types to fetchField (#794)

Co-authored-by: yigitkanbalci <yigitkan.balci@goodjobgames.com>
---
 checker/checker_test.go | 25 +++++++++++++++++++++++++
 checker/nature/utils.go |  5 +++++
 2 files changed, 30 insertions(+)

diff --git a/checker/checker_test.go b/checker/checker_test.go
index 4950c1a8e..2ec7c7cfc 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -1,6 +1,7 @@
 package checker_test
 
 import (
+	"context"
 	"fmt"
 	"reflect"
 	"regexp"
@@ -1078,6 +1079,30 @@ func TestCheck_builtin_without_call(t *testing.T) {
 	}
 }
 
+func TestCheck_EmbeddedInterface(t *testing.T) {
+	t.Run("embedded interface lookup returns compile-error not panic", func(t *testing.T) {
+		type Env struct {
+			context.Context
+			Country string
+		}
+		type Wrapper struct {
+			Ctx Env
+		}
+
+		config := conf.New(Wrapper{
+			Ctx: Env{
+				Context: context.Background(),
+				Country: "TR",
+			},
+		})
+		expr.WithContext("Ctx")(config)
+
+		_, err := checker.ParseCheck("Ctx.C", config)
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "has no field C")
+	})
+}
+
 func TestCheck_types(t *testing.T) {
 	env := types.Map{
 		"foo": types.Map{
diff --git a/checker/nature/utils.go b/checker/nature/utils.go
index c242f91a6..179459874 100644
--- a/checker/nature/utils.go
+++ b/checker/nature/utils.go
@@ -14,6 +14,11 @@ func fieldName(field reflect.StructField) string {
 }
 
 func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
+	// If t is not a struct, early return.
+	if t.Kind() != reflect.Struct {
+		return reflect.StructField{}, false
+	}
+
 	// First check all structs fields.
 	for i := 0; i < t.NumField(); i++ {
 		field := t.Field(i)

From 6d7d7d68e13eb61a89c0591dbedf5f64574f3610 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 27 May 2025 12:22:06 +0200
Subject: [PATCH 432/506] Run diff / bench in parallel

---
 .github/workflows/diff.yml | 53 +++++++++++++++++++++++++++++++-------
 1 file changed, 43 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml
index 3a81ba2e1..a0c55cba2 100644
--- a/.github/workflows/diff.yml
+++ b/.github/workflows/diff.yml
@@ -5,28 +5,61 @@ on:
     branches: [ master ]
 
 jobs:
-  bench:
+  benchmark:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ref: [master, ${{ github.sha }}]
+        include:
+          - ref: master
+            name: old
+          - ref: ${{ github.sha }}
+            name: new
     steps:
       - name: Setup Go 1.18
         uses: actions/setup-go@v4
         with:
           go-version: 1.18
+
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ matrix.ref }}
+
+      - name: Run benchmark
+        run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/${{ matrix.name }}.txt
+
+      - name: Upload benchmark results
+        uses: actions/upload-artifact@v3
+        with:
+          name: benchmark-${{ matrix.name }}
+          path: /tmp/${{ matrix.name }}.txt
+
+  compare:
+    needs: benchmark
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Go 1.18
+        uses: actions/setup-go@v4
+        with:
+          go-version: 1.18
+
       - name: Install benchstat
         # NOTE: benchstat@latest requires go 1.23 since 2025-02-14 - this is the last go 1.18 ref
         # https://cs.opensource.google/go/x/perf/+/c95ad7d5b636f67d322a7e4832e83103d0fdd292
         run: go install golang.org/x/perf/cmd/benchstat@884df5810d2850d775c2cb4885a7ea339128a17d
 
-      - uses: actions/checkout@v3
-      - name: Benchmark new code
-        run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/new.txt
+      - name: Download old benchmark results
+        uses: actions/download-artifact@v3
+        with:
+          name: benchmark-old
+          path: /tmp/
 
-      - name: Checkout master
-        uses: actions/checkout@v3
+      - name: Download new benchmark results
+        uses: actions/download-artifact@v3
         with:
-          ref: master
-      - name: Benchmark master
-        run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/old.txt
+          name: benchmark-new
+          path: /tmp/
 
-      - name: Diff
+      - name: Compare benchmarks
         run: benchstat /tmp/old.txt /tmp/new.txt

From 0bae5401b3f7a4e1303db30d9dcb4ffd384b36ee Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 27 May 2025 12:34:11 +0200
Subject: [PATCH 433/506] Fix diff.yml

---
 .github/workflows/diff.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml
index a0c55cba2..ff7a08840 100644
--- a/.github/workflows/diff.yml
+++ b/.github/workflows/diff.yml
@@ -9,11 +9,10 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ref: [master, ${{ github.sha }}]
         include:
           - ref: master
             name: old
-          - ref: ${{ github.sha }}
+          - ref: ${{ github.event.pull_request.head.sha }}
             name: new
     steps:
       - name: Setup Go 1.18

From 1609a12ce65e179db1ffc0c38485eb5368a1c6e8 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 27 May 2025 12:39:33 +0200
Subject: [PATCH 434/506] Revert "Fix diff.yml"

This reverts commit 0bae5401b3f7a4e1303db30d9dcb4ffd384b36ee.
---
 .github/workflows/diff.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml
index ff7a08840..a0c55cba2 100644
--- a/.github/workflows/diff.yml
+++ b/.github/workflows/diff.yml
@@ -9,10 +9,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
+        ref: [master, ${{ github.sha }}]
         include:
           - ref: master
             name: old
-          - ref: ${{ github.event.pull_request.head.sha }}
+          - ref: ${{ github.sha }}
             name: new
     steps:
       - name: Setup Go 1.18

From 5fbfe7211cd667c622a69bf4609e55f2eade7f63 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 27 May 2025 12:39:33 +0200
Subject: [PATCH 435/506] Revert "Run diff / bench in parallel"

This reverts commit 6d7d7d68e13eb61a89c0591dbedf5f64574f3610.
---
 .github/workflows/diff.yml | 53 +++++++-------------------------------
 1 file changed, 10 insertions(+), 43 deletions(-)

diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml
index a0c55cba2..3a81ba2e1 100644
--- a/.github/workflows/diff.yml
+++ b/.github/workflows/diff.yml
@@ -5,61 +5,28 @@ on:
     branches: [ master ]
 
 jobs:
-  benchmark:
+  bench:
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ref: [master, ${{ github.sha }}]
-        include:
-          - ref: master
-            name: old
-          - ref: ${{ github.sha }}
-            name: new
     steps:
       - name: Setup Go 1.18
         uses: actions/setup-go@v4
         with:
           go-version: 1.18
-
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          ref: ${{ matrix.ref }}
-
-      - name: Run benchmark
-        run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/${{ matrix.name }}.txt
-
-      - name: Upload benchmark results
-        uses: actions/upload-artifact@v3
-        with:
-          name: benchmark-${{ matrix.name }}
-          path: /tmp/${{ matrix.name }}.txt
-
-  compare:
-    needs: benchmark
-    runs-on: ubuntu-latest
-    steps:
-      - name: Setup Go 1.18
-        uses: actions/setup-go@v4
-        with:
-          go-version: 1.18
-
       - name: Install benchstat
         # NOTE: benchstat@latest requires go 1.23 since 2025-02-14 - this is the last go 1.18 ref
         # https://cs.opensource.google/go/x/perf/+/c95ad7d5b636f67d322a7e4832e83103d0fdd292
         run: go install golang.org/x/perf/cmd/benchstat@884df5810d2850d775c2cb4885a7ea339128a17d
 
-      - name: Download old benchmark results
-        uses: actions/download-artifact@v3
-        with:
-          name: benchmark-old
-          path: /tmp/
+      - uses: actions/checkout@v3
+      - name: Benchmark new code
+        run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/new.txt
 
-      - name: Download new benchmark results
-        uses: actions/download-artifact@v3
+      - name: Checkout master
+        uses: actions/checkout@v3
         with:
-          name: benchmark-new
-          path: /tmp/
+          ref: master
+      - name: Benchmark master
+        run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/old.txt
 
-      - name: Compare benchmarks
+      - name: Diff
         run: benchstat /tmp/old.txt /tmp/new.txt

From eeb1b8b6259d9a34ad5fb06bdd8cde80841396ac Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Tue, 3 Jun 2025 17:31:46 +0200
Subject: [PATCH 436/506] Add expr.MaxNodes() option (#799)

* Add expr.MaxNodes() option

* Fix error message

* Add more tests and comments
---
 conf/config.go | 48 ++++++++++++++++----------------
 expr.go        |  9 ++++++
 expr_test.go   | 74 ++++++++++++++++++++++++++++++++++++--------------
 vm/vm.go       |  1 -
 4 files changed, 86 insertions(+), 46 deletions(-)

diff --git a/conf/config.go b/conf/config.go
index d629958e5..2c14d9882 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -10,43 +10,41 @@ import (
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
-const (
-	// DefaultMemoryBudget represents an upper limit of memory usage
+var (
+	// DefaultMemoryBudget represents default maximum allowed memory usage by the vm.VM.
 	DefaultMemoryBudget uint = 1e6
 
-	// DefaultMaxNodes represents an upper limit of AST nodes
-	DefaultMaxNodes uint = 10000
+	// DefaultMaxNodes represents default maximum allowed AST nodes by the compiler.
+	DefaultMaxNodes uint = 1e4
 )
 
 type FunctionsTable map[string]*builtin.Function
 
 type Config struct {
-	EnvObject    any
-	Env          nature.Nature
-	Expect       reflect.Kind
-	ExpectAny    bool
-	Optimize     bool
-	Strict       bool
-	Profile      bool
-	MaxNodes     uint
-	MemoryBudget uint
-	ConstFns     map[string]reflect.Value
-	Visitors     []ast.Visitor
-	Functions    FunctionsTable
-	Builtins     FunctionsTable
-	Disabled     map[string]bool // disabled builtins
+	EnvObject any
+	Env       nature.Nature
+	Expect    reflect.Kind
+	ExpectAny bool
+	Optimize  bool
+	Strict    bool
+	Profile   bool
+	MaxNodes  uint
+	ConstFns  map[string]reflect.Value
+	Visitors  []ast.Visitor
+	Functions FunctionsTable
+	Builtins  FunctionsTable
+	Disabled  map[string]bool // disabled builtins
 }
 
 // CreateNew creates new config with default values.
 func CreateNew() *Config {
 	c := &Config{
-		Optimize:     true,
-		MaxNodes:     DefaultMaxNodes,
-		MemoryBudget: DefaultMemoryBudget,
-		ConstFns:     make(map[string]reflect.Value),
-		Functions:    make(map[string]*builtin.Function),
-		Builtins:     make(map[string]*builtin.Function),
-		Disabled:     make(map[string]bool),
+		Optimize:  true,
+		MaxNodes:  DefaultMaxNodes,
+		ConstFns:  make(map[string]reflect.Value),
+		Functions: make(map[string]*builtin.Function),
+		Builtins:  make(map[string]*builtin.Function),
+		Disabled:  make(map[string]bool),
 	}
 	for _, f := range builtin.Builtins {
 		c.Builtins[f.Name] = f
diff --git a/expr.go b/expr.go
index 33b7cf354..48298fe7e 100644
--- a/expr.go
+++ b/expr.go
@@ -195,6 +195,15 @@ func Timezone(name string) Option {
 	})
 }
 
+// MaxNodes sets the maximum number of nodes allowed in the expression.
+// By default, the maximum number of nodes is conf.DefaultMaxNodes.
+// If MaxNodes is set to 0, the node budget check is disabled.
+func MaxNodes(n uint) Option {
+	return func(c *conf.Config) {
+		c.MaxNodes = n
+	}
+}
+
 // Compile parses and compiles given input expression to bytecode program.
 func Compile(input string, ops ...Option) (*vm.Program, error) {
 	config := conf.CreateNew()
diff --git a/expr_test.go b/expr_test.go
index 241767a09..57d2cfbbb 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -10,9 +10,11 @@ import (
 	"testing"
 	"time"
 
+	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/internal/testify/assert"
 	"github.com/expr-lang/expr/internal/testify/require"
 	"github.com/expr-lang/expr/types"
+	"github.com/expr-lang/expr/vm"
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
@@ -2225,26 +2227,6 @@ func TestEval_slices_out_of_bound(t *testing.T) {
 	}
 }
 
-func TestMemoryBudget(t *testing.T) {
-	tests := []struct {
-		code string
-	}{
-		{`map(1..100, {map(1..100, {map(1..100, {0})})})`},
-		{`len(1..10000000)`},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.code, func(t *testing.T) {
-			program, err := expr.Compile(tt.code)
-			require.NoError(t, err, "compile error")
-
-			_, err = expr.Run(program, nil)
-			assert.Error(t, err, "run error")
-			assert.Contains(t, err.Error(), "memory budget exceeded")
-		})
-	}
-}
-
 func TestExpr_custom_tests(t *testing.T) {
 	f, err := os.Open("custom_tests.json")
 	if os.IsNotExist(err) {
@@ -2731,3 +2713,55 @@ func TestIssue785_get_nil(t *testing.T) {
 		})
 	}
 }
+
+func TestMaxNodes(t *testing.T) {
+	maxNodes := uint(100)
+
+	code := ""
+	for i := 0; i < int(maxNodes); i++ {
+		code += "1; "
+	}
+
+	_, err := expr.Compile(code, expr.MaxNodes(maxNodes))
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "exceeds maximum allowed nodes")
+
+	_, err = expr.Compile(code, expr.MaxNodes(maxNodes+1))
+	require.NoError(t, err)
+}
+
+func TestMaxNodesDisabled(t *testing.T) {
+	code := ""
+	for i := 0; i < 2*int(conf.DefaultMaxNodes); i++ {
+		code += "1; "
+	}
+
+	_, err := expr.Compile(code, expr.MaxNodes(0))
+	require.NoError(t, err)
+}
+
+func TestMemoryBudget(t *testing.T) {
+	tests := []struct {
+		code string
+		max  int
+	}{
+		{`map(1..100, {map(1..100, {map(1..100, {0})})})`, -1},
+		{`len(1..10000000)`, -1},
+		{`1..100`, 100},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			program, err := expr.Compile(tt.code)
+			require.NoError(t, err, "compile error")
+
+			vm := vm.VM{}
+			if tt.max > 0 {
+				vm.MemoryBudget = uint(tt.max)
+			}
+			_, err = vm.Run(program, nil)
+			require.Error(t, err, "run error")
+			assert.Contains(t, err.Error(), "memory budget exceeded")
+		})
+	}
+}
diff --git a/vm/vm.go b/vm/vm.go
index de13cade1..3018619d9 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -75,7 +75,6 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 	if len(vm.Variables) < program.variables {
 		vm.Variables = make([]any, program.variables)
 	}
-
 	if vm.MemoryBudget == 0 {
 		vm.MemoryBudget = conf.DefaultMemoryBudget
 	}

From 98b0990dd3b9e5c37306e7999184de9a9cdaf25e Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Mon, 30 Jun 2025 15:08:46 -0300
Subject: [PATCH 437/506] Improve parser and lexer (#811)

* convert source to a struct and fix minor issue displaying error

* lexer: add byte and char pos

* improve parser to use string instead of []rune

* add lexer benchmarks

* make lexer work as an iterator

* make parser use the new iterator API in lexer

* allow reusing the parser

* cleanup code

* add parser benchmarks
---
 file/error.go              |  57 +++++------
 file/source.go             |  52 ++++------
 internal/ring/ring.go      |  85 +++++++++++++++++
 internal/ring/ring_test.go | 140 +++++++++++++++++++++++++++
 parser/bench_test.go       |  20 ++++
 parser/lexer/lexer.go      | 188 +++++++++++++++++++++----------------
 parser/lexer/lexer_test.go |   1 +
 parser/lexer/state.go      |  24 ++---
 parser/lexer/token.go      |  12 +--
 parser/lexer/utils.go      |   9 +-
 parser/parser.go           | 159 ++++++++++++++++++-------------
 vm/vm_test.go              |  25 ++---
 12 files changed, 529 insertions(+), 243 deletions(-)
 create mode 100644 internal/ring/ring.go
 create mode 100644 internal/ring/ring_test.go
 create mode 100644 parser/bench_test.go

diff --git a/file/error.go b/file/error.go
index 8ff85dfa5..04253b6f6 100644
--- a/file/error.go
+++ b/file/error.go
@@ -3,7 +3,6 @@ package file
 import (
 	"fmt"
 	"strings"
-	"unicode/utf8"
 )
 
 type Error struct {
@@ -19,43 +18,47 @@ func (e *Error) Error() string {
 	return e.format()
 }
 
+var tabReplacer = strings.NewReplacer("\t", " ")
+
 func (e *Error) Bind(source Source) *Error {
+	src := source.String()
+
+	var runeCount, lineStart int
 	e.Line = 1
-	for i, r := range source {
-		if i == e.From {
+	e.Column = 0
+	for i, r := range src {
+		if runeCount == e.From {
 			break
 		}
 		if r == '\n' {
+			lineStart = i
 			e.Line++
 			e.Column = 0
-		} else {
-			e.Column++
 		}
+		runeCount++
+		e.Column++
+	}
+
+	lineEnd := lineStart + strings.IndexByte(src[lineStart:], '\n')
+	if lineEnd < lineStart {
+		lineEnd = len(src)
+	}
+	if lineStart == lineEnd {
+		return e
 	}
-	if snippet, found := source.Snippet(e.Line); found {
-		snippet := strings.Replace(snippet, "\t", " ", -1)
-		srcLine := "\n | " + snippet
-		var bytes = []byte(snippet)
-		var indLine = "\n | "
-		for i := 0; i < e.Column && len(bytes) > 0; i++ {
-			_, sz := utf8.DecodeRune(bytes)
-			bytes = bytes[sz:]
-			if sz > 1 {
-				goto noind
-			} else {
-				indLine += "."
-			}
-		}
-		if _, sz := utf8.DecodeRune(bytes); sz > 1 {
-			goto noind
-		} else {
-			indLine += "^"
-		}
-		srcLine += indLine
 
-	noind:
-		e.Snippet = srcLine
+	const prefix = "\n | "
+	line := src[lineStart:lineEnd]
+	snippet := new(strings.Builder)
+	snippet.Grow(2*len(prefix) + len(line) + e.Column + 1)
+	snippet.WriteString(prefix)
+	tabReplacer.WriteString(snippet, line)
+	snippet.WriteString(prefix)
+	for i := 0; i < e.Column; i++ {
+		snippet.WriteByte('.')
 	}
+	snippet.WriteByte('^')
+	e.Snippet = snippet.String()
 	return e
 }
 
diff --git a/file/source.go b/file/source.go
index 8e2b2d154..b11bb5f9d 100644
--- a/file/source.go
+++ b/file/source.go
@@ -1,48 +1,36 @@
 package file
 
-import (
-	"strings"
-	"unicode/utf8"
-)
+import "strings"
 
-type Source []rune
+type Source struct {
+	raw string
+}
 
 func NewSource(contents string) Source {
-	return []rune(contents)
+	return Source{
+		raw: contents,
+	}
 }
 
 func (s Source) String() string {
-	return string(s)
+	return s.raw
 }
 
 func (s Source) Snippet(line int) (string, bool) {
-	if s == nil {
+	if s.raw == "" {
 		return "", false
 	}
-	lines := strings.Split(string(s), "\n")
-	lineOffsets := make([]int, len(lines))
-	var offset int
-	for i, line := range lines {
-		offset = offset + utf8.RuneCountInString(line) + 1
-		lineOffsets[i] = offset
-	}
-	charStart, found := getLineOffset(lineOffsets, line)
-	if !found || len(s) == 0 {
-		return "", false
+	var start int
+	for i := 1; i < line; i++ {
+		pos := strings.IndexByte(s.raw[start:], '\n')
+		if pos < 0 {
+			return "", false
+		}
+		start += pos + 1
 	}
-	charEnd, found := getLineOffset(lineOffsets, line+1)
-	if found {
-		return string(s[charStart : charEnd-1]), true
-	}
-	return string(s[charStart:]), true
-}
-
-func getLineOffset(lineOffsets []int, line int) (int, bool) {
-	if line == 1 {
-		return 0, true
-	} else if line > 1 && line <= len(lineOffsets) {
-		offset := lineOffsets[line-2]
-		return offset, true
+	end := start + strings.IndexByte(s.raw[start:], '\n')
+	if end < start {
+		end = len(s.raw)
 	}
-	return -1, false
+	return s.raw[start:end], true
 }
diff --git a/internal/ring/ring.go b/internal/ring/ring.go
new file mode 100644
index 000000000..cc9e727b0
--- /dev/null
+++ b/internal/ring/ring.go
@@ -0,0 +1,85 @@
+package ring
+
+// Ring is a very simple ring buffer implementation that uses a slice. The
+// internal slice will only grow, never shrink. When it grows, it grows in
+// chunks of "chunkSize" (given as argument in the [New] function). Pointer and
+// reference types can be safely used because memory is cleared.
+type Ring[T any] struct {
+	data                 []T
+	back, len, chunkSize int
+}
+
+func New[T any](chunkSize int) *Ring[T] {
+	if chunkSize < 1 {
+		panic("chunkSize must be greater than zero")
+	}
+	return &Ring[T]{
+		chunkSize: chunkSize,
+	}
+}
+
+func (r *Ring[T]) Len() int {
+	return r.len
+}
+
+func (r *Ring[T]) Cap() int {
+	return len(r.data)
+}
+
+func (r *Ring[T]) Reset() {
+	var zero T
+	for i := range r.data {
+		r.data[i] = zero // clear mem, optimized by the compiler, in Go 1.21 the "clear" builtin can be used
+	}
+	r.back = 0
+	r.len = 0
+}
+
+// Nth returns the n-th oldest value (zero-based) in the ring without making
+// any change.
+func (r *Ring[T]) Nth(n int) (v T, ok bool) {
+	if n < 0 || n >= r.len || len(r.data) == 0 {
+		return v, false
+	}
+	n = (n + r.back) % len(r.data)
+	return r.data[n], true
+}
+
+// Dequeue returns the oldest value.
+func (r *Ring[T]) Dequeue() (v T, ok bool) {
+	if r.len == 0 {
+		return v, false
+	}
+	v, r.data[r.back] = r.data[r.back], v // retrieve and clear mem
+	r.len--
+	r.back = (r.back + 1) % len(r.data)
+	return v, true
+}
+
+// Enqueue adds an item to the ring.
+func (r *Ring[T]) Enqueue(v T) {
+	if r.len == len(r.data) {
+		r.grow()
+	}
+	writePos := (r.back + r.len) % len(r.data)
+	r.data[writePos] = v
+	r.len++
+}
+
+func (r *Ring[T]) grow() {
+	s := make([]T, len(r.data)+r.chunkSize)
+	if r.len > 0 {
+		chunk1 := r.back + r.len
+		if chunk1 > len(r.data) {
+			chunk1 = len(r.data)
+		}
+		copied := copy(s, r.data[r.back:chunk1])
+
+		if copied < r.len { // wrapped slice
+			chunk2 := r.len - copied
+			copy(s[copied:], r.data[:chunk2])
+		}
+	}
+	r.back = 0
+	r.data = s
+}
diff --git a/internal/ring/ring_test.go b/internal/ring/ring_test.go
new file mode 100644
index 000000000..b7457cd70
--- /dev/null
+++ b/internal/ring/ring_test.go
@@ -0,0 +1,140 @@
+package ring
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestRing(t *testing.T) {
+	type op = ringOp[int]
+	testRing(t, New[int](3),
+		// noops on empty ring
+		op{cap: 0, opType: opRst, value: 0, items: []int{}},
+		op{cap: 0, opType: opDeq, value: 0, items: []int{}},
+
+		// basic
+		op{cap: 3, opType: opEnq, value: 1, items: []int{1}},
+		op{cap: 3, opType: opDeq, value: 1, items: []int{}},
+
+		// wrapping
+		op{cap: 3, opType: opEnq, value: 2, items: []int{2}},
+		op{cap: 3, opType: opEnq, value: 3, items: []int{2, 3}},
+		op{cap: 3, opType: opEnq, value: 4, items: []int{2, 3, 4}},
+		op{cap: 3, opType: opDeq, value: 2, items: []int{3, 4}},
+		op{cap: 3, opType: opDeq, value: 3, items: []int{4}},
+		op{cap: 3, opType: opDeq, value: 4, items: []int{}},
+
+		// resetting
+		op{cap: 3, opType: opEnq, value: 2, items: []int{2}},
+		op{cap: 3, opType: opRst, value: 0, items: []int{}},
+		op{cap: 3, opType: opDeq, value: 0, items: []int{}},
+
+		// growing without wrapping
+		op{cap: 3, opType: opEnq, value: 5, items: []int{5}},
+		op{cap: 3, opType: opEnq, value: 6, items: []int{5, 6}},
+		op{cap: 3, opType: opEnq, value: 7, items: []int{5, 6, 7}},
+		op{cap: 6, opType: opEnq, value: 8, items: []int{5, 6, 7, 8}},
+		op{cap: 6, opType: opRst, value: 0, items: []int{}},
+		op{cap: 6, opType: opDeq, value: 0, items: []int{}},
+
+		// growing and wrapping
+		op{cap: 6, opType: opEnq, value: 9, items: []int{9}},
+		op{cap: 6, opType: opEnq, value: 10, items: []int{9, 10}},
+		op{cap: 6, opType: opEnq, value: 11, items: []int{9, 10, 11}},
+		op{cap: 6, opType: opEnq, value: 12, items: []int{9, 10, 11, 12}},
+		op{cap: 6, opType: opEnq, value: 13, items: []int{9, 10, 11, 12, 13}},
+		op{cap: 6, opType: opEnq, value: 14, items: []int{9, 10, 11, 12, 13, 14}},
+		op{cap: 6, opType: opDeq, value: 9, items: []int{10, 11, 12, 13, 14}},
+		op{cap: 6, opType: opDeq, value: 10, items: []int{11, 12, 13, 14}},
+		op{cap: 6, opType: opEnq, value: 15, items: []int{11, 12, 13, 14, 15}},
+		op{cap: 6, opType: opEnq, value: 16, items: []int{11, 12, 13, 14, 15, 16}},
+		op{cap: 9, opType: opEnq, value: 17, items: []int{11, 12, 13, 14, 15, 16, 17}}, // grows wrapped
+		op{cap: 9, opType: opDeq, value: 11, items: []int{12, 13, 14, 15, 16, 17}},
+		op{cap: 9, opType: opDeq, value: 12, items: []int{13, 14, 15, 16, 17}},
+		op{cap: 9, opType: opDeq, value: 13, items: []int{14, 15, 16, 17}},
+		op{cap: 9, opType: opDeq, value: 14, items: []int{15, 16, 17}},
+		op{cap: 9, opType: opDeq, value: 15, items: []int{16, 17}},
+		op{cap: 9, opType: opDeq, value: 16, items: []int{17}},
+		op{cap: 9, opType: opDeq, value: 17, items: []int{}},
+		op{cap: 9, opType: opDeq, value: 0, items: []int{}},
+	)
+
+	t.Run("should panic on invalid chunkSize", func(t *testing.T) {
+		defer func() {
+			if r := recover(); r == nil {
+				t.Fatalf("should have panicked")
+			}
+		}()
+		New[int](0)
+	})
+}
+
+const (
+	opEnq = iota // enqueue an item
+	opDeq        // dequeue an item and an item was available
+	opRst        // reset
+)
+
+type ringOp[T comparable] struct {
+	cap    int // expected values
+	opType int // opEnq or opDeq
+	value  T   // value to enqueue or value expected for dequeue; ignored for opRst
+	items  []T // items left
+}
+
+func testRing[T comparable](t *testing.T, r *Ring[T], ops ...ringOp[T]) {
+	for i, op := range ops {
+		testOK := t.Run(fmt.Sprintf("opIndex=%v", i), func(t *testing.T) {
+			testRingOp(t, r, op)
+		})
+		if !testOK {
+			return
+		}
+	}
+}
+
+func testRingOp[T comparable](t *testing.T, r *Ring[T], op ringOp[T]) {
+	var zero T
+	switch op.opType {
+	case opEnq:
+		r.Enqueue(op.value)
+	case opDeq:
+		shouldSucceed := r.Len() > 0
+		v, ok := r.Dequeue()
+		switch {
+		case ok != shouldSucceed:
+			t.Fatalf("should have succeeded: %v", shouldSucceed)
+		case ok && v != op.value:
+			t.Fatalf("expected value: %v; got: %v", op.value, v)
+		case !ok && v != zero:
+			t.Fatalf("expected zero value; got: %v", v)
+		}
+	case opRst:
+		r.Reset()
+	}
+	if c := r.Cap(); c != op.cap {
+		t.Fatalf("expected cap: %v; got: %v", op.cap, c)
+	}
+	if l := r.Len(); l != len(op.items) {
+		t.Errorf("expected Len(): %v; got: %v", len(op.items), l)
+	}
+	var got []T
+	for i := 0; ; i++ {
+		v, ok := r.Nth(i)
+		if !ok {
+			break
+		}
+		got = append(got, v)
+	}
+	if l := len(got); l != len(op.items) {
+		t.Errorf("expected items: %v\ngot items: %v", op.items, got)
+	}
+	for i := range op.items {
+		if op.items[i] != got[i] {
+			t.Fatalf("expected items: %v\ngot items: %v", op.items, got)
+		}
+	}
+	if v, ok := r.Nth(len(op.items)); ok || v != zero {
+		t.Fatalf("expected no more items, got: v=%v; ok=%v", v, ok)
+	}
+}
diff --git a/parser/bench_test.go b/parser/bench_test.go
new file mode 100644
index 000000000..0b9a69276
--- /dev/null
+++ b/parser/bench_test.go
@@ -0,0 +1,20 @@
+package parser
+
+import "testing"
+
+func BenchmarkParser(b *testing.B) {
+	const source = `
+		/*
+			Showing worst case scenario
+		*/
+		let value = trim("contains escapes \n\"\\ \U0001F600 and non ASCII ñ"); // inline comment
+		len(value) == 0x2A
+		// let's introduce an error too
+		whatever
+	`
+	b.ReportAllocs()
+	p := new(Parser)
+	for i := 0; i < b.N; i++ {
+		p.Parse(source, nil)
+	}
+}
diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go
index e6b06c09d..f417f02b6 100644
--- a/parser/lexer/lexer.go
+++ b/parser/lexer/lexer.go
@@ -2,152 +2,178 @@ package lexer
 
 import (
 	"fmt"
+	"io"
 	"strings"
+	"unicode/utf8"
 
 	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/internal/ring"
 )
 
+const ringChunkSize = 10
+
+// Lex will buffer and return the tokens of a disposable *[Lexer].
 func Lex(source file.Source) ([]Token, error) {
-	l := &lexer{
-		source: source,
-		tokens: make([]Token, 0),
-		start:  0,
-		end:    0,
+	tokens := make([]Token, 0, ringChunkSize)
+	l := New()
+	l.Reset(source)
+	for {
+		t, err := l.Next()
+		switch err {
+		case nil:
+			tokens = append(tokens, t)
+		case io.EOF:
+			return tokens, nil
+		default:
+			return nil, err
+		}
 	}
-	l.commit()
+}
 
-	for state := root; state != nil; {
-		state = state(l)
+// New returns a reusable lexer.
+func New() *Lexer {
+	return &Lexer{
+		tokens: ring.New[Token](ringChunkSize),
 	}
+}
 
-	if l.err != nil {
-		return nil, l.err.Bind(source)
+type Lexer struct {
+	state      stateFn
+	source     file.Source
+	tokens     *ring.Ring[Token]
+	err        *file.Error
+	start, end struct {
+		byte, rune int
 	}
+	eof bool
+}
 
-	return l.tokens, nil
+func (l *Lexer) Reset(source file.Source) {
+	l.source = source
+	l.tokens.Reset()
+	l.state = root
 }
 
-type lexer struct {
-	source     file.Source
-	tokens     []Token
-	start, end int
-	err        *file.Error
+func (l *Lexer) Next() (Token, error) {
+	for l.state != nil && l.err == nil && l.tokens.Len() == 0 {
+		l.state = l.state(l)
+	}
+	if l.err != nil {
+		return Token{}, l.err.Bind(l.source)
+	}
+	if t, ok := l.tokens.Dequeue(); ok {
+		return t, nil
+	}
+	return Token{}, io.EOF
 }
 
 const eof rune = -1
 
-func (l *lexer) commit() {
+func (l *Lexer) commit() {
 	l.start = l.end
 }
 
-func (l *lexer) next() rune {
-	if l.end >= len(l.source) {
-		l.end++
+func (l *Lexer) next() rune {
+	if l.end.byte >= len(l.source.String()) {
+		l.eof = true
 		return eof
 	}
-	r := l.source[l.end]
-	l.end++
+	r, sz := utf8.DecodeRuneInString(l.source.String()[l.end.byte:])
+	l.end.rune++
+	l.end.byte += sz
 	return r
 }
 
-func (l *lexer) peek() rune {
-	r := l.next()
-	l.backup()
-	return r
+func (l *Lexer) peek() rune {
+	if l.end.byte < len(l.source.String()) {
+		r, _ := utf8.DecodeRuneInString(l.source.String()[l.end.byte:])
+		return r
+	}
+	return eof
 }
 
-func (l *lexer) backup() {
-	l.end--
+func (l *Lexer) peekByte() (byte, bool) {
+	if l.end.byte >= 0 && l.end.byte < len(l.source.String()) {
+		return l.source.String()[l.end.byte], true
+	}
+	return 0, false
 }
 
-func (l *lexer) emit(t Kind) {
+func (l *Lexer) backup() {
+	if l.eof {
+		l.eof = false
+	} else if l.end.rune > 0 {
+		_, sz := utf8.DecodeLastRuneInString(l.source.String()[:l.end.byte])
+		l.end.byte -= sz
+		l.end.rune--
+	}
+}
+
+func (l *Lexer) emit(t Kind) {
 	l.emitValue(t, l.word())
 }
 
-func (l *lexer) emitValue(t Kind, value string) {
-	l.tokens = append(l.tokens, Token{
-		Location: file.Location{From: l.start, To: l.end},
+func (l *Lexer) emitValue(t Kind, value string) {
+	l.tokens.Enqueue(Token{
+		Location: file.Location{From: l.start.rune, To: l.end.rune},
 		Kind:     t,
 		Value:    value,
 	})
 	l.commit()
 }
 
-func (l *lexer) emitEOF() {
-	from := l.end - 2
+func (l *Lexer) emitEOF() {
+	from := l.end.rune - 1
 	if from < 0 {
 		from = 0
 	}
-	to := l.end - 1
+	to := l.end.rune - 0
 	if to < 0 {
 		to = 0
 	}
-	l.tokens = append(l.tokens, Token{
+	l.tokens.Enqueue(Token{
 		Location: file.Location{From: from, To: to},
 		Kind:     EOF,
 	})
 	l.commit()
 }
 
-func (l *lexer) skip() {
+func (l *Lexer) skip() {
 	l.commit()
 }
 
-func (l *lexer) word() string {
-	// TODO: boundary check is NOT needed here, but for some reason CI fuzz tests are failing.
-	if l.start > len(l.source) || l.end > len(l.source) {
-		return "__invalid__"
-	}
-	return string(l.source[l.start:l.end])
+func (l *Lexer) word() string {
+	return l.source.String()[l.start.byte:l.end.byte]
 }
 
-func (l *lexer) accept(valid string) bool {
-	if strings.ContainsRune(valid, l.next()) {
+func (l *Lexer) accept(valid string) bool {
+	if strings.ContainsRune(valid, l.peek()) {
+		l.next()
 		return true
 	}
-	l.backup()
 	return false
 }
 
-func (l *lexer) acceptRun(valid string) {
-	for strings.ContainsRune(valid, l.next()) {
+func (l *Lexer) acceptRun(valid string) {
+	for l.accept(valid) {
 	}
-	l.backup()
 }
 
-func (l *lexer) skipSpaces() {
-	r := l.peek()
-	for ; r == ' '; r = l.peek() {
-		l.next()
-	}
+func (l *Lexer) skipSpaces() {
+	l.acceptRun(" ")
 	l.skip()
 }
 
-func (l *lexer) acceptWord(word string) bool {
-	pos := l.end
-
-	l.skipSpaces()
-
-	for _, ch := range word {
-		if l.next() != ch {
-			l.end = pos
-			return false
-		}
-	}
-	if r := l.peek(); r != ' ' && r != eof {
-		l.end = pos
-		return false
-	}
-
-	return true
-}
-
-func (l *lexer) error(format string, args ...any) stateFn {
+func (l *Lexer) error(format string, args ...any) stateFn {
 	if l.err == nil { // show first error
+		end := l.end.rune
+		if l.eof {
+			end++
+		}
 		l.err = &file.Error{
 			Location: file.Location{
-				From: l.end - 1,
-				To:   l.end,
+				From: end - 1,
+				To:   end,
 			},
 			Message: fmt.Sprintf(format, args...),
 		}
@@ -167,7 +193,7 @@ func digitVal(ch rune) int {
 
 func lower(ch rune) rune { return ('a' - 'A') | ch } // returns lower-case ch iff ch is ASCII letter
 
-func (l *lexer) scanDigits(ch rune, base, n int) rune {
+func (l *Lexer) scanDigits(ch rune, base, n int) rune {
 	for n > 0 && digitVal(ch) < base {
 		ch = l.next()
 		n--
@@ -178,7 +204,7 @@ func (l *lexer) scanDigits(ch rune, base, n int) rune {
 	return ch
 }
 
-func (l *lexer) scanEscape(quote rune) rune {
+func (l *Lexer) scanEscape(quote rune) rune {
 	ch := l.next() // read character after '/'
 	switch ch {
 	case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', quote:
@@ -198,7 +224,7 @@ func (l *lexer) scanEscape(quote rune) rune {
 	return ch
 }
 
-func (l *lexer) scanString(quote rune) (n int) {
+func (l *Lexer) scanString(quote rune) (n int) {
 	ch := l.next() // read character after quote
 	for ch != quote {
 		if ch == '\n' || ch == eof {
@@ -215,7 +241,7 @@ func (l *lexer) scanString(quote rune) (n int) {
 	return
 }
 
-func (l *lexer) scanRawString(quote rune) (n int) {
+func (l *Lexer) scanRawString(quote rune) (n int) {
 	ch := l.next() // read character after back tick
 	for ch != quote {
 		if ch == eof {
@@ -225,6 +251,6 @@ func (l *lexer) scanRawString(quote rune) (n int) {
 		ch = l.next()
 		n++
 	}
-	l.emitValue(String, string(l.source[l.start+1:l.end-1]))
+	l.emitValue(String, l.source.String()[l.start.byte+1:l.end.byte-1])
 	return
 }
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index db02d2acf..5171f4255 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -335,6 +335,7 @@ literal not terminated (1:10)
 früh ♥︎
 unrecognized character: U+2665 '♥' (1:6)
  | früh ♥︎
+ | .....^
 `
 
 func TestLex_error(t *testing.T) {
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index c694a2ca0..e5ad45bcd 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -6,9 +6,9 @@ import (
 	"github.com/expr-lang/expr/parser/utils"
 )
 
-type stateFn func(*lexer) stateFn
+type stateFn func(*Lexer) stateFn
 
-func root(l *lexer) stateFn {
+func root(l *Lexer) stateFn {
 	switch r := l.next(); {
 	case r == eof:
 		l.emitEOF()
@@ -61,7 +61,7 @@ func root(l *lexer) stateFn {
 	return root
 }
 
-func number(l *lexer) stateFn {
+func number(l *Lexer) stateFn {
 	if !l.scanNumber() {
 		return l.error("bad number syntax: %q", l.word())
 	}
@@ -69,7 +69,7 @@ func number(l *lexer) stateFn {
 	return root
 }
 
-func (l *lexer) scanNumber() bool {
+func (l *Lexer) scanNumber() bool {
 	digits := "0123456789_"
 	// Is it hex?
 	if l.accept("0") {
@@ -107,7 +107,7 @@ func (l *lexer) scanNumber() bool {
 	return true
 }
 
-func dot(l *lexer) stateFn {
+func dot(l *Lexer) stateFn {
 	l.next()
 	if l.accept("0123456789") {
 		l.backup()
@@ -118,7 +118,7 @@ func dot(l *lexer) stateFn {
 	return root
 }
 
-func identifier(l *lexer) stateFn {
+func identifier(l *Lexer) stateFn {
 loop:
 	for {
 		switch r := l.next(); {
@@ -140,7 +140,7 @@ loop:
 	return root
 }
 
-func not(l *lexer) stateFn {
+func not(l *Lexer) stateFn {
 	l.emit(Operator)
 
 	l.skipSpaces()
@@ -167,13 +167,13 @@ func not(l *lexer) stateFn {
 	return root
 }
 
-func questionMark(l *lexer) stateFn {
+func questionMark(l *Lexer) stateFn {
 	l.accept(".?")
 	l.emit(Operator)
 	return root
 }
 
-func slash(l *lexer) stateFn {
+func slash(l *Lexer) stateFn {
 	if l.accept("/") {
 		return singleLineComment
 	}
@@ -184,7 +184,7 @@ func slash(l *lexer) stateFn {
 	return root
 }
 
-func singleLineComment(l *lexer) stateFn {
+func singleLineComment(l *Lexer) stateFn {
 	for {
 		r := l.next()
 		if r == eof || r == '\n' {
@@ -195,7 +195,7 @@ func singleLineComment(l *lexer) stateFn {
 	return root
 }
 
-func multiLineComment(l *lexer) stateFn {
+func multiLineComment(l *Lexer) stateFn {
 	for {
 		r := l.next()
 		if r == eof {
@@ -209,7 +209,7 @@ func multiLineComment(l *lexer) stateFn {
 	return root
 }
 
-func pointer(l *lexer) stateFn {
+func pointer(l *Lexer) stateFn {
 	l.accept("#")
 	l.emit(Operator)
 	for {
diff --git a/parser/lexer/token.go b/parser/lexer/token.go
index 459fa6905..c809c690e 100644
--- a/parser/lexer/token.go
+++ b/parser/lexer/token.go
@@ -31,17 +31,13 @@ func (t Token) String() string {
 }
 
 func (t Token) Is(kind Kind, values ...string) bool {
-	if len(values) == 0 {
-		return kind == t.Kind
+	if kind != t.Kind {
+		return false
 	}
-
 	for _, v := range values {
 		if v == t.Value {
-			goto found
+			return true
 		}
 	}
-	return false
-
-found:
-	return kind == t.Kind
+	return len(values) == 0
 }
diff --git a/parser/lexer/utils.go b/parser/lexer/utils.go
index 5c9e6b59d..fdb8beaa1 100644
--- a/parser/lexer/utils.go
+++ b/parser/lexer/utils.go
@@ -36,7 +36,8 @@ func unescape(value string) (string, error) {
 	if size >= math.MaxInt {
 		return "", fmt.Errorf("too large string")
 	}
-	buf := make([]byte, 0, size)
+	buf := new(strings.Builder)
+	buf.Grow(int(size))
 	for len(value) > 0 {
 		c, multibyte, rest, err := unescapeChar(value)
 		if err != nil {
@@ -44,13 +45,13 @@ func unescape(value string) (string, error) {
 		}
 		value = rest
 		if c < utf8.RuneSelf || !multibyte {
-			buf = append(buf, byte(c))
+			buf.WriteByte(byte(c))
 		} else {
 			n := utf8.EncodeRune(runeTmp[:], c)
-			buf = append(buf, runeTmp[:n]...)
+			buf.Write(runeTmp[:n])
 		}
 	}
-	return string(buf), nil
+	return buf.String(), nil
 }
 
 // unescapeChar takes a string input and returns the following info:
diff --git a/parser/parser.go b/parser/parser.go
index 0a463fed5..e1dd111fc 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -1,7 +1,9 @@
 package parser
 
 import (
+	"errors"
 	"fmt"
+	"io"
 	"math"
 	"strconv"
 	"strings"
@@ -10,6 +12,7 @@ import (
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
+	"github.com/expr-lang/expr/parser/lexer"
 	. "github.com/expr-lang/expr/parser/lexer"
 	"github.com/expr-lang/expr/parser/operator"
 	"github.com/expr-lang/expr/parser/utils"
@@ -44,17 +47,50 @@ var predicates = map[string]struct {
 	"reduce":        {[]arg{expr, predicate, expr | optional}},
 }
 
-type parser struct {
-	tokens    []Token
-	current   Token
-	pos       int
-	err       *file.Error
-	config    *conf.Config
-	depth     int  // predicate call depth
-	nodeCount uint // tracks number of AST nodes created
+// Parser is a reusable parser. The zero value is ready for use.
+type Parser struct {
+	lexer            *lexer.Lexer
+	current, stashed Token
+	hasStash         bool
+	err              *file.Error
+	config           *conf.Config
+	depth            int  // predicate call depth
+	nodeCount        uint // tracks number of AST nodes created
 }
 
-func (p *parser) checkNodeLimit() error {
+func (p *Parser) Parse(input string, config *conf.Config) (*Tree, error) {
+	if p.lexer == nil {
+		p.lexer = lexer.New()
+	}
+	p.config = config
+	source := file.NewSource(input)
+	p.lexer.Reset(source)
+	p.next()
+	node := p.parseSequenceExpression()
+
+	if !p.current.Is(EOF) {
+		p.error("unexpected token %v", p.current)
+	}
+
+	tree := &Tree{
+		Node:   node,
+		Source: source,
+	}
+	err := p.err
+
+	// cleanup non-reusable pointer values and reset state
+	p.err = nil
+	p.config = nil
+	p.lexer.Reset(file.Source{})
+
+	if err != nil {
+		return tree, err.Bind(source)
+	}
+
+	return tree, nil
+}
+
+func (p *Parser) checkNodeLimit() error {
 	p.nodeCount++
 	if p.config == nil {
 		if p.nodeCount > conf.DefaultMaxNodes {
@@ -70,7 +106,7 @@ func (p *parser) checkNodeLimit() error {
 	return nil
 }
 
-func (p *parser) createNode(n Node, loc file.Location) Node {
+func (p *Parser) createNode(n Node, loc file.Location) Node {
 	if err := p.checkNodeLimit(); err != nil {
 		return nil
 	}
@@ -81,7 +117,7 @@ func (p *parser) createNode(n Node, loc file.Location) Node {
 	return n
 }
 
-func (p *parser) createMemberNode(n *MemberNode, loc file.Location) *MemberNode {
+func (p *Parser) createMemberNode(n *MemberNode, loc file.Location) *MemberNode {
 	if err := p.checkNodeLimit(); err != nil {
 		return nil
 	}
@@ -102,42 +138,14 @@ func Parse(input string) (*Tree, error) {
 }
 
 func ParseWithConfig(input string, config *conf.Config) (*Tree, error) {
-	source := file.NewSource(input)
-
-	tokens, err := Lex(source)
-	if err != nil {
-		return nil, err
-	}
-
-	p := &parser{
-		tokens:  tokens,
-		current: tokens[0],
-		config:  config,
-	}
-
-	node := p.parseSequenceExpression()
-
-	if !p.current.Is(EOF) {
-		p.error("unexpected token %v", p.current)
-	}
-
-	tree := &Tree{
-		Node:   node,
-		Source: source,
-	}
-
-	if p.err != nil {
-		return tree, p.err.Bind(source)
-	}
-
-	return tree, nil
+	return new(Parser).Parse(input, config)
 }
 
-func (p *parser) error(format string, args ...any) {
+func (p *Parser) error(format string, args ...any) {
 	p.errorAt(p.current, format, args...)
 }
 
-func (p *parser) errorAt(token Token, format string, args ...any) {
+func (p *Parser) errorAt(token Token, format string, args ...any) {
 	if p.err == nil { // show first error
 		p.err = &file.Error{
 			Location: token.Location,
@@ -146,16 +154,32 @@ func (p *parser) errorAt(token Token, format string, args ...any) {
 	}
 }
 
-func (p *parser) next() {
-	p.pos++
-	if p.pos >= len(p.tokens) {
-		p.error("unexpected end of expression")
+func (p *Parser) next() {
+	if p.hasStash {
+		p.current = p.stashed
+		p.hasStash = false
 		return
 	}
-	p.current = p.tokens[p.pos]
+
+	token, err := p.lexer.Next()
+	var e *file.Error
+	switch {
+	case err == nil:
+		p.current = token
+	case errors.Is(err, io.EOF):
+		p.error("unexpected end of expression")
+	case errors.As(err, &e):
+		p.err = e
+	default:
+		p.err = &file.Error{
+			Location: p.current.Location,
+			Message:  "unknown lexing error",
+			Prev:     err,
+		}
+	}
 }
 
-func (p *parser) expect(kind Kind, values ...string) {
+func (p *Parser) expect(kind Kind, values ...string) {
 	if p.current.Is(kind, values...) {
 		p.next()
 		return
@@ -165,7 +189,7 @@ func (p *parser) expect(kind Kind, values ...string) {
 
 // parse functions
 
-func (p *parser) parseSequenceExpression() Node {
+func (p *Parser) parseSequenceExpression() Node {
 	nodes := []Node{p.parseExpression(0)}
 
 	for p.current.Is(Operator, ";") && p.err == nil {
@@ -186,7 +210,7 @@ func (p *parser) parseSequenceExpression() Node {
 	}, nodes[0].Location())
 }
 
-func (p *parser) parseExpression(precedence int) Node {
+func (p *Parser) parseExpression(precedence int) Node {
 	if p.err != nil {
 		return nil
 	}
@@ -209,15 +233,16 @@ func (p *parser) parseExpression(precedence int) Node {
 
 		// Handle "not *" operator, like "not in" or "not contains".
 		if negate {
-			currentPos := p.pos
+			tokenBackup := p.current
 			p.next()
 			if operator.AllowedNegateSuffix(p.current.Value) {
 				if op, ok := operator.Binary[p.current.Value]; ok && op.Precedence >= precedence {
 					notToken = p.current
 					opToken = p.current
 				} else {
-					p.pos = currentPos
-					p.current = opToken
+					p.hasStash = true
+					p.stashed = p.current
+					p.current = tokenBackup
 					break
 				}
 			} else {
@@ -288,7 +313,7 @@ func (p *parser) parseExpression(precedence int) Node {
 	return nodeLeft
 }
 
-func (p *parser) parseVariableDeclaration() Node {
+func (p *Parser) parseVariableDeclaration() Node {
 	p.expect(Operator, "let")
 	variableName := p.current
 	p.expect(Identifier)
@@ -303,7 +328,7 @@ func (p *parser) parseVariableDeclaration() Node {
 	}, variableName.Location)
 }
 
-func (p *parser) parseConditionalIf() Node {
+func (p *Parser) parseConditionalIf() Node {
 	p.next()
 	nodeCondition := p.parseExpression(0)
 	p.expect(Bracket, "{")
@@ -322,7 +347,7 @@ func (p *parser) parseConditionalIf() Node {
 
 }
 
-func (p *parser) parseConditional(node Node) Node {
+func (p *Parser) parseConditional(node Node) Node {
 	var expr1, expr2 Node
 	for p.current.Is(Operator, "?") && p.err == nil {
 		p.next()
@@ -349,7 +374,7 @@ func (p *parser) parseConditional(node Node) Node {
 	return node
 }
 
-func (p *parser) parsePrimary() Node {
+func (p *Parser) parsePrimary() Node {
 	token := p.current
 
 	if token.Is(Operator) {
@@ -402,7 +427,7 @@ func (p *parser) parsePrimary() Node {
 	return p.parseSecondary()
 }
 
-func (p *parser) parseSecondary() Node {
+func (p *Parser) parseSecondary() Node {
 	var node Node
 	token := p.current
 
@@ -501,7 +526,7 @@ func (p *parser) parseSecondary() Node {
 	return p.parsePostfixExpression(node)
 }
 
-func (p *parser) toIntegerNode(number int64) Node {
+func (p *Parser) toIntegerNode(number int64) Node {
 	if number > math.MaxInt {
 		p.error("integer literal is too large")
 		return nil
@@ -509,7 +534,7 @@ func (p *parser) toIntegerNode(number int64) Node {
 	return p.createNode(&IntegerNode{Value: int(number)}, p.current.Location)
 }
 
-func (p *parser) toFloatNode(number float64) Node {
+func (p *Parser) toFloatNode(number float64) Node {
 	if number > math.MaxFloat64 {
 		p.error("float literal is too large")
 		return nil
@@ -517,7 +542,7 @@ func (p *parser) toFloatNode(number float64) Node {
 	return p.createNode(&FloatNode{Value: number}, p.current.Location)
 }
 
-func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) Node {
+func (p *Parser) parseCall(token Token, arguments []Node, checkOverrides bool) Node {
 	var node Node
 
 	isOverridden := false
@@ -595,7 +620,7 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 	return node
 }
 
-func (p *parser) parseArguments(arguments []Node) []Node {
+func (p *Parser) parseArguments(arguments []Node) []Node {
 	// If pipe operator is used, the first argument is the left-hand side
 	// of the operator, so we do not parse it as an argument inside brackets.
 	offset := len(arguments)
@@ -616,7 +641,7 @@ func (p *parser) parseArguments(arguments []Node) []Node {
 	return arguments
 }
 
-func (p *parser) parsePredicate() Node {
+func (p *Parser) parsePredicate() Node {
 	startToken := p.current
 	withBrackets := false
 	if p.current.Is(Bracket, "{") {
@@ -648,7 +673,7 @@ func (p *parser) parsePredicate() Node {
 	return predicateNode
 }
 
-func (p *parser) parseArrayExpression(token Token) Node {
+func (p *Parser) parseArrayExpression(token Token) Node {
 	nodes := make([]Node, 0)
 
 	p.expect(Bracket, "[")
@@ -672,7 +697,7 @@ end:
 	return node
 }
 
-func (p *parser) parseMapExpression(token Token) Node {
+func (p *Parser) parseMapExpression(token Token) Node {
 	p.expect(Bracket, "{")
 
 	nodes := make([]Node, 0)
@@ -725,7 +750,7 @@ end:
 	return node
 }
 
-func (p *parser) parsePostfixExpression(node Node) Node {
+func (p *Parser) parsePostfixExpression(node Node) Node {
 	postfixToken := p.current
 	for (postfixToken.Is(Operator) || postfixToken.Is(Bracket)) && p.err == nil {
 		optional := postfixToken.Value == "?."
@@ -855,7 +880,7 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 	}
 	return node
 }
-func (p *parser) parseComparison(left Node, token Token, precedence int) Node {
+func (p *Parser) parseComparison(left Node, token Token, precedence int) Node {
 	var rootNode Node
 	for {
 		comparator := p.parseExpression(precedence + 1)
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 91752a419..817fc6cc2 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -8,6 +8,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr"
@@ -609,10 +610,10 @@ func TestVM_DirectCallOpcodes(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			program := vm.NewProgram(
-				nil, // source
-				nil, // node
-				nil, // locations
-				0,   // variables
+				file.Source{}, // source
+				nil,           // node
+				nil,           // locations
+				0,             // variables
 				tt.consts,
 				tt.bytecode,
 				tt.args,
@@ -735,10 +736,10 @@ func TestVM_IndexAndCountOperations(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			program := vm.NewProgram(
-				nil, // source
-				nil, // node
-				nil, // locations
-				0,   // variables
+				file.Source{}, // source
+				nil,           // node
+				nil,           // locations
+				0,             // variables
 				tt.consts,
 				tt.bytecode,
 				tt.args,
@@ -1176,10 +1177,10 @@ func TestVM_DirectBasicOpcodes(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			program := vm.NewProgram(
-				nil, // source
-				nil, // node
-				nil, // locations
-				0,   // variables
+				file.Source{}, // source
+				nil,           // node
+				nil,           // locations
+				0,             // variables
 				tt.consts,
 				tt.bytecode,
 				tt.args,

From 85d0be85096d16dc1e06d8f893b353133daa008d Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Mon, 30 Jun 2025 15:14:08 -0300
Subject: [PATCH 438/506] Ignoring fields with struct tag expr:"-" and make
 "in" return false for unexported fields (#806)

* allow ignoring struct member using a - in expr struct tag

* fix in operator

* simplify logic

* add regression test for #807

* fixes #807: make in operator return false for unexported struct fields

---------

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 builtin/lib.go          |   8 +++-
 checker/nature/utils.go |  20 +++++---
 expr_test.go            | 101 +++++++++++++++++++++++++++++++++++++++-
 vm/runtime/runtime.go   |  14 ++++--
 4 files changed, 130 insertions(+), 13 deletions(-)

diff --git a/builtin/lib.go b/builtin/lib.go
index 579393161..6f6a3b6cd 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -421,10 +421,14 @@ func get(params ...any) (out any, err error) {
 		fieldName := i.(string)
 		value := v.FieldByNameFunc(func(name string) bool {
 			field, _ := v.Type().FieldByName(name)
-			if field.Tag.Get("expr") == fieldName {
+			switch field.Tag.Get("expr") {
+			case "-":
+				return false
+			case fieldName:
 				return true
+			default:
+				return name == fieldName
 			}
-			return name == fieldName
 		})
 		if value.IsValid() {
 			return value.Interface(), nil
diff --git a/checker/nature/utils.go b/checker/nature/utils.go
index 179459874..c1551546c 100644
--- a/checker/nature/utils.go
+++ b/checker/nature/utils.go
@@ -6,11 +6,15 @@ import (
 	"github.com/expr-lang/expr/internal/deref"
 )
 
-func fieldName(field reflect.StructField) string {
-	if taggedName := field.Tag.Get("expr"); taggedName != "" {
-		return taggedName
+func fieldName(field reflect.StructField) (string, bool) {
+	switch taggedName := field.Tag.Get("expr"); taggedName {
+	case "-":
+		return "", false
+	case "":
+		return field.Name, true
+	default:
+		return taggedName, true
 	}
-	return field.Name
 }
 
 func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
@@ -23,7 +27,7 @@ func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
 	for i := 0; i < t.NumField(); i++ {
 		field := t.Field(i)
 		// Search all fields, even embedded structs.
-		if fieldName(field) == name {
+		if n, ok := fieldName(field); ok && n == name {
 			return field, true
 		}
 	}
@@ -69,7 +73,11 @@ func StructFields(t reflect.Type) map[string]Nature {
 				}
 			}
 
-			table[fieldName(f)] = Nature{
+			name, ok := fieldName(f)
+			if !ok {
+				continue
+			}
+			table[name] = Nature{
 				Type:       f.Type,
 				FieldIndex: f.Index,
 			}
diff --git a/expr_test.go b/expr_test.go
index 57d2cfbbb..32ec6dfb8 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"reflect"
+	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -139,7 +140,86 @@ func ExampleEnv_tagged_field_names() {
 
 	fmt.Printf("%v", output)
 
-	// Output : Hello World
+	// Output: Hello World
+}
+
+func ExampleEnv_hidden_tagged_field_names() {
+	type Internal struct {
+		Visible string
+		Hidden  string `expr:"-"`
+	}
+	type environment struct {
+		Visible         string
+		Hidden          string   `expr:"-"`
+		HiddenInternal  Internal `expr:"-"`
+		VisibleInternal Internal
+	}
+
+	env := environment{
+		Hidden: "First level secret",
+		HiddenInternal: Internal{
+			Visible: "Second level secret",
+			Hidden:  "Also hidden",
+		},
+		VisibleInternal: Internal{
+			Visible: "Not a secret",
+			Hidden:  "Hidden too",
+		},
+	}
+
+	hiddenValues := []string{
+		`Hidden`,
+		`HiddenInternal`,
+		`HiddenInternal.Visible`,
+		`HiddenInternal.Hidden`,
+		`VisibleInternal["Hidden"]`,
+	}
+	for _, expression := range hiddenValues {
+		output, err := expr.Eval(expression, env)
+		if err == nil || !strings.Contains(err.Error(), "cannot fetch") {
+			fmt.Printf("unexpected output: %v; err: %v\n", output, err)
+			return
+		}
+		fmt.Printf("%q is hidden as expected\n", expression)
+	}
+
+	visibleValues := []string{
+		`Visible`,
+		`VisibleInternal`,
+		`VisibleInternal["Visible"]`,
+	}
+	for _, expression := range visibleValues {
+		_, err := expr.Eval(expression, env)
+		if err != nil {
+			fmt.Printf("unexpected error: %v\n", err)
+			return
+		}
+		fmt.Printf("%q is visible as expected\n", expression)
+	}
+
+	testWithIn := []string{
+		`not ("Hidden" in $env)`,
+		`"Visible" in $env`,
+		`not ("Hidden" in VisibleInternal)`,
+		`"Visible" in VisibleInternal`,
+	}
+	for _, expression := range testWithIn {
+		val, err := expr.Eval(expression, env)
+		shouldBeTrue, ok := val.(bool)
+		if err != nil || !ok || !shouldBeTrue {
+			fmt.Printf("unexpected result; value: %v; error: %v\n", val, err)
+			return
+		}
+	}
+
+	// Output: "Hidden" is hidden as expected
+	// "HiddenInternal" is hidden as expected
+	// "HiddenInternal.Visible" is hidden as expected
+	// "HiddenInternal.Hidden" is hidden as expected
+	// "VisibleInternal[\"Hidden\"]" is hidden as expected
+	// "Visible" is visible as expected
+	// "VisibleInternal" is visible as expected
+	// "VisibleInternal[\"Visible\"]" is visible as expected
 }
 
 func ExampleAsKind() {
@@ -529,7 +609,7 @@ func ExamplePatch() {
 	}
 	fmt.Printf("%v", output)
 
-	// Output : Hello, you, world!
+	// Output: Hello, you, world!
 }
 
 func ExampleWithContext() {
@@ -2765,3 +2845,20 @@ func TestMemoryBudget(t *testing.T) {
 		})
 	}
 }
+
+func TestIssue807(t *testing.T) {
+	type MyStruct struct {
+		nonExported string
+	}
+	out, err := expr.Eval(` "nonExported" in $env `, MyStruct{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	b, ok := out.(bool)
+	if !ok {
+		t.Fatalf("expected boolean type, got %T: %v", b, b)
+	}
+	if b {
+		t.Fatalf("expected 'in' operator to return false for unexported field")
+	}
+}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index cd48a280d..fa14c4d0a 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -65,10 +65,14 @@ func Fetch(from, i any) any {
 		fieldName := i.(string)
 		value := v.FieldByNameFunc(func(name string) bool {
 			field, _ := v.Type().FieldByName(name)
-			if field.Tag.Get("expr") == fieldName {
+			switch field.Tag.Get("expr") {
+			case "-":
+				return false
+			case fieldName:
 				return true
+			default:
+				return name == fieldName
 			}
-			return name == fieldName
 		})
 		if value.IsValid() {
 			return value.Interface()
@@ -213,7 +217,11 @@ func In(needle any, array any) bool {
 		if !n.IsValid() || n.Kind() != reflect.String {
 			panic(fmt.Sprintf("cannot use %T as field name of %T", needle, array))
 		}
-		value := v.FieldByName(n.String())
+		field, ok := v.Type().FieldByName(n.String())
+		if !ok || !field.IsExported() || field.Tag.Get("expr") == "-" {
+			return false
+		}
+		value := v.FieldByIndex(field.Index)
 		if value.IsValid() {
 			return true
 		}

From f1c65fa312db6b2db3003d60fc514724b8223a4f Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Mon, 30 Jun 2025 15:21:25 -0300
Subject: [PATCH 439/506] Fix runtime error not allowing to slice unaddressable
 array type (#803)

* fix runtime error not allowing to slice unaddressable array type

* simplify logic and move test

* remove dead code

---------

Signed-off-by: Anton Medvedev <anton@medv.io>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 expr_test.go          | 17 +++++++++++++++++
 vm/runtime/runtime.go |  5 +++++
 2 files changed, 22 insertions(+)

diff --git a/expr_test.go b/expr_test.go
index 32ec6dfb8..14f6a15e7 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2846,6 +2846,23 @@ func TestMemoryBudget(t *testing.T) {
 	}
 }
 
+func TestIssue802(t *testing.T) {
+	prog, err := expr.Compile(`arr[1:2][0]`)
+	if err != nil {
+		t.Fatalf("error compiling program: %v", err)
+	}
+	val, err := expr.Run(prog, map[string]any{
+		"arr": [5]int{0, 1, 2, 3, 4},
+	})
+	if err != nil {
+		t.Fatalf("error running program: %v", err)
+	}
+	valInt, ok := val.(int)
+	if !ok || valInt != 1 {
+		t.Fatalf("invalid result, expected 1, got %v", val)
+	}
+}
+
 func TestIssue807(t *testing.T) {
 	type MyStruct struct {
 		nonExported string
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index fa14c4d0a..56759c531 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -166,6 +166,11 @@ func Slice(array, from, to any) any {
 		if a > b {
 			a = b
 		}
+		if v.Kind() == reflect.Array && !v.CanAddr() {
+			newValue := reflect.New(v.Type()).Elem()
+			newValue.Set(v)
+			v = newValue
+		}
 		value := v.Slice(a, b)
 		if value.IsValid() {
 			return value.Interface()

From 11286428d375e5fcf9d76f598aaf7e58ba41e9a7 Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Sat, 5 Jul 2025 08:46:48 -0300
Subject: [PATCH 440/506] fix VM not clearing memory references when reused
 (#813)

---
 vm/vm.go | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/vm/vm.go b/vm/vm.go
index 3018619d9..ed61d2f90 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -67,9 +67,11 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 	if vm.Stack == nil {
 		vm.Stack = make([]any, 0, 2)
 	} else {
+		clearSlice(vm.Stack)
 		vm.Stack = vm.Stack[0:0]
 	}
 	if vm.Scopes != nil {
+		clearSlice(vm.Scopes)
 		vm.Scopes = vm.Scopes[0:0]
 	}
 	if len(vm.Variables) < program.variables {
@@ -614,3 +616,10 @@ func (vm *VM) Step() {
 func (vm *VM) Position() chan int {
 	return vm.curr
 }
+
+func clearSlice[S ~[]E, E any](s S) {
+	var zero E
+	for i := range s {
+		s[i] = zero // clear mem, optimized by the compiler, in Go 1.21 the "clear" builtin can be used
+	}
+}

From 87df78319489e4c4e00bb3ac1256c63aa8bd63f1 Mon Sep 17 00:00:00 2001
From: David Klassen <davidklassen@proton.me>
Date: Thu, 24 Jul 2025 13:29:13 +0700
Subject: [PATCH 441/506] Update README.md (#815)

Add Naoma.AI to the list of companies

Signed-off-by: David Klassen <davidklassen@proton.me>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index c0778a84d..5afd743d8 100644
--- a/README.md
+++ b/README.md
@@ -150,6 +150,7 @@ func main() {
 * [ByteDance](https://bytedance.com) incorporates Expr into its internal business rule engine.
 * [Aviasales](https://aviasales.ru) utilizes Expr as a business rule engine for its flight search engine.
 * [Wish.com](https://www.wish.com) employs Expr in its decision-making rule engine for the Wish Assistant.
+* [Naoma.AI](https://www.naoma.ai) uses Expr as a part of its call scoring engine.
 * [Argo](https://argoproj.github.io) integrates Expr into Argo Rollouts and Argo Workflows for Kubernetes.
 * [OpenTelemetry](https://opentelemetry.io) integrates Expr into the OpenTelemetry Collector.
 * [Philips Labs](https://github.com/philips-labs/tabia) employs Expr in Tabia, a tool designed to collect insights on their code bases.

From bbcbc530f31620623b36750365ee883aa4b86d8f Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Thu, 28 Aug 2025 06:06:51 -0300
Subject: [PATCH 442/506] Allow backticks to be quoted in string literals
 (#820)

* allow backticks to be quoted in string literals

* remove redundant empty string
---
 parser/lexer/lexer.go      | 42 +++++++++++++++++++++++++++++++++-----
 parser/lexer/lexer_test.go | 36 ++++++++++++++++++++++++++++++++
 2 files changed, 73 insertions(+), 5 deletions(-)

diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go
index f417f02b6..a8cf6a5be 100644
--- a/parser/lexer/lexer.go
+++ b/parser/lexer/lexer.go
@@ -242,15 +242,47 @@ func (l *Lexer) scanString(quote rune) (n int) {
 }
 
 func (l *Lexer) scanRawString(quote rune) (n int) {
-	ch := l.next() // read character after back tick
-	for ch != quote {
-		if ch == eof {
+	var escapedQuotes int
+loop:
+	for {
+		ch := l.next()
+		for ch == quote && l.peek() == quote {
+			// skip current and next char which are the quote escape sequence
+			l.next()
+			ch = l.next()
+			escapedQuotes++
+		}
+		switch ch {
+		case quote:
+			break loop
+		case eof:
 			l.error("literal not terminated")
 			return
 		}
-		ch = l.next()
 		n++
 	}
-	l.emitValue(String, l.source.String()[l.start.byte+1:l.end.byte-1])
+	str := l.source.String()[l.start.byte+1 : l.end.byte-1]
+
+	// handle simple case where no quoted backtick was found, then no allocation
+	// is needed for the new string
+	if escapedQuotes == 0 {
+		l.emitValue(String, str)
+		return
+	}
+
+	var b strings.Builder
+	var skipped bool
+	b.Grow(len(str) - escapedQuotes)
+	for _, r := range str {
+		if r == quote {
+			if !skipped {
+				skipped = true
+				continue
+			}
+			skipped = false
+		}
+		b.WriteRune(r)
+	}
+	l.emitValue(String, b.String())
 	return
 }
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index 5171f4255..baa5aabb1 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -68,6 +68,22 @@ func TestLex(t *testing.T) {
 				{Kind: EOF},
 			},
 		},
+		{
+			"`escaped backticks` `` `a``b` ```` `a``` ```b` ```a````b``` ```````` ```a````` `````b```",
+			[]Token{
+				{Kind: String, Value: "escaped backticks"},
+				{Kind: String, Value: ""},
+				{Kind: String, Value: "a`b"},
+				{Kind: String, Value: "`"},
+				{Kind: String, Value: "a`"},
+				{Kind: String, Value: "`b"},
+				{Kind: String, Value: "`a``b`"},
+				{Kind: String, Value: "```"},
+				{Kind: String, Value: "`a``"},
+				{Kind: String, Value: "``b`"},
+				{Kind: EOF},
+			},
+		},
 		{
 			"a and orb().val #.",
 			[]Token{
@@ -332,6 +348,26 @@ literal not terminated (1:10)
  | id "hello
  | .........^
 
+id ` + "`" + `hello
+literal not terminated (1:10)
+ | id ` + "`" + `hello
+ | .........^
+
+id ` + "`" + `hello` + "``" + `
+literal not terminated (1:12)
+ | id ` + "`" + `hello` + "``" + `
+ | ...........^
+
+id ` + "```" + `hello
+literal not terminated (1:12)
+ | id ` + "```" + `hello
+ | ...........^
+
+id ` + "`" + `hello` + "``" + ` world
+literal not terminated (1:18)
+ | id ` + "`" + `hello` + "``" + ` world
+ | .................^
+
 früh ♥︎
 unrecognized character: U+2665 '♥' (1:6)
  | früh ♥︎

From 1c09e5e9ec3d7f1237fb11c47c6cb1545c0c9bf8 Mon Sep 17 00:00:00 2001
From: Andreev Fedor <f.andreev.dev@gmail.com>
Date: Mon, 8 Sep 2025 12:40:52 +0400
Subject: [PATCH 443/506] Fix error position reporting in multiline script
 (#827)

---
 expr_test.go  | 11 +++++++++++
 file/error.go |  5 +++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index 14f6a15e7..bed6d7468 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1757,6 +1757,17 @@ func TestEval_exposed_error(t *testing.T) {
 	require.Equal(t, 1, fileError.Line)
 }
 
+func TestCompile_exposed_error_with_multiline_script(t *testing.T) {
+	_, err := expr.Compile("{\n\ta: 1,\n\tb: #,\n\tc: 3,\n}")
+	require.Error(t, err)
+
+	fileError, ok := err.(*file.Error)
+	require.True(t, ok, "error should be of type *file.Error")
+	require.Equal(t, "unexpected token Operator(\"#\") (3:5)\n |  b: #,\n | ....^", fileError.Error())
+	require.Equal(t, 4, fileError.Column)
+	require.Equal(t, 3, fileError.Line)
+}
+
 func TestIssue105(t *testing.T) {
 	type A struct {
 		Field string
diff --git a/file/error.go b/file/error.go
index 04253b6f6..c398ed59c 100644
--- a/file/error.go
+++ b/file/error.go
@@ -31,12 +31,13 @@ func (e *Error) Bind(source Source) *Error {
 			break
 		}
 		if r == '\n' {
-			lineStart = i
+			lineStart = i + 1
 			e.Line++
 			e.Column = 0
+		} else {
+			e.Column++
 		}
 		runeCount++
-		e.Column++
 	}
 
 	lineEnd := lineStart + strings.IndexByte(src[lineStart:], '\n')

From bcb2d51045da5fd5290d302d9132044a2993f280 Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Thu, 18 Sep 2025 09:38:27 -0300
Subject: [PATCH 444/506] Improve Performance of the Type System (#824)

* export the checker and ensure no methods or fields are exported

* make Checker reusable

* add PatchAndCheck method to Checker, and reuse it in visitors

* avoid unnecessary map and consolidate structs

* make all Nature methods use pointer-receiver

* added cache for type and nature information

* optimize type and nature checks

* more aggressively cache some partial results and add cheap checks

* cache reused values

* reduce copying in Nature by breaking down optional fields

* enforce use of cache

* improve ergonomics of FromType and NatureOf

* improve struct method fetching

* make cache private to Nature

* first iteration improving struct reflect caching

* cleaned up struct fields data

* improve caching of functions data

* simplify checker code

* simplify and remove dead code

* add checker benchmarks

* address PR comments and minor improvements

* rename from SetCache to Bind

* make the benchmarks more fair

* fix benchmark option not being applied

* move Cache to be argument instead of field

* merge FuncData into Optional

* rename Optional to TypeData

* simplify struct logic

* cache builtin numeric types

---------

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 ast/node.go                   |   2 +-
 checker/checker.go            | 962 ++++++++++++++++++----------------
 checker/checker_bench_test.go | 114 ++++
 checker/checker_test.go       |  23 +-
 checker/info.go               |  25 +-
 checker/nature/nature.go      | 586 ++++++++++++++++-----
 checker/nature/utils.go       | 247 +++++++--
 checker/types.go              | 190 -------
 compiler/compiler.go          |  29 +-
 conf/config.go                |   5 +-
 conf/env.go                   |  44 +-
 docgen/docgen.go              |   7 +-
 expr.go                       |   1 +
 internal/deref/deref.go       |   9 +
 parser/lexer/lexer.go         |   7 -
 parser/parser.go              |   5 +-
 patcher/operator_override.go  |   5 +-
 types/types.go                |  25 +-
 18 files changed, 1360 insertions(+), 926 deletions(-)
 create mode 100644 checker/checker_bench_test.go
 delete mode 100644 checker/types.go

diff --git a/ast/node.go b/ast/node.go
index 02923ac52..40c507aa6 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -66,7 +66,7 @@ func (n *base) Type() reflect.Type {
 
 // SetType sets the type of the node.
 func (n *base) SetType(t reflect.Type) {
-	n.nature.Type = t
+	n.nature = nature.FromType(t)
 }
 
 // NilNode represents nil.
diff --git a/checker/checker.go b/checker/checker.go
index f49234137..531dadac3 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"reflect"
 	"regexp"
+	"time"
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
@@ -13,17 +14,90 @@ import (
 	"github.com/expr-lang/expr/parser"
 )
 
+var (
+	anyType      = reflect.TypeOf(new(any)).Elem()
+	boolType     = reflect.TypeOf(true)
+	intType      = reflect.TypeOf(0)
+	floatType    = reflect.TypeOf(float64(0))
+	stringType   = reflect.TypeOf("")
+	arrayType    = reflect.TypeOf([]any{})
+	mapType      = reflect.TypeOf(map[string]any{})
+	timeType     = reflect.TypeOf(time.Time{})
+	durationType = reflect.TypeOf(time.Duration(0))
+
+	anyTypeSlice = []reflect.Type{anyType}
+)
+
+// ParseCheck parses input expression and checks its types. Also, it applies
+// all provided patchers. In case of error, it returns error with a tree.
+func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) {
+	tree, err := parser.ParseWithConfig(input, config)
+	if err != nil {
+		return tree, err
+	}
+
+	_, err = new(Checker).PatchAndCheck(tree, config)
+	if err != nil {
+		return tree, err
+	}
+
+	return tree, nil
+}
+
+// Check calls Check on a disposable Checker.
+func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) {
+	return new(Checker).Check(tree, config)
+}
+
+type Checker struct {
+	config          *conf.Config
+	predicateScopes []predicateScope
+	varScopes       []varScope
+	err             *file.Error
+	needsReset      bool
+}
+
+type predicateScope struct {
+	collection Nature
+	vars       []varScope
+}
+
+type varScope struct {
+	name   string
+	nature Nature
+}
+
+// PatchAndCheck applies all patchers and checks the tree.
+func (v *Checker) PatchAndCheck(tree *parser.Tree, config *conf.Config) (reflect.Type, error) {
+	v.reset(config)
+	if len(config.Visitors) > 0 {
+		// Run all patchers that dont support being run repeatedly first
+		v.runVisitors(tree, false)
+
+		// Run patchers that require multiple passes next (currently only Operator patching)
+		v.runVisitors(tree, true)
+	}
+	return v.Check(tree, config)
+}
+
+// Check checks types of the expression tree. It returns type of the expression
+// and error if any. If config is nil, then default configuration will be used.
+func (v *Checker) Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) {
+	v.reset(config)
+	return v.check(tree)
+}
+
 // Run visitors in a given config over the given tree
 // runRepeatable controls whether to filter for only vistors that require multiple passes or not
-func runVisitors(tree *parser.Tree, config *conf.Config, runRepeatable bool) {
+func (v *Checker) runVisitors(tree *parser.Tree, runRepeatable bool) {
 	for {
 		more := false
-		for _, v := range config.Visitors {
+		for _, visitor := range v.config.Visitors {
 			// We need to perform types check, because some visitors may rely on
 			// types information available in the tree.
-			_, _ = Check(tree, config)
+			_, _ = v.Check(tree, v.config)
 
-			r, repeatable := v.(interface {
+			r, repeatable := visitor.(interface {
 				Reset()
 				ShouldRepeat() bool
 			})
@@ -31,12 +105,12 @@ func runVisitors(tree *parser.Tree, config *conf.Config, runRepeatable bool) {
 			if repeatable {
 				if runRepeatable {
 					r.Reset()
-					ast.Walk(&tree.Node, v)
+					ast.Walk(&tree.Node, visitor)
 					more = more || r.ShouldRepeat()
 				}
 			} else {
 				if !runRepeatable {
-					ast.Walk(&tree.Node, v)
+					ast.Walk(&tree.Node, visitor)
 				}
 			}
 		}
@@ -47,38 +121,7 @@ func runVisitors(tree *parser.Tree, config *conf.Config, runRepeatable bool) {
 	}
 }
 
-// ParseCheck parses input expression and checks its types. Also, it applies
-// all provided patchers. In case of error, it returns error with a tree.
-func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) {
-	tree, err := parser.ParseWithConfig(input, config)
-	if err != nil {
-		return tree, err
-	}
-
-	if len(config.Visitors) > 0 {
-		// Run all patchers that dont support being run repeatedly first
-		runVisitors(tree, config, false)
-
-		// Run patchers that require multiple passes next (currently only Operator patching)
-		runVisitors(tree, config, true)
-	}
-	_, err = Check(tree, config)
-	if err != nil {
-		return tree, err
-	}
-
-	return tree, nil
-}
-
-// Check checks types of the expression tree. It returns type of the expression
-// and error if any. If config is nil, then default configuration will be used.
-func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) {
-	if config == nil {
-		config = conf.New(nil)
-	}
-
-	v := &checker{config: config}
-
+func (v *Checker) check(tree *parser.Tree) (reflect.Type, error) {
 	nt := v.visit(tree.Node)
 
 	// To keep compatibility with previous versions, we should return any, if nature is unknown.
@@ -93,19 +136,19 @@ func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) {
 
 	if v.config.Expect != reflect.Invalid {
 		if v.config.ExpectAny {
-			if isUnknown(nt) {
+			if nt.IsUnknown(&v.config.NtCache) {
 				return t, nil
 			}
 		}
 
 		switch v.config.Expect {
 		case reflect.Int, reflect.Int64, reflect.Float64:
-			if !isNumber(nt) {
-				return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, nt)
+			if !nt.IsNumber() {
+				return nil, fmt.Errorf("expected %v, but got %s", v.config.Expect, nt.String())
 			}
 		default:
-			if nt.Kind() != v.config.Expect {
-				return nil, fmt.Errorf("expected %v, but got %s", v.config.Expect, nt)
+			if nt.Kind != v.config.Expect {
+				return nil, fmt.Errorf("expected %v, but got %s", v.config.Expect, nt.String())
 			}
 		}
 	}
@@ -113,81 +156,76 @@ func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) {
 	return t, nil
 }
 
-type checker struct {
-	config          *conf.Config
-	predicateScopes []predicateScope
-	varScopes       []varScope
-	err             *file.Error
-}
-
-type predicateScope struct {
-	collection Nature
-	vars       map[string]Nature
-}
+func (v *Checker) reset(config *conf.Config) {
+	if v.needsReset {
+		clearSlice(v.predicateScopes)
+		clearSlice(v.varScopes)
+		v.predicateScopes = v.predicateScopes[:0]
+		v.varScopes = v.varScopes[:0]
+		v.err = nil
+	}
+	v.needsReset = true
 
-type varScope struct {
-	name   string
-	nature Nature
+	if config == nil {
+		config = conf.New(nil)
+	}
+	v.config = config
 }
 
-type info struct {
-	method bool
-	fn     *builtin.Function
-
-	// elem is element type of array or map.
-	// Arrays created with type []any, but
-	// we would like to detect expressions
-	// like `42 in ["a"]` as invalid.
-	elem reflect.Type
+func clearSlice[S ~[]E, E any](s S) {
+	var zero E
+	for i := range s {
+		s[i] = zero
+	}
 }
 
-func (v *checker) visit(node ast.Node) Nature {
+func (v *Checker) visit(node ast.Node) Nature {
 	var nt Nature
 	switch n := node.(type) {
 	case *ast.NilNode:
-		nt = v.NilNode(n)
+		nt = v.config.NtCache.NatureOf(nil)
 	case *ast.IdentifierNode:
-		nt = v.IdentifierNode(n)
+		nt = v.identifierNode(n)
 	case *ast.IntegerNode:
-		nt = v.IntegerNode(n)
+		nt = v.config.NtCache.FromType(intType)
 	case *ast.FloatNode:
-		nt = v.FloatNode(n)
+		nt = v.config.NtCache.FromType(floatType)
 	case *ast.BoolNode:
-		nt = v.BoolNode(n)
+		nt = v.config.NtCache.FromType(boolType)
 	case *ast.StringNode:
-		nt = v.StringNode(n)
+		nt = v.config.NtCache.FromType(stringType)
 	case *ast.ConstantNode:
-		nt = v.ConstantNode(n)
+		nt = v.config.NtCache.FromType(reflect.TypeOf(n.Value))
 	case *ast.UnaryNode:
-		nt = v.UnaryNode(n)
+		nt = v.unaryNode(n)
 	case *ast.BinaryNode:
-		nt = v.BinaryNode(n)
+		nt = v.binaryNode(n)
 	case *ast.ChainNode:
-		nt = v.ChainNode(n)
+		nt = v.chainNode(n)
 	case *ast.MemberNode:
-		nt = v.MemberNode(n)
+		nt = v.memberNode(n)
 	case *ast.SliceNode:
-		nt = v.SliceNode(n)
+		nt = v.sliceNode(n)
 	case *ast.CallNode:
-		nt = v.CallNode(n)
+		nt = v.callNode(n)
 	case *ast.BuiltinNode:
-		nt = v.BuiltinNode(n)
+		nt = v.builtinNode(n)
 	case *ast.PredicateNode:
-		nt = v.PredicateNode(n)
+		nt = v.predicateNode(n)
 	case *ast.PointerNode:
-		nt = v.PointerNode(n)
+		nt = v.pointerNode(n)
 	case *ast.VariableDeclaratorNode:
-		nt = v.VariableDeclaratorNode(n)
+		nt = v.variableDeclaratorNode(n)
 	case *ast.SequenceNode:
-		nt = v.SequenceNode(n)
+		nt = v.sequenceNode(n)
 	case *ast.ConditionalNode:
-		nt = v.ConditionalNode(n)
+		nt = v.conditionalNode(n)
 	case *ast.ArrayNode:
-		nt = v.ArrayNode(n)
+		nt = v.arrayNode(n)
 	case *ast.MapNode:
-		nt = v.MapNode(n)
+		nt = v.mapNode(n)
 	case *ast.PairNode:
-		nt = v.PairNode(n)
+		nt = v.pairNode(n)
 	default:
 		panic(fmt.Sprintf("undefined node type (%T)", node))
 	}
@@ -195,236 +233,226 @@ func (v *checker) visit(node ast.Node) Nature {
 	return nt
 }
 
-func (v *checker) error(node ast.Node, format string, args ...any) Nature {
+func (v *Checker) error(node ast.Node, format string, args ...any) Nature {
 	if v.err == nil { // show first error
 		v.err = &file.Error{
 			Location: node.Location(),
 			Message:  fmt.Sprintf(format, args...),
 		}
 	}
-	return unknown
+	return Nature{}
 }
 
-func (v *checker) NilNode(*ast.NilNode) Nature {
-	return nilNature
-}
-
-func (v *checker) IdentifierNode(node *ast.IdentifierNode) Nature {
-	if variable, ok := v.lookupVariable(node.Value); ok {
-		return variable.nature
+func (v *Checker) identifierNode(node *ast.IdentifierNode) Nature {
+	for i := len(v.varScopes) - 1; i >= 0; i-- {
+		if v.varScopes[i].name == node.Value {
+			return v.varScopes[i].nature
+		}
 	}
 	if node.Value == "$env" {
-		return unknown
+		return Nature{}
 	}
 
 	return v.ident(node, node.Value, v.config.Strict, true)
 }
 
 // ident method returns type of environment variable, builtin or function.
-func (v *checker) ident(node ast.Node, name string, strict, builtins bool) Nature {
-	if nt, ok := v.config.Env.Get(name); ok {
+func (v *Checker) ident(node ast.Node, name string, strict, builtins bool) Nature {
+	if nt, ok := v.config.Env.Get(&v.config.NtCache, name); ok {
 		return nt
 	}
 	if builtins {
 		if fn, ok := v.config.Functions[name]; ok {
-			return Nature{Type: fn.Type(), Func: fn}
+			nt := v.config.NtCache.FromType(fn.Type())
+			if nt.TypeData == nil {
+				nt.TypeData = new(TypeData)
+			}
+			nt.TypeData.Func = fn
+			return nt
 		}
 		if fn, ok := v.config.Builtins[name]; ok {
-			return Nature{Type: fn.Type(), Func: fn}
+			nt := v.config.NtCache.FromType(fn.Type())
+			if nt.TypeData == nil {
+				nt.TypeData = new(TypeData)
+			}
+			nt.TypeData.Func = fn
+			return nt
 		}
 	}
 	if v.config.Strict && strict {
-		return v.error(node, "unknown name %v", name)
+		return v.error(node, "unknown name %s", name)
 	}
-	return unknown
+	return Nature{}
 }
 
-func (v *checker) IntegerNode(*ast.IntegerNode) Nature {
-	return integerNature
-}
-
-func (v *checker) FloatNode(*ast.FloatNode) Nature {
-	return floatNature
-}
-
-func (v *checker) BoolNode(*ast.BoolNode) Nature {
-	return boolNature
-}
-
-func (v *checker) StringNode(*ast.StringNode) Nature {
-	return stringNature
-}
-
-func (v *checker) ConstantNode(node *ast.ConstantNode) Nature {
-	return Nature{Type: reflect.TypeOf(node.Value)}
-}
-
-func (v *checker) UnaryNode(node *ast.UnaryNode) Nature {
+func (v *Checker) unaryNode(node *ast.UnaryNode) Nature {
 	nt := v.visit(node.Node)
-	nt = nt.Deref()
+	nt = nt.Deref(&v.config.NtCache)
 
 	switch node.Operator {
 
 	case "!", "not":
-		if isBool(nt) {
-			return boolNature
+		if nt.IsBool() {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if isUnknown(nt) {
-			return boolNature
+		if nt.IsUnknown(&v.config.NtCache) {
+			return v.config.NtCache.FromType(boolType)
 		}
 
 	case "+", "-":
-		if isNumber(nt) {
+		if nt.IsNumber() {
 			return nt
 		}
-		if isUnknown(nt) {
-			return unknown
+		if nt.IsUnknown(&v.config.NtCache) {
+			return Nature{}
 		}
 
 	default:
-		return v.error(node, "unknown operator (%v)", node.Operator)
+		return v.error(node, "unknown operator (%s)", node.Operator)
 	}
 
-	return v.error(node, `invalid operation: %v (mismatched type %s)`, node.Operator, nt)
+	return v.error(node, `invalid operation: %s (mismatched type %s)`, node.Operator, nt.String())
 }
 
-func (v *checker) BinaryNode(node *ast.BinaryNode) Nature {
+func (v *Checker) binaryNode(node *ast.BinaryNode) Nature {
 	l := v.visit(node.Left)
 	r := v.visit(node.Right)
 
-	l = l.Deref()
-	r = r.Deref()
+	l = l.Deref(&v.config.NtCache)
+	r = r.Deref(&v.config.NtCache)
 
 	switch node.Operator {
 	case "==", "!=":
-		if isComparable(l, r) {
-			return boolNature
+		if l.ComparableTo(&v.config.NtCache, r) {
+			return v.config.NtCache.FromType(boolType)
 		}
 
 	case "or", "||", "and", "&&":
-		if isBool(l) && isBool(r) {
-			return boolNature
+		if l.IsBool() && r.IsBool() {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if or(l, r, isBool) {
-			return boolNature
+		if l.MaybeCompatible(&v.config.NtCache, r, BoolCheck) {
+			return v.config.NtCache.FromType(boolType)
 		}
 
 	case "<", ">", ">=", "<=":
-		if isNumber(l) && isNumber(r) {
-			return boolNature
+		if l.IsNumber() && r.IsNumber() {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if isString(l) && isString(r) {
-			return boolNature
+		if l.IsString() && r.IsString() {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if isTime(l) && isTime(r) {
-			return boolNature
+		if l.IsTime() && r.IsTime() {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if isDuration(l) && isDuration(r) {
-			return boolNature
+		if l.IsDuration() && r.IsDuration() {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if or(l, r, isNumber, isString, isTime, isDuration) {
-			return boolNature
+		if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, StringCheck, TimeCheck, DurationCheck) {
+			return v.config.NtCache.FromType(boolType)
 		}
 
 	case "-":
-		if isNumber(l) && isNumber(r) {
-			return combined(l, r)
+		if l.IsNumber() && r.IsNumber() {
+			return l.PromoteNumericNature(&v.config.NtCache, r)
 		}
-		if isTime(l) && isTime(r) {
-			return durationNature
+		if l.IsTime() && r.IsTime() {
+			return v.config.NtCache.FromType(durationType)
 		}
-		if isTime(l) && isDuration(r) {
-			return timeNature
+		if l.IsTime() && r.IsDuration() {
+			return v.config.NtCache.FromType(timeType)
 		}
-		if isDuration(l) && isDuration(r) {
-			return durationNature
+		if l.IsDuration() && r.IsDuration() {
+			return v.config.NtCache.FromType(durationType)
 		}
-		if or(l, r, isNumber, isTime, isDuration) {
-			return unknown
+		if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, TimeCheck, DurationCheck) {
+			return Nature{}
 		}
 
 	case "*":
-		if isNumber(l) && isNumber(r) {
-			return combined(l, r)
+		if l.IsNumber() && r.IsNumber() {
+			return l.PromoteNumericNature(&v.config.NtCache, r)
 		}
-		if isNumber(l) && isDuration(r) {
-			return durationNature
+		if l.IsNumber() && r.IsDuration() {
+			return v.config.NtCache.FromType(durationType)
 		}
-		if isDuration(l) && isNumber(r) {
-			return durationNature
+		if l.IsDuration() && r.IsNumber() {
+			return v.config.NtCache.FromType(durationType)
 		}
-		if isDuration(l) && isDuration(r) {
-			return durationNature
+		if l.IsDuration() && r.IsDuration() {
+			return v.config.NtCache.FromType(durationType)
 		}
-		if or(l, r, isNumber, isDuration) {
-			return unknown
+		if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, DurationCheck) {
+			return Nature{}
 		}
 
 	case "/":
-		if isNumber(l) && isNumber(r) {
-			return floatNature
+		if l.IsNumber() && r.IsNumber() {
+			return v.config.NtCache.FromType(floatType)
 		}
-		if or(l, r, isNumber) {
-			return floatNature
+		if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck) {
+			return v.config.NtCache.FromType(floatType)
 		}
 
 	case "**", "^":
-		if isNumber(l) && isNumber(r) {
-			return floatNature
+		if l.IsNumber() && r.IsNumber() {
+			return v.config.NtCache.FromType(floatType)
 		}
-		if or(l, r, isNumber) {
-			return floatNature
+		if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck) {
+			return v.config.NtCache.FromType(floatType)
 		}
 
 	case "%":
-		if isInteger(l) && isInteger(r) {
-			return integerNature
+		if l.IsInteger && r.IsInteger {
+			return v.config.NtCache.FromType(intType)
 		}
-		if or(l, r, isInteger) {
-			return integerNature
+		if l.MaybeCompatible(&v.config.NtCache, r, IntegerCheck) {
+			return v.config.NtCache.FromType(intType)
 		}
 
 	case "+":
-		if isNumber(l) && isNumber(r) {
-			return combined(l, r)
+		if l.IsNumber() && r.IsNumber() {
+			return l.PromoteNumericNature(&v.config.NtCache, r)
 		}
-		if isString(l) && isString(r) {
-			return stringNature
+		if l.IsString() && r.IsString() {
+			return v.config.NtCache.FromType(stringType)
 		}
-		if isTime(l) && isDuration(r) {
-			return timeNature
+		if l.IsTime() && r.IsDuration() {
+			return v.config.NtCache.FromType(timeType)
 		}
-		if isDuration(l) && isTime(r) {
-			return timeNature
+		if l.IsDuration() && r.IsTime() {
+			return v.config.NtCache.FromType(timeType)
 		}
-		if isDuration(l) && isDuration(r) {
-			return durationNature
+		if l.IsDuration() && r.IsDuration() {
+			return v.config.NtCache.FromType(durationType)
 		}
-		if or(l, r, isNumber, isString, isTime, isDuration) {
-			return unknown
+		if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, StringCheck, TimeCheck, DurationCheck) {
+			return Nature{}
 		}
 
 	case "in":
-		if (isString(l) || isUnknown(l)) && isStruct(r) {
-			return boolNature
+		if (l.IsString() || l.IsUnknown(&v.config.NtCache)) && r.IsStruct() {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if isMap(r) {
-			if !isUnknown(l) && !l.AssignableTo(r.Key()) {
-				return v.error(node, "cannot use %v as type %v in map key", l, r.Key())
+		if r.IsMap() {
+			rKey := r.Key(&v.config.NtCache)
+			if !l.IsUnknown(&v.config.NtCache) && !l.AssignableTo(rKey) {
+				return v.error(node, "cannot use %s as type %s in map key", l.String(), rKey.String())
 			}
-			return boolNature
+			return v.config.NtCache.FromType(boolType)
 		}
-		if isArray(r) {
-			if !isComparable(l, r.Elem()) {
-				return v.error(node, "cannot use %v as type %v in array", l, r.Elem())
+		if r.IsArray() {
+			rElem := r.Elem(&v.config.NtCache)
+			if !l.ComparableTo(&v.config.NtCache, rElem) {
+				return v.error(node, "cannot use %s as type %s in array", l.String(), rElem.String())
 			}
-			return boolNature
+			return v.config.NtCache.FromType(boolType)
 		}
-		if isUnknown(l) && anyOf(r, isString, isArray, isMap) {
-			return boolNature
+		if l.IsUnknown(&v.config.NtCache) && r.IsAnyOf(StringCheck, ArrayCheck, MapCheck) {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if isUnknown(r) {
-			return boolNature
+		if r.IsUnknown(&v.config.NtCache) {
+			return v.config.NtCache.FromType(boolType)
 		}
 
 	case "matches":
@@ -434,57 +462,54 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature {
 				return v.error(node, err.Error())
 			}
 		}
-		if isString(l) && isString(r) {
-			return boolNature
+		if l.IsString() && r.IsString() {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if or(l, r, isString) {
-			return boolNature
+		if l.MaybeCompatible(&v.config.NtCache, r, StringCheck) {
+			return v.config.NtCache.FromType(boolType)
 		}
 
 	case "contains", "startsWith", "endsWith":
-		if isString(l) && isString(r) {
-			return boolNature
+		if l.IsString() && r.IsString() {
+			return v.config.NtCache.FromType(boolType)
 		}
-		if or(l, r, isString) {
-			return boolNature
+		if l.MaybeCompatible(&v.config.NtCache, r, StringCheck) {
+			return v.config.NtCache.FromType(boolType)
 		}
 
 	case "..":
-		if isInteger(l) && isInteger(r) {
-			return arrayOf(integerNature)
-		}
-		if or(l, r, isInteger) {
-			return arrayOf(integerNature)
+		if l.IsInteger && r.IsInteger || l.MaybeCompatible(&v.config.NtCache, r, IntegerCheck) {
+			return ArrayFromType(&v.config.NtCache, intType)
 		}
 
 	case "??":
-		if isNil(l) && !isNil(r) {
+		if l.Nil && !r.Nil {
 			return r
 		}
-		if !isNil(l) && isNil(r) {
+		if !l.Nil && r.Nil {
 			return l
 		}
-		if isNil(l) && isNil(r) {
-			return nilNature
+		if l.Nil && r.Nil {
+			return v.config.NtCache.NatureOf(nil)
 		}
 		if r.AssignableTo(l) {
 			return l
 		}
-		return unknown
+		return Nature{}
 
 	default:
-		return v.error(node, "unknown operator (%v)", node.Operator)
+		return v.error(node, "unknown operator (%s)", node.Operator)
 
 	}
 
-	return v.error(node, `invalid operation: %v (mismatched types %v and %v)`, node.Operator, l, r)
+	return v.error(node, `invalid operation: %s (mismatched types %s and %s)`, node.Operator, l.String(), r.String())
 }
 
-func (v *checker) ChainNode(node *ast.ChainNode) Nature {
+func (v *Checker) chainNode(node *ast.ChainNode) Nature {
 	return v.visit(node.Node)
 }
 
-func (v *checker) MemberNode(node *ast.MemberNode) Nature {
+func (v *Checker) memberNode(node *ast.MemberNode) Nature {
 	// $env variable
 	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "$env" {
 		if name, ok := node.Property.(*ast.StringNode); ok {
@@ -498,60 +523,60 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature {
 			}
 			return v.ident(node, name.Value, strict, false /* no builtins and no functions */)
 		}
-		return unknown
+		return Nature{}
 	}
 
 	base := v.visit(node.Node)
 	prop := v.visit(node.Property)
 
-	if isUnknown(base) {
-		return unknown
+	if base.IsUnknown(&v.config.NtCache) {
+		return Nature{}
 	}
 
 	if name, ok := node.Property.(*ast.StringNode); ok {
-		if isNil(base) {
-			return v.error(node, "type nil has no field %v", name.Value)
+		if base.Nil {
+			return v.error(node, "type nil has no field %s", name.Value)
 		}
 
 		// First, check methods defined on base type itself,
 		// independent of which type it is. Without dereferencing.
-		if m, ok := base.MethodByName(name.Value); ok {
+		if m, ok := base.MethodByName(&v.config.NtCache, name.Value); ok {
 			return m
 		}
 	}
 
-	base = base.Deref()
+	base = base.Deref(&v.config.NtCache)
 
-	switch base.Kind() {
+	switch base.Kind {
 	case reflect.Map:
-		if !prop.AssignableTo(base.Key()) && !isUnknown(prop) {
-			return v.error(node.Property, "cannot use %v to get an element from %v", prop, base)
+		if !prop.AssignableTo(base.Key(&v.config.NtCache)) && !prop.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Property, "cannot use %s to get an element from %s", prop.String(), base.String())
 		}
-		if prop, ok := node.Property.(*ast.StringNode); ok {
+		if prop, ok := node.Property.(*ast.StringNode); ok && base.TypeData != nil {
 			if field, ok := base.Fields[prop.Value]; ok {
 				return field
 			} else if base.Strict {
-				return v.error(node.Property, "unknown field %v", prop.Value)
+				return v.error(node.Property, "unknown field %s", prop.Value)
 			}
 		}
-		return base.Elem()
+		return base.Elem(&v.config.NtCache)
 
 	case reflect.Array, reflect.Slice:
-		if !isInteger(prop) && !isUnknown(prop) {
-			return v.error(node.Property, "array elements can only be selected using an integer (got %v)", prop)
+		if !prop.IsInteger && !prop.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Property, "array elements can only be selected using an integer (got %s)", prop.String())
 		}
-		return base.Elem()
+		return base.Elem(&v.config.NtCache)
 
 	case reflect.Struct:
 		if name, ok := node.Property.(*ast.StringNode); ok {
 			propertyName := name.Value
-			if field, ok := base.FieldByName(propertyName); ok {
-				return Nature{Type: field.Type}
+			if field, ok := base.FieldByName(&v.config.NtCache, propertyName); ok {
+				return v.config.NtCache.FromType(field.Type)
 			}
 			if node.Method {
-				return v.error(node, "type %v has no method %v", base, propertyName)
+				return v.error(node, "type %v has no method %v", base.String(), propertyName)
 			}
-			return v.error(node, "type %v has no field %v", base, propertyName)
+			return v.error(node, "type %v has no field %v", base.String(), propertyName)
 		}
 	}
 
@@ -559,47 +584,45 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature {
 
 	if name, ok := node.Property.(*ast.StringNode); ok {
 		if node.Method {
-			return v.error(node, "type %v has no method %v", base, name.Value)
+			return v.error(node, "type %v has no method %v", base.String(), name.Value)
 		}
-		return v.error(node, "type %v has no field %v", base, name.Value)
+		return v.error(node, "type %v has no field %v", base.String(), name.Value)
 	}
-	return v.error(node, "type %v[%v] is undefined", base, prop)
+	return v.error(node, "type %v[%v] is undefined", base.String(), prop.String())
 }
 
-func (v *checker) SliceNode(node *ast.SliceNode) Nature {
+func (v *Checker) sliceNode(node *ast.SliceNode) Nature {
 	nt := v.visit(node.Node)
 
-	if isUnknown(nt) {
-		return unknown
+	if nt.IsUnknown(&v.config.NtCache) {
+		return Nature{}
 	}
 
-	switch nt.Kind() {
+	switch nt.Kind {
 	case reflect.String, reflect.Array, reflect.Slice:
 		// ok
 	default:
-		return v.error(node, "cannot slice %s", nt)
+		return v.error(node, "cannot slice %s", nt.String())
 	}
 
 	if node.From != nil {
 		from := v.visit(node.From)
-		if !isInteger(from) && !isUnknown(from) {
-			return v.error(node.From, "non-integer slice index %v", from)
+		if !from.IsInteger && !from.IsUnknown(&v.config.NtCache) {
+			return v.error(node.From, "non-integer slice index %v", from.String())
 		}
 	}
 
 	if node.To != nil {
 		to := v.visit(node.To)
-		if !isInteger(to) && !isUnknown(to) {
-			return v.error(node.To, "non-integer slice index %v", to)
+		if !to.IsInteger && !to.IsUnknown(&v.config.NtCache) {
+			return v.error(node.To, "non-integer slice index %v", to.String())
 		}
 	}
 
 	return nt
 }
 
-func (v *checker) CallNode(node *ast.CallNode) Nature {
-	nt := v.functionReturnType(node)
-
+func (v *Checker) callNode(node *ast.CallNode) Nature {
 	// Check if type was set on node (for example, by patcher)
 	// and use node type instead of function return type.
 	//
@@ -611,18 +634,18 @@ func (v *checker) CallNode(node *ast.CallNode) Nature {
 	// fix `errCall()` to return proper type, so on second
 	// checker pass we should replace anyType on method node
 	// with new correct function return type.
-	if node.Type() != nil && node.Type() != anyType {
-		return node.Nature()
+	if typ := node.Type(); typ != nil && typ != anyType {
+		nt := node.Nature()
+		return nt
 	}
 
-	return nt
-}
-
-func (v *checker) functionReturnType(node *ast.CallNode) Nature {
 	nt := v.visit(node.Callee)
+	if nt.IsUnknown(&v.config.NtCache) {
+		return Nature{}
+	}
 
-	if nt.Func != nil {
-		return v.checkFunction(nt.Func, node, node.Arguments)
+	if nt.TypeData != nil && nt.TypeData.Func != nil {
+		return v.checkFunction(nt.TypeData.Func, node, node.Arguments)
 	}
 
 	fnName := "function"
@@ -635,122 +658,126 @@ func (v *checker) functionReturnType(node *ast.CallNode) Nature {
 		}
 	}
 
-	if isUnknown(nt) {
-		return unknown
-	}
-
-	if isNil(nt) {
+	if nt.Nil {
 		return v.error(node, "%v is nil; cannot call nil as function", fnName)
 	}
 
-	switch nt.Kind() {
-	case reflect.Func:
+	if nt.Kind == reflect.Func {
 		outType, err := v.checkArguments(fnName, nt, node.Arguments, node)
 		if err != nil {
 			if v.err == nil {
 				v.err = err
 			}
-			return unknown
+			return Nature{}
 		}
 		return outType
 	}
-	return v.error(node, "%s is not callable", nt)
+	return v.error(node, "%s is not callable", nt.String())
 }
 
-func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
+func (v *Checker) builtinNode(node *ast.BuiltinNode) Nature {
 	switch node.Name {
 	case "all", "none", "any", "one":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
 		v.begin(collection)
 		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(predicate) &&
+		if predicate.IsFunc() &&
 			predicate.NumOut() == 1 &&
-			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
+			predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) {
 
-			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
+			predicateOut := predicate.Out(&v.config.NtCache, 0)
+			if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String())
 			}
-			return boolNature
+			return v.config.NtCache.FromType(boolType)
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "filter":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
 		v.begin(collection)
 		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(predicate) &&
+		if predicate.IsFunc() &&
 			predicate.NumOut() == 1 &&
-			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
+			predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) {
 
-			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
+			predicateOut := predicate.Out(&v.config.NtCache, 0)
+			if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String())
 			}
-			if isUnknown(collection) {
-				return arrayNature
+			if collection.IsUnknown(&v.config.NtCache) {
+				return v.config.NtCache.FromType(arrayType)
 			}
-			return arrayOf(collection.Elem())
+			collection = collection.Elem(&v.config.NtCache)
+			return collection.MakeArrayOf(&v.config.NtCache)
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "map":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
-		v.begin(collection, scopeVar{"index", integerNature})
+		v.begin(collection, varScope{"index", v.config.NtCache.FromType(intType)})
 		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(predicate) &&
+		if predicate.IsFunc() &&
 			predicate.NumOut() == 1 &&
-			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
+			predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) {
 
-			return arrayOf(*predicate.PredicateOut)
+			return predicate.Ref.MakeArrayOf(&v.config.NtCache)
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "count":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
 		if len(node.Arguments) == 1 {
-			return integerNature
+			return v.config.NtCache.FromType(intType)
 		}
 
 		v.begin(collection)
 		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(predicate) &&
+		if predicate.IsFunc() &&
 			predicate.NumOut() == 1 &&
-			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
-			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
+			predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) {
+			predicateOut := predicate.Out(&v.config.NtCache, 0)
+			if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String())
 			}
 
-			return integerNature
+			return v.config.NtCache.FromType(intType)
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "sum":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
 		if len(node.Arguments) == 2 {
@@ -758,86 +785,95 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 			predicate := v.visit(node.Arguments[1])
 			v.end()
 
-			if isFunc(predicate) &&
+			if predicate.IsFunc() &&
 				predicate.NumOut() == 1 &&
-				predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
-				return predicate.Out(0)
+				predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) {
+				return predicate.Out(&v.config.NtCache, 0)
 			}
 		} else {
-			if isUnknown(collection) {
-				return unknown
+			if collection.IsUnknown(&v.config.NtCache) {
+				return Nature{}
 			}
-			return collection.Elem()
+			return collection.Elem(&v.config.NtCache)
 		}
 
 	case "find", "findLast":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
 		v.begin(collection)
 		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(predicate) &&
+		if predicate.IsFunc() &&
 			predicate.NumOut() == 1 &&
-			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
+			predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) {
 
-			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
+			predicateOut := predicate.Out(&v.config.NtCache, 0)
+			if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String())
 			}
-			if isUnknown(collection) {
-				return unknown
+			if collection.IsUnknown(&v.config.NtCache) {
+				return Nature{}
 			}
-			return collection.Elem()
+			return collection.Elem(&v.config.NtCache)
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "findIndex", "findLastIndex":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
 		v.begin(collection)
 		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(predicate) &&
+		if predicate.IsFunc() &&
 			predicate.NumOut() == 1 &&
-			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
+			predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) {
 
-			if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) {
-				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String())
+			predicateOut := predicate.Out(&v.config.NtCache, 0)
+			if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) {
+				return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String())
 			}
-			return integerNature
+			return v.config.NtCache.FromType(intType)
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "groupBy":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
 		v.begin(collection)
 		predicate := v.visit(node.Arguments[1])
 		v.end()
 
-		if isFunc(predicate) &&
+		if predicate.IsFunc() &&
 			predicate.NumOut() == 1 &&
-			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
+			predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) {
 
-			groups := arrayOf(collection.Elem())
-			return Nature{Type: reflect.TypeOf(map[any][]any{}), ArrayOf: &groups}
+			collection = collection.Elem(&v.config.NtCache)
+			collection = collection.MakeArrayOf(&v.config.NtCache)
+			nt := v.config.NtCache.NatureOf(map[any][]any{})
+			nt.Ref = &collection
+			return nt
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "sortBy":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
 		v.begin(collection)
@@ -848,21 +884,22 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 			_ = v.visit(node.Arguments[2])
 		}
 
-		if isFunc(predicate) &&
+		if predicate.IsFunc() &&
 			predicate.NumOut() == 1 &&
-			predicate.NumIn() == 1 && isUnknown(predicate.In(0)) {
+			predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) {
 
 			return collection
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
 	case "reduce":
-		collection := v.visit(node.Arguments[0]).Deref()
-		if !isArray(collection) && !isUnknown(collection) {
-			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection)
+		collection := v.visit(node.Arguments[0])
+		collection = collection.Deref(&v.config.NtCache)
+		if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String())
 		}
 
-		v.begin(collection, scopeVar{"index", integerNature}, scopeVar{"acc", unknown})
+		v.begin(collection, varScope{"index", v.config.NtCache.FromType(intType)}, varScope{"acc", Nature{}})
 		predicate := v.visit(node.Arguments[1])
 		v.end()
 
@@ -870,8 +907,8 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 			_ = v.visit(node.Arguments[2])
 		}
 
-		if isFunc(predicate) && predicate.NumOut() == 1 {
-			return *predicate.PredicateOut
+		if predicate.IsFunc() && predicate.NumOut() == 1 {
+			return *predicate.Ref
 		}
 		return v.error(node.Arguments[1], "predicate should has two input and one output param")
 
@@ -888,24 +925,18 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature {
 	return v.error(node, "unknown builtin %v", node.Name)
 }
 
-type scopeVar struct {
-	varName   string
-	varNature Nature
-}
-
-func (v *checker) begin(collectionNature Nature, vars ...scopeVar) {
-	scope := predicateScope{collection: collectionNature, vars: make(map[string]Nature)}
-	for _, v := range vars {
-		scope.vars[v.varName] = v.varNature
-	}
-	v.predicateScopes = append(v.predicateScopes, scope)
+func (v *Checker) begin(collectionNature Nature, vars ...varScope) {
+	v.predicateScopes = append(v.predicateScopes, predicateScope{
+		collection: collectionNature,
+		vars:       vars,
+	})
 }
 
-func (v *checker) end() {
+func (v *Checker) end() {
 	v.predicateScopes = v.predicateScopes[:len(v.predicateScopes)-1]
 }
 
-func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) Nature {
+func (v *Checker) checkBuiltinGet(node *ast.BuiltinNode) Nature {
 	if len(node.Arguments) != 2 {
 		return v.error(node, "invalid number of arguments (expected 2, got %d)", len(node.Arguments))
 	}
@@ -915,38 +946,38 @@ func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) Nature {
 
 	if id, ok := node.Arguments[0].(*ast.IdentifierNode); ok && id.Value == "$env" {
 		if s, ok := node.Arguments[1].(*ast.StringNode); ok {
-			if nt, ok := v.config.Env.Get(s.Value); ok {
+			if nt, ok := v.config.Env.Get(&v.config.NtCache, s.Value); ok {
 				return nt
 			}
 		}
-		return unknown
+		return Nature{}
 	}
 
-	if isUnknown(base) {
-		return unknown
+	if base.IsUnknown(&v.config.NtCache) {
+		return Nature{}
 	}
 
-	switch base.Kind() {
+	switch base.Kind {
 	case reflect.Slice, reflect.Array:
-		if !isInteger(prop) && !isUnknown(prop) {
-			return v.error(node.Arguments[1], "non-integer slice index %s", prop)
+		if !prop.IsInteger && !prop.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[1], "non-integer slice index %s", prop.String())
 		}
-		return base.Elem()
+		return base.Elem(&v.config.NtCache)
 	case reflect.Map:
-		if !prop.AssignableTo(base.Key()) && !isUnknown(prop) {
-			return v.error(node.Arguments[1], "cannot use %s to get an element from %s", prop, base)
+		if !prop.AssignableTo(base.Key(&v.config.NtCache)) && !prop.IsUnknown(&v.config.NtCache) {
+			return v.error(node.Arguments[1], "cannot use %s to get an element from %s", prop.String(), base.String())
 		}
-		return base.Elem()
+		return base.Elem(&v.config.NtCache)
 	}
-	return v.error(node.Arguments[0], "type %v does not support indexing", base)
+	return v.error(node.Arguments[0], "type %v does not support indexing", base.String())
 }
 
-func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) Nature {
+func (v *Checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) Nature {
 	if f.Validate != nil {
 		args := make([]reflect.Type, len(arguments))
 		for i, arg := range arguments {
 			argNature := v.visit(arg)
-			if isUnknown(argNature) {
+			if argNature.IsUnknown(&v.config.NtCache) {
 				args[i] = anyType
 			} else {
 				args[i] = argNature.Type
@@ -956,21 +987,21 @@ func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []
 		if err != nil {
 			return v.error(node, "%v", err)
 		}
-		return Nature{Type: t}
+		return v.config.NtCache.FromType(t)
 	} else if len(f.Types) == 0 {
-		nt, err := v.checkArguments(f.Name, Nature{Type: f.Type()}, arguments, node)
+		nt, err := v.checkArguments(f.Name, v.config.NtCache.FromType(f.Type()), arguments, node)
 		if err != nil {
 			if v.err == nil {
 				v.err = err
 			}
-			return unknown
+			return Nature{}
 		}
 		// No type was specified, so we assume the function returns any.
 		return nt
 	}
 	var lastErr *file.Error
 	for _, t := range f.Types {
-		outNature, err := v.checkArguments(f.Name, Nature{Type: t}, arguments, node)
+		outNature, err := v.checkArguments(f.Name, v.config.NtCache.FromType(t), arguments, node)
 		if err != nil {
 			lastErr = err
 			continue
@@ -989,30 +1020,31 @@ func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []
 		if v.err == nil {
 			v.err = lastErr
 		}
-		return unknown
+		return Nature{}
 	}
 
 	return v.error(node, "no matching overload for %v", f.Name)
 }
 
-func (v *checker) checkArguments(
+func (v *Checker) checkArguments(
 	name string,
 	fn Nature,
 	arguments []ast.Node,
 	node ast.Node,
 ) (Nature, *file.Error) {
-	if isUnknown(fn) {
-		return unknown, nil
+	if fn.IsUnknown(&v.config.NtCache) {
+		return Nature{}, nil
 	}
 
-	if fn.NumOut() == 0 {
-		return unknown, &file.Error{
+	numOut := fn.NumOut()
+	if numOut == 0 {
+		return Nature{}, &file.Error{
 			Location: node.Location(),
 			Message:  fmt.Sprintf("func %v doesn't return value", name),
 		}
 	}
-	if numOut := fn.NumOut(); numOut > 2 {
-		return unknown, &file.Error{
+	if numOut > 2 {
+		return Nature{}, &file.Error{
 			Location: node.Location(),
 			Message:  fmt.Sprintf("func %v returns more then two values", name),
 		}
@@ -1031,7 +1063,8 @@ func (v *checker) checkArguments(
 	}
 
 	var err *file.Error
-	if fn.IsVariadic() {
+	isVariadic := fn.IsVariadic()
+	if isVariadic {
 		if len(arguments) < fnNumIn-1 {
 			err = &file.Error{
 				Location: node.Location(),
@@ -1059,38 +1092,38 @@ func (v *checker) checkArguments(
 		for _, arg := range arguments {
 			_ = v.visit(arg)
 		}
-		return fn.Out(0), err
+		return fn.Out(&v.config.NtCache, 0), err
 	}
 
 	for i, arg := range arguments {
 		argNature := v.visit(arg)
 
 		var in Nature
-		if fn.IsVariadic() && i >= fnNumIn-1 {
+		if isVariadic && i >= fnNumIn-1 {
 			// For variadic arguments fn(xs ...int), go replaces type of xs (int) with ([]int).
 			// As we compare arguments one by one, we need underling type.
-			in = fn.In(fn.NumIn() - 1).Elem()
+			in = fn.InElem(&v.config.NtCache, fnNumIn-1)
 		} else {
-			in = fn.In(i + fnInOffset)
+			in = fn.In(&v.config.NtCache, i+fnInOffset)
 		}
 
-		if isFloat(in) && isInteger(argNature) {
+		if in.IsFloat && argNature.IsInteger {
 			traverseAndReplaceIntegerNodesWithFloatNodes(&arguments[i], in)
 			continue
 		}
 
-		if isInteger(in) && isInteger(argNature) && argNature.Kind() != in.Kind() {
+		if in.IsInteger && argNature.IsInteger && argNature.Kind != in.Kind {
 			traverseAndReplaceIntegerNodesWithIntegerNodes(&arguments[i], in)
 			continue
 		}
 
-		if isNil(argNature) {
-			if in.Kind() == reflect.Ptr || in.Kind() == reflect.Interface {
+		if argNature.Nil {
+			if in.Kind == reflect.Ptr || in.Kind == reflect.Interface {
 				continue
 			}
-			return unknown, &file.Error{
+			return Nature{}, &file.Error{
 				Location: arg.Location(),
-				Message:  fmt.Sprintf("cannot use nil as argument (type %s) to call %v", in, name),
+				Message:  fmt.Sprintf("cannot use nil as argument (type %s) to call %v", in.String(), name),
 			}
 		}
 
@@ -1102,17 +1135,20 @@ func (v *checker) checkArguments(
 		// We also need to check if dereference arg type is assignable to the function input type.
 		// For example, func(int) and argument *int. In this case we will add OpDeref to the argument,
 		// so we can call the function with *int argument.
-		assignable = assignable || argNature.Deref().AssignableTo(in)
+		if !assignable && argNature.IsPointer() {
+			nt := argNature.Deref(&v.config.NtCache)
+			assignable = nt.AssignableTo(in)
+		}
 
-		if !assignable && !isUnknown(argNature) {
-			return unknown, &file.Error{
+		if !assignable && !argNature.IsUnknown(&v.config.NtCache) {
+			return Nature{}, &file.Error{
 				Location: arg.Location(),
-				Message:  fmt.Sprintf("cannot use %s as argument (type %s) to call %v ", argNature, in, name),
+				Message:  fmt.Sprintf("cannot use %s as argument (type %s) to call %v ", argNature.String(), in.String(), name),
 			}
 		}
 	}
 
-	return fn.Out(0), nil
+	return fn.Out(&v.config.NtCache, 0), nil
 }
 
 func traverseAndReplaceIntegerNodesWithFloatNodes(node *ast.Node, newNature Nature) {
@@ -1152,45 +1188,46 @@ func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newNature Na
 	}
 }
 
-func (v *checker) PredicateNode(node *ast.PredicateNode) Nature {
+func (v *Checker) predicateNode(node *ast.PredicateNode) Nature {
 	nt := v.visit(node.Node)
 	var out []reflect.Type
-	if isUnknown(nt) {
+	if nt.IsUnknown(&v.config.NtCache) {
 		out = append(out, anyType)
-	} else if !isNil(nt) {
+	} else if !nt.Nil {
 		out = append(out, nt.Type)
 	}
-	return Nature{
-		Type:         reflect.FuncOf([]reflect.Type{anyType}, out, false),
-		PredicateOut: &nt,
-	}
+	n := v.config.NtCache.FromType(reflect.FuncOf(anyTypeSlice, out, false))
+	n.Ref = &nt
+	return n
 }
 
-func (v *checker) PointerNode(node *ast.PointerNode) Nature {
+func (v *Checker) pointerNode(node *ast.PointerNode) Nature {
 	if len(v.predicateScopes) == 0 {
 		return v.error(node, "cannot use pointer accessor outside predicate")
 	}
 	scope := v.predicateScopes[len(v.predicateScopes)-1]
 	if node.Name == "" {
-		if isUnknown(scope.collection) {
-			return unknown
+		if scope.collection.IsUnknown(&v.config.NtCache) {
+			return Nature{}
 		}
-		switch scope.collection.Kind() {
+		switch scope.collection.Kind {
 		case reflect.Array, reflect.Slice:
-			return scope.collection.Elem()
+			return scope.collection.Elem(&v.config.NtCache)
 		}
 		return v.error(node, "cannot use %v as array", scope)
 	}
 	if scope.vars != nil {
-		if t, ok := scope.vars[node.Name]; ok {
-			return t
+		for i := range scope.vars {
+			if node.Name == scope.vars[i].name {
+				return scope.vars[i].nature
+			}
 		}
 	}
 	return v.error(node, "unknown pointer #%v", node.Name)
 }
 
-func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Nature {
-	if _, ok := v.config.Env.Get(node.Name); ok {
+func (v *Checker) variableDeclaratorNode(node *ast.VariableDeclaratorNode) Nature {
+	if _, ok := v.config.Env.Get(&v.config.NtCache, node.Name); ok {
 		return v.error(node, "cannot redeclare %v", node.Name)
 	}
 	if _, ok := v.config.Functions[node.Name]; ok {
@@ -1199,8 +1236,10 @@ func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Natur
 	if _, ok := v.config.Builtins[node.Name]; ok {
 		return v.error(node, "cannot redeclare builtin %v", node.Name)
 	}
-	if _, ok := v.lookupVariable(node.Name); ok {
-		return v.error(node, "cannot redeclare variable %v", node.Name)
+	for i := len(v.varScopes) - 1; i >= 0; i-- {
+		if v.varScopes[i].name == node.Name {
+			return v.error(node, "cannot redeclare variable %v", node.Name)
+		}
 	}
 	varNature := v.visit(node.Value)
 	v.varScopes = append(v.varScopes, varScope{node.Name, varNature})
@@ -1209,7 +1248,7 @@ func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Natur
 	return exprNature
 }
 
-func (v *checker) SequenceNode(node *ast.SequenceNode) Nature {
+func (v *Checker) sequenceNode(node *ast.SequenceNode) Nature {
 	if len(node.Nodes) == 0 {
 		return v.error(node, "empty sequence expression")
 	}
@@ -1220,66 +1259,57 @@ func (v *checker) SequenceNode(node *ast.SequenceNode) Nature {
 	return last
 }
 
-func (v *checker) lookupVariable(name string) (varScope, bool) {
-	for i := len(v.varScopes) - 1; i >= 0; i-- {
-		if v.varScopes[i].name == name {
-			return v.varScopes[i], true
-		}
-	}
-	return varScope{}, false
-}
-
-func (v *checker) ConditionalNode(node *ast.ConditionalNode) Nature {
+func (v *Checker) conditionalNode(node *ast.ConditionalNode) Nature {
 	c := v.visit(node.Cond)
-	if !isBool(c) && !isUnknown(c) {
-		return v.error(node.Cond, "non-bool expression (type %v) used as condition", c)
+	if !c.IsBool() && !c.IsUnknown(&v.config.NtCache) {
+		return v.error(node.Cond, "non-bool expression (type %v) used as condition", c.String())
 	}
 
 	t1 := v.visit(node.Exp1)
 	t2 := v.visit(node.Exp2)
 
-	if isNil(t1) && !isNil(t2) {
+	if t1.Nil && !t2.Nil {
 		return t2
 	}
-	if !isNil(t1) && isNil(t2) {
+	if !t1.Nil && t2.Nil {
 		return t1
 	}
-	if isNil(t1) && isNil(t2) {
-		return nilNature
+	if t1.Nil && t2.Nil {
+		return v.config.NtCache.NatureOf(nil)
 	}
 	if t1.AssignableTo(t2) {
 		return t1
 	}
-	return unknown
+	return Nature{}
 }
 
-func (v *checker) ArrayNode(node *ast.ArrayNode) Nature {
+func (v *Checker) arrayNode(node *ast.ArrayNode) Nature {
 	var prev Nature
 	allElementsAreSameType := true
 	for i, node := range node.Nodes {
 		curr := v.visit(node)
 		if i > 0 {
-			if curr.Kind() != prev.Kind() {
+			if curr.Kind != prev.Kind {
 				allElementsAreSameType = false
 			}
 		}
 		prev = curr
 	}
 	if allElementsAreSameType {
-		return arrayOf(prev)
+		return prev.MakeArrayOf(&v.config.NtCache)
 	}
-	return arrayNature
+	return v.config.NtCache.FromType(arrayType)
 }
 
-func (v *checker) MapNode(node *ast.MapNode) Nature {
+func (v *Checker) mapNode(node *ast.MapNode) Nature {
 	for _, pair := range node.Pairs {
 		v.visit(pair)
 	}
-	return mapNature
+	return v.config.NtCache.FromType(mapType)
 }
 
-func (v *checker) PairNode(node *ast.PairNode) Nature {
+func (v *Checker) pairNode(node *ast.PairNode) Nature {
 	v.visit(node.Key)
 	v.visit(node.Value)
-	return nilNature
+	return v.config.NtCache.NatureOf(nil)
 }
diff --git a/checker/checker_bench_test.go b/checker/checker_bench_test.go
new file mode 100644
index 000000000..0583d7351
--- /dev/null
+++ b/checker/checker_bench_test.go
@@ -0,0 +1,114 @@
+package checker_test
+
+import (
+	"runtime"
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/checker/nature"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/parser"
+)
+
+func BenchmarkChecker(b *testing.B) {
+	cases := []struct {
+		name, input string
+	}{
+		{"function calls", `
+func(
+	func(
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+	),
+	func(
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+	),
+	func(
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+	)
+)
+		`},
+		{"unary and binary operations", `
+!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 &&
+!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 &&
+!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 &&
+!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 &&
+!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 &&
+!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1
+		`},
+		{"deep struct access", `
+a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.
+a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.
+a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.
+a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a
+		`},
+	}
+
+	f := func(params ...any) (any, error) { return nil, nil }
+	env := map[string]any{
+		"a":    new(recursive),
+		"b":    true,
+		"func": f,
+	}
+	config := conf.New(env)
+	expr.Function("func", f, f)(config)
+	expr.ConstExpr("func")(config)
+
+	for _, c := range cases {
+		batchSize := 100_000
+		if batchSize > b.N {
+			batchSize = b.N
+		}
+		trees := make([]*parser.Tree, 0, batchSize)
+		for i := 0; i < batchSize; i++ {
+			tree, err := parser.ParseWithConfig(c.input, config)
+			if err != nil {
+				b.Fatal(err)
+			}
+			trees = append(trees, tree)
+		}
+		runtime.GC() // try to cleanup the mess from the initialization
+
+		b.Run("name="+c.name, func(b *testing.B) {
+			var err error
+			for i := 0; i < b.N; i++ {
+				j := i
+				if j < 0 || j >= len(trees) {
+					b.StopTimer()
+					invalidateTrees(trees...)
+					j = 0
+					b.StartTimer()
+				}
+
+				_, err = checker.Check(trees[j], config)
+			}
+			b.StopTimer()
+			if err != nil {
+				b.Fatal(err)
+			}
+		})
+	}
+}
+
+type visitorFunc func(*ast.Node)
+
+func (f visitorFunc) Visit(node *ast.Node) { f(node) }
+
+func invalidateTrees(trees ...*parser.Tree) {
+	for _, tree := range trees {
+		ast.Walk(&tree.Node, visitorFunc(func(node *ast.Node) {
+			(*node).SetNature(nature.Nature{})
+		}))
+	}
+}
+
+type recursive struct {
+	Inner *recursive `expr:"a"`
+}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 2ec7c7cfc..bf2b812db 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -136,6 +136,7 @@ func TestCheck(t *testing.T) {
 		{"(Embed).EmbedPointerEmbedInt > 0"},
 	}
 
+	c := new(checker.Checker)
 	for _, tt := range tests {
 		t.Run(tt.input, func(t *testing.T) {
 			var err error
@@ -145,7 +146,7 @@ func TestCheck(t *testing.T) {
 			config := conf.New(mock.Env{})
 			expr.AsBool()(config)
 
-			_, err = checker.Check(tree, config)
+			_, err = c.Check(tree, config)
 			assert.NoError(t, err)
 		})
 	}
@@ -682,12 +683,13 @@ invalid operation: + (mismatched types int and bool) (1:6)
 		},
 	}
 
+	c := new(checker.Checker)
 	for _, tt := range errorTests {
 		t.Run(tt.code, func(t *testing.T) {
 			tree, err := parser.Parse(tt.code)
 			require.NoError(t, err)
 
-			_, err = checker.Check(tree, conf.New(mock.Env{}))
+			_, err = c.Check(tree, conf.New(mock.Env{}))
 			if err == nil {
 				err = fmt.Errorf("<nil>")
 			}
@@ -839,6 +841,7 @@ func TestCheck_TypeWeights(t *testing.T) {
 		"Float32": float32(11),
 		"Float64": float64(12),
 	}
+	c := new(checker.Checker)
 	for a := range types {
 		for b := range types {
 			tree, err := parser.Parse(fmt.Sprintf("%s + %s", a, b))
@@ -846,7 +849,7 @@ func TestCheck_TypeWeights(t *testing.T) {
 
 			config := conf.New(types)
 
-			_, err = checker.Check(tree, config)
+			_, err = c.Check(tree, config)
 			require.NoError(t, err)
 		}
 	}
@@ -926,6 +929,7 @@ func TestCheck_Function_types_are_checked(t *testing.T) {
 
 	config := conf.CreateNew()
 	add(config)
+	c := new(checker.Checker)
 
 	tests := []string{
 		"add(1)",
@@ -938,7 +942,7 @@ func TestCheck_Function_types_are_checked(t *testing.T) {
 			tree, err := parser.Parse(test)
 			require.NoError(t, err)
 
-			_, err = checker.Check(tree, config)
+			_, err = c.Check(tree, config)
 			require.NoError(t, err)
 			require.Equal(t, reflect.Int, tree.Node.Type().Kind())
 		})
@@ -948,7 +952,7 @@ func TestCheck_Function_types_are_checked(t *testing.T) {
 		tree, err := parser.Parse("add(1, '2')")
 		require.NoError(t, err)
 
-		_, err = checker.Check(tree, config)
+		_, err = c.Check(tree, config)
 		require.Error(t, err)
 		require.Equal(t, "cannot use string as argument (type int) to call add  (1:8)\n | add(1, '2')\n | .......^", err.Error())
 	})
@@ -1046,12 +1050,13 @@ func TestCheck_env_keyword(t *testing.T) {
 		{`$env[name]`, reflect.Interface},
 	}
 
+	c := new(checker.Checker)
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
 			tree, err := parser.Parse(test.input)
 			require.NoError(t, err)
 
-			rtype, err := checker.Check(tree, conf.New(env))
+			rtype, err := c.Check(tree, conf.New(env))
 			require.NoError(t, err)
 			require.True(t, rtype.Kind() == test.want, fmt.Sprintf("expected %s, got %s", test.want, rtype.Kind()))
 		})
@@ -1067,12 +1072,13 @@ func TestCheck_builtin_without_call(t *testing.T) {
 		{`string.A`, "type func(interface {}) string has no field A (1:8)\n | string.A\n | .......^"},
 	}
 
+	c := new(checker.Checker)
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
 			tree, err := parser.Parse(test.input)
 			require.NoError(t, err)
 
-			_, err = checker.Check(tree, conf.New(nil))
+			_, err = c.Check(tree, conf.New(nil))
 			require.Error(t, err)
 			require.Equal(t, test.err, err.Error())
 		})
@@ -1134,13 +1140,14 @@ func TestCheck_types(t *testing.T) {
 		{`arr | filter(.value contains "a") | filter(.value == 0)`, `invalid operation: == (mismatched types string and int)`},
 	}
 
+	c := new(checker.Checker)
 	for _, test := range tests {
 		t.Run(test.code, func(t *testing.T) {
 			tree, err := parser.Parse(test.code)
 			require.NoError(t, err)
 
 			config := conf.New(env)
-			_, err = checker.Check(tree, config)
+			_, err = c.Check(tree, config)
 			if test.err == noerr {
 				require.NoError(t, err)
 			} else {
diff --git a/checker/info.go b/checker/info.go
index f1cc92ebe..1b0e05100 100644
--- a/checker/info.go
+++ b/checker/info.go
@@ -8,22 +8,19 @@ import (
 	"github.com/expr-lang/expr/vm"
 )
 
-func FieldIndex(env Nature, node ast.Node) (bool, []int, string) {
+func FieldIndex(c *Cache, env Nature, node ast.Node) (bool, []int, string) {
 	switch n := node.(type) {
 	case *ast.IdentifierNode:
-		if env.Kind() == reflect.Struct {
-			if field, ok := env.Get(n.Value); ok && len(field.FieldIndex) > 0 {
-				return true, field.FieldIndex, n.Value
-			}
+		if idx, ok := env.FieldIndex(c, n.Value); ok {
+			return true, idx, n.Value
 		}
 	case *ast.MemberNode:
 		base := n.Node.Nature()
-		base = base.Deref()
-		if base.Kind() == reflect.Struct {
+		base = base.Deref(c)
+		if base.Kind == reflect.Struct {
 			if prop, ok := n.Property.(*ast.StringNode); ok {
-				name := prop.Value
-				if field, ok := base.FieldByName(name); ok {
-					return true, field.FieldIndex, name
+				if idx, ok := base.FieldIndex(c, prop.Value); ok {
+					return true, idx, prop.Value
 				}
 			}
 		}
@@ -31,11 +28,11 @@ func FieldIndex(env Nature, node ast.Node) (bool, []int, string) {
 	return false, nil, ""
 }
 
-func MethodIndex(env Nature, node ast.Node) (bool, int, string) {
+func MethodIndex(c *Cache, env Nature, node ast.Node) (bool, int, string) {
 	switch n := node.(type) {
 	case *ast.IdentifierNode:
-		if env.Kind() == reflect.Struct {
-			if m, ok := env.Get(n.Value); ok {
+		if env.Kind == reflect.Struct {
+			if m, ok := env.Get(c, n.Value); ok && m.TypeData != nil {
 				return m.Method, m.MethodIndex, n.Value
 			}
 		}
@@ -121,7 +118,7 @@ func IsFastFunc(fn reflect.Type, method bool) bool {
 		fn.NumOut() == 1 &&
 		fn.Out(0).Kind() == reflect.Interface {
 		rest := fn.In(fn.NumIn() - 1) // function has only one param for functions and two for methods
-		if kind(rest) == reflect.Slice && rest.Elem().Kind() == reflect.Interface {
+		if rest != nil && rest.Kind() == reflect.Slice && rest.Elem().Kind() == reflect.Interface {
 			return true
 		}
 	}
diff --git a/checker/nature/nature.go b/checker/nature/nature.go
index 993c9fcf8..483030aa1 100644
--- a/checker/nature/nature.go
+++ b/checker/nature/nature.go
@@ -1,247 +1,450 @@
 package nature
 
 import (
+	"fmt"
 	"reflect"
+	"time"
 
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/internal/deref"
 )
 
 var (
-	unknown = Nature{}
+	intType      = reflect.TypeOf(0)
+	floatType    = reflect.TypeOf(float64(0))
+	arrayType    = reflect.TypeOf([]any{})
+	timeType     = reflect.TypeOf(time.Time{})
+	durationType = reflect.TypeOf(time.Duration(0))
+
+	builtinInt = map[reflect.Type]struct{}{
+		reflect.TypeOf(int(0)):     {},
+		reflect.TypeOf(int8(0)):    {},
+		reflect.TypeOf(int16(0)):   {},
+		reflect.TypeOf(int32(0)):   {},
+		reflect.TypeOf(int64(0)):   {},
+		reflect.TypeOf(uintptr(0)): {},
+		reflect.TypeOf(uint(0)):    {},
+		reflect.TypeOf(uint8(0)):   {},
+		reflect.TypeOf(uint16(0)):  {},
+		reflect.TypeOf(uint32(0)):  {},
+		reflect.TypeOf(uint64(0)):  {},
+	}
+	builtinFloat = map[reflect.Type]struct{}{
+		reflect.TypeOf(float32(0)): {},
+		reflect.TypeOf(float64(0)): {},
+	}
+)
+
+type NatureCheck int
+
+const (
+	_ NatureCheck = iota
+	BoolCheck
+	StringCheck
+	IntegerCheck
+	NumberCheck
+	MapCheck
+	ArrayCheck
+	TimeCheck
+	DurationCheck
 )
 
 type Nature struct {
-	Type            reflect.Type      // Type of the value. If nil, then value is unknown.
-	Func            *builtin.Function // Used to pass function type from callee to CallNode.
-	ArrayOf         *Nature           // Elem nature of array type (usually Type is []any, but ArrayOf can be any nature).
-	PredicateOut    *Nature           // Out nature of predicate.
+	// The order of the fields matter, check alignment before making changes.
+
+	Type reflect.Type // Type of the value. If nil, then value is unknown.
+	Kind reflect.Kind // Kind of the value.
+
+	*TypeData
+
+	// Ref is a reference used for multiple, disjoint purposes. When the Nature
+	// is for a:
+	//	- Predicate: then Ref is the nature of the Out of the predicate.
+	//	- Array-like types: then Ref is the Elem nature of array type (usually Type is []any, but ArrayOf can be any nature).
+	Ref *Nature
+
+	Nil       bool // If value is nil.
+	Strict    bool // If map is types.StrictMap.
+	Method    bool // If value retrieved from method. Usually used to determine amount of in arguments.
+	IsInteger bool // If it's a builtin integer or unsigned integer type.
+	IsFloat   bool // If it's a builtin float type.
+}
+
+type TypeData struct {
+	methodset *methodset // optional to avoid the map in *Cache
+
+	*structData
+
+	// map-only data
 	Fields          map[string]Nature // Fields of map type.
 	DefaultMapValue *Nature           // Default value of map type.
-	Strict          bool              // If map is types.StrictMap.
-	Nil             bool              // If value is nil.
-	Method          bool              // If value retrieved from method. Usually used to determine amount of in arguments.
+
+	// callable-only data
+	Func            *builtin.Function // Used to pass function type from callee to CallNode.
 	MethodIndex     int               // Index of method in type.
-	FieldIndex      []int             // Index of field in type.
+	inElem, outZero *Nature
+	numIn, numOut   int
+
+	isVariadic    bool
+	isVariadicSet bool
+	numInSet      bool
+	numOutSet     bool
 }
 
-func (n Nature) IsAny() bool {
-	return n.Kind() == reflect.Interface && n.NumMethods() == 0
+// Cache is a shared cache of type information. It is only used in the stages
+// where type information becomes relevant, so packages like ast, parser, types,
+// and lexer do not need to use the cache because they don't need any service
+// from the Nature type, they only describe. However, when receiving a Nature
+// from one of those packages, the cache must be set immediately.
+type Cache struct {
+	methods map[reflect.Type]*methodset
+	structs map[reflect.Type]Nature
 }
 
-func (n Nature) IsUnknown() bool {
-	switch {
-	case n.Type == nil && !n.Nil:
-		return true
-	case n.IsAny():
-		return true
+// NatureOf returns a Nature describing "i". If "i" is nil then it returns a
+// Nature describing the value "nil".
+func (c *Cache) NatureOf(i any) Nature {
+	// reflect.TypeOf(nil) returns nil, but in FromType we want to differentiate
+	// what nil means for us
+	if i == nil {
+		return Nature{Nil: true}
 	}
-	return false
+	return c.FromType(reflect.TypeOf(i))
 }
 
-func (n Nature) String() string {
-	if n.Type != nil {
-		return n.Type.String()
+// FromType returns a Nature describing a value of type "t". If "t" is nil then
+// it returns a Nature describing an unknown value.
+func (c *Cache) FromType(t reflect.Type) Nature {
+	if t == nil {
+		return Nature{}
+	}
+	var td *TypeData
+	var isInteger, isFloat bool
+	k := t.Kind()
+	switch k {
+	case reflect.Struct:
+		// c can be nil when we call the package function FromType, which uses a
+		// nil *Cache to call this method.
+		if c != nil {
+			return c.getStruct(t)
+		}
+		fallthrough
+	case reflect.Func:
+		td = new(TypeData)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		_, isInteger = builtinInt[t]
+	case reflect.Float32, reflect.Float64:
+		_, isFloat = builtinFloat[t]
+	}
+	return Nature{
+		Type:      t,
+		Kind:      k,
+		TypeData:  td,
+		IsInteger: isInteger,
+		IsFloat:   isFloat,
 	}
-	return "unknown"
 }
 
-func (n Nature) Deref() Nature {
-	if n.Type != nil {
-		n.Type = deref.Type(n.Type)
+func (c *Cache) getStruct(t reflect.Type) Nature {
+	if c.structs == nil {
+		c.structs = map[reflect.Type]Nature{}
+	} else if nt, ok := c.structs[t]; ok {
+		return nt
+	}
+	nt := Nature{
+		Type: t,
+		Kind: reflect.Struct,
+		TypeData: &TypeData{
+			structData: &structData{
+				rType:    t,
+				numField: t.NumField(),
+				anonIdx:  -1, // do not lookup embedded fields yet
+			},
+		},
 	}
-	return n
+	c.structs[t] = nt
+	return nt
 }
 
-func (n Nature) Kind() reflect.Kind {
+func (c *Cache) getMethodset(t reflect.Type, k reflect.Kind) *methodset {
+	if t == nil || c == nil {
+		return nil
+	}
+	if c.methods == nil {
+		c.methods = map[reflect.Type]*methodset{
+			t: nil,
+		}
+	} else if s, ok := c.methods[t]; ok {
+		return s
+	}
+	numMethod := t.NumMethod()
+	if numMethod < 1 {
+		c.methods[t] = nil // negative cache
+		return nil
+	}
+	s := &methodset{
+		rType:     t,
+		kind:      k,
+		numMethod: numMethod,
+	}
+	c.methods[t] = s
+	return s
+}
+
+// NatureOf calls NatureOf on a nil *Cache. See the comment on Cache.
+func NatureOf(i any) Nature {
+	var c *Cache
+	return c.NatureOf(i)
+}
+
+// FromType calls FromType on a nil *Cache. See the comment on Cache.
+func FromType(t reflect.Type) Nature {
+	var c *Cache
+	return c.FromType(t)
+}
+
+func ArrayFromType(c *Cache, t reflect.Type) Nature {
+	elem := c.FromType(t)
+	nt := c.FromType(arrayType)
+	nt.Ref = &elem
+	return nt
+}
+
+func (n *Nature) IsAny(c *Cache) bool {
+	return n.Type != nil && n.Kind == reflect.Interface && n.NumMethods(c) == 0
+}
+
+func (n *Nature) IsUnknown(c *Cache) bool {
+	return n.Type == nil && !n.Nil || n.IsAny(c)
+}
+
+func (n *Nature) String() string {
 	if n.Type != nil {
-		return n.Type.Kind()
+		return n.Type.String()
+	}
+	return "unknown"
+}
+
+func (n *Nature) Deref(c *Cache) Nature {
+	t, _, changed := deref.TypeKind(n.Type, n.Kind)
+	if !changed {
+		return *n
 	}
-	return reflect.Invalid
+	return c.FromType(t)
 }
 
-func (n Nature) Key() Nature {
-	if n.Kind() == reflect.Map {
-		return Nature{Type: n.Type.Key()}
+func (n *Nature) Key(c *Cache) Nature {
+	if n.Kind == reflect.Map {
+		return c.FromType(n.Type.Key())
 	}
-	return unknown
+	return Nature{}
 }
 
-func (n Nature) Elem() Nature {
-	switch n.Kind() {
+func (n *Nature) Elem(c *Cache) Nature {
+	switch n.Kind {
 	case reflect.Ptr:
-		return Nature{Type: n.Type.Elem()}
+		return c.FromType(n.Type.Elem())
 	case reflect.Map:
-		if n.DefaultMapValue != nil {
+		if n.TypeData != nil && n.DefaultMapValue != nil {
 			return *n.DefaultMapValue
 		}
-		return Nature{Type: n.Type.Elem()}
-	case reflect.Array, reflect.Slice:
-		if n.ArrayOf != nil {
-			return *n.ArrayOf
+		return c.FromType(n.Type.Elem())
+	case reflect.Slice, reflect.Array:
+		if n.Ref != nil {
+			return *n.Ref
 		}
-		return Nature{Type: n.Type.Elem()}
+		return c.FromType(n.Type.Elem())
 	}
-	return unknown
+	return Nature{}
 }
 
-func (n Nature) AssignableTo(nt Nature) bool {
+func (n *Nature) AssignableTo(nt Nature) bool {
 	if n.Nil {
-		// Untyped nil is assignable to any interface, but implements only the empty interface.
-		if nt.IsAny() {
+		switch nt.Kind {
+		case reflect.Pointer, reflect.Interface, reflect.Chan, reflect.Func,
+			reflect.Map, reflect.Slice:
+			// nil can be assigned to these kinds
 			return true
 		}
 	}
-	if n.Type == nil || nt.Type == nil {
+	if n.Type == nil || nt.Type == nil ||
+		n.Kind != nt.Kind && nt.Kind != reflect.Interface {
 		return false
 	}
 	return n.Type.AssignableTo(nt.Type)
 }
 
-func (n Nature) NumMethods() int {
-	if n.Type == nil {
-		return 0
+func (n *Nature) getMethodset(c *Cache) *methodset {
+	if n.TypeData != nil && n.TypeData.methodset != nil {
+		return n.TypeData.methodset
+	}
+	s := c.getMethodset(n.Type, n.Kind)
+	if n.TypeData != nil {
+		n.TypeData.methodset = s // cache locally if possible
 	}
-	return n.Type.NumMethod()
+	return s
 }
 
-func (n Nature) MethodByName(name string) (Nature, bool) {
-	if n.Type == nil {
-		return unknown, false
-	}
-	method, ok := n.Type.MethodByName(name)
-	if !ok {
-		return unknown, false
+func (n *Nature) NumMethods(c *Cache) int {
+	if s := n.getMethodset(c); s != nil {
+		return s.numMethod
 	}
+	return 0
+}
 
-	if n.Type.Kind() == reflect.Interface {
-		// In case of interface type method will not have a receiver,
-		// and to prevent checker decreasing numbers of in arguments
-		// return method type as not method (second argument is false).
-
-		// Also, we can not use m.Index here, because it will be
-		// different indexes for different types which implement
-		// the same interface.
-		return Nature{Type: method.Type}, true
-	} else {
-		return Nature{
-			Type:        method.Type,
-			Method:      true,
-			MethodIndex: method.Index,
-		}, true
+func (n *Nature) MethodByName(c *Cache, name string) (Nature, bool) {
+	if s := n.getMethodset(c); s != nil {
+		if m := s.method(c, name); m != nil {
+			return m.nature, true
+		}
 	}
+	return Nature{}, false
 }
 
-func (n Nature) NumIn() int {
-	if n.Type == nil {
-		return 0
+func (n *Nature) NumIn() int {
+	if n.numInSet {
+		return n.numIn
 	}
-	return n.Type.NumIn()
+	n.numInSet = true
+	n.numIn = n.Type.NumIn()
+	return n.numIn
 }
 
-func (n Nature) In(i int) Nature {
-	if n.Type == nil {
-		return unknown
+func (n *Nature) InElem(c *Cache, i int) Nature {
+	if n.inElem == nil {
+		n2 := c.FromType(n.Type.In(i))
+		n2 = n2.Elem(c)
+		n.inElem = &n2
 	}
-	return Nature{Type: n.Type.In(i)}
+	return *n.inElem
 }
 
-func (n Nature) NumOut() int {
-	if n.Type == nil {
-		return 0
+func (n *Nature) In(c *Cache, i int) Nature {
+	return c.FromType(n.Type.In(i))
+}
+
+func (n *Nature) IsFirstArgUnknown(c *Cache) bool {
+	if n.Type != nil {
+		n2 := c.FromType(n.Type.In(0))
+		return n2.IsUnknown(c)
 	}
-	return n.Type.NumOut()
+	return false
 }
 
-func (n Nature) Out(i int) Nature {
-	if n.Type == nil {
-		return unknown
+func (n *Nature) NumOut() int {
+	if n.numOutSet {
+		return n.numOut
 	}
-	return Nature{Type: n.Type.Out(i)}
+	n.numOutSet = true
+	n.numOut = n.Type.NumOut()
+	return n.numOut
 }
 
-func (n Nature) IsVariadic() bool {
-	if n.Type == nil {
-		return false
+func (n *Nature) Out(c *Cache, i int) Nature {
+	if i != 0 {
+		return n.out(c, i)
+	}
+	if n.outZero != nil {
+		return *n.outZero
 	}
-	return n.Type.IsVariadic()
+	nt := n.out(c, 0)
+	n.outZero = &nt
+	return nt
 }
 
-func (n Nature) FieldByName(name string) (Nature, bool) {
+func (n *Nature) out(c *Cache, i int) Nature {
 	if n.Type == nil {
-		return unknown, false
+		return Nature{}
 	}
-	field, ok := fetchField(n.Type, name)
-	return Nature{Type: field.Type, FieldIndex: field.Index}, ok
+	return c.FromType(n.Type.Out(i))
 }
 
-func (n Nature) PkgPath() string {
-	if n.Type == nil {
-		return ""
+func (n *Nature) IsVariadic() bool {
+	if n.isVariadicSet {
+		return n.isVariadic
 	}
-	return n.Type.PkgPath()
+	n.isVariadicSet = true
+	n.isVariadic = n.Type.IsVariadic()
+	return n.isVariadic
 }
 
-func (n Nature) IsFastMap() bool {
-	if n.Type == nil {
-		return false
+func (n *Nature) FieldByName(c *Cache, name string) (Nature, bool) {
+	if n.Kind != reflect.Struct {
+		return Nature{}, false
 	}
-	if n.Type.Kind() == reflect.Map &&
-		n.Type.Key().Kind() == reflect.String &&
-		n.Type.Elem().Kind() == reflect.Interface {
-		return true
+	var sd *structData
+	if n.TypeData != nil && n.structData != nil {
+		sd = n.structData
+	} else {
+		sd = c.getStruct(n.Type).structData
 	}
-	return false
+	if sf := sd.structField(c, nil, name); sf != nil {
+		return sf.Nature, true
+	}
+	return Nature{}, false
 }
 
-func (n Nature) Get(name string) (Nature, bool) {
-	if n.Type == nil {
-		return unknown, false
-	}
+func (n *Nature) IsFastMap() bool {
+	return n.Type != nil &&
+		n.Type.Kind() == reflect.Map &&
+		n.Type.Key().Kind() == reflect.String &&
+		n.Type.Elem().Kind() == reflect.Interface
+}
 
-	if m, ok := n.MethodByName(name); ok {
-		return m, true
+func (n *Nature) Get(c *Cache, name string) (Nature, bool) {
+	if n.Kind == reflect.Map && n.TypeData != nil {
+		f, ok := n.Fields[name]
+		return f, ok
 	}
+	return n.getSlow(c, name)
+}
 
-	t := deref.Type(n.Type)
-
-	switch t.Kind() {
-	case reflect.Struct:
-		if f, ok := fetchField(t, name); ok {
-			return Nature{
-				Type:       f.Type,
-				FieldIndex: f.Index,
-			}, true
-		}
-	case reflect.Map:
-		if f, ok := n.Fields[name]; ok {
-			return f, true
+func (n *Nature) getSlow(c *Cache, name string) (Nature, bool) {
+	if nt, ok := n.MethodByName(c, name); ok {
+		return nt, true
+	}
+	if n.Kind == reflect.Struct {
+		if sf := n.structField(c, nil, name); sf != nil {
+			return sf.Nature, true
 		}
 	}
-	return unknown, false
+	return Nature{}, false
 }
 
-func (n Nature) All() map[string]Nature {
+func (n *Nature) FieldIndex(c *Cache, name string) ([]int, bool) {
+	if n.Kind != reflect.Struct {
+		return nil, false
+	}
+	if sf := n.structField(c, nil, name); sf != nil {
+		return sf.Index, true
+	}
+	return nil, false
+}
+
+func (n *Nature) All(c *Cache) map[string]Nature {
 	table := make(map[string]Nature)
 
 	if n.Type == nil {
 		return table
 	}
 
-	for i := 0; i < n.Type.NumMethod(); i++ {
+	for i := 0; i < n.NumMethods(c); i++ {
 		method := n.Type.Method(i)
-		table[method.Name] = Nature{
-			Type:        method.Type,
-			Method:      true,
-			MethodIndex: method.Index,
+		nt := c.FromType(method.Type)
+		if nt.TypeData == nil {
+			nt.TypeData = new(TypeData)
 		}
+		nt.Method = true
+		nt.MethodIndex = method.Index
+		table[method.Name] = nt
 	}
 
 	t := deref.Type(n.Type)
 
 	switch t.Kind() {
 	case reflect.Struct:
-		for name, nt := range StructFields(t) {
+		for name, nt := range StructFields(c, t) {
 			if _, ok := table[name]; ok {
 				continue
 			}
@@ -249,13 +452,116 @@ func (n Nature) All() map[string]Nature {
 		}
 
 	case reflect.Map:
-		for key, nt := range n.Fields {
-			if _, ok := table[key]; ok {
-				continue
+		if n.TypeData != nil {
+			for key, nt := range n.Fields {
+				if _, ok := table[key]; ok {
+					continue
+				}
+				table[key] = nt
 			}
-			table[key] = nt
 		}
 	}
 
 	return table
 }
+
+func (n *Nature) IsNumber() bool {
+	return n.IsInteger || n.IsFloat
+}
+
+func (n *Nature) PromoteNumericNature(c *Cache, rhs Nature) Nature {
+	if n.IsUnknown(c) || rhs.IsUnknown(c) {
+		return Nature{}
+	}
+	if n.IsFloat || rhs.IsFloat {
+		return c.FromType(floatType)
+	}
+	return c.FromType(intType)
+}
+
+func (n *Nature) IsTime() bool {
+	return n.Type == timeType
+}
+
+func (n *Nature) IsDuration() bool {
+	return n.Type == durationType
+}
+
+func (n *Nature) IsBool() bool {
+	return n.Kind == reflect.Bool
+}
+
+func (n *Nature) IsString() bool {
+	return n.Kind == reflect.String
+}
+
+func (n *Nature) IsArray() bool {
+	return n.Kind == reflect.Slice || n.Kind == reflect.Array
+}
+
+func (n *Nature) IsMap() bool {
+	return n.Kind == reflect.Map
+}
+
+func (n *Nature) IsStruct() bool {
+	return n.Kind == reflect.Struct
+}
+
+func (n *Nature) IsFunc() bool {
+	return n.Kind == reflect.Func
+}
+
+func (n *Nature) IsPointer() bool {
+	return n.Kind == reflect.Ptr
+}
+
+func (n *Nature) IsAnyOf(cs ...NatureCheck) bool {
+	var result bool
+	for i := 0; i < len(cs) && !result; i++ {
+		switch cs[i] {
+		case BoolCheck:
+			result = n.IsBool()
+		case StringCheck:
+			result = n.IsString()
+		case IntegerCheck:
+			result = n.IsInteger
+		case NumberCheck:
+			result = n.IsNumber()
+		case MapCheck:
+			result = n.IsMap()
+		case ArrayCheck:
+			result = n.IsArray()
+		case TimeCheck:
+			result = n.IsTime()
+		case DurationCheck:
+			result = n.IsDuration()
+		default:
+			panic(fmt.Sprintf("unknown check value %d", cs[i]))
+		}
+	}
+	return result
+}
+
+func (n *Nature) ComparableTo(c *Cache, rhs Nature) bool {
+	return n.IsUnknown(c) || rhs.IsUnknown(c) ||
+		n.Nil || rhs.Nil ||
+		n.IsNumber() && rhs.IsNumber() ||
+		n.IsDuration() && rhs.IsDuration() ||
+		n.IsTime() && rhs.IsTime() ||
+		n.IsArray() && rhs.IsArray() ||
+		n.AssignableTo(rhs)
+}
+
+func (n *Nature) MaybeCompatible(c *Cache, rhs Nature, cs ...NatureCheck) bool {
+	nIsUnknown := n.IsUnknown(c)
+	rshIsUnknown := rhs.IsUnknown(c)
+	return nIsUnknown && rshIsUnknown ||
+		nIsUnknown && rhs.IsAnyOf(cs...) ||
+		rshIsUnknown && n.IsAnyOf(cs...)
+}
+
+func (n *Nature) MakeArrayOf(c *Cache) Nature {
+	nt := c.FromType(arrayType)
+	nt.Ref = n
+	return nt
+}
diff --git a/checker/nature/utils.go b/checker/nature/utils.go
index c1551546c..755c2e08b 100644
--- a/checker/nature/utils.go
+++ b/checker/nature/utils.go
@@ -6,84 +6,227 @@ import (
 	"github.com/expr-lang/expr/internal/deref"
 )
 
-func fieldName(field reflect.StructField) (string, bool) {
-	switch taggedName := field.Tag.Get("expr"); taggedName {
+func fieldName(fieldName string, tag reflect.StructTag) (string, bool) {
+	switch taggedName := tag.Get("expr"); taggedName {
 	case "-":
 		return "", false
 	case "":
-		return field.Name, true
+		return fieldName, true
 	default:
 		return taggedName, true
 	}
 }
 
-func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
-	// If t is not a struct, early return.
-	if t.Kind() != reflect.Struct {
-		return reflect.StructField{}, false
+type structData struct {
+	rType                     reflect.Type
+	fields                    map[string]*structField
+	numField, ownIdx, anonIdx int
+
+	curParent, curChild *structData
+	curChildIndex       []int
+}
+
+type structField struct {
+	Nature
+	Index []int
+}
+
+func (s *structData) finished() bool {
+	return s.ownIdx >= s.numField && // no own fields left to visit
+		s.anonIdx >= s.numField && // no embedded fields to visit
+		s.curChild == nil // no child in process of visiting
+}
+
+func (s *structData) structField(c *Cache, parentEmbed *structData, name string) *structField {
+	if s.fields == nil {
+		if s.numField > 0 {
+			s.fields = make(map[string]*structField, s.numField)
+		}
+	} else if f := s.fields[name]; f != nil {
+		return f
+	}
+	if s.finished() {
+		return nil
 	}
 
-	// First check all structs fields.
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
-		// Search all fields, even embedded structs.
-		if n, ok := fieldName(field); ok && n == name {
-			return field, true
+	// Lookup own fields first.
+	for ; s.ownIdx < s.numField; s.ownIdx++ {
+		field := s.rType.Field(s.ownIdx)
+		// BUG: we should skip if !field.IsExported() here
+
+		if field.Anonymous && s.anonIdx < 0 {
+			// start iterating anon fields on the first instead of zero
+			s.anonIdx = s.ownIdx
+		}
+		fName, ok := fieldName(field.Name, field.Tag)
+		if !ok || fName == "" {
+			// name can still be empty for a type created at runtime with
+			// reflect
+			continue
+		}
+		nt := c.FromType(field.Type)
+		sf := &structField{
+			Nature: nt,
+			Index:  field.Index,
+		}
+		s.fields[fName] = sf
+		if parentEmbed != nil {
+			parentEmbed.trySet(fName, sf)
+		}
+		if fName == name {
+			return sf
+		}
+	}
+
+	if s.curChild != nil {
+		sf := s.findInEmbedded(c, parentEmbed, s.curChild, s.curChildIndex, name)
+		if sf != nil {
+			return sf
 		}
 	}
 
-	// Second check fields of embedded structs.
-	for i := 0; i < t.NumField(); i++ {
-		anon := t.Field(i)
-		if anon.Anonymous {
-			anonType := anon.Type
-			if anonType.Kind() == reflect.Pointer {
-				anonType = anonType.Elem()
-			}
-			if field, ok := fetchField(anonType, name); ok {
-				field.Index = append(anon.Index, field.Index...)
-				return field, true
-			}
+	// Lookup embedded fields through anon own fields
+	for ; s.anonIdx >= 0 && s.anonIdx < s.numField; s.anonIdx++ {
+		field := s.rType.Field(s.anonIdx)
+		// we do enter embedded non-exported types because they could contain
+		// exported fields
+		if !field.Anonymous {
+			continue
+		}
+		t, k, _ := deref.TypeKind(field.Type, field.Type.Kind())
+		if k != reflect.Struct {
+			continue
+		}
+
+		childEmbed := c.getStruct(t).structData
+		sf := s.findInEmbedded(c, parentEmbed, childEmbed, field.Index, name)
+		if sf != nil {
+			return sf
 		}
 	}
 
-	return reflect.StructField{}, false
+	return nil
 }
 
-func StructFields(t reflect.Type) map[string]Nature {
-	table := make(map[string]Nature)
+func (s *structData) findInEmbedded(
+	c *Cache,
+	parentEmbed, childEmbed *structData,
+	childIndex []int,
+	name string,
+) *structField {
+	// Set current parent/child data. This allows trySet to handle child fields
+	// and add them to our struct and to the parent as well if needed
+	s.curParent = parentEmbed
+	s.curChild = childEmbed
+	s.curChildIndex = childIndex
+	defer func() {
+		// Ensure to cleanup references
+		s.curParent = nil
+		if childEmbed.finished() {
+			// If the child can still have more fields to explore then keep it
+			// referened to look it up again if we need to
+			s.curChild = nil
+			s.curChildIndex = nil
+		}
+	}()
 
-	t = deref.Type(t)
+	// See if the child has already cached its fields. This is still important
+	// to check even if it's the s.unfinishedEmbedded because it may have
+	// explored new fields since the last time we visited it
+	for name, sf := range childEmbed.fields {
+		s.trySet(name, sf)
+	}
+
+	// Recheck if we have what we needed from the above sync
+	if sf := s.fields[name]; sf != nil {
+		return sf
+	}
+
+	// Try finding in the child again in case it hasn't finished
+	if !childEmbed.finished() {
+		if childEmbed.structField(c, s, name) != nil {
+			return s.fields[name]
+		}
+	}
+
+	return nil
+}
+
+func (s *structData) trySet(name string, sf *structField) {
+	if _, ok := s.fields[name]; ok {
+		return
+	}
+	sf = &structField{
+		Nature: sf.Nature,
+		Index:  append(s.curChildIndex, sf.Index...),
+	}
+	s.fields[name] = sf
+	if s.curParent != nil {
+		s.curParent.trySet(name, sf)
+	}
+}
+
+func StructFields(c *Cache, t reflect.Type) map[string]Nature {
+	table := make(map[string]Nature)
 	if t == nil {
 		return table
 	}
+	t, k, _ := deref.TypeKind(t, t.Kind())
+	if k == reflect.Struct {
+		// lookup for a field with an empty name, which will cause to never find a
+		// match, meaning everything will have been cached.
+		sd := c.getStruct(t).structData
+		sd.structField(c, nil, "")
+		for name, sf := range sd.fields {
+			table[name] = sf.Nature
+		}
+	}
+	return table
+}
 
-	switch t.Kind() {
-	case reflect.Struct:
-		for i := 0; i < t.NumField(); i++ {
-			f := t.Field(i)
+type methodset struct {
+	rType          reflect.Type
+	kind           reflect.Kind
+	methods        map[string]*method
+	numMethod, idx int
+}
 
-			if f.Anonymous {
-				for name, typ := range StructFields(f.Type) {
-					if _, ok := table[name]; ok {
-						continue
-					}
-					typ.FieldIndex = append(f.Index, typ.FieldIndex...)
-					table[name] = typ
-				}
-			}
+type method struct {
+	reflect.Method
+	nature Nature
+}
 
-			name, ok := fieldName(f)
-			if !ok {
-				continue
-			}
-			table[name] = Nature{
-				Type:       f.Type,
-				FieldIndex: f.Index,
-			}
+func (s *methodset) method(c *Cache, name string) *method {
+	if s.methods == nil {
+		s.methods = make(map[string]*method, s.numMethod)
+	} else if m := s.methods[name]; m != nil {
+		return m
+	}
+	for ; s.idx < s.numMethod; s.idx++ {
+		rm := s.rType.Method(s.idx)
+		if !rm.IsExported() {
+			continue
+		}
+		nt := c.FromType(rm.Type)
+		if s.rType.Kind() != reflect.Interface {
+			nt.Method = true
+			nt.MethodIndex = rm.Index
+			// In case of interface type method will not have a receiver,
+			// and to prevent checker decreasing numbers of in arguments
+			// return method type as not method (second argument is false).
 
+			// Also, we can not use m.Index here, because it will be
+			// different indexes for different types which implement
+			// the same interface.
+		}
+		m := &method{
+			Method: rm,
+			nature: nt,
+		}
+		s.methods[rm.Name] = m
+		if rm.Name == name {
+			return m
 		}
 	}
-
-	return table
+	return nil
 }
diff --git a/checker/types.go b/checker/types.go
deleted file mode 100644
index 09896de5d..000000000
--- a/checker/types.go
+++ /dev/null
@@ -1,190 +0,0 @@
-package checker
-
-import (
-	"reflect"
-	"time"
-
-	. "github.com/expr-lang/expr/checker/nature"
-)
-
-var (
-	unknown        = Nature{}
-	nilNature      = Nature{Nil: true}
-	boolNature     = Nature{Type: reflect.TypeOf(true)}
-	integerNature  = Nature{Type: reflect.TypeOf(0)}
-	floatNature    = Nature{Type: reflect.TypeOf(float64(0))}
-	stringNature   = Nature{Type: reflect.TypeOf("")}
-	arrayNature    = Nature{Type: reflect.TypeOf([]any{})}
-	mapNature      = Nature{Type: reflect.TypeOf(map[string]any{})}
-	timeNature     = Nature{Type: reflect.TypeOf(time.Time{})}
-	durationNature = Nature{Type: reflect.TypeOf(time.Duration(0))}
-)
-
-var (
-	anyType      = reflect.TypeOf(new(any)).Elem()
-	timeType     = reflect.TypeOf(time.Time{})
-	durationType = reflect.TypeOf(time.Duration(0))
-	arrayType    = reflect.TypeOf([]any{})
-)
-
-func arrayOf(nt Nature) Nature {
-	return Nature{
-		Type:    arrayType,
-		ArrayOf: &nt,
-	}
-}
-
-func isNil(nt Nature) bool {
-	return nt.Nil
-}
-
-func combined(l, r Nature) Nature {
-	if isUnknown(l) || isUnknown(r) {
-		return unknown
-	}
-	if isFloat(l) || isFloat(r) {
-		return floatNature
-	}
-	return integerNature
-}
-
-func anyOf(nt Nature, fns ...func(Nature) bool) bool {
-	for _, fn := range fns {
-		if fn(nt) {
-			return true
-		}
-	}
-	return false
-}
-
-func or(l, r Nature, fns ...func(Nature) bool) bool {
-	if isUnknown(l) && isUnknown(r) {
-		return true
-	}
-	if isUnknown(l) && anyOf(r, fns...) {
-		return true
-	}
-	if isUnknown(r) && anyOf(l, fns...) {
-		return true
-	}
-	return false
-}
-
-func isUnknown(nt Nature) bool {
-	return nt.IsUnknown()
-}
-
-func isInteger(nt Nature) bool {
-	switch nt.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		fallthrough
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return nt.PkgPath() == ""
-	}
-	return false
-}
-
-func isFloat(nt Nature) bool {
-	switch nt.Kind() {
-	case reflect.Float32, reflect.Float64:
-		return nt.PkgPath() == ""
-	}
-	return false
-}
-
-func isNumber(nt Nature) bool {
-	return isInteger(nt) || isFloat(nt)
-}
-
-func isTime(nt Nature) bool {
-	switch nt.Type {
-	case timeType:
-		return true
-	}
-	return false
-}
-
-func isDuration(nt Nature) bool {
-	switch nt.Type {
-	case durationType:
-		return true
-	}
-	return false
-}
-
-func isBool(nt Nature) bool {
-	switch nt.Kind() {
-	case reflect.Bool:
-		return true
-	}
-	return false
-}
-
-func isString(nt Nature) bool {
-	switch nt.Kind() {
-	case reflect.String:
-		return true
-	}
-	return false
-}
-
-func isArray(nt Nature) bool {
-	switch nt.Kind() {
-	case reflect.Slice, reflect.Array:
-		return true
-	}
-	return false
-}
-
-func isMap(nt Nature) bool {
-	switch nt.Kind() {
-	case reflect.Map:
-		return true
-	}
-	return false
-}
-
-func isStruct(nt Nature) bool {
-	switch nt.Kind() {
-	case reflect.Struct:
-		return true
-	}
-	return false
-}
-
-func isFunc(nt Nature) bool {
-	switch nt.Kind() {
-	case reflect.Func:
-		return true
-	}
-	return false
-}
-
-func kind(t reflect.Type) reflect.Kind {
-	if t == nil {
-		return reflect.Invalid
-	}
-	return t.Kind()
-}
-
-func isComparable(l, r Nature) bool {
-	if isUnknown(l) || isUnknown(r) {
-		return true
-	}
-	if isNil(l) || isNil(r) {
-		return true
-	}
-	if isNumber(l) && isNumber(r) {
-		return true
-	}
-	if isDuration(l) && isDuration(r) {
-		return true
-	}
-	if isTime(l) && isTime(r) {
-		return true
-	}
-	if isArray(l) && isArray(r) {
-		return true
-	}
-	return l.AssignableTo(r)
-}
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 595355d28..c7469030c 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -5,6 +5,7 @@ import (
 	"math"
 	"reflect"
 	"regexp"
+	"runtime/debug"
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/builtin"
@@ -24,7 +25,7 @@ const (
 func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err error) {
 	defer func() {
 		if r := recover(); r != nil {
-			err = fmt.Errorf("%v", r)
+			err = fmt.Errorf("%v\n%s", r, debug.Stack())
 		}
 	}()
 
@@ -36,6 +37,12 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 		debugInfo:      make(map[string]string),
 	}
 
+	if config != nil {
+		c.ntCache = &c.config.NtCache
+	} else {
+		c.ntCache = new(Cache)
+	}
+
 	c.compile(tree.Node)
 
 	if c.config != nil {
@@ -74,6 +81,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 
 type compiler struct {
 	config         *conf.Config
+	ntCache        *Cache
 	locations      []file.Location
 	bytecode       []Opcode
 	variables      int
@@ -302,12 +310,12 @@ func (c *compiler) IdentifierNode(node *ast.IdentifierNode) {
 
 	if env.IsFastMap() {
 		c.emit(OpLoadFast, c.addConstant(node.Value))
-	} else if ok, index, name := checker.FieldIndex(env, node); ok {
+	} else if ok, index, name := checker.FieldIndex(c.ntCache, env, node); ok {
 		c.emit(OpLoadField, c.addConstant(&runtime.Field{
 			Index: index,
 			Path:  []string{name},
 		}))
-	} else if ok, index, name := checker.MethodIndex(env, node); ok {
+	} else if ok, index, name := checker.MethodIndex(c.ntCache, env, node); ok {
 		c.emit(OpLoadMethod, c.addConstant(&runtime.Method{
 			Name:  name,
 			Index: index,
@@ -653,7 +661,7 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 		env = c.config.Env
 	}
 
-	if ok, index, name := checker.MethodIndex(env, node); ok {
+	if ok, index, name := checker.MethodIndex(c.ntCache, env, node); ok {
 		c.compile(node.Node)
 		c.emit(OpMethod, c.addConstant(&runtime.Method{
 			Name:  name,
@@ -664,14 +672,14 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 	op := OpFetch
 	base := node.Node
 
-	ok, index, nodeName := checker.FieldIndex(env, node)
+	ok, index, nodeName := checker.FieldIndex(c.ntCache, env, node)
 	path := []string{nodeName}
 
 	if ok {
 		op = OpFetchField
 		for !node.Optional {
 			if ident, isIdent := base.(*ast.IdentifierNode); isIdent {
-				if ok, identIndex, name := checker.FieldIndex(env, ident); ok {
+				if ok, identIndex, name := checker.FieldIndex(c.ntCache, env, ident); ok {
 					index = append(identIndex, index...)
 					path = append([]string{name}, path...)
 					c.emitLocation(ident.Location(), OpLoadField, c.addConstant(
@@ -682,7 +690,7 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 			}
 
 			if member, isMember := base.(*ast.MemberNode); isMember {
-				if ok, memberIndex, name := checker.FieldIndex(env, member); ok {
+				if ok, memberIndex, name := checker.FieldIndex(c.ntCache, env, member); ok {
 					index = append(memberIndex, index...)
 					path = append([]string{name}, path...)
 					node = member
@@ -743,7 +751,7 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 				}
 			}
 		case *ast.IdentifierNode:
-			if t, ok := c.config.Env.MethodByName(callee.Value); ok && t.Method {
+			if t, ok := c.config.Env.MethodByName(c.ntCache, callee.Value); ok && t.Method {
 				fnInOffset = 1
 				fnNumIn--
 			}
@@ -777,7 +785,7 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 	c.compile(node.Callee)
 
 	if c.config != nil {
-		isMethod, _, _ := checker.MethodIndex(c.config.Env, node.Callee)
+		isMethod, _, _ := checker.MethodIndex(c.ntCache, c.config.Env, node.Callee)
 		if index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok {
 			c.emit(OpCallTyped, index)
 			return
@@ -1080,7 +1088,8 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		for i, arg := range node.Arguments {
 			c.compile(arg)
 			argType := arg.Type()
-			if argType.Kind() == reflect.Ptr || arg.Nature().IsUnknown() {
+			argNature := arg.Nature()
+			if argType.Kind() == reflect.Ptr || argNature.IsUnknown(c.ntCache) {
 				if f.Deref == nil {
 					// By default, builtins expect arguments to be dereferenced.
 					c.emit(OpDeref)
diff --git a/conf/config.go b/conf/config.go
index 2c14d9882..8799d3d04 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -34,6 +34,7 @@ type Config struct {
 	Functions FunctionsTable
 	Builtins  FunctionsTable
 	Disabled  map[string]bool // disabled builtins
+	NtCache   nature.Cache
 }
 
 // CreateNew creates new config with default values.
@@ -61,7 +62,7 @@ func New(env any) *Config {
 
 func (c *Config) WithEnv(env any) {
 	c.EnvObject = env
-	c.Env = Env(env)
+	c.Env = EnvWithCache(&c.NtCache, env)
 	c.Strict = c.Env.Strict
 }
 
@@ -92,7 +93,7 @@ func (c *Config) IsOverridden(name string) bool {
 	if _, ok := c.Functions[name]; ok {
 		return true
 	}
-	if _, ok := c.Env.Get(name); ok {
+	if _, ok := c.Env.Get(&c.NtCache, name); ok {
 		return true
 	}
 	return false
diff --git a/conf/env.go b/conf/env.go
index 8b13df1e1..0acd44570 100644
--- a/conf/env.go
+++ b/conf/env.go
@@ -9,35 +9,42 @@ import (
 	"github.com/expr-lang/expr/types"
 )
 
+// Env returns the Nature of the given environment.
+//
+// Deprecated: use EnvWithCache instead.
 func Env(env any) Nature {
+	return EnvWithCache(new(Cache), env)
+}
+
+func EnvWithCache(c *Cache, env any) Nature {
 	if env == nil {
-		return Nature{
-			Type:   reflect.TypeOf(map[string]any{}),
-			Strict: true,
-		}
+		n := c.NatureOf(map[string]any{})
+		n.Strict = true
+		return n
 	}
 
 	switch env := env.(type) {
 	case types.Map:
-		return env.Nature()
+		nt := env.Nature()
+		return nt
 	}
 
 	v := reflect.ValueOf(env)
-	d := deref.Value(v)
+	t := v.Type()
 
-	switch d.Kind() {
+	switch deref.Value(v).Kind() {
 	case reflect.Struct:
-		return Nature{
-			Type:   v.Type(),
-			Strict: true,
-		}
+		n := c.FromType(t)
+		n.Strict = true
+		return n
 
 	case reflect.Map:
-		n := Nature{
-			Type:   v.Type(),
-			Fields: make(map[string]Nature, v.Len()),
-			Strict: true,
+		n := c.FromType(v.Type())
+		if n.TypeData == nil {
+			n.TypeData = new(TypeData)
 		}
+		n.Strict = true
+		n.Fields = make(map[string]Nature, v.Len())
 
 		for _, key := range v.MapKeys() {
 			elem := v.MapIndex(key)
@@ -49,14 +56,15 @@ func Env(env any) Nature {
 
 			switch face := face.(type) {
 			case types.Map:
-				n.Fields[key.String()] = face.Nature()
+				nt := face.Nature()
+				n.Fields[key.String()] = nt
 
 			default:
 				if face == nil {
-					n.Fields[key.String()] = Nature{Nil: true}
+					n.Fields[key.String()] = c.NatureOf(nil)
 					continue
 				}
-				n.Fields[key.String()] = Nature{Type: reflect.TypeOf(face)}
+				n.Fields[key.String()] = c.NatureOf(face)
 			}
 
 		}
diff --git a/docgen/docgen.go b/docgen/docgen.go
index 1844f23b5..17830106e 100644
--- a/docgen/docgen.go
+++ b/docgen/docgen.go
@@ -85,7 +85,9 @@ func CreateDoc(i any) *Context {
 		PkgPath:   deref.Type(reflect.TypeOf(i)).PkgPath(),
 	}
 
-	for name, t := range conf.Env(i).All() {
+	cache := new(nature.Cache)
+	env := conf.EnvWithCache(cache, i)
+	for name, t := range env.All(cache) {
 		if _, ok := c.Variables[Identifier(name)]; ok {
 			continue
 		}
@@ -221,7 +223,8 @@ appendix:
 			c.Types[name] = a
 		}
 
-		for name, field := range nature.StructFields(t) {
+		ntCache := new(nature.Cache)
+		for name, field := range nature.StructFields(ntCache, t) {
 			if isPrivate(name) || isProtobuf(name) {
 				continue
 			}
diff --git a/expr.go b/expr.go
index 48298fe7e..e8f4eb64b 100644
--- a/expr.go
+++ b/expr.go
@@ -48,6 +48,7 @@ func Operator(operator string, fn ...string) Option {
 			Overloads: fn,
 			Env:       &c.Env,
 			Functions: c.Functions,
+			NtCache:   &c.NtCache,
 		}
 		c.Visitors = append(c.Visitors, p)
 	}
diff --git a/internal/deref/deref.go b/internal/deref/deref.go
index da3e28ce6..4ad7877f8 100644
--- a/internal/deref/deref.go
+++ b/internal/deref/deref.go
@@ -45,3 +45,12 @@ func Value(v reflect.Value) reflect.Value {
 	}
 	return v
 }
+
+func TypeKind(t reflect.Type, k reflect.Kind) (_ reflect.Type, _ reflect.Kind, changed bool) {
+	for k == reflect.Pointer {
+		changed = true
+		t = t.Elem()
+		k = t.Kind()
+	}
+	return t, k, changed
+}
diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go
index a8cf6a5be..fe41e824a 100644
--- a/parser/lexer/lexer.go
+++ b/parser/lexer/lexer.go
@@ -92,13 +92,6 @@ func (l *Lexer) peek() rune {
 	return eof
 }
 
-func (l *Lexer) peekByte() (byte, bool) {
-	if l.end.byte >= 0 && l.end.byte < len(l.source.String()) {
-		return l.source.String()[l.end.byte], true
-	}
-	return 0, false
-}
-
 func (l *Lexer) backup() {
 	if l.eof {
 		l.eof = false
diff --git a/parser/parser.go b/parser/parser.go
index e1dd111fc..6034403bf 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -12,7 +12,6 @@ import (
 	"github.com/expr-lang/expr/builtin"
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
-	"github.com/expr-lang/expr/parser/lexer"
 	. "github.com/expr-lang/expr/parser/lexer"
 	"github.com/expr-lang/expr/parser/operator"
 	"github.com/expr-lang/expr/parser/utils"
@@ -49,7 +48,7 @@ var predicates = map[string]struct {
 
 // Parser is a reusable parser. The zero value is ready for use.
 type Parser struct {
-	lexer            *lexer.Lexer
+	lexer            *Lexer
 	current, stashed Token
 	hasStash         bool
 	err              *file.Error
@@ -60,7 +59,7 @@ type Parser struct {
 
 func (p *Parser) Parse(input string, config *conf.Config) (*Tree, error) {
 	if p.lexer == nil {
-		p.lexer = lexer.New()
+		p.lexer = New()
 	}
 	p.config = config
 	source := file.NewSource(input)
diff --git a/patcher/operator_override.go b/patcher/operator_override.go
index 308cbdba3..cf4287c24 100644
--- a/patcher/operator_override.go
+++ b/patcher/operator_override.go
@@ -16,6 +16,7 @@ type OperatorOverloading struct {
 	Env       *nature.Nature      // Env type.
 	Functions conf.FunctionsTable // Env functions.
 	applied   bool                // Flag to indicate if any changes were made to the tree.
+	NtCache   *nature.Cache
 }
 
 func (p *OperatorOverloading) Visit(node *ast.Node) {
@@ -62,7 +63,7 @@ func (p *OperatorOverloading) FindSuitableOperatorOverload(l, r reflect.Type) (r
 
 func (p *OperatorOverloading) findSuitableOperatorOverloadInTypes(l, r reflect.Type) (reflect.Type, string, bool) {
 	for _, fn := range p.Overloads {
-		fnType, ok := p.Env.Get(fn)
+		fnType, ok := p.Env.Get(p.NtCache, fn)
 		if !ok {
 			continue
 		}
@@ -109,7 +110,7 @@ func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex
 
 func (p *OperatorOverloading) Check() {
 	for _, fn := range p.Overloads {
-		fnType, foundType := p.Env.Get(fn)
+		fnType, foundType := p.Env.Get(p.NtCache, fn)
 		fnFunc, foundFunc := p.Functions[fn]
 		if !foundFunc && (!foundType || fnType.Type.Kind() != reflect.Func) {
 			panic(fmt.Errorf("function %s for %s operator does not exist in the environment", fn, p.Operator))
diff --git a/types/types.go b/types/types.go
index bb1cbe5fa..33257c500 100644
--- a/types/types.go
+++ b/types/types.go
@@ -44,7 +44,7 @@ func TypeOf(v any) Type {
 type anyType struct{}
 
 func (anyType) Nature() Nature {
-	return Nature{Type: nil}
+	return FromType(nil)
 }
 
 func (anyType) Equal(t Type) bool {
@@ -58,7 +58,7 @@ func (anyType) String() string {
 type nilType struct{}
 
 func (nilType) Nature() Nature {
-	return Nature{Nil: true}
+	return NatureOf(nil)
 }
 
 func (nilType) Equal(t Type) bool {
@@ -77,7 +77,7 @@ type rtype struct {
 }
 
 func (r rtype) Nature() Nature {
-	return Nature{Type: r.t}
+	return FromType(r.t)
 }
 
 func (r rtype) Equal(t Type) bool {
@@ -100,11 +100,12 @@ type Map map[string]Type
 const Extra = "[[__extra_keys__]]"
 
 func (m Map) Nature() Nature {
-	nt := Nature{
-		Type:   reflect.TypeOf(map[string]any{}),
-		Fields: make(map[string]Nature, len(m)),
-		Strict: true,
+	nt := NatureOf(map[string]any{})
+	if nt.TypeData == nil {
+		nt.TypeData = new(TypeData)
 	}
+	nt.Fields = make(map[string]Nature, len(m))
+	nt.Strict = true
 	for k, v := range m {
 		if k == Extra {
 			nt.Strict = false
@@ -155,11 +156,13 @@ type array struct {
 
 func (a array) Nature() Nature {
 	of := a.of.Nature()
-	return Nature{
-		Type:    reflect.TypeOf([]any{}),
-		Fields:  make(map[string]Nature, 1),
-		ArrayOf: &of,
+	nt := NatureOf([]any{})
+	if nt.TypeData == nil {
+		nt.TypeData = new(TypeData)
 	}
+	nt.Fields = make(map[string]Nature, 1)
+	nt.Ref = &of
+	return nt
 }
 
 func (a array) Equal(t Type) bool {

From 5f4de2012b5ae915bc90db0067201b5f90f24e3f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 18 Sep 2025 21:39:22 +0200
Subject: [PATCH 445/506] Add more tests

---
 expr_test.go                  | 23 ++++++++---------------
 test/issues/840/issue_test.go | 30 ++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 15 deletions(-)
 create mode 100644 test/issues/840/issue_test.go

diff --git a/expr_test.go b/expr_test.go
index bed6d7468..01ccdeeb9 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2318,23 +2318,16 @@ func TestEval_slices_out_of_bound(t *testing.T) {
 	}
 }
 
-func TestExpr_custom_tests(t *testing.T) {
-	f, err := os.Open("custom_tests.json")
-	if os.IsNotExist(err) {
-		t.Skip("no custom tests")
-		return
+func TestExpr_timeout(t *testing.T) {
+	tests := []struct{ code string }{
+		{`-999999..999999`},
+		{`map(1..999999, 1..999999)`},
+		{`map(1..999999, repeat('a', #))`},
 	}
 
-	require.NoError(t, err, "open file error")
-	defer f.Close()
-
-	var tests []string
-	err = json.NewDecoder(f).Decode(&tests)
-	require.NoError(t, err, "decode json error")
-
-	for id, tt := range tests {
-		t.Run(fmt.Sprintf("line %v", id+2), func(t *testing.T) {
-			program, err := expr.Compile(tt)
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			program, err := expr.Compile(tt.code)
 			require.NoError(t, err)
 
 			timeout := make(chan bool, 1)
diff --git a/test/issues/840/issue_test.go b/test/issues/840/issue_test.go
new file mode 100644
index 000000000..1c0d3c95b
--- /dev/null
+++ b/test/issues/840/issue_test.go
@@ -0,0 +1,30 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestEnvFieldMethods(t *testing.T) {
+	program, err := expr.Compile(`Func(0)`, expr.Env(&Env{}))
+	require.NoError(t, err)
+
+	env := &Env{}
+	env.Func = func() int {
+		return 42
+	}
+
+	out, err := expr.Run(program, Env{})
+	require.NoError(t, err)
+
+	require.Equal(t, 42, out)
+}
+
+type Env struct {
+	EmbeddedEnv
+	Func func() int
+}
+
+type EmbeddedEnv struct{}

From 69b27afae29804c646a7d51f8daaa032becd799d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Thu, 18 Sep 2025 21:45:44 +0200
Subject: [PATCH 446/506] Update README.md

---
 README.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 5afd743d8..a7ded479c 100644
--- a/README.md
+++ b/README.md
@@ -149,9 +149,9 @@ func main() {
 * [GoDaddy](https://godaddy.com) employs Expr for the customization of its GoDaddy Pro product.
 * [ByteDance](https://bytedance.com) incorporates Expr into its internal business rule engine.
 * [Aviasales](https://aviasales.ru) utilizes Expr as a business rule engine for its flight search engine.
-* [Wish.com](https://www.wish.com) employs Expr in its decision-making rule engine for the Wish Assistant.
-* [Naoma.AI](https://www.naoma.ai) uses Expr as a part of its call scoring engine.
+* [Alibaba](https://alibaba.com) uses Expr in a web framework for building recommendation services.
 * [Argo](https://argoproj.github.io) integrates Expr into Argo Rollouts and Argo Workflows for Kubernetes.
+* [Wish.com](https://www.wish.com) employs Expr in its decision-making rule engine for the Wish Assistant.
 * [OpenTelemetry](https://opentelemetry.io) integrates Expr into the OpenTelemetry Collector.
 * [Philips Labs](https://github.com/philips-labs/tabia) employs Expr in Tabia, a tool designed to collect insights on their code bases.
 * [CrowdSec](https://crowdsec.net) incorporates Expr into its security automation tool.
@@ -172,6 +172,7 @@ func main() {
 * [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system.
 * [WunderGraph Cosmo](https://github.com/wundergraph/cosmo) - GraphQL Federeration Router uses Expr to customize Middleware behaviour
 * [SOLO](https://solo.one) uses Expr interally to allow dynamic code execution with custom defined functions.
+* [Naoma.AI](https://www.naoma.ai) uses Expr as a part of its call scoring engine.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From 7dbd40912d18b1513abb25fab73d2f955115e3d2 Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Sun, 21 Sep 2025 15:42:57 -0300
Subject: [PATCH 447/506] Issue 840: Fix get field pointer struct (#843)

* improve issue test

* fix #840: pointer to struct env not returning fields
---
 checker/nature/nature.go      | 11 +++++++++--
 test/issues/840/issue_test.go | 15 ++++++++++-----
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/checker/nature/nature.go b/checker/nature/nature.go
index 483030aa1..ae406acbf 100644
--- a/checker/nature/nature.go
+++ b/checker/nature/nature.go
@@ -404,8 +404,15 @@ func (n *Nature) getSlow(c *Cache, name string) (Nature, bool) {
 	if nt, ok := n.MethodByName(c, name); ok {
 		return nt, true
 	}
-	if n.Kind == reflect.Struct {
-		if sf := n.structField(c, nil, name); sf != nil {
+	t, k, changed := deref.TypeKind(n.Type, n.Kind)
+	if k == reflect.Struct {
+		var sd *structData
+		if changed {
+			sd = c.getStruct(t).structData
+		} else {
+			sd = n.structData
+		}
+		if sf := sd.structField(c, nil, name); sf != nil {
 			return sf.Nature, true
 		}
 	}
diff --git a/test/issues/840/issue_test.go b/test/issues/840/issue_test.go
index 1c0d3c95b..abc00c3ad 100644
--- a/test/issues/840/issue_test.go
+++ b/test/issues/840/issue_test.go
@@ -8,23 +8,28 @@ import (
 )
 
 func TestEnvFieldMethods(t *testing.T) {
-	program, err := expr.Compile(`Func(0)`, expr.Env(&Env{}))
+	program, err := expr.Compile(`Func() + Int`, expr.Env(&Env{}))
 	require.NoError(t, err)
 
 	env := &Env{}
 	env.Func = func() int {
-		return 42
+		return 40
+	}
+	env.EmbeddedEnv = &EmbeddedEnv{
+		Int: 2,
 	}
 
-	out, err := expr.Run(program, Env{})
+	out, err := expr.Run(program, env)
 	require.NoError(t, err)
 
 	require.Equal(t, 42, out)
 }
 
 type Env struct {
-	EmbeddedEnv
+	*EmbeddedEnv
 	Func func() int
 }
 
-type EmbeddedEnv struct{}
+type EmbeddedEnv struct {
+	Int int
+}

From 3d0aec62ca6cbfb94989fa3857385c8d26c922b9 Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Sun, 21 Sep 2025 15:58:24 -0300
Subject: [PATCH 448/506] Fix #844 alternative 2: do not allow access to
 unexported struct fields (#846)

* add regression test

* fix #844: disallow direct access to unexported struct fields

---------

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 checker/checker_test.go       |   4 +-
 checker/nature/utils.go       |   5 +-
 test/issues/844/issue_test.go | 194 ++++++++++++++++++++++++++++++++++
 3 files changed, 199 insertions(+), 4 deletions(-)
 create mode 100644 test/issues/844/issue_test.go

diff --git a/checker/checker_test.go b/checker/checker_test.go
index bf2b812db..ec701534b 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -760,8 +760,8 @@ func TestCheck_TaggedFieldName(t *testing.T) {
 
 	config := conf.CreateNew()
 	expr.Env(struct {
-		x struct {
-			y bool `expr:"bar"`
+		X struct {
+			Y bool `expr:"bar"`
 		} `expr:"foo"`
 	}{})(config)
 	expr.AsBool()(config)
diff --git a/checker/nature/utils.go b/checker/nature/utils.go
index 755c2e08b..2af946002 100644
--- a/checker/nature/utils.go
+++ b/checker/nature/utils.go
@@ -52,12 +52,13 @@ func (s *structData) structField(c *Cache, parentEmbed *structData, name string)
 	// Lookup own fields first.
 	for ; s.ownIdx < s.numField; s.ownIdx++ {
 		field := s.rType.Field(s.ownIdx)
-		// BUG: we should skip if !field.IsExported() here
-
 		if field.Anonymous && s.anonIdx < 0 {
 			// start iterating anon fields on the first instead of zero
 			s.anonIdx = s.ownIdx
 		}
+		if !field.IsExported() {
+			continue
+		}
 		fName, ok := fieldName(field.Name, field.Tag)
 		if !ok || fName == "" {
 			// name can still be empty for a type created at runtime with
diff --git a/test/issues/844/issue_test.go b/test/issues/844/issue_test.go
new file mode 100644
index 000000000..2993ec82f
--- /dev/null
+++ b/test/issues/844/issue_test.go
@@ -0,0 +1,194 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/parser"
+)
+
+func TestIssue844(t *testing.T) {
+	testCases := []struct {
+		name       string
+		env        any
+		expression string
+		shouldFail bool
+	}{
+		{
+			name:       "exported env, exported field",
+			env:        ExportedEnv{},
+			expression: `ExportedEmbedded`,
+			shouldFail: false,
+		},
+		{
+			name:       "exported env, unexported field",
+			env:        ExportedEnv{},
+			expression: `unexportedEmbedded`,
+			shouldFail: true,
+		},
+		{
+			name:       "exported env, exported field inherited from exported field",
+			env:        ExportedEnv{},
+			expression: `Str`,
+			shouldFail: false,
+		},
+		{
+			name:       "exported env, unexported field inherited from exported field",
+			env:        ExportedEnv{},
+			expression: `str`,
+			shouldFail: true,
+		},
+		{
+			name:       "exported env, exported field inherited from exported field",
+			env:        ExportedEnv{},
+			expression: `Integer`,
+			shouldFail: false,
+		},
+		{
+			name:       "exported env, unexported field inherited from exported field",
+			env:        ExportedEnv{},
+			expression: `integer`,
+			shouldFail: true,
+		},
+		{
+			name:       "exported env, exported field directly accessed from exported field",
+			env:        ExportedEnv{},
+			expression: `ExportedEmbedded.Str`,
+			shouldFail: false,
+		},
+		{
+			name:       "exported env, unexported field directly accessed from exported field",
+			env:        ExportedEnv{},
+			expression: `ExportedEmbedded.str`,
+			shouldFail: true,
+		},
+		{
+			name:       "exported env, exported field directly accessed from exported field",
+			env:        ExportedEnv{},
+			expression: `unexportedEmbedded.Integer`,
+			shouldFail: true,
+		},
+		{
+			name:       "exported env, unexported field directly accessed from exported field",
+			env:        ExportedEnv{},
+			expression: `unexportedEmbedded.integer`,
+			shouldFail: true,
+		},
+		{
+			name:       "unexported env, exported field",
+			env:        unexportedEnv{},
+			expression: `ExportedEmbedded`,
+			shouldFail: false,
+		},
+		{
+			name:       "unexported env, unexported field",
+			env:        unexportedEnv{},
+			expression: `unexportedEmbedded`,
+			shouldFail: true,
+		},
+		{
+			name:       "unexported env, exported field inherited from exported field",
+			env:        unexportedEnv{},
+			expression: `Str`,
+			shouldFail: false,
+		},
+		{
+			name:       "unexported env, unexported field inherited from exported field",
+			env:        unexportedEnv{},
+			expression: `str`,
+			shouldFail: true,
+		},
+		{
+			name:       "unexported env, exported field inherited from exported field",
+			env:        unexportedEnv{},
+			expression: `Integer`,
+			shouldFail: false,
+		},
+		{
+			name:       "unexported env, unexported field inherited from exported field",
+			env:        unexportedEnv{},
+			expression: `integer`,
+			shouldFail: true,
+		},
+		{
+			name:       "unexported env, exported field directly accessed from exported field",
+			env:        unexportedEnv{},
+			expression: `ExportedEmbedded.Str`,
+			shouldFail: false,
+		},
+		{
+			name:       "unexported env, unexported field directly accessed from exported field",
+			env:        unexportedEnv{},
+			expression: `ExportedEmbedded.str`,
+			shouldFail: true,
+		},
+		{
+			name:       "unexported env, exported field directly accessed from exported field",
+			env:        unexportedEnv{},
+			expression: `unexportedEmbedded.Integer`,
+			shouldFail: true,
+		},
+		{
+			name:       "unexported env, unexported field directly accessed from exported field",
+			env:        unexportedEnv{},
+			expression: `unexportedEmbedded.integer`,
+			shouldFail: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			config := conf.New(tc.env)
+			tree, err := parser.ParseWithConfig(tc.expression, config)
+			require.NoError(t, err)
+
+			_, err = new(checker.Checker).PatchAndCheck(tree, config)
+			if tc.shouldFail {
+				require.Error(t, err)
+				errStr := err.Error()
+				if !strings.Contains(errStr, "unknown name") &&
+					!strings.Contains(errStr, " has no field ") {
+					t.Fatalf("expected a different error, got: %v", err)
+				}
+			} else {
+				require.NoError(t, err)
+			}
+
+			// We add this because the issue was actually not catching something
+			// that sometimes failed with the error:
+			//	reflect.Value.Interface: cannot return value obtained from unexported field or method
+			// This way, we test that everything we allow passing is also
+			// allowed later
+			_, err = expr.Eval(tc.expression, tc.env)
+			if tc.shouldFail {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+type ExportedEnv struct {
+	ExportedEmbedded
+	unexportedEmbedded
+}
+
+type unexportedEnv struct {
+	ExportedEmbedded
+	unexportedEmbedded
+}
+
+type ExportedEmbedded struct {
+	Str string
+	str string
+}
+
+type unexportedEmbedded struct {
+	Integer int
+	integer int
+}

From 5ac4a1a79919e2358c26f6e6f551c19b5af27293 Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Mon, 29 Sep 2025 06:10:45 -0300
Subject: [PATCH 449/506] make ast.Node return *nature.Nature (#849)

---
 ast/node.go          | 6 +++---
 checker/checker.go   | 3 +--
 checker/info.go      | 3 +--
 compiler/compiler.go | 3 +--
 4 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index 40c507aa6..f156f69be 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -15,7 +15,7 @@ var (
 type Node interface {
 	Location() file.Location
 	SetLocation(file.Location)
-	Nature() nature.Nature
+	Nature() *nature.Nature
 	SetNature(nature.Nature)
 	Type() reflect.Type
 	SetType(reflect.Type)
@@ -47,8 +47,8 @@ func (n *base) SetLocation(loc file.Location) {
 }
 
 // Nature returns the nature of the node.
-func (n *base) Nature() nature.Nature {
-	return n.nature
+func (n *base) Nature() *nature.Nature {
+	return &n.nature
 }
 
 // SetNature sets the nature of the node.
diff --git a/checker/checker.go b/checker/checker.go
index 531dadac3..e1d1f90a6 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -635,8 +635,7 @@ func (v *Checker) callNode(node *ast.CallNode) Nature {
 	// checker pass we should replace anyType on method node
 	// with new correct function return type.
 	if typ := node.Type(); typ != nil && typ != anyType {
-		nt := node.Nature()
-		return nt
+		return *node.Nature()
 	}
 
 	nt := v.visit(node.Callee)
diff --git a/checker/info.go b/checker/info.go
index 1b0e05100..57202e958 100644
--- a/checker/info.go
+++ b/checker/info.go
@@ -15,8 +15,7 @@ func FieldIndex(c *Cache, env Nature, node ast.Node) (bool, []int, string) {
 			return true, idx, n.Value
 		}
 	case *ast.MemberNode:
-		base := n.Node.Nature()
-		base = base.Deref(c)
+		base := n.Node.Nature().Deref(c)
 		if base.Kind == reflect.Struct {
 			if prop, ok := n.Property.(*ast.StringNode); ok {
 				if idx, ok := base.FieldIndex(c, prop.Value); ok {
diff --git a/compiler/compiler.go b/compiler/compiler.go
index c7469030c..83b19a885 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -1088,8 +1088,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		for i, arg := range node.Arguments {
 			c.compile(arg)
 			argType := arg.Type()
-			argNature := arg.Nature()
-			if argType.Kind() == reflect.Ptr || argNature.IsUnknown(c.ntCache) {
+			if argType.Kind() == reflect.Ptr || arg.Nature().IsUnknown(c.ntCache) {
 				if f.Deref == nil {
 					// By default, builtins expect arguments to be dereferenced.
 					c.emit(OpDeref)

From ad495449fa56d47beee87b7388f3b67cc57c7aeb Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Fri, 28 Nov 2025 14:45:06 +0200
Subject: [PATCH 450/506] fix(checker): array type in conditional op (#865)

Correctly handle mixed array types (e.g. `[]int` vs `[][]int`) in
ternary expressions by falling back to generic array type when element
types differ.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 checker/checker.go            |  7 +++++++
 checker/checker_test.go       |  1 +
 test/issues/819/issue_test.go | 36 +++++++++++++++++++++++++++++++++++
 3 files changed, 44 insertions(+)
 create mode 100644 test/issues/819/issue_test.go

diff --git a/checker/checker.go b/checker/checker.go
index e1d1f90a6..0210b4166 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -1277,6 +1277,13 @@ func (v *Checker) conditionalNode(node *ast.ConditionalNode) Nature {
 		return v.config.NtCache.NatureOf(nil)
 	}
 	if t1.AssignableTo(t2) {
+		if t1.IsArray() && t2.IsArray() {
+			e1 := t1.Elem(&v.config.NtCache)
+			e2 := t2.Elem(&v.config.NtCache)
+			if !e1.AssignableTo(e2) || !e2.AssignableTo(e1) {
+				return v.config.NtCache.FromType(arrayType)
+			}
+		}
 		return t1
 	}
 	return Nature{}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index ec701534b..541f63117 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -134,6 +134,7 @@ func TestCheck(t *testing.T) {
 		{"Bool ?? Bool"},
 		{"let foo = 1; foo == 1"},
 		{"(Embed).EmbedPointerEmbedInt > 0"},
+		{"(true ? [1] : [[1]])[0][0] == 1"},
 	}
 
 	c := new(checker.Checker)
diff --git a/test/issues/819/issue_test.go b/test/issues/819/issue_test.go
new file mode 100644
index 000000000..e1ad19084
--- /dev/null
+++ b/test/issues/819/issue_test.go
@@ -0,0 +1,36 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue819(t *testing.T) {
+	t.Run("case 1", func(t *testing.T) {
+		program, err := expr.Compile(`
+			let a = [1];
+			let b = type(a[0]) == 'array' ? a : [a];
+			b[0][0]
+		`)
+		require.NoError(t, err)
+
+		out, err := expr.Run(program, nil)
+		require.NoError(t, err)
+		require.Equal(t, 1, out)
+	})
+
+	t.Run("case 2", func(t *testing.T) {
+		program, err := expr.Compile(`
+			let range = [1,1000];
+			let arr = false ? range : [range];
+			map(arr, {len(#)})
+		`)
+		require.NoError(t, err)
+
+		out, err := expr.Run(program, nil)
+		require.NoError(t, err)
+		require.Equal(t, []interface{}{2}, out)
+	})
+}

From 3dbda4bd9c2531a05fe0ea77a4bf4d7f294dc1da Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 4 Dec 2025 16:39:47 +0200
Subject: [PATCH 451/506] fix(builtin): limit recursion depth (#870)

Add builtin.MaxDepth (default 10k) to prevent stack overflows when
processing deeply nested or cyclic structures in builtin functions.
The functions flatten, min, max, mean, and median now return a
"recursion depth exceeded" error instead of crashing the runtime.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 builtin/builtin.go      | 18 +++++---
 builtin/builtin_test.go | 97 +++++++++++++++++++++++++++++++++++++++++
 builtin/lib.go          | 33 ++++++++++----
 3 files changed, 134 insertions(+), 14 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index c23daf468..4fe356fbf 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -3,6 +3,7 @@ package builtin
 import (
 	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"reflect"
 	"sort"
@@ -16,6 +17,10 @@ import (
 var (
 	Index map[string]int
 	Names []string
+
+	// MaxDepth limits the recursion depth for nested structures.
+	MaxDepth      = 10000
+	ErrorMaxDepth = errors.New("recursion depth exceeded")
 )
 
 func init() {
@@ -377,7 +382,7 @@ var Builtins = []*Function{
 	{
 		Name: "max",
 		Func: func(args ...any) (any, error) {
-			return minMax("max", runtime.Less, args...)
+			return minMax("max", runtime.Less, 0, args...)
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			return validateAggregateFunc("max", args)
@@ -386,7 +391,7 @@ var Builtins = []*Function{
 	{
 		Name: "min",
 		Func: func(args ...any) (any, error) {
-			return minMax("min", runtime.More, args...)
+			return minMax("min", runtime.More, 0, args...)
 		},
 		Validate: func(args []reflect.Type) (reflect.Type, error) {
 			return validateAggregateFunc("min", args)
@@ -395,7 +400,7 @@ var Builtins = []*Function{
 	{
 		Name: "mean",
 		Func: func(args ...any) (any, error) {
-			count, sum, err := mean(args...)
+			count, sum, err := mean(0, args...)
 			if err != nil {
 				return nil, err
 			}
@@ -411,7 +416,7 @@ var Builtins = []*Function{
 	{
 		Name: "median",
 		Func: func(args ...any) (any, error) {
-			values, err := median(args...)
+			values, err := median(0, args...)
 			if err != nil {
 				return nil, err
 			}
@@ -940,7 +945,10 @@ var Builtins = []*Function{
 			if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
 				return nil, size, fmt.Errorf("cannot flatten %s", v.Kind())
 			}
-			ret := flatten(v)
+			ret, err := flatten(v, 0)
+			if err != nil {
+				return nil, 0, err
+			}
 			size = uint(len(ret))
 			return ret, size, nil
 		},
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 6ca1e8fdd..a5dabbbbe 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -722,3 +722,100 @@ func TestBuiltin_with_deref(t *testing.T) {
 		})
 	}
 }
+
+func TestBuiltin_flatten_recursion(t *testing.T) {
+	var s []any
+	s = append(s, &s) // s contains a pointer to itself
+
+	env := map[string]any{
+		"arr": s,
+	}
+
+	program, err := expr.Compile("flatten(arr)", expr.Env(env))
+	require.NoError(t, err)
+
+	_, err = expr.Run(program, env)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), builtin.ErrorMaxDepth.Error())
+}
+
+func TestBuiltin_flatten_recursion_slice(t *testing.T) {
+	s := make([]any, 1)
+	s[0] = s
+
+	env := map[string]any{
+		"arr": s,
+	}
+
+	program, err := expr.Compile("flatten(arr)", expr.Env(env))
+	require.NoError(t, err)
+
+	_, err = expr.Run(program, env)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), builtin.ErrorMaxDepth.Error())
+}
+
+func TestBuiltin_numerical_recursion(t *testing.T) {
+	s := make([]any, 1)
+	s[0] = s
+
+	env := map[string]any{
+		"arr": s,
+	}
+
+	tests := []string{
+		"max(arr)",
+		"min(arr)",
+		"mean(arr)",
+		"median(arr)",
+	}
+
+	for _, input := range tests {
+		t.Run(input, func(t *testing.T) {
+			program, err := expr.Compile(input, expr.Env(env))
+			require.NoError(t, err)
+
+			_, err = expr.Run(program, env)
+			require.Error(t, err)
+			assert.Contains(t, err.Error(), builtin.ErrorMaxDepth.Error())
+		})
+	}
+}
+
+func TestBuiltin_recursion_custom_max_depth(t *testing.T) {
+	originalMaxDepth := builtin.MaxDepth
+	defer func() {
+		builtin.MaxDepth = originalMaxDepth
+	}()
+
+	// Set a small depth limit
+	builtin.MaxDepth = 2
+
+	// Create a deeply nested array (depth 5)
+	// [1, [2, [3, [4, [5]]]]]
+	arr := []any{1, []any{2, []any{3, []any{4, []any{5}}}}}
+
+	env := map[string]any{
+		"arr": arr,
+	}
+
+	t.Run("flatten exceeds max depth", func(t *testing.T) {
+		program, err := expr.Compile("flatten(arr)", expr.Env(env))
+		require.NoError(t, err)
+
+		_, err = expr.Run(program, env)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), builtin.ErrorMaxDepth.Error())
+	})
+
+	t.Run("flatten within max depth", func(t *testing.T) {
+		// Depth 2: [1, [2]]
+		shallowArr := []any{1, []any{2}}
+		envShallow := map[string]any{"arr": shallowArr}
+		program, err := expr.Compile("flatten(arr)", expr.Env(envShallow))
+		require.NoError(t, err)
+
+		_, err = expr.Run(program, envShallow)
+		require.NoError(t, err)
+	})
+}
diff --git a/builtin/lib.go b/builtin/lib.go
index 6f6a3b6cd..07a029b2f 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -253,7 +253,10 @@ func String(arg any) any {
 	return fmt.Sprintf("%v", arg)
 }
 
-func minMax(name string, fn func(any, any) bool, args ...any) (any, error) {
+func minMax(name string, fn func(any, any) bool, depth int, args ...any) (any, error) {
+	if depth > MaxDepth {
+		return nil, ErrorMaxDepth
+	}
 	var val any
 	for _, arg := range args {
 		rv := reflect.ValueOf(arg)
@@ -261,7 +264,7 @@ func minMax(name string, fn func(any, any) bool, args ...any) (any, error) {
 		case reflect.Array, reflect.Slice:
 			size := rv.Len()
 			for i := 0; i < size; i++ {
-				elemVal, err := minMax(name, fn, rv.Index(i).Interface())
+				elemVal, err := minMax(name, fn, depth+1, rv.Index(i).Interface())
 				if err != nil {
 					return nil, err
 				}
@@ -294,7 +297,10 @@ func minMax(name string, fn func(any, any) bool, args ...any) (any, error) {
 	return val, nil
 }
 
-func mean(args ...any) (int, float64, error) {
+func mean(depth int, args ...any) (int, float64, error) {
+	if depth > MaxDepth {
+		return 0, 0, ErrorMaxDepth
+	}
 	var total float64
 	var count int
 
@@ -304,7 +310,7 @@ func mean(args ...any) (int, float64, error) {
 		case reflect.Array, reflect.Slice:
 			size := rv.Len()
 			for i := 0; i < size; i++ {
-				elemCount, elemSum, err := mean(rv.Index(i).Interface())
+				elemCount, elemSum, err := mean(depth+1, rv.Index(i).Interface())
 				if err != nil {
 					return 0, 0, err
 				}
@@ -327,7 +333,10 @@ func mean(args ...any) (int, float64, error) {
 	return count, total, nil
 }
 
-func median(args ...any) ([]float64, error) {
+func median(depth int, args ...any) ([]float64, error) {
+	if depth > MaxDepth {
+		return nil, ErrorMaxDepth
+	}
 	var values []float64
 
 	for _, arg := range args {
@@ -336,7 +345,7 @@ func median(args ...any) ([]float64, error) {
 		case reflect.Array, reflect.Slice:
 			size := rv.Len()
 			for i := 0; i < size; i++ {
-				elems, err := median(rv.Index(i).Interface())
+				elems, err := median(depth+1, rv.Index(i).Interface())
 				if err != nil {
 					return nil, err
 				}
@@ -355,18 +364,24 @@ func median(args ...any) ([]float64, error) {
 	return values, nil
 }
 
-func flatten(arg reflect.Value) []any {
+func flatten(arg reflect.Value, depth int) ([]any, error) {
+	if depth > MaxDepth {
+		return nil, ErrorMaxDepth
+	}
 	ret := []any{}
 	for i := 0; i < arg.Len(); i++ {
 		v := deref.Value(arg.Index(i))
 		if v.Kind() == reflect.Array || v.Kind() == reflect.Slice {
-			x := flatten(v)
+			x, err := flatten(v, depth+1)
+			if err != nil {
+				return nil, err
+			}
 			ret = append(ret, x...)
 		} else {
 			ret = append(ret, v.Interface())
 		}
 	}
-	return ret
+	return ret, nil
 }
 
 func get(params ...any) (out any, err error) {

From 73384e117febe7a5274a5efe53d3292fcb618f5f Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 4 Dec 2025 16:45:37 +0200
Subject: [PATCH 452/506] fix(vm): show func for safe calls in disassembly
 (#869)

Previously, safe builtin functions (OpCallSafe) were pushed to the stack
as constants (OpPush), causing the disassembler/debugger to display
their memory address (e.g., 0x140000...) instead of their name (e.g.,
concat).

This change updates the compiler to store the function name in debugInfo
when emitting OpCallSafe. The VM's disassembler now checks debugInfo for
OpPush arguments and displays the stored name if available.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 compiler/compiler.go          |  4 +++-
 test/issues/567/issue_test.go | 25 +++++++++++++++++++++++++
 vm/program.go                 |  3 +++
 3 files changed, 31 insertions(+), 1 deletion(-)
 create mode 100644 test/issues/567/issue_test.go

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 83b19a885..fe1c00c4d 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -1103,7 +1103,9 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		if f.Fast != nil {
 			c.emit(OpCallBuiltin1, id)
 		} else if f.Safe != nil {
-			c.emit(OpPush, c.addConstant(f.Safe))
+			id := c.addConstant(f.Safe)
+			c.emit(OpPush, id)
+			c.debugInfo[fmt.Sprintf("const_%d", id)] = node.Name
 			c.emit(OpCallSafe, len(node.Arguments))
 		} else if f.Func != nil {
 			c.emitFunction(f, len(node.Arguments))
diff --git a/test/issues/567/issue_test.go b/test/issues/567/issue_test.go
new file mode 100644
index 000000000..b5c76d83e
--- /dev/null
+++ b/test/issues/567/issue_test.go
@@ -0,0 +1,25 @@
+package expr_test
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue567(t *testing.T) {
+	program, err := expr.Compile("concat(1..2, 3..4)")
+	require.NoError(t, err)
+
+	var buf bytes.Buffer
+	program.DisassembleWriter(&buf)
+	output := buf.String()
+
+	// Check if "concat" is mentioned in the output
+	require.True(t, strings.Contains(output, "concat"), "expected 'concat' in disassembly output")
+
+	// It should appear as a pushed constant
+	require.True(t, strings.Contains(output, "OpPush\t<4>\tconcat"), "expected 'OpPush <4> concat' in disassembly output")
+}
diff --git a/vm/program.go b/vm/program.go
index 15ce26f5b..d146cc139 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -112,6 +112,9 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 			} else {
 				c = "out of range"
 			}
+			if name, ok := program.debugInfo[fmt.Sprintf("const_%d", arg)]; ok {
+				c = name
+			}
 			if r, ok := c.(*regexp.Regexp); ok {
 				c = r.String()
 			}

From cf589a44c53c1122549e6de3f457ce8baed3925d Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 4 Dec 2025 16:55:29 +0200
Subject: [PATCH 453/506] fix(vm): handle nil arguments in variadic funcs
 (#868)

Update OpCall to properly handle nil values passed to variadic
functions. Previously, passing nil as the last argument caused
an index out of range panic, and a single nil argument was
incorrectly treated as a nil slice. Added regression tests.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 test/issues/817/issue_test.go | 33 +++++++++++++++++++++++++++++++++
 vm/vm.go                      | 20 ++++++++++++++++++--
 2 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 test/issues/817/issue_test.go

diff --git a/test/issues/817/issue_test.go b/test/issues/817/issue_test.go
new file mode 100644
index 000000000..f397f9d1b
--- /dev/null
+++ b/test/issues/817/issue_test.go
@@ -0,0 +1,33 @@
+package issue_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue817_1(t *testing.T) {
+	out, err := expr.Eval(
+		`sprintf("result: %v %v", 1, nil)`,
+		map[string]any{
+			"sprintf": fmt.Sprintf,
+		},
+	)
+	require.NoError(t, err)
+	require.Equal(t, "result: 1 <nil>", out)
+}
+
+func TestIssue817_2(t *testing.T) {
+	out, err := expr.Eval(
+		`thing(nil)`,
+		map[string]any{
+			"thing": func(arg ...any) string {
+				return fmt.Sprintf("result: (%T) %v", arg[0], arg[0])
+			},
+		},
+	)
+	require.NoError(t, err)
+	require.Equal(t, "result: (<nil>) <nil>", out)
+}
diff --git a/vm/vm.go b/vm/vm.go
index ed61d2f90..960009f0a 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -330,13 +330,29 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.push(runtime.Slice(node, from, to))
 
 		case OpCall:
-			fn := reflect.ValueOf(vm.pop())
+			v := vm.pop()
+			if v == nil {
+				panic("invalid operation: cannot call nil")
+			}
+			fn := reflect.ValueOf(v)
+			if fn.Kind() != reflect.Func {
+				panic(fmt.Sprintf("invalid operation: cannot call non-function of type %T", v))
+			}
+			fnType := fn.Type()
 			size := arg
 			in := make([]reflect.Value, size)
+			isVariadic := fnType.IsVariadic()
+			numIn := fnType.NumIn()
 			for i := int(size) - 1; i >= 0; i-- {
 				param := vm.pop()
 				if param == nil {
-					in[i] = reflect.Zero(fn.Type().In(i))
+					var inType reflect.Type
+					if isVariadic && i >= numIn-1 {
+						inType = fnType.In(numIn - 1).Elem()
+					} else {
+						inType = fnType.In(i)
+					}
+					in[i] = reflect.Zero(inType)
 				} else {
 					in[i] = reflect.ValueOf(param)
 				}

From 96bace44f9238746ee2c792725f5bdcc6c09f22b Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 4 Dec 2025 16:57:02 +0200
Subject: [PATCH 454/506] chore: add regression test for issue 823 (#867)

Fixed in #824

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 test/issues/823/issue_test.go | 39 +++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 test/issues/823/issue_test.go

diff --git a/test/issues/823/issue_test.go b/test/issues/823/issue_test.go
new file mode 100644
index 000000000..672cc1f1f
--- /dev/null
+++ b/test/issues/823/issue_test.go
@@ -0,0 +1,39 @@
+package issue_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+type env struct {
+	Ctx context.Context `expr:"ctx"`
+}
+
+func TestIssue823(t *testing.T) {
+	p, err := expr.Compile(
+		"now2().After(date2())",
+		expr.Env(env{}),
+		expr.WithContext("ctx"),
+		expr.Function(
+			"now2",
+			func(params ...any) (any, error) { return time.Now(), nil },
+			new(func(context.Context) time.Time),
+		),
+		expr.Function(
+			"date2",
+			func(params ...any) (any, error) { return time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), nil },
+			new(func(context.Context) time.Time),
+		),
+	)
+	fmt.Printf("Compile result err: %v\n", err)
+	require.NoError(t, err)
+
+	r, err := expr.Run(p, &env{Ctx: context.Background()})
+	require.NoError(t, err)
+	require.True(t, r.(bool))
+}

From 709b577dd81a47647b4608e8dd6610828406256e Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 4 Dec 2025 17:22:43 +0200
Subject: [PATCH 455/506] fix(vm): handle nil in AsBool with undef vars (#866)

Update AsBool implementation to strictly return a boolean value,
ensuring that undefined variables are cast to false. Undefined
variables resolve to nil when AllowUndefinedVariables is enabled.
This adds a new ToBool runtime helper, updates the OpCast VM
instruction to support boolean casting, and modifies the compiler
to emit this cast when AsBool is used. Adds regression tests.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 compiler/compiler.go          |  2 +
 compiler/compiler_test.go     | 48 ++++++++++++++++++++
 test/issues/830/issue_test.go | 20 +++++++++
 vm/runtime/runtime.go         | 12 +++++
 vm/vm.go                      |  2 +
 vm/vm_test.go                 | 83 +++++++++++++++++++++++++++++++----
 6 files changed, 159 insertions(+), 8 deletions(-)
 create mode 100644 test/issues/830/issue_test.go

diff --git a/compiler/compiler.go b/compiler/compiler.go
index fe1c00c4d..d8a532440 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -53,6 +53,8 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro
 			c.emit(OpCast, 1)
 		case reflect.Float64:
 			c.emit(OpCast, 2)
+		case reflect.Bool:
+			c.emit(OpCast, 3)
 		}
 		if c.config.Optimize {
 			c.optimize()
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index b683b82d6..6efce686f 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -2,6 +2,7 @@ package compiler_test
 
 import (
 	"math"
+	"reflect"
 	"testing"
 
 	"github.com/expr-lang/expr/internal/testify/assert"
@@ -675,3 +676,50 @@ func TestCompile_call_on_nil(t *testing.T) {
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "foo is nil; cannot call nil as function")
 }
+
+func TestCompile_Expect(t *testing.T) {
+	tests := []struct {
+		input  string
+		option expr.Option
+		op     vm.Opcode
+		arg    int
+	}{
+		{
+			input:  "1",
+			option: expr.AsKind(reflect.Int),
+			op:     vm.OpCast,
+			arg:    0,
+		},
+		{
+			input:  "1",
+			option: expr.AsInt64(),
+			op:     vm.OpCast,
+			arg:    1,
+		},
+		{
+			input:  "1",
+			option: expr.AsFloat64(),
+			op:     vm.OpCast,
+			arg:    2,
+		},
+		{
+			input:  "true",
+			option: expr.AsBool(),
+			op:     vm.OpCast,
+			arg:    3,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			program, err := expr.Compile(tt.input, tt.option)
+			require.NoError(t, err)
+
+			lastOp := program.Bytecode[len(program.Bytecode)-1]
+			lastArg := program.Arguments[len(program.Arguments)-1]
+
+			assert.Equal(t, tt.op, lastOp)
+			assert.Equal(t, tt.arg, lastArg)
+		})
+	}
+}
diff --git a/test/issues/830/issue_test.go b/test/issues/830/issue_test.go
new file mode 100644
index 000000000..96db36933
--- /dev/null
+++ b/test/issues/830/issue_test.go
@@ -0,0 +1,20 @@
+package issues
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue830(t *testing.T) {
+	program, err := expr.Compile("varNotExist", expr.AllowUndefinedVariables(), expr.AsBool())
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, map[string]interface{}{})
+	require.NoError(t, err)
+
+	// The user expects output to be false (bool), but gets nil.
+	assert.Equal(t, false, output)
+}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 56759c531..36995d306 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -393,6 +393,18 @@ func ToFloat64(a any) float64 {
 	}
 }
 
+func ToBool(a any) bool {
+	if a == nil {
+		return false
+	}
+	switch x := a.(type) {
+	case bool:
+		return x
+	default:
+		panic(fmt.Sprintf("invalid operation: bool(%T)", x))
+	}
+}
+
 func IsNil(v any) bool {
 	if v == nil {
 		return true
diff --git a/vm/vm.go b/vm/vm.go
index 960009f0a..d76a1f8f9 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -470,6 +470,8 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 				vm.push(runtime.ToInt64(vm.pop()))
 			case 2:
 				vm.push(runtime.ToFloat64(vm.pop()))
+			case 3:
+				vm.push(runtime.ToBool(vm.pop()))
 			}
 
 		case OpDeref:
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 817fc6cc2..679dcf44b 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -61,18 +61,57 @@ func TestRun_ReuseVM_for_different_variables(t *testing.T) {
 }
 
 func TestRun_Cast(t *testing.T) {
-	input := `1`
+	tests := []struct {
+		input  string
+		expect reflect.Kind
+		want   any
+	}{
+		{
+			input:  `1`,
+			expect: reflect.Float64,
+			want:   float64(1),
+		},
+		{
+			input:  `1`,
+			expect: reflect.Int,
+			want:   int(1),
+		},
+		{
+			input:  `1`,
+			expect: reflect.Int64,
+			want:   int64(1),
+		},
+		{
+			input:  `true`,
+			expect: reflect.Bool,
+			want:   true,
+		},
+		{
+			input:  `false`,
+			expect: reflect.Bool,
+			want:   false,
+		},
+		{
+			input:  `nil`,
+			expect: reflect.Bool,
+			want:   false,
+		},
+	}
 
-	tree, err := parser.Parse(input)
-	require.NoError(t, err)
+	for _, tt := range tests {
+		t.Run(fmt.Sprintf("%v %v", tt.expect, tt.input), func(t *testing.T) {
+			tree, err := parser.Parse(tt.input)
+			require.NoError(t, err)
 
-	program, err := compiler.Compile(tree, &conf.Config{Expect: reflect.Float64})
-	require.NoError(t, err)
+			program, err := compiler.Compile(tree, &conf.Config{Expect: tt.expect})
+			require.NoError(t, err)
 
-	out, err := vm.Run(program, nil)
-	require.NoError(t, err)
+			out, err := vm.Run(program, nil)
+			require.NoError(t, err)
 
-	require.Equal(t, float64(1), out)
+			require.Equal(t, tt.want, out)
+		})
+	}
 }
 
 func TestRun_Helpers(t *testing.T) {
@@ -1063,6 +1102,34 @@ func TestVM_DirectBasicOpcodes(t *testing.T) {
 			consts: []any{int32(42)},
 			want:   int64(42),
 		},
+		{
+			name: "OpCast bool to bool",
+			bytecode: []vm.Opcode{
+				vm.OpTrue, // Push true
+				vm.OpCast, // Cast to bool
+			},
+			args: []int{0, 3},
+			want: true,
+		},
+		{
+			name: "OpCast nil to bool",
+			bytecode: []vm.Opcode{
+				vm.OpNil,  // Push nil
+				vm.OpCast, // Cast to bool
+			},
+			args: []int{0, 3},
+			want: false,
+		},
+		{
+			name: "OpCast int to bool",
+			bytecode: []vm.Opcode{
+				vm.OpPush, // Push int
+				vm.OpCast, // Cast to bool
+			},
+			args:    []int{0, 3},
+			consts:  []any{1},
+			wantErr: true,
+		},
 		{
 			name: "OpCast invalid type",
 			bytecode: []vm.Opcode{

From f423c10c5f7436c70edc7158a97193f87591a309 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 4 Dec 2025 17:25:17 +0200
Subject: [PATCH 456/506] fix(optimizer): wrap merged results as predicates
 (#864)

Ensure combined predicates in consecutive `filter()` calls are
wrapped in a `PredicateNode`. Previously, the optimizer created
a raw `BinaryNode` for merged filters, causing type assertion
panics. The expr parser generates `filter(array, predicate)`
calls only.

This fix ensures that the merged predicate is wrapped as an
`ast.PredicateNode`. Adds a regression test.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 optimizer/fold.go             | 10 +++++----
 optimizer/fold_test.go        |  6 ++++--
 test/issues/857/issue_test.go | 39 +++++++++++++++++++++++++++++++++++
 3 files changed, 49 insertions(+), 6 deletions(-)
 create mode 100644 test/issues/857/issue_test.go

diff --git a/optimizer/fold.go b/optimizer/fold.go
index bb40eab93..2e5498fa5 100644
--- a/optimizer/fold.go
+++ b/optimizer/fold.go
@@ -296,10 +296,12 @@ func (fold *fold) Visit(node *Node) {
 					Name: "filter",
 					Arguments: []Node{
 						base.Arguments[0],
-						&BinaryNode{
-							Operator: "&&",
-							Left:     base.Arguments[1].(*PredicateNode).Node,
-							Right:    n.Arguments[1].(*PredicateNode).Node,
+						&PredicateNode{
+							Node: &BinaryNode{
+								Operator: "&&",
+								Left:     base.Arguments[1].(*PredicateNode).Node,
+								Right:    n.Arguments[1].(*PredicateNode).Node,
+							},
 						},
 					},
 				})
diff --git a/optimizer/fold_test.go b/optimizer/fold_test.go
index d3f44fcf4..026a4f59b 100644
--- a/optimizer/fold_test.go
+++ b/optimizer/fold_test.go
@@ -70,8 +70,10 @@ func TestOptimize_constant_folding_filter_filter(t *testing.T) {
 					Value: 2,
 				},
 			},
-			&ast.BoolNode{
-				Value: true,
+			&ast.PredicateNode{
+				Node: &ast.BoolNode{
+					Value: true,
+				},
 			},
 		},
 		Throws: false,
diff --git a/test/issues/857/issue_test.go b/test/issues/857/issue_test.go
new file mode 100644
index 000000000..25a8ef109
--- /dev/null
+++ b/test/issues/857/issue_test.go
@@ -0,0 +1,39 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue857(t *testing.T) {
+	foo := map[string]any{
+		"entry": map[string]any{
+			"alpha": "x",
+			"beta":  1,
+		},
+	}
+	bar := map[string]any{
+		"entry": map[string]any{
+			"alpha": "x",
+			"beta":  1,
+		},
+	}
+
+	env := map[string]any{
+		"foo": foo,
+		"bar": bar,
+	}
+
+	code := `
+		foo
+		| keys()
+		| filter(# in bar)
+		| filter(foo[#].alpha == bar[#].alpha)
+		| filter(foo[#].beta == bar[#].beta)
+	`
+
+	_, err := expr.Compile(code, expr.Env(env))
+	require.NoError(t, err)
+}

From a2a9f37136f143c158ae9d4a2f9d90b7079f4744 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 4 Dec 2025 17:34:55 +0200
Subject: [PATCH 457/506] fix(vm): guard VM stack against underflow (#860)

Add explicit stack length checks in pop and current helpers.
Extend VM tests to assert safe underflow error reporting.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 vm/vm.go      |  6 ++++++
 vm/vm_test.go | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+)

diff --git a/vm/vm.go b/vm/vm.go
index d76a1f8f9..da9b79cac 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -607,10 +607,16 @@ func (vm *VM) push(value any) {
 }
 
 func (vm *VM) current() any {
+	if len(vm.Stack) == 0 {
+		panic("stack underflow")
+	}
 	return vm.Stack[len(vm.Stack)-1]
 }
 
 func (vm *VM) pop() any {
+	if len(vm.Stack) == 0 {
+		panic("stack underflow")
+	}
 	value := vm.Stack[len(vm.Stack)-1]
 	vm.Stack = vm.Stack[:len(vm.Stack)-1]
 	return value
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 679dcf44b..c7b07f372 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -1398,3 +1398,53 @@ func TestVM_Limits(t *testing.T) {
 		})
 	}
 }
+
+func TestVM_StackUnderflow(t *testing.T) {
+	tests := []struct {
+		name        string
+		bytecode    []vm.Opcode
+		args        []int
+		expectError string
+	}{
+		{
+			name:     "pop after push",
+			bytecode: []vm.Opcode{vm.OpInt, vm.OpPop},
+			args:     []int{42, 0},
+		},
+		{
+			name:        "underflow after valid operations",
+			bytecode:    []vm.Opcode{vm.OpInt, vm.OpInt, vm.OpPop, vm.OpPop, vm.OpPop},
+			args:        []int{1, 2, 0, 0, 0},
+			expectError: "stack underflow",
+		},
+		{
+			name:        "pop on empty stack",
+			bytecode:    []vm.Opcode{vm.OpPop},
+			args:        []int{0},
+			expectError: "stack underflow",
+		},
+		{
+			name:     "pop after push",
+			bytecode: []vm.Opcode{vm.OpInt, vm.OpPop},
+			args:     []int{123, 0},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program := &vm.Program{
+				Bytecode:  tt.bytecode,
+				Arguments: tt.args,
+				Constants: []any{},
+			}
+
+			_, err := vm.Run(program, nil)
+			if tt.expectError != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.expectError)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

From 593f93febed21dc14168c830df606dfd96aff827 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 4 Dec 2025 18:00:08 +0200
Subject: [PATCH 458/506] fix(vm): guard negative forward jump offsets (#861)

Disallow negative offsets for forward jump opcodes in the VM.
The compiler only ever emits non-negative offsets, but a crafted
Program or fuzzed bytecode could pass negative arguments for
OpJump and the conditional jump variants, causing unsafe control
flow. Now these opcodes panic with a clear error when given a
negative offset.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Signed-off-by: Anton Medvedev <anton@medv.io>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 vm/vm.go      | 18 ++++++++++++++++++
 vm/vm_test.go | 31 +++++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+)

diff --git a/vm/vm.go b/vm/vm.go
index da9b79cac..8e95d4ea7 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -176,29 +176,47 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.push(a.(string) == b.(string))
 
 		case OpJump:
+			if arg < 0 {
+				panic("negative jump offset is invalid")
+			}
 			vm.ip += arg
 
 		case OpJumpIfTrue:
+			if arg < 0 {
+				panic("negative jump offset is invalid")
+			}
 			if vm.current().(bool) {
 				vm.ip += arg
 			}
 
 		case OpJumpIfFalse:
+			if arg < 0 {
+				panic("negative jump offset is invalid")
+			}
 			if !vm.current().(bool) {
 				vm.ip += arg
 			}
 
 		case OpJumpIfNil:
+			if arg < 0 {
+				panic("negative jump offset is invalid")
+			}
 			if runtime.IsNil(vm.current()) {
 				vm.ip += arg
 			}
 
 		case OpJumpIfNotNil:
+			if arg < 0 {
+				panic("negative jump offset is invalid")
+			}
 			if !runtime.IsNil(vm.current()) {
 				vm.ip += arg
 			}
 
 		case OpJumpIfEnd:
+			if arg < 0 {
+				panic("negative jump offset is invalid")
+			}
 			scope := vm.scope()
 			if scope.Index >= scope.Len {
 				vm.ip += arg
diff --git a/vm/vm_test.go b/vm/vm_test.go
index c7b07f372..6b613d57d 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -1399,6 +1399,37 @@ func TestVM_Limits(t *testing.T) {
 	}
 }
 
+func TestVM_OpJump_NegativeOffset(t *testing.T) {
+	program := vm.NewProgram(
+		file.Source{},
+		nil,
+		nil,
+		0,
+		nil,
+		[]vm.Opcode{
+			vm.OpInt,
+			vm.OpInt,
+			vm.OpJump,
+			vm.OpInt,
+			vm.OpJump,
+		},
+		[]int{
+			1,
+			2,
+			-2, // negative offset for a forward jump opcode
+			3,
+			-2,
+		},
+		nil,
+		nil,
+		nil,
+	)
+
+	_, err := vm.Run(program, nil)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "negative jump offset is invalid")
+}
+
 func TestVM_StackUnderflow(t *testing.T) {
 	tests := []struct {
 		name        string

From 775fc3aca52094ab99d50c1d5f31fd9f4d2ee7c5 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Wed, 10 Dec 2025 15:28:47 +0200
Subject: [PATCH 459/506] feat: support byte slice in matches operator (#876)

The matches operator now supports matching against byte slices
in addition to strings. This allows expressions like
`b matches "pattern"` where `b` is a byte slice.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 checker/checker.go       |  2 +-
 checker/nature/nature.go | 15 ++++++++++-----
 vm/vm.go                 | 14 ++++++++++++--
 vm/vm_test.go            | 12 ++++++++++++
 4 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/checker/checker.go b/checker/checker.go
index 0210b4166..48fca7cf2 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -462,7 +462,7 @@ func (v *Checker) binaryNode(node *ast.BinaryNode) Nature {
 				return v.error(node, err.Error())
 			}
 		}
-		if l.IsString() && r.IsString() {
+		if (l.IsString() || l.IsByteSlice()) && r.IsString() {
 			return v.config.NtCache.FromType(boolType)
 		}
 		if l.MaybeCompatible(&v.config.NtCache, r, StringCheck) {
diff --git a/checker/nature/nature.go b/checker/nature/nature.go
index ae406acbf..c96f28c43 100644
--- a/checker/nature/nature.go
+++ b/checker/nature/nature.go
@@ -10,11 +10,12 @@ import (
 )
 
 var (
-	intType      = reflect.TypeOf(0)
-	floatType    = reflect.TypeOf(float64(0))
-	arrayType    = reflect.TypeOf([]any{})
-	timeType     = reflect.TypeOf(time.Time{})
-	durationType = reflect.TypeOf(time.Duration(0))
+	intType       = reflect.TypeOf(0)
+	floatType     = reflect.TypeOf(float64(0))
+	arrayType     = reflect.TypeOf([]any{})
+	byteSliceType = reflect.TypeOf([]byte{})
+	timeType      = reflect.TypeOf(time.Time{})
+	durationType  = reflect.TypeOf(time.Duration(0))
 
 	builtinInt = map[reflect.Type]struct{}{
 		reflect.TypeOf(int(0)):     {},
@@ -502,6 +503,10 @@ func (n *Nature) IsString() bool {
 	return n.Kind == reflect.String
 }
 
+func (n *Nature) IsByteSlice() bool {
+	return n.Type == byteSliceType
+}
+
 func (n *Nature) IsArray() bool {
 	return n.Kind == reflect.Slice || n.Kind == reflect.Array
 }
diff --git a/vm/vm.go b/vm/vm.go
index 8e95d4ea7..7a5b73286 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -299,7 +299,13 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 				vm.push(false)
 				break
 			}
-			match, err := regexp.MatchString(b.(string), a.(string))
+			var match bool
+			var err error
+			if s, ok := a.(string); ok {
+				match, err = regexp.MatchString(b.(string), s)
+			} else {
+				match, err = regexp.Match(b.(string), a.([]byte))
+			}
 			if err != nil {
 				panic(err)
 			}
@@ -312,7 +318,11 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 				break
 			}
 			r := program.Constants[arg].(*regexp.Regexp)
-			vm.push(r.MatchString(a.(string)))
+			if s, ok := a.(string); ok {
+				vm.push(r.MatchString(s))
+			} else {
+				vm.push(r.Match(a.([]byte)))
+			}
 
 		case OpContains:
 			b := vm.pop()
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 6b613d57d..6038abcae 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -368,6 +368,18 @@ func TestVM_OpcodeOperations(t *testing.T) {
 			expr: `"hello123" matches "^hello\\d+$"`,
 			want: true,
 		},
+		{
+			name: "byte slice matches regex",
+			expr: `b matches "^hello\\d+$"`,
+			env:  map[string]any{"b": []byte("hello123")},
+			want: true,
+		},
+		{
+			name: "byte slice matches dynamic regex",
+			expr: `b matches pattern`,
+			env:  map[string]any{"b": []byte("hello123"), "pattern": "^hello\\d+$"},
+			want: true,
+		},
 
 		// Data Structure Operations
 		{

From f493d7dbaef0b18fe2cf578b1771a2f68dd03c0b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 14 Dec 2025 11:45:29 +0100
Subject: [PATCH 460/506] Add test for handling missing property Fixes #854

---
 test/issues/854/issue_test.go | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 test/issues/854/issue_test.go

diff --git a/test/issues/854/issue_test.go b/test/issues/854/issue_test.go
new file mode 100644
index 000000000..d69b0ee4c
--- /dev/null
+++ b/test/issues/854/issue_test.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/types"
+)
+
+func TestIssue854(t *testing.T) {
+	envType := types.Map{
+		"user": types.Map{
+			// If we do not specify `Profile` here,
+			// this is a correct behavior to throw
+			// on a missing property.
+		},
+	}
+
+	code := `user.Profile?.Address ?? "Unknown address"`
+
+	_, err := expr.Compile(code, expr.Env(envType))
+	require.Error(t, err)
+}

From daf1790d9a0e7abe7842ff958a04d28288b08a90 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sun, 14 Dec 2025 12:50:36 +0200
Subject: [PATCH 461/506] fix: auto-deref for map/slice and conditionals (#871)

Ensure pointers are automatically derefer'd in map keys, slice
indices, and conditional expressions. Add dereferencing for map
keys to prefer exact type matches (e.g. map[*T]) before falling
back to deref'd types. Regression test added.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 checker/checker.go            |  12 ++++
 compiler/compiler.go          |  15 +++++
 test/issues/836/issue_test.go | 101 ++++++++++++++++++++++++++++++++++
 3 files changed, 128 insertions(+)
 create mode 100644 test/issues/836/issue_test.go

diff --git a/checker/checker.go b/checker/checker.go
index 48fca7cf2..0ed0d1e3b 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -549,6 +549,13 @@ func (v *Checker) memberNode(node *ast.MemberNode) Nature {
 
 	switch base.Kind {
 	case reflect.Map:
+		// If the map key is a pointer, we should not dereference the property.
+		if !prop.AssignableTo(base.Key(&v.config.NtCache)) {
+			propDeref := prop.Deref(&v.config.NtCache)
+			if propDeref.AssignableTo(base.Key(&v.config.NtCache)) {
+				prop = propDeref
+			}
+		}
 		if !prop.AssignableTo(base.Key(&v.config.NtCache)) && !prop.IsUnknown(&v.config.NtCache) {
 			return v.error(node.Property, "cannot use %s to get an element from %s", prop.String(), base.String())
 		}
@@ -562,6 +569,7 @@ func (v *Checker) memberNode(node *ast.MemberNode) Nature {
 		return base.Elem(&v.config.NtCache)
 
 	case reflect.Array, reflect.Slice:
+		prop = prop.Deref(&v.config.NtCache)
 		if !prop.IsInteger && !prop.IsUnknown(&v.config.NtCache) {
 			return v.error(node.Property, "array elements can only be selected using an integer (got %s)", prop.String())
 		}
@@ -607,6 +615,7 @@ func (v *Checker) sliceNode(node *ast.SliceNode) Nature {
 
 	if node.From != nil {
 		from := v.visit(node.From)
+		from = from.Deref(&v.config.NtCache)
 		if !from.IsInteger && !from.IsUnknown(&v.config.NtCache) {
 			return v.error(node.From, "non-integer slice index %v", from.String())
 		}
@@ -614,6 +623,7 @@ func (v *Checker) sliceNode(node *ast.SliceNode) Nature {
 
 	if node.To != nil {
 		to := v.visit(node.To)
+		to = to.Deref(&v.config.NtCache)
 		if !to.IsInteger && !to.IsUnknown(&v.config.NtCache) {
 			return v.error(node.To, "non-integer slice index %v", to.String())
 		}
@@ -942,6 +952,7 @@ func (v *Checker) checkBuiltinGet(node *ast.BuiltinNode) Nature {
 
 	base := v.visit(node.Arguments[0])
 	prop := v.visit(node.Arguments[1])
+	prop = prop.Deref(&v.config.NtCache)
 
 	if id, ok := node.Arguments[0].(*ast.IdentifierNode); ok && id.Value == "$env" {
 		if s, ok := node.Arguments[1].(*ast.StringNode); ok {
@@ -1260,6 +1271,7 @@ func (v *Checker) sequenceNode(node *ast.SequenceNode) Nature {
 
 func (v *Checker) conditionalNode(node *ast.ConditionalNode) Nature {
 	c := v.visit(node.Cond)
+	c = c.Deref(&v.config.NtCache)
 	if !c.IsBool() && !c.IsUnknown(&v.config.NtCache) {
 		return v.error(node.Cond, "non-bool expression (type %v) used as condition", c.String())
 	}
diff --git a/compiler/compiler.go b/compiler/compiler.go
index d8a532440..f657eccea 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -716,6 +716,18 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 
 	if op == OpFetch {
 		c.compile(node.Property)
+		deref := true
+		// If the map key is a pointer, we should not dereference the property.
+		if node.Node.Type() != nil && node.Node.Type().Kind() == reflect.Map {
+			keyType := node.Node.Type().Key()
+			propType := node.Property.Type()
+			if propType != nil && propType.AssignableTo(keyType) {
+				deref = false
+			}
+		}
+		if deref {
+			c.derefInNeeded(node.Property)
+		}
 		c.emit(OpFetch)
 	} else {
 		c.emitLocation(node.Location(), op, c.addConstant(
@@ -728,11 +740,13 @@ func (c *compiler) SliceNode(node *ast.SliceNode) {
 	c.compile(node.Node)
 	if node.To != nil {
 		c.compile(node.To)
+		c.derefInNeeded(node.To)
 	} else {
 		c.emit(OpLen)
 	}
 	if node.From != nil {
 		c.compile(node.From)
+		c.derefInNeeded(node.From)
 	} else {
 		c.emitPush(0)
 	}
@@ -1213,6 +1227,7 @@ func (c *compiler) lookupVariable(name string) (int, bool) {
 
 func (c *compiler) ConditionalNode(node *ast.ConditionalNode) {
 	c.compile(node.Cond)
+	c.derefInNeeded(node.Cond)
 	otherwise := c.emit(OpJumpIfFalse, placeholder)
 
 	c.emit(OpPop)
diff --git a/test/issues/836/issue_test.go b/test/issues/836/issue_test.go
new file mode 100644
index 000000000..e4ef6b341
--- /dev/null
+++ b/test/issues/836/issue_test.go
@@ -0,0 +1,101 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+type InputStruct struct {
+	Enabled *bool `json:"enabled"`
+}
+
+func TestIssue836(t *testing.T) {
+	str := "foo"
+	ptrStr := &str
+	b := true
+	ptrBool := &b
+	i := 1
+	ptrInt := &i
+
+	env := map[string]interface{}{
+		"ptrStr":  ptrStr,
+		"ptrBool": ptrBool,
+		"ptrInt":  ptrInt,
+		"arr":     []int{1, 2, 3},
+		"mapPtr":  map[*int]int{ptrInt: 42},
+	}
+
+	t.Run("map access with pointer key", func(t *testing.T) {
+		program, err := expr.Compile(`{"foo": "bar"}[ptrStr]`, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, "bar", output)
+	})
+
+	t.Run("conditional with pointer condition", func(t *testing.T) {
+		program, err := expr.Compile(`ptrBool ? 1 : 0`, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, 1, output)
+	})
+
+	t.Run("get() with pointer key", func(t *testing.T) {
+		program, err := expr.Compile(`get({"foo": "bar"}, ptrStr)`, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, "bar", output)
+	})
+
+	t.Run("struct field pointer check in ternary", func(t *testing.T) {
+		var v InputStruct
+		// v.Enabled is nil
+
+		env := map[string]any{
+			"v": v,
+		}
+
+		code := `v.Enabled == nil ? 'default' : ( v.Enabled ? 'enabled' : 'disabled' )`
+
+		program, err := expr.Compile(code, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, "default", output)
+	})
+
+	t.Run("struct field pointer check in ternary (enabled)", func(t *testing.T) {
+		b := true
+		v := InputStruct{Enabled: &b}
+
+		env := map[string]any{
+			"v": v,
+		}
+
+		code := `v.Enabled == nil ? 'default' : ( v.Enabled ? 'enabled' : 'disabled' )`
+
+		program, err := expr.Compile(code, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, "enabled", output)
+	})
+
+	t.Run("slice with pointer indices", func(t *testing.T) {
+		program, err := expr.Compile(`arr[ptrInt:ptrInt]`, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, []int{}, output)
+	})
+}

From d652fbe8df6201046ce3ff3cec12c44c61216fbb Mon Sep 17 00:00:00 2001
From: David Orozco <34346877+davixcky@users.noreply.github.com>
Date: Sun, 14 Dec 2025 06:05:22 -0500
Subject: [PATCH 462/506] Throw an error if predicate not present in parser
 (#842)

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 parser/parser.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/parser/parser.go b/parser/parser.go
index 6034403bf..623ab9a00 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -550,7 +550,10 @@ func (p *Parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 	}
 	isOverridden = isOverridden && checkOverrides
 
-	if b, ok := predicates[token.Value]; ok && !isOverridden {
+	if _, ok := predicates[token.Value]; ok && p.config != nil && p.config.Disabled[token.Value] && !isOverridden {
+		// Disabled predicate without replacement - fail immediately
+		p.error("unknown name %s", token.Value)
+	} else if b, ok := predicates[token.Value]; ok && !isOverridden {
 		p.expect(Bracket, "(")
 
 		// In case of the pipe operator, the first argument is the left-hand side
@@ -594,6 +597,9 @@ func (p *Parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 		if node == nil {
 			return nil
 		}
+	} else if _, ok := builtin.Index[token.Value]; ok && p.config != nil && p.config.Disabled[token.Value] && !isOverridden {
+		// Disabled builtin without replacement - fail immediately
+		p.error("unknown name %s", token.Value)
 	} else if _, ok := builtin.Index[token.Value]; ok && (p.config == nil || !p.config.Disabled[token.Value]) && !isOverridden {
 		node = p.createNode(&BuiltinNode{
 			Name:      token.Value,

From 55e913be02efc62fa751f769f4a3dd2e110b493d Mon Sep 17 00:00:00 2001
From: Diego Augusto Molina <diegoaugustomolina@gmail.com>
Date: Sun, 14 Dec 2025 08:17:34 -0300
Subject: [PATCH 463/506] VM performance improvements in function calls (#832)

* optimize vm allocation of function arguments

* make estimation faster by using a table

* add benchmarks

* avoid all allocations if no arguments are needed

* simplify code and gain 2% speed

* add safety limit on preallocation

---------

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 vm/vm.go            | 134 +++++++++++++++++++++++++++++++++++---------
 vm/vm_bench_test.go |  82 +++++++++++++++++++++++++++
 2 files changed, 189 insertions(+), 27 deletions(-)
 create mode 100644 vm/vm_bench_test.go

diff --git a/vm/vm.go b/vm/vm.go
index 7a5b73286..aebb524cb 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -17,6 +17,8 @@ import (
 	"github.com/expr-lang/expr/vm/runtime"
 )
 
+const maxFnArgsBuf = 256
+
 func Run(program *Program, env any) (any, error) {
 	if program == nil {
 		return nil, fmt.Errorf("program is nil")
@@ -83,6 +85,8 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 	vm.memory = 0
 	vm.ip = 0
 
+	var fnArgsBuf []any
+
 	for vm.ip < len(program.Bytecode) {
 		if debug && vm.debug {
 			<-vm.step
@@ -399,27 +403,27 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.push(out)
 
 		case OpCall1:
-			a := vm.pop()
-			out, err := program.functions[arg](a)
+			var args []any
+			args, fnArgsBuf = vm.getArgsForFunc(fnArgsBuf, program, 1)
+			out, err := program.functions[arg](args...)
 			if err != nil {
 				panic(err)
 			}
 			vm.push(out)
 
 		case OpCall2:
-			b := vm.pop()
-			a := vm.pop()
-			out, err := program.functions[arg](a, b)
+			var args []any
+			args, fnArgsBuf = vm.getArgsForFunc(fnArgsBuf, program, 2)
+			out, err := program.functions[arg](args...)
 			if err != nil {
 				panic(err)
 			}
 			vm.push(out)
 
 		case OpCall3:
-			c := vm.pop()
-			b := vm.pop()
-			a := vm.pop()
-			out, err := program.functions[arg](a, b, c)
+			var args []any
+			args, fnArgsBuf = vm.getArgsForFunc(fnArgsBuf, program, 3)
+			out, err := program.functions[arg](args...)
 			if err != nil {
 				panic(err)
 			}
@@ -427,12 +431,9 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 
 		case OpCallN:
 			fn := vm.pop().(Function)
-			size := arg
-			in := make([]any, size)
-			for i := int(size) - 1; i >= 0; i-- {
-				in[i] = vm.pop()
-			}
-			out, err := fn(in...)
+			var args []any
+			args, fnArgsBuf = vm.getArgsForFunc(fnArgsBuf, program, arg)
+			out, err := fn(args...)
 			if err != nil {
 				panic(err)
 			}
@@ -440,21 +441,15 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 
 		case OpCallFast:
 			fn := vm.pop().(func(...any) any)
-			size := arg
-			in := make([]any, size)
-			for i := int(size) - 1; i >= 0; i-- {
-				in[i] = vm.pop()
-			}
-			vm.push(fn(in...))
+			var args []any
+			args, fnArgsBuf = vm.getArgsForFunc(fnArgsBuf, program, arg)
+			vm.push(fn(args...))
 
 		case OpCallSafe:
 			fn := vm.pop().(SafeFunction)
-			size := arg
-			in := make([]any, size)
-			for i := int(size) - 1; i >= 0; i-- {
-				in[i] = vm.pop()
-			}
-			out, mem, err := fn(in...)
+			var args []any
+			args, fnArgsBuf = vm.getArgsForFunc(fnArgsBuf, program, arg)
+			out, mem, err := fn(args...)
 			if err != nil {
 				panic(err)
 			}
@@ -661,6 +656,64 @@ func (vm *VM) scope() *Scope {
 	return vm.Scopes[len(vm.Scopes)-1]
 }
 
+// getArgsForFunc lazily initializes the buffer the first time it is called for
+// a given program (thus, it also needs "program" to run). It will
+// take "needed" elements from the buffer and populate them with vm.pop() in
+// reverse order. Because the estimation can fall short, this function can
+// occasionally make a new allocation.
+func (vm *VM) getArgsForFunc(argsBuf []any, program *Program, needed int) (args []any, argsBufOut []any) {
+	if needed == 0 || program == nil {
+		return nil, argsBuf
+	}
+
+	// Step 1: fix estimations and preallocate
+	if argsBuf == nil {
+		estimatedFnArgsCount := estimateFnArgsCount(program)
+		if estimatedFnArgsCount > maxFnArgsBuf {
+			// put a practical limit to avoid excessive preallocation
+			estimatedFnArgsCount = maxFnArgsBuf
+		}
+		if estimatedFnArgsCount < needed {
+			// in the case that the first call is for example OpCallN with a large
+			// number of arguments, then make sure we will be able to serve them at
+			// least.
+			estimatedFnArgsCount = needed
+		}
+
+		// in the case that we are preparing the arguments for the first
+		// function call of the program, then argsBuf will be nil, so we
+		// initialize it. We delay this initial allocation here because a
+		// program could have many function calls but exit earlier than the
+		// first call, so in that case we avoid allocating unnecessarily
+		argsBuf = make([]any, estimatedFnArgsCount)
+	}
+
+	// Step 2: get the final slice that will be returned
+	var buf []any
+	if len(argsBuf) >= needed {
+		// in this case, we are successfully using the single preallocation. We
+		// use the full slice expression [low : high : max] because in that way
+		// a function that receives this slice as variadic arguments will not be
+		// able to make modifications to contiguous elements with append(). If
+		// they call append on their variadic arguments they will make a new
+		// allocation.
+		buf = (argsBuf)[:needed:needed]
+		argsBuf = (argsBuf)[needed:] // advance the buffer
+	} else {
+		// if we have been making calls to something like OpCallN with many more
+		// arguments than what we estimated, then we will need to allocate
+		// separately
+		buf = make([]any, needed)
+	}
+
+	// Step 3: populate the final slice bulk copying from the stack. This is the
+	// exact order and copy() is a highly optimized operation
+	copy(buf, vm.Stack[len(vm.Stack)-needed:])
+	vm.Stack = vm.Stack[:len(vm.Stack)-needed]
+
+	return buf, argsBuf
+}
+
 func (vm *VM) Step() {
 	vm.step <- struct{}{}
 }
@@ -675,3 +728,30 @@ func clearSlice[S ~[]E, E any](s S) {
 		s[i] = zero // clear mem, optimized by the compiler, in Go 1.21 the "clear" builtin can be used
 	}
 }
+
+// estimateFnArgsCount inspects a *Program and estimates how many function
+// arguments will be required to run it.
+func estimateFnArgsCount(program *Program) int {
+	// Implementation note: a program will not necessarily go through all
+	// operations, but this is just an estimation
+	var count int
+	for _, op := range program.Bytecode {
+		if int(op) < len(opArgLenEstimation) {
+			count += opArgLenEstimation[op]
+		}
+	}
+	return count
+}
+
+var opArgLenEstimation = [...]int{
+	OpCall1: 1,
+	OpCall2: 2,
+	OpCall3: 3,
+	// we don't know exactly but we know at least 4, so be conservative as this
+	// is only an optimization and we also want to avoid excessive preallocation
+	OpCallN: 4,
+	// here we don't know either, but we can guess it could be common to receive
+	// up to 3 arguments in a function
+	OpCallFast: 3,
+	OpCallSafe: 3,
+}
diff --git a/vm/vm_bench_test.go b/vm/vm_bench_test.go
new file mode 100644
index 000000000..bafbfb030
--- /dev/null
+++ b/vm/vm_bench_test.go
@@ -0,0 +1,82 @@
+package vm_test
+
+import (
+	"runtime"
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/checker"
+	"github.com/expr-lang/expr/compiler"
+	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/vm"
+)
+
+func BenchmarkVM(b *testing.B) {
+	cases := []struct {
+		name, input string
+	}{
+		{"function calls", `
+func(
+	func(
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+	),
+	func(
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+	),
+	func(
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+		func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)),
+	)
+)
+		`},
+	}
+
+	a := new(recursive)
+	for i, b := 0, a; i < 40*4; i++ {
+		b.Inner = new(recursive)
+		b = b.Inner
+	}
+
+	f := func(params ...any) (any, error) { return nil, nil }
+	env := map[string]any{
+		"a":    a,
+		"b":    true,
+		"func": f,
+	}
+	config := conf.New(env)
+	expr.Function("func", f, f)(config)
+	config.Check()
+
+	for _, c := range cases {
+		tree, err := checker.ParseCheck(c.input, config)
+		if err != nil {
+			b.Fatal(c.input, "parse and check", err)
+		}
+		prog, err := compiler.Compile(tree, config)
+		if err != nil {
+			b.Fatal(c.input, "compile", err)
+		}
+		//b.Logf("disassembled:\n%s", prog.Disassemble())
+		//b.FailNow()
+		runtime.GC()
+
+		var vm vm.VM
+		b.Run("name="+c.name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				_, err = vm.Run(prog, env)
+			}
+		})
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+type recursive struct {
+	Inner *recursive `expr:"a"`
+}

From 1973835b26fd4efc0990df48fb283d5a78808d9a Mon Sep 17 00:00:00 2001
From: lvliangxiong <lvliangxiong@foxmail.com>
Date: Sun, 14 Dec 2025 19:20:15 +0800
Subject: [PATCH 464/506] feat: add disable short-circuiting option to compiler
 (#847)

* feat: add disable short-circuiting option to compiler

* fix: nil config && unit test

---------

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 compiler/compiler.go | 16 ++++++++++++++
 conf/config.go       |  2 ++
 expr.go              |  7 ++++++
 expr_test.go         | 52 ++++++++++++++++++++++++++++++++++++++++++++
 vm/opcodes.go        |  2 ++
 vm/program.go        |  6 +++++
 vm/vm.go             | 10 +++++++++
 7 files changed, 95 insertions(+)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index f657eccea..1e78782f1 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -448,6 +448,14 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 		c.emit(OpNot)
 
 	case "or", "||":
+		if c.config != nil && c.config.DisableSC {
+			c.compile(node.Left)
+			c.derefInNeeded(node.Left)
+			c.compile(node.Right)
+			c.derefInNeeded(node.Right)
+			c.emit(OpOr)
+			break
+		}
 		c.compile(node.Left)
 		c.derefInNeeded(node.Left)
 		end := c.emit(OpJumpIfTrue, placeholder)
@@ -457,6 +465,14 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 		c.patchJump(end)
 
 	case "and", "&&":
+		if c.config != nil && c.config.DisableSC {
+			c.compile(node.Left)
+			c.derefInNeeded(node.Left)
+			c.compile(node.Right)
+			c.derefInNeeded(node.Right)
+			c.emit(OpAnd)
+			break
+		}
 		c.compile(node.Left)
 		c.derefInNeeded(node.Left)
 		end := c.emit(OpJumpIfFalse, placeholder)
diff --git a/conf/config.go b/conf/config.go
index 8799d3d04..b721d1ba7 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -35,6 +35,7 @@ type Config struct {
 	Builtins  FunctionsTable
 	Disabled  map[string]bool // disabled builtins
 	NtCache   nature.Cache
+	DisableSC bool
 }
 
 // CreateNew creates new config with default values.
@@ -46,6 +47,7 @@ func CreateNew() *Config {
 		Functions: make(map[string]*builtin.Function),
 		Builtins:  make(map[string]*builtin.Function),
 		Disabled:  make(map[string]bool),
+		DisableSC: false,
 	}
 	for _, f := range builtin.Builtins {
 		c.Builtins[f.Name] = f
diff --git a/expr.go b/expr.go
index e8f4eb64b..31651c0d5 100644
--- a/expr.go
+++ b/expr.go
@@ -126,6 +126,13 @@ func Optimize(b bool) Option {
 	}
 }
 
+// DisableShortCircuit turns short circuit off.
+func DisableShortCircuit() Option {
+	return func(c *conf.Config) {
+		c.DisableSC = true
+	}
+}
+
 // Patch adds visitor to list of visitors what will be applied before compiling AST to bytecode.
 func Patch(visitor ast.Visitor) Option {
 	return func(c *conf.Config) {
diff --git a/expr_test.go b/expr_test.go
index 01ccdeeb9..a8be9ef3c 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2883,3 +2883,55 @@ func TestIssue807(t *testing.T) {
 		t.Fatalf("expected 'in' operator to return false for unexported field")
 	}
 }
+
+func ExampleDisableShortCircuit() {
+	OR := func(a, b bool) bool {
+		return a || b
+	}
+
+	env := map[string]any{
+		"foo": func() bool {
+			fmt.Println("foo")
+			return false
+		},
+		"bar": func() bool {
+			fmt.Println("bar")
+			return false
+		},
+		"OR": OR,
+	}
+
+	program, _ := expr.Compile("true || foo() or bar()", expr.Env(env), expr.Operator("or", "OR"), expr.Operator("||", "OR"))
+	got, _ := expr.Run(program, env)
+	fmt.Println(got)
+
+	// Output:
+	// foo
+	// bar
+	// true
+}
+
+func TestDisableShortCircuit(t *testing.T) {
+	count := 0
+	exprStr := "foo() or bar()"
+	env := map[string]any{
+		"foo": func() bool {
+			count++
+			return true
+		},
+		"bar": func() bool {
+			count++
+			return true
+		},
+	}
+
+	program, _ := expr.Compile(exprStr, expr.DisableShortCircuit())
+	got, _ := expr.Run(program, env)
+	assert.Equal(t, 2, count)
+	assert.True(t, got.(bool))
+
+	program, _ = expr.Compile(exprStr)
+	got, _ = expr.Run(program, env)
+	assert.Equal(t, 3, count)
+	assert.True(t, got.(bool))
+}
diff --git a/vm/opcodes.go b/vm/opcodes.go
index 84d751d6b..5fca0fa29 100644
--- a/vm/opcodes.go
+++ b/vm/opcodes.go
@@ -84,5 +84,7 @@ const (
 	OpProfileStart
 	OpProfileEnd
 	OpBegin
+	OpAnd
+	OpOr
 	OpEnd // This opcode must be at the end of this list.
 )
diff --git a/vm/program.go b/vm/program.go
index d146cc139..7eb96bd3d 100644
--- a/vm/program.go
+++ b/vm/program.go
@@ -375,6 +375,12 @@ func (program *Program) DisassembleWriter(w io.Writer) {
 		case OpBegin:
 			code("OpBegin")
 
+		case OpAnd:
+			code("OpAnd")
+
+		case OpOr:
+			code("OpOr")
+
 		case OpEnd:
 			code("OpEnd")
 
diff --git a/vm/vm.go b/vm/vm.go
index aebb524cb..3c7a2b3f7 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -601,6 +601,16 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 				Len:   array.Len(),
 			})
 
+		case OpAnd:
+			a := vm.pop()
+			b := vm.pop()
+			vm.push(a.(bool) && b.(bool))
+
+		case OpOr:
+			a := vm.pop()
+			b := vm.pop()
+			vm.push(a.(bool) || b.(bool))
+
 		case OpEnd:
 			vm.Scopes = vm.Scopes[:len(vm.Scopes)-1]
 

From e5ee6c245bbf664c6a48d2eb1241320336aa98ed Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 14 Dec 2025 12:24:16 +0100
Subject: [PATCH 465/506] Rename `DisableSC` to `ShortCircuit` for better
 clarity and consistency

---
 compiler/compiler.go |  4 ++--
 conf/config.go       | 44 ++++++++++++++++++++++----------------------
 expr.go              |  2 +-
 3 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index 1e78782f1..5de89f54c 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -448,7 +448,7 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 		c.emit(OpNot)
 
 	case "or", "||":
-		if c.config != nil && c.config.DisableSC {
+		if c.config != nil && !c.config.ShortCircuit {
 			c.compile(node.Left)
 			c.derefInNeeded(node.Left)
 			c.compile(node.Right)
@@ -465,7 +465,7 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 		c.patchJump(end)
 
 	case "and", "&&":
-		if c.config != nil && c.config.DisableSC {
+		if c.config != nil && !c.config.ShortCircuit {
 			c.compile(node.Left)
 			c.derefInNeeded(node.Left)
 			c.compile(node.Right)
diff --git a/conf/config.go b/conf/config.go
index b721d1ba7..685241b0f 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -21,33 +21,33 @@ var (
 type FunctionsTable map[string]*builtin.Function
 
 type Config struct {
-	EnvObject any
-	Env       nature.Nature
-	Expect    reflect.Kind
-	ExpectAny bool
-	Optimize  bool
-	Strict    bool
-	Profile   bool
-	MaxNodes  uint
-	ConstFns  map[string]reflect.Value
-	Visitors  []ast.Visitor
-	Functions FunctionsTable
-	Builtins  FunctionsTable
-	Disabled  map[string]bool // disabled builtins
-	NtCache   nature.Cache
-	DisableSC bool
+	EnvObject    any
+	Env          nature.Nature
+	Expect       reflect.Kind
+	ExpectAny    bool
+	Optimize     bool
+	Strict       bool
+	ShortCircuit bool
+	Profile      bool
+	MaxNodes     uint
+	ConstFns     map[string]reflect.Value
+	Visitors     []ast.Visitor
+	Functions    FunctionsTable
+	Builtins     FunctionsTable
+	Disabled     map[string]bool // disabled builtins
+	NtCache      nature.Cache
 }
 
 // CreateNew creates new config with default values.
 func CreateNew() *Config {
 	c := &Config{
-		Optimize:  true,
-		MaxNodes:  DefaultMaxNodes,
-		ConstFns:  make(map[string]reflect.Value),
-		Functions: make(map[string]*builtin.Function),
-		Builtins:  make(map[string]*builtin.Function),
-		Disabled:  make(map[string]bool),
-		DisableSC: false,
+		Optimize:     true,
+		ShortCircuit: true,
+		MaxNodes:     DefaultMaxNodes,
+		ConstFns:     make(map[string]reflect.Value),
+		Functions:    make(map[string]*builtin.Function),
+		Builtins:     make(map[string]*builtin.Function),
+		Disabled:     make(map[string]bool),
 	}
 	for _, f := range builtin.Builtins {
 		c.Builtins[f.Name] = f
diff --git a/expr.go b/expr.go
index 31651c0d5..ff4ae5942 100644
--- a/expr.go
+++ b/expr.go
@@ -129,7 +129,7 @@ func Optimize(b bool) Option {
 // DisableShortCircuit turns short circuit off.
 func DisableShortCircuit() Option {
 	return func(c *conf.Config) {
-		c.DisableSC = true
+		c.ShortCircuit = false
 	}
 }
 

From cf53913bd4fb966a7bd4250def200bfe8b085c64 Mon Sep 17 00:00:00 2001
From: montag451 <montag451@laposte.net>
Date: Sun, 14 Dec 2025 12:32:01 +0100
Subject: [PATCH 466/506] Improve the performance of runtime.Fetch for
 structures (#833)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Improve the performance of runtime.Fetch for structures

The improvement comes from the use of a cache to speed up the
retrieval of struct fields. This commit also adds a new benchmark to
measure the performance gain.

goos: linux
goarch: amd64
pkg: github.com/expr-lang/expr
cpu: Intel(R) Core(TM) i7-8650U CPU @ 1.90GHz
                   │ /tmp/old.txt │            /tmp/new.txt             │
                   │    sec/op    │   sec/op     vs base                │
_envStruct_noEnv-8    503.3n ± 4%   228.8n ± 3%  -54.53% (p=0.000 n=10)

                   │ /tmp/old.txt │            /tmp/new.txt            │
                   │     B/op     │    B/op     vs base                │
_envStruct_noEnv-8     48.00 ± 0%   32.00 ± 0%  -33.33% (p=0.000 n=10)

                   │ /tmp/old.txt │            /tmp/new.txt            │
                   │  allocs/op   │ allocs/op   vs base                │
_envStruct_noEnv-8     3.000 ± 0%   1.000 ± 0%  -66.67% (p=0.000 n=10)

* Store only the index in the cache instead of the whole StructField

---------

Co-authored-by: Anton Medvedev <anton@medv.io>
---
 bench_test.go         | 24 ++++++++++++++++++++++++
 vm/runtime/runtime.go | 28 ++++++++++++++++++++++++----
 2 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/bench_test.go b/bench_test.go
index c9f2b7182..d70a09356 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -266,6 +266,30 @@ func Benchmark_envStruct(b *testing.B) {
 	require.True(b, out.(bool))
 }
 
+func Benchmark_envStruct_noEnv(b *testing.B) {
+	type Price struct {
+		Value int
+	}
+	type Env struct {
+		Price Price
+	}
+
+	program, err := expr.Compile(`Price.Value > 0`)
+	require.NoError(b, err)
+
+	env := Env{Price: Price{Value: 1}}
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, err = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.NoError(b, err)
+	require.True(b, out.(bool))
+}
+
 func Benchmark_envMap(b *testing.B) {
 	type Price struct {
 		Value int
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 36995d306..d24c6af03 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -6,10 +6,18 @@ import (
 	"fmt"
 	"math"
 	"reflect"
+	"sync"
 
 	"github.com/expr-lang/expr/internal/deref"
 )
 
+var fieldCache sync.Map
+
+type fieldCacheKey struct {
+	t reflect.Type
+	f string
+}
+
 func Fetch(from, i any) any {
 	v := reflect.ValueOf(from)
 	if v.Kind() == reflect.Invalid {
@@ -63,8 +71,16 @@ func Fetch(from, i any) any {
 
 	case reflect.Struct:
 		fieldName := i.(string)
-		value := v.FieldByNameFunc(func(name string) bool {
-			field, _ := v.Type().FieldByName(name)
+		t := v.Type()
+		key := fieldCacheKey{
+			t: t,
+			f: fieldName,
+		}
+		if cv, ok := fieldCache.Load(key); ok {
+			return v.FieldByIndex(cv.([]int)).Interface()
+		}
+		field, ok := t.FieldByNameFunc(func(name string) bool {
+			field, _ := t.FieldByName(name)
 			switch field.Tag.Get("expr") {
 			case "-":
 				return false
@@ -74,8 +90,12 @@ func Fetch(from, i any) any {
 				return name == fieldName
 			}
 		})
-		if value.IsValid() {
-			return value.Interface()
+		if ok {
+			value := v.FieldByIndex(field.Index)
+			if value.IsValid() {
+				fieldCache.Store(key, field.Index)
+				return value.Interface()
+			}
 		}
 	}
 	panic(fmt.Sprintf("cannot fetch %v from %T", i, from))

From eb73788eb823513b73e3f62dada27de4f4c73cd2 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 14 Dec 2025 20:37:39 +0100
Subject: [PATCH 467/506] Add `else if` support (#879)

* Add `else if` support

* Add test for nested `else if` handling

* Add `Ternary` field to `ConditionalNode` and update tests and printing logic
---
 ast/node.go           |  9 +++--
 ast/print.go          | 10 +++++
 ast/print_test.go     |  3 +-
 expr_test.go          |  4 ++
 parser/parser.go      | 19 ++++++---
 parser/parser_test.go | 92 ++++++++++++++++++++++++++++++++-----------
 6 files changed, 102 insertions(+), 35 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index f156f69be..f17fd7e52 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -200,12 +200,13 @@ type PointerNode struct {
 	Name string // Name of the pointer. Like "index" in "#index".
 }
 
-// ConditionalNode represents a ternary operator.
+// ConditionalNode represents a ternary operator or if/else operator.
 type ConditionalNode struct {
 	base
-	Cond Node // Condition of the ternary operator. Like "foo" in "foo ? bar : baz".
-	Exp1 Node // Expression 1 of the ternary operator. Like "bar" in "foo ? bar : baz".
-	Exp2 Node // Expression 2 of the ternary operator. Like "baz" in "foo ? bar : baz".
+	Ternary bool // Is it ternary or if/else operator?
+	Cond    Node // Condition
+	Exp1    Node // Expression 1
+	Exp2    Node // Expression 2
 }
 
 // VariableDeclaratorNode represents a variable declaration.
diff --git a/ast/print.go b/ast/print.go
index e4e45f0fa..527a5b99b 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -207,6 +207,16 @@ func (n *SequenceNode) String() string {
 }
 
 func (n *ConditionalNode) String() string {
+	if !n.Ternary {
+		cond := n.Cond.String()
+		exp1 := n.Exp1.String()
+		if c2, ok := n.Exp2.(*ConditionalNode); ok && !c2.Ternary {
+			return fmt.Sprintf("if %s { %s } else %s", cond, exp1, c2.String())
+		}
+		exp2 := n.Exp2.String()
+		return fmt.Sprintf("if %s { %s } else { %s }", cond, exp1, exp2)
+	}
+
 	var cond, exp1, exp2 string
 	if _, ok := n.Cond.(*ConditionalNode); ok {
 		cond = fmt.Sprintf("(%s)", n.Cond.String())
diff --git a/ast/print_test.go b/ast/print_test.go
index d0859606f..bcdad782c 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -83,7 +83,8 @@ func TestPrint(t *testing.T) {
 		{`(2 ** 2) ** 3`, `(2 ** 2) ** 3`},
 		{`(3 + 5) / (5 % 3)`, `(3 + 5) / (5 % 3)`},
 		{`(-(1+1)) == 2`, `-(1 + 1) == 2`},
-		{`if true { 1 } else { 2 }`, `true ? 1 : 2`},
+		{`if true { 1 } else { 2 }`, `if true { 1 } else { 2 }`},
+		{`if true { 1 } else if false { 2 } else { 3 }`, `if true { 1 } else if false { 2 } else { 3 }`},
 	}
 
 	for _, tt := range tests {
diff --git a/expr_test.go b/expr_test.go
index a8be9ef3c..c923d5a46 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1390,6 +1390,10 @@ func TestExpr(t *testing.T) {
 			`if "a" < "b" {let x = "a"; x} else {"abc"}`,
 			"a",
 		},
+		{
+			`if 1 == 2 { "no" } else if 1 == 1 { "yes" } else { "maybe" }`,
+			"yes",
+		},
 		{
 			`1; 2; 3`,
 			3,
diff --git a/parser/parser.go b/parser/parser.go
index 623ab9a00..90daae43b 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -334,9 +334,15 @@ func (p *Parser) parseConditionalIf() Node {
 	expr1 := p.parseSequenceExpression()
 	p.expect(Bracket, "}")
 	p.expect(Operator, "else")
-	p.expect(Bracket, "{")
-	expr2 := p.parseSequenceExpression()
-	p.expect(Bracket, "}")
+
+	var expr2 Node
+	if p.current.Is(Operator, "if") {
+		expr2 = p.parseConditionalIf()
+	} else {
+		p.expect(Bracket, "{")
+		expr2 = p.parseSequenceExpression()
+		p.expect(Bracket, "}")
+	}
 
 	return &ConditionalNode{
 		Cond: nodeCondition,
@@ -362,9 +368,10 @@ func (p *Parser) parseConditional(node Node) Node {
 		}
 
 		node = p.createNode(&ConditionalNode{
-			Cond: node,
-			Exp1: expr1,
-			Exp2: expr2,
+			Ternary: true,
+			Cond:    node,
+			Exp1:    expr1,
+			Exp2:    expr2,
 		}, p.current.Location)
 		if node == nil {
 			return nil
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 16dac6b79..85c465750 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -197,15 +197,19 @@ world`},
 		},
 		{
 			"true ? true : false",
-			&ConditionalNode{Cond: &BoolNode{Value: true},
-				Exp1: &BoolNode{Value: true},
-				Exp2: &BoolNode{}},
+			&ConditionalNode{
+				Ternary: true,
+				Cond:    &BoolNode{Value: true},
+				Exp1:    &BoolNode{Value: true},
+				Exp2:    &BoolNode{}},
 		},
 		{
 			"a?[b]:c",
-			&ConditionalNode{Cond: &IdentifierNode{Value: "a"},
-				Exp1: &ArrayNode{Nodes: []Node{&IdentifierNode{Value: "b"}}},
-				Exp2: &IdentifierNode{Value: "c"}},
+			&ConditionalNode{
+				Ternary: true,
+				Cond:    &IdentifierNode{Value: "a"},
+				Exp1:    &ArrayNode{Nodes: []Node{&IdentifierNode{Value: "b"}}},
+				Exp2:    &IdentifierNode{Value: "c"}},
 		},
 		{
 			"a.b().c().d[33]",
@@ -396,6 +400,7 @@ world`},
 		{
 			"2==2 ? false : 3 not in [1, 2, 5]",
 			&ConditionalNode{
+				Ternary: true,
 				Cond: &BinaryNode{
 					Operator: "==",
 					Left:     &IntegerNode{Value: 2},
@@ -659,6 +664,29 @@ world`},
 				Exp1: &BoolNode{Value: true},
 				Exp2: &IdentifierNode{Value: "x"}},
 		},
+		{
+			"if a { 1 } else if b { 2 } else { 3 }",
+			&ConditionalNode{
+				Cond: &IdentifierNode{Value: "a"},
+				Exp1: &IntegerNode{Value: 1},
+				Exp2: &ConditionalNode{
+					Cond: &IdentifierNode{Value: "b"},
+					Exp1: &IntegerNode{Value: 2},
+					Exp2: &IntegerNode{Value: 3}}},
+		},
+		{
+			"if a { 1 } else if b { 2 } else if c { 3 } else { 4 }",
+			&ConditionalNode{
+				Cond: &IdentifierNode{Value: "a"},
+				Exp1: &IntegerNode{Value: 1},
+				Exp2: &ConditionalNode{
+					Cond: &IdentifierNode{Value: "b"},
+					Exp1: &IntegerNode{Value: 2},
+					Exp2: &ConditionalNode{
+						Cond: &IdentifierNode{Value: "c"},
+						Exp1: &IntegerNode{Value: 3},
+						Exp2: &IntegerNode{Value: 4}}}},
+		},
 		{
 			"1; 2; 3",
 			&SequenceNode{
@@ -687,9 +715,10 @@ world`},
 			&SequenceNode{
 				Nodes: []Node{
 					&ConditionalNode{
-						Cond: &BoolNode{Value: true},
-						Exp1: &IntegerNode{Value: 1},
-						Exp2: &IntegerNode{Value: 2}},
+						Ternary: true,
+						Cond:    &BoolNode{Value: true},
+						Exp1:    &IntegerNode{Value: 1},
+						Exp2:    &IntegerNode{Value: 2}},
 					&IntegerNode{Value: 3},
 					&IntegerNode{Value: 4},
 				},
@@ -698,8 +727,9 @@ world`},
 		{
 			"true ? 1 : ( 2; 3; 4 )",
 			&ConditionalNode{
-				Cond: &BoolNode{Value: true},
-				Exp1: &IntegerNode{Value: 1},
+				Ternary: true,
+				Cond:    &BoolNode{Value: true},
+				Exp1:    &IntegerNode{Value: 1},
 				Exp2: &SequenceNode{
 					Nodes: []Node{
 						&IntegerNode{Value: 2},
@@ -714,9 +744,10 @@ world`},
 			&SequenceNode{
 				Nodes: []Node{
 					&ConditionalNode{
-						Cond: &BoolNode{Value: true},
-						Exp1: &BoolNode{Value: true},
-						Exp2: &IntegerNode{Value: 1}},
+						Ternary: true,
+						Cond:    &BoolNode{Value: true},
+						Exp1:    &BoolNode{Value: true},
+						Exp2:    &IntegerNode{Value: 1}},
 					&IntegerNode{Value: 2},
 					&IntegerNode{Value: 3},
 				},
@@ -727,9 +758,10 @@ world`},
 			&VariableDeclaratorNode{
 				Name: "x",
 				Value: &ConditionalNode{
-					Cond: &BoolNode{Value: true},
-					Exp1: &IntegerNode{Value: 1},
-					Exp2: &IntegerNode{Value: 2}},
+					Ternary: true,
+					Cond:    &BoolNode{Value: true},
+					Exp1:    &IntegerNode{Value: 1},
+					Exp2:    &IntegerNode{Value: 2}},
 				Expr: &IdentifierNode{Value: "x"}},
 		},
 		{
@@ -737,8 +769,9 @@ world`},
 			&VariableDeclaratorNode{
 				Name: "x",
 				Value: &ConditionalNode{
-					Cond: &BoolNode{Value: true},
-					Exp1: &IntegerNode{Value: 1},
+					Ternary: true,
+					Cond:    &BoolNode{Value: true},
+					Exp1:    &IntegerNode{Value: 1},
 					Exp2: &SequenceNode{
 						Nodes: []Node{
 							&IntegerNode{Value: 2},
@@ -762,7 +795,8 @@ world`},
 					Nodes: []Node{
 						&IntegerNode{Value: 4},
 						&IntegerNode{Value: 5},
-						&IntegerNode{Value: 6}}}},
+						&IntegerNode{Value: 6}}},
+			},
 		},
 		{
 			`all(ls, if true { 1 } else { 2 })`,
@@ -774,7 +808,8 @@ world`},
 						Node: &ConditionalNode{
 							Cond: &BoolNode{Value: true},
 							Exp1: &IntegerNode{Value: 1},
-							Exp2: &IntegerNode{Value: 2}}}}},
+							Exp2: &IntegerNode{Value: 2},
+						}}}},
 		},
 		{
 			`let x = if true { 1 } else { 2 }; x`,
@@ -783,7 +818,8 @@ world`},
 				Value: &ConditionalNode{
 					Cond: &BoolNode{Value: true},
 					Exp1: &IntegerNode{Value: 1},
-					Exp2: &IntegerNode{Value: 2}},
+					Exp2: &IntegerNode{Value: 2},
+				},
 				Expr: &IdentifierNode{Value: "x"}},
 		},
 		{
@@ -794,7 +830,8 @@ world`},
 					&ConditionalNode{
 						Cond: &BoolNode{Value: true},
 						Exp1: &IntegerNode{Value: 1},
-						Exp2: &IntegerNode{Value: 2}}}},
+						Exp2: &IntegerNode{Value: 2},
+					}}},
 		},
 		{
 			`[if true { 1 } else { 2 }]`,
@@ -803,7 +840,8 @@ world`},
 					&ConditionalNode{
 						Cond: &BoolNode{Value: true},
 						Exp1: &IntegerNode{Value: 1},
-						Exp2: &IntegerNode{Value: 2}}}},
+						Exp2: &IntegerNode{Value: 2},
+					}}},
 		},
 		{
 			`map(ls, { 1; 2; 3 })`,
@@ -1019,6 +1057,12 @@ func TestParse_error(t *testing.T) {
 			`unexpected token Operator("if") (1:5)
  | 1 + if true { 2 } else { 3 }
  | ....^`,
+		},
+		{
+			`if a { 1 } else b`,
+			`unexpected token Identifier("b") (1:17)
+ | if a { 1 } else b
+ | ................^`,
 		},
 		{
 			`list | all(#,,)`,

From 738da0b342aa8a57e4a88ddd8c74c810bc8886c6 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 14 Dec 2025 20:47:23 +0100
Subject: [PATCH 468/506] Remove `ExampleDisableShortCircuit` test function

---
 expr_test.go | 27 ---------------------------
 1 file changed, 27 deletions(-)

diff --git a/expr_test.go b/expr_test.go
index c923d5a46..413313db0 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2888,33 +2888,6 @@ func TestIssue807(t *testing.T) {
 	}
 }
 
-func ExampleDisableShortCircuit() {
-	OR := func(a, b bool) bool {
-		return a || b
-	}
-
-	env := map[string]any{
-		"foo": func() bool {
-			fmt.Println("foo")
-			return false
-		},
-		"bar": func() bool {
-			fmt.Println("bar")
-			return false
-		},
-		"OR": OR,
-	}
-
-	program, _ := expr.Compile("true || foo() or bar()", expr.Env(env), expr.Operator("or", "OR"), expr.Operator("||", "OR"))
-	got, _ := expr.Run(program, env)
-	fmt.Println(got)
-
-	// Output:
-	// foo
-	// bar
-	// true
-}
-
 func TestDisableShortCircuit(t *testing.T) {
 	count := 0
 	exprStr := "foo() or bar()"

From 087698e2554c3928e19f6fbb7f55f6aba7c2186f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 14 Dec 2025 21:02:20 +0100
Subject: [PATCH 469/506] Add error handling for invalid `if` condition and
 test for crash with null byte

---
 expr_test.go     | 6 ++++++
 parser/parser.go | 3 +++
 2 files changed, 9 insertions(+)

diff --git a/expr_test.go b/expr_test.go
index 413313db0..14715889e 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -2683,6 +2683,12 @@ func TestExpr_crash(t *testing.T) {
 	require.Error(t, err)
 }
 
+func TestExpr_crash_with_zero(t *testing.T) {
+	code := "if\x00"
+	_, err := expr.Compile(code)
+	require.Error(t, err)
+}
+
 func TestExpr_nil_op_str(t *testing.T) {
 	// Let's test operators, which do `.(string)` in VM, also check for nil.
 
diff --git a/parser/parser.go b/parser/parser.go
index 90daae43b..5f3ffb362 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -329,6 +329,9 @@ func (p *Parser) parseVariableDeclaration() Node {
 
 func (p *Parser) parseConditionalIf() Node {
 	p.next()
+	if p.err != nil {
+		return nil
+	}
 	nodeCondition := p.parseExpression(0)
 	p.expect(Bracket, "{")
 	expr1 := p.parseSequenceExpression()

From 4d38449b9f7f0238c6ac534e414cd4b4f25704e8 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sun, 14 Dec 2025 22:54:40 +0200
Subject: [PATCH 470/506] chore: test and build on Go 1.25 (#880)

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 .github/workflows/build.yml | 2 +-
 .github/workflows/test.yml  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 854ca5348..ebebf13e8 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.22', '1.24' ]
+        go-versions: [ '1.18', '1.22', '1.24', '1.25' ]
         go-arch: [ '386' ]
     steps:
       - uses: actions/checkout@v3
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 5d0b0744e..ae2280d3a 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22', '1.23', '1.24' ]
+        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22', '1.23', '1.24', '1.25' ]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Go ${{ matrix.go-version }}

From 6ed72a21491b5d18b419d2115c404f400431248b Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 14 Dec 2025 21:56:41 +0100
Subject: [PATCH 471/506] Add `DisableIfOperator` option (#881)

---
 conf/config.go        |  5 +++++
 expr.go               |  8 ++++++++
 expr_test.go          | 11 +++++++++++
 parser/lexer/lexer.go |  3 +++
 parser/lexer/state.go |  8 +++++++-
 parser/parser.go      | 10 +++++++++-
 6 files changed, 43 insertions(+), 2 deletions(-)

diff --git a/conf/config.go b/conf/config.go
index 685241b0f..f7c95d203 100644
--- a/conf/config.go
+++ b/conf/config.go
@@ -36,6 +36,11 @@ type Config struct {
 	Builtins     FunctionsTable
 	Disabled     map[string]bool // disabled builtins
 	NtCache      nature.Cache
+	// DisableIfOperator disables the built-in `if ... { } else { }` operator syntax
+	// so that users can use a custom function named `if(...)` without conflicts.
+	// When enabled, the lexer treats `if`/`else` as identifiers and the parser
+	// will not parse `if` statements.
+	DisableIfOperator bool
 }
 
 // CreateNew creates new config with default values.
diff --git a/expr.go b/expr.go
index ff4ae5942..280605e67 100644
--- a/expr.go
+++ b/expr.go
@@ -109,6 +109,14 @@ func AsFloat64() Option {
 	}
 }
 
+// DisableIfOperator disables the `if ... else ...` operator syntax so a custom
+// function named `if(...)` can be used without conflicts.
+func DisableIfOperator() Option {
+	return func(c *conf.Config) {
+		c.DisableIfOperator = true
+	}
+}
+
 // WarnOnAny tells the compiler to warn if expression return any type.
 func WarnOnAny() Option {
 	return func(c *conf.Config) {
diff --git a/expr_test.go b/expr_test.go
index 14715889e..ba1f001ec 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -70,6 +70,17 @@ func ExampleCompile() {
 	// Output: true
 }
 
+func TestDisableIfOperator_AllowsIfFunction(t *testing.T) {
+	env := map[string]any{
+		"if": func(x int) int { return x + 1 },
+	}
+	program, err := expr.Compile("if(41)", expr.Env(env), expr.DisableIfOperator())
+	require.NoError(t, err)
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, 42, out)
+}
+
 func ExampleEnv() {
 	type Segment struct {
 		Origin string
diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go
index fe41e824a..5daf95037 100644
--- a/parser/lexer/lexer.go
+++ b/parser/lexer/lexer.go
@@ -46,6 +46,9 @@ type Lexer struct {
 		byte, rune int
 	}
 	eof bool
+	// When true, keywords `if`/`else` are not treated as operators and
+	// will be emitted as identifiers instead (for compatibility with custom if()).
+	DisableIfOperator bool
 }
 
 func (l *Lexer) Reset(source file.Source) {
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index e5ad45bcd..91857eade 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -129,8 +129,14 @@ loop:
 			switch l.word() {
 			case "not":
 				return not
-			case "in", "or", "and", "matches", "contains", "startsWith", "endsWith", "let", "if", "else":
+			case "in", "or", "and", "matches", "contains", "startsWith", "endsWith", "let":
 				l.emit(Operator)
+			case "if", "else":
+				if !l.DisableIfOperator {
+					l.emit(Operator)
+				} else {
+					l.emit(Identifier)
+				}
 			default:
 				l.emit(Identifier)
 			}
diff --git a/parser/parser.go b/parser/parser.go
index 5f3ffb362..9ccf47830 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -62,6 +62,14 @@ func (p *Parser) Parse(input string, config *conf.Config) (*Tree, error) {
 		p.lexer = New()
 	}
 	p.config = config
+	// propagate config flags to lexer
+	if p.lexer != nil {
+		if config != nil {
+			p.lexer.DisableIfOperator = config.DisableIfOperator
+		} else {
+			p.lexer.DisableIfOperator = false
+		}
+	}
 	source := file.NewSource(input)
 	p.lexer.Reset(source)
 	p.next()
@@ -218,7 +226,7 @@ func (p *Parser) parseExpression(precedence int) Node {
 		return p.parseVariableDeclaration()
 	}
 
-	if precedence == 0 && p.current.Is(Operator, "if") {
+	if precedence == 0 && (p.config == nil || !p.config.DisableIfOperator) && p.current.Is(Operator, "if") {
 		return p.parseConditionalIf()
 	}
 

From 713a26a272ae656fa73685994b875bda8322a5af Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 14 Dec 2025 22:10:48 +0100
Subject: [PATCH 472/506] Add support for Unicode escape sequences in the
 `\u{XXXXXX}` format (#882)

---
 parser/lexer/lexer.go      | 31 +++++++++++++++++++++++++++++++
 parser/lexer/lexer_test.go |  8 ++++++++
 parser/lexer/utils.go      | 35 +++++++++++++++++++++++++++++++++++
 3 files changed, 74 insertions(+)

diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go
index 5daf95037..0e75942d0 100644
--- a/parser/lexer/lexer.go
+++ b/parser/lexer/lexer.go
@@ -211,6 +211,37 @@ func (l *Lexer) scanEscape(quote rune) rune {
 	case 'x':
 		ch = l.scanDigits(l.next(), 16, 2)
 	case 'u':
+		// Support variable-length form: \u{XXXXXX}
+		if l.peek() == '{' {
+			// consume '{'
+			l.next()
+			// read 1-6 hex digits
+			digits := 0
+			for {
+				p := l.peek()
+				if p == '}' {
+					break
+				}
+				if digitVal(p) >= 16 {
+					l.error("invalid char escape")
+					return eof
+				}
+				if digits >= 6 {
+					l.error("invalid char escape")
+					return eof
+				}
+				l.next()
+				digits++
+			}
+			if l.peek() != '}' || digits == 0 {
+				l.error("invalid char escape")
+				return eof
+			}
+			// consume '}' and continue
+			l.next()
+			ch = l.next()
+			break
+		}
 		ch = l.scanDigits(l.next(), 16, 4)
 	case 'U':
 		ch = l.scanDigits(l.next(), 16, 8)
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index baa5aabb1..f46870e9b 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -291,6 +291,14 @@ func TestLex(t *testing.T) {
 				{Kind: EOF},
 			},
 		},
+		{
+			"\"\\u{61}\\u{1F600}\" '\\u{61}\\u{1F600}'",
+			[]Token{
+				{Kind: String, Value: "a😀"},
+				{Kind: String, Value: "a😀"},
+				{Kind: EOF},
+			},
+		},
 	}
 
 	for _, test := range tests {
diff --git a/parser/lexer/utils.go b/parser/lexer/utils.go
index fdb8beaa1..6aa088ae3 100644
--- a/parser/lexer/utils.go
+++ b/parser/lexer/utils.go
@@ -111,6 +111,41 @@ func unescapeChar(s string) (value rune, multibyte bool, tail string, err error)
 
 	// 4. Unicode escape sequences, reproduced from `strconv/quote.go`
 	case 'x', 'X', 'u', 'U':
+		// Support Go/Rust-style variable-length form: \u{XXXXXX}
+		if c == 'u' && len(s) > 0 && s[0] == '{' {
+			// consume '{'
+			s = s[1:]
+			var v rune
+			digits := 0
+			for len(s) > 0 && s[0] != '}' {
+				x, ok := unhex(s[0])
+				if !ok {
+					err = fmt.Errorf("unable to unescape string")
+					return
+				}
+				if digits >= 6 { // at most 6 hex digits
+					err = fmt.Errorf("unable to unescape string")
+					return
+				}
+				v = v<<4 | x
+				s = s[1:]
+				digits++
+			}
+			// require closing '}' and at least 1 digit
+			if len(s) == 0 || s[0] != '}' || digits == 0 {
+				err = fmt.Errorf("unable to unescape string")
+				return
+			}
+			// consume '}'
+			s = s[1:]
+			if v > utf8.MaxRune {
+				err = fmt.Errorf("unable to unescape string")
+				return
+			}
+			value = v
+			multibyte = true
+			break
+		}
 		n := 0
 		switch c {
 		case 'x', 'X':

From d4722867d2df8480c650afa169b350a03d0b668a Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Mon, 15 Dec 2025 00:08:20 +0100
Subject: [PATCH 473/506] Improve gen.go

---
 test/gen/gen.go | 38 +++++++++++++++++++++++++++++++++-----
 1 file changed, 33 insertions(+), 5 deletions(-)

diff --git a/test/gen/gen.go b/test/gen/gen.go
index b43b677c0..d0d60c5b1 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -28,6 +28,7 @@ var (
 		">=",
 		"<=",
 		"..",
+		"??",
 		"+",
 		"-",
 		"*",
@@ -218,7 +219,12 @@ func memberNode(depth int) string {
 }
 
 func unaryNode(depth int) string {
-	return random([]string{"-", "!", "not"})
+	op := random([]string{"-", "!", "not"})
+	// Use a simple formatting to ensure valid unary expression syntax
+	if op == "not" {
+		return fmt.Sprintf("not %v", node(depth-1))
+	}
+	return fmt.Sprintf("%s%v", op, node(depth-1))
 }
 
 func binaryNode(depth int) string {
@@ -364,9 +370,31 @@ func sequenceNode(depth int) string {
 }
 
 func variableNode(depth int) string {
-	e := node(depth - 1)
-	if !strings.Contains(e, "foobar") {
-		return "~!@"
+	// Generate 1-3 variable declarations with diverse names and then make sure
+	// at least one of them is used in the final expression.
+	namesPool := []string{"x", "y", "z", "foo", "bar", "foobar", "tmp"}
+	nDecls := oneOf(list[int]{
+		{1, 60},
+		{2, 30},
+		{3, 10},
+	})
+
+	var decls []string
+	var chosen []string
+	for i := 0; i < nDecls; i++ {
+		name := random(namesPool)
+		chosen = append(chosen, name)
+		decls = append(decls, fmt.Sprintf("let %s = %v", name, node(depth-1)))
 	}
-	return fmt.Sprintf("let foobar = %v; %v", node(depth-1), e)
+
+	// Build a usage expression that references declared vars to guarantee coverage.
+	use := oneOf(list[string]{
+		{chosen[0], 50},
+		{fmt.Sprintf("%s + %v", chosen[0], node(depth-1)), 30},
+		{fmt.Sprintf("%v + %s", node(depth-1), chosen[0]), 30},
+		{fmt.Sprintf("if %v { %s } else { %v }", node(depth-1), chosen[0], node(depth-1)), 20},
+		{fmt.Sprintf("%s ? %v : %v", chosen[0], node(depth-1), node(depth-1)), 10},
+	})
+
+	return fmt.Sprintf("%s; %s", strings.Join(decls, "; "), use)
 }

From c020e9595927657cc9a0c5dca091b47058473ff5 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 25 Dec 2025 18:30:38 +0200
Subject: [PATCH 474/506] fix(checker): correct variadic method arg type (#889)

When checking arguments for variadic methods, the index passed to
InElem used "fnNumIn-1", but fnNumIn had already been decremented
to exclude the receiver. This caused InElem to access the receiver
type (index 0) instead of the variadic parameter type, causing a
type error ("cannot use string as argument").

Add "fnInOffset" to the index calculation to correctly reference the
variadic parameter. Regression tests included.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 checker/checker.go            |  2 +-
 checker/checker_test.go       |  1 +
 test/issues/888/issue_test.go | 44 +++++++++++++++++++++++++++++++++++
 test/mock/mock.go             |  4 ++++
 4 files changed, 50 insertions(+), 1 deletion(-)
 create mode 100644 test/issues/888/issue_test.go

diff --git a/checker/checker.go b/checker/checker.go
index 0ed0d1e3b..2a9e234a1 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -1112,7 +1112,7 @@ func (v *Checker) checkArguments(
 		if isVariadic && i >= fnNumIn-1 {
 			// For variadic arguments fn(xs ...int), go replaces type of xs (int) with ([]int).
 			// As we compare arguments one by one, we need underling type.
-			in = fn.InElem(&v.config.NtCache, fnNumIn-1)
+			in = fn.InElem(&v.config.NtCache, fnNumIn-1+fnInOffset)
 		} else {
 			in = fn.In(&v.config.NtCache, i+fnInOffset)
 		}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 541f63117..07047ff5d 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -135,6 +135,7 @@ func TestCheck(t *testing.T) {
 		{"let foo = 1; foo == 1"},
 		{"(Embed).EmbedPointerEmbedInt > 0"},
 		{"(true ? [1] : [[1]])[0][0] == 1"},
+		{"Foo.VariadicMethod('a', 'b', 'c')"},
 	}
 
 	c := new(checker.Checker)
diff --git a/test/issues/888/issue_test.go b/test/issues/888/issue_test.go
new file mode 100644
index 000000000..175e34f1e
--- /dev/null
+++ b/test/issues/888/issue_test.go
@@ -0,0 +1,44 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+type Container struct {
+	ID   string
+	List []string
+}
+
+func (c Container) IncludesAny(s ...string) bool {
+	for _, l := range c.List {
+		// Note: original issue used "slices.Contains" but
+		// it is not available in the minimum Go version of expr (1.18).
+		for _, v := range s {
+			if v == l {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func TestIssue888(t *testing.T) {
+	env := map[string]any{
+		"Container": Container{
+			ID:   "id",
+			List: []string{"foo", "bar", "baz"},
+		},
+	}
+
+	code := `Container.IncludesAny("nope", "nope again", "bar")`
+
+	program, err := expr.Compile(code, expr.Env(env))
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, true, output)
+}
diff --git a/test/mock/mock.go b/test/mock/mock.go
index fc91652fb..aad12051b 100644
--- a/test/mock/mock.go
+++ b/test/mock/mock.go
@@ -186,6 +186,10 @@ func (Foo) String() string {
 	return "Foo.String"
 }
 
+func (Foo) VariadicMethod(_ ...string) bool {
+	return true
+}
+
 type Bar struct {
 	Baz string
 }

From 476d403fd806ddecc470abfa14406d53e51145df Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 27 Dec 2025 13:34:51 +0100
Subject: [PATCH 475/506] Add variation for conditional `if-else` formatting in
 `gen.go`

---
 test/gen/gen.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/gen/gen.go b/test/gen/gen.go
index d0d60c5b1..d2807d97a 100644
--- a/test/gen/gen.go
+++ b/test/gen/gen.go
@@ -350,6 +350,7 @@ func sliceNode(depth int) string {
 func conditionalNode(depth int) string {
 	return oneOf(list[string]{
 		{fmt.Sprintf("if %v { %v } else { %v }", node(depth-1), node(depth-1), node(depth-1)), 100},
+		{fmt.Sprintf("if %v { %v } else %v", node(depth-1), node(depth-1), node(depth-1)), 100},
 		{fmt.Sprintf("%v ? %v : %v", node(depth-1), node(depth-1), node(depth-1)), 100},
 		{fmt.Sprintf("%v ?: %v", node(depth-1), node(depth-1)), 20},
 	})

From d082f3d52ab181b514eea75a882f83b3fc761102 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 27 Dec 2025 15:02:34 +0100
Subject: [PATCH 476/506] Update README.md

Updated repository link to reflect new location.

Signed-off-by: Anton Medvedev <anton@medv.io>
---
 README.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/README.md b/README.md
index a7ded479c..8a12f6af9 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,5 @@
 <h1><a href="https://expr-lang.org"><img src="https://expr-lang.org/img/logo.png" alt="Zx logo" height="48"align="right"></a> Expr</h1>
 
-> [!IMPORTANT]
-> The repository [github.com/antonmedv/expr](https://github.com/antonmedv/expr) moved to [github.com/**expr-lang**/expr](https://github.com/expr-lang/expr).
-
 [![test](https://github.com/expr-lang/expr/actions/workflows/test.yml/badge.svg)](https://github.com/expr-lang/expr/actions/workflows/test.yml) 
 [![Go Report Card](https://goreportcard.com/badge/github.com/expr-lang/expr)](https://goreportcard.com/report/github.com/expr-lang/expr) 
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/expr.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:expr)

From 3111bbe8c72d3d64333ae2807c28b78fbab0d24d Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 27 Dec 2025 15:22:17 +0100
Subject: [PATCH 477/506] Expand `testdata/generated.txt` with exhaustive
 boolean and conditional expression variations for comprehensive test coverage

---
 testdata/generated.txt | 21333 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 21333 insertions(+)

diff --git a/testdata/generated.txt b/testdata/generated.txt
index 557fa9511..017cf5803 100644
--- a/testdata/generated.txt
+++ b/testdata/generated.txt
@@ -1,5 +1,287 @@
+!!!ok
+!!$env?.ok
+!!false
+!!not false
+!!ok
+!!ok ?? 1
+!!true
+!$env && false
+!$env and !true
+!$env and false
+!$env or true
+!$env || true
+!$env.ok
+!$env.ok ?? foo
+!$env?.ok
+!all($env, false)
+!all($env, true)
+!all(array, false)
+!all(array, true)
+!all(list, true)
+!any($env, false)
+!any($env, ok)
+!any($env, true)
+!any(array, false)
+!any(array, ok ?? #)
+!any(array, ok)
+!any(array, true)
+!any(list, ok)
+!false != $env
+!false != 0 ?? false
+!false != false
+!false != nil
+!false != ok
+!false != true
+!false && $env
+!false && false
+!false && ok
+!false && true
+!false == $env
+!false == false
+!false == nil
+!false == ok
+!false == ok == ok
+!false == true
+!false ? 0 : f64
+!false ? 0 : nil
+!false ? 1 : ok
+!false ? 1.0 : 0
+!false ? add : array
+!false ? add : foo
+!false ? array : $env
+!false ? array : nil
+!false ? f64 : true
+!false ? false : foo
+!false ? false : greet
+!false ? false : true
+!false ? foo : $env
+!false ? foo : foo
+!false ? foo : greet
+!false ? str : $env
+!false ?: $env
+!false ?: 1.0
+!false ?: bitnand(i, 1)
+!false ?: foo
+!false ?: list
+!false ?: nil
+!false ?: true
+!false ?? $env
+!false ?? $env?.String
+!false ?? 0
+!false ?? 1
+!false ?? 1.0
+!false ?? add
+!false ?? array
+!false ?? f64
+!false ?? false
+!false ?? foo
+!false ?? greet
+!false ?? i
+!false ?? list
+!false ?? nil
+!false ?? ok
+!false ?? sortBy($env, $env)
+!false ?? str
+!false ?? true
+!false and $env
+!false and 1.0 != f64
+!false and 1.0 ?? list
+!false and false
+!false and false == $env
+!false and ok
+!false and true
+!false or $env
+!false or 1.0 != f64
+!false or false
+!false or ok
+!false or true
+!false || $env
+!false || $env?.[$env]
+!false || $env?.[greet()]
+!false || $env?.[greet]
+!false || false
+!false || ok
+!false || true
+!false; foo
+!nil ?? false
+!nil ?? false || true
+!nil ?? ok
+!nil ?? true
+!none($env, false)
+!none($env, ok)
+!none($env, true)
+!none(array, ok)
+!none(array, true)
+!none(list, ok)
+!not !false
+!not !ok
+!not $env.ok
+!not false
+!not not false
+!not ok
+!not true
+!ok
+!ok != $env
+!ok != false
+!ok != nil
+!ok != ok
+!ok != true
+!ok && $env
+!ok && $env?.Bar
+!ok && $env?.[i]
+!ok && false
+!ok && list not in $env
+!ok && ok
+!ok && true
+!ok == $env
+!ok == false
+!ok == nil
+!ok == nil == nil
+!ok == ok
+!ok == true
+!ok ? $env : $env
+!ok ? $env : 0
+!ok ? $env : str
+!ok ? 1 : str
+!ok ? 1.0 : 1.0
+!ok ? 1.0 : str
+!ok ? add : ok
+!ok ? array : false
+!ok ? foo : 1
+!ok ? foo : foo
+!ok ? list : foo
+!ok ? nil : 1.0
+!ok ? nil : true
+!ok ?: $env
+!ok ?: $env?.f64
+!ok ?: i
+!ok ?: ok
+!ok ?: str
+!ok ?? $env
+!ok ?? $env?.add
+!ok ?? 0
+!ok ?? 1
+!ok ?? 1.0
+!ok ?? add
+!ok ?? array
+!ok ?? f64
+!ok ?? false
+!ok ?? foo
+!ok ?? foo?.String
+!ok ?? greet
+!ok ?? i
+!ok ?? list
+!ok ?? nil
+!ok ?? ok
+!ok ?? str
+!ok ?? true
+!ok and $env
+!ok and $env ?? ok
+!ok and false
+!ok and ok
+!ok and true
+!ok not in $env?.[Bar]
+!ok or $env
+!ok or $env?.Bar
+!ok or false
+!ok or ok
+!ok or true
+!ok || $env
+!ok || $env ?? f64
+!ok || false
+!ok || foo ?? i
+!ok || greet == $env
+!ok || ok
+!ok || true
+!one($env, false)
+!one($env, ok)
+!one($env, true)
+!one(array, false)
+!one(array, true)
+!one(list, ok)
+!reduce($env, false, foo)
+!reduce([true], $env != nil)
+!reduce(array, false, list)
+!reduce(array, ok)
+!reduce(array, ok, $env)
+!reduce(array, true)
+!reduce(list, false)
+!reduce(list, ok)
+!reduce(list, true)
+!true != $env
+!true != $env?.[foobar]
+!true != false
+!true != nil
+!true != ok
+!true != true
+!true && $env
+!true && $env?.[Bar]
+!true && 1 ?? foo
+!true && 1.0 != nil
+!true && false
+!true && not $env
+!true && ok
+!true && true
+!true == $env
+!true == $env?.String
+!true == false
+!true == nil
+!true == ok
+!true == true
+!true ? 1 : false
+!true ? 1.0 : 1.0
+!true ? 1.0 : str
+!true ? add : 1.0
+!true ? array : 0
+!true ? f64 : f64
+!true ? nil : false
+!true ? str : 1.0
+!true ? str : add
+!true ? str : nil
+!true ? str : str
+!true ?: array
+!true ?: false
+!true ?: foo
+!true ?: i
+!true ?: nil
+!true ?: ok
+!true ?: str
+!true ?? $env
+!true ?? $env?.array
+!true ?? 0
+!true ?? 1
+!true ?? 1.0
+!true ?? add
+!true ?? array
+!true ?? date($env, foo)
+!true ?? f64
+!true ?? false
+!true ?? foo
+!true ?? greet
+!true ?? i
+!true ?? list
+!true ?? nil
+!true ?? ok
+!true ?? str
+!true ?? true
+!true and $env
+!true and false
+!true and nil ?? $env
+!true and ok
+!true and true
+!true not in [$env]
+!true or $env
+!true or $env == foo
+!true or false
+!true or ok
+!true or true
+!true || $env
+!true || false
+!true || ok
+!true || true
 $env != $env == ok
 $env != $env ?: greet
+$env != $env or f64 ?? foo
 $env != $env.add
 $env != $env.array
 $env != $env.f64
@@ -13,7 +295,9 @@ $env != $env?.Bar
 $env != $env?.Bar?.add
 $env != $env?.Bar?.list
 $env != $env?.String
+$env != $env?.String?.String
 $env != $env?.[Bar]
+$env != $env?.[Bar]?.Bar
 $env != $env?.[Bar]?.sum(foobar matches Bar)
 $env != $env?.[String]
 $env != $env?.[String]?.[array]
@@ -26,6 +310,7 @@ $env != $env?.f64
 $env != $env?.foo
 $env != $env?.foobar
 $env != $env?.foobar?.greet
+$env != $env?.foobar?.ok
 $env != $env?.greet
 $env != $env?.i
 $env != $env?.list
@@ -34,17 +319,41 @@ $env != $env?.str
 $env != 0 != ok
 $env != 0 && 1.0 != nil
 $env != 0 ?: $env?.[f64]
+$env != 0 ?? add
+$env != 0 ?? ok
+$env != 1 != $env?.[str]
 $env != 1 / f64
+$env != 1.0 != $env.ok
+$env != 1.0 * $env.i
+$env != 1.0 * f64
 $env != 1.0 * i
+$env != 1.0 ** i && false
 $env != 1.0 + f64
 $env != 1.0 - f64
 $env != 1.0 / i
+$env != 1.0 == $env?.false
+$env != 1.0 ?? foo
+$env != 1.0 ?? ok
+$env != 1.0 or ok
 $env != 1.0 || abs($env)
 $env != add ? add : ok ?: array
+$env != add || $env + $env
+$env != add || 1.0 not in $env
+$env != array or ok
 $env != array?.[i]
+$env != f64 && ok
+$env != f64 + i
 $env != f64 / f64
+$env != f64 ? $env?.ok : foo
+$env != f64 and ok
 $env != false != ok
+$env != foo != greet ?? 1
+$env != foo && add ?? foo
 $env != foo == $env?.[String]
+$env != foo == ok
+$env != foo ?? add
+$env != foo ?? ok
+$env != foo ?? str
 $env != foo and ok
 $env != foo.Bar
 $env != foo.String
@@ -52,23 +361,45 @@ $env != foo.String()
 $env != foo?.Bar
 $env != foo?.String
 $env != foo?.String()
+$env != greet ?? add
+$env != greet ?? f64
+$env != i ?? f64 ?? foo
+$env != i ?? i
+$env != i ?? list
 $env != i not in toPairs($env)
+$env != i or one($env, true)
+$env != i || ok
+$env != list ?? flatten($env)
+$env != list ?? list
+$env != list and ok
 $env != list or ok
 $env != list?.[i]
 $env != nil != ok
+$env != nil ?? array
+$env != nil ?? i
+$env != nil ?? ok
+$env != ok ?? add
 $env != str && ok
 $env != str + str
+$env != str in $env?.[String]
 $env != str || 1 in $env
+$env != true ?? list
+$env != true ?? ok
 $env != true and nil != nil
+$env && false && 1.0 == 1.0
 $env && false and $env matches $env
 $env && false or ok
 $env * 1 || true == true
 $env - 1.0 not startsWith $env && false
 $env .. $env in $env || true
 $env == $env && nil in list
+$env == $env && ok
 $env == $env ?: i != $env
+$env == $env ?? $env?.[ok]
+$env == $env ?? f64
 $env == $env and ok
 $env == $env or $env?.Bar()
+$env == $env or ok
 $env == $env.add
 $env == $env.array
 $env == $env.f64
@@ -79,76 +410,301 @@ $env == $env.list
 $env == $env.list?.[i]
 $env == $env.ok
 $env == $env.str
+$env == $env?.$env?.[list]
 $env == $env?.Bar
 $env == $env?.String
 $env == $env?.String?.foo
 $env == $env?.String?.foobar?.[array]
+$env == $env?.String?.list
 $env == $env?.[Bar]
+$env == $env?.[Bar]?.[i]
 $env == $env?.[Bar]?.[ok]?.[array]
 $env == $env?.[Bar]?.foo
 $env == $env?.[Bar]?.i
 $env == $env?.[String]
+$env == $env?.[foobar?.Bar]
+$env == $env?.[foobar]
 $env == $env?.[str]
 $env == $env?.add
 $env == $env?.array
 $env == $env?.f64
 $env == $env?.f64 / i
 $env == $env?.foo
+$env == $env?.foo.Bar
 $env == $env?.foobar
 $env == $env?.greet
 $env == $env?.i
 $env == $env?.list
 $env == $env?.ok
 $env == $env?.str
+$env == 0 ?? list
+$env == 0 ?? ok == ok
 $env == 0 ^ f64
 $env == 0 and take($env, 0)
+$env == 1 && ok
+$env == 1 * f64
+$env == 1 .. i
 $env == 1 ?: array
 $env == 1.0 && $env != greet
 $env == 1.0 && map($env, false)?.[i]
 $env == 1.0 ** 1 ?: 1
+$env == 1.0 ** f64
+$env == 1.0 - f64
+$env == 1.0 / $env?.i
+$env == 1.0 == $env?.Bar
 $env == 1.0 == none(array, true)
 $env == 1.0 ?: $env?.greet
+$env == 1.0 ?? i
+$env == 1.0 ?? ok
 $env == 1.0 ^ $env?.f64
 $env == 1.0 ^ f64
 $env == 1.0 and add != add
+$env == 1.0 or foo ?? str
+$env == add ?? array
 $env == add and $env[foo:]
+$env == add or nil != foo
+$env == array ?? -1.0
+$env == array ?? add
 $env == array and ok
 $env == array?.[i]
 $env == f64 * f64
+$env == f64 - f64
+$env == f64 - i
+$env == f64 == ok
+$env == false == ok
 $env == false not in $env?.[Bar]
 $env == false not in $env?.[String]
+$env == foo != !ok
 $env == foo && ok
+$env == foo == $env ?? 1.0
+$env == foo ?? add
+$env == foo ?? list
+$env == foo ?? ok
+$env == foo || ok
 $env == foo.Bar
 $env == foo.String
 $env == foo.String()
 $env == foo?.Bar
 $env == foo?.String
 $env == foo?.String()
+$env == greet ?? $env?.[str]
 $env == i ** f64
 $env == i || ok
 $env == list && $env not in list
 $env == list && findLast($env, .array)
+$env == list or ok
 $env == list?.[i]
 $env == list[i:]
+$env == nil != ok
 $env == nil && 1.0 > i
+$env == nil ?? type(foo)
+$env == nil or all($env, false)
+$env == ok ?? ok
 $env == ok and $env in foo
+$env == ok and not $env?.String
 $env == str && ok or $env
+$env == str ?? 1 and ok
+$env == str ?? add
+$env == str ?? lastIndexOf($env, str)
 $env == str || ok
+$env == true && f64 ?? 1
+$env == true ?? !true
+$env == true ?? list
+$env == true || ok
 $env >= 1.0 == $env or true
+$env ?? $env ?? timezone($env)
+$env ?? $env | map($env)
+$env ?? $env | map(i)
+$env ?? $env | map(str)
+$env ?? $env | reduce(true, true)
+$env ?? $env.add
+$env ?? $env.array
+$env ?? $env.f64
+$env ?? $env.foo
+$env ?? $env.foo?.String
+$env ?? $env.greet
+$env ?? $env.i
+$env ?? $env.list
+$env ?? $env.ok
+$env ?? $env.str
+$env ?? $env?.$env?.[add]
+$env ?? $env?.$env?.array
+$env ?? $env?.Bar
+$env ?? $env?.Bar()
+$env ?? $env?.Bar()?.add
+$env ?? $env?.Bar(String(foobar) | float(String))
+$env ?? $env?.Bar?.add
+$env ?? $env?.Bar?.f64
+$env ?? $env?.String
+$env ?? $env?.String()
+$env ?? $env?.String(String ?? not foobar)
+$env ?? $env?.String.f64
+$env ?? $env?.String.greet
+$env ?? $env?.String?.i(foo)
+$env ?? $env?.[Bar]
+$env ?? $env?.[String]
+$env ?? $env?.[add]
+$env ?? $env?.[array]
+$env ?? $env?.[f64]
+$env ?? $env?.[foo?.add]
+$env ?? $env?.[foo]
+$env ?? $env?.[foobar | sortBy(1)]
+$env ?? $env?.[foobar.foobar]
+$env ?? $env?.[foobar?.[f64]]
+$env ?? $env?.[foobar]
+$env ?? $env?.[greet || false]
+$env ?? $env?.[greet?.f64]
+$env ?? $env?.[greet]
+$env ?? $env?.[greet] | any(ok)
+$env ?? $env?.[greet]?.f64
+$env ?? $env?.[i]
+$env ?? $env?.[i].foo()
+$env ?? $env?.[list]
+$env ?? $env?.[ok()]
+$env ?? $env?.[ok?.[str]]
+$env ?? $env?.[ok]
+$env ?? $env?.[str]
+$env ?? $env?.[str].i
+$env ?? $env?.add
+$env ?? $env?.array
+$env ?? $env?.f64
+$env ?? $env?.findLast(ok)
+$env ?? $env?.foo
+$env ?? $env?.foobar
+$env ?? $env?.greet
+$env ?? $env?.i
+$env ?? $env?.list
+$env ?? $env?.ok
+$env ?? $env?.str
+$env ?? $env[:1 not endsWith foobar]
+$env ?? $env[:Bar()]
+$env ?? $env[:f64()]
+$env ?? $env[:f64(foobar)]
+$env ?? $env[:filter(foobar, #)]
+$env ?? $env[:foo.foo]
+$env ?? $env[:foobar not startsWith greet].f64
+$env ?? $env[:foobar]
+$env ?? $env[:nil | any(array)]?.[i]
+$env ?? $env[:str | foo(0)]
+$env ?? $env[String(String):]
+$env ?? $env[String(i):$env?.array(foo, false)]
+$env ?? $env[array():]
+$env ?? $env[filter(foobar, #):]
+$env ?? $env[foo:String]
+$env ?? $env[foobar | groupBy(1.0):]
+$env ?? $env[foobar || Bar:]
+$env ?? $env[foobar:]
+$env ?? $env[foobar[foobar:0]:foobar]
+$env ?? $env[list():true <= 1.0]
+$env ?? $env[list:foobar]
+$env ?? $env[str | groupBy(#.list):]
+$env ?? 0 | filter(false)
+$env ?? 0 | find(false)
+$env ?? 0 | map(array)
+$env ?? 0 | map(false)
+$env ?? 0 | map(str)
+$env ?? 0 | none(true)
+$env ?? 1 | map(#index)
+$env ?? 1 | sum(f64)
+$env ?? 1.0 ?? array
+$env ?? 1.0 ?? greet
+$env ?? 1.0 | findIndex(ok)
+$env ?? 1.0 | map($env)
+$env ?? 1.0 | map(ok)
+$env ?? 1.0 | sum(0)
+$env ?? 1.0 | sum(i)
+$env ?? add | any(false)
+$env ?? add | reduce(foo, nil)
+$env ?? array | map($env)
+$env ?? array | map(foo)
+$env ?? array | map(true)
+$env ?? array | reduce(i, 1.0)
+$env ?? array | sum(1.0)
+$env ?? array?.[i]
+$env ?? f64 ?? f64
+$env ?? f64 | find(false)
+$env ?? f64 | findLastIndex(ok)
+$env ?? f64 | map(add)
+$env ?? f64 | map(str)
+$env ?? false | all(false)
+$env ?? false | none(true)
+$env ?? false | sum(1.0)
+$env ?? foo ?? $env?.[str]
+$env ?? foo ?? array
+$env ?? foo ?? f64
+$env ?? foo ?? i
+$env ?? foo | any(false)
+$env ?? foo | count(true)
+$env ?? foo | map(1.0)
+$env ?? foo | none(ok)
+$env ?? foo | one(ok)
+$env ?? foo | reduce(f64, $env)
+$env ?? foo | sum(1.0)
+$env ?? foo | sum(i)
+$env ?? foo.Bar
+$env ?? foo.String
+$env ?? foo.String()
+$env ?? foo?.Bar
+$env ?? foo?.String
+$env ?? foo?.String()
+$env ?? greet ?? i
+$env ?? greet | map($env)
+$env ?? greet | none(true)
+$env ?? greet | sum(1.0)
+$env ?? i ?? array
+$env ?? i | map(0)
+$env ?? i | sum(0)
+$env ?? list | any(false)
+$env ?? list?.[i]
+$env ?? nil ?? false | map(foo)
+$env ?? nil ?? i
+$env ?? nil ?? str
+$env ?? nil | all(ok)
+$env ?? nil | any(true)
+$env ?? nil | filter(0 >= 1)
+$env ?? nil | findLastIndex(true)
+$env ?? nil | none(false)
+$env ?? nil | none(true)
+$env ?? nil | reduce(str, true)
+$env ?? nil | sum(1)
+$env ?? ok ?? ok
+$env ?? ok | map(true)
+$env ?? ok | none(ok)
+$env ?? str ?? $env?.add
+$env ?? str | map(foo)
+$env ?? str | map(ok)
+$env ?? str | none(true)
+$env ?? str | sum(0)
+$env ?? true | all(true)
+$env ?? true | findLastIndex(true)
+$env ?? true | none(ok)
+$env and false or 1.0 != f64
 $env contains $env?.Bar
+$env contains $env?.Bar?.str
 $env contains $env?.String
+$env contains $env?.String?.foo
+$env contains $env?.String?.list
 $env contains $env?.[Bar]
+$env contains $env?.[Bar]?.Bar
 $env contains $env?.[Bar]?.[f64]
 $env contains $env?.[String]
+$env contains $env?.[String]?.[foo]
+$env contains $env?.[foobar]
 $env contains $env?.[str[:1.0]]
 $env contains $env?.foobar
 $env contains $env?.nil?.[list]
 $env endsWith $env?.Bar
+$env endsWith $env?.Bar?.[foo]
 $env endsWith $env?.String
+$env endsWith $env?.String?.[array]
 $env endsWith $env?.[Bar]
+$env endsWith $env?.[Bar]?.[f64]
+$env endsWith $env?.[Bar]?.[foo].i
 $env endsWith $env?.[Bar]?.str
+$env endsWith $env?.[String?.array]
 $env endsWith $env?.[String]
 $env endsWith $env?.[foobar?.[add]]
+$env endsWith $env?.[foobar]
 $env endsWith $env?.foobar
 $env in $env.array
 $env in $env.list
@@ -156,32 +712,48 @@ $env in $env?.Bar
 $env in $env?.Bar?.foo
 $env in $env?.String
 $env in $env?.String?.list
+$env in $env?.[Bar?.ok()]
 $env in $env?.[Bar]
+$env in $env?.[Bar]?.add?.[i]
 $env in $env?.[String?.[str]]
 $env in $env?.[String]
+$env in $env?.[String]?.foo(foo)
+$env in $env?.[foobar]
 $env in $env?.array
+$env in $env?.foo || true
 $env in $env?.foobar
 $env in $env?.foobar?.foo
+$env in $env?.foobar?.list(foo)
 $env in $env?.list
 $env in $env?.true?.f64(foobar)
 $env in 0 .. i
 $env in 1 .. i
+$env in 1..i
+$env in array ?: ok
+$env in array ?? greet
 $env in array or ok
+$env in array[:]
+$env in array[:i]
 $env in i .. $env.i
 $env in list && $env and $env
 $env in list and $env?.[f64]
+$env in list and max($env)
+$env in nil ?? list
 $env matches $env && ok or true
 $env matches $env?.$env?.add
 $env matches $env?.Bar
 $env matches $env?.String
 $env matches $env?.[Bar]
 $env matches $env?.[Bar]?.[f64]
+$env matches $env?.[String?.[foobar]]
 $env matches $env?.[String]
 $env matches $env?.[String]?.ok()
 $env matches $env?.[foobar]
+$env matches $env?.[last(foo)]
 $env matches $env?.foobar
 $env matches $env?.foobar?.Bar(foobar, foobar)
 $env matches $env?.foobar?.greet()
+$env matches $env?.foobar?.greet(foobar, 1)
 $env not contains $env?.Bar
 $env not contains $env?.String
 $env not contains $env?.String?.[str]
@@ -189,20 +761,26 @@ $env not contains $env?.String?.array
 $env not contains $env?.[Bar]
 $env not contains $env?.[Bar]?.add()
 $env not contains $env?.[Bar]?.ok
+$env not contains $env?.[String?.str]
 $env not contains $env?.[String]
 $env not contains $env?.[first(foobar, greet)]
+$env not contains $env?.[foobar?.array()]
 $env not contains $env?.[foobar]
 $env not contains $env?.[toJSON(foobar)]
 $env not contains $env?.foobar
 $env not contains $env?.foobar?.[ok]
 $env not contains $env?.foobar?.greet()
+$env not contains $env?.foobar?.i
+$env not contains $env?.nil?.f64
 $env not endsWith $env?.Bar
 $env not endsWith $env?.Bar?.[list]
 $env not endsWith $env?.String
+$env not endsWith $env?.String?.[greet]
 $env not endsWith $env?.[Bar]
 $env not endsWith $env?.[String]
 $env not endsWith $env?.[foobar]
 $env not endsWith $env?.foobar
+$env not endsWith $env?.nil?.add()
 $env not in $env.array
 $env not in $env.list
 $env not in $env?.Bar
@@ -211,30 +789,47 @@ $env not in $env?.String
 $env not in $env?.String?.f64
 $env not in $env?.[Bar]
 $env not in $env?.[String]
+$env not in $env?.[foobar?.list]
 $env not in $env?.[foobar]
 $env not in $env?.array
+$env not in $env?.foobar
+$env not in $env?.foobar?.[foo]
+$env not in $env?.foobar?.foobar
 $env not in $env?.list
+$env not in 1 .. 1 ?? add
+$env not in 1..i
 $env not in array && ok
 $env not in array == $env || false
 $env not in array == $env?.[String]
+$env not in array || i ?? false
 $env not in array[:i]
+$env not in list and 1 <= f64
+$env not in list and greet == greet
 $env not in list or ok
+$env not in nil ?? list
 $env not matches $env?.Bar
 $env not matches $env?.Bar?.[add]
 $env not matches $env?.Bar?.array
 $env not matches $env?.String
 $env not matches $env?.String?.[add]
 $env not matches $env?.String?.[ok]
+$env not matches $env?.String?.array
 $env not matches $env?.[Bar]
+$env not matches $env?.[Bar]?.[str]
 $env not matches $env?.[String?.[Bar]]
 $env not matches $env?.[String]
+$env not matches $env?.[String]?.[add]
+$env not matches $env?.[foobar?.[0]]
 $env not matches $env?.[foobar]
+$env not matches $env?.foobar
 $env not startsWith $env?.Bar
 $env not startsWith $env?.Bar?.[greet]
 $env not startsWith $env?.String
 $env not startsWith $env?.[Bar]
+$env not startsWith $env?.[Bar]?.Bar
 $env not startsWith $env?.[Bar]?.f64
 $env not startsWith $env?.[String]
+$env not startsWith $env?.[String]?.[f64]
 $env not startsWith $env?.[foobar]
 $env not startsWith $env?.foobar
 $env not startsWith $env?.foobar?.[foo]
@@ -243,95 +838,231 @@ $env or nil != nil || true
 $env or nil == list and false
 $env or true ?: greet
 $env startsWith $env?.Bar
+$env startsWith $env?.Bar?.Bar
+$env startsWith $env?.Bar?.add
 $env startsWith $env?.String
 $env startsWith $env?.[Bar]
 $env startsWith $env?.[String]
+$env startsWith $env?.[String]?.greet
 $env startsWith $env?.[foobar]
 $env startsWith $env?.[foobar]?.[i]
 $env startsWith $env?.foobar
 $env startsWith $env?.foobar?.Bar()
+$env | all(false) && $env?.[f64]
+$env | all(ok) && ok
+$env | all(ok) or -$env
 $env | any(false) != ok
+$env | any(false) ?? str
+$env | any(ok) != ok
+$env | any(ok) == ok
+$env | count(ok) | min(0)
+$env | count(true) .. -i
+$env | filter(#) | filter(false)
 $env | filter(#.f64) | filter(false)
+$env | filter(false) | all(#.str())
+$env | filter(false) | all($env)
+$env | filter(false) | all(true)
+$env | filter(false) | any(#)
+$env | filter(false) | any(.list)
+$env | filter(false) | count($env)
 $env | filter(false) | count(.i.greet)
+$env | filter(false) | filter(.str)
 $env | filter(false) | find($env)
+$env | filter(false) | findIndex(#.ok)
+$env | filter(false) | findIndex(.String)
 $env | filter(false) | findIndex(.foo)
 $env | filter(false) | findLast(.greet)
 $env | filter(false) | findLast(.ok)
 $env | filter(false) | findLastIndex(.i)
+$env | filter(false) | groupBy(#.f64)
+$env | filter(false) | groupBy(str)
 $env | filter(false) | map(#)
 $env | filter(false) | one(#)
+$env | filter(false) | one(.foo)
+$env | filter(false) | sum(#)
 $env | filter(false) | sum(.greet)
 $env | filter(true) | map($env)
+$env | filter(true) | map(1.0)
 $env | find(.add) startsWith str || true
+$env | find(false) ?? $env?.String
+$env | findIndex(false) not in array
+$env | findIndex(ok) <= i
+$env | findIndex(true) ?? f64
 $env | findLast(false) == str or true
+$env | findLast(false) | get(nil)
+$env | findLastIndex(false) in sort($env)
+$env | findLastIndex(true) + f64
 $env | findLastIndex(true) - i
+$env | findLastIndex(true) > i
+$env | get(str) | groupBy(foo)
+$env | map(#index) != array
+$env | map(#index) | findIndex(true)
 $env | map(#index) | groupBy(f64)
 $env | map(#index) | map(i)
 $env | map(#index) | reduce(f64, nil)
+$env | map(#index) | sortBy(f64)
+$env | map($env) | count(ok)
 $env | map($env) | find(#.ok)
+$env | map($env) | findIndex(false)
+$env | map($env) | map(#.ok)
+$env | map($env) | map(.array)
 $env | map($env) | map(list)
+$env | map($env) | map(true)
+$env | map($env) | reduce(add)
+$env | map($env) | reduce(true)
 $env | map($env) | sortBy(#.i)
 $env | map($env) | sortBy(.i)
 $env | map($env) | sortBy(i)
+$env | map(0) == list
+$env | map(0) | all(ok)
 $env | map(0) | groupBy(1)
+$env | map(0) | map(ok)
 $env | map(0) | sortBy(#)
 $env | map(0) | sortBy(1.0)
+$env | map(0) | sum(#)
+$env | map(0) | sum(1.0)
+$env | map(1) | groupBy(#)
+$env | map(1) | map($env)
 $env | map(1) | sum(#)
+$env | map(1) | sum(f64)
 $env | map(1.0) | filter(true)
 $env | map(1.0) | findLastIndex(ok)
 $env | map(1.0) | groupBy(foo)
 $env | map(1.0) | mean(0)
+$env | map(1.0) | none(ok)
 $env | map(1.0) | none(true)
+$env | map(1.0) | reduce(#)
 $env | map(1.0) | reduce(1.0)
 $env | map(1.0) | reduce(false, list)
 $env | map(1.0) | sortBy(#)
+$env | map(add) | count(true)
+$env | map(add) | reduce(#, 1.0)
+$env | map(array) ?? i
+$env | map(array) | findIndex(ok)
+$env | map(array) | map(add)
+$env | map(array) | one(false)
+$env | map(f64) | map(#)
+$env | map(false) | groupBy(1)
 $env | map(false) | map(f64)
+$env | map(false) | reduce(foo, i)
 $env | map(false) | reduce(str)
+$env | map(foo) ?? array
 $env | map(foo) | any(false)
 $env | map(foo) | findIndex(true)
+$env | map(foo) | groupBy(#)
 $env | map(foo) | groupBy(1)
+$env | map(foo) | map(#)
+$env | map(foo) | map(list)
+$env | map(foo) | none(ok)
 $env | map(foo) | reduce(#acc)
+$env | map(foo) | reduce($env, $env)
 $env | map(foo) | sum(1)
 $env | map(greet) | map(array)
+$env | map(greet) | map(greet)
+$env | map(greet) | reduce(foo)
+$env | map(i) ?? greet
 $env | map(i) | count(false)
+$env | map(i) | groupBy(1.0)
+$env | map(list) ?? list
+$env | map(list) | any(false)
+$env | map(list) | any(ok)
 $env | map(list) | reduce(ok)
+$env | map(list) | reduce(true)
+$env | map(ok) ?? ok
 $env | map(ok) | findLast(ok)
 $env | map(ok) | map($env)
 $env | map(ok) | none(#)
 $env | map(ok) | one(#)
 $env | map(ok) | reduce(0)
 $env | map(ok) | reduce(false)
+$env | map(str) != list
+$env | map(str) | findIndex(ok)
 $env | map(str) | groupBy(foo)
+$env | map(str) | map(1)
+$env | map(str) | map(foo)
+$env | map(str) | reduce(#)
+$env | map(str) | sortBy(str)
+$env | map(true) ?? array
+$env | map(true) ?? str
 $env | map(true) | all(#)
+$env | map(true) | count(#)
+$env | map(true) | filter(#)
+$env | map(true) | find(false)
 $env | map(true) | findLastIndex(#)
+$env | map(true) | groupBy(foo)
+$env | map(true) | map(#)
 $env | map(true) | map($env)
+$env | median(1.0) or true || true
 $env | none(true) && ok
 $env | one(ok) || ok
 $env | reduce(#, nil) > $env and false
 $env | reduce($env, $env) | count(ok)
 $env | reduce($env, 1) | sum(0)
+$env | reduce(0, false) | max(1.0, f64)
 $env | reduce(1.0, 1) <= f64
 $env | reduce(false, $env); list
+$env | reduce(greet, array) ?? foo
 $env | reduce(ok, 1) ?: greet
+$env | reduce(str, foo) not startsWith str
 $env | sortBy(#, 0) * $env && false
+$env | sum(#) not endsWith $env or true
+$env | sum(1.0) <= i
 $env | sum(1.0) in array
 $env | sum(f64) > f64
+$env | sum(f64) ?? ok
 $env | sum(i) / bitnot(i)
+$env || false and $env?.Bar()
 $env || true || $env < 1
+$env.add != $env?.add
 $env.add == $env.add
 $env.add == $env?.add
 $env.add == add
+$env.add ?? !false
+$env.add ?? $env?.foo
+$env.add ?? [i]
+$env.add ?? add
+$env.add ?? array
+$env.add ?? count(array)
+$env.add ?? foo
+$env.add ?? greet
+$env.add ?? groupBy(array, $env)
+$env.add ?? i
+$env.add ?? list
+$env.add ?? list ?? nil
+$env.add ?? ok
+$env.add ?? str
+$env.add ?? sum($env)
+$env.add not in [nil, false]
+$env.add(1, 1) < f64 && ok
 $env.array != array
 $env.array != list
 $env.array == $env?.array
 $env.array == array
 $env.array == list
+$env.array ?? !true
+$env.array ?? $env | groupBy(#)
+$env.array ?? $env?.Bar
+$env.array ?? $env?.[String]
+$env.array ?? $env?.add
+$env.array ?? [nil]
+$env.array ?? add
+$env.array ?? array
+$env.array ?? f64
+$env.array ?? foo | findLastIndex(false)
+$env.array ?? greet
+$env.array ?? list
+$env.array ?? ok
+$env.array | all(false)
+$env.array | all(ok)
+$env.array | all(true)
 $env.array | any($env?.ok)
 $env.array | any(false)
+$env.array | any(nil == #)
 $env.array | any(ok)
 $env.array | concat(array)
 $env.array | concat(list)
 $env.array | count(false)
+$env.array | count(true)
 $env.array | filter(false)
 $env.array | filter(ok)
 $env.array | filter(true)
@@ -342,6 +1073,7 @@ $env.array | findIndex(false)
 $env.array | findIndex(nil == list)
 $env.array | findIndex(ok)
 $env.array | findIndex(true)
+$env.array | findLast(false)
 $env.array | findLast(ok)
 $env.array | findLast(true)
 $env.array | findLastIndex(false)
@@ -352,16 +1084,20 @@ $env.array | groupBy(0)
 $env.array | groupBy(1)
 $env.array | groupBy(1.0)
 $env.array | groupBy(f64)
+$env.array | groupBy(false)
 $env.array | groupBy(foo)
 $env.array | groupBy(i)
 $env.array | groupBy(ok)
 $env.array | map(#)
 $env.array | map(#index)
 $env.array | map($env)
+$env.array | map($env?.[String])
 $env.array | map(1)
+$env.array | map(1.0)
 $env.array | map(array)
 $env.array | map(f64)
 $env.array | map(false)
+$env.array | map(float(1.0))
 $env.array | map(foo)
 $env.array | map(greet)
 $env.array | map(i)
@@ -374,27 +1110,49 @@ $env.array | mean(f64)
 $env.array | mean(i)
 $env.array | median(0, array)
 $env.array | median(1)
+$env.array | median(1.0)
+$env.array | median(i)
+$env.array | min(0)
+$env.array | min(1)
 $env.array | none(ok)
 $env.array | none(true)
+$env.array | one(false)
 $env.array | one(ok)
+$env.array | one(true)
+$env.array | reduce(# ^ #)
 $env.array | reduce(#)
+$env.array | reduce(#, $env)
 $env.array | reduce(#, 0)
+$env.array | reduce(#, 1)
+$env.array | reduce(#, false)
 $env.array | reduce(#, foo)
+$env.array | reduce(#, greet)
+$env.array | reduce(#index)
 $env.array | reduce($env)
+$env.array | reduce($env, 1.0)
+$env.array | reduce(0)
 $env.array | reduce(1)
+$env.array | reduce(1.0)
+$env.array | reduce(1.0, f64)
 $env.array | reduce(1.0, greet)
 $env.array | reduce(add)
+$env.array | reduce(add, greet)
+$env.array | reduce(add, true)
 $env.array | reduce(array)
 $env.array | reduce(f64)
+$env.array | reduce(f64, 0)
+$env.array | reduce(f64, i)
 $env.array | reduce(false)
 $env.array | reduce(foo)
 $env.array | reduce(foo, 1)
 $env.array | reduce(foo, 1.0)
 $env.array | reduce(foo, array)
+$env.array | reduce(foo, i)
 $env.array | reduce(greet)
 $env.array | reduce(i)
 $env.array | reduce(i, true)
 $env.array | reduce(list)
+$env.array | reduce(not false)
 $env.array | reduce(ok)
 $env.array | reduce(str)
 $env.array | reduce(str, false)
@@ -402,127 +1160,260 @@ $env.array | reduce(true)
 $env.array | reduce(true, false)
 $env.array | reduce(true, true)
 $env.array | sortBy(#)
+$env.array | sortBy(0)
 $env.array | sortBy(1)
 $env.array | sortBy(1.0)
 $env.array | sortBy(f64)
+$env.array | sortBy(i)
 $env.array | sortBy(str)
 $env.array | sum(#)
 $env.array | sum(0)
 $env.array | sum(1)
 $env.array | sum(1.0)
+$env.array | sum(i)
 $env.array | take(0)
+$env.array | take(1)
+$env.array | take(i)
 $env.array?.[i]
 $env.array[:]
 $env.array[:i]
 $env.f64 != $env.i
+$env.f64 != -1.0
 $env.f64 != 0 % i
 $env.f64 != abs(f64)
+$env.f64 != f64
 $env.f64 != i
+$env.f64 != sum(array)
 $env.f64 * 0 >= 1.0
 $env.f64 * array?.[i]
 $env.f64 * f64
 $env.f64 * i
+$env.f64 * i ?? str
+$env.f64 ** f64
 $env.f64 ** i
 $env.f64 ** sum(array)
+$env.f64 + $env.i
+$env.f64 + f64
 $env.f64 + f64 == 1
 $env.f64 + i
 $env.f64 - 1 >= f64
 $env.f64 - 1.0 > 0
 $env.f64 - f64
 $env.f64 - i
+$env.f64 - i ^ 0
+$env.f64 / 0.0
 $env.f64 / f64
 $env.f64 / i
+$env.f64 < 1.0 ?: list
 $env.f64 < 1.0 || ok
 $env.f64 < f64
 $env.f64 < i
+$env.f64 <= $env.i
+$env.f64 <= 1.0 != false
 $env.f64 <= f64
 $env.f64 <= i
+$env.f64 <= i ?? foo
+$env.f64 == $env.f64
 $env.f64 == f64
+$env.f64 == i
 $env.f64 > $env.f64
+$env.f64 > bitushr(0, i)
 $env.f64 > f64
 $env.f64 > i
 $env.f64 > sum($env, f64)
 $env.f64 >= 1.0 - 1.0
 $env.f64 >= abs(1.0)
 $env.f64 >= i
+$env.f64 ?? !true
+$env.f64 ?? add
+$env.f64 ?? f64
+$env.f64 ?? foo
+$env.f64 ?? greet
+$env.f64 ?? i
+$env.f64 ?? list
+$env.f64 ?? list?.[i]
+$env.f64 ?? ok
+$env.f64 ?? sortBy(list, f64)
+$env.f64 ?? str
 $env.f64 ^ 0 / 0
 $env.f64 ^ f64
 $env.f64 ^ i
 $env.f64 ^ i != $env
 $env.f64 in array
+$env.f64 in array and ok
+$env.f64 not in array ? i : $env
 $env.f64 not in first($env)
+$env.f64 | max(1.0)
 $env.f64 | max(f64)
+$env.f64 | max(i, 1.0)
+$env.f64 | mean(0)
 $env.f64 | mean(1)
 $env.f64 | mean(f64)
 $env.f64 | median(i)
+$env.f64 | min(0)
+$env.f64 | min(array)
+$env.f64 | min(i)
+$env.foo != $env.foo
+$env.foo != $env?.foo
 $env.foo != foo
+$env.foo != {foo: list, foo: true, foo: $env}?.foo
 $env.foo == $env?.foo
 $env.foo == foo
 $env.foo == nil == $env
 $env.foo == nil and ok
+$env.foo ?? $env.array
+$env.foo ?? $env?.[add]
+$env.foo ?? add
+$env.foo ?? all($env, true)
+$env.foo ?? array
+$env.foo ?? array?.[i]
+$env.foo ?? foo
+$env.foo ?? greet
+$env.foo ?? greet(str)
+$env.foo ?? i
+$env.foo ?? last(array)
+$env.foo ?? list
+$env.foo ?? ok
+$env.foo ?? str
+$env.foo ?? sum($env, 1.0)
 $env.foo in list
 $env.foo not in list
 $env.foo.Bar
 $env.foo.String
 $env.foo.String()
 $env.foo?.Bar
+$env.foo?.Bar > str
 $env.foo?.String
 $env.foo?.String()
+$env.greet != $env && $env
+$env.greet != $env.greet
 $env.greet != greet
+$env.greet == $env?.foobar?.[list]
 $env.greet == greet
+$env.greet ?? $env?.[list]
+$env.greet ?? $env?.list
+$env.greet ?? array
+$env.greet ?? f64
+$env.greet ?? foo
+$env.greet ?? greet
+$env.greet ?? greet(str)
+$env.greet ?? list
+$env.greet ?? ok
+$env.greet ?? reduce(list, str)
+$env.greet ?? str
 $env.greet($env.str)
 $env.greet($env?.[str])
+$env.greet($env?.str)
 $env.greet(foo.Bar)
 $env.greet(foo.String())
+$env.greet(foo?.Bar)
 $env.greet(foo?.String())
 $env.greet(greet(str))
 $env.greet(str)
 $env.greet(string($env))
+$env.greet(string(1.0))
+$env.greet(toJSON(list))
+$env.greet(trimPrefix(str))
+$env.greet(type(0))
 $env.i != $env?.Bar
 $env.i != $env?.[Bar]?.foo()
 $env.i != 1 / 1
+$env.i != 1.0 + 1.0
+$env.i != f64
+$env.i != i
 $env.i % i
+$env.i % i != $env
+$env.i % i <= 0
+$env.i * -i
 $env.i * f64
 $env.i * i
+$env.i * min(0)
 $env.i ** f64
 $env.i ** i
 $env.i ** mean(1.0)
+$env.i + f64
+$env.i + i
+$env.i - -0
+$env.i - -1.0
+$env.i - 1 == 1.0
+$env.i - ceil(1)
 $env.i - f64
+$env.i - i
+$env.i .. i
 $env.i / $env.f64
 $env.i / f64
 $env.i / find(array, true)
+$env.i / i
+$env.i / i - 0
+$env.i < $env.i
+$env.i < 1.0 != $env
 $env.i < 1.0 or $env
+$env.i < f64
+$env.i < f64 ^ f64
 $env.i < i
 $env.i < i / i
+$env.i <= 1.0 > 1.0
 $env.i <= f64
+$env.i <= i
+$env.i == $env?.f64
 $env.i == f64
 $env.i == i
 $env.i > $env.i
 $env.i > f64
+$env.i > i
+$env.i >= $env?.i
 $env.i >= f64
+$env.i >= f64 / f64
 $env.i >= i
+$env.i ?? $env?.[str]
+$env.i ?? add
+$env.i ?? array
+$env.i ?? f64
+$env.i ?? foo?.Bar
+$env.i ?? foo?.String
+$env.i ?? greet
+$env.i ?? i
+$env.i ?? ok
+$env.i ?? str
+$env.i ?? sum(array)
+$env.i ?? toJSON(f64)
 $env.i ^ f64
 $env.i ^ i
+$env.i in $env?.[Bar]
 $env.i in array
 $env.i in array != nil
+$env.i in take(array, 0)
 $env.i not in $env?.[String]
 $env.i not in $env?.array
+$env.i not in array
 $env.i | add(i)
 $env.i | bitnand(i)
+$env.i | bitor(0)
 $env.i | bitor(1)
 $env.i | bitshl(0)
+$env.i | bitshl(1)
 $env.i | bitshr(i)
 $env.i | bitushr(1)
 $env.i | bitushr(i)
 $env.i | bitxor(0)
 $env.i | max(1.0)
 $env.i | mean(i)
+$env.i | median(1)
 $env.list != array
 $env.list != list
 $env.list == $env?.Bar
 $env.list == array
 $env.list == list
 $env.list == nil || $env
+$env.list ?? $env?.[greet]
+$env.list ?? $env?.i
+$env.list ?? -0
+$env.list ?? add
+$env.list ?? f64
+$env.list ?? false | sortBy(#.Bar)
+$env.list ?? foo
+$env.list ?? i
+$env.list ?? list
 $env.list | all(false)
 $env.list | all(ok)
 $env.list | all(true)
@@ -531,18 +1422,25 @@ $env.list | any(ok)
 $env.list | any(true)
 $env.list | concat(array)
 $env.list | count(false)
+$env.list | count(ok)
 $env.list | count(true)
 $env.list | filter(false)
+$env.list | filter(ok)
 $env.list | filter(true)
 $env.list | find(false)
 $env.list | find(nil not in list)
 $env.list | find(ok)
+$env.list | find(true)
 $env.list | findIndex(false)
 $env.list | findIndex(ok)
 $env.list | findIndex(true)
+$env.list | findLast(false)
+$env.list | findLast(ok)
 $env.list | findLast(true)
+$env.list | findLastIndex(ok)
 $env.list | findLastIndex(true)
 $env.list | groupBy(#)
+$env.list | groupBy(#.Bar)
 $env.list | groupBy(.Bar)
 $env.list | groupBy(0)
 $env.list | groupBy(1)
@@ -551,6 +1449,8 @@ $env.list | groupBy(f64)
 $env.list | groupBy(false != false)
 $env.list | groupBy(false)
 $env.list | groupBy(foo)
+$env.list | groupBy(ok)
+$env.list | groupBy(true)
 $env.list | map(#)
 $env.list | map(#.Bar)
 $env.list | map(#.String)
@@ -563,6 +1463,7 @@ $env.list | map(1.0)
 $env.list | map(add)
 $env.list | map(array)
 $env.list | map(f64)
+$env.list | map(false)
 $env.list | map(foo)
 $env.list | map(greet)
 $env.list | map(i)
@@ -570,157 +1471,282 @@ $env.list | map(list)
 $env.list | map(ok)
 $env.list | map(str)
 $env.list | map(true)
+$env.list | none(false)
+$env.list | none(ok)
+$env.list | none(true)
 $env.list | one(false)
+$env.list | one(foo != $env)
+$env.list | one(ok)
 $env.list | one(true)
 $env.list | reduce(#)
+$env.list | reduce(#, $env)
+$env.list | reduce(#, 0)
+$env.list | reduce(#, 1.0)
 $env.list | reduce(#, nil)
+$env.list | reduce(#, true)
 $env.list | reduce(#.Bar)
+$env.list | reduce(#.String)
+$env.list | reduce(#acc)
+$env.list | reduce(#acc, $env)
+$env.list | reduce(#index)
 $env.list | reduce($env)
 $env.list | reduce(.Bar, 1)
+$env.list | reduce(.Bar, 1.0)
 $env.list | reduce(.String)
 $env.list | reduce(0)
 $env.list | reduce(1)
+$env.list | reduce(1, $env)
 $env.list | reduce(1.0)
 $env.list | reduce(1.0, f64)
 $env.list | reduce(1.0, false)
 $env.list | reduce(add)
 $env.list | reduce(add, nil)
 $env.list | reduce(array)
+$env.list | reduce(array, 0)
 $env.list | reduce(f64)
+$env.list | reduce(false)
+$env.list | reduce(false, i)
+$env.list | reduce(false, str)
 $env.list | reduce(foo == #)
 $env.list | reduce(foo)
 $env.list | reduce(foo, 0)
 $env.list | reduce(foo, foo)
+$env.list | reduce(foo, i)
 $env.list | reduce(foo, nil)
 $env.list | reduce(foo, str)
+$env.list | reduce(greet)
+$env.list | reduce(greet, foo)
 $env.list | reduce(i)
 $env.list | reduce(i, 1.0)
 $env.list | reduce(list)
 $env.list | reduce(str)
+$env.list | reduce(str, false)
+$env.list | reduce(true)
 $env.list | reduce(true, 1)
 $env.list | sortBy(#.Bar)
 $env.list | sortBy(.Bar)
+$env.list | sortBy(0)
+$env.list | sortBy(1)
 $env.list | sortBy(1.0)
+$env.list | sortBy(f64)
+$env.list | sortBy(i)
+$env.list | sortBy(str)
 $env.list | sum(0)
 $env.list | sum(1)
 $env.list | sum(1.0)
+$env.list | sum(f64)
 $env.list | sum(i)
+$env.list?.[$env?.i]
 $env.list?.[i]
 $env.list?.[i].Bar
 $env.list?.[i].String()
+$env.list[:]
 $env.list[:sum(array, #)]
 $env.list[i:]
+$env.ok != list ?? foo
 $env.ok != ok
+$env.ok && $env?.$env
 $env.ok && $env?.[nil]
+$env.ok && $env?.[str]
+$env.ok && array ?? i
+$env.ok && f64 == nil
 $env.ok && ok
+$env.ok == $env ?? ok
+$env.ok == nil || true
 $env.ok == ok
 $env.ok ? list : date(1)
 $env.ok ?: array
 $env.ok ?: f64
+$env.ok ?? add
+$env.ok ?? array
+$env.ok ?? foo.String
+$env.ok ?? i
+$env.ok ?? ok
+$env.ok ?? str
 $env.ok and $env?.[foobar]
 $env.ok and $env?.[nil]
+$env.ok and f64 < 1.0
 $env.ok and ok
 $env.ok in $env?.[nil]
 $env.ok in keys($env)
 $env.ok not in $env?.$env
+$env.ok not in [false]
+$env.ok or $env?.String.String
+$env.ok or $env?.[String]
+$env.ok or $env?.ok
+$env.ok or not $env
 $env.ok or ok
+$env.ok || $env?.foobar
+$env.ok || array ?? i
 $env.ok || ok
 $env.str != str
+$env.str + $env.str
 $env.str + str
 $env.str + type($env)
+$env.str + type(nil)
 $env.str < $env?.[str]
 $env.str < foo.Bar
+$env.str < str
 $env.str <= str
+$env.str <= toJSON(ok)
+$env.str == $env?.[Bar]
+$env.str == str
 $env.str > str
 $env.str > type(nil)
 $env.str >= greet(str)
 $env.str >= str
+$env.str ?? $env.foo
+$env.str ?? add
+$env.str ?? array
+$env.str ?? f64
+$env.str ?? foo
+$env.str ?? greet
+$env.str ?? greet($env)
+$env.str ?? i
+$env.str ?? list
+$env.str ?? ok
+$env.str ?? str
 $env.str contains $env?.String
+$env.str contains $env?.[Bar]
 $env.str contains str
+$env.str contains toJSON(foo)
 $env.str endsWith str
+$env.str endsWith str[:i]
 $env.str in foo
 $env.str matches str
 $env.str matches str ?: 1.0
 $env.str matches string(1.0)
 $env.str not contains $env.str
+$env.str not contains $env?.[str]
+$env.str not contains foo.String()
 $env.str not contains str
 $env.str not endsWith str
 $env.str not in $env ? foo : 0
 $env.str not in foo
+$env.str not matches foo?.Bar
 $env.str not matches str
+$env.str not startsWith foo?.Bar
 $env.str not startsWith str
+$env.str startsWith str
 $env.str | greet()
+$env.str | hasPrefix(str)
 $env.str | hasSuffix(str)
 $env.str | split(str)
 $env.str[:]
 $env.str[i:]
 $env; $env.add
+$env; $env.i
+$env; $env?.[Bar]
 $env; $env?.foo
 $env; $env?.i
+$env; $env?.ok
 $env; $env?.str
 $env; false; $env?.foo
+$env; list?.[i]
 $env?.$env != $env.array
 $env?.$env != foo
 $env?.$env != i
+$env?.$env != str
 $env?.$env == add
+$env?.$env == foo?.String()
+$env?.$env ?? $env ?? greet
+$env?.$env ?? array
+$env?.$env ?? greet
+$env?.$env and $env || true
+$env?.$env in foo || true
+$env?.$env in list
 $env?.$env not contains str
+$env?.$env not endsWith str
 $env?.$env?.Bar
+$env?.$env?.Bar()
+$env?.$env?.Bar()?.[foo]
 $env?.$env?.Bar?.foo
 $env?.$env?.String
 $env?.$env?.String()
+$env?.$env?.String(foobar)
+$env?.$env?.String(greet)
 $env?.$env?.[add]
 $env?.$env?.[array]
 $env?.$env?.[f64]
+$env?.$env?.[f64].list.greet
 $env?.$env?.[f64]?.str
 $env?.$env?.[foo]
 $env?.$env?.[foo].ok
 $env?.$env?.[greet]
+$env?.$env?.[greet].i
 $env?.$env?.[i]
 $env?.$env?.[i].f64
+$env?.$env?.[i].foo
 $env?.$env?.[i].str
+$env?.$env?.[i]?.[greet]?.greet()
 $env?.$env?.[i]?.[ok]
+$env?.$env?.[i]?.f64
 $env?.$env?.[list]
 $env?.$env?.[ok]
 $env?.$env?.[str]
 $env?.$env?.[str]?.[foo]?.str
 $env?.$env?.add
 $env?.$env?.add()
+$env?.$env?.add().Bar
+$env?.$env?.add(foobar?.[str])
+$env?.$env?.add(nil == Bar, add)
 $env?.$env?.add?.ok
 $env?.$env?.array
 $env?.$env?.array()
+$env?.$env?.array(foobar)
 $env?.$env?.array.i
+$env?.$env?.array?.[list]
 $env?.$env?.array?.[ok]
+$env?.$env?.array?.[str]
+$env?.$env?.array?.list
+$env?.$env?.count(String, foobar)
 $env?.$env?.f64
 $env?.$env?.f64()
+$env?.$env?.f64(foobar)
 $env?.$env?.f64.String
 $env?.$env?.filter(1.0, foo)
+$env?.$env?.findLast(i, i)
 $env?.$env?.foo
+$env?.$env?.foo.greet
+$env?.$env?.foobar.Bar
 $env?.$env?.foobar.i(foo)
 $env?.$env?.greet
 $env?.$env?.greet()
 $env?.$env?.greet.foo()
+$env?.$env?.greet.i
 $env?.$env?.greet?.i()
 $env?.$env?.i
 $env?.$env?.i()
 $env?.$env?.i()?.list
+$env?.$env?.i(foobar?.[f64])?.String
 $env?.$env?.i(str, foobar?.f64)
 $env?.$env?.i?.greet
+$env?.$env?.keys(Bar, foobar)
 $env?.$env?.list
 $env?.$env?.list()
+$env?.$env?.list.String
+$env?.$env?.list.list
 $env?.$env?.list?.foo
+$env?.$env?.list?.list
 $env?.$env?.ok
 $env?.$env?.ok()
 $env?.$env?.ok(String)
+$env?.$env?.ok.first(0)?.list
 $env?.$env?.ok?.String
+$env?.$env?.ok?.ok
 $env?.$env?.str
 $env?.$env?.str()
 $env?.$env?.str()?.[add]
 $env?.$env?.str(foobar)
 $env?.$env?.sum(0, list)
+$env?.$env?.uniq(foobar)
 $env?.Bar != $env.add
 $env?.Bar != add
+$env?.Bar != array
 $env?.Bar != f64
+$env?.Bar != filter(array, true)
 $env?.Bar != foo
+$env?.Bar != foo && true
 $env?.Bar != greet
 $env?.Bar != i
 $env?.Bar != list
@@ -730,54 +1756,112 @@ $env?.Bar != str
 $env?.Bar != type(1.0)
 $env?.Bar + 1.0 or true
 $env?.Bar == $env?.f64
+$env?.Bar == $env?.foobar
 $env?.Bar == 1.0 / f64
 $env?.Bar == add
 $env?.Bar == array
 $env?.Bar == f64
+$env?.Bar == foo
+$env?.Bar == foo.Bar
 $env?.Bar == greet
 $env?.Bar == greet(str)
 $env?.Bar == i
+$env?.Bar == list
+$env?.Bar == map(array, #)
 $env?.Bar == map(list, 1.0)
+$env?.Bar == nil ?? 1.0
 $env?.Bar == ok
 $env?.Bar == ok or true
+$env?.Bar == str
 $env?.Bar == string(list)
+$env?.Bar ?? $env?.str
+$env?.Bar ?? -f64
+$env?.Bar ?? [foo]
+$env?.Bar ?? add
+$env?.Bar ?? array
+$env?.Bar ?? f64
+$env?.Bar ?? foo
+$env?.Bar ?? greet
+$env?.Bar ?? i
+$env?.Bar ?? list
+$env?.Bar ?? not ok
+$env?.Bar ?? ok
+$env?.Bar ?? str
+$env?.Bar ?? type(array)
 $env?.Bar contains $env?.$env
 $env?.Bar contains str
+$env?.Bar endsWith $env?.String
 $env?.Bar endsWith str
 $env?.Bar endsWith str ? foo : 1
+$env?.Bar endsWith toJSON(0)
 $env?.Bar in array
+$env?.Bar matches $env?.[String]
 $env?.Bar matches str
 $env?.Bar matches string(i)
+$env?.Bar not contains mean(array)
 $env?.Bar not contains str
+$env?.Bar not endsWith $env.str
 $env?.Bar not endsWith foo.Bar
 $env?.Bar not in $env?.String
+$env?.Bar not in $env?.list
 $env?.Bar not in [f64, $env]
 $env?.Bar not in array
+$env?.Bar not in array ?? array
 $env?.Bar not in list
 $env?.Bar not in list and $env
+$env?.Bar not matches greet(str)
 $env?.Bar not matches str
 $env?.Bar not startsWith $env?.str
+$env?.Bar not startsWith 0 ?? array
 $env?.Bar not startsWith str
+$env?.Bar not startsWith str ?? $env
+$env?.Bar startsWith $env ?? foo
 $env?.Bar startsWith $env?.[String]
+$env?.Bar startsWith 1.0 ?? 0
 $env?.Bar startsWith str
+$env?.Bar | get(1.0)
+$env?.Bar | get(list)
+$env?.Bar | get(nil)
+$env?.Bar | get(true)
+$env?.Bar().foobar or true
+$env?.Bar(foobar)?.foobar && false
+$env?.Bar; array
+$env?.Bar?.$env?.ok()
 $env?.Bar?.Bar
 $env?.Bar?.Bar()
+$env?.Bar?.Bar() != !ok
 $env?.Bar?.Bar().Bar
 $env?.Bar?.Bar()?.[f64]
+$env?.Bar?.Bar(Bar)
+$env?.Bar?.Bar(String)
+$env?.Bar?.Bar(f64)
+$env?.Bar?.Bar(foo != foobar)
 $env?.Bar?.Bar(foobar)
 $env?.Bar?.Bar(foobar?.String)
+$env?.Bar?.Bar(foobar?.[greet])
+$env?.Bar?.Bar(foobar?.greet())
+$env?.Bar?.Bar(i)
+$env?.Bar?.Bar(list)
+$env?.Bar?.Bar.String
 $env?.Bar?.Bar.add
 $env?.Bar?.Bar.i
+$env?.Bar?.Bar.list()
 $env?.Bar?.Bar.ok
+$env?.Bar?.Bar.str()
 $env?.Bar?.Bar?.Bar
 $env?.Bar?.Bar?.Bar().greet
 $env?.Bar?.Bar?.String
 $env?.Bar?.Bar?.[f64]
+$env?.Bar?.Bar?.[i]
+$env?.Bar?.Bar?.[list]
 $env?.Bar?.Bar?.i
+$env?.Bar?.Bar?.list
 $env?.Bar?.Bar?.ok
 $env?.Bar?.Bar?.str
 $env?.Bar?.String
 $env?.Bar?.String()
+$env?.Bar?.String()?.[foo]
+$env?.Bar?.String(add(foobar, foobar))
 $env?.Bar?.String(foo)
 $env?.Bar?.String(foobar)
 $env?.Bar?.String(foobar)?.[add]
@@ -785,117 +1869,231 @@ $env?.Bar?.String(foobar)?.[ok]?.[str]
 $env?.Bar?.String(foobar)?.str
 $env?.Bar?.String(foobar?.Bar?.[f64])
 $env?.Bar?.String(foobar?.[true])
+$env?.Bar?.String(foobar?.f64(foobar))
+$env?.Bar?.String(greet(Bar))?.foobar
 $env?.Bar?.String(greet)
 $env?.Bar?.String(i)
 $env?.Bar?.String(str | toBase64(foobar), foobar)
+$env?.Bar?.String.f64
+$env?.Bar?.String.foo
 $env?.Bar?.String.i
+$env?.Bar?.String.ok
 $env?.Bar?.String?.String
+$env?.Bar?.String?.[array]
+$env?.Bar?.String?.[f64]
 $env?.Bar?.String?.[i]
 $env?.Bar?.String?.[str]
+$env?.Bar?.String?.add()
+$env?.Bar?.String?.date(foo)
 $env?.Bar?.String?.foo
 $env?.Bar?.String?.str()
 $env?.Bar?.[$env.i]
+$env?.Bar?.[$env?.Bar]
+$env?.Bar?.[$env?.[String]]
 $env?.Bar?.[$env?.[add]].Bar
+$env?.Bar?.[$env?.f64]
 $env?.Bar?.[add]
+$env?.Bar?.[add].Bar
+$env?.Bar?.[add].String
 $env?.Bar?.[add].add
 $env?.Bar?.[add].foo
 $env?.Bar?.[add].i
+$env?.Bar?.[add]?.Bar?.str
+$env?.Bar?.[add]?.[greet]
+$env?.Bar?.[add]?.[i]
+$env?.Bar?.[add]?.f64
 $env?.Bar?.[add]?.foo
+$env?.Bar?.[add]?.greet
+$env?.Bar?.[add]?.list
 $env?.Bar?.[add]?.ok
 $env?.Bar?.[add]?.str
 $env?.Bar?.[array]
+$env?.Bar?.[array].ok
 $env?.Bar?.[array].ok()
 $env?.Bar?.[array]?.Bar
+$env?.Bar?.[array]?.String
+$env?.Bar?.[array]?.[greet]
+$env?.Bar?.[array]?.[list]
 $env?.Bar?.[array]?.add
 $env?.Bar?.[array]?.foo
 $env?.Bar?.[array]?.list
+$env?.Bar?.[count($env)]
 $env?.Bar?.[f64]
 $env?.Bar?.[f64].Bar
+$env?.Bar?.[f64].f64
 $env?.Bar?.[f64].list
+$env?.Bar?.[f64].ok
 $env?.Bar?.[f64]?.Bar
 $env?.Bar?.[f64]?.[greet]
 $env?.Bar?.[f64]?.[list]
+$env?.Bar?.[f64]?.add()
 $env?.Bar?.[f64]?.array()
+$env?.Bar?.[f64]?.str(foobar)
 $env?.Bar?.[false != $env]
+$env?.Bar?.[foo?.String]
 $env?.Bar?.[foo]
 $env?.Bar?.[foo].add
 $env?.Bar?.[foo].array()
+$env?.Bar?.[foo].f64
 $env?.Bar?.[foo].greet
+$env?.Bar?.[foo].str
 $env?.Bar?.[foo]?.Bar
 $env?.Bar?.[foo]?.String
+$env?.Bar?.[foo]?.[array]
 $env?.Bar?.[foo]?.[greet]
+$env?.Bar?.[foo]?.[i]
 $env?.Bar?.[foo]?.[ok]
+$env?.Bar?.[foo]?.add
+$env?.Bar?.[foo]?.array(i)
+$env?.Bar?.[foo]?.f64
+$env?.Bar?.[foo]?.list
 $env?.Bar?.[foo]?.str
 $env?.Bar?.[greet]
+$env?.Bar?.[greet].Bar
+$env?.Bar?.[greet].Bar(add)?.greet
 $env?.Bar?.[greet].add
 $env?.Bar?.[greet].f64
 $env?.Bar?.[greet].foo
 $env?.Bar?.[greet].i
+$env?.Bar?.[greet].list
 $env?.Bar?.[greet].ok
+$env?.Bar?.[greet]?.Bar
+$env?.Bar?.[greet]?.[add]
+$env?.Bar?.[greet]?.[f64]
+$env?.Bar?.[greet]?.[i]
+$env?.Bar?.[greet]?.array
 $env?.Bar?.[greet]?.f64
+$env?.Bar?.[greet]?.foo()
+$env?.Bar?.[greet]?.greet
+$env?.Bar?.[greet]?.list.String
 $env?.Bar?.[groupBy(list, #)]
 $env?.Bar?.[i]
+$env?.Bar?.[i].Bar(foo, false, greet).array
+$env?.Bar?.[i].add
 $env?.Bar?.[i].foo
+$env?.Bar?.[i].list
 $env?.Bar?.[i].ok
 $env?.Bar?.[i]?.Bar
 $env?.Bar?.[i]?.String
+$env?.Bar?.[i]?.[add]
+$env?.Bar?.[i]?.[array]
 $env?.Bar?.[i]?.[greet]
+$env?.Bar?.[i]?.[i]
+$env?.Bar?.[i]?.[list]
 $env?.Bar?.[i]?.[ok]
+$env?.Bar?.[i]?.add
 $env?.Bar?.[i]?.f64
 $env?.Bar?.[i]?.foo
+$env?.Bar?.[i]?.ok
 $env?.Bar?.[i]?.str()
+$env?.Bar?.[list?.[i]]
 $env?.Bar?.[list]
 $env?.Bar?.[list].Bar
 $env?.Bar?.[list].add
+$env?.Bar?.[list].array()
 $env?.Bar?.[list].f64
 $env?.Bar?.[list].greet
 $env?.Bar?.[list].i(foobar)
+$env?.Bar?.[list].ok
+$env?.Bar?.[list].str
 $env?.Bar?.[list].str()
 $env?.Bar?.[list]?.String
+$env?.Bar?.[list]?.[add]
+$env?.Bar?.[list]?.[array]
+$env?.Bar?.[list]?.[f64]
 $env?.Bar?.[list]?.[foo]
 $env?.Bar?.[list]?.[i]
+$env?.Bar?.[list]?.[ok]
+$env?.Bar?.[list]?.[str]
 $env?.Bar?.[list]?.array.list
 $env?.Bar?.[list]?.f64
+$env?.Bar?.[list]?.list
 $env?.Bar?.[list]?.list()
 $env?.Bar?.[list]?.str()
 $env?.Bar?.[median(0)]
+$env?.Bar?.[nil | date(array)]
+$env?.Bar?.[none($env, #.i)]
 $env?.Bar?.[ok]
+$env?.Bar?.[ok] == greet
 $env?.Bar?.[ok].Bar
 $env?.Bar?.[ok].String
 $env?.Bar?.[ok].f64
+$env?.Bar?.[ok].i
+$env?.Bar?.[ok].ok()
+$env?.Bar?.[ok].str
+$env?.Bar?.[ok]?.Bar
 $env?.Bar?.[ok]?.String
+$env?.Bar?.[ok]?.[greet]
 $env?.Bar?.[ok]?.[i]
 $env?.Bar?.[ok]?.[str]
 $env?.Bar?.[ok]?.add
 $env?.Bar?.[ok]?.array
 $env?.Bar?.[ok]?.array()
 $env?.Bar?.[ok]?.f64()
+$env?.Bar?.[ok]?.foo
+$env?.Bar?.[ok]?.greet()
 $env?.Bar?.[ok]?.greet.array(foobar?.[str])
+$env?.Bar?.[ok]?.i()?.[ok]
 $env?.Bar?.[ok]?.ok
+$env?.Bar?.[ok]?.str
 $env?.Bar?.[str]
+$env?.Bar?.[str].f64
+$env?.Bar?.[str].foo()
 $env?.Bar?.[str].i
+$env?.Bar?.[str].list
+$env?.Bar?.[str].ok(foobar)
+$env?.Bar?.[str].str
 $env?.Bar?.[str]?.[array]
 $env?.Bar?.[str]?.[foo]
+$env?.Bar?.[str]?.[greet]
 $env?.Bar?.[str]?.[i]
+$env?.Bar?.[str]?.[ok]?.greet
+$env?.Bar?.[str]?.add
+$env?.Bar?.[str]?.array
+$env?.Bar?.[str]?.f64
 $env?.Bar?.add
 $env?.Bar?.add not contains $env
 $env?.Bar?.add($env.foo).String
 $env?.Bar?.add()
 $env?.Bar?.add().f64
 $env?.Bar?.add().f64(foobar)
+$env?.Bar?.add()?.[array]
+$env?.Bar?.add()?.greet()
 $env?.Bar?.add()?.i()
+$env?.Bar?.add(Bar)
 $env?.Bar?.add(add)
+$env?.Bar?.add(f64)
+$env?.Bar?.add(foo)
+$env?.Bar?.add(foobar != 1)
 $env?.Bar?.add(foobar)
 $env?.Bar?.add(foobar?.Bar?.[list])
+$env?.Bar?.add(list)
+$env?.Bar?.add(ok)
+$env?.Bar?.add.Bar
+$env?.Bar?.add.f64()
+$env?.Bar?.add.foo
+$env?.Bar?.add.greet
 $env?.Bar?.add.i
 $env?.Bar?.add.list
+$env?.Bar?.add.ok
 $env?.Bar?.add.ok()
+$env?.Bar?.add?.Bar
+$env?.Bar?.add?.String
 $env?.Bar?.add?.[add]
+$env?.Bar?.add?.[foo]
 $env?.Bar?.add?.[greet]
+$env?.Bar?.add?.[list]
+$env?.Bar?.add?.[str]
+$env?.Bar?.add?.array
+$env?.Bar?.add?.greet
+$env?.Bar?.all(greet)
+$env?.Bar?.any(foo)
 $env?.Bar?.any(str)
 $env?.Bar?.array
 $env?.Bar?.array($env)
 $env?.Bar?.array()
+$env?.Bar?.array().f64
+$env?.Bar?.array()?.[str]
 $env?.Bar?.array(array)
 $env?.Bar?.array(f64)
 $env?.Bar?.array(foobar)
@@ -906,242 +2104,474 @@ $env?.Bar?.array(reduce(list, foobar))?.Bar
 $env?.Bar?.array(str)
 $env?.Bar?.array.Bar
 $env?.Bar?.array.array
+$env?.Bar?.array.i?.foo
+$env?.Bar?.array.list
 $env?.Bar?.array.list(string(list) endsWith foobar?.String)
 $env?.Bar?.array.str
+$env?.Bar?.array?.[add]
 $env?.Bar?.array?.[array]
 $env?.Bar?.array?.[f64]
 $env?.Bar?.array?.[foo]
 $env?.Bar?.array?.[str]
 $env?.Bar?.array?.array
+$env?.Bar?.array?.f64
 $env?.Bar?.array?.foo
+$env?.Bar?.array?.ok
+$env?.Bar?.array?.str
+$env?.Bar?.array?.str?.[array]
 $env?.Bar?.bitand(foobar)
 $env?.Bar?.bitnand(i, f64)
 $env?.Bar?.bitshl(str, foobar)
 $env?.Bar?.bitshr(foobar)
+$env?.Bar?.bitushr(Bar, str)
+$env?.Bar?.count(nil, nil)
 $env?.Bar?.f64
 $env?.Bar?.f64()
 $env?.Bar?.f64().add()
 $env?.Bar?.f64(1)
 $env?.Bar?.f64(Bar?.[ok])
+$env?.Bar?.f64(f64)
 $env?.Bar?.f64(foobar)
 $env?.Bar?.f64(foobar, foobar?.str())
+$env?.Bar?.f64(i == foobar not in nil)
+$env?.Bar?.f64(list)
+$env?.Bar?.f64(ok, foobar)
+$env?.Bar?.f64(str, foobar)
 $env?.Bar?.f64.Bar(0)
 $env?.Bar?.f64.array()
 $env?.Bar?.f64.list
 $env?.Bar?.f64?.Bar()
 $env?.Bar?.f64?.[f64]
+$env?.Bar?.f64?.[greet]
 $env?.Bar?.f64?.[i]
 $env?.Bar?.f64?.f64
 $env?.Bar?.f64?.list()
 $env?.Bar?.f64?.str
 $env?.Bar?.false?.[foo]
 $env?.Bar?.false?.list
+$env?.Bar?.filter(Bar)
+$env?.Bar?.filter(Bar, foobar)
+$env?.Bar?.filter(foo)
+$env?.Bar?.find(false)
+$env?.Bar?.find(foobar)
+$env?.Bar?.findIndex($env, foobar)
 $env?.Bar?.findIndex(false)
+$env?.Bar?.findLast($env)
 $env?.Bar?.findLastIndex(1, foobar)
+$env?.Bar?.findLastIndex(foo, foo)
+$env?.Bar?.findLastIndex(foobar, ok)
+$env?.Bar?.floor(ok, 1.0)
 $env?.Bar?.foo
 $env?.Bar?.foo not contains $env
 $env?.Bar?.foo($env matches foobar)
 $env?.Bar?.foo()
 $env?.Bar?.foo().greet.str
+$env?.Bar?.foo().i
+$env?.Bar?.foo()?.[add]
+$env?.Bar?.foo(Bar not matches foobar)
+$env?.Bar?.foo(f64)
 $env?.Bar?.foo(foobar)
 $env?.Bar?.foo(foobar, foobar)
+$env?.Bar?.foo(foobar?.list(foobar, array))
 $env?.Bar?.foo(i)
 $env?.Bar?.foo(list)
+$env?.Bar?.foo(str)
 $env?.Bar?.foo.Bar
+$env?.Bar?.foo.add
 $env?.Bar?.foo.array
+$env?.Bar?.foo.f64
+$env?.Bar?.foo.greet(greet)
+$env?.Bar?.foo.greet.i
 $env?.Bar?.foo.i
+$env?.Bar?.foo.list
 $env?.Bar?.foo?.Bar
+$env?.Bar?.foo?.[array]
+$env?.Bar?.foo?.[foo]
+$env?.Bar?.foo?.[i]
 $env?.Bar?.foo?.[ok]
+$env?.Bar?.foo?.add
+$env?.Bar?.foo?.i
 $env?.Bar?.foo?.str
 $env?.Bar?.foobar
+$env?.Bar?.foobar ?? foo
+$env?.Bar?.foobar.String.greet?.ok
 $env?.Bar?.foobar.add
+$env?.Bar?.foobar.add(foobar)
+$env?.Bar?.foobar.array
+$env?.Bar?.foobar.f64
 $env?.Bar?.foobar.foobar
 $env?.Bar?.foobar.i
+$env?.Bar?.foobar.i()
 $env?.Bar?.foobar.list
+$env?.Bar?.foobar.ok
 $env?.Bar?.foobar.str()?.ok
+$env?.Bar?.foobar?.Bar(Bar)
+$env?.Bar?.foobar?.String
+$env?.Bar?.foobar?.[f64]
+$env?.Bar?.foobar?.[foo]
 $env?.Bar?.foobar?.[i].String
 $env?.Bar?.foobar?.[list]
+$env?.Bar?.foobar?.array
+$env?.Bar?.foobar?.array(foobar)
+$env?.Bar?.foobar?.foo
 $env?.Bar?.foobar?.i
 $env?.Bar?.foobar?.list
+$env?.Bar?.foobar?.str
+$env?.Bar?.fromBase64(ok)
 $env?.Bar?.fromPairs(0)
 $env?.Bar?.greet
 $env?.Bar?.greet()
 $env?.Bar?.greet()?.String
+$env?.Bar?.greet(String not contains foo, foo)
+$env?.Bar?.greet(String)
 $env?.Bar?.greet(array)
 $env?.Bar?.greet(foo)
+$env?.Bar?.greet(foobar ?? String)
 $env?.Bar?.greet(foobar startsWith foobar)
+$env?.Bar?.greet(foobar | greet())
 $env?.Bar?.greet(foobar)
 $env?.Bar?.greet(foobar?.ok())
 $env?.Bar?.greet(ok)
+$env?.Bar?.greet(str)
 $env?.Bar?.greet.add()
 $env?.Bar?.greet.f64
 $env?.Bar?.greet.foo
+$env?.Bar?.greet.greet
+$env?.Bar?.greet?.[add]
 $env?.Bar?.greet?.[array]
+$env?.Bar?.greet?.[f64]
+$env?.Bar?.greet?.[i]
+$env?.Bar?.greet?.[i]?.f64
+$env?.Bar?.greet?.[ok]
+$env?.Bar?.greet?.add
+$env?.Bar?.greet?.array
 $env?.Bar?.greet?.foo
+$env?.Bar?.greet?.foo(foobar)?.str
+$env?.Bar?.greet?.greet()
 $env?.Bar?.greet?.i()
+$env?.Bar?.greet?.list
 $env?.Bar?.groupBy(add)
+$env?.Bar?.groupBy(true, foo)
 $env?.Bar?.i
+$env?.Bar?.i == 1.0
 $env?.Bar?.i()
+$env?.Bar?.i().foo
+$env?.Bar?.i()?.array
+$env?.Bar?.i(Bar, ok)
 $env?.Bar?.i(String)
+$env?.Bar?.i(foo.Bar)
+$env?.Bar?.i(foobar)
 $env?.Bar?.i(foobar?.[str])
+$env?.Bar?.i(foobar?.str().str)
 $env?.Bar?.i(list)
+$env?.Bar?.i(nil matches foobar)
+$env?.Bar?.i(nil, false)
+$env?.Bar?.i.Bar(1, nil)
 $env?.Bar?.i.array()
+$env?.Bar?.i.i
+$env?.Bar?.i.ok
+$env?.Bar?.i?.String
+$env?.Bar?.i?.String(foobar)
 $env?.Bar?.i?.[add]
 $env?.Bar?.i?.[greet]?.[array]
+$env?.Bar?.i?.[ok]
 $env?.Bar?.i?.array
 $env?.Bar?.i?.foo
+$env?.Bar?.i?.foo()
 $env?.Bar?.i?.ok
+$env?.Bar?.last(foobar)
+$env?.Bar?.len(add)
 $env?.Bar?.len(greet)
 $env?.Bar?.list
 $env?.Bar?.list()
 $env?.Bar?.list().ok
 $env?.Bar?.list()?.ok
+$env?.Bar?.list(1.0 startsWith foobar, foobar?.list)
+$env?.Bar?.list(Bar | type(nil))
 $env?.Bar?.list(f64)
 $env?.Bar?.list(foobar)
+$env?.Bar?.list(foobar?.i)
 $env?.Bar?.list(list)?.str
+$env?.Bar?.list(nil)
 $env?.Bar?.list(type(foobar))
 $env?.Bar?.list.Bar
+$env?.Bar?.list.String
+$env?.Bar?.list.array
+$env?.Bar?.list.f64()
 $env?.Bar?.list.foobar
+$env?.Bar?.list?.Bar
 $env?.Bar?.list?.String
+$env?.Bar?.list?.[array]
 $env?.Bar?.list?.[foo]?.String()?.list
+$env?.Bar?.list?.[greet]
 $env?.Bar?.list?.[list]
 $env?.Bar?.list?.add
 $env?.Bar?.list?.f64
 $env?.Bar?.list?.foo
 $env?.Bar?.list?.i
+$env?.Bar?.list?.str
 $env?.Bar?.map(foobar)
 $env?.Bar?.map(foobar, greet, String)
 $env?.Bar?.median(true, $env)
 $env?.Bar?.nil.array()
+$env?.Bar?.nil?.ok()
+$env?.Bar?.none(false, foobar)
+$env?.Bar?.none(foo)
 $env?.Bar?.none(foobar)
 $env?.Bar?.ok
 $env?.Bar?.ok()
+$env?.Bar?.ok().array
 $env?.Bar?.ok().greet
 $env?.Bar?.ok()?.f64
 $env?.Bar?.ok()?.list
+$env?.Bar?.ok(add)
 $env?.Bar?.ok(f64)
 $env?.Bar?.ok(foobar)
+$env?.Bar?.ok(foobar?.[array])
+$env?.Bar?.ok(foobar?.[f64])
+$env?.Bar?.ok(foobar?.foo)
 $env?.Bar?.ok(greet)
 $env?.Bar?.ok(list)
 $env?.Bar?.ok(str)
 $env?.Bar?.ok.String()
+$env?.Bar?.ok.f64
+$env?.Bar?.ok.f64(foobar?.[add]?.f64())
 $env?.Bar?.ok.greet
+$env?.Bar?.ok.i(add)
+$env?.Bar?.ok.list
+$env?.Bar?.ok.ok
 $env?.Bar?.ok.str
 $env?.Bar?.ok?.Bar
 $env?.Bar?.ok?.String
+$env?.Bar?.ok?.[add]
 $env?.Bar?.ok?.[array]
 $env?.Bar?.ok?.[f64]
+$env?.Bar?.ok?.[foo]
+$env?.Bar?.ok?.add
 $env?.Bar?.ok?.f64
 $env?.Bar?.ok?.foo
+$env?.Bar?.ok?.greet
+$env?.Bar?.ok?.i
 $env?.Bar?.ok?.str
+$env?.Bar?.one(array)
+$env?.Bar?.one(list)
 $env?.Bar?.reduce(foobar, foobar)
+$env?.Bar?.reduce(str)
 $env?.Bar?.reduce(true)
+$env?.Bar?.replace(str)
+$env?.Bar?.round(array)
 $env?.Bar?.round(foobar)
+$env?.Bar?.round(foobar, nil)
+$env?.Bar?.sort(list)?.Bar
 $env?.Bar?.sortBy($env, false)
 $env?.Bar?.sortBy(nil)
 $env?.Bar?.split(false)
 $env?.Bar?.str
 $env?.Bar?.str != ok
 $env?.Bar?.str()
+$env?.Bar?.str() endsWith str
+$env?.Bar?.str()?.[str]
 $env?.Bar?.str()?.f64
 $env?.Bar?.str()?.greet
 $env?.Bar?.str(1, foobar)
+$env?.Bar?.str(Bar)
 $env?.Bar?.str(add)
+$env?.Bar?.str(f64 in nil)
 $env?.Bar?.str(foobar)
+$env?.Bar?.str(foobar?.[foobar])
+$env?.Bar?.str(foobar?.array(String))
+$env?.Bar?.str(greet)
+$env?.Bar?.str(ok)
+$env?.Bar?.str.f64
 $env?.Bar?.str.foo
+$env?.Bar?.str.i
+$env?.Bar?.str.list
+$env?.Bar?.str?.Bar
+$env?.Bar?.str?.Bar()
 $env?.Bar?.str?.[foo]
 $env?.Bar?.str?.[greet]
 $env?.Bar?.str?.[ok]
 $env?.Bar?.str?.[str]
+$env?.Bar?.str?.[str]?.Bar
+$env?.Bar?.str?.[str]?.array
+$env?.Bar?.str?.array
+$env?.Bar?.str?.greet(foobar)
 $env?.Bar?.str?.i()
+$env?.Bar?.str?.list
+$env?.Bar?.str?.str()
 $env?.Bar?.string(foobar)
+$env?.Bar?.sum(f64)
+$env?.Bar?.sum(false)
+$env?.Bar?.toJSON(true)
+$env?.Bar?.true?.add
+$env?.Bar?.type(i)
 $env?.String != $env ? ok : true
+$env?.String != add
+$env?.String != array
+$env?.String != f64
+$env?.String != float(i)
 $env?.String != foo
+$env?.String != foo?.String
 $env?.String != greet
+$env?.String != i
 $env?.String != list
+$env?.String != list != true
+$env?.String != ok
 $env?.String != str
+$env?.String == $env?.list
+$env?.String == -1.0
+$env?.String == add
 $env?.String == array
 $env?.String == f64
+$env?.String == foo
 $env?.String == greet
 $env?.String == i
 $env?.String == list
 $env?.String == str
+$env?.String ?? add
+$env?.String ?? array
+$env?.String ?? foo
+$env?.String ?? greet
+$env?.String ?? list
+$env?.String ?? str
+$env?.String ?? toJSON(1.0)
+$env?.String contains 0 ?? greet
 $env?.String contains str
 $env?.String endsWith $env && $env
 $env?.String endsWith str
 $env?.String in $env ? 1 : true
+$env?.String in $env ?? greet
 $env?.String in array
 $env?.String in list
+$env?.String matches $env ?: foo
 $env?.String matches $env?.nil
 $env?.String matches str
 $env?.String not contains str
 $env?.String not endsWith $env and $env
 $env?.String not endsWith $env.str
+$env?.String not endsWith str
 $env?.String not in $env?.Bar?.array
 $env?.String not in array
 $env?.String not in list
+$env?.String not in values($env)
 $env?.String not matches $env?.[String]
+$env?.String not matches foo.String()
+$env?.String not matches str
 $env?.String not startsWith str
 $env?.String startsWith str
+$env?.String startsWith toJSON(foo)
+$env?.String | get(1.0)
+$env?.String | get(false)
+$env?.String() == 1 || true
 $env?.String?.$env != true
+$env?.String?.$env.foo
 $env?.String?.Bar
 $env?.String?.Bar()
 $env?.String?.Bar(String)
 $env?.String?.Bar(add)
+$env?.String?.Bar(f64)
+$env?.String?.Bar(foo, ok)
 $env?.String?.Bar(foobar)
+$env?.String?.Bar(greet != foobar)
 $env?.String?.Bar(ok)
 $env?.String?.Bar.String
 $env?.String?.Bar.add
 $env?.String?.Bar.add()
 $env?.String?.Bar.i
 $env?.String?.Bar.list
+$env?.String?.Bar.ok
 $env?.String?.Bar.str
+$env?.String?.Bar?.Bar?.[ok]
 $env?.String?.Bar?.String
+$env?.String?.Bar?.[f64]
 $env?.String?.Bar?.[greet]
+$env?.String?.Bar?.[list]
 $env?.String?.Bar?.[ok]
+$env?.String?.Bar?.add
+$env?.String?.Bar?.greet
+$env?.String?.Bar?.greet()
 $env?.String?.Bar?.i
+$env?.String?.Bar?.ok
 $env?.String?.Bar?.str
 $env?.String?.String
 $env?.String?.String()
+$env?.String?.String().array
+$env?.String?.String(foobar not matches Bar)
 $env?.String?.String(foobar)
+$env?.String?.String(foobar, foobar)
+$env?.String?.String(i)
 $env?.String?.String(str)
 $env?.String?.String.add.f64
 $env?.String?.String.f64
 $env?.String?.String.i
+$env?.String?.String.list
 $env?.String?.String.ok
 $env?.String?.String?.[foo]
+$env?.String?.String?.[greet]
+$env?.String?.String?.[i]
+$env?.String?.String?.[list].ok
+$env?.String?.String?.add
 $env?.String?.String?.f64
 $env?.String?.String?.foo
 $env?.String?.String?.greet
+$env?.String?.String?.list
 $env?.String?.String?.one(foobar?.list)
+$env?.String?.[$env or $env]
+$env?.String?.[$env | count(true)]
+$env?.String?.[$env.f64]
 $env?.String?.[$env?.[f64]]
 $env?.String?.[add]
 $env?.String?.[add] != greet
+$env?.String?.[add].Bar
 $env?.String?.[add].array
+$env?.String?.[add].greet
 $env?.String?.[add].i
+$env?.String?.[add].ok
 $env?.String?.[add]?.Bar?.array
 $env?.String?.[add]?.[f64]
+$env?.String?.[add]?.[foo]
 $env?.String?.[add]?.[i]
 $env?.String?.[add]?.[list]
 $env?.String?.[array]
+$env?.String?.[array].Bar
 $env?.String?.[array].f64
 $env?.String?.[array].f64()
+$env?.String?.[array].greet
 $env?.String?.[array].str
+$env?.String?.[array]?.Bar
+$env?.String?.[array]?.String
+$env?.String?.[array]?.[add]
+$env?.String?.[array]?.[array]
+$env?.String?.[array]?.[f64]
+$env?.String?.[array]?.[list]
+$env?.String?.[array]?.add
 $env?.String?.[array]?.array
+$env?.String?.[array]?.foo
 $env?.String?.[array]?.foo()
 $env?.String?.[f64]
 $env?.String?.[f64].add
+$env?.String?.[f64].array
 $env?.String?.[f64].foobar
+$env?.String?.[f64].greet
+$env?.String?.[f64].i()
 $env?.String?.[f64]?.Bar
 $env?.String?.[f64]?.String
+$env?.String?.[f64]?.[f64]
+$env?.String?.[f64]?.[list]
 $env?.String?.[f64]?.[str]
 $env?.String?.[f64]?.array
 $env?.String?.[f64]?.greet
 $env?.String?.[f64]?.list
+$env?.String?.[f64]?.list()
+$env?.String?.[f64]?.ok
+$env?.String?.[f64]?.str()
+$env?.String?.[findLast($env, .list)]
 $env?.String?.[foo]
 $env?.String?.[foo].array
+$env?.String?.[foo].f64
 $env?.String?.[foo].f64()
 $env?.String?.[foo].i
+$env?.String?.[foo]?.String
 $env?.String?.[foo]?.[foo]
 $env?.String?.[foo]?.[i]
 $env?.String?.[foo]?.add
@@ -1149,60 +2579,99 @@ $env?.String?.[foo]?.foo
 $env?.String?.[foo]?.i
 $env?.String?.[foo]?.list
 $env?.String?.[foo]?.ok
+$env?.String?.[foo]?.ok()
+$env?.String?.[foo]?.str
 $env?.String?.[greet]
+$env?.String?.[greet] not in array
 $env?.String?.[greet].add
 $env?.String?.[greet].any(foobar).str
 $env?.String?.[greet].array
+$env?.String?.[greet]?.[add]
 $env?.String?.[greet]?.[list]
 $env?.String?.[greet]?.f64
+$env?.String?.[greet]?.greet()
 $env?.String?.[greet]?.list
+$env?.String?.[greet]?.ok
 $env?.String?.[i]
+$env?.String?.[i].Bar
 $env?.String?.[i].f64
 $env?.String?.[i].f64()
 $env?.String?.[i].foo
 $env?.String?.[i].list
+$env?.String?.[i]?.String
 $env?.String?.[i]?.[array]
 $env?.String?.[i]?.[foo]
 $env?.String?.[i]?.[greet]
 $env?.String?.[i]?.add
 $env?.String?.[i]?.array
 $env?.String?.[i]?.foo
+$env?.String?.[i]?.list
+$env?.String?.[i]?.str
 $env?.String?.[i]?.str()
 $env?.String?.[list]
 $env?.String?.[list].array
+$env?.String?.[list].f64
 $env?.String?.[list].foo
 $env?.String?.[list].list
+$env?.String?.[list].ok
 $env?.String?.[list].ok()
+$env?.String?.[list].str
 $env?.String?.[list]?.[list]
 $env?.String?.[list]?.[str]
 $env?.String?.[list]?.add
 $env?.String?.[list]?.list(foobar)
+$env?.String?.[list]?.ok
 $env?.String?.[ok]
 $env?.String?.[ok].Bar
 $env?.String?.[ok].add
+$env?.String?.[ok].list()
+$env?.String?.[ok]?.Bar
 $env?.String?.[ok]?.Bar.str
+$env?.String?.[ok]?.[array]
+$env?.String?.[ok]?.[f64]?.foo
 $env?.String?.[ok]?.[i]
 $env?.String?.[ok]?.[ok]
 $env?.String?.[ok]?.[str]
+$env?.String?.[ok]?.add
+$env?.String?.[ok]?.add()
+$env?.String?.[ok]?.foo()
 $env?.String?.[ok]?.greet
 $env?.String?.[ok]?.ok
 $env?.String?.[str]
+$env?.String?.[str] != lower(str)
 $env?.String?.[str].foo
 $env?.String?.[str].str()
 $env?.String?.[str]?.[array]
 $env?.String?.[str]?.[list]
 $env?.String?.[str]?.array
 $env?.String?.[str]?.f64
+$env?.String?.[str]?.foo()
 $env?.String?.[str]?.str(str)
+$env?.String?.[sum($env)]
+$env?.String?.abs(1.0)
 $env?.String?.add
 $env?.String?.add()
 $env?.String?.add()?.[i]
 $env?.String?.add(Bar)
 $env?.String?.add(f64 not endsWith nil)
+$env?.String?.add(f64)
+$env?.String?.add(foobar)
+$env?.String?.add(foobar).i
+$env?.String?.add(foobar, ceil(abs(foobar, 1)))
+$env?.String?.add(ok)
+$env?.String?.add(str)
+$env?.String?.add.f64
+$env?.String?.add.ok
 $env?.String?.add.ok()
+$env?.String?.add?.Bar
+$env?.String?.add?.[array]
 $env?.String?.add?.[f64]
+$env?.String?.add?.[greet]
 $env?.String?.add?.[ok]
+$env?.String?.add?.[str]
+$env?.String?.add?.add
 $env?.String?.add?.array
+$env?.String?.add?.f64
 $env?.String?.add?.greet
 $env?.String?.add?.i(f64)
 $env?.String?.add?.list
@@ -1212,177 +2681,319 @@ $env?.String?.all(1.0, true)
 $env?.String?.all(foobar)
 $env?.String?.all(nil, nil)
 $env?.String?.all(ok, nil)
+$env?.String?.any(f64)?.[foo]
 $env?.String?.any(foo)
+$env?.String?.any(foobar, foobar, foobar)
 $env?.String?.array
 $env?.String?.array not endsWith str
 $env?.String?.array()
 $env?.String?.array()?.[f64]
 $env?.String?.array(String)
+$env?.String?.array(add)
 $env?.String?.array(array matches nil)
+$env?.String?.array(foo)
+$env?.String?.array(foobar and true)
+$env?.String?.array(foobar)
 $env?.String?.array(i)
 $env?.String?.array(str not in String)
 $env?.String?.array.Bar
 $env?.String?.array.String
+$env?.String?.array.add
+$env?.String?.array.array
 $env?.String?.array.f64
 $env?.String?.array.foo
 $env?.String?.array.list
+$env?.String?.array.ok
+$env?.String?.array?.Bar
+$env?.String?.array?.Bar?.list
 $env?.String?.array?.String
+$env?.String?.array?.[array]
+$env?.String?.array?.[str]
 $env?.String?.array?.array()
 $env?.String?.array?.f64
 $env?.String?.array?.f64.list()
+$env?.String?.array?.i.foo
 $env?.String?.array?.ok
 $env?.String?.bitshl(String)
 $env?.String?.bitshr(nil, f64)
 $env?.String?.bitushr(str, foobar)
 $env?.String?.bitxor(String)
+$env?.String?.date(foobar, foobar)
 $env?.String?.duration(foobar)
 $env?.String?.f64
+$env?.String?.f64 == i
 $env?.String?.f64()
+$env?.String?.f64().f64
+$env?.String?.f64()?.String
 $env?.String?.f64()?.[i]
 $env?.String?.f64()?.[str]
+$env?.String?.f64(1.0 ?? nil)
+$env?.String?.f64(String)
 $env?.String?.f64(foobar)
+$env?.String?.f64(foobar)?.greet
 $env?.String?.f64(foobar, foobar)
+$env?.String?.f64(foobar?.[0])
 $env?.String?.f64(i)
 $env?.String?.f64(list)
 $env?.String?.f64(nil == f64)
+$env?.String?.f64.String?.greet
 $env?.String?.f64.f64
+$env?.String?.f64.greet
 $env?.String?.f64.list
+$env?.String?.f64.list()
 $env?.String?.f64.ok
 $env?.String?.f64.str(foobar, foobar)?.[add]
+$env?.String?.f64?.String
 $env?.String?.f64?.[array]
 $env?.String?.f64?.[greet]
+$env?.String?.f64?.[ok]
+$env?.String?.f64?.add
 $env?.String?.f64?.list?.[str]
 $env?.String?.f64?.ok
+$env?.String?.false?.add()
+$env?.String?.filter(str)
 $env?.String?.findIndex($env)
 $env?.String?.findIndex(f64, foobar)
 $env?.String?.findIndex(foobar)
+$env?.String?.findIndex(nil)
 $env?.String?.findLast(greet, nil)
+$env?.String?.flatten(f64)
+$env?.String?.flatten(foobar, foobar)
+$env?.String?.float($env)
 $env?.String?.foo
 $env?.String?.foo($env)
 $env?.String?.foo()
 $env?.String?.foo()?.[i]
+$env?.String?.foo(add)
+$env?.String?.foo(f64)
+$env?.String?.foo(false ?? add)
 $env?.String?.foo(foo)
+$env?.String?.foo(foobar)
+$env?.String?.foo(foobar?.greet)
 $env?.String?.foo(greet)
 $env?.String?.foo(list, 1)
 $env?.String?.foo(ok)
+$env?.String?.foo.array
 $env?.String?.foo.i
+$env?.String?.foo.ok()
+$env?.String?.foo?.Bar
 $env?.String?.foo?.[f64]
 $env?.String?.foo?.[i]
 $env?.String?.foo?.[ok]
 $env?.String?.foo?.[ok].f64()
+$env?.String?.foo?.[str]
+$env?.String?.foo?.add
+$env?.String?.foo?.f64
 $env?.String?.foo?.greet
+$env?.String?.foo?.i
 $env?.String?.foobar
+$env?.String?.foobar ?? add
 $env?.String?.foobar in array
+$env?.String?.foobar.String(greet)
+$env?.String?.foobar.add
 $env?.String?.foobar.f64
 $env?.String?.foobar.foo
 $env?.String?.foobar.greet
+$env?.String?.foobar.str()
 $env?.String?.foobar?.[add]
+$env?.String?.foobar?.[array]
 $env?.String?.foobar?.[list]
 $env?.String?.foobar?.add()
 $env?.String?.foobar?.foo()
+$env?.String?.foobar?.foo(i)
 $env?.String?.get(nil)
 $env?.String?.greet
+$env?.String?.greet($env)
 $env?.String?.greet()
 $env?.String?.greet().Bar
 $env?.String?.greet().foo
+$env?.String?.greet()?.String
 $env?.String?.greet()?.[i]
+$env?.String?.greet(0)
+$env?.String?.greet(String)
 $env?.String?.greet(foobar == String)
+$env?.String?.greet(foobar and true)
 $env?.String?.greet(foobar or true)
 $env?.String?.greet(foobar)
+$env?.String?.greet(foobar?.String)
+$env?.String?.greet(i)
+$env?.String?.greet(nil)
+$env?.String?.greet(ok)
+$env?.String?.greet(str)
 $env?.String?.greet.add
 $env?.String?.greet.i
 $env?.String?.greet?.[array]
 $env?.String?.greet?.[list]
 $env?.String?.greet?.[ok]
 $env?.String?.greet?.foo
+$env?.String?.greet?.greet()
 $env?.String?.greet?.i
 $env?.String?.greet?.list
+$env?.String?.groupBy(nil)
+$env?.String?.groupBy(str, foobar)
 $env?.String?.i
 $env?.String?.i()
+$env?.String?.i().add
+$env?.String?.i()?.add
+$env?.String?.i()?.i
 $env?.String?.i(0).f64
 $env?.String?.i(1)
+$env?.String?.i(Bar)?.[array]
 $env?.String?.i(String?.$env)
 $env?.String?.i(array)
 $env?.String?.i(f64)
 $env?.String?.i(foobar)
+$env?.String?.i.Bar
 $env?.String?.i.add
 $env?.String?.i.foo
 $env?.String?.i.foobar
 $env?.String?.i.str
+$env?.String?.i?.Bar
 $env?.String?.i?.String
 $env?.String?.i?.[f64]
+$env?.String?.i?.add
+$env?.String?.i?.foo
 $env?.String?.i?.ok
 $env?.String?.int(add, foobar, greet)
 $env?.String?.join(true, f64)
+$env?.String?.keys(0, 0)
+$env?.String?.last(foo)
 $env?.String?.list
 $env?.String?.list()
+$env?.String?.list()?.[i]
+$env?.String?.list(1.0, foobar, greet)
 $env?.String?.list(false)
+$env?.String?.list(foobar not endsWith greet)
+$env?.String?.list(foobar?.f64())
 $env?.String?.list(ok)
+$env?.String?.list.String()
 $env?.String?.list.array()
+$env?.String?.list.str
+$env?.String?.list?.[add]
 $env?.String?.list?.[i]
+$env?.String?.list?.[list]
 $env?.String?.list?.[str]
+$env?.String?.list?.add
 $env?.String?.list?.f64
 $env?.String?.list?.list
 $env?.String?.list?.str
+$env?.String?.lower(0)
+$env?.String?.map($env)
+$env?.String?.map(false)
+$env?.String?.map(foo)
 $env?.String?.map(nil, String)
+$env?.String?.mean(add)
 $env?.String?.nil endsWith str
+$env?.String?.nil?.foo
 $env?.String?.not
+$env?.String?.not .array
 $env?.String?.ok
 $env?.String?.ok()
+$env?.String?.ok()?.Bar
+$env?.String?.ok(array)
+$env?.String?.ok(foo)
 $env?.String?.ok(foobar not endsWith add)
 $env?.String?.ok(foobar)
+$env?.String?.ok(foobar?.[foo])
 $env?.String?.ok(nil)
 $env?.String?.ok.Bar()
 $env?.String?.ok.array
 $env?.String?.ok.f64
 $env?.String?.ok.foo
+$env?.String?.ok.foo()
 $env?.String?.ok.greet
 $env?.String?.ok.list
 $env?.String?.ok?.Bar
 $env?.String?.ok?.[array]
 $env?.String?.ok?.[list]
 $env?.String?.ok?.[ok]
+$env?.String?.ok?.[str]
+$env?.String?.ok?.f64
+$env?.String?.ok?.i
+$env?.String?.ok?.i(foobar)
 $env?.String?.ok?.str
+$env?.String?.reverse(greet)
 $env?.String?.round(foobar, foobar)
 $env?.String?.sortBy(foobar)
+$env?.String?.sortBy(true)
 $env?.String?.str
+$env?.String?.str($env)
 $env?.String?.str()
+$env?.String?.str().String
+$env?.String?.str()?.[f64]
+$env?.String?.str()?.add
+$env?.String?.str()?.ok
+$env?.String?.str(foo?.String)
 $env?.String?.str(foobar)
+$env?.String?.str(i)
 $env?.String?.str.Bar
 $env?.String?.str.add()
+$env?.String?.str.greet(foobar, foobar)
 $env?.String?.str.list
 $env?.String?.str.str
 $env?.String?.str?.Bar
 $env?.String?.str?.String
 $env?.String?.str?.[greet]
 $env?.String?.str?.[str]
+$env?.String?.str?.f64
+$env?.String?.str?.greet
+$env?.String?.str?.greet()
 $env?.String?.str?.i
 $env?.String?.str?.ok
 $env?.String?.sum(1.0)
 $env?.String?.toPairs(Bar)
 $env?.String?.true.array
+$env?.String?.true?.[list]
 $env?.[1.0]?.foobar and false
+$env?.[Bar] != $env.i
+$env?.[Bar] != $env?.list
+$env?.[Bar] != 1.0 && $env
 $env?.[Bar] != 1.0 + 1.0
 $env?.[Bar] != add
 $env?.[Bar] != array
+$env?.[Bar] != f64
 $env?.[Bar] != foo
+$env?.[Bar] != foo.Bar
 $env?.[Bar] != greet
 $env?.[Bar] != i
+$env?.[Bar] != i - 1.0
 $env?.[Bar] != list
+$env?.[Bar] != min(f64)
+$env?.[Bar] != not true
 $env?.[Bar] != ok
 $env?.[Bar] != str
 $env?.[Bar] != str != true
 $env?.[Bar] != string(false)
 $env?.[Bar] < i || true
 $env?.[Bar] == $env.array
+$env?.[Bar] == $env?.[str]
 $env?.[Bar] == add
 $env?.[Bar] == array
+$env?.[Bar] == count(array, ok)
+$env?.[Bar] == f64
 $env?.[Bar] == foo
+$env?.[Bar] == foo?.Bar
 $env?.[Bar] == greet ? 0 : true
+$env?.[Bar] == greet or ok
+$env?.[Bar] == i
 $env?.[Bar] == list
 $env?.[Bar] == ok
+$env?.[Bar] == str
+$env?.[Bar] ?? add
+$env?.[Bar] ?? array
+$env?.[Bar] ?? f64
+$env?.[Bar] ?? foo
+$env?.[Bar] ?? foo?.Bar
+$env?.[Bar] ?? greet ?? str
+$env?.[Bar] ?? i
+$env?.[Bar] ?? list
+$env?.[Bar] ?? ok
+$env?.[Bar] ?? str
 $env?.[Bar] and true and false
+$env?.[Bar] contains $env ?? nil
+$env?.[Bar] contains foo.Bar
 $env?.[Bar] contains last($env)
+$env?.[Bar] contains nil ?? $env
 $env?.[Bar] contains str
 $env?.[Bar] endsWith str
 $env?.[Bar] in $env?.nil?.add
@@ -1392,32 +3003,68 @@ $env?.[Bar] matches $env?.str
 $env?.[Bar] matches str
 $env?.[Bar] not contains $env.str
 $env?.[Bar] not contains $env?.Bar
+$env?.[Bar] not contains $env?.String
+$env?.[Bar] not contains greet(str)
 $env?.[Bar] not contains str
+$env?.[Bar] not endsWith $env || false
+$env?.[Bar] not endsWith greet(str)
+$env?.[Bar] not endsWith str
+$env?.[Bar] not in $env?.[foobar]
+$env?.[Bar] not in array
 $env?.[Bar] not in list
+$env?.[Bar] not matches foo.Bar
 $env?.[Bar] not matches str
+$env?.[Bar] not matches string(1.0)
 $env?.[Bar] not startsWith $env?.[String]
 $env?.[Bar] not startsWith foo.Bar
 $env?.[Bar] not startsWith str
 $env?.[Bar] not startsWith str != nil
 $env?.[Bar] startsWith str
+$env?.[Bar] | get($env)
+$env?.[Bar] | get(1.0)
+$env?.[Bar] | get(list)
 $env?.[Bar]?.$env?.[f64]
 $env?.[Bar]?.$env?.[foo].Bar
+$env?.[Bar]?.$env?.array()
+$env?.[Bar]?.$env?.str
 $env?.[Bar]?.Bar
 $env?.[Bar]?.Bar($env)
 $env?.[Bar]?.Bar()
+$env?.[Bar]?.Bar().ok
+$env?.[Bar]?.Bar()?.[i]
+$env?.[Bar]?.Bar()?.greet()
 $env?.[Bar]?.Bar(0)?.foo
 $env?.[Bar]?.Bar(Bar not contains f64)
+$env?.[Bar]?.Bar(Bar?.ok)
+$env?.[Bar]?.Bar(String?.ok(foobar))
+$env?.[Bar]?.Bar(add)
 $env?.[Bar]?.Bar(foo)
+$env?.[Bar]?.Bar(foo, foobar)
 $env?.[Bar]?.Bar(foobar)
+$env?.[Bar]?.Bar(greet)
+$env?.[Bar]?.Bar(nil)
+$env?.[Bar]?.Bar(ok)
 $env?.[Bar]?.Bar.add
 $env?.[Bar]?.Bar.greet
+$env?.[Bar]?.Bar.str
+$env?.[Bar]?.Bar?.[add]
+$env?.[Bar]?.Bar?.[array]
+$env?.[Bar]?.Bar?.[list]?.array
+$env?.[Bar]?.Bar?.f64
+$env?.[Bar]?.Bar?.foo
+$env?.[Bar]?.Bar?.i
 $env?.[Bar]?.Bar?.list
+$env?.[Bar]?.Bar?.str
 $env?.[Bar]?.String
 $env?.[Bar]?.String()
+$env?.[Bar]?.String().foo
+$env?.[Bar]?.String().ok
 $env?.[Bar]?.String(f64)
 $env?.[Bar]?.String(foobar not contains foobar?.String)
 $env?.[Bar]?.String(foobar)
 $env?.[Bar]?.String(str)
+$env?.[Bar]?.String(str).i
+$env?.[Bar]?.String.foobar
 $env?.[Bar]?.String.greet
 $env?.[Bar]?.String.i
 $env?.[Bar]?.String?.Bar
@@ -1434,72 +3081,115 @@ $env?.[Bar]?.String?.i()
 $env?.[Bar]?.String?.i(false)
 $env?.[Bar]?.String?.list
 $env?.[Bar]?.String?.ok
+$env?.[Bar]?.String?.str
+$env?.[Bar]?.[$env % 1]?.[f64]
+$env?.[Bar]?.[$env | none(.array)]
 $env?.[Bar]?.[$env?.array]
+$env?.[Bar]?.[add ?? 1]
 $env?.[Bar]?.[add]
+$env?.[Bar]?.[add].Bar
 $env?.[Bar]?.[add].Bar()
+$env?.[Bar]?.[add].Bar()?.[list]
 $env?.[Bar]?.[add].f64
 $env?.[Bar]?.[add].foo
 $env?.[Bar]?.[add].greet
+$env?.[Bar]?.[add].list
 $env?.[Bar]?.[add].ok
 $env?.[Bar]?.[add].str
 $env?.[Bar]?.[add]?.[list]
 $env?.[Bar]?.[add]?.[ok]
+$env?.[Bar]?.[add]?.array
 $env?.[Bar]?.[add]?.i
 $env?.[Bar]?.[add]?.list
+$env?.[Bar]?.[add]?.ok
 $env?.[Bar]?.[array]
+$env?.[Bar]?.[array].Bar
 $env?.[Bar]?.[array].String
 $env?.[Bar]?.[array].String()
 $env?.[Bar]?.[array].add()
 $env?.[Bar]?.[array].f64
+$env?.[Bar]?.[array].f64()
 $env?.[Bar]?.[array].foo
 $env?.[Bar]?.[array].greet
 $env?.[Bar]?.[array].i
+$env?.[Bar]?.[array]?.Bar
+$env?.[Bar]?.[array]?.[array]
+$env?.[Bar]?.[array]?.[i]
+$env?.[Bar]?.[array]?.[ok]
 $env?.[Bar]?.[array]?.f64
 $env?.[Bar]?.[array]?.foo
 $env?.[Bar]?.[count($env)]
 $env?.[Bar]?.[count(list)]
+$env?.[Bar]?.[date(ok, false)]
 $env?.[Bar]?.[f64]
 $env?.[Bar]?.[f64] != i
+$env?.[Bar]?.[f64].Bar
 $env?.[Bar]?.[f64].array
+$env?.[Bar]?.[f64].array()?.list
 $env?.[Bar]?.[f64].f64
+$env?.[Bar]?.[f64].greet
 $env?.[Bar]?.[f64].str
 $env?.[Bar]?.[f64]?.Bar
 $env?.[Bar]?.[f64]?.[add]
 $env?.[Bar]?.[f64]?.[ok]
+$env?.[Bar]?.[f64]?.add(foobar, Bar)
 $env?.[Bar]?.[f64]?.array
 $env?.[Bar]?.[f64]?.f64()
 $env?.[Bar]?.[f64]?.foo()
+$env?.[Bar]?.[f64]?.i?.[f64]
 $env?.[Bar]?.[f64]?.none(foobar)
+$env?.[Bar]?.[f64]?.ok
+$env?.[Bar]?.[f64]?.str
 $env?.[Bar]?.[foo == foo]
 $env?.[Bar]?.[foo]
+$env?.[Bar]?.[foo].String
 $env?.[Bar]?.[foo].foo()
 $env?.[Bar]?.[foo].greet
 $env?.[Bar]?.[foo].i
+$env?.[Bar]?.[foo].ok
+$env?.[Bar]?.[foo]?.Bar(f64)
 $env?.[Bar]?.[foo]?.[f64]
 $env?.[Bar]?.[foo]?.[foo]
 $env?.[Bar]?.[foo]?.[list]
+$env?.[Bar]?.[foo]?.[list].greet
+$env?.[Bar]?.[foo]?.f64
+$env?.[Bar]?.[foo]?.findLast(list, foobar)
 $env?.[Bar]?.[foo]?.ok()
 $env?.[Bar]?.[foo]?.str
 $env?.[Bar]?.[greet]
+$env?.[Bar]?.[greet] == str
 $env?.[Bar]?.[greet].array
 $env?.[Bar]?.[greet].array()
 $env?.[Bar]?.[greet].i
 $env?.[Bar]?.[greet].i()
+$env?.[Bar]?.[greet].list
+$env?.[Bar]?.[greet].ok
 $env?.[Bar]?.[greet].str
 $env?.[Bar]?.[greet]?.String
+$env?.[Bar]?.[greet]?.[f64]
+$env?.[Bar]?.[greet]?.[str]
 $env?.[Bar]?.[greet]?.add()
 $env?.[Bar]?.[greet]?.array()
+$env?.[Bar]?.[greet]?.foo
 $env?.[Bar]?.[greet]?.i
 $env?.[Bar]?.[greet]?.str
+$env?.[Bar]?.[greet]?.str()
 $env?.[Bar]?.[groupBy($env, #)]?.[str]
 $env?.[Bar]?.[i]
 $env?.[Bar]?.[i].Bar
 $env?.[Bar]?.[i].Bar()
+$env?.[Bar]?.[i].array
+$env?.[Bar]?.[i].greet
+$env?.[Bar]?.[i].i()
+$env?.[Bar]?.[i].list
 $env?.[Bar]?.[i].str
 $env?.[Bar]?.[i]?.String
+$env?.[Bar]?.[i]?.[i]
 $env?.[Bar]?.[i]?.[list]
 $env?.[Bar]?.[i]?.[ok]
 $env?.[Bar]?.[i]?.array
+$env?.[Bar]?.[i]?.f64
+$env?.[Bar]?.[i]?.foo
 $env?.[Bar]?.[i]?.i
 $env?.[Bar]?.[i]?.str
 $env?.[Bar]?.[list]
@@ -1511,38 +3201,61 @@ $env?.[Bar]?.[list].foo
 $env?.[Bar]?.[list].greet
 $env?.[Bar]?.[list].ok
 $env?.[Bar]?.[list].ok()
+$env?.[Bar]?.[list].str(foobar)
 $env?.[Bar]?.[list]?.String
 $env?.[Bar]?.[list]?.[array]
 $env?.[Bar]?.[list]?.[greet]?.list
 $env?.[Bar]?.[list]?.[i]
 $env?.[Bar]?.[list]?.[list]
+$env?.[Bar]?.[list]?.[ok]
+$env?.[Bar]?.[list]?.add()
 $env?.[Bar]?.[list]?.f64
 $env?.[Bar]?.[list]?.foo
 $env?.[Bar]?.[list]?.i
+$env?.[Bar]?.[list]?.str()
+$env?.[Bar]?.[nil != 0]
 $env?.[Bar]?.[ok]
 $env?.[Bar]?.[ok].f64
 $env?.[Bar]?.[ok].foo()
+$env?.[Bar]?.[ok]?.[greet]
 $env?.[Bar]?.[ok]?.[i]
+$env?.[Bar]?.[ok]?.foo
 $env?.[Bar]?.[ok]?.foo()
 $env?.[Bar]?.[ok]?.i
 $env?.[Bar]?.[ok]?.ok
+$env?.[Bar]?.[ok]?.str
 $env?.[Bar]?.[str]
+$env?.[Bar]?.[str].Bar
+$env?.[Bar]?.[str].String
+$env?.[Bar]?.[str].greet()
+$env?.[Bar]?.[str].i
 $env?.[Bar]?.[str].ok
 $env?.[Bar]?.[str]?.[array]
+$env?.[Bar]?.[str]?.[f64]
+$env?.[Bar]?.[str]?.[foo]?.ok
+$env?.[Bar]?.[str]?.i()
 $env?.[Bar]?.[str]?.ok()
+$env?.[Bar]?.[sum($env, str)]
 $env?.[Bar]?.abs(nil, ok)?.[ok]
 $env?.[Bar]?.add
 $env?.[Bar]?.add()
+$env?.[Bar]?.add() == add
 $env?.[Bar]?.add().str
 $env?.[Bar]?.add()?.[f64]
 $env?.[Bar]?.add(1)
 $env?.[Bar]?.add(Bar)
+$env?.[Bar]?.add(String, foo, 1.0 | int(String, 1.0))
 $env?.[Bar]?.add(add)
 $env?.[Bar]?.add(array)
 $env?.[Bar]?.add(foo)
 $env?.[Bar]?.add(foobar)
+$env?.[Bar]?.add(foobar?.[add])
+$env?.[Bar]?.add(list)
+$env?.[Bar]?.add(str == foobar?.greet(foobar))
+$env?.[Bar]?.add.Bar
 $env?.[Bar]?.add.String()
 $env?.[Bar]?.add.add
+$env?.[Bar]?.add.get(foobar?.str())
 $env?.[Bar]?.add.greet
 $env?.[Bar]?.add.i
 $env?.[Bar]?.add.not
@@ -1552,43 +3265,69 @@ $env?.[Bar]?.add?.Bar()
 $env?.[Bar]?.add?.[add]
 $env?.[Bar]?.add?.[foo]
 $env?.[Bar]?.add?.[ok]
+$env?.[Bar]?.add?.array
 $env?.[Bar]?.add?.join(foobar, str)
+$env?.[Bar]?.all($env)
 $env?.[Bar]?.any(foo)
 $env?.[Bar]?.any(foobar, foobar)
 $env?.[Bar]?.array
 $env?.[Bar]?.array()
 $env?.[Bar]?.array().ok
 $env?.[Bar]?.array()?.list
+$env?.[Bar]?.array(1 != foo)
 $env?.[Bar]?.array(Bar, array)
 $env?.[Bar]?.array(add) == greet
+$env?.[Bar]?.array(add, foobar)
+$env?.[Bar]?.array(f64)
+$env?.[Bar]?.array(foo)
+$env?.[Bar]?.array(foobar endsWith 1.0)
 $env?.[Bar]?.array(foobar)
 $env?.[Bar]?.array(foobar, f64, i)
 $env?.[Bar]?.array(foobar?.ok)
+$env?.[Bar]?.array(greet)
 $env?.[Bar]?.array(sort(foobar))
+$env?.[Bar]?.array.Bar
 $env?.[Bar]?.array.String()
 $env?.[Bar]?.array.add
+$env?.[Bar]?.array.f64
 $env?.[Bar]?.array.list()
 $env?.[Bar]?.array?.[add]
+$env?.[Bar]?.array?.[add]?.foo
 $env?.[Bar]?.array?.[array]
+$env?.[Bar]?.array?.[greet]
 $env?.[Bar]?.array?.[list]
+$env?.[Bar]?.array?.list
 $env?.[Bar]?.bitxor(ok)
 $env?.[Bar]?.concat(i, 0)
 $env?.[Bar]?.f64
 $env?.[Bar]?.f64()
+$env?.[Bar]?.f64().array
+$env?.[Bar]?.f64()?.f64?.[greet]
 $env?.[Bar]?.f64()?.ok
+$env?.[Bar]?.f64(1.0 != foo)
+$env?.[Bar]?.f64(Bar?.ok?.greet)
 $env?.[Bar]?.f64(add)
+$env?.[Bar]?.f64(foo)
 $env?.[Bar]?.f64(foobar in foobar)?.[add]
+$env?.[Bar]?.f64(foobar, ok)
+$env?.[Bar]?.f64(greet)
 $env?.[Bar]?.f64.String
 $env?.[Bar]?.f64.foo
 $env?.[Bar]?.f64.foo()
 $env?.[Bar]?.f64.greet
 $env?.[Bar]?.f64.i
 $env?.[Bar]?.f64.i()
+$env?.[Bar]?.f64.list
 $env?.[Bar]?.f64?.[add]
 $env?.[Bar]?.f64?.[greet]
+$env?.[Bar]?.f64?.[str]
+$env?.[Bar]?.f64?.f64
+$env?.[Bar]?.f64?.i
 $env?.[Bar]?.f64?.list()
 $env?.[Bar]?.false.foo
+$env?.[Bar]?.find($env, foo)
 $env?.[Bar]?.find(Bar)
+$env?.[Bar]?.findIndex(true)
 $env?.[Bar]?.findLast(1)
 $env?.[Bar]?.findLast(1, i)
 $env?.[Bar]?.findLastIndex(nil)
@@ -1596,27 +3335,49 @@ $env?.[Bar]?.foo
 $env?.[Bar]?.foo($env)
 $env?.[Bar]?.foo()
 $env?.[Bar]?.foo().list
+$env?.[Bar]?.foo()?.[i]
 $env?.[Bar]?.foo(foobar)
+$env?.[Bar]?.foo(foobar)?.foo
 $env?.[Bar]?.foo(foobar, foobar)
 $env?.[Bar]?.foo(foobar?.true startsWith foobar contains foobar)
+$env?.[Bar]?.foo(let bar = array; let z = ok; let z = 1.0; bar)?.[f64]
+$env?.[Bar]?.foo.add
+$env?.[Bar]?.foo.array
+$env?.[Bar]?.foo.greet
+$env?.[Bar]?.foo.greet?.greet(foobar)
 $env?.[Bar]?.foo.i
+$env?.[Bar]?.foo.ok
 $env?.[Bar]?.foo.ok()
 $env?.[Bar]?.foo.str
 $env?.[Bar]?.foo?.Bar
 $env?.[Bar]?.foo?.String
+$env?.[Bar]?.foo?.[add]
+$env?.[Bar]?.foo?.[array]
 $env?.[Bar]?.foo?.[greet].list()
+$env?.[Bar]?.foo?.[i]
 $env?.[Bar]?.foo?.[list]
+$env?.[Bar]?.foo?.array
 $env?.[Bar]?.foo?.f64
 $env?.[Bar]?.foo?.foo()
+$env?.[Bar]?.foo?.greet
+$env?.[Bar]?.foo?.list
 $env?.[Bar]?.foo?.ok
 $env?.[Bar]?.foobar
+$env?.[Bar]?.foobar == add
+$env?.[Bar]?.foobar endsWith $env
 $env?.[Bar]?.foobar not endsWith str
+$env?.[Bar]?.foobar || false
 $env?.[Bar]?.foobar.String
+$env?.[Bar]?.foobar.String?.Bar
 $env?.[Bar]?.foobar.array
+$env?.[Bar]?.foobar.foo
 $env?.[Bar]?.foobar.list(nil)
 $env?.[Bar]?.foobar.str
+$env?.[Bar]?.foobar?.String
 $env?.[Bar]?.foobar?.[f64]
+$env?.[Bar]?.foobar?.[foo]
 $env?.[Bar]?.foobar?.[i]
+$env?.[Bar]?.foobar?.[ok]
 $env?.[Bar]?.foobar?.ok
 $env?.[Bar]?.fromPairs(foobar, foo)
 $env?.[Bar]?.greet
@@ -1624,71 +3385,122 @@ $env?.[Bar]?.greet == ok
 $env?.[Bar]?.greet($env endsWith foobar)
 $env?.[Bar]?.greet()
 $env?.[Bar]?.greet().add
+$env?.[Bar]?.greet()?.[foo]
 $env?.[Bar]?.greet()?.[i]
 $env?.[Bar]?.greet()?.f64
 $env?.[Bar]?.greet(0)
+$env?.[Bar]?.greet(array)
+$env?.[Bar]?.greet(f64, foobar)
+$env?.[Bar]?.greet(foo endsWith foobar?.[String]).Bar
 $env?.[Bar]?.greet(foo)
 $env?.[Bar]?.greet(foobar)
 $env?.[Bar]?.greet(foobar)?.String
+$env?.[Bar]?.greet(foobar, str)
+$env?.[Bar]?.greet(greet)
 $env?.[Bar]?.greet(list)
 $env?.[Bar]?.greet(str)
+$env?.[Bar]?.greet.Bar()
+$env?.[Bar]?.greet.add
+$env?.[Bar]?.greet.array()
 $env?.[Bar]?.greet.f64
 $env?.[Bar]?.greet.f64(foobar)
 $env?.[Bar]?.greet?.[add]
+$env?.[Bar]?.greet?.[f64]
 $env?.[Bar]?.greet?.[i]
 $env?.[Bar]?.greet?.[list]
+$env?.[Bar]?.greet?.array
 $env?.[Bar]?.greet?.f64
+$env?.[Bar]?.greet?.i
 $env?.[Bar]?.greet?.ok
+$env?.[Bar]?.groupBy(0, $env, foobar)
 $env?.[Bar]?.i
 $env?.[Bar]?.i($env not matches foobar, Bar)?.foo
 $env?.[Bar]?.i($env)
 $env?.[Bar]?.i()
+$env?.[Bar]?.i()?.str
+$env?.[Bar]?.i(0 < i)
 $env?.[Bar]?.i(foobar)
 $env?.[Bar]?.i(foobar, str | reduce($env, f64))
 $env?.[Bar]?.i(greet, foobar)
 $env?.[Bar]?.i(list, foobar)
+$env?.[Bar]?.i.add
+$env?.[Bar]?.i.array()
+$env?.[Bar]?.i.ok
 $env?.[Bar]?.i.str
+$env?.[Bar]?.i?.Bar
+$env?.[Bar]?.i?.[add]
 $env?.[Bar]?.i?.[foo]
 $env?.[Bar]?.i?.[greet]
+$env?.[Bar]?.i?.add
 $env?.[Bar]?.i?.array
+$env?.[Bar]?.i?.foo()
 $env?.[Bar]?.i?.greet
 $env?.[Bar]?.i?.i
+$env?.[Bar]?.i?.i()
+$env?.[Bar]?.i?.ok()
 $env?.[Bar]?.i?.str
+$env?.[Bar]?.indexOf(nil, 1.0)
 $env?.[Bar]?.keys(Bar, false)
+$env?.[Bar]?.len(foo)
 $env?.[Bar]?.list
 $env?.[Bar]?.list()
+$env?.[Bar]?.list()?.[array]
 $env?.[Bar]?.list()?.[ok]
+$env?.[Bar]?.list()?.ok
 $env?.[Bar]?.list()?.str
+$env?.[Bar]?.list(array)
 $env?.[Bar]?.list(foo.String)
+$env?.[Bar]?.list(foobar ?? list)
 $env?.[Bar]?.list(foobar)
 $env?.[Bar]?.list(foobar).f64
 $env?.[Bar]?.list(foobar)?.[str]
 $env?.[Bar]?.list(foobar?.list)
 $env?.[Bar]?.list.Bar
+$env?.[Bar]?.list.String
 $env?.[Bar]?.list.add
 $env?.[Bar]?.list.f64
 $env?.[Bar]?.list.foobar
+$env?.[Bar]?.list.str
 $env?.[Bar]?.list?.Bar(foo, f64)
+$env?.[Bar]?.list?.[foo]
 $env?.[Bar]?.list?.[greet]
 $env?.[Bar]?.list?.[list]
 $env?.[Bar]?.list?.foo
+$env?.[Bar]?.list?.i
 $env?.[Bar]?.list?.str
+$env?.[Bar]?.list?.str()
 $env?.[Bar]?.lower(nil)
 $env?.[Bar]?.map(nil)
+$env?.[Bar]?.nil.str(Bar)
+$env?.[Bar]?.nil?.[ok]
 $env?.[Bar]?.nil?.i?.f64
 $env?.[Bar]?.none(list)
 $env?.[Bar]?.none(ok)
+$env?.[Bar]?.not .str
 $env?.[Bar]?.not.ok
+$env?.[Bar]?.now(f64, foo)
 $env?.[Bar]?.now(foobar, foobar, $env)
 $env?.[Bar]?.ok
 $env?.[Bar]?.ok()
 $env?.[Bar]?.ok().list
 $env?.[Bar]?.ok()?.add
+$env?.[Bar]?.ok(Bar)
 $env?.[Bar]?.ok(add)
+$env?.[Bar]?.ok(array)
+$env?.[Bar]?.ok(f64)
+$env?.[Bar]?.ok(foobar?.[f64])
+$env?.[Bar]?.ok(greet)
 $env?.[Bar]?.ok.String
+$env?.[Bar]?.ok.add
+$env?.[Bar]?.ok.f64
+$env?.[Bar]?.ok.foo
 $env?.[Bar]?.ok.list
+$env?.[Bar]?.ok.ok
+$env?.[Bar]?.ok?.[array]
 $env?.[Bar]?.ok?.[greet]
 $env?.[Bar]?.ok?.foo
+$env?.[Bar]?.ok?.list
+$env?.[Bar]?.one(foobar, foobar)?.[str]
 $env?.[Bar]?.reduce(1.0)
 $env?.[Bar]?.str
 $env?.[Bar]?.str($env == foobar)
@@ -1696,20 +3508,40 @@ $env?.[Bar]?.str($env)
 $env?.[Bar]?.str()
 $env?.[Bar]?.str().add.i
 $env?.[Bar]?.str()?.[list]
+$env?.[Bar]?.str(0)
+$env?.[Bar]?.str(Bar)
 $env?.[Bar]?.str(f64)
 $env?.[Bar]?.str(f64, array)
+$env?.[Bar]?.str(foobar)
+$env?.[Bar]?.str(greet)
 $env?.[Bar]?.str(list | first(true, foobar))
+$env?.[Bar]?.str(list)
 $env?.[Bar]?.str(nil)
 $env?.[Bar]?.str.Bar
+$env?.[Bar]?.str.String
+$env?.[Bar]?.str.array
 $env?.[Bar]?.str.foo
+$env?.[Bar]?.str.greet
 $env?.[Bar]?.str.ok
+$env?.[Bar]?.str?.Bar
 $env?.[Bar]?.str?.[add]
 $env?.[Bar]?.str?.[array]
+$env?.[Bar]?.str?.[foo]
 $env?.[Bar]?.str?.[list]
 $env?.[Bar]?.str?.[str]
+$env?.[Bar]?.str?.f64
+$env?.[Bar]?.str?.i(greet)
+$env?.[Bar]?.str?.list
 $env?.[Bar]?.sum(foobar)
+$env?.[Bar]?.sum(list).ok
+$env?.[Bar]?.sum(ok)
+$env?.[Bar]?.toBase64(1.0)
+$env?.[Bar]?.true not contains $env
 $env?.[Bar]?.true?.[ok]
+$env?.[Bar]?.uniq(array, $env)
+$env?.[Bar]?.uniq(foobar, foo)
 $env?.[Bar]?.values(foobar, foobar)
+$env?.[String] != $env.ok
 $env?.[String] != 1 ? f64 : f64
 $env?.[String] != add
 $env?.[String] != array
@@ -1717,26 +3549,61 @@ $env?.[String] != f64
 $env?.[String] != foo
 $env?.[String] != foo ? foo : 0
 $env?.[String] != i
+$env?.[String] != len(list)
 $env?.[String] != list
+$env?.[String] != nil ? add : foo
 $env?.[String] != ok
 $env?.[String] != str
 $env?.[String] == $env.i
+$env?.[String] == 0 != $env
+$env?.[String] == 1.0 / 1
 $env?.[String] == add
+$env?.[String] == array
+$env?.[String] == f64
+$env?.[String] == foo
+$env?.[String] == foo == $env
+$env?.[String] == foo?.Bar
 $env?.[String] == greet
+$env?.[String] == i
 $env?.[String] == i && $env
 $env?.[String] == list
 $env?.[String] == str
+$env?.[String] ?? -0
+$env?.[String] ?? add
+$env?.[String] ?? array
+$env?.[String] ?? f64
+$env?.[String] ?? foo
+$env?.[String] ?? i
+$env?.[String] ?? list
+$env?.[String] ?? str
+$env?.[String] contains $env?.[String]
+$env?.[String] contains $env?.[str]
+$env?.[String] contains 1.0 ?? greet
+$env?.[String] contains add ?? list
 $env?.[String] contains str
+$env?.[String] endsWith $env?.String
 $env?.[String] endsWith $env?.[str]
+$env?.[String] endsWith str
+$env?.[String] in [1]
+$env?.[String] in array
 $env?.[String] in list
 $env?.[String] matches str
+$env?.[String] not contains $env?.Bar
+$env?.[String] not contains false ?? greet
 $env?.[String] not contains str
+$env?.[String] not endsWith 1 ?? greet
+$env?.[String] not endsWith str
+$env?.[String] not in $env?.array
+$env?.[String] not in 0 .. 0
 $env?.[String] not in array
 $env?.[String] not in list
 $env?.[String] not matches str
 $env?.[String] not startsWith str
+$env?.[String] startsWith $env?.[Bar]
+$env?.[String] startsWith foo ?? add
 $env?.[String] startsWith min($env)
 $env?.[String] startsWith str
+$env?.[String] | get(i)
 $env?.[String]?.$env.list
 $env?.[String]?.$env?.[foo]
 $env?.[String]?.$env?.[ok]
@@ -1744,150 +3611,290 @@ $env?.[String]?.$env?.array
 $env?.[String]?.Bar
 $env?.[String]?.Bar()
 $env?.[String]?.Bar().foo
+$env?.[String]?.Bar()?.str
+$env?.[String]?.Bar(1.0).String
+$env?.[String]?.Bar(array)
 $env?.[String]?.Bar(f64)
+$env?.[String]?.Bar(foo contains String)?.[foo]
 $env?.[String]?.Bar(foobar)
+$env?.[String]?.Bar(greet)
 $env?.[String]?.Bar.String
 $env?.[String]?.Bar.greet
+$env?.[String]?.Bar.i(ok)
+$env?.[String]?.Bar.ok()
+$env?.[String]?.Bar.ok?.[ok]
 $env?.[String]?.Bar.str
 $env?.[String]?.Bar?.Bar()
+$env?.[String]?.Bar?.[add]
 $env?.[String]?.Bar?.[foo]
 $env?.[String]?.Bar?.[greet]
 $env?.[String]?.Bar?.[str]
 $env?.[String]?.Bar?.add
 $env?.[String]?.Bar?.i
 $env?.[String]?.Bar?.list()
+$env?.[String]?.Bar?.str.f64
 $env?.[String]?.String
+$env?.[String]?.String($env)
 $env?.[String]?.String()
 $env?.[String]?.String().list
+$env?.[String]?.String().list(String)
+$env?.[String]?.String()?.add
 $env?.[String]?.String(String)
 $env?.[String]?.String(add)
+$env?.[String]?.String(foo)
+$env?.[String]?.String(foobar)
 $env?.[String]?.String(foobar, $env)
 $env?.[String]?.String(foobar?.[list])?.str()
 $env?.[String]?.String(greet)
+$env?.[String]?.String(last($env, String))
 $env?.[String]?.String(ok && foobar)
+$env?.[String]?.String.add
 $env?.[String]?.String.split(false, add).str.array
 $env?.[String]?.String?.Bar
+$env?.[String]?.String?.Bar?.greet
+$env?.[String]?.String?.String
+$env?.[String]?.String?.[$env]
 $env?.[String]?.String?.[foo]
 $env?.[String]?.String?.[greet]
+$env?.[String]?.String?.[i]
 $env?.[String]?.String?.[list]
+$env?.[String]?.String?.[ok]
 $env?.[String]?.String?.array
+$env?.[String]?.String?.f64(false)
+$env?.[String]?.String?.foo
+$env?.[String]?.String?.foo(foobar)
 $env?.[String]?.String?.foo?.foo
+$env?.[String]?.String?.greet.greet
 $env?.[String]?.String?.list
+$env?.[String]?.String?.str?.ok
 $env?.[String]?.[$env == true]
+$env?.[String]?.[$env | none($env)]
 $env?.[String]?.[$env.foo]
 $env?.[String]?.[$env?.[greet]]
 $env?.[String]?.[$env?.array]
 $env?.[String]?.[add]
+$env?.[String]?.[add].String
+$env?.[String]?.[add].foo
+$env?.[String]?.[add].greet
 $env?.[String]?.[add].str
+$env?.[String]?.[add]?.String
+$env?.[String]?.[add]?.[add]
 $env?.[String]?.[add]?.[list]
+$env?.[String]?.[add]?.[ok]
 $env?.[String]?.[add]?.add
+$env?.[String]?.[add]?.add(foo)
 $env?.[String]?.[add]?.greet
+$env?.[String]?.[add]?.list?.Bar
+$env?.[String]?.[array | reduce(#)]
 $env?.[String]?.[array]
 $env?.[String]?.[array] == list
 $env?.[String]?.[array].Bar
+$env?.[String]?.[array].String
+$env?.[String]?.[array].String()
+$env?.[String]?.[array].array
+$env?.[String]?.[array].foo
+$env?.[String]?.[array].i
 $env?.[String]?.[array].ok
 $env?.[String]?.[array]?.Bar()
+$env?.[String]?.[array]?.[add]
+$env?.[String]?.[array]?.[foo]
+$env?.[String]?.[array]?.[list]
 $env?.[String]?.[array]?.[ok]
+$env?.[String]?.[array]?.[str]
 $env?.[String]?.[array]?.add
+$env?.[String]?.[array]?.array()
 $env?.[String]?.[array]?.f64
 $env?.[String]?.[array]?.list?.[add]
+$env?.[String]?.[array]?.ok
+$env?.[String]?.[array]?.str
 $env?.[String]?.[f64]
+$env?.[String]?.[f64].add
+$env?.[String]?.[f64].foo
 $env?.[String]?.[f64].list
 $env?.[String]?.[f64].list()
+$env?.[String]?.[f64].ok
+$env?.[String]?.[f64].str
 $env?.[String]?.[f64]?.Bar
 $env?.[String]?.[f64]?.Bar()
 $env?.[String]?.[f64]?.[f64]
+$env?.[String]?.[f64]?.[foo]
+$env?.[String]?.[f64]?.[greet]
+$env?.[String]?.[f64]?.[i]
+$env?.[String]?.[f64]?.[str]
 $env?.[String]?.[f64]?.array()
 $env?.[String]?.[f64]?.greet
+$env?.[String]?.[f64]?.greet().foo
 $env?.[String]?.[f64]?.ok
 $env?.[String]?.[foo != nil]
 $env?.[String]?.[foo]
 $env?.[String]?.[foo].String
 $env?.[String]?.[foo].f64
+$env?.[String]?.[foo].foo
 $env?.[String]?.[foo].i
+$env?.[String]?.[foo].str.add?.[i]
 $env?.[String]?.[foo]?.String
+$env?.[String]?.[foo]?.[foo]
 $env?.[String]?.[foo]?.[ok]
 $env?.[String]?.[foo]?.[ok]?.[f64]
+$env?.[String]?.[foo]?.[str]
 $env?.[String]?.[foo]?.add
 $env?.[String]?.[foo]?.f64()
+$env?.[String]?.[foo]?.foo
 $env?.[String]?.[greet]
 $env?.[String]?.[greet].String
+$env?.[String]?.[greet].array
 $env?.[String]?.[greet].str
+$env?.[String]?.[greet]?.Bar
+$env?.[String]?.[greet]?.[greet]
 $env?.[String]?.[greet]?.[ok]
+$env?.[String]?.[greet]?.foo
 $env?.[String]?.[greet]?.i
 $env?.[String]?.[greet]?.list(foobar)
+$env?.[String]?.[greet]?.ok
 $env?.[String]?.[greet]?.str
+$env?.[String]?.[i | mean(1.0)]
 $env?.[String]?.[i]
 $env?.[String]?.[i].Bar
+$env?.[String]?.[i].add({foo: str})
 $env?.[String]?.[i].f64
 $env?.[String]?.[i].foo
+$env?.[String]?.[i].i
 $env?.[String]?.[i].list
 $env?.[String]?.[i].ok
+$env?.[String]?.[i]?.[add]
+$env?.[String]?.[i]?.[array]
+$env?.[String]?.[i]?.[foo]
+$env?.[String]?.[i]?.[greet]
 $env?.[String]?.[i]?.array
+$env?.[String]?.[i]?.greet
+$env?.[String]?.[i]?.ok
 $env?.[String]?.[list]
+$env?.[String]?.[list].array
 $env?.[String]?.[list].array()
+$env?.[String]?.[list].foobar
 $env?.[String]?.[list].greet
+$env?.[String]?.[list].i
 $env?.[String]?.[list].ok
+$env?.[String]?.[list].str
+$env?.[String]?.[list]?.String
 $env?.[String]?.[list]?.String()
 $env?.[String]?.[list]?.[add]
+$env?.[String]?.[list]?.[i]
+$env?.[String]?.[list]?.array()
+$env?.[String]?.[list]?.f64
 $env?.[String]?.[list]?.greet
+$env?.[String]?.[list]?.ok
+$env?.[String]?.[nil ?? array]
 $env?.[String]?.[ok and ok]
 $env?.[String]?.[ok not in $env]
 $env?.[String]?.[ok]
 $env?.[String]?.[ok].add
+$env?.[String]?.[ok].add?.array
+$env?.[String]?.[ok].f64
 $env?.[String]?.[ok].ok
 $env?.[String]?.[ok]?.Bar
 $env?.[String]?.[ok]?.[f64]
+$env?.[String]?.[ok]?.[list]
 $env?.[String]?.[ok]?.greet
 $env?.[String]?.[ok]?.i
+$env?.[String]?.[str matches str]
+$env?.[String]?.[str not endsWith $env]
 $env?.[String]?.[str]
+$env?.[String]?.[str] != f64
+$env?.[String]?.[str].array
 $env?.[String]?.[str].f64
+$env?.[String]?.[str].i.add
+$env?.[String]?.[str]?.Bar
+$env?.[String]?.[str]?.String
 $env?.[String]?.[str]?.[f64]
+$env?.[String]?.[str]?.[i]
+$env?.[String]?.[str]?.[ok]
+$env?.[String]?.[str]?.add
+$env?.[String]?.[str]?.array
 $env?.[String]?.[str]?.foo
 $env?.[String]?.add
+$env?.[String]?.add($env)
 $env?.[String]?.add()
 $env?.[String]?.add()?.[foo]
 $env?.[String]?.add()?.f64()
+$env?.[String]?.add()?.greet
 $env?.[String]?.add(1)
+$env?.[String]?.add(1.0, foobar)
 $env?.[String]?.add(foobar)
+$env?.[String]?.add(i == true)
+$env?.[String]?.add(str)
 $env?.[String]?.add.Bar
 $env?.[String]?.add.String
+$env?.[String]?.add.array()
+$env?.[String]?.add.greet
+$env?.[String]?.add.i
+$env?.[String]?.add.list()
+$env?.[String]?.add?.Bar
+$env?.[String]?.add?.String
 $env?.[String]?.add?.[add]
+$env?.[String]?.add?.[foo]
 $env?.[String]?.add?.[greet]
+$env?.[String]?.add?.[list]
+$env?.[String]?.add?.array
+$env?.[String]?.add?.f64
+$env?.[String]?.add?.foo
 $env?.[String]?.add?.greet
 $env?.[String]?.add?.greet()
+$env?.[String]?.add?.ok()
 $env?.[String]?.all(ok)
 $env?.[String]?.any(foobar, ok)
 $env?.[String]?.array
 $env?.[String]?.array()
+$env?.[String]?.array().array
+$env?.[String]?.array()?.[foo]
 $env?.[String]?.array()?.f64(list)
+$env?.[String]?.array(Bar?.foo())
 $env?.[String]?.array(String)
 $env?.[String]?.array(add)
 $env?.[String]?.array(f64)
+$env?.[String]?.array(foo)
 $env?.[String]?.array(foobar not startsWith foo)
 $env?.[String]?.array(foobar)
+$env?.[String]?.array(foobar?.[String].add)
 $env?.[String]?.array(i)
 $env?.[String]?.array(str)
+$env?.[String]?.array(toJSON(foobar))
 $env?.[String]?.array.String
 $env?.[String]?.array.array(String, foo)
+$env?.[String]?.array.f64
 $env?.[String]?.array.i
 $env?.[String]?.array.i()
+$env?.[String]?.array.list(foobar)
+$env?.[String]?.array.list.array
 $env?.[String]?.array.ok
 $env?.[String]?.array?.Bar
+$env?.[String]?.array?.Bar(list)
 $env?.[String]?.array?.[greet]
 $env?.[String]?.array?.f64
 $env?.[String]?.array?.foo
+$env?.[String]?.array?.greet
+$env?.[String]?.array?.i
 $env?.[String]?.array?.list(i)
+$env?.[String]?.bitor(foobar, 0)
 $env?.[String]?.bitshl(foobar)
+$env?.[String]?.bitshr(nil)
 $env?.[String]?.bitushr(foobar)
 $env?.[String]?.ceil(nil)
+$env?.[String]?.concat(1.0)
+$env?.[String]?.duration(foobar)
 $env?.[String]?.f64
 $env?.[String]?.f64()
 $env?.[String]?.f64().Bar
+$env?.[String]?.f64().Bar()
 $env?.[String]?.f64()?.f64
 $env?.[String]?.f64(String?.[array])
+$env?.[String]?.f64(foo.Bar)
 $env?.[String]?.f64(foobar)
+$env?.[String]?.f64(min(foobar))
+$env?.[String]?.f64.Bar
 $env?.[String]?.f64.Bar()
+$env?.[String]?.f64.add()
+$env?.[String]?.f64.greet.str
 $env?.[String]?.f64.i
 $env?.[String]?.f64.ok
 $env?.[String]?.f64?.String
@@ -1897,16 +3904,29 @@ $env?.[String]?.f64?.foo()
 $env?.[String]?.f64?.greet()
 $env?.[String]?.f64?.i
 $env?.[String]?.f64?.ok()
+$env?.[String]?.f64?.str
 $env?.[String]?.false?.str
+$env?.[String]?.filter(1)
 $env?.[String]?.find(foobar)
+$env?.[String]?.findLastIndex(add, f64)
 $env?.[String]?.foo
 $env?.[String]?.foo()
+$env?.[String]?.foo().foo
+$env?.[String]?.foo().list
+$env?.[String]?.foo()?.foo
 $env?.[String]?.foo()?.str
 $env?.[String]?.foo(f64, foobar)
 $env?.[String]?.foo(foobar)
+$env?.[String]?.foo(true)
 $env?.[String]?.foo.String
+$env?.[String]?.foo.add
+$env?.[String]?.foo.add()
+$env?.[String]?.foo.add?.greet
+$env?.[String]?.foo.array()
+$env?.[String]?.foo.f64
 $env?.[String]?.foo.foo
 $env?.[String]?.foo.greet
+$env?.[String]?.foo.i
 $env?.[String]?.foo.ok
 $env?.[String]?.foo.str
 $env?.[String]?.foo?.Bar
@@ -1915,22 +3935,35 @@ $env?.[String]?.foo?.[add]
 $env?.[String]?.foo?.[array]
 $env?.[String]?.foo?.[f64]
 $env?.[String]?.foo?.[foo]
+$env?.[String]?.foo?.add
 $env?.[String]?.foo?.array
+$env?.[String]?.foo?.greet
 $env?.[String]?.foo?.i
 $env?.[String]?.foo?.list
 $env?.[String]?.foo?.str
 $env?.[String]?.foo?.str()
 $env?.[String]?.foobar
+$env?.[String]?.foobar.Bar
+$env?.[String]?.foobar.array
 $env?.[String]?.foobar.f64
+$env?.[String]?.foobar.foo
+$env?.[String]?.foobar.i
+$env?.[String]?.foobar.list(foobar, add)
+$env?.[String]?.foobar.str
 $env?.[String]?.foobar.str()
+$env?.[String]?.foobar?.Bar
+$env?.[String]?.foobar?.[foo]
+$env?.[String]?.foobar?.[i]
 $env?.[String]?.foobar?.[list]
 $env?.[String]?.foobar?.[ok]
 $env?.[String]?.foobar?.array
 $env?.[String]?.foobar?.foo
 $env?.[String]?.foobar?.i
 $env?.[String]?.foobar?.i()
+$env?.[String]?.foobar?.ok()
 $env?.[String]?.fromJSON(foobar)
 $env?.[String]?.fromPairs(false)
+$env?.[String]?.get(String)
 $env?.[String]?.get(str)
 $env?.[String]?.greet
 $env?.[String]?.greet != str
@@ -1939,46 +3972,80 @@ $env?.[String]?.greet().Bar
 $env?.[String]?.greet()?.[list]
 $env?.[String]?.greet()?.[str]
 $env?.[String]?.greet(add)
+$env?.[String]?.greet(foobar != str)
 $env?.[String]?.greet(foobar)
 $env?.[String]?.greet(greet)
+$env?.[String]?.greet.Bar
 $env?.[String]?.greet.add
 $env?.[String]?.greet.array()
+$env?.[String]?.greet.f64
 $env?.[String]?.greet.foo
+$env?.[String]?.greet.foobar
 $env?.[String]?.greet.i
+$env?.[String]?.greet.i()
 $env?.[String]?.greet.list
+$env?.[String]?.greet.ok
+$env?.[String]?.greet.ok()
 $env?.[String]?.greet?.Bar
 $env?.[String]?.greet?.[array]
+$env?.[String]?.greet?.[list]
 $env?.[String]?.greet?.[str]
+$env?.[String]?.greet?.array
+$env?.[String]?.greet?.f64
+$env?.[String]?.greet?.foo
+$env?.[String]?.greet?.greet()
 $env?.[String]?.greet?.list.str
 $env?.[String]?.groupBy(1.0)
+$env?.[String]?.groupBy(f64, foobar, array)?.[ok]
 $env?.[String]?.groupBy(foobar)
 $env?.[String]?.groupBy(str)
 $env?.[String]?.hasPrefix(nil)?.String
 $env?.[String]?.i
+$env?.[String]?.i in array
 $env?.[String]?.i()
+$env?.[String]?.i().ok
+$env?.[String]?.i()?.[add]
 $env?.[String]?.i()?.[array]
 $env?.[String]?.i()?.[greet]
+$env?.[String]?.i()?.f64
+$env?.[String]?.i(add)
+$env?.[String]?.i(array)
 $env?.[String]?.i(foo)
+$env?.[String]?.i(foobar ?? array)
 $env?.[String]?.i(foobar)
+$env?.[String]?.i(i)
 $env?.[String]?.i(ok)
 $env?.[String]?.i(str)
 $env?.[String]?.i(true)
+$env?.[String]?.i.Bar
 $env?.[String]?.i.String
+$env?.[String]?.i.f64(f64)
 $env?.[String]?.i.greet
 $env?.[String]?.i.list
+$env?.[String]?.i?.[array]
 $env?.[String]?.i?.[greet]
+$env?.[String]?.i?.[list]
 $env?.[String]?.i?.[ok]
+$env?.[String]?.i?.[str]
+$env?.[String]?.i?.add
+$env?.[String]?.i?.array
+$env?.[String]?.i?.f64?.String
 $env?.[String]?.i?.foo
 $env?.[String]?.i?.foo()
 $env?.[String]?.i?.greet
 $env?.[String]?.i?.list
 $env?.[String]?.i?.ok.f64
 $env?.[String]?.int(foo)
+$env?.[String]?.lastIndexOf(true, foobar, foo)
 $env?.[String]?.len(false)
 $env?.[String]?.list
+$env?.[String]?.list($env)
 $env?.[String]?.list()
+$env?.[String]?.list().i
+$env?.[String]?.list(0)
 $env?.[String]?.list(1.0)
 $env?.[String]?.list(Bar)
+$env?.[String]?.list(foo).f64
 $env?.[String]?.list(foobar)
 $env?.[String]?.list(foobar).greet
 $env?.[String]?.list(greet)
@@ -1987,149 +4054,274 @@ $env?.[String]?.list(ok)
 $env?.[String]?.list(true, true)
 $env?.[String]?.list.add()
 $env?.[String]?.list.foo
+$env?.[String]?.list.foo($env)
 $env?.[String]?.list.list
+$env?.[String]?.list?.String()
+$env?.[String]?.list?.[array]
+$env?.[String]?.list?.[foo]
+$env?.[String]?.list?.[greet]
+$env?.[String]?.list?.[list]?.Bar
 $env?.[String]?.list?.[ok]
 $env?.[String]?.list?.add?.list
 $env?.[String]?.list?.array
+$env?.[String]?.list?.foo(0)
 $env?.[String]?.list?.foobar
 $env?.[String]?.list?.i
+$env?.[String]?.list?.list
+$env?.[String]?.map($env)
+$env?.[String]?.map($env, foo).add
+$env?.[String]?.map(String, foobar)
 $env?.[String]?.nil.String
+$env?.[String]?.nil.list
+$env?.[String]?.nil?.f64
+$env?.[String]?.nil?.ok()
+$env?.[String]?.none($env)
+$env?.[String]?.none(array)
+$env?.[String]?.none(foobar)
 $env?.[String]?.not
 $env?.[String]?.ok
 $env?.[String]?.ok()
+$env?.[String]?.ok().add
+$env?.[String]?.ok()?.[add]
 $env?.[String]?.ok()?.list
+$env?.[String]?.ok()?.str() == f64
+$env?.[String]?.ok(array)
 $env?.[String]?.ok(f64, foobar)
+$env?.[String]?.ok(foo contains foobar)
+$env?.[String]?.ok(foo)
+$env?.[String]?.ok(foobar)
 $env?.[String]?.ok(foobar?.[1.0])
+$env?.[String]?.ok(foobar?.[list])
+$env?.[String]?.ok(nil startsWith ok)
 $env?.[String]?.ok(toJSON(foo)).f64
 $env?.[String]?.ok.add
+$env?.[String]?.ok.f64
 $env?.[String]?.ok.foo
 $env?.[String]?.ok.i
+$env?.[String]?.ok.ok
 $env?.[String]?.ok.str
+$env?.[String]?.ok?.[array]
 $env?.[String]?.ok?.[f64]
+$env?.[String]?.ok?.[f64].list
 $env?.[String]?.ok?.[foo]
 $env?.[String]?.ok?.[list]
 $env?.[String]?.ok?.[ok]
 $env?.[String]?.ok?.add
 $env?.[String]?.ok?.f64
+$env?.[String]?.ok?.foo
 $env?.[String]?.ok?.ok
 $env?.[String]?.one($env)
+$env?.[String]?.one(array)
 $env?.[String]?.one(foobar)?.[f64]
 $env?.[String]?.reduce(1.0)
 $env?.[String]?.reduce(foobar)
+$env?.[String]?.sortBy(add)
 $env?.[String]?.splitAfter(true)
 $env?.[String]?.str
+$env?.[String]?.str not endsWith $env
 $env?.[String]?.str not startsWith str
 $env?.[String]?.str()
 $env?.[String]?.str().list
+$env?.[String]?.str().list?.[list]
 $env?.[String]?.str()?.array
+$env?.[String]?.str(add)
 $env?.[String]?.str(foo)
 $env?.[String]?.str(foobar)
 $env?.[String]?.str(foobar?.array)
+$env?.[String]?.str.String
 $env?.[String]?.str.add
 $env?.[String]?.str.array
+$env?.[String]?.str.foo
+$env?.[String]?.str.ok
 $env?.[String]?.str?.Bar
 $env?.[String]?.str?.String
 $env?.[String]?.str?.[add]
+$env?.[String]?.str?.[i]
 $env?.[String]?.str?.add
 $env?.[String]?.str?.f64()
 $env?.[String]?.str?.f64(false)?.greet
+$env?.[String]?.str?.list()
+$env?.[String]?.str?.str
+$env?.[String]?.string(foobar, foobar)
+$env?.[String]?.sum(String, foobar)
 $env?.[String]?.sum(add)
+$env?.[String]?.sum(foobar, foobar)
 $env?.[String]?.take(String)?.str
 $env?.[String]?.trimPrefix(add)
+$env?.[String]?.trimPrefix(foobar)
 $env?.[String]?.true not in array
+$env?.[String]?.true.foo
+$env?.[String]?.true?.[1]
+$env?.[String]?.true?.foobar
 $env?.[add] != 1.0 && false
 $env?.[add] * f64 && false
+$env?.[add] == nil and false
+$env?.[f64] == list || true
+$env?.[false] and not true
 $env?.[foo] != 1.0 || true
+$env?.[foo] endsWith $env && false
 $env?.[foobar] != $env.i
+$env?.[foobar] != $env.list
+$env?.[foobar] != f64
 $env?.[foobar] != foo
 $env?.[foobar] != greet
 $env?.[foobar] != i
+$env?.[foobar] != i ? true : $env
 $env?.[foobar] != list
+$env?.[foobar] != str
+$env?.[foobar] == add
 $env?.[foobar] == array
 $env?.[foobar] == f64
 $env?.[foobar] == foo
+$env?.[foobar] == greet
+$env?.[foobar] == list
 $env?.[foobar] == list != $env
 $env?.[foobar] == ok
+$env?.[foobar] ?? f64
+$env?.[foobar] ?? greet
+$env?.[foobar] ?? ok
 $env?.[foobar] contains str
+$env?.[foobar] endsWith $env?.[str]
+$env?.[foobar] endsWith str
 $env?.[foobar] in $env?.[String]
 $env?.[foobar] in list
+$env?.[foobar] in reverse(array)
+$env?.[foobar] matches str
+$env?.[foobar] not contains str
+$env?.[foobar] not endsWith str
 $env?.[foobar] not in array
 $env?.[foobar] not in list
 $env?.[foobar] not matches str
 $env?.[foobar] not startsWith foo?.String()
+$env?.[foobar] not startsWith str
 $env?.[foobar] not startsWith trim(str)
 $env?.[foobar] startsWith $env or $env
+$env?.[foobar] startsWith $env?.[str]
+$env?.[foobar] | get($env)
+$env?.[foobar] | get(foo)
 $env?.[foobar]?.$env == nil
+$env?.[foobar]?.$env.greet
 $env?.[foobar]?.Bar
 $env?.[foobar]?.Bar()
+$env?.[foobar]?.Bar().str
 $env?.[foobar]?.Bar()?.foobar
+$env?.[foobar]?.Bar(add)
 $env?.[foobar]?.Bar(foobar)
 $env?.[foobar]?.Bar(list)
 $env?.[foobar]?.Bar.foo()
+$env?.[foobar]?.Bar.foobar
+$env?.[foobar]?.Bar.i
 $env?.[foobar]?.Bar.str(foobar)
+$env?.[foobar]?.Bar?.[f64]
+$env?.[foobar]?.Bar?.[i]
 $env?.[foobar]?.Bar?.[str]
+$env?.[foobar]?.Bar?.[str]?.array
 $env?.[foobar]?.Bar?.f64
 $env?.[foobar]?.Bar?.foo
 $env?.[foobar]?.String
 $env?.[foobar]?.String()
 $env?.[foobar]?.String(Bar)
 $env?.[foobar]?.String(add).String
+$env?.[foobar]?.String(foobar)
+$env?.[foobar]?.String(foobar?.f64, Bar?.[foobar])
+$env?.[foobar]?.String(nil == foobar)
+$env?.[foobar]?.String.Bar
 $env?.[foobar]?.String.ok
+$env?.[foobar]?.String.str
 $env?.[foobar]?.String?.[i]
+$env?.[foobar]?.String?.[str]
 $env?.[foobar]?.String?.[str]?.[f64]?.ok
 $env?.[foobar]?.String?.array
 $env?.[foobar]?.String?.i
+$env?.[foobar]?.String?.list
+$env?.[foobar]?.String?.ok()
+$env?.[foobar]?.[!false]
+$env?.[foobar]?.[$env | groupBy(i)]
+$env?.[foobar]?.[$env[nil:]]
 $env?.[foobar]?.[add]
 $env?.[foobar]?.[add].f64
 $env?.[foobar]?.[add].greet
+$env?.[foobar]?.[add].i
+$env?.[foobar]?.[add]?.Bar
+$env?.[foobar]?.[add]?.[add]
 $env?.[foobar]?.[add]?.[foo]
 $env?.[foobar]?.[add]?.[greet]
+$env?.[foobar]?.[add]?.f64
 $env?.[foobar]?.[array]
+$env?.[foobar]?.[array].i
 $env?.[foobar]?.[array]?.Bar
+$env?.[foobar]?.[array]?.Bar()
+$env?.[foobar]?.[array]?.[i]
+$env?.[foobar]?.[array]?.[ok]
+$env?.[foobar]?.[array]?.add
 $env?.[foobar]?.[array]?.f64
+$env?.[foobar]?.[array]?.f64()
+$env?.[foobar]?.[array]?.foo
 $env?.[foobar]?.[array]?.list()?.[add]
+$env?.[foobar]?.[f64 ^ 1.0]
 $env?.[foobar]?.[f64]
+$env?.[foobar]?.[f64].array
 $env?.[foobar]?.[f64].f64
 $env?.[foobar]?.[f64].f64()
 $env?.[foobar]?.[f64].greet
 $env?.[foobar]?.[f64].ok()
+$env?.[foobar]?.[f64]?.[i]
+$env?.[foobar]?.[f64]?.[str]
+$env?.[foobar]?.[f64]?.greet
 $env?.[foobar]?.[foo]
 $env?.[foobar]?.[foo].Bar
+$env?.[foobar]?.[foo].String
 $env?.[foobar]?.[foo].String()
+$env?.[foobar]?.[foo].add()
 $env?.[foobar]?.[foo]?.[str]
 $env?.[foobar]?.[foo]?.i
+$env?.[foobar]?.[greet ?? 1.0]
 $env?.[foobar]?.[greet]
 $env?.[foobar]?.[greet].array.array
 $env?.[foobar]?.[greet].f64
+$env?.[foobar]?.[greet]?.[add]
 $env?.[foobar]?.[greet]?.[i].array
 $env?.[foobar]?.[greet]?.[ok]
 $env?.[foobar]?.[greet]?.str
 $env?.[foobar]?.[i]
 $env?.[foobar]?.[i].Bar
+$env?.[foobar]?.[i].array
 $env?.[foobar]?.[i].greet
 $env?.[foobar]?.[i].str
 $env?.[foobar]?.[i]?.[list]
 $env?.[foobar]?.[i]?.[ok]
 $env?.[foobar]?.[i]?.ok
 $env?.[foobar]?.[list]
+$env?.[foobar]?.[list].f64()
 $env?.[foobar]?.[list].foo
+$env?.[foobar]?.[list].ok
 $env?.[foobar]?.[list]?.[f64]
 $env?.[foobar]?.[list]?.[str]
 $env?.[foobar]?.[list]?.f64()
 $env?.[foobar]?.[list]?.ok
 $env?.[foobar]?.[ok]
 $env?.[foobar]?.[ok].Bar
+$env?.[foobar]?.[ok].list
+$env?.[foobar]?.[ok].str
 $env?.[foobar]?.[ok]?.[add]
 $env?.[foobar]?.[ok]?.[f64]
+$env?.[foobar]?.[ok]?.f64
 $env?.[foobar]?.[ok]?.ok
 $env?.[foobar]?.[sortBy($env, f64)]
 $env?.[foobar]?.[str]
+$env?.[foobar]?.[str].Bar
+$env?.[foobar]?.[str].foo?.[add]
 $env?.[foobar]?.[str].i
 $env?.[foobar]?.[str]?.[f64]
 $env?.[foobar]?.add
 $env?.[foobar]?.add()
 $env?.[foobar]?.add()?.[array]
 $env?.[foobar]?.add(foobar)
+$env?.[foobar]?.add(toJSON(foo), Bar)
+$env?.[foobar]?.add.add()
+$env?.[foobar]?.add.greet(foo)
+$env?.[foobar]?.add?.[add]
+$env?.[foobar]?.add?.array()
 $env?.[foobar]?.add?.greet
 $env?.[foobar]?.add?.i
 $env?.[foobar]?.all(foobar, greet, $env)
@@ -2137,102 +4329,180 @@ $env?.[foobar]?.any(1, foobar)
 $env?.[foobar]?.any(f64, nil)
 $env?.[foobar]?.any(i).f64
 $env?.[foobar]?.array
+$env?.[foobar]?.array contains str
 $env?.[foobar]?.array()
+$env?.[foobar]?.array(foobar)
+$env?.[foobar]?.array.Bar
 $env?.[foobar]?.array.f64
+$env?.[foobar]?.array.f64()
+$env?.[foobar]?.array?.[add]
+$env?.[foobar]?.array?.[f64]
 $env?.[foobar]?.array?.[i]
 $env?.[foobar]?.array?.add()
 $env?.[foobar]?.array?.i
+$env?.[foobar]?.bitand(false)
+$env?.[foobar]?.count(0)
 $env?.[foobar]?.f64
 $env?.[foobar]?.f64()
 $env?.[foobar]?.f64()?.[ok]
 $env?.[foobar]?.f64()?.array
 $env?.[foobar]?.f64(String)
+$env?.[foobar]?.f64(foobar endsWith String)?.[greet]
+$env?.[foobar]?.f64(foobar)
+$env?.[foobar]?.f64(i)
 $env?.[foobar]?.f64.ok
 $env?.[foobar]?.f64?.Bar
+$env?.[foobar]?.f64?.[i]
+$env?.[foobar]?.f64?.list()
 $env?.[foobar]?.f64?.ok
+$env?.[foobar]?.false?.[add]
 $env?.[foobar]?.filter(foo)
+$env?.[foobar]?.find(foobar, 1)
+$env?.[foobar]?.findLast(foo).String()
 $env?.[foobar]?.foo
 $env?.[foobar]?.foo()
 $env?.[foobar]?.foo()?.array
 $env?.[foobar]?.foo()?.f64
+$env?.[foobar]?.foo(Bar)
 $env?.[foobar]?.foo(foobar)
 $env?.[foobar]?.foo(foobar, foobar)
 $env?.[foobar]?.foo.foobar
+$env?.[foobar]?.foo?.String
 $env?.[foobar]?.foo?.[array]
 $env?.[foobar]?.foo?.[foo]
 $env?.[foobar]?.foo?.[i]
 $env?.[foobar]?.foo?.foo
 $env?.[foobar]?.foo?.foo?.array
 $env?.[foobar]?.foobar
+$env?.[foobar]?.foobar not in $env
 $env?.[foobar]?.foobar.str
+$env?.[foobar]?.foobar?.[foo]
+$env?.[foobar]?.foobar?.greet
+$env?.[foobar]?.foobar?.ok(list, foobar)
+$env?.[foobar]?.foobar?.str
 $env?.[foobar]?.greet
+$env?.[foobar]?.greet == foo
 $env?.[foobar]?.greet()
 $env?.[foobar]?.greet()?.String
 $env?.[foobar]?.greet(Bar)
 $env?.[foobar]?.greet(String)
+$env?.[foobar]?.greet(foobar)
 $env?.[foobar]?.greet(foobar, foo)
+$env?.[foobar]?.greet(foobar?.list(), array)
 $env?.[foobar]?.greet(greet)
+$env?.[foobar]?.greet(list, Bar)
 $env?.[foobar]?.greet.foo
 $env?.[foobar]?.greet.i
+$env?.[foobar]?.greet?.add
+$env?.[foobar]?.greet?.add(nil)
+$env?.[foobar]?.greet?.array
+$env?.[foobar]?.greet?.ok
 $env?.[foobar]?.i
 $env?.[foobar]?.i()
 $env?.[foobar]?.i()?.greet
 $env?.[foobar]?.i(Bar)
 $env?.[foobar]?.i(foo)
 $env?.[foobar]?.i(foobar)
+$env?.[foobar]?.i.Bar
+$env?.[foobar]?.i.String
 $env?.[foobar]?.i.array
 $env?.[foobar]?.i.foo
 $env?.[foobar]?.i?.[array]
+$env?.[foobar]?.i?.[foo]
 $env?.[foobar]?.i?.[greet]
 $env?.[foobar]?.i?.f64
+$env?.[foobar]?.i?.ok
+$env?.[foobar]?.join(greet, nil)
 $env?.[foobar]?.lastIndexOf(nil, foobar)
 $env?.[foobar]?.list
 $env?.[foobar]?.list()
+$env?.[foobar]?.list(1)
 $env?.[foobar]?.list(f64)
 $env?.[foobar]?.list(foobar)
+$env?.[foobar]?.list(str)
+$env?.[foobar]?.list.i
+$env?.[foobar]?.list.i()
 $env?.[foobar]?.list.list
+$env?.[foobar]?.list.ok(foobar)
 $env?.[foobar]?.list?.[array]
 $env?.[foobar]?.list?.[i]
 $env?.[foobar]?.list?.[list]
+$env?.[foobar]?.list?.f64
+$env?.[foobar]?.list?.ok()
+$env?.[foobar]?.max(1, ok)
 $env?.[foobar]?.max(foo)
 $env?.[foobar]?.nil?.[foo]
+$env?.[foobar]?.nil?.str(foo, foobar)
 $env?.[foobar]?.none(foobar)
 $env?.[foobar]?.none(nil, foobar)
+$env?.[foobar]?.not .String
 $env?.[foobar]?.now(1)
 $env?.[foobar]?.ok
 $env?.[foobar]?.ok()
+$env?.[foobar]?.ok()?.i
 $env?.[foobar]?.ok(Bar?.[greet])?.greet
+$env?.[foobar]?.ok(foo not startsWith foobar)
+$env?.[foobar]?.ok(foo)
 $env?.[foobar]?.ok(list)
+$env?.[foobar]?.ok.add
 $env?.[foobar]?.ok.add()
 $env?.[foobar]?.ok.i
+$env?.[foobar]?.ok?.[greet]
+$env?.[foobar]?.ok?.greet()
 $env?.[foobar]?.ok?.i
+$env?.[foobar]?.reduce(nil, 1.0)
+$env?.[foobar]?.sortBy(foo, 0, foobar)
 $env?.[foobar]?.str
 $env?.[foobar]?.str($env)
 $env?.[foobar]?.str()
 $env?.[foobar]?.str()?.str
 $env?.[foobar]?.str(foobar)
 $env?.[foobar]?.str(foobar?.greet(nil))
+$env?.[foobar]?.str(i)
 $env?.[foobar]?.str.ok
+$env?.[foobar]?.str?.String
+$env?.[foobar]?.str?.[f64]
 $env?.[foobar]?.str?.[list]
 $env?.[foobar]?.str?.foo
+$env?.[foobar]?.str?.i
 $env?.[foobar]?.str?.i()
 $env?.[foobar]?.str?.list
 $env?.[foobar]?.sum($env)
 $env?.[foobar]?.trimSuffix(f64, foobar)
+$env?.[foobar]?.true?.ok
 $env?.[greet]?.foobar or true
+$env?.[i] and !true
 $env?.[i].i and false
 $env?.[list] contains str && false
 $env?.[list] || false or true
+$env?.[nil] != array
+$env?.[nil] != ok
 $env?.[nil] == array?.[0]
 $env?.[nil] == ok
 $env?.[nil] == str
+$env?.[nil] ?? add
+$env?.[nil] ?? map($env, foo)
+$env?.[nil] endsWith str
+$env?.[nil] in $env?.[String]
+$env?.[nil] not endsWith str
+$env?.[nil] not startsWith str
+$env?.[nil] | get(nil)
 $env?.[nil]?.Bar
 $env?.[nil]?.Bar()
 $env?.[nil]?.Bar?.[add]
+$env?.[nil]?.Bar?.[str]
 $env?.[nil]?.String
 $env?.[nil]?.String()
+$env?.[nil]?.String(Bar?.[str])
+$env?.[nil]?.String(f64)
+$env?.[nil]?.String(false ?? foobar)
+$env?.[nil]?.String.greet
+$env?.[nil]?.String?.[add]
+$env?.[nil]?.String?.[list]
 $env?.[nil]?.[add]
+$env?.[nil]?.[add].Bar
 $env?.[nil]?.[add]?.[add]
+$env?.[nil]?.[add]?.array
 $env?.[nil]?.[array]
 $env?.[nil]?.[array].count(i)
 $env?.[nil]?.[array]?.f64()
@@ -2242,55 +4512,90 @@ $env?.[nil]?.[f64]?.Bar
 $env?.[nil]?.[foo]
 $env?.[nil]?.[foo]?.i()
 $env?.[nil]?.[greet]
+$env?.[nil]?.[greet]?.Bar
 $env?.[nil]?.[greet]?.array()
 $env?.[nil]?.[i]
 $env?.[nil]?.[list]
 $env?.[nil]?.[ok]
 $env?.[nil]?.[str]
 $env?.[nil]?.[str]?.[array]
+$env?.[nil]?.[{foo: 1}]
 $env?.[nil]?.add
 $env?.[nil]?.add()
 $env?.[nil]?.array
+$env?.[nil]?.array()
 $env?.[nil]?.array(add)
 $env?.[nil]?.array(list)
+$env?.[nil]?.array?.[foo]
+$env?.[nil]?.array?.add
 $env?.[nil]?.f64
+$env?.[nil]?.f64()
 $env?.[nil]?.f64.add
 $env?.[nil]?.f64.f64
+$env?.[nil]?.f64.foo()
 $env?.[nil]?.f64.i
+$env?.[nil]?.flatten(0)
 $env?.[nil]?.foo
 $env?.[nil]?.foo()
 $env?.[nil]?.foo?.String
+$env?.[nil]?.foobar
 $env?.[nil]?.foobar.String()
+$env?.[nil]?.foobar.str
+$env?.[nil]?.foobar?.i
 $env?.[nil]?.greet
 $env?.[nil]?.greet()
 $env?.[nil]?.greet(foobar)
 $env?.[nil]?.greet.f64
+$env?.[nil]?.greet?.f64
 $env?.[nil]?.i
 $env?.[nil]?.i()
 $env?.[nil]?.i(true or $env >= ok)
 $env?.[nil]?.i?.f64
 $env?.[nil]?.list
 $env?.[nil]?.list($env?.foo)
+$env?.[nil]?.list()
 $env?.[nil]?.list?.array
+$env?.[nil]?.list?.f64
 $env?.[nil]?.list?.i
+$env?.[nil]?.map(foo)
 $env?.[nil]?.ok
 $env?.[nil]?.ok()
+$env?.[nil]?.ok(f64)
 $env?.[nil]?.ok?.[str]
+$env?.[nil]?.ok?.f64
 $env?.[nil]?.str
 $env?.[nil]?.str()
 $env?.[nil]?.str(String)
 $env?.[nil]?.str(foobar)
+$env?.[nil]?.str(str)?.[f64]
+$env?.[nil]?.str?.greet()
+$env?.[ok] - 1 or true
+$env?.[str] != 1 and false
 $env?.[str] != add
+$env?.[str] != add != $env
+$env?.[str] != array
 $env?.[str] != f64
+$env?.[str] != foo
+$env?.[str] != foo.Bar
+$env?.[str] != foo?.String()
 $env?.[str] != greet
 $env?.[str] != i
+$env?.[str] != list
 $env?.[str] != ok
 $env?.[str] != str
+$env?.[str] != string(1.0)
+$env?.[str] != type(str)
 $env?.[str] + str
+$env?.[str] < foo?.Bar
+$env?.[str] < foo?.String()
 $env?.[str] < str
+$env?.[str] <= $env.str
 $env?.[str] <= str
 $env?.[str] == 1.0 == $env
+$env?.[str] == add
 $env?.[str] == array
+$env?.[str] == f64
+$env?.[str] == first($env)
 $env?.[str] == foo
 $env?.[str] == greet
 $env?.[str] == i
@@ -2298,17 +4603,36 @@ $env?.[str] == ok
 $env?.[str] == str
 $env?.[str] > str
 $env?.[str] >= str
+$env?.[str] ?? $env[:foobar]
+$env?.[str] ?? add
+$env?.[str] ?? array
+$env?.[str] ?? foo
+$env?.[str] ?? greet
+$env?.[str] ?? i
+$env?.[str] ?? list
+$env?.[str] ?? ok
+$env?.[str] ?? str
+$env?.[str] contains foo?.Bar
 $env?.[str] contains str
+$env?.[str] contains type(greet)
 $env?.[str] endsWith $env?.str
 $env?.[str] endsWith str
+$env?.[str] in $env.foo
+$env?.[str] in $env.list
+$env?.[str] in array
 $env?.[str] in list
+$env?.[str] matches foo?.Bar
 $env?.[str] matches str
+$env?.[str] not contains str
 $env?.[str] not endsWith str
 $env?.[str] not in $env == ok
 $env?.[str] not in $env.list
 $env?.[str] not in $env?.[Bar]
 $env?.[str] not in $env?.array
 $env?.[str] not in array
+$env?.[str] not in list
+$env?.[str] not in {foo: 1}
+$env?.[str] not matches $env?.[Bar]
 $env?.[str] not matches foo?.String()
 $env?.[str] not matches str
 $env?.[str] not startsWith str
@@ -2319,11 +4643,17 @@ $env?.[str] | all(false)
 $env?.[str] | all(ok)
 $env?.[str] | all(true)
 $env?.[str] | any(any(list, true))
+$env?.[str] | any(false)
+$env?.[str] | any(ok)
 $env?.[str] | any(true)
 $env?.[str] | count(false)
 $env?.[str] | count(i != 0)
 $env?.[str] | count(ok)
+$env?.[str] | count(true)
+$env?.[str] | date(str)
 $env?.[str] | filter(false)
+$env?.[str] | filter(true != false)
+$env?.[str] | filter(true)
 $env?.[str] | find(0 >= #)
 $env?.[str] | find(false)
 $env?.[str] | find(ok)
@@ -2335,11 +4665,13 @@ $env?.[str] | findIndex(ok)
 $env?.[str] | findIndex(true)
 $env?.[str] | findLast(false)
 $env?.[str] | findLast(ok)
+$env?.[str] | findLast(true)
 $env?.[str] | findLastIndex(false)
 $env?.[str] | findLastIndex(true)
 $env?.[str] | greet()
 $env?.[str] | groupBy(#)
 $env?.[str] | groupBy(0)
+$env?.[str] | groupBy(1)
 $env?.[str] | groupBy(1.0)
 $env?.[str] | groupBy(f64)
 $env?.[str] | groupBy(false)
@@ -2351,24 +4683,35 @@ $env?.[str] | groupBy(true)
 $env?.[str] | hasPrefix(str)
 $env?.[str] | indexOf(str)
 $env?.[str] | map(#)
+$env?.[str] | map($env)
+$env?.[str] | map(0)
 $env?.[str] | map(1)
 $env?.[str] | map(1.0)
 $env?.[str] | map(add)
+$env?.[str] | map(false)
 $env?.[str] | map(foo)
 $env?.[str] | map(greet)
 $env?.[str] | map(i)
+$env?.[str] | map(list)
+$env?.[str] | map(ok)
 $env?.[str] | map(str)
 $env?.[str] | map(true)
 $env?.[str] | none(false)
 $env?.[str] | none(ok)
 $env?.[str] | none(true)
 $env?.[str] | one(false)
+$env?.[str] | one(ok)
 $env?.[str] | one(true)
 $env?.[str] | reduce(#)
+$env?.[str] | reduce(#, add)
 $env?.[str] | reduce(#, array)
 $env?.[str] | reduce(#, false)
 $env?.[str] | reduce(#, ok)
+$env?.[str] | reduce(#, str)
+$env?.[str] | reduce(#acc)
 $env?.[str] | reduce($env)
+$env?.[str] | reduce($env, ok)
+$env?.[str] | reduce($env, true)
 $env?.[str] | reduce(0)
 $env?.[str] | reduce(0, nil)
 $env?.[str] | reduce(1, 1.0)
@@ -2384,8 +4727,11 @@ $env?.[str] | reduce(false, greet)
 $env?.[str] | reduce(foo)
 $env?.[str] | reduce(foo, true)
 $env?.[str] | reduce(greet)
+$env?.[str] | reduce(greet, add)
 $env?.[str] | reduce(greet, foo)
 $env?.[str] | reduce(i)
+$env?.[str] | reduce(list)
+$env?.[str] | reduce(list, true)
 $env?.[str] | reduce(ok)
 $env?.[str] | reduce(ok, $env)
 $env?.[str] | reduce(str)
@@ -2405,37 +4751,76 @@ $env?.[str] | sum(1.0)
 $env?.[str] | sum(f64)
 $env?.[str] | sum(i)
 $env?.[str] | trimSuffix(str)
+$env?.[str].Bar or true
+$env?.[str]?.[-1.0]
 $env?.[str]?.[f64]
 $env?.[str]?.[f64] * f64
 $env?.[str]?.[i]
+$env?.[str][:-1]
 $env?.[str][:]
+$env?.[str][:f64]
 $env?.[str][:i]
 $env?.[str][array?.[f64]:]
 $env?.[str][f64:]
+$env?.add != 1.0 ?? 1
+$env?.add != add
+$env?.add == $env || ok
 $env?.add == add
+$env?.add ?? $env.i
+$env?.add ?? add
+$env?.add ?? array
+$env?.add ?? f64
+$env?.add ?? foo?.Bar
+$env?.add ?? greet
+$env?.add ?? i
+$env?.add ?? join($env)
+$env?.add ?? list
+$env?.add ?? ok
+$env?.add ?? reverse($env)
+$env?.add ?? str
+$env?.add ?? sum($env)
+$env?.add in $env?.Bar
+$env?.add not in $env?.[Bar]
 $env?.array != array
 $env?.array != array || $env
 $env?.array != list
 $env?.array == array
 $env?.array == list
+$env?.array ?? $env?.[add]
+$env?.array ?? ceil(1.0)
+$env?.array ?? f64
+$env?.array ?? false | groupBy(foo)
+$env?.array ?? fromBase64(str)
+$env?.array ?? i
+$env?.array ?? list
+$env?.array ?? ok
+$env?.array ?? str
+$env?.array ?? true | map(add)
+$env?.array in $env?.[Bar]
+$env?.array in sort($env)
 $env?.array | all(false)
 $env?.array | all(ok)
 $env?.array | all(true)
 $env?.array | any(# == 0)
+$env?.array | any(false)
 $env?.array | any(ok)
+$env?.array | any(true)
 $env?.array | count(ok)
 $env?.array | count(true)
 $env?.array | filter(false)
+$env?.array | filter(ok)
 $env?.array | filter(true)
 $env?.array | find(false)
 $env?.array | find(ok)
 $env?.array | find(true)
 $env?.array | findIndex(ok)
 $env?.array | findIndex(true)
+$env?.array | findLast(false ?? nil)
 $env?.array | findLast(false)
 $env?.array | findLast(ok)
 $env?.array | findLast(true)
 $env?.array | findLastIndex(false)
+$env?.array | findLastIndex(ok)
 $env?.array | findLastIndex(true)
 $env?.array | get(1)
 $env?.array | groupBy(#)
@@ -2444,39 +4829,60 @@ $env?.array | groupBy(1)
 $env?.array | groupBy(1.0)
 $env?.array | groupBy(false)
 $env?.array | groupBy(foo)
+$env?.array | groupBy(mean(1))
 $env?.array | groupBy(ok)
 $env?.array | groupBy(str)
 $env?.array | groupBy(true)
 $env?.array | map(#)
+$env?.array | map(#index)
 $env?.array | map($env)
 $env?.array | map(0)
+$env?.array | map(1)
 $env?.array | map(1.0)
 $env?.array | map(add)
 $env?.array | map(array)
 $env?.array | map(f64)
+$env?.array | map(false)
 $env?.array | map(foo)
+$env?.array | map(i)
+$env?.array | map(list)
 $env?.array | map(ok)
+$env?.array | map(str)
 $env?.array | map(true)
+$env?.array | mean(1)
 $env?.array | mean(1.0)
+$env?.array | mean(f64)
+$env?.array | min(array)
+$env?.array | min(i)
+$env?.array | none(false)
 $env?.array | none(ok)
 $env?.array | none(true)
+$env?.array | one(f64 != nil)
 $env?.array | one(false)
 $env?.array | one(ok)
 $env?.array | one(true)
 $env?.array | reduce(#)
 $env?.array | reduce(#, $env)
 $env?.array | reduce(#, 1)
+$env?.array | reduce(#, array)
+$env?.array | reduce(#, f64)
 $env?.array | reduce(#, foo)
 $env?.array | reduce(#, true)
 $env?.array | reduce(#acc)
+$env?.array | reduce(#index)
 $env?.array | reduce($env)
+$env?.array | reduce($env, $env)
 $env?.array | reduce($env, add)
+$env?.array | reduce($env, greet)
 $env?.array | reduce($env, nil)
+$env?.array | reduce(0)
 $env?.array | reduce(0, foo)
+$env?.array | reduce(1 == #)
 $env?.array | reduce(1)
 $env?.array | reduce(1, 1)
 $env?.array | reduce(1, list)
 $env?.array | reduce(1.0)
+$env?.array | reduce(1.0, array)
 $env?.array | reduce(add)
 $env?.array | reduce(add, 1.0)
 $env?.array | reduce(add, nil)
@@ -2484,9 +4890,15 @@ $env?.array | reduce(array)
 $env?.array | reduce(f64)
 $env?.array | reduce(false)
 $env?.array | reduce(foo)
+$env?.array | reduce(foo, foo)
+$env?.array | reduce(greet, str)
+$env?.array | reduce(i)
 $env?.array | reduce(i, 1.0)
 $env?.array | reduce(ok)
+$env?.array | reduce(ok, true)
+$env?.array | reduce(str)
 $env?.array | reduce(true)
+$env?.array | reduce(true, 0)
 $env?.array | sortBy(#)
 $env?.array | sortBy(0)
 $env?.array | sortBy(1)
@@ -2497,65 +4909,118 @@ $env?.array | sortBy(str)
 $env?.array | sum(#)
 $env?.array | sum(1)
 $env?.array | sum(1.0)
+$env?.array | sum(f64)
 $env?.array | sum(i)
 $env?.array | take(0)
 $env?.array; i
+$env?.array?.[-0]
+$env?.array?.[-1]
 $env?.array?.[first(array)]
 $env?.array?.[i]
+$env?.array[:$env.i]
 $env?.array[:]
+$env?.array[:i]
+$env?.f64 != $env?.String
+$env?.f64 != f64
 $env?.f64 != i
+$env?.f64 != nil ?? 1.0
 $env?.f64 * 1.0 == 1.0
 $env?.f64 * f64
+$env?.f64 * i
+$env?.f64 ** $env.f64
 $env?.f64 ** 0 / f64
 $env?.f64 ** f64
 $env?.f64 ** i
 $env?.f64 ** int(f64)
 $env?.f64 + 0 < 1.0
+$env?.f64 + 1 * 0
 $env?.f64 + f64
 $env?.f64 + i
+$env?.f64 - 1 / f64
 $env?.f64 - 1.0 == 1.0
+$env?.f64 - 1.0 > 0
 $env?.f64 - f64
 $env?.f64 / f64
 $env?.f64 / i
 $env?.f64 / len($env)
 $env?.f64 < 0 % i
+$env?.f64 < 1.0 - 1
 $env?.f64 < 1.0 - 1.0
 $env?.f64 < f64
 $env?.f64 < i
+$env?.f64 <= f64
+$env?.f64 <= i
+$env?.f64 == $env?.[Bar]
+$env?.f64 == $env?.[str]
 $env?.f64 == f64
 $env?.f64 == i
+$env?.f64 == max(array, 1.0)
 $env?.f64 > f64
 $env?.f64 > i
+$env?.f64 >= -1
 $env?.f64 >= f64
+$env?.f64 >= i
+$env?.f64 >= i == false
 $env?.f64 >= round(f64)
+$env?.f64 ?? 1.0 ?? i
+$env?.f64 ?? add
+$env?.f64 ?? array
+$env?.f64 ?? foo
+$env?.f64 ?? foo.String
+$env?.f64 ?? greet
+$env?.f64 ?? list
+$env?.f64 ?? list ?? foo
+$env?.f64 ?? ok
+$env?.f64 ?? str
+$env?.f64 ?? upper($env)
+$env?.f64 ^ $env?.f64
+$env?.f64 ^ f64
 $env?.f64 ^ i
+$env?.f64 in $env.array
 $env?.f64 in array
 $env?.f64 not in $env?.String
 $env?.f64 not in array
+$env?.f64 | max(1.0)
+$env?.f64 | mean(0)
 $env?.f64 | mean(1.0)
+$env?.f64 | median(0)
+$env?.f64 | median(1.0, f64)
 $env?.f64 | median(f64)
+$env?.f64 | min(1.0, 1.0)
 $env?.false != add
 $env?.false != ok
 $env?.false == add
+$env?.false ?? array
 $env?.false contains $env?.String
 $env?.false endsWith str
+$env?.false in list
 $env?.false?.Bar
 $env?.false?.Bar()
+$env?.false?.Bar()?.[i]
 $env?.false?.Bar.String
 $env?.false?.String
+$env?.false?.String([foobar contains String])
+$env?.false?.String?.list
 $env?.false?.[add]
+$env?.false?.[add].String()
+$env?.false?.[add].i
 $env?.false?.[array]
+$env?.false?.[array].String()
 $env?.false?.[array]?.String
 $env?.false?.[f64]
 $env?.false?.[foo]
+$env?.false?.[foo].String?.list
 $env?.false?.[greet]
 $env?.false?.[i]
 $env?.false?.[list]
+$env?.false?.[list]?.array()
 $env?.false?.[ok]
+$env?.false?.[ok]?.[foo]
 $env?.false?.[str]
 $env?.false?.add
 $env?.false?.add()
 $env?.false?.add?.[f64]
+$env?.false?.add?.[greet]
 $env?.false?.array
 $env?.false?.array()
 $env?.false?.array(f64)
@@ -2567,20 +5032,41 @@ $env?.false?.foo
 $env?.false?.foo()
 $env?.false?.foo(foobar, i .. f64)
 $env?.false?.foobar
+$env?.false?.foobar.array
+$env?.false?.foobar?.array()
+$env?.false?.foobar?.str
 $env?.false?.greet
 $env?.false?.greet()
+$env?.false?.groupBy(str)
 $env?.false?.i
 $env?.false?.i.str
 $env?.false?.list
 $env?.false?.list()
+$env?.false?.list(String == foobar?.[str])
 $env?.false?.list?.Bar
+$env?.false?.list?.[foo]
 $env?.false?.ok
 $env?.false?.ok()
+$env?.false?.ok?.[list]
+$env?.false?.ok?.foobar.foo
+$env?.false?.sortBy($env)
 $env?.false?.str
 $env?.false?.str()
 $env?.false?.str.foo
 $env?.false?.str?.add
+$env?.foo == foo
+$env?.foo ?? $env?.String
+$env?.foo ?? $env?.[f64]
+$env?.foo ?? array
+$env?.foo ?? f64
+$env?.foo ?? foo
+$env?.foo ?? ok
+$env?.foo ?? str
+$env?.foo ?? {foo: i}
+$env?.foo in $env?.[Bar]
 $env?.foo in list
+$env?.foo not in $env?.[String]
+$env?.foo not in [$env]
 $env?.foo not in list
 $env?.foo.Bar
 $env?.foo.String
@@ -2588,76 +5074,151 @@ $env?.foo.String()
 $env?.foo?.Bar
 $env?.foo?.String
 $env?.foo?.String()
+$env?.foobar != -f64
 $env?.foobar != f64
+$env?.foobar != greet
 $env?.foobar != str
 $env?.foobar == $env.i
+$env?.foobar == $env.str
+$env?.foobar == $env?.add
 $env?.foobar == [1.0]
 $env?.foobar == add
 $env?.foobar == array
+$env?.foobar == f64
 $env?.foobar == foo
 $env?.foobar == greet
 $env?.foobar == list
 $env?.foobar == ok
 $env?.foobar == reduce(list, false)
+$env?.foobar == str
+$env?.foobar ?? $env?.[String]
+$env?.foobar ?? i
+$env?.foobar ?? list
+$env?.foobar ?? ok
+$env?.foobar contains greet(str)
 $env?.foobar contains str
 $env?.foobar endsWith str
 $env?.foobar in array
 $env?.foobar in groupBy(array, 1.0)
+$env?.foobar in list
 $env?.foobar matches str
 $env?.foobar not contains str
+$env?.foobar not endsWith str
+$env?.foobar not in array
+$env?.foobar not in array == $env
+$env?.foobar not matches str
+$env?.foobar startsWith str
+$env?.foobar | get(add)
+$env?.foobar | get(ok)
+$env?.foobar?.$env.array(foo)
 $env?.foobar?.$env?.[f64]
 $env?.foobar?.Bar
 $env?.foobar?.Bar()
 $env?.foobar?.Bar().str
+$env?.foobar?.Bar()?.[str]
+$env?.foobar?.Bar(foobar)
+$env?.foobar?.Bar(greet)
+$env?.foobar?.Bar(list)
 $env?.foobar?.Bar.str
 $env?.foobar?.Bar?.[list]
 $env?.foobar?.Bar?.list()
 $env?.foobar?.String
 $env?.foobar?.String()
+$env?.foobar?.String()?.Bar
+$env?.foobar?.String(array)
 $env?.foobar?.String(foo)
 $env?.foobar?.String(foobar)
+$env?.foobar?.String.i
+$env?.foobar?.String.ok
+$env?.foobar?.String?.[greet]
+$env?.foobar?.String?.add
 $env?.foobar?.[add]
+$env?.foobar?.[add].list
 $env?.foobar?.[add]?.[array]
 $env?.foobar?.[add]?.[f64]
 $env?.foobar?.[add]?.f64
+$env?.foobar?.[add]?.foo
 $env?.foobar?.[add]?.greet()
 $env?.foobar?.[array]
+$env?.foobar?.[array] in list
+$env?.foobar?.[array].ok()
+$env?.foobar?.[array].str
+$env?.foobar?.[array]?.[f64]
+$env?.foobar?.[array]?.[f64]?.list?.[i]
+$env?.foobar?.[array]?.i?.f64
 $env?.foobar?.[count($env)]
 $env?.foobar?.[f64]
+$env?.foobar?.[f64].add
 $env?.foobar?.[f64]?.Bar
+$env?.foobar?.[f64]?.[foo]
+$env?.foobar?.[f64]?.[i]
+$env?.foobar?.[f64]?.[list]
 $env?.foobar?.[f64]?.add
 $env?.foobar?.[f64]?.f64(foobar)
+$env?.foobar?.[f64]?.foo
+$env?.foobar?.[f64]?.greet
+$env?.foobar?.[f64]?.i
 $env?.foobar?.[foo]
+$env?.foobar?.[foo].Bar
 $env?.foobar?.[foo].str
 $env?.foobar?.[foo]?.[i]
+$env?.foobar?.[foo]?.[str]
 $env?.foobar?.[foo]?.ok
 $env?.foobar?.[greet]
+$env?.foobar?.[greet].ok().array
+$env?.foobar?.[greet].str
+$env?.foobar?.[greet]?.[greet]
 $env?.foobar?.[greet]?.add
 $env?.foobar?.[greet]?.array
+$env?.foobar?.[greet]?.ok
 $env?.foobar?.[i]
+$env?.foobar?.[i].add
+$env?.foobar?.[i].str()
+$env?.foobar?.[i]?.Bar
+$env?.foobar?.[i]?.[list]
 $env?.foobar?.[i]?.[ok]
 $env?.foobar?.[i]?.foo()
 $env?.foobar?.[i]?.i
 $env?.foobar?.[i]?.list
+$env?.foobar?.[i]?.ok
 $env?.foobar?.[list]
 $env?.foobar?.[list] != ok
 $env?.foobar?.[list].Bar
+$env?.foobar?.[list].greet()
 $env?.foobar?.[list].list
 $env?.foobar?.[list]?.[f64]
 $env?.foobar?.[list]?.add
+$env?.foobar?.[list]?.i
+$env?.foobar?.[nil ?? list]
 $env?.foobar?.[ok]
+$env?.foobar?.[ok].ok
+$env?.foobar?.[ok]?.ok
+$env?.foobar?.[ok]?.ok()
 $env?.foobar?.[ok]?.str
 $env?.foobar?.[str]
 $env?.foobar?.[str].String
+$env?.foobar?.[str].array
+$env?.foobar?.[str].foo
 $env?.foobar?.[str].list(foobar?.[i].ok)
+$env?.foobar?.[str].ok
 $env?.foobar?.[str]?.f64
+$env?.foobar?.[str]?.i
 $env?.foobar?.[str]?.list
 $env?.foobar?.add
+$env?.foobar?.add($env)
 $env?.foobar?.add()
+$env?.foobar?.add().f64()
 $env?.foobar?.add(1.0)
 $env?.foobar?.add(foobar)
+$env?.foobar?.add(foobar?.[add])
+$env?.foobar?.add.Bar()
+$env?.foobar?.add.add()
 $env?.foobar?.add.array
+$env?.foobar?.add.foo
+$env?.foobar?.add.ok
+$env?.foobar?.add.str
 $env?.foobar?.add?.[greet]
+$env?.foobar?.add?.[greet]?.foo
 $env?.foobar?.add?.[i]
 $env?.foobar?.add?.[str]
 $env?.foobar?.add?.add
@@ -2670,26 +5231,42 @@ $env?.foobar?.all(str)
 $env?.foobar?.array
 $env?.foobar?.array()
 $env?.foobar?.array().list
+$env?.foobar?.array()?.foo
 $env?.foobar?.array(Bar)
+$env?.foobar?.array(foo)
 $env?.foobar?.array(foobar)
+$env?.foobar?.array(foobar, ok)
+$env?.foobar?.array(i)
+$env?.foobar?.array.array()
 $env?.foobar?.array.foo
+$env?.foobar?.array.list()
 $env?.foobar?.array.ok
+$env?.foobar?.array.str
 $env?.foobar?.array?.String(i)
+$env?.foobar?.array?.[add]
 $env?.foobar?.array?.array
 $env?.foobar?.array?.list
 $env?.foobar?.count($env)
 $env?.foobar?.count(foo, foo)
 $env?.foobar?.f64
+$env?.foobar?.f64 not matches $env
 $env?.foobar?.f64()
 $env?.foobar?.f64()?.greet
 $env?.foobar?.f64(add)?.String(list)
+$env?.foobar?.f64(false ? foobar : foobar)
+$env?.foobar?.f64(foobar)
+$env?.foobar?.f64(foobar?.[String])
 $env?.foobar?.f64.f64
 $env?.foobar?.f64.i
 $env?.foobar?.f64?.[array].Bar
 $env?.foobar?.f64?.[foo]?.[greet]
+$env?.foobar?.f64?.[i]
+$env?.foobar?.f64?.[ok]
+$env?.foobar?.f64?.array
 $env?.foobar?.f64?.array()
 $env?.foobar?.f64?.foo
 $env?.foobar?.false?.i()
+$env?.foobar?.filter(f64)
 $env?.foobar?.findIndex(array)
 $env?.foobar?.findLast($env, $env)
 $env?.foobar?.findLastIndex(foo, f64, array)
@@ -2697,18 +5274,28 @@ $env?.foobar?.findLastIndex(true)
 $env?.foobar?.foo
 $env?.foobar?.foo()
 $env?.foobar?.foo(array)
+$env?.foobar?.foo(ceil(Bar, 1), foobar?.Bar())
 $env?.foobar?.foo(foobar | string($env))
 $env?.foobar?.foo(foobar)?.[i]
+$env?.foobar?.foo(i)
+$env?.foobar?.foo.f64
 $env?.foobar?.foo.ok
 $env?.foobar?.foo?.String
 $env?.foobar?.foo?.[add]
 $env?.foobar?.foo?.[foo]
+$env?.foobar?.foo?.[greet]
+$env?.foobar?.foo?.ok(str)
 $env?.foobar?.foo?.str
 $env?.foobar?.foobar
+$env?.foobar?.foobar?.[f64]
+$env?.foobar?.foobar?.[foo]
 $env?.foobar?.foobar?.[greet]
+$env?.foobar?.foobar?.[ok]
 $env?.foobar?.greet
 $env?.foobar?.greet()
 $env?.foobar?.greet(array)
+$env?.foobar?.greet(foobar)
+$env?.foobar?.greet(list)
 $env?.foobar?.greet.Bar
 $env?.foobar?.greet.array
 $env?.foobar?.greet?.add
@@ -2718,6 +5305,8 @@ $env?.foobar?.i
 $env?.foobar?.i()
 $env?.foobar?.i(foobar)
 $env?.foobar?.i(list not endsWith foobar)
+$env?.foobar?.i.array
+$env?.foobar?.i?.Bar
 $env?.foobar?.i?.f64
 $env?.foobar?.i?.greet
 $env?.foobar?.i?.ok
@@ -2725,50 +5314,106 @@ $env?.foobar?.list
 $env?.foobar?.list()
 $env?.foobar?.list().ok
 $env?.foobar?.list()?.f64
+$env?.foobar?.list(foobar)
 $env?.foobar?.list?.[greet]
+$env?.foobar?.list?.[list]
 $env?.foobar?.list?.foo
 $env?.foobar?.min(foobar, 1.0)
+$env?.foobar?.nil.foobar
+$env?.foobar?.none(1)
 $env?.foobar?.none(array)
 $env?.foobar?.not
 $env?.foobar?.not?.[ok]
 $env?.foobar?.ok
 $env?.foobar?.ok()
+$env?.foobar?.ok().String()
 $env?.foobar?.ok(foobar not contains foobar)
+$env?.foobar?.ok(foobar)
 $env?.foobar?.ok(ok)
+$env?.foobar?.ok(str, $env)
 $env?.foobar?.ok.array
+$env?.foobar?.ok.f64()
+$env?.foobar?.ok?.[array]
+$env?.foobar?.ok?.[f64]
+$env?.foobar?.ok?.[greet]
 $env?.foobar?.ok?.[str]
 $env?.foobar?.ok?.i
+$env?.foobar?.ok?.ok
 $env?.foobar?.one(foobar)
+$env?.foobar?.one(i)
+$env?.foobar?.reduce(1.0)
+$env?.foobar?.repeat(foobar)
 $env?.foobar?.replace(str)
+$env?.foobar?.reverse($env)
+$env?.foobar?.round(foo)
 $env?.foobar?.split(1.0)
 $env?.foobar?.str
 $env?.foobar?.str()
 $env?.foobar?.str().String
+$env?.foobar?.str()?.[foo]
+$env?.foobar?.str(1 ?? foobar)
 $env?.foobar?.str(String?.[i])
 $env?.foobar?.str(foo)
+$env?.foobar?.str(foobar)
 $env?.foobar?.str.array
 $env?.foobar?.str.i
+$env?.foobar?.str.str
+$env?.foobar?.str?.[f64]
+$env?.foobar?.str?.[i]
 $env?.foobar?.str?.[str]
 $env?.foobar?.str?.add
 $env?.foobar?.str?.i
 $env?.foobar?.string($env)
 $env?.foobar?.timezone(str)
+$env?.foobar?.trimSuffix(list, i)
+$env?.foobar?.true?.$env
 $env?.foobar?.true?.str
+$env?.foobar?.uniq(foobar).add
+$env?.foobar?.upper(list)
 $env?.greet != greet
+$env?.greet == $env?.[Bar]
 $env?.greet == find($env, false)
 $env?.greet == greet
+$env?.greet == list ?? 1.0
+$env?.greet ?? $env?.Bar(true)
+$env?.greet ?? $env?.[String]
+$env?.greet ?? add
+$env?.greet ?? array
+$env?.greet ?? f64
+$env?.greet ?? foo
+$env?.greet ?? greet
+$env?.greet ?? i
+$env?.greet ?? list
+$env?.greet ?? nil ?? foo
+$env?.greet ?? ok ?? foo
+$env?.greet ?? str
+$env?.greet($env?.[str])
 $env?.greet($env?.str)
 $env?.greet(foo.Bar)
 $env?.greet(foo.String())
+$env?.greet(foo?.Bar)
 $env?.greet(foo?.String())
 $env?.greet(greet(str))
+$env?.greet(str ?? str)
 $env?.greet(str)
 $env?.greet(str) startsWith str
+$env?.greet(str[:])
 $env?.greet(string(0))
+$env?.greet(toJSON(1.0))
+$env?.greet(toJSON(array))
 $env?.greet(toJSON(false))
+$env?.greet(toJSON(str))
+$env?.greet(trim(str))
+$env?.greet(type(greet))
+$env?.greet(type(ok))
 $env?.greet(type(true))
+$env?.greet(upper(str))
+$env?.i != $env?.foobar
+$env?.i != 1.0 ** i
 $env?.i != f64
 $env?.i != i
+$env?.i % $env.i
+$env?.i % 1 ?? foo
 $env?.i % i
 $env?.i * 1 != $env
 $env?.i * f64
@@ -2776,54 +5421,108 @@ $env?.i * i
 $env?.i ** 1.0 >= i
 $env?.i ** f64
 $env?.i ** i
+$env?.i ** int(1.0)
+$env?.i + $env?.f64
 $env?.i + f64
 $env?.i + findIndex($env, ok)
+$env?.i + i
 $env?.i - ceil(i)
 $env?.i - i
 $env?.i .. 1 | groupBy(f64)
 $env?.i .. i
+$env?.i / 1.0 <= i
 $env?.i / f64
 $env?.i / i
+$env?.i / len(list)
 $env?.i / max(1.0)
+$env?.i < 1.0 - 0
 $env?.i < f64
 $env?.i < i
+$env?.i < i + 1
+$env?.i <= 0 ^ 1.0
 $env?.i <= f64
 $env?.i <= i
+$env?.i == 1 - 0
 $env?.i == f64
 $env?.i == first($env)
 $env?.i == i
+$env?.i == len($env)
 $env?.i == len(list)
 $env?.i == max($env)
+$env?.i > 0 * 1.0
+$env?.i > 1 ?? nil
 $env?.i > f64
 $env?.i > i
+$env?.i > i != true
 $env?.i >= $env?.f64
 $env?.i >= 0 or $env
 $env?.i >= 1.0 ** 1
 $env?.i >= f64
 $env?.i >= floor(1.0)
 $env?.i >= i
+$env?.i ?? add
+$env?.i ?? f64
+$env?.i ?? filter($env, #.f64)
+$env?.i ?? foo
+$env?.i ?? greet
+$env?.i ?? i
+$env?.i ?? str
+$env?.i ?? str ?? str
+$env?.i ?? sum($env)
+$env?.i ^ 1.0 * 1
 $env?.i ^ i
 $env?.i ^ i not in array
 $env?.i in array
+$env?.i not in $env?.String
 $env?.i not in $env?.[Bar]
 $env?.i not in array
+$env?.i | add(0)
+$env?.i | add(1)
+$env?.i | bitand(i)
 $env?.i | bitnand(0)
 $env?.i | bitnand(1)
 $env?.i | bitor(i)
 $env?.i | bitshl(0)
+$env?.i | bitushr(i)
+$env?.i | max(1.0)
+$env?.i | max(array)
 $env?.i | mean(i)
+$env?.i | median(0)
+$env?.i | median(1)
+$env?.i | median(1.0)
 $env?.i | median(f64)
+$env?.i | median(i)
+$env?.i | min(1, f64)
+$env?.i | min(f64, 1)
+$env?.i..i
 $env?.list != [1.0]
 $env?.list != array
 $env?.list != list
 $env?.list == [foo, 0]
+$env?.list == array
 $env?.list == list
 $env?.list == nil || $env
+$env?.list ?? $env?.add
+$env?.list ?? add
+$env?.list ?? array
+$env?.list ?? f64
+$env?.list ?? foo
+$env?.list ?? greet
+$env?.list ?? i
+$env?.list ?? nil ?? ok
+$env?.list ?? nil | groupBy(#)
+$env?.list ?? ok
+$env?.list ?? str
+$env?.list ?? toJSON(add)
+$env?.list ?? toPairs($env)
 $env?.list | all(false)
+$env?.list | all(nil == 1)
 $env?.list | all(ok)
 $env?.list | all(true)
+$env?.list | any(f64 >= f64)
 $env?.list | any(false)
 $env?.list | any(ok)
+$env?.list | any(true)
 $env?.list | concat(list)
 $env?.list | count(false)
 $env?.list | count(ok)
@@ -2833,9 +5532,20 @@ $env?.list | filter(true)
 $env?.list | find(false)
 $env?.list | find(ok)
 $env?.list | find(true)
+$env?.list | findIndex(!ok)
+$env?.list | findIndex(false)
 $env?.list | findIndex(ok)
+$env?.list | findIndex(true)
+$env?.list | findIndex(true) not in array
+$env?.list | findLast(false)
+$env?.list | findLast(ok)
+$env?.list | findLast(true)
 $env?.list | findLastIndex(#.Bar in #)
+$env?.list | findLastIndex(false)
+$env?.list | findLastIndex(ok)
+$env?.list | findLastIndex(true)
 $env?.list | groupBy(#)
+$env?.list | groupBy(#.Bar)
 $env?.list | groupBy(.Bar)
 $env?.list | groupBy(0)
 $env?.list | groupBy(1)
@@ -2849,6 +5559,7 @@ $env?.list | groupBy(str)
 $env?.list | groupBy(true)
 $env?.list | map(#)
 $env?.list | map(#.Bar)
+$env?.list | map(#.String)
 $env?.list | map(#index)
 $env?.list | map($env)
 $env?.list | map(.Bar)
@@ -2867,14 +5578,19 @@ $env?.list | map(ok)
 $env?.list | map(str)
 $env?.list | map(true)
 $env?.list | none(.Bar not startsWith #.Bar)
+$env?.list | none(false)
 $env?.list | none(ok)
 $env?.list | none(true)
 $env?.list | one(false)
 $env?.list | one(ok)
 $env?.list | reduce(#)
+$env?.list | reduce(#, f64)
 $env?.list | reduce(#, false)
+$env?.list | reduce(#, foo)
+$env?.list | reduce(#, i)
 $env?.list | reduce(#.Bar)
 $env?.list | reduce(#.Bar, 0)
+$env?.list | reduce(#.String, $env)
 $env?.list | reduce(#acc)
 $env?.list | reduce(#acc, 1)
 $env?.list | reduce(#acc, true)
@@ -2887,16 +5603,23 @@ $env?.list | reduce(.String, $env)
 $env?.list | reduce(0)
 $env?.list | reduce(1)
 $env?.list | reduce(1.0)
+$env?.list | reduce(1.0, list)
 $env?.list | reduce(add)
 $env?.list | reduce(array)
 $env?.list | reduce(array, $env)
+$env?.list | reduce(f64 == 1)
+$env?.list | reduce(f64, $env)
+$env?.list | reduce(false)
 $env?.list | reduce(foo)
 $env?.list | reduce(foo, nil)
+$env?.list | reduce(foo, ok)
 $env?.list | reduce(foo, str)
 $env?.list | reduce(greet)
+$env?.list | reduce(greet, ok)
 $env?.list | reduce(list)
 $env?.list | reduce(ok)
 $env?.list | reduce(str)
+$env?.list | reduce(str, nil)
 $env?.list | reduce(true)
 $env?.list | reduce(true, i)
 $env?.list | sortBy(#.Bar)
@@ -2905,26 +5628,42 @@ $env?.list | sortBy(0)
 $env?.list | sortBy(1)
 $env?.list | sortBy(1.0)
 $env?.list | sortBy(str)
+$env?.list | sum(0)
 $env?.list | sum(1)
 $env?.list | sum(1.0)
 $env?.list | sum(f64)
 $env?.list | sum(i)
+$env?.list | take(1)
 $env?.list?.[i]
+$env?.list?.[i].Bar
 $env?.list?.[i].String
 $env?.list[:]
+$env?.list[:i]
+$env?.list[i:]
+$env?.nil != $env?.[String]
 $env?.nil != array
 $env?.nil != greet
+$env?.nil == array
 $env?.nil == foo.Bar
+$env?.nil ?? foo.String
+$env?.nil ?? str
 $env?.nil contains $env?.[nil]
+$env?.nil in list
 $env?.nil matches str
 $env?.nil not in array
+$env?.nil startsWith str
+$env?.nil.Bar || true
+$env?.nil?.$env.foo
 $env?.nil?.Bar
 $env?.nil?.Bar()
 $env?.nil?.Bar(list)
 $env?.nil?.Bar?.String(Bar)
 $env?.nil?.Bar?.[i]
+$env?.nil?.Bar?.[list]
 $env?.nil?.String
 $env?.nil?.String()
+$env?.nil?.String(i)
+$env?.nil?.String.i
 $env?.nil?.String?.ok()
 $env?.nil?.[add]
 $env?.nil?.[add]?.[greet]
@@ -2933,58 +5672,110 @@ $env?.nil?.[array]
 $env?.nil?.[array].Bar
 $env?.nil?.[array]?.String
 $env?.nil?.[f64]
+$env?.nil?.[f64]?.f64
 $env?.nil?.[foo]
+$env?.nil?.[foo]?.ok
 $env?.nil?.[greet]
 $env?.nil?.[greet]?.ok
 $env?.nil?.[i]
+$env?.nil?.[i]?.Bar
+$env?.nil?.[i]?.[foo]
 $env?.nil?.[list]
 $env?.nil?.[ok]
+$env?.nil?.[ok]?.str
 $env?.nil?.[str]
+$env?.nil?.[str]?.i
 $env?.nil?.[str]?.str
 $env?.nil?.add
 $env?.nil?.add()
+$env?.nil?.add(foobar)
 $env?.nil?.array
 $env?.nil?.array()
 $env?.nil?.array(str)
+$env?.nil?.array?.foo
+$env?.nil?.array?.list
 $env?.nil?.f64
 $env?.nil?.f64()
+$env?.nil?.f64(foobar != i)
+$env?.nil?.f64?.true?.greet?.foo
+$env?.nil?.filter(0)
 $env?.nil?.filter(1.0)
+$env?.nil?.findIndex(str)
+$env?.nil?.findLast(false)
 $env?.nil?.foo
 $env?.nil?.foo()
+$env?.nil?.foo.foo
 $env?.nil?.foo.i
+$env?.nil?.foo.str
 $env?.nil?.foo?.[add].array
 $env?.nil?.foo?.[f64]
 $env?.nil?.foo?.f64(Bar)
 $env?.nil?.foobar
+$env?.nil?.foobar.ok
+$env?.nil?.foobar?.Bar(foobar, $env)
+$env?.nil?.foobar?.i
 $env?.nil?.greet
 $env?.nil?.greet()
+$env?.nil?.greet?.array
 $env?.nil?.i
+$env?.nil?.i($env.foo)
+$env?.nil?.i()
 $env?.nil?.list
 $env?.nil?.list()
+$env?.nil?.map(foobar)
+$env?.nil?.median(foobar)
 $env?.nil?.ok
 $env?.nil?.ok()
 $env?.nil?.ok(add)
+$env?.nil?.ok(foobar?.[String].add)
+$env?.nil?.ok.add
 $env?.nil?.one(foobar, foobar)
 $env?.nil?.round(1.0)
 $env?.nil?.str
 $env?.nil?.str()
+$env?.nil?.str(foobar)
 $env?.ok && $env?.Bar
 $env?.ok && $env?.[str]
+$env?.ok && $env?.ok
+$env?.ok && nil not in $env
 $env?.ok && ok
 $env?.ok == ok
+$env?.ok ? add : foo
 $env?.ok ? foo == nil : i
+$env?.ok ?: array
 $env?.ok ?: foo
+$env?.ok ?? $env?.[Bar]
+$env?.ok ?? $env?.[add]
+$env?.ok ?? add
+$env?.ok ?? array
+$env?.ok ?? f64
+$env?.ok ?? foo
+$env?.ok ?? greet
+$env?.ok ?? i
+$env?.ok ?? keys($env)
+$env?.ok ?? list
+$env?.ok ?? str
+$env?.ok ?? str ?? $env
 $env?.ok and $env?.[String]
+$env?.ok and 1.0 == i
 $env?.ok and foo != foo
 $env?.ok and ok
 $env?.ok not in $env && false
+$env?.ok or !true
+$env?.ok or $env != $env
+$env?.ok or $env in str
 $env?.ok or i != 1.0
+$env?.ok or nil not in $env
 $env?.ok or ok
 $env?.ok || $env?.Bar()
 $env?.ok || ok
 $env?.ok || sum($env)
+$env?.str != 1.0 ?? foo
 $env?.str + str
+$env?.str < foo.Bar
+$env?.str < str
 $env?.str < type(add)
+$env?.str <= $env?.str
 $env?.str <= foo.Bar
 $env?.str <= str
 $env?.str <= string(str)
@@ -2993,11 +5784,25 @@ $env?.str > str
 $env?.str > str == nil
 $env?.str > toJSON(nil)
 $env?.str >= foo?.Bar
+$env?.str ?? $env.ok
+$env?.str ?? $env?.String()
+$env?.str ?? add
+$env?.str ?? array
+$env?.str ?? f64
+$env?.str ?? foo
+$env?.str ?? greet
+$env?.str ?? list
+$env?.str ?? not ok
+$env?.str ?? ok
+$env?.str ?? str
+$env?.str contains $env?.[Bar]
 $env?.str contains foo?.Bar
 $env?.str contains str
 $env?.str endsWith $env and false
 $env?.str endsWith str
+$env?.str endsWith toJSON(foo)
 $env?.str in $env ? 1.0 : nil
+$env?.str in $env?.[String]
 $env?.str in foo
 $env?.str matches $env?.[String]
 $env?.str matches str
@@ -3005,29 +5810,48 @@ $env?.str not contains str
 $env?.str not endsWith str
 $env?.str not in $env?.[String]
 $env?.str not in foo
+$env?.str not in {foo: greet, foo: nil}
 $env?.str not matches foo.Bar
 $env?.str not matches str
+$env?.str not startsWith $env.str
 $env?.str not startsWith foo?.Bar
+$env?.str not startsWith str
+$env?.str startsWith $env?.Bar
 $env?.str | date(str)
 $env?.str | greet()
+$env?.str | trim(str)
 $env?.str | trimPrefix(str)
+$env?.str[:0 ?? false]
 $env?.str[:]
 $env?.str[:i]
 $env?.str[i:]
+$env?.true != i
 $env?.true != ok
 $env?.true == foo
 $env?.true == i
+$env?.true ?? foo.Bar
 $env?.true not endsWith str
+$env?.true not matches str
+$env?.true | get(array)
 $env?.true?.Bar
 $env?.true?.Bar()
+$env?.true?.Bar(false)
 $env?.true?.String
 $env?.true?.String()
+$env?.true?.String().add
+$env?.true?.String.foo(foobar)
+$env?.true?.String?.Bar.str
 $env?.true?.[add]
 $env?.true?.[array]
 $env?.true?.[array].Bar
+$env?.true?.[array].add()
 $env?.true?.[f64]
+$env?.true?.[f64]?.String()
+$env?.true?.[f64]?.[list]
 $env?.true?.[foo]
 $env?.true?.[greet]
+$env?.true?.[greet].Bar
+$env?.true?.[greet]?.ok
 $env?.true?.[i]
 $env?.true?.[list]
 $env?.true?.[ok]
@@ -3035,8 +5859,10 @@ $env?.true?.[ok]?.[ok]
 $env?.true?.[str]
 $env?.true?.[str].foo
 $env?.true?.add
+$env?.true?.add(foobar matches foo)
 $env?.true?.add.foo
 $env?.true?.array
+$env?.true?.array()
 $env?.true?.f64
 $env?.true?.f64()
 $env?.true?.f64(foobar)
@@ -3045,8 +5871,10 @@ $env?.true?.foo
 $env?.true?.foo()
 $env?.true?.foo?.[ok]
 $env?.true?.foobar
+$env?.true?.foobar?.str
 $env?.true?.greet
 $env?.true?.greet()
+$env?.true?.greet().i
 $env?.true?.greet?.ok
 $env?.true?.i
 $env?.true?.i()
@@ -3055,9 +5883,12 @@ $env?.true?.list()
 $env?.true?.list.foo
 $env?.true?.ok
 $env?.true?.ok()
+$env?.true?.reduce(array)
 $env?.true?.str
 $env?.true?.str()
+$env?.true?.true?.array
 $env[$env:] - f64 and false
+$env[:str] not in foo || true
 - + $env || true
 - + $env.f64
 - + $env.i
@@ -3101,8 +5932,784 @@ $env[$env:] - f64 and false
 - - len($env)
 - - max(1.0)
 - - sum(array)
+-$env && false
+-$env and false
+-$env in str && false
+-$env not in foo || true
+-$env or true
+-$env || true
+-$env.f64
+-$env.f64 - i
+-$env.f64 ?? i
+-$env.i
+-$env.i / i
+-$env.i ?? add
+-$env?.[str]?.[f64]
+-$env?.array?.[i]
+-$env?.f64
+-$env?.i
+-$env?.i != $env
+-$env?.i == f64
+--$env.f64
+--$env?.f64
+--$env?.i
+--0
+--0 .. i
+--0 ?? array
+--1
+--1 < 1.0
+--1.0
+--1.0 - 1.0
+--bitnot(0)
+--f64
+--f64 / f64
+--i
+--sum(array)
 -.0 ** 0
 -.0 / 1
+-0 != $env
+-0 != 0
+-0 != 1
+-0 != 1.0
+-0 != f64
+-0 != i
+-0 != mean(f64)
+-0 != min($env)
+-0 != nil
+-0 % 1
+-0 % i
+-0 % i + f64
+-0 * 0
+-0 * 1
+-0 * 1.0
+-0 * f64
+-0 * i
+-0 ** 0
+-0 ** 1
+-0 ** 1.0
+-0 ** 1.0 < i
+-0 ** 1.0 ?? list
+-0 ** i
+-0 + -f64
+-0 + 0
+-0 + 1
+-0 + 1.0
+-0 + f64
+-0 + f64 != 1.0
+-0 + i
+-0 - 0
+-0 - 1
+-0 - 1.0
+-0 - f64
+-0 - floor(f64)
+-0 - i
+-0 .. 0
+-0 .. 1
+-0 .. i
+-0 / 0
+-0 / 1
+-0 / 1.0
+-0 / f64
+-0 / i
+-0 < 0
+-0 < 1
+-0 < 1.0
+-0 < f64
+-0 < i
+-0 <= 0
+-0 <= 1
+-0 <= 1.0
+-0 <= f64
+-0 <= i
+-0 == $env
+-0 == $env?.Bar
+-0 == $env?.[Bar]
+-0 == 0
+-0 == 1
+-0 == 1.0
+-0 == f64
+-0 == i
+-0 == mean(1.0)
+-0 == nil
+-0 > 0
+-0 > 1
+-0 > 1.0
+-0 > f64
+-0 > i
+-0 >= 0
+-0 >= 0 || false
+-0 >= 1
+-0 >= 1.0
+-0 >= f64
+-0 >= i
+-0 ?? $env
+-0 ?? 0
+-0 ?? 1
+-0 ?? 1.0
+-0 ?? add
+-0 ?? array
+-0 ?? f64
+-0 ?? false
+-0 ?? foo
+-0 ?? foo.Bar
+-0 ?? foo?.Bar
+-0 ?? greet
+-0 ?? i
+-0 ?? list
+-0 ?? min(0, i)
+-0 ?? nil
+-0 ?? ok
+-0 ?? str
+-0 ?? true
+-0 ^ 0
+-0 ^ 0 | max(1)
+-0 ^ 1
+-0 ^ 1.0
+-0 ^ 1.0 <= 1
+-0 ^ f64
+-0 ^ i
+-0 in $env?.array
+-0 in array
+-0 not in array
+-0 | bitshl(i)
+-0 | bitushr(1)
+-0 | max(array)
+-0 | mean(0)
+-0 | mean(1.0)
+-0 | median(1.0)
+-0 | median(i)
+-0.0
+-0.1
+-1 != $env
+-1 != 0
+-1 != 1
+-1 != 1.0
+-1 != 1.0 || true
+-1 != f64
+-1 != i
+-1 != mean(array)
+-1 != nil
+-1 % 1
+-1 % i
+-1 * 0
+-1 * 1
+-1 * 1.0
+-1 * 1.0 - i
+-1 * f64
+-1 * i
+-1 ** 0
+-1 ** 1
+-1 ** 1.0
+-1 ** f64
+-1 ** i
+-1 + 0
+-1 + 1
+-1 + 1 ^ f64
+-1 + 1.0
+-1 + f64
+-1 + float(i)
+-1 + i
+-1 - 0
+-1 - 1
+-1 - 1.0
+-1 - f64
+-1 - i
+-1 .. 0
+-1 .. 1
+-1 .. i
+-1 / 0
+-1 / 1
+-1 / 1.0
+-1 / f64
+-1 / i
+-1 < 0
+-1 < 1
+-1 < 1.0
+-1 < f64
+-1 < i
+-1 <= -0
+-1 <= 0
+-1 <= 1
+-1 <= 1.0
+-1 <= f64
+-1 <= i
+-1 == $env
+-1 == 0
+-1 == 1
+-1 == 1.0
+-1 == 1.0 * 1
+-1 == f64
+-1 == i
+-1 == nil
+-1 == nil != false
+-1 > 0
+-1 > 1
+-1 > 1.0
+-1 > f64
+-1 > i
+-1 >= 0
+-1 >= 0 + i
+-1 >= 1
+-1 >= 1.0
+-1 >= f64
+-1 >= i
+-1 ?? $env
+-1 ?? $env.ok
+-1 ?? $env?.greet
+-1 ?? 0
+-1 ?? 1
+-1 ?? 1.0
+-1 ?? add
+-1 ?? array
+-1 ?? array ?? $env
+-1 ?? f64
+-1 ?? false
+-1 ?? foo
+-1 ?? greet
+-1 ?? i
+-1 ?? list
+-1 ?? nil
+-1 ?? ok
+-1 ?? str
+-1 ?? str && false
+-1 ?? sum($env, list)
+-1 ?? true
+-1 ?? type(i)
+-1 ^ $env?.i
+-1 ^ 0
+-1 ^ 1
+-1 ^ 1.0
+-1 ^ f64
+-1 ^ i
+-1 ^ i <= 1
+-1 in array
+-1 not in $env.array
+-1 not in array
+-1 | bitnand(0)
+-1 | bitnand(1)
+-1 | bitor(1)
+-1 | bitshr(1)
+-1 | bitushr(i)
+-1 | bitxor(i)
+-1 | max(1.0)
+-1 | max(array)
+-1 | mean(0)
+-1 | mean(1)
+-1 | mean(1.0)
+-1 | mean(f64)
+-1 | median(1, 0)
+-1 | min(f64)
+-1..i
+-1.0
+-1.0 != $env
+-1.0 != $env?.[Bar]
+-1.0 != $env?.i
+-1.0 != 0
+-1.0 != 1
+-1.0 != 1.0
+-1.0 != 1.0 == $env?.[String]
+-1.0 != f64
+-1.0 != i
+-1.0 != nil
+-1.0 * $env?.i
+-1.0 * -1
+-1.0 * 0
+-1.0 * 1
+-1.0 * 1.0
+-1.0 * f64
+-1.0 * i
+-1.0 ** 0
+-1.0 ** 1
+-1.0 ** 1.0
+-1.0 ** f64
+-1.0 ** i
+-1.0 + 0
+-1.0 + 1
+-1.0 + 1.0
+-1.0 + f64
+-1.0 + i
+-1.0 + i != 1.0
+-1.0 - $env?.i
+-1.0 - 0
+-1.0 - 1
+-1.0 - 1.0
+-1.0 - f64
+-1.0 - i
+-1.0 / $env.i
+-1.0 / 0
+-1.0 / 1
+-1.0 / 1.0
+-1.0 / f64
+-1.0 / i
+-1.0 < 0
+-1.0 < 0 ** 1.0
+-1.0 < 1
+-1.0 < 1.0
+-1.0 < f64
+-1.0 < i
+-1.0 < mean(i, 1.0)
+-1.0 <= 0
+-1.0 <= 1
+-1.0 <= 1.0
+-1.0 <= f64
+-1.0 <= f64 != $env
+-1.0 <= i
+-1.0 == $env
+-1.0 == $env?.[String]
+-1.0 == $env?.[str]
+-1.0 == 0
+-1.0 == 1
+-1.0 == 1 && false
+-1.0 == 1.0
+-1.0 == f64
+-1.0 == f64 ?? add
+-1.0 == i
+-1.0 == nil
+-1.0 > 0
+-1.0 > 1
+-1.0 > 1.0
+-1.0 > f64
+-1.0 > i
+-1.0 >= -f64
+-1.0 >= 0
+-1.0 >= 1
+-1.0 >= 1.0
+-1.0 >= 1.0 >= 1
+-1.0 >= f64
+-1.0 >= i
+-1.0 ?? !true
+-1.0 ?? $env
+-1.0 ?? $env?.add
+-1.0 ?? -f64
+-1.0 ?? 0
+-1.0 ?? 1
+-1.0 ?? 1.0
+-1.0 ?? add
+-1.0 ?? array
+-1.0 ?? f64
+-1.0 ?? false
+-1.0 ?? foo
+-1.0 ?? greet
+-1.0 ?? i
+-1.0 ?? list
+-1.0 ?? nil
+-1.0 ?? ok
+-1.0 ?? str
+-1.0 ?? true
+-1.0 ^ 0
+-1.0 ^ 1
+-1.0 ^ 1.0
+-1.0 ^ 1.0 <= 1.0
+-1.0 ^ array?.[i]
+-1.0 ^ f64
+-1.0 ^ i
+-1.0 in array
+-1.0 not in $env?.Bar
+-1.0 not in array
+-1.0 | max(f64)
+-1.0 | mean(1)
+-1.0 | mean(1.0, f64)
+-1.0 | median(1.0)
+-1.0 | median(i)
+-1.0 | min(0)
+-1.0 | min(1)
+-1.0 | min(1.0)
+-1.0 | min(array)
+-1.0 | min(array, 1.0)
+-1.0; false
+-1.1
+-abs(0)
+-abs(1 * i)
+-abs(1)
+-abs(1.0)
+-abs(f64)
+-abs(i)
+-abs(reduce(array, 0))
+-add(0, 1)
+-add(1, 1)
+-add(i, 0)
+-add(i, 1)
+-array?.[0]
+-array?.[1]
+-array?.[i]
+-bitnand(0, 1)
+-bitnand(1, i)
+-bitnot(0)
+-bitnot(1)
+-bitnot(i)
+-bitnot(min(array))
+-bitnot(sum(array))
+-bitshl(0, i)
+-bitshl(1, i)
+-bitshl(i, i)
+-bitshr(1, 0)
+-bitshr(1, i)
+-bitshr(i, 1)
+-bitxor(1, 1)
+-ceil(0)
+-ceil(1)
+-ceil(1.0)
+-ceil(f64)
+-ceil(i)
+-count($env, ok)
+-count($env, true)
+-count(array, false)
+-count(array, ok)
+-count(list, false)
+-count(list, ok)
+-count(list, true)
+-f64
+-f64 != $env
+-f64 != 0
+-f64 != 1
+-f64 != 1.0
+-f64 != f64
+-f64 != i
+-f64 != int(1)
+-f64 != nil
+-f64 * 0
+-f64 * 1
+-f64 * 1.0
+-f64 * f64
+-f64 * i
+-f64 ** 0
+-f64 ** 1
+-f64 ** 1.0
+-f64 ** f64
+-f64 ** i
+-f64 + 0
+-f64 + 1
+-f64 + 1.0
+-f64 + 1.0 / 1
+-f64 + f64
+-f64 + i
+-f64 + sum(array)
+-f64 - 0
+-f64 - 1
+-f64 - 1.0
+-f64 - f64
+-f64 - i
+-f64 / 1
+-f64 / 1.0
+-f64 / 1.0 ?? false
+-f64 / f64
+-f64 / i
+-f64 / i ** 0
+-f64 < 0
+-f64 < 1
+-f64 < 1.0
+-f64 < f64
+-f64 < i
+-f64 <= 0
+-f64 <= 1
+-f64 <= 1.0
+-f64 <= f64
+-f64 <= i
+-f64 == $env
+-f64 == 0
+-f64 == 1
+-f64 == 1.0
+-f64 == 1.0 || $env
+-f64 == f64
+-f64 == i
+-f64 == max(0)
+-f64 == nil
+-f64 > 0
+-f64 > 1
+-f64 > 1.0
+-f64 > f64
+-f64 > f64 <= f64
+-f64 > i
+-f64 >= $env?.i
+-f64 >= 0
+-f64 >= 0 > 0
+-f64 >= 1
+-f64 >= 1.0
+-f64 >= f64
+-f64 >= float(1.0)
+-f64 >= i
+-f64 ?? $env
+-f64 ?? 0
+-f64 ?? 1
+-f64 ?? 1.0
+-f64 ?? add
+-f64 ?? array
+-f64 ?? false
+-f64 ?? foo
+-f64 ?? greet
+-f64 ?? i
+-f64 ?? list
+-f64 ?? nil
+-f64 ?? nil ?? nil
+-f64 ?? ok
+-f64 ?? str
+-f64 ?? string(nil)
+-f64 ?? true
+-f64 ^ 1
+-f64 ^ 1.0
+-f64 ^ f64
+-f64 ^ i
+-f64 in array
+-f64 not in array
+-f64 | mean(0)
+-find(array, ok)
+-find(array, true)
+-findIndex($env, ok)
+-findIndex(list, true)
+-findLast(array, ok)
+-findLastIndex($env, ok)
+-findLastIndex($env, true)
+-findLastIndex(array, ok)
+-findLastIndex(array, true)
+-findLastIndex(list, true)
+-first($env | map(#index))
+-first(array)
+-float(0)
+-float(1)
+-float(1.0 ?? nil)
+-float(1.0)
+-float(f64)
+-float(i)
+-floor($env.i)
+-floor(0)
+-floor(1)
+-floor(1.0)
+-floor(f64)
+-floor(i)
+-i
+-i != $env
+-i != 0
+-i != 1
+-i != 1.0
+-i != ceil(f64)
+-i != f64
+-i != i
+-i != nil
+-i % 1
+-i % i
+-i * 1
+-i * 1.0
+-i * f64
+-i * i
+-i * nil ?? 1.0
+-i ** 0
+-i ** 1.0
+-i ** 1.0 ** f64
+-i ** 1.0 == nil
+-i ** f64
+-i ** i
+-i + 0
+-i + 1
+-i + 1.0
+-i + f64
+-i + i
+-i + median(1.0)
+-i - 0
+-i - 1
+-i - 1.0
+-i - array?.[i]
+-i - f64
+-i - i
+-i .. 0
+-i .. 1
+-i .. i
+-i .. min(1)
+-i / 0
+-i / 1
+-i / 1.0
+-i / f64
+-i / i
+-i < 0
+-i < 1
+-i < 1 and false
+-i < 1.0
+-i < f64
+-i < i
+-i < sum(array)
+-i <= 0
+-i <= 1
+-i <= 1.0
+-i <= f64
+-i <= i
+-i == $env
+-i == 0
+-i == 1.0
+-i == 1.0 * i
+-i == f64
+-i == i
+-i == nil
+-i > 0
+-i > 1
+-i > 1.0
+-i > f64
+-i > i
+-i >= 1
+-i >= 1.0
+-i >= 1.0 ?? foo
+-i >= f64
+-i >= i
+-i >= i || $env
+-i ?? $env
+-i ?? $env.array
+-i ?? $env?.String?.i
+-i ?? $env?.[i]
+-i ?? $env?.add
+-i ?? $env?.i
+-i ?? 0
+-i ?? 1
+-i ?? 1.0
+-i ?? add
+-i ?? array
+-i ?? f64
+-i ?? false
+-i ?? foo
+-i ?? foo?.Bar
+-i ?? greet
+-i ?? i
+-i ?? list
+-i ?? nil
+-i ?? ok
+-i ?? str
+-i ?? true
+-i ^ 0
+-i ^ 0 ?? foo
+-i ^ 1
+-i ^ 1.0
+-i ^ f64
+-i ^ i
+-i ^ i > 1.0
+-i in array
+-i not in array
+-i | add(i)
+-i | bitand(0)
+-i | bitor(0)
+-i | bitshr(1)
+-i | bitxor(1)
+-i | bitxor(i)
+-i | max(1)
+-i | max(f64)
+-i | min(1.0)
+-i..i
+-int($env?.i)
+-int(0)
+-int(1)
+-int(1.0)
+-int(array | max(1))
+-int(f64)
+-int(i)
+-last(array)
+-len($env)
+-len(array)
+-len(foo?.Bar)
+-len(list)
+-len(str)
+-max($env).i
+-max(0 * 1)
+-max(0)
+-max(1)
+-max(1, 1.0)
+-max(1, array)
+-max(1.0)
+-max(1.0, 0)
+-max(1.0, 1.0)
+-max(array)
+-max(array, 0)
+-max(array, i)
+-max(f64)
+-max(f64, 1.0)
+-max(i)
+-max(i, 0)
+-max(i, 1)
+-max(i, array)
+-mean(0)
+-mean(0, f64)
+-mean(1)
+-mean(1, 1)
+-mean(1, f64)
+-mean(1.0)
+-mean(1.0, 0, array)
+-mean(1.0, 1)
+-mean(1.0, 1.0)
+-mean(1.0, i)
+-mean(array)
+-mean(f64)
+-mean(f64, 1)
+-mean(i)
+-mean(i) > f64
+-mean(i, f64)
+-median(0)
+-median(1)
+-median(1) < i
+-median(1.0)
+-median(array)
+-median(array, 1.0)
+-median(f64)
+-median(f64, f64)
+-median(i)
+-median(i, 1)
+-median(min(0))
+-min(0)
+-min(0, 1)
+-min(1)
+-min(1.0)
+-min(1.0, i)
+-min(array)
+-min(array, 0, array)
+-min(array, i, 1.0)
+-min(f64)
+-min(f64, 0, 1.0)
+-min(i)
+-min(i, 1)
+-min(i, 1.0)
+-min(i, 1.0) + f64
+-nil ?? -f64
+-nil ?? 0
+-nil ?? 1
+-nil ?? 1 != nil
+-nil ?? 1.0
+-nil ?? f64
+-nil ?? i
+-nil ?? i / 0
+-reduce($env, 0, nil)
+-reduce($env, i, str)
+-reduce(array, #)
+-reduce(array, #acc)
+-reduce(array, #index, $env)
+-reduce(array, 0)
+-reduce(array, 1)
+-reduce(array, 1, f64)
+-reduce(array, 1.0)
+-reduce(array, f64)
+-reduce(array, i)
+-reduce(list, 1)
+-reduce(list, 1.0)
+-round(0)
+-round(1)
+-round(1.0)
+-round(f64)
+-round(i)
+-sum($env, 0)
+-sum($env, 1)
+-sum($env, 1.0)
+-sum($env, f64)
+-sum($env.array)
+-sum(array)
+-sum(array); str
+-sum(array, #)
+-sum(array, 0)
+-sum(array, 1)
+-sum(array, 1.0)
+-sum(array, i)
+-sum(list | reduce(array, greet))
+-sum(list, 0)
+-sum(list, 1)
+-sum(list, 1.0)
+-sum(list, f64)
+-sum(str ?? 0)
+0 != $env ?: $env?.[i]?.ok
+0 != $env ?: ok
+0 != $env ?? add
+0 != $env ?? array
 0 != $env.f64
 0 != $env.i
 0 != $env?.Bar
@@ -3116,137 +6723,258 @@ $env[$env:] - f64 and false
 0 != $env?.foobar?.foo
 0 != $env?.i
 0 != $env?.not
+0 != 0 % sum(array)
+0 != 0 && $env == foo
+0 != 0 - i
 0 != 0 ?: array
+0 != 0 ?? f64
+0 != 0 ^ 1.0 ^ 1
+0 != 0 or 0 != f64
+0 != 1.0 && ok ?? greet
 0 != 1.0 * $env.f64
+0 != 1.0 * i
 0 != 1.0 + f64 ** 1.0
 0 != 1.0 / i * 1.0
+0 != 1.0 ?? ok
 0 != 1.0 || $env - i
 0 != array?.[i]
+0 != f64 - $env?.i
 0 != f64 / f64
 0 != f64 == $env?.Bar
 0 != f64 ^ 1.0 or $env
+0 != f64 || $env?.[ok]
+0 != f64 || nil == str
 0 != f64 || ok
+0 != foo ?? list
 0 != i ** i
 0 != i ^ f64
 0 != nil != ok
 0 != nil || $env?.[String]
+0 != ok ?? $env?.Bar
+0 != ok ?? i
+0 != true ?? foo?.Bar
 0 % $env.i
 0 % $env?.i
 0 % 1 * i
 0 % 1 + i >= 0
+0 % 1 < array?.[i]
+0 % 1 > -1
 0 % 1 > count(array, false)
 0 % 1 >= i
+0 % 1 in array != $env
 0 % 1 | median(f64)
 0 % array?.[i]
+0 % i * i
+0 % i <= f64
+0 % i | mean(f64)
 0 * $env.f64
 0 * $env.i
 0 * $env?.f64
 0 * $env?.i
 0 * 0 != f64
 0 * 0 == i
+0 * 0 ?? foo
 0 * 1 != i
 0 * 1 + f64
+0 * 1 < f64
+0 * 1 | bitshl(0)
+0 * 1.0 != i
 0 * 1.0 != nil or ok
 0 * 1.0 ** i
+0 * 1.0 < f64
 0 * array?.[i]
 0 * f64 + i
 0 * f64 <= f64
+0 * f64 == f64 || ok
 0 * i != i
 0 * i ^ f64
+0 * i not in groupBy(array, foo)
+0 * i | max(0)
 0 ** $env.f64
 0 ** $env.i
 0 ** $env?.f64
 0 ** $env?.i
 0 ** 0 != $env?.i
 0 ** 0 + $env.i
+0 ** 0 >= i
+0 ** 0 | max(1.0)
+0 ** 1 > i
+0 ** 1 | max(1)
 0 ** 1.0 ** f64
 0 ** 1.0 / f64
 0 ** 1.0 < i
 0 ** 1.0 == i
 0 ** 1.0 > i
+0 ** 1.0 >= floor(i)
+0 ** 1.0 ?? f64
+0 ** 1.0 ^ i
+0 ** 1.0 | max(f64)
 0 ** array?.[i]
+0 ** f64 == nil || false
 0 ** f64 >= $env?.f64
 0 ** i != f64
+0 ** i ?? ok
+0 ** i ^ $env?.f64
 0 + $env.f64
 0 + $env.i
 0 + $env?.[str]?.[i]
 0 + $env?.f64
 0 + $env?.i
+0 + 0 != f64
 0 + 0 - f64
 0 + 0 / i
 0 + 0 >= f64 <= $env
+0 + 0 ^ i
+0 + 0 in array
+0 + 1 + i
 0 + 1 <= $env.i
 0 + 1 <= f64
+0 + 1 == $env.f64
 0 + 1 | min(0)
 0 + 1.0 + i
+0 + 1.0 <= f64
+0 + 1.0 > f64
+0 + 1.0 >= i
+0 + 1.0 ?? i
+0 + 1.0 ^ f64
 0 + array?.[i]
 0 + f64 > i
+0 + i != f64
 0 + i * f64
+0 + i ** i
+0 + i < $env?.f64
 0 - $env.f64
 0 - $env.i
 0 - $env?.f64
 0 - $env?.i
+0 - 0 != bitand(0, i)
 0 - 0 < f64
 0 - 0 == i
 0 - 1 ** f64
+0 - 1 + f64
 0 - 1 < $env.i
+0 - 1 < sum(array)
+0 - 1 >= -f64
+0 - 1 ?? array
+0 - 1 ?? str
+0 - 1.0 + i
 0 - array?.[i]
+0 - f64 <= f64
+0 - f64 > f64
 0 - f64 >= f64 * i
+0 - f64 >= i
+0 - i ?? f64
+0 - i ?? foo
+0 - nil ?? i
 0 .. $env.i
 0 .. $env?.i
+0 .. 0 ?? toJSON(i)
 0 .. 0 | find(ok)
 0 .. 0 | map(#)
+0 .. 0 | map(#index)
+0 .. 0 | map(true)
 0 .. 0 | max(1.0)
+0 .. 0 | reduce(#)
 0 .. 0 | reduce(str)
 0 .. 1 | get(1)
+0 .. 1 | map(#)
 0 .. 1 | map(array)
 0 .. 1 | map(foo)
 0 .. 1 | reduce(#)
 0 .. 1 | reduce($env)
 0 .. 1 | reduce(add)
 0 .. 1 | sortBy(#)
+0 .. 1 | sum(#)
+0 .. 1.0 ?? foo
 0 .. array?.[i]
+0 .. i | any(false)
 0 .. i | groupBy(foo)
 0 .. i | map(str)
+0 .. i | median(f64)
+0 .. i | one(false)
+0 .. i | reduce(list, add)
 0 .. i | sortBy(1)
 0 / $env != 1 and false
 0 / $env.f64
+0 / $env.f64 ** f64
 0 / $env.i
 0 / $env?.f64
 0 / $env?.i
 0 / 0 * i
 0 / 0 + ceil(1.0)
+0 / 0 / i
+0 / 0 > f64
 0 / 1 / f64
+0 / 1 == $env?.String
+0 / 1.0 * f64
 0 / 1.0 + $env.i
+0 / 1.0 > f64
+0 / 1.0 ?? $env ?? i
+0 / 1.0 ?? date(nil, foo)
+0 / 1.0 ?? foo
+0 / 1.0 ?? list ?? 1.0
 0 / array?.[i]
+0 / f64 - f64
 0 / f64 <= f64
+0 / f64 | median(f64)
 0 / i + i
+0 / i / 1.0 ?? 0
+0 / i <= 0 != nil
+0 / i == f64
+0 / i > f64
+0 / i ?? i
+0 / i not in concat(list)
 0 < $env.f64
 0 < $env.i
 0 < $env?.[str]?.[f64]
 0 < $env?.f64
 0 < $env?.i
+0 < 0 != ok
 0 < 0 + len(str)
+0 < 0 ?? date(1)
+0 < 0 ?? ok
 0 < 1 % i
 0 < 1 - i
+0 < 1 >= i
 0 < 1 ^ median(1.0)
+0 < 1 and foo ?? 1.0
+0 < 1.0 * 1 != false
 0 < 1.0 - f64
 0 < 1.0 / i
 0 < 1.0 <= i
+0 < 1.0 > i
 0 < array?.[i]
+0 < f64 + i
+0 < f64 - f64
+0 < f64 ? array : list
+0 < f64 ?? array
+0 < f64 ^ 0 / i
 0 < f64 || $env?.ok
+0 < i + i
+0 < i < i
 0 < i <= reduce(array, #)
 0 <= $env.f64
 0 <= $env.i
 0 <= $env?.f64
 0 <= $env?.i
+0 <= 0 ?? ok
 0 <= 1 * i
 0 <= 1 <= f64
 0 <= 1 ^ f64
 0 <= 1 or $env != 1
 0 <= 1.0 * f64
 0 <= array?.[i]
+0 <= f64 - f64 or $env
+0 <= f64 > f64
+0 <= f64 ?? add
+0 <= f64 or !$env
 0 <= i % i
+0 <= i ^ 1.0 <= 1.0
+0 <= i || ok
+0 <= nil ?? f64
+0 == $env == 0 ?? 1.0
+0 == $env or $env.ok
+0 == $env or ok
 0 == $env || ok
 0 == $env.f64
 0 == $env.i
@@ -3254,18 +6982,31 @@ $env[$env:] - f64 and false
 0 == $env?.Bar?.foo
 0 == $env?.String
 0 == $env?.String?.str
+0 == $env?.[Bar | get(foo)]
 0 == $env?.[Bar]
 0 == $env?.[String]
+0 == $env?.[first(0, ok)]
 0 == $env?.[foobar]
+0 == $env?.[foobar]?.add
 0 == $env?.[str]
 0 == $env?.f64
 0 == $env?.i
+0 == 0 * f64
+0 == 0 * i
 0 == 0 not in $env?.foobar
 0 == 1.0 && f64 + $env
 0 == 1.0 / i
+0 == add ?? f64
 0 == array?.[i]
+0 == f64 - 1 and false
 0 == f64 ?: add
+0 == f64 ?? ok
+0 == false ?? str
+0 == foo ?? $env?.add
 0 == i and $env?.[foo]
+0 == nil and $env matches str
+0 == str ?? greet
+0 == true ?? list
 0 > $env.f64
 0 > $env.i
 0 > $env?.[str]?.[f64]
@@ -3273,69 +7014,188 @@ $env[$env:] - f64 and false
 0 > $env?.i
 0 > 0 * f64
 0 > 0 / i
+0 > 0 == ok
 0 > 0 > ceil($env)
 0 > 0 or foo == nil
 0 > 1 - i
+0 > 1.0 != str ?? i
+0 > 1.0 ** f64
+0 > 1.0 / f64
+0 > 1.0 >= f64 or ok
 0 > 1.0 ^ f64
 0 > array?.[i]
 0 > f64 > $env?.[Bar]
 0 > f64 > f64
+0 > f64 ?? f64
+0 > f64 and $env?.[greet]
+0 > i > i
+0 > i and foo == nil
 0 >= $env.f64
 0 >= $env.i
 0 >= $env?.f64
 0 >= $env?.i
 0 >= 0 ** i
+0 >= 0 ?? list
+0 >= 0 or str != nil
 0 >= 1 >= i
+0 >= 1 ?? add
+0 >= 1 ?? i
+0 >= 1.0 ** i
+0 >= 1.0 / 1 ** 1
+0 >= 1.0 ?? list
+0 >= 1.0 ?? ok
+0 >= 1.0 ^ i
 0 >= 1.0 and ok
 0 >= 1.0 or ok
+0 >= array?.[i]
 0 >= f64 ** f64
 0 >= f64 + f64
+0 >= f64 <= $env?.i
+0 >= f64 >= $env?.[foo]
+0 >= i > i
+0 >= i >= 1.0 - $env
+0 >= nil ?? f64
+0 ?? $env ?? str
+0 ?? $env | max(1.0)
+0 ?? $env.add
+0 ?? $env.array
+0 ?? $env.foo
+0 ?? $env.greet
+0 ?? $env.i
+0 ?? $env.list
+0 ?? $env.ok
+0 ?? $env.str
+0 ?? $env?.Bar
+0 ?? $env?.String
+0 ?? $env?.String()
+0 ?? $env?.String(greet())
+0 ?? $env?.[Bar]
+0 ?? $env?.[String]
+0 ?? $env?.[String].String
+0 ?? $env?.[add(0)]
+0 ?? $env?.[add]
+0 ?? $env?.[add]?.[array]
+0 ?? $env?.[array]
+0 ?? $env?.[date($env)]
+0 ?? $env?.[f64]
+0 ?? $env?.[foo]
+0 ?? $env?.[greet]
+0 ?? $env?.[i]
+0 ?? $env?.[list]
+0 ?? $env?.[nil | date(1, foobar)]
+0 ?? $env?.[ok]
+0 ?? $env?.[str]
+0 ?? $env?.add
+0 ?? $env?.array
+0 ?? $env?.f64
+0 ?? $env?.foo
+0 ?? $env?.foobar
+0 ?? $env?.greet
+0 ?? $env?.i
+0 ?? $env?.list
+0 ?? $env?.ok
+0 ?? $env?.str
+0 ?? $env[:String matches $env]
+0 ?? $env[:add(greet, str)]
+0 ?? $env[:count(foo)]
+0 ?? $env[:foo]
+0 ?? $env[:foobar and foobar]
+0 ?? $env[:foobar | filter(#.i)]
+0 ?? $env[:foobar.add]
+0 ?? $env[:greet.ok]
+0 ?? $env[String():add(list)]
+0 ?? $env[i:foobar]
+0 ?? 1 ?? i
+0 ?? 1 ?? str
+0 ?? 1.0 ?? i
+0 ?? add ?? i
+0 ?? array?.[array?.[i]]
+0 ?? array?.[i]
+0 ?? f64 | mean(0)
+0 ?? foo | get(foo)
+0 ?? foo.Bar
+0 ?? foo.String
+0 ?? foo.String()
+0 ?? foo?.Bar
+0 ?? foo?.String
+0 ?? foo?.String()
+0 ?? i ?? foo
+0 ?? list ?? greet
+0 ?? list?.[i]
+0 ?? ok ?? i
+0 ?? true ?? foo
 0 ^ $env.f64
 0 ^ $env.i
 0 ^ $env?.f64
 0 ^ $env?.i
 0 ^ 1 * i
+0 ^ 1 ** i
 0 ^ 1 / f64
+0 ^ 1.0 != $env?.f64
 0 ^ 1.0 != i
 0 ^ 1.0 + f64
 0 ^ 1.0 / f64
+0 ^ 1.0 >= f64
+0 ^ 1.0 ?? $env.ok
+0 ^ 1.0 ?? 1.0 > f64
 0 ^ 1.0 in array
 0 ^ array?.[i]
+0 ^ f64 == i
 0 ^ i == i
+0 ^ i ?? i
 0 in $env.array
 0 in $env?.Bar
 0 in $env?.Bar?.greet
 0 in $env?.String
 0 in $env?.[Bar]
 0 in $env?.[String]
+0 in $env?.[String]?.array
 0 in $env?.array
 0 in array != ok
+0 in nil ?? array
 0 not in $env.array
 0 not in $env?.Bar
 0 not in $env?.String
+0 not in $env?.String?.[array]
 0 not in $env?.[Bar]
 0 not in $env?.[String]
 0 not in $env?.[foobar]
 0 not in $env?.array
+0 not in $env?.foobar
+0 | add(0) ^ f64
+0 | bitnand(0) > i
 0 | bitor($env) == 1 and false
 0 | bitshl(1) / f64
+0 | bitshr(0); array; greet
 0 | bitxor(0) in array
 0 | max(0) in array
 0 | max(array, 1.0) - floor(i)
+0 | mean(i) ?? f64
+0 | min(0) | mean(1)
+0 | min(1) ** f64
 0..array?.[i]
+0..i | count(true)
+0..i | groupBy(#)
+0..i | groupBy(f64)
+0..i | map(1.0)
 0..i | map(list)
+0.0 != f64
 0.0 + 0 == $env
 0.1 != floor(1.0)
 0.1 | mean(f64)
+0.1 | min(1.0)
+0; $env.add
 0; $env?.add
 1 != $env not in [true]
 1 != $env.f64
 1 != $env.i
 1 != $env?.Bar
+1 != $env?.Bar?.array
 1 != $env?.String
 1 != $env?.String?.f64
 1 != $env?.[Bar]
 1 != $env?.[Bar]?.f64
+1 != $env?.[Bar]?.greet
 1 != $env?.[String]
 1 != $env?.[foobar]
 1 != $env?.[str]
@@ -3343,55 +7203,110 @@ $env[$env:] - f64 and false
 1 != $env?.foobar
 1 != $env?.i
 1 != 0 * f64
+1 != 0 ?? list
 1 != 1 - f64
+1 != 1 ?? list
+1 != 1 ?? ok
+1 != 1.0 && 0 == 1.0
 1 != 1.0 + i
+1 != 1.0 ^ f64
+1 != array ?? list
 1 != array?.[i]
 1 != f64 && $env?.[str]
+1 != f64 ** f64
+1 != f64 || $env?.[ok]
 1 != f64 || ok
+1 != false ?? foo
+1 != foo ?? f64
 1 != i != ok
+1 != i + f64
+1 != i - f64
+1 != i ?? greet
+1 != i ^ f64
+1 != list ?? array ?: list
 1 != nil or ok
 1 % $env.i
 1 % $env?.i
 1 % 1 > f64
+1 % 1 ?? list
 1 % array?.[i]
+1 % i + f64
+1 % i < f64
+1 % i >= i
 1 * $env.f64
 1 * $env.i
 1 * $env.i + f64
 1 * $env?.f64
 1 * $env?.i
 1 * 0 / f64
+1 * 0 < f64
 1 * 0 == {foo: 1.0}?.array
+1 * 0 not in $env?.[Bar]
 1 * 0 | bitushr(0)
+1 * 1 == i
 1 * 1 | bitnand(0)
 1 * 1 | min(f64)
+1 * 1.0 * 1.0 * i
 1 * 1.0 ** $env.i
 1 * 1.0 < f64
+1 * 1.0 <= ceil(0)
+1 * 1.0 <= f64
+1 * 1.0 ?? foo
 1 * array?.[i]
+1 * f64 * f64
+1 * f64 * i
+1 * f64 / min(0)
 1 * f64 ^ f64 - 1
 1 * f64 | mean(1)
+1 * i + bitnot(0)
+1 * i - f64
 1 * i / i
 1 * i | bitxor(i)
+1 * nil ?? $env?.f64
 1 ** $env.f64
 1 ** $env.i
 1 ** $env?.f64
+1 ** $env?.f64 ?? list
 1 ** $env?.i
 1 ** 0 ** i
+1 ** 0 / i
+1 ** 0 == ceil(1)
+1 ** 0 > f64
+1 ** 0 ?? list
 1 ** 1 != i
 1 ** 1 ** i
 1 ** 1.0 != f64
+1 ** 1.0 ?? $env == f64
+1 ** 1.0 ?? groupBy(list, ok)
+1 ** 1.0 in array
+1 ** 1.0 | mean(array)
 1 ** array?.[i]
+1 ** f64 - array?.[i]
+1 ** f64 | median(i)
 1 ** i + f64
+1 ** i < 1.0 + 0
+1 ** i <= i
+1 ** nil ?? i
+1 ** nil ?? mean(0)
 1 + $env.f64
 1 + $env.i
 1 + $env?.f64
 1 + $env?.i
 1 + 0 ** i
+1 + 0 | bitor(i)
 1 + 1 % i
+1 + 1 >= f64 ^ 0
 1 + 1 not in array
 1 + 1.0 != i
+1 + 1.0 * f64
 1 + 1.0 - i
 1 + 1.0 < f64
+1 + 1.0 ?? foo
+1 + 1.0 ?? greet > f64
+1 + 1.0 ?? ok
 1 + 1.0 ^ i
+1 + 1.0 | max(1)
+1 + f64 ?? greet
 1 + f64 ^ i ** 1
 1 + f64 in array
 1 + f64 | max(array)
@@ -3403,10 +7318,24 @@ $env[$env:] - f64 and false
 1 - $env.i
 1 - $env?.f64
 1 - $env?.i
+1 - 0 > i
+1 - 0 ?? list
+1 - 1 == f64
+1 - 1 | median(1, 1.0)
+1 - 1.0 ** f64
+1 - 1.0 + f64
+1 - 1.0 / i
+1 - 1.0 == 1.0 == $env
+1 - 1.0 ?? i
+1 - 1.0 ?? not true
 1 - 1.0 in array
 1 - 1.0 not in array
 1 - array?.[i]
+1 - f64 / i
+1 - f64 > f64
 1 - f64 >= 1.0 < 1
+1 - f64 ?? add
+1 - f64 ^ f64
 1 - f64 | min(array)
 1 - i / f64
 1 - i > i
@@ -3414,15 +7343,26 @@ $env[$env:] - f64 and false
 1 - i | min(1.0)
 1 .. $env.i
 1 .. $env?.i
+1 .. 0 | all($env)
+1 .. 0 | filter(true)
 1 .. 0 | groupBy(#)
 1 .. 0 | groupBy(foo)
 1 .. 0 | one($env)
+1 .. 0 | sortBy(#)
 1 .. 0 | sortBy($env)
 1 .. 0 | sortBy(str)
 1 .. 0 | sum(greet)
+1 .. 1 ?? array
 1 .. 1 | filter(ok)
+1 .. 1 | findLast(true)
+1 .. 1 | map(#)
+1 .. 1 | map($env)
+1 .. 1 | map(foo)
+1 .. 1 | sum(1.0)
 1 .. array?.[i]
 1 .. i - i
+1 .. i ?? i
+1 .. i ?? ok
 1 .. i | groupBy(#)
 1 .. i | groupBy(foo)
 1 .. i | groupBy(ok)
@@ -3432,25 +7372,53 @@ $env[$env:] - f64 and false
 1 / $env.i
 1 / $env?.f64
 1 / $env?.i
+1 / 0 ?? foo
 1 / 1 * f64
 1 / 1 > f64
 1 / 1 ^ i
 1 / 1 in [nil]
 1 / 1.0 * $env?.f64
 1 / 1.0 ** i
+1 / 1.0 <= f64
 1 / 1.0 == i || ok
+1 / 1.0 > 1.0 != nil
+1 / 1.0 ?? f64
 1 / array?.[i]
 1 / f64 - f64
+1 / f64 >= f64
+1 / i != i
+1 / i + 1.0 / 1
+1 / i + i
+1 / i ?? i
 1 < $env.f64
 1 < $env.i
 1 < $env?.f64
 1 < $env?.f64 && ok
 1 < $env?.i
+1 < 0 && ok
+1 < 0 - f64
+1 < 0 - f64 ?? foo
 1 < 0 <= $env?.[str]
+1 < 0 ?? i
 1 < 0 ^ i ** 1.0
+1 < 1 * f64
+1 < 1 < f64
 1 < 1 ?: array
+1 < 1 ?? f64
+1 < 1 ?? i
+1 < 1 ^ sum(array)
 1 < 1.0 < i
 1 < 1.0 > $env?.[false]
+1 < 1.0 ?? add
+1 < 1.0 ?? greet
+1 < 1.0 ?? str
+1 < array?.[i]
+1 < f64 / f64
+1 < f64 > 0 ** i
+1 < f64 >= $env?.i
+1 < i > i
+1 < i ? ok : ok
+1 < i ?? f64
 1 < i or min($env)
 1 <= $env.f64
 1 <= $env.i
@@ -3458,10 +7426,17 @@ $env[$env:] - f64 and false
 1 <= $env?.i
 1 <= 0 - i
 1 <= 0 ?: greet
+1 <= 0 and ok
+1 <= 1 * i
 1 <= 1 / f64
 1 <= 1 == true or true
 1 <= 1.0 == $env?.[Bar]
+1 <= 1.0 >= f64
+1 <= 1.0 ?? array
 1 <= array?.[i]
+1 <= f64 + i
+1 <= f64 - f64
+1 <= f64 or ok
 1 <= i / i
 1 <= i ^ i
 1 == $env || ok
@@ -3481,86 +7456,233 @@ $env[$env:] - f64 and false
 1 == $env?.not
 1 == 1 ^ i
 1 == 1.0 - $env.i
+1 == 1.0 - f64
 1 == 1.0 - i
+1 == 1.0 ?? 1.0 ?? ok
+1 == 1.0 and ok
+1 == 1.0 or $env[:foobar]
 1 == array?.[i]
 1 == f64 && list == $env
 1 == f64 * f64 ** 1.0
 1 == f64 ?: greet
+1 == f64 ?? -$env
 1 == f64 ^ f64
+1 == foo ?? list
+1 == foo ?? str
+1 == i != $env?.String
 1 == i - f64
+1 == i || $env?.[add]
+1 == nil != ok
+1 == ok ?? foo
+1 == str ?? array
 1 > $env.f64
 1 > $env.i
 1 > $env?.f64
 1 > $env?.i
 1 > 0 != ok
+1 > 0 * f64
 1 > 0 <= i or $env
+1 > 0 ?? foo
+1 > 1 or nil != str
 1 > 1.0 / i
+1 > 1.0 <= -$env
+1 > 1.0 <= array?.[i]
 1 > 1.0 <= i
 1 > 1.0 >= $env.i
+1 > 1.0 >= $env[true:1]
 1 > 1.0 ^ min(array)
 1 > array?.[i]
+1 > f64 ** i
 1 > i % i
 1 > i - i
+1 > i / i
 1 > i <= f64
+1 > i ?? i
 1 >= $env.f64
 1 >= $env.i
 1 >= $env?.f64
 1 >= $env?.i
+1 >= 0 && $env?.String
+1 >= 0 * i
 1 >= 0 == ok
+1 >= 0 >= f64
 1 >= 1 <= f64
 1 >= 1 <= i
+1 >= 1 ?? greet
+1 >= 1.0 ** f64
 1 >= 1.0 > float(1)
+1 >= 1.0 >= i
+1 >= 1.0 ?: list
 1 >= 1.0 or $env.ok
 1 >= array?.[i]
+1 >= f64 > sum($env, 1)
+1 >= f64 ?? array
+1 >= i ** i
+1 >= i >= i
+1 ?? $env | get(ok)
+1 ?? $env | max(1.0)
+1 ?? $env.add
+1 ?? $env.array
+1 ?? $env.array?.[i]
+1 ?? $env.f64
+1 ?? $env.foo
+1 ?? $env.greet
+1 ?? $env.i
+1 ?? $env.list
+1 ?? $env.ok
+1 ?? $env.str
+1 ?? $env?.Bar
+1 ?? $env?.Bar()
+1 ?? $env?.Bar?.[f64]
+1 ?? $env?.String
+1 ?? $env?.String()
+1 ?? $env?.String(nil)
+1 ?? $env?.[Bar]
+1 ?? $env?.[Bar]?.[add]
+1 ?? $env?.[String]
+1 ?? $env?.[add]
+1 ?? $env?.[array]
+1 ?? $env?.[f64()]
+1 ?? $env?.[f64]
+1 ?? $env?.[f64].f64.greet
+1 ?? $env?.[foo(true)]
+1 ?? $env?.[foo]
+1 ?? $env?.[greet]
+1 ?? $env?.[greet]?.[str]
+1 ?? $env?.[i]
+1 ?? $env?.[i]?.[foo]
+1 ?? $env?.[list]
+1 ?? $env?.[list]?.Bar
+1 ?? $env?.[ok]
+1 ?? $env?.[ok].str
+1 ?? $env?.[ok]?.[str]
+1 ?? $env?.[str]
+1 ?? $env?.[str].Bar
+1 ?? $env?.add
+1 ?? $env?.array
+1 ?? $env?.f64
+1 ?? $env?.foo
+1 ?? $env?.foobar
+1 ?? $env?.foobar.greet
+1 ?? $env?.foobar?.[f64]?.array()
+1 ?? $env?.foobar?.list()
+1 ?? $env?.greet
+1 ?? $env?.i
+1 ?? $env?.list
+1 ?? $env?.ok
+1 ?? $env?.round(foobar)
+1 ?? $env?.str
+1 ?? $env[:String | ceil(foobar)]
+1 ?? $env[:foobar == foobar].foo
+1 ?? $env[:foobar?.array(foobar)]
+1 ?? $env[:str]
+1 ?? $env[String <= false:foobar < foo]
+1 ?? $env[String():]?.list
+1 ?? $env[list():]
+1 ?? $env[ok(foobar):]
+1 ?? $env[reverse(0):]
+1 ?? 1 ?? array
+1 ?? 1.0 ?? greet
+1 ?? 1.0 | bitnand(i)
+1 ?? 1.0 | mean(f64)
+1 ?? add ?? f64
+1 ?? array ?? f64
+1 ?? false ?? f64
+1 ?? foo ?? array
+1 ?? foo ?? str
+1 ?? foo | max(1)
+1 ?? foo.Bar
+1 ?? foo.String
+1 ?? foo.String()
+1 ?? foo?.Bar
+1 ?? foo?.String
+1 ?? foo?.String()
+1 ?? i ?? array
+1 ?? list?.[i]
+1 ?? ok | get(true)
 1 ^ $env.f64
 1 ^ $env.i
 1 ^ $env?.f64
 1 ^ $env?.i
 1 ^ 0 ** i
+1 ^ 0 >= i
+1 ^ 1 - i
 1 ^ 1 > f64
+1 ^ 1 ?? foo?.String
+1 ^ 1 in $env.array
+1 ^ 1 in array
+1 ^ 1 not in array
 1 ^ 1.0 + f64
+1 ^ 1.0 + i - 0
+1 ^ 1.0 == f64 ?? 1.0
 1 ^ 1.0 == i
+1 ^ 1.0 > i
+1 ^ 1.0 ?? array
+1 ^ 1.0 ?? foo
+1 ^ 1.0 ?? list
+1 ^ 1.0 ?? {foo: foo}
+1 ^ 1.0 ^ f64
 1 ^ 1.0 ^ int(1.0)
 1 ^ 1.0 ^ round(0)
 1 ^ array?.[i]
 1 ^ f64 != $env.f64
 1 ^ f64 - ceil(1.0)
+1 ^ f64 | min(1)
+1 ^ i ** i
 1 in $env.array
 1 in $env?.Bar
 1 in $env?.String
 1 in $env?.[Bar]
+1 in $env?.[Bar]?.[array]
+1 in $env?.[Bar]?.f64
 1 in $env?.[String]
 1 in $env?.array
 1 in $env?.foobar
+1 in array ?? foo
 1 in array || false ? 1 : foo
 1 in array || ok
 1 not in $env.array
+1 not in $env?.$env?.list
 1 not in $env?.Bar
 1 not in $env?.Bar?.[i]
+1 not in $env?.Bar?.add
 1 not in $env?.String
+1 not in $env?.String?.[foo]
 1 not in $env?.[Bar]
 1 not in $env?.[String]
 1 not in $env?.[String]?.f64
 1 not in $env?.[foobar]
 1 not in $env?.array
 1 not in $env?.foobar
+1 not in $env?.foobar?.String(foobar)
+1 not in $env?.foobar?.[array]
+1 not in list ?? add
+1 not in nil ?? array
+1 | bitand(i) ?? $env?.[foo]
 1 | bitshl(0) != f64
+1 | bitshl(1) != f64
 1 | bitxor(1) >= i
+1 | mean(1) < 0 ?? 1.0
 1 | min(1.0) + i
 1..array?.[i]
+1..i != array
+1..i | all(true)
 1..i | map(#)
 1..i | map(0)
 1..i | reduce(array)
+1.0 != $env ?? foo
 1.0 != $env.f64
 1.0 != $env.i
 1.0 != $env?.Bar
 1.0 != $env?.Bar?.[array]
 1.0 != $env?.Bar?.str
 1.0 != $env?.String
+1.0 != $env?.String?.[add]
 1.0 != $env?.String?.[i]
 1.0 != $env?.String?.[ok]
 1.0 != $env?.[Bar]
 1.0 != $env?.[String]
+1.0 != $env?.[String]?.greet()
 1.0 != $env?.[foobar?.add($env)]?.greet
 1.0 != $env?.[foobar?.add]
 1.0 != $env?.[foobar]
@@ -3572,161 +7694,348 @@ $env[$env:] - f64 and false
 1.0 != $env?.i
 1.0 != $env?.not
 1.0 != 0 != ok
+1.0 != 0 - f64
 1.0 != 0 / abs(1.0)
+1.0 != 0 ?? add
+1.0 != 0 ?? str
+1.0 != 0.-1.0
+1.0 != 1 != ok
 1.0 != 1 / i
 1.0 != 1 ?: foo
 1.0 != 1.0 ** i
+1.0 != 1.0 / abs(1.0)
+1.0 != 1.0 == ok
 1.0 != 1.0 ^ $env.f64
 1.0 != 1.0 ^ f64
 1.0 != 1.0 and $env not endsWith $env
+1.0 != add ?? greet
+1.0 != add ?? {foo: 1}
 1.0 != array?.[i]
 1.0 != f64 && ok
+1.0 != false ?? $env?.[list]
+1.0 != foo ?? array?.[i]
+1.0 != foo ?? count($env, false)
+1.0 != foo ?? greet
 1.0 != i % i
+1.0 != i * f64
+1.0 != i / i
+1.0 != i ^ f64
+1.0 != i or ok
+1.0 != list ?? array
+1.0 != nil ?? 1 ?? foo
+1.0 != nil or reduce($env, #.str)?.[str]
+1.0 != str ?? array
+1.0 != true ?? $env.add
+1.0 != true ?? array
+1.0 != true ?? f64
+1.0 * $env.array?.[i]
 1.0 * $env.f64
 1.0 * $env.i
 1.0 * $env?.f64
 1.0 * $env?.i
+1.0 * 0 + f64
+1.0 * 0 / f64 != nil
+1.0 * 0 <= f64
+1.0 * 0 == f64
 1.0 * 0 >= i
+1.0 * 0 ^ f64
+1.0 * 1 != i
+1.0 * 1 != max($env)
+1.0 * 1 ** i
+1.0 * 1 ?? add
+1.0 * 1 ?? list
+1.0 * 1 ?? ok
+1.0 * 1 | max(f64)
+1.0 * 1.0 != i
+1.0 * 1.0 / f64
 1.0 * 1.0 <= f64
 1.0 * 1.0 > f64
 1.0 * 1.0 > i
 1.0 * 1.0 >= 0 == nil
+1.0 * 1.0 >= i
+1.0 * 1.0 ?? f64
 1.0 * 1.0 | mean(array)
+1.0 * 1.0 | median(1.0)
+1.0 * 1.0 | min(1.0)
 1.0 * array?.[i]
+1.0 * f64 * i
+1.0 * f64 - i
 1.0 * f64 - max(1, array)
 1.0 * f64 == f64
 1.0 * f64 == sum(array)
+1.0 * f64 ?? f64
+1.0 * f64 ?? greet
+1.0 * f64 | max(1.0)
+1.0 * i + f64
 1.0 * i >= 1.0 ^ 1
+1.0 * i ?? ok
 1.0 * i not in array
+1.0 * i | median(1.0)
 1.0 ** $env.f64
 1.0 ** $env.i
 1.0 ** $env?.f64
 1.0 ** $env?.i
+1.0 ** 0 - 1.0 in array
+1.0 ** 0 - i
 1.0 ** 0 / i
 1.0 ** 0 < i
+1.0 ** 0 <= f64
+1.0 ** 0 == f64
 1.0 ** 0 == i
 1.0 ** 0 > i
+1.0 ** 0 ?? str
+1.0 ** 0 ^ 0 ** 0
 1.0 ** 0 | median(1)
+1.0 ** 1 ** $env.i
+1.0 ** 1 / 1.0 ?? foo
+1.0 ** 1 ^ i
 1.0 ** 1.0 != i
 1.0 ** 1.0 * i
+1.0 ** 1.0 ** -1.0
 1.0 ** 1.0 < 0 != false
+1.0 ** 1.0 < i
+1.0 ** 1.0 ?? array
+1.0 ** 1.0 ?? foo
+1.0 ** 1.0 ?? greet
+1.0 ** 1.0 ?? list
+1.0 ** 1.0 ?? nil ?? foo
+1.0 ** 1.0 ?? upper($env)
 1.0 ** 1.0 | median(1.0)
 1.0 ** array?.[i]
+1.0 ** f64
+1.0 ** f64 != f64
 1.0 ** f64 * f64
+1.0 ** f64 * i
+1.0 ** f64 - f64
+1.0 ** f64 / i
+1.0 ** f64 >= f64
+1.0 ** f64 ?? ok
 1.0 ** f64 | median(i)
 1.0 ** f64 | min(1)
+1.0 ** i - -0
 1.0 ** i - float(f64)
+1.0 ** i / f64
+1.0 ** i <= i * 1.0
+1.0 ** nil ?? f64
 1.0 + $env.f64
 1.0 + $env.i
 1.0 + $env?.f64
 1.0 + $env?.i
 1.0 + 0 != i
 1.0 + 0 + f64
+1.0 + 0 / reduce(array, i)
+1.0 + 0 < round(1)
+1.0 + 0 ?? add
+1.0 + 1 ?? f64
+1.0 + 1 not in array
 1.0 + 1 | median(1.0)
+1.0 + 1.0 + i
+1.0 + 1.0 - i
 1.0 + 1.0 <= i
+1.0 + 1.0 ?? add
 1.0 + 1.0 ^ f64
 1.0 + 1.0 ^ i
+1.0 + 1.0 in $env?.Bar
+1.0 + 1.0 not in array
 1.0 + 1.0 | mean(1)
 1.0 + 1.0 | median(1.0)
 1.0 + array?.[i]
 1.0 + f64 / f64
 1.0 + f64 / i
+1.0 + f64 < i
+1.0 + f64 == i
 1.0 + f64 >= f64
+1.0 + i / f64
 1.0 + i < f64
+1.0 + i > i
+1.0 + i >= i
+1.0 + i ?? greet == foo
 1.0 - $env.f64
 1.0 - $env.i
 1.0 - $env?.f64
+1.0 - $env?.f64 == 1.0
 1.0 - $env?.i
 1.0 - 0 != f64
+1.0 - 0 * f64
+1.0 - 0 >= f64
+1.0 - 0 ?? str
 1.0 - 1 + 1.0 == nil
 1.0 - 1 - i
 1.0 - 1 - min(1.0)
 1.0 - 1 / i
+1.0 - 1 > i and $env
+1.0 - 1 not in array
+1.0 - 1.0 != f64
 1.0 - 1.0 ** f64
 1.0 - 1.0 + f64
 1.0 - 1.0 < f64
+1.0 - 1.0 <= i
+1.0 - 1.0 == f64
 1.0 - 1.0 == i
 1.0 - 1.0 > f64
 1.0 - 1.0 >= f64
+1.0 - 1.0 ?? ok
 1.0 - 1.0 in array
+1.0 - 1.0 in array ?: i
+1.0 - 1.0 | median(0)
 1.0 - array?.[i]
+1.0 - f64 != f64
+1.0 - f64 * i
 1.0 - f64 - f64
 1.0 - f64 / i
+1.0 - f64 in array
 1.0 - i * $env.i
+1.0 - i ** -i
 1.0 - i < i
+1.0 - i ^ f64
+1.0 - i ^ i
 1.0 / $env.f64
 1.0 / $env.i
 1.0 / $env?.f64
 1.0 / $env?.i
 1.0 / 0 != i
 1.0 / 0 * $env?.f64
+1.0 / 0 + f64
+1.0 / 0 - i
+1.0 / 0 < i
 1.0 / 0 <= 1 + f64
+1.0 / 0 == f64
 1.0 / 0 == i
 1.0 / 0 > $env?.f64
+1.0 / 0 ?? list
+1.0 / 0 | median(f64, i)
+1.0 / 0 | min(1.0)
+1.0 / 1 != find($env, false)
 1.0 / 1 * f64
 1.0 / 1 ** i
+1.0 / 1 > f64
+1.0 / 1 >= f64
+1.0 / 1.0 != f64
 1.0 / 1.0 + i
+1.0 / 1.0 + min(0)
 1.0 / 1.0 - f64
+1.0 / 1.0 / f64
+1.0 / 1.0 <= f64
 1.0 / 1.0 == i
+1.0 / 1.0 > f64
+1.0 / 1.0 > i
 1.0 / 1.0 >= f64
+1.0 / 1.0 ?? 0 + 1
+1.0 / 1.0 ?? i
+1.0 / 1.0 ^ f64
+1.0 / 1.0 ^ i
 1.0 / array?.[i]
 1.0 / f64 * i
 1.0 / f64 <= f64 || true
+1.0 / f64 ?? one($env, #.foo)
 1.0 / f64 ^ i
 1.0 / f64 in array
+1.0 / i ** i
+1.0 / i / i != nil
 1.0 / i < f64
 1.0 / i <= i
+1.0 / i == i
+1.0 < $env.add(0, i)
 1.0 < $env.f64
 1.0 < $env.i
 1.0 < $env?.f64
 1.0 < $env?.i
+1.0 < 1 <= f64
+1.0 < 1 > $env?.[greet]
+1.0 < 1 > f64
+1.0 < 1 >= i
+1.0 < 1 ?? ok
 1.0 < 1.0 != ok
 1.0 < 1.0 && $env?.String(foobar, i)
 1.0 < 1.0 && $env?.[ok]
 1.0 < 1.0 ** f64
+1.0 < 1.0 - i
 1.0 < 1.0 / round(1.0)
 1.0 < 1.0 <= $env?.String
+1.0 < 1.0 <= i
+1.0 < 1.0 == $env && true
+1.0 < 1.0 == ok
+1.0 < 1.0 > round($env)
+1.0 < 1.0 >= 1.0 == ok
 1.0 < 1.0 ? foo != nil : str
+1.0 < 1.0 ?? $env?.[greet]
+1.0 < 1.0 ?? f64
+1.0 < 1.0 ?? foo
 1.0 < 1.0 ^ f64
+1.0 < 1.0 ^ i
 1.0 < 1.0 || ok
 1.0 < array?.[i]
 1.0 < f64 + $env.i
+1.0 < f64 + i
+1.0 < f64 - f64
+1.0 < f64 - i ?? add
+1.0 < f64 < $env?.[ok]
 1.0 < f64 ?: i
 1.0 < f64 ^ f64
 1.0 < i != ok
+1.0 < i / f64
 1.0 < i > f64
 1.0 < i > i
+1.0 < i >= -1.0
+1.0 < i >= i
 1.0 < i ?: 1 == i
 1.0 < i ?: list
+1.0 < i ^ f64
 1.0 <= $env.f64
 1.0 <= $env.i
 1.0 <= $env?.f64
 1.0 <= $env?.i
 1.0 <= 0 % i
+1.0 <= 0 - f64
 1.0 <= 0 / f64
+1.0 <= 0 / i
 1.0 <= 0 < f64 <= f64
 1.0 <= 0 >= i
 1.0 <= 0 ? f64 : greet
+1.0 <= 0 ?? array
+1.0 <= 0 ?? duration($env)
+1.0 <= 0 or ok
+1.0 <= 1 ** f64 ^ 1
 1.0 <= 1 ** i
 1.0 <= 1 / $env?.i
 1.0 <= 1 / i
+1.0 <= 1 < -i
+1.0 <= 1 < f64 < f64
 1.0 <= 1 or none($env, $env)
 1.0 <= 1.0 != ok
+1.0 <= 1.0 && $env?.Bar
+1.0 <= 1.0 * f64
+1.0 <= 1.0 * i
 1.0 <= 1.0 ** 1 and false
 1.0 <= 1.0 - f64
 1.0 <= 1.0 / mean(f64)
 1.0 <= 1.0 < f64
+1.0 <= 1.0 <= i
+1.0 <= 1.0 == ok == $env
+1.0 <= 1.0 > i
 1.0 <= 1.0 >= f64
 1.0 <= 1.0 or ok
 1.0 <= 1.0 || ok
 1.0 <= array?.[i]
+1.0 <= f64
 1.0 <= f64 != ok
 1.0 <= f64 && ok
+1.0 <= f64 ** 1 ? 1.0 : ok
+1.0 <= f64 < $env.f64
+1.0 <= f64 < -0
 1.0 <= f64 <= f64
 1.0 <= f64 >= f64
+1.0 <= f64 ?? add
+1.0 <= i * $env.f64
 1.0 <= i * i
 1.0 <= i / i
+1.0 <= i or 1 != f64
+1.0 <= i or ok != false
 1.0 == $env && ok != false
+1.0 == $env ?? array
+1.0 == $env ^ $env or true
+1.0 == $env or ok
+1.0 == $env or true ?? nil
 1.0 == $env.f64
 1.0 == $env.i
 1.0 == $env?.Bar
@@ -3734,100 +8043,295 @@ $env[$env:] - f64 and false
 1.0 == $env?.[Bar]
 1.0 == $env?.[Bar]?.foo
 1.0 == $env?.[String]
+1.0 == $env?.[String]?.[array]
+1.0 == $env?.[String]?.[ok].greet
 1.0 == $env?.[foobar?.[f64]]
+1.0 == $env?.[foobar]
+1.0 == $env?.[greet(Bar)]
 1.0 == $env?.[str]
 1.0 == $env?.f64
+1.0 == $env?.foobar
+1.0 == $env?.foobar?.[ok]
 1.0 == $env?.i
 1.0 == $env?.true != $env
+1.0 == 0 != $env || false
+1.0 == 0 ?? -0
+1.0 == 0 ^ f64
 1.0 == 0 or $env?.ok
 1.0 == 1 != ok
 1.0 == 1 % i
+1.0 == 1 * f64
 1.0 == 1 - f64
 1.0 == 1 - i
 1.0 == 1 == ok
 1.0 == 1.0 != ok
 1.0 == 1.0 * f64
+1.0 == 1.0 ** i
 1.0 == 1.0 - i
 1.0 == 1.0 / f64
+1.0 == 1.0 ?? i
 1.0 == 1.0 and ok
+1.0 == 1.0 in [nil, 1]
+1.0 == 1.0 || any($env, true)
 1.0 == 1.0 || ok
 1.0 == array?.[i]
 1.0 == f64 != ok
+1.0 == f64 * 0 ?? 0
+1.0 == false ?? uniq(array)
+1.0 == foo ?? count(array)
+1.0 == foo ?? ok
+1.0 == i != ok
+1.0 == i != ok; nil
 1.0 == i * i
 1.0 == i + f64
+1.0 == i + sum(list, 1.0)
+1.0 == i / i
+1.0 == i ?? i
 1.0 == nil ?: array
 1.0 == nil and $env.ok
 1.0 == nil or ok
+1.0 == ok ?? f64
+1.0 == str ?? foo
+1.0 > $env * 1.0 || true
 1.0 > $env.f64
 1.0 > $env.i
 1.0 > $env?.f64
 1.0 > $env?.i
 1.0 > 0 / i
+1.0 > 0 < 1 ^ f64
 1.0 > 0 < f64
 1.0 > 0 < i
+1.0 > 0 >= last(array)
+1.0 > 0 || ok
+1.0 > 1 > find($env, #)
+1.0 > 1 >= $env?.[ok]
 1.0 > 1 ?: {foo: add, foo: ok}?.foo
+1.0 > 1 ?? $env?.str
+1.0 > 1 ?? f64
+1.0 > 1 ?? nil && $env
+1.0 > 1 ^ i
 1.0 > 1.0 * array?.[i]
+1.0 > 1.0 <= f64
+1.0 > 1.0 == ok
 1.0 > 1.0 > i
+1.0 > 1.0 >= len(str)
+1.0 > 1.0 ?? array
+1.0 > 1.0 ?? list
 1.0 > array?.[i]
 1.0 > f64 * f64
+1.0 > f64 ** i
 1.0 > f64 + f64
 1.0 > f64 / i
 1.0 > f64 < f64
 1.0 > f64 > round(1.0)
+1.0 > f64 ?? greet
+1.0 > f64 ?? map(list, true)
 1.0 > f64 or none($env, .f64)
+1.0 > i != str ?? foo
+1.0 > i && median($env, foo)
 1.0 > i && ok
 1.0 > i + 1.0
 1.0 > i >= $env?.[String]
 1.0 >= $env.f64
 1.0 >= $env.i
+1.0 >= $env?.[str]?.[f64]
 1.0 >= $env?.f64
 1.0 >= $env?.i
 1.0 >= 0 / i
+1.0 >= 1 <= f64
 1.0 >= 1 > i
 1.0 >= 1 > i >= i
+1.0 >= 1 ?? array < 0
+1.0 >= 1 in $env?.Bar
+1.0 >= 1.0 * f64
 1.0 >= 1.0 * f64 or ok
 1.0 >= 1.0 + f64
 1.0 >= 1.0 / i
 1.0 >= 1.0 / sum(array)
+1.0 >= 1.0 < f64
+1.0 >= 1.0 <= f64
 1.0 >= 1.0 == {foo: $env, foo: $env}.foo
+1.0 >= 1.0 > i
 1.0 >= 1.0 ?: list
+1.0 >= 1.0 ?? greet
+1.0 >= 1.0 ?? list
 1.0 >= 1.0 ^ f64
+1.0 >= 1.0 and f64 ?? foo
 1.0 >= array?.[i]
 1.0 >= f64 ** $env?.i
 1.0 >= f64 ** 0 > 1.0
+1.0 >= f64 + i
+1.0 >= f64 - i
 1.0 >= f64 / i
+1.0 >= f64 > f64
+1.0 >= f64 not in $env?.[String]
 1.0 >= i * f64
 1.0 >= i * i
 1.0 >= i + 1.0 >= $env
 1.0 >= i - i
 1.0 >= i < $env?.i
+1.0 >= i == $env?.[Bar]
+1.0 >= i == not false
+1.0 >= i ?? array
+1.0 >= i and not ok
+1.0 ?? $env ?? list
+1.0 ?? $env.add
+1.0 ?? $env.array
+1.0 ?? $env.f64
+1.0 ?? $env.foo
+1.0 ?? $env.greet
+1.0 ?? $env.i
+1.0 ?? $env.list
+1.0 ?? $env.ok
+1.0 ?? $env.str
+1.0 ?? $env?.$env?.$env
+1.0 ?? $env?.$env?.array
+1.0 ?? $env?.Bar
+1.0 ?? $env?.Bar()
+1.0 ?? $env?.String
+1.0 ?? $env?.String()
+1.0 ?? $env?.String?.f64
+1.0 ?? $env?.String?.ok()
+1.0 ?? $env?.[$env?.[foobar]]
+1.0 ?? $env?.[1.0 >= list]
+1.0 ?? $env?.[1.0 not in array]
+1.0 ?? $env?.[Bar]
+1.0 ?? $env?.[Bar]?.[list]
+1.0 ?? $env?.[String]
+1.0 ?? $env?.[String]?.[add]
+1.0 ?? $env?.[String]?.ok
+1.0 ?? $env?.[add]
+1.0 ?? $env?.[add].str
+1.0 ?? $env?.[array < array]
+1.0 ?? $env?.[array]
+1.0 ?? $env?.[array].greet
+1.0 ?? $env?.[count(1)]
+1.0 ?? $env?.[f64(ok)]
+1.0 ?? $env?.[f64]
+1.0 ?? $env?.[filter(foobar, foobar)]
+1.0 ?? $env?.[findIndex(ok, #acc)]
+1.0 ?? $env?.[flatten(add)]
+1.0 ?? $env?.[foo | floor(foobar)]
+1.0 ?? $env?.[foo?.str]
+1.0 ?? $env?.[foo]
+1.0 ?? $env?.[foobar | ok()]
+1.0 ?? $env?.[foobar?.add(foobar)]
+1.0 ?? $env?.[foobar?.add]
+1.0 ?? $env?.[foobar]
+1.0 ?? $env?.[greet startsWith String]
+1.0 ?? $env?.[greet()]
+1.0 ?? $env?.[greet?.add]
+1.0 ?? $env?.[greet]
+1.0 ?? $env?.[i]
+1.0 ?? $env?.[list(Bar)]?.[i]
+1.0 ?? $env?.[list]
+1.0 ?? $env?.[ok]
+1.0 ?? $env?.[str]
+1.0 ?? $env?.[str].foo
+1.0 ?? $env?.[str]?.[f64]
+1.0 ?? $env?.add
+1.0 ?? $env?.array
+1.0 ?? $env?.f64
+1.0 ?? $env?.false?.[f64]
+1.0 ?? $env?.foo
+1.0 ?? $env?.foo?.String
+1.0 ?? $env?.foobar.array
+1.0 ?? $env?.greet
+1.0 ?? $env?.i
+1.0 ?? $env?.list
+1.0 ?? $env?.ok
+1.0 ?? $env?.str
+1.0 ?? $env[$env || foobar:foobar ** f64]
+1.0 ?? $env[1.0 || true:]
+1.0 ?? $env[:$env && add]
+1.0 ?? $env[:$env | hasSuffix(false)]
+1.0 ?? $env[:findIndex(foobar, foobar)]
+1.0 ?? $env[:foobar?.[array]]
+1.0 ?? $env[:foobar]
+1.0 ?? $env[add not startsWith greet:]
+1.0 ?? $env[array():]
+1.0 ?? $env[f64 and ok:0 or 1.0]
+1.0 ?? $env[foo($env):str(foobar)]
+1.0 ?? $env[foo?.foo():]
+1.0 ?? $env[foobar | f64():]
+1.0 ?? $env[foobar:greet()]
+1.0 ?? $env[reduce(true, nil, foobar):foo and foobar]
+1.0 ?? 1.0 ?? f64
+1.0 ?? 1.0 ?? list
+1.0 ?? array ?? ok
+1.0 ?? array | mean(0)
+1.0 ?? array?.[i]
+1.0 ?? array[:$env ?? f64]
+1.0 ?? array[:i]
+1.0 ?? f64 | max(1.0)
+1.0 ?? foo.Bar
+1.0 ?? foo.String
+1.0 ?? foo.String()
+1.0 ?? foo?.Bar
+1.0 ?? foo?.String
+1.0 ?? foo?.String()
+1.0 ?? greet ?? add
+1.0 ?? greet ?? ok
+1.0 ?? list ?? greet
+1.0 ?? list?.[i]
+1.0 ?? nil | median(array)
+1.0 ?? ok ?? list
+1.0 ?? str ?? [true]
+1.0 ?? true ?? add
 1.0 ^ $env.f64
 1.0 ^ $env.i
 1.0 ^ $env?.f64
 1.0 ^ $env?.i
 1.0 ^ 0 - i
+1.0 ^ 0 / -i
+1.0 ^ 0 < f64
+1.0 ^ 0 <= i
+1.0 ^ 0 == $env ?? 1.0
 1.0 ^ 0 > i ? array : foo
+1.0 ^ 0 ?? f64
+1.0 ^ 0 ?? foo
 1.0 ^ 0 ^ f64
 1.0 ^ 1 * i
+1.0 ^ 1 ** f64
+1.0 ^ 1 - f64
 1.0 ^ 1 - sum(array)
 1.0 ^ 1 == i
 1.0 ^ 1 >= 1 || false
+1.0 ^ 1 ?? add
+1.0 ^ 1 ?? f64
+1.0 ^ 1 ?? foo
+1.0 ^ 1.0 * f64
+1.0 ^ 1.0 ** f64
+1.0 ^ 1.0 ** i
 1.0 ^ 1.0 + 1.0 in array
 1.0 ^ 1.0 == $env?.i
 1.0 ^ 1.0 > i
 1.0 ^ 1.0 >= f64
+1.0 ^ 1.0 ?? f64
+1.0 ^ 1.0 ?? foo
+1.0 ^ 1.0 ?? ok
+1.0 ^ 1.0 ^ i
+1.0 ^ 1.0 not in array
+1.0 ^ 1.0 | min(1.0 ?? $env)
+1.0 ^ 1.0 | min(f64)
 1.0 ^ array?.[i]
 1.0 ^ f64 * i
+1.0 ^ f64 <= f64
 1.0 ^ f64 <= i and $env
+1.0 ^ f64 == f64
+1.0 ^ f64 ^ i
 1.0 ^ i * i
+1.0 ^ i - i
 1.0 ^ i < f64 < 1.0
 1.0 ^ i <= int(1.0)
 1.0 ^ i > i
+1.0 ^ i ?? greet
 1.0 ^ i in array
 1.0 ^ i not in array
 1.0 in $env.array
 1.0 in $env?.Bar
 1.0 in $env?.String
+1.0 in $env?.String?.array
 1.0 in $env?.String?.f64
 1.0 in $env?.[Bar]
 1.0 in $env?.[Bar]?.[add]
@@ -3836,10 +8340,16 @@ $env[$env:] - f64 and false
 1.0 in $env?.[String]?.[i]
 1.0 in $env?.[String]?.[str]
 1.0 in $env?.[foobar?.[foo]]
+1.0 in $env?.[foobar]
 1.0 in $env?.array
 1.0 in $env?.foobar
+1.0 in $env?.foobar?.Bar()
 1.0 in 0 .. i
+1.0 in array != ok
+1.0 in array == ok
+1.0 in array ?? i
 1.0 in array or ok
+1.0 in i..i
 1.0 not in $env.array
 1.0 not in $env?.Bar
 1.0 not in $env?.String
@@ -3848,36 +8358,73 @@ $env[$env:] - f64 and false
 1.0 not in $env?.[String]?.[array]
 1.0 not in $env?.[foobar?.str]
 1.0 not in $env?.[foobar]
+1.0 not in $env?.[foobar]?.list
 1.0 not in $env?.array
 1.0 not in $env?.foobar
 1.0 not in $env?.nil?.[list].array()
+1.0 not in array && ok
+1.0 not in array ?? $env?.[list]
 1.0 | max(1.0, f64) < f64
 1.0 | max(array) <= i
+1.0 | max(f64) != i
+1.0 | max(i) == f64
+1.0 | mean(1.0) * 1 ?? false
 1.0 | mean(f64) != i
 1.0 | median(0) ^ i
 1.0 | median(array) | get(foo)
+1.0 | min(1.0) != i
 1.0 | min(1.0) ** i
 1.0; $env.i
 1.0; $env?.Bar
+1.0; $env?.i
 1.0; $env?.list
 1.0; 1.0 < f64
+1.0; array | reduce(#)
+1.0; foo?.Bar
+1.1 * f64
+1.1 < i
+1.1 >= f64
+1; $env.i
+1; $env?.foo
+1; $env?.foobar
+1; $env?.i
+1; 1 ?? $env.array
+1; add ?? date(i)
+1; f64 < i
+[!false, -0]
+[!false, foo]
+[!false]
+[!ok, foo]
+[!ok, greet]
+[!ok]
+[!true, array]
+[!true]
 [$env != $env]
 [$env != 0]
+[$env != 1, f64]
 [$env != 1.0]
 [$env != 1]
 [$env != add]
 [$env != f64]
 [$env != false]
 [$env != foo]
+[$env != greet]
+[$env != i]
 [$env != list]
 [$env != nil]
+[$env != ok]
+[$env != str]
+[$env && false]
 [$env && true]
+[$env == $env, foo != foo]
+[$env == $env.add]
 [$env == $env]
 [$env == 0]
 [$env == 1.0]
 [$env == 1]
 [$env == add]
 [$env == false]
+[$env == foo, ok]
 [$env == foo]
 [$env == greet]
 [$env == i, f64]
@@ -3887,6 +8434,18 @@ $env[$env:] - f64 and false
 [$env == ok]
 [$env == str]
 [$env == true]
+[$env ?? $env]
+[$env ?? 0]
+[$env ?? 1.0]
+[$env ?? 1]
+[$env ?? add]
+[$env ?? array]
+[$env ?? false]
+[$env ?? foo]
+[$env ?? i]
+[$env ?? nil]
+[$env ?? str]
+[$env ?? true]
 [$env and false]
 [$env and true]
 [$env in list]
@@ -3901,8 +8460,11 @@ $env[$env:] - f64 and false
 [$env | any(ok)]
 [$env | any(true)]
 [$env | filter(false), f64]
+[$env | find(false)]
+[$env | findIndex(true)]
 [$env | findLast(false)]
 [$env | findLastIndex(false)]
+[$env | map(#index)]
 [$env | map(1.0)]
 [$env | map(add)]
 [$env | map(array)]
@@ -3913,16 +8475,22 @@ $env[$env:] - f64 and false
 [$env | map(list)]
 [$env | map(ok)]
 [$env | map(str)]
+[$env | map(true)]
 [$env | none(false)]
 [$env | one(false)]
 [$env | one(ok)]
+[$env | reduce(list, 0)]
+[$env | reduce(true, foo)]
 [$env | sum(0)]
 [$env | sum(1)]
 [$env | sum(1.0)]
 [$env | sum(f64)]
+[$env || false]
+[$env || true]
 [$env, $env]?.[i]
 [$env, 0] | any(.ok)
 [$env, 1.0] | find(true)
+[$env, 1.0] | map(#)
 [$env, 1.0] | map(true)
 [$env, 1.0]?.[i]
 [$env, 1] | reduce(i, nil)
@@ -3930,6 +8498,14 @@ $env[$env:] - f64 and false
 [$env, false] | reduce(#)
 [$env, foo] | groupBy(f64)
 [$env, foo] | reduce($env)
+[$env, foo]?.[i]
+[$env, greet] | reduce(1)
+[$env, i] | reduce(false, $env)
+[$env, nil]?.[i]
+[$env, ok, $env]?.[i]
+[$env, ok] | findLastIndex(#)
+[$env, ok] | findLastIndex(false)
+[$env, ok] | reduce(f64)
 [$env, ok]?.[i]
 [$env, true] | groupBy(foo)
 [$env, true] | map(foo)
@@ -3937,8 +8513,10 @@ $env[$env:] - f64 and false
 [$env.add, list]
 [$env.add]
 [$env.array, i]
+[$env.array?.[i]]
 [$env.array]
 [$env.f64, greet]
+[$env.f64, ok]
 [$env.f64, round(1.0)]
 [$env.f64, string($env)]
 [$env.f64]
@@ -3948,84 +8526,134 @@ $env[$env:] - f64 and false
 [$env.greet, 1 >= 1]
 [$env.greet, foo]
 [$env.greet]
+[$env.i, $env.i]
 [$env.i, greet]
+[$env.i, str]
 [$env.i]
 [$env.list, add]
 [$env.list]
+[$env.ok, foo]
+[$env.ok, i]
+[$env.ok, list]
 [$env.ok]
 [$env.str, max(1.0)]
+[$env.str, str]
 [$env.str]
 [$env?.$env]
 [$env?.Bar]
 [$env?.String, add]
 [$env?.String, f64]
+[$env?.String?.f64]
 [$env?.String]
 [$env?.[Bar], array]
 [$env?.[Bar], foo]
+[$env?.[Bar]?.f64]
 [$env?.[Bar]]
+[$env?.[String] == list]
+[$env?.[String], foo]
+[$env?.[String], list]
 [$env?.[String], str]
 [$env?.[String]?.[foo]]
+[$env?.[String]?.[list]]
 [$env?.[String]]
+[$env?.[foobar], i]
 [$env?.[foobar]?.add?.add]
+[$env?.[foobar]?.greet]
 [$env?.[foobar]]
+[$env?.[nil]?.add()]
 [$env?.[nil]]
+[$env?.[str] | groupBy(#)]
 [$env?.[str], f64]
+[$env?.[str]?.[i]]
 [$env?.[str]]
 [$env?.add, foo]
+[$env?.add, ok]
 [$env?.add]
 [$env?.array | map(str)]
 [$env?.array, $env?.list]
+[$env?.array, [true]]
+[$env?.array, add]
 [$env?.array, array != $env]
+[$env?.array, str]
 [$env?.array]
 [$env?.f64]
+[$env?.false]
 [$env?.foo]
 [$env?.foobar, $env.add]
 [$env?.foobar?.ok]
 [$env?.foobar]
+[$env?.greet, add]
+[$env?.greet, array]
 [$env?.greet]
 [$env?.i, i < f64]
+[$env?.i, ok]
 [$env?.i]
 [$env?.list | map(#)]
 [$env?.list]
 [$env?.nil]
 [$env?.ok]
+[$env?.str, str]
 [$env?.str]
 [$env] != list
 [$env] == 0 .. 1
+[$env] ?? duration($env)
+[$env] ?? str
+[$env] | all(false)
 [$env] | any(#.ok)
+[$env] | any(.ok)
+[$env] | any(false)
+[$env] | any(true)
 [$env] | concat(array)
 [$env] | count(#.ok)
 [$env] | count(ok)
 [$env] | filter(.ok)
+[$env] | filter(false)
 [$env] | filter(ok)
 [$env] | find(#.ok != .Bar)
 [$env] | find(#.ok)
+[$env] | findLast(ok)
+[$env] | findLast(true)
+[$env] | findLastIndex(#.ok)
 [$env] | findLastIndex(false)
+[$env] | groupBy(#.f64)
 [$env] | groupBy(.add == ok)
 [$env] | groupBy(1)
 [$env] | groupBy(i)
 [$env] | map(#.String)
+[$env] | map(#.ok)
 [$env] | map($env)
 [$env] | map(.greet)
+[$env] | map(.list)
 [$env] | map(.str)
 [$env] | map(1)
 [$env] | map(1.0)
 [$env] | map(array)
+[$env] | map(false)
 [$env] | map(foo)
 [$env] | map(true)
+[$env] | one(.ok)
 [$env] | reduce(#)
+[$env] | reduce(#.Bar)
 [$env] | reduce(#.add)
 [$env] | reduce(#.add?.[false])
 [$env] | reduce(#.f64 | map(#.str))
 [$env] | reduce(#.greet, greet)
 [$env] | reduce(#.greet?.[foo])
 [$env] | reduce(#.ok)
+[$env] | reduce(#index)
 [$env] | reduce($env)
+[$env] | reduce(.Bar)
 [$env] | reduce(.Bar, 0)
+[$env] | reduce(.String)
+[$env] | reduce(0)
 [$env] | reduce(1)
 [$env] | reduce(1.0)
 [$env] | reduce(array)
+[$env] | reduce(f64)
+[$env] | reduce(false)
+[$env] | reduce(false, 1.0)
 [$env] | reduce(foo)
+[$env] | reduce(greet, true)
 [$env] | reduce(i)
 [$env] | reduce(list, i)
 [$env] | reduce(ok)
@@ -4033,6 +8661,7 @@ $env[$env:] - f64 and false
 [$env] | sortBy(#.list)
 [$env] | sortBy(#?.[.String])
 [$env] | sortBy(.array)
+[$env] | sortBy(.foo)
 [$env] | sortBy(1)
 [$env] | sortBy(array)
 [$env] | sortBy(false)
@@ -4040,33 +8669,63 @@ $env[$env:] - f64 and false
 [$env] | sortBy(greet)
 [$env] | sortBy(list)
 [$env] | sum(#.f64)
+[$env] | sum(#.i)
 [$env] | sum(.f64)
+[$env] | sum(1)
 [$env] | sum(1.0)
+[$env]; i
 [$env][len(list):]
+[-$env.f64]
+[--1.0]
+[-0, list]
+[-0, ok]
+[-0]
+[-1.0, i ?? foo]
+[-1.0]
+[-1]
+[-f64]
+[-i, add]
+[-i, f64]
+[-i]
 [0 != $env]
 [0 != 0]
 [0 != 1.0]
+[0 != f64]
 [0 != i]
 [0 != nil]
+[0 % i]
 [0 * 0]
+[0 * 1.0]
 [0 * 1]
 [0 * f64]
+[0 ** 0]
+[0 ** 1.0, f64]
 [0 ** 1.0]
 [0 ** 1]
 [0 + 1.0]
 [0 + f64]
+[0 + i]
 [0 - 0]
+[0 - 1.0]
+[0 - 1]
+[0 - i]
+[0 .. 0]
+[0 .. i]
+[0 / 0]
 [0 / f64]
 [0 / i]
 [0 < 0]
 [0 < 1.0]
+[0 < 1]
 [0 < f64]
+[0 < i]
 [0 <= 0]
 [0 <= f64]
 [0 <= i]
 [0 == $env]
 [0 == 0]
 [0 == 1.0]
+[0 == 1]
 [0 == i]
 [0 == nil]
 [0 > 0]
@@ -4076,25 +8735,54 @@ $env[$env:] - f64 and false
 [0 >= 1.0]
 [0 >= 1]
 [0 >= f64]
+[0 ?? 0]
+[0 ?? 1.0]
+[0 ?? array]
+[0 ?? foo]
+[0 ?? greet]
+[0 ?? i]
+[0 ?? nil]
+[0 ?? ok]
+[0 ?? true]
+[0 ^ 1.0]
 [0 ^ 1]
+[0 ^ i]
 [0 in array]
 [0 not in array]
+[0 | bitor(1), list]
 [0 | median(1.0)]
 [0, $env] | count(false || true)
+[0, $env] | map(1)
+[0, $env] | reduce(str, 1.0)
 [0, $env] | sortBy(1.0)
+[0, $env]?.[i]
 [0, 0] | reduce(1.0, $env)
+[0, 1.0] | map(array)
 [0, 1.0]?.[i]
+[0, 1]?.[i]
 [0, add] | findLastIndex(ok)
+[0, add]?.[i]
+[0, false]?.[i]
+[0, foo] | findLast(true)
+[0, foo] | reduce(#, 1)
+[0, foo]?.[i]
 [0, foo][:]
 [0, greet]?.[i]
 [0, i] | any(false)
 [0, i]?.[i]
+[0, list, true] | map(#)
+[0, list] | sortBy(f64)
 [0, list]?.[i]
+[0, nil] | map(#)
+[0, nil]?.[i]
 [0, ok]?.[i]
 [0, str] | map(#)
+[0, true] ?? str
 [0, true]?.[i]
 [0.0]
 [0.1]
+[0] ?? $env?.String
+[0] ?? groupBy($env, .Bar)
 [0] | all(false)
 [0] | any(false)
 [0] | count(ok)
@@ -4105,60 +8793,105 @@ $env[$env:] - f64 and false
 [0] | map(array)
 [0] | map(f64)
 [0] | map(foo)
+[0] | map(greet)
+[0] | map(true)
+[0] | none(false)
+[0] | one(ok)
+[0] | one(true)
 [0] | reduce(#)
 [0] | reduce(0, nil)
+[0] | reduce(1)
+[0] | reduce(false)
+[0] | reduce(foo, $env)
 [0] | reduce(i)
 [0] | sortBy(#)
+[0] | sortBy(0)
 [0] | sortBy(1.0)
 [0] | sortBy(foo)
 [0] | sortBy(str)
+[0] | sum(#)
 [0] | sum(i)
 [1 != $env]
+[1 != 0]
 [1 != 1.0]
+[1 != 1]
 [1 != f64]
+[1 != i]
 [1 != nil]
+[1 % i]
 [1 * 0]
 [1 * 1.0]
 [1 * 1]
 [1 * f64]
+[1 ** 1.0]
+[1 ** 1]
 [1 ** f64]
+[1 ** i]
 [1 + 0]
 [1 + 1.0]
 [1 + 1]
 [1 + f64]
+[1 + i]
 [1 - 0]
 [1 - 1.0]
 [1 - f64]
+[1 - i]
 [1 .. 1]
 [1 / 1.0]
+[1 / f64]
 [1 / i]
 [1 < 0]
 [1 < 1.0, foo]
 [1 < 1.0]
 [1 < 1]
+[1 < f64]
 [1 <= 1.0]
 [1 <= 1]
+[1 <= i]
 [1 == $env]
 [1 == 1.0]
 [1 == 1]
 [1 == f64]
 [1 == i]
+[1 == nil]
 [1 > 1.0]
+[1 > 1]
+[1 > i]
 [1 >= 1.0]
+[1 >= 1]
 [1 >= i]
+[1 ?? 1, i]
+[1 ?? 1.0]
+[1 ?? 1]
+[1 ?? add]
+[1 ?? array]
+[1 ?? foo]
+[1 ?? list, greet]
+[1 ?? list]
+[1 ?? nil]
+[1 ?? str]
+[1 ?? true]
 [1 ^ f64]
+[1 ^ i]
 [1 | max(1.0)]
 [1 | median(1.0)]
 [1, $env]?.[i]
+[1, 1.0] | one(ok)
+[1, 1.0]?.[i]
+[1, 1] | reduce(true)
 [1, 1]?.[i]
 [1, false] | all(false)
 [1, false] | groupBy(true)
+[1, foo] | count(true)
 [1, foo]?.[i]
+[1, greet] | reduce(#, foo)
 [1, greet] | reduce(#acc, 0)
+[1, greet]?.[i]
 [1, nil] | reduce(add, array)
 [1, str, 0] | findLastIndex($env?.ok)
 [1, true] | findLastIndex(#)
 [1.0 != $env]
+[1.0 != $env] | all(ok)
 [1.0 != 0]
 [1.0 != 1.0]
 [1.0 != 1]
@@ -4169,11 +8902,15 @@ $env[$env:] - f64 and false
 [1.0 * 1.0]
 [1.0 * 1]
 [1.0 * i]
+[1.0 ** 0]
+[1.0 ** 1, ok]
 [1.0 ** 1.0]
+[1.0 ** 1]
 [1.0 ** f64]
 [1.0 ** i]
 [1.0 + 0]
 [1.0 + 1.0]
+[1.0 + 1]
 [1.0 + f64]
 [1.0 + i]
 [1.0 - 0]
@@ -4181,12 +8918,16 @@ $env[$env:] - f64 and false
 [1.0 - 1]
 [1.0 - i]
 [1.0 / 0]
+[1.0 / 1.0]
 [1.0 / 1]
 [1.0 / f64]
 [1.0 / i]
+[1.0 < 0]
 [1.0 < 1.0]
+[1.0 < 1]
 [1.0 < f64]
 [1.0 < i]
+[1.0 <= 0]
 [1.0 <= 1.0, foo]
 [1.0 <= 1.0]
 [1.0 <= 1]
@@ -4202,45 +8943,94 @@ $env[$env:] - f64 and false
 [1.0 > 0]
 [1.0 > 1.0]
 [1.0 > 1]
+[1.0 > f64]
+[1.0 > i]
+[1.0 >= 0]
 [1.0 >= 1.0]
 [1.0 >= 1]
 [1.0 >= f64]
 [1.0 >= i]
+[1.0 ?? $env]
+[1.0 ?? 0]
+[1.0 ?? 1.0]
+[1.0 ?? add]
+[1.0 ?? array]
+[1.0 ?? f64]
+[1.0 ?? foo]
+[1.0 ?? greet]
+[1.0 ?? list]
+[1.0 ?? nil]
+[1.0 ?? str]
 [1.0 ^ 0]
+[1.0 ^ 1.0]
 [1.0 ^ 1]
 [1.0 ^ f64]
 [1.0 ^ i]
 [1.0 in array, list]
+[1.0 not in array]
 [1.0 | max(f64)]
+[1.0 | mean(array)]
 [1.0 | mean(f64)]
+[1.0 | min(1)]
+[1.0 | min(1.0, i)]
+[1.0, $env] | map(add)
 [1.0, $env] | map(str)
 [1.0, $env] | reduce(array)
+[1.0, $env]?.[i]
+[1.0, 0] | groupBy(#)
 [1.0, 0] | map(#)
+[1.0, 1.0] | findLast(true)
+[1.0, 1.0] | mean(i)
+[1.0, 1.0] | reduce(str)
 [1.0, 1.0] | sortBy(#)
+[1.0, 1.0]?.[i]
+[1.0, 1]?.[i]
+[1.0, add] | any(ok)
 [1.0, f64] | reduce(#)
+[1.0, f64]?.[i]
 [1.0, foo]?.[i]
 [1.0, greet] | reduce($env, list)
+[1.0, greet]?.[i]
+[1.0, i]?.[i]
+[1.0, list] ?? ok
 [1.0, nil] | reduce(true)
+[1.0, nil] | sortBy(1)
 [1.0, nil] | sum(f64)
 [1.0, ok] | findLastIndex(true)
 [1.0, ok]?.[i]
+[1.0, str] | map(array)
+[1.0, str] | reduce(greet)
+[1.0, true] | map($env)
+[1.0, true]?.[i]
 [1.0]
+[1.0] != array
+[1.0] != nil || ok
 [1.0] == list
+[1.0] ?? array
+[1.0] ?? count($env, $env)
+[1.0] ?? f64
 [1.0] | all(true)
 [1.0] | any(true)
 [1.0] | filter(ok)
+[1.0] | filter(true)
 [1.0] | find(false)
 [1.0] | findLastIndex(false)
+[1.0] | get(0)
 [1.0] | groupBy(#)
 [1.0] | groupBy(0)
 [1.0] | groupBy(1)
+[1.0] | groupBy(1.0)
 [1.0] | groupBy(f64)
 [1.0] | groupBy(foo)
+[1.0] | map(#)
 [1.0] | map(#index)
 [1.0] | map($env)
+[1.0] | map(1)
 [1.0] | map(1.0)
 [1.0] | map(add)
+[1.0] | map(array)
 [1.0] | map(foo)
+[1.0] | map(greet)
 [1.0] | map(i)
 [1.0] | map(str)
 [1.0] | median(1.0)
@@ -4251,56 +9041,101 @@ $env[$env:] - f64 and false
 [1.0] | reduce(#acc)
 [1.0] | reduce(#acc, foo)
 [1.0] | reduce($env)
+[1.0] | reduce(0)
+[1.0] | reduce(1, foo)
 [1.0] | reduce(1.0)
+[1.0] | reduce(add)
 [1.0] | reduce(array)
 [1.0] | reduce(f64)
+[1.0] | reduce(false)
+[1.0] | reduce(greet)
+[1.0] | sortBy(0)
 [1.0] | sortBy(1)
 [1.0] | sortBy(false)
 [1.0] | sortBy(greet)
+[1.0] | sortBy(list)
 [1.0] | sum(0)
 [1.0] | sum(1.0)
 [1.0][:]
 [1.1]
+[1] != [1]
+[1] ?? f64
+[1] ?? ok
+[1] | all(true)
 [1] | filter(false)
+[1] | findIndex(ok)
 [1] | findIndex(true)
+[1] | findLast(ok)
 [1] | groupBy(#)
+[1] | groupBy(f64)
 [1] | groupBy(foo)
+[1] | groupBy(str)
 [1] | map(#)
+[1] | map($env)
 [1] | map(1.0)
 [1] | map(foo)
+[1] | mean(1.0)
+[1] | one(ok)
+[1] | reduce(#)
 [1] | reduce(#, foo)
+[1] | reduce(1.0, true)
+[1] | reduce(f64, foo)
+[1] | reduce(list)
 [1] | sortBy(#)
+[1] | sortBy($env)
 [1] | sortBy(1.0)
 [1] | sortBy(array)
 [1] | sortBy(true)
 [1] | sum(#)
 [1] | sum(1.0)
+[1] | sum(f64)
+[1]?.[f64 ?? $env]
+[[$env, greet, i]]
+[[$env, i, 1.0]]
 [[$env]]
 [[0]]
+[[1, add]]
+[[1, foo], greet]
 [[1, ok]]
 [[1, true, true]]
 [[1.0, foo]]
+[[1.0, true]]
 [[1.0], 1 / 1.0]
+[[1.0], foo]
+[[1.0], greet]
 [[1.0]]
 [[1]]
+[[add, ok]]
 [[add]]
+[[array, $env]]
 [[array]]
+[[f64, array]]
 [[f64, foo]]
 [[f64]]
 [[false, add]]
 [[false]]
 [[foo, 1]]
 [[foo, array]]
+[[foo, f64]]
+[[foo, true]]
 [[foo], i]
 [[foo]]
 [[greet], $env?.String]
+[[greet], add]
 [[greet]]
+[[i, foo]]
 [[i]]
+[[list, nil, foo]]
+[[list, nil]]
 [[list, ok, foo]]
 [[list]]
+[[nil, $env]]
+[[nil, ok]]
+[[nil], f64]
 [[nil], i]
 [[nil]]
 [[ok, 0]]
+[[ok, add]]
 [[ok]]
 [[str]]
 [[true]]
@@ -4314,187 +9149,340 @@ $env[$env:] - f64 and false
 [add != nil]
 [add == $env]
 [add == nil]
+[add ?? $env]
+[add ?? 0]
+[add ?? 1.0]
+[add ?? array]
+[add ?? f64]
+[add ?? foo]
+[add ?? list]
+[add ?? nil]
+[add ?? str]
+[add ?? true]
 [add(1, i)]
 [add(i, 1)]
+[add(i, i)]
 [add, $env != 1]
 [add, $env.foo]
 [add, $env?.[String]]
 [add, $env?.[str]]
 [add, $env?.greet]
+[add, -1.0]
 [add, 0] | map(add)
+[add, 1.0, i] | count(true)
 [add, 1.0]?.[i]
+[add, 1] | reduce(true, nil)
 [add, [$env]]
 [add, add]
 [add, array]
 [add, f64]
+[add, f64]?.[i]
 [add, false]?.[i]
+[add, foo, list]
+[add, foo.Bar]
+[add, foo?.String]
 [add, foo]
 [add, foo] | groupBy(foo)
+[add, foo] | reduce(#index)
+[add, foo] | reduce(f64)
+[add, foo] | reduce(foo)
+[add, foo] | sortBy(i)
 [add, greet]
+[add, greet] | reduce(i, foo)
 [add, i]
 [add, list]
 [add, ok]
+[add, ok] | groupBy(foo)
 [add, ok] | none(ok)
 [add, ok]?.[i]
 [add, str]
+[add, str] | groupBy(f64)
+[add, string(i)]
+[add, toJSON(true)]
 [add, true]?.[i]
 [add]
+[add] ?? greet
+[add] ?? ok
+[add] | all(false)
 [add] | all(true)
+[add] | any(false)
+[add] | any(ok)
+[add] | findLast(ok)
 [add] | findLastIndex(false)
+[add] | groupBy(0)
 [add] | groupBy(true)
 [add] | map(#)
 [add] | map($env)
+[add] | map(0)
 [add] | map(1.0)
 [add] | map(add)
+[add] | map(greet)
 [add] | map(ok)
 [add] | none(ok)
 [add] | reduce(#)
 [add] | reduce(#, add)
 [add] | reduce(#acc)
+[add] | reduce(1)
 [add] | reduce(foo, foo)
+[add] | reduce(ok)
 [add] | sortBy($env)
+[add] | sortBy(list)
+[add] | sum(1)
 [add] | sum(1.0)
+[add][i:]
 [all($env, ok)]
 [all($env, true)]
+[all(array, false)]
 [all(list, ok)]
 [any(list, false)]
 [array != $env]
 [array != array]
+[array != list]
 [array != nil]
 [array == $env]
+[array == array]
+[array == list]
+[array == nil]
+[array ?? 1.0]
+[array ?? f64]
+[array ?? false]
+[array ?? foo]
+[array ?? greet]
+[array ?? true]
+[array | all(ok)]
+[array | findIndex(ok)]
 [array | findLast(false)]
 [array | groupBy(#)]
+[array | groupBy(foo)]
 [array | map(#)]
+[array | map($env)]
+[array | map(0)]
 [array | map(1)]
 [array | map(1.0)]
+[array | map(add)]
+[array | map(foo)]
+[array | map(i)]
 [array | map(ok)]
+[array | mean(1.0)]
 [array | one(false)]
 [array | one(true)]
 [array | reduce(#)]
 [array | reduce(#, false)]
 [array | reduce(#index)]
+[array | reduce($env)]
 [array | reduce(0)]
+[array | reduce(1.0)]
 [array | reduce(add)]
+[array | reduce(array)]
 [array | reduce(f64)]
+[array | reduce(false)]
+[array | reduce(foo)]
 [array | reduce(foo, true)]
 [array | reduce(ok)]
 [array | sortBy(#)]
+[array | sortBy(1)]
 [array | sortBy(1.0)]
 [array | sortBy(f64)]
 [array | sum(#), foo]
+[array | sum(#)]
 [array | sum(1)]
+[array | sum(1.0)]
+[array | sum(i)]
+[array, !ok]
+[array, !true]
 [array, $env.array]
 [array, $env?.[Bar]]
 [array, 0 == $env]
+[array, 1.0 == 1]
 [array, 1.0]?.[i]
+[array, 1] | findIndex(ok)
+[array, add, add]
 [array, add]
 [array, array]
+[array, array]?.[i]
 [array, f64]
 [array, f64] | findIndex(ok)
 [array, f64] | reduce(str)
 [array, f64]?.[i]
 [array, false, ok] | findLastIndex(#)
+[array, false] | sum(f64)
 [array, foo]
+[array, foo]?.[i]
 [array, greet]
+[array, greet] | reduce(foo)
 [array, i]
 [array, i]?.[i]
+[array, len($env)]
 [array, list]
+[array, nil] | map(#)
 [array, nil] | sum(0)
 [array, ok]
+[array, ok] | filter(false)
 [array, ok] | reduce(true)
 [array, ok]?.[i]
 [array, str, ok]
 [array, str]
+[array, str] | reduce(1.0)
+[array, true] ?? $env?.[str]
+[array, {foo: list}]
+[array?.[1]]
 [array?.[i]]
+[array[:1]]
 [array[i:]]
 [array]
+[array] ?? add
+[array] ?? f64
+[array] ?? ok
+[array] | all(false)
+[array] | any(false)
+[array] | count(false)
+[array] | count(ok)
+[array] | find(true)
+[array] | findLastIndex(true)
+[array] | groupBy(ok)
 [array] | map(#)
+[array] | map($env)
+[array] | map(1.0)
+[array] | map(greet)
+[array] | map(ok)
+[array] | map(str)
+[array] | mean(i)
 [array] | reduce(#)
 [array] | reduce(#, 1.0)
+[array] | reduce($env)
+[array] | reduce($env, 1.0)
 [array] | reduce(0)
 [array] | reduce(1.0)
+[array] | reduce(ok)
 [array] | sortBy(#)
+[array] | sortBy($env)
 [array] | sortBy(i)
 [array] | sum(0)
+[array] | sum(1)
 [array] | sum(1.0)
 [array][:i]
 [bitnot(0)]
 [bitnot(1)]
 [bitnot(i)]
 [ceil(0)]
+[ceil(1)]
 [ceil(1.0)]
+[ceil(f64), add]
 [ceil(f64)]
 [ceil(i)]
+[concat(array), i]
 [concat(array)]
 [concat(list)]
 [count($env, false)]
 [count(list, false)]
+[f64 != $env]
 [f64 != 0]
 [f64 != 1.0]
+[f64 != i]
 [f64 != nil]
+[f64 * 1.0]
 [f64 * 1]
 [f64 * f64]
 [f64 * i]
 [f64 ** 0]
+[f64 ** 1.0]
 [f64 ** 1]
 [f64 ** i]
 [f64 + 1.0]
+[f64 - 0]
 [f64 - 1]
+[f64 - f64]
+[f64 / 1.0]
 [f64 / 1]
 [f64 / f64]
 [f64 < 0]
 [f64 < 1.0]
+[f64 < 1]
 [f64 < f64]
 [f64 < i]
+[f64 <= 1.0]
+[f64 <= 1]
 [f64 <= f64]
 [f64 == $env]
 [f64 == 0]
+[f64 == 1.0]
+[f64 == 1]
 [f64 == f64]
 [f64 == i]
 [f64 == nil]
 [f64 > 1.0]
 [f64 > f64]
+[f64 > i]
 [f64 >= 0]
 [f64 >= 1.0]
+[f64 >= i]
+[f64 ?? $env]
+[f64 ?? array]
+[f64 ?? foo]
+[f64 ?? greet]
+[f64 ?? nil]
+[f64 ^ 0]
 [f64 ^ 1]
+[f64 ^ f64]
 [f64 not in array]
 [f64 | median(1.0)]
 [f64, $env == 1.0]
 [f64, $env.add]
+[f64, $env.foo]
 [f64, $env.list]
 [f64, $env?.String]
+[f64, $env] | map(ok)
 [f64, 1.0 ^ i]
 [f64, 1.0] | map(0)
+[f64, abs(f64)]
 [f64, add]
 [f64, array]
 [f64, f64]
 [f64, foo]
 [f64, foo] | reduce(#)
+[f64, foo]?.[i]
 [f64, greet]
+[f64, i ?? 1]
 [f64, i]
+[f64, i] | findLast(false)
+[f64, i] | groupBy(1)
 [f64, i] | take(i)
 [f64, list]
 [f64, nil != foo]
 [f64, nil]?.[i]
+[f64, not true]
 [f64, ok]
 [f64, str]
 [f64, str] | findLast(ok)
 [f64, {foo: 0}]
 [f64]
+[f64] | count(ok)
+[f64] | findLast(ok)
+[f64] | findLast(true)
+[f64] | groupBy(#)
+[f64] | groupBy(str)
 [f64] | map(#)
+[f64] | map(#index)
+[f64] | map(1)
 [f64] | map(1.0)
+[f64] | map(add)
 [f64] | map(false)
 [f64] | map(foo)
 [f64] | map(greet)
+[f64] | none(false)
+[f64] | reduce(#)
 [f64] | reduce(1)
 [f64] | reduce(1.0)
 [f64] | reduce(f64)
 [f64] | reduce(false)
 [f64] | reduce(greet, true)
+[f64] | reduce(true, foo)
 [f64] | sortBy($env)
 [f64] | sortBy(0)
+[f64] | sortBy(add)
 [f64] | sum(#)
 [f64] | sum(1.0)
+[f64] | sum(i)
 [f64][:]
 [false != $env]
 [false != false]
@@ -4509,37 +9497,84 @@ $env[$env:] - f64 and false
 [false == ok]
 [false == true]
 [false ? 1.0 : foo]
+[false ? foo : 1.0]
 [false ?: 1.0]
 [false ?: foo]
+[false ?? $env]
+[false ?? 0, greet]
+[false ?? 0]
+[false ?? 1.0]
+[false ?? false, greet]
+[false ?? false]
+[false ?? foo]
+[false ?? greet]
+[false ?? nil]
+[false ?? ok]
+[false ?? true]
 [false and $env]
 [false and ok]
 [false and true]
 [false or $env]
 [false or false]
+[false or true]
+[false || $env?.[Bar]]
 [false || $env]
 [false || false, list]
+[false || ok]
+[false || true]
 [false, $env] | findIndex(true)
 [false, $env] | groupBy(1.0)
+[false, $env]?.[i]
+[false, 0] | map(#)
+[false, 1.0]?.[i]
 [false, 1] != nil ? 1.0 : $env[add(false) == greet():]
+[false, 1] | groupBy(#)
 [false, 1]?.[i]
+[false, add] | all(false)
 [false, array] | reduce(0)
 [false, f64]?.[i]
+[false, foo]?.[i]
 [false, greet]?.[i]
+[false, i] | map(#)
+[false, i]?.[i]
 [false, str] | groupBy(foo)
+[false, true]?.[i]
 [false] == $env?.Bar
+[false] ?? f64
+[false] ?? foo
 [false] | all(#)
+[false] | all(true)
+[false] | any(#)
 [false] | count(false)
 [false] | find(#)
+[false] | findIndex(#)
 [false] | findLast(true)
+[false] | findLastIndex(#)
+[false] | findLastIndex(false)
 [false] | groupBy(#)
+[false] | groupBy(1.0)
+[false] | groupBy(foo)
 [false] | groupBy(i)
+[false] | map(#)
+[false] | map($env)
 [false] | map(foo)
 [false] | map(list)
 [false] | none(#)
+[false] | one(#)
+[false] | one(false)
 [false] | reduce(false, add)
+[false] | reduce(foo)
+[false] | reduce(greet)
 [false] | reduce(list, foo)
+[false] | reduce(true)
+[false] | sortBy(#)
+[false] | sortBy($env)
+[false] | sortBy(1.0)
+[false] | sortBy(array)
 [false] | sortBy(false)
 [false] | sortBy(true)
+[false] | sum(1)
+[false] | sum(1.0)
 [false][:]
 [false][i:]
 [filter($env, false)]
@@ -4549,6 +9584,7 @@ $env[$env:] - f64 and false
 [find(list, false)]
 [find(list, true)]
 [findIndex($env, true)]
+[findIndex(array, false)]
 [findIndex(list, ok)]
 [findIndex(list, true)]
 [findLast(array, true)]
@@ -4558,12 +9594,14 @@ $env[$env:] - f64 and false
 [findLastIndex(list, true)]
 [first($env)]
 [first(array)]
+[first(list), string(foo)]
 [first(list)]
 [flatten(array)]
 [flatten(list)]
 [float(0)]
 [float(1)]
 [float(1.0)]
+[float(f64), ok]
 [float(f64)]
 [float(i)]
 [floor(0)]
@@ -4572,6 +9610,7 @@ $env[$env:] - f64 and false
 [floor(1.0)]
 [floor(f64)]
 [floor(i)]
+[foo != $env.foo]
 [foo != $env]
 [foo != foo, add]
 [foo != foo]
@@ -4580,14 +9619,42 @@ $env[$env:] - f64 and false
 [foo == $env]
 [foo == foo]
 [foo == nil]
+[foo ?? $env?.String()]
+[foo ?? $env]
+[foo ?? 0]
+[foo ?? 1.0]
+[foo ?? 1]
+[foo ?? add]
+[foo ?? array]
+[foo ?? f64]
+[foo ?? false]
+[foo ?? foo]
+[foo ?? i]
+[foo ?? list]
+[foo ?? str]
+[foo ?? true]
+[foo in list]
 [foo not in list]
+[foo, $env?.[str]]
+[foo, $env?.f64]
+[foo, $env?.false]
+[foo, $env?.ok]
+[foo, $env] | find(ok)
 [foo, $env] | map(1.0)
+[foo, $env] | sortBy(f64)
 [foo, $env]?.[i]
+[foo, -f64]
+[foo, 0] | groupBy(1.0)
+[foo, 0] | map(#)
 [foo, 1.0, $env]?.[i]
 [foo, 1.0] | groupBy(1)
+[foo, 1.0] | map(foo)
 [foo, 1.0] | one(ok)
 [foo, 1.0]?.[i]
+[foo, 1] | map(list)
 [foo, 1]?.[i]
+[foo, 1]?.[i] != greet
+[foo, abs(1.0)]
 [foo, add, $env] | findLastIndex(ok)
 [foo, add, f64]
 [foo, add]
@@ -4595,166 +9662,312 @@ $env[$env:] - f64 and false
 [foo, array]
 [foo, array] | reduce(i)
 [foo, array]?.[i]
+[foo, f64, greet] | sortBy(1.0)
 [foo, f64]
 [foo, f64] | count(false)
+[foo, f64]?.[i]
+[foo, false, add] | none(true)
 [foo, false] | map(#)
 [foo, false]?.[i]
 [foo, foo != $env]
+[foo, foo.String]
 [foo, foo]
+[foo, foo] != list
+[foo, foo] | groupBy(1.0)
 [foo, foo] | reduce(1.0)
 [foo, foo]?.[i]
 [foo, greet(str)]
 [foo, greet]
+[foo, i, greet]
 [foo, i]
 [foo, i]?.[i]
+[foo, int(0)]
+[foo, list, foo] | reduce(list)
 [foo, list]
+[foo, list] != array
+[foo, list] | groupBy(f64)
 [foo, list]?.[i]
 [foo, mean(1)]
+[foo, nil != str]
 [foo, nil, list] | map(#)
+[foo, nil] | map(0)
 [foo, nil]?.[i]
 [foo, ok]
+[foo, ok] | all(true)
+[foo, round(1)]
 [foo, str]
+[foo, str] ?? f64
+[foo, str]?.[i]
 [foo, true]?.[i]
 [foo, values($env)]
+[foo.Bar, [foo]]
+[foo.Bar, greet]
 [foo.Bar, ok]
 [foo.Bar]
 [foo.String()]
 [foo.String, f64]
+[foo.String, list]
 [foo.String]
 [foo?.Bar]
+[foo?.String(), ok]
 [foo?.String()]
 [foo?.String, $env?.String]
 [foo?.String]
 [foo]
+[foo] != array
+[foo] == $env?.[Bar]
+[foo] ?? add
+[foo] ?? array
+[foo] ?? greet
+[foo] ?? list
+[foo] ?? ok
 [foo] in [nil]
 [foo] | all(ok)
 [foo] | all(true)
 [foo] | any(ok)
+[foo] | any(true)
 [foo] | count(false)
+[foo] | count(ok)
+[foo] | count(true)
 [foo] | filter(ok)
 [foo] | filter(true)
+[foo] | find(false)
 [foo] | find(ok)
 [foo] | findLast(false)
 [foo] | findLastIndex(ok)
 [foo] | groupBy(#)
 [foo] | groupBy(#.Bar)
+[foo] | groupBy(f64)
+[foo] | groupBy(false)
 [foo] | groupBy(foo)
+[foo] | groupBy(ok)
 [foo] | map(#)
 [foo] | map(.String)
+[foo] | map(1)
+[foo] | map(add)
+[foo] | map(f64)
+[foo] | map(foo)
 [foo] | map(i)
 [foo] | map(list)
 [foo] | map(ok)
+[foo] | none(!true)
+[foo] | none(ok)
 [foo] | none(true)
+[foo] | one(false)
+[foo] | one(ok)
 [foo] | reduce(#)
 [foo] | reduce(#, ok)
+[foo] | reduce(#.String, 0)
 [foo] | reduce(#index)
 [foo] | reduce(.Bar, 0)
+[foo] | reduce(.Bar, nil)
 [foo] | reduce(0)
 [foo] | reduce(1)
+[foo] | reduce(1, 1.0)
 [foo] | reduce(1.0)
+[foo] | reduce(1.0, foo)
+[foo] | reduce(add)
+[foo] | reduce(array)
+[foo] | reduce(false)
 [foo] | reduce(foo)
 [foo] | reduce(foo, list)
 [foo] | reduce(greet)
+[foo] | reduce(i, 0)
+[foo] | reduce(list)
+[foo] | reduce(ok)
+[foo] | reduce(true)
 [foo] | sortBy(#)
 [foo] | sortBy(#.String)
+[foo] | sortBy($env)
 [foo] | sortBy(.Bar)
+[foo] | sortBy(1)
 [foo] | sortBy(add)
+[foo] | sortBy(f64)
+[foo] | sortBy(false)
 [foo] | sortBy(greet)
 [foo] | sortBy(i)
 [foo] | sortBy(str)
 [foo] | sum(i)
 [foo][:]
+[foo][:i]
 [get($env, nil)]
 [get($env, str)]
+[greet != $env]
 [greet != nil]
 [greet == $env]
 [greet == nil, array]
 [greet == nil]
+[greet ?? 1.0, list]
+[greet ?? 1]
+[greet ?? f64]
+[greet ?? foo, foo]
+[greet ?? foo]
+[greet ?? i]
 [greet(str), array]
+[greet(str), greet]
 [greet(str)]
 [greet, $env.array]
 [greet, $env.greet]
+[greet, $env.i]
+[greet, $env?.greet]
+[greet, $env?.nil]
+[greet, $env] | none(false)
+[greet, $env] | reduce(true)
+[greet, $env]?.[i]
+[greet, -i]
+[greet, 0]?.[i]
 [greet, 1.0]?.[i]
 [greet, [array]]
 [greet, abs(1.0)]
 [greet, add]
 [greet, add] | reduce($env)
 [greet, array]
+[greet, array] | map(i)
 [greet, f64]
+[greet, f64] | reduce(f64)
 [greet, foo == $env]
+[greet, foo ?? $env]
 [greet, foo]
 [greet, foo] | none(true)
 [greet, foo]?.[i]
 [greet, greet]
+[greet, greet] | reduce(#)
 [greet, i]
+[greet, int(1)]
 [greet, list]
+[greet, list] | reduce(add)
 [greet, nil]?.[i]
 [greet, ok]
+[greet, str, f64]
 [greet, str]
 [greet, true]?.[i]
 [greet]
+[greet] == $env.array
+[greet] ?? add
+[greet] ?? array
+[greet] ?? false ?? i
+[greet] ?? i
+[greet] ?? list
+[greet] ?? median(1.0)
+[greet] ?? str
+[greet] | all(ok)
 [greet] | any(false)
 [greet] | count(false)
+[greet] | find(false)
+[greet] | find(ok)
 [greet] | groupBy(1)
 [greet] | groupBy(foo)
 [greet] | groupBy(true)
 [greet] | map($env)
+[greet] | map(1)
+[greet] | map(add)
 [greet] | map(i)
 [greet] | map(str)
 [greet] | reduce(#, array)
+[greet] | reduce(false, nil)
+[greet] | reduce(foo, $env)
 [greet] | reduce(greet)
 [greet] | reduce(ok)
+[greet] | sortBy(#)
+[greet] | sortBy(array)
+[greet] | sortBy(i)
+[greet] | sortBy(str)
 [greet] | sum(f64)
 [greet][:i]
+[greet][i:]
 [groupBy(array, #)]
+[groupBy(array, foo)]
+[groupBy(list, #)?.[foo]]
 [groupBy(list, #)]
 [groupBy(list, 1.0)?.[i]]
+[groupBy(list, f64)]
 [groupBy(list, false)]
 [groupBy(list, foo)]
 [i != $env]
+[i != 0, str]
 [i != 0]
 [i != 1.0]
 [i != 1]
 [i != f64]
+[i != i]
+[i != nil]
 [i % 1]
 [i % i]
 [i * 0]
+[i * 1.0]
 [i * 1]
+[i * i]
 [i ** 0]
 [i ** 1.0]
+[i ** 1]
+[i ** f64]
 [i + 1.0]
+[i + 1]
+[i + f64]
+[i - 1.0]
+[i - 1]
 [i - f64]
+[i .. 0]
 [i .. i]
+[i / 1.0 ?? $env]
+[i / 1.0]
 [i / 1]
 [i < 1.0]
+[i < 1]
 [i <= 1.0]
 [i <= 1]
+[i <= f64]
 [i == $env]
 [i == 0]
+[i == 1.0]
 [i == 1]
 [i == f64]
 [i == nil]
+[i > 1.0]
 [i > f64]
+[i >= 1.0]
 [i >= 1]
+[i >= f64]
+[i ?? $env]
+[i ?? array]
+[i ?? f64]
+[i ?? false]
+[i ?? foo]
+[i ?? true]
 [i ^ 1.0]
 [i ^ 1]
 [i | max(array, i)]
+[i | min(0)]
+[i, $env in list]
 [i, $env?.String]
+[i, $env?.[String]]
 [i, $env?.foobar]
+[i, -1.0]
+[i, 1.0 >= 1.0]
+[i, 1.0] | sortBy(1)
+[i, 1.0] | sum(#)
 [i, 1.0]?.[i]
+[i, 1]?.[i]
 [i, add]
+[i, array?.[i]]
 [i, array]
 [i, f64 > i]
+[i, f64 ?? str]
 [i, f64]
 [i, f64] != array
 [i, foo?.String]
 [i, foo]
+[i, foo] | groupBy(1.0)
 [i, greet]
 [i, i]
 [i, list]
+[i, nil ?? 1.0]
 [i, nil in $env]
+[i, nil] | filter(true)
 [i, nil] | groupBy(1.0)
+[i, nil]?.[i]
 [i, ok]
+[i, ok]?.[i]
 [i, str]
 [i, sum(array)]
 [i, toJSON(0)]
@@ -4764,34 +9977,65 @@ $env[$env:] - f64 and false
 [i] != list
 [i] == array
 [i] == list
+[i] ?? $env?.[foo]
+[i] ?? f64
+[i] ?? greet
+[i] ?? i
+[i] ?? ok
 [i] | any(ok)
 [i] | find(false)
+[i] | findLast(ok)
+[i] | findLast(true)
 [i] | groupBy(1)
 [i] | groupBy(1.0)
+[i] | groupBy(foo)
+[i] | groupBy(ok)
 [i] | map(#)
+[i] | map(add)
 [i] | map(false)
 [i] | reduce(add, i)
+[i] | reduce(f64)
+[i] | reduce(foo)
+[i] | reduce(ok, nil)
+[i] | reduce(ok, true)
 [i] | reduce(str)
+[i] | reduce(str, str)
 [i] | sortBy(#)
 [i] | sortBy($env)
+[i] | sortBy(0)
 [i] | sortBy(1.0)
+[i] | sortBy(greet)
+[i] | sortBy(list)
+[i] | sortBy(str)
+[i] | sortBy(true)
 [i] | sum(#)
+[i] | sum(1.0)
+[i] | sum(f64)
+[i][i:]
 [if false { $env } else { 1.0 }]
 [if false { $env } else { greet }]
 [if false { 1.0 } else { true }]
 [if false { foo } else { 1 }]
 [if false { foo } else { true }]
+[if false { nil } else { $env }]
+[if false { true } else { false }]
 [if ok { 1.0 } else { foo }]
 [if ok { false } else { 1.0 }]
+[if ok { foo } else { $env }]
+[if ok { greet } else { nil }]
 [if ok { nil } else { nil }]
 [if ok { true } else { 1.0 }, $env.f64]
+[if true { $env } else { false }, list]
 [if true { 0 } else { ok }]
 [if true { 1 } else { 0 }]
 [if true { f64 } else { 1 }]
 [if true { foo } else { 1 }]
 [if true { foo } else { add }]
+[if true { foo } else { nil }]
 [if true { foo } else { ok }]
+[if true { nil } else { 1 }]
 [if true { nil } else { array }]
+[int(0), ok]
 [int(0)]
 [int(1)]
 [int(1.0)]
@@ -4800,37 +10044,71 @@ $env[$env:] - f64 and false
 [int(i)]
 [keys($env)]
 [last($env)]
+[last($env?.list)]
 [last(array)]
+[last(list), array]
 [last(list)]
 [len($env)]
+[len([nil, list])]
+[len(array), str]
 [len(array)]
 [len(list)]
 [len(str)]
 [len({foo: list})]
+[let foobar = $env; foobar]
 [let foobar = 1.0; foobar]
+[let z = 1.0; 0 + z]
+[list != $env]
+[list != array]
 [list != list]
 [list != nil]
+[list == $env]
+[list == nil]
+[list ?? 1.0]
+[list ?? add]
+[list ?? array]
+[list ?? foo]
+[list ?? greet]
+[list ?? i]
+[list ?? nil]
+[list ?? ok]
+[list | all(true)]
+[list | any(ok)]
+[list | find(false)]
 [list | findLast(false)]
 [list | groupBy(#)]
 [list | groupBy(1.0)]
 [list | groupBy(f64)]
+[list | groupBy(i)]
+[list | groupBy(str)]
 [list | map(#)]
 [list | map(foo)]
+[list | map(i), i]
 [list | reduce(#)]
 [list | reduce(#, 0)]
+[list | reduce(#, i)]
+[list | reduce(#, nil)]
 [list | reduce(#.String)]
+[list | reduce(#acc)]
+[list | reduce(#index)]
 [list | reduce(#index, greet)]
 [list | reduce($env)]
 [list | reduce($env, foo)]
+[list | reduce(1.0)]
 [list | reduce(1.0, greet)]
 [list | reduce(array)]
 [list | reduce(foo)]
 [list | reduce(i)]
+[list | reduce(list)]
+[list | sortBy(.Bar)]
 [list | sortBy(1)]
 [list | sortBy(1.0)]
+[list, $env, 1.0] | filter(ok)
 [list, $env.foo]
+[list, $env.i]
 [list, $env?.String]
 [list, $env?.list]
+[list, $env] | one(false)
 [list, 0 * i]
 [list, 0 ^ 1.0]
 [list, 0] | find(false)
@@ -4840,97 +10118,151 @@ $env[$env:] - f64 and false
 [list, add] | map(#)
 [list, add]?.[i]
 [list, array]
+[list, f64, ok]
 [list, f64]
 [list, f64]?.[i]
 [list, false, 1] | reduce(foo)
+[list, foo.String()]
 [list, foo]
 [list, foo] | groupBy(foo)
+[list, foo] | sum(1)
+[list, foo]?.[i]
 [list, greet]
+[list, greet] | map(#)
 [list, i ^ 1.0]
+[list, i, greet]
 [list, i]
 [list, list]
+[list, nil] | groupBy(foo)
 [list, ok]
+[list, ok]?.[i]
+[list, round(i)]
 [list, str, str]
 [list, str]
 [list, toJSON(nil)]
 [list, true != $env]
+[list, true] | reduce(f64)
+[list, true] | reduce(foo, ok)
 [list?.[0]]
+[list?.[i], add]
 [list?.[i]]
+[list[:1]]
+[list[i:]]
 [list]
 [list] != list
+[list] == $env?.String
 [list] == array
 [list] | filter(ok)
 [list] | findIndex(ok)
 [list] | findLast(false)
+[list] | findLastIndex(ok)
+[list] | get(i)
 [list] | groupBy($env.foo)
+[list] | map(#)
+[list] | map(1.0)
 [list] | map(add)
 [list] | map(i)
+[list] | map(ok)
 [list] | map(true)
 [list] | none(ok)
 [list] | one(true)
 [list] | reduce(1)
 [list] | reduce(foo)
 [list] | reduce(foo, false)
+[list] | reduce(foo, ok)
 [list] | sortBy(#)
 [list] | sortBy(add)
+[list] | sortBy(false)
 [list] | sortBy(foo)
 [list] | sortBy(i)
 [list] | sortBy(str)
+[list] | sum(1.0)
 [lower(str)]
+[map($env, #index)]
 [map($env, $env)]
+[map($env, 1.0)]
+[map($env, array)]
+[map($env, foo)]
+[map($env, greet)]
 [map($env, list)]
 [map($env, str)]
 [map(array, #)]
 [map(array, $env)]
 [map(array, 1)]
 [map(array, 1.0), foo]
+[map(array, 1.0)]
+[map(array, array)]
+[map(array, f64)]
 [map(array, false)]
+[map(array, foo)]
 [map(array, str), ok]
 [map(array, str)]
+[map(array, true)]
 [map(list, #)]
+[map(list, #index)]
 [map(list, $env)]
 [map(list, 0)]
+[map(list, f64)]
+[map(list, foo)]
+[map(list, list)]
 [map(list, ok)]
 [map(list, str)]
 [max($env), f64]
 [max($env)]
 [max(0)]
+[max(0, 1.0)]
+[max(1)]
 [max(1.0)]
+[max(1.0, 1)]
 [max(array) ^ f64]
 [max(array)]
 [max(array, 1.0)]
 [max(f64)]
+[max(i)]
 [mean(0)]
 [mean(1)]
+[mean(1, 1.0)]
 [mean(1.0)]
 [mean(array)]
 [mean(f64)]
 [mean(i)]
 [median(0)]
 [median(1)]
+[median(1, 1.0)]
 [median(1.0)]
+[median(1.0, 1.0)]
 [median(array)]
 [median(f64)]
 [median(floor(0))]
 [median(i)]
+[min($env ?? foo)]
 [min($env)]
 [min(0)]
 [min(1)]
 [min(1.0)]
 [min(array)]
 [min(f64)]
+[min(i)]
+[nil != $env?.f64]
 [nil != $env]
 [nil != 0]
 [nil != 1.0]
+[nil != add]
+[nil != array]
 [nil != f64]
+[nil != foo, greet]
 [nil != foo]
 [nil != greet]
+[nil != i]
+[nil != list, add]
 [nil != list]
+[nil != nil, ok]
 [nil != nil]
 [nil != ok]
 [nil != str]
 [nil != true]
 [nil == $env, foo]
+[nil == $env]
 [nil == 0]
 [nil == 1.0]
 [nil == add]
@@ -4940,65 +10272,136 @@ $env[$env:] - f64 and false
 [nil == false]
 [nil == foo]
 [nil == greet]
+[nil == list, f64]
 [nil == list]
 [nil == nil]
 [nil == ok]
 [nil == str]
 [nil == true]
+[nil ?? $env]
+[nil ?? 1]
+[nil ?? add]
+[nil ?? false]
+[nil ?? foo, greet]
+[nil ?? foo]
+[nil ?? greet]
+[nil ?? list]
+[nil ?? nil]
+[nil ?? str]
 [nil in $env]
 [nil in list]
 [nil not in $env]
+[nil not in array]
 [nil not in list]
+[nil, $env] | reduce(0)
+[nil, $env]?.[i]
+[nil, 0] | reduce(i, greet)
 [nil, 0]?.[i]
+[nil, 1.0, 0] | all(true)
+[nil, 1.0] ?? add
 [nil, 1.0] | none(true)
 [nil, 1.0] | reduce(#)
+[nil, 1.0] | sum(f64)
 [nil, 1.0]?.[i]
 [nil, 1]?.[i]
 [nil, add] | none(false)
 [nil, add]?.[i]
 [nil, f64] | groupBy(str)
+[nil, false] | map($env)
 [nil, foo] | findLast(ok)
+[nil, foo] | map(ok)
 [nil, foo]?.[i]
+[nil, i] | filter(true)
+[nil, i]?.[i]
 [nil, nil, $env]?.[i]
 [nil, nil, array]?.[i]
 [nil, str, 1.0] | map(#)
 [nil, true]?.[i]
+[nil] == array
 [nil] == list
+[nil] == nil ? 1 : foo
+[nil] ?? i
+[nil] ?? ok
 [nil] | count(ok)
+[nil] | count(true)
+[nil] | filter(false)
+[nil] | filter(ok)
+[nil] | find(false)
+[nil] | find(true)
 [nil] | findIndex(true)
 [nil] | findLast(false)
+[nil] | findLastIndex(false)
+[nil] | findLastIndex(true)
 [nil] | groupBy(0)
+[nil] | groupBy(1)
 [nil] | groupBy(str)
+[nil] | groupBy(string(nil))
+[nil] | groupBy(true)
+[nil] | map($env)
 [nil] | map(1.0)
 [nil] | map(f64)
+[nil] | map(foo)
+[nil] | map(greet)
+[nil] | map(i)
+[nil] | map(true)
 [nil] | one(ok)
+[nil] | reduce(#index)
 [nil] | reduce(0)
 [nil] | reduce(array)
 [nil] | reduce(array, array)
 [nil] | reduce(false)
+[nil] | reduce(foo)
 [nil] | reduce(i)
 [nil] | reduce(ok)
 [nil] | reduce(true)
+[nil] | sortBy($env)
 [nil] | sortBy(0)
 [nil] | sortBy(false)
 [nil] | sortBy(foo)
 [nil] | sortBy(true)
 [nil] | sum(1)
 [nil] | sum(1.0)
+[nil] | sum(i)
+[nil][:]
+[nil][i:]
+[none($env, false)]
 [none($env, true)]
 [none(array, false)]
+[not false, add]
+[not false]
+[not ok]
+[not ok] != array
+[not true]
 [ok != $env]
 [ok != nil]
+[ok != true]
+[ok && $env]
+[ok && false, foo?.Bar]
 [ok && ok]
+[ok && true]
 [ok == $env]
 [ok == false]
 [ok == nil]
 [ok == true]
+[ok ? 0 : false]
 [ok ? 1 : greet]
 [ok ? str : i, add]
 [ok ?: 0]
+[ok ?: nil]
+[ok ?? $env]
+[ok ?? 0]
+[ok ?? 1.0]
+[ok ?? add]
+[ok ?? array]
+[ok ?? foo]
+[ok ?? greet]
+[ok ?? nil, $env in array]
+[ok ?? nil]
+[ok ?? true]
 [ok and $env]
+[ok and false]
 [ok and ok, ok]
+[ok and ok]
 [ok and true]
 [ok or $env]
 [ok or false]
@@ -5006,20 +10409,31 @@ $env[$env:] - f64 and false
 [ok or true]
 [ok || $env]
 [ok || false]
+[ok, $env.greet]
+[ok, $env?.[foobar]]
 [ok, $env?.[str]]
+[ok, $env?.i]
 [ok, $env?.str]
 [ok, $env] | find(#)
 [ok, $env] | map(false)
+[ok, $env]?.[i]
+[ok, 0]?.[i]
+[ok, 1 / 0]
 [ok, 1.0 == 1.0]
+[ok, 1] == array
+[ok, 1] | groupBy(#)
 [ok, 1] | map(1.0)
 [ok, add]
 [ok, array]
 [ok, array]?.[i]
 [ok, f64]
+[ok, false] not in uniq(list)
+[ok, false] | map(foo)
 [ok, floor(0)]
 [ok, foo not in list]
 [ok, foo?.String]
 [ok, foo]
+[ok, foo] | any(#)
 [ok, foo] | map(f64)
 [ok, foo]?.[i]
 [ok, greet]
@@ -5028,37 +10442,78 @@ $env[$env:] - f64 and false
 [ok, list]
 [ok, list] | findIndex(false)
 [ok, list]?.[i]
+[ok, nil == 1.0]
 [ok, nil] | find(#)
+[ok, nil]?.[i]
 [ok, ok]
+[ok, ok]?.[i]
 [ok, reduce(list, str)]
 [ok, str]
 [ok, str] | reduce(foo)
 [ok, string(add)]
 [ok]
+[ok] != $env?.list
 [ok] != array
+[ok] != list
+[ok] == nil and ok
+[ok] ?? f64
+[ok] ?? foo
 [ok] | all(#)
 [ok] | any(#)
 [ok] | count(#)
+[ok] | filter(#)
+[ok] | findIndex(#)
+[ok] | findLast(#)
 [ok] | findLast(false)
+[ok] | groupBy(#)
+[ok] | groupBy(1)
+[ok] | groupBy(foo)
+[ok] | groupBy(true)
+[ok] | map(#)
+[ok] | map(0)
+[ok] | map(str)
+[ok] | none(#)
+[ok] | none(false)
+[ok] | one(#)
+[ok] | reduce($env)
 [ok] | reduce(1.0)
 [ok] | reduce(foo)
+[ok] | reduce(string(greet))
+[ok] | sortBy(#)
+[ok] | sortBy($env)
+[ok] | sortBy(array)
 [ok] | sortBy(f64)
+[ok] | sortBy(foo)
+[ok] | sortBy(greet)
+[ok] | sortBy(str)
+[ok] | sum(1.0)
 [ok] | sum(f64)
 [one($env, false)]
 [one($env, ok)]
+[one(array, ok)]
+[one(list, true)]
 [reduce(array, #)]
+[reduce(array, $env), add]
 [reduce(array, $env)]
 [reduce(array, $env, f64)]
+[reduce(array, 1.0)]
+[reduce(array, add)]
 [reduce(array, array)]
 [reduce(array, false)]
 [reduce(array, foo)]
+[reduce(array, i)]
 [reduce(array, true)]
+[reduce(list, #.String)]
 [reduce(list, .String)]
 [reduce(list, add)]
+[reduce(list, f64)]
 [reduce(list, foo)]
+[reduce(list, greet)]
 [reduce(list, i)]
 [reduce(list, list)]
 [reverse(array)]
+[reverse(list)]
+[round(0), ok]
 [round(0)]
 [round(1)]
 [round(1.0)]
@@ -5067,25 +10522,56 @@ $env[$env:] - f64 and false
 [sort($env)?.[i], foo]
 [sort($env)]
 [sort(array)]
+[sort(last($env)), list]
+[sortBy(array, #)]
 [sortBy(array, 1.0)]
 [sortBy(array, i)]
+[sortBy(list, .Bar)]
 [sortBy(list, 1)]
+[sortBy(list, 1.0)]
+[sortBy(list, i)]
 [str != nil]
 [str < str]
 [str <= str]
+[str == nil]
+[str >= str]
+[str ?? $env]
+[str ?? 1.0]
+[str ?? 1]
+[str ?? array]
+[str ?? f64]
+[str ?? false]
+[str ?? foo]
+[str ?? nil, ok]
+[str ?? str]
+[str ?? true]
 [str contains str]
 [str in $env]
+[str in foo, foo]
 [str in foo]
+[str matches str]
 [str not contains str]
+[str not endsWith str]
 [str not in $env]
 [str not in foo]
 [str not matches str]
 [str not startsWith str]
+[str startsWith str]
 [str | greet()]
+[str | splitAfter(str)]
 [str, $env == false]
+[str, $env ?? foo]
+[str, $env | count(true)]
+[str, $env.f64]
+[str, $env.str]
 [str, $env?.[Bar]]
+[str, $env?.[str]]
+[str, $env?.array]
+[str, $env?.nil]
 [str, $env?.ok]
+[str, $env] | map(add)
 [str, 0] | reduce(false, foo)
+[str, 1.0] | map(#)
 [str, 1]?.[i]
 [str, add]
 [str, array]
@@ -5096,130 +10582,240 @@ $env[$env:] - f64 and false
 [str, false]?.[i]
 [str, foo.Bar]
 [str, foo]
+[str, foo] | findIndex(ok)
+[str, foo] | map(greet)
 [str, greet]
+[str, i, array] | reduce(1.0)
 [str, i]
 [str, list | findLastIndex(true)]
 [str, list]
 [str, list] | any(false)
 [str, map(list, $env)]
+[str, nil in array]
+[str, nil] | map(str)
 [str, nil]?.[i]
+[str, ok, greet]
 [str, ok]
 [str, str, 0]?.[i]
 [str, str]
+[str, str]?.[i]
 [str[1:]]
+[str[:i]]
 [str]
 [str] == array
+[str] ?? f64
+[str] ?? i
+[str] ?? str
 [str] | all(false)
+[str] | all(ok)
 [str] | any(ok)
 [str] | count(true)
 [str] | filter(ok)
+[str] | find(false)
+[str] | findLast(ok)
 [str] | findLastIndex(false)
 [str] | groupBy(#)
+[str] | groupBy(false)
+[str] | map(1)
+[str] | map(false)
+[str] | map(foo)
+[str] | none(false)
 [str] | one(ok)
 [str] | one(true)
 [str] | reduce(#)
 [str] | reduce(#acc)
+[str] | reduce(1.0, ok)
 [str] | reduce(false)
+[str] | reduce(str, i)
+[str] | sortBy(#)
 [str] | sortBy($env)
 [str] | sortBy(1.0)
+[str] | sortBy(add)
+[str] | sortBy(array)
 [str] | sortBy(foo)
 [str] | sum(abs(0))
 [str][i:]
 [string($env)]
 [string($env.f64)]
+[string($env.greet)]
 [string(0)]
 [string(1)]
 [string(1.0)]
 [string(add)]
+[string(array), any(array, true)]
+[string(array), str]
 [string(array)]
 [string(f64)]
 [string(false)]
+[string(floor(0))]
 [string(foo), add]
+[string(foo), f64]
+[string(foo), foo]
 [string(foo)]
 [string(greet)]
 [string(i)]
 [string(list) not in $env?.foobar]
 [string(list)]
 [string(nil)]
+[string(str)]
+[string(true)]
+[sum($env, 1)]
+[sum($env.array)]
+[sum($env?.[str])]
+[sum([i])]
+[sum(array) - i]
+[sum(array), i]
 [sum(array)]
 [sum(array, #)]
 [sum(array, 1)]
+[sum(array, 1.0)]
+[sum(array, f64)]
 [sum(array, i)]
+[sum(list, 0)]
+[sum(list, 1.0)]
 [toBase64(str)]
 [toBase64(string(1.0))]
 [toJSON($env.foo)]
+[toJSON($env?.[String])]
 [toJSON(0)]
 [toJSON(1)]
 [toJSON(1.0)]
 [toJSON(array)]
+[toJSON(f64)]
 [toJSON(false), str]
 [toJSON(false)]
 [toJSON(foo)]
+[toJSON(foo?.Bar)]
 [toJSON(i)]
 [toJSON(list)]
 [toJSON(nil), foo.Bar]
 [toJSON(nil)]
+[toJSON(ok), array]
 [toJSON(ok)]
 [toJSON(true)]
 [toPairs($env)]
 [trim(str)]
 [trimPrefix(str)]
+[true != $env]
 [true != false]
 [true != nil]
 [true && $env, list]
 [true && $env]
 [true && false, array]
+[true && false]
+[true && true]
 [true == $env]
+[true == false]
 [true == nil]
+[true == true]
 [true ? $env : 1.0]
+[true ? f64 : foo]
+[true ? i : false, list]
 [true ?: 1]
 [true ?: array]
+[true ?: f64]
 [true ?: list]
+[true ?: ok]
+[true ?? $env?.i]
+[true ?? $env]
+[true ?? 0]
+[true ?? 1.0]
+[true ?? 1]
+[true ?? array, sum(array)]
+[true ?? f64]
+[true ?? foo]
+[true ?? list]
+[true ?? true]
 [true and $env]
+[true and false]
+[true and ok]
 [true and true]
 [true or true]
 [true || $env]
+[true || ok]
 [true || true]
+[true, $env] | groupBy(foo)
+[true, $env] | map(foo)
+[true, 0] | map(ok)
+[true, 1.0]?.[i]
 [true, 1] == $env?.array
+[true, 1] | any(ok)
+[true, add, foo] | findLastIndex(false)
 [true, add] | findLast(true)
 [true, add] | reduce(array, greet)
 [true, add]?.[i]
+[true, f64]?.[i]
+[true, false] == list
 [true, foo] | find(#)
+[true, foo] | groupBy(foo)
+[true, foo] | sum(1.0)
 [true, foo]?.[i]
 [true, list]?.[i]
+[true, nil, greet]?.[i]?.foo
+[true, nil] | none(#)
+[true, nil] | reduce(f64)
 [true, nil]?.[i]
 [true, ok] | find(true)
 [true, ok]?.[i]
+[true, str] ?? add
+[true, str] | groupBy(1.0)
+[true, str][i:]
 [true] != [array]
+[true] != array
+[true] ?? i
 [true] in $env?.foobar
 [true] | all(#)
+[true] | all(ok)
 [true] | any(#)
 [true] | any(false)
+[true] | count(#)
+[true] | filter(#)
 [true] | findIndex(#)
+[true] | findLastIndex(#)
 [true] | findLastIndex(false)
+[true] | groupBy(#)
+[true] | groupBy($env != $env)
 [true] | groupBy(1.0)
+[true] | groupBy(foo)
+[true] | groupBy(str)
+[true] | groupBy(true)
+[true] | map(#)
 [true] | map(1.0)
+[true] | map(true)
 [true] | none(true)
+[true] | one(#)
 [true] | one(false)
+[true] | reduce(#)
 [true] | reduce($env)
 [true] | reduce($env, str)
 [true] | reduce(1.0)
+[true] | reduce(true, $env)
 [true] | sortBy(#)
+[true] | sortBy($env)
+[true] | sortBy(0)
+[true] | sortBy(foo)
 [true] | sortBy(greet)
 [true] | sortBy(true)
 [true] | sum(1)
 [true] | sum(1.0)
+[true][:0 ?? str]
 [type($env)]
 [type(0)]
+[type(1)]
+[type(1.0), $env?.foo]
 [type(1.0)]
 [type(add)]
 [type(array)]
 [type(f64)]
+[type(false), str]
 [type(false)]
 [type(foo)]
 [type(greet)]
+[type(i)]
 [type(list), array]
 [type(list)]
+[type(nil)]
+[type(ok) not endsWith str, ok]
 [type(ok)]
 [type(str), foo]?.[i]
 [type(str)]
@@ -5228,59 +10824,101 @@ $env[$env:] - f64 and false
 [uniq(list)]
 [upper(str)]
 [values($env)]
+[{foo: $env, foo: 1.0, foo: 0}]
 [{foo: $env, foo: nil}]
 [{foo: $env}]
 [{foo: 0, foo: 1.0}]
 [{foo: 0, foo: nil}]
 [{foo: 0, foo: true}]
 [{foo: 0}]
+[{foo: 1.0, foo: 0}]
 [{foo: 1.0}.add]
+[{foo: 1.0}?.str]
 [{foo: 1.0}]
 [{foo: 1}]
 [{foo: add, foo: i}]
 [{foo: add, foo: str}]
 [{foo: add}]
+[{foo: array, foo: nil}]
 [{foo: array}]
+[{foo: f64, foo: foo}]
+[{foo: f64}?.f64]
 [{foo: f64}]
 [{foo: false, foo: 0}]
 [{foo: false}]
+[{foo: foo, foo: $env}.String]
 [{foo: foo, foo: false}]
+[{foo: foo, foo: nil}]
 [{foo: foo}]
 [{foo: greet, foo: f64, foo: 0}]
+[{foo: greet, foo: foo}]
 [{foo: greet}]
 [{foo: i, foo: $env}]
+[{foo: i, foo: greet, foo: foo}]
 [{foo: i}]
 [{foo: list, foo: foo}]
+[{foo: list}?.Bar]
 [{foo: list}]
 [{foo: nil, foo: 1.0}]
 [{foo: nil, foo: i}]
+[{foo: nil, foo: nil}]
 [{foo: nil, foo: str}]
 [{foo: nil}]
 [{foo: ok}?.foo]
 [{foo: ok}]
+[{foo: str, foo: true}]
 [{foo: str}]
 [{foo: true}]
+abs($env | count(ok))
 abs($env | count(true))
+abs($env | findLastIndex(ok))
 abs($env | sum(1))
 abs($env | sum(1.0))
 abs($env.f64)
 abs($env.i)
 abs($env?.f64)
 abs($env?.i)
+abs(-0)
+abs(-1)
+abs(-1.0)
+abs(-f64)
+abs(-i)
+abs(0 % i)
 abs(0 * 1.0)
+abs(0 ** 1.0)
 abs(0 ** f64)
+abs(0 ** i)
 abs(0 + 0)
 abs(0 + 1.0)
 abs(0 + i)
+abs(0 - 0)
+abs(0 - 1)
 abs(0 - 1.0)
 abs(0 - f64)
 abs(0 - i)
 abs(0 / 0)
+abs(0 / 1)
+abs(0 / 1.0)
+abs(0 / f64)
+abs(0 ?? 1)
+abs(0 ?? add)
+abs(0 ?? array)
+abs(0 ?? false)
+abs(0 ?? foo)
+abs(0 ?? i)
+abs(0 ?? nil)
 abs(0 ^ 1.0)
+abs(0 ^ i)
 abs(0 | mean(i, i))
+abs(0 | min(f64))
 abs(0) * f64
+abs(0) ** $env?.i
+abs(0) - f64
 abs(0) - i
 abs(0) / f64
+abs(0) ?? add
+abs(0) ?? array
+abs(0) ^ f64
 abs(0) in array
 abs(0.1)
 abs(1 % 1)
@@ -5290,42 +10928,75 @@ abs(1 ** 1)
 abs(1 ** 1.0)
 abs(1 ** f64)
 abs(1 + 0)
+abs(1 + 1.0)
 abs(1 - 1)
 abs(1 - 1.0)
 abs(1 - f64)
+abs(1 / 1)
+abs(1 / 1.0)
 abs(1 / i)
+abs(1 ?? 1.0)
+abs(1 ?? add)
+abs(1 ?? f64)
+abs(1 ?? false)
+abs(1 ?? foo)
+abs(1 ?? greet)
+abs(1 ?? i)
 abs(1 ^ 0)
 abs(1 ^ 1)
+abs(1 ^ f64)
 abs(1 ^ i)
+abs(1 | bitshr(i))
 abs(1 | max(array))
+abs(1) != i
+abs(1) * i
 abs(1) + f64
 abs(1) < f64
 abs(1) < i
+abs(1) <= nil ?? i
 abs(1) >= i
+abs(1) ?? array
+abs(1) ^ float(1.0)
+abs(1) not in $env?.foobar
 abs(1) | mean(i)
 abs(1.0 * 0)
 abs(1.0 * 1)
 abs(1.0 * 1.0)
+abs(1.0 * f64)
 abs(1.0 * i)
 abs(1.0 ** 0)
 abs(1.0 ** 1)
 abs(1.0 ** 1.0)
 abs(1.0 ** i)
+abs(1.0 + 0)
 abs(1.0 + 1)
 abs(1.0 + 1.0)
 abs(1.0 + f64)
+abs(1.0 + i)
 abs(1.0 - 1)
 abs(1.0 - 1.0)
+abs(1.0 - f64)
 abs(1.0 - i)
 abs(1.0 / 0)
 abs(1.0 / 1)
 abs(1.0 / 1.0)
+abs(1.0 ?? $env[count(foobar):findLast(str, .list)])
+abs(1.0 ?? 1)
+abs(1.0 ?? 1.0)
+abs(1.0 ?? f64)
+abs(1.0 ?? foo)
+abs(1.0 ?? list)
+abs(1.0 ?? nil)
+abs(1.0 ?? true)
 abs(1.0 ^ 0)
 abs(1.0 ^ 1)
 abs(1.0 ^ 1.0)
 abs(1.0 ^ f64)
 abs(1.0 ^ i)
 abs(1.0 | mean(array))
+abs(1.0 | min(f64))
+abs(1.0)
+abs(1.0) != $env?.[Bar]
 abs(1.0) != f64
 abs(1.0) * i
 abs(1.0) ** f64
@@ -5333,25 +11004,38 @@ abs(1.0) + count(list, false)
 abs(1.0) - f64
 abs(1.0) / 0 in array
 abs(1.0) / f64
+abs(1.0) < 1.0 ?? 1
 abs(1.0) <= reduce(array, #)
 abs(1.0) == i
+abs(1.0) > i
+abs(1.0) ?? f64
 abs(1.0) ^ f64 > 0
 abs(1.0) ^ i
 abs(1.0) in $env?.[String]
 abs(1.0) in array
+abs(1.0) | max(0)
+abs(1.0) | median(array)
+abs(1.1)
+abs(abs(1))
 abs(abs(1.0))
 abs(abs(f64))
+abs(abs(i))
+abs(abs(int(1.0)))
 abs(add(1, 1))
 abs(array | count(true))
 abs(array | find(ok))
 abs(array | findLast(true))
+abs(array | findLastIndex(ok))
 abs(array | reduce(#))
 abs(array | reduce(#acc))
 abs(array | reduce(#index))
 abs(array | reduce(0))
 abs(array | reduce(0, array))
+abs(array | reduce(1, nil))
 abs(array | reduce(1.0))
 abs(array | reduce(1.0, foo))
+abs(array | sum(1.0))
+abs(array?.[1])
 abs(array?.[i])
 abs(bitnot(0))
 abs(bitnot(1))
@@ -5359,6 +11043,9 @@ abs(bitnot(i))
 abs(bitor(0, 0))
 abs(ceil(0))
 abs(ceil(1))
+abs(ceil(1.0))
+abs(ceil(f64))
+abs(ceil(i))
 abs(count($env, false))
 abs(count($env, true))
 abs(f64 * 1)
@@ -5369,46 +11056,91 @@ abs(f64 ** 0)
 abs(f64 ** 1)
 abs(f64 ** 1.0)
 abs(f64 + 0)
+abs(f64 + 1)
 abs(f64 + 1.0)
 abs(f64 + f64)
 abs(f64 - 1)
 abs(f64 - i)
+abs(f64 / 1)
+abs(f64 / 1.0)
 abs(f64 / f64)
+abs(f64 ?? 0)
+abs(f64 ?? 1)
+abs(f64 ?? add)
+abs(f64 ?? foo)
+abs(f64 ?? nil)
 abs(f64 ^ 0)
+abs(f64 ^ 1)
 abs(f64 ^ 1.0)
 abs(f64 ^ i)
 abs(f64)
 abs(f64) != f64
 abs(f64) != i
+abs(f64) ** i
 abs(f64) + i
 abs(f64) - f64
+abs(f64) - i
 abs(f64) / i
+abs(f64) == f64
+abs(f64) > f64
+abs(f64) ?? array
+abs(f64) ?? f64
+abs(f64) ?? i
+abs(f64) ?? str
 abs(findIndex($env, true))
+abs(findIndex(array, true))
+abs(findLastIndex($env, true))
+abs(findLastIndex(list, true))
 abs(first(array))
 abs(float(0))
+abs(float(1))
 abs(float(1.0))
 abs(float(f64))
+abs(float(i))
+abs(floor(0))
 abs(floor(1))
 abs(floor(1.0))
+abs(floor(f64))
+abs(floor(i))
 abs(i % i)
 abs(i * 0)
+abs(i * 1)
+abs(i * 1.0)
 abs(i * f64)
+abs(i * i)
 abs(i ** 0)
 abs(i ** 1.0)
+abs(i ** i)
 abs(i + 0)
+abs(i + 1)
 abs(i + i)
 abs(i - 1.0)
+abs(i - f64)
+abs(i - i)
 abs(i / 1.0)
 abs(i / i)
+abs(i ?? $env)
+abs(i ?? 1.0)
+abs(i ?? add)
+abs(i ?? i)
+abs(i ?? list)
+abs(i ?? true)
+abs(i ^ 1)
 abs(i ^ 1.0)
+abs(i ^ i)
 abs(i | bitshl(0))
+abs(i | bitushr(0))
 abs(i)
+abs(i) * i
 abs(i) + f64
+abs(i) < i
 abs(i) ^ i
 abs(i) not in array
 abs(i) | bitshr(0)
 abs(if false { array } else { 1 })
 abs(if false { array } else { i })
+abs(if ok { 1.0 } else { i })
+abs(if true { f64 } else { list })
 abs(if true { i } else { i })
 abs(int(0))
 abs(int(1))
@@ -5421,6 +11153,7 @@ abs(list | findIndex(ok))
 abs(list | findIndex(true))
 abs(list | reduce(1))
 abs(list | sum(1.0))
+abs(max($env)?.f64)
 abs(max(0))
 abs(max(1))
 abs(max(1.0))
@@ -5431,20 +11164,32 @@ abs(max(i))
 abs(mean(0))
 abs(mean(1))
 abs(mean(1.0))
+abs(mean(1.0, i))
 abs(mean(array))
+abs(mean(array, 0))
 abs(mean(f64))
+abs(mean(f64, array))
 abs(mean(i))
 abs(median(0))
+abs(median(0, 1.0))
 abs(median(1))
+abs(median(1, 0))
 abs(median(1.0))
+abs(median(1.0, 1.0))
 abs(median(array))
 abs(median(f64))
 abs(median(f64, array))
 abs(median(i))
 abs(min(0))
+abs(min(1))
 abs(min(1.0))
 abs(min(array))
+abs(min(f64))
 abs(min(i))
+abs(nil ?? 0)
+abs(nil ?? 1)
+abs(nil ?? 1.0)
+abs(nil ?? f64)
 abs(reduce(array, #))
 abs(reduce(array, #, nil))
 abs(reduce(array, i))
@@ -5453,34 +11198,77 @@ abs(reduce(list, 1))
 abs(round(0))
 abs(round(1))
 abs(round(1.0))
+abs(round(f64))
+abs(round(i))
+abs(round(median(f64)))
 abs(sum($env, 1.0))
+abs(sum($env, i))
 abs(sum(array))
 abs(sum(array, #))
 abs(sum(array, 0))
 abs(sum(array, f64))
+abs(sum(list, 1))
 abs(sum(list, 1.0))
+abs(sum(list, f64))
+abs(sum(list, i))
 add
 add != $env && $env?.ok
+add != $env && ok
 add != $env == $env
+add != $env ?? f64
+add != $env ?? false
+add != $env ?? list
+add != $env ?? str
+add != $env and ok
+add != $env or $env?.[array]
 add != $env or ok
 add != $env.add
+add != $env?.$env?.greet
 add != $env?.Bar
+add != $env?.Bar?.ok
 add != $env?.String
+add != $env?.String?.str(foo)
 add != $env?.[Bar]
 add != $env?.[String]
+add != $env?.[String]?.[array]
+add != $env?.[String]?.str()
 add != $env?.[foobar?.[foobar]]
+add != $env?.[foobar?.f64]
 add != $env?.[foobar]
 add != $env?.[str]
 add != $env?.add
 add != $env?.add ?: foo
 add != $env?.foobar
 add != $env?.foobar?.[array]
+add != 1 ?? foo
+add != 1.0 ?? foo
 add != add
+add != add ?? count(array)
+add != add ?? true
+add != array ?? 1
+add != array ?? 1.0
+add != f64 ?? ok
+add != false ?? list
+add != foo ?? $env
+add != i ?? foo
+add != list ?? greet
+add != max(array)
+add != min($env)
 add != nil && $env
+add != nil == true
+add != nil ?: 1
 add != nil ?: false
+add != nil and false
+add != nil || ok
 add != nil || true
+add != ok ?? str
+add == $env == false
 add == $env ? 0 : 1
 add == $env ? array : ok
+add == $env ?? foo
+add == $env ?? greet
+add == $env or false
+add == $env or true
 add == $env.add
 add == $env?.Bar
 add == $env?.Bar?.[str]
@@ -5492,14 +11280,215 @@ add == $env?.[foobar]
 add == $env?.[str]
 add == $env?.add
 add == $env?.foobar
+add == $env?.foobar?.[greet]
+add == 0 ?? $env
+add == 0 ?? array
+add == 1 ?? foo
+add == 1 ?? str
+add == 1.0 ?? foo
+add == 1.0 ?? greet
+add == 1.0 ?? i
+add == 1.0 ?? str
 add == add
+add == add && $env
+add == add == true
+add == add ?? 1.0
+add == add and $env?.[foo]
+add == add or $env
+add == false ?? 0
+add == foo ?? 1
+add == foo ?? array
+add == foo ?? f64
+add == foo ?? i
+add == greet ?? $env
+add == i ?? str
 add == last($env)
 add == max($env)
+add == mean(array)
 add == nil != $env?.[Bar]
 add == nil && $env[foobar:foobar]
+add == nil == ok
+add == nil ?? add
 add == nil || $env
 add == nil || false
+add == str ?? list
+add == str ?? ok
+add ?? !false
+add ?? $env ?? nil
+add ?? $env.add
+add ?? $env.array
+add ?? $env.f64
+add ?? $env.foo
+add ?? $env.greet
+add ?? $env.i
+add ?? $env.list
+add ?? $env.ok
+add ?? $env.str
+add ?? $env?.Bar
+add ?? $env?.Bar()
+add ?? $env?.Bar(f64 not endsWith foobar ^ true)
+add ?? $env?.Bar(foobar?.[i])
+add ?? $env?.String
+add ?? $env?.String()
+add ?? $env?.String(add)
+add ?? $env?.String(array.i())
+add ?? $env?.String?.f64
+add ?? $env?.[Bar]
+add ?? $env?.[String]
+add ?? $env?.[add]
+add ?? $env?.[array]
+add ?? $env?.[array]?.[str]
+add ?? $env?.[array]?.foo
+add ?? $env?.[f64]
+add ?? $env?.[f64]?.[str]
+add ?? $env?.[f64]?.greet
+add ?? $env?.[foo]
+add ?? $env?.[foobar and String]
+add ?? $env?.[foobar]
+add ?? $env?.[greet]
+add ?? $env?.[i]
+add ?? $env?.[last(Bar, foobar, foobar)]
+add ?? $env?.[list]
+add ?? $env?.[list].String
+add ?? $env?.[ok]
+add ?? $env?.[str]
+add ?? $env?.add
+add ?? $env?.array
+add ?? $env?.f64
+add ?? $env?.findIndex(foobar)
+add ?? $env?.foo
+add ?? $env?.greet
+add ?? $env?.i
+add ?? $env?.list
+add ?? $env?.ok
+add ?? $env?.str
+add ?? $env[$env != list:]
+add ?? $env[:String?.add]
+add ?? $env[:foobar]
+add ?? $env[f64(Bar):]
+add ?? $env[foo.ok():]
+add ?? $env[foobar != 1.0:]
+add ?? $env[foobar:1.0]
+add ?? $env[greet && Bar:foobar]
+add ?? -$env
+add ?? -0
+add ?? -1
+add ?? -f64
+add ?? -i
+add ?? 0 ?? array
+add ?? 1 ?? i
+add ?? 1 ?? str
+add ?? 1.0 ?? add
+add ?? [1]
+add ?? [add]
+add ?? [foo]
+add ?? [i]
+add ?? [ok]
+add ?? abs(0)
+add ?? add
+add ?? add ?? foo
+add ?? add ?? true
+add ?? array
+add ?? array?.[i]
+add ?? bitnot(0)
+add ?? ceil(0)
+add ?? ceil(1)
+add ?? ceil(f64)
+add ?? count($env)
+add ?? count(array)
+add ?? count(list)
+add ?? date(false)
+add ?? date(nil)
+add ?? duration($env)
+add ?? duration(str)
+add ?? f64
+add ?? false ?? foo
+add ?? false ?? i
+add ?? filter($env, #)
+add ?? filter($env, true)
+add ?? findIndex($env, #.array)
+add ?? findIndex($env, #.foo)
+add ?? findLast($env, #)
+add ?? findLast($env, false)
+add ?? findLast(list, true)
+add ?? flatten(array)
+add ?? float(1.0)
+add ?? floor(0)
+add ?? foo
+add ?? foo ?? f64
+add ?? foo ?? foo
+add ?? foo ?? nil
+add ?? foo ?? true
+add ?? foo.Bar
+add ?? foo.String
+add ?? foo.String()
+add ?? foo?.Bar
+add ?? foo?.String
+add ?? foo?.String()
+add ?? fromBase64(str)
+add ?? fromPairs(list)
+add ?? greet
+add ?? greet ?? 1.0
+add ?? greet($env)
+add ?? groupBy($env, 1)
+add ?? groupBy($env, foo)
+add ?? i
+add ?? i ?? $env
+add ?? i ?? $env?.Bar()
+add ?? int(1)
+add ?? list
+add ?? list ?? greet
+add ?? list ?? ok
+add ?? list | get(ok)
+add ?? list?.[i]
+add ?? list[:bitshr($env, i)]
+add ?? list[:i]
+add ?? lower($env)
+add ?? map($env, #index)
+add ?? map($env, greet)
+add ?? max($env)
+add ?? max(i)
+add ?? mean(1.0)
+add ?? mean(array)
+add ?? nil ?? false
+add ?? nil ?? foo
+add ?? nil ?? ok
+add ?? not $env
+add ?? not ok
+add ?? not true
+add ?? ok
+add ?? reduce($env, #)
+add ?? reduce($env, .Bar)?.array
+add ?? reverse(array)
+add ?? sortBy($env, $env).list(i)
+add ?? sortBy(array, #)
+add ?? sortBy(array, foo)
+add ?? str
+add ?? str ?? max(array)
+add ?? string(1.0)
+add ?? string(foo)
+add ?? string(greet)
+add ?? string(nil)
+add ?? sum($env)
+add ?? sum($env, 1)
+add ?? sum($env, array)
+add ?? sum($env, str)
+add ?? sum(array, f64)
+add ?? sum(list)
+add ?? timezone(str)
+add ?? toBase64($env)
+add ?? trim($env)
+add ?? true ?? 1.0
+add ?? true | get(foo)
+add ?? type(1.0)
+add ?? type(array)
+add ?? upper($env)
+add ?? values($env)
+add ?? {foo: foo, foo: greet}
+add ?? {foo: foo}
+add ?? {foo: str}
 add in $env?.Bar
+add in $env?.Bar?.[f64]
 add in $env?.String
 add in $env?.[Bar]
 add in $env?.[String]
@@ -5510,106 +11499,207 @@ add in $env?.foobar
 add in $env?.foobar?.str()?.greet
 add in [$env, $env]
 add in keys($env)
+add in list ?? add
+add in map(array, $env)
 add in values($env)
 add in {foo: add}?.add
+add not in $env?.$env
 add not in $env?.Bar
+add not in $env?.Bar?.Bar
 add not in $env?.String
 add not in $env?.[Bar]
 add not in $env?.[String]
 add not in $env?.[foobar]
+add not in $env?.[nil]
 add not in $env?.foobar
 add not in $env?.foobar == false
 add not in $env?.foobar?.[str]
 add not in $env?.true?.[greet]
+add not in [array, foo]
+add not in [foo, nil]
+add not in [nil]
+add not in find($env, false)
 add not in first($env)
 add not in keys($env)
+add not in list ?? false
+add not in list ?? str
 add not in reverse(list)
+add not in toPairs($env)
 add not in {foo: 1}?.array
 add($env.i, i)
+add($env?.i, i)
+add(-i, i)
+add(0, 0) != i
+add(0, 0) ** ceil(i)
 add(0, 1) * f64
+add(0, i) ?? array
+add(abs(1), sum(array, #))
+add(i, -i)
 add(i, 1) >= f64 > i
 add(i, array?.[i])
 add(i, i)
 add(i, list | sum(i))
+add(int(0), i)
 add(min(0, i), i)
 add(sum(array), i)
+add; $env.add
 add; $env.array
 add; add
+add; add ?? f64
+add; array
 add; greet
 add; list
 add; ok
 add; {foo: f64}
 all($env | filter(false), #[.ok:$env])
+all($env, false) and $env?.[add].f64
+all($env, false) and f64 <= 0
+all($env, ok) ?? add
+all($env, ok) ?? str
+all($env, true) ?: greet
 all($env, true) and ok
 all($env.array, 1 > #)
+all($env.list, # != foo)
 all($env.list, $env == #)
+all($env?.[str], str != #)
+all($env?.array, ok)
 all($env?.list, nil == $env)
+all($env?.list, ok)
 all([$env], ok)
+all([add], ok)
+all([false], #)
 all([list], 1.0 < 1.0)
+all([ok], #)
+all(array, # != $env)
 all(array, # < #)
+all(array, # < f64)
 all(array, # <= #)
+all(array, # <= i)
 all(array, # == #)
 all(array, # == $env)
 all(array, # == 0)
+all(array, # == 1.0)
 all(array, # > #)
 all(array, # >= #)
 all(array, $env != #)
+all(array, $env != f64)
 all(array, $env == #)
+all(array, 0 == i)
+all(array, 1 <= 1.0)
+all(array, 1 == 0)
+all(array, 1.0 <= #)
 all(array, 1.0 > 0)
+all(array, add == $env)
+all(array, f64 | min(#, 1.0) >= #)
+all(array, false and ok)
+all(array, false) or 1.0 ?? i
+all(array, foo == nil)
+all(array, i >= 0)
 all(array, i >= 1)
 all(array, list | one(true))
+all(array, nil != #)
 all(array, nil != nil)
+all(array, nil == 1)
 all(array, nil == true)
+all(array, ok ?? $env)
 all(array, ok)
 all(array, ok) || $env?.Bar
 all(array, str == nil)
 all(array, str startsWith str)
 all(array, true or $env)
+all(array, true) ?? greet
 all(list | map(true), #)
+all(list, !false)
 all(list, # != #)
 all(list, # in list)
 all(list, #.Bar >= str)
+all(list, $env != #)
 all(list, $env != 0)
+all(list, $env == #)
+all(list, $env?.ok)
 all(list, 0 < 1.0)
+all(list, 0 <= 1.0)
+all(list, 1.0 <= 0)
+all(list, add != $env)
 all(list, array | any(ok))
+all(list, f64 != $env)
 all(list, f64 <= 1.0)
+all(list, false != false)
+all(list, false) != ok
+all(list, false) == $env == nil
+all(list, foo != #)
 all(list, foo == #)
 all(list, nil == nil)
 all(list, nil not in $env)
+all(list, not true)
 all(list, ok)
+all(list, true && ok)
 all(list, true and ok)
+all(list, true or true)
+all(map(list, 1.0), i < 1.0)
+all(nil ?? $env, ok)
 all(sort($env), #)
+all(sort($env), #.foo)
 all(sort($env), .f64 | reduce(#, foo))
 all(sort($env), .f64)
+all(sort($env), .ok)
 all(sort($env), .ok?.array)
+all(sort($env), .str <= #)
 all(sort($env), 1.0 >= #)
 all(sort($env), sortBy(#, ok))
+all(sort($env), str == #)
 all(toPairs($env), ok)
+all(uniq(list), ok)
+any($env ?? 1.0, ok)
+any($env, false) or $env?.[String]
 any($env, ok) || $env == foo
+any($env, true) ?? f64
 any($env, true) || $env?.[str]
 any($env.list, ok)
 any($env?.[str], true and true)
 any($env?.array, # == #)
+any($env?.array, ok)
 any($env?.list, ok)
+any([$env], ok)
+any([0], foo == nil)
+any([1.0], not true)
+any(array ?? $env, true or #)
 any(array, # != #)
 any(array, # != $env)
 any(array, # < 0)
 any(array, # <= #)
+any(array, # > #)
+any(array, # >= 1)
 any(array, $env != #)
 any(array, $env != add)
+any(array, $env == 0)
 any(array, $env | all(true))
+any(array, $env.ok)
 any(array, $env?.ok)
+any(array, 0 <= 1)
 any(array, 0 == #)
 any(array, 1 == 1.0)
+any(array, 1.0 != 0)
+any(array, 1.0 <= #)
 any(array, array == array)
+any(array, f64 != f64)
+any(array, false) ?? list
+any(array, false) || $env != 0
 any(array, foo == nil)
 any(array, i != #)
 any(array, i <= i)
+any(array, nil != #)
+any(array, nil == greet)
 any(array, ok != ok)
+any(array, ok ?? $env)
+any(array, ok ?? 0)
 any(array, ok or $env)
 any(array, ok)
 any(array, str >= str)
+any(filter(list, false), ok)
 any(keys($env), ok)
+any(list ?? list, ok)
+any(list, !true)
 any(list, # != #)
 any(list, # == #)
 any(list, # in list)
@@ -5617,20 +11707,40 @@ any(list, $env != false)
 any(list, $env && false)
 any(list, $env == 1.0)
 any(list, $env == list)
+any(list, $env == ok)
 any(list, $env == str)
+any(list, $env.ok)
 any(list, $env?.ok)
+any(list, 0 <= 1.0)
+any(list, 1 < 0)
+any(list, 1.0 < 1.0)
+any(list, false && true)
+any(list, false) && 1.0 ?? $env
+any(list, foo != #)
+any(list, foo == nil)
 any(list, i ^ i == 1.0)
 any(list, list != array)
 any(list, nil != 1)
 any(list, nil == nil)
+any(list, not true)
+any(list, ok or $env)
 any(list, ok)
 any(map(array, add), ok)
+any(nil ?? $env, ok)
+any(sort($env), #)
+any(sort($env), -#)
+any(sort($env), .String)
+any(sort($env), .list)
+any(sort($env), f64 == #)
+any(sort(array), # == ok)
 any(sortBy(list, i), ok)
 any(values($env), # != 1.0)
 array
+array != $env != $env
 array != $env && false
 array != $env == false
 array != $env == ok
+array != $env ?: str
 array != $env and $env
 array != $env and $env?.[Bar]
 array != $env or true
@@ -5643,168 +11753,566 @@ array != $env?.String?.foo()
 array != $env?.[Bar]
 array != $env?.[String]
 array != $env?.[String]?.[greet]
+array != $env?.[foobar]
 array != $env?.[str]
 array != $env?.array
 array != $env?.foobar
 array != $env?.list
+array != $env?.true
+array != 0 ?? $env
+array != 0 ?? list
+array != 1.0 ?? array
 array != [1.0 + f64]
 array != [f64]
 array != [foo]
+array != [list]
+array != [median(1.0)]
+array != [true]
 array != array
+array != array != nil
+array != array && ok
 array != array && true
+array != array ?? false
 array != array or ok
+array != false ?? $env
+array != false ?? f64
+array != false ?? greet
 array != flatten(array)
+array != foo ?? f64
+array != i .. 1
+array != i ?? foo
 array != list
 array != list != false
+array != list != true
 array != list && 1.0 > 0
 array != list || ok
 array != map($env, 1.0)
+array != map(array, $env)
 array != map(list, #)
 array != map(list, 1.0)
 array != min($env)
 array != nil == $env
 array != nil ? list : greet
 array != nil and ok
+array != nil and true
+array != nil or $env
+array != nil or false
+array != nil or ok
+array != str ?? greet
 array != values($env)
 array != {foo: $env}?.str
+array != {foo: 0}.add
 array == $env != ok
 array == $env && false
+array == $env ?? i
+array == $env ?? nil
+array == $env ?? str
 array == $env and $env
+array == $env or $env?.Bar
+array == $env or false
 array == $env.array
 array == $env.list
 array == $env?.Bar
+array == $env?.Bar?.ok
 array == $env?.String
+array == $env?.String?.[greet]
+array == $env?.String?.greet
 array == $env?.[Bar]
+array == $env?.[Bar]?.[add]
+array == $env?.[Bar]?.add
 array == $env?.[String]
 array == $env?.[foobar]
+array == $env?.[greet(nil)]
 array == $env?.[str]
 array == $env?.array
 array == $env?.foobar
 array == $env?.list
+array == 0 ?? array
+array == 1.0 ?? find($env, #.list)
+array == [$env]
 array == [1.0]
 array == [1]
 array == [foo]
 array == [nil]
 array == [ok, 1.0]
+array == [ok]
 array == [str]
+array == [true]
+array == add ?? foo
 array == array
 array == array != ok
+array == f64 ?? $env
+array == false ?? $env
+array == false ?? i
+array == foo ?? add
+array == foo ?? true
+array == greet ?? array
+array == greet ?? ok
 array == keys($env)
 array == list
+array == list != $env
 array == list != false
 array == list[:]
 array == map(array, #)
+array == map(list, true)
 array == max($env)?.greet
+array == min($env)
 array == min(array)
+array == nil != nil
+array == nil != ok
 array == nil && $env
+array == nil && foo == $env
+array == nil == $env
+array == nil ?? nil
+array == ok ?? foo
+array == ok ?? list
+array ?? !$env
+array ?? !false
+array ?? !ok
+array ?? $env ?? foo
+array ?? $env ?? i
+array ?? $env | count(true)
+array ?? $env | findLast(ok)
+array ?? $env | groupBy(false)
+array ?? $env | map(f64)
+array ?? $env | map(foo)
+array ?? $env | map(ok)
+array ?? $env | median(i, f64)
+array ?? $env | reduce(#)
+array ?? $env | reduce(add)
+array ?? $env | reduce(foo)
+array ?? $env | sortBy(1.0)
+array ?? $env.add
+array ?? $env.array
+array ?? $env.f64
+array ?? $env.foo
+array ?? $env.greet
+array ?? $env.i
+array ?? $env.list
+array ?? $env.ok
+array ?? $env.str
+array ?? $env?.Bar
+array ?? $env?.Bar()
+array ?? $env?.Bar(foobar)
+array ?? $env?.String
+array ?? $env?.String()
+array ?? $env?.String(Bar, 0)
+array ?? $env?.[Bar]
+array ?? $env?.[String]
+array ?? $env?.[add]
+array ?? $env?.[add].str
+array ?? $env?.[array]
+array ?? $env?.[f64]
+array ?? $env?.[f64]?.[add]
+array ?? $env?.[f64]?.greet()
+array ?? $env?.[foo?.[array]]
+array ?? $env?.[foo]
+array ?? $env?.[foobar.Bar]
+array ?? $env?.[foobar]
+array ?? $env?.[greet()]
+array ?? $env?.[greet]
+array ?? $env?.[i]
+array ?? $env?.[list | fromJSON(nil)]
+array ?? $env?.[list]
+array ?? $env?.[list]?.f64
+array ?? $env?.[list]?.foo
+array ?? $env?.[nil or $env]
+array ?? $env?.[ok]
+array ?? $env?.[ok].foo()
+array ?? $env?.[str]
+array ?? $env?.[str].str
+array ?? $env?.add
+array ?? $env?.array
+array ?? $env?.f64
+array ?? $env?.foo
+array ?? $env?.greet
+array ?? $env?.i
+array ?? $env?.list
+array ?? $env?.ok
+array ?? $env?.sort(foobar, nil)
+array ?? $env?.str
+array ?? $env[1.0:foobar]
+array ?? $env[:1.0]
+array ?? $env[:foobar]
+array ?? $env[:fromPairs(ok)]
+array ?? $env[:str .. false]
+array ?? $env[f64():]
+array ?? $env[findLastIndex(foo, greet):]
+array ?? $env[foobar .. foobar:]
+array ?? $env[foobar:]
+array ?? $env[str:]
+array ?? $env[true != foobar:]
+array ?? -$env
+array ?? -0
+array ?? -1
+array ?? -1.0
+array ?? -1.0 ^ 1.0 | map(foo)
+array ?? 0 ?? f64
+array ?? 0 | filter(false)
+array ?? 0 | map(#)
+array ?? 0 | map(add)
+array ?? 0 | one(false)
+array ?? 0 | one(ok)
+array ?? 0 | reduce(#)
+array ?? 0 | sum(i)
+array ?? 1 | map(1)
+array ?? 1 | map(false)
+array ?? 1 | reduce($env, $env)
+array ?? 1 | reduce(greet)
+array ?? 1 | reduce(i)
+array ?? 1.0 ?? add
+array ?? 1.0 ?? foo
+array ?? 1.0 | findLast(false)
+array ?? 1.0 | groupBy(1)
+array ?? 1.0 | map(#)
+array ?? 1.0 | sortBy(#)
+array ?? 1.0 | sortBy(1.0)
+array ?? 1.0 | sum(#)
+array ?? [1]
+array ?? [add]
+array ?? [list]
+array ?? [ok, add]
+array ?? abs(1.0)
+array ?? abs(f64)
+array ?? add
+array ?? add | findLastIndex(ok)
+array ?? add | groupBy(true)
+array ?? add | map(#)
+array ?? add | reduce($env)
+array ?? add | reduce(i)
+array ?? add($env, 1)
+array ?? array
+array ?? array ?? 0
+array ?? array ?? f64
+array ?? array | map(true)
+array ?? array | one(true)
+array ?? array | reduce($env)
+array ?? array | reduce(str)
+array ?? array?.[i]
+array ?? bitnot(1)
+array ?? bitushr($env, 0)
+array ?? ceil(1.0)
+array ?? concat(list)
+array ?? count($env)
+array ?? count($env, #)
+array ?? count(list)
+array ?? count(str ?? 1.0)
+array ?? date(foo)
+array ?? date(i)
+array ?? date(str)
+array ?? duration($env)
+array ?? f64
+array ?? f64 ?? 1.0
+array ?? f64 | map(#)
+array ?? f64 | map(foo)
+array ?? f64 | sortBy(f64)
+array ?? f64 | sum(#)
+array ?? false ?? false
+array ?? false | findLastIndex(true)
+array ?? false | groupBy(#)
+array ?? false | map($env)
+array ?? false | one(ok)
+array ?? filter($env, .str)
+array ?? findIndex($env, #)
+array ?? findLast($env, #.String)
+array ?? findLast($env, .add)
+array ?? findLastIndex($env, #)
+array ?? findLastIndex($env, #.i)
+array ?? floor(1.0)
+array ?? foo
+array ?? foo | all(ok)
+array ?? foo | all(true)
+array ?? foo | any(false)
+array ?? foo | filter(true)
+array ?? foo | groupBy(1)
+array ?? foo | map(#)
+array ?? foo | map(1.0)
+array ?? foo | map(foo)
+array ?? foo | reduce(#)
+array ?? foo | reduce(#acc, true)
+array ?? foo | reduce(#index * #)
+array ?? foo | reduce(1)
+array ?? foo | reduce(1.0)
+array ?? foo | reduce(foo)
+array ?? foo | reduce(foo, true)
+array ?? foo | sortBy(1)
+array ?? foo | sortBy(str)
+array ?? foo | sum(1.0)
+array ?? foo.Bar
+array ?? foo.String
+array ?? foo.String()
+array ?? foo?.Bar
+array ?? foo?.String
+array ?? foo?.String()
+array ?? fromBase64(str)
+array ?? greet
+array ?? greet ?? $env
+array ?? greet | all(ok)
+array ?? greet | map(true)
+array ?? greet | reduce(foo)
+array ?? greet | sortBy(f64)
+array ?? greet | sum(0)
+array ?? greet($env)
+array ?? i
+array ?? i ?? add
+array ?? i | map(#)
+array ?? i | max(0)
+array ?? i | sortBy(#)
+array ?? i | sum(1)
+array ?? last($env)?.Bar
+array ?? list
+array ?? list ?? str
+array ?? list | find(true)
+array ?? list | findIndex(ok)
+array ?? list | findIndex(true)
+array ?? list | map($env)
+array ?? list | map(foo)
+array ?? list?.[i]
+array ?? list[:]
+array ?? map($env, array)
+array ?? map($env?.[String], bitshr(#, #))
+array ?? max(f64)
+array ?? mean(f64)
+array ?? min(i)
+array ?? nil ?? $env?.f64
+array ?? nil ?? add
+array ?? nil ?? f64
+array ?? nil ?? i
+array ?? nil | filter(false)
+array ?? nil | map(#)
+array ?? nil | map(false)
+array ?? nil | reduce(#)
+array ?? nil | reduce(foo, $env)
+array ?? nil | reduce(foo, foo)
+array ?? nil | sortBy(#)
+array ?? not ok
+array ?? not true
+array ?? ok
+array ?? ok | findIndex(ok)
+array ?? ok | findLastIndex(true)
+array ?? ok | map(i)
+array ?? ok | reduce(i, 1.0)
+array ?? ok | sum(#)
+array ?? one($env, #)
+array ?? reduce($env, #.greet)
+array ?? reduce($env, list)
+array ?? round(1)
+array ?? round(i)
+array ?? sortBy($env, 0)
+array ?? sortBy($env, 1)
+array ?? sortBy($env, foo)
+array ?? str
+array ?? str | map(foo)
+array ?? str | none(false)
+array ?? str | reduce(#, f64)
+array ?? str | sortBy(#)
+array ?? str | sum(#)
+array ?? string($env)
+array ?? string(array)
+array ?? string(nil)
+array ?? string(ok)
+array ?? sum($env)
+array ?? sum($env, list)
+array ?? sum(array)
+array ?? sum(array, true)
+array ?? toJSON(add)
+array ?? true | groupBy(ok)
+array ?? true | reduce(0)
+array ?? true | reduce(foo)
+array ?? true | sum(#)
+array ?? type(array)
+array ?? type(foo)
+array ?? type(list)
+array ?? uniq($env)
+array ?? uniq(array)
+array ?? {foo: 1}
+array ?? {foo: add}
+array ?? {foo: i}
 array in $env?.Bar
+array in $env?.Bar?.[array]
 array in $env?.String
 array in $env?.String?.array
+array in $env?.String?.foo
 array in $env?.[Bar]
 array in $env?.[String]
 array in $env?.[String]?.[greet]
+array in $env?.[String]?.list
+array in $env?.[foobar]
 array in $env?.[foobar]?.[i]
 array in $env?.foobar
+array in [$env?.foobar]
 array in [array]
 array in [f64, list]
 array in [list]
+array in [nil]
 array in [str, $env]
+array in array ?? add
+array in array ?? greet
 array in flatten(array)
+array in keys($env)
 array in last($env)
 array in reverse(list)
 array in uniq(array)
+array in values($env)
+array not in $env and false
 array not in $env?.Bar
 array not in $env?.String
 array not in $env?.[Bar]
+array not in $env?.[Bar]?.add
 array not in $env?.[String]
+array not in $env?.[String]?.[add]
 array not in $env?.[String]?.f64
 array not in $env?.[String]?.list
 array not in $env?.[foobar?.String]
 array not in $env?.[foobar]
+array not in $env?.false
 array not in $env?.foobar
+array not in [1, 1.0]
 array not in [array]
+array not in [list]
+array not in first($env)
+array not in last($env)
+array not in list ?? none($env, #.Bar)
 array not in map(array, array)
 array not in toPairs($env)
 array not in uniq(array)
+array not in uniq(list)
 array not in {foo: foo}.add
+array | all(# != #)
 array | all(# != nil)
+array | all(# <= 1.0)
 array | all(# == f64)
 array | all(# >= i)
 array | all($env == #)
+array | all($env == $env)
 array | all($env == foo)
 array | all(0 < 1.0)
 array | all(0 == #)
+array | all(1.0 != nil)
+array | all(1.0 <= #)
+array | all(f64 < #)
 array | all(false)
 array | all(foo == foo)
+array | all(foo not in list)
 array | all(i != f64)
 array | all(i > #)
 array | all(ok)
+array | all(one(list, true))
 array | all(true && true)
 array | all(true)
+array | any(# != #)
 array | any(# < #)
 array | any(# <= #)
 array | any(# == $env.i)
+array | any(# > #)
+array | any(# >= f64)
 array | any($env != #)
+array | any($env != nil)
 array | any($env == foo)
 array | any($env?.ok)
 array | any(1 < #)
 array | any(1.0 <= 1)
 array | any(false)
 array | any(i <= #)
+array | any(not ok)
 array | any(ok ?: nil)
 array | any(ok)
 array | any(true)
 array | concat(array)
 array | concat(array) | find(ok)
+array | concat(array) | sortBy(1)
+array | concat(array, array)
 array | concat(list)
+array | concat(list) | reduce(f64)
 array | count(# != #)
 array | count(# != $env)
 array | count(# != nil)
 array | count(# <= 0)
+array | count(# > #)
 array | count($env != foo)
 array | count($env == #)
 array | count($env == array)
+array | count($env.ok)
 array | count($env?.ok)
+array | count(0 < 1)
 array | count(0 <= #)
+array | count(0 > #)
 array | count(1.0 == #)
 array | count(false)
 array | count(i >= #)
+array | count(nil not in $env)
+array | count(not true)
 array | count(ok)
+array | count(ok) not in array
 array | count(true)
 array | count(true) ** i
+array | filter(!true)
 array | filter(# < 1.0)
 array | filter(# <= #)
 array | filter(# <= f64)
+array | filter(# >= #)
+array | filter(# >= 0)
 array | filter($env == #)
 array | filter($env == i)
+array | filter($env == ok)
+array | filter($env == str)
 array | filter($env.ok)
 array | filter(1 != #)
+array | filter(f64 < #)
+array | filter(f64 == #)
 array | filter(false)
+array | filter(false) | map(#)
+array | filter(false) | map(array)
 array | filter(false) | sortBy(#)
+array | filter(false) | sortBy(foo)
 array | filter(foo != foo)
+array | filter(foo != nil)
+array | filter(greet == $env)
 array | filter(nil == #)
 array | filter(nil == foo)
 array | filter(ok)
+array | filter(ok) | find(1.0 > #)
+array | filter(ok) | map(foo)
+array | filter(ok) | mean(1.0)
 array | filter(ok) | sum(1)
 array | filter(true)
+array | filter(true) != list
 array | filter(true) | groupBy(#)
+array | filter(true) | take(0)
+array | find(# < #)
 array | find(# >= 1.0)
 array | find($env != $env)
+array | find($env == i)
+array | find($env not in array)
 array | find($env not in list)
+array | find(-1 < #)
 array | find(0 < 1)
+array | find(1.0 != 1.0)
 array | find(1.0 < #)
 array | find(1.0 == 0)
+array | find(1.0 == 1.0)
 array | find(false)
 array | find(foo in list)
+array | find(i == i)
 array | find(ok)
 array | find(true)
+array | find(true) == i
 array | find(true) >= float(f64)
+array | find(true) ?? ok
+array | find(true) | mean(1.0)
+array | find(type(true) contains str[0:])
+array | findIndex(!false)
 array | findIndex(# != 0)
 array | findIndex(# == #)
+array | findIndex(# > 1.0)
 array | findIndex(# > f64)
 array | findIndex(# >= 1.0)
 array | findIndex($env != false)
+array | findIndex($env != nil)
+array | findIndex($env.ok)
 array | findIndex($env?.ok)
+array | findIndex(0 != #)
+array | findIndex(1 not in array)
 array | findIndex(1.0 < 1.0)
 array | findIndex(1.0 <= #)
 array | findIndex(f64 == $env)
@@ -5812,42 +12320,65 @@ array | findIndex(f64 >= 1.0)
 array | findIndex(false and false)
 array | findIndex(false)
 array | findIndex(i != $env)
+array | findIndex(ok ?? ok)
 array | findIndex(ok)
 array | findIndex(true)
 array | findIndex(true) + i
+array | findIndex(true) | bitshl(0)
+array | findLast(# <= i)
 array | findLast(# > #)
+array | findLast(# >= 1.0)
+array | findLast($env or true)
+array | findLast(0 >= #)
 array | findLast(1.0 < #)
 array | findLast(1.0 >= i)
+array | findLast(f64 + f64 != nil)
+array | findLast(f64 <= #)
 array | findLast(f64 >= #)
 array | findLast(false)
 array | findLast(greet != nil)
 array | findLast(nil != #)
 array | findLast(nil not in $env)
+array | findLast(none($env, true))
 array | findLast(ok)
+array | findLast(ok) ?? $env[false:]
+array | findLast(ok) | mean(i)
 array | findLast(true ?: add)
 array | findLast(true)
+array | findLastIndex(!true)
 array | findLastIndex(# != $env)
 array | findLastIndex(# < #)
 array | findLastIndex(# <= #)
+array | findLastIndex($env != 0)
+array | findLastIndex($env != 1.0)
 array | findLastIndex($env | any(false))
 array | findLastIndex(0 <= 0)
 array | findLastIndex(1 <= i)
+array | findLastIndex(1.0 < #)
 array | findLastIndex(1.0 <= #)
 array | findLastIndex(1.0 <= 1.0)
 array | findLastIndex(false ?: ok)
 array | findLastIndex(false)
 array | findLastIndex(foo in list)
+array | findLastIndex(nil == nil)
+array | findLastIndex(nil ?? true)
 array | findLastIndex(ok)
 array | findLastIndex(ok) < f64
+array | findLastIndex(ok) ?? i
+array | findLastIndex(str endsWith str)
 array | findLastIndex(true)
 array | findLastIndex(true) - i
 array | get(0)
 array | get(1)
 array | get(i)
+array | get(mean(1.0, array))
+array | get(sum(array))
 array | groupBy(# != #)
 array | groupBy(# - #)
 array | groupBy(# / 1.0)
+array | groupBy(# / i)
 array | groupBy(# == #)
+array | groupBy(# == nil)
 array | groupBy(# > #)
 array | groupBy(# >= #)
 array | groupBy(# ^ #)
@@ -5855,117 +12386,209 @@ array | groupBy(#)
 array | groupBy($env != 0)
 array | groupBy($env && false)
 array | groupBy($env.foo)
+array | groupBy($env?.[Bar])
+array | groupBy($env?.[String])
 array | groupBy($env?.[str])
 array | groupBy($env?.foo)
+array | groupBy($env?.foobar)
 array | groupBy($env?.str)
+array | groupBy(-#)
 array | groupBy(0 ** 1.0)
 array | groupBy(0)
 array | groupBy(1)
 array | groupBy(1.0 != #)
+array | groupBy(1.0 != f64)
 array | groupBy(1.0 ** 1)
 array | groupBy(1.0 ** f64)
+array | groupBy(1.0 == 1.0)
+array | groupBy(1.0 ?? foo)
+array | groupBy(1.0 ^ #)
 array | groupBy(1.0)
+array | groupBy(add(#, 0))
+array | groupBy(array?.[i])
+array | groupBy(bitnot(i))
 array | groupBy(f64)
 array | groupBy(false != false)
+array | groupBy(false ?? false)
 array | groupBy(false)
+array | groupBy(first(array))
 array | groupBy(foo)
 array | groupBy(foo.Bar)
+array | groupBy(foo.String())
 array | groupBy(i)
+array | groupBy(len(list))
 array | groupBy(list?.[i])
+array | groupBy(mean(1.0 ?? 1.0))
+array | groupBy(not false)
+array | groupBy(ok ?? str)
 array | groupBy(ok)
 array | groupBy(round(#))
+array | groupBy(round(0))
 array | groupBy(round(1.0))
 array | groupBy(str)
+array | groupBy(str[0:])
 array | groupBy(string(1))
+array | groupBy(sum(array))
 array | groupBy(trimPrefix(str))
 array | groupBy(true)
+array | map(!ok)
 array | map(# != 0)
+array | map(# * #)
 array | map(# ** i)
+array | map(# + #)
 array | map(# - #)
 array | map(# .. #index)
+array | map(# < #)
+array | map(# == 0)
 array | map(# > #)
 array | map(# >= #)
 array | map(# >= i)
+array | map(# ?? #)
+array | map(# ?? 0)
 array | map(# ^ #)
 array | map(#)
 array | map(#) | any(ok)
+array | map(#) | groupBy(foo)
+array | map(#) | map($env?.foobar)
 array | map(#) | map(1.0)
+array | map(#) | map(foo)
+array | map(#) | map(ok)
 array | map(#) | one(ok)
 array | map(#) | one(true)
 array | map(#) | reduce(#)
+array | map(#) | reduce(foo)
 array | map(#) | reduce(ok)
 array | map(#) | sum(1.0)
 array | map(#) | take(0)
 array | map(#index % i)
 array | map(#index - 1.0)
+array | map(#index / #)
 array | map(#index)
+array | map(#index) | filter(ok)
+array | map(#index) | groupBy(#)
 array | map(#index) | map(false)
+array | map(#index) | map(list)
 array | map($env != str)
 array | map($env)
 array | map($env) | any(.ok)
+array | map($env) | map(#)
+array | map($env.foo)
+array | map($env.greet)
+array | map($env.i)
 array | map($env.list)
 array | map($env.ok)
+array | map($env.str)
 array | map($env?.Bar)
+array | map($env?.[Bar])
+array | map($env?.[foobar])
+array | map($env?.i)
 array | map($env?.list)
+array | map($env?.str)
+array | map(-1)
+array | map(0 - i)
 array | map(0)
 array | map(0) | reduce(#)
 array | map(0) | sum(#)
 array | map(0) | sum(f64)
+array | map(1 ** #)
 array | map(1 >= 1)
 array | map(1)
+array | map(1) ?? greet
 array | map(1) | find(ok)
 array | map(1) | groupBy(#)
+array | map(1) | map(list)
+array | map(1) | one(ok)
 array | map(1) | reduce($env, array)
+array | map(1.0 ** #)
 array | map(1.0 + #index)
 array | map(1.0 - 1.0)
 array | map(1.0 <= #)
 array | map(1.0 > #)
 array | map(1.0)
+array | map(1.0) | groupBy(false)
+array | map(1.0) | groupBy(foo)
 array | map(1.0) | map(0)
 array | map(1.0) | reduce(foo)
 array | map(1.0) | sortBy(#)
 array | map([#])
 array | map([$env])
+array | map([foo])
+array | map([list])
 array | map(add(#, #))
 array | map(add)
+array | map(add) | map(greet)
+array | map(add) | reduce(#)
+array | map(array | findLast(true))
 array | map(array)
 array | map(array) == array
 array | map(array) | any(false)
+array | map(array) | findIndex(true)
+array | map(bitshl(#, #))
+array | map(f64 < 1.0)
 array | map(f64 ^ #)
 array | map(f64)
+array | map(f64) ?? $env?.f64
+array | map(f64) | findLastIndex(false)
 array | map(f64) | one(array == $env)
+array | map(f64) | reduce(#)
+array | map(f64) | reduce(foo)
+array | map(f64) | reduce(str, ok)
 array | map(f64) | sortBy(i)
+array | map(false && true)
 array | map(false)
 array | map(false) != list
 array | map(false) | none(#)
 array | map(foo)
 array | map(foo) != array
+array | map(foo) ?? greet
 array | map(foo) | map(#)
 array | map(foo) | reduce(#)
 array | map(foo) | reduce(1.0)
+array | map(foo) | sum(1.0)
+array | map(foo.Bar)
+array | map(foo.String)
 array | map(foo?.Bar)
+array | map(foo?.String())
+array | map(foo?.String)
 array | map(greet)
 array | map(greet) | groupBy(true)
+array | map(greet) | map(#)
+array | map(i != $env)
 array | map(i <= 1)
+array | map(i ^ #)
 array | map(i)
 array | map(i) | filter(ok)
 array | map(i) | groupBy(f64)
+array | map(i) | reduce(add)
+array | map(i) | sum(#)
 array | map(if false { 0 } else { foo })
+array | map(len($env))
 array | map(let foobar = greet; foobar)
 array | map(list)
+array | map(list) | get(i)
+array | map(max(#))
 array | map(mean(#))
 array | map(median(#))
 array | map(nil == greet)
 array | map(ok)
+array | map(ok) | all(ok)
 array | map(ok) | any(#)
 array | map(ok) | groupBy(ok)
 array | map(str)
 array | map(str) | groupBy(#)
 array | map(str) | map(#)
+array | map(sum(array))
 array | map(toJSON(f64))
+array | map(toJSON(foo))
+array | map(true != nil)
+array | map(true ?? nil)
 array | map(true)
+array | map(true) | findLastIndex(#)
 array | map(true) | reduce(foo)
+array | map(type(foo))
+array | max($env.f64)
 array | max(0)
+array | max(0, 0)
 array | max(0, 1)
 array | max(0, 1.0)
 array | max(1)
@@ -5979,12 +12602,16 @@ array | max(f64, f64)
 array | max(i)
 array | max(i, i)
 array | max(map($env, #index))
+array | mean(-1.0)
 array | mean(0 / 1)
 array | mean(0)
 array | mean(0, 1.0, array)
 array | mean(1)
 array | mean(1, 0)
+array | mean(1, 1)
+array | mean(1, 1.0)
 array | mean(1.0)
+array | mean(1.0) * f64
 array | mean(1.0, 1)
 array | mean(1.0, 1.0)
 array | mean(array)
@@ -5992,40 +12619,66 @@ array | mean(array, 0) <= i
 array | mean(array, array)
 array | mean(f64)
 array | mean(f64, 1)
+array | mean(f64, 1.0)
 array | mean(i)
+array | mean(i, 0)
 array | mean(i, f64)
 array | median($env.array)
 array | median($env?.array)
 array | median(0)
+array | median(0, i)
 array | median(1 - 1.0)
 array | median(1)
+array | median(1, 1)
 array | median(1.0)
 array | median(1.0, 1.0)
+array | median(1.0, 1.0) ** f64
 array | median(1.0, f64)
 array | median([array])
 array | median(array)
 array | median(f64)
+array | median(f64) == $env?.ok
+array | median(f64, 1.0)
 array | median(i)
+array | min(-0)
 array | min(0)
+array | min(0, 1.0)
 array | min(0, array)
 array | min(0, f64)
 array | min(1)
+array | min(1, 1)
 array | min(1.0)
+array | min(1.0, 1.0)
+array | min(1.0, i)
 array | min(array)
+array | min(array, i)
+array | min(f64 ?? f64)
 array | min(f64)
+array | min(f64) | max(1.0, f64)
+array | min(f64, 0)
 array | min(i)
+array | min(i, 1.0)
 array | min(i, i)
+array | min(list | map(#index))
+array | none(!true)
 array | none(# != $env)
 array | none(# != 1)
+array | none(# != 1.0)
+array | none(# != nil)
 array | none(# < #)
+array | none(# <= #)
 array | none(# == #)
 array | none(# == $env)
 array | none(# == nil)
 array | none($env != 1.0)
 array | none($env.ok)
+array | none(1 in array)
 array | none(1.0 < #)
+array | none(1.0 == i)
 array | none(1.0 > #)
+array | none(false ?? foo)
 array | none(false)
+array | none(i == #)
 array | none(ok)
 array | none(true == $env)
 array | none(true)
@@ -6036,20 +12689,39 @@ array | one(# not in array)
 array | one($env != $env)
 array | one($env != foo)
 array | one($env.ok)
+array | one(false != false)
 array | one(false)
+array | one(false) || ok
 array | one(i == nil)
+array | one(list | reduce(true, ok))
+array | one(nil != f64)
+array | one(nil == #)
 array | one(nil == 1)
 array | one(nil == foo)
 array | one(ok)
 array | one(true)
+array | one(true) ?? f64
 array | reduce(# != #)
 array | reduce(# * #)
+array | reduce(# * i)
 array | reduce(# + #)
 array | reduce(# - f64)
+array | reduce(# / #acc)
+array | reduce(# == 1)
+array | reduce(# == 1.0)
 array | reduce(# > #index)
+array | reduce(# >= 1.0)
+array | reduce(# | bitshl(0))
 array | reduce(#)
+array | reduce(#) != f64
+array | reduce(#) / f64
+array | reduce(#) > f64
+array | reduce(#) ?? array
+array | reduce(#) ^ f64
 array | reduce(#, $env)
+array | reduce(#, 0 ^ 0)
 array | reduce(#, 0)
+array | reduce(#, 1 / 0)
 array | reduce(#, 1)
 array | reduce(#, 1.0)
 array | reduce(#, add)
@@ -6057,6 +12729,7 @@ array | reduce(#, array)
 array | reduce(#, f64)
 array | reduce(#, false)
 array | reduce(#, foo)
+array | reduce(#, foo) > i
 array | reduce(#, greet)
 array | reduce(#, i)
 array | reduce(#, list)
@@ -6064,24 +12737,41 @@ array | reduce(#, nil)
 array | reduce(#, ok)
 array | reduce(#, str)
 array | reduce(#, true)
+array | reduce(#acc != 1)
+array | reduce(#acc * 1)
+array | reduce(#acc ?? nil)
 array | reduce(#acc)
+array | reduce(#acc) - f64
 array | reduce(#acc) == greet
+array | reduce(#acc) == {foo: f64, foo: 1}
+array | reduce(#acc, $env)
 array | reduce(#acc, 0)
 array | reduce(#acc, 1.0) in [str, foo]
 array | reduce(#acc, add)
 array | reduce(#acc, array)
+array | reduce(#acc, f64)
 array | reduce(#acc, foo)
 array | reduce(#acc, greet)
 array | reduce(#acc, i)
 array | reduce(#acc, nil)
+array | reduce(#acc, true)
+array | reduce(#index <= f64)
+array | reduce(#index >= 1)
 array | reduce(#index)
+array | reduce(#index, $env)
+array | reduce(#index, array)
+array | reduce(#index, f64)
 array | reduce(#index, false)
 array | reduce(#index, foo)
+array | reduce(#index, greet) >= i
 array | reduce(#index, i)
 array | reduce(#index, list)
+array | reduce(#index, nil)
 array | reduce(#index, ok)
 array | reduce(#index, str)
+array | reduce($env != #)
 array | reduce($env != array)
+array | reduce($env == greet)
 array | reduce($env)
 array | reduce($env) | findLastIndex(true)
 array | reduce($env) | reduce($env, nil)
@@ -6095,35 +12785,61 @@ array | reduce($env, f64)
 array | reduce($env, false)
 array | reduce($env, foo)
 array | reduce($env, greet)
+array | reduce($env, i)
 array | reduce($env, list)
 array | reduce($env, nil)
 array | reduce($env, ok)
+array | reduce($env, ok) | map(array)
+array | reduce($env, str)
+array | reduce($env, true)
 array | reduce($env.ok)
 array | reduce($env?.Bar)
 array | reduce($env?.[Bar])
+array | reduce($env?.[String])
 array | reduce($env?.[String]?.foo())
+array | reduce($env?.array)
+array | reduce($env?.f64)
+array | reduce($env?.foo)
+array | reduce($env?.i)
 array | reduce($env?.list, foo?.String)
+array | reduce(-#)
+array | reduce(-1.0, str)
 array | reduce(0 + i)
 array | reduce(0 .. #)
+array | reduce(0 <= #index)
 array | reduce(0 == #)
+array | reduce(0 > #)
 array | reduce(0)
+array | reduce(0) ?? add
+array | reduce(0, $env)
 array | reduce(0, 0)
 array | reduce(0, 1.0)
+array | reduce(0, array)
 array | reduce(0, foo)
 array | reduce(0, i)
 array | reduce(0, list)
+array | reduce(0, ok)
+array | reduce(0, str)
 array | reduce(0, true)
+array | reduce(1 ** #acc)
+array | reduce(1 ?? str)
 array | reduce(1)
 array | reduce(1, 0)
+array | reduce(1, 1)
 array | reduce(1, 1.0)
 array | reduce(1, add)
+array | reduce(1, array)
+array | reduce(1, f64)
 array | reduce(1, false)
 array | reduce(1, foo)
+array | reduce(1, greet)
 array | reduce(1, nil)
 array | reduce(1, ok)
 array | reduce(1, str)
 array | reduce(1.0 * 1)
+array | reduce(1.0 ** #)
 array | reduce(1.0 > 1.0)
+array | reduce(1.0 ?? $env)
 array | reduce(1.0)
 array | reduce(1.0) != f64
 array | reduce(1.0) / f64
@@ -6136,9 +12852,12 @@ array | reduce(1.0, array)
 array | reduce(1.0, f64)
 array | reduce(1.0, false)
 array | reduce(1.0, foo)
+array | reduce(1.0, greet)
+array | reduce(1.0, i)
 array | reduce(1.0, list)
 array | reduce(1.0, nil)
 array | reduce(1.0, ok)
+array | reduce(1.0, str)
 array | reduce(1.0, true)
 array | reduce(add)
 array | reduce(add, $env)
@@ -6147,22 +12866,35 @@ array | reduce(add, 1.0)
 array | reduce(add, array)
 array | reduce(add, f64)
 array | reduce(add, false)
+array | reduce(add, foo)
+array | reduce(add, greet)
+array | reduce(add, i)
 array | reduce(add, list)
 array | reduce(add, nil)
 array | reduce(add, ok)
 array | reduce(add, str)
+array | reduce(all($env, true))
 array | reduce(array)
+array | reduce(array) | map(#)
+array | reduce(array) | none(true)
 array | reduce(array) | reduce(false)
+array | reduce(array) | sortBy(#)
 array | reduce(array, $env)
 array | reduce(array, 0)
+array | reduce(array, 1)
 array | reduce(array, 1.0)
 array | reduce(array, f64)
+array | reduce(array, false)
 array | reduce(array, foo)
 array | reduce(array, greet)
 array | reduce(array, list)
 array | reduce(array, nil)
 array | reduce(array, ok)
+array | reduce(bitnot(#))
+array | reduce(concat(list), $env.greet)
+array | reduce(f64 ^ 0)
 array | reduce(f64)
+array | reduce(f64, $env)
 array | reduce(f64, 0)
 array | reduce(f64, 1)
 array | reduce(f64, 1.0)
@@ -6176,16 +12908,20 @@ array | reduce(f64, nil)
 array | reduce(f64, true)
 array | reduce(false)
 array | reduce(false, $env)
+array | reduce(false, 0)
 array | reduce(false, 1)
 array | reduce(false, 1.0)
 array | reduce(false, add)
 array | reduce(false, false)
 array | reduce(false, foo)
+array | reduce(false, greet)
 array | reduce(false, i)
 array | reduce(false, list)
 array | reduce(false, nil)
+array | reduce(false, ok)
 array | reduce(false, true)
 array | reduce(foo)
+array | reduce(foo) ?? list
 array | reduce(foo, $env)
 array | reduce(foo, 0)
 array | reduce(foo, 1)
@@ -6193,6 +12929,7 @@ array | reduce(foo, 1.0)
 array | reduce(foo, add)
 array | reduce(foo, array)
 array | reduce(foo, f64)
+array | reduce(foo, false)
 array | reduce(foo, foo)
 array | reduce(foo, i)
 array | reduce(foo, list)
@@ -6200,92 +12937,153 @@ array | reduce(foo, nil)
 array | reduce(foo, ok)
 array | reduce(foo, str)
 array | reduce(foo, true)
+array | reduce(foo.String, $env?.[Bar])
+array | reduce(foo?.Bar)
+array | reduce(greet != $env)
+array | reduce(greet(str), int(1.0))
 array | reduce(greet)
+array | reduce(greet, $env)
+array | reduce(greet, 0)
+array | reduce(greet, 1)
 array | reduce(greet, 1.0)
+array | reduce(greet, add)
 array | reduce(greet, array)
+array | reduce(greet, f64)
 array | reduce(greet, false)
 array | reduce(greet, foo)
 array | reduce(greet, greet)
 array | reduce(greet, i)
+array | reduce(greet, nil)
 array | reduce(greet, str)
 array | reduce(greet, true)
+array | reduce(i * #)
 array | reduce(i > 1)
+array | reduce(i >= 1)
 array | reduce(i)
 array | reduce(i, $env)
 array | reduce(i, 0)
 array | reduce(i, 1)
 array | reduce(i, 1.0)
+array | reduce(i, array)
 array | reduce(i, false)
 array | reduce(i, foo)
+array | reduce(i, greet)
+array | reduce(i, i)
 array | reduce(i, list)
 array | reduce(i, nil)
 array | reduce(i, ok)
+array | reduce(i, true)
+array | reduce(int(#))
 array | reduce(list)
 array | reduce(list, $env)
 array | reduce(list, 0)
+array | reduce(list, 1)
 array | reduce(list, 1.0)
+array | reduce(list, add)
+array | reduce(list, array)
+array | reduce(list, false)
 array | reduce(list, foo)
+array | reduce(list, greet)
 array | reduce(list, i)
 array | reduce(list, list)
 array | reduce(list, nil)
 array | reduce(list, ok)
 array | reduce(list, ok) | all(true)
 array | reduce(list, true)
+array | reduce(median(#))
 array | reduce(median(0))
 array | reduce(nil != #)
+array | reduce(not false)
+array | reduce(not true)
+array | reduce(ok ?? 1.0)
 array | reduce(ok)
+array | reduce(ok) ?? array
 array | reduce(ok, $env)
 array | reduce(ok, 0)
 array | reduce(ok, 1.0)
 array | reduce(ok, add)
+array | reduce(ok, array)
 array | reduce(ok, false)
 array | reduce(ok, foo)
 array | reduce(ok, greet)
+array | reduce(ok, i)
 array | reduce(ok, list)
 array | reduce(ok, nil)
 array | reduce(ok, true)
 array | reduce(str)
 array | reduce(str) | greet()
 array | reduce(str, $env)
+array | reduce(str, -1.0)
 array | reduce(str, 1)
 array | reduce(str, 1.0)
 array | reduce(str, abs(1))
 array | reduce(str, add)
+array | reduce(str, array)
+array | reduce(str, false)
 array | reduce(str, foo)
 array | reduce(str, greet)
 array | reduce(str, i)
 array | reduce(str, list)
 array | reduce(str, nil)
+array | reduce(str, ok)
+array | reduce(string(1.0))
 array | reduce(string(add))
+array | reduce(toJSON(array))
 array | reduce(true and true)
 array | reduce(true)
 array | reduce(true, $env)
+array | reduce(true, 0)
 array | reduce(true, 1)
 array | reduce(true, 1.0)
+array | reduce(true, add)
 array | reduce(true, array)
 array | reduce(true, foo)
 array | reduce(true, i)
 array | reduce(true, nil)
 array | reduce(true, ok)
+array | reduce(true, str)
 array | reduce(true, true)
+array | reduce(type(greet))
 array | sortBy(# + #)
+array | sortBy(# + 1.0)
 array | sortBy(# + i)
 array | sortBy(# / #)
+array | sortBy(# / 1.0)
+array | sortBy(# ?? ok)
 array | sortBy(# ^ 1.0)
 array | sortBy(# ^ f64)
+array | sortBy(# | bitushr(#))
 array | sortBy(#)
+array | sortBy(#) ?? [0, $env]
 array | sortBy(#) | all(ok)
+array | sortBy(#) | groupBy(#)
+array | sortBy(#) | groupBy(f64)
 array | sortBy(#) | map(#)
+array | sortBy(#) | map(#index)
 array | sortBy(#) | map(foo)
+array | sortBy(#) | reduce(#)
+array | sortBy(#) | reduce(1.0)
+array | sortBy(#) | reduce(ok)
+array | sortBy(#) | sum(1)
+array | sortBy($env.add(#, 1))
 array | sortBy($env?.[str])
 array | sortBy($env?.i)
+array | sortBy(-#)
+array | sortBy(-0)
+array | sortBy(0 / #)
 array | sortBy(0 ^ #)
 array | sortBy(0)
 array | sortBy(0) | median(1.0)
+array | sortBy(0) | reduce(0)
+array | sortBy(0) | reduce(foo, foo)
 array | sortBy(1)
+array | sortBy(1.0 ^ #)
 array | sortBy(1.0)
 array | sortBy(1.0) != list
+array | sortBy(1.0) ?? i
+array | sortBy(1.0) | findLastIndex(ok)
 array | sortBy(1.0) | one(true)
+array | sortBy(1.0) | reduce($env)
 array | sortBy(1.0) | sortBy(#)
 array | sortBy(array | reduce(1.0))
 array | sortBy(array?.[i])
@@ -6296,47 +13094,85 @@ array | sortBy(f64) | sortBy(1.0)
 array | sortBy(f64) | sortBy(i)
 array | sortBy(floor(#))
 array | sortBy(foo.String())
+array | sortBy(i - 1)
 array | sortBy(i)
 array | sortBy(i) | sortBy(#)
+array | sortBy(max(#))
+array | sortBy(mean(#))
+array | sortBy(median(#))
 array | sortBy(reduce(array, str, foo))
 array | sortBy(str + str)
 array | sortBy(str)
+array | sortBy(str) | reduce(#)
+array | sortBy(sum(array))
+array | sortBy(true ? # : $env)
+array | sortBy(type(f64))
+array | sortBy(type(true))
 array | sum(# ** #)
+array | sum(# + #)
 array | sum(# - #)
+array | sum(# ?? 0)
 array | sum(# ^ 1)
 array | sum(# ^ i)
 array | sum(#)
 array | sum(#) < 1.0 ^ 1.0
+array | sum(#) <= f64
+array | sum(#) ^ f64
+array | sum($env.f64)
+array | sum($env.i)
+array | sum(-0)
+array | sum(-1)
+array | sum(-i)
+array | sum(0 ** 1.0)
 array | sum(0)
 array | sum(0.1)
+array | sum(1 * f64)
 array | sum(1 + 1.0)
+array | sum(1 | max(1.0))
 array | sum(1)
+array | sum(1) not in array
 array | sum(1.0 * #)
 array | sum(1.0 ** #)
 array | sum(1.0 - 1.0)
 array | sum(1.0)
+array | sum(1.0) < i
+array | sum(1.0) > 1.0 ^ i
+array | sum(array?.[i])
+array | sum(bitnot(1))
 array | sum(bitshl(#, #))
+array | sum(ceil(#))
 array | sum(f64)
+array | sum(f64) ?? str
 array | sum(float(f64))
 array | sum(i + 0)
+array | sum(i | bitshr(1))
 array | sum(i)
+array | sum(i) > -0
 array | sum(int(#))
 array | sum(max(#, 1))
 array | sum(median(#))
 array | sum(round(1.0))
 array | take(0)
+array | take(0) | one(ok)
 array | take(1)
 array | take(i)
 array; $env.ok
 array; add
 array; array
+array; f64
+array; f64; array
+array; foo
 array; foo.String
 array; greet
 array; i
 array; list
+array; ok
 array?.[$env.i]
 array?.[$env?.i]
+array?.[-0]
+array?.[-i]
 array?.[0 % i]
+array?.[1.0 ?? foo]
 array?.[1] % i
 array?.[1] .. i
 array?.[1] / f64
@@ -6346,178 +13182,374 @@ array?.[i]
 array?.[i] != 1.0 ?: 1.0
 array?.[i] != f64
 array?.[i] != i * 1.0
+array?.[i] != i ?? f64
+array?.[i] % i
+array?.[i] * f64
 array?.[i] * i
+array?.[i] ** 0 ?? ok
 array?.[i] ** i
+array?.[i] + f64
 array?.[i] - f64
 array?.[i] - i
 array?.[i] .. i
+array?.[i] .. i ?? 1.0
+array?.[i] / ceil(f64)
+array?.[i] / f64
+array?.[i] / float(0)
 array?.[i] / i
 array?.[i] < 0 + 1.0
 array?.[i] < f64
+array?.[i] < i
+array?.[i] <= 1.0 <= $env
 array?.[i] <= f64
+array?.[i] <= i
+array?.[i] == $env.i
+array?.[i] == -f64
+array?.[i] == array ?? $env
 array?.[i] == f64
+array?.[i] == i
 array?.[i] > f64
+array?.[i] > i
 array?.[i] >= f64
 array?.[i] >= i
+array?.[i] ?? $env?.Bar.greet
+array?.[i] ?? f64
+array?.[i] ?? foo?.String()
+array?.[i] ?? greet
+array?.[i] ?? ok
+array?.[i] ?? str
 array?.[i] ^ f64
+array?.[i] ^ f64 <= 1
 array?.[i] ^ i
+array?.[i] in array
 array?.[i] not in array
 array?.[i] | add(i)
+array?.[i] | bitand(1)
 array?.[i] | bitshr(0)
+array?.[i] | max(1)
+array?.[i] | mean(1)
 array?.[i] | min(0)
+array?.[i] | min(array)
 array?.[int(1.0)]
 array?.[len(list)]
 array?.[list | count(ok)]
+array?.[max(0)]
 array?.[mean(1)]
 array?.[mean(i)]
 array?.[median(1)]
+array[$env | count(true):]
+array[$env.i:]
 array[$env?.i:]
+array[-i:]
+array[0:] | any(ok)
+array[0:] | map(greet)
 array[0:] | reduce(#)
+array[0:] | reduce(add)
 array[0:] | reduce(str)
 array[0:] | sortBy(#)
 array[0:]?.[i]
 array[1:] == list
 array[1:] | any(ok)
 array[1:] | findLast(false)
+array[1:] | reduce(#)
 array[1:] | reduce(foo)
+array[1:] | reduce(list, nil)
 array[1:] | sum(#)
+array[1:] | sum(1.0)
 array[1:]?.[i]
 array[:$env.i]
+array[:-1]
+array[:-i]
+array[:0 ?? foo]
+array[:0] ?? ok
+array[:0] | groupBy(str)
 array[:0] | sortBy(#)
 array[:0] | sum(str)
+array[:1 ?? 0]
+array[:1 ?? false]
+array[:1 ?? greet]
 array[:1] | findLastIndex(false)
+array[:1] | sortBy(#)
 array[:1] | sum(#)
 array[:]
+array[:] | map(f64)
 array[:] | reduce(f64)
 array[:]?.[i]
 array[:i]
+array[:i] ?? !ok
+array[:i] | map(#)
 array[:i] | map(f64)
 array[:i] | reduce($env)
+array[:i] | reduce(0)
 array[:i] | sortBy(array)
+array[:i] | sortBy(ok)
 array[:int(1.0)]
+array[:max(i)]
+array[:nil ?? 0]
 array[:reduce(array, 1)]
+array[:sum(array)]
 array[array?.[i]:]
 array[bitnot(1):]
 array[i % 1:]
 array[i:]
+array[i:] ?? list
 array[i:] | findIndex(false)
 array[i:] | groupBy(1)
+array[i:]?.[i]
+array[int(1):]
 array[len($env):]
+array[max(0):]
 array[sum(array):]
+bitand($env.i, i)
+bitand(1, 1) | median(0)
 bitand(1, i) * i
 bitand(i, 0) + f64
+bitand(i, 0) > i
 bitand(i, i)
 bitand(i, sum(array))
 bitnand($env.i, i)
+bitnand(-i, i)
+bitnand(i + i, i)
 bitnand(i, i)
+bitnand(i, i) % i
+bitnand(sum(array), i)
 bitnot($env | findIndex(true))
 bitnot($env | findLastIndex(ok))
+bitnot($env | findLastIndex(true))
 bitnot($env.i)
 bitnot($env?.[str]?.[i])
 bitnot($env?.i)
+bitnot(-$env.i)
+bitnot(-0 ?? 1)
+bitnot(-0)
+bitnot(-1)
+bitnot(-i)
+bitnot(-min(array, 1.0))
 bitnot(0 * 1)
 bitnot(0 * i)
+bitnot(0 + 1)
 bitnot(0 - 0)
 bitnot(0 - 1)
+bitnot(0 - i)
+bitnot(0 ?? $env)
+bitnot(0 ?? 1.0)
+bitnot(0 ?? foo)
+bitnot(0 ?? greet)
+bitnot(0 ?? i)
+bitnot(0 ?? str)
 bitnot(0 | min(0))
+bitnot(0) + f64
+bitnot(0) + i
+bitnot(0) - $env.i
 bitnot(0) < f64
+bitnot(0) <= f64
 bitnot(0) == $env?.[Bar]
+bitnot(0) > $env?.i
+bitnot(0) ?? array
+bitnot(0) ?? ok
 bitnot(0) in array
+bitnot(0) not in array
 bitnot(0) | min(array, 0)
+bitnot(1 % 1)
 bitnot(1 % i)
 bitnot(1 * 0)
+bitnot(1 + 1)
 bitnot(1 - i)
+bitnot(1 ?? $env)
+bitnot(1 ?? 0)
+bitnot(1 ?? 1)
+bitnot(1 ?? foo)
+bitnot(1 ?? list)
+bitnot(1 ?? ok)
+bitnot(1 ?? true)
+bitnot(1 | bitshr(i))
 bitnot(1 | min(i))
+bitnot(1) != i
 bitnot(1) != i && false
+bitnot(1) * i
+bitnot(1) - f64
 bitnot(1) == f64
+bitnot(1) > i
+bitnot(1) ?? list
+bitnot(1) ^ f64
+bitnot(1) | bitand(1)
+bitnot(abs(0))
+bitnot(abs(1))
 bitnot(abs(i))
 bitnot(array | count(false))
 bitnot(array | count(ok))
+bitnot(array | findIndex(ok))
+bitnot(array | findLast(true))
+bitnot(array | reduce(#))
+bitnot(array | reduce(i))
 bitnot(array | sum(#))
 bitnot(array | sum(i))
 bitnot(array?.[0])
 bitnot(array?.[i])
 bitnot(bitand(1, 0))
+bitnot(bitnot(0 ?? foo))
 bitnot(bitnot(0))
 bitnot(bitnot(1))
 bitnot(bitnot(i))
 bitnot(count(array, false))
+bitnot(count(array, true))
+bitnot(count(list, false))
 bitnot(count(list, ok))
 bitnot(false ? nil : 1)
 bitnot(false ?: 1)
 bitnot(findIndex($env, ok))
 bitnot(findIndex(array, ok))
+bitnot(findIndex(list, ok))
 bitnot(findLastIndex(array, true))
+bitnot(findLastIndex(list, ok))
 bitnot(first(array))
 bitnot(i % i)
 bitnot(i * 0)
 bitnot(i * 1)
 bitnot(i + 0)
+bitnot(i - 0)
+bitnot(i - 1)
+bitnot(i ?? $env)
+bitnot(i ?? 0)
+bitnot(i ?? array)
+bitnot(i ?? foo)
+bitnot(i ?? list)
+bitnot(i ?? ok)
+bitnot(i ?? str)
+bitnot(i ?? true)
 bitnot(i | add(i))
 bitnot(i | min(1.0))
 bitnot(i)
+bitnot(i) != f64
+bitnot(i) != i
+bitnot(i) * -1.0
 bitnot(i) + i
 bitnot(i) - i
+bitnot(i) > f64
+bitnot(i) ?? $env.str
+bitnot(i) ?? ok
+bitnot(i) | bitshr(0)
+bitnot(i) | median(array)
 bitnot(if false { f64 } else { 0 })
+bitnot(if true { 1 } else { 0 })
 bitnot(if true { 1 } else { foo })
+bitnot(int(0))
 bitnot(int(1))
 bitnot(int(1.0))
 bitnot(int(f64))
+bitnot(int(f64)) ** i
+bitnot(int(i))
 bitnot(last(array))
 bitnot(len($env))
 bitnot(len(array))
+bitnot(len(list))
 bitnot(len(str))
+bitnot(list | count(true))
+bitnot(list | findIndex(ok))
 bitnot(list | findLastIndex(ok))
 bitnot(list | findLastIndex(true))
+bitnot(list | reduce(1))
+bitnot(list | sum(1))
 bitnot(max(0))
 bitnot(max(1))
 bitnot(max(1, 0))
+bitnot(max(array))
 bitnot(max(array, 0))
 bitnot(max(i))
 bitnot(min(0))
+bitnot(min(1))
 bitnot(min(array))
 bitnot(min(i))
 bitnot(min(i, 0))
+bitnot(nil ?? 1)
+bitnot(nil ?? i)
 bitnot(reduce(array, #))
 bitnot(reduce(array, 0))
 bitnot(reduce(list, i))
+bitnot(reduce(reverse(list), #index))
+bitnot(sum($env, 0))
+bitnot(sum($env, 1))
 bitnot(sum(array))
 bitnot(sum(array, #))
 bitnot(sum(list, 0))
+bitnot(sum(list, 1))
+bitnot(sum(list, i))
 bitor($env.i, i)
+bitor(1, i) > f64
+bitor(i, 1) ?? add
 bitor(i, array?.[i])
 bitor(i, i)
 bitor(i, len(list))
+bitor(i, list | count(true))
 bitshl(i, $env?.i)
 bitshl(i, i)
+bitshl(int(f64), i)
+bitshr(0, 1) + f64
+bitshr(1, 0) + i
 bitshr(i, $env?.i)
 bitshr(i, i)
 bitshr(i, sum(array))
+bitushr(1, 0) .. i
+bitushr(array | count(ok), i)
+bitushr(i, $env?.i)
 bitushr(i, i)
+bitxor(i, 1 ?? array)
 bitxor(i, i)
+bitxor(i, i) ?? $env?.f64
+ceil($env | findIndex(true))
+ceil($env | reduce(1.0, nil))
 ceil($env | sum(0))
+ceil($env | sum(1))
+ceil($env | sum(1.0))
 ceil($env | sum(f64))
 ceil($env | sum(i))
 ceil($env.f64)
+ceil($env.f64) not in array
 ceil($env.i)
 ceil($env?.[str] | sum(1.0))
 ceil($env?.array | findLast(ok))
+ceil($env?.array?.[i])
 ceil($env?.f64)
 ceil($env?.i)
 ceil($env?.i) < f64
+ceil(--i)
+ceil(-0)
+ceil(-1)
+ceil(-1.0)
+ceil(-f64)
+ceil(-i)
+ceil(0 * 0)
 ceil(0 * 1)
 ceil(0 * 1.0)
+ceil(0 * f64)
 ceil(0 ** 1)
 ceil(0 ** 1.0)
 ceil(0 ** f64)
+ceil(0 + 0)
 ceil(0 + 1)
 ceil(0 + 1.0)
 ceil(0 + i)
 ceil(0 - 0)
 ceil(0 - 1.0)
+ceil(0 - f64)
 ceil(0 - i)
+ceil(0 / 0)
 ceil(0 / 1)
 ceil(0 / 1.0)
+ceil(0 / f64)
+ceil(0 / i)
+ceil(0 ?? $env)
+ceil(0 ?? 0)
+ceil(0 ?? 1)
+ceil(0 ?? array)
+ceil(0 ?? f64)
+ceil(0 ?? false)
+ceil(0 ?? foo)
+ceil(0 ?? greet)
+ceil(0 ?? list)
+ceil(0 ?? nil)
+ceil(0 ?? ok)
+ceil(0 ?? true)
 ceil(0 ^ 0)
 ceil(0 ^ 1.0)
 ceil(0 ^ f64)
@@ -6525,51 +13557,122 @@ ceil(0 ^ i)
 ceil(0 | add(i))
 ceil(0 | bitshl(i))
 ceil(0 | median(1.0))
+ceil(0) != $env?.[String]
 ceil(0) != f64
+ceil(0) * f64
+ceil(0) ** 0 ^ 1.0
+ceil(0) ** i
+ceil(0) / i
 ceil(0) <= f64
+ceil(0) ?? list
+ceil(0) ?? type(1.0)
+ceil(0) in {foo: greet}?.str
 ceil(0.0)
+ceil(0.1)
 ceil(1 % 1)
+ceil(1 * 0)
 ceil(1 * f64)
+ceil(1 ** 1)
 ceil(1 ** 1.0)
 ceil(1 ** f64)
+ceil(1 + 0)
+ceil(1 + 1.0)
 ceil(1 + f64)
 ceil(1 + i)
+ceil(1 - 0)
 ceil(1 - 1.0)
+ceil(1 / 1.0)
+ceil(1 ?? $env)
+ceil(1 ?? f64)
+ceil(1 ?? greet)
+ceil(1 ?? i)
+ceil(1 ?? nil)
+ceil(1 ?? true)
 ceil(1 ^ 1.0)
+ceil(1 ^ i)
 ceil(1 | bitor(0))
+ceil(1 | min(1.0))
 ceil(1) != i
+ceil(1) - i
+ceil(1) / i
 ceil(1) > f64
+ceil(1) ?? i
 ceil(1) ^ i
 ceil(1) | median(1.0, 1)
 ceil(1) | min(array)
+ceil(1); f64
 ceil(1.0 * 0)
 ceil(1.0 * 1)
 ceil(1.0 * 1.0)
+ceil(1.0 * f64)
 ceil(1.0 * i)
+ceil(1.0 ** 1)
+ceil(1.0 ** 1.0)
 ceil(1.0 ** i)
 ceil(1.0 + 0)
 ceil(1.0 + 1)
 ceil(1.0 + 1.0)
+ceil(1.0 + f64)
 ceil(1.0 + i)
 ceil(1.0 - 0)
 ceil(1.0 - 1)
 ceil(1.0 - 1.0)
 ceil(1.0 - f64)
 ceil(1.0 - i)
+ceil(1.0 / 0)
 ceil(1.0 / 1)
 ceil(1.0 / 1.0)
 ceil(1.0 / f64)
+ceil(1.0 ?? $env)
+ceil(1.0 ?? 0)
+ceil(1.0 ?? 1)
+ceil(1.0 ?? add)
+ceil(1.0 ?? array)
+ceil(1.0 ?? f64)
+ceil(1.0 ?? false)
+ceil(1.0 ?? foo)
+ceil(1.0 ?? greet)
+ceil(1.0 ?? i)
+ceil(1.0 ?? list)
+ceil(1.0 ?? nil)
+ceil(1.0 ?? ok)
+ceil(1.0 ?? true)
 ceil(1.0 ^ 0)
+ceil(1.0 ^ 1)
 ceil(1.0 ^ 1.0)
 ceil(1.0 ^ f64)
+ceil(1.0 ^ i)
+ceil(1.0 | max(array))
+ceil(1.0 | mean(1, 1.0))
+ceil(1.0 | mean(1.0))
+ceil(1.0 | median(array))
 ceil(1.0 | min(1))
+ceil(1.0) != $env or $env
+ceil(1.0) != f64
+ceil(1.0) ** f64
+ceil(1.0) <= f64
+ceil(1.0) <= i
 ceil(1.0) == nil ? foo : str
+ceil(1.0) > i
 ceil(1.0) >= f64
+ceil(1.0) ?? add
+ceil(1.0) ?? list
 ceil(1.0) not in array
 ceil(1.0) | mean(1)
+ceil(1.1)
 ceil(abs(0))
+ceil(abs(1.0))
 ceil(abs(f64))
 ceil(abs(i))
+ceil(array | count(ok))
+ceil(array | mean(1.0))
+ceil(array | reduce(#))
+ceil(array | reduce(#, greet))
+ceil(array | reduce(i, f64))
+ceil(array | sum(#))
+ceil(array | sum(0))
+ceil(array | sum(f64))
+ceil(array?.[0])
 ceil(array?.[i])
 ceil(bitnot(0))
 ceil(bitnot(1))
@@ -6577,36 +13680,67 @@ ceil(ceil(0))
 ceil(ceil(1))
 ceil(ceil(1.0))
 ceil(ceil(f64))
+ceil(ceil(i))
 ceil(count($env, false))
+ceil(count($env, true))
 ceil(f64 * 0)
+ceil(f64 * 1)
+ceil(f64 * 1.0)
+ceil(f64 * f64)
 ceil(f64 ** 0)
 ceil(f64 ** 1)
 ceil(f64 ** 1.0)
 ceil(f64 ** i)
+ceil(f64 + 1)
 ceil(f64 + 1.0)
 ceil(f64 + f64)
 ceil(f64 - 1)
+ceil(f64 - 1.0)
+ceil(f64 / 0)
 ceil(f64 / 1)
 ceil(f64 / 1.0)
 ceil(f64 / f64)
 ceil(f64 / i)
+ceil(f64 ?? $env)
+ceil(f64 ?? 0)
+ceil(f64 ?? 1.0)
+ceil(f64 ?? array)
+ceil(f64 ?? f64)
+ceil(f64 ?? false)
+ceil(f64 ?? greet)
+ceil(f64 ?? i)
+ceil(f64 ?? true)
+ceil(f64 ^ 0)
 ceil(f64 ^ 1.0)
 ceil(f64 ^ i)
+ceil(f64 | max(1))
+ceil(f64 | median(1))
 ceil(f64 | min(1.0))
 ceil(f64)
+ceil(f64) != -f64
 ceil(f64) != i
 ceil(f64) * f64
 ceil(f64) * i
+ceil(f64) - i
+ceil(f64) / 1 + i
 ceil(f64) == f64
 ceil(f64) == i
+ceil(f64) ^ f64
 ceil(f64) ^ i
+ceil(f64) | median(1)
 ceil(f64) | median(1.0, i, i)
+ceil(false ? 1.0 : 1)
 ceil(false ?: 0)
 ceil(false ?: 1)
+ceil(false ?: i)
 ceil(findIndex($env, true))
 ceil(findIndex(array, true))
+ceil(findLast(array, ok))
 ceil(findLastIndex($env, true))
+ceil(findLastIndex(array, true))
 ceil(first(array))
+ceil(float(0))
+ceil(float(1))
 ceil(float(1.0))
 ceil(float(f64))
 ceil(float(i))
@@ -6614,33 +13748,54 @@ ceil(floor(0))
 ceil(floor(1))
 ceil(floor(1.0))
 ceil(floor(f64))
+ceil(floor(f64)) ?? list
 ceil(floor(i))
+ceil(i % 1) not in array
 ceil(i % i)
 ceil(i * 1)
 ceil(i * 1.0)
+ceil(i * i)
 ceil(i ** 0)
 ceil(i ** 1)
 ceil(i ** 1.0)
+ceil(i ** f64)
 ceil(i + 1)
+ceil(i + 1.0)
 ceil(i + i)
 ceil(i - 0)
 ceil(i - 1.0)
 ceil(i - i)
+ceil(i / 0)
 ceil(i / 1)
 ceil(i / 1.0)
 ceil(i / f64)
 ceil(i / i)
+ceil(i ?? 0)
+ceil(i ?? add)
+ceil(i ?? array)
+ceil(i ?? foo)
+ceil(i ?? true)
 ceil(i ^ 0)
+ceil(i ^ 1)
+ceil(i ^ 1.0)
 ceil(i ^ f64)
 ceil(i ^ i)
 ceil(i | min(0))
 ceil(i | min(1.0))
+ceil(i | min(array))
 ceil(i)
 ceil(i) != 0 ?: 1.0
+ceil(i) != i
+ceil(i) - i
 ceil(i) == i
 ceil(i) > i
 ceil(i) >= f64
+ceil(i) >= min(1)
+ceil(i) ?? -1.0
 ceil(if false { false } else { f64 })
+ceil(if false { str } else { 1.0 })
+ceil(if false { true } else { 0 })
+ceil(if ok { 0 } else { 0 })
 ceil(if true { 1.0 } else { 1.0 })
 ceil(if true { 1.0 } else { f64 })
 ceil(if true { i } else { foo })
@@ -6656,6 +13811,7 @@ ceil(len(array))
 ceil(len(list))
 ceil(len(str))
 ceil(let foobar = 1.0; foobar)
+ceil(let foobar = f64; foobar + foobar)
 ceil(list | reduce(0))
 ceil(list | reduce(0, 1.0))
 ceil(list | reduce(f64))
@@ -6664,8 +13820,11 @@ ceil(max(0))
 ceil(max(1))
 ceil(max(1.0))
 ceil(max(array))
+ceil(max(array, 1.0))
 ceil(max(f64))
+ceil(max(f64, f64))
 ceil(max(i))
+ceil(mean(0))
 ceil(mean(1))
 ceil(mean(1.0 ^ 1.0))
 ceil(mean(1.0))
@@ -6674,9 +13833,12 @@ ceil(mean(f64))
 ceil(mean(f64, 1))
 ceil(mean(i))
 ceil(mean(i, i, 0))
+ceil(mean(mean(1.0)))
 ceil(median(0))
+ceil(median(1))
 ceil(median(1.0))
 ceil(median(1.0, 0))
+ceil(median(1.0, array))
 ceil(median(1.0, i))
 ceil(median(array))
 ceil(median(f64))
@@ -6689,29 +13851,48 @@ ceil(min(1.0, f64))
 ceil(min(1.0, i))
 ceil(min(array))
 ceil(min(f64))
+ceil(min(i))
+ceil(nil ?? 1)
+ceil(nil ?? i)
+ceil(reduce($env, 1, $env))
 ceil(reduce(array, #))
 ceil(reduce(array, #acc))
 ceil(reduce(array, 1.0))
+ceil(reduce(array, f64))
 ceil(reduce(list, 0))
+ceil(reduce(list, 1))
 ceil(round(0))
+ceil(round(1))
 ceil(round(1.0))
+ceil(round(f64))
 ceil(round(i))
+ceil(sum($env, f64))
+ceil(sum($env.array))
 ceil(sum(array))
+ceil(sum(array, #))
 ceil(sum(list, 1.0))
+ceil(sum(list, f64))
+ceil({foo: 1.0}?.foo)
 concat($env | map(1.0))
 concat($env | map(1.0))[:i]
 concat($env | map(add))
 concat($env | map(array))
 concat($env | map(foo))
+concat($env | map(greet))
 concat($env.array)
 concat($env.list)
+concat($env?.array | sortBy(#))
 concat($env?.array)
 concat($env?.list)
+concat(0 .. 1)
 concat(0 .. i)
 concat(1 .. 0)
 concat(1 .. 1)
+concat(1 .. i)
 concat(1..i)
+concat([$env, $env])
 concat([$env, 1])
+concat([$env, add])
 concat([$env, nil])
 concat([$env])
 concat([0])
@@ -6720,177 +13901,312 @@ concat([1.0 - 1.0])
 concat([1.0, $env])
 concat([1.0])
 concat([1])
+concat([add, $env])
+concat([add])
+concat([array, 1.0])
+concat([array, 1])
 concat([array])
 concat([f64, foo])
+concat([f64])
 concat([false, $env])
 concat([false])
+concat([foo, 1.0])
 concat([foo, array])
 concat([foo])
 concat([greet, 0])
 concat([greet])
 concat([i, 1.0])
+concat([i])
 concat([list])
 concat([nil])
 concat([ok, $env])
 concat([ok])
 concat([str])
+concat([true, list])
+concat([true, str])
 concat([true])
 concat([true], array)
+concat(array ?? $env)
+concat(array ?? 1)
+concat(array ?? add)
+concat(array ?? f64)
+concat(array ?? greet)
+concat(array ?? nil)
+concat(array ?? true)
 concat(array | map(#))
+concat(array | map($env))
 concat(array | map(foo))
 concat(array | sortBy(#))
 concat(array | sortBy(f64))
 concat(array | sortBy(i))
 concat(array | take(0))
 concat(array)
+concat(array) == array
+concat(array) == list
+concat(array) | all(ok)
+concat(array) | any(false)
+concat(array) | any(ok)
+concat(array) | count(1.0 >= f64)
+concat(array) | count(ok)
+concat(array) | groupBy(#)
+concat(array) | groupBy(0)
 concat(array) | groupBy(1.0)
+concat(array) | groupBy(true)
+concat(array) | map(0)
+concat(array) | map(1.0)
+concat(array) | map(f64)
 concat(array) | map(list)
+concat(array) | map(ok)
+concat(array) | max(1.0)
 concat(array) | reduce(#)
+concat(array) | reduce(1, foo)
 concat(array) | reduce(str)
 concat(array) | sortBy(f64)
+concat(array) | sum(#)
 concat(array)?.[i]
 concat(array, [greet])
 concat(array, array)
 concat(array, array)?.[i]
+concat(array, array, [list])
 concat(array, list)
 concat(array[0:])
+concat(array[1:])
+concat(array[:0])
 concat(array[:1])
 concat(array[:])
 concat(array[i:])
 concat(concat(array))
 concat(concat(array, array))
+concat(concat(list))
 concat(false ?: array)
 concat(false ?: list)
 concat(filter($env, false))
+concat(flatten($env.array))
 concat(flatten(array))
 concat(flatten(list))
+concat(i .. 0)
+concat(i..i)
 concat(keys($env))
+concat(keys({foo: array, foo: i}))
+concat(list ?? $env)
+concat(list ?? 1)
+concat(list ?? 1.0)
+concat(list ?? foo)
+concat(list ?? i)
+concat(list ?? str)
+concat(list ?? true)
 concat(list | filter(ok))
 concat(list | map(#))
+concat(list | map($env))
+concat(list | map(.String))
 concat(list | map(1))
 concat(list | map(1.0))
+concat(list | map(foo))
+concat(list | map(list), array)
+concat(list | sortBy(1.0))
+concat(list | sortBy(i))
 concat(list)
+concat(list) == [1, str]
+concat(list) | any(ok)
 concat(list) | count(false)
+concat(list) | findIndex(true)
 concat(list) | groupBy(#)
+concat(list) | groupBy(0)
+concat(list) | groupBy(1)
 concat(list) | groupBy(1.0)
+concat(list) | groupBy(foo)
 concat(list) | map(0)
 concat(list) | map(add)
+concat(list) | map(f64)
 concat(list) | map(foo)
 concat(list) | none(ok)
 concat(list) | reduce(#)
 concat(list) | reduce(1.0, foo)
+concat(list) | reduce(f64)
+concat(list) | reduce(foo)
 concat(list) | reduce(i, str)
 concat(list) | sum(1)
 concat(list) | sum(i)
 concat(list)?.[i]
+concat(list, $env.array)
 concat(list, array)
+concat(list, array)?.[i]
 concat(list, list | sortBy(i))
 concat(list, list)
 concat(list, list) | any(true)
+concat(list, list)?.[i]
+concat(list[1:])
 concat(map($env, #index))
 concat(map($env, $env))
+concat(map($env, 1.0))
+concat(map($env, array))
 concat(map($env, array), list)
+concat(map($env, f64))
 concat(map($env, foo))
+concat(map($env, list))
+concat(map($env, ok))
 concat(map(array, #))
 concat(map(array, $env))
 concat(map(array, 1))
 concat(map(array, 1.0))
 concat(map(array, f64))
+concat(map(array, foo))
 concat(map(list, #))
 concat(map(list, $env))
 concat(map(list, 0))
 concat(map(list, 1.0))
+concat(map(list, add))
 concat(map(list, greet))
 concat(map(list, i))
+concat(map(list, str))
 concat(reduce(list, array))
 concat(reverse(array))
 concat(reverse(list))
 concat(sort($env))
 concat(sort(array))
 concat(sortBy(array, #))
+concat(sortBy(array, 1.0))
+concat(sortBy(list, 1.0))
+concat(sortBy(list, i))
 concat(toPairs($env))
 concat(toPairs({foo: false, foo: add}))
 concat(uniq(array))
 concat(values($env))
+count($env ?? f64, .greet and false)
 count($env | filter(false))
+count($env | map(false))
 count($env | map(foo), ok)
 count($env | map(ok))
 count($env | map(true))
 count($env, false) ^ i
+count($env, ok) | bitushr(0)
 count($env, true) ** i
+count($env, true) <= 1.0 == $env
+count($env, true) <= f64
+count($env, true) > i
 count($env.list, foo != foo)
 count($env.list, ok)
 count($env?.[str], true != nil)
 count($env?.array, ok)
 count($env?.list, ok)
+count(0 .. 0, $env == list)
 count(1 .. 0)
 count([$env && false])
+count([$env, true], 1 == $env)
 count([false, false])
+count([false, true])
 count([false])
 count([false], #)
+count([foo] | filter(false))
+count([nil], 1.0 >= 1.0)
 count([ok])
+count([ok], #)
 count([true])
+count(array ?? 0, 1.0 not in array)
+count(array | filter(false))
+count(array | filter(nil == #))
 count(array | map(false))
 count(array | map(ok))
+count(array, !false)
+count(array, # != #)
 count(array, # != i)
+count(array, # <= #)
+count(array, # == nil)
 count(array, # > #)
+count(array, # >= 1)
+count(array, # >= f64)
 count(array, # >= i)
 count(array, # not in array)
 count(array, $env != #)
 count(array, $env.ok)
 count(array, $env?.false != nil and ok)
+count(array, 0 <= 1.0)
+count(array, 0 == #)
+count(array, 0 == $env)
 count(array, 1 != nil)
+count(array, 1 == f64)
+count(array, 1 > #)
 count(array, 1.0 != #)
+count(array, 1.0 != nil)
+count(array, 1.0 == $env)
+count(array, 1.0 == nil)
 count(array, array | none(true))
+count(array, f64 < #)
 count(array, false and $env)
 count(array, false) <= 1 ^ i
 count(array, false) ^ f64
 count(array, foo in list)
 count(array, i >= #)
 count(array, nil == $env)
+count(array, nil == 1.0)
+count(array, nil == nil)
+count(array, nil ?? false)
+count(array, ok != false)
 count(array, ok)
+count(array, ok) ?? ok
 count(array, ok) ^ f64
+count(array, true == ok)
 count(array, true) in array
 count(array[:0])
 count(filter($env, false))
 count(filter(list, # != #))
+count(filter(list, false))
+count(groupBy(list, 1.0).str)
 count(i .. 0)
+count(keys($env), ok || #)
+count(list ?? $env, $env?.ok)
 count(list | filter(false))
 count(list | map(false))
 count(list | map(true))
 count(list, # != foo)
 count(list, # != nil)
+count(list, # == foo)
 count(list, #.Bar == nil)
+count(list, #.Bar matches .Bar)
 count(list, $env == $env)
 count(list, $env in array)
+count(list, $env?.ok)
 count(list, 0 != nil)
 count(list, 0 <= f64)
 count(list, 0 == i)
 count(list, 1 < i)
 count(list, 1.0 < 1.0)
+count(list, 1.0 == nil)
 count(list, [#] | all(true))
 count(list, add == $env)
 count(list, f64 == nil)
+count(list, false) ?? i
 count(list, foo != $env)
+count(list, greet != $env)
+count(list, i == nil)
 count(list, nil != 1.0)
 count(list, nil != true)
+count(list, not ok)
+count(list, ok ?: .String)
 count(list, ok)
 count(list, ok) .. 1 | take(1)
 count(list, str != $env)
 count(list, true != nil)
+count(list, true) >= f64
 count(list[:0])
+count(list[:i], ok)
+count(list[array?.[i]:])
 count(map($env, $env), ok == $env)
 count(map($env, false))
 count(map($env, ok))
 count(map($env, true))
 count(map($env, true)) >= f64
 count(map(array, false))
+count(map(array, ok))
 count(map(list, false))
 count(map(list, ok))
+count(map(list, true))
 count(sort($env))
 count(sort($env), # < #.str)
 count(sort($env), #)
 count(sort($env), #.str && #)
+count(sort($env), -#.add)
+count(sort($env), .greet?.[greet])
 count(toPairs($env), 0 in #)
 date(str, str)
 duration(string(0))
@@ -6898,6 +14214,9 @@ duration(toJSON(0))
 f64
 f64 != $env == false
 f64 != $env ?: false
+f64 != $env ?? f64
+f64 != $env ?? foo
+f64 != $env and $env
 f64 != $env or $env
 f64 != $env or ok
 f64 != $env || $env
@@ -6906,6 +14225,7 @@ f64 != $env.f64
 f64 != $env.i
 f64 != $env?.$env
 f64 != $env?.Bar
+f64 != $env?.Bar?.String
 f64 != $env?.Bar?.[ok]
 f64 != $env?.Bar?.list()
 f64 != $env?.String
@@ -6920,206 +14240,416 @@ f64 != $env?.foobar
 f64 != $env?.i
 f64 != $env?.nil
 f64 != $env?.true
+f64 != -0
+f64 != -1.0
+f64 != 0 != nil
+f64 != 0 != ok
 f64 != 0 != true
+f64 != 0 ** i
 f64 != 0 + i
 f64 != 0 - i
 f64 != 0 == $env
+f64 != 0 == false
 f64 != 0 == nil
+f64 != 0 ?: 1.0
+f64 != 0 || $env
+f64 != 1 ** i
+f64 != 1 + 1.0
 f64 != 1 / i
+f64 != 1 == $env
+f64 != 1 ?? $env
 f64 != 1 and $env
 f64 != 1 || $env
 f64 != 1.0 != $env
 f64 != 1.0 != nil
+f64 != 1.0 * 1.0
+f64 != 1.0 ** 0
+f64 != 1.0 ** i
+f64 != 1.0 + 1.0
 f64 != 1.0 - 0
 f64 != 1.0 - 1
 f64 != 1.0 - i
 f64 != 1.0 == true
 f64 != 1.0 ?: add
+f64 != 1.0 ?? $env?.[greet]
+f64 != 1.0 ?? i
+f64 != 1.0 ^ 1.0
+f64 != 1.0 ^ i
+f64 != 1.0 and $env
 f64 != 1.0 and false
 f64 != 1.0 or $env
+f64 != 1.0 or true
+f64 != abs(1.0)
+f64 != abs(i)
 f64 != array?.[i]
+f64 != bitxor(i, i)
 f64 != f64
+f64 != f64 != $env
 f64 != f64 && $env
+f64 != f64 + 0
+f64 != f64 == ok
+f64 != f64 ?? foo
+f64 != f64 ?? greet
+f64 != f64 ^ f64 && false
 f64 != f64 and true
+f64 != false ?? foo
+f64 != false ?? list
+f64 != findIndex(list, true)
+f64 != first($env)
 f64 != float(i)
 f64 != floor(f64)
 f64 != floor(i)
+f64 != foo ?? 0
+f64 != greet ?? 1
+f64 != greet ?? foo
+f64 != greet ?? true
 f64 != i
 f64 != i != false
 f64 != i && $env
 f64 != i * f64
+f64 != i + 1
+f64 != i / 1
+f64 != i == nil
+f64 != i ?? 0
+f64 != i ?? f64
+f64 != i ^ 0
+f64 != i ^ f64
 f64 != i and $env
 f64 != i and nil not in array
 f64 != i and true
+f64 != i or ok
 f64 != int(1.0)
 f64 != last($env)
+f64 != last(array)
 f64 != len($env)
+f64 != len(array)
+f64 != max(f64)
+f64 != max(i)
 f64 != mean(0)
 f64 != mean(1.0)
 f64 != mean(array)
+f64 != mean(f64)
 f64 != median(1.0)
+f64 != median(array)
+f64 != median(f64)
+f64 != min(0)
+f64 != min(1.0)
+f64 != min(array, 1)
+f64 != nil != $env
 f64 != nil != false
+f64 != nil != nil
 f64 != nil && $env
+f64 != nil ?: greet
+f64 != nil ?? 1.0
+f64 != nil ?? nil
 f64 != nil or $env
+f64 != nil || false
+f64 != ok ?? $env
+f64 != round(1)
 f64 != round(1.0)
+f64 != str ?? $env
+f64 != sum($env, 0)
+f64 != sum(array)
 f64 * $env.f64
 f64 * $env.i
 f64 * $env?.f64
 f64 * $env?.i
+f64 * -f64
+f64 * -i
 f64 * 0 * 1.0
 f64 * 0 + 1
 f64 * 0 - 1.0
+f64 * 0 - f64
+f64 * 0 == $env
+f64 * 0 ?? str
+f64 * 0 ^ f64
+f64 * 0 ^ max(i)
+f64 * 0 in array
 f64 * 1 != nil
 f64 * 1 * 0
 f64 * 1 * i
+f64 * 1 < 1.0
+f64 * 1 <= 0
 f64 * 1 <= i
 f64 * 1 == nil
+f64 * 1 ?? $env?.String
+f64 * 1 ?? false
+f64 * 1 ?? i
 f64 * 1 in array
 f64 * 1.0
+f64 * 1.0 != $env
 f64 * 1.0 != i
 f64 * 1.0 * 1.0
 f64 * 1.0 * f64
 f64 * 1.0 ** f64
 f64 * 1.0 < 0
 f64 * 1.0 < 1
+f64 * 1.0 <= f64
+f64 * 1.0 == $env
+f64 * 1.0 == 1
+f64 * 1.0 == nil
+f64 * 1.0 > 0
+f64 * 1.0 ?? str
+f64 * 1.0 ^ f64
 f64 * 1.0 | max(0)
 f64 * abs(1.0)
 f64 * array?.[1]
 f64 * array?.[i]
 f64 * bitnot(0)
+f64 * ceil(1.0)
+f64 * ceil(f64)
 f64 * f64
 f64 * f64 * i
+f64 * f64 + $env.f64
+f64 * f64 - f64
 f64 * f64 / i
 f64 * f64 > 1
+f64 * f64 ?? true
+f64 * f64 ^ 1.0
 f64 * float(0)
 f64 * float(f64)
 f64 * float(i)
+f64 * floor(f64)
 f64 * i
 f64 * i != $env?.i
 f64 * i != sum(array)
 f64 * i ** 1.0
+f64 * i == i
 f64 * i == nil
 f64 * i > $env?.f64
+f64 * i ?? $env
+f64 * i ?? groupBy($env, .greet)
+f64 * i ?? str
+f64 * i | max(array)
+f64 * int(0)
 f64 * int(1)
 f64 * int(1.0)
+f64 * int(i)
 f64 * len($env)
 f64 * len(foo.Bar)
 f64 * len(str)
+f64 * max(map(array, #))
+f64 * median(1.0)
+f64 * median(f64)
+f64 * min(1.0, 0)
 f64 * min(array)
+f64 * reduce(array, #)
+f64 * round(1.0)
+f64 * sum($env, 1)
 f64 * sum(array | sortBy(#))
+f64 * sum(array)
 f64 ** $env.f64
 f64 ** $env.i
+f64 ** $env?.array?.[i]
 f64 ** $env?.f64
 f64 ** $env?.i
+f64 ** -1
+f64 ** -1.0
+f64 ** -f64
+f64 ** -i
+f64 ** 0 * i
 f64 ** 0 ** f64
+f64 ** 0 < f64
+f64 ** 0 <= i
+f64 ** 0 > i
 f64 ** 0 >= 1.0
+f64 ** 0 ?? i
+f64 ** 0 ?? list / 0
+f64 ** 0 ?? ok
 f64 ** 1 != nil
 f64 ** 1 - i
 f64 ** 1 / 0
 f64 ** 1 < f64
+f64 ** 1 == i
+f64 ** 1 > len($env)
+f64 ** 1 ^ 1
 f64 ** 1.0 != $env
 f64 ** 1.0 != f64
 f64 ** 1.0 * 1.0
 f64 ** 1.0 + 0
 f64 ** 1.0 / i
 f64 ** 1.0 > 1
+f64 ** 1.0 > 1.0
+f64 ** 1.0 >= 1.0
+f64 ** 1.0 ?? f64
+f64 ** 1.0 ?? list
 f64 ** 1.0 ^ 1.0
+f64 ** 1.0 ^ f64
 f64 ** 1.0 not in array
 f64 ** abs(mean(1.0))
 f64 ** array?.[i]
 f64 ** bitnot(0)
 f64 ** f64
+f64 ** f64 != $env || $env
 f64 ** f64 * 0
 f64 ** f64 * i
 f64 ** f64 + 1.0
 f64 ** f64 - 1.0
+f64 ** f64 ?? $env?.[i]
 f64 ** f64 ^ i
 f64 ** f64 | median(0)
+f64 ** float(0)
 f64 ** float(1.0)
+f64 ** floor(1.0)
+f64 ** floor(i)
 f64 ** i
+f64 ** i + $env?.f64
+f64 ** i == nil
 f64 ** i >= i
+f64 ** i ?? $env
+f64 ** i ?? true
 f64 ** i ^ i
+f64 ** int(i)
 f64 ** mean(1.0)
 f64 ** mean(f64)
 f64 ** min(1.0)
 f64 ** min(f64)
 f64 ** round(f64)
 f64 ** sum(array)
+f64 + $env or true
 f64 + $env.f64
 f64 + $env.i
 f64 + $env?.f64
 f64 + $env?.i
+f64 + -0
+f64 + -1
+f64 + -1.0
+f64 + -f64
+f64 + -i
 f64 + 0 * f64
+f64 + 0 + array?.[i]
+f64 + 0 - 1.0
+f64 + 0 - f64
+f64 + 0 ?? !false
 f64 + 0 ^ 1.0
 f64 + 0 ^ f64
+f64 + 0.1
 f64 + 1 * 0
+f64 + 1 * f64
 f64 + 1 * i
+f64 + 1 ** 1.0
 f64 + 1 / 1.0
 f64 + 1 < 1.0
+f64 + 1 <= 1.0
 f64 + 1 > $env and false
+f64 + 1 > 0
+f64 + 1 ?? foo
 f64 + 1 ^ f64
 f64 + 1.0 != f64
+f64 + 1.0 - f64
 f64 + 1.0 < 1.0
 f64 + 1.0 < int(0)
 f64 + 1.0 <= $env.i
 f64 + 1.0 <= 0
+f64 + 1.0 <= 1.0
 f64 + 1.0 == 0
+f64 + 1.0 == i
 f64 + 1.0 == nil
+f64 + 1.0 > 0
+f64 + 1.0 > i
+f64 + 1.0 >= 1
+f64 + 1.0 ?? 1
 f64 + 1.0 ^ 0
 f64 + 1.0 ^ 1.0
 f64 + 1.0 not in array
 f64 + 1.0 | max(1.0)
+f64 + abs(f64)
 f64 + abs(i)
 f64 + array?.[i]
 f64 + bitnot(i)
+f64 + ceil(0)
 f64 + ceil(1)
+f64 + ceil(1.0)
 f64 + count($env, true)
 f64 + f64
 f64 + f64 ** 1.0
+f64 + f64 ?? 1
 f64 + f64 ^ i
+f64 + floor(0)
+f64 + floor(i)
 f64 + i
 f64 + i != 0
 f64 + i ** 1
 f64 + i - 1
 f64 + i / i
+f64 + i == f64
 f64 + i == i
 f64 + i > 1.0
+f64 + i > f64
 f64 + i in array
+f64 + i not in array
 f64 + int(i)
+f64 + mean(1.0)
+f64 + median(f64)
 f64 + min(f64)
+f64 + min(i)
+f64 + nil ?? i ?? greet
+f64 + round(1.0)
 f64 + sum(array)
 f64 + sum(list, 1)
 f64 - $env.f64
 f64 - $env.i
 f64 - $env?.f64
 f64 - $env?.i
+f64 - -0
+f64 - -1
+f64 - -1.0
+f64 - -i
+f64 - 0 % i
+f64 - 0 ** 1.0
 f64 - 0 / 1
 f64 - 0 / f64
 f64 - 0 < 0
 f64 - 0 < 1
 f64 - 0 > 0
 f64 - 0 > f64
+f64 - 0 in array
 f64 - 1 != $env
+f64 - 1 * $env.f64
+f64 - 1 <= -1
+f64 - 1 <= 1
 f64 - 1 <= 1 + f64
 f64 - 1 > i
+f64 - 1 ?? $env.ok
+f64 - 1 ^ i
 f64 - 1 not in $env?.[Bar]
 f64 - 1 | mean(1.0)
+f64 - 1.0 * 1
+f64 - 1.0 ** i
 f64 - 1.0 - 0
+f64 - 1.0 - 1
 f64 - 1.0 - 1.0
 f64 - 1.0 / i
+f64 - 1.0 < f64 + 0
+f64 - 1.0 <= i
 f64 - 1.0 == f64
+f64 - 1.0 == nil
 f64 - 1.0 > 1
+f64 - 1.0 ?? list
+f64 - 1.0 ^ f64
+f64 - 1.0 | mean(array)
+f64 - abs(0)
 f64 - array?.[i]
+f64 - bitnot(i)
 f64 - bitxor(i, i)
 f64 - ceil(f64)
+f64 - count(list, true)
 f64 - f64
 f64 - f64 < i
 f64 - f64 <= f64
+f64 - f64 > 0
+f64 - float(1.0)
 f64 - floor(0)
+f64 - floor(f64)
+f64 - floor(i)
 f64 - i
+f64 - i % 1
 f64 - i >= 1
 f64 - i >= i
+f64 - i ^ 1.0
 f64 - i | median(1.0)
+f64 - int(0)
+f64 - int(1.0)
 f64 - last(array)
 f64 - len(str)
 f64 - max(array)
@@ -7127,60 +14657,128 @@ f64 - max(f64)
 f64 - median(1.0)
 f64 - median(array)
 f64 - min(1.0, array)
+f64 - reduce(array, i)
+f64 - sum(array)
 f64 / $env.f64
 f64 / $env.i
 f64 / $env?.f64
 f64 / $env?.i
+f64 / -0
+f64 / -1
+f64 / -1.0
+f64 / -i
 f64 / 0 != 1.0
 f64 / 0 + i
 f64 / 0 - 1.0
+f64 / 0 < f64
+f64 / 0 ^ $env?.i
+f64 / 0 ^ 1.0
+f64 / 0 not in array
+f64 / 1 * f64
+f64 / 1 * i ?? 1.0
 f64 / 1 / 1.0
 f64 / 1 / i
 f64 / 1 <= 0
+f64 / 1 == 0
+f64 / 1 == int(f64)
+f64 / 1 ?? array
 f64 / 1.0 != 1
 f64 / 1.0 != f64
 f64 / 1.0 ** 1.0
 f64 / 1.0 - 1
+f64 / 1.0 / $env?.i
+f64 / 1.0 / 1.0
 f64 / 1.0 <= 1.0
+f64 / 1.0 == 1.0
+f64 / 1.0 > 1
 f64 / 1.0 >= 0
+f64 / 1.0 >= 1.0
+f64 / 1.0 ?? list
+f64 / 1.0 ?? nil + 1.0
+f64 / 1.0 ?? true >= 1.0
 f64 / 1.0 ^ 1.0
 f64 / 1.0 ^ f64
+f64 / 1.0 ^ i
 f64 / abs(1.0)
 f64 / abs(i)
 f64 / add(i, 1)
 f64 / array?.[i]
 f64 / ceil(1.0)
 f64 / f64
+f64 / f64 != 1
 f64 / f64 ** i
+f64 / f64 + 0
 f64 / f64 / 1.0
 f64 / f64 <= f64
+f64 / f64 ?? 0
+f64 / f64 ?? ok
+f64 / f64 not in array
 f64 / first(array)
 f64 / float(1.0)
 f64 / i
+f64 / i * i
+f64 / i - sum(array)
+f64 / i == 0
 f64 / i >= 1.0
+f64 / i ?? i
+f64 / i ?? nil
+f64 / i ^ 0 * 1.0
+f64 / i ^ 1.0
+f64 / int(f64)
 f64 / len($env)
+f64 / len(array)
 f64 / max(1)
 f64 / max(f64, f64)
+f64 / max(i)
+f64 / mean(0)
 f64 / mean(1)
+f64 / mean(1.0)
+f64 / mean(1.0, array)
 f64 / mean(array)
+f64 / min(array)
+f64 / nil ?? 1.0
+f64 / reduce(list, i)
+f64 / round(1.0)
+f64 / sum(array)
+f64 / sum(array, 0)
 f64 < $env.f64
 f64 < $env.i
 f64 < $env?.f64
 f64 < $env?.i
+f64 < -1.0
+f64 < -f64
 f64 < 0 % 1
+f64 < 0 * 1
 f64 < 0 ** f64
+f64 < 0 + 0
+f64 < 0 + 1
 f64 < 0 + 1.0
 f64 < 0 + i
 f64 < 0 < $env > $env
 f64 < 0 <= $env?.[array]
 f64 < 0 == false
+f64 < 0 == true
+f64 < 0 ?? array
+f64 < 0 ?? nil
+f64 < 0 ?? str
 f64 < 0 or true
 f64 < 1 % 1
+f64 < 1 ** 1.0
 f64 < 1 / 0
+f64 < 1 / 1.0
 f64 < 1 <= f64
+f64 < 1 > 1.0
+f64 < 1 >= 1
+f64 < 1 >= 1.0
+f64 < 1 ?? i
 f64 < 1 or ok
 f64 < 1 or true
+f64 < 1.0 != true
 f64 < 1.0 && $env
+f64 < 1.0 * 1.0
+f64 < 1.0 * i
+f64 < 1.0 ** 0
+f64 < 1.0 + f64
 f64 < 1.0 - 1.0
 f64 < 1.0 - f64
 f64 < 1.0 / 1
@@ -7190,23 +14788,44 @@ f64 < 1.0 < 1.0
 f64 < 1.0 <= i
 f64 < 1.0 == false
 f64 < 1.0 >= 1.0 == true
+f64 < 1.0 >= i
 f64 < 1.0 ?: true
+f64 < 1.0 ?? ok
+f64 < 1.0 and false
 f64 < abs(1)
+f64 < abs(1.0)
 f64 < array?.[i]
+f64 < bitnot(i)
 f64 < ceil(1.0)
 f64 < count(list, true)
 f64 < f64
+f64 < f64 < 1.0
+f64 < f64 <= 1.0
 f64 < f64 > 0
+f64 < f64 >= 1.0
 f64 < f64 ?: ok
+f64 < f64 ?? 1.0
+f64 < f64 ?? greet
+f64 < f64 and $env
 f64 < f64 in $env?.String
+f64 < findIndex($env, ok)
 f64 < float(1)
+f64 < float(f64)
 f64 < floor(1)
 f64 < floor(f64)
 f64 < i
 f64 < i != nil
+f64 < i % 1
 f64 < i % i
+f64 < i && $env
+f64 < i < $env.i
+f64 < i < max(0)
+f64 < i == nil
 f64 < i >= f64
+f64 < i ?? f64
+f64 < i ?? greet
 f64 < i || true
+f64 < len($env)
 f64 < max(array)
 f64 < max(f64)
 f64 < mean(f64)
@@ -7214,219 +14833,627 @@ f64 < median(array)
 f64 < min(0)
 f64 < min(1.0)
 f64 < min(i)
+f64 < nil ?? i
 f64 < round(1.0)
+f64 < sum($env, 1)
 f64 < sum(array)
 f64 <= $env.f64
 f64 <= $env.i
 f64 <= $env?.f64
 f64 <= $env?.i
+f64 <= -0
 f64 <= 0 ** 1.0
+f64 <= 0 - f64
+f64 <= 0 <= 1.0
 f64 <= 0 > i
+f64 <= 0 >= mean(1.0)
 f64 <= 0.1
+f64 <= 1 != true and $env
+f64 <= 1 && true
+f64 <= 1 * i
 f64 <= 1 - i
+f64 <= 1 / 1
 f64 <= 1 / f64
+f64 <= 1 >= 1.0
 f64 <= 1 >= f64
+f64 <= 1 ?? $env.f64
+f64 <= 1 ?? foo
 f64 <= 1 ^ 0
+f64 <= 1 ^ i
 f64 <= 1 or true
 f64 <= 1 || $env
+f64 <= 1.0
 f64 <= 1.0 != nil
+f64 <= 1.0 != true
 f64 <= 1.0 && $env
 f64 <= 1.0 && true
 f64 <= 1.0 * $env?.i
 f64 <= 1.0 * min(i)
+f64 <= 1.0 + 1.0
+f64 <= 1.0 / 1.0
+f64 <= 1.0 < 1.0 ^ i
 f64 <= 1.0 <= f64
+f64 <= 1.0 <= i
 f64 <= 1.0 <= mean(1.0)
 f64 <= 1.0 > 1
+f64 <= 1.0 > i
+f64 <= 1.0 ?? add
+f64 <= 1.0 ?? greet
+f64 <= 1.0 ?? str
+f64 <= 1.0 ^ 0
 f64 <= 1.0 ^ 1.0
+f64 <= 1.0 ^ f64
 f64 <= 1.0 and $env
 f64 <= 1.0 and ok
+f64 <= 1.0 || true
 f64 <= 1.1 <= 1
 f64 <= abs(0)
+f64 <= abs(1)
 f64 <= abs(f64)
 f64 <= add(i, i)
 f64 <= array?.[i]
 f64 <= bitnand(i, 1)
 f64 <= f64
 f64 <= f64 && $env
+f64 <= f64 * i
 f64 <= f64 - 0
+f64 <= f64 == false
+f64 <= f64 ?? $env
 f64 <= f64 and $env
+f64 <= f64 || $env
+f64 <= findIndex(list, ok)
 f64 <= floor(1.0)
 f64 <= i
 f64 <= i + f64
+f64 <= i - 0
 f64 <= i == $env?.Bar
 f64 <= i > i
+f64 <= i ?? ok
 f64 <= int(1.0)
+f64 <= last(array)
 f64 <= len(list)
+f64 <= mean(1)
+f64 <= mean(1.0)
 f64 <= mean(i)
 f64 <= median(1.0)
+f64 <= median(f64)
 f64 <= min(f64)
+f64 <= reduce(array, 1.0, true)
 f64 <= sum(array)
 f64 <= sum(array, #)
 f64 == $env && true
 f64 == $env == $env
 f64 == $env ? add : $env
+f64 == $env ?? add
+f64 == $env ?? greet
 f64 == $env or $env
+f64 == $env or ok
 f64 == $env.f64
 f64 == $env.i
 f64 == $env?.Bar
 f64 == $env?.String
 f64 == $env?.[Bar]
 f64 == $env?.[String]
+f64 == $env?.[String]?.[greet]
+f64 == $env?.[foobar]
 f64 == $env?.[str]
 f64 == $env?.f64
 f64 == $env?.foobar
 f64 == $env?.foobar?.str
 f64 == $env?.i
+f64 == -1
+f64 == -1.0
+f64 == 0 % i
 f64 == 0 && $env?.[add]
+f64 == 0 && 0 == nil
 f64 == 0 && sum($env)
+f64 == 0 ** 1.0
+f64 == 0 - 1.0
+f64 == 0 / $env.i
+f64 == 0 == nil
 f64 == 0 or ok
 f64 == 1 != ok
 f64 == 1 * i
+f64 == 1 + 1.0
 f64 == 1 - 1.0
 f64 == 1 - f64
+f64 == 1 ?: 1.0
+f64 == 1 ?? f64
+f64 == 1 || i <= 0
+f64 == 1.0 != false
 f64 == 1.0 ** 0
 f64 == 1.0 + f64
+f64 == 1.0 == nil
 f64 == 1.0 == ok
 f64 == 1.0 ?: nil
+f64 == 1.0 ?? 1
+f64 == 1.0 ?? ok
+f64 == 1.0 ^ 1.0
+f64 == 1.0 and ok
 f64 == 1.0 and true
 f64 == 1.0 || $env
 f64 == abs(1.0)
+f64 == abs(i)
+f64 == add ?? false
+f64 == add ?? greet
+f64 == add ?? list
+f64 == array ?? greet
 f64 == array?.[i]
+f64 == bitnot(i)
 f64 == bitor(i, 1)
+f64 == ceil(1)
+f64 == ceil(1.0)
 f64 == count(array, ok)
 f64 == f64
+f64 == f64 * 1
+f64 == f64 * f64
+f64 == f64 / 0
+f64 == f64 ?? false
 f64 == f64 ^ i
+f64 == f64 || false
 f64 == findLastIndex($env, true)
+f64 == floor(1)
+f64 == foo ?? f64
+f64 == foo ?? list
+f64 == greet ?? add
 f64 == i
+f64 == i % 1
+f64 == i - i
+f64 == i / f64
 f64 == i / i
+f64 == i ?? [foo]
+f64 == i ?? any($env, false)
+f64 == i ^ 0
+f64 == i or ok
+f64 == i || false
 f64 == int(f64)
+f64 == len(string(nil))
+f64 == list ?? $env
+f64 == list ?? array
+f64 == max(0)
 f64 == mean(1.0)
+f64 == median(1.0)
 f64 == median(i)
 f64 == min($env)
 f64 == min(1.0)
 f64 == nil != nil
 f64 == nil != ok
 f64 == nil ?: list
+f64 == nil or $env
 f64 == nil || max(array)
 f64 == nil || true
+f64 == ok ?? foo
+f64 == ok ?? str
+f64 == round(f64)
+f64 == str ?? 0
+f64 == str ?? i
+f64 == sum(array)
 f64 > $env.f64
 f64 > $env.i
 f64 > $env?.[str]?.[f64]
 f64 > $env?.f64
 f64 > $env?.i
+f64 > -0
+f64 > -1
+f64 > -1.0
 f64 > 0 + 1.0
+f64 > 0 / 1.0
+f64 > 0 / i
 f64 > 0 >= 0
 f64 > 0 >= 1.0
 f64 > 0 ? 1 : 1.0
+f64 > 0 ?? $env.f64
+f64 > 0 ?? false
+f64 > 0 ?? foo
 f64 > 0 and $env?.String
 f64 > 0 or true
+f64 > 0 || $env
+f64 > 1 != ok
+f64 > 1 && $env
+f64 > 1 * i
 f64 > 1 ** i
+f64 > 1 / 1.0
 f64 > 1 / f64
 f64 > 1 / i
 f64 > 1 <= i
 f64 > 1 >= f64
 f64 > 1 >= i
 f64 > 1 ? array : false
+f64 > 1 ?? list
 f64 > 1 or true
+f64 > 1.0 != nil
+f64 > 1.0 != ok
+f64 > 1.0 && $env
+f64 > 1.0 * 1.0
 f64 > 1.0 * i
 f64 > 1.0 ** f64
+f64 > 1.0 - nil ?? i
 f64 > 1.0 / 0
 f64 > 1.0 <= f64
+f64 > 1.0 <= i
 f64 > 1.0 == true
 f64 > 1.0 > $env
 f64 > 1.0 > median(list, 1)
 f64 > 1.0 ? i : false
+f64 > 1.0 ?? 1.0
+f64 > 1.0 ?? add
+f64 > 1.0 ?? foo
+f64 > 1.0 ^ f64
 f64 > 1.0 and true
+f64 > 1.0 or ok
+f64 > 1.0 || $env?.[Bar]
 f64 > array?.[i]
+f64 > bitnot(1)
 f64 > ceil(0)
+f64 > ceil(f64)
+f64 > ceil(i)
 f64 > f64
 f64 > f64 != true
 f64 > f64 * f64
 f64 > f64 - 1
 f64 > f64 >= 1.0
+f64 > f64 and true
+f64 > f64 or ok
+f64 > first(array)
 f64 > float(1.0)
 f64 > i
+f64 > i - f64
 f64 > i < f64 ?: $env
 f64 > i == $env
+f64 > i >= max($env)
 f64 > i ^ 1
+f64 > i and ok
 f64 > max(array)
+f64 > mean(1)
 f64 > mean(1.0)
 f64 > median(f64)
 f64 > round(1)
+f64 > round(1.0)
 f64 > round(i)
 f64 > sum($env | filter(false))
 f64 > sum($env, f64)
 f64 >= $env && false
+f64 >= $env ^ 1 and false
+f64 >= $env or true
 f64 >= $env || true
 f64 >= $env.f64
 f64 >= $env.i
 f64 >= $env?.f64
 f64 >= $env?.i
+f64 >= -1.0
+f64 >= -i
 f64 >= 0 != $env
+f64 >= 0 - 0
+f64 >= 0 == true
 f64 >= 0 >= f64
+f64 >= 0 ? add : 0
 f64 >= 0 ? greet : 1
+f64 >= 0 ?? i
 f64 >= 0 || ok
+f64 >= 1 != nil
 f64 >= 1 != true
+f64 >= 1 / f64
 f64 >= 1 < i
+f64 >= 1 == false
+f64 >= 1 >= f64
 f64 >= 1 ? 0 : foo
 f64 >= 1 ? foo : str
+f64 >= 1 ^ 1.0
+f64 >= 1.0 != add ?? foo
 f64 >= 1.0 != nil
+f64 >= 1.0 && ok
 f64 >= 1.0 ** i < f64
+f64 >= 1.0 + $env.f64
 f64 >= 1.0 + 1.0
+f64 >= 1.0 / i
 f64 >= 1.0 > i
+f64 >= 1.0 ?: greet
 f64 >= 1.0 ?: list
+f64 >= 1.0 ?? nil
 f64 >= 1.0 and $env in str
 f64 >= 1.0 and $env?.[str]
+f64 >= 1.0 and not ok
+f64 >= 1.0 || ok
+f64 >= 1.1
 f64 >= array?.[i]
 f64 >= bitnot(i)
 f64 >= ceil(0)
 f64 >= ceil(i)
 f64 >= f64
+f64 >= f64 * 1.0
 f64 >= f64 == ok
+f64 >= f64 >= i
+f64 >= f64 ?? str
 f64 >= f64 ^ f64
+f64 >= f64 || 1.0 == 1.0
+f64 >= f64 || true
 f64 >= float(0)
 f64 >= float(1)
 f64 >= float(1.0)
+f64 >= floor(-0)
+f64 >= floor(1.0)
+f64 >= floor(f64)
+f64 >= floor(i)
 f64 >= i
 f64 >= i != $env
 f64 >= i * f64
 f64 >= i + 1.0
+f64 >= i / f64
+f64 >= i < f64
+f64 >= i ?: true
+f64 >= i ?? $env
+f64 >= i ?? $env.list
+f64 >= i ?? false
+f64 >= i || $env
+f64 >= int(1.0)
+f64 >= mean(0)
 f64 >= mean(1)
 f64 >= mean(1.0)
+f64 >= min(0)
+f64 >= min(i)
+f64 >= nil ?? f64
+f64 >= nil ?? i
+f64 >= round(1)
 f64 >= sum(array)
+f64 ?? !$env
+f64 ?? !false
+f64 ?? !ok
+f64 ?? $env ?? $env
+f64 ?? $env ?? add
+f64 ?? $env ?? f64
+f64 ?? $env ?? nil
+f64 ?? $env ?? ok
+f64 ?? $env | get(greet)
+f64 ?? $env | max(1)
+f64 ?? $env.add
+f64 ?? $env.array
+f64 ?? $env.f64
+f64 ?? $env.foo
+f64 ?? $env.greet
+f64 ?? $env.i
+f64 ?? $env.list
+f64 ?? $env.ok
+f64 ?? $env.str
+f64 ?? $env?.Bar
+f64 ?? $env?.Bar($env < 1.0)
+f64 ?? $env?.Bar()
+f64 ?? $env?.String
+f64 ?? $env?.String()
+f64 ?? $env?.[$env?.String()]
+f64 ?? $env?.[Bar]
+f64 ?? $env?.[String]
+f64 ?? $env?.[String].str()
+f64 ?? $env?.[add]
+f64 ?? $env?.[add]?.[greet]
+f64 ?? $env?.[array]
+f64 ?? $env?.[array].list()
+f64 ?? $env?.[f64]
+f64 ?? $env?.[false - 1]
+f64 ?? $env?.[foo]
+f64 ?? $env?.[foobar.Bar]
+f64 ?? $env?.[foobar?.[f64]]
+f64 ?? $env?.[foobar]
+f64 ?? $env?.[greet(foo)]
+f64 ?? $env?.[greet]
+f64 ?? $env?.[greet].array()
+f64 ?? $env?.[i]
+f64 ?? $env?.[i]?.[str]
+f64 ?? $env?.[list]
+f64 ?? $env?.[not foo]
+f64 ?? $env?.[ok]
+f64 ?? $env?.[ok].array()
+f64 ?? $env?.[str]
+f64 ?? $env?.[str][:i(i < foobar)]
+f64 ?? $env?.add
+f64 ?? $env?.all(foobar)
+f64 ?? $env?.array
+f64 ?? $env?.f64
+f64 ?? $env?.foo
+f64 ?? $env?.foobar
+f64 ?? $env?.foobar?.list
+f64 ?? $env?.greet
+f64 ?? $env?.i
+f64 ?? $env?.list
+f64 ?? $env?.ok
+f64 ?? $env?.str
+f64 ?? $env[0:foobar]
+f64 ?? $env[:1]
+f64 ?? $env[:add[:]]
+f64 ?? $env[:foo]
+f64 ?? $env[:foobar]
+f64 ?? $env[:nil]
+f64 ?? $env[:sum(0, foobar)].ok
+f64 ?? $env[Bar | none(#):]
+f64 ?? $env[Bar():i(1)]
+f64 ?? $env[f64 / foo:]
+f64 ?? $env[f64:replace(foobar, 1.0)]
+f64 ?? $env[false > Bar:]
+f64 ?? $env[foo - 1:foobar].ok
+f64 ?? $env[foobar:]
+f64 ?? $env[foobar:foobar and array]
+f64 ?? $env[list:greet]
+f64 ?? -$env
+f64 ?? -$env?.[1]
+f64 ?? -0
+f64 ?? -1
+f64 ?? -1.0
+f64 ?? -f64
+f64 ?? 0 ?? $env?.nil
+f64 ?? 0 ?? [1.0]
+f64 ?? 0 ?? true
+f64 ?? 1 ?? foo
+f64 ?? 1.0 ?? date(f64)
+f64 ?? [$env]
+f64 ?? [f64, f64]
+f64 ?? abs(1.0)
+f64 ?? add
+f64 ?? add(i, $env)
+f64 ?? array
+f64 ?? array ?? array
+f64 ?? array ?? true
+f64 ?? array | mean(1.0)
+f64 ?? array?.[i]
+f64 ?? bitnot(i)
+f64 ?? count($env | map(#.add))
+f64 ?? count($env)
+f64 ?? count($env, #)
+f64 ?? count($env?.[i])
+f64 ?? count(array)
+f64 ?? count(list)
+f64 ?? date($env, 1)
+f64 ?? date(foo)
+f64 ?? date(sum(list))
+f64 ?? f64
+f64 ?? f64 ?? ok
+f64 ?? false ?? 1.0
+f64 ?? false | max(0)
+f64 ?? findLast($env, #.f64)
+f64 ?? findLast(array, false)
+f64 ?? first($env)?.ok()
+f64 ?? floor($env)
+f64 ?? foo
+f64 ?? foo ?? $env
+f64 ?? foo ?? foo
+f64 ?? foo | get(1.0)
+f64 ?? foo | max(0)
+f64 ?? foo.Bar
+f64 ?? foo.String
+f64 ?? foo.String()
+f64 ?? foo?.Bar
+f64 ?? foo?.String
+f64 ?? foo?.String()
+f64 ?? fromBase64($env)
+f64 ?? greet
+f64 ?? greet($env)
+f64 ?? groupBy($env, #)
+f64 ?? groupBy($env, true)
+f64 ?? groupBy(list, #)
+f64 ?? i
+f64 ?? i ?? add
+f64 ?? int(1)
+f64 ?? int(f64)
+f64 ?? int(str)
+f64 ?? len(str)
+f64 ?? list
+f64 ?? list?.[i]
+f64 ?? lower($env)
+f64 ?? map($env, #)
+f64 ?? map($env, #.Bar)
+f64 ?? map(array, #index)
+f64 ?? max(1.0)
+f64 ?? mean($env)
+f64 ?? median(1.0)
+f64 ?? min($env?.[add])
+f64 ?? min(0)
+f64 ?? min(list)
+f64 ?? nil ?? 0
+f64 ?? not $env
+f64 ?? not ok
+f64 ?? not true
+f64 ?? ok
+f64 ?? ok ?? 1.0
+f64 ?? ok ?? greet
+f64 ?? reduce($env, add)
+f64 ?? reduce($env, foo)
+f64 ?? reduce(array, #, $env)
+f64 ?? reduce(list, str)
+f64 ?? reverse($env)
+f64 ?? reverse(array)
+f64 ?? round(i)
+f64 ?? sortBy($env, #.String, list)
+f64 ?? sortBy(list, ok)
+f64 ?? str
+f64 ?? str[$env:i]
+f64 ?? string(f64)
+f64 ?? string(str)
+f64 ?? string(true)
+f64 ?? sum($env, #.foo)
+f64 ?? sum($env, .str)
+f64 ?? sum($env, foo)
+f64 ?? sum($env?.[list])
+f64 ?? sum(array)
+f64 ?? toJSON(0)
+f64 ?? toJSON(1.0)
+f64 ?? true ?? 0
+f64 ?? type(1)
+f64 ?? uniq($env)
+f64 ?? {foo: 1.0, foo: list}
+f64 ?? {foo: 1}
+f64 ?? {foo: greet}
+f64 ?? {foo: i, foo: str}
+f64 ?? {foo: list}
 f64 ^ $env.f64
 f64 ^ $env.i
 f64 ^ $env?.f64
 f64 ^ $env?.i
+f64 ^ -1
+f64 ^ -1.0
+f64 ^ -f64
 f64 ^ 0 - 1.0
+f64 ^ 0 - i
 f64 ^ 0 / i
 f64 ^ 0 < 0
 f64 ^ 0 >= 1.0 ?: greet
+f64 ^ 1 != 1
+f64 ^ 1 * 1.0
+f64 ^ 1 + 1
 f64 ^ 1 + 1.0
+f64 ^ 1 + f64
+f64 ^ 1 > 1
+f64 ^ 1 > f64
+f64 ^ 1 ?? nil
+f64 ^ 1 in [1.0]
 f64 ^ 1.0
+f64 ^ 1.0 != $env
 f64 ^ 1.0 != 1.0
 f64 ^ 1.0 != f64
+f64 ^ 1.0 != i
 f64 ^ 1.0 ** 1.0
+f64 ^ 1.0 / i
 f64 ^ 1.0 > 1
 f64 ^ 1.0 >= i
+f64 ^ 1.0 ?? str
 f64 ^ array?.[i]
+f64 ^ bitand(0, 0)
+f64 ^ bitnot(1)
+f64 ^ ceil(0)
 f64 ^ f64
 f64 ^ f64 != $env
+f64 ^ f64 != 0
+f64 ^ f64 != 1
+f64 ^ f64 * 1.0
 f64 ^ f64 ** i
 f64 ^ f64 + 1.0
+f64 ^ f64 == i
+f64 ^ f64 > f64
+f64 ^ f64 ?? greet
+f64 ^ f64 ^ f64
+f64 ^ f64 in array
 f64 ^ find(array, ok)
 f64 ^ float(i)
+f64 ^ floor(i)
 f64 ^ i
 f64 ^ i ** 1.0
 f64 ^ i ** i
+f64 ^ i / $env.i
+f64 ^ i <= 1.0
 f64 ^ i >= 0 || $env
 f64 ^ i not in array
+f64 ^ int(0)
+f64 ^ int(1.0)
+f64 ^ int(f64)
 f64 ^ len($env)
+f64 ^ mean(0)
+f64 ^ mean(i)
 f64 ^ median(0)
+f64 ^ min(0)
+f64 ^ nil ?? 1
+f64 ^ round(1.0)
 f64 ^ sum(array)
 f64 in $env && false
 f64 in $env.array
 f64 in $env?.Bar
+f64 in $env?.Bar?.[str]
 f64 in $env?.String
 f64 in $env?.[$env?.[String]]
 f64 in $env?.[Bar]
@@ -7439,11 +15466,26 @@ f64 in $env?.nil
 f64 in [1.0]
 f64 in [foo, 1.0]
 f64 in [foo, i]
+f64 in [foo, nil]
+f64 in [i]
 f64 in [list, 1.0]
 f64 in [nil]
+f64 in [true, $env]
 f64 in array
+f64 in array != nil
+f64 in array ? foo : foo
+f64 in array ? type(false) : foo
+f64 in array ?? 0
+f64 in array ?? nil
+f64 in array and $env
 f64 in array or false
+f64 in last($env)
+f64 in list ?? foo
+f64 in list ?? i
 f64 in reverse(array)
+f64 in sort($env)
+f64 in uniq(array)
+f64 in uniq(list)
 f64 not in $env or true
 f64 not in $env.array
 f64 not in $env?.Bar
@@ -7454,71 +15496,115 @@ f64 not in $env?.[String]?.foo
 f64 not in $env?.[foobar]
 f64 not in $env?.array
 f64 not in $env?.foobar
+f64 not in $env?.foobar?.String
+f64 not in 0..i
 f64 not in [$env]
 f64 not in [1.0]
 f64 not in [array | groupBy(#), i]
 f64 not in array
+f64 not in array ?? 0
+f64 not in array ?? foo or false
+f64 not in array || sum($env)
 f64 not in i .. i
 f64 not in keys($env)
+f64 not in list ?? str
 f64 not in map($env, $env)
 f64 not in map(array, 1)
 f64 | max(0)
 f64 | max(0, 1)
 f64 | max(1)
+f64 | max(1, array)
 f64 | max(1.0)
+f64 | max(1.0, 1)
+f64 | max(1.0, 1.0)
+f64 | max(1.0, f64)
+f64 | max(1.0, i)
+f64 | max([1.0])
 f64 | max(array)
+f64 | max(array, 0)
 f64 | max(array, 1)
 f64 | max(bitnot(1))
 f64 | max(f64)
+f64 | max(f64, i)
 f64 | max(i)
+f64 | max(i, 1)
 f64 | max(i, 1.0)
+f64 | max(i, i)
+f64 | max(sortBy(array, #))
+f64 | mean($env?.i)
 f64 | mean(0)
 f64 | mean(0, 0)
 f64 | mean(0, 1.0)
 f64 | mean(0, array)
 f64 | mean(1)
+f64 | mean(1) > f64
+f64 | mean(1.0 ?? 1.0)
 f64 | mean(1.0)
+f64 | mean(1.0, 0)
 f64 | mean(1.0, 1.0)
 f64 | mean(1.0, array)
 f64 | mean(array)
 f64 | mean(array, 0)
 f64 | mean(f64)
+f64 | mean(f64, 1.0)
+f64 | mean(f64, array)
 f64 | mean(f64, array) != add
 f64 | mean(f64, f64)
+f64 | mean(f64, i)
 f64 | mean(i)
+f64 | mean(i, 1)
+f64 | median($env?.i)
+f64 | median(-i)
 f64 | median(0)
 f64 | median(0, 0)
 f64 | median(0, array)
 f64 | median(0, i)
 f64 | median(1)
 f64 | median(1.0)
+f64 | median(1.0, 1)
+f64 | median(1.0, 1.0)
 f64 | median(array)
 f64 | median(array) >= f64
+f64 | median(array, 0)
 f64 | median(array, 1.0)
+f64 | median(array, i)
 f64 | median(f64)
+f64 | median(f64, 1.0)
 f64 | median(i)
+f64 | median(i, 1.0)
 f64 | min($env?.array)
 f64 | min($env?.f64)
 f64 | min(0)
+f64 | min(0, 1)
 f64 | min(0, i)
 f64 | min(1)
 f64 | min(1, f64)
+f64 | min(1, i, 1.0, 1.0)
 f64 | min(1.0)
 f64 | min(1.0, 0)
 f64 | min(array)
 f64 | min(array, 1)
+f64 | min(array, array)
 f64 | min(array, i)
 f64 | min(f64)
 f64 | min(f64, 1.0)
 f64 | min(i)
+f64 | min(i, i)
+f64 | min(mean(f64))
 f64; $env?.list
+f64; array
 f64; f64
 f64; foo?.String
+f64; greet
 f64; i
+f64; min(foo ?? true)
+f64; ok
 f64; str
+false != $env ?? -1
 false != $env and ok
 false != $env.ok
 false != $env?.Bar
+false != $env?.Bar?.greet()
 false != $env?.String
 false != $env?.[Bar]
 false != $env?.[String]
@@ -7526,82 +15612,164 @@ false != $env?.[foobar]
 false != $env?.[str]
 false != $env?.foobar
 false != $env?.ok
+false != $env?.true?.[list].i
+false != 0 ?? str
+false != 1.0 ?? i
+false != add ?? f64 ?: foo
+false != array ?? list
+false != greet ?? $env?.[ok]
+false != greet ?? str
+false != i ?? array
+false != nil == nil ?: list
 false != nil == ok
+false != nil ?: add
+false != nil ?: f64 != $env
+false != nil or sum($env)
+false != str ?? filter($env, true)
+false && $env + i
+false && $env == add
 false && $env == count(array)
 false && $env > findLastIndex($env, #)
 false && $env >= sum($env)?.[array]
+false && $env ?? ok
+false && $env ^ f64 <= 1
+false && $env contains array ?? list
+false && $env in list
 false && $env in str
+false && $env not contains str
 false && $env not in list
 false && $env or ok
 false && $env.ok
 false && $env?.Bar
+false && $env?.Bar()
+false && $env?.Bar(ok(), f64(), foobar)[foobar?.add.str:]
+false && $env?.Bar.add()
 false && $env?.String
 false && $env?.String()
 false && $env?.String(foobar.Bar)
+false && $env?.String?.[str]
+false && $env?.[0 in foobar]
 false && $env?.[Bar]
+false && $env?.[Bar]?.[f64]
 false && $env?.[String]
 false && $env?.[add]
 false && $env?.[add].array
+false && $env?.[array()]
 false && $env?.[array]
 false && $env?.[array]?.[ok]
 false && $env?.[f64 > str]
+false && $env?.[f64()]
 false && $env?.[f64]
 false && $env?.[f64]?.array
+false && $env?.[findLastIndex(greet, #.ok)]
 false && $env?.[foo]
 false && $env?.[foobar - foobar]
+false && $env?.[foobar >= foobar]
 false && $env?.[foobar.add]
 false && $env?.[foobar]
 false && $env?.[greet]
 false && $env?.[greet].i
 false && $env?.[i]
+false && $env?.[i].foo
 false && $env?.[list]
 false && $env?.[ok]
 false && $env?.[ok].add
 false && $env?.[str]
 false && $env?.[str].String
+false && $env?.[str]?.list()
+false && $env?.[type($env, foobar, 1)]
 false && $env?.foobar
+false && $env?.min(foobar)
 false && $env?.ok
+false && $env[:$env | toPairs(foobar)]
 false && $env[:Bar < 0]
+false && $env[:Bar()]
+false && $env[:add(1.0)]
 false && $env[:ok()]
+false && $env[:trimPrefix(foobar)]
+false && $env[String():str(foobar)]
+false && $env[count(foo):]
+false && $env[foobar < true:]
+false && $env[foobar | toPairs(foobar, false):]
+false && $env[foobar.list(foobar):ok endsWith foobar]
 false && $env[foobar:Bar]
 false && $env[foobar:foobar?.[String]]
 false && $env[foobar?.ok(foobar):]
+false && $env[hasPrefix(i):foobar[$env:true]].ok
+false && $env[i:-foobar]
 false && $env[i:]
+false && $env[i?.str:]
 false && $env[ok.String:all(foobar, #.foo)]
 false && 0 >= i
 false && 0 not in map($env, i)
+false && 1 - findLast($env, #)
 false && 1 == 1 ** $env
+false && 1 > 1.0 ** $env
+false && 1.0 <= f64 > $env
 false && 1.0 == i
 false && 1.0 == int(1)
 false && 1.0 > $env[:ok]
 false && 1.0 > i
+false && 1.0 >= f64
+false && 1.0 >= false ?? 1.0
+false && array == [$env]
+false && f64 - $env?.[foobar]
 false && f64 < i
+false && false ?? ok
+false && foo != foo
+false && foo ?? array
+false && foo ?? greet
+false && greet ?? array
 false && i < f64
+false && i in $env.array
 false && i in array
 false && nil != greet
+false && nil == add
+false && nil == greet
 false && nil == ok
 false && nil in reduce($env, #)
 false && ok || ok
+false && str ?? ok
+false && true ?? foo
 false == $env && ok
+false == $env ?? reverse($env)
 false == $env.ok
 false == $env?.Bar
 false == $env?.String
+false == $env?.String?.list
 false == $env?.[Bar]
 false == $env?.[String]
 false == $env?.[String]?.[f64]
 false == $env?.[String]?.greet
+false == $env?.[foobar]
 false == $env?.[foobar]?.[str]
 false == $env?.[str]
+false == $env?.[str]?.[f64]
 false == $env?.ok
+false == 1.0 ?? $env?.foo
+false == 1.0 ?? add
+false == false && $env == str
+false == foo ?? i
+false == i ?? ok
 false == nil && ok
+false == nil and foo in $env
+false == nil || $env in list
+false == true ? $env | map(.array) : array
+false == true ?? greet
+false == true ?? list
+false ? $env : $env | map($env)
+false ? $env : $env.array
 false ? $env : $env.greet
 false ? $env : $env.list
 false ? $env : $env?.[str]
 false ? $env : $env?.add
+false ? $env : $env?.f64
 false ? $env : foo.Bar
 false ? $env : foo?.Bar
 false ? 0 : array?.[i]
 false ? 0 : foo?.Bar
+false ? 1 : $env.foo
+false ? 1 : $env.list
 false ? 1 : $env?.f64
 false ? 1 : $env?.i
 false ? 1 : $env?.ok
@@ -7610,14 +15778,21 @@ false ? 1.0 : $env?.[Bar]
 false ? 1.0 : $env?.greet
 false ? 1.0 : $env?.list
 false ? 1.0 : $env?.ok
+false ? 1.0 : foo.Bar
 false ? 1.0 : foo?.Bar
 false ? 1.0 : foo?.String()
 false ? 1.0 : str contains str
+false ? add : $env not matches $env?.String
 false ? add : $env.array
+false ? add : $env?.String
+false ? add : foo.Bar
+false ? add : list | map($env.add)
 false ? add : list | reduce(true)
+false ? add : list?.[i]
 false ? add : nil not in array
 false ? array : $env.f64
 false ? array : $env?.f64
+false ? array : $env?.foo
 false ? array : $env?.list
 false ? array : 1 * f64
 false ? array : nil != str
@@ -7625,48 +15800,72 @@ false ? f64 : $env.array
 false ? f64 : $env.f64
 false ? f64 : $env.list
 false ? f64 : $env.ok
+false ? f64 : $env.str
 false ? f64 : $env?.[String]
 false ? f64 : $env?.greet
 false ? f64 : $env?.str
+false ? f64 : foo.Bar
 false ? f64 : list | groupBy(#)
 false ? false : $env?.list
+false ? false : foo ?? greet
+false ? false : foo?.Bar
 false ? foo : $env?.String
 false ? foo : $env?.[Bar]
 false ? foo : $env?.[String]
 false ? foo : $env?.add
 false ? foo : $env?.f64
 false ? foo : $env?.i
+false ? foo : $env?.list
 false ? foo : $env?.ok
 false ? foo : array | map(0)
+false ? foo : array?.[i]
 false ? foo : foo.Bar
+false ? foo : foo.String
 false ? foo : foo?.Bar
 false ? foo : foo?.String
+false ? foo : i ^ i
 false ? greet : $env | map(1.0)
 false ? greet : $env?.greet
+false ? greet : foo.String
 false ? i : $env.str
 false ? i : $env?.[String]
+false ? i : $env?.foo
+false ? i : foo.Bar
+false ? list : $env ?? list
 false ? list : $env.array
+false ? list : $env.i
 false ? list : $env?.foo
 false ? list : foo.Bar
+false ? nil : $env.f64
 false ? nil : $env.foo
+false ? nil : $env.ok
+false ? nil : $env?.Bar
+false ? nil : $env?.[foobar]
 false ? nil : $env?.greet
+false ? nil : $env?.ok
 false ? nil : $env?.str
+false ? nil : 1.0 / f64
 false ? nil : foo.String
+false ? nil : foo.String()
 false ? ok : $env.str
 false ? ok : $env?.[Bar]
 false ? ok : $env?.array
 false ? ok : list | groupBy(i)
 false ? str : $env != str
+false ? str : $env | map(add)
 false ? str : $env.add
 false ? str : $env.f64
 false ? str : $env.list
 false ? str : $env?.Bar
 false ? str : foo?.Bar
 false ? true : $env.add
+false ? true : $env.i
 false ? true : $env?.String
 false ? true : foo.Bar
 false ? true : foo?.Bar
+false ? true : list != $env?.[str]
 false ?: $env.add
+false ?: $env.foo
 false ?: $env.greet
 false ?: $env.i
 false ?: $env.ok
@@ -7675,29 +15874,115 @@ false ?: $env?.Bar
 false ?: $env?.String
 false ?: $env?.[foobar]
 false ?: $env?.add
+false ?: $env?.array
+false ?: $env?.f64
+false ?: $env?.foo
 false ?: $env?.i
 false ?: $env?.list
 false ?: $env?.str
 false ?: array | sum(1.0)
+false ?: array?.[i]
 false ?: f64 - i
 false ?: foo.Bar
+false ?: foo.String
+false ?: foo?.Bar
 false ?: foo?.String
 false ?: foo?.String()
 false ?: i | mean(1)
 false ?: list | map(foo)
+false ?? $env ?? $env?.[foo]
+false ?? $env.add
+false ?? $env.array
+false ?? $env.f64
+false ?? $env.foo
+false ?? $env.greet
+false ?? $env.i
+false ?? $env.list
+false ?? $env.ok
+false ?? $env.str
+false ?? $env?.Bar
+false ?? $env?.Bar().String
+false ?? $env?.String
+false ?? $env?.String()
+false ?? $env?.String?.ok
+false ?? $env?.[!String]
+false ?? $env?.[0 .. greet]
+false ?? $env?.[1.0 | any(String)]
+false ?? $env?.[Bar]
+false ?? $env?.[String]
+false ?? $env?.[add | groupBy(1)]
+false ?? $env?.[add]
+false ?? $env?.[add]?.[f64]?.[foo]
+false ?? $env?.[array]
+false ?? $env?.[f64]
+false ?? $env?.[foo]
+false ?? $env?.[foobar.list]
+false ?? $env?.[greet]
+false ?? $env?.[greet]?.add()
+false ?? $env?.[greet]?.f64
+false ?? $env?.[i != foobar]
+false ?? $env?.[i]
+false ?? $env?.[list()]
+false ?? $env?.[list]
+false ?? $env?.[list]?.[i]
+false ?? $env?.[ok]
+false ?? $env?.[str ^ String]
+false ?? $env?.[str]
+false ?? $env?.add
+false ?? $env?.all(array)
+false ?? $env?.array
+false ?? $env?.f64
+false ?? $env?.foo
+false ?? $env?.foobar
+false ?? $env?.foobar?.f64
+false ?? $env?.greet
+false ?? $env?.i
+false ?? $env?.list
+false ?? $env?.none(i)
+false ?? $env?.ok
+false ?? $env?.str
+false ?? $env[1.0 | trimPrefix(1):foobar < true]
+false ?? $env[:String.f64]
+false ?? $env[:array || foo]
+false ?? $env[:array()]
+false ?? $env[:foo?.str]
+false ?? $env[Bar matches foobar:]
+false ?? $env[date(str, true):]
+false ?? 1.0 ?: f64
+false ?? array?.[i]
+false ?? foo ?? ok ?: greet
+false ?? foo.Bar
+false ?? foo.String
+false ?? foo.String()
+false ?? foo?.Bar
+false ?? foo?.String
+false ?? foo?.String()
+false ?? nil ?? [$env, 1.0]
+false ?? nil ?? list
+false ?? nil ?? ok
+false ?? ok ?? foo
+false ?? true ?? $env?.String
 false and $env != f64
+false and $env + $env?.[f64]
+false and $env + str
 false and $env <= $env[foobar:foobar]
 false and $env == add
+false and $env == str
 false and $env >= str
+false and $env ?? $env?.[Bar]
 false and $env not contains str
 false and $env not in array
 false and $env not in foo || true
 false and $env || ok
 false and $env.ok
+false and $env?.$env.Bar
 false and $env?.$env?.ok
 false and $env?.Bar
 false and $env?.Bar != foo
+false and $env?.Bar()
+false and $env?.Bar(1 | filter(list)) || ok
 false and $env?.Bar(array, foobar)
+false and $env?.Bar.f64()
 false and $env?.String
 false and $env?.String()
 false and $env?.String?.greet(str)
@@ -7712,53 +15997,101 @@ false and $env?.[f64]
 false and $env?.[findLast(String, $env)]
 false and $env?.[foo.list]
 false and $env?.[foo]
+false and $env?.[foo].greet
+false and $env?.[foobar?.[add]]
 false and $env?.[foobar]
 false and $env?.[greet]
 false and $env?.[i]
 false and $env?.[i].array
+false and $env?.[i]?.list
+false and $env?.[len(foo, Bar, foo)]
 false and $env?.[list]
 false and $env?.[list].array
 false and $env?.[ok(foobar)]
 false and $env?.[ok]
 false and $env?.[str]
+false and $env?.[str]?.[f64].array
 false and $env?.[str]?.list(filter(String / foobar, f64 >= 1.0))
+false and $env?.[trim(foobar)]
+false and $env?.[true | findLast(foobar)]
 false and $env?.all(foobar, foo)
+false and $env?.concat(Bar, 1, foobar)
+false and $env?.foobar
 false and $env?.none(foobar)
 false and $env?.ok
 false and $env?.repeat(nil)
+false and $env?.type(foobar, str)
 false and $env[$env .. add:foo ? true : foobar]?.greet
 false and $env[$env[array:foo]:]
+false and $env[:Bar]
+false and $env[:String($env, ok)]
+false and $env[:add()]
+false and $env[:false > nil]?.[greet]
+false and $env[:foo.foobar]
+false and $env[:foo]?.list(first(foobar ?? String), array && foobar >= String, foobar && list?.[1])
 false and $env[:foobar?.Bar]
 false and $env[Bar(foo):]
 false and $env[array():]
+false and $env[bitshr(foobar, array):foobar | reduce(.String)]
 false and $env[foobar:]
 false and $env[greet(str):true in list]
 false and $env[i():]
+false and $env[i:nil ^ 1.0]
 false and 0 == i
+false and 0 > count(array, false)
+false and 0 >= -1
+false and 0 ?? $env[:nil]
 false and 1 != f64
 false and 1 <= f64
 false and 1 not in $env?.array
 false and 1.0 ** 1.0 == nil
+false and 1.0 + $env?.Bar
+false and 1.0 <= f64
 false and 1.0 <= f64 / f64
 false and 1.0 == i
+false and 1.0 > 0 ?? 0
+false and 1.0 > sum($env)
+false and 1.0 ?? greet
+false and f64 >= i
 false and f64 in array
+false and false != $env?.[i]
+false and foo != foo
+false and foo ?? greet
+false and foo ?? i
+false and greet ?? ok
+false and greet not in $env?.[Bar]
+false and i != $env?.[add]
 false and i == median(list)
 false and nil == str
 false and ok and ok
+false and str > str
 false and str >= foo?.Bar
+false and str not in foo
 false and true ?: add
+false and true ?? sum($env)
+false and true || ok
 false in $env?.Bar
 false in $env?.String
 false in $env?.[Bar]
 false in $env?.[String]
+false in $env?.[foobar?.[foo]]
+false in $env?.[foobar]
 false in $env?.[foobar]?.[array]
+false in $env?.foobar
+false in $env?.foobar?.String
+false in list ?? foo
 false not in $env?.Bar
 false not in $env?.String
 false not in $env?.[Bar]
 false not in $env?.[String]
 false not in $env?.[String]?.Bar
+false not in $env?.[String]?.String
+false not in $env?.[String]?.[list]
 false not in $env?.[first(foobar)]
+false not in $env?.[foobar?.list]
 false not in $env?.[foobar]
+false not in $env?.foobar
+false not in array ?? {foo: $env}
 false or $env in $env?.[foobar]
 false or $env startsWith $env?.[Bar]
 false or $env.ok
@@ -7771,26 +16104,49 @@ false or $env?.[String]
 false or $env?.[String]?.[list]
 false or $env?.[foobar | toJSON(nil)]
 false or $env?.[foobar?.[0]]
+false or $env?.[foobar]
 false or $env?.[str]
 false or $env?.foobar
 false or $env?.ok
+false or 0 < 1.0 ^ 1
+false or 0 == i
+false or 0 >= i || true
 false or 0 not in array
+false or 1 > i
+false or 1 ?? list
+false or 1 in array
 false or 1.0 >= i
+false or 1.0 ?? foo
 false or array == list
+false or f64 ?? $env?.ok
 false or false ?: ok
+false or false ?? foo
+false or foo ?? i
+false or foo ?? ok
+false or foo in list
 false or greet == greet
 false or i == i
+false or i ?? foo
+false or i ?? list
+false or list ?? ok
 false or nil != array
 false or nil != f64
+false or nil == array
 false or nil == foo
 false or ok == ok
 false or str != str
+false or str >= string(0)
+false or str in foo == $env
 false or str not matches str
 false || $env != f64 and $env
+false || $env == [foo]
+false || $env == array ? foo : foo
 false || $env == i
+false || $env ?? f64
 false || $env in list
 false || $env.ok
 false || $env?.Bar
+false || $env?.Bar?.[ok]
 false || $env?.Bar?.foo
 false || $env?.String
 false || $env?.String?.foo()
@@ -7798,16 +16154,31 @@ false || $env?.[Bar]
 false || $env?.[String]
 false || $env?.[str]
 false || $env?.false?.array
+false || $env?.foobar
 false || $env?.ok
+false || 0 != $env?.String
+false || 1 == $env?.[foobar]
 false || 1 == array?.[i]
 false || 1 > f64
 false || 1 in array
 false || 1.0 <= 1.0 ?: 1
 false || 1.0 <= i
+false || 1.0 >= f64
+false || 1.0 ?? array
 false || add != add
 false || array != list
+false || f64 != i
+false || false ?? foo
+false || foo ?? array
+false || foo ?? str
 false || foo in list
+false || foo.Bar matches str
+false || i == i
+false || i > median(f64)
 false || i >= i
+false || i ?? greet($env)
+false || i ?? str
+false || nil != f64
 false || nil != i
 false || nil == greet
 false || str not endsWith str
@@ -7815,51 +16186,94 @@ false || true == ok
 false; $env?.Bar
 false; $env?.String
 false; $env?.[Bar]
+false; $env?.foo
+filter($env | map(0), !true)
 filter($env, #.list) | filter(false)
 filter($env, .f64) | filter(false)
 filter($env, .ok) | filter(false)
+filter($env, .str) | filter(false)
 filter($env, false) | all(#)
 filter($env, false) | all(#.str not matches .str)
 filter($env, false) | all(false)
+filter($env, false) | find(#)
 filter($env, false) | find(true)
+filter($env, false) | findIndex(#)
+filter($env, false) | findLastIndex(.f64 not contains #)
 filter($env, false) | groupBy(#)
 filter($env, false) | reduce(#.list, str)
 filter($env, false) | reduce(true, nil)
 filter($env, false) | sortBy(foo)
+filter($env, false) | sum(.Bar)
+filter($env, false) | sum(.i)
+filter($env, false) | sum(foo)
 filter($env, false) | sum(greet)
 filter($env, ok) | map(foo)
 filter($env.array, foo != foo)
 filter($env.array, i == 1)
+filter($env.array, ok)
 filter($env.list, ok)
 filter($env.list, true || true)
+filter($env?.[str], false && $env)
 filter($env?.[str], ok)
+filter($env?.array, # <= #)
 filter($env?.array, ok)
 filter($env?.list, ok)
 filter([0], ok)
 filter([1], # != 1.0)
+filter([greet], ok)
+filter([i], ok)
 filter([true, $env], 1 < 1)
+filter(array, !ok)
 filter(array, # != #)
+filter(array, # != 1)
+filter(array, # < #)
 filter(array, # <= #)
+filter(array, # not in array)
 filter(array, $env != $env)
+filter(array, $env == $env)
 filter(array, $env and false)
+filter(array, $env.ok)
+filter(array, 0 <= #)
+filter(array, 1 != f64)
+filter(array, 1 <= #)
 filter(array, 1 >= #)
+filter(array, 1.0 != #)
 filter(array, 1.0 <= f64)
 filter(array, 1.0 == $env)
+filter(array, 1.0 > #)
 filter(array, 1.0 > 1.0)
 filter(array, f64 <= #)
+filter(array, false != $env)
 filter(array, false) | all($env[1.0:])
+filter(array, false) | groupBy(#)
 filter(array, false) | sortBy($env)
 filter(array, false) | sortBy(add)
+filter(array, false) | sum(f64)
+filter(array, foo == foo)
+filter(array, i > #)
+filter(array, list == nil)
+filter(array, nil != #)
+filter(array, nil != list)
+filter(array, nil ?? false)
+filter(array, not true)
+filter(array, ok && i != #)
+filter(array, ok ?? i)
+filter(array, ok and true)
 filter(array, ok)
 filter(array, ok) | findIndex(false)
+filter(array, ok) | groupBy(foo)
 filter(array, ok) | sortBy(0)
 filter(array, ok)?.[i]
 filter(array, str in foo)
 filter(array, true) | findLast(ok)
+filter(array, true) | map(foo)
 filter(array, true) | none(true)
 filter(array, true)?.[i]
 filter(concat(array), #.greet || true)
 filter(keys($env), ok)
+filter(list | map($env), ok == nil)
+filter(list, !false)
+filter(list, # != #)
 filter(list, # == $env)
 filter(list, # not in list)
 filter(list, #.Bar in #)
@@ -7867,330 +16281,651 @@ filter(list, #.Bar not in foo)
 filter(list, $env != #)
 filter(list, $env != str)
 filter(list, $env == #)
+filter(list, $env == str)
 filter(list, $env?.ok)
+filter(list, 1 > 1.0)
+filter(list, 1.0 < 1)
 filter(list, 1.0 == nil)
+filter(list, 1.0 > f64)
+filter(list, 1.0 not in array)
+filter(list, array != array)
 filter(list, f64 <= 1.0)
+filter(list, false != nil)
+filter(list, false && $env)
+filter(list, false ?? 1.0)
+filter(list, false) | groupBy(#)
+filter(list, false) | groupBy(ok)
+filter(list, false) | map(array)
 filter(list, false) | sum($env)
 filter(list, false) | sum(foo)
 filter(list, foo != nil)
+filter(list, greet == nil)
+filter(list, nil == nil)
+filter(list, nil in $env)
+filter(list, not true)
 filter(list, ok)
 filter(list, ok) | findIndex(true)
+filter(list, ok) | reduce(add)
 filter(list, ok)?.[i]
+filter(list, one(array, true))
 filter(list, str != $env)
 filter(list, true) | all(true)
+filter(list, true) | groupBy(#)
+filter(list, true) | groupBy(1.0)
 filter(list, true) | reduce(#acc)
 filter(list, true) | reduce(i)
+filter(list, true)?.[i]
 filter(map($env, foo), # != #)
+filter(sort($env), #.String?.list)
 filter(sort($env), #.foo?.String)
 filter(sort($env), #.i || #)
 filter(sort($env), nil not in .list)
+find($env ?? ok, $env == 1.0)
 find($env | filter(false), # endsWith .Bar)
+find($env | map(greet), not true)
+find($env, false) != f64
+find($env, false) ?? ok
 find($env, false)?.Bar
+find($env, false)?.Bar()
 find($env, false)?.String
+find($env, false)?.String?.foo
 find($env, false)?.[add]
 find($env, false)?.[array]
 find($env, false)?.[f64]
 find($env, false)?.[foo]
+find($env, false)?.[greet]
 find($env, false)?.[greet].i()
 find($env, false)?.[greet].str
+find($env, false)?.[i]
 find($env, false)?.[i]?.foo
 find($env, false)?.[list]
 find($env, false)?.[ok]
+find($env, false)?.[str]
+find($env, false)?.[str]?.greet
 find($env, false)?.[{foo: false}]
 find($env, false)?.add
 find($env, false)?.array
 find($env, false)?.bitxor(ok, nil, 1)
 find($env, false)?.f64
+find($env, false)?.f64?.[array]
 find($env, false)?.foo
 find($env, false)?.foo()
 find($env, false)?.greet
+find($env, false)?.greet()
 find($env, false)?.greet(foobar)
 find($env, false)?.i
 find($env, false)?.i()
 find($env, false)?.list
 find($env, false)?.ok
+find($env, false)?.ok()
+find($env, false)?.str
+find($env.array, # > #)
+find($env.array, $env.ok)
 find($env.array, i != 1.0)
 find($env.array, ok)
+find($env.list, $env != .String)
 find($env.list, ok)
 find($env?.[str], 1 > 0)
 find($env?.[str], ok or .ok)
 find($env?.[str], ok)
 find($env?.list, f64 != 0)
 find($env?.list, ok)
+find([$env], .ok)
+find([1, greet], f64 < 1.0)
+find([array], nil in $env)
+find([array], ok)
+find([false], #)
+find([ok], #)
+find([str, true], ok)
 find([str], ok)
+find(array, !false)
 find(array, # != 0)
+find(array, # != nil)
+find(array, # < #)
 find(array, # < 0)
+find(array, # <= #)
 find(array, # <= 0)
 find(array, # <= i)
 find(array, # == 1)
+find(array, # > #)
+find(array, $env != $env)
 find(array, $env == foo)
 find(array, $env | any(false))
+find(array, $env.ok)
+find(array, $env?.ok)
 find(array, 0 != f64)
 find(array, 0 <= 1)
+find(array, 0 >= #)
+find(array, 1 != f64)
+find(array, 1 > i)
 find(array, 1.0 != #)
 find(array, 1.0 != nil)
+find(array, 1.0 <= #)
 find(array, 1.0 == nil)
+find(array, 1.0 >= 1.0)
+find(array, array != list)
 find(array, array | one(true))
+find(array, f64 != #)
+find(array, false == nil)
+find(array, i != nil)
+find(array, nil != ok)
 find(array, nil != true)
+find(array, not false)
 find(array, ok or false)
 find(array, ok)
+find(array, str not contains str)
+find(array, true ?? #)
+find(array, true ?? 1)
+find(array, true) - i
+find(array, true) | max(array)
+find(filter($env, false), .list in #.list)
+find(list ?? list, ok)
 find(list, # != #)
 find(list, #.String == .String)
 find(list, $env != list)
 find(list, $env == nil)
+find(list, $env == ok)
 find(list, $env not in array)
+find(list, $env.ok)
+find(list, $env?.ok)
 find(list, 0 > i)
 find(list, 1 == 1.0)
+find(list, 1.0 != 1)
+find(list, 1.0 <= i)
+find(list, 1.0 > f64)
 find(list, array != $env)
 find(list, array == list)
+find(list, false != nil)
+find(list, false) ?? list
 find(list, false)?.Bar
 find(list, foo != #)
+find(list, foo != $env)
 find(list, foo != nil)
+find(list, nil != #.Bar)
 find(list, nil == str)
+find(list, nil == true)
 find(list, ok)
 find(list, ok).Bar
+find(list, ok).String
 find(list, ok)?.Bar
 find(list, ok)?.String
 find(list, str == $env)
+find(list, true ?? $env)
 find(list, true).Bar
 find(list, true).String
+find(list, true)?.Bar
 find(list, true)?.String
+find(map($env, $env), foo == #)
+find(map(array, 1.0), i != 1.0)
+find(map(list, #), ok)
+find(map(list, 0), ok)
 find(max($env), $env == i)
+find(nil ?? array, # > #)
+find(nil ?? list, # == #)
+find(sort($env), #.array.f64)
 find(sort($env), #.f64 not startsWith .String)
+find(sort($env), #.foo)
+find(sort($env), .foo?.[greet])
+find(sort($env), .greet.Bar)
+find(sort($env), .list?.foobar)
 find(sort($env), .str?.ok)?.[ok]
 find(toPairs($env), $env.ok)
+find(toPairs($env), ok)
+find(values($env), ok ?? 1)
+findIndex($env | map(i), # > f64)
+findIndex($env, ok) > -f64
+findIndex($env, ok) >= f64
+findIndex($env, ok) ?? f64
+findIndex($env, ok) ?? foo
+findIndex($env, true) <= f64
+findIndex($env, true) ?? 1.0 ?? $env
+findIndex($env.array, ok)
+findIndex($env.list, ok)
 findIndex($env?.[str], 1.0 == nil)
 findIndex($env?.array, # < #)
+findIndex($env?.array, nil == greet)
 findIndex($env?.list, ok)
 findIndex([0], # <= 1)
+findIndex([1.0, foo], not ok)
 findIndex([1.0], # > 1.0)
 findIndex([add], ok)
 findIndex([array], ok)
 findIndex([f64], ok)
 findIndex([false], #)
+findIndex([false], ok)
 findIndex([foo], ok)
 findIndex([list], $env == add)
+findIndex([ok], #)
 findIndex([str], $env?.ok)
 findIndex([true], #)
 findIndex(array | sortBy(1.0), ok)
+findIndex(array, !false)
+findIndex(array, !true)
 findIndex(array, # != #)
 findIndex(array, # != nil)
+findIndex(array, # <= #)
+findIndex(array, # == 1.0)
 findIndex(array, # > #)
 findIndex(array, # >= #)
+findIndex(array, $env != $env)
+findIndex(array, $env != 0)
 findIndex(array, $env != true)
+findIndex(array, $env == #)
 findIndex(array, $env.ok)
 findIndex(array, $env?.ok)
 findIndex(array, 0 == #)
+findIndex(array, 0 == i)
 findIndex(array, 1 <= #)
 findIndex(array, 1.0 != $env)
 findIndex(array, 1.0 < #)
+findIndex(array, 1.0 == $env)
 findIndex(array, 1.0 >= #)
 findIndex(array, add == nil)
+findIndex(array, f64 > f64)
 findIndex(array, false || ok)
 findIndex(array, foo == nil)
+findIndex(array, nil != #)
 findIndex(array, nil != foo)
+findIndex(array, not true)
 findIndex(array, ok)
+findIndex(array, ok) ^ f64
+findIndex(array, reduce(list, true))
+findIndex(array, true || $env)
+findIndex(array, true || false)
+findIndex(array, true) / i
+findIndex(array, true) == $env != nil
 findIndex(array, true) | min(array)
 findIndex(filter($env, false), #.list(foobar))
+findIndex(flatten(list), # != list)
 findIndex(flatten(list), .String != ok)
+findIndex(list | map(add), not ok)
+findIndex(list, !ok)
+findIndex(list, !true)
+findIndex(list, # != nil)
 findIndex(list, # == #)
 findIndex(list, # == nil)
 findIndex(list, $env != .String)
+findIndex(list, $env != true)
 findIndex(list, $env == false)
+findIndex(list, $env == i)
 findIndex(list, .Bar == $env)
+findIndex(list, all($env, true))
+findIndex(list, f64 <= f64)
 findIndex(list, f64 == 1.0)
 findIndex(list, foo != $env)
+findIndex(list, foo == foo)
 findIndex(list, greet == nil)
 findIndex(list, nil != $env)
+findIndex(list, none(array, ok))
+findIndex(list, not false)
+findIndex(list, ok ?? ok)
 findIndex(list, ok)
 findIndex(list, ok) * f64
 findIndex(list, str in #)
 findIndex(list, str not contains str)
+findIndex(list, true) | min(1.0)
+findIndex(map($env, $env), #.String contains #)
+findIndex(map($env, $env), ok) ?? add
+findIndex(max($env), i > f64)
+findIndex(nil ?? $env, ok)
 findIndex(sort($env), #.String?.list(foobar))
+findIndex(sort($env), #.f64 - #.i)
+findIndex(sort($env), #.str && #.f64)
 findIndex(sort($env), .array)
 findIndex(sort($env), list not in .Bar)
+findIndex(sort(array), # == false)
+findIndex(values($env), 1 != 1.0)
 findLast($env, false) == greet
 findLast($env, false)?.Bar
 findLast($env, false)?.String
+findLast($env, false)?.String?.str
 findLast($env, false)?.[add]
+findLast($env, false)?.[array]
+findLast($env, false)?.[f64]
 findLast($env, false)?.[foo]
 findLast($env, false)?.[greet]
 findLast($env, false)?.[greet]?.Bar
 findLast($env, false)?.[i]
+findLast($env, false)?.[i].array
 findLast($env, false)?.[list]
 findLast($env, false)?.[ok]
 findLast($env, false)?.[str]
 findLast($env, false)?.add()
 findLast($env, false)?.array
+findLast($env, false)?.array()
 findLast($env, false)?.f64
 findLast($env, false)?.f64()
 findLast($env, false)?.f64?.[str]
 findLast($env, false)?.foo
+findLast($env, false)?.fromPairs(i)
+findLast($env, false)?.greet
 findLast($env, false)?.greet()
 findLast($env, false)?.i
 findLast($env, false)?.i()
+findLast($env, false)?.list
 findLast($env, false)?.list()
+findLast($env, false)?.list(foobar?.f64)
 findLast($env, false)?.ok
 findLast($env, false)?.ok()
+findLast($env, false)?.reduce(String)
 findLast($env, false)?.str
 findLast($env.array, # >= #)
+findLast($env.array, ok)
 findLast($env.array, str in $env)
+findLast($env.list, !false)
 findLast($env.list, ok)
 findLast($env?.[str], # not in array)
+findLast($env?.[str], 1 == 1.0)
 findLast($env?.[str], false == #)
 findLast($env?.array, $env.ok)
 findLast($env?.array, i in array)
 findLast($env?.array, ok)
 findLast($env?.list, ok)
 findLast([$env], $env != nil).array
+findLast([$env], .Bar != str)
 findLast([1.0], ok)
+findLast([f64, true], if # { # } else { # })
+findLast([f64], 1 != $env)
 findLast([false], $env | none(true))
+findLast([foo], ok)
+findLast([list], ok)
+findLast([ok], #)
 findLast([ok], ok)
 findLast([true], ok)
+findLast(array ?? 0, # != 1.0)
 findLast(array | map(#index), ok)
+findLast(array | sortBy(0), 1 < 1)
+findLast(array, # != #)
+findLast(array, # < #)
 findLast(array, # < f64)
 findLast(array, # <= #)
+findLast(array, # > 1)
 findLast(array, # > 1.0)
+findLast(array, # >= #)
+findLast(array, # >= 1.0)
+findLast(array, # >= i)
+findLast(array, $env != 1)
+findLast(array, $env == $env)
+findLast(array, $env == true)
 findLast(array, $env?.ok)
+findLast(array, 0 >= 1.0)
+findLast(array, 0 in array)
 findLast(array, 1 != #)
 findLast(array, 1 < 1)
+findLast(array, 1 > 1.0)
+findLast(array, 1.0 == nil)
 findLast(array, 1.0 >= 1.0)
 findLast(array, f64 < 0)
+findLast(array, f64 < 1.0)
 findLast(array, f64 < f64)
 findLast(array, f64 > #)
 findLast(array, f64 >= 1.0)
 findLast(array, f64 >= i)
 findLast(array, false || true)
+findLast(array, i < #)
 findLast(array, nil != #)
 findLast(array, nil != nil)
+findLast(array, none($env, false))
+findLast(array, not ok)
 findLast(array, ok ?: 1.0)
+findLast(array, ok ?? #)
 findLast(array, ok)
+findLast(array, ok) + i
 findLast(array, ok) >= f64
 findLast(array, ok) in array
 findLast(array, str not in foo)
+findLast(concat(list), !true)
 findLast(filter(list, false), $env?.[array])
+findLast(flatten(array), true ?? .ok)
+findLast(flatten(list), ok)
 findLast(keys($env), foo == foo)
+findLast(list ?? list, ok)
 findLast(list | sortBy(0), # == #)
+findLast(list, # != #)
+findLast(list, # != $env)
+findLast(list, # != nil)
+findLast(list, # == $env)
 findLast(list, # == foo)
 findLast(list, #.Bar in #)
 findLast(list, #.String != nil)
+findLast(list, $env != nil)
 findLast(list, $env != true)
 findLast(list, $env == false)
 findLast(list, $env == foo.String())
 findLast(list, $env or true)
 findLast(list, $env.ok)
+findLast(list, .Bar matches str)
 findLast(list, 0 != 1.0)
+findLast(list, 1 != f64)
 findLast(list, 1 >= 1.0)
 findLast(list, 1.0 <= f64)
 findLast(list, 1.0 == 1)
 findLast(list, 1.0 >= 1.0)
 findLast(list, f64 == f64)
+findLast(list, f64 > i)
 findLast(list, false)?.Bar
+findLast(list, foo != #)
 findLast(list, foo == #)
+findLast(list, i == $env)
 findLast(list, i > 0)
 findLast(list, nil == #)
 findLast(list, nil == greet)
 findLast(list, ok)
 findLast(list, ok).Bar
+findLast(list, ok).String
 findLast(list, ok).String()
+findLast(list, ok)?.Bar
+findLast(list, str != nil)
+findLast(list, str not contains str)
+findLast(list, str startsWith str)
 findLast(list, true && false)
+findLast(list, true ?? add)
+findLast(list, true) ?? i
+findLast(list, true).Bar
 findLast(list, true).String
+findLast(list, true).String()
 findLast(list, true)?.Bar
+findLast(map(list, ok), #)
 findLast(min($env), .array and false)
+findLast(sort($env), #)
 findLast(sort($env), .array)
 findLast(sort($env), .f64 != #.i)
+findLast(sort($env), .greet.array)?.list
 findLast(sort($env), .list?.list)
 findLast(sort($env), 1.0 != #.list)
+findLast(uniq(array), ok)
+findLast(values($env), # != foo)
+findLast(values($env), ok)
+findLastIndex($env ?? 1, true || #)
+findLastIndex($env ?? foo, ok)
+findLastIndex($env | filter(false), #.add)
 findLastIndex($env, ok) > i
 findLastIndex($env, ok) ^ f64
+findLastIndex($env, true) + i
 findLastIndex($env, true) <= f64
+findLastIndex($env, true) ^ i
 findLastIndex($env, true) | bitor(1)
 findLastIndex($env, true) | bitshl(1)
+findLastIndex($env.array, # >= 1)
+findLastIndex($env.array, ok)
+findLastIndex($env.array, true == ok)
 findLastIndex($env?.[str], 1.0 > #)
+findLastIndex($env?.[str], ok)
+findLastIndex($env?.array, # != #)
+findLastIndex($env?.array, $env != $env)
 findLastIndex($env?.array, ok)
+findLastIndex([$env], #.f64 == true)
+findLastIndex([$env], #.f64 not endsWith .String)
+findLastIndex([false, 0], ok)
 findLastIndex([false, true, $env], #.greet != true)
 findLastIndex([list], foo not in #)
+findLastIndex([true], #)
 findLastIndex([true], str < str)
+findLastIndex(array ?? 1.0, ok)
+findLastIndex(array ?? foo, ok)
+findLastIndex(array, !false)
+findLastIndex(array, # != 0)
 findLastIndex(array, # < #)
 findLastIndex(array, # < i)
 findLastIndex(array, # <= #)
+findLastIndex(array, # == $env)
+findLastIndex(array, # == f64)
 findLastIndex(array, # > #)
+findLastIndex(array, $env != false)
 findLastIndex(array, $env == 1.0)
 findLastIndex(array, $env.ok)
+findLastIndex(array, $env?.ok)
 findLastIndex(array, 0 == $env)
 findLastIndex(array, 1 >= 1.0)
+findLastIndex(array, 1.0 == #)
 findLastIndex(array, add == nil)
 findLastIndex(array, any($env, false))
+findLastIndex(array, false && $env)
 findLastIndex(array, false) != 1.0 + 1.0
+findLastIndex(array, i >= # != false)
+findLastIndex(array, nil != 1.0)
+findLastIndex(array, nil != array)
 findLastIndex(array, nil == ok)
+findLastIndex(array, not false)
+findLastIndex(array, ok ?? false)
 findLastIndex(array, ok)
 findLastIndex(array, str in foo)
 findLastIndex(array, str not in $env)
+findLastIndex(array, true ?? ok)
+findLastIndex(array, true || $env)
+findLastIndex(array, true) * 1.0 + 1
 findLastIndex(array, true) * f64
+findLastIndex(array, true) ?? sortBy(array, 1.0)
+findLastIndex(array, true) | bitushr(i)
 findLastIndex(false ? nil : $env, ok)
 findLastIndex(flatten(array), ok)
+findLastIndex(flatten(list), ok)
+findLastIndex(list, !true)
 findLastIndex(list, # == #)
 findLastIndex(list, #.Bar == nil)
+findLastIndex(list, #.Bar matches str)
 findLastIndex(list, $env.ok)
+findLastIndex(list, .Bar in foo)
 findLastIndex(list, 0 != 1)
 findLastIndex(list, 0 > 1.0)
+findLastIndex(list, 0 >= 1.0)
+findLastIndex(list, 1.0 >= f64)
+findLastIndex(list, false ? foo : ok)
 findLastIndex(list, foo != #)
 findLastIndex(list, foo != $env)
+findLastIndex(list, foo == #)
 findLastIndex(list, foo not in list)
+findLastIndex(list, i > f64)
+findLastIndex(list, nil != #)
+findLastIndex(list, nil != foo)
 findLastIndex(list, nil != nil)
 findLastIndex(list, nil == 1)
+findLastIndex(list, nil in $env)
+findLastIndex(list, not false)
+findLastIndex(list, ok != false)
 findLastIndex(list, ok)
 findLastIndex(list, ok) < i
+findLastIndex(list, one(list, false))
 findLastIndex(list, str == $env)
 findLastIndex(list, str not in #)
+findLastIndex(list, str not startsWith .Bar)
 findLastIndex(list, true) > f64
+findLastIndex(list, true) ?? greet
+findLastIndex(map($env, str), ok)
 findLastIndex(map(array, ok), #)
 findLastIndex(map(list, add), ok)
+findLastIndex(sort($env), # contains #)
 findLastIndex(sort($env), #.foo?.greet)
 findLastIndex(sort($env), $env ?: #.i)
+findLastIndex(sort($env), ok)
+first($env ?? $env)
+first($env ?? 0)
+first($env ?? 1)
+first($env ?? 1.0)
+first($env ?? foo)
+first($env ?? foo) not in list
+first($env ?? greet)
+first($env ?? i)
+first($env ?? str)
+first($env ?? true)
+first($env ?? true)?.i
 first($env | findLast(false))
+first($env | map(#index))
 first($env | map($env))
 first($env | map($env))?.foo
+first($env | map(1))
+first($env) != $env?.f64
 first($env) != foo
 first($env) != i
+first($env) == i
 first($env) == str
+first($env) ?? array
+first($env) ?? list
 first($env) not contains str
 first($env) not in array
 first($env) not matches str
 first($env) not startsWith str
 first($env) startsWith str
+first($env) | get(1.0)
 first($env)?.$env?.array()
 first($env)?.Bar
 first($env)?.Bar()
 first($env)?.Bar(add)
+first($env)?.Bar?.add
 first($env)?.String
 first($env)?.String()
 first($env)?.String?.array
+first($env)?.String?.foo
 first($env)?.[add]
+first($env)?.[add].list()
 first($env)?.[add]?.[foo]
+first($env)?.[add]?.i
 first($env)?.[array]
 first($env)?.[f64]
+first($env)?.[f64].String
+first($env)?.[f64].list
 first($env)?.[f64]?.String
 first($env)?.[foo]
 first($env)?.[foo]?.[greet].String
 first($env)?.[greet]
 first($env)?.[greet]?.[greet]
+first($env)?.[greet]?.f64
 first($env)?.[greet]?.str
 first($env)?.[i]
+first($env)?.[i]?.String
+first($env)?.[i]?.[foo]
 first($env)?.[i]?.add
+first($env)?.[i]?.i
 first($env)?.[i]?.str
 first($env)?.[list]
+first($env)?.[list].Bar?.str().ok?.[str]
+first($env)?.[list].list
 first($env)?.[ok]
 first($env)?.[ok].add()
+first($env)?.[ok].list
 first($env)?.[str]
+first($env)?.[str].String
+first($env)?.[str].f64
+first($env)?.[str]?.[str]
 first($env)?.[str]?.f64
 first($env)?.[str]?.ok
+first($env)?.[str]?.str
 first($env)?.add
 first($env)?.add()
+first($env)?.add()?.add()
+first($env)?.add.String
+first($env)?.add.f64
+first($env)?.add.greet()
+first($env)?.add?.String
 first($env)?.add?.[greet]
+first($env)?.add?.[i]
+first($env)?.add?.[list]
+first($env)?.any(foobar)
+first($env)?.any(foobar, ok)
 first($env)?.array
 first($env)?.array()
 first($env)?.array(foobar)
+first($env)?.array.ok
 first($env)?.f64
 first($env)?.f64()
 first($env)?.f64(f64)
@@ -8199,53 +16934,79 @@ first($env)?.f64.String
 first($env)?.findIndex(add)
 first($env)?.foo
 first($env)?.foo()
+first($env)?.foo()?.Bar
+first($env)?.foo(foo)?.[list]
 first($env)?.foo(foobar not contains foobar)
 first($env)?.foo(foobar)
 first($env)?.foo?.[greet]
+first($env)?.foobar
 first($env)?.foobar not in $env
 first($env)?.foobar.greet
+first($env)?.foobar.list
 first($env)?.foobar?.[greet]
 first($env)?.greet
 first($env)?.greet()
 first($env)?.greet(foobar not startsWith foobar)
 first($env)?.greet(foobar, foobar)
 first($env)?.greet(true)
+first($env)?.greet?.Bar
+first($env)?.greet?.[f64]
 first($env)?.greet?.[i]
+first($env)?.greet?.[str]
 first($env)?.greet?.str
 first($env)?.i
 first($env)?.i()
+first($env)?.i.i
 first($env)?.i?.add
+first($env)?.indexOf(foobar)
 first($env)?.list
 first($env)?.list()
+first($env)?.list().Bar
+first($env)?.list(Bar)
 first($env)?.list(foo)
+first($env)?.list(foobar)
+first($env)?.list(foobar).String
 first($env)?.list(foobar?.[Bar])
 first($env)?.list.str
+first($env)?.list?.[foo]
+first($env)?.list?.[str]
 first($env)?.list?.add
 first($env)?.map(add)
 first($env)?.ok
 first($env)?.ok()
+first($env)?.ok()?.[ok]
 first($env)?.ok(foobar)
 first($env)?.str
 first($env)?.str()
 first($env)?.str(f64)
+first($env)?.toJSON(String)
 first($env.array)
 first($env.list)
 first($env?.$env)
+first($env?.$env?.f64)
 first($env?.Bar)
 first($env?.Bar)?.array
 first($env?.Bar?.[array])
+first($env?.Bar?.[foo])
 first($env?.Bar?.f64)
 first($env?.String)
+first($env?.String)?.String
 first($env?.String)?.String()
+first($env?.String)?.i
 first($env?.[Bar])
 first($env?.[Bar])?.[i]
+first($env?.[Bar])?.[str]
 first($env?.[Bar])?.str
 first($env?.[Bar]?.String)
 first($env?.[Bar]?.f64)
 first($env?.[String])
+first($env?.[String])?.String()
+first($env?.[String])?.str
+first($env?.[String]?.f64)
 first($env?.[String]?.foo)
 first($env?.[foobar])
 first($env?.[foobar])?.Bar
+first($env?.[nil])
 first($env?.[nil]?.ok)
 first($env?.[str])
 first($env?.array)
@@ -8253,122 +17014,292 @@ first($env?.false)
 first($env?.foobar)
 first($env?.foobar)?.Bar()
 first($env?.foobar)?.i()
+first($env?.foobar?.str)
+first($env?.greet ?? ok)
 first($env?.list)
 first($env?.nil)
 first($env?.nil)?.f64
+first($env?.true)
+first(0 .. 0)
+first(0 .. i)
+first(0 ?? $env)
+first(0 ?? array)
+first(0 ?? false)
+first(0 ?? foo)
+first(0 ?? greet)
+first(0 ?? str)
+first(0 ?? true)
 first(0..i)
+first(1 .. 0)
 first(1 .. i)
+first(1 ?? $env)
+first(1 ?? 1.0)
+first(1 ?? foo)
+first(1 ?? ok)
+first(1 ?? true)
 first(1 | median(array))
+first(1.0 ?? $env)
+first(1.0 ?? $env.list)
+first(1.0 ?? 0)
+first(1.0 ?? 1)
+first(1.0 ?? add)
+first(1.0 ?? false)
+first(1.0 ?? foo)
+first(1.0 ?? greet)
+first(1.0 ?? i)
+first(1.0 ?? list)
 first(1.0 | min(array))
+first([$env, array])
 first([$env?.array])
 first([$env])
+first([0, array])
 first([0])
+first([1 > 1.0])
+first([1, add])
+first([1.0, 1.0])
 first([1.0])
 first([1])
 first([add, $env, greet])
 first([add])
 first([array])
 first([f64])
+first([false, $env])
+first([false, str])
 first([false])
+first([floor(f64)])
+first([foo ?? foo])
 first([foo])
 first([greet])
 first([i])
 first([list])
+first([nil, array])
 first([nil])
 first([ok])
 first([str])
 first([true])
+first([type(greet)])
+first(add ?? $env)?.f64
+first(add ?? 0)
+first(add ?? 1)
+first(add ?? foo)
+first(add ?? list)
+first(add ?? str)
+first(add ?? true)
+first(array ?? $env)
+first(array ?? add)
+first(array ?? array)
+first(array ?? i)
+first(array ?? nil)
+first(array ?? ok)
+first(array | map(#))
 first(array | map($env))
 first(array | map(0))
+first(array | map(1.0))
 first(array | map(foo))
+first(array | reduce($env, foo))
+first(array | reduce(list, nil))
 first(array | sortBy(#))
 first(array | sortBy(1.0))
 first(array | take(1))
 first(array)
 first(array) != i
+first(array) * $env?.i
+first(array) / i != nil
 first(array) == i
 first(array) > 1.0 > $env
+first(array) > f64
+first(array) >= $env.f64
+first(array) ?? $env?.String()
+first(array) ?? foo
+first(array) ?? list
 first(array) | bitand(1)
+first(array) | bitshr(1)
 first(array[:0])
 first(array[:1])
+first(concat(array) | reduce(#))
 first(concat(array))
 first(concat(list))
+first(f64 ?? $env)?.[foo]
+first(f64 ?? 1)
+first(f64 ?? array)
+first(f64 ?? greet)
+first(f64 ?? i)
+first(f64 ?? list)
+first(f64 ?? str)
+first(f64 | mean(array, 1))
+first(false ? i : list)
+first(false ?? $env)
+first(false ?? 1)
+first(false ?? 1.0)
+first(false ?? add)
+first(false ?? foo)
+first(false ?? str)
+first(filter($env, false))
 first(filter(list, ok))
+first(find($env, false))
+first(find($env, false))?.foo
 first(first($env))
+first(first($env))?.[add]
 first(flatten(array))
 first(flatten(list))
+first(foo ?? $env)
+first(foo ?? $env.add)
+first(foo ?? 0)
+first(foo ?? 1)
+first(foo ?? 1.0)
+first(foo ?? add)
+first(foo ?? array)
+first(foo ?? f64)
+first(foo ?? false)
+first(foo ?? greet)
+first(foo ?? i)
+first(foo ?? list)
+first(foo ?? ok)
+first(foo ?? str)
+first(foo ?? true)
+first(greet ?? 1)
+first(greet ?? 1.0)
+first(greet ?? f64)
+first(greet ?? foo.Bar)
+first(greet ?? i)
+first(greet ?? list)
+first(greet ?? true)
 first(i .. 1)
+first(i ?? $env)
+first(i ?? f64)
+first(i ?? false)
+first(i ?? greet)
+first(i ?? ok)
 first(i..i)
 first(if false { 0 } else { foo })
+first(if false { foo } else { greet })
+first(if false { foo } else { str })
+first(if ok { foo } else { false })
 first(if true { 0 } else { foo })?.add
 first(if true { ok } else { 1 })
 first(if true { ok } else { 1.0 })
 first(keys($env))
 first(last($env))
 first(let foobar = list; foobar)
+first(list ?? add)
+first(list ?? f64)
+first(list ?? false)
+first(list ?? str)
 first(list | map(#))
+first(list | map(#.Bar))
 first(list | map(0))
 first(list | map(add))
+first(list | map(false))
 first(list | map(true))
 first(list | reduce(list))
 first(list | sortBy(#.Bar))
 first(list)
 first(list) == $env?.String
+first(list) ?? $env?.[add]
+first(list) ?? f64
+first(list) ?? foo
+first(list) ?? greet
 first(list).Bar
 first(list).String
 first(list).String()
 first(list)?.Bar
 first(list)?.String
 first(list)?.String()
+first(list[:0])
+first(list[:1])
 first(list[:i])
 first(map($env, $env))
 first(map($env, 0))
+first(map($env, 1))
 first(map($env, array))
 first(map($env, f64))
+first(map($env, false))
 first(map($env, i))
+first(map($env, ok))
 first(map(array, #))
+first(map(array, #index))
+first(map(array, $env))
 first(map(array, 0))
+first(map(array, 1))
 first(map(array, 1.0))
 first(map(array, false))
 first(map(array, greet))
+first(map(array, list))
 first(map(array, str))
 first(map(array, true))
 first(map(list, #))
+first(map(list, $env) | findLast(true))
 first(map(list, 0))
+first(map(list, array))
+first(map(list, f64))
 first(map(list, foo))
 first(max($env))
 first(max(array))
 first(mean(array))
 first(median(array))
 first(min($env))
+first(min($env))?.add
+first(min($env)?.f64)
 first(min(array))
+first(min(array, 1, 1))
+first(nil ?? $env)
+first(nil ?? array)
 first(ok ? 0 : 1.0)
+first(ok ? add : false)
+first(ok ? ok : $env)
 first(ok ?: $env)
 first(ok ?: add)
 first(ok ?: list)
+first(ok ?? $env)
+first(ok ?? 0)
+first(ok ?? 1.0)
+first(ok ?? foo)
+first(ok ?? foo)?.[list]
+first(ok ?? greet)
 first(reduce(array, $env))
+first(reduce(list, list, $env))
+first(reverse(array))
 first(reverse(list))
 first(sort($env))
+first(sort(array))
 first(sortBy(array, #))
+first(sortBy(array, 1))
 first(sortBy(array, f64))
 first(sortBy(list, .Bar))
+first(str ?? 0)
+first(str ?? 1)
+first(str ?? 1.0)
+first(str ?? add)
+first(str ?? i)
+first(str ?? ok)
+first(take(array, i))
 first(toPairs($env))
 first(true ? 1.0 : foo)
 first(true ?: 1.0)?.str
+first(true ?: str)
+first(true ?? add)
+first(true ?? foo)
+first(true ?? list)
 first(uniq(array))
 first(uniq(list))
 first(values($env))
 first({foo: 1.0}.f64)
 first({foo: greet, foo: nil}.ok)
+first({foo: i, foo: f64}.String)
+flatten($env | map($env))
+flatten($env | map(1.0))
+flatten($env | map(add))
 flatten($env | map(array))
 flatten($env | map(foo))
 flatten($env | map(i))
+flatten($env | map(list))
 flatten($env.array)
 flatten($env.list)
 flatten($env?.array)
 flatten($env?.list)
 flatten($env?.list)?.[i]
 flatten(0 .. i)
+flatten(1 .. 0)
 flatten(1 .. 1)
 flatten(1 .. i)
 flatten([$env])
@@ -8379,32 +17310,67 @@ flatten([1.0, foo])
 flatten([1.0])
 flatten([1])
 flatten([add, greet])
+flatten([add, i])
 flatten([add])
+flatten([array, f64])
 flatten([array, ok])
 flatten([array])
+flatten([f64, $env, 1])
+flatten([f64, nil])
 flatten([f64])
 flatten([false, list])
 flatten([false])
+flatten([foo, 0])
 flatten([foo, 1.0])
+flatten([foo, str])
 flatten([foo])
+flatten([greet, foo])
 flatten([greet])
 flatten([i, list])
 flatten([i])
 flatten([list])
+flatten([nil == ok])
 flatten([nil])
+flatten([ok, array])
 flatten([ok, true])
 flatten([ok])
+flatten([str, list])
 flatten([str])
+flatten([true])
+flatten(array ?? 0)
+flatten(array ?? 1)
+flatten(array ?? add)
+flatten(array ?? f64)
+flatten(array ?? foo)
+flatten(array ?? list)
+flatten(array ?? nil)
+flatten(array ?? true)
 flatten(array | map(#))
 flatten(array | map(1.0))
+flatten(array | map(array))
 flatten(array | map(false))
+flatten(array | reduce(array, false))
 flatten(array | sortBy(#))
 flatten(array | sortBy(1.0))
+flatten(array | sortBy(i))
 flatten(array)
+flatten(array) != array
+flatten(array) == array
+flatten(array) == list
+flatten(array) ?? greet
+flatten(array) ?? i
+flatten(array) | filter(ok)
 flatten(array) | groupBy(#)
+flatten(array) | groupBy(1.0)
+flatten(array) | groupBy(f64)
 flatten(array) | map(#)
+flatten(array) | map(ok)
+flatten(array) | min(1.0)
 flatten(array) | one(true)
+flatten(array) | reduce(#)
 flatten(array) | reduce(1.0)
+flatten(array) | reduce(foo)
+flatten(array) | reduce(true)
 flatten(array) | sum(#)
 flatten(array)?.[i]
 flatten(array)[i:]
@@ -8414,81 +17380,147 @@ flatten(concat(array))
 flatten(concat(list))
 flatten(filter(list, false))
 flatten(flatten(array))
+flatten(flatten(list))
+flatten(groupBy(array, #).String)
 flatten(groupBy(list, #).i)
 flatten(i .. 0)
 flatten(i..i)
+flatten(if ok { array } else { foo })
+flatten(if ok { list } else { array })
 flatten(if true { array } else { add })
 flatten(keys($env))
+flatten(let z = array; z)
+flatten(list ?? $env)
+flatten(list ?? 1)
+flatten(list ?? 1.0)
+flatten(list ?? nil)
 flatten(list | map(#))
 flatten(list | map(i))
+flatten(list | sortBy(0))
 flatten(list | sortBy(f64))
 flatten(list | sortBy(str))
 flatten(list)
 flatten(list) == list
 flatten(list) | filter(true)
+flatten(list) | findLast(ok)
 flatten(list) | findLastIndex(false)
+flatten(list) | groupBy(!ok)
+flatten(list) | groupBy(#)
 flatten(list) | groupBy(foo)
+flatten(list) | groupBy(i)
+flatten(list) | map(1.0)
+flatten(list) | map(add)
 flatten(list) | map(f64)
 flatten(list) | map(false)
 flatten(list) | map(foo)
 flatten(list) | map(ok)
+flatten(list) | none(true)
 flatten(list) | reduce(#)
 flatten(list) | reduce($env, $env)
+flatten(list) | reduce(1.0)
 flatten(list) | sortBy(0)
+flatten(list) | sortBy(1.0)
 flatten(list) | sortBy(str)
+flatten(list) | sum(1)
 flatten(list)?.[i]
 flatten(list)[:]
+flatten(list[0:])
+flatten(list[1:])
+flatten(list[:])
 flatten(map($env, $env))
 flatten(map($env, 0))
 flatten(map($env, 1.0))
+flatten(map($env, f64))
+flatten(map($env, false))
+flatten(map(array, f64))
+flatten(map(array, i))
 flatten(map(array, true))
 flatten(map(list, #))
 flatten(map(list, $env))
 flatten(map(list, .Bar))
+flatten(map(list, f64))
 flatten(map(list, ok))
+flatten(nil ?? array)
+flatten(nil ?? list)
 flatten(reduce(array, array))
 flatten(reverse(array))
 flatten(reverse(list))
+flatten(sort($env))
 flatten(sort(array))
 flatten(sortBy(array, #))
 flatten(sortBy(array, 1))
 flatten(sortBy(array, 1.0))
 flatten(sortBy(array, f64))
+flatten(sortBy(list, 1.0))
+flatten(sortBy(list, i))
 flatten(toPairs($env))
+flatten(true ? list : list)
 flatten(uniq(array))
 flatten(uniq(list))
 flatten(values($env))
+float($env | findIndex(true))
 float($env | findLastIndex(ok))
 float($env | findLastIndex(true))
+float($env | sum(0))
 float($env | sum(1.0))
 float($env | sum(f64))
+float($env | sum(i))
 float($env.f64)
 float($env.i)
 float($env?.f64)
 float($env?.i)
+float(-0)
+float(-1)
+float(-1.0)
+float(-f64)
+float(-i)
 float(0 % 1)
 float(0 % i)
 float(0 * 1)
 float(0 * 1.0)
 float(0 * f64)
+float(0 ** 1)
 float(0 ** 1.0)
 float(0 ** f64)
 float(0 ** i)
 float(0 + 1)
 float(0 + i)
+float(0 - 1)
 float(0 - 1.0)
 float(0 - i)
 float(0 / 0)
 float(0 / 1.0)
+float(0 / f64)
 float(0 / i)
+float(0 ?? $env)
+float(0 ?? $env?.[i])
+float(0 ?? false)
+float(0 ?? greet)
+float(0 ?? nil)
+float(0 ?? true)
+float(0 ^ 0)
+float(0 ^ 1)
 float(0 ^ 1.0)
+float(0 ^ f64)
 float(0 ^ i)
+float(0 | median(1.0))
+float(0) != $env && ok
+float(0) != 1.0 && false
+float(0) ** f64
+float(0) + $env?.f64
+float(0) - float(0)
 float(0) > f64
 float(0) > i
+float(0) >= -1
 float(0) ^ f64
+float(1 % 1)
 float(1 % i)
+float(1 * 1)
 float(1 * 1.0)
+float(1 * f64)
+float(1 * i)
 float(1 ** 1)
+float(1 ** 1.0)
 float(1 ** f64)
 float(1 ** i)
 float(1 + 1)
@@ -8496,23 +17528,40 @@ float(1 + 1.0)
 float(1 + i)
 float(1 - 1.0)
 float(1 - f64)
+float(1 / 0)
 float(1 / 1)
 float(1 / 1.0)
+float(1 ?? $env)
+float(1 ?? $env?.array)
+float(1 ?? 0)
+float(1 ?? 1.0)
+float(1 ?? add)
+float(1 ?? nil)
+float(1 ?? ok)
 float(1 ^ 0)
+float(1 ^ 1)
 float(1 ^ 1.0)
 float(1 ^ i)
+float(1) + i
 float(1) - f64
 float(1) < f64
+float(1) == f64
 float(1) == i
+float(1) ?? f64
+float(1) ?? foo ?? $env
+float(1) ?? str
+float(1) ^ i
 float(1) in [add, true]
 float(1.0 * 0)
 float(1.0 * 1)
 float(1.0 * 1.0)
 float(1.0 * f64)
 float(1.0 * i)
+float(1.0 ** 0)
 float(1.0 ** 1)
 float(1.0 ** 1.0)
 float(1.0 ** f64)
+float(1.0 ** i)
 float(1.0 + 0)
 float(1.0 + 1.0)
 float(1.0 + f64)
@@ -8522,9 +17571,25 @@ float(1.0 - 1)
 float(1.0 - 1.0)
 float(1.0 - f64)
 float(1.0 - i)
+float(1.0 / 0)
+float(1.0 / 1)
 float(1.0 / 1.0)
 float(1.0 / f64)
 float(1.0 / i)
+float(1.0 ?? $env)
+float(1.0 ?? 0)
+float(1.0 ?? 1)
+float(1.0 ?? 1.0)
+float(1.0 ?? add)
+float(1.0 ?? array)
+float(1.0 ?? f64)
+float(1.0 ?? false)
+float(1.0 ?? foo)
+float(1.0 ?? i)
+float(1.0 ?? list)
+float(1.0 ?? nil)
+float(1.0 ?? str)
+float(1.0 ^ 0)
 float(1.0 ^ 1)
 float(1.0 ^ 1.0)
 float(1.0 ^ f64)
@@ -8532,25 +17597,37 @@ float(1.0 ^ i)
 float(1.0 | min(f64))
 float(1.0) != $env?.[str]
 float(1.0) * max(f64)
+float(1.0) ** i
 float(1.0) - f64
+float(1.0) - i
 float(1.0) / i
+float(1.0) < i
+float(1.0) <= i
 float(1.0) == 0 % 1
 float(1.0) == i
 float(1.0) == i != false
 float(1.0) > f64
 float(1.0) >= last(array)
+float(1.0) | median(1.0)
 float(abs(0))
+float(abs(1))
 float(abs(1.0))
 float(abs(f64))
 float(abs(i))
 float(add(0, i))
+float(add(1, 1))
+float(array | findLastIndex(true))
 float(array | max(1))
+float(array | reduce(#acc))
 float(array | reduce(#index, 1.0))
+float(array | reduce(1))
 float(array | sum(#))
+float(array | sum(0))
 float(array | sum(1.0))
 float(array?.[i])
 float(bitand(0, i))
 float(bitnot(0))
+float(bitnot(1))
 float(bitnot(i))
 float(bitor(0, i))
 float(bitshl(i, 0))
@@ -8562,55 +17639,108 @@ float(ceil(1.0))
 float(ceil(f64))
 float(ceil(i))
 float(count($env, false))
+float(count($env, ok))
+float(count(array, true))
 float(count(list, false))
 float(count(list, ok))
+float(f64 * 1)
 float(f64 * 1.0)
+float(f64 * f64)
 float(f64 ** 0)
 float(f64 ** 1)
 float(f64 ** 1.0)
+float(f64 + 0)
+float(f64 + 1.0)
 float(f64 + f64)
 float(f64 + i)
 float(f64 - 1.0)
+float(f64 / 0)
+float(f64 / 1)
 float(f64 / 1.0)
+float(f64 / f64)
 float(f64 / i)
+float(f64 ?? 1)
+float(f64 ?? 1.0)
+float(f64 ?? add)
+float(f64 ?? f64)
+float(f64 ?? greet)
+float(f64 ?? true)
 float(f64 ^ 0)
+float(f64 ^ 1)
 float(f64 ^ 1.0)
 float(f64)
 float(f64) != f64
+float(f64) * 1.0 ** i
+float(f64) ** f64
+float(f64) / max(1)
 float(f64) == i
+float(f64) ?? greet
+float(f64) ?? upper(str)
 float(false ? i : 1.0)
 float(false ? str : 1.0)
 float(false ?: 1.0)
 float(false ?: i)
 float(findIndex($env, ok))
 float(findIndex(array, true))
+float(findLastIndex($env, ok))
 float(findLastIndex($env, true))
+float(findLastIndex(array, ok))
+float(first(array))
+float(float(0))
 float(float(1))
+float(float(1.0))
 float(float(f64))
+float(float(i))
+float(floor(0))
 float(floor(1))
 float(floor(1.0))
 float(floor(f64))
+float(floor(i))
 float(i % 1)
+float(i * 0)
 float(i * 1.0)
+float(i * f64)
 float(i ** 1.0)
+float(i ** i)
+float(i + 0)
 float(i + 1)
+float(i + 1.0)
 float(i - 0)
 float(i - 1)
+float(i - 1.0)
 float(i - f64)
 float(i - i)
+float(i / 0)
 float(i / 1)
 float(i / 1.0)
+float(i ?? $env)
+float(i ?? 1)
+float(i ?? 1.0)
+float(i ?? add)
+float(i ?? foo)
+float(i ?? nil)
+float(i ?? true)
+float(i ^ i)
+float(i | bitor(0))
 float(i)
 float(i) + first(array)
+float(i) == i
+float(i) > f64
+float(i) in $env?.[String]
+float(i) | max(f64)
 float(if false { 1.0 } else { 1 })
 float(if false { greet } else { 1 })
 float(if false { greet } else { 1.0 })
+float(if false { ok } else { 1.0 })
 float(if true { 0 } else { $env })
+float(if true { 1.0 } else { $env })
+float(if true { 1.0 } else { i })
 float(int(0))
 float(int(1))
 float(int(1.0))
 float(int(f64))
 float(int(i))
+float(last(array))
 float(lastIndexOf(str, str))
 float(len($env))
 float(len(array))
@@ -8619,9 +17749,14 @@ float(len(str))
 float(let foobar = i; foobar)
 float(list | findIndex(ok))
 float(list | reduce(i))
+float(list | sum(1.0))
 float(list | sum(f64))
+float(max($env?.f64))
 float(max(0))
+float(max(1))
 float(max(1.0))
+float(max(f64, 1))
+float(max(f64, 1.0))
 float(max(i))
 float(mean(0))
 float(mean(1))
@@ -8629,22 +17764,33 @@ float(mean(1.0 - 1.0))
 float(mean(1.0))
 float(mean(array))
 float(mean(f64))
+float(mean(f64, 1))
 float(mean(i))
 float(median(0))
+float(median(1))
 float(median(1.0))
 float(median(1.0, 0, 0))
 float(median(1.0, i))
+float(median(array))
+float(median(array, f64))
 float(median(f64))
 float(median(i))
+float(min($env).f64)
 float(min($env?.array))
 float(min(0))
+float(min(0, 1))
+float(min(1))
 float(min(1.0))
 float(min(array))
+float(min(f64))
 float(min(i))
+float(nil ?? 1.0)
 float(reduce($env, 1.0, 1.0))
+float(reduce(array, #))
 float(reduce(list, 0))
 float(reduce(list, 1))
 float(reduce(list, i))
+float(round(0))
 float(round(1))
 float(round(1.0))
 float(round(f64))
@@ -8653,71 +17799,140 @@ float(string(0))
 float(string(1))
 float(string(1.0))
 float(string(f64))
+float(string(i))
 float(sum($env, 0))
 float(sum($env, 1))
+float(sum($env, 1.0))
+float(sum($env.array))
 float(sum($env?.array))
 float(sum(array))
 float(sum(array, #))
 float(sum(array, 1))
 float(sum(array, i))
 float(sum(list, 1))
+float(toJSON(0))
 float(toJSON(1))
+float(toJSON(1.0))
+float(toJSON(f64))
 float(toJSON(i))
 float(toJSON(min(1.0)))
 float(true ? 1.0 : ok)
 float(true ? f64 : foo)
 float(true ? f64 : str)
+floor($env | count(true))
 floor($env | findIndex(ok))
+floor($env | findLastIndex(true))
+floor($env | reduce(f64, f64))
+floor($env.array?.[i])
 floor($env.f64)
 floor($env.i)
+floor($env?.add(i, 1))
 floor($env?.f64)
+floor($env?.i ^ f64)
 floor($env?.i)
+floor(-0)
+floor(-1)
+floor(-1.0)
+floor(-f64)
+floor(-i)
 floor(0 % i)
 floor(0 * 1)
 floor(0 * 1.0)
+floor(0 * f64)
 floor(0 * i)
+floor(0 ** 0)
+floor(0 ** 1.0)
+floor(0 ** f64)
+floor(0 ** i)
 floor(0 + 1.0)
 floor(0 + f64)
 floor(0 - 0)
 floor(0 - 1)
 floor(0 - 1.0)
+floor(0 - f64)
 floor(0 - i)
+floor(0 / 0)
 floor(0 / 1)
 floor(0 / f64)
+floor(0 / i)
+floor(0 ?? add)
+floor(0 ?? array)
+floor(0 ?? foo)
+floor(0 ?? greet)
+floor(0 ?? i)
+floor(0 ?? str)
+floor(0 ?? true)
 floor(0 ^ 0)
 floor(0 ^ 1.0)
+floor(0 ^ f64)
+floor(0 | bitxor(i))
 floor(0 | min(1.0))
 floor(0) * i
+floor(0) * reduce(array, #)
+floor(0) < array?.[i]
+floor(0) < f64
+floor(0) < i
 floor(0) <= f64
+floor(0) >= i
+floor(0) ?? f64
+floor(0) ?? greet(str)
+floor(0) ?? list
+floor(0.0)
+floor(1 % 1)
+floor(1 % i)
 floor(1 * 1)
 floor(1 * 1.0)
 floor(1 * f64)
 floor(1 * i)
 floor(1 ** 0)
 floor(1 ** 1)
+floor(1 ** 1.0)
 floor(1 ** i)
+floor(1 + 1)
 floor(1 + 1.0)
+floor(1 + f64)
 floor(1 + i)
+floor(1 - 1)
 floor(1 - i)
 floor(1 / 0)
 floor(1 / 1.0)
 floor(1 / f64)
+floor(1 ?? $env?.[array])
+floor(1 ?? 0)
+floor(1 ?? 1)
+floor(1 ?? false)
+floor(1 ?? foo)
+floor(1 ?? greet)
+floor(1 ?? i)
+floor(1 ?? nil)
+floor(1 ?? str)
+floor(1 ?? true)
 floor(1 ^ 0)
 floor(1 ^ 1.0)
 floor(1 ^ f64)
 floor(1 ^ i)
 floor(1) != f64
 floor(1) * f64
+floor(1) * i
+floor(1) ** f64
 floor(1) + $env?.f64
+floor(1) - i
 floor(1) <= i
+floor(1) ?? str
 floor(1) in array
+floor(1) | mean(1.0)
+floor(1) | min(1.0)
+floor(1.0 * 0)
 floor(1.0 * 1)
 floor(1.0 * 1.0)
 floor(1.0 * f64)
+floor(1.0 * i)
+floor(1.0 ** 0)
 floor(1.0 ** 1)
 floor(1.0 ** 1.0)
 floor(1.0 ** f64)
 floor(1.0 ** i)
+floor(1.0 + 0)
 floor(1.0 + 1)
 floor(1.0 + 1.0)
 floor(1.0 + f64)
@@ -8726,19 +17941,36 @@ floor(1.0 - 1.0)
 floor(1.0 - f64)
 floor(1.0 - i)
 floor(1.0 / 0)
+floor(1.0 / 1)
 floor(1.0 / 1.0)
 floor(1.0 / f64)
+floor(1.0 ?? $env)
+floor(1.0 ?? 0)
+floor(1.0 ?? 1)
+floor(1.0 ?? 1.0)
+floor(1.0 ?? add)
+floor(1.0 ?? false)
+floor(1.0 ?? foo)
+floor(1.0 ?? greet)
+floor(1.0 ?? i)
+floor(1.0 ?? nil)
+floor(1.0 ?? str)
 floor(1.0 ^ 0)
 floor(1.0 ^ 1.0)
 floor(1.0 ^ i)
 floor(1.0 | max(f64))
 floor(1.0 | mean(array))
+floor(1.0 | min(f64))
 floor(1.0) != $env?.f64
 floor(1.0) + f64
 floor(1.0) - $env.i
+floor(1.0) <= i
 floor(1.0) == f64
 floor(1.0) > i
+floor(1.0) ?? array
+floor(1.0) | mean(1.0)
 floor(1.0) | median(0)
+floor(1.0) | min(f64)
 floor(abs(0))
 floor(abs(1))
 floor(abs(1.0))
@@ -8746,73 +17978,131 @@ floor(abs(f64))
 floor(abs(i))
 floor(add(i, i))
 floor(array | findLast(ok))
+floor(array | findLastIndex(ok))
+floor(array | findLastIndex(true))
 floor(array | mean(1))
 floor(array | mean(f64))
 floor(array | reduce(#))
+floor(array | reduce(#index))
+floor(array | sum(#))
 floor(array | sum(f64))
+floor(array | sum(i))
+floor(array?.[0])
+floor(array?.[1])
 floor(array?.[i])
+floor(bitand(i, 1))
+floor(bitnot(-0))
 floor(bitnot(0))
 floor(bitnot(1))
+floor(bitnot(i))
+floor(bitshr(1, i))
+floor(bitxor(0, 1))
+floor(ceil(0))
 floor(ceil(1))
 floor(ceil(1.0))
+floor(ceil(f64 + 0))
+floor(ceil(f64))
 floor(ceil(i))
 floor(count($env, true))
 floor(count(list, ok))
+floor(f64 * 1)
 floor(f64 * 1.0)
+floor(f64 * i)
 floor(f64 ** 1.0)
 floor(f64 ** i)
 floor(f64 + 0)
+floor(f64 + 1)
 floor(f64 + 1.0)
+floor(f64 + f64)
+floor(f64 + i)
 floor(f64 - 1)
 floor(f64 - 1.0)
+floor(f64 - f64)
 floor(f64 - i)
+floor(f64 / 1.0)
 floor(f64 / f64)
+floor(f64 ?? $env)
+floor(f64 ?? 0)
+floor(f64 ?? 1)
+floor(f64 ?? 1.0)
+floor(f64 ?? foo)
+floor(f64 ?? greet)
+floor(f64 ^ 0)
 floor(f64 ^ 1.0)
 floor(f64 ^ i)
 floor(f64)
+floor(f64) ** f64
+floor(f64) / i
 floor(f64) < f64
 floor(f64) >= f64
 floor(f64) >= i ^ f64
 floor(f64) in array
+floor(false ? $env : i)
 floor(false ?: 1)
 floor(findIndex($env, ok))
 floor(findIndex(list, true))
 floor(findLast(array, ok))
 floor(findLastIndex(array, true))
+floor(findLastIndex(list, ok))
 floor(first(array))
 floor(float(0))
 floor(float(1))
 floor(float(1.0))
 floor(float(f64))
+floor(float(i))
 floor(floor(0))
 floor(floor(1))
 floor(floor(1.0))
+floor(floor(f64))
+floor(floor(i))
 floor(i * 1.0)
 floor(i * i)
+floor(i ** 0)
 floor(i ** 1)
 floor(i ** 1.0)
+floor(i ** f64)
 floor(i ** i)
+floor(i + 1)
 floor(i + 1.0)
 floor(i + i)
+floor(i - 0)
+floor(i - 1.0)
 floor(i - f64)
 floor(i / 0)
 floor(i / 1)
 floor(i / 1.0)
 floor(i / f64)
+floor(i ?? 0)
+floor(i ?? foo)
+floor(i ?? greet)
+floor(i ?? i)
+floor(i ?? ok)
+floor(i ?? str)
+floor(i ?? true)
 floor(i ^ 0)
+floor(i ^ 1)
 floor(i ^ 1.0)
+floor(i ^ f64)
 floor(i ^ i)
+floor(i | add(1))
+floor(i | median(array))
 floor(i | min(0))
 floor(i)
+floor(i) * f64 < 1.0
 floor(i) ** 1.0 >= 1.0
 floor(i) ** i
 floor(i) - f64
+floor(i) / 1.0 >= 1.0
 floor(i) / sum(array)
 floor(i) == $env != ok
+floor(i) == f64
 floor(i) == i
+floor(i) > f64
 floor(i) ^ f64
 floor(i) | max(1.0)
+floor(if ok { f64 } else { nil })
 floor(if ok { i } else { $env })
+floor(if true { 1.0 } else { f64 })
 floor(int(0))
 floor(int(1))
 floor(int(1.0))
@@ -8824,7 +18114,9 @@ floor(len(array))
 floor(len(list))
 floor(len(str))
 floor(let foobar = 1.0; foobar)
+floor(let x = f64; x)
 floor(list | sum(1))
+floor(max(0 ^ 0))
 floor(max(0))
 floor(max(1))
 floor(max(1.0))
@@ -8833,38 +18125,61 @@ floor(max(i))
 floor(mean(0))
 floor(mean(0, 1.0))
 floor(mean(1))
+floor(mean(1, 1))
 floor(mean(1.0))
 floor(mean(array))
 floor(mean(f64))
 floor(mean(i))
 floor(median(0))
+floor(median(0, 1.0))
 floor(median(1))
 floor(median(1.0))
 floor(median(array))
 floor(median(f64))
 floor(median(i))
+floor(min(0))
 floor(min(1))
 floor(min(1.0))
 floor(min(1.0, 0))
 floor(min(array))
+floor(min(array, 1))
+floor(min(f64))
 floor(min(i))
+floor(nil ?? 0)
+floor(nil ?? 1.0)
+floor(nil ?? f64)
 floor(ok ? 1.0 : nil)
 floor(ok ? i : greet)
 floor(reduce(array, #))
+floor(reduce(array, #, list))
 floor(reduce(array, 1))
+floor(reduce(list, 1))
+floor(reduce(list, f64))
+floor(round(0))
 floor(round(1))
 floor(round(1.0))
+floor(round(add(0, i)))
 floor(round(f64))
+floor(round(i))
+floor(sum($env, 0))
 floor(sum($env, 1.0))
 floor(sum(array))
 floor(sum(array, #))
 floor(sum(array, 1.0))
+floor(sum(list, 0))
 floor(sum(list, 1.0))
 foo
 foo != $env != ok
 foo != $env && ok and ok
+foo != $env == ok
 foo != $env == true
 foo != $env ? $env : nil
+foo != $env ?? greet
+foo != $env ?? list
+foo != $env and ok
+foo != $env or $env[foobar:]
+foo != $env || false
+foo != $env || ok
 foo != $env.foo
 foo != $env?.Bar
 foo != $env?.Bar?.[i]
@@ -8872,57 +18187,126 @@ foo != $env?.Bar?.array
 foo != $env?.Bar?.list
 foo != $env?.String
 foo != $env?.String?.[greet]
+foo != $env?.String?.array
 foo != $env?.String?.greet
+foo != $env?.[Bar?.[greet]]
 foo != $env?.[Bar]
 foo != $env?.[String]
 foo != $env?.[String]?.add
+foo != $env?.[String]?.list
+foo != $env?.[foobar?.[foo]]
 foo != $env?.[foobar]
 foo != $env?.[str]
 foo != $env?.foo
 foo != $env?.foobar
 foo != $env?.not
+foo != 0 ?? ok
+foo != 1 ?? f64
+foo != 1.0 ?? add
+foo != 1.0 ?? greet
+foo != 1.0 ?? ok
+foo != add ?? array
+foo != array ?? ok
+foo != array ?? str
+foo != first($env)
 foo != first(list)
 foo != foo
 foo != foo != $env
 foo != foo && $env.ok
+foo != foo && f64 == 0
 foo != foo && get($env, 1)
 foo != foo == $env || false
 foo != foo == false
 foo != foo == true
+foo != foo ?: i
+foo != foo ?? $env.array
+foo != foo ?? add
+foo != foo ?? foo
+foo != foo ?? list
+foo != foo ?? nil
+foo != foo and find($env, .f64)
+foo != foo and true
+foo != foo or 0 ?? false
 foo != foo or ok
+foo != foo || ok
+foo != greet ?? add
+foo != greet ?? false
+foo != i ?? false
+foo != i ?? ok
+foo != last(list)
+foo != list ?? $env
+foo != list ?? greet(str)
 foo != list?.[i]
+foo != mean(array)
 foo != nil != $env
+foo != nil == $env.ok
 foo != nil ? 1.0 : $env
 foo != nil ? str : foo
+foo != nil ?: $env
+foo != nil ?? foo
 foo != nil || sum($env, $env)
+foo != str ?? f64
 foo == $env != nil
+foo == $env != ok
+foo == $env && ok
+foo == $env ?: $env | map(foo)
+foo == $env ?? array
+foo == $env ?? greet
+foo == $env and $env
 foo == $env in $env?.foobar
 foo == $env or $env.ok
 foo == $env || $env
 foo == $env.foo
 foo == $env?.Bar
 foo == $env?.Bar?.[i]
+foo == $env?.Bar?.[list]
 foo == $env?.String
+foo == $env?.String?.[array]
 foo == $env?.[Bar]
 foo == $env?.[String]
 foo == $env?.[String]?.[f64]
+foo == $env?.[foo?.Bar]
+foo == $env?.[foobar?.[foobar]]
 foo == $env?.[foobar?.greet]
 foo == $env?.[foobar]
 foo == $env?.[str]
 foo == $env?.foo
 foo == $env?.foobar
 foo == $env?.foobar?.array()
+foo == $env?.foobar?.ok
 foo == $env?.nil
 foo == $env?.not
+foo == 0 ?? foo?.String
+foo == 0 ?? i ?? $env
+foo == 1 ?? f64
+foo == 1.0 ?? $env
+foo == 1.0 ?? false
+foo == 1.0 ?? foo == false
+foo == add ?? 0
+foo == add ?? 1
+foo == array ?? foo
+foo == f64 ?? str
+foo == false ?? 1.0
+foo == false ?? i
 foo == foo
 foo == foo != ok
+foo == foo && 0 ?? true
+foo == foo == false
 foo == foo == ok
 foo == foo ? $env : $env
 foo == foo ?: f64
 foo == foo ?: i
+foo == foo ?? 0
+foo == foo ?? 1.0
+foo == foo ?? greet
+foo == foo ?? ok
+foo == foo ?? str
 foo == foo or $env?.[greet]
 foo == foo or ok
+foo == foo || $env?.[array]
+foo == foo || false
 foo == foo || ok
+foo == i ?? add
 foo == last($env)
 foo == last(list)
 foo == list?.[i]
@@ -8930,49 +18314,290 @@ foo == nil != $env
 foo == nil != nil
 foo == nil && $env or $env
 foo == nil && f64 >= 1.0
+foo == nil && nil != foo
 foo == nil == $env
 foo == nil ? foo : i
 foo == nil ? true : i
+foo == nil ?: str
 foo == nil and ok
 foo == nil || false
+foo == ok ?? $env?.[foo]
+foo == ok ?? f64
+foo == ok ?? foo
+foo == true ?? foo
+foo == true ?? str
+foo ?? !$env
+foo ?? !ok
+foo ?? $env ?? f64
+foo ?? $env ?? foo
+foo ?? $env ?? list
+foo ?? $env ?? str
+foo ?? $env.add
+foo ?? $env.array
+foo ?? $env.f64
+foo ?? $env.foo
+foo ?? $env.greet
+foo ?? $env.i
+foo ?? $env.list
+foo ?? $env.ok
+foo ?? $env.str
+foo ?? $env?.Bar
+foo ?? $env?.Bar()
+foo ?? $env?.Bar()?.list
+foo ?? $env?.Bar.Bar()
+foo ?? $env?.String
+foo ?? $env?.String()
+foo ?? $env?.[$env?.list()]
+foo ?? $env?.[$env][:Bar].list
+foo ?? $env?.[Bar]
+foo ?? $env?.[String]
+foo ?? $env?.[String].String
+foo ?? $env?.[add(ok)]
+foo ?? $env?.[add?.f64]
+foo ?? $env?.[add]
+foo ?? $env?.[add]?.ok
+foo ?? $env?.[array]
+foo ?? $env?.[array]?.[array]
+foo ?? $env?.[f64]
+foo ?? $env?.[f64]?.[i]
+foo ?? $env?.[f64]?.count(foobar)?.foobar?.i()
+foo ?? $env?.[f64]?.i()
+foo ?? $env?.[foo ?? nil]
+foo ?? $env?.[foo]
+foo ?? $env?.[foo]?.str
+foo ?? $env?.[foobar not contains ok]
+foo ?? $env?.[foobar | none(#)]
+foo ?? $env?.[foobar.str()]
+foo ?? $env?.[foobar?.i]
+foo ?? $env?.[foobar]
+foo ?? $env?.[foobar]?.array
+foo ?? $env?.[greet]
+foo ?? $env?.[i]
+foo ?? $env?.[i]?.ok()
+foo ?? $env?.[lastIndexOf(foo)]
+foo ?? $env?.[list]
+foo ?? $env?.[list].array(foobar)
+foo ?? $env?.[nil | sortBy(.Bar, foo)]
+foo ?? $env?.[nil]
+foo ?? $env?.[ok]
+foo ?? $env?.[ok]?.String
+foo ?? $env?.[one(f64, foo)]
+foo ?? $env?.[sort($env, list)]
+foo ?? $env?.[str]
+foo ?? $env?.[str]?.[str]
+foo ?? $env?.[str]?.array
+foo ?? $env?.[str]?.foo
+foo ?? $env?.add
+foo ?? $env?.array
+foo ?? $env?.f64
+foo ?? $env?.foo
+foo ?? $env?.foobar
+foo ?? $env?.greet
+foo ?? $env?.groupBy(nil, str, nil)?.i
+foo ?? $env?.i
+foo ?? $env?.list
+foo ?? $env?.nil
+foo ?? $env?.nil?.[greet]
+foo ?? $env?.ok
+foo ?? $env?.str
+foo ?? $env[$env < ok:]
+foo ?? $env[:$env]
+foo ?? $env[:array]
+foo ?? $env[:false].array
+foo ?? $env[:foo]
+foo ?? $env[:foobar]
+foo ?? $env[:i]
+foo ?? $env[:list]
+foo ?? $env[Bar?.str(foobar):]
+foo ?? $env[add:]
+foo ?? $env[foo.greet(ok):add | find(0)]
+foo ?? $env[foobar - true:]
+foo ?? $env[foobar.ok(foo):foobar?.foo]
+foo ?? $env[foobar:]
+foo ?? $env[foobar:true]
+foo ?? $env[get(greet, foobar):]
+foo ?? $env[i || nil:i($env, 1.0)]
+foo ?? $env[sortBy(foo, .greet):]
+foo ?? -$env
+foo ?? -1
+foo ?? -1.0
+foo ?? -i
+foo ?? 1 ?? add
+foo ?? 1.0 ?? sortBy(array, 1)
+foo ?? [0]
+foo ?? [1]
+foo ?? [f64]
+foo ?? [foo, str]
+foo ?? [i]
+foo ?? [true, foo]
+foo ?? add
+foo ?? add ?? add
+foo ?? add ?? str
+foo ?? all($env, #)
+foo ?? all($env, #.Bar)
+foo ?? any($env, $env)
+foo ?? array
+foo ?? array ?? f64
+foo ?? array ?? greet
+foo ?? array?.[i]
+foo ?? array[:0]
+foo ?? array[:]
+foo ?? array[:count($env)]
+foo ?? concat(list)
+foo ?? concat(map(list, str))?.[i]
+foo ?? count($env)
+foo ?? count(array)
+foo ?? count(list)
+foo ?? date(1)
+foo ?? date(array)
+foo ?? date(array, list, ok)
+foo ?? date(foo)
+foo ?? date(true)
+foo ?? duration(str)
+foo ?? f64
+foo ?? f64 ?? add
+foo ?? false ?? list
+foo ?? false ?? nil
+foo ?? filter($env, #)
+foo ?? find($env, #.add)
+foo ?? findLastIndex($env, .add)
+foo ?? findLastIndex(list, $env)
+foo ?? float(1.0)
+foo ?? floor(0)
+foo ?? floor(i)
+foo ?? foo
+foo ?? foo ?? 1.0
+foo ?? foo ?? add
+foo ?? foo ?? f64
+foo ?? foo ?? foo
+foo ?? foo ?? greet
+foo ?? foo ?? i
+foo ?? foo ?? list
+foo ?? foo ?? str
+foo ?? foo.Bar
+foo ?? foo.String
+foo ?? foo.String()
+foo ?? foo?.Bar
+foo ?? foo?.String
+foo ?? foo?.String()
+foo ?? fromPairs($env)
+foo ?? greet
+foo ?? greet($env)
+foo ?? greet(str)
+foo ?? groupBy($env, #.add)
+foo ?? groupBy(array, i)
+foo ?? i
+foo ?? i ?? i
+foo ?? int(1)
+foo ?? list
+foo ?? list?.[1]
+foo ?? list?.[i]
+foo ?? lower($env)
+foo ?? map($env, i)
+foo ?? mean(array)
+foo ?? mean(i)
+foo ?? mean(list, str)
+foo ?? median($env .. $env)
+foo ?? median(0)
+foo ?? median(array)
+foo ?? median(f64)
+foo ?? min(array, 1.0)
+foo ?? nil ?? 1.0
+foo ?? nil ?? add
+foo ?? nil ?? array
+foo ?? nil ?? str
+foo ?? not $env
+foo ?? not false
+foo ?? not ok
+foo ?? ok
+foo ?? ok ?? foo?.String
+foo ?? ok ?? i
+foo ?? reduce($env, #.i)
+foo ?? reduce($env, .array)
+foo ?? reverse(list)
+foo ?? sort($env)
+foo ?? sortBy(array, ok)
+foo ?? str
+foo ?? string($env)
+foo ?? string(add)
+foo ?? string(greet)
+foo ?? sum($env ?? foo).ok
+foo ?? sum($env).array
+foo ?? sum($env, true)
+foo ?? sum(list)
+foo ?? toJSON(1)
+foo ?? toJSON(array)
+foo ?? trimPrefix(str)
+foo ?? true ?? list
+foo ?? type(false)
+foo ?? uniq($env)
+foo ?? {foo: 0, foo: foo}
+foo ?? {foo: array}
+foo ?? {foo: f64}
+foo ?? {foo: foo}
+foo ?? {foo: ok}
+foo in $env and false
 foo in $env.list
 foo in $env?.Bar
 foo in $env?.Bar?.[add]?.[str]
 foo in $env?.String
+foo in $env?.String?.[greet]
+foo in $env?.String?.[i]
 foo in $env?.String?.[ok]
+foo in $env?.String?.add
+foo in $env?.String?.ok()
 foo in $env?.[Bar]
 foo in $env?.[Bar]?.[i]
 foo in $env?.[String]
 foo in $env?.[String]?.[array]
 foo in $env?.[String]?.[foo]
+foo in $env?.[String]?.i
 foo in $env?.[foobar?.foo]
 foo in $env?.[foobar]
+foo in $env?.[foobar]?.i
 foo in $env?.[foobar]?.list
 foo in $env?.foobar
 foo in $env?.foobar?.list()
 foo in $env?.list
 foo in $env?.true?.[greet]
+foo in [foo, 0]
+foo in [foo]
+foo in [list, 1]
 foo in [nil]
+foo in array ?? 0
+foo in array ?? 1.0 != nil
+foo in array ?? f64
 foo in flatten(array)
 foo in keys($env)
 foo in list
 foo in list != nil && $env
 foo in list != ok
 foo in list == $env?.ok
+foo in list ?? add
+foo in list ?? greet
+foo in list or $env
 foo in list || false
 foo in list[0:]
 foo in map(list, foo)
+foo in nil ?? list
 foo in toPairs($env)
 foo in uniq(list)
+foo in values($env)
+foo in {foo: 1.0}.f64
 foo not in $env.list
 foo not in $env?.Bar
 foo not in $env?.String
+foo not in $env?.String?.[greet]
 foo not in $env?.[Bar]
 foo not in $env?.[Bar]?.String
 foo not in $env?.[String]
 foo not in $env?.[String]?.[list]
+foo not in $env?.[String]?.greet
+foo not in $env?.[foobar?.[add]]
 foo not in $env?.[foobar?.f64]
+foo not in $env?.[foobar?.foo]
 foo not in $env?.[foobar]
+foo not in $env?.[foobar]?.[greet]
 foo not in $env?.[nil | last(foobar)]
 foo not in $env?.[nil]
 foo not in $env?.foobar
@@ -8980,37 +18605,76 @@ foo not in $env?.foobar?.greet(foobar)
 foo not in $env?.list
 foo not in $env?.nil?.[ok]
 foo not in [$env]
+foo not in [foo]
+foo not in [nil]
+foo not in array ?? foo
+foo not in find($env, false)?.[i]
+foo not in first($env)
 foo not in flatten(array)
+foo not in groupBy(list, #)
 foo not in keys($env)
 foo not in list
 foo not in list != false
 foo not in list && ok
+foo not in list ?? 1
+foo not in list ?? foo
+foo not in list || ok
+foo not in toPairs($env)
+foo not in {foo: 1}?.array
+foo not in {foo: str}.str
 foo.Bar
+foo.Bar != $env == nil
 foo.Bar != foo?.Bar
 foo.Bar != str
 foo.Bar + str
 foo.Bar < foo.Bar
+foo.Bar < str
 foo.Bar <= str
+foo.Bar == $env ?? 0
+foo.Bar == $env.str
 foo.Bar == $env?.Bar
 foo.Bar == foo?.Bar
 foo.Bar == str
 foo.Bar > foo.String()
 foo.Bar > str
 foo.Bar >= str
+foo.Bar >= string(foo)
 foo.Bar >= type(ok)
+foo.Bar ?? $env ?? true
+foo.Bar ?? $env?.Bar
+foo.Bar ?? $env?.f64
+foo.Bar ?? add
+foo.Bar ?? array
+foo.Bar ?? foo
+foo.Bar ?? greet
+foo.Bar ?? i
+foo.Bar ?? list
+foo.Bar ?? round(f64)
+foo.Bar ?? str
+foo.Bar ?? {foo: foo}
 foo.Bar contains $env?.String
+foo.Bar contains $env?.[str]
 foo.Bar contains str
+foo.Bar endsWith $env?.Bar
 foo.Bar endsWith str
 foo.Bar in $env
+foo.Bar in $env?.String
 foo.Bar in foo
+foo.Bar matches foo.Bar
+foo.Bar matches greet(str)
 foo.Bar matches str
+foo.Bar not contains $env?.Bar
 foo.Bar not contains str
+foo.Bar not contains type(0)
 foo.Bar not endsWith str
+foo.Bar not endsWith type(list)
 foo.Bar not in foo
+foo.Bar not in foo == $env
 foo.Bar not in {foo: nil, foo: 1}
 foo.Bar not matches str
 foo.Bar not matches toJSON(i)
 foo.Bar not startsWith foo?.Bar
+foo.Bar not startsWith foo?.String()
 foo.Bar not startsWith str
 foo.Bar startsWith $env?.String?.f64()
 foo.Bar startsWith $env?.[Bar]
@@ -9018,67 +18682,141 @@ foo.Bar startsWith str
 foo.Bar | greet()
 foo.Bar | hasPrefix(str)
 foo.Bar | indexOf(str)
+foo.Bar | lastIndexOf(str)
 foo.Bar | repeat(0)
 foo.Bar | split($env?.str)
 foo.Bar | trimSuffix(str)
 foo.Bar[:]
 foo.Bar[:i]
+foo.Bar[:int(1)]
 foo.Bar[i:]
 foo.String
 foo.String != $env?.foobar
+foo.String != ok ?? $env
 foo.String == $env?.[String]
+foo.String ?? $env?.[Bar]
+foo.String ?? $env?.array
+foo.String ?? $env?.list
+foo.String ?? add
+foo.String ?? array
+foo.String ?? ceil(f64)
+foo.String ?? first(list)
+foo.String ?? foo
+foo.String ?? greet
+foo.String ?? i
+foo.String ?? len(array)
+foo.String ?? ok
+foo.String ?? str
 foo.String()
+foo.String() != max(array)
 foo.String() != str
+foo.String() + str
+foo.String() < $env.str
+foo.String() < str
 foo.String() <= $env.str
 foo.String() <= str
+foo.String() <= type(0 != 1.0)
+foo.String() == str
 foo.String() > foo.Bar
+foo.String() > str
 foo.String() >= $env?.[str]
 foo.String() >= str
+foo.String() ?? $env.i
+foo.String() ?? add
+foo.String() ?? array
+foo.String() ?? f64
+foo.String() ?? foo
+foo.String() ?? greet
+foo.String() ?? i
 foo.String() contains str
 foo.String() endsWith str
+foo.String() in $env?.[Bar]
+foo.String() in foo
+foo.String() matches str
+foo.String() not contains str
 foo.String() not in foo
 foo.String() not in foo == false
+foo.String() not startsWith str
+foo.String() startsWith str
 foo.String() | greet()
+foo.String() | lastIndexOf(str)
+foo.String() | trimPrefix(str)
+foo.String()[0 ?? 1.0:]
 foo.String()[:]
 foo.String()[i:]
 foo; $env?.foo
 foo; $env?.ok
 foo; $env?.str
+foo; 1.0; $env?.add
 foo; 1.0; $env?.ok
+foo; array
 foo; f64
 foo; foo; nil != ok
 foo; foo?.Bar
+foo; greet
 foo; i
 foo; list
 foo; str
 foo?.Bar
+foo?.Bar != list ?? 0
 foo?.Bar != nil == $env
 foo?.Bar != str
 foo?.Bar != type(f64)
+foo?.Bar + foo.Bar
 foo?.Bar + str
+foo?.Bar + string(foo)
+foo?.Bar + toJSON(1)
 foo?.Bar + type(i)
+foo?.Bar < $env?.str
 foo?.Bar < str
 foo?.Bar < string(0)
 foo?.Bar <= str
 foo?.Bar == $env.str
+foo?.Bar == foo?.Bar
 foo?.Bar == nil and false
 foo?.Bar == str
 foo?.Bar > str
+foo?.Bar > trimPrefix(str)
 foo?.Bar > type(false)
+foo?.Bar > type(list)
 foo?.Bar >= $env.str
 foo?.Bar >= str
 foo?.Bar >= toJSON(foo)
+foo?.Bar ?? !true
+foo?.Bar ?? $env?.[add].greet
+foo?.Bar ?? $env?.[str]
+foo?.Bar ?? $env[foobar:]
+foo?.Bar ?? add
+foo?.Bar ?? array
+foo?.Bar ?? f64
+foo?.Bar ?? flatten(array)
+foo?.Bar ?? foo
+foo?.Bar ?? greet
+foo?.Bar ?? i
+foo?.Bar ?? list
+foo?.Bar ?? map($env, 0)
+foo?.Bar ?? ok
+foo?.Bar ?? str
+foo?.Bar ?? toJSON(f64)
 foo?.Bar contains $env?.Bar
 foo?.Bar contains $env?.[Bar]
+foo?.Bar contains str
+foo?.Bar contains str ?? list
 foo?.Bar endsWith $env?.String
 foo?.Bar endsWith first($env)
 foo?.Bar endsWith str
+foo?.Bar in $env?.[Bar]
 foo?.Bar in foo
+foo?.Bar in list?.[i]
+foo?.Bar in uniq(list)
 foo?.Bar in {foo: array}
 foo?.Bar in {foo: str}
+foo?.Bar matches $env.str
 foo?.Bar matches str
+foo?.Bar matches str and true
 foo?.Bar matches toJSON(array)
 foo?.Bar not contains str
+foo?.Bar not contains type(nil)
 foo?.Bar not endsWith $env?.[String]
 foo?.Bar not endsWith $env?.foobar
 foo?.Bar not endsWith str
@@ -9091,26 +18829,62 @@ foo?.Bar not matches str
 foo?.Bar not startsWith $env.str
 foo?.Bar not startsWith $env?.Bar
 foo?.Bar not startsWith str
+foo?.Bar not startsWith toJSON(0)
 foo?.Bar not startsWith toJSON(nil)
 foo?.Bar not startsWith type(str)
+foo?.Bar startsWith $env?.[Bar]
 foo?.Bar startsWith str
 foo?.Bar | greet()
 foo?.Bar | hasSuffix(str)
+foo?.Bar | lastIndexOf(str)
+foo?.Bar | repeat(i)
+foo?.Bar | splitAfter(str)
 foo?.Bar[:]
+foo?.Bar[i:]
 foo?.String
+foo?.String != $env && $env
 foo?.String != $env?.[Bar]
 foo?.String != $env?.[str]
+foo?.String != nil && $env
 foo?.String == $env or $env
 foo?.String == $env?.[String]
+foo?.String == nil || true
+foo?.String ?? $env?.list
+foo?.String ?? -$env
+foo?.String ?? add
+foo?.String ?? array
+foo?.String ?? f64
+foo?.String ?? findLast($env, #)
+foo?.String ?? foo
+foo?.String ?? greet
+foo?.String ?? groupBy($env, 0)
+foo?.String ?? i
+foo?.String ?? list
+foo?.String ?? ok
+foo?.String ?? str
+foo?.String ?? str ?? foo
+foo?.String ?? string(foo)
 foo?.String()
 foo?.String() != str
+foo?.String() + foo.String()
 foo?.String() < str
 foo?.String() == str
+foo?.String() > foo?.Bar
 foo?.String() > str
+foo?.String() >= str
 foo?.String() >= toJSON(f64)
+foo?.String() ?? foo
+foo?.String() ?? greet
+foo?.String() ?? keys($env)
+foo?.String() ?? list
+foo?.String() ?? reverse($env)
+foo?.String() ?? str
+foo?.String() contains str
+foo?.String() endsWith str
 foo?.String() in foo
 foo?.String() matches str
 foo?.String() not contains $env?.[str]
+foo?.String() not contains str
 foo?.String() not endsWith $env?.Bar
 foo?.String() not endsWith $env?.[foobar]
 foo?.String() not in foo
@@ -9120,13 +18894,16 @@ foo?.String() | greet()
 foo?.String() | hasSuffix(str)
 foo?.String()[:]
 fromBase64(string(ok))
+fromBase64(string(true))
 fromBase64(toBase64(str))
 fromBase64(toJSON(nil))
 fromBase64(toJSON(ok))
 fromBase64(toJSON(true))
 fromBase64(type(add))
+fromBase64(type(false))
 fromBase64(type(greet))
 fromBase64(type(ok))
+fromBase64(type(true))
 fromJSON(string(0))
 fromJSON(string(1))
 fromJSON(string(1.0))
@@ -9143,6 +18920,7 @@ fromJSON(toJSON(f64))
 fromJSON(toJSON(false))
 fromJSON(toJSON(foo))
 fromJSON(toJSON(foo)).add
+fromJSON(toJSON(i))
 fromJSON(toJSON(list))
 fromJSON(toJSON(nil))
 fromJSON(toJSON(nil))?.[i].i()
@@ -9151,144 +18929,475 @@ fromJSON(toJSON(str))
 fromJSON(toJSON(str)) contains str
 fromJSON(toJSON(true))
 fromJSON(toJSON(type(ok)))
+fromPairs($env).true && false
 fromPairs([list])
+fromPairs(array | take(0))
+fromPairs(array[:0])
+fromPairs(filter($env, false))
+fromPairs(filter(list, false))
 fromPairs(list[:0])
+fromPairs(map($env, list))
 fromPairs(sort($env))
+fromPairs(take(array, 0))
 fromPairs(toPairs($env))
 fromPairs(toPairs($env)).ok
+fromPairs(toPairs($env))?.[f64]
 get($env, nil) != array
+get($env, nil) == add
+get($env, nil)?.String
 get($env, nil)?.[add]
 get($env, nil)?.[add].add
+get($env, nil)?.[array]
 get($env, nil)?.[f64]
+get($env, nil)?.[foo]
 get($env, nil)?.[i]
 get($env, nil)?.[ok]
+get($env, nil)?.[str]
 get($env, nil)?.add
+get($env, nil)?.array()
 get($env, nil)?.f64
 get($env, nil)?.foo
+get($env, nil)?.foo(foobar)
 get($env, nil)?.greet().add
+get($env, nil)?.list()
+get($env, nil)?.ok
+get($env, nil)?.ok(foobar)
+get($env, nil)?.str()
 get($env, str) | reduce($env)
 get($env, str)?.[f64]
+get($env?.[Bar], foo)
+get($env?.[String], foo.String)
+get(0 ?? list, add)
+get(1.0 ?? $env, false ?? list)
+get(add ?? f64, add)
+get(add ?? str, i)
 get(array, $env.i)
 get(array, i)
+get(array, i) < i
+get(false ? false : add, foo)
+get(i ?? $env, foo ?? $env)
 get(if ok { i } else { array }, list)
+get(list ?? add, i)
+get(list, -0)
+get(list, 1)?.String
 get(list, i)
 get(list, i).String
+get(mean(array), foo.String)
 get(median(array), true && $env)
+get(str ?? $env, i)
 greet
 greet != $env != nil
 greet != $env && $env
 greet != $env == nil
+greet != $env ?: add
+greet != $env ?? array
+greet != $env ?? list
 greet != $env and $env
 greet != $env or sum(array, true)
+greet != $env || ok
+greet != $env || true
 greet != $env.greet
 greet != $env?.Bar
 greet != $env?.String
 greet != $env?.String?.add()
 greet != $env?.[Bar]
 greet != $env?.[String]
+greet != $env?.[String]?.[greet]
+greet != $env?.[foobar?.String($env)]
 greet != $env?.[foobar]
 greet != $env?.[str]
+greet != $env?.foobar
 greet != $env?.greet
 greet != $env?.true
+greet != 0 ?? 1.0
+greet != 0 ?? greet
+greet != 1 ?? str
+greet != 1.0 ?? add
+greet != array ?? !true
+greet != array ?? ok
+greet != first($env)
+greet != foo ?? array
+greet != foo ?? f64
+greet != foo ?? list
 greet != get($env, str)
 greet != greet
 greet != greet != nil
 greet != greet != ok
 greet != greet && true
+greet != greet ?: greet
+greet != greet or ok
+greet != greet || $env
 greet != greet || false
+greet != max($env)
+greet != nil == nil
+greet != nil ? foo : true
+greet != nil ?? $env
 greet != nil and $env
+greet != nil || $env?.[i]
+greet != ok ?? i
+greet != ok ?? str
+greet != reduce(array, $env, 0)
+greet != str ?? $env
+greet != {foo: nil}.Bar?.list
 greet != {foo: str}.foobar
+greet != {foo: true}?.list
+greet == $env && $env
+greet == $env ?? foo
+greet == $env ?? true
 greet == $env and false
+greet == $env or ok
 greet == $env.greet
 greet == $env?.Bar
+greet == $env?.Bar?.array()
 greet == $env?.String
 greet == $env?.[Bar]
+greet == $env?.[Bar]?.[foo]
 greet == $env?.[String]
+greet == $env?.[String]?.ok
 greet == $env?.[foobar]
 greet == $env?.[str]
 greet == $env?.foobar
 greet == $env?.foobar?.String
 greet == $env?.greet
+greet == 0 ?? f64
+greet == 1.0 ?? array
+greet == 1.0 ?? i
+greet == add ?? f64
+greet == array ?? add
+greet == foo ?? 1.0
+greet == foo ?? true
 greet == greet
+greet == greet && $env
 greet == greet == ok
 greet == greet ? 1.0 : foo
+greet == greet and $env
 greet == min($env)
+greet == nil != nil
+greet == nil != ok
 greet == nil == true
 greet == nil or $env
+greet == nil or ok
 greet == nil || true
+greet == ok ?? 1.0
+greet == str ?? greet
+greet == str ?? true
+greet ?? !$env
+greet ?? !false
+greet ?? !ok
+greet ?? !true
+greet ?? $env ?? f64
+greet ?? $env ?? foo
+greet ?? $env ?? str
+greet ?? $env.add
+greet ?? $env.array
+greet ?? $env.f64
+greet ?? $env.foo
+greet ?? $env.greet
+greet ?? $env.i
+greet ?? $env.list
+greet ?? $env.ok
+greet ?? $env.str
+greet ?? $env?.Bar
+greet ?? $env?.Bar()
+greet ?? $env?.Bar()?.i
+greet ?? $env?.Bar(foobar)
+greet ?? $env?.Bar.array
+greet ?? $env?.Bar?.foo
+greet ?? $env?.String
+greet ?? $env?.String()
+greet ?? $env?.String?.[array]
+greet ?? $env?.String?.[i]
+greet ?? $env?.String?.greet
+greet ?? $env?.[Bar]
+greet ?? $env?.[String not in foobar]
+greet ?? $env?.[String]
+greet ?? $env?.[add]
+greet ?? $env?.[add]?.[add]
+greet ?? $env?.[array]
+greet ?? $env?.[f64]
+greet ?? $env?.[foo.f64()].filter(get(foobar))
+greet ?? $env?.[foo.f64]
+greet ?? $env?.[foo]
+greet ?? $env?.[foobar.f64]
+greet ?? $env?.[foobar]
+greet ?? $env?.[greet]
+greet ?? $env?.[i]
+greet ?? $env?.[list]
+greet ?? $env?.[ok()]
+greet ?? $env?.[ok]
+greet ?? $env?.[str]
+greet ?? $env?.[str]?.[add]
+greet ?? $env?.add
+greet ?? $env?.array
+greet ?? $env?.f64
+greet ?? $env?.foo
+greet ?? $env?.foobar
+greet ?? $env?.greet
+greet ?? $env?.i
+greet ?? $env?.list
+greet ?? $env?.nil?.String
+greet ?? $env?.ok
+greet ?? $env?.str
+greet ?? $env[$env:]
+greet ?? $env[:bitor(f64)]
+greet ?? $env[:foobar?.[add]]
+greet ?? $env[:foobar]
+greet ?? $env[:foobar].i()
+greet ?? $env[Bar(list):count(foobar)]
+greet ?? $env[array():]
+greet ?? $env[foo ^ foo:]
+greet ?? $env[foobar < foo:]
+greet ?? $env[foobar?.list:String]
+greet ?? $env[list(0):foo[:$env]]
+greet ?? -$env
+greet ?? -0
+greet ?? -i
+greet ?? 0 ?? 1
+greet ?? 0 ?? str
+greet ?? [1]
+greet ?? [false]
+greet ?? [list]
+greet ?? [true]
+greet ?? abs($env)
+greet ?? abs(i)
+greet ?? add
+greet ?? array
+greet ?? array ?? add
+greet ?? array ?? true
+greet ?? array?.[i]
+greet ?? count($env)
+greet ?? date($env)
+greet ?? date(false)
+greet ?? date(foo)
+greet ?? f64
+greet ?? f64 ?? foo
+greet ?? findLast($env, #.foo)
+greet ?? findLastIndex(list, ok)
+greet ?? flatten($env)
+greet ?? float(i)
+greet ?? foo
+greet ?? foo ?? $env
+greet ?? foo ?? array
+greet ?? foo ?? greet
+greet ?? foo ?? i
+greet ?? foo | get(array)
+greet ?? foo | get(foo)
+greet ?? foo.Bar
+greet ?? foo.String
+greet ?? foo.String()
+greet ?? foo?.Bar
+greet ?? foo?.String
+greet ?? foo?.String()
+greet ?? fromJSON($env)
+greet ?? fromPairs(list)
+greet ?? greet
+greet ?? greet ?? array
+greet ?? groupBy($env, add)
+greet ?? groupBy(list, $env)
+greet ?? groupBy(list, list)
+greet ?? i
+greet ?? i ?? foo
+greet ?? i ?? list
+greet ?? int(1.0)
+greet ?? int(f64)
+greet ?? keys($env)
+greet ?? list
+greet ?? list ?? 0
+greet ?? list ?? array
+greet ?? list ?? str
+greet ?? list?.[i]
+greet ?? lower($env)
+greet ?? map($env, #.ok)
+greet ?? map(list, #index * 1.0)
+greet ?? map(list, #index)
+greet ?? max(1.0, $env)
+greet ?? mean(1.0)
+greet ?? median(0)
+greet ?? min($env)
+greet ?? min(1.0)
+greet ?? min(i)
+greet ?? nil ?? 1.0
+greet ?? nil ?? add
+greet ?? not false
+greet ?? not true
+greet ?? ok
+greet ?? one($env, .str)
+greet ?? reduce($env, true)
+greet ?? round(i)
+greet ?? sortBy(list, #)
+greet ?? str
+greet ?? str[:$env]
+greet ?? string($env)
+greet ?? string(array)
+greet ?? string(nil)
+greet ?? sum($env)
+greet ?? sum($env, #.ok)
+greet ?? sum(array)
+greet ?? sum(list)
+greet ?? sum(list, $env)
+greet ?? toJSON(add)
+greet ?? toJSON(foo)
+greet ?? toJSON(list)
+greet ?? toPairs($env)
+greet ?? trimSuffix($env)
+greet ?? type(1.0)
+greet ?? type(add)
+greet ?? type(str)
+greet ?? type(true)
+greet ?? {foo: foo}.i()
 greet in $env?.Bar
 greet in $env?.String
 greet in $env?.[Bar]
 greet in $env?.[Bar] && ok
 greet in $env?.[String]
+greet in $env?.[foobar?.[f64]]
 greet in $env?.[foobar?.[i]]
+greet in $env?.[foobar]
+greet in $env?.foobar
 greet in $env?.foobar?.[foo]
 greet in $env?.nil
 greet in $env?.true
+greet in [$env, foo]
 greet in [nil]
+greet in array ?? foo
+greet in first($env)
+greet in flatten(list)
+greet in list ?? $env?.[array]
+greet in list ?? $env?.[i]
+greet in map($env, $env)
+greet in reverse(list)
 greet in sort($env)
 greet in toPairs($env)
+greet in uniq(list)
+greet not in $env and false
 greet not in $env?.Bar
 greet not in $env?.String
 greet not in $env?.String?.str
 greet not in $env?.[Bar]
+greet not in $env?.[Bar]?.list()
 greet not in $env?.[String]
+greet not in $env?.[foobar?.[add]]
 greet not in $env?.[foobar]
+greet not in $env?.foobar
+greet not in [foo, 1.0]
+greet not in array ?? add
+greet not in array ?? i
+greet not in first($env)
+greet not in flatten(array)
+greet not in flatten(list)
 greet not in last($env)
+greet not in list ?? str
 greet not in toPairs($env)
 greet not in {foo: foo}.list and ok
+greet($env) != $env or true
+greet($env.foo?.Bar)
 greet($env.greet(str))
 greet($env.str)
+greet($env?.[foobar] ?? str)
 greet($env?.[str])
+greet($env?.foo?.Bar)
 greet($env?.greet(str))
 greet($env?.str)
+greet(false ? foo : str)
 greet(foo.Bar)
 greet(foo.String())
 greet(foo?.Bar)
 greet(foo?.Bar) not endsWith str
+greet(foo?.Bar) | repeat(nil ?? i)
 greet(foo?.String())
+greet(get($env, str))
 greet(greet($env?.[str]))
 greet(greet(foo.String()))
+greet(greet(greet(str)))
+greet(greet(str ?? foo?.Bar))
 greet(greet(str))
 greet(greet(str[:i]))
+greet(greet(string($env)))
+greet(greet(string(0)))
 greet(greet(type($env)))
+greet(greet(type(add)))
 greet(greet(type(true)))
 greet(if false { 1.0 } else { str })
 greet(if ok { str } else { nil })
+greet(if true { str } else { $env })
 greet(join($env | map(str)))
 greet(keys($env)?.[i])
 greet(last(list).Bar)
+greet(let x = str; x)
 greet(list | reduce(#.Bar))
 greet(list | reduce(str))
 greet(list | reduce(str, str))
 greet(list?.[i].Bar)
+greet(list?.[i].String())
 greet(lower(greet(str)))
 greet(lower(str))
+greet(min($env)?.str)
+greet(nil ?? str)
 greet(ok ? str : 1)
 greet(reduce(array, str))
 greet(reduce(list, str))
 greet(str + str)
+greet(str ?? $env)
+greet(str ?? 0)
+greet(str ?? 1)
+greet(str ?? 1.0)
+greet(str ?? add)
+greet(str ?? array)
+greet(str ?? f64)
+greet(str ?? false)
+greet(str ?? foo)
+greet(str ?? greet)
+greet(str ?? i)
+greet(str ?? list)
+greet(str ?? nil)
+greet(str ?? ok)
+greet(str ?? str)
+greet(str ?? true)
 greet(str | greet())
 greet(str | repeat(0))
 greet(str | trim(str))
+greet(str | trimPrefix(str))
 greet(str)
 greet(str) != $env && $env
+greet(str) != list ?? 0
 greet(str) != str
+greet(str) + str
+greet(str) < lower(str)
 greet(str) < str
+greet(str) <= $env?.str
 greet(str) <= str
+greet(str) <= type(i)
 greet(str) == nil ? foo : nil
+greet(str) == str
+greet(str) > str
 greet(str) > type(0)
+greet(str) >= $env.str
+greet(str) >= foo?.String()
 greet(str) >= str
+greet(str) ?? [array]
+greet(str) ?? f64
+greet(str) ?? list
+greet(str) ?? str
 greet(str) contains str
 greet(str) contains string(true)
 greet(str) endsWith $env?.[str]
 greet(str) endsWith str
+greet(str) in $env == $env
+greet(str) in foo
 greet(str) matches str
 greet(str) not contains str
+greet(str) not endsWith $env?.str
 greet(str) not endsWith string(foo)
 greet(str) not endsWith type(nil)
 greet(str) not in foo
+greet(str) not matches str
 greet(str) not startsWith $env?.Bar
+greet(str) not startsWith $env?.String
+greet(str) not startsWith foo.Bar
+greet(str) not startsWith str
+greet(str) startsWith foo.Bar
+greet(str) startsWith str
+greet(str) startsWith toJSON(1)
 greet(str) | greet()
 greet(str)[:]
 greet(str)[:i]
@@ -9296,16 +19405,21 @@ greet(str)[i:]
 greet(str[0:])
 greet(str[1:0])
 greet(str[1:])
+greet(str[:0])
 greet(str[:1])
 greet(str[:])
 greet(str[:i])
+greet(str[i:1])
 greet(str[i:])
 greet(str[i:i])
 greet(string($env))
 greet(string($env?.Bar))
+greet(string($env?.i))
 greet(string(0))
 greet(string(1))
+greet(string(1.0 * f64))
 greet(string(1.0))
+greet(string(abs(0)))
 greet(string(add))
 greet(string(array | sortBy(str)))
 greet(string(array))
@@ -9317,11 +19431,14 @@ greet(string(groupBy(list, ok)))
 greet(string(i))
 greet(string(last(array)))
 greet(string(list))
+greet(string(nil != add))
 greet(string(nil))
 greet(string(ok))
 greet(string(str))
 greet(string(true))
 greet(toBase64(str))
+greet(toJSON($env.array))
+greet(toJSON($env.foo))
 greet(toJSON(0))
 greet(toJSON(1))
 greet(toJSON(1.0 + 1.0))
@@ -9333,92 +19450,171 @@ greet(toJSON(false))
 greet(toJSON(foo) | greet())
 greet(toJSON(foo))
 greet(toJSON(foo?.Bar))
+greet(toJSON(i % i))
 greet(toJSON(i))
 greet(toJSON(list))
+greet(toJSON(max(0)))
 greet(toJSON(nil))
 greet(toJSON(ok))
 greet(toJSON(str))
 greet(toJSON(true))
 greet(trim(str))
+greet(trim(trimSuffix(str)))
+greet(trimPrefix(str ?? nil))
 greet(trimPrefix(str))
 greet(trimSuffix(foo.String()))
 greet(trimSuffix(str))
+greet(trimSuffix(str, str))
+greet(true ? str : add)
 greet(true ? str : i)
 greet(true ? str : nil)
+greet(true ? str : ok)
+greet(type($env != 1.0))
 greet(type($env))
 greet(type($env.ok))
+greet(type($env?.foo))
 greet(type(0))
 greet(type(1))
 greet(type(1.0))
+greet(type([list]))
+greet(type([ok]))
 greet(type(add))
 greet(type(array))
 greet(type(f64))
 greet(type(false))
 greet(type(foo))
+greet(type(foo.String))
 greet(type(greet))
+greet(type(i * f64))
 greet(type(i))
 greet(type(list))
 greet(type(map(array, ok)))
 greet(type(nil == f64))
 greet(type(nil))
+greet(type(not ok))
 greet(type(ok))
 greet(type(str))
 greet(type(true))
 greet(upper(str))
 greet; $env?.[Bar]
+greet; $env?.add
+greet; $env?.foobar
 greet; add
 greet; array
+greet; array | sum(0)
 greet; f64
+greet; float(f64)
 greet; foo
 greet; foo; i
 greet; greet
 greet; i
 greet; ok
+greet; ok ?? i
+greet; {foo: nil}
+groupBy($env | map(false), i)?.ok
 groupBy($env | map(i), ok)
+groupBy($env.array, # >= #)
 groupBy($env.array, #)
+groupBy($env.array, -#)?.f64
 groupBy($env.array, 0 * 1.0)
+groupBy($env.array, f64)
 groupBy($env.array, foo)
 groupBy($env.array, i / #)
 groupBy($env.list, #)
+groupBy($env.list, f64)
 groupBy($env.list, foo)
+groupBy($env.list, i)
 groupBy($env.list, nil != #.String)
+groupBy($env.list, not ok)
+groupBy($env.list, str)
 groupBy($env?.[str], #)
 groupBy($env?.[str], 1.0 <= i)
+groupBy($env?.[str], 1.0 > 1.0)
+groupBy($env?.[str], any($env, true))
 groupBy($env?.[str], f64)
 groupBy($env?.[str], i)
 groupBy($env?.[str], mean(#))
 groupBy($env?.[str], ok)
 groupBy($env?.[str], ok)?.add
+groupBy($env?.[str], str)
 groupBy($env?.array, #)
+groupBy($env?.array, #)?.[i]
 groupBy($env?.array, $env?.i)
+groupBy($env?.array, -#)
+groupBy($env?.array, 0 <= #)
 groupBy($env?.array, f64)
+groupBy($env?.array, foo)?.ok
 groupBy($env?.array, i)
+groupBy($env?.array, ok)
 groupBy($env?.array, str)
+groupBy($env?.list, #)
+groupBy($env?.list, #.Bar)
 groupBy($env?.list, $env?.i)
 groupBy($env?.list, 0 == $env)
+groupBy($env?.list, int(1.0))
+groupBy($env?.list, ok)
+groupBy($env?.list, str)
+groupBy(1 .. 0, #)
 groupBy(1 .. 1, ok)
+groupBy([$env], .String startsWith .str)
+groupBy([$env], i)
+groupBy([0, 0], #)
+groupBy([0], #)
 groupBy([1.0], # / f64)
+groupBy([1.0], #)
 groupBy([1.0], foo)
+groupBy([1.0], ok)
 groupBy([1], #)
+groupBy([1], i)
+groupBy([f64], ok)
+groupBy([f64], str)
 groupBy([false, str], ok)
 groupBy([false], #)
+groupBy([foo], .Bar not matches #.Bar)
 groupBy([foo], 0 >= i)
+groupBy([foo], foo)?.[ok]
 groupBy([foo], i)
+groupBy([greet], i)
 groupBy([i], foo)
 groupBy([list], abs(1.0))
+groupBy([ok], #)
 groupBy([str], str)
+groupBy(array ?? $env, foo)
+groupBy(array ?? add, 1.0 ?? foo)
+groupBy(array ?? array, foo)
+groupBy(array ?? foo, str == #)
+groupBy(array ?? greet, #)
+groupBy(array ?? greet, ok)
 groupBy(array | filter(false), greet)
+groupBy(array | map(#), ok)
 groupBy(array | map($env), #.ok)
+groupBy(array | map(0), str)
+groupBy(array | map(1), #)
+groupBy(array | sortBy(#), 1 + #)
+groupBy(array | sortBy(1.0), #)
+groupBy(array, !false)
 groupBy(array, # != 1.0)
 groupBy(array, # % #)
+groupBy(array, # % #)?.[str]
 groupBy(array, # * i)
+groupBy(array, # ** 0)
 groupBy(array, # + #)
+groupBy(array, # - 1.0)
 groupBy(array, # / #)
+groupBy(array, # < 1)
+groupBy(array, # <= f64)
 groupBy(array, # == #)
 groupBy(array, # > #)
 groupBy(array, # >= #).String
 groupBy(array, # >= 0)
+groupBy(array, # >= f64)
+groupBy(array, # ?? 1.0)
+groupBy(array, # ?? array)
+groupBy(array, # ?? nil)
+groupBy(array, # ?? str)
 groupBy(array, # ^ #)
+groupBy(array, # ^ 1.0)
+groupBy(array, # | bitor(#))
 groupBy(array, #)
 groupBy(array, #).Bar
 groupBy(array, #).String
@@ -9426,8 +19622,11 @@ groupBy(array, #).add
 groupBy(array, #).array
 groupBy(array, #).f64
 groupBy(array, #).foo
+groupBy(array, #).foobar
+groupBy(array, #).foobar | any(true)
 groupBy(array, #).greet
 groupBy(array, #).i
+groupBy(array, #).i | any(#.ok.array)
 groupBy(array, #).list
 groupBy(array, #).ok
 groupBy(array, #).str
@@ -9448,24 +19647,40 @@ groupBy(array, #)?.i
 groupBy(array, #)?.list
 groupBy(array, #)?.ok
 groupBy(array, #)?.str
+groupBy(array, $env != i)?.[ok]
+groupBy(array, $env == array).str
 groupBy(array, $env == foo)
 groupBy(array, $env | sum(1.0))
 groupBy(array, $env.f64)
 groupBy(array, $env.foo)
+groupBy(array, $env.i)
 groupBy(array, $env.ok)
 groupBy(array, $env.str)
+groupBy(array, $env?.[String])
 groupBy(array, $env?.[foobar])
 groupBy(array, $env?.[str])
 groupBy(array, $env?.f64)
 groupBy(array, $env?.i)
+groupBy(array, $env?.nil)
+groupBy(array, $env?.ok)
 groupBy(array, $env?.str)
+groupBy(array, -#)
+groupBy(array, -#)?.str
+groupBy(array, -0)
+groupBy(array, -1.0)
+groupBy(array, -i)
 groupBy(array, 0 + #)
 groupBy(array, 0 == 1.0)
+groupBy(array, 0) ?? foo
 groupBy(array, 0).Bar
 groupBy(array, 0).String
 groupBy(array, 0).add
 groupBy(array, 0).array
 groupBy(array, 0).foo
+groupBy(array, 0).foobar
+groupBy(array, 0).greet
+groupBy(array, 0).i
+groupBy(array, 0).list
 groupBy(array, 0).str
 groupBy(array, 0)?.Bar
 groupBy(array, 0)?.String
@@ -9475,11 +19690,15 @@ groupBy(array, 0)?.[i]
 groupBy(array, 0)?.[str]
 groupBy(array, 0)?.add
 groupBy(array, 0)?.array
+groupBy(array, 0)?.f64
 groupBy(array, 0)?.foo
 groupBy(array, 0)?.foobar
 groupBy(array, 0)?.greet
 groupBy(array, 0)?.i
 groupBy(array, 0)?.list
+groupBy(array, 0)?.str
+groupBy(array, 1 >= #)
+groupBy(array, 1).Bar
 groupBy(array, 1).String
 groupBy(array, 1).add
 groupBy(array, 1).array
@@ -9489,16 +19708,29 @@ groupBy(array, 1).greet
 groupBy(array, 1).i
 groupBy(array, 1).list
 groupBy(array, 1)?.Bar
+groupBy(array, 1)?.String
+groupBy(array, 1)?.[foo]
 groupBy(array, 1)?.[i]
 groupBy(array, 1)?.[ok]
 groupBy(array, 1)?.[str]
 groupBy(array, 1)?.add
+groupBy(array, 1)?.array
 groupBy(array, 1)?.f64
+groupBy(array, 1)?.foo
+groupBy(array, 1)?.greet
+groupBy(array, 1)?.i
 groupBy(array, 1)?.list
 groupBy(array, 1)?.ok
+groupBy(array, 1)?.str
 groupBy(array, 1.0 != $env)
+groupBy(array, 1.0 != 1.0)
+groupBy(array, 1.0 ** #)
 groupBy(array, 1.0 - 1.0)
+groupBy(array, 1.0 < #)
 groupBy(array, 1.0 < 0)?.ok
+groupBy(array, 1.0 <= 0)
+groupBy(array, 1.0 <= f64)
+groupBy(array, 1.0 ?? str)
 groupBy(array, 1.0 ^ #)
 groupBy(array, 1.0) == $env?.Bar
 groupBy(array, 1.0).Bar
@@ -9506,18 +19738,22 @@ groupBy(array, 1.0).add
 groupBy(array, 1.0).array
 groupBy(array, 1.0).f64
 groupBy(array, 1.0).foo
+groupBy(array, 1.0).foobar
 groupBy(array, 1.0).greet
 groupBy(array, 1.0).i
 groupBy(array, 1.0).list
 groupBy(array, 1.0).ok
+groupBy(array, 1.0).ok?.[i]
 groupBy(array, 1.0).str
 groupBy(array, 1.0)?.Bar
 groupBy(array, 1.0)?.String
 groupBy(array, 1.0)?.[f64]
 groupBy(array, 1.0)?.[foo]
+groupBy(array, 1.0)?.[i]
 groupBy(array, 1.0)?.[ok]
 groupBy(array, 1.0)?.[str]
 groupBy(array, 1.0)?.add
+groupBy(array, 1.0)?.array
 groupBy(array, 1.0)?.f64
 groupBy(array, 1.0)?.foo
 groupBy(array, 1.0)?.greet
@@ -9526,25 +19762,42 @@ groupBy(array, 1.0)?.list
 groupBy(array, 1.0)?.ok
 groupBy(array, 1.0)?.str
 groupBy(array, abs(#))
+groupBy(array, array | sum(#))
+groupBy(array, bitand(#, #))
 groupBy(array, bitshr(#, 0))
+groupBy(array, ceil(#))
+groupBy(array, ceil(floor(1.0)))
+groupBy(array, f64 ** i)
 groupBy(array, f64 - 1)
 groupBy(array, f64 / #)
 groupBy(array, f64 < #)
+groupBy(array, f64 >= #)
+groupBy(array, f64 ?? #)
 groupBy(array, f64)
 groupBy(array, f64).Bar
 groupBy(array, f64).String
 groupBy(array, f64).add
 groupBy(array, f64).array
 groupBy(array, f64).f64
+groupBy(array, f64).foo
+groupBy(array, f64).foobar
+groupBy(array, f64).greet
 groupBy(array, f64).i
+groupBy(array, f64).list
 groupBy(array, f64).ok
 groupBy(array, f64).str
 groupBy(array, f64)?.Bar
+groupBy(array, f64)?.String
+groupBy(array, f64)?.[f64]
+groupBy(array, f64)?.[foo]
 groupBy(array, f64)?.[i]
 groupBy(array, f64)?.[ok]
 groupBy(array, f64)?.[str]
 groupBy(array, f64)?.add
+groupBy(array, f64)?.array
 groupBy(array, f64)?.foo
+groupBy(array, f64)?.greet
+groupBy(array, f64)?.i
 groupBy(array, f64)?.list
 groupBy(array, f64)?.ok
 groupBy(array, f64)?.str
@@ -9556,40 +19809,59 @@ groupBy(array, false).add
 groupBy(array, false).f64
 groupBy(array, false).foo
 groupBy(array, false).greet
+groupBy(array, false).i
 groupBy(array, false).list
+groupBy(array, false).ok
 groupBy(array, false).str
 groupBy(array, false)?.Bar
 groupBy(array, false)?.String
 groupBy(array, false)?.[f64]
 groupBy(array, false)?.[foo]
 groupBy(array, false)?.[i]
+groupBy(array, false)?.[ok]
 groupBy(array, false)?.[str]
 groupBy(array, false)?.add
+groupBy(array, false)?.array
 groupBy(array, false)?.f64
 groupBy(array, false)?.foo
 groupBy(array, false)?.greet
+groupBy(array, false)?.i
+groupBy(array, false)?.list
 groupBy(array, false)?.ok
 groupBy(array, false)?.str
+groupBy(array, float(1.0))
+groupBy(array, float(i))
+groupBy(array, floor(#))
+groupBy(array, foo == $env)
+groupBy(array, foo ?? #)
+groupBy(array, foo in list)
 groupBy(array, foo not in list)
 groupBy(array, foo)
+groupBy(array, foo) ?? ok
 groupBy(array, foo).Bar
 groupBy(array, foo).String
 groupBy(array, foo).add
 groupBy(array, foo).array
+groupBy(array, foo).f64
 groupBy(array, foo).foo
+groupBy(array, foo).foobar
+groupBy(array, foo).foobar | groupBy(0)
 groupBy(array, foo).greet
 groupBy(array, foo).i
 groupBy(array, foo).list
 groupBy(array, foo).ok
 groupBy(array, foo).str
+groupBy(array, foo)?.Bar
 groupBy(array, foo)?.String
 groupBy(array, foo)?.[f64]
 groupBy(array, foo)?.[foo]
 groupBy(array, foo)?.[i]
 groupBy(array, foo)?.[ok]
+groupBy(array, foo)?.[str]
 groupBy(array, foo)?.add
 groupBy(array, foo)?.array
 groupBy(array, foo)?.f64
+groupBy(array, foo)?.foo
 groupBy(array, foo)?.greet
 groupBy(array, foo)?.i
 groupBy(array, foo)?.list
@@ -9598,8 +19870,14 @@ groupBy(array, foo)?.str
 groupBy(array, foo.Bar)
 groupBy(array, greet == $env)
 groupBy(array, greet(str))
+groupBy(array, i - 1.0)
+groupBy(array, i / 1.0)
+groupBy(array, i > #)
+groupBy(array, i ^ #)
 groupBy(array, i | bitand(#))?.list
 groupBy(array, i)
+groupBy(array, i) ?? $env.f64
+groupBy(array, i).Bar
 groupBy(array, i).add
 groupBy(array, i).array
 groupBy(array, i).f64
@@ -9609,48 +19887,80 @@ groupBy(array, i).i
 groupBy(array, i).ok
 groupBy(array, i).str
 groupBy(array, i)?.Bar
+groupBy(array, i)?.String
 groupBy(array, i)?.[f64]
+groupBy(array, i)?.[foo]
 groupBy(array, i)?.[ok]
 groupBy(array, i)?.[str]
 groupBy(array, i)?.add
 groupBy(array, i)?.array
 groupBy(array, i)?.f64
+groupBy(array, i)?.foo
+groupBy(array, i)?.foobar
+groupBy(array, i)?.greet
+groupBy(array, i)?.i
+groupBy(array, i)?.list
 groupBy(array, i)?.ok
 groupBy(array, i)?.str
 groupBy(array, if true { nil } else { f64 })
+groupBy(array, max(#))
 groupBy(array, max(i))
 groupBy(array, mean(1.0))
 groupBy(array, nil == $env)
+groupBy(array, nil == 0)
+groupBy(array, not false)
+groupBy(array, not ok)
+groupBy(array, ok ?? #)
+groupBy(array, ok or true)
 groupBy(array, ok)
 groupBy(array, ok).Bar
 groupBy(array, ok).String
 groupBy(array, ok).add
+groupBy(array, ok).array
 groupBy(array, ok).f64
 groupBy(array, ok).foo
 groupBy(array, ok).greet
+groupBy(array, ok).i
+groupBy(array, ok).list
 groupBy(array, ok).str
+groupBy(array, ok)?.Bar
 groupBy(array, ok)?.String
+groupBy(array, ok)?.[f64]
 groupBy(array, ok)?.[foo]
 groupBy(array, ok)?.[i]
 groupBy(array, ok)?.[ok]
 groupBy(array, ok)?.[str]
+groupBy(array, ok)?.add
 groupBy(array, ok)?.array
 groupBy(array, ok)?.foo
 groupBy(array, ok)?.list
 groupBy(array, ok)?.ok
+groupBy(array, ok)?.str
+groupBy(array, one(array, true))
 groupBy(array, round(i))
+groupBy(array, str endsWith str)
 groupBy(array, str)
 groupBy(array, str).Bar
 groupBy(array, str).String
 groupBy(array, str).add
+groupBy(array, str).array
 groupBy(array, str).foo
+groupBy(array, str).greet
+groupBy(array, str).i
 groupBy(array, str).list
+groupBy(array, str).ok
 groupBy(array, str).str
+groupBy(array, str)?.Bar
 groupBy(array, str)?.String
+groupBy(array, str)?.[f64]
 groupBy(array, str)?.[i]
 groupBy(array, str)?.[ok]
+groupBy(array, str)?.[str]
+groupBy(array, str)?.add
 groupBy(array, str)?.array
 groupBy(array, str)?.f64
+groupBy(array, str)?.foo
+groupBy(array, str)?.greet
 groupBy(array, str)?.i
 groupBy(array, str)?.list
 groupBy(array, str)?.not
@@ -9658,44 +19968,68 @@ groupBy(array, str)?.ok
 groupBy(array, str)?.str
 groupBy(array, sum(array))
 groupBy(array, toJSON(array))
+groupBy(array, toJSON(nil))
+groupBy(array, toJSON(ok))
 groupBy(array, true && true)
+groupBy(array, true || ok)
 groupBy(array, true).Bar
+groupBy(array, true).String
 groupBy(array, true).add
 groupBy(array, true).array
 groupBy(array, true).f64
 groupBy(array, true).foo
+groupBy(array, true).greet
 groupBy(array, true).i
 groupBy(array, true).list
+groupBy(array, true).ok
 groupBy(array, true).str
+groupBy(array, true)?.Bar
 groupBy(array, true)?.[f64]
 groupBy(array, true)?.[foo]
 groupBy(array, true)?.[i]
 groupBy(array, true)?.[ok]
 groupBy(array, true)?.[str]
 groupBy(array, true)?.add
+groupBy(array, true)?.array
 groupBy(array, true)?.f64
+groupBy(array, true)?.foo
 groupBy(array, true)?.i
 groupBy(array, true)?.list
 groupBy(array, true)?.ok
 groupBy(array, true)?.str
 groupBy(array, type(#))
 groupBy(array, type(i))
+groupBy(array, type(nil))
+groupBy(concat(array), #)
+groupBy(concat(list), true ?? #).array
+groupBy(false ? nil : array, f64)
 groupBy(filter($env, false), .ok.greet())
+groupBy(filter(array, false), #)
 groupBy(flatten(array), #)
 groupBy(flatten(list), #)
+groupBy(flatten(list), .Bar)
 groupBy(groupBy(array, ok).i, #?.[ok][.f64:])
 groupBy(i..i, #)
+groupBy(if false { ok } else { list }, ok)
+groupBy(keys($env), #)
 groupBy(list | map(#), f64)
 groupBy(list | map(#), ok)
 groupBy(list | map(array), $env?.f64)
+groupBy(list | map(false), #)
+groupBy(list | map(list), ok)
+groupBy(list, # != foo)
 groupBy(list, # == #)
+groupBy(list, # ?? nil)
 groupBy(list, #)
+groupBy(list, #) ?? foo
+groupBy(list, #) ?? str
 groupBy(list, #).Bar
 groupBy(list, #).String
 groupBy(list, #).add
 groupBy(list, #).array
 groupBy(list, #).f64
 groupBy(list, #).foo
+groupBy(list, #).foobar
 groupBy(list, #).greet
 groupBy(list, #).i
 groupBy(list, #).list
@@ -9703,6 +20037,7 @@ groupBy(list, #).ok
 groupBy(list, #).str
 groupBy(list, #)?.Bar
 groupBy(list, #)?.String
+groupBy(list, #)?.[$env?.[str]]
 groupBy(list, #)?.[f64]
 groupBy(list, #)?.[foo]
 groupBy(list, #)?.[i]
@@ -9717,24 +20052,33 @@ groupBy(list, #)?.i
 groupBy(list, #)?.list
 groupBy(list, #)?.ok
 groupBy(list, #)?.str
+groupBy(list, #.Bar not in $env)
 groupBy(list, #.Bar)
 groupBy(list, #.Bar).Bar
 groupBy(list, #.Bar).array
 groupBy(list, #.Bar).f64
 groupBy(list, #.Bar).foo
+groupBy(list, #.Bar).list
 groupBy(list, #.Bar).ok
 groupBy(list, #.Bar).str
 groupBy(list, #.Bar)?.String
 groupBy(list, #.Bar)?.[f64]
 groupBy(list, #.Bar)?.[ok]
+groupBy(list, #.Bar)?.add
 groupBy(list, #.Bar)?.array
 groupBy(list, #.Bar)?.f64
 groupBy(list, #.Bar)?.foo
+groupBy(list, #.Bar)?.greet
 groupBy(list, #.Bar)?.i
+groupBy(list, #.Bar)?.list
+groupBy(list, #.Bar)?.ok
+groupBy(list, #.String == $env)
 groupBy(list, #?.Bar)
 groupBy(list, #?.Bar)?.[f64]
 groupBy(list, #?.String())
 groupBy(list, $env != f64)
+groupBy(list, $env != greet)
+groupBy(list, $env != true)
 groupBy(list, $env == add)
 groupBy(list, $env == greet)
 groupBy(list, $env.f64)
@@ -9742,28 +20086,47 @@ groupBy(list, $env.foo)
 groupBy(list, $env.i)
 groupBy(list, $env.str)
 groupBy(list, $env?.[String])
+groupBy(list, $env?.[str])
 groupBy(list, $env?.f64)
 groupBy(list, $env?.foo)
 groupBy(list, $env?.foobar)
+groupBy(list, $env?.nil)
+groupBy(list, $env?.str)
+groupBy(list, -i)
 groupBy(list, .Bar)
+groupBy(list, .Bar) ?? str
+groupBy(list, .Bar).Bar
 groupBy(list, .Bar).String
 groupBy(list, .Bar).add
+groupBy(list, .Bar).array
+groupBy(list, .Bar).f64
 groupBy(list, .Bar).greet
+groupBy(list, .Bar).i
+groupBy(list, .Bar).list
 groupBy(list, .Bar)?.Bar
 groupBy(list, .Bar)?.[f64]
 groupBy(list, .Bar)?.[foo]
 groupBy(list, .Bar)?.[ok]
+groupBy(list, .Bar)?.[str]
 groupBy(list, .Bar)?.f64
 groupBy(list, .Bar)?.greet
 groupBy(list, .Bar)?.i
+groupBy(list, .Bar)?.ok
+groupBy(list, .Bar)?.str
 groupBy(list, 0 + 1)
 groupBy(list, 0 == 1)
+groupBy(list, 0).Bar
 groupBy(list, 0).String
 groupBy(list, 0).f64
 groupBy(list, 0).foo
+groupBy(list, 0).greet
+groupBy(list, 0).i
 groupBy(list, 0).list
+groupBy(list, 0).str
 groupBy(list, 0)?.Bar
+groupBy(list, 0)?.String
 groupBy(list, 0)?.[f64]
+groupBy(list, 0)?.[foo]
 groupBy(list, 0)?.[i]
 groupBy(list, 0)?.[str]
 groupBy(list, 0)?.add
@@ -9772,14 +20135,22 @@ groupBy(list, 0)?.f64
 groupBy(list, 0)?.foo
 groupBy(list, 0)?.greet
 groupBy(list, 0)?.i
+groupBy(list, 0)?.list
+groupBy(list, 0)?.ok
+groupBy(list, 0)?.str
 groupBy(list, 0.1)
+groupBy(list, 1 * 0)
 groupBy(list, 1 * i)
+groupBy(list, 1 not in array)
 groupBy(list, 1).Bar
 groupBy(list, 1).String
+groupBy(list, 1).add
+groupBy(list, 1).array
 groupBy(list, 1).f64
 groupBy(list, 1).foo
 groupBy(list, 1).foobar
 groupBy(list, 1).greet
+groupBy(list, 1).i
 groupBy(list, 1).str
 groupBy(list, 1)?.Bar
 groupBy(list, 1)?.String
@@ -9790,18 +20161,25 @@ groupBy(list, 1)?.[str]
 groupBy(list, 1)?.add
 groupBy(list, 1)?.array
 groupBy(list, 1)?.f64
+groupBy(list, 1)?.foo
 groupBy(list, 1)?.greet
+groupBy(list, 1)?.i
 groupBy(list, 1.0 > 1.0)?.[f64]
+groupBy(list, 1.0 >= f64)
+groupBy(list, 1.0 ?? foo)
 groupBy(list, 1.0 ^ 1.0)
+groupBy(list, 1.0) ?? list
 groupBy(list, 1.0) | get(1)
 groupBy(list, 1.0).String
 groupBy(list, 1.0).add
+groupBy(list, 1.0).array
 groupBy(list, 1.0).f64
 groupBy(list, 1.0).foo
 groupBy(list, 1.0).foobar
 groupBy(list, 1.0).greet
 groupBy(list, 1.0).i
 groupBy(list, 1.0).list
+groupBy(list, 1.0).ok
 groupBy(list, 1.0).str
 groupBy(list, 1.0)?.Bar
 groupBy(list, 1.0)?.String
@@ -9816,17 +20194,25 @@ groupBy(list, 1.0)?.f64
 groupBy(list, 1.0)?.foo
 groupBy(list, 1.0)?.greet
 groupBy(list, 1.0)?.i
+groupBy(list, 1.0)?.list
 groupBy(list, 1.0)?.ok
 groupBy(list, 1.0)?.str
+groupBy(list, abs(1))
 groupBy(list, add != add)
 groupBy(list, array | sum(1))
+groupBy(list, bitor(i, i))
+groupBy(list, ceil(0))
+groupBy(list, f64 - 1.0)
 groupBy(list, f64)
+groupBy(list, f64).Bar
 groupBy(list, f64).String
+groupBy(list, f64).add
 groupBy(list, f64).array
 groupBy(list, f64).f64
 groupBy(list, f64).foo
 groupBy(list, f64).greet
 groupBy(list, f64).i
+groupBy(list, f64).list
 groupBy(list, f64).ok
 groupBy(list, f64)?.Bar
 groupBy(list, f64)?.[f64]
@@ -9834,31 +20220,46 @@ groupBy(list, f64)?.[foo]
 groupBy(list, f64)?.[i]
 groupBy(list, f64)?.[ok]
 groupBy(list, f64)?.[str]
+groupBy(list, f64)?.add
 groupBy(list, f64)?.array
 groupBy(list, f64)?.f64
 groupBy(list, f64)?.foo
+groupBy(list, f64)?.greet
+groupBy(list, f64)?.i
+groupBy(list, f64)?.list
 groupBy(list, f64)?.ok
 groupBy(list, f64)?.str
 groupBy(list, false).Bar
 groupBy(list, false).String
 groupBy(list, false).add
+groupBy(list, false).array
 groupBy(list, false).f64
 groupBy(list, false).foo
 groupBy(list, false).foobar
+groupBy(list, false).greet
 groupBy(list, false).i
 groupBy(list, false).list
 groupBy(list, false).str
 groupBy(list, false)?.String
+groupBy(list, false)?.[f64]
 groupBy(list, false)?.[i]
+groupBy(list, false)?.[i]?.[i]
 groupBy(list, false)?.[ok]
+groupBy(list, false)?.[str]
 groupBy(list, false)?.add
 groupBy(list, false)?.array
 groupBy(list, false)?.f64
 groupBy(list, false)?.greet
+groupBy(list, false)?.i
+groupBy(list, false)?.list
 groupBy(list, false)?.ok
 groupBy(list, false)?.str
+groupBy(list, float(0))
+groupBy(list, foo != foo)
 groupBy(list, foo != nil)
 groupBy(list, foo == #)
+groupBy(list, foo == foo)
+groupBy(list, foo ?? #)
 groupBy(list, foo)
 groupBy(list, foo).Bar
 groupBy(list, foo).String
@@ -9866,6 +20267,7 @@ groupBy(list, foo).add
 groupBy(list, foo).array
 groupBy(list, foo).f64
 groupBy(list, foo).foo
+groupBy(list, foo).foobar
 groupBy(list, foo).greet
 groupBy(list, foo).i
 groupBy(list, foo).list
@@ -9875,6 +20277,7 @@ groupBy(list, foo)?.Bar
 groupBy(list, foo)?.String
 groupBy(list, foo)?.[f64]
 groupBy(list, foo)?.[foo]
+groupBy(list, foo)?.[i]
 groupBy(list, foo)?.[ok]
 groupBy(list, foo)?.[str]
 groupBy(list, foo)?.add
@@ -9888,9 +20291,13 @@ groupBy(list, foo)?.ok
 groupBy(list, foo)?.str
 groupBy(list, foo.Bar)
 groupBy(list, foo?.Bar)
+groupBy(list, foo?.String())
 groupBy(list, greet(.Bar))
 groupBy(list, i + i)
+groupBy(list, i == i)
 groupBy(list, i)
+groupBy(list, i).Bar
+groupBy(list, i).String
 groupBy(list, i).add
 groupBy(list, i).array
 groupBy(list, i).f64
@@ -9899,49 +20306,78 @@ groupBy(list, i).i
 groupBy(list, i).list
 groupBy(list, i).ok
 groupBy(list, i).str
+groupBy(list, i)?.Bar
+groupBy(list, i)?.String
+groupBy(list, i)?.[f64]
+groupBy(list, i)?.[foo]
+groupBy(list, i)?.[i]
 groupBy(list, i)?.[ok]
+groupBy(list, i)?.[str]
 groupBy(list, i)?.add
 groupBy(list, i)?.array
 groupBy(list, i)?.f64
 groupBy(list, i)?.foo
 groupBy(list, i)?.greet
+groupBy(list, i)?.i
+groupBy(list, i)?.list
 groupBy(list, i)?.ok
 groupBy(list, i)?.str
+groupBy(list, if false { # } else { #.Bar })
 groupBy(list, if true { # } else { false })
 groupBy(list, nil != 0)
+groupBy(list, nil == $env)
 groupBy(list, nil == 1.0)
+groupBy(list, nil == true)
+groupBy(list, nil ?? #)
 groupBy(list, none($env, true))
 groupBy(list, ok and ok)
 groupBy(list, ok)
 groupBy(list, ok).String
 groupBy(list, ok).add
+groupBy(list, ok).array
 groupBy(list, ok).f64
 groupBy(list, ok).foo
 groupBy(list, ok).i
 groupBy(list, ok).list
 groupBy(list, ok).ok
+groupBy(list, ok).ok?.[i]
+groupBy(list, ok).str
 groupBy(list, ok)?.Bar
+groupBy(list, ok)?.String
 groupBy(list, ok)?.[f64]
 groupBy(list, ok)?.[foo]
 groupBy(list, ok)?.[i]
 groupBy(list, ok)?.[ok]
 groupBy(list, ok)?.add
+groupBy(list, ok)?.f64
 groupBy(list, ok)?.foo
+groupBy(list, ok)?.greet
+groupBy(list, ok)?.i
 groupBy(list, ok)?.list
+groupBy(list, ok)?.ok
 groupBy(list, ok)?.str
+groupBy(list, reduce(list, false)).ok
 groupBy(list, str == nil)
+groupBy(list, str ?? true)
 groupBy(list, str)
+groupBy(list, str).Bar
+groupBy(list, str).String
 groupBy(list, str).add
 groupBy(list, str).array
+groupBy(list, str).f64
 groupBy(list, str).foo
 groupBy(list, str).greet
+groupBy(list, str).i
 groupBy(list, str).list
 groupBy(list, str).ok
 groupBy(list, str).str
+groupBy(list, str)?.Bar
+groupBy(list, str)?.String
 groupBy(list, str)?.[f64]
 groupBy(list, str)?.[foo]
 groupBy(list, str)?.[i]
 groupBy(list, str)?.[ok]
+groupBy(list, str)?.[str]
 groupBy(list, str)?.add
 groupBy(list, str)?.f64
 groupBy(list, str)?.foo
@@ -9953,7 +20389,13 @@ groupBy(list, str)?.ok
 groupBy(list, string(#))
 groupBy(list, string(add)).str
 groupBy(list, string(false))
+groupBy(list, sum(array))
+groupBy(list, toJSON(list))
+groupBy(list, toJSON(ok))
+groupBy(list, trimSuffix(str))
+groupBy(list, true ?? str)
 groupBy(list, true).Bar
+groupBy(list, true).String
 groupBy(list, true).add
 groupBy(list, true).array
 groupBy(list, true).f64
@@ -9969,299 +20411,649 @@ groupBy(list, true)?.[i]
 groupBy(list, true)?.[ok]
 groupBy(list, true)?.[str]
 groupBy(list, true)?.add
+groupBy(list, true)?.array
 groupBy(list, true)?.f64
 groupBy(list, true)?.greet
 groupBy(list, true)?.list
+groupBy(list, true)?.ok
 groupBy(list, true)?.str
+groupBy(list, type(0))
+groupBy(list, type(1.0))?.i
 groupBy(list, type(foo))
+groupBy(map($env, 1.0), f64)
 groupBy(map($env, 1.0), sum(array))
+groupBy(map($env, foo), min(1.0))
 groupBy(map(array, list), $env?.[str])
 groupBy(map(list, #index), #)
+groupBy(reverse(array), # <= 1)
 groupBy(reverse(array), foo)
 groupBy(reverse(array), i + f64)
 groupBy(reverse(array), ok)
 groupBy(sort($env), # != .array)
+groupBy(sort($env), #.Bar)
 groupBy(sort($env), #.add not contains str)
+groupBy(sort($env), #.foo.str)
+groupBy(sort($env), #.greet)
+groupBy(sort($env), #.greet?.[i])
+groupBy(sort($env), #.list.Bar(1.0))
+groupBy(sort($env), 1.0 <= .array)
+groupBy(sort($env), 1.0 | min(#.f64, str))
 groupBy(sort($env), i)
 groupBy(sort($env), max(#))
+groupBy(sort(array), foo)
+groupBy(str ?? $env, toJSON(false))
+groupBy(str ?? 1, foo)
+groupBy(str ?? add, str)
+groupBy(str ?? f64, # ^ #)
+groupBy(str ?? foo, str)
+groupBy(str ?? i, f64)
 groupBy(toPairs($env), 1 <= 1.0)
 groupBy(values($env), foo)
 groupBy(values($env), i)
+groupBy(values($env), str)
+hasPrefix(str, foo?.String())
 hasPrefix(str, str)
+hasPrefix(str, string(i))
+hasSuffix(foo.Bar, str)
 hasSuffix(foo.String(), str)
 hasSuffix(str, greet(str))
 hasSuffix(str, str)
+hasSuffix(string(1), str)
+hasSuffix(string(nil), foo?.Bar)
 i
 i != $env != $env
 i != $env != true
+i != $env && false
+i != $env ?? 1.0
+i != $env ?? f64
+i != $env ?? str
+i != $env and false
 i != $env || $env
 i != $env.f64
 i != $env.i
 i != $env?.$env?.list(add, nil)
 i != $env?.Bar
 i != $env?.Bar?.[f64]
+i != $env?.Bar?.[greet]
 i != $env?.String
 i != $env?.[Bar]
 i != $env?.[Bar]?.[i]
 i != $env?.[String]
 i != $env?.[String]?.[array]
+i != $env?.[foobar]
 i != $env?.[str]
 i != $env?.f64
+i != $env?.foobar
 i != $env?.i
 i != $env?.true
+i != $env?.true?.str()
+i != -0
+i != -1.0
+i != -f64
 i != 0 != $env
+i != 0 - 1.0 + 1.0
+i != 0 == ok
+i != 0 == true != true
+i != 0 ?? i
 i != 0 ^ 0
+i != 0 or $env
+i != 0 or ok
 i != 0 or true
+i != 0 || $env
+i != 1 && ok
 i != 1 / 1
+i != 1 == nil
+i != 1 ?? list
+i != 1 ^ f64
 i != 1 or ok
+i != 1.0 != $env
+i != 1.0 && str not endsWith str
 i != 1.0 * 1.0
 i != 1.0 * array?.[i]
 i != 1.0 ** 0
+i != 1.0 ** 1.0
 i != 1.0 + 1.0
 i != 1.0 + i
 i != 1.0 - 1.0
+i != 1.0 == false
+i != 1.0 == nil
 i != 1.0 == ok
+i != 1.0 == true
+i != 1.0 ?: $env
+i != 1.0 ?? false
+i != 1.0 ?? nil
+i != 1.0 ^ i
+i != 1.0 and false
+i != 1.0 or $env
 i != 1.0 || $env
+i != abs(f64)
 i != abs(i)
+i != add ?? [foo]
+i != add ?? i
 i != array?.[i]
 i != f64
+i != f64 && $env
 i != f64 && false
+i != f64 && true
 i != f64 + 1.0
+i != f64 + f64
+i != f64 ^ i
+i != f64 and $env
+i != false ?? list
+i != first($env)
 i != float(1.0)
 i != floor(0)
 i != floor(1)
+i != floor(1.0)
+i != floor(i)
+i != foo ?? greet
+i != foo ?? list
 i != i
 i != i != $env.ok
 i != i * f64
+i != i ?: greet
+i != i ?? 1.0
+i != i ^ 0 || true
+i != int(i)
 i != last($env)
+i != len($env)
+i != list ?? str
 i != max(1.0)
 i != mean(f64)
 i != median(1.0)
 i != min($env)
+i != min(0)
 i != min(i)
 i != nil != $env
+i != nil != false
 i != nil != ok
+i != nil && ok
+i != nil or ok
 i != sum(array)
+i != {foo: foo}.foo
 i % $env.i
 i % $env?.i
+i % -1
+i % -i
 i % 1 != 1.0
+i % 1 * f64
+i % 1 - 1
+i % 1 <= i
 i % 1 == i
+i % 1 > 0
+i % add(i, i)
 i % array?.[i]
 i % i
+i % i != $env
+i % i - 1
 i % i < i
 i % i <= 1
 i % i <= 1.0
 i % i == i ^ i
+i % i > 1.0
 i % len(str)
+i % min(i)
+i % nil ?? i
+i % sum(array)
+i * $env or true
+i * $env || true
 i * $env.f64
 i * $env.i
 i * $env?.f64
 i * $env?.i
 i * - - f64
+i * -1
+i * -1.0
+i * -i
 i * 0 != f64
 i * 0 != nil
+i * 0 + i
+i * 0 - i
+i * 0 == i
+i * 0 ?? i
+i * 0 | min(array)
 i * 1 != 0
+i * 1 != 1.0
+i * 1 % i
+i * 1 - i
+i * 1 < f64
 i * 1 | bitshl(i)
+i * 1.0 != 1.0
+i * 1.0 != nil
+i * 1.0 * 1.0
+i * 1.0 * f64
+i * 1.0 * i
 i * 1.0 + 1.0
 i * 1.0 + f64
 i * 1.0 - i
+i * 1.0 < 1
+i * 1.0 < i / 0
 i * 1.0 <= 0
+i * 1.0 <= 1.0
+i * 1.0 == $env?.[String]
 i * 1.0 == 0
+i * 1.0 ?? str
+i * 1.0 | min(i)
+i * abs(i)
 i * array?.[i]
 i * f64
+i * f64 ** 1
+i * f64 + f64
+i * f64 / f64
+i * f64 == i
+i * f64 ?? nil
+i * f64 ^ f64
 i * f64 ^ i
 i * floor(0)
+i * floor(f64)
 i * i
 i * i != i
 i * i % i
 i * i ** 1.0
 i * i / 1.0
+i * i / i
 i * i <= i
+i * i == $env
 i * i == 0
+i * i > i
+i * i ?? list
+i * i in array
+i * i | median(1)
 i * int(0)
 i * int(1.0)
+i * len(array)
+i * len(str)
+i * max(i)
 i * mean(array)
 i * mean(i)
 i * median(f64)
 i * median(i)
+i * min(0, f64)
 i * min(i)
+i * round(1.0)
 i * sum($env, 0)
 i * sum(array)
 i ** $env.f64
 i ** $env.i
 i ** $env?.f64
 i ** $env?.i
+i ** -0
+i ** -1.0
+i ** -f64
+i ** -i
+i ** 0 != nil
 i ** 0 - abs(i)
+i ** 0 in array
+i ** 1 != $env
+i ** 1 + i
+i ** 1 <= 1
+i ** 1 > 1.0
+i ** 1 ?? true
 i ** 1 ^ 1.0
+i ** 1.0 != i
+i ** 1.0 ** i
 i ** 1.0 + 1.0
+i ** 1.0 - 1
 i ** 1.0 - i
 i ** 1.0 / i
 i ** 1.0 == $env
+i ** 1.0 == nil
 i ** 1.0 >= f64 <= f64
+i ** 1.0 ?? foo
+i ** 1.0 ?? list
 i ** 1.0 ^ 1
 i ** 1.0 ^ i
 i ** 1.0 | max(1)
 i ** abs(1.0)
 i ** array?.[i]
+i ** bitshl(1, 0)
+i ** ceil(f64)
+i ** count($env, true)
 i ** f64
 i ** f64 * 1.0
+i ** f64 + 0
+i ** f64 < 1
 i ** f64 == nil
+i ** f64 ^ i
+i ** float(1.0)
+i ** float(i)
+i ** floor(f64)
 i ** i
 i ** i ** 1.0
 i ** i + f64
 i ** i / 1.0
 i ** i < 1
+i ** i == 1.0
 i ** i > 0
 i ** i >= i
+i ** i ^ 1
+i ** i | max(array, i)
 i ** int(i)
 i ** len($env)
+i ** len(list)
+i ** max(0)
 i ** max(1)
 i ** mean(1, array)
+i ** min(0)
 i ** min(1)
 i ** min(1.0)
 i ** min(1.0, array)
 i ** min(array)
+i ** min(f64)
+i ** nil ?? 1
 i ** sum($env, 1.0)
+i ** sum($env?.[str])
+i ** sum(array)
 i + $env != str || true
 i + $env.f64
 i + $env.i
 i + $env?.f64
 i + $env?.i
+i + -1
+i + -i
 i + 0 ** f64
+i + 0 - 0
+i + 0 - i
+i + 0 / 1
+i + 0 <= 1.0
+i + 0 ?? i
+i + 0 ?? ok
+i + 0 ?? true
+i + 1 != 1
 i + 1 != 1.0
+i + 1 - 1.0
 i + 1 .. i
 i + 1 < 0
+i + 1 ^ $env.f64
 i + 1 in array
+i + 1 | min(1.0, 1.0)
 i + 1.0 != nil
+i + 1.0 * len(array)
 i + 1.0 ** f64
+i + 1.0 - 1
+i + 1.0 < f64
+i + 1.0 < i
 i + 1.0 <= 1.0
 i + 1.0 == f64
+i + 1.0 > 1.0
+i + 1.0 >= 1.0 && $env
+i + 1.0 ?? $env
+i + 1.0 ?? false
+i + 1.0 ?? nil
 i + abs(1)
+i + abs(1.0)
+i + abs(i)
 i + array?.[i]
 i + bitnot(0)
 i + ceil($env.i)
+i + ceil(0)
 i + f64
+i + f64 != nil
 i + f64 ** i
 i + f64 <= i
+i + f64 > 1.0
+i + f64 ?? nil < 1.0
+i + first(array)
+i + float(1)
 i + float(1.0)
+i + floor(1.0)
+i + floor(i)
 i + i
+i + i ** f64
+i + i .. i
 i + i / 0
+i + i <= i
+i + i == $env
+i + i > 1.0
 i + i > i <= 0
 i + i | add(1)
+i + i | bitand(0)
 i + len($env)
+i + len(str)
+i + max(1)
+i + max(array)
 i + max(array, array)
+i + max(f64)
+i + max(i)
 i + mean(0)
+i + mean(1)
 i + mean(1.0)
 i + mean(i)
 i + reduce(list, 1.0)
+i + sum(array)
+i + sum(list, 0)
 i - $env and false and ok
 i - $env.f64
 i - $env.i
 i - $env?.f64
 i - $env?.i
+i - -0
+i - -1.0
+i - -f64
+i - -i
+i - 0 != 1.0
+i - 0 % i
+i - 0 * 1.0
+i - 0 ** 1
+i - 0 ** 1.0
 i - 0 ** f64
 i - 0 ** i
+i - 0 / 1.0
+i - 0 == f64
+i - 0 >= 0
 i - 0 | mean(1.0)
 i - 1 ** 1.0 ^ 1
 i - 1 / f64
+i - 1 < i
+i - 1 ?? array
+i - 1 ?? nil
 i - 1 ^ f64
+i - 1 in array
 i - 1.0 != $env?.String
 i - 1.0 != 1.0
+i - 1.0 * 0
+i - 1.0 ** 1.0
 i - 1.0 ** i
 i - 1.0 + 1
 i - 1.0 - 1.0
+i - 1.0 < 0
 i - 1.0 < f64
+i - 1.0 <= 0
+i - 1.0 <= f64
 i - 1.0 == $env
+i - 1.0 == i
+i - 1.0 > f64
+i - 1.0 >= 1
+i - 1.0 >= f64
+i - 1.0 ?? list
 i - 1.0 ^ i
+i - 1.0 ^ round(f64)
 i - 1.0 not in array
+i - 1.0 | min(1.0)
+i - array?.[0]
 i - array?.[i]
+i - ceil(0)
 i - ceil(1)
 i - ceil(1.0)
 i - f64
 i - f64 != 1
 i - f64 != 1.0
+i - f64 - i
 i - f64 >= f64
 i - f64 >= i
 i - f64 ^ 1.0 == 0
+i - f64 in array
 i - float(f64)
 i - floor(1.0)
 i - floor(f64)
+i - floor(i)
 i - i
+i - i != 1.0
 i - i != i
+i - i % i < 0
 i - i ** i
+i - i + i
+i - i / i
+i - i < f64
 i - i == 1.0
+i - i > 0
 i - i >= i
+i - i ?? $env
+i - i ?? array
+i - i ^ 1.0
 i - i not in $env?.String
+i - i | min(array)
+i - i..i
 i - int(0)
+i - int(1.0)
 i - len(array)
+i - len(list)
 i - max(1.0)
 i - max(array)
 i - mean(1.0)
+i - median(array, 1)
+i - min(0)
+i - min(1)
+i - min(1.0)
+i - min(f64)
+i - min(i)
+i - nil ?? f64
 i - reduce($env, #acc, i)
 i - reduce(array, #index)
+i - sum($env, f64)
 i .. $env.i
 i .. $env?.i
+i .. -i
+i .. 0 != $env
 i .. 0 * i
 i .. 0 == list
+i .. 0 ?? $env
+i .. 0 ?? list
 i .. 0 | all($env[.Bar:])
 i .. 0 | count($env)
+i .. 0 | groupBy($env)
 i .. 0 | groupBy(greet)
 i .. 0 | map(#)
 i .. 0 | median(f64)
+i .. 0 | reduce(#, $env)
 i .. 0 | sum(1)
 i .. 0 | sum(foo)
 i .. 0 | sum(str)
+i .. 1 - i
+i .. 1 ?? f64
+i .. 1 | filter(false)
 i .. 1 | groupBy(#)
+i .. 1 | groupBy(1.0)
 i .. 1 | map(#)
+i .. 1 | reduce(true)
+i .. 1 | sortBy(#)
 i .. 1 | sortBy(1)
 i .. 1 | sortBy(foo.Bar)
+i .. 1.0 ?? i
+i .. 1.0 ?? list
 i .. abs(i)
 i .. array?.[i]
+i .. bitnot(1)
+i .. f64 * 1.0 ?? 0
+i .. f64 ?? array
+i .. f64 ?? true
 i .. i
+i .. i != nil
 i .. i % 1
+i .. i ?? 1.0
+i .. i | filter(ok)
 i .. i | groupBy(#)
+i .. i | map(#)
 i .. i | reduce(#)
+i .. i | reduce($env)
+i .. i | reduce(1.0)
 i .. i | reduce(false)
+i .. i | reduce(foo)
+i .. i | sortBy(1)
+i .. i | sortBy(false)
 i .. int(0)
 i .. len(array)
 i .. max(0)
+i .. max(i)
 i .. median(i)
 i .. min(1)
+i .. sum(array)
 i / $env.f64
 i / $env.i
 i / $env?.f64
 i / $env?.i
+i / -0
+i / -1
+i / -1.0
+i / -f64
+i / -i
 i / 0 + f64 == i
 i / 0 - f64
 i / 0 < 1
+i / 0 <= i
 i / 0 == 1.0
+i / 0 not in array
+i / 1 != i
 i / 1 * i
 i / 1 ** f64
+i / 1 + f64
+i / 1 / 1
+i / 1 ?? foo
+i / 1 not in array
+i / 1 | median(f64, 1.0)
 i / 1.0 != 1
 i / 1.0 != 1.0
 i / 1.0 * ceil(1.0)
+i / 1.0 ** i
 i / 1.0 + f64
 i / 1.0 - 0
 i / 1.0 - f64
+i / 1.0 / i
 i / 1.0 < 0
 i / 1.0 < i
+i / 1.0 <= 1.0
 i / 1.0 > 1.0
+i / 1.0 ?? 1
+i / 1.0 ?? add
+i / 1.0 ?? foo
+i / 1.0 ?? greet
+i / 1.0 ?? list
+i / 1.0 ?? str
 i / 1.0 in array
+i / abs(1.0)
 i / array?.[i]
 i / bitnot(0)
+i / ceil(0)
 i / count(array, false)
 i / f64
+i / f64 * 1.0
+i / f64 / 1.0
 i / f64 < 1.0
+i / f64 == $env
+i / f64 > i
+i / f64 ?? 1
+i / f64 ^ i
+i / f64 in list ?? str
+i / float(1)
 i / floor(1.0)
 i / i
+i / i ** f64
 i / i + 1.0
 i / i < 0
+i / i < f64 ?? foo
 i / i <= 0
 i / i == 1.0
 i / i == i
+i / i == nil
+i / i ?? add
 i / i in array
 i / len($env)
 i / mean(1.0, 1.0)
+i / median(1)
+i / median(1.0)
+i / min(i)
+i / nil ?? i
+i / reduce(array, 0)
 i / sum(array)
 i / sum(list, f64)
 i < $env && false
@@ -10270,12 +21062,19 @@ i < $env.f64
 i < $env.i
 i < $env?.f64
 i < $env?.i
+i < -0
+i < -f64
+i < -i
+i < 0 != ok
 i < 0 && false
 i < 0 / i
 i < 0 < i
 i < 0 <= f64
 i < 0 > 0
+i < 0 ?? $env?.[Bar]
+i < 0 and ok
 i < 0 || $env
+i < 1 != $env
 i < 1 ** i
 i < 1 + 1.0
 i < 1 / 1.0
@@ -10284,77 +21083,161 @@ i < 1 <= $env?.[foo]
 i < 1 <= 1
 i < 1 <= sum($env, #)
 i < 1 ? array : add
+i < 1 ?? foo
+i < 1 ?? i
+i < 1 ?? nil
 i < 1 || $env
+i < 1.0 != nil
 i < 1.0 != ok
+i < 1.0 * f64
 i < 1.0 ** 0
+i < 1.0 / i
 i < 1.0 < $env?.f64
+i < 1.0 < 0
 i < 1.0 < 1.0
+i < 1.0 < i
 i < 1.0 <= 1
 i < 1.0 <= 1.0
 i < 1.0 <= f64
+i < 1.0 == $env
+i < 1.0 == nil
 i < 1.0 == true
+i < 1.0 > 1.0
+i < 1.0 ?? 0
+i < 1.0 ?? greet
 i < 1.0 || ok
+i < abs(1)
 i < abs(1.0)
+i < abs(i)
 i < array?.[i]
 i < bitnot(i)
+i < ceil(1.0)
 i < ceil(f64)
 i < f64
 i < f64 != ok
+i < f64 != true
 i < f64 ** ceil(1.0)
+i < f64 + 1.0
 i < f64 < 0
 i < f64 < f64 < i
+i < f64 == $env
 i < f64 >= $env
 i < f64 ? 1 : foo
+i < f64 or $env
+i < f64 || true
 i < findIndex($env, ok)
 i < first(array)
+i < float(0)
 i < float(i)
 i < floor(0)
+i < floor(f64)
 i < i
 i < i + i
+i < i / 0
+i < i <= i
+i < i == $env
+i < i >= i
 i < i ^ 0
+i < i || $env
 i < int(0)
+i < len($env)
+i < max(array)
 i < max(f64)
+i < mean(0, array)
 i < min(1.0)
+i < reduce(array, 1.0)
 i < round(1.0)
 i < sum(array)
+i < sum(array, 1.0)
 i <= $env.f64
 i <= $env.i
 i <= $env?.f64
 i <= $env?.i
+i <= -0
+i <= -1.0
+i <= -f64
 i <= 0 && $env
 i <= 0 * i
+i <= 0 + f64
 i <= 0 < $env
+i <= 0 >= 0
+i <= 0 >= f64
+i <= 0 ?? 0
+i <= 0 ?? nil
 i <= 0 and $env
 i <= 0 or false
 i <= 1 / 1
+i <= 1 / 1.0
+i <= 1 == nil
 i <= 1 >= 1
 i <= 1 || ok
 i <= 1.0 && ok
 i <= 1.0 * i
+i <= 1.0 - 1.0
+i <= 1.0 / f64
+i <= 1.0 / i
 i <= 1.0 < 0
+i <= 1.0 < f64
 i <= 1.0 <= 1
+i <= 1.0 == nil
+i <= 1.0 > 1.0
+i <= 1.0 > i
+i <= 1.0 ?? greet
+i <= 1.0 ^ i
+i <= 1.0 or $env
 i <= 1.0 or ok
 i <= 1.0 || $env.ok
+i <= 1.0 || ok
+i <= abs(f64)
+i <= array?.[i]
 i <= bitnot(1)
 i <= ceil(1.0)
 i <= f64
+i <= f64 * 1.0
 i <= f64 < 1.0
 i <= f64 > $env
+i <= f64 and false
+i <= f64 and true
 i <= f64 in $env?.String
+i <= f64 || $env
+i <= float(i)
+i <= floor(0)
 i <= floor(1)
+i <= floor(1.0)
 i <= i
+i <= i && true
 i <= i + i
+i <= i - 0
 i <= i / 1
 i <= i <= 1
 i <= i == nil
 i <= i >= i
 i <= i ?: add
+i <= i ?? f64
 i <= i ^ i
+i <= len(array)
+i <= max(1)
+i <= max(1.0)
+i <= max(array)
 i <= mean(1.0)
+i <= mean(i)
+i <= mean(i, i)
 i <= median(1.0)
+i <= median(array)
+i <= nil ?? 1.0
+i <= round(0)
+i <= sum(array, #)
 i == $env != $env
 i == $env != ok
+i == $env && ok
+i == $env == $env
+i == $env ? array : array
 i == $env ?: 1.0
+i == $env ?: f64
+i == $env ?? 0 ?? array
+i == $env ?? array
+i == $env and $env?.[String]
+i == $env and nil == 1.0
 i == $env || false
 i == $env.f64
 i == $env.i
@@ -10362,14 +21245,22 @@ i == $env?.Bar
 i == $env?.String
 i == $env?.String?.[f64]?.foo
 i == $env?.[Bar]
+i == $env?.[Bar]?.String()
+i == $env?.[Bar]?.add
 i == $env?.[String]
 i == $env?.[foobar]
 i == $env?.[str]
 i == $env?.f64
+i == $env?.false?.[str]
 i == $env?.foobar
 i == $env?.i
+i == -0 ** 0
+i == -1
+i == -1.0
+i == -i
 i == 0 != ok
 i == 0 ** i
+i == 0 + i
 i == 0 - 1.0
 i == 0 - f64 && false
 i == 0 ?: $env
@@ -10377,67 +21268,146 @@ i == 0 or $env
 i == 0 or ok
 i == 0 || $env
 i == 1 != false
+i == 1 && true
+i == 1 * 0
 i == 1 ** 1.0
 i == 1 - 1.0
 i == 1 / f64
+i == 1 / max(array)
 i == 1 == false
+i == 1 ?? 0
+i == 1 ?? true
+i == 1 ^ i
 i == 1 and true
+i == 1 || ok
+i == 1.0 != $env
 i == 1.0 != ok ?: foo
+i == 1.0 != true
+i == 1.0 * 1.0
 i == 1.0 ** 1.0
 i == 1.0 + 1.0
 i == 1.0 - 1
+i == 1.0 == nil
 i == 1.0 == true
+i == 1.0 ?? 1.0
+i == 1.0 ?? foo
+i == 1.0 ?? nil
+i == 1.0 ^ 1
 i == 1.0 ^ 1.0
+i == 1.0 || $env
 i == 1.0 || max($env)
+i == abs(f64)
 i == abs(i)
+i == add ?? ok
 i == array?.[i]
+i == bitnot(1)
+i == bitor(1, 0)
 i == ceil(1.0)
+i == count(list, false)
 i == f64
 i == f64 != $env
 i == f64 && $env
 i == f64 * 0
+i == f64 * 1
 i == f64 * f64
 i == f64 / f64
 i == f64 ? f64 : foo
 i == f64 ?: array
+i == f64 ?? foo
 i == float(1.0)
+i == floor(1)
+i == floor(i)
+i == foo ?? 1
+i == foo ?? ok
 i == i
+i == i + $env?.i
+i == i + 0
+i == i + f64
 i == i == $env
+i == i == nil
+i == i ?? 1.0
+i == i ?? false
 i == i ^ 0
+i == i ^ 1.0
+i == i or $env
+i == int(1.0)
 i == int(i)
+i == len(array)
+i == len(list)
+i == len(str)
+i == list ?? 1
+i == list ?? str
 i == max(array)
 i == max(i)
+i == mean(1.0)
 i == median(f64)
 i == min($env)
 i == min(f64)
 i == nil == $env
 i == nil ? $env?.[i] : list
 i == nil ?: foo
+i == nil ?? $env
+i == nil ?? 1
+i == nil or false
+i == nil || $env
+i == ok ?? 0
+i == round(1)
+i == round(f64)
 i == sum(array)
+i == sum(array, 1.0)
+i == true ?? add
 i > $env.f64
 i > $env.i
 i > $env?.f64
 i > $env?.i
+i > -1.0
 i > 0 + 1
 i > 0 + i
 i > 0 / f64
 i > 0 <= 1.0
 i > 0 == nil
+i > 0 > 1.0
+i > 0 > f64
 i > 0 ?: ok
+i > 0 and $env
+i > 0 or false
 i > 0.0
 i > 1 && ok
+i > 1 * 0
+i > 1 * f64
 i > 1 - 0
 i > 1 - 1.0
 i > 1 < 1.0
+i > 1 == ok
+i > 1 >= $env
+i > 1 >= $env[:0]
+i > 1 >= 0
+i > 1 ?? 1.0
 i > 1 or ok
+i > 1 || $env
+i > 1.0
+i > 1.0 ** 0
 i > 1.0 ** f64
+i > 1.0 - $env?.i
+i > 1.0 - 1
 i > 1.0 / 1
+i > 1.0 / i
+i > 1.0 < $env
+i > 1.0 < $env == nil
+i > 1.0 < -$env
 i > 1.0 == $env
+i > 1.0 == ok
 i > 1.0 > $env
 i > 1.0 > 1.0
 i > 1.0 >= 1.0
+i > 1.0 ?: array
+i > 1.0 ?? f64
+i > 1.0 ?? nil
 i > 1.0 or $env
+i > 1.0 or ok
+i > abs(i)
 i > array?.[i]
+i > ceil(1)
 i > ceil(1.0)
 i > f64
 i > f64 != nil
@@ -10445,29 +21415,54 @@ i > f64 != ok
 i > f64 && $env
 i > f64 ** i
 i > f64 + 1
+i > f64 / 1.0
+i > f64 <= i
 i > f64 >= 1
 i > f64 >= 1.0
+i > f64 ?? $env.foo
+i > f64 ?? i
 i > find(array, ok)
+i > float(0)
+i > floor(1)
 i > floor(1.0)
+i > get(array, 0)
 i > i
 i > i ** f64
 i > i + 0
+i > i - 1.0
+i > i <= 1
+i > i ?? greet
 i > i and $env
 i > last(array)
 i > len($env)
 i > max(1.0)
+i > max(i)
 i > mean(1.0)
 i > median(f64)
+i > min(0)
+i > min(i)
+i > round(-1.0)
 i > sum(array)
 i >= $env or true
+i >= $env || true
 i >= $env.f64
 i >= $env.i
 i >= $env?.f64
 i >= $env?.i
+i >= -1
+i >= -f64
+i >= -i
+i >= 0 != nil
+i >= 0 != ok
+i >= 0 - f64
+i >= 0 - i
 i >= 0 / max(1.0)
 i >= 0 <= i
 i >= 0 >= 1
+i >= 0 >= f64
+i >= 0 >= i
 i >= 0 ^ 1
+i >= 0 ^ f64
 i >= 0 or $env
 i >= 0 || $env
 i >= 0.0
@@ -10476,98 +21471,369 @@ i >= 1 ** f64
 i >= 1 - 1.0
 i >= 1 < f64
 i >= 1 > 1.0
+i >= 1 ?? $env?.[add]
 i >= 1 and $env
 i >= 1 and $env?.[str]
+i >= 1.0 != $env
+i >= 1.0 != nil
 i >= 1.0 && true
 i >= 1.0 * 0
 i >= 1.0 ** i
 i >= 1.0 + 1.0
+i >= 1.0 + i
+i >= 1.0 - sum($env, 0)
+i >= 1.0 ?? 1.0
 i >= 1.0 ^ i
 i >= 1.0 and $env
 i >= 1.0 or $env
+i >= 1.0 or false
+i >= abs(1)
 i >= array?.[i]
 i >= ceil(0)
 i >= f64
+i >= f64 != $env
 i >= f64 * 0
+i >= f64 * 1
+i >= f64 * 1.0
 i >= f64 ** f64
 i >= f64 ** i
 i >= f64 + 1
+i >= f64 - 0
 i >= f64 < i
 i >= f64 > 1.0
+i >= f64 ?? foo
+i >= f64 ?? ok
+i >= f64 and $env
 i >= f64 || $env
 i >= float(1)
+i >= float(1.0)
+i >= float(f64)
 i >= floor(i)
 i >= i
+i >= i != $env
+i >= i != ok
+i >= i * 0
 i >= i ** 0
 i >= i - i
 i >= i / 1.0
+i >= i ?? list
+i >= i ?? nil == nil
+i >= i || $env
+i >= i || false
+i >= int(1)
 i >= int(1.0)
+i >= last(array)
+i >= max(array)
+i >= mean(1.0)
+i >= mean(f64)
+i >= median(0)
+i >= median(1.0)
+i >= median(array)
+i >= min(1)
 i >= min(1.0)
+i >= min(array)
 i >= reduce($env, 0, 0)
+i >= round(f64)
 i >= round(i)
+i >= sum(array)
+i ?? !$env
+i ?? !ok
+i ?? !true
+i ?? $env.add
+i ?? $env.array
+i ?? $env.f64
+i ?? $env.foo
+i ?? $env.greet
+i ?? $env.i
+i ?? $env.list
+i ?? $env.ok
+i ?? $env.str
+i ?? $env?.Bar
+i ?? $env?.Bar()
+i ?? $env?.String
+i ?? $env?.String()
+i ?? $env?.String(foobar, foobar startsWith foobar?.list)
+i ?? $env?.String?.[i]
+i ?? $env?.[Bar]
+i ?? $env?.[String]
+i ?? $env?.[add]
+i ?? $env?.[array]
+i ?? $env?.[f64]
+i ?? $env?.[f64].str
+i ?? $env?.[foo]
+i ?? $env?.[foobar and foobar]
+i ?? $env?.[foobar]
+i ?? $env?.[greet]
+i ?? $env?.[i.f64]
+i ?? $env?.[i]
+i ?? $env?.[i].Bar()
+i ?? $env?.[list | median(true)]
+i ?? $env?.[list]
+i ?? $env?.[list]?.[list]
+i ?? $env?.[list]?.str()
+i ?? $env?.[ok]
+i ?? $env?.[str]
+i ?? $env?.add
+i ?? $env?.array
+i ?? $env?.f64
+i ?? $env?.foo
+i ?? $env?.foobar
+i ?? $env?.foobar?.[list]
+i ?? $env?.i
+i ?? $env?.list
+i ?? $env?.ok
+i ?? $env?.str
+i ?? $env?.true.foobar
+i ?? $env[$env.greet():]
+i ?? $env[:find(i, #acc)]
+i ?? $env[:foobar]
+i ?? $env[add:]
+i ?? $env[any(foo, i):]
+i ?? $env[f64?.String():]
+i ?? $env[false:foobar]
+i ?? $env[find(f64, 1.0):]?.[f64]
+i ?? $env[foo:foobar]
+i ?? $env[foobar:]
+i ?? $env[nil:1]
+i ?? -$env
+i ?? -0
+i ?? -1.0
+i ?? -abs($env?.String(foobar))?.ok
+i ?? -i
+i ?? 0 ?? foo
+i ?? 0 ?? nil
+i ?? 1.0 ?? $env.greet
+i ?? 1.0 ?? ok
+i ?? 1.0 ?? str
+i ?? 1.0 | bitand(0)
+i ?? 1.0 | max(0)
+i ?? [1.0]
+i ?? [false]
+i ?? [nil]
+i ?? [ok]
+i ?? abs($env - $env)?.[f64]
+i ?? abs($env)
+i ?? add
+i ?? add ?? 1
+i ?? all($env, #.add)
+i ?? array
+i ?? array ?? ok
+i ?? array?.[i]
+i ?? bitand(i, $env)
+i ?? ceil(i)
+i ?? count(array)
+i ?? count(list)
+i ?? date(false)
+i ?? date(foo)
+i ?? date(foo, array)
+i ?? date(nil)
+i ?? date(true, true)
+i ?? f64
+i ?? f64 ?? nil
+i ?? false ?? str
+i ?? findLast($env, .f64)
+i ?? findLastIndex($env, #)
+i ?? findLastIndex($env, $env)
+i ?? first($env)
+i ?? first(array)
+i ?? foo
+i ?? foo ?? foo
+i ?? foo | bitshl(0)
+i ?? foo | get(true)
+i ?? foo.Bar
+i ?? foo.String
+i ?? foo.String()
+i ?? foo?.Bar
+i ?? foo?.String
+i ?? foo?.String()
+i ?? fromBase64(str)
+i ?? fromJSON($env)
+i ?? fromPairs($env)
+i ?? greet
+i ?? greet ?? f64
+i ?? greet($env - 1.0)
+i ?? greet($env)
+i ?? greet(str)
+i ?? groupBy($env, i)
+i ?? hasSuffix($env, $env)
+i ?? i
+i ?? i ?? add
+i ?? join($env)
+i ?? list
+i ?? list ?? f64
+i ?? list ?? ok
+i ?? list?.[i]
+i ?? map($env, 0)
+i ?? map($env, 1)
+i ?? max($env)
+i ?? max(1.0)
+i ?? max(array)
+i ?? max(array)?.[f64]
+i ?? median(f64)
+i ?? median(list, list)
+i ?? min($env)
+i ?? nil ?? $env
+i ?? not $env
+i ?? not $env?.String(false)
+i ?? not $env?.[greet]
+i ?? not false
+i ?? not true
+i ?? ok
+i ?? ok ?? greet
+i ?? reduce(array, #acc)
+i ?? reduce(array, ok)
+i ?? round(0)
+i ?? sort(array)
+i ?? sortBy(list, #)
+i ?? str
+i ?? string(1)
+i ?? string(1.0)
+i ?? string(list)
+i ?? string(str)
+i ?? sum($env)
+i ?? sum($env, #.greet)
+i ?? sum($env, array)
+i ?? sum(array, #)
+i ?? sum(array, $env)
+i ?? sum(list)
+i ?? sum(list)?.String
+i ?? toBase64(str)
+i ?? toJSON(1.0)
+i ?? toJSON(ok)
+i ?? true ?? i
+i ?? true | get(0)
+i ?? type(greet)
+i ?? upper($env)
+i ?? {foo: 0}
+i ?? {foo: 1, foo: nil, foo: nil}
+i ?? {foo: 1.0}
+i ?? {foo: array}
+i ?? {foo: foo, foo: greet}.Bar
+i ?? {foo: foo}
+i ?? {foo: list}
+i ?? {foo: nil, foo: str}
+i ?? {foo: true}
 i ^ $env.f64
 i ^ $env.i
 i ^ $env?.f64
 i ^ $env?.i
+i ^ -1
+i ^ -1.0
+i ^ -f64
+i ^ -i
 i ^ 0 != 1.0
+i ^ 0 * abs(1)
+i ^ 0 + 1
+i ^ 0 < 1.0
 i ^ 0 < i
+i ^ 0 > f64
 i ^ 0 not in array
+i ^ 1 != $env
+i ^ 1 - f64
+i ^ 1 < i
 i ^ 1 == 0
+i ^ 1 >= i
+i ^ 1 | median(1, i, 0)
+i ^ 1.-0
+i ^ 1.0 != $env
 i ^ 1.0 != i
 i ^ 1.0 != nil
 i ^ 1.0 - 0
+i ^ 1.0 - 1
+i ^ 1.0 / i
 i ^ 1.0 < 1
+i ^ 1.0 < 1.0
+i ^ 1.0 < f64
 i ^ 1.0 <= 0
 i ^ 1.0 == 0
+i ^ 1.0 > 0
 i ^ 1.0 > 1.0
 i ^ 1.0 > f64
 i ^ 1.0 > i
 i ^ 1.0 > max(0)
+i ^ 1.0 ?? 1.0
+i ^ 1.0 ?? add
 i ^ 1.0 | max(0)
 i ^ abs(0)
 i ^ array?.[i]
+i ^ bitnot(1)
 i ^ ceil(1)
+i ^ ceil(1.0)
 i ^ count($env, false)
 i ^ f64
 i ^ f64 * 0
 i ^ f64 ** f64
+i ^ f64 + i
+i ^ f64 == $env
+i ^ f64 == 1
+i ^ f64 == float(1.0)
 i ^ f64 >= 1
+i ^ f64 ?? 1
 i ^ f64 ^ 1.0
+i ^ findIndex($env, true)
+i ^ findIndex(array, true)
 i ^ first(array)
 i ^ float(1.0)
+i ^ floor(1)
 i ^ floor(1.0)
 i ^ i
+i ^ i != f64
 i ^ i * i
 i ^ i / f64
+i ^ i < i
 i ^ i == nil
+i ^ i > f64
 i ^ i >= i
+i ^ i ?? $env?.i
+i ^ i ?? array
+i ^ i ^ 0 ?? list
+i ^ i ^ 1.0
+i ^ i in array
 i ^ i not in array
 i ^ int(1)
 i ^ int(1.0)
+i ^ int(i)
 i ^ len($env)
 i ^ max(array)
 i ^ mean(1.0)
 i ^ mean(array)
 i ^ mean(f64)
+i ^ median(1.0)
+i ^ min(0)
 i ^ min(1.0)
 i ^ min(i)
 i ^ sum(array)
 i in $env and false
 i in $env.array
 i in $env?.Bar
+i in $env?.Bar?.[list]
 i in $env?.String
 i in $env?.[Bar]
 i in $env?.[String]
+i in $env?.[String]?.foo
+i in $env?.[foobar?.[list]]
 i in $env?.array
+i in $env?.nil
+i in [0]
 i in array
+i in array != $env
+i in array ?? ok
 i in array and $env
+i in array and ok
 i in array or ok
 i in concat(array)
 i in concat(list, list)
 i in flatten(list)
 i in groupBy(list, #)?.i
+i in i .. 0
 i in last($env)
+i in list ?? str
+i in map($env, f64)
+i in sort(array)
+i in toPairs($env)
 i in {foo: 1.0}.greet
+i in {foo: nil}?.greet
+i not in $env or true
 i not in $env.array
 i not in $env?.Bar
 i not in $env?.String
@@ -10575,17 +21841,29 @@ i not in $env?.[Bar]
 i not in $env?.[Bar]?.array
 i not in $env?.[String]
 i not in $env?.[String]?.[list]
+i not in $env?.[String]?.str
+i not in $env?.[foobar]
 i not in $env?.array
+i not in $env?.foobar?.[i]
+i not in $env?.nil?.[add]
 i not in 1 .. i
 i not in [1.0]
 i not in [1]
 i not in [true, nil]
 i not in array
+i not in array == ok
 i not in array == true
+i not in concat(array)
 i not in flatten(array)
 i not in flatten(list)
+i not in groupBy(array, #)
+i not in groupBy(list, i)
+i not in last($env)
 i not in map(list, 1)
+i not in map(list, f64)
+i not in values($env)
 i | add(0)
+i | add(0) ?? foo
 i | add(1)
 i | add(i)
 i | bitand(0)
@@ -10594,15 +21872,18 @@ i | bitand(1) + i
 i | bitand(i)
 i | bitnand(0)
 i | bitnand(1)
+i | bitnand(array?.[i])
 i | bitnand(i)
 i | bitor(0)
 i | bitor(1 % 1)
 i | bitor(1)
 i | bitor(i)
+i | bitor(sum(array))
 i | bitshl($env.i)
 i | bitshl(0)
 i | bitshl(1)
 i | bitshl(i)
+i | bitshl(sum(array))
 i | bitshr(0)
 i | bitshr(0) != 1.0 || false
 i | bitshr(1)
@@ -10621,52 +21902,78 @@ i | max(1.0)
 i | max(1.0, array)
 i | max(1.0, f64)
 i | max(array)
+i | max(array, 0)
+i | max(array, 1)
 i | max(f64)
 i | max(f64, 0)
 i | max(f64, f64)
 i | max(i)
 i | max(i, array)
+i | mean(0 / 1.0)
 i | mean(0)
+i | mean(0, array, 0)
 i | mean(1)
 i | mean(1, array)
 i | mean(1.0)
 i | mean(array)
+i | mean(f64 * 1)
 i | mean(f64)
 i | mean(f64, 1)
 i | mean(i)
 i | mean(i, f64)
 i | median(0)
 i | median(0, 0)
+i | median(0, 1.0)
+i | median(0, array, array)
 i | median(1)
+i | median(1) / f64
 i | median(1, 1)
+i | median(1, f64)
 i | median(1.0)
+i | median(1.0, 0)
+i | median(1.0, 1)
 i | median(1.0, i)
 i | median(array)
 i | median(f64)
 i | median(i)
 i | median(i) != f64
 i | median(i, 1.0)
+i | median(i, i)
 i | min(0)
+i | min(0) <= i
 i | min(0) | median(1.0)
+i | min(0, array)
 i | min(0, f64)
 i | min(1)
+i | min(1.0 ?? add)
 i | min(1.0)
+i | min(1.0, 0)
 i | min(array)
+i | min(array, f64)
+i | min(array, i, f64)
 i | min(f64)
+i | min(f64, 1)
 i | min(f64, array)
 i | min(i)
 i | min(i, 1)
+i | min(i, 1.0)
 i..array?.[i]
 i..i
 i..i - 0
 i..i == $env
 i..i == nil
 i..i | map(#)
+i..i | map(ok)
 i..i | reduce(foo)
+i..i | sortBy(ok)
 i; 1.0; $env.foo
+i; add
+i; array
 i; ceil(1.0)
 i; f64
+i; foo
 i; greet
+i; i
 i; i; greet(str)
 i; list
 i; str
@@ -10675,26 +21982,45 @@ if $env != f64 { add } else { foo }
 if $env != foo { greet } else { str }
 if $env == 1.0 { list } else { add }
 if $env?.ok { foo?.String } else { greet }
+if $env?.ok { greet } else { foo }
 if 0 > 1 { list } else { false ? ok : ok }
+if 0 > f64 { f64 } else { array }
+if 1.0 != $env { ok } else { $env <= $env }
 if 1.0 >= 0 { foo } else { ok }
+if array == $env { i } else { median(0) }
+if f64 > 1.0 { array } else { round(1.0) }
 if f64 not in array { map(list, list) } else { add }
+if foo == foo { true != true } else { list | groupBy(1) }
+if i < 0 { str } else { str }
 if i > $env?.i { greet } else { list }
+if nil != nil { $env | bitshl(i) } else { 0 != $env }
 if nil != str { greet } else { array }
+if nil == nil { greet } else { array }
+if nil == ok { ok } else { greet }
+if nil not in list { array } else { f64 }
 if ok or false { str } else { greet }
 if ok { $env.foo } else { foo.Bar }
 if ok { 0 != i } else { ok }
 if ok { 1 > 1.0 } else { f64 }
+if ok { 1.0 ?? 0 } else { $env != $env }
 if ok { add } else { add }
+if ok { add } else { array }
 if ok { add } else { f64 }
+if ok { add } else { foo != $env }
 if ok { add } else { foo }
 if ok { add } else { greet }
 if ok { add } else { i }
 if ok { add } else { ok }
 if ok { array } else { foo }
 if ok { array } else { foo?.Bar }
+if ok { array } else { i }
+if ok { array } else { str }
+if ok { ceil(i) } else { list }
+if ok { f64 } else { array }
 if ok { f64 } else { f64 }
 if ok { f64 } else { findLastIndex($env, $env) }
 if ok { f64 } else { foo }
+if ok { f64 } else { list }
 if ok { f64 } else { ok }
 if ok { false && true } else { false == nil }
 if ok { foo } else { $env ?: f64 }
@@ -10702,13 +22028,19 @@ if ok { foo } else { $env?.str }
 if ok { foo } else { f64 }
 if ok { foo } else { foo }
 if ok { foo } else { greet }
+if ok { foo } else { i }
 if ok { foo } else { ok }
 if ok { foo.Bar } else { 1 == 1.0 }
 if ok { greet } else { array }
 if ok { greet } else { f64 }
+if ok { greet } else { greet }
 if ok { greet } else { i }
 if ok { greet } else { str }
+if ok { i } else { $env | filter($env) }
+if ok { i } else { add }
+if ok { i } else { array }
 if ok { i } else { date($env) }
+if ok { i } else { str }
 if ok { i } else { type(nil) }
 if ok { list } else { i }
 if ok { list } else { nil == true }
@@ -10716,38 +22048,70 @@ if ok { list } else { ok }
 if ok { list } else { str }
 if ok { nil == false } else { greet }
 if ok { ok } else { $env.add }
+if ok { ok } else { add }
 if ok { ok } else { array }
+if ok { ok } else { date(1.0) }
 if ok { ok } else { foo }
 if ok { ok } else { greet }
+if ok { ok } else { ok }
 if ok { str } else { array }
+if ok { str } else { foo }
 if ok { str } else { i }
+if ok { str } else { list }
 if ok { str } else { ok }
+if ok { str } else { str }
 if ok { type(f64) } else { foo }
 if str == $env { foo?.String() } else { $env.foo }
 if str > str { str } else { find(array, ok) }
+if true != true { i } else { array }
 if true && ok { array } else { greet }
 indexOf($env?.[str], str)
+indexOf($env?.str, $env?.str)
 indexOf(str, str)
 indexOf(toJSON(1.0), toJSON(true))
 int($env | count(ok))
 int($env | findIndex(ok))
 int($env | findIndex(true))
+int($env | findLastIndex(true))
+int($env | reduce(1, f64))
+int($env | sum(f64))
 int($env | sum(i))
 int($env.f64)
 int($env.i)
 int($env?.f64)
 int($env?.i)
+int(-$env?.i)
+int(-0)
+int(-1)
+int(-1.0)
+int(-f64)
+int(-i)
 int(0 % 1)
 int(0 % i)
 int(0 * 1)
 int(0 * 1.0)
+int(0 * f64)
+int(0 * i)
+int(0 ** 0)
+int(0 ** 1)
 int(0 ** 1.0)
 int(0 + 1)
 int(0 + 1.0)
+int(0 + f64)
+int(0 - $env.i)
 int(0 - 1.0)
+int(0 - f64)
+int(0 - i)
 int(0 / 0)
 int(0 / 1)
+int(0 / 1.0)
 int(0 / i)
+int(0 ?? 0)
+int(0 ?? 1)
+int(0 ?? 1.0)
+int(0 ?? array)
+int(0 ?? list)
+int(0 ?? true)
 int(0 ^ 0)
 int(0 ^ 1.0)
 int(0 ^ i)
@@ -10761,29 +22125,51 @@ int(0) + i
 int(0) - i
 int(0) .. i
 int(0) == i
+int(0) > 0 + i
 int(0) > 1.0 > 1
 int(0) ^ i
+int(0) | bitshl(0)
 int(0) | mean(i)
 int(0) | median(array)
 int(0)..i
+int(0.0)
 int(1 % 1)
 int(1 * 0)
 int(1 * 1.0)
+int(1 * i)
 int(1 ** 1.0)
+int(1 ** f64)
 int(1 ** i)
 int(1 + f64)
+int(1 - 0)
+int(1 - 1)
 int(1 - 1.0)
 int(1 - f64)
 int(1 - i)
 int(1 / 1.0)
 int(1 / f64)
+int(1 ?? 1)
+int(1 ?? 1.0)
+int(1 ?? add)
+int(1 ?? false)
+int(1 ?? foo)
+int(1 ?? ok)
+int(1 ?? true)
 int(1 ^ 0)
 int(1 ^ 1.0)
+int(1 ^ f64)
+int(1 ^ i)
+int(1 | bitxor(i))
 int(1 | max(i))
+int(1 | median(f64))
 int(1) != i
+int(1) * f64
+int(1) - f64
 int(1) <= f64
 int(1) == f64
 int(1) == i
+int(1) ?? add
+int(1) ?? str
 int(1) ^ f64
 int(1) not in array
 int(1.0 * 1)
@@ -10792,38 +22178,81 @@ int(1.0 * f64)
 int(1.0 ** 0)
 int(1.0 ** 1.0)
 int(1.0 ** f64)
+int(1.0 ** i)
 int(1.0 + 0)
 int(1.0 + 1)
+int(1.0 + 1.0)
+int(1.0 + f64)
+int(1.0 + i)
+int(1.0 - 0)
 int(1.0 - 1)
+int(1.0 - 1.0)
+int(1.0 - f64)
 int(1.0 / 0)
 int(1.0 / 1)
 int(1.0 / 1.0)
+int(1.0 / f64)
+int(1.0 / i)
+int(1.0 ?? $env)
+int(1.0 ?? 0)
+int(1.0 ?? 1.0)
+int(1.0 ?? add)
+int(1.0 ?? array)
+int(1.0 ?? f64)
+int(1.0 ?? foo)
+int(1.0 ?? foo?.Bar)
+int(1.0 ?? i)
+int(1.0 ?? list)
+int(1.0 ?? nil)
+int(1.0 ?? ok)
+int(1.0 ?? str)
+int(1.0 ?? true)
+int(1.0 ^ 0)
 int(1.0 ^ 1)
 int(1.0 ^ 1.0)
 int(1.0 ^ f64)
 int(1.0 ^ i)
+int(1.0 | median(1))
 int(1.0 | min(f64))
 int(1.0)
 int(1.0) != 1.0 ^ i
 int(1.0) != f64
 int(1.0) != i
+int(1.0) * f64
 int(1.0) * i
 int(1.0) ** f64
+int(1.0) ** i
+int(1.0) + i / 1
+int(1.0) .. i
 int(1.0) / i
+int(1.0) < f64
 int(1.0) == f64
 int(1.0) == i
+int(1.0) > 1 > 1.0
 int(1.0) >= f64
+int(1.0) ?? foo
+int(1.0) ?? greet
+int(1.0) ?? greet($env)
 int(1.0) in array
+int(1.0) | bitushr(i)
 int(1.0) | median(array)
 int(1.0)..i
 int(abs(0))
 int(abs(1))
+int(abs(1.0))
 int(abs(f64))
 int(abs(i))
+int(array | count(false))
+int(array | count(ok))
+int(array | find(not false))
+int(array | max(f64, array, 0))
+int(array | median(f64, i))
 int(array | min(1.0))
 int(array | reduce(#))
 int(array | reduce(#index))
+int(array | reduce(0))
 int(array | sum(#))
+int(array | sum(0))
 int(array?.[1])
 int(array?.[i])
 int(bitnot(0))
@@ -10833,6 +22262,7 @@ int(bitshr(0, i))
 int(ceil($env?.i))
 int(ceil(0))
 int(ceil(1))
+int(ceil(1.0))
 int(ceil(f64))
 int(ceil(i))
 int(count($env, true))
@@ -10844,67 +22274,112 @@ int(f64 * 1.0)
 int(f64 * f64)
 int(f64 ** 1)
 int(f64 ** i)
+int(f64 + 1.0)
 int(f64 + i)
 int(f64 - 0)
 int(f64 - 1)
 int(f64 - 1.0)
+int(f64 - f64)
 int(f64 - i)
 int(f64 / 0)
+int(f64 / 1)
+int(f64 / 1.0)
+int(f64 ?? $env)
+int(f64 ?? 0)
+int(f64 ?? 1.0)
+int(f64 ?? false)
+int(f64 ?? foo)
+int(f64 ?? i)
 int(f64 ^ 0)
+int(f64 ^ 1.0)
+int(f64 ^ f64)
 int(f64 ^ i)
 int(f64 | mean(i))
 int(f64 | min(1.0))
 int(f64)
+int(f64) != f64
+int(f64) / i
 int(f64) <= ceil(1.0)
 int(f64) <= f64
 int(f64) == i
 int(f64) in array
+int(f64) not in array ?? nil
+int(f64)..i
+int(false ?: 1.0)
+int(findIndex(array, true))
+int(findIndex(list, ok))
 int(findLast(array, true))
 int(findLastIndex($env, ok))
+int(findLastIndex(list, true))
+int(first(array))
 int(float(0))
 int(float(1))
 int(float(1.0))
 int(float(f64))
 int(float(i))
+int(floor(1))
 int(floor(1.0))
 int(floor(f64))
 int(floor(i))
 int(i % i)
+int(i * i)
 int(i ** 1)
 int(i ** 1.0)
 int(i ** i)
 int(i + 0)
 int(i + 1)
 int(i + 1.0)
+int(i + f64)
 int(i - 1)
 int(i - 1.0)
+int(i - f64)
 int(i - i)
+int(i / 0)
 int(i / 1.0)
+int(i / i)
+int(i ?? 1.0)
+int(i ?? add)
+int(i ?? false)
+int(i ?? foo)
+int(i ?? i)
+int(i ?? nil)
+int(i ^ 1.0)
 int(i | bitxor(1))
 int(i)
 int(i) != f64
 int(i) * i
+int(i) ** f64
 int(i) .. i
 int(i) < i
 int(i) == sum(array)
+int(i) ?? array
+int(i) ?? foo
+int(i) ?? foo ?? list
 int(i) | min(array)
+int(if ok { 1 } else { f64 })
 int(if true { 1.0 } else { $env })
 int(int(0))
 int(int(1))
 int(int(1.0))
+int(int(f64))
 int(int(i))
 int(last(array))
 int(len($env))
 int(len(0 .. i))
 int(len(array))
 int(len(list))
+int(len(str))
 int(let foobar = 1.0; foobar)
 int(list | findLastIndex(ok))
 int(list | reduce(#index))
 int(list | reduce(0))
+int(list | reduce(1, false))
 int(list | reduce(1.0))
+int(list | reduce(i))
+int(list | sum(1))
 int(list | sum(f64))
 int(max(0))
+int(max(1))
 int(max(1.0))
 int(max(array))
 int(max(f64))
@@ -10923,17 +22398,30 @@ int(median(i))
 int(min(0))
 int(min(1))
 int(min(1.0))
+int(min(1.0, i))
 int(min(array))
+int(min(f64))
 int(min(i))
+int(min(i, array))
+int(nil ?? 0)
+int(nil ?? 1.0)
+int(nil ?? i)
 int(ok ? 1.0 : greet)
 int(ok ? f64 : list)
+int(reduce($env, 1.0, i))
+int(reduce(array, #))
+int(reduce(array, f64))
 int(reduce(list, 1.0))
 int(round(1))
 int(round(1.0))
 int(round(f64))
 int(round(i))
 int(string(0))
+int(string(1))
 int(string(1.0))
+int(string(i))
+int(sum($env, 0))
+int(sum($env, 1))
 int(sum($env, i))
 int(sum(array))
 int(sum(array, #))
@@ -10941,138 +22429,267 @@ int(sum(array, f64))
 int(toJSON(0))
 int(toJSON(1))
 int(toJSON(1.0))
+int(toJSON(i))
 int(toPairs($env) | reduce(i))
+int(true ? 1 : array)
 int(true ? 1.0 : $env)
 int(true ? f64 : foo)
+int(true ? i : nil)
+join($env | filter(false))
 join([str])
 join(array | map(str))
 join(keys($env))
+join(list | map(str))
 join(map(list, #.Bar))
 join(sort($env))
+keys($env ?? 0)
+keys($env ?? 1)
+keys($env ?? 1.0)
+keys($env ?? array)
+keys($env ?? f64)
+keys($env ?? false)
+keys($env ?? foo)
+keys($env ?? greet)
+keys($env ?? nil)
+keys($env ?? true)
+keys($env | reduce($env, add))
 keys($env) != array
+keys($env) != foo ?? 1.0
+keys($env) == foo ?? f64
+keys($env) == list
 keys($env) == nil && true
+keys($env) | any(ok)
+keys($env) | count(ok)
 keys($env) | count(true)
+keys($env) | filter(true)
 keys($env) | find(false)
+keys($env) | findLast(true)
+keys($env) | findLastIndex(false)
 keys($env) | groupBy(#)
 keys($env) | groupBy($env?.i)
+keys($env) | groupBy(sum(#))
 keys($env) | map(#)
 keys($env) | map(1)
 keys($env) | map(1.0)
 keys($env) | map(add)
 keys($env) | map(f64)
+keys($env) | map(greet)
 keys($env) | map(str)
+keys($env) | none(false)
+keys($env) | one(false)
+keys($env) | one(ok)
+keys($env) | one(true)
 keys($env) | reduce(#)
+keys($env) | reduce(#index)
+keys($env) | reduce($env)
 keys($env) | reduce(1.0)
+keys($env) | reduce(f64, ok)
+keys($env) | reduce(greet, $env)
+keys($env) | reduce(i)
 keys($env) | reduce(ok)
+keys($env) | sortBy(#)
 keys($env) | sortBy(str)
 keys($env)?.[i]
 keys(array | reduce($env))
+keys(groupBy(array, #))
+keys(groupBy(array, 1))
+keys(groupBy(array, 1.0))
+keys(groupBy(array, false))
+keys(groupBy(array, foo))
 keys(groupBy(list, #))
+keys(groupBy(list, #.Bar))
 keys(groupBy(list, foo))
+keys(groupBy(list, ok))
+keys(if true { $env } else { str })
+keys(list | groupBy(#))
+keys(list | groupBy(1))
 keys(max($env))
 keys(min($env))
+keys(nil ?? $env)
 keys(reduce(list, $env))
 keys({foo: $env})
 keys({foo: 0})
 keys({foo: 1, foo: 0})
 keys({foo: 1, foo: false})
+keys({foo: 1, foo: i})
 keys({foo: 1.0})
 keys({foo: 1})
 keys({foo: add})
+keys({foo: array, foo: i})
 keys({foo: array})
 keys({foo: f64})
 keys({foo: false})
+keys({foo: foo, foo: $env?.f64})
 keys({foo: foo, foo: 0})
 keys({foo: foo, foo: 1.0})
+keys({foo: foo, foo: i})
 keys({foo: foo})
+keys({foo: greet, foo: $env})
 keys({foo: greet})
 keys({foo: i, foo: true})
 keys({foo: i})
+keys({foo: list})
+keys({foo: nil, foo: 0})
 keys({foo: nil})
+keys({foo: ok, foo: str})
 keys({foo: ok})
+keys({foo: str, foo: $env})
+keys({foo: str, foo: f64})
+keys({foo: str, foo: nil})
 keys({foo: str})
+keys({foo: true, foo: $env})
 keys({foo: true, foo: list})
 keys({foo: true})
+last($env ?? $env)
+last($env ?? $env.greet)
+last($env ?? 1)
+last($env ?? 1.0)
+last($env ?? false)
+last($env ?? foo)
+last($env ?? greet)
+last($env ?? i)
+last($env ?? nil)
+last($env ?? str)
 last($env | map(#index))
 last($env | map(1))
 last($env | map(add))
+last($env | map(array))
+last($env | map(f64))
 last($env | map(foo))
 last($env | map(greet))
+last($env | map(ok))
+last($env | reduce($env, add))
+last($env) != array
+last($env) != list
 last($env) == i
 last($env) == ok
 last($env) contains foo.Bar
+last($env) contains str
 last($env) in array
+last($env) matches foo?.Bar
 last($env) not contains foo.Bar
 last($env) not in array
+last($env) not matches str
+last($env) not startsWith str
 last($env) startsWith str
 last($env)?.Bar
 last($env)?.Bar()
+last($env)?.Bar()?.[f64]
 last($env)?.Bar()?.foo
+last($env)?.Bar()?.str()
 last($env)?.Bar(foobar)
+last($env)?.Bar?.[array]
 last($env)?.Bar?.[i]
 last($env)?.Bar?.greet
 last($env)?.String
 last($env)?.String()
 last($env)?.String().add
+last($env)?.String()?.ok
+last($env)?.String(foobar)
+last($env)?.String(greet)
+last($env)?.String?.[add]
+last($env)?.String?.[array]
 last($env)?.[add]
+last($env)?.[add].Bar
+last($env)?.[add]?.String
 last($env)?.[array]
+last($env)?.[array].foo
 last($env)?.[array].i
 last($env)?.[f64]
+last($env)?.[f64] == i
+last($env)?.[f64].add()
+last($env)?.[f64]?.[list]
 last($env)?.[f64]?.f64(foobar, greet)
 last($env)?.[f64]?.foo()
 last($env)?.[foo]
 last($env)?.[foo].Bar
+last($env)?.[foo].list
 last($env)?.[foo]?.foo
 last($env)?.[greet]
 last($env)?.[greet]?.[i]
 last($env)?.[greet]?.[ok]
+last($env)?.[greet]?.list
 last($env)?.[i]
 last($env)?.[list]
 last($env)?.[list].greet
+last($env)?.[list].ok
 last($env)?.[ok]
 last($env)?.[ok] != i
 last($env)?.[ok].ok()
 last($env)?.[str]
 last($env)?.[str]?.[foo]
 last($env)?.[str]?.i
+last($env)?.[str]?.ok
+last($env)?.[{foo: add}]
 last($env)?.add
 last($env)?.add()
 last($env)?.add(f64)
+last($env)?.add(foobar)
 last($env)?.add.add()
 last($env)?.add.i
 last($env)?.add?.[ok]
+last($env)?.add?.f64
 last($env)?.array
 last($env)?.array()
 last($env)?.array.list()
+last($env)?.array?.[add]
+last($env)?.array?.[greet]
 last($env)?.f64
+last($env)?.f64($env?.[String])
 last($env)?.f64()
+last($env)?.f64() == array
 last($env)?.f64(greet(foobar))
 last($env)?.f64(list)
 last($env)?.f64?.[list]
+last($env)?.f64?.greet
+last($env)?.false != 0
 last($env)?.findLast(foo, foobar)
 last($env)?.foo
 last($env)?.foo()
+last($env)?.foo()?.greet()
 last($env)?.foo(String, foobar?.greet)
+last($env)?.foo(add)
+last($env)?.foo.String
 last($env)?.foo?.[foo]
 last($env)?.foo?.[greet]
+last($env)?.foo?.array
+last($env)?.foobar
+last($env)?.foobar.str()
+last($env)?.foobar?.[str]
+last($env)?.foobar?.ok()
+last($env)?.fromPairs(foobar, foobar)
 last($env)?.greet
 last($env)?.greet()
+last($env)?.greet?.Bar
+last($env)?.greet?.[add]
+last($env)?.greet?.[foo].foo()
+last($env)?.greet?.array
 last($env)?.greet?.i
 last($env)?.i
 last($env)?.i()
+last($env)?.i(foobar endsWith add)
+last($env)?.i.Bar(foobar)
 last($env)?.i.foo
+last($env)?.i.foo(foobar, f64)
 last($env)?.i?.greet
 last($env)?.i?.i
+last($env)?.int(String)
+last($env)?.join(1.0)
 last($env)?.list
 last($env)?.list()
+last($env)?.list(foobar)
 last($env)?.list.array
+last($env)?.list?.[list]
 last($env)?.none(foobar)?.String()
 last($env)?.ok
 last($env)?.ok()
+last($env)?.ok?.add
 last($env)?.str
 last($env)?.str()
 last($env)?.str(foobar)
 last($env)?.str?.[list]
+last($env)?.str?.array?.[ok]
+last($env)?.str?.foo
 last($env)?.toJSON(str)
 last($env.array)
 last($env.list)
@@ -11081,13 +22698,19 @@ last($env?.Bar)
 last($env?.Bar)?.[add]
 last($env?.Bar)?.[f64]
 last($env?.Bar)?.[ok]
+last($env?.Bar)?.add
 last($env?.Bar)?.add()
 last($env?.Bar?.String)
 last($env?.Bar?.[list])
 last($env?.Bar?.[ok])
 last($env?.String)
+last($env?.String)?.[ok]
+last($env?.String)?.greet()
 last($env?.String?.[add])
+last($env?.String?.[f64])
 last($env?.[Bar])
+last($env?.[Bar])?.foo.add
+last($env?.[Bar]?.[foo])
 last($env?.[Bar]?.[str])
 last($env?.[Bar]?.array)
 last($env?.[String])
@@ -11095,7 +22718,9 @@ last($env?.[String])?.Bar
 last($env?.[String])?.[add]
 last($env?.[String])?.[foo]
 last($env?.[String]?.[foo])
+last($env?.[String]?.ok)
 last($env?.[foobar])
+last($env?.[foobar])?.String
 last($env?.[foobar])?.[f64]
 last($env?.[foobar])?.f64()
 last($env?.[foobar]?.str)
@@ -11103,6 +22728,7 @@ last($env?.[nil])
 last($env?.[str])
 last($env?.array)
 last($env?.false)
+last($env?.false)?.[greet]
 last($env?.foobar)
 last($env?.foobar)?.ok
 last($env?.foobar?.[greet])
@@ -11111,38 +22737,99 @@ last($env?.nil)
 last($env?.true)
 last(0 .. 0)
 last(0 .. 1)
+last(0 ?? 1.0)
+last(0 ?? false)
+last(0 ?? greet)
+last(0 ?? str)
+last(0 ?? true)
+last(0..i)
 last(1 .. 0)
 last(1 .. 1)
 last(1 .. i)
+last(1 ?? foo)
+last(1 ?? greet)
+last(1.0 ?? $env)
+last(1.0 ?? $env?.i)
+last(1.0 ?? 0)
+last(1.0 ?? array)
+last(1.0 ?? false)
+last(1.0 ?? foo)
+last(1.0 ?? greet)
+last(1.0 ?? true)
+last(1.0 | min(array))
 last([$env, true])
+last([$env.ok, array])
 last([$env])
 last([$env]).i
 last([0])
 last([1, 0])
+last([1, add])
 last([1, nil])
+last([1.0, str])
 last([1.0])
 last([1])
+last([add, $env])
+last([add, 1])
 last([add])
 last([array, 0])
+last([array, false])
 last([array])
 last([f64])
 last([false, 0])
+last([false, foo])
 last([false])
+last([foo, $env])
 last([foo, str])
 last([foo])
+last([greet, 1])
+last([greet, false])
+last([greet, nil])
 last([greet])
 last([i])
 last([list])
 last([nil])
 last([ok])
+last([str, $env])
 last([str])
+last([true, 1.0])
+last(add ?? 1)
+last(add ?? 1.0)
+last(add ?? foo)
+last(add ?? foo)?.add
+last(add ?? true)
+last(array ?? 0)
+last(array ?? 1)
+last(array ?? array)
+last(array ?? greet)
+last(array ?? i)
+last(array ?? nil)
+last(array ?? str)
+last(array | map(#))
 last(array | map(f64))
 last(array | map(false))
+last(array | map(foo))
+last(array | map(list))
+last(array | min(1.0))
 last(array | reduce(#acc))
+last(array | sortBy(1.0))
 last(array)
 last(array) != i
 last(array) % i
 last(array) >= i
+last(array) ?? -0
+last(array) ?? add
+last(array) in array != false
+last(array) | mean(1.0)
+last(array[:])
+last(array[:i])
+last(concat(array))
+last(concat(list))
+last(f64 ?? $env)
+last(f64 ?? add)?.f64()
+last(f64 ?? false)
+last(f64 ?? i)
+last(f64 ?? list)
+last(f64 ?? str)
 last(false ? $env : $env)
 last(false ? $env : greet)
 last(false ? add : greet)
@@ -11150,31 +22837,75 @@ last(false ? false : 1)
 last(false ? foo : greet)
 last(false ?: $env)
 last(false ?: add)
+last(false ?? $env?.f64)
+last(false ?? 1.0)
+last(false ?? array)?.list()
+last(false ?? str)
 last(filter($env, false))
 last(filter(array, true))
+last(filter(list, false))
 last(filter(list, true))
 last(first($env))
+last(first($env)?.[list])
+last(first({foo: greet}?.list))
 last(flatten(array))
 last(flatten(list))
+last(foo ?? $env)
+last(foo ?? $env.greet)
+last(foo ?? 0)
+last(foo ?? 1.0)
+last(foo ?? add)
+last(foo ?? add)?.[array]
+last(foo ?? array)
+last(foo ?? f64)
+last(foo ?? false)
+last(foo ?? greet)
+last(foo ?? i)
+last(foo ?? ok)
+last(foo ?? str)
+last(foo ?? true)
+last(greet ?? 1.0)
+last(greet ?? foo)
+last(greet ?? str)
+last(greet ?? true)
 last(groupBy(list, f64)?.[ok])
+last(i ?? $env)
+last(i ?? foo)
+last(i ?? ok)
+last(if false { $env } else { i })
+last(if false { nil } else { list })
+last(if ok { $env } else { 1 })
 last(if ok { false } else { $env })
 last(if ok { foo } else { true })
 last(if ok { list } else { $env })
+last(if ok { list } else { true })
 last(if true { $env } else { 1.0 })
 last(if true { 1.0 } else { 1 })
 last(if true { add } else { ok })
 last(if true { list } else { array })
+last(if true { ok } else { 1.0 })
 last(keys($env))
+last(keys($env)) | all(ok)
 last(last($env))
 last(last($env)?.[list])
+last(list ?? array)
+last(list ?? greet)
+last(list ?? true)
+last(list | map(#))
+last(list | map(#.Bar))
 last(list | map(foo))
 last(list | map(greet))
+last(list | map(list))
 last(list | map(ok))
 last(list | map(str))
 last(list | reduce(array))
+last(list | reduce(array, foo))
 last(list | sortBy(0))
 last(list)
+last(list) != $env != ok
 last(list) == foo
+last(list) ?? foo
+last(list) in list
 last(list).Bar
 last(list).String
 last(list).String()
@@ -11182,13 +22913,24 @@ last(list)?.Bar
 last(list)?.String
 last(list)?.String()
 last(list[1:])
+last(list[:1])
 last(map($env, $env))
+last(map($env, $env)).ok
+last(map($env, 1))
+last(map($env, 1.0))
 last(map($env, f64))
 last(map($env, foo))
+last(map($env, greet))
+last(map($env, str))
 last(map(array, #))
 last(map(array, false))
+last(map(array, foo))
+last(map(array, true))
 last(map(list, #))
+last(map(list, 1))
 last(map(list, 1.0))
+last(map(list, array))
+last(map(list, foo))
 last(map(list, i))
 last(max($env))
 last(max($env?.Bar))
@@ -11201,41 +22943,102 @@ last(min($env))
 last(min(array))
 last(min(array, 1.0))
 last(min(if true { $env } else { f64 }))
+last(nil ?? $env)
+last(nil ?? array)
+last(ok ? list : ok)
+last(ok ? true : list)
+last(ok ?? $env)
+last(ok ?? 1)
+last(ok ?? array)
+last(ok ?? foo)
+last(ok ?? i)
+last(ok ?? str)
 last(reduce(list, #acc))
+last(reduce(list, $env))
 last(reduce(list, list, foo))
 last(reverse(array))
 last(reverse(list))
 last(sort($env))
 last(sort(array))
+last(sortBy(array, #))
 last(sortBy(array, 0))
+last(sortBy(array, f64))
+last(sortBy(list, .Bar))
+last(sortBy(list, 1.0))
+last(sortBy(list, str))
+last(str ?? 0)
+last(str ?? false)
+last(str ?? foo)
+last(str ?? i)
 last(toPairs($env))
 last(true ? 1.0 : greet)
 last(true ? array : 0)
 last(true ? foo : array)
 last(true ? list : 1)
 last(true ? str : 1.0)
+last(true ? true : array)
+last(true ?: greet)
+last(true ?? 0)
+last(true ?? array)
+last(true ?? f64)
+last(true ?? foo)
+last(true ?? list)
 last(uniq(array))
 last(uniq(list))
 last(values($env))
+last({foo: $env}.str)
 last({foo: $env}?.foobar?.add)
 last({foo: f64, foo: str}.foo)
 last({foo: foo, foo: 1}?.[str])
 last({foo: foo}.greet)
+last({foo: ok, foo: foo}?.str)
+last({foo: str}?.f64)
+lastIndexOf(foo.Bar, str)
+lastIndexOf(foo?.Bar, str)
+lastIndexOf(str, false ? $env : str)
 lastIndexOf(str, str)
+lastIndexOf(str, str) ?? ok
+len($env ?? 0)
+len($env ?? 1)
+len($env ?? 1.0)
+len($env ?? add)
+len($env ?? false)
+len($env ?? foo)
+len($env ?? greet)
+len($env ?? list)
+len($env ?? nil)
+len($env ?? ok)
+len($env ?? str)
+len($env | filter(false))
 len($env | filter(ok))
+len($env | filter(true))
+len($env | get(str))
+len($env | map(0))
 len($env | map(1.0))
+len($env | map(false))
 len($env | map(foo))
 len($env | map(i))
 len($env | map(true))
+len($env | reduce(str, i))
 len($env) != f64
+len($env) * i
 len($env) ** int(f64)
 len($env) + i
+len($env) == $env || $env
+len($env) == add ?? false
+len($env) >= i
+len($env) ?? add
+len($env) ?? list
 len($env) ^ 1.0 < f64
 len($env) ^ max(f64)
 len($env) ^ min(f64)
+len($env) not in array
+len($env) | bitand(1)
+len($env.array | groupBy(1))
 len($env.array)
 len($env.list)
 len($env.str)
+len($env?.[str] | map(add))
 len($env?.[str])
 len($env?.array)
 len($env?.list)
@@ -11244,44 +23047,77 @@ len(0 .. 0)
 len(0 .. i)
 len(1 .. 0)
 len([$env, 1.0])
+len([$env, add])
 len([$env])
 len([0, str])
+len([0])
+len([1.0, false, f64])
 len([1.0])
 len([1])
 len([add, i])
 len([add])
+len([array, foo])
+len([array])
 len([f64, 0])
 len([f64])
 len([false])
+len([foo, 1.0])
 len([foo, 1])
+len([foo, array])
 len([foo, foo])
 len([foo, i])
 len([foo])
 len([greet])
+len([i, foo])
+len([i])
 len([list, f64])
 len([list])
+len([nil, 1])
 len([nil, foo, add])
 len([nil, nil])
 len([nil])
+len([ok, 1.0])
 len([ok])
+len([str, nil])
 len([str])
+len([true, list])
 len([true])
+len(array ?? 1)
+len(array ?? 1.0)
+len(array ?? array)
+len(array ?? greet)
+len(array ?? nil)
 len(array | filter(false))
+len(array | groupBy(#))
 len(array | groupBy(1))
+len(array | groupBy(1.0))
+len(array | groupBy(false))
 len(array | groupBy(true))
 len(array | map(#))
+len(array | map(1.0))
+len(array | map(array))
+len(array | map(f64))
+len(array | map(foo))
+len(array | reduce($env))
+len(array | reduce(array, 0))
 len(array | sortBy(#))
 len(array)
+len(array) % i
 len(array) * i
 len(array) - i
+len(array) .. i
 len(array) == nil && false
 len(array) > findIndex(list, true)
+len(array) | bitshr(1)
+len(array[0:])
 len(array[1:])
 len(array[:0])
 len(array[:1])
 len(array[:i])
 len(concat(array))
 len(concat(list))
+len(false ? array : list)
+len(false ?: str)
 len(filter($env, ok))
 len(flatten(array))
 len(flatten(list))
@@ -11290,63 +23126,126 @@ len(foo.Bar)
 len(foo.String())
 len(foo?.Bar)
 len(foo?.String())
+len(greet(foo?.Bar))
 len(greet(greet(str)))
 len(greet(str))
+len(groupBy(array, 0))
 len(groupBy(array, 1.0))
 len(groupBy(array, f64))
+len(groupBy(array, false))
 len(groupBy(array, foo))
 len(groupBy(array, i))
+len(groupBy(array, true))
 len(groupBy(list, #))
+len(groupBy(list, .Bar))
 len(groupBy(list, foo))
+len(groupBy(list, str))
+len(i .. 0)
 len(if true { str } else { nil })
 len(keys($env))
+len(let y = $env; y)
+len(list ?? $env)
+len(list ?? array)
+len(list ?? f64)
+len(list ?? foo)
+len(list ?? list)
+len(list ?? nil)
+len(list ?? ok)
+len(list ?? true)
 len(list | filter(false))
 len(list | filter(true))
 len(list | groupBy(#))
+len(list | groupBy(foo))
 len(list | groupBy(str))
+len(list | map(#))
 len(list | map(#.String))
 len(list | map($env))
 len(list | map(1))
 len(list | map(1.0))
+len(list | map(false))
+len(list | map(foo))
+len(list | map(list))
 len(list | map(str))
 len(list | reduce(#.Bar))
+len(list | reduce(.Bar))
 len(list)
 len(list) % i
 len(list) ** i
+len(list) < 1 and true
+len(list) < i
+len(list) <= i
 len(list) == f64
 len(list) > i
 len(list) ^ f64
+len(list) in $env?.array
 len(list)..i
+len(list[:0])
+len(list[:1])
 len(list[:])
 len(lower(str))
+len(map($env, #index))
 len(map($env, 1))
 len(map($env, 1.0))
+len(map($env, add))
 len(map($env, array))
 len(map($env, f64))
 len(map($env, foo))
+len(map($env, greet))
+len(map($env, i))
+len(map($env, list))
 len(map($env, str))
 len(map(array, #))
 len(map(array, $env))
 len(map(array, 1))
 len(map(array, foo))
+len(map(array, list))
 len(map(list, #))
+len(map(list, #.String))
+len(map(list, #index))
+len(map(list, add))
 len(map(list, f64))
+len(map(list, true))
 len(max($env))
 len(min($env))
+len(nil ?? array)
+len(nil ?? str)
+len(ok ? list : $env)
+len(reduce($env, $env, 1))
+len(reduce($env, array, 0))
 len(reduce(array, $env))
 len(reduce(array, array))
 len(reduce(list, $env, foo))
+len(reduce(list, list))
+len(reduce(list, str, f64))
 len(reverse(array))
+len(reverse(list))
 len(sort($env))
+len(sort(array))
 len(sortBy(list, #.Bar))
 len(sortBy(list, .Bar))
 len(sortBy(list, 1))
+len(sortBy(list, i))
+len(sortBy(list, str))
+len(str ?? $env)
+len(str ?? 1.0)
+len(str ?? greet)
+len(str ?? i)
+len(str ?? list)
+len(str ?? nil)
+len(str ?? ok)
+len(str ?? true)
+len(str | trimSuffix(str))
 len(str)
+len(str) * i
 len(str) + 1.0 - i
 len(str) .. 0 | find($env)
 len(str) .. i
+len(str) / f64 ^ f64
+len(str) <= i
 len(str) == i
 len(str) >= f64
+len(str) ?? add
+len(str) ^ f64
 len(str) | bitnand(1)
 len(str) | bitor(1)
 len(str) | mean(i)
@@ -11356,9 +23255,12 @@ len(str[0:])
 len(str[1:])
 len(str[:1])
 len(string($env))
+len(string(0))
 len(string(1))
 len(string(1.0))
+len(string(add))
 len(string(array))
+len(string(f64))
 len(string(false))
 len(string(foo))
 len(string(greet))
@@ -11366,15 +23268,23 @@ len(string(i))
 len(string(list))
 len(string(nil))
 len(string(ok))
+len(string(str))
+len(string(true))
 len(toBase64(str))
+len(toJSON($env.ok))
 len(toJSON(0))
 len(toJSON(1))
+len(toJSON(1.0))
+len(toJSON(array))
+len(toJSON(f64))
 len(toJSON(false))
 len(toJSON(foo))
+len(toJSON(i))
 len(toJSON(list))
 len(toJSON(nil))
 len(toJSON(ok))
 len(toJSON(str))
+len(toJSON(true != false))
 len(toJSON(true))
 len(toPairs($env))
 len(trim(str))
@@ -11386,44 +23296,101 @@ len(type(1))
 len(type(1.0))
 len(type(add))
 len(type(array))
+len(type(f64))
+len(type(false))
 len(type(foo))
 len(type(greet))
 len(type(i))
 len(type(list))
 len(type(nil))
+len(type(ok))
 len(type(str))
 len(type(true))
 len(uniq(array))
 len(uniq(list))
 len(upper(str))
 len(values($env))
+len({foo: $env ?? $env})
 len({foo: $env, foo: $env})
+len({foo: $env, foo: 0})
+len({foo: $env, foo: 1.0})
+len({foo: $env, foo: true})
 len({foo: $env})
+len({foo: 0, foo: nil})
+len({foo: 0, foo: str, foo: str})
 len({foo: 0})
 len({foo: 1, foo: false})
+len({foo: 1, foo: nil})
 len({foo: 1.0, foo: f64})
 len({foo: 1.0})
 len({foo: 1})
 len({foo: add})
 len({foo: array, foo: 1.0})
+len({foo: array, foo: greet})
 len({foo: array, foo: str})
 len({foo: array})
 len({foo: f64})
 len({foo: false})
+len({foo: foo, foo: $env})
 len({foo: foo, foo: 1.0})
 len({foo: foo, foo: foo})
 len({foo: foo, foo: nil})
+len({foo: foo, foo: ok})
 len({foo: foo})
 len({foo: greet, foo: str})
+len({foo: greet})
 len({foo: i, foo: $env})
 len({foo: i})
+len({foo: list, foo: foo})
 len({foo: list})
+len({foo: nil, foo: 1.0})
+len({foo: nil, foo: add})
+len({foo: nil, foo: array})
 len({foo: nil})
 len({foo: ok, foo: $env})
 len({foo: ok})
+len({foo: str, foo: $env})
+len({foo: str, foo: f64, foo: f64})
+len({foo: str, foo: greet})
 len({foo: str, foo: str})
 len({foo: str})
 len({foo: true})
+let bar = $env == f64; bar
+let bar = $env.f64; bar
+let bar = $env.str; bar
+let bar = $env; bar.array
+let bar = $env; bar.foo
+let bar = $env?.list; bar
+let bar = 0 == $env; bar
+let bar = 1 == $env; bar
+let bar = [1.0]; bar
+let bar = add; bar
+let bar = array == list; bar
+let bar = array ?? foo; bar
+let bar = array; bar
+let bar = f64; bar
+let bar = f64; bar + f64
+let bar = f64; let tmp = add; bar
+let bar = foo ?? f64; bar
+let bar = foo.Bar; bar
+let bar = foo.Bar; let x = add; bar
+let bar = foo.String(); bar
+let bar = foo; bar
+let bar = foo; bar.String
+let bar = greet ?? i; bar
+let bar = greet; bar
+let bar = i; bar
+let bar = i; let z = !ok; bar
+let bar = list; bar
+let bar = list; let foobar = greet; bar
+let bar = list[1:]; bar
+let bar = nil != add; bar
+let bar = ok == true; bar
+let bar = ok; bar
+let bar = str; bar
+let bar = str; let foobar = greet; bar
+let bar = string($env); bar
+let bar = type(f64); bar
 let foobar = $env not in array; foobar
 let foobar = $env.f64; i < foobar
 let foobar = $env.list; foobar
@@ -11432,7 +23399,9 @@ let foobar = $env; foobar == foobar
 let foobar = $env; foobar.Bar
 let foobar = $env; foobar.String
 let foobar = $env; foobar.add
+let foobar = $env; foobar.foo
 let foobar = $env; foobar.greet
+let foobar = $env; foobar.list
 let foobar = $env; foobar.ok
 let foobar = $env; foobar.str
 let foobar = $env; foobar?.[str]
@@ -11442,15 +23411,21 @@ let foobar = $env; foobar?.greet
 let foobar = $env; foobar?.i
 let foobar = $env; foobar?.list
 let foobar = $env; foobar?.str
+let foobar = $env?.Bar; foobar
+let foobar = $env?.String; foobar
 let foobar = $env?.[Bar]; foobar?.list
 let foobar = $env?.[String]; foobar
 let foobar = $env?.[String]; foobar?.[str]
+let foobar = $env?.[str]; foobar
 let foobar = $env?.f64; foobar > foobar
+let foobar = $env?.true; foobar
 let foobar = 0 + f64; foobar
+let foobar = 0; foobar != foobar
 let foobar = 0; foobar <= foobar
 let foobar = 1 * 1.0; foobar
 let foobar = 1.0 != 1.0; foobar
 let foobar = 1.0; foobar * foobar
+let foobar = 1; foobar != f64
 let foobar = 1; foobar % foobar
 let foobar = 1; foobar < float(foobar)
 let foobar = add; $env != foobar
@@ -11459,12 +23434,16 @@ let foobar = array | sortBy(1.0); foobar
 let foobar = array; foobar
 let foobar = array; foobar?.[0]
 let foobar = array; foobar?.[i]
+let foobar = array; let bar = foobar; foobar
 let foobar = array?.[i]; f64 + foobar
+let foobar = f64 ?? nil; foobar
 let foobar = f64; foobar
 let foobar = f64; foobar ** f64
 let foobar = f64; foobar + foobar
 let foobar = f64; foobar == foobar
 let foobar = false; foobar != foobar
+let foobar = false; foobar == $env and foobar
+let foobar = flatten(list); foobar
 let foobar = foo != nil; foobar || false
 let foobar = foo; foobar
 let foobar = foo; foobar.Bar
@@ -11473,24 +23452,32 @@ let foobar = foo; foobar?.String
 let foobar = foo?.Bar; foobar
 let foobar = foo?.String; foobar
 let foobar = greet; foobar
+let foobar = greet; let z = foobar; foobar
 let foobar = greet; {foo: foobar}
 let foobar = i <= i; foobar
 let foobar = i; 1.0 == foobar
+let foobar = i; floor(foobar) + foobar
 let foobar = i; foobar
 let foobar = i; foobar != 0
+let foobar = i; foobar % foobar
 let foobar = i; foobar ** foobar / foobar
+let foobar = i; foobar + foobar
 let foobar = i; foobar == f64
 let foobar = i; foobar ^ foobar
 let foobar = i; {foo: foobar, foo: nil}
 let foobar = last(array); foobar
+let foobar = len(array); foobar
 let foobar = list; foobar
 let foobar = list; foobar != list
 let foobar = list; foobar?.[i]
 let foobar = list; reduce(foobar, foobar, $env)
 let foobar = map($env, 1); foobar
+let foobar = nil != nil; foobar
+let foobar = not true; foobar
 let foobar = ok ? nil : $env; foobar?.Bar
 let foobar = ok; foobar
 let foobar = ok; foobar == foobar
+let foobar = ok; let bar = foo; foobar
 let foobar = str != $env; foobar
 let foobar = str != nil; foobar
 let foobar = str; foobar
@@ -11499,9 +23486,123 @@ let foobar = sum(array); foobar
 let foobar = toPairs($env); foobar
 let foobar = trimSuffix(str); foobar
 let foobar = {foo: 0}; foobar.ok
+let foobar = {foo: nil}; foobar
+let tmp = $env.add; tmp
+let tmp = $env; tmp.greet
+let tmp = $env; tmp.str
+let tmp = $env?.array; tmp
+let tmp = 1.0 < 1; tmp
+let tmp = [$env]; tmp
+let tmp = add; tmp
+let tmp = array; tmp
+let tmp = f64 ?? $env; tmp
+let tmp = f64; tmp
+let tmp = foo; let y = foo; tmp
+let tmp = foo; tmp
+let tmp = greet; tmp
+let tmp = i; tmp
+let tmp = list; tmp
+let tmp = min(i, f64); tmp
+let tmp = ok; let y = foo; tmp
+let tmp = ok; tmp
+let tmp = str endsWith $env?.String; tmp
+let tmp = str; tmp
+let x = $env != true; x
+let x = $env; let tmp = 1.0; x?.ok
+let x = $env; x.add
+let x = $env; x.str
+let x = $env; x?.add
+let x = $env; x?.f64
+let x = $env; x?.str
+let x = $env?.[foobar]; x
+let x = add; x
+let x = array; x
+let x = f64; x
+let x = foo.Bar; x
+let x = foo; x
+let x = foo; x.Bar
+let x = foo; x?.String
+let x = greet; x
+let x = i; let y = ok; x
+let x = i; x
+let x = list; let bar = foo; x
+let x = list; x
+let x = ok and $env; x
+let x = ok; x
+let x = str; x
+let x = trimSuffix(str); x
+let x = {foo: 1.0}; x
+let y = $env ?? $env; y
+let y = $env.array; y
+let y = $env; let tmp = i; y?.[str]
+let y = $env; y.greet
+let y = $env; y.list
+let y = $env; y?.String
+let y = $env; y?.add
+let y = $env; y?.greet
+let y = $env?.[String]; y
+let y = $env?.add; y
+let y = -1.0; y
+let y = 1.0 * i; y
+let y = add; y
+let y = array; y
+let y = concat(list); y
+let y = f64; y
+let y = false != ok; y
+let y = findLastIndex($env, true); y
+let y = foo.Bar; y
+let y = foo; y
+let y = foo?.String; y
+let y = greet; y
+let y = i; let bar = foo; y
+let y = i; y
+let y = list; y
+let y = nil ?? false; y
+let y = not false; y
+let y = ok; y
+let y = sort($env); y
+let y = str; y
+let z = $env != nil; z
+let z = $env == greet; z
+let z = $env.i; z
+let z = $env.ok; z
+let z = $env; z.Bar
+let z = $env; z.String
+let z = $env; z.array
+let z = $env; z.f64
+let z = $env; z.greet
+let z = $env; z?.greet
+let z = $env?.ok; z
+let z = [foo]; z
+let z = add; z
+let z = array == list; z
+let z = array; z
+let z = array; z | groupBy(foo)
+let z = f64 != $env; z
+let z = f64; z
+let z = foo.String; z
+let z = foo; z
+let z = greet; z
+let z = i; z
+let z = list; let x = f64; z
+let z = list; z
+let z = map($env, add); z
+let z = ok or true; z
+let z = ok; z
+let z = str != $env; z
+let z = str; let tmp = array; z
+let z = str; z
+let z = {foo: ok, foo: nil}; z
 list
 list != $env != false
+list != $env != nil
+list != $env && ok
 list != $env ? list : i
+list != $env ?? $env?.add
+list != $env ?? 1
+list != $env ?? f64
+list != $env ?? i
+list != $env and ok
 list != $env or 1.0 > f64
 list != $env or false
 list != $env or ok
@@ -11510,39 +23611,79 @@ list != $env.list
 list != $env?.Bar
 list != $env?.String
 list != $env?.[Bar]
+list != $env?.[Bar]?.list
 list != $env?.[String]
+list != $env?.[foobar?.[foo]]
+list != $env?.[foobar]
 list != $env?.[str]
 list != $env?.array
 list != $env?.foobar
 list != $env?.list
 list != $env?.nil
+list != 0 ?? ok
+list != 1 ?? false
+list != 1..i
+list != 1.0 ?? add
+list != 1.0 ?? foo
 list != [0]
+list != [foo]
+list != [nil]
+list != [str]
 list != array
 list != array and ok
+list != array or $env
 list != array or false
 list != array || $env
+list != false ?? foo
 list != flatten(list)
+list != foo ?? f64
+list != foo ?? ok
+list != foo ?? true
+list != greet ?? list
 list != i .. i
+list != i ?? foo
 list != keys($env)
 list != list
 list != list != ok
+list != list && $env
 list != list && true
+list != list == false
+list != list ?? 0
+list != list ?? date(list)
+list != list ?? greet
 list != list and false
+list != list or false
+list != map(list, #)
 list != map(list, str)
+list != max($env)
+list != median(array)
 list != min(array)
+list != nil ? 1.0 : f64
 list != nil ? ok : 1.0
 list != nil ?: list
+list != nil ?? nil
 list != nil || false
+list != nil || true
+list != ok ?? 1.0
 list != reverse($env.list)
 list != reverse(array)
+list != str ?? ok
+list != true ?? str
 list == $env == nil
 list == $env == ok
+list == $env == true
+list == $env ? foo : i
+list == $env ?: list == nil
+list == $env ?? 0
+list == $env ?? f64
+list == $env ?? i
 list == $env and false
 list == $env || $env
 list == $env.array
 list == $env.list
 list == $env?.$env
 list == $env?.Bar
+list == $env?.Bar?.add
 list == $env?.String
 list == $env?.[Bar]
 list == $env?.[String]
@@ -11555,187 +23696,605 @@ list == $env?.array
 list == $env?.foobar
 list == $env?.list
 list == 0 .. 1
+list == 0 ?? foo
+list == 1 ?? add
+list == 1.0 ?? $env
+list == 1.0 ?? $env && $env
+list == 1.0 ?? greet
+list == 1.0 ?? str
+list == [$env]
 list == [0]
+list == [add]
 list == [false]
 list == [foo]
 list == [greet, 0]
+list == [greet]
 list == [list]
 list == [nil]
 list == [str]
+list == [true]
+list == add ?? array
+list == add ?? false
 list == array
+list == array == $env == true
+list == array == nil
 list == array ? nil : foo
 list == array ?: list
 list == array or ok
 list == array[:i]
+list == concat(array)
+list == f64 ?? $env ?? 1.0
+list == false ?? greet
 list == flatten(array)
+list == foo ?? true
+list == i ?? f64
 list == keys($env)
 list == list
+list == list != $env
+list == list != nil
+list == list == true
 list == list and true
+list == list[:i]
 list == map($env, str)
+list == map(list, $env)
+list == nil != false
 list == nil && false
 list == nil == nil
 list == nil ? add : $env
+list == nil ?: $env
+list == nil ?: nil
 list == nil or $env
+list == ok ?? greet
+list == ok ?? str
 list == reverse(array)
+list == str ?? array
 list == toPairs($env)
 list == values($env)
+list ?? !$env
+list ?? !false
+list ?? !true
+list ?? $env ?? $env
+list ?? $env ?? add
+list ?? $env ?? nil
+list ?? $env | count(ok)
+list ?? $env | filter(true)
+list ?? $env | findIndex(false)
+list ?? $env | findLast(false)
+list ?? $env | groupBy(1)
+list ?? $env | map(0)
+list ?? $env | reduce(#)
+list ?? $env | reduce($env)
+list ?? $env | reduce(.String)
+list ?? $env | reduce(ok)
+list ?? $env | sortBy(1)
+list ?? $env.add
+list ?? $env.array
+list ?? $env.f64
+list ?? $env.foo
+list ?? $env.greet
+list ?? $env.i
+list ?? $env.list
+list ?? $env.ok
+list ?? $env.str
+list ?? $env?.Bar
+list ?? $env?.Bar()
+list ?? $env?.Bar()?.[list]
+list ?? $env?.String
+list ?? $env?.String()
+list ?? $env?.String(foobar)?.ok()
+list ?? $env?.String(ok | filter(String))
+list ?? $env?.[$env]
+list ?? $env?.[Bar]
+list ?? $env?.[Bar].foo()
+list ?? $env?.[Bar]?.[array]
+list ?? $env?.[String]
+list ?? $env?.[add]
+list ?? $env?.[add].Bar
+list ?? $env?.[array]
+list ?? $env?.[f64]
+list ?? $env?.[f64]?.add()
+list ?? $env?.[foo]
+list ?? $env?.[foobar | keys(foobar)]
+list ?? $env?.[foobar]
+list ?? $env?.[greet]
+list ?? $env?.[i]
+list ?? $env?.[list]
+list ?? $env?.[list]?.[ok]
+list ?? $env?.[list]?.i()?.String
+list ?? $env?.[ok]
+list ?? $env?.[ok][add:foobar]
+list ?? $env?.[str]
+list ?? $env?.[true]
+list ?? $env?.add
+list ?? $env?.array
+list ?? $env?.f64
+list ?? $env?.foo
+list ?? $env?.foobar
+list ?? $env?.greet
+list ?? $env?.i
+list ?? $env?.list
+list ?? $env?.nil
+list ?? $env?.ok
+list ?? $env?.str
+list ?? $env[:count(1.0)]
+list ?? $env[:foo.foo]
+list ?? $env[:str(nil)]
+list ?? $env[foobar:]
+list ?? -$env?.[nil]
+list ?? --1.0
+list ?? -f64
+list ?? 0 ?? $env
+list ?? 0 ?? array
+list ?? 0 | map(foo)
+list ?? 0 | none(true)
+list ?? 0 | sortBy(0)
+list ?? 0 | sortBy(str)
+list ?? 1 | groupBy(foo)
+list ?? 1 | map(1.0)
+list ?? 1.0
+list ?? 1.0 ?? foo
+list ?? 1.0 | count(true)
+list ?? 1.0 | groupBy(0)
+list ?? 1.0 | groupBy(str)
+list ?? 1.0 | map(0)
+list ?? 1.0 | one(true)
+list ?? 1.0 | reduce(.Bar)
+list ?? [array]
+list ?? [list]
+list ?? [ok]
+list ?? [str]
+list ?? abs($env).greet
+list ?? add
+list ?? add | groupBy(#)
+list ?? add | groupBy(ok)
+list ?? add | reduce(1.0)
+list ?? add | sum(0)
+list ?? any($env, #)
+list ?? any($env, $env)
+list ?? array
+list ?? array ?? $env?.[greet]
+list ?? array | reduce($env)
+list ?? array?.[i]
+list ?? bitnot($env)
+list ?? bitshr($env, $env)
+list ?? ceil($env)
+list ?? count($env)
+list ?? count(array)
+list ?? count(foo ?? $env)
+list ?? date(greet)
+list ?? date(list)
+list ?? date(nil)
+list ?? f64
+list ?? f64 ?? str
+list ?? f64 | count(true)
+list ?? f64 | groupBy(foo)
+list ?? f64 | map(#)
+list ?? f64 | map(ok)
+list ?? f64 | reduce(#, i)
+list ?? f64 | reduce(#acc, $env)
+list ?? false ?? greet
+list ?? false | filter(ok)
+list ?? false | find(true)
+list ?? false | map(1.0)
+list ?? false | map(false)
+list ?? false | map(foo)
+list ?? false | reduce(i)
+list ?? false | sortBy(1)
+list ?? filter(list, false)
+list ?? find($env, .add)
+list ?? find(array, ok)
+list ?? findIndex($env, .i)
+list ?? findLast($env, #)
+list ?? findLastIndex($env, #.ok)
+list ?? flatten($env)
+list ?? float(1.0)
+list ?? foo
+list ?? foo ?? foo
+list ?? foo ?? sortBy($env, 0)
+list ?? foo | all(false)
+list ?? foo | any(true)
+list ?? foo | findIndex(ok)
+list ?? foo | groupBy(i)
+list ?? foo | map(#)
+list ?? foo | map(#index)
+list ?? foo | map(ok)
+list ?? foo | reduce(#)
+list ?? foo | reduce(#) ?? foo
+list ?? foo | reduce($env)
+list ?? foo | reduce(1.0)
+list ?? foo | sum(0)
+list ?? foo | sum(1)
+list ?? foo.Bar
+list ?? foo.String
+list ?? foo.String()
+list ?? foo?.Bar
+list ?? foo?.String
+list ?? foo?.String()
+list ?? fromBase64($env)
+list ?? greet
+list ?? greet ?? list
+list ?? greet | all(false)
+list ?? greet | any(true)
+list ?? greet | findLastIndex(true)
+list ?? greet | map(#)
+list ?? greet | map(1)
+list ?? greet | reduce(foo, foo)
+list ?? greet | sum(1.0)
+list ?? greet($env)
+list ?? greet(str)
+list ?? i
+list ?? i | groupBy(1.0)
+list ?? i | groupBy(false)
+list ?? i | reduce($env)
+list ?? i | reduce(.Bar)
+list ?? int($env)
+list ?? len($env)
+list ?? list
+list ?? list | one(true)
+list ?? list | sum(1)
+list ?? map($env, $env)
+list ?? max($env)
+list ?? max(1, $env)?.list
+list ?? max(list)
+list ?? mean(1.0)
+list ?? mean(array)
+list ?? mean(i)
+list ?? median($env)
+list ?? min(f64)
+list ?? nil ?? str
+list ?? nil | all(true)
+list ?? nil | count(ok)
+list ?? nil | groupBy(#)
+list ?? nil | groupBy(1.0)
+list ?? nil | groupBy(foo)
+list ?? nil | map(#)
+list ?? nil | map(#index)
+list ?? nil | reduce(str)
+list ?? nil | reduce(true)
+list ?? nil | sortBy(f64)
+list ?? nil | sum(0)
+list ?? not $env
+list ?? not $env?.[array]
+list ?? not foo ?? str
+list ?? ok
+list ?? ok ?? 0
+list ?? ok ?? false
+list ?? ok ?? i
+list ?? ok | all(true)
+list ?? ok | findLastIndex(ok)
+list ?? ok | map(#)
+list ?? ok | none(true)
+list ?? ok | reduce(list)
+list ?? ok | sortBy(str)
+list ?? ok | sum(i)
+list ?? one($env, #.Bar)
+list ?? reduce($env, #.String, add)
+list ?? reduce($env?.String(false, 1.0), #.foo[str:])
+list ?? repeat($env, i)
+list ?? reverse($env)
+list ?? reverse(list)
+list ?? round($env)
+list ?? sortBy($env, .add)
+list ?? str
+list ?? str | any(true)
+list ?? str | findLast(true)
+list ?? str | map(foo)
+list ?? str | reduce(#)
+list ?? str | reduce(1.0)
+list ?? string($env)
+list ?? string(1)
+list ?? string(i)
+list ?? string(nil)
+list ?? sum($env)
+list ?? sum($env)?.[add]
+list ?? sum(array)
+list ?? sum(array, $env)
+list ?? sum(list)
+list ?? sum(list, add)
+list ?? toJSON(add)
+list ?? true ?? $env?.array
+list ?? true | count(false)
+list ?? true | groupBy(#)
+list ?? true | map(#)
+list ?? true | map(str)
+list ?? true | reduce(#)
+list ?? type(1)
+list ?? type(nil)
+list ?? upper($env)
+list ?? {foo: 1.0}
+list ?? {foo: 1}
+list ?? {foo: add}
 list in $env?.Bar
 list in $env?.String
+list in $env?.String?.[foo]
 list in $env?.String?.f64
 list in $env?.[Bar]
+list in $env?.[Bar]?.Bar
 list in $env?.[Bar]?.[array]
 list in $env?.[String]
+list in $env?.[String]?.[ok]
+list in $env?.[String]?.[str]
+list in $env?.[foobar?.[Bar]]
 list in $env?.[foobar]
 list in $env?.foobar
 list in [$env, 1.0]
 list in [$env, nil]
+list in [array]
 list in [nil, $env]
+list in [nil]
+list in array ?? $env
+list in array ?? i
 list in concat(list)
 list in last($env)
+list in sort($env)
+list in {foo: 0}.array
+list not in $env?.$env?.list
 list not in $env?.Bar
 list not in $env?.String
 list not in $env?.String?.[add]
 list not in $env?.String?.add
 list not in $env?.[Bar]
 list not in $env?.[String]
+list not in $env?.[foobar?.[ok]]
+list not in $env?.[foobar]
 list not in $env?.foobar
 list not in [array, true]
+list not in [list]
+list not in array ?? 1
+list not in last($env)
+list not in list ?? $env?.[f64]
+list not in list ?? array
+list not in list ?? i
 list not in toPairs($env)
+list | all(!true)
+list | all(# != $env)
 list | all(# == nil)
 list | all($env | any(true))
+list | all($env?.ok)
 list | all(.Bar not in #)
 list | all(0 == nil)
 list | all(1.0 != f64)
 list | all(false && $env)
+list | all(false or false)
 list | all(false)
 list | all(false) ?: f64
+list | all(foo != #)
 list | all(list != array)
+list | all(nil != 1.0)
 list | all(ok)
+list | all(ok) ?? f64
+list | all(str >= .Bar)
 list | all(true)
+list | any(# == $env)
 list | any($env != #)
 list | any($env != 1.0)
 list | any($env == $env)
+list | any($env == foo)
+list | any($env.ok)
+list | any($env?.ok)
 list | any(.Bar in foo)
+list | any(array | any(ok))
+list | any(f64 != 1.0)
 list | any(false)
+list | any(false) ?? list
+list | any(i == nil)
+list | any(i >= 1.0)
 list | any(nil == i)
 list | any(ok != nil)
 list | any(ok)
 list | any(true ?: nil)
 list | any(true)
 list | concat(array)
+list | concat(array) ?? i
+list | concat(i .. i)
 list | concat(list)
+list | concat(list) | any(true)
+list | concat(sortBy(array, #))
+list | count(!false)
 list | count(# != nil)
+list | count($env != foo)
 list | count($env == #)
+list | count($env.ok)
 list | count(1.0 != $env)
 list | count(1.0 != nil)
+list | count(1.0 <= i)
 list | count(false)
 list | count(false) | bitxor(i)
+list | count(nil != ok)
 list | count(ok)
+list | count(ok) ?? $env?.String?.Bar
+list | count(ok) | median(f64)
 list | count(true != true)
 list | count(true and false)
+list | count(true or false)
 list | count(true)
+list | filter(!ok)
+list | filter(# != $env)
 list | filter(# == #)
+list | filter(#.String != nil)
+list | filter($env != false)
+list | filter($env.ok)
+list | filter(0 <= 1)
+list | filter(1.0 > 0)
 list | filter(false)
+list | filter(false) | find(true)
+list | filter(false) | findLast(true)
+list | filter(false) | map(1.0)
 list | filter(i <= 1)
 list | filter(list == $env)
 list | filter(nil != #.String)
+list | filter(nil == foo)
+list | filter(not false)
 list | filter(ok == nil)
 list | filter(ok)
+list | filter(ok) | reduce(1.0)
 list | filter(ok) | sum(1.0)
 list | filter(str not startsWith .Bar)
 list | filter(true)
+list | filter(true) ?? !$env
+list | filter(true) | groupBy(foo)
 list | filter(true) | groupBy(ok)
+list | filter(true) | map(#)
 list | filter(true) | sum(1.0)
 list | find(# != $env)
 list | find(# == #)
 list | find(# == $env)
+list | find($env != i)
 list | find(0 < 0)
 list | find(1.0 > 0)
 list | find(array | one(true))
+list | find(f64 == 0)
 list | find(f64 > 1.0)
 list | find(false)
 list | find(foo == #)
+list | find(foo == $env)
 list | find(foo == foo)
 list | find(nil != $env?.f64)
 list | find(nil != foo)
 list | find(nil == foo)
+list | find(not ok)
 list | find(ok)
 list | find(true)
+list | findIndex(!ok)
 list | findIndex(# != #)
 list | findIndex(# != foo)
+list | findIndex(#.Bar in #)
+list | findIndex(#.String != $env)
+list | findIndex($env.ok)
+list | findIndex(1.0 >= 1)
 list | findIndex(false && $env)
 list | findIndex(false)
+list | findIndex(list != nil)
+list | findIndex(nil != greet)
 list | findIndex(nil == .Bar)
+list | findIndex(nil not in $env)
 list | findIndex(ok == true)
 list | findIndex(ok)
+list | findIndex(ok) ?? foo
+list | findIndex(ok) not in array
 list | findIndex(true == ok)
 list | findIndex(true)
+list | findLast(# == #)
 list | findLast($env == $env)
 list | findLast($env == 0)
 list | findLast($env.ok)
 list | findLast(.Bar in foo)
+list | findLast(0 > 1.0)
 list | findLast(1.0 <= 1)
 list | findLast(f64 < 0)
 list | findLast(false)
 list | findLast(nil != str)
+list | findLast(not false)
+list | findLast(ok ?? .String)
 list | findLast(ok)
+list | findLast(ok) ?? foo
 list | findLast(true)
+list | findLastIndex(!false)
+list | findLastIndex(!true)
 list | findLastIndex(# == #)
 list | findLastIndex(# == $env)
+list | findLastIndex(#.Bar == #.Bar)
 list | findLastIndex($env != nil)
+list | findLastIndex(all(array, true))
 list | findLastIndex(array == $env)
 list | findLastIndex(false or true)
 list | findLastIndex(false)
 list | findLastIndex(foo == #)
 list | findLastIndex(greet != $env)
+list | findLastIndex(i <= 0)
 list | findLastIndex(nil not in list)
 list | findLastIndex(ok)
 list | findLastIndex(true)
 list | get(0)
 list | get(1)
+list | get(1.0 ?? $env)
 list | get(i)
+list | groupBy(# != #)
 list | groupBy(# != nil)
+list | groupBy(# == #)
+list | groupBy(# == nil)
+list | groupBy(# in list)
 list | groupBy(#)
 list | groupBy(#.Bar)
+list | groupBy(#.String())
+list | groupBy($env != #)
+list | groupBy($env != 0)
+list | groupBy($env == 0)
+list | groupBy($env.f64)
+list | groupBy($env.i)
+list | groupBy($env.ok)
+list | groupBy($env?.Bar)
+list | groupBy($env?.String)
 list | groupBy($env?.f64)
+list | groupBy($env?.i)
+list | groupBy(-0)
 list | groupBy(.Bar)
 list | groupBy(0 > i)
+list | groupBy(0 ?? $env)
 list | groupBy(0)
+list | groupBy(1 ** 1.0)
 list | groupBy(1 / 1.0)
 list | groupBy(1)
+list | groupBy(1.0 != $env)
+list | groupBy(1.0 + i)
+list | groupBy(1.0 <= 1.0)
 list | groupBy(1.0 >= 1.0)
 list | groupBy(1.0 in array)
 list | groupBy(1.0)
 list | groupBy(f64 + 1)
 list | groupBy(f64)
 list | groupBy(false && $env)
+list | groupBy(false ?? #)
 list | groupBy(false)
 list | groupBy(foo)
+list | groupBy(foo.Bar)
+list | groupBy(greet(.Bar))
 list | groupBy(i)
 list | groupBy(i) | get(true)
+list | groupBy(let foobar = true; foobar)
 list | groupBy(list?.[i])
+list | groupBy(mean(f64))
+list | groupBy(nil != #)
+list | groupBy(nil != $env)
 list | groupBy(ok)
 list | groupBy(ok) | get(str)
 list | groupBy(str)
 list | groupBy(string(#))
 list | groupBy(string(str))
 list | groupBy(toJSON(array))
+list | groupBy(toJSON(foo))
 list | groupBy(true && ok)
 list | groupBy(true && true)
 list | groupBy(true)
+list | groupBy(type(#))
+list | groupBy(type(#?.Bar))
+list | groupBy(type(1.0))
 list | map(# != foo)
+list | map(# != nil)
+list | map(# == #)
 list | map(#)
 list | map(#) == array
 list | map(#) | all(true)
 list | map(#) | findIndex(false)
 list | map(#) | get(0)
+list | map(#) | groupBy(#)
+list | map(#) | groupBy(foo)
 list | map(#) | map(#)
+list | map(#) | map(#.Bar)
+list | map(#) | map(foo)
+list | map(#) | map(greet)
+list | map(#) | none(ok)
 list | map(#) | one(false)
 list | map(#) | reduce(#)
 list | map(#.Bar)
 list | map(#.Bar) | reduce(#, nil)
+list | map(#.Bar) | sortBy(#)
 list | map(#.String())
 list | map(#.String)
+list | map(#.String) | reduce(#)
+list | map(#?.Bar)
+list | map(#?.String())
+list | map(#?.String)
 list | map(#index)
 list | map($env)
 list | map($env) == list
@@ -11746,46 +24305,81 @@ list | map($env) | findLastIndex(#.ok)
 list | map($env) | groupBy(0)
 list | map($env) | map(#.i)
 list | map($env) | map(.ok)
+list | map($env) | map(0)
+list | map($env) | reduce(greet(.str))
 list | map($env) | reduce(str)
+list | map($env.ok)
 list | map($env?.Bar)
 list | map($env?.String)
 list | map($env?.[Bar])
 list | map($env?.[String])
 list | map($env?.f64)
+list | map($env?.i)
 list | map($env?.list)
+list | map($env?.nil)
 list | map($env?.str)
+list | map(-0)
+list | map(-i)
 list | map(.Bar)
+list | map(.Bar) ?? i
 list | map(.String)
 list | map(.String) == array
 list | map(0)
+list | map(0) ?? list
+list | map(0) | all(ok)
 list | map(0) | map(array)
+list | map(0) | none(ok)
+list | map(0) | reduce(#)
+list | map(0) | reduce(0)
 list | map(1 > 1)
+list | map(1 >= 0)
 list | map(1)
 list | map(1.0 * f64)
+list | map(1.0 + 1)
 list | map(1.0)
 list | map(1.0) | any(true)
+list | map(1.0) | findLastIndex(true)
 list | map(1.0) | map(str)
 list | map(1.0) | reduce(1.0)
+list | map(1.0) | reduce(foo)
+list | map(1.0) | sortBy(#)
+list | map([#])
 list | map([.Bar, str])
+list | map([false])
 list | map(add)
+list | map(add) | find(ok)
+list | map(add) | reduce(add)
 list | map(array == nil)
 list | map(array)
 list | map(array) == array
 list | map(bitnot(i))
+list | map(concat(list))
+list | map(f64 < 1.0)
 list | map(f64)
 list | map(f64) | sum(#)
+list | map(f64); f64
+list | map(false or $env)
 list | map(false)
+list | map(false) ?? greet
+list | map(false) | all(#)
 list | map(false) | map(#)
+list | map(false) | reduce(0)
+list | map(false) | sortBy(str)
 list | map(false) | sum(f64)
 list | map(foo == #)
 list | map(foo == $env)
+list | map(foo ?? 0)
+list | map(foo ?? i)
 list | map(foo)
+list | map(foo) != list
+list | map(foo) | count(ok)
 list | map(foo) | groupBy(#)
 list | map(foo) | groupBy(true)
 list | map(foo) | reduce(#acc)
 list | map(foo.Bar)
 list | map(foo?.String)
 list | map(get($env, str))
+list | map(greet(.Bar))
 list | map(greet)
 list | map(greet) != array
 list | map(greet) | sortBy(i)
@@ -11793,27 +24387,49 @@ list | map(i != 1.0)
 list | map(i / f64)
 list | map(i)
 list | map(if true { 1.0 } else { # })
+list | map(last($env))
 list | map(let foobar = str; foobar)
+list | map(let x = array; x)
+list | map(list ?? 0)
 list | map(list)
+list | map(list) | map(#)
 list | map(list) | none(ok)
+list | map(map(array, list))
 list | map(nil != 1)
+list | map(nil != nil)
+list | map(nil ?? $env)
+list | map(not true)
+list | map(ok or $env)
 list | map(ok)
+list | map(ok) | findLast(ok)
 list | map(ok) | reduce(1.0, 0)
 list | map(sortBy(array, #))
+list | map(str <= .Bar)
 list | map(str)
 list | map(str) | groupBy(foo)
 list | map(str) | sortBy(f64)
+list | map(string(#.Bar))
+list | map(string(greet))
 list | map(true || ok)
 list | map(true)
 list | map(true) | find(true)
+list | map(true) | groupBy(0)
 list | map(type(#))
+list | map(type(.String))
+list | map(type(ok))
 list | none(# != #)
 list | none(# == $env)
 list | none(#.Bar in foo)
 list | none($env != $env)
 list | none($env == #)
+list | none($env == i)
+list | none($env.ok)
+list | none($env?.f64 <= f64)
 list | none($env?.ok)
+list | none(.String == .String)
+list | none(1 < 0)
 list | none(1.0 <= 1)
+list | none(all(array, true))
 list | none(f64 <= f64)
 list | none(false)
 list | none(false) || ok
@@ -11822,21 +24438,35 @@ list | none(foo == #)
 list | none(i == 0)
 list | none(list | any(ok))
 list | none(nil == add)
+list | none(ok == $env)
 list | none(ok)
+list | none(true == nil)
 list | none(true)
 list | one(# != foo)
 list | one(# != nil)
+list | one(# == foo)
 list | one($env == $env)
 list | one($env == false)
+list | one($env.ok)
+list | one($env?.ok)
 list | one(.Bar not endsWith str)
 list | one(0 != 1.0)
+list | one(1 >= 1)
+list | one(add != nil)
 list | one(add == nil)
+list | one(f64 != 0)
 list | one(false)
+list | one(foo == $env)
 list | one(i == i)
+list | one(nil ?? false)
 list | one(ok ?: 0)
 list | one(ok)
 list | one(str == str)
 list | one(true)
+list | reduce(!ok)
+list | reduce(# ?? #)
+list | reduce(# ?? $env)
+list | reduce(# ?? 1.0)
 list | reduce(#)
 list | reduce(#, $env)
 list | reduce(#, 0)
@@ -11846,6 +24476,7 @@ list | reduce(#, add)
 list | reduce(#, array)
 list | reduce(#, f64)
 list | reduce(#, false)
+list | reduce(#, foo ?? array)
 list | reduce(#, foo)
 list | reduce(#, greet)
 list | reduce(#, i)
@@ -11858,6 +24489,7 @@ list | reduce(#.Bar)
 list | reduce(#.Bar, $env)
 list | reduce(#.Bar, 0)
 list | reduce(#.Bar, 1)
+list | reduce(#.Bar, add)
 list | reduce(#.Bar, array)
 list | reduce(#.Bar, f64)
 list | reduce(#.Bar, foo)
@@ -11867,10 +24499,14 @@ list | reduce(#.Bar, list)
 list | reduce(#.Bar, nil)
 list | reduce(#.Bar, ok)
 list | reduce(#.String == nil)
+list | reduce(#.String ?? nil)
 list | reduce(#.String)
 list | reduce(#.String, $env)
 list | reduce(#.String, 1)
+list | reduce(#.String, 1.0)
 list | reduce(#.String, f64)
+list | reduce(#.String, foo)
+list | reduce(#.String, greet)
 list | reduce(#.String, i)
 list | reduce(#.String, nil)
 list | reduce(#.String, true)
@@ -11881,8 +24517,11 @@ list | reduce(#acc, $env)
 list | reduce(#acc, 1)
 list | reduce(#acc, 1.0)
 list | reduce(#acc, add)
+list | reduce(#acc, array)
+list | reduce(#acc, array) | map($env)
 list | reduce(#acc, f64)
 list | reduce(#acc, foo)
+list | reduce(#acc, i)
 list | reduce(#acc, nil)
 list | reduce(#acc, str)
 list | reduce(#acc, true)
@@ -11891,18 +24530,26 @@ list | reduce(#index <= 1)
 list | reduce(#index)
 list | reduce(#index, $env)
 list | reduce(#index, 1.0)
+list | reduce(#index, add)
 list | reduce(#index, false)
 list | reduce(#index, foo)
 list | reduce(#index, list)
 list | reduce(#index, nil)
+list | reduce(#index, ok)
+list | reduce(#index, str)
+list | reduce(#index, true)
 list | reduce($env != #)
+list | reduce($env == #.Bar)
 list | reduce($env not in array)
 list | reduce($env)
 list | reduce($env, $env)
+list | reduce($env, 0)
 list | reduce($env, 1)
 list | reduce($env, 1.0)
 list | reduce($env, add)
+list | reduce($env, array)
 list | reduce($env, f64)
+list | reduce($env, false)
 list | reduce($env, foo)
 list | reduce($env, greet)
 list | reduce($env, i)
@@ -11912,16 +24559,23 @@ list | reduce($env, ok)
 list | reduce($env, str)
 list | reduce($env, true)
 list | reduce($env.i)
+list | reduce($env.ok)
 list | reduce($env?.String)
+list | reduce($env?.[Bar])
 list | reduce($env?.[String])
 list | reduce($env?.[foobar])
 list | reduce($env?.[str])
 list | reduce($env?.add)
+list | reduce($env?.add, ok)
 list | reduce($env?.greet, max(1))
+list | reduce(-1)
 list | reduce(.Bar not in $env)
 list | reduce(.Bar)
+list | reduce(.Bar, $env)
 list | reduce(.Bar, 0)
 list | reduce(.Bar, 1.0)
+list | reduce(.Bar, add)
+list | reduce(.Bar, array)
 list | reduce(.Bar, i)
 list | reduce(.Bar, nil)
 list | reduce(.Bar, ok)
@@ -11929,8 +24583,10 @@ list | reduce(.Bar, true)
 list | reduce(.String)
 list | reduce(.String, $env)
 list | reduce(.String, 0)
+list | reduce(.String, 1)
 list | reduce(.String, 1.0)
 list | reduce(.String, array)
+list | reduce(.String, f64)
 list | reduce(.String, foo)
 list | reduce(.String, greet)
 list | reduce(.String, i)
@@ -11939,10 +24595,12 @@ list | reduce(.String, nil)
 list | reduce(.String, ok)
 list | reduce(0 == f64)
 list | reduce(0)
+list | reduce(0) == sum(array)
 list | reduce(0) ^ f64
 list | reduce(0) | median(1.0)
 list | reduce(0, $env)
 list | reduce(0, 1.0)
+list | reduce(0, add)
 list | reduce(0, array)
 list | reduce(0, false)
 list | reduce(0, foo)
@@ -11960,6 +24618,7 @@ list | reduce(1, add)
 list | reduce(1, array)
 list | reduce(1, false)
 list | reduce(1, foo)
+list | reduce(1, foo) | max(array)
 list | reduce(1, greet)
 list | reduce(1, i)
 list | reduce(1, list)
@@ -11973,6 +24632,8 @@ list | reduce(1.0)
 list | reduce(1.0, $env)
 list | reduce(1.0, 0)
 list | reduce(1.0, 1)
+list | reduce(1.0, 1.0)
+list | reduce(1.0, add)
 list | reduce(1.0, array)
 list | reduce(1.0, f64)
 list | reduce(1.0, false)
@@ -11981,21 +24642,32 @@ list | reduce(1.0, greet)
 list | reduce(1.0, i)
 list | reduce(1.0, list)
 list | reduce(1.0, nil)
+list | reduce(1.0, ok)
 list | reduce(1.0, str)
 list | reduce(1.0, true)
+list | reduce([1.0])
 list | reduce([ok, foo])
 list | reduce([true, #])
+list | reduce(add ?? #)
 list | reduce(add)
 list | reduce(add, $env)
 list | reduce(add, 1)
 list | reduce(add, 1.0)
+list | reduce(add, add)
 list | reduce(add, array)
 list | reduce(add, f64)
 list | reduce(add, false)
 list | reduce(add, foo)
 list | reduce(add, nil)
+list | reduce(add, ok)
+list | reduce(array ?? .String)
 list | reduce(array)
+list | reduce(array) | groupBy(0)
+list | reduce(array) | groupBy(ok)
+list | reduce(array) | map(#)
+list | reduce(array) | map($env)
 list | reduce(array) | none(ok)
+list | reduce(array) | reduce(0, list)
 list | reduce(array) | reduce(array)
 list | reduce(array, $env)
 list | reduce(array, 0)
@@ -12008,15 +24680,22 @@ list | reduce(array, false)
 list | reduce(array, foo)
 list | reduce(array, greet)
 list | reduce(array, i)
+list | reduce(array, list)
 list | reduce(array, nil)
 list | reduce(array, ok)
 list | reduce(array, str)
+list | reduce(array, true)
+list | reduce(f64 != $env)
 list | reduce(f64 != nil)
 list | reduce(f64 <= 1.0)
 list | reduce(f64)
+list | reduce(f64) < f64
+list | reduce(f64) ?? $env?.foo
 list | reduce(f64, $env)
 list | reduce(f64, 0)
+list | reduce(f64, 1)
 list | reduce(f64, 1.0)
+list | reduce(f64, add)
 list | reduce(f64, array)
 list | reduce(f64, f64)
 list | reduce(f64, false)
@@ -12025,9 +24704,12 @@ list | reduce(f64, greet)
 list | reduce(f64, list)
 list | reduce(f64, nil)
 list | reduce(f64, str)
+list | reduce(false != nil)
+list | reduce(false ? # : foo)
 list | reduce(false || $env)
 list | reduce(false)
 list | reduce(false, $env)
+list | reduce(false, 0)
 list | reduce(false, 1)
 list | reduce(false, 1.0)
 list | reduce(false, array)
@@ -12036,11 +24718,14 @@ list | reduce(false, false)
 list | reduce(false, foo)
 list | reduce(false, greet)
 list | reduce(false, i)
+list | reduce(false, nil)
 list | reduce(false, ok)
 list | reduce(false, true)
 list | reduce(first($env))
 list | reduce(float(1.0))
 list | reduce(foo == foo)
+list | reduce(foo ?? #)
+list | reduce(foo ?? 1)
 list | reduce(foo)
 list | reduce(foo, $env)
 list | reduce(foo, $env.array)
@@ -12059,191 +24744,305 @@ list | reduce(foo, ok)
 list | reduce(foo, str)
 list | reduce(foo, true)
 list | reduce(foo.Bar)
+list | reduce(foo?.Bar)
+list | reduce(greet ?? 1)
 list | reduce(greet)
+list | reduce(greet) != greet
 list | reduce(greet, $env)
 list | reduce(greet, 1.0)
 list | reduce(greet, add)
 list | reduce(greet, array)
+list | reduce(greet, f64)
 list | reduce(greet, false)
 list | reduce(greet, foo)
 list | reduce(greet, greet)
+list | reduce(greet, i)
 list | reduce(greet, list)
 list | reduce(greet, nil)
 list | reduce(greet, str)
 list | reduce(greet, true)
+list | reduce(groupBy(list, f64)?.[foo])
 list | reduce(i ^ i)
 list | reduce(i)
 list | reduce(i, 0)
 list | reduce(i, 1.0)
 list | reduce(i, add)
+list | reduce(i, array)
+list | reduce(i, f64)
 list | reduce(i, false)
 list | reduce(i, foo)
 list | reduce(i, greet)
 list | reduce(i, i)
+list | reduce(i, list)
 list | reduce(i, list) != $env?.String
 list | reduce(i, nil)
+list | reduce(i, ok)
 list | reduce(i, str)
+list | reduce(i, true)
 list | reduce(list)
+list | reduce(list) ?? not $env
 list | reduce(list) | groupBy(0)
 list | reduce(list, $env)
 list | reduce(list, 1.0)
 list | reduce(list, add)
 list | reduce(list, array)
+list | reduce(list, false)
 list | reduce(list, foo)
 list | reduce(list, greet)
 list | reduce(list, i)
 list | reduce(list, nil)
 list | reduce(list, ok)
 list | reduce(list, str)
+list | reduce(map(list, greet))
+list | reduce(mean([1]))
+list | reduce(nil ?? foo)
 list | reduce(ok and #acc)
 list | reduce(ok)
+list | reduce(ok) == ok
 list | reduce(ok, $env)
 list | reduce(ok, add)
+list | reduce(ok, array)
 list | reduce(ok, false)
 list | reduce(ok, foo)
 list | reduce(ok, i)
 list | reduce(ok, list)
 list | reduce(ok, nil)
 list | reduce(ok, ok)
+list | reduce(ok, true)
 list | reduce(reduce(list, .Bar), ok)
 list | reduce(str)
 list | reduce(str) >= foo.Bar
 list | reduce(str) contains str
 list | reduce(str, $env)
 list | reduce(str, 0)
+list | reduce(str, 1)
 list | reduce(str, 1.0)
 list | reduce(str, add)
 list | reduce(str, array)
 list | reduce(str, f64)
+list | reduce(str, false)
 list | reduce(str, foo)
 list | reduce(str, i)
 list | reduce(str, list)
+list | reduce(str, nil)
 list | reduce(str, ok)
 list | reduce(str, str)
+list | reduce(str, true)
 list | reduce(trim(str))
+list | reduce(true ?? #index)
 list | reduce(true and ok)
 list | reduce(true)
+list | reduce(true, $env)
 list | reduce(true, 0)
 list | reduce(true, array)
 list | reduce(true, f64)
 list | reduce(true, false)
 list | reduce(true, foo)
+list | reduce(true, greet)
 list | reduce(true, i)
 list | reduce(true, ok)
+list | reduce(true, str)
 list | reduce(type(#))
 list | reduce(values($env))
 list | sortBy(#.Bar)
+list | sortBy(#.Bar) | groupBy(foo)
 list | sortBy(#.String())
 list | sortBy(#?.Bar)
 list | sortBy($env?.i)
+list | sortBy(-0)
+list | sortBy(-1.0)
+list | sortBy(-i)
 list | sortBy(.Bar)
+list | sortBy(.Bar) | groupBy(f64)
+list | sortBy(.Bar) | reduce($env)
 list | sortBy(0)
+list | sortBy(0) | one(ok)
+list | sortBy(0) | sortBy(str)
 list | sortBy(1)
+list | sortBy(1) | map(greet)
 list | sortBy(1) | map(str)
+list | sortBy(1) | sum(0)
 list | sortBy(1.0 ** 0)
 list | sortBy(1.0)
+list | sortBy(1.0) ?? i
 list | sortBy(1.0) | filter(false)
 list | sortBy(1.0) | groupBy(true)
 list | sortBy(1.0) | map(.String)
 list | sortBy(1.0) | reduce($env)
+list | sortBy(1.0) | sum(i)
+list | sortBy(ceil(1.0))
 list | sortBy(f64 ** 0)
 list | sortBy(f64)
 list | sortBy(f64) == array
 list | sortBy(float(1))
+list | sortBy(foo.String())
+list | sortBy(foo?.Bar)
 list | sortBy(greet(.Bar))
 list | sortBy(i)
 list | sortBy(i) | groupBy(0)
 list | sortBy(last(array))
 list | sortBy(str)
 list | sortBy(str) | count(ok)
+list | sortBy(str) | reduce(ok, true)
+list | sortBy(string(true))
 list | sum($env.i)
+list | sum($env?.f64)
+list | sum(-f64)
+list | sum(-i)
+list | sum(0 * 0)
 list | sum(0 - 1.0)
 list | sum(0)
 list | sum(0) != i
 list | sum(0) >= 1.0 == false
+list | sum(0) >= bitnot(i)
 list | sum(1)
 list | sum(1) / 0 ** 1
+list | sum(1) <= f64
 list | sum(1) | median(array)
+list | sum(1.0 ^ 1)
 list | sum(1.0)
 list | sum(array | findLastIndex(true))
+list | sum(ceil(1.0))
 list | sum(f64 * 1.0)
 list | sum(f64)
+list | sum(f64) ?? i
 list | sum(f64) in array
 list | sum(i)
 list | sum(int(i))
+list | sum(round(1))
 list | take(0)
+list | take(0) | sortBy(#)
 list | take(1)
 list | take(1) | sum(0)
 list | take(i)
 list; $env.i
+list; $env; $env?.ok
+list; $env?.ok
 list; add
+list; f64
+list; foo
 list; foo; $env.array
 list; foo?.Bar
+list; foo?.String
 list; greet
+list; i
 list; list
 list; nil == nil
 list; nil; foo?.String
 list; ok
 list; str
+list; toJSON(i)
+list?.[$env | count(false)]
 list?.[$env.i]
+list?.[$env?.i]
+list?.[-0]
+list?.[-1]
+list?.[-i]
 list?.[0 % 1]
+list?.[0 ?? nil]
 list?.[0]
 list?.[0].Bar
 list?.[0].String
 list?.[0]?.Bar
 list?.[0]?.String
 list?.[1 + 0]
+list?.[1 ?? 1.0]
+list?.[1 ?? foo]
+list?.[1.0 ?? greet]
 list?.[1]
+list?.[1] != f64 ?? ok
 list?.[1].Bar
 list?.[1].String
 list?.[1].String()
 list?.[1]?.Bar
+list?.[1]?.String
+list?.[1]?.String()
 list?.[array?.[0]]
+list?.[f64 ?? $env?.[add]]
+list?.[i ?? add]
+list?.[i ?? f64]
 list?.[i]
+list?.[i] != foo
 list?.[i] != foo && $env
 list?.[i] == foo
 list?.[i] == nil && $env
+list?.[i] ?? $env?.ok
+list?.[i] ?? add
+list?.[i] ?? array
+list?.[i] ?? f64
+list?.[i] ?? greet
+list?.[i] ?? ok
+list?.[i] ?? str
+list?.[i] ?? type(foo)
 list?.[i] not in list
+list?.[i] not in list ?? f64
 list?.[i].Bar
+list?.[i].Bar ?? foo
 list?.[i].String
 list?.[i].String()
 list?.[i]?.Bar
 list?.[i]?.String
 list?.[i]?.String()
+list?.[int(1.0)]
 list?.[max(i)]
+list?.[mean(i)]
+list?.[median(0)]
 list[$env.i:]
 list[$env?.i:]
+list[-1:]
+list[-i:]
+list[0:] | map(foo)
+list[0:] | reduce(#.Bar)
 list[0:] | reduce(1.0)
 list[0:] | reduce(str)
 list[0:]?.[i]
 list[1 + 0:]
+list[1 ?? 0:]
 list[1:] | findLast(true)
 list[1:] | map(0)
 list[1:] | map(ok)
 list[1:] | reduce(foo)
+list[1:][:i]
+list[:$env.i]
 list[:$env?.i]
+list[:-i]
 list[:0 * 0]
 list[:0] | findIndex(nil != foo)
+list[:0] | map(str)
+list[:1] ?? list
 list[:1] | groupBy(ok)
+list[:1] | one(ok)
+list[:1] | sortBy(foo)
 list[:]
 list[:] | map(#index)
 list[:]?.[i]
+list[:array?.[i]]
 list[:bitnot(1)]
+list[:bitnot(i)]
+list[:count(array, ok)]
 list[:i]
+list[:i] | any(ok)
 list[:i] | filter(true)
+list[:i] | groupBy(ok)
 list[:i] | sum(f64)
 list[:mean(i)]
+list[:median(0)]
 list[:median(array)]
 list[:min(i)]
 list[:sum(array)]
 list[add(1, 0):]
 list[array?.[i]:]
+list[f64 ?? false:]
 list[i:]
+list[i:] ?? greet
+list[i:] | findIndex(ok)
 list[i:] | groupBy(true)
 list[i:] | sortBy(0)
 list[i:i]
 list[int(1.0):]
+list[len($env):]
 list[min(array):]
+list[sum(array):]
 lower($env | reduce(str, 1.0))
 lower($env.str)
 lower($env?.[str])
@@ -12253,19 +25052,38 @@ lower(foo.Bar)
 lower(foo.String())
 lower(foo?.Bar)
 lower(foo?.String())
+lower(greet($env?.str))
 lower(greet(str))
 lower(greet(string(nil)))
 lower(greet(toJSON(array)))
 lower(list?.[i]?.Bar)
 lower(lower(str))
 lower(reduce(array, str))
+lower(repeat(str, 0))
 lower(str + str)
+lower(str ?? $env)
+lower(str ?? 0)
+lower(str ?? 1.0)
+lower(str ?? array)
+lower(str ?? f64)
+lower(str ?? foo)
+lower(str ?? foo?.Bar)
+lower(str ?? ok)
+lower(str ?? true)
 lower(str | greet())
 lower(str)
+lower(str) < str
+lower(str) == $env != false
 lower(str) == str
+lower(str) > str
+lower(str) ?? add
+lower(str) ?? f64
+lower(str) ?? trim(str)
+lower(str) endsWith str
 lower(str) | greet()
 lower(str[1:])
 lower(string($env))
+lower(string(0))
 lower(string(1))
 lower(string(1.0))
 lower(string(add))
@@ -12273,6 +25091,7 @@ lower(string(array))
 lower(string(f64))
 lower(string(false))
 lower(string(foo))
+lower(string(i))
 lower(string(list))
 lower(string(nil))
 lower(string(ok))
@@ -12291,86 +25110,165 @@ lower(toJSON(nil))
 lower(toJSON(ok))
 lower(toJSON(str))
 lower(toJSON(true))
+lower(trim(foo?.Bar))
+lower(trim(str))
 lower(trimPrefix(str))
 lower(trimSuffix(str))
 lower(type($env))
+lower(type(0))
 lower(type(1))
 lower(type(1.0))
 lower(type(add))
+lower(type(array))
+lower(type(f64))
 lower(type(false))
 lower(type(foo))
+lower(type(greet))
 lower(type(i))
 lower(type(list))
 lower(type(nil))
 lower(type(ok))
 lower(type(str))
 lower(type(true))
+lower(upper(str))
+map($env ?? $env, ok)
+map($env ?? 1.0, ok)
+map($env | filter(false), #.add)
+map($env | filter(false), $env - #.str)
+map($env | map(#index), f64)
 map($env | map(foo), #.String)
 map($env, #index) | filter(false)
 map($env, #index) | map(greet)
+map($env, #index) | reduce($env)
 map($env, #index) | reduce(0, $env)
+map($env, #index)?.[i]
+map($env, $env) ?? timezone(str)
+map($env, $env) in last($env)
+map($env, $env) | any(f64 == .foo)
 map($env, $env) | count(ok)
 map($env, $env) | findLast(ok)
 map($env, $env) | map(array)
 map($env, $env) | map(foo)
 map($env, $env) | reduce($env)
+map($env, $env) | reduce(.f64, false)
 map($env, $env) | reduce(0)
+map($env, $env) | sum(1)
 map($env, $env)?.[i]
 map($env, 0) != i .. 0
+map($env, 0) ?? greet
+map($env, 0) ?? list
+map($env, 0) | map($env)
 map($env, 0) | map(str)
 map($env, 0) | reduce(ok, i)
 map($env, 0) | sortBy(1.0)
+map($env, 0)?.[i]
+map($env, 1) | any(ok)
 map($env, 1) | count(ok)
+map($env, 1) | groupBy(foo)
+map($env, 1) | map(#)
+map($env, 1) | none(ok)
 map($env, 1) | reduce(foo)
 map($env, 1) | sum(#)
 map($env, 1)?.[i]
+map($env, 1.0) ?? f64
 map($env, 1.0) | all(true)
+map($env, 1.0) | filter(ok)
+map($env, 1.0) | find(true)
+map($env, 1.0) | groupBy(#)
 map($env, 1.0) | map(str)
+map($env, 1.0) | reduce(ok, add)
 map($env, 1.0)?.[i]
+map($env, add) | groupBy(i)
 map($env, add) | map(false)
+map($env, add) | reduce(1.0)
 map($env, add) | reduce(add, false)
 map($env, add) | sum(f64)
 map($env, add)?.[i]
 map($env, array) | findIndex(ok)
+map($env, array) | map(0)
 map($env, array) | reduce(f64)
+map($env, array)?.[i]
 map($env, f64) | count(ok)
+map($env, f64) | count(true)
+map($env, f64) | groupBy(#)
 map($env, f64) | reduce(#)
 map($env, f64) | reduce(foo)
+map($env, f64) | reduce(greet)
 map($env, f64) | sortBy(#)
+map($env, f64) | sortBy(i)
 map($env, f64) | sum(#)
 map($env, f64)?.[i]
+map($env, f64)[:]
 map($env, false) | filter(false)
+map($env, false) | find(#)
 map($env, false) | map(#)
+map($env, false) | map(1.0)
 map($env, false) | map(greet)
 map($env, false) | reduce(str, nil)
 map($env, false)?.[i]
+map($env, foo) == list
+map($env, foo) ?? list
+map($env, foo) ?? str
 map($env, foo) not in [add, f64]
+map($env, foo) | all(.Bar not startsWith .Bar)
+map($env, foo) | findLastIndex(true)
 map($env, foo) | get(1)
+map($env, foo) | groupBy(#)
+map($env, foo) | map($env)
 map($env, foo) | map(f64)
+map($env, foo) | map(foo)
 map($env, foo) | map(greet)
 map($env, foo) | map(list)
 map($env, foo) | none(true)
+map($env, foo) | reduce(#)
+map($env, foo) | reduce(list)
+map($env, foo) | sortBy(.Bar)
 map($env, foo) | sortBy(str)
 map($env, foo)?.[i]
+map($env, greet) ?? list
+map($env, greet) | all(ok)
+map($env, greet) | findLast(false)
+map($env, greet) | map(1)
 map($env, greet) | map(greet)
 map($env, greet) | reduce(list)
 map($env, greet) | sortBy(i)
 map($env, greet)?.[i]
+map($env, i) == list
 map($env, i) | any(true)
+map($env, i) | groupBy(f64)
+map($env, i) | one(ok)
+map($env, i) | sortBy(1.0)
 map($env, i)?.[i]
+map($env, list) ?? str
 map($env, list) | filter(false)
+map($env, list) | map($env)
+map($env, list) | map(greet)
+map($env, list) | map(str)
 map($env, list) | reduce(1.0)
+map($env, list) | reduce(foo)
 map($env, list) | reduce(list)
 map($env, list)?.[i]
+map($env, ok) | findLastIndex(#)
+map($env, ok) | findLastIndex(false)
+map($env, ok) | one(1.0 == nil)
+map($env, ok) | reduce(false)
 map($env, ok)?.[i]
 map($env, str) | find(ok)
 map($env, str) | find(true)
 map($env, str) | findIndex(false)
 map($env, str) | groupBy(#)
+map($env, str) | map(1)
+map($env, str) | sortBy(str)
 map($env, str)?.[i]
+map($env, true) ?? ok
 map($env, true) | any(#)
+map($env, true) | filter(true)
 map($env, true) | find(#)
+map($env, true) | groupBy(0)
 map($env, true) | map(#)
+map($env, true) | map(f64)
+map($env, true) | reduce(foo)
+map($env, true) | sortBy(1.0)
 map($env, true)?.[i]
 map($env.array, #)
 map($env.array, #index - 1.0)
@@ -12379,20 +25277,33 @@ map($env.array, add)
 map($env.array, foo)
 map($env.array, list)
 map($env.array, mean(0))
+map($env.array, not true)
+map($env.array, ok)
+map($env.array, str)
 map($env.list, #)
 map($env.list, #index)
 map($env.list, .String)
+map($env.list, 0 >= 1.0)
 map($env.list, array)
 map($env.list, f64 ^ f64)
 map($env.list, greet)
+map($env.list, i)
 map($env.list, list)
 map($env.list, ok)
+map($env.list, sortBy(array, 1.0))?.[i]
 map($env.list, str)
 map($env?.[str], # ** #)
 map($env?.[str], #)
+map($env?.[str], #index != #)
+map($env?.[str], #index)
+map($env?.[str], 0 <= 1.0)
 map($env?.[str], array)
+map($env?.[str], f64 - 1.0)
+map($env?.[str], foo ?? #.array)
+map($env?.[str], foo)
 map($env?.[str], greet)
 map($env?.[str], i != f64)
+map($env?.[str], i)
 map($env?.[str], list)
 map($env?.[str], median(0))
 map($env?.[str], nil != false)
@@ -12404,13 +25315,22 @@ map($env?.array, add)
 map($env?.array, all(list, true))
 map($env?.array, array)
 map($env?.array, f64)
+map($env?.array, foo)
+map($env?.array, greet == greet)
 map($env?.array, list)
 map($env?.array, str)
 map($env?.list, # != $env)
 map($env?.list, #)
 map($env?.list, $env?.[String])
+map($env?.list, add)
+map($env?.list, count($env, false))
 map($env?.list, foo)
 map($env?.list, greet)
+map($env?.list, i)
+map($env?.list, list[1:])
+map($env?.list, median(i))
+map($env?.list, ok)
+map($env?.list, trimSuffix(str))
 map(1 .. 1, list)
 map([$env], #)
 map([$env], #.Bar not in #.array)
@@ -12419,165 +25339,323 @@ map([$env], 1 ^ 1.0)
 map([$env], add)
 map([$env], false != #)
 map([$env], greet)
+map([$env], true || .array)
 map([0], #)
 map([1.0], #)
 map([1.0], greet)
 map([1.0], ok)
 map([1], greet)
+map([add, i], array)
+map([array], #)
+map([false], -1)
 map([false], list)
+map([false], ok)
+map([foo, 1.0], #index)
+map([foo, true], #)
 map([foo], #)
 map([foo], #?.Bar)
+map([foo], .String)
+map([foo], 1.0 < 0)
 map([foo], add)
 map([foo], f64)
 map([foo], foo)
 map([foo], str)
+map([greet], #)
+map([greet], array)
+map([greet], foo)
+map([i / 1.0], #)
 map([i, 1.0], #)
+map([i], #)
+map([i], ok)
 map([i], str)
+map([list], array)
 map([list], f64 + 1.0)
 map([list], f64)
 map([nil], 1.0 <= 1)
+map([nil], foo)
 map([nil], list)
 map([nil], ok)
+map([nil], str ?? f64)
 map([ok], #)
+map([ok], array)
 map([str], greet)
+map([true], #)
 map([true], foo)
+map([true], i ^ 1.0)
+map(array ?? 1, i)
+map(array ?? 1, ok)
+map(array ?? 1.0, false ? #.add : #)
+map(array ?? array, add)
+map(array ?? foo, # > #)
+map(array ?? foo, add)
+map(array | map(#), 1.1)
 map(array | reduce($env), list)
+map(array | sortBy(#), ok)
+map(array, !false)
+map(array, !true)
+map(array, # != #)
+map(array, # % i)
+map(array, # ** #)
 map(array, # ** 1.0)
+map(array, # + #)
 map(array, # + 1)
 map(array, # .. #)
+map(array, # .. 0)
+map(array, # < f64)
 map(array, # <= #)
 map(array, # <= 1.0)
 map(array, # == #)
+map(array, # > #)
 map(array, # > 0)
 map(array, # >= #)
+map(array, # >= 0)
+map(array, # ?? #)
+map(array, # ?? i)
 map(array, # ^ #)
 map(array, # ^ 1.0)
+map(array, # | bitshr(#))
 map(array, #)
+map(array, #) ?? add
+map(array, #) ?? greet
+map(array, #) | filter(false)
+map(array, #) | findLastIndex(ok)
 map(array, #) | findLastIndex(true)
 map(array, #) | groupBy(#)
 map(array, #) | map($env)
 map(array, #) | map(bitnot(1))
 map(array, #) | map(foo)
+map(array, #) | map(greet)
+map(array, #) | reduce($env?.foobar)
+map(array, #) | reduce(1.0)
 map(array, #) | sortBy(#)
 map(array, #)?.[i]
+map(array, #..i)
+map(array, #index < 1.0)
 map(array, #index)
 map(array, #index) | groupBy(ok)
 map(array, #index)?.[i]
 map(array, $env && true)
 map(array, $env == #)
 map(array, $env == true)
+map(array, $env) | all(#.list || true)
+map(array, $env) | count(#.ok)
+map(array, $env) | none(.String matches #)
+map(array, $env) | reduce(1.0)
+map(array, $env) | reduce(add)
+map(array, $env) | sortBy(1)
 map(array, $env)?.[i]
+map(array, $env.array)
 map(array, $env.f64)
 map(array, $env.foo)
 map(array, $env.greet)
 map(array, $env.list)
 map(array, $env.str)
 map(array, $env?.String)
+map(array, $env?.[String])
 map(array, $env?.[foobar])
 map(array, $env?.[str])
 map(array, $env?.add)
+map(array, $env?.array)
+map(array, $env?.f64)
 map(array, $env?.greet)
 map(array, $env?.list)
+map(array, $env?.ok)
+map(array, -1)
+map(array, -1.0)
+map(array, -f64)
+map(array, -i)
 map(array, 0 != #)
+map(array, 0 % #)
 map(array, 0 - #)
+map(array, 0 - 1)
+map(array, 0 <= #)
 map(array, 0 | bitxor(#))
 map(array, 0) | find(false)
 map(array, 0) | map(array)
+map(array, 0) | reduce(#)
 map(array, 0) | sortBy(f64)
+map(array, 0)?.[i]
 map(array, 1 != #)
+map(array, 1 - #)
+map(array, 1 ^ #)
 map(array, 1) | map(1)
+map(array, 1) | one(ok)
+map(array, 1) | reduce($env)
 map(array, 1)?.[i]
+map(array, 1.0 != #)
 map(array, 1.0 != 1.0)
+map(array, 1.0 ** #)
 map(array, 1.0 + #)
 map(array, 1.0 + 1.0)
+map(array, 1.0 / 0)
+map(array, 1.0 <= #)
 map(array, 1.0 == #)
+map(array, 1.0 == nil)
+map(array, 1.0 ?? nil)
+map(array, 1.0 ^ f64)
+map(array, 1.0) != array
+map(array, 1.0) != f64 ?? greet
+map(array, 1.0) == list
+map(array, 1.0) | groupBy(#)
+map(array, 1.0) | groupBy(1.0)
+map(array, 1.0) | groupBy(ok)
+map(array, 1.0) | map(#)
+map(array, 1.0) | map(foo)
+map(array, 1.0) | reduce($env)
 map(array, 1.0) | reduce(1.0)
+map(array, 1.0) | reduce(true)
 map(array, 1.0) | take(1)
 map(array, 1.0)?.[i]
 map(array, [#])
 map(array, [0, $env])
+map(array, [f64])
+map(array, [i])
+map(array, [nil])
 map(array, add)
 map(array, add) | groupBy(foo)
+map(array, add)?.[i]
+map(array, array | map(1.0))
 map(array, array)
+map(array, array) | all(true)
+map(array, array) | sum(i)
 map(array, array)?.[i]
+map(array, array?.[1])
 map(array, bitnot(#))
 map(array, f64 - 1.0)
+map(array, f64 <= f64)
+map(array, f64 >= i)
 map(array, f64)
 map(array, f64) != list
+map(array, f64) ?? -1.0
+map(array, f64) | groupBy(foo)
+map(array, f64) | reduce(#)
 map(array, f64)?.[i]
+map(array, false) | any(#)
 map(array, false) | count(false)
 map(array, false) | reduce(greet)
 map(array, false) | sortBy(str)
 map(array, false)?.[i]
+map(array, findIndex($env, ok))
 map(array, flatten(array))
 map(array, flatten(list))
 map(array, float(#))
+map(array, float(1))
 map(array, foo != $env)
+map(array, foo != foo)
 map(array, foo == foo)
+map(array, foo ?? ok)
 map(array, foo)
 map(array, foo) != array
 map(array, foo) | count(true)
 map(array, foo) | findLastIndex(false)
 map(array, foo) | map(#.Bar)
 map(array, foo) | map(ok)
+map(array, foo) | reduce(#)
 map(array, foo) | reduce(list)
 map(array, foo) | reduce(str, f64)
+map(array, foo) | reduce(true)
+map(array, foo) | sum(0 + 1)
 map(array, foo)?.[i]
 map(array, foo)[:]
+map(array, foo.Bar)
 map(array, foo.String)
+map(array, foo?.Bar)
 map(array, foo?.String)
 map(array, greet)
+map(array, greet) | sum(f64)
 map(array, greet)?.[i]
+map(array, i * f64)
 map(array, i < 0)
 map(array, i == #index)
 map(array, i)
 map(array, i) | find(ok)
 map(array, i)?.[i]
+map(array, if ok { $env } else { i })
 map(array, int(#index))
 map(array, len($env))
 map(array, list == $env)
 map(array, list == list)
 map(array, list)
 map(array, list)?.[i]
+map(array, list?.[i])
 map(array, median(#))
 map(array, median(1.0))
 map(array, min(0))
+map(array, nil != 1.0)
+map(array, nil != array)
+map(array, nil == 1.0)
+map(array, nil ?? list)
+map(array, not false)
+map(array, not true)
 map(array, ok != true)
+map(array, ok == nil)
+map(array, ok ?? str)
 map(array, ok || false)
 map(array, ok)
+map(array, ok) ?? float($env)
 map(array, ok) | count(1 >= 1.0)
 map(array, ok) | map(1)
 map(array, ok) | one(true)
 map(array, ok) | sum(1.0)
+map(array, ok)?.[i]
 map(array, reduce(array, foo, #index))
+map(array, reverse(list))
+map(array, round(1))
 map(array, sort(array))
 map(array, str == nil)
+map(array, str in foo)
 map(array, str)
 map(array, str) == list
 map(array, str) | groupBy(#)
 map(array, str) | map(list)
 map(array, str) | reduce(#)
 map(array, str)?.[i]
+map(array, sum(array))
+map(array, true ? 1 : #)
+map(array, true ?? #)
+map(array, true ?? foo)
 map(array, true) != array
+map(array, true) | findLast(#)
 map(array, true)?.[i]
 map(array, type(1.0))
+map(array, type(list))
+map(array[i:], $env?.ok)
 map(concat(array), # == f64)
 map(concat(array), greet)
+map(concat(list), foo)
 map(false ? foo : list, $env.ok)
 map(filter(array, true), greet)
 map(flatten(array), #)
 map(flatten(array), i)
+map(flatten(array), str)
+map(i .. i, array)
+map(if false { $env } else { list }, #index)
+map(keys($env), #)
+map(keys($env), str)
+map(list ?? 0, # == str)
+map(list ?? false, f64)
+map(list ?? true, list)
 map(list | map($env), #)
 map(list | map(.Bar), #)
+map(list | map(.Bar), greet)
 map(list | sortBy(1.0), .String)
 map(list | sortBy(1.0), string(#))
+map(list | sortBy(str), f64)
 map(list, # != #)
 map(list, # == #)
 map(list, # == foo)
+map(list, # ?? #)
+map(list, # ?? #index)
+map(list, # ?? $env)
+map(list, # ?? .Bar)
+map(list, # ?? greet)
 map(list, #)
+map(list, #) == array
+map(list, #) ?? greet
 map(list, #) | any(false)
 map(list, #) | any(ok)
 map(list, #) | findIndex(ok)
+map(list, #) | findIndex(true)
 map(list, #) | findLastIndex(ok)
 map(list, #) | groupBy(#)
 map(list, #) | groupBy(1.0)
@@ -12585,25 +25663,41 @@ map(list, #) | groupBy(foo)
 map(list, #) | map(#)
 map(list, #) | map(1.0)
 map(list, #) | map(true)
+map(list, #) | one(false)
 map(list, #) | one(true)
 map(list, #) | reduce(#.String, foo)
 map(list, #) | reduce(#acc, 1)
+map(list, #) | reduce(1.0, nil)
+map(list, #) | reduce(f64, list)
 map(list, #) | sortBy(1.0)
+map(list, #) | take(1)
 map(list, #)?.[i]
 map(list, #.Bar <= #.Bar)
 map(list, #.Bar)
 map(list, #.String)
+map(list, #.String) ?? i
 map(list, #.String)?.[i]
+map(list, #?.Bar)
 map(list, #?.String)
 map(list, #index + i)
 map(list, #index - 1)
 map(list, #index | add(i))
 map(list, #index)
+map(list, #index) ?? $env ?? nil
 map(list, #index)?.[i]
+map(list, $env != #)
+map(list, $env != foo)
+map(list, $env != greet)
 map(list, $env != nil)
+map(list, $env ?? 1.0)
+map(list, $env) ?? $env.ok
+map(list, $env) ?? array
 map(list, $env) | findIndex(.ok)
 map(list, $env) | findLastIndex(#.foo != #)
 map(list, $env) | map(1.0)
+map(list, $env) | map(foo)
+map(list, $env) | reduce(#.ok)
+map(list, $env) | reduce(1.0)
 map(list, $env)?.[i]
 map(list, $env.add)
 map(list, $env.f64)
@@ -12611,108 +25705,220 @@ map(list, $env.foo)
 map(list, $env.greet)
 map(list, $env?.[.Bar])
 map(list, $env?.[Bar])
+map(list, $env?.[String])
+map(list, $env?.[str])
 map(list, $env?.add)
 map(list, $env?.array)
+map(list, $env?.f64)
+map(list, $env?.foo)
+map(list, $env?.foobar)
 map(list, $env?.greet)
 map(list, $env?.i)
 map(list, $env?.ok)
+map(list, $env?.str)
+map(list, -#index)
 map(list, .Bar)
+map(list, .Bar) | sum(1)
 map(list, .String)
+map(list, .String) | filter(true)
 map(list, .String) | map(#)
+map(list, .String) | sum(i)
 map(list, .String)?.[i]
 map(list, 0 <= 1.0)
 map(list, 0 > 1)
 map(list, 0) | groupBy(foo)
+map(list, 0) | sortBy(#)
 map(list, 0) | sum(#)
 map(list, 1 == 1.0)
+map(list, 1) | all(false)
 map(list, 1) | groupBy(#)
+map(list, 1) | map(list)
 map(list, 1)?.[i]
 map(list, 1.0 / i)
+map(list, 1.0 >= 1.0)
+map(list, 1.0 ?? #.Bar)
+map(list, 1.0 ?? list)
+map(list, 1.0) != array
+map(list, 1.0) ?? array
+map(list, 1.0) | any(# < i)
 map(list, 1.0) | findLast(true)
 map(list, 1.0) | groupBy(#)
 map(list, 1.0) | reduce(foo)
 map(list, 1.0) | sortBy(#)
 map(list, 1.0)?.[i]
 map(list, [$env, nil, add])
+map(list, [foo])
+map(list, [ok])
+map(list, abs(1))
 map(list, abs(1.0))
+map(list, add ?? #)
+map(list, add ?? list)
 map(list, add)
 map(list, add)?.[i]
 map(list, array)
+map(list, array) ?? list
 map(list, array) | one(ok)
 map(list, array) | one(true)
+map(list, array)?.[i]
+map(list, array?.[i])
 map(list, bitnot(0))
 map(list, bitnot(i))
 map(list, ceil(1.0))
+map(list, f64 != 1.0)
+map(list, f64 * 0)
 map(list, f64 / 1.0)
 map(list, f64)
 map(list, f64) | groupBy(#)
 map(list, f64) | map($env)
+map(list, f64) | none(true)
 map(list, f64) | reduce(1)
+map(list, false ?? foo)
+map(list, false) | groupBy(foo)
 map(list, false) | map(#)
+map(list, float(0))
 map(list, floor(1.0))
+map(list, foo == #)
+map(list, foo ?? #)
+map(list, foo ?? foo)
+map(list, foo not in list)
 map(list, foo)
+map(list, foo) ?? f64
+map(list, foo) | none(false)
+map(list, foo) | reduce(#, add)
 map(list, foo) | reduce(#.String)
 map(list, foo) | reduce(1)
+map(list, foo) | reduce(array)
 map(list, foo) | sum(0)
 map(list, foo)?.[i]
 map(list, foo.Bar)
 map(list, foo.String)
 map(list, foo?.Bar)
 map(list, foo?.String())
+map(list, greet ?? nil)
 map(list, greet(#.Bar))
 map(list, greet(str))
 map(list, greet)
 map(list, greet) | findIndex(true)
+map(list, greet)?.[i]
+map(list, i == $env)
 map(list, i >= 0)
 map(list, i)
+map(list, i) != list
+map(list, i) != nil or true
 map(list, i) | groupBy(# < #)
+map(list, i) | reduce(#)
 map(list, i) | sortBy(#)
 map(list, i)?.[i]
 map(list, list)
+map(list, list) | map(str)
 map(list, list) | sum(f64)
 map(list, list)?.[i]
+map(list, max(1))
 map(list, max(f64))
+map(list, mean(array))
 map(list, nil != add)
+map(list, nil ?? #)
+map(list, nil in $env)
 map(list, none($env, true))
+map(list, not true)
+map(list, ok ? str : foo)
+map(list, ok ?? 0)
 map(list, ok or ok)
 map(list, ok)
+map(list, ok) | map(false)
+map(list, ok)?.[i]
+map(list, reverse(list))
 map(list, round(f64))
+map(list, sort(array))
+map(list, str ?? 0)
 map(list, str not in #)
 map(list, str)
 map(list, str) | findLast(false)
 map(list, str) | map(#)
 map(list, str) | reduce(#)
 map(list, string(#))
+map(list, string(f64))
 map(list, sum(array))
+map(list, toJSON(1))
 map(list, trim(str))
 map(list, true ? array : f64)
+map(list, true ?? #index)
 map(list, true)?.[i]
 map(list, type(#))
 map(list, type($env))
 map(list, upper(#.Bar))
+map(list[:1], f64)
+map(map($env, $env), greet)
+map(map($env, 0), str == str)
 map(map(array, #), #)
+map(map(array, array), greet)
 map(map(array, list), str)
+map(map(list, 1), list)
 map(map(list, f64), ok)
+map(map(list, str), map($env, 1.0))
+map(max($env), greet)
 map(min($env), f64)
+map(nil ?? $env, str)
+map(nil ?? array, 1.0 != 1.0)
+map(reduce($env, list, $env), foo)
 map(reduce(array, $env), foo.String())
 map(reverse(array), str)
+map(sort($env), #.String contains #.list)
+map(sort($env), #.String.i)
+map(sort($env), #.array.greet)
+map(sort($env), #.greet.foo)
 map(sort($env), #.greet?.Bar(Bar))
+map(sort($env), add)
+map(sort($env), array?.[#])
 map(sort($env), lower(#))
+map(sort($env), ok)
+map(sort($env), str not matches $env)
+map(sort($env), str)
+map(sort(array), list?.[i])
 map(sort(array), ok)
+map(sortBy(array, 1.0), #)
 map(sortBy(array, str), # >= #index)
+map(str ?? foo, #)
+map(str ?? foo, f64)
+map(str ?? foo, i)
+map(toPairs($env), f64)
+map(toPairs($env), list | sortBy(1))
+map(true ? array : false, $env?.greet)
+map(uniq(list), ok)
 map(uniq(list), reduce(list, foo))
 map(values($env), #)
+max($env ?? $env)
+max($env ?? 1)
+max($env ?? add)
+max($env ?? array)
+max($env ?? f64)
+max($env ?? foo)
+max($env ?? list)
+max($env ?? nil)
+max($env ?? str)
+max($env ?? true)
+max($env | count(ok))
+max($env | count(true))
 max($env | find(false))
 max($env | findIndex(ok))
+max($env | findLast(false))
+max($env | findLastIndex(false))
 max($env | findLastIndex(ok))
+max($env | findLastIndex(true))
 max($env | map(#index))
 max($env | map(0))
+max($env | map(1))
 max($env | sum(i))
 max($env) != $env?.array
 max($env) != greet
 max($env) == $env?.foo
+max($env) == f64
 max($env) == list
 max($env) == ok
+max($env) ?? i
+max($env) ?? list
+max($env) not in list
+max($env) | all(ok)
 max($env) | count($env.ok)
 max($env) | count(false)
 max($env) | count(true)
@@ -12723,15 +25929,23 @@ max($env) | map(f64)
 max($env) | map(greet)
 max($env) | map(i)
 max($env) | map(str)
+max($env) | none(ok)
+max($env) | sum(0)
 max($env) | sum(1.0)
 max($env).Bar
 max($env).Bar?.i().str
+max($env).Bar?.str
 max($env).String
+max($env).String?.[array]
+max($env).String?.[str]
 max($env).add
 max($env).array
 max($env).f64
 max($env).foo
+max($env).foobar
+max($env).foobar?.[add]
 max($env).foobar?.[greet]
+max($env).foobar?.foo
 max($env).foobar?.str
 max($env).greet
 max($env).greet(foobar)
@@ -12740,8 +25954,11 @@ max($env).list
 max($env).not
 max($env).ok
 max($env).str
+max($env)?.$env?.Bar
+max($env)?.$env?.foo(1.0)
 max($env)?.Bar
 max($env)?.String
+max($env)?.String?.[str]
 max($env)?.[str]
 max($env)?.[str]?.[i]
 max($env)?.add
@@ -12749,6 +25966,7 @@ max($env)?.array
 max($env)?.array not in list
 max($env)?.f64
 max($env)?.foo
+max($env)?.foobar?.[add]
 max($env)?.foobar?.[greet]
 max($env)?.greet
 max($env)?.greet(foobar)
@@ -12758,9 +25976,12 @@ max($env)?.list?.[f64]
 max($env)?.not
 max($env)?.ok
 max($env)?.str
+max($env)?.str?.[f64]
+max($env.array ?? array)
 max($env.array)
 max($env.array, array)
 max($env.f64)
+max($env.f64, sum(array))
 max($env.i)
 max($env?.$env)
 max($env?.Bar)
@@ -12768,16 +25989,24 @@ max($env?.Bar)?.[foo]
 max($env?.Bar)?.foo
 max($env?.Bar)?.list
 max($env?.String)
+max($env?.String)?.[foo]
 max($env?.String)?.[i]
+max($env?.String?.[array])
+max($env?.String?.foo())
+max($env?.String?.i())
 max($env?.[Bar])
+max($env?.[Bar])?.[ok]
 max($env?.[String])
 max($env?.[String])?.[i]
+max($env?.[String])?.foo
 max($env?.[String]?.[f64])
+max($env?.[String]?.[str])
 max($env?.[String]?.ok)
 max($env?.[foobar])
 max($env?.[nil])
 max($env?.[str])
 max($env?.[str]) | reduce(ceil(#))
+max($env?.[str]?.[f64])
 max($env?.array)
 max($env?.f64 ^ i)
 max($env?.f64)
@@ -12787,40 +26016,96 @@ max($env?.foobar)
 max($env?.i)
 max($env?.nil)
 max($env?.true)
+max(-0)
+max(-1)
+max(-1.0)
+max(-f64)
+max(-i)
+max(-median(1, 0))
 max(0 % 1)
 max(0 % i)
 max(0 * 0)
 max(0 * 1)
 max(0 * 1.0)
+max(0 ** 1)
 max(0 ** f64)
+max(0 + 0)
 max(0 + 1)
+max(0 + 1.0)
+max(0 + f64)
 max(0 - 0)
+max(0 - 1)
 max(0 - 1.0)
 max(0 - f64)
 max(0 - i)
+max(0 .. 1)
 max(0 .. 1, i)
 max(0 .. i)
 max(0 / 0)
 max(0 / 1)
+max(0 ?? $env)
+max(0 ?? 1)
+max(0 ?? add)
+max(0 ?? array)
+max(0 ?? f64)
+max(0 ?? false)
+max(0 ?? greet)
+max(0 ?? ok)
+max(0 ^ 0)
 max(0 ^ 1)
 max(0 ^ 1.0)
 max(0 ^ f64)
+max(0 ^ i)
 max(0 | min(1.0, 1.0))
 max(0) != 0 || ok
 max(0) - i
+max(0) < i
+max(0) == f64
+max(0) ?? -f64
+max(0) ?? f64
+max(0) not in array
 max(0..i)
+max(0.0)
 max(0.1)
+max(1 * 0)
+max(1 * 1.0)
+max(1 * i)
+max(1 ** 0)
 max(1 ** 1.0)
 max(1 + 0)
+max(1 + 1)
+max(1 + f64)
+max(1 + i)
+max(1 - 1)
 max(1 - 1.0)
+max(1 - f64)
+max(1 - i)
 max(1 .. 1)
 max(1 / 1.0)
+max(1 / f64)
+max(1 / i)
+max(1 ?? 1.0)
+max(1 ?? f64)
+max(1 ?? false)
+max(1 ?? foo)
+max(1 ?? list)
+max(1 ?? list, array)
+max(1 ?? ok)
+max(1 ^ $env?.i)
 max(1 ^ 0)
 max(1 ^ 1.0)
+max(1 ^ i)
+max(1 | bitshr(1))
 max(1 | max(1.0))
+max(1) * i
 max(1) ** f64
+max(1) ** i
 max(1) .. i
 max(1) / i
+max(1) < f64
+max(1) < i
+max(1) ?? $env.ok
+max(1, 1.0) < f64
 max(1, 1.0) in array
 max(1.0 * 0)
 max(1.0 * 1)
@@ -12828,94 +26113,194 @@ max(1.0 * 1.0)
 max(1.0 * f64)
 max(1.0 * i)
 max(1.0 ** 0)
+max(1.0 ** 1)
 max(1.0 ** 1.0)
+max(1.0 ** f64)
+max(1.0 ** i)
 max(1.0 + 0)
 max(1.0 + 1)
 max(1.0 + 1.0)
+max(1.0 + f64)
+max(1.0 + i)
 max(1.0 - 0)
+max(1.0 - 1)
 max(1.0 - 1.0)
 max(1.0 - f64)
 max(1.0 - i)
 max(1.0 / 0)
 max(1.0 / 1.0)
+max(1.0 / i)
+max(1.0 ?? $env)
+max(1.0 ?? 1.0)
+max(1.0 ?? array)
+max(1.0 ?? f64)
+max(1.0 ?? false)
+max(1.0 ?? false, i)
+max(1.0 ?? foo)
+max(1.0 ?? greet)
+max(1.0 ?? i)
+max(1.0 ?? nil)
+max(1.0 ?? ok)
 max(1.0 ^ 0)
+max(1.0 ^ 1)
+max(1.0 ^ 1.0)
 max(1.0 ^ f64)
 max(1.0 ^ i)
 max(1.0)
 max(1.0) ** i
+max(1.0) - i
 max(1.0) < i
 max(1.0) <= $env.f64
 max(1.0) <= i
+max(1.0) > 1 - i
 max(1.0) > f64
 max(1.0) >= i
+max(1.0) ?? i
+max(1.0) ?? list
+max(1.0) ?? ok
 max(1.0) ^ f64
 max(1.0) | min(array)
+max(1.0, 1.0) ?? greet
+max(1.0, array) >= floor(1.0)
+max([0])
 max([1.0])
 max([1])
+max([array, 1.0])
 max([array])
+max([f64, 1.0] ?? add)
+max([f64])
 max([i])
 max(abs(0))
 max(abs(1))
 max(abs(1.0))
 max(abs(f64))
 max(abs(i))
+max(add ?? $env)
+max(add ?? f64)
+max(add ?? i)
+max(add(0, 0))
+max(array ?? false)
+max(array ?? greet)
+max(array ?? i)
+max(array | find(false))
+max(array | findLast(ok))
+max(array | findLast(true))
 max(array | get(i))
 max(array | map(1.0))
 max(array | map(i))
 max(array | reduce(#index))
+max(array | reduce($env))
 max(array | reduce($env, 0))
+max(array | reduce(0))
 max(array | reduce(1.0, foo))
+max(array | reduce(i))
 max(array | sortBy(#))
 max(array | sortBy(0))
+max(array | sortBy(1))
+max(array | sortBy(1.0))
 max(array | sortBy(f64))
 max(array | sum(0))
+max(array | sum(i))
 max(array)
 max(array) != array
+max(array) != i
+max(array) ** f64
+max(array) ** i
 max(array) - f64
 max(array) / median(1)
 max(array) == i
 max(array) == str
 max(array) > f64
+max(array) ?? greet
+max(array) ?? ok
 max(array, abs(i))
 max(array, array)
 max(array, f64)
 max(array, i)
+max(array, int(0))
 max(array?.[1])
 max(array?.[i])
 max(array[:])
+max(bitnand(i, i))
 max(bitnot(0))
 max(bitnot(1))
 max(bitnot(i))
+max(bitor(1, 1))
+max(bitushr(0, 1))
+max(bitxor(0, 0))
+max(bitxor(1, 0))
 max(ceil(0))
 max(ceil(1))
 max(ceil(1.0))
+max(ceil(f64))
+max(ceil(i))
 max(concat(array))
+max(count(array, true))
 max(count(list, false))
 max(count(list, ok))
+max(f64 * 1.0)
 max(f64 * f64)
 max(f64 * i)
+max(f64 ** 0)
 max(f64 ** 1)
+max(f64 ** 1.0)
+max(f64 ** i)
 max(f64 + 0)
 max(f64 + 1)
+max(f64 + 1.0)
+max(f64 - 1.0)
+max(f64 - i)
+max(f64 / 0)
+max(f64 / 1)
+max(f64 / 1.0)
+max(f64 ?? $env)
+max(f64 ?? 0)
+max(f64 ?? 1.0)
+max(f64 ?? foo)
+max(f64 ?? greet)
+max(f64 ?? i)
+max(f64 ?? nil)
+max(f64 ?? ok)
+max(f64 ^ 1)
 max(f64 ^ 1.0)
+max(f64 ^ i)
 max(f64)
 max(f64) != f64
+max(f64) ** f64
+max(f64) / f64
 max(f64) < i
 max(f64) <= 0 * f64
 max(f64) <= f64
+max(f64) == f64
 max(f64) >= f64
+max(f64) ?? add
+max(f64) ^ f64
 max(f64) not in array
+max(f64, $env?.array)
+max(f64, 1.0 ** 1.0)
 max(f64, array)
 max(f64, array, array)
 max(f64, f64)
 max(f64, i)
+max(f64, median(0))
+max(f64, min(1, 1))
 max(false ? foo : 0)
 max(false ? nil : $env)
+max(false ? nil : array)
+max(false ? str : 0)
 max(false ?: foo)
+max(false ?? $env)
+max(false ?? 1.0)
+max(false ?? foo)
+max(findLast($env, false))
+max(findLastIndex($env, true))
 max(findLastIndex(array, false))
 max(findLastIndex(array, ok))
 max(findLastIndex(array, true))
+max(findLastIndex(list, false))
 max(first($env))
+max(first(array))
+max(first(array), array)
 max(flatten(array))
 max(float(0))
 max(float(1))
@@ -12923,34 +26308,87 @@ max(float(1.0))
 max(float(f64))
 max(float(i))
 max(floor(1))
+max(floor(1.0))
 max(floor(i))
+max(foo ?? $env)
+max(foo ?? $env[foo:])
+max(foo ?? 0)
+max(foo ?? 1)
+max(foo ?? 1.0)
+max(foo ?? add)
+max(foo ?? array)
+max(foo ?? f64)
+max(foo ?? false)
+max(foo ?? greet)
+max(foo ?? i)
+max(foo ?? list)
+max(foo ?? ok)
+max(foo ?? true)
+max(get($env, nil))
+max(greet ?? $env)
+max(greet ?? 0)
+max(greet ?? 1)
+max(greet ?? add)
+max(greet ?? array)
+max(greet ?? false)
+max(greet ?? foo)
+max(greet ?? list)
 max(i % 1)
 max(i % i)
+max(i * 0)
+max(i * 1)
 max(i * 1.0)
 max(i * i, i)
+max(i ** 0)
+max(i ** 1)
 max(i ** 1.0)
 max(i ** f64)
+max(i ** i)
 max(i + 0)
+max(i + 1.0)
 max(i + f64)
 max(i - 1)
 max(i - 1.0)
+max(i - i)
 max(i .. 0)
+max(i .. 1)
 max(i / 1)
 max(i / 1.0)
 max(i / i)
+max(i ?? 0)
+max(i ?? 1.0)
+max(i ?? add)
+max(i ?? list)
+max(i ?? nil)
+max(i ?? ok)
+max(i ?? true)
 max(i ^ 0)
 max(i ^ i)
 max(i | bitor(i))
+max(i | bitshl(0))
+max(i | max(1))
 max(i | min(f64))
 max(i)
+max(i) + f64
+max(i) - f64
 max(i) < f64
 max(i) <= f64
+max(i) >= i
+max(i) ?? str
 max(i) not in array
+max(i) | bitushr(i)
 max(i) | bitxor(0)
+max(i) | min(1.0)
 max(i, array)
+max(i, array, i)
 max(i, f64)
 max(i, i)
+max(i, min(1.0))
+max(i..i)
+max(if false { 0 } else { nil })
+max(if false { array } else { nil })
 max(if false { ok } else { 1.0 })
+max(if ok { $env } else { 1.0 })
 max(if ok { foo } else { 1.0 })
 max(if ok { ok } else { 0 })
 max(if true { $env } else { f64 })
@@ -12959,32 +26397,45 @@ max(int(1))
 max(int(1.0))
 max(int(f64))
 max(int(i))
+max(int(sum(array, 1.0)))
 max(last($env))
 max(last($env)?.ok)
 max(last(array))
 max(len($env))
+max(len(array))
 max(len(list))
 max(len(str))
 max(let foobar = f64; foobar)
+max(let tmp = $env; tmp)
 max(list | count(ok))
+max(list | count(true))
+max(list | filter(false))
 max(list | map(f64))
 max(list | reduce($env))
 max(list) startsWith str and false
 max(map($env, #index))
+max(map($env, 0))
+max(map($env, 1.0))
+max(map($env, array))
+max(map(array, #index))
 max(map(array, 1))
 max(map(array, array))
 max(map(array, f64))
 max(map(list, 1))
 max(map(list, i))
 max(max($env))
+max(max($env.array))
+max(max($env?.Bar))
 max(max(0))
 max(max(1))
 max(max(1.0))
 max(max(array))
 max(max(array?.[i]))
 max(max(f64))
+max(max(f64, 1))
 max(max(i))
 max(mean(0))
+max(mean(0, f64))
 max(mean(1))
 max(mean(1.0))
 max(mean(1.0, 1.0))
@@ -12993,46 +26444,89 @@ max(mean(f64))
 max(mean(i))
 max(mean(i), array)
 max(median(0))
+max(median(1))
 max(median(1.0))
+max(median(1.0, array))
 max(median(array))
 max(median(array, 1))
 max(median(f64))
 max(median(i))
+max(min($env))
 max(min(0))
 max(min(1))
 max(min(1.0))
+max(min(1.0, array))
+max(min(1.0, f64, i))
 max(min(array))
 max(min(f64))
 max(min(i))
+max(nil ?? $env)
+max(nil ?? 0)
+max(nil ?? 1)
+max(nil ?? 1.0)
+max(nil ?? f64)
+max(ok ? 1 : nil)
+max(ok ? 1.0 : 1)
 max(ok ? 1.0 : nil)
+max(ok ? add : $env)
 max(ok ? f64 : $env)
+max(ok ?? 1.0)
+max(ok ?? f64)
+max(ok ?? foo)
+max(ok ?? i)
 max(reduce($env, i, foo))
 max(reduce(array, #))
 max(reduce(array, #acc))
 max(reduce(array, $env))
+max(reduce(array, $env).String)
 max(reduce(array, 1.0))
 max(reduce(list, 0))
 max(reduce(list, 1.0))
+max(reduce(list, f64))
 max(reverse(array))
+max(round(0))
+max(round(1))
 max(round(1.0))
+max(round(f64))
 max(round(i))
 max(sort($env))
 max(sort(array))
 max(sortBy(array, #))
 max(sortBy(array, 1))
+max(str ?? 0)
+max(str ?? 1.0)
+max(str ?? array)
+max(str ?? foo)
+max(str ?? i)
+max(str ?? list)
+max(sum($env, 1))
+max(sum($env, 1), i)
+max(sum($env, 1.0))
 max(sum($env, f64))
+max(sum($env?.[str]))
 max(sum(array))
 max(sum(array, #))
 max(sum(array, 1.0))
 max(sum(list, f64))
+max(sum(list, i))
 max(true ? array : false)
 max(true ?: list)
+max(true ?? $env?.[str])
+max(true ?? 1)
+max(true ?? add)
+max(true ?? foo)
 max(uniq(array))
 max({foo: $env}?.add)
 max({foo: true, foo: str}?.list)
+mean($env | count(ok))
+mean($env | filter(false))
 mean($env | map(0))
+mean($env | map(1.0))
+mean($env | reduce(1, 1.0))
 mean($env | reduce(1.0, greet))
+mean($env | reduce(array, foo))
 mean($env | reduce(i, nil))
+mean($env | sum(0))
 mean($env.array)
 mean($env.array, median(0))
 mean($env.f64)
@@ -13045,37 +26539,92 @@ mean($env?.f64, array)
 mean($env?.f64, f64)
 mean($env?.i)
 mean($env?.i, mean(f64))
+mean(-0)
+mean(-1)
+mean(-1.0)
+mean(-f64)
+mean(-i)
 mean(0 % 1)
+mean(0 * 0)
 mean(0 * 1)
 mean(0 * 1.0)
+mean(0 * i)
 mean(0 ** 0)
 mean(0 ** 1)
 mean(0 ** f64)
 mean(0 ** f64, i)
+mean(0 + 0)
 mean(0 + f64)
 mean(0 + i)
 mean(0 - 0)
 mean(0 - 1.0)
+mean(0 - f64)
+mean(0 .. 0)
+mean(0 / 0)
 mean(0 / 1)
+mean(0 / 1, i)
+mean(0 / 1.0)
 mean(0 / i)
+mean(0 ?? $env)
+mean(0 ?? 0)
+mean(0 ?? 1)
+mean(0 ?? add)
+mean(0 ?? foo)
+mean(0 ?? foo, $env?.array)
+mean(0 ?? i)
+mean(0 ^ 0)
 mean(0 ^ f64)
+mean(0 ^ i)
+mean(0 | bitand(0))
+mean(0) * f64
+mean(0) .. i
+mean(0) / f64
 mean(0) <= i
 mean(0) == f64
 mean(0) | max(f64)
 mean(0, 1.0) >= 1 == nil
+mean(0..i)
+mean(0.1)
 mean(1 % 1)
 mean(1 % i)
+mean(1 * 0)
+mean(1 * 1.0, i)
+mean(1 * i)
 mean(1 ** 0)
 mean(1 + 1)
 mean(1 + 1.0)
 mean(1 + f64)
+mean(1 + i)
+mean(1 - i)
 mean(1 .. 0)
 mean(1 / 0)
+mean(1 / 1)
 mean(1 / 1.0)
+mean(1 / i)
+mean(1 ?? $env)
+mean(1 ?? 0)
+mean(1 ?? 1)
+mean(1 ?? 1.0)
+mean(1 ?? add)
+mean(1 ?? f64)
+mean(1 ?? false)
+mean(1 ?? foo)
+mean(1 ?? ok)
+mean(1 ?? str)
+mean(1 ?? true)
+mean(1 ^ 1)
 mean(1 ^ 1.0)
 mean(1 ^ f64)
+mean(1 ^ i)
+mean(1) * 1.0 ?? add
 mean(1) * i
 mean(1) ** i
+mean(1) <= f64
+mean(1) == f64
+mean(1) == i + 0 ^ f64
+mean(1) ?? array
+mean(1) ?? i
+mean(1) ?? ok
 mean(1) ^ bitnot(1)
 mean(1) not in array
 mean(1, 1) * f64
@@ -13084,11 +26633,16 @@ mean(1, f64) / f64
 mean(1..i)
 mean(1.0 * 0)
 mean(1.0 * 1)
+mean(1.0 * 1.0)
 mean(1.0 * i)
 mean(1.0 ** 0)
 mean(1.0 ** 1)
+mean(1.0 ** 1.0)
+mean(1.0 ** f64)
 mean(1.0 ** i)
+mean(1.0 + 1)
 mean(1.0 + 1.0)
+mean(1.0 + f64)
 mean(1.0 + i)
 mean(1.0 - 0)
 mean(1.0 - 1)
@@ -13097,48 +26651,104 @@ mean(1.0 - i)
 mean(1.0 / 1)
 mean(1.0 / 1.0)
 mean(1.0 / f64)
+mean(1.0 / i)
+mean(1.0 ?? $env)
+mean(1.0 ?? 1.0)
+mean(1.0 ?? add)
+mean(1.0 ?? array)
+mean(1.0 ?? false)
+mean(1.0 ?? foo)
+mean(1.0 ?? i)
+mean(1.0 ?? list)
+mean(1.0 ?? nil)
+mean(1.0 ?? str)
 mean(1.0 ^ 0)
+mean(1.0 ^ 1)
 mean(1.0 ^ 1.0)
 mean(1.0 ^ f64)
 mean(1.0 ^ i)
 mean(1.0 | max(1.0))
+mean(1.0 | median(array))
+mean(1.0)
 mean(1.0) * i
 mean(1.0) + i
 mean(1.0) / f64
+mean(1.0) == $env or $env
+mean(1.0) > f64
+mean(1.0) >= i
 mean(1.0) >= i || true
+mean(1.0) ?? findIndex($env, $env)
+mean(1.0) ?? greet
+mean(1.0) ?? list
 mean(1.0) ^ i
+mean(1.0) | max(1.0)
 mean(1.0) | max(array)
+mean(1.0, 1.0) < f64
+mean(1.0, 1.0) ?? i
+mean(1.1)
+mean([0, 1.0])
 mean([0, array])
 mean([0])
 mean([1.0])
 mean([1])
+mean([array, 0])
 mean([array])
 mean([f64, i])
+mean([f64])
 mean([i, 1.0])
 mean([i])
+mean(abs(-f64))
 mean(abs(0))
 mean(abs(1))
 mean(abs(1.0))
 mean(abs(f64))
+mean(abs(i))
 mean(abs(i), f64)
+mean(array ?? $env)
+mean(array ?? f64)
+mean(array ?? f64, array)
+mean(array ?? foo)
+mean(array ?? nil)
+mean(array | count(false))
 mean(array | count(true))
+mean(array | filter(ok))
 mean(array | findLastIndex(ok))
 mean(array | map(#index))
+mean(array | map(array))
+mean(array | map(i))
 mean(array | max(0))
 mean(array | max(1.0))
 mean(array | mean(array))
 mean(array | sortBy(#))
 mean(array | sortBy(1))
+mean(array | sum(#))
+mean(array | sum(1.0))
 mean(array)
 mean(array) != add
+mean(array) * f64
+mean(array) .. i
+mean(array) < f64
+mean(array) <= f64
+mean(array) == list
+mean(array) >= f64
+mean(array) >= f64 or ok
+mean(array) ?? i
 mean(array) not in array
 mean(array) | median(array)
+mean(array, -1.0)
 mean(array, array)
 mean(array, f64)
 mean(array, f64, i)
 mean(array, i)
+mean(array, int(1.0))
+mean(array?.[0])
+mean(array?.[1])
 mean(array?.[i])
+mean(array?.[i], i)
 mean(array[:0])
+mean(array[i:0])
+mean(bitand(0, i))
+mean(bitnot(0))
 mean(bitnot(1))
 mean(bitnot(1)) ** f64
 mean(bitnot(i))
@@ -13147,38 +26757,63 @@ mean(bitushr(1, 1))
 mean(ceil(0))
 mean(ceil(1))
 mean(ceil(1.0))
+mean(ceil(abs(f64)))
 mean(ceil(f64))
 mean(ceil(i))
 mean(concat(array))
 mean(f64 * 0)
+mean(f64 * 1)
 mean(f64 * 1.0)
+mean(f64 * i)
+mean(f64 ** 0)
 mean(f64 ** 1.0)
 mean(f64 ** i)
 mean(f64 + 1.0)
+mean(f64 + f64)
 mean(f64 - 1.0)
 mean(f64 - i)
 mean(f64 / 1.0)
+mean(f64 / f64)
+mean(f64 / i)
+mean(f64 ?? $env)
+mean(f64 ?? 1.0)
+mean(f64 ?? greet)
+mean(f64 ?? list)
 mean(f64 ^ 0)
+mean(f64 ^ 1.0)
 mean(f64 | min(1.0))
 mean(f64)
 mean(f64) * i
+mean(f64) ** f64
 mean(f64) - f64
+mean(f64) > f64
 mean(f64) > i
 mean(f64) in $env?.array
 mean(f64, 0) | median(1)
+mean(f64, 1) <= f64
 mean(f64, array)
 mean(f64, f64)
 mean(f64, i)
+mean(f64, reduce(array, 1.0, nil))
+mean(f64, round(i))
 mean(f64, sum(array))
 mean(false ? add : 1.0)
+mean(false ? i : f64)
 mean(false ?: 1)
+mean(filter($env, false))
+mean(filter(array, ok))
 mean(find(array, ok))
 mean(findIndex($env, true))
+mean(findIndex(array, true))
+mean(findLastIndex($env, ok))
 mean(findLastIndex($env, true))
 mean(findLastIndex(array, true))
+mean(findLastIndex(list, ok))
+mean(first(array))
 mean(first(array), i * i)
 mean(flatten(array))
 mean(float(0))
+mean(float(1))
 mean(float(1.0))
 mean(float(f64))
 mean(float(float(f64)))
@@ -13189,41 +26824,82 @@ mean(floor(1.0))
 mean(floor(f64))
 mean(floor(i))
 mean(floor(len(str)))
+mean(i % 1)
 mean(i * 1)
 mean(i * 1.0)
 mean(i ** 0)
 mean(i ** 1.0)
+mean(i ** f64)
 mean(i ** i)
+mean(i + 0)
 mean(i + 1)
 mean(i + 1.0)
+mean(i + i)
 mean(i - 1.0)
+mean(i - f64)
+mean(i .. $env?.i)
 mean(i .. 1)
 mean(i .. i)
 mean(i / 1)
+mean(i / f64)
 mean(i / i)
+mean(i ?? $env)
+mean(i ?? 1.0)
+mean(i ?? array)
+mean(i ?? f64, i)
+mean(i ?? foo)
+mean(i ?? greet)
+mean(i ?? list)
+mean(i ?? nil)
+mean(i ?? str)
+mean(i ?? true)
 mean(i ^ 1.0)
+mean(i | bitxor(i))
 mean(i | max(1, 1.0))
 mean(i | mean(1.0))
 mean(i)
+mean(i) / 1.0 ^ 1.0
+mean(i) <= f64
+mean(i) >= i
+mean(i) ?? $env?.[String]
+mean(i) ^ $env?.i
 mean(i) ^ f64
 mean(i) in array
+mean(i, $env.f64)
+mean(i, -1.0)
+mean(i, 0) + f64
+mean(i, 1 ** f64)
 mean(i, array)
 mean(i, f64)
 mean(i, float(f64))
 mean(i, i)
 mean(i, int(0))
+mean(if false { 1 } else { 0 })
 mean(if ok { 0 } else { foo })
+mean(if ok { 0 } else { nil })
+mean(if ok { f64 } else { 1.0 })
+mean(if true { 1.0 } else { foo })
+mean(if true { f64 } else { false })
 mean(int(0))
 mean(int(1))
 mean(int(1.0))
+mean(int(f64))
 mean(int(i))
 mean(last(array))
+mean(lastIndexOf(str, str))
+mean(len($env))
 mean(len(array))
+mean(len(list))
+mean(let z = f64; 1.0 + z)
+mean(let z = f64; z)
 mean(list | filter(false))
+mean(list | map(1.0))
 mean(list | reduce(1))
 mean(list | reduce(array))
 mean(list | reduce(f64))
+mean(list | sum(1))
 mean(map($env, 1))
+mean(map($env, 1.0))
 mean(map($env, array))
 mean(map($env, f64))
 mean(map(array, #))
@@ -13242,6 +26918,7 @@ mean(mean(0))
 mean(mean(1))
 mean(mean(1.0))
 mean(mean(1.0, 0))
+mean(mean(1.0, f64, i))
 mean(mean(array))
 mean(mean(f64))
 mean(mean(f64, f64))
@@ -13250,53 +26927,96 @@ mean(median(0))
 mean(median(0, f64))
 mean(median(1))
 mean(median(1, 0))
+mean(median(1, 1.0))
 mean(median(1.0))
 mean(median(1.0, f64))
+mean(median(array))
+mean(median(array, 0))
+mean(median(array, 1))
+mean(median(array, f64))
 mean(median(f64))
 mean(median(i))
+mean(min(0))
 mean(min(1))
 mean(min(1, 1.0))
 mean(min(1.0))
 mean(min(1.0, array))
 mean(min(array))
+mean(min(f64))
+mean(min(f64, array))
 mean(min(i))
+mean(nil ?? 0)
+mean(nil ?? 1)
+mean(nil ?? 1.0)
+mean(nil ?? array)
+mean(nil ?? f64)
+mean(reduce($env, 1.0, 1.0))
 mean(reduce($env, i, greet))
 mean(reduce(array, #))
 mean(reduce(array, 1.0))
+mean(reduce(array, array))
+mean(reduce(array, f64, array))
 mean(reduce(list, 1))
 mean(reduce(list, array))
+mean(reverse(array))
+mean(round(0))
 mean(round(1))
 mean(round(1.0))
+mean(round(f64))
+mean(round(i))
 mean(sort($env))
+mean(sort(array))
 mean(sortBy(array, #))
+mean(sortBy(array, 0))
 mean(sortBy(array, 1.0))
 mean(sum($env, 1))
 mean(sum($env, 1.0))
 mean(sum($env, f64))
 mean(sum(array))
 mean(sum(array, #))
+mean(sum(array, 0))
 mean(sum(array, 1.0))
+mean(true ? 0 : ok)
 mean(true ? 0 : str)
+mean(true ? 1.0 : 1)
+mean(uniq(array ?? 1.0))
 mean(uniq(array))
+median($env | count(false))
 median($env | findIndex(true))
 median($env | findLastIndex(ok))
+median($env | map(1))
+median($env | map(1.0))
+median($env | map(i))
+median($env | reduce(f64, greet))
 median($env | sum(0))
 median($env | sum(1.0))
 median($env.array)
 median($env.array, f64)
 median($env.f64)
+median($env.f64, i)
 median($env.i)
 median($env.i, i)
 median($env?.array)
+median($env?.array, array)
 median($env?.f64)
 median($env?.i)
 median($env?.i, $env.i)
+median(-0)
+median(-1)
+median(-1.0 ?? true)
+median(-1.0)
+median(-f64)
+median(-i ?? {foo: foo})
+median(-i)
 median(0 % 1)
+median(0 % i)
+median(0 * 0)
 median(0 * 1)
 median(0 * 1.0)
 median(0 * f64)
 median(0 * i)
 median(0 ** 0)
+median(0 ** 1.0)
 median(0 ** i)
 median(0 + 1)
 median(0 + 1.0)
@@ -13305,20 +27025,45 @@ median(0 - 0)
 median(0 - 1)
 median(0 - 1.0)
 median(0 .. 0)
+median(0 .. 1)
+median(0 .. i)
+median(0 / 0)
 median(0 / 1.0)
 median(0 / i)
+median(0 ?? $env)
+median(0 ?? f64)
+median(0 ?? false)
+median(0 ?? foo)
+median(0 ?? greet)
+median(0 ?? list)
+median(0 ?? nil)
+median(0 ^ $env.i)
 median(0 ^ 1)
+median(0 ^ 1.0)
 median(0 | max(1))
 median(0) * i
+median(0) - f64
 median(0) / f64
+median(0) == f64
+median(0) >= f64
 median(0) >= i
+median(0) ?? trim($env)
 median(0) not in [nil]
+median(0, 0) ?? i
+median(0.0)
+median(0.1)
+median(1 % 1)
+median(1 * 0)
 median(1 * 1)
 median(1 * 1.0)
 median(1 * i)
+median(1 ** 0)
+median(1 ** 1)
+median(1 ** 1.0)
 median(1 ** i)
 median(1 + 0)
 median(1 + 1)
+median(1 + 1.0)
 median(1 + f64)
 median(1 + i)
 median(1 - 0)
@@ -13327,44 +27072,91 @@ median(1 - 1.0)
 median(1 - f64)
 median(1 .. 0)
 median(1 / 1.0)
+median(1 / f64)
+median(1 / i)
+median(1 ?? $env)
+median(1 ?? array)
+median(1 ?? f64)
+median(1 ?? false)
+median(1 ?? foo)
+median(1 ?? greet)
+median(1 ?? str)
 median(1 ^ 0)
 median(1 ^ 0, f64)
+median(1 ^ 1.0)
+median(1 ^ f64)
 median(1 ^ i)
 median(1 | max(array), i)
+median(1 | min(array))
 median(1) != 1.0 && ok
+median(1) != f64
 median(1) ^ $env?.f64
+median(1.0 * 0)
+median(1.0 * 1)
+median(1.0 * 1.0)
 median(1.0 * f64)
+median(1.0 * f64, array | sortBy(1))
 median(1.0 * i)
+median(1.0 ** 0)
 median(1.0 ** 1.0)
 median(1.0 ** f64)
 median(1.0 ** i)
 median(1.0 + 0)
+median(1.0 + 1)
 median(1.0 + 1.0)
 median(1.0 + f64)
 median(1.0 + i)
 median(1.0 - 1)
 median(1.0 - 1.0)
+median(1.0 - f64)
 median(1.0 - i)
+median(1.0 / 0)
 median(1.0 / 1)
 median(1.0 / 1.0)
 median(1.0 / f64)
 median(1.0 / i)
+median(1.0 ?? $env)
+median(1.0 ?? 0, 1.0)
+median(1.0 ?? 1)
+median(1.0 ?? 1.0)
+median(1.0 ?? add)
+median(1.0 ?? false)
+median(1.0 ?? foo)
+median(1.0 ?? greet)
+median(1.0 ?? nil)
+median(1.0 ?? str)
 median(1.0 ^ 1)
 median(1.0 ^ f64)
 median(1.0 ^ i)
 median(1.0 | mean(i))
+median(1.0) * 0 ?? nil
+median(1.0) * 1 + 1
+median(1.0) * f64
+median(1.0) ** f64
 median(1.0) + 1.0 != f64
 median(1.0) + i
 median(1.0) - f64
 median(1.0) / f64
+median(1.0) / i
 median(1.0) <= f64
+median(1.0) <= i
 median(1.0) <= i / 0
+median(1.0) == $env == false
 median(1.0) > 1.0 ? greet : list
 median(1.0) >= f64
+median(1.0) ?? $env.ok
+median(1.0) ?? 1 ?? true
+median(1.0) ?? add
+median(1.0) ?? foo
+median(1.0) ?? greet
+median(1.0) ?? str
 median(1.0) in array
 median(1.0) not in array
+median(1.0) | max(f64)
 median(1.0) | max(i)
 median(1.0, 0) ** f64
+median(1.0, 0) ** i
+median(1.0, 1.0) | mean(i, 0)
 median(1.1)
 median([0])
 median([1 % i])
@@ -13373,6 +27165,8 @@ median([1.0])
 median([1])
 median([1], $env.f64)
 median([array])
+median([f64])
+median([i, 1.0])
 median([i])
 median(abs(0))
 median(abs(1))
@@ -13380,22 +27174,47 @@ median(abs(1.0))
 median(abs(f64))
 median(abs(i))
 median(add(1, 0))
+median(array ?? add)
+median(array ?? array)
+median(array ?? f64)
+median(array ?? false)
+median(array ?? foo)
+median(array ?? nil)
+median(array ?? str)
 median(array | find(ok))
+median(array | findLast(true))
 median(array | map(#))
+median(array | map(1.0))
 median(array | reduce(1.0))
+median(array | reduce(i, 1.0))
 median(array | reduce(i, foo))
 median(array | sortBy(#))
 median(array | sortBy(i))
 median(array | sum(#))
 median(array)
+median(array) != add
 median(array) != ok
+median(array) ** f64
+median(array) ** i
+median(array) + i
+median(array) - 1.0 + i
 median(array) / f64
+median(array) < 0 >= 1.0
 median(array) < i
 median(array) >= i
+median(array) ?? f64
+median(array) ?? not ok
+median(array) ?? ok
 median(array) ^ f64
+median(array) | get(nil)
 median(array, $env?.i)
+median(array, -0)
+median(array, -i)
+median(array, 1 ^ 1)
 median(array, array)
+median(array, array) not endsWith $env?.[Bar]
 median(array, f64)
+median(array, i % i)
 median(array, i .. 0)
 median(array, i)
 median(array?.[i])
@@ -13405,29 +27224,55 @@ median(bitand(1, 1))
 median(bitnot(0))
 median(bitnot(1))
 median(bitnot(i))
+median(bitxor(0, 0))
 median(ceil($env.i))
 median(ceil(0))
 median(ceil(1.0))
 median(ceil(f64))
 median(ceil(i))
 median(concat(array))
+median(count($env, false))
+median(count(array, ok))
 median(count(array[0:0]))
+median(count(list, ok))
 median(f64 * $env?.f64)
+median(f64 * 1.0)
 median(f64 * f64)
 median(f64 ** $env?.i)
+median(f64 ** 0)
+median(f64 ** 1)
 median(f64 ** 1.0)
+median(f64 + 0)
 median(f64 + 1.0)
 median(f64 + f64)
+median(f64 + i)
+median(f64 - 0)
+median(f64 - 1)
 median(f64 - 1.0)
 median(f64 - i)
+median(f64 / 0)
 median(f64 / 1.0)
 median(f64 / f64)
+median(f64 / i)
+median(f64 ?? 1)
+median(f64 ?? 1.0)
+median(f64 ?? array)
+median(f64 ?? date(foo))
+median(f64 ?? false)
+median(f64 ?? i)
+median(f64 ?? str)
+median(f64 ^ 0)
 median(f64 ^ 1)
+median(f64 ^ 1.0)
 median(f64 ^ f64)
+median(f64 ^ i)
 median(f64 | min(1.0))
 median(f64)
 median(f64) + i
 median(f64) < f64
+median(f64) == 1.0 and ok
+median(f64) > i
+median(f64) ?? array
 median(f64, array)
 median(f64, array) / 0 == 0
 median(f64, f64)
@@ -13435,8 +27280,13 @@ median(f64, i)
 median(f64, i) + i
 median(f64, i, 1 - 0)
 median(f64, list | sum(i))
+median(f64, min(f64))
 median(filter(list, false))
+median(find(array, ok))
 median(findIndex($env, true))
+median(findLastIndex($env, ok))
+median(findLastIndex($env, true))
+median(findLastIndex(list, true))
 median(first(array))
 median(flatten(array))
 median(float(0))
@@ -13453,20 +27303,44 @@ median(i % i)
 median(i * 0)
 median(i * 1)
 median(i * 1.0)
+median(i * f64)
+median(i * i)
 median(i ** 0)
+median(i ** 1.0)
+median(i ** i)
+median(i + 0)
 median(i + 1)
 median(i - 1.0)
 median(i - i)
 median(i .. i)
 median(i / 0)
 median(i / 1.0)
+median(i ?? $env?.ok)
+median(i ?? 0)
+median(i ?? 1.0)
+median(i ?? foo?.Bar)
+median(i ?? i)
+median(i ?? ok)
+median(i ?? str)
+median(i ^ 0)
 median(i ^ 1.0)
 median(i ^ f64)
 median(i ^ i)
 median(i | bitnand(i))
+median(i | bitshr(1))
+median(i | min(f64))
 median(i)
+median(i) * i
+median(i) ?? f64
+median(i) ?? list
+median(i) ^ i
+median(i) in $env?.array
+median(i) | mean(array)
 median(i) | median(array)
 median(i) | min(f64)
+median(i, $env.i)
+median(i, -i)
+median(i, 1.0) < i
 median(i, array)
 median(i, f64)
 median(i, floor(1))
@@ -13474,6 +27348,7 @@ median(i, i)
 median(i..i)
 median(if false { $env } else { 1 })
 median(if false { 1.0 } else { i })
+median(if false { str } else { i })
 median(int(1))
 median(int(1.0))
 median(int(1.0), array)
@@ -13481,16 +27356,31 @@ median(int(f64))
 median(int(i))
 median(last(array))
 median(len($env))
+median(len(list))
+median(len(str))
+median(let bar = 1.0; let foobar = 0; bar)
+median(let bar = 1; bar)
+median(let foobar = 0; foobar)
+median(let z = 1; z)
+median(list | count(ok))
+median(list | map(#index))
 median(list | map(array))
 median(list | reduce(i))
+median(list | sum(0))
+median(map($env, 0))
 median(map($env, 1))
+median(map($env, 1.0))
 median(map($env, f64))
+median(map(array, 1))
+median(map(list, 0))
 median(map(list, 1.0))
 median(max(0))
 median(max(1))
 median(max(1.0))
 median(max(1.0, i))
+median(max(array))
 median(max(i))
+median(max(i), array)
 median(mean(0))
 median(mean(1))
 median(mean(1.0))
@@ -13499,18 +27389,28 @@ median(mean(array))
 median(mean(f64))
 median(mean(i))
 median(median(0))
+median(median(1))
 median(median(1, 1.0))
 median(median(1.0))
 median(median(array))
+median(median(f64))
 median(median(f64, i))
 median(median(i))
 median(min(0 * 1))
 median(min(0))
 median(min(1))
+median(min(1.0, array, 1))
 median(min(array))
 median(min(f64))
+median(min(f64, 1.0))
 median(min(i))
+median(nil ?? 0)
+median(nil ?? 1)
+median(nil ?? 1.0)
+median(nil ?? f64)
+median(ok ? 1.0 : greet)
 median(reduce(array, #))
+median(reduce(array, #index))
 median(reduce(array, i))
 median(reduce(list, #index))
 median(reduce(list, 1.0))
@@ -13522,73 +27422,133 @@ median(round(f64))
 median(round(i))
 median(sort($env))
 median(sort(array))
+median(sortBy(array, 1))
+median(sortBy(array, f64))
+median(sum($env, 0))
 median(sum($env, 1.0))
+median(sum($env, f64))
+median(sum($env, i))
 median(sum(array))
 median(sum(array), f64)
+median(sum(array), i)
 median(sum(array, #))
+median(sum(array, 1.0))
 median(sum(list, i))
 median(true ? 0 : 1.0, f64)
+median(true ? 0 : ok)
+median(true ? i : foo)
 median(uniq(array))
+median({foo: 1.0}?.foo)
+min($env ?? 0)
+min($env ?? 1)?.ok
+min($env ?? add)
+min($env ?? f64)
+min($env ?? false)
+min($env ?? foo)
+min($env ?? greet)
+min($env ?? i)
+min($env ?? ok)
+min($env ?? true)
+min($env | filter(false))
 min($env | findIndex(false))
+min($env | findIndex(true))
+min($env | findLast(false))
+min($env | get(str))
+min($env | map(0))
 min($env | map(1))
 min($env | map(1.0))
 min($env | reduce(array, 1))
 min($env | sum(1.0))
 min($env | sum(f64))
+min($env | sum(i))
 min($env) != array
 min($env) == greet
 min($env) == i
+min($env) == ok
+min($env) ?? uniq($env)
+min($env) matches $env?.foobar
+min($env) not contains $env || true
+min($env) not in list
 min($env) | all(false)
 min($env) | any(false)
 min($env) | count(ok)
+min($env) | map(1)
+min($env) | map(add)
 min($env) | map(f64)
+min($env) | map(false)
+min($env) | map(foo)
+min($env) | map(ok)
 min($env) | reduce(0, 1)
+min($env) | reduce(1.0, $env)
 min($env) | sum(0)
+min($env) | sum(1.0)
 min($env).Bar
+min($env).Bar?.greet()
 min($env).String
+min($env).String?.[greet]
 min($env).add
 min($env).array
 min($env).f64
+min($env).false?.add
 min($env).false?.f64
 min($env).foo
 min($env).foobar
+min($env).foobar?.i(foobar, foobar)
 min($env).foobar?.ok
 min($env).greet
 min($env).i
+min($env).i && false
 min($env).list
 min($env).nil?.foobar
 min($env).ok
 min($env).str
+min($env)?.$env?.Bar()
 min($env)?.Bar
 min($env)?.Bar?.foobar.foo().list
 min($env)?.String
+min($env)?.String?.foo
 min($env)?.[str]
+min($env)?.[str] not startsWith str
 min($env)?.add
 min($env)?.array
 min($env)?.f64
 min($env)?.foo
 min($env)?.foobar
+min($env)?.foobar?.String()
 min($env)?.foobar?.foo.i
+min($env)?.foobar?.list
+min($env)?.foobar?.str
 min($env)?.greet
+min($env)?.greet(foobar)
 min($env)?.i
 min($env)?.list
 min($env)?.not
 min($env)?.ok
 min($env)?.str
+min($env)?.true?.f64(foobar)
 min($env.array)
 min($env.array, sum(array))
 min($env.f64)
 min($env.i)
+min($env.i, i)
 min($env?.$env)
 min($env?.Bar)
+min($env?.Bar?.array())
+min($env?.Bar?.foo)
+min($env?.Bar?.greet())
 min($env?.String)
+min($env?.String)?.[i]
+min($env?.String?.list)
 min($env?.[Bar])
 min($env?.[Bar])?.add()
 min($env?.[Bar]?.Bar)
 min($env?.[Bar]?.[greet])
+min($env?.[Bar]?.i())
 min($env?.[String])
 min($env?.[String])?.f64
 min($env?.[foobar])
+min($env?.[foobar])?.[str]
+min($env?.[nil])
 min($env?.[str])
 min($env?.array)
 min($env?.f64)
@@ -13598,51 +27558,103 @@ min($env?.foobar)
 min($env?.i)
 min($env?.nil)
 min($env?.true)
+min(-0)
+min(-1)
+min(-1.0 ** 1)
+min(-1.0 + i)
+min(-1.0)
+min(-f64)
+min(-i)
+min(0 % 1)
+min(0 % i)
+min(0 * 0)
 min(0 * 1)
 min(0 * 1.0)
 min(0 * f64)
+min(0 * i)
 min(0 ** 0)
 min(0 ** 1.0)
 min(0 ** i)
+min(0 + 1)
+min(0 + 1.0)
 min(0 + f64)
+min(0 - 1)
 min(0 - 1.0)
 min(0 - f64)
 min(0 - i)
+min(0 .. 0)
+min(0 .. 1)
 min(0 .. i)
 min(0 / 0)
+min(0 / 1)
+min(0 ?? 1.0)
+min(0 ?? false)
+min(0 ?? foo)
+min(0 ?? true)
+min(0 ^ 0)
 min(0 ^ 1)
 min(0 | bitshl(1))
+min(0 | median(1))
+min(0) != $env?.i
 min(0) * 0 < f64
 min(0) * f64
 min(0) ** f64
 min(0) + i
 min(0) - ceil(i)
+min(0) / f64
 min(0) ^ f64
 min(0) in array
 min(0) | max(0)
+min(0, array) != str
 min(0.0)
+min(1 % 1)
 min(1 * 1)
+min(1 * 1.0)
 min(1 ** 0)
+min(1 ** 1)
 min(1 ** 1.0)
+min(1 ** f64)
 min(1 ** i)
+min(1 + 0)
 min(1 + 1.0)
+min(1 - 1)
 min(1 - f64)
+min(1 .. i)
 min(1 / 0)
 min(1 / 1)
 min(1 / 1.0)
 min(1 / i)
+min(1 ?? 0)
+min(1 ?? 1.0)
+min(1 ?? add)
+min(1 ?? foo)
+min(1 ?? greet)
+min(1 ?? nil)
+min(1 ?? ok)
 min(1 ^ 0)
+min(1 ^ 1.0)
+min(1 ^ i)
 min(1 | min(1.0))
 min(1) % i
+min(1) + f64
+min(1) - i
 min(1) < f64
 min(1) < i
 min(1) <= i
+min(1) ?? i
+min(1) not in array
+min(1) | median(array)
+min(1, 1) - i
 min(1, 1.0) in array
+min(1, array) | get(ok)
 min(1..i)
+min(1.0 * 0)
+min(1.0 * 1)
 min(1.0 * 1.0)
 min(1.0 * f64)
 min(1.0 ** 0)
 min(1.0 ** 1)
+min(1.0 ** 1.0)
 min(1.0 ** i)
 min(1.0 + 0)
 min(1.0 + 1)
@@ -13655,19 +27667,55 @@ min(1.0 - i)
 min(1.0 / 1)
 min(1.0 / 1.0)
 min(1.0 / f64)
+min(1.0 ?? $env?.[greet])
+min(1.0 ?? 0)
+min(1.0 ?? 1)
+min(1.0 ?? add)
+min(1.0 ?? array)
+min(1.0 ?? f64)
+min(1.0 ?? foo)
+min(1.0 ?? list)
+min(1.0 ?? nil)
+min(1.0 ?? ok)
+min(1.0 ?? ok, array)
+min(1.0 ?? str)
+min(1.0 ?? true)
+min(1.0 ^ 0)
 min(1.0 ^ 1)
 min(1.0 ^ 1.0)
 min(1.0 ^ f64)
+min(1.0 ^ i)
+min(1.0 | max(0))
+min(1.0 | max(1))
 min(1.0 | max(array))
+min(1.0 | mean(1.0))
 min(1.0 | min(1.0))
+min(1.0) * bitand(i, i)
+min(1.0) * f64
+min(1.0) ** f64
 min(1.0) ** i
 min(1.0) - f64
 min(1.0) <= 1.0 + 0
 min(1.0) > i
 min(1.0) >= i
+min(1.0) ?? add
+min(1.0) ?? f64
+min(1.0) ?? greet
+min(1.0) ?? list
+min(1.0) ?? str
+min(1.0) ^ i
 min(1.0) not in array
+min(1.0) | max(array, 1.0)
+min(1.0) | median(array)
 min(1.0, 0) + i
+min(1.0, 0) ?? ok
+min(1.0, 1) - f64
+min(1.0, 1.0) ** f64 ?? true
+min(1.0, 1.0) + i
+min(1.0, 1.0) - 0 < 1.0
+min(1.0, 1.0) ^ f64
 min(1.1)
+min([$env] | reduce(.f64))
 min([0])
 min([1.0])
 min([1])
@@ -13679,11 +27727,24 @@ min(abs(0))
 min(abs(1))
 min(abs(1.0))
 min(abs(f64))
+min(abs(i))
+min(add ?? 1.0)
+min(add ?? array)
+min(add ?? f64)
+min(add ?? foo)
 min(add(0, 0))
+min(add(1, 1))
+min(array ?? $env?.[greet(f64)])
+min(array ?? 0)
+min(array ?? nil)
+min(array | count(true))
+min(array | filter(true))
 min(array | find(ok))
 min(array | findIndex(false))
 min(array | findIndex(ok))
 min(array | map(#))
+min(array | map(i))
+min(array | max(1.0, 0))
 min(array | reduce(#))
 min(array | reduce(0))
 min(array | reduce(1.0))
@@ -13691,52 +27752,96 @@ min(array | sortBy(0))
 min(array | sortBy(1.0))
 min(array | sum(#))
 min(array | sum(1.0))
+min(array | sum(f64))
 min(array)
+min(array) + f64
+min(array) - i
 min(array) .. i
 min(array) / i
 min(array) < 1.0 - i
+min(array) == i
+min(array) ?? f64
+min(array) ?? ok
 min(array) | bitushr(0)
+min(array) | get(0)
 min(array) | get(str)
 min(array) | median(0)
 min(array, 1 - 0)
+min(array, 1.0 ?? 0)
 min(array, array)
+min(array, array, 1) == f64
 min(array, ceil(0))
+min(array, f64 * i)
 min(array, f64)
 min(array, float(1.0))
+min(array, i ?? 1.0)
 min(array, i)
 min(array, int(0))
 min(array, sortBy(array, #))
+min(array?.[0])
+min(array?.[1])
 min(array?.[i])
+min(array[0:])
 min(array[:0])?.[greet]
 min(array[min(1):])
+min(bitnot(0))
 min(bitnot(1))
 min(bitnot(i))
+min(ceil(0))
 min(ceil(1))
 min(ceil(1.0))
 min(ceil(f64))
 min(ceil(i))
+min(ceil(sum(array)), i)
 min(count($env, false))
 min(count($env, ok))
+min(count([true]))
+min(count(array, false))
+min(f64 * 0)
+min(f64 * 1)
 min(f64 * f64)
+min(f64 * i)
 min(f64 ** 1)
 min(f64 ** 1.0)
 min(f64 ** f64)
+min(f64 ** i)
 min(f64 + 0)
 min(f64 + 1.0)
 min(f64 + f64)
 min(f64 - 0)
 min(f64 - 1.0)
 min(f64 - i)
+min(f64 / 0)
 min(f64 / 1)
 min(f64 / 1.0)
+min(f64 ?? $env)
+min(f64 ?? 1)
+min(f64 ?? 1.0)
+min(f64 ?? add, i)
+min(f64 ?? array)
+min(f64 ?? false)
+min(f64 ?? foo)
+min(f64 ?? ok)
+min(f64 ?? true)
 min(f64 ^ 0)
 min(f64 ^ 1)
 min(f64 ^ 1.0)
 min(f64 ^ f64)
 min(f64 ^ i)
+min(f64 | min(0))
 min(f64)
+min(f64) * i
+min(f64) / f64
+min(f64) < i
 min(f64) <= $env.i
+min(f64) >= i
+min(f64) ?? greet
 min(f64) not in array
+min(f64) | median(1.0)
+min(f64, $env.array)
+min(f64, $env.f64)
+min(f64, -1)
+min(f64, 0) == f64
 min(f64, 1.0 / 1.0)
 min(f64, abs(f64))
 min(f64, array)
@@ -13745,13 +27850,29 @@ min(f64, i)
 min(f64, min(1.0))
 min(false ? 0 : greet)
 min(false ? 0 : nil)
+min(false ? 1 : 1.0)
 min(false ? array : nil)
+min(false ? foo : $env).i
 min(false ? greet : foo)
+min(false ?: 0)
+min(false ?? 1.0)
+min(false ?? add)
+min(false ?? array)
+min(false ?? list)
+min(findIndex($env, false))
+min(findIndex($env, true))
+min(findIndex(array, true))
+min(findIndex(list, false))
 min(findLast(array, false))
+min(findLast(array, true))
+min(findLastIndex($env, false))
 min(findLastIndex($env, true))
 min(first($env))
 min(first(array))
+min(first(str ?? add))
 min(flatten(array))
+min(flatten(array), f64)
+min(float(0))
 min(float(1))
 min(float(1.0))
 min(float(f64))
@@ -13760,28 +27881,68 @@ min(floor(1.0 + i))
 min(floor(1.0))
 min(floor(f64))
 min(floor(i))
+min(foo ?? $env)
+min(foo ?? 0)
+min(foo ?? 1)
+min(foo ?? add)
+min(foo ?? f64)
+min(foo ?? false)
+min(foo ?? greet)
+min(foo ?? list)
+min(foo ?? ok)
+min(foo ?? str)
+min(foo ?? true)
+min(greet ?? 1.0)
+min(greet ?? add)
+min(greet ?? f64)
+min(greet ?? foo)
 min(groupBy(array, #)?.array)
+min(i % 1)
 min(i % i)
+min(i * 0)
 min(i * f64)
 min(i * i)
 min(i + 1.0)
+min(i + f64)
 min(i + i)
 min(i - 0)
+min(i - 1.0)
 min(i - f64)
 min(i - i)
 min(i .. 0)
 min(i / 1.0)
+min(i ?? $env)
+min(i ?? f64)
+min(i ?? false)
+min(i ?? foo)
+min(i ?? ok)
+min(i ?? str)
+min(i ?? true)
 min(i ^ 1.0)
+min(i ^ i)
 min(i | bitor(0))
 min(i | bitshr(1))
 min(i | min(0))
 min(i)
 min(i) != $env?.i
+min(i) != f64
 min(i) % i
+min(i) < f64
 min(i) < i
 min(i) <= f64
+min(i) == f64
+min(i) ?? [0]
+min(i) ?? foo
+min(i) ?? foo.Bar
+min(i) ?? foo?.Bar
+min(i, $env.i)
+min(i, 1 ?? 0)
+min(i, [1])
 min(i, array)
 min(i, array) .. i
+min(i, array) ^ i <= 1.0
+min(i, f64 ** 1)
+min(i, f64 / i)
 min(i, f64)
 min(i, i)
 min(i, max(sum(array)))
@@ -13794,6 +27955,7 @@ min(if true { greet } else { 1.0 })
 min(int(0))
 min(int(1))
 min(int(1.0))
+min(int(f64))
 min(int(i))
 min(last($env))
 min(last(array))
@@ -13804,21 +27966,28 @@ min(len(str))
 min(list | count(false))
 min(list | count(true))
 min(list | findIndex(false))
+min(list | map(1))
+min(list | map(1.0))
+min(list | map(i))
+min(list | reduce($env))
 min(list | reduce(1))
 min(list | reduce(1.0))
 min(list | reduce(array))
 min(list | sum(1))
 min(list[1:1])
 min(map($env, 0))
+min(map($env, 1.0))
 min(map($env, array))
 min(map(array, #))
 min(map(array, #index))
 min(map(array, 1.0))
+min(map(list, #index))
 min(map(list, f64))
 min(max($env))
 min(max(0))
 min(max(0, 1))
 min(max(0, 1.0, 0))
+min(max(0, i))
 min(max(1))
 min(max(1.0))
 min(max(1.0, 1.0))
@@ -13828,6 +27997,7 @@ min(max(i))
 min(mean(0))
 min(mean(1))
 min(mean(1.0))
+min(mean(1.0, 1.0))
 min(mean(array))
 min(mean(f64))
 min(mean(i))
@@ -13836,15 +28006,29 @@ min(median(1))
 min(median(1.0))
 min(median(array))
 min(median(f64))
+min(median(i))
 min(min($env))
 min(min(0))
+min(min(1))
 min(min(1.0))
 min(min(1.0, 1))
 min(min(f64))
 min(min(f64, 1.0))
+min(min(f64, 1.0, 1.0))
 min(min(i))
+min(nil ?? $env)
+min(nil ?? f64)
+min(nil ?? i)
+min(ok ? array : true)
 min(ok ?: 1.0)
+min(ok ?? 1)
+min(ok ?? i)
+min(ok ?? toJSON(list))
+min(reduce(array, #))
+min(reduce(array, $env))?.str
+min(reduce(array, 1.0))
 min(reduce(array, i))
+min(reduce(list, 1.0))
 min(reduce(list, f64))
 min(reduce(list, f64), $env?.array)
 min(reverse(array))
@@ -13853,25 +28037,48 @@ min(round(0), array)
 min(round(1))
 min(round(1.0))
 min(round(f64))
+min(round(i))
+min(sort($env))
 min(sort(array))
+min(sortBy(array, #))
+min(sortBy(array, 1))
 min(sortBy(array, f64))
+min(sortBy(array, str), i)
+min(sortBy(array, toJSON(foo)))
+min(str ?? $env)
+min(str ?? 1.0)
+min(str ?? false)
+min(str ?? foo)
+min(str ?? i)
+min(str ?? list)
 min(sum($env, 1))
 min(sum($env, 1.0))
+min(sum($env?.array))
 min(sum(array))
 min(sum(array), array)
 min(sum(array, #))
 min(sum(array, 1.0))
 min(sum(list, 1))
 min(sum(list, f64))
+min(true ? 0 : foo)
 min(true ? 1.0 : str)
+min(true ? nil : $env)
 min(true ? nil : i)
 min(true ?: add)
+min(true ?: foo)
+min(true ?? 1)
+min(true ?? foo)
+min(true ?? list)
+min(true ?? str)
 min(uniq(array))
 min({foo: 0}.foo)
+min({foo: 1.0}.array)
 min({foo: add}.i)
 min({foo: i}?.i)
 min({foo: nil}?.i)
+min({foo: str}?.list)
 min({foo: sum(array)}.array)
+nil != $env ?? add
 nil != $env.add
 nil != $env.array
 nil != $env.f64
@@ -13882,52 +28089,110 @@ nil != $env.list
 nil != $env.ok
 nil != $env.str
 nil != $env?.Bar
+nil != $env?.Bar?.[i]
+nil != $env?.Bar?.list()
+nil != $env?.Bar?.str()
 nil != $env?.String
+nil != $env?.String?.[i]
 nil != $env?.[1.0 | first(nil)]
 nil != $env?.[Bar]
+nil != $env?.[Bar]?.Bar
 nil != $env?.[String]
+nil != $env?.[String]?.foo
 nil != $env?.[foobar]
 nil != $env?.[greet(foobar)]
 nil != $env?.[str]
 nil != $env?.add
 nil != $env?.array
+nil != $env?.array && true
 nil != $env?.f64
+nil != $env?.false?.[str]
 nil != $env?.foo
+nil != $env?.foobar
+nil != $env?.foobar?.greet(1.0)
 nil != $env?.greet
 nil != $env?.i
 nil != $env?.list
 nil != $env?.ok
 nil != $env?.str
+nil != 0 && ok
+nil != 0 ** i
 nil != 0 - i
 nil != 0 / f64
 nil != 0 ?: array
 nil != 0 ^ $env?.i
 nil != 1 % i
+nil != 1 + f64
+nil != 1 + i
+nil != 1 ?? foo
+nil != 1 ^ i
+nil != 1.0 && ok
+nil != 1.0 + f64
+nil != 1.0 - f64
 nil != 1.0 ?: reduce($env, #.String, true)
+nil != 1.0 ?? ok
 nil != 1.0 ^ f64
+nil != 1.0 and ok
 nil != 1.0 or 1.0 == 1
+nil != add ?? ok
 nil != add and ok
+nil != array ?: i ^ 1.0
+nil != array ?? i
 nil != array?.[i]
+nil != f64 + i
+nil != f64 - f64 == nil
 nil != f64 / f64 && ok
+nil != f64 ?? -1
+nil != f64 ?? foo
+nil != f64 not in $env?.String
 nil != f64 or i == i
+nil != false == ok
+nil != false ?? add
+nil != false ?? foo
 nil != false || $env > $env
+nil != foo == ok
 nil != foo ?: greet
 nil != foo ?: list
+nil != foo ?? foo
+nil != foo or $env?.[add]
+nil != foo || 1 == $env?.[ok]
+nil != foo || i == f64
 nil != foo.Bar
 nil != foo.String
 nil != foo.String()
 nil != foo?.Bar
 nil != foo?.String
 nil != foo?.String()
+nil != greet && false != nil
+nil != greet == ok
 nil != greet ?: i
+nil != greet ?? add
+nil != i && f64 < 1.0
+nil != i + i
+nil != i .. $env?.i
+nil != i ?? greet
+nil != list or one($env, #.f64)
+nil != list?.[-i]
 nil != list?.[i]
 nil != list?.[i]?.Bar
 nil != list?.[i]?.String
 nil != list[:]
 nil != nil && $env?.[array]
+nil != nil && ok
+nil != nil ?? array
+nil != nil ?? i
+nil != nil ?? str
 nil != ok || abs($env)
 nil != str && get($env, nil)
+nil != str ?? foo
+nil != str or $env * i
+nil != str[:]
+nil != true ?? i
 nil != true || $env == 1.0
+nil == $env ?? add
+nil == $env ?? array
+nil == $env ?? ok
+nil == $env ?? str == false
 nil == $env or f64 < 1.0
 nil == $env.add
 nil == $env.array
@@ -13941,10 +28206,12 @@ nil == $env.str
 nil == $env?.Bar
 nil == $env?.String
 nil == $env?.String?.[list]
+nil == $env?.String?.ok
 nil == $env?.[Bar]
 nil == $env?.[String]
 nil == $env?.[foo.Bar]
 nil == $env?.[foobar?.[i]]
+nil == $env?.[foobar?.array]
 nil == $env?.[foobar]
 nil == $env?.[str]
 nil == $env?.add
@@ -13953,20 +28220,48 @@ nil == $env?.f64
 nil == $env?.foo
 nil == $env?.foobar
 nil == $env?.foobar?.add(foobar, foobar)
+nil == $env?.foobar?.i
 nil == $env?.greet
 nil == $env?.i
 nil == $env?.list
+nil == $env?.nil?.[foo]
 nil == $env?.ok
 nil == $env?.str
+nil == 0 != foo ?? greet
 nil == 0 ** 1.0 ? nil : nil
+nil == 0 ?? $env?.add
 nil == 0 || ok
 nil == 1 * i
+nil == 1 + f64
+nil == 1 / i
 nil == 1 and find($env, #.add)?.[i]
+nil == 1 || 0 > i
+nil == 1..i
+nil == 1.0 ** f64
+nil == 1.0 + f64
 nil == 1.0 ?: i
+nil == 1.0 ?: str
+nil == 1.0 ?? string(nil)
 nil == 1.0 ^ f64
+nil == 1.0 and ok
+nil == add ?: i
+nil == add and ok
+nil == add or foo ?? f64
+nil == array ?? add
 nil == array?.[i]
 nil == f64 * f64
+nil == f64 + f64
+nil == f64 - f64
+nil == f64 ?: ok
+nil == f64 ?? greet
+nil == false && list != $env
+nil == false ?? array
+nil == foo != foo ?? greet
 nil == foo != ok
+nil == foo ?: i
+nil == foo ?? 1.0 ?? true
+nil == foo ?? add
+nil == foo ?? greet($env)
 nil == foo and ok
 nil == foo.Bar
 nil == foo.String
@@ -13975,29 +28270,123 @@ nil == foo?.Bar
 nil == foo?.String
 nil == foo?.String()
 nil == greet != $env?.Bar
+nil == greet ?? map($env, #.f64)
 nil == greet and $env?.[list]
 nil == greet or ok
+nil == i != ok
 nil == i + i
 nil == i and ok
 nil == i in $env?.[String]
+nil == list ?? list
 nil == list?.[i]
+nil == list[:]
 nil == nil != $env?.[String]
 nil == nil != nil || false
 nil == nil and ok
 nil == ok != ok
 nil == str != false || true
+nil == str ?? add
+nil == true ?? ok
+nil ?? $env ?? $env?.[array][foobar:]
+nil ?? $env ?? str
+nil ?? $env | findLastIndex(true)
+nil ?? $env | map(0)
+nil ?? $env | map(1)
+nil ?? $env | map(1.0)
+nil ?? $env | map(add)
+nil ?? $env | map(list)
+nil ?? $env | one(ok)
+nil ?? $env | sum(f64)
+nil ?? $env.add
+nil ?? $env.array
+nil ?? $env.f64
+nil ?? $env.foo
+nil ?? $env.greet
+nil ?? $env.i
+nil ?? $env.list
+nil ?? $env.ok
+nil ?? $env.str
+nil ?? $env?.Bar
+nil ?? $env?.String
+nil ?? $env?.[Bar]
+nil ?? $env?.[String]
+nil ?? $env?.[foobar]
+nil ?? $env?.[str]
+nil ?? $env?.add
+nil ?? $env?.array
+nil ?? $env?.f64
+nil ?? $env?.foo
+nil ?? $env?.foobar
+nil ?? $env?.foobar?.i
+nil ?? $env?.greet
+nil ?? $env?.i
+nil ?? $env?.list
+nil ?? $env?.ok
+nil ?? $env?.str
+nil ?? 0 | min(1.0)
+nil ?? 1 ?? array
+nil ?? 1.0 ?? trimSuffix(str)
+nil ?? array ?? str
+nil ?? array | groupBy(1.0)
+nil ?? array | map(#)
+nil ?? array | map(true)
+nil ?? array | one(ok)
+nil ?? array | reduce(#, false)
+nil ?? array | reduce(greet, $env)
+nil ?? array | reduce(list)
+nil ?? array | sortBy(1.0)
+nil ?? array | sum(i)
+nil ?? array?.[i]
+nil ?? f64 ?? i
+nil ?? foo ?? $env.list
+nil ?? foo.Bar
+nil ?? foo.String
+nil ?? foo.String()
+nil ?? foo?.Bar
+nil ?? foo?.String
+nil ?? foo?.String()
+nil ?? greet ?? add
+nil ?? i | median(f64)
+nil ?? list ?? add
+nil ?? list ?? {foo: foo}
+nil ?? list | groupBy(#)
+nil ?? list | groupBy(ok)
+nil ?? list | groupBy(true)
+nil ?? list | map(f64)
+nil ?? list | map(str)
+nil ?? list | reduce(#acc)
+nil ?? list | reduce(1.0, $env)
+nil ?? list | sortBy(.Bar)
+nil ?? list | sum(0)
+nil ?? list?.[i]
+nil ?? nil ?? foo
+nil ?? ok ?? ok
+nil ?? str ?? str
+nil ?? str | repeat(0)
+nil in $env != ok
+nil in $env ?? str
+nil in $env or ok
 nil in $env.array
 nil in $env.list
 nil in $env?.Bar
+nil in $env?.Bar?.[greet]
 nil in $env?.String
 nil in $env?.[Bar]
+nil in $env?.[Bar]?.[array]
 nil in $env?.[String]
+nil in $env?.[String]?.list
+nil in $env?.[foobar?.f64]
+nil in $env?.[foobar]
 nil in $env?.array
 nil in $env?.foobar?.i(false)
 nil in $env?.list
+nil in array ?? greet
+nil in array ?? toJSON(str)
 nil in list && ok
 nil in list and $env == foo
+nil in list and ok
 nil in list or ok
+nil not in $env ?: str
 nil not in $env or ok
 nil not in $env || 0 <= $env
 nil not in $env.array
@@ -14014,42 +28403,76 @@ nil not in $env?.array
 nil not in $env?.foobar?.[list]
 nil not in $env?.foobar?.add(nil, f64)
 nil not in $env?.list
+nil not in array != ok
 nil not in array ?: i
 nil not in list[i:]
 nil; $env.greet
 nil; $env.ok
+nil; array | reduce(1.0, 1.0)
 none($env | map($env), .f64 != foo)
+none($env, false) != ok
 none($env, false) && ok == true
+none($env.array, # == 1.0)
 none($env.array, str not in $env)
+none($env.list, 1.0 <= 1.0)
 none($env?.[str], 1 > f64)
 none($env?.[str], ok)
+none($env?.list, f64 == $env)
+none($env?.list, ok)
 none(1 .. 0, $env < $env)
 none(1 .. 0, $env | all(ok))
+none(1 .. i, !false)
 none([$env, foo], false != #)
 none([$env], .f64 in #.String)
 none([1.0], ok)
+none([array, false], true and ok)
+none([f64, nil], ok)
+none([false], #)
 none([greet, 1.0], ok)
 none([nil, foo], ok)
+none(array | map(0), ok)
+none(array, !true)
 none(array, # != #)
 none(array, # != 0)
 none(array, # != nil)
+none(array, # < #)
 none(array, # < 1)
 none(array, # <= #)
 none(array, # == 0)
+none(array, # == nil)
+none(array, # > #)
 none(array, # >= #)
+none(array, # >= f64)
+none(array, # >= i)
 none(array, $env == foo)
+none(array, $env || true)
 none(array, $env.ok)
 none(array, 0 <= 0)
 none(array, 1 == #)
+none(array, 1.0 != 1.0)
+none(array, 1.0 < #)
+none(array, 1.0 <= #)
+none(array, 1.0 == $env)
 none(array, add == add)
 none(array, f64 == #)
+none(array, false ?? add)
+none(array, foo != nil)
 none(array, i != #)
+none(array, i != nil)
 none(array, i < #)
+none(array, i >= #)
+none(array, nil != 1)
+none(array, nil == add)
+none(array, nil == false)
 none(array, nil == i)
+none(array, not false)
 none(array, ok && false)
+none(array, ok ?? i)
 none(array, ok)
 none(concat(array), f64 >= #)
 none(flatten(array), ok)
+none(if true { list } else { greet }, list != list)
+none(list ?? ok, ok)
 none(list | map($env), #.ok)
 none(list | map(str), ok)
 none(list, # != foo)
@@ -14058,49 +28481,388 @@ none(list, $env != $env)
 none(list, $env != i)
 none(list, $env != nil)
 none(list, $env.ok)
+none(list, $env?.ok)
+none(list, .Bar not in #)
+none(list, .Bar startsWith str)
 none(list, 1 == f64)
 none(list, 1.0 > 1.0)
 none(list, array == $env)
 none(list, f64 != $env)
+none(list, f64 == 1.0)
 none(list, false != true)
+none(list, false ?? #)
+none(list, false and false)
+none(list, foo != #)
 none(list, foo != foo)
 none(list, foo == #)
 none(list, foo == foo)
+none(list, i == 1)
+none(list, nil == list)
+none(list, not true)
 none(list, ok == $env)
 none(list, ok)
+none(list, ok) || ok
 none(list, str < .Bar)
 none(list, true == $env)
+none(list, true || true) ?? i
+none(list, true) != ok
 none(map($env, 1.0), ok)
 none(map(list, $env), ok)
+none(reverse(array), not false)
 none(sort($env), #.add?.greet(foo))
+none(sort($env), #.f64 != 1.0)
+none(sort($env), #.ok not in #)
+none(sort($env), not #.f64)
+none(sort($env), sortBy(.Bar, #.greet))
+none(str ?? $env, ok)
+none(str ?? ok, f64 >= #)
+none(toPairs($env), # in #)
+not !$env.ok
+not !false
+not !ok
+not !true
+not !true or true
+not $env && false
+not $env and false
+not $env or true
+not $env || true
+not $env.ok
+not $env?.ok
+not all($env, false)
+not all($env, ok)
+not all($env, true)
+not all(array, false)
+not all(array, true)
+not all(list, ok)
+not all(list, true)
+not any($env, false)
+not any($env, ok)
+not any($env, true)
+not any(array, ok)
+not any(array, true)
+not any(list, ok)
+not false != $env
+not false != false
+not false != nil
+not false != ok
+not false != true
+not false && $env
+not false && false
+not false && ok
+not false && true
+not false == $env
+not false == false
+not false == nil
+not false == true
+not false ? 0 / 1 : ok
+not false ? 1.0 : foo
+not false ? add : foo
+not false ? foo : foo
+not false ? greet : nil
+not false ? list : 1.0
+not false ? nil : 1.0
+not false ? ok : i
+not false ? ok : nil
+not false ?: 1.0
+not false ?: add
+not false ?: nil
+not false ?: ok
+not false ?? $env
+not false ?? 0
+not false ?? 1
+not false ?? 1.0
+not false ?? add
+not false ?? array
+not false ?? f64
+not false ?? false
+not false ?? findLastIndex($env, #.foo)
+not false ?? foo
+not false ?? greet
+not false ?? i
+not false ?? list
+not false ?? nil
+not false ?? not $env
+not false ?? ok
+not false ?? one(list, ok)
+not false ?? str
+not false ?? true
+not false and $env
+not false and false
+not false and ok
+not false not in $env or true
+not false not in $env?.Bar
+not false or $env
+not false or false
+not false or false != $env
+not false or not true
+not false or ok
+not false or true
+not false || $env
+not false || false
+not false || last($env)
+not false || ok
+not false || true
+not max($env).ok
+not nil ?? false
+not nil ?? ok
+not nil ?? true
+not none($env, false)
+not none($env, ok)
+not none($env, true)
+not none(array, false)
+not none(array, ok)
+not none(array, true)
+not none(list, false)
+not none(list, ok)
+not not !false
+not not $env.ok
+not not $env?.ok
+not not false
+not not not false
+not not ok
+not not ok != false
+not not true
+not not true and ok
+not ok
+not ok != $env
+not ok != 1.0 ?? i
+not ok != false
+not ok != nil
+not ok != ok
+not ok != true
+not ok && $env
+not ok && $env?.[list]
+not ok && 1.0 ?? split($env, str)
+not ok && false
+not ok && ok
+not ok && true
+not ok == $env
+not ok == false
+not ok == false != $env
+not ok == foo ?? $env
+not ok == nil
+not ok == ok
+not ok == true
+not ok ? $env : str
+not ok ? 1 : $env
+not ok ? 1.0 : 1.0
+not ok ? 1.0 : add
+not ok ? 1.0 : foo
+not ok ? 1.0 : ok
+not ok ? f64 : 1.0
+not ok ? f64 : foo
+not ok ? foo : nil
+not ok ? i : 1.0
+not ok ? list : 1
+not ok ? nil : 0
+not ok ? nil : array
+not ok ? nil : foo
+not ok ? ok : $env
+not ok ? ok : $env?.add
+not ok ? ok : foo
+not ok ? true : $env
+not ok ? true : 0
+not ok ?: $env
+not ok ?: 1.0
+not ok ?: array
+not ok ?: foo
+not ok ?: list
+not ok ?? $env.f64
+not ok ?? $env?.[foo]
+not ok ?? 0
+not ok ?? 0 == $env
+not ok ?? 1
+not ok ?? 1.0
+not ok ?? [$env, list]
+not ok ?? add
+not ok ?? array
+not ok ?? f64
+not ok ?? f64 ?: greet
+not ok ?? false
+not ok ?? foo
+not ok ?? foo.String
+not ok ?? greet
+not ok ?? i
+not ok ?? list
+not ok ?? nil
+not ok ?? nil || ok
+not ok ?? ok
+not ok ?? str
+not ok ?? true
+not ok and $env
+not ok and false
+not ok and foo in list
+not ok and ok
+not ok and true
+not ok not in $env?.[String]
+not ok or $env
+not ok or $env?.[str]
+not ok or false
+not ok or ok
+not ok or true
+not ok || $env
+not ok || false
+not ok || ok
+not ok || true
+not ok; nil
+not one($env, false)
+not one($env, ok)
+not one($env, true)
+not one(array, false)
+not one(array, true)
+not one(list, false)
+not one(list, ok)
+not one(list, true)
+not reduce(array, false)
+not reduce(array, ok)
+not reduce(array, true)
+not reduce(list, true)
+not true != $env
+not true != false
+not true != nil
+not true != nil or $env
+not true != ok
+not true != true
+not true && $env
+not true && $env == $env
+not true && 0 * $env
+not true && false
+not true && not true
+not true && ok
+not true && true
+not true == $env
+not true == false
+not true == nil
+not true == ok
+not true == true
+not true ? 0 : foo
+not true ? 1.0 : $env
+not true ? 1.0 : nil
+not true ? f64 : 1
+not true ? greet : list
+not true ? str : array
+not true ?: $env
+not true ?: 0
+not true ?: 1
+not true ?: 1.0
+not true ?: add
+not true ?: greet
+not true ?: nil
+not true ?: ok
+not true ?? $env
+not true ?? $env.add
+not true ?? $env.list
+not true ?? $env?.[Bar]
+not true ?? $env?.ok
+not true ?? $env[:$env | now(greet)]
+not true ?? $env[:foobar].i
+not true ?? 0
+not true ?? 1
+not true ?? 1.0
+not true ?? add
+not true ?? array
+not true ?? f64
+not true ?? false
+not true ?? floor($env)
+not true ?? foo
+not true ?? greet
+not true ?? i
+not true ?? list
+not true ?? nil
+not true ?? ok
+not true ?? str
+not true ?? str && true
+not true ?? true
+not true and $env
+not true and false
+not true and ok
+not true and true
+not true in $env?.[foobar]
+not true or $env
+not true or $env?.String
+not true or $env?.[Bar]
+not true or false
+not true or ok
+not true or true
+not true || $env
+not true || $env?.String
+not true || $env?.[String]
+not true || false
+not true || ok
+not true || true
 ok
+ok != !false
+ok != !ok
+ok != !true
+ok != $env != $env
+ok != $env != ok
+ok != $env && $env
+ok != $env == ok
+ok != $env ?? foo
+ok != $env ?? ok
 ok != $env and $env
+ok != $env or nil not in $env
 ok != $env.ok
 ok != $env?.Bar
 ok != $env?.String
+ok != $env?.String?.[i]
 ok != $env?.[Bar]
 ok != $env?.[String]
+ok != $env?.[foobar]
+ok != $env?.[nil]
 ok != $env?.[str]
 ok != $env?.foobar
 ok != $env?.foobar?.greet
 ok != $env?.ok
 ok != any($env, ok)
 ok != any(array, false)
+ok != array ?? f64
 ok != false && $env
+ok != false ? 1.0 : foo
+ok != false ? list : 0
+ok != false ?? findLastIndex($env, #)
 ok != false or false
+ok != false or true
+ok != false; false
+ok != greet ?? foo
+ok != i ?? sum($env, #)
 ok != nil && ok
+ok != nil == ok
 ok != nil == ok and ok
 ok != nil ? f64 : 1
+ok != nil ?? false
+ok != nil ?? true
 ok != nil and $env
+ok != nil and 1 <= 1
+ok != nil or false
+ok != not false
+ok != not true
 ok != ok
+ok != ok != nil
+ok != ok == nil
+ok != ok ? str : str
+ok != reduce(list, ok)
+ok != str ?? f64
+ok != str ?? i
 ok != sum($env?.[str])
 ok != true != nil
 ok != true != true
+ok != true && $env
 ok != true && ok
+ok != true == $env
+ok != true ? 1.0 : $env
+ok != true ?? foo
+ok != true and $env?.Bar
+ok && !true
+ok && $env != $env
 ok && $env != array
+ok && $env != nil
 ok && $env != str
 ok && $env == foo
 ok && $env == greet
+ok && $env ?? greet
+ok && $env ?? ok
+ok && $env not in $env?.array
 ok && $env not in array
 ok && $env.ok
 ok && $env?.Bar
@@ -14108,89 +28870,199 @@ ok && $env?.String
 ok && $env?.String?.String
 ok && $env?.String?.list
 ok && $env?.[Bar]
+ok && $env?.[Bar]?.[array]
 ok && $env?.[Bar]?.add
 ok && $env?.[String]
+ok && $env?.[String]?.foo
 ok && $env?.[foobar?.Bar]
 ok && $env?.[foobar]
 ok && $env?.[str]
 ok && $env?.foobar
 ok && $env?.ok
 ok && 0 < 0
+ok && 0 < 1
+ok && 0 == 0
+ok && 0 >= f64
+ok && 0 ?? add
 ok && 1 != i
+ok && 1 <= 1.0
 ok && 1 == 1
 ok && 1 == f64
+ok && 1 ?? foo
 ok && 1.0 != $env
 ok && 1.0 != 1.0
 ok && 1.0 != f64
 ok && 1.0 < f64
+ok && 1.0 == f64
 ok && 1.0 > 1
+ok && 1.0 >= f64
+ok && 1.0 ?? 0
+ok && 1.0 ?? foo
+ok && 1.0 ?? list
 ok && add != $env
 ok && add != $env?.String
+ok && add == nil
+ok && add ?? list
+ok && add ?? true
+ok && all(list, false)
+ok && array == array
+ok && array ?? !$env
+ok && array ?? f64
+ok && array ?? false
+ok && array ?? greet
+ok && f64 != nil
 ok && f64 > 1 or $env
 ok && f64 > 1.0
 ok && foo != foo
 ok && foo != nil
+ok && foo == $env
+ok && foo ?? $env
+ok && foo ?? i
+ok && foo ?? ok
+ok && greet == nil
+ok && i < 1
 ok && i <= f64
+ok && i == i
 ok && i >= 1
 ok && i not in array
+ok && list == $env
+ok && list ?? greet
 ok && max($env)
+ok && max(array)
+ok && mean(array)
 ok && median(array)
+ok && min(array)
 ok && nil != $env
+ok && nil != add
 ok && nil == i
+ok && nil == nil
 ok && nil == true
+ok && nil ?? $env
 ok && nil in array
+ok && not $env?.ok
+ok && not true
 ok && ok
 ok && ok && $env?.[str]
+ok && ok == $env
 ok && ok == ok
+ok && ok == true
+ok && ok ?? 1.0
 ok && ok and $env
 ok && ok or false
 ok && ok || false
 ok && one(list, false)
+ok && str == nil
 ok && str endsWith str
+ok && str not in $env
+ok && str not startsWith str
+ok && str startsWith str
+ok && true != ok
+ok && true ?? 0
+ok && true ?? foo
+ok && true ?? max(i, 1.0)
+ok && true ?? true
+ok && true or false
 ok && true || $env?.String
+ok == !true
+ok == $env && $env
 ok == $env && ok
+ok == $env ? nil : foo
+ok == $env ?? 0
+ok == $env ?? 1
+ok == $env ?? 1.0 == false
+ok == $env ?? ok
+ok == $env and ok
+ok == $env and true
+ok == $env || false
 ok == $env || ok
 ok == $env.ok
 ok == $env?.Bar
+ok == $env?.Bar?.[str]
 ok == $env?.String
 ok == $env?.String?.[greet]
 ok == $env?.[Bar]
 ok == $env?.[Bar]?.[array]
 ok == $env?.[String]
+ok == $env?.[foobar]
 ok == $env?.[str]
+ok == $env?.false
 ok == $env?.foobar
 ok == $env?.nil
 ok == $env?.ok
+ok == 1.0 ?? $env
+ok == 1.0 ?? array
+ok == any($env, false)
+ok == array ?? $env
+ok == array ?? 0
+ok == f64 ?? array
+ok == f64 ?? i
 ok == false != nil
+ok == first($env)
+ok == foo ?? i
+ok == foo ?? ok
+ok == i ?? f64
+ok == i ?? min($env)
+ok == list ?? greet
+ok == list ?? ok
+ok == max(array)
 ok == mean(array)
 ok == min($env)
+ok == nil != false
+ok == nil != ok
 ok == nil != true
+ok == nil == nil
 ok == nil ? 1.0 : $env
+ok == not false
+ok == not ok
+ok == not true
 ok == ok
+ok == ok != $env
 ok == ok ? nil : $env
+ok == ok || true
+ok == str ?? true
+ok == true != ok
 ok == true && $env
+ok == true == $env
+ok == true ?? false
+ok == true and ok
+ok == true in find($env, false)
+ok ? $env : $env * $env | map(i)
 ok ? $env : $env >= 1.0 | date(ok, true)
 ok ? $env : $env | find(.f64)
+ok ? $env : $env | map(1.0)
 ok ? $env : $env?.Bar
 ok ? $env : $env?.String()
+ok ? $env : $env?.[Bar]
 ok ? $env : $env?.[String]
+ok ? $env : $env?.[add]
 ok ? $env : $env?.[str]
 ok ? $env : $env?.array
 ok ? $env : $env?.ok
+ok ? $env : 0 not in array
 ok ? $env : foo.Bar
 ok ? $env : foo?.Bar
+ok ? $env?.String : str
+ok ? $env?.[String] : add
 ok ? 0 : $env.list
+ok ? 0 : $env?.f64
+ok ? 0 : $env?.foo
+ok ? 0 : $env?.ok
 ok ? 0 : foo?.Bar
 ok ? 1 : $env.add
 ok ? 1 : $env?.[f64]
 ok ? 1 : $env[timezone(array):]
 ok ? 1.0 : $env | groupBy(#.str)
+ok ? 1.0 : $env.add
 ok ? 1.0 : $env.array
 ok ? 1.0 : $env.list
 ok ? 1.0 : $env?.Bar
 ok ? 1.0 : $env?.[array]
+ok ? 1.0 : $env?.array
 ok ? 1.0 : $env?.greet
+ok ? 1.0 : $env?.i
 ok ? 1.0 : $env?.list
+ok ? 1.0 : 1.0 * f64
+ok ? 1.0 : f64 ?? list
 ok ? 1.0 : list | groupBy($env)
 ok ? add : $env | groupBy(#.list)
 ok ? add : $env | map(foo)
@@ -14198,95 +29070,158 @@ ok ? add : $env | none(#)
 ok ? add : $env.array
 ok ? add : $env.f64
 ok ? add : $env.greet
+ok ? add : $env?.Bar()
+ok ? add : $env?.[String]
 ok ? add : $env?.[greet]
 ok ? add : $env?.ok
 ok ? add : add
+ok ? add : array | reduce(1.0)
 ok ? add : f64
+ok ? add : foo.Bar
+ok ? add : foo?.String
+ok ? add : greet
+ok ? add : i
+ok ? add : list | find($env?.Bar)
 ok ? add : list | reduce(#)
+ok ? add : nil in -$env
+ok ? add : nil in array
 ok ? add : str
 ok ? array : $env | sum(#)
+ok ? array : $env?.add
 ok ? array : add
 ok ? array : foo
 ok ? array : list | min(i)
 ok ? array : ok
 ok ? array : sum(array)
+ok ? f64 - 0 : $env not contains $env
 ok ? f64 : $env.foo
 ok ? f64 : $env.i
 ok ? f64 : $env.ok
 ok ? f64 : $env[bitxor(foobar):]
 ok ? f64 : f64
 ok ? f64 : foo
+ok ? f64 : foo?.String
 ok ? f64 : foo?.String()
+ok ? f64 : keys($env)
+ok ? f64 : list ?? str
+ok ? f64 : str
 ok ? f64 : uniq($env)
 ok ? false : $env.foo
+ok ? false : $env?.[Bar]
 ok ? false : $env?.[add]
+ok ? false : $env?.[i]
 ok ? false : $env?.list
 ok ? false : foo.Bar
 ok ? false : list?.[i]
+ok ? foo : $env endsWith str
 ok ? foo : $env not endsWith $env?.true
 ok ? foo : $env | groupBy(.list)
 ok ? foo : $env | groupBy(i)
+ok ? foo : $env | sum(#.foo)
 ok ? foo : $env.add
 ok ? foo : $env.greet
+ok ? foo : $env.i
+ok ? foo : $env?.Bar()
+ok ? foo : $env?.String
 ok ? foo : $env?.[f64]
 ok ? foo : $env?.[find(foobar, .f64)]
+ok ? foo : $env?.[foo]
 ok ? foo : $env?.add
 ok ? foo : $env?.array
 ok ? foo : $env?.foobar?.String()
 ok ? foo : $env?.greet
 ok ? foo : add
+ok ? foo : array
+ok ? foo : array | reduce(false)
 ok ? foo : array?.[i]
 ok ? foo : foo
 ok ? foo : foo?.Bar
 ok ? foo : foo?.String
 ok ? foo : list
 ok ? foo not in list : array
+ok ? foo.String : str
+ok ? greet : $env.str
+ok ? greet : $env?.f64
 ok ? greet : array
 ok ? greet : f64
 ok ? greet : foo
+ok ? greet : foo?.String()
 ok ? greet : groupBy($env, greet)?.[i]
 ok ? greet : i
 ok ? greet : list | mean(nil)
 ok ? greet : sortBy($env, 1)
 ok ? greet : str
+ok ? greet : string($env)
 ok ? greet : {foo: true}
 ok ? i : $env?.[greet]
+ok ? i : $env?.i
 ok ? i : foo
+ok ? i : foo.Bar
 ok ? i : list
 ok ? i : list?.[i]
+ok ? i : str
 ok ? list : $env.i
+ok ? list : $env[fromBase64(foo, foo):]
+ok ? list : add
 ok ? list : f64
 ok ? list : foo
+ok ? list : foo.String
+ok ? list : i
+ok ? list : nil ?? list
+ok ? list : ok
 ok ? list : str
+ok ? nil != $env : str
 ok ? nil : $env not matches $env?.[i]
+ok ? nil : $env | mean($env)
 ok ? nil : $env.foo
+ok ? nil : $env.ok
 ok ? nil : $env?.String
 ok ? nil : $env?.[String]
+ok ? nil : $env?.[f64]
 ok ? nil : $env?.[greet]
+ok ? nil : $env?.[list]
 ok ? nil : $env?.[ok]
+ok ? nil : $env?.greet
 ok ? nil : $env?.i
 ok ? nil : $env?.ok
 ok ? nil : $env?.str
+ok ? nil : foo.Bar
 ok ? nil : foo.String
+ok ? ok != $env : 1 < 1.0
 ok ? ok : $env | filter(one(array, ok))
 ok ? ok : $env.list
 ok ? ok : $env?.[array]
+ok ? ok : $env?.greet
 ok ? ok : false and ok
 ok ? ok : foo
 ok ? ok : foo | date(list)
+ok ? ok : foo?.String
+ok ? ok : i
+ok ? ok : list?.[i]
+ok ? ok : ok
 ok ? reduce($env, $env, true) : foo?.Bar
+ok ? str : $env | findLastIndex(#)
 ok ? str : $env?.String(i)?.ok
+ok ? str : $env?.[Bar]
 ok ? str : $env?.foo
 ok ? str : $env?.ok
+ok ? str : add
 ok ? str : f64
 ok ? str : foo
 ok ? str : ok
+ok ? true : $env | groupBy(sortBy(#, 1))
+ok ? true : array?.[i]
 ok ? true : foo?.String
+ok ? true : foo?.String()
 ok ? true ?: 0 : str
+ok ?: $env ?? $env
 ok ?: $env not endsWith str
+ok ?: $env not matches $env
 ok ?: $env | any(.Bar)
 ok ?: $env | filter(.Bar)
 ok ?: $env | find(#.str)
+ok ?: $env | map(#.Bar)
+ok ?: $env | max(add)
 ok ?: $env | one(#.Bar)
 ok ?: $env | reduce(#)
 ok ?: $env | sortBy(.i != #)
@@ -14297,26 +29232,33 @@ ok ?: $env.f64
 ok ?: $env.foo
 ok ?: $env.ok
 ok ?: $env.str
+ok ?: $env?.Bar
 ok ?: $env?.[Bar]
 ok ?: $env?.[Bar]?.str
 ok ?: $env?.[String]
 ok ?: $env?.[add]
 ok ?: $env?.[array]
+ok ?: $env?.[f64]
+ok ?: $env?.[foo]
 ok ?: $env?.[greet]
 ok ?: $env?.[i]
 ok ?: $env?.[ok]
 ok ?: $env?.[str]
+ok ?: $env?.add
 ok ?: $env?.array
 ok ?: $env?.f64
 ok ?: $env?.foo
 ok ?: $env?.greet
 ok ?: $env?.i
 ok ?: $env?.list
+ok ?: $env?.str
 ok ?: $env[foobar not in list:]
 ok ?: $env[foobar:]
 ok ?: 1 % 1
 ok ?: 1.0 | date($env)
+ok ?: 1.0 | date(1)
 ok ?: add
+ok ?: all($env, .f64)
 ok ?: array
 ok ?: array | sum(greet)
 ok ?: array?.[i]
@@ -14324,7 +29266,9 @@ ok ?: ceil(f64)
 ok ?: count($env)
 ok ?: count(array)
 ok ?: count(list)
+ok ?: date(array)
 ok ?: date(false)
+ok ?: date(list)
 ok ?: f64
 ok ?: foo
 ok ?: foo not in $env
@@ -14340,54 +29284,304 @@ ok ?: i >= i
 ok ?: int(1.0)
 ok ?: list
 ok ?: list | findIndex($env)
+ok ?: list | none(true)
 ok ?: max(list)
+ok ?: nil != str
 ok ?: nil in $env
 ok ?: ok
+ok ?: ok | date(add, f64)
 ok ?: str
+ok ?: str matches findLast($env, #)
 ok ?: str startsWith $env
 ok ?: sum($env)
+ok ?: sum(array, 0)
+ok ?: {foo: list}
+ok ?? !$env
+ok ?? !false
+ok ?? !ok
+ok ?? !true
+ok ?? $env ?: list | min(add, add)
+ok ?? $env ?? f64
+ok ?? $env ?? true
+ok ?? $env | get(f64)
+ok ?? $env.add
+ok ?? $env.array
+ok ?? $env.f64
+ok ?? $env.foo
+ok ?? $env.greet
+ok ?? $env.i
+ok ?? $env.list
+ok ?? $env.ok
+ok ?? $env.str
+ok ?? $env?.Bar
+ok ?? $env?.Bar()
+ok ?? $env?.String
+ok ?? $env?.String($env)
+ok ?? $env?.String(str)
+ok ?? $env?.String.Bar
+ok ?? $env?.String.add
+ok ?? $env?.String?.[ok]
+ok ?? $env?.String?.list()
+ok ?? $env?.[0 + foo]
+ok ?? $env?.[1 ** foobar]
+ok ?? $env?.[1.0 < list]
+ok ?? $env?.[Bar]
+ok ?? $env?.[Bar]?.array
+ok ?? $env?.[String]
+ok ?? $env?.[String].f64
+ok ?? $env?.[String].ok
+ok ?? $env?.[String]?.ok
+ok ?? $env?.[add]
+ok ?? $env?.[array]
+ok ?? $env?.[array]?.f64
+ok ?? $env?.[f64]
+ok ?? $env?.[foo and i]
+ok ?? $env?.[foo]
+ok ?? $env?.[foo]?.[i]
+ok ?? $env?.[foobar?.[greet]]
+ok ?? $env?.[foobar?.array()]
+ok ?? $env?.[greet]
+ok ?? $env?.[i]
+ok ?? $env?.[list]
+ok ?? $env?.[list]?.ok
+ok ?? $env?.[ok]
+ok ?? $env?.[ok]?.[i]
+ok ?? $env?.[str]
+ok ?? $env?.[true ** 0]
+ok ?? $env?.add
+ok ?? $env?.all(foobar, nil, list)
+ok ?? $env?.array
+ok ?? $env?.f64
+ok ?? $env?.foo
+ok ?? $env?.greet
+ok ?? $env?.i
+ok ?? $env?.list
+ok ?? $env?.ok
+ok ?? $env?.str
+ok ?? $env[:f64]
+ok ?? $env[array not matches foobar:]
+ok ?? $env[array.list:foo(String)]
+ok ?? $env[foobar not matches false:foobar]
+ok ?? $env[foobar.ok:]
+ok ?? $env[greet:foobar?.[greet]]
+ok ?? $env[i:]
+ok ?? $env[nil:Bar]
+ok ?? $env[str():]
+ok ?? $env[str(foobar):]
+ok ?? -$env
+ok ?? -$env?.[ok]
+ok ?? -0
+ok ?? -1
+ok ?? -1.0
+ok ?? -f64
+ok ?? -i
+ok ?? 0 ?? $env
+ok ?? 0 ?? foo
+ok ?? 1 ?: f64
+ok ?? 1 ?? $env
+ok ?? 1.0 ?? $env.add
+ok ?? 1.0 ?? ok
+ok ?? 1.0 | get($env)
+ok ?? [1.0]
+ok ?? add
+ok ?? add ?? i
+ok ?? add(i, 1)
+ok ?? all($env, #.str)
+ok ?? all($env, .Bar)
+ok ?? any($env, .str)
+ok ?? array
+ok ?? array ?? str
+ok ?? bitnot($env)
+ok ?? bitnot(i)
+ok ?? ceil(1.0)
+ok ?? concat($env)
+ok ?? count($env)
+ok ?? count($env, #.add)
+ok ?? count(array)
+ok ?? count(list)
+ok ?? date(1.0)
+ok ?? date(ok)
+ok ?? f64
+ok ?? f64 ?? false
+ok ?? f64 ?? i
+ok ?? false ? $env : f64
+ok ?? find($env, #.foo)
+ok ?? find($env, .ok)
+ok ?? find(array, ok)
+ok ?? findIndex($env, .array)
+ok ?? findLastIndex($env, #)
+ok ?? findLastIndex($env, #.list)
+ok ?? findLastIndex($env, .list)
+ok ?? first($env)
+ok ?? flatten($env)
+ok ?? float(0)
+ok ?? float(1.0)
+ok ?? float(str)
+ok ?? foo
+ok ?? foo ?? $env?.Bar()
+ok ?? foo ?? array
+ok ?? foo ?? list
+ok ?? foo ?? lower($env)
+ok ?? foo.Bar
+ok ?? foo.String
+ok ?? foo.String()
+ok ?? foo?.Bar
+ok ?? foo?.String
+ok ?? foo?.String()
+ok ?? greet
+ok ?? greet ? greet : greet
+ok ?? greet ?? nil
+ok ?? greet ?? str
+ok ?? greet($env)
+ok ?? greet(str)
+ok ?? groupBy($env, $env)?.i
+ok ?? groupBy($env, .foo)
+ok ?? groupBy($env, .greet)
+ok ?? groupBy($env, .list)
+ok ?? groupBy($env, i)
+ok ?? groupBy(array, #)
+ok ?? groupBy(array, foo)
+ok ?? i
+ok ?? i ?? ok
+ok ?? i ?? str
+ok ?? int(i)
+ok ?? len(list)
+ok ?? list
+ok ?? list ? ok : 1.0
+ok ?? list?.[i]
+ok ?? max(0, $env)?.[add]
+ok ?? min(array)
+ok ?? nil ? false : foo
+ok ?? nil ?? 1
+ok ?? nil ?? add
+ok ?? nil ?? array
+ok ?? none($env, #)
+ok ?? none(list, $env)
+ok ?? not $env
+ok ?? not 1.0 ?? foo
+ok ?? not false
+ok ?? not ok
+ok ?? not true
+ok ?? ok
+ok ?? round($env)
+ok ?? sort($env)
+ok ?? sortBy($env, #)
+ok ?? sortBy(array, #)
+ok ?? str
+ok ?? str ?? array
+ok ?? str ?? f64
+ok ?? str ?? ok
+ok ?? str | get(false)
+ok ?? string(add)
+ok ?? string(ok)
+ok ?? sum($env)
+ok ?? sum($env, #)
+ok ?? sum($env, #.f64)?.[add]
+ok ?? sum(array)
+ok ?? sum(list)
+ok ?? sum(uniq($env))
+ok ?? timezone($env)
+ok ?? toBase64($env)
+ok ?? toJSON(0)
+ok ?? toJSON(1.0)
+ok ?? toJSON(foo)
+ok ?? toJSON(true)
+ok ?? toPairs($env)
+ok ?? trimPrefix($env)
+ok ?? true ?? list
+ok ?? type($env)
+ok ?? type(f64)
+ok ?? type(greet)
+ok ?? type(ok)
+ok ?? {foo: 1}
+ok ?? {foo: i}
+ok ?? {foo: nil}
+ok ?? {foo: ok}
+ok and !true
 ok and $env != 0
 ok and $env != 1.0
 ok and $env != false
 ok and $env != list
+ok and $env == f64
 ok and $env == list
+ok and $env ?? f64
 ok and $env in array
+ok and $env || false
 ok and $env.ok
 ok and $env?.Bar
+ok and $env?.Bar?.f64
 ok and $env?.Bar?.foobar
 ok and $env?.String
 ok and $env?.[Bar]
+ok and $env?.[Bar]?.[foo]
 ok and $env?.[Bar]?.array
 ok and $env?.[String]
 ok and $env?.[String]?.[add]
 ok and $env?.[foobar]
 ok and $env?.[str]
 ok and $env?.foobar
+ok and $env?.foobar?.[foo]
 ok and $env?.nil?.f64
 ok and $env?.ok
 ok and 0 != nil
 ok and 0 < i
+ok and 0 <= f64
+ok and 1 < 1.0
+ok and 1 < i
+ok and 1 <= f64
+ok and 1.0 != f64
 ok and 1.0 != i
 ok and 1.0 <= i
+ok and 1.0 ?? $env
+ok and 1.0 ?? $env.foo
 ok and 1.0 not in array
 ok and add == $env
 ok and array != array
+ok and array ?? f64
 ok and f64 not in array
 ok and false && $env
+ok and false == $env
 ok and false ? $env : $env
+ok and false ?? 1.0
+ok and first($env)
 ok and foo != foo
 ok and foo == nil
+ok and foo ?? $env.ok
+ok and foo ?? $env?.String()
+ok and foo ?? true
+ok and greet == nil
+ok and greet not in $env?.[Bar]
 ok and i < i
 ok and i == f64
+ok and i >= 1.0
+ok and i ?? add
+ok and i ^ 1 != 1.0
 ok and last($env)
+ok and list ?? [i]
+ok and list ?? foo
+ok and nil != false
+ok and nil != foo
 ok and nil != ok
 ok and nil == $env
+ok and nil == add
+ok and nil == f64
+ok and nil == true
 ok and nil not in array
+ok and not ok
+ok and not true
 ok and ok
 ok and ok ? add : i
+ok and ok ?? $env
+ok and one(list, ok)
+ok and str == string(foo)
+ok and str matches toJSON(1.0)
+ok and str not endsWith str
 ok and str not startsWith str
 ok and true != false
 ok and true && $env
+ok and true ?? add
+ok and true ?? str
+ok and true and $env
 ok and true || $env.ok
 ok and {foo: i}?.foo
 ok in $env && false
@@ -14397,14 +29591,20 @@ ok in $env?.[Bar]
 ok in $env?.[String]
 ok in $env?.[foobar]
 ok in $env?.foobar
+ok in $env?.foobar?.[add]
+ok in [$env, 1]
 ok in [false]
 ok in [ok]
 ok in concat(array)
+ok in first($env)
+ok in flatten(array)
+ok in last($env)
 ok in sort(array)
 ok not in $env || true
 ok not in $env?.Bar
 ok not in $env?.Bar?.list
 ok not in $env?.String
+ok not in $env?.String?.greet
 ok not in $env?.[Bar]
 ok not in $env?.[Bar]?.[foo]
 ok not in $env?.[Bar]?.ok()
@@ -14412,25 +29612,54 @@ ok not in $env?.[String]
 ok not in $env?.[String]?.String
 ok not in $env?.[foobar]
 ok not in $env?.false?.[i]
+ok not in $env?.foobar?.[array]
+ok not in $env?.foobar?.[list]
+ok not in $env?.true || false
 ok not in [0, nil]
 ok not in [false]
+ok not in [ok]
 ok not in [true]
+ok not in array ?? greet
 ok not in groupBy(list, i)
 ok not in last($env)
+ok not in list ?? add
+ok not in list ?? greet
 ok not in map($env, false)
+ok not in values($env)
+ok or !false
+ok or !ok
+ok or !true
 ok or $env != 1
+ok or $env != nil
+ok or $env * 1.0
 ok or $env * f64
+ok or $env + $env?.str
+ok or $env - $env
+ok or $env - 1
+ok or $env - 1.0
+ok or $env < i
+ok or $env <= $env.f64
+ok or $env <= $env?.[f64]
 ok or $env == $env
 ok or $env == $env?.foo
+ok or $env == 1
 ok or $env == array
 ok or $env == list
 ok or $env == ok
 ok or $env > str
 ok or $env >= i
+ok or $env >= str
 ok or $env ?: ok
 ok or $env and $env?.String
+ok or $env and 1 != $env
+ok or $env endsWith str
+ok or $env in $env
+ok or $env in list
+ok or $env not in foo
+ok or $env not in str
 ok or $env not startsWith str
 ok or $env or $env
+ok or $env or ok
 ok or $env || true
 ok or $env.ok
 ok or $env?.Bar
@@ -14439,130 +29668,241 @@ ok or $env?.Bar(list())
 ok or $env?.Bar(list)
 ok or $env?.Bar(one(foobar, false))
 ok or $env?.String
+ok or $env?.String()
+ok or $env?.String(1, f64)
 ok or $env?.String(1.0, i)?.f64
 ok or $env?.[$env]?.ok(foobar?.str)
 ok or $env?.[1.0 not matches f64]
+ok or $env?.[1]
 ok or $env?.[Bar]
+ok or $env?.[Bar].array
 ok or $env?.[Bar]?.[list]
+ok or $env?.[Bar]?.greet
 ok or $env?.[String]
 ok or $env?.[String].list
 ok or $env?.[add]
+ok or $env?.[add]?.array
+ok or $env?.[add]?.ok
+ok or $env?.[array($env)]
 ok or $env?.[array]
 ok or $env?.[array].ok
 ok or $env?.[f64]
 ok or $env?.[f64].i
 ok or $env?.[foo not in foobar]
 ok or $env?.[foo]
+ok or $env?.[foobar or 1]
 ok or $env?.[foobar]
+ok or $env?.[foobar]?.add
 ok or $env?.[greet()]
 ok or $env?.[greet]
+ok or $env?.[greet] < str
 ok or $env?.[i]
+ok or $env?.[i].String
 ok or $env?.[list]
 ok or $env?.[list]?.add()
 ok or $env?.[ok | reduce(foo)]
 ok or $env?.[ok()]
 ok or $env?.[ok]
+ok or $env?.[ok]?.add
+ok or $env?.[sortBy(foobar, $env)]
 ok or $env?.[str]
 ok or $env?.[str]?.[f64]
+ok or $env?.[str]?.list
 ok or $env?.ok
 ok or $env?.upper(1.0, 0, foo)
 ok or $env[$env:foobar]?.[foo]?.[foo]
+ok or $env[:1.0 ^ false].str
+ok or $env[:foo?.list]
+ok or $env[:foo]
+ok or $env[:greet?.f64]
+ok or $env[:indexOf(greet)]
 ok or $env[:nil .. add]
+ok or $env[:str]
 ok or $env[add.Bar():]
+ok or $env[foo:]
 ok or $env[foobar.foo(nil):f64?.[foo]]
 ok or $env[foobar:]
+ok or $env[list:]
 ok or $env[nil matches i:foobar not startsWith foobar]
+ok or $env[not foobar:ok]
 ok or $env[ok():]
 ok or $env[ok:]
+ok or -$env
+ok or -i ?? add
+ok or 0 < $env
 ok or 0 == nil
 ok or 0 == nil ? 0 : array
+ok or 0 >= $env?.[array]
+ok or 0 >= 1.0
+ok or 1 + $env?.[i]
 ok or 1 <= 1.0
 ok or 1 <= i
+ok or 1 > $env?.[String]
+ok or 1 > 0
 ok or 1 >= 1.0
+ok or 1 ?? ok
+ok or 1.0 != $env
+ok or 1.0 != nil
 ok or 1.0 < 0
 ok or 1.0 < 1.0
+ok or 1.0 < f64
 ok or 1.0 <= $env
 ok or 1.0 <= f64
 ok or 1.0 <= f64 + 1
 ok or 1.0 == $env
 ok or 1.0 >= $env
 ok or 1.0 >= 1
+ok or 1.0 ?? 1
+ok or 1.0 ?? list
 ok or 1.0 in $env
 ok or abs($env)
+ok or add == $env.add
+ok or add ?? array
 ok or array != nil
+ok or array ?? 0
+ok or f64 < 1
 ok or f64 <= i
 ok or f64 == nil
 ok or f64 > $env
+ok or f64 > $env?.[array]
 ok or f64 > 1
 ok or f64 > f64
 ok or f64 >= 0
+ok or f64 ?? $env
+ok or false && ok
 ok or false ? foo : foo
+ok or false ?: foo
+ok or false ?? 1.0
 ok or false or ok
 ok or false || false
+ok or find($env, #)
 ok or find($env, .greet)
 ok or find($env, .str)
 ok or foo != $env.foo
+ok or foo != foo
+ok or foo == foo
+ok or foo ?? $env
+ok or foo ?? list
 ok or foo in $env
 ok or foo in list
 ok or foo in sum($env)
 ok or foo not in groupBy($env, 1)
 ok or fromJSON($env)
+ok or fromJSON(str)
 ok or greet != $env
+ok or greet == $env
 ok or greet not in $env
+ok or i != nil
+ok or i < i
 ok or i == nil
+ok or i ?? foo
+ok or last($env)
+ok or list ?? true
 ok or mean(array)
 ok or nil != $env
+ok or nil != add
 ok or nil != foo
+ok or nil != i
 ok or nil != str
 ok or nil == add
 ok or nil == array
+ok or nil == str
+ok or nil in array
+ok or nil not in $env?.[Bar]
 ok or none($env, #)
+ok or not $env
+ok or not $env?.Bar()?.String
+ok or not $env?.[str]
+ok or not ok
 ok or ok
+ok or ok != true
 ok or ok == false
+ok or ok ?? nil
+ok or ok ?? not ok
 ok or ok or ok
 ok or reduce($env, ok)
 ok or sortBy($env, 1.0)
 ok or sortBy($env, true)?.array?.[array]
 ok or str + $env
 ok or str == $env
+ok or str == $env?.[str]?.String
 ok or str not endsWith $env
 ok or str not in foo
 ok or sum($env)
+ok or true && false
 ok or true == $env?.[String]
 ok or true == nil
+ok or true ?? $env
+ok or true ?? list
+ok or true ?? true
 ok or true or $env?.String(i)
 ok or true || ok
 ok or {foo: nil}?.i
+ok || !$env
+ok || !false
+ok || !ok
+ok || !true
+ok || $env != f64
 ok || $env != false
+ok || $env != i
+ok || $env != nil ? foo : array
+ok || $env && $env
+ok || $env + 1.0
 ok || $env + i
 ok || $env < $env
+ok || $env < -1.0
+ok || $env < false ?? 1.0
 ok || $env <= 0
+ok || $env <= i
 ok || $env == $env
+ok || $env == 1.0
 ok || $env == list
+ok || $env >= $env.f64
 ok || $env >= str
+ok || $env contains $env?.[Bar].Bar
+ok || $env contains str
+ok || $env endsWith $env?.[list]
 ok || $env matches $env
+ok || $env matches str
 ok || $env not contains str
 ok || $env not in str
+ok || $env not matches $env
 ok || $env or false
 ok || $env || $env
+ok || $env || ok
 ok || $env.ok
+ok || $env?.$env
 ok || $env?.$env.str
 ok || $env?.Bar
 ok || $env?.Bar()
 ok || $env?.String
 ok || $env?.String()
+ok || $env?.String()[:ok]?.foo
+ok || $env?.String(all(foobar, #.list))
+ok || $env?.String(first(foobar))
+ok || $env?.String(foo())
+ok || $env?.String.greet
 ok || $env?.String?.ok()?.array
 ok || $env?.[Bar]
+ok || $env?.[String?.Bar]
 ok || $env?.[String]
 ok || $env?.[String]?.Bar
 ok || $env?.[add]
+ok || $env?.[add]?.[i]
+ok || $env?.[add]?.i
 ok || $env?.[all(foobar, foobar)]
 ok || $env?.[array]
+ok || $env?.[array].list
 ok || $env?.[f64]
 ok || $env?.[f64].str(list?.[ok])
+ok || $env?.[findLastIndex(i, .String)]
 ok || $env?.[foo]
+ok || $env?.[foo].f64
+ok || $env?.[foo]?.str
 ok || $env?.[foobar startsWith foobar]
+ok || $env?.[foobar | take(foobar)]
 ok || $env?.[foobar?.i]
+ok || $env?.[foobar]
 ok || $env?.[greet]
 ok || $env?.[greet]?.String
 ok || $env?.[greet]?.f64
@@ -14570,104 +29910,193 @@ ok || $env?.[i]
 ok || $env?.[i].str
 ok || $env?.[i]?.[foo]
 ok || $env?.[list]
+ok || $env?.[list].add
+ok || $env?.[list]?.[greet]
 ok || $env?.[nil endsWith list]
 ok || $env?.[ok]
 ok || $env?.[str()]
 ok || $env?.[str]
 ok || $env?.[str].list
 ok || $env?.foobar
+ok || $env?.foobar.String
 ok || $env?.ok
 ok || $env?.sortBy(nil)
 ok || $env?.toPairs(add, true)
+ok || $env[$env:Bar]
 ok || $env[1.0:]
 ok || $env[:String()]
 ok || $env[:add()]
+ok || $env[:array | none(false)]
 ok || $env[:foo]
 ok || $env[:foobar]
 ok || $env[Bar(foo):add and foobar]
+ok || $env[Bar?.[str]:date($env)]
 ok || $env[add():]
 ok || $env[add:foobar]
 ok || $env[f64.ok:array(foobar, foobar, String)]
 ok || $env[f64:ok(true)]
+ok || $env[false .. String:]
 ok || $env[foo:foobar]
 ok || $env[foobar:]
+ok || $env[foobar?.list:]
+ok || $env[greet:$env?.Bar]
+ok || $env[i(foobar):Bar .. foo]
+ok || $env[map(foo, foobar):]
 ok || $env[str?.add:groupBy(i, foobar)]
+ok || 0 - $env
 ok || 0 == $env
 ok || 0 == 1
 ok || 0 == 1.0
+ok || 0 > 1.0
+ok || 0 ?? $env[:String()]
+ok || 0 ?? ok
+ok || 1 < findLast($env, #.ok)
 ok || 1 > 1
+ok || 1 >= $env?.[foo]
+ok || 1.0 != 1.0
 ok || 1.0 != f64
 ok || 1.0 * $env
 ok || 1.0 - $env?.[ok]
+ok || 1.0 <= 0
 ok || 1.0 <= 1
 ok || 1.0 <= i
 ok || 1.0 == 1
 ok || 1.0 == 1.0
+ok || 1.0 ?? add
+ok || 1.0 ?? array
+ok || 1.0 ?? i
 ok || 1.0 in $env
+ok || 1.0 in $env?.String
+ok || add == $env?.[foo]
+ok || add ?? str
 ok || add not in $env
 ok || any($env, #)
 ok || any($env, .list)
+ok || any($env, false)
+ok || array != nil
+ok || array ?? 1.0
 ok || f64 != $env
 ok || f64 != f64
 ok || f64 + $env
 ok || f64 < $env
+ok || f64 < 1.0
+ok || f64 < i
+ok || f64 <= 1
+ok || f64 == f64
 ok || f64 > $env
 ok || f64 > 1
 ok || false ?: foo
+ok || false and false
 ok || false not in sum(list, $env)
+ok || findLast($env, #.String)
+ok || findLast($env, $env)
+ok || foo != nil
+ok || foo == $env
+ok || foo == $env[:false]
+ok || foo == foo
 ok || foo == nil
+ok || foo ?? array
+ok || foo ?? list
+ok || foo ?? not true
 ok || foo not in list
 ok || fromJSON($env)
 ok || greet != nil
 ok || greet == $env
+ok || greet ?? array
+ok || greet ?? i
 ok || i * $env
 ok || i + $env
 ok || i < f64
+ok || i == 1
 ok || i > i
+ok || i >= $env
+ok || i >= 1.0
+ok || last($env)
 ok || list != list
+ok || list ?? i
+ok || list ?? str
+ok || max(i, list)
+ok || max(list, greet)
+ok || mean(list | sortBy(greet))
 ok || mean(list)
+ok || median($env)?.greet
 ok || median(array)
 ok || median(array, 1)
 ok || median(array, str)
 ok || min($env)
+ok || nil != -1.0
+ok || nil != 1
 ok || nil != add
+ok || nil != greet
 ok || nil != i
+ok || nil != nil
 ok || nil != true
+ok || nil == $env.array
+ok || nil == 1.0
 ok || nil == false
+ok || nil == nil ?? 1
+ok || nil ?? $env?.[f64]
 ok || nil in $env?.String
 ok || nil in array
 ok || nil not in array
+ok || none(array, $env)
+ok || not $env
+ok || not ok
 ok || ok
+ok || ok == nil
 ok || ok == ok
 ok || ok ?: foo
+ok || ok ?? [nil]
 ok || ok || $env
 ok || one($env, .add)
+ok || reduce($env, .foo)
 ok || sortBy($env, array).str
 ok || sortBy($env, foo, 1)
 ok || sortBy($env, i, str)
 ok || str != $env
 ok || str != nil
 ok || str != str
+ok || str + $env
 ok || str <= str
+ok || str ?? array
 ok || str contains $env
+ok || str contains str
+ok || str endsWith $env
 ok || str endsWith str
+ok || str in $env
+ok || str matches $env
+ok || str not in foo
 ok || sum($env)
+ok || sum($env, .list)
+ok || true != nil
 ok || true && $env
+ok || true ?? add
 ok || true and $env
 ok || true and true
+ok || true || $env?.[greet]
 ok || {foo: nil}?.add
+ok; 0 ?? 1
 ok; add
 ok; f64
+ok; foo
+ok; foo.String
 ok; foo?.String; groupBy(list, #)
 ok; greet
 ok; list
+ok; list | sortBy(i)
+ok; list?.[i]
 ok; ok
 ok; str
+ok; true != $env
+one($env ?? nil, false == $env)
 one($env | map(true), ok)
 one($env, true) ?: greet
 one($env, true) || $env?.Bar
 one($env.array, nil != true)
+one($env?.[str], # in list)
+one($env?.[str], list == #)
 one($env?.[str], ok)
+one($env?.array, $env == #)
 one($env?.array, ok)
 one($env?.list, 0 <= 1.0)
 one($env?.list, ok)
@@ -14678,87 +30107,188 @@ one([foo], ok)
 one([i], ok)
 one([ok], #)
 one([str], none($env, false))
+one([true, foo], ok)
+one(array ?? nil, ok)
+one(array, !ok)
 one(array, # != #)
+one(array, # < #)
 one(array, # <= 0)
 one(array, # <= 1)
 one(array, # == 1)
+one(array, # > #)
+one(array, # > 0)
 one(array, # >= #)
+one(array, # not in array)
+one(array, $env != #)
+one(array, $env != ok)
 one(array, $env && false)
+one(array, $env == list)
 one(array, $env.ok)
+one(array, $env?.ok)
+one(array, 0 == 0)
 one(array, 0 >= 0)
+one(array, 1 == 1.0)
+one(array, 1 >= #)
 one(array, 1.0 < #)
 one(array, 1.0 <= #)
+one(array, 1.0 > #)
+one(array, 1.0 >= #)
+one(array, f64 != nil)
 one(array, f64 == i)
 one(array, false and $env?.[ok])
 one(array, false) != $env?.ok
+one(array, false) != ok
+one(array, foo == foo)
+one(array, greet == nil)
 one(array, i != $env)
 one(array, i <= f64)
 one(array, list != $env)
+one(array, nil != #)
 one(array, nil != add)
 one(array, nil in $env)
+one(array, nil not in list)
 one(array, ok)
+one(array, ok) and $env[greet:]
+one(array, ok) or ok
+one(array, str == str)
 one(array, str > str)
+one(array, true ?? i)
+one(array, true and true)
+one(array, true or $env)
 one(array, true) == ok
 one(if ok { $env } else { add }, ok)
+one(list ?? ok, ok)
+one(list, # != $env)
 one(list, # != foo)
 one(list, # == #)
+one(list, # == $env)
+one(list, # == foo)
+one(list, $env != .String)
 one(list, $env != i)
 one(list, $env == foo)
+one(list, $env == nil)
+one(list, $env.ok)
 one(list, $env?.ok)
+one(list, .Bar in foo)
 one(list, 1 <= f64)
+one(list, 1 > 1.0)
+one(list, 1.0 != i)
+one(list, 1.0 < i)
 one(list, 1.0 == $env)
+one(list, 1.0 >= 0)
 one(list, any(list, ok))
 one(list, f64 == 1)
+one(list, f64 > 1.0)
+one(list, false and ok)
 one(list, foo != #)
 one(list, greet == nil)
 one(list, i == 0)
 one(list, list != $env)
+one(list, nil != 1.0)
+one(list, nil == #)
 one(list, nil == list)
 one(list, nil not in $env)
+one(list, none(list, false))
+one(list, not ok)
 one(list, ok)
+one(list, ok) and ok
 one(list, str < #.Bar)
 one(list, str >= str)
 one(list, true != $env)
+one(list, true ?? foo)
+one(min($env), ok)
 one(sort($env), $env == nil)
+one(sort($env), .String.list(nil))
 one(sort($env), .greet[:.i])
+one(sort($env), .list?.array(foobar))
+one(sort($env), 1.0 != $env)
+one(sort($env), i >= .f64)
 one(sort($env), ok)
+one(uniq(array), ok)
+reduce($env | map($env), #.foo)
+reduce($env | map(0), str)
 reduce($env | map(1.0), str)
+reduce($env | map(f64), #)
+reduce($env | map(foo), greet)
+reduce($env | map(str), str)
 reduce($env, #.list) == 1 && false
+reduce($env, $env, $env).foo
 reduce($env, $env, $env).greet
+reduce($env, $env, $env)?.add
 reduce($env, $env, $env)?.f64
 reduce($env, $env, $env)?.greet
+reduce($env, $env, $env)?.ok
 reduce($env, $env, 1)?.f64
 reduce($env, $env, 1.0)?.add
+reduce($env, $env, 1.0)?.greet
+reduce($env, $env, 1.0)?.list
+reduce($env, $env, add).ok
+reduce($env, $env, array)?.i
 reduce($env, $env, false).str
+reduce($env, $env, foo)?.Bar
 reduce($env, $env, foo)?.str
 reduce($env, $env, greet).String
+reduce($env, $env, greet).greet
+reduce($env, $env, greet)?.String
 reduce($env, $env, greet)?.greet
+reduce($env, $env, i)?.[str]
 reduce($env, $env, i)?.f64
+reduce($env, $env, list).foo
+reduce($env, $env, list).ok
 reduce($env, $env, list)?.add
+reduce($env, $env, nil).Bar
 reduce($env, $env, nil)?.str
+reduce($env, $env, true)?.list
+reduce($env, 1.0, false) ?? array
+reduce($env, array, $env) | reduce(str)
 reduce($env, array, 1.0) | all(false)
 reduce($env, array, false)?.[i]
 reduce($env, foo, 1).Bar
+reduce($env, foo, add)?.Bar
 reduce($env, foo, false).Bar
 reduce($env, foo, nil)?.Bar
+reduce($env, foo, ok).String
+reduce($env, foo, ok)?.String()
+reduce($env, i, 1.0) ?? add
+reduce($env, list, 1.0)?.[i]
+reduce($env, str, false) ?? array
 reduce($env.array, #)
+reduce($env.array, #index / #)
+reduce($env.array, add)
+reduce($env.array, f64)
+reduce($env.array, greet)
 reduce($env.array, i)
 reduce($env.array, last($env))
+reduce($env.array, list)
 reduce($env.array, mean(f64, #))
+reduce($env.array, ok)
 reduce($env.array, str)
 reduce($env.list, #)
 reduce($env.list, #.Bar)
 reduce($env.list, #?.Bar)
+reduce($env.list, #acc)
 reduce($env.list, 1.0 + 1.0)
+reduce($env.list, [#, 1])
 reduce($env.list, [nil])
 reduce($env.list, add)
 reduce($env.list, array)
 reduce($env.list, f64 ^ 1)
+reduce($env.list, greet ?? $env, str ?? add)
 reduce($env.list, greet)
+reduce($env.list, list)
+reduce($env.list, ok)
+reduce($env.list, ok, {foo: nil})
 reduce($env.list, str)
+reduce($env?.[str], # != foo)
 reduce($env?.[str], #)
+reduce($env?.[str], #acc)
 reduce($env?.[str], #index != #)
+reduce($env?.[str], #index == #)
+reduce($env?.[str], -0)
+reduce($env?.[str], 1 <= 1)
+reduce($env?.[str], f64)
 reduce($env?.[str], foo)
+reduce($env?.[str], greet)
 reduce($env?.[str], list)
 reduce($env?.[str], nil != list)
 reduce($env?.[str], ok)
@@ -14769,50 +30299,100 @@ reduce($env?.array, # >= 1.0)
 reduce($env?.array, #)
 reduce($env?.array, #acc ** #)
 reduce($env?.array, #acc)
+reduce($env?.array, $env.greet)
 reduce($env?.array, add)
+reduce($env?.array, array)
+reduce($env?.array, f64)
 reduce($env?.array, foo)
+reduce($env?.array, greet)
 reduce($env?.array, i != #)
+reduce($env?.array, i)
 reduce($env?.array, list | groupBy(foo))
 reduce($env?.array, list)
+reduce($env?.array, ok)
+reduce($env?.array, str)
 reduce($env?.list, #)
 reduce($env?.list, #.String)
 reduce($env?.list, #.String, array)
+reduce($env?.list, #acc)
+reduce($env?.list, .Bar in #)
 reduce($env?.list, .Bar)
 reduce($env?.list, add)
+reduce($env?.list, f64)
+reduce($env?.list, false != ok)
+reduce($env?.list, foo)
+reduce($env?.list, foo, $env?.i)
+reduce($env?.list, foo?.Bar)
+reduce($env?.list, greet)
 reduce($env?.list, i ^ 0)
 reduce($env?.list, i in array)
 reduce($env?.list, i)
 reduce($env?.list, ok)
 reduce(1 .. 1, #acc?.[foo])
+reduce([$env], #)
 reduce([$env], #.Bar)
 reduce([$env], #.String != $env)
+reduce([$env], #.add < #.greet)
 reduce([$env], #.foo?.[list])
+reduce([$env], #acc)
+reduce([$env], .Bar)
 reduce([$env], .str)
 reduce([$env], add)
 reduce([$env], f64 <= #.f64)
+reduce([$env], foo)
 reduce([$env], greet)
 reduce([$env], i)
+reduce([$env], if true { .greet } else { foo })
 reduce([$env], round($env))
+reduce([$env], upper(.foo))
 reduce([0, $env], array)
+reduce([0], #)
 reduce([0], array)
+reduce([1, greet], add)
+reduce([1.0, 1], # - #)
 reduce([1.0, foo], #)
+reduce([1.0], # - 1)
+reduce([1.0], #)
 reduce([1.0], $env[:#])
+reduce([1.0], list)
+reduce([1], add)
+reduce([1], foo)
+reduce([add], $env[foobar:])
+reduce([f64, add], #)
+reduce([f64], i)
+reduce([false, add], i)
+reduce([false], #acc)
+reduce([false], foo)
+reduce([foo, add], #)
 reduce([foo], #)
 reduce([foo], #.Bar + #acc)
 reduce([foo], #index)
+reduce([foo], $env?.[f64])
 reduce([foo], foo).String
 reduce([foo], greet)
 reduce([foo], ok)
 reduce([greet, greet], str)
+reduce([greet], f64)
 reduce([i, 1.0], # != #)
 reduce([i, i], foo)
+reduce([i], list)
 reduce([list], #)
+reduce([list], add)
 reduce([list], greet)
 reduce([nil != true], list)
+reduce([nil, add], foo)
+reduce([nil, foo], # ?? .add)
+reduce([nil], array)
+reduce([nil], i)
 reduce([ok], #)
 reduce([ok], add)
+reduce([ok], foo)
+reduce([str, 1.0], $env.i)
 reduce([str], i)
+reduce([true, greet], #)
 reduce([true], foo.Bar)
+reduce(array ?? add, str)
+reduce(array ?? str, #index)
 reduce(array | map(#), f64)
 reduce(array | map(#), foo)
 reduce(array | map($env), #index)
@@ -14820,72 +30400,122 @@ reduce(array | map(foo), f64)
 reduce(array | sortBy(#), ok)
 reduce(array | sortBy(1), #acc)
 reduce(array, # != #)
+reduce(array, # != i)
+reduce(array, # % #)
 reduce(array, # % i)
 reduce(array, # * #)
+reduce(array, # + #)
 reduce(array, # + 0)
+reduce(array, # - #acc)
+reduce(array, # .. #)
 reduce(array, # / #)
+reduce(array, # / 0)
+reduce(array, # < #)
 reduce(array, # <= #)
+reduce(array, # <= 1)
 reduce(array, # == #)
+reduce(array, # == 0)
 reduce(array, # > i)
 reduce(array, # >= #)
+reduce(array, # >= 0)
+reduce(array, # ?? foo)
 reduce(array, # ^ #)
 reduce(array, # in array)
 reduce(array, #)
 reduce(array, #) * f64
 reduce(array, #, add)
 reduce(array, #, array)
+reduce(array, #, greet)
+reduce(array, #, i)
 reduce(array, #, i) | mean(array)
 reduce(array, #, ok)
+reduce(array, #..i)
 reduce(array, #acc)
+reduce(array, #acc, nil)?.[greet]
+reduce(array, #acc, nil)?.i
 reduce(array, #acc, nil)?.list
 reduce(array, #index != f64)
 reduce(array, #index ** 1.0)
 reduce(array, #index ** f64)
+reduce(array, #index == 1.0)
+reduce(array, #index ?? foo)
+reduce(array, #index ^ #)
 reduce(array, #index)
+reduce(array, #index, foo)
 reduce(array, $env != foo)
+reduce(array, $env != ok)
 reduce(array, $env == #)
+reduce(array, $env == ok)
+reduce(array, $env ?? ok)
+reduce(array, $env and true)
+reduce(array, $env) == ok
 reduce(array, $env) | count(false)
+reduce(array, $env) | find(false)
+reduce(array, $env) | map(false)
 reduce(array, $env).Bar
 reduce(array, $env).String
 reduce(array, $env).add
 reduce(array, $env).array
 reduce(array, $env).f64
+reduce(array, $env).foo
 reduce(array, $env).foobar
 reduce(array, $env).greet
+reduce(array, $env).greet(foobar)
 reduce(array, $env).i
 reduce(array, $env).list
 reduce(array, $env).str
 reduce(array, $env)?.Bar
 reduce(array, $env)?.String
+reduce(array, $env)?.String?.str
 reduce(array, $env)?.[str]
 reduce(array, $env)?.add
 reduce(array, $env)?.array
 reduce(array, $env)?.f64
+reduce(array, $env)?.false?.foo
 reduce(array, $env)?.foo
+reduce(array, $env)?.foobar
 reduce(array, $env)?.greet
 reduce(array, $env)?.i
 reduce(array, $env)?.list
 reduce(array, $env)?.ok
 reduce(array, $env)?.str
+reduce(array, $env, $env) | sum(1)
 reduce(array, $env, $env)?.str
 reduce(array, $env, 0)?.String
+reduce(array, $env, 1.0).Bar
 reduce(array, $env, f64)?.[str]
+reduce(array, $env, f64)?.list
 reduce(array, $env, foo)?.ok
+reduce(array, $env, ok)?.Bar
 reduce(array, $env, str)?.greet
 reduce(array, $env, true).array
 reduce(array, $env.array)
+reduce(array, $env.f64)
+reduce(array, $env.foo)
 reduce(array, $env.greet)
 reduce(array, $env.i)
+reduce(array, $env.list)
+reduce(array, $env.ok)
 reduce(array, $env.str)
 reduce(array, $env?.add)
+reduce(array, $env?.array)
 reduce(array, $env?.f64)
 reduce(array, $env?.foo)
+reduce(array, $env?.foo.Bar)
 reduce(array, $env?.greet)
+reduce(array, $env?.i)
 reduce(array, $env?.list, greet)
 reduce(array, $env?.str)
+reduce(array, -#)
+reduce(array, -0)
+reduce(array, -1)
+reduce(array, 0 * 1)
+reduce(array, 0) ^ i
 reduce(array, 0) | min(1.0)
 reduce(array, 1 != $env)
 reduce(array, 1 != nil)
+reduce(array, 1 | max(#acc))
+reduce(array, 1) ** f64
 reduce(array, 1.0 != #)
 reduce(array, 1.0 != 1)
 reduce(array, 1.0 * #)
@@ -14893,88 +30523,150 @@ reduce(array, 1.0 ** #)
 reduce(array, 1.0 ** #index)
 reduce(array, 1.0 ** 1.0)
 reduce(array, 1.0 - #acc)
+reduce(array, 1.0 - f64)
 reduce(array, 1.0 - i)
 reduce(array, 1.0 / #)
 reduce(array, 1.0 < #)
 reduce(array, 1.0 == i)
+reduce(array, 1.0 > #)
+reduce(array, 1.0 >= f64)
+reduce(array, 1.0 ?? #)
+reduce(array, 1.0 ?? $env)
 reduce(array, 1.0 ^ #)
 reduce(array, 1.0) / $env?.i
 reduce(array, 1.0) == $env?.[str]
 reduce(array, 1.0) ^ $env?.f64
+reduce(array, [#])
 reduce(array, [1.0])
+reduce(array, [add])
 reduce(array, [flatten(list)])
 reduce(array, [foo])
+reduce(array, abs(#))
+reduce(array, add == nil)
 reduce(array, add)
 reduce(array, add, f64)
+reduce(array, array | reduce($env))
 reduce(array, array)
 reduce(array, array) | mean(1, i)
 reduce(array, array)?.[i]
+reduce(array, array, foo)
+reduce(array, array, i)
+reduce(array, array?.[i])
 reduce(array, array[1:])
 reduce(array, bitnand(1, #acc))
 reduce(array, bitnot(#))
 reduce(array, bitnot(#)) % i
+reduce(array, bitnot(i))
 reduce(array, bitor(i, #))
 reduce(array, ceil(#))
 reduce(array, concat(list))
+reduce(array, f64 + #)
 reduce(array, f64)
+reduce(array, f64) ?? f64
+reduce(array, false ?? #)
 reduce(array, false) == $env?.String
+reduce(array, false) and ok
+reduce(array, float(#))
 reduce(array, float(i))
 reduce(array, foo == $env)
+reduce(array, foo ?? $env)
 reduce(array, foo)
 reduce(array, foo).Bar
 reduce(array, foo).String
+reduce(array, foo).String()
 reduce(array, foo)?.Bar
 reduce(array, foo)?.String
 reduce(array, foo)?.String()
 reduce(array, foo, 1.0).Bar
+reduce(array, foo, array)
+reduce(array, foo, foo).String
 reduce(array, foo, greet)?.String()
 reduce(array, foo, i).Bar
 reduce(array, foo, list).Bar
+reduce(array, foo, str)
+reduce(array, foo, str).Bar
 reduce(array, foo.Bar)
+reduce(array, foo.String())
 reduce(array, foo.String)
 reduce(array, foo?.Bar)
+reduce(array, foo?.String())
 reduce(array, foo?.String)
 reduce(array, greet(str))
 reduce(array, greet)
+reduce(array, greet, [array])
 reduce(array, greet, foo)
+reduce(array, i ** #acc)
 reduce(array, i .. #, greet)
 reduce(array, i <= #)
 reduce(array, i ^ #acc)
 reduce(array, i)
+reduce(array, i) != i
 reduce(array, i, array) % i
 reduce(array, i, f64) not in $env?.array
+reduce(array, i, list)
 reduce(array, keys($env))
+reduce(array, list ?? #, i)
+reduce(array, list ?? str)
 reduce(array, list)
+reduce(array, list)?.[i]
+reduce(array, list, {foo: nil})
 reduce(array, list[:#])
 reduce(array, mean(#))
 reduce(array, median(#))
+reduce(array, median(0))
 reduce(array, ok ? ok : #index)
 reduce(array, ok)
 reduce(array, ok, $env.ok)
+reduce(array, ok, 1.0) == ok
 reduce(array, reduce(array, #))
 reduce(array, reduce(array, #, i))
 reduce(array, round(#))
 reduce(array, round(1))
+reduce(array, str ?? 1.0)
 reduce(array, str not in foo)
 reduce(array, str)
+reduce(array, str) + str
 reduce(array, str) | greet()
+reduce(array, str, $env.f64)
+reduce(array, str, array) not in foo
+reduce(array, str, f64)
 reduce(array, string(#))
+reduce(array, string(i))
 reduce(array, sum(array, 1.0))
 reduce(array, toJSON(#))
 reduce(array, toJSON(1.0))
 reduce(array, true and ok)
+reduce(array, true or $env)
+reduce(array, true) ?? add
 reduce(array, type(#))
+reduce(array, type(true))
 reduce(array, uniq(list))
 reduce(array[0:], list)
+reduce(concat(list), #)
 reduce(flatten(array), array)
 reduce(flatten(array), foo)
 reduce(flatten(list), #)
+reduce(keys($env), #acc)
+reduce(keys($env), $env?.[String])
+reduce(keys($env), abs(0))
+reduce(keys($env), greet)
+reduce(keys($env), max(#))
 reduce(keys($env), sum(#))
 reduce(let foobar = array; foobar, #)
+reduce(list ?? 1.0, foo)
+reduce(list ?? array, #)
 reduce(list | map(1), $env?.f64)
+reduce(list | map(1.0), array)
+reduce(list | map(false), true != #)
+reduce(list | reduce(array), #)
 reduce(list | sortBy(1.0), greet)
 reduce(list, # == #)
+reduce(list, # == $env)
+reduce(list, # ?? false)
+reduce(list, # ?? foo)
+reduce(list, # in list)
 reduce(list, #)
+reduce(list, #) ?? foo
 reduce(list, #).Bar
 reduce(list, #).String
 reduce(list, #).String()
@@ -14982,20 +30674,34 @@ reduce(list, #)?.Bar
 reduce(list, #)?.String
 reduce(list, #)?.String()
 reduce(list, #, 1.0)?.Bar
+reduce(list, #, 1.0)?.String
+reduce(list, #, add)
 reduce(list, #, array)?.String
 reduce(list, #, f64).String
 reduce(list, #, nil).String
 reduce(list, #, ok)?.Bar
 reduce(list, #.Bar != nil)
+reduce(list, #.Bar >= .Bar)
 reduce(list, #.Bar)
+reduce(list, #.String())
 reduce(list, #.String)
+reduce(list, #?.Bar)
+reduce(list, #?.String())
 reduce(list, #?.String)
 reduce(list, #acc == 0)
+reduce(list, #acc ?? $env)
+reduce(list, #acc ?? 1)
 reduce(list, #acc)
+reduce(list, #acc).Bar
 reduce(list, #acc)?.Bar
 reduce(list, #acc, foo).String
 reduce(list, #index)
 reduce(list, $env && true)
+reduce(list, $env == ok)
+reduce(list, $env ?? array)
+reduce(list, $env and true)
+reduce(list, $env | map(add))
+reduce(list, $env) | map(i)
 reduce(list, $env).Bar
 reduce(list, $env).String
 reduce(list, $env).add
@@ -15013,7 +30719,9 @@ reduce(list, $env)?.String
 reduce(list, $env)?.[str]
 reduce(list, $env)?.add
 reduce(list, $env)?.f64
+reduce(list, $env)?.foo
 reduce(list, $env)?.foobar
+reduce(list, $env)?.foobar?.i
 reduce(list, $env)?.greet
 reduce(list, $env)?.i
 reduce(list, $env)?.list
@@ -15023,33 +30731,60 @@ reduce(list, $env, $env)?.i
 reduce(list, $env, add).array
 reduce(list, $env, add).foo
 reduce(list, $env, add)?.list
+reduce(list, $env, array)?.greet
+reduce(list, $env, false).f64
+reduce(list, $env, false).ok
 reduce(list, $env, foo).ok
 reduce(list, $env, greet)?.Bar?.str
+reduce(list, $env, i).ok
 reduce(list, $env, nil)?.greet
+reduce(list, $env.add)
 reduce(list, $env.f64)
 reduce(list, $env.list)
+reduce(list, $env.str)
 reduce(list, $env?.[#.Bar])
+reduce(list, $env?.[String])
 reduce(list, $env?.[foobar])
 reduce(list, $env?.add)
 reduce(list, $env?.f64)
 reduce(list, $env?.foo)
 reduce(list, $env?.list)
+reduce(list, $env?.nil?.[greet])
 reduce(list, $env?.ok)
 reduce(list, $env?.str)
+reduce(list, -i)
+reduce(list, .Bar not contains str)
 reduce(list, .Bar not in foo, {foo: str})
 reduce(list, .Bar)
+reduce(list, .String ?? foo)
 reduce(list, .String)
+reduce(list, .String, greet)
+reduce(list, 0 .. 0)
+reduce(list, 0 == 1)
 reduce(list, 0) != i
+reduce(list, 0) | mean(1.0)
+reduce(list, 1 <= 1)
 reduce(list, 1) * i
 reduce(list, 1) / i
 reduce(list, 1.0 * f64)
+reduce(list, 1.0 * i)
 reduce(list, 1.0 + 1)
+reduce(list, 1.0 <= 1.0)
 reduce(list, 1.0) * i
 reduce(list, 1.0) == i
+reduce(list, 1.0, array) <= i
 reduce(list, [$env, 0])
 reduce(list, [f64, false])
+reduce(list, [foo])
+reduce(list, [nil, #])
+reduce(list, [str])
+reduce(list, abs(#index))
 reduce(list, add == $env)
 reduce(list, add)
+reduce(list, add, foo)
+reduce(list, add, ok)
+reduce(list, array != array)
+reduce(list, array | one(ok))
 reduce(list, array)
 reduce(list, array) | map(foo)
 reduce(list, array) | sum(#)
@@ -15057,18 +30792,30 @@ reduce(list, array)?.[i]
 reduce(list, array, add)
 reduce(list, bitnot(1))
 reduce(list, f64 != $env)
+reduce(list, f64 * #index)
 reduce(list, f64 * f64)
 reduce(list, f64 / f64)
+reduce(list, f64 >= 1)
 reduce(list, f64)
 reduce(list, f64, f64)
+reduce(list, f64, str)
+reduce(list, false == ok)
 reduce(list, false ?: foo)
 reduce(list, false) ? f64 : [false]
+reduce(list, false) in uniq(list)
 reduce(list, first(#acc))
+reduce(list, foo != foo)
+reduce(list, foo ?? f64)
+reduce(list, foo ?? nil)
 reduce(list, foo)
 reduce(list, foo).Bar
 reduce(list, foo).String
+reduce(list, foo).String()
 reduce(list, foo)?.Bar
 reduce(list, foo)?.String
+reduce(list, foo)?.String()
+reduce(list, foo, $env) not in list
+reduce(list, foo, array).String
 reduce(list, foo, foo)
 reduce(list, foo, i)?.String
 reduce(list, foo, str)
@@ -15076,56 +30823,110 @@ reduce(list, foo.Bar, list)
 reduce(list, foo.String)
 reduce(list, foo?.String())
 reduce(list, foo?.String)
+reduce(list, greet == #acc)
+reduce(list, greet ?? $env)
 reduce(list, greet(#.Bar))
+reduce(list, greet(.Bar))
 reduce(list, greet)
+reduce(list, greet) ?? greet
 reduce(list, greet, greet)
+reduce(list, i / 1.0)
 reduce(list, i ^ 0)
 reduce(list, i)
 reduce(list, i, $env?.list[:])
 reduce(list, i, 1.0) == i
 reduce(list, i, list)
+reduce(list, i, ok)
 reduce(list, int(#index))
 reduce(list, int(0))
+reduce(list, len($env))
 reduce(list, list | any(ok))
 reduce(list, list | map($env))
 reduce(list, list)
 reduce(list, list)?.[i]
+reduce(list, list, f64) | map(array)
 reduce(list, list, i)
+reduce(list, list?.[i])
+reduce(list, max(f64))
+reduce(list, mean(1.0))
+reduce(list, median(i))
 reduce(list, nil != $env)
+reduce(list, nil != 0)
+reduce(list, nil == $env)
+reduce(list, ok == false)
+reduce(list, ok ?? #)
+reduce(list, ok ?? #acc)
+reduce(list, ok ?? $env)
 reduce(list, ok)
+reduce(list, ok) || $env?.[greet]
+reduce(list, ok, $env.foo)
+reduce(list, ok, 1 * i)
 reduce(list, ok, f64)
 reduce(list, reduce(array, greet, foo))
+reduce(list, sort($env), ok)
+reduce(list, str > #.Bar)
+reduce(list, str ?? f64)
 reduce(list, str)
 reduce(list, str) == str
 reduce(list, string(ok))
+reduce(list, sum(list, 1.0))
 reduce(list, toBase64(#.Bar))
+reduce(list, trimSuffix(#.Bar))
+reduce(list, trimSuffix(.Bar))
 reduce(list, true != $env)
 reduce(list, true != ok)
+reduce(list, true ? # : false)
 reduce(list, true || false)
 reduce(list, true || true)
+reduce(list, true) and ok
+reduce(list, type($env))
 reduce(list, type(i))
 reduce(list, type(list))
 reduce(list[:1], [$env])
+reduce(list[:1], str)
+reduce(list[:], greet)
 reduce(map($env, 1.0), #)
+reduce(map($env, false), i)
 reduce(map($env, foo), str)
+reduce(map($env, greet), #)
+reduce(map($env, greet), i)
+reduce(map($env, list), $env.str)
 reduce(map(array, foo), foo?.Bar)
 reduce(map(array, list), list)
+reduce(map(array, ok), greet)
+reduce(map(list, #), #)
 reduce(map(list, #), $env?.add)
+reduce(map(list, .Bar), list)
 reduce(map(list, i), #)
+reduce(max($env).array, ok)
+reduce(nil ?? list, add)
 reduce(reduce(array, list), #index)
+reduce(reduce(list, array), i)
 reduce(reverse(array), $env.ok)
 reduce(reverse(array), $env?.ok)
 reduce(reverse(list), str)
 reduce(sort(array), str)
+reduce(sortBy(array, #), #)
+reduce(sortBy(array, #), array)
+reduce(sortBy(array, 1.0), ok)
+reduce(sortBy(list, 1.0), i)
+reduce(str ?? $env, #)
+reduce(uniq(array), greet)
+reduce(values($env), # == $env)
 reduce(values($env), #)
+repeat(nil ?? str, i)
+repeat(str, 0 ?? false)
 repeat(str, i)
 repeat(str, i) not startsWith str
+repeat(str, max(1.0, array))
 repeat(type(1), i)
 reverse($env | filter(false))
 reverse($env | map($env))
 reverse($env | map(0))
 reverse($env | map(1.0))
 reverse($env | map(false))
+reverse($env | map(foo))
+reverse($env | map(ok))
 reverse($env | map(true))
 reverse($env.array)
 reverse($env.list)
@@ -15133,11 +30934,16 @@ reverse($env?.array)
 reverse($env?.list)
 reverse(0 .. 1)
 reverse(0 .. i)
+reverse(1 .. 0)
 reverse(1 .. 1)
+reverse(1 .. i)
 reverse([$env, 0])
 reverse([$env, f64])
+reverse([$env, ok])
 reverse([$env])
 reverse([0, $env, foo])
+reverse([0, foo])
+reverse([0, nil])
 reverse([0])
 reverse([1 .. 1])
 reverse([1, true])
@@ -15145,86 +30951,148 @@ reverse([1.0, list])
 reverse([1.0])
 reverse([1])
 reverse([add, list])
+reverse([add])
 reverse([array, array])
 reverse([array, greet])
 reverse([array])
 reverse([f64, nil])
 reverse([f64])
+reverse([false, true])
 reverse([false])
 reverse([foo, 1.0])
+reverse([foo, array])
+reverse([foo, f64])
+reverse([foo, list])
 reverse([foo, str])
 reverse([foo])
 reverse([greet])
 reverse([i, 1])
 reverse([i])
 reverse([list])
+reverse([nil, 1])
+reverse([nil, i])
 reverse([nil, list])
 reverse([nil, nil])
+reverse([nil, true])
 reverse([nil])
 reverse([ok])
 reverse([str, ok])
 reverse([str])
 reverse([true])
+reverse(array ?? 1)
+reverse(array ?? 1.0)
+reverse(array ?? add)
+reverse(array ?? f64)
+reverse(array ?? foo)
+reverse(array | map(#))
 reverse(array | map($env))
+reverse(array | map(1.0))
 reverse(array | map(ok))
 reverse(array | map(str))
 reverse(array | reduce(array, foo))
 reverse(array | sortBy(1))
 reverse(array)
+reverse(array) ?? list
+reverse(array) not in sort(array)
 reverse(array) | findIndex(ok)
 reverse(array) | findLastIndex(false)
+reverse(array) | groupBy(#)
+reverse(array) | groupBy(0)
+reverse(array) | groupBy(i)
 reverse(array) | map(#)
+reverse(array) | map($env)
 reverse(array) | one(ok)
 reverse(array) | reduce(#)
 reverse(array) | reduce(#, greet)
 reverse(array) | reduce($env)
+reverse(array) | reduce(array)
 reverse(array) | reduce(foo)
 reverse(array) | reduce(str)
 reverse(array) | sortBy(1)
 reverse(array) | sortBy(i)
 reverse(array) | sum(#)
+reverse(array) | sum(f64)
 reverse(array)?.[i]
 reverse(array[i:1])
 reverse(concat(array))
 reverse(concat(list))
+reverse(false ? array : list)
 reverse(filter($env, false))
+reverse(filter(list, ok))
+reverse(flatten(array))
 reverse(flatten(list))
+reverse(i .. i)
 reverse(if false { $env } else { array })
+reverse(if false { 1.0 } else { list })
 reverse(keys($env))
 reverse(let foobar = array; foobar)
 reverse(let foobar = list; foobar)
+reverse(list ?? 1.0)
+reverse(list ?? add)
+reverse(list ?? f64)
+reverse(list ?? false)
+reverse(list ?? foo)
+reverse(list ?? ok)
+reverse(list ?? str)
+reverse(list ?? true)
 reverse(list | filter(true))
 reverse(list | map(#))
+reverse(list | map(1.0))
+reverse(list | map(array))
+reverse(list | map(foo))
 reverse(list | map(i))
+reverse(list | map(ok))
 reverse(list | map(str))
 reverse(list | map(true))
+reverse(list | sortBy(0))
 reverse(list | sortBy(1.0))
+reverse(list | sortBy(str))
 reverse(list)
 reverse(list) != list
 reverse(list) == array
+reverse(list) ?? list
 reverse(list) | any(true)
 reverse(list) | count(true)
+reverse(list) | find(false)
+reverse(list) | findIndex(false)
 reverse(list) | groupBy(#)
 reverse(list) | groupBy(foo)
+reverse(list) | groupBy(true)
+reverse(list) | map(#index)
+reverse(list) | map(list)
+reverse(list) | one(false)
+reverse(list) | reduce(#, false)
 reverse(list) | reduce(0)
+reverse(list) | reduce(1.0)
 reverse(list) | reduce(f64)
 reverse(list) | reduce(foo)
 reverse(list) | reduce(greet)
+reverse(list) | reduce(ok)
 reverse(list) | reduce(true)
+reverse(list) | sum(f64)
 reverse(list)?.[i]
+reverse(list[:i])
+reverse(map($env, $env))
 reverse(map($env, 0))
 reverse(map($env, 1.0))
+reverse(map($env, add))
 reverse(map($env, array))
 reverse(map($env, f64))
+reverse(map($env, foo))
 reverse(map($env, list))
 reverse(map($env, str))
+reverse(map($env, true))
 reverse(map(array, #))
 reverse(map(array, #index))
+reverse(map(array, 1.0))
 reverse(map(array, foo))
+reverse(map(array, i))
 reverse(map(list, #))
 reverse(map(list, #.Bar))
 reverse(map(list, $env))
 reverse(reduce(array, list))
+reverse(reduce(list, list, ok))
+reverse(reverse(array))
 reverse(reverse(list))
 reverse(sort($env))
 reverse(sort(array))
@@ -15232,54 +31100,99 @@ reverse(sortBy(array, #))
 reverse(sortBy(array, 1.0))
 reverse(sortBy(array, str))
 reverse(sortBy(list, 1.0))
+reverse(sortBy(list, i))
 reverse(toPairs($env))
 reverse(uniq(array))
 reverse(uniq(list))
+reverse(values($env))
+round($env | count(ok))
 round($env | findIndex(true))
 round($env | reduce(0, foo))
+round($env | reduce(1.0, f64))
 round($env | sum(1.0))
+round($env | sum(f64))
 round($env.f64)
 round($env.f64) != i
 round($env.i)
 round($env?.f64)
+round($env?.f64) - f64
 round($env?.i)
+round(-0)
+round(-1)
+round(-1.0)
+round(-f64)
+round(-i)
+round(0 * 0)
 round(0 * 1.0)
 round(0 * f64)
 round(0 ** 0)
+round(0 ** 1)
+round(0 ** 1.0)
 round(0 ** f64)
 round(0 ** i)
 round(0 + 0)
 round(0 + 1)
 round(0 + 1.0)
 round(0 + i)
+round(0 - 0)
 round(0 - 1)
+round(0 - f64)
 round(0 / 0)
 round(0 / 1.0)
 round(0 / f64)
+round(0 / i)
+round(0 ?? f64)
+round(0 ?? false)
+round(0 ?? true)
 round(0 ^ 1.0)
 round(0 ^ f64)
+round(0 | max(array))
+round(0) != i
+round(0) - i
 round(0) / f64
 round(0) < i
+round(0) == max($env)
+round(0) ?? foo
 round(0) ^ f64
 round(0) ^ i
 round(0.1)
+round(1 % i)
 round(1 * 0)
+round(1 * 1)
 round(1 ** 0)
 round(1 ** 1)
+round(1 ** 1.0)
 round(1 ** i)
 round(1 + 0)
+round(1 + 1)
 round(1 + 1.0)
 round(1 + i)
 round(1 - 0)
+round(1 - 1)
 round(1 - 1.0)
 round(1 - i)
 round(1 / 1)
+round(1 / f64)
 round(1 / i)
+round(1 ?? 0)
+round(1 ?? 1.0)
+round(1 ?? array)
+round(1 ?? f64)
+round(1 ?? foo)
+round(1 ?? i)
+round(1 ?? nil)
 round(1 ^ 0)
+round(1 ^ 1)
 round(1 ^ 1.0)
 round(1 ^ f64)
+round(1 ^ i)
 round(1 | bitnand(0))
+round(1) * f64
+round(1) * i
 round(1) / f64
+round(1) ?? array ?? foo
+round(1) ?? greet
+round(1) ?? ok
 round(1) ^ sum(array)
 round(1) not in array
 round(1.0 * 0)
@@ -15288,72 +31201,143 @@ round(1.0 * 1.0)
 round(1.0 * f64)
 round(1.0 * i)
 round(1.0 ** 0)
+round(1.0 ** 1)
 round(1.0 ** 1.0)
+round(1.0 ** f64)
 round(1.0 ** i)
 round(1.0 + 0)
+round(1.0 + 1.0)
+round(1.0 + f64)
+round(1.0 + i)
+round(1.0 - 0)
 round(1.0 - 1)
 round(1.0 - 1.0)
 round(1.0 - f64)
 round(1.0 - i)
+round(1.0 / 0)
 round(1.0 / 1)
 round(1.0 / 1.0)
+round(1.0 / f64)
 round(1.0 / i)
+round(1.0 ?? $env)
+round(1.0 ?? 0)
+round(1.0 ?? 1)
+round(1.0 ?? add)
+round(1.0 ?? f64)
+round(1.0 ?? false)
+round(1.0 ?? foo)
+round(1.0 ?? i)
+round(1.0 ?? list)
+round(1.0 ?? nil)
+round(1.0 ?? ok)
+round(1.0 ?? str)
 round(1.0 ^ $env.i)
 round(1.0 ^ 0)
+round(1.0 ^ 1)
 round(1.0 ^ 1.0)
 round(1.0 ^ f64)
 round(1.0 ^ i)
 round(1.0 | max(i))
 round(1.0 | mean(0))
 round(1.0)
+round(1.0) != f64
 round(1.0) * $env and false
 round(1.0) * f64
 round(1.0) ** 1.0 != 1
+round(1.0) ** 1.0 / f64
 round(1.0) ** f64
 round(1.0) + f64
 round(1.0) + mean(1.0, f64)
+round(1.0) + min(1.0)
+round(1.0) - f64
 round(1.0) / i
+round(1.0) / int(1.0)
 round(1.0) <= i
+round(1.0) == 1 / i
+round(1.0) == i
 round(1.0) > i
 round(1.0) >= f64
+round(1.0) >= i
+round(1.0) ?? f64
+round(1.0) ?? foo
 round(1.0) ^ f64
 round(1.0) ^ i
 round(1.0) ^ sum($env, 1)
+round(1.0) in $env.array
 round(1.0) | median(array)
+round(1.0) | median(f64)
 round(1.1)
+round(abs(-1.0))
 round(abs(1.0))
+round(abs(f64))
 round(abs(i))
+round(array | max(array))
+round(array | median(1.0))
 round(array | reduce(#))
 round(array | sum(#))
+round(array | sum(0))
 round(array | sum(1))
+round(array | sum(f64))
 round(array?.[0])
 round(array?.[i])
+round(bitand(0, i))
+round(bitnand(1, 1))
+round(bitnand(i, 1))
+round(bitnot(0))
+round(bitnot(1))
 round(bitnot(i))
+round(ceil(0))
+round(ceil(1))
 round(ceil(1.0))
 round(ceil(f64))
+round(ceil(i))
+round(count($env, ok))
+round(count($env, true))
 round(f64 * 0)
 round(f64 * 1)
 round(f64 * 1.0)
 round(f64 * i)
+round(f64 ** $env.f64)
 round(f64 ** 0)
+round(f64 + 0)
 round(f64 + 1.0)
 round(f64 - 0)
+round(f64 - 1.0)
+round(f64 - f64)
 round(f64 - i)
 round(f64 / 0)
 round(f64 / 1.0)
 round(f64 / f64)
+round(f64 ?? $env)
+round(f64 ?? 0)
+round(f64 ?? add)
+round(f64 ?? array)
+round(f64 ?? foo)
+round(f64 ?? greet)
+round(f64 ?? list)
+round(f64 ?? nil)
+round(f64 ?? ok)
 round(f64 ^ 1)
 round(f64 ^ 1.0)
 round(f64 ^ f64)
+round(f64 ^ i)
+round(f64 | median(0))
 round(f64)
+round(f64) != $env?.f64
+round(f64) != f64
 round(f64) + f64
 round(f64) + f64 < 0
+round(f64) < i
 round(f64) <= i
 round(f64) >= i
 round(false ? 0 : 1.0)
 round(false ?: 1)
+round(find(array, true))
+round(findIndex(array, true))
+round(findIndex(list, ok))
 round(findLast(array, ok))
 round(findLastIndex($env, true))
+round(findLastIndex(array, ok))
 round(first(array))
 round(float(0))
 round(float(1))
@@ -15366,36 +31350,68 @@ round(floor(1.0))
 round(floor(f64))
 round(floor(i))
 round(i % 1)
+round(i * 1)
 round(i * 1.0)
 round(i * i)
 round(i ** 0)
 round(i ** 1)
 round(i ** 1.0)
+round(i + 1)
+round(i + f64)
+round(i - 0)
 round(i - 1)
+round(i - 1.0)
 round(i - f64)
+round(i / 1)
 round(i / 1.0)
 round(i / f64)
 round(i / i)
+round(i ?? $env)
+round(i ?? 1.0)
+round(i ?? add)
+round(i ?? false)
+round(i ?? list)
+round(i ?? nil)
 round(i ^ 0)
+round(i ^ 1)
 round(i ^ 1.0)
+round(i ^ f64)
 round(i)
+round(i) ** i
 round(i) + i
 round(i) / i
+round(i) < 1.0 != $env
+round(i) <= 1.0 ? foo : add
 round(i) == i
 round(i) > $env?.i
 round(i) > f64
+round(i) ?? add
+round(i) ?? f64
+round(i) ?? foo
+round(i) ?? str
+round(i) ^ i
+round(i) | median(f64)
 round(if false { foo } else { 0 })
 round(if true { 0 } else { greet })
 round(int(0))
 round(int(1))
+round(int(1.0))
 round(int(f64))
+round(int(i))
 round(int(string(1.0)))
 round(last(array))
+round(len($env))
+round(len(array))
 round(len(list))
 round(len(str))
 round(list | count(ok))
+round(list | reduce(1))
+round(list | reduce(1.0, $env))
 round(list | reduce(1.0, 1.0))
 round(list | reduce(f64))
+round(map(list, 1.0) | max(1))
+round(max(0))
+round(max(1))
 round(max(1.0 * 0))
 round(max(1.0))
 round(max(array))
@@ -15407,117 +31423,215 @@ round(mean(1))
 round(mean(1, 1.0))
 round(mean(1.0))
 round(mean(array))
+round(mean(array, i, array))
 round(mean(f64))
 round(mean(f64, f64))
 round(mean(i))
+round(median($env.array))
 round(median(0))
 round(median(1))
+round(median(1.0))
 round(median(array))
+round(median(array, 1.0))
 round(median(f64))
 round(median(f64, i))
 round(median(i))
+round(min(0))
 round(min(1))
 round(min(1.0))
+round(min(1.0, 1.0))
 round(min(array))
+round(min(array, 0))
+round(min(array, array, array))
 round(min(f64))
 round(min(i))
+round(nil ?? 1)
+round(nil ?? 1.0)
+round(nil ?? f64)
 round(ok ? i : 0)
 round(reduce(array, #))
 round(reduce(array, #, nil))
+round(reduce(array, 1.0))
+round(reduce(array, i))
 round(reduce(list, #index, nil))
+round(round(0))
 round(round(1))
 round(round(1.0))
 round(sum($env, 0))
 round(sum($env, 1))
 round(sum($env, f64))
+round(sum($env, i))
 round(sum(array))
+sort($env ?? $env)
+sort($env ?? add)
+sort($env ?? array)
+sort($env ?? f64)
+sort($env ?? false)
+sort($env ?? foo)
+sort($env ?? greet)
+sort($env ?? list)
+sort($env ?? nil)
+sort($env ?? ok)
+sort($env | filter(false))
+sort($env | find(false))
 sort($env | map(#index))
 sort($env | map(0))
+sort($env) != $env?.String
+sort($env) != array
+sort($env) ?? $env?.array
+sort($env) ?? greet
+sort($env) ?? type(list)
+sort($env) | all(#)
 sort($env) | all(#.Bar)
+sort($env) | all(#.String)
 sort($env) | all(#.add)
+sort($env) | all(#.array)
+sort($env) | all(#.foo?.Bar)
 sort($env) | all(#.ok)
+sort($env) | all($env)
+sort($env) | all(.foo?.[array])
 sort($env) | all(.str)
 sort($env) | all(true)
 sort($env) | any(#)
 sort($env) | any(#.f64)
+sort($env) | any(#.i)
 sort($env) | any(.String)
 sort($env) | any(.array)
 sort($env) | concat(list)
 sort($env) | count(#)
+sort($env) | count(#.Bar)
 sort($env) | count(#.foo)
 sort($env) | count(#.i == 0)
 sort($env) | count($env)
+sort($env) | count(.f64)
+sort($env) | count(false)
 sort($env) | filter(#)
+sort($env) | filter(#.String)
 sort($env) | filter(#.i)
+sort($env) | filter(#.list)
 sort($env) | find(#)
 sort($env) | find(#.Bar)
 sort($env) | find(#.list)
+sort($env) | find($env)
+sort($env) | find(.String[#.array:true])
+sort($env) | find(.array)
+sort($env) | find(.i)
 sort($env) | find(false)
 sort($env) | findIndex(#)
 sort($env) | findIndex(#.add)
 sort($env) | findIndex(#.array)
 sort($env) | findIndex(.String)
+sort($env) | findIndex(.array)
 sort($env) | findIndex(.foo)
 sort($env) | findIndex(.ok)
+sort($env) | findIndex(false)
 sort($env) | findIndex(ok)
 sort($env) | findLast(#)
 sort($env) | findLast(#.array)
 sort($env) | findLast(#.list?.foo(#))
+sort($env) | findLast(#.str)
+sort($env) | findLast(false)
 sort($env) | findLastIndex(#)
+sort($env) | findLastIndex(#.add)
 sort($env) | findLastIndex(#.list)
+sort($env) | findLastIndex($env)
 sort($env) | findLastIndex(.Bar)
+sort($env) | findLastIndex(.foo)
 sort($env) | groupBy(#)
+sort($env) | groupBy(#.Bar)
 sort($env) | groupBy(#.add)
+sort($env) | groupBy(#.greet / #)
 sort($env) | groupBy(#.greet)
 sort($env) | groupBy(#?.foo(i))
 sort($env) | groupBy(.array)
+sort($env) | groupBy(.greet)
+sort($env) | groupBy(0)
+sort($env) | groupBy(1.0)
 sort($env) | groupBy(add)
+sort($env) | groupBy(f64)
 sort($env) | groupBy(i)
+sort($env) | groupBy(list)
+sort($env) | groupBy(ok)
 sort($env) | map(#)
+sort($env) | map(#.Bar)
 sort($env) | map(#.f64)
+sort($env) | map($env)
+sort($env) | map(.array)
 sort($env) | map(.foo)
 sort($env) | map(.list)
+sort($env) | map(1)
 sort($env) | map(1.0)
+sort($env) | map(f64 ?? 0)
+sort($env) | map(foo)
 sort($env) | map(i)
 sort($env) | map(true)
 sort($env) | mean(1.0)
 sort($env) | none(#)
+sort($env) | none(#.add[foobar:])
+sort($env) | none(#.list)
 sort($env) | none(#.ok)
 sort($env) | none($env)
 sort($env) | none(.String)
+sort($env) | none(.add)
 sort($env) | none(.array)
+sort($env) | none(.foo)
+sort($env) | none(.list)
+sort($env) | one(#.add)
 sort($env) | one(#.f64)
+sort($env) | one(#.greet)
 sort($env) | one(#.list)
 sort($env) | one(#.ok)
 sort($env) | one(#.ok.nil)
+sort($env) | one(#.str)
 sort($env) | one($env)
+sort($env) | one(.Bar)
 sort($env) | one(.f64)
 sort($env) | one(.f64?.[.greet])
 sort($env) | one(.list)
+sort($env) | one(false)
 sort($env) | one(ok)
 sort($env) | reduce(#.String, nil)
+sort($env) | reduce(#.greet, str)
+sort($env) | reduce(false, 0)
 sort($env) | reduce(foo, foo)
 sort($env) | sortBy(#)
+sort($env) | sortBy(#.String)
+sort($env) | sortBy(.add)
+sort($env) | sortBy(.f64)
 sort($env) | sortBy(1.0)
+sort($env) | sortBy(foo)
 sort($env) | sortBy(i)
 sort($env) | sortBy(str)
+sort($env) | sum(#.foo)
 sort($env) | sum(#.greet)
 sort($env) | sum(#.str?.String)
+sort($env) | sum($env)
 sort($env) | sum(.array)
+sort($env) | sum(1.0)
+sort($env) | sum(array)
 sort($env) | sum(false)
 sort($env) | sum(foo)
+sort($env) | sum(not #.array)
 sort($env)?.[i]
 sort($env)?.[i].add()
+sort($env)?.[i]?.[array]
 sort($env)[:]
 sort($env.array)
+sort($env?.$env)
 sort($env?.Bar)
+sort($env?.Bar?.[ok])
 sort($env?.Bar?.greet)
 sort($env?.String)
+sort($env?.String) | one(.str.add(foobar))
 sort($env?.[Bar])
+sort($env?.[Bar]) ?? array
 sort($env?.[Bar]?.[array])
+sort($env?.[Bar]?.foo())
 sort($env?.[String])
 sort($env?.[foobar])
+sort($env?.[foobar]?.[add])
 sort($env?.[nil])
+sort($env?.[nil]?.String().array)
 sort($env?.[str])
 sort($env?.array)
 sort($env?.false)
@@ -15525,61 +31639,163 @@ sort($env?.foobar)
 sort($env?.foobar?.greet)
 sort($env?.list | reduce(#acc))
 sort($env?.nil)
+sort(0 .. i)
+sort(0 ?? 1.0)
+sort(0 ?? foo)
+sort(0 ?? foo.Bar)
+sort(0 ?? ok)
+sort(1 .. 1)
+sort(1 ?? 1.0)
+sort(1 ?? array)
+sort(1 ?? false)
+sort(1 ?? foo)
+sort(1 ?? greet)
+sort(1 ?? ok)
 sort(1..i)
+sort(1.0 ?? $env)
+sort(1.0 ?? 0)
+sort(1.0 ?? false)
+sort(1.0 ?? foo)
+sort(1.0 ?? greet)
+sort(1.0 ?? i)
+sort(1.0 ?? ok)
+sort(1.0 ?? str)
+sort(1.0 ?? true)
 sort([$env])
 sort([0 .. 0])
 sort([0])
+sort([1 ?? 0])
 sort([1.0])
 sort([1])
 sort([add])
 sort([array])
+sort([f64])
 sort([false])
 sort([foo])
+sort([greet])
 sort([i])
 sort([list])
 sort([nil])
 sort([ok])
 sort([str])
 sort([true])
+sort(add ?? $env)
+sort(add ?? 0)
+sort(add ?? 1.0)
+sort(add ?? array)
+sort(add ?? greet)
+sort(add ?? i)
+sort(add ?? ok)
+sort(array ?? 0)
+sort(array ?? array)
+sort(array ?? foo)
+sort(array ?? nil)
+sort(array ?? true)
+sort(array | filter(ok))
 sort(array | map(#))
+sort(array | map(1))
+sort(array | mean(1))
+sort(array | median(1, i))
 sort(array | sortBy(#))
+sort(array | sortBy(f64))
+sort(array | sortBy(str))
+sort(array | sum(#)..i)
 sort(array)
+sort(array) != list
 sort(array) == list
+sort(array) ?? mean(f64)
+sort(array) ?? not ok
+sort(array) | filter(true)
 sort(array) | find(true)
 sort(array) | findIndex($env?.ok)
+sort(array) | findLast(ok)
 sort(array) | findLastIndex(false)
 sort(array) | get(i)
 sort(array) | groupBy(#)
+sort(array) | groupBy(foo)
 sort(array) | groupBy(str)
 sort(array) | map(#)
 sort(array) | map(0)
 sort(array) | map(1.0)
+sort(array) | map(foo)
 sort(array) | map(list)
+sort(array) | map(ok)
 sort(array) | one(false)
+sort(array) | reduce(#)
+sort(array) | reduce(#index)
 sort(array) | reduce($env)
 sort(array) | reduce(foo)
+sort(array) | reduce(list, greet)
 sort(array) | reduce(true, 1.0)
+sort(array) | sortBy(#)
 sort(array) | sortBy(1)
 sort(array)?.[i]
 sort(array[0:])
+sort(array[:0])
 sort(concat(array))
+sort(f64 ?? $env)
+sort(f64 ?? foo)
 sort(false ? true : 0)
+sort(false ?: $env)
 sort(false ?: 1.0)
 sort(false ?: i)
+sort(false ?: list)
+sort(false ?? $env)
+sort(false ?? add)
+sort(false ?? array)
+sort(false ?? foo)
+sort(false ?? greet)
+sort(false ?? list)
 sort(filter($env, false))
+sort(filter(list, false))
 sort(first($env))
+sort(flatten(array))
+sort(foo ?? $env)
+sort(foo ?? 0)
+sort(foo ?? 1)
+sort(foo ?? 1.0)
+sort(foo ?? add)
+sort(foo ?? array)
+sort(foo ?? f64)
+sort(foo ?? false)
+sort(foo ?? i)
+sort(foo ?? ok)
+sort(foo ?? true)
+sort(greet ?? $env)
+sort(greet ?? foo)
+sort(i .. 0)
+sort(i .. 1)
+sort(i ?? $env)
+sort(i ?? 1.0)
+sort(i ?? f64)
+sort(i ?? list)
 sort(if false { 1 } else { 1.0 })
 sort(if false { 1.0 } else { 1 })
+sort(if false { false } else { f64 })
+sort(if false { foo } else { 1.0 })
+sort(if false { nil } else { $env })
 sort(if ok { ok } else { 1.0 })
 sort(if true { add } else { str })
+sort(if true { array } else { i })
 sort(if true { f64 } else { $env })
+sort(if true { foo } else { 1.0 })
 sort(if true { greet } else { 1 })
 sort(keys($env))
 sort(last($env))
+sort(list ?? 1)
+sort(list ?? 1.0)
+sort(list ?? add)
+sort(list ?? str)
+sort(list ?? true)
 sort(list | map(#.Bar))
+sort(list | reduce(array))
+sort(map($env, #index))
+sort(map($env, i))
 sort(map(array, #))
 sort(map(array, 0))
 sort(map(array, 1.0))
+sort(map(list, #.Bar))
+sort(map(list, 1.0))
 sort(map(list, str))
 sort(max($env))
 sort(max(array))
@@ -15589,33 +31805,74 @@ sort(median(array))
 sort(min($env))
 sort(min(array))
 sort(min(array, 1.0))
+sort(nil ?? $env)
 sort(ok ? 1.0 : $env)
 sort(ok ? list : str)
 sort(ok ?: 1.0)
 sort(ok ?: list)
+sort(ok ?? 0)
+sort(ok ?? add)
+sort(ok ?? f64)
+sort(ok ?? foo)
+sort(ok ?? list)
+sort(reduce(array, $env))
 sort(reduce(array, array))
+sort(reduce(list, $env))
 sort(reverse(array))
 sort(sort($env))
+sort(sort([str]))
 sort(sort(array))
 sort(sortBy(array, 1.0))
+sort(str ?? $env)
+sort(str ?? $env.list)
+sort(str ?? 0)
+sort(str ?? 1.0)
+sort(str ?? foo)
+sort(str ?? greet)
+sort(str ?? true)
 sort(toPairs($env))
+sort(true ? 0 : $env)
 sort(true ? i : 1.0)
+sort(true ? list : 1)
+sort(true ?? 1.0)
+sort(true ?? f64)
+sort(true ?? foo)
+sort(true ?? greet)
+sort(true ?? str)
 sort({foo: 1.0}.add)
+sort({foo: foo, foo: add}.Bar)
+sort({foo: nil, foo: foo}.add)
+sort({foo: nil}.i)
 sort({foo: str}.greet)
+sort({foo: true}.Bar)
+sortBy($env, #) == $env || true
 sortBy($env.array, #)
 sortBy($env.array, f64)
+sortBy($env.array, str)
 sortBy($env.list, #.Bar)
 sortBy($env.list, f64)
+sortBy($env.list, i)
+sortBy($env.list, str)
+sortBy($env?.[str], #)
 sortBy($env?.[str], $env?.i)
 sortBy($env?.[str], f64)
+sortBy($env?.[str], str)
 sortBy($env?.array, #)
+sortBy($env?.array, str)
+sortBy($env?.list, .Bar)
 sortBy($env?.list, f64)
+sortBy($env?.list, i)
 sortBy(0 .. 0, #)
+sortBy(0 .. 0, str)
 sortBy(0 .. 1, #)
 sortBy(0 .. i, # ^ i)
 sortBy([$env], #)
+sortBy([$env], #.String?.[foo])
 sortBy([$env], #?.add)
 sortBy([$env], .list)
+sortBy([$env], f64 ?? .array)
+sortBy([$env], greet)
+sortBy([$env], str)
 sortBy([0], $env.ok)
 sortBy([0], $env?.Bar)
 sortBy([0], add)
@@ -15624,84 +31881,168 @@ sortBy([1.0], $env?.ok)
 sortBy([1.0], f64)
 sortBy([1], 0 >= #)
 sortBy([array], f64)
+sortBy([f64], # + #)
 sortBy([f64], add)
+sortBy([f64], array)
+sortBy([f64], f64)
+sortBy([f64], i)
 sortBy([false], list)
 sortBy([foo], #)
+sortBy([foo], #?.Bar)
 sortBy([foo], add)
 sortBy([foo], array)
 sortBy([foo], foo)
+sortBy([greet], #)
+sortBy([groupBy(array, #)], #)
+sortBy([i], array)
 sortBy([list], #)
+sortBy([nil], add)
 sortBy([nil], array)
+sortBy([ok], add)
+sortBy([str], #)
+sortBy([str], findIndex(list, ok))
 sortBy([true], f64)
 sortBy([true], i)
+sortBy(array ?? 1.0, #)
+sortBy(array ?? f64, f64)
+sortBy(array | sortBy(#), #)
 sortBy(array, # * #)
 sortBy(array, # ** #)
 sortBy(array, # + #)
+sortBy(array, # - 1)
+sortBy(array, # / #)
+sortBy(array, # / f64)
+sortBy(array, # ?? #)
+sortBy(array, # ?? foo)
+sortBy(array, # ?? str)
 sortBy(array, # ^ #)
+sortBy(array, # ^ 1)
+sortBy(array, # | bitshl(#))
+sortBy(array, # | mean(#, #))
 sortBy(array, #)
+sortBy(array, #) | any(ok)
 sortBy(array, #) | findIndex(false)
 sortBy(array, #) | groupBy(true)
+sortBy(array, #) | map(#)
+sortBy(array, #) | map($env)
 sortBy(array, #) | map(0)
+sortBy(array, #) | map(foo)
+sortBy(array, #) | min(array, 1)
 sortBy(array, #) | reduce(#)
+sortBy(array, #) | reduce(#, 1)
 sortBy(array, #) | reduce($env)
+sortBy(array, #) | reduce(1.0, nil)
+sortBy(array, #) | reduce(true, 1.0)
 sortBy(array, #)?.[i]
+sortBy(array, $env.f64)
 sortBy(array, $env.i)
+sortBy(array, $env.str)
 sortBy(array, $env?.[str])
 sortBy(array, $env?.i)
+sortBy(array, -#)
+sortBy(array, -0)
+sortBy(array, -1.0)
 sortBy(array, 0 * #)
+sortBy(array, 0 ** #)
 sortBy(array, 0 - 1)
 sortBy(array, 0) | map(#)
+sortBy(array, 0) | sortBy(#)
 sortBy(array, 0)?.[i]
 sortBy(array, 1 ** f64)
+sortBy(array, 1 + #)
 sortBy(array, 1 / #)
+sortBy(array, 1 ?? false)
 sortBy(array, 1 ^ #)
+sortBy(array, 1) | all(ok)
 sortBy(array, 1) | groupBy(#)
 sortBy(array, 1) | reduce($env)
+sortBy(array, 1) | reduce(foo)
 sortBy(array, 1)?.[i]
 sortBy(array, 1.0 ^ #)
+sortBy(array, 1.0) | findLast(false)
+sortBy(array, 1.0) | max(1.0)
 sortBy(array, 1.0)?.[i]
 sortBy(array, abs(#))
+sortBy(array, bitnand(#, #))
 sortBy(array, bitnot(#))
 sortBy(array, f64 ** #)
 sortBy(array, f64)
+sortBy(array, f64) | groupBy(1.0)
+sortBy(array, f64) | reduce(#, 1.0)
 sortBy(array, f64)?.[i]
 sortBy(array, findLast(array, ok))
 sortBy(array, findLastIndex($env, ok))
 sortBy(array, float(1))
+sortBy(array, foo.Bar)
+sortBy(array, foo?.Bar)
 sortBy(array, i ** #)
+sortBy(array, i + 1)
+sortBy(array, i - #)
 sortBy(array, i)
+sortBy(array, i) | find(false)
+sortBy(array, i) | map(list)
 sortBy(array, i)?.[i]
 sortBy(array, max(#))
 sortBy(array, mean(#))
+sortBy(array, median(1.0))
+sortBy(array, min(#))
 sortBy(array, round(#))
 sortBy(array, round(i))
 sortBy(array, str)
+sortBy(array, str) | groupBy(1.0)
 sortBy(array, str) | map(list)
 sortBy(array, str) | none(ok)
+sortBy(array, str) | reduce(#)
+sortBy(array, str) | reduce(ok)
+sortBy(array, str) | sortBy(0)
 sortBy(array, str)?.[i]
+sortBy(array, string(1.0))
+sortBy(array, toJSON(f64))
 sortBy(array, toJSON(foo))
 sortBy(array, toJSON(nil))
 sortBy(array[:i], str)
 sortBy(concat(array), #)
 sortBy(concat(array), round(i))
 sortBy(filter($env, false), #.foo)
+sortBy(filter($env, false), .add)
+sortBy(filter($env, false), findLast($env, #.greet))
+sortBy(flatten(array), #)
 sortBy(flatten(list), f64)
+sortBy(flatten(list), str)
 sortBy(let foobar = array; foobar, # * 1.0)
 sortBy(list | map(i), # ^ #)
 sortBy(list, #.Bar)
+sortBy(list, #.Bar) | map(#)
 sortBy(list, #.Bar)?.[i]
 sortBy(list, #.String())
 sortBy(list, #?.Bar)
 sortBy(list, $env.f64)
 sortBy(list, $env.i)
+sortBy(list, $env.str)
+sortBy(list, $env?.[str])
 sortBy(list, $env?.i)
+sortBy(list, -0)
+sortBy(list, -1.0)
+sortBy(list, -f64)
 sortBy(list, .Bar)
+sortBy(list, .Bar) != list
 sortBy(list, .Bar) | sum(f64)
+sortBy(list, 0 ^ 0)
+sortBy(list, 0) ?? greet
 sortBy(list, 0)?.[i]
+sortBy(list, 1 ?? #)
+sortBy(list, 1 ?? greet)
 sortBy(list, 1)?.[i]
 sortBy(list, 1.0 ** f64)
+sortBy(list, 1.0 + i)
+sortBy(list, 1.0) | groupBy(true)
+sortBy(list, 1.0) | map(list)
+sortBy(list, 1.0) | reduce(greet)
+sortBy(list, 1.0) | sortBy(i)
 sortBy(list, 1.0)?.[$env?.i]
+sortBy(list, 1.0)?.[i]
 sortBy(list, abs(0))
+sortBy(list, abs(f64))
 sortBy(list, bitnand(0, 1))
 sortBy(list, bitnot(1))
 sortBy(list, f64)
@@ -15710,34 +32051,59 @@ sortBy(list, f64) | map($env)
 sortBy(list, f64) | reduce(#)
 sortBy(list, f64) | sum(0)
 sortBy(list, f64)?.[i]
+sortBy(list, foo.String())
+sortBy(list, foo?.Bar)
 sortBy(list, greet(#.Bar))
 sortBy(list, greet(.Bar))
 sortBy(list, greet(str))
+sortBy(list, i ?? #)
+sortBy(list, i ?? $env)
 sortBy(list, i)
 sortBy(list, i) == list
+sortBy(list, i) | one(false)
 sortBy(list, i) | reduce($env)
+sortBy(list, i) | reduce(add)
+sortBy(list, i)?.[i]
 sortBy(list, len(#.Bar))
+sortBy(list, len(list))
 sortBy(list, reduce(array, i))
+sortBy(list, round(1))
+sortBy(list, round(1.0))
 sortBy(list, str)
+sortBy(list, str) | map(0)
+sortBy(list, str) | map(array)
 sortBy(list, str) | reduce(true)
 sortBy(list, str)?.[i]
+sortBy(list, string(#.Bar))
 sortBy(list, string(1.0))
 sortBy(list, string(greet))
 sortBy(list, string(ok))
+sortBy(list, sum(array))
+sortBy(list, toBase64(#.Bar))
 sortBy(list, toBase64(str))
 sortBy(list, toJSON(#.Bar))
 sortBy(list, toJSON(i))
+sortBy(list, trimPrefix(str))
+sortBy(list, type(1.0))
 sortBy(list, type(add))
 sortBy(list, type(false))
 sortBy(list, type(list))
 sortBy(map($env, greet), type(f64))
+sortBy(map(array, #), #)
+sortBy(map(array, add), bitnot(1))
 sortBy(sort($env), #)
 sortBy(sort($env), #.array .. .f64)
+sortBy(sort($env), f64)
 sortBy(sort($env), map(#.list, array))
+sortBy(sort($env), ok)
 sortBy(sortBy(array, i), #)
 sortBy(take(list, 1), #)
+sortBy(uniq(array), #)
+split($env.str, str)
 split(str, $env?.[str])
+split(str, $env?.str)
 split(str, str)
+split(str, str)?.[i]
 split(str, string($env))
 split(str, toBase64(str))
 splitAfter(foo?.Bar, str)
@@ -15747,41 +32113,94 @@ splitAfter(str, toJSON(nil))
 str
 str != $env == $env
 str != $env ? 1.0 : $env
+str != $env ?? $env
+str != $env ?? 1.0
+str != $env ?? i
+str != $env and false
 str != $env and ok
 str != $env or $env
+str != $env or false
 str != $env.str
 str != $env?.Bar
 str != $env?.String
 str != $env?.[Bar]
 str != $env?.[String]
+str != $env?.[foobar]
 str != $env?.[nil]
 str != $env?.[str]
+str != $env?.foobar
+str != $env?.foobar?.[greet]
 str != $env?.str
+str != 0 ?? array
+str != 1 ?? f64
+str != 1 ?? foo
+str != 1.0 ?? 1
+str != 1.0 ?? concat($env, $env)
+str != 1.0 ?? list
+str != add ?? foo
+str != array ?? $env?.[String]
+str != f64 ?? array
+str != first($env)
+str != foo ?? $env?.greet
+str != foo ?? 1.0
+str != foo ?? array
+str != foo ?? f64
+str != foo ?? false
+str != foo ?? greet
+str != foo ?? greet and $env
 str != foo.Bar
 str != foo.String()
 str != foo?.Bar
 str != foo?.String()
+str != greet ?? $env?.[String]
+str != greet ?? array
+str != greet ?? ok
 str != greet(str)
+str != i ?? array
+str != list ?? 1
+str != list ?? false
+str != list ?? true
+str != lower(str)
 str != median(array)
 str != min(array, array)
+str != nil != nil
 str != nil && $env
+str != nil == true
 str != nil ? foo : f64
+str != nil ?? $env
 str != nil or $env
 str != nil or $env?.[Bar]
 str != nil or ok
 str != nil || $env
+str != nil || false
+str != nil || ok
+str != ok ?? 1
 str != reduce(array, #acc, foo)
 str != reduce(list, .Bar, false)
 str != str
+str != str != false
 str != str && $env?.String.i()
 str != str && true
 str != str ? 0 : 1.0
 str != str ? foo : true
+str != str ?? 1.0
+str != str ?? i
+str != str ?? ok
+str != str and $env
+str != str || $env
+str != str || false
+str != string(1.0)
 str != string(f64)
+str != string(false)
 str != string(list)
+str != toJSON(1.0)
 str != toJSON(false)
 str != toJSON(foo)
 str != trim(str)
+str != true ?? f64
+str != true ?? str
+str != type($env)
+str != type(false)
 str != type(foo)
 str != type(str)
 str + $env not endsWith $env and false
@@ -15793,35 +32212,54 @@ str + foo.String()
 str + foo?.Bar
 str + foo?.String()
 str + greet(str)
+str + repeat(str, 1)
 str + str
 str + str != $env
+str + str ?? foo
+str + str in max($env)
+str + str not in $env
 str + string($env)
 str + string(add)
 str + string(f64)
+str + string(list)
+str + string(nil)
 str + string(str)
 str + toBase64(str)
+str + toJSON(1.0)
+str + toJSON(false)
 str + toJSON(i)
 str + toJSON(list)
 str + toJSON(nil)
+str + toJSON(ok)
 str + toJSON(str)
 str + type($env)
+str + type(foo)
 str < $env && false
 str < $env.str
 str < $env?.[str]
 str < $env?.str
+str < -$env or true
 str < foo.Bar
 str < foo.String()
 str < foo?.Bar
 str < foo?.String()
 str < greet(str)
+str < nil ?? str
 str < str
 str < str && false
+str < str and ok
 str < str || ok
+str < string($env)
 str < string(add)
 str < string(foo)
+str < string(greet)
+str < string(str)
+str < toJSON(foo)
 str < type(array)
 str < type(nil)
+str < type(str)
 str < type(true)
+str <= $env or true
 str <= $env.str
 str <= $env?.[str]
 str <= $env?.foobar and false
@@ -15832,15 +32270,31 @@ str <= foo?.Bar
 str <= foo?.String()
 str <= greet(str)
 str <= str
+str <= str != $env
+str <= str != nil
 str <= str ?: str
+str <= str ?? f64
 str <= str[:i]
 str <= string($env)
 str <= string(0)
+str <= string(i)
 str <= string(list)
 str <= string(nil)
+str <= string(true)
+str <= toJSON(1.0)
+str <= toJSON(f64)
+str <= toJSON(foo)
 str <= toJSON(nil)
+str <= toJSON(ok)
 str <= type(1.0)
+str <= type(add)
+str <= type(foo)
+str <= type(list)
+str <= type(str)
 str <= type(true)
+str == $env != nil
+str == $env && ok
+str == $env ?? 1
 str == $env or $env
 str == $env || $env?.[Bar]
 str == $env.str
@@ -15848,61 +32302,98 @@ str == $env?.Bar
 str == $env?.String
 str == $env?.[Bar]
 str == $env?.[Bar]?.[array]
+str == $env?.[Bar]?.[list]
 str == $env?.[String]
+str == $env?.[String]?.add
 str == $env?.[String]?.array
 str == $env?.[foobar]
 str == $env?.[str]
 str == $env?.foo.Bar
 str == $env?.foobar
+str == $env?.foobar?.String
 str == $env?.not
 str == $env?.str
 str == $env?.true
+str == 0 ?? 1.0
+str == 1 ?? add
+str == 1.0 ?? foo
+str == add ?? list
+str == f64 ?? 0
+str == false ?? str
 str == first($env)
+str == foo ?? add
+str == foo ?? str
 str == foo.Bar
 str == foo.String()
 str == foo?.Bar
 str == foo?.String()
 str == greet(str)
+str == i ?? array
+str == list ?? foo
 str == max($env)
+str == nil == ok
+str == nil ?: list
 str == nil or true || $env
 str == reduce(array, str)
 str == str
+str == str || $env[true:]
 str == str || true
 str == string(add)
 str == string(foo)
+str == string(ok)
 str == toBase64(str | repeat(0))
 str == toJSON(0)
 str == toJSON(1.0)
+str == toJSON(f64)
+str == toJSON(nil)
 str == trim(str)
+str == true ?? foo
 str == type(add)
 str == type(foo)
 str == type(greet)
+str == upper(str)
 str == {foo: 1}.array
 str > $env or true
 str > $env || true
 str > $env.str
 str > $env?.[str]
+str > $env?.foo?.String()
 str > $env?.str
 str > foo.Bar
+str > foo.Bar < foo.Bar
 str > foo.String()
 str > foo?.Bar
 str > foo?.String()
 str > str
+str > str + $env.str
 str > str + str
+str > str < $env?.str
+str > str > $env?.Bar
+str > str > $env?.[list]
 str > str ?: 1
+str > str ?: str
 str > str and true
 str > str[1:]
+str > str[int(0):]
 str > string($env)
+str > string(nil)
+str > string(true)
+str > toJSON(1.0)
+str > toJSON(foo)
 str > toJSON(ok)
 str > trimSuffix(str)
 str > type(1)
 str > type(1.0)
 str > type(add)
+str > type(false)
 str > type(nil)
+str > upper(toJSON(false))
 str >= $env && false
 str >= $env or true
 str >= $env.str
 str >= $env?.[str]
+str >= $env?.[str] ?? list
+str >= $env?.foo.Bar
 str >= $env?.str
 str >= foo.Bar
 str >= foo.String()
@@ -15910,13 +32401,279 @@ str >= foo?.Bar
 str >= foo?.String()
 str >= greet(str)
 str >= str
+str >= str != $env
+str >= str ?? nil
 str >= string(1)
 str >= string(1.0)
+str >= string(add)
+str >= string(str)
 str >= toJSON(false)
+str >= toJSON(str)
+str >= type(1)
 str >= type(list)
+str ?? !$env
+str ?? !ok
+str ?? $env ?? f64
+str ?? $env ?? foo
+str ?? $env ?? foo?.String
+str ?? $env ?? list
+str ?? $env ?? ok
+str ?? $env ?? str
+str ?? $env | any(false)
+str ?? $env | greet()
+str ?? $env | groupBy(#)
+str ?? $env | map(#)
+str ?? $env | reduce(#)
+str ?? $env | reduce($env, false)
+str ?? $env | reduce(0)
+str ?? $env | reduce(foo, foo)
+str ?? $env | reduce(true, 1.0)
+str ?? $env | sum(#)
+str ?? $env.add
+str ?? $env.array
+str ?? $env.f64
+str ?? $env.foo
+str ?? $env.greet
+str ?? $env.i
+str ?? $env.list
+str ?? $env.ok
+str ?? $env.str
+str ?? $env?.Bar
+str ?? $env?.Bar()
+str ?? $env?.Bar(foo)
+str ?? $env?.Bar(list)
+str ?? $env?.String
+str ?? $env?.String()
+str ?? $env?.String(foo contains foobar)
+str ?? $env?.[1.0]
+str ?? $env?.[Bar | any(1)]
+str ?? $env?.[Bar()]
+str ?? $env?.[Bar]
+str ?? $env?.[Bar].String()
+str ?? $env?.[String]
+str ?? $env?.[String].list
+str ?? $env?.[[foo]]
+str ?? $env?.[add]
+str ?? $env?.[add].greet
+str ?? $env?.[add]?.[f64]
+str ?? $env?.[array]
+str ?? $env?.[array].f64()
+str ?? $env?.[f64]
+str ?? $env?.[f64].f64
+str ?? $env?.[foo]
+str ?? $env?.[foobar]
+str ?? $env?.[greet]
+str ?? $env?.[i]
+str ?? $env?.[i]?.foo
+str ?? $env?.[list]
+str ?? $env?.[list]?.add?.[array]
+str ?? $env?.[list]?.i
+str ?? $env?.[nil]
+str ?? $env?.[ok]
+str ?? $env?.[ok]?.Bar
+str ?? $env?.[str]
+str ?? $env?.add
+str ?? $env?.array
+str ?? $env?.f64
+str ?? $env?.foo
+str ?? $env?.foobar
+str ?? $env?.greet
+str ?? $env?.i
+str ?? $env?.list
+str ?? $env?.nil
+str ?? $env?.ok
+str ?? $env?.str
+str ?? $env[:foobar]
+str ?? $env[:list?.f64()]
+str ?? $env[f64:]
+str ?? $env[ok:]
+str ?? -$env
+str ?? -0
+str ?? -1
+str ?? -1.0
+str ?? -i
+str ?? 0 | all(false)
+str ?? 0 | groupBy(foo)
+str ?? 0 | map(greet)
+str ?? 0 | map(ok)
+str ?? 0 | sum(f64)
+str ?? 1 ?? foo
+str ?? 1 | greet()
+str ?? 1 | map(foo)
+str ?? 1 | map(i)
+str ?? 1.0 ?? foo
+str ?? 1.0 | findLast(true)
+str ?? 1.0 | findLastIndex(ok)
+str ?? 1.0 | groupBy(#)
+str ?? 1.0 | groupBy(0)
+str ?? 1.0 | map(#)
+str ?? 1.0 | map(1)
+str ?? 1.0 | map(1.0)
+str ?? 1.0 | reduce(#)
+str ?? 1.0 | reduce(false == #)
+str ?? 1.0 | sum(#)
+str ?? [0, i]
+str ?? [1.0]
+str ?? [f64]
+str ?? [foo]
+str ?? [nil]
+str ?? [true]
+str ?? add
+str ?? add ?? $env
+str ?? add | count(true)
+str ?? add | map(add)
+str ?? add | reduce(foo)
+str ?? add | reduce(greet)
+str ?? all($env, #)
+str ?? all(list, $env)
+str ?? array
+str ?? array | findIndex(true)
+str ?? array | map(array)
+str ?? array | none(true)
+str ?? array?.[i]
+str ?? concat(array)
+str ?? count($env)
+str ?? date(array)
+str ?? date(greet)
+str ?? date(ok, foo)
+str ?? duration(str)
+str ?? f64
+str ?? f64 | groupBy(#)
+str ?? false | count(false)
+str ?? false | findLastIndex(# not in list)
+str ?? false | groupBy(#)
+str ?? false | map(0)
+str ?? false | map(foo)
+str ?? false | reduce(#)
+str ?? findIndex($env, #)
+str ?? first($env)
+str ?? float(1.0)
+str ?? floor(1)
+str ?? foo
+str ?? foo ?? $env
+str ?? foo ?? 1.0
+str ?? foo ?? f64
+str ?? foo ?? list
+str ?? foo ?? nil
+str ?? foo ?? ok
+str ?? foo ?? str
+str ?? foo | any(ok)
+str ?? foo | count(ok)
+str ?? foo | findLastIndex(false)
+str ?? foo | findLastIndex(ok)
+str ?? foo | groupBy(1.0)
+str ?? foo | map(#)
+str ?? foo | map(ok)
+str ?? foo | none(ok)
+str ?? foo | none(true)
+str ?? foo | one(false)
+str ?? foo | reduce(#, 1)
+str ?? foo | reduce(add)
+str ?? foo | reduce(greet, foo)
+str ?? foo | reduce(i, nil)
+str ?? foo | sortBy(0)
+str ?? foo | sum(#)
+str ?? foo.Bar
+str ?? foo.String
+str ?? foo.String()
+str ?? foo?.Bar
+str ?? foo?.String
+str ?? fromJSON($env)
+str ?? greet
+str ?? greet | greet()
+str ?? greet | groupBy(1.0)
+str ?? greet | groupBy(i)
+str ?? greet | groupBy(ok)
+str ?? greet | none(true)
+str ?? greet | reduce(#)
+str ?? greet | reduce(str)
+str ?? greet($env)
+str ?? greet(str)
+str ?? groupBy($env, 1.0)
+str ?? i
+str ?? i ?? 1
+str ?? i ?? ok
+str ?? i | map(true)
+str ?? i | reduce(#)
+str ?? i | reduce($env)
+str ?? i | reduce($env, greet)
+str ?? i | reduce(false)
+str ?? i | sortBy(#)
+str ?? i | sum(#)
+str ?? indexOf($env, str)
+str ?? len(list)
+str ?? list
+str ?? list ?? $env | reduce(#)
+str ?? list ?? true
+str ?? list | any(ok)
+str ?? list | map(list)
+str ?? list | map(str)
+str ?? list | sortBy(f64)
+str ?? list?.[i]
+str ?? map($env, add)
+str ?? map(array, 1)
+str ?? max($env)
+str ?? max(0, 1)
+str ?? max(1.0)
+str ?? mean(array).i()
+str ?? min(1.0)
+str ?? min(list)
+str ?? nil ?? list
+str ?? nil | greet()
+str ?? not $env
+str ?? not false
+str ?? not true
+str ?? ok
+str ?? ok ?? array
+str ?? ok ?? toJSON(1)
+str ?? ok | all(ok)
+str ?? ok | find(ok)
+str ?? ok | findIndex(false)
+str ?? ok | groupBy(foo)
+str ?? ok | map(#)
+str ?? ok | map($env)
+str ?? ok | map(list)
+str ?? one($env, .greet)
+str ?? reduce($env, #)
+str ?? round(0)
+str ?? sortBy(array, f64)
+str ?? str
+str ?? str ?? str
+str ?? str[:sum(array)]
+str ?? string(1)
+str ?? string(array)
+str ?? string(true)
+str ?? sum($env)
+str ?? sum($env, #.f64)
+str ?? sum($env, .String)
+str ?? sum(array, foo)
+str ?? toJSON(0)
+str ?? toJSON(foo)
+str ?? toJSON(nil)
+str ?? toJSON(str)
+str ?? toPairs($env)
+str ?? toPairs($env?.String)
+str ?? trim($env)
+str ?? trimSuffix($env)
+str ?? true ?? greet
+str ?? true | all(true)
+str ?? true | find(false)
+str ?? true | greet()
+str ?? true | reduce(#)
+str ?? true | reduce($env)
+str ?? true | sum(1.0)
+str ?? type(1)
+str ?? type(1.0)
+str ?? type(nil)
+str ?? {foo: 1.0}
+str ?? {foo: 1}
+str ?? {foo: array}
+str ?? {foo: nil}
+str ?? {foo: true}
 str contains $env.str
 str contains $env?.Bar
 str contains $env?.String
+str contains $env?.String?.[i]
 str contains $env?.String?.list
 str contains $env?.[Bar]
 str contains $env?.[Bar]?.foo
@@ -15932,62 +32689,106 @@ str contains foo.String()
 str contains foo?.Bar
 str contains foo?.String()
 str contains greet(str)
+str contains last($env)
 str contains str
+str contains str && ok
+str contains str == ok
+str contains str ?? $env
+str contains str ?? list
+str contains str ?? str
+str contains str or $env?.[foo]
+str contains str[:i]
+str contains string(greet)
 str contains string(ok)
 str contains string(str)
 str contains toJSON(f64)
+str contains toJSON(foo)
+str contains toJSON(nil)
 str contains toJSON(ok)
+str contains trimSuffix(str)
 str contains type(foo)
 str contains type(nil)
 str contains type(ok)
 str endsWith $env.str
 str endsWith $env?.Bar
+str endsWith $env?.Bar?.foo(foo)
 str endsWith $env?.String
 str endsWith $env?.[Bar]
+str endsWith $env?.[Bar]?.add
 str endsWith $env?.[String]
 str endsWith $env?.[String]?.[add]
 str endsWith $env?.[foobar]
 str endsWith $env?.[str]
+str endsWith $env?.foobar
 str endsWith $env?.str
+str endsWith first($env)
 str endsWith foo.Bar
 str endsWith foo.String()
 str endsWith foo?.Bar
 str endsWith foo?.String()
 str endsWith greet(str)
 str endsWith str
+str endsWith str == nil
+str endsWith str ?? foo
+str endsWith str ?? ok
 str endsWith string(foo)
 str endsWith string(nil)
 str endsWith string(ok)
 str endsWith toJSON(0)
 str endsWith toJSON(foo)
 str endsWith toJSON(i)
+str endsWith toJSON(nil)
+str endsWith toJSON(str)
 str endsWith toJSON(true)
 str endsWith trimPrefix($env.str)
+str endsWith trimSuffix(str)
+str endsWith type($env)
+str endsWith type(add)
+str endsWith type(i)
 str endsWith type(list)
+str endsWith type(str)
 str endsWith {foo: f64}.f64
 str endsWith {foo: nil, foo: $env}?.f64
+str in $env != $env
 str in $env && $env
 str in $env == ok
+str in $env ?? $env?.[i]
+str in $env ?? str
+str in $env and $env
+str in $env and false
+str in $env and ok
 str in $env || $env
+str in $env || ok
 str in $env.foo
 str in $env?.Bar
 str in $env?.String
+str in $env?.String?.[f64]
 str in $env?.[Bar]
+str in $env?.[Bar]?.[ok]
 str in $env?.[Bar]?.[str]
 str in $env?.[String]
 str in $env?.[String]?.str()
 str in $env?.[foobar?.[str]]
+str in $env?.[foobar]
 str in $env?.foo
 str in $env?.foobar
 str in $env?.foobar?.greet
 str in [$env, nil]
 str in [nil]
+str in array ?? foo
 str in concat(array)
+str in find($env, false)
 str in find(list, true)
 str in foo
+str in foo != false
+str in foo ?? greet
+str in foo and array != array
 str in foo and false
 str in foo || $env
 str in list?.[i]
+str in min($env)
+str in sort(array)
+str in {foo: $env?.[Bar]}
 str in {foo: 1}
 str in {foo: f64}
 str in {foo: foo}
@@ -16005,23 +32806,40 @@ str matches $env?.[String]
 str matches $env?.[foobar]
 str matches $env?.[foobar]?.str
 str matches $env?.[str]
+str matches $env?.foobar
 str matches $env?.foobar?.[ok]
 str matches $env?.str
 str matches foo.Bar
 str matches foo.String()
 str matches foo?.Bar
 str matches foo?.String()
+str matches last($env)
+str matches lower(str)
 str matches str
+str matches str == nil
+str matches str ?? 1.0
+str matches str ?? foo
+str matches str ?? i
+str matches str || $env
+str matches string($env)
 str matches string($env?.[String])
 str matches string(1)
 str matches string(1.0)
 str matches string(add)
+str matches toBase64(str)
+str matches toJSON(1.0)
 str matches toJSON(nil)
+str matches toJSON(ok)
+str matches trimSuffix(str)
 str matches type(0)
+str matches type(1)
+str matches type(f64)
 str matches type(foo)
+str matches type(greet)
 str matches type(i)
 str matches type(str)
 str matches type(true)
+str matches {foo: i}?.foobar
 str not contains $env.str
 str not contains $env?.Bar
 str not contains $env?.Bar?.[f64]
@@ -16031,36 +32849,56 @@ str not contains $env?.[Bar]
 str not contains $env?.[Bar]?.Bar()
 str not contains $env?.[String]
 str not contains $env?.[foobar]
+str not contains $env?.[nil]
 str not contains $env?.[str]
 str not contains $env?.foobar
 str not contains $env?.nil
 str not contains $env?.str
+str not contains $env?.true?.[greet]
 str not contains foo.Bar
 str not contains foo.String()
 str not contains foo?.Bar
 str not contains foo?.String()
 str not contains greet(str)
+str not contains last($env)
 str not contains last($env)?.add
+str not contains lower(str)
 str not contains str
+str not contains str && $env
 str not contains str + str
 str not contains str[:1]
+str not contains string($env)
+str not contains string(add)
+str not contains string(nil)
 str not contains string(str)
 str not contains toJSON(0)
+str not contains toJSON(array)
+str not contains trim(str)
+str not contains trimPrefix(str)
+str not contains trimSuffix(str)
 str not contains type(0)
 str not contains type(foo)
+str not contains type(greet)
 str not contains type(list)
 str not contains type(str)
 str not contains upper(str)
 str not contains {foo: foo}.String
+str not endsWith $env and false
 str not endsWith $env.str
 str not endsWith $env?.Bar
+str not endsWith $env?.Bar?.[list]
 str not endsWith $env?.String
 str not endsWith $env?.[Bar]
+str not endsWith $env?.[Bar]?.String
 str not endsWith $env?.[String]
 str not endsWith $env?.[String]?.String
+str not endsWith $env?.[String]?.[add]?.[add]
+str not endsWith $env?.[String]?.[greet]
 str not endsWith $env?.[foobar?.foo($env)]
 str not endsWith $env?.[str]
 str not endsWith $env?.false
+str not endsWith $env?.foobar
+str not endsWith $env?.greet(str)
 str not endsWith $env?.not
 str not endsWith $env?.str
 str not endsWith first($env)
@@ -16072,38 +32910,77 @@ str not endsWith foo?.String()
 str not endsWith greet(str)
 str not endsWith str
 str not endsWith str && $env?.String
+str not endsWith str ?? array
+str not endsWith str ?? nil
+str not endsWith str || $env.ok
 str not endsWith str || true
 str not endsWith string(1)
+str not endsWith toBase64(str)
+str not endsWith toJSON(foo)
+str not endsWith trimSuffix(str)
 str not endsWith type(i)
 str not endsWith type(list)
+str not endsWith upper(foo?.String())
+str not endsWith {foo: foo}.i
+str not in $env && $env
+str not in $env == $env
+str not in $env ? $env : $env
+str not in $env ? 1.0 : false
+str not in $env ?? list
+str not in $env and false
 str not in $env.foo
 str not in $env?.Bar
+str not in $env?.Bar?.add
 str not in $env?.String
 str not in $env?.String?.[ok]
 str not in $env?.[Bar]
+str not in $env?.[Bar]?.String
 str not in $env?.[Bar]?.list
 str not in $env?.[String]
+str not in $env?.[String]?.[array]
 str not in $env?.[String]?.add()
 str not in $env?.[foobar]
 str not in $env?.[foobar]?.[ok]
+str not in $env?.[foobar]?.ok
 str not in $env?.[nil]
 str not in $env?.foo
 str not in $env?.foobar
+str not in $env?.foobar?.[ok]
+str not in [greet, $env]
+str not in [nil, add]
 str not in [nil, greet]
 str not in [nil]
+str not in array ?? 1
 str not in foo
+str not in foo != false
 str not in foo && $env
+str not in foo && $env || true
+str not in foo && false
+str not in foo ? 1.0 : i
+str not in foo ?? $env
+str not in foo ?? f64
+str not in foo ?? foo
 str not in foo and false
 str not in foo and ok
+str not in foo or $env?.[f64]
 str not in foo || $env
 str not in foo || ok
 str not in foo || true
+str not in groupBy(array, 1)
 str not in groupBy(list, #)
+str not in list ?? foo
 str not in list?.[i]
+str not in map(list, #.Bar)
+str not in nil ?? $env
 str not in reduce($env, $env, list)
+str not in reverse(array)
+str not in reverse(list)
+str not in toPairs($env)
+str not in {foo: $env}
 str not in {foo: 0, foo: add}
 str not in {foo: 1.0}
 str not in {foo: add}
+str not in {foo: array}
 str not in {foo: foo, foo: list, foo: $env}
 str not in {foo: foo}
 str not in {foo: nil}
@@ -16115,18 +32992,28 @@ str not matches $env?.[String]
 str not matches $env?.[foobar]
 str not matches $env?.[str]
 str not matches $env?.foobar
+str not matches $env?.foobar?.[str]
+str not matches $env?.nil
 str not matches $env?.str
 str not matches foo.Bar
 str not matches foo.String()
 str not matches foo?.Bar
 str not matches foo?.String()
+str not matches greet(str)
+str not matches lower(str)
 str not matches str
+str not matches str == $env
+str not matches str ?: {foo: $env}
 str not matches str || ok
+str not matches string(1)
 str not matches string(foo)
 str not matches toJSON(1.0)
 str not matches toJSON(f64)
+str not matches toJSON(foo)
 str not matches toJSON(i)
 str not matches toJSON(nil)
+str not matches toJSON(ok)
+str not matches trimSuffix(str)
 str not matches type(false)
 str not matches type(true)
 str not startsWith $env.str
@@ -16135,32 +33022,46 @@ str not startsWith $env?.Bar
 str not startsWith $env?.String
 str not startsWith $env?.[Bar]
 str not startsWith $env?.[Bar]?.[i]
+str not startsWith $env?.[Bar]?.i
 str not startsWith $env?.[String]
+str not startsWith $env?.[String]?.list
+str not startsWith $env?.[foobar]?.[str]
 str not startsWith $env?.[nil]
 str not startsWith $env?.[str]
+str not startsWith $env?.false?.[add]
 str not startsWith $env?.nil
 str not startsWith $env?.str
+str not startsWith findLast($env, false)
 str not startsWith foo.Bar
 str not startsWith foo.String()
 str not startsWith foo?.Bar
 str not startsWith foo?.String()
 str not startsWith greet(str)
+str not startsWith last($env)
 str not startsWith lower(str)
 str not startsWith str
 str not startsWith str ?: 1.0
 str not startsWith str ?: ok
+str not startsWith str and $env
+str not startsWith string(false)
+str not startsWith string(foo)
+str not startsWith string(i)
 str not startsWith string(nil)
+str not startsWith string(ok)
 str not startsWith toJSON(foo)
 str not startsWith toJSON(true)
 str not startsWith trimSuffix(string(foo))
 str not startsWith type(0)
 str not startsWith type(add)
 str not startsWith type(f64)
+str not startsWith type(i)
 str not startsWith type(ok)
+str not startsWith {foo: i}?.greet
 str startsWith $env.str
 str startsWith $env?.Bar
 str startsWith $env?.String
 str startsWith $env?.String?.[greet]
+str startsWith $env?.String?.array
 str startsWith $env?.[Bar]
 str startsWith $env?.[String]
 str startsWith $env?.[foobar]
@@ -16171,34 +33072,61 @@ str startsWith first($env)
 str startsWith foo.Bar
 str startsWith foo.String()
 str startsWith foo?.Bar
+str startsWith foo?.String()
 str startsWith greet(str)
+str startsWith lower(type(array))
 str startsWith str
 str startsWith str && ok
+str startsWith str ?? nil
 str startsWith str[1:]
+str startsWith string($env)
+str startsWith string(1.0)
+str startsWith string(add)
+str startsWith toBase64(str)
 str startsWith toJSON(1.0)
+str startsWith toJSON(foo)
 str startsWith toJSON(list)
 str startsWith toJSON(true)
+str startsWith type($env)
+str startsWith type(add)
+str startsWith type(foo)
+str startsWith type(i)
+str startsWith type(true)
 str | date(str)
 str | greet()
 str | greet() != $env?.$env
+str | greet() < str
 str | greet() not in foo
 str | hasPrefix($env?.[str])
 str | hasPrefix(str)
 str | hasSuffix(str)
 str | indexOf(str)
+str | indexOf(toJSON(foo))
 str | lastIndexOf(str)
 str | repeat(0)
 str | repeat(1)
 str | repeat(i)
 str | split(str)
+str | split(str, i)
+str | splitAfter($env?.[str])
+str | splitAfter($env?.str)
+str | splitAfter(foo?.Bar)
 str | splitAfter(str)
 str | splitAfter(str, 1)
+str | trim(nil ?? str)
 str | trim(str)
+str | trim(type(1.0))
 str | trimPrefix(str)
 str | trimPrefix(toJSON(ok))
 str | trimPrefix(type(i))
 str | trimSuffix(str)
+str; $env | count(false)
+str; $env?.[Bar]
+str; $env?.add
+str; $env?.ok
 str; add
+str; array
+str; f64
 str; foo
 str; greet
 str; i
@@ -16206,27 +33134,52 @@ str; ok
 str; str
 str; uniq(array)
 str[$env?.i:]
+str[-0:]
+str[-1:]
+str[0:] + str ?? i
+str[1 ?? add:]
+str[1.0 ?? foo:]
 str[1:] endsWith str
 str[1:] not contains str
 str[1:] | greet()
 str[:$env.i]
 str[:$env?.i]
+str[:-1]
+str[:-i]
+str[:0 % i]
+str[:0] matches str
 str[:]
+str[:] <= str
 str[:array | reduce(#)]
 str[:array?.[i]]
 str[:i]
+str[:int(i)]
+str[:last(array)]
 str[:median(1, 1.0)]
 str[:min(0)]
+str[:nil ?? 0]
+str[:sum(array)]
+str[f64 ?? str:]
 str[first(array):]
 str[i:]
+str[i:] endsWith str
 str[i:] not endsWith str
 str[i:i]
+str[len(str):]
+str[nil ?? 0:]
+str[sum(array):]
+string(!false)
+string(!ok)
+string(!true)
 string($env != 0)
 string($env != 1)
 string($env != 1.0)
 string($env != add)
 string($env != f64)
+string($env != false)
 string($env != foo)
+string($env != foo?.String())
+string($env != greet)
 string($env != i)
 string($env != nil)
 string($env != ok)
@@ -16235,18 +33188,36 @@ string($env != true)
 string($env && false)
 string($env && true)
 string($env == $env)
+string($env == 1.0)
 string($env == array)
+string($env == f64)
 string($env == false)
 string($env == foo)
 string($env == greet)
 string($env == nil)
+string($env == str)
+string($env ?? $env)
+string($env ?? 1)
+string($env ?? 1.0)
+string($env ?? add)
+string($env ?? f64)
+string($env ?? false)
+string($env ?? foo)
+string($env ?? list)
+string($env ?? nil)
+string($env ?? ok)
+string($env ?? true)
 string($env and true)
 string($env in $env?.[Bar])
 string($env in array)
+string($env in list)
 string($env not in array)
+string($env or true)
 string($env | all(false))
 string($env | all(ok))
 string($env | count(false))
+string($env | count(ok))
+string($env | count(true))
 string($env | findIndex(ok))
 string($env | findIndex(true))
 string($env | findLastIndex(true))
@@ -16255,16 +33226,29 @@ string($env | map($env))
 string($env | map(1))
 string($env | map(array))
 string($env | map(greet))
+string($env | map(true))
 string($env | none(ok))
+string($env | one(ok))
 string($env | one(true))
+string($env | reduce($env, ok))
+string($env | reduce(1, array))
 string($env | reduce(f64, 1.0))
 string($env | sum(0))
 string($env | sum(1))
 string($env | sum(1.0))
+string($env | sum(f64))
 string($env || false)
+string($env || true)
+string($env) ?? f64
+string($env) ?? i
 string($env) matches str
+string($env) not in foo
+string($env) not matches $env?.Bar
+string($env) not matches str
 string($env) not startsWith str
 string($env) | greet()
+string($env) | trimPrefix(str)
+string($env)[:]
 string($env)[i:]
 string($env.add)
 string($env.array)
@@ -16277,14 +33261,22 @@ string($env.ok)
 string($env.str)
 string($env?.$env)
 string($env?.Bar)
+string($env?.Bar?.[list])
 string($env?.Bar?.[str])
+string($env?.Bar?.greet)
 string($env?.String)
 string($env?.String?.Bar)
 string($env?.String?.String)
+string($env?.String?.list)
 string($env?.[Bar])
+string($env?.[Bar]?.Bar)
 string($env?.[Bar]?.[i])
+string($env?.[Bar]?.foobar)
 string($env?.[String])
+string($env?.[String]?.array)
+string($env?.[String]?.str)
 string($env?.[foobar])
+string($env?.[nil])
 string($env?.[str])
 string($env?.add)
 string($env?.array)
@@ -16295,10 +33287,20 @@ string($env?.foobar)
 string($env?.greet)
 string($env?.i)
 string($env?.list)
+string($env?.nil)
 string($env?.ok)
 string($env?.str)
+string($env?.str[:])
+string($env?.true)
+string(-0)
+string(-1 == nil)
+string(-1)
+string(-1.0)
+string(-f64)
+string(-i)
 string(0 != 0)
 string(0 != 1.0)
+string(0 != i)
 string(0 != nil)
 string(0 % 1)
 string(0 * 0)
@@ -16309,29 +33311,62 @@ string(0 ** 0)
 string(0 ** 1)
 string(0 ** 1.0)
 string(0 ** f64)
+string(0 ** i)
+string(0 + 0)
 string(0 + 1.0)
 string(0 - 1)
+string(0 - i)
+string(0 .. 0)
 string(0 .. i)
+string(0 / $env.f64)
+string(0 / 1)
 string(0 < 0)
 string(0 < 1)
 string(0 < 1.0)
 string(0 < f64)
 string(0 <= 0)
+string(0 <= 1.0)
 string(0 <= f64)
 string(0 <= i)
 string(0 == $env)
 string(0 == 1)
+string(0 == f64)
 string(0 == i)
 string(0 == nil)
+string(0 > 1)
 string(0 > f64)
 string(0 > i)
 string(0 >= 1)
+string(0 >= 1.0)
+string(0 >= f64)
 string(0 >= i)
+string(0 ?? 1)
+string(0 ?? 1.0)
+string(0 ?? array)
+string(0 ?? f64)
+string(0 ?? foo)
+string(0 ?? i)
+string(0 ?? list)
+string(0 ?? str)
+string(0 ?? true)
+string(0 ^ i)
+string(0 | mean(f64))
 string(0) >= str
+string(0) ?? $env?.list
+string(0) ?? 0 | find(true)
+string(0) contains string(str)
+string(0) not startsWith str
+string(0) | greet()
+string(0)[:]
+string(0)[i:]
+string(0..i)
+string(1 != 1)
+string(1 != 1.0)
 string(1 != f64)
 string(1 != nil)
 string(1 % 1)
 string(1 * 0)
+string(1 * 0) ?? add
 string(1 * 1.0)
 string(1 * f64)
 string(1 * i)
@@ -16339,17 +33374,23 @@ string(1 ** 0)
 string(1 ** 1)
 string(1 ** 1.0)
 string(1 ** f64)
+string(1 ** i)
+string(1 + 1)
 string(1 + i)
+string(1 - 0)
 string(1 - 1)
 string(1 - 1.0)
 string(1 - f64)
 string(1 .. 0)
 string(1 .. 1)
+string(1 .. i)
 string(1 / 0)
+string(1 / 1)
 string(1 / 1.0)
 string(1 / f64)
 string(1 < 0)
 string(1 < 1.0)
+string(1 < i)
 string(1 <= 1.0)
 string(1 <= f64)
 string(1 <= i)
@@ -16358,17 +33399,35 @@ string(1 == i)
 string(1 == nil)
 string(1 > $env?.i)
 string(1 > 0)
+string(1 > 1)
 string(1 >= 1)
 string(1 >= 1.0)
 string(1 >= f64)
 string(1 >= i)
+string(1 ?? $env)
+string(1 ?? 0)
+string(1 ?? 1.0)
+string(1 ?? array)
+string(1 ?? f64)
+string(1 ?? false)
+string(1 ?? foo)
+string(1 ?? i)
+string(1 ?? nil)
+string(1 ?? str)
 string(1 ^ 1)
 string(1 ^ 1.0)
 string(1 ^ i)
+string(1 not in array)
 string(1 | min(1.0))
 string(1) != str
+string(1) + str
 string(1) < foo?.Bar
 string(1) == $env?.[Bar]
+string(1) > foo?.Bar
+string(1) ?? i
+string(1) ?? list
+string(1) ?? str
+string(1) matches toJSON(false)
 string(1) not in foo
 string(1) not startsWith toJSON(1)
 string(1) | greet()
@@ -16376,6 +33435,7 @@ string(1..i)
 string(1.0 != $env)
 string(1.0 != 0)
 string(1.0 != 1.0)
+string(1.0 != f64)
 string(1.0 != nil)
 string(1.0 * 0)
 string(1.0 * 1)
@@ -16387,20 +33447,30 @@ string(1.0 ** 1)
 string(1.0 ** 1.0)
 string(1.0 ** f64)
 string(1.0 ** i)
+string(1.0 + 0)
+string(1.0 + 1)
 string(1.0 + 1.0)
 string(1.0 + f64)
 string(1.0 + i)
 string(1.0 - 0)
 string(1.0 - 1)
 string(1.0 - 1.0)
+string(1.0 - f64)
 string(1.0 - i)
 string(1.0 / 0)
 string(1.0 / 1)
 string(1.0 / 1.0)
 string(1.0 / f64)
+string(1.0 / i)
+string(1.0 < 0)
 string(1.0 < 1)
+string(1.0 < 1.0)
+string(1.0 <= 0)
 string(1.0 <= 1)
 string(1.0 <= 1.0)
+string(1.0 <= i)
+string(1.0 == $env)
+string(1.0 == 0)
 string(1.0 == 1)
 string(1.0 == 1.0)
 string(1.0 == f64)
@@ -16409,29 +33479,55 @@ string(1.0 == nil)
 string(1.0 > 0)
 string(1.0 > 1)
 string(1.0 > 1.0)
+string(1.0 > f64)
 string(1.0 > i)
+string(1.0 >= 0)
 string(1.0 >= 1)
 string(1.0 >= 1.0)
+string(1.0 >= i)
+string(1.0 ?? $env)
+string(1.0 ?? 0)
+string(1.0 ?? 1.0)
+string(1.0 ?? array)
+string(1.0 ?? false)
+string(1.0 ?? foo)
+string(1.0 ?? foo) not endsWith str
+string(1.0 ?? list)
+string(1.0 ?? nil)
+string(1.0 ?? ok)
+string(1.0 ?? true)
 string(1.0 ^ 0)
 string(1.0 ^ 1)
 string(1.0 ^ 1.0)
 string(1.0 ^ f64)
 string(1.0 ^ i)
 string(1.0 in array)
+string(1.0 not in array)
+string(1.0 | median(array))
 string(1.0)
 string(1.0) != str
+string(1.0) >= str
+string(1.0) >= string(i)
+string(1.0) ?? add
+string(1.0) endsWith str
+string(1.0) in first($env)
 string(1.0) not startsWith toJSON(false)
 string(1.0) startsWith str
 string(1.0) startsWith type(foo)
 string(1.0) | greet()
+string([$env, 0])
 string([$env, foo])
 string([$env, ok])
 string([$env])
 string([0, nil])
+string([0])
 string([1, true])
+string([1.0, $env])
 string([1.0])
 string([1])
+string([add, 1.0])
 string([add])
+string([array, i])
 string([array])
 string([f64, f64])
 string([f64])
@@ -16440,50 +33536,91 @@ string([false])
 string([foo])
 string([greet, i])
 string([greet])
+string([i])
+string([list, false])
+string([list, list])
+string([list])
+string([nil, list])
 string([nil])
 string([ok, 1])
 string([ok, list])
 string([ok, nil])
 string([ok])
 string([str])
+string([true, greet])
 string([true, list])
 string([true])
 string(abs(0))
 string(abs(1))
 string(abs(1.0))
 string(abs(f64))
+string(abs(i))
+string(add != $env)
+string(add == add)
 string(add == nil)
+string(add ?? 1.0)
+string(add ?? add)
+string(add ?? f64)
+string(add ?? foo)
 string(add(1, 0))
 string(add(1, 1))
+string(add(1, i))
 string(add)
+string(add) ?? ok
 string(add) in foo
 string(add) matches str
 string(add) | greet()
+string(any($env, false))
+string(any($env, ok))
+string(any(array, false))
 string(any(array, ok))
 string(array != $env)
 string(array != array)
+string(array != list)
 string(array != nil)
 string(array == $env)
 string(array == array)
 string(array == list)
 string(array == nil)
+string(array ?? $env)
+string(array ?? 1.0)
+string(array ?? add)
+string(array ?? f64)
+string(array ?? foo)
+string(array ?? i)
 string(array | any(ok))
+string(array | count(false))
+string(array | findIndex(false))
+string(array | findLast(false))
+string(array | groupBy(i))
+string(array | map(#))
 string(array | map($env))
 string(array | map(f64))
 string(array | one(true))
+string(array | reduce(#))
 string(array | reduce(#acc))
 string(array | reduce(add))
+string(array | reduce(foo))
+string(array | reduce(i))
+string(array | reduce(list))
 string(array | sortBy(#))
+string(array | sortBy(i))
 string(array | sum(#))
+string(array | sum(1))
 string(array | sum(f64))
 string(array)
 string(array) > str
 string(array) >= foo.Bar
+string(array) in map(array, $env)
+string(array) matches str
 string(array) not in foo
 string(array) not startsWith str
+string(array) startsWith str
 string(array) | greet()
 string(array)[:i]
 string(array?.[i])
+string(array[0:])
+string(array[1:])
 string(array[i:])
 string(bitnot(0))
 string(bitnot(1))
@@ -16492,56 +33629,102 @@ string(ceil(0))
 string(ceil(1))
 string(ceil(1.0))
 string(ceil(f64))
+string(ceil(i))
 string(concat(array))
+string(concat(list))
 string(count($env, false))
+string(count($env, ok))
+string(count(list, ok))
 string(f64 != $env)
 string(f64 != f64)
 string(f64 != nil)
 string(f64 * 1)
+string(f64 * 1.0)
 string(f64 * f64)
+string(f64 * i)
 string(f64 ** 0)
 string(f64 ** 1.0)
+string(f64 ** i)
 string(f64 + 1)
 string(f64 + 1.0)
 string(f64 + f64)
+string(f64 + i)
 string(f64 - 1)
+string(f64 - i)
+string(f64 / 0)
+string(f64 / 1.0)
+string(f64 < 1)
 string(f64 < 1.0)
 string(f64 < f64)
+string(f64 <= f64)
 string(f64 == $env)
+string(f64 == 0)
+string(f64 == 1)
 string(f64 == 1.0)
 string(f64 == nil)
 string(f64 > 0)
 string(f64 > 1)
 string(f64 > 1.0)
 string(f64 > f64)
+string(f64 > i)
 string(f64 >= 0)
+string(f64 >= 1)
 string(f64 >= 1.0)
 string(f64 >= i)
+string(f64 ?? $env)
+string(f64 ?? add)
+string(f64 ?? array)
+string(f64 ?? f64)
+string(f64 ?? false)
+string(f64 ?? foo)
+string(f64 ?? i)
+string(f64 ?? nil)
 string(f64 ^ 1.0)
 string(f64 ^ i)
+string(f64 not in array)
 string(f64)
 string(f64) + str
 string(f64) < str
+string(f64) <= str
+string(f64) >= str
+string(f64) ?? $env.ok
+string(f64) ?? [foo]
 string(false != $env)
 string(false != false)
+string(false != nil)
 string(false != true)
 string(false && $env)
 string(false && ok)
 string(false == $env)
+string(false == false)
 string(false == nil)
+string(false == true)
 string(false ? foo : 1)
 string(false ?: i)
+string(false ?? $env)
+string(false ?? 1.0)
+string(false ?? f64)
+string(false ?? foo)
+string(false ?? nil)
+string(false and $env)
 string(false and false)
 string(false or $env)
 string(false or false)
 string(false or ok)
 string(false || $env)
+string(false) + foo?.Bar
+string(false) < str
+string(false) == foo.Bar
+string(false) in $env?.[String]
 string(false) not contains str
+string(false) startsWith str
 string(false) | greet()
 string(find(array, false))
+string(find(list, ok))
 string(find(list, true))
 string(findIndex($env, true))
 string(findIndex(list, false))
+string(findLast(list, false))
 string(findLast(list, ok))
 string(findLastIndex($env, false))
 string(findLastIndex(list, false))
@@ -16549,9 +33732,13 @@ string(findLastIndex(list, ok))
 string(first($env))
 string(first(array))
 string(first(list))
+string(first(list)?.Bar)
+string(flatten(array))
 string(flatten(list))
 string(float(0))
+string(float(1))
 string(float(1.0))
+string(float(f64 * 1.0))
 string(float(f64))
 string(float(i))
 string(floor(0))
@@ -16565,17 +33752,43 @@ string(foo != nil)
 string(foo == $env)
 string(foo == foo)
 string(foo == nil)
+string(foo ?? $env)
+string(foo ?? 0)
+string(foo ?? 1.0)
+string(foo ?? add)
+string(foo ?? array)
+string(foo ?? f64)
+string(foo ?? false)
+string(foo ?? foo)
+string(foo ?? foo) ?? list
+string(foo ?? greet)
+string(foo ?? i)
+string(foo ?? list)
+string(foo ?? ok)
+string(foo ?? true)
 string(foo in list)
 string(foo not in list)
 string(foo)
 string(foo) != $env?.Bar
 string(foo) != $env?.foobar
 string(foo) < str
+string(foo) == str
 string(foo) > str
+string(foo) >= str
+string(foo) ?? array
+string(foo) ?? i
+string(foo) ?? list
+string(foo) ?? ok
 string(foo) contains str
+string(foo) contains toJSON(foo)
+string(foo) in list?.[i]
+string(foo) matches str
 string(foo) not endsWith type(str)
+string(foo) not in foo
+string(foo) not matches greet(str)
 string(foo) startsWith str
 string(foo) | greet()
+string(foo)[:]
 string(foo.Bar)
 string(foo.String())
 string(foo.String)
@@ -16583,49 +33796,102 @@ string(foo?.Bar)
 string(foo?.Bar) not in foo
 string(foo?.String())
 string(foo?.String)
+string(get(list, 1))
+string(greet != $env)
+string(greet != greet)
+string(greet != nil)
+string(greet == greet)
+string(greet ?? 0)
+string(greet ?? 1.0)
+string(greet ?? add)
+string(greet ?? f64)
+string(greet ?? foo)
+string(greet ?? greet)
 string(greet(str))
 string(greet)
+string(greet) + str
+string(greet) ?? {foo: 0}
+string(greet) not in foo
 string(greet) not matches str
+string(greet) startsWith $env?.[str]
+string(greet) | greet()
+string(groupBy(array, #))
+string(groupBy(array, 0))
+string(groupBy(list, 1.0))
+string(groupBy(list, false))
 string(groupBy(list, ok)?.greet)
 string(groupBy(list, str))
+string(i != $env)
 string(i != 0)
 string(i != 1)
 string(i != 1.0)
 string(i != nil)
 string(i % 1)
+string(i * 0)
 string(i * 1.0)
+string(i ** 0)
 string(i ** 1.0)
+string(i ** f64)
+string(i ** i)
 string(i + 0)
 string(i + 1)
 string(i + 1.0)
 string(i + f64)
+string(i + i)
 string(i - 1)
 string(i - 1.0)
 string(i - f64)
 string(i - i)
+string(i .. 0)
 string(i .. 1)
 string(i / 0)
 string(i / f64)
+string(i / i)
+string(i < 0)
 string(i <= f64)
 string(i == $env)
+string(i == 1)
+string(i == 1.0)
 string(i == f64)
+string(i == nil)
 string(i > 0)
+string(i > 1)
+string(i > f64)
 string(i >= 1.0)
+string(i >= i)
+string(i ?? $env)
+string(i ?? f64)
+string(i ?? false)
+string(i ?? foo)
+string(i ?? i)
+string(i ?? list)
+string(i ?? ok)
+string(i ?? true)
 string(i ^ 1)
+string(i ^ 1.0)
 string(i ^ f64)
 string(i ^ i)
+string(i in array)
 string(i not in array)
 string(i | bitshr(i))
 string(i | min(1.0, 1.0))
 string(i)
+string(i) ?? i
+string(i) ?? toJSON(array)
+string(i) not endsWith str
 string(i) not in foo
+string(i) | greet()
 string(i) | indexOf(str)
+string(i)[:]
+string(if false ?? list { $env?.f64 } else { f64 })
 string(if false { foo } else { false })
 string(if false { ok } else { i })
+string(if ok { 0 } else { str })
 string(if ok { 1 } else { 1.0 })
 string(if true { 1 } else { $env })
 string(if true { 1.0 } else { foo })
 string(if true { list } else { 0 })
+string(if true { str } else { 1.0 })
 string(int(0))
 string(int(1))
 string(int(1.0))
@@ -16639,29 +33905,59 @@ string(len($env))
 string(len(array))
 string(len(list))
 string(len(str))
+string(let foobar = 1.0; foobar + foobar)
+string(let x = foo; x)
+string(let z = 0; let x = foo; z)
 string(list != $env)
+string(list != array)
 string(list != list)
 string(list != nil)
+string(list == $env)
 string(list == array)
 string(list == list)
+string(list == nil)
+string(list ?? $env)
+string(list ?? 1.0)
+string(list ?? false)
+string(list ?? foo)
+string(list ?? greet)
+string(list ?? i)
+string(list ?? list)
+string(list ?? nil)
+string(list ?? true)
+string(list | concat(array))
 string(list | count(true))
+string(list | findIndex(ok))
 string(list | groupBy(#))
+string(list | groupBy(0))
 string(list | groupBy(1))
+string(list | groupBy(1.0))
+string(list | groupBy(ok))
 string(list | map(.Bar))
+string(list | map(.String))
 string(list | map(greet))
 string(list | map(i))
 string(list | one(false))
 string(list | reduce(#))
+string(list | reduce(#.String))
 string(list | reduce(#index))
 string(list | reduce(.String))
 string(list | reduce(1))
 string(list | reduce(false))
 string(list | sortBy(1.0))
 string(list)
+string(list) != str ?? true
+string(list) > str
+string(list) ?? add
 string(list) not contains str
+string(list) not contains str ?? add
+string(list) not startsWith str
 string(list) startsWith str
+string(list) | greet()
+string(list) | split(str)
 string(list?.[0])
 string(list?.[i])
+string(list?.[i]?.String)
 string(list[1:])
 string(list[:0])
 string(list[i:])
@@ -16674,77 +33970,138 @@ string(map($env, false))
 string(map($env, foo))
 string(map($env, i))
 string(map($env, true))
+string(map(array, #index))
 string(map(array, add))
 string(map(array, f64))
 string(map(array, greet))
+string(map(array, str))
 string(map(list, $env))
 string(map(list, greet))
 string(map(list, list))
+string(map(list, true))
 string(max($env))
 string(max(0))
 string(max(1))
 string(max(1.0))
 string(max(array))
+string(max(f64))
+string(max(f64, 0))
 string(max(i))
 string(mean(0))
+string(mean(1))
 string(mean(1.0))
 string(mean(array))
+string(mean(f64))
 string(mean(i))
 string(median(0))
+string(median(1))
 string(median(1.0))
+string(median(1.0, 0))
 string(median(array))
 string(median(f64))
 string(median(i))
+string(median(i, 0))
+string(median(round(i)))
 string(min($env))
 string(min(0))
 string(min(0, 1.0))
 string(min(1))
+string(min(1, f64))
+string(min(1.0))
 string(min(1.0, 0))
+string(min(1.0, array))
 string(min(array))
 string(min(f64))
 string(min(i))
+string(min(i, 1.0))
 string(nil != $env)
 string(nil != 0)
 string(nil != 1.0)
 string(nil != foo)
+string(nil != list)
+string(nil != nil)
 string(nil != ok)
 string(nil != str)
+string(nil == $env)
 string(nil == 0)
+string(nil == 1.0)
+string(nil == add)
 string(nil == array)
 string(nil == f64)
 string(nil == foo)
 string(nil == greet)
+string(nil == i)
 string(nil == list)
 string(nil == nil)
 string(nil == nil) <= str
+string(nil == ok)
 string(nil == true)
+string(nil ?? 0)
+string(nil ?? 1.0)
+string(nil ?? add)
+string(nil ?? array)
+string(nil ?? foo)
+string(nil ?? i)
+string(nil ?? nil)
+string(nil ?? true)
 string(nil in $env)
 string(nil in array)
+string(nil in list)
 string(nil not in $env)
+string(nil not in $env?.array)
+string(nil not in array)
 string(nil not in list)
 string(nil) != $env?.[String]
+string(nil) != str
 string(nil) == toJSON(nil)
+string(nil) > str
 string(nil) >= str
+string(nil) ?? f64
+string(nil) ?? greet
+string(nil) ?? list
 string(nil) contains str
 string(nil) in foo
 string(nil) not matches greet(str)
+string(nil) not matches str
 string(nil) not startsWith str
 string(nil) | greet()
 string(nil) | trimSuffix(str)
+string(nil)[:i]
 string(nil)[i:]
+string(none($env, ok))
+string(none(list, true))
+string(not false)
+string(not ok)
+string(not true)
+string(ok != $env)
 string(ok != ok)
 string(ok && $env)
 string(ok && ok)
 string(ok && true)
+string(ok == $env)
 string(ok == false)
 string(ok == nil)
+string(ok == ok)
+string(ok ? $env : $env)
 string(ok ? $env : str)
+string(ok ? foo : nil)
 string(ok ? foo : ok)
 string(ok ? true : $env)
 string(ok ?: add)
 string(ok ?: f64)
+string(ok ?: foo)
+string(ok ?: list)
+string(ok ?? $env)
+string(ok ?? $env?.[i])
+string(ok ?? foo)
+string(ok ?? i)
+string(ok and $env)
+string(ok and $env?.[Bar])
+string(ok and ok)
 string(ok and true)
+string(ok or $env)
 string(ok or ok)
+string(ok or true)
 string(ok || $env)
 string(ok || false)
 string(ok)
@@ -16752,16 +34109,26 @@ string(ok) >= str
 string(ok) contains str
 string(ok) in foo
 string(ok) matches str
+string(ok) matches trimPrefix(str)
 string(ok) | greet()
 string(ok) | indexOf(str)
+string(ok); ok
+string(ok)[1.0 ?? 1:]
 string(ok)[:]
 string(one($env, false))
 string(reduce(array, #))
+string(reduce(array, 1.0))
+string(reduce(array, add))
 string(reduce(array, foo))
+string(reduce(array, greet))
+string(reduce(array, i))
 string(reduce(array, list))
+string(reduce(list, #))
+string(reduce(list, .Bar))
 string(reduce(list, foo))
 string(reduce(list, greet))
 string(reduce(list, ok, 1.0))
+string(reverse(array))
 string(round(0))
 string(round(1))
 string(round(1.0))
@@ -16769,41 +34136,62 @@ string(round(f64))
 string(round(i))
 string(sort($env))
 string(sort(array))
+string(sort(ok ? foo : 1.0))
 string(sortBy(array, #))
+string(sortBy(list, .Bar))
 string(sortBy(list, f64))
+string(str != $env)
+string(str < str)
 string(str <= str)
 string(str == $env)
+string(str == $env?.[Bar])
 string(str == nil)
 string(str == str)
+string(str > foo.Bar)
+string(str ?? add)
+string(str ?? ok)
+string(str ?? true)
+string(str contains str)
 string(str in $env)
+string(str in $env?.Bar)
 string(str in foo)
+string(str not contains $env?.[str])
 string(str not in $env)
 string(str not in foo)
 string(str not matches str)
+string(str | greet())
 string(str)
+string(str) != str
 string(str) + str
 string(str) contains str
 string(str) in foo
 string(str) matches str
 string(str) not contains str
+string(str) | greet()
 string(str)[:]
+string(str[:0])
 string(str[:1])
 string(str[:i])
 string(string($env))
 string(string(0))
+string(string(1))
 string(string(1.0))
 string(string(add))
+string(string(array))
+string(string(f64))
 string(string(false))
 string(string(foo))
 string(string(greet))
 string(string(i))
 string(string(list))
+string(string(nil))
 string(string(ok))
 string(string(str))
 string(string(true))
 string(sum($env, 0))
 string(sum($env, 1.0))
 string(sum(array))
+string(sum(array, #))
 string(sum(list, 0))
 string(toBase64(str))
 string(toJSON(0))
@@ -16813,6 +34201,7 @@ string(toJSON(array))
 string(toJSON(f64))
 string(toJSON(false))
 string(toJSON(foo))
+string(toJSON(list))
 string(toJSON(nil))
 string(toJSON(ok))
 string(toJSON(str))
@@ -16820,31 +34209,49 @@ string(toJSON(true))
 string(toPairs($env))
 string(trim(str))
 string(trimPrefix(str))
+string(trimSuffix(str))
+string(true != $env)
 string(true != false)
 string(true != nil)
 string(true != ok)
 string(true != true)
 string(true && $env)
 string(true && false)
+string(true == $env)
 string(true == false)
 string(true == nil)
+string(true == true)
 string(true ? $env : f64)
 string(true ? add : nil)
 string(true ? false : greet)
+string(true ? false : i)
 string(true ? foo : $env)
 string(true ? str : add)
 string(true ?: $env)
+string(true ?: nil)
+string(true ?: ok)
+string(true ?? 0)
+string(true ?? array)
+string(true ?? foo)
+string(true ?? i)
+string(true ?? list)
+string(true and $env)
+string(true and false)
 string(true and ok)
+string(true or false)
 string(true or ok)
 string(true || $env)
+string(true || ok)
 string(true || true)
 string(true) + str
+string(true) ?? array | groupBy(foo)
 string(type($env))
 string(type(0))
 string(type(1))
 string(type(1.0))
 string(type(add))
 string(type(array))
+string(type(f64))
 string(type(false))
 string(type(foo))
 string(type(greet))
@@ -16854,19 +34261,29 @@ string(type(ok))
 string(type(str))
 string(type(true))
 string(uniq(array))
+string(uniq(list))
 string(upper(str))
 string(values($env))
+string({foo: $env, foo: $env}?.f64)
 string({foo: $env, foo: nil})
+string({foo: $env})
 string({foo: 0})
 string({foo: 1.0, foo: list})
 string({foo: 1.0})
+string({foo: 1})
+string({foo: add ?? $env})
+string({foo: add, foo: 1.0})
 string({foo: add})
 string({foo: array, foo: 1.0, foo: list})
+string({foo: array})
 string({foo: f64, foo: 1.0, foo: foo})
 string({foo: f64, foo: 1.0})
 string({foo: f64})
 string({foo: false, foo: array})
 string({foo: false})
+string({foo: foo, foo: 1})
+string({foo: foo, foo: array})
+string({foo: foo, foo: list})
 string({foo: foo, foo: str})
 string({foo: foo})
 string({foo: greet, foo: 1.0})
@@ -16875,75 +34292,141 @@ string({foo: greet})
 string({foo: i, foo: $env})
 string({foo: i})
 string({foo: list})
+string({foo: nil, foo: $env})
 string({foo: nil, foo: 1})
 string({foo: nil, foo: foo})
 string({foo: nil, foo: list})
 string({foo: nil, foo: ok})
 string({foo: nil})
+string({foo: ok, foo: false, foo: list})
 string({foo: ok, foo: ok, foo: array})
 string({foo: ok, foo: str})
 string({foo: ok})
 string({foo: str})
 string({foo: true})
+string({foo: true}?.array)
+sum($env ?? greet, f64)
 sum($env | filter(false))
 sum($env | filter(false), reduce(#, #))
 sum($env | map(#index))
 sum($env | map(0))
 sum($env | map(1))
 sum($env | map(1.0))
+sum($env | map(f64))
 sum($env | map(i))
+sum($env | map(str), f64)
+sum($env | reduce(#acc, str))
 sum($env | reduce(array, 0))
+sum($env) or true ? foo : array
 sum($env, 0) in array
+sum($env, 0) | max(i)
+sum($env, 0) | median(1.0)
+sum($env, 1) != f64
 sum($env, 1) >= 1.0 >= 1.0
 sum($env, 1) >= i
+sum($env, 1.0) ** 1 ^ 1
+sum($env, 1.0) / -0
 sum($env, 1.0) >= f64
+sum($env, 1.0) ?? add
+sum($env, 1.0) ?? str
+sum($env, f64) != sum(array)
+sum($env, f64) ** f64 + f64
+sum($env, f64) ?? add
 sum($env, f64) | max(i)
+sum($env, i) <= abs(1.0)
+sum($env, i) ^ i
+sum($env, ok) or not false
+sum($env.array | sortBy(#))
+sum($env.array | sortBy(i))
 sum($env.array)
 sum($env.array, # ** #)
 sum($env.array, #)
 sum($env.array, f64)
+sum($env.array, i)
+sum($env.list, abs(1.0))
+sum($env.list, f64)
 sum($env.list, i)
 sum($env?.[str])
+sum($env?.[str]) != ok
 sum($env?.[str], #)
+sum($env?.[str], f64)
+sum($env?.[str], i)
 sum($env?.array)
+sum($env?.array) ?? add
 sum($env?.array, #)
 sum($env?.array, i)
+sum($env?.array, i) <= i
 sum($env?.list, f64 + 1.0)
 sum(0 .. 0)
 sum(0 .. 1)
 sum(0 .. i)
 sum(0..i)
 sum(1 .. 0)
+sum(1 .. 0, #)
 sum(1 .. 1)
 sum(1 .. i)
 sum(1..i)
+sum(1..i, # + #)
 sum(1..i, f64)
 sum([$env, add], f64)
+sum([-1])
+sum([0, 0])
 sum([0])
+sum([1, 0])
 sum([1, 1.0])
+sum([1.0, 0])
+sum([1.0, 1.0])
+sum([1.0, 1.0], #)
 sum([1.0, 1])
 sum([1.0, 1], f64)
 sum([1.0, f64])
 sum([1.0])
+sum([1.0], #)
+sum([1.0], i)
 sum([1])
+sum([1], 1 / #)
+sum([f64, 0])
 sum([f64, 1.0])
 sum([f64])
 sum([f64], i)
 sum([foo], f64)
 sum([i])
+sum([nil], 1.0 + i)
 sum([ok], f64)
+sum([ok], i)
 sum([str, str])
+sum([true], i)
+sum(array ?? 0, min(1))
+sum(array ?? 1)
+sum(array ?? 1.0)
+sum(array ?? add)
+sum(array ?? add, #)
+sum(array ?? array)
+sum(array ?? f64)
+sum(array ?? false)
+sum(array ?? foo)
+sum(array ?? greet)
+sum(array ?? i)
+sum(array ?? list)
+sum(array ?? nil)
+sum(array ?? str)
+sum(array ?? true)
 sum(array | filter(false))
 sum(array | filter(ok))
 sum(array | filter(true))
 sum(array | map(#))
+sum(array | map(#index))
 sum(array | map(0))
+sum(array | map(1))
 sum(array | map(1.0))
 sum(array | map(f64))
+sum(array | map(i))
+sum(array | map(i), i)
 sum(array | sortBy(#))
 sum(array | sortBy(0))
 sum(array | sortBy(1))
 sum(array | sortBy(1.0))
+sum(array | sortBy(i))
 sum(array | sortBy(str))
 sum(array | take(0))
 sum(array)
@@ -16951,8 +34434,10 @@ sum(array) != f64
 sum(array) != i
 sum(array) != i ** 1.0
 sum(array) % i
+sum(array) * f64
 sum(array) * i
 sum(array) ** f64
+sum(array) ** i
 sum(array) + $env.f64
 sum(array) + f64
 sum(array) + i
@@ -16965,56 +34450,99 @@ sum(array) / f64
 sum(array) < f64
 sum(array) < i
 sum(array) <= f64
+sum(array) <= i
 sum(array) <= i || $env
+sum(array) <= max(array)
 sum(array) == f64
 sum(array) == i
 sum(array) > f64
+sum(array) > reduce(array, i)
 sum(array) >= f64 != true
+sum(array) >= i
+sum(array) ?? all($env, #)
+sum(array) ?? f64
+sum(array) ?? foo
+sum(array) ?? list
+sum(array) ?? ok
+sum(array) ?? str
+sum(array) ?? {foo: true}
 sum(array) ^ f64
 sum(array) ^ i
 sum(array) ^ round(1)
 sum(array) not in $env.array
 sum(array) not in array
+sum(array) | bitnand(i)
+sum(array) | bitor(i)
+sum(array) | bitushr(0)
 sum(array) | bitxor(0)
+sum(array) | max(array)
 sum(array) | mean(1)
 sum(array) | mean(1.0)
+sum(array) | min(i)
 sum(array)..i
 sum(array); f64
 sum(array, # % #)
 sum(array, # ** #)
+sum(array, # ** i)
+sum(array, # + #)
+sum(array, # - 0)
 sum(array, # / f64)
 sum(array, #)
 sum(array, #) * i
 sum(array, #) ** f64
 sum(array, #) <= i
+sum(array, #) <= i ?? 1.0
+sum(array, #) ?? foo
 sum(array, #) not in array
 sum(array, $env.f64)
 sum(array, $env.i)
 sum(array, $env?.f64)
 sum(array, $env?.i)
+sum(array, -#)
+sum(array, -0)
+sum(array, -1)
+sum(array, -1.0)
 sum(array, 0 ** f64)
 sum(array, 1 - #)
+sum(array, 1 ?? i)
+sum(array, 1) != i
 sum(array, 1) .. array?.[i]
+sum(array, 1) ?? i
+sum(array, 1) ^ i
 sum(array, 1.0 ** #)
+sum(array, 1.0 / #)
+sum(array, 1.0 ?? foo)
+sum(array, 1.0) * mean(i, 0)
 sum(array, 1.0) - f64
 sum(array, 1.0) == f64
+sum(array, abs(#))
 sum(array, array | reduce(f64))
 sum(array, array?.[i])
 sum(array, bitnot(#))
 sum(array, bitshr(#, #))
+sum(array, bitushr(#, #))
 sum(array, ceil(f64))
 sum(array, f64)
 sum(array, f64) + int(i)
+sum(array, f64) == i
 sum(array, f64) > i
 sum(array, f64) ^ i
+sum(array, float(# | bitxor(#)))
 sum(array, float(#))
 sum(array, float(1.0))
+sum(array, floor(0))
 sum(array, floor(f64))
 sum(array, i + 1.0)
 sum(array, i)
+sum(array, int(i))
+sum(array, max(#, #))
 sum(array, mean(array))
+sum(array, nil ?? #)
+sum(array, round(#))
 sum(array, round(1.0))
+sum(array, sum($env, 1))
 sum(array, sum(array, #))
+sum(array, true ? 0 : 0)
 sum(array[0:])
 sum(array[1:])
 sum(array[:0])
@@ -17022,6 +34550,8 @@ sum(array[:1])
 sum(array[:i])
 sum(array[i:])
 sum(concat(array))
+sum(concat(array), #)
+sum(concat(array, array))
 sum(false ? $env : $env, f64)
 sum(false ? $env : array)
 sum(false ? i : str)
@@ -17035,23 +34565,32 @@ sum(filter(array, false))
 sum(filter(array, ok), f64)
 sum(filter(array, ok), i)
 sum(filter(array, true))
+sum(filter(list, false))
 sum(flatten(array))
 sum(flatten(array), max(#))
+sum(flatten(sort(str ?? 1)))
 sum(get($env, str))
 sum(i .. 0)
 sum(i .. 1)
+sum(i .. i)
 sum(i..i)
 sum(if false { 1 } else { array })
 sum(if false { array } else { array })
+sum(if false { foo } else { str })
+sum(if ok { array } else { 1 })
 sum(if ok { str } else { f64 })
 sum(if true { array } else { 1.0 })
 sum(if true { array } else { list })
 sum(let foobar = array; foobar)
+sum(let y = array; y)
 sum(list | filter(false))
+sum(list | map(#index))
 sum(list | map(0))
 sum(list | map(1))
 sum(list | map(1.0))
+sum(list | map(f64))
 sum(list | map(greet), i)
+sum(list | map(i))
 sum(list | reduce($env), i)
 sum(list | reduce(array))
 sum(list | sortBy(str), f64)
@@ -17059,20 +34598,38 @@ sum(list, $env.f64)
 sum(list, $env.i)
 sum(list, $env?.f64)
 sum(list, $env?.i)
+sum(list, -1.0)
+sum(list, 0 * 1.0)
+sum(list, 0 ?? #)
+sum(list, 0 ?? str)
 sum(list, 0) ** f64
+sum(list, 0) ?? array
+sum(list, 1 ^ 0)
 sum(list, 1) | bitxor(0)
+sum(list, 1.0 ** i)
 sum(list, 1.0 / 1.0)
+sum(list, 1.0 ?? str)
 sum(list, f64 * 0)
 sum(list, f64 ** 0)
+sum(list, f64 - 1.0)
 sum(list, f64 - f64)
 sum(list, f64)
+sum(list, f64) ?? 1.0 ?? list
+sum(list, f64) | mean(f64)
 sum(list, i + 0)
 sum(list, i / 0)
+sum(list, i ?? true)
 sum(list, i)
+sum(list, i) ** i
 sum(list, int(i))
+sum(list, len($env))
 sum(list, len(str))
 sum(list, list | sum(1.0))
 sum(list, max(0))
+sum(list, mean(i))
+sum(list, round(1.0))
+sum(list[i:0])
+sum(list[i:i])
 sum(map($env, #index))
 sum(map($env, $env), i)
 sum(map($env, 0) | sortBy(1.0))
@@ -17087,18 +34644,34 @@ sum(map(array, 0))
 sum(map(array, 1))
 sum(map(array, 1.0))
 sum(map(array, f64))
+sum(map(list, #index))
 sum(map(list, 0))
+sum(map(list, 1))
 sum(map(list, 1.0))
 sum(map(list, f64))
+sum(map(list, i))
+sum(max($env).array)
+sum(max($env?.[str]))
 sum(min($env), f64)
+sum(nil ?? array)
+sum(ok ? array : false)
 sum(ok ? array : foo)
 sum(reduce($env, array, $env))
+sum(reduce($env, array, nil))
 sum(reduce(array, array))
+sum(reduce(array, array, false))
 sum(reduce(list, array))
 sum(reverse(array))
 sum(sort($env))
+sum(sort($env), #.Bar)
+sum(sort($env), #.add % 1)
 sum(sort($env), #.add not in #.add)
 sum(sort($env), $env == #)
+sum(sort($env), .array?.foobar)
+sum(sort($env), .list)
+sum(sort($env), 1.0 ?? #.greet)
+sum(sort($env), any(#, #.String))
+sum(sort($env?.String))
 sum(sort(array))
 sum(sort(ok ? i : 1.0))
 sum(sortBy(array, #))
@@ -17108,6 +34681,24 @@ sum(sortBy(array, 1.0))
 sum(sortBy(array, f64))
 sum(sortBy(array, i))
 sum(sortBy(array, str))
+sum(str ?? $env)
+sum(str ?? 0)
+sum(str ?? 1)
+sum(str ?? 1, #)
+sum(str ?? 1.0)
+sum(str ?? add)
+sum(str ?? array)
+sum(str ?? f64)
+sum(str ?? false)
+sum(str ?? false, #)
+sum(str ?? false, f64)
+sum(str ?? foo)
+sum(str ?? greet)
+sum(str ?? i)
+sum(str ?? list)
+sum(str ?? ok)
+sum(str ?? true)
+sum(string($env) ?? array)
 sum(take(array, i))
 sum(toPairs($env), i)
 sum(true ? str : 1.0)
@@ -17115,6 +34706,7 @@ sum(true ? str : add)
 sum(true ? str : foo)
 sum(uniq(array))
 sum(uniq(array), 1.0 - 0)
+take(array, $env?.i)
 take(array, i)
 take(list, i)
 toBase64($env.foo?.Bar)
@@ -17123,28 +34715,48 @@ toBase64($env?.[str])
 toBase64($env?.str)
 toBase64(foo.Bar)
 toBase64(foo.String())
+toBase64(foo?.Bar ?? foo)
 toBase64(foo?.Bar)
+toBase64(foo?.Bar)[:]
 toBase64(foo?.String())
 toBase64(greet(str))
 toBase64(lower(str))
+toBase64(reduce(list, str))
 toBase64(str + str)
+toBase64(str ?? $env)
+toBase64(str ?? 1)
+toBase64(str ?? array)
+toBase64(str ?? i)
+toBase64(str ?? nil)
+toBase64(str ?? ok)
+toBase64(str | greet())
 toBase64(str)
+toBase64(str) < str
 toBase64(str) > str
 toBase64(str) >= str
+toBase64(str) ?? array
+toBase64(str) endsWith first($env)
+toBase64(str) in foo ?? 0
 toBase64(str) not contains $env?.str
+toBase64(str) not matches $env?.Bar
 toBase64(str) not startsWith str
 toBase64(str) | greet()
 toBase64(str) | repeat(i)
 toBase64(str)[i:]
 toBase64(str[:0])
+toBase64(str[:1])
+toBase64(str[:i])
+toBase64(str[i:])
 toBase64(string($env))
 toBase64(string(0))
 toBase64(string(1))
 toBase64(string(1.0))
+toBase64(string(add))
 toBase64(string(array))
 toBase64(string(f64))
 toBase64(string(false))
 toBase64(string(foo))
+toBase64(string(foo?.Bar))
 toBase64(string(greet))
 toBase64(string(i))
 toBase64(string(list))
@@ -17164,6 +34776,7 @@ toBase64(toJSON(list))
 toBase64(toJSON(nil))
 toBase64(toJSON(ok))
 toBase64(toJSON(true))
+toBase64(trim(str))
 toBase64(trimPrefix(str))
 toBase64(trimSuffix(str))
 toBase64(type($env))
@@ -17181,39 +34794,57 @@ toBase64(type(i))
 toBase64(type(list))
 toBase64(type(nil))
 toBase64(type(ok))
+toBase64(type(str))
 toBase64(type(true))
 toBase64(upper(str))
+toJSON(!false)
+toJSON(!ok)
+toJSON(!true)
 toJSON($env != 0)
+toJSON($env != 1)
+toJSON($env != 1.0)
 toJSON($env != add)
 toJSON($env != array)
+toJSON($env != f64)
 toJSON($env != false)
 toJSON($env != foo)
 toJSON($env != greet)
+toJSON($env != i)
 toJSON($env != list)
 toJSON($env != nil)
 toJSON($env != str)
 toJSON($env != true)
+toJSON($env && false)
 toJSON($env == $env)
 toJSON($env == 0)
 toJSON($env == 1)
+toJSON($env == array)
 toJSON($env == f64)
 toJSON($env == false)
 toJSON($env == foo)
+toJSON($env == i)
 toJSON($env == list)
 toJSON($env == nil)
 toJSON($env == str)
 toJSON($env == true)
 toJSON($env in list)
+toJSON($env not in array)
 toJSON($env not in list)
 toJSON($env or true)
 toJSON($env | all(false))
+toJSON($env | any(false))
+toJSON($env | any(true))
 toJSON($env | count(false))
 toJSON($env | findIndex(ok))
+toJSON($env | findLastIndex(ok))
+toJSON($env | get(nil))
 toJSON($env | map(array))
 toJSON($env | map(f64))
 toJSON($env | map(list))
 toJSON($env | map(str))
 toJSON($env | map(true))
+toJSON($env | none(false))
+toJSON($env | reduce(#index, $env))
 toJSON($env | reduce(#index, nil))
 toJSON($env | reduce(false, 1))
 toJSON($env | sum(0))
@@ -17229,12 +34860,16 @@ toJSON($env.ok)
 toJSON($env.str)
 toJSON($env?.$env)
 toJSON($env?.Bar)
+toJSON($env?.Bar?.Bar())
 toJSON($env?.Bar?.[greet])
+toJSON($env?.Bar?.[list])
+toJSON($env?.Bar?.f64)
 toJSON($env?.String)
 toJSON($env?.[Bar])
 toJSON($env?.[String])
 toJSON($env?.[foobar])
 toJSON($env?.[foobar]?.i())
+toJSON($env?.[foobar]?.list)
 toJSON($env?.[nil])
 toJSON($env?.[str])
 toJSON($env?.array)
@@ -17247,77 +34882,140 @@ toJSON($env?.list)
 toJSON($env?.nil)
 toJSON($env?.ok)
 toJSON($env?.str)
+toJSON($env?.true)
+toJSON(-$env?.i)
+toJSON(-0 < 1.0)
+toJSON(-0)
+toJSON(-1)
+toJSON(-1.0)
+toJSON(-f64)
+toJSON(-i)
 toJSON(0 != $env)
+toJSON(0 != 1)
+toJSON(0 != 1.0)
+toJSON(0 != i)
 toJSON(0 != nil)
 toJSON(0 % 1)
 toJSON(0 % i)
 toJSON(0 * 1.0)
+toJSON(0 ** 1)
 toJSON(0 ** 1.0)
 toJSON(0 ** f64)
 toJSON(0 + 0)
 toJSON(0 + 1)
 toJSON(0 + 1.0)
+toJSON(0 + f64)
 toJSON(0 - 1)
 toJSON(0 - 1.0)
 toJSON(0 - f64)
+toJSON(0 - i)
+toJSON(0 .. 1)
 toJSON(0 .. i)
 toJSON(0 / 1.0)
 toJSON(0 / f64)
+toJSON(0 / i)
+toJSON(0 < 0)
 toJSON(0 < 1.0)
+toJSON(0 <= 0)
+toJSON(0 <= 1)
 toJSON(0 <= 1.0)
 toJSON(0 <= f64)
+toJSON(0 <= i)
+toJSON(0 == $env?.[foobar])
+toJSON(0 == 1)
 toJSON(0 == 1.0)
 toJSON(0 == f64)
 toJSON(0 == nil)
+toJSON(0 > 1)
+toJSON(0 > 1.0)
 toJSON(0 > i)
 toJSON(0 >= 0)
 toJSON(0 >= 1)
 toJSON(0 >= 1.0)
+toJSON(0 ?? 1.0)
+toJSON(0 ?? f64)
+toJSON(0 ?? greet)
+toJSON(0 ?? list)
+toJSON(0 ?? nil)
 toJSON(0 ^ 1.0)
 toJSON(0 ^ f64)
 toJSON(0 ^ i)
 toJSON(0 in array)
 toJSON(0 not in array)
+toJSON(0 | bitor(i))
 toJSON(0 | bitshl(0))
 toJSON(0 | bitshr(0))
+toJSON(0 | min(1.0))
+toJSON(0) != greet(str)
 toJSON(0) + str
 toJSON(0) > str
 toJSON(0) >= str
+toJSON(0) ?? array
+toJSON(0) ?? not true
+toJSON(0) contains $env?.[String]
+toJSON(0) in foo
+toJSON(0) | greet()
 toJSON(0..i)
 toJSON(0.0)
+toJSON(0.1)
 toJSON(1 != $env)
+toJSON(1 != 0)
+toJSON(1 != 1.0)
 toJSON(1 != i)
 toJSON(1 != nil)
+toJSON(1 % i)
 toJSON(1 * 1.0)
 toJSON(1 * i)
+toJSON(1 ** 0)
+toJSON(1 ** 1)
 toJSON(1 ** i)
+toJSON(1 + 0)
 toJSON(1 + 1)
 toJSON(1 + 1.0)
 toJSON(1 + f64)
+toJSON(1 - 1.0)
 toJSON(1 - f64)
+toJSON(1 - i)
 toJSON(1 .. 0)
 toJSON(1 .. 1)
 toJSON(1 .. i)
+toJSON(1 / 1)
 toJSON(1 / f64)
 toJSON(1 / i)
 toJSON(1 < 0)
 toJSON(1 < 1.0)
 toJSON(1 <= 0)
 toJSON(1 <= 1)
+toJSON(1 <= f64)
 toJSON(1 <= i)
+toJSON(1 == $env)
 toJSON(1 == 0)
 toJSON(1 == 1.0)
 toJSON(1 == nil)
 toJSON(1 > 0)
 toJSON(1 > 1)
+toJSON(1 > 1.0)
 toJSON(1 > i)
+toJSON(1 >= 0)
+toJSON(1 >= 1)
+toJSON(1 >= 1.0)
 toJSON(1 >= f64)
 toJSON(1 >= i)
+toJSON(1 ?? $env?.[foo])
+toJSON(1 ?? 1)
+toJSON(1 ?? false)
+toJSON(1 ?? foo)
+toJSON(1 ?? nil)
 toJSON(1 ^ 1.0)
 toJSON(1 not in array)
+toJSON(1 | min(f64))
 toJSON(1) != str
+toJSON(1) > str
+toJSON(1) ?? $env.ok
+toJSON(1) ?? array
 toJSON(1) endsWith str
 toJSON(1) not contains str
+toJSON(1) not endsWith str
 toJSON(1) not in $env?.true
 toJSON(1) | greet()
 toJSON(1.0 != $env)
@@ -17326,23 +35024,32 @@ toJSON(1.0 != 1)
 toJSON(1.0 != 1.0)
 toJSON(1.0 != i)
 toJSON(1.0 != nil)
+toJSON(1.0 * 0)
 toJSON(1.0 * 1)
 toJSON(1.0 * 1.0)
 toJSON(1.0 * f64)
 toJSON(1.0 * i)
+toJSON(1.0 ** 0)
 toJSON(1.0 ** 1)
 toJSON(1.0 ** 1.0)
+toJSON(1.0 ** f64)
 toJSON(1.0 ** i)
 toJSON(1.0 + 0)
 toJSON(1.0 + 1)
 toJSON(1.0 + 1.0)
+toJSON(1.0 + f64)
+toJSON(1.0 + i)
 toJSON(1.0 - 0)
 toJSON(1.0 - 1)
 toJSON(1.0 - 1.0)
 toJSON(1.0 - f64)
+toJSON(1.0 - i)
 toJSON(1.0 / 1)
 toJSON(1.0 / 1.0)
 toJSON(1.0 / i)
+toJSON(1.0 < 0)
+toJSON(1.0 < 1.0)
+toJSON(1.0 < f64)
 toJSON(1.0 < i)
 toJSON(1.0 <= 0)
 toJSON(1.0 <= 1.0)
@@ -17352,67 +35059,126 @@ toJSON(1.0 == $env)
 toJSON(1.0 == 1)
 toJSON(1.0 == 1.0)
 toJSON(1.0 == f64)
+toJSON(1.0 == i)
 toJSON(1.0 > 0)
 toJSON(1.0 > 1.0)
+toJSON(1.0 > f64)
 toJSON(1.0 > i)
 toJSON(1.0 >= 0)
 toJSON(1.0 >= 1)
 toJSON(1.0 >= 1.0)
+toJSON(1.0 >= f64)
 toJSON(1.0 >= i)
+toJSON(1.0 ?? $env)
+toJSON(1.0 ?? 1)
+toJSON(1.0 ?? add)
+toJSON(1.0 ?? array)
+toJSON(1.0 ?? f64)
+toJSON(1.0 ?? foo)
+toJSON(1.0 ?? greet)
+toJSON(1.0 ?? i)
+toJSON(1.0 ?? nil)
+toJSON(1.0 ^ 0)
 toJSON(1.0 ^ 1)
 toJSON(1.0 ^ 1.0)
 toJSON(1.0 ^ f64)
+toJSON(1.0 ^ f64) + str
 toJSON(1.0 ^ i)
+toJSON(1.0 in $env?.[String])
 toJSON(1.0 in array)
 toJSON(1.0 not in array)
+toJSON(1.0 | median(array))
+toJSON(1.0)
 toJSON(1.0) + str
 toJSON(1.0) <= str
+toJSON(1.0) ?? add
+toJSON(1.0) ?? foo
+toJSON(1.0) contains str
 toJSON(1.0) matches str
+toJSON(1.0) not endsWith str
 toJSON(1.0) not in foo
+toJSON(1.0) startsWith str
 toJSON(1.0) | greet()
 toJSON(1.0) | indexOf(str)
 toJSON([0])
 toJSON([1, 1])
+toJSON([1, foo])
+toJSON([1, i])
+toJSON([1, str])
 toJSON([1.0])
 toJSON([1])
 toJSON([array, 0])
 toJSON([array])
 toJSON([f64, nil])
+toJSON([f64])
 toJSON([false])
 toJSON([foo, list])
 toJSON([foo])
+toJSON([i])
 toJSON([nil])
+toJSON([not true])
 toJSON([ok])
+toJSON([str, 1.0])
 toJSON([str])
 toJSON([true])
 toJSON(abs(0))
 toJSON(abs(1))
 toJSON(abs(1.0))
+toJSON(abs(f64 / 1.0))
 toJSON(abs(f64))
+toJSON(abs(i))
 toJSON(add != $env)
+toJSON(add != add)
+toJSON(add == $env)
 toJSON(add == add)
 toJSON(add == nil)
+toJSON(add(i, 0))
+toJSON(all(list, false))
 toJSON(all(list, true))
 toJSON(any(array, false))
+toJSON(any(array, true))
+toJSON(any(list, ok))
 toJSON(array != $env)
 toJSON(array != array)
 toJSON(array != list)
+toJSON(array != nil)
 toJSON(array == array)
 toJSON(array == list)
+toJSON(array == nil)
+toJSON(array ?? 0)
+toJSON(array ?? 1)
+toJSON(array ?? 1.0)
+toJSON(array ?? array)
+toJSON(array ?? f64)
+toJSON(array ?? list)
+toJSON(array ?? str)
+toJSON(array | count(false))
 toJSON(array | count(ok))
 toJSON(array | count(true))
+toJSON(array | filter(ok))
 toJSON(array | find(true))
+toJSON(array | findLast(true))
 toJSON(array | map(#))
+toJSON(array | map(array))
 toJSON(array | max(i))
 toJSON(array | min(i))
 toJSON(array | none(false))
+toJSON(array | one(ok))
+toJSON(array | reduce(1))
+toJSON(array | reduce(ok))
 toJSON(array | sortBy(#))
 toJSON(array | sortBy(0))
+toJSON(array | sum(#))
+toJSON(array | sum(1.0))
 toJSON(array | sum(i))
 toJSON(array)
+toJSON(array) != $env?.[Bar]
+toJSON(array) != str
 toJSON(array) + str
 toJSON(array) < str
 toJSON(array) == greet(str)
+toJSON(array) endsWith str
+toJSON(array) matches str
 toJSON(array) not contains str
 toJSON(array) | greet()
 toJSON(array?.[0])
@@ -17420,6 +35186,7 @@ toJSON(array?.[1])
 toJSON(array?.[i])
 toJSON(array[1:])
 toJSON(bitand(0, 0))
+toJSON(bitnand(1, 1))
 toJSON(bitnot(0))
 toJSON(bitnot(1))
 toJSON(bitnot(i))
@@ -17430,39 +35197,61 @@ toJSON(ceil(f64))
 toJSON(ceil(i))
 toJSON(concat(array))
 toJSON(concat(list))
+toJSON(count(array, false))
+toJSON(count(array, ok))
 toJSON(count(array, true))
 toJSON(count(list, false))
 toJSON(count(list, true))
+toJSON(f64 != 0)
 toJSON(f64 != 1)
 toJSON(f64 != 1.0)
 toJSON(f64 != f64)
 toJSON(f64 != nil)
 toJSON(f64 * 0)
+toJSON(f64 * 1.0)
 toJSON(f64 * f64)
+toJSON(f64 ** 1)
 toJSON(f64 ** f64)
 toJSON(f64 + 1.0)
 toJSON(f64 - 1.0)
+toJSON(f64 / 1)
 toJSON(f64 / 1.0)
+toJSON(f64 / i)
 toJSON(f64 < 0)
 toJSON(f64 < 1)
 toJSON(f64 < 1.0)
 toJSON(f64 <= 0)
 toJSON(f64 <= 1)
 toJSON(f64 <= 1.0)
+toJSON(f64 <= i)
 toJSON(f64 == $env)
 toJSON(f64 == 0)
 toJSON(f64 == 1.0)
 toJSON(f64 == nil)
+toJSON(f64 > 0)
+toJSON(f64 > 1.0)
 toJSON(f64 >= 1.0)
 toJSON(f64 >= i)
+toJSON(f64 ?? $env)
+toJSON(f64 ?? 1.0)
+toJSON(f64 ?? add)
+toJSON(f64 ?? array)
+toJSON(f64 ?? i)
+toJSON(f64 ?? nil)
+toJSON(f64 ?? ok)
 toJSON(f64 ^ 0)
+toJSON(f64 ^ 1.0)
 toJSON(f64 ^ f64)
 toJSON(f64 ^ i)
 toJSON(f64 in array)
+toJSON(f64 not in array)
+toJSON(f64 | mean(1.0))
 toJSON(f64 | median(i))
 toJSON(f64)
 toJSON(f64) > str
+toJSON(f64) ?? add
 toJSON(f64) in reduce(array, $env, array)
+toJSON(f64) not contains str ?? 0
 toJSON(f64) not in foo
 toJSON(false != $env)
 toJSON(false != false)
@@ -17470,18 +35259,43 @@ toJSON(false != nil)
 toJSON(false != ok)
 toJSON(false && $env)
 toJSON(false && $env?.[greet])
+toJSON(false && ok)
+toJSON(false == $env)
 toJSON(false == nil)
+toJSON(false == ok)
 toJSON(false == true)
+toJSON(false ? ok : true)
+toJSON(false ?: f64)
+toJSON(false ?? 1.0)
+toJSON(false ?? add)
+toJSON(false ?? f64)
+toJSON(false ?? foo)
+toJSON(false ?? greet)
+toJSON(false ?? i)
+toJSON(false ?? nil)
+toJSON(false ?? ok)
+toJSON(false and $env)
+toJSON(false not in $env?.[String])
 toJSON(false or false)
 toJSON(false || false)
 toJSON(false || ok)
+toJSON(false) <= $env.str
+toJSON(false) <= str
+toJSON(false) ?? f64
+toJSON(false) ?? len(array)
 toJSON(false) not endsWith str
 toJSON(false) startsWith first($env)
+toJSON(false) | lastIndexOf(str)
+toJSON(find(array, true))
+toJSON(find(list, false))
+toJSON(find(list, ok))
 toJSON(findIndex($env, false))
 toJSON(findIndex($env, true))
 toJSON(findIndex(list, false))
 toJSON(findLastIndex($env, false))
+toJSON(findLastIndex($env, ok))
 toJSON(first($env))
+toJSON(first(array))
 toJSON(first(list))
 toJSON(flatten(array))
 toJSON(flatten(list))
@@ -17491,6 +35305,7 @@ toJSON(float(1.0))
 toJSON(float(f64))
 toJSON(float(i))
 toJSON(floor(0))
+toJSON(floor(1))
 toJSON(floor(1.0))
 toJSON(floor(f64))
 toJSON(floor(i))
@@ -17500,12 +35315,30 @@ toJSON(foo != nil)
 toJSON(foo == $env)
 toJSON(foo == foo)
 toJSON(foo == nil)
+toJSON(foo ?? $env)
+toJSON(foo ?? $env?.[f64 >= foobar])
+toJSON(foo ?? 0)
+toJSON(foo ?? 1)
+toJSON(foo ?? add)
+toJSON(foo ?? f64)
+toJSON(foo ?? foo)
+toJSON(foo ?? list)
+toJSON(foo ?? ok)
+toJSON(foo ?? str)
+toJSON(foo ?? true)
 toJSON(foo in list)
 toJSON(foo not in list)
 toJSON(foo)
+toJSON(foo) + str
 toJSON(foo) < str
 toJSON(foo) > str
+toJSON(foo) > toJSON(1.0)
+toJSON(foo) >= string(nil)
+toJSON(foo) ?? $env?.greet
+toJSON(foo) ?? i
+toJSON(foo) ?? ok
 toJSON(foo) not in $env?.String
+toJSON(foo) not matches $env?.[foobar]
 toJSON(foo) not matches str
 toJSON(foo) | greet()
 toJSON(foo) | repeat(i)
@@ -17517,6 +35350,7 @@ toJSON(greet != $env)
 toJSON(greet != greet)
 toJSON(greet != nil)
 toJSON(greet == $env)
+toJSON(greet == nil)
 toJSON(greet(str))
 toJSON(groupBy(array, 1.0)?.Bar)
 toJSON(i != 1.0)
@@ -17528,39 +35362,74 @@ toJSON(i * 0)
 toJSON(i * 1)
 toJSON(i * 1.0)
 toJSON(i * f64)
+toJSON(i * i)
+toJSON(i ** 1.0) | greet()
 toJSON(i ** f64)
 toJSON(i + 1 .. 0)
+toJSON(i + 1.0)
+toJSON(i - 1)
 toJSON(i - i)
 toJSON(i .. 1)
+toJSON(i / 1.0)
 toJSON(i / f64)
 toJSON(i / i)
 toJSON(i < 1)
 toJSON(i < 1.0)
 toJSON(i <= 1)
 toJSON(i == 0)
+toJSON(i == 1)
 toJSON(i == 1.0)
 toJSON(i == nil)
 toJSON(i == nil) <= str
+toJSON(i > 1)
 toJSON(i > f64)
+toJSON(i > i)
 toJSON(i >= 0)
+toJSON(i >= 1.0)
+toJSON(i >= f64)
 toJSON(i >= i)
+toJSON(i ?? $env)
+toJSON(i ?? 0)
+toJSON(i ?? 1.0)
+toJSON(i ?? add)
+toJSON(i ?? array)
+toJSON(i ?? foo)
+toJSON(i ?? greet)
+toJSON(i ?? list?.[i])
+toJSON(i ?? nil)
+toJSON(i ?? str)
+toJSON(i ?? true)
 toJSON(i ^ 0)
 toJSON(i ^ 1.0)
+toJSON(i ^ f64)
 toJSON(i in array)
 toJSON(i not in array)
+toJSON(i | bitand(0))
 toJSON(i)
 toJSON(i) + str
+toJSON(i) < foo.String()
 toJSON(i) <= str
+toJSON(i) ?? array
+toJSON(i) ?? i
 toJSON(i) not contains string(0)
+toJSON(i) not in foo ? 1.0 : foo
+toJSON(i) | greet()
+toJSON(if false { $env } else { nil })
 toJSON(if false { add } else { ok })
+toJSON(if false { nil } else { list })
 toJSON(if false { str } else { str })
+toJSON(if ok { foo } else { 1.0 })
+toJSON(if true { foo } else { 1 })
 toJSON(if true { ok } else { f64 })
+toJSON(if true { true } else { i })
 toJSON(int(0))
 toJSON(int(1))
 toJSON(int(1.0))
 toJSON(int(f64))
 toJSON(keys($env))
 toJSON(last($env))
+toJSON(last($env?.[foobar]))
+toJSON(last(array))
 toJSON(last(list))
 toJSON(len($env))
 toJSON(len(list))
@@ -17574,44 +35443,78 @@ toJSON(list == $env.list)
 toJSON(list == array)
 toJSON(list == list)
 toJSON(list == nil)
+toJSON(list ?? 0)
+toJSON(list ?? 1.0)
+toJSON(list ?? add)
+toJSON(list ?? array)
+toJSON(list ?? false)
+toJSON(list ?? foo)
+toJSON(list ?? nil)
+toJSON(list ?? ok)
+toJSON(list ?? true)
 toJSON(list | all(false))
 toJSON(list | find(false))
 toJSON(list | find(ok))
 toJSON(list | findIndex(true))
+toJSON(list | findLast(ok))
 toJSON(list | map(#))
 toJSON(list | map(#.Bar))
 toJSON(list | map(0))
+toJSON(list | map(1))
+toJSON(list | map(foo))
 toJSON(list | map(true))
 toJSON(list | none(true))
 toJSON(list | reduce(#))
 toJSON(list | reduce(0))
 toJSON(list | reduce(foo))
+toJSON(list | sortBy(f64))
+toJSON(list | sortBy(i))
+toJSON(list | sum(1.0))
+toJSON(list | sum(i))
 toJSON(list)
+toJSON(list) + str
+toJSON(list) <= str
 toJSON(list) == str
+toJSON(list) > str
+toJSON(list) > string($env)
+toJSON(list) not in foo
 toJSON(list) startsWith str
 toJSON(list) | greet()
 toJSON(list?.[0])
 toJSON(list?.[i])
+toJSON(list[0:])
+toJSON(list[:1])
 toJSON(lower(str))
 toJSON(map($env, 0))
 toJSON(map($env, array))
+toJSON(map($env, false))
 toJSON(map($env, foo))
+toJSON(map($env, i))
 toJSON(map($env, list))
 toJSON(map(array, #))
 toJSON(map(array, 0))
+toJSON(map(array, list))
+toJSON(map(array, ok))
+toJSON(map(array, str))
 toJSON(map(list, #))
+toJSON(map(list, #index))
 toJSON(map(list, .Bar))
+toJSON(map(list, array))
 toJSON(map(list, f64))
+toJSON(map(list, list))
 toJSON(max(0))
 toJSON(max(1))
 toJSON(max(1.0))
 toJSON(max(1.0, 0))
 toJSON(max(1.0, 1))
+toJSON(max(1.0, array))
+toJSON(max(array))
 toJSON(max(f64))
 toJSON(max(i))
 toJSON(mean(0))
 toJSON(mean(1))
 toJSON(mean(1.0))
+toJSON(mean(array))
 toJSON(mean(f64))
 toJSON(mean(i))
 toJSON(median(0))
@@ -17621,25 +35524,36 @@ toJSON(median(1.0))
 toJSON(median(array))
 toJSON(median(array, array))
 toJSON(median(f64))
+toJSON(median(f64, i))
 toJSON(median(i))
+toJSON(min($env)?.list)
 toJSON(min(0))
 toJSON(min(1))
+toJSON(min(1, f64))
 toJSON(min(1.0))
 toJSON(min(array))
 toJSON(min(f64))
+toJSON(min(i))
 toJSON(nil != $env)
 toJSON(nil != 0)
 toJSON(nil != 1)
 toJSON(nil != 1.0)
 toJSON(nil != add)
 toJSON(nil != array)
+toJSON(nil != f64)
 toJSON(nil != false)
+toJSON(nil != foo)
 toJSON(nil != greet)
 toJSON(nil != i)
+toJSON(nil != list)
 toJSON(nil != nil)
+toJSON(nil != ok)
+toJSON(nil != str)
+toJSON(nil != true or ok)
 toJSON(nil != true)
 toJSON(nil == $env)
 toJSON(nil == 0)
+toJSON(nil == 1)
 toJSON(nil == 1.0)
 toJSON(nil == array)
 toJSON(nil == foo)
@@ -17648,36 +35562,88 @@ toJSON(nil == i)
 toJSON(nil == list)
 toJSON(nil == nil)
 toJSON(nil == ok)
+toJSON(nil ?? 0)
+toJSON(nil ?? 1)
+toJSON(nil ?? array)
+toJSON(nil ?? f64)
+toJSON(nil ?? foo)
+toJSON(nil ?? i)
+toJSON(nil ?? list)
+toJSON(nil ?? nil)
+toJSON(nil ?? true)
+toJSON(nil in $env)
 toJSON(nil in array)
 toJSON(nil in list)
 toJSON(nil not in $env)
 toJSON(nil not in list)
 toJSON(nil) < str
 toJSON(nil) <= str
+toJSON(nil) > toJSON(true)
+toJSON(nil) >= str
+toJSON(nil) ?? str
+toJSON(nil) in $env?.String
+toJSON(nil) in foo
+toJSON(nil) matches str
+toJSON(nil) not contains $env?.[str]
+toJSON(nil) not in foo
 toJSON(nil) not matches foo?.Bar
 toJSON(nil) not startsWith str
 toJSON(nil) | greet()
+toJSON(nil)[:i]
+toJSON(none($env, false))
 toJSON(none($env, true))
 toJSON(none(list, false))
+toJSON(none(list, ok))
+toJSON(not false)
+toJSON(not ok)
+toJSON(not true)
+toJSON(ok != false)
 toJSON(ok != nil)
 toJSON(ok != ok)
+toJSON(ok && false)
 toJSON(ok && ok)
 toJSON(ok && true)
+toJSON(ok == $env)
 toJSON(ok == false)
+toJSON(ok == nil)
+toJSON(ok == nil) < foo?.String()
+toJSON(ok == true)
+toJSON(ok ? 1.0 : 0)
 toJSON(ok ? foo : ok)
 toJSON(ok ?: foo)
+toJSON(ok ?? $env)
+toJSON(ok ?? 1)
+toJSON(ok ?? 1.0)
+toJSON(ok ?? array)
+toJSON(ok ?? f64)
+toJSON(ok ?? false)
+toJSON(ok ?? foo)
+toJSON(ok ?? ok)
+toJSON(ok and true)
 toJSON(ok or false)
+toJSON(ok or true)
+toJSON(ok || false)
 toJSON(ok)
+toJSON(ok) != string(true)
+toJSON(ok) == trimSuffix(str)
+toJSON(ok) ?? i
+toJSON(ok) matches foo.Bar
 toJSON(ok) not startsWith str
+toJSON(ok) | greet()
 toJSON(one($env, true))
 toJSON(one(list, ok))
 toJSON(reduce($env, 1.0, 0))
 toJSON(reduce(array, #index))
 toJSON(reduce(array, 0))
+toJSON(reduce(array, 1))
 toJSON(reduce(array, f64))
+toJSON(reduce(array, foo))
+toJSON(reduce(array, str))
 toJSON(reduce(list, #))
 toJSON(reduce(list, #.Bar))
+toJSON(reduce(list, 0))
 toJSON(reduce(list, 1.0))
+toJSON(reduce(list, f64))
 toJSON(reduce(list, foo))
 toJSON(reduce(list, ok))
 toJSON(reverse(array))
@@ -17690,6 +35656,8 @@ toJSON(round(i))
 toJSON(sort($env))
 toJSON(sort(array))
 toJSON(sortBy(array, #))
+toJSON(sortBy(array, 0))
+toJSON(sortBy(array, 1))
 toJSON(sortBy(array, f64))
 toJSON(sortBy(list, 0))
 toJSON(sortBy(list, i))
@@ -17697,36 +35665,61 @@ toJSON(str != nil)
 toJSON(str <= str)
 toJSON(str == nil)
 toJSON(str > str)
+toJSON(str >= str)
+toJSON(str ?? $env)
+toJSON(str ?? 0)
+toJSON(str ?? array)
+toJSON(str ?? false)
+toJSON(str ?? foo)
+toJSON(str ?? list)
+toJSON(str ?? ok)
 toJSON(str contains str)
+toJSON(str endsWith str)
 toJSON(str in $env)
 toJSON(str in foo)
+toJSON(str in list?.[i])
+toJSON(str matches str)
+toJSON(str not contains str)
 toJSON(str not endsWith str)
 toJSON(str not in $env)
 toJSON(str not in [add, array, foo])
 toJSON(str not in foo)
+toJSON(str startsWith str)
 toJSON(str)
+toJSON(str) ?? array
+toJSON(str) endsWith str
+toJSON(str) matches str
+toJSON(str) matches str || ok
 toJSON(str) | greet()
 toJSON(str[0:])
 toJSON(str[:0])
+toJSON(str[:])
 toJSON(string($env | one(true)))
 toJSON(string($env))
 toJSON(string($env?.[str]))
 toJSON(string(0))
 toJSON(string(1))
+toJSON(string(1.0 - 1))
 toJSON(string(1.0))
 toJSON(string(add))
 toJSON(string(array))
 toJSON(string(f64))
 toJSON(string(false))
 toJSON(string(foo))
+toJSON(string(greet))
+toJSON(string(i))
 toJSON(string(list))
 toJSON(string(nil))
+toJSON(string(ok))
 toJSON(string(str))
 toJSON(string(true))
 toJSON(string(values($env)))
 toJSON(sum($env, 1.0))
 toJSON(sum(array))
 toJSON(sum(array, #))
+toJSON(sum(array, i))
+toJSON(sum(i .. i))
+toJSON(sum(list, i))
 toJSON(toBase64(str))
 toJSON(toJSON(1))
 toJSON(toJSON(1.0))
@@ -17740,26 +35733,48 @@ toJSON(toJSON(nil))
 toJSON(toJSON(ok))
 toJSON(toJSON(str))
 toJSON(toJSON(true))
+toJSON(trim(greet(str)))
 toJSON(trim(str))
 toJSON(trimPrefix($env?.[str]))
+toJSON(trimPrefix(str))
 toJSON(trimSuffix($env?.str))
 toJSON(trimSuffix(str))
 toJSON(true != $env)
+toJSON(true != false)
 toJSON(true != nil)
+toJSON(true != ok)
+toJSON(true != true)
 toJSON(true && false)
 toJSON(true && ok)
+toJSON(true && true)
+toJSON(true == $env)
+toJSON(true == true)
 toJSON(true ? foo : 1.0)
 toJSON(true ? foo : f64)
 toJSON(true ? nil : false)
+toJSON(true ?: greet)
 toJSON(true ?: nil)
+toJSON(true ?? $env)
+toJSON(true ?? foo)
+toJSON(true ?? nil)
+toJSON(true ?? str)
+toJSON(true and ok)
 toJSON(true and true)
 toJSON(true or $env)
+toJSON(true or false)
 toJSON(true or ok)
+toJSON(true or true)
+toJSON(true || $env)
 toJSON(true || ok)
 toJSON(true || true)
 toJSON(true) + str | trimPrefix(str)
 toJSON(true) < str
 toJSON(true) > str
+toJSON(true) ?? $env.greet
+toJSON(true) ?? 1 | groupBy(true)
+toJSON(true) ?? f64
+toJSON(true) ?? foo | filter(true)
+toJSON(true) in foo
 toJSON(true) not endsWith greet(str)
 toJSON(true) not startsWith str
 toJSON(true) | greet()
@@ -17770,6 +35785,7 @@ toJSON(type(0))
 toJSON(type(1.0))
 toJSON(type(add))
 toJSON(type(array))
+toJSON(type(f64 + 1.0))
 toJSON(type(f64))
 toJSON(type(false))
 toJSON(type(foo))
@@ -17779,70 +35795,123 @@ toJSON(type(list))
 toJSON(type(nil))
 toJSON(type(ok))
 toJSON(type(str))
+toJSON(type(true))
 toJSON(uniq(array))
 toJSON(uniq(list))
 toJSON(upper(str))
+toJSON({foo: $env}?.list)
 toJSON({foo: 0, foo: f64}.i)
+toJSON({foo: 0})
+toJSON({foo: 1, foo: 1.0, foo: $env})
 toJSON({foo: 1, foo: true})
 toJSON({foo: 1.0})
 toJSON({foo: 1.0}.f64)
 toJSON({foo: 1})
+toJSON({foo: array})
+toJSON({foo: f64})
 toJSON({foo: false})
+toJSON({foo: foo, foo: array})
+toJSON({foo: foo, foo: f64})
 toJSON({foo: foo, foo: str})
 toJSON({foo: foo, foo: true})
 toJSON({foo: foo})
+toJSON({foo: foo}.Bar)
+toJSON({foo: foo}?.array)
 toJSON({foo: i, foo: foo})
 toJSON({foo: i})
 toJSON({foo: list})
+toJSON({foo: nil != 1.0})
+toJSON({foo: nil, foo: $env, foo: 0})
 toJSON({foo: nil, foo: 1.0})
 toJSON({foo: nil, foo: i})
 toJSON({foo: nil})
 toJSON({foo: ok})
+toJSON({foo: str, foo: 0})
 toJSON({foo: str})
 toJSON({foo: true})
+toPairs($env ?? $env)
+toPairs($env ?? 0)
+toPairs($env ?? 1)
+toPairs($env ?? 1.0)
+toPairs($env ?? add)
+toPairs($env ?? array)
+toPairs($env ?? foo)
+toPairs($env ?? i)
+toPairs($env ?? ok)
+toPairs($env ?? str)
+toPairs($env ?? true)
 toPairs($env) != array
+toPairs($env) != list
 toPairs($env) == array
 toPairs($env) == list
+toPairs($env) ?? array
+toPairs($env) ?? foo
+toPairs($env) ?? greet
+toPairs($env) ?? list
+toPairs($env) ?? str
 toPairs($env) not in $env?.Bar
 toPairs($env) | concat(array)
+toPairs($env) | count(false)
+toPairs($env) | count(ok)
+toPairs($env) | findIndex(false)
 toPairs($env) | findLast(ok)
 toPairs($env) | findLastIndex(true)
 toPairs($env) | groupBy(1.0)
+toPairs($env) | groupBy(false)
+toPairs($env) | groupBy(foo)
 toPairs($env) | groupBy(i)
 toPairs($env) | map(#)
 toPairs($env) | map(1.0)
 toPairs($env) | one(false)
 toPairs($env) | one(true)
 toPairs($env) | reduce(#)
+toPairs($env) | reduce(#, foo)
+toPairs($env) | reduce($env)
 toPairs($env) | reduce(1.0)
 toPairs($env) | reduce(add)
+toPairs($env) | reduce(false)
 toPairs($env) | reduce(foo)
 toPairs($env) | reduce(greet)
 toPairs($env) | reduce(i)
+toPairs($env) | sortBy(0)
+toPairs($env) | sortBy(i)
 toPairs($env)?.[i]
+toPairs(array | groupBy(1.0))
 toPairs(array | groupBy(f64))
 toPairs(array | groupBy(ok))
 toPairs(false ? $env : $env)
 toPairs(groupBy(array, 1.0))
+toPairs(groupBy(array, str))
+toPairs(groupBy(array, true))
 toPairs(groupBy(list, #))
+toPairs(groupBy(list, 1.0))
 toPairs(list | groupBy(#))
 toPairs(list | groupBy(false))
+toPairs(list | groupBy(foo))
+toPairs(list | groupBy(i))
 toPairs(max($env))
 toPairs(min($env))
+toPairs(nil ?? $env)
 toPairs(reduce(array, $env))
 toPairs({foo: $env, foo: true})
 toPairs({foo: $env})
+toPairs({foo: 0, foo: $env})
 toPairs({foo: 0})
 toPairs({foo: 1, foo: $env})
+toPairs({foo: 1, foo: foo})
 toPairs({foo: 1.0 - 1.0})
+toPairs({foo: 1.0, foo: $env})
 toPairs({foo: 1.0, foo: 1})
 toPairs({foo: 1.0})
 toPairs({foo: 1})
 toPairs({foo: add, foo: add})
 toPairs({foo: add})
+toPairs({foo: array, foo: f64})
 toPairs({foo: array})
 toPairs({foo: f64})
+toPairs({foo: false})
 toPairs({foo: foo, foo: greet})
+toPairs({foo: foo, foo: list})
 toPairs({foo: foo, foo: ok})
 toPairs({foo: foo, foo: str})
 toPairs({foo: foo})
@@ -17860,35 +35929,55 @@ trim($env?.[str], str)
 trim($env?.str)
 trim(false ? foo : str)
 trim(foo.Bar)
+trim(foo.Bar, str)
 trim(foo.String())
 trim(foo?.Bar)
 trim(foo?.String())
 trim(greet(foo?.Bar))
 trim(greet(str))
+trim(last(list).Bar)
 trim(list | reduce(.Bar))
 trim(lower(str))
+trim(nil ?? str)
 trim(reduce($env, str, greet))
+trim(reduce(array, str))
+trim(str + str)
+trim(str ?? 1.0)
+trim(str ?? add)
+trim(str ?? list)
 trim(str | greet())
 trim(str)
+trim(str) == str
 trim(str) >= str
+trim(str) ?? array
+trim(str) in foo
 trim(str) matches str
 trim(str) not endsWith $env?.[str]
 trim(str) not in list?.[i]
 trim(str) not matches foo.String()
+trim(str) not matches str
 trim(str) | greet()
+trim(str)[:]
 trim(str, foo.Bar)
 trim(str, str)
 trim(str, toJSON(ok))
 trim(str[0:])
+trim(str[:0])
+trim(str[:1])
+trim(str[:i])
 trim(string($env))
 trim(string($env.ok))
 trim(string($env?.Bar))
 trim(string(0))
+trim(string(1))
 trim(string(1.0))
+trim(string(add))
 trim(string(array))
 trim(string(f64))
 trim(string(false))
 trim(string(foo))
+trim(string(greet))
+trim(string(i))
 trim(string(list))
 trim(string(nil))
 trim(string(ok))
@@ -17897,54 +35986,96 @@ trim(string(true))
 trim(string(upper(str)))
 trim(toBase64(str))
 trim(toJSON($env.list))
+trim(toJSON($env?.foo))
 trim(toJSON(0))
 trim(toJSON(1))
 trim(toJSON(1.0))
 trim(toJSON(array))
 trim(toJSON(f64))
+trim(toJSON(false))
+trim(toJSON(foo != foo))
 trim(toJSON(foo))
+trim(toJSON(i))
 trim(toJSON(list))
 trim(toJSON(nil))
 trim(toJSON(ok))
+trim(toJSON(str))
 trim(toJSON(true))
 trim(trim(str))
 trim(trimPrefix(str))
 trim(trimSuffix(str))
 trim(type($env))
+trim(type(0))
+trim(type(1))
 trim(type(1.0))
+trim(type(add))
 trim(type(array))
+trim(type(f64))
 trim(type(false))
 trim(type(foo))
 trim(type(greet))
 trim(type(i))
+trim(type(list))
 trim(type(nil))
+trim(type(ok))
 trim(type(str))
+trim(type(true))
+trim(upper(str))
+trimPrefix($env) == nil || true
 trimPrefix($env.str)
 trimPrefix($env?.[str])
 trimPrefix($env?.str)
 trimPrefix($env?.str, str)
+trimPrefix(array | reduce(str, add))
 trimPrefix(false ? greet : str)
 trimPrefix(foo.Bar)
 trimPrefix(foo.String())
 trimPrefix(foo?.Bar)
 trimPrefix(foo?.String())
+trimPrefix(greet(foo?.String()))
 trimPrefix(greet(str))
 trimPrefix(greet(toJSON(false)))
 trimPrefix(lower(str))
+trimPrefix(nil ?? str)
+trimPrefix(reduce(array, str))
 trimPrefix(reduce(list, str))
+trimPrefix(str + foo?.Bar)
+trimPrefix(str ?? $env)
+trimPrefix(str ?? 0)
+trimPrefix(str ?? array)
+trimPrefix(str ?? false)
+trimPrefix(str ?? foo)
+trimPrefix(str ?? greet)
+trimPrefix(str ?? i)
+trimPrefix(str ?? str)
+trimPrefix(str | greet())
 trimPrefix(str)
+trimPrefix(str) < type(nil)
 trimPrefix(str) <= str
+trimPrefix(str) == str
+trimPrefix(str) > str
+trimPrefix(str) ?? f64
+trimPrefix(str) endsWith str
+trimPrefix(str) not contains str
+trimPrefix(str) not startsWith str
+trimPrefix(str) startsWith str
 trimPrefix(str, false ? i : str)
 trimPrefix(str, foo?.Bar)
 trimPrefix(str, str)
+trimPrefix(str, string(foo))
+trimPrefix(str, toJSON(nil))
+trimPrefix(str, type(false))
 trimPrefix(str, type(true))
 trimPrefix(str[0:])
+trimPrefix(str[1:])
 trimPrefix(str[:i])
 trimPrefix(string($env))
 trimPrefix(string(0))
 trimPrefix(string(1))
 trimPrefix(string(1.0))
+trimPrefix(string(add))
 trimPrefix(string(array))
+trimPrefix(string(f64))
 trimPrefix(string(false))
 trimPrefix(string(foo))
 trimPrefix(string(greet))
@@ -17956,6 +36087,7 @@ trimPrefix(string(str))
 trimPrefix(string(true))
 trimPrefix(toBase64(str))
 trimPrefix(toJSON(0))
+trimPrefix(toJSON(1))
 trimPrefix(toJSON(1.0))
 trimPrefix(toJSON(array))
 trimPrefix(toJSON(f64))
@@ -17969,18 +36101,26 @@ trimPrefix(toJSON(true))
 trimPrefix(trim(str))
 trimPrefix(trimPrefix(str))
 trimPrefix(trimPrefix(str, str))
+trimPrefix(trimPrefix(type($env)))
 trimPrefix(trimSuffix(str))
 trimPrefix(type($env))
+trimPrefix(type($env.ok))
 trimPrefix(type(0))
+trimPrefix(type(1))
 trimPrefix(type(1.0))
 trimPrefix(type(add))
 trimPrefix(type(array))
 trimPrefix(type(f64))
 trimPrefix(type(false))
 trimPrefix(type(foo))
+trimPrefix(type(greet))
 trimPrefix(type(i))
+trimPrefix(type(list))
 trimPrefix(type(nil))
+trimPrefix(type(ok))
+trimPrefix(type(str))
 trimPrefix(type(true))
+trimPrefix(upper(foo?.String()))
 trimPrefix(upper(str))
 trimSuffix($env.str)
 trimSuffix($env?.[str])
@@ -17995,15 +36135,26 @@ trimSuffix(greet(foo?.String()))
 trimSuffix(greet(str))
 trimSuffix(greet(str), str)
 trimSuffix(greet(string(add)))
+trimSuffix(list | reduce(#.Bar))
 trimSuffix(lower(str))
+trimSuffix(str ?? $env)
+trimSuffix(str ?? foo)
+trimSuffix(str ?? list)
 trimSuffix(str | greet())
 trimSuffix(str)
 trimSuffix(str) != str
+trimSuffix(str) + str
 trimSuffix(str) <= greet(str)
+trimSuffix(str) ?? add
+trimSuffix(str) ?? foo
+trimSuffix(str) ?? ok
 trimSuffix(str) | greet()
+trimSuffix(str, $env?.[str])
 trimSuffix(str, str)
+trimSuffix(string($env))
 trimSuffix(string($env), str)
 trimSuffix(string(0))
+trimSuffix(string(1))
 trimSuffix(string(1.0))
 trimSuffix(string(add))
 trimSuffix(string(array))
@@ -18016,14 +36167,19 @@ trimSuffix(string(i))
 trimSuffix(string(list))
 trimSuffix(string(nil))
 trimSuffix(string(ok))
+trimSuffix(string(str))
+trimSuffix(string(sum($env, 0)))
+trimSuffix(string(true))
 trimSuffix(toBase64($env?.[str]))
 trimSuffix(toBase64($env?.str))
 trimSuffix(toBase64(str))
+trimSuffix(toJSON(0))
 trimSuffix(toJSON(1.0))
 trimSuffix(toJSON(array))
 trimSuffix(toJSON(f64))
 trimSuffix(toJSON(false))
 trimSuffix(toJSON(foo))
+trimSuffix(toJSON(i))
 trimSuffix(toJSON(list))
 trimSuffix(toJSON(nil))
 trimSuffix(toJSON(ok))
@@ -18038,6 +36194,7 @@ trimSuffix(type(1))
 trimSuffix(type(1.0))
 trimSuffix(type(add))
 trimSuffix(type(array))
+trimSuffix(type(f64))
 trimSuffix(type(false))
 trimSuffix(type(foo))
 trimSuffix(type(greet))
@@ -18046,12 +36203,16 @@ trimSuffix(type(list))
 trimSuffix(type(nil))
 trimSuffix(type(ok))
 trimSuffix(type(str))
+trimSuffix(type(true))
 trimSuffix(upper(str))
+true != $env != 1 ?? foo
 true != $env || $env >= 1.0
+true != $env || ok
 true != $env.ok
 true != $env?.Bar
 true != $env?.String
 true != $env?.String?.String
+true != $env?.String?.[str]
 true != $env?.[Bar]
 true != $env?.[String]
 true != $env?.[String]?.Bar
@@ -18059,31 +36220,62 @@ true != $env?.[foobar?.[greet]]
 true != $env?.[foobar]
 true != $env?.[str]
 true != $env?.ok
+true != f64 - 0 ?? $env
 true != false == ok
+true != false ?? i
+true != i ?? f64
+true != list ?? array
+true != list ?? not ok
+true != nil and foo ?? ok
 true != nil and ok
+true != ok != $env?.String
+true != ok ?? array
+true != str ?? add
+true != str ?? greet
+true != str ?? i
 true != true ?: foo
+true != true ?? array
+true != true ?? greet
 true && $env != list
 true && $env == list?.[i]
 true && $env == str
+true && $env ?? $env[:foo]
+true && $env ?? foo
+true && $env ?? groupBy(list, foo)?.f64
+true && $env ?? not $env
+true && $env ?? ok
 true && $env.ok
 true && $env?.Bar
 true && $env?.String
 true && $env?.[Bar]
+true && $env?.[Bar]?.[str]
 true && $env?.[Bar]?.str
 true && $env?.[String]
 true && $env?.[foobar]
 true && $env?.[str]
 true && $env?.foobar
+true && $env?.i != f64
 true && $env?.ok
 true && 0 * i < 1
+true && 0 ?? add
+true && 1 < len($env)
 true && 1.0 == f64
+true && 1.0 > 0 and true
 true && 1.0 >= f64
+true && add ?? list
+true && false != false || true
 true && false && ok
 true && greet == greet
+true && nil != foo
 true && nil == ok
 true && nil == str
 true && ok ?: str
+true && str != str
+true && str ?? $env?.[ok]
+true && str ?? f64
+true && str ?? i
 true && str startsWith $env?.String
+true && true ?? ok
 true == $env == ok
 true == $env || $env != ok
 true == $env || 1.0 >= f64
@@ -18094,81 +36286,152 @@ true == $env?.[Bar]
 true == $env?.[String]
 true == $env?.[foobar]
 true == $env?.[str]
+true == $env?.foobar
 true == $env?.ok
+true == 1.0 ?? foo || ok
+true == f64 ?? greet
+true == false and ok
+true == foo ?? f64
+true == nil && false != nil
+true == nil && foo in $env
 true == nil == ok
 true == ok && ok
+true == true ?: add
+true == true or !true
 true ? $env : $env.f64
 true ? $env : $env.foo
 true ? $env : $env.str
 true ? $env : $env?.Bar
+true ? $env : $env?.String
 true ? $env : $env?.[array]
+true ? $env : $env?.[list]
+true ? $env : $env?.[ok]
+true ? $env : $env?.greet
 true ? $env : foo.String
+true ? $env : i | date(i)
+true ? 0 : $env.i
+true ? 0 : $env?.Bar
 true ? 0 : $env?.Bar?.greet
 true ? 0 : $env?.String
 true ? 0 : $env?.[Bar]
+true ? 0 : $env?.[add]?.[f64]
+true ? 0 : $env?.[sortBy(1, foobar)]
+true ? 0 : $env?.foobar
 true ? 0 : $env[:list(foobar)]
+true ? 0 : 1 < 1.0 ** 1.0
+true ? 0 : foo.String()
+true ? 0 : i > f64
+true ? 1 : $env | max(0, f64)
+true ? 1 : $env.f64
+true ? 1 : $env?.[ok]
 true ? 1 : $env?.i
 true ? 1 : 1.0 / 1 == f64
+true ? 1 : list | sortBy(add)
+true ? 1.0 : $env | sortBy(add)
+true ? 1.0 : $env.foo
 true ? 1.0 : $env.greet
+true ? 1.0 : $env.ok
 true ? 1.0 : $env.str
+true ? 1.0 : $env?.[Bar]
 true ? 1.0 : $env?.[i]
 true ? 1.0 : $env?.[str]
+true ? 1.0 : $env?.list
 true ? 1.0 : $env?.ok
 true ? 1.0 : str >= $env?.[Bar]
 true ? add : $env ^ 0 != $env
 true ? add : $env.f64
 true ? add : $env?.Bar
+true ? add : $env?.[add]
+true ? add : $env?.[ok]
+true ? add : foo.String
+true ? add : i != i
+true ? array : $env.array
+true ? array : $env?.[str]
 true ? array : $env?.foo
 true ? array : foo.String
 true ? f64 : $env.add
+true ? f64 : $env?.[f64]
 true ? f64 : $env?.[i]
 true ? f64 : $env?.greet
 true ? f64 : $env?.i
 true ? f64 : $env[foo?.[String]:]
 true ? false : $env | count($env)
+true ? false : $env.list
+true ? false : $env?.[array]
+true ? false : $env?.[i]
 true ? false : $env?.f64
+true ? false : $env[:Bar not matches $env]
 true ? false : array != array
+true ? foo : $env | greet()
+true ? foo : $env | one(ok)
+true ? foo : $env | sortBy(1.0)
 true ? foo : $env.array
 true ? foo : $env.foo
 true ? foo : $env?.[String]
+true ? foo : $env?.[foo]?.greet
 true ? foo : $env?.[str]
 true ? foo : $env?.array
+true ? foo : $env?.i
 true ? foo : $env?.str
 true ? foo : 1.0 + i
+true ? foo : array | sortBy(f64)
+true ? foo : foo ?? list
+true ? foo : foo.Bar
+true ? foo : foo.String
 true ? foo : foo?.Bar
 true ? foo : i .. i
 true ? greet : $env | sum(.greet)
 true ? greet : $env.greet
 true ? greet : $env?.[add].foo
 true ? greet : $env?.str
+true ? greet : foo?.Bar
 true ? greet : nil != none($env, #)
 true ? i : $env?.[Bar]
+true ? i : array | map(i)
+true ? list : $env | all(#.foo)
 true ? list : $env?.String
+true ? list : $env?.[f64]
 true ? list : $env?.[greet]
 true ? list : $env?.[ok]
 true ? list : $env?.ok
 true ? list : foo.Bar
 true ? list : foo?.Bar
 true ? list : foo?.String
+true ? nil : $env | bitxor(0)
 true ? nil : $env.str
 true ? nil : $env?.[f64]
 true ? nil : $env?.foo
+true ? nil : $env?.str
+true ? nil : $env[str(1.0):] | all(.list?.i(foobar))
 true ? nil : foo.Bar
+true ? nil : nil != greet
 true ? ok : $env.foo
 true ? ok : $env?.[str]
+true ? ok : $env?.array
 true ? ok : foo.String
+true ? str : $env?.array
+true ? str : $env?.f64
+true ? str : array | max(i)
+true ? str : foo.Bar
 true ? str : foo?.Bar
 true ? str : i + i
 true ? true : $env?.String.str
+true ? true : $env?.[array]
+true ? true : $env?.[array].greet
 true ? true : $env?.greet
+true ? true : $env?.str
 true ? true : 1.0 == $env?.Bar
 true ? true : array | date(false, foo)
 true ? true : foo?.Bar
 true ? true : list | sum(#)
+true ? true : str != str
 true ?: $env != 0 ^ $env
 true ?: $env % i
+true ?: $env or ok
+true ?: $env | any(.i)
 true ?: $env | count(.list)
 true ?: $env | find(#)
+true ?: $env | groupBy(.foo)
 true ?: $env | groupBy(1.0)
 true ?: $env | reduce(#.list)
 true ?: $env | reduce(1.0)
@@ -18177,12 +36440,17 @@ true ?: $env.array
 true ?: $env.foo
 true ?: $env.greet
 true ?: $env.i
+true ?: $env.i ?? $env
 true ?: $env.list
 true ?: $env.ok
 true ?: $env.str
+true ?: $env?.Bar
+true ?: $env?.String
 true ?: $env?.[Bar]
 true ?: $env?.[String()]
 true ?: $env?.[array]
+true ?: $env?.[f64]
+true ?: $env?.[foo]
 true ?: $env?.[i]
 true ?: $env?.[list]
 true ?: $env?.add
@@ -18190,75 +36458,200 @@ true ?: $env?.array
 true ?: $env?.f64
 true ?: $env?.foo
 true ?: $env?.greet
+true ?: $env?.i
 true ?: $env?.ok
+true ?: $env?.str
 true ?: $env[:foobar]
+true ?: 0 != 0 ? true : false
+true ?: 1.0 - f64
 true ?: 1.0 == f64
+true ?: 1.0 >= f64
+true ?: 1.0 | max($env)
+true ?: array | map(1.0)
+true ?: array?.[$env?.String()]
+true ?: foo ?? f64
 true ?: foo.Bar
 true ?: foo.String
+true ?: foo?.Bar
 true ?: foo?.String
 true ?: nil != f64
 true ?: nil == $env?.str
+true ?? $env.add
+true ?? $env.array
+true ?? $env.f64
+true ?? $env.foo
+true ?? $env.greet
+true ?? $env.i
+true ?? $env.list
+true ?? $env.ok
+true ?? $env.str
+true ?? $env?.Bar
+true ?? $env?.String
+true ?? $env?.String()
+true ?? $env?.String?.f64
+true ?? $env?.[1.0 not endsWith foobar]
+true ?? $env?.[Bar]
+true ?? $env?.[Bar]?.[str]
+true ?? $env?.[String]
+true ?? $env?.[abs(foobar)]
+true ?? $env?.[add]
+true ?? $env?.[array]
+true ?? $env?.[f64]
+true ?? $env?.[foo?.greet]
+true ?? $env?.[foo]
+true ?? $env?.[foo].array
+true ?? $env?.[foobar | one(#)]
+true ?? $env?.[foobar.f64(1, foobar, ok)]
+true ?? $env?.[greet]
+true ?? $env?.[i]
+true ?? $env?.[list]
+true ?? $env?.[ok]
+true ?? $env?.[ok]?.[greet]
+true ?? $env?.[str]
+true ?? $env?.add
+true ?? $env?.array
+true ?? $env?.f64
+true ?? $env?.foo
+true ?? $env?.foobar
+true ?? $env?.foobar.String
+true ?? $env?.greet
+true ?? $env?.i
+true ?? $env?.list
+true ?? $env?.ok
+true ?? $env?.str
+true ?? $env[$env?.[str]:]
+true ?? $env[:String.greet].greet
+true ?? $env[:array[:f64]]
+true ?? $env[f64():]
+true ?? $env[false == str:]
+true ?? $env[foobar ^ foobar:findIndex($env, #index)]
+true ?? $env[foobar:foobar]
+true ?? 0 ?? greet
+true ?? 1 ?? groupBy($env, .str)
+true ?? 1.0 ?? i
+true ?? array?.[i]
+true ?? foo ?? i
+true ?? foo.Bar
+true ?? foo.String
+true ?? foo?.Bar
+true ?? foo?.String
+true ?? foo?.String()
+true ?? i | get(false)
+true ?? list?.[i]
+true ?? nil ?? greet
+true and $env != greet
 true and $env == f64
+true and $env == last(array)
+true and $env ?? $env ?? add
+true and $env ?? count($env, #)
+true and $env ?? str
 true and $env startsWith $env?.Bar
 true and $env.ok
 true and $env?.Bar
 true and $env?.Bar?.Bar
 true and $env?.String
+true and $env?.String?.Bar
+true and $env?.String?.[array]
 true and $env?.String?.ok
 true and $env?.[Bar]
+true and $env?.[Bar]?.i
 true and $env?.[String]
 true and $env?.[str]
 true and $env?.foobar
 true and $env?.foobar?.array()
 true and $env?.ok
+true and 0 != f64
+true and 0 < i
 true and 1 > f64
 true and 1 > i
+true and 1 >= i
 true and 1 in sort($env)
 true and 1.0 > f64
+true and 1.0 in array
+true and add ?? array
 true and array != list
 true and f64 < f64
+true and f64 <= f64
+true and f64 ?? foo
+true and false ?? ok
 true and false || ok
+true and foo != foo
+true and foo == foo
 true and i == i
 true and nil != greet
+true and nil != list
 true and nil == greet
 true and str != str
+true and str ?? greet
 true and true || $env >= $env
 true in $env?.Bar
+true in $env?.Bar?.foo
 true in $env?.String
 true in $env?.[Bar]
 true in $env?.[String]
+true in $env?.[first(foobar)]
+true in $env?.[foobar | last(nil)]
 true in $env?.[foobar]
 true not in $env?.Bar
 true not in $env?.String
+true not in $env?.String?.Bar(foo)
 true not in $env?.[Bar]
 true not in $env?.[Bar]?.String
 true not in $env?.[Bar]?.foo
 true not in $env?.[String]
 true not in $env?.[String]?.[list]
 true not in $env?.[foobar]
+true not in array ?? add
+true not in array ?? foo
+true not in list ?? i
+true or $env != array
+true or $env != ok
+true or $env && ok
+true or $env * findIndex(list, true)
+true or $env - f64
+true or $env - list ?? false
+true or $env ?? $env?.[Bar]
+true or $env ?? foo
+true or $env endsWith $env?.greet($env)
 true or $env in str
+true or $env not in [i]
 true or $env startsWith str
 true or $env.ok
 true or $env?.Bar
 true or $env?.Bar()
+true or $env?.Bar(add not matches foobar)
+true or $env?.Bar(f64?.String() in count(greet))
+true or $env?.Bar?.array
 true or $env?.String
 true or $env?.String()
+true or $env?.String(add())
+true or $env?.String(true | findLastIndex(1))
 true or $env?.String?.ok
 true or $env?.[0 | one(1.0)]
 true or $env?.[Bar]
+true or $env?.[Bar].ok
 true or $env?.[String]
 true or $env?.[add]
+true or $env?.[add]?.[add]
 true or $env?.[add]?.str
+true or $env?.[array(ok, foobar)]
 true or $env?.[array]
 true or $env?.[array]?.greet?.Bar
 true or $env?.[array]?.str()
 true or $env?.[f64]
+true or $env?.[float(array, foobar)]
+true or $env?.[foo | findLastIndex(#)]
 true or $env?.[foo]
+true or $env?.[foobar != foo]
+true or $env?.[foobar | concat(true)]
 true or $env?.[greet]
 true or $env?.[greet]?.[add]
 true or $env?.[i.f64]
 true or $env?.[i]
+true or $env?.[i] == ok
+true or $env?.[list(foobar, foobar)]?.foo
 true or $env?.[list]
+true or $env?.[list]?.list
 true or $env?.[ok(foobar)]
 true or $env?.[ok]
 true or $env?.[str.greet]
@@ -18274,124 +36667,250 @@ true or $env[:array ?: foo]
 true or $env[:bitnand(greet, foobar)]
 true or $env[:foobar?.String(foobar, foobar)]
 true or $env[:greet]
+true or $env[:i]
+true or $env[:nil | filter(false)]
+true or $env[:str]
 true or $env[:true || foobar]
+true or $env[foobar:]
 true or $env[foobar?.[array]:]
+true or $env[none($env, .String):]
+true or $env[ok:]
+true or $env[trimSuffix(foobar, nil, 1.0, array):]
 true or 0 < f64
+true or 0 < f64 ** 1
 true or 0 <= $env?.[f64]?.[foo]
+true or 0 <= i
+true or 0 ?? foo?.Bar
 true or 1 > f64
 true or 1 >= $env in $env
+true or 1.0 != i
+true or 1.0 <= $env ^ i
 true or 1.0 > i
 true or 1.0 >= f64
+true or array == list
 true or f64 + $env?.[add]
+true or f64 ?? foo
+true or f64 ?? i
+true or f64 ?? list
 true or false ?: sum($env, .Bar)
 true or false or ok
+true or foo != foo && true
+true or greet == greet
+true or i > $env[:foobar]
 true or i not in $env * f64
+true or list != list
+true or nil == add
 true or nil == str in $env
+true or nil not in $env?.[String]
 true or nil not in list
+true or ok && ok
 true or ok and foo == $env?.[String]
+true or ok in sum($env)
+true or str == toJSON(f64)
 true or str contains $env?.str
+true or str in $env[list:]
 true or str not in foo
 true || $env != 1.0 - $env
 true || $env != i
+true || $env <= foo?.Bar
 true || $env == greet
+true || $env > f64
+true || $env >= f64 - 0
+true || $env ?? add
+true || $env ?? array
+true || $env ?? f64
+true || $env ?? foo
+true || $env ?? ok
 true || $env contains str
 true || $env in str
 true || $env not contains $env?.[foo]
+true || $env not contains str
+true || $env or ok
 true || $env.ok
 true || $env?.Bar
 true || $env?.Bar()
 true || $env?.Bar?.i()
 true || $env?.String
+true || $env?.String($env | bitshl(str)).str
 true || $env?.String()
 true || $env?.String(false > foobar, array(foobar))
+true || $env?.String(foobar?.greet(foobar))
 true || $env?.String(map(foobar | findIndex(#.str), .greet))
 true || $env?.String(reduce(foobar, #.list).i)
 true || $env?.String?.list
+true || $env?.[$env > list]
 true || $env?.[Bar(nil, 0)]
 true || $env?.[Bar]
 true || $env?.[String]
+true || $env?.[add(String)]
 true || $env?.[add]
 true || $env?.[add].f64
 true || $env?.[add].f64.list
 true || $env?.[array?.array()]
 true || $env?.[array]
 true || $env?.[f64]
+true || $env?.[foo.i]
 true || $env?.[foo]
 true || $env?.[foobar | findIndex(add)]
+true || $env?.[foobar | findLastIndex(.ok)]
 true || $env?.[foobar]
 true || $env?.[greet]
 true || $env?.[i]
+true || $env?.[i]?.[ok]
 true || $env?.[list]
+true || $env?.[list]?.String
+true || $env?.[ok not startsWith 1.0]
 true || $env?.[ok]
 true || $env?.[ok]?.[ok]
 true || $env?.[str]
+true || $env?.[{foo: nil}]
+true || $env?.any($env)
 true || $env?.foobar
 true || $env?.ok
 true || $env?.reduce($env)
 true || $env[:String == foo]
+true || $env[:array($env)]
 true || $env[:foobar]
 true || $env[:ok ? false : add]
 true || $env[:str]
+true || $env[Bar | map(1):foobar]
 true || $env[String.Bar(foobar):add()]
 true || $env[duration(String):]
 true || $env[false | bitand(str):]
+true || $env[foo(foobar):f64 contains list]
 true || $env[foobar:]
 true || $env[foobar?.[str]:str()]
 true || $env[list endsWith str:foobar]
+true || $env[list:]
+true || $env[ok + foobar:]
+true || $env[ok not in foobar:]
 true || 0 != $env?.f64
+true || 0 != f64
 true || 0 <= $env?.String(str)
+true || 0 > 1.0 != true
+true || 0 >= median(0, $env)
+true || 1 > f64
+true || 1.0 ** f64 >= f64
+true || 1.0 + 1.0 > 1.0
+true || 1.0 < $env?.[str]
 true || 1.0 < find($env, #)
 true || 1.0 <= i
+true || 1.0 > f64
 true || 1.0 > f64 == true
+true || 1.0 >= f64
+true || 1.0 >= i
+true || 1.0 in $env?.[add]
 true || add != add
+true || add ?? f64
+true || array != list
+true || array ?? !true
+true || array not in $env?.[f64]
+true || false == $env?.[add]
+true || false ?: f64
+true || false ?: foo ?? f64
+true || false ?? $env?.[array]
+true || foo == $env || ok
+true || foo ?? array
+true || foo ?? ok
+true || i == $env?.[f64]
 true || i > f64
+true || i >= $env ?? $env
+true || i in array
 true || nil != f64
+true || nil != greet ?? $env
+true || nil != i
 true || nil == foo
 true || nil == ok
+true || ok ?? greet
+true || true && f64 != 1.0
+true || true and ok
+true; $env?.[str]
+true; foo?.String
+type(!false)
+type(!ok)
+type(!true)
 type($env != $env)
 type($env != 0)
+type($env != 1.0)
 type($env != add)
 type($env != f64)
 type($env != foo)
 type($env != greet)
 type($env != list)
 type($env != nil)
+type($env != str)
+type($env != true)
 type($env && true)
 type($env == $env)
 type($env == 1)
 type($env == 1.0)
 type($env == add)
+type($env == array)
 type($env == f64)
 type($env == false)
 type($env == foo)
+type($env == greet)
 type($env == nil)
+type($env == ok)
+type($env == str)
+type($env ?? $env)
+type($env ?? 1)
+type($env ?? 1.0)
+type($env ?? array)
+type($env ?? false)
+type($env ?? foo)
+type($env ?? greet)
+type($env ?? i)
+type($env ?? list)
+type($env ?? nil)
+type($env and false)
 type($env and true)
 type($env in array)
 type($env in list)
 type($env not in array)
 type($env not in list)
+type($env or false)
 type($env or true)
 type($env | all(true))
+type($env | any(false))
 type($env | any(ok))
 type($env | any(true))
+type($env | count(false))
 type($env | count(ok))
+type($env | count(true))
+type($env | find(false))
+type($env | findIndex(true))
 type($env | findLastIndex(ok))
 type($env | map(#index))
+type($env | map($env))
+type($env | map(1.0))
+type($env | map(false))
 type($env | map(foo))
+type($env | map(ok))
+type($env | map(str))
 type($env | none(true))
 type($env | one(false))
 type($env | sum(0))
 type($env | sum(1.0))
 type($env || false)
+type($env || true)
 type($env) != foo?.Bar
+type($env) != str
+type($env) <= str
+type($env) contains str
+type($env) endsWith str
+type($env) in foo
 type($env) not contains toJSON(true)
 type($env) not in foo
 type($env) not matches str
+type($env) startsWith type($env)
 type($env) | greet()
+type($env) | indexOf(str)
 type($env.add)
 type($env.array)
 type($env.f64)
 type($env.foo)
+type($env.foo?.Bar)
 type($env.greet)
 type($env.i)
 type($env.list)
@@ -18401,6 +36920,7 @@ type($env?.$env)
 type($env?.Bar)
 type($env?.String)
 type($env?.String?.add)
+type($env?.String?.greet)
 type($env?.[Bar])
 type($env?.[Bar]) | trimPrefix(str)
 type($env?.[String])
@@ -18413,15 +36933,23 @@ type($env?.add)
 type($env?.add) | greet()
 type($env?.array)
 type($env?.f64)
+type($env?.false)
 type($env?.foo)
+type($env?.foo?.String)
 type($env?.foobar)
 type($env?.greet)
 type($env?.i)
+type($env?.list ?? foo)
 type($env?.list)
 type($env?.nil)
 type($env?.ok)
 type($env?.str)
 type($env?.true)
+type(-0)
+type(-1)
+type(-1.0)
+type(-f64)
+type(-i)
 type(0 != $env)
 type(0 != 0)
 type(0 != 1.0)
@@ -18430,40 +36958,76 @@ type(0 != i)
 type(0 != nil)
 type(0 % i)
 type(0 * 0)
+type(0 * 1)
+type(0 ** 0)
 type(0 + 0)
 type(0 + 1)
 type(0 + i)
+type(0 - 0)
 type(0 - 1)
 type(0 - f64)
+type(0 - i)
 type(0 .. 0)
 type(0 .. 1)
 type(0 .. i)
 type(0 / 1)
 type(0 / 1.0)
 type(0 / i)
+type(0 < 0)
+type(0 < 1)
 type(0 < 1.0)
+type(0 < f64)
 type(0 <= 1)
+type(0 <= 1.0)
 type(0 <= i)
+type(0 == $env)
 type(0 == 1)
 type(0 == 1.0)
 type(0 == i)
 type(0 == nil)
+type(0 > 0)
 type(0 > 1.0)
+type(0 > i)
+type(0 >= 1.0)
+type(0 ?? $env)
+type(0 ?? $env?.ok)
+type(0 ?? 1)
+type(0 ?? 1.0)
+type(0 ?? foo)
+type(0 ?? greet)
+type(0 ?? list)
+type(0 ?? nil)
+type(0 ?? ok)
+type(0 ?? str)
+type(0 ^ 1)
 type(0 ^ 1.0)
+type(0 ^ f64)
 type(0 ^ i)
+type(0 | bitshr(0))
+type(0 | bitxor(1))
 type(0 | median(1, 1.0))
 type(0 | min(0))
 type(0 | min(i))
 type(0) != str
+type(0) ?? array
+type(0) ?? i
+type(0) ?? ok
 type(0) in foo
 type(0) not startsWith str
+type(0) | greet()
+type(0) | splitAfter(str)
+type(0) | trim(str)
 type(0)[i:]
 type(0..i)
+type(0.0)
+type(0.1)
 type(1 != $env)
+type(1 != 1.0)
 type(1 != f64)
 type(1 != nil)
 type(1 % 1)
 type(1 * 0)
+type(1 * 1)
 type(1 * 1.0)
 type(1 * f64)
 type(1 * i)
@@ -18472,28 +37036,52 @@ type(1 ** f64)
 type(1 + 0)
 type(1 + 1)
 type(1 + 1.0)
+type(1 + i)
+type(1 - 1.0)
 type(1 .. 0)
+type(1 .. 1)
+type(1 / 0)
 type(1 / 1)
+type(1 / 1.0)
+type(1 / f64)
 type(1 / i)
+type(1 < 1.0)
 type(1 <= 0)
 type(1 <= 1)
 type(1 <= 1.0)
 type(1 <= i)
+type(1 == $env)
+type(1 == 1.0)
+type(1 == f64)
 type(1 == i)
 type(1 == nil)
 type(1 > 0)
 type(1 > 1)
 type(1 > 1.0)
 type(1 > f64)
+type(1 > i)
 type(1 >= 0)
 type(1 >= 1.0)
+type(1 >= f64)
 type(1 >= i)
+type(1 ?? $env)
+type(1 ?? 0)
+type(1 ?? add)
+type(1 ?? foo)
+type(1 ?? ok)
+type(1 ?? str)
 type(1 ^ 0)
 type(1 ^ 1)
 type(1 ^ 1.0)
 type(1 in array)
 type(1 not in array)
+type(1) != str
+type(1) < str
+type(1) <= str
+type(1) >= type(ok)
+type(1) in $env?.Bar
 type(1) not in foo
+type(1) not matches str
 type(1) startsWith reduce(list, #.Bar)
 type(1) | greet()
 type(1.0 != $env)
@@ -18508,12 +37096,14 @@ type(1.0 * 1)
 type(1.0 * 1.0)
 type(1.0 * f64)
 type(1.0 * i)
+type(1.0 * i) | greet()
 type(1.0 ** 1)
 type(1.0 ** 1.0)
 type(1.0 ** f64)
 type(1.0 + 0)
 type(1.0 + 1)
 type(1.0 + 1.0)
+type(1.0 + f64)
 type(1.0 + i)
 type(1.0 - 0)
 type(1.0 - 1.0)
@@ -18522,49 +37112,84 @@ type(1.0 - i)
 type(1.0 / 1)
 type(1.0 / 1.0)
 type(1.0 / f64)
+type(1.0 / i)
 type(1.0 < 0)
 type(1.0 < 1)
 type(1.0 < 1.0)
+type(1.0 < f64)
 type(1.0 < i)
 type(1.0 <= 0)
+type(1.0 <= 1)
 type(1.0 <= 1.0)
+type(1.0 <= i)
 type(1.0 == $env)
+type(1.0 == 0)
 type(1.0 == 1.0)
 type(1.0 == f64)
 type(1.0 == i)
 type(1.0 == nil)
 type(1.0 > 1.0)
+type(1.0 > f64)
 type(1.0 > i)
+type(1.0 >= 0)
 type(1.0 >= 1)
 type(1.0 >= 1.0)
+type(1.0 >= f64)
 type(1.0 >= i)
+type(1.0 ?? $env)
+type(1.0 ?? 0)
+type(1.0 ?? add)
+type(1.0 ?? f64)
+type(1.0 ?? foo)
+type(1.0 ?? greet)
+type(1.0 ?? i)
+type(1.0 ?? nil)
+type(1.0 ?? ok)
+type(1.0 ?? str)
 type(1.0 ^ 0)
 type(1.0 ^ 1.0)
 type(1.0 ^ f64)
+type(1.0 ^ i)
+type(1.0 in array)
 type(1.0 | max(0))
 type(1.0 | mean(1.0))
 type(1.0)
+type(1.0) + foo.Bar
 type(1.0) + str
+type(1.0) < str
 type(1.0) >= str
+type(1.0) ?? array
+type(1.0) ?? f64
+type(1.0) ?? greet($env)
 type(1.0) contains str
 type(1.0) not endsWith foo.Bar
 type(1.0) not endsWith str
 type(1.0) not matches str
+type(1.0) not startsWith foo?.Bar
 type(1.0) startsWith str
 type(1.0) | greet()
 type(1.0)[:i]
+type([$env, $env])
+type([$env, 0])
+type([$env, f64])
 type([$env])
 type([0])
+type([1.0, 0])
 type([1.0, foo])
 type([1.0])
 type([1])
 type([add])
 type([array])
 type([f64])
+type([false, $env])
 type([false])
+type([foo, foo])
 type([foo, i])
+type([foo, nil])
 type([foo])
 type([greet])
+type([i, array])
+type([i, foo, nil])
 type([i])
 type([list, 1.0, true])
 type([list, ok])
@@ -18572,6 +37197,7 @@ type([list])
 type([nil, foo])
 type([nil])
 type([ok, f64])
+type([ok, nil])
 type([ok])
 type([str])
 type([true, foo])
@@ -18579,49 +37205,98 @@ type([true])
 type(abs(0))
 type(abs(1))
 type(abs(1.0))
+type(abs(f64))
 type(abs(i))
 type(add != $env)
 type(add != add)
 type(add == nil)
+type(add ?? $env)
+type(add ?? $env?.[i])
+type(add ?? 0)
+type(add ?? foo)
+type(add ?? i)
+type(add ?? list)
+type(add ?? ok)
+type(add ?? true)
+type(add(1, 0))
 type(add(i, 0))
 type(add)
 type(add) != str
 type(add) == foo.Bar
+type(add) > str
+type(add) ?? max(array)
 type(add) matches str
 type(add) not matches str
 type(add) | greet()
 type(add)[:]
+type(all($env, true))
 type(all(array, false))
+type(all(array, true))
 type(all(list, true))
+type(any($env, false))
+type(any($env, ok))
 type(any(array, 1 > #))
+type(any(array, false))
 type(any(array, ok))
+type(any(list, false))
+type(array != nil)
 type(array == $env)
+type(array == array)
 type(array == nil)
+type(array ?? $env)
+type(array ?? 1.0)
+type(array ?? add)
+type(array ?? array)
+type(array ?? f64)
+type(array ?? false)
+type(array ?? i)
+type(array ?? nil)
+type(array ?? str)
+type(array ?? true)
 type(array | find(false))
 type(array | findIndex(false))
 type(array | findIndex(ok))
+type(array | groupBy(#))
+type(array | groupBy(foo))
 type(array | groupBy(ok))
+type(array | map(#))
+type(array | map(1))
+type(array | map(greet))
 type(array | min(array))
 type(array | none(false))
 type(array | none(ok))
 type(array | reduce(#))
 type(array | reduce(#, foo))
+type(array | reduce(#index))
 type(array | reduce(1.0, list))
 type(array | reduce(1.0, ok))
 type(array | reduce(false))
+type(array | reduce(false, add))
 type(array | reduce(foo))
+type(array | reduce(true))
 type(array | sortBy(#))
+type(array | sum(#))
+type(array | sum(1))
+type(array | sum(1.0))
 type(array | sum(i))
 type(array)
+type(array) != false ?? i
+type(array) + str
 type(array) < str
 type(array) == str
+type(array) ?? f64
+type(array) ?? greet
+type(array) ?? str
 type(array) endsWith $env?.[Bar]?.[str]
 type(array) in foo
 type(array) not in foo
 type(array) | repeat(1)
+type(array?.[0])
 type(array?.[i])
 type(array[1:])
 type(array[:0])
+type(array[:])
+type(array[:i])
 type(bitnand(i, 0))
 type(bitnot(0))
 type(bitnot(1))
@@ -18629,65 +37304,125 @@ type(bitnot(i))
 type(bitshr(i, 1))
 type(bitxor(i, i))
 type(ceil(0))
+type(ceil(1 - f64))
 type(ceil(1))
 type(ceil(1.0))
 type(ceil(f64))
+type(ceil(floor(i)))
 type(ceil(i))
 type(concat(array))
 type(concat(list))
 type(count($env, ok))
+type(count($env, true))
 type(count([true]))
+type(f64 != 0)
 type(f64 != 1)
 type(f64 != 1.0)
+type(f64 != nil)
+type(f64 * 0)
 type(f64 * 1.0)
 type(f64 * f64)
 type(f64 * i)
+type(f64 ** 0)
 type(f64 ** 1.0)
 type(f64 ** i)
 type(f64 + 1)
 type(f64 + 1.0)
+type(f64 + f64)
 type(f64 + i)
 type(f64 - 0)
+type(f64 - 1.0)
+type(f64 / 0)
 type(f64 / 1.0)
+type(f64 / i)
+type(f64 < 1)
 type(f64 < 1.0)
 type(f64 <= 1)
+type(f64 <= 1.0)
+type(f64 <= i)
 type(f64 == 0)
+type(f64 == 1)
 type(f64 == f64)
 type(f64 == nil)
+type(f64 > 0 != $env)
 type(f64 > 1)
 type(f64 > 1.0)
 type(f64 > f64)
 type(f64 > i)
+type(f64 >= 1)
 type(f64 >= 1.0)
+type(f64 >= f64)
+type(f64 ?? $env?.[nil == nil])
+type(f64 ?? array)
+type(f64 ?? false)
+type(f64 ?? foo)
+type(f64 ?? str)
+type(f64 ?? true)
 type(f64 ^ 1)
 type(f64 ^ 1.0)
+type(f64 ^ f64)
 type(f64 ^ i)
 type(f64 not in array)
 type(f64)
+type(f64) == str
 type(f64) > str
+type(f64) >= str
+type(f64) matches toJSON(1.0)
 type(f64) not startsWith str
+type(f64) startsWith str
+type(f64) | greet()
 type(false != false)
+type(false != nil)
 type(false != ok)
+type(false != true)
 type(false && $env)
+type(false && ok)
 type(false == $env)
 type(false == false)
+type(false == ok)
 type(false ? f64 : 1)
 type(false ? foo : add)
 type(false ? foo : list)
 type(false ? list : foo)
+type(false ?? $env)
+type(false ?? 1.0)
+type(false ?? add)
+type(false ?? f64)
+type(false ?? i)
+type(false ?? list)
+type(false ?? nil)
+type(false ?? ok)
+type(false ?? str)
+type(false ?? true)
+type(false and $env)
+type(false and true)
+type(false or $env)
+type(false or ok)
 type(false or true)
 type(false || $env)
 type(false || false)
+type(false || ok)
+type(false || true)
 type(false) == str
 type(false) > str
+type(false) ?? $env?.[i]
+type(false) ?? greet
+type(false) | greet()
+type(false) | splitAfter(str)
 type(filter($env, false))
 type(find(array, false))
+type(find(array, true))
 type(findIndex($env, ok))
+type(findIndex(list, ok))
 type(findLast($env, false))
+type(findLast(array, ok))
+type(findLast(list, false))
 type(findLast(list, ok))
+type(findLastIndex(array, ok))
 type(first($env))
 type(first(array))
 type(first(list))
+type(flatten(array))
 type(flatten(list))
 type(float(0))
 type(float(1))
@@ -18695,8 +37430,10 @@ type(float(1.0))
 type(float(f64))
 type(float(i))
 type(floor(0))
+type(floor(1))
 type(floor(1.0))
 type(floor(f64))
+type(floor(i))
 type(foo != $env)
 type(foo != $env?.foo)
 type(foo != foo)
@@ -18704,19 +37441,42 @@ type(foo != nil)
 type(foo == $env)
 type(foo == foo)
 type(foo == nil)
+type(foo ?? $env)
+type(foo ?? 0)
+type(foo ?? 1)
+type(foo ?? 1.0)
+type(foo ?? add)
+type(foo ?? array)
+type(foo ?? f64)
+type(foo ?? false)
+type(foo ?? foo)
+type(foo ?? greet)
+type(foo ?? i)
+type(foo ?? list)
+type(foo ?? nil)
+type(foo ?? ok)
+type(foo ?? true)
 type(foo in list)
+type(foo not in list)
 type(foo)
 type(foo) != $env?.foobar
 type(foo) <= str
+type(foo) > str
+type(foo) ?? add
+type(foo) ?? array
+type(foo) contains $env?.Bar?.[add]
 type(foo) matches $env?.String?.[greet]
 type(foo) matches str
 type(foo) not endsWith str
 type(foo) not in $env and false
 type(foo) not in foo and $env
+type(foo) not matches str
 type(foo) not startsWith str
+type(foo) startsWith $env?.[Bar]
 type(foo) | greet()
 type(foo)[:]
 type(foo.Bar)
+type(foo.Bar) matches str
 type(foo.String())
 type(foo.String)
 type(foo?.Bar)
@@ -18727,25 +37487,48 @@ type(greet != greet)
 type(greet == $env)
 type(greet == greet)
 type(greet == nil)
+type(greet ?? $env)
+type(greet ?? 1)
+type(greet ?? 1.0)
+type(greet ?? add)
+type(greet ?? array)
+type(greet ?? f64)
+type(greet ?? false)
+type(greet ?? greet)
+type(greet ?? list)
+type(greet ?? nil)
+type(greet ?? str)
 type(greet(str))
+type(greet(toJSON(false)))
 type(greet)
+type(greet) ?? foo
+type(greet) contains foo.Bar
+type(greet) startsWith str
+type(greet) | greet()
 type(groupBy(array, #))
 type(groupBy(array, 0))
 type(groupBy(array, 1.0))
 type(groupBy(array, false))
 type(groupBy(array, foo))
+type(groupBy(array, ok))
 type(groupBy(list, #))
 type(groupBy(list, .Bar))
+type(groupBy(list, 0))
 type(groupBy(list, 1.0))
 type(groupBy(list, false))
 type(i != $env)
+type(i != 1.0)
 type(i != array?.[i])
+type(i != f64)
 type(i != i)
 type(i != nil)
 type(i * 0)
 type(i * 1)
+type(i * 1.0)
 type(i * f64)
+type(i ** 0)
 type(i ** 1.0)
+type(i ** f64)
 type(i + 0)
 type(i + 1)
 type(i + 1.0)
@@ -18753,9 +37536,12 @@ type(i + f64)
 type(i + i)
 type(i - 0)
 type(i - 1)
+type(i - 1.0)
+type(i - f64)
 type(i .. 0)
 type(i .. i)
 type(i / 1.0)
+type(i < 1.0)
 type(i < i)
 type(i <= 0)
 type(i <= 1)
@@ -18764,21 +37550,47 @@ type(i <= 1.0)
 type(i <= f64)
 type(i <= i)
 type(i == $env)
+type(i == 1)
 type(i == 1.0)
 type(i == nil)
+type(i > 1.0)
 type(i > f64)
+type(i >= 1.0)
 type(i >= f64)
+type(i >= i)
+type(i ?? $env)
+type(i ?? 1.0)
+type(i ?? add)
+type(i ?? false)
+type(i ?? foo)
+type(i ?? list)
+type(i ?? nil)
+type(i ^ 0)
+type(i ^ 1)
 type(i ^ i)
 type(i | bitushr(i))
 type(i)
 type(i) <= str
+type(i) ?? foo
+type(i) ?? greet
+type(i) matches string(ok)
+type(i) not in foo
+type(i) not startsWith str
+type(i) | greet()
 type(i) | splitAfter(str)
+type(if false { $env } else { $env })
+type(if false { f64 } else { 0 })
 type(if false { nil } else { foo })
 type(if false { nil } else { nil })
+type(if false { nil } else { ok })
+type(if false { str } else { add })
 type(if false { true } else { array })
 type(if ok { 1 } else { false })
+type(if ok { array } else { ok })
 type(if ok { foo } else { foo })
 type(if ok { nil } else { str })
+type(if true { i } else { 0 })
+type(int(0))
 type(int(1))
 type(int(1.0))
 type(int(f64))
@@ -18786,66 +37598,109 @@ type(int(i))
 type(keys($env))
 type(last($env))
 type(last($env)?.String)
+type(last($env)?.[i])
 type(last($env?.Bar))
 type(last(array))
+type(last(list))
 type(len($env))
 type(len(array))
 type(len(list))
 type(len(str))
+type(let bar = $env; bar)
+type(let bar = true; bar)
 type(let foobar = 1; foobar)
+type(let y = list; let bar = i; y)
 type(list != $env)
+type(list != array)
+type(list != list)
 type(list != nil)
 type(list == $env)
 type(list == nil)
+type(list ?? $env)
+type(list ?? 0)
+type(list ?? 1.0)
+type(list ?? add)
+type(list ?? foo)
+type(list ?? greet)
+type(list | any(ok))
+type(list | count(true))
+type(list | filter(true))
+type(list | find(false))
+type(list | findLast(ok))
 type(list | groupBy(#))
 type(list | groupBy(0))
+type(list | groupBy(1.0))
 type(list | map(#))
 type(list | map(#index))
 type(list | map(0))
+type(list | map(1.0))
+type(list | map(foo))
 type(list | map(greet))
 type(list | one(false))
 type(list | one(ok))
+type(list | reduce(#))
+type(list | reduce(#, 0))
 type(list | reduce(#, nil))
 type(list | reduce(#.Bar))
+type(list | reduce(#acc))
+type(list | reduce($env))
 type(list | reduce(i))
 type(list | reduce(ok, add))
+type(list | sortBy(#.Bar))
 type(list)
 type(list) == str
 type(list) >= string(0)
+type(list) ?? foo | reduce(foo, 1.0)
+type(list) ?? greet
+type(list) contains toBase64(str)
 type(list) | hasSuffix(str)
 type(list?.[i])
+type(list?.[i].Bar)
 type(list[0:])
+type(list[:i])
+type(lower($env?.[str]))
 type(lower(str))
+type(map($env, #index))
 type(map($env, $env))
 type(map($env, 1))
+type(map($env, 1.0))
 type(map($env, add))
 type(map($env, f64))
 type(map($env, foo))
+type(map($env, greet))
 type(map($env, i))
+type(map(array, # == i))
+type(map(array, #))
 type(map(array, 0))
 type(map(array, 1))
 type(map(array, false))
 type(map(list, #))
 type(map(list, 1.0))
+type(map(list, false))
 type(map(list, foo))
 type(max($env))
 type(max(0))
 type(max(0, array))
+type(max(0, f64))
 type(max(1))
 type(max(1.0))
 type(max(array))
 type(max(f64))
+type(max(i))
 type(mean(0))
 type(mean(1))
 type(mean(1.0))
 type(mean(array))
 type(mean(array, 1.0))
+type(mean(f64))
 type(mean(i))
 type(median($env.i))
 type(median(0))
 type(median(0, 1))
 type(median(1.0))
 type(median(array))
+type(median(f64))
+type(median(f64, 1.0))
 type(median(i))
 type(median(min(f64)))
 type(min($env))
@@ -18854,6 +37709,7 @@ type(min(1))
 type(min(1.0))
 type(min(array))
 type(min(f64))
+type(min(f64, 1.0))
 type(min(i))
 type(nil != $env)
 type(nil != 0)
@@ -18877,68 +37733,143 @@ type(nil == array)
 type(nil == f64)
 type(nil == false)
 type(nil == foo)
+type(nil == greet)
+type(nil == i)
 type(nil == list)
 type(nil == nil)
 type(nil == ok)
+type(nil == str)
+type(nil ?? $env)
+type(nil ?? 0)
+type(nil ?? 1.0)
+type(nil ?? add)
+type(nil ?? array)
+type(nil ?? foo)
+type(nil ?? i)
+type(nil ?? nil)
+type(nil ?? ok)
+type(nil ?? str)
+type(nil ?? true)
 type(nil in $env)
 type(nil in array)
 type(nil in list)
 type(nil not in $env)
+type(nil not in array)
+type(nil not in list)
+type(nil) < str
 type(nil) <= str
+type(nil) >= str
+type(nil) ?? toJSON($env)
 type(nil) matches str
 type(nil) matches string(foo)
+type(nil) not endsWith str
+type(nil) not in foo
 type(nil) not in {foo: false}
+type(nil) startsWith str
 type(nil) | greet()
 type(nil)[:]
+type(none(array, false))
+type(none(array, ok))
 type(none(list, false))
 type(none(list, ok))
+type(not !false)
+type(not false)
+type(not ok)
+type(not true)
+type(ok != $env)
 type(ok != nil)
+type(ok && true)
 type(ok == $env)
+type(ok == false)
 type(ok == nil)
 type(ok == true)
 type(ok ? 1 : 1.0)
+type(ok ? 1 : foo)
 type(ok ? list : foo)
 type(ok ?: array)
 type(ok ?: greet)
+type(ok ?? 0)
+type(ok ?? 1)
+type(ok ?? 1.0)
+type(ok ?? add)
+type(ok ?? f64)
+type(ok ?? foo)
+type(ok ?? i)
+type(ok ?? list)
+type(ok ?? ok)
+type(ok ?? str)
+type(ok ?? true)
 type(ok and $env)
+type(ok and false)
+type(ok and ok)
+type(ok and true)
 type(ok or $env)
 type(ok or false)
 type(ok or true)
+type(ok || $env)
 type(ok || false)
 type(ok || ok)
 type(ok || true)
 type(ok)
+type(ok) <= str
+type(ok) ?? array
+type(ok) ?? f64
+type(ok) ?? foo
 type(ok) contains str
+type(ok) in foo
 type(ok) in {foo: true}
 type(ok) | greet()
 type(one($env, false))
 type(one($env, true))
 type(reduce(array, #))
 type(reduce(array, $env))
+type(reduce(array, 0))
 type(reduce(array, add))
+type(reduce(array, array))
 type(reduce(array, f64))
 type(reduce(array, foo))
+type(reduce(array, greet, false))
 type(reduce(array, ok))
 type(reduce(list, #))
 type(reduce(list, #.String))
 type(reduce(list, #index))
+type(reduce(list, $env))
 type(reduce(list, 0))
 type(reduce(list, add))
+type(reduce(list, false))
+type(reduce(list, ok))
+type(reverse([ok]))
 type(reverse(array))
 type(reverse(list))
 type(round(0))
 type(round(1))
 type(round(1.0))
 type(round(f64))
+type(round(i))
 type(sort($env))
+type(sort(array))
 type(sortBy(array, #))
 type(sortBy(array, 0))
 type(sortBy(array, 1.0))
+type(sortBy(list, 0))
 type(sortBy(list, i))
+type(str != $env)
+type(str != str)
 type(str <= str)
 type(str == $env)
+type(str == str)
 type(str > str)
 type(str >= str)
+type(str ?? $env)
+type(str ?? 1.0)
+type(str ?? f64)
+type(str ?? foo)
+type(str ?? i)
+type(str ?? list)
+type(str ?? nil)
+type(str ?? ok)
+type(str ?? str)
+type(str contains str)
 type(str in $env)
 type(str in foo)
 type(str not in $env)
@@ -18947,7 +37878,13 @@ type(str)
 type(str) <= trim(str)
 type(str) == str
 type(str) >= str
+type(str) ?? -f64
+type(str) ?? foo
 type(str) contains $env?.String
+type(str) matches str
+type(str) not endsWith str
+type(str) not in list?.[i]
+type(str)[:]
 type(str[:])
 type(str[i:])
 type(string($env))
@@ -18963,11 +37900,16 @@ type(string(foo))
 type(string(greet))
 type(string(list))
 type(string(map($env, 1)))
+type(string(nil))
+type(string(ok))
+type(string(str))
 type(string(true))
+type(sum($env, f64))
 type(sum(array))
 type(sum(array, #))
 type(sum(array, 1))
 type(sum(list, 1.0))
+type(toBase64(str))
 type(toJSON(0))
 type(toJSON(1))
 type(toJSON(1.0))
@@ -18983,20 +37925,42 @@ type(toJSON(ok))
 type(toJSON(str))
 type(toJSON(true))
 type(toPairs($env))
+type(trim(str))
 type(trimPrefix(str))
 type(trimSuffix(str))
+type(true != $env)
 type(true != nil)
+type(true != ok)
 type(true && $env)
+type(true && ok)
+type(true && true)
+type(true == $env)
 type(true == false)
 type(true == ok)
+type(true == true)
 type(true ? $env : add)
+type(true ? foo : 1)
+type(true ? greet : 1.0)
+type(true ?: 1)
+type(true ?? 0)
+type(true ?? 1)
+type(true ?? 1.0)
+type(true ?? array)
+type(true ?? foo)
+type(true and false)
+type(true or $env)
 type(true or false)
 type(true or ok)
+type(true || $env)
 type(true || false)
 type(true || true)
+type(true) < foo?.String()
 type(true) <= str
+type(true) in foo
+type(true) not in [add, false]
 type(true) | greet()
 type(type($env))
+type(type($env.foo))
 type(type(0))
 type(type(1))
 type(type(1.0))
@@ -19008,6 +37972,8 @@ type(type(foo))
 type(type(greet))
 type(type(i))
 type(type(list))
+type(type(nil))
+type(type(ok))
 type(type(str))
 type(type(true))
 type(uniq(array))
@@ -19015,43 +37981,62 @@ type(uniq(list))
 type(upper(str))
 type(values($env))
 type({foo: $env})
+type({foo: $env}?.ok)
+type({foo: -0})
 type({foo: 0, foo: 1.0})
+type({foo: 0, foo: add})
 type({foo: 0, foo: false})
 type({foo: 0, foo: foo})
 type({foo: 0, foo: i})
 type({foo: 0})
 type({foo: 0}.greet)
 type({foo: 1, foo: str})
+type({foo: 1.0, foo: $env})
 type({foo: 1.0, foo: greet, foo: ok})
+type({foo: 1.0, foo: greet})
 type({foo: 1.0})
 type({foo: 1})
 type({foo: add})
 type({foo: array, foo: array | reduce(#, i)})
 type({foo: array, foo: foo})
 type({foo: array})
+type({foo: f64, foo: $env})
 type({foo: f64, foo: add})
+type({foo: f64, foo: true})
 type({foo: f64})
+type({foo: false, foo: 1.0})
 type({foo: false, foo: foo})
+type({foo: false, foo: nil})
 type({foo: false})
+type({foo: foo, foo: $env})
 type({foo: foo, foo: 1})
 type({foo: foo, foo: foo})
 type({foo: foo, foo: i})
+type({foo: foo, foo: list})
 type({foo: foo})
+type({foo: foo}.Bar)
+type({foo: greet, foo: i})
+type({foo: greet})
 type({foo: i, foo: ok})
 type({foo: i})
 type({foo: list})
 type({foo: nil})
 type({foo: ok, foo: 0})
 type({foo: ok})
+type({foo: str, foo: str})
 type({foo: str})
+type({foo: toJSON(foo)})
 type({foo: true})
 uniq($env | filter(false))
 uniq($env | map(#index))
 uniq($env | map(0))
 uniq($env | map(1.0))
+uniq($env | map(add))
 uniq($env | map(f64))
+uniq($env | map(foo))
 uniq($env | map(ok))
 uniq($env | map(str))
+uniq($env | reduce(array, foo))
 uniq($env.array)
 uniq($env.list)
 uniq($env?.array)
@@ -19060,9 +38045,16 @@ uniq($env?.list[i:])
 uniq(0 .. 0)
 uniq(0 .. i)
 uniq(1 .. 0)
+uniq([$env, add])
 uniq([$env])
+uniq([0, 1.0])
 uniq([0])
+uniq([1 == nil])
+uniq([1.0, $env, foo])
+uniq([1.0, $env])
+uniq([1.0, array])
 uniq([1.0, ok])
+uniq([1.0, str])
 uniq([1.0])
 uniq([1])
 uniq([add, 1.0])
@@ -19075,82 +38067,150 @@ uniq([false, true])
 uniq([false])
 uniq([foo, foo])
 uniq([foo])
+uniq([greet, $env])
+uniq([greet])
 uniq([i])
 uniq([list])
+uniq([nil, $env])
+uniq([nil, nil])
 uniq([nil])
 uniq([ok])
 uniq([str, 1.0])
 uniq([str, true])
 uniq([str])
+uniq([true, $env])
+uniq([true, true])
 uniq([true])
+uniq(array ?? 0)
+uniq(array ?? 1)
+uniq(array ?? 1.0)
+uniq(array ?? add)
+uniq(array ?? false)
+uniq(array ?? i)
+uniq(array ?? list)
 uniq(array | filter(ok))
 uniq(array | map(#))
+uniq(array | map(1.0))
+uniq(array | sortBy(#))
 uniq(array | sortBy(1))
 uniq(array)
+uniq(array) != array
 uniq(array) == array
+uniq(array) | all(ok)
 uniq(array) | count(false)
+uniq(array) | filter(false)
+uniq(array) | filter(true)
 uniq(array) | groupBy(1)
 uniq(array) | groupBy(1.0)
 uniq(array) | groupBy(ok)
 uniq(array) | map(1)
+uniq(array) | map(add)
 uniq(array) | map(true)
 uniq(array) | min(i)
+uniq(array) | one(false)
+uniq(array) | reduce(#)
 uniq(array) | reduce(1.0)
 uniq(array) | reduce(false)
+uniq(array) | reduce(foo)
 uniq(array) | reduce(greet)
 uniq(array) | reduce(i)
 uniq(array) | sortBy(#)
 uniq(array) | sortBy(1)
+uniq(array) | sum(#)
 uniq(array); str
 uniq(array)?.[i]
+uniq(array)[:]
 uniq(array)[:i]
 uniq(array)[i:]
 uniq(array[1:i])
 uniq(array[:1])
+uniq(array[:])
+uniq(array[:i])
+uniq(concat(array))
 uniq(concat(list))
 uniq(false ? 0 : array)
+uniq(filter(array, ok))
 uniq(filter(array, true))
 uniq(filter(list, false))
 uniq(flatten(array))
+uniq(flatten(list))
 uniq(keys($env))
+uniq(list ?? 1.0)
+uniq(list ?? f64)
+uniq(list ?? false)
+uniq(list ?? foo | map(#))
+uniq(list ?? foo)
+uniq(list ?? str)
+uniq(list ?? true)
+uniq(list | map(#))
+uniq(list | map(.String))
 uniq(list | map(1.0))
 uniq(list | map(add))
+uniq(list | map(false))
+uniq(list | map(foo))
+uniq(list | map(greet))
+uniq(list | reduce(list))
 uniq(list | sortBy(#.Bar))
 uniq(list | sortBy(1.0))
 uniq(list)
 uniq(list) != array
+uniq(list) ?? ok
 uniq(list) | all(false)
 uniq(list) | all(true)
+uniq(list) | find(false)
 uniq(list) | findIndex(false)
+uniq(list) | findLast(false)
+uniq(list) | groupBy(#)
+uniq(list) | groupBy(1.0)
+uniq(list) | groupBy(i)
 uniq(list) | groupBy(ok)
 uniq(list) | map(#)
 uniq(list) | map(.String)
+uniq(list) | map(false)
 uniq(list) | map(greet)
+uniq(list) | one(true)
+uniq(list) | reduce(#.String)
+uniq(list) | reduce(foo, foo)
 uniq(list) | reduce(ok)
 uniq(list) | reduce(true, 1.0)
 uniq(list) | sortBy(0)
+uniq(list) | sortBy(1)
+uniq(list) | sum(0)
 uniq(list)?.[i]
 uniq(list)[$env.i:]
+uniq(list[1:])
+uniq(list[:i])
 uniq(list[i:])
+uniq(map($env, 1.0))
 uniq(map($env, array))
+uniq(map($env, foo))
+uniq(map($env, i))
 uniq(map($env, list))
 uniq(map($env, ok))
 uniq(map($env, str))
 uniq(map($env, true))
 uniq(map(array, #))
 uniq(map(array, 1.0))
+uniq(map(array, array))
 uniq(map(array, greet))
+uniq(map(array, i))
 uniq(map(array, ok))
 uniq(map(list, #))
+uniq(map(list, f64))
+uniq(map(list, ok))
+uniq(reduce(array, array))
 uniq(reverse(array))
 uniq(reverse(list))
 uniq(sort($env))
 uniq(sort(array))
 uniq(sortBy(array, #))
 uniq(sortBy(array, 0))
+uniq(sortBy(list, #.Bar))
+uniq(sortBy(list, 1))
 uniq(sortBy(list, 1.0))
 uniq(toPairs($env))
 uniq(uniq(array))
+uniq(uniq(list))
 uniq(values($env))
 upper($env | reduce(str, nil))
 upper($env.str)
@@ -19158,27 +38218,45 @@ upper($env?.[str])
 upper($env?.str)
 upper(array | reduce(str, list))
 upper(foo.Bar)
+upper(foo.Bar) > str
+upper(foo.Bar) ?? add
 upper(foo.String())
 upper(foo?.Bar)
 upper(foo?.String())
 upper(greet(str))
 upper(list | reduce(#.Bar))
+upper(list?.[i]?.Bar)
 upper(lower(str))
+upper(nil ?? $env?.str)
+upper(reduce(array, str))
+upper(str ?? 0)
+upper(str ?? 1.0)
+upper(str ?? array)
+upper(str ?? greet)
+upper(str ?? list)
+upper(str | greet())
 upper(str)
+upper(str) <= string($env)
+upper(str) ?? add
 upper(str) in foo
 upper(str) matches str
+upper(str) not contains str
 upper(str) not endsWith str
 upper(str) not in foo
+upper(str) | greet()
 upper(str[1:])
 upper(str[:0])
+upper(str[i:])
 upper(string($env))
 upper(string(0))
 upper(string(1))
+upper(string(1.0))
 upper(string(add))
 upper(string(array))
 upper(string(f64))
 upper(string(foo))
 upper(string(foo.Bar))
+upper(string(greet))
 upper(string(i))
 upper(string(list))
 upper(string(nil))
@@ -19186,6 +38264,8 @@ upper(string(ok))
 upper(string(str))
 upper(string(true))
 upper(toBase64(str))
+upper(toJSON(0))
+upper(toJSON(1))
 upper(toJSON(1.0))
 upper(toJSON(array))
 upper(toJSON(f64))
@@ -19195,10 +38275,13 @@ upper(toJSON(i))
 upper(toJSON(list))
 upper(toJSON(nil))
 upper(toJSON(ok))
+upper(toJSON(reduce(list, ok)))
 upper(toJSON(str))
 upper(toJSON(true))
 upper(trim(str))
 upper(trimPrefix(str))
+upper(trimSuffix(str))
+upper(type($env))
 upper(type(0))
 upper(type(1))
 upper(type(1.0))
@@ -19207,44 +38290,78 @@ upper(type(array))
 upper(type(f64))
 upper(type(false))
 upper(type(foo))
+upper(type(foo?.Bar))
 upper(type(greet))
+upper(type(i))
 upper(type(list))
 upper(type(nil))
 upper(type(ok))
 upper(type(str))
 upper(type(true))
 upper(upper(str))
+values($env ?? $env)
+values($env ?? 0)
+values($env ?? 1)
+values($env ?? 1.0)
+values($env ?? false)
+values($env ?? foo)
+values($env ?? greet)
+values($env ?? ok)
+values($env ?? true)
+values($env | reduce($env, 1))
+values($env) ?? add
+values($env) ?? foo
+values($env) ?? i
+values($env) | all(ok)
+values($env) | find(false)
+values($env) | findIndex(ok)
 values($env) | findIndex(true)
 values($env) | findLast(ok)
 values($env) | findLastIndex(ok)
+values($env) | groupBy(1)
 values($env) | groupBy(f64)
 values($env) | groupBy(foo)
 values($env) | groupBy(str)
+values($env) | map(#)
+values($env) | map(1.0)
 values($env) | map(add)
 values($env) | map(f64)
+values($env) | map(foo)
 values($env) | map(greet)
 values($env) | one(true)
 values($env) | reduce(#)
 values($env) | reduce(#index)
 values($env) | reduce(1)
+values($env) | reduce(1.0, 0)
 values($env) | reduce(add, nil)
 values($env) | reduce(array)
 values($env) | reduce(foo, nil)
 values($env) | reduce(i)
 values($env) | sortBy(i)
 values($env) | sum(1)
+values($env) | sum(1.0)
 values($env)?.[i]
 values(array | groupBy(#))
 values(array | groupBy(0))
 values(array | groupBy(1))
 values(array | groupBy(false))
+values(false ? add : $env)
 values(groupBy(array, 0))
+values(groupBy(array, 1.0))
 values(groupBy(array, foo))
+values(groupBy(array, ok))
+values(groupBy(list, #))
+values(groupBy(list, 1.0))
+values(groupBy(list, f64))
+values(groupBy(list, false))
 values(groupBy(list, ok))
 values(if ok { $env } else { str })
+values(list | groupBy(#))
+values(list | groupBy(.Bar))
 values(list | groupBy(false))
 values(max($env))
 values(min($env))
+values(nil ?? $env)
 values(ok ? $env : nil)
 values(reduce(array, $env))
 values(reduce(list, $env))
@@ -19253,9 +38370,14 @@ values({foo: $env}?.foo)
 values({foo: 0, foo: 0})
 values({foo: 0})
 values({foo: 1, foo: 0})
+values({foo: 1.0 * 0})
+values({foo: 1.0, foo: 1.0})
+values({foo: 1.0, foo: f64})
 values({foo: 1.0})
 values({foo: 1})
+values({foo: add, foo: i})
 values({foo: array, foo: foo})
+values({foo: array, foo: nil, foo: foo})
 values({foo: array})
 values({foo: f64})
 values({foo: false, foo: false})
@@ -19263,10 +38385,14 @@ values({foo: false})
 values({foo: foo, foo: list})
 values({foo: foo})
 values({foo: greet, foo: 0})
+values({foo: greet, foo: 1.0, foo: false})
 values({foo: greet, foo: foo})
 values({foo: greet})
+values({foo: i, foo: true})
 values({foo: i})
+values({foo: last($env)})
 values({foo: list})
+values({foo: nil, foo: list})
 values({foo: nil, foo: ok})
 values({foo: nil})
 values({foo: ok, foo: $env})
@@ -19274,48 +38400,86 @@ values({foo: ok, foo: 1.0})
 values({foo: ok, foo: list})
 values({foo: ok})
 values({foo: str})
+values({foo: true, foo: 1.0})
+values({foo: true, foo: false})
+values({foo: true})
+{foo: !false}
+{foo: !ok, foo: greet}
+{foo: !ok}
+{foo: !true, foo: greet}
+{foo: !true}
 {foo: $env != $env}
+{foo: $env != $env}.f64
 {foo: $env != 0}
 {foo: $env != 1.0}
 {foo: $env != 1}
 {foo: $env != add}
+{foo: $env != array}
 {foo: $env != f64, foo: foo}
+{foo: $env != false}
 {foo: $env != foo}
 {foo: $env != greet}
 {foo: $env != greet}.Bar
+{foo: $env != i}
 {foo: $env != list}
+{foo: $env != nil, foo: array}
 {foo: $env != nil}
 {foo: $env != ok}
 {foo: $env != str}
+{foo: $env && false}
+{foo: $env && true}
 {foo: $env == $env}
 {foo: $env == 0}
 {foo: $env == 0}.array
 {foo: $env == 1.0}
 {foo: $env == 1}
+{foo: $env == 1}?.greet
 {foo: $env == add}
+{foo: $env == array}
+{foo: $env == f64}
 {foo: $env == false}
 {foo: $env == foo}
 {foo: $env == foo}.i
 {foo: $env == greet}
 {foo: $env == i}
+{foo: $env == list}
 {foo: $env == nil}
 {foo: $env == ok}
 {foo: $env == str}
 {foo: $env == true}
+{foo: $env ?? $env}
+{foo: $env ?? 1, foo: list}
+{foo: $env ?? 1.0}
+{foo: $env ?? 1}
+{foo: $env ?? array}
+{foo: $env ?? f64}
+{foo: $env ?? f64}.Bar
+{foo: $env ?? foo}
+{foo: $env ?? greet}
+{foo: $env ?? i}
+{foo: $env ?? list}
+{foo: $env ?? nil}
+{foo: $env ?? str}
 {foo: $env and false}
 {foo: $env and true}
 {foo: $env in array}
 {foo: $env in list}
+{foo: $env not in list}
 {foo: $env or false}
 {foo: $env or true}
+{foo: $env | all(ok)}
 {foo: $env | any(ok)}
 {foo: $env | any(true)}
+{foo: $env | find(false)}
 {foo: $env | map(#index)}
 {foo: $env | map($env)}
 {foo: $env | map(0)}
+{foo: $env | map(1)}
 {foo: $env | map(add), foo: i}
+{foo: $env | map(add)}
 {foo: $env | map(f64)}
 {foo: $env | map(foo)}
+{foo: $env | map(i)}
 {foo: $env | map(list)}
 {foo: $env | none(false)}
 {foo: $env | none(true)}
@@ -19323,195 +38487,346 @@ values({foo: str})
 {foo: $env | reduce($env, foo)}?.f64
 {foo: $env | reduce(1, $env)}
 {foo: $env | reduce(foo, 1.0)}
+{foo: $env | reduce(greet, i)}
 {foo: $env | sum(0)}
 {foo: $env | sum(1.0)}
+{foo: $env || false}
 {foo: $env || true}
 {foo: $env, foo: $env, foo: true}?.add
 {foo: $env, foo: $env}.Bar
+{foo: $env, foo: $env}.String
 {foo: $env, foo: $env}.add
+{foo: $env, foo: $env}.array
 {foo: $env, foo: $env}.f64
+{foo: $env, foo: $env}.foo
 {foo: $env, foo: $env}.greet
+{foo: $env, foo: $env}.i
 {foo: $env, foo: $env}.i?.[ok]
+{foo: $env, foo: $env}.ok
+{foo: $env, foo: $env}.str
 {foo: $env, foo: $env}?.String
+{foo: $env, foo: $env}?.[str]
+{foo: $env, foo: $env}?.add
 {foo: $env, foo: $env}?.array
+{foo: $env, foo: $env}?.f64
+{foo: $env, foo: $env}?.foo
 {foo: $env, foo: $env}?.foobar
+{foo: $env, foo: $env}?.greet
+{foo: $env, foo: $env}?.i
+{foo: $env, foo: $env}?.list
 {foo: $env, foo: $env}?.ok
+{foo: $env, foo: $env}?.str
 {foo: $env, foo: 0}.Bar
 {foo: $env, foo: 0}.add
+{foo: $env, foo: 0}.foo
 {foo: $env, foo: 0}.greet
+{foo: $env, foo: 0}.list
 {foo: $env, foo: 0}.ok
 {foo: $env, foo: 0}?.Bar
 {foo: $env, foo: 0}?.false?.ok
+{foo: $env, foo: 0}?.i
 {foo: $env, foo: 0}?.list
+{foo: $env, foo: 1, foo: foo}?.foo
 {foo: $env, foo: 1.0, foo: foo}.ok
+{foo: $env, foo: 1.0, foo: greet}.str
+{foo: $env, foo: 1.0}.Bar
 {foo: $env, foo: 1.0}.String
 {foo: $env, foo: 1.0}.add
+{foo: $env, foo: 1.0}.f64
+{foo: $env, foo: 1.0}.foo
 {foo: $env, foo: 1.0}.greet
+{foo: $env, foo: 1.0}.i
 {foo: $env, foo: 1.0}.list
+{foo: $env, foo: 1.0}.ok
+{foo: $env, foo: 1.0}.str
+{foo: $env, foo: 1.0}?.Bar
 {foo: $env, foo: 1.0}?.array
 {foo: $env, foo: 1.0}?.foo
+{foo: $env, foo: 1.0}?.greet
 {foo: $env, foo: 1.0}?.i
 {foo: $env, foo: 1.0}?.ok
 {foo: $env, foo: 1.0}?.str
+{foo: $env, foo: 1}.Bar
 {foo: $env, foo: 1}.String
+{foo: $env, foo: 1}.add
 {foo: $env, foo: 1}.f64
+{foo: $env, foo: 1}.foo
+{foo: $env, foo: 1}.list
 {foo: $env, foo: 1}.ok
+{foo: $env, foo: 1}?.String
 {foo: $env, foo: 1}?.[str]
+{foo: $env, foo: 1}?.array
 {foo: $env, foo: 1}?.f64
 {foo: $env, foo: 1}?.greet
 {foo: $env, foo: 1}?.i
+{foo: $env, foo: add, foo: $env}?.foo
+{foo: $env, foo: add}.Bar
 {foo: $env, foo: add}.foo?.list
 {foo: $env, foo: add}.i
 {foo: $env, foo: add}.list
 {foo: $env, foo: add}.str
+{foo: $env, foo: add}.str?.array
+{foo: $env, foo: add}?.Bar
 {foo: $env, foo: add}?.add
 {foo: $env, foo: add}?.foo
+{foo: $env, foo: add}?.list
 {foo: $env, foo: add}?.ok
 {foo: $env, foo: array}.array
 {foo: $env, foo: array}.foo
 {foo: $env, foo: array}.greet
 {foo: $env, foo: array}.i
 {foo: $env, foo: array}.list
+{foo: $env, foo: array}?.Bar
+{foo: $env, foo: array}?.array
 {foo: $env, foo: array}?.f64
 {foo: $env, foo: array}?.foo
 {foo: $env, foo: array}?.greet
 {foo: $env, foo: array}?.str
 {foo: $env, foo: f64}.String
 {foo: $env, foo: f64}.String?.array
+{foo: $env, foo: f64}.add
+{foo: $env, foo: f64}.f64
 {foo: $env, foo: f64}?.foo
 {foo: $env, foo: f64}?.i
 {foo: $env, foo: false, foo: foo}?.str
+{foo: $env, foo: false, foo: str}.array
 {foo: $env, foo: false}.add
 {foo: $env, foo: false}.array
+{foo: $env, foo: false}.i
+{foo: $env, foo: false}.list
 {foo: $env, foo: false}.str
 {foo: $env, foo: false}?.[str]
 {foo: $env, foo: false}?.array
+{foo: $env, foo: false}?.greet
+{foo: $env, foo: false}?.i
 {foo: $env, foo: foo, foo: $env}?.greet
+{foo: $env, foo: foo, foo: foo}?.i
 {foo: $env, foo: foo, foo: list}.String
+{foo: $env, foo: foo, foo: nil}.ok
+{foo: $env, foo: foo, foo: ok}?.ok
 {foo: $env, foo: foo}.String
 {foo: $env, foo: foo}.array
+{foo: $env, foo: foo}.foo
 {foo: $env, foo: foo}.foobar
 {foo: $env, foo: foo}.greet
 {foo: $env, foo: foo}.i
 {foo: $env, foo: foo}.list
+{foo: $env, foo: foo}.ok
 {foo: $env, foo: foo}.str
 {foo: $env, foo: foo}?.Bar
 {foo: $env, foo: foo}?.String
+{foo: $env, foo: foo}?.add
 {foo: $env, foo: foo}?.array
+{foo: $env, foo: foo}?.greet
+{foo: $env, foo: foo}?.i?.[array]
+{foo: $env, foo: foo}?.list
 {foo: $env, foo: foo}?.ok
+{foo: $env, foo: foo}?.str
 {foo: $env, foo: greet, foo: 0}.greet
+{foo: $env, foo: greet, foo: foo}.f64
+{foo: $env, foo: greet, foo: nil}?.foo
+{foo: $env, foo: greet}.Bar?.[list]?.greet
 {foo: $env, foo: greet}.add
+{foo: $env, foo: greet}.f64
 {foo: $env, foo: greet}.foo
+{foo: $env, foo: greet}.i
+{foo: $env, foo: greet}.str
 {foo: $env, foo: greet}?.Bar
+{foo: $env, foo: greet}?.[str]
 {foo: $env, foo: greet}?.add
 {foo: $env, foo: greet}?.f64
+{foo: $env, foo: greet}?.greet
+{foo: $env, foo: greet}?.list
+{foo: $env, foo: i, foo: nil}.greet
 {foo: $env, foo: i}.greet
+{foo: $env, foo: i}?.Bar
+{foo: $env, foo: i}?.String
 {foo: $env, foo: i}?.add
 {foo: $env, foo: i}?.foo
 {foo: $env, foo: list, foo: 1}?.[str]
 {foo: $env, foo: list}.Bar
 {foo: $env, foo: list}.array
 {foo: $env, foo: list}.greet
+{foo: $env, foo: list}.ok
 {foo: $env, foo: list}?.Bar?.greet
 {foo: $env, foo: list}?.[str]
+{foo: $env, foo: list}?.add
+{foo: $env, foo: list}?.array
+{foo: $env, foo: list}?.greet
 {foo: $env, foo: list}?.list
+{foo: $env, foo: list}?.str
 {foo: $env, foo: nil}.Bar
+{foo: $env, foo: nil}.String
+{foo: $env, foo: nil}.array
 {foo: $env, foo: nil}.foo
 {foo: $env, foo: nil}.foobar?.i
 {foo: $env, foo: nil}.greet
+{foo: $env, foo: nil}.ok
+{foo: $env, foo: nil}.ok?.ok(ok)
 {foo: $env, foo: nil}.str
+{foo: $env, foo: nil}?.[str]
 {foo: $env, foo: nil}?.add
+{foo: $env, foo: nil}?.array
 {foo: $env, foo: nil}?.f64
 {foo: $env, foo: nil}?.foobar
 {foo: $env, foo: nil}?.list
+{foo: $env, foo: nil}?.ok
 {foo: $env, foo: nil}?.str
+{foo: $env, foo: ok}.Bar
+{foo: $env, foo: ok}.String
 {foo: $env, foo: ok}.array
 {foo: $env, foo: ok}.f64
+{foo: $env, foo: ok}.i
+{foo: $env, foo: ok}?.greet
 {foo: $env, foo: str, foo: f64}?.i
+{foo: $env, foo: str, foo: nil}?.array
 {foo: $env, foo: str}.array
+{foo: $env, foo: str}.f64
+{foo: $env, foo: str}.ok
 {foo: $env, foo: str}?.Bar
+{foo: $env, foo: str}?.[str]
+{foo: $env, foo: str}?.f64
+{foo: $env, foo: str}?.foo
 {foo: $env, foo: str}?.greet
+{foo: $env, foo: str}?.ok
 {foo: $env, foo: true, foo: 1.0}?.list
+{foo: $env, foo: true, foo: nil}?.greet
+{foo: $env, foo: true}.Bar
+{foo: $env, foo: true}.String?.list
+{foo: $env, foo: true}.array
+{foo: $env, foo: true}.foo
 {foo: $env, foo: true}.foobar
 {foo: $env, foo: true}.list
+{foo: $env, foo: true}.ok
 {foo: $env, foo: true}.str?.list
+{foo: $env, foo: true}?.String
 {foo: $env, foo: true}?.[str]
+{foo: $env, foo: true}?.array
 {foo: $env, foo: true}?.greet
 {foo: $env, foo: true}?.ok
 {foo: $env.add, foo: $env.ok}
 {foo: $env.add}
 {foo: $env.add}.String
 {foo: $env.add}.array
+{foo: $env.add}?.[str]
+{foo: $env.add}?.f64
+{foo: $env.array, foo: $env != i}?.str
 {foo: $env.array, foo: add}
+{foo: $env.array, foo: greet}
 {foo: $env.array, foo: {foo: array}}
 {foo: $env.array}
+{foo: $env.array}.i
+{foo: $env.f64, foo: array}
 {foo: $env.f64, foo: str}
 {foo: $env.f64}
+{foo: $env.f64}.foo
 {foo: $env.f64}?.add
 {foo: $env.f64}?.array
 {foo: $env.foo, foo: f64}?.list
 {foo: $env.foo}
+{foo: $env.foo}.greet
 {foo: $env.foo}?.String
 {foo: $env.greet, foo: array}
 {foo: $env.greet, foo: i}
 {foo: $env.greet}
+{foo: $env.greet}.array
 {foo: $env.i, foo: add}
 {foo: $env.i, foo: array}
 {foo: $env.i, foo: ok != $env}
 {foo: $env.i}
+{foo: $env.i}?.str
+{foo: $env.list != list}
 {foo: $env.list, foo: 1.0 == 1.0}
+{foo: $env.list, foo: array}
 {foo: $env.list}
+{foo: $env.list}.foo
 {foo: $env.ok, foo: add}
+{foo: $env.ok, foo: ok}
 {foo: $env.ok}
+{foo: $env.ok}.String
 {foo: $env.ok}?.str
 {foo: $env.str}
 {foo: $env.str}.ok
 {foo: $env?.$env}
+{foo: $env?.Bar, foo: array}
 {foo: $env?.Bar, foo: if false { foo } else { 0 }}
 {foo: $env?.Bar, foo: ok}
+{foo: $env?.Bar?.Bar()}
 {foo: $env?.Bar?.Bar}
 {foo: $env?.Bar?.[greet]}
+{foo: $env?.Bar?.greet()}
 {foo: $env?.Bar?.list}
 {foo: $env?.Bar}
 {foo: $env?.Bar}.Bar
+{foo: $env?.Bar}.String
+{foo: $env?.Bar}.list
 {foo: $env?.Bar}?.list
+{foo: $env?.Bar}?.ok
+{foo: $env?.Bar}?.str
+{foo: $env?.String, foo: ok}
+{foo: $env?.String, foo: str}
 {foo: $env?.String}
+{foo: $env?.String}?.ok
+{foo: $env?.[Bar], foo: f64}
 {foo: $env?.[Bar], foo: i}
+{foo: $env?.[Bar], foo: list}
 {foo: $env?.[Bar], foo: str}
 {foo: $env?.[Bar]?.Bar}
 {foo: $env?.[Bar]?.[add]}
 {foo: $env?.[Bar]}
 {foo: $env?.[Bar]}?.greet
 {foo: $env?.[Bar]}?.ok
+{foo: $env?.[String], foo: $env.greet}
 {foo: $env?.[String], foo: ok}
 {foo: $env?.[String]?.array}
 {foo: $env?.[String]}
 {foo: $env?.[String]}.f64
+{foo: $env?.[String]}.greet
 {foo: $env?.[foobar]?.add}
+{foo: $env?.[foobar]?.list}
 {foo: $env?.[foobar]}
+{foo: $env?.[foobar]}?.add
 {foo: $env?.[nil]}
 {foo: $env?.[str]}
+{foo: $env?.[str]}.str
 {foo: $env?.[str]}?.add
 {foo: $env?.add, foo: add}
 {foo: $env?.add}
 {foo: $env?.add}.greet
+{foo: $env?.add}?.array
 {foo: $env?.add}?.foo
+{foo: $env?.add}?.str
 {foo: $env?.array, foo: add}
 {foo: $env?.array}
 {foo: $env?.array}.ok
+{foo: $env?.array}?.Bar
+{foo: $env?.f64, foo: add}
 {foo: $env?.f64}
+{foo: $env?.f64}.ok?.add
+{foo: $env?.f64}.str
 {foo: $env?.f64}?.greet
+{foo: $env?.false}
 {foo: $env?.foo.String()}
 {foo: $env?.foobar, foo: greet}
 {foo: $env?.foobar}
+{foo: $env?.foobar}?.list
 {foo: $env?.foo}
+{foo: $env?.foo}.f64
 {foo: $env?.foo}.str
+{foo: $env?.foo}?.ok
+{foo: $env?.greet, foo: first(array)}
+{foo: $env?.greet, foo: i}
 {foo: $env?.greet}
 {foo: $env?.greet}.foo
 {foo: $env?.greet}?.add
+{foo: $env?.greet}?.foo
+{foo: $env?.i, foo: foo?.Bar}
+{foo: $env?.i, foo: i}
+{foo: $env?.i, foo: ok}
 {foo: $env?.i, foo: string(i)}
 {foo: $env?.i, foo: str}
 {foo: $env?.i}
+{foo: $env?.i}.String
 {foo: $env?.i}?.f64
 {foo: $env?.i}?.greet
 {foo: $env?.list, foo: [1.0]}
@@ -19520,138 +38835,254 @@ values({foo: str})
 {foo: $env?.nil?.[add]}
 {foo: $env?.nil?.[i]}
 {foo: $env?.nil}
+{foo: $env?.ok, foo: greet}
 {foo: $env?.ok}
 {foo: $env?.ok}.f64
+{foo: $env?.ok}?.add
 {foo: $env?.ok}?.foo
 {foo: $env?.ok}?.list
 {foo: $env?.str, foo: $env?.ok}
 {foo: $env?.str, foo: array}
+{foo: $env?.str, foo: f64}
 {foo: $env?.str}
 {foo: $env?.str}.f64
 {foo: $env?.str}?.Bar
+{foo: $env?.str}?.i
+{foo: $env?.true}
 {foo: $env} == nil or false
+{foo: $env} ?? $env.array
+{foo: $env} ?? add
+{foo: $env} ?? list
 {foo: $env}.Bar
 {foo: $env}.Bar?.[str]
 {foo: $env}.Bar?.add
 {foo: $env}.String
+{foo: $env}.String?.foo
 {foo: $env}.add
+{foo: $env}.add?.String
+{foo: $env}.add?.[add]
 {foo: $env}.add?.[array]
 {foo: $env}.add?.[foo]
 {foo: $env}.add?.[ok]
 {foo: $env}.add?.array
 {foo: $env}.add?.list
 {foo: $env}.array
+{foo: $env}.array?.Bar()
 {foo: $env}.array?.i
 {foo: $env}.array?.str
 {foo: $env}.f64
+{foo: $env}.f64?.[foo]
 {foo: $env}.foo
+{foo: $env}.foo.array
+{foo: $env}.foo?.foo
 {foo: $env}.foo?.i
 {foo: $env}.foobar
+{foo: $env}.foobar?.[f64]
+{foo: $env}.foobar?.[list]
 {foo: $env}.greet
 {foo: $env}.greet?.Bar
+{foo: $env}.greet?.[ok]
 {foo: $env}.i
+{foo: $env}.i?.add()
+{foo: $env}.i?.greet()
 {foo: $env}.list
+{foo: $env}.list?.[f64]
 {foo: $env}.list?.greet
 {foo: $env}.ok
+{foo: $env}.ok?.[greet]
 {foo: $env}.ok?.[ok]
+{foo: $env}.ok?.array
 {foo: $env}.str
 {foo: $env}.str?.Bar
+{foo: $env}.str?.[f64]
+{foo: $env}.str?.str
+{foo: $env}?.$env?.Bar(1.0)
+{foo: $env}?.$env?.add()
 {foo: $env}?.Bar
+{foo: $env}?.Bar?.[add]
+{foo: $env}?.Bar?.foo
 {foo: $env}?.Bar?.i
 {foo: $env}?.String
+{foo: $env}?.String != str
 {foo: $env}?.String?.[add]
+{foo: $env}?.String?.[f64]
+{foo: $env}?.String?.list
 {foo: $env}?.String?.str()
+{foo: $env}?.[$env?.Bar]
 {foo: $env}?.[str]
 {foo: $env}?.add
 {foo: $env}?.array
+{foo: $env}?.array?.Bar(1.0)
+{foo: $env}?.array?.[array]
 {foo: $env}?.array?.[greet]
+{foo: $env}?.array?.[ok]
 {foo: $env}?.f64
+{foo: $env}?.f64?.[f64]
 {foo: $env}?.foo
+{foo: $env}?.foo ?? ok
 {foo: $env}?.foo.Bar
+{foo: $env}?.foo.f64
 {foo: $env}?.foo.ok
 {foo: $env}?.foobar
+{foo: $env}?.foobar?.[list]?.[list]
+{foo: $env}?.foobar?.array
 {foo: $env}?.foobar?.greet(nil)
 {foo: $env}?.greet
+{foo: $env}?.greet?.[f64]
+{foo: $env}?.greet?.f64
 {foo: $env}?.greet?.list()
 {foo: $env}?.greet?.ok
 {foo: $env}?.i
 {foo: $env}?.i?.[array]
+{foo: $env}?.i?.add
 {foo: $env}?.list
 {foo: $env}?.list?.[foo]
+{foo: $env}?.list?.f64
 {foo: $env}?.list?.greet?.[i]
+{foo: $env}?.list?.i
 {foo: $env}?.ok
+{foo: $env}?.ok?.[array]?.ok
+{foo: $env}?.ok?.[ok]
 {foo: $env}?.ok?.[str]
 {foo: $env}?.str
 {foo: $env}?.str?.[ok]
 {foo: $env}?.str?.array
 {foo: $env}?.str?.foo
+{foo: -$env?.f64}
+{foo: -0}
+{foo: -1.0 / i}
+{foo: -1.0, foo: $env?.f64}
+{foo: -1.0, foo: i}
+{foo: -1.0}
+{foo: -1}
+{foo: -f64}
+{foo: -i, foo: !ok}
+{foo: -i, foo: add}
+{foo: -i}
+{foo: -i}.list
 {foo: 0 != $env.i}
 {foo: 0 != $env}
 {foo: 0 != 0}
+{foo: 0 != 1.0}
+{foo: 0 != 1}
 {foo: 0 != f64}
+{foo: 0 != i}
 {foo: 0 != nil}
 {foo: 0 % i}
 {foo: 0 * 0}
 {foo: 0 * 1.0}
 {foo: 0 * 1}
 {foo: 0 * i}
+{foo: 0 * i}.add
+{foo: 0 ** 0}
 {foo: 0 ** 1}
+{foo: 0 ** f64}
 {foo: 0 ** i}
+{foo: 0 + 0}
 {foo: 0 + 1.0}
 {foo: 0 + f64}
+{foo: 0 - 0}
+{foo: 0 - 1.0, foo: array}
 {foo: 0 - 1.0}
 {foo: 0 - 1}
 {foo: 0 - f64}
+{foo: 0 - i}
+{foo: 0 .. 0}
 {foo: 0 .. 1}
 {foo: 0 .. i}
 {foo: 0 / 0}
 {foo: 0 / 1.0}
+{foo: 0 < $env.i}
 {foo: 0 < 0, foo: i}
+{foo: 0 < 0}
 {foo: 0 < 1.0}
+{foo: 0 < 1.0}?.f64
 {foo: 0 < 1}
 {foo: 0 < f64}
 {foo: 0 <= 0}
 {foo: 0 <= 1.0}
+{foo: 0 <= f64}
 {foo: 0 == 0}
 {foo: 0 == 1.0}
+{foo: 0 == f64}
 {foo: 0 == i}
 {foo: 0 == nil}
+{foo: 0 > 0, foo: ok}
 {foo: 0 > 1.0}
 {foo: 0 > 1}
+{foo: 0 > i}
+{foo: 0 >= 0}
 {foo: 0 >= 1}
+{foo: 0 >= i}
+{foo: 0 ?? $env?.[ok]}
+{foo: 0 ?? $env}
+{foo: 0 ?? array}
+{foo: 0 ?? foo}
+{foo: 0 ?? i}
+{foo: 0 ?? str}
+{foo: 0 ?? true}
 {foo: 0 ^ 0}
 {foo: 0 ^ 1.0}
 {foo: 0 ^ i}
 {foo: 0 in array}
+{foo: 0 | add(i)}
 {foo: 0 | bitshl(i)}
 {foo: 0, foo: $env, foo: 1.0}?.greet
 {foo: 0, foo: $env}.String
 {foo: 0, foo: $env}.foo
+{foo: 0, foo: $env}.i
 {foo: 0, foo: $env}.list
 {foo: 0, foo: $env}.str
+{foo: 0, foo: $env}?.String
+{foo: 0, foo: $env}?.[str]
 {foo: 0, foo: $env}?.add
 {foo: 0, foo: $env}?.array
+{foo: 0, foo: $env}?.f64
+{foo: 0, foo: $env}?.greet
+{foo: 0, foo: $env}?.ok
+{foo: 0, foo: $env}?.str
 {foo: 0, foo: 0, foo: false}?.list
 {foo: 0, foo: 0}.String
 {foo: 0, foo: 0}.add
+{foo: 0, foo: 0}.array
+{foo: 0, foo: 0}.foobar
 {foo: 0, foo: 0}?.f64
 {foo: 0, foo: 0}?.ok
+{foo: 0, foo: 1, foo: 0} ?? i
+{foo: 0, foo: 1.0, foo: array}?.i
+{foo: 0, foo: 1.0, foo: ok}.str
+{foo: 0, foo: 1.0} ?? ok
 {foo: 0, foo: 1.0}.Bar
 {foo: 0, foo: 1.0}.array
 {foo: 0, foo: 1.0}.ok
+{foo: 0, foo: 1.0}.str
+{foo: 0, foo: 1.0}?.[str]
 {foo: 0, foo: 1.0}?.f64
+{foo: 0, foo: 1.0}?.foo
 {foo: 0, foo: 1.0}?.i
+{foo: 0, foo: 1.0}?.list
+{foo: 0, foo: 1.0}?.str
+{foo: 0, foo: 1.0}?.str?.max(foo)?.ok
 {foo: 0, foo: 1}.Bar
+{foo: 0, foo: 1}.add
 {foo: 0, foo: 1}.array
+{foo: 0, foo: 1}.foo
 {foo: 0, foo: 1}.greet
+{foo: 0, foo: 1}?.add
+{foo: 0, foo: 1}?.i
 {foo: 0, foo: 1}?.ok
+{foo: 0, foo: add}.String?.[greet]
 {foo: 0, foo: add}.array
 {foo: 0, foo: add}?.[str]
 {foo: 0, foo: add}?.foobar
 {foo: 0, foo: add}?.greet
 {foo: 0, foo: array}.Bar
 {foo: 0, foo: array}.array
+{foo: 0, foo: array}.f64
+{foo: 0, foo: array}.greet
+{foo: 0, foo: array}.list
 {foo: 0, foo: array}?.foo
+{foo: 0, foo: array}?.i
 {foo: 0, foo: array}?.not
 {foo: 0, foo: f64}.foo
 {foo: 0, foo: f64}.greet
@@ -19659,61 +39090,113 @@ values({foo: str})
 {foo: 0, foo: false, foo: 1}.add
 {foo: 0, foo: false}?.f64
 {foo: 0, foo: false}?.foo
+{foo: 0, foo: false}?.list
+{foo: 0, foo: false}?.list?.foo
+{foo: 0, foo: foo, foo: 1}?.String
 {foo: 0, foo: foo, foo: add}.array
 {foo: 0, foo: foo, foo: false}?.greet
 {foo: 0, foo: foo}.Bar
+{foo: 0, foo: foo}.String
+{foo: 0, foo: foo}.add
+{foo: 0, foo: foo}.foo
 {foo: 0, foo: foo}.foobar
+{foo: 0, foo: foo}.greet?.add
+{foo: 0, foo: foo}.i
+{foo: 0, foo: foo}.str
+{foo: 0, foo: foo}?.add
 {foo: 0, foo: foo}?.array
 {foo: 0, foo: foo}?.f64
+{foo: 0, foo: foo}?.foo
 {foo: 0, foo: foo}?.ok
+{foo: 0, foo: greet, foo: i}?.array
 {foo: 0, foo: greet}.f64
+{foo: 0, foo: greet}.foobar
 {foo: 0, foo: greet}.greet
 {foo: 0, foo: greet}.ok
 {foo: 0, foo: greet}?.add
+{foo: 0, foo: greet}?.greet
 {foo: 0, foo: greet}?.str
 {foo: 0, foo: i}.add
 {foo: 0, foo: i}.array
 {foo: 0, foo: i}.f64
+{foo: 0, foo: i}?.foobar
+{foo: 0, foo: i}?.str
+{foo: 0, foo: list}?.Bar
 {foo: 0, foo: list}?.[str]
+{foo: 0, foo: list}?.greet
+{foo: 0, foo: nil, foo: foo}?.add
 {foo: 0, foo: nil}.Bar
 {foo: 0, foo: nil}.String?.i()
 {foo: 0, foo: nil}.array
 {foo: 0, foo: nil}.greet
+{foo: 0, foo: nil}.list
 {foo: 0, foo: nil}.ok
+{foo: 0, foo: nil}?.Bar
+{foo: 0, foo: nil}?.String
+{foo: 0, foo: ok}.add
+{foo: 0, foo: ok}.array
 {foo: 0, foo: ok}.f64
 {foo: 0, foo: ok}.ok
+{foo: 0, foo: ok}.str
+{foo: 0, foo: ok}?.[str]
+{foo: 0, foo: ok}?.add
+{foo: 0, foo: ok}?.foo
+{foo: 0, foo: ok}?.ok
+{foo: 0, foo: str, foo: f64}.Bar
 {foo: 0, foo: str}.Bar
+{foo: 0, foo: str}?.f64
 {foo: 0, foo: str}?.foo
 {foo: 0, foo: str}?.greet
+{foo: 0, foo: str}?.i
 {foo: 0, foo: str}?.ok
+{foo: 0, foo: true, foo: i}.list
+{foo: 0, foo: true}?.ok
+{foo: 0, foo: true}?.str
 {foo: 0..i}
+{foo: 0.0}
+{foo: 0.1}
+{foo: 0} ?? array
+{foo: 0} ?? list
+{foo: 0} ?? sum(array)
 {foo: 0}.Bar
 {foo: 0}.String
 {foo: 0}.String?.[f64]
+{foo: 0}.String?.[i]
 {foo: 0}.String?.ok()
 {foo: 0}.add
 {foo: 0}.array
+{foo: 0}.array?.ok
 {foo: 0}.f64
 {foo: 0}.foo
 {foo: 0}.greet
+{foo: 0}.greet?.String
 {foo: 0}.greet?.[list]
 {foo: 0}.i
+{foo: 0}.i?.foo(nil)
 {foo: 0}.list
+{foo: 0}.list?.[add]
 {foo: 0}.list?.[foo].String
+{foo: 0}.nil?.[add]
 {foo: 0}.ok
 {foo: 0}.ok?.[array]
 {foo: 0}.ok?.f64
 {foo: 0}.ok?.foo?.[i]
 {foo: 0}.str
 {foo: 0}.str?.String
+{foo: 0}.str?.[add]?.[add]
 {foo: 0}?.Bar
+{foo: 0}?.Bar?.foo
 {foo: 0}?.String
 {foo: 0}?.[str]
 {foo: 0}?.add
+{foo: 0}?.add?.ok
 {foo: 0}?.array
+{foo: 0}?.array?.[i]
 {foo: 0}?.f64
 {foo: 0}?.foo
+{foo: 0}?.foobar
 {foo: 0}?.foobar == foo
+{foo: 0}?.foobar?.[array]
 {foo: 0}?.greet
 {foo: 0}?.i
 {foo: 0}?.list
@@ -19723,6 +39206,7 @@ values({foo: str})
 {foo: 0}?.str?.Bar
 {foo: 0}?.str?.str
 {foo: 1 != $env}
+{foo: 1 != 0}
 {foo: 1 != 1.0}
 {foo: 1 != 1}
 {foo: 1 != f64}
@@ -19736,131 +39220,229 @@ values({foo: str})
 {foo: 1 * f64}
 {foo: 1 * i}
 {foo: 1 ** 0}
+{foo: 1 ** 1.0}
 {foo: 1 ** 1.0}.f64
 {foo: 1 ** 1.0}.i
+{foo: 1 ** 1.0}?.[str]
 {foo: 1 ** 1}
+{foo: 1 ** f64}
+{foo: 1 ** i}
 {foo: 1 + 0}
+{foo: 1 + 1.0}
+{foo: 1 + 1}
+{foo: 1 + f64}
 {foo: 1 + i}
+{foo: 1 - 0}
 {foo: 1 - 1.0}
+{foo: 1 - 1}
 {foo: 1 - f64}
 {foo: 1 - i}
+{foo: 1 .. 0}
 {foo: 1 .. i}
+{foo: 1 / 0}?.String
 {foo: 1 / 1.0}
 {foo: 1 / 1}
 {foo: 1 / f64}
+{foo: 1 / i}
 {foo: 1 < 1.0}
 {foo: 1 < 1}
+{foo: 1 < f64}
 {foo: 1 < i}
+{foo: 1 <= 0}
+{foo: 1 <= 1.0}
 {foo: 1 <= 1}
+{foo: 1 <= f64, foo: array}
 {foo: 1 == $env}
 {foo: 1 == 0}
 {foo: 1 == 1.0}
 {foo: 1 == 1}
+{foo: 1 == f64}
 {foo: 1 == nil}
 {foo: 1 > 0}
 {foo: 1 > 1.0}
+{foo: 1 > 1}
 {foo: 1 > i}
+{foo: 1 >= 1.0}
 {foo: 1 >= 1}
 {foo: 1 >= f64}
 {foo: 1 >= i}
+{foo: 1 ?? $env, foo: str}
+{foo: 1 ?? $env}
+{foo: 1 ?? 1}
+{foo: 1 ?? greet}
+{foo: 1 ?? list}
+{foo: 1 ?? nil}
+{foo: 1 ?? ok}
+{foo: 1 ?? str}
 {foo: 1 ^ 0}
 {foo: 1 ^ 1.0}
 {foo: 1 ^ f64}
 {foo: 1 in array}
 {foo: 1 not in $env?.array}
+{foo: 1 | bitand(i)}
 {foo: 1, foo: $env, foo: add}?.ok
+{foo: 1, foo: $env}.Bar
 {foo: 1, foo: $env}.String
 {foo: 1, foo: $env}.array
 {foo: 1, foo: $env}.greet
+{foo: 1, foo: $env}.i
+{foo: 1, foo: $env}.list
 {foo: 1, foo: $env}.str
+{foo: 1, foo: $env}?.f64
 {foo: 1, foo: $env}?.greet
 {foo: 1, foo: $env}?.str
 {foo: 1, foo: 0, foo: add}?.array
+{foo: 1, foo: 0} ?? foo?.Bar
 {foo: 1, foo: 0}.add
+{foo: 1, foo: 0}.f64
 {foo: 1, foo: 0}.foo
+{foo: 1, foo: 0}.greet
 {foo: 1, foo: 0}.list
+{foo: 1, foo: 0}?.list
+{foo: 1, foo: 0}?.ok
 {foo: 1, foo: 1.0}.String
+{foo: 1, foo: 1.0}.f64
+{foo: 1, foo: 1.0}.i
 {foo: 1, foo: 1.0}?.Bar
+{foo: 1, foo: 1.0}?.add
 {foo: 1, foo: 1.0}?.foobar
 {foo: 1, foo: 1.0}?.greet
 {foo: 1, foo: 1.0}?.str?.array()
 {foo: 1, foo: 1}.f64
 {foo: 1, foo: 1}.greet
 {foo: 1, foo: 1}?.f64
+{foo: 1, foo: 1}?.ok
+{foo: 1, foo: add, foo: 1.0}?.Bar
+{foo: 1, foo: add}.Bar
 {foo: 1, foo: add}.array
 {foo: 1, foo: add}.greet
+{foo: 1, foo: add}.i
 {foo: 1, foo: add}?.Bar
+{foo: 1, foo: add}?.i
 {foo: 1, foo: add}?.list
+{foo: 1, foo: array}?.String
+{foo: 1, foo: array}?.add
+{foo: 1, foo: array}?.i
 {foo: 1, foo: array}?.ok
+{foo: 1, foo: f64}.Bar
+{foo: 1, foo: f64}.array
+{foo: 1, foo: f64}.foo
+{foo: 1, foo: f64}.greet
 {foo: 1, foo: f64}?.f64
 {foo: 1, foo: f64}?.i
+{foo: 1, foo: false}.array
 {foo: 1, foo: false}.f64
 {foo: 1, foo: false}.foo
 {foo: 1, foo: false}.foobar?.foo()
 {foo: 1, foo: false}?.add
+{foo: 1, foo: false}?.f64
+{foo: 1, foo: false}?.f64?.[f64]
 {foo: 1, foo: false}?.ok
 {foo: 1, foo: foo, foo: $env}?.[str]
+{foo: 1, foo: foo, foo: 1.0}.list
+{foo: 1, foo: foo, foo: nil}.foo
 {foo: 1, foo: foo}.Bar
 {foo: 1, foo: foo}.f64
 {foo: 1, foo: foo}.foo
 {foo: 1, foo: foo}?.[str]
+{foo: 1, foo: foo}?.[str]?.greet
+{foo: 1, foo: foo}?.f64
 {foo: 1, foo: foo}?.foo
 {foo: 1, foo: foo}?.foobar
 {foo: 1, foo: foo}?.greet
 {foo: 1, foo: foo}?.list
+{foo: 1, foo: greet, foo: 0}?.add
+{foo: 1, foo: greet, foo: i}.foobar
+{foo: 1, foo: greet, foo: list}?.ok
 {foo: 1, foo: greet}.String
 {foo: 1, foo: greet}.greet
 {foo: 1, foo: greet}.i
 {foo: 1, foo: greet}.ok?.String
+{foo: 1, foo: greet}?.[str]
+{foo: 1, foo: greet}?.add
+{foo: 1, foo: greet}?.array
 {foo: 1, foo: greet}?.greet
 {foo: 1, foo: i, foo: list}?.[str]
+{foo: 1, foo: i}.String
+{foo: 1, foo: i}?.greet
+{foo: 1, foo: list} ?? i
 {foo: 1, foo: list}.f64
+{foo: 1, foo: list}.foo
+{foo: 1, foo: list}.list
+{foo: 1, foo: list}.str
 {foo: 1, foo: list}?.Bar
+{foo: 1, foo: list}?.String
+{foo: 1, foo: list}?.[str]
 {foo: 1, foo: list}?.add
+{foo: 1, foo: list}?.ok
+{foo: 1, foo: nil, foo: 1}.add
 {foo: 1, foo: nil, foo: greet}.foo
+{foo: 1, foo: nil}.add
 {foo: 1, foo: nil}.i
+{foo: 1, foo: nil}.list
 {foo: 1, foo: nil}.ok
 {foo: 1, foo: nil}?.Bar
 {foo: 1, foo: nil}?.String
+{foo: 1, foo: nil}?.[str]
 {foo: 1, foo: nil}?.add
+{foo: 1, foo: nil}?.f64
 {foo: 1, foo: nil}?.list
 {foo: 1, foo: nil}?.str
 {foo: 1, foo: ok}.foo
 {foo: 1, foo: ok}.list
+{foo: 1, foo: ok}?.Bar
 {foo: 1, foo: ok}?.String
 {foo: 1, foo: ok}?.[str]
+{foo: 1, foo: ok}?.array
+{foo: 1, foo: ok}?.ok
 {foo: 1, foo: ok}?.str
 {foo: 1, foo: str, foo: 0}.i
 {foo: 1, foo: str}.f64
 {foo: 1, foo: str}.list
+{foo: 1, foo: str}?.i
 {foo: 1, foo: str}?.str
 {foo: 1, foo: true}.String
+{foo: 1, foo: true}.array
 {foo: 1, foo: true}.ok
+{foo: 1.0 != $env?.String}
+{foo: 1.0 != 0}
 {foo: 1.0 != 1.0}
 {foo: 1.0 != 1}
 {foo: 1.0 != f64}
 {foo: 1.0 != i}
 {foo: 1.0 * 1.0}
 {foo: 1.0 * 1}
+{foo: 1.0 * f64}
+{foo: 1.0 * i}
+{foo: 1.0 * i}?.f64
+{foo: 1.0 ** 0}
 {foo: 1.0 ** 1.0}
+{foo: 1.0 ** 1}
 {foo: 1.0 ** f64}
 {foo: 1.0 ** i}
 {foo: 1.0 + 1.0}
 {foo: 1.0 + 1}
 {foo: 1.0 + f64}
+{foo: 1.0 + f64}?.f64
 {foo: 1.0 + i}
 {foo: 1.0 - 0}
 {foo: 1.0 - 1.0}
 {foo: 1.0 - 1}
+{foo: 1.0 - f64}
 {foo: 1.0 - i}
 {foo: 1.0 / 0}
 {foo: 1.0 / 1.0}
 {foo: 1.0 / 1}
 {foo: 1.0 / f64}
 {foo: 1.0 / i}
+{foo: 1.0 < 0}
 {foo: 1.0 < 1.0}
 {foo: 1.0 < 1.0}.String
+{foo: 1.0 < 1}
+{foo: 1.0 < f64}
+{foo: 1.0 < i}
 {foo: 1.0 <= 0}
+{foo: 1.0 <= 1.0, foo: str}
 {foo: 1.0 <= 1.0}
 {foo: 1.0 <= 1}
 {foo: 1.0 <= f64}
@@ -19869,10 +39451,13 @@ values({foo: str})
 {foo: 1.0 == 0}
 {foo: 1.0 == 1.0}
 {foo: 1.0 == 1}
+{foo: 1.0 == f64}
 {foo: 1.0 == f64}.foo
 {foo: 1.0 == i}
 {foo: 1.0 == nil}
 {foo: 1.0 == nil}?.String
+{foo: 1.0 > 0}
+{foo: 1.0 > 0}.list
 {foo: 1.0 > 1.0}
 {foo: 1.0 > 1}
 {foo: 1.0 > f64}
@@ -19884,73 +39469,135 @@ values({foo: str})
 {foo: 1.0 >= f64}
 {foo: 1.0 >= i, foo: greet}
 {foo: 1.0 >= i}
+{foo: 1.0 ?? $env}
+{foo: 1.0 ?? 0}
+{foo: 1.0 ?? 1.0, foo: i}
+{foo: 1.0 ?? 1.0, foo: str}
+{foo: 1.0 ?? 1.0}
+{foo: 1.0 ?? 1}
+{foo: 1.0 ?? f64}
+{foo: 1.0 ?? foo}
+{foo: 1.0 ?? i}
+{foo: 1.0 ?? list}
+{foo: 1.0 ?? nil}
+{foo: 1.0 ?? ok}
+{foo: 1.0 ?? str}
 {foo: 1.0 ^ 0}
 {foo: 1.0 ^ 1.0}
 {foo: 1.0 ^ 1}
 {foo: 1.0 ^ i}
+{foo: 1.0 in array, foo: i}
 {foo: 1.0 in array}
 {foo: 1.0 not in array}
 {foo: 1.0 | max(1.0)}
+{foo: 1.0 | median(f64)}
 {foo: 1.0 | min(1)}
 {foo: 1.0, foo: $env, foo: foo}.f64
+{foo: 1.0, foo: $env, foo: foo}.greet
 {foo: 1.0, foo: $env, foo: str}?.i?.[add]
+{foo: 1.0, foo: $env}.add
 {foo: 1.0, foo: $env}.array
+{foo: 1.0, foo: $env}.f64
+{foo: 1.0, foo: $env}.foo
 {foo: 1.0, foo: $env}.foobar
 {foo: 1.0, foo: $env}.greet
+{foo: 1.0, foo: $env}.i
+{foo: 1.0, foo: $env}.ok
+{foo: 1.0, foo: $env}?.Bar
+{foo: 1.0, foo: $env}?.String
 {foo: 1.0, foo: $env}?.add
+{foo: 1.0, foo: $env}?.array
+{foo: 1.0, foo: $env}?.f64
 {foo: 1.0, foo: $env}?.greet
+{foo: 1.0, foo: $env}?.list
 {foo: 1.0, foo: $env}?.ok
 {foo: 1.0, foo: 0, foo: $env}?.i
+{foo: 1.0, foo: 0, foo: 0}?.array
 {foo: 1.0, foo: 0, foo: array}.String
 {foo: 1.0, foo: 0}.Bar
 {foo: 1.0, foo: 0}.String
 {foo: 1.0, foo: 0}.String?.String
 {foo: 1.0, foo: 0}.i
 {foo: 1.0, foo: 0}.list
+{foo: 1.0, foo: 0}?.[str]
+{foo: 1.0, foo: 0}?.f64
 {foo: 1.0, foo: 0}?.foo
 {foo: 1.0, foo: 0}?.str
 {foo: 1.0, foo: 1.0}.Bar
 {foo: 1.0, foo: 1.0}.add
 {foo: 1.0, foo: 1.0}.array
+{foo: 1.0, foo: 1.0}.f64
 {foo: 1.0, foo: 1.0}.foo
 {foo: 1.0, foo: 1.0}.greet
+{foo: 1.0, foo: 1.0}.i
 {foo: 1.0, foo: 1.0}.list
 {foo: 1.0, foo: 1.0}.ok
 {foo: 1.0, foo: 1.0}.str
+{foo: 1.0, foo: 1.0}?.[str]
 {foo: 1.0, foo: 1.0}?.add
+{foo: 1.0, foo: 1.0}?.array
 {foo: 1.0, foo: 1.0}?.f64
 {foo: 1.0, foo: 1.0}?.greet
+{foo: 1.0, foo: 1.0}?.i
+{foo: 1.0, foo: 1.0}?.ok
+{foo: 1.0, foo: 1}.add
+{foo: 1.0, foo: 1}.array
 {foo: 1.0, foo: 1}.foo
+{foo: 1.0, foo: 1}.list
 {foo: 1.0, foo: 1}?.Bar
+{foo: 1.0, foo: 1}?.String
+{foo: 1.0, foo: 1}?.[str]
 {foo: 1.0, foo: 1}?.add
+{foo: 1.0, foo: 1}?.foo
 {foo: 1.0, foo: 1}?.greet
 {foo: 1.0, foo: 1}?.i
+{foo: 1.0, foo: 1}?.list
+{foo: 1.0, foo: 1}?.ok
 {foo: 1.0, foo: add}.Bar
+{foo: 1.0, foo: add}.add
 {foo: 1.0, foo: add}?.String
 {foo: 1.0, foo: add}?.f64
 {foo: 1.0, foo: add}?.f64?.str?.[array]
 {foo: 1.0, foo: add}?.greet
 {foo: 1.0, foo: add}?.list
+{foo: 1.0, foo: add}?.ok
+{foo: 1.0, foo: add}?.str
 {foo: 1.0, foo: array}.foo
+{foo: 1.0, foo: array}.greet
+{foo: 1.0, foo: array}.list
 {foo: 1.0, foo: array}.str
 {foo: 1.0, foo: array}?.Bar
+{foo: 1.0, foo: array}?.[str]
+{foo: 1.0, foo: array}?.add
 {foo: 1.0, foo: array}?.f64
 {foo: 1.0, foo: array}?.list
 {foo: 1.0, foo: f64}.add
+{foo: 1.0, foo: f64}.foobar
 {foo: 1.0, foo: f64}.greet
+{foo: 1.0, foo: f64}.i
 {foo: 1.0, foo: f64}.list
 {foo: 1.0, foo: f64}.ok
 {foo: 1.0, foo: f64}.str
 {foo: 1.0, foo: f64}?.add
+{foo: 1.0, foo: f64}?.greet
+{foo: 1.0, foo: false, foo: $env}?.ok
+{foo: 1.0, foo: false, foo: 1.0}?.greet
 {foo: 1.0, foo: false}.String
 {foo: 1.0, foo: false}.array
 {foo: 1.0, foo: false}.array?.add
 {foo: 1.0, foo: false}.i
 {foo: 1.0, foo: false}.str
+{foo: 1.0, foo: false}?.[str]
 {foo: 1.0, foo: false}?.array
 {foo: 1.0, foo: false}?.list
+{foo: 1.0, foo: foo, foo: 1}.add
+{foo: 1.0, foo: foo, foo: foo}?.list
 {foo: 1.0, foo: foo, foo: list}?.f64
 {foo: 1.0, foo: foo, foo: true}.Bar
+{foo: 1.0, foo: foo}.Bar
+{foo: 1.0, foo: foo}.array
+{foo: 1.0, foo: foo}.f64
+{foo: 1.0, foo: foo}.f64?.[ok]
 {foo: 1.0, foo: foo}.foo
 {foo: 1.0, foo: foo}.greet
 {foo: 1.0, foo: foo}.list
@@ -19962,16 +39609,27 @@ values({foo: str})
 {foo: 1.0, foo: foo}?.f64
 {foo: 1.0, foo: foo}?.foo
 {foo: 1.0, foo: foo}?.greet
+{foo: 1.0, foo: foo}?.i
 {foo: 1.0, foo: foo}?.list
 {foo: 1.0, foo: foo}?.ok
 {foo: 1.0, foo: greet}.Bar
 {foo: 1.0, foo: greet}.array
+{foo: 1.0, foo: greet}.f64
 {foo: 1.0, foo: greet}.i
 {foo: 1.0, foo: greet}.list
+{foo: 1.0, foo: greet}.ok
 {foo: 1.0, foo: greet}?.[str]
+{foo: 1.0, foo: greet}?.array
 {foo: 1.0, foo: greet}?.foo
 {foo: 1.0, foo: greet}?.greet
+{foo: 1.0, foo: greet}?.i?.[i]
+{foo: 1.0, foo: greet}?.ok
+{foo: 1.0, foo: greet}?.str
+{foo: 1.0, foo: i} ?? f64
+{foo: 1.0, foo: i}.Bar
 {foo: 1.0, foo: i}.String
+{foo: 1.0, foo: i}.add
+{foo: 1.0, foo: i}.f64
 {foo: 1.0, foo: i}.ok
 {foo: 1.0, foo: i}?.Bar
 {foo: 1.0, foo: i}?.String
@@ -19980,101 +39638,166 @@ values({foo: str})
 {foo: 1.0, foo: i}?.foobar
 {foo: 1.0, foo: i}?.greet
 {foo: 1.0, foo: i}?.i
+{foo: 1.0, foo: i}?.ok
 {foo: 1.0, foo: list}.f64
+{foo: 1.0, foo: list}.foobar
 {foo: 1.0, foo: list}.i
 {foo: 1.0, foo: list}.list
+{foo: 1.0, foo: list}.ok
+{foo: 1.0, foo: list}?.String
 {foo: 1.0, foo: list}?.array
 {foo: 1.0, foo: list}?.ok
 {foo: 1.0, foo: nil}.Bar
+{foo: 1.0, foo: nil}.String
+{foo: 1.0, foo: nil}.add
 {foo: 1.0, foo: nil}.array
 {foo: 1.0, foo: nil}.foo
+{foo: 1.0, foo: nil}.greet
 {foo: 1.0, foo: nil}.i
 {foo: 1.0, foo: nil}.ok
 {foo: 1.0, foo: nil}?.Bar
+{foo: 1.0, foo: nil}?.Bar?.list
 {foo: 1.0, foo: nil}?.String
 {foo: 1.0, foo: nil}?.[str]
 {foo: 1.0, foo: nil}?.add
+{foo: 1.0, foo: nil}?.array
 {foo: 1.0, foo: nil}?.f64
+{foo: 1.0, foo: nil}?.foo
 {foo: 1.0, foo: nil}?.foobar
+{foo: 1.0, foo: nil}?.greet
 {foo: 1.0, foo: nil}?.str
+{foo: 1.0, foo: ok, foo: str}.f64
 {foo: 1.0, foo: ok}.String
 {foo: 1.0, foo: ok}.add
 {foo: 1.0, foo: ok}.f64
+{foo: 1.0, foo: ok}.greet
 {foo: 1.0, foo: ok}.i
 {foo: 1.0, foo: ok}.str
 {foo: 1.0, foo: ok}?.String
+{foo: 1.0, foo: ok}?.[str]
 {foo: 1.0, foo: ok}?.f64
 {foo: 1.0, foo: ok}?.greet
+{foo: 1.0, foo: ok}?.list
 {foo: 1.0, foo: ok}?.list?.ok
 {foo: 1.0, foo: ok}?.str
+{foo: 1.0, foo: str, foo: 1} != true ?? add
+{foo: 1.0, foo: str, foo: str}.list
 {foo: 1.0, foo: str}.array
 {foo: 1.0, foo: str}.str
+{foo: 1.0, foo: str}?.String
+{foo: 1.0, foo: str}?.f64
+{foo: 1.0, foo: str}?.greet
+{foo: 1.0, foo: str}?.i
 {foo: 1.0, foo: str}?.str
+{foo: 1.0, foo: true, foo: foo}?.Bar
+{foo: 1.0, foo: true, foo: true}?.[str]
+{foo: 1.0, foo: true}.String
+{foo: 1.0, foo: true}.add
 {foo: 1.0, foo: true}.greet
+{foo: 1.0, foo: true}.i
 {foo: 1.0, foo: true}?.Bar
+{foo: 1.0, foo: true}?.String
+{foo: 1.0, foo: true}?.[str]
+{foo: 1.0, foo: true}?.add
 {foo: 1.0, foo: true}?.array
 {foo: 1.0, foo: true}?.f64
 {foo: 1.0, foo: true}?.ok
 {foo: 1.0}
+{foo: 1.0} ?? foo
+{foo: 1.0} not in $env?.[String]
 {foo: 1.0} | get(str)
 {foo: 1.0}.Bar
 {foo: 1.0}.Bar?.str
 {foo: 1.0}.String
 {foo: 1.0}.String?.[foo]
+{foo: 1.0}.String?.array
 {foo: 1.0}.String?.foo
 {foo: 1.0}.add
 {foo: 1.0}.add?.Bar
 {foo: 1.0}.add?.f64
 {foo: 1.0}.add?.list
+{foo: 1.0}.add?.ok
 {foo: 1.0}.array
+{foo: 1.0}.array?.array()
 {foo: 1.0}.f64
 {foo: 1.0}.f64?.[add]
+{foo: 1.0}.f64?.foo
 {foo: 1.0}.f64?.greet()
 {foo: 1.0}.foo
 {foo: 1.0}.foobar
 {foo: 1.0}.foobar == 1.0
+{foo: 1.0}.foobar?.String
+{foo: 1.0}.foobar?.i
 {foo: 1.0}.greet
+{foo: 1.0}.greet?.[ok]
 {foo: 1.0}.greet?.foo
 {foo: 1.0}.i
 {foo: 1.0}.i == ok
+{foo: 1.0}.i?.[str]
 {foo: 1.0}.list
+{foo: 1.0}.list?.[list]?.i
 {foo: 1.0}.list?.i
 {foo: 1.0}.ok
+{foo: 1.0}.ok?.[foo]
+{foo: 1.0}.ok?.ok()
 {foo: 1.0}.str
+{foo: 1.0}.str?.[f64]
 {foo: 1.0}.str?.[list]?.foo
+{foo: 1.0}.str?.str
+{foo: 1.0}?.$env?.String()
 {foo: 1.0}?.$env?.[add]
+{foo: 1.0}?.$env?.f64
 {foo: 1.0}?.Bar
+{foo: 1.0}?.Bar?.[greet]
 {foo: 1.0}?.Bar?.[ok]
 {foo: 1.0}?.Bar?.add
 {foo: 1.0}?.Bar?.list(array, ok)
 {foo: 1.0}?.Bar?.list(foobar)
 {foo: 1.0}?.String
+{foo: 1.0}?.String?.[f64]
 {foo: 1.0}?.String?.[f64].str
+{foo: 1.0}?.[greet(str)]
 {foo: 1.0}?.[str]
 {foo: 1.0}?.add
 {foo: 1.0}?.add?.[i]
+{foo: 1.0}?.add?.list
 {foo: 1.0}?.array
 {foo: 1.0}?.array?.greet
+{foo: 1.0}?.array?.ok
+{foo: 1.0}?.array?.str(foobar)
 {foo: 1.0}?.f64
+{foo: 1.0}?.f64?.[list]
 {foo: 1.0}?.f64?.foo
+{foo: 1.0}?.false?.[list]
 {foo: 1.0}?.foo
 {foo: 1.0}?.foobar
 {foo: 1.0}?.foobar?.String
 {foo: 1.0}?.greet
+{foo: 1.0}?.greet?.array()
 {foo: 1.0}?.greet?.list
 {foo: 1.0}?.i
+{foo: 1.0}?.i?.[foo]
 {foo: 1.0}?.list
+{foo: 1.0}?.list?.[i]
 {foo: 1.0}?.list?.[str]
 {foo: 1.0}?.not
 {foo: 1.0}?.ok
+{foo: 1.0}?.ok?.[ok]
 {foo: 1.0}?.str
 {foo: 1} == $env?.[String]
+{foo: 1} ?? array
+{foo: 1} ?? ok
 {foo: 1}.Bar
+{foo: 1}.Bar?.Bar()
+{foo: 1}.Bar?.foo?.i
 {foo: 1}.String
+{foo: 1}.String?.[array]
 {foo: 1}.String?.[greet]
 {foo: 1}.add
+{foo: 1}.add?.array
 {foo: 1}.add?.str()
 {foo: 1}.array
+{foo: 1}.array?.[list]
 {foo: 1}.f64
 {foo: 1}.foo
 {foo: 1}.foobar
@@ -20082,14 +39805,20 @@ values({foo: str})
 {foo: 1}.greet?.[list]
 {foo: 1}.i
 {foo: 1}.list
+{foo: 1}.list != add
 {foo: 1}.list?.foo
 {foo: 1}.ok
 {foo: 1}.ok?.add
+{foo: 1}.ok?.greet
 {foo: 1}.str
 {foo: 1}.str?.[f64]
 {foo: 1}?.Bar
 {foo: 1}?.String
 {foo: 1}?.String not startsWith $env
+{foo: 1}?.String?.Bar
+{foo: 1}?.String?.[f64]
+{foo: 1}?.String?.add
+{foo: 1}?.String?.greet
 {foo: 1}?.[str]
 {foo: 1}?.[str] startsWith str
 {foo: 1}?.[str]?.String
@@ -20097,53 +39826,83 @@ values({foo: str})
 {foo: 1}?.add?.[str]
 {foo: 1}?.array
 {foo: 1}?.f64
+{foo: 1}?.f64?.String
 {foo: 1}?.f64?.[ok]
 {foo: 1}?.foo
 {foo: 1}?.foobar
+{foo: 1}?.foobar?.foo.foobar?.[foo]
+{foo: 1}?.foobar?.greet(add)
 {foo: 1}?.foobar?.i.array
 {foo: 1}?.greet
 {foo: 1}?.i
+{foo: 1}?.i?.[add]
 {foo: 1}?.list
 {foo: 1}?.list?.[ok]
 {foo: 1}?.nil?.str(nil)
 {foo: 1}?.ok
+{foo: 1}?.ok?.str
 {foo: 1}?.str
 {foo: 1}?.str?.[i]
 {foo: 1}?.str?.[ok]
+{foo: [$env, 1.0]}
 {foo: [$env, false], foo: f64}
+{foo: [$env, nil]}
 {foo: [$env, ok]}
 {foo: [$env]}
 {foo: [$env]}?.String
 {foo: [0 + 0, list]}
+{foo: [0, 1.0]}
 {foo: [0]}
+{foo: [1, 1.0]}
 {foo: [1.0, $env]}
+{foo: [1.0, greet, 1.0]}
 {foo: [1.0], foo: greet}
 {foo: [1.0]}
+{foo: [1.0]}?.f64
+{foo: [1], foo: foo?.String}
 {foo: [1]}
 {foo: [1]}.list
+{foo: [add, $env]}
 {foo: [add, 1]}
+{foo: [add, str]}
 {foo: [add]}
+{foo: [array, 1]}
+{foo: [array, list, foo]}
 {foo: [array]}
 {foo: [ceil(f64)]}
 {foo: [f64]}
+{foo: [f64]}.array
 {foo: [false, f64]}
 {foo: [false]}
 {foo: [foo, $env]}
+{foo: [foo, false]}
 {foo: [foo, i]}
 {foo: [foo, nil]}
+{foo: [foo, ok]}
 {foo: [foo]}
+{foo: [foo]}?.Bar
 {foo: [greet, array]}
 {foo: [greet]}
 {foo: [greet]}.Bar
+{foo: [i, 1, array]}
+{foo: [i, 1]}
+{foo: [i, str]}
+{foo: [i], foo: f64}
 {foo: [i]}
+{foo: [i]}?.[str]
 {foo: [list]}
+{foo: [nil, 1.0]}
 {foo: [nil, array]}
 {foo: [nil, nil]}
 {foo: [nil, true]}
 {foo: [nil]}
 {foo: [ok, foo]}
 {foo: [ok]}
+{foo: [str, ok]}
+{foo: [str, true]}
 {foo: [str]}
+{foo: [true, add], foo: foo}
+{foo: [true, false]}
 {foo: [true, nil]}.i
 {foo: [true]}
 {foo: abs(0)}
@@ -20154,53 +39913,105 @@ values({foo: str})
 {foo: abs(i)}
 {foo: add != $env}
 {foo: add != add}
+{foo: add != nil, foo: $env.list}.greet
 {foo: add != nil}
 {foo: add == $env}
+{foo: add == add}
+{foo: add ?? $env}
+{foo: add ?? 0}
+{foo: add ?? 1.0}
+{foo: add ?? add}
+{foo: add ?? false}
+{foo: add ?? foo}
+{foo: add ?? foo}?.list
+{foo: add ?? i}
+{foo: add ?? nil}
+{foo: add ?? str}
+{foo: add ?? true}
 {foo: add(1, 0)}
 {foo: add(i, 0)}
 {foo: add(i, i)}
+{foo: add, foo: $env in array}
+{foo: add, foo: $env.add}
 {foo: add, foo: $env.f64}
+{foo: add, foo: $env.i}
+{foo: add, foo: $env?.foobar}
+{foo: add, foo: $env?.list}
 {foo: add, foo: $env}.$env == f64
+{foo: add, foo: $env}.Bar
+{foo: add, foo: $env}.array
+{foo: add, foo: $env}.f64
 {foo: add, foo: $env}.ok
 {foo: add, foo: $env}?.Bar
 {foo: add, foo: $env}?.String
 {foo: add, foo: $env}?.foo
 {foo: add, foo: $env}?.i
+{foo: add, foo: $env}?.list
+{foo: add, foo: $env}?.ok
 {foo: add, foo: 0, foo: 0}.ok
+{foo: add, foo: 0, foo: nil}.String
+{foo: add, foo: 0}.f64
 {foo: add, foo: 0}.list
+{foo: add, foo: 0}?.Bar
+{foo: add, foo: 0}?.f64
+{foo: add, foo: 0}?.i
 {foo: add, foo: 1 ** i}
 {foo: add, foo: 1 < f64}
 {foo: add, foo: 1.0 / 1.0}
 {foo: add, foo: 1.0 > f64}
 {foo: add, foo: 1.0}.String
+{foo: add, foo: 1.0}.f64
+{foo: add, foo: 1.0}.greet
+{foo: add, foo: 1.0}.i
 {foo: add, foo: 1.0}.list
 {foo: add, foo: 1.0}.str
 {foo: add, foo: 1.0}?.Bar
 {foo: add, foo: 1.0}?.greet
 {foo: add, foo: 1.0}?.list
 {foo: add, foo: 1.0}?.ok
+{foo: add, foo: 1} ?? f64
+{foo: add, foo: 1}.Bar
+{foo: add, foo: 1}.String
 {foo: add, foo: 1}.add
+{foo: add, foo: 1}.foo
+{foo: add, foo: 1}.list
+{foo: add, foo: 1}?.foo
 {foo: add, foo: add}
+{foo: add, foo: add}.String
+{foo: add, foo: add}.add
 {foo: add, foo: add}.array
 {foo: add, foo: add}.foo
 {foo: add, foo: add}?.f64
 {foo: add, foo: add}?.i
+{foo: add, foo: add}?.list
 {foo: add, foo: add}?.ok
 {foo: add, foo: add}?.str
 {foo: add, foo: array}
+{foo: add, foo: array}.String
 {foo: add, foo: array}.i
+{foo: add, foo: array}?.Bar
 {foo: add, foo: array}?.array
+{foo: add, foo: array}?.i?.Bar
+{foo: add, foo: f64, foo: $env}.foo
 {foo: add, foo: f64}
 {foo: add, foo: f64}.array
 {foo: add, foo: f64}.foo
 {foo: add, foo: f64}.greet
+{foo: add, foo: f64}.i
 {foo: add, foo: f64}.nil?.f64(foobar)
+{foo: add, foo: f64}?.Bar
 {foo: add, foo: f64}?.[str]
+{foo: add, foo: f64}?.greet?.[array]
+{foo: add, foo: f64}?.list
 {foo: add, foo: f64}?.ok
+{foo: add, foo: false}.array
+{foo: add, foo: false}.foo
 {foo: add, foo: false}.i
 {foo: add, foo: false}?.Bar
 {foo: add, foo: false}?.String
 {foo: add, foo: false}?.[str]
+{foo: add, foo: false}?.f64
+{foo: add, foo: false}?.list
 {foo: add, foo: false}?.ok
 {foo: add, foo: false}?.str
 {foo: add, foo: foo.String()}
@@ -20208,9 +40019,12 @@ values({foo: str})
 {foo: add, foo: foo}
 {foo: add, foo: foo}.array
 {foo: add, foo: foo}.f64
+{foo: add, foo: foo}.foo
 {foo: add, foo: foo}.greet
 {foo: add, foo: foo}.ok
 {foo: add, foo: foo}?.Bar
+{foo: add, foo: foo}?.add
+{foo: add, foo: foo}?.array
 {foo: add, foo: foo}?.f64
 {foo: add, foo: foo}?.foo
 {foo: add, foo: foo}?.i
@@ -20219,23 +40033,38 @@ values({foo: str})
 {foo: add, foo: greet}
 {foo: add, foo: greet}.Bar?.String
 {foo: add, foo: greet}.String
+{foo: add, foo: greet}.add
+{foo: add, foo: greet}.array
 {foo: add, foo: greet}.greet
+{foo: add, foo: greet}?.Bar
 {foo: add, foo: greet}?.f64
 {foo: add, foo: greet}?.greet
 {foo: add, foo: greet}?.str
 {foo: add, foo: i}
 {foo: add, foo: i}.array
+{foo: add, foo: i}.f64
 {foo: add, foo: i}.greet
 {foo: add, foo: i}.str
+{foo: add, foo: i}?.Bar
 {foo: add, foo: i}?.f64
 {foo: add, foo: i}?.str
+{foo: add, foo: list?.[i]}
 {foo: add, foo: list}
 {foo: add, foo: list}.str
+{foo: add, foo: list}?.Bar
+{foo: add, foo: list}?.greet
 {foo: add, foo: list}?.list
+{foo: add, foo: mean(1.0)}
+{foo: add, foo: nil, foo: nil}?.f64
+{foo: add, foo: nil}.array
+{foo: add, foo: nil}.foo
 {foo: add, foo: nil}.greet
 {foo: add, foo: nil}.str
+{foo: add, foo: nil}?.Bar
 {foo: add, foo: nil}?.[str]
+{foo: add, foo: nil}?.[str]?.str
 {foo: add, foo: nil}?.add
+{foo: add, foo: nil}?.f64
 {foo: add, foo: nil}?.greet
 {foo: add, foo: nil}?.list
 {foo: add, foo: nil}?.ok
@@ -20245,137 +40074,256 @@ values({foo: str})
 {foo: add, foo: ok}?.list
 {foo: add, foo: str}
 {foo: add, foo: str}.String
+{foo: add, foo: str}.add
 {foo: add, foo: str}.foo
+{foo: add, foo: str}.greet
 {foo: add, foo: str}?.String
 {foo: add, foo: str}?.foo
+{foo: add, foo: str}?.ok
+{foo: add, foo: str}?.str
 {foo: add, foo: true}.foo
 {foo: add, foo: true}.i
 {foo: add, foo: true}.list
 {foo: add, foo: true}?.f64
+{foo: add, foo: true}?.foo
 {foo: add, foo: true}?.i
+{foo: add, foo: true}?.list
 {foo: add}
+{foo: add} ?? greet
 {foo: add}.Bar
 {foo: add}.String
 {foo: add}.add
 {foo: add}.array
 {foo: add}.f64
 {foo: add}.foo
+{foo: add}.foobar
 {foo: add}.greet
 {foo: add}.greet?.i
 {foo: add}.i
+{foo: add}.i?.[foo]
 {foo: add}.i?.[greet]
 {foo: add}.i?.greet
 {foo: add}.list
 {foo: add}.list?.add()?.Bar
+{foo: add}.nil?.[greet]
 {foo: add}.ok
 {foo: add}.ok?.Bar(ok)
 {foo: add}.str
+{foo: add}.str?.[ok]
+{foo: add}.true?.[str]
+{foo: add}?.$env?.array
 {foo: add}?.Bar
 {foo: add}?.Bar?.i(foobar)
+{foo: add}?.Bar?.list
 {foo: add}?.String
 {foo: add}?.String?.String
+{foo: add}?.String?.[str]
 {foo: add}?.[str]
+{foo: add}?.[str]?.[f64]
 {foo: add}?.add
+{foo: add}?.add?.String()
 {foo: add}?.array
+{foo: add}?.array?.[f64]
 {foo: add}?.array?.[list]
 {foo: add}?.array?.find(nil, true).String
 {foo: add}?.f64
+{foo: add}?.f64?.[add]
+{foo: add}?.f64?.[greet]
 {foo: add}?.f64?.[str]
+{foo: add}?.f64?.i
 {foo: add}?.foo
+{foo: add}?.foobar
+{foo: add}?.foobar?.[array]
+{foo: add}?.foobar?.[ok]
 {foo: add}?.greet
+{foo: add}?.greet?.[f64]
+{foo: add}?.greet?.[foo]
 {foo: add}?.i
 {foo: add}?.list
 {foo: add}?.list?.[array].list
+{foo: add}?.list?.[ok]
 {foo: add}?.list?.add
 {foo: add}?.list?.list
 {foo: add}?.ok
+{foo: add}?.ok?.i
 {foo: add}?.str
+{foo: all($env, true)}
 {foo: all(array, ok)}.Bar
+{foo: all(array, true)}
+{foo: all(list, true)}
 {foo: any($env, false)}
 {foo: any($env, ok)}
 {foo: any($env, true)}
+{foo: any(array, false)}
+{foo: any(array, ok)}
+{foo: any(list, ok)}
+{foo: array != $env}
 {foo: array != list}
 {foo: array != nil}
 {foo: array == $env}
 {foo: array == array}
+{foo: array == list}
 {foo: array == nil}
+{foo: array ?? $env}
+{foo: array ?? 0}
+{foo: array ?? 1.0}
+{foo: array ?? 1}
+{foo: array ?? add}
+{foo: array ?? array}
+{foo: array ?? foo}
+{foo: array ?? greet}
+{foo: array ?? i}
+{foo: array ?? list}
+{foo: array ?? str}
+{foo: array ?? true}
 {foo: array | all(false)}
+{foo: array | filter(true)}
+{foo: array | find(true)}
+{foo: array | findIndex(true)}
+{foo: array | groupBy(0)}
 {foo: array | groupBy(1.0)}
+{foo: array | groupBy(foo)}
+{foo: array | groupBy(str)}
 {foo: array | map(#)}
+{foo: array | map($env)}
 {foo: array | map(1)}?.list
 {foo: array | map(false)}
+{foo: array | map(foo)}
 {foo: array | map(greet)}
 {foo: array | map(list)}
+{foo: array | map(ok)}
+{foo: array | map(str)}
 {foo: array | mean(i)}
 {foo: array | min(f64)}
+{foo: array | none(false)}
 {foo: array | one(ok)}
 {foo: array | reduce(#)}
+{foo: array | reduce($env, 1.0)}
 {foo: array | reduce(0)}
+{foo: array | reduce(1.0)}
 {foo: array | reduce(foo)}
 {foo: array | reduce(i)}
 {foo: array | reduce(i, f64)}
+{foo: array | sortBy(#)}
+{foo: array | sum(#)}
+{foo: array | sum(1.0)}
 {foo: array | sum(i)}
+{foo: array, foo: !false}?.greet
+{foo: array, foo: $env, foo: nil}.i
 {foo: array, foo: $env.add}
+{foo: array, foo: $env?.nil}
 {foo: array, foo: $env}.String
+{foo: array, foo: $env}.array?.[add]
 {foo: array, foo: $env}.foo
+{foo: array, foo: $env}.greet
+{foo: array, foo: $env}.list
 {foo: array, foo: $env}?.Bar
+{foo: array, foo: $env}?.[str]
 {foo: array, foo: $env}?.array
+{foo: array, foo: $env}?.f64
 {foo: array, foo: $env}?.foo
+{foo: array, foo: $env}?.greet
+{foo: array, foo: $env}?.i
+{foo: array, foo: $env}?.ok
 {foo: array, foo: 0}.Bar
 {foo: array, foo: 0}?.ok
+{foo: array, foo: 0}?.str
 {foo: array, foo: 1.0 <= 0}
+{foo: array, foo: 1.0, foo: ok}?.String
 {foo: array, foo: 1.0}.String
 {foo: array, foo: 1.0}.add
 {foo: array, foo: 1.0}.list
+{foo: array, foo: 1.0}.str
+{foo: array, foo: 1.0}?.Bar
+{foo: array, foo: 1.0}?.[str]
 {foo: array, foo: 1.0}?.array
+{foo: array, foo: 1.0}?.f64
 {foo: array, foo: 1.0}?.greet
 {foo: array, foo: 1.0}?.list
 {foo: array, foo: 1.0}?.ok
 {foo: array, foo: 1.0}?.str
 {foo: array, foo: 1}.Bar
+{foo: array, foo: 1}.add
+{foo: array, foo: 1}.f64
 {foo: array, foo: 1}.i?.ok
 {foo: array, foo: 1}.ok
 {foo: array, foo: 1}?.String
 {foo: array, foo: 1}?.[str]
+{foo: array, foo: 1}?.array
+{foo: array, foo: 1}?.str
+{foo: array, foo: [$env, nil]}
 {foo: array, foo: add}
+{foo: array, foo: add}.ok
 {foo: array, foo: add}?.foo
+{foo: array, foo: add}?.list
 {foo: array, foo: array, foo: $env}.ok
 {foo: array, foo: array}
 {foo: array, foo: array}.Bar
+{foo: array, foo: array}.add?.list()
 {foo: array, foo: array}.array?.Bar(nil)
 {foo: array, foo: array}.f64
 {foo: array, foo: array}.list
+{foo: array, foo: array}.str
 {foo: array, foo: array}?.str
 {foo: array, foo: f64, foo: 1.0}?.f64
 {foo: array, foo: f64}
 {foo: array, foo: f64}.Bar
+{foo: array, foo: f64}.String
+{foo: array, foo: f64}.f64
 {foo: array, foo: f64}.list
 {foo: array, foo: f64}.str
 {foo: array, foo: f64}?.foo
+{foo: array, foo: false}.add
 {foo: array, foo: false}.f64
 {foo: array, foo: false}.foo
 {foo: array, foo: false}?.f64
+{foo: array, foo: false}?.list
+{foo: array, foo: false}?.str
+{foo: array, foo: float(0)}
+{foo: array, foo: foo != foo}
+{foo: array, foo: foo, foo: foo}.i
+{foo: array, foo: foo.Bar}
+{foo: array, foo: foo.String}
 {foo: array, foo: foo}
+{foo: array, foo: foo}.Bar
+{foo: array, foo: foo}.String
 {foo: array, foo: foo}.add
+{foo: array, foo: foo}.array
+{foo: array, foo: foo}.greet
 {foo: array, foo: foo}.i
+{foo: array, foo: foo}.list
+{foo: array, foo: foo}.str
 {foo: array, foo: foo}?.Bar
 {foo: array, foo: foo}?.String
+{foo: array, foo: foo}?.array
+{foo: array, foo: foo}?.foobar?.array()
 {foo: array, foo: foo}?.greet
 {foo: array, foo: foo}?.i
 {foo: array, foo: foo}?.list
 {foo: array, foo: foo}?.ok
 {foo: array, foo: greet}
+{foo: array, foo: greet}.String
+{foo: array, foo: greet}?.f64
+{foo: array, foo: greet}?.foo
 {foo: array, foo: greet}?.greet
 {foo: array, foo: greet}?.str
 {foo: array, foo: groupBy(list, false)}
+{foo: array, foo: i, foo: 1.0}?.f64
 {foo: array, foo: i}
+{foo: array, foo: i}.String
+{foo: array, foo: i}.array
+{foo: array, foo: i}.i
 {foo: array, foo: i}.list
 {foo: array, foo: i}?.String
+{foo: array, foo: i}?.add
 {foo: array, foo: list}
 {foo: array, foo: list}.String
 {foo: array, foo: list}.array
 {foo: array, foo: list}.false?.[i]
+{foo: array, foo: list}.greet
 {foo: array, foo: list}.list
+{foo: array, foo: list}.ok
+{foo: array, foo: list}?.Bar
 {foo: array, foo: list}?.String
 {foo: array, foo: list}?.add
 {foo: array, foo: list}?.foo
@@ -20384,54 +40332,86 @@ values({foo: str})
 {foo: array, foo: list}?.ok
 {foo: array, foo: nil}.Bar
 {foo: array, foo: nil}.Bar?.[f64]
+{foo: array, foo: nil}.add
 {foo: array, foo: nil}.array
+{foo: array, foo: nil}.greet
 {foo: array, foo: nil}.list
 {foo: array, foo: nil}.str
+{foo: array, foo: nil}?.[str]
 {foo: array, foo: nil}?.add
 {foo: array, foo: nil}?.foo
 {foo: array, foo: nil}?.greet
 {foo: array, foo: nil}?.i
 {foo: array, foo: nil}?.list
+{foo: array, foo: nil}?.ok
 {foo: array, foo: nil}?.str
+{foo: array, foo: ok, foo: 1.0}.ok
 {foo: array, foo: ok, foo: false}?.String?.String()
 {foo: array, foo: ok}
+{foo: array, foo: ok}.ok
 {foo: array, foo: ok}?.Bar
+{foo: array, foo: ok}?.String
 {foo: array, foo: ok}?.ok
 {foo: array, foo: reduce(array, #)}?.ok
+{foo: array, foo: str, foo: foo}?.array
 {foo: array, foo: str}
 {foo: array, foo: str}.Bar
 {foo: array, foo: str}.f64
+{foo: array, foo: str}.i
+{foo: array, foo: str}.list
+{foo: array, foo: str}.ok
+{foo: array, foo: str}.str
 {foo: array, foo: toJSON(1.0)}
+{foo: array, foo: true}.greet
 {foo: array, foo: true}.str
 {foo: array, foo: true}?.Bar
+{foo: array, foo: true}?.foo
+{foo: array, foo: {foo: $env}}
+{foo: array?.[1]}
 {foo: array?.[i], foo: list}
 {foo: array?.[i]}
+{foo: array[0:]}
 {foo: array[1:]}
+{foo: array[:0]}
+{foo: array[:1]}
 {foo: array[:]}
+{foo: array[:i]}?.list
 {foo: array}
+{foo: array} ?? add
+{foo: array} ?? groupBy(list, 1)
+{foo: array} ?? list
 {foo: array}.Bar
+{foo: array}.Bar?.String
 {foo: array}.Bar?.[array]
 {foo: array}.Bar?.[i]
 {foo: array}.Bar?.[ok]
 {foo: array}.String
+{foo: array}.String?.[f64]
+{foo: array}.String?.list
 {foo: array}.add
+{foo: array}.add?.[add]
 {foo: array}.array
 {foo: array}.array?.add
 {foo: array}.array?.list
 {foo: array}.f64
 {foo: array}.f64?.[i]
+{foo: array}.f64?.add
+{foo: array}.f64?.f64()
 {foo: array}.foo
 {foo: array}.foobar
 {foo: array}.greet
+{foo: array}.greet?.greet
 {foo: array}.i
 {foo: array}.i?.[list]
 {foo: array}.i?.[ok]
+{foo: array}.i?.array
 {foo: array}.i?.foo
 {foo: array}.list
 {foo: array}.list?.[f64]
 {foo: array}.ok
 {foo: array}.str
 {foo: array}.str?.[greet]
+{foo: array}.str?.add
 {foo: array}?.Bar
 {foo: array}?.Bar?.[array]
 {foo: array}?.String
@@ -20439,10 +40419,13 @@ values({foo: str})
 {foo: array}?.[str]
 {foo: array}?.[str]?.String()
 {foo: array}?.[str]?.[add]
+{foo: array}?.[str]?.[array]
+{foo: array}?.[type(nil)]
 {foo: array}?.add
 {foo: array}?.array
 {foo: array}?.array?.foobar
 {foo: array}?.f64
+{foo: array}?.f64?.add
 {foo: array}?.f64?.ok
 {foo: array}?.foo
 {foo: array}?.foobar
@@ -20451,25 +40434,36 @@ values({foo: str})
 {foo: array}?.i
 {foo: array}?.list
 {foo: array}?.list?.add
+{foo: array}?.list?.f64
 {foo: array}?.ok
 {foo: array}?.ok?.ok()
 {foo: array}?.str
 {foo: array}?.str?.[f64]
+{foo: array}?.str?.[greet]
 {foo: bitnand(i, 1)}
 {foo: bitnot(0)}
+{foo: bitnot(1)}
 {foo: bitnot(i)}
 {foo: bitor(0, 0)}
 {foo: bitor(i, i)}
+{foo: bitshr(1, i)}
+{foo: bitxor(0, i)}
 {foo: bitxor(i, 1)}
 {foo: ceil(0), foo: array}
 {foo: ceil(0)}
 {foo: ceil(1)}
+{foo: ceil(1.0), foo: ok}
 {foo: ceil(1.0)}
 {foo: ceil(f64)}
+{foo: ceil(f64)}.array
 {foo: ceil(i)}
 {foo: concat(array)}
 {foo: concat(list)}
+{foo: count($env, ok)}
 {foo: count($env, true), foo: f64}
+{foo: count($env, true)}
+{foo: count(array, false)}
+{foo: count(array, ok)}
 {foo: count(list, ok)}
 {foo: f64 != $env}
 {foo: f64 != 1.0}
@@ -20477,149 +40471,274 @@ values({foo: str})
 {foo: f64 != f64}
 {foo: f64 != i}
 {foo: f64 != nil}
+{foo: f64 * 0}
 {foo: f64 * 1.0}
+{foo: f64 * f64}
+{foo: f64 * i}
+{foo: f64 * i}?.Bar
+{foo: f64 ** 1.0}
+{foo: f64 ** f64}
 {foo: f64 ** i}
 {foo: f64 + 1.0}
 {foo: f64 + 1}
 {foo: f64 + f64}
+{foo: f64 + i}
+{foo: f64 - 0}
 {foo: f64 / 0}
 {foo: f64 / f64}
 {foo: f64 / i}
+{foo: f64 < 0}
+{foo: f64 < 0}.f64
 {foo: f64 < i}
 {foo: f64 <= 1.0}
+{foo: f64 <= f64}
 {foo: f64 <= i}
+{foo: f64 == $env}
+{foo: f64 == 0}
 {foo: f64 == 1.0}
 {foo: f64 == 1}
+{foo: f64 == i}
 {foo: f64 == nil}
 {foo: f64 > 0, foo: floor(1.0)}
 {foo: f64 > 0}
 {foo: f64 > f64}
 {foo: f64 >= 0}
+{foo: f64 >= 1.0}
 {foo: f64 >= 1}
+{foo: f64 ?? $env}
+{foo: f64 ?? 1.0}
+{foo: f64 ?? f64}
+{foo: f64 ?? foo}
+{foo: f64 ?? list}
+{foo: f64 ?? nil}
+{foo: f64 ?? str}
 {foo: f64 ^ 1.0}
+{foo: f64 ^ i}
 {foo: f64 in array}
 {foo: f64 not in array}
 {foo: f64 not in array}.f64
 {foo: f64, foo: $env == array}
+{foo: f64, foo: $env.foo}
 {foo: f64, foo: $env?.[foobar]}
 {foo: f64, foo: $env?.list}
+{foo: f64, foo: $env?.ok}
 {foo: f64, foo: $env}.String
+{foo: f64, foo: $env}.greet
+{foo: f64, foo: $env}.i
+{foo: f64, foo: $env}.ok
+{foo: f64, foo: $env}.str
 {foo: f64, foo: $env}?.i
+{foo: f64, foo: $env}?.list
 {foo: f64, foo: $env}?.ok
 {foo: f64, foo: 0, foo: 1.0}.f64
 {foo: f64, foo: 0}.Bar
+{foo: f64, foo: 0}.add
+{foo: f64, foo: 0}.array
 {foo: f64, foo: 0}.list
+{foo: f64, foo: 0}.ok
 {foo: f64, foo: 0}.str
 {foo: f64, foo: 0}?.foo
+{foo: f64, foo: 0}?.list
 {foo: f64, foo: 1 != $env}
 {foo: f64, foo: 1 / 0}
 {foo: f64, foo: 1, foo: $env}?.i
 {foo: f64, foo: 1, foo: nil}.String
+{foo: f64, foo: 1.0, foo: true}.foo
 {foo: f64, foo: 1.0}.f64
 {foo: f64, foo: 1.0}.i
 {foo: f64, foo: 1.0}?.Bar
+{foo: f64, foo: 1.0}?.[str]
+{foo: f64, foo: 1.0}?.array
 {foo: f64, foo: 1.0}?.f64
+{foo: f64, foo: 1.0}?.greet
+{foo: f64, foo: 1.0}?.i
 {foo: f64, foo: 1.0}?.ok
 {foo: f64, foo: 1.0}?.str
+{foo: f64, foo: 1}.ok
+{foo: f64, foo: 1}?.String
+{foo: f64, foo: 1}?.[str]
 {foo: f64, foo: 1}?.greet
+{foo: f64, foo: 1}?.list
+{foo: f64, foo: 1}?.str
 {foo: f64, foo: add}
+{foo: f64, foo: add}.Bar
 {foo: f64, foo: add}.add
 {foo: f64, foo: add}.foo
+{foo: f64, foo: add}.greet
+{foo: f64, foo: add}.str
+{foo: f64, foo: add}?.String
 {foo: f64, foo: add}?.f64
 {foo: f64, foo: add}?.foo
 {foo: f64, foo: add}?.greet
+{foo: f64, foo: add}?.i
 {foo: f64, foo: array}
 {foo: f64, foo: array}.Bar
 {foo: f64, foo: array}.add
+{foo: f64, foo: array}?.Bar
+{foo: f64, foo: array}?.foo
+{foo: f64, foo: array}?.list
 {foo: f64, foo: array}?.str
 {foo: f64, foo: f64}
 {foo: f64, foo: f64}.String
 {foo: f64, foo: f64}.ok
+{foo: f64, foo: f64}.str
 {foo: f64, foo: f64}?.Bar
+{foo: f64, foo: f64}?.f64
+{foo: f64, foo: f64}?.foo
+{foo: f64, foo: f64}?.str
+{foo: f64, foo: false != nil}
+{foo: f64, foo: false}.f64
+{foo: f64, foo: false}.greet
+{foo: f64, foo: false}.ok?.[array]
+{foo: f64, foo: foo, foo: 0}.ok
+{foo: f64, foo: foo, foo: foo}.Bar
 {foo: f64, foo: foo, foo: foo}?.add
+{foo: f64, foo: foo, foo: foo}?.greet
 {foo: f64, foo: foo}
+{foo: f64, foo: foo}.Bar
+{foo: f64, foo: foo}.add
 {foo: f64, foo: foo}.array
 {foo: f64, foo: foo}.f64
 {foo: f64, foo: foo}.foo
 {foo: f64, foo: foo}.greet
+{foo: f64, foo: foo}.i
 {foo: f64, foo: foo}.list
+{foo: f64, foo: foo}.ok
+{foo: f64, foo: foo}?.String
 {foo: f64, foo: foo}?.[str]
 {foo: f64, foo: foo}?.add
 {foo: f64, foo: foo}?.array
+{foo: f64, foo: foo}?.foo
 {foo: f64, foo: foo}?.greet
 {foo: f64, foo: foo}?.i
 {foo: f64, foo: foo}?.str
+{foo: f64, foo: greet(str)}.str
 {foo: f64, foo: greet, foo: i}?.str
 {foo: f64, foo: greet}
 {foo: f64, foo: greet}.add
+{foo: f64, foo: greet}.array
+{foo: f64, foo: greet}.i
+{foo: f64, foo: greet}?.foo
+{foo: f64, foo: greet}?.greet
 {foo: f64, foo: greet}?.ok
 {foo: f64, foo: i, foo: add}.ok
+{foo: f64, foo: i, foo: foo}?.greet
 {foo: f64, foo: if ok { foo } else { nil }}.foo
 {foo: f64, foo: i}
+{foo: f64, foo: i}.array
+{foo: f64, foo: i}.greet
 {foo: f64, foo: i}?.[str]
 {foo: f64, foo: list}
+{foo: f64, foo: list}.String
+{foo: f64, foo: list}.add
 {foo: f64, foo: list}.array
 {foo: f64, foo: list}.foo
 {foo: f64, foo: list}.list
+{foo: f64, foo: list}?.Bar
+{foo: f64, foo: list}?.String
 {foo: f64, foo: list}?.i?.[i]
 {foo: f64, foo: nil, foo: $env}?.f64
+{foo: f64, foo: nil, foo: $env}?.ok
 {foo: f64, foo: nil, foo: 1.0}.array
 {foo: f64, foo: nil}.String
 {foo: f64, foo: nil}.array
 {foo: f64, foo: nil}.f64
 {foo: f64, foo: nil}.foobar
+{foo: f64, foo: nil}.greet
 {foo: f64, foo: nil}?.[str]
+{foo: f64, foo: nil}?.add?.[f64]
+{foo: f64, foo: nil}?.array
+{foo: f64, foo: nil}?.f64
+{foo: f64, foo: nil}?.foobar
+{foo: f64, foo: nil}?.i
 {foo: f64, foo: nil}?.str
+{foo: f64, foo: ok ?? f64}
 {foo: f64, foo: ok, foo: 1.0}?.str
 {foo: f64, foo: ok}
+{foo: f64, foo: ok}?.Bar
 {foo: f64, foo: ok}?.String
 {foo: f64, foo: ok}?.f64?.[i]
+{foo: f64, foo: ok}?.ok
+{foo: f64, foo: round(1)}
+{foo: f64, foo: str, foo: 0}?.[str]
 {foo: f64, foo: str}
+{foo: f64, foo: str}.array
+{foo: f64, foo: str}.f64
+{foo: f64, foo: str}.i
 {foo: f64, foo: str}?.[str]
 {foo: f64, foo: str}?.add
+{foo: f64, foo: str}?.f64
+{foo: f64, foo: str}?.list
 {foo: f64, foo: sum(array)}
 {foo: f64, foo: toJSON(1)}
+{foo: f64, foo: true != nil}
 {foo: f64, foo: true}.add
+{foo: f64, foo: true}?.foo
+{foo: f64, foo: true}?.str
+{foo: f64, foo: {foo: nil}}
 {foo: f64}
+{foo: f64} ?? abs(0)
+{foo: f64} ?? add
+{foo: f64} ?? greet
+{foo: f64} not in first($env)
 {foo: f64}.Bar
 {foo: f64}.String
 {foo: f64}.String?.foo
 {foo: f64}.add
 {foo: f64}.array
+{foo: f64}.array?.foo?.[ok]
 {foo: f64}.f64
+{foo: f64}.f64 != array
+{foo: f64}.f64?.greet
 {foo: f64}.foo
 {foo: f64}.foobar
+{foo: f64}.foobar?.[add]
 {foo: f64}.greet
 {foo: f64}.i
+{foo: f64}.i?.add(foo)
+{foo: f64}.i?.array
 {foo: f64}.list
 {foo: f64}.list?.list()
 {foo: f64}.ok
+{foo: f64}.ok?.list
 {foo: f64}.str
+{foo: f64}.str?.array
 {foo: f64}?.Bar
 {foo: f64}?.String
 {foo: f64}?.[str]
 {foo: f64}?.[str]?.Bar?.f64.String
+{foo: f64}?.[str]?.list
+{foo: f64}?.[str]?.list()
 {foo: f64}?.add
 {foo: f64}?.add?.[array]
 {foo: f64}?.add?.add
 {foo: f64}?.array
+{foo: f64}?.array?.Bar()
 {foo: f64}?.f64
+{foo: f64}?.f64?.[f64]
+{foo: f64}?.f64?.[ok]
 {foo: f64}?.f64?.array
 {foo: f64}?.foo
 {foo: f64}?.foobar
 {foo: f64}?.greet
 {foo: f64}?.i
+{foo: f64}?.i?.[foo]
 {foo: f64}?.i?.add
 {foo: f64}?.list
+{foo: f64}?.list?.[list]
 {foo: f64}?.ok
+{foo: f64}?.ok?.foo
 {foo: f64}?.str
 {foo: f64}?.str?.i
 {foo: false != $env}
 {foo: false != false}
 {foo: false != nil}
+{foo: false != ok}
+{foo: false != true}
 {foo: false && $env}
 {foo: false == false}
 {foo: false == nil}
+{foo: false == ok}
 {foo: false == true}
 {foo: false ? foo : i}
 {foo: false ? foo : ok}
@@ -20628,98 +40747,170 @@ values({foo: str})
 {foo: false ? list : f64}
 {foo: false ? ok : f64}
 {foo: false ?: foo}
+{foo: false ?: greet}
+{foo: false ?? $env}
+{foo: false ?? 0}
+{foo: false ?? 1.0}
+{foo: false ?? 1}
+{foo: false ?? array}
+{foo: false ?? f64}.str
+{foo: false ?? false}
+{foo: false ?? foo}
+{foo: false ?? i}
+{foo: false ?? list}
+{foo: false ?? nil, foo: array}
+{foo: false ?? nil}
 {foo: false and $env}
 {foo: false and false}
+{foo: false and ok}
+{foo: false and true}
 {foo: false or $env}
+{foo: false or false}
 {foo: false or ok}
 {foo: false or true}
 {foo: false || $env}
+{foo: false || true}
+{foo: false, foo: $env, foo: foo}?.str
 {foo: false, foo: $env, foo: true}.foo
+{foo: false, foo: $env}.Bar
 {foo: false, foo: $env}.String
+{foo: false, foo: $env}.f64
 {foo: false, foo: $env}.foo
 {foo: false, foo: $env}.greet
+{foo: false, foo: $env}.list
+{foo: false, foo: $env}.ok
+{foo: false, foo: $env}?.Bar
 {foo: false, foo: $env}?.String
 {foo: false, foo: $env}?.[str]
+{foo: false, foo: $env}?.greet
 {foo: false, foo: $env}?.list
+{foo: false, foo: $env}?.str
 {foo: false, foo: 0, foo: $env}?.list
 {foo: false, foo: 0, foo: 0}.str
+{foo: false, foo: 0}.f64
+{foo: false, foo: 0}.greet
+{foo: false, foo: 0}?.array
+{foo: false, foo: 0}?.list
 {foo: false, foo: 1.0, foo: $env}.add
 {foo: false, foo: 1.0}.Bar
+{foo: false, foo: 1.0}.String
 {foo: false, foo: 1.0}.array
+{foo: false, foo: 1.0}.foo
 {foo: false, foo: 1.0}.greet
+{foo: false, foo: 1.0}.str
 {foo: false, foo: 1.0}?.String
 {foo: false, foo: 1.0}?.[str]
 {foo: false, foo: 1.0}?.ok
+{foo: false, foo: 1.0}?.str
 {foo: false, foo: 1.0}?.str?.[f64]
+{foo: false, foo: 1}.String
 {foo: false, foo: 1}.add
+{foo: false, foo: 1}.foo
 {foo: false, foo: 1}.i
 {foo: false, foo: 1}.list?.[greet]
 {foo: false, foo: 1}.ok
 {foo: false, foo: 1}?.String
 {foo: false, foo: 1}?.i
+{foo: false, foo: add}.array
 {foo: false, foo: add}?.String
 {foo: false, foo: add}?.f64
 {foo: false, foo: add}?.foo
+{foo: false, foo: add}?.greet
 {foo: false, foo: array, foo: foo}?.Bar
+{foo: false, foo: array}.Bar?.[greet]
 {foo: false, foo: array}.foo
+{foo: false, foo: array}.ok
 {foo: false, foo: array}?.Bar
 {foo: false, foo: array}?.greet
+{foo: false, foo: array}?.i
 {foo: false, foo: array}?.ok
 {foo: false, foo: array}?.str?.greet
 {foo: false, foo: f64, foo: 1.0}.list
+{foo: false, foo: f64}.Bar
 {foo: false, foo: f64}.greet
 {foo: false, foo: f64}.i
+{foo: false, foo: f64}?.str
 {foo: false, foo: f64}?.str?.f64
 {foo: false, foo: false, foo: foo}?.Bar
+{foo: false, foo: false}.Bar
 {foo: false, foo: false}?.f64
 {foo: false, foo: false}?.foo
+{foo: false, foo: false}?.greet?.[foo]?.str
 {foo: false, foo: false}?.ok
+{foo: false, foo: foo, foo: add}.Bar
 {foo: false, foo: foo, foo: foo}.str
 {foo: false, foo: foo, foo: greet}.f64
 {foo: false, foo: foo}.Bar
 {foo: false, foo: foo}.array
 {foo: false, foo: foo}.f64
+{foo: false, foo: foo}.foo
+{foo: false, foo: foo}.greet
 {foo: false, foo: foo}.i
 {foo: false, foo: foo}.list
+{foo: false, foo: foo}.ok
 {foo: false, foo: foo}.str
 {foo: false, foo: foo}?.Bar
 {foo: false, foo: foo}?.[str]
 {foo: false, foo: foo}?.add
+{foo: false, foo: foo}?.array
 {foo: false, foo: foo}?.foo
+{foo: false, foo: foo}?.i
+{foo: false, foo: foo}?.str
+{foo: false, foo: greet}.Bar
+{foo: false, foo: greet}.add
 {foo: false, foo: greet}.array
 {foo: false, foo: greet}.greet
+{foo: false, foo: greet}.i
 {foo: false, foo: greet}.str
 {foo: false, foo: greet}?.array
 {foo: false, foo: greet}?.foobar
+{foo: false, foo: greet}?.ok
 {foo: false, foo: greet}?.str
+{foo: false, foo: i}.list
+{foo: false, foo: i}.ok
 {foo: false, foo: i}.str
 {foo: false, foo: i}?.Bar
+{foo: false, foo: i}?.foo
 {foo: false, foo: i}?.greet
+{foo: false, foo: i}?.i
+{foo: false, foo: i}?.list
+{foo: false, foo: list, foo: f64}?.str
 {foo: false, foo: list, foo: list}?.array
 {foo: false, foo: list}.foobar
 {foo: false, foo: list}?.[str]
+{foo: false, foo: list}?.add
 {foo: false, foo: list}?.array?.foo
 {foo: false, foo: nil}.Bar
 {foo: false, foo: nil}.String
 {foo: false, foo: nil}.add
+{foo: false, foo: nil}.foo
 {foo: false, foo: nil}.foobar?.str
 {foo: false, foo: nil}.greet
 {foo: false, foo: nil}?.String?.array
 {foo: false, foo: nil}?.add
 {foo: false, foo: nil}?.foo
 {foo: false, foo: nil}?.list
+{foo: false, foo: nil}?.ok
+{foo: false, foo: nil}?.str
+{foo: false, foo: ok}.add
 {foo: false, foo: ok}.list
 {foo: false, foo: ok}?.String
+{foo: false, foo: ok}?.[str]
+{foo: false, foo: ok}?.array
 {foo: false, foo: ok}?.greet
+{foo: false, foo: ok}?.i
 {foo: false, foo: str}.array
 {foo: false, foo: str}?.Bar
+{foo: false, foo: str}?.String
 {foo: false, foo: str}?.[str]
 {foo: false, foo: true}.Bar
 {foo: false, foo: true}.add
+{foo: false, foo: true}.array
 {foo: false, foo: true}.ok
 {foo: false, foo: true}?.array
 {foo: false, foo: true}?.list
 {foo: false, foo: true}?.ok
+{foo: false} ?? list
 {foo: false}.Bar
 {foo: false}.String
 {foo: false}.String?.[i]
@@ -20728,14 +40919,20 @@ values({foo: str})
 {foo: false}.array?.greet(foobar)
 {foo: false}.f64
 {foo: false}.f64?.Bar
+{foo: false}.f64?.[ok]
+{foo: false}.f64?.list
 {foo: false}.foo
 {foo: false}.foobar
 {foo: false}.greet
 {foo: false}.i
+{foo: false}.i?.Bar
 {foo: false}.list
+{foo: false}.list?.str
 {foo: false}.ok
 {foo: false}.ok == i
+{foo: false}.ok?.f64
 {foo: false}.str
+{foo: false}.str?.array
 {foo: false}?.$env?.array
 {foo: false}?.Bar
 {foo: false}?.String
@@ -20743,23 +40940,34 @@ values({foo: str})
 {foo: false}?.add
 {foo: false}?.array
 {foo: false}?.f64
+{foo: false}?.f64?.Bar
+{foo: false}?.f64?.array()
 {foo: false}?.foo
 {foo: false}?.foobar
+{foo: false}?.foobar?.foo
 {foo: false}?.greet
+{foo: false}?.greet?.greet
 {foo: false}?.i
+{foo: false}?.i?.[foo]
 {foo: false}?.list
 {foo: false}?.ok
+{foo: false}?.ok?.[foo]
 {foo: false}?.str
+{foo: false}?.str?.[f64]
 {foo: false}?.str?.[list]
 {foo: filter($env, false)}
+{foo: filter(array, ok)}
 {foo: filter(list, ok)}
 {foo: filter(list, true)}
 {foo: find(array, false)}
+{foo: find(array, ok)}
 {foo: find(array, true)}
+{foo: find(list, false)}.str
 {foo: find(list, true), foo: foo}
 {foo: findIndex($env, ok)}
 {foo: findIndex($env, true)}
 {foo: findIndex(array, ok)}
+{foo: findIndex(list, ok)}
 {foo: findIndex(list, true)}
 {foo: first($env)}
 {foo: first($env)}?.foo
@@ -20772,65 +40980,120 @@ values({foo: str})
 {foo: float(1.0)}
 {foo: float(1.0)}.i
 {foo: float(1.0)}?.String
+{foo: float(f64), foo: f64}
 {foo: float(f64)}
 {foo: float(i)}
 {foo: floor(0)}
+{foo: floor(1), foo: nil == foo}
 {foo: floor(1)}
 {foo: floor(1.0)}
 {foo: floor(f64)}
 {foo: floor(f64)}.add
 {foo: floor(i)}
 {foo: foo != $env}
+{foo: foo != $env}.list
+{foo: foo != foo, foo: greet}
 {foo: foo != foo}
+{foo: foo != foo}?.greet
 {foo: foo != nil}
 {foo: foo == $env}
 {foo: foo == foo}
 {foo: foo == nil}
+{foo: foo ?? $env.foo}
+{foo: foo ?? $env}
+{foo: foo ?? 0}
+{foo: foo ?? 1.0}
+{foo: foo ?? 1}
+{foo: foo ?? add}
+{foo: foo ?? array}
+{foo: foo ?? f64}
+{foo: foo ?? foo}
+{foo: foo ?? greet}
+{foo: foo ?? i}
+{foo: foo ?? list}
+{foo: foo ?? nil, foo: ok}
+{foo: foo ?? nil}
+{foo: foo ?? ok}
+{foo: foo in list}
+{foo: foo not in list, foo: f64}.i
 {foo: foo not in list}
+{foo: foo, foo: $env, foo: 1}?.str
+{foo: foo, foo: $env, foo: add}.foo
+{foo: foo, foo: $env, foo: nil}?.f64
 {foo: foo, foo: $env, foo: ok}?.array
 {foo: foo, foo: $env.f64}.greet
+{foo: foo, foo: $env.greet}
+{foo: foo, foo: $env?.[foobar]}
 {foo: foo, foo: $env?.f64}
 {foo: foo, foo: $env}.Bar
+{foo: foo, foo: $env}.String?.str
+{foo: foo, foo: $env}.add
 {foo: foo, foo: $env}.array
+{foo: foo, foo: $env}.f64
 {foo: foo, foo: $env}.foo
+{foo: foo, foo: $env}.greet
 {foo: foo, foo: $env}.list
 {foo: foo, foo: $env}.nil?.[foo]
 {foo: foo, foo: $env}.ok
+{foo: foo, foo: $env}.str
 {foo: foo, foo: $env}?.Bar
 {foo: foo, foo: $env}?.String
 {foo: foo, foo: $env}?.[str]
+{foo: foo, foo: $env}?.add
 {foo: foo, foo: $env}?.array
 {foo: foo, foo: $env}?.f64
 {foo: foo, foo: $env}?.foo
+{foo: foo, foo: $env}?.greet
 {foo: foo, foo: $env}?.i
+{foo: foo, foo: $env}?.list
 {foo: foo, foo: $env}?.ok
 {foo: foo, foo: $env}?.str != foo
+{foo: foo, foo: 0, foo: add}?.str
+{foo: foo, foo: 0} ?? greet
+{foo: foo, foo: 0}.Bar
+{foo: foo, foo: 0}.String
 {foo: foo, foo: 0}.foo
+{foo: foo, foo: 0}.foobar
+{foo: foo, foo: 0}.greet
+{foo: foo, foo: 0}.ok
+{foo: foo, foo: 0}.str
+{foo: foo, foo: 0}?.$env?.[list]
 {foo: foo, foo: 0}?.Bar
+{foo: foo, foo: 0}?.String
+{foo: foo, foo: 0}?.[str]
 {foo: foo, foo: 0}?.add
 {foo: foo, foo: 0}?.f64
+{foo: foo, foo: 0}?.foo
 {foo: foo, foo: 0}?.greet
+{foo: foo, foo: 0}?.list
 {foo: foo, foo: 1, foo: greet}?.str
 {foo: foo, foo: 1, foo: list}?.str
+{foo: foo, foo: 1.0 - 1.0}
 {foo: foo, foo: 1.0, foo: array}.str
 {foo: foo, foo: 1.0}.Bar
+{foo: foo, foo: 1.0}.String
 {foo: foo, foo: 1.0}.add
 {foo: foo, foo: 1.0}.array
 {foo: foo, foo: 1.0}.f64
 {foo: foo, foo: 1.0}.foo
 {foo: foo, foo: 1.0}.greet
 {foo: foo, foo: 1.0}.i
+{foo: foo, foo: 1.0}.i?.list
 {foo: foo, foo: 1.0}.list
 {foo: foo, foo: 1.0}.ok
 {foo: foo, foo: 1.0}.str
+{foo: foo, foo: 1.0}?.Bar
 {foo: foo, foo: 1.0}?.String
 {foo: foo, foo: 1.0}?.[str]
 {foo: foo, foo: 1.0}?.add
+{foo: foo, foo: 1.0}?.add?.ok
 {foo: foo, foo: 1.0}?.array
 {foo: foo, foo: 1.0}?.f64
 {foo: foo, foo: 1.0}?.foo
 {foo: foo, foo: 1.0}?.greet
 {foo: foo, foo: 1.0}?.list
+{foo: foo, foo: 1.0}?.ok?.[add]
+{foo: foo, foo: 1.0}?.str
 {foo: foo, foo: 1}.Bar
 {foo: foo, foo: 1}.String
 {foo: foo, foo: 1}.add
@@ -20839,48 +41102,94 @@ values({foo: str})
 {foo: foo, foo: 1}.i
 {foo: foo, foo: 1}.list
 {foo: foo, foo: 1}.ok
+{foo: foo, foo: 1}.str
+{foo: foo, foo: 1}?.add
 {foo: foo, foo: 1}?.f64
+{foo: foo, foo: 1}?.foo
+{foo: foo, foo: 1}?.list
+{foo: foo, foo: 1}?.ok
 {foo: foo, foo: 1}?.str
 {foo: foo, foo: [$env?.add]}
+{foo: foo, foo: add, foo: foo}?.add
 {foo: foo, foo: add, foo: nil}.f64
 {foo: foo, foo: add}
 {foo: foo, foo: add}.array
 {foo: foo, foo: add}.f64
+{foo: foo, foo: add}.foo
+{foo: foo, foo: add}.greet
 {foo: foo, foo: add}.i
 {foo: foo, foo: add}.list
+{foo: foo, foo: add}.str
 {foo: foo, foo: add}?.String
+{foo: foo, foo: add}?.add
 {foo: foo, foo: add}?.f64
+{foo: foo, foo: add}?.list
+{foo: foo, foo: add}?.ok
+{foo: foo, foo: add}?.str
+{foo: foo, foo: array, foo: false}?.greet
 {foo: foo, foo: array, foo: i}.f64
 {foo: foo, foo: array}
+{foo: foo, foo: array}.Bar
 {foo: foo, foo: array}.String
+{foo: foo, foo: array}.f64
 {foo: foo, foo: array}.foo
 {foo: foo, foo: array}.greet
+{foo: foo, foo: array}.i
 {foo: foo, foo: array}.list
+{foo: foo, foo: array}.ok
+{foo: foo, foo: array}.str
 {foo: foo, foo: array}?.String
 {foo: foo, foo: array}?.[str]
+{foo: foo, foo: array}?.add
+{foo: foo, foo: array}?.array
 {foo: foo, foo: array}?.foo
 {foo: foo, foo: array}?.greet
+{foo: foo, foo: array}?.greet?.list
 {foo: foo, foo: array}?.i
+{foo: foo, foo: array}?.ok
 {foo: foo, foo: f64, foo: 1.0}?.array
 {foo: foo, foo: f64}
 {foo: foo, foo: f64}.String
+{foo: foo, foo: f64}.add
 {foo: foo, foo: f64}.array
+{foo: foo, foo: f64}.f64
+{foo: foo, foo: f64}.i
 {foo: foo, foo: f64}.list
 {foo: foo, foo: f64}.list?.[i]
+{foo: foo, foo: f64}?.Bar
+{foo: foo, foo: f64}?.String
 {foo: foo, foo: f64}?.add
 {foo: foo, foo: f64}?.f64
 {foo: foo, foo: f64}?.foo
+{foo: foo, foo: f64}?.ok
+{foo: foo, foo: f64}?.str
+{foo: foo, foo: false, foo: list}?.str?.add
+{foo: foo, foo: false}.Bar
 {foo: foo, foo: false}.String
+{foo: foo, foo: false}.array
 {foo: foo, foo: false}.f64
+{foo: foo, foo: false}.foo
+{foo: foo, foo: false}.greet
+{foo: foo, foo: false}.i
+{foo: foo, foo: false}.list
+{foo: foo, foo: false}.ok
 {foo: foo, foo: false}.str
+{foo: foo, foo: false}?.[str]
+{foo: foo, foo: false}?.add
 {foo: foo, foo: false}?.foo
 {foo: foo, foo: false}?.i
+{foo: foo, foo: false}?.ok
+{foo: foo, foo: false}?.str
+{foo: foo, foo: foo, foo: $env}.String
+{foo: foo, foo: foo, foo: add}?.f64
 {foo: foo, foo: foo, foo: foo}.greet
 {foo: foo, foo: foo, foo: greet}
+{foo: foo, foo: foo, foo: nil}.Bar
 {foo: foo, foo: foo, foo: ok}?.str
 {foo: foo, foo: foo.Bar}
 {foo: foo, foo: foo}
 {foo: foo, foo: foo}.Bar
+{foo: foo, foo: foo}.Bar?.[f64]
 {foo: foo, foo: foo}.String
 {foo: foo, foo: foo}.add
 {foo: foo, foo: foo}.array
@@ -20890,27 +41199,35 @@ values({foo: str})
 {foo: foo, foo: foo}.list
 {foo: foo, foo: foo}.ok
 {foo: foo, foo: foo}.str
+{foo: foo, foo: foo}?.Bar
 {foo: foo, foo: foo}?.String
 {foo: foo, foo: foo}?.[str]
 {foo: foo, foo: foo}?.add
 {foo: foo, foo: foo}?.array
 {foo: foo, foo: foo}?.f64
+{foo: foo, foo: foo}?.foo
+{foo: foo, foo: foo}?.foobar
 {foo: foo, foo: foo}?.greet
+{foo: foo, foo: foo}?.list
 {foo: foo, foo: foo}?.list?.f64
 {foo: foo, foo: foo}?.ok
 {foo: foo, foo: foo}?.str
 {foo: foo, foo: greet, foo: 1.0}.list
+{foo: foo, foo: greet, foo: foo}?.i
 {foo: foo, foo: greet}
 {foo: foo, foo: greet}.Bar
 {foo: foo, foo: greet}.String
+{foo: foo, foo: greet}.add
 {foo: foo, foo: greet}.array
 {foo: foo, foo: greet}.foo
 {foo: foo, foo: greet}.greet
 {foo: foo, foo: greet}.i
 {foo: foo, foo: greet}.str
+{foo: foo, foo: greet}?.Bar
 {foo: foo, foo: greet}?.array
 {foo: foo, foo: greet}?.f64
 {foo: foo, foo: greet}?.foo
+{foo: foo, foo: greet}?.greet
 {foo: foo, foo: greet}?.list
 {foo: foo, foo: i / f64}
 {foo: foo, foo: i, foo: 0}.ok
@@ -20921,14 +41238,21 @@ values({foo: str})
 {foo: foo, foo: i}.String?.String
 {foo: foo, foo: i}.add
 {foo: foo, foo: i}.foo
+{foo: foo, foo: i}.str
+{foo: foo, foo: i}?.String
 {foo: foo, foo: i}?.[str]
+{foo: foo, foo: i}?.array
 {foo: foo, foo: i}?.f64
+{foo: foo, foo: i}?.foo
+{foo: foo, foo: i}?.foobar
 {foo: foo, foo: i}?.greet
 {foo: foo, foo: i}?.ok
 {foo: foo, foo: i}?.str
+{foo: foo, foo: list != list}
 {foo: foo, foo: list, foo: false and false}
 {foo: foo, foo: list, foo: greet}?.f64
 {foo: foo, foo: list}
+{foo: foo, foo: list}.String
 {foo: foo, foo: list}.add?.[i]
 {foo: foo, foo: list}.array
 {foo: foo, foo: list}.array?.Bar
@@ -20937,78 +41261,132 @@ values({foo: str})
 {foo: foo, foo: list}.ok
 {foo: foo, foo: list}.str
 {foo: foo, foo: list}?.Bar
+{foo: foo, foo: list}?.[str]
 {foo: foo, foo: list}?.add
+{foo: foo, foo: list}?.array
+{foo: foo, foo: list}?.f64
 {foo: foo, foo: list}?.greet
+{foo: foo, foo: list}?.i
 {foo: foo, foo: list}?.list
 {foo: foo, foo: list}?.str
+{foo: foo, foo: list}?.str?.array(1.0)
+{foo: foo, foo: median(0)}
 {foo: foo, foo: nil in $env}
 {foo: foo, foo: nil, foo: 0}.f64
 {foo: foo, foo: nil, foo: 0}?.f64?.i()
+{foo: foo, foo: nil, foo: 1}.greet
 {foo: foo, foo: nil, foo: nil}.f64
+{foo: foo, foo: nil, foo: nil}.list
 {foo: foo, foo: nil, foo: ok}?.list
+{foo: foo, foo: nil}.Bar
 {foo: foo, foo: nil}.String
 {foo: foo, foo: nil}.add
 {foo: foo, foo: nil}.array
 {foo: foo, foo: nil}.f64
 {foo: foo, foo: nil}.foo
+{foo: foo, foo: nil}.foobar?.[array]
+{foo: foo, foo: nil}.foobar?.[list]
 {foo: foo, foo: nil}.i
+{foo: foo, foo: nil}.i?.array
+{foo: foo, foo: nil}.list
 {foo: foo, foo: nil}.ok
 {foo: foo, foo: nil}.ok?.array()
 {foo: foo, foo: nil}.str
+{foo: foo, foo: nil}?.String
 {foo: foo, foo: nil}?.[str]
 {foo: foo, foo: nil}?.add
+{foo: foo, foo: nil}?.array
+{foo: foo, foo: nil}?.f64
+{foo: foo, foo: nil}?.foo
 {foo: foo, foo: nil}?.greet
 {foo: foo, foo: nil}?.i
 {foo: foo, foo: nil}?.list
+{foo: foo, foo: nil}?.ok
+{foo: foo, foo: nil}?.str
+{foo: foo, foo: ok, foo: 1}.Bar?.i(foobar)
+{foo: foo, foo: ok, foo: f64}.foo
 {foo: foo, foo: ok}
+{foo: foo, foo: ok}.String
 {foo: foo, foo: ok}.add
+{foo: foo, foo: ok}.array
+{foo: foo, foo: ok}.i
+{foo: foo, foo: ok}.list
 {foo: foo, foo: ok}?.String
 {foo: foo, foo: ok}?.[str]
 {foo: foo, foo: ok}?.add
 {foo: foo, foo: ok}?.array
 {foo: foo, foo: ok}?.f64
+{foo: foo, foo: ok}?.foo
+{foo: foo, foo: ok}?.i
+{foo: foo, foo: ok}?.list
+{foo: foo, foo: ok}?.str
 {foo: foo, foo: str, foo: 1.0}.Bar
+{foo: foo, foo: str, foo: foo}?.f64
 {foo: foo, foo: str, foo: list}?.String
 {foo: foo, foo: str}
 {foo: foo, foo: str}.String
+{foo: foo, foo: str}.f64
 {foo: foo, foo: str}.i
 {foo: foo, foo: str}.ok
 {foo: foo, foo: str}?.Bar
 {foo: foo, foo: str}?.add
 {foo: foo, foo: str}?.array
+{foo: foo, foo: str}?.f64
 {foo: foo, foo: str}?.f64?.ok
 {foo: foo, foo: str}?.foo
 {foo: foo, foo: str}?.greet
+{foo: foo, foo: str}?.greet?.[i]
+{foo: foo, foo: str}?.i
 {foo: foo, foo: str}?.str
 {foo: foo, foo: true, foo: $env}?.add
+{foo: foo, foo: true, foo: array}.ok
 {foo: foo, foo: true, foo: nil}?.Bar
 {foo: foo, foo: true, foo: nil}?.i
 {foo: foo, foo: true}.Bar
 {foo: foo, foo: true}.add
+{foo: foo, foo: true}.add?.[array]
 {foo: foo, foo: true}.foo
+{foo: foo, foo: true}.greet?.Bar
+{foo: foo, foo: true}.i
+{foo: foo, foo: true}.str
+{foo: foo, foo: true}?.Bar
 {foo: foo, foo: true}?.String
 {foo: foo, foo: true}?.[str]
 {foo: foo, foo: true}?.add
+{foo: foo, foo: true}?.array
 {foo: foo, foo: true}?.f64
 {foo: foo, foo: true}?.list
+{foo: foo, foo: true}?.list?.[i].Bar()
+{foo: foo, foo: true}?.ok
 {foo: foo, foo: true}?.str?.i
 {foo: foo, foo: {foo: foo}}
 {foo: foo.Bar, foo: false ? foo : str}?.ok
 {foo: foo.Bar, foo: greet}
+{foo: foo.Bar, foo: list}
 {foo: foo.Bar}
 {foo: foo.Bar}.greet
+{foo: foo.Bar}.list
 {foo: foo.Bar}?.f64
 {foo: foo.String() not matches str}
 {foo: foo.String()}
+{foo: foo.String()}?.ok
 {foo: foo.String, foo: ok}
+{foo: foo.String, foo: str}
 {foo: foo.String}
 {foo: foo.String}.String
 {foo: foo.String}.add
 {foo: foo.String}.array
+{foo: foo.String}.greet
 {foo: foo.String}.str
+{foo: foo.String}?.add
+{foo: foo.String}?.str
+{foo: foo?.Bar, foo: add}
 {foo: foo?.Bar}
 {foo: foo?.Bar}?.list
+{foo: foo?.String(), foo: i}
 {foo: foo?.String()}
+{foo: foo?.String()}.Bar
+{foo: foo?.String()}?.list
 {foo: foo?.String, foo: f64}
 {foo: foo?.String, foo: greet}
 {foo: foo?.String, foo: str}
@@ -21016,16 +41394,29 @@ values({foo: str})
 {foo: foo?.String}.array
 {foo: foo?.String}?.Bar
 {foo: foo}
+{foo: foo} ?? $env?.f64
+{foo: foo} ?? add
+{foo: foo} ?? greet
+{foo: foo} ?? ok
 {foo: foo}.Bar
 {foo: foo}.String
+{foo: foo}.String != str
+{foo: foo}.String?.[i]
 {foo: foo}.add
+{foo: foo}.add?.add()
 {foo: foo}.array
 {foo: foo}.array?.[str]
+{foo: foo}.array?.foo
 {foo: foo}.array?.greet()
 {foo: foo}.array?.i
 {foo: foo}.f64
+{foo: foo}.f64?.Bar
 {foo: foo}.f64?.[array]
+{foo: foo}.f64?.[f64]
+{foo: foo}.f64?.add
 {foo: foo}.f64?.i
+{foo: foo}.f64?.ok
+{foo: foo}.f64?.str
 {foo: foo}.false?.f64
 {foo: foo}.foo
 {foo: foo}.foobar
@@ -21033,39 +41424,69 @@ values({foo: str})
 {foo: foo}.greet
 {foo: foo}.greet != f64
 {foo: foo}.greet?.[f64]
+{foo: foo}.greet?.[i]
 {foo: foo}.greet?.[ok]
+{foo: foo}.greet?.array()
 {foo: foo}.i
+{foo: foo}.i?.[f64]
+{foo: foo}.i?.add
 {foo: foo}.list
 {foo: foo}.list?.[f64]
 {foo: foo}.list?.[str]?.foobar
+{foo: foo}.list?.str
 {foo: foo}.ok
 {foo: foo}.ok?.[add].add()
 {foo: foo}.ok?.f64
+{foo: foo}.ok?.ok
 {foo: foo}.str
+{foo: foo}.str?.String
+{foo: foo}.str?.[array]
+{foo: foo}.str?.greet
 {foo: foo}?.Bar
 {foo: foo}?.String
 {foo: foo}?.String?.Bar
 {foo: foo}?.String?.String()
+{foo: foo}?.String?.array.str
 {foo: foo}?.[str]
 {foo: foo}?.[str]?.String
 {foo: foo}?.add
 {foo: foo}?.add?.f64(foobar, foobar)
+{foo: foo}?.add?.i
+{foo: foo}?.add?.ok
+{foo: foo}?.add?.str
 {foo: foo}?.array
+{foo: foo}?.array?.String?.[foo]
+{foo: foo}?.array?.[foo]
 {foo: foo}?.array?.i
 {foo: foo}?.f64
+{foo: foo}?.f64?.[add]
+{foo: foo}?.f64?.[list]
+{foo: foo}?.f64?.[ok]
 {foo: foo}?.f64?.str
 {foo: foo}?.foo
 {foo: foo}?.foobar
 {foo: foo}?.foobar == foo
+{foo: foo}?.foobar?.[add]
+{foo: foo}?.foobar?.[array]
+{foo: foo}?.foobar?.array
+{foo: foo}?.foobar?.foo
 {foo: foo}?.foobar?.greet(foobar)
 {foo: foo}?.greet
+{foo: foo}?.greet?.String?.[greet]
 {foo: foo}?.greet?.[f64]
 {foo: foo}?.greet?.[i]
+{foo: foo}?.greet?.[str]
 {foo: foo}?.i
+{foo: foo}?.i?.[add]
+{foo: foo}?.i?.ok
 {foo: foo}?.list
 {foo: foo}?.list?.[add]?.str
+{foo: foo}?.list?.add
+{foo: foo}?.list?.foo
+{foo: foo}?.list?.list
 {foo: foo}?.ok
 {foo: foo}?.ok?.Bar
+{foo: foo}?.ok?.String
 {foo: foo}?.ok?.[i]
 {foo: foo}?.ok?.f64()
 {foo: foo}?.ok?.greet()?.f64()
@@ -21074,27 +41495,57 @@ values({foo: str})
 {foo: foo}?.str?.add
 {foo: foo}?.str?.f64
 {foo: greet != $env}
+{foo: greet != greet}.foo
 {foo: greet != nil}
 {foo: greet == $env}
 {foo: greet == greet}
+{foo: greet ?? $env}
+{foo: greet ?? 0}
+{foo: greet ?? 1.0}
+{foo: greet ?? 1}
+{foo: greet ?? add}
+{foo: greet ?? f64, foo: i}
+{foo: greet ?? f64}
+{foo: greet ?? false}
+{foo: greet ?? foo}
+{foo: greet ?? greet}
+{foo: greet ?? nil}
 {foo: greet($env?.[str])}
+{foo: greet(str), foo: array}
 {foo: greet(str)}
+{foo: greet(str)}.String
+{foo: greet(str)}.ok
 {foo: greet(str)}.str
+{foo: greet, foo: !false}
+{foo: greet, foo: $env.array}
 {foo: greet, foo: $env.f64}
+{foo: greet, foo: $env.ok}
+{foo: greet, foo: $env.str}
 {foo: greet, foo: $env?.ok}
 {foo: greet, foo: $env?.str}
+{foo: greet, foo: $env}.Bar
+{foo: greet, foo: $env}.Bar?.add
 {foo: greet, foo: $env}.String
 {foo: greet, foo: $env}.add
+{foo: greet, foo: $env}.greet
 {foo: greet, foo: $env}.str
 {foo: greet, foo: $env}?.String
+{foo: greet, foo: $env}?.add
 {foo: greet, foo: $env}?.array
 {foo: greet, foo: $env}?.greet
+{foo: greet, foo: $env}?.list
 {foo: greet, foo: $env}?.ok
+{foo: greet, foo: 0, foo: foo}?.String
+{foo: greet, foo: 0}.String
 {foo: greet, foo: 0}.foo
+{foo: greet, foo: 0}.i
 {foo: greet, foo: 0}?.Bar
 {foo: greet, foo: 0}?.add
 {foo: greet, foo: 0}?.f64
 {foo: greet, foo: 0}?.ok
+{foo: greet, foo: 1 ** f64}
+{foo: greet, foo: 1, foo: $env}?.Bar
+{foo: greet, foo: 1.0}.Bar
 {foo: greet, foo: 1.0}.String
 {foo: greet, foo: 1.0}.i
 {foo: greet, foo: 1.0}.ok
@@ -21102,28 +41553,56 @@ values({foo: str})
 {foo: greet, foo: 1.0}?.Bar
 {foo: greet, foo: 1.0}?.String
 {foo: greet, foo: 1.0}?.array
+{foo: greet, foo: 1.0}?.f64?.[i]
 {foo: greet, foo: 1.0}?.list
 {foo: greet, foo: 1.0}?.str
+{foo: greet, foo: 1}.Bar
+{foo: greet, foo: 1}.foo
+{foo: greet, foo: 1}.list
 {foo: greet, foo: 1}?.[str]
+{foo: greet, foo: 1}?.i
 {foo: greet, foo: 1}?.ok
 {foo: greet, foo: [$env]}
 {foo: greet, foo: add}
+{foo: greet, foo: add}.array
 {foo: greet, foo: add}.foo
+{foo: greet, foo: add}?.add
+{foo: greet, foo: add}?.add?.[add]
 {foo: greet, foo: add}?.f64
+{foo: greet, foo: add}?.foo
+{foo: greet, foo: add}?.i
 {foo: greet, foo: array}
+{foo: greet, foo: array} ?? add
+{foo: greet, foo: array}.String
 {foo: greet, foo: array}.array
+{foo: greet, foo: array}.foo
 {foo: greet, foo: array}?.array
 {foo: greet, foo: f64}
+{foo: greet, foo: f64}.String
+{foo: greet, foo: f64}.greet
+{foo: greet, foo: f64}.i
+{foo: greet, foo: f64}?.Bar
+{foo: greet, foo: f64}?.String
+{foo: greet, foo: f64}?.i
+{foo: greet, foo: f64}?.list
+{foo: greet, foo: false == nil}
+{foo: greet, foo: false, foo: add}.Bar
 {foo: greet, foo: false, foo: foo}.String
+{foo: greet, foo: false}.add
+{foo: greet, foo: false}.array
 {foo: greet, foo: false}.f64
 {foo: greet, foo: false}.greet
+{foo: greet, foo: false}.ok
 {foo: greet, foo: false}.str
+{foo: greet, foo: false}?.[str]
 {foo: greet, foo: false}?.f64
 {foo: greet, foo: false}?.str
 {foo: greet, foo: float(f64)}
 {foo: greet, foo: foo != foo}
+{foo: greet, foo: foo ?? f64}
 {foo: greet, foo: foo, foo: array}
 {foo: greet, foo: foo, foo: greet}?.add
+{foo: greet, foo: foo.Bar}
 {foo: greet, foo: foo}
 {foo: greet, foo: foo}.String
 {foo: greet, foo: foo}.add
@@ -21133,59 +41612,109 @@ values({foo: str})
 {foo: greet, foo: foo}.i
 {foo: greet, foo: foo}.list
 {foo: greet, foo: foo}.ok
+{foo: greet, foo: foo}.ok?.list
+{foo: greet, foo: foo}?.Bar
+{foo: greet, foo: foo}?.Bar?.[ok]
+{foo: greet, foo: foo}?.String
+{foo: greet, foo: foo}?.[str]
 {foo: greet, foo: foo}?.add
+{foo: greet, foo: foo}?.f64
 {foo: greet, foo: foo}?.foo
+{foo: greet, foo: foo}?.greet
 {foo: greet, foo: foo}?.i
 {foo: greet, foo: foo}?.list
+{foo: greet, foo: foo}?.list?.str
+{foo: greet, foo: foo}?.ok
+{foo: greet, foo: foo}?.str
+{foo: greet, foo: greet(str)}
 {foo: greet, foo: greet}
 {foo: greet, foo: greet}?.str
 {foo: greet, foo: i == 1.0}
 {foo: greet, foo: i}
+{foo: greet, foo: i}.list
 {foo: greet, foo: i}?.String
 {foo: greet, foo: list}
+{foo: greet, foo: list}.Bar
 {foo: greet, foo: list}.list
+{foo: greet, foo: list}.str
+{foo: greet, foo: list}.true?.f64(false)
+{foo: greet, foo: list}?.add
+{foo: greet, foo: list}?.f64
+{foo: greet, foo: nil == str}
+{foo: greet, foo: nil}.add
+{foo: greet, foo: nil}.array
+{foo: greet, foo: nil}.f64
+{foo: greet, foo: nil}.f64?.[foo]
+{foo: greet, foo: nil}.foo(foobar?.[ok])
+{foo: greet, foo: nil}.greet
 {foo: greet, foo: nil}?.[str]
+{foo: greet, foo: nil}?.foo
 {foo: greet, foo: nil}?.greet
 {foo: greet, foo: nil}?.ok
 {foo: greet, foo: ok}
+{foo: greet, foo: ok}.foo
+{foo: greet, foo: ok}.i
 {foo: greet, foo: ok}?.array
+{foo: greet, foo: ok}?.f64
 {foo: greet, foo: ok}?.list
 {foo: greet, foo: ok}?.ok
 {foo: greet, foo: ok}?.str
 {foo: greet, foo: str}
 {foo: greet, foo: str}.Bar
+{foo: greet, foo: str}.String
+{foo: greet, foo: str}.add
+{foo: greet, foo: str}.foo
+{foo: greet, foo: str}.ok
 {foo: greet, foo: str}?.f64
 {foo: greet, foo: trimPrefix(str)}
+{foo: greet, foo: true}.Bar
 {foo: greet, foo: true}?.String
 {foo: greet, foo: true}?.greet
+{foo: greet, foo: true}?.ok
+{foo: greet, foo: true}?.str
 {foo: greet}
+{foo: greet} ?? 1 ?? 1.0
+{foo: greet} ?? add
 {foo: greet}.Bar
+{foo: greet}.Bar?.String
 {foo: greet}.Bar?.ok
 {foo: greet}.String
 {foo: greet}.String?.str()
 {foo: greet}.add
+{foo: greet}.add?.ok
 {foo: greet}.array
+{foo: greet}.array?.i
 {foo: greet}.f64
 {foo: greet}.f64?.String
+{foo: greet}.f64?.f64
 {foo: greet}.foo
 {foo: greet}.foobar
 {foo: greet}.foobar?.[1.0]
 {foo: greet}.foobar?.[foo]
+{foo: greet}.foobar?.foo()
+{foo: greet}.foobar?.str?.f64
 {foo: greet}.greet
 {foo: greet}.greet?.i
+{foo: greet}.greet?.str
 {foo: greet}.i
 {foo: greet}.list
+{foo: greet}.list?.Bar()
+{foo: greet}.list?.[f64]
+{foo: greet}.list?.list?.[f64]
 {foo: greet}.ok
 {foo: greet}.ok?.Bar
 {foo: greet}.ok?.add
 {foo: greet}.str
 {foo: greet}?.Bar
 {foo: greet}?.String
+{foo: greet}?.String?.String
 {foo: greet}?.[str]
 {foo: greet}?.add
+{foo: greet}?.add?.String
 {foo: greet}?.array
 {foo: greet}?.array?.[array]
 {foo: greet}?.f64
+{foo: greet}?.f64?.foo(array)
 {foo: greet}?.foo
 {foo: greet}?.foobar
 {foo: greet}?.foobar?.[foo]
@@ -21198,20 +41727,33 @@ values({foo: str})
 {foo: greet}?.list?.i
 {foo: greet}?.ok
 {foo: greet}?.ok?.[foo]
+{foo: greet}?.ok?.list
 {foo: greet}?.str
 {foo: groupBy(array, #)}
+{foo: groupBy(array, 0), foo: min($env)}
+{foo: groupBy(array, 1.0)}
 {foo: groupBy(array, f64)}
 {foo: groupBy(array, false)}
 {foo: groupBy(array, foo)}
 {foo: groupBy(list, #)}
+{foo: groupBy(list, #.Bar)}
+{foo: groupBy(list, 0)}
+{foo: groupBy(list, 1)}
 {foo: groupBy(list, foo)}
+{foo: groupBy(list, foo.String())}
 {foo: groupBy(list, i)}
 {foo: groupBy(list, ok)}
+{foo: groupBy(list, true)}
 {foo: i != $env}?.String
+{foo: i != 0}
 {foo: i != 1.0}
+{foo: i != f64}
+{foo: i != f64}?.ok
+{foo: i != i, foo: greet(str)}
 {foo: i % 1}
 {foo: i * 0}
 {foo: i * 1.0}
+{foo: i * 1}
 {foo: i * f64}
 {foo: i * i}
 {foo: i ** 1, foo: ok}.f64
@@ -21219,9 +41761,16 @@ values({foo: str})
 {foo: i ** 1}
 {foo: i ** f64}
 {foo: i + 0}
+{foo: i + 1.0}
+{foo: i + 1}
+{foo: i + 1}?.i
 {foo: i + f64}
+{foo: i + i}
+{foo: i - 0}
 {foo: i - 1}
+{foo: i .. 0}
 {foo: i .. 1, foo: i}
+{foo: i .. 1}
 {foo: i .. i}
 {foo: i / 0}
 {foo: i / 1, foo: string(false)}
@@ -21229,50 +41778,88 @@ values({foo: str})
 {foo: i < 0}
 {foo: i < 1.0}
 {foo: i < 1}
+{foo: i < f64}
+{foo: i < i}
+{foo: i <= 0}
 {foo: i <= 1.0}
 {foo: i <= f64}
+{foo: i <= i}
+{foo: i == $env}
 {foo: i == $env}?.Bar
+{foo: i == 1.0}
 {foo: i == nil}
 {foo: i > 0, foo: 1 >= f64}
+{foo: i >= 0}
 {foo: i >= 1.0}
 {foo: i >= 1}
+{foo: i >= f64}
 {foo: i >= f64}.str
+{foo: i ?? $env}
+{foo: i ?? 0}
+{foo: i ?? 1.0}
+{foo: i ?? array}
+{foo: i ?? foo}
+{foo: i ?? greet}
+{foo: i ?? str}
 {foo: i ^ 0}
 {foo: i ^ 1.0}
 {foo: i ^ 1}
+{foo: i ^ f64}
+{foo: i ^ i, foo: array}
 {foo: i ^ i}
 {foo: i not in array}
 {foo: i not in array}?.greet
 {foo: i | bitnand(1)}
 {foo: i | bitor(i)}
+{foo: i | bitushr(i)}
 {foo: i | bitxor(i)}
+{foo: i | median(i)}
 {foo: i, foo: $env != foo}
+{foo: i, foo: $env != ok}
 {foo: i, foo: $env, foo: nil}?.add
 {foo: i, foo: $env?.[Bar]}
+{foo: i, foo: $env}.add
 {foo: i, foo: $env}.foo
 {foo: i, foo: $env}.ok
+{foo: i, foo: $env}?.[str]
+{foo: i, foo: $env}?.list
+{foo: i, foo: 0 ?? f64}
+{foo: i, foo: 0}.String
 {foo: i, foo: 0}.greet
+{foo: i, foo: 0}?.Bar
+{foo: i, foo: 0}?.f64
 {foo: i, foo: 0}?.ok?.str
 {foo: i, foo: 1 - f64}
+{foo: i, foo: 1.0 < 0}
 {foo: i, foo: 1.0, foo: foo}?.[str]
 {foo: i, foo: 1.0, foo: foo}?.str
 {foo: i, foo: 1.0}.Bar
 {foo: i, foo: 1.0}.String
+{foo: i, foo: 1.0}.array
 {foo: i, foo: 1.0}.f64
 {foo: i, foo: 1.0}.f64?.ok
 {foo: i, foo: 1.0}.foobar?.ok
 {foo: i, foo: 1.0}.i
 {foo: i, foo: 1.0}.ok
+{foo: i, foo: 1.0}.str
 {foo: i, foo: 1.0}?.String
+{foo: i, foo: 1.0}?.add
 {foo: i, foo: 1.0}?.f64
+{foo: i, foo: 1.0}?.ok
 {foo: i, foo: 1.0}?.str
 {foo: i, foo: 1}.f64
 {foo: i, foo: 1}?.array
+{foo: i, foo: 1}?.list
+{foo: i, foo: 1}?.ok
 {foo: i, foo: add}
 {foo: i, foo: add}.i
 {foo: i, foo: add}.str
+{foo: i, foo: add}?.String
+{foo: i, foo: add}?.foo
+{foo: i, foo: add}?.i
 {foo: i, foo: add}?.str
 {foo: i, foo: array}
+{foo: i, foo: array}.f64
 {foo: i, foo: array}.greet
 {foo: i, foo: array}.i
 {foo: i, foo: array}.list
@@ -21282,52 +41869,106 @@ values({foo: str})
 {foo: i, foo: f64}.foo
 {foo: i, foo: f64}.foobar?.f64(foo)
 {foo: i, foo: f64}?.i
+{foo: i, foo: f64}?.list
+{foo: i, foo: f64}?.ok
 {foo: i, foo: false}.array
+{foo: i, foo: false}.f64?.array
 {foo: i, foo: false}.str
 {foo: i, foo: false}?.Bar
 {foo: i, foo: false}?.String
+{foo: i, foo: false}?.i
 {foo: i, foo: false}?.str
 {foo: i, foo: foo, foo: $env}.ok
+{foo: i, foo: foo?.String}
 {foo: i, foo: foo}
+{foo: i, foo: foo}.Bar
+{foo: i, foo: foo}.String
+{foo: i, foo: foo}.String?.array
+{foo: i, foo: foo}.array
+{foo: i, foo: foo}.f64
+{foo: i, foo: foo}.f64?.foo
+{foo: i, foo: foo}.greet
 {foo: i, foo: foo}.list
 {foo: i, foo: foo}?.String
+{foo: i, foo: foo}?.array
+{foo: i, foo: foo}?.greet
+{foo: i, foo: foo}?.i
 {foo: i, foo: foo}?.list
 {foo: i, foo: foo}?.list == foo
+{foo: i, foo: foo}?.ok
 {foo: i, foo: foo}?.str
 {foo: i, foo: greet(str)}
+{foo: i, foo: greet, foo: nil}?.Bar
 {foo: i, foo: greet}
+{foo: i, foo: greet}.Bar
 {foo: i, foo: greet}.foo
+{foo: i, foo: greet}.ok
+{foo: i, foo: greet}?.String
+{foo: i, foo: greet}?.f64
+{foo: i, foo: greet}?.list
+{foo: i, foo: greet}?.str
 {foo: i, foo: i >= 1}
+{foo: i, foo: i, foo: 0}?.ok
 {foo: i, foo: i}
+{foo: i, foo: i}.String
 {foo: i, foo: i}.f64
 {foo: i, foo: i}.foo
+{foo: i, foo: i}?.Bar
 {foo: i, foo: i}?.[str]
+{foo: i, foo: i}?.i
+{foo: i, foo: list | reduce(greet)}
 {foo: i, foo: list}
+{foo: i, foo: list}?.String
+{foo: i, foo: list}?.[str]
+{foo: i, foo: list}?.array
 {foo: i, foo: list}?.list
 {foo: i, foo: map(list, foo)}
+{foo: i, foo: nil, foo: true}.array
 {foo: i, foo: nil}.array
+{foo: i, foo: nil}.array?.f64
 {foo: i, foo: nil}.foo
 {foo: i, foo: nil}.list
 {foo: i, foo: nil}?.Bar
 {foo: i, foo: nil}?.[str]
+{foo: i, foo: nil}?.add
 {foo: i, foo: nil}?.foo
 {foo: i, foo: nil}?.list
 {foo: i, foo: ok, foo: 1.0}?.ok
+{foo: i, foo: ok, foo: ok}.greet?.list(array)
 {foo: i, foo: ok}
+{foo: i, foo: sortBy(array, #)}.i
 {foo: i, foo: str}
 {foo: i, foo: str}.array
+{foo: i, foo: str}.f64
 {foo: i, foo: str}.foo
 {foo: i, foo: str}.foobar?.i()
+{foo: i, foo: str}.i
+{foo: i, foo: str}?.Bar
+{foo: i, foo: str}?.add
 {foo: i, foo: str}?.add?.[str]
 {foo: i, foo: str}?.f64
+{foo: i, foo: str}?.greet
 {foo: i, foo: str}?.list
+{foo: i, foo: true, foo: add}.str
+{foo: i, foo: true, foo: foo}.Bar
 {foo: i, foo: true}.foo
 {foo: i, foo: true}?.f64
+{foo: i, foo: true}?.list
+{foo: i, foo: true}?.ok
+{foo: i, foo: true}?.str
+{foo: i, foo: {foo: add, foo: true}}
 {foo: i, foo: {foo: str}}
+{foo: i, foo: {foo: true}}?.foo
+{foo: i..i}
+{foo: if false { 1 } else { 1.0 }}
 {foo: if false { foo } else { $env }}
 {foo: if false { str } else { array }}
+{foo: if false { true } else { greet }}
+{foo: if ok { 1 } else { foo }}
 {foo: if true { $env } else { array }}
+{foo: if true { 0 } else { 1.0 }}
 {foo: if true { 1.0 } else { foo }}
+{foo: if true { f64 } else { add }}
 {foo: if true { foo } else { greet }}
 {foo: if true { ok } else { foo }}
 {foo: int(0)}
@@ -21337,80 +41978,142 @@ values({foo: str})
 {foo: int(f64)}?.foobar?.list()
 {foo: int(i)}
 {foo: i}
+{foo: i} ?? add
+{foo: i} not in [nil]
 {foo: i}.$env?.Bar(Bar)
 {foo: i}.Bar
+{foo: i}.Bar?.list
 {foo: i}.String
 {foo: i}.String?.i
 {foo: i}.add
+{foo: i}.add?.[list]?.[greet]
 {foo: i}.add?.add
+{foo: i}.add?.list()
 {foo: i}.array
 {foo: i}.array?.Bar
 {foo: i}.array?.[str]
 {foo: i}.f64
 {foo: i}.f64?.[foo]
 {foo: i}.f64?.[list]
+{foo: i}.f64?.foo
 {foo: i}.foo
+{foo: i}.foo ?? 1
 {foo: i}.foobar
 {foo: i}.greet
 {foo: i}.greet?.add
+{foo: i}.greet?.greet
 {foo: i}.i
+{foo: i}.i?.ok()
 {foo: i}.list
+{foo: i}.list?.greet()
 {foo: i}.nil?.array
 {foo: i}.not
 {foo: i}.ok
+{foo: i}.ok?.f64
 {foo: i}.str
+{foo: i}.str?.[nil]
 {foo: i}?.Bar
 {foo: i}?.Bar?.String
 {foo: i}?.String
+{foo: i}?.String?.[str]
 {foo: i}?.[str]
+{foo: i}?.[str]?.[add]
 {foo: i}?.add
+{foo: i}?.add?.String()
 {foo: i}?.array
 {foo: i}?.array?.[foo]
 {foo: i}?.array?.greet
 {foo: i}?.f64
+{foo: i}?.f64?.greet
 {foo: i}?.foo
 {foo: i}?.foo == add
 {foo: i}?.foobar
 {foo: i}?.greet
+{foo: i}?.greet?.[greet]
 {foo: i}?.greet?.ok
 {foo: i}?.i
 {foo: i}?.i?.f64
 {foo: i}?.list
+{foo: i}?.list?.ok
+{foo: i}?.nil not contains $env
 {foo: i}?.ok
+{foo: i}?.ok?.array
 {foo: i}?.str
+{foo: i}?.str?.str
 {foo: keys($env), foo: list}
 {foo: keys($env)}
+{foo: keys($env)}?.i
 {foo: keys($env)}?.list
+{foo: keys($env)}?.ok
 {foo: last($env)?.String}
 {foo: last($env)}
 {foo: last(array)}
+{foo: last(list), foo: ok}
 {foo: last(list)}
 {foo: len($env)}
+{foo: len($env)}.foo
 {foo: len(array)}
 {foo: len(list)}
+{foo: len({foo: true})}
 {foo: let foobar = false; foobar}
 {foo: let foobar = str; foobar}
+{foo: let tmp = ok; tmp}
 {foo: list != $env}
+{foo: list != array}
 {foo: list != list}
 {foo: list != nil}
 {foo: list == $env?.[str]}
 {foo: list == $env}
 {foo: list == list}
+{foo: list == list}.array
 {foo: list == nil}
+{foo: list ?? $env}
+{foo: list ?? 0}
+{foo: list ?? 1.0}
+{foo: list ?? f64}
+{foo: list ?? foo}
+{foo: list ?? greet}
+{foo: list ?? list}
+{foo: list ?? nil}
+{foo: list ?? str}
+{foo: list | all(ok)}
+{foo: list | all(true)}
 {foo: list | count(false)}
+{foo: list | findIndex(false)}
 {foo: list | findIndex(true)}.add
 {foo: list | groupBy(#)}
+{foo: list | groupBy(1.0)}
 {foo: list | groupBy(foo)}
 {foo: list | groupBy(ok)}
 {foo: list | groupBy(str)}
+{foo: list | map(#)}
+{foo: list | map(1.0)}
+{foo: list | map(i)}
 {foo: list | one(false)}
+{foo: list | reduce(#)}
 {foo: list | reduce(#.Bar, nil)}
 {foo: list | reduce(#.String, nil)}
+{foo: list | reduce($env)}
 {foo: list | reduce(0)}
+{foo: list | reduce(f64)}
 {foo: list | reduce(false)}
 {foo: list | reduce(foo)}
+{foo: list | reduce(ok)}
+{foo: list | reduce(str)}
 {foo: list | sortBy(.Bar)}
+{foo: list | sortBy(0)}
+{foo: list | sortBy(1), foo: str}.foo
+{foo: list | sortBy(1.0)}
+{foo: list | sortBy(i)}
 {foo: list | sum(1.0)}
+{foo: list, foo: $env ?? list}
+{foo: list, foo: $env.f64}
+{foo: list, foo: $env.ok}
+{foo: list, foo: $env?.array}
+{foo: list, foo: $env?.f64}
+{foo: list, foo: $env}.String
+{foo: list, foo: $env}.add
+{foo: list, foo: $env}.foo
 {foo: list, foo: $env}.i
 {foo: list, foo: $env}.list
 {foo: list, foo: $env}.ok
@@ -21421,45 +42124,76 @@ values({foo: str})
 {foo: list, foo: $env}?.str
 {foo: list, foo: 0, foo: 0}?.add
 {foo: list, foo: 0, foo: nil}.add
+{foo: list, foo: 0}.list
+{foo: list, foo: 0}?.Bar
+{foo: list, foo: 0}?.list
+{foo: list, foo: 1, foo: false}?.list
 {foo: list, foo: 1.0 == 1.0}
+{foo: list, foo: 1.0, foo: true}?.i
+{foo: list, foo: 1.0}.f64
 {foo: list, foo: 1.0}.foo
 {foo: list, foo: 1.0}.list
+{foo: list, foo: 1.0}?.String
 {foo: list, foo: 1.0}?.[str]
+{foo: list, foo: 1.0}?.add
 {foo: list, foo: 1.0}?.greet
+{foo: list, foo: 1.0}?.i
 {foo: list, foo: 1.0}?.ok
 {foo: list, foo: 1}.list
 {foo: list, foo: 1}?.String
 {foo: list, foo: 1}?.foo
 {foo: list, foo: 1}?.greet
 {foo: list, foo: 1}?.i
+{foo: list, foo: 1}?.list
 {foo: list, foo: add}
 {foo: list, foo: add}.array
+{foo: list, foo: add}.f64
+{foo: list, foo: add}.greet
 {foo: list, foo: add}.i
+{foo: list, foo: add}?.[str]
 {foo: list, foo: add}?.array
 {foo: list, foo: add}?.f64
 {foo: list, foo: array}
+{foo: list, foo: array}.f64
 {foo: list, foo: array}.greet
 {foo: list, foo: array}.i
+{foo: list, foo: array}.ok
+{foo: list, foo: array}.str
 {foo: list, foo: array}?.array
+{foo: list, foo: array}?.f64
 {foo: list, foo: array}?.ok
 {foo: list, foo: f64 - f64}
 {foo: list, foo: f64}
+{foo: list, foo: f64}.foo
 {foo: list, foo: f64}.greet
 {foo: list, foo: f64}?.Bar
+{foo: list, foo: false || $env}
+{foo: list, foo: false}.f64
 {foo: list, foo: false}.foobar
+{foo: list, foo: false}?.[str]
 {foo: list, foo: false}?.add
 {foo: list, foo: false}?.f64
+{foo: list, foo: false}?.foo
+{foo: list, foo: false}?.greet
+{foo: list, foo: false}?.i
+{foo: list, foo: false}?.ok
 {foo: list, foo: foo, foo: list}.Bar
+{foo: list, foo: foo, foo: true}.String
 {foo: list, foo: foo?.String()}
 {foo: list, foo: foo}
 {foo: list, foo: foo}.add
 {foo: list, foo: foo}.array
 {foo: list, foo: foo}.f64
+{foo: list, foo: foo}.i
+{foo: list, foo: foo}.ok
 {foo: list, foo: foo}?.Bar
+{foo: list, foo: foo}?.[str]
 {foo: list, foo: foo}?.add
 {foo: list, foo: foo}?.foo
+{foo: list, foo: foo}?.foobar?.[str]
 {foo: list, foo: greet}
 {foo: list, foo: greet}.list
+{foo: list, foo: greet}.str
 {foo: list, foo: greet}?.greet
 {foo: list, foo: i, foo: 1.0}?.list
 {foo: list, foo: i}
@@ -21467,27 +42201,46 @@ values({foo: str})
 {foo: list, foo: i}?.String?.add()
 {foo: list, foo: i}?.foo
 {foo: list, foo: i}?.list
+{foo: list, foo: list, foo: i}.foobar?.array
 {foo: list, foo: list}
 {foo: list, foo: list}.Bar
 {foo: list, foo: list}.String
 {foo: list, foo: list}.foo
+{foo: list, foo: list}.list
 {foo: list, foo: list}?.String
 {foo: list, foo: list}?.foo
+{foo: list, foo: list}?.greet
 {foo: list, foo: list}?.list
 {foo: list, foo: list}?.ok
 {foo: list, foo: max(0)}
 {foo: list, foo: median(array)}
+{foo: list, foo: nil} ?? f64
 {foo: list, foo: nil}.String
+{foo: list, foo: nil}.add
+{foo: list, foo: nil}.foo
+{foo: list, foo: nil}.greet
 {foo: list, foo: nil}.list
+{foo: list, foo: nil}.str?.list
+{foo: list, foo: nil}?.String
 {foo: list, foo: nil}?.[str]
+{foo: list, foo: nil}?.i
 {foo: list, foo: nil}?.str
 {foo: list, foo: ok}
 {foo: list, foo: ok}.add
+{foo: list, foo: ok}.ok
 {foo: list, foo: ok}?.Bar
 {foo: list, foo: ok}?.[str]
+{foo: list, foo: ok}?.array
+{foo: list, foo: ok}?.foo
+{foo: list, foo: ok}?.i
+{foo: list, foo: str, foo: abs(f64)}
 {foo: list, foo: str}
+{foo: list, foo: str}.String
 {foo: list, foo: str}.array
+{foo: list, foo: str}.list
 {foo: list, foo: str}?.String
+{foo: list, foo: str}?.i
+{foo: list, foo: str}?.list
 {foo: list, foo: str}?.ok
 {foo: list, foo: sum(array)}
 {foo: list, foo: true, foo: add}?.ok
@@ -21499,9 +42252,13 @@ values({foo: str})
 {foo: list?.[i], foo: list}
 {foo: list?.[i], foo: ok}
 {foo: list?.[i]}
+{foo: list?.[i]}.greet?.[array]
 {foo: list?.[i]}.ok
+{foo: list[0:]}
 {foo: list[:0]}
+{foo: list[i:]}
 {foo: list}
+{foo: list} ?? reduce($env, 1.0, 1)
 {foo: list}.Bar
 {foo: list}.String
 {foo: list}.add
@@ -21517,15 +42274,21 @@ values({foo: str})
 {foo: list}.greet?.[str]
 {foo: list}.i
 {foo: list}.i?.[array]
+{foo: list}.i?.[foo]
 {foo: list}.list
+{foo: list}.list?.[f64]
 {foo: list}.list?.[greet]
 {foo: list}.ok
 {foo: list}.ok?.Bar
+{foo: list}.ok?.[f64]
 {foo: list}.str
 {foo: list}?.Bar
 {foo: list}?.Bar?.[foo]
+{foo: list}?.Bar?.[greet]
 {foo: list}?.Bar?.[list]
+{foo: list}?.Bar?.add
 {foo: list}?.String
+{foo: list}?.String?.[array]
 {foo: list}?.String?.list()
 {foo: list}?.[str]
 {foo: list}?.[str]?.[i]
@@ -21533,28 +42296,39 @@ values({foo: str})
 {foo: list}?.add
 {foo: list}?.array
 {foo: list}?.f64
+{foo: list}?.f64?.array
+{foo: list}?.f64?.greet
 {foo: list}?.f64?.ok
 {foo: list}?.foo
 {foo: list}?.foobar
 {foo: list}?.greet
 {foo: list}?.greet?.list
 {foo: list}?.i
+{foo: list}?.i?.[greet]
+{foo: list}?.i?.[i]
+{foo: list}?.i?.array
 {foo: list}?.list
 {foo: list}?.ok
 {foo: list}?.ok?.[ok]
 {foo: list}?.str
 {foo: list}?.str?.[list]
+{foo: list}?.str?.[str]
 {foo: lower(str)}
+{foo: lower(str)}?.[str]
 {foo: map($env, $env)}
+{foo: map($env, 0)}
 {foo: map($env, 1)}
+{foo: map($env, 1.0), foo: i}
 {foo: map($env, 1.0)}
 {foo: map($env, array)}
+{foo: map($env, f64)}
 {foo: map($env, foo)}
 {foo: map($env, greet)}
 {foo: map($env, i)}
 {foo: map($env, i)}?.add
 {foo: map($env, list)}
 {foo: map($env, ok)}
+{foo: map($env, str)}
 {foo: map(array, #)}
 {foo: map(array, $env)}
 {foo: map(array, 1)}
@@ -21563,18 +42337,25 @@ values({foo: str})
 {foo: map(list, #)}
 {foo: map(list, #.Bar)}
 {foo: map(list, $env)}
+{foo: map(list, .String)}
 {foo: map(list, add)}
 {foo: map(list, foo)}
 {foo: map(list, greet)}
 {foo: map(list, ok)}
+{foo: max($env), foo: array}
 {foo: max($env)}
 {foo: max($env)}.i
+{foo: max(0)}
 {foo: max(1)}
 {foo: max(1.0)}
+{foo: max(1.0, 1.0)}
 {foo: max(array)}
 {foo: max(f64)}
+{foo: max(f64)}?.str
 {foo: max(i)}
 {foo: mean(0)}
+{foo: mean(1)}
+{foo: mean(1, 0)}
 {foo: mean(1.0 * 1.0)}
 {foo: mean(1.0), foo: array}
 {foo: mean(1.0)}
@@ -21584,31 +42365,47 @@ values({foo: str})
 {foo: mean(array, i)}
 {foo: mean(f64)}
 {foo: mean(i)}
+{foo: mean(i, 1)}
 {foo: median(0)}
+{foo: median(0)}?.ok
 {foo: median(1)}
 {foo: median(1.0)}
+{foo: median(array)}
+{foo: median(array, 1.0)}
+{foo: median(f64), foo: i}
 {foo: median(f64)}
+{foo: median(f64, i)}.i
 {foo: median(flatten(array))}
 {foo: median(i)}
 {foo: median(i, array)}.Bar
 {foo: min($env)?.String}
 {foo: min($env)}
+{foo: min(0)}
 {foo: min(1), foo: ok}
 {foo: min(1)}
+{foo: min(1, 1.0)}
 {foo: min(1.0)}
 {foo: min(1.0)}?.String
 {foo: min(array)}
 {foo: min(f64)}
 {foo: min(i)}
 {foo: min(i)}.list
+{foo: nil != $env, foo: foo}
 {foo: nil != $env}
 {foo: nil != 0}
 {foo: nil != 1.0}
+{foo: nil != 1}
+{foo: nil != 1}.ok
 {foo: nil != add}
 {foo: nil != array}
 {foo: nil != f64}
+{foo: nil != false, foo: i}
+{foo: nil != false}
+{foo: nil != foo?.String()}
 {foo: nil != foo}
+{foo: nil != foo}.str
 {foo: nil != greet}
+{foo: nil != i, foo: list}
 {foo: nil != list}
 {foo: nil != nil, foo: list}
 {foo: nil != nil}
@@ -21618,20 +42415,43 @@ values({foo: str})
 {foo: nil == $env}
 {foo: nil == 0}
 {foo: nil == 1.0}
+{foo: nil == 1}
 {foo: nil == add}
 {foo: nil == array}
+{foo: nil == f64}
 {foo: nil == false}
 {foo: nil == foo}
+{foo: nil == greet}
 {foo: nil == list}?.Bar
 {foo: nil == nil}
 {foo: nil == ok}
+{foo: nil == true}
+{foo: nil ?? $env}
+{foo: nil ?? 0}
+{foo: nil ?? 1.0}
+{foo: nil ?? 1}
+{foo: nil ?? add}
+{foo: nil ?? array}
+{foo: nil ?? f64}
+{foo: nil ?? false, foo: i}
+{foo: nil ?? false}
+{foo: nil ?? foo}
+{foo: nil ?? greet}
+{foo: nil ?? i}
+{foo: nil ?? list, foo: f64}
+{foo: nil ?? nil, foo: f64}
+{foo: nil ?? nil}
+{foo: nil ?? ok}
 {foo: nil in $env}
 {foo: nil in array}
 {foo: nil in list}
 {foo: nil not in $env}
+{foo: nil not in array}
+{foo: nil not in list}
 {foo: nil, foo: $env}.Bar
 {foo: nil, foo: $env}.String
 {foo: nil, foo: $env}.add
+{foo: nil, foo: $env}.array
 {foo: nil, foo: $env}.f64
 {foo: nil, foo: $env}.foo
 {foo: nil, foo: $env}.foobar
@@ -21640,118 +42460,212 @@ values({foo: str})
 {foo: nil, foo: $env}?.Bar
 {foo: nil, foo: $env}?.Bar?.[f64]
 {foo: nil, foo: $env}?.String
+{foo: nil, foo: $env}?.add
 {foo: nil, foo: $env}?.foo
+{foo: nil, foo: $env}?.i
 {foo: nil, foo: $env}?.list
 {foo: nil, foo: $env}?.str
 {foo: nil, foo: 0, foo: 0}.greet
 {foo: nil, foo: 0, foo: true}?.[str]
+{foo: nil, foo: 0}.Bar
+{foo: nil, foo: 0}.String
 {foo: nil, foo: 0}.f64
 {foo: nil, foo: 0}.list
+{foo: nil, foo: 0}.ok
 {foo: nil, foo: 0}?.Bar
 {foo: nil, foo: 0}?.String?.[f64]
 {foo: nil, foo: 0}?.add
+{foo: nil, foo: 0}?.array
+{foo: nil, foo: 0}?.f64
 {foo: nil, foo: 0}?.greet
+{foo: nil, foo: 0}?.ok
 {foo: nil, foo: 1, foo: false}?.String
 {foo: nil, foo: 1, foo: foo}.ok
+{foo: nil, foo: 1.0, foo: 1}.f64
+{foo: nil, foo: 1.0, foo: array}?.str
+{foo: nil, foo: 1.0}.Bar
+{foo: nil, foo: 1.0}.String
+{foo: nil, foo: 1.0}.add
 {foo: nil, foo: 1.0}.array
 {foo: nil, foo: 1.0}.foo
 {foo: nil, foo: 1.0}.greet
+{foo: nil, foo: 1.0}.i
 {foo: nil, foo: 1.0}.list
+{foo: nil, foo: 1.0}.nil?.[greet]
+{foo: nil, foo: 1.0}.str
 {foo: nil, foo: 1.0}?.String
 {foo: nil, foo: 1.0}?.[str]
 {foo: nil, foo: 1.0}?.array
 {foo: nil, foo: 1.0}?.f64
 {foo: nil, foo: 1.0}?.greet
 {foo: nil, foo: 1.0}?.i
+{foo: nil, foo: 1.0}?.list
 {foo: nil, foo: 1.0}?.ok
 {foo: nil, foo: 1.0}?.str
+{foo: nil, foo: 1}.Bar
 {foo: nil, foo: 1}.String
+{foo: nil, foo: 1}.add
 {foo: nil, foo: 1}.array
 {foo: nil, foo: 1}.f64
+{foo: nil, foo: 1}.i
 {foo: nil, foo: 1}.list
+{foo: nil, foo: 1}?.[str]
+{foo: nil, foo: 1}?.add
+{foo: nil, foo: 1}?.f64
 {foo: nil, foo: 1}?.foo
+{foo: nil, foo: add}.Bar
+{foo: nil, foo: add}.f64
 {foo: nil, foo: add}.i
 {foo: nil, foo: add}.list
+{foo: nil, foo: add}?.Bar
 {foo: nil, foo: add}?.String
+{foo: nil, foo: add}?.add
 {foo: nil, foo: add}?.foo
 {foo: nil, foo: add}?.i
+{foo: nil, foo: add}?.ok
 {foo: nil, foo: array, foo: add}?.add
+{foo: nil, foo: array}.foo
 {foo: nil, foo: array}.str
 {foo: nil, foo: array}?.[str]
 {foo: nil, foo: array}?.array
+{foo: nil, foo: array}?.array?.[foo]
 {foo: nil, foo: array}?.f64
 {foo: nil, foo: array}?.foobar
 {foo: nil, foo: array}?.greet
+{foo: nil, foo: array}?.i
 {foo: nil, foo: f64}.String
 {foo: nil, foo: f64}.add
+{foo: nil, foo: f64}.f64
 {foo: nil, foo: f64}.greet
+{foo: nil, foo: f64}?.Bar
+{foo: nil, foo: f64}?.array
+{foo: nil, foo: f64}?.greet
 {foo: nil, foo: f64}?.ok
 {foo: nil, foo: false}.Bar
 {foo: nil, foo: false}.f64
+{foo: nil, foo: false}.foo
+{foo: nil, foo: false}.list
 {foo: nil, foo: false}?.f64
 {foo: nil, foo: false}?.greet
 {foo: nil, foo: false}?.i
+{foo: nil, foo: false}?.list
 {foo: nil, foo: false}?.ok
+{foo: nil, foo: foo, foo: 1}.foo
+{foo: nil, foo: foo, foo: 1}.i
 {foo: nil, foo: foo, foo: false}?.array
 {foo: nil, foo: foo, foo: i}?.i
 {foo: nil, foo: foo, foo: list}.Bar
+{foo: nil, foo: foo, foo: true}.ok
 {foo: nil, foo: foo}.String
 {foo: nil, foo: foo}.add
 {foo: nil, foo: foo}.array
 {foo: nil, foo: foo}.foo
+{foo: nil, foo: foo}.greet
+{foo: nil, foo: foo}.i
 {foo: nil, foo: foo}.ok
 {foo: nil, foo: foo}.str
 {foo: nil, foo: foo}?.Bar
 {foo: nil, foo: foo}?.[str]
+{foo: nil, foo: foo}?.add
 {foo: nil, foo: foo}?.f64
+{foo: nil, foo: foo}?.foo
+{foo: nil, foo: foo}?.greet
 {foo: nil, foo: foo}?.i
+{foo: nil, foo: foo}?.list in list
 {foo: nil, foo: foo}?.ok
+{foo: nil, foo: foo}?.ok?.Bar()
+{foo: nil, foo: foo}?.str
+{foo: nil, foo: greet, foo: nil}.add
 {foo: nil, foo: greet}.String
+{foo: nil, foo: greet}.array
+{foo: nil, foo: greet}.i
+{foo: nil, foo: greet}.ok
 {foo: nil, foo: greet}?.f64
 {foo: nil, foo: greet}?.foo
 {foo: nil, foo: greet}?.greet
+{foo: nil, foo: greet}?.i
 {foo: nil, foo: greet}?.str
+{foo: nil, foo: i, foo: $env}.f64
+{foo: nil, foo: i, foo: foo}?.i
 {foo: nil, foo: i, foo: greet}?.String
 {foo: nil, foo: i}.f64
 {foo: nil, foo: i}.foo
+{foo: nil, foo: i}.greet
 {foo: nil, foo: i}.i
+{foo: nil, foo: i}.list
 {foo: nil, foo: i}.ok
+{foo: nil, foo: i}?.String
 {foo: nil, foo: i}?.array
 {foo: nil, foo: list, foo: add}.Bar
 {foo: nil, foo: list, foo: nil}.f64
 {foo: nil, foo: list}.Bar
 {foo: nil, foo: list}.f64
 {foo: nil, foo: list}.f64?.str
+{foo: nil, foo: list}.ok
 {foo: nil, foo: list}?.Bar
+{foo: nil, foo: list}?.f64
+{foo: nil, foo: list}?.foo
+{foo: nil, foo: list}?.i
+{foo: nil, foo: list}?.str
+{foo: nil, foo: nil, foo: 1.0}?.array
 {foo: nil, foo: nil, foo: greet}?.[str]
+{foo: nil, foo: nil, foo: i}?.String
 {foo: nil, foo: nil, foo: true}?.greet
 {foo: nil, foo: nil}.array
 {foo: nil, foo: nil}.foo
 {foo: nil, foo: nil}.greet
+{foo: nil, foo: nil}.i
 {foo: nil, foo: nil}.ok
+{foo: nil, foo: nil}.str
 {foo: nil, foo: nil}?.Bar
 {foo: nil, foo: nil}?.String
 {foo: nil, foo: nil}?.add
+{foo: nil, foo: nil}?.array
+{foo: nil, foo: nil}?.array?.array(foobar)
+{foo: nil, foo: nil}?.f64
 {foo: nil, foo: nil}?.foo
+{foo: nil, foo: nil}?.i
+{foo: nil, foo: nil}?.list
+{foo: nil, foo: nil}?.ok
 {foo: nil, foo: nil}?.str
 {foo: nil, foo: ok, foo: nil}.String
+{foo: nil, foo: ok}.Bar
 {foo: nil, foo: ok}.String
+{foo: nil, foo: ok}.add
 {foo: nil, foo: ok}.array
 {foo: nil, foo: ok}.f64
+{foo: nil, foo: ok}.foo
 {foo: nil, foo: ok}.i
 {foo: nil, foo: ok}?.Bar?.[add]
+{foo: nil, foo: ok}?.array
+{foo: nil, foo: ok}?.f64
+{foo: nil, foo: ok}?.foo
+{foo: nil, foo: ok}?.str?.[greet]
 {foo: nil, foo: str}.String
+{foo: nil, foo: str}.add
+{foo: nil, foo: str}.array
 {foo: nil, foo: str}.f64
+{foo: nil, foo: str}.foo
+{foo: nil, foo: str}.greet
 {foo: nil, foo: str}.i
 {foo: nil, foo: str}.ok
 {foo: nil, foo: str}.str
+{foo: nil, foo: str}?.add
 {foo: nil, foo: str}?.f64
+{foo: nil, foo: true, foo: str}.list
 {foo: nil, foo: true}.String
 {foo: nil, foo: true}.f64
 {foo: nil, foo: true}.ok
+{foo: nil, foo: true}.str
+{foo: nil, foo: true}?.String
 {foo: nil, foo: true}?.i
 {foo: nil, foo: true}?.ok
+{foo: nil} ?? array
+{foo: nil} ?? foo
+{foo: nil} ?? ok
+{foo: nil} not in $env?.[String]
 {foo: nil}.Bar
+{foo: nil}.Bar?.add?.list
 {foo: nil}.Bar?.f64
 {foo: nil}.String
 {foo: nil}.String?.[i]
@@ -21759,99 +42673,203 @@ values({foo: str})
 {foo: nil}.String?.greet
 {foo: nil}.add
 {foo: nil}.add?.[ok]
+{foo: nil}.add?.[str]
 {foo: nil}.array
 {foo: nil}.array?.[array]
 {foo: nil}.array?.[foo]
+{foo: nil}.array?.[i]
+{foo: nil}.array?.[ok]
 {foo: nil}.array?.[str]
 {foo: nil}.array?.str
 {foo: nil}.f64
+{foo: nil}.f64?.[list].ok
+{foo: nil}.f64?.f64
+{foo: nil}.f64?.i
 {foo: nil}.foo
 {foo: nil}.foo?.[list]
+{foo: nil}.foo?.ok
+{foo: nil}.foobar
 {foo: nil}.foobar?.i
 {foo: nil}.greet
+{foo: nil}.greet?.[add]
+{foo: nil}.greet?.[f64]
 {foo: nil}.greet?.[foo]
+{foo: nil}.greet?.greet(foo)
 {foo: nil}.i
 {foo: nil}.list
+{foo: nil}.list?.String
+{foo: nil}.list?.String()
+{foo: nil}.list?.list
 {foo: nil}.not
 {foo: nil}.ok
+{foo: nil}.ok?.String
+{foo: nil}.ok?.greet
 {foo: nil}.str
+{foo: nil}.str?.ok
+{foo: nil}?.$env?.str
 {foo: nil}?.Bar
+{foo: nil}?.Bar?.String
 {foo: nil}?.String
+{foo: nil}?.String?.add
+{foo: nil}?.String?.greet
 {foo: nil}?.[str]
 {foo: nil}?.[str]?.[list]
 {foo: nil}?.[str]?.[str]
 {foo: nil}?.[str]?.ok
 {foo: nil}?.add
+{foo: nil}?.add?.Bar
+{foo: nil}?.add?.add
 {foo: nil}?.array
+{foo: nil}?.array?.Bar
 {foo: nil}?.f64
 {foo: nil}?.f64?.[i]
 {foo: nil}?.foo
+{foo: nil}?.foo != f64
 {foo: nil}?.foo?.[f64]
+{foo: nil}?.foo?.[ok]
 {foo: nil}?.foo?.i
+{foo: nil}?.foo?.str
+{foo: nil}?.foobar
+{foo: nil}?.foobar or true
 {foo: nil}?.foobar?.add
 {foo: nil}?.greet
+{foo: nil}?.greet?.ok
 {foo: nil}?.i
 {foo: nil}?.i?.[greet]
+{foo: nil}?.i?.[str]
 {foo: nil}?.list
+{foo: nil}?.list?.[list]
 {foo: nil}?.list?.f64(foobar)
 {foo: nil}?.ok
+{foo: nil}?.ok?.[f64]
+{foo: nil}?.ok?.add
 {foo: nil}?.str
+{foo: nil}?.str?.f64()
+{foo: nil}?.str?.list
+{foo: nil}?.str?.ok
+{foo: none($env, false)}
+{foo: none($env, ok)}
+{foo: none($env, true)}
 {foo: none(list, ok)}
+{foo: none(list, true)}
+{foo: not false}
+{foo: not false}?.add
+{foo: not false}?.ok
+{foo: not ok && $env}
+{foo: not ok}
+{foo: not true, foo: add}
+{foo: not true, foo: array}
+{foo: not true, foo: str}
+{foo: not true}
+{foo: not true}.f64
+{foo: not true}?.str
 {foo: ok != $env}
+{foo: ok != false}
 {foo: ok != nil}
+{foo: ok != ok}
+{foo: ok != true}
+{foo: ok && $env}
 {foo: ok && false}
 {foo: ok && ok}
 {foo: ok == $env}
 {foo: ok == $env}.String
+{foo: ok == false}
 {foo: ok == nil}
+{foo: ok == ok}
 {foo: ok == true}
+{foo: ok == true}.f64
+{foo: ok ? 1.0 : 1}
+{foo: ok ? 1.0 : greet}
 {foo: ok ? add : f64}
 {foo: ok ? foo : 0}
+{foo: ok ? greet : add}
 {foo: ok ? greet : list}
 {foo: ok ? nil : foo}
 {foo: ok ?: array}
+{foo: ok ?: nil}
+{foo: ok ?? $env}
+{foo: ok ?? 0}
+{foo: ok ?? 1.0}
+{foo: ok ?? 1}
+{foo: ok ?? array}
+{foo: ok ?? false}
+{foo: ok ?? foo}
+{foo: ok ?? i}
+{foo: ok ?? list}
+{foo: ok ?? true, foo: $env.list}
 {foo: ok and $env}
+{foo: ok and true}
 {foo: ok or $env}
 {foo: ok or false}
 {foo: ok || $env}
+{foo: ok || ok}
+{foo: ok || true}
+{foo: ok, foo: $env, foo: foo}?.array
 {foo: ok, foo: $env.add}
+{foo: ok, foo: $env.str}
+{foo: ok, foo: $env?.array}
 {foo: ok, foo: $env?.i, foo: str}
+{foo: ok, foo: $env}.foo
+{foo: ok, foo: $env}.i
+{foo: ok, foo: $env}.ok
 {foo: ok, foo: $env}?.Bar
 {foo: ok, foo: $env}?.String
+{foo: ok, foo: $env}?.[str]
 {foo: ok, foo: $env}?.add
 {foo: ok, foo: $env}?.f64
 {foo: ok, foo: $env}?.str
 {foo: ok, foo: 0 > i}
 {foo: ok, foo: 0, foo: 1.0}.String
+{foo: ok, foo: 0, foo: array}?.String
 {foo: ok, foo: 0}.Bar
+{foo: ok, foo: 0}.String
 {foo: ok, foo: 0}.ok
 {foo: ok, foo: 0}?.list
+{foo: ok, foo: 0}?.ok
 {foo: ok, foo: 0}?.str
 {foo: ok, foo: 1, foo: nil}?.str
 {foo: ok, foo: 1.0 - i}
+{foo: ok, foo: 1.0}.Bar
 {foo: ok, foo: 1.0}.f64
+{foo: ok, foo: 1.0}.foo
 {foo: ok, foo: 1.0}.greet
+{foo: ok, foo: 1.0}.i
 {foo: ok, foo: 1.0}.list
 {foo: ok, foo: 1.0}.ok
 {foo: ok, foo: 1.0}.str
 {foo: ok, foo: 1.0}?.Bar
+{foo: ok, foo: 1.0}?.f64
 {foo: ok, foo: 1.0}?.foo
 {foo: ok, foo: 1.0}?.greet
+{foo: ok, foo: 1.0}?.i
 {foo: ok, foo: 1.0}?.ok
 {foo: ok, foo: 1}.array
+{foo: ok, foo: 1}.greet
 {foo: ok, foo: 1}?.[str]
 {foo: ok, foo: 1}?.add?.String
+{foo: ok, foo: 1}?.greet
+{foo: ok, foo: add ?? 1.0}
+{foo: ok, foo: add, foo: 1.0}?.greet
 {foo: ok, foo: add}
 {foo: ok, foo: add}.greet
 {foo: ok, foo: add}.i
 {foo: ok, foo: add}?.foo
 {foo: ok, foo: add}?.greet?.ok
+{foo: ok, foo: array | map(1.0)}
 {foo: ok, foo: array}
 {foo: ok, foo: array}.String
+{foo: ok, foo: array}.greet
+{foo: ok, foo: array}.str
 {foo: ok, foo: array}?.String
+{foo: ok, foo: array}?.String?.[f64]
+{foo: ok, foo: array}?.add
+{foo: ok, foo: array}?.f64
 {foo: ok, foo: array}?.foo
 {foo: ok, foo: array}?.list
+{foo: ok, foo: f64 <= i}
+{foo: ok, foo: f64, foo: $env}?.foo
 {foo: ok, foo: f64}
+{foo: ok, foo: f64}.foo
 {foo: ok, foo: f64}.greet
 {foo: ok, foo: f64}.i
 {foo: ok, foo: f64}?.Bar
@@ -21859,70 +42877,121 @@ values({foo: str})
 {foo: ok, foo: f64}?.f64
 {foo: ok, foo: f64}?.foo
 {foo: ok, foo: f64}?.greet
+{foo: ok, foo: f64}?.i
 {foo: ok, foo: false}?.String
+{foo: ok, foo: false}?.f64
 {foo: ok, foo: false}?.ok
+{foo: ok, foo: false}?.str
 {foo: ok, foo: foo?.Bar}
 {foo: ok, foo: foo}
 {foo: ok, foo: foo}.Bar
+{foo: ok, foo: foo}.add
+{foo: ok, foo: foo}.array
 {foo: ok, foo: foo}.f64
+{foo: ok, foo: foo}.foo
+{foo: ok, foo: foo}.greet
 {foo: ok, foo: foo}.i
+{foo: ok, foo: foo}.list
 {foo: ok, foo: foo}.ok
 {foo: ok, foo: foo}.str
 {foo: ok, foo: foo}?.Bar
+{foo: ok, foo: foo}?.array
+{foo: ok, foo: foo}?.f64
+{foo: ok, foo: foo}?.foo
+{foo: ok, foo: foo}?.list
+{foo: ok, foo: foo}?.ok
+{foo: ok, foo: foo}?.str
 {foo: ok, foo: greet}
+{foo: ok, foo: greet}.greet
 {foo: ok, foo: greet}.i
 {foo: ok, foo: greet}?.greet
+{foo: ok, foo: greet}?.list
+{foo: ok, foo: i <= f64}
 {foo: ok, foo: i, foo: true}.foo
 {foo: ok, foo: i}
 {foo: ok, foo: i}.Bar
+{foo: ok, foo: i}.list
 {foo: ok, foo: i}?.list
+{foo: ok, foo: list, foo: 0}.i
 {foo: ok, foo: list}
+{foo: ok, foo: list}.i
+{foo: ok, foo: list}.str
 {foo: ok, foo: list}?.array
 {foo: ok, foo: list}?.foo
+{foo: ok, foo: list}?.greet
+{foo: ok, foo: list}?.ok
+{foo: ok, foo: list}?.str
 {foo: ok, foo: mean(0)}
+{foo: ok, foo: nil == ok}
 {foo: ok, foo: nil, foo: $env}?.ok
 {foo: ok, foo: nil, foo: greet}.i
 {foo: ok, foo: nil, foo: greet}?.add
+{foo: ok, foo: nil} ?? i
+{foo: ok, foo: nil}.Bar
+{foo: ok, foo: nil}.String
 {foo: ok, foo: nil}.add
+{foo: ok, foo: nil}.array
 {foo: ok, foo: nil}.foo
 {foo: ok, foo: nil}.greet
 {foo: ok, foo: nil}.i
+{foo: ok, foo: nil}.list
 {foo: ok, foo: nil}?.foo
 {foo: ok, foo: nil}?.ok
 {foo: ok, foo: nil}?.str
+{foo: ok, foo: nil}?.str?.i()
 {foo: ok, foo: ok}
 {foo: ok, foo: ok}.f64
+{foo: ok, foo: ok}.i?.greet
 {foo: ok, foo: ok}?.list
 {foo: ok, foo: str}
 {foo: ok, foo: str}.f64
+{foo: ok, foo: str}.greet
 {foo: ok, foo: str}?.f64
 {foo: ok, foo: str}?.list
+{foo: ok, foo: true, foo: str}?.String
+{foo: ok, foo: true}.Bar
+{foo: ok, foo: true}.array
+{foo: ok, foo: true}.greet
 {foo: ok, foo: true}.true?.add
 {foo: ok, foo: true}?.Bar
+{foo: ok, foo: true}?.[str]
+{foo: ok, foo: true}?.add
 {foo: ok, foo: true}?.array?.greet
+{foo: ok, foo: true}?.f64
 {foo: ok, foo: true}?.list
 {foo: ok, foo: true}?.ok
+{foo: ok, foo: true}?.str
 {foo: ok}
+{foo: ok} ?? str
 {foo: ok}.Bar
 {foo: ok}.String
 {foo: ok}.add
+{foo: ok}.add?.greet()
 {foo: ok}.array
+{foo: ok}.array?.String
 {foo: ok}.f64
+{foo: ok}.f64?.[greet]
 {foo: ok}.foo
 {foo: ok}.foobar
 {foo: ok}.greet
+{foo: ok}.greet?.add
 {foo: ok}.i
 {foo: ok}.i?.[list]
+{foo: ok}.i?.[ok]
 {foo: ok}.list
 {foo: ok}.ok
+{foo: ok}.ok matches $env
 {foo: ok}.ok?.greet
 {foo: ok}.str
 {foo: ok}?.Bar
+{foo: ok}?.Bar?.[greet]
 {foo: ok}?.Bar?.[list]
+{foo: ok}?.Bar?.[str]
 {foo: ok}?.String
 {foo: ok}?.String?.[i]
 {foo: ok}?.String?.[str]
 {foo: ok}?.[str]
+{foo: ok}?.[str]?.[array]
 {foo: ok}?.add
 {foo: ok}?.add?.String?.ok
 {foo: ok}?.array
@@ -21930,28 +42999,51 @@ values({foo: str})
 {foo: ok}?.array?.str
 {foo: ok}?.f64
 {foo: ok}?.foo
+{foo: ok}?.foo != foo
+{foo: ok}?.foobar
+{foo: ok}?.foobar?.ok(foo)
 {foo: ok}?.greet
 {foo: ok}?.i
 {foo: ok}?.i?.ok
 {foo: ok}?.list
+{foo: ok}?.nil?.greet
 {foo: ok}?.ok
 {foo: ok}?.str
+{foo: one($env, false)}
+{foo: one($env, true)}
+{foo: one(array, ok)}
 {foo: one(array, true)}
 {foo: one(list, false)}
 {foo: one(list, ok)}
+{foo: one(list, true)}
 {foo: reduce($env, #acc, foo)}
 {foo: reduce(array, #)}
+{foo: reduce(array, $env, $env)}
+{foo: reduce(array, 0)}
+{foo: reduce(array, add)}
+{foo: reduce(array, array)}
+{foo: reduce(array, f64)}
+{foo: reduce(array, list)}
+{foo: reduce(array, ok, $env)}
+{foo: reduce(array, str)}
 {foo: reduce(list, #)}
+{foo: reduce(list, #.Bar)}
 {foo: reduce(list, #.String)}
 {foo: reduce(list, $env)}
 {foo: reduce(list, 1.0)}
 {foo: reduce(list, add)}
+{foo: reduce(list, array)}.str
 {foo: reduce(list, f64)}
 {foo: reduce(list, false), foo: 1.0 * f64}
+{foo: reduce(list, false)}
 {foo: reduce(list, foo)}
+{foo: reduce(list, ok)}
 {foo: reduce(list, str)}
+{foo: reduce(map(array, $env), #.list | reduce(foo))}
 {foo: reverse(array)}
+{foo: reverse(list)}
 {foo: round(0)}
+{foo: round(0)}?.Bar
 {foo: round(1)}
 {foo: round(1.0), foo: str}
 {foo: round(1.0)}
@@ -21959,17 +43051,34 @@ values({foo: str})
 {foo: round(i)}
 {foo: round(i)}?.ok
 {foo: sort($env)}
+{foo: sort(array), foo: str}
 {foo: sort(array)}
 {foo: sortBy(array, #)}
 {foo: sortBy(array, 0)}
+{foo: sortBy(array, 1)}
 {foo: sortBy(array, 1.0)}
+{foo: sortBy(array, f64)}
+{foo: sortBy(list, #.Bar)}
 {foo: sortBy(list, 1.0)}
 {foo: sortBy(list, i)}
 {foo: sortBy(list, str)}
 {foo: str != $env?.[Bar]}
+{foo: str != $env}
+{foo: str < str}
+{foo: str == $env}
 {foo: str == nil}
 {foo: str == str}
 {foo: str >= str, foo: str}
+{foo: str ?? 0}
+{foo: str ?? 1.0}
+{foo: str ?? add}
+{foo: str ?? array}
+{foo: str ?? f64}
+{foo: str ?? false}
+{foo: str ?? foo}
+{foo: str ?? true}
+{foo: str contains str}
+{foo: str endsWith str}
 {foo: str in $env}
 {foo: str in foo}
 {foo: str matches str}
@@ -21978,22 +43087,40 @@ values({foo: str})
 {foo: str not in $env}
 {foo: str not in foo}
 {foo: str not matches str}
+{foo: str not startsWith str}
 {foo: str startsWith str}
 {foo: str, foo: $env != 0}
+{foo: str, foo: $env, foo: 0}?.add
 {foo: str, foo: $env, foo: nil}.str
 {foo: str, foo: $env.f64}
 {foo: str, foo: $env.greet}
+{foo: str, foo: $env?.add}
+{foo: str, foo: $env?.foobar}
 {foo: str, foo: $env}.foo
+{foo: str, foo: $env}.foobar?.list()
 {foo: str, foo: $env}.greet
 {foo: str, foo: $env}.list
 {foo: str, foo: $env}.str
 {foo: str, foo: $env}?.[str]
+{foo: str, foo: $env}?.f64
+{foo: str, foo: $env}?.foo
+{foo: str, foo: $env}?.str
+{foo: str, foo: 0, foo: f64}?.foo
+{foo: str, foo: 0, foo: nil}?.add
 {foo: str, foo: 0}.add
+{foo: str, foo: 0}.foobar
+{foo: str, foo: 0}.ok
+{foo: str, foo: 0}?.add
 {foo: str, foo: 0}?.array
 {foo: str, foo: 0}?.ok
+{foo: str, foo: 1.0, foo: greet}?.add
+{foo: str, foo: 1.0}.String
+{foo: str, foo: 1.0}.f64
 {foo: str, foo: 1.0}.foo
 {foo: str, foo: 1.0}.greet
 {foo: str, foo: 1.0}.i
+{foo: str, foo: 1.0}.list
+{foo: str, foo: 1.0}.ok
 {foo: str, foo: 1.0}.str
 {foo: str, foo: 1.0}?.[str]
 {foo: str, foo: 1.0}?.add
@@ -22002,35 +43129,56 @@ values({foo: str})
 {foo: str, foo: 1.0}?.str
 {foo: str, foo: 1}.Bar
 {foo: str, foo: 1}.foo
+{foo: str, foo: 1}.ok
 {foo: str, foo: 1}.str
+{foo: str, foo: 1}?.String
+{foo: str, foo: 1}?.add
+{foo: str, foo: 1}?.i
 {foo: str, foo: 1}?.list
 {foo: str, foo: [f64]}
 {foo: str, foo: add, foo: f64}?.ok
+{foo: str, foo: add, foo: str}?.f64
 {foo: str, foo: add}
 {foo: str, foo: add}.Bar
+{foo: str, foo: add}.String
 {foo: str, foo: add}.f64
 {foo: str, foo: add}.greet
 {foo: str, foo: add}.i
 {foo: str, foo: add}?.[str]
+{foo: str, foo: add}?.array
 {foo: str, foo: array}
 {foo: str, foo: array}.greet
+{foo: str, foo: array}.i
 {foo: str, foo: array}.list
 {foo: str, foo: array}.ok
 {foo: str, foo: array}?.String
+{foo: str, foo: array}?.add
 {foo: str, foo: array}?.foo
 {foo: str, foo: array}?.i
+{foo: str, foo: ceil(1.0)}
 {foo: str, foo: f64}
+{foo: str, foo: f64} ?? foo
 {foo: str, foo: f64}.add
 {foo: str, foo: f64}?.String
+{foo: str, foo: f64}?.add
 {foo: str, foo: f64}?.add?.[add]
 {foo: str, foo: f64}?.list
 {foo: str, foo: false}.array
 {foo: str, foo: false}.f64
+{foo: str, foo: false}.i
 {foo: str, foo: false}?.[str]
+{foo: str, foo: false}?.greet?.[add]
+{foo: str, foo: false}?.i
+{foo: str, foo: false}?.str
 {foo: str, foo: foo, foo: array}?.str
+{foo: str, foo: foo.String}
 {foo: str, foo: foo}
 {foo: str, foo: foo}.Bar
+{foo: str, foo: foo}.array
 {foo: str, foo: foo}.f64?.foo
+{foo: str, foo: foo}.greet
+{foo: str, foo: foo}.i
+{foo: str, foo: foo}.list
 {foo: str, foo: foo}.ok
 {foo: str, foo: foo}.str
 {foo: str, foo: foo}?.[str]?.String()
@@ -22041,59 +43189,100 @@ values({foo: str})
 {foo: str, foo: greet(str)}
 {foo: str, foo: greet}
 {foo: str, foo: greet}.Bar
+{foo: str, foo: greet}.String
+{foo: str, foo: greet}.greet?.[greet]
 {foo: str, foo: greet}.ok
 {foo: str, foo: greet}?.add
+{foo: str, foo: greet}?.array
 {foo: str, foo: i}
 {foo: str, foo: i}.Bar
+{foo: str, foo: i}.add
 {foo: str, foo: i}.array
+{foo: str, foo: i}.foo
+{foo: str, foo: i}?.Bar
 {foo: str, foo: i}?.list
+{foo: str, foo: last($env)}
 {foo: str, foo: list}
 {foo: str, foo: list}.String
+{foo: str, foo: list}.add
+{foo: str, foo: list}.f64
+{foo: str, foo: list}.ok
+{foo: str, foo: list}?.add
 {foo: str, foo: list}?.foo
+{foo: str, foo: list}?.str
 {foo: str, foo: map($env, 0)}
 {foo: str, foo: median(1.0)}
+{foo: str, foo: nil, foo: i}?.array
 {foo: str, foo: nil}.add
+{foo: str, foo: nil}.i
 {foo: str, foo: nil}?.Bar
 {foo: str, foo: nil}?.i
 {foo: str, foo: nil}?.list
+{foo: str, foo: ok, foo: $env}.add
 {foo: str, foo: ok, foo: array}
 {foo: str, foo: ok}
+{foo: str, foo: ok}.f64
 {foo: str, foo: ok}.list
 {foo: str, foo: ok}?.Bar
+{foo: str, foo: ok}?.String
+{foo: str, foo: ok}?.[str]
+{foo: str, foo: ok}?.foobar != foo
+{foo: str, foo: ok}?.greet
+{foo: str, foo: str, foo: true}?.add
 {foo: str, foo: str}
 {foo: str, foo: str}.add
+{foo: str, foo: str}.f64
 {foo: str, foo: str}.foo
+{foo: str, foo: str}?.array
 {foo: str, foo: str}?.greet
+{foo: str, foo: str}?.list
+{foo: str, foo: toJSON(0)}
+{foo: str, foo: true}.Bar
 {foo: str, foo: true}.array
 {foo: str, foo: true}.ok?.String
 {foo: str, foo: true}?.Bar
+{foo: str, foo: true}?.array
 {foo: str, foo: true}?.foo
 {foo: str, foo: true}?.i
+{foo: str, foo: true}?.ok
 {foo: str[:1]}
+{foo: str[:i]}
 {foo: string($env), foo: list}
 {foo: string($env)}
 {foo: string(0)}
 {foo: string(1)}
+{foo: string(1.0), foo: add}
 {foo: string(1.0)}
+{foo: string(add)}
 {foo: string(array)}
 {foo: string(array)}.foo
 {foo: string(f64)}
+{foo: string(false), foo: add}
 {foo: string(foo)}
 {foo: string(greet), foo: array}
 {foo: string(greet)}
+{foo: string(greet)}.greet
+{foo: string(i)}
 {foo: string(list), foo: i}
+{foo: string(list)}
 {foo: string(nil)}
 {foo: string(ok)}
 {foo: string(str)}
+{foo: string(str)}.i
 {foo: string(true)}
 {foo: str}
 {foo: str} != $env?.[Bar]
+{foo: str} != nil || $env
+{foo: str} ?? $env.i
+{foo: str} ?? str
 {foo: str}.Bar
 {foo: str}.String
+{foo: str}.String?.[ok]
 {foo: str}.add
 {foo: str}.array
 {foo: str}.f64
 {foo: str}.f64?.[list]
+{foo: str}.f64?.[str]
 {foo: str}.foo
 {foo: str}.foobar?.Bar
 {foo: str}.greet
@@ -22101,15 +43290,23 @@ values({foo: str})
 {foo: str}.greet?.array?.i
 {foo: str}.i
 {foo: str}.list
+{foo: str}.list?.[add]
 {foo: str}.ok
+{foo: str}.ok?.array
+{foo: str}.ok?.str
 {foo: str}.str
 {foo: str}?.Bar
 {foo: str}?.Bar?.String
+{foo: str}?.Bar?.[str]
 {foo: str}?.String
 {foo: str}?.String?.[i]
 {foo: str}?.[str]
+{foo: str}?.[str]?.greet
 {foo: str}?.add
+{foo: str}?.add?.add
 {foo: str}?.array
+{foo: str}?.array?.[i]
+{foo: str}?.array?.ok
 {foo: str}?.f64
 {foo: str}?.f64?.[f64]
 {foo: str}?.foo
@@ -22117,6 +43314,7 @@ values({foo: str})
 {foo: str}?.greet
 {foo: str}?.greet?.Bar
 {foo: str}?.greet?.greet
+{foo: str}?.greet?.i
 {foo: str}?.i
 {foo: str}?.i in array
 {foo: str}?.i?.[ok]
@@ -22127,15 +43325,22 @@ values({foo: str})
 {foo: str}?.ok not endsWith $env
 {foo: str}?.ok?.[ok]
 {foo: str}?.str
+{foo: str}?.str?.f64
 {foo: sum($env, 1)}
 {foo: sum($env, 1.0)}
 {foo: sum($env, f64)}
+{foo: sum($env, i)}
 {foo: sum(array), foo: list}
 {foo: sum(array), foo: ok}
 {foo: sum(array)}
+{foo: sum(array)}.String
+{foo: sum(array)}.foo
 {foo: sum(array)}?.array
 {foo: sum(array, #)}
 {foo: sum(array, 1.0)}
+{foo: sum(list, 1)}
+{foo: sum(list, 1.0)}
+{foo: take(list, 1)}
 {foo: toBase64(str)}
 {foo: toJSON(0)}
 {foo: toJSON(1)}
@@ -22145,6 +43350,7 @@ values({foo: str})
 {foo: toJSON(f64), foo: array}
 {foo: toJSON(f64)}
 {foo: toJSON(false)}
+{foo: toJSON(false)}.list
 {foo: toJSON(foo), foo: foo?.String}
 {foo: toJSON(foo)}
 {foo: toJSON(i), foo: add}
@@ -22156,42 +43362,81 @@ values({foo: str})
 {foo: toJSON(true)}
 {foo: toPairs($env), foo: list}
 {foo: toPairs($env)}
+{foo: trim(foo?.Bar)}
 {foo: trim(str)}
+{foo: trimPrefix(foo.Bar)}
 {foo: trimPrefix(str)}
 {foo: trimSuffix(str)}
 {foo: trimSuffix(string(nil))}
 {foo: true != $env}
 {foo: true != false}
 {foo: true != nil}
+{foo: true != ok}
 {foo: true && $env}
 {foo: true && true}
 {foo: true && true}.String
 {foo: true == $env}
+{foo: true == false}
+{foo: true == nil, foo: i}
 {foo: true == nil}
 {foo: true == true}
+{foo: true ? 1 : 1.0}
 {foo: true ? add : i}
+{foo: true ? false : greet}
+{foo: true ? list : 1}
 {foo: true ? ok : 0}
 {foo: true ?: foo}
+{foo: true ?? 0}
+{foo: true ?? 1}
+{foo: true ?? f64}
+{foo: true ?? foo}
+{foo: true ?? greet}
+{foo: true ?? nil}
+{foo: true ?? str}
+{foo: true and ok}
 {foo: true or $env}
+{foo: true or $env}?.[str]
+{foo: true or false}
+{foo: true or ok}
+{foo: true or true}
 {foo: true || $env}
 {foo: true || false}
 {foo: true || ok}
+{foo: true || true}
 {foo: true, foo: $env, foo: 1.0}?.greet
+{foo: true, foo: $env} ?? foo.Bar
+{foo: true, foo: $env}.array
 {foo: true, foo: $env}.f64
+{foo: true, foo: $env}.greet
 {foo: true, foo: $env}.i
 {foo: true, foo: $env}.list
 {foo: true, foo: $env}?.String
+{foo: true, foo: $env}?.[str]
 {foo: true, foo: $env}?.add
+{foo: true, foo: $env}?.array
+{foo: true, foo: $env}?.foo
 {foo: true, foo: $env}?.i
+{foo: true, foo: $env}?.list
 {foo: true, foo: $env}?.ok
+{foo: true, foo: 0} != array ?? ok
+{foo: true, foo: 0}.$env?.[i]?.f64?.[add]
+{foo: true, foo: 0}.foo
+{foo: true, foo: 0}.str
 {foo: true, foo: 0}?.array
+{foo: true, foo: 0}?.i
 {foo: true, foo: 1.0, foo: nil}.list
+{foo: true, foo: 1.0, foo: true}?.[str]
 {foo: true, foo: 1.0}.Bar
 {foo: true, foo: 1.0}.array
 {foo: true, foo: 1.0}.i
+{foo: true, foo: 1.0}.i?.[str].add
 {foo: true, foo: 1.0}.ok
+{foo: true, foo: 1.0}?.String
+{foo: true, foo: 1.0}?.f64
 {foo: true, foo: 1.0}?.i
+{foo: true, foo: 1.0}?.list
 {foo: true, foo: 1.0}?.ok
+{foo: true, foo: 1.0}?.str
 {foo: true, foo: 1}.Bar
 {foo: true, foo: 1}.array
 {foo: true, foo: 1}.foo
@@ -22199,23 +43444,41 @@ values({foo: str})
 {foo: true, foo: 1}?.[str]
 {foo: true, foo: 1}?.foo
 {foo: true, foo: 1}?.greet
+{foo: true, foo: 1}?.ok
+{foo: true, foo: 1}?.str
+{foo: true, foo: add}.add
 {foo: true, foo: add}.f64
+{foo: true, foo: add}.i
 {foo: true, foo: add}?.Bar
 {foo: true, foo: add}?.String
 {foo: true, foo: add}?.array
+{foo: true, foo: add}?.f64
 {foo: true, foo: add}?.greet
+{foo: true, foo: add}?.str
 {foo: true, foo: array}.add
+{foo: true, foo: array}.f64
 {foo: true, foo: array}.i
+{foo: true, foo: array}?.add
+{foo: true, foo: array}?.greet
 {foo: true, foo: f64}.greet
 {foo: true, foo: f64}.i
+{foo: true, foo: f64}.ok
+{foo: true, foo: f64}?.foo
 {foo: true, foo: false}.Bar
 {foo: true, foo: false}.i?.[ok]
 {foo: true, foo: false}?.foo
 {foo: true, foo: false}?.greet
+{foo: true, foo: false}?.i
+{foo: true, foo: foo}.Bar
 {foo: true, foo: foo}.String
+{foo: true, foo: foo}.array
+{foo: true, foo: foo}.f64
 {foo: true, foo: foo}.greet
+{foo: true, foo: foo}.i
 {foo: true, foo: foo}.ok
 {foo: true, foo: foo}.str?.list()
+{foo: true, foo: foo}?.Bar
+{foo: true, foo: foo}?.String
 {foo: true, foo: foo}?.[str]
 {foo: true, foo: foo}?.add
 {foo: true, foo: foo}?.f64
@@ -22224,33 +43487,60 @@ values({foo: str})
 {foo: true, foo: foo}?.ok
 {foo: true, foo: foo}?.str
 {foo: true, foo: greet}.Bar
+{foo: true, foo: greet}.array
 {foo: true, foo: greet}.f64
 {foo: true, foo: greet}.foo
 {foo: true, foo: greet}?.[str]
+{foo: true, foo: greet}?.f64
+{foo: true, foo: greet}?.str
 {foo: true, foo: i}.String
 {foo: true, foo: i}.add
 {foo: true, foo: i}.i
 {foo: true, foo: i}.str
 {foo: true, foo: i}?.Bar
+{foo: true, foo: i}?.[str]?.add
 {foo: true, foo: i}?.array
+{foo: true, foo: i}?.list
+{foo: true, foo: list}.String
+{foo: true, foo: list}.String?.Bar
+{foo: true, foo: list}.array
+{foo: true, foo: list}?.Bar
 {foo: true, foo: list}?.[str]
+{foo: true, foo: list}?.f64
+{foo: true, foo: list}?.foo
 {foo: true, foo: list}?.greet
+{foo: true, foo: nil, foo: i}?.i?.i
 {foo: true, foo: nil, foo: list}?.[str]
 {foo: true, foo: nil}.add
+{foo: true, foo: nil}?.Bar
 {foo: true, foo: nil}?.String
 {foo: true, foo: nil}?.add
+{foo: true, foo: nil}?.greet
+{foo: true, foo: ok, foo: 1.0}?.greet
 {foo: true, foo: ok}.Bar
+{foo: true, foo: ok}.add
+{foo: true, foo: ok}.array
 {foo: true, foo: ok}.foo
 {foo: true, foo: ok}.list
 {foo: true, foo: ok}?.[str]
 {foo: true, foo: str}.Bar
 {foo: true, foo: str}.array
 {foo: true, foo: str}.f64
+{foo: true, foo: str}.greet
+{foo: true, foo: str}.list
+{foo: true, foo: str}.ok
 {foo: true, foo: str}.str
 {foo: true, foo: str}?.array
+{foo: true, foo: str}?.array?.add
+{foo: true, foo: str}?.f64
 {foo: true, foo: str}?.greet
 {foo: true, foo: str}?.ok
+{foo: true, foo: true, foo: greet}?.f64
+{foo: true, foo: true}.add
+{foo: true, foo: true}.foo
+{foo: true, foo: true}.i
 {foo: true, foo: true}.list
+{foo: true, foo: true}?.array
 {foo: true} not in $env?.String
 {foo: true}.Bar
 {foo: true}.Bar?.[add]
@@ -22261,56 +43551,77 @@ values({foo: str})
 {foo: true}.array
 {foo: true}.f64
 {foo: true}.f64?.add
+{foo: true}.f64?.array.i()
 {foo: true}.false == add
 {foo: true}.foo
 {foo: true}.foo ? ok : nil
 {foo: true}.foobar
 {foo: true}.greet
 {foo: true}.i
+{foo: true}.i == i
 {foo: true}.list
 {foo: true}.list?.[str]
 {foo: true}.ok
+{foo: true}.ok?.add
 {foo: true}.ok?.array
 {foo: true}.str
+{foo: true}.str?.[list]
+{foo: true}.str?.ok
+{foo: true}?.$env ?? i
 {foo: true}?.Bar
 {foo: true}?.Bar?.[list]
+{foo: true}?.Bar?.f64
 {foo: true}?.Bar?.list
 {foo: true}?.String
+{foo: true}?.String?.[greet]
 {foo: true}?.String?.[ok]
 {foo: true}?.[str]
+{foo: true}?.[str]?.foo?.[greet]
 {foo: true}?.add
+{foo: true}?.add?.[add]
 {foo: true}?.add?.[foo]
 {foo: true}?.add?.ok
 {foo: true}?.array
 {foo: true}?.array?.[ok]
 {foo: true}?.f64
+{foo: true}?.f64?.[add]
 {foo: true}?.foo
+{foo: true}?.foobar?.i()
 {foo: true}?.greet
 {foo: true}?.greet?.[greet]
+{foo: true}?.greet?.foo
 {foo: true}?.greet?.greet
 {foo: true}?.i
 {foo: true}?.i?.Bar
+{foo: true}?.i?.[ok]
+{foo: true}?.i?.foo
 {foo: true}?.list
 {foo: true}?.list?.[greet]
 {foo: true}?.ok
 {foo: true}?.ok?.Bar
+{foo: true}?.ok?.[greet]?.list
 {foo: true}?.str
+{foo: true}?.str?.[f64]
 {foo: true}?.str?.greet
+{foo: true}?.str?.i
 {foo: type($env)}
 {foo: type(0)}
 {foo: type(1)}
 {foo: type(1.0)}
+{foo: type(1.0)}?.[str]
 {foo: type(1.0)}?.f64
 {foo: type(add)}
 {foo: type(array)}
 {foo: type(f64)}
 {foo: type(false)}
+{foo: type(foo), foo: add}
 {foo: type(foo), foo: f64}
 {foo: type(foo)}
 {foo: type(greet)}
 {foo: type(i)}
 {foo: type(list)}
 {foo: type(nil)}
+{foo: type(ok), foo: add}
 {foo: type(ok)}
 {foo: type(str)}
 {foo: type(true)}
@@ -22318,25 +43629,38 @@ values({foo: str})
 {foo: uniq(list)}
 {foo: upper(str)}
 {foo: values($env)}
+{foo: values($env)}.String
+{foo: {foo: $env, foo: i}}
 {foo: {foo: $env}}
+{foo: {foo: $env}}?.i
+{foo: {foo: 0, foo: $env}}
 {foo: {foo: 0, foo: 1.0}}
+{foo: {foo: 0, foo: foo, foo: $env}}
+{foo: {foo: 0, foo: foo}}
 {foo: {foo: 0, foo: nil}}
 {foo: {foo: 0}}
 {foo: {foo: 0}}?.array
 {foo: {foo: 0}}?.f64
 {foo: {foo: 1, foo: 0}}
+{foo: {foo: 1.0, foo: 1.0, foo: foo}}
 {foo: {foo: 1.0, foo: true}}
 {foo: {foo: 1.0}}
 {foo: {foo: 1}}
+{foo: {foo: add, foo: $env}}
 {foo: {foo: add, foo: foo}}
 {foo: {foo: add, foo: greet}}
+{foo: {foo: add}}
+{foo: {foo: array, foo: 1.0}}
 {foo: {foo: array}}
+{foo: {foo: f64, foo: $env}}
 {foo: {foo: f64}}
 {foo: {foo: false, foo: $env}?.foo}
 {foo: {foo: false}}
 {foo: {foo: false}}.Bar
 {foo: {foo: foo, foo: 1.0}}
+{foo: {foo: foo, foo: foo}}
 {foo: {foo: foo}, foo: $env?.greet}
+{foo: {foo: foo}?.String}
 {foo: {foo: foo}?.ok}
 {foo: {foo: foo}?.str}
 {foo: {foo: foo}}
@@ -22347,13 +43671,22 @@ values({foo: str})
 {foo: {foo: i, foo: array}}
 {foo: {foo: i}}
 {foo: {foo: list?.[0]}}
+{foo: {foo: list}, foo: f64}
+{foo: {foo: list}.String}
 {foo: {foo: list}}
+{foo: {foo: list}}?.String
 {foo: {foo: nil, foo: $env}}
+{foo: {foo: nil, foo: 1}}
 {foo: {foo: nil, foo: foo}}
+{foo: {foo: nil}, foo: $env?.String}
 {foo: {foo: nil}}
 {foo: {foo: ok, foo: nil}}
 {foo: {foo: ok, foo: true}}
+{foo: {foo: ok}, foo: ok}
+{foo: {foo: ok}?.[str], foo: f64}
 {foo: {foo: ok}}
 {foo: {foo: ok}}.list
+{foo: {foo: ok}}?.i
 {foo: {foo: str}}
+{foo: {foo: true, foo: foo}}
 {foo: {foo: true}}

From 0fcde75fea53412a9c08937571be624a937fce55 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Tue, 6 Jan 2026 00:39:55 +0200
Subject: [PATCH 478/506] perf(optimizer): add sum range optimization (#896)

Optimize sum(m..n) and reduce(m..n, # + #acc) with constant integer
bounds to compile-time constants using the arithmetic series formula.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 optimizer/optimizer.go      |   1 +
 optimizer/sum_range.go      | 172 +++++++++++++++++++++
 optimizer/sum_range_test.go | 289 ++++++++++++++++++++++++++++++++++++
 3 files changed, 462 insertions(+)
 create mode 100644 optimizer/sum_range.go
 create mode 100644 optimizer/sum_range_test.go

diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index 9a9677c1b..7ccbee548 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -40,6 +40,7 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &filterLast{})
 	Walk(node, &filterFirst{})
 	Walk(node, &predicateCombination{})
+	Walk(node, &sumRange{})
 	Walk(node, &sumArray{})
 	Walk(node, &sumMap{})
 	return nil
diff --git a/optimizer/sum_range.go b/optimizer/sum_range.go
new file mode 100644
index 000000000..92f6e1dac
--- /dev/null
+++ b/optimizer/sum_range.go
@@ -0,0 +1,172 @@
+package optimizer
+
+import (
+	. "github.com/expr-lang/expr/ast"
+)
+
+type sumRange struct{}
+
+func (*sumRange) Visit(node *Node) {
+	// Pattern 1: sum(m..n) or sum(m..n, predicate) where m and n are constant integers
+	if sumBuiltin, ok := (*node).(*BuiltinNode); ok &&
+		sumBuiltin.Name == "sum" &&
+		(len(sumBuiltin.Arguments) == 1 || len(sumBuiltin.Arguments) == 2) {
+		if rangeOp, ok := sumBuiltin.Arguments[0].(*BinaryNode); ok && rangeOp.Operator == ".." {
+			if from, ok := rangeOp.Left.(*IntegerNode); ok {
+				if to, ok := rangeOp.Right.(*IntegerNode); ok {
+					m := from.Value
+					n := to.Value
+					if n >= m {
+						count := n - m + 1
+						// Use the arithmetic series formula: (n - m + 1) * (m + n) / 2
+						sum := count * (m + n) / 2
+
+						if len(sumBuiltin.Arguments) == 1 {
+							// sum(m..n)
+							patchWithType(node, &IntegerNode{Value: sum})
+						} else if len(sumBuiltin.Arguments) == 2 {
+							// sum(m..n, predicate)
+							if result, ok := applySumPredicate(sum, count, sumBuiltin.Arguments[1]); ok {
+								patchWithType(node, &IntegerNode{Value: result})
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Pattern 2: reduce(m..n, # + #acc) where m and n are constant integers
+	if reduceBuiltin, ok := (*node).(*BuiltinNode); ok &&
+		reduceBuiltin.Name == "reduce" &&
+		(len(reduceBuiltin.Arguments) == 2 || len(reduceBuiltin.Arguments) == 3) {
+		if rangeOp, ok := reduceBuiltin.Arguments[0].(*BinaryNode); ok && rangeOp.Operator == ".." {
+			if from, ok := rangeOp.Left.(*IntegerNode); ok {
+				if to, ok := rangeOp.Right.(*IntegerNode); ok {
+					if isPointerPlusAcc(reduceBuiltin.Arguments[1]) {
+						m := from.Value
+						n := to.Value
+						if n >= m {
+							// Use the arithmetic series formula: (n - m + 1) * (m + n) / 2
+							sum := (n - m + 1) * (m + n) / 2
+
+							// Check for optional initialValue (3rd argument)
+							if len(reduceBuiltin.Arguments) == 3 {
+								if initialValue, ok := reduceBuiltin.Arguments[2].(*IntegerNode); ok {
+									result := initialValue.Value + sum
+									patchWithType(node, &IntegerNode{Value: result})
+								}
+							} else {
+								patchWithType(node, &IntegerNode{Value: sum})
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+// isPointerPlusAcc checks if the node represents `# + #acc` pattern
+func isPointerPlusAcc(node Node) bool {
+	predicate, ok := node.(*PredicateNode)
+	if !ok {
+		return false
+	}
+
+	binary, ok := predicate.Node.(*BinaryNode)
+	if !ok {
+		return false
+	}
+
+	if binary.Operator != "+" {
+		return false
+	}
+
+	// Check for # + #acc (pointer + accumulator)
+	leftPointer, leftIsPointer := binary.Left.(*PointerNode)
+	rightPointer, rightIsPointer := binary.Right.(*PointerNode)
+
+	if leftIsPointer && rightIsPointer {
+		// # + #acc: Left is pointer (Name=""), Right is acc (Name="acc")
+		if leftPointer.Name == "" && rightPointer.Name == "acc" {
+			return true
+		}
+		// #acc + #: Left is acc (Name="acc"), Right is pointer (Name="")
+		if leftPointer.Name == "acc" && rightPointer.Name == "" {
+			return true
+		}
+	}
+
+	return false
+}
+
+// applySumPredicate tries to compute the result of sum(m..n, predicate) at compile time.
+// Returns (result, true) if optimization is possible, (0, false) otherwise.
+// Supported predicates:
+//   - # (identity): result = sum
+//   - # * k (multiply by constant): result = k * sum
+//   - k * # (multiply by constant): result = k * sum
+//   - # + k (add constant): result = sum + count * k
+//   - k + # (add constant): result = sum + count * k
+//   - # - k (subtract constant): result = sum - count * k
+func applySumPredicate(sum, count int, predicateArg Node) (int, bool) {
+	predicate, ok := predicateArg.(*PredicateNode)
+	if !ok {
+		return 0, false
+	}
+
+	// Case 1: # (identity) - just return the sum
+	if pointer, ok := predicate.Node.(*PointerNode); ok && pointer.Name == "" {
+		return sum, true
+	}
+
+	// Case 2: Binary operations with pointer and constant
+	binary, ok := predicate.Node.(*BinaryNode)
+	if !ok {
+		return 0, false
+	}
+
+	pointer, constant, pointerOnLeft := extractPointerAndConstantWithPosition(binary)
+	if pointer == nil || constant == nil {
+		return 0, false
+	}
+
+	switch binary.Operator {
+	case "*":
+		// # * k or k * # => k * sum
+		return constant.Value * sum, true
+	case "+":
+		// # + k or k + # => sum + count * k
+		return sum + count*constant.Value, true
+	case "-":
+		if pointerOnLeft {
+			// # - k => sum - count * k
+			return sum - count*constant.Value, true
+		}
+		// k - # => count * k - sum
+		return count*constant.Value - sum, true
+	}
+
+	return 0, false
+}
+
+// extractPointerAndConstantWithPosition extracts pointer (#) and integer constant from a binary node.
+// Returns (pointer, constant, pointerOnLeft) or (nil, nil, false) if not matching the expected pattern.
+func extractPointerAndConstantWithPosition(binary *BinaryNode) (*PointerNode, *IntegerNode, bool) {
+	// Try left=pointer, right=constant
+	if pointer, ok := binary.Left.(*PointerNode); ok && pointer.Name == "" {
+		if constant, ok := binary.Right.(*IntegerNode); ok {
+			return pointer, constant, true
+		}
+	}
+
+	// Try left=constant, right=pointer
+	if constant, ok := binary.Left.(*IntegerNode); ok {
+		if pointer, ok := binary.Right.(*PointerNode); ok && pointer.Name == "" {
+			return pointer, constant, false
+		}
+	}
+
+	return nil, nil, false
+}
diff --git a/optimizer/sum_range_test.go b/optimizer/sum_range_test.go
new file mode 100644
index 000000000..87185b227
--- /dev/null
+++ b/optimizer/sum_range_test.go
@@ -0,0 +1,289 @@
+package optimizer_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
+)
+
+func TestOptimize_sum_range(t *testing.T) {
+	tree, err := parser.Parse(`sum(1..100)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.IntegerNode{Value: 5050}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_sum_range_different_values(t *testing.T) {
+	tests := []struct {
+		expr string
+		want int
+	}{
+		{`sum(1..10)`, 55},
+		{`sum(1..100)`, 5050},
+		{`sum(5..10)`, 45},
+		{`sum(0..100)`, 5050},
+		{`sum(1..1)`, 1},
+		{`sum(0..0)`, 0},
+		{`sum(10..20)`, 165},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+		})
+	}
+}
+
+func TestOptimize_sum_range_with_predicate(t *testing.T) {
+	tests := []struct {
+		expr string
+		want int
+	}{
+		// # (identity) - same as sum(m..n)
+		{`sum(1..10, #)`, 55},
+		{`sum(1..100, #)`, 5050},
+
+		// # * k (multiply by constant)
+		{`sum(1..10, # * 2)`, 110},    // 2 * 55
+		{`sum(1..100, # * 2)`, 10100}, // 2 * 5050
+		{`sum(1..10, # * 0)`, 0},
+		{`sum(1..10, # * 1)`, 55},
+
+		// k * # (multiply by constant, reversed)
+		{`sum(1..10, 2 * #)`, 110},
+		{`sum(1..100, 3 * #)`, 15150}, // 3 * 5050
+
+		// # + k (add constant to each element)
+		{`sum(1..10, # + 1)`, 65},    // 55 + 10*1
+		{`sum(1..100, # + 1)`, 5150}, // 5050 + 100*1
+		{`sum(1..10, # + 0)`, 55},
+		{`sum(1..10, # + 10)`, 155}, // 55 + 10*10
+
+		// k + # (add constant, reversed)
+		{`sum(1..10, 1 + #)`, 65},
+		{`sum(1..100, 5 + #)`, 5550}, // 5050 + 100*5
+
+		// # - k (subtract constant from each element)
+		{`sum(1..10, # - 1)`, 45},    // 55 - 10*1
+		{`sum(1..100, # - 1)`, 4950}, // 5050 - 100*1
+		{`sum(1..10, # - 0)`, 55},
+
+		// k - # (constant minus each element)
+		{`sum(1..10, 10 - #)`, 45}, // 10*10 - 55
+		{`sum(1..10, 0 - #)`, -55}, // 10*0 - 55
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+		})
+	}
+}
+
+func TestOptimize_sum_range_with_predicate_ast(t *testing.T) {
+	// Verify that sum(1..10, # * 2) is optimized to a constant
+	tree, err := parser.Parse(`sum(1..10, # * 2)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.IntegerNode{Value: 110}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_reduce_range_sum(t *testing.T) {
+	tree, err := parser.Parse(`reduce(1..100, # + #acc)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.IntegerNode{Value: 5050}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_reduce_range_sum_different_values(t *testing.T) {
+	tests := []struct {
+		expr string
+		want int
+	}{
+		{`reduce(1..10, # + #acc)`, 55},
+		{`reduce(1..100, # + #acc)`, 5050},
+		{`reduce(5..10, # + #acc)`, 45},
+		{`reduce(0..100, # + #acc)`, 5050},
+		{`reduce(1..1, # + #acc)`, 1},
+		{`reduce(10..20, # + #acc)`, 165},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+		})
+	}
+}
+
+func TestOptimize_reduce_range_sum_reverse_order(t *testing.T) {
+	// Test #acc + # (reverse order) - should also be optimized
+	tree, err := parser.Parse(`reduce(1..100, #acc + #)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.IntegerNode{Value: 5050}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_reduce_range_sum_with_initial_value(t *testing.T) {
+	// Test reduce with initialValue: reduce(1..100, # + #acc, 10) => 5050 + 10 = 5060
+	tree, err := parser.Parse(`reduce(1..100, # + #acc, 10)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &ast.IntegerNode{Value: 5060}
+
+	assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node))
+}
+
+func TestOptimize_reduce_range_sum_with_initial_value_different_values(t *testing.T) {
+	tests := []struct {
+		expr string
+		want int
+	}{
+		{`reduce(1..10, # + #acc, 0)`, 55},
+		{`reduce(1..10, # + #acc, 10)`, 65},
+		{`reduce(1..100, # + #acc, 0)`, 5050},
+		{`reduce(1..100, # + #acc, 100)`, 5150},
+		{`reduce(5..10, # + #acc, 5)`, 50},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+		})
+	}
+}
+
+func TestOptimize_sum_range_reversed(t *testing.T) {
+	// When n < m (e.g., 10..1), the range is empty and sum should return 0.
+	// The optimization should NOT apply (n >= m check), so runtime handles it.
+	tests := []struct {
+		expr string
+		want int
+	}{
+		{`sum(10..1)`, 0},
+		{`sum(5..3)`, 0},
+		{`sum(100..1)`, 0},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+		})
+	}
+}
+
+func TestOptimize_sum_range_reversed_not_optimized(t *testing.T) {
+	// Verify that reversed ranges are NOT optimized (left as BuiltinNode)
+	tree, err := parser.Parse(`sum(10..1)`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	// Should still be a BuiltinNode, not an IntegerNode
+	_, isBuiltin := tree.Node.(*ast.BuiltinNode)
+	assert.True(t, isBuiltin, "reversed range should not be optimized")
+}
+
+func TestOptimize_reduce_range_reversed_errors(t *testing.T) {
+	// reduce on empty range (reversed) should error at runtime
+	program, err := expr.Compile(`reduce(10..1, # + #acc)`)
+	require.NoError(t, err)
+
+	_, err = expr.Run(program, nil)
+	require.Error(t, err, "reduce on empty range should error")
+}
+
+func BenchmarkSumRange_Optimized(b *testing.B) {
+	program, err := expr.Compile(`sum(1..100)`)
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = expr.Run(program, nil)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 5050, out)
+}
+
+func BenchmarkReduceRangeSum_Optimized(b *testing.B) {
+	program, err := expr.Compile(`reduce(1..100, # + #acc)`)
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = expr.Run(program, nil)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 5050, out)
+}
+
+func BenchmarkSumRange_Unoptimized(b *testing.B) {
+	program, err := expr.Compile(`sum(1..100)`, expr.Optimize(false))
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = expr.Run(program, nil)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 5050, out)
+}

From 13c5b65f9bab45fcc942320a64e94ec92972641a Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Tue, 6 Jan 2026 17:57:59 +0200
Subject: [PATCH 479/506] perf(optimizer): count comparisons to any (#897)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Optimize count(...) comparisons to use any/none builtins which support
early exit on first matching element:

- count(arr, pred) > 0   → any(arr, pred)
- count(arr, pred) >= 1  → any(arr, pred)

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 optimizer/count_any.go      |  36 ++++++++
 optimizer/count_any_test.go | 166 ++++++++++++++++++++++++++++++++++++
 optimizer/optimizer.go      |   1 +
 3 files changed, 203 insertions(+)
 create mode 100644 optimizer/count_any.go
 create mode 100644 optimizer/count_any_test.go

diff --git a/optimizer/count_any.go b/optimizer/count_any.go
new file mode 100644
index 000000000..e0c50d21d
--- /dev/null
+++ b/optimizer/count_any.go
@@ -0,0 +1,36 @@
+package optimizer
+
+import (
+	. "github.com/expr-lang/expr/ast"
+)
+
+// countAny optimizes count comparisons to use any for early termination.
+// Patterns:
+//   - count(arr, pred) > 0  → any(arr, pred)
+//   - count(arr, pred) >= 1 → any(arr, pred)
+type countAny struct{}
+
+func (*countAny) Visit(node *Node) {
+	binary, ok := (*node).(*BinaryNode)
+	if !ok {
+		return
+	}
+
+	count, ok := binary.Left.(*BuiltinNode)
+	if !ok || count.Name != "count" || len(count.Arguments) != 2 {
+		return
+	}
+
+	integer, ok := binary.Right.(*IntegerNode)
+	if !ok {
+		return
+	}
+
+	if (binary.Operator == ">" && integer.Value == 0) ||
+		(binary.Operator == ">=" && integer.Value == 1) {
+		patchCopyType(node, &BuiltinNode{
+			Name:      "any",
+			Arguments: count.Arguments,
+		})
+	}
+}
diff --git a/optimizer/count_any_test.go b/optimizer/count_any_test.go
new file mode 100644
index 000000000..18c608c34
--- /dev/null
+++ b/optimizer/count_any_test.go
@@ -0,0 +1,166 @@
+package optimizer_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/vm"
+)
+
+func TestOptimize_count_any(t *testing.T) {
+	tree, err := parser.Parse(`count(items, .active) > 0`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &BuiltinNode{
+		Name: "any",
+		Arguments: []Node{
+			&IdentifierNode{Value: "items"},
+			&PredicateNode{
+				Node: &MemberNode{
+					Node:     &PointerNode{},
+					Property: &StringNode{Value: "active"},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, Dump(expected), Dump(tree.Node))
+}
+
+func TestOptimize_count_any_gte_one(t *testing.T) {
+	tree, err := parser.Parse(`count(items, .valid) >= 1`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &BuiltinNode{
+		Name: "any",
+		Arguments: []Node{
+			&IdentifierNode{Value: "items"},
+			&PredicateNode{
+				Node: &MemberNode{
+					Node:     &PointerNode{},
+					Property: &StringNode{Value: "valid"},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, Dump(expected), Dump(tree.Node))
+}
+
+func TestOptimize_count_any_correctness(t *testing.T) {
+	tests := []struct {
+		expr string
+		want bool
+	}{
+		// count > 0 → any
+		{`count(1..100, # == 1) > 0`, true},
+		{`count(1..100, # == 50) > 0`, true},
+		{`count(1..100, # == 100) > 0`, true},
+		{`count(1..100, # == 0) > 0`, false},
+
+		// count >= 1 → any
+		{`count(1..100, # % 10 == 0) >= 1`, true},
+		{`count(1..100, # > 100) >= 1`, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+		})
+	}
+}
+
+func TestOptimize_count_no_optimization(t *testing.T) {
+	// These should NOT be optimized
+	tests := []string{
+		`count(items, .active) > 1`,  // not > 0
+		`count(items, .active) >= 2`, // not >= 1
+		`count(items, .active) == 0`, // not optimized (none has overhead)
+		`count(items, .active) == 1`, // not == 0
+		`count(items, .active) < 1`,  // not optimized (none has overhead)
+		`count(items, .active) <= 0`, // not optimized (none has overhead)
+		`count(items, .active) != 0`, // different operator
+	}
+
+	for _, code := range tests {
+		t.Run(code, func(t *testing.T) {
+			tree, err := parser.Parse(code)
+			require.NoError(t, err)
+
+			err = optimizer.Optimize(&tree.Node, nil)
+			require.NoError(t, err)
+
+			// Should still be a BinaryNode (not optimized to any)
+			_, ok := tree.Node.(*BinaryNode)
+			assert.True(t, ok, "expected BinaryNode, got %T", tree.Node)
+		})
+	}
+}
+
+// Benchmarks for count > 0 → any
+func BenchmarkCountGtZero(b *testing.B) {
+	program, _ := expr.Compile(`count(1..1000, # == 1) > 0`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+func BenchmarkCountGtZeroLargeEarlyMatch(b *testing.B) {
+	program, _ := expr.Compile(`count(1..10000, # == 1) > 0`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+func BenchmarkCountGtZeroNoMatch(b *testing.B) {
+	program, _ := expr.Compile(`count(1..1000, # == 0) > 0`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+// Benchmarks for count >= 1 → any
+func BenchmarkCountGteOneEarlyMatch(b *testing.B) {
+	program, _ := expr.Compile(`count(1..1000, # == 1) >= 1`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+func BenchmarkCountGteOneNoMatch(b *testing.B) {
+	program, _ := expr.Compile(`count(1..1000, # == 0) >= 1`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index 7ccbee548..fedf0208a 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -43,6 +43,7 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &sumRange{})
 	Walk(node, &sumArray{})
 	Walk(node, &sumMap{})
+	Walk(node, &countAny{})
 	return nil
 }
 

From de0da09604e38f105e7ba37c95627368695d19e6 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Wed, 7 Jan 2026 21:21:22 +0200
Subject: [PATCH 480/506] fix(fuzz): handle bare "invalid argument" (#899)

OSS-Fuzz finding #471520156 had an assert caused by the
time.LoadLocation outputting "invalid argument" for a null byte
argument. The fuzz test was already intentionally skipping
"invalid argument for" as a regex, which didn't match this err
string.

Changes:

- Simplify regex to match both "invalid argument for X" and bare form
- Remove redundant "operator in" pattern (covered by wildcard variant)

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 test/fuzz/fuzz_test.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 78f910db9..c7583b7bf 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -26,7 +26,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`error parsing regexp`),
 		regexp.MustCompile(`integer divide by zero`),
 		regexp.MustCompile(`interface conversion`),
-		regexp.MustCompile(`invalid argument for .*`),
+		regexp.MustCompile(`invalid argument`),
 		regexp.MustCompile(`invalid character`),
 		regexp.MustCompile(`invalid operation`),
 		regexp.MustCompile(`invalid duration`),
@@ -46,7 +46,6 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`reflect: string index out of range`),
 		regexp.MustCompile(`strings: negative Repeat count`),
 		regexp.MustCompile(`strings: illegal bytes to escape`),
-		regexp.MustCompile(`operator "in" not defined on int`),
 		regexp.MustCompile(`invalid date .*`),
 		regexp.MustCompile(`cannot parse .* as .*`),
 		regexp.MustCompile(`operator "in" not defined on .*`),

From 02f92c2a78e45571ed71e27246beaec95a19fe42 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 8 Jan 2026 16:43:41 +0200
Subject: [PATCH 481/506] feat(parser): add bytes literal syntax (#894)

Implements bytes literals, which return []byte directly and
interpret \x and octal escapes as raw byte values (0-255) rather
than Unicode codepoints.

Components:

- lexer/token: add Bytes token kind
- lexer/state: detect [bB]'...' and [bB]"..." prefix, emit Bytes token
- lexer/utils: add unescapeBytes and unescapeByteChar functions
  for byte-level escape handling ((no \u/\U support, 0-255 limit)
- parser: parse Bytes token into BytesNode
- ast/node: add BytesNode struct with []byte value
- ast/visitor: handle BytesNode in AST walker
- ast/print: add String() method
- checker: type inference returns []byte
- compiler: emit push for BytesNode value

Updated docs.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 ast/node.go                 |   6 ++
 ast/print.go                |   4 ++
 ast/visitor.go              |   1 +
 checker/checker.go          |   3 +
 compiler/compiler.go        |   6 ++
 docs/language-definition.md |  38 +++++++++++
 expr_test.go                |  70 ++++++++++++++++++++
 parser/lexer/lexer_test.go  |  56 ++++++++++++++++
 parser/lexer/state.go       |   8 +++
 parser/lexer/token.go       |   1 +
 parser/lexer/utils.go       | 128 ++++++++++++++++++++++++++++++++++++
 parser/parser.go            |   7 ++
 parser/parser_test.go       |   8 +++
 13 files changed, 336 insertions(+)

diff --git a/ast/node.go b/ast/node.go
index f17fd7e52..198efa59b 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -104,6 +104,12 @@ type StringNode struct {
 	Value string // Value of the string.
 }
 
+// BytesNode represents a byte slice.
+type BytesNode struct {
+	base
+	Value []byte // Value of the byte slice.
+}
+
 // ConstantNode represents a constant.
 // Constants are predefined values like nil, true, false, array, map, etc.
 // The parser.Parse will never generate ConstantNode, it is only generated
diff --git a/ast/print.go b/ast/print.go
index 527a5b99b..1c197445e 100644
--- a/ast/print.go
+++ b/ast/print.go
@@ -33,6 +33,10 @@ func (n *StringNode) String() string {
 	return fmt.Sprintf("%q", n.Value)
 }
 
+func (n *BytesNode) String() string {
+	return fmt.Sprintf("b%q", n.Value)
+}
+
 func (n *ConstantNode) String() string {
 	if n.Value == nil {
 		return "nil"
diff --git a/ast/visitor.go b/ast/visitor.go
index 72cd6366b..ef23758e1 100644
--- a/ast/visitor.go
+++ b/ast/visitor.go
@@ -17,6 +17,7 @@ func Walk(node *Node, v Visitor) {
 	case *FloatNode:
 	case *BoolNode:
 	case *StringNode:
+	case *BytesNode:
 	case *ConstantNode:
 	case *UnaryNode:
 		Walk(&n.Node, v)
diff --git a/checker/checker.go b/checker/checker.go
index 2a9e234a1..b78afc2b4 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -24,6 +24,7 @@ var (
 	mapType      = reflect.TypeOf(map[string]any{})
 	timeType     = reflect.TypeOf(time.Time{})
 	durationType = reflect.TypeOf(time.Duration(0))
+	byteSliceType = reflect.TypeOf([]byte(nil))
 
 	anyTypeSlice = []reflect.Type{anyType}
 )
@@ -194,6 +195,8 @@ func (v *Checker) visit(node ast.Node) Nature {
 		nt = v.config.NtCache.FromType(boolType)
 	case *ast.StringNode:
 		nt = v.config.NtCache.FromType(stringType)
+	case *ast.BytesNode:
+		nt = v.config.NtCache.FromType(byteSliceType)
 	case *ast.ConstantNode:
 		nt = v.config.NtCache.FromType(reflect.TypeOf(n.Value))
 	case *ast.UnaryNode:
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 5de89f54c..951385cdb 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -254,6 +254,8 @@ func (c *compiler) compile(node ast.Node) {
 		c.BoolNode(n)
 	case *ast.StringNode:
 		c.StringNode(n)
+	case *ast.BytesNode:
+		c.BytesNode(n)
 	case *ast.ConstantNode:
 		c.ConstantNode(n)
 	case *ast.UnaryNode:
@@ -410,6 +412,10 @@ func (c *compiler) StringNode(node *ast.StringNode) {
 	c.emitPush(node.Value)
 }
 
+func (c *compiler) BytesNode(node *ast.BytesNode) {
+	c.emitPush(node.Value)
+}
+
 func (c *compiler) ConstantNode(node *ast.ConstantNode) {
 	if node.Value == nil {
 		c.emit(OpNil)
diff --git a/docs/language-definition.md b/docs/language-definition.md
index 5e530a57d..69efbdfa9 100644
--- a/docs/language-definition.md
+++ b/docs/language-definition.md
@@ -53,6 +53,12 @@
             <code>nil</code>
         </td>
     </tr>
+    <tr>
+        <td><strong>Bytes</strong></td>
+        <td>
+            <code>b"hello"</code>, <code>b'\xff\x00'</code>
+        </td>
+    </tr>
 </table>
 
 ### Strings
@@ -73,6 +79,38 @@ World`
 
 Backticks strings are raw strings, they do not support escape sequences.
 
+### Bytes
+
+Bytes literals are represented by string literals preceded by a `b` or `B` character.
+The bytes literal returns a `[]byte` value.
+
+```expr
+b"abc" // []byte{97, 98, 99}
+```
+
+Non-ASCII characters are UTF-8 encoded:
+
+```expr
+b"ÿ" // []byte{195, 191} - UTF-8 encoding of ÿ
+```
+
+Bytes literals support escape sequences for specifying arbitrary byte values:
+
+- `\xNN` - hexadecimal escape (2 hex digits, value 0-255)
+- `\NNN` - octal escape (3 octal digits, value 0-377)
+- `\n`, `\t`, `\r`, etc. - standard escape sequences
+
+```expr
+b"\xff"     // []byte{255}
+b"\x00\x01" // []byte{0, 1}
+b"\101"     // []byte{65} - octal for 'A'
+```
+
+:::note
+Unlike string literals, bytes literals do not support `\u` or `\U` Unicode escapes.
+Use `\x` escapes for arbitrary byte values.
+:::
+
 ## Operators
 
 <table>
diff --git a/expr_test.go b/expr_test.go
index ba1f001ec..28b2c54be 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -70,6 +70,19 @@ func ExampleCompile() {
 	// Output: true
 }
 
+func ExampleEval_bytes_literal() {
+	// Bytes literal returns []byte.
+	output, err := expr.Eval(`b"abc"`, nil)
+	if err != nil {
+		fmt.Printf("%v", err)
+		return
+	}
+
+	fmt.Printf("%v", output)
+
+	// Output: [97 98 99]
+}
+
 func TestDisableIfOperator_AllowsIfFunction(t *testing.T) {
 	env := map[string]any{
 		"if": func(x int) int { return x + 1 },
@@ -2929,3 +2942,60 @@ func TestDisableShortCircuit(t *testing.T) {
 	assert.Equal(t, 3, count)
 	assert.True(t, got.(bool))
 }
+
+func TestBytesLiteral(t *testing.T) {
+	tests := []struct {
+		code string
+		want []byte
+	}{
+		{`b"hello"`, []byte("hello")},
+		{`b'world'`, []byte("world")},
+		{`b""`, []byte{}},
+		{`b'\x00\xff'`, []byte{0, 255}},
+		{`b"\x41\x42\x43"`, []byte("ABC")},
+		{`b'\101\102\103'`, []byte("ABC")},
+		{`b'\n\t\r'`, []byte{'\n', '\t', '\r'}},
+		{`b'hello\x00world'`, []byte("hello\x00world")},
+		{`b"ÿ"`, []byte{0xc3, 0xbf}}, // UTF-8 encoding of ÿ
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			program, err := expr.Compile(tt.code)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+		})
+	}
+}
+
+func TestBytesLiteral_type(t *testing.T) {
+	env := map[string]any{
+		"data": []byte("test"),
+	}
+
+	// Verify bytes literal has []byte type and can be compared with []byte
+	program, err := expr.Compile(`data == b"test"`, expr.Env(env))
+	require.NoError(t, err)
+
+	output, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, true, output)
+}
+
+func TestBytesLiteral_errors(t *testing.T) {
+	// \u and \U escapes should not be allowed in bytes literals
+	errorCases := []string{
+		`b'\u0041'`,
+		`b"\U00000041"`,
+	}
+
+	for _, code := range errorCases {
+		t.Run(code, func(t *testing.T) {
+			_, err := expr.Compile(code)
+			require.Error(t, err)
+		})
+	}
+}
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index f46870e9b..6212d066f 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -299,6 +299,52 @@ func TestLex(t *testing.T) {
 				{Kind: EOF},
 			},
 		},
+		{
+			`b"hello" b'world'`,
+			[]Token{
+				{Kind: Bytes, Value: "hello"},
+				{Kind: Bytes, Value: "world"},
+				{Kind: EOF},
+			},
+		},
+		{
+			`b"\x00\xff" b'\x41\x42\x43'`,
+			[]Token{
+				{Kind: Bytes, Value: "\x00\xff"},
+				{Kind: Bytes, Value: "ABC"},
+				{Kind: EOF},
+			},
+		},
+		{
+			`b"\101\102\103" b'\n\t\r'`,
+			[]Token{
+				{Kind: Bytes, Value: "ABC"},
+				{Kind: Bytes, Value: "\n\t\r"},
+				{Kind: EOF},
+			},
+		},
+		{
+			`b""`,
+			[]Token{
+				{Kind: Bytes, Value: ""},
+				{Kind: EOF},
+			},
+		},
+		{
+			`B"hello" B'world'`,
+			[]Token{
+				{Kind: Bytes, Value: "hello"},
+				{Kind: Bytes, Value: "world"},
+				{Kind: EOF},
+			},
+		},
+		{
+			`b"ÿ"`,
+			[]Token{
+				{Kind: Bytes, Value: "\xc3\xbf"},
+				{Kind: EOF},
+			},
+		},
 	}
 
 	for _, test := range tests {
@@ -380,6 +426,16 @@ früh ♥︎
 unrecognized character: U+2665 '♥' (1:6)
  | früh ♥︎
  | .....^
+
+b"\u0041"
+unable to unescape string (1:9)
+ | b"\u0041"
+ | ........^
+
+b'\U00000041'
+unable to unescape string (1:13)
+ | b'\U00000041'
+ | ............^
 `
 
 func TestLex_error(t *testing.T) {
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index 91857eade..d606258b2 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -25,6 +25,14 @@ func root(l *Lexer) stateFn {
 		l.emitValue(String, str)
 	case r == '`':
 		l.scanRawString(r)
+	case (r == 'b' || r == 'B') && (l.peek() == '\'' || l.peek() == '"'):
+		quote := l.next()
+		l.scanString(quote)
+		str, err := unescapeBytes(l.word()[1:]) // skip 'b'
+		if err != nil {
+			l.error("%v", err)
+		}
+		l.emitValue(Bytes, str)
 	case '0' <= r && r <= '9':
 		l.backup()
 		return number
diff --git a/parser/lexer/token.go b/parser/lexer/token.go
index c809c690e..1041784e7 100644
--- a/parser/lexer/token.go
+++ b/parser/lexer/token.go
@@ -12,6 +12,7 @@ const (
 	Identifier Kind = "Identifier"
 	Number     Kind = "Number"
 	String     Kind = "String"
+	Bytes      Kind = "Bytes"
 	Operator   Kind = "Operator"
 	Bracket    Kind = "Bracket"
 	EOF        Kind = "EOF"
diff --git a/parser/lexer/utils.go b/parser/lexer/utils.go
index 6aa088ae3..13cb5f314 100644
--- a/parser/lexer/utils.go
+++ b/parser/lexer/utils.go
@@ -54,6 +54,49 @@ func unescape(value string) (string, error) {
 	return buf.String(), nil
 }
 
+// unescapeBytes takes a quoted string, unquotes, and unescapes it as bytes.
+func unescapeBytes(value string) (string, error) {
+	// All strings normalize newlines to the \n representation.
+	value = newlineNormalizer.Replace(value)
+	n := len(value)
+
+	// Nothing to unescape / decode.
+	if n < 2 {
+		return value, fmt.Errorf("unable to unescape string")
+	}
+
+	// Quoted string of some form, must have same first and last char.
+	if value[0] != value[n-1] || (value[0] != '"' && value[0] != '\'') {
+		return value, fmt.Errorf("unable to unescape string")
+	}
+
+	value = value[1 : n-1]
+
+	// The string contains escape characters.
+	// The following logic is adapted from `strconv/quote.go`
+	var runeTmp [utf8.UTFMax]byte
+	size := 3 * uint64(n) / 2
+	if size >= math.MaxInt {
+		return "", fmt.Errorf("too large string")
+	}
+	buf := new(strings.Builder)
+	buf.Grow(int(size))
+	for len(value) > 0 {
+		c, multibyte, rest, err := unescapeByteChar(value)
+		if err != nil {
+			return "", err
+		}
+		value = rest
+		if c < utf8.RuneSelf || !multibyte {
+			buf.WriteByte(byte(c))
+		} else {
+			n := utf8.EncodeRune(runeTmp[:], c)
+			buf.Write(runeTmp[:n])
+		}
+	}
+	return buf.String(), nil
+}
+
 // unescapeChar takes a string input and returns the following info:
 //
 //	value - the escaped unicode rune at the front of the string.
@@ -208,6 +251,91 @@ func unescapeChar(s string) (value rune, multibyte bool, tail string, err error)
 	return
 }
 
+// unescapeByteChar unescapes a single character or escape sequence from a bytes literal.
+// Unlike unescapeChar, this only supports byte-level escapes (\x, octal) and rejects
+// Unicode escapes (\u, \U) since bytes literals represent raw byte sequences.
+//
+// Note: We cannot use strconv.UnquoteChar here because it interprets \x and octal
+// escapes as Unicode codepoints (e.g., \xff → codepoint 255 → 2 UTF-8 bytes),
+// whereas bytes literals require them as raw byte values (\xff → single byte 255).
+func unescapeByteChar(s string) (value rune, multibyte bool, tail string, err error) {
+	// Non-escape: return the character as-is.
+	// For bytes literals, we accept UTF-8 sequences but they get encoded back to bytes.
+	c := s[0]
+	if c != '\\' {
+		if c >= utf8.RuneSelf {
+			r, size := utf8.DecodeRuneInString(s)
+			return r, true, s[size:], nil
+		}
+		return rune(c), false, s[1:], nil
+	}
+
+	// Escape sequence: need at least one more character.
+	if len(s) <= 1 {
+		return 0, false, "", fmt.Errorf("unable to unescape string, found '\\' as last character")
+	}
+
+	c = s[1]
+	s = s[2:]
+
+	switch c {
+	// Simple escape sequences
+	case 'a':
+		return '\a', false, s, nil
+	case 'b':
+		return '\b', false, s, nil
+	case 'f':
+		return '\f', false, s, nil
+	case 'n':
+		return '\n', false, s, nil
+	case 'r':
+		return '\r', false, s, nil
+	case 't':
+		return '\t', false, s, nil
+	case 'v':
+		return '\v', false, s, nil
+	case '\\':
+		return '\\', false, s, nil
+	case '\'':
+		return '\'', false, s, nil
+	case '"':
+		return '"', false, s, nil
+	case '`':
+		return '`', false, s, nil
+	case '?':
+		return '?', false, s, nil
+
+	// Hex escape: \xNN (exactly 2 hex digits, value 0-255)
+	case 'x', 'X':
+		if len(s) < 2 {
+			return 0, false, "", fmt.Errorf("unable to unescape string")
+		}
+		hi, ok1 := unhex(s[0])
+		lo, ok2 := unhex(s[1])
+		if !ok1 || !ok2 {
+			return 0, false, "", fmt.Errorf("unable to unescape string")
+		}
+		return hi<<4 | lo, false, s[2:], nil
+
+	// Octal escape: \NNN (3 octal digits, value 0-255)
+	case '0', '1', '2', '3':
+		if len(s) < 2 {
+			return 0, false, "", fmt.Errorf("unable to unescape octal sequence in string")
+		}
+		if s[0] < '0' || s[0] > '7' || s[1] < '0' || s[1] > '7' {
+			return 0, false, "", fmt.Errorf("unable to unescape octal sequence in string")
+		}
+		v := rune(c-'0')*64 + rune(s[0]-'0')*8 + rune(s[1]-'0')
+		if v > 255 {
+			return 0, false, "", fmt.Errorf("unable to unescape string")
+		}
+		return v, false, s[2:], nil
+
+	default:
+		return 0, false, "", fmt.Errorf("unable to unescape string")
+	}
+}
+
 func unhex(b byte) (rune, bool) {
 	c := rune(b)
 	switch {
diff --git a/parser/parser.go b/parser/parser.go
index 9ccf47830..a0c6d4491 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -530,6 +530,13 @@ func (p *Parser) parseSecondary() Node {
 			return nil
 		}
 
+	case Bytes:
+		p.next()
+		node = p.createNode(&BytesNode{Value: []byte(token.Value)}, token.Location)
+		if node == nil {
+			return nil
+		}
+
 	default:
 		if token.Is(Bracket, "[") {
 			node = p.parseArrayExpression(token)
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 85c465750..963a23050 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -87,6 +87,14 @@ world`},
 			"nil",
 			&NilNode{},
 		},
+		{
+			`b"hello"`,
+			&BytesNode{Value: []byte("hello")},
+		},
+		{
+			`b'\xff\x00'`,
+			&BytesNode{Value: []byte{255, 0}},
+		},
 		{
 			"-3",
 			&UnaryNode{Operator: "-",

From ebbe1bac9de77c0bd042e78cfed09b65645d77f1 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sun, 11 Jan 2026 23:20:16 +0200
Subject: [PATCH 482/506] fix(fuzz): skip time parsing errors (#901)

Add "parsing time .*" pattern to skip list to handle Go time.Parse
errors like "parsing time ... extra text ..." that are expected
runtime errors, not bugs.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 test/fuzz/fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index c7583b7bf..1be7b11db 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -47,6 +47,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`strings: negative Repeat count`),
 		regexp.MustCompile(`strings: illegal bytes to escape`),
 		regexp.MustCompile(`invalid date .*`),
+		regexp.MustCompile(`parsing time .*`),
 		regexp.MustCompile(`cannot parse .* as .*`),
 		regexp.MustCompile(`operator "in" not defined on .*`),
 		regexp.MustCompile(`cannot sum .*`),

From 4ff281dde7352134b200bb56c3c5fab36aa6579c Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Mon, 12 Jan 2026 22:49:35 +0200
Subject: [PATCH 483/506] perf(optimizer): add count threshold comparisons
 (#898)

Optimize the following patterns:

- count(arr, pred) > N
- count(arr, pred) >= N
- count(arr, pred) < N
- count(arr, pred) <= N

Add a threshold check inside the count loop. When the count reaches
the threshold, the loop exits early instead of scanning the entire array.

This is implemented via a new Threshold field on BuiltinNode that the
optimizer sets when detecting these patterns. The compiler then emits
bytecode that checks the count against the threshold after each increment
and jumps out of the loop when reached.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 ast/node.go                       |   1 +
 compiler/compiler.go              |  17 ++
 optimizer/count_threshold.go      |  54 ++++++
 optimizer/count_threshold_test.go | 278 ++++++++++++++++++++++++++++++
 optimizer/optimizer.go            |   1 +
 5 files changed, 351 insertions(+)
 create mode 100644 optimizer/count_threshold.go
 create mode 100644 optimizer/count_threshold_test.go

diff --git a/ast/node.go b/ast/node.go
index 198efa59b..fbb9ae825 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -187,6 +187,7 @@ type BuiltinNode struct {
 	Arguments []Node // Arguments of the builtin function.
 	Throws    bool   // If true then accessing a field or array index can throw an error. Used by optimizer.
 	Map       Node   // Used by optimizer to fold filter() and map() builtins.
+	Threshold *int   // Used by optimizer for count() early termination.
 }
 
 // PredicateNode represents a predicate.
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 951385cdb..ed8942c97 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -937,6 +937,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 		c.compile(node.Arguments[0])
 		c.derefInNeeded(node.Arguments[0])
 		c.emit(OpBegin)
+		var loopBreak int
 		c.emitLoop(func() {
 			if len(node.Arguments) == 2 {
 				c.compile(node.Arguments[1])
@@ -945,9 +946,25 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 			}
 			c.emitCond(func() {
 				c.emit(OpIncrementCount)
+				// Early termination if threshold is set
+				if node.Threshold != nil {
+					c.emit(OpGetCount)
+					c.emit(OpInt, *node.Threshold)
+					c.emit(OpMoreOrEqual)
+					loopBreak = c.emit(OpJumpIfTrue, placeholder)
+					c.emit(OpPop)
+				}
 			})
 		})
 		c.emit(OpGetCount)
+		if node.Threshold != nil {
+			end := c.emit(OpJump, placeholder)
+			c.patchJump(loopBreak)
+			// Early exit path: pop the bool comparison result, push count
+			c.emit(OpPop)
+			c.emit(OpGetCount)
+			c.patchJump(end)
+		}
 		c.emit(OpEnd)
 		return
 
diff --git a/optimizer/count_threshold.go b/optimizer/count_threshold.go
new file mode 100644
index 000000000..d045760b0
--- /dev/null
+++ b/optimizer/count_threshold.go
@@ -0,0 +1,54 @@
+package optimizer
+
+import (
+	. "github.com/expr-lang/expr/ast"
+)
+
+// countThreshold optimizes count comparisons by setting a threshold for early termination.
+// The threshold allows the count loop to exit early once enough matches are found.
+// Patterns:
+//   - count(arr, pred) > N  → threshold = N + 1 (exit proves > N is true)
+//   - count(arr, pred) >= N → threshold = N (exit proves >= N is true)
+//   - count(arr, pred) < N  → threshold = N (exit proves < N is false)
+//   - count(arr, pred) <= N → threshold = N + 1 (exit proves <= N is false)
+type countThreshold struct{}
+
+func (*countThreshold) Visit(node *Node) {
+	binary, ok := (*node).(*BinaryNode)
+	if !ok {
+		return
+	}
+
+	count, ok := binary.Left.(*BuiltinNode)
+	if !ok || count.Name != "count" || len(count.Arguments) != 2 {
+		return
+	}
+
+	integer, ok := binary.Right.(*IntegerNode)
+	if !ok || integer.Value < 0 {
+		return
+	}
+
+	var threshold int
+	switch binary.Operator {
+	case ">":
+		threshold = integer.Value + 1
+	case ">=":
+		threshold = integer.Value
+	case "<":
+		threshold = integer.Value
+	case "<=":
+		threshold = integer.Value + 1
+	default:
+		return
+	}
+
+	// Skip if threshold is 0 or 1 (handled by count_any optimizer)
+	if threshold <= 1 {
+		return
+	}
+
+	// Set threshold on the count node for early termination
+	// The original comparison remains unchanged
+	count.Threshold = &threshold
+}
diff --git a/optimizer/count_threshold_test.go b/optimizer/count_threshold_test.go
new file mode 100644
index 000000000..3bac6fc3f
--- /dev/null
+++ b/optimizer/count_threshold_test.go
@@ -0,0 +1,278 @@
+package optimizer_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/vm"
+)
+
+func TestOptimize_count_threshold_gt(t *testing.T) {
+	tree, err := parser.Parse(`count(items, .active) > 100`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	// Operator should remain >, but count should have threshold set
+	binary, ok := tree.Node.(*BinaryNode)
+	require.True(t, ok, "expected BinaryNode, got %T", tree.Node)
+	assert.Equal(t, ">", binary.Operator)
+
+	count, ok := binary.Left.(*BuiltinNode)
+	require.True(t, ok, "expected BuiltinNode, got %T", binary.Left)
+	assert.Equal(t, "count", count.Name)
+	require.NotNil(t, count.Threshold)
+	assert.Equal(t, 101, *count.Threshold) // threshold = N + 1 for > operator
+}
+
+func TestOptimize_count_threshold_gte(t *testing.T) {
+	tree, err := parser.Parse(`count(items, .active) >= 50`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	// Operator should remain >=, but count should have threshold set
+	binary, ok := tree.Node.(*BinaryNode)
+	require.True(t, ok, "expected BinaryNode, got %T", tree.Node)
+	assert.Equal(t, ">=", binary.Operator)
+
+	count, ok := binary.Left.(*BuiltinNode)
+	require.True(t, ok, "expected BuiltinNode, got %T", binary.Left)
+	assert.Equal(t, "count", count.Name)
+	require.NotNil(t, count.Threshold)
+	assert.Equal(t, 50, *count.Threshold) // threshold = N for >= operator
+}
+
+func TestOptimize_count_threshold_lt(t *testing.T) {
+	tree, err := parser.Parse(`count(items, .active) < 100`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	// Operator should remain <, but count should have threshold set
+	binary, ok := tree.Node.(*BinaryNode)
+	require.True(t, ok, "expected BinaryNode, got %T", tree.Node)
+	assert.Equal(t, "<", binary.Operator)
+
+	count, ok := binary.Left.(*BuiltinNode)
+	require.True(t, ok, "expected BuiltinNode, got %T", binary.Left)
+	assert.Equal(t, "count", count.Name)
+	require.NotNil(t, count.Threshold)
+	assert.Equal(t, 100, *count.Threshold) // threshold = N for < operator
+}
+
+func TestOptimize_count_threshold_lte(t *testing.T) {
+	tree, err := parser.Parse(`count(items, .active) <= 50`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	// Operator should remain <=, but count should have threshold set
+	binary, ok := tree.Node.(*BinaryNode)
+	require.True(t, ok, "expected BinaryNode, got %T", tree.Node)
+	assert.Equal(t, "<=", binary.Operator)
+
+	count, ok := binary.Left.(*BuiltinNode)
+	require.True(t, ok, "expected BuiltinNode, got %T", binary.Left)
+	assert.Equal(t, "count", count.Name)
+	require.NotNil(t, count.Threshold)
+	assert.Equal(t, 51, *count.Threshold) // threshold = N + 1 for <= operator
+}
+
+func TestOptimize_count_threshold_correctness(t *testing.T) {
+	tests := []struct {
+		expr string
+		want bool
+	}{
+		// count > N (threshold = N + 1)
+		{`count(1..1000, # <= 100) > 50`, true},   // 100 matches > 50
+		{`count(1..1000, # <= 100) > 100`, false}, // 100 matches not > 100
+		{`count(1..1000, # <= 100) > 99`, true},   // 100 matches > 99
+		{`count(1..100, # > 0) > 50`, true},       // 100 matches > 50
+		{`count(1..100, # > 0) > 100`, false},     // 100 matches not > 100
+
+		// count >= N (threshold = N)
+		{`count(1..1000, # <= 100) >= 100`, true},  // 100 matches >= 100
+		{`count(1..1000, # <= 100) >= 101`, false}, // 100 matches not >= 101
+		{`count(1..100, # > 0) >= 50`, true},       // 100 matches >= 50
+		{`count(1..100, # > 0) >= 100`, true},      // 100 matches >= 100
+
+		// count < N (threshold = N)
+		{`count(1..1000, # <= 100) < 101`, true},  // 100 matches < 101
+		{`count(1..1000, # <= 100) < 100`, false}, // 100 matches not < 100
+		{`count(1..1000, # <= 100) < 50`, false},  // 100 matches not < 50
+		{`count(1..100, # > 0) < 101`, true},      // 100 matches < 101
+		{`count(1..100, # > 0) < 100`, false},     // 100 matches not < 100
+
+		// count <= N (threshold = N + 1)
+		{`count(1..1000, # <= 100) <= 100`, true},  // 100 matches <= 100
+		{`count(1..1000, # <= 100) <= 99`, false},  // 100 matches not <= 99
+		{`count(1..1000, # <= 100) <= 50`, false},  // 100 matches not <= 50
+		{`count(1..100, # > 0) <= 100`, true},      // 100 matches <= 100
+		{`count(1..100, # > 0) <= 99`, false},      // 100 matches not <= 99
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+		})
+	}
+}
+
+func TestOptimize_count_threshold_no_optimization(t *testing.T) {
+	// These should NOT get a threshold (handled by count_any or not optimizable)
+	tests := []struct {
+		code      string
+		threshold bool
+	}{
+		{`count(items, .active) > 0`, false},   // handled by count_any
+		{`count(items, .active) >= 1`, false},  // handled by count_any
+		{`count(items, .active) < 1`, false},   // threshold = 1, skipped
+		{`count(items, .active) <= 0`, false},  // threshold = 1, skipped
+		{`count(items, .active) == 10`, false}, // not supported
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			tree, err := parser.Parse(tt.code)
+			require.NoError(t, err)
+
+			err = optimizer.Optimize(&tree.Node, nil)
+			require.NoError(t, err)
+
+			// Check if count has threshold set
+			var count *BuiltinNode
+			if binary, ok := tree.Node.(*BinaryNode); ok {
+				count, _ = binary.Left.(*BuiltinNode)
+			} else if builtin, ok := tree.Node.(*BuiltinNode); ok {
+				count = builtin
+			}
+
+			if count != nil && count.Name == "count" {
+				if tt.threshold {
+					assert.NotNil(t, count.Threshold, "expected threshold to be set")
+				} else {
+					assert.Nil(t, count.Threshold, "expected threshold to be nil")
+				}
+			}
+		})
+	}
+}
+
+// Benchmark: count > 100 with early match (element 101 matches early)
+func BenchmarkCountThresholdEarlyMatch(b *testing.B) {
+	// Array of 10000 elements, all match predicate, threshold is 101
+	// Should exit after ~101 iterations
+	program, _ := expr.Compile(`count(1..10000, # > 0) > 100`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+// Benchmark: count >= 50 with early match
+func BenchmarkCountThresholdGteEarlyMatch(b *testing.B) {
+	// All elements match, threshold is 50
+	// Should exit after ~50 iterations
+	program, _ := expr.Compile(`count(1..10000, # > 0) >= 50`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+// Benchmark: count > 100 with no early exit (not enough matches)
+func BenchmarkCountThresholdNoEarlyExit(b *testing.B) {
+	// Only 100 elements match (# <= 100), threshold is 101
+	// Must scan entire array
+	program, _ := expr.Compile(`count(1..10000, # <= 100) > 100`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+// Benchmark: Large threshold with early match
+func BenchmarkCountThresholdLargeEarlyMatch(b *testing.B) {
+	// All 10000 match, threshold is 1000
+	// Should exit after ~1000 iterations
+	program, _ := expr.Compile(`count(1..10000, # > 0) > 999`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+// Benchmark: count < N with early exit (result is false)
+func BenchmarkCountThresholdLtEarlyExit(b *testing.B) {
+	// All 10000 match, threshold is 100
+	// Should exit after ~100 iterations with result = false
+	program, _ := expr.Compile(`count(1..10000, # > 0) < 100`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+// Benchmark: count <= N with early exit (result is false)
+func BenchmarkCountThresholdLteEarlyExit(b *testing.B) {
+	// All 10000 match, threshold is 51
+	// Should exit after ~51 iterations with result = false
+	program, _ := expr.Compile(`count(1..10000, # > 0) <= 50`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+// Benchmark: count < N without early exit (result is true)
+func BenchmarkCountThresholdLtNoEarlyExit(b *testing.B) {
+	// Only 100 elements match (# <= 100), threshold is 200
+	// Must scan entire array, result = true
+	program, _ := expr.Compile(`count(1..10000, # <= 100) < 200`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+// Benchmark: count <= N without early exit (result is true)
+func BenchmarkCountThresholdLteNoEarlyExit(b *testing.B) {
+	// Only 100 elements match (# <= 100), threshold is 101
+	// Must scan entire array, result = true
+	program, _ := expr.Compile(`count(1..10000, # <= 100) <= 100`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go
index fedf0208a..9e4c75d3b 100644
--- a/optimizer/optimizer.go
+++ b/optimizer/optimizer.go
@@ -44,6 +44,7 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &sumArray{})
 	Walk(node, &sumMap{})
 	Walk(node, &countAny{})
+	Walk(node, &countThreshold{})
 	return nil
 }
 

From 5ef01205d977a50f9026824fb7ae7449e70f662f Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 15 Jan 2026 11:55:27 +0200
Subject: [PATCH 484/506] fix(vm): validate arg count before OpCall (#904)

Prevent index out of bounds panic when calling a function with more
arguments than it accepts. The VM now validates argument count before
attempting to access parameter types. Includes a regression test.

This issue was discovered by clusterfuzz with the expression:
$env(''matches'  '? :now().UTC(g).d)//

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 test/fuzz/fuzz_test.go |  1 +
 vm/vm.go               | 11 ++++++++++-
 vm/vm_test.go          | 19 +++++++++++++++++++
 3 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 1be7b11db..684df025a 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -40,6 +40,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`reflect.Value.MapIndex: value of type .* is not assignable to type .*`),
 		regexp.MustCompile(`reflect: Call using .* as type .*`),
 		regexp.MustCompile(`reflect: Call with too few input arguments`),
+		regexp.MustCompile(`invalid number of arguments`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Call on .* Value`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Index on map Value`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Len on .* Value`),
diff --git a/vm/vm.go b/vm/vm.go
index 3c7a2b3f7..69c379b2a 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -372,9 +372,18 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			}
 			fnType := fn.Type()
 			size := arg
-			in := make([]reflect.Value, size)
 			isVariadic := fnType.IsVariadic()
 			numIn := fnType.NumIn()
+			if isVariadic {
+				if size < numIn-1 {
+					panic(fmt.Sprintf("invalid number of arguments: expected at least %d, got %d", numIn-1, size))
+				}
+			} else {
+				if size != numIn {
+					panic(fmt.Sprintf("invalid number of arguments: expected %d, got %d", numIn, size))
+				}
+			}
+			in := make([]reflect.Value, size)
 			for i := int(size) - 1; i >= 0; i-- {
 				param := vm.pop()
 				if param == nil {
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 6038abcae..355f764ee 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -1491,3 +1491,22 @@ func TestVM_StackUnderflow(t *testing.T) {
 		})
 	}
 }
+
+func TestVM_OpCall_InvalidNumberOfArguments(t *testing.T) {
+	// This test ensures that calling a function with wrong number of arguments
+	// produces a clear error message instead of a panic.
+	// Regression test for clusterfuzz issue with expression:
+	// $env(''matches'  '? :now().UTC(g).d)//
+
+	env := map[string]any{
+		"ok": true,
+	}
+
+	code := `$env('' matches ' '? : now().UTC(g))`
+	program, err := expr.Compile(code, expr.Env(env))
+	require.NoError(t, err)
+
+	_, err = expr.Run(program, env)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "invalid number of arguments")
+}

From 1fa02826f361c6cc8d3b7249d0f9439baad0c0a6 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Mon, 19 Jan 2026 12:13:04 +0200
Subject: [PATCH 485/506] fix(fuzz): skip invalid location name errors (#907)

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 test/fuzz/fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 684df025a..91a85d4f2 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -33,6 +33,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`time: missing unit in duration`),
 		regexp.MustCompile(`time: unknown unit .* in duration`),
 		regexp.MustCompile(`unknown time zone`),
+		regexp.MustCompile(`invalid location name`),
 		regexp.MustCompile(`json: unsupported value`),
 		regexp.MustCompile(`unexpected end of JSON input`),
 		regexp.MustCompile(`memory budget exceeded`),

From 556b1d14d40ec241cf17f325d7379cbf039eea47 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Fri, 23 Jan 2026 01:44:42 +0200
Subject: [PATCH 486/506] fix(compiler): reduce empty array without init val
 (#911)

Add bounds check before accessing first element when reduce is called
without an initial value. Previously this caused a panic on empty arrays.
Now returns a clear error: "reduce of empty array with no initial value".

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 builtin/builtin_test.go | 2 ++
 compiler/compiler.go    | 9 +++++++++
 expr_test.go            | 6 ++++++
 test/fuzz/fuzz_test.go  | 1 +
 4 files changed, 18 insertions(+)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index a5dabbbbe..ec424b546 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -150,6 +150,8 @@ func TestBuiltin(t *testing.T) {
 		{`reduce(1..9, # + #acc)`, 45},
 		{`reduce([.5, 1.5, 2.5], # + #acc, 0)`, 4.5},
 		{`reduce([], 5, 0)`, 0},
+		{`reduce(10..1, # + #acc, 100)`, 100},
+		{`reduce([], # + #acc, 42)`, 42},
 		{`concat(ArrayOfString, ArrayOfInt)`, []any{"foo", "bar", "baz", 1, 2, 3}},
 		{`concat(PtrArrayWithNil, [nil])`, []any{42, nil}},
 		{`flatten([["a", "b"], [1, 2]])`, []any{"a", "b", 1, 2}},
diff --git a/compiler/compiler.go b/compiler/compiler.go
index ed8942c97..f66cf9ed8 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -1124,9 +1124,18 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) {
 			c.derefInNeeded(node.Arguments[2])
 			c.emit(OpSetAcc)
 		} else {
+			// When no initial value is provided, we use the first element as the
+			// accumulator. But first we must check if the array is empty to avoid
+			// an index out of range panic.
+			empty := c.emit(OpJumpIfEnd, placeholder)
 			c.emit(OpPointer)
 			c.emit(OpIncrementIndex)
 			c.emit(OpSetAcc)
+			jumpPastError := c.emit(OpJump, placeholder)
+			c.patchJump(empty)
+			c.emit(OpPush, c.addConstant(fmt.Errorf("reduce of empty array with no initial value")))
+			c.emit(OpThrow)
+			c.patchJump(jumpPastError)
 		}
 		c.emitLoop(func() {
 			c.compile(node.Arguments[1])
diff --git a/expr_test.go b/expr_test.go
index 28b2c54be..1bce3c8dc 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1485,6 +1485,12 @@ func TestExpr_error(t *testing.T) {
  | ArrayOfAny[-7]
  | ..........^`,
 		},
+		{
+			`reduce(10..1, # + #acc)`,
+			`reduce of empty array with no initial value (1:1)
+ | reduce(10..1, # + #acc)
+ | ^`,
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 91a85d4f2..e24b96cd7 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -54,6 +54,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`operator "in" not defined on .*`),
 		regexp.MustCompile(`cannot sum .*`),
 		regexp.MustCompile(`index out of range: .* \(array length is .*\)`),
+		regexp.MustCompile(`reduce of empty array with no initial value`),
 		regexp.MustCompile(`cannot use <nil> as argument \(type .*\) to call .*`),
 		regexp.MustCompile(`illegal base64 data at input byte .*`),
 	}

From a9ac10fa699b624c7f503e7dcaed40fbcafcf053 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Fri, 23 Jan 2026 14:25:43 +0200
Subject: [PATCH 487/506] perf(builtin): add fast paths for min, max, mean, and
 median (#909)

Avoid reflection and per-element allocations for common typed slices
([]int, []float64, []any) by adding type-switch fast paths that iterate
directly without calling reflect.Value.Interface().

For []any containing numeric types, the fast path handles int and float64
directly, falling back to reflection for other numeric types (int32, etc.)
to keep the code compact while still avoiding per-element recursion.

Falls back to reflection for other slice types to maintain compatibility.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 bench_test.go           |  68 +++++++++++++++
 builtin/builtin_test.go |  48 +++++++++--
 builtin/lib.go          | 181 +++++++++++++++++++++++++++++++++++++++-
 3 files changed, 291 insertions(+), 6 deletions(-)

diff --git a/bench_test.go b/bench_test.go
index d70a09356..99fd4aabf 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -571,3 +571,71 @@ func Benchmark_reduce(b *testing.B) {
 
 	require.Equal(b, 5050, out.(int))
 }
+
+func Benchmark_min(b *testing.B) {
+	arr := []any{55, 58, 42, 61, 75, 52, 64, 62, 16, 79, 40, 14, 50, 76, 23, 2, 5, 80, 89, 51, 21, 96, 91, 13, 71, 82, 65, 63, 11, 17, 94, 81, 74, 4, 97, 1, 39, 3, 28, 8, 84, 90, 47, 85, 7, 56, 49, 93, 33, 12, 19, 60, 86, 100, 44, 45, 36, 72, 95, 77, 34, 92, 24, 73, 18, 38, 43, 26, 41, 69, 67, 57, 9, 27, 66, 87, 46, 35, 59, 70, 10, 20, 53, 15, 32, 98, 68, 31, 54, 25, 83, 88, 22, 48, 29, 37, 6, 78, 99, 30}
+	env := map[string]any{"arr": arr}
+
+	program, err := expr.Compile(`min(arr)`, expr.Env(env))
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 1, out)
+}
+
+func Benchmark_max(b *testing.B) {
+	arr := []any{55, 58, 42, 61, 75, 52, 64, 62, 16, 79, 40, 14, 50, 76, 23, 2, 5, 80, 89, 51, 21, 96, 91, 13, 71, 82, 65, 63, 11, 17, 94, 81, 74, 4, 97, 1, 39, 3, 28, 8, 84, 90, 47, 85, 7, 56, 49, 93, 33, 12, 19, 60, 86, 100, 44, 45, 36, 72, 95, 77, 34, 92, 24, 73, 18, 38, 43, 26, 41, 69, 67, 57, 9, 27, 66, 87, 46, 35, 59, 70, 10, 20, 53, 15, 32, 98, 68, 31, 54, 25, 83, 88, 22, 48, 29, 37, 6, 78, 99, 30}
+	env := map[string]any{"arr": arr}
+
+	program, err := expr.Compile(`max(arr)`, expr.Env(env))
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 100, out)
+}
+
+func Benchmark_mean(b *testing.B) {
+	arr := []any{55, 58, 42, 61, 75, 52, 64, 62, 16, 79, 40, 14, 50, 76, 23, 2, 5, 80, 89, 51, 21, 96, 91, 13, 71, 82, 65, 63, 11, 17, 94, 81, 74, 4, 97, 1, 39, 3, 28, 8, 84, 90, 47, 85, 7, 56, 49, 93, 33, 12, 19, 60, 86, 100, 44, 45, 36, 72, 95, 77, 34, 92, 24, 73, 18, 38, 43, 26, 41, 69, 67, 57, 9, 27, 66, 87, 46, 35, 59, 70, 10, 20, 53, 15, 32, 98, 68, 31, 54, 25, 83, 88, 22, 48, 29, 37, 6, 78, 99, 30}
+	env := map[string]any{"arr": arr}
+
+	program, err := expr.Compile(`mean(arr)`, expr.Env(env))
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 50.5, out)
+}
+
+func Benchmark_median(b *testing.B) {
+	arr := []any{55, 58, 42, 61, 75, 52, 64, 62, 16, 79, 40, 14, 50, 76, 23, 2, 5, 80, 89, 51, 21, 96, 91, 13, 71, 82, 65, 63, 11, 17, 94, 81, 74, 4, 97, 1, 39, 3, 28, 8, 84, 90, 47, 85, 7, 56, 49, 93, 33, 12, 19, 60, 86, 100, 44, 45, 36, 72, 95, 77, 34, 92, 24, 73, 18, 38, 43, 26, 41, 69, 67, 57, 9, 27, 66, 87, 46, 35, 59, 70, 10, 20, 53, 15, 32, 98, 68, 31, 54, 25, 83, 88, 22, 48, 29, 37, 6, 78, 99, 30}
+	env := map[string]any{"arr": arr}
+
+	program, err := expr.Compile(`median(arr)`, expr.Env(env))
+	require.NoError(b, err)
+
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, env)
+	}
+	b.StopTimer()
+
+	require.Equal(b, 50.5, out)
+}
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index ec424b546..fcc0a5e19 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -21,11 +21,19 @@ import (
 func TestBuiltin(t *testing.T) {
 	ArrayWithNil := []any{42}
 	env := map[string]any{
-		"ArrayOfString":   []string{"foo", "bar", "baz"},
-		"ArrayOfInt":      []int{1, 2, 3},
-		"ArrayOfAny":      []any{1, "2", true},
-		"ArrayOfFoo":      []mock.Foo{{Value: "a"}, {Value: "b"}, {Value: "c"}},
-		"PtrArrayWithNil": &ArrayWithNil,
+		"ArrayOfString":    []string{"foo", "bar", "baz"},
+		"ArrayOfInt":       []int{1, 2, 3},
+		"ArrayOfFloat":     []float64{1.5, 2.5, 3.5},
+		"ArrayOfInt32":     []int32{1, 2, 3},
+		"ArrayOfAny":       []any{1, "2", true},
+		"ArrayOfFoo":       []mock.Foo{{Value: "a"}, {Value: "b"}, {Value: "c"}},
+		"PtrArrayWithNil":  &ArrayWithNil,
+		"EmptyIntArray":    []int{},
+		"EmptyFloatArray":  []float64{},
+		"NestedIntArrays":  []any{[]int{1, 2}, []int{3, 4}},
+		"NestedAnyArrays":  []any{[]any{1, 2}, []any{3, 4}},
+		"MixedNestedArray": []any{1, []int{2, 3}, []float64{4.0, 5.0}},
+		"NestedInt32Array": []any{[]int32{1, 2}, []int32{3, 4}},
 	}
 
 	var tests = []struct {
@@ -86,6 +94,22 @@ func TestBuiltin(t *testing.T) {
 		{`min([1, 2, 3])`, 1},
 		{`min([1.5, 2.5, 3.5])`, 1.5},
 		{`min(-1, [1.5, 2.5, 3.5])`, -1},
+		{`max(ArrayOfInt)`, 3},
+		{`min(ArrayOfInt)`, 1},
+		{`max(ArrayOfFloat)`, 3.5},
+		{`min(ArrayOfFloat)`, 1.5},
+		{`max(EmptyIntArray, 5)`, 5},
+		{`min(EmptyFloatArray, 5)`, 5},
+		{`max(NestedIntArrays)`, 4},
+		{`min(NestedIntArrays)`, 1},
+		{`max(NestedAnyArrays)`, 4},
+		{`min(NestedAnyArrays)`, 1},
+		{`max(MixedNestedArray)`, 5.0},
+		{`min(MixedNestedArray)`, 1},
+		{`max(ArrayOfInt32)`, int32(3)},
+		{`min(ArrayOfInt32)`, int32(1)},
+		{`max(NestedInt32Array)`, int32(4)},
+		{`min(NestedInt32Array)`, int32(1)},
 		{`sum(1..9)`, 45},
 		{`sum([.5, 1.5, 2.5])`, 4.5},
 		{`sum([])`, 0},
@@ -97,6 +121,13 @@ func TestBuiltin(t *testing.T) {
 		{`mean(10, [1, 2, 3], 1..9)`, 4.6923076923076925},
 		{`mean(-10, [1, 2, 3, 4])`, 0.0},
 		{`mean(10.9, 1..9)`, 5.59},
+		{`mean(ArrayOfInt)`, 2.0},
+		{`mean(ArrayOfFloat)`, 2.5},
+		{`mean(NestedIntArrays)`, 2.5},
+		{`mean(NestedAnyArrays)`, 2.5},
+		{`mean(MixedNestedArray)`, 3.0},
+		{`mean(ArrayOfInt32)`, 2.0},
+		{`mean(NestedInt32Array)`, 2.5},
 		{`median(1..9)`, 5.0},
 		{`median([.5, 1.5, 2.5])`, 1.5},
 		{`median([])`, 0.0},
@@ -105,6 +136,13 @@ func TestBuiltin(t *testing.T) {
 		{`median(10, [1, 2, 3], 1..9)`, 4.0},
 		{`median(-10, [1, 2, 3, 4])`, 2.0},
 		{`median(1..5, 4.9)`, 3.5},
+		{`median(ArrayOfInt)`, 2.0},
+		{`median(ArrayOfFloat)`, 2.5},
+		{`median(NestedIntArrays)`, 2.5},
+		{`median(NestedAnyArrays)`, 2.5},
+		{`median(MixedNestedArray)`, 3.0},
+		{`median(ArrayOfInt32)`, 2.0},
+		{`median(NestedInt32Array)`, 2.5},
 		{`toJSON({foo: 1, bar: 2})`, "{\n  \"bar\": 2,\n  \"foo\": 1\n}"},
 		{`fromJSON("[1, 2, 3]")`, []any{1.0, 2.0, 3.0}},
 		{`toBase64("hello")`, "aGVsbG8="},
diff --git a/builtin/lib.go b/builtin/lib.go
index 07a029b2f..40ba19e96 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -259,6 +259,75 @@ func minMax(name string, fn func(any, any) bool, depth int, args ...any) (any, e
 	}
 	var val any
 	for _, arg := range args {
+		// Fast paths for common typed slices - avoid reflection and allocations
+		switch arr := arg.(type) {
+		case []int:
+			if len(arr) == 0 {
+				continue
+			}
+			m := arr[0]
+			for i := 1; i < len(arr); i++ {
+				if fn(m, arr[i]) {
+					m = arr[i]
+				}
+			}
+			if val == nil || fn(val, m) {
+				val = m
+			}
+			continue
+		case []float64:
+			if len(arr) == 0 {
+				continue
+			}
+			m := arr[0]
+			for i := 1; i < len(arr); i++ {
+				if fn(m, arr[i]) {
+					m = arr[i]
+				}
+			}
+			if val == nil || fn(val, m) {
+				val = m
+			}
+			continue
+		case []any:
+			// Fast path for []any with simple numeric types
+			for _, elem := range arr {
+				switch e := elem.(type) {
+				case int, int8, int16, int32, int64,
+					uint, uint8, uint16, uint32, uint64,
+					float32, float64:
+					if val == nil || fn(val, e) {
+						val = e
+					}
+				case []int, []float64, []any:
+					// Nested array - recurse
+					nested, err := minMax(name, fn, depth+1, e)
+					if err != nil {
+						return nil, err
+					}
+					if nested != nil && (val == nil || fn(val, nested)) {
+						val = nested
+					}
+				default:
+					// Could be another slice type, use reflection
+					rv := reflect.ValueOf(e)
+					if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {
+						nested, err := minMax(name, fn, depth+1, e)
+						if err != nil {
+							return nil, err
+						}
+						if nested != nil && (val == nil || fn(val, nested)) {
+							val = nested
+						}
+					} else {
+						return nil, fmt.Errorf("invalid argument for %s (type %T)", name, e)
+					}
+				}
+			}
+			continue
+		}
+
+		// Slow path: use reflection for other types
 		rv := reflect.ValueOf(arg)
 		switch rv.Kind() {
 		case reflect.Array, reflect.Slice:
@@ -278,7 +347,6 @@ func minMax(name string, fn func(any, any) bool, depth int, args ...any) (any, e
 				default:
 					return nil, fmt.Errorf("invalid argument for %s (type %T)", name, elemVal)
 				}
-
 			}
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
 			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
@@ -305,6 +373,67 @@ func mean(depth int, args ...any) (int, float64, error) {
 	var count int
 
 	for _, arg := range args {
+		// Fast paths for common typed slices - avoid reflection and allocations
+		switch arr := arg.(type) {
+		case []int:
+			for _, v := range arr {
+				total += float64(v)
+			}
+			count += len(arr)
+			continue
+		case []float64:
+			for _, v := range arr {
+				total += v
+			}
+			count += len(arr)
+			continue
+		case []any:
+			// Fast path for []any - single pass without recursive calls for flat arrays
+			for _, elem := range arr {
+				switch e := elem.(type) {
+				case int:
+					total += float64(e)
+					count++
+				case float64:
+					total += e
+					count++
+				case []int, []float64, []any:
+					// Nested array - recurse
+					nestedCount, nestedSum, err := mean(depth+1, e)
+					if err != nil {
+						return 0, 0, err
+					}
+					total += nestedSum
+					count += nestedCount
+				default:
+					// Other numeric types or slices - use reflection
+					rv := reflect.ValueOf(e)
+					switch rv.Kind() {
+					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+						total += float64(rv.Int())
+						count++
+					case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+						total += float64(rv.Uint())
+						count++
+					case reflect.Float32, reflect.Float64:
+						total += rv.Float()
+						count++
+					case reflect.Slice, reflect.Array:
+						nestedCount, nestedSum, err := mean(depth+1, e)
+						if err != nil {
+							return 0, 0, err
+						}
+						total += nestedSum
+						count += nestedCount
+					default:
+						return 0, 0, fmt.Errorf("invalid argument for mean (type %T)", e)
+					}
+				}
+			}
+			continue
+		}
+
+		// Slow path: use reflection for other types
 		rv := reflect.ValueOf(arg)
 		switch rv.Kind() {
 		case reflect.Array, reflect.Slice:
@@ -340,6 +469,56 @@ func median(depth int, args ...any) ([]float64, error) {
 	var values []float64
 
 	for _, arg := range args {
+		// Fast paths for common typed slices - avoid reflection and allocations
+		switch arr := arg.(type) {
+		case []int:
+			for _, v := range arr {
+				values = append(values, float64(v))
+			}
+			continue
+		case []float64:
+			values = append(values, arr...)
+			continue
+		case []any:
+			// Fast path for []any - single pass without recursive calls for flat arrays
+			for _, elem := range arr {
+				switch e := elem.(type) {
+				case int:
+					values = append(values, float64(e))
+				case float64:
+					values = append(values, e)
+				case []int, []float64, []any:
+					// Nested array - recurse
+					elems, err := median(depth+1, e)
+					if err != nil {
+						return nil, err
+					}
+					values = append(values, elems...)
+				default:
+					// Other numeric types or slices - use reflection
+					rv := reflect.ValueOf(e)
+					switch rv.Kind() {
+					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+						values = append(values, float64(rv.Int()))
+					case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+						values = append(values, float64(rv.Uint()))
+					case reflect.Float32, reflect.Float64:
+						values = append(values, rv.Float())
+					case reflect.Slice, reflect.Array:
+						elems, err := median(depth+1, e)
+						if err != nil {
+							return nil, err
+						}
+						values = append(values, elems...)
+					default:
+						return nil, fmt.Errorf("invalid argument for median (type %T)", e)
+					}
+				}
+			}
+			continue
+		}
+
+		// Slow path: use reflection for other types
 		rv := reflect.ValueOf(arg)
 		switch rv.Kind() {
 		case reflect.Array, reflect.Slice:

From 77df21185c120c7137d0b36f60cd561b915191e3 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Fri, 23 Jan 2026 23:54:41 +0200
Subject: [PATCH 488/506] fix(checker): validate sortBy order argument type
 (#912)

The sortBy and sort functions accept an optional order argument that
must be "asc" or "desc". Previously, passing a non-string value would
cause a panic due to an unsafe type assertion in the VM. This adds
compile-time validation in the type checker and defensive runtime
checks in both the VM and builtin implementations to return proper
errors instead of panicking.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 builtin/builtin.go     |  8 ++++++--
 checker/checker.go     | 23 +++++++++++++----------
 test/fuzz/fuzz_test.go |  4 ++++
 testdata/generated.txt |  3 ---
 vm/vm.go               |  6 +++++-
 vm/vm_test.go          | 20 ++++++++++++++++++++
 6 files changed, 48 insertions(+), 16 deletions(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 4fe356fbf..78b55be6d 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -1000,13 +1000,17 @@ var Builtins = []*Function{
 
 			var desc bool
 			if len(args) == 2 {
-				switch args[1].(string) {
+				order, ok := args[1].(string)
+				if !ok {
+					return nil, 0, fmt.Errorf("sort order argument must be a string (got %T)", args[1])
+				}
+				switch order {
 				case "asc":
 					desc = false
 				case "desc":
 					desc = true
 				default:
-					return nil, 0, fmt.Errorf("invalid order %s, expected asc or desc", args[1])
+					return nil, 0, fmt.Errorf("invalid order %s, expected asc or desc", order)
 				}
 			}
 
diff --git a/checker/checker.go b/checker/checker.go
index b78afc2b4..23ed1725f 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -15,15 +15,15 @@ import (
 )
 
 var (
-	anyType      = reflect.TypeOf(new(any)).Elem()
-	boolType     = reflect.TypeOf(true)
-	intType      = reflect.TypeOf(0)
-	floatType    = reflect.TypeOf(float64(0))
-	stringType   = reflect.TypeOf("")
-	arrayType    = reflect.TypeOf([]any{})
-	mapType      = reflect.TypeOf(map[string]any{})
-	timeType     = reflect.TypeOf(time.Time{})
-	durationType = reflect.TypeOf(time.Duration(0))
+	anyType       = reflect.TypeOf(new(any)).Elem()
+	boolType      = reflect.TypeOf(true)
+	intType       = reflect.TypeOf(0)
+	floatType     = reflect.TypeOf(float64(0))
+	stringType    = reflect.TypeOf("")
+	arrayType     = reflect.TypeOf([]any{})
+	mapType       = reflect.TypeOf(map[string]any{})
+	timeType      = reflect.TypeOf(time.Time{})
+	durationType  = reflect.TypeOf(time.Duration(0))
 	byteSliceType = reflect.TypeOf([]byte(nil))
 
 	anyTypeSlice = []reflect.Type{anyType}
@@ -893,7 +893,10 @@ func (v *Checker) builtinNode(node *ast.BuiltinNode) Nature {
 		v.end()
 
 		if len(node.Arguments) == 3 {
-			_ = v.visit(node.Arguments[2])
+			order := v.visit(node.Arguments[2])
+			if !order.IsString() && !order.IsUnknown(&v.config.NtCache) {
+				return v.error(node.Arguments[2], "sortBy order argument must be a string (got %v)", order.String())
+			}
 		}
 
 		if predicate.IsFunc() &&
diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index e24b96cd7..09b4d4f6b 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -57,6 +57,10 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`reduce of empty array with no initial value`),
 		regexp.MustCompile(`cannot use <nil> as argument \(type .*\) to call .*`),
 		regexp.MustCompile(`illegal base64 data at input byte .*`),
+		regexp.MustCompile(`sort order argument must be a string`),
+		regexp.MustCompile(`sortBy order argument must be a string`),
+		regexp.MustCompile(`invalid order .*, expected asc or desc`),
+		regexp.MustCompile(`unknown order, use asc or desc`),
 	}
 
 	env := NewEnv()
diff --git a/testdata/generated.txt b/testdata/generated.txt
index 017cf5803..5166aeb82 100644
--- a/testdata/generated.txt
+++ b/testdata/generated.txt
@@ -1004,7 +1004,6 @@ $env | reduce(false, $env); list
 $env | reduce(greet, array) ?? foo
 $env | reduce(ok, 1) ?: greet
 $env | reduce(str, foo) not startsWith str
-$env | sortBy(#, 0) * $env && false
 $env | sum(#) not endsWith $env or true
 $env | sum(1.0) <= i
 $env | sum(1.0) in array
@@ -15360,7 +15359,6 @@ f64 ?? reduce(list, str)
 f64 ?? reverse($env)
 f64 ?? reverse(array)
 f64 ?? round(i)
-f64 ?? sortBy($env, #.String, list)
 f64 ?? sortBy(list, ok)
 f64 ?? str
 f64 ?? str[$env:i]
@@ -30051,7 +30049,6 @@ ok || ok || $env
 ok || one($env, .add)
 ok || reduce($env, .foo)
 ok || sortBy($env, array).str
-ok || sortBy($env, foo, 1)
 ok || sortBy($env, i, str)
 ok || str != $env
 ok || str != nil
diff --git a/vm/vm.go b/vm/vm.go
index 69c379b2a..887825413 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -556,7 +556,11 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			case 2:
 				scope := vm.scope()
 				var desc bool
-				switch vm.pop().(string) {
+				order, ok := vm.pop().(string)
+				if !ok {
+					panic("sortBy order argument must be a string")
+				}
+				switch order {
 				case "asc":
 					desc = false
 				case "desc":
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 355f764ee..6963803ed 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -513,6 +513,26 @@ func TestVM_GroupAndSortOperations(t *testing.T) {
 	}
 }
 
+// TestVM_SortBy_NonStringOrder tests that sortBy with non-string order
+// returns a proper error instead of panicking (regression test for OSS-Fuzz #477658245).
+func TestVM_SortBy_NonStringOrder(t *testing.T) {
+	env := map[string]any{}
+	fn := expr.Function("fn", func(params ...any) (any, error) {
+		return fmt.Sprintf("fn(%v)", params), nil
+	})
+
+	// This expression passes a function result as the order argument to sortBy.
+	// The function returns a string that is not "asc" or "desc", which should
+	// produce a proper error rather than a panic.
+	program, err := expr.Compile(`sortBy([1, 2, 3], #, fn($env))`, expr.Env(env), fn)
+	require.NoError(t, err)
+
+	testVM := &vm.VM{}
+	_, err = testVM.Run(program, env)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "unknown order")
+}
+
 // TestVM_ProfileOperations tests the profiling opcodes
 func TestVM_ProfileOperations(t *testing.T) {
 	program := &vm.Program{

From 553025ac7d0b8d55396e3d4e9521794109d2bde2 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sat, 24 Jan 2026 12:25:47 +0200
Subject: [PATCH 489/506] fix(fuzz): reduce mem budget to prevent timeouts
 (#913)

Fixes OSS-Fuzz timeout caused by expressions like "-817810..178"
creating ~818K element arrays that exceeded the 60s timeout when
passed to fmt.Sprintf for string formatting.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 test/fuzz/fuzz_test.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 09b4d4f6b..32c43de96 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
 )
 
 //go:embed fuzz_corpus.txt
@@ -76,7 +77,8 @@ func FuzzExpr(f *testing.F) {
 			t.Skipf("compile error: %s", err)
 		}
 
-		_, err = expr.Run(program, env)
+		v := vm.VM{MemoryBudget: 500000}
+		_, err = v.Run(program, env)
 		if err != nil {
 			for _, r := range skip {
 				if r.MatchString(err.Error()) {

From 9c830634f98b690a409e3e13d17df6c377c817cf Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Tue, 27 Jan 2026 08:02:29 +0200
Subject: [PATCH 490/506] fix(fuzz): JSON number overflow errs in fromJSON
 (#915)

Skip errors from fromJSON when parsing numbers with exponents too
large for float64 (e.g., '5e2482'). This is expected behavior from
Go's encoding/json package, not a bug.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 builtin/builtin_test.go   | 1 +
 test/fuzz/fuzz_corpus.txt | 1 +
 test/fuzz/fuzz_test.go    | 1 +
 3 files changed, 3 insertions(+)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index fcc0a5e19..9f5e19244 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -283,6 +283,7 @@ func TestBuiltin_errors(t *testing.T) {
 		{`timezone(nil)`, "cannot use nil as argument (type string) to call timezone (1:10)"},
 		{`flatten([1, 2], [3, 4])`, "invalid number of arguments (expected 1, got 2)"},
 		{`flatten(1)`, "cannot flatten int"},
+		{`fromJSON("5e2482")`, "cannot unmarshal number"},
 	}
 	for _, test := range errorTests {
 		t.Run(test.input, func(t *testing.T) {
diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
index 72afdf6ce..4ce90e7bf 100644
--- a/test/fuzz/fuzz_corpus.txt
+++ b/test/fuzz/fuzz_corpus.txt
@@ -19543,3 +19543,4 @@ values({"foo": ok})
 {"foo": score, "foo": array}.array
 {"foo": score, "foo": f32}
 {"foo": score, "foo": greet}
+fromJSON('5e2482')
diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 32c43de96..786612183 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -36,6 +36,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`unknown time zone`),
 		regexp.MustCompile(`invalid location name`),
 		regexp.MustCompile(`json: unsupported value`),
+		regexp.MustCompile(`json: cannot unmarshal .* into Go value of type .*`),
 		regexp.MustCompile(`unexpected end of JSON input`),
 		regexp.MustCompile(`memory budget exceeded`),
 		regexp.MustCompile(`using interface \{} as type .*`),

From d3805b027f16501b4326bd4400040243d0879951 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Wed, 28 Jan 2026 15:01:21 +0200
Subject: [PATCH 491/506] fix(builtin): bounds check to get() (#918)

Validate argument count before accessing params slice in the get()
function. This prevents a runtime panic when malformed input bypasses
compile-time validation, as discovered by OSS-Fuzz.

Includes regression test for the specific fuzz case.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 builtin/builtin_test.go | 15 +++++++++++++++
 builtin/lib.go          |  3 +++
 2 files changed, 18 insertions(+)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 9f5e19244..b7ad16fdc 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -300,6 +300,21 @@ func TestBuiltin_errors(t *testing.T) {
 	}
 }
 
+// The get() builtin must return an error when called with
+// insufficient arguments at runtime, even if compile-time checks
+// are bypassed (regression test for OSS-Fuzz #479270603).
+func TestBuiltin_get_runtime_args_check(t *testing.T) {
+	code := `$env(''matches'i'?t:get().UTC())`
+	env := map[string]any{"t": 1}
+
+	program, err := expr.Compile(code, expr.Env(env))
+	require.NoError(t, err)
+
+	_, err = expr.Run(program, env)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "invalid number of arguments")
+}
+
 func TestBuiltin_types(t *testing.T) {
 	env := map[string]any{
 		"num":           42,
diff --git a/builtin/lib.go b/builtin/lib.go
index 40ba19e96..622612cb7 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -564,6 +564,9 @@ func flatten(arg reflect.Value, depth int) ([]any, error) {
 }
 
 func get(params ...any) (out any, err error) {
+	if len(params) < 2 {
+		return nil, fmt.Errorf("invalid number of arguments (expected 2, got %d)", len(params))
+	}
 	from := params[0]
 	i := params[1]
 	v := reflect.ValueOf(from)

From 0785f19850ddb9dd21ed5df86073689066163835 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sun, 1 Feb 2026 23:11:47 +0200
Subject: [PATCH 492/506] fix(fuzz): skip reflect err for variadic calls (#921)

Skip pattern for the variadic function type mismatch error
format ("reflect: cannot use X as type Y in Call"). Differs from
the regular function error format that was already covered.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 test/fuzz/fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 786612183..93a043afd 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -42,6 +42,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`using interface \{} as type .*`),
 		regexp.MustCompile(`reflect.Value.MapIndex: value of type .* is not assignable to type .*`),
 		regexp.MustCompile(`reflect: Call using .* as type .*`),
+		regexp.MustCompile(`reflect: cannot use .* as type .* in .*`),
 		regexp.MustCompile(`reflect: Call with too few input arguments`),
 		regexp.MustCompile(`invalid number of arguments`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Call on .* Value`),

From 2aaa9aa0612a0109098db39175a14563c44d8a62 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Thu, 5 Feb 2026 08:25:02 +0200
Subject: [PATCH 493/506] fix(checker): detect $env() calls at compile time
 (#923)

Previously, expressions like `$env(abs())` would compile without error
and cause a runtime "stack underflow" panic. The checker now validates
that $env cannot be used as a function callee, producing a clear error
message like "map[string]interface {} is not callable".

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 builtin/builtin_test.go | 12 +++---------
 checker/checker.go      |  5 +++++
 checker/checker_test.go | 24 ++++++++++++++++++++++++
 vm/vm_test.go           | 38 +++++++++++++++++++++++++++++++-------
 4 files changed, 63 insertions(+), 16 deletions(-)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index b7ad16fdc..8f1644b68 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -300,19 +300,13 @@ func TestBuiltin_errors(t *testing.T) {
 	}
 }
 
-// The get() builtin must return an error when called with
-// insufficient arguments at runtime, even if compile-time checks
-// are bypassed (regression test for OSS-Fuzz #479270603).
-func TestBuiltin_get_runtime_args_check(t *testing.T) {
+func TestBuiltin_env_not_callable(t *testing.T) {
 	code := `$env(''matches'i'?t:get().UTC())`
 	env := map[string]any{"t": 1}
 
-	program, err := expr.Compile(code, expr.Env(env))
-	require.NoError(t, err)
-
-	_, err = expr.Run(program, env)
+	_, err := expr.Compile(code, expr.Env(env))
 	require.Error(t, err)
-	assert.Contains(t, err.Error(), "invalid number of arguments")
+	assert.Contains(t, err.Error(), "is not callable")
 }
 
 func TestBuiltin_types(t *testing.T) {
diff --git a/checker/checker.go b/checker/checker.go
index 23ed1725f..3620f2075 100644
--- a/checker/checker.go
+++ b/checker/checker.go
@@ -651,6 +651,11 @@ func (v *Checker) callNode(node *ast.CallNode) Nature {
 		return *node.Nature()
 	}
 
+	// $env is not callable.
+	if id, ok := node.Callee.(*ast.IdentifierNode); ok && id.Value == "$env" {
+		return v.error(node, "%s is not callable", v.config.Env.String())
+	}
+
 	nt := v.visit(node.Callee)
 	if nt.IsUnknown(&v.config.NtCache) {
 		return Nature{}
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 07047ff5d..7a581612a 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -681,6 +681,30 @@ invalid operation: > (mismatched types string and int) (1:30)
 invalid operation: + (mismatched types int and bool) (1:6)
  | 1; 2 + true; 3
  | .....^
+`,
+		},
+		{
+			`$env()`,
+			`
+mock.Env is not callable (1:1)
+ | $env()
+ | ^
+`,
+		},
+		{
+			`$env(1)`,
+			`
+mock.Env is not callable (1:1)
+ | $env(1)
+ | ^
+`,
+		},
+		{
+			`$env(abs())`,
+			`
+mock.Env is not callable (1:1)
+ | $env(abs())
+ | ^
 `,
 		},
 	}
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 6963803ed..a9b096973 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -1512,20 +1512,44 @@ func TestVM_StackUnderflow(t *testing.T) {
 	}
 }
 
-func TestVM_OpCall_InvalidNumberOfArguments(t *testing.T) {
-	// This test ensures that calling a function with wrong number of arguments
-	// produces a clear error message instead of a panic.
-	// Regression test for clusterfuzz issue with expression:
-	// $env(''matches'  '? :now().UTC(g).d)//
-
+func TestVM_EnvNotCallable(t *testing.T) {
+	// $env is the environment, not a function.
 	env := map[string]any{
 		"ok": true,
 	}
 
 	code := `$env('' matches ' '? : now().UTC(g))`
-	program, err := expr.Compile(code, expr.Env(env))
+	_, err := expr.Compile(code, expr.Env(env))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "is not callable")
+}
+
+func TestVM_OpCall_InvalidNumberOfArguments(t *testing.T) {
+	// Test that the VM validates argument count at runtime.
+	// Compile without Env() so compiler generates OpCall without type info.
+	program, err := expr.Compile(`fn(1, 2)`)
 	require.NoError(t, err)
 
+	// Run with a function that has different arity
+	env := map[string]any{
+		"fn": func(a int) int { return a },
+	}
+
+	_, err = expr.Run(program, env)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "invalid number of arguments")
+}
+
+func TestVM_OpCall_InvalidNumberOfArguments_Variadic(t *testing.T) {
+	// Test variadic function with too few arguments.
+	program, err := expr.Compile(`fn()`)
+	require.NoError(t, err)
+
+	// Run with a variadic function that requires at least 1 argument
+	env := map[string]any{
+		"fn": func(first int, rest ...int) int { return first },
+	}
+
 	_, err = expr.Run(program, env)
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "invalid number of arguments")

From f0176e7ad3ad7467c9b6a11af930a9512d50edc7 Mon Sep 17 00:00:00 2001
From: Ashish Bagri <ashishbagri@gmail.com>
Date: Thu, 12 Feb 2026 15:51:26 +0100
Subject: [PATCH 494/506] Update README.md: Added GlassFlow.dev in the list of
 companies using expr (#927)

Added GlassFlow.dev in the list of companies using expr

Signed-off-by: Ashish Bagri <ashishbagri@gmail.com>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 8a12f6af9..fed955d7b 100644
--- a/README.md
+++ b/README.md
@@ -170,6 +170,7 @@ func main() {
 * [WunderGraph Cosmo](https://github.com/wundergraph/cosmo) - GraphQL Federeration Router uses Expr to customize Middleware behaviour
 * [SOLO](https://solo.one) uses Expr interally to allow dynamic code execution with custom defined functions.
 * [Naoma.AI](https://www.naoma.ai) uses Expr as a part of its call scoring engine.
+* [GlassFlow.dev](https://github.com/glassflow/clickhouse-etl) uses Expr to do realtime data transformation in ETL pipelines
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From 391930f25cf8a6208beb2eefe5b6f9b4a3e22a2d Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sat, 14 Feb 2026 12:24:18 +0200
Subject: [PATCH 495/506] chore(ci): add Go 1.26 to test matrix (#929)

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 .github/workflows/build.yml | 2 +-
 .github/workflows/test.yml  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index ebebf13e8..6ea93e074 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.22', '1.24', '1.25' ]
+        go-versions: [ '1.18', '1.22', '1.24', '1.25', '1.26' ]
         go-arch: [ '386' ]
     steps:
       - uses: actions/checkout@v3
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index ae2280d3a..90783a6ce 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22', '1.23', '1.24', '1.25' ]
+        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22', '1.23', '1.24', '1.25', '1.26' ]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Go ${{ matrix.go-version }}

From 75a31bc266b3def5e97c30f3f513e96f43341f28 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sat, 14 Feb 2026 12:29:31 +0200
Subject: [PATCH 496/506] fix(fuzz): skip json unsupported type errors (#928)

Add skip pattern for json.UnsupportedTypeError in fuzz
test. The toJSON() builtin returns this error when given
non-serializable types like functions (e.g. toJSON(score)).

The existing skip list only covered json: unsupported value
(for NaN/Inf) but not json: unsupported type (for func,
chan, complex types).

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 test/fuzz/fuzz_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 93a043afd..9616b1ea4 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -36,6 +36,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`unknown time zone`),
 		regexp.MustCompile(`invalid location name`),
 		regexp.MustCompile(`json: unsupported value`),
+		regexp.MustCompile(`json: unsupported type`),
 		regexp.MustCompile(`json: cannot unmarshal .* into Go value of type .*`),
 		regexp.MustCompile(`unexpected end of JSON input`),
 		regexp.MustCompile(`memory budget exceeded`),

From 552eb1baa42c6d65a9de22f65b2922fdc145541f Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 14 Feb 2026 13:10:23 +0100
Subject: [PATCH 497/506] Disable check for missing predicate during parseing

As we may not have env/fn override for disabled builtin just yet. For example, during expr.Run, or compile without expr.Env.
---
 parser/parser.go | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/parser/parser.go b/parser/parser.go
index a0c6d4491..9e24a71e4 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -575,10 +575,7 @@ func (p *Parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 	}
 	isOverridden = isOverridden && checkOverrides
 
-	if _, ok := predicates[token.Value]; ok && p.config != nil && p.config.Disabled[token.Value] && !isOverridden {
-		// Disabled predicate without replacement - fail immediately
-		p.error("unknown name %s", token.Value)
-	} else if b, ok := predicates[token.Value]; ok && !isOverridden {
+	if b, ok := predicates[token.Value]; ok && !isOverridden {
 		p.expect(Bracket, "(")
 
 		// In case of the pipe operator, the first argument is the left-hand side
@@ -622,9 +619,6 @@ func (p *Parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 		if node == nil {
 			return nil
 		}
-	} else if _, ok := builtin.Index[token.Value]; ok && p.config != nil && p.config.Disabled[token.Value] && !isOverridden {
-		// Disabled builtin without replacement - fail immediately
-		p.error("unknown name %s", token.Value)
 	} else if _, ok := builtin.Index[token.Value]; ok && (p.config == nil || !p.config.Disabled[token.Value]) && !isOverridden {
 		node = p.createNode(&BuiltinNode{
 			Name:      token.Value,

From 40bda0b3736f9fc5d96c02f970d0ef55748c3ed9 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sat, 14 Feb 2026 13:10:23 +0100
Subject: [PATCH 498/506] Disable check for missing predicate during parseing

As we may not have env/fn override for disabled builtin just yet. For example, during expr.Run, or compile without expr.Env.
---
 test/issues/924/issue_test.go | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 test/issues/924/issue_test.go

diff --git a/test/issues/924/issue_test.go b/test/issues/924/issue_test.go
new file mode 100644
index 000000000..9a953a158
--- /dev/null
+++ b/test/issues/924/issue_test.go
@@ -0,0 +1,23 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue924_allow_disabling_builtins_and_providing_fn_at_runtime(t *testing.T) {
+	// We disable the builtin "upper", but do not env information,
+	// but we can provide a function at runtime.
+	program, err := expr.Compile(`upper(1)`, expr.DisableBuiltin("upper"))
+	require.NoError(t, err)
+
+	env := map[string]any{
+		"upper": func(a int) int { return a },
+	}
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 1, out)
+}

From 94ec86d333889229c4190a0d91fb9b031d02b116 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sat, 14 Feb 2026 14:21:17 +0200
Subject: [PATCH 499/506] fix(patcher): ctx into nested custom funcs and Env
 (#883)

WithContext patcher now looks up function types from the Functions
table and Env methods when the callee type is interface{}. This fixes
context injection for custom functions and Env methods nested as
arguments inside method calls with unknown callee types
(e.g., Now2().After(Date2())).

Also improved the regression test to actually verify context is passed
to both functions, and added a test for Env methods.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 expr.go                       | 11 ++++++--
 patcher/with_context.go       | 25 ++++++++++++++++-
 test/issues/823/issue_test.go | 53 ++++++++++++++++++++++++++++++++---
 3 files changed, 81 insertions(+), 8 deletions(-)

diff --git a/expr.go b/expr.go
index 280605e67..76fbd426f 100644
--- a/expr.go
+++ b/expr.go
@@ -195,9 +195,14 @@ func EnableBuiltin(name string) Option {
 
 // WithContext passes context to all functions calls with a context.Context argument.
 func WithContext(name string) Option {
-	return Patch(patcher.WithContext{
-		Name: name,
-	})
+	return func(c *conf.Config) {
+		c.Visitors = append(c.Visitors, patcher.WithContext{
+			Name:      name,
+			Functions: c.Functions,
+			Env:       &c.Env,
+			NtCache:   &c.NtCache,
+		})
+	}
 }
 
 // Timezone sets default timezone for date() and now() builtin functions.
diff --git a/patcher/with_context.go b/patcher/with_context.go
index f9861a2c2..2043041ba 100644
--- a/patcher/with_context.go
+++ b/patcher/with_context.go
@@ -4,11 +4,16 @@ import (
 	"reflect"
 
 	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/checker/nature"
+	"github.com/expr-lang/expr/conf"
 )
 
 // WithContext adds WithContext.Name argument to all functions calls with a context.Context argument.
 type WithContext struct {
-	Name string
+	Name      string
+	Functions conf.FunctionsTable // Optional: used to look up function types when callee type is unknown.
+	Env       *nature.Nature      // Optional: used to look up method types when callee type is unknown.
+	NtCache   *nature.Cache       // Optional: cache for nature lookups.
 }
 
 // Visit adds WithContext.Name argument to all functions calls with a context.Context argument.
@@ -19,6 +24,24 @@ func (w WithContext) Visit(node *ast.Node) {
 		if fn == nil {
 			return
 		}
+		// If callee type is interface{} (unknown), look up the function type from
+		// the Functions table or Env. This handles cases where the checker returns early
+		// without visiting nested call arguments (e.g., Date2() in Now2().After(Date2()))
+		// because the outer call's type is unknown due to missing context arguments.
+		if fn.Kind() == reflect.Interface {
+			if ident, ok := call.Callee.(*ast.IdentifierNode); ok {
+				if w.Functions != nil {
+					if f, ok := w.Functions[ident.Value]; ok {
+						fn = f.Type()
+					}
+				}
+				if fn.Kind() == reflect.Interface && w.Env != nil {
+					if m, ok := w.Env.MethodByName(w.NtCache, ident.Value); ok {
+						fn = m.Type
+					}
+				}
+			}
+		}
 		if fn.Kind() != reflect.Func {
 			return
 		}
diff --git a/test/issues/823/issue_test.go b/test/issues/823/issue_test.go
index 672cc1f1f..221267de4 100644
--- a/test/issues/823/issue_test.go
+++ b/test/issues/823/issue_test.go
@@ -2,7 +2,6 @@ package issue_test
 
 import (
 	"context"
-	"fmt"
 	"testing"
 	"time"
 
@@ -14,26 +13,72 @@ type env struct {
 	Ctx context.Context `expr:"ctx"`
 }
 
+// TestIssue823 verifies that WithContext injects context into nested custom
+// function calls. The bug was that date2() nested as an argument to After()
+// didn't receive the context because its callee type was unknown.
 func TestIssue823(t *testing.T) {
+	now2Called := false
+	date2Called := false
+
 	p, err := expr.Compile(
 		"now2().After(date2())",
 		expr.Env(env{}),
 		expr.WithContext("ctx"),
 		expr.Function(
 			"now2",
-			func(params ...any) (any, error) { return time.Now(), nil },
+			func(params ...any) (any, error) {
+				require.Len(t, params, 1, "now2 should receive context")
+				_, ok := params[0].(context.Context)
+				require.True(t, ok, "now2 first param should be context.Context")
+				now2Called = true
+				return time.Now(), nil
+			},
 			new(func(context.Context) time.Time),
 		),
 		expr.Function(
 			"date2",
-			func(params ...any) (any, error) { return time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), nil },
+			func(params ...any) (any, error) {
+				require.Len(t, params, 1, "date2 should receive context")
+				_, ok := params[0].(context.Context)
+				require.True(t, ok, "date2 first param should be context.Context")
+				date2Called = true
+				return time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), nil
+			},
 			new(func(context.Context) time.Time),
 		),
 	)
-	fmt.Printf("Compile result err: %v\n", err)
 	require.NoError(t, err)
 
 	r, err := expr.Run(p, &env{Ctx: context.Background()})
 	require.NoError(t, err)
 	require.True(t, r.(bool))
+	require.True(t, now2Called, "now2 should have been called")
+	require.True(t, date2Called, "date2 should have been called")
+}
+
+// envWithMethods tests that Env methods with context.Context work correctly
+// when nested in method chains (similar to TestIssue823 but with Env methods).
+type envWithMethods struct {
+	Ctx context.Context `expr:"ctx"`
+}
+
+func (e *envWithMethods) Now2(ctx context.Context) time.Time {
+	return time.Now()
+}
+
+func (e *envWithMethods) Date2(ctx context.Context) time.Time {
+	return time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
+}
+
+func TestIssue823_EnvMethods(t *testing.T) {
+	p, err := expr.Compile(
+		"Now2().After(Date2())",
+		expr.Env(&envWithMethods{}),
+		expr.WithContext("ctx"),
+	)
+	require.NoError(t, err)
+
+	r, err := expr.Run(p, &envWithMethods{Ctx: context.Background()})
+	require.NoError(t, err)
+	require.True(t, r.(bool))
 }

From 3461fbb4c2feacd83414ff6e782835259eedb232 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sat, 14 Feb 2026 14:25:40 +0200
Subject: [PATCH 500/506] perf(vm): optimize loop iteration with scope pool
 (#908)

Iteration over slices previously used reflection to access elements,
which was slow and allocated unnecessarily. This change adds
type-specialized fast paths for common slice types ([]int, []float64,
[]string, []any) that bypass reflection entirely. Scope objects are
now pooled and reused across loop iterations. The current scope
pointer is cached to avoid repeated slice lookups.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
Co-authored-by: Anton Medvedev <anton@medv.io>
---
 vm/utils.go |  22 ++++++++++++
 vm/vm.go    | 100 ++++++++++++++++++++++++++++++++++++----------------
 2 files changed, 91 insertions(+), 31 deletions(-)

diff --git a/vm/utils.go b/vm/utils.go
index 11005137c..7f1ca1e89 100644
--- a/vm/utils.go
+++ b/vm/utils.go
@@ -20,6 +20,28 @@ type Scope struct {
 	Len   int
 	Count int
 	Acc   any
+	// Fast paths
+	Ints    []int
+	Floats  []float64
+	Strings []string
+	Anys    []any
+}
+
+// Item returns the current element from the scope using fast paths when available.
+func (s *Scope) Item() any {
+	if s.Ints != nil {
+		return s.Ints[s.Index]
+	}
+	if s.Floats != nil {
+		return s.Floats[s.Index]
+	}
+	if s.Strings != nil {
+		return s.Strings[s.Index]
+	}
+	if s.Anys != nil {
+		return s.Anys[s.Index]
+	}
+	return s.Array.Index(s.Index).Interface()
 }
 
 type groupBy = map[any][]any
diff --git a/vm/vm.go b/vm/vm.go
index 887825413..29ceb51f7 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -46,6 +46,9 @@ type VM struct {
 	debug        bool
 	step         chan struct{}
 	curr         chan int
+	scopePool    []Scope // Pre-allocated pool of Scope values; grows as needed but never shrinks
+	scopePoolIdx int     // Current index into scopePool for allocation
+	currScope    *Scope  // Cached pointer to the current scope (optimization)
 }
 
 func (vm *VM) Run(program *Program, env any) (_ any, err error) {
@@ -76,6 +79,8 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		clearSlice(vm.Scopes)
 		vm.Scopes = vm.Scopes[0:0]
 	}
+	vm.scopePoolIdx = 0 // Reset pool index for reuse
+	vm.currScope = nil
 	if len(vm.Variables) < program.variables {
 		vm.Variables = make([]any, program.variables)
 	}
@@ -221,8 +226,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			if arg < 0 {
 				panic("negative jump offset is invalid")
 			}
-			scope := vm.scope()
-			if scope.Index >= scope.Len {
+			if vm.currScope.Index >= vm.currScope.Len {
 				vm.ip += arg
 			}
 
@@ -511,40 +515,34 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			vm.push(deref.Interface(a))
 
 		case OpIncrementIndex:
-			vm.scope().Index++
+			vm.currScope.Index++
 
 		case OpDecrementIndex:
-			scope := vm.scope()
-			scope.Index--
+			vm.currScope.Index--
 
 		case OpIncrementCount:
-			scope := vm.scope()
-			scope.Count++
+			vm.currScope.Count++
 
 		case OpGetIndex:
-			vm.push(vm.scope().Index)
+			vm.push(vm.currScope.Index)
 
 		case OpGetCount:
-			scope := vm.scope()
-			vm.push(scope.Count)
+			vm.push(vm.currScope.Count)
 
 		case OpGetLen:
-			scope := vm.scope()
-			vm.push(scope.Len)
+			vm.push(vm.currScope.Len)
 
 		case OpGetAcc:
-			vm.push(vm.scope().Acc)
+			vm.push(vm.currScope.Acc)
 
 		case OpSetAcc:
-			vm.scope().Acc = vm.pop()
+			vm.currScope.Acc = vm.pop()
 
 		case OpSetIndex:
-			scope := vm.scope()
-			scope.Index = vm.pop().(int)
+			vm.currScope.Index = vm.pop().(int)
 
 		case OpPointer:
-			scope := vm.scope()
-			vm.push(scope.Array.Index(scope.Index).Interface())
+			vm.push(vm.currScope.Item())
 
 		case OpThrow:
 			panic(vm.pop().(error))
@@ -554,7 +552,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			case 1:
 				vm.push(make(groupBy))
 			case 2:
-				scope := vm.scope()
+				scope := vm.currScope
 				var desc bool
 				order, ok := vm.pop().(string)
 				if !ok {
@@ -578,21 +576,19 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 			}
 
 		case OpGroupBy:
-			scope := vm.scope()
+			scope := vm.currScope
 			key := vm.pop()
-			item := scope.Array.Index(scope.Index).Interface()
-			scope.Acc.(groupBy)[key] = append(scope.Acc.(groupBy)[key], item)
+			scope.Acc.(groupBy)[key] = append(scope.Acc.(groupBy)[key], scope.Item())
 
 		case OpSortBy:
-			scope := vm.scope()
+			scope := vm.currScope
 			value := vm.pop()
-			item := scope.Array.Index(scope.Index).Interface()
 			sortable := scope.Acc.(*runtime.SortBy)
-			sortable.Array = append(sortable.Array, item)
+			sortable.Array = append(sortable.Array, scope.Item())
 			sortable.Values = append(sortable.Values, value)
 
 		case OpSort:
-			scope := vm.scope()
+			scope := vm.currScope
 			sortable := scope.Acc.(*runtime.SortBy)
 			sort.Sort(sortable)
 			vm.memGrow(uint(scope.Len))
@@ -608,11 +604,26 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 
 		case OpBegin:
 			a := vm.pop()
-			array := reflect.ValueOf(a)
-			vm.Scopes = append(vm.Scopes, &Scope{
-				Array: array,
-				Len:   array.Len(),
-			})
+			s := vm.allocScope()
+			switch v := a.(type) {
+			case []int:
+				s.Ints = v
+				s.Len = len(v)
+			case []float64:
+				s.Floats = v
+				s.Len = len(v)
+			case []string:
+				s.Strings = v
+				s.Len = len(v)
+			case []any:
+				s.Anys = v
+				s.Len = len(v)
+			default:
+				s.Array = reflect.ValueOf(a)
+				s.Len = s.Array.Len()
+			}
+			vm.Scopes = append(vm.Scopes, s)
+			vm.currScope = s
 
 		case OpAnd:
 			a := vm.pop()
@@ -626,6 +637,11 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 
 		case OpEnd:
 			vm.Scopes = vm.Scopes[:len(vm.Scopes)-1]
+			if len(vm.Scopes) > 0 {
+				vm.currScope = vm.Scopes[len(vm.Scopes)-1]
+			} else {
+				vm.currScope = nil
+			}
 
 		default:
 			panic(fmt.Sprintf("unknown bytecode %#x", op))
@@ -679,6 +695,28 @@ func (vm *VM) scope() *Scope {
 	return vm.Scopes[len(vm.Scopes)-1]
 }
 
+// allocScope returns a pointer to a Scope from the pool, growing the pool if needed.
+// Callers must set Len and exactly one of: Ints, Floats, Strings, Anys, or Array.
+func (vm *VM) allocScope() *Scope {
+	if vm.scopePoolIdx >= len(vm.scopePool) {
+		vm.scopePool = append(vm.scopePool, Scope{})
+	}
+	s := &vm.scopePool[vm.scopePoolIdx]
+	vm.scopePoolIdx++
+	// Reset iteration state
+	s.Index = 0
+	s.Count = 0
+	s.Acc = nil
+	// Clear typed slice pointers to avoid stale fast-path matches
+	s.Ints = nil
+	s.Floats = nil
+	s.Strings = nil
+	s.Anys = nil
+	// Clear Array to release reference for GC (only matters for fallback path)
+	s.Array = reflect.Value{}
+	return s
+}
+
 // getArgsForFunc lazily initializes the buffer the first time it is called for
 // a given program (thus, it also needs "program" to run). It will
 // take "needed" elements from the buffer and populate them with vm.pop() in

From 21f4f0575591d7097e576edd7983daf23c1e4afe Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Sat, 14 Feb 2026 14:16:09 +0100
Subject: [PATCH 501/506] Fix impossible unsigned integer comparisons in Abs()
 function (#919)

---
 builtin/builtin_test.go | 33 +++++++++++++++++++++++++++++++++
 builtin/lib.go          | 30 +++++-------------------------
 2 files changed, 38 insertions(+), 25 deletions(-)

diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 8f1644b68..0d0dec357 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -869,3 +869,36 @@ func TestBuiltin_recursion_custom_max_depth(t *testing.T) {
 		require.NoError(t, err)
 	})
 }
+
+func TestAbs_UnsignedIntegers(t *testing.T) {
+	// Test that abs() correctly handles unsigned integers
+	// Unsigned integers are always non-negative, so abs() should return them unchanged
+	tests := []struct {
+		name  string
+		env   map[string]any
+		expr  string
+		want  any
+	}{
+		{"uint", map[string]any{"x": uint(42)}, "abs(x)", uint(42)},
+		{"uint8", map[string]any{"x": uint8(42)}, "abs(x)", uint8(42)},
+		{"uint16", map[string]any{"x": uint16(42)}, "abs(x)", uint16(42)},
+		{"uint32", map[string]any{"x": uint32(42)}, "abs(x)", uint32(42)},
+		{"uint64", map[string]any{"x": uint64(42)}, "abs(x)", uint64(42)},
+		{"uint zero", map[string]any{"x": uint(0)}, "abs(x)", uint(0)},
+		{"uint8 zero", map[string]any{"x": uint8(0)}, "abs(x)", uint8(0)},
+		{"uint16 zero", map[string]any{"x": uint16(0)}, "abs(x)", uint16(0)},
+		{"uint32 zero", map[string]any{"x": uint32(0)}, "abs(x)", uint32(0)},
+		{"uint64 zero", map[string]any{"x": uint64(0)}, "abs(x)", uint64(0)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr, expr.Env(tt.env))
+			require.NoError(t, err)
+
+			result, err := expr.Run(program, tt.env)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, result)
+		})
+	}
+}
diff --git a/builtin/lib.go b/builtin/lib.go
index 622612cb7..d626f944b 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -102,35 +102,15 @@ func Abs(x any) any {
 			return x
 		}
 	case uint:
-		if x < 0 {
-			return -x
-		} else {
-			return x
-		}
+		return x
 	case uint8:
-		if x < 0 {
-			return -x
-		} else {
-			return x
-		}
+		return x
 	case uint16:
-		if x < 0 {
-			return -x
-		} else {
-			return x
-		}
+		return x
 	case uint32:
-		if x < 0 {
-			return -x
-		} else {
-			return x
-		}
+		return x
 	case uint64:
-		if x < 0 {
-			return -x
-		} else {
-			return x
-		}
+		return x
 	}
 	panic(fmt.Sprintf("invalid argument for abs (type %T)", x))
 }

From 3abfc80cdbc5994930ac77d66ae4e9bac153e5c6 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Wed, 18 Feb 2026 14:50:51 +0200
Subject: [PATCH 502/506] fix: wrap LoadLocation error in date() builtin (#931)

When date() is called with an invalid timezone string like ".",
time.LoadLocation can return raw OS-level errors such as
"is a directory". Replace the raw error with a consistent
"unknown time zone" message to improve error clarity and match
the fuzz test's known-error skip patterns.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 builtin/builtin.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/builtin/builtin.go b/builtin/builtin.go
index 78b55be6d..87e73614a 100644
--- a/builtin/builtin.go
+++ b/builtin/builtin.go
@@ -530,7 +530,7 @@ var Builtins = []*Function{
 				timeZone := args[2].(string)
 				tz, err := time.LoadLocation(timeZone)
 				if err != nil {
-					return nil, err
+					return nil, fmt.Errorf("unknown time zone %s", timeZone)
 				}
 				t, err := time.ParseInLocation(layout, date, tz)
 				if err != nil {

From 27acc2dd45bb2e91dcadadd947354f812fa5c776 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Mon, 23 Feb 2026 12:05:44 +0200
Subject: [PATCH 503/506] fix: reject unexported struct fields at runtime
 (#935)

When the type checker cannot determine a concrete struct type at
compile time (e.g. ternary with mixed types), field access
falls through to dynamic OpFetch at runtime. The Fetch function
in vm/runtime and the get function in builtin/lib used
FieldByNameFunc which matched unexported fields, then called
Interface() on the resulting reflect.Value, causing a reflect
error.

Add IsExported() guards after FieldByNameFunc in both Fetch()
and get() so unexported fields are never accessed via
reflection.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 builtin/lib.go                | 14 +++++----
 test/issues/934/issue_test.go | 53 +++++++++++++++++++++++++++++++++++
 vm/runtime/runtime.go         |  2 +-
 3 files changed, 63 insertions(+), 6 deletions(-)
 create mode 100644 test/issues/934/issue_test.go

diff --git a/builtin/lib.go b/builtin/lib.go
index d626f944b..61748da08 100644
--- a/builtin/lib.go
+++ b/builtin/lib.go
@@ -596,9 +596,10 @@ func get(params ...any) (out any, err error) {
 
 	case reflect.Struct:
 		fieldName := i.(string)
-		value := v.FieldByNameFunc(func(name string) bool {
-			field, _ := v.Type().FieldByName(name)
-			switch field.Tag.Get("expr") {
+		t := v.Type()
+		field, ok := t.FieldByNameFunc(func(name string) bool {
+			f, _ := t.FieldByName(name)
+			switch f.Tag.Get("expr") {
 			case "-":
 				return false
 			case fieldName:
@@ -607,8 +608,11 @@ func get(params ...any) (out any, err error) {
 				return name == fieldName
 			}
 		})
-		if value.IsValid() {
-			return value.Interface(), nil
+		if ok && field.IsExported() {
+			value := v.FieldByIndex(field.Index)
+			if value.IsValid() {
+				return value.Interface(), nil
+			}
 		}
 	}
 
diff --git a/test/issues/934/issue_test.go b/test/issues/934/issue_test.go
new file mode 100644
index 000000000..15ac26276
--- /dev/null
+++ b/test/issues/934/issue_test.go
@@ -0,0 +1,53 @@
+package issue934
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+type Env struct {
+	Exported
+	unexported
+}
+
+type Exported struct {
+	Str string
+	str string
+}
+
+type unexported struct {
+	Integer int
+	integer int
+}
+
+// TestIssue934 tests that accessing unexported fields on values whose type
+// is unknown at compile time (e.g., from a ternary with mixed types) yields
+// a descriptive error.
+//
+// OSS-Fuzz issue #486370271.
+func TestIssue934(t *testing.T) {
+	env := map[string]any{
+		"v": Env{},
+	}
+
+	// Accessing unexported fields like time.Time.loc
+        // should produce a proper error.
+	_, err := expr.Eval(`(true ? v : "string").str`, env)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "cannot fetch str")
+
+	// Exported field access should still work.
+	_, err = expr.Eval(`(true ? v : "string").Str`, env)
+	require.NoError(t, err)
+
+	// Access unexported field inherited from unexported embedded struct.
+	_, err = expr.Eval(`(true ? v : "string").integer`, env)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "cannot fetch integer")
+
+	// Access exported field inherited from unexported embedded struct should work.
+	_, err = expr.Eval(`(true ? v : "string").Integer`, env)
+	require.NoError(t, err)
+}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index d24c6af03..bc6f2b4df 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -90,7 +90,7 @@ func Fetch(from, i any) any {
 				return name == fieldName
 			}
 		})
-		if ok {
+		if ok && field.IsExported() {
 			value := v.FieldByIndex(field.Index)
 			if value.IsValid() {
 				fieldCache.Store(key, field.Index)

From 851b241a301f7c74646e65e4009c69cf290993a8 Mon Sep 17 00:00:00 2001
From: Ville Vesilehto <ville@vesilehto.fi>
Date: Sat, 28 Feb 2026 12:02:43 +0200
Subject: [PATCH 504/506] fix(vm): handle non-comparable groupBy keys (#940)

Check that the groupBy predicate result is comparable before
using it as a map key. Previously, a non-comparable type such
as a slice would cause a raw Go runtime panic. Now it produces
a clear error message instead.

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>
---
 test/fuzz/fuzz_test.go | 1 +
 vm/vm.go               | 3 +++
 vm/vm_test.go          | 5 +++++
 3 files changed, 9 insertions(+)

diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
index 9616b1ea4..e12c4d8ec 100644
--- a/test/fuzz/fuzz_test.go
+++ b/test/fuzz/fuzz_test.go
@@ -65,6 +65,7 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`sortBy order argument must be a string`),
 		regexp.MustCompile(`invalid order .*, expected asc or desc`),
 		regexp.MustCompile(`unknown order, use asc or desc`),
+		regexp.MustCompile(`cannot use .* as a key for groupBy: type is not comparable`),
 	}
 
 	env := NewEnv()
diff --git a/vm/vm.go b/vm/vm.go
index 29ceb51f7..ba3b53863 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -578,6 +578,9 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 		case OpGroupBy:
 			scope := vm.currScope
 			key := vm.pop()
+			if key != nil && !reflect.TypeOf(key).Comparable() {
+				panic(fmt.Sprintf("cannot use %T as a key for groupBy: type is not comparable", key))
+			}
 			scope.Acc.(groupBy)[key] = append(scope.Acc.(groupBy)[key], scope.Item())
 
 		case OpSortBy:
diff --git a/vm/vm_test.go b/vm/vm_test.go
index a9b096973..c86183cad 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -487,6 +487,11 @@ func TestVM_GroupAndSortOperations(t *testing.T) {
 				"odd":  {1, 3, 5},
 			},
 		},
+		{
+			name:        "group by with non-comparable key",
+			expr:        `groupBy([1, 2, 3], [#, # + 1])`, // predicate returns a slice, which is not comparable
+			expectError: "not comparable",
+		},
 		{
 			name:        "invalid sort order",
 			expr:        `sortBy([1, 2, 3], #, "invalid")`,

From b90e77c64fb9ba94587b4284da4bb2cf28aae9db Mon Sep 17 00:00:00 2001
From: Jesse Suen <jessesuen@users.noreply.github.com>
Date: Fri, 13 Mar 2026 02:56:59 -0700
Subject: [PATCH 505/506] docs: add Kargo's usage of expr (#944)

Signed-off-by: Jesse Suen <jesse@akuity.io>
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index fed955d7b..b6ea22713 100644
--- a/README.md
+++ b/README.md
@@ -171,6 +171,7 @@ func main() {
 * [SOLO](https://solo.one) uses Expr interally to allow dynamic code execution with custom defined functions.
 * [Naoma.AI](https://www.naoma.ai) uses Expr as a part of its call scoring engine.
 * [GlassFlow.dev](https://github.com/glassflow/clickhouse-etl) uses Expr to do realtime data transformation in ETL pipelines
+* [Kargo](https://kargo.io/) uses Expr to evaluate and manipulate variables dynamically during [promotion steps](https://docs.kargo.io/user-guide/reference-docs/expressions/)
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

From 3a46b1970b37df26cd2d929ecfe8d12d7fc2ccf7 Mon Sep 17 00:00:00 2001
From: chaoliang yan <z5643222@ad.unsw.edu.au>
Date: Mon, 13 Apr 2026 00:40:15 +1000
Subject: [PATCH 506/506] fix(compiler): pop stale bool from stack in
 emitLoopBackwards (#954)

emitLoopBackwards uses OpMoreOrEqual + OpJumpIfFalse to check the loop
condition, but never pops the comparison result from the stack. This
leaves a stale bool that corrupts the value stack for the parent context.

When findLast or findLastIndex is used inside a map literal like
{"r": findLast([1, 2, 3], # > 3)}, the OpMap opcode tries to pop a
string key but finds the leftover bool instead, causing:
  interface conversion: interface {} is bool, not string

The forward-iterating emitLoop avoids this by using OpJumpIfEnd, which
checks scope.Index directly without touching the stack.

Fix: add OpPop after OpJumpIfFalse (continue path) and after patchJump
(exit path), matching the convention used by emitCond and every other
OpJumpIfFalse callsite in the compiler.

Fixes #950

Co-authored-by: lawrence3699 <lawrence3699@users.noreply.github.com>
---
 compiler/compiler.go |  2 ++
 expr_test.go         | 16 ++++++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/compiler/compiler.go b/compiler/compiler.go
index f66cf9ed8..685175350 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -1213,12 +1213,14 @@ func (c *compiler) emitLoopBackwards(body func()) {
 	c.emit(OpInt, 0)
 	c.emit(OpMoreOrEqual)
 	end := c.emit(OpJumpIfFalse, placeholder)
+	c.emit(OpPop)
 
 	body()
 
 	c.emit(OpDecrementIndex)
 	c.emit(OpJumpBackward, c.calcBackwardJump(begin))
 	c.patchJump(end)
+	c.emit(OpPop)
 }
 
 func (c *compiler) PredicateNode(node *ast.PredicateNode) {
diff --git a/expr_test.go b/expr_test.go
index 1bce3c8dc..fd1ce3ab7 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1275,6 +1275,22 @@ func TestExpr(t *testing.T) {
 			`findLastIndex(1..9, # % 2 == 0)`,
 			7,
 		},
+		{
+			`{"r": findLast([1, 2, 3, 4, 5], # > 3)}`,
+			map[string]any{"r": 5},
+		},
+		{
+			`{"r": findLastIndex([1, 2, 3, 4, 5], # > 3)}`,
+			map[string]any{"r": 4},
+		},
+		{
+			`{"r": findLast([1, 2, 3], # > 10)}`,
+			map[string]any{"r": nil},
+		},
+		{
+			`{"a": findLast([1, 2, 3], # > 1), "b": findLastIndex([4, 5, 6], # > 4)}`,
+			map[string]any{"a": 3, "b": 2},
+		},
 		{
 			`filter(1..9, # % 2 == 0)[-1]`,
 			8,